diff --git a/quest/m2/ts-model/README.md b/quest/m2/ts-model/README.md index e1cebbcff..09ecd98a0 100644 --- a/quest/m2/ts-model/README.md +++ b/quest/m2/ts-model/README.md @@ -18,7 +18,7 @@ read into a group, to the benchmark's workloads, which hold only its sync frame codec's WASM route stays in the benchmark as the baseline of compiled Rust in a browser. The codec's differential harness is the pattern to repeat. The shared npm runtime -(for checked integer ops and the rest of `rt.ts`) is published only once two +(for checked integer ops and the rest of `rs.ts`) is published only once two generated packages need it. Decided with the maintainer on 2026-10-23, for the subset: `u128` stays, on the diff --git a/quest/m3/README.md b/quest/m3/README.md index 23ab26216..844b43024 100644 --- a/quest/m3/README.md +++ b/quest/m3/README.md @@ -13,7 +13,6 @@ generic std gap is planned here even when moq never calls it. ## Required -- [The runtime's namespace is rs](/quest/m3/ts-rs-rename.md) - translated code and hand-written callers import the runtime as `rs`, not `rt` - [Retrial Cranelift on moq's tests](/quest/m3/cranelift-unwind.md) - waits on upstream: moq's tests pass under Cranelift, so its CI can weigh it again - [Relink without rebuilding](/quest/m3/relink.md) - measure upstream's skip of dependency-only rebuilds on moq's edits once it reaches nightly - [Unsafe code the translator can model](/quest/m3/ts-unsafe.md) - a dependency using only `unsafe` the translator can model translates from source diff --git a/quest/m3/ts-chunk-mut.md b/quest/m3/ts-chunk-mut.md index 843d42b36..3907a8f89 100644 --- a/quest/m3/ts-chunk-mut.md +++ b/quest/m3/ts-chunk-mut.md @@ -9,9 +9,9 @@ against native Rust. ## Plan -`spare_capacity_mut` is an `rt.ByteSlice` of the storage past the length, and +`spare_capacity_mut` is an `rs.ByteSlice` of the storage past the length, and `advance_mut` maps. An `UninitSlice` is `#[repr(transparent)]` over `[MaybeUninit]`, -so it can be the same `rt.ByteSlice`; `chunk_mut` reserves 64 bytes where there is no +so it can be the same `rs.ByteSlice`; `chunk_mut` reserves 64 bytes where there is no room, as the runtime's `bytesMutRoom` and `byteVecRoom` already model. A generic `B: BufMut`, the crate's own included, reaches it, as it is a required method. moq calls neither. diff --git a/quest/m3/ts-dyn.md b/quest/m3/ts-dyn.md index bb7ba5a7f..6634f4740 100644 --- a/quest/m3/ts-dyn.md +++ b/quest/m3/ts-dyn.md @@ -14,8 +14,8 @@ config, so trait objects move from never to not yet. - `dyn Debug` and `dyn Display` translate as functions writing their value, behind `&`, `&mut`, `Box`, `Arc`, and `Rc`, `dyn Future` - as an `rt.Future`, `dyn Any` as the class a downcast checks for, `dyn Fn*` as the - closure itself, `dyn Iterator` and its subtraits as an `rt.Iter`, behind `&`, `&mut`, + as an `rs.Future`, `dyn Any` as the class a downcast checks for, `dyn Fn*` as the + closure itself, `dyn Iterator` and its subtraits as an `rs.Iter`, behind `&`, `&mut`, `Box`, `Arc`, and `Rc`, and the translated crates' traits as an object with the trait's methods. Build the rest on those. - `dyn Error` translates as an object of `source`, `Debug`, and `Display`, whose downcasts diff --git a/quest/m3/ts-rs-rename.md b/quest/m3/ts-rs-rename.md deleted file mode 100644 index 35ec2d3b5..000000000 --- a/quest/m3/ts-rs-rename.md +++ /dev/null @@ -1,21 +0,0 @@ -# [S] The runtime's namespace is rs - -## Goal - -[rust2-ts](/ts/README.md)'s runtime is imported and named `rs` rather than `rt`, in the -translator's output, the runtime's own files, the fixtures and their snapshots, the tests, -and the README, so a translated Rust type reads as `rs.Vec`, `rs.HashMap`, `rs.u64`. -Nothing named `rt` is left. - -## Plan - -Decided with the maintainer on 2026-11-03: rename, as its own PR, started next. The -wrapper quests ([rs.String](/quest/m3/ts-string-capacity.md), -[rs.Slice](/quest/m3/ts-slice-object.md)) run in parallel rather than waiting on it; -whichever lands second merges the rename. - -It touches every open TS PR, so land it when few are in flight and merge main into -them rather than leaving them to conflict. It's mechanical: the snapshots change by name -only, and the bundles should differ by nothing but the name. - -Public API: the translator's output and every hand-written import of the runtime. diff --git a/quest/m3/ts-slice-object.md b/quest/m3/ts-slice-object.md index cb5e72a16..84f6b0c82 100644 --- a/quest/m3/ts-slice-object.md +++ b/quest/m3/ts-slice-object.md @@ -71,11 +71,10 @@ whole write. Noting the origin costs, per shared part of 8 of 16 values, in ns: | the origin as a symbol property | 27.4 | 30.6 | | the origin in a `WeakMap` | 410 | 116 | -The object carries the array and start, and compares by them as `rt.ByteSlice` does. +The object carries the array and start, and compares by them as `rs.ByteSlice` does. Public API: the translator's output and what a hand-written caller passes for a slice. ## Related -- [The runtime's namespace is rs](/quest/m3/ts-rs-rename.md) - runs in parallel - [rs.String](/quest/m3/ts-string-capacity.md) - the other native mapping becoming a wrapper diff --git a/quest/m3/ts-string-capacity.md b/quest/m3/ts-string-capacity.md index 50ac6e8f6..638839636 100644 --- a/quest/m3/ts-string-capacity.md +++ b/quest/m3/ts-string-capacity.md @@ -40,5 +40,4 @@ Public API: the translator's output and what a hand-written caller passes for a ## Related -- [The runtime's namespace is rs](/quest/m3/ts-rs-rename.md) - runs in parallel - [rs.Slice](/quest/m3/ts-slice-object.md) - the other native mapping becoming a wrapper diff --git a/quest/m3/ts-uninit-slices.md b/quest/m3/ts-uninit-slices.md index 74a7aa4f3..6e0af7aed 100644 --- a/quest/m3/ts-uninit-slices.md +++ b/quest/m3/ts-uninit-slices.md @@ -9,7 +9,7 @@ differential tests against native Rust. ## Plan A `MaybeUninit` is a `T` in JS, and one of a byte is the byte, so a `[MaybeUninit]` -is an `rt.ByteSlice`; `write_copy_of_slice` and a slice's `assume_init_ref` and +is an `rs.ByteSlice`; `write_copy_of_slice` and a slice's `assume_init_ref` and `assume_init_mut` already map. `write_clone_of_slice` clones in without dropping what was there, unlike `clone_from_slice`. Found translating `spare_capacity_mut`; no consumer calls either yet. diff --git a/quest/m3/ts-unsafe.md b/quest/m3/ts-unsafe.md index 8cb10fdf5..889c4408c 100644 --- a/quest/m3/ts-unsafe.md +++ b/quest/m3/ts-unsafe.md @@ -15,7 +15,7 @@ the consumer [at first](/ts/README.md#bindings), and moq gives its own `unsafe` annotations or config; this quest is what retires them. Decided with the maintainer on 2026-10-28, typed pointers: a raw pointer is what its -reference is, the object, an `rt.Place`, or `rt.NULL`, and a pointer into a slice or `Vec` +reference is, the object, an `rs.Place`, or `rs.NULL`, and a pointer into a slice or `Vec` is `{ array, index }`. Byte reinterpretation, pointer-to-integer casts, and raw allocation are refused with a span. [#201](https://github.com/moq-dev/rust2/pull/201) landed `Box` to raw and back, `NonNull`, `MaybeUninit`, raw reads and writes, `get_unchecked`, and @@ -25,7 +25,7 @@ none of its own `unsafe`. - An `unsafe` operation outside the modeled set is refused with its span, as today. - Undefined behavior in Rust need not be reproduced, but a translated program never silently differs from native where Rust's behavior is defined. -- Element pointers into arrays of values JS copies are `rt.AtIndex`, `{ array, index }`, +- Element pointers into arrays of values JS copies are `rs.AtIndex`, `{ array, index }`, which `add`, `offset`, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` act on. Decided with the maintainer on 2026-11-01: where one body shows a pointer crossing what JS keeps apart (a value in no array, a copied shared subslice), translation refuses it @@ -38,7 +38,7 @@ none of its own `unsafe`. is a fresh JS array of `T`s, which `realloc` copies and `dealloc` frees. Untyped and byte allocation stay refused. smallvec spills to it, and `Vec::from_raw_parts` of it is left. -- Decided with the maintainer on 2026-11-02: a raw slice pointer is `rt.RawSlice`, its +- Decided with the maintainer on 2026-11-02: a raw slice pointer is `rs.RawSlice`, its first element's pointer and its length, read through only where Rust reads, and an empty slice from a pointer into no array keeps that pointer through every part of it. - A union over a type parameter, whose layout has no fixed offsets until an instance @@ -68,14 +68,14 @@ none of its own `unsafe`. defines it, but a debug build aborts on a violated precondition where the checked form panics with another message. - `BinaryHeap` and `PeekMut` translate from std's MIR, whose `Hole` moves elements - through raw pointers into the `Vec`'s storage, replacing `rt.BinaryHeap` and - `rt.PeekMut`, the hand-written port of std's sifts that + through raw pointers into the `Vec`'s storage, replacing `rs.BinaryHeap` and + `rs.PeekMut`, the hand-written port of std's sifts that [#252](https://github.com/moq-dev/rust2/pull/252) mapped them to and that must track std's by hand. The lang fixture's `orders` differential case proves the translation still matches std's comparisons, pop order, and drops. - `Vec::drain` translates from std's MIR, whose `Drain` reads its range out and moves the - tail back through raw pointers into the `Vec`'s storage, replacing `rt.vecDrain` and - `rt.byteVecDrain`, the runtime port that + tail back through raw pointers into the `Vec`'s storage, replacing `rs.vecDrain` and + `rs.byteVecDrain`, the runtime port that [the slice gaps' PR](https://github.com/moq-dev/rust2/pull/259) mapped it to. The lang fixture's `slices::drains` differential case proves the translation still matches std's items, drops, and what a forgotten drain leaves. diff --git a/ts/README.md b/ts/README.md index 66c67677d..23f437d3c 100644 --- a/ts/README.md +++ b/ts/README.md @@ -76,10 +76,10 @@ publishes their tables. Each Rust module with translated items becomes a file (`lib.ts`, `coding/varint.ts`), and each type a module of its own beside it, holding the type and its functions (`coding/decode.Decoder.ts`), each with a `.ts.map` source map into the Rust it came -from. `rt.ts` beside them is the -runtime: what std does that JS does not, with iterators in `rt/iter.ts`, `str`'s searches -in `rt/str.ts`, the ASCII methods of `u8`, `char`, `[u8]`, and `str` in `rt/ascii.ts`, `char`'s Unicode classes, case maps, escapes, and encodings, and `str`'s case maps and escapes, in `rt/char.ts`, collections in `rt/collections.ts`, hashing in `rt/hash.ts`, ownership, atomics, and async in -`rt/task.ts`, `f64`'s and `f32`'s methods in `rt/float.ts`, `Duration` in `rt/time.ts`, and `Layout` and memory from `alloc` in `rt/alloc.ts`. What translates from std's own MIR, +from. `rs.ts` beside them is the +runtime: what std does that JS does not, with iterators in `rs/iter.ts`, `str`'s searches +in `rs/str.ts`, the ASCII methods of `u8`, `char`, `[u8]`, and `str` in `rs/ascii.ts`, `char`'s Unicode classes, case maps, escapes, and encodings, and `str`'s case maps and escapes, in `rs/char.ts`, collections in `rs/collections.ts`, hashing in `rs/hash.ts`, ownership, atomics, and async in +`rs/task.ts`, `f64`'s and `f32`'s methods in `rs/float.ts`, `Duration` in `rs/time.ts`, and `Layout` and memory from `alloc` in `rs/alloc.ts`. What translates from std's own MIR, `Option`'s, `Result`'s, and `Poll`'s methods, `==` of std's errors, `==` and ordering of a `Result` and a `Poll`, `cmp::max` and `min`, and the `str::parse` and `from_str_radix` of an integer or a `NonZero` and `bool`'s `str::parse`, goes in a module under its crate's name, as `core/option.ts` holds `map$1cf8u0y`. A dependency's modules go @@ -90,77 +90,77 @@ crate translation reaches is refused, and so are two versions of one crate it re | Rust | TypeScript | | --- | --- | | `bool`, `str`, `String`, `Box` | `boolean`, `string` | -| `char` | `rt.char`: a `number` branded so, its Unicode scalar value | -| `u8`-`u32`, `i8`-`i32`, `usize`, `isize` | `rt.u8` and so on: a `number` branded with its type, checked: overflow panics | -| `u64`, `i64`, `u128`, `i128` | `rt.u64` and so on: a branded `number` while a safe integer, 32-bit limbs past 2^53, checked the same way | +| `char` | `rs.char`: a `number` branded so, its Unicode scalar value | +| `u8`-`u32`, `i8`-`i32`, `usize`, `isize` | `rs.u8` and so on: a `number` branded with its type, checked: overflow panics | +| `u64`, `i64`, `u128`, `i128` | `rs.u64` and so on: a branded `number` while a safe integer, 32-bit limbs past 2^53, checked the same way | | `Wrapping` | the integer, whose operators wrap, and mask a shift's amount to the width, as std's do | | `Saturating` | the integer, whose operators saturate at its bounds, as std's do | -| `f64` | `rt.f64`: a `number` branded so, which is the same IEEE 754 double | -| `f32` | `rt.f32`: a `number` branded so, which a single holds exactly | +| `f64` | `rs.f64`: a `number` branded so, which is the same IEEE 754 double | +| `f32` | `rs.f32`: a `number` branded so, which a single holds exactly | | `()`, `PhantomData`, `PhantomPinned`, `..` | `undefined`, every value equal and hashing nothing; a type parameter only a `PhantomData` holds is `_T` in its struct's interface | | `struct` | a plain object, typed by an interface; a class if it may drop | | `enum` without data | a union of strings: `"Lite01" \| "Lite02"`, or `never` without variants | | `enum` | a union of objects tagged by variant | -| `Option` | `T \| undefined`; `T \| rt.None` where `T` can already be `undefined`, as `()` and `Option` can, so `Option<()>` and `Option>` keep `None` apart from each `Some` | -| `Result` | `rt.Result`: `{ ok: true, value }` or `{ ok: false, error }`; `rt.OK` or `rt.ERR` where the payload is `undefined`, as in `Ok(())` | -| `ControlFlow` | `rt.Result`, `Ok` to continue; what `?` branches on is the value it was applied to, but for a `Poll`'s `Pending` and `Ready(None)`, which continue as `Ok` of themselves | -| tuple, `[T; N]`, `&[T]`, `Box<[T]>` | an array; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rt.ByteSlice` for `&[u8]`, `&[u8; N]`, and `Box<[u8]>` | -| `Vec` | `rt.Vec`: its items, the array `items`, and the capacity std's holds; `rt.vecFrom(items)` makes one of an array with room for exactly them. `rt.ByteVec` of bytes | -| `Cow<[T]>`, `Cow` | `rt.Cow`: the `Vec` it owns, or an `rt.Borrowed` holding the slice it borrows; `rt.ByteCow` for bytes, an `rt.ByteVec` or an `rt.ByteSlice`; `rt.StrCow` for text, the string it owns or an `rt.Borrowed` holding the one it borrows, which `rt.strCowStr` reads | -| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rt.Place`, which for what a box holds is the place holding the box | -| `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rt.ByteSlice` of a `[u8; N]`'s bytes, which compares by the buffer and offset they are at, or an `rt.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rt.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to an array of other values than bytes, which a slice lends as a copy of its own; `rt.NULL` for null and `rt.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rt.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rt.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rt.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rt` class such as `rt.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | +| `Option` | `T \| undefined`; `T \| rs.None` where `T` can already be `undefined`, as `()` and `Option` can, so `Option<()>` and `Option>` keep `None` apart from each `Some` | +| `Result` | `rs.Result`: `{ ok: true, value }` or `{ ok: false, error }`; `rs.OK` or `rs.ERR` where the payload is `undefined`, as in `Ok(())` | +| `ControlFlow` | `rs.Result`, `Ok` to continue; what `?` branches on is the value it was applied to, but for a `Poll`'s `Pending` and `Ready(None)`, which continue as `Ok` of themselves | +| tuple, `[T; N]`, `&[T]`, `Box<[T]>` | an array; for bytes, `u8` or `MaybeUninit`, `Uint8Array` for `[u8; N]`, and `rs.ByteSlice` for `&[u8]`, `&[u8; N]`, and `Box<[u8]>` | +| `Vec` | `rs.Vec`: its items, the array `items`, and the capacity std's holds; `rs.vecFrom(items)` makes one of an array with room for exactly them. `rs.ByteVec` of bytes | +| `Cow<[T]>`, `Cow` | `rs.Cow`: the `Vec` it owns, or an `rs.Borrowed` holding the slice it borrows; `rs.ByteCow` for bytes, an `rs.ByteVec` or an `rs.ByteSlice`; `rs.StrCow` for text, the string it owns or an `rs.Borrowed` holding the one it borrows, which `rs.strCowStr` reads | +| `&T`, `&mut T`, `Box`, `Reverse`, `NonZero`, `AssertUnwindSafe` | the value; a `&mut` to a value JS copies, such as a number, an `Option`, a `String`, or a reference, or to an `Arc`, a `Waker`, or a `LocalKey`, whose copies share what it points at, is an `rs.Place`, which for what a box holds is the place holding the box | +| `*const T`, `*mut T`, `NonNull` | what a `&mut T` is: the object, an `rs.ByteSlice` of a `[u8; N]`'s bytes, which compares by the buffer and offset they are at, or an `rs.Place` to a value JS copies and to a library type such as a `Vec` or an `Arc`, which into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which `add`, `sub`, `offset`, their wrapping forms, `offset_from`, `ptr::copy`, and `slice::from_raw_parts` move, measure, copy between, and view; one to a value in no array is element 0 of an array of one, as in Rust; JS keeps that array, and a shared subslice, which JS copies, apart from what holds it in Rust, so a pointer, slice, or copy the body shows reaching past either, a raw or mutable slice of a byte in no array, and `offset_from` between pointers the body shows JS keeps in different arrays are refused, and through a pointer from elsewhere, such as a field, any of these, or a read or write past the array JS keeps it in, fails at run time; a pointer into an array of values JS keeps as objects is refused, as is comparing pointers to an array of other values than bytes, which a slice lends as a copy of its own; `rs.NULL` for null and `rs.DANGLING` for dangling. A `*const ()` is an identity, such as a waker's data, and `rs.DANGLING_UNIT` when dangling; one to a place of `()` or from a reference to one is refused. A pointer to a value JS keeps as an object cast to one, by `as` or `cast`, is the same object, which `rs.ptrErase` notes the type of, so a cast back to a pointer to another type fails at run time, and null and dangling stay so, dangling at the alignment of the type it was cast from; one to a value JS copies is the same place where an `Arc`'s or `Rc`'s `into_raw` or `as_ptr` gave it, its value's one place, which `rs.arcErase` checks where the body doesn't show it, and refused where the body shows a borrow's, a new place each borrow, as is casting one to a view of bytes, a new one each borrow, or one of no fixed size. A write of a whole object copies into it one object deep, as an assignment through a `&mut` does, the state an `rs` class such as `rs.LazyCell` keeps private included, so a pointer to a part kept as an object, such as a field of a tuple or struct type, is refused wherever the crate may put another object there while a pointer into that memory may still be read, which a write into a fresh allocation, or a variable before any pointer into it is taken, can't, whether by index or through std's iterators over its slots; a read copies what the crate writes into in place | | `MaybeUninit` | `T`: `undefined` until written, `0` for a byte, or an object whose parts kept as objects are there, holding `undefined` | | `ManuallyDrop` | `T`, which nothing drops but its own `drop`; its `Debug`, comparisons, and constants are refused | | `union` | an object of slots named by offset, `at0` and `at8`, each holding the field part kept there; fields must overlap in the same type, or in a non-null pointer and an `Option` of it | -| an iterator | `rt.Iter`, whose adaptors are runtime functions: `rt.iterMap(rt.iterSlice(v), f)` | -| `a..b`, `a..=b` | `rt.Range`, `rt.RangeInclusive`, which are iterators too | -| `a..`, `..b`, `..=b`, `Bound` | `{ start }`, `{ end }`, `{ end, inclusive: true }`; `rt.RangeBound`, a union tagged by variant | -| a range a drain or a B-tree's `range` or `extract_if` takes | itself, or of a type other than std's ranges and a pair of `Bound`s, `rt.boundsOf` of it and its `start_bound` and `end_bound`, which the runtime calls where std's does; one that drops, the parameter of the call `rt.dropAfter` makes, which drops it once the call returns, as std drops it before it does anything JS can see, or of an `extract_if`, which holds it, the parameter of a call that hands its iterator what drops it after its closure | -| `HashMap`, `HashSet`, `BTreeMap`, `BTreeSet`, `VecDeque`, `LinkedList`, `BinaryHeap` | `rt.HashMap` and so on, each a plain object whose functions are the runtime's: `rt.hashGet(map, key)` | -| `PeekMut` | `rt.PeekMut`, the `rt.Place` of a heap's greatest element, which sifts it down as it drops once `DerefMut` lent it | -| `Ordering`, `DefaultHasher`, `RandomState`, `BuildHasherDefault` | `rt.Ordering`, which is `-1`, `0`, or `1`; `rt.Hasher`; `rt.RandomState`, the keys of the `DefaultHasher` it builds, never changed once made; `undefined`, as `PhantomData` is, whose `build_hasher` is `H::default()` | -| `Duration` | `rt.Duration`: `{ secs, nanos }`, std's whole seconds as an `rt.u64` and the nanoseconds past them, never changed once made | -| `Layout`, `alloc::alloc` | `rt.Layout`: `{ size, align }`, never changed once made, checked as std's constructors check it; `alloc` gives an `rt.Block` of its bytes, which a cast of its pointer to `*mut T` the body shows came from `alloc` or `realloc` makes a JS array of `T`s, values JS copies, as an `rt.AtIndex` of its first; a cast back to `*mut u8` only as what `dealloc` or `realloc` takes, which free the array or copy it into a new one; its bytes, read, written, or cast to any other type, are refused, and fail at run time through a pointer from elsewhere | +| an iterator | `rs.Iter`, whose adaptors are runtime functions: `rs.iterMap(rs.iterSlice(v), f)` | +| `a..b`, `a..=b` | `rs.Range`, `rs.RangeInclusive`, which are iterators too | +| `a..`, `..b`, `..=b`, `Bound` | `{ start }`, `{ end }`, `{ end, inclusive: true }`; `rs.RangeBound`, a union tagged by variant | +| a range a drain or a B-tree's `range` or `extract_if` takes | itself, or of a type other than std's ranges and a pair of `Bound`s, `rs.boundsOf` of it and its `start_bound` and `end_bound`, which the runtime calls where std's does; one that drops, the parameter of the call `rs.dropAfter` makes, which drops it once the call returns, as std drops it before it does anything JS can see, or of an `extract_if`, which holds it, the parameter of a call that hands its iterator what drops it after its closure | +| `HashMap`, `HashSet`, `BTreeMap`, `BTreeSet`, `VecDeque`, `LinkedList`, `BinaryHeap` | `rs.HashMap` and so on, each a plain object whose functions are the runtime's: `rs.hashGet(map, key)` | +| `PeekMut` | `rs.PeekMut`, the `rs.Place` of a heap's greatest element, which sifts it down as it drops once `DerefMut` lent it | +| `Ordering`, `DefaultHasher`, `RandomState`, `BuildHasherDefault` | `rs.Ordering`, which is `-1`, `0`, or `1`; `rs.Hasher`; `rs.RandomState`, the keys of the `DefaultHasher` it builds, never changed once made; `undefined`, as `PhantomData` is, whose `build_hasher` is `H::default()` | +| `Duration` | `rs.Duration`: `{ secs, nanos }`, std's whole seconds as an `rs.u64` and the nanoseconds past them, never changed once made | +| `Layout`, `alloc::alloc` | `rs.Layout`: `{ size, align }`, never changed once made, checked as std's constructors check it; `alloc` gives an `rs.Block` of its bytes, which a cast of its pointer to `*mut T` the body shows came from `alloc` or `realloc` makes a JS array of `T`s, values JS copies, as an `rs.AtIndex` of its first; a cast back to `*mut u8` only as what `dealloc` or `realloc` takes, which free the array or copy it into a new one; its bytes, read, written, or cast to any other type, are refused, and fail at run time through a pointer from elsewhere | | closure | an arrow function, with `[Symbol.dispose]` if it owns a value that drops, and what makes its clone if a clone can't be itself | | `fn` pointer, function item as a value | the function, or std's an arrow that calls it as a written call does, as a closure is typed: a `()` result is `undefined`, where a declared function returns `void` | -| `&dyn Trait`, `&mut dyn Trait`, `Box`, `Arc`, `Rc`, `Weak`, `Pin

` of one | an object with the trait's methods, its supertraits' included: `shape.area$Shape()`; behind an `Arc` or an `Rc`, an `rt.ArcDyn` sharing the count of the `Arc` it was made from | -| a pointer to a struct whose last field unsizes to a trait object: `Rc>`, `Arc>`, `Arc>`, `&mut Cell`, `Rc>`, `Arc>`, the crate's own `&Tail` | `rt.tailDyn` of the struct it was made from: the same struct, whose other fields, borrows, and lock are that struct's own, and whose last field is the trait object a `&mut` to that field would be, made where it is read; a `dyn Future`'s polls the one future in place and drops it with the struct. A `ManuallyDrop` is the trait object of what it holds, which a box of it never drops | +| `&dyn Trait`, `&mut dyn Trait`, `Box`, `Arc`, `Rc`, `Weak`, `Pin

` of one | an object with the trait's methods, its supertraits' included: `shape.area$Shape()`; behind an `Arc` or an `Rc`, an `rs.ArcDyn` sharing the count of the `Arc` it was made from | +| a pointer to a struct whose last field unsizes to a trait object: `Rc>`, `Arc>`, `Arc>`, `&mut Cell`, `Rc>`, `Arc>`, the crate's own `&Tail` | `rs.tailDyn` of the struct it was made from: the same struct, whose other fields, borrows, and lock are that struct's own, and whose last field is the trait object a `&mut` to that field would be, made where it is read; a `dyn Future`'s polls the one future in place and drops it with the struct. A `ManuallyDrop` is the trait object of what it holds, which a box of it never drops | | `dyn Error` | an object of its `fmt$Debug` and `fmt$Display`, and its `source` where a call dispatches to it: `e.source$Error()` | | `dyn Any` | an instance of the class its value's type was wrapped in, which a downcast checks for: `a instanceof of$dyns_Square ? a.v : undefined` | -| `dyn Fn`, `dyn FnMut`, `dyn FnOnce` | the closure or function it was made of: `(a0: rt.u8) => rt.u32` | -| `dyn Iterator`, `dyn DoubleEndedIterator`, `dyn ExactSizeIterator`, `dyn FusedIterator` | `rt.Iter`: `rt.iterDyn` of the iterator it was made of | +| `dyn Fn`, `dyn FnMut`, `dyn FnOnce` | the closure or function it was made of: `(a0: rs.u8) => rs.u32` | +| `dyn Iterator`, `dyn DoubleEndedIterator`, `dyn ExactSizeIterator`, `dyn FusedIterator` | `rs.Iter`: `rs.iterDyn` of the iterator it was made of | | constant | its value, inlined as Rust inlines it, so each use of one holding a cell is a cell of its own; one with no value tree, or holding a cell, read from the memory rustc evaluated | -| `static` | a module's value, named for the static, that every use shares, read from the memory rustc evaluated; one that reads another static or a class is an `rt.LazyCell` of it, made on first use, since that may not be made yet when its module is. A `static mut`, and a pointer in one into memory the translation can't name, fail translation | +| `static` | a module's value, named for the static, that every use shares, read from the memory rustc evaluated; one that reads another static or a class is an `rs.LazyCell` of it, made on first use, since that may not be made yet when its module is. A `static mut`, and a pointer in one into memory the translation can't name, fail translation | | a type that drops | a class with `[Symbol.dispose]`: its `Drop` impl, then its fields | | a type's function | a function of the type's module, taking `self` first: `Decoder.slice(dec, 4)` after `import * as Decoder` | -| `Arc`, `Rc`, `Weak`, `Mutex` | `rt.Arc` for either, of what a `Box` is for a slice or `str`, with its strong and weak counts, an `Arc<[u8]>` of an `Arc`'s bytes sharing its count, and `new_cyclic`'s `Weak` upgrading only once its value is made, `get_mut` lending its value only while no other `Arc` or `Weak` shares it, `make_mut` cloning it into a new `rt.Arc` while another `Arc` shares it, or moving it there while only `Weak`s do, which then dangle, as a copy where pointers to it compare, `as_ptr` and `into_raw` pointing where a reference to its value does, or at its place where JS copies it, as a pointer the body shows made from a reference to that value does, which `from_raw`, `increment_strong_count`, and `decrement_strong_count` take back to its `rt.Arc` and count, refused for one the body shows a borrow made, and failing at run time on another pointer no `as_ptr` or `into_raw` of that type of `Arc` gave, or one whose value dropped, and refused for one to a slice or bytes, which JS makes anew each time, and `ptr::addr_eq` comparing what `ptr::eq` compares, of one pointee type, and `into_inner` giving it only from the last strong `Arc`, after which its `Weak`s no longer upgrade; `rt.Weak`, counted in its `rt.Arc` until it drops, and of no `Arc` once made by `Weak::new`; `rt.Mutex`, its own guard, which a lock gives as `Ok` and the guard's drop unlocks: locking it again while held panics and `try_lock` gives `WouldBlock`, as wasm32's do, and a guard's `map` and `filter_map` make `rt.MutexMap`s, each where the part it lends is, which hold the mutex locked until they drop, and a panic aborts, so nothing poisons it and `thread::panicking` is `false`; a `Mutex`'s, a `RefCell`'s, and an `RwLock`'s `into_inner` gives its value and `get_mut` lends it, or an `rt.Place` of it where JS copies it | -| `PoisonError`, `TryLockError` | the `T` it holds; `rt.TryLockError`, tagged as `Bound` is | -| `Cell`, `UnsafeCell`, `RefCell`, `RwLock` | `rt.Cell`, the place holding its value in `v`, for either of the first two: `UnsafeCell::get`'s and `Cell::as_ptr`'s pointer, and `get_mut`'s reference, is the cell where it is an `rt.Place`, and otherwise the object in `v`, refused where the crate may put another cell or object in its place; `rt.RefCell` for either of the others, its own guard, counting its borrows: borrowing it while that conflicts panics as `RefCell`'s does, and locking it so aborts as wasm32's `RwLock` does; `try_borrow` and `try_borrow_mut` fail with `rt.BorrowError` and `rt.BorrowMutError` instead, a clone borrows the cell, `Ref::clone` counts another borrow of it, and a guard's `map`, `filter_map`, `try_map`, and `map_split`, an `RwLock` guard's included, make `rt.RefMap`s, each where a part it lends is, which a write through a mapped `RefMut` reaches in place, sharing the cell's borrow until the last drops; `RwLockWriteGuard::downgrade` keeps the lock as one read, and `Ref::leak` and `RefMut::leak` keep the borrow until `RefCell::undo_leak` ends it; `Cell::update` calls its function on a copy, and `RefCell::replace_with` on the value, borrowed as `borrow_mut` does, or its place where JS copies it; refused for a part of a sized type JS can't write in place, such as a binding's | -| `thread_local!`, `LocalKey` | an `rt.LocalKey`, a module's value that each copy of the key is, which makes its value on first use from the `const` or the expression and never drops it, as wasm32's do; `with` calls its function on that value, `try_with` never fails, the `Cell` and `RefCell` helpers lower from std, and a `RefCell` key's `set` and `with_borrow_mut` borrow it as `borrow_mut` does | -| `OnceCell`, `OnceLock` | `rt.OnceCell` and `rt.OnceLock`, holding the `Option` in `v`, which is the place `get_mut` lends where JS copies the value; a `OnceLock` initialized from within its own initialization panics, as wasm32's does, and `get_or_try_init`'s error leaves either empty | -| `Once`, `OnceState` | `rt.Once`, an `rt.OnceLock` that holds `true` once `call_once` or `call_once_force` ran its function, and panics as wasm32's does if run again from within it; `rt.OnceState`, that `Once`, which a panic never poisons, as it aborts | -| `LazyCell`, `LazyLock` | `rt.LazyCell` and `rt.LazyLock`, which run their function on the first `force` or `Deref`, once, and drop it then, or with the cell if it never ran; forced from within it, either panics as std's does | -| `AtomicU32` and the others of `bool` and integers, `AtomicPtr` | `rt.Atomic`, the `rt.Place` of its value; an `atomic::Ordering` is its discriminant, and one an operation can't take panics as std's does. An `AtomicPtr` compares pointers only to what JS keeps as an object or bytes, as raw pointers do | -| `async fn` | a function returning `rt.Future`: a class of its own, its coroutine's state machine | +| `Arc`, `Rc`, `Weak`, `Mutex` | `rs.Arc` for either, of what a `Box` is for a slice or `str`, with its strong and weak counts, an `Arc<[u8]>` of an `Arc`'s bytes sharing its count, and `new_cyclic`'s `Weak` upgrading only once its value is made, `get_mut` lending its value only while no other `Arc` or `Weak` shares it, `make_mut` cloning it into a new `rs.Arc` while another `Arc` shares it, or moving it there while only `Weak`s do, which then dangle, as a copy where pointers to it compare, `as_ptr` and `into_raw` pointing where a reference to its value does, or at its place where JS copies it, as a pointer the body shows made from a reference to that value does, which `from_raw`, `increment_strong_count`, and `decrement_strong_count` take back to its `rs.Arc` and count, refused for one the body shows a borrow made, and failing at run time on another pointer no `as_ptr` or `into_raw` of that type of `Arc` gave, or one whose value dropped, and refused for one to a slice or bytes, which JS makes anew each time, and `ptr::addr_eq` comparing what `ptr::eq` compares, of one pointee type, and `into_inner` giving it only from the last strong `Arc`, after which its `Weak`s no longer upgrade; `rs.Weak`, counted in its `rs.Arc` until it drops, and of no `Arc` once made by `Weak::new`; `rs.Mutex`, its own guard, which a lock gives as `Ok` and the guard's drop unlocks: locking it again while held panics and `try_lock` gives `WouldBlock`, as wasm32's do, and a guard's `map` and `filter_map` make `rs.MutexMap`s, each where the part it lends is, which hold the mutex locked until they drop, and a panic aborts, so nothing poisons it and `thread::panicking` is `false`; a `Mutex`'s, a `RefCell`'s, and an `RwLock`'s `into_inner` gives its value and `get_mut` lends it, or an `rs.Place` of it where JS copies it | +| `PoisonError`, `TryLockError` | the `T` it holds; `rs.TryLockError`, tagged as `Bound` is | +| `Cell`, `UnsafeCell`, `RefCell`, `RwLock` | `rs.Cell`, the place holding its value in `v`, for either of the first two: `UnsafeCell::get`'s and `Cell::as_ptr`'s pointer, and `get_mut`'s reference, is the cell where it is an `rs.Place`, and otherwise the object in `v`, refused where the crate may put another cell or object in its place; `rs.RefCell` for either of the others, its own guard, counting its borrows: borrowing it while that conflicts panics as `RefCell`'s does, and locking it so aborts as wasm32's `RwLock` does; `try_borrow` and `try_borrow_mut` fail with `rs.BorrowError` and `rs.BorrowMutError` instead, a clone borrows the cell, `Ref::clone` counts another borrow of it, and a guard's `map`, `filter_map`, `try_map`, and `map_split`, an `RwLock` guard's included, make `rs.RefMap`s, each where a part it lends is, which a write through a mapped `RefMut` reaches in place, sharing the cell's borrow until the last drops; `RwLockWriteGuard::downgrade` keeps the lock as one read, and `Ref::leak` and `RefMut::leak` keep the borrow until `RefCell::undo_leak` ends it; `Cell::update` calls its function on a copy, and `RefCell::replace_with` on the value, borrowed as `borrow_mut` does, or its place where JS copies it; refused for a part of a sized type JS can't write in place, such as a binding's | +| `thread_local!`, `LocalKey` | an `rs.LocalKey`, a module's value that each copy of the key is, which makes its value on first use from the `const` or the expression and never drops it, as wasm32's do; `with` calls its function on that value, `try_with` never fails, the `Cell` and `RefCell` helpers lower from std, and a `RefCell` key's `set` and `with_borrow_mut` borrow it as `borrow_mut` does | +| `OnceCell`, `OnceLock` | `rs.OnceCell` and `rs.OnceLock`, holding the `Option` in `v`, which is the place `get_mut` lends where JS copies the value; a `OnceLock` initialized from within its own initialization panics, as wasm32's does, and `get_or_try_init`'s error leaves either empty | +| `Once`, `OnceState` | `rs.Once`, an `rs.OnceLock` that holds `true` once `call_once` or `call_once_force` ran its function, and panics as wasm32's does if run again from within it; `rs.OnceState`, that `Once`, which a panic never poisons, as it aborts | +| `LazyCell`, `LazyLock` | `rs.LazyCell` and `rs.LazyLock`, which run their function on the first `force` or `Deref`, once, and drop it then, or with the cell if it never ran; forced from within it, either panics as std's does | +| `AtomicU32` and the others of `bool` and integers, `AtomicPtr` | `rs.Atomic`, the `rs.Place` of its value; an `atomic::Ordering` is its discriminant, and one an operation can't take panics as std's does. An `AtomicPtr` compares pointers only to what JS keeps as an object or bytes, as raw pointers do | +| `async fn` | a function returning `rs.Future`: a class of its own, its coroutine's state machine | | async closure | a closure returning the future of each call, with what makes the future of a call that consumes it if it owns a value that drops and `Fn` or `FnMut` call it | -| `Poll`, `Waker`, `Context`, `RawWaker`, `RawWakerVTable` | `T \| typeof rt.Pending`; `T \| rt.OuterPending` where `T` can already be pending, as `Poll>` can, so `Ready(Pending)` keeps apart from `Pending`; `rt.Waker`, which is also the context, and whose `data` and `vtable` are its identity, which `Waker::data`, `Waker::vtable`, and `will_wake` read, and `clone_from` keeps where the waker it has `will_wake` the source; `rt.RawWaker` and `rt.WakerVTable`, records of their fields under std's names, compared by their derived `==` | -| `pin!(x)`, `poll_fn(f)`, `future::pending()`, `future::ready(v)` | `x`; `rt.PollFn`, which drops `f` with itself; `rt.NEVER`, which every `Pending` is; `rt.Ready`, whose first poll or `into_inner` takes `v` and a later one panics, and which drops `v` with itself unless one took it | -| `Box::pin(x)`, `dyn Future` | `x`; `rt.Future`: an `async` body or std's future as it is, and another future as an `rt.DynFuture` over its `poll`, which drops it with itself unless borrowed | -| `bytes::Bytes` | `rt.ByteSlice`, as `&[u8]` is: its clones and slices share bytes that never change | -| `bytes::BytesMut` | `rt.BytesMut`: a window of storage, which what it splits off and freezes share without overlapping | -| `rand::rngs::ThreadRng` | `rt.ThreadRng`, which holds no state | -| `hashbrown::HashMap`, `HashSet` | `rt.HashMap` and `rt.HashSet`, as std's, which are hashbrown's | -| `hashbrown::HashTable` | `rt.HashTable`: an `rt.HashMap` of nothing to each item, under the hash its caller gives; its entries are `rt.TableEntry`, the place of the item an occupied one holds | +| `Poll`, `Waker`, `Context`, `RawWaker`, `RawWakerVTable` | `T \| typeof rs.Pending`; `T \| rs.OuterPending` where `T` can already be pending, as `Poll>` can, so `Ready(Pending)` keeps apart from `Pending`; `rs.Waker`, which is also the context, and whose `data` and `vtable` are its identity, which `Waker::data`, `Waker::vtable`, and `will_wake` read, and `clone_from` keeps where the waker it has `will_wake` the source; `rs.RawWaker` and `rs.WakerVTable`, records of their fields under std's names, compared by their derived `==` | +| `pin!(x)`, `poll_fn(f)`, `future::pending()`, `future::ready(v)` | `x`; `rs.PollFn`, which drops `f` with itself; `rs.NEVER`, which every `Pending` is; `rs.Ready`, whose first poll or `into_inner` takes `v` and a later one panics, and which drops `v` with itself unless one took it | +| `Box::pin(x)`, `dyn Future` | `x`; `rs.Future`: an `async` body or std's future as it is, and another future as an `rs.DynFuture` over its `poll`, which drops it with itself unless borrowed | +| `bytes::Bytes` | `rs.ByteSlice`, as `&[u8]` is: its clones and slices share bytes that never change | +| `bytes::BytesMut` | `rs.BytesMut`: a window of storage, which what it splits off and freezes share without overlapping | +| `rand::rngs::ThreadRng` | `rs.ThreadRng`, which holds no state | +| `hashbrown::HashMap`, `HashSet` | `rs.HashMap` and `rs.HashSet`, as std's, which are hashbrown's | +| `hashbrown::HashTable` | `rs.HashTable`: an `rs.HashMap` of nothing to each item, under the hash its caller gives; its entries are `rs.TableEntry`, the place of the item an occupied one holds | `Vec` storage and `[x; N]` byte arrays up to 1 KiB share 8 KiB `ArrayBuffer`s, as Node's `Buffer` pool does, so the `buffer` behind a view holds other bytes too: read it through `byteOffset` and `byteLength`, and copy it before transferring it. -An `rt.ByteSlice` is a range of a `Uint8Array`: its `data`, from `start`, for `length` +An `rs.ByteSlice` is a range of a `Uint8Array`: its `data`, from `start`, for `length` bytes. A struct's private `&[u8]` or `&[u8; N]` field is its three parts, `bufData`, `bufStart`, and `bufLen` for `buf`, so a cursor moving through it makes no object; a read that needs the slice whole makes it there. A caller passes bytes as -`rt.byteSliceFrom(array)` and reads a slice it gets as `rt.byteSliceView(slice)`, a view +`rs.byteSliceFrom(array)` and reads a slice it gets as `rs.byteSliceView(slice)`, a view of it. A mutable part of a slice of other values, as `&mut v[a..b]`, `split_at_mut`, `chunks_mut`, and `split_mut` lend it, is a `Proxy` of an array whose elements are the slice's, read and written where they are, since a JS array @@ -173,59 +173,59 @@ reads, and the runtime's swaps, rotations, and sorts move copies of the runs. `usize` is 32 bits, as on wasm32, so it is exact in a `number`. Arithmetic is checked as a debug build checks it, so translated code panics where native code would: it never -wraps silently. A panic throws `rt.Panic`, with the message native Rust panics with, and +wraps silently. A panic throws `rs.Panic`, with the message native Rust panics with, and aborts as wasm32's does: it runs no cleanup, so what the translation held is undefined -after one, as a wasm trap leaves it, and a caller that catches `rt.Panic` must not use it +after one, as a wasm trap leaves it, and a caller that catches `rs.Panic` must not use it again. An abort without a panic, as std's for an `RwLock` locked again while held, -throws `rt.Abort`, a `Panic` with std's abort message. So `catch_unwind` only ever returns -`Ok`, `resume_unwind` throws `rt.Abort` without running the hook, and `panic_any` panics +throws `rs.Abort`, a `Panic` with std's abort message. So `catch_unwind` only ever returns +`Ok`, `resume_unwind` throws `rs.Abort` without running the hook, and `panic_any` panics with its payload if that is text, or `Box` as std's hook writes any other. A program that reaches `set_hook` has each panic carry the `Location` native code gives it, std's own at the `/rustc//library/...` path its build names, read from the toolchain's source, and runs its hook with a `PanicHookInfo` before throwing; a panic in -the hook throws `rt.Abort`, as std aborts. A panic of `bytes`' own code is where the +the hook throws `rs.Abort`, as std aborts. A panic of `bytes`' own code is where the program's `bytes` has it, named as the session names that file: by the host's cargo registry, unless the build remaps it, as `--remap-path-prefix` does natively. The default hook writes nothing, as wasm32 has no stderr. A program without one passes no locations, -and a bundler drops the hook's runtime, `rt/hook.ts`, from it; what stays is the location +and a bundler drops the hook's runtime, `rs/hook.ts`, from it; what stays is the location parameter of the runtime's panicking functions, which it leaves unset, and the key each of std's and `bytes`' panics passes. `Location::caller` gives rustc's location: the file as the session names it, and line and column. A function rustc passes its caller's location to, such as a `#[track_caller]` -one, takes it as an `rt.Location` last parameter, and so does a trait object's method +one, takes it as an `rs.Location` last parameter, and so does a trait object's method whose trait declares it so. A call the crate writes passes the call's location, or, in such a function, its own caller's; a function pointer, or a trait object's method only the impl tracks, passes the function's own, as rustc's shim does. One that std's code calls, through its `Fn` impls, is refused, as its location is in std's source. -Each integer type is its own type to `tsc`, named as Rust's: `rt.u8` is a `number` with a +Each integer type is its own type to `tsc`, named as Rust's: `rs.u8` is a `number` with a type-only brand, so a `u16` where a `u8` goes fails the type check, while a plain -number, such as a literal, passes for any. A cast that keeps the value is `x as rt.u16`, +number, such as a literal, passes for any. A cast that keeps the value is `x as rs.u16`, which costs nothing at run time. A wider integer is a `number` up to 2^53 - 1 in magnitude, and past that an immutable object of 32-bit limbs, `{ hi, lo }`, with `w2` and `w1` between them at 128 bits and `hi` signed in a signed type. Each value has one form, so `x === 0` is exact; a caller -makes one past 2^53 with `rt.u64Of(18446744073709551615n)`. Its other operators and -comparisons are runtime calls, `rt.u64Add(a, b)` and `rt.u64Lt(a, b)`, and `x as u32` -is `rt.u64Low(x)`. `((hi as u64) << 32) | lo as u64` of halves of at most 32 bits is -one call, `rt.u64FromHalves(hi, lo)`. +makes one past 2^53 with `rs.u64Of(18446744073709551615n)`. Its other operators and +comparisons are runtime calls, `rs.u64Add(a, b)` and `rs.u64Lt(a, b)`, and `x as u32` +is `rs.u64Low(x)`. `((hi as u64) << 32) | lo as u64` of halves of at most 32 bits is +one call, `rs.u64FromHalves(hi, lo)`. Each integer's inherent methods are std's, and a `NonZero`'s, a `Wrapping`'s, and a `Saturating`'s are its integer's, as std defines them: a `Wrapping`'s `pow` is `wrapping_pow`. `pow` and `abs` panic on overflow as a debug build's do. Those the operators -lack are one runtime function for every width, `rt.intCheckedPow(a, n, 64, false)`, given +lack are one runtime function for every width, `rs.intCheckedPow(a, n, 64, false)`, given the width and sign, which computes on the value's `bigint`. The stable ASCII methods of `u8` and `char`, and of `[u8]` and `str`, so of a `Vec` -and a `String`, are std's. A `u8` and a `char` share each runtime function, `rt.isAsciiDigit(c)`. +and a `String`, are std's. A `u8` and a `char` share each runtime function, `rs.isAsciiDigit(c)`. `make_ascii_uppercase` and `make_ascii_lowercase` of a byte, a char, or a string write the other case where the `&mut` borrows it, a part of a `String` included. `escape_ascii`'s iterators read from either end, size themselves as std's do, and write what they have left by `Display`, unpadded. `char`'s Unicode classes and case maps read std's Unicode tables, which the runtime -carries in `rt/unicode.ts`, not the engine's, so they hold of the chars std's do whatever +carries in `rs/unicode.ts`, not the engine's, so they hold of the chars std's do whatever the engine's Unicode version. `to_lowercase`, `to_uppercase`, and the escapes read from either end, size themselves as std's do, and write what they have left by `Display`, unpadded, as `escape_debug` of a char it leaves as it is writes that char even once it has @@ -241,7 +241,7 @@ are std's `flat_map` of each char's, sized as it is, and write what they have le `Display`, unpadded. `encode_utf16` is sized as std's, and `Debug` of it is `EncodeUtf16 { .. }`. `String::from_utf16` and `from_utf16_lossy`, and `from_utf16le`, `from_utf16be`, and their lossy forms over bytes, decode as `char::decode_utf16` does: an unpaired surrogate -fails with `rt.FromUtf16Error`, `{ kind }`, its private `FromUtf16ErrorKind`'s name, or +fails with `rs.FromUtf16Error`, `{ kind }`, its private `FromUtf16ErrorKind`'s name, or becomes U+FFFD, and so does an odd byte at the end. `String::from_utf8_lossy` is a `TextDecoder`'s, which writes one U+FFFD for each maximal invalid sequence, as std's does, and borrows the text of valid UTF-8, as std's does. `utf8_chunks` splits @@ -283,9 +283,9 @@ to a single, and the rest go through `f64` as std's do. translate, as do `Display` and `Debug` impls, derived and thiserror's included. The runtime ports `core::fmt`, so the text matches native Rust's byte for byte. A placeholder becomes a function writing its value, and `fmt::Arguments` an array of literal pieces -and such functions: `rt.fmtWriteFmt(f, ["code=", (f) => rt.u16Display(code, f)])`. A `&dyn +and such functions: `rs.fmtWriteFmt(f, ["code=", (f) => rs.u16Display(code, f)])`. A `&dyn Debug` or `&dyn Display` is such a function too, and so is a `&mut` one, which reads -through the `rt.Place` of a value JS copies as it writes, a `Box` of one, `rt.fmtOwned` +through the `rs.Place` of a value JS copies as it writes, a `Box` of one, `rs.fmtOwned` of the value, which drops it as the box drops, and an `Arc` or `Rc` of one, which the last pointer drops, as an `Arc` of the crate's own trait object does. Format specs take every option but `{:p}`: fill, alignment, `+`, `#`, `0`, `x?` and `X?`, a width and a precision, each also from an @@ -297,9 +297,9 @@ single, found as Dragon does, which JS has no function for. `str::parse` of a fl std's grammar, not `Number`'s, and rounds to the nearest of the type once, so an `f32` never rounds through a double. The `str::parse` and `from_str_radix` of an integer or a `NonZero` are core's own, over the string's UTF-8 bytes; their `ParseIntError` is -`rt.ParseIntError`, `{ kind }`, whose `IntErrorKind` is the variant's name. `bool`'s is -core's too, failing with an `rt.ParseBoolError`; a `char`'s is `rt.charFromStr`, failing with -an `rt.ParseCharError`, `{ kind }`, its private `CharErrorKind`'s name. `==` of a `Result`, +`rs.ParseIntError`, `{ kind }`, whose `IntErrorKind` is the variant's name. `bool`'s is +core's too, failing with an `rs.ParseBoolError`; a `char`'s is `rs.charFromStr`, failing with +an `rs.ParseCharError`, `{ kind }`, its private `CharErrorKind`'s name. `==` of a `Result`, a `Poll`, and std's errors is their derived `PartialEq`, from core's MIR, so two errors are equal where their kinds are, private or not. A `Result`'s and a `Poll`'s `PartialOrd` and `Ord` are their derived ones too: by variant, `Ok` before `Err` and `Ready` before `Pending`, then by @@ -333,8 +333,8 @@ not, writes what it lends by its own `Debug` and `Display`. `Debug` of a `Cell`, its name. A `LazyCell` and a `LazyLock` write their value, or ``, unpadded, before it is forced and while their function runs, without forcing it. A caller prints a `printable` type as `to_string()` and `format!("{err:?}")` -would: `rt.fmtToString((f) => DecodeError.fmt$fmt_Display(err, f))` and -`rt.fmtFormat([(f) => DecodeError.fmt$fmt_Debug(err, f)])`, after +would: `rs.fmtToString((f) => DecodeError.fmt$fmt_Display(err, f))` and +`rs.fmtFormat([(f) => DecodeError.fmt$fmt_Debug(err, f)])`, after `import * as DecodeError from "./coding/decode.DecodeError.ts"`. `fmt::Write` translates for a `String`, a `Formatter`, and the crate's own writers, and through a `&mut` to any of them. A crate's own provided `write_char` and a literal `write_fmt` call its `write_str` once, as @@ -343,9 +343,9 @@ makes, with the same text in the same order: each fill a `write_char`, an intege before its digits, a float's formatted parts, and a string's `Debug` in runs between its escapes, so a writer that counts calls or fails partway sees what it would natively. -An iterator's `next()` returns its next item or `rt.DONE`, never `undefined`, so an +An iterator's `next()` returns its next item or `rs.DONE`, never `undefined`, so an iterator of `Option` keeps each `None` apart from its end. std's adaptors and consumers -are runtime functions taking the iterator first, `rt.iterMap(it, f)`, lazy and +are runtime functions taking the iterator first, `rs.iterMap(it, f)`, lazy and short-circuiting as std's are, and call their closures, and read what they wrap, in the same order and as often, a skip by `nth` included. `max`, `min`, and their `_by_key` forms test each next item's key for `<` the best's, as std's do, `max_by` and `min_by` @@ -356,32 +356,32 @@ compare the best and then the next, and a B-tree's iterators read their ends. `e An iterator over a slice, array, or `Vec`, or a small range, that only its `next` and moves into other variables read steps in place, not one moved into a field, as an `async` block's is when held across an `.await`, as two variables: the array and an index into it, or the -range's bounds, with no `rt.Iter` made. The crate's own `impl Iterator` returns `rt.DONE` from its `next` too, and joins -std's adaptors through `rt.iterFrom`, which calls its own `size_hint`, `next_back`, `len`, `nth`, and `nth_back`, +range's bounds, with no `rs.Iter` made. The crate's own `impl Iterator` returns `rs.DONE` from its `next` too, and joins +std's adaptors through `rs.iterFrom`, which calls its own `size_hint`, `next_back`, `len`, `nth`, and `nth_back`, and of one it owns, not borrows by `&mut` or boxes, its own `fold`, `rfold`, `count`, `last`, `find`, `rfind`, `find_map`, `for_each`, `reduce`, `all`, and `is_sorted_by`, where std's adaptors and consumers call them: a filter's `next` calls `find`, an `extend` into a hash or B-tree collection, a `String`, or a tuple calls `for_each`, `max` calls `reduce`, and `is_sorted` calls `is_sorted_by`, which calls `all`. One whose JS value is copied, such as an -enum's, it holds as an `rt.Place` of its own, which its `next` and std's methods taking +enum's, it holds as an `rs.Place` of its own, which its `next` and std's methods taking `&mut self` write through, as they do the place a `&mut` to it is. Its own `collect` into a `Vec` runs where std's `FromIterator` of a `Box<[T]>`, `Rc<[T]>`, `Arc<[T]>`, `BTreeMap`, `BTreeSet`, or `BinaryHeap` calls it first, its own `eq` and `partial_cmp` where `ne` and the tests on `partial_cmp` call them, and its own `by_ref`, which std calls only from `Vec::splice`, which refuses one that overrides it, `position`, `max`, and the others std never calls in place of another only where the crate calls them, and `fuse` reads on past the end of one that is a `FusedIterator`, as std's does. A caller calls `next()` for one item, or iterates -an `rt.Iter` with `for ... of`. Each `rt.Iter`'s `sizeHint` is std's `size_hint`, its upper +an `rs.Iter` with `for ... of`. Each `rs.Iter`'s `sizeHint` is std's `size_hint`, its upper bound `undefined` for `None`, and a `collect` or `extend` into a `Vec`, `VecDeque`, `BinaryHeap`, B-tree, or hash collection reserves by it where std's does, panicking with std's capacity overflow past the most it holds. A tuple of these, of `String`s, `()`, or such tuples, collects, unzips, and extends as std's tuple impls do: a 1-tuple's collection by its own `extend`, and a longer one's each reserving the lower bound, in field order, before -each item's fields go into them in order, as `rt.tupleExtend(t, it, [rt.vecPart(2), -rt.STRING_PART])`. The crate's own `Default + Extend` collection keeps the defaults stable +each item's fields go into them in order, as `rs.tupleExtend(t, it, [rs.vecPart(2), +rs.STRING_PART])`. The crate's own `Default + Extend` collection keeps the defaults stable Rust can't override: it reserves nothing, and takes each item by its `extend` of `Some(item)`, -through `rt.ownPart`. Any other collection in one is refused. +through `rs.ownPart`. Any other collection in one is refused. -`clone` of one of std's iterators or adaptors is its `rt.Iter`'s `clone`, which reads on +`clone` of one of std's iterators or adaptors is its `rs.Iter`'s `clone`, which reads on from where the original was, independently of it, as std's `Clone` does; one over a hash collection steps a fresh iterator of it past what the original read, as JS can't copy where a `Map`'s iterator is. What it holds that the runtime can't clone, an item one that @@ -390,12 +390,12 @@ what the translation gives it, as `it.clone({ v: Item.clone$Clone })`. A closure clones its captures: one that writes none of them, each of which only copies or clones as itself, is its own clone, and another whose clone translation reaches is made by a function of its captures, which makes the clone again of theirs, in order. `cycle` takes -the same clones, as `rt.iterCycle(it, { v: Item.clone$Clone })`, by which it clones its +the same clones, as `rs.iterCycle(it, { v: Item.clone$Clone })`, by which it clones its iterator as it is made and again each time a clone ends. A `str` is a JS string, which is UTF-16: `chars` steps by code point, and a search by a `char`, a `&str`, a predicate (a closure, a function or a function pointer, or a `dyn FnMut`) behind any references and boxes, -or an array or slice of chars, as in `rt.strSplit(s, "/")`, takes the text or the +or an array or slice of chars, as in `rs.strSplit(s, "/")`, takes the text or the closure, which it calls on each char it reads, in the order std reads them, and drops a closure it owns as it returns, or with the iterator it returns, as `split` does, leaving one it borrows to its owner. An offset it returns, from `rfind` or `match_indices`, counts UTF-8 bytes, as Rust's does, and so does @@ -405,8 +405,8 @@ does inside a char, where `get` gives `None`. A JS string can't change in place, field the `&mut` borrows, taking and checking byte offsets as std does, and `retain` then drops its closure. `+`, of a `String`, is JS's `+` of the moved text, as `+=` is, and of a `Cow` takes either side whole when the other is empty, as std's does. A `&mut str` is -the `rt.Place` of its `String` wherever that is, and a part of one, from `&mut s[a..b]`, -`get_mut`, or `split_at_mut`, is `rt.strPart(p, a, b)`, a place of its own that writes the +the `rs.Place` of its `String` wherever that is, and a part of one, from `&mut s[a..b]`, +`get_mut`, or `split_at_mut`, is `rs.strPart(p, a, b)`, a place of its own that writes the whole string anew, checking its offsets as `&s[a..b]` does. `as_bytes_mut`, `get_unchecked_mut`, and `str::from_utf8_mut` are refused. `extend` and `collect` read their iterator by `for_each`, as std's do, and of chars first reserve its @@ -443,13 +443,13 @@ function is suffixed instead by a hash of its text, with what it calls by name, `map$1cf8u0y`: instances that print the same are one function, whichever of them translation reaches. Types are translated once, generically, so a function of a generic type is one instance's, declaring the instance it takes as `self`: -`fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rt.Formatter)`. A reference or pointer +`fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rs.Formatter)`. A reference or pointer in a generic type to what only an instance decides the form of, such as `*mut T` or -`&'a mut T`, is an `rt.Ptr`: the object, an `rt.Place`, or an `rt.ByteSlice`, +`&'a mut T`, is an `rs.Ptr`: the object, an `rs.Place`, or an `rs.ByteSlice`, which each read of an instance's field casts to what it holds. So is a run of a -parameter, whose `u8` instance holds bytes: `[T; N]` is an `rt.ArrayOf`, a `T[]` or a -`Uint8Array`, and `[T]`, `Vec`, and `Cow<[T]>` an `rt.SliceOf`, an `rt.VecOf`, -and an `rt.CowOf`. A type's module exports the +parameter, whose `u8` instance holds bytes: `[T; N]` is an `rs.ArrayOf`, a `T[]` or a +`Uint8Array`, and `[T]`, `Vec`, and `Cow<[T]>` an `rs.SliceOf`, an `rs.VecOf`, +and an `rs.CowOf`. A type's module exports the type by its own name, which a caller writes `Decoder.Decoder`, and a function whose name and exports it as its own: `function new_` is `Decoder.new`. A module imports a function or value by its name, and a type's module whole by the type's, `import * as Decoder`, @@ -471,13 +471,13 @@ one kept other than in a local, counts as a write into what it points at. A writ not change in place what it passes to or gets from the translation either. A `&mut` to a value JS copies, which no JS value can point at, such as a number, an -`Option`, an enum, a tuple, a `Box`, or a `String`, is an `rt.Place` whose `v` reads and +`Option`, an enum, a tuple, a `Box`, or a `String`, is an `rs.Place` whose `v` reads and writes where it points. Where it is only read and written through, in the function that borrows it, it is the place it borrows, so a body that passes none on makes none. Passed on, returned, kept in a field, or captured by a value, it is -`rt.place(() => x, (value) => x = value)` over that place, the objects and index it goes +`rs.place(() => x, (value) => x = value)` over that place, the objects and index it goes through held as they were when it was borrowed; a reborrow of one is the same -`rt.Place`. A caller passes one as `{ v }`, or as any object whose `v` it reads and writes. +`rs.Place`. A caller passes one as `{ v }`, or as any object whose `v` it reads and writes. std's mappings take a `&mut` parameter as what it points at. So is a `&mut` to an `Arc` or a `Waker`, pinned or boxed too, whose clones may be one JS object. @@ -507,7 +507,7 @@ an `Arc`'s `!=` call as well. What a composite holds compares, orders, and hashe reference or a `Box` as std's impls forward it, by what it points at, or by the crate's own impl on the reference or `Box` itself. A reference std makes to a byte array it holds, as a collection's `keys`, `HashSet::get`, and `retain`'s closure, `Option::iter`, -`slice::first`, and `filter`'s closure over `[u8; N]` items get one, is an `rt.ByteSlice` +`slice::first`, and `filter`'s closure over `[u8; N]` items get one, is an `rs.ByteSlice` of its bytes, as a `&[u8; N]` is elsewhere; a `&mut` writes where std holds them. A `&[u8; N]` std was given and holds, as a `HashMap<&[u8; N], V>`'s keys, stays the slice it was, and `extend` by references to arrays copies each into its own `Uint8Array`. A @@ -515,7 +515,7 @@ was, and `extend` by references to arrays copies each into its own `Uint8Array`. `assert_eq!` take one, is a view of the slice's bytes, which std reads, copies, and writes through where the reference points; `mem::swap`, `replace`, and `take` through a `&mut [u8; N]` copy bytes in place. A `&mut` to a value a map holds that JS copies, -such as a number, from `get_mut` or the entry API, is an `rt.Place` whose `v` reads and +such as a number, from `get_mut` or the entry API, is an `rs.Place` whose `v` reads and writes the map's slot. A hash map iterates in an order of the runtime's, mostly insertion order, which std leaves unspecified, and hashes a key with a hasher of its own, as std's keys its at random. So is how often the runtime @@ -536,8 +536,8 @@ does, from keys drawn once and the first raised by one for each state, drawn fro slice's one `write` included, and std's provided methods it doesn't write itself write through the others as std's do. `BuildHasher::hash_one` of a crate's own builds its hasher, hashes, finishes, then drops the hasher and the value. A hasher JS copies, such as -an enum, hashes as a struct one does, through the `rt.Place` its `&mut` is. -Its iterators are `rt.Iter`s, so std's adaptors run over them. +an enum, hashes as a struct one does, through the `rs.Place` its `&mut` is. +Its iterators are `rs.Iter`s, so std's adaptors run over them. A value drops where Rust drops it, if dropping it does something JS can see: a `Drop` impl, an `Arc`'s count, or a waker. Bodies lower from MIR, so each drop is where drop @@ -553,7 +553,7 @@ functions for std's collections, `Arc`, and the std functions that may discard a drop it where std's do. So do iterators: one that owns its items, as a `Vec`'s `into_iter` or a map's `drain` does, drops those it still holds by `[Symbol.dispose]`, an adaptor drops what it skips or rejects, and a consumer that takes an iterator by value drops it: -through each `rt.Iter`'s own `fold` where std's folds, which drops each adaptor's closure +through each `rs.Iter`'s own `fold` where std's folds, which drops each adaptor's closure as its fold ends, before what it wraps, as std's does. The crate's own `fold` is given that closure as a `Box`, which drops it where its body does, and so are its own `find`, `find_map`, `for_each`, `reduce`, and `all`, whose `find_map` is given what it finds @@ -576,20 +576,20 @@ The trait's module exports its type, `Shape.Shape` from `dyns.Shape.ts`, which a caller can implement. A coercion wraps the value in a class of its type's from `lib.ts`, named for the type as a suffix spells it, `new of$dyns_Square(sq)`, which every trait's object of the type shares, whose methods call that type's impls; one from a `&mut` to a -value JS copies holds its `rt.Place`, as `ofPlace$dyns_Square`, so `&mut self` writes +value JS copies holds its `rs.Place`, as `ofPlace$dyns_Square`, so `&mut self` writes where the value is. An upcast, to `dyn Any` too, is the same object. Objects of two traits of one name, with a method of one name, are refused for one type, whose class can't hold both. A `Box` drops what it holds through its `[Symbol.dispose]`, which a TS caller's object may leave out. An `Arc` unsized to an `Arc`, or to an -`Arc`, is an `rt.ArcDyn`: the object a box of its value would be, and the +`Arc`, is an `rs.ArcDyn`: the object a box of its value would be, and the `Arc` it was made from, whose one count both sides' clones and drops change, and the last of which drops the value. `Arc::ptr_eq` compares the `Arc`s. An `Rc` is an `Arc`, and a `Pin` the pointer it holds. A `Weak` unsized to a `Weak` keeps the -`Arc` and makes the `rt.ArcDyn` as it upgrades, since the value of `new_cyclic`'s -`Weak` is not there yet as it unsizes. `Arc::from` or `Rc::from` of a box is an `rt.Arc` +`Arc` and makes the `rs.ArcDyn` as it upgrades, since the value of `new_cyclic`'s +`Weak` is not there yet as it unsizes. `Arc::from` or `Rc::from` of a box is an `rs.Arc` of what the box is, which drops it with the last clone. A pointer to a struct whose last -field unsizes to a trait object, such as `RefCell`, is an `rt.tailDyn` view of -the struct it was made from, behind an `rt.ArcDyn` in an `Arc`, and two such pointers are +field unsizes to a trait object, such as `RefCell`, is an `rs.tailDyn` view of +the struct it was made from, behind an `rs.ArcDyn` in an `Arc`, and two such pointers are equal if their views are of one struct. A raw pointer unsized to a trait object, or to a struct of one, is what a box of the object it points at unsizes to, which drops it as `Box::from_raw` of it does, or what a `&mut` to its place does; one to a library value, @@ -603,16 +603,16 @@ whose `IoSlice` has no JS value, so a call of it fails. A `dyn Any` is such an object with no methods, whose class `is`, `downcast_ref`, `downcast_mut`, and `Box`'s, `Arc`'s, and `Rc`'s `downcast` check for: `a instanceof of$dyns_Square ? -a.v : undefined`. Its `Debug` writes `Any { .. }`, as std's does. A `&mut` one of a value JS copies is the class holding its `rt.Place`, +a.v : undefined`. Its `Debug` writes `Any { .. }`, as std's does. A `&mut` one of a value JS copies is the class holding its `rs.Place`, or the class itself behind a `Box`, as a `&mut dyn Trait`'s is, and `Arc::downcast` gives -back the `Arc` the object was made from, or, of one made from a box, an `rt.ArcDyn` of +back the `Arc` the object was made from, or, of one made from a box, an `rs.ArcDyn` of the value sharing its count. A `dyn Fn`, `dyn FnMut`, or `dyn FnOnce` is the closure or function it was made of, which a call calls as it does the closure, and which a box drops as it does the closure. One -that `Fn` or `FnMut` calls, boxed as a `dyn FnOnce`, is `rt.once` of it, which drops it +that `Fn` or `FnMut` calls, boxed as a `dyn FnOnce`, is `rs.once` of it, which drops it after the call, as an `FnOnce` closure's body drops what it owns, and a box of a -reference to one is `rt.lent` of it, which never drops it. +reference to one is `rs.lent` of it, which never drops it. A `dyn Error` is such an object of `source` and its supertraits' `Debug` and `Display`, `of$errors_Leaf`, whose `source` is `None` for a type that keeps `Error`'s own. `From` an @@ -623,11 +623,11 @@ do, which a value upcast from the crate's own trait is of too. Its deprecated private error type. A `dyn Iterator`, `dyn DoubleEndedIterator`, `dyn ExactSizeIterator`, or `dyn FusedIterator` -behind `&`, `&mut`, `Box`, `Arc`, or `Rc` is an `rt.Iter` of its items, `rt.iterDyn` of the iterator it was made +behind `&`, `&mut`, `Box`, `Arc`, or `Rc` is an `rs.Iter` of its items, `rs.iterDyn` of the iterator it was made of, std's or the crate's own: it reads that iterator by the methods std's vtable holds, such as `next`, `nth`, and `size_hint`, and folds it by `next`, as std's defaults read a trait object, so a `count` or `last` of a boxed `Chain` drops its items in the order the -trait object's does. A box of any iterator, a trait object or not, is `rt.iterBox` of it +trait object's does. A box of any iterator, a trait object or not, is `rs.iterBox` of it wherever it is read, behind a `&mut` too: it forwards `next`, `nth`, `last`, and what else std's `Iterator` for `Box` forwards, and reads the rest by `next`, `advance_by` and the folds included, so a boxed `skip` of a zip skips through the zip's `nth` as std's does. A @@ -648,19 +648,19 @@ stopped in. A poll after the future returned panics, and dropping it cancels it, dropping what its state holds. An async closure's future borrows what the closure captured, and that of a call that consumes it owns it, as rustc's by-move body does: a class of its own (`closuresFuture$closure2_closure0_once`), which a closure that `Fn` or -`FnMut` call and that owns what drops makes through `rt.callOnce`, as std's functions and +`FnMut` call and that owns what drops makes through `rs.callOnce`, as std's functions and a `dyn FnOnce` call it. -`rt.spawn(future, signal?)` runs one as a promise, polling woken tasks in a batch from a +`rs.spawn(future, signal?)` runs one as a promise, polling woken tasks in a batch from a microtask and yielding to a macrotask after 128 polls. Aborting `signal` drops the future at once, or as the poll it aborts in returns pending, and rejects the promise with the signal's reason; a future ready in that poll resolves it. A waker's identity is its `data` -and `vtable`, as std's is, and its vtable an `rt.WakerVTable` of the four functions std's +and `vtable`, as std's is, and its vtable an `rs.WakerVTable` of the four functions std's `RawWakerVTable` holds, which `RawWakerVTable::new` and a `static` of one make, `==` -compares, and `Waker::new`, `Waker::from_raw`'s `rt.VTableWaker`, calls on its data for +compares, and `Waker::new`, `Waker::from_raw`'s `rs.VTableWaker`, calls on its data for each clone, wake, and drop, which a function casts back to what it points at, such as an `Arc`'s `into_raw` it counts and takes back. `Waker::from(arc)` and `RawWaker::from(arc)`, of an `Arc` of the crate's `Wake` impl, hold a count of the `Arc` and wake through the impl: their data is the `Arc`, and their vtable the impl's, so clones and wakers made apart from one `Arc` -share them. `Waker::noop()` is `rt.NOOP_WAKER`, and a caller's own waker gives its own +share them. `Waker::noop()` is `rs.NOOP_WAKER`, and a caller's own waker gives its own identity, which each of its clones shares, and a vtable of what it does. A file's items follow the Rust source, whatever @@ -677,12 +677,12 @@ Imports name the `.ts` file, which Node, Bun, and bundlers run as is. A `tsc` bu rust2-ts maps a few crates itself, as it maps std, so a consumer binds and configures none of them: -- `bytes::Bytes` is an `rt.ByteSlice`: an `rt.CountedBytes`, one of the handles its - storage counts as `bytes` does, which drops by `rt.bytesDrop`, or a plain one where it is +- `bytes::Bytes` is an `rs.ByteSlice`: an `rs.CountedBytes`, one of the handles its + storage counts as `bytes` does, which drops by `rs.bytesDrop`, or a plain one where it is static. Its constructors, `len`, `is_empty`, `is_unique`, `try_into_mut`, `slice`, `Clone`, `Deref`, `AsRef`, `PartialEq` with bytes, `Default`, `Debug`, and `From` between it and `Vec`, `String`, `&'static [u8]`, and `&'static str` map to - `rt/bytes.ts`, panicking as `bytes` does, and so do `split_to`, `split_off`, + `rs/bytes.ts`, panicking as `bytes` does, and so do `split_to`, `split_off`, `truncate`, `clear`, and `slice_ref`, whose panic names no addresses. A `String`'s bytes are in storage of its capacity, which JS keeps none of, so where any crate makes a `Bytes` or a `Vec` of them, every crate is refused what reads a `Bytes`' capacity: @@ -692,7 +692,7 @@ of them: str`'s bytes that `as_bytes` encodes anew. `Bytes::from_owner` reads its owner's bytes once, as `bytes` does, and is refused for an owner that drops, which would drop with the last clone of what it makes. -- `bytes::BytesMut` is an `rt.BytesMut`: a vector of its own, or a window of storage that +- `bytes::BytesMut` is an `rs.BytesMut`: a vector of its own, or a window of storage that the handles `split_to`, `split_off`, and `split` make and the `Bytes` that `freeze` makes share without overlapping, as `bytes`' do. Its constructors, `len`, `is_empty`, `capacity`, `freeze`, `split_to`, `split_off`, `split`, `truncate`, `clear`, `resize`, @@ -700,7 +700,7 @@ of them: `Deref`, `DerefMut`, `AsRef`, `AsMut`, `PartialEq` with bytes, `Default`, `Debug`, and `From` between it and `Bytes`, `Vec`, `&[u8]`, and `&str` map, with `bytes`' capacities and panics: each handle drops, so `reserve` reclaims storage once no other - handle holds it, as `bytes`' does. `spare_capacity_mut` is an `rt.ByteSlice` of the + handle holds it, as `bytes`' does. `spare_capacity_mut` is an `rs.ByteSlice` of the storage past its bytes, which `set_len` takes in, panicking past the capacity as `bytes`' debug assertion does. - `Buf` and `BufMut` of a `Bytes`, a `BytesMut`, a `&[u8]`, and a `Vec` map: the @@ -739,8 +739,8 @@ of them: `hashlink`'s default too, a crate's own `Hasher` over hashbrown's. Nothing of hashbrown translates, so `hashlink`, which keeps its entries in a `HashTable`, translates over the runtime's. -- `rand::rng()` is an `rt.ThreadRng`, whose `random` of an integer or `bool` and - `random_range` of an integer range map to `rt/rand.ts`. Each value comes from +- `rand::rng()` is an `rs.ThreadRng`, whose `random` of an integer or `bool` and + `random_range` of an integer range map to `rs/rand.ts`. Each value comes from `crypto.getRandomValues`, uniform as `rand`'s are, though no seed reproduces them, as none reproduces `rand::rng()`'s. An empty range panics as `rand`'s does. A seeded generator, such as `StdRng`, is refused, since its values would have to be `rand`'s. @@ -756,7 +756,7 @@ Its path goes from the crate root, or else from a crate it depends on by the nam gives it, as `buf::Blob` for `buf = { package = "blob" }`. A crate it reaches only through another goes by its own name, where one crate of that name is built. Its file, relative to `ts.toml`, is copied to the same path in the output, beside the -runtime. It imports `rt.ts` as the output's modules do, `../rt.ts` from `bind/blob.ts`, +runtime. It imports `rs.ts` as the output's modules do, `../rs.ts` from `bind/blob.ts`, and may import the translated modules and npm packages too. Callers import it whole, as a type's module, `import * as Blob from "./bind/blob.ts"`. @@ -776,7 +776,7 @@ generic bound type's value at each of its instantiations translation reaches. A type with a representation of its own, std's or a well-known crate's, can't be bound. Translation can't see into a bound type, so a field, variant, or constructor of one is -refused, as are iterating one and assigning a whole one through a `&mut`. Its value is never `undefined` or `rt.Pending`, which `None` and +refused, as are iterating one and assigning a whole one through a `&mut`. Its value is never `undefined` or `rs.Pending`, which `None` and `Poll::Pending` are, and is an object unless the Rust type is `Copy`. A `&mut` to one passes that object, which the binding's functions change in place. Where the type is `Copy`, such a `&mut` is refused, since JS shares the value where Rust copies it, and a @@ -793,12 +793,12 @@ another only where translation reaches both. A binding inside the output is refu a translation replaces it. A bound type keys a collection, alone or in a tuple, `Option`, or `Arc`, by the exports of -its Rust impls: `hash$Hash(self, state: rt.Hasher): undefined` and `eq$cmp_PartialEq` for a +its Rust impls: `hash$Hash(self, state: rs.Hasher): undefined` and `eq$cmp_PartialEq` for a `HashMap` or `HashSet`, `cmp$cmp_Ord` for a `BTreeMap` or `BTreeSet`, and `partialCmp$cmp_PartialOrd` too for a B-tree's `range` and `extract_if`. A derived impl's are the same exports. -Each must agree with the Rust impl: `hash` writes what it writes, through `rt.hash8` to -`rt.hash128`, `rt.hashI8` to `rt.hashI128`, `rt.hashUsize`, `rt.hashIsize`, `rt.hashStr`, -and `rt.hashBytes`, so values `eq` finds equal hash alike, and +Each must agree with the Rust impl: `hash` writes what it writes, through `rs.hash8` to +`rs.hash128`, `rs.hashI8` to `rs.hashI128`, `rs.hashUsize`, `rs.hashIsize`, `rs.hashStr`, +and `rs.hashBytes`, so values `eq` finds equal hash alike, and `cmp` orders as it does. A collection finds even a bound value that is a JS primitive by these, never by `===`. A missing one fails at its impl, as any missing export does. @@ -816,7 +816,7 @@ stand-ins for V8 and JavaScriptCore, as Safari runs it; where any engine disagre Chrome, Chrome decides. It stays `.ts`, so `tsc` keeps checking the internals, and minifying is the consumer's bundler's job. Types must be solid at the API boundary: the `roots` items and -`printable` types use Rust's branded types (`rt.u64`), while internals cast as freely as +`printable` types use Rust's branded types (`rs.u64`), while internals cast as freely as they need. - 64- and 128-bit integers are numbers while they are safe integers, which most values @@ -825,7 +825,7 @@ they need. numbers in locals, fields, and arguments. It ties unboxed halves on the codec and beats `bigint` there in Node, Bun, and Chrome: varint encode 13-65% faster, frame decode 8-32%, and message decode 22-31%, though Chrome's 8-byte varint decode is - 25-45% slower; joining a varint's halves in one call, `rt.u64FromHalves`, makes that + 25-45% slower; joining a varint's halves in one call, `rs.u64FromHalves`, makes that decode 1.05-1.2x faster in Chrome. A loop of sums and comparisons past 2^32 measured 2-6x faster. Limbs for every value allocate an object each, which costs what a `bigint` does in V8, so they lost decode; unboxed halves would lower every value to @@ -860,9 +860,9 @@ they need. type's module (`export * as Decoder`) still shakes in Bun and Rollup but not in esbuild ([evanw/esbuild#1420](https://github.com/evanw/esbuild/issues/1420)), which keeps the whole module: 10.2 KB gzipped against 8.3 for the decoding caller. -- The runtime is free functions too, flat exports of `rt.ts` named for what they act on - (`rt.u64Add`, `rt.iterMap`, `rt.fmtPad`), so a bundler drops every one translated code - never calls. `rt.ts` re-exports its parts with `export *`, since esbuild keeps a whole +- The runtime is free functions too, flat exports of `rs.ts` named for what they act on + (`rs.u64Add`, `rs.iterMap`, `rs.fmtPad`), so a bundler drops every one translated code + never calls. `rs.ts` re-exports its parts with `export *`, since esbuild keeps a whole `export * as` namespace. A method stays only where a call dispatches on its receiver: an iterator's `next`, a future's `poll`, a waker's, and `[Symbol.dispose]`. Each integer type's functions pass their bounds or width to shared helpers, with a wide @@ -879,14 +879,14 @@ they need. (`Wrap$Pair`) would rename the type for callers, and TS generics with trait dictionaries would undo monomorphization. - `None` is `undefined`, so a TS caller reads an `Option` with `?.` and `??`, except where - the `Some` can already be `undefined`: there it is `rt.None`, as `Pending` is - `rt.Pending`, chosen by the type alone, so every function agrees on it. A `rt.None` + the `Some` can already be `undefined`: there it is `rs.None`, as `Pending` is + `rs.Pending`, chosen by the type alone, so every function agrees on it. A `rs.None` for every `Option` would cost callers `?.` and `??` everywhere for the few that need it. - A `Cow` is a JS string, as `str` and `String` are, rather than an object tagged by its variant: no `Cow` in moq-net or kio tells its variants apart, and a tag would wrap every value and unwrap it at every read. - A `Cow<[T]>` is told apart by class, an owned one bare and a borrowed one in an - `rt.Borrowed`, so it clones and drops as std's does and only the borrowed side pays a + `rs.Borrowed`, so it clones and drops as std's does and only the borrowed side pays a wrapper. Untagged, as `Cow` is, `to_mut` would clone on every call and a `match` would be refused; tagged, every `Cow` would be wrapped. - A `Duration` keeps std's fields, whole seconds and nanoseconds, rather than one count @@ -900,13 +900,13 @@ they need. it in Chrome, 0.75 in Firefox, and 0.75 in Bun at the geometric mean, with A/A within 0.03 in Chrome and Node within its noise. Sharing a result of any other constant, such as `Err(DecodeError::Short)`, measured no faster on the decodes that return it. -- A `&[u8]` is an `rt.ByteSlice` rather than a `Uint8Array` view, since a view costs +- A `&[u8]` is an `rs.ByteSlice` rather than a `Uint8Array` view, since a view costs several times what an object does to make in V8 and JavaScriptCore, and a varint's decode splits its slice once to four times. `just ts bench` measured the codec's decode workloads at 0.75 times the views' time in Chrome, 0.81-0.84 in Node, and 0.82-0.85 in Bun at the geometric mean, over two runs whose A/A route measured within 0.05 of them, and encode no slower. A `&[u8; N]`, such as `split_first_chunk`'s chunk, is an - `rt.ByteSlice` too, its bytes read in place: the decode workloads then took 0.72 times + `rs.ByteSlice` too, its bytes read in place: the decode workloads then took 0.72 times a view's time in Chrome, 0.67 in Firefox, 0.87 in Node, and 0.71 in Bun at the geometric mean, with the A/A route within 0.03, and encode no slower. - A run of bytes `as_chunks_mut` lends is a `Uint8Array` view, which a whole write of @@ -925,7 +925,7 @@ they need. times the objects' time in Chrome, 0.57 in Firefox, 0.64 in Node, and 0.56 in Bun at the geometric mean, and frame decode at 0.61, 0.56, 0.70, and 0.61, with the A/A route within 0.04 and encode no slower. A tuple or `Result` of numbers alone is held so only - where it meets a slot below, and its object, such as an `rt.Ok`, counts as made at each + where it meets a slot below, and its object, such as an `rs.Ok`, counts as made at each read that makes it. An `Option` of a number is one part, that or `undefined`, as its JS value is. A return is still a `ByteSlice` but for the `Result`s below. - A function only translated code calls takes each `&[u8]` or `&[u8; N]` parameter as @@ -974,7 +974,7 @@ they need. whose length is std's capacity, a `Uint8Array` of bytes, and each step places its items where std's does, so `as_slices` splits them as std's; one made from a `Vec` takes the capacity held for the `Vec`, and a `Vec` made from one takes its. A `Vec` and `BinaryHeap` hold std's - capacity exactly: an `rt.Vec` holds the capacity, as `cap`, that the last step that + capacity exactly: an `rs.Vec` holds the capacity, as `cap`, that the last step that fixes it set, as `with_capacity`, `reserve`, `shrink_to`, a `clone`, or a `collect` does, and, as `peak`, the most it held before a step that shortened it, so a push never reads or writes either. Reading it doubles `cap` while short of the longer of its length @@ -982,7 +982,7 @@ they need. pushes grows std's. Holding the capacity on each push instead took up to 1.7x as long on `push/vec`, and tracking it on each pop up to 2.8x on `push/stack` (decided with the maintainer on 2026-11-03). A `Vec`'s is its buffer's length, so its - `spare_capacity_mut` is an `rt.ByteSlice` of the buffer past its length, which `set_len` + `spare_capacity_mut` is an `rs.ByteSlice` of the buffer past its length, which `set_len` takes in, panicking past the capacity as std's check does, which can't unwind; any other `Vec`'s is refused, as no JS array holds room past its length. Their `try_reserve` and `try_reserve_exact`, and a `String`'s, give `Ok` where `reserve` makes room and `TryReserveError`'s @@ -1002,20 +1002,20 @@ they need. comparing it, and each engine orders its comparisons differently. A byte slice's sorts by its own `Ord` are its typed array's, whose order nothing observes. `sort_by_cached_key` sorts its keys paired with their indexes by that `sort_unstable`. -- A `BinaryHeap` is std's heap in an `rt.Vec`, with std's sifts ported to the runtime: std's +- A `BinaryHeap` is std's heap in an `rs.Vec`, with std's sifts ported to the runtime: std's move elements through raw pointers into its `Vec`, which no body of std's lowers through, and the sifts decide which `PartialOrd` tests run and which of equal elements leaves first. `Vec::drain`, `splice`, and `extract_if`, and `VecDeque`'s rotations and `make_contiguous`, are ported for the same reason: std's move elements through raw pointers. The sorts, `max` and `min`, the heap, - and `is_sorted` take an integer's tests as the runtime's `rt.lt`, `rt.le`, `rt.gt`, - and `rt.ge` rather than through its `partial_cmp`, `rt.cmpLt(rt.cmp)`: on `just ts + and `is_sorted` take an integer's tests as the runtime's `rs.lt`, `rs.le`, `rs.gt`, + and `rs.ge` rather than through its `partial_cmp`, `rs.cmpLt(rs.cmp)`: on `just ts bench`'s `order/` workloads that took Firefox 0.8-0.86x the time on sorts and `max`/`min` and Chrome 0.66x on the heap, and Chrome the same on the rest. - Iterators are the runtime's lazy classes rather than generators or ES iterator helpers: std's adaptors would lower from std's own bodies, whose slice iterators are raw pointers, ES helpers lack most of them - (`rev`, `zip`, `peekable`), and a `next` returning an item or `rt.DONE` allocates + (`rev`, `zip`, `peekable`), and a `next` returning an item or `rs.DONE` allocates nothing per item. `just ts bench` measures chains of `map`, `filter`, `any`, `skip`, and `take` 1.4-8x faster than the same ES helpers in Node, Bun, and Chrome. - Bodies lower from MIR, not THIR: drops are where drop elaboration put them, exact by @@ -1049,7 +1049,7 @@ These fail translation: `f16` and `f128`, a `Poll` of a `Poll` of a `Poll`, a fu that drops given to a std function that keeps it other than in an iterator or a `poll_fn`, or whose mapping doesn't drop it where std's does, a `Cow` of other than `str` or a slice, a std function without a mapping of its own that makes or reads an `Option` whose `None` is -`rt.None`, an `Option` of an `Option` of `()` or another +`rs.None`, an `Option` of an `Option` of `()` or another `Option`, an instance of a generic type whose field is an `Option` of a type parameter that can be `undefined`, a `String`'s `capacity`, looking up a key by another type it borrows as through the crate's own `Borrow`, a `&mut` to a value JS @@ -1158,7 +1158,7 @@ so adding, removing, or reordering a case changes no other case's inputs. - `census` holds a few constructs translation refuses for good, whose census, with its totals, is `census.md`. -`tests/spawn.ts` checks that `rt.spawn` yields to a timer after its 128-poll budget, +`tests/spawn.ts` checks that `rs.spawn` yields to a timer after its 128-poll budget, rejects when a future panics as it drops, and drops a future when its signal aborts: before its first poll, while pending, and from within its own poll. `tests/retain.ts` runs a collection's `retain` and `Vec::dedup_by` over every keep mask of up to 6 items, and `retain` checks that each @@ -1200,7 +1200,7 @@ starts, and one that runs 30 s fails the run, naming it. The task fixture's `bench::run` times an async handoff: a value sent to a task parked on its channel, read through 1, 4, or 16 async functions. Its translation runs polled at -once, as natively, and on `rt.spawn`; its hand-written route is the same handoff with +once, as natively, and on `rs.spawn`; its hand-written route is the same handoff with promises, as moq's TypeScript writes it. An A/B run times another translator's output as one more route: run `just ts bench` in diff --git a/ts/bench/iter.ts b/ts/bench/iter.ts index 947cea042..896e8ca80 100644 --- a/ts/bench/iter.ts +++ b/ts/bench/iter.ts @@ -1,6 +1,6 @@ // The iterator workloads' hand-written route: each chain in the codec fixture's // `bench.rs` op 6, written with ES iterator helpers (`Iterator.prototype.map` and the -// rest), as TypeScript would write it without the translation's `rt.Iter`. Helpers +// rest), as TypeScript would write it without the translation's `rs.Iter`. Helpers // without an ES counterpart, `enumerate` and `zip` here, are a `for ... of` with a counter. /** Run one chain, as `bench::run`'s op 6 does, over `data`. */ diff --git a/ts/bench/main.ts b/ts/bench/main.ts index a5deecf87..7f3693669 100644 --- a/ts/bench/main.ts +++ b/ts/bench/main.ts @@ -107,10 +107,10 @@ async function codecEntry(dir: string): Promise { const entry = join(dir, "bench-entry.ts"); await Bun.write( entry, - `import * as rt from "./rt.ts"; + `import * as rs from "./rs.ts"; import { run as bench } from "./bench.ts"; -export const run = (input: Uint8Array) => bench(rt.byteSliceFrom(input)); +export const run = (input: Uint8Array) => bench(rs.byteSliceFrom(input)); `, ); return entry; @@ -125,12 +125,12 @@ async function taskEntry(dir: string): Promise { const entry = join(dir, "bench-entry.ts"); await Bun.write( entry, - `import * as rt from "./rt.ts"; + `import * as rs from "./rs.ts"; import * as Channel from "./model.Channel.ts"; import { drain } from "./model.ts"; import { polled, spawned } from ${JSON.stringify(join(import.meta.dir, "task.ts"))}; -const fixture = { Pending: rt.Pending, spawn: rt.spawn, Channel, drain }; +const fixture = { Pending: rs.Pending, spawn: rs.spawn, Channel, drain }; export const run = polled(fixture); export const spawn = spawned(fixture); `, diff --git a/ts/fixtures/bind/bind/blob.ts b/ts/fixtures/bind/bind/blob.ts index cb5a5ee0b..c9293098c 100644 --- a/ts/fixtures/bind/bind/blob.ts +++ b/ts/fixtures/bind/bind/blob.ts @@ -1,19 +1,19 @@ // `blob::Blob`, which contains `unsafe`: immutable bytes that its slices and clones // share, as a byte slice of them is. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Blob = rt.ByteSlice; +export type Blob = rs.ByteSlice; -export function copyFromSlice(data: rt.ByteSlice): Blob { - return rt.byteSliceFrom(rt.byteSliceView(data).slice()); +export function copyFromSlice(data: rs.ByteSlice): Blob { + return rs.byteSliceFrom(rs.byteSliceView(data).slice()); } -export function from$convert_From_Vec_u8(vec: rt.ByteVec): Blob { - return rt.byteVecSlice(vec); +export function from$convert_From_Vec_u8(vec: rs.ByteVec): Blob { + return rs.byteVecSlice(vec); } -export function len(self: Blob): rt.usize { +export function len(self: Blob): rs.usize { return self.length; } @@ -24,43 +24,43 @@ export function isEmpty(self: Blob): boolean { /** Over each range translated code makes: `a..b`, `a..=b`, `a..`, `..b`, and `..`. */ export function slice( self: Blob, - range: rt.Range | rt.RangeInclusive | { start: rt.usize } | { end: rt.usize } | undefined, + range: rs.Range | rs.RangeInclusive | { start: rs.usize } | { end: rs.usize } | undefined, ): Blob { let begin = 0; let end = self.length; - if (range instanceof rt.RangeInclusive) { + if (range instanceof rs.RangeInclusive) { begin = range.lo; - end = rt.usizeAdd(range.hi, 1); + end = rs.usizeAdd(range.hi, 1); } else if (range !== undefined) { if ("start" in range) begin = range.start; if ("end" in range) end = range.end; } - if (begin > end) rt.panic(`range start must not be greater than end: ${begin} <= ${end}`); - if (end > self.length) rt.panic(`range end out of bounds: ${end} <= ${self.length}`); - return new rt.ByteSlice(self.data, self.start + begin, end - begin); + if (begin > end) rs.panic(`range start must not be greater than end: ${begin} <= ${end}`); + if (end > self.length) rs.panic(`range end out of bounds: ${end} <= ${self.length}`); + return new rs.ByteSlice(self.data, self.start + begin, end - begin); } export function clone$Clone(self: Blob): Blob { return self; } -export function deref$ops_Deref(self: Blob): rt.ByteSlice { +export function deref$ops_Deref(self: Blob): rs.ByteSlice { return self; } export function eq$cmp_PartialEq(self: Blob, other: Blob): boolean { - return rt.byteSliceEq(self, other); + return rs.byteSliceEq(self, other); } -export function hash$Hash(self: Blob, state: rt.Hasher): undefined { - rt.hashBytes(self, state); +export function hash$Hash(self: Blob, state: rs.Hasher): undefined { + rs.hashBytes(self, state); return undefined; } -export function partialCmp$cmp_PartialOrd(self: Blob, other: Blob): rt.Ordering { - return rt.cmpBytes(self, other); +export function partialCmp$cmp_PartialOrd(self: Blob, other: Blob): rs.Ordering { + return rs.cmpBytes(self, other); } -export function cmp$cmp_Ord(self: Blob, other: Blob): rt.Ordering { - return rt.cmpBytes(self, other); +export function cmp$cmp_Ord(self: Blob, other: Blob): rs.Ordering { + return rs.cmpBytes(self, other); } diff --git a/ts/fixtures/bind/bind/checksum.ts b/ts/fixtures/bind/bind/checksum.ts index 53d1b1a45..226685821 100644 --- a/ts/fixtures/bind/bind/checksum.ts +++ b/ts/fixtures/bind/bind/checksum.ts @@ -1,8 +1,8 @@ // `raw::checksum`, which reads through a raw pointer. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; -export function checksum(bytes: rt.ByteSlice): rt.u32 { +export function checksum(bytes: rs.ByteSlice): rs.u32 { let sum = 0; for (let i = 0; i < bytes.length; i++) sum = (Math.imul(sum, 31) + bytes.data[bytes.start + i]) >>> 0; return sum; diff --git a/ts/fixtures/bind/bind/nibble.ts b/ts/fixtures/bind/bind/nibble.ts index fd1d92954..9135fa066 100644 --- a/ts/fixtures/bind/bind/nibble.ts +++ b/ts/fixtures/bind/bind/nibble.ts @@ -1,16 +1,16 @@ // `key::Nibble`, a byte that compares, hashes, and orders by its low four bits, which the // `===` of its number would not. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Nibble = rt.u8; +export type Nibble = rs.u8; -function make(byte: rt.u8): Nibble { +function make(byte: rs.u8): Nibble { return byte; } export { make as new }; -export function get(self: Nibble): rt.u8 { +export function get(self: Nibble): rs.u8 { return self; } @@ -18,15 +18,15 @@ export function eq$cmp_PartialEq(self: Nibble, other: Nibble): boolean { return (self & 0xf) === (other & 0xf); } -export function hash$Hash(self: Nibble, state: rt.Hasher): undefined { - rt.hash8(self & 0xf, state); +export function hash$Hash(self: Nibble, state: rs.Hasher): undefined { + rs.hash8(self & 0xf, state); return undefined; } -export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rt.Ordering { +export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rs.Ordering { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Nibble, other: Nibble): rt.Ordering { - return rt.cmp(self & 0xf, other & 0xf); +export function cmp$cmp_Ord(self: Nibble, other: Nibble): rs.Ordering { + return rs.cmp(self & 0xf, other & 0xf); } diff --git a/ts/fixtures/bind/bind/skip.ts b/ts/fixtures/bind/bind/skip.ts index 90676bfaf..fe4dcf198 100644 --- a/ts/fixtures/bind/bind/skip.ts +++ b/ts/fixtures/bind/bind/skip.ts @@ -1,7 +1,7 @@ // `raw::skip`, which reads through a raw pointer. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; -export function skip(bytes: rt.ByteSlice, at: rt.Place): undefined { +export function skip(bytes: rs.ByteSlice, at: rs.Place): undefined { while (at.v < bytes.length && bytes.data[bytes.start + at.v] === 0) at.v++; } diff --git a/ts/fixtures/bind/bind/tally.ts b/ts/fixtures/bind/bind/tally.ts index dd9fc8be8..30e596c89 100644 --- a/ts/fixtures/bind/bind/tally.ts +++ b/ts/fixtures/bind/bind/tally.ts @@ -1,25 +1,25 @@ // `raw::Tally`, which holds its `Arc` by a raw pointer, and drops it where Rust drops // the tally. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; export class Tally implements Disposable { - readonly count: rt.Arc; + readonly count: rs.Arc; - constructor(count: rt.Arc) { - this.count = rt.arcClone(count); + constructor(count: rs.Arc) { + this.count = rs.arcClone(count); } [Symbol.dispose](): void { - rt.arcDrop(this.count); + rs.arcDrop(this.count); } } -function make(count: rt.Arc): Tally { +function make(count: rs.Arc): Tally { return new Tally(count); } export { make as new }; -export function get(self: Tally): rt.u32 { +export function get(self: Tally): rs.u32 { return self.count.value; } diff --git a/ts/fixtures/bind/expected/bind/blob.ts b/ts/fixtures/bind/expected/bind/blob.ts index 6a6448233..b15c6361f 100644 --- a/ts/fixtures/bind/expected/bind/blob.ts +++ b/ts/fixtures/bind/expected/bind/blob.ts @@ -2,19 +2,19 @@ // `blob::Blob`, which contains `unsafe`: immutable bytes that its slices and clones // share, as a byte slice of them is. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Blob = rt.ByteSlice; +export type Blob = rs.ByteSlice; -export function copyFromSlice(data: rt.ByteSlice): Blob { - return rt.byteSliceFrom(rt.byteSliceView(data).slice()); +export function copyFromSlice(data: rs.ByteSlice): Blob { + return rs.byteSliceFrom(rs.byteSliceView(data).slice()); } -export function from$convert_From_Vec_u8(vec: rt.ByteVec): Blob { - return rt.byteVecSlice(vec); +export function from$convert_From_Vec_u8(vec: rs.ByteVec): Blob { + return rs.byteVecSlice(vec); } -export function len(self: Blob): rt.usize { +export function len(self: Blob): rs.usize { return self.length; } @@ -25,43 +25,43 @@ export function isEmpty(self: Blob): boolean { /** Over each range translated code makes: `a..b`, `a..=b`, `a..`, `..b`, and `..`. */ export function slice( self: Blob, - range: rt.Range | rt.RangeInclusive | { start: rt.usize } | { end: rt.usize } | undefined, + range: rs.Range | rs.RangeInclusive | { start: rs.usize } | { end: rs.usize } | undefined, ): Blob { let begin = 0; let end = self.length; - if (range instanceof rt.RangeInclusive) { + if (range instanceof rs.RangeInclusive) { begin = range.lo; - end = rt.usizeAdd(range.hi, 1); + end = rs.usizeAdd(range.hi, 1); } else if (range !== undefined) { if ("start" in range) begin = range.start; if ("end" in range) end = range.end; } - if (begin > end) rt.panic(`range start must not be greater than end: ${begin} <= ${end}`); - if (end > self.length) rt.panic(`range end out of bounds: ${end} <= ${self.length}`); - return new rt.ByteSlice(self.data, self.start + begin, end - begin); + if (begin > end) rs.panic(`range start must not be greater than end: ${begin} <= ${end}`); + if (end > self.length) rs.panic(`range end out of bounds: ${end} <= ${self.length}`); + return new rs.ByteSlice(self.data, self.start + begin, end - begin); } export function clone$Clone(self: Blob): Blob { return self; } -export function deref$ops_Deref(self: Blob): rt.ByteSlice { +export function deref$ops_Deref(self: Blob): rs.ByteSlice { return self; } export function eq$cmp_PartialEq(self: Blob, other: Blob): boolean { - return rt.byteSliceEq(self, other); + return rs.byteSliceEq(self, other); } -export function hash$Hash(self: Blob, state: rt.Hasher): undefined { - rt.hashBytes(self, state); +export function hash$Hash(self: Blob, state: rs.Hasher): undefined { + rs.hashBytes(self, state); return undefined; } -export function partialCmp$cmp_PartialOrd(self: Blob, other: Blob): rt.Ordering { - return rt.cmpBytes(self, other); +export function partialCmp$cmp_PartialOrd(self: Blob, other: Blob): rs.Ordering { + return rs.cmpBytes(self, other); } -export function cmp$cmp_Ord(self: Blob, other: Blob): rt.Ordering { - return rt.cmpBytes(self, other); +export function cmp$cmp_Ord(self: Blob, other: Blob): rs.Ordering { + return rs.cmpBytes(self, other); } diff --git a/ts/fixtures/bind/expected/bind/checksum.ts b/ts/fixtures/bind/expected/bind/checksum.ts index d683fc9c9..2710d2ab5 100644 --- a/ts/fixtures/bind/expected/bind/checksum.ts +++ b/ts/fixtures/bind/expected/bind/checksum.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. // `raw::checksum`, which reads through a raw pointer. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; -export function checksum(bytes: rt.ByteSlice): rt.u32 { +export function checksum(bytes: rs.ByteSlice): rs.u32 { let sum = 0; for (let i = 0; i < bytes.length; i++) sum = (Math.imul(sum, 31) + bytes.data[bytes.start + i]) >>> 0; return sum; diff --git a/ts/fixtures/bind/expected/bind/nibble.ts b/ts/fixtures/bind/expected/bind/nibble.ts index dc6597182..72e8adead 100644 --- a/ts/fixtures/bind/expected/bind/nibble.ts +++ b/ts/fixtures/bind/expected/bind/nibble.ts @@ -2,16 +2,16 @@ // `key::Nibble`, a byte that compares, hashes, and orders by its low four bits, which the // `===` of its number would not. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Nibble = rt.u8; +export type Nibble = rs.u8; -function make(byte: rt.u8): Nibble { +function make(byte: rs.u8): Nibble { return byte; } export { make as new }; -export function get(self: Nibble): rt.u8 { +export function get(self: Nibble): rs.u8 { return self; } @@ -19,15 +19,15 @@ export function eq$cmp_PartialEq(self: Nibble, other: Nibble): boolean { return (self & 0xf) === (other & 0xf); } -export function hash$Hash(self: Nibble, state: rt.Hasher): undefined { - rt.hash8(self & 0xf, state); +export function hash$Hash(self: Nibble, state: rs.Hasher): undefined { + rs.hash8(self & 0xf, state); return undefined; } -export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rt.Ordering { +export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rs.Ordering { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Nibble, other: Nibble): rt.Ordering { - return rt.cmp(self & 0xf, other & 0xf); +export function cmp$cmp_Ord(self: Nibble, other: Nibble): rs.Ordering { + return rs.cmp(self & 0xf, other & 0xf); } diff --git a/ts/fixtures/bind/expected/bind/skip.ts b/ts/fixtures/bind/expected/bind/skip.ts index 3921bfb9e..ce0ecec4c 100644 --- a/ts/fixtures/bind/expected/bind/skip.ts +++ b/ts/fixtures/bind/expected/bind/skip.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. // `raw::skip`, which reads through a raw pointer. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; -export function skip(bytes: rt.ByteSlice, at: rt.Place): undefined { +export function skip(bytes: rs.ByteSlice, at: rs.Place): undefined { while (at.v < bytes.length && bytes.data[bytes.start + at.v] === 0) at.v++; } diff --git a/ts/fixtures/bind/expected/bind/tally.ts b/ts/fixtures/bind/expected/bind/tally.ts index 007d0ed42..bfbe1f360 100644 --- a/ts/fixtures/bind/expected/bind/tally.ts +++ b/ts/fixtures/bind/expected/bind/tally.ts @@ -2,25 +2,25 @@ // `raw::Tally`, which holds its `Arc` by a raw pointer, and drops it where Rust drops // the tally. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; export class Tally implements Disposable { - readonly count: rt.Arc; + readonly count: rs.Arc; - constructor(count: rt.Arc) { - this.count = rt.arcClone(count); + constructor(count: rs.Arc) { + this.count = rs.arcClone(count); } [Symbol.dispose](): void { - rt.arcDrop(this.count); + rs.arcDrop(this.count); } } -function make(count: rt.Arc): Tally { +function make(count: rs.Arc): Tally { return new Tally(count); } export { make as new }; -export function get(self: Tally): rt.u32 { +export function get(self: Tally): rs.u32 { return self.count.value; } diff --git a/ts/fixtures/bind/expected/core/option.ts b/ts/fixtures/bind/expected/core/option.ts index 261f6df81..8c663de6e 100644 --- a/ts/fixtures/bind/expected/core/option.ts +++ b/ts/fixtures/bind/expected/core/option.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Nibble from "../bind/nibble.ts"; -export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$0yvilko(self: rs.ByteSlice | undefined, default_: rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$174crag(self: Nibble.Nibble | undefined, default_: rt.u8, f: (a0: Nibble.Nibble) => rt.u8): rt.u8 { +export function mapOr$0oywhrg(self: Nibble.Nibble | undefined, default_: rs.u8, f: (a0: Nibble.Nibble) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/bind/expected/harness.ts b/ts/fixtures/bind/expected/harness.ts index fa1a90457..9862382a7 100644 --- a/ts/fixtures/bind/expected/harness.ts +++ b/ts/fixtures/bind/expected/harness.ts @@ -1,76 +1,76 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Blob from "./bind/blob.ts"; import * as checksum from "./bind/checksum.ts"; import * as Nibble from "./bind/nibble.ts"; import * as skip from "./bind/skip.ts"; import * as Tally from "./bind/tally.ts"; -import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$174crag as option_mapOr$174crag } from "./core/option.ts"; +import { unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$0oywhrg as option_mapOr$0oywhrg } from "./core/option.ts"; /** * Split the input as `Blob`, compare and hash the parts, skip its leading zeros, and * count tallies down as they drop, then key collections by bound types. A first byte of * 1 slices out of order, which panics. */ -export function run(input: rt.ByteSlice): rt.ByteVec { +export function run(input: rs.ByteSlice): rs.ByteVec { let _128: boolean = false; - const out: rt.ByteVec = new rt.ByteVec(); + const out: rs.ByteVec = new rs.ByteVec(); const bytes: Blob.Blob = Blob.copyFromSlice(input); - const mid: rt.usize = rt.usizeDiv(Blob.len(bytes), 2); + const mid: rs.usize = rs.usizeDiv(Blob.len(bytes), 2); const head: Blob.Blob = Blob.slice(bytes, { end: mid }); - const tail: Blob.Blob = Blob.slice(bytes, new rt.RangeFrom(mid, rt.usizeStep)); - const _16: rt.Range = new rt.Range(rt.min(1, mid), mid); + const tail: Blob.Blob = Blob.slice(bytes, new rs.RangeFrom(mid, rs.usizeStep)); + const _16: rs.Range = new rs.Range(rs.min(1, mid), mid); const inner: Blob.Blob = Blob.slice(bytes, _16); - const _20: rt.u8 = Blob.len(head) & 0xff; - rt.byteVecPush(out, _20); - const _25: rt.u8 = Blob.len(inner) & 0xff; - rt.byteVecPush(out, _25); - const _30: rt.ByteSlice = Blob.deref$ops_Deref(tail); - rt.byteVecExtendFromSlice(out, _30); - const _34: rt.u8 = Blob.eq$cmp_PartialEq(head, tail) ? 1 : 0; - rt.byteVecPush(out, _34); - const _40: rt.u8 = Blob.eq$cmp_PartialEq(Blob.clone$Clone(head), head) ? 1 : 0; - rt.byteVecPush(out, _40); - const _48: rt.u8 = Blob.eq$cmp_PartialEq(Blob.from$convert_From_Vec_u8(rt.byteSliceToByteVec(input)), bytes) ? 1 : 0; - rt.byteVecPush(out, _48); - const _56: rt.u8 = Blob.isEmpty(bytes) ? 1 : 0; - rt.byteVecPush(out, _56); - const sum: rt.u32 = checksum.checksum(Blob.deref$ops_Deref(tail)); - const iter: rt.Iter = rt.iterSlice([0, 8, 16, 24]); + const _20: rs.u8 = Blob.len(head) & 0xff; + rs.byteVecPush(out, _20); + const _25: rs.u8 = Blob.len(inner) & 0xff; + rs.byteVecPush(out, _25); + const _30: rs.ByteSlice = Blob.deref$ops_Deref(tail); + rs.byteVecExtendFromSlice(out, _30); + const _34: rs.u8 = Blob.eq$cmp_PartialEq(head, tail) ? 1 : 0; + rs.byteVecPush(out, _34); + const _40: rs.u8 = Blob.eq$cmp_PartialEq(Blob.clone$Clone(head), head) ? 1 : 0; + rs.byteVecPush(out, _40); + const _48: rs.u8 = Blob.eq$cmp_PartialEq(Blob.from$convert_From_Vec_u8(rs.byteSliceToByteVec(input)), bytes) ? 1 : 0; + rs.byteVecPush(out, _48); + const _56: rs.u8 = Blob.isEmpty(bytes) ? 1 : 0; + rs.byteVecPush(out, _56); + const sum: rs.u32 = checksum.checksum(Blob.deref$ops_Deref(tail)); + const iter: rs.Iter = rs.iterSlice([0, 8, 16, 24]); while (true) { - const _65: rt.i32 | rt.Done = iter.next(); - if (_65 === rt.DONE) { + const _65: rs.i32 | rs.Done = iter.next(); + if (_65 === rs.DONE) { break; } - rt.byteVecPush(out, rt.u32Shr(sum, _65) & 0xff); + rs.byteVecPush(out, rs.u32Shr(sum, _65) & 0xff); } - let at: rt.usize = 0; - skip.skip(input, rt.place(() => at, (value) => at = value)); - rt.byteVecPush(out, at & 0xff); - if (rt.byteSliceFirst(input) === 1) { - const _88: rt.Range = new rt.Range(mid, rt.usizeSaturatingSub(mid, 1)); + let at: rs.usize = 0; + skip.skip(input, rs.place(() => at, (value) => at = value)); + rs.byteVecPush(out, at & 0xff); + if (rs.byteSliceFirst(input) === 1) { + const _88: rs.Range = new rs.Range(mid, rs.usizeSaturatingSub(mid, 1)); Blob.slice(bytes, _88); } - const count: rt.Arc = new rt.Arc(input.length as rt.u32); + const count: rs.Arc = new rs.Arc(input.length as rs.u32); const a: Tally.Tally = Tally.new(count); const b: Tally.Tally = Tally.new(count); - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); a[Symbol.dispose](); - rt.byteVecPush(out, count.strong & 0xff); - const _110: rt.u8 = Tally.get(b) & 0xff; - rt.byteVecPush(out, _110); + rs.byteVecPush(out, count.strong & 0xff); + const _110: rs.u8 = Tally.get(b) & 0xff; + rs.byteVecPush(out, _110); _128 = true; const held: Tally.Tally | undefined = b; - if (rt.byteSliceFirst(input) === 2) { + if (rs.byteSliceFirst(input) === 2) { _128 = false; - rt.drop(held); + rs.drop(held); } - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); keys(input, bytes, out); - const _0: rt.ByteVec = out; + const _0: rs.ByteVec = out; if (_128) { - rt.drop(held); + rs.drop(held); } _128 = false; count[Symbol.dispose](); @@ -81,81 +81,81 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * Collections keyed by `Blob`s, equal by their bytes wherever they are sliced from, and by * `Nibble`s, equal by their low bits: what each finds, keeps, and orders. */ -export function keys(input: rt.ByteSlice, bytes: Blob.Blob, out: rt.ByteVec): void { - let _12!: rt.usize; - let _143!: rt.u8; - const seen: rt.HashSet = rt.hashNew(rt.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rt.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rt.HashSet; - const counts: rt.HashMap = rt.hashNew(rt.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rt.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rt.HashMap; - const sorted: rt.BTreeSet = rt.btreeNew(Blob.cmp$cmp_Ord) as rt.BTreeSet; - const firsts: rt.BTreeMap = rt.btreeNew(Blob.cmp$cmp_Ord) as rt.BTreeMap; - const _10: rt.usize = Blob.len(bytes); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _10; +export function keys(input: rs.ByteSlice, bytes: Blob.Blob, out: rs.ByteVec): void { + let _12!: rs.usize; + let _143!: rs.u8; + const seen: rs.HashSet = rs.hashNew(rs.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rs.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rs.HashSet; + const counts: rs.HashMap = rs.hashNew(rs.hashing(Blob.hash$Hash as (a0: Blob.Blob, a1: rs.Hasher) => undefined, Blob.eq$cmp_PartialEq, true)) as rs.HashMap; + const sorted: rs.BTreeSet = rs.btreeNew(Blob.cmp$cmp_Ord) as rs.BTreeSet; + const firsts: rs.BTreeMap = rs.btreeNew(Blob.cmp$cmp_Ord) as rs.BTreeMap; + const _10: rs.usize = Blob.len(bytes); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _10; while ((_12 = iterStart++) < iterEnd) { - const at: rt.usize = _12; - const part: Blob.Blob = Blob.slice(bytes, new rt.Range(at, rt.min(rt.usizeAdd(at, 2), Blob.len(bytes)))); + const at: rs.usize = _12; + const part: Blob.Blob = Blob.slice(bytes, new rs.Range(at, rs.min(rs.usizeAdd(at, 2), Blob.len(bytes)))); const _26: Blob.Blob = Blob.clone$Clone(part); - rt.byteVecPush(out, rt.hashAdd(seen, _26) ? 1 : 0); + rs.byteVecPush(out, rs.hashAdd(seen, _26) ? 1 : 0); const _31: Blob.Blob = Blob.clone$Clone(part); - const _28: rt.Place = rt.entryOrInsertMut(rt.entry(counts, _31), 0); - _28.v = rt.u8Add(_28.v, 1); + const _28: rs.Place = rs.entryOrInsertMut(rs.entry(counts, _31), 0); + _28.v = rs.u8Add(_28.v, 1); const _36: Blob.Blob = Blob.clone$Clone(part); - rt.btreeAdd(sorted, _36); - rt.entryOrInsertMut(rt.entry(firsts, part), at & 0xff); + rs.btreeAdd(sorted, _36); + rs.entryOrInsertMut(rs.entry(firsts, part), at & 0xff); } - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - rt.byteVecPush(out, rt.hashLen(counts) & 0xff); - const probe: Blob.Blob = Blob.copyFromSlice(option_unwrapOr$1rbuegs(rt.byteSliceGetRange(input, 0, 2), input)); - rt.byteVecPush(out, rt.hashContains(seen, probe) ? 1 : 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(counts, probe), 0)); - rt.byteVecPush(out, rt.btreeContains(sorted, probe) ? 1 : 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeGet(firsts, probe), 255)); - const _81: rt.RangeFrom = new rt.RangeFrom(Blob.clone$Clone(probe)); - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(sorted, _81, Blob.eq$cmp_PartialEq, rt.cmpGt(Blob.partialCmp$cmp_PartialOrd))) & 0xff); - const iter2: rt.Iter<[Blob.Blob, rt.u8]> = rt.btreeIter(firsts); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); + rs.byteVecPush(out, rs.hashLen(counts) & 0xff); + const probe: Blob.Blob = Blob.copyFromSlice(option_unwrapOr$0yvilko(rs.byteSliceGetRange(input, 0, 2), input)); + rs.byteVecPush(out, rs.hashContains(seen, probe) ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(counts, probe), 0)); + rs.byteVecPush(out, rs.btreeContains(sorted, probe) ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(firsts, probe), 255)); + const _81: rs.RangeFrom = new rs.RangeFrom(Blob.clone$Clone(probe)); + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(sorted, _81, Blob.eq$cmp_PartialEq, rs.cmpGt(Blob.partialCmp$cmp_PartialOrd))) & 0xff); + const iter2: rs.Iter<[Blob.Blob, rs.u8]> = rs.btreeIter(firsts); while (true) { - const _87: [Blob.Blob, rt.u8] | rt.Done = iter2.next(); - if (_87 === rt.DONE) { + const _87: [Blob.Blob, rs.u8] | rs.Done = iter2.next(); + if (_87 === rs.DONE) { break; } - rt.byteVecPush(out, Blob.len(_87[0]) & 0xff); - rt.byteVecExtendFromSlice(out, Blob.deref$ops_Deref(_87[0])); - rt.byteVecPush(out, _87[1]); + rs.byteVecPush(out, Blob.len(_87[0]) & 0xff); + rs.byteVecExtendFromSlice(out, Blob.deref$ops_Deref(_87[0])); + rs.byteVecPush(out, _87[1]); } - rt.byteVecPush(out, rt.hashDelete(seen, probe) ? 1 : 0); - rt.byteVecPush(out, rt.btreeDelete(sorted, probe) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - const nibbles: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq, true)) as rt.HashSet; - const lasts: rt.HashMap = rt.hashNew(rt.hashing(Nibble.hash$Hash as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq, true)) as rt.HashMap; - const ordered: rt.BTreeSet = rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet; - const values: rt.BTreeMap = rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeMap; - for (const byte of rt.byteSliceView(input)) { + rs.byteVecPush(out, rs.hashDelete(seen, probe) ? 1 : 0); + rs.byteVecPush(out, rs.btreeDelete(sorted, probe) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); + const nibbles: rs.HashSet = rs.hashNew(rs.hashing(Nibble.hash$Hash as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq, true)) as rs.HashSet; + const lasts: rs.HashMap = rs.hashNew(rs.hashing(Nibble.hash$Hash as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq, true)) as rs.HashMap; + const ordered: rs.BTreeSet = rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet; + const values: rs.BTreeMap = rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeMap; + for (const byte of rs.byteSliceView(input)) { const key: Nibble.Nibble = Nibble.new(byte); - rt.byteVecPush(out, rt.hashAdd(nibbles, key) ? 1 : 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(lasts, key, byte), 255)); - rt.btreeAdd(ordered, key); - rt.btreeInsert(values, key, byte); + rs.byteVecPush(out, rs.hashAdd(nibbles, key) ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(lasts, key, byte), 255)); + rs.btreeAdd(ordered, key); + rs.btreeInsert(values, key, byte); } - rt.byteVecPush(out, rt.hashLen(nibbles) & 0xff); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 16; + rs.byteVecPush(out, rs.hashLen(nibbles) & 0xff); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 16; while ((_143 = iterStart2++) < iterEnd2) { - const key3: Nibble.Nibble = Nibble.new(rt.u8Mul(_143, 17)); - rt.byteVecPush(out, option_mapOr$174crag(rt.hashKey(nibbles, key3), 255, (n: Nibble.Nibble): rt.u8 => { + const key3: Nibble.Nibble = Nibble.new(rs.u8Mul(_143, 17)); + rs.byteVecPush(out, option_mapOr$0oywhrg(rs.hashKey(nibbles, key3), 255, (n: Nibble.Nibble): rs.u8 => { return Nibble.get(n); })); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(lasts, key3), 255)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(lasts, key3), 255)); } - const iter5: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.btreeIter(values); + const iter5: rs.Iter<[Nibble.Nibble, rs.u8]> = rs.btreeIter(values); while (true) { - const _164: [Nibble.Nibble, rt.u8] | rt.Done = iter5.next(); - if (_164 === rt.DONE) { + const _164: [Nibble.Nibble, rs.u8] | rs.Done = iter5.next(); + if (_164 === rs.DONE) { break; } - rt.byteVecPush(out, Nibble.get(_164[0])); - rt.byteVecPush(out, _164[1]); + rs.byteVecPush(out, Nibble.get(_164[0])); + rs.byteVecPush(out, _164[1]); } - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(ordered), (n2: Nibble.Nibble): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(ordered), (n2: Nibble.Nibble): rs.u8 => { return Nibble.get(n2); }), undefined, true); } diff --git a/ts/fixtures/bind/refused.toml b/ts/fixtures/bind/refused.toml index bdfab714c..2f009c7da 100644 --- a/ts/fixtures/bind/refused.toml +++ b/ts/fixtures/bind/refused.toml @@ -9,8 +9,8 @@ roots = ["harness::run", "harness::refused"] "raw" = "bind/raw.ts" "buf::Source" = "bind/source.ts" "raw::Tally::get" = { file = "bind/get.ts", drop = true } -"raw::Tally::new" = "rt/tally.ts" -"raw::Held::new" = "RT/held.ts" +"raw::Tally::new" = "rs/tally.ts" +"raw::Held::new" = "RS/held.ts" "buf::empty" = "../blob.ts" "buf::Blob" = "bind/blob.ts" # The crate renames the dependency, so its own name names nothing. diff --git a/ts/fixtures/bind/refused.txt b/ts/fixtures/bind/refused.txt index 6a4d9cda2..3043e59f4 100644 --- a/ts/fixtures/bind/refused.txt +++ b/ts/fixtures/bind/refused.txt @@ -2,9 +2,9 @@ binding `blob::Blob`: no such item, or more than one, in the crate or a crate it binding `buf::Source`: a binding is of a function or a type, not Trait binding `buf::empty`: ../blob.ts must be relative to ts.toml, inside its directory binding `nowhere::Thing`: no such item, or more than one, in the crate or a crate it depends on -binding `raw::Held::new`: RT/held.ts would replace the runtime, rt.ts and rt/ +binding `raw::Held::new`: RS/held.ts would replace the runtime, rs.ts and rs/ binding `raw::Tally::get`: only a type's value drops -binding `raw::Tally::new`: rt/tally.ts would replace the runtime, rt.ts and rt/ +binding `raw::Tally::new`: rs/tally.ts would replace the runtime, rs.ts and rs/ binding `raw::Tally`: bind/blob.ts binds another type binding `raw::checksum`: `checksum` binds the same item binding `raw`: a binding is of a function or a type, not Mod diff --git a/ts/fixtures/bind/wrong/blob.ts b/ts/fixtures/bind/wrong/blob.ts index 7dbe5d9d4..0cd7cecd2 100644 --- a/ts/fixtures/bind/wrong/blob.ts +++ b/ts/fixtures/bind/wrong/blob.ts @@ -1,16 +1,16 @@ // `blob::Blob`, bound wrong: `slice` and the key's `hash`, `cmp`, and `partial_cmp` are // missing, `len` returns a string, and `eq` takes what no `Blob` is. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Blob = rt.ByteSlice; +export type Blob = rs.ByteSlice; -export function copyFromSlice(data: rt.ByteSlice): Blob { +export function copyFromSlice(data: rs.ByteSlice): Blob { return data; } -export function from$convert_From_Vec_u8(vec: rt.ByteVec): Blob { - return rt.byteVecSlice(vec); +export function from$convert_From_Vec_u8(vec: rs.ByteVec): Blob { + return rs.byteVecSlice(vec); } export function len(self: Blob): string { @@ -25,7 +25,7 @@ export function clone$Clone(self: Blob): Blob { return self; } -export function deref$ops_Deref(self: Blob): rt.ByteSlice { +export function deref$ops_Deref(self: Blob): rs.ByteSlice { return self; } diff --git a/ts/fixtures/bind/wrong/skip.ts b/ts/fixtures/bind/wrong/skip.ts index 00e53a15d..227e9c181 100644 --- a/ts/fixtures/bind/wrong/skip.ts +++ b/ts/fixtures/bind/wrong/skip.ts @@ -1,8 +1,8 @@ // `raw::skip`, bound wrong: it returns the new position, where Rust returns `()`. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; -export function skip(bytes: rt.ByteSlice, at: rt.Place): rt.usize { +export function skip(bytes: rs.ByteSlice, at: rs.Place): rs.usize { while (at.v < bytes.length && bytes.data[bytes.start + at.v] === 0) at.v++; return at.v; } diff --git a/ts/fixtures/bind/wrong/tally.ts b/ts/fixtures/bind/wrong/tally.ts index e036fb5ba..9ee12811a 100644 --- a/ts/fixtures/bind/wrong/tally.ts +++ b/ts/fixtures/bind/wrong/tally.ts @@ -1,16 +1,16 @@ // `raw::Tally`, bound wrong: it drops, but has no `[Symbol.dispose]`. -import type * as rt from "../rt.ts"; +import type * as rs from "../rs.ts"; export interface Tally { - count: rt.Arc; + count: rs.Arc; } -function make(count: rt.Arc): Tally { +function make(count: rs.Arc): Tally { return { count }; } export { make as new }; -export function get(self: Tally): rt.u32 { +export function get(self: Tally): rs.u32 { return self.count.value; } diff --git a/ts/fixtures/codec/expected/bench.Point.ts b/ts/fixtures/codec/expected/bench.Point.ts index bc95887bb..c249c1c00 100644 --- a/ts/fixtures/codec/expected/bench.Point.ts +++ b/ts/fixtures/codec/expected/bench.Point.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Point, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { const _3: string = "Point"; const _4: string = "x"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.i64Debug(self.x, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self.x, f); const _7: string = "y"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.i64Debug(self.y, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self.y, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A pair `format` writes with its derived `Debug`. */ export interface Point { - x: rt.i64; - y: rt.i64; + x: rs.i64; + y: rs.i64; } //# sourceMappingURL=bench.Point.ts.map diff --git a/ts/fixtures/codec/expected/bench.Timestamp.ts b/ts/fixtures/codec/expected/bench.Timestamp.ts index 5baec6970..1660099f8 100644 --- a/ts/fixtures/codec/expected/bench.Timestamp.ts +++ b/ts/fixtures/codec/expected/bench.Timestamp.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { bounded } from "./bench.ts"; /** moq-net's `Timestamp`, with the scale it keeps as a `NonZero` unwrapped. */ export interface Timestamp { - value: rt.u64; - scale: rt.u64; + value: rs.u64; + scale: rs.u64; } /** @@ -14,12 +14,12 @@ export interface Timestamp { * `Timestamp::checked_add` returns `TimeOverflow`. */ export function checkedAdd(self: Timestamp, rhs: Timestamp): Timestamp | undefined { - if (!rt.u64Ne(self.scale, rhs.scale)) { - const _6: rt.u64 | undefined = rt.u64CheckedAdd(self.value, rhs.value); + if (!rs.u64Ne(self.scale, rhs.scale)) { + const _6: rs.u64 | undefined = rs.u64CheckedAdd(self.value, rhs.value); if (_6 === undefined) { return undefined; } - const _11: rt.u64 | undefined = bounded(rt.u128Cast(_6)); + const _11: rs.u64 | undefined = bounded(rs.u128Cast(_6)); if (_11 === undefined) { return undefined; } @@ -28,7 +28,7 @@ export function checkedAdd(self: Timestamp, rhs: Timestamp): Timestamp | undefin return undefined; } -export function partialCmp$cmp_PartialOrd(self: Timestamp, other: Timestamp): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Timestamp, other: Timestamp): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } @@ -36,15 +36,15 @@ export function partialCmp$cmp_PartialOrd(self: Timestamp, other: Timestamp): rt * moq-net's temporal order: across scales, the cross products in `u128`, with a tie * broken by `(scale, value)`. */ -export function cmp$cmp_Ord(self: Timestamp, other: Timestamp): rt.Ordering { - if (!rt.u64Eq(self.scale, other.scale)) { - return rt.orderingThen(rt.orderingThen(rt.cmp(rt.u128Mul(rt.u128Cast(self.value), rt.u128Cast(other.scale)), rt.u128Mul(rt.u128Cast(other.value), rt.u128Cast(self.scale))), (): rt.Ordering => { - return rt.cmp(self.scale, other.scale); - }, true), (): rt.Ordering => { - return rt.cmp(self.value, other.value); +export function cmp$cmp_Ord(self: Timestamp, other: Timestamp): rs.Ordering { + if (!rs.u64Eq(self.scale, other.scale)) { + return rs.orderingThen(rs.orderingThen(rs.cmp(rs.u128Mul(rs.u128Cast(self.value), rs.u128Cast(other.scale)), rs.u128Mul(rs.u128Cast(other.value), rs.u128Cast(self.scale))), (): rs.Ordering => { + return rs.cmp(self.scale, other.scale); + }, true), (): rs.Ordering => { + return rs.cmp(self.value, other.value); }, true); } - return rt.cmp(self.value, other.value); + return rs.cmp(self.value, other.value); } //# sourceMappingURL=bench.Timestamp.ts.map diff --git a/ts/fixtures/codec/expected/bench.ts b/ts/fixtures/codec/expected/bench.ts index 193f94ffd..458d7413f 100644 --- a/ts/fixtures/codec/expected/bench.ts +++ b/ts/fixtures/codec/expected/bench.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$bench_Timestamp, out$tuple2_i64_u64, out$u64 } from "./lib.ts"; import * as Point from "./bench.Point.ts"; import * as Timestamp from "./bench.Timestamp.ts"; @@ -10,52 +10,52 @@ import type * as EncodeError from "./coding/encode.EncodeError.ts"; import * as Encoder from "./coding/encode.Encoder.ts"; import { zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as Form from "./coding/varint.Form.ts"; -import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, map$1cf8u0y as option_map$1cf8u0y, mapOr$1jt76jv as option_mapOr$1jt76jv } from "./core/option.ts"; +import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, map$1haiqd3 as option_map$1haiqd3, mapOr$1glsik0 as option_mapOr$1glsik0 } from "./core/option.ts"; import { form, liteVersion, putU64 as harness_putU64, putUsize, takeU64, decodeError, encodeError } from "./harness.ts"; import * as Group from "./lite/group.Group.ts"; import type * as lite_version_Version from "./lite/version.Version.ts"; /** Run one workload. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (input.length !== 0) { - const op: rt.u8 = input.data[input.start]; + const op: rs.u8 = input.data[input.start]; if (input.length - 1 !== 0) { - const selector: rt.u8 = input.data[input.start + 1]; + const selector: rs.u8 = input.data[input.start + 1]; if (op === 0) { - encoded(encodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); + encoded(encodeVarints(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); } else if (op === 1) { - decoded(decodeVarints(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); + decoded(decodeVarints(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), form(selector), out), out); } else if (op === 2) { - encoded(encodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + encoded(encodeFrames(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 3) { - decoded(decodeFrames(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeFrames(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 4) { - encoded(encodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + encoded(encodeGroup(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 6) { - iterate(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + iterate(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 7) { - decoded(decodeSplit(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeSplit(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } else if (op === 8) { - ordered(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + ordered(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 9) { - rescale(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + rescale(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 10) { - stamp(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + stamp(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 11) { - interleave(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + interleave(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 12) { - order(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + order(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 13) { - push(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + push(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 14) { - hashed(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + hashed(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 15) { - packets(selector, new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + packets(selector, new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else if (op === 16) { - format(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), out); + format(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), out); } else { - decoded(decodeGroup(new rt.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); + decoded(decodeGroup(new rs.ByteSlice(input.data, input.start + 2, input.length - 2), liteVersion(selector), out), out); } return out; } @@ -64,53 +64,53 @@ export function run(input: rt.ByteSlice): rt.ByteVec { return out; } -export function encoded(result: rt.Result, out: rt.ByteVec): void { +export function encoded(result: rs.Result, out: rs.ByteVec): void { if (!result.ok) { encodeError(out, result.error); } } -export function decoded(result: rt.Result, out: rt.ByteVec): void { +export function decoded(result: rs.Result, out: rs.ByteVec): void { if (!result.ok) { decodeError(out, result.error); } } /** The same value, `count` times. */ -export function encodeVarints(data: rt.ByteSlice, form: Form.Form, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); - const count: rt.u64 = _6[0]; - const value: rt.u64 = takeU64(_6[1])[0]; +export function encodeVarints(data: rs.ByteSlice, form: Form.Form, out: rs.ByteVec): rs.Result { + const _6: [rs.u64, rs.ByteSlice] = takeU64(data); + const count: rs.u64 = _6[0]; + const value: rs.u64 = takeU64(_6[1])[0]; const w: Encoder.Encoder = Encoder.new(out, form); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = rt.u64Low(count); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); while (iterStart++ < iterEnd) { - const _17: rt.Result = Encoder.varint(w, value); + const _17: rs.Result = Encoder.varint(w, value); if (!_17.ok) { return _17; } } - return rt.OK; + return rs.OK; } /** Every varint on the wire: how many, and the last. */ -export function decodeVarints(wire: rt.ByteSlice, form: Form.Form, out: rt.ByteVec): rt.Result { +export function decodeVarints(wire: rs.ByteSlice, form: Form.Form, out: rs.ByteVec): rs.Result { const r: Decoder.Decoder = Decoder.new(wire, form); - let count: rt.usize = 0; - let last: rt.u64 = 0; + let count: rs.usize = 0; + let last: rs.u64 = 0; while (!Decoder.isEmpty(r)) { - const part: rt.u64 | undefined = Decoder.varint(r); + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - last = part as rt.u64; - count = rt.usizeAdd(count, 1); + last = part as rs.u64; + count = rs.usizeAdd(count, 1); } else { - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } } putUsize(out, count); harness_putU64(out, last); - return rt.OK; + return rs.OK; } /** @@ -118,48 +118,48 @@ export function decodeVarints(wire: rt.ByteSlice, form: Form.Form, out: rt.ByteV * zigzag timestamp delta, then the size. The first frame has no delta and its own size, * and every `key_every`th frame after it is `key_size`, as moq's benchmark samples are. */ -export function encodeFrames(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - let _32!: rt.usize; - let _38!: [rt.i64, rt.u64]; - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); - const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); - const delta: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); - const first: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); - const size: rt.u64 = _15[0]; - const _18: [rt.u64, rt.ByteSlice] = takeU64(_15[1]); - const keyEvery: rt.u64 = _18[0]; - const keySize: rt.u64 = takeU64(_18[1])[0]; - const _24: rt.i64 = rt.i64Cast(delta); - const _23: [rt.i64, rt.usize] = [_24, rt.u64Low(keyEvery)]; - const delta2: rt.i64 = _24; - const keyEvery2: rt.usize = _23[1]; +export function encodeFrames(data: rs.ByteSlice, version: lite_version_Version.Version, out: rs.ByteVec): rs.Result { + let _32!: rs.usize; + let _38!: [rs.i64, rs.u64]; + const _6: [rs.u64, rs.ByteSlice] = takeU64(data); + const count: rs.u64 = _6[0]; + const _9: [rs.u64, rs.ByteSlice] = takeU64(_6[1]); + const delta: rs.u64 = _9[0]; + const _12: [rs.u64, rs.ByteSlice] = takeU64(_9[1]); + const first: rs.u64 = _12[0]; + const _15: [rs.u64, rs.ByteSlice] = takeU64(_12[1]); + const size: rs.u64 = _15[0]; + const _18: [rs.u64, rs.ByteSlice] = takeU64(_15[1]); + const keyEvery: rs.u64 = _18[0]; + const keySize: rs.u64 = takeU64(_18[1])[0]; + const _24: rs.i64 = rs.i64Cast(delta); + const _23: [rs.i64, rs.usize] = [_24, rs.u64Low(keyEvery)]; + const delta2: rs.i64 = _24; + const keyEvery2: rs.usize = _23[1]; const w: Encoder.Encoder = Encoder.new(out, Form.from$convert_From_lite_version_Version(version)); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = rt.u64Low(count); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); while ((_32 = iterStart++) < iterEnd) { b3: { - const n: rt.usize = _32; + const n: rs.usize = _32; if (n === 0) { - _38 = [0, first] as [rt.i64, rt.u64]; + _38 = [0, first] as [rs.i64, rs.u64]; } else { if (keyEvery2 !== 0) { - if (rt.usizeRem(n, keyEvery2) === 0) { - _38 = [delta2, keySize] as [rt.i64, rt.u64]; + if (rs.usizeRem(n, keyEvery2) === 0) { + _38 = [delta2, keySize] as [rs.i64, rs.u64]; break b3; } } - _38 = [delta2, size] as [rt.i64, rt.u64]; + _38 = [delta2, size] as [rs.i64, rs.u64]; } } - const delta3: rt.i64 = _38[0]; - const size2: rt.u64 = _38[1]; - const _48: rt.u64 = varint_zigzag(delta3); - const _45: rt.Result = Encoder.varint(w, _48); + const delta3: rs.i64 = _38[0]; + const size2: rs.u64 = _38[1]; + const _48: rs.u64 = varint_zigzag(delta3); + const _45: rs.Result = Encoder.varint(w, _48); if (_45.ok) { - const _51: rt.Result = Encoder.varint(w, size2); + const _51: rs.Result = Encoder.varint(w, size2); if (!_51.ok) { return _51; } @@ -167,36 +167,36 @@ export function encodeFrames(data: rt.ByteSlice, version: lite_version_Version.V return _45; } } - return rt.OK; + return rs.OK; } /** Every FRAME header on the wire: how many, their total size, and the last delta. */ -export function decodeFrames(wire: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { +export function decodeFrames(wire: rs.ByteSlice, version: lite_version_Version.Version, out: rs.ByteVec): rs.Result { const r: Decoder.Decoder = Decoder.new(wire, Form.from$convert_From_lite_version_Version(version)); - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; + let count: rs.usize = 0; + let total: rs.u64 = 0; + let last: rs.i64 = 0; while (!Decoder.isEmpty(r)) { - const part: rt.u64 | undefined = Decoder.varint(r); + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - last = unzigzag(part as rt.u64); - const part2: rt.u64 | undefined = Decoder.varint(r); + last = unzigzag(part as rs.u64); + const part2: rs.u64 | undefined = Decoder.varint(r); const err2: DecodeError.DecodeError | undefined = part2 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err2 === undefined) { - total = rt.u64Add(total, part2 as rt.u64); - count = rt.usizeAdd(count, 1); + total = rs.u64Add(total, part2 as rs.u64); + count = rs.usizeAdd(count, 1); } else { - return rt.Err(err2 as DecodeError.DecodeError); + return rs.Err(err2 as DecodeError.DecodeError); } } else { - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } } putUsize(out, count); harness_putU64(out, total); - harness_putU64(out, rt.u64Cast(last)); - return rt.OK; + harness_putU64(out, rs.u64Cast(last)); + return rs.OK; } /** @@ -206,61 +206,61 @@ export function decodeFrames(wire: rt.ByteSlice, version: lite_version_Version.V * decoded again from its start on the next. How many, their total size, the last delta, * and how many decodes came up short. */ -export function decodeSplit(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); - const read2: rt.usize = rt.max(rt.u64Low(_6[0]), 1); - let start: rt.usize = 0; - let end: rt.usize = 0; - let count: rt.usize = 0; - let total: rt.u64 = 0; - let last: rt.i64 = 0; - let short: rt.usize = 0; +export function decodeSplit(data: rs.ByteSlice, version: lite_version_Version.Version, out: rs.ByteVec): rs.Result { + const _6: [rs.u64, rs.ByteSlice] = takeU64(data); + const read2: rs.usize = rs.max(rs.u64Low(_6[0]), 1); + let start: rs.usize = 0; + let end: rs.usize = 0; + let count: rs.usize = 0; + let total: rs.u64 = 0; + let last: rs.i64 = 0; + let short: rs.usize = 0; l2: while (end < _6[1].length) { - end = rt.min(_6[1].length, rt.usizeAdd(end, read2)); + end = rs.min(_6[1].length, rs.usizeAdd(end, read2)); while (true) { if (!(start < end)) { continue l2; } - const r: Decoder.Decoder = Decoder.new(rt.byteSliceRange(_6[1], start, end), Form.from$convert_From_lite_version_Version(version)); - const part: rt.i64 | undefined = frameHeader(r); + const r: Decoder.Decoder = Decoder.new(rs.byteSliceRange(_6[1], start, end), Form.from$convert_From_lite_version_Version(version)); + const part: rs.i64 | undefined = frameHeader(r); const err2: DecodeError.DecodeError | undefined = part === undefined ? out$tuple2_i64_u64.err as DecodeError.DecodeError : undefined; - const part2: rt.u64 = out$tuple2_i64_u64.p_1; + const part2: rs.u64 = out$tuple2_i64_u64.p_1; if (err2 === undefined) { - const delta: rt.i64 = part as rt.i64; - const size: rt.u64 = part2; - start = rt.usizeSub(end, Decoder.remaining(r)); + const delta: rs.i64 = part as rs.i64; + const size: rs.u64 = part2; + start = rs.usizeSub(end, Decoder.remaining(r)); last = delta; - total = rt.u64Add(total, size); - count = rt.usizeAdd(count, 1); + total = rs.u64Add(total, size); + count = rs.usizeAdd(count, 1); } else { if ((err2 as DecodeError.DecodeError).tag === "Short") { - short = rt.usizeAdd(short, 1); + short = rs.usizeAdd(short, 1); continue l2; } - return rt.Err(err2 as DecodeError.DecodeError); + return rs.Err(err2 as DecodeError.DecodeError); } } } if (!(start < end)) { putUsize(out, count); harness_putU64(out, total); - harness_putU64(out, rt.u64Cast(last)); + harness_putU64(out, rs.u64Cast(last)); putUsize(out, short); - return rt.OK; + return rs.OK; } - return rt.Err({ tag: "Short" } as DecodeError.DecodeError); + return rs.Err({ tag: "Short" } as DecodeError.DecodeError); } /** One FRAME header: the zigzag timestamp delta, then the size. */ -export function frameHeader(r: Decoder.Decoder): rt.i64 | undefined { - const part: rt.u64 | undefined = Decoder.varint(r); +export function frameHeader(r: Decoder.Decoder): rs.i64 | undefined { + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const delta: rt.i64 = unzigzag(part as rt.u64); - const part2: rt.u64 | undefined = Decoder.varint(r); + const delta: rs.i64 = unzigzag(part as rs.u64); + const part2: rs.u64 | undefined = Decoder.varint(r); const err2: DecodeError.DecodeError | undefined = part2 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err2 === undefined) { - out$tuple2_i64_u64.p_1 = part2 as rt.u64; + out$tuple2_i64_u64.p_1 = part2 as rs.u64; return delta; } out$tuple2_i64_u64.err = err2 as DecodeError.DecodeError; @@ -271,8 +271,8 @@ export function frameHeader(r: Decoder.Decoder): rt.i64 | undefined { } /** One size-prefixed GROUP header, starting at the first frame. */ -export function encodeGroup(data: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); +export function encodeGroup(data: rs.ByteSlice, version: lite_version_Version.Version, out: rs.ByteVec): rs.Result { + const _6: [rs.u64, rs.ByteSlice] = takeU64(data); const group: Group.Group = { subscribe: _6[0], sequence: takeU64(_6[1])[0], frameStart: 0 }; return Group.encode$coding_encode_Encode_lite_version_Version(group, Encoder.new(out, Form.from$convert_From_lite_version_Version(version)), version); } @@ -282,43 +282,43 @@ export function encodeGroup(data: rt.ByteSlice, version: lite_version_Version.Ve * up, summed over a quarter of the key space, and removed again. The sum of the values * found. */ -export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { - let _15!: rt.u32; - let _28!: rt.u32; - let _66!: rt.u32; - const _10: (a0: rt.u32) => rt.u32 = (i4: rt.u32): rt.u32 => { - return rt.u32Rem(rt.u32Mul(i4, 40503), 1 << 16); +export function ordered(data: rs.ByteSlice, out: rs.ByteVec): void { + let _15!: rs.u32; + let _28!: rs.u32; + let _66!: rs.u32; + const _10: (a0: rs.u32) => rs.u32 = (i4: rs.u32): rs.u32 => { + return rs.u32Rem(rs.u32Mul(i4, 40503), 1 << 16); }; - const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = count2; + const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); + const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = count2; while ((_15 = iterStart++) < iterEnd) { - const i: rt.u32 = _15; - const _21: rt.u32 = _10(i); - rt.btreeInsert(map, _21, i); + const i: rs.u32 = _15; + const _21: rs.u32 = _10(i); + rs.btreeInsert(map, _21, i); } - let sum: rt.u64 = 0; - let iterStart2: rt.u32 = 0; - const iterEnd2: rt.u32 = count2; + let sum: rs.u64 = 0; + let iterStart2: rs.u32 = 0; + const iterEnd2: rs.u32 = count2; while ((_28 = iterStart2++) < iterEnd2) { - const _38: rt.u32 = _10(rt.u32Sub(rt.u32Sub(count2, 1), _28)); - sum = rt.u64Add(sum, option_unwrapOr$11c0we2(rt.btreeGet(map, _38), 0) as rt.u64); + const _38: rs.u32 = _10(rs.u32Sub(rs.u32Sub(count2, 1), _28)); + sum = rs.u64Add(sum, option_unwrapOr$1b5hww3(rs.btreeGet(map, _38), 0) as rs.u64); } - const _49: rt.Range = new rt.Range(1 << 14, 2 << 14); - const iter3: rt.Iter<[rt.u32, rt.u32]> = rt.btreeRange(map, _49); + const _49: rs.Range = new rs.Range(1 << 14, 2 << 14); + const iter3: rs.Iter<[rs.u32, rs.u32]> = rs.btreeRange(map, _49); while (true) { - const _57: [rt.u32, rt.u32] | rt.Done = iter3.next(); - if (_57 === rt.DONE) { + const _57: [rs.u32, rs.u32] | rs.Done = iter3.next(); + if (_57 === rs.DONE) { break; } - sum = rt.u64Add(sum, _57[1] as rt.u64); + sum = rs.u64Add(sum, _57[1] as rs.u64); } - let iterStart3: rt.u32 = 0; - const iterEnd3: rt.u32 = count2; + let iterStart3: rs.u32 = 0; + const iterEnd3: rs.u32 = count2; while ((_66 = iterStart3++) < iterEnd3) { - const _73: rt.u32 = _10(_66); - rt.btreeRemove(map, _73); + const _73: rs.u32 = _10(_66); + rs.btreeRemove(map, _73); } harness_putU64(out, sum); } @@ -327,45 +327,45 @@ export function ordered(data: rt.ByteSlice, out: rt.ByteVec): void { * `count` keys, scattered as `ordered`'s, inserted into a `HashMap`, and unless `selector` * is 1, each looked up and removed: the sum of what the lookups found, and the length left. */ -export function hashed(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _16!: rt.u32; - let sum!: rt.u64; - let _30!: rt.u32; - let _51!: rt.u32; - const _11: (a0: rt.u32) => rt.u32 = (i4: rt.u32): rt.u32 => { - return rt.u32Rem(rt.u32Mul(i4, 40503), 1 << 16); +export function hashed(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _16!: rs.u32; + let sum!: rs.u64; + let _30!: rs.u32; + let _51!: rs.u32; + const _11: (a0: rs.u32) => rs.u32 = (i4: rs.u32): rs.u32 => { + return rs.u32Rem(rs.u32Mul(i4, 40503), 1 << 16); }; - const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = count2; + const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = count2; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u32 = _16; - const _22: rt.u32 = _11(i); - rt.hashInsert(map, _22, i); + const i: rs.u32 = _16; + const _22: rs.u32 = _11(i); + rs.hashInsert(map, _22, i); } b2: { sum = 0; if (selector !== 1) { - let iterStart2: rt.u32 = 0; - const iterEnd2: rt.u32 = count2; + let iterStart2: rs.u32 = 0; + const iterEnd2: rs.u32 = count2; while ((_30 = iterStart2++) < iterEnd2) { - const _40: rt.u32 = _11(rt.u32Sub(rt.u32Sub(count2, 1), _30)); - sum = rt.u64Add(sum, option_unwrapOr$11c0we2(rt.hashGet(map, _40), 0) as rt.u64); + const _40: rs.u32 = _11(rs.u32Sub(rs.u32Sub(count2, 1), _30)); + sum = rs.u64Add(sum, option_unwrapOr$1b5hww3(rs.hashGet(map, _40), 0) as rs.u64); } - let iterStart3: rt.u32 = 0; - const iterEnd3: rt.u32 = count2; + let iterStart3: rs.u32 = 0; + const iterEnd3: rs.u32 = count2; while (true) { if (!((_51 = iterStart3++) < iterEnd3)) { break b2; } - const _58: rt.u32 = _11(_51); - rt.hashRemove(map, _58); + const _58: rs.u32 = _11(_51); + rs.hashRemove(map, _58); } } } harness_putU64(out, sum); - putUsize(out, rt.hashLen(map)); + putUsize(out, rs.hashLen(map)); } /** @@ -374,46 +374,46 @@ export function hashed(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo * `selector` picks, each by `u32`'s own `Ord`: the first, middle, and last of the order, * the greatest and least, or the first key, the length, and the last key or its value. */ -export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u64Low(rt.u64Clamp(takeU64(data)[0], 1, 65536))), (i: rt.u32): rt.u32 => { - return rt.u32Rem(rt.u32Mul(i, 40503), 1 << 16); +export function order(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u64Low(rs.u64Clamp(takeU64(data)[0], 1, 65536))), (i: rs.u32): rs.u32 => { + return rs.u32Rem(rs.u32Mul(i, 40503), 1 << 16); }), undefined, 4, true); if (selector === 0) { - rt.sliceSort(v.items, rt.lt, 4, true); + rs.sliceSort(v.items, rs.lt, 4, true); } else if (selector === 1) { - rt.sliceSort(v.items, rt.keyLt((_212: rt.u32): rt.u32 => { - return rt.u32Rem(_212, 1024); - }, rt.lt), 4, true); + rs.sliceSort(v.items, rs.keyLt((_212: rs.u32): rs.u32 => { + return rs.u32Rem(_212, 1024); + }, rs.lt), 4, true); } else if (selector === 2) { - v = rt.vecFrom([rt.optionUnwrap(rt.iterMax(rt.iterSlice(v.items), rt.lt)), rt.optionUnwrap(rt.iterMin(rt.iterSlice(v.items), rt.lt))]); + v = rs.vecFrom([rs.optionUnwrap(rs.iterMax(rs.iterSlice(v.items), rs.lt)), rs.optionUnwrap(rs.iterMin(rs.iterSlice(v.items), rs.lt))]); } else if (selector === 3) { - const _35: [rt.u32, rt.u32] = rt.iterFold(rt.iterSlice(v.items), [0, 4294967295] as [rt.u32, rt.u32], (_211: [rt.u32, rt.u32], _33: rt.u32): [rt.u32, rt.u32] => { - const hi2: rt.u32 = _211[0]; - const lo2: rt.u32 = _211[1]; - const x6: rt.u32 = _33; - return [rt.max(hi2, x6), rt.min(lo2, x6)] as [rt.u32, rt.u32]; + const _35: [rs.u32, rs.u32] = rs.iterFold(rs.iterSlice(v.items), [0, 4294967295] as [rs.u32, rs.u32], (_211: [rs.u32, rs.u32], _33: rs.u32): [rs.u32, rs.u32] => { + const hi2: rs.u32 = _211[0]; + const lo2: rs.u32 = _211[1]; + const x6: rs.u32 = _33; + return [rs.max(hi2, x6), rs.min(lo2, x6)] as [rs.u32, rs.u32]; }); - v = rt.vecFrom([_35[0], _35[1]]); + v = rs.vecFrom([_35[0], _35[1]]); } else if (selector === 5) { - const _43: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(rt.iterSlice(v.items), (_210: rt.u32): [rt.u32, rt.u32] => { - const x5: rt.u32 = _210; - return [rt.u32Rem(x5, 512), x5] as [rt.u32, rt.u32]; + const _43: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(rs.iterSlice(v.items), (_210: rs.u32): [rs.u32, rs.u32] => { + const x5: rs.u32 = _210; + return [rs.u32Rem(x5, 512), x5] as [rs.u32, rs.u32]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _43, true, undefined, undefined, undefined, 8, true); - v = rt.vecFrom([rt.optionUnwrap(rt.iterToOption(rt.btreeKeys(map).next())), rt.btreeLen(map) as rt.u32, rt.optionUnwrap(rt.iterToOption(rt.btreeValues(map).nextBack()))]); + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _43, true, undefined, undefined, undefined, 8, true); + v = rs.vecFrom([rs.optionUnwrap(rs.iterToOption(rs.btreeKeys(map).next())), rs.btreeLen(map) as rs.u32, rs.optionUnwrap(rs.iterToOption(rs.btreeValues(map).nextBack()))]); } else if (selector === 6) { - const _65: rt.Iter = rt.iterMap(rt.iterSlice(v.items), (_2: rt.u32): rt.u32 => { - return rt.u32Rem(_2, 512); + const _65: rs.Iter = rs.iterMap(rs.iterSlice(v.items), (_2: rs.u32): rs.u32 => { + return rs.u32Rem(_2, 512); }); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _65, true, undefined, undefined, 4, true); - v = rt.vecFrom([rt.optionUnwrap(rt.btreeFirstKey(set)), rt.btreeLen(set) as rt.u32, rt.optionUnwrap(rt.btreeFirstKey(set, true))]); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _65, true, undefined, undefined, 4, true); + v = rs.vecFrom([rs.optionUnwrap(rs.btreeFirstKey(set)), rs.btreeLen(set) as rs.u32, rs.optionUnwrap(rs.btreeFirstKey(set, true))]); } else { - const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - for (const _87 of rt.replaceIn(v, new rt.Vec()).items) { - rt.heapPush(heap, _87, rt.le); + const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + for (const _87 of rs.replaceIn(v, new rs.Vec()).items) { + rs.heapPush(heap, _87, rs.le); } while (true) { - const _93: rt.u32 | undefined = rt.heapPop(heap, rt.le); + const _93: rs.u32 | undefined = rs.heapPop(heap, rs.le); if (_93 !== undefined) { v.items.push(_93); } else { @@ -421,18 +421,18 @@ export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } } } - const _103: rt.Vec = v; - const _101: rt.u32 = _103.items[rt.idx(_103.items, 0)]; - const _106: rt.Vec = v; - const _104: rt.u32 = _106.items[rt.idx(_106.items, rt.usizeDiv(v.items.length, 2))]; - const _113: rt.Vec = v; - const iter2: rt.Iter = rt.iterSlice([_101, _104, _113.items[rt.idx(_113.items, rt.usizeSub(v.items.length, 1))]]); + const _103: rs.Vec = v; + const _101: rs.u32 = _103.items[rs.idx(_103.items, 0)]; + const _106: rs.Vec = v; + const _104: rs.u32 = _106.items[rs.idx(_106.items, rs.usizeDiv(v.items.length, 2))]; + const _113: rs.Vec = v; + const iter2: rs.Iter = rs.iterSlice([_101, _104, _113.items[rs.idx(_113.items, rs.usizeSub(v.items.length, 1))]]); while (true) { - const _119: rt.u32 | rt.Done = iter2.next(); - if (_119 === rt.DONE) { + const _119: rs.u32 | rs.Done = iter2.next(); + if (_119 === rs.DONE) { break; } - harness_putU64(out, _119 as rt.u64); + harness_putU64(out, _119 as rs.u64); } } @@ -441,55 +441,55 @@ export function order(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi * and middle item. With `selector` 2, a `Vec` as a stack, popped after every fourth push * and then emptied: its length and the sum of what it popped. */ -export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _13!: [rt.usize, rt.u32 | undefined]; - let _18!: rt.u32; - let _38!: rt.u32; - let _66!: rt.u32; - const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536)); +export function push(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _13!: [rs.usize, rs.u32 | undefined]; + let _18!: rs.u32; + let _38!: rs.u32; + let _66!: rs.u32; + const count2: rs.u32 = rs.u64Low(rs.u64Min(takeU64(data)[0], 65536)); if (selector === 1) { - const q: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = count2; + const q: rs.VecDeque = rs.dequeNew(4) as rs.VecDeque; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = count2; while ((_18 = iterStart++) < iterEnd) { - rt.dequePushBack(q, _18); + rs.dequePushBack(q, _18); } - _13 = [q.n, rt.dequeGet(q, rt.usizeDiv(q.n, 2))] as [rt.usize, rt.u32 | undefined]; + _13 = [q.n, rs.dequeGet(q, rs.usizeDiv(q.n, 2))] as [rs.usize, rs.u32 | undefined]; } else if (selector === 2) { - const v: rt.Vec = new rt.Vec(); - let sum: rt.u32 = 0; - let iterStart2: rt.u32 = 0; - const iterEnd2: rt.u32 = count2; + const v: rs.Vec = new rs.Vec(); + let sum: rs.u32 = 0; + let iterStart2: rs.u32 = 0; + const iterEnd2: rs.u32 = count2; while ((_38 = iterStart2++) < iterEnd2) { - const i2: rt.u32 = _38; + const i2: rs.u32 = _38; v.items.push(i2); - if (rt.u32Rem(i2, 4) === 3) { - sum = rt.u32WrappingAdd(sum, option_unwrapOr$11c0we2(rt.vecPop(v), 0)); + if (rs.u32Rem(i2, 4) === 3) { + sum = rs.u32WrappingAdd(sum, option_unwrapOr$1b5hww3(rs.vecPop(v), 0)); } } while (true) { - const _52: rt.u32 | undefined = rt.vecPop(v); + const _52: rs.u32 | undefined = rs.vecPop(v); if (_52 !== undefined) { - sum = rt.u32WrappingAdd(sum, _52); + sum = rs.u32WrappingAdd(sum, _52); } else { break; } } - _13 = [v.items.length, sum] as [rt.usize, rt.u32 | undefined]; + _13 = [v.items.length, sum] as [rs.usize, rs.u32 | undefined]; } else { - const v2: rt.Vec = new rt.Vec(); - let iterStart3: rt.u32 = 0; - const iterEnd3: rt.u32 = count2; + const v2: rs.Vec = new rs.Vec(); + let iterStart3: rs.u32 = 0; + const iterEnd3: rs.u32 = count2; while ((_66 = iterStart3++) < iterEnd3) { v2.items.push(_66); } - _13 = [v2.items.length, rt.sliceGet(v2.items, rt.usizeDiv(v2.items.length, 2))] as [rt.usize, rt.u32 | undefined]; + _13 = [v2.items.length, rs.sliceGet(v2.items, rs.usizeDiv(v2.items.length, 2))] as [rs.usize, rs.u32 | undefined]; } - const len: rt.usize = _13[0]; - const middle: rt.u32 | undefined = _13[1]; + const len: rs.usize = _13[0]; + const middle: rs.u32 | undefined = _13[1]; putUsize(out, len); - harness_putU64(out, option_mapOr$1jt76jv(middle, 0, (a0: rt.u32): rt.u64 => { - return a0 as rt.u64; + harness_putU64(out, option_mapOr$1glsik0(middle, 0, (a0: rs.u32): rs.u64 => { + return a0 as rs.u64; })); } @@ -497,26 +497,26 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `count` lines written into one `String` with padded, `Debug`, and fixed-precision * placeholders: its length and the sum of its bytes. */ -export function format(data: rt.ByteSlice, out: rt.ByteVec): void { - const count2: rt.i64 = rt.i64Cast(rt.u64Min(takeU64(data)[0], 65536)); +export function format(data: rs.ByteSlice, out: rs.ByteVec): void { + const count2: rs.i64 = rs.i64Cast(rs.u64Min(takeU64(data)[0], 65536)); let s: string = ""; - const iter: rt.Range = new rt.Range(0, count2, rt.i64Step); + const iter: rs.Range = new rs.Range(0, count2, rs.i64Step); while (true) { - const _14: rt.i64 | rt.Done = iter.next(); - if (_14 === rt.DONE) { + const _14: rs.i64 | rs.Done = iter.next(); + if (_14 === rs.DONE) { break; } - const i: rt.i64 = _14; - const point: Point.Point = { x: i, y: rt.i64Neg(i) }; - const _26: rt.f64 = rt.i64ToF64(i) / 3.0; - const _29: rt.i64 = rt.i64Neg(i); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(i, f), (f: rt.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rt.Formatter) => rt.f64Display(_26, f), (f: rt.Formatter) => rt.i64Display(_29, f)]; - s = rt.fmtWriteString(s, [rt.fmtSpec({ align: ">", width: 6 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ precision: 2 }, args2[2]), "|", args2[3], "\n"]).s; + const i: rs.i64 = _14; + const point: Point.Point = { x: i, y: rs.i64Neg(i) }; + const _26: rs.f64 = rs.i64ToF64(i) / 3.0; + const _29: rs.i64 = rs.i64Neg(i); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(i, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => rs.f64Display(_26, f), (f: rs.Formatter) => rs.i64Display(_29, f)]; + s = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ precision: 2 }, args2[2]), "|", args2[3], "\n"]).s; } - putUsize(out, rt.stringLen(s)); - harness_putU64(out, rt.iterSum(rt.iterMap(rt.strBytes(s), (a0: rt.u8): rt.u64 => { - return a0 as rt.u64; - }), rt.u64Add, 0)); + putUsize(out, rs.stringLen(s)); + harness_putU64(out, rs.iterSum(rs.iterMap(rs.strBytes(s), (a0: rs.u8): rs.u64 => { + return a0 as rs.u64; + }), rs.u64Add, 0)); } /** @@ -525,20 +525,20 @@ export function format(data: rt.ByteSlice, out: rt.ByteVec): void { * `selector` 1, each packet is read by value first, a copy of its bytes. The sum of the * counters and of each copy's last byte. */ -export function packets(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _32!: rt.u8; - let cc!: rt.u8; - const packets: rt.ByteVec = rt.byteVecOf(0, rt.usizeMul(rt.u64Low(rt.u64Min(takeU64(data)[0], 4096)), 188)); - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(rt.byteSliceAsChunksMut(rt.byteVecSlice(packets), 188)[0]), rt.byteSliceFrom)); +export function packets(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _32!: rs.u8; + let cc!: rs.u8; + const packets: rs.ByteVec = rs.byteVecOf(0, rs.usizeMul(rs.u64Low(rs.u64Min(takeU64(data)[0], 4096)), 188)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rs.byteSliceAsChunksMut(rs.byteVecSlice(packets), 188)[0]), rs.byteSliceFrom)); while (true) { - const _21: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_21 === rt.DONE) { + const _21: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_21 === rs.DONE) { break; } - const i: rt.usize = _21[0]; + const i: rs.usize = _21[0]; _21[1].data[_21[1].start] = 71; - _21[1].data[_21[1].start + 2] = rt.usizeRem(i, 3) & 0xff; - if (!(rt.usizeRem(i, 5) === 0)) { + _21[1].data[_21[1].start + 2] = rs.usizeRem(i, 3) & 0xff; + if (!(rs.usizeRem(i, 5) === 0)) { _32 = 16; } else { _32 = 32; @@ -546,31 +546,31 @@ export function packets(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v _21[1].data[_21[1].start + 3] = _32; _21[1].data[_21[1].start + 187] = i & 0xff; } - const counters: Uint8Array = rt.bytes(3); - let sum: rt.u64 = 0; - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(rt.byteSliceAsChunksMut(rt.byteVecSlice(packets), 188)[0]), rt.byteSliceFrom); + const counters: Uint8Array = rs.bytes(3); + let sum: rs.u64 = 0; + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(rs.byteSliceAsChunksMut(rs.byteVecSlice(packets), 188)[0]), rs.byteSliceFrom); while (true) { - const _48: rt.ByteSlice | rt.Done = iter2.next(); - if (_48 === rt.DONE) { + const _48: rs.ByteSlice | rs.Done = iter2.next(); + if (_48 === rs.DONE) { break; } if (selector === 1) { - sum = rt.u64Add(sum, rt.byteSliceToArray(_48)[187] as rt.u64); + sum = rs.u64Add(sum, rs.byteSliceToArray(_48)[187] as rs.u64); } - const _73: rt.usize = rt.usizeRem((((((_48.data[_48.start + 1] & 31) as rt.usize) << 8) >>> 0) | _48.data[_48.start + 2] as rt.usize) >>> 0, 3); + const _73: rs.usize = rs.usizeRem((((((_48.data[_48.start + 1] & 31) as rs.usize) << 8) >>> 0) | _48.data[_48.start + 2] as rs.usize) >>> 0, 3); if (!(_73 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _73); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _73); } if (!((_48.data[_48.start + 3] & 16) !== 0)) { - cc = rt.u8WrappingSub(counters[_73], 1) & 15; + cc = rs.u8WrappingSub(counters[_73], 1) & 15; } else { - const _82: rt.u8 = rt.u8Add(counters[_73], 1) & 15; + const _82: rs.u8 = rs.u8Add(counters[_73], 1) & 15; const old = counters[_73]; counters[_73] = _82; cc = old; } _48.data[_48.start + 3] = (_48.data[_48.start + 3] & 240) | cc; - sum = rt.u64Add(sum, cc as rt.u64); + sum = rs.u64Add(sum, cc as rs.u64); } harness_putU64(out, sum); } @@ -579,54 +579,54 @@ export function packets(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v * One iterator chain over every byte, picked by `chain`, with closures that cost little * next to the iterator protocol they run through. */ -export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function iterate(chain: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (chain === 0) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): rt.u8 => { + putUsize(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_217: rs.u8): rs.u8 => { return _217 >> 1; - }), (_218: rt.u8): boolean => { + }), (_218: rs.u8): boolean => { return (_218 & 1) === 0; }))); } else if (chain === 1) { - rt.byteVecPush(out, rt.iterAny(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterAny(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): boolean => { return _216 === 255; }) ? 1 : 0); } else if (chain === 2) { - putUsize(out, rt.iterToByteVec(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): boolean => { + putUsize(out, rs.iterToByteVec(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): boolean => { return (_215 & 1) === 1; }), "next").length); } else if (chain === 3) { - harness_putU64(out, rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u32 => { - return _214 as rt.u32; - }), rt.u32Add, 0) as rt.u64); + harness_putU64(out, rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): rs.u32 => { + return _214 as rs.u32; + }), rs.u32Add, 0) as rs.u64); } else if (chain === 4) { - harness_putU64(out, rt.iterFold(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 16), 512), 0, (acc: rt.u32, _3: rt.u8): rt.u32 => { - return (acc ^ _3 as rt.u32) >>> 0; - }) as rt.u64); + harness_putU64(out, rs.iterFold(rs.iterTake(rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), 16), 512), 0, (acc: rs.u32, _3: rs.u8): rs.u32 => { + return (acc ^ _3 as rs.u32) >>> 0; + }) as rs.u64); } else if (chain === 6) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), "len"), (_213: [rt.u8, rt.u8]): boolean => { + putUsize(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), "len"), (_213: [rs.u8, rs.u8]): boolean => { return _213[0] < _213[1]; }))); } else if (chain === 7) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterRev(rt.iterZip(new rt.Range(0, rt.usizeMul(data.length, 64)), rt.iterSlice(rt.byteSliceView(data)), [false, false])), (_212: [rt.usize, rt.u8]): boolean => { + putUsize(out, rs.iterCount(rs.iterFilter(rs.iterRev(rs.iterZip(new rs.Range(0, rs.usizeMul(data.length, 64)), rs.iterSlice(rs.byteSliceView(data)), [false, false])), (_212: [rs.usize, rs.u8]): boolean => { return (_212[0] & 0xff) < _212[1]; }))); } else if (chain === 8) { - putUsize(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { + putUsize(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2 >> 1; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): rt.u8 => { + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): rs.u8 => { return _210 ^ 3; - }), [true, true]), (_211: [rt.u8, rt.u8]): boolean => { + }), [true, true]), (_211: [rs.u8, rs.u8]): boolean => { return _211[0] < _211[1]; }))); } else { - let last: rt.usize = 0; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + let last: rs.usize = 0; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _54: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_54 === rt.DONE) { + const _54: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_54 === rs.DONE) { break; } - const i: rt.usize = _54[0]; + const i: rs.usize = _54[0]; if (_54[1] === 128) { last = i; } @@ -640,51 +640,51 @@ export function iterate(chain: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `Timestamp::convert` in `u128`, or the same in `u64` (selector 1), which overflows * sooner. How many converted, how many overflowed, and the last converted. */ -export function rescale(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _26!: rt.usize; - let scaled!: rt.u64 | undefined; - const _6: [rt.u64, rt.ByteSlice] = takeU64(data); - const count: rt.u64 = _6[0]; - const _9: [rt.u64, rt.ByteSlice] = takeU64(_6[1]); - const start: rt.u64 = _9[0]; - const _12: [rt.u64, rt.ByteSlice] = takeU64(_9[1]); - const step: rt.u64 = _12[0]; - const _15: [rt.u64, rt.ByteSlice] = takeU64(_12[1]); - const from: rt.u64 = _15[0]; - const to: rt.u64 = takeU64(_15[1])[0]; - let converted: rt.u64 = 0; - let overflowed: rt.u64 = 0; - let last: rt.u64 = 0; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = rt.u64Low(count); +export function rescale(selector: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _26!: rs.usize; + let scaled!: rs.u64 | undefined; + const _6: [rs.u64, rs.ByteSlice] = takeU64(data); + const count: rs.u64 = _6[0]; + const _9: [rs.u64, rs.ByteSlice] = takeU64(_6[1]); + const start: rs.u64 = _9[0]; + const _12: [rs.u64, rs.ByteSlice] = takeU64(_9[1]); + const step: rs.u64 = _12[0]; + const _15: [rs.u64, rs.ByteSlice] = takeU64(_12[1]); + const from: rs.u64 = _15[0]; + const to: rs.u64 = takeU64(_15[1])[0]; + let converted: rs.u64 = 0; + let overflowed: rs.u64 = 0; + let last: rs.u64 = 0; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = rs.u64Low(count); while ((_26 = iterStart++) < iterEnd) { b2: { - const value: rt.u64 = rt.u64Add(start, rt.u64Mul(_26 as rt.u64, step)); + const value: rs.u64 = rs.u64Add(start, rs.u64Mul(_26 as rs.u64, step)); if (selector === 0) { - const _36: rt.u128 | undefined = rt.u128CheckedMul(rt.u128Cast(value), rt.u128Cast(to)); + const _36: rs.u128 | undefined = rs.u128CheckedMul(rs.u128Cast(value), rs.u128Cast(to)); if (_36 === undefined) { - scaled = undefined as rt.u64 | undefined; + scaled = undefined as rs.u64 | undefined; } else { - scaled = bounded(rt.u128Div(_36, rt.u128Cast(from))); + scaled = bounded(rs.u128Div(_36, rs.u128Cast(from))); } } else { - const _44: rt.u64 | undefined = option_map$1cf8u0y(rt.u64CheckedMul(value, to), (scaled3: rt.u64): rt.u64 => { - return rt.u64Div(scaled3, from); + const _44: rs.u64 | undefined = option_map$1haiqd3(rs.u64CheckedMul(value, to), (scaled3: rs.u64): rs.u64 => { + return rs.u64Div(scaled3, from); }); if (_44 !== undefined) { - if (rt.u64Le(_44, { hi: 0x1fffffff, lo: 0xffffffff } as rt.u64)) { + if (rs.u64Le(_44, { hi: 0x1fffffff, lo: 0xffffffff } as rs.u64)) { scaled = _44; break b2; } } - scaled = undefined as rt.u64 | undefined; + scaled = undefined as rs.u64 | undefined; } } if (scaled === undefined) { - overflowed = rt.u64Add(overflowed, 1); + overflowed = rs.u64Add(overflowed, 1); } else { last = scaled; - converted = rt.u64Add(converted, 1); + converted = rs.u64Add(converted, 1); } } harness_putU64(out, converted); @@ -693,40 +693,40 @@ export function rescale(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v } /** `value`, or `None` past [`MAX_TIMESTAMP`], as moq-net bounds a converted timestamp. */ -export function bounded(value: rt.u128): rt.u64 | undefined { - if (!rt.u128Le(value, { hi: 0, w2: 0, w1: 0x1fffffff, lo: 0xffffffff } as rt.u128)) { +export function bounded(value: rs.u128): rs.u64 | undefined { + if (!rs.u128Le(value, { hi: 0, w2: 0, w1: 0x1fffffff, lo: 0xffffffff } as rs.u128)) { return undefined; } - return rt.u64Cast(value); + return rs.u64Cast(value); } /** * A track's frames stamped one duration apart by [`Timestamp::checked_add`], as a * publisher stamps them. How many were stamped, how many overflowed, and the last. */ -export function stamp(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(data); - const count: rt.u64 = _5[0]; - const _8: [rt.u64, rt.ByteSlice] = takeU64(_5[1]); - const start: rt.u64 = _8[0]; - const _11: [rt.u64, rt.ByteSlice] = takeU64(_8[1]); - const step: rt.u64 = _11[0]; - const scale: rt.u64 = takeU64(_11[1])[0]; +export function stamp(data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: [rs.u64, rs.ByteSlice] = takeU64(data); + const count: rs.u64 = _5[0]; + const _8: [rs.u64, rs.ByteSlice] = takeU64(_5[1]); + const start: rs.u64 = _8[0]; + const _11: [rs.u64, rs.ByteSlice] = takeU64(_8[1]); + const step: rs.u64 = _11[0]; + const scale: rs.u64 = takeU64(_11[1])[0]; let time: Timestamp.Timestamp = { value: start, scale }; - let stamped: rt.u64 = 0; - let overflowed: rt.u64 = 0; - const iter: rt.Range = new rt.Range(0, count, rt.u64Step); + let stamped: rs.u64 = 0; + let overflowed: rs.u64 = 0; + const iter: rs.Range = new rs.Range(0, count, rs.u64Step); while (true) { const step2: Timestamp.Timestamp = { value: step, scale }; - if (iter.next() === rt.DONE) { + if (iter.next() === rs.DONE) { break; } const _25: Timestamp.Timestamp | undefined = Timestamp.checkedAdd(time, step2); if (_25 === undefined) { - overflowed = rt.u64Add(overflowed, 1); + overflowed = rs.u64Add(overflowed, 1); } else { time = _25; - stamped = rt.u64Add(stamped, 1); + stamped = rs.u64Add(stamped, 1); } } harness_putU64(out, stamped); @@ -740,31 +740,31 @@ export function stamp(data: rt.ByteSlice, out: rt.ByteVec): void { * comparison per frame taken. How many came from each track, and how many times the * interleave switched tracks. */ -export function interleave(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: [rt.u64, rt.ByteSlice] = takeU64(data); - const count: rt.u64 = _5[0]; - const _9: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_5[1]); +export function interleave(data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: [rs.u64, rs.ByteSlice] = takeU64(data); + const count: rs.u64 = _5[0]; + const _9: [Timestamp.Timestamp, rs.u64, rs.ByteSlice] = track(_5[1]); const a: Timestamp.Timestamp = copy$bench_Timestamp(_9[0]); - const aStep: rt.u64 = _9[1]; - const _12: [Timestamp.Timestamp, rt.u64, rt.ByteSlice] = track(_9[2]); + const aStep: rs.u64 = _9[1]; + const _12: [Timestamp.Timestamp, rs.u64, rs.ByteSlice] = track(_9[2]); const b: Timestamp.Timestamp = copy$bench_Timestamp(_12[0]); - const bStep: rt.u64 = _12[1]; - let fromA: rt.u64 = 0; - let fromB: rt.u64 = 0; - let switches: rt.u64 = 0; + const bStep: rs.u64 = _12[1]; + let fromA: rs.u64 = 0; + let fromB: rs.u64 = 0; + let switches: rs.u64 = 0; let lastA: boolean = true; - const iter: rt.Range = new rt.Range(0, count, rt.u64Step); - while (iter.next() !== rt.DONE) { + const iter: rs.Range = new rs.Range(0, count, rs.u64Step); + while (iter.next() !== rs.DONE) { const takeA: boolean = Timestamp.partialCmp$cmp_PartialOrd(a, b) === -1; if (!takeA) { - b.value = rt.u64Add(b.value, bStep); - fromB = rt.u64Add(fromB, 1); + b.value = rs.u64Add(b.value, bStep); + fromB = rs.u64Add(fromB, 1); } else { - a.value = rt.u64Add(a.value, aStep); - fromA = rt.u64Add(fromA, 1); + a.value = rs.u64Add(a.value, aStep); + fromA = rs.u64Add(fromA, 1); } if (takeA !== lastA) { - switches = rt.u64Add(switches, 1); + switches = rs.u64Add(switches, 1); } lastA = takeA; } @@ -774,26 +774,26 @@ export function interleave(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A track's first timestamp and its frame duration: start, step, and scale. */ -export function track(data: rt.ByteSlice): [Timestamp.Timestamp, rt.u64, rt.ByteSlice] { - const _4: [rt.u64, rt.ByteSlice] = takeU64(data); - const value: rt.u64 = _4[0]; - const _7: [rt.u64, rt.ByteSlice] = takeU64(_4[1]); - const step: rt.u64 = _7[0]; - const _10: [rt.u64, rt.ByteSlice] = takeU64(_7[1]); - return [{ value, scale: _10[0] }, step, _10[1]] as [Timestamp.Timestamp, rt.u64, rt.ByteSlice]; +export function track(data: rs.ByteSlice): [Timestamp.Timestamp, rs.u64, rs.ByteSlice] { + const _4: [rs.u64, rs.ByteSlice] = takeU64(data); + const value: rs.u64 = _4[0]; + const _7: [rs.u64, rs.ByteSlice] = takeU64(_4[1]); + const step: rs.u64 = _7[0]; + const _10: [rs.u64, rs.ByteSlice] = takeU64(_7[1]); + return [{ value, scale: _10[0] }, step, _10[1]] as [Timestamp.Timestamp, rs.u64, rs.ByteSlice]; } -export function decodeGroup(wire: rt.ByteSlice, version: lite_version_Version.Version, out: rt.ByteVec): rt.Result { - const _6: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(wire, version); +export function decodeGroup(wire: rs.ByteSlice, version: lite_version_Version.Version, out: rs.ByteVec): rs.Result { + const _6: rs.Result<[Group.Group, rs.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(wire, version); if (_6.ok) { - const val: [Group.Group, rt.usize] = _6.value; + const val: [Group.Group, rs.usize] = _6.value; const group: Group.Group = val[0]; - const used: rt.usize = val[1]; + const used: rs.usize = val[1]; harness_putU64(out, group.subscribe); harness_putU64(out, group.sequence); harness_putU64(out, group.frameStart); putUsize(out, used); - return rt.OK; + return rs.OK; } return _6; } diff --git a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts index c0115377c..4504471d9 100644 --- a/ts/fixtures/codec/expected/coding/decode.DecodeError.ts +++ b/ts/fixtures/codec/expected/coding/decode.DecodeError.ts @@ -1,158 +1,158 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import * as SessionError from "../lib.SessionError.ts"; import { asDisplay$thiserror___private21_AsDisplay_ref_usize } from "../thiserror/display.ts"; -export function fmt$fmt_Display(self: DecodeError, __formatter: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: DecodeError, __formatter: rs.Formatter): rs.Result { if (self.tag === "Short") { - return rt.fmtWriteStr(__formatter, "short buffer"); + return rs.fmtWriteStr(__formatter, "short buffer"); } if (self.tag === "Long") { - return rt.fmtWriteStr(__formatter, "long buffer"); + return rs.fmtWriteStr(__formatter, "long buffer"); } if (self.tag === "InvalidString") { - return rt.fmtWriteStr(__formatter, "invalid string"); + return rs.fmtWriteStr(__formatter, "invalid string"); } if (self.tag === "InvalidMessage") { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Debug(arg, f)]; - return rt.fmtWriteFmt(__formatter, ["invalid message: ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(arg, f)]; + return rs.fmtWriteFmt(__formatter, ["invalid message: ", args2[0]]); } if (self.tag === "InvalidSubscribeLocation") { - return rt.fmtWriteStr(__formatter, "invalid subscribe location"); + return rs.fmtWriteStr(__formatter, "invalid subscribe location"); } if (self.tag === "InvalidValue") { - return rt.fmtWriteStr(__formatter, "invalid value"); + return rs.fmtWriteStr(__formatter, "invalid value"); } if (self.tag === "TooMany") { - return rt.fmtWriteStr(__formatter, "too many"); + return rs.fmtWriteStr(__formatter, "too many"); } if (self.tag === "BoundsExceeded") { - return rt.fmtWriteStr(__formatter, "bounds exceeded"); + return rs.fmtWriteStr(__formatter, "bounds exceeded"); } if (self.tag === "ExpectedEnd") { - return rt.fmtWriteStr(__formatter, "expected end"); + return rs.fmtWriteStr(__formatter, "expected end"); } if (self.tag === "MessageTooLarge") { - const _26: rt.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.size); - const _28: rt.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.max); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_26, f), (f: rt.Formatter) => rt.usizeDisplay(_28, f)]; - return rt.fmtWriteFmt(__formatter, ["message too large: ", args4[0], " bytes exceeds ", args4[1], " byte limit"]); + const _26: rs.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.size); + const _28: rs.usize = asDisplay$thiserror___private21_AsDisplay_ref_usize(self.max); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_26, f), (f: rs.Formatter) => rs.usizeDisplay(_28, f)]; + return rs.fmtWriteFmt(__formatter, ["message too large: ", args4[0], " bytes exceeds ", args4[1], " byte limit"]); } if (self.tag === "ExpectedData") { - return rt.fmtWriteStr(__formatter, "expected data"); + return rs.fmtWriteStr(__formatter, "expected data"); } if (self.tag === "Duplicate") { - return rt.fmtWriteStr(__formatter, "duplicate"); + return rs.fmtWriteStr(__formatter, "duplicate"); } if (self.tag === "Missing") { - return rt.fmtWriteStr(__formatter, "missing"); + return rs.fmtWriteStr(__formatter, "missing"); } if (self.tag === "Unsupported") { - return rt.fmtWriteStr(__formatter, "unsupported"); + return rs.fmtWriteStr(__formatter, "unsupported"); } if (self.tag === "TrailingBytes") { - return rt.fmtWriteStr(__formatter, "trailing bytes"); + return rs.fmtWriteStr(__formatter, "trailing bytes"); } if (self.tag === "Version") { - return rt.fmtWriteStr(__formatter, "unsupported version"); + return rs.fmtWriteStr(__formatter, "unsupported version"); } if (self.tag === "Session") { return SessionError.fmt$fmt_Display(self._0, __formatter); } if (self.tag === "MalformedAuthToken") { - return rt.fmtWriteStr(__formatter, "malformed authorization token"); + return rs.fmtWriteStr(__formatter, "malformed authorization token"); } - return rt.fmtWriteStr(__formatter, "multiple authorization tokens"); + return rs.fmtWriteStr(__formatter, "multiple authorization tokens"); } -export function from$convert_From_string_FromUtf8Error(source: rt.FromUtf8Error): DecodeError { +export function from$convert_From_string_FromUtf8Error(source: rs.FromUtf8Error): DecodeError { return { tag: "InvalidString", _0: source } as DecodeError; } -export function fmt$fmt_Debug(self: DecodeError, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: DecodeError, f: rs.Formatter): rs.Result { if (self.tag === "Short") { - return rt.fmtWriteStr(f, "Short"); + return rs.fmtWriteStr(f, "Short"); } if (self.tag === "Long") { - return rt.fmtWriteStr(f, "Long"); + return rs.fmtWriteStr(f, "Long"); } if (self.tag === "InvalidString") { const _7: string = "InvalidString"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _7), _8)); } if (self.tag === "InvalidMessage") { const _11: string = "InvalidMessage"; - const _12: rt.Fmt = (f: rt.Formatter) => rt.u64Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _11), _12)); + const _12: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _11), _12)); } if (self.tag === "InvalidSubscribeLocation") { - return rt.fmtWriteStr(f, "InvalidSubscribeLocation"); + return rs.fmtWriteStr(f, "InvalidSubscribeLocation"); } if (self.tag === "InvalidValue") { - return rt.fmtWriteStr(f, "InvalidValue"); + return rs.fmtWriteStr(f, "InvalidValue"); } if (self.tag === "TooMany") { - return rt.fmtWriteStr(f, "TooMany"); + return rs.fmtWriteStr(f, "TooMany"); } if (self.tag === "BoundsExceeded") { - return rt.fmtWriteStr(f, "BoundsExceeded"); + return rs.fmtWriteStr(f, "BoundsExceeded"); } if (self.tag === "ExpectedEnd") { - return rt.fmtWriteStr(f, "ExpectedEnd"); + return rs.fmtWriteStr(f, "ExpectedEnd"); } if (self.tag === "MessageTooLarge") { const _21: string = "MessageTooLarge"; const _22: string = "size"; - const _23: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self.size, f); + const _23: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.size, f); const _24: string = "max"; - const _25: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self.max, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _21), _22, _23), _24, _25)); + const _25: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.max, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _21), _22, _23), _24, _25)); } if (self.tag === "ExpectedData") { - return rt.fmtWriteStr(f, "ExpectedData"); + return rs.fmtWriteStr(f, "ExpectedData"); } if (self.tag === "Duplicate") { - return rt.fmtWriteStr(f, "Duplicate"); + return rs.fmtWriteStr(f, "Duplicate"); } if (self.tag === "Missing") { - return rt.fmtWriteStr(f, "Missing"); + return rs.fmtWriteStr(f, "Missing"); } if (self.tag === "Unsupported") { - return rt.fmtWriteStr(f, "Unsupported"); + return rs.fmtWriteStr(f, "Unsupported"); } if (self.tag === "TrailingBytes") { - return rt.fmtWriteStr(f, "TrailingBytes"); + return rs.fmtWriteStr(f, "TrailingBytes"); } if (self.tag === "Version") { - return rt.fmtWriteStr(f, "Version"); + return rs.fmtWriteStr(f, "Version"); } if (self.tag === "Session") { const _34: string = "Session"; - const _35: rt.Fmt = (f: rt.Formatter) => SessionError.fmt$fmt_Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _34), _35)); + const _35: rs.Fmt = (f: rs.Formatter) => SessionError.fmt$fmt_Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _34), _35)); } if (self.tag === "MalformedAuthToken") { - return rt.fmtWriteStr(f, "MalformedAuthToken"); + return rs.fmtWriteStr(f, "MalformedAuthToken"); } - return rt.fmtWriteStr(f, "MultipleAuthTokens"); + return rs.fmtWriteStr(f, "MultipleAuthTokens"); } /** A decode error. */ export type DecodeError = | { tag: "Short" } | { tag: "Long" } - | { tag: "InvalidString"; _0: rt.FromUtf8Error } - | { tag: "InvalidMessage"; _0: rt.u64 } + | { tag: "InvalidString"; _0: rs.FromUtf8Error } + | { tag: "InvalidMessage"; _0: rs.u64 } | { tag: "InvalidSubscribeLocation" } | { tag: "InvalidValue" } | { tag: "TooMany" } | { tag: "BoundsExceeded" } | { tag: "ExpectedEnd" } - | { tag: "MessageTooLarge"; size: rt.usize; max: rt.usize } + | { tag: "MessageTooLarge"; size: rs.usize; max: rs.usize } | { tag: "ExpectedData" } | { tag: "Duplicate" } | { tag: "Missing" } diff --git a/ts/fixtures/codec/expected/coding/decode.Decoder.ts b/ts/fixtures/codec/expected/coding/decode.Decoder.ts index e697df418..702625c71 100644 --- a/ts/fixtures/codec/expected/coding/decode.Decoder.ts +++ b/ts/fixtures/codec/expected/coding/decode.Decoder.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$Option_u64, out$bool, out$ref_slice_u8, out$tuple2_u64_ref_slice_u8, out$u16, out$u64, out$u8 } from "../lib.ts"; import * as DecodeError from "../coding/decode.DecodeError.ts"; import { read } from "../coding/varint.ts"; import type * as Form from "../coding/varint.Form.ts"; -import { mapErr$06mnjtr as result_mapErr$06mnjtr, inspectErr$156koiv } from "../core/result.ts"; +import { mapErr$0o8djoc as result_mapErr$0o8djoc, inspectErr$157k8w1 } from "../core/result.ts"; import type * as Control from "../stats.Control.ts"; /** @@ -20,20 +20,20 @@ export interface Decoder { bufLen: number; form: Form.Form; /** The length of the buffer this decoder started with. */ - len: rt.usize; + len: rs.usize; /** See [`Self::need`]. */ - need: rt.usize; + need: rs.usize; /** The control message read, counted once the read is consumed. */ control: Control.Control | undefined; /** * Leading bytes left out of the `control` count: a type selector the sender writes * apart from the message, and so never counts. */ - uncounted: rt.usize; + uncounted: rs.usize; } /** Read `buf`, with varints in the given form. */ -function new_(buf: rt.ByteSlice, form: Form.Form): Decoder { +function new_(buf: rs.ByteSlice, form: Form.Form): Decoder { return { bufData: buf.data, bufStart: buf.start, bufLen: buf.length, form, len: buf.length, need: 0, control: undefined, uncounted: 0 }; } @@ -42,19 +42,19 @@ function new_(buf: rt.ByteSlice, form: Form.Form): Decoder { * needed: at least one more than the buffer when it can't tell, and 0 if no read of * this decoder ran short. */ -export function need(self: Decoder): rt.usize { +export function need(self: Decoder): rs.usize { return self.need; } /** Record that a read wanted `more` bytes past the current position. */ -export function short(self: Decoder, more: rt.usize): DecodeError.DecodeError { - const need: rt.usize = rt.usizeSaturatingAdd(rt.usizeSub(self.len, self.bufLen), more); - self.need = rt.max(self.need, need); +export function short(self: Decoder, more: rs.usize): DecodeError.DecodeError { + const need: rs.usize = rs.usizeSaturatingAdd(rs.usizeSub(self.len, self.bufLen), more); + self.need = rs.max(self.need, need); return { tag: "Short" } as DecodeError.DecodeError; } /** The number of unread bytes. */ -export function remaining(self: Decoder): rt.usize { +export function remaining(self: Decoder): rs.usize { return self.bufLen; } @@ -64,7 +64,7 @@ export function isEmpty(self: Decoder): boolean { } /** Read `len` raw bytes. */ -export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | undefined { +export function slice(self: Decoder, len: rs.usize): DecodeError.DecodeError | undefined { const _8Data: Uint8Array = self.bufData; const _8Start: number = self.bufStart; const _8Len: number = self.bufLen; @@ -81,8 +81,8 @@ export function slice(self: Decoder, len: rt.usize): DecodeError.DecodeError | u } /** Read every remaining byte. */ -export function rest(self: Decoder): rt.ByteSlice { - const taken = new rt.ByteSlice(self.bufData, self.bufStart, self.bufLen); +export function rest(self: Decoder): rs.ByteSlice { + const taken = new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen); self.bufData = new Uint8Array(0); self.bufStart = 0; self.bufLen = 0; @@ -90,26 +90,26 @@ export function rest(self: Decoder): rt.ByteSlice { } /** Split off the next `len` bytes as their own decoder, e.g. a size-prefixed body. */ -export function sub(self: Decoder, len: rt.usize): rt.Result { +export function sub(self: Decoder, len: rs.usize): rs.Result { const err: DecodeError.DecodeError | undefined = slice(self, len); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { - return rt.Ok(new_(new rt.ByteSlice(part, part2, part3), self.form)); + return rs.Ok(new_(new rs.ByteSlice(part, part2, part3), self.form)); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** Read a single byte. */ -export function u8(self: Decoder): rt.u8 | undefined { +export function u8(self: Decoder): rs.u8 | undefined { const err: DecodeError.DecodeError | undefined = slice(self, 1); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { if (0 >= part3) { - rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } return part[part2]; } @@ -118,18 +118,18 @@ export function u8(self: Decoder): rt.u8 | undefined { } /** Read a big-endian `u16`. */ -export function u16(self: Decoder): rt.u16 | undefined { +export function u16(self: Decoder): rs.u16 | undefined { const err: DecodeError.DecodeError | undefined = slice(self, 2); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { if (0 >= part3) { - rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + part3 + " but the index is " + 0); } - const _9: rt.u8 = part[part2]; + const _9: rs.u8 = part[part2]; if (1 >= part3) { - rt.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); + rs.panic("index out of bounds: the len is " + part3 + " but the index is " + 1); } return (_9 << 8) | part[part2 + 1]; } @@ -139,10 +139,10 @@ export function u16(self: Decoder): rt.u16 | undefined { /** Read a byte that must be 0 or 1. */ export function bool(self: Decoder): DecodeError.DecodeError | undefined { - const part: rt.u8 | undefined = u8(self); + const part: rs.u8 | undefined = u8(self); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u8.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const val: rt.u8 = part as rt.u8; + const val: rs.u8 = part as rs.u8; if (val === 0) { out$bool.p = false; return undefined; @@ -157,24 +157,24 @@ export function bool(self: Decoder): DecodeError.DecodeError | undefined { } /** Read a varint. */ -export function varint(self: Decoder): rt.u64 | undefined { +export function varint(self: Decoder): rs.u64 | undefined { let _0Err!: boolean; - let _02!: rt.u64; + let _02!: rs.u64; let _03!: DecodeError.DecodeError; - const part: rt.u64 | undefined = read(self.bufData, self.bufStart, self.bufLen, self.form); + const part: rs.u64 | undefined = read(self.bufData, self.bufStart, self.bufLen, self.form); const err2: DecodeError.DecodeError | undefined = part === undefined ? out$tuple2_u64_ref_slice_u8.err as DecodeError.DecodeError : undefined; const part2: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part3: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part4: number = out$tuple2_u64_ref_slice_u8.p_1Len; if (err2 === undefined) { - const value: rt.u64 = part as rt.u64; + const value: rs.u64 = part as rs.u64; self.bufData = part2; self.bufStart = part3; self.bufLen = part4; _0Err = false; _02 = value; } else if ((err2 as DecodeError.DecodeError).tag === "Short") { - const _8: DecodeError.DecodeError = short(self, rt.usizeAdd(self.bufLen, 1)); + const _8: DecodeError.DecodeError = short(self, rs.usizeAdd(self.bufLen, 1)); _0Err = true; _03 = _8; } else { @@ -191,10 +191,10 @@ export function varint(self: Decoder): rt.u64 | undefined { /** Read an optional varint: 0 is `None`, and `n + 1` is `Some(n)`. */ export function varintOpt(self: Decoder): DecodeError.DecodeError | undefined { - const part: rt.u64 | undefined = varint(self); + const part: rs.u64 | undefined = varint(self); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - out$Option_u64.p = rt.u64CheckedSub(part as rt.u64, 1); + out$Option_u64.p = rs.u64CheckedSub(part as rs.u64, 1); return undefined; } return err as DecodeError.DecodeError; @@ -202,14 +202,14 @@ export function varintOpt(self: Decoder): DecodeError.DecodeError | undefined { /** Read a varint length, then that many raw bytes. */ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { - let _0!: rt.Result; + let _0!: rs.Result; const startData: Uint8Array = self.bufData; const startStart: number = self.bufStart; const startLen: number = self.bufLen; - const part: rt.u64 | undefined = varint(self); + const part: rs.u64 | undefined = varint(self); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const _3: rt.Result = result_mapErr$06mnjtr(rt.usizeTryFrom(part as rt.u64), (_2: rt.TryFromIntError): DecodeError.DecodeError => { + const _3: rs.Result = result_mapErr$0o8djoc(rs.usizeTryFrom(part as rs.u64), (_2: rs.TryFromIntError): DecodeError.DecodeError => { return { tag: "BoundsExceeded" } as DecodeError.DecodeError; }); if (_3.ok) { @@ -222,18 +222,18 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { self.bufStart = startStart; self.bufLen = startLen; }; - _0 = inspectErr$156koiv((err2 !== undefined ? rt.Err(err2 as DecodeError.DecodeError) : rt.Ok(new rt.ByteSlice(part2, part3, part4))) as rt.Result, _15); + _0 = inspectErr$157k8w1((err2 !== undefined ? rs.Err(err2 as DecodeError.DecodeError) : rs.Ok(new rs.ByteSlice(part2, part3, part4))) as rs.Result, _15); } else { _0 = _3; } } else { - _0 = rt.Err(err as DecodeError.DecodeError); + _0 = rs.Err(err as DecodeError.DecodeError); } - const result: rt.Result = _0; + const result: rs.Result = _0; if (!result.ok) { return result.error; } - const slice_: rt.ByteSlice = result.value; + const slice_: rs.ByteSlice = result.value; out$ref_slice_u8.pData = slice_.data; out$ref_slice_u8.pStart = slice_.start; out$ref_slice_u8.pLen = slice_.length; @@ -241,19 +241,19 @@ export function bytes(self: Decoder): DecodeError.DecodeError | undefined { } /** Read a varint length, then that many bytes of UTF-8. */ -export function string(self: Decoder): rt.Result { +export function string(self: Decoder): rs.Result { const err: DecodeError.DecodeError | undefined = bytes(self); const part: Uint8Array = out$ref_slice_u8.pData; const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { - const _2: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(new rt.ByteSlice(part, part2, part3))); + const _2: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(new rs.ByteSlice(part, part2, part3))); if (_2.ok) { - return rt.Ok(_2.value); + return rs.Ok(_2.value); } - return rt.Err(DecodeError.from$convert_From_string_FromUtf8Error((_2 as { ok: false; error: rt.FromUtf8Error }).error)); + return rs.Err(DecodeError.from$convert_From_string_FromUtf8Error((_2 as { ok: false; error: rs.FromUtf8Error }).error)); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts index 7b676e8fe..91bd019db 100644 --- a/ts/fixtures/codec/expected/coding/encode.EncodeError.ts +++ b/ts/fixtures/codec/expected/coding/encode.EncodeError.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; -export function fmt$fmt_Display(self: EncodeError, __formatter: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: EncodeError, __formatter: rs.Formatter): rs.Result { if (self === "BoundsExceeded") { - return rt.fmtWriteStr(__formatter, "bounds exceeded"); + return rs.fmtWriteStr(__formatter, "bounds exceeded"); } if (self === "TooLarge") { - return rt.fmtWriteStr(__formatter, "too large"); + return rs.fmtWriteStr(__formatter, "too large"); } if (self === "Short") { - return rt.fmtWriteStr(__formatter, "short buffer"); + return rs.fmtWriteStr(__formatter, "short buffer"); } if (self === "InvalidState") { - return rt.fmtWriteStr(__formatter, "invalid state"); + return rs.fmtWriteStr(__formatter, "invalid state"); } if (self === "TooMany") { - return rt.fmtWriteStr(__formatter, "too many"); + return rs.fmtWriteStr(__formatter, "too many"); } if (self === "Version") { - return rt.fmtWriteStr(__formatter, "unsupported version"); + return rs.fmtWriteStr(__formatter, "unsupported version"); } - return rt.fmtWriteStr(__formatter, "unsupported"); + return rs.fmtWriteStr(__formatter, "unsupported"); } -export function fmt$fmt_Debug(self: EncodeError, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: EncodeError, f: rs.Formatter): rs.Result { let _3!: string; if (self === "BoundsExceeded") { _3 = "BoundsExceeded"; @@ -42,7 +42,7 @@ export function fmt$fmt_Debug(self: EncodeError, f: rt.Formatter): rt.Result { +export function varint(self: Encoder, v: rs.u64): rs.Result { if (write(v, self.form, self.buf).ok) { - return rt.OK; + return rs.OK; } - return rt.Err(EncodeError.from$convert_From_coding_varint_BoundsExceeded({})); + return rs.Err(EncodeError.from$convert_From_coding_varint_BoundsExceeded({})); } /** Write an optional varint: `None` as 0, and `Some(n)` as `n + 1`. */ -export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - let v2!: rt.u64; +export function varintOpt(self: Encoder, v: rs.u64 | undefined): rs.Result { + let v2!: rs.u64; if (v === undefined) { v2 = 0; } else { - const _6: rt.Result = option_okOr$1lamf4s(rt.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); + const _6: rs.Result = option_okOr$08cl3no(rs.u64CheckedAdd(v, 1), "TooLarge" as EncodeError.EncodeError); if (_6.ok) { v2 = _6.value; } else { @@ -71,18 +71,18 @@ export function varintOpt(self: Encoder, v: rt.u64 | undefined): rt.Result { - const _3: rt.Result = varint(self, v.length as rt.u64); +export function bytes(self: Encoder, v: rs.ByteSlice): rs.Result { + const _3: rs.Result = varint(self, v.length as rs.u64); if (_3.ok) { slice(self, v); - return rt.OK; + return rs.OK; } return _3; } /** Write a varint length, then the UTF-8 bytes. */ -export function string(self: Encoder, v: string): rt.Result { - return bytes(self, rt.stringAsBytes(v)); +export function string(self: Encoder, v: string): rs.Result { + return bytes(self, rs.stringAsBytes(v)); } /** @@ -91,73 +91,73 @@ export function string(self: Encoder, v: string): rt.Result { - const body: rt.usize = prefix.body; - const end: rt.usize = self.buf.length; +export function fill(self: Encoder, prefix: Prefix.Prefix): rs.Result { + const body: rs.usize = prefix.body; + const end: rs.usize = self.buf.length; if (prefix.kind === "Varint") { - if (write(rt.usizeSub(end, body) as rt.u64, self.form, self.buf).ok) { - const len: rt.usize = rt.usizeSub(self.buf.length, end); + if (write(rs.usizeSub(end, body) as rs.u64, self.form, self.buf).ok) { + const len: rs.usize = rs.usizeSub(self.buf.length, end); if (!(len === 1)) { - const size2: Uint8Array = rt.bytes(9); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(size2), 0, len), rt.byteSliceRange(rt.byteVecSlice(self.buf), end)); - rt.byteVecTruncate(self.buf, rt.usizeSub(rt.usizeAdd(end, len), 1)); - rt.byteSliceCopyWithin(rt.byteVecSlice(self.buf), body, end, rt.usizeSub(rt.usizeAdd(body, len), 1)); - const _84: rt.ByteVec = self.buf; - const part2 = rt.usizeSub(body, 1); - const part3 = rt.usizeAdd(rt.usizeSub(body, 1), len); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteVecSlice(_84), part2, part3), rt.byteSliceRange(rt.byteSliceFrom(size2), 0, len)); + const size2: Uint8Array = rs.bytes(9); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(size2), 0, len), rs.byteSliceRange(rs.byteVecSlice(self.buf), end)); + rs.byteVecTruncate(self.buf, rs.usizeSub(rs.usizeAdd(end, len), 1)); + rs.byteSliceCopyWithin(rs.byteVecSlice(self.buf), body, end, rs.usizeSub(rs.usizeAdd(body, len), 1)); + const _84: rs.ByteVec = self.buf; + const part2 = rs.usizeSub(body, 1); + const part3 = rs.usizeAdd(rs.usizeSub(body, 1), len); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteVecSlice(_84), part2, part3), rs.byteSliceRange(rs.byteSliceFrom(size2), 0, len)); } else { - const _78: rt.ByteVec = self.buf; - const _35: rt.u8 = _78.data[rt.idx(_78, end)]; - const _79: rt.ByteVec = self.buf; - _79.data[rt.idx(_79, rt.usizeSub(body, 1))] = _35; - rt.byteVecTruncate(self.buf, end); - return rt.OK; + const _78: rs.ByteVec = self.buf; + const _35: rs.u8 = _78.data[rs.idx(_78, end)]; + const _79: rs.ByteVec = self.buf; + _79.data[rs.idx(_79, rs.usizeSub(body, 1))] = _35; + rs.byteVecTruncate(self.buf, end); + return rs.OK; } } else { - return rt.Err(EncodeError.from$convert_From_coding_varint_BoundsExceeded({})); + return rs.Err(EncodeError.from$convert_From_coding_varint_BoundsExceeded({})); } } else { - const _7: rt.Result = result_mapErr$0ujtlj1(rt.u16TryFrom(rt.usizeSub(end, body)), (_2: rt.TryFromIntError): EncodeError.EncodeError => { + const _7: rs.Result = result_mapErr$0f1want(rs.u16TryFrom(rs.usizeSub(end, body)), (_2: rs.TryFromIntError): EncodeError.EncodeError => { return "TooLarge" as EncodeError.EncodeError; }); if (_7.ok) { - const size: rt.u16 = _7.value; - const _75: rt.ByteVec = self.buf; - const part = rt.usizeSub(body, 2); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteVecSlice(_75), part, body), rt.byteSliceFrom(rt.u16ToBeBytes(size))); + const size: rs.u16 = _7.value; + const _75: rs.ByteVec = self.buf; + const part = rs.usizeSub(body, 2); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteVecSlice(_75), part, body), rs.byteSliceFrom(rs.u16ToBeBytes(size))); } else { return _7; } } - return rt.OK; + return rs.OK; } export { new_ as new }; diff --git a/ts/fixtures/codec/expected/coding/encode.Prefix.ts b/ts/fixtures/codec/expected/coding/encode.Prefix.ts index 49ab45b37..8ec64f748 100644 --- a/ts/fixtures/codec/expected/coding/encode.Prefix.ts +++ b/ts/fixtures/codec/expected/coding/encode.Prefix.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as PrefixKind from "../coding/encode.PrefixKind.ts"; /** A size prefix reserved ahead of a body, sized by [`Encoder::fill`] once it is written. */ export interface Prefix { /** Where the body starts, just past the reserved bytes. */ - body: rt.usize; + body: rs.usize; kind: PrefixKind.PrefixKind; } diff --git a/ts/fixtures/codec/expected/coding/varint.BoundsExceeded.ts b/ts/fixtures/codec/expected/coding/varint.BoundsExceeded.ts index 6887438fa..4a48bc5ae 100644 --- a/ts/fixtures/codec/expected/coding/varint.BoundsExceeded.ts +++ b/ts/fixtures/codec/expected/coding/varint.BoundsExceeded.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function fmt$fmt_Debug(_self: BoundsExceeded, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "BoundsExceeded"); +export function fmt$fmt_Debug(_self: BoundsExceeded, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "BoundsExceeded"); } -export function fmt$fmt_Display(_self: BoundsExceeded, __formatter: rt.Formatter): rt.Result { - return rt.fmtWriteStr(__formatter, "value out of range"); +export function fmt$fmt_Display(_self: BoundsExceeded, __formatter: rs.Formatter): rs.Result { + return rs.fmtWriteStr(__formatter, "value out of range"); } /** The number does not fit the target: a varint wire form or a narrower integer. */ diff --git a/ts/fixtures/codec/expected/coding/varint.ts b/ts/fixtures/codec/expected/coding/varint.ts index 35f589610..c275d8594 100644 --- a/ts/fixtures/codec/expected/coding/varint.ts +++ b/ts/fixtures/codec/expected/coding/varint.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$tuple2_u64_ref_slice_u8, out$usize } from "../lib.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import type * as BoundsExceeded from "../coding/varint.BoundsExceeded.ts"; import type * as Form from "../coding/varint.Form.ts"; /** The high and low 32 bits: the only place the codec splits a `u64`. */ -export function toHalves(value: rt.u64): [rt.u32, rt.u32] { - return [rt.u64Low(rt.u64Shr(value, 32)), rt.u64Low(value)] as [rt.u32, rt.u32]; +export function toHalves(value: rs.u64): [rs.u32, rs.u32] { + return [rs.u64Low(rs.u64Shr(value, 32)), rs.u64Low(value)] as [rs.u32, rs.u32]; } /** The inverse of [`to_halves`]. */ -export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { - return rt.u64FromHalves(hi, lo); +export function fromHalves(hi: rs.u32, lo: rs.u32): rs.u64 { + return rs.u64FromHalves(hi, lo); } /** The bytes `value` takes on the wire in `form`, or [`BoundsExceeded`] if it does not fit. */ -export function size(value: rt.u64, form: Form.Form): rt.usize | undefined { - const _5: [rt.u32, rt.u32] = toHalves(value); - const hi: rt.u32 = _5[0]; - const lo: rt.u32 = _5[1]; +export function size(value: rs.u64, form: Form.Form): rs.usize | undefined { + const _5: [rs.u32, rs.u32] = toHalves(value); + const hi: rs.u32 = _5[0]; + const lo: rs.u32 = _5[1]; if (form.tag === "Quic") { if (hi === 0) { if (lo < 64) { @@ -80,119 +80,119 @@ export function size(value: rt.u64, form: Form.Form): rt.usize | undefined { * * Fails past [`MAX_QUIC`] in the QUIC form, writing nothing. */ -export function write(value: rt.u64, form: Form.Form, out: rt.ByteVec): rt.Result { +export function write(value: rs.u64, form: Form.Form, out: rs.ByteVec): rs.Result { if (form.tag === "Quic") { return writeQuic(value, out); } writeLeadingOnes(value, out); - return rt.OK; + return rs.OK; } -export function writeQuic(value: rt.u64, out: rt.ByteVec): rt.Result { - const _5: [rt.u32, rt.u32] = toHalves(value); +export function writeQuic(value: rs.u64, out: rs.ByteVec): rs.Result { + const _5: [rs.u32, rs.u32] = toHalves(value); b1: { - const hi: rt.u32 = _5[0]; - const lo: rt.u32 = _5[1]; + const hi: rs.u32 = _5[0]; + const lo: rs.u32 = _5[1]; if (hi === 0) { if (lo < 64) { - rt.byteVecPush(out, lo & 0xff); + rs.byteVecPush(out, lo & 0xff); break b1; } } if (hi === 0) { if (lo < 16384) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(16384 | (lo & 0xffff)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(16384 | (lo & 0xffff)))); break b1; } } if (hi === 0) { if (lo < 1073741824) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((2147483648 | lo) >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes((2147483648 | lo) >>> 0))); break b1; } } if (!(hi < 1073741824)) { - return rt.Err({}); + return rs.Err({}); } - const _42: Uint8Array = rt.u32ToBeBytes((3221225472 | hi) >>> 0); - const a: rt.u8 = _42[0]; - const b: rt.u8 = _42[1]; - const c: rt.u8 = _42[2]; - const d: rt.u8 = _42[3]; - const _48: Uint8Array = rt.u32ToBeBytes(lo); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3]))); + const _42: Uint8Array = rs.u32ToBeBytes((3221225472 | hi) >>> 0); + const a: rs.u8 = _42[0]; + const b: rs.u8 = _42[1]; + const c: rs.u8 = _42[2]; + const d: rs.u8 = _42[3]; + const _48: Uint8Array = rs.u32ToBeBytes(lo); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b, c, d, _48[0], _48[1], _48[2], _48[3]))); } - return rt.OK; + return rs.OK; } -export function writeLeadingOnes(value: rt.u64, out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = toHalves(value); - const hi: rt.u32 = _5[0]; - const lo: rt.u32 = _5[1]; - const _10: Uint8Array = rt.u32ToBeBytes(lo); +export function writeLeadingOnes(value: rs.u64, out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = toHalves(value); + const hi: rs.u32 = _5[0]; + const lo: rs.u32 = _5[1]; + const _10: Uint8Array = rs.u32ToBeBytes(lo); b0: { - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; - const c: rt.u8 = _10[2]; - const d: rt.u8 = _10[3]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; + const c: rs.u8 = _10[2]; + const d: rs.u8 = _10[3]; if (hi === 0) { if (lo < 128) { - rt.byteVecPush(out, d); + rs.byteVecPush(out, d); break b0; } } if (hi === 0) { if (lo < 16384) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(128 | c, d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(128 | c, d))); break b0; } } if (hi === 0) { if (lo < 2097152) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(192 | b, c, d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(192 | b, c, d))); break b0; } } if (hi === 0) { if (lo < 268435456) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(224 | a, b, c, d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(224 | a, b, c, d))); break b0; } } if (!(hi < 8)) { if (!(hi < 1024)) { if (!(hi < 16777216)) { - const _87: Uint8Array = rt.u32ToBeBytes(hi); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(255, _87[0], _87[1], _87[2], _87[3], a, b, c, d))); + const _87: Uint8Array = rs.u32ToBeBytes(hi); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(255, _87[0], _87[1], _87[2], _87[3], a, b, c, d))); } else { - const _78: Uint8Array = rt.u32ToBeBytes(hi); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(254, _78[1], _78[2], _78[3], a, b, c, d))); + const _78: Uint8Array = rs.u32ToBeBytes(hi); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(254, _78[1], _78[2], _78[3], a, b, c, d))); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(248 | ((hi >>> 8) & 0xff), hi & 0xff, a, b, c, d))); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(240 | (hi & 0xff), a, b, c, d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(240 | (hi & 0xff), a, b, c, d))); } } } /** Decode a varint in `form` from the front of `buf`, returning it and the rest of `buf`. */ -export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rt.u64 | undefined { +export function read(bufData: Uint8Array, bufStart: number, bufLen: number, form: Form.Form): rs.u64 | undefined { if (form.tag === "Quic") { return readQuic(bufData, bufStart, bufLen); } return readLeadingOnes(bufData, bufStart, bufLen, form.seven); } -export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rt.u64 | undefined { +export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): rs.u64 | undefined { if (bufLen !== 0) { - const first: rt.u8 = bufData[bufStart]; + const first: rs.u8 = bufData[bufStart]; if (!(first < 64)) { if (!(first < 128)) { if (!(first < 192)) { if (bufLen >= 8) { - const _61_0: rt.u64 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); + const _61_0: rs.u64 = fromHalves((((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0, ((bufData[bufStart + 4] << 24) | (bufData[bufStart + 5] << 16) | (bufData[bufStart + 6] << 8) | bufData[bufStart + 7]) >>> 0); out$tuple2_u64_ref_slice_u8.p_1Data = bufData; out$tuple2_u64_ref_slice_u8.p_1Start = bufStart + 8; out$tuple2_u64_ref_slice_u8.p_1Len = bufLen - 8; @@ -202,7 +202,7 @@ export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): return undefined; } if (bufLen >= 4) { - const _40_0: rt.u64 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + const _40_0: rs.u64 = (((bufData[bufStart] & 63) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rs.u64; out$tuple2_u64_ref_slice_u8.p_1Data = bufData; out$tuple2_u64_ref_slice_u8.p_1Start = bufStart + 4; out$tuple2_u64_ref_slice_u8.p_1Len = bufLen - 4; @@ -212,7 +212,7 @@ export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): return undefined; } if (bufLen >= 2) { - const _21_0: rt.u64 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + const _21_0: rs.u64 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rs.u64; out$tuple2_u64_ref_slice_u8.p_1Data = bufData; out$tuple2_u64_ref_slice_u8.p_1Start = bufStart + 2; out$tuple2_u64_ref_slice_u8.p_1Len = bufLen - 2; @@ -224,28 +224,28 @@ export function readQuic(bufData: Uint8Array, bufStart: number, bufLen: number): out$tuple2_u64_ref_slice_u8.p_1Data = bufData; out$tuple2_u64_ref_slice_u8.p_1Start = bufStart + 1; out$tuple2_u64_ref_slice_u8.p_1Len = bufLen - 1; - return first as rt.u64; + return first as rs.u64; } out$tuple2_u64_ref_slice_u8.err = { tag: "Short" } as DecodeError.DecodeError; return undefined; } -export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rt.u64 | undefined { - let _8_0!: rt.u64; +export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: number, seven: boolean): rs.u64 | undefined { + let _8_0!: rs.u64; let _8_1Data!: Uint8Array; let _8_1Start!: number; let _8_1Len!: number; if (bufLen !== 0) { - const first: rt.u8 = bufData[bufStart]; - const _9: rt.u32 = rt.u8LeadingOnes(first); + const first: rs.u8 = bufData[bufStart]; + const _9: rs.u32 = rs.u8LeadingOnes(first); if (_9 === 0) { - _8_0 = first as rt.u64; + _8_0 = first as rs.u64; _8_1Data = bufData; _8_1Start = bufStart + 1; _8_1Len = bufLen - 1; } else if (_9 === 1) { if (bufLen >= 2) { - _8_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rt.u64; + _8_0 = (((bufData[bufStart] & 63) << 8) | bufData[bufStart + 1]) as rs.u64; _8_1Data = bufData; _8_1Start = bufStart + 2; _8_1Len = bufLen - 2; @@ -255,7 +255,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n } } else if (_9 === 2) { if (bufLen >= 3) { - _8_0 = (((bufData[bufStart] & 31) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2]) as rt.u64; + _8_0 = (((bufData[bufStart] & 31) << 16) | (bufData[bufStart + 1] << 8) | bufData[bufStart + 2]) as rs.u64; _8_1Data = bufData; _8_1Start = bufStart + 3; _8_1Len = bufLen - 3; @@ -265,7 +265,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n } } else if (_9 === 3) { if (bufLen >= 4) { - _8_0 = (((bufData[bufStart] & 15) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rt.u64; + _8_0 = (((bufData[bufStart] & 15) << 24) | (bufData[bufStart + 1] << 16) | (bufData[bufStart + 2] << 8) | bufData[bufStart + 3]) >>> 0 as rs.u64; _8_1Data = bufData; _8_1Start = bufStart + 4; _8_1Len = bufLen - 4; @@ -275,7 +275,7 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n } } else if (_9 === 4) { if (bufLen >= 5) { - _8_0 = fromHalves((bufData[bufStart] & 7) as rt.u32, ((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0); + _8_0 = fromHalves((bufData[bufStart] & 7) as rs.u32, ((bufData[bufStart + 1] << 24) | (bufData[bufStart + 2] << 16) | (bufData[bufStart + 3] << 8) | bufData[bufStart + 4]) >>> 0); _8_1Data = bufData; _8_1Start = bufStart + 5; _8_1Len = bufLen - 5; @@ -340,13 +340,13 @@ export function readLeadingOnes(bufData: Uint8Array, bufStart: number, bufLen: n * * Small magnitudes stay small (-1 -> 1, 1 -> 2, -2 -> 3, ...), and all of `i64` fits. */ -export function zigzag(signed: rt.i64): rt.u64 { - return rt.u64Cast(rt.i64Xor(rt.i64Shl(signed, 1), rt.i64Shr(signed, 63))); +export function zigzag(signed: rs.i64): rs.u64 { + return rs.u64Cast(rs.i64Xor(rs.i64Shl(signed, 1), rs.i64Shr(signed, 63))); } /** The inverse of [`zigzag`]. */ -export function unzigzag(value: rt.u64): rt.i64 { - return rt.i64Xor(rt.i64Cast(rt.u64Shr(value, 1)), rt.i64Neg(rt.i64Cast(rt.u64And(value, 1)))); +export function unzigzag(value: rs.u64): rs.i64 { + return rs.i64Xor(rs.i64Cast(rs.u64Shr(value, 1)), rs.i64Neg(rs.i64Cast(rs.u64And(value, 1)))); } //# sourceMappingURL=varint.ts.map diff --git a/ts/fixtures/codec/expected/coding/version.Version.ts b/ts/fixtures/codec/expected/coding/version.Version.ts index ad6d8d9ca..bf5f92fa9 100644 --- a/ts/fixtures/codec/expected/coding/version.Version.ts +++ b/ts/fixtures/codec/expected/coding/version.Version.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$u64 } from "../lib.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; @@ -11,33 +11,33 @@ import type * as lite_version_Version from "../lite/version.Version.ts"; /** A version number negotiated during the setup. */ export interface Version { - _0: rt.u64; + _0: rs.u64; } /** Decode the version number. */ -export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decoder, _2: Form.Form): rt.Result { - const part: rt.u64 | undefined = Decoder.varint(r); +export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decoder, _2: Form.Form): rs.Result { + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - return rt.Ok({ _0: part as rt.u64 }); + return rs.Ok({ _0: part as rs.u64 }); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$coding_encode_Encode_coding_varint_Form(self: Version, w: Encoder.Encoder, _3: Form.Form): rt.Result { - const _4: rt.Result = Encoder.varint(w, self._0); +export function encode$coding_encode_Encode_coding_varint_Form(self: Version, w: Encoder.Encoder, _3: Form.Form): rs.Result { + const _4: rs.Result = Encoder.varint(w, self._0); if (_4.ok) { - return rt.OK; + return rs.OK; } return _4; } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$coding_encode_Encode_lite_version_Version(self: Version, w: Encoder.Encoder, _3: lite_version_Version.Version): rt.Result { - const _4: rt.Result = Encoder.varint(w, self._0); +export function encode$coding_encode_Encode_lite_version_Version(self: Version, w: Encoder.Encoder, _3: lite_version_Version.Version): rs.Result { + const _4: rs.Result = Encoder.varint(w, self._0); if (_4.ok) { - return rt.OK; + return rs.OK; } return _4; } diff --git a/ts/fixtures/codec/expected/coding/version.Versions.ts b/ts/fixtures/codec/expected/coding/version.Versions.ts index fd3b0fcb7..cee202c6f 100644 --- a/ts/fixtures/codec/expected/coding/version.Versions.ts +++ b/ts/fixtures/codec/expected/coding/version.Versions.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$u64 } from "../lib.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; @@ -11,73 +11,73 @@ import * as coding_version_Version from "../coding/version.Version.ts"; import type * as lite_version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_coding_varint_Form(buf: rt.ByteSlice, version: Form.Form): rt.Result<[Versions, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$coding_decode_Decode_coding_varint_Form(buf: rs.ByteSlice, version: Form.Form): rs.Result<[Versions, rs.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, version); - const _5: rt.Result = decode$coding_decode_Decode_coding_varint_Form(r, version); + const _5: rs.Result = decode$coding_decode_Decode_coding_varint_Form(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rt.usize]); + return rs.Ok([_5.value, rs.usizeSub(buf.length, Decoder.remaining(r))] as [Versions, rs.usize]); } return _5; } /** A list of versions in preferred order. */ export interface Versions { - _0: rt.Vec; + _0: rs.Vec; } /** Decode the version list. */ -export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decoder, version: Form.Form): rt.Result { - const part: rt.u64 | undefined = Decoder.varint(r); +export function decode$coding_decode_Decode_coding_varint_Form(r: Decoder.Decoder, version: Form.Form): rs.Result { + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const count: rt.u64 = part as rt.u64; - const vs: rt.Vec = new rt.Vec(); - const iter: rt.Range = new rt.Range(0, count, rt.u64Step); - while (iter.next() !== rt.DONE) { - const _15: rt.Result = coding_version_Version.decode$coding_decode_Decode_coding_varint_Form(r, version); + const count: rs.u64 = part as rs.u64; + const vs: rs.Vec = new rs.Vec(); + const iter: rs.Range = new rs.Range(0, count, rs.u64Step); + while (iter.next() !== rs.DONE) { + const _15: rs.Result = coding_version_Version.decode$coding_decode_Decode_coding_varint_Form(r, version); if (_15.ok) { vs.items.push(_15.value); } else { return _15; } } - return rt.Ok({ _0: vs }); + return rs.Ok({ _0: vs }); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** Encode the version list. */ -export function encode$coding_encode_Encode_coding_varint_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rt.Result { - const _4: rt.Result = Encoder.varint(w, self._0.items.length as rt.u64); +export function encode$coding_encode_Encode_coding_varint_Form(self: Versions, w: Encoder.Encoder, version: Form.Form): rs.Result { + const _4: rs.Result = Encoder.varint(w, self._0.items.length as rs.u64); if (_4.ok) { for (const _14 of self._0.items) { - const _18: rt.Result = coding_version_Version.encode$coding_encode_Encode_coding_varint_Form(_14, w, version); + const _18: rs.Result = coding_version_Version.encode$coding_encode_Encode_coding_varint_Form(_14, w, version); if (!_18.ok) { return _18; } } - return rt.OK; + return rs.OK; } return _4; } /** Encode the version list. */ -export function encode$coding_encode_Encode_lite_version_Version(self: Versions, w: Encoder.Encoder, version: lite_version_Version.Version): rt.Result { - const _4: rt.Result = Encoder.varint(w, self._0.items.length as rt.u64); +export function encode$coding_encode_Encode_lite_version_Version(self: Versions, w: Encoder.Encoder, version: lite_version_Version.Version): rs.Result { + const _4: rs.Result = Encoder.varint(w, self._0.items.length as rs.u64); if (_4.ok) { for (const _14 of self._0.items) { - const _18: rt.Result = coding_version_Version.encode$coding_encode_Encode_lite_version_Version(_14, w, version); + const _18: rs.Result = coding_version_Version.encode$coding_encode_Encode_lite_version_Version(_14, w, version); if (!_18.ok) { return _18; } } - return rt.OK; + return rs.OK; } return _4; } export function from$convert_From_array2_coding_version_Version(vs: coding_version_Version.Version[]): Versions { - return { _0: rt.vecFrom(vs.slice()) }; + return { _0: rs.vecFrom(vs.slice()) }; } //# sourceMappingURL=version.Versions.ts.map diff --git a/ts/fixtures/codec/expected/core/bool.ts b/ts/fixtures/codec/expected/core/bool.ts index 492c81ecd..b92d1f157 100644 --- a/ts/fixtures/codec/expected/core/bool.ts +++ b/ts/fixtures/codec/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1ugl8af(self: boolean, t: rt.u64): rt.u64 | undefined { +export function thenSome$0be218t(self: boolean, t: rs.u64): rs.u64 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/codec/expected/core/option.ts b/ts/fixtures/codec/expected/core/option.ts index efb225183..f2b27b988 100644 --- a/ts/fixtures/codec/expected/core/option.ts +++ b/ts/fixtures/codec/expected/core/option.ts @@ -1,41 +1,41 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; -export function unwrapOr$11c0we2(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { +export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$1tvry1i(self: rt.u64 | undefined, default_: rt.u64): rt.u64 { +export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs.u64 { if (self === undefined) { return default_; } return self; } -export function map$1cf8u0y(self: rt.u64 | undefined, f: (a0: rt.u64) => rt.u64): rt.u64 | undefined { +export function map$1haiqd3(self: rs.u64 | undefined, f: (a0: rs.u64) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1jt76jv(self: rt.u32 | undefined, default_: rt.u64, _: (a0: rt.u32) => rt.u64): rt.u64 { +export function mapOr$1glsik0(self: rs.u32 | undefined, default_: rs.u64, _: (a0: rs.u32) => rs.u64): rs.u64 { if (self === undefined) { return default_; } - return self as rt.u64; + return self as rs.u64; } -export function okOr$1lamf4s(self: rt.u64 | undefined, err: EncodeError.EncodeError): rt.Result { +export function okOr$08cl3no(self: rs.u64 | undefined, err: EncodeError.EncodeError): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/codec/expected/core/result.ts b/ts/fixtures/codec/expected/core/result.ts index 7df0be5cd..9fb273c27 100644 --- a/ts/fixtures/codec/expected/core/result.ts +++ b/ts/fixtures/codec/expected/core/result.ts @@ -1,61 +1,61 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as DecodeError from "../coding/decode.DecodeError.ts"; import type * as EncodeError from "../coding/encode.EncodeError.ts"; import type * as Group from "../lite/group.Group.ts"; import type * as Probe from "../lite/probe.Probe.ts"; -export function mapErr$0577706(self: rt.Result, _: (a0: DecodeError.DecodeError) => DecodeError.DecodeError): rt.Result { +export function mapErr$02fx80t(self: rs.Result, _: (a0: DecodeError.DecodeError) => DecodeError.DecodeError): rs.Result { if (self.ok) { return self; } - return rt.Err(DecodeError.complete(self.error)); + return rs.Err(DecodeError.complete(self.error)); } -export function mapErr$04g1m7s(self: rt.Result, _: (a0: DecodeError.DecodeError) => DecodeError.DecodeError): rt.Result { +export function mapErr$0ro6mbb(self: rs.Result, _: (a0: DecodeError.DecodeError) => DecodeError.DecodeError): rs.Result { if (self.ok) { return self; } - return rt.Err(DecodeError.complete(self.error)); + return rs.Err(DecodeError.complete(self.error)); } -export function mapErr$0ujtlj1(self: rt.Result, op: (a0: rt.TryFromIntError) => EncodeError.EncodeError): rt.Result { +export function mapErr$0f1want(self: rs.Result, op: (a0: rs.TryFromIntError) => EncodeError.EncodeError): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function mapErr$06mnjtr(self: rt.Result, op: (a0: rt.TryFromIntError) => DecodeError.DecodeError): rt.Result { +export function mapErr$0o8djoc(self: rs.Result, op: (a0: rs.TryFromIntError) => DecodeError.DecodeError): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function inspectErr$156koiv(self: rt.Result, f: (a0: DecodeError.DecodeError) => undefined): rt.Result { +export function inspectErr$157k8w1(self: rs.Result, f: (a0: DecodeError.DecodeError) => undefined): rs.Result { if (!self.ok) { f(self.error); } return self; } -export function andThen$0hcfsqc(self: rt.Result, op: (a0: Group.Group) => rt.Result): rt.Result { +export function andThen$0xo70ms(self: rs.Result, op: (a0: Group.Group) => rs.Result): rs.Result { if (self.ok) { return op(self.value); } return self; } -export function andThen$1kvlask(self: rt.Result, op: (a0: Probe.Probe) => rt.Result): rt.Result { +export function andThen$0bc8wcd(self: rs.Result, op: (a0: Probe.Probe) => rs.Result): rs.Result { if (self.ok) { return op(self.value); } return self; } -export function unwrapOr$0jeml8j(self: rt.Result, default_: rt.usize): rt.usize { +export function unwrapOr$0a2fg79(self: rs.Result, default_: rs.usize): rs.usize { if (self.ok) { return self.value; } diff --git a/ts/fixtures/codec/expected/harness.ts b/ts/fixtures/codec/expected/harness.ts index b83888cdf..563fce646 100644 --- a/ts/fixtures/codec/expected/harness.ts +++ b/ts/fixtures/codec/expected/harness.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$Option_u64, out$bool, out$ref_slice_u8, out$u16, out$u64, out$u8, out$usize } from "./lib.ts"; import * as DecodeError from "./coding/decode.DecodeError.ts"; import * as Decoder from "./coding/decode.Decoder.ts"; @@ -11,7 +11,7 @@ import { size, zigzag as varint_zigzag, unzigzag } from "./coding/varint.ts"; import * as BoundsExceeded from "./coding/varint.BoundsExceeded.ts"; import * as Form from "./coding/varint.Form.ts"; import * as Versions from "./coding/version.Versions.ts"; -import { thenSome$1ugl8af } from "./core/bool.ts"; +import { thenSome$0be218t } from "./core/bool.ts"; import type * as SessionError from "./lib.SessionError.ts"; import * as Group from "./lite/group.Group.ts"; import * as Probe from "./lite/probe.Probe.ts"; @@ -21,38 +21,38 @@ import type * as lite_version_Version from "./lite/version.Version.ts"; * Each case's name and what it runs. The first byte picks one modulo their count, so a * case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]> { - return rt.vecFrom([["decode_script", (a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]> { + return rs.vecFrom([["decode_script", (a0: rs.ByteSlice, a1: rs.ByteVec): undefined => { decodeScript(a0.data, a0.start, a0.length, a1); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["encode_script", (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["encode_script", (a02: rs.ByteSlice, a12: rs.ByteVec): undefined => { encodeScript(a02.data, a02.start, a02.length, a12); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["zigzag", zigzag as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["sizes", sizes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["roundtrip", (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["zigzag", zigzag as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["sizes", sizes as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["roundtrip", (a03: rs.ByteSlice, a13: rs.ByteVec): undefined => { roundtrip$coding_version_Versions(a03.data, a03.start, a03.length, a13); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["roundtrip_lite::", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["roundtrip_lite::", (a04: rs.ByteSlice, a14: rs.ByteVec): undefined => { roundtripLite$lite_group_Group(a04.data, a04.start, a04.length, a14); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["roundtrip_lite::", (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["roundtrip_lite::", (a05: rs.ByteSlice, a15: rs.ByteVec): undefined => { roundtripLite$lite_probe_Probe(a05.data, a05.start, a05.length, a15); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["encode_messages", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["encode_messages", (a06: rs.ByteSlice, a16: rs.ByteVec): undefined => { encodeMessages(a06.data, a06.start, a06.length, a16); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["errors", (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["errors", (a07: rs.ByteSlice, a17: rs.ByteVec): undefined => { errors(a07.data, a07.start, a07.length, a17); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); } /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (input.length !== 0) { - const op: rt.u8 = input.data[input.start]; - const cases_: rt.Vec<[string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(op as rt.usize, cases_.items.length))][1](new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + const op: rs.u8 = input.data[input.start]; + const cases_: rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(op as rs.usize, cases_.items.length))][1](new rs.ByteSlice(input.data, input.start + 1, input.length - 1), out); return out; } return out; } -export function form(selector: rt.u8): Form.Form { - const _2: rt.u8 = rt.u8Rem(selector, 3); +export function form(selector: rs.u8): Form.Form { + const _2: rs.u8 = rs.u8Rem(selector, 3); if (_2 === 0) { return { tag: "Quic" } as Form.Form; } @@ -62,8 +62,8 @@ export function form(selector: rt.u8): Form.Form { return { tag: "LeadingOnes", seven: true } as Form.Form; } -export function liteVersion(selector: rt.u8): lite_version_Version.Version { - const _2: rt.u8 = rt.u8Rem(selector, 7); +export function liteVersion(selector: rs.u8): lite_version_Version.Version { + const _2: rs.u8 = rs.u8Rem(selector, 7); if (_2 === 0) { return "Lite01" as lite_version_Version.Version; } @@ -85,95 +85,95 @@ export function liteVersion(selector: rt.u8): lite_version_Version.Version { return "Lite07" as lite_version_Version.Version; } -export function putU64(out: rt.ByteVec, value: rt.u64): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(value))); +export function putU64(out: rs.ByteVec, value: rs.u64): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(value))); } -export function putUsize(out: rt.ByteVec, value: rt.usize): void { - putU64(out, value as rt.u64); +export function putUsize(out: rs.ByteVec, value: rs.usize): void { + putU64(out, value as rs.u64); } /** Take up to 8 big-endian bytes as a `u64`, zero-padded on the right. */ -export function takeU64(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, 8); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - return [rt.u64FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u64, rt.ByteSlice]; +export function takeU64(data: rs.ByteSlice): [rs.u64, rs.ByteSlice] { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, 8); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + return [rs.u64FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.u64, rs.ByteSlice]; } /** A decode error's code, then its text. */ -export function decodeFailed(out: rt.ByteVec, err: DecodeError.DecodeError): void { +export function decodeFailed(out: rs.ByteVec, err: DecodeError.DecodeError): void { decodeError(out, err); - const _5: string = rt.fmtToString((f: rt.Formatter) => DecodeError.fmt$fmt_Display(err, f)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; - putText(out, _5, rt.fmtFormat([args2[0]])); + const _5: string = rs.fmtToString((f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; + putText(out, _5, rs.fmtFormat([args2[0]])); } /** An encode error's code, then its text. */ -export function encodeFailed(out: rt.ByteVec, err: EncodeError.EncodeError): void { +export function encodeFailed(out: rs.ByteVec, err: EncodeError.EncodeError): void { encodeError(out, err); - const _5: string = rt.fmtToString((f: rt.Formatter) => EncodeError.fmt$fmt_Display(err, f)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => EncodeError.fmt$fmt_Debug(err, f)]; - putText(out, _5, rt.fmtFormat([args2[0]])); + const _5: string = rs.fmtToString((f: rs.Formatter) => EncodeError.fmt$fmt_Display(err, f)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => EncodeError.fmt$fmt_Debug(err, f)]; + putText(out, _5, rs.fmtFormat([args2[0]])); } /** An error's thiserror `Display` and derived `Debug`, which callers see. */ -export function putText(out: rt.ByteVec, display: string, debug: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(display)); - rt.byteVecPush(out, 0); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(debug)); - rt.byteVecPush(out, 0); +export function putText(out: rs.ByteVec, display: string, debug: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(display)); + rs.byteVecPush(out, 0); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(debug)); + rs.byteVecPush(out, 0); } -export function decodeError(out: rt.ByteVec, err: DecodeError.DecodeError): void { - rt.byteVecPush(out, 238); +export function decodeError(out: rs.ByteVec, err: DecodeError.DecodeError): void { + rs.byteVecPush(out, 238); if (err.tag === "Short") { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (err.tag === "Long") { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else if (err.tag === "InvalidString") { - rt.byteVecPush(out, 2); + rs.byteVecPush(out, 2); } else if (err.tag === "InvalidMessage") { - rt.byteVecPush(out, 3); + rs.byteVecPush(out, 3); putU64(out, err._0); } else if (err.tag === "InvalidSubscribeLocation") { - rt.byteVecPush(out, 4); + rs.byteVecPush(out, 4); } else if (err.tag === "InvalidValue") { - rt.byteVecPush(out, 5); + rs.byteVecPush(out, 5); } else if (err.tag === "TooMany") { - rt.byteVecPush(out, 6); + rs.byteVecPush(out, 6); } else if (err.tag === "BoundsExceeded") { - rt.byteVecPush(out, 7); + rs.byteVecPush(out, 7); } else if (err.tag === "ExpectedEnd") { - rt.byteVecPush(out, 8); + rs.byteVecPush(out, 8); } else if (err.tag === "MessageTooLarge") { - rt.byteVecPush(out, 9); + rs.byteVecPush(out, 9); putUsize(out, err.size); putUsize(out, err.max); } else if (err.tag === "ExpectedData") { - rt.byteVecPush(out, 10); + rs.byteVecPush(out, 10); } else if (err.tag === "Duplicate") { - rt.byteVecPush(out, 11); + rs.byteVecPush(out, 11); } else if (err.tag === "Missing") { - rt.byteVecPush(out, 12); + rs.byteVecPush(out, 12); } else if (err.tag === "Unsupported") { - rt.byteVecPush(out, 13); + rs.byteVecPush(out, 13); } else if (err.tag === "TrailingBytes") { - rt.byteVecPush(out, 14); + rs.byteVecPush(out, 14); } else if (err.tag === "Version") { - rt.byteVecPush(out, 15); + rs.byteVecPush(out, 15); } else if (err.tag === "Session") { - rt.byteVecPush(out, 16); + rs.byteVecPush(out, 16); } else if (err.tag === "MalformedAuthToken") { - rt.byteVecPush(out, 17); + rs.byteVecPush(out, 17); } else { - rt.byteVecPush(out, 18); + rs.byteVecPush(out, 18); } } -export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void { - let _5!: rt.u8; - rt.byteVecPush(out, 239); +export function encodeError(out: rs.ByteVec, err: EncodeError.EncodeError): void { + let _5!: rs.u8; + rs.byteVecPush(out, 239); if (err === "BoundsExceeded") { _5 = 0; } else if (err === "TooLarge") { @@ -189,26 +189,26 @@ export function encodeError(out: rt.ByteVec, err: EncodeError.EncodeError): void } else { _5 = 6; } - rt.byteVecPush(out, _5); + rs.byteVecPush(out, _5); } /** * Read primitives as a script says until one fails: the script is the first * `data[1]` bytes after the form selector, and the wire is everything after it. */ -export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { - const selector: rt.u8 = dataData[dataStart]; + const selector: rs.u8 = dataData[dataStart]; if (dataLen - 1 !== 0) { - const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + const mid: number = rs.min(dataLen - 2, dataData[dataStart + 1] as rs.usize); if (mid > dataLen - 2) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const r: Decoder.Decoder = Decoder.new(new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid), form(selector)); - for (const _21 of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { - const _26: rt.Result = decodeStep(r, _21, out); + const r: Decoder.Decoder = Decoder.new(new rs.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid), form(selector)); + for (const _21 of rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, mid))) { + const _26: rs.Result = decodeStep(r, _21, out); if (_26.ok) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); putUsize(out, Decoder.remaining(r)); } else { decodeFailed(out, _26.error); @@ -216,59 +216,59 @@ export function decodeScript(dataData: Uint8Array, dataStart: number, dataLen: n break; } } - rt.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); + rs.byteVecPush(out, Decoder.isEmpty(r) ? 1 : 0); } } } -export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt.Result { - const _5: rt.u8 = rt.u8Rem(step, 10); +export function decodeStep(r: Decoder.Decoder, step: rs.u8, out: rs.ByteVec): rs.Result { + const _5: rs.u8 = rs.u8Rem(step, 10); if (_5 === 0) { - const part12: rt.u8 | undefined = Decoder.u8(r); + const part12: rs.u8 | undefined = Decoder.u8(r); const err8: DecodeError.DecodeError | undefined = part12 === undefined ? out$u8.err as DecodeError.DecodeError : undefined; if (err8 === undefined) { - rt.byteVecPush(out, part12 as rt.u8); + rs.byteVecPush(out, part12 as rs.u8); } else { - return rt.Err(err8 as DecodeError.DecodeError); + return rs.Err(err8 as DecodeError.DecodeError); } } else if (_5 === 1) { - const part11: rt.u16 | undefined = Decoder.u16(r); + const part11: rs.u16 | undefined = Decoder.u16(r); const err7: DecodeError.DecodeError | undefined = part11 === undefined ? out$u16.err as DecodeError.DecodeError : undefined; if (err7 === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(part11 as rt.u16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(part11 as rs.u16))); } else { - return rt.Err(err7 as DecodeError.DecodeError); + return rs.Err(err7 as DecodeError.DecodeError); } } else if (_5 === 2) { const err6: DecodeError.DecodeError | undefined = Decoder.bool(r); const part10: boolean = out$bool.p; if (err6 === undefined) { - rt.byteVecPush(out, part10 ? 1 : 0); + rs.byteVecPush(out, part10 ? 1 : 0); } else { - return rt.Err(err6 as DecodeError.DecodeError); + return rs.Err(err6 as DecodeError.DecodeError); } } else if (_5 === 3) { - const part9: rt.u64 | undefined = Decoder.varint(r); + const part9: rs.u64 | undefined = Decoder.varint(r); const err5: DecodeError.DecodeError | undefined = part9 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err5 === undefined) { - putU64(out, part9 as rt.u64); + putU64(out, part9 as rs.u64); } else { - return rt.Err(err5 as DecodeError.DecodeError); + return rs.Err(err5 as DecodeError.DecodeError); } } else if (_5 === 4) { const err4: DecodeError.DecodeError | undefined = Decoder.varintOpt(r); - const part8: rt.u64 | undefined = out$Option_u64.p; + const part8: rs.u64 | undefined = out$Option_u64.p; if (err4 === undefined) { - const val5: rt.u64 | undefined = part8; + const val5: rs.u64 | undefined = part8; if (val5 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v: rt.u64 = val5; - rt.byteVecPush(out, 1); + const v: rs.u64 = val5; + rs.byteVecPush(out, 1); putU64(out, v); } } else { - return rt.Err(err4 as DecodeError.DecodeError); + return rs.Err(err4 as DecodeError.DecodeError); } } else if (_5 === 5) { const err3: DecodeError.DecodeError | undefined = Decoder.bytes(r); @@ -277,38 +277,38 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt const part7: number = out$ref_slice_u8.pLen; if (err3 === undefined) { putUsize(out, part7); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part5, part6, part7)); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part5, part6, part7)); } else { - return rt.Err(err3 as DecodeError.DecodeError); + return rs.Err(err3 as DecodeError.DecodeError); } } else if (_5 === 6) { - const _49: rt.Result = Decoder.string(r); + const _49: rs.Result = Decoder.string(r); if (_49.ok) { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_49.value)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_49.value)); } else { return _49; } } else if (_5 === 7) { - const err2: DecodeError.DecodeError | undefined = Decoder.slice(r, rt.u8Div(step, 10) as rt.usize); + const err2: DecodeError.DecodeError | undefined = Decoder.slice(r, rs.u8Div(step, 10) as rs.usize); const part2: Uint8Array = out$ref_slice_u8.pData; const part3: number = out$ref_slice_u8.pStart; const part4: number = out$ref_slice_u8.pLen; if (err2 === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part2, part3, part4)); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part2, part3, part4)); } else { - return rt.Err(err2 as DecodeError.DecodeError); + return rs.Err(err2 as DecodeError.DecodeError); } } else if (_5 === 8) { - const _67: rt.Result = Decoder.sub(r, rt.u8Div(step, 10) as rt.usize); + const _67: rs.Result = Decoder.sub(r, rs.u8Div(step, 10) as rs.usize); if (_67.ok) { const sub: Decoder.Decoder = _67.value; - const part: rt.u64 | undefined = Decoder.varint(sub); + const part: rs.u64 | undefined = Decoder.varint(sub); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - putU64(out, part as rt.u64); + putU64(out, part as rs.u64); putUsize(out, Decoder.rest(sub).length); } else { - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } } else { return _67; @@ -316,94 +316,94 @@ export function decodeStep(r: Decoder.Decoder, step: rt.u8, out: rt.ByteVec): rt } else { putUsize(out, Decoder.rest(r).length); } - return rt.OK; + return rs.OK; } /** Write primitives as a script says, taking each value from the data that follows. */ -export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let result!: rt.Result; - let _47!: rt.u64 | undefined; +export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let result!: rs.Result; + let _47!: rs.u64 | undefined; let _74!: Prefix.Prefix; if (dataLen !== 0) { - const selector: rt.u8 = dataData[dataStart]; + const selector: rs.u8 = dataData[dataStart]; if (dataLen - 1 !== 0) { - const mid: number = rt.min(dataLen - 2, dataData[dataStart + 1] as rt.usize); + const mid: number = rs.min(dataLen - 2, dataData[dataStart + 1] as rs.usize); if (mid > dataLen - 2) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - let values: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); - const buf: rt.ByteVec = new rt.ByteVec(); + let values: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); + const buf: rs.ByteVec = new rs.ByteVec(); const _20: Form.Form = form(selector); const w: Encoder.Encoder = Encoder.new(buf, _20); - const prefixes: rt.Vec = new rt.Vec(); - for (const step of rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, mid))) { - const _30: [rt.u64, rt.ByteSlice] = takeU64(values); - const value: rt.u64 = _30[0]; + const prefixes: rs.Vec = new rs.Vec(); + for (const step of rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, mid))) { + const _30: [rs.u64, rs.ByteSlice] = takeU64(values); + const value: rs.u64 = _30[0]; values = _30[1]; - const _33: rt.u8 = rt.u8Rem(step, 10); + const _33: rs.u8 = rs.u8Rem(step, 10); if (_33 === 0) { - Encoder.u8(w, rt.u64Low(value) & 0xff); - result = rt.OK as rt.Result; + Encoder.u8(w, rs.u64Low(value) & 0xff); + result = rs.OK as rs.Result; } else if (_33 === 1) { - Encoder.u16(w, rt.u64Low(value) & 0xffff); - result = rt.OK as rt.Result; + Encoder.u16(w, rs.u64Low(value) & 0xffff); + result = rs.OK as rs.Result; } else if (_33 === 2) { - Encoder.bool(w, rt.u64And(value, 1) === 1); - result = rt.OK as rt.Result; + Encoder.bool(w, rs.u64And(value, 1) === 1); + result = rs.OK as rs.Result; } else if (_33 === 3) { result = Encoder.varint(w, value); } else if (_33 === 4) { - const _48: rt.u64 = rt.u64Rem(value, 3); + const _48: rs.u64 = rs.u64Rem(value, 3); if (_48 === 0) { _47 = undefined; } else if (_48 === 1) { _47 = value; } else { - _47 = { hi: 0xffffffff, lo: 0xffffffff } as rt.u64; + _47 = { hi: 0xffffffff, lo: 0xffffffff } as rs.u64; } result = Encoder.varintOpt(w, _47); } else if (_33 === 5) { - const _51: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.u64ToBeBytes(value)), 0, rt.u8Rem(rt.u8Div(step, 10), 9) as rt.usize); + const _51: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.u64ToBeBytes(value)), 0, rs.u8Rem(rs.u8Div(step, 10), 9) as rs.usize); result = Encoder.bytes(w, _51); } else if (_33 === 6) { - const _60: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rt.byteSliceFrom(rt.u64ToBeBytes(value)))); + const _60: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rs.byteSliceFrom(rs.u64ToBeBytes(value)))); if (_60.ok) { result = Encoder.string(w, _60.value); } else { result = Encoder.string(w, "not utf-8"); } } else if (_33 === 7) { - if (rt.u64Rem(value, 2) === 0) { + if (rs.u64Rem(value, 2) === 0) { _74 = Encoder.prefixVarint(w); } else { _74 = Encoder.prefixU16(w); } prefixes.items.push(_74); - result = rt.OK as rt.Result; + result = rs.OK as rs.Result; } else if (_33 === 8) { - const _79: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _79: Prefix.Prefix | undefined = rs.vecPop(prefixes); if (_79 === undefined) { - result = rt.OK as rt.Result; + result = rs.OK as rs.Result; } else { const prefix: Prefix.Prefix = _79; putUsize(out, Encoder.since(w, prefix)); result = Encoder.fill(w, prefix); } } else { - const _88: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _88: Prefix.Prefix | undefined = rs.vecPop(prefixes); if (_88 !== undefined) { Encoder.discard(w, _88); } - result = rt.OK as rt.Result; + result = rs.OK as rs.Result; } if (!result.ok) { encodeFailed(out, result.error); } } while (true) { - const _98: Prefix.Prefix | undefined = rt.vecPop(prefixes); + const _98: Prefix.Prefix | undefined = rs.vecPop(prefixes); if (_98 !== undefined) { - const _102: rt.Result = Encoder.fill(w, _98); + const _102: rs.Result = Encoder.fill(w, _98); if (!_102.ok) { encodeFailed(out, _102.error); } @@ -412,46 +412,46 @@ export function encodeScript(dataData: Uint8Array, dataStart: number, dataLen: n } } putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } } } -export function zigzag(data: rt.ByteSlice, out: rt.ByteVec): void { - const value: rt.u64 = takeU64(data)[0]; - const signed: rt.i64 = rt.i64Cast(value); +export function zigzag(data: rs.ByteSlice, out: rs.ByteVec): void { + const value: rs.u64 = takeU64(data)[0]; + const signed: rs.i64 = rs.i64Cast(value); putU64(out, varint_zigzag(signed)); - putU64(out, rt.u64Cast(unzigzag(value))); - putU64(out, rt.u64Cast(unzigzag(varint_zigzag(signed)))); + putU64(out, rs.u64Cast(unzigzag(value))); + putU64(out, rs.u64Cast(unzigzag(varint_zigzag(signed)))); } -export function sizes(data: rt.ByteSlice, out: rt.ByteVec): void { - let _9!: rt.u8; - const value: rt.u64 = takeU64(data)[0]; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 3; +export function sizes(data: rs.ByteSlice, out: rs.ByteVec): void { + let _9!: rs.u8; + const value: rs.u64 = takeU64(data)[0]; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 3; while ((_9 = iterStart++) < iterEnd) { - const part: rt.usize | undefined = size(value, form(_9)); + const part: rs.usize | undefined = size(value, form(_9)); if ((part === undefined ? out$usize.err as BoundsExceeded.BoundsExceeded : undefined) === undefined) { - putUsize(out, part as rt.usize); + putUsize(out, part as rs.usize); } else { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } } } /** Decode a `T` from the wire, then encode what came out. */ -export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { const form_: Form.Form = form(dataData[dataStart]); - const _8: rt.Result<[Versions.Versions, rt.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), form_); + const _8: rs.Result<[Versions.Versions, rs.usize], DecodeError.DecodeError> = Versions.decodeSlice$coding_decode_Decode_coding_varint_Form(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), form_); if (_8.ok) { const value: Versions.Versions = _8.value[0]; putUsize(out, _8.value[1]); - const buf: rt.ByteVec = new rt.ByteVec(); - const _14: rt.Result = Versions.encode$coding_encode_Encode_coding_varint_Form(value, Encoder.new(buf, form_), form_); + const buf: rs.ByteVec = new rs.ByteVec(); + const _14: rs.Result = Versions.encode$coding_encode_Encode_coding_varint_Form(value, Encoder.new(buf, form_), form_); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -462,18 +462,18 @@ export function roundtrip$coding_version_Versions(dataData: Uint8Array, dataStar } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _8: rt.Result<[Group.Group, rt.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); + const _8: rs.Result<[Group.Group, rs.usize], DecodeError.DecodeError> = Group.decodeSlice$coding_decode_Decode_lite_version_Version(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Group.Group = _8.value[0]; putUsize(out, _8.value[1]); - const buf: rt.ByteVec = new rt.ByteVec(); + const buf: rs.ByteVec = new rs.ByteVec(); const _19: Form.Form = Form.from$convert_From_lite_version_Version(version); - const _14: rt.Result = Group.encode$coding_encode_Encode_lite_version_Version(value, Encoder.new(buf, _19), version); + const _14: rs.Result = Group.encode$coding_encode_Encode_lite_version_Version(value, Encoder.new(buf, _19), version); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -484,18 +484,18 @@ export function roundtripLite$lite_group_Group(dataData: Uint8Array, dataStart: } /** [`roundtrip`] for a lite message, size-prefixed at a lite version. */ -export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _8: rt.Result<[Probe.Probe, rt.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); + const _8: rs.Result<[Probe.Probe, rs.usize], DecodeError.DecodeError> = Probe.decodeSlice$coding_decode_Decode_lite_version_Version(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), version); if (_8.ok) { const value: Probe.Probe = _8.value[0]; putUsize(out, _8.value[1]); - const buf: rt.ByteVec = new rt.ByteVec(); + const buf: rs.ByteVec = new rs.ByteVec(); const _19: Form.Form = Form.from$convert_From_lite_version_Version(version); - const _14: rt.Result = Probe.encode$coding_encode_Encode_lite_version_Version(value, Encoder.new(buf, _19), version); + const _14: rs.Result = Probe.encode$coding_encode_Encode_lite_version_Version(value, Encoder.new(buf, _19), version); if (_14.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _14.error); } @@ -506,79 +506,79 @@ export function roundtripLite$lite_probe_Probe(dataData: Uint8Array, dataStart: } /** Encode messages built from the data, at a lite version. */ -export function encodeMessages(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function encodeMessages(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { const version: lite_version_Version.Version = liteVersion(dataData[dataStart]); - const _10: [rt.u64, rt.ByteSlice] = takeU64(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); - const subscribe: rt.u64 = _10[0]; - const _13: [rt.u64, rt.ByteSlice] = takeU64(_10[1]); - const sequence: rt.u64 = _13[0]; - const _16: [rt.u64, rt.ByteSlice] = takeU64(_13[1]); - const frameStart: rt.u64 = _16[0]; - const _19: [rt.u64, rt.ByteSlice] = takeU64(_16[1]); - const bitrate: rt.u64 = _19[0]; - const rtt: rt.u64 = takeU64(_19[1])[0]; - encodeMessage$lite_group_Group({ subscribe, sequence, frameStart: rt.u64Rem(frameStart, 4) }, version, out); - encodeMessage$lite_probe_Probe({ bitrate: rt.u64CheckedSub(bitrate, 1), rtt: thenSome$1ugl8af(rt.u64Rem(rtt, 3) !== 0, rtt) }, version, out); + const _10: [rs.u64, rs.ByteSlice] = takeU64(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)); + const subscribe: rs.u64 = _10[0]; + const _13: [rs.u64, rs.ByteSlice] = takeU64(_10[1]); + const sequence: rs.u64 = _13[0]; + const _16: [rs.u64, rs.ByteSlice] = takeU64(_13[1]); + const frameStart: rs.u64 = _16[0]; + const _19: [rs.u64, rs.ByteSlice] = takeU64(_16[1]); + const bitrate: rs.u64 = _19[0]; + const rtt: rs.u64 = takeU64(_19[1])[0]; + encodeMessage$lite_group_Group({ subscribe, sequence, frameStart: rs.u64Rem(frameStart, 4) }, version, out); + encodeMessage$lite_probe_Probe({ bitrate: rs.u64CheckedSub(bitrate, 1), rtt: thenSome$0be218t(rs.u64Rem(rtt, 3) !== 0, rtt) }, version, out); const versions: Versions.Versions = Versions.from$convert_From_array2_coding_version_Version([{ _0: subscribe }, { _0: sequence }]); - const buf: rt.ByteVec = new rt.ByteVec(); + const buf: rs.ByteVec = new rs.ByteVec(); const _45: Form.Form = Form.from$convert_From_lite_version_Version(version); - const _40: rt.Result = Versions.encode$coding_encode_Encode_lite_version_Version(versions, Encoder.new(buf, _45), version); + const _40: rs.Result = Versions.encode$coding_encode_Encode_lite_version_Version(versions, Encoder.new(buf, _45), version); if (_40.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _40.error); } } } -export function encodeMessage$lite_group_Group(msg: Group.Group, version: lite_version_Version.Version, out: rt.ByteVec): void { - const buf: rt.ByteVec = new rt.ByteVec(); +export function encodeMessage$lite_group_Group(msg: Group.Group, version: lite_version_Version.Version, out: rs.ByteVec): void { + const buf: rs.ByteVec = new rs.ByteVec(); const _7: Form.Form = Form.from$convert_From_lite_version_Version(version); const w: Encoder.Encoder = Encoder.new(buf, _7); - const _8: rt.Result = Group.encode$coding_encode_Encode_lite_version_Version(msg, w, version); + const _8: rs.Result = Group.encode$coding_encode_Encode_lite_version_Version(msg, w, version); if (_8.ok) { - rt.byteVecPush(out, w.control !== undefined ? 1 : 0); + rs.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _8.error); } } -export function encodeMessage$lite_probe_Probe(msg: Probe.Probe, version: lite_version_Version.Version, out: rt.ByteVec): void { - const buf: rt.ByteVec = new rt.ByteVec(); +export function encodeMessage$lite_probe_Probe(msg: Probe.Probe, version: lite_version_Version.Version, out: rs.ByteVec): void { + const buf: rs.ByteVec = new rs.ByteVec(); const _7: Form.Form = Form.from$convert_From_lite_version_Version(version); const w: Encoder.Encoder = Encoder.new(buf, _7); - const _8: rt.Result = Probe.encode$coding_encode_Encode_lite_version_Version(msg, w, version); + const _8: rs.Result = Probe.encode$coding_encode_Encode_lite_version_Version(msg, w, version); if (_8.ok) { - rt.byteVecPush(out, w.control !== undefined ? 1 : 0); + rs.byteVecPush(out, w.control !== undefined ? 1 : 0); putUsize(out, buf.length); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } else { encodeFailed(out, _8.error); } } /** Each error the codec can return, built from the data, as callers see it. */ -export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let err!: DecodeError.DecodeError; b0: { if (dataLen !== 0) { - const selector: rt.u8 = dataData[dataStart]; - const data2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const value: rt.u64 = takeU64(data2)[0]; - const _10: rt.u8 = rt.u8Rem(selector, 8); + const selector: rs.u8 = dataData[dataStart]; + const data2: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const value: rs.u64 = takeU64(data2)[0]; + const _10: rs.u8 = rs.u8Rem(selector, 8); if (_10 === 0) { err = { tag: "InvalidMessage", _0: value } as DecodeError.DecodeError; } else if (_10 === 1) { - err = { tag: "MessageTooLarge", size: rt.u64Low(value), max: rt.u64Low(rt.u64Shr(value, 32)) } as DecodeError.DecodeError; + err = { tag: "MessageTooLarge", size: rs.u64Low(value), max: rs.u64Low(rs.u64Shr(value, 32)) } as DecodeError.DecodeError; } else if (_10 === 2) { - err = { tag: "Session", _0: { tag: "App", _0: rt.u64Low(value) & 0xffff } as SessionError.SessionError } as DecodeError.DecodeError; + err = { tag: "Session", _0: { tag: "App", _0: rs.u64Low(value) & 0xffff } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 3) { err = { tag: "Session", _0: { tag: "ProtocolViolation" } as SessionError.SessionError } as DecodeError.DecodeError; } else if (_10 === 4) { - const _20: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data2)); + const _20: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data2)); if (_20.ok) { err = { tag: "Missing" } as DecodeError.DecodeError; } else { @@ -589,18 +589,18 @@ export function errors(dataData: Uint8Array, dataStart: number, dataLen: number, } else { if (_10 === 6) { const arg = {}; - const _26: string = rt.fmtToString((f: rt.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); + const _26: string = rs.fmtToString((f: rs.Formatter) => BoundsExceeded.fmt$fmt_Display(arg, f)); const arg2 = {}; - const args2: rt.Fmt[] = [(f: rt.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; - putText(out, _26, rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0])])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => BoundsExceeded.fmt$fmt_Debug(arg2, f)]; + putText(out, _26, rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])])); break b0; } err = { tag: "MalformedAuthToken" } as DecodeError.DecodeError; } - const args4: rt.Fmt[] = [(f: rt.Formatter) => DecodeError.fmt$fmt_Display(err, f)]; - const _38: string = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); - const args6: rt.Fmt[] = [(f: rt.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; - putText(out, _38, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args6[0])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Display(err, f)]; + const _38: string = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|"]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => DecodeError.fmt$fmt_Debug(err, f)]; + putText(out, _38, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args6[0])])); decodeFailed(out, err); } } diff --git a/ts/fixtures/codec/expected/lib.SessionError.ts b/ts/fixtures/codec/expected/lib.SessionError.ts index fbcbb58df..9eb6b81be 100644 --- a/ts/fixtures/codec/expected/lib.SessionError.ts +++ b/ts/fixtures/codec/expected/lib.SessionError.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { asDisplay$thiserror___private21_AsDisplay_ref_u16 } from "./thiserror/display.ts"; -export function fmt$fmt_Display(self: SessionError, __formatter: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: SessionError, __formatter: rs.Formatter): rs.Result { if (self.tag === "ProtocolViolation") { - return rt.fmtWriteStr(__formatter, "protocol violation"); + return rs.fmtWriteStr(__formatter, "protocol violation"); } const arg = asDisplay$thiserror___private21_AsDisplay_ref_u16(self._0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg, f)]; - return rt.fmtWriteFmt(__formatter, ["app code=", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; + return rs.fmtWriteFmt(__formatter, ["app code=", args2[0]]); } -export function fmt$fmt_Debug(self: SessionError, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: SessionError, f: rs.Formatter): rs.Result { if (self.tag === "ProtocolViolation") { - return rt.fmtWriteStr(f, "ProtocolViolation"); + return rs.fmtWriteStr(f, "ProtocolViolation"); } const _6: string = "App"; - const _7: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); + const _7: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); } /** moq-net's session error, trimmed to a few variants: the codec only carries it. */ -export type SessionError = { tag: "ProtocolViolation" } | { tag: "App"; _0: rt.u16 }; +export type SessionError = { tag: "ProtocolViolation" } | { tag: "App"; _0: rs.u16 }; //# sourceMappingURL=lib.SessionError.ts.map diff --git a/ts/fixtures/codec/expected/lib.ts b/ts/fixtures/codec/expected/lib.ts index 5edfc263a..8f093d758 100644 --- a/ts/fixtures/codec/expected/lib.ts +++ b/ts/fixtures/codec/expected/lib.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Timestamp from "./bench.Timestamp.ts"; export function copy$bench_Timestamp(v: Timestamp.Timestamp): Timestamp.Timestamp { return { value: v.value, scale: v.scale }; } -export const out$Option_u64: { p: rt.u64 | undefined } = { p: undefined as never }; +export const out$Option_u64: { p: rs.u64 | undefined } = { p: undefined as never }; export const out$bool: { p: boolean } = { p: undefined as never }; export const out$ref_slice_u8: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; -export const out$tuple2_i64_u64: { err: unknown; p_1: rt.u64 } = { err: undefined, p_1: undefined as never }; +export const out$tuple2_i64_u64: { err: unknown; p_1: rs.u64 } = { err: undefined, p_1: undefined as never }; export const out$tuple2_u64_ref_slice_u8: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; diff --git a/ts/fixtures/codec/expected/lite/group.Group.ts b/ts/fixtures/codec/expected/lite/group.Group.ts index e4010068a..1fe013f3a 100644 --- a/ts/fixtures/codec/expected/lite/group.Group.ts +++ b/ts/fixtures/codec/expected/lite/group.Group.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$u64 } from "../lib.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; @@ -12,67 +12,67 @@ import { decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T import * as lite_version_Version from "../lite/version.Version.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rt.ByteSlice, version: lite_version_Version.Version): rt.Result<[Group, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rs.ByteSlice, version: lite_version_Version.Version): rs.Result<[Group, rs.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, Form.from$convert_From_lite_version_Version(version)); - const _5: rt.Result = decode$coding_decode_Decode_lite_version_Version(r, version); + const _5: rs.Result = decode$coding_decode_Decode_lite_version_Version(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rt.usize]); + return rs.Ok([_5.value, rs.usizeSub(buf.length, Decoder.remaining(r))] as [Group, rs.usize]); } return _5; } export interface Group { - subscribe: rt.u64; - sequence: rt.u64; - frameStart: rt.u64; + subscribe: rs.u64; + sequence: rs.u64; + frameStart: rs.u64; } /** Decode a message body (without size prefix). */ -export function decodeMsg$lite_message_Message(r: Decoder.Decoder, version: lite_version_Version.Version): rt.Result { - let frameStart!: rt.u64; - const part: rt.u64 | undefined = Decoder.varint(r); +export function decodeMsg$lite_message_Message(r: Decoder.Decoder, version: lite_version_Version.Version): rs.Result { + let frameStart!: rs.u64; + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const subscribe: rt.u64 = part as rt.u64; - const part2: rt.u64 | undefined = Decoder.varint(r); + const subscribe: rs.u64 = part as rs.u64; + const part2: rs.u64 | undefined = Decoder.varint(r); const err2: DecodeError.DecodeError | undefined = part2 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err2 === undefined) { - const sequence: rt.u64 = part2 as rt.u64; + const sequence: rs.u64 = part2 as rs.u64; if (!lite_version_Version.hasFrameBounds(version)) { frameStart = 0; } else { - const part3: rt.u64 | undefined = Decoder.varint(r); + const part3: rs.u64 | undefined = Decoder.varint(r); const err3: DecodeError.DecodeError | undefined = part3 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err3 === undefined) { - frameStart = part3 as rt.u64; + frameStart = part3 as rs.u64; } else { - return rt.Err(err3 as DecodeError.DecodeError); + return rs.Err(err3 as DecodeError.DecodeError); } } - return rt.Ok({ subscribe, sequence, frameStart }); + return rs.Ok({ subscribe, sequence, frameStart }); } - return rt.Err(err2 as DecodeError.DecodeError); + return rs.Err(err2 as DecodeError.DecodeError); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** Encode this message body (without size prefix). */ -export function encodeMsg$lite_message_Message(self: Group, w: Encoder.Encoder, version: lite_version_Version.Version): rt.Result { - const _4: rt.Result = Encoder.varint(w, self.subscribe); +export function encodeMsg$lite_message_Message(self: Group, w: Encoder.Encoder, version: lite_version_Version.Version): rs.Result { + const _4: rs.Result = Encoder.varint(w, self.subscribe); if (_4.ok) { - const _9: rt.Result = Encoder.varint(w, self.sequence); + const _9: rs.Result = Encoder.varint(w, self.sequence); if (_9.ok) { if (!lite_version_Version.hasFrameBounds(version)) { if (self.frameStart !== 0) { - return rt.Err("Version" as EncodeError.EncodeError); + return rs.Err("Version" as EncodeError.EncodeError); } } else { - const _15: rt.Result = Encoder.varint(w, self.frameStart); + const _15: rs.Result = Encoder.varint(w, self.frameStart); if (!_15.ok) { return _15; } } - return rt.OK; + return rs.OK; } return _9; } @@ -80,27 +80,27 @@ export function encodeMsg$lite_message_Message(self: Group, w: Encoder.Encoder, } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$coding_encode_Encode_lite_version_Version(self: Group, w: Encoder.Encoder, version: lite_version_Version.Version): rt.Result { +export function encode$coding_encode_Encode_lite_version_Version(self: Group, w: Encoder.Encoder, version: lite_version_Version.Version): rs.Result { const prefix: Prefix.Prefix = Encoder.prefixVarint(w); - const _39: rt.Result = encodeMsg$lite_message_Message(self, w, version); + const _39: rs.Result = encodeMsg$lite_message_Message(self, w, version); if (_39.ok) { if (!(Encoder.since(w, prefix) > 65535)) { - const _49: rt.Result = Encoder.fill(w, prefix); + const _49: rs.Result = Encoder.fill(w, prefix); if (_49.ok) { w.control = undefined; - return rt.OK; + return rs.OK; } return _49; } Encoder.discard(w, prefix); - return rt.Err("TooLarge" as EncodeError.EncodeError); + return rs.Err("TooLarge" as EncodeError.EncodeError); } return _39; } /** Decode the value from the front of the decoder. */ -export function decode$coding_decode_Decode_lite_version_Version(r: Decoder.Decoder, version: lite_version_Version.Version): rt.Result { - return decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_group_Group(r, (body: Decoder.Decoder): rt.Result => { +export function decode$coding_decode_Decode_lite_version_Version(r: Decoder.Decoder, version: lite_version_Version.Version): rs.Result { + return decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_group_Group(r, (body: Decoder.Decoder): rs.Result => { return decodeMsg$lite_message_Message(body, version); }); } diff --git a/ts/fixtures/codec/expected/lite/message.ts b/ts/fixtures/codec/expected/lite/message.ts index 6d406ff74..51d7353cc 100644 --- a/ts/fixtures/codec/expected/lite/message.ts +++ b/ts/fixtures/codec/expected/lite/message.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$u64, out$usize } from "../lib.ts"; import * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; -import { mapErr$0577706 as result_mapErr$0577706, mapErr$04g1m7s as result_mapErr$04g1m7s, andThen$0hcfsqc as result_andThen$0hcfsqc, andThen$1kvlask as result_andThen$1kvlask, unwrapOr$0jeml8j as result_unwrapOr$0jeml8j } from "../core/result.ts"; +import { mapErr$02fx80t as result_mapErr$02fx80t, mapErr$0ro6mbb as result_mapErr$0ro6mbb, andThen$0xo70ms as result_andThen$0xo70ms, andThen$0bc8wcd as result_andThen$0bc8wcd, unwrapOr$0a2fg79 as result_unwrapOr$0a2fg79 } from "../core/result.ts"; import type * as Group from "../lite/group.Group.ts"; import type * as Probe from "../lite/probe.Probe.ts"; import type * as Control from "../stats.Control.ts"; /** Read a lite message's varint size prefix, refusing one past `max`. */ -export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.usize | undefined { - const part: rt.u64 | undefined = Decoder.varint(r); +export function decodeSize(r: Decoder.Decoder, max: rs.usize): rs.usize | undefined { + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const size: rt.u64 = part as rt.u64; - const _8: rt.Result = rt.usizeTryFrom(size); + const size: rs.u64 = part as rs.u64; + const _8: rs.Result = rs.usizeTryFrom(size); if (_8.ok) { if (_8.value <= max) { return _8.value; } } - out$usize.err = { tag: "MessageTooLarge", size: result_unwrapOr$0jeml8j(rt.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError; + out$usize.err = { tag: "MessageTooLarge", size: result_unwrapOr$0a2fg79(rs.usizeTryFrom(size), 4294967295), max } as DecodeError.DecodeError; return undefined; } out$usize.err = err as DecodeError.DecodeError; @@ -32,18 +32,18 @@ export function decodeSize(r: Decoder.Decoder, max: rt.usize): rt.usize | undefi * Decode a size-prefixed `T`, reading its body with `decode` in place of * [`Message::decode_msg`], for a body whose bounds come from the session. */ -export function decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_group_Group(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rt.Result): rt.Result { - const part: rt.usize | undefined = decodeSize(r, 65535); +export function decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_group_Group(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rs.Result): rs.Result { + const part: rs.usize | undefined = decodeSize(r, 65535); const err: DecodeError.DecodeError | undefined = part === undefined ? out$usize.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const _9: rt.Result = Decoder.sub(r, part as rt.usize); + const _9: rs.Result = Decoder.sub(r, part as rs.usize); if (_9.ok) { const body: Decoder.Decoder = _9.value; - const result: rt.Result = result_andThen$0hcfsqc(result_mapErr$0577706(decode(body), DecodeError.complete), (msg: Group.Group): rt.Result => { + const result: rs.Result = result_andThen$0xo70ms(result_mapErr$02fx80t(decode(body), DecodeError.complete), (msg: Group.Group): rs.Result => { if (!Decoder.isEmpty(body)) { - return rt.Err({ tag: "Long" } as DecodeError.DecodeError); + return rs.Err({ tag: "Long" } as DecodeError.DecodeError); } - return rt.Ok(msg); + return rs.Ok(msg); }); if (result.ok) { r.control = undefined; @@ -52,25 +52,25 @@ export function decodeWith$lite_group_Group_coding_decode_Decode_lite_version_Ve } return _9; } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** * Decode a size-prefixed `T`, reading its body with `decode` in place of * [`Message::decode_msg`], for a body whose bounds come from the session. */ -export function decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_probe_Probe(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rt.Result): rt.Result { - const part: rt.usize | undefined = decodeSize(r, 65535); +export function decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_probe_Probe(r: Decoder.Decoder, decode: (a0: Decoder.Decoder) => rs.Result): rs.Result { + const part: rs.usize | undefined = decodeSize(r, 65535); const err: DecodeError.DecodeError | undefined = part === undefined ? out$usize.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const _9: rt.Result = Decoder.sub(r, part as rt.usize); + const _9: rs.Result = Decoder.sub(r, part as rs.usize); if (_9.ok) { const body: Decoder.Decoder = _9.value; - const result: rt.Result = result_andThen$1kvlask(result_mapErr$04g1m7s(decode(body), DecodeError.complete), (msg: Probe.Probe): rt.Result => { + const result: rs.Result = result_andThen$0bc8wcd(result_mapErr$0ro6mbb(decode(body), DecodeError.complete), (msg: Probe.Probe): rs.Result => { if (!Decoder.isEmpty(body)) { - return rt.Err({ tag: "Long" } as DecodeError.DecodeError); + return rs.Err({ tag: "Long" } as DecodeError.DecodeError); } - return rt.Ok(msg); + return rs.Ok(msg); }); if (result.ok) { r.control = "Probe" as Control.Control; @@ -79,7 +79,7 @@ export function decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Ve } return _9; } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } //# sourceMappingURL=message.ts.map diff --git a/ts/fixtures/codec/expected/lite/probe.Probe.ts b/ts/fixtures/codec/expected/lite/probe.Probe.ts index f4c58ce42..4f5a8f0ac 100644 --- a/ts/fixtures/codec/expected/lite/probe.Probe.ts +++ b/ts/fixtures/codec/expected/lite/probe.Probe.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { out$u64 } from "../lib.ts"; import type * as DecodeError from "../coding/decode.DecodeError.ts"; import * as Decoder from "../coding/decode.Decoder.ts"; @@ -8,43 +8,43 @@ import type * as EncodeError from "../coding/encode.EncodeError.ts"; import * as Encoder from "../coding/encode.Encoder.ts"; import type * as Prefix from "../coding/encode.Prefix.ts"; import * as Form from "../coding/varint.Form.ts"; -import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$1cf8u0y as option_map$1cf8u0y } from "../core/option.ts"; +import { unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1haiqd3 as option_map$1haiqd3 } from "../core/option.ts"; import { decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_probe_Probe } from "../lite/message.ts"; import * as lite_version_Version from "../lite/version.Version.ts"; import type * as Control from "../stats.Control.ts"; /** Decode the value from the front of `buf`, returning it and the bytes it took. */ -export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rt.ByteSlice, version: lite_version_Version.Version): rt.Result<[Probe, rt.usize], DecodeError.DecodeError> { +export function decodeSlice$coding_decode_Decode_lite_version_Version(buf: rs.ByteSlice, version: lite_version_Version.Version): rs.Result<[Probe, rs.usize], DecodeError.DecodeError> { const r: Decoder.Decoder = Decoder.new(buf, Form.from$convert_From_lite_version_Version(version)); - const _5: rt.Result = decode$coding_decode_Decode_lite_version_Version(r, version); + const _5: rs.Result = decode$coding_decode_Decode_lite_version_Version(r, version); if (_5.ok) { - return rt.Ok([_5.value, rt.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rt.usize]); + return rs.Ok([_5.value, rs.usizeSub(buf.length, Decoder.remaining(r))] as [Probe, rs.usize]); } return _5; } /** Encode the value to the given encoder, which may hold partial output on error. */ -export function encode$coding_encode_Encode_lite_version_Version(self: Probe, w: Encoder.Encoder, version: lite_version_Version.Version): rt.Result { +export function encode$coding_encode_Encode_lite_version_Version(self: Probe, w: Encoder.Encoder, version: lite_version_Version.Version): rs.Result { const prefix: Prefix.Prefix = Encoder.prefixVarint(w); - const _39: rt.Result = encodeMsg$lite_message_Message(self, w, version); + const _39: rs.Result = encodeMsg$lite_message_Message(self, w, version); if (_39.ok) { if (!(Encoder.since(w, prefix) > 65535)) { - const _49: rt.Result = Encoder.fill(w, prefix); + const _49: rs.Result = Encoder.fill(w, prefix); if (_49.ok) { w.control = "Probe" as Control.Control; - return rt.OK; + return rs.OK; } return _49; } Encoder.discard(w, prefix); - return rt.Err("TooLarge" as EncodeError.EncodeError); + return rs.Err("TooLarge" as EncodeError.EncodeError); } return _39; } /** Decode the value from the front of the decoder. */ -export function decode$coding_decode_Decode_lite_version_Version(r: Decoder.Decoder, version: lite_version_Version.Version): rt.Result { - return decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_probe_Probe(r, (body: Decoder.Decoder): rt.Result => { +export function decode$coding_decode_Decode_lite_version_Version(r: Decoder.Decoder, version: lite_version_Version.Version): rs.Result { + return decodeWith$lite_probe_Probe_coding_decode_Decode_lite_version_Version_T_decode_closure0_lite_probe_Probe(r, (body: Decoder.Decoder): rs.Result => { return decodeMsg$lite_message_Message(body, version); }); } @@ -56,21 +56,21 @@ export function decode$coding_decode_Decode_lite_version_Version(r: Decoder.Deco * On the wire, 0 means unknown (None). Some(0) is rounded up to Some(1). */ export interface Probe { - bitrate: rt.u64 | undefined; - rtt: rt.u64 | undefined; + bitrate: rs.u64 | undefined; + rtt: rs.u64 | undefined; } /** Decode a message body (without size prefix). */ -export function decodeMsg$lite_message_Message(r: Decoder.Decoder, version: lite_version_Version.Version): rt.Result { - let bitrate!: rt.u64 | undefined; - let rtt!: rt.u64 | undefined; +export function decodeMsg$lite_message_Message(r: Decoder.Decoder, version: lite_version_Version.Version): rs.Result { + let bitrate!: rs.u64 | undefined; + let rtt!: rs.u64 | undefined; if (version === "Lite01" || version === "Lite02") { - return rt.Err({ tag: "Version" } as DecodeError.DecodeError); + return rs.Err({ tag: "Version" } as DecodeError.DecodeError); } - const part: rt.u64 | undefined = Decoder.varint(r); + const part: rs.u64 | undefined = Decoder.varint(r); const err: DecodeError.DecodeError | undefined = part === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err === undefined) { - const val: rt.u64 = part as rt.u64; + const val: rs.u64 = part as rs.u64; if (val === 0) { bitrate = undefined; } else { @@ -79,42 +79,42 @@ export function decodeMsg$lite_message_Message(r: Decoder.Decoder, version: lite if (!lite_version_Version.hasProbeRtt(version)) { rtt = undefined; } else { - const part2: rt.u64 | undefined = Decoder.varint(r); + const part2: rs.u64 | undefined = Decoder.varint(r); const err2: DecodeError.DecodeError | undefined = part2 === undefined ? out$u64.err as DecodeError.DecodeError : undefined; if (err2 === undefined) { - const val2: rt.u64 = part2 as rt.u64; + const val2: rs.u64 = part2 as rs.u64; if (val2 === 0) { rtt = undefined; } else { rtt = val2; } } else { - return rt.Err(err2 as DecodeError.DecodeError); + return rs.Err(err2 as DecodeError.DecodeError); } } - return rt.Ok({ bitrate, rtt }); + return rs.Ok({ bitrate, rtt }); } - return rt.Err(err as DecodeError.DecodeError); + return rs.Err(err as DecodeError.DecodeError); } /** Encode this message body (without size prefix). */ -export function encodeMsg$lite_message_Message(self: Probe, w: Encoder.Encoder, version: lite_version_Version.Version): rt.Result { +export function encodeMsg$lite_message_Message(self: Probe, w: Encoder.Encoder, version: lite_version_Version.Version): rs.Result { if (version === "Lite01" || version === "Lite02") { - return rt.Err("Version" as EncodeError.EncodeError); + return rs.Err("Version" as EncodeError.EncodeError); } - const _9: rt.Result = Encoder.varint(w, option_unwrapOr$1tvry1i(option_map$1cf8u0y(self.bitrate, (v: rt.u64): rt.u64 => { - return rt.u64Max(v, 1); + const _9: rs.Result = Encoder.varint(w, option_unwrapOr$15hbiwd(option_map$1haiqd3(self.bitrate, (v: rs.u64): rs.u64 => { + return rs.u64Max(v, 1); }), 0)); if (_9.ok) { if (lite_version_Version.hasProbeRtt(version)) { - const _17: rt.Result = Encoder.varint(w, option_unwrapOr$1tvry1i(option_map$1cf8u0y(self.rtt, (v2: rt.u64): rt.u64 => { - return rt.u64Max(v2, 1); + const _17: rs.Result = Encoder.varint(w, option_unwrapOr$15hbiwd(option_map$1haiqd3(self.rtt, (v2: rs.u64): rs.u64 => { + return rs.u64Max(v2, 1); }), 0)); if (!_17.ok) { return _17; } } - return rt.OK; + return rs.OK; } return _9; } diff --git a/ts/fixtures/codec/expected/thiserror/display.ts b/ts/fixtures/codec/expected/thiserror/display.ts index 6f6c99b4f..bc8c1933f 100644 --- a/ts/fixtures/codec/expected/thiserror/display.ts +++ b/ts/fixtures/codec/expected/thiserror/display.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function asDisplay$thiserror___private21_AsDisplay_ref_u16(self: rt.u16): rt.u16 { +export function asDisplay$thiserror___private21_AsDisplay_ref_u16(self: rs.u16): rs.u16 { return self; } -export function asDisplay$thiserror___private21_AsDisplay_ref_usize(self: rt.usize): rt.usize { +export function asDisplay$thiserror___private21_AsDisplay_ref_usize(self: rs.usize): rs.usize { return self; } diff --git a/ts/fixtures/crates/bind/last.ts b/ts/fixtures/crates/bind/last.ts index c7255edbb..7ccb8c7ae 100644 --- a/ts/fixtures/crates/bind/last.ts +++ b/ts/fixtures/crates/bind/last.ts @@ -1,8 +1,8 @@ // `crates_dep::last`, which reads through a raw pointer. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function last(bytes: rt.ByteSlice): rt.u8 { - if (bytes.length === 0) rt.panic("no last byte"); - return bytes.data[bytes.start + bytes.length - 1] as rt.u8; +export function last(bytes: rs.ByteSlice): rs.u8 { + if (bytes.length === 0) rs.panic("no last byte"); + return bytes.data[bytes.start + bytes.length - 1] as rs.u8; } diff --git a/ts/fixtures/crates/bind/slots.ts b/ts/fixtures/crates/bind/slots.ts index 968acec82..6fa5432b4 100644 --- a/ts/fixtures/crates/bind/slots.ts +++ b/ts/fixtures/crates/bind/slots.ts @@ -1,14 +1,14 @@ // `crates_dep::Slots`, which writes into the array it is given. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Slots = { base: rt.i16 }; +export type Slots = { base: rs.i16 }; -export function withBase(base: rt.i16): Slots { +export function withBase(base: rs.i16): Slots { return { base }; } -export function fill(self: Slots, out: rt.i16[]): undefined { +export function fill(self: Slots, out: rs.i16[]): undefined { out[0] = self.base; - out[1] = rt.i16Sub(self.base, 1 as rt.i16); + out[1] = rs.i16Sub(self.base, 1 as rs.i16); } diff --git a/ts/fixtures/crates/expected/bind/last.ts b/ts/fixtures/crates/expected/bind/last.ts index 7ada99ffe..edfeaf071 100644 --- a/ts/fixtures/crates/expected/bind/last.ts +++ b/ts/fixtures/crates/expected/bind/last.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. // `crates_dep::last`, which reads through a raw pointer. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function last(bytes: rt.ByteSlice): rt.u8 { - if (bytes.length === 0) rt.panic("no last byte"); - return bytes.data[bytes.start + bytes.length - 1] as rt.u8; +export function last(bytes: rs.ByteSlice): rs.u8 { + if (bytes.length === 0) rs.panic("no last byte"); + return bytes.data[bytes.start + bytes.length - 1] as rs.u8; } diff --git a/ts/fixtures/crates/expected/bind/slots.ts b/ts/fixtures/crates/expected/bind/slots.ts index 8a7bfc9f1..7596643bb 100644 --- a/ts/fixtures/crates/expected/bind/slots.ts +++ b/ts/fixtures/crates/expected/bind/slots.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. // `crates_dep::Slots`, which writes into the array it is given. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Slots = { base: rt.i16 }; +export type Slots = { base: rs.i16 }; -export function withBase(base: rt.i16): Slots { +export function withBase(base: rs.i16): Slots { return { base }; } -export function fill(self: Slots, out: rt.i16[]): undefined { +export function fill(self: Slots, out: rs.i16[]): undefined { out[0] = self.base; - out[1] = rt.i16Sub(self.base, 1 as rt.i16); + out[1] = rs.i16Sub(self.base, 1 as rs.i16); } diff --git a/ts/fixtures/crates/expected/crates_dep.Countdown.ts b/ts/fixtures/crates/expected/crates_dep.Countdown.ts index 4ed98b58c..68569e40e 100644 --- a/ts/fixtures/crates/expected/crates_dep.Countdown.ts +++ b/ts/fixtures/crates/expected/crates_dep.Countdown.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Counts down from where it starts to one. */ export interface Countdown { - next: rt.u8; - last: rt.u8; + next: rs.u8; + last: rs.u8; } -function new_(from: rt.u8): Countdown { +function new_(from: rs.u8): Countdown { return { next: from, last: 0 }; } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { if (!(self.next === self.last)) { - self.next = rt.u8Sub(self.next, 1); - return rt.u8Add(self.next, 1); + self.next = rs.u8Sub(self.next, 1); + return rs.u8Add(self.next, 1); } - return rt.DONE; + return rs.DONE; } -export function nextBack$iter_DoubleEndedIterator(self: Countdown): rt.u8 | undefined { +export function nextBack$iter_DoubleEndedIterator(self: Countdown): rs.u8 | undefined { if (!(self.next === self.last)) { - self.last = rt.u8Add(self.last, 1); + self.last = rs.u8Add(self.last, 1); return self.last; } return undefined; diff --git a/ts/fixtures/crates/expected/crates_dep.Guard.ts b/ts/fixtures/crates/expected/crates_dep.Guard.ts index 0fef80760..e52b531b2 100644 --- a/ts/fixtures/crates/expected/crates_dep.Guard.ts +++ b/ts/fixtures/crates/expected/crates_dep.Guard.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Notes its id in a log when it drops. */ export class Guard { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -18,26 +18,26 @@ export class Guard { } } -function new_(id: rt.u8, log: rt.Arc>): Guard { - return new Guard(id, rt.arcClone(log)); +function new_(id: rs.u8, log: rs.Arc>): Guard { + return new Guard(id, rs.arcClone(log)); } export function drop$ops_Drop(self: Guard): void { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.mutexUnlock(_5); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.mutexUnlock(_5); } -export function add$crates_dep_Tally(self: Guard, by: rt.u8): void { - self.id = rt.u8WrappingAdd(self.id, by); +export function add$crates_dep_Tally(self: Guard, by: rs.u8): void { + self.id = rs.u8WrappingAdd(self.id, by); } -export function count$crates_dep_Tally(self: Guard): rt.u32 { - return self.id as rt.u32; +export function count$crates_dep_Tally(self: Guard): rs.u32 { + return self.id as rs.u32; } /** Provided, and overridden by one impl. */ -export function scale$crates_dep_Tally(_self: Guard): rt.u32 { +export function scale$crates_dep_Tally(_self: Guard): rs.u32 { return 2; } diff --git a/ts/fixtures/crates/expected/crates_dep.Point.ts b/ts/fixtures/crates/expected/crates_dep.Point.ts index feb16da0c..1865e7d2e 100644 --- a/ts/fixtures/crates/expected/crates_dep.Point.ts +++ b/ts/fixtures/crates/expected/crates_dep.Point.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Point { - x: rt.i32; - y: rt.i32; + x: rs.i32; + y: rs.i32; } /** Move it by `(dx, dy)`: the only write into a `Point` in either crate. */ -export function shift(self: Point, dx: rt.i32, dy: rt.i32): void { - self.x = rt.i32Add(self.x, dx); - self.y = rt.i32Add(self.y, dy); +export function shift(self: Point, dx: rs.i32, dy: rs.i32): void { + self.x = rs.i32Add(self.x, dx); + self.y = rs.i32Add(self.y, dy); } //# sourceMappingURL=crates_dep.Point.ts.map diff --git a/ts/fixtures/crates/expected/crates_dep.Tally.ts b/ts/fixtures/crates/expected/crates_dep.Tally.ts index 09ae81435..ee4f7899c 100644 --- a/ts/fixtures/crates/expected/crates_dep.Tally.ts +++ b/ts/fixtures/crates/expected/crates_dep.Tally.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What [`tally`] counts with, through trait objects of either crate's types. */ export type Tally = - | { add$Tally: (a0: rt.u8) => void; count$Tally: () => rt.u32; scale$Tally: () => rt.u32 }; + | { add$Tally: (a0: rs.u8) => void; count$Tally: () => rs.u32; scale$Tally: () => rs.u32 }; //# sourceMappingURL=crates_dep.Tally.ts.map diff --git a/ts/fixtures/crates/expected/crates_dep.ts b/ts/fixtures/crates/expected/crates_dep.ts index 428eb8db3..708f26ac7 100644 --- a/ts/fixtures/crates/expected/crates_dep.ts +++ b/ts/fixtures/crates/expected/crates_dep.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Tally from "./crates_dep.Tally.ts"; import * as Item from "./harness.Item.ts"; @@ -10,8 +10,8 @@ export function heaviest$harness_Item(items: Item.Item[]): Item.Item | undefined const iterS: Item.Item[] = items; let iterI: number = 0; while (true) { - const _5: Item.Item | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: Item.Item | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return best; } if (best !== undefined) { @@ -24,49 +24,49 @@ export function heaviest$harness_Item(items: Item.Item[]): Item.Item | undefined } /** The first byte of `bytes`. */ -export function first(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rt.u8 { +export function first(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rs.u8 { if (!(bytesLen === 0)) { return read(bytesData, bytesStart, bytesLen); } - rt.panicFmt(["no first byte"]); + rs.panicFmt(["no first byte"]); } -export function read(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rt.u8 { +export function read(bytesData: Uint8Array, bytesStart: number, bytesLen: number): rs.u8 { if (0 >= bytesLen) { - rt.panic("index out of bounds: the len is " + bytesLen + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + bytesLen + " but the index is " + 0); } return bytesData[bytesStart]; } /** Provided, and overridden by one impl. */ -export function scale$crates_dep_Tally_u32(_self: rt.u32): rt.u32 { +export function scale$crates_dep_Tally_u32(_self: rs.u32): rs.u32 { return 1; } -export function add$crates_dep_Tally_u32(self: rt.Place, by: rt.u8): void { - self.v = rt.u32WrappingAdd(self.v, by as rt.u32); +export function add$crates_dep_Tally_u32(self: rs.Place, by: rs.u8): void { + self.v = rs.u32WrappingAdd(self.v, by as rs.u32); } -export function count$crates_dep_Tally_u32(self: rt.u32): rt.u32 { +export function count$crates_dep_Tally_u32(self: rs.u32): rs.u32 { return self; } /** Add `by` to each of `tallies`, then sum their counts by their scales. */ -export function tally(tallies: Tally.Tally[], by: rt.u8): rt.u32 { - let _9!: rt.usize; - let sum: rt.u32 = 0; - const _6: rt.usize = tallies.length; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _6; +export function tally(tallies: Tally.Tally[], by: rs.u8): rs.u32 { + let _9!: rs.usize; + let sum: rs.u32 = 0; + const _6: rs.usize = tallies.length; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _6; while (true) { if (!((_9 = iterStart++) < iterEnd)) { return sum; } - const i: rt.usize = _9; - rt.idx(tallies, i); + const i: rs.usize = _9; + rs.idx(tallies, i); const t: Tally.Tally = tallies[i]; t.add$Tally(by); - sum = rt.u32WrappingAdd(sum, rt.u32WrappingMul(t.count$Tally(), t.scale$Tally())); + sum = rs.u32WrappingAdd(sum, rs.u32WrappingMul(t.count$Tally(), t.scale$Tally())); } } diff --git a/ts/fixtures/crates/expected/harness.Item.ts b/ts/fixtures/crates/expected/harness.Item.ts index 02e893ac5..a62dbd3a9 100644 --- a/ts/fixtures/crates/expected/harness.Item.ts +++ b/ts/fixtures/crates/expected/harness.Item.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The package's own type, which the dependency's generic function ranks. */ export interface Item { - _0: rt.u8; + _0: rs.u8; } -export function weight$crates_dep_Weigh(self: Item): rt.u32 { - return rt.u32Rem(self._0 as rt.u32, 7); +export function weight$crates_dep_Weigh(self: Item): rs.u32 { + return rs.u32Rem(self._0 as rs.u32, 7); } -export function add$crates_dep_Tally(self: Item, by: rt.u8): void { +export function add$crates_dep_Tally(self: Item, by: rs.u8): void { self._0 = self._0 ^ by; } -export function count$crates_dep_Tally(self: Item): rt.u32 { - return self._0 as rt.u32; +export function count$crates_dep_Tally(self: Item): rs.u32 { + return self._0 as rs.u32; } /** Provided, and overridden by one impl. */ -export function scale$crates_dep_Tally(_self: Item): rt.u32 { +export function scale$crates_dep_Tally(_self: Item): rs.u32 { return 1; } diff --git a/ts/fixtures/crates/expected/harness.ts b/ts/fixtures/crates/expected/harness.ts index 383a30d80..a07674133 100644 --- a/ts/fixtures/crates/expected/harness.ts +++ b/ts/fixtures/crates/expected/harness.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_i16, copy$crates_dep_Point, of$crates_dep_Guard, of$harness_Item, of$u32, ofPlace$u32 } from "./lib.ts"; import * as last from "./bind/last.ts"; import * as Slots from "./bind/slots.ts"; @@ -11,89 +11,89 @@ import * as Point from "./crates_dep.Point.ts"; import type * as Tally from "./crates_dep.Tally.ts"; import type * as Item from "./harness.Item.ts"; -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (input.length >= 2) { - const p: Point.Point = { x: input.data[input.start] as rt.i32, y: input.data[input.start + 1] as rt.i32 }; + const p: Point.Point = { x: input.data[input.start] as rs.i32, y: input.data[input.start + 1] as rs.i32 }; const q: Point.Point = copy$crates_dep_Point(p); Point.shift(q, 1, -1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(p.x & 0xff, p.y & 0xff, q.x & 0xff, q.y & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(p.x & 0xff, p.y & 0xff, q.x & 0xff, q.y & 0xff)), undefined, true); } - const _29: Item.Item | undefined = heaviest$harness_Item(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(input)), (_2: rt.u8): Item.Item => { + const _29: Item.Item | undefined = heaviest$harness_Item(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(input)), (_2: rs.u8): Item.Item => { return { _0: _2 }; }), undefined, 1, true).items); if (_29 !== undefined) { - rt.byteVecPush(out, _29._0); + rs.byteVecPush(out, _29._0); } - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const guards: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(input)), 3), (_26: rt.u8): Guard.Guard => { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const guards: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(input)), 3), (_26: rs.u8): Guard.Guard => { return Guard.new(_26, log); }), undefined, 8, true); const held: Guard.Guard = Guard.new(255, log); - rt.dropVec(guards); + rs.dropVec(guards); const _late: Guard.Guard = Guard.new(254, log); held[Symbol.dispose](); _late[Symbol.dispose](); - const _58: rt.Mutex = rt.mutexLock(log.value); - const _54: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_58.value))); - rt.iterExtendBytes(out, _54, undefined, true); - rt.mutexUnlock(_58); + const _58: rs.Mutex = rs.mutexLock(log.value); + const _54: rs.Iter = rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_58.value))); + rs.iterExtendBytes(out, _54, undefined, true); + rs.mutexUnlock(_58); if (input.length >= 3) { const item: Item.Item = { _0: input.data[input.start] }; - let n: rt.u32 = input.data[input.start + 1] as rt.u32; + let n: rs.u32 = input.data[input.start + 1] as rs.u32; const guard: Guard.Guard = Guard.new(input.data[input.start + 2], log); - const _77: Tally.Tally[] = [new of$harness_Item(item), new ofPlace$u32(rt.place(() => n, (value) => n = value)), new of$crates_dep_Guard(guard)]; - const _87: Uint8Array = rt.u32ToBeBytes(tally(_77, input.data[input.start])).reverse(); - rt.iterExtendBytes(out, rt.iterSlice(_87), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(item._0, n & 0xff)), undefined, true); - const boxed: rt.Vec = rt.vecFrom([new of$crates_dep_Guard(guard), new of$harness_Item(item), new of$u32(n)]); - rt.sliceSwap(boxed.items, 0, 2); - rt.vecTruncate(boxed, 2, rt.drop); - const iter: rt.Iter> = rt.iterSliceMut(boxed.items); + const _77: Tally.Tally[] = [new of$harness_Item(item), new ofPlace$u32(rs.place(() => n, (value) => n = value)), new of$crates_dep_Guard(guard)]; + const _87: Uint8Array = rs.u32ToBeBytes(tally(_77, input.data[input.start])).reverse(); + rs.iterExtendBytes(out, rs.iterSlice(_87), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(item._0, n & 0xff)), undefined, true); + const boxed: rs.Vec = rs.vecFrom([new of$crates_dep_Guard(guard), new of$harness_Item(item), new of$u32(n)]); + rs.sliceSwap(boxed.items, 0, 2); + rs.vecTruncate(boxed, 2, rs.drop); + const iter: rs.Iter> = rs.iterSliceMut(boxed.items); while (true) { - const _113: rt.Place | rt.Done = iter.next(); - if (_113 === rt.DONE) { + const _113: rs.Place | rs.Done = iter.next(); + if (_113 === rs.DONE) { break; } _113.v.add$Tally(input.data[input.start + 2]); - const _122: rt.u8 = _113.v.count$Tally() & 0xff; - rt.byteVecPush(out, _122); + const _122: rs.u8 = _113.v.count$Tally() & 0xff; + rs.byteVecPush(out, _122); } - rt.dropVec(boxed); - const _133: rt.Mutex = rt.mutexLock(log.value); - const _129: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_133.value))); - rt.iterExtendBytes(out, _129, undefined, true); - rt.mutexUnlock(_133); + rs.dropVec(boxed); + const _133: rs.Mutex = rs.mutexLock(log.value); + const _129: rs.Iter = rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_133.value))); + rs.iterExtendBytes(out, _129, undefined, true); + rs.mutexUnlock(_133); } - const iter2: Countdown.Countdown = Countdown.new(rt.min(input.length, 4) & 0xff); + const iter2: Countdown.Countdown = Countdown.new(rs.min(input.length, 4) & 0xff); while (true) { - const _143: rt.u8 | rt.Done = Countdown.next$iter_Iterator(iter2); - if (_143 === rt.DONE) { + const _143: rs.u8 | rs.Done = Countdown.next$iter_Iterator(iter2); + if (_143 === rs.DONE) { break; } - rt.byteVecPush(out, _143); + rs.byteVecPush(out, _143); } - const _151: rt.Iter = rt.iterRev(rt.iterFrom(Countdown.new(rt.min(input.length, 5) & 0xff), Countdown.next$iter_Iterator, undefined, { back: (it: Countdown.Countdown) => rt.iterFromOption(Countdown.nextBack$iter_DoubleEndedIterator(it)) })); - rt.iterExtendBytes(out, _151, "next"); - const both: Countdown.Countdown = Countdown.new(rt.min(input.length, 6) & 0xff); + const _151: rs.Iter = rs.iterRev(rs.iterFrom(Countdown.new(rs.min(input.length, 5) & 0xff), Countdown.next$iter_Iterator, undefined, { back: (it: Countdown.Countdown) => rs.iterFromOption(Countdown.nextBack$iter_DoubleEndedIterator(it)) })); + rs.iterExtendBytes(out, _151, "next"); + const both: Countdown.Countdown = Countdown.new(rs.min(input.length, 6) & 0xff); while (true) { - const _160: rt.u8 | undefined = Countdown.nextBack$iter_DoubleEndedIterator(both); + const _160: rs.u8 | undefined = Countdown.nextBack$iter_DoubleEndedIterator(both); if (_160 !== undefined) { - rt.byteVecPush(out, _160); - const _168: rt.u8 | undefined = rt.iterToOption(Countdown.next$iter_Iterator(both)); - rt.iterExtendBytes(out, rt.iterOption(_168), undefined, true); + rs.byteVecPush(out, _160); + const _168: rs.u8 | undefined = rs.iterToOption(Countdown.next$iter_Iterator(both)); + rs.iterExtendBytes(out, rs.iterOption(_168), undefined, true); } else { break; } } - const kept: rt.i16[] = [(input.length << 16) >> 16, 7]; - const filled: rt.i16[] = copy$array_i16(kept); + const kept: rs.i16[] = [(input.length << 16) >> 16, 7]; + const filled: rs.i16[] = copy$array_i16(kept); Slots.fill(Slots.withBase(kept[0]), filled); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff)), undefined, true); - const _202: rt.u8 = first(input.data, input.start, input.length); - rt.byteVecPush(out, _202); - const _205: rt.u8 = last.last(input); - rt.byteVecPush(out, _205); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(kept[0] & 0xff, kept[1] & 0xff, filled[0] & 0xff, filled[1] & 0xff)), undefined, true); + const _202: rs.u8 = first(input.data, input.start, input.length); + rs.byteVecPush(out, _202); + const _205: rs.u8 = last.last(input); + rs.byteVecPush(out, _205); log[Symbol.dispose](); return out; } diff --git a/ts/fixtures/crates/expected/lib.ts b/ts/fixtures/crates/expected/lib.ts index 63a285415..55710e784 100644 --- a/ts/fixtures/crates/expected/lib.ts +++ b/ts/fixtures/crates/expected/lib.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { scale$crates_dep_Tally_u32, add$crates_dep_Tally_u32, count$crates_dep_Tally_u32 } from "./crates_dep.ts"; import * as Guard from "./crates_dep.Guard.ts"; import type * as Point from "./crates_dep.Point.ts"; import * as Item from "./harness.Item.ts"; -export function copy$array_i16(v: rt.i16[]): rt.i16[] { +export function copy$array_i16(v: rs.i16[]): rs.i16[] { return v.slice(); } @@ -25,15 +25,15 @@ export class of$crates_dep_Guard { this.v[Symbol.dispose](); } - add$Tally(a: rt.u8): void { + add$Tally(a: rs.u8): void { return Guard.add$crates_dep_Tally(this.v, a); } - count$Tally(): rt.u32 { + count$Tally(): rs.u32 { return Guard.count$crates_dep_Tally(this.v); } - scale$Tally(): rt.u32 { + scale$Tally(): rs.u32 { return Guard.scale$crates_dep_Tally(this.v); } } @@ -45,55 +45,55 @@ export class of$harness_Item { this.v = v; } - add$Tally(a: rt.u8): void { + add$Tally(a: rs.u8): void { return Item.add$crates_dep_Tally(this.v, a); } - count$Tally(): rt.u32 { + count$Tally(): rs.u32 { return Item.count$crates_dep_Tally(this.v); } - scale$Tally(): rt.u32 { + scale$Tally(): rs.u32 { return Item.scale$crates_dep_Tally(this.v); } } export class of$u32 { - v: rt.u32; + v: rs.u32; - constructor(v: rt.u32) { + constructor(v: rs.u32) { this.v = v; } - add$Tally(a: rt.u8): void { + add$Tally(a: rs.u8): void { return add$crates_dep_Tally_u32(this, a); } - count$Tally(): rt.u32 { + count$Tally(): rs.u32 { return count$crates_dep_Tally_u32(this.v); } - scale$Tally(): rt.u32 { + scale$Tally(): rs.u32 { return scale$crates_dep_Tally_u32(this.v); } } export class ofPlace$u32 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - add$Tally(a: rt.u8): void { + add$Tally(a: rs.u8): void { return add$crates_dep_Tally_u32(this.v, a); } - count$Tally(): rt.u32 { + count$Tally(): rs.u32 { return count$crates_dep_Tally_u32(this.v.v); } - scale$Tally(): rt.u32 { + scale$Tally(): rs.u32 { return scale$crates_dep_Tally_u32(this.v.v); } } diff --git a/ts/fixtures/lang/args/expected/args.Scale.ts b/ts/fixtures/lang/args/expected/args.Scale.ts index e9e62c3c7..b5e9b313e 100644 --- a/ts/fixtures/lang/args/expected/args.Scale.ts +++ b/ts/fixtures/lang/args/expected/args.Scale.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Scale { - _0: rt.u8; + _0: rs.u8; } -export function weigh$args_Weigh(self: Scale, data: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(data)), self._0, (a: rt.u8, b: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a, b ^ 90); +export function weigh$args_Weigh(self: Scale, data: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(data)), self._0, (a: rs.u8, b: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a, b ^ 90); }); } diff --git a/ts/fixtures/lang/args/expected/args.ts b/ts/fixtures/lang/args/expected/args.ts index 56b67f17a..b75e073da 100644 --- a/ts/fixtures/lang/args/expected/args.ts +++ b/ts/fixtures/lang/args/expected/args.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Scale from "./args.Scale.ts"; -import { map$0waqle9 as option_map$0waqle9, map$1yogfym as option_map$1yogfym, mapOr$0dk8jdr as option_mapOr$0dk8jdr } from "./core/option.ts"; +import { map$0a3rlpk as option_map$0a3rlpk, map$05uajnx as option_map$05uajnx, mapOr$1klptgj as option_mapOr$1klptgj } from "./core/option.ts"; /** A use that needs the slice itself. */ -export function opaque(s: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(s)), s.length & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a ^ (a >> 3), b); +export function opaque(s: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(s)), s.length & 0xff, (a: rs.u8, b: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a ^ (a >> 3), b); }); } /** A parameter reassigned from its own tail. */ -export function sum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - let sum: rt.u8 = 0; +export function sum(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { + let sum: rs.u8 = 0; while (true) { const _4Data: Uint8Array = dataData; const _4Start: number = dataStart; const _4Len: number = dataLen; if (_4Len !== 0) { - sum = rt.u8WrappingAdd(sum, _4Data[_4Start]); + sum = rs.u8WrappingAdd(sum, _4Data[_4Start]); dataData = _4Data; dataStart = _4Start + 1; dataLen = _4Len - 1; @@ -30,25 +30,25 @@ export function sum(dataData: Uint8Array, dataStart: number, dataLen: number): r } /** A parameter only measured. */ -export function len(_dataData: Uint8Array, _dataStart: number, dataLen: number): rt.usize { +export function len(_dataData: Uint8Array, _dataStart: number, dataLen: number): rs.usize { return dataLen; } /** A parameter borrowed, which takes it whole. */ -export function byRef(data: rt.ByteSlice): rt.usize { +export function byRef(data: rs.ByteSlice): rs.usize { return lenOf(data); } -export function lenOf(data: rt.ByteSlice): rt.usize { +export function lenOf(data: rs.ByteSlice): rs.usize { return data.length; } /** A parameter made whole in a loop, which takes it whole. */ -export function kept(data: rt.ByteSlice, n: rt.u8): rt.Vec { - const all: rt.Vec = new rt.Vec(); - const _6: rt.u8 = rt.u8Rem(n, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _6; +export function kept(data: rs.ByteSlice, n: rs.u8): rs.Vec { + const all: rs.Vec = new rs.Vec(); + const _6: rs.u8 = rs.u8Rem(n, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _6; while (true) { if (!(iterStart++ < iterEnd)) { return all; @@ -58,39 +58,39 @@ export function kept(data: rt.ByteSlice, n: rt.u8): rt.Vec { } /** A reference to an array of bytes. */ -export function word(w: rt.ByteSlice): rt.u32 { +export function word(w: rs.ByteSlice): rs.u32 { return ((w.data[w.start] << 24) | (w.data[w.start + 1] << 16) | (w.data[w.start + 2] << 8) | w.data[w.start + 3]) >>> 0; } /** Two slices, perhaps the same. */ -export function both(a: rt.ByteSlice, bData: Uint8Array, bStart: number, bLen: number): rt.u8 { +export function both(a: rs.ByteSlice, bData: Uint8Array, bStart: number, bLen: number): rs.u8 { return opaque(a) ^ (len(bData, bStart, bLen) & 0xff); } /** A recursive count of the bytes before a zero. */ -export function depth(data: rt.ByteSlice): rt.u8 { - const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); +export function depth(data: rs.ByteSlice): rs.u8 { + const _2: [rs.u8, rs.ByteSlice] | undefined = rs.byteSliceSplitFirst(data); if (_2 !== undefined) { if (_2[0] !== 0) { - return rt.u8Add(1, depth(_2[1])); + return rs.u8Add(1, depth(_2[1])); } } return 0; } /** Passed along to one that takes it whole, so taken whole too. */ -export function relay(data: rt.ByteSlice): rt.u8 { +export function relay(data: rs.ByteSlice): rs.u8 { return opaque(data); } /** Passed along to one that takes its parts, so taken as parts too. */ -export function relaySum(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function relaySum(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { return sum(dataData, dataStart, dataLen); } /** Recursive, and made whole at the bottom, so taken whole all the way down. */ -export function lastRun(data: rt.ByteSlice): rt.u8 { - const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); +export function lastRun(data: rs.ByteSlice): rs.u8 { + const _2: [rs.u8, rs.ByteSlice] | undefined = rs.byteSliceSplitFirst(data); if (_2 !== undefined) { if (_2[0] !== 0) { return lastRun(_2[1]); @@ -100,14 +100,14 @@ export function lastRun(data: rt.ByteSlice): rt.u8 { } /** Mutually recursive, each reading bytes, so both take parts. */ -export function evens(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function evens(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { if (dataLen === 0) { return 0; } - return rt.u8WrappingAdd(dataData[dataStart], odds(dataData, dataStart + 1, dataLen - 1)); + return rs.u8WrappingAdd(dataData[dataStart], odds(dataData, dataStart + 1, dataLen - 1)); } -export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { if (dataLen === 0) { return 0; } @@ -115,128 +115,128 @@ export function odds(dataData: Uint8Array, dataStart: number, dataLen: number): } /** Mutually recursive, where `ping` makes its slice whole and `pong` only splits its own. */ -export function ping(data: rt.ByteSlice): rt.u8 { - const _2: [rt.u8, rt.ByteSlice] | undefined = rt.byteSliceSplitFirst(data); +export function ping(data: rs.ByteSlice): rs.u8 { + const _2: [rs.u8, rs.ByteSlice] | undefined = rs.byteSliceSplitFirst(data); if (_2 !== undefined) { - if (rt.u8Rem(_2[0], 3) !== 0) { + if (rs.u8Rem(_2[0], 3) !== 0) { return pong(_2[1].data, _2[1].start, _2[1].length); } } return opaque(data); } -export function pong(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function pong(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { if (dataLen === 0) { return 0; } - return dataData[dataStart] ^ ping(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)); + return dataData[dataStart] ^ ping(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)); } /** A slice chosen by a call that does something. */ -export function pick(out: rt.ByteVec, data: rt.ByteSlice): rt.ByteSlice { - rt.byteVecPush(out, 187); - return rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); +export function pick(out: rs.ByteVec, data: rs.ByteSlice): rs.ByteSlice { + rs.byteVecPush(out, 187); + return rs.byteSliceRange(data, rs.usizeDiv(data.length, 2)); } -export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { - rt.byteVecPush(out, 238); +export function code(out: rs.ByteVec, n: rs.u8): rs.u8 { + rs.byteVecPush(out, 238); return n; } -export function pair(n: rt.u8, s: rt.ByteSlice): rt.u8 { +export function pair(n: rs.u8, s: rs.ByteSlice): rs.u8 { return n ^ opaque(s); } -export function weigh$args_Scale(w: Scale.Scale, data: rt.ByteSlice): rt.u8 { +export function weigh$args_Scale(w: Scale.Scale, data: rs.ByteSlice): rs.u8 { return Scale.weigh$args_Weigh(w, data); } -export function args(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: (a0: rt.ByteSlice) => rt.u8; - const _4: rt.u8 = rt.u8Rem(kind, 8); +export function args(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: (a0: rs.ByteSlice) => rs.u8; + const _4: rs.u8 = rs.u8Rem(kind, 8); if (_4 === 0) { - rt.byteVecPush(out, sum(data.data, data.start, data.length)); - rt.byteVecPush(out, len(data.data, data.start, data.length) & 0xff); - rt.byteVecPush(out, byRef(data) & 0xff); - rt.byteVecPush(out, rt.iterFold(rt.iterMap(rt.iterSlice(kept(data, kind).items), (s: rt.ByteSlice): rt.u8 => { + rs.byteVecPush(out, sum(data.data, data.start, data.length)); + rs.byteVecPush(out, len(data.data, data.start, data.length) & 0xff); + rs.byteVecPush(out, byRef(data) & 0xff); + rs.byteVecPush(out, rs.iterFold(rs.iterMap(rs.iterSlice(kept(data, kind).items), (s: rs.ByteSlice): rs.u8 => { return opaque(s); - }), 0, (a03: rt.u8, a1: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a03, a1); + }), 0, (a03: rs.u8, a1: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a03, a1); })); } else if (_4 === 1) { if (data.length >= 4) { - const w: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(word(w), 1)))); - rt.byteVecPush(out, both(new rt.ByteSlice(data.data, data.start + 4, data.length - 4), data.data, data.start + 4, data.length - 4)); - rt.byteVecPush(out, both(w, data.data, data.start + 4, data.length - 4)); + const w: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 4); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32WrappingAdd(word(w), 1)))); + rs.byteVecPush(out, both(new rs.ByteSlice(data.data, data.start + 4, data.length - 4), data.data, data.start + 4, data.length - 4)); + rs.byteVecPush(out, both(w, data.data, data.start + 4, data.length - 4)); } - rt.byteVecPush(out, depth(rt.byteSliceRange(data, 0, rt.min(data.length, 64)))); + rs.byteVecPush(out, depth(rs.byteSliceRange(data, 0, rs.min(data.length, 64)))); } else if (_4 === 2) { - rt.iterExtendBytes(out, rt.iterOption(option_map$0waqle9(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_2: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0a3rlpk(option_map$05uajnx((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, (_2: [rs.u8, rs.ByteSlice]): rs.ByteSlice => { return _2[1]; }), opaque)), undefined, true); - if (!(rt.usizeRem(data.length, 2) === 0)) { - f = (a0: rt.ByteSlice): rt.u8 => { + if (!(rs.usizeRem(data.length, 2) === 0)) { + f = (a0: rs.ByteSlice): rs.u8 => { return sum(a0.data, a0.start, a0.length); }; } else { f = opaque; } - rt.byteVecPush(out, f(data)); - rt.byteVecPush(out, option_mapOr$0dk8jdr(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + rs.byteVecPush(out, f(data)); + rs.byteVecPush(out, option_mapOr$1klptgj(option_map$05uajnx((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, (_22: [rs.u8, rs.ByteSlice]): rs.ByteSlice => { return _22[1]; - }), 0, (a02: rt.ByteSlice): rt.usize => { + }), 0, (a02: rs.ByteSlice): rs.usize => { return len(a02.data, a02.start, a02.length); }) & 0xff); } else if (_4 === 3) { - rt.byteVecPush(out, pair(code(out, 1), pick(out, data))); + rs.byteVecPush(out, pair(code(out, 1), pick(out, data))); } else if (_4 === 4) { - const seen: rt.ByteVec = new rt.ByteVec(); - const note: (a0: rt.u8) => undefined = (b2: rt.u8): undefined => { - rt.byteVecPush(seen, b2 ^ opaque(data)); + const seen: rs.ByteVec = new rs.ByteVec(); + const note: (a0: rs.u8) => undefined = (b2: rs.u8): undefined => { + rs.byteVecPush(seen, b2 ^ opaque(data)); }; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3); while (true) { - const _70: rt.u8 | rt.Done = iter.next(); - if (_70 === rt.DONE) { + const _70: rs.u8 | rs.Done = iter.next(); + if (_70 === rs.DONE) { break; } note(_70); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(seen)); } else if (_4 === 6) { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 64)); - rt.byteVecPush(out, relay(data2)); - rt.byteVecPush(out, relaySum(data2.data, data2.start, data2.length)); - rt.byteVecPush(out, lastRun(data2)); - rt.byteVecPush(out, evens(data2.data, data2.start, data2.length)); - rt.byteVecPush(out, ping(data2)); - rt.byteVecPush(out, pong(data2.data, data2.start, data2.length)); + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 64)); + rs.byteVecPush(out, relay(data2)); + rs.byteVecPush(out, relaySum(data2.data, data2.start, data2.length)); + rs.byteVecPush(out, lastRun(data2)); + rs.byteVecPush(out, evens(data2.data, data2.start, data2.length)); + rs.byteVecPush(out, ping(data2)); + rs.byteVecPush(out, pong(data2.data, data2.start, data2.length)); } else if (_4 === 7) { - const mid: number = rt.usizeDiv(data.length, 2); + const mid: number = rs.usizeDiv(data.length, 2); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const mid2: number = rt.usizeDiv(data.length, 2); + const mid2: number = rs.usizeDiv(data.length, 2); if (mid2 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const halves: rt.ByteSlice[] = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2)]; - const iter2: rt.Iter = rt.iterSlice(halves); + const halves: rs.ByteSlice[] = [new rs.ByteSlice(data.data, data.start, mid), new rs.ByteSlice(data.data, data.start + mid2, data.length - mid2)]; + const iter2: rs.Iter = rs.iterSlice(halves); while (true) { - const _111: rt.ByteSlice | rt.Done = iter2.next(); - if (_111 === rt.DONE) { + const _111: rs.ByteSlice | rs.Done = iter2.next(); + if (_111 === rs.DONE) { break; } - const _138: rt.ByteSlice = _111; - rt.byteVecPush(out, sum(_138.data, _138.start, _138.length)); - rt.byteVecPush(out, relay(_111)); + const _138: rs.ByteSlice = _111; + rs.byteVecPush(out, sum(_138.data, _138.start, _138.length)); + rs.byteVecPush(out, relay(_111)); } - rt.byteVecPush(out, relaySum(halves[1].data, halves[1].start, halves[1].length)); - rt.byteVecPush(out, sum(data.data, data.start, data.length)); + rs.byteVecPush(out, relaySum(halves[1].data, halves[1].start, halves[1].length)); + rs.byteVecPush(out, sum(data.data, data.start, data.length)); } else { - rt.byteVecPush(out, weigh$args_Scale({ _0: kind }, data)); - rt.byteVecPush(out, Scale.weigh$args_Weigh({ _0: 3 }, rt.byteSliceRange(data, rt.min(data.length, 2)))); + rs.byteVecPush(out, weigh$args_Scale({ _0: kind }, data)); + rs.byteVecPush(out, Scale.weigh$args_Weigh({ _0: 3 }, rs.byteSliceRange(data, rs.min(data.length, 2)))); } } diff --git a/ts/fixtures/lang/args/expected/core/option.ts b/ts/fixtures/lang/args/expected/core/option.ts index 2e934a440..e4f75b3c8 100644 --- a/ts/fixtures/lang/args/expected/core/option.ts +++ b/ts/fixtures/lang/args/expected/core/option.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { opaque, len as args_len } from "../args.ts"; -export function map$0waqle9(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { +export function map$0a3rlpk(self: rs.ByteSlice | undefined, _: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return opaque(self); } -export function map$1yogfym(self: [rt.u8, rt.ByteSlice] | undefined, f: (a0: [rt.u8, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice | undefined { +export function map$05uajnx(self: [rs.u8, rs.ByteSlice] | undefined, f: (a0: [rs.u8, rs.ByteSlice]) => rs.ByteSlice): rs.ByteSlice | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$0dk8jdr(self: rt.ByteSlice | undefined, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { +export function mapOr$1klptgj(self: rs.ByteSlice | undefined, default_: rs.usize, _: (a0: rs.ByteSlice) => rs.usize): rs.usize { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/args/expected/harness.ts b/ts/fixtures/lang/args/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/args/expected/harness.ts +++ b/ts/fixtures/lang/args/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/args/expected/lib.ts b/ts/fixtures/lang/args/expected/lib.ts index 39efddd86..86836ffd5 100644 --- a/ts/fixtures/lang/args/expected/lib.ts +++ b/ts/fixtures/lang/args/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { args } from "./args.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["args::args", args as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["args::args", args as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/arrays/expected/arrays.Bracketed.ts b/ts/fixtures/lang/arrays/expected/arrays.Bracketed.ts index 1b5b25a57..93a233c4c 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.Bracketed.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.Bracketed.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An array formatted through its own `Debug`, given a reference to it. */ export interface Bracketed { _0: Uint8Array; } -export function fmt$fmt_Debug(self: Bracketed, f: rt.Formatter): rt.Result { - if (rt.fmtWriteStr(f, "<").ok) { - if (rt.fmtList(rt.byteSliceView(rt.byteSliceFrom(self._0)), f, rt.u8Debug).ok) { - return rt.fmtWriteStr(f, ">"); +export function fmt$fmt_Debug(self: Bracketed, f: rs.Formatter): rs.Result { + if (rs.fmtWriteStr(f, "<").ok) { + if (rs.fmtList(rs.byteSliceView(rs.byteSliceFrom(self._0)), f, rs.u8Debug).ok) { + return rs.fmtWriteStr(f, ">"); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } //# sourceMappingURL=arrays.Bracketed.ts.map diff --git a/ts/fixtures/lang/arrays/expected/arrays.Listed.ts b/ts/fixtures/lang/arrays/expected/arrays.Listed.ts index 4c0ee74cf..67bb1f051 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.Listed.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.Listed.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An `Option` formatted as a list of what it holds. */ export interface Listed { _0: Uint8Array | undefined; } -export function fmt$fmt_Debug(self: Listed, f: rt.Formatter): rt.Result { - return rt.debugListFinish(rt.debugListEntries(rt.fmtDebugList(f), rt.iterLend(rt.iterOption(self._0), rt.byteSliceFrom), (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug))); +export function fmt$fmt_Debug(self: Listed, f: rs.Formatter): rs.Result { + return rs.debugListFinish(rs.debugListEntries(rs.fmtDebugList(f), rs.iterLend(rs.iterOption(self._0), rs.byteSliceFrom), (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))); } //# sourceMappingURL=arrays.Listed.ts.map diff --git a/ts/fixtures/lang/arrays/expected/arrays.ts b/ts/fixtures/lang/arrays/expected/arrays.ts index 4306d188d..0e0aa39b0 100644 --- a/ts/fixtures/lang/arrays/expected/arrays.ts +++ b/ts/fixtures/lang/arrays/expected/arrays.ts @@ -1,213 +1,213 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_Option_array0_u8, copy$Option_Option_array1_u8, copy$Option_Option_array5_u8, copy$Option_array0_u8, copy$Option_array1_u8, copy$Option_array3_u8, copy$Option_array40_u8, copy$Option_array5_u8, copy$array_Option_Option_array0_u8, copy$array_Option_Option_array1_u8, copy$array_Option_Option_array5_u8, copy$array_array0_u8, copy$array_array1_u8, copy$array_array2_u8, copy$array_array5_u8, copy$array_u32, copy$array_u8 } from "./lib.ts"; import * as Bracketed from "./arrays.Bracketed.ts"; import type * as Framed from "./arrays.Framed.ts"; import * as Listed from "./arrays.Listed.ts"; import { then$11x7xqs } from "./core/bool.ts"; -import { isSomeAnd$09tpccf, unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1j8xzu6 as option_map$1j8xzu6, map$0p6o7wa as option_map$0p6o7wa, map$1jcn6wm as option_map$1jcn6wm, map$0rbsrz6 as option_map$0rbsrz6, mapOr$1surhce as option_mapOr$1surhce } from "./core/option.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1tggsfb as option_map$1tggsfb, map$0p6o7wa as option_map$0p6o7wa, map$10o993m as option_map$10o993m, map$1yv0md6 as option_map$1yv0md6, mapOr$0vxw5sq as option_mapOr$0vxw5sq } from "./core/option.ts"; /** Each byte an operation, its value the operand; each puts what it read. */ -export function fromFns(data: rt.ByteSlice, out: rt.ByteVec): void { +export function fromFns(data: rs.ByteSlice, out: rs.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(op, 5); + for (const op of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { - const seen: rt.Vec = new rt.Vec(); - const bytes: Uint8Array = rt.bytesFromFn(4, (i6: rt.usize): rt.u8 => { + const seen: rs.Vec = new rs.Vec(); + const bytes: Uint8Array = rs.bytesFromFn(4, (i6: rs.usize): rs.u8 => { seen.items.push(i6); - return rt.u8WrappingMul(op, rt.u8Add(i6 & 0xff, 1)); + return rs.u8WrappingMul(op, rs.u8Add(i6 & 0xff, 1)); }); - const wide: rt.u64[] = rt.arrayFromFn(3, (i7: rt.usize): rt.u64 => { - return rt.u64Shl(op as rt.u64, rt.usizeMul(i7, 30)); + const wide: rs.u64[] = rs.arrayFromFn(3, (i7: rs.usize): rs.u64 => { + return rs.u64Shl(op as rs.u64, rs.usizeMul(i7, 30)); }); - const _23: rt.ByteSlice = rt.byteSliceFrom(bytes); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_23), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(wide, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtList(seen.items, f, rt.usizeDebug)]; - s = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const _23: rs.ByteSlice = rs.byteSliceFrom(bytes); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_23), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtList(seen.items, f, rs.usizeDebug)]; + s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); } else if (_10 === 1) { - const counts: rt.Atomic[] = rt.arrayFromFn(8, (_2: rt.usize): rt.Atomic => { - return new rt.Atomic(op as rt.u64); + const counts: rs.Atomic[] = rs.arrayFromFn(8, (_2: rs.usize): rs.Atomic => { + return new rs.Atomic(op as rs.u64); }); - const _37: rt.usize = rt.u8Rem(op, 8) as rt.usize; + const _37: rs.usize = rs.u8Rem(op, 8) as rs.usize; if (!(_37 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _37); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _37); } - rt.atomicFetch(counts[_37], rt.u64WrappingAdd, 1, 0); - const copy: rt.Atomic[] = rt.arrayFromFn(8, (i4: rt.usize): rt.Atomic => { + rs.atomicFetch(counts[_37], rs.u64WrappingAdd, 1, 0); + const copy: rs.Atomic[] = rs.arrayFromFn(8, (i4: rs.usize): rs.Atomic => { if (!(i4 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i4); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + i4); } - return new rt.Atomic(rt.atomicLoad(counts[i4], 0)); + return new rs.Atomic(rs.atomicLoad(counts[i4], 0)); }); - rt.atomicStore(copy[0], 0, 0); - const loads: rt.u64[] = rt.arrayFromFn(8, (i5: rt.usize): rt.u64 => { + rs.atomicStore(copy[0], 0, 0); + const loads: rs.u64[] = rs.arrayFromFn(8, (i5: rs.usize): rs.u64 => { if (!(i5 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i5); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + i5); } - return rt.atomicLoad(counts[i5], 0); + return rs.atomicLoad(counts[i5], 0); }); - const _57: rt.u64 = rt.atomicLoad(copy[0], 0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(loads, f, rt.u64Debug), (f: rt.Formatter) => rt.u64Display(_57, f)]; - s = rt.fmtFormat([args4[0], " ", args4[1]]); + const _57: rs.u64 = rs.atomicLoad(copy[0], 0); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(loads, f, rs.u64Debug), (f: rs.Formatter) => rs.u64Display(_57, f)]; + s = rs.fmtFormat([args4[0], " ", args4[1]]); } else if (_10 === 2) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(op, f)]; - const captured = rt.fmtFormat(["w", args6[0]]); - const words: string[] = rt.arrayFromFn(3, (i2: rt.usize): string => { - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, captured), (f: rt.Formatter) => rt.usizeDisplay(i2, f)]; - return rt.fmtFormat([args14[0], args14[1]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; + const captured = rs.fmtFormat(["w", args6[0]]); + const words: string[] = rs.arrayFromFn(3, (i2: rs.usize): string => { + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.usizeDisplay(i2, f)]; + return rs.fmtFormat([args14[0], args14[1]]); }); - const _79: string[] = rt.arrayFromFn(0, (i3: rt.usize): string => { - return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(i3, f)); + const _79: string[] = rs.arrayFromFn(0, (i3: rs.usize): string => { + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(i3, f)); }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(words, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(_79, f, rt.fmtStr)]; - s = rt.fmtFormat([args8[0], " ", args8[1]]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_79, f, rs.fmtStr)]; + s = rs.fmtFormat([args8[0], " ", args8[1]]); } else if (_10 === 3) { - const grid: Uint8Array[] = rt.arrayFromFn(3, (i: rt.usize): Uint8Array => { - return rt.bytesFromFn(2, (j: rt.usize): rt.u8 => { - return rt.u8WrappingAdd(op, rt.usizeAdd(rt.usizeMul(i, 2), j) & 0xff); + const grid: Uint8Array[] = rs.arrayFromFn(3, (i: rs.usize): Uint8Array => { + return rs.bytesFromFn(2, (j: rs.usize): rs.u8 => { + return rs.u8WrappingAdd(op, rs.usizeAdd(rs.usizeMul(i, 2), j) & 0xff); }); }); - const named: rt.u16[] = rt.arrayFromFn(4, doubled); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(grid, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(named, f, rt.u16Debug)]; - s = rt.fmtFormat([args10[0], " ", args10[1]]); + const named: rs.u16[] = rs.arrayFromFn(4, doubled); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(named, f, rs.u16Debug)]; + s = rs.fmtFormat([args10[0], " ", args10[1]]); } else { - const _108: rt.usize[] = counted$2(op); - const _110: rt.usize[] = counted$5(op); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(_108, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtList(_110, f, rt.usizeDebug)]; - s = rt.fmtFormat([args12[0], " ", args12[1]]); + const _108: rs.usize[] = counted$2(op); + const _110: rs.usize[] = counted$5(op); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_108, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(_110, f, rs.usizeDebug)]; + s = rs.fmtFormat([args12[0], " ", args12[1]]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 10); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 10); } } -export function doubled(i: rt.usize): rt.u16 { - return rt.u16Mul(i & 0xffff, 2); +export function doubled(i: rs.usize): rs.u16 { + return rs.u16Mul(i & 0xffff, 2); } /** An array as long as `N` says, of `N` instances. */ -export function counted$2(op: rt.u8): rt.usize[] { - return rt.arrayFromFn(2, (i: rt.usize): rt.usize => { - return rt.usizeAdd(rt.usizeMul(i, 2), op as rt.usize); +export function counted$2(op: rs.u8): rs.usize[] { + return rs.arrayFromFn(2, (i: rs.usize): rs.usize => { + return rs.usizeAdd(rs.usizeMul(i, 2), op as rs.usize); }); } /** An array as long as `N` says, of `N` instances. */ -export function counted$5(op: rt.u8): rt.usize[] { - return rt.arrayFromFn(5, (i: rt.usize): rt.usize => { - return rt.usizeAdd(rt.usizeMul(i, 5), op as rt.usize); +export function counted$5(op: rs.u8): rs.usize[] { + return rs.arrayFromFn(5, (i: rs.usize): rs.usize => { + return rs.usizeAdd(rs.usizeMul(i, 5), op as rs.usize); }); } /** * Arrays `map` makes, calling its closure on each element in order; each byte an * operation, its value the operand. From bytes and to them, of none at all, through what - * the closure captured by reference and by move, of `Option`s whose `None` is `rt.None`, + * the closure captured by reference and by move, of `Option`s whose `None` is `rs.None`, * and of arrays, each element the closure's own to change. */ -export function maps(data: rt.ByteSlice, out: rt.ByteVec): void { +export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(op, 5); + for (const op of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(op, 5); if (_10 === 0) { - const seen: rt.ByteVec = new rt.ByteVec(); + const seen: rs.ByteVec = new rs.ByteVec(); const bytes: Uint8Array = Uint8Array.of(op, op ^ 1, op ^ 2, op ^ 3); - const wide: rt.u16[] = rt.arrayMap(bytes, (b2: rt.u8): rt.u16 => { - rt.byteVecPush(seen, b2); - return (((b2 as rt.u16) << 8) & 0xffff) | op as rt.u16; + const wide: rs.u16[] = rs.arrayMap(bytes, (b2: rs.u8): rs.u16 => { + rs.byteVecPush(seen, b2); + return (((b2 as rs.u16) << 8) & 0xffff) | op as rs.u16; }); - const narrow: Uint8Array = rt.bytesMap(wide, (w3: rt.u16): rt.u8 => { + const narrow: Uint8Array = rs.bytesMap(wide, (w3: rs.u16): rs.u8 => { return (w3 >> 4) & 0xff; }); - const same: Uint8Array = rt.bytesMap(narrow, (b3: rt.u8): rt.u8 => { - return rt.u8WrappingMul(b3, op); + const same: Uint8Array = rs.bytesMap(narrow, (b3: rs.u8): rs.u8 => { + return rs.u8WrappingMul(b3, op); }); - const words: rt.u32[] = rt.arrayMap([op as rt.u32, 7, 9], (w4: rt.u32): rt.u32 => { - return rt.u32WrappingMul(w4, 16777619); + const words: rs.u32[] = rs.arrayMap([op as rs.u32, 7, 9], (w4: rs.u32): rs.u32 => { + return rs.u32WrappingMul(w4, 16777619); }); - const _31: rt.ByteSlice = rt.byteSliceFrom(bytes); - const _33: rt.ByteSlice = rt.byteSliceFrom(narrow); - const _34: rt.ByteSlice = rt.byteSliceFrom(same); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_31), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(wide, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_33), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_34), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(words, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(seen), f, rt.u8Debug)]; - s = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]]); + const _31: rs.ByteSlice = rs.byteSliceFrom(bytes); + const _33: rs.ByteSlice = rs.byteSliceFrom(narrow); + const _34: rs.ByteSlice = rs.byteSliceFrom(same); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_31), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_33), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_34), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; + s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]]); } else if (_10 === 1) { - const _46: rt.u16[] = rt.arrayMap(Uint8Array.of(), (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + const _46: rs.u16[] = rs.arrayMap(Uint8Array.of(), (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }); - const _47: Uint8Array = rt.bytesMap([], (w2: rt.u16): rt.u8 => { + const _47: Uint8Array = rs.bytesMap([], (w2: rs.u16): rs.u8 => { return w2 & 0xff; }); - const _48: string[] = rt.arrayMap([], (n: rt.u32): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u32Display(n, f)); + const _48: string[] = rs.arrayMap([], (n: rs.u32): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(n, f)); }); - const _53: rt.ByteSlice = rt.byteSliceFrom(_47); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(_46, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_53), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_48, f, rt.fmtStr)]; - s = rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); + const _53: rs.ByteSlice = rs.byteSliceFrom(_47); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(_46, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_53), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_48, f, rs.fmtStr)]; + s = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); } else if (_10 === 2) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(op, f)]; - const captured = rt.fmtFormat(["w", args6[0]]); - const words2: string[] = rt.arrayMap(Uint8Array.of(1, 2, 3), (i: rt.u8): string => { - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, captured), (f: rt.Formatter) => rt.u8Display(i, f)]; - return rt.fmtFormat([args16[0], args16[1]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(op, f)]; + const captured = rs.fmtFormat(["w", args6[0]]); + const words2: string[] = rs.arrayMap(Uint8Array.of(1, 2, 3), (i: rs.u8): string => { + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, captured), (f: rs.Formatter) => rs.u8Display(i, f)]; + return rs.fmtFormat([args16[0], args16[1]]); }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(words2, f, rt.fmtStr)]; - const shown: string = rt.fmtFormat([args8[0]]); - const _89: rt.ByteSlice = rt.byteSliceFrom(rt.bytesMap(words2, (w: string): rt.u8 => { - return rt.u8Add(rt.stringLen(w) & 0xff, rt.u8Rem(op, 3)); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(words2, f, rs.fmtStr)]; + const shown: string = rs.fmtFormat([args8[0]]); + const _89: rs.ByteSlice = rs.byteSliceFrom(rs.bytesMap(words2, (w: string): rs.u8 => { + return rs.u8Add(rs.stringLen(w) & 0xff, rs.u8Rem(op, 3)); })); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, shown), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_89), f, rt.u8Debug)]; - s = rt.fmtFormat([args10[0], " ", args10[1]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, shown), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_89), f, rs.u8Debug)]; + s = rs.fmtFormat([args10[0], " ", args10[1]]); } else if (_10 === 3) { - const options: Array = [op, undefined, rt.u8WrappingAdd(op, 60)]; - const nested: Array = rt.arrayMap(options, (o: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return option_map$0rbsrz6(o, (b: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedAdd(b, 200); + const options: Array = [op, undefined, rs.u8WrappingAdd(op, 60)]; + const nested: Array = rs.arrayMap(options, (o: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return option_map$1yv0md6(o, (b: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedAdd(b, 200); }); }); - const flat: Array = rt.arrayMap(nested, (o2: rt.u8 | undefined | rt.None): rt.u8 | undefined => { - if (o2 === rt.None) { + const flat: Array = rs.arrayMap(nested, (o2: rs.u8 | undefined | rs.None): rs.u8 | undefined => { + if (o2 === rs.None) { return 0; } return o2; }); - const units: Array = rt.arrayMap(nested, (o3: rt.u8 | undefined | rt.None): undefined | rt.None => { - return option_map$1j8xzu6(o3, (_2: rt.u8 | undefined): undefined => {}); + const units: Array = rs.arrayMap(nested, (o3: rs.u8 | undefined | rs.None): undefined | rs.None => { + return option_map$1tggsfb(o3, (_2: rs.u8 | undefined): undefined => {}); }); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(options, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(nested, f, (value: rt.u8 | undefined | rt.None, f: rt.Formatter) => rt.fmtOption(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)), (f: rt.Formatter) => rt.fmtList(flat, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(units, f, (value: undefined | rt.None, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtUnit, rt.None))]; - s = rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3]]); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(options, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(nested, f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)), (f: rs.Formatter) => rs.fmtList(flat, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(units, f, (value: undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None))]; + s = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3]]); } else { const grid: Uint8Array[] = [Uint8Array.of(op, 1), Uint8Array.of(2, 3), Uint8Array.of(4, op)]; - const flipped: Uint8Array[] = rt.arrayMap(grid, (row: Uint8Array): Uint8Array => { + const flipped: Uint8Array[] = rs.arrayMap(grid, (row: Uint8Array): Uint8Array => { row = copy$array_u8(row); row[0] = row[0] ^ 255; - rt.byteSliceView(rt.byteSliceFrom(row)).reverse(); + rs.byteSliceView(rs.byteSliceFrom(row)).reverse(); return copy$array_u8(row); }); - const sums: rt.u16[] = rt.arrayMap(flipped, (row2: Uint8Array): rt.u16 => { - return rt.u16Add(row2[0] as rt.u16, row2[1] as rt.u16); + const sums: rs.u16[] = rs.arrayMap(flipped, (row2: Uint8Array): rs.u16 => { + return rs.u16Add(row2[0] as rs.u16, row2[1] as rs.u16); }); - const same2: Uint8Array[] = copy$array_array2_u8(rt.arrayMap(grid, (row3: Uint8Array): Uint8Array => { + const same2: Uint8Array[] = copy$array_array2_u8(rs.arrayMap(grid, (row3: Uint8Array): Uint8Array => { return row3; })); - const _124: rt.usize = rt.usizeRem(op as rt.usize, 3); + const _124: rs.usize = rs.usizeRem(op as rs.usize, 3); if (!(_124 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _124); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _124); } same2[_124][0] = same2[_124][0] ^ 128; - const _134: rt.u64[] = shifted$3(op); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(grid, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(flipped, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(sums, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(same2, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(_134, f, rt.u64Debug)]; - s = rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4]]); + const _134: rs.u64[] = shifted$3(op); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(flipped, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(sums, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(same2, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(_134, f, rs.u64Debug)]; + s = rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4]]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 10); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 10); } } /** An array as long as `N` says, mapped by a function. */ -export function shifted$3(op: rt.u8): rt.u64[] { - return rt.arrayMap(rt.bytes(3).fill(op), (a0: rt.u8): rt.u64 => { - return a0 as rt.u64; +export function shifted$3(op: rs.u8): rs.u64[] { + return rs.arrayMap(rs.bytes(3).fill(op), (a0: rs.u8): rs.u64 => { + return a0 as rs.u64; }); } @@ -216,222 +216,222 @@ export function shifted$3(op: rt.u8): rt.u64[] { * the operand: bytes, wide integers, and strings, each lent as its place, arrays of bytes * as their views, and other arrays as themselves. Writes through each land in the array. */ -export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { - const bytes: Uint8Array = rt.bytes(3); - const wide: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { +export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { + const bytes: Uint8Array = rs.bytes(3); + const wide: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return 0; }); const words: string[] = ["", ""]; - const item = copy$array_u8(rt.bytes(2)); + const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const item2 = copy$array_u32(Array.from({ length: 2 }, (): rt.u32 => { + const item2 = copy$array_u32(Array.from({ length: 2 }, (): rs.u32 => { return 0; })); - const pairs: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const pairs: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item2); }); - for (const op of rt.byteSliceView(data)) { - const i: rt.usize = op as rt.usize; - const _21: rt.u8 = rt.u8Rem(op, 6); + for (const op of rs.byteSliceView(data)) { + const i: rs.usize = op as rs.usize; + const _21: rs.u8 = rs.u8Rem(op, 6); if (_21 === 0) { - const _23: rt.Place[] = rt.arrayPlaces(rt.byteSliceView(rt.byteSliceFrom(bytes))); - const _25: rt.usize = rt.usizeRem(i, 3); + const _23: rs.Place[] = rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(bytes))); + const _25: rs.usize = rs.usizeRem(i, 3); if (!(_25 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _25); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _25); } _23[_25].v = _23[_25].v ^ op; - const iter2: rt.Iter> = rt.iterSlice(rt.arrayPlaces(rt.byteSliceView(rt.byteSliceFrom(bytes)))); + const iter2: rs.Iter> = rs.iterSlice(rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(bytes)))); while (true) { - const _32: rt.Place | rt.Done = iter2.next(); - if (_32 === rt.DONE) { + const _32: rs.Place | rs.Done = iter2.next(); + if (_32 === rs.DONE) { break; } - _32.v = rt.u8WrappingAdd(_32.v, 1); + _32.v = rs.u8WrappingAdd(_32.v, 1); } } else if (_21 === 1) { - const _40: rt.Place[] = rt.arrayPlaces(wide); - _40[0].v = rt.u16WrappingAdd(_40[0].v, ((op as rt.u16) << 7) & 0xffff); + const _40: rs.Place[] = rs.arrayPlaces(wide); + _40[0].v = rs.u16WrappingAdd(_40[0].v, ((op as rs.u16) << 7) & 0xffff); const swapped = _40[0].v; _40[0].v = _40[1].v; _40[1].v = swapped; } else if (_21 === 2) { - const _49: rt.Place[] = rt.arrayPlaces(words); - const _51: rt.usize = rt.usizeRem(i, 2); + const _49: rs.Place[] = rs.arrayPlaces(words); + const _51: rs.usize = rs.usizeRem(i, 2); if (!(_51 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _51); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _51); } - _49[_51].v = _49[_51].v + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(op, 26)) as rt.char); + _49[_51].v = _49[_51].v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_21 === 3) { - const rows: rt.ByteSlice[] = rt.arrayMap(grid, rt.byteSliceFrom); - const _61: rt.usize = rt.usizeRem(i, 2); + const rows: rs.ByteSlice[] = rs.arrayMap(grid, rs.byteSliceFrom); + const _61: rs.usize = rs.usizeRem(i, 2); if (!(_61 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _61); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _61); } - const _64: rt.usize = rt.usizeRem(rt.usizeRem(i, 3), 2); + const _64: rs.usize = rs.usizeRem(rs.usizeRem(i, 3), 2); if (!(_64 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _64); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _64); } const slice = rows[_61]; slice.data[slice.start + _64] = op; - const _71: rt.usize = rt.usizeRem(rt.usizeAdd(i, 1), 2); + const _71: rs.usize = rs.usizeRem(rs.usizeAdd(i, 1), 2); if (!(_71 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _71); } - rt.byteSliceView(rows[_71]).reverse(); - const _78: rt.u32[][] = rt.arrayFrom(pairs); - const _80: rt.u32 = op as rt.u32; - const _83: rt.usize = rt.usizeRem(i, 2); + rs.byteSliceView(rows[_71]).reverse(); + const _78: rs.u32[][] = rs.arrayFrom(pairs); + const _80: rs.u32 = op as rs.u32; + const _83: rs.usize = rs.usizeRem(i, 2); if (!(_83 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _83); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _83); } _78[0][_83] = (_80 << 20) >>> 0; - rt.sliceCopyFromSlice(_78[1], [_78[0][1], op as rt.u32]); + rs.sliceCopyFromSlice(_78[1], [_78[0][1], op as rs.u32]); } else if (_21 === 4) { - rt.arrayPlaces(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))); - const iter3: rt.Iter> = rt.iterSlice([]); + rs.arrayPlaces(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))); + const iter3: rs.Iter> = rs.iterSlice([]); while (true) { - const _99: rt.Place | rt.Done = iter3.next(); - if (_99 === rt.DONE) { + const _99: rs.Place | rs.Done = iter3.next(); + if (_99 === rs.DONE) { break; } _99.v = op; } - const lens: Uint8Array = rt.bytesMap(rt.arrayFrom(words), (w: string): rt.u8 => { - return rt.stringLen(w) & 0xff; + const lens: Uint8Array = rs.bytesMap(rs.arrayFrom(words), (w: string): rs.u8 => { + return rs.stringLen(w) & 0xff; }); - const rows2: Uint8Array = rt.bytesMap(rt.arrayMap(grid, rt.byteSliceFrom), (row: rt.ByteSlice): rt.u8 => { + const rows2: Uint8Array = rs.bytesMap(rs.arrayMap(grid, rs.byteSliceFrom), (row: rs.ByteSlice): rs.u8 => { return row.data[row.start] ^ row.data[row.start + 1]; }); - const sums: rt.u32[] = rt.arrayMap(rt.arrayFrom(pairs), (pair: rt.u32[]): rt.u32 => { - return rt.u32WrappingAdd(pair[0], pair[1]); + const sums: rs.u32[] = rs.arrayMap(rs.arrayFrom(pairs), (pair: rs.u32[]): rs.u32 => { + return rs.u32WrappingAdd(pair[0], pair[1]); }); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(lens)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rows2)); - const _123: rt.usize = rt.usizeRem(i, 2); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(lens)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rows2)); + const _123: rs.usize = rs.usizeRem(i, 2); if (!(_123 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _123); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _123); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sums[_123]).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(sums[_123]).reverse())); } else { - const read: rt.u8[] = rt.arrayFrom(rt.byteSliceView(rt.byteSliceFrom(bytes))); - const wides: rt.u16[] = rt.arrayFrom(wide); - const _135: rt.u8[] = rt.arrayFrom(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(read, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(wides, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(_135, f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + const read: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(bytes))); + const wides: rs.u16[] = rs.arrayFrom(wide); + const _135: rs.u8[] = rs.arrayFrom(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wides, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(_135, f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); } } - [rt.byteSliceFrom(bytes), wide, words, grid, pairs] as [rt.ByteSlice, rt.u16[], string[], Uint8Array[], rt.u32[][]]; - const arg = rt.byteSliceFrom(bytes); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(wide, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(words, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(grid, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(pairs, f, (value: rt.u32[], f: rt.Formatter) => rt.fmtList(value, f, rt.u32Debug))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]))); + [rs.byteSliceFrom(bytes), wide, words, grid, pairs] as [rs.ByteSlice, rs.u16[], string[], Uint8Array[], rs.u32[][]]; + const arg = rs.byteSliceFrom(bytes); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(wide, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(grid, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(pairs, f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]]))); } /** * Arrays as slices, of bytes and of other values, empty ones included; each byte an * operation, its value the operand. Writes through `as_mut_slice` land in the array. */ -export function asSlices(data: rt.ByteSlice, out: rt.ByteVec): void { - const bytes: Uint8Array = rt.bytes(4); - const wide: rt.u16[] = Array.from({ length: 3 }, (): rt.u16 => { +export function asSlices(data: rs.ByteSlice, out: rs.ByteVec): void { + const bytes: Uint8Array = rs.bytes(4); + const wide: rs.u16[] = Array.from({ length: 3 }, (): rs.u16 => { return 0; }); const words: string[] = ["", ""]; - const item = copy$array_u8(rt.bytes(2)); + const item = copy$array_u8(rs.bytes(2)); const grid: Uint8Array[] = Array.from({ length: 3 }, (): Uint8Array => { return copy$array_u8(item); }); - const item2 = copy$array_u32(Array.from({ length: 2 }, (): rt.u32 => { + const item2 = copy$array_u32(Array.from({ length: 2 }, (): rs.u32 => { return 0; })); - const pairs: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const pairs: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item2); }); - for (const op of rt.byteSliceView(data)) { - const i: rt.usize = op as rt.usize; - const _22: rt.u8 = rt.u8Rem(op, 8); + for (const op of rs.byteSliceView(data)) { + const i: rs.usize = op as rs.usize; + const _22: rs.u8 = rs.u8Rem(op, 8); if (_22 === 0) { - const s: rt.ByteSlice = rt.byteSliceFrom(bytes); - const _26: rt.usize = rt.usizeRem(i, 4); - rt.idx(s, _26); + const s: rs.ByteSlice = rs.byteSliceFrom(bytes); + const _26: rs.usize = rs.usizeRem(i, 4); + rs.idx(s, _26); s.data[s.start + _26] = op; - rt.byteSliceRotateLeft(s, 1); + rs.byteSliceRotateLeft(s, 1); } else if (_22 === 1) { - const _32: rt.u16 = op as rt.u16; - const _35: rt.u16[] = wide; - const _37: rt.usize = rt.usizeRem(i, 3); - rt.idx(_35, _37); + const _32: rs.u16 = op as rs.u16; + const _35: rs.u16[] = wide; + const _37: rs.usize = rs.usizeRem(i, 3); + rs.idx(_35, _37); _35[_37] = (_32 << 7) & 0xffff; - rt.sliceRotateRight(wide, 1); + rs.sliceRotateRight(wide, 1); } else if (_22 === 2) { const _46: string[] = words; - const _48: rt.usize = rt.usizeRem(i, 2); - rt.idx(_46, _48); - _46[_48] = _46[_48] + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(op, 26)) as rt.char); + const _48: rs.usize = rs.usizeRem(i, 2); + rs.idx(_46, _48); + _46[_48] = _46[_48] + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); } else if (_22 === 3) { const _59: Uint8Array[] = grid; - const _61: rt.usize = rt.usizeRem(i, 3); - rt.idx(_59, _61); - const row: rt.ByteSlice = rt.byteSliceFrom(_59[_61]); - const _66: rt.ByteSlice = row; - const _67: rt.usize = rt.usizeRem(i, 2); - rt.idx(_66, _67); + const _61: rs.usize = rs.usizeRem(i, 3); + rs.idx(_59, _61); + const row: rs.ByteSlice = rs.byteSliceFrom(_59[_61]); + const _66: rs.ByteSlice = row; + const _67: rs.usize = rs.usizeRem(i, 2); + rs.idx(_66, _67); _66.data[_66.start + _67] = op; - const _73: rt.ByteSlice = row; - const _75: rt.usize = rt.usizeRem(rt.usizeAdd(i, 1), 2); - rt.idx(_73, _75); - const read: rt.u8 = _73.data[_73.start + _75]; - const _81: rt.usize = rt.usizeRem(rt.usizeAdd(i, 1), 3); + const _73: rs.ByteSlice = row; + const _75: rs.usize = rs.usizeRem(rs.usizeAdd(i, 1), 2); + rs.idx(_73, _75); + const read: rs.u8 = _73.data[_73.start + _75]; + const _81: rs.usize = rs.usizeRem(rs.usizeAdd(i, 1), 3); if (!(_81 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _81); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _81); } grid[_81][0] = grid[_81][0] ^ read; } else if (_22 === 4) { - const all: rt.u32[][] = pairs; - const _93: rt.usize = rt.usizeRem(i, 2); - rt.idx(all, _93); - rt.sliceCopyFromSlice(all[_93], [op as rt.u32, ((op as rt.u32) << 20) >>> 0]); - rt.sliceSwap(all, 0, 1); + const all: rs.u32[][] = pairs; + const _93: rs.usize = rs.usizeRem(i, 2); + rs.idx(all, _93); + rs.sliceCopyFromSlice(all[_93], [op as rs.u32, ((op as rs.u32) << 20) >>> 0]); + rs.sliceSwap(all, 0, 1); } else if (_22 === 5) { - const _108: rt.u16[] = []; + const _108: rs.u16[] = []; _108.reverse(); - rt.byteSliceFill(rt.byteSliceFrom(Uint8Array.of()), op); - const _117: rt.u16[] = []; - rt.byteVecPush(out, rt.u8Add(_117.length & 0xff, rt.byteSliceFrom(Uint8Array.of()).length & 0xff)); + rs.byteSliceFill(rs.byteSliceFrom(Uint8Array.of()), op); + const _117: rs.u16[] = []; + rs.byteVecPush(out, rs.u8Add(_117.length & 0xff, rs.byteSliceFrom(Uint8Array.of()).length & 0xff)); } else if (_22 === 6) { - written(rt.byteSliceFrom(bytes), wide, op); + written(rs.byteSliceFrom(bytes), wide, op); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(wide), (_2: rt.u16): rt.u32 => { - return _2 as rt.u32; - }), rt.u32Add, 0)).reverse())); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterSlice(wide), (_2: rs.u16): rs.u32 => { + return _2 as rs.u32; + }), rs.u32Add, 0)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); } } - const _143: rt.ByteSlice = rt.byteSliceFrom(bytes); - const _146: rt.u16[] = wide; + const _143: rs.ByteSlice = rs.byteSliceFrom(bytes); + const _146: rs.u16[] = wide; const _149: string[] = words; const _152: Uint8Array[] = grid; - const _155: rt.u32[][] = pairs; - const _158: rt.u16[] = []; - const _161: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of()); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_143), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_146, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(_149, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(_152, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtList(_155, f, (value: rt.u32[], f: rt.Formatter) => rt.fmtList(value, f, rt.u32Debug)), (f: rt.Formatter) => rt.fmtList(_158, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_161), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6]]))); + const _155: rs.u32[][] = pairs; + const _158: rs.u16[] = []; + const _161: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_143), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_146, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(_149, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_152, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtList(_155, f, (value: rs.u32[], f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)), (f: rs.Formatter) => rs.fmtList(_158, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_161), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6]]))); } /** Arrays lent by `&mut`, written through their slices. */ -export function written(bytes: rt.ByteSlice, wide: rt.u16[], op: rt.u8): void { - const s: rt.ByteSlice = bytes; - rt.idx(s, 0); - const _5: rt.u8 = rt.u8WrappingAdd(s.data[s.start], op); - rt.idx(s, 3); +export function written(bytes: rs.ByteSlice, wide: rs.u16[], op: rs.u8): void { + const s: rs.ByteSlice = bytes; + rs.idx(s, 0); + const _5: rs.u8 = rs.u8WrappingAdd(s.data[s.start], op); + rs.idx(s, 3); s.data[s.start + 3] = _5; - const w: rt.u16[] = wide; - const _16: rt.u16 = op as rt.u16; - rt.idx(w, 0); + const w: rs.u16[] = wide; + const _16: rs.u16 = op as rs.u16; + rs.idx(w, 0); w[0] = _16; - rt.sliceSwap(w, 1, 2); - rt.sliceRangeMut(w, 1).fill(rt.u16Add(op as rt.u16, 1)); + rs.sliceSwap(w, 1, 2); + rs.sliceRangeMut(w, 1).fill(rs.u16Add(op as rs.u16, 1)); } /** @@ -441,8 +441,8 @@ export function written(bytes: rt.ByteSlice, wide: rt.u16[], op: rt.u8): void { * fields, and parts of a longer slice. Writes through each land in the array, and a copy shares nothing with * it. Of no bytes, one, three, and many. */ -export function given(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 4); +export function given(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 4); if (_4 === 0) { givenN$0(data, out); taken$0(data, out); @@ -460,608 +460,608 @@ export function given(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$0(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$0(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(0, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$1(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$1(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(1, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$3(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$3(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(3, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$32(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(32, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$32(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(32, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$40(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(40, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$40(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(40, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$5(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(5, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$5(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(5, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** Each array's bytes, in order. */ -export function put$0(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$0(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** Each array's bytes, in order. */ -export function put$1(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$1(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** Each array's bytes, in order. */ -export function put$3(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$3(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** Each array's bytes, in order. */ -export function put$32(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$32(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** Each array's bytes, in order. */ -export function put$40(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$40(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** Each array's bytes, in order. */ -export function put$5(out: rt.ByteVec, arrays: Uint8Array[]): void { - const iter: rt.Iter = rt.iterLend(rt.iterSlice(arrays), rt.byteSliceFrom); +export function put$5(out: rs.ByteVec, arrays: Uint8Array[]): void { + const iter: rs.Iter = rs.iterLend(rs.iterSlice(arrays), rs.byteSliceFrom); while (true) { - const _5: rt.ByteSlice | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.ByteSlice | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _5); + rs.byteVecExtendFromSlice(out, _5); } } /** The bytes of a `Some`, or 0xff for a `None`. */ -export function putSome$0(out: rt.ByteVec, a: Uint8Array | undefined): void { +export function putSome$0(out: rs.ByteVec, a: Uint8Array | undefined): void { if (a === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); } } /** The bytes of a `Some`, or 0xff for a `None`. */ -export function putSome$1(out: rt.ByteVec, a: Uint8Array | undefined): void { +export function putSome$1(out: rs.ByteVec, a: Uint8Array | undefined): void { if (a === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); } } /** The bytes of a `Some`, or 0xff for a `None`. */ -export function putSome$3(out: rt.ByteVec, a: Uint8Array | undefined): void { +export function putSome$3(out: rs.ByteVec, a: Uint8Array | undefined): void { if (a === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); } } /** The bytes of a `Some`, or 0xff for a `None`. */ -export function putSome$40(out: rt.ByteVec, a: Uint8Array | undefined): void { +export function putSome$40(out: rs.ByteVec, a: Uint8Array | undefined): void { if (a === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); } } /** The bytes of a `Some`, or 0xff for a `None`. */ -export function putSome$5(out: rt.ByteVec, a: Uint8Array | undefined): void { +export function putSome$5(out: rs.ByteVec, a: Uint8Array | undefined): void { if (a === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); } } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$0(data: rt.ByteSlice, out: rt.ByteVec): void { +export function givenN$0(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); const b: Uint8Array = copy$array_u8(bytesAt$0(data, 0)); - const copied: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); - const cloned: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); - const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const copied: Uint8Array | undefined = copy$Option_array0_u8(rs.optionMap(rs.byteSliceFrom(a), rs.byteSliceView)); + const cloned: Uint8Array | undefined = copy$Option_array0_u8(rs.optionMap(rs.byteSliceFrom(b), rs.byteSliceView)); + const _11: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_11 !== undefined) { _11.v = _11.v ^ 1; } - const _16: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(b))); + const _16: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(b))); if (_16 !== undefined) { _16.v = _16.v ^ 2; } put$0(out, [copy$array_u8(a), copy$array_u8(b)]); putSome$0(out, copied); putSome$0(out, cloned); - rt.byteSliceFrom(a); - rt.byteSliceFrom(b); - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + rs.byteSliceFrom(a); + rs.byteSliceFrom(b); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_32 !== undefined) { - _32.v = rt.u8WrappingAdd(_32.v, 1); + _32.v = rs.u8WrappingAdd(_32.v, 1); } put$0(out, [copy$array_u8(a), copy$array_u8(b)]); - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$0(data, rt.usizeMul(k, 2)); + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { + return bytesAt$0(data, rs.usizeMul(k, 2)); }), undefined, 0, true); - rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - rt.byteSliceFrom(a); - rt.byteSliceFrom(v.items[rt.idx(v.items, 2)]); + rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + rs.byteSliceFrom(a); + rs.byteSliceFrom(v.items[rs.idx(v.items, 2)]); const old: Uint8Array = copy$array_u8(b); - rt.byteSliceFill(rt.byteSliceFrom(b), 187); + rs.byteSliceFill(rs.byteSliceFrom(b), 187); put$0(out, [old, copy$array_u8(a), copy$array_u8(b)]); put$0(out, v.items); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(a)), rt.eqBytes), rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(b)), rt.eqBytes), rt.sliceContains(rt.sliceRange(v.items, 0, 1), rt.byteSliceView(rt.byteSliceFrom(old)), rt.eqBytes)], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(v.items, 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(v.items, 1); - rt.idx(_87[0], 0); - rt.byteSliceFrom(_87[0][0]); - rt.idx(_87[1], 1); - rt.byteSliceFrom(_87[1][1]); + const _87: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(v.items, 1); + rs.idx(_87[0], 0); + rs.byteSliceFrom(_87[0][0]); + rs.idx(_87[1], 1); + rs.byteSliceFrom(_87[1][1]); put$0(out, v.items); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.usizeAdd(2 * 0, 1)), (i: rt.usize): rt.u8 => { - return option_mapOr$1surhce(rt.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rt.u8): rt.u8 => { + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 0, 1)), (i: rs.usize): rs.u8 => { + return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rt.byteVecPush(out, rt.sliceContains(v.items, rt.byteSliceView(rt.optionUnwrap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0))), rt.eqBytes) ? 1 : 0); - const part: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceGetRange(rt.byteSliceRange(rt.byteVecSlice(buf), 1), 0, 0), rt.byteSliceView)); - const _126: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(buf), 0); + rs.byteVecPush(out, rs.sliceContains(v.items, rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0))), rs.eqBytes) ? 1 : 0); + const part: Uint8Array | undefined = copy$Option_array0_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 0), rs.byteSliceView)); + const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 0); if (_126 !== undefined) { - rt.byteSliceLastChunk(_126[1], 0); + rs.byteSliceLastChunk(_126[1], 0); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const _144: rt.ByteSlice = rt.byteSliceFrom(a); - const old2: Uint8Array | undefined = option_map$1jcn6wm(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0), (_t: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(_144); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const _144: rs.ByteSlice = rs.byteSliceFrom(a); + const old2: Uint8Array | undefined = option_map$10o993m(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0), (_t: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(_144); }); - const cloned2: Uint8Array | undefined = copy$Option_array0_u8(rt.optionMap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0), rt.byteSliceView)); - const _149: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(buf))); + const cloned2: Uint8Array | undefined = copy$Option_array0_u8(rs.optionMap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0), rs.byteSliceView)); + const _149: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(buf))); if (_149 !== undefined) { _149.v = _149.v ^ 64; } putSome$0(out, part); putSome$0(out, old2); putSome$0(out, cloned2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(a))]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(a))]; + rs.byteVecPush(out, one.length & 0xff); put$0(out, one); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)])))); - const _173: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); + const _173: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))))); if (_173 !== undefined) { _173.v = 238; } put$0(out, [copy$array_u8(b)]); - const _190: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - const _192: rt.ByteSlice = rt.byteSliceFrom(a); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_192), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_190, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d2: rt.u8): boolean => { - return rt.u8Rem(d2, 3) === 0; + const _190: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + const _192: rs.ByteSlice = rs.byteSliceFrom(a); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_190, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { + return rs.u8Rem(d2, 3) === 0; })) { - [rt.byteSliceFrom(a), rt.byteSliceFrom(b)] as [rt.ByteSlice, rt.ByteSlice]; - if (!rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) { + [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; + if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; const kind: string = "=="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - const _208: rt.Arguments | undefined = ["after ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(b)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _208); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; + const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); + const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); + rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); } } } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$1(data: rt.ByteSlice, out: rt.ByteVec): void { +export function givenN$1(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$1(data, 0)); const b: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); - const copied: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); - const cloned: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); - const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const copied: Uint8Array | undefined = copy$Option_array1_u8(rs.optionMap(rs.byteSliceFrom(a), rs.byteSliceView)); + const cloned: Uint8Array | undefined = copy$Option_array1_u8(rs.optionMap(rs.byteSliceFrom(b), rs.byteSliceView)); + const _11: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_11 !== undefined) { _11.v = _11.v ^ 1; } - const _16: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(b))); + const _16: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(b))); if (_16 !== undefined) { _16.v = _16.v ^ 2; } put$1(out, [copy$array_u8(a), copy$array_u8(b)]); putSome$1(out, copied); putSome$1(out, cloned); - const _30: rt.ByteSlice = rt.byteSliceFrom(a); - const _31: rt.ByteSlice = rt.byteSliceFrom(b); - const swapped = rt.byteSliceToArray(_30); - _30.data.set(rt.byteSliceToArray(_31), _30.start); + const _30: rs.ByteSlice = rs.byteSliceFrom(a); + const _31: rs.ByteSlice = rs.byteSliceFrom(b); + const swapped = rs.byteSliceToArray(_30); + _30.data.set(rs.byteSliceToArray(_31), _30.start); _31.data.set(swapped, _31.start); - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_32 !== undefined) { - _32.v = rt.u8WrappingAdd(_32.v, 1); + _32.v = rs.u8WrappingAdd(_32.v, 1); } put$1(out, [copy$array_u8(a), copy$array_u8(b)]); - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$1(data, rt.usizeMul(k, 2)); + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { + return bytesAt$1(data, rs.usizeMul(k, 2)); }), undefined, 1, true); - const _50: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - const _52: rt.ByteSlice = rt.byteSliceFrom(a); - const swapped2 = rt.byteSliceToArray(_50); - _50.data.set(rt.byteSliceToArray(_52), _50.start); + const _50: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + const _52: rs.ByteSlice = rs.byteSliceFrom(a); + const swapped2 = rs.byteSliceToArray(_50); + _50.data.set(rs.byteSliceToArray(_52), _50.start); _52.data.set(swapped2, _52.start); - const _54: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 2)]); + const _54: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 2)]); const _56: Uint8Array = copy$array_u8(b); - const old3 = rt.byteSliceToArray(_54); + const old3 = rs.byteSliceToArray(_54); _54.data.set(_56, _54.start); const old: Uint8Array = old3; - rt.byteSliceFill(rt.byteSliceFrom(b), 187); + rs.byteSliceFill(rs.byteSliceFrom(b), 187); put$1(out, [old, copy$array_u8(a), copy$array_u8(b)]); put$1(out, v.items); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(a)), rt.eqBytes), rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(b)), rt.eqBytes), rt.sliceContains(rt.sliceRange(v.items, 0, 1), rt.byteSliceView(rt.byteSliceFrom(old)), rt.eqBytes)], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(v.items, 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(v.items, 1); - rt.idx(_87[0], 0); - const _91: rt.ByteSlice = rt.byteSliceFrom(_87[0][0]); - rt.idx(_87[1], 1); - const _96: rt.ByteSlice = rt.byteSliceFrom(_87[1][1]); - const swapped3 = rt.byteSliceToArray(_91); - _91.data.set(rt.byteSliceToArray(_96), _91.start); + const _87: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(v.items, 1); + rs.idx(_87[0], 0); + const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0][0]); + rs.idx(_87[1], 1); + const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1][1]); + const swapped3 = rs.byteSliceToArray(_91); + _91.data.set(rs.byteSliceToArray(_96), _91.start); _96.data.set(swapped3, _96.start); put$1(out, v.items); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.usizeAdd(2 * 1, 1)), (i: rt.usize): rt.u8 => { - return option_mapOr$1surhce(rt.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rt.u8): rt.u8 => { + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 1, 1)), (i: rs.usize): rs.u8 => { + return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rt.byteVecPush(out, rt.sliceContains(v.items, rt.byteSliceView(rt.optionUnwrap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1))), rt.eqBytes) ? 1 : 0); - const part: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceGetRange(rt.byteSliceRange(rt.byteVecSlice(buf), 1), 0, 1), rt.byteSliceView)); - const _126: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(buf), 1); + rs.byteVecPush(out, rs.sliceContains(v.items, rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1))), rs.eqBytes) ? 1 : 0); + const part: Uint8Array | undefined = copy$Option_array1_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 1), rs.byteSliceView)); + const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 1); if (_126 !== undefined) { - const _132: rt.ByteSlice | undefined = rt.byteSliceLastChunk(_126[1], 1); + const _132: rs.ByteSlice | undefined = rs.byteSliceLastChunk(_126[1], 1); if (_132 !== undefined) { - const swapped4 = rt.byteSliceToArray(_126[0]); - _126[0].data.set(rt.byteSliceToArray(_132), _126[0].start); + const swapped4 = rs.byteSliceToArray(_126[0]); + _126[0].data.set(rs.byteSliceToArray(_132), _126[0].start); _132.data.set(swapped4, _132.start); } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const _144: rt.ByteSlice = rt.byteSliceFrom(a); - const old2: Uint8Array | undefined = option_map$1jcn6wm(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1), (t: rt.ByteSlice): Uint8Array => { - const _36: Uint8Array = rt.byteSliceToArray(_144); - const old4 = rt.byteSliceToArray(t); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const _144: rs.ByteSlice = rs.byteSliceFrom(a); + const old2: Uint8Array | undefined = option_map$10o993m(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1), (t: rs.ByteSlice): Uint8Array => { + const _36: Uint8Array = rs.byteSliceToArray(_144); + const old4 = rs.byteSliceToArray(t); t.data.set(_36, t.start); return old4; }); - const cloned2: Uint8Array | undefined = copy$Option_array1_u8(rt.optionMap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1), rt.byteSliceView)); - const _149: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(buf))); + const cloned2: Uint8Array | undefined = copy$Option_array1_u8(rs.optionMap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1), rs.byteSliceView)); + const _149: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(buf))); if (_149 !== undefined) { _149.v = _149.v ^ 64; } putSome$1(out, part); putSome$1(out, old2); putSome$1(out, cloned2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(a))]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(a))]; + rs.byteVecPush(out, one.length & 0xff); put$1(out, one); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)])))); - const _173: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); + const _173: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))))); if (_173 !== undefined) { _173.v = 238; } put$1(out, [copy$array_u8(b)]); - const _190: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - const _192: rt.ByteSlice = rt.byteSliceFrom(a); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_192), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_190, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d2: rt.u8): boolean => { - return rt.u8Rem(d2, 3) === 0; + const _190: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + const _192: rs.ByteSlice = rs.byteSliceFrom(a); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_190, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { + return rs.u8Rem(d2, 3) === 0; })) { - [rt.byteSliceFrom(a), rt.byteSliceFrom(b)] as [rt.ByteSlice, rt.ByteSlice]; - if (!rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) { + [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; + if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; const kind: string = "=="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - const _208: rt.Arguments | undefined = ["after ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(b)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _208); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; + const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); + const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); + rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); } } } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$3(data: rt.ByteSlice, out: rt.ByteVec): void { +export function givenN$3(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$3(data, 0)); const b: Uint8Array = copy$array_u8(bytesAt$3(data, 3)); - const copied: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); - const cloned: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); - const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const copied: Uint8Array | undefined = copy$Option_array3_u8(rs.optionMap(rs.byteSliceFrom(a), rs.byteSliceView)); + const cloned: Uint8Array | undefined = copy$Option_array3_u8(rs.optionMap(rs.byteSliceFrom(b), rs.byteSliceView)); + const _11: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_11 !== undefined) { _11.v = _11.v ^ 1; } - const _16: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(b))); + const _16: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(b))); if (_16 !== undefined) { _16.v = _16.v ^ 2; } put$3(out, [copy$array_u8(a), copy$array_u8(b)]); putSome$3(out, copied); putSome$3(out, cloned); - const _30: rt.ByteSlice = rt.byteSliceFrom(a); - const _31: rt.ByteSlice = rt.byteSliceFrom(b); - const swapped = rt.byteSliceToArray(_30); - _30.data.set(rt.byteSliceToArray(_31), _30.start); + const _30: rs.ByteSlice = rs.byteSliceFrom(a); + const _31: rs.ByteSlice = rs.byteSliceFrom(b); + const swapped = rs.byteSliceToArray(_30); + _30.data.set(rs.byteSliceToArray(_31), _30.start); _31.data.set(swapped, _31.start); - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_32 !== undefined) { - _32.v = rt.u8WrappingAdd(_32.v, 1); + _32.v = rs.u8WrappingAdd(_32.v, 1); } put$3(out, [copy$array_u8(a), copy$array_u8(b)]); - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$3(data, rt.usizeMul(k, 2)); + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { + return bytesAt$3(data, rs.usizeMul(k, 2)); }), undefined, 3, true); - const _50: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - const _52: rt.ByteSlice = rt.byteSliceFrom(a); - const swapped2 = rt.byteSliceToArray(_50); - _50.data.set(rt.byteSliceToArray(_52), _50.start); + const _50: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + const _52: rs.ByteSlice = rs.byteSliceFrom(a); + const swapped2 = rs.byteSliceToArray(_50); + _50.data.set(rs.byteSliceToArray(_52), _50.start); _52.data.set(swapped2, _52.start); - const _54: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 2)]); + const _54: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 2)]); const _56: Uint8Array = copy$array_u8(b); - const old3 = rt.byteSliceToArray(_54); + const old3 = rs.byteSliceToArray(_54); _54.data.set(_56, _54.start); const old: Uint8Array = old3; - rt.byteSliceFill(rt.byteSliceFrom(b), 187); + rs.byteSliceFill(rs.byteSliceFrom(b), 187); put$3(out, [old, copy$array_u8(a), copy$array_u8(b)]); put$3(out, v.items); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(a)), rt.eqBytes), rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(b)), rt.eqBytes), rt.sliceContains(rt.sliceRange(v.items, 0, 1), rt.byteSliceView(rt.byteSliceFrom(old)), rt.eqBytes)], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(v.items, 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(v.items, 1); - rt.idx(_87[0], 0); - const _91: rt.ByteSlice = rt.byteSliceFrom(_87[0][0]); - rt.idx(_87[1], 1); - const _96: rt.ByteSlice = rt.byteSliceFrom(_87[1][1]); - const swapped3 = rt.byteSliceToArray(_91); - _91.data.set(rt.byteSliceToArray(_96), _91.start); + const _87: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(v.items, 1); + rs.idx(_87[0], 0); + const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0][0]); + rs.idx(_87[1], 1); + const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1][1]); + const swapped3 = rs.byteSliceToArray(_91); + _91.data.set(rs.byteSliceToArray(_96), _91.start); _96.data.set(swapped3, _96.start); put$3(out, v.items); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.usizeAdd(2 * 3, 1)), (i: rt.usize): rt.u8 => { - return option_mapOr$1surhce(rt.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rt.u8): rt.u8 => { + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 3, 1)), (i: rs.usize): rs.u8 => { + return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rt.byteVecPush(out, rt.sliceContains(v.items, rt.byteSliceView(rt.optionUnwrap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3))), rt.eqBytes) ? 1 : 0); - const part: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceGetRange(rt.byteSliceRange(rt.byteVecSlice(buf), 1), 0, 3), rt.byteSliceView)); - const _126: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(buf), 3); + rs.byteVecPush(out, rs.sliceContains(v.items, rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3))), rs.eqBytes) ? 1 : 0); + const part: Uint8Array | undefined = copy$Option_array3_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 3), rs.byteSliceView)); + const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 3); if (_126 !== undefined) { - const _132: rt.ByteSlice | undefined = rt.byteSliceLastChunk(_126[1], 3); + const _132: rs.ByteSlice | undefined = rs.byteSliceLastChunk(_126[1], 3); if (_132 !== undefined) { - const swapped4 = rt.byteSliceToArray(_126[0]); - _126[0].data.set(rt.byteSliceToArray(_132), _126[0].start); + const swapped4 = rs.byteSliceToArray(_126[0]); + _126[0].data.set(rs.byteSliceToArray(_132), _126[0].start); _132.data.set(swapped4, _132.start); } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const _144: rt.ByteSlice = rt.byteSliceFrom(a); - const old2: Uint8Array | undefined = option_map$1jcn6wm(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3), (t: rt.ByteSlice): Uint8Array => { - const _36: Uint8Array = rt.byteSliceToArray(_144); - const old4 = rt.byteSliceToArray(t); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const _144: rs.ByteSlice = rs.byteSliceFrom(a); + const old2: Uint8Array | undefined = option_map$10o993m(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3), (t: rs.ByteSlice): Uint8Array => { + const _36: Uint8Array = rs.byteSliceToArray(_144); + const old4 = rs.byteSliceToArray(t); t.data.set(_36, t.start); return old4; }); - const cloned2: Uint8Array | undefined = copy$Option_array3_u8(rt.optionMap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3), rt.byteSliceView)); - const _149: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(buf))); + const cloned2: Uint8Array | undefined = copy$Option_array3_u8(rs.optionMap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3), rs.byteSliceView)); + const _149: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(buf))); if (_149 !== undefined) { _149.v = _149.v ^ 64; } putSome$3(out, part); putSome$3(out, old2); putSome$3(out, cloned2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(a))]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(a))]; + rs.byteVecPush(out, one.length & 0xff); put$3(out, one); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)])))); - const _173: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); + const _173: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))))); if (_173 !== undefined) { _173.v = 238; } put$3(out, [copy$array_u8(b)]); - const _190: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - const _192: rt.ByteSlice = rt.byteSliceFrom(a); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_192), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_190, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d2: rt.u8): boolean => { - return rt.u8Rem(d2, 3) === 0; + const _190: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + const _192: rs.ByteSlice = rs.byteSliceFrom(a); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_190, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { + return rs.u8Rem(d2, 3) === 0; })) { - [rt.byteSliceFrom(a), rt.byteSliceFrom(b)] as [rt.ByteSlice, rt.ByteSlice]; - if (!rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) { + [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; + if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; const kind: string = "=="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - const _208: rt.Arguments | undefined = ["after ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(b)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _208); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; + const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); + const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); + rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); } } } /** [`given`] of `N` bytes, all but `mem::take`. */ -export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { +export function givenN$40(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$40(data, 0)); const b: Uint8Array = copy$array_u8(bytesAt$40(data, 40)); - const copied: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(a), rt.byteSliceView)); - const cloned: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceFrom(b), rt.byteSliceView)); - const _11: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const copied: Uint8Array | undefined = copy$Option_array40_u8(rs.optionMap(rs.byteSliceFrom(a), rs.byteSliceView)); + const cloned: Uint8Array | undefined = copy$Option_array40_u8(rs.optionMap(rs.byteSliceFrom(b), rs.byteSliceView)); + const _11: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_11 !== undefined) { _11.v = _11.v ^ 1; } - const _16: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(b))); + const _16: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(b))); if (_16 !== undefined) { _16.v = _16.v ^ 2; } put$40(out, [copy$array_u8(a), copy$array_u8(b)]); putSome$40(out, copied); putSome$40(out, cloned); - const _30: rt.ByteSlice = rt.byteSliceFrom(a); - const _31: rt.ByteSlice = rt.byteSliceFrom(b); - const swapped = rt.byteSliceToArray(_30); - _30.data.set(rt.byteSliceToArray(_31), _30.start); + const _30: rs.ByteSlice = rs.byteSliceFrom(a); + const _31: rs.ByteSlice = rs.byteSliceFrom(b); + const swapped = rs.byteSliceToArray(_30); + _30.data.set(rs.byteSliceToArray(_31), _30.start); _31.data.set(swapped, _31.start); - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_32 !== undefined) { - _32.v = rt.u8WrappingAdd(_32.v, 1); + _32.v = rs.u8WrappingAdd(_32.v, 1); } put$40(out, [copy$array_u8(a), copy$array_u8(b)]); - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (k: rt.usize): Uint8Array => { - return bytesAt$40(data, rt.usizeMul(k, 2)); + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (k: rs.usize): Uint8Array => { + return bytesAt$40(data, rs.usizeMul(k, 2)); }), undefined, 40, true); - const _50: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - const _52: rt.ByteSlice = rt.byteSliceFrom(a); - const swapped2 = rt.byteSliceToArray(_50); - _50.data.set(rt.byteSliceToArray(_52), _50.start); + const _50: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + const _52: rs.ByteSlice = rs.byteSliceFrom(a); + const swapped2 = rs.byteSliceToArray(_50); + _50.data.set(rs.byteSliceToArray(_52), _50.start); _52.data.set(swapped2, _52.start); - const _54: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 2)]); + const _54: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 2)]); const _56: Uint8Array = copy$array_u8(b); - const old3 = rt.byteSliceToArray(_54); + const old3 = rs.byteSliceToArray(_54); _54.data.set(_56, _54.start); const old: Uint8Array = old3; - rt.byteSliceFill(rt.byteSliceFrom(b), 187); + rs.byteSliceFill(rs.byteSliceFrom(b), 187); put$40(out, [old, copy$array_u8(a), copy$array_u8(b)]); put$40(out, v.items); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(a)), rt.eqBytes), rt.sliceContains(v.items, rt.byteSliceView(rt.byteSliceFrom(b)), rt.eqBytes), rt.sliceContains(rt.sliceRange(v.items, 0, 1), rt.byteSliceView(rt.byteSliceFrom(old)), rt.eqBytes)], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(a)), rs.eqBytes), rs.sliceContains(v.items, rs.byteSliceView(rs.byteSliceFrom(b)), rs.eqBytes), rs.sliceContains(rs.sliceRange(v.items, 0, 1), rs.byteSliceView(rs.byteSliceFrom(old)), rs.eqBytes)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _87: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(v.items, 1); - rt.idx(_87[0], 0); - const _91: rt.ByteSlice = rt.byteSliceFrom(_87[0][0]); - rt.idx(_87[1], 1); - const _96: rt.ByteSlice = rt.byteSliceFrom(_87[1][1]); - const swapped3 = rt.byteSliceToArray(_91); - _91.data.set(rt.byteSliceToArray(_96), _91.start); + const _87: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(v.items, 1); + rs.idx(_87[0], 0); + const _91: rs.ByteSlice = rs.byteSliceFrom(_87[0][0]); + rs.idx(_87[1], 1); + const _96: rs.ByteSlice = rs.byteSliceFrom(_87[1][1]); + const swapped3 = rs.byteSliceToArray(_91); + _91.data.set(rs.byteSliceToArray(_96), _91.start); _96.data.set(swapped3, _96.start); put$40(out, v.items); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.usizeAdd(2 * 40, 1)), (i: rt.usize): rt.u8 => { - return option_mapOr$1surhce(rt.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rt.u8): rt.u8 => { + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeAdd(2 * 40, 1)), (i: rs.usize): rs.u8 => { + return option_mapOr$0vxw5sq(rs.byteSliceGet(data, i), (i & 0xff) ^ 85, (d: rs.u8): rs.u8 => { return d ^ 128; }); }), undefined, true); - rt.byteVecPush(out, rt.sliceContains(v.items, rt.byteSliceView(rt.optionUnwrap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 40))), rt.eqBytes) ? 1 : 0); - const part: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceGetRange(rt.byteSliceRange(rt.byteVecSlice(buf), 1), 0, 40), rt.byteSliceView)); - const _126: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(buf), 40); + rs.byteVecPush(out, rs.sliceContains(v.items, rs.byteSliceView(rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40))), rs.eqBytes) ? 1 : 0); + const part: Uint8Array | undefined = copy$Option_array40_u8(rs.optionMap(rs.byteSliceGetRange(rs.byteSliceRange(rs.byteVecSlice(buf), 1), 0, 40), rs.byteSliceView)); + const _126: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(buf), 40); if (_126 !== undefined) { - const _132: rt.ByteSlice | undefined = rt.byteSliceLastChunk(_126[1], 40); + const _132: rs.ByteSlice | undefined = rs.byteSliceLastChunk(_126[1], 40); if (_132 !== undefined) { - const swapped4 = rt.byteSliceToArray(_126[0]); - _126[0].data.set(rt.byteSliceToArray(_132), _126[0].start); + const swapped4 = rs.byteSliceToArray(_126[0]); + _126[0].data.set(rs.byteSliceToArray(_132), _126[0].start); _132.data.set(swapped4, _132.start); } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const _144: rt.ByteSlice = rt.byteSliceFrom(a); - const old2: Uint8Array | undefined = option_map$1jcn6wm(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 40), (t: rt.ByteSlice): Uint8Array => { - const _36: Uint8Array = rt.byteSliceToArray(_144); - const old4 = rt.byteSliceToArray(t); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const _144: rs.ByteSlice = rs.byteSliceFrom(a); + const old2: Uint8Array | undefined = option_map$10o993m(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40), (t: rs.ByteSlice): Uint8Array => { + const _36: Uint8Array = rs.byteSliceToArray(_144); + const old4 = rs.byteSliceToArray(t); t.data.set(_36, t.start); return old4; }); - const cloned2: Uint8Array | undefined = copy$Option_array40_u8(rt.optionMap(rt.byteSliceLastChunk(rt.byteVecSlice(buf), 40), rt.byteSliceView)); - const _149: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(buf))); + const cloned2: Uint8Array | undefined = copy$Option_array40_u8(rs.optionMap(rs.byteSliceLastChunk(rs.byteVecSlice(buf), 40), rs.byteSliceView)); + const _149: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(buf))); if (_149 !== undefined) { _149.v = _149.v ^ 64; } putSome$40(out, part); putSome$40(out, old2); putSome$40(out, cloned2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(a))]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(a))]; + rs.byteVecPush(out, one.length & 0xff); put$40(out, one); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)])))); - const _173: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)])))); + const _173: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))))); if (_173 !== undefined) { _173.v = 238; } put$40(out, [copy$array_u8(b)]); - const _190: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - const _192: rt.ByteSlice = rt.byteSliceFrom(a); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_192), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(_190, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d2: rt.u8): boolean => { - return rt.u8Rem(d2, 3) === 0; + const _190: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + const _192: rs.ByteSlice = rs.byteSliceFrom(a); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_192), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(_190, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d2: rs.u8): boolean => { + return rs.u8Rem(d2, 3) === 0; })) { - [rt.byteSliceFrom(a), rt.byteSliceFrom(b)] as [rt.ByteSlice, rt.ByteSlice]; - if (!rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) { + [rs.byteSliceFrom(a), rs.byteSliceFrom(b)] as [rs.ByteSlice, rs.ByteSlice]; + if (!rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) { const arg = data.length; const kind: string = "=="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - const _208: rt.Arguments | undefined = ["after ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(a)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(b)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _208); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; + const _208: rs.Arguments | undefined = ["after ", args4[0]]; + const arg2 = rs.byteSliceView(rs.byteSliceFrom(a)); + const arg3 = rs.byteSliceView(rs.byteSliceFrom(b)); + rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _208); } } } @@ -1070,111 +1070,111 @@ export function givenN$40(data: rt.ByteSlice, out: rt.ByteVec): void { * [`given`] of a field's `[u8; 3]`, swapped, replaced, taken, and formatted through its * own `Debug`. */ -export function fields(data: rt.ByteSlice, out: rt.ByteVec): void { +export function fields(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$3(data, 2)); const held: Framed.Framed = { bytes: copy$array_u8(bytesAt$3(data, 0)) }; - const _7: rt.ByteSlice = rt.byteSliceFrom(held.bytes); - const _8: rt.ByteSlice = rt.byteSliceFrom(a); - const swapped = rt.byteSliceToArray(_7); - _7.data.set(rt.byteSliceToArray(_8), _7.start); + const _7: rs.ByteSlice = rs.byteSliceFrom(held.bytes); + const _8: rs.ByteSlice = rs.byteSliceFrom(a); + const swapped = rs.byteSliceToArray(_7); + _7.data.set(rs.byteSliceToArray(_8), _7.start); _8.data.set(swapped, _8.start); - const _10: rt.ByteSlice = rt.byteSliceFrom(held.bytes); + const _10: rs.ByteSlice = rs.byteSliceFrom(held.bytes); const _11: Uint8Array = Uint8Array.of(a[2], a[1], a[0]); - const old2 = rt.byteSliceToArray(_10); + const old2 = rs.byteSliceToArray(_10); _10.data.set(_11, _10.start); const old: Uint8Array = old2; held.bytes[0] = held.bytes[0] ^ 16; put$3(out, [copy$array_u8(a), old, copy$array_u8(held.bytes)]); const part = { _0: copy$array_u8(held.bytes) }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]; - const shown: string = rt.fmtFormat([args2[0]]); - const _41: rt.ByteSlice = rt.byteSliceFrom(held.bytes); - const taken2 = rt.byteSliceToArray(_41); - _41.data.set(rt.bytes(3), _41.start); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Bracketed.fmt$fmt_Debug(part, f)]; + const shown: string = rs.fmtFormat([args2[0]]); + const _41: rs.ByteSlice = rs.byteSliceFrom(held.bytes); + const taken2 = rs.byteSliceToArray(_41); + _41.data.set(rs.bytes(3), _41.start); put$3(out, [taken2, copy$array_u8(held.bytes)]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(shown)); - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (d: rt.u8): boolean => { - return rt.u8Rem(d, 3) === 1; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(shown)); + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (d: rs.u8): boolean => { + return rs.u8Rem(d, 3) === 1; })) { - [rt.byteSliceFrom(old), rt.byteSliceFrom(a)] as [rt.ByteSlice, rt.ByteSlice]; - if (rt.eqBytes(rt.byteSliceFrom(old), rt.byteSliceFrom(a))) { + [rs.byteSliceFrom(old), rs.byteSliceFrom(a)] as [rs.ByteSlice, rs.ByteSlice]; + if (rs.eqBytes(rs.byteSliceFrom(old), rs.byteSliceFrom(a))) { const arg = data.length; const kind: string = "!="; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg, f)]; - const _60: rt.Arguments | undefined = ["fields of ", args4[0]]; - const arg2 = rt.byteSliceView(rt.byteSliceFrom(old)); - const arg3 = rt.byteSliceView(rt.byteSliceFrom(a)); - rt.assertFailed(kind, (f: rt.Formatter) => rt.fmtList(arg2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u8Debug), _60); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg, f)]; + const _60: rs.Arguments | undefined = ["fields of ", args4[0]]; + const arg2 = rs.byteSliceView(rs.byteSliceFrom(old)); + const arg3 = rs.byteSliceView(rs.byteSliceFrom(a)); + rs.assertFailed(kind, (f: rs.Formatter) => rs.fmtList(arg2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u8Debug), _60); } } } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$0(data: rt.ByteSlice, out: rt.ByteVec): void { +export function taken$0(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$0(data, 1)); - rt.byteSliceFrom(a); - put$0(out, [rt.bytes(0), copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(0).fill(119))), undefined, true); - const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 0); + rs.byteSliceFrom(a); + put$0(out, [rs.bytes(0), copy$array_u8(a)]); + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(0).fill(119))), undefined, true); + const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 0); if (_17 !== undefined) { - rt.byteSliceFill(_17, 102); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.bytes(0))); + rs.byteSliceFill(_17, 102); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.bytes(0))); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$1(data: rt.ByteSlice, out: rt.ByteVec): void { +export function taken$1(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$1(data, 1)); - const _5: rt.ByteSlice = rt.byteSliceFrom(a); - const taken = rt.byteSliceToArray(_5); - _5.data.set(rt.bytes(1), _5.start); + const _5: rs.ByteSlice = rs.byteSliceFrom(a); + const taken = rs.byteSliceToArray(_5); + _5.data.set(rs.bytes(1), _5.start); put$1(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(1).fill(119))), undefined, true); - const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 1); + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(1).fill(119))), undefined, true); + const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 1); if (_17 !== undefined) { - rt.byteSliceFill(_17, 102); - const taken2 = rt.byteSliceToArray(_17); - _17.data.set(rt.bytes(1), _17.start); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(taken2)); + rs.byteSliceFill(_17, 102); + const taken2 = rs.byteSliceToArray(_17); + _17.data.set(rs.bytes(1), _17.start); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(taken2)); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$3(data: rt.ByteSlice, out: rt.ByteVec): void { +export function taken$3(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$3(data, 1)); - const _5: rt.ByteSlice = rt.byteSliceFrom(a); - const taken = rt.byteSliceToArray(_5); - _5.data.set(rt.bytes(3), _5.start); + const _5: rs.ByteSlice = rs.byteSliceFrom(a); + const taken = rs.byteSliceToArray(_5); + _5.data.set(rs.bytes(3), _5.start); put$3(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(3).fill(119))), undefined, true); - const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 3); + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(3).fill(119))), undefined, true); + const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 3); if (_17 !== undefined) { - rt.byteSliceFill(_17, 102); - const taken2 = rt.byteSliceToArray(_17); - _17.data.set(rt.bytes(3), _17.start); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(taken2)); + rs.byteSliceFill(_17, 102); + const taken2 = rs.byteSliceToArray(_17); + _17.data.set(rs.bytes(3), _17.start); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(taken2)); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } /** [`given`] of `N` bytes, by `mem::take`, which `Default` bounds. */ -export function taken$32(data: rt.ByteSlice, out: rt.ByteVec): void { +export function taken$32(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(bytesAt$32(data, 1)); - const _5: rt.ByteSlice = rt.byteSliceFrom(a); - const taken = rt.byteSliceToArray(_5); - _5.data.set(rt.bytes(32), _5.start); + const _5: rs.ByteSlice = rs.byteSliceFrom(a); + const taken = rs.byteSliceToArray(_5); + _5.data.set(rs.bytes(32), _5.start); put$32(out, [taken, copy$array_u8(a)]); - const buf: rt.ByteVec = rt.iterToByteVec(rt.iterChain(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSlice(rt.bytes(32).fill(119))), undefined, true); - const _17: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(buf), 32); + const buf: rs.ByteVec = rs.iterToByteVec(rs.iterChain(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSlice(rs.bytes(32).fill(119))), undefined, true); + const _17: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(buf), 32); if (_17 !== undefined) { - rt.byteSliceFill(_17, 102); - const taken2 = rt.byteSliceToArray(_17); - _17.data.set(rt.bytes(32), _17.start); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(taken2)); + rs.byteSliceFill(_17, 102); + const taken2 = rs.byteSliceToArray(_17); + _17.data.set(rs.bytes(32), _17.start); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(taken2)); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(buf)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(buf)); } /** @@ -1183,8 +1183,8 @@ export function taken$32(data: rt.ByteSlice, out: rt.ByteVec): void { * and the free `zip`, `extend`, `from_iter`, and `DebugList::entries`, read from both ends and written through. * Of no bytes, one, and many. */ -export function flattened(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 3); +export function flattened(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 3); if (_5 === 0) { flattenedN$0(data, out); } else if (_5 === 1) { @@ -1193,13 +1193,13 @@ export function flattened(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi flattenedN$5(data, out); } const part = [{ _0: bytesAt$3(data, 1) }, { _0: undefined }]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: Listed.Listed, f: rt.Formatter) => Listed.fmt$fmt_Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: Listed.Listed, f: rs.Formatter) => Listed.fmt$fmt_Debug(value, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** [`flattened`] of `N` bytes. */ -export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const options: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): Uint8Array | undefined => { +export function flattenedN$0(data: rs.ByteSlice, out: rs.ByteVec): void { + const options: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): Uint8Array | undefined => { let _3!: boolean; if (!(k !== 2)) { _3 = false; @@ -1207,241 +1207,241 @@ export function flattenedN$0(data: rt.ByteSlice, out: rt.ByteVec): void { _3 = k !== 4; } return then$11x7xqs(_3, (): Uint8Array => { - return bytesAt$0(data, rt.usizeMul(k, 0)); + return bytesAt$0(data, rs.usizeMul(k, 0)); }); }), undefined, 1, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const it: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; + const _36: [rs.ByteSlice | undefined, rs.ByteSlice | undefined] = [rs.iterToOption(it.next()), rs.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { - const b: rt.ByteSlice | undefined = _36[1]; - rt.byteVecExtendFromSlice(out, _36[0]); - rt.byteVecExtendFromSlice(out, option_unwrapOr$1rbuegs(b, rt.byteSliceFrom(Uint8Array.of()))); + const b: rs.ByteSlice | undefined = _36[1]; + rs.byteVecExtendFromSlice(out, _36[0]); + rs.byteVecExtendFromSlice(out, option_unwrapOr$0yvilko(b, rs.byteSliceFrom(Uint8Array.of()))); } else { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _56: rt.ByteSlice | rt.Done = iter3.next(); - if (_56 === rt.DONE) { + const _56: rs.ByteSlice | rs.Done = iter3.next(); + if (_56 === rs.DONE) { break; } - rt.byteSliceView(_56).reverse(); - const _62: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_56)); + rs.byteSliceView(_56).reverse(); + const _62: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_56)); if (_62 !== undefined) { _62.v = _62.v ^ 17; } } putOptions$0(out, options.items); - const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { + const iter4: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + }, (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _75: rt.ByteSlice | rt.Done = iter4.next(); - if (_75 === rt.DONE) { + const _75: rs.ByteSlice | rs.Done = iter4.next(); + if (_75 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _75); + rs.byteVecExtendFromSlice(out, _75); } - const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options.items), (o2: Uint8Array | undefined): rt.Iter => { - return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterRev(rs.iterFlatMap(rs.iterSlice(options.items), (o2: Uint8Array | undefined): rs.Iter => { + return rs.iterLend(rs.iterOption(o2), rs.byteSliceFrom); }, undefined, true, undefined, true)); while (true) { - const _88: rt.ByteSlice | rt.Done = iter5.next(); - if (_88 === rt.DONE) { + const _88: rs.ByteSlice | rs.Done = iter5.next(); + if (_88 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _88); + rs.byteVecExtendFromSlice(out, _88); } - const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { - return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); + const iter6: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o3: Uint8Array | undefined): rs.ByteSlice | undefined => { + return rs.optionMap(o3, rs.byteSliceFrom); + }, (value: rs.ByteSlice | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _100: rt.ByteSlice | rt.Done = iter6.next(); - if (_100 === rt.DONE) { + const _100: rs.ByteSlice | rs.Done = iter6.next(); + if (_100 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _100); + rs.byteVecExtendFromSlice(out, _100); } - const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options.items), (o4: rt.Place): rt.Place => { + const iter7: rs.Iter = rs.iterFlatMap(rs.iterSliceMut(options.items), (o4: rs.Place): rs.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + }, (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _112: rt.ByteSlice | rt.Done = iter7.next(); - if (_112 === rt.DONE) { + const _112: rs.ByteSlice | rs.Done = iter7.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_112)); + const _116: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_112)); if (_116 !== undefined) { - _116.v = rt.u8WrappingAdd(_116.v, 3); + _116.v = rs.u8WrappingAdd(_116.v, 3); } } putOptions$0(out, options.items); - const one: Uint8Array | undefined = copy$Option_array0_u8(options.items[rt.idx(options.items, 0)]); - const other: Uint8Array | undefined = copy$Option_array0_u8(options.items[rt.idx(options.items, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const one: Uint8Array | undefined = copy$Option_array0_u8(options.items[rs.idx(options.items, 0)]); + const other: Uint8Array | undefined = copy$Option_array0_u8(options.items[rs.idx(options.items, 1)]); + const iter8: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterOption(one), rs.byteSliceFrom), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _142: rt.ByteSlice | rt.Done = iter8.next(); - if (_142 === rt.DONE) { + const _142: rs.ByteSlice | rs.Done = iter8.next(); + if (_142 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _142); + rs.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); while (true) { - const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); - if (_156 === rt.DONE) { + const _156: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); + if (_156 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _156[0]); - rt.byteVecExtendFromSlice(out, _156[1]); + rs.byteVecExtendFromSlice(out, _156[0]); + rs.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); - while (iter10.next() !== rt.DONE) { + const iter10: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); + while (iter10.next() !== rs.DONE) { } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); + const _182: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), _182); while (true) { - const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); - if (_187 === rt.DONE) { + const _187: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); + if (_187 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _187[0]); - rt.byteVecExtendFromSlice(out, _187[1]); + rs.byteVecExtendFromSlice(out, _187[0]); + rs.byteVecExtendFromSlice(out, _187[1]); } - const iter12: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterSliceMut(options.items), "len"); + const iter12: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterSliceMut(options.items), "len"); while (true) { - const _201: [rt.ByteSlice, rt.Place] | rt.Done = iter12.next(); - if (_201 === rt.DONE) { + const _201: [rs.ByteSlice, rs.Place] | rs.Done = iter12.next(); + if (_201 === rs.DONE) { break; } - rt.byteSliceRotateLeft(_201[0], rt.min(0, 1)); + rs.byteSliceRotateLeft(_201[0], rs.min(0, 1)); _201[1].v = copy$Option_array0_u8(option_map$0p6o7wa(copy$Option_array0_u8(_201[1].v), (a: Uint8Array): Uint8Array => { a = copy$array_u8(a); - rt.byteSliceFill(rt.byteSliceFrom(a), option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_201[0]), 51)); + rs.byteSliceFill(rs.byteSliceFrom(a), option_unwrapOr$1fr498u(rs.byteSliceFirst(_201[0]), 51)); return copy$array_u8(a); })); } - const sums: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): rt.u16 => { - return _24 as rt.u16; + const sums: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.u16 => { + return _24 as rs.u16; }), undefined, 2, true); - const _219: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data)))); - const iter13: rt.Iter<[rt.Place, [rt.usize, rt.u8]]> = rt.iterZip(rt.iterSliceMut(sums.items), _219, "len"); + const _219: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data)))); + const iter13: rs.Iter<[rs.Place, [rs.usize, rs.u8]]> = rs.iterZip(rs.iterSliceMut(sums.items), _219, "len"); while (true) { - const _223: [rt.Place, [rt.usize, rt.u8]] | rt.Done = iter13.next(); - if (_223 === rt.DONE) { + const _223: [rs.Place, [rs.usize, rs.u8]] | rs.Done = iter13.next(); + if (_223 === rs.DONE) { break; } - const i: rt.usize = _223[1][0]; - const _229: rt.u16 = rt.u16WrappingMul(_223[0].v, 31); - _223[0].v = _229 ^ rt.u16Shl(_223[1][1] as rt.u16, rt.usizeRem(i, 8)); + const i: rs.usize = _223[1][0]; + const _229: rs.u16 = rs.u16WrappingMul(_223[0].v, 31); + _223[0].v = _229 ^ rs.u16Shl(_223[1][1] as rs.u16, rs.usizeRem(i, 8)); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums.items), (x: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 3)]), rt.byteSliceFrom)); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(sums.items), (x: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const iter14: rs.Iter = rs.iterChain(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 3)]), rs.byteSliceFrom)); while (true) { - const _249: rt.ByteSlice | rt.Done = iter14.next(); - if (_249 === rt.DONE) { + const _249: rs.ByteSlice | rs.Done = iter14.next(); + if (_249 === rs.DONE) { break; } - rt.byteSliceFill(_249, 90); + rs.byteSliceFill(_249, 90); } - const iter15: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter15: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _258: rt.ByteSlice | rt.Done = iter15.next(); - if (_258 === rt.DONE) { + const _258: rs.ByteSlice | rs.Done = iter15.next(); + if (_258 === rs.DONE) { break; } - rt.byteSliceView(_258).reverse(); + rs.byteSliceView(_258).reverse(); } - const iter16: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter16: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _267: rt.ByteSlice | rt.Done = iter16.next(); - if (_267 === rt.DONE) { + const _267: rs.ByteSlice | rs.Done = iter16.next(); + if (_267 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _267); + rs.byteVecExtendFromSlice(out, _267); } putOptions$0(out, options.items); putSome$0(out, other); - const copied: rt.Vec = rt.iterToVec(rt.iterCopied(rt.vecIntoIter(rt.iterToVec(rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 0, true); - rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 0); + const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 0, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 0, true); + const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 0); put$0(out, copied.items); - const nested: rt.Vec = rt.vecFrom(copy$array_Option_Option_array0_u8([undefined, rt.None, copy$Option_array0_u8(options.items[rt.idx(options.items, 0)]), bytesAt$0(data, 3), undefined]).map(copy$Option_Option_array0_u8)); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array0_u8([undefined, rs.None, copy$Option_array0_u8(options.items[rs.idx(options.items, 0)]), bytesAt$0(data, 3), undefined]).map(copy$Option_Option_array0_u8)); + const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _317: rt.ByteSlice | rt.Done = iter17.next(); - if (_317 === rt.DONE) { + const _317: rs.ByteSlice | rs.Done = iter17.next(); + if (_317 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _317); + rs.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter18: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _331: rt.ByteSlice | rt.Done = iter18.next(); - if (_331 === rt.DONE) { + const _331: rs.ByteSlice | rs.Done = iter18.next(); + if (_331 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _331); + rs.byteVecExtendFromSlice(out, _331); } - const vecs: rt.Vec> = rt.vecFrom([new rt.Vec(), rt.vecFrom(copy$array_array0_u8([bytesAt$0(data, 4), bytesAt$0(data, 5)]).map(copy$array_u8))]); - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs.items), (value: rt.Vec) => rt.iterLend(rt.iterSlice(value.items), rt.byteSliceFrom), true)); + const vecs: rs.Vec> = rs.vecFrom([new rs.Vec(), rs.vecFrom(copy$array_array0_u8([bytesAt$0(data, 4), bytesAt$0(data, 5)]).map(copy$array_u8))]); + const iter19: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(vecs.items), (value: rs.Vec) => rs.iterLend(rs.iterSlice(value.items), rs.byteSliceFrom), true)); while (true) { - const _351: rt.ByteSlice | rt.Done = iter19.next(); - if (_351 === rt.DONE) { + const _351: rs.ByteSlice | rs.Done = iter19.next(); + if (_351 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _351); + rs.byteVecExtendFromSlice(out, _351); } - const iter20: rt.Iter = rt.iterFlatten(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterSlice(vecs.items), (v: rt.Vec): Uint8Array[] => { + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): Uint8Array[] => { return v.items; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); + }), undefined, 8, true)), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true); while (true) { - const _366: rt.ByteSlice | rt.Done = iter20.next(); - if (_366 === rt.DONE) { + const _366: rs.ByteSlice | rs.Done = iter20.next(); + if (_366 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _366); + rs.byteVecExtendFromSlice(out, _366); } const _374: Uint8Array = bytesAt$0(data, 6); const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array0_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); + })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); while (true) { - const _381: rt.ByteSlice | rt.Done = iter21.next(); - if (_381 === rt.DONE) { + const _381: rs.ByteSlice | rs.Done = iter21.next(); + if (_381 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _381); + rs.byteVecExtendFromSlice(out, _381); } } /** [`flattened`] of `N` bytes. */ -export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const options: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): Uint8Array | undefined => { +export function flattenedN$1(data: rs.ByteSlice, out: rs.ByteVec): void { + const options: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): Uint8Array | undefined => { let _3!: boolean; if (!(k !== 2)) { _3 = false; @@ -1449,248 +1449,248 @@ export function flattenedN$1(data: rt.ByteSlice, out: rt.ByteVec): void { _3 = k !== 4; } return then$11x7xqs(_3, (): Uint8Array => { - return bytesAt$1(data, rt.usizeMul(k, 1)); + return bytesAt$1(data, rs.usizeMul(k, 1)); }); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const it: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; + const _36: [rs.ByteSlice | undefined, rs.ByteSlice | undefined] = [rs.iterToOption(it.next()), rs.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { - const b: rt.ByteSlice | undefined = _36[1]; - rt.byteVecExtendFromSlice(out, _36[0]); - rt.byteVecExtendFromSlice(out, option_unwrapOr$1rbuegs(b, rt.byteSliceFrom(Uint8Array.of(170)))); + const b: rs.ByteSlice | undefined = _36[1]; + rs.byteVecExtendFromSlice(out, _36[0]); + rs.byteVecExtendFromSlice(out, option_unwrapOr$0yvilko(b, rs.byteSliceFrom(Uint8Array.of(170)))); } else { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _56: rt.ByteSlice | rt.Done = iter3.next(); - if (_56 === rt.DONE) { + const _56: rs.ByteSlice | rs.Done = iter3.next(); + if (_56 === rs.DONE) { break; } - rt.byteSliceView(_56).reverse(); - const _62: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_56)); + rs.byteSliceView(_56).reverse(); + const _62: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_56)); if (_62 !== undefined) { _62.v = _62.v ^ 17; } } putOptions$1(out, options.items); - const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { + const iter4: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + }, (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _75: rt.ByteSlice | rt.Done = iter4.next(); - if (_75 === rt.DONE) { + const _75: rs.ByteSlice | rs.Done = iter4.next(); + if (_75 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _75); + rs.byteVecExtendFromSlice(out, _75); } - const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options.items), (o2: Uint8Array | undefined): rt.Iter => { - return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterRev(rs.iterFlatMap(rs.iterSlice(options.items), (o2: Uint8Array | undefined): rs.Iter => { + return rs.iterLend(rs.iterOption(o2), rs.byteSliceFrom); }, undefined, true, undefined, true)); while (true) { - const _88: rt.ByteSlice | rt.Done = iter5.next(); - if (_88 === rt.DONE) { + const _88: rs.ByteSlice | rs.Done = iter5.next(); + if (_88 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _88); + rs.byteVecExtendFromSlice(out, _88); } - const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { - return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); + const iter6: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o3: Uint8Array | undefined): rs.ByteSlice | undefined => { + return rs.optionMap(o3, rs.byteSliceFrom); + }, (value: rs.ByteSlice | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _100: rt.ByteSlice | rt.Done = iter6.next(); - if (_100 === rt.DONE) { + const _100: rs.ByteSlice | rs.Done = iter6.next(); + if (_100 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _100); + rs.byteVecExtendFromSlice(out, _100); } - const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options.items), (o4: rt.Place): rt.Place => { + const iter7: rs.Iter = rs.iterFlatMap(rs.iterSliceMut(options.items), (o4: rs.Place): rs.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + }, (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _112: rt.ByteSlice | rt.Done = iter7.next(); - if (_112 === rt.DONE) { + const _112: rs.ByteSlice | rs.Done = iter7.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_112)); + const _116: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_112)); if (_116 !== undefined) { - _116.v = rt.u8WrappingAdd(_116.v, 3); + _116.v = rs.u8WrappingAdd(_116.v, 3); } } putOptions$1(out, options.items); - const one: Uint8Array | undefined = copy$Option_array1_u8(options.items[rt.idx(options.items, 0)]); - const other: Uint8Array | undefined = copy$Option_array1_u8(options.items[rt.idx(options.items, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const one: Uint8Array | undefined = copy$Option_array1_u8(options.items[rs.idx(options.items, 0)]); + const other: Uint8Array | undefined = copy$Option_array1_u8(options.items[rs.idx(options.items, 1)]); + const iter8: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterOption(one), rs.byteSliceFrom), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _142: rt.ByteSlice | rt.Done = iter8.next(); - if (_142 === rt.DONE) { + const _142: rs.ByteSlice | rs.Done = iter8.next(); + if (_142 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _142); + rs.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); while (true) { - const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); - if (_156 === rt.DONE) { + const _156: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); + if (_156 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _156[0]); - rt.byteVecExtendFromSlice(out, _156[1]); + rs.byteVecExtendFromSlice(out, _156[0]); + rs.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter10: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); while (true) { - const _173: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter10.next(); - if (_173 === rt.DONE) { + const _173: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter10.next(); + if (_173 === rs.DONE) { break; } - const swapped = rt.byteSliceToArray(_173[0]); - _173[0].data.set(rt.byteSliceToArray(_173[1]), _173[0].start); + const swapped = rs.byteSliceToArray(_173[0]); + _173[0].data.set(rs.byteSliceToArray(_173[1]), _173[0].start); _173[1].data.set(swapped, _173[1].start); } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); + const _182: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), _182); while (true) { - const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); - if (_187 === rt.DONE) { + const _187: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); + if (_187 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _187[0]); - rt.byteVecExtendFromSlice(out, _187[1]); + rs.byteVecExtendFromSlice(out, _187[0]); + rs.byteVecExtendFromSlice(out, _187[1]); } - const iter12: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterSliceMut(options.items), "len"); + const iter12: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterSliceMut(options.items), "len"); while (true) { - const _201: [rt.ByteSlice, rt.Place] | rt.Done = iter12.next(); - if (_201 === rt.DONE) { + const _201: [rs.ByteSlice, rs.Place] | rs.Done = iter12.next(); + if (_201 === rs.DONE) { break; } - rt.byteSliceRotateLeft(_201[0], rt.min(1, 1)); + rs.byteSliceRotateLeft(_201[0], rs.min(1, 1)); _201[1].v = copy$Option_array1_u8(option_map$0p6o7wa(copy$Option_array1_u8(_201[1].v), (a: Uint8Array): Uint8Array => { a = copy$array_u8(a); - rt.byteSliceFill(rt.byteSliceFrom(a), option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_201[0]), 51)); + rs.byteSliceFill(rs.byteSliceFrom(a), option_unwrapOr$1fr498u(rs.byteSliceFirst(_201[0]), 51)); return copy$array_u8(a); })); } - const sums: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): rt.u16 => { - return _24 as rt.u16; + const sums: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.u16 => { + return _24 as rs.u16; }), undefined, 2, true); - const _219: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data)))); - const iter13: rt.Iter<[rt.Place, [rt.usize, rt.u8]]> = rt.iterZip(rt.iterSliceMut(sums.items), _219, "len"); + const _219: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data)))); + const iter13: rs.Iter<[rs.Place, [rs.usize, rs.u8]]> = rs.iterZip(rs.iterSliceMut(sums.items), _219, "len"); while (true) { - const _223: [rt.Place, [rt.usize, rt.u8]] | rt.Done = iter13.next(); - if (_223 === rt.DONE) { + const _223: [rs.Place, [rs.usize, rs.u8]] | rs.Done = iter13.next(); + if (_223 === rs.DONE) { break; } - const i: rt.usize = _223[1][0]; - const _229: rt.u16 = rt.u16WrappingMul(_223[0].v, 31); - _223[0].v = _229 ^ rt.u16Shl(_223[1][1] as rt.u16, rt.usizeRem(i, 8)); + const i: rs.usize = _223[1][0]; + const _229: rs.u16 = rs.u16WrappingMul(_223[0].v, 31); + _223[0].v = _229 ^ rs.u16Shl(_223[1][1] as rs.u16, rs.usizeRem(i, 8)); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums.items), (x: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 3)]), rt.byteSliceFrom)); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(sums.items), (x: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const iter14: rs.Iter = rs.iterChain(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 3)]), rs.byteSliceFrom)); while (true) { - const _249: rt.ByteSlice | rt.Done = iter14.next(); - if (_249 === rt.DONE) { + const _249: rs.ByteSlice | rs.Done = iter14.next(); + if (_249 === rs.DONE) { break; } - rt.byteSliceFill(_249, 90); + rs.byteSliceFill(_249, 90); } - const iter15: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter15: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _258: rt.ByteSlice | rt.Done = iter15.next(); - if (_258 === rt.DONE) { + const _258: rs.ByteSlice | rs.Done = iter15.next(); + if (_258 === rs.DONE) { break; } - rt.byteSliceView(_258).reverse(); + rs.byteSliceView(_258).reverse(); } - const iter16: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter16: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _267: rt.ByteSlice | rt.Done = iter16.next(); - if (_267 === rt.DONE) { + const _267: rs.ByteSlice | rs.Done = iter16.next(); + if (_267 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _267); + rs.byteVecExtendFromSlice(out, _267); } putOptions$1(out, options.items); putSome$1(out, other); - const copied: rt.Vec = rt.iterToVec(rt.iterCopied(rt.vecIntoIter(rt.iterToVec(rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 1, true); - rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 1, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 1); + const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 1, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 1, true); + const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 1); put$1(out, copied.items); - const nested: rt.Vec = rt.vecFrom(copy$array_Option_Option_array1_u8([undefined, rt.None, copy$Option_array1_u8(options.items[rt.idx(options.items, 0)]), bytesAt$1(data, 3), undefined]).map(copy$Option_Option_array1_u8)); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array1_u8([undefined, rs.None, copy$Option_array1_u8(options.items[rs.idx(options.items, 0)]), bytesAt$1(data, 3), undefined]).map(copy$Option_Option_array1_u8)); + const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _317: rt.ByteSlice | rt.Done = iter17.next(); - if (_317 === rt.DONE) { + const _317: rs.ByteSlice | rs.Done = iter17.next(); + if (_317 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _317); + rs.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter18: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _331: rt.ByteSlice | rt.Done = iter18.next(); - if (_331 === rt.DONE) { + const _331: rs.ByteSlice | rs.Done = iter18.next(); + if (_331 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _331); + rs.byteVecExtendFromSlice(out, _331); } - const vecs: rt.Vec> = rt.vecFrom([new rt.Vec(), rt.vecFrom(copy$array_array1_u8([bytesAt$1(data, 4), bytesAt$1(data, 5)]).map(copy$array_u8))]); - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs.items), (value: rt.Vec) => rt.iterLend(rt.iterSlice(value.items), rt.byteSliceFrom), true)); + const vecs: rs.Vec> = rs.vecFrom([new rs.Vec(), rs.vecFrom(copy$array_array1_u8([bytesAt$1(data, 4), bytesAt$1(data, 5)]).map(copy$array_u8))]); + const iter19: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(vecs.items), (value: rs.Vec) => rs.iterLend(rs.iterSlice(value.items), rs.byteSliceFrom), true)); while (true) { - const _351: rt.ByteSlice | rt.Done = iter19.next(); - if (_351 === rt.DONE) { + const _351: rs.ByteSlice | rs.Done = iter19.next(); + if (_351 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _351); + rs.byteVecExtendFromSlice(out, _351); } - const iter20: rt.Iter = rt.iterFlatten(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterSlice(vecs.items), (v: rt.Vec): Uint8Array[] => { + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): Uint8Array[] => { return v.items; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); + }), undefined, 8, true)), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true); while (true) { - const _366: rt.ByteSlice | rt.Done = iter20.next(); - if (_366 === rt.DONE) { + const _366: rs.ByteSlice | rs.Done = iter20.next(); + if (_366 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _366); + rs.byteVecExtendFromSlice(out, _366); } const _374: Uint8Array = bytesAt$1(data, 6); const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array1_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); + })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); while (true) { - const _381: rt.ByteSlice | rt.Done = iter21.next(); - if (_381 === rt.DONE) { + const _381: rs.ByteSlice | rs.Done = iter21.next(); + if (_381 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _381); + rs.byteVecExtendFromSlice(out, _381); } } /** [`flattened`] of `N` bytes. */ -export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { - const options: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): Uint8Array | undefined => { +export function flattenedN$5(data: rs.ByteSlice, out: rs.ByteVec): void { + const options: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): Uint8Array | undefined => { let _3!: boolean; if (!(k !== 2)) { _3 = false; @@ -1698,261 +1698,261 @@ export function flattenedN$5(data: rt.ByteSlice, out: rt.ByteVec): void { _3 = k !== 4; } return then$11x7xqs(_3, (): Uint8Array => { - return bytesAt$5(data, rt.usizeMul(k, 5)); + return bytesAt$5(data, rs.usizeMul(k, 5)); }); }), undefined, 6, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const it: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _36: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; + const _36: [rs.ByteSlice | undefined, rs.ByteSlice | undefined] = [rs.iterToOption(it.next()), rs.iterToOption(it.nextBack())]; if (_36[0] !== undefined) { - const b: rt.ByteSlice | undefined = _36[1]; - rt.byteVecExtendFromSlice(out, _36[0]); - rt.byteVecExtendFromSlice(out, option_unwrapOr$1rbuegs(b, rt.byteSliceFrom(Uint8Array.of(170, 170, 170, 170, 170)))); + const b: rs.ByteSlice | undefined = _36[1]; + rs.byteVecExtendFromSlice(out, _36[0]); + rs.byteVecExtendFromSlice(out, option_unwrapOr$0yvilko(b, rs.byteSliceFrom(Uint8Array.of(170, 170, 170, 170, 170)))); } else { break; } } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _56: rt.ByteSlice | rt.Done = iter3.next(); - if (_56 === rt.DONE) { + const _56: rs.ByteSlice | rs.Done = iter3.next(); + if (_56 === rs.DONE) { break; } - rt.byteSliceView(_56).reverse(); - const _62: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_56)); + rs.byteSliceView(_56).reverse(); + const _62: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_56)); if (_62 !== undefined) { _62.v = _62.v ^ 17; } } putOptions$5(out, options.items); - const iter4: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { + const iter4: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o: Uint8Array | undefined): Uint8Array | undefined => { return o; - }, (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + }, (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _75: rt.ByteSlice | rt.Done = iter4.next(); - if (_75 === rt.DONE) { + const _75: rs.ByteSlice | rs.Done = iter4.next(); + if (_75 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _75); + rs.byteVecExtendFromSlice(out, _75); } - const iter5: rt.Iter = rt.iterRev(rt.iterFlatMap(rt.iterSlice(options.items), (o2: Uint8Array | undefined): rt.Iter => { - return rt.iterLend(rt.iterOption(o2), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterRev(rs.iterFlatMap(rs.iterSlice(options.items), (o2: Uint8Array | undefined): rs.Iter => { + return rs.iterLend(rs.iterOption(o2), rs.byteSliceFrom); }, undefined, true, undefined, true)); while (true) { - const _88: rt.ByteSlice | rt.Done = iter5.next(); - if (_88 === rt.DONE) { + const _88: rs.ByteSlice | rs.Done = iter5.next(); + if (_88 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _88); + rs.byteVecExtendFromSlice(out, _88); } - const iter6: rt.Iter = rt.iterFlatMap(rt.iterSlice(options.items), (o3: Uint8Array | undefined): rt.ByteSlice | undefined => { - return rt.optionMap(o3, rt.byteSliceFrom); - }, (value: rt.ByteSlice | undefined) => rt.iterOption(value), true, undefined, true); + const iter6: rs.Iter = rs.iterFlatMap(rs.iterSlice(options.items), (o3: Uint8Array | undefined): rs.ByteSlice | undefined => { + return rs.optionMap(o3, rs.byteSliceFrom); + }, (value: rs.ByteSlice | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _100: rt.ByteSlice | rt.Done = iter6.next(); - if (_100 === rt.DONE) { + const _100: rs.ByteSlice | rs.Done = iter6.next(); + if (_100 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _100); + rs.byteVecExtendFromSlice(out, _100); } - const iter7: rt.Iter = rt.iterFlatMap(rt.iterSliceMut(options.items), (o4: rt.Place): rt.Place => { + const iter7: rs.Iter = rs.iterFlatMap(rs.iterSliceMut(options.items), (o4: rs.Place): rs.Place => { return o4; - }, (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true); + }, (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _112: rt.ByteSlice | rt.Done = iter7.next(); - if (_112 === rt.DONE) { + const _112: rs.ByteSlice | rs.Done = iter7.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_112)); + const _116: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_112)); if (_116 !== undefined) { - _116.v = rt.u8WrappingAdd(_116.v, 3); + _116.v = rs.u8WrappingAdd(_116.v, 3); } } putOptions$5(out, options.items); - const one: Uint8Array | undefined = copy$Option_array5_u8(options.items[rt.idx(options.items, 0)]); - const other: Uint8Array | undefined = copy$Option_array5_u8(options.items[rt.idx(options.items, 1)]); - const iter8: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterOption(one), rt.byteSliceFrom), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const one: Uint8Array | undefined = copy$Option_array5_u8(options.items[rs.idx(options.items, 0)]); + const other: Uint8Array | undefined = copy$Option_array5_u8(options.items[rs.idx(options.items, 1)]); + const iter8: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterOption(one), rs.byteSliceFrom), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _142: rt.ByteSlice | rt.Done = iter8.next(); - if (_142 === rt.DONE) { + const _142: rs.ByteSlice | rs.Done = iter8.next(); + if (_142 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _142); + rs.byteVecExtendFromSlice(out, _142); } - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); while (true) { - const _156: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); - if (_156 === rt.DONE) { + const _156: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); + if (_156 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _156[0]); - rt.byteVecExtendFromSlice(out, _156[1]); + rs.byteVecExtendFromSlice(out, _156[0]); + rs.byteVecExtendFromSlice(out, _156[1]); } - const iter10: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterFlatten(rt.iterSliceMut(options.items), (value: rt.Place) => rt.iterLend(rt.iterOption(value.v), rt.byteSliceFrom), true, undefined, true), rt.iterLend(rt.iterOption(other), rt.byteSliceFrom)); + const iter10: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterFlatten(rs.iterSliceMut(options.items), (value: rs.Place) => rs.iterLend(rs.iterOption(value.v), rs.byteSliceFrom), true, undefined, true), rs.iterLend(rs.iterOption(other), rs.byteSliceFrom)); while (true) { - const _173: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter10.next(); - if (_173 === rt.DONE) { + const _173: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter10.next(); + if (_173 === rs.DONE) { break; } - const swapped = rt.byteSliceToArray(_173[0]); - _173[0].data.set(rt.byteSliceToArray(_173[1]), _173[0].start); + const swapped = rs.byteSliceToArray(_173[0]); + _173[0].data.set(rs.byteSliceToArray(_173[1]), _173[0].start); _173[1].data.set(swapped, _173[1].start); } - const _182: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), _182); + const _182: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), _182); while (true) { - const _187: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); - if (_187 === rt.DONE) { + const _187: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); + if (_187 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _187[0]); - rt.byteVecExtendFromSlice(out, _187[1]); + rs.byteVecExtendFromSlice(out, _187[0]); + rs.byteVecExtendFromSlice(out, _187[1]); } - const iter12: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterZip(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterSliceMut(options.items), "len"); + const iter12: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterZip(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterSliceMut(options.items), "len"); while (true) { - const _201: [rt.ByteSlice, rt.Place] | rt.Done = iter12.next(); - if (_201 === rt.DONE) { + const _201: [rs.ByteSlice, rs.Place] | rs.Done = iter12.next(); + if (_201 === rs.DONE) { break; } - rt.byteSliceRotateLeft(_201[0], rt.min(5, 1)); + rs.byteSliceRotateLeft(_201[0], rs.min(5, 1)); _201[1].v = copy$Option_array5_u8(option_map$0p6o7wa(copy$Option_array5_u8(_201[1].v), (a: Uint8Array): Uint8Array => { a = copy$array_u8(a); - rt.byteSliceFill(rt.byteSliceFrom(a), option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_201[0]), 51)); + rs.byteSliceFill(rs.byteSliceFrom(a), option_unwrapOr$1fr498u(rs.byteSliceFirst(_201[0]), 51)); return copy$array_u8(a); })); } - const sums: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): rt.u16 => { - return _24 as rt.u16; + const sums: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.u16 => { + return _24 as rs.u16; }), undefined, 2, true); - const _219: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data)))); - const iter13: rt.Iter<[rt.Place, [rt.usize, rt.u8]]> = rt.iterZip(rt.iterSliceMut(sums.items), _219, "len"); + const _219: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data)))); + const iter13: rs.Iter<[rs.Place, [rs.usize, rs.u8]]> = rs.iterZip(rs.iterSliceMut(sums.items), _219, "len"); while (true) { - const _223: [rt.Place, [rt.usize, rt.u8]] | rt.Done = iter13.next(); - if (_223 === rt.DONE) { + const _223: [rs.Place, [rs.usize, rs.u8]] | rs.Done = iter13.next(); + if (_223 === rs.DONE) { break; } - const i: rt.usize = _223[1][0]; - const _229: rt.u16 = rt.u16WrappingMul(_223[0].v, 31); - _223[0].v = _229 ^ rt.u16Shl(_223[1][1] as rt.u16, rt.usizeRem(i, 8)); + const i: rs.usize = _223[1][0]; + const _229: rs.u16 = rs.u16WrappingMul(_223[0].v, 31); + _223[0].v = _229 ^ rs.u16Shl(_223[1][1] as rs.u16, rs.usizeRem(i, 8)); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(sums.items), (x: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const iter14: rt.Iter = rt.iterChain(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 3)]), rt.byteSliceFrom)); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(sums.items), (x: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const iter14: rs.Iter = rs.iterChain(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 3)]), rs.byteSliceFrom)); while (true) { - const _249: rt.ByteSlice | rt.Done = iter14.next(); - if (_249 === rt.DONE) { + const _249: rs.ByteSlice | rs.Done = iter14.next(); + if (_249 === rs.DONE) { break; } - rt.byteSliceFill(_249, 90); + rs.byteSliceFill(_249, 90); } - const iter15: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter15: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _258: rt.ByteSlice | rt.Done = iter15.next(); - if (_258 === rt.DONE) { + const _258: rs.ByteSlice | rs.Done = iter15.next(); + if (_258 === rs.DONE) { break; } - rt.byteSliceView(_258).reverse(); + rs.byteSliceView(_258).reverse(); } - const iter16: rt.Iter = rt.iterLend(rt.iterOption(other), rt.byteSliceFrom); + const iter16: rs.Iter = rs.iterLend(rs.iterOption(other), rs.byteSliceFrom); while (true) { - const _267: rt.ByteSlice | rt.Done = iter16.next(); - if (_267 === rt.DONE) { + const _267: rs.ByteSlice | rs.Done = iter16.next(); + if (_267 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _267); + rs.byteVecExtendFromSlice(out, _267); } putOptions$5(out, options.items); putSome$5(out, other); - const copied: rt.Vec = rt.iterToVec(rt.iterCopied(rt.vecIntoIter(rt.iterToVec(rt.iterLend(rt.iterOption(options.items[rt.idx(options.items, 0)]), rt.byteSliceFrom), undefined, 4, true)), rt.byteSliceToArray), undefined, 5, true); - rt.iterExtend(copied, rt.iterMap(rt.iterLend(rt.iterOption(other), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 5, true); - const _289: rt.Iter = rt.iterFlatten(rt.iterSlice(options.items), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); - rt.iterExtend(copied, rt.iterMap(_289, rt.byteSliceToArray), "next", 5); + const copied: rs.Vec = rs.iterToVec(rs.iterCopied(rs.vecIntoIter(rs.iterToVec(rs.iterLend(rs.iterOption(options.items[rs.idx(options.items, 0)]), rs.byteSliceFrom), undefined, 4, true)), rs.byteSliceToArray), undefined, 5, true); + rs.iterExtend(copied, rs.iterMap(rs.iterLend(rs.iterOption(other), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 5, true); + const _289: rs.Iter = rs.iterFlatten(rs.iterSlice(options.items), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); + rs.iterExtend(copied, rs.iterMap(_289, rs.byteSliceToArray), "next", 5); put$5(out, copied.items); - const nested: rt.Vec = rt.vecFrom(copy$array_Option_Option_array5_u8([undefined, rt.None, copy$Option_array5_u8(options.items[rt.idx(options.items, 0)]), bytesAt$5(data, 3), undefined]).map(copy$Option_Option_array5_u8)); - const iter17: rt.Iter = rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true); + const nested: rs.Vec = rs.vecFrom(copy$array_Option_Option_array5_u8([undefined, rs.None, copy$Option_array5_u8(options.items[rs.idx(options.items, 0)]), bytesAt$5(data, 3), undefined]).map(copy$Option_Option_array5_u8)); + const iter17: rs.Iter = rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _317: rt.ByteSlice | rt.Done = iter17.next(); - if (_317 === rt.DONE) { + const _317: rs.ByteSlice | rs.Done = iter17.next(); + if (_317 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _317); + rs.byteVecExtendFromSlice(out, _317); } - const iter18: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.iterSlice(nested.items), (value: Uint8Array | undefined | rt.None) => rt.iterOption(value, undefined, rt.None), true, undefined, true), (value: Uint8Array | undefined) => rt.iterLend(rt.iterOption(value), rt.byteSliceFrom), true, undefined, true)); + const iter18: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterFlatten(rs.iterSlice(nested.items), (value: Uint8Array | undefined | rs.None) => rs.iterOption(value, undefined, rs.None), true, undefined, true), (value: Uint8Array | undefined) => rs.iterLend(rs.iterOption(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _331: rt.ByteSlice | rt.Done = iter18.next(); - if (_331 === rt.DONE) { + const _331: rs.ByteSlice | rs.Done = iter18.next(); + if (_331 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _331); + rs.byteVecExtendFromSlice(out, _331); } - const vecs: rt.Vec> = rt.vecFrom([new rt.Vec(), rt.vecFrom(copy$array_array5_u8([bytesAt$5(data, 4), bytesAt$5(data, 5)]).map(copy$array_u8))]); - const iter19: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(vecs.items), (value: rt.Vec) => rt.iterLend(rt.iterSlice(value.items), rt.byteSliceFrom), true)); + const vecs: rs.Vec> = rs.vecFrom([new rs.Vec(), rs.vecFrom(copy$array_array5_u8([bytesAt$5(data, 4), bytesAt$5(data, 5)]).map(copy$array_u8))]); + const iter19: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(vecs.items), (value: rs.Vec) => rs.iterLend(rs.iterSlice(value.items), rs.byteSliceFrom), true)); while (true) { - const _351: rt.ByteSlice | rt.Done = iter19.next(); - if (_351 === rt.DONE) { + const _351: rs.ByteSlice | rs.Done = iter19.next(); + if (_351 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _351); + rs.byteVecExtendFromSlice(out, _351); } - const iter20: rt.Iter = rt.iterFlatten(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterSlice(vecs.items), (v: rt.Vec): Uint8Array[] => { + const iter20: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): Uint8Array[] => { return v.items; - }), undefined, 8, true)), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true); + }), undefined, 8, true)), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true); while (true) { - const _366: rt.ByteSlice | rt.Done = iter20.next(); - if (_366 === rt.DONE) { + const _366: rs.ByteSlice | rs.Done = iter20.next(); + if (_366 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _366); + rs.byteVecExtendFromSlice(out, _366); } const _374: Uint8Array = bytesAt$5(data, 6); const _373: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_374); }); - const iter21: rt.Iter = rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { + const iter21: rs.Iter = rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array5_u8(_373); - })), (value: Uint8Array[]) => rt.iterLend(rt.iterSlice(value), rt.byteSliceFrom), true, 2); + })), (value: Uint8Array[]) => rs.iterLend(rs.iterSlice(value), rs.byteSliceFrom), true, 2); while (true) { - const _381: rt.ByteSlice | rt.Done = iter21.next(); - if (_381 === rt.DONE) { + const _381: rs.ByteSlice | rs.Done = iter21.next(); + if (_381 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _381); + rs.byteVecExtendFromSlice(out, _381); } } /** Each `Option`'s bytes, as [`put_some`] puts them. */ -export function putOptions$0(out: rt.ByteVec, options: Array): void { +export function putOptions$0(out: rs.ByteVec, options: Array): void { for (const _5 of options) { putSome$0(out, _5); } } /** Each `Option`'s bytes, as [`put_some`] puts them. */ -export function putOptions$1(out: rt.ByteVec, options: Array): void { +export function putOptions$1(out: rs.ByteVec, options: Array): void { for (const _5 of options) { putSome$1(out, _5); } } /** Each `Option`'s bytes, as [`put_some`] puts them. */ -export function putOptions$5(out: rt.ByteVec, options: Array): void { +export function putOptions$5(out: rs.ByteVec, options: Array): void { for (const _5 of options) { putSome$5(out, _5); } diff --git a/ts/fixtures/lang/arrays/expected/core/option.ts b/ts/fixtures/lang/arrays/expected/core/option.ts index 8c39a353f..c8fe8eef1 100644 --- a/ts/fixtures/lang/arrays/expected/core/option.ts +++ b/ts/fixtures/lang/arrays/expected/core/option.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$0yvilko(self: rs.ByteSlice | undefined, default_: rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1j8xzu6(self: rt.u8 | undefined | rt.None, f: (a0: rt.u8 | undefined) => undefined): undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$1tggsfb(self: rs.u8 | undefined | rs.None, f: (a0: rs.u8 | undefined) => undefined): undefined | rs.None { + if (self === rs.None) { + return rs.None; } f(self); return undefined; @@ -38,21 +38,21 @@ export function map$0p6o7wa(self: Uint8Array | undefined, f: (a0: Uint8Array) => return f(self); } -export function map$1jcn6wm(self: rt.ByteSlice | undefined, f: (a0: rt.ByteSlice) => Uint8Array): Uint8Array | undefined { +export function map$10o993m(self: rs.ByteSlice | undefined, f: (a0: rs.ByteSlice) => Uint8Array): Uint8Array | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0rbsrz6(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function map$1yv0md6(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/arrays/expected/harness.ts b/ts/fixtures/lang/arrays/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/arrays/expected/harness.ts +++ b/ts/fixtures/lang/arrays/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/arrays/expected/lib.ts b/ts/fixtures/lang/arrays/expected/lib.ts index 5f9905bdc..3c236cbae 100644 --- a/ts/fixtures/lang/arrays/expected/lib.ts +++ b/ts/fixtures/lang/arrays/expected/lib.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { fromFns, maps, lent, asSlices, given, flattened } from "./arrays.ts"; -export function copy$Option_Option_array0_u8(v: Uint8Array | undefined | rt.None): Uint8Array | undefined | rt.None { - return v === rt.None ? v : copy$Option_array0_u8(v); +export function copy$Option_Option_array0_u8(v: Uint8Array | undefined | rs.None): Uint8Array | undefined | rs.None { + return v === rs.None ? v : copy$Option_array0_u8(v); } -export function copy$Option_Option_array1_u8(v: Uint8Array | undefined | rt.None): Uint8Array | undefined | rt.None { - return v === rt.None ? v : copy$Option_array1_u8(v); +export function copy$Option_Option_array1_u8(v: Uint8Array | undefined | rs.None): Uint8Array | undefined | rs.None { + return v === rs.None ? v : copy$Option_array1_u8(v); } -export function copy$Option_Option_array5_u8(v: Uint8Array | undefined | rt.None): Uint8Array | undefined | rt.None { - return v === rt.None ? v : copy$Option_array5_u8(v); +export function copy$Option_Option_array5_u8(v: Uint8Array | undefined | rs.None): Uint8Array | undefined | rs.None { + return v === rs.None ? v : copy$Option_array5_u8(v); } export function copy$Option_array0_u8(v: Uint8Array | undefined): Uint8Array | undefined { @@ -35,15 +35,15 @@ export function copy$Option_array5_u8(v: Uint8Array | undefined): Uint8Array | u return v === undefined ? v : copy$array_u8(v); } -export function copy$array_Option_Option_array0_u8(v: Array): Array { +export function copy$array_Option_Option_array0_u8(v: Array): Array { return v.map(copy$Option_Option_array0_u8); } -export function copy$array_Option_Option_array1_u8(v: Array): Array { +export function copy$array_Option_Option_array1_u8(v: Array): Array { return v.map(copy$Option_Option_array1_u8); } -export function copy$array_Option_Option_array5_u8(v: Array): Array { +export function copy$array_Option_Option_array5_u8(v: Array): Array { return v.map(copy$Option_Option_array5_u8); } @@ -63,7 +63,7 @@ export function copy$array_array5_u8(v: Uint8Array[]): Uint8Array[] { return v.map(copy$array_u8); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } @@ -75,16 +75,16 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["arrays::from_fns", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["arrays::from_fns", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { fromFns(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::as_slices", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::as_slices", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { asSlices(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::maps", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::maps", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { maps(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::lent", (_25: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::lent", (_25: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { lent(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::given", given as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["arrays::flattened", flattened as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::given", given as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["arrays::flattened", flattened as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/arrays/src/arrays.rs b/ts/fixtures/lang/arrays/src/arrays.rs index 7f2d9a312..1767b1bc1 100644 --- a/ts/fixtures/lang/arrays/src/arrays.rs +++ b/ts/fixtures/lang/arrays/src/arrays.rs @@ -62,7 +62,7 @@ fn counted(op: u8) -> [usize; N] { /// Arrays `map` makes, calling its closure on each element in order; each byte an /// operation, its value the operand. From bytes and to them, of none at all, through what -/// the closure captured by reference and by move, of `Option`s whose `None` is `rt.None`, +/// the closure captured by reference and by move, of `Option`s whose `None` is `rs.None`, /// and of arrays, each element the closure's own to change. pub fn maps(data: &[u8], out: &mut Vec) { for &op in data { diff --git a/ts/fixtures/lang/ascii/expected/ascii.Held.ts b/ts/fixtures/lang/ascii/expected/ascii.Held.ts index 7975a1e66..c5f7fcf96 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.Held.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.Held.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct whose fields change case where they are. */ export interface Held { - n: rt.u8; + n: rs.u8; text: string; } diff --git a/ts/fixtures/lang/ascii/expected/ascii.ts b/ts/fixtures/lang/ascii/expected/ascii.ts index 3f3cad9f2..c50f74fef 100644 --- a/ts/fixtures/lang/ascii/expected/ascii.ts +++ b/ts/fixtures/lang/ascii/expected/ascii.ts @@ -1,69 +1,69 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Held from "./ascii.Held.ts"; -import { isSomeAnd$09tpccf, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$0l7j3f6 as option_unwrapOr$0l7j3f6, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$0jad0p1 as option_mapOr$0jad0p1, mapOr$02k4ito as option_mapOr$02k4ito, asDeref$0w8at8i as option_asDeref$0w8at8i } from "./core/option.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0p20wlb as option_mapOr$0p20wlb, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i } from "./core/option.ts"; import { put } from "./harness.ts"; /** Each test of `b`, a bit apiece. */ -export function byteTests(b: rt.u8): rt.u16 { - return rt.iterFold(rt.iterEnumerate(rt.iterSlice([rt.isAscii(b), rt.isAsciiAlphabetic(b), rt.isAsciiUppercase(b), rt.isAsciiLowercase(b), rt.isAsciiAlphanumeric(b), rt.isAsciiDigit(b), rt.isAsciiHexdigit(b), rt.isAsciiPunctuation(b), rt.isAsciiGraphic(b), rt.isAsciiWhitespace(b), rt.isAsciiControl(b)])), 0, (bits: rt.u16, _32: [rt.usize, boolean]): rt.u16 => { - return bits | rt.u16Shl(_32[1] ? 1 : 0, _32[0]); +export function byteTests(b: rs.u8): rs.u16 { + return rs.iterFold(rs.iterEnumerate(rs.iterSlice([rs.isAscii(b), rs.isAsciiAlphabetic(b), rs.isAsciiUppercase(b), rs.isAsciiLowercase(b), rs.isAsciiAlphanumeric(b), rs.isAsciiDigit(b), rs.isAsciiHexdigit(b), rs.isAsciiPunctuation(b), rs.isAsciiGraphic(b), rs.isAsciiWhitespace(b), rs.isAsciiControl(b)])), 0, (bits: rs.u16, _32: [rs.usize, boolean]): rs.u16 => { + return bits | rs.u16Shl(_32[1] ? 1 : 0, _32[0]); }); } /** Each test of `c`, a bit apiece. */ -export function charTests(c: rt.char): rt.u16 { - return rt.iterFold(rt.iterEnumerate(rt.iterSlice([rt.isAscii(c), rt.isAsciiAlphabetic(c), rt.isAsciiUppercase(c), rt.isAsciiLowercase(c), rt.isAsciiAlphanumeric(c), rt.isAsciiDigit(c), rt.isAsciiHexdigit(c), rt.isAsciiPunctuation(c), rt.isAsciiGraphic(c), rt.isAsciiWhitespace(c), rt.isAsciiControl(c)])), 0, (bits: rt.u16, _32: [rt.usize, boolean]): rt.u16 => { - return bits | rt.u16Shl(_32[1] ? 1 : 0, _32[0]); +export function charTests(c: rs.char): rs.u16 { + return rs.iterFold(rs.iterEnumerate(rs.iterSlice([rs.isAscii(c), rs.isAsciiAlphabetic(c), rs.isAsciiUppercase(c), rs.isAsciiLowercase(c), rs.isAsciiAlphanumeric(c), rs.isAsciiDigit(c), rs.isAsciiHexdigit(c), rs.isAsciiPunctuation(c), rs.isAsciiGraphic(c), rs.isAsciiWhitespace(c), rs.isAsciiControl(c)])), 0, (bits: rs.u16, _32: [rs.usize, boolean]): rs.u16 => { + return bits | rs.u16Shl(_32[1] ? 1 : 0, _32[0]); }); } -export function upperByte(b: rt.Place): void { - b.v = rt.toAsciiUppercase(b.v); +export function upperByte(b: rs.Place): void { + b.v = rs.toAsciiUppercase(b.v); } -export function lowerChar(c: rt.Place): void { - c.v = rt.toAsciiLowercase(c.v); +export function lowerChar(c: rs.Place): void { + c.v = rs.toAsciiLowercase(c.v); } -export function upperText(s: rt.Place): void { - s.v = rt.strToAsciiUppercase(s.v); +export function upperText(s: rs.Place): void { + s.v = rs.strToAsciiUppercase(s.v); } /** * Read `e` alternately from the front and the back as `data`'s bits say, putting its * length before each step, then what `Display` writes of what is left. */ -export function steps$ascii_EscapeDefault(e: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { - let next!: rt.u8 | undefined; - let i: rt.usize = 0; +export function steps$ascii_EscapeDefault(e: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { + let next!: rs.u8 | undefined; + let i: rs.usize = 0; while (true) { - rt.byteVecPush(out, e.len() & 0xff); - const _11: [rt.usize, rt.usize | undefined] = e.sizeHint(); - const lo: rt.usize = _11[0]; - const hi: rt.usize | undefined = _11[1]; - rt.byteVecPush(out, lo & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(hi, 255, (h: rt.usize): rt.u8 => { + rs.byteVecPush(out, e.len() & 0xff); + const _11: [rs.usize, rs.usize | undefined] = e.sizeHint(); + const lo: rs.usize = _11[0]; + const hi: rs.usize | undefined = _11[1]; + rs.byteVecPush(out, lo & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(hi, 255, (h: rs.usize): rs.u8 => { return h & 0xff; })); - const _25: rt.usize = i; - if (!isSomeAnd$09tpccf(rt.byteSliceGet(data, rt.usizeRem(i, rt.max(data.length, 1))), (b2: rt.u8): boolean => { - return (rt.u8Shr(b2, rt.usizeRem(_25, 8)) & 1) === 1; + const _25: rs.usize = i; + if (!isSomeAnd$1s2u5lz(rs.byteSliceGet(data, rs.usizeRem(i, rs.max(data.length, 1))), (b2: rs.u8): boolean => { + return (rs.u8Shr(b2, rs.usizeRem(_25, 8)) & 1) === 1; })) { - next = rt.iterToOption(e.next()); + next = rs.iterToOption(e.next()); } else { - next = rt.iterToOption(e.nextBack()); + next = rs.iterToOption(e.nextBack()); } if (next !== undefined) { - rt.byteVecPush(out, next); + rs.byteVecPush(out, next); let shown: string = ""; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEscapeAscii(e, f)]; - const written = rt.fmtWriteString(shown, [args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f)]; + const written = rs.fmtWriteString(shown, [args2[0]]); shown = written.s; - rt.resultUnwrap(written.result, rt.fmtErrorDebug); + rs.resultUnwrap(written.result, rs.fmtErrorDebug); put(out, shown); - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } else { return; } @@ -71,95 +71,95 @@ export function steps$ascii_EscapeDefault(e: rt.Iter, data: rt.ByteSlice, } /** Every byte, through each method of `u8`. */ -export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _67!: rt.usize; - const all: rt.ByteVec = rt.iterToByteVec(new rt.RangeInclusive(0, 255, rt.u8Step), undefined, true); +export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _67!: rs.usize; + const all: rs.ByteVec = rs.iterToByteVec(new rs.RangeInclusive(0, 255, rs.u8Step), undefined, true); b0: { - const _6: rt.u8 = rt.u8Rem(kind, 4); + const _6: rs.u8 = rs.u8Rem(kind, 4); if (_6 === 0) { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, 255, rt.u8Step); + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); while (true) { - const _11: rt.u8 | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: rs.u8 | rs.Done = iter.next(); + if (_11 === rs.DONE) { break b0; } - const b: rt.u8 = _11; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(byteTests(b)))); - rt.byteVecPush(out, rt.toAsciiUppercase(b)); - rt.byteVecPush(out, rt.toAsciiLowercase(b)); - const other: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), b ^ 32); - rt.byteVecPush(out, rt.eqIgnoreAsciiCase(b, other) ? 1 : 0); - rt.byteVecPush(out, rt.eqIgnoreAsciiCase(b, b ^ 32) ? 1 : 0); + const b: rs.u8 = _11; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(byteTests(b)))); + rs.byteVecPush(out, rs.toAsciiUppercase(b)); + rs.byteVecPush(out, rs.toAsciiLowercase(b)); + const other: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), b ^ 32); + rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, other) ? 1 : 0); + rs.byteVecPush(out, rs.eqIgnoreAsciiCase(b, b ^ 32) ? 1 : 0); } } if (_6 === 1) { - const iter2: rt.RangeInclusive = new rt.RangeInclusive(0, 255, rt.u8Step); + const iter2: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); while (true) { - const _44: rt.u8 | rt.Done = iter2.next(); - if (_44 === rt.DONE) { + const _44: rs.u8 | rs.Done = iter2.next(); + if (_44 === rs.DONE) { break; } - const b2: rt.u8 = _44; - let local: rt.u8 = b2; - local = rt.toAsciiUppercase(local); - rt.byteVecPush(out, local); - const pair: [rt.u8, rt.u8] = [b2, b2]; - pair[1] = rt.toAsciiLowercase(pair[1]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); + const b2: rs.u8 = _44; + let local: rs.u8 = b2; + local = rs.toAsciiUppercase(local); + rs.byteVecPush(out, local); + const pair: [rs.u8, rs.u8] = [b2, b2]; + pair[1] = rs.toAsciiLowercase(pair[1]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } - const _64: rt.usize = all.length; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _64; + const _64: rs.usize = all.length; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _64; while ((_67 = iterStart++) < iterEnd) { - const i: rt.usize = _67; - if (!(rt.usizeRem(i, 2) === 0)) { - const at2 = rt.idx(all, i); - upperByte(rt.place(() => all.data[at2], (value) => all.data[at2] = value)); + const i: rs.usize = _67; + if (!(rs.usizeRem(i, 2) === 0)) { + const at2 = rs.idx(all, i); + upperByte(rs.place(() => all.data[at2], (value) => all.data[at2] = value)); } else { - const at = rt.idx(all, i); - all.data[at] = rt.toAsciiLowercase(all.data[at]); + const at = rs.idx(all, i); + all.data[at] = rs.toAsciiLowercase(all.data[at]); } } - const iter4: rt.Iter> = rt.iterSkip(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(all))), option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize); + const iter4: rs.Iter> = rs.iterSkip(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(all))), option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize); while (true) { - const _90: rt.Place | rt.Done = iter4.next(); - if (_90 === rt.DONE) { + const _90: rs.Place | rs.Done = iter4.next(); + if (_90 === rs.DONE) { break; } - _90.v = rt.toAsciiUppercase(_90.v); + _90.v = rs.toAsciiUppercase(_90.v); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(all)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(all)); } else { if (_6 === 2) { - const iter5: rt.RangeInclusive = new rt.RangeInclusive(0, 255, rt.u8Step); + const iter5: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); while (true) { - const _101: rt.u8 | rt.Done = iter5.next(); - if (_101 === rt.DONE) { + const _101: rs.u8 | rs.Done = iter5.next(); + if (_101 === rs.DONE) { break b0; } - const b3: rt.u8 = _101; - const e: rt.Iter = rt.escapeAscii(b3); + const b3: rs.u8 = _101; + const e: rs.Iter = rs.escapeAscii(b3); let shown: string = ""; - const _113: rt.Iter = rt.escapeAscii(b3); - const _115: rt.usize = rt.iterCount(e.clone()); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEscapeAscii(e, f), (f: rt.Formatter) => rt.fmtEscapeAscii(_113, f), (f: rt.Formatter) => rt.usizeDisplay(_115, f)]; - const written = rt.fmtWriteString(shown, [args2[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", args2[2]]); + const _113: rs.Iter = rs.escapeAscii(b3); + const _115: rs.usize = rs.iterCount(e.clone()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.fmtEscapeAscii(_113, f), (f: rs.Formatter) => rs.usizeDisplay(_115, f)]; + const written = rs.fmtWriteString(shown, [args2[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", args2[2]]); shown = written.s; - rt.resultUnwrap(written.result, rt.fmtErrorDebug); + rs.resultUnwrap(written.result, rs.fmtErrorDebug); put(out, shown); - rt.iterExtendBytes(out, e.clone(), "next"); - rt.iterExtendBytes(out, rt.iterRev(e.clone()), "next"); - rt.byteVecPush(out, rt.optionUnwrap(rt.iterLast(e.clone()))); - rt.byteVecPush(out, rt.stringLen(rt.fmtToString((f: rt.Formatter) => rt.fmtEscapeAscii(e, f))) & 0xff); + rs.iterExtendBytes(out, e.clone(), "next"); + rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); + rs.byteVecPush(out, rs.optionUnwrap(rs.iterLast(e.clone()))); + rs.byteVecPush(out, rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))) & 0xff); } } - const iter6: rt.RangeInclusive = new rt.RangeInclusive(0, 255, rt.u8Step); + const iter6: rs.RangeInclusive = new rs.RangeInclusive(0, 255, rs.u8Step); while (true) { - const _149: rt.u8 | rt.Done = iter6.next(); - if (_149 === rt.DONE) { + const _149: rs.u8 | rs.Done = iter6.next(); + if (_149 === rs.DONE) { break b0; } - steps$ascii_EscapeDefault(rt.escapeAscii(_149), data, out); + steps$ascii_EscapeDefault(rs.escapeAscii(_149), data, out); } } } @@ -169,40 +169,40 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * The chars at each edge, then each of `data`'s big-endian `u32`s that is one, through * each method of `char`. */ -export function chars(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const all: rt.Vec = rt.vecFrom([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].slice()); - const _9: rt.Iter = rt.iterFilterMap(rt.byteSliceChunks(data, 4), (c2: rt.ByteSlice): rt.char | undefined => { - return rt.charFromU32(rt.u32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c2, i2), 0); +export function chars(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const all: rs.Vec = rs.vecFrom([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].slice()); + const _9: rs.Iter = rs.iterFilterMap(rs.byteSliceChunks(data, 4), (c2: rs.ByteSlice): rs.char | undefined => { + return rs.charFromU32(rs.u32FromBeBytes(rs.bytesFromFn(4, (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(c2, i2), 0); }))); }); - rt.iterExtend(all, _9, "next", 4); - const others: rt.Vec = rt.vecFrom(all.items.slice()); - const iter: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(all.items)); + rs.iterExtend(all, _9, "next", 4); + const others: rs.Vec = rs.vecFrom(all.items.slice()); + const iter: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.iterSlice(all.items)); while (true) { - const _19: [rt.usize, rt.char] | rt.Done = iter.next(); - if (_19 === rt.DONE) { + const _19: [rs.usize, rs.char] | rs.Done = iter.next(); + if (_19 === rs.DONE) { break; } - const i: rt.usize = _19[0]; - const c: rt.char = _19[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(charTests(c)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.toAsciiUppercase(c) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.toAsciiLowercase(c) as rt.u32))); - let local: rt.char = c; - local = rt.toAsciiUppercase(local); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(local as rt.u32))); - const held: rt.Vec = rt.vecFrom([c, c]); - const at = rt.idx(held.items, 1); - lowerChar(rt.place(() => held.items[at], (value) => held.items[at] = value)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(held.items[rt.idx(held.items, 1)] as rt.u32))); - const iter2: rt.Iter = rt.iterSlice([others.items[rt.idx(others.items, rt.usizeRem(rt.usizeAdd(i, 1), others.items.length))], local, held.items[rt.idx(held.items, 1)]]); + const i: rs.usize = _19[0]; + const c: rs.char = _19[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(charTests(c)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.toAsciiUppercase(c) as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.toAsciiLowercase(c) as rs.u32))); + let local: rs.char = c; + local = rs.toAsciiUppercase(local); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(local as rs.u32))); + const held: rs.Vec = rs.vecFrom([c, c]); + const at = rs.idx(held.items, 1); + lowerChar(rs.place(() => held.items[at], (value) => held.items[at] = value)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(held.items[rs.idx(held.items, 1)] as rs.u32))); + const iter2: rs.Iter = rs.iterSlice([others.items[rs.idx(others.items, rs.usizeRem(rs.usizeAdd(i, 1), others.items.length))], local, held.items[rs.idx(held.items, 1)]]); while (true) { - const _81: rt.char | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.char | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - rt.byteVecPush(out, rt.eqIgnoreAsciiCase(c, _81) ? 1 : 0); + rs.byteVecPush(out, rs.eqIgnoreAsciiCase(c, _81) ? 1 : 0); } } } @@ -211,114 +211,114 @@ export function chars(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `data` as bytes and as text, through the ASCII methods of slices and `str`, and those * of a `Vec` and a `String` they deref to. */ -export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let next!: rt.u8 | undefined; - const half: rt.usize = rt.usizeDiv(data.length, 2); +export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let next!: rs.u8 | undefined; + const half: rs.usize = rs.usizeDiv(data.length, 2); if (half > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const a: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, half); - const b: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + half, data.length - half); + const a: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, half); + const b: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + half, data.length - half); b0: { - const _10: rt.u8 = rt.u8Rem(kind, 4); + const _10: rs.u8 = rs.u8Rem(kind, 4); if (_10 === 0) { - rt.byteVecPush(out, rt.byteSliceIsAscii(data) ? 1 : 0); - rt.byteVecPush(out, rt.iterAll(rt.iterSlice(rt.byteSliceView(data)), (a02: rt.u8): boolean => { - return rt.isAsciiHexdigit(a02); + rs.byteVecPush(out, rs.byteSliceIsAscii(data) ? 1 : 0); + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(rs.byteSliceView(data)), (a02: rs.u8): boolean => { + return rs.isAsciiHexdigit(a02); }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (a03: rt.u8): rt.u8 => { - return rt.toAsciiUppercase(a03); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (a03: rs.u8): rs.u8 => { + return rs.toAsciiUppercase(a03); }), undefined, true); - rt.byteVecPush(out, rt.byteSliceEqIgnoreAsciiCase(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEqIgnoreAsciiCase(a, rt.byteVecSlice(rt.byteSliceToAsciiLowercase(b))) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToAsciiUppercase(data))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteSliceToAsciiLowercase(data))); - const iter: rt.Iter = rt.iterSlice([rt.byteSliceTrimAsciiStart(data), rt.byteSliceTrimAsciiEnd(data), rt.byteSliceTrimAscii(data)]); + rs.byteVecPush(out, rs.byteSliceEqIgnoreAsciiCase(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.byteSliceEqIgnoreAsciiCase(a, rs.byteVecSlice(rs.byteSliceToAsciiLowercase(b))) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteSliceToAsciiUppercase(data))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteSliceToAsciiLowercase(data))); + const iter: rs.Iter = rs.iterSlice([rs.byteSliceTrimAsciiStart(data), rs.byteSliceTrimAsciiEnd(data), rs.byteSliceTrimAscii(data)]); while (true) { - const _46: rt.ByteSlice | rt.Done = iter.next(); - if (_46 === rt.DONE) { + const _46: rs.ByteSlice | rs.Done = iter.next(); + if (_46 === rs.DONE) { break; } - rt.byteVecPush(out, _46.length & 0xff); - rt.byteVecExtendFromSlice(out, _46); + rs.byteVecPush(out, _46.length & 0xff); + rs.byteVecExtendFromSlice(out, _46); } - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteSliceMakeAsciiUppercase(rt.byteSliceRange(rt.byteVecSlice(v), half)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); - rt.byteSliceMakeAsciiLowercase(rt.byteVecSlice(v)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); - const array: Uint8Array = rt.bytes(4); - rt.byteSliceCopyFromSlice(rt.byteSliceFrom(array), rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(4, data.length)))), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(97, 97, 97, 97))))), 4), undefined, true))); - rt.byteSliceMakeAsciiUppercase(rt.byteSliceFrom(array)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(array)); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteSliceMakeAsciiUppercase(rs.byteSliceRange(rs.byteVecSlice(v), half)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); + rs.byteSliceMakeAsciiLowercase(rs.byteVecSlice(v)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); + const array: Uint8Array = rs.bytes(4); + rs.byteSliceCopyFromSlice(rs.byteSliceFrom(array), rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, rs.min(4, data.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(97, 97, 97, 97))))), 4), undefined, true))); + rs.byteSliceMakeAsciiUppercase(rs.byteSliceFrom(array)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(array)); } else if (_10 === 1) { let s: string = ""; - for (const _95 of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(_95 as rt.usize, [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].length); + for (const _95 of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(_95 as rs.usize, [0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111].length); if (!(_103 < 41)) { - rt.panic("index out of bounds: the len is " + 41 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 41 + " but the index is " + _103); } s = s + String.fromCodePoint([0, 9, 10, 11, 12, 13, 31, 32, 33, 47, 48, 55, 56, 57, 58, 64, 65, 70, 71, 90, 91, 96, 97, 102, 103, 122, 123, 126, 127, 128, 192, 255, 256, 383, 304, 8490, 55295, 57344, 65535, 65536, 1114111][_103]); } - const mid: rt.usize = option_unwrapOr$0l7j3f6(rt.iterFind(rt.iterRev(new rt.RangeInclusive(0, rt.usizeDiv(rt.stringLen(s), 2), rt.usizeStep)), (_2: rt.usize): boolean => { - return rt.strIsCharBoundary(s, _2); + const mid: rs.usize = option_unwrapOr$05jq4mv(rs.iterFind(rs.iterRev(new rs.RangeInclusive(0, rs.usizeDiv(rs.stringLen(s), 2), rs.usizeStep)), (_2: rs.usize): boolean => { + return rs.strIsCharBoundary(s, _2); }), 0); - const _124: string = rt.strSlice(s, 0, mid); - const _127: string = rt.strSlice(s, mid); - rt.byteVecPush(out, rt.strIsAscii(s) ? 1 : 0); - rt.byteVecPush(out, rt.strEqIgnoreAsciiCase(_124, _127) ? 1 : 0); - rt.byteVecPush(out, rt.strEqIgnoreAsciiCase(_124, rt.strToAsciiUppercase(_127)) ? 1 : 0); - put(out, rt.strToAsciiUppercase(s)); - put(out, rt.stringExtendChars("", rt.iterFilter(rt.strChars(s), (a0: rt.char): boolean => { - return rt.isAsciiAlphanumeric(a0); + const _124: string = rs.strSlice(s, 0, mid); + const _127: string = rs.strSlice(s, mid); + rs.byteVecPush(out, rs.strIsAscii(s) ? 1 : 0); + rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, _127) ? 1 : 0); + rs.byteVecPush(out, rs.strEqIgnoreAsciiCase(_124, rs.strToAsciiUppercase(_127)) ? 1 : 0); + put(out, rs.strToAsciiUppercase(s)); + put(out, rs.stringExtendChars("", rs.iterFilter(rs.strChars(s), (a0: rs.char): boolean => { + return rs.isAsciiAlphanumeric(a0); }))); - put(out, rt.strToAsciiLowercase(s)); - put(out, rt.strTrimAsciiStart(s)); - put(out, rt.strTrimAsciiEnd(s)); - put(out, rt.strTrimAscii(s)); + put(out, rs.strToAsciiLowercase(s)); + put(out, rs.strTrimAsciiStart(s)); + put(out, rs.strTrimAsciiEnd(s)); + put(out, rs.strTrimAscii(s)); let t: string = s; - t = rt.strToAsciiUppercase(t); + t = rs.strToAsciiUppercase(t); put(out, t); - t = rt.strToAsciiLowercase(t); + t = rs.strToAsciiLowercase(t); put(out, t); const held: Held.Held = { n: 0, text: t }; - upperText(rt.place(() => held.text, (value) => held.text = value)); + upperText(rs.place(() => held.text, (value) => held.text = value)); put(out, held.text); - held.text = rt.strToAsciiLowercase(held.text); + held.text = rs.strToAsciiLowercase(held.text); put(out, held.text); - held.n = rt.toAsciiUppercase(held.n); - rt.byteVecPush(out, held.n); + held.n = rs.toAsciiUppercase(held.n); + rs.byteVecPush(out, held.n); } else if (_10 === 2) { - const e: rt.Iter = rt.byteSliceEscapeAscii(data); - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtEscapeAscii(e, f))); - const _221: rt.usize = rt.iterCount(e.clone()); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEscapeAscii(e, f), (f: rt.Formatter) => rt.usizeDisplay(_221, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1]])); - rt.iterExtendBytes(out, rt.iterRev(e.clone()), "next"); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(e.clone()), 255)); + const e: rs.Iter = rs.byteSliceEscapeAscii(data); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e, f))); + const _221: rs.usize = rs.iterCount(e.clone()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(e, f), (f: rs.Formatter) => rs.usizeDisplay(_221, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1]])); + rs.iterExtendBytes(out, rs.iterRev(e.clone()), "next"); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(e.clone()), 255)); } else { - const e2: rt.Iter = rt.byteSliceEscapeAscii(data); - let i: rt.usize = 0; + const e2: rs.Iter = rs.byteSliceEscapeAscii(data); + let i: rs.usize = 0; while (true) { - const _243: [rt.usize, rt.usize | undefined] = e2.sizeHint(); - const lo: rt.usize = _243[0]; - const hi: rt.usize | undefined = _243[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(lo as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_mapOr$0jad0p1(hi, 4294967295, (h: rt.usize): rt.u32 => { - return h as rt.u32; + const _243: [rs.usize, rs.usize | undefined] = e2.sizeHint(); + const lo: rs.usize = _243[0]; + const hi: rs.usize | undefined = _243[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(lo as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_mapOr$0p20wlb(hi, 4294967295, (h: rs.usize): rs.u32 => { + return h as rs.u32; })))); - if (!isSomeAnd$09tpccf(rt.byteSliceGet(data, i), (b4: rt.u8): boolean => { + if (!isSomeAnd$1s2u5lz(rs.byteSliceGet(data, i), (b4: rs.u8): boolean => { return (b4 & 1) === 1; })) { - next = rt.iterToOption(e2.next()); + next = rs.iterToOption(e2.next()); } else { - next = rt.iterToOption(e2.nextBack()); + next = rs.iterToOption(e2.nextBack()); } if (next !== undefined) { - rt.byteVecPush(out, next); - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtEscapeAscii(e2, f))); - rt.iterExtendBytes(out, e2.clone(), "next"); - i = rt.usizeAdd(i, 1); + rs.byteVecPush(out, next); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtEscapeAscii(e2, f))); + rs.iterExtendBytes(out, e2.clone(), "next"); + i = rs.usizeAdd(i, 1); } else { break b0; } @@ -328,20 +328,20 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `s[a..b]`'s case changed through the `&mut str` it is given. */ -export function upperPart(s: rt.Place, a: rt.usize, b: rt.usize): void { - const _5: rt.Place = rt.strPart(s, a, b); - _5.v = rt.strToAsciiUppercase(_5.v); +export function upperPart(s: rs.Place, a: rs.usize, b: rs.usize): void { + const _5: rs.Place = rs.strPart(s, a, b); + _5.v = rs.strToAsciiUppercase(_5.v); } /** * A part `get_mut` or `split_at_mut_checked` may give, upper-cased and put, or 0xfe if * it gave none. */ -export function putUpper(out: rt.ByteVec, part: rt.Place | undefined): void { +export function putUpper(out: rs.ByteVec, part: rs.Place | undefined): void { if (part === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - part.v = rt.strToAsciiUppercase(part.v); + part.v = rs.strToAsciiUppercase(part.v); put(out, part.v); } } @@ -352,7 +352,7 @@ export function putUpper(out: rt.ByteVec, part: rt.Place | undefined): v * two past the end, the `String` put after each change. A part off a char boundary, * backwards, or out of bounds panics as std's does; a checked one gives `None`. */ -export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let text!: string; if ((kind & 16) === 0) { text = "aÉbࠀc😀dZ"; @@ -360,104 +360,104 @@ export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { text = ""; } const _7: string = text; - const at: (a0: rt.usize) => rt.usize = (i: rt.usize): rt.usize => { - return option_mapOr$1t0muvr(rt.byteSliceGet(data, i), 0, (_2: rt.u8): rt.usize => { - return rt.usizeRem(_2 as rt.usize, rt.usizeAdd(rt.stringLen(_7), 3)); + const at: (a0: rs.usize) => rs.usize = (i: rs.usize): rs.usize => { + return option_mapOr$1d4bp7c(rs.byteSliceGet(data, i), 0, (_2: rs.u8): rs.usize => { + return rs.usizeRem(_2 as rs.usize, rs.usizeAdd(rs.stringLen(_7), 3)); }); }; - const _10: [rt.usize, rt.usize] = [at(0), at(1)]; - const a: rt.usize = _10[0]; - const b: rt.usize = _10[1]; + const _10: [rs.usize, rs.usize] = [at(0), at(1)]; + const a: rs.usize = _10[0]; + const b: rs.usize = _10[1]; let s: string = text; - const pair: [rt.u8, string] = [7, text]; + const pair: [rs.u8, string] = [7, text]; const array: string[] = ["q", text]; - const v: rt.Vec = rt.vecFrom([text, text]); - const _32: rt.u8 = rt.u8Rem(kind, 8); + const v: rs.Vec = rs.vecFrom([text, text]); + const _32: rs.u8 = rs.u8Rem(kind, 8); if (_32 === 0) { - s = rt.strToAsciiUppercase(s); + s = rs.strToAsciiUppercase(s); put(out, s); - const _41: rt.Place = rt.strPart(rt.place(() => s, (value15) => s = value15), a, b); - _41.v = rt.strToAsciiLowercase(_41.v); + const _41: rs.Place = rs.strPart(rs.place(() => s, (value15) => s = value15), a, b); + _41.v = rs.strToAsciiLowercase(_41.v); put(out, s); } else if (_32 === 1) { - pair[1] = rt.strToAsciiUppercase(pair[1]); + pair[1] = rs.strToAsciiUppercase(pair[1]); put(out, pair[1]); - const _54: rt.Place = rt.strPart(rt.place(() => pair[1], (value14) => pair[1] = value14), a); - _54.v = rt.strToAsciiLowercase(_54.v); + const _54: rs.Place = rs.strPart(rs.place(() => pair[1], (value14) => pair[1] = value14), a); + _54.v = rs.strToAsciiLowercase(_54.v); put(out, pair[1]); - rt.byteVecPush(out, pair[0]); + rs.byteVecPush(out, pair[0]); } else if (_32 === 2) { - array[1] = rt.strToAsciiUppercase(array[1]); + array[1] = rs.strToAsciiUppercase(array[1]); put(out, array[1]); - const _73: rt.Place = rt.strPart(rt.place(() => array[1], (value13) => array[1] = value13), 0, b); - _73.v = rt.strToAsciiLowercase(_73.v); + const _73: rs.Place = rs.strPart(rs.place(() => array[1], (value13) => array[1] = value13), 0, b); + _73.v = rs.strToAsciiLowercase(_73.v); put(out, array[1]); put(out, array[0]); } else if (_32 === 3) { - const iter: rt.Iter> = rt.iterSliceMut(v.items); + const iter: rs.Iter> = rs.iterSliceMut(v.items); while (true) { - const _93: rt.Place | rt.Done = iter.next(); - if (_93 === rt.DONE) { + const _93: rs.Place | rs.Done = iter.next(); + if (_93 === rs.DONE) { break; } - _93.v = rt.strToAsciiUppercase(_93.v); + _93.v = rs.strToAsciiUppercase(_93.v); } - const at6 = rt.idx(v.items, 0); - const _100: rt.Place = rt.strPart(rt.place(() => v.items[at6], (value11) => v.items[at6] = value11), 0); - _100.v = rt.strToAsciiLowercase(_100.v); - const at7 = rt.idx(v.items, 1); - const _105: rt.Place = rt.strPart(rt.place(() => v.items[at7], (value12) => v.items[at7] = value12), a, b); - _105.v = rt.strToAsciiLowercase(_105.v); - put(out, v.items[rt.idx(v.items, 0)]); - put(out, v.items[rt.idx(v.items, 1)]); + const at6 = rs.idx(v.items, 0); + const _100: rs.Place = rs.strPart(rs.place(() => v.items[at6], (value11) => v.items[at6] = value11), 0); + _100.v = rs.strToAsciiLowercase(_100.v); + const at7 = rs.idx(v.items, 1); + const _105: rs.Place = rs.strPart(rs.place(() => v.items[at7], (value12) => v.items[at7] = value12), a, b); + _105.v = rs.strToAsciiLowercase(_105.v); + put(out, v.items[rs.idx(v.items, 0)]); + put(out, v.items[rs.idx(v.items, 1)]); } else if (_32 === 4) { - const _119: [rt.Place, rt.Place] = rt.strSplitAtMut(rt.place(() => s, (value10) => s = value10), a); - _119[0].v = rt.strToAsciiUppercase(_119[0].v); - _119[1].v = rt.strToAsciiUppercase(_119[1].v); - _119[0].v = rt.strToAsciiLowercase(_119[0].v); + const _119: [rs.Place, rs.Place] = rs.strSplitAtMut(rs.place(() => s, (value10) => s = value10), a); + _119[0].v = rs.strToAsciiUppercase(_119[0].v); + _119[1].v = rs.strToAsciiUppercase(_119[1].v); + _119[0].v = rs.strToAsciiLowercase(_119[0].v); put(out, _119[0].v); put(out, _119[1].v); - const _131: [rt.Place, rt.Place] = rt.strSplitAtMut(_119[1], rt.usizeSaturatingSub(b, a)); - _131[1].v = rt.strToAsciiLowercase(_131[1].v); + const _131: [rs.Place, rs.Place] = rs.strSplitAtMut(_119[1], rs.usizeSaturatingSub(b, a)); + _131[1].v = rs.strToAsciiLowercase(_131[1].v); put(out, _131[0].v); put(out, _131[1].v); put(out, s); } else if (_32 === 5) { - putUpper(out, rt.strGetMut(rt.place(() => s, (value7) => s = value7), a, b)); - putUpper(out, rt.strGetMut(rt.place(() => pair[1], (value8) => pair[1] = value8), a)); - const at4 = rt.idx(v.items, 1); - putUpper(out, rt.strGetMut(rt.place(() => v.items[at4], (value9) => v.items[at4] = value9), 0, b)); + putUpper(out, rs.strGetMut(rs.place(() => s, (value7) => s = value7), a, b)); + putUpper(out, rs.strGetMut(rs.place(() => pair[1], (value8) => pair[1] = value8), a)); + const at4 = rs.idx(v.items, 1); + putUpper(out, rs.strGetMut(rs.place(() => v.items[at4], (value9) => v.items[at4] = value9), 0, b)); put(out, s); put(out, pair[1]); - put(out, v.items[rt.idx(v.items, 1)]); + put(out, v.items[rs.idx(v.items, 1)]); } else if (_32 === 6) { - const _168: [rt.Place, rt.Place] | undefined = rt.strSplitAtMutChecked(rt.place(() => array[1], (value5) => array[1] = value5), a); + const _168: [rs.Place, rs.Place] | undefined = rs.strSplitAtMutChecked(rs.place(() => array[1], (value5) => array[1] = value5), a); if (_168 === undefined) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { - _168[1].v = rt.strToAsciiUppercase(_168[1].v); - putUpper(out, rt.strGetMut(_168[0], rt.min(b, rt.stringLen(_168[0].v)))); + _168[1].v = rs.strToAsciiUppercase(_168[1].v); + putUpper(out, rs.strGetMut(_168[0], rs.min(b, rs.stringLen(_168[0].v)))); } put(out, array[1]); let held: string | undefined = text; - const _191: rt.Place | undefined = held === undefined ? undefined : rt.place(() => held as string, (value6) => held = value6); + const _191: rs.Place | undefined = held === undefined ? undefined : rs.place(() => held as string, (value6) => held = value6); if (_191 !== undefined) { - _191.v = rt.strToAsciiUppercase(_191.v); + _191.v = rs.strToAsciiUppercase(_191.v); } put(out, option_unwrapOr$1iemzn8(option_asDeref$0w8at8i(held), "-")); } else { - const at2 = rt.idx(v.items, 1); - upperPart(rt.strPart(rt.place(() => v.items[at2], (value) => v.items[at2] = value), a), 0, rt.usizeSaturatingSub(b, a)); - put(out, v.items[rt.idx(v.items, 1)]); - upperPart(rt.place(() => s, (value2) => s = value2), a, b); - put(out, rt.strPart(rt.place(() => s, (value3) => s = value3), 0, a).v); - put(out, rt.strPart(rt.place(() => s, (value4) => s = value4), a).v); - const leaked: rt.Place = { v: pair[1] }; - const _234: rt.Place = rt.strPart(leaked, rt.min(b, a)); - _234.v = rt.strToAsciiUppercase(_234.v); + const at2 = rs.idx(v.items, 1); + upperPart(rs.strPart(rs.place(() => v.items[at2], (value) => v.items[at2] = value), a), 0, rs.usizeSaturatingSub(b, a)); + put(out, v.items[rs.idx(v.items, 1)]); + upperPart(rs.place(() => s, (value2) => s = value2), a, b); + put(out, rs.strPart(rs.place(() => s, (value3) => s = value3), 0, a).v); + put(out, rs.strPart(rs.place(() => s, (value4) => s = value4), a).v); + const leaked: rs.Place = { v: pair[1] }; + const _234: rs.Place = rs.strPart(leaked, rs.min(b, a)); + _234.v = rs.strToAsciiUppercase(_234.v); put(out, leaked.v); - const empty: rt.Place = { v: "" }; - empty.v = rt.strToAsciiUppercase(empty.v); + const empty: rs.Place = { v: "" }; + empty.v = rs.strToAsciiUppercase(empty.v); put(out, empty.v); } } diff --git a/ts/fixtures/lang/ascii/expected/core/option.ts b/ts/fixtures/lang/ascii/expected/core/option.ts index af5bdbb10..40c09ab17 100644 --- a/ts/fixtures/lang/ascii/expected/core/option.ts +++ b/ts/fixtures/lang/ascii/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } @@ -16,14 +16,14 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0l7j3f6(self: rt.usize | undefined, default_: rt.usize): rt.usize { +export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize): rs.usize { if (self === undefined) { return default_; } @@ -37,21 +37,21 @@ export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string) return self; } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0jad0p1(self: rt.usize | undefined, default_: rt.u32, f: (a0: rt.usize) => rt.u32): rt.u32 { +export function mapOr$0p20wlb(self: rs.usize | undefined, default_: rs.u32, f: (a0: rs.usize) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/ascii/expected/harness.ts b/ts/fixtures/lang/ascii/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/ascii/expected/harness.ts +++ b/ts/fixtures/lang/ascii/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/ascii/expected/lib.ts b/ts/fixtures/lang/ascii/expected/lib.ts index b310fecc3..cacd04baa 100644 --- a/ts/fixtures/lang/ascii/expected/lib.ts +++ b/ts/fixtures/lang/ascii/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { bytes, chars, slices, parts } from "./ascii.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["ascii::bytes", bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::chars", chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::slices", slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ascii::parts", parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["ascii::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ascii::chars", chars as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ascii::slices", slices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ascii::parts", parts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/atomics/expected/atomics.Stats.ts b/ts/fixtures/lang/atomics/expected/atomics.Stats.ts index e533ac0fe..604d71021 100644 --- a/ts/fixtures/lang/atomics/expected/atomics.Stats.ts +++ b/ts/fixtures/lang/atomics/expected/atomics.Stats.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Stats { - return { sent: new rt.Atomic(0), open: new rt.Atomic(false), peers: new rt.Atomic(0) }; + return { sent: new rs.Atomic(0), open: new rs.Atomic(false), peers: new rs.Atomic(0) }; } /** Counters shared by `Arc`, in fields, as moq-net's stats are. */ export interface Stats { - sent: rt.Atomic; - open: rt.Atomic; - peers: rt.Atomic; + sent: rs.Atomic; + open: rs.Atomic; + peers: rs.Atomic; } //# sourceMappingURL=atomics.Stats.ts.map diff --git a/ts/fixtures/lang/atomics/expected/atomics.ts b/ts/fixtures/lang/atomics/expected/atomics.ts index 7e1e180da..612a65a9c 100644 --- a/ts/fixtures/lang/atomics/expected/atomics.ts +++ b/ts/fixtures/lang/atomics/expected/atomics.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Stats from "./atomics.Stats.ts"; -import { thenSome$0kwiij6, thenSome$0n2gkz4, thenSome$0tjggir, thenSome$1s4itlz, thenSome$0jkru5t, thenSome$0b23a33, thenSome$1af3oea, thenSome$1ugl8af, thenSome$0d5am30, thenSome$07z8k4h } from "./core/bool.ts"; -import { isSomeAnd$09tpccf } from "./core/option.ts"; -import { unwrapOr$1pnwyus as result_unwrapOr$1pnwyus, unwrapOr$0xokg9f as result_unwrapOr$0xokg9f, unwrapOr$1imvcmw as result_unwrapOr$1imvcmw, unwrapOr$06fxvgg as result_unwrapOr$06fxvgg, unwrapOr$0gr9tn5 as result_unwrapOr$0gr9tn5, unwrapOr$0hnup9g as result_unwrapOr$0hnup9g, unwrapOr$1dnnsw8 as result_unwrapOr$1dnnsw8, unwrapOr$1k2j44a as result_unwrapOr$1k2j44a, unwrapOr$0jmm2jy as result_unwrapOr$0jmm2jy, unwrapOr$1czbd6g as result_unwrapOr$1czbd6g } from "./core/result.ts"; +import { thenSome$0dd86kk, thenSome$05ku0zn, thenSome$179x8nl, thenSome$0kk1b17, thenSome$0v7hg8b, thenSome$1gvhopg, thenSome$1bahm2u, thenSome$0be218t, thenSome$0quywni, thenSome$12zzmkc } from "./core/bool.ts"; +import { isSomeAnd$1s2u5lz } from "./core/option.ts"; +import { unwrapOr$0u1litd as result_unwrapOr$0u1litd, unwrapOr$14lx6wa as result_unwrapOr$14lx6wa, unwrapOr$1vlkfwl as result_unwrapOr$1vlkfwl, unwrapOr$08ab42n as result_unwrapOr$08ab42n, unwrapOr$1495lg8 as result_unwrapOr$1495lg8, unwrapOr$0jt2sr8 as result_unwrapOr$0jt2sr8, unwrapOr$0sf2nxo as result_unwrapOr$0sf2nxo, unwrapOr$0ca9158 as result_unwrapOr$0ca9158, unwrapOr$0gfqfcv as result_unwrapOr$0gfqfcv, unwrapOr$0kcfya3 as result_unwrapOr$0kcfya3 } from "./core/result.ts"; /** An ordering from `b`: one of `valid`, or from 0xf0 on any, which may panic. */ -export function order(b: rt.u8, valid: rt.AtomicOrdering[]): rt.AtomicOrdering { +export function order(b: rs.u8, valid: rs.AtomicOrdering[]): rs.AtomicOrdering { if (!(b >= 240)) { - const _12: rt.usize = rt.usizeRem(b as rt.usize, valid.length); - rt.idx(valid, _12); + const _12: rs.usize = rs.usizeRem(b as rs.usize, valid.length); + rs.idx(valid, _12); return valid[_12]; } - const _5: rt.usize = rt.usizeRem(b as rt.usize, [0, 1, 2, 3, 4].length); + const _5: rs.usize = rs.usizeRem(b as rs.usize, [0, 1, 2, 3, 4].length); if (!(_5 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _5); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _5); } return [0, 1, 2, 3, 4][_5]; } @@ -24,70 +24,70 @@ export function order(b: rt.u8, valid: rt.AtomicOrdering[]): rt.AtomicOrdering { * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.i16; - let current!: rt.i16; - let result!: rt.Result; - let x!: rt.i16; - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i16 = rt.i16FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.i16 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function i16s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.i16; + let current!: rs.i16; + let result!: rs.Result; + let x!: rs.i16; + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i16 = rs.i16FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.i16 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.i16 = rt.i16FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.i16 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.i16 = rs.i16FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.i16 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.i16WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.i16WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.i16WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.i16WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.i16WrappingAdd(v, 1); + current = rs.i16WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -95,112 +95,112 @@ export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i16): rt.i16 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.i16): rs.i16 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i16CheckedAdd(x6, v); + return rs.i16CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.i16WrappingAdd(_98.error, 1); + old = rs.i16WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i16): rt.i16 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.i16): rs.i16 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i16WrappingSub(x5, v) ^ 1; + return rs.i16WrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$1pnwyus(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i16): rt.i16 | undefined => { - return thenSome$0kwiij6(x4 !== v, v); + old = result_unwrapOr$0u1litd(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.i16): rs.i16 | undefined => { + return thenSome$0dd86kk(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.i32; - let current!: rt.i32; - let result!: rt.Result; - let x!: rt.i32; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i32 = rt.i32FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.i32 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function i32s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.i32; + let current!: rs.i32; + let result!: rs.Result; + let x!: rs.i32; + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i32 = rs.i32FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.i32 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.i32 = rt.i32FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.i32 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.i32 = rs.i32FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.i32 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.i32WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.i32WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.i32WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.i32WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.i32WrappingAdd(v, 1); + current = rs.i32WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -208,112 +208,112 @@ export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i32): rt.i32 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.i32): rs.i32 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i32CheckedAdd(x6, v); + return rs.i32CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.i32WrappingAdd(_98.error, 1); + old = rs.i32WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i32): rt.i32 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.i32): rs.i32 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i32WrappingSub(x5, v) ^ 1; + return rs.i32WrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$0xokg9f(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i32): rt.i32 | undefined => { - return thenSome$0n2gkz4(x4 !== v, v); + old = result_unwrapOr$14lx6wa(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.i32): rs.i32 | undefined => { + return thenSome$05ku0zn(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.i64; - let current!: rt.i64; - let result!: rt.Result; - let x!: rt.i64; - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i64 = rt.i64FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.i64 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function i64s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.i64; + let current!: rs.i64; + let result!: rs.Result; + let x!: rs.i64; + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i64 = rs.i64FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.i64 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.i64 = rt.i64FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.i64 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.i64 = rs.i64FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.i64 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.i64WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.i64WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.i64WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.i64WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => rt.i64And(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.i64And(old, value), v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => rt.i64Or(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.i64Or(old, value), v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => rt.i64Xor(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.i64Xor(old, value), v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.i64Max, v, any); + old = rs.atomicFetch(atomic, rs.i64Max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.i64Min, v, any); + old = rs.atomicFetch(atomic, rs.i64Min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.i64WrappingAdd(v, 1); + current = rs.i64WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.i64Eq); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure, rs.i64Eq); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.i64Eq); + result = rs.atomicCompareExchange(atomic, current, v, any, failure, rs.i64Eq); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -321,112 +321,112 @@ export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i64): rt.i64 | undefined => { - rt.byteVecPush(out, 192); - if (rt.i64Ne(x6, v)) { + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.i64): rs.i64 | undefined => { + rs.byteVecPush(out, 192); + if (rs.i64Ne(x6, v)) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i64CheckedAdd(x6, v); - }, rt.i64Eq); + return rs.i64CheckedAdd(x6, v); + }, rs.i64Eq); if (_98.ok) { old = _98.value; } else { - old = rt.i64WrappingAdd(_98.error, 1); + old = rs.i64WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i64): rt.i64 => { - rt.byteVecPush(out, 193); - if (rt.i64Ne(x5, v)) { + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.i64): rs.i64 => { + rs.byteVecPush(out, 193); + if (rs.i64Ne(x5, v)) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i64Xor(rt.i64WrappingSub(x5, v), 1); - }, rt.i64Eq); + return rs.i64Xor(rs.i64WrappingSub(x5, v), 1); + }, rs.i64Eq); } else if (_60 === 14) { - old = result_unwrapOr$1imvcmw(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(rt.i64Ne(x4, v), v); - }, rt.i64Eq), v); + old = result_unwrapOr$1vlkfwl(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.i64): rs.i64 | undefined => { + return thenSome$179x8nl(rs.i64Ne(x4, v), v); + }, rs.i64Eq), v); } else { - const _116: rt.Place = atomic; - _116.v = rt.i64Xor(_116.v, v); - old = rt.atomicLoad(atomic, 4); + const _116: rs.Place = atomic; + _116.v = rs.i64Xor(_116.v, v); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.i8; - let current!: rt.i8; - let result!: rt.Result; - let x!: rt.i8; +export function i8s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.i8; + let current!: rs.i8; + let result!: rs.Result; + let x!: rs.i8; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i8 = rt.i8FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.i8 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i8 = rs.i8FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.i8 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.i8 = rt.i8FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.i8 = _43; + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.i8 = rs.i8FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.i8 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.i8WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.i8WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.i8WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.i8WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.i8WrappingAdd(v, 1); + current = rs.i8WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -434,112 +434,112 @@ export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.i8): rt.i8 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.i8): rs.i8 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i8CheckedAdd(x6, v); + return rs.i8CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.i8WrappingAdd(_98.error, 1); + old = rs.i8WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.i8): rt.i8 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.i8): rs.i8 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.i8WrappingSub(x5, v) ^ 1; + return rs.i8WrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$06fxvgg(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.i8): rt.i8 | undefined => { - return thenSome$1s4itlz(x4 !== v, v); + old = result_unwrapOr$08ab42n(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.i8): rs.i8 | undefined => { + return thenSome$0kk1b17(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.isize; - let current!: rt.isize; - let result!: rt.Result; - let x!: rt.isize; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.isize = rt.isizeFromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.isize = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function isizes(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.isize; + let current!: rs.isize; + let result!: rs.Result; + let x!: rs.isize; + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.isize = rs.isizeFromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.isize = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.isize = rt.isizeFromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.isize = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.isize = rs.isizeFromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.isize = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.isizeWrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.isizeWrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.isizeWrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.isizeWrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.isizeWrappingAdd(v, 1); + current = rs.isizeWrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -547,112 +547,112 @@ export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.isize): rt.isize | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.isize): rs.isize | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.isizeCheckedAdd(x6, v); + return rs.isizeCheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.isizeWrappingAdd(_98.error, 1); + old = rs.isizeWrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.isize): rt.isize => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.isize): rs.isize => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.isizeWrappingSub(x5, v) ^ 1; + return rs.isizeWrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$0gr9tn5(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.isize): rt.isize | undefined => { - return thenSome$0jkru5t(x4 !== v, v); + old = result_unwrapOr$1495lg8(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.isize): rs.isize | undefined => { + return thenSome$0v7hg8b(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.u16; - let current!: rt.u16; - let result!: rt.Result; - let x!: rt.u16; - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u16 = rt.u16FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.u16 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function u16s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.u16; + let current!: rs.u16; + let result!: rs.Result; + let x!: rs.u16; + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u16 = rs.u16FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.u16 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.u16 = rt.u16FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.u16 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.u16 = rs.u16FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.u16 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.u16WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.u16WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.u16WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.u16WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.u16WrappingAdd(v, 1); + current = rs.u16WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -660,112 +660,112 @@ export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u16): rt.u16 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.u16): rs.u16 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u16CheckedAdd(x6, v); + return rs.u16CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.u16WrappingAdd(_98.error, 1); + old = rs.u16WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u16): rt.u16 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.u16): rs.u16 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u16WrappingSub(x5, v) ^ 1; + return rs.u16WrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$0hnup9g(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u16): rt.u16 | undefined => { - return thenSome$0b23a33(x4 !== v, v); + old = result_unwrapOr$0jt2sr8(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.u16): rs.u16 | undefined => { + return thenSome$1gvhopg(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.u32; - let current!: rt.u32; - let result!: rt.Result; - let x!: rt.u32; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u32 = rt.u32FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.u32 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function u32s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.u32; + let current!: rs.u32; + let result!: rs.Result; + let x!: rs.u32; + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u32 = rs.u32FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.u32 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.u32 = rt.u32FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.u32 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.u32 = rs.u32FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.u32 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.u32WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.u32WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.u32WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.u32WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.u32WrappingAdd(v, 1); + current = rs.u32WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -773,112 +773,112 @@ export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u32): rt.u32 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.u32): rs.u32 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u32CheckedAdd(x6, v); + return rs.u32CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.u32WrappingAdd(_98.error, 1); + old = rs.u32WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u32): rt.u32 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.u32): rs.u32 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return (rt.u32WrappingSub(x5, v) ^ 1) >>> 0; + return (rs.u32WrappingSub(x5, v) ^ 1) >>> 0; }); } else if (_60 === 14) { - old = result_unwrapOr$1dnnsw8(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u32): rt.u32 | undefined => { - return thenSome$1af3oea(x4 !== v, v); + old = result_unwrapOr$0sf2nxo(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.u32): rs.u32 | undefined => { + return thenSome$1bahm2u(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = (_116.v ^ v) >>> 0; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.u64; - let current!: rt.u64; - let result!: rt.Result; - let x!: rt.u64; - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u64 = rt.u64FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.u64 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function u64s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.u64; + let current!: rs.u64; + let result!: rs.Result; + let x!: rs.u64; + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u64 = rs.u64FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.u64 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.u64 = rt.u64FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.u64 = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.u64 = rs.u64FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.u64 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.u64WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.u64WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.u64WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.u64WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => rt.u64And(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.u64And(old, value), v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => rt.u64Or(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.u64Or(old, value), v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => rt.u64Xor(old, value), v, any); + old = rs.atomicFetch(atomic, (old, value) => rs.u64Xor(old, value), v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.u64Max, v, any); + old = rs.atomicFetch(atomic, rs.u64Max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.u64Min, v, any); + old = rs.atomicFetch(atomic, rs.u64Min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.u64WrappingAdd(v, 1); + current = rs.u64WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.u64Eq); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure, rs.u64Eq); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure, rt.u64Eq); + result = rs.atomicCompareExchange(atomic, current, v, any, failure, rs.u64Eq); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -886,112 +886,112 @@ export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u64): rt.u64 | undefined => { - rt.byteVecPush(out, 192); - if (rt.u64Ne(x6, v)) { + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.u64): rs.u64 | undefined => { + rs.byteVecPush(out, 192); + if (rs.u64Ne(x6, v)) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u64CheckedAdd(x6, v); - }, rt.u64Eq); + return rs.u64CheckedAdd(x6, v); + }, rs.u64Eq); if (_98.ok) { old = _98.value; } else { - old = rt.u64WrappingAdd(_98.error, 1); + old = rs.u64WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u64): rt.u64 => { - rt.byteVecPush(out, 193); - if (rt.u64Ne(x5, v)) { + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.u64): rs.u64 => { + rs.byteVecPush(out, 193); + if (rs.u64Ne(x5, v)) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u64Xor(rt.u64WrappingSub(x5, v), 1); - }, rt.u64Eq); + return rs.u64Xor(rs.u64WrappingSub(x5, v), 1); + }, rs.u64Eq); } else if (_60 === 14) { - old = result_unwrapOr$1k2j44a(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u64): rt.u64 | undefined => { - return thenSome$1ugl8af(rt.u64Ne(x4, v), v); - }, rt.u64Eq), v); + old = result_unwrapOr$0ca9158(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.u64): rs.u64 | undefined => { + return thenSome$0be218t(rs.u64Ne(x4, v), v); + }, rs.u64Eq), v); } else { - const _116: rt.Place = atomic; - _116.v = rt.u64Xor(_116.v, v); - old = rt.atomicLoad(atomic, 4); + const _116: rs.Place = atomic; + _116.v = rs.u64Xor(_116.v, v); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.u8; - let current!: rt.u8; - let result!: rt.Result; - let x!: rt.u8; +export function u8s(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.u8; + let current!: rs.u8; + let result!: rs.Result; + let x!: rs.u8; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u8 = rt.u8FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.u8 = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u8 = rs.u8FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.u8 = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.u8 = rt.u8FromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.u8 = _43; + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.u8 = rs.u8FromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.u8 = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.u8WrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.u8WrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.u8WrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.u8WrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => old & value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old & value, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => old | value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old | value, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => old ^ value, v, any); + old = rs.atomicFetch(atomic, (old, value) => old ^ value, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.u8WrappingAdd(v, 1); + current = rs.u8WrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -999,112 +999,112 @@ export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.u8): rt.u8 | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.u8): rs.u8 | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u8CheckedAdd(x6, v); + return rs.u8CheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.u8WrappingAdd(_98.error, 1); + old = rs.u8WrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.u8): rt.u8 => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.u8): rs.u8 => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.u8WrappingSub(x5, v) ^ 1; + return rs.u8WrappingSub(x5, v) ^ 1; }); } else if (_60 === 14) { - old = result_unwrapOr$0jmm2jy(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(x4 !== v, v); + old = result_unwrapOr$0gfqfcv(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = _116.v ^ v; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(atomic.v))); } /** * Steps of an operation, an ordering, and an operand on one atomic, each putting * what it read. */ -export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { - let old!: rt.usize; - let current!: rt.usize; - let result!: rt.Result; - let x!: rt.usize; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.usize = rt.usizeFromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const first: rt.usize = _18; - let data2: rt.ByteSlice = _20; - const atomic: rt.Atomic = new rt.Atomic(first); +export function usizes(data: rs.ByteSlice, out: rs.ByteVec): void { + let old!: rs.usize; + let current!: rs.usize; + let result!: rs.Result; + let x!: rs.usize; + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.usize = rs.usizeFromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const first: rs.usize = _18; + let data2: rs.ByteSlice = _20; + const atomic: rs.Atomic = new rs.Atomic(first); while (data2.length >= 2) { - const op: rt.u8 = data2.data[data2.start]; - const b: rt.u8 = data2.data[data2.start + 1]; - const rest: rt.ByteSlice = rt.byteSliceRange(data2, 2); - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(rest.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(rest, 0, n2)); - const _43: rt.usize = rt.usizeFromBeBytes(buf2); - const _45: rt.ByteSlice = rt.byteSliceRange(rest, n2); - const v: rt.usize = _43; + const op: rs.u8 = data2.data[data2.start]; + const b: rs.u8 = data2.data[data2.start + 1]; + const rest: rs.ByteSlice = rs.byteSliceRange(data2, 2); + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(rest.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(rest, 0, n2)); + const _43: rs.usize = rs.usizeFromBeBytes(buf2); + const _45: rs.ByteSlice = rs.byteSliceRange(rest, n2); + const v: rs.usize = _43; data2 = _45; - const b2: rt.u8 = b; - const op2: rt.u8 = op; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const failure: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _60: rt.u8 = rt.u8Rem(op2, 16); + const b2: rs.u8 = b; + const op2: rs.u8 = op; + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const failure: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _60: rs.u8 = rs.u8Rem(op2, 16); if (_60 === 0) { - const _63: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(atomic, _63); + const _63: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(atomic, _63); } else if (_60 === 1) { - const _68: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(atomic, v, _68); + const _68: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(atomic, v, _68); old = v; } else if (_60 === 2) { - old = rt.atomicSwap(atomic, v, any); + old = rs.atomicSwap(atomic, v, any); } else if (_60 === 3) { - old = rt.atomicFetch(atomic, rt.usizeWrappingAdd, v, any); + old = rs.atomicFetch(atomic, rs.usizeWrappingAdd, v, any); } else if (_60 === 4) { - old = rt.atomicFetch(atomic, rt.usizeWrappingSub, v, any); + old = rs.atomicFetch(atomic, rs.usizeWrappingSub, v, any); } else if (_60 === 5) { - old = rt.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old & value) >>> 0, v, any); } else if (_60 === 6) { - old = rt.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old | value) >>> 0, v, any); } else if (_60 === 7) { - old = rt.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); + old = rs.atomicFetch(atomic, (old, value) => (old ^ value) >>> 0, v, any); } else if (_60 === 8) { - old = rt.atomicFetch(atomic, rt.max, v, any); + old = rs.atomicFetch(atomic, rs.max, v, any); } else if (_60 === 9) { - old = rt.atomicFetch(atomic, rt.min, v, any); + old = rs.atomicFetch(atomic, rs.min, v, any); } else if (_60 === 10 || _60 === 11) { if (!((b2 & 1) === 0)) { - current = rt.usizeWrappingAdd(v, 1); + current = rs.usizeWrappingAdd(v, 1); } else { - current = rt.atomicLoad(atomic, 0); + current = rs.atomicLoad(atomic, 0); } - if (!(rt.u8Rem(op2, 16) === 10)) { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + if (!(rs.u8Rem(op2, 16) === 10)) { + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } else { - result = rt.atomicCompareExchange(atomic, current, v, any, failure); + result = rs.atomicCompareExchange(atomic, current, v, any, failure); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { x = result.value; } else { @@ -1112,141 +1112,141 @@ export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { } old = x; } else if (_60 === 12) { - const _98: rt.Result = rt.atomicTryUpdate(atomic, any, failure, (x6: rt.usize): rt.usize | undefined => { - rt.byteVecPush(out, 192); + const _98: rs.Result = rs.atomicTryUpdate(atomic, any, failure, (x6: rs.usize): rs.usize | undefined => { + rs.byteVecPush(out, 192); if (x6 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return rt.usizeCheckedAdd(x6, v); + return rs.usizeCheckedAdd(x6, v); }); if (_98.ok) { old = _98.value; } else { - old = rt.usizeWrappingAdd(_98.error, 1); + old = rs.usizeWrappingAdd(_98.error, 1); } } else if (_60 === 13) { - old = rt.atomicUpdate(atomic, any, failure, (x5: rt.usize): rt.usize => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(atomic, any, failure, (x5: rs.usize): rs.usize => { + rs.byteVecPush(out, 193); if (x5 !== v) { if ((b2 & 2) === 0) { - rt.atomicStore(atomic, v, 0); + rs.atomicStore(atomic, v, 0); } } - return (rt.usizeWrappingSub(x5, v) ^ 1) >>> 0; + return (rs.usizeWrappingSub(x5, v) ^ 1) >>> 0; }); } else if (_60 === 14) { - old = result_unwrapOr$1czbd6g(rt.atomicTryUpdate(atomic, any, failure, (x4: rt.usize): rt.usize | undefined => { - return thenSome$07z8k4h(x4 !== v, v); + old = result_unwrapOr$0kcfya3(rs.atomicTryUpdate(atomic, any, failure, (x4: rs.usize): rs.usize | undefined => { + return thenSome$12zzmkc(x4 !== v, v); }), v); } else { - const _116: rt.Place = atomic; + const _116: rs.Place = atomic; _116.v = (_116.v ^ v) >>> 0; - old = rt.atomicLoad(atomic, 4); + old = rs.atomicLoad(atomic, 4); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(old))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(old))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(atomic.v))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(atomic.v))); } -export function bools(data: rt.ByteSlice, out: rt.ByteVec): void { +export function bools(data: rs.ByteSlice, out: rs.ByteVec): void { let old!: boolean; - const flag: rt.Atomic = new rt.Atomic(isSomeAnd$09tpccf(rt.byteSliceFirst(data), (_2: rt.u8): boolean => { + const flag: rs.Atomic = new rs.Atomic(isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (_2: rs.u8): boolean => { return (_2 & 1) === 1; })); let dataData: Uint8Array = data.data; let dataStart: number = data.start; let dataLen: number = data.length; while (dataLen >= 2) { - const op: rt.u8 = dataData[dataStart]; - const b: rt.u8 = dataData[dataStart + 1]; + const op: rs.u8 = dataData[dataStart]; + const b: rs.u8 = dataData[dataStart + 1]; const restData: Uint8Array = dataData; const restStart: number = dataStart + 2; const restLen: number = dataLen - 2; dataData = restData; dataStart = restStart; dataLen = restLen; - const op2: rt.u8 = op; - const b2: rt.u8 = b; + const op2: rs.u8 = op; + const b2: rs.u8 = b; const v: boolean = (b2 & 1) === 1; - const any: rt.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); - const _23: rt.u8 = rt.u8Rem(op2, 11); + const any: rs.AtomicOrdering = order(b2, [0, 1, 2, 3, 4]); + const _23: rs.u8 = rs.u8Rem(op2, 11); if (_23 === 0) { - const _26: rt.AtomicOrdering = order(b2, [0, 2, 4]); - old = rt.atomicLoad(flag, _26); + const _26: rs.AtomicOrdering = order(b2, [0, 2, 4]); + old = rs.atomicLoad(flag, _26); } else if (_23 === 1) { - const _31: rt.AtomicOrdering = order(b2, [0, 1, 4]); - rt.atomicStore(flag, v, _31); + const _31: rs.AtomicOrdering = order(b2, [0, 1, 4]); + rs.atomicStore(flag, v, _31); old = v; } else if (_23 === 2) { - old = rt.atomicSwap(flag, v, any); + old = rs.atomicSwap(flag, v, any); } else if (_23 === 3) { - old = rt.atomicFetch(flag, (old, value) => old && value, v, any); + old = rs.atomicFetch(flag, (old, value) => old && value, v, any); } else if (_23 === 4) { - old = rt.atomicFetch(flag, (old, value) => old || value, v, any); + old = rs.atomicFetch(flag, (old, value) => old || value, v, any); } else if (_23 === 5) { - old = rt.atomicFetch(flag, (old, value) => old !== value, v, any); + old = rs.atomicFetch(flag, (old, value) => old !== value, v, any); } else if (_23 === 6) { - old = rt.atomicFetch(flag, (old, value) => !(old && value), v, any); + old = rs.atomicFetch(flag, (old, value) => !(old && value), v, any); } else if (_23 === 7) { - old = rt.atomicFetch(flag, (old, value) => old !== value, true, any); + old = rs.atomicFetch(flag, (old, value) => old !== value, true, any); } else if (_23 === 8) { const _42: boolean = !v; - const _43: rt.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); - const _40: rt.Result = rt.atomicCompareExchange(flag, v, _42, any, _43); + const _43: rs.AtomicOrdering = order(b2 ^ 15, [0, 2, 4]); + const _40: rs.Result = rs.atomicCompareExchange(flag, v, _42, any, _43); if (_40.ok) { old = _40.value; } else { old = !_40.error; } } else if (_23 === 9) { - rt.fence(order(b2, [1, 2, 3, 4])); - rt.fence(order(b2 ^ 15, [1, 2, 3, 4])); + rs.fence(order(b2, [1, 2, 3, 4])); + rs.fence(order(b2 ^ 15, [1, 2, 3, 4])); old = v; } else { - old = rt.atomicUpdate(flag, any, 0, (x3: boolean): boolean => { - rt.byteVecPush(out, 193); + old = rs.atomicUpdate(flag, any, 0, (x3: boolean): boolean => { + rs.byteVecPush(out, 193); if (x3 !== v) { - rt.atomicStore(flag, v, 0); + rs.atomicStore(flag, v, 0); } return x3 !== v; }); } - rt.byteVecPush(out, old ? 1 : 0); + rs.byteVecPush(out, old ? 1 : 0); } - rt.byteVecPush(out, flag.v ? 1 : 0); + rs.byteVecPush(out, flag.v ? 1 : 0); } /** A load at an ordering passed in, as moq-net's frame does. */ -export function sent(stats: Stats.Stats, ord: rt.AtomicOrdering): rt.u64 { - return rt.atomicLoad(stats.sent, ord); +export function sent(stats: Stats.Stats, ord: rs.AtomicOrdering): rs.u64 { + return rs.atomicLoad(stats.sent, ord); } -export function shared(data: rt.ByteSlice, out: rt.ByteVec): void { - let stats2!: rt.Arc; - const stats: rt.Arc = new rt.Arc(Stats.default$Default()); - const peer: rt.Arc = rt.arcClone(stats); - for (const b of rt.byteSliceView(data)) { +export function shared(data: rs.ByteSlice, out: rs.ByteVec): void { + let stats2!: rs.Arc; + const stats: rs.Arc = new rs.Arc(Stats.default$Default()); + const peer: rs.Arc = rs.arcClone(stats); + for (const b of rs.byteSliceView(data)) { if (!((b & 1) === 0)) { stats2 = peer; } else { stats2 = stats; } - rt.atomicFetch(stats2.value.sent, rt.u64WrappingAdd, rt.u64Shl(b as rt.u64, 50), 0); - rt.atomicFetch(stats2.value.peers, rt.usizeWrappingSub, (b & 2) === 0 ? 1 : 0, 1); - rt.atomicStore(stats2.value.open, b > 128, 1); - rt.byteVecPush(out, rt.atomicLoad(stats2.value.open, 2) ? 1 : 0); + rs.atomicFetch(stats2.value.sent, rs.u64WrappingAdd, rs.u64Shl(b as rs.u64, 50), 0); + rs.atomicFetch(stats2.value.peers, rs.usizeWrappingSub, (b & 2) === 0 ? 1 : 0, 1); + rs.atomicStore(stats2.value.open, b > 128, 1); + rs.byteVecPush(out, rs.atomicLoad(stats2.value.open, 2) ? 1 : 0); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sent(peer.value, order(data.length & 0xff, [0, 2, 4]))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.atomicLoad(peer.value.peers, 4)))); - rt.byteVecPush(out, stats.strong & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(sent(peer.value, order(data.length & 0xff, [0, 2, 4]))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.atomicLoad(peer.value.peers, 4)))); + rs.byteVecPush(out, stats.strong & 0xff); peer[Symbol.dispose](); stats[Symbol.dispose](); } -export function atomics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 12); +export function atomics(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 12); if (_4 === 0) { u8s(data, out); } else if (_4 === 1) { diff --git a/ts/fixtures/lang/atomics/expected/core/bool.ts b/ts/fixtures/lang/atomics/expected/core/bool.ts index 777252c21..66f5cf5cc 100644 --- a/ts/fixtures/lang/atomics/expected/core/bool.ts +++ b/ts/fixtures/lang/atomics/expected/core/bool.ts @@ -1,71 +1,71 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0kwiij6(self: boolean, t: rt.i16): rt.i16 | undefined { +export function thenSome$0dd86kk(self: boolean, t: rs.i16): rs.i16 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0n2gkz4(self: boolean, t: rt.i32): rt.i32 | undefined { +export function thenSome$05ku0zn(self: boolean, t: rs.i32): rs.i32 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0tjggir(self: boolean, t: rt.i64): rt.i64 | undefined { +export function thenSome$179x8nl(self: boolean, t: rs.i64): rs.i64 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1s4itlz(self: boolean, t: rt.i8): rt.i8 | undefined { +export function thenSome$0kk1b17(self: boolean, t: rs.i8): rs.i8 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0jkru5t(self: boolean, t: rt.isize): rt.isize | undefined { +export function thenSome$0v7hg8b(self: boolean, t: rs.isize): rs.isize | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0b23a33(self: boolean, t: rt.u16): rt.u16 | undefined { +export function thenSome$1gvhopg(self: boolean, t: rs.u16): rs.u16 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1af3oea(self: boolean, t: rt.u32): rt.u32 | undefined { +export function thenSome$1bahm2u(self: boolean, t: rs.u32): rs.u32 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1ugl8af(self: boolean, t: rt.u64): rt.u64 | undefined { +export function thenSome$0be218t(self: boolean, t: rs.u64): rs.u64 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$07z8k4h(self: boolean, t: rt.usize): rt.usize | undefined { +export function thenSome$12zzmkc(self: boolean, t: rs.usize): rs.usize | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/atomics/expected/core/option.ts b/ts/fixtures/lang/atomics/expected/core/option.ts index 80602fe91..151982117 100644 --- a/ts/fixtures/lang/atomics/expected/core/option.ts +++ b/ts/fixtures/lang/atomics/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } diff --git a/ts/fixtures/lang/atomics/expected/core/result.ts b/ts/fixtures/lang/atomics/expected/core/result.ts index 3db834283..ca3f01eaa 100644 --- a/ts/fixtures/lang/atomics/expected/core/result.ts +++ b/ts/fixtures/lang/atomics/expected/core/result.ts @@ -1,71 +1,71 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1pnwyus(self: rt.Result, default_: rt.i16): rt.i16 { +export function unwrapOr$0u1litd(self: rs.Result, default_: rs.i16): rs.i16 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$0xokg9f(self: rt.Result, default_: rt.i32): rt.i32 { +export function unwrapOr$14lx6wa(self: rs.Result, default_: rs.i32): rs.i32 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$1imvcmw(self: rt.Result, default_: rt.i64): rt.i64 { +export function unwrapOr$1vlkfwl(self: rs.Result, default_: rs.i64): rs.i64 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$06fxvgg(self: rt.Result, default_: rt.i8): rt.i8 { +export function unwrapOr$08ab42n(self: rs.Result, default_: rs.i8): rs.i8 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$0gr9tn5(self: rt.Result, default_: rt.isize): rt.isize { +export function unwrapOr$1495lg8(self: rs.Result, default_: rs.isize): rs.isize { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$0hnup9g(self: rt.Result, default_: rt.u16): rt.u16 { +export function unwrapOr$0jt2sr8(self: rs.Result, default_: rs.u16): rs.u16 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$1dnnsw8(self: rt.Result, default_: rt.u32): rt.u32 { +export function unwrapOr$0sf2nxo(self: rs.Result, default_: rs.u32): rs.u32 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$1k2j44a(self: rt.Result, default_: rt.u64): rt.u64 { +export function unwrapOr$0ca9158(self: rs.Result, default_: rs.u64): rs.u64 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$0jmm2jy(self: rt.Result, default_: rt.u8): rt.u8 { +export function unwrapOr$0gfqfcv(self: rs.Result, default_: rs.u8): rs.u8 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$1czbd6g(self: rt.Result, default_: rt.usize): rt.usize { +export function unwrapOr$0kcfya3(self: rs.Result, default_: rs.usize): rs.usize { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/atomics/expected/harness.ts b/ts/fixtures/lang/atomics/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/atomics/expected/harness.ts +++ b/ts/fixtures/lang/atomics/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/atomics/expected/lib.ts b/ts/fixtures/lang/atomics/expected/lib.ts index 4ab22284a..aa8135f8d 100644 --- a/ts/fixtures/lang/atomics/expected/lib.ts +++ b/ts/fixtures/lang/atomics/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { atomics } from "./atomics.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["atomics::atomics", atomics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["atomics::atomics", atomics as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/borrows/expected/borrows.Noisy.ts b/ts/fixtures/lang/borrows/expected/borrows.Noisy.ts index a89cf0f2b..79f099fe7 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Noisy.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Noisy.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id when it drops. */ export class Noisy { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -19,9 +19,9 @@ export class Noisy { } export function drop$ops_Drop(self: Noisy): void { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.mutexUnlock(_5); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.mutexUnlock(_5); } //# sourceMappingURL=borrows.Noisy.ts.map diff --git a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts index 4703d0156..b39700456 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Parts.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Parts.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Tagged from "./borrows.Tagged.ts"; /** @@ -8,14 +8,14 @@ import type * as Tagged from "./borrows.Tagged.ts"; * a value that logs as it drops, which it doesn't, and bytes, which a reference views. */ export class Parts { - n: rt.u32; + n: rs.u32; text: string; - bytes: rt.ByteVec; + bytes: rs.ByteVec; tagged: Tagged.Tagged; - maybe: rt.u16 | undefined; + maybe: rs.u16 | undefined; quad: Uint8Array; - constructor(n: rt.u32, text: string, bytes: rt.ByteVec, tagged: Tagged.Tagged, maybe: rt.u16 | undefined, quad: Uint8Array) { + constructor(n: rs.u32, text: string, bytes: rs.ByteVec, tagged: Tagged.Tagged, maybe: rs.u16 | undefined, quad: Uint8Array) { this.n = n; this.text = text; this.bytes = bytes; diff --git a/ts/fixtures/lang/borrows/expected/borrows.Polling.ts b/ts/fixtures/lang/borrows/expected/borrows.Polling.ts index 4a46c300b..608726c61 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Polling.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Polling.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Polling { - return { current: new rt.Cell(undefined), held: new rt.RefCell(new rt.ByteVec()) }; + return { current: new rs.Cell(undefined), held: new rs.RefCell(new rs.ByteVec()) }; } /** What a shared reference changes, as kio's `Polling` holds it. */ export interface Polling { - current: rt.Cell<[rt.u64, rt.u64] | undefined>; - held: rt.RefCell; + current: rs.Cell<[rs.u64, rs.u64] | undefined>; + held: rs.RefCell; } //# sourceMappingURL=borrows.Polling.ts.map diff --git a/ts/fixtures/lang/borrows/expected/borrows.Probe.ts b/ts/fixtures/lang/borrows/expected/borrows.Probe.ts index 6e8d9615a..b9c8a1be8 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Probe.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Probe.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_cell_RefMut_borrows_Probe_cell_BorrowMutError, drop$Result_cell_Ref_borrows_Probe_cell_BorrowError } from "./lib.ts"; /** @@ -8,9 +8,9 @@ import { drop$Result_cell_RefMut_borrows_Probe_cell_BorrowMutError, drop$Result_ * writes, while the cell writes it. */ export class Probe { - _0: rt.Weak>; + _0: rs.Weak>; - constructor(_0: rt.Weak>) { + constructor(_0: rs.Weak>) { this._0 = _0; } @@ -19,17 +19,17 @@ export class Probe { } } -export function fmt$fmt_Debug(self: Probe, f: rt.Formatter): rt.Result { - const cell: rt.Arc> = rt.optionUnwrap(rt.weakUpgrade(self._0)); - const _8: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell.value); +export function fmt$fmt_Debug(self: Probe, f: rs.Formatter): rs.Result { + const cell: rs.Arc> = rs.optionUnwrap(rs.weakUpgrade(self._0)); + const _8: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell.value); const shared: boolean = _8.ok; drop$Result_cell_Ref_borrows_Probe_cell_BorrowError(_8); - const _13: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(cell.value); + const _13: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(cell.value); const exclusive: boolean = _13.ok; drop$Result_cell_RefMut_borrows_Probe_cell_BorrowMutError(_13); - const _19: boolean = rt.fmtAlternate(f); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(shared, f), (f: rt.Formatter) => rt.fmtBool(exclusive, f), (f: rt.Formatter) => rt.fmtBool(_19, f)]; - const _0: rt.Result = rt.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); + const _19: boolean = rs.fmtAlternate(f); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(shared, f), (f: rs.Formatter) => rs.fmtBool(exclusive, f), (f: rs.Formatter) => rs.fmtBool(_19, f)]; + const _0: rs.Result = rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); cell[Symbol.dispose](); return _0; } diff --git a/ts/fixtures/lang/borrows/expected/borrows.Shown.ts b/ts/fixtures/lang/borrows/expected/borrows.Shown.ts index 5c2a6f9f9..c9271277d 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Shown.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Shown.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Shown, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Shown, f: rs.Formatter): rs.Result { const _3: string = "Shown"; const _4: string = "cell"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.cellDebug(() => self.cell.v, f, rt.u8Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.cellDebug(() => self.cell.v, f, rs.u8Debug); const _7: string = "refcell"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.refCellDebug(self.refcell, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug)); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(self.refcell, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug)); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** What a derived `Debug` writes each cell of as its field. */ export interface Shown { - cell: rt.Cell; - refcell: rt.RefCell; + cell: rs.Cell; + refcell: rs.RefCell; } //# sourceMappingURL=borrows.Shown.ts.map diff --git a/ts/fixtures/lang/borrows/expected/borrows.Tagged.ts b/ts/fixtures/lang/borrows/expected/borrows.Tagged.ts index 93bbfb49a..aaa695d23 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.Tagged.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.Tagged.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it is cloned, with the high bit set, and as it drops; its clone's id * is one more. */ export class Tagged { - id: rt.u8; - n: rt.u32; - log: rt.Arc>; + id: rs.u8; + n: rs.u32; + log: rs.Arc>; - constructor(id: rt.u8, n: rt.u32, log: rt.Arc>) { + constructor(id: rs.u8, n: rs.u32, log: rs.Arc>) { this.id = id; this.n = n; this.log = log; @@ -24,16 +24,16 @@ export class Tagged { } export function clone$Clone(self: Tagged): Tagged { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.mutexUnlock(_5); - return new Tagged(rt.u8WrappingAdd(self.id, 1), self.n, rt.arcClone(self.log)); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.mutexUnlock(_5); + return new Tagged(rs.u8WrappingAdd(self.id, 1), self.n, rs.arcClone(self.log)); } export function drop$ops_Drop(self: Tagged): void { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.mutexUnlock(_5); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.mutexUnlock(_5); } //# sourceMappingURL=borrows.Tagged.ts.map diff --git a/ts/fixtures/lang/borrows/expected/borrows.ts b/ts/fixtures/lang/borrows/expected/borrows.ts index 02df0dc0f..46e64dd55 100644 --- a/ts/fixtures/lang/borrows/expected/borrows.ts +++ b/ts/fixtures/lang/borrows/expected/borrows.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_tuple2_u64_u64, copy$tuple2_u64_u64, drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError, drop$Result_cell_RefMut_array4_u8_cell_BorrowMutError, drop$Result_cell_RefMut_borrows_Parts_cell_BorrowMutError, drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError, drop$Result_cell_RefMut_tuple2_u16_Vec_u8_cell_BorrowMutError, drop$Result_cell_RefMut_u32_cell_BorrowMutError, drop$Result_cell_RefMut_u32_tuple2_cell_RefMut_borrows_Parts_unit, drop$Result_cell_Ref_Vec_u8_cell_BorrowError, drop$Result_cell_Ref_array4_u8_cell_BorrowError, drop$Result_cell_Ref_borrows_Parts_cell_BorrowError, drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8, drop$Result_cell_Ref_tuple2_u16_Vec_u8_cell_BorrowError, drop$Result_cell_Ref_u32_cell_BorrowError, drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts, drop$Result_cell_Ref_u32_tuple2_cell_Ref_borrows_Parts_unit, drop$tuple2_Option_cell_Ref_borrows_Tagged_Option_cell_RefMut_borrows_Tagged, drop$tuple2_Result_cell_Ref_Vec_u8_cell_BorrowError_cell_Ref_Vec_u8, drop$tuple2_cell_RefMut_slice_u8_cell_RefMut_slice_u8, drop$tuple2_cell_Ref_Vec_u8_cell_Ref_u8, drop$tuple2_cell_Ref_str_cell_RefMut_u32, drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32 } from "./lib.ts"; import * as Noisy from "./borrows.Noisy.ts"; import * as Parts from "./borrows.Parts.ts"; @@ -8,105 +8,105 @@ import * as Polling from "./borrows.Polling.ts"; import * as Probe from "./borrows.Probe.ts"; import * as Shown from "./borrows.Shown.ts"; import * as Tagged from "./borrows.Tagged.ts"; -import { thenSome$0zrlsto, thenSome$0d5am30, then$1jgls7y } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0qqbaqw as option_mapOr$0qqbaqw, mapOr$1dvn0au as option_mapOr$1dvn0au, mapOr$0ucbp7g as option_mapOr$0ucbp7g, mapOr$099335t as option_mapOr$099335t, okOr$1oufq9m as option_okOr$1oufq9m } from "./core/option.ts"; -import { map$0n1xnuw as result_map$0n1xnuw, unwrapOr$0k9nfhn as result_unwrapOr$0k9nfhn } from "./core/result.ts"; +import { thenSome$1y1lbvl, thenSome$0quywni, then$0d67oqn } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$0yt2o85 as option_mapOr$0yt2o85, mapOr$0rsyyii as option_mapOr$0rsyyii, mapOr$1idpb1d as option_mapOr$1idpb1d, mapOr$031uhqp as option_mapOr$031uhqp, okOr$1bx6za5 as option_okOr$1bx6za5 } from "./core/option.ts"; +import { map$0jl4kv2 as result_map$0jl4kv2, unwrapOr$1bnshxn as result_unwrapOr$1bnshxn } from "./core/result.ts"; /** * Each byte an operation on the cells, its value the operand; each puts what it read and * what dropped. */ -export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const count: rt.Cell = new rt.Cell(0); - const pair: rt.Cell<[rt.u64, rt.u64]> = new rt.Cell([0, 0] as [rt.u64, rt.u64]); - const noisy: rt.Cell = new rt.Cell(undefined as Noisy.Noisy | undefined); +export function borrows(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const count: rs.Cell = new rs.Cell(0); + const pair: rs.Cell<[rs.u64, rs.u64]> = new rs.Cell([0, 0] as [rs.u64, rs.u64]); + const noisy: rs.Cell = new rs.Cell(undefined as Noisy.Noisy | undefined); const polling: Polling.Polling = Polling.default$Default(); - const shared: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const owned: rt.RefCell = new rt.RefCell(new Noisy.Noisy(170, rt.arcClone(log))); - for (const op of rt.byteSliceView(data)) { - const _25: rt.u8 = rt.u8Rem(op, 10); + const shared: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const owned: rs.RefCell = new rs.RefCell(new Noisy.Noisy(170, rs.arcClone(log))); + for (const op of rs.byteSliceView(data)) { + const _25: rs.u8 = rs.u8Rem(op, 10); if (_25 === 0) { - const _28: rt.u32 = rt.u32WrappingAdd(count.v, op as rt.u32); - rt.cellSet(count, _28); + const _28: rs.u32 = rs.u32WrappingAdd(count.v, op as rs.u32); + rs.cellSet(count, _28); } else if (_25 === 1) { - const copy: [rt.u64, rt.u64] = copy$tuple2_u64_u64(copy$tuple2_u64_u64(pair.v)); - copy[0] = rt.u64Add(copy[0], op as rt.u64); - rt.byteVecPush(out, rt.u64Low(copy$tuple2_u64_u64(pair.v)[0]) & 0xff); - rt.cellSet(pair, [copy[1], copy[0]] as [rt.u64, rt.u64]); - rt.byteVecPush(out, rt.u64Low(copy$tuple2_u64_u64(pair.v)[1]) & 0xff); + const copy: [rs.u64, rs.u64] = copy$tuple2_u64_u64(copy$tuple2_u64_u64(pair.v)); + copy[0] = rs.u64Add(copy[0], op as rs.u64); + rs.byteVecPush(out, rs.u64Low(copy$tuple2_u64_u64(pair.v)[0]) & 0xff); + rs.cellSet(pair, [copy[1], copy[0]] as [rs.u64, rs.u64]); + rs.byteVecPush(out, rs.u64Low(copy$tuple2_u64_u64(pair.v)[1]) & 0xff); } else if (_25 === 2) { - rt.byteVecPush(out, rt.cellReplace(count, op as rt.u32) & 0xff); + rs.byteVecPush(out, rs.cellReplace(count, op as rs.u32) & 0xff); } else if (_25 === 3) { - const _56: Noisy.Noisy | undefined = new Noisy.Noisy(op, rt.arcClone(log)); - rt.cellSet(noisy, _56, rt.drop); + const _56: Noisy.Noisy | undefined = new Noisy.Noisy(op, rs.arcClone(log)); + rs.cellSet(noisy, _56, rs.drop); } else if (_25 === 4) { - const taken: Noisy.Noisy | undefined = rt.cellReplace(noisy, undefined); - rt.byteVecPush(out, option_mapOr$0qqbaqw(taken, 253, (n: Noisy.Noisy): rt.u8 => { + const taken: Noisy.Noisy | undefined = rs.cellReplace(noisy, undefined); + rs.byteVecPush(out, option_mapOr$0yt2o85(taken, 253, (n: Noisy.Noisy): rs.u8 => { return n.id; })); - rt.drop(taken); + rs.drop(taken); } else if (_25 === 5) { - const _68: [rt.u64, rt.u64] | undefined = [op as rt.u64, 1]; - const outer: [rt.u64, rt.u64] | undefined = rt.cellReplace(polling.current, _68); - const _74: rt.RefCell = rt.refCellBorrowMut(polling.held); - rt.byteVecPush(_74.value, op); - rt.refMutRelease(_74); - rt.byteVecPush(out, option_mapOr$0ucbp7g(outer, 253, (_2: [rt.u64, rt.u64]): rt.u8 => { - return rt.u64Low(_2[0]) & 0xff; + const _68: [rs.u64, rs.u64] | undefined = [op as rs.u64, 1]; + const outer: [rs.u64, rs.u64] | undefined = rs.cellReplace(polling.current, _68); + const _74: rs.RefCell = rs.refCellBorrowMut(polling.held); + rs.byteVecPush(_74.value, op); + rs.refMutRelease(_74); + rs.byteVecPush(out, option_mapOr$1idpb1d(outer, 253, (_2: [rs.u64, rs.u64]): rs.u8 => { + return rs.u64Low(_2[0]) & 0xff; })); - const _83: rt.RefCell = rt.refCellBorrow(polling.held); - rt.byteVecPush(out, _83.value.length & 0xff); - rt.refRelease(_83); + const _83: rs.RefCell = rs.refCellBorrow(polling.held); + rs.byteVecPush(out, _83.value.length & 0xff); + rs.refRelease(_83); } else if (_25 === 6) { - const a: rt.RefCell = rt.refCellBorrow(shared); - const b: rt.RefCell = rt.refCellBorrow(shared); - rt.byteVecPush(out, rt.usizeAdd(a.value.length, b.value.length) & 0xff); - rt.refRelease(b); - rt.refRelease(a); + const a: rs.RefCell = rs.refCellBorrow(shared); + const b: rs.RefCell = rs.refCellBorrow(shared); + rs.byteVecPush(out, rs.usizeAdd(a.value.length, b.value.length) & 0xff); + rs.refRelease(b); + rs.refRelease(a); } else if (_25 === 7) { - const w: rt.RefCell = rt.refCellBorrowMut(shared); - rt.byteVecPush(w.value, op); - rt.byteVecPush(out, w.value.length & 0xff); - rt.refMutRelease(w); - const _116: rt.RefCell = rt.refCellBorrow(shared); - rt.byteVecPush(out, _116.value.length & 0xff); - rt.refRelease(_116); + const w: rs.RefCell = rs.refCellBorrowMut(shared); + rs.byteVecPush(w.value, op); + rs.byteVecPush(out, w.value.length & 0xff); + rs.refMutRelease(w); + const _116: rs.RefCell = rs.refCellBorrow(shared); + rs.byteVecPush(out, _116.value.length & 0xff); + rs.refRelease(_116); } else if (_25 === 8) { - const _118: Noisy.Noisy = new Noisy.Noisy(op, rt.arcClone(log)); - const _123: rt.RefCell = rt.refCellBorrowMut(owned); + const _118: Noisy.Noisy = new Noisy.Noisy(op, rs.arcClone(log)); + const _123: rs.RefCell = rs.refCellBorrowMut(owned); _123.value[Symbol.dispose](); _123.value = _118; - rt.refMutRelease(_123); - const _129: rt.RefCell = rt.refCellBorrow(owned); - rt.byteVecPush(out, _129.value.id); - rt.refRelease(_129); + rs.refMutRelease(_123); + const _129: rs.RefCell = rs.refCellBorrow(owned); + rs.byteVecPush(out, _129.value.id); + rs.refRelease(_129); } else { - const _131: rt.u8 = op >> 4; + const _131: rs.u8 = op >> 4; if (_131 === 13) { - const _r: rt.RefCell = rt.refCellBorrow(shared); - rt.refMutRelease(rt.refCellBorrowMut(shared)); - rt.refRelease(_r); + const _r: rs.RefCell = rs.refCellBorrow(shared); + rs.refMutRelease(rs.refCellBorrowMut(shared)); + rs.refRelease(_r); } else if (_131 === 14) { - const _w2: rt.RefCell = rt.refCellBorrowMut(shared); - rt.refRelease(rt.refCellBorrow(shared)); - rt.refMutRelease(_w2); + const _w2: rs.RefCell = rs.refCellBorrowMut(shared); + rs.refRelease(rs.refCellBorrow(shared)); + rs.refMutRelease(_w2); } else if (_131 === 15) { - const _w3: rt.RefCell = rt.refCellBorrowMut(shared); - rt.refMutRelease(rt.refCellBorrowMut(shared)); - rt.refMutRelease(_w3); + const _w3: rs.RefCell = rs.refCellBorrowMut(shared); + rs.refMutRelease(rs.refCellBorrowMut(shared)); + rs.refMutRelease(_w3); } else { - rt.refMutRelease(rt.refCellBorrowMut(shared)); - const _154: rt.RefCell = rt.refCellBorrow(shared); - rt.byteVecPush(out, _154.value.length & 0xff); - rt.refRelease(_154); + rs.refMutRelease(rs.refCellBorrowMut(shared)); + const _154: rs.RefCell = rs.refCellBorrow(shared); + rs.byteVecPush(out, _154.value.length & 0xff); + rs.refRelease(_154); } } flush(log.value, out); } - rt.byteVecPush(out, count.v & 0xff); - rt.byteVecPush(out, option_mapOr$0ucbp7g(copy$Option_tuple2_u64_u64(polling.current.v), 253, (_22: [rt.u64, rt.u64]): rt.u8 => { - return rt.u64Low(rt.u64Add(_22[0], _22[1])) & 0xff; + rs.byteVecPush(out, count.v & 0xff); + rs.byteVecPush(out, option_mapOr$1idpb1d(copy$Option_tuple2_u64_u64(polling.current.v), 253, (_22: [rs.u64, rs.u64]): rs.u8 => { + return rs.u64Low(rs.u64Add(_22[0], _22[1])) & 0xff; })); noisy[Symbol.dispose](); owned[Symbol.dispose](); @@ -119,184 +119,184 @@ export function borrows(data: rt.ByteSlice, out: rt.ByteVec): void { * `get_mut`, taken apart, tried, and borrowed through mapped and cloned guards; each puts * what it read and what dropped. */ -export function guards(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const tag: (a0: rt.u8) => Tagged.Tagged = (id2: rt.u8): Tagged.Tagged => { - return new Tagged.Tagged(id2, 0, rt.arcClone(log)); +export function guards(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const tag: (a0: rs.u8) => Tagged.Tagged = (id2: rs.u8): Tagged.Tagged => { + return new Tagged.Tagged(id2, 0, rs.arcClone(log)); }; - const number: rt.RefCell = new rt.RefCell(0); - const bytes: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - let tagged: rt.RefCell = new rt.RefCell(tag(0)); - for (const op of rt.byteSliceView(data)) { - const _22: rt.u8 = rt.u8Rem(op, 8); + const number: rs.RefCell = new rs.RefCell(0); + const bytes: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + let tagged: rs.RefCell = new rs.RefCell(tag(0)); + for (const op of rs.byteSliceView(data)) { + const _22: rs.u8 = rs.u8Rem(op, 8); if (_22 === 0) { - const _24: rt.u32 = op as rt.u32; - const _25: rt.Place = rt.valuePlace(number); - _25.v = rt.u32Add(_25.v, _24); - rt.byteVecPush(bytes.value, op); + const _24: rs.u32 = op as rs.u32; + const _25: rs.Place = rs.valuePlace(number); + _25.v = rs.u32Add(_25.v, _24); + rs.byteVecPush(bytes.value, op); const _31: Tagged.Tagged = tagged.value; - _31.n = rt.u32Add(_31.n, 1); - const _39: rt.RefCell = rt.refCellBorrow(number); - rt.byteVecPush(out, _39.value & 0xff); - rt.refRelease(_39); + _31.n = rs.u32Add(_31.n, 1); + const _39: rs.RefCell = rs.refCellBorrow(number); + rs.byteVecPush(out, _39.value & 0xff); + rs.refRelease(_39); } else if (_22 === 1) { - const _46: rt.RefCell = rt.refCellBorrowMut(twin$ref_cell_RefCell_u32(number)); - _46.value = rt.u32Add(_46.value, 1); - rt.refMutRelease(_46); - const _53: rt.RefCell = rt.refCellBorrow(number); - rt.byteVecPush(out, _53.value & 0xff); - rt.refRelease(_53); - rt.byteVecPush(out, twin$ref_sync_Arc_sync_Mutex_Vec_u8(log).strong & 0xff); - const held: rt.RefCell | undefined = then$1jgls7y((op >> 4) === 14, (): rt.RefCell => { - return rt.refCellBorrow(tagged); + const _46: rs.RefCell = rs.refCellBorrowMut(twin$ref_cell_RefCell_u32(number)); + _46.value = rs.u32Add(_46.value, 1); + rs.refMutRelease(_46); + const _53: rs.RefCell = rs.refCellBorrow(number); + rs.byteVecPush(out, _53.value & 0xff); + rs.refRelease(_53); + rs.byteVecPush(out, twin$ref_sync_Arc_sync_Mutex_Vec_u8(log).strong & 0xff); + const held: rs.RefCell | undefined = then$0d67oqn((op >> 4) === 14, (): rs.RefCell => { + return rs.refCellBorrow(tagged); }); - const heldMut: rt.RefCell | undefined = then$1jgls7y((op >> 4) === 15, (): rt.RefCell => { - return rt.refCellBorrowMut(tagged); + const heldMut: rs.RefCell | undefined = then$0d67oqn((op >> 4) === 15, (): rs.RefCell => { + return rs.refCellBorrowMut(tagged); }); - const copy: rt.RefCell = rt.refCellClone(tagged, Tagged.clone$Clone); - const _81: rt.RefCell = rt.refCellBorrow(copy); - rt.byteVecPush(out, _81.value.id); - rt.refRelease(_81); - drop$tuple2_Option_cell_Ref_borrows_Tagged_Option_cell_RefMut_borrows_Tagged([held, heldMut] as [rt.RefCell | undefined, rt.RefCell | undefined]); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.refCellClone(bytes, (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const copy: rs.RefCell = rs.refCellClone(tagged, Tagged.clone$Clone); + const _81: rs.RefCell = rs.refCellBorrow(copy); + rs.byteVecPush(out, _81.value.id); + rs.refRelease(_81); + drop$tuple2_Option_cell_Ref_borrows_Tagged_Option_cell_RefMut_borrows_Tagged([held, heldMut] as [rs.RefCell | undefined, rs.RefCell | undefined]); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.refCellClone(bytes, (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); }).value)); - rt.byteVecPush(out, rt.refCellClone(number, undefined).value & 0xff); + rs.byteVecPush(out, rs.refCellClone(number, undefined).value & 0xff); copy[Symbol.dispose](); } else if (_22 === 2) { - const inner: Tagged.Tagged = new rt.RefCell(tag(op)).value; - rt.byteVecPush(out, inner.id); + const inner: Tagged.Tagged = new rs.RefCell(tag(op)).value; + rs.byteVecPush(out, inner.id); flush(log.value, out); inner[Symbol.dispose](); } else if (_22 === 3) { - const shared: rt.RefCell = rt.refCellBorrow(bytes); - const read: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(bytes); - rt.byteVecPush(out, read.ok ? 1 : 0); - const _116: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); + const shared: rs.RefCell = rs.refCellBorrow(bytes); + const read: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(bytes); + rs.byteVecPush(out, read.ok ? 1 : 0); + const _116: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); if (_116.ok) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - const part3 = new rt.BorrowMutError(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.borrowMutErrorDisplay(part3, f), (f: rt.Formatter) => rt.borrowMutErrorDebug(part3, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); + const part3 = new rs.BorrowMutError(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowMutErrorDisplay(part3, f), (f: rs.Formatter) => rs.borrowMutErrorDebug(part3, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); } if (_116.ok) { drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_116); } - drop$tuple2_Result_cell_Ref_Vec_u8_cell_BorrowError_cell_Ref_Vec_u8([read, shared] as [rt.Result, rt.BorrowError>, rt.RefCell]); - const write: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, write.ok ? 1 : 0); - const _141: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(bytes); + drop$tuple2_Result_cell_Ref_Vec_u8_cell_BorrowError_cell_Ref_Vec_u8([read, shared] as [rs.Result, rs.BorrowError>, rs.RefCell]); + const write: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, write.ok ? 1 : 0); + const _141: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(bytes); if (_141.ok) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - const part4 = new rt.BorrowError(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.borrowErrorDisplay(part4, f), (f: rt.Formatter) => rt.borrowErrorDebug(part4, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); + const part4 = new rs.BorrowError(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.borrowErrorDisplay(part4, f), (f: rs.Formatter) => rs.borrowErrorDebug(part4, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); } if (_141.ok) { drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_141); } drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(write); - rt.byteVecPush(out, result_unwrapOr$0k9nfhn(result_map$0n1xnuw(rt.refCellTryBorrowMut(bytes), (b3: rt.RefCell): rt.u8 => { - rt.byteVecPush(b3.value, op); - const _05: rt.u8 = b3.value.length & 0xff; - rt.refMutRelease(b3); + rs.byteVecPush(out, result_unwrapOr$1bnshxn(result_map$0jl4kv2(rs.refCellTryBorrowMut(bytes), (b3: rs.RefCell): rs.u8 => { + rs.byteVecPush(b3.value, op); + const _05: rs.u8 = b3.value.length & 0xff; + rs.refMutRelease(b3); return _05; }), 253)); } else if (_22 === 4) { - const _166: rt.RefCell = rt.refCellBorrow(tagged); - const n: rt.RefCell = rt.refMap(_166, ((t2: Tagged.Tagged): rt.u32 => { + const _166: rs.RefCell = rs.refCellBorrow(tagged); + const n: rs.RefCell = rs.refMap(_166, ((t2: Tagged.Tagged): rs.u32 => { return t2.n; })(_166.value)); - const _169: rt.RefCell = rt.refCellBorrow(tagged); - const id: rt.RefCell = rt.refMap(_169, ((t3: Tagged.Tagged): rt.u8 => { + const _169: rs.RefCell = rs.refCellBorrow(tagged); + const id: rs.RefCell = rs.refMap(_169, ((t3: Tagged.Tagged): rs.u8 => { return t3.id; })(_169.value)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(n.value & 0xff, id.value))); - const _186: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(tagged); - rt.byteVecPush(out, !_186.ok ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(n.value & 0xff, id.value))); + const _186: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(tagged); + rs.byteVecPush(out, !_186.ok ? 1 : 0); drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError(_186); - rt.refRelease(n); - const _193: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(tagged); - rt.byteVecPush(out, !_193.ok ? 1 : 0); + rs.refRelease(n); + const _193: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(tagged); + rs.byteVecPush(out, !_193.ok ? 1 : 0); drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError(_193); - rt.refRelease(id); - const _200: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(tagged); - rt.byteVecPush(out, !_200.ok ? 1 : 0); + rs.refRelease(id); + const _200: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(tagged); + rs.byteVecPush(out, !_200.ok ? 1 : 0); drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError(_200); - const _203: rt.RefCell = rt.refCellBorrow(bytes); - const half: rt.RefCell = rt.refMap(_203, ((b2: rt.ByteVec): rt.ByteSlice => { - const part2 = rt.usizeDiv(b2.length, 2); - return rt.byteSliceRange(rt.byteVecSlice(b2), part2); + const _203: rs.RefCell = rs.refCellBorrow(bytes); + const half: rs.RefCell = rs.refMap(_203, ((b2: rs.ByteVec): rs.ByteSlice => { + const part2 = rs.usizeDiv(b2.length, 2); + return rs.byteSliceRange(rs.byteVecSlice(b2), part2); })(_203.value)); - rt.byteVecPush(out, half.value.length & 0xff); - const last: rt.RefCell = rt.refMap(half, ((s: rt.ByteSlice): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceLast(s), 253); + rs.byteVecPush(out, half.value.length & 0xff); + const last: rs.RefCell = rs.refMap(half, ((s: rs.ByteSlice): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceLast(s), 253); })(half.value)); - rt.byteVecPush(out, last.value); - const _219: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, !_219.ok ? 1 : 0); + rs.byteVecPush(out, last.value); + const _219: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, !_219.ok ? 1 : 0); drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_219); - rt.refRelease(last); - const _226: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, !_226.ok ? 1 : 0); + rs.refRelease(last); + const _226: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, !_226.ok ? 1 : 0); drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_226); } else if (_22 === 5) { - const a: rt.RefCell = rt.refCellBorrow(bytes); - const b: rt.RefCell = rt.refClone(a); - rt.refRelease(a); - const _237: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, !_237.ok ? 1 : 0); + const a: rs.RefCell = rs.refCellBorrow(bytes); + const b: rs.RefCell = rs.refClone(a); + rs.refRelease(a); + const _237: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, !_237.ok ? 1 : 0); drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_237); - const _240: rt.RefCell = rt.refClone(b); - const c: rt.RefCell = rt.refMap(_240, ((v: rt.ByteVec): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rt.byteVecSlice(v)), 253); + const _240: rs.RefCell = rs.refClone(b); + const c: rs.RefCell = rs.refMap(_240, ((v: rs.ByteVec): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceFirst(rs.byteVecSlice(v)), 253); })(_240.value)); - const d: rt.RefCell = rt.refClone(c); - drop$tuple2_cell_Ref_Vec_u8_cell_Ref_u8([b, c] as [rt.RefCell, rt.RefCell]); - rt.byteVecPush(out, d.value); - const _254: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, !_254.ok ? 1 : 0); + const d: rs.RefCell = rs.refClone(c); + drop$tuple2_cell_Ref_Vec_u8_cell_Ref_u8([b, c] as [rs.RefCell, rs.RefCell]); + rs.byteVecPush(out, d.value); + const _254: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, !_254.ok ? 1 : 0); drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_254); - rt.refRelease(d); - const _261: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(bytes); - rt.byteVecPush(out, !_261.ok ? 1 : 0); + rs.refRelease(d); + const _261: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(bytes); + rs.byteVecPush(out, !_261.ok ? 1 : 0); drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_261); } else if (_22 === 6) { - const _263: rt.u8 = op >> 4; + const _263: rs.u8 = op >> 4; if (_263 === 14) { - const _267: rt.RefCell = rt.refCellBorrow(tagged); - const _n: rt.RefCell = rt.refMap(_267, ((t: Tagged.Tagged): rt.u32 => { + const _267: rs.RefCell = rs.refCellBorrow(tagged); + const _n: rs.RefCell = rs.refMap(_267, ((t: Tagged.Tagged): rs.u32 => { return t.n; })(_267.value)); - rt.refMutRelease(rt.refCellBorrowMut(tagged)); - rt.refRelease(_n); + rs.refMutRelease(rs.refCellBorrowMut(tagged)); + rs.refRelease(_n); } else if (_263 === 15) { - const a2: rt.RefCell = rt.refCellBorrow(tagged); - const _b: rt.RefCell = rt.refClone(a2); - rt.refRelease(a2); - rt.refMutRelease(rt.refCellBorrowMut(tagged)); - rt.refRelease(_b); + const a2: rs.RefCell = rs.refCellBorrow(tagged); + const _b: rs.RefCell = rs.refClone(a2); + rs.refRelease(a2); + rs.refMutRelease(rs.refCellBorrowMut(tagged)); + rs.refRelease(_b); } else { - const _281: rt.RefCell = rt.refCellBorrowMut(tagged); - rt.byteVecPush(out, _281.value.id); - rt.refMutRelease(_281); + const _281: rs.RefCell = rs.refCellBorrowMut(tagged); + rs.byteVecPush(out, _281.value.id); + rs.refMutRelease(_281); } } else { - const _285: rt.RefCell = new rt.RefCell(tag(op)); + const _285: rs.RefCell = new rs.RefCell(tag(op)); const old2 = tagged; tagged = _285; const _291: Tagged.Tagged = old2.value; - rt.byteVecPush(out, _291.id); + rs.byteVecPush(out, _291.id); _291[Symbol.dispose](); } flush(log.value, out); } - rt.byteVecPush(out, number.value & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes.value)); + rs.byteVecPush(out, number.value & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes.value)); const last2: Tagged.Tagged = tagged.value; - rt.byteVecPush(out, last2.id); + rs.byteVecPush(out, last2.id); flush(log.value, out); last2[Symbol.dispose](); flush(log.value, out); @@ -308,311 +308,311 @@ export function guards(data: rt.ByteSlice, out: rt.ByteVec): void { * parts, its value the operand; each puts what it read through them, what the cell holds * after they drop, whether it is still borrowed, and what dropped. */ -export function maps(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const tag: (a0: rt.u8) => Tagged.Tagged = (id: rt.u8): Tagged.Tagged => { - return new Tagged.Tagged(id, 0, rt.arcClone(log)); +export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const tag: (a0: rs.u8) => Tagged.Tagged = (id: rs.u8): Tagged.Tagged => { + return new Tagged.Tagged(id, 0, rs.arcClone(log)); }; - const parts: rt.RefCell = new rt.RefCell(new Parts.Parts(0, "", new rt.ByteVec(), tag(1), undefined, rt.bytes(4))); - const number: rt.RefCell = new rt.RefCell(0); - const bytes4: rt.RefCell = new rt.RefCell(Uint8Array.of(1, 2, 3, 4)); - const slot: rt.RefCell = new rt.RefCell(undefined as Tagged.Tagged | undefined); - for (const op of rt.byteSliceView(data)) { - const _29: rt.u8 = rt.u8Rem(op, 8); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), tag(1), undefined, rs.bytes(4))); + const number: rs.RefCell = new rs.RefCell(0); + const bytes4: rs.RefCell = new rs.RefCell(Uint8Array.of(1, 2, 3, 4)); + const slot: rs.RefCell = new rs.RefCell(undefined as Tagged.Tagged | undefined); + for (const op of rs.byteSliceView(data)) { + const _29: rs.u8 = rs.u8Rem(op, 8); if (_29 === 0) { - const _32: rt.RefCell = rt.refCellBorrowMut(parts); - const n: rt.RefCell = rt.refMutMap(_32, ((p16: Parts.Parts): rt.Place => { - return rt.place(() => p16.n, (value8) => p16.n = value8); + const _32: rs.RefCell = rs.refCellBorrowMut(parts); + const n: rs.RefCell = rs.refMutMap(_32, ((p16: Parts.Parts): rs.Place => { + return rs.place(() => p16.n, (value8) => p16.n = value8); })(_32.value)); - n.value = rt.u32Add(n.value, op as rt.u32); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - const _42: rt.RefCell = n; - const again: rt.RefCell = rt.refMutMap(_42, ((n6: rt.Place): rt.Place => { + n.value = rs.u32Add(n.value, op as rs.u32); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + const _42: rs.RefCell = n; + const again: rs.RefCell = rs.refMutMap(_42, ((n6: rs.Place): rs.Place => { return n6; - })(rt.valuePlace(_42))); - again.value = rt.u32Add(again.value, 1); - rt.refMutRelease(again); - const _52: rt.u8 = borrowed$borrows_Parts(parts); - const _58: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_52, _58.value.n & 0xff))); - rt.refRelease(_58); - const _61: rt.RefCell = rt.refCellBorrowMut(number); - const whole: rt.RefCell = rt.refMutMap(_61, ((n7: rt.Place): rt.Place => { + })(rs.valuePlace(_42))); + again.value = rs.u32Add(again.value, 1); + rs.refMutRelease(again); + const _52: rs.u8 = borrowed$borrows_Parts(parts); + const _58: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_52, _58.value.n & 0xff))); + rs.refRelease(_58); + const _61: rs.RefCell = rs.refCellBorrowMut(number); + const whole: rs.RefCell = rs.refMutMap(_61, ((n7: rs.Place): rs.Place => { return n7; - })(rt.valuePlace(_61))); - const _68: rt.u32 = rt.u32Add(rt.u32WrappingMul(whole.value, 3), op as rt.u32); + })(rs.valuePlace(_61))); + const _68: rs.u32 = rs.u32Add(rs.u32WrappingMul(whole.value, 3), op as rs.u32); whole.value = _68; - rt.refMutRelease(whole); - const _78: rt.RefCell = rt.refCellBorrow(number); - rt.byteVecPush(out, _78.value & 0xff); - rt.refRelease(_78); + rs.refMutRelease(whole); + const _78: rs.RefCell = rs.refCellBorrow(number); + rs.byteVecPush(out, _78.value & 0xff); + rs.refRelease(_78); } else if (_29 === 1) { - const _81: rt.RefCell = rt.refCellBorrowMut(parts); - const text: rt.RefCell = rt.refMutMap(_81, ((p15: Parts.Parts): rt.Place => { - return rt.place(() => p15.text, (value7) => p15.text = value7); + const _81: rs.RefCell = rs.refCellBorrowMut(parts); + const text: rs.RefCell = rs.refMutMap(_81, ((p15: Parts.Parts): rs.Place => { + return rs.place(() => p15.text, (value7) => p15.text = value7); })(_81.value)); - text.value = text.value + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(op, 26)) as rt.char); + text.value = text.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); if ((op >> 4) === 15) { text.value = "z"; } - rt.byteVecPush(out, rt.stringLen(text.value) & 0xff); - rt.refMutRelease(text); - const _110: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_110.value.text)); - rt.refRelease(_110); + rs.byteVecPush(out, rs.stringLen(text.value) & 0xff); + rs.refMutRelease(text); + const _110: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_110.value.text)); + rs.refRelease(_110); } else if (_29 === 2) { - const _113: rt.RefCell = rt.refCellBorrowMut(parts); - const bytes: rt.RefCell = rt.refMutMap(_113, rt.partPlace(((p13: Parts.Parts): rt.ByteVec => { + const _113: rs.RefCell = rs.refCellBorrowMut(parts); + const bytes: rs.RefCell = rs.refMutMap(_113, rs.partPlace(((p13: Parts.Parts): rs.ByteVec => { return p13.bytes; })(_113.value))); - rt.byteVecPush(bytes.value, op); + rs.byteVecPush(bytes.value, op); if ((op >> 4) === 15) { - const _122: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(op, op)); + const _122: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(op, op)); bytes.value = _122; } - rt.refMutRelease(bytes); - const _133: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_133.value.bytes)); - rt.refRelease(_133); - const _136: rt.RefCell = rt.refCellBorrowMut(parts); - const tagged: rt.RefCell = rt.refMutMap(_136, rt.partPlace(((p14: Parts.Parts): Tagged.Tagged => { + rs.refMutRelease(bytes); + const _133: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_133.value.bytes)); + rs.refRelease(_133); + const _136: rs.RefCell = rs.refCellBorrowMut(parts); + const tagged: rs.RefCell = rs.refMutMap(_136, rs.partPlace(((p14: Parts.Parts): Tagged.Tagged => { return p14.tagged; })(_136.value))); - tagged.value.n = rt.u32Add(tagged.value.n, 1); - const _142: rt.u32 = tagged.value.n; - const _145: rt.Arc> = rt.arcClone(log); + tagged.value.n = rs.u32Add(tagged.value.n, 1); + const _142: rs.u32 = tagged.value.n; + const _145: rs.Arc> = rs.arcClone(log); const _141: Tagged.Tagged = new Tagged.Tagged(op, _142, _145); tagged.value[Symbol.dispose](); tagged.value = _141; flush(log.value, out); - rt.refMutRelease(tagged); - const _161: rt.RefCell = rt.refCellBorrow(parts); - const _158: rt.u8 = _161.value.tagged.id; - const _167: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_158, _167.value.tagged.n & 0xff))); - rt.refRelease(_167); - rt.refRelease(_161); + rs.refMutRelease(tagged); + const _161: rs.RefCell = rs.refCellBorrow(parts); + const _158: rs.u8 = _161.value.tagged.id; + const _167: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_158, _167.value.tagged.n & 0xff))); + rs.refRelease(_167); + rs.refRelease(_161); } else if (_29 === 3) { - const _170: rt.RefCell = rt.refCellBorrowMut(parts); - const _169: rt.Result, rt.RefCell> = rt.refMutFilterMap(_170, ((p11: Parts.Parts): rt.Place | undefined => { - return p11.maybe === undefined ? undefined : rt.place(() => p11.maybe as rt.u16, (value6) => p11.maybe = value6); + const _170: rs.RefCell = rs.refCellBorrowMut(parts); + const _169: rs.Result, rs.RefCell> = rs.refMutFilterMap(_170, ((p11: Parts.Parts): rs.Place | undefined => { + return p11.maybe === undefined ? undefined : rs.place(() => p11.maybe as rs.u16, (value6) => p11.maybe = value6); })(_170.value)); if (_169.ok) { - const m: rt.RefCell = _169.value; - m.value = rt.u16Add(m.value, 1); - rt.byteVecPush(out, m.value & 0xff); - rt.refMutRelease(m); + const m: rs.RefCell = _169.value; + m.value = rs.u16Add(m.value, 1); + rs.byteVecPush(out, m.value & 0xff); + rs.refMutRelease(m); } else { - const whole2: rt.RefCell = _169.error; - whole2.value.maybe = op as rt.u16; - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refMutRelease(whole2); + const whole2: rs.RefCell = _169.error; + whole2.value.maybe = op as rs.u16; + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refMutRelease(whole2); } - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - const _195: rt.RefCell = rt.refCellBorrow(parts); - const _194: rt.Result, rt.RefCell> = rt.refFilterMap(_195, ((p12: Parts.Parts): rt.u8 | undefined => { - return rt.byteSliceLast(rt.byteVecSlice(p12.bytes)); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + const _195: rs.RefCell = rs.refCellBorrow(parts); + const _194: rs.Result, rs.RefCell> = rs.refFilterMap(_195, ((p12: Parts.Parts): rs.u8 | undefined => { + return rs.byteSliceLast(rs.byteVecSlice(p12.bytes)); })(_195.value)); if (_194.ok) { - const last: rt.RefCell = _194.value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(last.value, borrowed$borrows_Parts(parts)))); - rt.refRelease(last); + const last: rs.RefCell = _194.value; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last.value, borrowed$borrows_Parts(parts)))); + rs.refRelease(last); } else { - const whole3: rt.RefCell = _194.error; - rt.byteVecPush(out, 240 | (whole3.value.bytes.length & 0xff)); - rt.refRelease(whole3); + const whole3: rs.RefCell = _194.error; + rs.byteVecPush(out, 240 | (whole3.value.bytes.length & 0xff)); + rs.refRelease(whole3); } - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - const _218: rt.RefCell = rt.refCellBorrowMut(slot); - const part = ((s2: rt.Place): Tagged.Tagged | undefined => { + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + const _218: rs.RefCell = rs.refCellBorrowMut(slot); + const part = ((s2: rs.Place): Tagged.Tagged | undefined => { return s2.v; - })(rt.valuePlace(_218)); - const _217: rt.Result, rt.RefCell> = rt.refMutFilterMap(_218, part === undefined ? undefined : rt.partPlace(part)); + })(rs.valuePlace(_218)); + const _217: rs.Result, rs.RefCell> = rs.refMutFilterMap(_218, part === undefined ? undefined : rs.partPlace(part)); if (_217.ok) { - const t: rt.RefCell = _217.value; + const t: rs.RefCell = _217.value; const _222: Tagged.Tagged = tag(op); t.value[Symbol.dispose](); t.value = _222; - rt.refMutRelease(t); + rs.refMutRelease(t); } else { - const s: rt.RefCell = _217.error; + const s: rs.RefCell = _217.error; const _228: Tagged.Tagged | undefined = tag(op); - rt.drop(s.value); + rs.drop(s.value); s.value = _228; - rt.refMutRelease(s); + rs.refMutRelease(s); } flush(log.value, out); - const _242: rt.RefCell = rt.refCellBorrow(slot); - rt.byteVecPush(out, option_mapOr$1dvn0au(_242.value, 253, (t2: Tagged.Tagged): rt.u8 => { + const _242: rs.RefCell = rs.refCellBorrow(slot); + rs.byteVecPush(out, option_mapOr$0rsyyii(_242.value, 253, (t2: Tagged.Tagged): rs.u8 => { return t2.id; })); - rt.refRelease(_242); + rs.refRelease(_242); } else if (_29 === 4) { - const _247: rt.RefCell = rt.refCellBorrow(parts); - const _246: [rt.RefCell, rt.RefCell] = rt.refMapSplit(_247, ((p10: Parts.Parts): [rt.u32, rt.ByteVec] => { - return [p10.n, p10.bytes] as [rt.u32, rt.ByteVec]; + const _247: rs.RefCell = rs.refCellBorrow(parts); + const _246: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_247, ((p10: Parts.Parts): [rs.u32, rs.ByteVec] => { + return [p10.n, p10.bytes] as [rs.u32, rs.ByteVec]; })(_247.value)); - const n2: rt.RefCell = _246[0]; - const bytes2: rt.RefCell = _246[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(n2.value & 0xff, bytes2.value.length & 0xff, borrowed$borrows_Parts(parts)))); - rt.refRelease(n2); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refRelease(bytes2); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + const n2: rs.RefCell = _246[0]; + const bytes2: rs.RefCell = _246[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(n2.value & 0xff, bytes2.value.length & 0xff, borrowed$borrows_Parts(parts)))); + rs.refRelease(n2); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refRelease(bytes2); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_29 === 5) { - const _274: rt.RefCell = rt.refCellBorrowMut(parts); - const _273: [rt.RefCell, rt.RefCell] = rt.refMutMapSplit(_274, ((p8: Parts.Parts): [rt.Place, rt.Place] => { - return [rt.place(() => p8.n, (value4) => p8.n = value4), rt.place(() => p8.text, (value5) => p8.text = value5)] as [rt.Place, rt.Place]; + const _274: rs.RefCell = rs.refCellBorrowMut(parts); + const _273: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_274, ((p8: Parts.Parts): [rs.Place, rs.Place] => { + return [rs.place(() => p8.n, (value4) => p8.n = value4), rs.place(() => p8.text, (value5) => p8.text = value5)] as [rs.Place, rs.Place]; })(_274.value)); - const n3: rt.RefCell = _273[0]; - const text2: rt.RefCell = _273[1]; - n3.value = rt.u32Add(n3.value, 1); + const n3: rs.RefCell = _273[0]; + const text2: rs.RefCell = _273[1]; + n3.value = rs.u32Add(n3.value, 1); text2.value = text2.value + "s"; - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); if (!((op & 16) === 0)) { - rt.refMutRelease(text2); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refMutRelease(n3); + rs.refMutRelease(text2); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refMutRelease(n3); } else { - rt.refMutRelease(n3); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refMutRelease(text2); + rs.refMutRelease(n3); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refMutRelease(text2); } - const _305: rt.u8 = borrowed$borrows_Parts(parts); - const _311: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_305, _311.value.n & 0xff))); - rt.refRelease(_311); - const _316: rt.RefCell = rt.refCellBorrowMut(parts); - const parts3 = ((p9: Parts.Parts): [rt.ByteSlice, rt.ByteSlice] => { - const half: rt.usize = rt.usizeDiv(p9.bytes.length, 2); - return rt.byteSliceSplitAt(rt.byteVecSlice(p9.bytes), half); + const _305: rs.u8 = borrowed$borrows_Parts(parts); + const _311: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_305, _311.value.n & 0xff))); + rs.refRelease(_311); + const _316: rs.RefCell = rs.refCellBorrowMut(parts); + const parts3 = ((p9: Parts.Parts): [rs.ByteSlice, rs.ByteSlice] => { + const half: rs.usize = rs.usizeDiv(p9.bytes.length, 2); + return rs.byteSliceSplitAt(rs.byteVecSlice(p9.bytes), half); })(_316.value); - const _315: [rt.RefCell, rt.RefCell] = rt.refMutMapSplit(_316, [rt.partPlace(parts3[0]), rt.partPlace(parts3[1])]); - const low: rt.RefCell = _315[0]; - const high: rt.RefCell = _315[1]; - const _318: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(low.value)); + const _315: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_316, [rs.partPlace(parts3[0]), rs.partPlace(parts3[1])]); + const low: rs.RefCell = _315[0]; + const high: rs.RefCell = _315[1]; + const _318: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(low.value)); if (_318 !== undefined) { - _318.v = rt.u8WrappingAdd(_318.v, op); + _318.v = rs.u8WrappingAdd(_318.v, op); } - const _325: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(high.value)); + const _325: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(high.value)); if (_325 !== undefined) { _325.v = _325.v ^ 255; } - drop$tuple2_cell_RefMut_slice_u8_cell_RefMut_slice_u8([low, high] as [rt.RefCell, rt.RefCell]); - const _339: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_339.value.bytes)); - rt.refRelease(_339); + drop$tuple2_cell_RefMut_slice_u8_cell_RefMut_slice_u8([low, high] as [rs.RefCell, rs.RefCell]); + const _339: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_339.value.bytes)); + rs.refRelease(_339); } else if (_29 === 6) { - const _341: rt.u8 = op >> 4; + const _341: rs.u8 = op >> 4; if (_341 === 12) { - const _345: rt.RefCell = rt.refCellBorrowMut(parts); - const _n: rt.RefCell = rt.refMutMap(_345, ((p7: Parts.Parts): rt.Place => { - return rt.place(() => p7.n, (value3) => p7.n = value3); + const _345: rs.RefCell = rs.refCellBorrowMut(parts); + const _n: rs.RefCell = rs.refMutMap(_345, ((p7: Parts.Parts): rs.Place => { + return rs.place(() => p7.n, (value3) => p7.n = value3); })(_345.value)); - rt.refRelease(rt.refCellBorrow(parts)); - rt.refMutRelease(_n); + rs.refRelease(rs.refCellBorrow(parts)); + rs.refMutRelease(_n); } else if (_341 === 13) { - const _352: rt.RefCell = rt.refCellBorrowMut(parts); - const parts2 = ((p6: Parts.Parts): [rt.Place, rt.ByteVec] => { - return [rt.place(() => p6.n, (value2) => p6.n = value2), p6.bytes] as [rt.Place, rt.ByteVec]; + const _352: rs.RefCell = rs.refCellBorrowMut(parts); + const parts2 = ((p6: Parts.Parts): [rs.Place, rs.ByteVec] => { + return [rs.place(() => p6.n, (value2) => p6.n = value2), p6.bytes] as [rs.Place, rs.ByteVec]; })(_352.value); - const _351: [rt.RefCell, rt.RefCell] = rt.refMutMapSplit(_352, [parts2[0], rt.partPlace(parts2[1])]); - const a: rt.RefCell = _351[0]; - const _b: rt.RefCell = _351[1]; - rt.refMutRelease(a); - rt.refMutRelease(rt.refCellBorrowMut(parts)); - rt.refMutRelease(_b); + const _351: [rs.RefCell, rs.RefCell] = rs.refMutMapSplit(_352, [parts2[0], rs.partPlace(parts2[1])]); + const a: rs.RefCell = _351[0]; + const _b: rs.RefCell = _351[1]; + rs.refMutRelease(a); + rs.refMutRelease(rs.refCellBorrowMut(parts)); + rs.refMutRelease(_b); } else if (_341 === 14) { - const _358: rt.RefCell = rt.refCellBorrow(parts); - const _f: rt.Result, rt.RefCell> = rt.refFilterMap(_358, ((p5: Parts.Parts): rt.u32 | undefined => { + const _358: rs.RefCell = rs.refCellBorrow(parts); + const _f: rs.Result, rs.RefCell> = rs.refFilterMap(_358, ((p5: Parts.Parts): rs.u32 | undefined => { return p5.n; })(_358.value)); - rt.refMutRelease(rt.refCellBorrowMut(parts)); + rs.refMutRelease(rs.refCellBorrowMut(parts)); drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts(_f); } else if (_341 === 15) { - const _365: rt.RefCell = rt.refCellBorrow(parts); - const _364: [rt.RefCell, rt.RefCell] = rt.refMapSplit(_365, ((p4: Parts.Parts): [rt.u32, string] => { - return [p4.n, p4.text] as [rt.u32, string]; + const _365: rs.RefCell = rs.refCellBorrow(parts); + const _364: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_365, ((p4: Parts.Parts): [rs.u32, string] => { + return [p4.n, p4.text] as [rs.u32, string]; })(_365.value)); - const _a: rt.RefCell = _364[0]; - rt.refRelease(_364[1]); - rt.refMutRelease(rt.refCellBorrowMut(parts)); - rt.refRelease(_a); + const _a: rs.RefCell = _364[0]; + rs.refRelease(_364[1]); + rs.refMutRelease(rs.refCellBorrowMut(parts)); + rs.refRelease(_a); } else { - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } } else { - const _373: rt.RefCell = rt.refCellBorrow(parts); - const text3: rt.RefCell = rt.refMap(_373, ((p: Parts.Parts): string => { + const _373: rs.RefCell = rs.refCellBorrow(parts); + const text3: rs.RefCell = rs.refMap(_373, ((p: Parts.Parts): string => { return p.text; })(_373.value)); - const _376: rt.RefCell = rt.refCellBorrowMut(number); - const n4: rt.RefCell = rt.refMutMap(_376, ((n5: rt.Place): rt.Place => { + const _376: rs.RefCell = rs.refCellBorrowMut(number); + const n4: rs.RefCell = rs.refMutMap(_376, ((n5: rs.Place): rs.Place => { return n5; - })(rt.valuePlace(_376))); + })(rs.valuePlace(_376))); const _387: string = text3.value; - const _390: rt.u32 = rt.u32Add(n4.value, 1); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _387), (f: rt.Formatter) => rt.u32Display(_390, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(borrowed$borrows_Parts(parts), borrowed$u32(number)))); - drop$tuple2_cell_Ref_str_cell_RefMut_u32([text3, n4] as [rt.RefCell, rt.RefCell]); - const _411: rt.RefCell = rt.refCellBorrowMut(parts); - const quad: rt.RefCell = rt.refMutMap(_411, rt.partPlace(rt.byteSliceView(((p2: Parts.Parts): rt.ByteSlice => { - return rt.byteSliceFrom(p2.quad); + const _390: rs.u32 = rs.u32Add(n4.value, 1); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _387), (f: rs.Formatter) => rs.u32Display(_390, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(borrowed$borrows_Parts(parts), borrowed$u32(number)))); + drop$tuple2_cell_Ref_str_cell_RefMut_u32([text3, n4] as [rs.RefCell, rs.RefCell]); + const _411: rs.RefCell = rs.refCellBorrowMut(parts); + const quad: rs.RefCell = rs.refMutMap(_411, rs.partPlace(rs.byteSliceView(((p2: Parts.Parts): rs.ByteSlice => { + return rs.byteSliceFrom(p2.quad); })(_411.value)))); - const _413: rt.ByteSlice = rt.byteSliceFrom(quad.value); - const _415: rt.usize = ((op >> 4) & 3) as rt.usize; + const _413: rs.ByteSlice = rs.byteSliceFrom(quad.value); + const _415: rs.usize = ((op >> 4) & 3) as rs.usize; if (!(_415 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _415); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _415); } _413.data[_413.start + _415] = _413.data[_413.start + _415] ^ op; if ((op & 64) !== 0) { - const _423: rt.ByteSlice = rt.byteSliceFrom(quad.value); - _423.data.set(rt.bytes(4).fill(op), _423.start); + const _423: rs.ByteSlice = rs.byteSliceFrom(quad.value); + _423.data.set(rs.bytes(4).fill(op), _423.start); } - rt.refMutRelease(quad); - const _428: rt.RefCell = rt.refCellBorrow(parts); - const quad2: rt.RefCell = rt.refMap(_428, rt.byteSliceView(((p3: Parts.Parts): rt.ByteSlice => { - return rt.byteSliceFrom(p3.quad); + rs.refMutRelease(quad); + const _428: rs.RefCell = rs.refCellBorrow(parts); + const quad2: rs.RefCell = rs.refMap(_428, rs.byteSliceView(((p3: Parts.Parts): rs.ByteSlice => { + return rs.byteSliceFrom(p3.quad); })(_428.value))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(quad2.value)); - rt.refRelease(quad2); - const _436: rt.RefCell = rt.refCellBorrowMut(bytes4); - const _438: (a0: rt.ByteSlice) => rt.Place = (b2: rt.ByteSlice): rt.Place => { - const _33: rt.usize = (op & 3) as rt.usize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(quad2.value)); + rs.refRelease(quad2); + const _436: rs.RefCell = rs.refCellBorrowMut(bytes4); + const _438: (a0: rs.ByteSlice) => rs.Place = (b2: rs.ByteSlice): rs.Place => { + const _33: rs.usize = (op & 3) as rs.usize; if (!(_33 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _33); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _33); } - return rt.place(() => b2.data[b2.start + _33], (value) => b2.data[b2.start + _33] = value); + return rs.place(() => b2.data[b2.start + _33], (value) => b2.data[b2.start + _33] = value); }; - const byte: rt.RefCell = rt.refMutMap(_436, ((held) => _438(rt.byteSliceFrom(held)))(_436.value)); - const _440: rt.u8 = rt.u8WrappingAdd(byte.value, op); + const byte: rs.RefCell = rs.refMutMap(_436, ((held) => _438(rs.byteSliceFrom(held)))(_436.value)); + const _440: rs.u8 = rs.u8WrappingAdd(byte.value, op); byte.value = _440; - rt.refMutRelease(byte); - const _451: rt.RefCell = rt.refCellBorrow(bytes4); - const f = (b3: rt.ByteSlice): [rt.ByteSlice, rt.ByteSlice] => { - return rt.byteSliceSplitAt(b3, 2); + rs.refMutRelease(byte); + const _451: rs.RefCell = rs.refCellBorrow(bytes4); + const f = (b3: rs.ByteSlice): [rs.ByteSlice, rs.ByteSlice] => { + return rs.byteSliceSplitAt(b3, 2); }; - const _450: [rt.RefCell, rt.RefCell] = rt.refMapSplit(_451, ((held2) => f(rt.byteSliceFrom(held2)))(_451.value)); - const low2: rt.RefCell = _450[0]; - const high2: rt.RefCell = _450[1]; - const _459: rt.ByteSlice = low2.value; - rt.idx(_459, 0); - const _458: rt.u8 = _459.data[_459.start]; - const _465: rt.ByteSlice = high2.value; - rt.idx(_465, 1); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_458 ^ _465.data[_465.start + 1], borrowed$array4_u8(bytes4)))); - rt.refRelease(high2); - rt.refRelease(low2); + const _450: [rs.RefCell, rs.RefCell] = rs.refMapSplit(_451, ((held2) => f(rs.byteSliceFrom(held2)))(_451.value)); + const low2: rs.RefCell = _450[0]; + const high2: rs.RefCell = _450[1]; + const _459: rs.ByteSlice = low2.value; + rs.idx(_459, 0); + const _458: rs.u8 = _459.data[_459.start]; + const _465: rs.ByteSlice = high2.value; + rs.idx(_465, 1); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_458 ^ _465.data[_465.start + 1], borrowed$array4_u8(bytes4)))); + rs.refRelease(high2); + rs.refRelease(low2); } flush(log.value, out); } const last2: Parts.Parts = parts.value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(last2.n & 0xff, last2.tagged.id, option_mapOr$099335t(last2.maybe, 253, (m2: rt.u16): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, last2.tagged.id, option_mapOr$031uhqp(last2.maybe, 253, (m2: rs.u16): rs.u8 => { return m2 & 0xff; })))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(last2.text)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last2.bytes)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); slot[Symbol.dispose](); flush(log.value, out); @@ -625,197 +625,197 @@ export function maps(data: rt.ByteSlice, out: rt.ByteVec): void { * through them, what the cell holds after they drop, whether it is still borrowed, and * what dropped. */ -export function tries(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const parts: rt.RefCell = new rt.RefCell(new Parts.Parts(0, "", new rt.ByteVec(), new Tagged.Tagged(1, 0, rt.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); - const number: rt.RefCell = new rt.RefCell(0); - for (const op of rt.byteSliceView(data)) { - const _23: rt.u8 = rt.u8Rem(op, 4); +export function tries(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const parts: rs.RefCell = new rs.RefCell(new Parts.Parts(0, "", new rs.ByteVec(), new Tagged.Tagged(1, 0, rs.arcClone(log)), undefined, Uint8Array.of(1, 2, 3, 4))); + const number: rs.RefCell = new rs.RefCell(0); + for (const op of rs.byteSliceView(data)) { + const _23: rs.u8 = rs.u8Rem(op, 4); if (_23 === 0) { - const _26: rt.RefCell = rt.refCellBorrowMut(parts); - const tried: rt.Result, [rt.RefCell, Noisy.Noisy]> = rt.refMutTryMap(_26, ((p9: Parts.Parts): rt.Result, Noisy.Noisy> => { - const _39: rt.Place | undefined = p9.maybe === undefined ? undefined : rt.place(() => p9.maybe as rt.u16, (value3) => p9.maybe = value3); + const _26: rs.RefCell = rs.refCellBorrowMut(parts); + const tried: rs.Result, [rs.RefCell, Noisy.Noisy]> = rs.refMutTryMap(_26, ((p9: Parts.Parts): rs.Result, Noisy.Noisy> => { + const _39: rs.Place | undefined = p9.maybe === undefined ? undefined : rs.place(() => p9.maybe as rs.u16, (value3) => p9.maybe = value3); if (_39 === undefined) { - return rt.Err(new Noisy.Noisy(op, rt.arcClone(log))); + return rs.Err(new Noisy.Noisy(op, rs.arcClone(log))); } - return rt.Ok(_39); + return rs.Ok(_39); })(_26.value)); if (tried.ok) { - const m: rt.RefCell = tried.value; - const _33: rt.u16 = rt.u16WrappingAdd(m.value, op as rt.u16); + const m: rs.RefCell = tried.value; + const _33: rs.u16 = rs.u16WrappingAdd(m.value, op as rs.u16); m.value = _33; - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refMutRelease(m); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refMutRelease(m); } else { - const whole: rt.RefCell = tried.error[0]; + const whole: rs.RefCell = tried.error[0]; const noisy: Noisy.Noisy = tried.error[1]; - whole.value.maybe = noisy.id as rt.u16; - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + whole.value.maybe = noisy.id as rs.u16; + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); noisy[Symbol.dispose](); flush(log.value, out); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refMutRelease(whole); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refMutRelease(whole); } - const _64: rt.u8 = borrowed$borrows_Parts(parts); - const _70: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_64, option_mapOr$099335t(_70.value.maybe, 253, (m2: rt.u16): rt.u8 => { + const _64: rs.u8 = borrowed$borrows_Parts(parts); + const _70: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_64, option_mapOr$031uhqp(_70.value.maybe, 253, (m2: rs.u16): rs.u8 => { return m2 & 0xff; })))); - rt.refRelease(_70); - const _73: rt.RefCell = rt.refCellBorrowMut(parts); - const part = ((p10: Parts.Parts): rt.Result => { + rs.refRelease(_70); + const _73: rs.RefCell = rs.refCellBorrowMut(parts); + const part = ((p10: Parts.Parts): rs.Result => { if ((op & 16) === 0) { - return rt.Ok(p10.bytes); + return rs.Ok(p10.bytes); } - return rt.ERR; + return rs.ERR; })(_73.value); - const tried2: rt.Result, [rt.RefCell, undefined]> = rt.refMutTryMap(_73, part.ok ? rt.Ok(rt.partPlace(part.value)) : rt.Err(part.error)); + const tried2: rs.Result, [rs.RefCell, undefined]> = rs.refMutTryMap(_73, part.ok ? rs.Ok(rs.partPlace(part.value)) : rs.Err(part.error)); if (tried2.ok) { - const bytes: rt.RefCell = tried2.value; - rt.byteVecPush(bytes.value, op); + const bytes: rs.RefCell = tried2.value; + rs.byteVecPush(bytes.value, op); if ((op >> 5) === 7) { - const _87: rt.ByteVec = rt.byteVecOf(op, 2); + const _87: rs.ByteVec = rs.byteVecOf(op, 2); bytes.value = _87; } - rt.refMutRelease(bytes); + rs.refMutRelease(bytes); } else { - const whole2: rt.RefCell = tried2.error[0]; - rt.byteVecPush(out, 240 | (whole2.value.bytes.length & 0xff)); - rt.refMutRelease(whole2); + const whole2: rs.RefCell = tried2.error[0]; + rs.byteVecPush(out, 240 | (whole2.value.bytes.length & 0xff)); + rs.refMutRelease(whole2); } - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - const _105: rt.RefCell = rt.refCellBorrow(parts); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_105.value.bytes)); - rt.refRelease(_105); - const _109: rt.RefCell = rt.refCellBorrowMut(number); - const n: rt.RefCell = rt.resultUnwrap(rt.refMutTryMap(_109, ((n3: rt.Place): rt.Result, rt.u8> => { - return rt.Ok(n3); - })(rt.valuePlace(_109))), (value: [rt.RefCell, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0].value, f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)); - n.value = rt.u32Add(n.value, op as rt.u32); - rt.refMutRelease(n); - const _122: rt.RefCell = rt.refCellBorrow(number); - rt.byteVecPush(out, _122.value & 0xff); - rt.refRelease(_122); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + const _105: rs.RefCell = rs.refCellBorrow(parts); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_105.value.bytes)); + rs.refRelease(_105); + const _109: rs.RefCell = rs.refCellBorrowMut(number); + const n: rs.RefCell = rs.resultUnwrap(rs.refMutTryMap(_109, ((n3: rs.Place): rs.Result, rs.u8> => { + return rs.Ok(n3); + })(rs.valuePlace(_109))), (value: [rs.RefCell, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0].value, f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)); + n.value = rs.u32Add(n.value, op as rs.u32); + rs.refMutRelease(n); + const _122: rs.RefCell = rs.refCellBorrow(number); + rs.byteVecPush(out, _122.value & 0xff); + rs.refRelease(_122); } else if (_23 === 1) { - const other: rt.RefCell = rt.refCellBorrow(parts); - const _128: rt.RefCell = rt.refCellBorrow(parts); - const _127: rt.Result, [rt.RefCell, rt.usize]> = rt.refTryMap(_128, ((p8: Parts.Parts): rt.Result => { - return option_okOr$1oufq9m(rt.byteSliceLast(rt.byteVecSlice(p8.bytes)), p8.bytes.length); + const other: rs.RefCell = rs.refCellBorrow(parts); + const _128: rs.RefCell = rs.refCellBorrow(parts); + const _127: rs.Result, [rs.RefCell, rs.usize]> = rs.refTryMap(_128, ((p8: Parts.Parts): rs.Result => { + return option_okOr$1bx6za5(rs.byteSliceLast(rs.byteVecSlice(p8.bytes)), p8.bytes.length); })(_128.value)); if (_127.ok) { - const last: rt.RefCell = _127.value; - const tried3: rt.Result, [rt.RefCell, rt.u8]> = rt.refTryMap(last, ((b3: rt.u8): rt.Result => { + const last: rs.RefCell = _127.value; + const tried3: rs.Result, [rs.RefCell, rs.u8]> = rs.refTryMap(last, ((b3: rs.u8): rs.Result => { if (!((b3 & 1) === 0)) { - return rt.Err(b3); + return rs.Err(b3); } - return rt.Ok(b3); + return rs.Ok(b3); })(last.value)); if (tried3.ok) { - const b: rt.RefCell = tried3.value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(b.value, borrowed$borrows_Parts(parts)))); - rt.refRelease(b); + const b: rs.RefCell = tried3.value; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(b.value, borrowed$borrows_Parts(parts)))); + rs.refRelease(b); } else { - const b2: rt.RefCell = tried3.error[0]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(b2.value ^ tried3.error[1], borrowed$borrows_Parts(parts)))); - rt.refRelease(b2); + const b2: rs.RefCell = tried3.error[0]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(b2.value ^ tried3.error[1], borrowed$borrows_Parts(parts)))); + rs.refRelease(b2); } } else { - const whole3: rt.RefCell = _127.error[0]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(whole3.value.n & 0xff, _127.error[1] & 0xff))); - rt.refRelease(whole3); + const whole3: rs.RefCell = _127.error[0]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(whole3.value.n & 0xff, _127.error[1] & 0xff))); + rs.refRelease(whole3); } - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); - rt.refRelease(other); - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.refRelease(other); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } else if (_23 === 2) { - const _175: rt.RefCell = rt.refCellBorrowMut(parts); - _175.value.text = _175.value.text + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(op, 26)) as rt.char); - rt.refMutRelease(_175); - const _183: rt.RefCell = rt.refCellBorrow(parts); - const text: rt.RefCell = rt.refMap(_183, ((p3: Parts.Parts): string => { + const _175: rs.RefCell = rs.refCellBorrowMut(parts); + _175.value.text = _175.value.text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(op, 26)) as rs.char); + rs.refMutRelease(_175); + const _183: rs.RefCell = rs.refCellBorrow(parts); + const text: rs.RefCell = rs.refMap(_183, ((p3: Parts.Parts): string => { return p3.text; })(_183.value)); - const _186: rt.RefCell = rt.refCellBorrow(parts); - const quad: rt.RefCell = rt.refMap(_186, rt.byteSliceView(((p4: Parts.Parts): rt.ByteSlice => { - return rt.byteSliceFrom(p4.quad); + const _186: rs.RefCell = rs.refCellBorrow(parts); + const quad: rs.RefCell = rs.refMap(_186, rs.byteSliceView(((p4: Parts.Parts): rs.ByteSlice => { + return rs.byteSliceFrom(p4.quad); })(_186.value))); - const n2: rt.RefCell = rt.refCellBorrow(number); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, text.value), (f: rt.Formatter) => rt.fmtStr(text.value, f), (f: rt.Formatter) => rt.fmtList(quad.value, f, rt.u8Debug), (f: rt.Formatter) => rt.u32Debug(n2.value, f), (f: rt.Formatter) => rt.u32Display(n2.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " [", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "] ", args2[2], " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", args2[3], " ", rt.fmtSpec({ align: ">", width: 5 }, args2[4])]))); - drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rt.RefCell, rt.RefCell, rt.RefCell]); - const _211: rt.RefCell = rt.refCellBorrowMut(parts); - const maybe: rt.RefCell = rt.refMutMap(_211, ((p5: Parts.Parts): rt.Place => { - return rt.place(() => p5.maybe, (value2) => p5.maybe = value2); + const n2: rs.RefCell = rs.refCellBorrow(number); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text.value), (f: rs.Formatter) => rs.fmtStr(text.value, f), (f: rs.Formatter) => rs.fmtList(quad.value, f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(n2.value, f), (f: rs.Formatter) => rs.u32Display(n2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " [", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "] ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", args2[3], " ", rs.fmtSpec({ align: ">", width: 5 }, args2[4])]))); + drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32([text, quad, n2] as [rs.RefCell, rs.RefCell, rs.RefCell]); + const _211: rs.RefCell = rs.refCellBorrowMut(parts); + const maybe: rs.RefCell = rs.refMutMap(_211, ((p5: Parts.Parts): rs.Place => { + return rs.place(() => p5.maybe, (value2) => p5.maybe = value2); })(_211.value)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(maybe.value, f, rt.u16Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[0])]))); - rt.refMutRelease(maybe); - const _227: rt.RefCell = rt.refCellBorrowMut(parts); - const bytes2: rt.RefCell = rt.refMutMap(_227, rt.partPlace(((p6: Parts.Parts): rt.ByteVec => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(maybe.value, f, rs.u16Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0])]))); + rs.refMutRelease(maybe); + const _227: rs.RefCell = rs.refCellBorrowMut(parts); + const bytes2: rs.RefCell = rs.refMutMap(_227, rs.partPlace(((p6: Parts.Parts): rs.ByteVec => { return p6.bytes; })(_227.value))); - const _237: rt.RefCell = rt.refCellBorrowMut(number); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(bytes2.value), f, rt.u8Debug), (f: rt.Formatter) => rt.u32Debug(_237.value, f)]; - const _233: string = rt.fmtFormat([args6[0], " ", args6[1]]); - rt.refMutRelease(_237); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_233)); - rt.refMutRelease(bytes2); - const pair: rt.RefCell<[rt.u8, string]> = new rt.RefCell([op, "pair"] as [rt.u8, string]); - const _256: rt.RefCell<[rt.u8, string]> = rt.refCellBorrow(pair); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_256.value[0], f), (f: rt.Formatter) => rt.fmtStr(_256.value[1], f)], f)]; - const _252: string = rt.fmtFormat([args8[0], " "]); - rt.refRelease(_256); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_252)); - const _270: rt.RefCell<[rt.u8, string]> = rt.refCellBorrowMut(pair); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_270.value[0], f), (f: rt.Formatter) => rt.fmtStr(_270.value[1], f)], f)]; - const _266: string = rt.fmtFormat([rt.fmtSpec({ alternate: true }, args10[0])]); - rt.refMutRelease(_270); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_266)); - const _277: rt.RefCell<[rt.u8, string]> = rt.refCellBorrow(pair); - const tried4: rt.Result, [rt.RefCell<[rt.u8, string]>, rt.u8]> = rt.refTryMap(_277, ((p7: [rt.u8, string]): rt.Result => { + const _237: rs.RefCell = rs.refCellBorrowMut(number); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Debug(_237.value, f)]; + const _233: string = rs.fmtFormat([args6[0], " ", args6[1]]); + rs.refMutRelease(_237); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_233)); + rs.refMutRelease(bytes2); + const pair: rs.RefCell<[rs.u8, string]> = new rs.RefCell([op, "pair"] as [rs.u8, string]); + const _256: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_256.value[0], f), (f: rs.Formatter) => rs.fmtStr(_256.value[1], f)], f)]; + const _252: string = rs.fmtFormat([args8[0], " "]); + rs.refRelease(_256); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_252)); + const _270: rs.RefCell<[rs.u8, string]> = rs.refCellBorrowMut(pair); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_270.value[0], f), (f: rs.Formatter) => rs.fmtStr(_270.value[1], f)], f)]; + const _266: string = rs.fmtFormat([rs.fmtSpec({ alternate: true }, args10[0])]); + rs.refMutRelease(_270); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_266)); + const _277: rs.RefCell<[rs.u8, string]> = rs.refCellBorrow(pair); + const tried4: rs.Result, [rs.RefCell<[rs.u8, string]>, rs.u8]> = rs.refTryMap(_277, ((p7: [rs.u8, string]): rs.Result => { if (!((p7[0] & 1) === 0)) { - return rt.Err(p7[0]); + return rs.Err(p7[0]); } - return rt.Ok(p7[1]); + return rs.Ok(p7[1]); })(_277.value)); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried4, f, (value: rt.RefCell, f: rt.Formatter) => rt.fmtStr(value.value, f), (value: [rt.RefCell<[rt.u8, string]>, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0].value[0], f), (f: rt.Formatter) => rt.fmtStr(value[0].value[1], f)], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args12[0]]))); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried4, f, (value: rs.RefCell, f: rs.Formatter) => rs.fmtStr(value.value, f), (value: [rs.RefCell<[rs.u8, string]>, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0].value[0], f), (f: rs.Formatter) => rs.fmtStr(value[0].value[1], f)], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0]]))); drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(tried4); } else { - const _291: rt.u8 = op >> 4; + const _291: rs.u8 = op >> 4; if (_291 === 13) { - const _297: rt.RefCell = rt.refCellBorrowMut(parts); - const _whole: rt.RefCell = rt.resultUnwrapErr(rt.refMutTryMap(_297, ((_2: Parts.Parts): rt.Result, undefined> => { - return rt.ERR; - })(_297.value)), (value: rt.RefCell, f: rt.Formatter) => rt.u32Debug(value.value, f))[0]; - rt.refRelease(rt.refCellBorrow(parts)); - rt.refMutRelease(_whole); + const _297: rs.RefCell = rs.refCellBorrowMut(parts); + const _whole: rs.RefCell = rs.resultUnwrapErr(rs.refMutTryMap(_297, ((_2: Parts.Parts): rs.Result, undefined> => { + return rs.ERR; + })(_297.value)), (value: rs.RefCell, f: rs.Formatter) => rs.u32Debug(value.value, f))[0]; + rs.refRelease(rs.refCellBorrow(parts)); + rs.refMutRelease(_whole); } else if (_291 === 14) { - const _302: rt.RefCell = rt.refCellBorrow(parts); - const _n: rt.Result, [rt.RefCell, undefined]> = rt.refTryMap(_302, ((p2: Parts.Parts): rt.Result => { - return rt.Ok(p2.n); + const _302: rs.RefCell = rs.refCellBorrow(parts); + const _n: rs.Result, [rs.RefCell, undefined]> = rs.refTryMap(_302, ((p2: Parts.Parts): rs.Result => { + return rs.Ok(p2.n); })(_302.value)); - rt.refMutRelease(rt.refCellBorrowMut(parts)); + rs.refMutRelease(rs.refCellBorrowMut(parts)); drop$Result_cell_Ref_u32_tuple2_cell_Ref_borrows_Parts_unit(_n); } else if (_291 === 15) { - const _307: rt.RefCell = rt.refCellBorrowMut(parts); - const _n2: rt.Result, [rt.RefCell, undefined]> = rt.refMutTryMap(_307, ((p: Parts.Parts): rt.Result, undefined> => { - return rt.Ok(rt.place(() => p.n, (value) => p.n = value)); + const _307: rs.RefCell = rs.refCellBorrowMut(parts); + const _n2: rs.Result, [rs.RefCell, undefined]> = rs.refMutTryMap(_307, ((p: Parts.Parts): rs.Result, undefined> => { + return rs.Ok(rs.place(() => p.n, (value) => p.n = value)); })(_307.value)); - rt.refRelease(rt.refCellBorrow(parts)); + rs.refRelease(rs.refCellBorrow(parts)); drop$Result_cell_RefMut_u32_tuple2_cell_RefMut_borrows_Parts_unit(_n2); } else { - rt.byteVecPush(out, borrowed$borrows_Parts(parts)); + rs.byteVecPush(out, borrowed$borrows_Parts(parts)); } } flush(log.value, out); } const last2: Parts.Parts = parts.value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(last2.n & 0xff, option_mapOr$099335t(last2.maybe, 253, (m3: rt.u16): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(last2.n & 0xff, option_mapOr$031uhqp(last2.maybe, 253, (m3: rs.u16): rs.u8 => { return m3 & 0xff; })))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(last2.text)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last2.bytes)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(last2.text)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.bytes)); last2[Symbol.dispose](); flush(log.value, out); log[Symbol.dispose](); @@ -827,153 +827,153 @@ export function tries(data: rt.ByteSlice, out: rt.ByteVec): void { * cell holds, its value the operand; each puts what it read through them and whether the * cell is still borrowed, and borrows again while a leak holds it, which panics. */ -export function leaks(data: rt.ByteSlice, out: rt.ByteVec): void { - const pair: rt.RefCell<[rt.u16, rt.ByteVec]> = new rt.RefCell([0, new rt.ByteVec()] as [rt.u16, rt.ByteVec]); - const number: rt.RefCell = new rt.RefCell(0); - const quad: rt.RefCell = new rt.RefCell(Uint8Array.of(1, 2, 3, 4)); - for (const op of rt.byteSliceView(data)) { - const _16: rt.u8 = rt.u8Rem(op, 4); +export function leaks(data: rs.ByteSlice, out: rs.ByteVec): void { + const pair: rs.RefCell<[rs.u16, rs.ByteVec]> = new rs.RefCell([0, new rs.ByteVec()] as [rs.u16, rs.ByteVec]); + const number: rs.RefCell = new rs.RefCell(0); + const quad: rs.RefCell = new rs.RefCell(Uint8Array.of(1, 2, 3, 4)); + for (const op of rs.byteSliceView(data)) { + const _16: rs.u8 = rs.u8Rem(op, 4); if (_16 === 0) { - const whole: [rt.u16, rt.ByteVec] = rt.refCellBorrow(pair).value; - const other: rt.RefCell<[rt.u16, rt.ByteVec]> = rt.refCellBorrow(pair); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((whole[0] & 0xff) ^ (other.value[1].length & 0xff), borrowed$tuple2_u16_Vec_u8(pair)))); - rt.refRelease(other); - const _40: rt.RefCell<[rt.u16, rt.ByteVec]> = rt.refCellBorrow(pair); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.refMap(_40, ((p2: [rt.u16, rt.ByteVec]): rt.ByteVec => { + const whole: [rs.u16, rs.ByteVec] = rs.refCellBorrow(pair).value; + const other: rs.RefCell<[rs.u16, rs.ByteVec]> = rs.refCellBorrow(pair); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((whole[0] & 0xff) ^ (other.value[1].length & 0xff), borrowed$tuple2_u16_Vec_u8(pair)))); + rs.refRelease(other); + const _40: rs.RefCell<[rs.u16, rs.ByteVec]> = rs.refCellBorrow(pair); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.refMap(_40, ((p2: [rs.u16, rs.ByteVec]): rs.ByteVec => { return p2[1]; })(_40.value)).value)); - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); - rt.refCellUndoLeak(pair).value; - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + rs.refCellUndoLeak(pair).value; + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); } else if (_16 === 1) { - const n: rt.Place = rt.valuePlace(rt.refCellBorrowMut(number)); - n.v = rt.u32Add(n.v, op as rt.u32); - rt.byteVecPush(out, borrowed$u32(number)); - const _60: rt.Place = rt.valuePlace(rt.refCellUndoLeak(number)); + const n: rs.Place = rs.valuePlace(rs.refCellBorrowMut(number)); + n.v = rs.u32Add(n.v, op as rs.u32); + rs.byteVecPush(out, borrowed$u32(number)); + const _60: rs.Place = rs.valuePlace(rs.refCellUndoLeak(number)); _60.v = (_60.v ^ 1) >>> 0; - const _66: rt.u8 = borrowed$u32(number); - const _72: rt.RefCell = rt.refCellBorrow(number); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_66, _72.value & 0xff))); - rt.refRelease(_72); - const whole2: [rt.u16, rt.ByteVec] = rt.refCellBorrowMut(pair).value; - whole2[0] = rt.u16Add(whole2[0], op as rt.u16); - rt.byteVecPush(whole2[1], op); + const _66: rs.u8 = borrowed$u32(number); + const _72: rs.RefCell = rs.refCellBorrow(number); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_66, _72.value & 0xff))); + rs.refRelease(_72); + const whole2: [rs.u16, rs.ByteVec] = rs.refCellBorrowMut(pair).value; + whole2[0] = rs.u16Add(whole2[0], op as rs.u16); + rs.byteVecPush(whole2[1], op); if ((op >> 4) === 15) { - Object.assign(whole2, [op as rt.u16, rt.byteVecFrom(Uint8Array.of(op))] as [rt.u16, rt.ByteVec]); + Object.assign(whole2, [op as rs.u16, rs.byteVecFrom(Uint8Array.of(op))] as [rs.u16, rs.ByteVec]); } - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); - rt.byteVecPush(rt.refCellUndoLeak(pair).value[1], 252); - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); - const _100: rt.RefCell<[rt.u16, rt.ByteVec]> = rt.refCellBorrowMut(pair); - rt.byteVecPush(rt.refMutMap(_100, rt.partPlace(((p: [rt.u16, rt.ByteVec]): rt.ByteVec => { + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + rs.byteVecPush(rs.refCellUndoLeak(pair).value[1], 252); + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + const _100: rs.RefCell<[rs.u16, rs.ByteVec]> = rs.refCellBorrowMut(pair); + rs.byteVecPush(rs.refMutMap(_100, rs.partPlace(((p: [rs.u16, rs.ByteVec]): rs.ByteVec => { return p[1]; })(_100.value))).value, op); - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(pair.value[1])); + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(pair.value[1])); } else if (_16 === 2) { - const _112: rt.RefCell = rt.refCellBorrowMut(quad); - const f = (q3: rt.ByteSlice): rt.ByteSlice => { + const _112: rs.RefCell = rs.refCellBorrowMut(quad); + const f = (q3: rs.ByteSlice): rs.ByteSlice => { return q3; }; - const bytes3: rt.RefCell = rt.refMutMap(_112, rt.partPlace(rt.byteSliceView(((held) => f(rt.byteSliceFrom(held)))(_112.value)))); - const _114: rt.ByteSlice = rt.byteSliceFrom(bytes3.value); - const _116: rt.usize = (op & 3) as rt.usize; + const bytes3: rs.RefCell = rs.refMutMap(_112, rs.partPlace(rs.byteSliceView(((held) => f(rs.byteSliceFrom(held)))(_112.value)))); + const _114: rs.ByteSlice = rs.byteSliceFrom(bytes3.value); + const _116: rs.usize = (op & 3) as rs.usize; if (!(_116 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _116); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _116); } _114.data[_114.start + _116] = _114.data[_114.start + _116] ^ op; - const _120: rt.RefCell = bytes3; - const f2 = (q4: rt.ByteSlice): rt.ByteSlice => { + const _120: rs.RefCell = bytes3; + const f2 = (q4: rs.ByteSlice): rs.ByteSlice => { return q4; }; - const again: rt.RefCell = rt.refMutMap(_120, rt.partPlace(rt.byteSliceView(((held2) => f2(rt.byteSliceFrom(held2)))(_120.value)))); + const again: rs.RefCell = rs.refMutMap(_120, rs.partPlace(rs.byteSliceView(((held2) => f2(rs.byteSliceFrom(held2)))(_120.value)))); if ((op >> 4) === 15) { - const _125: rt.ByteSlice = rt.byteSliceFrom(again.value); - _125.data.set(rt.bytes(4).fill(op), _125.start); + const _125: rs.ByteSlice = rs.byteSliceFrom(again.value); + _125.data.set(rs.bytes(4).fill(op), _125.start); } - rt.byteVecPush(out, borrowed$array4_u8(quad)); - rt.refMutRelease(again); - const _133: rt.RefCell = rt.refCellBorrow(quad); - const f3 = (q5: rt.ByteSlice): rt.ByteSlice => { + rs.byteVecPush(out, borrowed$array4_u8(quad)); + rs.refMutRelease(again); + const _133: rs.RefCell = rs.refCellBorrow(quad); + const f3 = (q5: rs.ByteSlice): rs.ByteSlice => { return q5; }; - const read: rt.RefCell = rt.refMap(_133, rt.byteSliceView(((held3) => f3(rt.byteSliceFrom(held3)))(_133.value))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(read.value)); - rt.byteVecPush(out, borrowed$array4_u8(quad)); - rt.refRelease(read); - const _145: rt.RefCell = rt.refCellBorrowMut(quad); - const f4 = (q6: rt.ByteSlice): rt.ByteSlice | undefined => { - return thenSome$0zrlsto((q6.data[q6.start] & 1) === 0, q6); + const read: rs.RefCell = rs.refMap(_133, rs.byteSliceView(((held3) => f3(rs.byteSliceFrom(held3)))(_133.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(read.value)); + rs.byteVecPush(out, borrowed$array4_u8(quad)); + rs.refRelease(read); + const _145: rs.RefCell = rs.refCellBorrowMut(quad); + const f4 = (q6: rs.ByteSlice): rs.ByteSlice | undefined => { + return thenSome$1y1lbvl((q6.data[q6.start] & 1) === 0, q6); }; - const part = ((held4) => f4(rt.byteSliceFrom(held4)))(_145.value); - const _144: rt.Result, rt.RefCell> = rt.refMutFilterMap(_145, part === undefined ? undefined : rt.partPlace(rt.byteSliceView(part))); + const part = ((held4) => f4(rs.byteSliceFrom(held4)))(_145.value); + const _144: rs.Result, rs.RefCell> = rs.refMutFilterMap(_145, part === undefined ? undefined : rs.partPlace(rs.byteSliceView(part))); if (_144.ok) { - const q: rt.RefCell = _144.value; - const _151: rt.ByteSlice = rt.byteSliceFrom(q.value); - const _149: rt.u8 = rt.u8WrappingAdd(_151.data[_151.start + 1], op); - const _155: rt.ByteSlice = rt.byteSliceFrom(q.value); + const q: rs.RefCell = _144.value; + const _151: rs.ByteSlice = rs.byteSliceFrom(q.value); + const _149: rs.u8 = rs.u8WrappingAdd(_151.data[_151.start + 1], op); + const _155: rs.ByteSlice = rs.byteSliceFrom(q.value); _155.data[_155.start + 1] = _149; - rt.byteVecPush(out, borrowed$array4_u8(quad)); - rt.refMutRelease(q); + rs.byteVecPush(out, borrowed$array4_u8(quad)); + rs.refMutRelease(q); } else { - const whole3: rt.RefCell = _144.error; - const _165: rt.ByteSlice = rt.byteSliceFrom(whole3.value); - rt.byteVecPush(out, _165.data[_165.start] ^ borrowed$array4_u8(quad)); - rt.refMutRelease(whole3); + const whole3: rs.RefCell = _144.error; + const _165: rs.ByteSlice = rs.byteSliceFrom(whole3.value); + rs.byteVecPush(out, _165.data[_165.start] ^ borrowed$array4_u8(quad)); + rs.refMutRelease(whole3); } - const _173: rt.RefCell = rt.refCellBorrow(quad); - const f5 = (q7: rt.ByteSlice): rt.Result => { + const _173: rs.RefCell = rs.refCellBorrow(quad); + const f5 = (q7: rs.ByteSlice): rs.Result => { if (!((q7.data[q7.start + 2] & 1) === 0)) { - return rt.Err(q7.data[q7.start + 2]); + return rs.Err(q7.data[q7.start + 2]); } - return rt.Ok(q7); + return rs.Ok(q7); }; - const part2 = ((held5) => f5(rt.byteSliceFrom(held5)))(_173.value); - const _172: rt.Result, [rt.RefCell, rt.u8]> = rt.refTryMap(_173, part2.ok ? rt.Ok(rt.byteSliceView(part2.value)) : rt.Err(part2.error)); + const part2 = ((held5) => f5(rs.byteSliceFrom(held5)))(_173.value); + const _172: rs.Result, [rs.RefCell, rs.u8]> = rs.refTryMap(_173, part2.ok ? rs.Ok(rs.byteSliceView(part2.value)) : rs.Err(part2.error)); if (_172.ok) { - const q2: rt.RefCell = _172.value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(q2.value)); - rt.refRelease(q2); + const q2: rs.RefCell = _172.value; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(q2.value)); + rs.refRelease(q2); } else { - const whole4: rt.RefCell = _172.error[0]; - const e: rt.u8 = _172.error[1]; - const _184: rt.ByteSlice = rt.byteSliceFrom(whole4.value); - rt.byteVecPush(out, _184.data[_184.start + 3] ^ e); - rt.refRelease(whole4); + const whole4: rs.RefCell = _172.error[0]; + const e: rs.u8 = _172.error[1]; + const _184: rs.ByteSlice = rs.byteSliceFrom(whole4.value); + rs.byteVecPush(out, _184.data[_184.start + 3] ^ e); + rs.refRelease(whole4); } - const _190: rt.RefCell = rt.refCellBorrowMut(quad); - const f6 = (q8: rt.ByteSlice): rt.ByteSlice => { + const _190: rs.RefCell = rs.refCellBorrowMut(quad); + const f6 = (q8: rs.ByteSlice): rs.ByteSlice => { return q8; }; - rt.byteSliceRotateLeft(rt.byteSliceFrom(rt.refMutMap(_190, rt.partPlace(rt.byteSliceView(((held6) => f6(rt.byteSliceFrom(held6)))(_190.value)))).value), 1); - rt.byteVecPush(out, borrowed$array4_u8(quad)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.refCellUndoLeak(quad).value)); + rs.byteSliceRotateLeft(rs.byteSliceFrom(rs.refMutMap(_190, rs.partPlace(rs.byteSliceView(((held6) => f6(rs.byteSliceFrom(held6)))(_190.value)))).value), 1); + rs.byteVecPush(out, borrowed$array4_u8(quad)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.refCellUndoLeak(quad).value)); } else { - const _202: rt.u8 = op >> 4; + const _202: rs.u8 = op >> 4; if (_202 === 14) { - rt.refCellBorrow(pair).value; - rt.refMutRelease(rt.refCellBorrowMut(pair)); + rs.refCellBorrow(pair).value; + rs.refMutRelease(rs.refCellBorrowMut(pair)); } else if (_202 === 15) { - rt.valuePlace(rt.refCellBorrowMut(number)); - rt.refRelease(rt.refCellBorrow(number)); + rs.valuePlace(rs.refCellBorrowMut(number)); + rs.refRelease(rs.refCellBorrow(number)); } else { - rt.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); + rs.byteVecPush(out, borrowed$tuple2_u16_Vec_u8(pair)); } } } - const last: [rt.u16, rt.ByteVec] = pair.value; - rt.byteVecPush(out, last[0] & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last[1])); - rt.byteVecPush(out, number.value & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(quad.value)); + const last: [rs.u16, rs.ByteVec] = pair.value; + rs.byteVecPush(out, last[0] & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last[1])); + rs.byteVecPush(out, number.value & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(quad.value)); } /** Whether `cell` is borrowed exclusively, as 2, shared, as 1, or not at all. */ -export function borrowed$array4_u8(cell: rt.RefCell): rt.u8 { - let _0!: rt.u8; - const _5: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell); +export function borrowed$array4_u8(cell: rs.RefCell): rs.u8 { + let _0!: rs.u8; + const _5: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell); const _3: boolean = !_5.ok; - const _8: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(cell); + const _8: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(cell); const _2: [boolean, boolean] = [_3, !_8.ok]; if (!_3) { if (!_2[1]) { @@ -990,11 +990,11 @@ export function borrowed$array4_u8(cell: rt.RefCell): rt.u8 { } /** Whether `cell` is borrowed exclusively, as 2, shared, as 1, or not at all. */ -export function borrowed$borrows_Parts(cell: rt.RefCell): rt.u8 { - let _0!: rt.u8; - const _5: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell); +export function borrowed$borrows_Parts(cell: rs.RefCell): rs.u8 { + let _0!: rs.u8; + const _5: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell); const _3: boolean = !_5.ok; - const _8: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(cell); + const _8: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(cell); const _2: [boolean, boolean] = [_3, !_8.ok]; if (!_3) { if (!_2[1]) { @@ -1011,11 +1011,11 @@ export function borrowed$borrows_Parts(cell: rt.RefCell): rt.u8 { } /** Whether `cell` is borrowed exclusively, as 2, shared, as 1, or not at all. */ -export function borrowed$tuple2_u16_Vec_u8(cell: rt.RefCell<[rt.u16, rt.ByteVec]>): rt.u8 { - let _0!: rt.u8; - const _5: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell); +export function borrowed$tuple2_u16_Vec_u8(cell: rs.RefCell<[rs.u16, rs.ByteVec]>): rs.u8 { + let _0!: rs.u8; + const _5: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell); const _3: boolean = !_5.ok; - const _8: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(cell); + const _8: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(cell); const _2: [boolean, boolean] = [_3, !_8.ok]; if (!_3) { if (!_2[1]) { @@ -1032,11 +1032,11 @@ export function borrowed$tuple2_u16_Vec_u8(cell: rt.RefCell<[rt.u16, rt.ByteVec] } /** Whether `cell` is borrowed exclusively, as 2, shared, as 1, or not at all. */ -export function borrowed$u32(cell: rt.RefCell): rt.u8 { - let _0!: rt.u8; - const _5: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell); +export function borrowed$u32(cell: rs.RefCell): rs.u8 { + let _0!: rs.u8; + const _5: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell); const _3: boolean = !_5.ok; - const _8: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(cell); + const _8: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(cell); const _2: [boolean, boolean] = [_3, !_8.ok]; if (!_3) { if (!_2[1]) { @@ -1053,21 +1053,21 @@ export function borrowed$u32(cell: rt.RefCell): rt.u8 { } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_RefCell_u32(t: rt.RefCell): rt.RefCell { +export function twin$ref_cell_RefCell_u32(t: rs.RefCell): rs.RefCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_Arc_sync_Mutex_Vec_u8(t: rt.Arc>): rt.Arc> { +export function twin$ref_sync_Arc_sync_Mutex_Vec_u8(t: rs.Arc>): rs.Arc> { return t; } /** Puts what dropped since the last flush. */ -export function flush(log: rt.Mutex, out: rt.ByteVec): void { - const log2: rt.Mutex = rt.mutexLock(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log2.value)); - rt.byteVecClear(log2.value); - rt.mutexUnlock(log2); +export function flush(log: rs.Mutex, out: rs.ByteVec): void { + const log2: rs.Mutex = rs.mutexLock(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log2.value)); + rs.byteVecClear(log2.value); + rs.mutexUnlock(log2); } /** @@ -1077,102 +1077,102 @@ export function flush(log: rt.Mutex, out: rt.ByteVec): void { * holds; cells nested in cells, a vector, and a derived `Debug`; guards of cells, which * write the cell they lend; and `Cell`s of `Copy` values and an `UnsafeCell`. */ -export function printed(data: rt.ByteSlice, out: rt.ByteVec): void { +export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { let text!: string; - const number: rt.RefCell = new rt.RefCell(0); - const nested: rt.RefCell>> = new rt.RefCell(rt.vecFrom([new rt.RefCell(0)])); - const pair: rt.Cell<[rt.u8, rt.char]> = new rt.Cell([0, 97] as [rt.u8, rt.char]); - const shown: Shown.Shown = { cell: new rt.Cell(0), refcell: new rt.RefCell(new rt.ByteVec()) }; - for (const op of rt.byteSliceView(data)) { - const v: rt.u8 = op >> 3; - const _25: rt.u8 = rt.u8Rem(op, 8); + const number: rs.RefCell = new rs.RefCell(0); + const nested: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.RefCell(0)])); + const pair: rs.Cell<[rs.u8, rs.char]> = new rs.Cell([0, 97] as [rs.u8, rs.char]); + const shown: Shown.Shown = { cell: new rs.Cell(0), refcell: new rs.RefCell(new rs.ByteVec()) }; + for (const op of rs.byteSliceView(data)) { + const v: rs.u8 = op >> 3; + const _25: rs.u8 = rs.u8Rem(op, 8); if (_25 === 0) { - const _27: rt.u32 = v as rt.u32; - const _30: rt.RefCell = rt.refCellBorrowMut(number); - _30.value = rt.u32Add(_30.value, _27); - rt.refMutRelease(_30); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(number, f, rt.u32Debug)]; - const free: string = rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0]), " ", rt.fmtSpec({ align: ">", width: 4 }, args2[0])]); - const shared: rt.RefCell = rt.refCellBorrow(number); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(number, f, rt.u32Debug)]; - const read: string = rt.fmtFormat([args4[0]]); - rt.refRelease(shared); - const _held: rt.RefCell = rt.refCellBorrowMut(number); - const dynamic: rt.Fmt = (f: rt.Formatter) => rt.refCellDebug(number, f, rt.u32Debug); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free), (f: rt.Formatter) => rt.fmtPad(f, read), (f: rt.Formatter) => rt.refCellDebug(number, f, rt.u32Debug), (f: rt.Formatter) => dynamic(f)]; - text = rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rt.fmtSpec({ alternate: true }, args6[2]), " ", rt.fmtSpec({ align: ">", width: 16 }, args6[2]), " ", args6[3]]); - rt.refMutRelease(_held); + const _27: rs.u32 = v as rs.u32; + const _30: rs.RefCell = rs.refCellBorrowMut(number); + _30.value = rs.u32Add(_30.value, _27); + rs.refMutRelease(_30); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; + const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const shared: rs.RefCell = rs.refCellBorrow(number); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug)]; + const read: string = rs.fmtFormat([args4[0]]); + rs.refRelease(shared); + const _held: rs.RefCell = rs.refCellBorrowMut(number); + const dynamic: rs.Fmt = (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, read), (f: rs.Formatter) => rs.refCellDebug(number, f, rs.u32Debug), (f: rs.Formatter) => dynamic(f)]; + text = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " ", rs.fmtSpec({ alternate: true }, args6[2]), " ", rs.fmtSpec({ align: ">", width: 16 }, args6[2]), " ", args6[3]]); + rs.refMutRelease(_held); } else if (_25 === 1) { - const _75: rt.RefCell>> = rt.refCellBorrowMut(nested); - const _77: rt.RefCell = new rt.RefCell(thenSome$0d5am30(rt.u8Rem(v, 3) !== 0, v)); + const _75: rs.RefCell>> = rs.refCellBorrowMut(nested); + const _77: rs.RefCell = new rs.RefCell(thenSome$0quywni(rs.u8Rem(v, 3) !== 0, v)); _75.value.items.push(_77); - rt.refMutRelease(_75); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(nested, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.RefCell, f: rt.Formatter) => rt.refCellDebug(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))))]; - const free2: string = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0])]); - const cells: rt.RefCell>> = rt.refCellBorrow(nested); - const _95: rt.Vec> = cells.value; - const _inner: rt.RefCell = rt.refCellBorrowMut(_95.items[rt.idx(_95.items, rt.usizeSub(cells.value.items.length, 1))]); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free2), (f: rt.Formatter) => rt.refCellDebug(nested, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.RefCell, f: rt.Formatter) => rt.refCellDebug(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))))]; - text = rt.fmtFormat([args10[0], " ", args10[1], " ", rt.fmtSpec({ alternate: true }, args10[1])]); - rt.refMutRelease(_inner); - rt.refRelease(cells); + rs.refMutRelease(_75); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + const free2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0])]); + const cells: rs.RefCell>> = rs.refCellBorrow(nested); + const _95: rs.Vec> = cells.value; + const _inner: rs.RefCell = rs.refCellBorrowMut(_95.items[rs.idx(_95.items, rs.usizeSub(cells.value.items.length, 1))]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.refCellDebug(nested, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))))]; + text = rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])]); + rs.refMutRelease(_inner); + rs.refRelease(cells); } else if (_25 === 2) { - const outer: rt.RefCell> = new rt.RefCell(new rt.RefCell(v)); - const shared2: rt.RefCell> = rt.refCellBorrow(outer); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(shared2.value, f, rt.u8Debug)]; - const free3: string = rt.fmtFormat([args12[0], " ", rt.fmtSpec({ alternate: true }, args12[0])]); - rt.refRelease(shared2); - const exclusive: rt.RefCell> = rt.refCellBorrowMut(outer); - const inner: rt.RefCell = rt.refCellBorrowMut(exclusive.value); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(exclusive.value, f, rt.u8Debug), (f: rt.Formatter) => rt.refCellDebug(outer, f, (value: rt.RefCell, f: rt.Formatter) => rt.refCellDebug(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.u8Debug(inner.value, f)]; - const held: string = rt.fmtFormat([args14[0], " ", rt.fmtSpec({ alternate: true }, args14[0]), " ", args14[1], " ", args14[2]]); - rt.refMutRelease(inner); - const _146: rt.RefCell>> = rt.refCellBorrow(nested); - const last: rt.RefCell> = rt.refMap(_146, ((n: rt.Vec>): rt.RefCell => { - return n.items[rt.idx(n.items, 0)]; + const outer: rs.RefCell> = new rs.RefCell(new rs.RefCell(v)); + const shared2: rs.RefCell> = rs.refCellBorrow(outer); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(shared2.value, f, rs.u8Debug)]; + const free3: string = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]); + rs.refRelease(shared2); + const exclusive: rs.RefCell> = rs.refCellBorrowMut(outer); + const inner: rs.RefCell = rs.refCellBorrowMut(exclusive.value); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(outer, f, (value: rs.RefCell, f: rs.Formatter) => rs.refCellDebug(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.u8Debug(inner.value, f)]; + const held: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", args14[1], " ", args14[2]]); + rs.refMutRelease(inner); + const _146: rs.RefCell>> = rs.refCellBorrow(nested); + const last: rs.RefCell> = rs.refMap(_146, ((n: rs.Vec>): rs.RefCell => { + return n.items[rs.idx(n.items, 0)]; })(_146.value)); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free3), (f: rt.Formatter) => rt.fmtPad(f, held), (f: rt.Formatter) => rt.refCellDebug(exclusive.value, f, rt.u8Debug), (f: rt.Formatter) => rt.refCellDebug(last.value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - text = rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); - rt.refRelease(last); - rt.refMutRelease(exclusive); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free3), (f: rs.Formatter) => rs.fmtPad(f, held), (f: rs.Formatter) => rs.refCellDebug(exclusive.value, f, rs.u8Debug), (f: rs.Formatter) => rs.refCellDebug(last.value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + text = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); + rs.refRelease(last); + rs.refMutRelease(exclusive); } else if (_25 === 3) { - const _164: [rt.u8, rt.char] = [rt.u8WrappingAdd(pair.v[0], v), rt.u8Add(97, rt.u8Rem(v, 26)) as rt.char]; - rt.cellSet(pair, _164); - const wide: rt.Cell = new rt.Cell(rt.u64Shl(v as rt.u64, 56)); - const maybe: rt.Cell = new rt.Cell(thenSome$0d5am30(rt.u8Rem(v, 2) === 0, v)); - const _184: rt.Cell = new rt.Cell(undefined); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.cellDebug(() => pair.v, f, (value: [rt.u8, rt.char], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtCharDebug(value[1], f)], f)), (f: rt.Formatter) => rt.cellDebug(() => wide.v, f, rt.u64Debug), (f: rt.Formatter) => rt.cellDebug(() => maybe.v, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.cellDebug(() => _184.v, f, rt.fmtUnit)]; - text = rt.fmtFormat([args18[0], " ", rt.fmtSpec({ alternate: true }, args18[0]), " ", args18[1], " ", args18[2], " ", rt.fmtSpec({ alternate: true }, args18[2]), " ", args18[3], " ", rt.fmtSpec({ align: ">", width: 3 }, args18[0])]); + const _164: [rs.u8, rs.char] = [rs.u8WrappingAdd(pair.v[0], v), rs.u8Add(97, rs.u8Rem(v, 26)) as rs.char]; + rs.cellSet(pair, _164); + const wide: rs.Cell = new rs.Cell(rs.u64Shl(v as rs.u64, 56)); + const maybe: rs.Cell = new rs.Cell(thenSome$0quywni(rs.u8Rem(v, 2) === 0, v)); + const _184: rs.Cell = new rs.Cell(undefined); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.cellDebug(() => pair.v, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f)), (f: rs.Formatter) => rs.cellDebug(() => wide.v, f, rs.u64Debug), (f: rs.Formatter) => rs.cellDebug(() => maybe.v, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.cellDebug(() => _184.v, f, rs.fmtUnit)]; + text = rs.fmtFormat([args18[0], " ", rs.fmtSpec({ alternate: true }, args18[0]), " ", args18[1], " ", args18[2], " ", rs.fmtSpec({ alternate: true }, args18[2]), " ", args18[3], " ", rs.fmtSpec({ align: ">", width: 3 }, args18[0])]); } else if (_25 === 4) { - rt.cellSet(shown.cell, v); - const _204: rt.RefCell = rt.refCellBorrowMut(shown.refcell); - rt.byteVecPush(_204.value, v); - rt.refMutRelease(_204); - const args20: rt.Fmt[] = [(f: rt.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - const free4: string = rt.fmtFormat([args20[0], " ", rt.fmtSpec({ alternate: true }, args20[0])]); - const _held2: rt.RefCell = rt.refCellBorrowMut(shown.refcell); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free4), (f: rt.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; - text = rt.fmtFormat([args22[0], " ", args22[1], " ", rt.fmtSpec({ alternate: true }, args22[1])]); - rt.refMutRelease(_held2); + rs.cellSet(shown.cell, v); + const _204: rs.RefCell = rs.refCellBorrowMut(shown.refcell); + rs.byteVecPush(_204.value, v); + rs.refMutRelease(_204); + const args20: rs.Fmt[] = [(f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + const free4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])]); + const _held2: rs.RefCell = rs.refCellBorrowMut(shown.refcell); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free4), (f: rs.Formatter) => Shown.fmt$fmt_Debug(shown, f)]; + text = rs.fmtFormat([args22[0], " ", args22[1], " ", rs.fmtSpec({ alternate: true }, args22[1])]); + rs.refMutRelease(_held2); } else if (_25 === 5) { - new rt.Cell(v); - const inRefcell: rt.RefCell> = new rt.RefCell(new rt.Cell(v)); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "UnsafeCell")), (f: rt.Formatter) => rt.refCellDebug(inRefcell, f, (value: rt.Cell, f: rt.Formatter) => rt.cellDebug(() => value.v, f, rt.u8Debug))]; - text = rt.fmtFormat([args24[0], " ", rt.fmtSpec({ alternate: true }, args24[0]), " ", args24[1], " ", rt.fmtSpec({ alternate: true }, args24[1])]); + new rs.Cell(v); + const inRefcell: rs.RefCell> = new rs.RefCell(new rs.Cell(v)); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.refCellDebug(inRefcell, f, (value: rs.Cell, f: rs.Formatter) => rs.cellDebug(() => value.v, f, rs.u8Debug))]; + text = rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0]), " ", args24[1], " ", rs.fmtSpec({ alternate: true }, args24[1])]); } else if (_25 === 6) { - const probe: rt.Arc> = rt.arcNewCyclic((me: rt.Weak>): rt.RefCell => { - return new rt.RefCell(new Probe.Probe(rt.weakClone(me))); + const probe: rs.Arc> = rs.arcNewCyclic((me: rs.Weak>): rs.RefCell => { + return new rs.RefCell(new Probe.Probe(rs.weakClone(me))); }); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(probe.value, f, (value: Probe.Probe, f: rt.Formatter) => Probe.fmt$fmt_Debug(value, f))]; - text = rt.fmtFormat([args26[0], " ", rt.fmtSpec({ alternate: true }, args26[0])]); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(probe.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; + text = rs.fmtFormat([args26[0], " ", rs.fmtSpec({ alternate: true }, args26[0])]); probe[Symbol.dispose](); } else { - const _253: rt.RefCell = new rt.RefCell("s"); - const _256: rt.RefCell = new rt.RefCell(rt.bytes(2).fill(v)); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(_253, f, rt.fmtStr), (f: rt.Formatter) => rt.refCellDebug(_256, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - text = rt.fmtFormat([args28[0], " ", args28[1]]); + const _253: rs.RefCell = new rs.RefCell("s"); + const _256: rs.RefCell = new rs.RefCell(rs.bytes(2).fill(v)); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(_253, f, rs.fmtStr), (f: rs.Formatter) => rs.refCellDebug(_256, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + text = rs.fmtFormat([args28[0], " ", args28[1]]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } } diff --git a/ts/fixtures/lang/borrows/expected/core/bool.ts b/ts/fixtures/lang/borrows/expected/core/bool.ts index b5044cb9b..31a0f9948 100644 --- a/ts/fixtures/lang/borrows/expected/core/bool.ts +++ b/ts/fixtures/lang/borrows/expected/core/bool.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Tagged from "../borrows.Tagged.ts"; -export function thenSome$0zrlsto(self: boolean, t: rt.ByteSlice): rt.ByteSlice | undefined { +export function thenSome$1y1lbvl(self: boolean, t: rs.ByteSlice): rs.ByteSlice | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function then$1jgls7y(self: boolean, f: () => rt.RefCell): rt.RefCell | undefined { +export function then$0d67oqn(self: boolean, f: () => rs.RefCell): rs.RefCell | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/borrows/expected/core/option.ts b/ts/fixtures/lang/borrows/expected/core/option.ts index 88326f40d..1e977e6c3 100644 --- a/ts/fixtures/lang/borrows/expected/core/option.ts +++ b/ts/fixtures/lang/borrows/expected/core/option.ts @@ -1,49 +1,49 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Noisy from "../borrows.Noisy.ts"; import type * as Tagged from "../borrows.Tagged.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$0qqbaqw(self: Noisy.Noisy | undefined, default_: rt.u8, f: (a0: Noisy.Noisy) => rt.u8): rt.u8 { +export function mapOr$0yt2o85(self: Noisy.Noisy | undefined, default_: rs.u8, f: (a0: Noisy.Noisy) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1dvn0au(self: Tagged.Tagged | undefined, default_: rt.u8, f: (a0: Tagged.Tagged) => rt.u8): rt.u8 { +export function mapOr$0rsyyii(self: Tagged.Tagged | undefined, default_: rs.u8, f: (a0: Tagged.Tagged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0ucbp7g(self: [rt.u64, rt.u64] | undefined, default_: rt.u8, f: (a0: [rt.u64, rt.u64]) => rt.u8): rt.u8 { +export function mapOr$1idpb1d(self: [rs.u64, rs.u64] | undefined, default_: rs.u8, f: (a0: [rs.u64, rs.u64]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$099335t(self: rt.u16 | undefined, default_: rt.u8, f: (a0: rt.u16) => rt.u8): rt.u8 { +export function mapOr$031uhqp(self: rs.u16 | undefined, default_: rs.u8, f: (a0: rs.u16) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function okOr$1oufq9m(self: rt.u8 | undefined, err: rt.usize): rt.Result { +export function okOr$1bx6za5(self: rs.u8 | undefined, err: rs.usize): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/borrows/expected/core/result.ts b/ts/fixtures/lang/borrows/expected/core/result.ts index f6bcfd668..89334c521 100644 --- a/ts/fixtures/lang/borrows/expected/core/result.ts +++ b/ts/fixtures/lang/borrows/expected/core/result.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$0n1xnuw(self: rt.Result, rt.BorrowMutError>, op: (a0: rt.RefCell) => rt.u8): rt.Result { +export function map$0jl4kv2(self: rs.Result, rs.BorrowMutError>, op: (a0: rs.RefCell) => rs.u8): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function unwrapOr$0k9nfhn(self: rt.Result, default_: rt.u8): rt.u8 { +export function unwrapOr$1bnshxn(self: rs.Result, default_: rs.u8): rs.u8 { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/borrows/expected/harness.ts b/ts/fixtures/lang/borrows/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/borrows/expected/harness.ts +++ b/ts/fixtures/lang/borrows/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/borrows/expected/lib.ts b/ts/fixtures/lang/borrows/expected/lib.ts index 5de0b2e7e..54bc53e1b 100644 --- a/ts/fixtures/lang/borrows/expected/lib.ts +++ b/ts/fixtures/lang/borrows/expected/lib.ts @@ -1,202 +1,202 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { borrows, guards, maps, tries, leaks, printed } from "./borrows.ts"; import type * as Parts from "./borrows.Parts.ts"; import type * as Probe from "./borrows.Probe.ts"; import type * as Tagged from "./borrows.Tagged.ts"; -export function copy$Option_tuple2_u64_u64(v: [rt.u64, rt.u64] | undefined): [rt.u64, rt.u64] | undefined { +export function copy$Option_tuple2_u64_u64(v: [rs.u64, rs.u64] | undefined): [rs.u64, rs.u64] | undefined { return v === undefined ? v : copy$tuple2_u64_u64(v); } -export function copy$tuple2_u64_u64(v: [rt.u64, rt.u64]): [rt.u64, rt.u64] { +export function copy$tuple2_u64_u64(v: [rs.u64, rs.u64]): [rs.u64, rs.u64] { return [v[0], v[1]]; } -export function drop$Option_cell_RefMut_borrows_Tagged(_1: rt.RefCell | undefined): void { +export function drop$Option_cell_RefMut_borrows_Tagged(_1: rs.RefCell | undefined): void { if (_1 !== undefined) { - rt.refMutRelease(_1); + rs.refMutRelease(_1); } } -export function drop$Option_cell_Ref_borrows_Tagged(_1: rt.RefCell | undefined): void { +export function drop$Option_cell_Ref_borrows_Tagged(_1: rs.RefCell | undefined): void { if (_1 !== undefined) { - rt.refRelease(_1); + rs.refRelease(_1); } } -export function drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_Vec_u8_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_array4_u8_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_array4_u8_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_borrows_Parts_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_borrows_Parts_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_borrows_Probe_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_borrows_Probe_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_borrows_Tagged_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_tuple2_u16_Vec_u8_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_tuple2_u16_Vec_u8_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_u32_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_u32_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_u32_tuple2_cell_RefMut_borrows_Parts_unit(_1: rt.Result, [rt.RefCell, undefined]>): void { +export function drop$Result_cell_RefMut_u32_tuple2_cell_RefMut_borrows_Parts_unit(_1: rs.Result, [rs.RefCell, undefined]>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$tuple2_cell_RefMut_borrows_Parts_unit(_1.error); } } -export function drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_array4_u8_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_array4_u8_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_borrows_Parts_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_borrows_Parts_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_borrows_Probe_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_borrows_Probe_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: rt.Result, [rt.RefCell<[rt.u8, string]>, rt.u8]>): void { +export function drop$Result_cell_Ref_ref_str_tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: rs.Result, [rs.RefCell<[rs.u8, string]>, rs.u8]>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1.error); } } -export function drop$Result_cell_Ref_tuple2_u16_Vec_u8_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_tuple2_u16_Vec_u8_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_u32_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_u32_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts(_1: rt.Result, rt.RefCell>): void { +export function drop$Result_cell_Ref_u32_cell_Ref_borrows_Parts(_1: rs.Result, rs.RefCell>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { - rt.refRelease(_1.error); + rs.refRelease(_1.error); } } -export function drop$Result_cell_Ref_u32_tuple2_cell_Ref_borrows_Parts_unit(_1: rt.Result, [rt.RefCell, undefined]>): void { +export function drop$Result_cell_Ref_u32_tuple2_cell_Ref_borrows_Parts_unit(_1: rs.Result, [rs.RefCell, undefined]>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$tuple2_cell_Ref_borrows_Parts_unit(_1.error); } } -export function drop$tuple2_Option_cell_Ref_borrows_Tagged_Option_cell_RefMut_borrows_Tagged(_1: [rt.RefCell | undefined, rt.RefCell | undefined]): void { +export function drop$tuple2_Option_cell_Ref_borrows_Tagged_Option_cell_RefMut_borrows_Tagged(_1: [rs.RefCell | undefined, rs.RefCell | undefined]): void { drop$Option_cell_Ref_borrows_Tagged(_1[0]); drop$Option_cell_RefMut_borrows_Tagged(_1[1]); } -export function drop$tuple2_Result_cell_Ref_Vec_u8_cell_BorrowError_cell_Ref_Vec_u8(_1: [rt.Result, rt.BorrowError>, rt.RefCell]): void { +export function drop$tuple2_Result_cell_Ref_Vec_u8_cell_BorrowError_cell_Ref_Vec_u8(_1: [rs.Result, rs.BorrowError>, rs.RefCell]): void { drop$Result_cell_Ref_Vec_u8_cell_BorrowError(_1[0]); - rt.refRelease(_1[1]); + rs.refRelease(_1[1]); } -export function drop$tuple2_cell_RefMut_borrows_Parts_unit(_1: [rt.RefCell, undefined]): void { - rt.refMutRelease(_1[0]); +export function drop$tuple2_cell_RefMut_borrows_Parts_unit(_1: [rs.RefCell, undefined]): void { + rs.refMutRelease(_1[0]); } -export function drop$tuple2_cell_RefMut_slice_u8_cell_RefMut_slice_u8(_1: [rt.RefCell, rt.RefCell]): void { - rt.refMutRelease(_1[0]); - rt.refMutRelease(_1[1]); +export function drop$tuple2_cell_RefMut_slice_u8_cell_RefMut_slice_u8(_1: [rs.RefCell, rs.RefCell]): void { + rs.refMutRelease(_1[0]); + rs.refMutRelease(_1[1]); } -export function drop$tuple2_cell_Ref_Vec_u8_cell_Ref_u8(_1: [rt.RefCell, rt.RefCell]): void { - rt.refRelease(_1[0]); - rt.refRelease(_1[1]); +export function drop$tuple2_cell_Ref_Vec_u8_cell_Ref_u8(_1: [rs.RefCell, rs.RefCell]): void { + rs.refRelease(_1[0]); + rs.refRelease(_1[1]); } -export function drop$tuple2_cell_Ref_borrows_Parts_unit(_1: [rt.RefCell, undefined]): void { - rt.refRelease(_1[0]); +export function drop$tuple2_cell_Ref_borrows_Parts_unit(_1: [rs.RefCell, undefined]): void { + rs.refRelease(_1[0]); } -export function drop$tuple2_cell_Ref_str_cell_RefMut_u32(_1: [rt.RefCell, rt.RefCell]): void { - rt.refRelease(_1[0]); - rt.refMutRelease(_1[1]); +export function drop$tuple2_cell_Ref_str_cell_RefMut_u32(_1: [rs.RefCell, rs.RefCell]): void { + rs.refRelease(_1[0]); + rs.refMutRelease(_1[1]); } -export function drop$tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: [rt.RefCell<[rt.u8, string]>, rt.u8]): void { - rt.refRelease(_1[0]); +export function drop$tuple2_cell_Ref_tuple2_u8_ref_str_u8(_1: [rs.RefCell<[rs.u8, string]>, rs.u8]): void { + rs.refRelease(_1[0]); } -export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rt.RefCell, rt.RefCell, rt.RefCell]): void { - rt.refRelease(_1[0]); - rt.refRelease(_1[1]); - rt.refRelease(_1[2]); +export function drop$tuple3_cell_Ref_String_cell_Ref_array4_u8_cell_Ref_u32(_1: [rs.RefCell, rs.RefCell, rs.RefCell]): void { + rs.refRelease(_1[0]); + rs.refRelease(_1[1]); + rs.refRelease(_1[2]); } /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["borrows::borrows", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["borrows::borrows", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { borrows(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::guards", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["borrows::guards", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { guards(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::maps", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["borrows::maps", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { maps(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::tries", (_25: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["borrows::tries", (_25: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { tries(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::leaks", (_26: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["borrows::leaks", (_26: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { leaks(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["borrows::printed", (_27: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["borrows::printed", (_27: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { printed(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/bounds/expected/bounds.Asked.ts b/ts/fixtures/lang/bounds/expected/bounds.Asked.ts index 13eb6b833..d2b1afcf7 100644 --- a/ts/fixtures/lang/bounds/expected/bounds.Asked.ts +++ b/ts/fixtures/lang/bounds/expected/bounds.Asked.ts @@ -1,35 +1,35 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./bounds.ts"; /** The crate's own range, which logs each bound std asks it for: 0xa5 its start, 0xae its end. */ export class Asked { - start: rt.RangeBound; - end: rt.RangeBound; + start: rs.RangeBound; + end: rs.RangeBound; - constructor(start: rt.RangeBound, end: rt.RangeBound) { + constructor(start: rs.RangeBound, end: rs.RangeBound) { this.start = start; this.end = end; } } -export function startBound$ops_RangeBounds_u8_u8(self: Asked): rt.RangeBound { +export function startBound$ops_RangeBounds_u8_u8(self: Asked): rs.RangeBound { log(165); return self.start; } -export function startBound$ops_RangeBounds_usize_usize(self: Asked): rt.RangeBound { +export function startBound$ops_RangeBounds_usize_usize(self: Asked): rs.RangeBound { log(165); return self.start; } -export function endBound$ops_RangeBounds_u8_u8(self: Asked): rt.RangeBound { +export function endBound$ops_RangeBounds_u8_u8(self: Asked): rs.RangeBound { log(174); return self.end; } -export function endBound$ops_RangeBounds_usize_usize(self: Asked): rt.RangeBound { +export function endBound$ops_RangeBounds_usize_usize(self: Asked): rs.RangeBound { log(174); return self.end; } diff --git a/ts/fixtures/lang/bounds/expected/bounds.Item.ts b/ts/fixtures/lang/bounds/expected/bounds.Item.ts index e632e7244..c0909fd43 100644 --- a/ts/fixtures/lang/bounds/expected/bounds.Item.ts +++ b/ts/fixtures/lang/bounds/expected/bounds.Item.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./bounds.ts"; /** Logs its tag as it drops. */ export class Item { - tag: rt.u8; + tag: rs.u8; - constructor(tag: rt.u8) { + constructor(tag: rs.u8) { this.tag = tag; } diff --git a/ts/fixtures/lang/bounds/expected/bounds.Key.ts b/ts/fixtures/lang/bounds/expected/bounds.Key.ts index 0cf81a1db..73f38d248 100644 --- a/ts/fixtures/lang/bounds/expected/bounds.Key.ts +++ b/ts/fixtures/lang/bounds/expected/bounds.Key.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./bounds.ts"; /** @@ -8,7 +8,7 @@ import { log } from "./bounds.ts"; * which logs each `==` and `partial_cmp`: 0xe9 and 0xc9. */ export interface Key { - _0: rt.u8; + _0: rs.u8; } export function eq$cmp_PartialEq(self: Key, other: Key): boolean { @@ -16,11 +16,11 @@ export function eq$cmp_PartialEq(self: Key, other: Key): boolean { return self._0 === other._0; } -export function cmp$cmp_Ord(self: Key, other: Key): rt.Ordering { - return rt.cmp(other._0, self._0); +export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { + return rs.cmp(other._0, self._0); } -export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rs.Ordering | undefined { log(201); return cmp$cmp_Ord(self, other); } diff --git a/ts/fixtures/lang/bounds/expected/bounds.ts b/ts/fixtures/lang/bounds/expected/bounds.ts index ba56b5151..89b919f2e 100644 --- a/ts/fixtures/lang/bounds/expected/bounds.ts +++ b/ts/fixtures/lang/bounds/expected/bounds.ts @@ -1,321 +1,321 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Asked from "./bounds.Asked.ts"; import * as Item from "./bounds.Item.ts"; import * as Key from "./bounds.Key.ts"; -import { map$1iekgsb as option_map$1iekgsb, map$1hdkvwd as option_map$1hdkvwd, map$0a57co2 as option_map$0a57co2 } from "./core/option.ts"; +import { map$1i6no0n as option_map$1i6no0n, map$1c8069b as option_map$1c8069b, map$04ry0e1 as option_map$04ry0e1 } from "./core/option.ts"; -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LOG$init, false); +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); -export function LOG$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function LOG$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } -export function log(entry: rt.u8): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, entry); +export function log(entry: rs.u8): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, entry); }); } /** Puts what was logged since the last flush. */ -export function flush(out: rt.ByteVec): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); - rt.byteVecClear(log); +export function flush(out: rs.ByteVec): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); + rs.byteVecClear(log); }); } -export function bound$ref_bounds_Key(kind: rt.u8, at: Key.Key): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$ref_bounds_Key(kind: rs.u8, at: Key.Key): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound; + return { tag: "Included", _0: at } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound; + return { tag: "Excluded", _0: at } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function bound$ref_tuple2_u8_bounds_Key(kind: rt.u8, at: [rt.u8, Key.Key]): rt.RangeBound<[rt.u8, Key.Key]> { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$ref_tuple2_u8_bounds_Key(kind: rs.u8, at: [rs.u8, Key.Key]): rs.RangeBound<[rs.u8, Key.Key]> { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound<[rt.u8, Key.Key]>; + return { tag: "Included", _0: at } as rs.RangeBound<[rs.u8, Key.Key]>; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound<[rt.u8, Key.Key]>; + return { tag: "Excluded", _0: at } as rs.RangeBound<[rs.u8, Key.Key]>; } - return { tag: "Unbounded" } as rt.RangeBound<[rt.u8, Key.Key]>; + return { tag: "Unbounded" } as rs.RangeBound<[rs.u8, Key.Key]>; } -export function bound$ref_u8(kind: rt.u8, at: rt.u8): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$ref_u8(kind: rs.u8, at: rs.u8): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound; + return { tag: "Included", _0: at } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound; + return { tag: "Excluded", _0: at } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function bound$ref_usize(kind: rt.u8, at: rt.usize): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$ref_usize(kind: rs.u8, at: rs.usize): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound; + return { tag: "Included", _0: at } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound; + return { tag: "Excluded", _0: at } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function bound$u8(kind: rt.u8, at: rt.u8): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$u8(kind: rs.u8, at: rs.u8): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound; + return { tag: "Included", _0: at } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound; + return { tag: "Excluded", _0: at } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function bound$usize(kind: rt.u8, at: rt.usize): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function bound$usize(kind: rs.u8, at: rs.usize): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: at } as rt.RangeBound; + return { tag: "Included", _0: at } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: at } as rt.RangeBound; + return { tag: "Excluded", _0: at } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function asked$u8(s: rt.u8, e: rt.u8, a: rt.u8, b: rt.u8): Asked.Asked { +export function asked$u8(s: rs.u8, e: rs.u8, a: rs.u8, b: rs.u8): Asked.Asked { return new Asked.Asked(bound$u8(s, a), bound$u8(e, b)); } -export function asked$usize(s: rt.u8, e: rt.u8, a: rt.usize, b: rt.usize): Asked.Asked { +export function asked$usize(s: rs.u8, e: rs.u8, a: rs.usize, b: rs.usize): Asked.Asked { return new Asked.Asked(bound$usize(s, a), bound$usize(e, b)); } /** The keys of `set` within `range`, through a generic function, as each instance has it. */ -export function within$bounds_Asked_u8(set: rt.BTreeSet, range: Asked.Asked): rt.usize { - return rt.iterCount(rt.btreeRangeKeys(set, rt.boundsOf(range, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8))); +export function within$bounds_Asked_u8(set: rs.BTreeSet, range: Asked.Asked): rs.usize { + return rs.iterCount(rs.btreeRangeKeys(set, rs.boundsOf(range, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8))); } /** The keys of `set` within `range`, through a generic function, as each instance has it. */ -export function within$tuple2_ops_Bound_u8_ops_Bound_u8(set: rt.BTreeSet, range: [rt.RangeBound, rt.RangeBound]): rt.usize { - return rt.iterCount(rt.btreeRangeKeys(set, range)); +export function within$tuple2_ops_Bound_u8_ops_Bound_u8(set: rs.BTreeSet, range: [rs.RangeBound, rs.RangeBound]): rs.usize { + return rs.iterCount(rs.btreeRangeKeys(set, range)); } /** * `kind` picks the collection and how its range is given. The first two bytes pick the * kinds of the range's bounds, the next two their values, and the rest are the items. */ -export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - rt.localKeyWithBorrowMut(LOG, (a0: rt.ByteVec): undefined => { - rt.byteVecClear(a0); +export function bounds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + rs.localKeyWithBorrowMut(LOG, (a0: rs.ByteVec): undefined => { + rs.byteVecClear(a0); }); if (data.length >= 4) { - const s: rt.u8 = data.data[data.start]; - const e: rt.u8 = data.data[data.start + 1]; - const a: rt.u8 = data.data[data.start + 2]; - const b: rt.u8 = data.data[data.start + 3]; - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 4).length, 2); - const _18: [rt.usize, rt.usize] = [rt.usizeRem(a as rt.usize, reach), rt.usizeRem(b as rt.usize, reach)]; - const i: rt.usize = _18[0]; - const j: rt.usize = _18[1]; - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_2: rt.u8): Item.Item => { + const s: rs.u8 = data.data[data.start]; + const e: rs.u8 = data.data[data.start + 1]; + const a: rs.u8 = data.data[data.start + 2]; + const b: rs.u8 = data.data[data.start + 3]; + const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 4).length, 2); + const _18: [rs.usize, rs.usize] = [rs.usizeRem(a as rs.usize, reach), rs.usizeRem(b as rs.usize, reach)]; + const i: rs.usize = _18[0]; + const j: rs.usize = _18[1]; + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4))), (_2: rs.u8): Item.Item => { return new Item.Item(_2); }), undefined, 1, true); - const _28: rt.u8 = rt.u8Rem(kind, 6); + const _28: rs.u8 = rs.u8Rem(kind, 6); if (_28 === 0) { - const range: [rt.RangeBound, rt.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; - const iter: rt.Iter = rt.vecDrain(items, range, rt.drop); + const range: [rs.RangeBound, rs.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; + const iter: rs.Iter = rs.vecDrain(items, range, rs.drop); while (true) { - const _37: Item.Item | rt.Done = iter.next(); - if (_37 === rt.DONE) { + const _37: Item.Item | rs.Done = iter.next(); + if (_37 === rs.DONE) { break; } const x: Item.Item = _37; - rt.byteVecPush(out, x.tag); + rs.byteVecPush(out, x.tag); flush(out); x[Symbol.dispose](); } - rt.drop(iter); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 4)); - const _49: [rt.RangeBound, rt.RangeBound] = [bound$ref_usize(s, i), bound$ref_usize(e, j)]; - rt.iterExtendBytes(out, rt.iterRev(rt.byteVecDrain(bytes, _49)), "fold", true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))), (_216: rt.u8): rt.u32 => { - return rt.u32Add(_216 as rt.u32, 1000); + rs.drop(iter); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 4)); + const _49: [rs.RangeBound, rs.RangeBound] = [bound$ref_usize(s, i), bound$ref_usize(e, j)]; + rs.iterExtendBytes(out, rs.iterRev(rs.byteVecDrain(bytes, _49)), "fold", true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4))), (_216: rs.u8): rs.u32 => { + return rs.u32Add(_216 as rs.u32, 1000); }), undefined, 4, true); - const drain: rt.Iter = rt.vecDrain(words, range); - rt.iterExtendBytes(out, rt.iterOption(option_map$0a57co2(rt.iterToOption(drain.nextBack()), (w: rt.u32): rt.u8 => { + const drain: rs.Iter = rs.vecDrain(words, range); + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(rs.iterToOption(drain.nextBack()), (w: rs.u32): rs.u8 => { return w & 0xff; })), undefined, true); - rt.byteVecPush(out, drain.len() & 0xff); - rt.drop(drain); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_217: rt.u32): rt.u8 => { + rs.byteVecPush(out, drain.len() & 0xff); + rs.drop(drain); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_217: rs.u32): rs.u8 => { return _217 & 0xff; }), undefined, true); } else if (_28 === 1) { - const _78: Asked.Asked = asked$usize(s, e, i, j); - const drain2: rt.Iter = rt.vecDrain(items, rt.boundsOf(_78, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize), rt.drop); + const _78: Asked.Asked = asked$usize(s, e, i, j); + const drain2: rs.Iter = rs.vecDrain(items, rs.boundsOf(_78, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize), rs.drop); flush(out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1iekgsb(rt.iterToOption(drain2.next()), (x5: Item.Item): rt.u8 => { - const _09: rt.u8 = x5.tag; + rs.iterExtendBytes(out, rs.iterOption(option_map$1i6no0n(rs.iterToOption(drain2.next()), (x5: Item.Item): rs.u8 => { + const _09: rs.u8 = x5.tag; x5[Symbol.dispose](); return _09; })), undefined, true); flush(out); - rt.drop(drain2); + rs.drop(drain2); flush(out); - const bytes2: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 4)); - const _94: Asked.Asked = asked$usize(s, e, i, j); - rt.byteVecPush(out, rt.ownedCount(rt.byteVecDrain(bytes2, rt.boundsOf(_94, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize))) & 0xff); + const bytes2: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 4)); + const _94: Asked.Asked = asked$usize(s, e, i, j); + rs.byteVecPush(out, rs.ownedCount(rs.byteVecDrain(bytes2, rs.boundsOf(_94, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize))) & 0xff); flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes2)), undefined, true); } else if (_28 === 2) { - const queue: rt.VecDeque = rt.dequeNew(1) as rt.VecDeque; - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); + const queue: rs.VecDeque = rs.dequeNew(1) as rs.VecDeque; + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4)))); while (true) { - const _104: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_104 === rt.DONE) { + const _104: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_104 === rs.DONE) { break; } - const n: rt.usize = _104[0]; - const tag: rt.u8 = _104[1]; - if (rt.usizeRem(n, 2) === 0) { - rt.dequePushBack(queue, new Item.Item(tag)); + const n: rs.usize = _104[0]; + const tag: rs.u8 = _104[1]; + if (rs.usizeRem(n, 2) === 0) { + rs.dequePushBack(queue, new Item.Item(tag)); } else { - rt.dequePushFront(queue, new Item.Item(tag)); + rs.dequePushFront(queue, new Item.Item(tag)); } } - const _117: [rt.RangeBound, rt.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; - const drain3: rt.Iter = rt.dequeDrain(queue, _117, rt.drop); - rt.iterExtendBytes(out, rt.iterOption(option_map$1iekgsb(rt.iterToOption(drain3.nextBack()), (x2: Item.Item): rt.u8 => { - const _06: rt.u8 = x2.tag; + const _117: [rs.RangeBound, rs.RangeBound] = [bound$usize(s, i), bound$usize(e, j)]; + const drain3: rs.Iter = rs.dequeDrain(queue, _117, rs.drop); + rs.iterExtendBytes(out, rs.iterOption(option_map$1i6no0n(rs.iterToOption(drain3.nextBack()), (x2: Item.Item): rs.u8 => { + const _06: rs.u8 = x2.tag; x2[Symbol.dispose](); return _06; })), undefined, true); flush(out); - rt.drop(drain3); + rs.drop(drain3); flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(queue), (x3: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(queue), (x3: Item.Item): rs.u8 => { return x3.tag; }), undefined, true); - const reach2: rt.usize = rt.usizeAdd(queue.n, 1); - const _138: Asked.Asked = asked$usize(s, e, rt.usizeRem(a as rt.usize, reach2), rt.usizeRem(b as rt.usize, reach2)); - const drain4: rt.Iter = rt.dequeDrain(queue, rt.boundsOf(_138, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize), rt.drop); + const reach2: rs.usize = rs.usizeAdd(queue.n, 1); + const _138: Asked.Asked = asked$usize(s, e, rs.usizeRem(a as rs.usize, reach2), rs.usizeRem(b as rs.usize, reach2)); + const drain4: rs.Iter = rs.dequeDrain(queue, rs.boundsOf(_138, Asked.startBound$ops_RangeBounds_usize_usize, Asked.endBound$ops_RangeBounds_usize_usize), rs.drop); flush(out); - rt.byteVecPush(out, rt.ownedCount(drain4, rt.drop) & 0xff); + rs.byteVecPush(out, rs.ownedCount(drain4, rs.drop) & 0xff); flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(queue), (x4: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(queue), (x4: Item.Item): rs.u8 => { return x4.tag; }), undefined, true); - rt.dequeDrop(queue, rt.drop); + rs.dequeDrop(queue, rs.drop); } else if (_28 === 3) { - const _155: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))), (_210: [rt.usize, rt.u8]): [rt.u8, rt.u8] => { - return [_210[1], _210[0] & 0xff] as [rt.u8, rt.u8]; + const _155: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4)))), (_210: [rs.usize, rs.u8]): [rs.u8, rs.u8] => { + return [_210[1], _210[0] & 0xff] as [rs.u8, rs.u8]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _155, true, undefined, undefined, undefined, 2, true); - const range2: [rt.RangeBound, rt.RangeBound] = [bound$u8(s, a), bound$u8(e, b)]; - const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.btreeRange(map, range2); + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _155, true, undefined, undefined, undefined, 2, true); + const range2: [rs.RangeBound, rs.RangeBound] = [bound$u8(s, a), bound$u8(e, b)]; + const iter3: rs.Iter<[rs.u8, rs.u8]> = rs.btreeRange(map, range2); while (true) { - const _165: [rt.u8, rt.u8] | rt.Done = iter3.next(); - if (_165 === rt.DONE) { + const _165: [rs.u8, rs.u8] | rs.Done = iter3.next(); + if (_165 === rs.DONE) { break; } - rt.byteVecPush(out, _165[0]); - rt.byteVecPush(out, _165[1]); + rs.byteVecPush(out, _165[0]); + rs.byteVecPush(out, _165[1]); } - const _180: [rt.RangeBound, rt.RangeBound] = [bound$ref_u8(s, a), bound$ref_u8(e, b)]; - rt.iterExtendBytes(out, rt.iterOption(option_map$1hdkvwd(rt.iterToOption(rt.btreeRange(map, _180).nextBack()), (_214: [rt.u8, rt.u8]): rt.u8 => { + const _180: [rs.RangeBound, rs.RangeBound] = [bound$ref_u8(s, a), bound$ref_u8(e, b)]; + rs.iterExtendBytes(out, rs.iterOption(option_map$1c8069b(rs.iterToOption(rs.btreeRange(map, _180).nextBack()), (_214: [rs.u8, rs.u8]): rs.u8 => { return _214[0]; })), undefined, true); - const iter4: rt.Iter<[rt.u8, rt.Place]> = rt.btreeRangeMut(map, range2); + const iter4: rs.Iter<[rs.u8, rs.Place]> = rs.btreeRangeMut(map, range2); while (true) { - const _189: [rt.u8, rt.Place] | rt.Done = iter4.next(); - if (_189 === rt.DONE) { + const _189: [rs.u8, rs.Place] | rs.Done = iter4.next(); + if (_189 === rs.DONE) { break; } - _189[1].v = rt.u8WrappingAdd(_189[1].v, 100); + _189[1].v = rs.u8WrappingAdd(_189[1].v, 100); } - rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); - const _199: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _199, true, undefined, undefined, 1, true); - rt.iterExtendBytes(out, rt.iterRev(rt.btreeRangeKeys(set, range2)), "next"); - rt.byteVecPush(out, within$tuple2_ops_Bound_u8_ops_Bound_u8(set, range2) & 0xff); + rs.iterExtendBytes(out, rs.btreeValues(map), undefined, true); + const _199: rs.Iter = rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4))); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _199, true, undefined, undefined, 1, true); + rs.iterExtendBytes(out, rs.iterRev(rs.btreeRangeKeys(set, range2)), "next"); + rs.byteVecPush(out, within$tuple2_ops_Bound_u8_ops_Bound_u8(set, range2) & 0xff); } else if (_28 === 4) { - const empty: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _215: Asked.Asked = asked$u8(s, e, a, b); - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(empty, rt.boundsOf(_215, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8))) & 0xff); + const empty: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _215: Asked.Asked = asked$u8(s, e, a, b); + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(empty, rs.boundsOf(_215, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8))) & 0xff); flush(out); - const _218: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))); - const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _218, true, undefined, undefined, 1, true); - const _222: Asked.Asked = asked$u8(s, e, a, b); - const range3: rt.Iter = rt.btreeRangeKeys(set2, rt.boundsOf(_222, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8)); + const _218: rs.Iter = rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4))); + const set2: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _218, true, undefined, undefined, 1, true); + const _222: Asked.Asked = asked$u8(s, e, a, b); + const range3: rs.Iter = rs.btreeRangeKeys(set2, rs.boundsOf(_222, Asked.startBound$ops_RangeBounds_u8_u8, Asked.endBound$ops_RangeBounds_u8_u8)); flush(out); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.next())), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(range3.nextBack())), undefined, true); - const _234: Asked.Asked = asked$u8(s, e, a, b); - rt.byteVecPush(out, within$bounds_Asked_u8(set2, _234) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(range3.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(range3.nextBack())), undefined, true); + const _234: Asked.Asked = asked$u8(s, e, a, b); + rs.byteVecPush(out, within$bounds_Asked_u8(set2, _234) & 0xff); flush(out); - rt.btreeDrop(empty, undefined, rt.drop); + rs.btreeDrop(empty, undefined, rs.drop); } else { const _238: [Key.Key, Key.Key] = [{ _0: a }, { _0: b }]; const a2: Key.Key = _238[0]; const b2: Key.Key = _238[1]; - const set3: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; - const map2: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4)))); + const set3: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; + const map2: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 4)))); while (true) { - const _247: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_247 === rt.DONE) { + const _247: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_247 === rs.DONE) { break; } - const n2: rt.usize = _247[0]; - const k: rt.u8 = _247[1]; - rt.btreeAdd(set3, { _0: k }); - rt.btreeInsert(map2, { _0: k }, n2 & 0xff); + const n2: rs.usize = _247[0]; + const k: rs.u8 = _247[1]; + rs.btreeAdd(set3, { _0: k }); + rs.btreeInsert(map2, { _0: k }, n2 & 0xff); } - const _263: [rt.RangeBound, rt.RangeBound] = [bound$ref_bounds_Key(s, a2), bound$ref_bounds_Key(e, b2)]; - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(set3, _263, Key.eq$cmp_PartialEq, rt.cmpGt(Key.partialCmp$cmp_PartialOrd)), (k3: Key.Key): rt.u8 => { + const _263: [rs.RangeBound, rs.RangeBound] = [bound$ref_bounds_Key(s, a2), bound$ref_bounds_Key(e, b2)]; + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set3, _263, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), (k3: Key.Key): rs.u8 => { return k3._0; }), "next"); flush(out); - const _272: [rt.RangeBound, rt.RangeBound] = [bound$ref_bounds_Key(s, a2), bound$ref_bounds_Key(e, b2)]; - const iter6: rt.Iter<[Key.Key, rt.Place]> = rt.btreeRangeMut(map2, _272, Key.eq$cmp_PartialEq, rt.cmpGt(Key.partialCmp$cmp_PartialOrd)); + const _272: [rs.RangeBound, rs.RangeBound] = [bound$ref_bounds_Key(s, a2), bound$ref_bounds_Key(e, b2)]; + const iter6: rs.Iter<[Key.Key, rs.Place]> = rs.btreeRangeMut(map2, _272, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)); while (true) { - const _278: [Key.Key, rt.Place] | rt.Done = iter6.next(); - if (_278 === rt.DONE) { + const _278: [Key.Key, rs.Place] | rs.Done = iter6.next(); + if (_278 === rs.DONE) { break; } _278[1].v = _278[1].v ^ 128; } flush(out); - rt.iterExtendBytes(out, rt.btreeValues(map2), undefined, true); - const pairs: rt.BTreeSet<[rt.u8, Key.Key]> = rt.btreeNew(rt.cmpTuple<[rt.u8, Key.Key], rt.Ordering>([rt.cmp, Key.cmp$cmp_Ord])) as rt.BTreeSet<[rt.u8, Key.Key]>; - for (const k2 of rt.byteSliceView(rt.byteSliceRange(data, 4))) { - rt.btreeAdd(pairs, [k2, { _0: k2 }] as [rt.u8, Key.Key]); + rs.iterExtendBytes(out, rs.btreeValues(map2), undefined, true); + const pairs: rs.BTreeSet<[rs.u8, Key.Key]> = rs.btreeNew(rs.cmpTuple<[rs.u8, Key.Key], rs.Ordering>([rs.cmp, Key.cmp$cmp_Ord])) as rs.BTreeSet<[rs.u8, Key.Key]>; + for (const k2 of rs.byteSliceView(rs.byteSliceRange(data, 4))) { + rs.btreeAdd(pairs, [k2, { _0: k2 }] as [rs.u8, Key.Key]); } - const _299: [[rt.u8, Key.Key], [rt.u8, Key.Key]] = [[a2._0, a2] as [rt.u8, Key.Key], [b2._0, b2] as [rt.u8, Key.Key]]; - const a3: [rt.u8, Key.Key] = _299[0]; - const b3: [rt.u8, Key.Key] = _299[1]; - const _308: [rt.RangeBound<[rt.u8, Key.Key]>, rt.RangeBound<[rt.u8, Key.Key]>] = [bound$ref_tuple2_u8_bounds_Key(s, a3), bound$ref_tuple2_u8_bounds_Key(e, b3)]; - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(pairs, _308, rt.eqTuple([rt.same, Key.eq$cmp_PartialEq]), rt.cmpGt(rt.cmpTuple<[rt.u8, Key.Key], rt.Ordering | undefined>([rt.cmp, Key.partialCmp$cmp_PartialOrd]))), (_25: [rt.u8, Key.Key]): rt.u8 => { + const _299: [[rs.u8, Key.Key], [rs.u8, Key.Key]] = [[a2._0, a2] as [rs.u8, Key.Key], [b2._0, b2] as [rs.u8, Key.Key]]; + const a3: [rs.u8, Key.Key] = _299[0]; + const b3: [rs.u8, Key.Key] = _299[1]; + const _308: [rs.RangeBound<[rs.u8, Key.Key]>, rs.RangeBound<[rs.u8, Key.Key]>] = [bound$ref_tuple2_u8_bounds_Key(s, a3), bound$ref_tuple2_u8_bounds_Key(e, b3)]; + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(pairs, _308, rs.eqTuple([rs.same, Key.eq$cmp_PartialEq]), rs.cmpGt(rs.cmpTuple<[rs.u8, Key.Key], rs.Ordering | undefined>([rs.cmp, Key.partialCmp$cmp_PartialOrd]))), (_25: [rs.u8, Key.Key]): rs.u8 => { return _25[0]; }), "next"); flush(out); } flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items.items), (x6: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(items.items), (x6: Item.Item): rs.u8 => { return x6.tag; }), undefined, true); - rt.dropVec(items); + rs.dropVec(items); flush(out); } } diff --git a/ts/fixtures/lang/bounds/expected/core/option.ts b/ts/fixtures/lang/bounds/expected/core/option.ts index 1ca931a41..e89222af4 100644 --- a/ts/fixtures/lang/bounds/expected/core/option.ts +++ b/ts/fixtures/lang/bounds/expected/core/option.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Item from "../bounds.Item.ts"; -export function map$1iekgsb(self: Item.Item | undefined, f: (a0: Item.Item) => rt.u8): rt.u8 | undefined { +export function map$1i6no0n(self: Item.Item | undefined, f: (a0: Item.Item) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1hdkvwd(self: [rt.u8, rt.u8] | undefined, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 | undefined { +export function map$1c8069b(self: [rs.u8, rs.u8] | undefined, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0a57co2(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u8): rt.u8 | undefined { +export function map$04ry0e1(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/bounds/expected/harness.ts b/ts/fixtures/lang/bounds/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/bounds/expected/harness.ts +++ b/ts/fixtures/lang/bounds/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/bounds/expected/lib.ts b/ts/fixtures/lang/bounds/expected/lib.ts index cf71fbb51..157ac0123 100644 --- a/ts/fixtures/lang/bounds/expected/lib.ts +++ b/ts/fixtures/lang/bounds/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { bounds } from "./bounds.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["bounds::bounds", bounds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["bounds::bounds", bounds as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/boxes/expected/boxes.Held.ts b/ts/fixtures/lang/boxes/expected/boxes.Held.ts index c859a6ecc..bef1821ae 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.Held.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.Held.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Logged from "./boxes.Logged.ts"; /** A boxed slice in a field, beside one that drops after it. */ @@ -14,7 +14,7 @@ export class Held { } [Symbol.dispose](): void { - rt.dropAll(this.items); + rs.dropAll(this.items); this.last[Symbol.dispose](); } } diff --git a/ts/fixtures/lang/boxes/expected/boxes.Logged.ts b/ts/fixtures/lang/boxes/expected/boxes.Logged.ts index 3b064e132..eb53240e5 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.Logged.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops, and as it is cloned, the id with the high bit set: its clone's * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -22,16 +22,16 @@ export class Logged { } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=boxes.Logged.ts.map diff --git a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts index c8d263a2f..456b3d3e6 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.Owner.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.Owner.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Boxes of values JS copies, held in a struct a `&mut` reaches. */ export interface Owner { - n: rt.u32; + n: rs.u32; s: string; - nested: rt.u32; + nested: rs.u32; } //# sourceMappingURL=boxes.Owner.ts.map diff --git a/ts/fixtures/lang/boxes/expected/boxes.ts b/ts/fixtures/lang/boxes/expected/boxes.ts index 1f1a1828d..2d492988b 100644 --- a/ts/fixtures/lang/boxes/expected/boxes.ts +++ b/ts/fixtures/lang/boxes/expected/boxes.ts @@ -1,430 +1,430 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_tuple2_u8_u16, copy$array_u16, copy$array_u8, copy$tuple2_u8_u16, drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged } from "./lib.ts"; import * as Held from "./boxes.Held.ts"; import * as Logged from "./boxes.Logged.ts"; import type * as Owner from "./boxes.Owner.ts"; -import { then$0ea5h05 } from "./core/bool.ts"; -import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, asDeref$0w2m0zn as option_asDeref$0w2m0zn, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0avuzwv as option_asDeref$0avuzwv, flatten$08boupk as option_flatten$08boupk } from "./core/option.ts"; -import { map$0nfi04k as result_map$0nfi04k, asDeref$1fldd5d as result_asDeref$1fldd5d, asDeref$04i8i5u as result_asDeref$04i8i5u, unwrapOr$0e4foht as result_unwrapOr$0e4foht, copied$0bbq7yi } from "./core/result.ts"; +import { then$0apfzgv } from "./core/bool.ts"; +import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, asDeref$0r30y86 as option_asDeref$0r30y86, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$13yyv6y as option_asDeref$13yyv6y, flatten$1s0exy3 as option_flatten$1s0exy3 } from "./core/option.ts"; +import { map$0v9s95z as result_map$0v9s95z, asDeref$15ue8vz as result_asDeref$15ue8vz, asDeref$1qd1pp0 as result_asDeref$1qd1pp0, unwrapOr$1n4fvf5 as result_unwrapOr$1n4fvf5, copied$1m63478 } from "./core/result.ts"; import { put, text } from "./harness.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } -export function hash$boxed_Box_slice_u16(value: rt.u16[]): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(value, h); - return rt.hashFinish(h); +export function hash$boxed_Box_slice_u16(value: rs.u16[]): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(value, h); + return rs.hashFinish(h); } -export function hash$boxed_Box_slice_u8(value: rt.ByteSlice): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - return rt.hashFinish(h); +export function hash$boxed_Box_slice_u8(value: rs.ByteSlice): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + return rs.hashFinish(h); } -export function hash$boxed_Box_str(value: string): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashStr(value, h); - return rt.hashFinish(h); +export function hash$boxed_Box_str(value: string): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashStr(value, h); + return rs.hashFinish(h); } -export function hash$slice_u16(value: rt.u16[]): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(value, h); - return rt.hashFinish(h); +export function hash$slice_u16(value: rs.u16[]): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(value, h); + return rs.hashFinish(h); } -export function hash$slice_u8(value: rt.ByteSlice): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - return rt.hashFinish(h); +export function hash$slice_u8(value: rs.ByteSlice): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + return rs.hashFinish(h); } -export function hash$str(value: string): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashStr(value, h); - return rt.hashFinish(h); +export function hash$str(value: string): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashStr(value, h); + return rs.hashFinish(h); } /** Puts `b`'s length and bytes. */ -export function bytes(b: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); - rt.byteVecExtendFromSlice(out, b); +export function bytes(b: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); + rs.byteVecExtendFromSlice(out, b); } /** Puts `b`'s length and each `u16`'s bytes. */ -export function wides(b: rt.u16[], out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); +export function wides(b: rs.u16[], out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); for (const _8 of b) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_8).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_8).reverse()), undefined, true); } } /** Puts the ids of `b`. */ -export function ids(b: Logged.Logged[], out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(b), (l: Logged.Logged): rt.u8 => { +export function ids(b: Logged.Logged[], out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(b), (l: Logged.Logged): rs.u8 => { return l.id; }), undefined, true); } /** Writes through `DerefMut` of a boxed slice of bytes. */ -export function scramble(b: rt.Place): void { - rt.byteSliceView(b.v).reverse(); - const _4: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(b.v)); +export function scramble(b: rs.Place): void { + rs.byteSliceView(b.v).reverse(); + const _4: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(b.v)); if (_4 !== undefined) { _4.v = _4.v ^ 255; } - const iter: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(b.v)); + const iter: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(b.v)); while (true) { - const _12: rt.Place | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: rs.Place | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - _12.v = rt.u8WrappingAdd(_12.v, 1); + _12.v = rs.u8WrappingAdd(_12.v, 1); } - rt.iterForEach(rt.byteSliceChunksExact(b.v, 2), (c: rt.ByteSlice): undefined => { - rt.byteSliceSwap(c, 0, 1); + rs.iterForEach(rs.byteSliceChunksExact(b.v, 2), (c: rs.ByteSlice): undefined => { + rs.byteSliceSwap(c, 0, 1); }); - const n: rt.usize = b.v.length; + const n: rs.usize = b.v.length; if (n > 2) { - const _24: rt.usize = rt.usizeSub(n, 1); - rt.idx(b.v, _24); - const _40: rt.ByteSlice = b.v; + const _24: rs.usize = rs.usizeSub(n, 1); + rs.idx(b.v, _24); + const _40: rs.ByteSlice = b.v; _40.data[_40.start + _24] = 66; - rt.byteSliceCopyFromSlice(rt.byteSliceRange(b.v, 0, 2), rt.byteSliceFrom(Uint8Array.of(7, 8))); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(b.v, 0, 2), rs.byteSliceFrom(Uint8Array.of(7, 8))); } } /** A whole boxed slice written through a `&mut`, of another length. */ -export function set$boxes_Logged(slot: rt.Place, value: Logged.Logged[]): void { - rt.dropAll(slot.v); +export function set$boxes_Logged(slot: rs.Place, value: Logged.Logged[]): void { + rs.dropAll(slot.v); slot.v = value; } /** A whole boxed slice written through a `&mut`, of another length. */ -export function set$u16(slot: rt.Place, value: rt.u16[]): void { +export function set$u16(slot: rs.Place, value: rs.u16[]): void { slot.v = value; } /** A whole boxed slice written through a `&mut`, of another length. */ -export function set$u8(slot: rt.Place, value: rt.ByteSlice): void { +export function set$u8(slot: rs.Place, value: rs.ByteSlice): void { slot.v = value; } -export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const _15: rt.u8 = rt.u8Rem(kind, 6); +export function boxes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const _15: rs.u8 = rs.u8Rem(kind, 6); if (_15 === 0) { - const source: rt.ByteVec = rt.byteSliceToByteVec(data2); - let fromRef: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - scramble(rt.place(() => fromRef, (value3) => fromRef = value3)); + const source: rs.ByteVec = rs.byteSliceToByteVec(data2); + let fromRef: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + scramble(rs.place(() => fromRef, (value3) => fromRef = value3)); bytes(fromRef, out); - const fromMut: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(rt.byteVecSlice(source), 0))); - rt.byteSliceView(fromMut).sort(); + const fromMut: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(rs.byteVecSlice(source), 0))); + rs.byteSliceView(fromMut).sort(); bytes(fromMut, out); - bytes(rt.byteVecSlice(source), out); - bytes(rt.byteSliceFrom(rt.byteSliceToArray(data2)), out); - const spare: rt.ByteVec = rt.byteVecWithCapacity(64); - rt.byteVecExtendFromSlice(spare, data2); - let fromVec: rt.ByteSlice = rt.byteVecSlice(spare); - scramble(rt.place(() => fromVec, (value4) => fromVec = value4)); + bytes(rs.byteVecSlice(source), out); + bytes(rs.byteSliceFrom(rs.byteSliceToArray(data2)), out); + const spare: rs.ByteVec = rs.byteVecWithCapacity(64); + rs.byteVecExtendFromSlice(spare, data2); + let fromVec: rs.ByteSlice = rs.byteVecSlice(spare); + scramble(rs.place(() => fromVec, (value4) => fromVec = value4)); bytes(fromVec, out); - let boxed: rt.ByteSlice = rt.byteVecSlice(rt.byteVecFrom(rt.byteVecView(source))); - scramble(rt.place(() => boxed, (value5) => boxed = value5)); + let boxed: rs.ByteSlice = rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(source))); + scramble(rs.place(() => boxed, (value5) => boxed = value5)); bytes(boxed, out); - const array: Uint8Array = Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 1), 2, 3, 4); - let fromArray: rt.ByteSlice = rt.byteSliceFrom(copy$array_u8(array)); - scramble(rt.place(() => fromArray, (value6) => fromArray = value6)); + const array: Uint8Array = Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceFirst(data2), 1), 2, 3, 4); + let fromArray: rs.ByteSlice = rs.byteSliceFrom(copy$array_u8(array)); + scramble(rs.place(() => fromArray, (value6) => fromArray = value6)); bytes(fromArray, out); - bytes(rt.byteSliceFrom(array), out); - const coerced: rt.ByteSlice = rt.byteSliceFrom(copy$array_u8(array)); - rt.idx(coerced, 0); + bytes(rs.byteSliceFrom(array), out); + const coerced: rs.ByteSlice = rs.byteSliceFrom(copy$array_u8(array)); + rs.idx(coerced, 0); coerced.data[coerced.start] = 9; bytes(coerced, out); - bytes(rt.byteSliceFrom(array), out); - const collected: rt.ByteSlice = rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_27: rt.u8): rt.u8 => { + bytes(rs.byteSliceFrom(array), out); + const collected: rs.ByteSlice = rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_27: rs.u8): rs.u8 => { return _27 ^ 85; }), undefined, true)); bytes(collected, out); - let cloned: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(collected)); - scramble(rt.place(() => cloned, (value7) => cloned = value7)); + let cloned: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(collected)); + scramble(rs.place(() => cloned, (value7) => cloned = value7)); bytes(cloned, out); bytes(collected, out); - const empty: rt.ByteSlice = rt.byteSliceFrom(new Uint8Array(0)); + const empty: rs.ByteSlice = rs.byteSliceFrom(new Uint8Array(0)); bytes(empty, out); - bytes(rt.byteSliceFrom(rt.byteSliceToArray(empty)), out); - bytes(rt.byteVecSlice(rt.byteCowIntoOwned(data2)), out); - bytes(rt.byteVecSlice(rt.byteCowIntoOwned(rt.byteSliceToByteVec(data2))), out); - const v: rt.ByteVec = rt.byteSliceToByteVec(fromRef); - rt.byteVecPush(v, 238); - rt.byteVecExtendFromSlice(v, fromVec); - bytes(rt.byteVecSlice(v), out); - bytes(rt.byteVecSlice(rt.byteSliceToByteVec(cloned)), out); - let slot: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - const _136: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); - set$u8(rt.place(() => slot, (value8) => slot = value8), _136); + bytes(rs.byteSliceFrom(rs.byteSliceToArray(empty)), out); + bytes(rs.byteVecSlice(rs.byteCowIntoOwned(data2)), out); + bytes(rs.byteVecSlice(rs.byteCowIntoOwned(rs.byteSliceToByteVec(data2))), out); + const v: rs.ByteVec = rs.byteSliceToByteVec(fromRef); + rs.byteVecPush(v, 238); + rs.byteVecExtendFromSlice(v, fromVec); + bytes(rs.byteVecSlice(v), out); + bytes(rs.byteVecSlice(rs.byteSliceToByteVec(cloned)), out); + let slot: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + const _136: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(1, 2, 3)); + set$u8(rs.place(() => slot, (value8) => slot = value8), _136); bytes(slot, out); - const _143: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); + const _143: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); const old2 = slot; slot = _143; bytes(old2, out); const taken2 = slot; - slot = rt.byteSliceFrom(new Uint8Array(0)); + slot = rs.byteSliceFrom(new Uint8Array(0)); bytes(taken2, out); bytes(slot, out); - let other: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(9)); + let other: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(9)); const swapped = slot; slot = other; other = swapped; bytes(slot, out); bytes(other, out); - let sum: rt.u8 = 0; - const iter: rt.Iter = rt.iterSlice(rt.byteSliceView(boxed)); + let sum: rs.u8 = 0; + const iter: rs.Iter = rs.iterSlice(rs.byteSliceView(boxed)); while (true) { - const _170: rt.u8 | rt.Done = iter.next(); - if (_170 === rt.DONE) { + const _170: rs.u8 | rs.Done = iter.next(); + if (_170 === rs.DONE) { break; } - sum = rt.u8WrappingAdd(sum, _170); + sum = rs.u8WrappingAdd(sum, _170); } - rt.byteVecPush(out, sum); + rs.byteVecPush(out, sum); } else if (_15 === 1) { - const a: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - const b: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, 0, rt.usizeDiv(data2.length, 2)))); - rt.byteVecPush(out, rt.eqBytes(a, b) ? 1 : 0); - rt.byteVecPush(out, !rt.eqBytes(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.cmpBytes(a, b) === -1 ? 1 : 0); - const order = rt.cmpBytes(a, b); - rt.byteVecPush(out, order !== undefined && order >= 0 ? 1 : 0); - rt.byteVecPush(out, rt.cmpBytes(a, b) & 0xff); - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.cmpBytes(b, a), 9, (o: rt.Ordering): rt.u8 => { + const a: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + const b: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, 0, rs.usizeDiv(data2.length, 2)))); + rs.byteVecPush(out, rs.eqBytes(a, b) ? 1 : 0); + rs.byteVecPush(out, !rs.eqBytes(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.cmpBytes(a, b) === -1 ? 1 : 0); + const order = rs.cmpBytes(a, b); + rs.byteVecPush(out, order !== undefined && order >= 0 ? 1 : 0); + rs.byteVecPush(out, rs.cmpBytes(a, b) & 0xff); + rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpBytes(b, a), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - rt.byteVecPush(out, rt.byteSliceEq(a, data2) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u8(a), hash$slice_u8(data2)) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(hash$boxed_Box_slice_u8(b)).reverse()), undefined, true); - rt.byteVecPush(out, a.length & 0xff); - rt.byteVecPush(out, a.length === 0 ? 1 : 0); - rt.byteVecPush(out, rt.iterFold(rt.iterSlice(rt.byteSliceView(a)), 0, (a0: rt.u8, a1: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a0, a1); + rs.byteVecPush(out, rs.byteSliceEq(a, data2) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_slice_u8(a), hash$slice_u8(data2)) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(hash$boxed_Box_slice_u8(b)).reverse()), undefined, true); + rs.byteVecPush(out, a.length & 0xff); + rs.byteVecPush(out, a.length === 0 ? 1 : 0); + rs.byteVecPush(out, rs.iterFold(rs.iterSlice(rs.byteSliceView(a)), 0, (a0: rs.u8, a1: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a0, a1); })); - rt.byteVecPush(out, rt.byteSliceView(a).includes(0) ? 1 : 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceFirst(a), 170)); - const _261: rt.ByteSlice = rt.byteSliceFrom(new Uint8Array(0)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(a), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(b), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_261), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + rs.byteVecPush(out, rs.byteSliceView(a).includes(0) ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceFirst(a), 170)); + const _261: rs.ByteSlice = rs.byteSliceFrom(new Uint8Array(0)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_261), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); } else if (_15 === 2) { - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_24: rt.u8): rt.u16 => { - return rt.u16Mul(_24 as rt.u16, 257); + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_24: rs.u8): rs.u16 => { + return rs.u16Mul(_24 as rs.u16, 257); }), undefined, 2, true); - const fromRef2: rt.u16[] = rt.sliceRange(wide.items, 0).slice(); + const fromRef2: rs.u16[] = rs.sliceRange(wide.items, 0).slice(); fromRef2.reverse(); - const iter2: rt.Iter> = rt.iterSliceMut(fromRef2); + const iter2: rs.Iter> = rs.iterSliceMut(fromRef2); while (true) { - const _282: rt.Place | rt.Done = iter2.next(); - if (_282 === rt.DONE) { + const _282: rs.Place | rs.Done = iter2.next(); + if (_282 === rs.DONE) { break; } _282.v = _282.v ^ 3855; } wides(fromRef2, out); wides(wide.items, out); - const fromVec2: rt.u16[] = rt.vecFrom(wide.items.slice()).items; - const _295: rt.Place | undefined = rt.sliceLastMut(fromVec2); + const fromVec2: rs.u16[] = rs.vecFrom(wide.items.slice()).items; + const _295: rs.Place | undefined = rs.sliceLastMut(fromVec2); if (_295 !== undefined) { _295.v = 48879; } wides(fromVec2, out); - const array2: rt.u16[] = [1, 2, 768]; - const fromArray2: rt.u16[] = copy$array_u16(array2); - rt.idx(fromArray2, 2); + const array2: rs.u16[] = [1, 2, 768]; + const fromArray2: rs.u16[] = copy$array_u16(array2); + rs.idx(fromArray2, 2); fromArray2[2] = 7; wides(fromArray2, out); wides(array2, out); - const collected2: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(wide.items), (_26: rt.u16): rt.u16 => { - return rt.intRotateLeft(_26, 3, 16, false); + const collected2: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(wide.items), (_26: rs.u16): rs.u16 => { + return rs.intRotateLeft(_26, 3, 16, false); }), undefined, 2, true).items; - const cloned2: rt.u16[] = collected2.slice(); - rt.sliceSortUnstable(cloned2, rt.lt, 2, true, true); + const cloned2: rs.u16[] = collected2.slice(); + rs.sliceSortUnstable(cloned2, rs.lt, 2, true, true); wides(cloned2, out); wides(collected2, out); - const empty2: rt.u16[] = []; + const empty2: rs.u16[] = []; wides(empty2, out); - rt.byteVecPush(out, rt.eqSlice(rt.same)(collected2, cloned2) ? 1 : 0); - rt.byteVecPush(out, rt.cmpSlice(rt.cmp)(collected2, cloned2) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(rt.sliceRange(collected2, 0))) ? 1 : 0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected2, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args4[0]])); - const v3: rt.Vec = rt.vecFrom(fromVec2); + rs.byteVecPush(out, rs.eqSlice(rs.same)(collected2, cloned2) ? 1 : 0); + rs.byteVecPush(out, rs.cmpSlice(rs.cmp)(collected2, cloned2) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_slice_u16(collected2), hash$slice_u16(rs.sliceRange(collected2, 0))) ? 1 : 0); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(collected2, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args4[0]])); + const v3: rs.Vec = rs.vecFrom(fromVec2); v3.items.push(5); wides(v3.items, out); - let slot2: rt.u16[] = fromArray2; - const _372: rt.u16[] = collected2.slice(); - set$u16(rt.place(() => slot2, (value2) => slot2 = value2), _372); + let slot2: rs.u16[] = fromArray2; + const _372: rs.u16[] = collected2.slice(); + set$u16(rs.place(() => slot2, (value2) => slot2 = value2), _372); wides(slot2, out); const taken = slot2; slot2 = []; wides(taken, out); - const it: rt.Iter = rt.iterSlice(wide.items); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, (x4: rt.u16): rt.u8 => { + const it: rs.Iter = rs.iterSlice(wide.items); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(rs.iterToOption(it.nextBack()), 0)).reverse()), undefined, true); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it, (x4: rs.u16): rs.u8 => { return x4 & 0xff; }), undefined, true); } else if (_15 === 3) { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const boxed2: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): Logged.Logged => { + const boxed2: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_22: rs.u8): Logged.Logged => { return logged(_22 & 126); }), undefined, 8, true).items; ids(boxed2, out); const cloned3: Logged.Logged[] = boxed2.map(Logged.clone$Clone); flush(log.value, out); - rt.dropAll(boxed2); + rs.dropAll(boxed2); flush(log.value, out); - const fromRef3: Logged.Logged[] = rt.sliceRange(cloned3, 0).map(Logged.clone$Clone); + const fromRef3: Logged.Logged[] = rs.sliceRange(cloned3, 0).map(Logged.clone$Clone); flush(log.value, out); - let collected3: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): Logged.Logged => { + let collected3: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_23: rs.u8): Logged.Logged => { return logged(_23 | 1); }), undefined, 8, true).items; ids(collected3, out); const _433: Logged.Logged[] = [logged(16), logged(18)]; - rt.dropAll(collected3); + rs.dropAll(collected3); collected3 = _433; flush(log.value, out); const _444: Logged.Logged = logged(20); - rt.idx(collected3, 0); + rs.idx(collected3, 0); collected3[0][Symbol.dispose](); collected3[0] = _444; flush(log.value, out); - const it2: rt.Iter = rt.iterSlice(cloned3, rt.drop); - const _454: Logged.Logged | rt.Done = it2.next(); - if (_454 !== rt.DONE) { + const it2: rs.Iter = rs.iterSlice(cloned3, rs.drop); + const _454: Logged.Logged | rs.Done = it2.next(); + if (_454 !== rs.DONE) { const first: Logged.Logged = _454; - rt.byteVecPush(out, first.id); + rs.byteVecPush(out, first.id); first[Symbol.dispose](); } - const back: Logged.Logged | undefined = rt.iterToOption(it2.nextBack()); + const back: Logged.Logged | undefined = rs.iterToOption(it2.nextBack()); flush(log.value, out); - rt.drop(it2); + rs.drop(it2); flush(log.value, out); - rt.drop(back); - const v4: rt.Vec = rt.vecFrom(fromRef3); + rs.drop(back); + const v4: rs.Vec = rs.vecFrom(fromRef3); ids(v4.items, out); - rt.dropVec(v4); + rs.dropVec(v4); flush(log.value, out); const held: Held.Held = new Held.Held([logged(32), logged(34)], logged(36)); - rt.byteVecPush(out, held.items.length & 0xff); - rt.byteVecPush(out, held.last.id); + rs.byteVecPush(out, held.items.length & 0xff); + rs.byteVecPush(out, held.last.id); held[Symbol.dispose](); flush(log.value, out); const empty3: Logged.Logged[] = []; const _506: Logged.Logged[] = empty3.map(Logged.clone$Clone); ids(_506, out); - rt.dropAll(_506); - set$boxes_Logged(rt.place(() => collected3, (value) => collected3 = value), [logged(48)]); + rs.dropAll(_506); + set$boxes_Logged(rs.place(() => collected3, (value) => collected3 = value), [logged(48)]); flush(log.value, out); - rt.dropAll(collected3); + rs.dropAll(collected3); flush(log.value, out); - rt.dropAll(empty3); + rs.dropAll(empty3); log[Symbol.dispose](); } else if (_15 === 4) { - const pairs: rt.Vec<[rt.u8, rt.u16]> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): [rt.u8, rt.u16] => { - const b2: rt.u8 = _2; - return [b2, ((b2 as rt.u16) << 4) & 0xffff] as [rt.u8, rt.u16]; + const pairs: rs.Vec<[rs.u8, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): [rs.u8, rs.u16] => { + const b2: rs.u8 = _2; + return [b2, ((b2 as rs.u16) << 4) & 0xffff] as [rs.u8, rs.u16]; }), undefined, 4, true); - const boxed3: [rt.u8, rt.u16][] = rt.sliceRange(pairs.items, 0).map(copy$tuple2_u8_u16); - const iter3: rt.Iter<[rt.u8, rt.u16]> = rt.iterSlice(boxed3); + const boxed3: [rs.u8, rs.u16][] = rs.sliceRange(pairs.items, 0).map(copy$tuple2_u8_u16); + const iter3: rs.Iter<[rs.u8, rs.u16]> = rs.iterSlice(boxed3); while (true) { - const _533: [rt.u8, rt.u16] | rt.Done = iter3.next(); - if (_533 === rt.DONE) { + const _533: [rs.u8, rs.u16] | rs.Done = iter3.next(); + if (_533 === rs.DONE) { break; } _533[0] = _533[0] ^ 255; } - const _537: [rt.u8, rt.u16] | undefined = rt.sliceFirst(boxed3); + const _537: [rs.u8, rs.u16] | undefined = rs.sliceFirst(boxed3); if (_537 !== undefined) { _537[1] = 1; } - const array3: [rt.u8, rt.u16][] = [[1, 2] as [rt.u8, rt.u16], [3, 4] as [rt.u8, rt.u16]]; - const fromArray3: [rt.u8, rt.u16][] = copy$array_tuple2_u8_u16(array3); - rt.idx(fromArray3, 0); + const array3: [rs.u8, rs.u16][] = [[1, 2] as [rs.u8, rs.u16], [3, 4] as [rs.u8, rs.u16]]; + const fromArray3: [rs.u8, rs.u16][] = copy$array_tuple2_u8_u16(array3); + rs.idx(fromArray3, 0); fromArray3[0][0] = 9; - const quads: Uint8Array[] = rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _3: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + const quads: Uint8Array[] = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _3: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true).items; - const quadsV: rt.Vec = rt.vecFrom(quads.map(copy$array_u8)); - const _554: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(quadsV.items), rt.byteSliceFrom); + const quadsV: rs.Vec = rs.vecFrom(quads.map(copy$array_u8)); + const _554: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(quadsV.items), rs.byteSliceFrom); if (_554 !== undefined) { _554.data[_554.start] = 119; } - const iter4: rt.Iter<[rt.u8, rt.u16]> = rt.iterChain(rt.iterChain(rt.iterChain(rt.iterSlice(boxed3), rt.iterSlice(pairs.items)), rt.iterSlice(fromArray3)), rt.iterSlice(array3)); + const iter4: rs.Iter<[rs.u8, rs.u16]> = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterSlice(boxed3), rs.iterSlice(pairs.items)), rs.iterSlice(fromArray3)), rs.iterSlice(array3)); while (true) { - const _576: [rt.u8, rt.u16] | rt.Done = iter4.next(); - if (_576 === rt.DONE) { + const _576: [rs.u8, rs.u16] | rs.Done = iter4.next(); + if (_576 === rs.DONE) { break; } - rt.byteVecPush(out, _576[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_576[1]).reverse()), undefined, true); + rs.byteVecPush(out, _576[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_576[1]).reverse()), undefined, true); } - const iter5: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(quads), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(quadsV.items), rt.byteSliceFrom)); + const iter5: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(quads), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(quadsV.items), rs.byteSliceFrom)); while (true) { - const _594: rt.ByteSlice | rt.Done = iter5.next(); - if (_594 === rt.DONE) { + const _594: rs.ByteSlice | rs.Done = iter5.next(); + if (_594 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _594); + rs.byteVecExtendFromSlice(out, _594); } - const _603: [rt.u8, rt.u16][] = rt.sliceRange(boxed3, 0); - const _605: [rt.u8, rt.u16][] = rt.sliceRange(pairs.items, 0); - rt.byteVecPush(out, rt.eqSlice(rt.eqTuple([rt.same, rt.same]))(_603, _605) ? 1 : 0); - const p: [rt.u8, rt.u16] = [option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 5), 6]; - const twins: [rt.u8, rt.u16][] = [copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]; - rt.idx(twins, 0); + const _603: [rs.u8, rs.u16][] = rs.sliceRange(boxed3, 0); + const _605: [rs.u8, rs.u16][] = rs.sliceRange(pairs.items, 0); + rs.byteVecPush(out, rs.eqSlice(rs.eqTuple([rs.same, rs.same]))(_603, _605) ? 1 : 0); + const p: [rs.u8, rs.u16] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data2), 5), 6]; + const twins: [rs.u8, rs.u16][] = [copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]; + rs.idx(twins, 0); twins[0][0] = twins[0][0] ^ 1; - const coerced2: [rt.u8, rt.u16][] = [copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]; - rt.idx(coerced2, 1); + const coerced2: [rs.u8, rs.u16][] = [copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]; + rs.idx(coerced2, 1); coerced2[1][1] = 0; - const iter6: rt.Iter<[rt.u8, rt.u16]> = rt.iterChain(rt.iterChain(rt.iterSlice(twins), rt.iterSlice(coerced2)), rt.iterSlice([p])); + const iter6: rs.Iter<[rs.u8, rs.u16]> = rs.iterChain(rs.iterChain(rs.iterSlice(twins), rs.iterSlice(coerced2)), rs.iterSlice([p])); while (true) { - const _634: [rt.u8, rt.u16] | rt.Done = iter6.next(); - if (_634 === rt.DONE) { + const _634: [rs.u8, rs.u16] | rs.Done = iter6.next(); + if (_634 === rs.DONE) { break; } - rt.byteVecPush(out, _634[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_634[1]).reverse()), undefined, true); + rs.byteVecPush(out, _634[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_634[1]).reverse()), undefined, true); } } else { const s: string = text(data2); const fromRef4: string = s; const fromString: string = s; const into2: string = s; - const collected4: string = rt.stringExtendChars("", rt.iterRev(rt.strChars(s))); + const collected4: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(s))); const empty4: string = ""; put(out, fromRef4); put(out, fromString); put(out, into2); put(out, collected4); put(out, empty4); - rt.byteVecPush(out, fromRef4 === into2 ? 1 : 0); - rt.byteVecPush(out, rt.cmpStr(collected4, fromRef4) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s)) ? 1 : 0); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, fromRef4), (f: rt.Formatter) => rt.fmtStr(collected4, f)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1]])); + rs.byteVecPush(out, fromRef4 === into2 ? 1 : 0); + rs.byteVecPush(out, rs.cmpStr(collected4, fromRef4) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hash$boxed_Box_str(fromRef4), hash$str(s)) ? 1 : 0); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef4), (f: rs.Formatter) => rs.fmtStr(collected4, f)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1]])); let back2: string = into2; back2 = back2 + "!"; put(out, back2); @@ -433,24 +433,24 @@ export function boxes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** Adds `by` to what `x` borrows. */ -export function bump(x: rt.Place, by: rt.u8): void { - x.v = rt.u32WrappingAdd(x.v, by as rt.u32); +export function bump(x: rs.Place, by: rs.u8): void { + x.v = rs.u32WrappingAdd(x.v, by as rs.u32); } /** Writes through a `&mut` to what a `Box` holds, and to a part of it. */ -export function shout(s: rt.Place, by: rt.u8): void { - const half: rt.usize = rt.usizeDiv(rt.stringLen(s.v), 2); - if (rt.u8Rem(by, 2) === 0) { - s.v = rt.strToAsciiUppercase(s.v); +export function shout(s: rs.Place, by: rs.u8): void { + const half: rs.usize = rs.usizeDiv(rs.stringLen(s.v), 2); + if (rs.u8Rem(by, 2) === 0) { + s.v = rs.strToAsciiUppercase(s.v); } else { - const _9: rt.Place = rt.strPart(s, 0, half); - _9.v = rt.strToAsciiLowercase(_9.v); + const _9: rs.Place = rs.strPart(s, 0, half); + _9.v = rs.strToAsciiLowercase(_9.v); } } /** A box taken by value and written through before it is given back. */ -export function took(b: rt.u32, by: rt.u8): rt.u32 { - bump(rt.place(() => b, (value) => b = value), by); +export function took(b: rs.u32, by: rs.u8): rs.u32 { + bump(rs.place(() => b, (value) => b = value), by); return b; } @@ -458,32 +458,32 @@ export function took(b: rt.u32, by: rt.u8): rt.u32 { * A write through a pointer into what `a` holds, made before the reference holding `a` * is aimed at `b`, still reaches `a`. */ -export function reaimed(a: rt.Place, b: rt.Place, by: rt.u8): void { - let p!: rt.Place; - let r: rt.Place = a; - if (rt.u8Rem(by, 2) === 0) { +export function reaimed(a: rs.Place, b: rs.Place, by: rs.u8): void { + let p!: rs.Place; + let r: rs.Place = a; + if (rs.u8Rem(by, 2) === 0) { const borrowed = r; - p = rt.place(() => borrowed.v, (value2) => borrowed.v = value2); + p = rs.place(() => borrowed.v, (value2) => borrowed.v = value2); } else { - const _9: rt.Place = r; - p = rt.place(() => _9.v, (value) => _9.v = value); + const _9: rs.Place = r; + p = rs.place(() => _9.v, (value) => _9.v = value); } r = b; - p.v = (p.v ^ by as rt.u32) >>> 0; - r.v = rt.u32WrappingAdd(r.v, 1); + p.v = (p.v ^ by as rs.u32) >>> 0; + r.v = rs.u32WrappingAdd(r.v, 1); } /** What `&mut Owner` reaches of its boxes, each written by `by`. */ -export function reach(b: Owner.Owner, by: rt.u8): void { - const _3: rt.u8 = rt.u8Rem(by, 4); +export function reach(b: Owner.Owner, by: rs.u8): void { + const _3: rs.u8 = rs.u8Rem(by, 4); if (_3 === 0) { - bump(rt.place(() => b.n, (value2) => b.n = value2), by); + bump(rs.place(() => b.n, (value2) => b.n = value2), by); } else if (_3 === 1) { - b.n = (b.n ^ by as rt.u32) >>> 0; + b.n = (b.n ^ by as rs.u32) >>> 0; } else if (_3 === 2) { - bump(rt.place(() => b.nested, (value) => b.nested = value), by); + bump(rs.place(() => b.nested, (value) => b.nested = value), by); } else { - b.s = b.s + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(by, 26)) as rt.char); + b.s = b.s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } } @@ -493,158 +493,158 @@ export function reach(b: Owner.Owner, by: rt.u8): void { * `&mut *b`, `DerefMut`, `AsMut`, `BorrowMut`, `as_deref_mut`, and a write through the box * itself. */ -export function places(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let n: rt.u32 = 7; +export function places(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let n: rs.u32 = 7; const pair: Uint8Array = Uint8Array.of(1, 2); let s: string = "b"; let t: string = "aBc/D"; - let nested: rt.u32 = 3; - let maybe: rt.u32 | undefined = undefined as rt.u32 | undefined; + let nested: rs.u32 = 3; + let maybe: rs.u32 | undefined = undefined as rs.u32 | undefined; const held: Owner.Owner = { n: 5, s: "", nested: 9 }; - const v: rt.Vec = rt.vecFrom([1, 2]); - let o: rt.u32 | undefined = 4; - let res: rt.Result = rt.Ok(2); - let said: rt.Result = rt.Ok("r"); - const words: rt.u32[] = [6, 8]; - const someWords: rt.u32[] | undefined = [3, 5]; + const v: rs.Vec = rs.vecFrom([1, 2]); + let o: rs.u32 | undefined = 4; + let res: rs.Result = rs.Ok(2); + let said: rs.Result = rs.Ok("r"); + const words: rs.u32[] = [6, 8]; + const someWords: rs.u32[] | undefined = [3, 5]; let named: string | undefined = "xY/z"; - const leaked: rt.Place = { v: 11 }; - let deep = 1 as rt.u32 | undefined | rt.None; - const tup: rt.Result<[rt.u32, rt.u32], rt.u8> = rt.Ok([1, 2]); - let boxedOpt: rt.u32 | undefined = 3; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const leaked: rs.Place = { v: 11 }; + let deep = 1 as rs.u32 | undefined | rs.None; + const tup: rs.Result<[rs.u32, rs.u32], rs.u8> = rs.Ok([1, 2]); + let boxedOpt: rs.u32 | undefined = 3; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _52: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_52 === rt.DONE) { + const _52: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_52 === rs.DONE) { break; } - const i: rt.usize = _52[0]; - const by: rt.u8 = _52[1]; - const _58: rt.u8 = rt.u8Rem(by, 26); + const i: rs.usize = _52[0]; + const by: rs.u8 = _52[1]; + const _58: rs.u8 = rs.u8Rem(by, 26); if (_58 === 0) { - const r: rt.Place = rt.place(() => n, (value28) => n = value28); - r.v = rt.u32WrappingMul(r.v, 3); + const r: rs.Place = rs.place(() => n, (value28) => n = value28); + r.v = rs.u32WrappingMul(r.v, 3); } else if (_58 === 1) { - bump(rt.place(() => n, (value27) => n = value27), by); + bump(rs.place(() => n, (value27) => n = value27), by); } else if (_58 === 2) { - const _65: rt.Place = rt.place(() => n, (value25) => n = value25); - bump(rt.place(() => _65.v, (value26) => _65.v = value26), by); + const _65: rs.Place = rs.place(() => n, (value25) => n = value25); + bump(rs.place(() => _65.v, (value26) => _65.v = value26), by); } else if (_58 === 3) { - const _67: rt.Place = rt.place(() => n, (value23) => n = value23); - bump(rt.place(() => _67.v, (value24) => _67.v = value24), by); + const _67: rs.Place = rs.place(() => n, (value23) => n = value23); + bump(rs.place(() => _67.v, (value24) => _67.v = value24), by); } else if (_58 === 4) { - const _69: rt.Place = rt.place(() => n, (value21) => n = value21); - bump(rt.place(() => _69.v, (value22) => _69.v = value22), by); + const _69: rs.Place = rs.place(() => n, (value21) => n = value21); + bump(rs.place(() => _69.v, (value22) => _69.v = value22), by); } else if (_58 === 5) { - n = (n ^ by as rt.u32) >>> 0; + n = (n ^ by as rs.u32) >>> 0; } else if (_58 === 6) { - n = rt.u32WrappingAdd(by as rt.u32, n); + n = rs.u32WrappingAdd(by as rs.u32, n); } else if (_58 === 7) { - const r2: rt.ByteSlice = rt.byteSliceFrom(pair); - const _76: rt.usize = rt.usizeRem(by as rt.usize, 2); + const r2: rs.ByteSlice = rs.byteSliceFrom(pair); + const _76: rs.usize = rs.usizeRem(by as rs.usize, 2); if (!(_76 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _76); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _76); } r2.data[r2.start + _76] = r2.data[r2.start + _76] ^ by; } else if (_58 === 8) { - s = s + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(by, 26)) as rt.char); + s = s + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char); } else if (_58 === 9) { s = s + "!?"; } else if (_58 === 10) { - s = rt.stringInsertStr(s, 0, "<"); + s = rs.stringInsertStr(s, 0, "<"); } else if (_58 === 11) { - shout(rt.place(() => t, (value20) => t = value20), by); + shout(rs.place(() => t, (value20) => t = value20), by); } else if (_58 === 12) { - const _92: rt.Place = rt.place(() => t, (value18) => t = value18); - shout(rt.place(() => _92.v, (value19) => _92.v = value19), by); + const _92: rs.Place = rs.place(() => t, (value18) => t = value18); + shout(rs.place(() => _92.v, (value19) => _92.v = value19), by); } else if (_58 === 13) { - const _94: rt.Place = rt.place(() => t, (value17) => t = value17); - _94.v = rt.strToAsciiLowercase(_94.v); + const _94: rs.Place = rs.place(() => t, (value17) => t = value17); + _94.v = rs.strToAsciiLowercase(_94.v); } else if (_58 === 14) { - t = rt.strSlice(s, 0); + t = rs.strSlice(s, 0); } else if (_58 === 15) { - bump(rt.place(() => nested, (value16) => nested = value16), by); + bump(rs.place(() => nested, (value16) => nested = value16), by); } else if (_58 === 16) { - nested = rt.u32WrappingAdd(nested, by as rt.u32); + nested = rs.u32WrappingAdd(nested, by as rs.u32); } else if (_58 === 17) { - const _104: rt.u32 = by as rt.u32; + const _104: rs.u32 = by as rs.u32; if (maybe === undefined) { maybe = _104; } - maybe = rt.u32Add(maybe as rt.u32, 1); + maybe = rs.u32Add(maybe as rs.u32, 1); if (maybe !== undefined) { - bump(rt.place(() => maybe as rt.u32, (value15) => maybe = value15), by); + bump(rs.place(() => maybe as rs.u32, (value15) => maybe = value15), by); } } else if (_58 === 18) { reach(held, by); } else if (_58 === 19) { - const at2 = rt.idx(v.items, rt.usizeRem(by as rt.usize, v.items.length)); + const at2 = rs.idx(v.items, rs.usizeRem(by as rs.usize, v.items.length)); const borrowed = v.items; const borrowed2 = at2; - bump(rt.place(() => borrowed[borrowed2], (value14) => borrowed[borrowed2] = value14), by); - const _120: rt.Place | undefined = rt.sliceLastMut(v.items); + bump(rs.place(() => borrowed[borrowed2], (value14) => borrowed[borrowed2] = value14), by); + const _120: rs.Place | undefined = rs.sliceLastMut(v.items); if (_120 !== undefined) { _120.v = (_120.v ^ 16) >>> 0; } } else if (_58 === 20) { - const iter2: rt.Iter> = rt.iterSliceMut(v.items); + const iter2: rs.Iter> = rs.iterSliceMut(v.items); while (true) { - const _130: rt.Place | rt.Done = iter2.next(); - if (_130 === rt.DONE) { + const _130: rs.Place | rs.Done = iter2.next(); + if (_130 === rs.DONE) { break; } - bump(rt.place(() => _130.v, (value13) => _130.v = value13), by); + bump(rs.place(() => _130.v, (value13) => _130.v = value13), by); } - v.items.push(by as rt.u32); + v.items.push(by as rs.u32); } else if (_58 === 21) { - const _140: rt.Place = rt.place(() => o, (value9) => o = value9); + const _140: rs.Place = rs.place(() => o, (value9) => o = value9); if (_140.v !== undefined) { - _140.v = rt.u32WrappingAdd(_140.v, by as rt.u32); + _140.v = rs.u32WrappingAdd(_140.v, by as rs.u32); } - const _147: rt.Place = rt.place(() => o, (value10) => o = value10); - const _146: rt.Place | undefined = _147.v === undefined ? undefined : rt.place(() => _147.v as rt.u32, (value11) => _147.v = value11); + const _147: rs.Place = rs.place(() => o, (value10) => o = value10); + const _146: rs.Place | undefined = _147.v === undefined ? undefined : rs.place(() => _147.v as rs.u32, (value11) => _147.v = value11); if (_146 !== undefined) { bump(_146, by); } - if (rt.usizeRem(i, 3) === 0) { - o = then$0ea5h05(o === undefined, (): rt.u32 => { - return by as rt.u32; + if (rs.usizeRem(i, 3) === 0) { + o = then$0apfzgv(o === undefined, (): rs.u32 => { + return by as rs.u32; }); } if (res.ok) { - res = { ok: true, value: rt.u32WrappingMul(res.value, by as rt.u32) }; + res = { ok: true, value: rs.u32WrappingMul(res.value, by as rs.u32) }; } - const _165: rt.Place> = rt.place(() => said, (value12) => said = value12); + const _165: rs.Place> = rs.place(() => said, (value12) => said = value12); if (_165.v.ok) { - _165.v = { ok: true, value: _165.v.value + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(by, 26)) as rt.char) }; + _165.v = { ok: true, value: _165.v.value + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(by, 26)) as rs.char) }; } - if (rt.usizeRem(i, 5) === 4) { - said = rt.Err(by); + if (rs.usizeRem(i, 5) === 4) { + said = rs.Err(by); } } else if (_58 === 22) { - const _180: rt.u32 = by as rt.u32; - const _181: rt.usize = rt.usizeRem(by as rt.usize, 2); - rt.idx(words, _181); - words[_181] = rt.u32Add(words[_181], _180); - const _188: rt.u32[] | undefined = someWords; + const _180: rs.u32 = by as rs.u32; + const _181: rs.usize = rs.usizeRem(by as rs.usize, 2); + rs.idx(words, _181); + words[_181] = rs.u32Add(words[_181], _180); + const _188: rs.u32[] | undefined = someWords; if (_188 !== undefined) { - const _192: rt.u32 = by as rt.u32; - rt.idx(_188, 1); + const _192: rs.u32 = by as rs.u32; + rs.idx(_188, 1); _188[1] = (_188[1] ^ _192) >>> 0; } - const _197: rt.Place | undefined = named === undefined ? undefined : rt.place(() => named as string, (value4) => named = value4); + const _197: rs.Place | undefined = named === undefined ? undefined : rs.place(() => named as string, (value4) => named = value4); if (_197 !== undefined) { shout(_197, by); } - const _202: rt.Place | undefined = deep === rt.None ? undefined : rt.place(() => deep as rt.u32 | undefined, (value5) => deep = value5); + const _202: rs.Place | undefined = deep === rs.None ? undefined : rs.place(() => deep as rs.u32 | undefined, (value5) => deep = value5); if (_202 !== undefined) { if (_202.v !== undefined) { - _202.v = rt.u32Add(_202.v, by as rt.u32); + _202.v = rs.u32Add(_202.v, by as rs.u32); } } - const _209: rt.Place | undefined = deep === rt.None ? undefined : rt.place(() => deep as rt.u32 | undefined, (value6) => deep = value6); + const _209: rs.Place | undefined = deep === rs.None ? undefined : rs.place(() => deep as rs.u32 | undefined, (value6) => deep = value6); if (_209 !== undefined) { - if (!(rt.u8Rem(by, 4) === 0)) { + if (!(rs.u8Rem(by, 4) === 0)) { if (_209.v === undefined) { _209.v = 9; } @@ -653,89 +653,89 @@ export function places(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } if (tup.ok) { - tup.value[0] = rt.u32Add(tup.value[0], by as rt.u32); - const _357: [rt.u32, rt.u32] = tup.value; - bump(rt.place(() => _357[1], (value7) => _357[1] = value7), by); + tup.value[0] = rs.u32Add(tup.value[0], by as rs.u32); + const _357: [rs.u32, rs.u32] = tup.value; + bump(rs.place(() => _357[1], (value7) => _357[1] = value7), by); } - const _227: rt.Place | undefined = boxedOpt === undefined ? undefined : rt.place(() => boxedOpt as rt.u32, (value8) => boxedOpt = value8); + const _227: rs.Place | undefined = boxedOpt === undefined ? undefined : rs.place(() => boxedOpt as rs.u32, (value8) => boxedOpt = value8); if (_227 !== undefined) { bump(_227, by); } if (boxedOpt !== undefined) { - boxedOpt = rt.u32Add(boxedOpt, 1); + boxedOpt = rs.u32Add(boxedOpt, 1); } } else if (_58 === 23) { - const _238: rt.Place = rt.place(() => n, (value3) => n = value3); - const f: (a0: rt.u8) => undefined = (by2: rt.u8): undefined => { + const _238: rs.Place = rs.place(() => n, (value3) => n = value3); + const f: (a0: rs.u8) => undefined = (by2: rs.u8): undefined => { bump(_238, by2); }; f(by); f(1); } else if (_58 === 24) { n = took(n, by); - reaimed(rt.place(() => n, (value) => n = value), rt.place(() => held.n, (value2) => held.n = value2), by); + reaimed(rs.place(() => n, (value) => n = value), rs.place(() => held.n, (value2) => held.n = value2), by); } else { bump(leaked, by); } - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(n).reverse()), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pair)); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(n).reverse()), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pair)); put(out, s); put(out, t); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(nested).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(maybe, 238)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(held.n).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(nested).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(maybe, 238)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.n).reverse()), undefined, true); put(out, held.s); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(held.nested).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v.items), (b: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(b).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(option_asDeref$0avuzwv(o), 238)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(result_unwrapOr$0e4foht(copied$0bbq7yi(result_asDeref$04i8i5u(res)), 238)).reverse()), undefined, true); - const _298: rt.Result = said; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(held.nested).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v.items), (b: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(b).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(option_asDeref$13yyv6y(o), 238)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(result_unwrapOr$1n4fvf5(copied$1m63478(result_asDeref$1qd1pp0(res)), 238)).reverse()), undefined, true); + const _298: rs.Result = said; if (_298.ok) { put(out, _298.value); } else { - rt.byteVecPush(out, _298.error); + rs.byteVecPush(out, _298.error); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(words), (w: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(w).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterFlatten(rt.iterOption(someWords), (value: rt.u32[]) => rt.iterSlice(value), true), (w2: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(w2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), "next"); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(words), (w: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(w).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterFlatten(rs.iterOption(someWords), (value: rs.u32[]) => rs.iterSlice(value), true), (w2: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(w2).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), "next"); put(out, option_unwrapOr$1iemzn8(option_asDeref$0w8at8i(named), "-")); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(leaked.v).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(option_flatten$08boupk(option_asDeref$0w2m0zn(deep)), 238)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(result_unwrapOr$0e4foht(result_map$0nfi04k(result_asDeref$1fldd5d(tup), (t2: [rt.u32, rt.u32]): rt.u32 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(leaked.v).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(option_flatten$1s0exy3(option_asDeref$0r30y86(deep)), 238)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(result_unwrapOr$1n4fvf5(result_map$0v9s95z(result_asDeref$15ue8vz(tup), (t2: [rs.u32, rs.u32]): rs.u32 => { return (t2[0] ^ t2[1]) >>> 0; }), 238)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_unwrapOr$11c0we2(boxedOpt, 238)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(boxedOpt, 238)).reverse()), undefined, true); } } /** Clones `from` into `slot` by its `clone_from`. */ -export function refill$boxed_Box_slice_boxes_Logged(slot: rt.Place, from: Logged.Logged[]): void { - slot.v = rt.boxSliceCloneFrom(slot.v, from, Logged.clone$Clone, rt.drop); +export function refill$boxed_Box_slice_boxes_Logged(slot: rs.Place, from: Logged.Logged[]): void { + slot.v = rs.boxSliceCloneFrom(slot.v, from, Logged.clone$Clone, rs.drop); } /** Clones `from` into `slot` by its `clone_from`. */ -export function refill$boxed_Box_slice_u8(slot: rt.Place, from: rt.ByteSlice): void { - slot.v = rt.byteBoxSliceCloneFrom(slot.v, from); +export function refill$boxed_Box_slice_u8(slot: rs.Place, from: rs.ByteSlice): void { + slot.v = rs.byteBoxSliceCloneFrom(slot.v, from); } /** The sum of the bytes `x` lends by its `AsRef`. */ -export function sum$boxed_Box_slice_u8(x: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(x)), 0, (a: rt.u8, _32: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a, _32); +export function sum$boxed_Box_slice_u8(x: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(x)), 0, (a: rs.u8, _32: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a, _32); }); } /** Writes through what `x` lends by its `AsMut`. */ -export function flip$boxed_Box_slice_u8(x: rt.Place): void { - const iter: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(x.v)); +export function flip$boxed_Box_slice_u8(x: rs.Place): void { + const iter: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(x.v)); while (true) { - const _5: rt.Place | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.Place | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } _5.v = _5.v ^ 15; @@ -743,50 +743,50 @@ export function flip$boxed_Box_slice_u8(x: rt.Place): void { } /** Puts what boxing `r` into an array gave: its bytes, or a marker and what it gave back. */ -export function boxed$0_boxed_Box_slice_u8(r: rt.Result, out: rt.ByteVec): void { +export function boxed$0_boxed_Box_slice_u8(r: rs.Result, out: rs.ByteVec): void { if (r.ok) { const a: Uint8Array = r.value; - const _5: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _5: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_5 !== undefined) { _5.v = _5.v ^ 255; } - bytes(rt.byteSliceFrom(a), out); + bytes(rs.byteSliceFrom(a), out); } else { - const e: rt.ByteSlice = r.error; - rt.byteVecPush(out, 238); + const e: rs.ByteSlice = r.error; + rs.byteVecPush(out, 238); bytes(e, out); } } /** Puts what boxing `r` into an array gave: its bytes, or a marker and what it gave back. */ -export function boxed$3_boxed_Box_slice_u8(r: rt.Result, out: rt.ByteVec): void { +export function boxed$3_boxed_Box_slice_u8(r: rs.Result, out: rs.ByteVec): void { if (r.ok) { const a: Uint8Array = r.value; - const _5: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _5: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_5 !== undefined) { _5.v = _5.v ^ 255; } - bytes(rt.byteSliceFrom(a), out); + bytes(rs.byteSliceFrom(a), out); } else { - const e: rt.ByteSlice = r.error; - rt.byteVecPush(out, 238); + const e: rs.ByteSlice = r.error; + rs.byteVecPush(out, 238); bytes(e, out); } } /** Puts what boxing `r` into an array gave: its bytes, or a marker and what it gave back. */ -export function boxed$4_Vec_u8(r: rt.Result, out: rt.ByteVec): void { +export function boxed$4_Vec_u8(r: rs.Result, out: rs.ByteVec): void { if (r.ok) { const a: Uint8Array = r.value; - const _5: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(a))); + const _5: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(a))); if (_5 !== undefined) { _5.v = _5.v ^ 255; } - bytes(rt.byteSliceFrom(a), out); + bytes(rs.byteSliceFrom(a), out); } else { - const e: rt.ByteVec = r.error; - rt.byteVecPush(out, 238); - bytes(rt.byteVecSlice(e), out); + const e: rs.ByteVec = r.error; + rs.byteVecPush(out, 238); + bytes(rs.byteVecSlice(e), out); } } @@ -797,239 +797,239 @@ export function boxed$4_Vec_u8(r: rt.Result, out: rt.Byt * length or not; and a boxed text's bytes. Each of bytes and of other values, empty or * not, with what drops dropped in std's order. */ -export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const half: rt.usize = rt.usizeDiv(data2.length, 2); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const half: rs.usize = rs.usizeDiv(data2.length, 2); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const _23: rt.u8 = rt.u8Rem(kind, 4); + const _23: rs.u8 = rs.u8Rem(kind, 4); if (_23 === 0) { - let a: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, 0, half))); - const b: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))); - a = rt.byteBoxSliceCloneFrom(a, b); - const _36: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(a)); + let a: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, 0, half))); + const b: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))); + a = rs.byteBoxSliceCloneFrom(a, b); + const _36: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(a)); if (_36 !== undefined) { _36.v = _36.v ^ 255; } bytes(a, out); bytes(b, out); - const _49: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - refill$boxed_Box_slice_u8(rt.place(() => a, (value2) => a = value2), _49); - rt.byteSliceView(a).reverse(); + const _49: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + refill$boxed_Box_slice_u8(rs.place(() => a, (value2) => a = value2), _49); + rs.byteSliceView(a).reverse(); bytes(a, out); - let w: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half))), (_216: rt.u8): rt.u16 => { - return rt.u16Mul(_216 as rt.u16, 257); + let w: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half))), (_216: rs.u8): rs.u16 => { + return rs.u16Mul(_216 as rs.u16, 257); }), undefined, 2, true).items; - const v: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, rt.usizeSub(data2.length, half)))), (_218: rt.u8): rt.u16 => { - return ((_218 as rt.u16) << 3) & 0xffff; + const v: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, rs.usizeSub(data2.length, half)))), (_218: rs.u8): rs.u16 => { + return ((_218 as rs.u16) << 3) & 0xffff; }), undefined, 2, true).items; - w = rt.boxSliceCloneFrom(w, v); + w = rs.boxSliceCloneFrom(w, v); w.reverse(); wides(w, out); wides(v, out); - const _82: rt.u16[] = [1, 2, 3]; - w = rt.boxSliceCloneFrom(w, _82); + const _82: rs.u16[] = [1, 2, 3]; + w = rs.boxSliceCloneFrom(w, _82); wides(w, out); - let p: [rt.u8, rt.u16][] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, half))), (_220: rt.u8): [rt.u8, rt.u16] => { - return [_220, 7] as [rt.u8, rt.u16]; + let p: [rs.u8, rs.u16][] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_220: rs.u8): [rs.u8, rs.u16] => { + return [_220, 7] as [rs.u8, rs.u16]; }), undefined, 4, true).items; - const q: [rt.u8, rt.u16][] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))), (_221: rt.u8): [rt.u8, rt.u16] => { - return [_221 ^ 1, 9] as [rt.u8, rt.u16]; + const q: [rs.u8, rs.u16][] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_221: rs.u8): [rs.u8, rs.u16] => { + return [_221 ^ 1, 9] as [rs.u8, rs.u16]; }), undefined, 4, true).items; - p = rt.boxSliceCloneFrom(p, q, copy$tuple2_u8_u16); - const _102: [rt.u8, rt.u16] | undefined = rt.sliceFirst(p); + p = rs.boxSliceCloneFrom(p, q, copy$tuple2_u8_u16); + const _102: [rs.u8, rs.u16] | undefined = rs.sliceFirst(p); if (_102 !== undefined) { _102[0] = 51; _102[1] = 68; } - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterChain(rt.iterSlice(p), rt.iterSlice(q)); + const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterChain(rs.iterSlice(p), rs.iterSlice(q)); while (true) { - const _113: [rt.u8, rt.u16] | rt.Done = iter.next(); - if (_113 === rt.DONE) { + const _113: [rs.u8, rs.u16] | rs.Done = iter.next(); + if (_113 === rs.DONE) { break; } - rt.byteVecPush(out, _113[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_113[1]).reverse()), undefined, true); + rs.byteVecPush(out, _113[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_113[1]).reverse()), undefined, true); } - let s: string[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, half))), (_222: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_222))); + let s: string[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_222: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(_222))); }), undefined, 12, true).items; - const t: string[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))), (_223: rt.u8): string => { - const x11: rt.u8 = _223; - return text(rt.byteSliceFrom(Uint8Array.of(x11, x11))); + const t: string[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_223: rs.u8): string => { + const x11: rs.u8 = _223; + return text(rs.byteSliceFrom(Uint8Array.of(x11, x11))); }), undefined, 12, true).items; - s = rt.boxSliceCloneFrom(s, t); - const _138: rt.Place | undefined = rt.sliceFirstMut(s); + s = rs.boxSliceCloneFrom(s, t); + const _138: rs.Place | undefined = rs.sliceFirstMut(s); if (_138 !== undefined) { _138.v = _138.v + "!"; } - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(s), rt.iterSlice(t)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(s), rs.iterSlice(t)); while (true) { - const _150: string | rt.Done = iter2.next(); - if (_150 === rt.DONE) { + const _150: string | rs.Done = iter2.next(); + if (_150 === rs.DONE) { break; } put(out, _150); } - let l: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, half))), (_224: rt.u8): Logged.Logged => { + let l: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, half))), (_224: rs.u8): Logged.Logged => { return logged(_224 & 126); }), undefined, 8, true).items; - const m: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, half, rt.usizeMul(half, 2)))), (_226: rt.u8): Logged.Logged => { + const m: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, half, rs.usizeMul(half, 2)))), (_226: rs.u8): Logged.Logged => { return logged(_226 | 1); }), undefined, 8, true).items; flush(log.value, out); - l = rt.boxSliceCloneFrom(l, m, Logged.clone$Clone, rt.drop); + l = rs.boxSliceCloneFrom(l, m, Logged.clone$Clone, rs.drop); flush(log.value, out); ids(l, out); const _187: Logged.Logged[] = [logged(16), logged(18), logged(20)]; - refill$boxed_Box_slice_boxes_Logged(rt.place(() => l, (value3) => l = value3), _187); - rt.dropAll(_187); + refill$boxed_Box_slice_boxes_Logged(rs.place(() => l, (value3) => l = value3), _187); + rs.dropAll(_187); flush(log.value, out); ids(l, out); - const held: Held.Held = new Held.Held(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data2, 0, rt.usizeSub(data2.length, half)))), (_227: rt.u8): Logged.Logged => { + const held: Held.Held = new Held.Held(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data2, 0, rs.usizeSub(data2.length, half)))), (_227: rs.u8): Logged.Logged => { return logged(_227 & 126); }), undefined, 8, true).items, logged(80)); flush(log.value, out); - held.items = rt.boxSliceCloneFrom(held.items, m, Logged.clone$Clone, rt.drop); + held.items = rs.boxSliceCloneFrom(held.items, m, Logged.clone$Clone, rs.drop); flush(log.value, out); ids(held.items, out); held[Symbol.dispose](); flush(log.value, out); - const v2: rt.Vec = rt.vecFrom([rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, 0, half))), rt.byteSliceFrom(rt.byteSliceToArray(data2))]); - const at = rt.idx(v2.items, 1); - v2.items[at] = rt.byteBoxSliceCloneFrom(v2.items[at], b); - const at2 = rt.idx(v2.items, 0); - v2.items[at2] = rt.byteBoxSliceCloneFrom(v2.items[at2], a); + const v2: rs.Vec = rs.vecFrom([rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, 0, half))), rs.byteSliceFrom(rs.byteSliceToArray(data2))]); + const at = rs.idx(v2.items, 1); + v2.items[at] = rs.byteBoxSliceCloneFrom(v2.items[at], b); + const at2 = rs.idx(v2.items, 0); + v2.items[at2] = rs.byteBoxSliceCloneFrom(v2.items[at2], a); for (const _252 of v2.items) { bytes(_252, out); } - rt.dropAll(l); - rt.dropAll(m); + rs.dropAll(l); + rs.dropAll(m); flush(log.value, out); let t2: string = "ab"; t2 = text(data2); put(out, t2); } else if (_23 === 1) { - let a2: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); + let a2: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); bytes(a2, out); - rt.byteSliceView(a2).reverse(); - flip$boxed_Box_slice_u8(rt.place(() => a2, (value) => a2 = value)); - rt.byteVecPush(out, sum$boxed_Box_slice_u8(a2)); + rs.byteSliceView(a2).reverse(); + flip$boxed_Box_slice_u8(rs.place(() => a2, (value) => a2 = value)); + rs.byteVecPush(out, sum$boxed_Box_slice_u8(a2)); bytes(a2, out); - let n: rt.u32 = data2.length as rt.u32; - n = rt.u32Add(n, 7); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(n).reverse()), undefined, true); - const pair: [rt.u8, rt.u16] = [option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 1), 2]; - const _306: [rt.u8, rt.u16] = pair; + let n: rs.u32 = data2.length as rs.u32; + n = rs.u32Add(n, 7); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(n).reverse()), undefined, true); + const pair: [rs.u8, rs.u16] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data2), 1), 2]; + const _306: [rs.u8, rs.u16] = pair; _306[1] = _306[1] ^ 257; - const copy: [rt.u8, rt.u16] = copy$tuple2_u8_u16(pair); + const copy: [rs.u8, rs.u16] = copy$tuple2_u8_u16(pair); pair[0] = 9; - rt.byteVecPush(out, copy[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(copy[1]).reverse()), undefined, true); - rt.byteVecPush(out, pair[0]); + rs.byteVecPush(out, copy[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(copy[1]).reverse()), undefined, true); + rs.byteVecPush(out, pair[0]); const array: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const _322: rt.ByteSlice = rt.byteSliceFrom(array); - const _324: rt.usize = rt.usizeRem(kind as rt.usize, 4); + const _322: rs.ByteSlice = rs.byteSliceFrom(array); + const _324: rs.usize = rs.usizeRem(kind as rs.usize, 4); if (!(_324 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _324); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _324); } _322.data[_322.start + _324] = 85; - rt.byteSliceView(rt.byteSliceFrom(array)).reverse(); - bytes(rt.byteSliceFrom(array), out); - const v3: rt.ByteVec = rt.byteSliceToByteVec(data2); - rt.byteVecPush(v3, 102); - bytes(rt.byteVecSlice(v3), out); + rs.byteSliceView(rs.byteSliceFrom(array)).reverse(); + bytes(rs.byteSliceFrom(array), out); + const v3: rs.ByteVec = rs.byteSliceToByteVec(data2); + rs.byteVecPush(v3, 102); + bytes(rs.byteVecSlice(v3), out); let s2: string = text(data2); s2 = s2 + "#"; put(out, s2); - const w2: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_28: rt.u8): rt.u16 => { - return rt.u16Add(_28 as rt.u16, 1); + const w2: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_28: rs.u8): rs.u16 => { + return rs.u16Add(_28 as rs.u16, 1); }), undefined, 2, true).items; - rt.sliceSortUnstable(w2, rt.lt, 2, true, true); + rs.sliceSortUnstable(w2, rs.lt, 2, true, true); wides(w2, out); - const l2: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_214: rt.u8): Logged.Logged => { + const l2: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_214: rs.u8): Logged.Logged => { return logged(_214); }), undefined, 8, true).items; const _368: Logged.Logged[] = l2; if (_368.length >= 2) { - rt.sliceSwapAcross(_368, 0, _368, _368.length - 1); + rs.sliceSwapAcross(_368, 0, _368, _368.length - 1); } ids(l2, out); - let o: rt.u8 | undefined = rt.byteSliceFirst(data2); + let o: rs.u8 | undefined = rs.byteSliceFirst(data2); if (o !== undefined) { - o = rt.u8WrappingAdd(o, 1); + o = rs.u8WrappingAdd(o, 1); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(o, 238)); - rt.dropAll(l2); + rs.byteVecPush(out, option_unwrapOr$1fr498u(o, 238)); + rs.dropAll(l2); } else if (_23 === 2) { - const _395: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - boxed$3_boxed_Box_slice_u8(_395.length === 3 ? rt.Ok(rt.byteSliceView(_395)) : rt.Err(_395), out); - const _398: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceToArray(data2)); - boxed$0_boxed_Box_slice_u8(_398.length === 0 ? rt.Ok(rt.byteSliceView(_398)) : rt.Err(_398), out); - const _400: rt.ByteVec = rt.byteSliceToByteVec(data2); - const r: rt.Result = _400.length === 2 ? rt.Ok(rt.byteSliceView(rt.byteVecSlice(_400))) : rt.Err(_400); + const _395: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + boxed$3_boxed_Box_slice_u8(_395.length === 3 ? rs.Ok(rs.byteSliceView(_395)) : rs.Err(_395), out); + const _398: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceToArray(data2)); + boxed$0_boxed_Box_slice_u8(_398.length === 0 ? rs.Ok(rs.byteSliceView(_398)) : rs.Err(_398), out); + const _400: rs.ByteVec = rs.byteSliceToByteVec(data2); + const r: rs.Result = _400.length === 2 ? rs.Ok(rs.byteSliceView(rs.byteVecSlice(_400))) : rs.Err(_400); if (r.ok) { - bytes(rt.byteSliceFrom(r.value), out); + bytes(rs.byteSliceFrom(r.value), out); } else { - const v4: rt.ByteVec = r.error; - rt.byteVecPush(v4, 119); - bytes(rt.byteVecSlice(v4), out); + const v4: rs.ByteVec = r.error; + rs.byteVecPush(v4, 119); + bytes(rs.byteVecSlice(v4), out); } - const spare: rt.ByteVec = rt.byteVecWithCapacity(32); - rt.byteVecExtendFromSlice(spare, data2); - const _417: rt.ByteVec = spare; - boxed$4_Vec_u8(_417.length === 4 ? rt.Ok(rt.byteSliceView(rt.byteVecSlice(_417))) : rt.Err(_417), out); - const w3: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 3); + const spare: rs.ByteVec = rs.byteVecWithCapacity(32); + rs.byteVecExtendFromSlice(spare, data2); + const _417: rs.ByteVec = spare; + boxed$4_Vec_u8(_417.length === 4 ? rs.Ok(rs.byteSliceView(rs.byteVecSlice(_417))) : rs.Err(_417), out); + const w3: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 3); }), undefined, 2, true).items; - const _422: rt.Result = w3.length === 2 ? rt.Ok(w3) : rt.Err(w3); + const _422: rs.Result = w3.length === 2 ? rs.Ok(w3) : rs.Err(w3); if (_422.ok) { - const a4: rt.u16[] = _422.value; + const a4: rs.u16[] = _422.value; a4[1] = 4660; wides(a4, out); } else { wides(_422.error, out); } - const l3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): Logged.Logged => { + const l3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_22: rs.u8): Logged.Logged => { return logged(_22 & 126); }), undefined, 8, true); - const _438: rt.Result> = l3.items.length === 2 ? rt.Ok(l3.items) : rt.Err(l3); + const _438: rs.Result> = l3.items.length === 2 ? rs.Ok(l3.items) : rs.Err(l3); if (_438.ok) { const a5: Logged.Logged[] = _438.value; ids(a5, out); flush(log.value, out); - rt.dropAll(a5); + rs.dropAll(a5); } else { - const l4: rt.Vec = _438.error; + const l4: rs.Vec = _438.error; ids(l4.items, out); flush(log.value, out); - rt.dropVec(l4); + rs.dropVec(l4); } flush(log.value, out); - const l5: Logged.Logged[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_25: rt.u8): Logged.Logged => { + const l5: Logged.Logged[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_25: rs.u8): Logged.Logged => { return logged(_25 | 1); }), undefined, 8, true).items; - const r2: rt.Result = l5.length === 1 ? rt.Ok(l5) : rt.Err(l5); + const r2: rs.Result = l5.length === 1 ? rs.Ok(l5) : rs.Err(l5); flush(log.value, out); drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(r2); flush(log.value, out); } else { const s3: string = text(data2); - const a6: rt.ByteSlice = rt.stringAsBytes(s3); - rt.byteSliceView(a6).reverse(); + const a6: rs.ByteSlice = rs.stringAsBytes(s3); + rs.byteSliceView(a6).reverse(); bytes(a6, out); - const b2: rt.ByteSlice = rt.stringAsBytes(s3); - const _485: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(b2)); + const b2: rs.ByteSlice = rs.stringAsBytes(s3); + const _485: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(b2)); if (_485 !== undefined) { _485.v = 33; } bytes(b2, out); - const v5: rt.ByteVec = rt.byteSliceToByteVec(rt.stringAsBytes(s3)); - rt.byteVecPush(v5, 46); - bytes(rt.byteVecSlice(v5), out); - bytes(rt.stringAsBytes(""), out); + const v5: rs.ByteVec = rs.byteSliceToByteVec(rs.stringAsBytes(s3)); + rs.byteVecPush(v5, 46); + bytes(rs.byteVecSlice(v5), out); + bytes(rs.stringAsBytes(""), out); } log[Symbol.dispose](); } diff --git a/ts/fixtures/lang/boxes/expected/core/bool.ts b/ts/fixtures/lang/boxes/expected/core/bool.ts index a9e31d7f0..c200186ac 100644 --- a/ts/fixtures/lang/boxes/expected/core/bool.ts +++ b/ts/fixtures/lang/boxes/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$0ea5h05(self: boolean, f: () => rt.u32): rt.u32 | undefined { +export function then$0apfzgv(self: boolean, f: () => rs.u32): rs.u32 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/boxes/expected/core/option.ts b/ts/fixtures/lang/boxes/expected/core/option.ts index f61d09eca..d64701c30 100644 --- a/ts/fixtures/lang/boxes/expected/core/option.ts +++ b/ts/fixtures/lang/boxes/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; export function unwrapOr$1iemzn8(self: string | undefined, default_: string): string { if (self === undefined) { @@ -9,30 +9,30 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$11c0we2(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { +export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1k1fy8u(self: rt.u32 | undefined | rt.None, _: (a0: rt.u32 | undefined) => rt.u32 | undefined): rt.u32 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$05w7tkb(self: rs.u32 | undefined | rs.None, _: (a0: rs.u32 | undefined) => rs.u32 | undefined): rs.u32 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return self; } @@ -44,22 +44,22 @@ export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string) return self; } -export function map$0xz4pvf(self: rt.u32 | undefined, _: (a0: rt.u32) => rt.u32): rt.u32 | undefined { +export function map$03qwbb9(self: rs.u32 | undefined, _: (a0: rs.u32) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function asDeref$0w2m0zn(self: rt.u32 | undefined | rt.None): rt.u32 | undefined | rt.None { - return map$1k1fy8u(self, (a0: rt.u32 | undefined): rt.u32 | undefined => { +export function asDeref$0r30y86(self: rs.u32 | undefined | rs.None): rs.u32 | undefined | rs.None { + return map$05w7tkb(self, (a0: rs.u32 | undefined): rs.u32 | undefined => { return a0; }); } @@ -70,14 +70,14 @@ export function asDeref$0w8at8i(self: string | undefined): string | undefined { }); } -export function asDeref$0avuzwv(self: rt.u32 | undefined): rt.u32 | undefined { - return map$0xz4pvf(self, (a0: rt.u32): rt.u32 => { +export function asDeref$13yyv6y(self: rs.u32 | undefined): rs.u32 | undefined { + return map$03qwbb9(self, (a0: rs.u32): rs.u32 => { return a0; }); } -export function flatten$08boupk(self: rt.u32 | undefined | rt.None): rt.u32 | undefined { - if (self === rt.None) { +export function flatten$1s0exy3(self: rs.u32 | undefined | rs.None): rs.u32 | undefined { + if (self === rs.None) { return undefined; } return self; diff --git a/ts/fixtures/lang/boxes/expected/core/result.ts b/ts/fixtures/lang/boxes/expected/core/result.ts index a5e4c7199..df7de7899 100644 --- a/ts/fixtures/lang/boxes/expected/core/result.ts +++ b/ts/fixtures/lang/boxes/expected/core/result.ts @@ -1,64 +1,64 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function asRef$0iljode(self: rt.Result<[rt.u32, rt.u32], rt.u8>): rt.Result<[rt.u32, rt.u32], rt.u8> { +export function asRef$18mrs71(self: rs.Result<[rs.u32, rs.u32], rs.u8>): rs.Result<[rs.u32, rs.u32], rs.u8> { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function asRef$10maq8w(self: rt.Result): rt.Result { +export function asRef$14w520n(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function map$17yn9bi(self: rt.Result<[rt.u32, rt.u32], rt.u8>, _: (a0: [rt.u32, rt.u32]) => [rt.u32, rt.u32]): rt.Result<[rt.u32, rt.u32], rt.u8> { +export function map$1t0fph6(self: rs.Result<[rs.u32, rs.u32], rs.u8>, _: (a0: [rs.u32, rs.u32]) => [rs.u32, rs.u32]): rs.Result<[rs.u32, rs.u32], rs.u8> { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } return self; } -export function map$0m0doqe(self: rt.Result, _: (a0: rt.u32) => rt.u32): rt.Result { +export function map$00dshix(self: rs.Result, _: (a0: rs.u32) => rs.u32): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } return self; } -export function map$0nfi04k(self: rt.Result<[rt.u32, rt.u32], rt.u8>, op: (a0: [rt.u32, rt.u32]) => rt.u32): rt.Result { +export function map$0v9s95z(self: rs.Result<[rs.u32, rs.u32], rs.u8>, op: (a0: [rs.u32, rs.u32]) => rs.u32): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function asDeref$1fldd5d(self: rt.Result<[rt.u32, rt.u32], rt.u8>): rt.Result<[rt.u32, rt.u32], rt.u8> { - return map$17yn9bi(asRef$0iljode(self), (a0: [rt.u32, rt.u32]): [rt.u32, rt.u32] => { +export function asDeref$15ue8vz(self: rs.Result<[rs.u32, rs.u32], rs.u8>): rs.Result<[rs.u32, rs.u32], rs.u8> { + return map$1t0fph6(asRef$18mrs71(self), (a0: [rs.u32, rs.u32]): [rs.u32, rs.u32] => { return a0; }); } -export function asDeref$04i8i5u(self: rt.Result): rt.Result { - return map$0m0doqe(asRef$10maq8w(self), (a0: rt.u32): rt.u32 => { +export function asDeref$1qd1pp0(self: rs.Result): rs.Result { + return map$00dshix(asRef$14w520n(self), (a0: rs.u32): rs.u32 => { return a0; }); } -export function unwrapOr$0e4foht(self: rt.Result, default_: rt.u32): rt.u32 { +export function unwrapOr$1n4fvf5(self: rs.Result, default_: rs.u32): rs.u32 { if (self.ok) { return self.value; } return default_; } -export function copied$0bbq7yi(self: rt.Result): rt.Result { +export function copied$1m63478(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } return self; } diff --git a/ts/fixtures/lang/boxes/expected/harness.ts b/ts/fixtures/lang/boxes/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/boxes/expected/harness.ts +++ b/ts/fixtures/lang/boxes/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/boxes/expected/lib.ts b/ts/fixtures/lang/boxes/expected/lib.ts index fb83f882d..c959c2542 100644 --- a/ts/fixtures/lang/boxes/expected/lib.ts +++ b/ts/fixtures/lang/boxes/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { boxes, places, impls } from "./boxes.ts"; import type * as Logged from "./boxes.Logged.ts"; -export function copy$array_tuple2_u8_u16(v: [rt.u8, rt.u16][]): [rt.u8, rt.u16][] { +export function copy$array_tuple2_u8_u16(v: [rs.u8, rs.u16][]): [rs.u8, rs.u16][] { return v.map(copy$tuple2_u8_u16); } -export function copy$array_u16(v: rt.u16[]): rt.u16[] { +export function copy$array_u16(v: rs.u16[]): rs.u16[] { return v.slice(); } @@ -16,15 +16,15 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } -export function drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(_1: rt.Result): void { +export function drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_Logged(_1: rs.Result): void { if (_1.ok) { - rt.dropAll(_1.value); + rs.dropAll(_1.value); } else { - rt.dropAll(_1.error); + rs.dropAll(_1.error); } } @@ -32,8 +32,8 @@ export function drop$Result_boxed_Box_array1_boxes_Logged_boxed_Box_slice_boxes_ * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["boxes::boxes", boxes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::places", places as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["boxes::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["boxes::boxes", boxes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["boxes::places", places as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["boxes::impls", impls as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/capacity/expected/capacity.Holds.ts b/ts/fixtures/lang/capacity/expected/capacity.Holds.ts index 00d17f7c4..c752fc00a 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.Holds.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.Holds.ts @@ -1,33 +1,33 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u64, copy$tuple2_u64_u8 } from "./lib.ts"; -export function clone$Clone_array160_u64(self: Holds): Holds { - return new Holds(rt.vecFrom((self._0 as rt.Vec).items.map(copy$array_u64))); +export function clone$Clone_array160_u64(self: Holds): Holds { + return new Holds(rs.vecFrom((self._0 as rs.Vec).items.map(copy$array_u64))); } -export function clone$Clone_tuple2_u64_u8(self: Holds<[rt.u64, rt.u8]>): Holds<[rt.u64, rt.u8]> { - return new Holds(rt.vecFrom((self._0 as rt.Vec<[rt.u64, rt.u8]>).items.map(copy$tuple2_u64_u8))); +export function clone$Clone_tuple2_u64_u8(self: Holds<[rs.u64, rs.u8]>): Holds<[rs.u64, rs.u8]> { + return new Holds(rs.vecFrom((self._0 as rs.Vec<[rs.u64, rs.u8]>).items.map(copy$tuple2_u64_u8))); } -export function clone$Clone_u16(self: Holds): Holds { - return new Holds(rt.vecFrom((self._0 as rt.Vec).items.slice())); +export function clone$Clone_u16(self: Holds): Holds { + return new Holds(rs.vecFrom((self._0 as rs.Vec).items.slice())); } -export function clone$Clone_u8(self: Holds): Holds { - return new Holds(rt.byteVecFrom(rt.byteVecView(self._0 as rt.ByteVec))); +export function clone$Clone_u8(self: Holds): Holds { + return new Holds(rs.byteVecFrom(rs.byteVecView(self._0 as rs.ByteVec))); } export function clone$Clone_unit(self: Holds): Holds { - return new Holds(rt.vecFrom((self._0 as rt.Vec).items.slice())); + return new Holds(rs.vecFrom((self._0 as rs.Vec).items.slice())); } /** A struct whose derived `clone_from` clones. */ export class Holds { - _0: rt.VecOf; + _0: rs.VecOf; - constructor(_0: rt.VecOf) { + constructor(_0: rs.VecOf) { this._0 = _0; } } diff --git a/ts/fixtures/lang/capacity/expected/capacity.ts b/ts/fixtures/lang/capacity/expected/capacity.ts index 48eaa9a82..4ece5c87d 100644 --- a/ts/fixtures/lang/capacity/expected/capacity.ts +++ b/ts/fixtures/lang/capacity/expected/capacity.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u64, copy$array_usize, copy$tuple2_u64_u8 } from "./lib.ts"; import * as Holds from "./capacity.Holds.ts"; -import { then$060nyee, then$15ykizu, then$06am279, then$0ozmvid, then$1svdnnn } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrDefault$0301ewp as option_unwrapOrDefault$0301ewp, map$1e3rrc6 as option_map$1e3rrc6, map$0rgpr92 as option_map$0rgpr92, map$1dj8fjk as option_map$1dj8fjk, map$1p5j86b as option_map$1p5j86b, map$0197mxk as option_map$0197mxk, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; -import { unwrapOrElse$1q4qcpp as result_unwrapOrElse$1q4qcpp, unwrapOrElse$17cj159 as result_unwrapOrElse$17cj159, unwrapOrElse$1urqnv6 as result_unwrapOrElse$1urqnv6, unwrapOrElse$1bt75f9 as result_unwrapOrElse$1bt75f9, unwrapOrElse$1341i4f as result_unwrapOrElse$1341i4f } from "./core/result.ts"; +import { then$1b5wr43, then$0tujtct, then$0svbdod, then$17csa2h, then$0g2g1ls } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$1n6i7tn as option_map$1n6i7tn, map$12r4ivp as option_map$12r4ivp, map$03x2fqt as option_map$03x2fqt, map$1o9z3sm as option_map$1o9z3sm, map$1d4d0v7 as option_map$1d4d0v7, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; +import { unwrapOrElse$128e309 as result_unwrapOrElse$128e309, unwrapOrElse$02f6iwg as result_unwrapOrElse$02f6iwg, unwrapOrElse$05mb9nr as result_unwrapOrElse$05mb9nr, unwrapOrElse$0pqj9wx as result_unwrapOrElse$0pqj9wx, unwrapOrElse$01ys8fc as result_unwrapOrElse$01ys8fc } from "./core/result.ts"; /** A length or capacity, as four bytes. */ -export function put(out: rt.ByteVec, n: rt.usize): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(n as rt.u32).reverse())); +export function put(out: rs.ByteVec, n: rs.usize): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(n as rs.u32).reverse())); } /** A length and a capacity, as four bytes each. */ -export function sized(out: rt.ByteVec, len: rt.usize, cap: rt.usize): void { +export function sized(out: rs.ByteVec, len: rs.usize, cap: rs.usize): void { put(out, len); put(out, cap); } @@ -23,17 +23,17 @@ export function sized(out: rt.ByteVec, len: rt.usize, cap: rt.usize): void { * eight past what a vector of them may hold, or within eight of `usize::MAX`, either of * which panics before it allocates. */ -export function amount(arg: rt.u8, len: rt.usize, size: rt.usize): rt.usize { - const _4: rt.u8 = arg >> 5; +export function amount(arg: rs.u8, len: rs.usize, size: rs.usize): rs.usize { + const _4: rs.u8 = arg >> 5; if (_4 === 7) { - return rt.usizeSub(4294967295, (arg & 7) as rt.usize); + return rs.usizeSub(4294967295, (arg & 7) as rs.usize); } if (_4 === 6) { if (size > 0) { - return rt.usizeAdd(rt.usizeAdd(rt.usizeSub(rt.usizeDiv(2147483647, size), len), 1), (arg & 7) as rt.usize); + return rs.usizeAdd(rs.usizeAdd(rs.usizeSub(rs.usizeDiv(2147483647, size), len), 1), (arg & 7) as rs.usize); } } - return (arg & 31) as rt.usize; + return (arg & 31) as rs.usize; } /** A test that keeps every other element it is asked about. */ @@ -49,1246 +49,1246 @@ export function alternate(): () => boolean { * A `Vec` that `data`'s first byte makes, by `with_capacity` if odd, and each pair after * it changes, its length and capacity after each. */ -export function vecs(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 5); +export function vecs(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 5); if (_5 === 0) { - vecSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + vecSteps$u8(dataData, dataStart, dataLen, (b3: rs.u8): rs.u8 => { return b3; }, out); } else if (_5 === 1) { - vecSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + vecSteps$u16(dataData, dataStart, dataLen, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }, out); } else if (_5 === 2) { - vecSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { - return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + vecSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rs.u8): [rs.u64, rs.u8] => { + return [b2 as rs.u64, b2] as [rs.u64, rs.u8]; }, out); } else if (_5 === 3) { - vecSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { - const _3: rt.u64 = b as rt.u64; - return Array.from({ length: 160 }, (): rt.u64 => { + vecSteps$array160_u64(dataData, dataStart, dataLen, (b: rs.u8): rs.u64[] => { + const _3: rs.u64 = b as rs.u64; + return Array.from({ length: 160 }, (): rs.u64 => { return _3; }); }, out); } else { - vecSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + vecSteps$unit(dataData, dataStart, dataLen, (_2: rs.u8): undefined => {}, out); } } -export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { - let v!: rt.Vec; - let _132!: rt.u8; - let newLen!: rt.usize; - let end!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 1280; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function vecSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { + let v!: rs.Vec; + let _132!: rs.u8; + let newLen!: rs.usize; + let end!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 1280; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - v = rt.vecWithCapacity(first >> 3 as rt.usize, 1280); + v = rs.vecWithCapacity(first >> 3 as rs.usize, 1280); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - put(out, rt.vecCapacity(v, 1280)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(v, 1280)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 41); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 41); if (_39 === 0 || _39 === 1) { - const _41: rt.Vec = v; - const _42: rt.u64[] = copy$array_u64(make(arg)); + const _41: rs.Vec = v; + const _42: rs.u64[] = copy$array_u64(make(arg)); _41.items.push(_42); } else if (_39 === 2) { - rt.vecPop(v); + rs.vecPop(v); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 3) { - rt.vecReserve(v, additional, 1280); + const additional: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 3) { + rs.vecReserve(v, additional, 1280); } else { - rt.vecReserveExact(v, additional, 1280); + rs.vecReserveExact(v, additional, 1280); } } else if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 1280); + rs.vecShrinkTo(v, rs.u8Rem(arg, 40) as rs.usize, 1280); } else if (_39 === 6) { - rt.vecShrinkTo(v, 0, 1280); + rs.vecShrinkTo(v, 0, 1280); } else if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + rs.vecTruncate(v, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), copy$array_u64(make(arg))); + rs.vecInsert(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), copy$array_u64(make(arg))); } else if (_39 === 9) { if (!(v.items.length === 0)) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 10) { - rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i4: rt.u8): boolean => { - return rt.u8Rem(i4, 3) !== 0; + rs.iterExtend(v, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i4: rs.u8): boolean => { + return rs.u8Rem(i4, 3) !== 0; }), make), "next", 1280); } else if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 1280, true); + rs.iterExtend(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, 1280, true); } else if (_39 === 12) { - rt.vecExtendFromSlice(v, rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$array_u64).items, 1280, copy$array_u64); + rs.vecExtendFromSlice(v, rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 24) as rs.usize, copy$array_u64).items, 1280, copy$array_u64); } else if (_39 === 13) { - rt.vecTruncate(v, 0); + rs.vecTruncate(v, 0); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u64[]): boolean => { + rs.vecRetain(v, (_28: rs.u64[]): boolean => { return keep(); }); } else if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.items.length, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.vecDrain(v, { end: rs.min(v.items.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { - v = rt.vecFrom(v.items.map(copy$array_u64)); + v = rs.vecFrom(v.items.map(copy$array_u64)); } else if (_39 === 17) { - v = rt.vecFrom(v.items); + v = rs.vecFrom(v.items); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_27: rt.u64[]): boolean => { + v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_27: rs.u64[]): boolean => { return keep2(); }), "next", 1280, false, 1280); } else if (_39 === 19) { - const it: rt.Iter = rt.vecIntoIter(v); - const _129: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _129; + const it: rs.Iter = rs.vecIntoIter(v); + const _129: rs.u8 = rs.u8Rem(arg, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _129; while ((_132 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_132, 3) === 2)) { - rt.iterToOption(it.next()); + if (!(rs.u8Rem(_132, 3) === 2)) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } - v = rt.iterToVec(it, "next", 1280, true, 1280); + v = rs.iterToVec(it, "next", 1280, true, 1280); } else if (_39 === 20) { - let taken: rt.Vec = rt.replaceIn(v, new rt.Vec()); - const _149: rt.u64[] = copy$array_u64(make(arg)); + let taken: rs.Vec = rs.replaceIn(v, new rs.Vec()); + const _149: rs.u64[] = copy$array_u64(make(arg)); taken.items.push(_149); - sized(out, taken.items.length, rt.vecCapacity(taken, 1280)); - const _157: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 1280); + sized(out, taken.items.length, rs.vecCapacity(taken, 1280)); + const _157: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 1280); const old = taken; taken = _157; v = old; - sized(out, taken.items.length, rt.vecCapacity(taken, 1280)); + sized(out, taken.items.length, rs.vecCapacity(taken, 1280)); } else if (_39 === 21) { if (!(v.items.length === 0)) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecSwapRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 22) { - rt.vecDedupBy(v, rt.eqSlice(rt.u64Eq)); + rs.vecDedupBy(v, rs.eqSlice(rs.u64Eq)); } else if (_39 === 23) { - const it2: rt.Iter = rt.vecIntoIter(v); - const _180: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _180; + const it2: rs.Iter = rs.vecIntoIter(v); + const _180: rs.u8 = rs.u8Rem(arg, 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _180; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); + rs.iterToOption(it2.next()); } - v = rt.iterToVec(it2.clone({ v: copy$array_u64 }), "next", 1280, true, 1280); - const rest: rt.Vec = rt.iterToVec(it2, "next", 1280, true, 1280); - sized(out, rest.items.length, rt.vecCapacity(rest, 1280)); + v = rs.iterToVec(it2.clone({ v: copy$array_u64 }), "next", 1280, true, 1280); + const rest: rs.Vec = rs.iterToVec(it2, "next", 1280, true, 1280); + sized(out, rest.items.length, rs.vecCapacity(rest, 1280)); } else if (_39 === 24) { - v = rt.vecFromElem(copy$array_u64(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$array_u64); + v = rs.vecFromElem(copy$array_u64(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$array_u64); } else if (_39 === 25) { - rt.vecPopIf(v, (_26: rt.u64[]): boolean => { - return rt.u8Rem(arg, 2) === 1; + rs.vecPopIf(v, (_26: rs.u64[]): boolean => { + return rs.u8Rem(arg, 2) === 1; }); } else if (_39 === 26) { - v = rt.slicesJoin([rt.vecFrom(v.items.map(copy$array_u64)), v], 1280, undefined, rt.asSlice, copy$array_u64); + v = rs.slicesJoin([rs.vecFrom(v.items.map(copy$array_u64)), v], 1280, undefined, rs.asSlice, copy$array_u64); } else if (_39 === 27) { - v = rt.iterToVec(rt.iterSlice(v.items), "next", 1280, true, 1280); + v = rs.iterToVec(rs.iterSlice(v.items), "next", 1280, true, 1280); } else if (_39 === 28) { - const own: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1280); - const _225: rt.u64[] = copy$array_u64(make(arg)); + const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280); + const _225: rs.u64[] = copy$array_u64(make(arg)); own.items.push(_225); - rt.vecCloneFrom(own, v, 1280, copy$array_u64); + rs.vecCloneFrom(own, v, 1280, copy$array_u64); v = own; } else if (_39 === 29) { - const other: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1280); - const _236: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.iterExtend(other, _236, undefined, 1280, true); - rt.vecAppend(v, other, 1280); - sized(out, other.items.length, rt.vecCapacity(other, 1280)); + const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280); + const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _236, undefined, 1280, true); + rs.vecAppend(v, other, 1280); + sized(out, other.items.length, rs.vecCapacity(other, 1280)); } else if (_39 === 30 || _39 === 31) { b8: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b8; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 41) === 30) { - rt.vecResize(v, newLen, copy$array_u64(make(arg)), 1280, copy$array_u64); + if (rs.u8Rem(op, 41) === 30) { + rs.vecResize(v, newLen, copy$array_u64(make(arg)), 1280, copy$array_u64); } else { - rt.vecResizeWith(v, newLen, (): rt.u64[] => { + rs.vecResizeWith(v, newLen, (): rs.u64[] => { return make(arg); }, 1280); } } else if (_39 === 32) { - const tail: rt.Vec = rt.vecSplitOff(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1))); - sized(out, tail.items.length, rt.vecCapacity(tail, 1280)); + const tail: rs.Vec = rs.vecSplitOff(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1))); + sized(out, tail.items.length, rs.vecCapacity(tail, 1280)); } else if (_39 === 33) { - rt.vecExtendFromWithin(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 1280, copy$array_u64); + rs.vecExtendFromWithin(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 1280, copy$array_u64); } else if (_39 === 34) { - v = rt.dequeToVec(rt.dequeFromVec(v, 1280) as rt.VecDeque); + v = rs.dequeToVec(rs.dequeFromVec(v, 1280) as rs.VecDeque); } else if (_39 === 35) { - const len: rt.usize = v.items.length; - const start: rt.usize = rt.usizeRem((arg & 3) as rt.usize, rt.usizeAdd(len, 1)); + const len: rs.usize = v.items.length; + const start: rs.usize = rs.usizeRem((arg & 3) as rs.usize, rs.usizeAdd(len, 1)); if ((arg & 128) === 0) { - end = rt.usizeAdd(start, rt.usizeRem(((arg >> 2) & 1) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))); + end = rs.usizeAdd(start, rs.usizeRem(((arg >> 2) & 1) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))); } else { end = len; } - const _323: rt.usize = ((arg >> 5) & 3) as rt.usize; + const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; if (!(_323 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); } - const n: rt.usize = [0, 2, 6, 17][_323]; - const _329: rt.u8 = (arg >> 3) & 3; + const n: rs.usize = [0, 2, 6, 17][_323]; + const _329: rs.u8 = (arg >> 3) & 3; if (_329 === 0) { - const _334: rt.Vec = v; - const _335: rt.Range = new rt.Range(start, end); - const _337: rt.Iter = rt.iterMap(new rt.Range(0, n & 0xff), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_334, _335, 1280), _337, true)); + const _334: rs.Vec = v; + const _335: rs.Range = new rs.Range(start, end); + const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 1280), _337, true)); } else if (_329 === 1) { - const _341: rt.Vec = v; - const _342: rt.Range = new rt.Range(start, end); - const _344: rt.Iter = rt.iterMap(rt.iterFilter(new rt.Range(0, n & 0xff), (i3: rt.u8): boolean => { - return rt.u8Rem(i3, 4) !== 1; + const _341: rs.Vec = v; + const _342: rs.Range = new rs.Range(start, end); + const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + return rs.u8Rem(i3, 4) !== 1; }), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_341, _342, 1280), _344)); + rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 1280), _344)); } else if (_329 === 2) { - const _349: rt.Vec = v; - const _350: rt.Range = new rt.Range(start, end); - const _352: rt.Iter = rt.iterMap(rt.iterChain(new rt.Range(0, n & 0xff), rt.iterFilter(new rt.Range(0, n & 0xff), (i2: rt.u8): boolean => { - return rt.u8Rem(i2, 2) === 0; + const _349: rs.Vec = v; + const _350: rs.Range = new rs.Range(start, end); + const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + return rs.u8Rem(i2, 2) === 0; })), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_349, _350, 1280), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 1280), _352)); } else { - const _360: rt.Vec = v; - const _361: rt.Range = new rt.Range(start, end); - const _363: rt.Vec = rt.vecFromElem(copy$array_u64(make(arg)), n, copy$array_u64); - rt.drop(rt.spliceFrom(rt.vecSplice(_360, _361, 1280), rt.vecIntoIter(_363), true)); + const _360: rs.Vec = v; + const _361: rs.Range = new rs.Range(start, end); + const _363: rs.Vec = rs.vecFromElem(copy$array_u64(make(arg)), n, copy$array_u64); + rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 1280), rs.vecIntoIter(_363), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rt.ownedCount(rt.iterTake(rt.vecExtractIf(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), (_23: rt.u64[]): boolean => { + rs.ownedCount(rs.iterTake(rs.vecExtractIf(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), (_23: rs.u64[]): boolean => { return keep3(); - }), rt.u8Rem(arg, 5) as rt.usize)); + }), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { - const pairs: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2560); - const iter4: rt.Iter = rt.sliceChunksExact(v.items, 2); + const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2560); + const iter4: rs.Iter = rs.sliceChunksExact(v.items, 2); while (true) { - const _392: rt.u64[][] | rt.Done = iter4.next(); - if (_392 === rt.DONE) { + const _392: rs.u64[][] | rs.Done = iter4.next(); + if (_392 === rs.DONE) { break; } - rt.idx(_392, 0); - const _399: rt.u64[] = copy$array_u64(copy$array_u64(_392[0])); - rt.idx(_392, 1); - const _398: rt.u64[][] = [_399, copy$array_u64(copy$array_u64(_392[1]))]; + rs.idx(_392, 0); + const _399: rs.u64[] = copy$array_u64(copy$array_u64(_392[0])); + rs.idx(_392, 1); + const _398: rs.u64[][] = [_399, copy$array_u64(copy$array_u64(_392[1]))]; pairs.items.push(_398); } - const flat: rt.Vec = rt.vecIntoFlattened(pairs, 2, 1280); - sized(out, flat.items.length, rt.vecCapacity(flat, 1280)); + const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 1280); + sized(out, flat.items.length, rs.vecCapacity(flat, 1280)); } else if (_39 === 38) { - rt.spliceFrom(rt.vecSplice(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 1280), rt.iterSlice([]), true); + rs.spliceFrom(rs.vecSplice(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 1280), rs.iterSlice([]), true); } else if (_39 === 39 || _39 === 40) { - const additional2: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 39) { - tried = rt.vecTryReserve(v, additional2, 1280); + const additional2: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 39) { + tried = rs.vecTryReserve(v, additional2, 1280); } else { - tried = rt.vecTryReserveExact(v, additional2, 1280); + tried = rs.vecTryReserveExact(v, additional2, 1280); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, v.items.length, rt.vecCapacity(v, 1280)); + sized(out, v.items.length, rs.vecCapacity(v, 1280)); } } -export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { - let v!: rt.Vec<[rt.u64, rt.u8]>; - let _132!: rt.u8; - let newLen!: rt.usize; - let end!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 16; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function vecSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => [rs.u64, rs.u8], out: rs.ByteVec): void { + let v!: rs.Vec<[rs.u64, rs.u8]>; + let _132!: rs.u8; + let newLen!: rs.usize; + let end!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 16; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - v = rt.vecWithCapacity(first >> 3 as rt.usize, 16); + v = rs.vecWithCapacity(first >> 3 as rs.usize, 16); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - put(out, rt.vecCapacity(v, 16)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(v, 16)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 41); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 41); if (_39 === 0 || _39 === 1) { - const _41: rt.Vec<[rt.u64, rt.u8]> = v; - const _42: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + const _41: rs.Vec<[rs.u64, rs.u8]> = v; + const _42: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); _41.items.push(_42); } else if (_39 === 2) { - rt.vecPop(v); + rs.vecPop(v); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 3) { - rt.vecReserve(v, additional, 16); + const additional: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 3) { + rs.vecReserve(v, additional, 16); } else { - rt.vecReserveExact(v, additional, 16); + rs.vecReserveExact(v, additional, 16); } } else if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 16); + rs.vecShrinkTo(v, rs.u8Rem(arg, 40) as rs.usize, 16); } else if (_39 === 6) { - rt.vecShrinkTo(v, 0, 16); + rs.vecShrinkTo(v, 0, 16); } else if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + rs.vecTruncate(v, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), copy$tuple2_u64_u8(make(arg))); + rs.vecInsert(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), copy$tuple2_u64_u8(make(arg))); } else if (_39 === 9) { if (!(v.items.length === 0)) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 10) { - rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i4: rt.u8): boolean => { - return rt.u8Rem(i4, 3) !== 0; + rs.iterExtend(v, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i4: rs.u8): boolean => { + return rs.u8Rem(i4, 3) !== 0; }), make), "next", 16); } else if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 16, true); + rs.iterExtend(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, 16, true); } else if (_39 === 12) { - rt.vecExtendFromSlice(v, rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 24) as rt.usize, copy$tuple2_u64_u8).items, 16, copy$tuple2_u64_u8); + rs.vecExtendFromSlice(v, rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), rs.u8Rem(arg, 24) as rs.usize, copy$tuple2_u64_u8).items, 16, copy$tuple2_u64_u8); } else if (_39 === 13) { - rt.vecTruncate(v, 0); + rs.vecTruncate(v, 0); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: [rt.u64, rt.u8]): boolean => { + rs.vecRetain(v, (_28: [rs.u64, rs.u8]): boolean => { return keep(); }); } else if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.items.length, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.vecDrain(v, { end: rs.min(v.items.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { - v = rt.vecFrom(v.items.map(copy$tuple2_u64_u8)); + v = rs.vecFrom(v.items.map(copy$tuple2_u64_u8)); } else if (_39 === 17) { - v = rt.vecFrom(v.items); + v = rs.vecFrom(v.items); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_27: [rt.u64, rt.u8]): boolean => { + v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_27: [rs.u64, rs.u8]): boolean => { return keep2(); }), "next", 16, false, 16); } else if (_39 === 19) { - const it: rt.Iter<[rt.u64, rt.u8]> = rt.vecIntoIter(v); - const _129: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _129; + const it: rs.Iter<[rs.u64, rs.u8]> = rs.vecIntoIter(v); + const _129: rs.u8 = rs.u8Rem(arg, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _129; while ((_132 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_132, 3) === 2)) { - rt.iterToOption(it.next()); + if (!(rs.u8Rem(_132, 3) === 2)) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } - v = rt.iterToVec(it, "next", 16, true, 16); + v = rs.iterToVec(it, "next", 16, true, 16); } else if (_39 === 20) { - let taken: rt.Vec<[rt.u64, rt.u8]> = rt.replaceIn(v, new rt.Vec()); - const _149: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + let taken: rs.Vec<[rs.u64, rs.u8]> = rs.replaceIn(v, new rs.Vec()); + const _149: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); taken.items.push(_149); - sized(out, taken.items.length, rt.vecCapacity(taken, 16)); - const _157: rt.Vec<[rt.u64, rt.u8]> = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 16); + sized(out, taken.items.length, rs.vecCapacity(taken, 16)); + const _157: rs.Vec<[rs.u64, rs.u8]> = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 16); const old = taken; taken = _157; v = old; - sized(out, taken.items.length, rt.vecCapacity(taken, 16)); + sized(out, taken.items.length, rs.vecCapacity(taken, 16)); } else if (_39 === 21) { if (!(v.items.length === 0)) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecSwapRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 22) { - rt.vecDedupBy(v, rt.eqTuple([rt.u64Eq, rt.same])); + rs.vecDedupBy(v, rs.eqTuple([rs.u64Eq, rs.same])); } else if (_39 === 23) { - const it2: rt.Iter<[rt.u64, rt.u8]> = rt.vecIntoIter(v); - const _180: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _180; + const it2: rs.Iter<[rs.u64, rs.u8]> = rs.vecIntoIter(v); + const _180: rs.u8 = rs.u8Rem(arg, 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _180; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); + rs.iterToOption(it2.next()); } - v = rt.iterToVec(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true, 16); - const rest: rt.Vec<[rt.u64, rt.u8]> = rt.iterToVec(it2, "next", 16, true, 16); - sized(out, rest.items.length, rt.vecCapacity(rest, 16)); + v = rs.iterToVec(it2.clone({ v: copy$tuple2_u64_u8 }), "next", 16, true, 16); + const rest: rs.Vec<[rs.u64, rs.u8]> = rs.iterToVec(it2, "next", 16, true, 16); + sized(out, rest.items.length, rs.vecCapacity(rest, 16)); } else if (_39 === 24) { - v = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), rt.u8Rem(arg, 6) as rt.usize, copy$tuple2_u64_u8); + v = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), rs.u8Rem(arg, 6) as rs.usize, copy$tuple2_u64_u8); } else if (_39 === 25) { - rt.vecPopIf(v, (_26: [rt.u64, rt.u8]): boolean => { - return rt.u8Rem(arg, 2) === 1; + rs.vecPopIf(v, (_26: [rs.u64, rs.u8]): boolean => { + return rs.u8Rem(arg, 2) === 1; }); } else if (_39 === 26) { - v = rt.slicesJoin([rt.vecFrom(v.items.map(copy$tuple2_u64_u8)), v], 16, undefined, rt.asSlice, copy$tuple2_u64_u8); + v = rs.slicesJoin([rs.vecFrom(v.items.map(copy$tuple2_u64_u8)), v], 16, undefined, rs.asSlice, copy$tuple2_u64_u8); } else if (_39 === 27) { - v = rt.iterToVec(rt.iterSlice(v.items), "next", 16, true, 16); + v = rs.iterToVec(rs.iterSlice(v.items), "next", 16, true, 16); } else if (_39 === 28) { - const own: rt.Vec<[rt.u64, rt.u8]> = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 16); - const _225: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); + const own: rs.Vec<[rs.u64, rs.u8]> = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 16); + const _225: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); own.items.push(_225); - rt.vecCloneFrom(own, v, 16, copy$tuple2_u64_u8); + rs.vecCloneFrom(own, v, 16, copy$tuple2_u64_u8); v = own; } else if (_39 === 29) { - const other: rt.Vec<[rt.u64, rt.u8]> = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 16); - const _236: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.iterExtend(other, _236, undefined, 16, true); - rt.vecAppend(v, other, 16); - sized(out, other.items.length, rt.vecCapacity(other, 16)); + const other: rs.Vec<[rs.u64, rs.u8]> = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 16); + const _236: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _236, undefined, 16, true); + rs.vecAppend(v, other, 16); + sized(out, other.items.length, rs.vecCapacity(other, 16)); } else if (_39 === 30 || _39 === 31) { b8: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b8; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 41) === 30) { - rt.vecResize(v, newLen, copy$tuple2_u64_u8(make(arg)), 16, copy$tuple2_u64_u8); + if (rs.u8Rem(op, 41) === 30) { + rs.vecResize(v, newLen, copy$tuple2_u64_u8(make(arg)), 16, copy$tuple2_u64_u8); } else { - rt.vecResizeWith(v, newLen, (): [rt.u64, rt.u8] => { + rs.vecResizeWith(v, newLen, (): [rs.u64, rs.u8] => { return make(arg); }, 16); } } else if (_39 === 32) { - const tail: rt.Vec<[rt.u64, rt.u8]> = rt.vecSplitOff(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1))); - sized(out, tail.items.length, rt.vecCapacity(tail, 16)); + const tail: rs.Vec<[rs.u64, rs.u8]> = rs.vecSplitOff(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1))); + sized(out, tail.items.length, rs.vecCapacity(tail, 16)); } else if (_39 === 33) { - rt.vecExtendFromWithin(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 16, copy$tuple2_u64_u8); + rs.vecExtendFromWithin(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 16, copy$tuple2_u64_u8); } else if (_39 === 34) { - v = rt.dequeToVec(rt.dequeFromVec(v, 16) as rt.VecDeque<[rt.u64, rt.u8]>); + v = rs.dequeToVec(rs.dequeFromVec(v, 16) as rs.VecDeque<[rs.u64, rs.u8]>); } else if (_39 === 35) { - const len: rt.usize = v.items.length; - const start: rt.usize = rt.usizeRem((arg & 3) as rt.usize, rt.usizeAdd(len, 1)); + const len: rs.usize = v.items.length; + const start: rs.usize = rs.usizeRem((arg & 3) as rs.usize, rs.usizeAdd(len, 1)); if ((arg & 128) === 0) { - end = rt.usizeAdd(start, rt.usizeRem(((arg >> 2) & 1) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))); + end = rs.usizeAdd(start, rs.usizeRem(((arg >> 2) & 1) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))); } else { end = len; } - const _323: rt.usize = ((arg >> 5) & 3) as rt.usize; + const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; if (!(_323 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); } - const n: rt.usize = [0, 2, 6, 17][_323]; - const _329: rt.u8 = (arg >> 3) & 3; + const n: rs.usize = [0, 2, 6, 17][_323]; + const _329: rs.u8 = (arg >> 3) & 3; if (_329 === 0) { - const _334: rt.Vec<[rt.u64, rt.u8]> = v; - const _335: rt.Range = new rt.Range(start, end); - const _337: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(new rt.Range(0, n & 0xff), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_334, _335, 16), _337, true)); + const _334: rs.Vec<[rs.u64, rs.u8]> = v; + const _335: rs.Range = new rs.Range(start, end); + const _337: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 16), _337, true)); } else if (_329 === 1) { - const _341: rt.Vec<[rt.u64, rt.u8]> = v; - const _342: rt.Range = new rt.Range(start, end); - const _344: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(rt.iterFilter(new rt.Range(0, n & 0xff), (i3: rt.u8): boolean => { - return rt.u8Rem(i3, 4) !== 1; + const _341: rs.Vec<[rs.u64, rs.u8]> = v; + const _342: rs.Range = new rs.Range(start, end); + const _344: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + return rs.u8Rem(i3, 4) !== 1; }), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_341, _342, 16), _344)); + rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 16), _344)); } else if (_329 === 2) { - const _349: rt.Vec<[rt.u64, rt.u8]> = v; - const _350: rt.Range = new rt.Range(start, end); - const _352: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(rt.iterChain(new rt.Range(0, n & 0xff), rt.iterFilter(new rt.Range(0, n & 0xff), (i2: rt.u8): boolean => { - return rt.u8Rem(i2, 2) === 0; + const _349: rs.Vec<[rs.u64, rs.u8]> = v; + const _350: rs.Range = new rs.Range(start, end); + const _352: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + return rs.u8Rem(i2, 2) === 0; })), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_349, _350, 16), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 16), _352)); } else { - const _360: rt.Vec<[rt.u64, rt.u8]> = v; - const _361: rt.Range = new rt.Range(start, end); - const _363: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(copy$tuple2_u64_u8(make(arg)), n, copy$tuple2_u64_u8); - rt.drop(rt.spliceFrom(rt.vecSplice(_360, _361, 16), rt.vecIntoIter(_363), true)); + const _360: rs.Vec<[rs.u64, rs.u8]> = v; + const _361: rs.Range = new rs.Range(start, end); + const _363: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(copy$tuple2_u64_u8(make(arg)), n, copy$tuple2_u64_u8); + rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 16), rs.vecIntoIter(_363), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rt.ownedCount(rt.iterTake(rt.vecExtractIf(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), (_23: [rt.u64, rt.u8]): boolean => { + rs.ownedCount(rs.iterTake(rs.vecExtractIf(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), (_23: [rs.u64, rs.u8]): boolean => { return keep3(); - }), rt.u8Rem(arg, 5) as rt.usize)); + }), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { - const pairs: rt.Vec<[rt.u64, rt.u8][]> = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 32); - const iter4: rt.Iter<[rt.u64, rt.u8][]> = rt.sliceChunksExact(v.items, 2); + const pairs: rs.Vec<[rs.u64, rs.u8][]> = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 32); + const iter4: rs.Iter<[rs.u64, rs.u8][]> = rs.sliceChunksExact(v.items, 2); while (true) { - const _392: [rt.u64, rt.u8][] | rt.Done = iter4.next(); - if (_392 === rt.DONE) { + const _392: [rs.u64, rs.u8][] | rs.Done = iter4.next(); + if (_392 === rs.DONE) { break; } - rt.idx(_392, 0); - const _399: [rt.u64, rt.u8] = copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392[0])); - rt.idx(_392, 1); - const _398: [rt.u64, rt.u8][] = [_399, copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392[1]))]; + rs.idx(_392, 0); + const _399: [rs.u64, rs.u8] = copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392[0])); + rs.idx(_392, 1); + const _398: [rs.u64, rs.u8][] = [_399, copy$tuple2_u64_u8(copy$tuple2_u64_u8(_392[1]))]; pairs.items.push(_398); } - const flat: rt.Vec<[rt.u64, rt.u8]> = rt.vecIntoFlattened(pairs, 2, 16); - sized(out, flat.items.length, rt.vecCapacity(flat, 16)); + const flat: rs.Vec<[rs.u64, rs.u8]> = rs.vecIntoFlattened(pairs, 2, 16); + sized(out, flat.items.length, rs.vecCapacity(flat, 16)); } else if (_39 === 38) { - rt.spliceFrom(rt.vecSplice(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 16), rt.iterSlice([]), true); + rs.spliceFrom(rs.vecSplice(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 16), rs.iterSlice([]), true); } else if (_39 === 39 || _39 === 40) { - const additional2: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 39) { - tried = rt.vecTryReserve(v, additional2, 16); + const additional2: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 39) { + tried = rs.vecTryReserve(v, additional2, 16); } else { - tried = rt.vecTryReserveExact(v, additional2, 16); + tried = rs.vecTryReserveExact(v, additional2, 16); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, v.items.length, rt.vecCapacity(v, 16)); + sized(out, v.items.length, rs.vecCapacity(v, 16)); } } -export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { - let v!: rt.Vec; - let _132!: rt.u8; - let newLen!: rt.usize; - let end!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 2; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function vecSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u16, out: rs.ByteVec): void { + let v!: rs.Vec; + let _132!: rs.u8; + let newLen!: rs.usize; + let end!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 2; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - v = rt.vecWithCapacity(first >> 3 as rt.usize, 2); + v = rs.vecWithCapacity(first >> 3 as rs.usize, 2); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - put(out, rt.vecCapacity(v, 2)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(v, 2)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 41); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 41); if (_39 === 0 || _39 === 1) { - const _41: rt.Vec = v; - const _42: rt.u16 = make(arg); + const _41: rs.Vec = v; + const _42: rs.u16 = make(arg); _41.items.push(_42); } else if (_39 === 2) { - rt.vecPop(v); + rs.vecPop(v); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 3) { - rt.vecReserve(v, additional, 2); + const additional: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 3) { + rs.vecReserve(v, additional, 2); } else { - rt.vecReserveExact(v, additional, 2); + rs.vecReserveExact(v, additional, 2); } } else if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 2); + rs.vecShrinkTo(v, rs.u8Rem(arg, 40) as rs.usize, 2); } else if (_39 === 6) { - rt.vecShrinkTo(v, 0, 2); + rs.vecShrinkTo(v, 0, 2); } else if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + rs.vecTruncate(v, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.vecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), make(arg)); + rs.vecInsert(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), make(arg)); } else if (_39 === 9) { if (!(v.items.length === 0)) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 10) { - rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i4: rt.u8): boolean => { - return rt.u8Rem(i4, 3) !== 0; + rs.iterExtend(v, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i4: rs.u8): boolean => { + return rs.u8Rem(i4, 3) !== 0; }), make), "next", 2); } else if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 2, true); + rs.iterExtend(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, 2, true); } else if (_39 === 12) { - rt.vecExtendFromSlice(v, rt.vecFromElem(make(arg), rt.u8Rem(arg, 24) as rt.usize, undefined).items, 2); + rs.vecExtendFromSlice(v, rs.vecFromElem(make(arg), rs.u8Rem(arg, 24) as rs.usize, undefined).items, 2); } else if (_39 === 13) { - rt.vecTruncate(v, 0); + rs.vecTruncate(v, 0); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: rt.u16): boolean => { + rs.vecRetain(v, (_28: rs.u16): boolean => { return keep(); }); } else if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.items.length, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.vecDrain(v, { end: rs.min(v.items.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { - v = rt.vecFrom(v.items.slice()); + v = rs.vecFrom(v.items.slice()); } else if (_39 === 17) { - v = rt.vecFrom(v.items); + v = rs.vecFrom(v.items); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_27: rt.u16): boolean => { + v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_27: rs.u16): boolean => { return keep2(); }), "next", 2, false, 2); } else if (_39 === 19) { - const it: rt.Iter = rt.vecIntoIter(v); - const _129: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _129; + const it: rs.Iter = rs.vecIntoIter(v); + const _129: rs.u8 = rs.u8Rem(arg, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _129; while ((_132 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_132, 3) === 2)) { - rt.iterToOption(it.next()); + if (!(rs.u8Rem(_132, 3) === 2)) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } - v = rt.iterToVec(it, "next", 2, true, 2); + v = rs.iterToVec(it, "next", 2, true, 2); } else if (_39 === 20) { - let taken: rt.Vec = rt.replaceIn(v, new rt.Vec()); - const _149: rt.u16 = make(arg); + let taken: rs.Vec = rs.replaceIn(v, new rs.Vec()); + const _149: rs.u16 = make(arg); taken.items.push(_149); - sized(out, taken.items.length, rt.vecCapacity(taken, 2)); - const _157: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); + sized(out, taken.items.length, rs.vecCapacity(taken, 2)); + const _157: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2); const old = taken; taken = _157; v = old; - sized(out, taken.items.length, rt.vecCapacity(taken, 2)); + sized(out, taken.items.length, rs.vecCapacity(taken, 2)); } else if (_39 === 21) { if (!(v.items.length === 0)) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecSwapRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 22) { - rt.vecDedupBy(v, rt.same); + rs.vecDedupBy(v, rs.same); } else if (_39 === 23) { - const it2: rt.Iter = rt.vecIntoIter(v); - const _180: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _180; + const it2: rs.Iter = rs.vecIntoIter(v); + const _180: rs.u8 = rs.u8Rem(arg, 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _180; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); + rs.iterToOption(it2.next()); } - v = rt.iterToVec(it2.clone({ v: rt.itself }), "next", 2, true, 2); - const rest: rt.Vec = rt.iterToVec(it2, "next", 2, true, 2); - sized(out, rest.items.length, rt.vecCapacity(rest, 2)); + v = rs.iterToVec(it2.clone({ v: rs.itself }), "next", 2, true, 2); + const rest: rs.Vec = rs.iterToVec(it2, "next", 2, true, 2); + sized(out, rest.items.length, rs.vecCapacity(rest, 2)); } else if (_39 === 24) { - v = rt.vecFromElem(make(arg), rt.u8Rem(arg, 6) as rt.usize, undefined); + v = rs.vecFromElem(make(arg), rs.u8Rem(arg, 6) as rs.usize, undefined); } else if (_39 === 25) { - rt.vecPopIfMut(v, (_26: rt.Place): boolean => { - return rt.u8Rem(arg, 2) === 1; + rs.vecPopIfMut(v, (_26: rs.Place): boolean => { + return rs.u8Rem(arg, 2) === 1; }); } else if (_39 === 26) { - v = rt.slicesJoin([rt.vecFrom(v.items.slice()), v], 2, undefined, rt.asSlice); + v = rs.slicesJoin([rs.vecFrom(v.items.slice()), v], 2, undefined, rs.asSlice); } else if (_39 === 27) { - v = rt.iterToVec(rt.iterSlice(v.items), "next", 2, true, 2); + v = rs.iterToVec(rs.iterSlice(v.items), "next", 2, true, 2); } else if (_39 === 28) { - const own: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 2); - const _225: rt.u16 = make(arg); + const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 2); + const _225: rs.u16 = make(arg); own.items.push(_225); - rt.vecCloneFrom(own, v, 2); + rs.vecCloneFrom(own, v, 2); v = own; } else if (_39 === 29) { - const other: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 2); - const _236: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.iterExtend(other, _236, undefined, 2, true); - rt.vecAppend(v, other, 2); - sized(out, other.items.length, rt.vecCapacity(other, 2)); + const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 2); + const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _236, undefined, 2, true); + rs.vecAppend(v, other, 2); + sized(out, other.items.length, rs.vecCapacity(other, 2)); } else if (_39 === 30 || _39 === 31) { b8: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b8; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 41) === 30) { - rt.vecResize(v, newLen, make(arg), 2, undefined); + if (rs.u8Rem(op, 41) === 30) { + rs.vecResize(v, newLen, make(arg), 2, undefined); } else { - rt.vecResizeWith(v, newLen, (): rt.u16 => { + rs.vecResizeWith(v, newLen, (): rs.u16 => { return make(arg); }, 2); } } else if (_39 === 32) { - const tail: rt.Vec = rt.vecSplitOff(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1))); - sized(out, tail.items.length, rt.vecCapacity(tail, 2)); + const tail: rs.Vec = rs.vecSplitOff(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1))); + sized(out, tail.items.length, rs.vecCapacity(tail, 2)); } else if (_39 === 33) { - rt.vecExtendFromWithin(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 2, undefined); + rs.vecExtendFromWithin(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 2, undefined); } else if (_39 === 34) { - v = rt.dequeToVec(rt.dequeFromVec(v, 2) as rt.VecDeque); + v = rs.dequeToVec(rs.dequeFromVec(v, 2) as rs.VecDeque); } else if (_39 === 35) { - const len: rt.usize = v.items.length; - const start: rt.usize = rt.usizeRem((arg & 3) as rt.usize, rt.usizeAdd(len, 1)); + const len: rs.usize = v.items.length; + const start: rs.usize = rs.usizeRem((arg & 3) as rs.usize, rs.usizeAdd(len, 1)); if ((arg & 128) === 0) { - end = rt.usizeAdd(start, rt.usizeRem(((arg >> 2) & 1) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))); + end = rs.usizeAdd(start, rs.usizeRem(((arg >> 2) & 1) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))); } else { end = len; } - const _323: rt.usize = ((arg >> 5) & 3) as rt.usize; + const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; if (!(_323 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); } - const n: rt.usize = [0, 2, 6, 17][_323]; - const _329: rt.u8 = (arg >> 3) & 3; + const n: rs.usize = [0, 2, 6, 17][_323]; + const _329: rs.u8 = (arg >> 3) & 3; if (_329 === 0) { - const _334: rt.Vec = v; - const _335: rt.Range = new rt.Range(start, end); - const _337: rt.Iter = rt.iterMap(new rt.Range(0, n & 0xff), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_334, _335, 2), _337, true)); + const _334: rs.Vec = v; + const _335: rs.Range = new rs.Range(start, end); + const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 2), _337, true)); } else if (_329 === 1) { - const _341: rt.Vec = v; - const _342: rt.Range = new rt.Range(start, end); - const _344: rt.Iter = rt.iterMap(rt.iterFilter(new rt.Range(0, n & 0xff), (i3: rt.u8): boolean => { - return rt.u8Rem(i3, 4) !== 1; + const _341: rs.Vec = v; + const _342: rs.Range = new rs.Range(start, end); + const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + return rs.u8Rem(i3, 4) !== 1; }), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_341, _342, 2), _344)); + rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 2), _344)); } else if (_329 === 2) { - const _349: rt.Vec = v; - const _350: rt.Range = new rt.Range(start, end); - const _352: rt.Iter = rt.iterMap(rt.iterChain(new rt.Range(0, n & 0xff), rt.iterFilter(new rt.Range(0, n & 0xff), (i2: rt.u8): boolean => { - return rt.u8Rem(i2, 2) === 0; + const _349: rs.Vec = v; + const _350: rs.Range = new rs.Range(start, end); + const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + return rs.u8Rem(i2, 2) === 0; })), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_349, _350, 2), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 2), _352)); } else { - const _360: rt.Vec = v; - const _361: rt.Range = new rt.Range(start, end); - const _363: rt.Vec = rt.vecFromElem(make(arg), n, undefined); - rt.drop(rt.spliceFrom(rt.vecSplice(_360, _361, 2), rt.vecIntoIter(_363), true)); + const _360: rs.Vec = v; + const _361: rs.Range = new rs.Range(start, end); + const _363: rs.Vec = rs.vecFromElem(make(arg), n, undefined); + rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 2), rs.vecIntoIter(_363), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rt.ownedCount(rt.iterTake(rt.vecExtractIfMut(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), (_23: rt.Place): boolean => { + rs.ownedCount(rs.iterTake(rs.vecExtractIfMut(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), (_23: rs.Place): boolean => { return keep3(); - }), rt.u8Rem(arg, 5) as rt.usize)); + }), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { - const pairs: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 4); - const iter4: rt.Iter = rt.sliceChunksExact(v.items, 2); + const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 4); + const iter4: rs.Iter = rs.sliceChunksExact(v.items, 2); while (true) { - const _392: rt.u16[] | rt.Done = iter4.next(); - if (_392 === rt.DONE) { + const _392: rs.u16[] | rs.Done = iter4.next(); + if (_392 === rs.DONE) { break; } - rt.idx(_392, 0); - const _399: rt.u16 = _392[0]; - rt.idx(_392, 1); - const _398: rt.u16[] = [_399, _392[1]]; + rs.idx(_392, 0); + const _399: rs.u16 = _392[0]; + rs.idx(_392, 1); + const _398: rs.u16[] = [_399, _392[1]]; pairs.items.push(_398); } - const flat: rt.Vec = rt.vecIntoFlattened(pairs, 2, 2); - sized(out, flat.items.length, rt.vecCapacity(flat, 2)); + const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 2); + sized(out, flat.items.length, rs.vecCapacity(flat, 2)); } else if (_39 === 38) { - rt.spliceFrom(rt.vecSplice(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 2), rt.iterSlice([]), true); + rs.spliceFrom(rs.vecSplice(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 2), rs.iterSlice([]), true); } else if (_39 === 39 || _39 === 40) { - const additional2: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 39) { - tried = rt.vecTryReserve(v, additional2, 2); + const additional2: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 39) { + tried = rs.vecTryReserve(v, additional2, 2); } else { - tried = rt.vecTryReserveExact(v, additional2, 2); + tried = rs.vecTryReserveExact(v, additional2, 2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, v.items.length, rt.vecCapacity(v, 2)); + sized(out, v.items.length, rs.vecCapacity(v, 2)); } } -export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let v!: rt.ByteVec; - let _132!: rt.u8; - let newLen!: rt.usize; - let end!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 1; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function vecSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let v!: rs.ByteVec; + let _132!: rs.u8; + let newLen!: rs.usize; + let end!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 1; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - v = rt.byteVecWithCapacity(first >> 3 as rt.usize); + v = rs.byteVecWithCapacity(first >> 3 as rs.usize); } else { - v = new rt.ByteVec(); + v = new rs.ByteVec(); } put(out, v.data.length); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 41); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 41); if (_39 === 0 || _39 === 1) { - rt.byteVecPush(v, make(arg)); + rs.byteVecPush(v, make(arg)); } else if (_39 === 2) { - rt.byteVecPop(v); + rs.byteVecPop(v); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 41) === 3) { - rt.byteVecReserve(v, additional); + const additional: rs.usize = amount(arg, v.length, size); + if (rs.u8Rem(op, 41) === 3) { + rs.byteVecReserve(v, additional); } else { - rt.byteVecReserveExact(v, additional); + rs.byteVecReserveExact(v, additional); } } else if (_39 === 5) { - rt.byteVecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize); + rs.byteVecShrinkTo(v, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.byteVecShrinkTo(v, 0); + rs.byteVecShrinkTo(v, 0); } else if (_39 === 7) { - rt.byteVecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + rs.byteVecTruncate(v, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.byteVecInsert(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), make(arg)); + rs.byteVecInsert(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.length, 1)), make(arg)); } else if (_39 === 9) { if (!(v.length === 0)) { - rt.byteVecRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + rs.byteVecRemove(v, rs.usizeRem(arg as rs.usize, v.length)); } } else if (_39 === 10) { - rt.iterExtendBytes(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i4: rt.u8): boolean => { - return rt.u8Rem(i4, 3) !== 0; + rs.iterExtendBytes(v, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i4: rs.u8): boolean => { + return rs.u8Rem(i4, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.iterExtendBytes(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.iterExtendBytes(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.byteVecExtendFromSlice(v, rt.byteVecSlice(rt.byteVecOf(make(arg), rt.u8Rem(arg, 24) as rt.usize))); + rs.byteVecExtendFromSlice(v, rs.byteVecSlice(rs.byteVecOf(make(arg), rs.u8Rem(arg, 24) as rs.usize))); } else if (_39 === 13) { - rt.byteVecClear(v); + rs.byteVecClear(v); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rt.byteVecRetain(v, (_28: rt.u8): boolean => { + rs.byteVecRetain(v, (_28: rs.u8): boolean => { return keep(); }); } else if (_39 === 15) { - rt.drop(rt.byteVecDrain(v, { end: rt.min(v.length, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.byteVecDrain(v, { end: rs.min(v.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { - v = rt.byteVecFrom(rt.byteVecView(v)); + v = rs.byteVecFrom(rs.byteVecView(v)); } else if (_39 === 17) { - v = rt.byteSliceToByteVec(rt.byteVecSlice(v)); + v = rs.byteSliceToByteVec(rs.byteVecSlice(v)); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(v), (_27: rt.u8): boolean => { + v = rs.iterToByteVec(rs.iterFilter(rs.byteVecIntoIter(v), (_27: rs.u8): boolean => { return keep2(); }), "next", false, 1); } else if (_39 === 19) { - const it: rt.Iter = rt.byteVecIntoIter(v); - const _129: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _129; + const it: rs.Iter = rs.byteVecIntoIter(v); + const _129: rs.u8 = rs.u8Rem(arg, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _129; while ((_132 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_132, 3) === 2)) { - rt.iterToOption(it.next()); + if (!(rs.u8Rem(_132, 3) === 2)) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } - v = rt.iterToByteVec(it, "next", true, 1); + v = rs.iterToByteVec(it, "next", true, 1); } else if (_39 === 20) { - let taken: rt.ByteVec = rt.replaceIn(v, new rt.ByteVec()); - const _149: rt.u8 = make(arg); - rt.byteVecPush(taken, _149); + let taken: rs.ByteVec = rs.replaceIn(v, new rs.ByteVec()); + const _149: rs.u8 = make(arg); + rs.byteVecPush(taken, _149); sized(out, taken.length, taken.data.length); - const _157: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 6) as rt.usize); + const _157: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(arg, 6) as rs.usize); const old = taken; taken = _157; v = old; sized(out, taken.length, taken.data.length); } else if (_39 === 21) { if (!(v.length === 0)) { - rt.byteVecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.length)); + rs.byteVecSwapRemove(v, rs.usizeRem(arg as rs.usize, v.length)); } } else if (_39 === 22) { - rt.byteVecDedup(v); + rs.byteVecDedup(v); } else if (_39 === 23) { - const it2: rt.Iter = rt.byteVecIntoIter(v); - const _180: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _180; + const it2: rs.Iter = rs.byteVecIntoIter(v); + const _180: rs.u8 = rs.u8Rem(arg, 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _180; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next()); + rs.iterToOption(it2.next()); } - v = rt.iterToByteVec(it2.clone({ v: rt.itself }), "next", true, 1); - const rest: rt.ByteVec = rt.iterToByteVec(it2, "next", true, 1); + v = rs.iterToByteVec(it2.clone({ v: rs.itself }), "next", true, 1); + const rest: rs.ByteVec = rs.iterToByteVec(it2, "next", true, 1); sized(out, rest.length, rest.data.length); } else if (_39 === 24) { - v = rt.byteVecOf(make(arg), rt.u8Rem(arg, 6) as rt.usize); + v = rs.byteVecOf(make(arg), rs.u8Rem(arg, 6) as rs.usize); } else if (_39 === 25) { - rt.byteVecPopIf(v, (_26: rt.Place): boolean => { - return rt.u8Rem(arg, 2) === 1; + rs.byteVecPopIf(v, (_26: rs.Place): boolean => { + return rs.u8Rem(arg, 2) === 1; }); } else if (_39 === 26) { - v = rt.byteSlicesJoin([rt.byteVecFrom(rt.byteVecView(v)), v], undefined, rt.byteVecSlice); + v = rs.byteSlicesJoin([rs.byteVecFrom(rs.byteVecView(v)), v], undefined, rs.byteVecSlice); } else if (_39 === 27) { - v = rt.iterToByteVec(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))), "next", true, 1); + v = rs.iterToByteVec(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), "next", true, 1); } else if (_39 === 28) { - const own: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 8) as rt.usize); - const _225: rt.u8 = make(arg); - rt.byteVecPush(own, _225); - rt.byteVecCloneFrom(own, v); + const own: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(arg, 8) as rs.usize); + const _225: rs.u8 = make(arg); + rs.byteVecPush(own, _225); + rs.byteVecCloneFrom(own, v); v = own; } else if (_39 === 29) { - const other: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(arg, 8) as rt.usize); - const _236: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.iterExtendBytes(other, _236, undefined, true); - rt.byteVecAppend(v, other); + const other: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(arg, 8) as rs.usize); + const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtendBytes(other, _236, undefined, true); + rs.byteVecAppend(v, other); sized(out, other.length, other.data.length); } else if (_39 === 30 || _39 === 31) { b8: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b8; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 41) === 30) { - rt.byteVecResize(v, newLen, make(arg)); + if (rs.u8Rem(op, 41) === 30) { + rs.byteVecResize(v, newLen, make(arg)); } else { - rt.byteVecResizeWith(v, newLen, (): rt.u8 => { + rs.byteVecResizeWith(v, newLen, (): rs.u8 => { return make(arg); }); } } else if (_39 === 32) { - const tail: rt.ByteVec = rt.byteVecSplitOff(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1))); + const tail: rs.ByteVec = rs.byteVecSplitOff(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.length, 1))); sized(out, tail.length, tail.data.length); } else if (_39 === 33) { - rt.byteVecExtendFromWithin(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), rt.usizeStep)); + rs.byteVecExtendFromWithin(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.length, 1)), rs.usizeStep)); } else if (_39 === 34) { - v = rt.byteVecFromVec(rt.dequeToVec(rt.dequeFromVec(rt.byteVecToVec(v), 1, true) as rt.VecDeque)); + v = rs.byteVecFromVec(rs.dequeToVec(rs.dequeFromVec(rs.byteVecToVec(v), 1, true) as rs.VecDeque)); } else if (_39 === 35) { - const len: rt.usize = v.length; - const start: rt.usize = rt.usizeRem((arg & 3) as rt.usize, rt.usizeAdd(len, 1)); + const len: rs.usize = v.length; + const start: rs.usize = rs.usizeRem((arg & 3) as rs.usize, rs.usizeAdd(len, 1)); if ((arg & 128) === 0) { - end = rt.usizeAdd(start, rt.usizeRem(((arg >> 2) & 1) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))); + end = rs.usizeAdd(start, rs.usizeRem(((arg >> 2) & 1) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))); } else { end = len; } - const _323: rt.usize = ((arg >> 5) & 3) as rt.usize; + const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; if (!(_323 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); } - const n: rt.usize = [0, 2, 6, 17][_323]; - const _329: rt.u8 = (arg >> 3) & 3; + const n: rs.usize = [0, 2, 6, 17][_323]; + const _329: rs.u8 = (arg >> 3) & 3; if (_329 === 0) { - const _334: rt.ByteVec = v; - const _335: rt.Range = new rt.Range(start, end); - const _337: rt.Iter = rt.iterMap(new rt.Range(0, n & 0xff), make); - rt.drop(rt.spliceFrom(rt.byteVecSplice(_334, _335), _337, true)); + const _334: rs.ByteVec = v; + const _335: rs.Range = new rs.Range(start, end); + const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_334, _335), _337, true)); } else if (_329 === 1) { - const _341: rt.ByteVec = v; - const _342: rt.Range = new rt.Range(start, end); - const _344: rt.Iter = rt.iterMap(rt.iterFilter(new rt.Range(0, n & 0xff), (i3: rt.u8): boolean => { - return rt.u8Rem(i3, 4) !== 1; + const _341: rs.ByteVec = v; + const _342: rs.Range = new rs.Range(start, end); + const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + return rs.u8Rem(i3, 4) !== 1; }), make); - rt.drop(rt.spliceFrom(rt.byteVecSplice(_341, _342), _344)); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_341, _342), _344)); } else if (_329 === 2) { - const _349: rt.ByteVec = v; - const _350: rt.Range = new rt.Range(start, end); - const _352: rt.Iter = rt.iterMap(rt.iterChain(new rt.Range(0, n & 0xff), rt.iterFilter(new rt.Range(0, n & 0xff), (i2: rt.u8): boolean => { - return rt.u8Rem(i2, 2) === 0; + const _349: rs.ByteVec = v; + const _350: rs.Range = new rs.Range(start, end); + const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + return rs.u8Rem(i2, 2) === 0; })), make); - rt.drop(rt.spliceFrom(rt.byteVecSplice(_349, _350), _352)); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_349, _350), _352)); } else { - const _360: rt.ByteVec = v; - const _361: rt.Range = new rt.Range(start, end); - const _363: rt.ByteVec = rt.byteVecOf(make(arg), n); - rt.drop(rt.spliceFrom(rt.byteVecSplice(_360, _361), rt.byteVecIntoIter(_363), true)); + const _360: rs.ByteVec = v; + const _361: rs.Range = new rs.Range(start, end); + const _363: rs.ByteVec = rs.byteVecOf(make(arg), n); + rs.drop(rs.spliceFrom(rs.byteVecSplice(_360, _361), rs.byteVecIntoIter(_363), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rt.ownedCount(rt.iterTake(rt.byteVecExtractIf(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), rt.usizeStep), (_23: rt.Place): boolean => { + rs.ownedCount(rs.iterTake(rs.byteVecExtractIf(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.length, 1)), rs.usizeStep), (_23: rs.Place): boolean => { return keep3(); - }), rt.u8Rem(arg, 5) as rt.usize)); + }), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { - const pairs: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 2); - const iter4: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(v), 2); + const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 2); + const iter4: rs.Iter = rs.byteSliceChunksExact(rs.byteVecSlice(v), 2); while (true) { - const _392: rt.ByteSlice | rt.Done = iter4.next(); - if (_392 === rt.DONE) { + const _392: rs.ByteSlice | rs.Done = iter4.next(); + if (_392 === rs.DONE) { break; } - rt.idx(_392, 0); - const _399: rt.u8 = _392.data[_392.start]; - rt.idx(_392, 1); + rs.idx(_392, 0); + const _399: rs.u8 = _392.data[_392.start]; + rs.idx(_392, 1); const _398: Uint8Array = Uint8Array.of(_399, _392.data[_392.start + 1]); pairs.items.push(_398); } - const flat: rt.ByteVec = rt.byteVecIntoFlattened(pairs, 2); + const flat: rs.ByteVec = rs.byteVecIntoFlattened(pairs, 2); sized(out, flat.length, flat.data.length); } else if (_39 === 38) { - rt.spliceFrom(rt.byteVecSplice(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.length, 1)), rt.usizeStep)), rt.iterSlice(Uint8Array.of()), true); + rs.spliceFrom(rs.byteVecSplice(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.length, 1)), rs.usizeStep)), rs.iterSlice(Uint8Array.of()), true); } else if (_39 === 39 || _39 === 40) { - const additional2: rt.usize = amount(arg, v.length, size); - if (rt.u8Rem(op, 41) === 39) { - tried = rt.byteVecTryReserve(v, additional2); + const additional2: rs.usize = amount(arg, v.length, size); + if (rs.u8Rem(op, 41) === 39) { + tried = rs.byteVecTryReserve(v, additional2); } else { - tried = rt.byteVecTryReserveExact(v, additional2); + tried = rs.byteVecTryReserveExact(v, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } sized(out, v.length, v.data.length); } } -export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { - let v!: rt.Vec; - let _132!: rt.u8; - let newLen!: rt.usize; - let end!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 0; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => undefined, out: rs.ByteVec): void { + let v!: rs.Vec; + let _132!: rs.u8; + let newLen!: rs.usize; + let end!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 0; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - v = rt.vecWithCapacity(first >> 3 as rt.usize, 0); + v = rs.vecWithCapacity(first >> 3 as rs.usize, 0); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - put(out, rt.vecCapacity(v, 0)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(v, 0)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 41); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 41); if (_39 === 0 || _39 === 1) { - const _41: rt.Vec = v; + const _41: rs.Vec = v; make(arg); _41.items.push(undefined); } else if (_39 === 2) { - rt.vecPop(v, rt.None); + rs.vecPop(v, rs.None); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 3) { - rt.vecReserve(v, additional, 0); + const additional: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 3) { + rs.vecReserve(v, additional, 0); } else { - rt.vecReserveExact(v, additional, 0); + rs.vecReserveExact(v, additional, 0); } } else if (_39 === 5) { - rt.vecShrinkTo(v, rt.u8Rem(arg, 40) as rt.usize, 0); + rs.vecShrinkTo(v, rs.u8Rem(arg, 40) as rs.usize, 0); } else if (_39 === 6) { - rt.vecShrinkTo(v, 0, 0); + rs.vecShrinkTo(v, 0, 0); } else if (_39 === 7) { - rt.vecTruncate(v, rt.u8Rem(arg, 8) as rt.usize); + rs.vecTruncate(v, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - const _61: rt.Vec = v; - const _62: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)); + const _61: rs.Vec = v; + const _62: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)); make(arg); - rt.vecInsert(_61, _62, undefined); + rs.vecInsert(_61, _62, undefined); } else if (_39 === 9) { if (!(v.items.length === 0)) { - rt.vecRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 10) { - rt.iterExtend(v, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i4: rt.u8): boolean => { - return rt.u8Rem(i4, 3) !== 0; + rs.iterExtend(v, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i4: rs.u8): boolean => { + return rs.u8Rem(i4, 3) !== 0; }), make), "next", 0); } else if (_39 === 11) { - rt.iterExtend(v, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, 0, true); + rs.iterExtend(v, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, 0, true); } else if (_39 === 12) { - const _90: rt.Vec = v; + const _90: rs.Vec = v; make(arg); - rt.vecExtendFromSlice(_90, rt.vecFromElem(undefined, rt.u8Rem(arg, 24) as rt.usize, undefined).items, 0); + rs.vecExtendFromSlice(_90, rs.vecFromElem(undefined, rs.u8Rem(arg, 24) as rs.usize, undefined).items, 0); } else if (_39 === 13) { - rt.vecTruncate(v, 0); + rs.vecTruncate(v, 0); } else if (_39 === 14) { const keep: () => boolean = alternate(); - rt.vecRetain(v, (_28: undefined): boolean => { + rs.vecRetain(v, (_28: undefined): boolean => { return keep(); }); } else if (_39 === 15) { - rt.drop(rt.vecDrain(v, { end: rt.min(v.items.length, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.vecDrain(v, { end: rs.min(v.items.length, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 16) { - v = rt.vecFrom(v.items.slice()); + v = rs.vecFrom(v.items.slice()); } else if (_39 === 17) { - v = rt.vecFrom(v.items); + v = rs.vecFrom(v.items); } else if (_39 === 18) { const keep2: () => boolean = alternate(); - v = rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_27: undefined): boolean => { + v = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_27: undefined): boolean => { return keep2(); }), "next", 0); } else if (_39 === 19) { - const it: rt.Iter = rt.vecIntoIter(v); - const _129: rt.u8 = rt.u8Rem(arg, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _129; + const it: rs.Iter = rs.vecIntoIter(v); + const _129: rs.u8 = rs.u8Rem(arg, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _129; while ((_132 = iterStart++) < iterEnd) { - if (!(rt.u8Rem(_132, 3) === 2)) { - rt.iterToOption(it.next(), rt.None); + if (!(rs.u8Rem(_132, 3) === 2)) { + rs.iterToOption(it.next(), rs.None); } else { - rt.iterToOption(it.nextBack(), rt.None); + rs.iterToOption(it.nextBack(), rs.None); } } - v = rt.iterToVec(it, undefined, 0, true); + v = rs.iterToVec(it, undefined, 0, true); } else if (_39 === 20) { - let taken: rt.Vec = rt.replaceIn(v, new rt.Vec()); + let taken: rs.Vec = rs.replaceIn(v, new rs.Vec()); make(arg); taken.items.push(undefined); - sized(out, taken.items.length, rt.vecCapacity(taken, 0)); - const _157: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); + sized(out, taken.items.length, rs.vecCapacity(taken, 0)); + const _157: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 0); const old = taken; taken = _157; v = old; - sized(out, taken.items.length, rt.vecCapacity(taken, 0)); + sized(out, taken.items.length, rs.vecCapacity(taken, 0)); } else if (_39 === 21) { if (!(v.items.length === 0)) { - rt.vecSwapRemove(v, rt.usizeRem(arg as rt.usize, v.items.length)); + rs.vecSwapRemove(v, rs.usizeRem(arg as rs.usize, v.items.length)); } } else if (_39 === 22) { - rt.vecDedupBy(v, rt.same); + rs.vecDedupBy(v, rs.same); } else if (_39 === 23) { - const it2: rt.Iter = rt.vecIntoIter(v); - const _180: rt.u8 = rt.u8Rem(arg, 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _180; + const it2: rs.Iter = rs.vecIntoIter(v); + const _180: rs.u8 = rs.u8Rem(arg, 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _180; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it2.next(), rt.None); + rs.iterToOption(it2.next(), rs.None); } - v = rt.iterToVec(it2.clone({ v: rt.itself }), undefined, 0, true); - const rest: rt.Vec = rt.iterToVec(it2, undefined, 0, true); - sized(out, rest.items.length, rt.vecCapacity(rest, 0)); + v = rs.iterToVec(it2.clone({ v: rs.itself }), undefined, 0, true); + const rest: rs.Vec = rs.iterToVec(it2, undefined, 0, true); + sized(out, rest.items.length, rs.vecCapacity(rest, 0)); } else if (_39 === 24) { make(arg); - v = rt.vecFromElem(undefined, rt.u8Rem(arg, 6) as rt.usize, undefined); + v = rs.vecFromElem(undefined, rs.u8Rem(arg, 6) as rs.usize, undefined); } else if (_39 === 25) { - rt.vecPopIfMut(v, (_26: rt.Place): boolean => { - return rt.u8Rem(arg, 2) === 1; - }, undefined, rt.None); + rs.vecPopIfMut(v, (_26: rs.Place): boolean => { + return rs.u8Rem(arg, 2) === 1; + }, undefined, rs.None); } else if (_39 === 26) { - v = rt.slicesJoin([rt.vecFrom(v.items.slice()), v], 0, undefined, rt.asSlice); + v = rs.slicesJoin([rs.vecFrom(v.items.slice()), v], 0, undefined, rs.asSlice); } else if (_39 === 27) { - v = rt.iterToVec(rt.iterSlice(v.items), undefined, 0, true); + v = rs.iterToVec(rs.iterSlice(v.items), undefined, 0, true); } else if (_39 === 28) { - const own: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 0); + const own: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 0); make(arg); own.items.push(undefined); - rt.vecCloneFrom(own, v, 0); + rs.vecCloneFrom(own, v, 0); v = own; } else if (_39 === 29) { - const other: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 0); - const _236: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.iterExtend(other, _236, undefined, 0, true); - rt.vecAppend(v, other, 0); - sized(out, other.items.length, rt.vecCapacity(other, 0)); + const other: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 0); + const _236: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.iterExtend(other, _236, undefined, 0, true); + rs.vecAppend(v, other, 0); + sized(out, other.items.length, rs.vecCapacity(other, 0)); } else if (_39 === 30 || _39 === 31) { b8: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b8; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 41) === 30) { - const _265: rt.Vec = v; + if (rs.u8Rem(op, 41) === 30) { + const _265: rs.Vec = v; make(arg); - rt.vecResize(_265, newLen, undefined, 0, undefined); + rs.vecResize(_265, newLen, undefined, 0, undefined); } else { - rt.vecResizeWith(v, newLen, (): undefined => { + rs.vecResizeWith(v, newLen, (): undefined => { make(arg); }, 0); } } else if (_39 === 32) { - const tail: rt.Vec = rt.vecSplitOff(v, rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1))); - sized(out, tail.items.length, rt.vecCapacity(tail, 0)); + const tail: rs.Vec = rs.vecSplitOff(v, rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1))); + sized(out, tail.items.length, rs.vecCapacity(tail, 0)); } else if (_39 === 33) { - rt.vecExtendFromWithin(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 0, undefined); + rs.vecExtendFromWithin(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 0, undefined); } else if (_39 === 34) { - v = rt.dequeToVec(rt.dequeFromVec(v, 0) as rt.VecDeque); + v = rs.dequeToVec(rs.dequeFromVec(v, 0) as rs.VecDeque); } else if (_39 === 35) { - const len: rt.usize = v.items.length; - const start: rt.usize = rt.usizeRem((arg & 3) as rt.usize, rt.usizeAdd(len, 1)); + const len: rs.usize = v.items.length; + const start: rs.usize = rs.usizeRem((arg & 3) as rs.usize, rs.usizeAdd(len, 1)); if ((arg & 128) === 0) { - end = rt.usizeAdd(start, rt.usizeRem(((arg >> 2) & 1) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))); + end = rs.usizeAdd(start, rs.usizeRem(((arg >> 2) & 1) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))); } else { end = len; } - const _323: rt.usize = ((arg >> 5) & 3) as rt.usize; + const _323: rs.usize = ((arg >> 5) & 3) as rs.usize; if (!(_323 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _323); } - const n: rt.usize = [0, 2, 6, 17][_323]; - const _329: rt.u8 = (arg >> 3) & 3; + const n: rs.usize = [0, 2, 6, 17][_323]; + const _329: rs.u8 = (arg >> 3) & 3; if (_329 === 0) { - const _334: rt.Vec = v; - const _335: rt.Range = new rt.Range(start, end); - const _337: rt.Iter = rt.iterMap(new rt.Range(0, n & 0xff), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_334, _335, 0), _337, true)); + const _334: rs.Vec = v; + const _335: rs.Range = new rs.Range(start, end); + const _337: rs.Iter = rs.iterMap(new rs.Range(0, n & 0xff), make); + rs.drop(rs.spliceFrom(rs.vecSplice(_334, _335, 0), _337, true)); } else if (_329 === 1) { - const _341: rt.Vec = v; - const _342: rt.Range = new rt.Range(start, end); - const _344: rt.Iter = rt.iterMap(rt.iterFilter(new rt.Range(0, n & 0xff), (i3: rt.u8): boolean => { - return rt.u8Rem(i3, 4) !== 1; + const _341: rs.Vec = v; + const _342: rs.Range = new rs.Range(start, end); + const _344: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n & 0xff), (i3: rs.u8): boolean => { + return rs.u8Rem(i3, 4) !== 1; }), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_341, _342, 0), _344)); + rs.drop(rs.spliceFrom(rs.vecSplice(_341, _342, 0), _344)); } else if (_329 === 2) { - const _349: rt.Vec = v; - const _350: rt.Range = new rt.Range(start, end); - const _352: rt.Iter = rt.iterMap(rt.iterChain(new rt.Range(0, n & 0xff), rt.iterFilter(new rt.Range(0, n & 0xff), (i2: rt.u8): boolean => { - return rt.u8Rem(i2, 2) === 0; + const _349: rs.Vec = v; + const _350: rs.Range = new rs.Range(start, end); + const _352: rs.Iter = rs.iterMap(rs.iterChain(new rs.Range(0, n & 0xff), rs.iterFilter(new rs.Range(0, n & 0xff), (i2: rs.u8): boolean => { + return rs.u8Rem(i2, 2) === 0; })), make); - rt.drop(rt.spliceFrom(rt.vecSplice(_349, _350, 0), _352)); + rs.drop(rs.spliceFrom(rs.vecSplice(_349, _350, 0), _352)); } else { - const _360: rt.Vec = v; + const _360: rs.Vec = v; make(arg); - const _361: rt.Range = new rt.Range(start, end); - const _363: rt.Vec = rt.vecFromElem(undefined, n, undefined); - rt.drop(rt.spliceFrom(rt.vecSplice(_360, _361, 0), rt.vecIntoIter(_363), true)); + const _361: rs.Range = new rs.Range(start, end); + const _363: rs.Vec = rs.vecFromElem(undefined, n, undefined); + rs.drop(rs.spliceFrom(rs.vecSplice(_360, _361, 0), rs.vecIntoIter(_363), true)); } } else if (_39 === 36) { const keep3: () => boolean = alternate(); - rt.ownedCount(rt.iterTake(rt.vecExtractIfMut(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), (_23: rt.Place): boolean => { + rs.ownedCount(rs.iterTake(rs.vecExtractIfMut(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), (_23: rs.Place): boolean => { return keep3(); - }), rt.u8Rem(arg, 5) as rt.usize)); + }), rs.u8Rem(arg, 5) as rs.usize)); } else if (_39 === 37) { - const pairs: rt.Vec = rt.vecWithCapacity(rt.u8Rem(arg, 6) as rt.usize, 0); - const iter4: rt.Iter = rt.sliceChunksExact(v.items, 2); + const pairs: rs.Vec = rs.vecWithCapacity(rs.u8Rem(arg, 6) as rs.usize, 0); + const iter4: rs.Iter = rs.sliceChunksExact(v.items, 2); while (true) { - const _392: undefined[] | rt.Done = iter4.next(); - if (_392 === rt.DONE) { + const _392: undefined[] | rs.Done = iter4.next(); + if (_392 === rs.DONE) { break; } - rt.idx(_392, 0); + rs.idx(_392, 0); _392[0]; - rt.idx(_392, 1); + rs.idx(_392, 1); _392[1]; pairs.items.push([undefined, undefined]); } - const flat: rt.Vec = rt.vecIntoFlattened(pairs, 2, 0); - sized(out, flat.items.length, rt.vecCapacity(flat, 0)); + const flat: rs.Vec = rs.vecIntoFlattened(pairs, 2, 0); + sized(out, flat.items.length, rs.vecCapacity(flat, 0)); } else if (_39 === 38) { - rt.spliceFrom(rt.vecSplice(v, new rt.RangeFrom(rt.usizeRem(arg as rt.usize, rt.usizeAdd(v.items.length, 1)), rt.usizeStep), 0), rt.iterSlice([]), true); + rs.spliceFrom(rs.vecSplice(v, new rs.RangeFrom(rs.usizeRem(arg as rs.usize, rs.usizeAdd(v.items.length, 1)), rs.usizeStep), 0), rs.iterSlice([]), true); } else if (_39 === 39 || _39 === 40) { - const additional2: rt.usize = amount(arg, v.items.length, size); - if (rt.u8Rem(op, 41) === 39) { - tried = rt.vecTryReserve(v, additional2, 0); + const additional2: rs.usize = amount(arg, v.items.length, size); + if (rs.u8Rem(op, 41) === 39) { + tried = rs.vecTryReserve(v, additional2, 0); } else { - tried = rt.vecTryReserveExact(v, additional2, 0); + tried = rs.vecTryReserveExact(v, additional2, 0); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, v.items.length, rt.vecCapacity(v, 0)); + sized(out, v.items.length, rs.vecCapacity(v, 0)); } } @@ -1298,2156 +1298,2156 @@ export function vecSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: * over each `Vec` it holds, and a clone's where a tuple's, a derived struct's, or a * deque's clones it anew. */ -export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 5); +export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 5); if (_5 === 0) { - cloneFromSteps$u8(data, (b3: rt.u8): rt.u8 => { + cloneFromSteps$u8(data, (b3: rs.u8): rs.u8 => { return b3; }, out); } else if (_5 === 1) { - cloneFromSteps$u16(data, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + cloneFromSteps$u16(data, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }, out); } else if (_5 === 2) { - cloneFromSteps$tuple2_u64_u8(data, (b2: rt.u8): [rt.u64, rt.u8] => { - return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + cloneFromSteps$tuple2_u64_u8(data, (b2: rs.u8): [rs.u64, rs.u8] => { + return [b2 as rs.u64, b2] as [rs.u64, rs.u8]; }, out); } else if (_5 === 3) { - cloneFromSteps$array160_u64(data, (b: rt.u8): rt.u64[] => { - const _3: rt.u64 = b as rt.u64; - return Array.from({ length: 160 }, (): rt.u64 => { + cloneFromSteps$array160_u64(data, (b: rs.u8): rs.u64[] => { + const _3: rs.u64 = b as rs.u64; + return Array.from({ length: 160 }, (): rs.u64 => { return _3; }); }, out); } else { - cloneFromSteps$unit(data, (_2: rt.u8): undefined => {}, out); + cloneFromSteps$unit(data, (_2: rs.u8): undefined => {}, out); } } -export function cloneFromSteps$array160_u64(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { - let result!: rt.Result, rt.Vec>; - let _204!: rt.Result, rt.Vec>; - const _17: (a0: rt.Vec[], a1: rt.ByteVec) => undefined = (vs: rt.Vec[], out2: rt.ByteVec): undefined => { +export function cloneFromSteps$array160_u64(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { + let result!: rs.Result, rs.Vec>; + let _204!: rs.Result, rs.Vec>; + const _17: (a0: rs.Vec[], a1: rs.ByteVec) => undefined = (vs: rs.Vec[], out2: rs.ByteVec): undefined => { put(out2, vs.length); for (const _8 of vs) { put(out2, _8.items.length); - put(out2, rt.vecCapacity(_8, 1280)); + put(out2, rs.vecCapacity(_8, 1280)); } }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; - const held: (a0: rt.usize) => rt.Vec = (i2: rt.usize): rt.Vec => { - let v!: rt.Vec; - let _192!: rt.u8; - const b: rt.u8 = at(i2); + const held: (a0: rs.usize) => rs.Vec = (i2: rs.usize): rs.Vec => { + let v!: rs.Vec; + let _192!: rs.u8; + const b: rs.u8 = at(i2); if ((b & 1) === 1) { - v = rt.vecWithCapacity(b >> 4 as rt.usize, 1280); + v = rs.vecWithCapacity(b >> 4 as rs.usize, 1280); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - const _132: rt.u8 = rt.u8Rem(b >> 1, 6); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _132; + const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _132; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; } - const j: rt.u8 = _192; - const _243: rt.Vec = v; - const _25: rt.u64[] = copy$array_u64(make(j)); + const j: rs.u8 = _192; + const _243: rs.Vec = v; + const _25: rs.u64[] = copy$array_u64(make(j)); _243.items.push(_25); } }; - const source: (a0: rt.usize) => rt.Vec = (i3: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(i3), 10)), make), undefined, 1280, true); + const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(i3), 10)), make), undefined, 1280, true); }; - const len: (a0: rt.usize) => rt.usize = (i4: rt.usize): rt.usize => { - return rt.u8Rem(at(i4), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i4: rs.usize): rs.usize => { + return rs.u8Rem(at(i4), 4) as rs.usize; }; - const holds: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from: rt.usize, n: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (j2: rt.usize): rt.Vec => { - return held(rt.usizeAdd(from, j2)); + const holds: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from: rs.usize, n: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (j2: rs.usize): rs.Vec => { + return held(rs.usizeAdd(from, j2)); }), undefined, 12, true); }; - const sources: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from2: rt.usize, n2: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (j3: rt.usize): rt.Vec => { - return source(rt.usizeAdd(from2, j3)); + const sources: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from2: rs.usize, n2: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (j3: rs.usize): rs.Vec => { + return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; - const array: rt.Vec[] = [held(0), held(1)]; - const _28: rt.Vec[] = [source(2), source(3)]; - rt.sliceCloneFromSlice(array, _28, (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + const array: rs.Vec[] = [held(0), held(1)]; + const _28: rs.Vec[] = [source(2), source(3)]; + rs.sliceCloneFromSlice(array, _28, (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(array, out); - const slice: rt.Vec[] = [held(4), held(5), held(6)]; - rt.sliceCloneFromSlice(rt.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + const slice: rs.Vec[] = [held(4), held(5), held(6)]; + rs.sliceCloneFromSlice(rs.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(slice, out); - rt.sliceFill(slice, source(9), (a03: rt.Vec): rt.Vec => { - return rt.vecFrom(a03.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + rs.sliceFill(slice, source(9), (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(slice, out); const part6 = len(10); - const nested: rt.Vec> = holds(11, part6); + const nested: rs.Vec> = holds(11, part6); const part7 = len(14); - const _88: rt.Vec> = sources(15, part7); - rt.vecCloneFrom(nested, _88, 12, (a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + const _88: rs.Vec> = sources(15, part7); + rs.vecCloneFrom(nested, _88, 12, (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(nested.items, out); const part9 = len(18); - const into: rt.Vec> = holds(19, part9); + const into: rs.Vec> = holds(19, part9); const part10 = len(22); - const _106: rt.Vec[] = rt.sliceRange(sources(23, part10).items, 0); - rt.vecCloneFrom(into, _106, 12, (a05: rt.Vec): rt.Vec => { - return rt.vecFrom(a05.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + const _106: rs.Vec[] = rs.sliceRange(sources(23, part10).items, 0); + rs.vecCloneFrom(into, _106, 12, (a05: rs.Vec): rs.Vec => { + return rs.vecFrom(a05.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(into.items, out); - const boxed: rt.Vec = held(26); - const _127: rt.Vec = source(27); - rt.vecCloneFrom(boxed, _127, 1280, copy$array_u64); + const boxed: rs.Vec = held(26); + const _127: rs.Vec = source(27); + rs.vecCloneFrom(boxed, _127, 1280, copy$array_u64); _17([boxed], out); const part13 = len(28); - let boxes: rt.Vec[] = holds(29, part13).items; + let boxes: rs.Vec[] = holds(29, part13).items; const part14 = len(32); - const _148: rt.Vec[] = sources(33, part14).items; - boxes = rt.boxSliceCloneFrom(boxes, _148, (a06: rt.Vec): rt.Vec => { - return rt.vecFrom(a06.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + const _148: rs.Vec[] = sources(33, part14).items; + boxes = rs.boxSliceCloneFrom(boxes, _148, (a06: rs.Vec): rs.Vec => { + return rs.vecFrom(a06.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17(boxes, out); - let option: rt.Vec | undefined = then$060nyee(rt.u8Rem(at(36), 3) !== 0, (): rt.Vec => { + let option: rs.Vec | undefined = then$1b5wr43(rs.u8Rem(at(36), 3) !== 0, (): rs.Vec => { return held(37); }); - const _172: rt.Vec | undefined = then$060nyee(rt.u8Rem(at(38), 3) !== 0, (): rt.Vec => { + const _172: rs.Vec | undefined = then$1b5wr43(rs.u8Rem(at(38), 3) !== 0, (): rs.Vec => { return source(39); }); - option = rt.optionCloneFrom(option, _172, (a07: rt.Vec): rt.Vec => { - return rt.vecFrom(a07.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); - const part16 = rt.iterToVec(rt.iterOption(option), undefined, 12, true).items; + option = rs.optionCloneFrom(option, _172, (a07: rs.Vec): rs.Vec => { + return rs.vecFrom(a07.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); + const part16 = rs.iterToVec(rs.iterOption(option), undefined, 12, true).items; _17(part16, out); - if (rt.u8Rem(at(40), 2) === 0) { - result = rt.Ok(held(41)); + if (rs.u8Rem(at(40), 2) === 0) { + result = rs.Ok(held(41)); } else { - result = rt.Err(held(42)); + result = rs.Err(held(42)); } - const _202: rt.Place, rt.Vec>> = rt.place(() => result, (value2) => result = value2); - if (rt.u8Rem(at(43), 2) === 0) { - _204 = rt.Ok(source(44)); + const _202: rs.Place, rs.Vec>> = rs.place(() => result, (value2) => result = value2); + if (rs.u8Rem(at(43), 2) === 0) { + _204 = rs.Ok(source(44)); } else { - _204 = rt.Err(source(45)); + _204 = rs.Err(source(45)); } - _202.v = rt.resultCloneFrom(_202.v, _204, (a08: rt.Vec): rt.Vec => { - return rt.vecFrom(a08.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64), (a09: rt.Vec): rt.Vec => { - return rt.vecFrom(a09.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); - rt.byteVecPush(out, result.ok ? 1 : 0); - const part17 = [result_unwrapOrElse$1q4qcpp(result, (v2: rt.Vec): rt.Vec => { + _202.v = rs.resultCloneFrom(_202.v, _204, (a08: rs.Vec): rs.Vec => { + return rs.vecFrom(a08.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64), (a09: rs.Vec): rs.Vec => { + return rs.vecFrom(a09.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); + rs.byteVecPush(out, result.ok ? 1 : 0); + const part17 = [result_unwrapOrElse$128e309(result, (v2: rs.Vec): rs.Vec => { return v2; })]; _17(part17, out); - let cell: rt.RefCell> = new rt.RefCell(held(46)); - const _235: rt.RefCell> = new rt.RefCell(source(47)); - cell = rt.refCellCloneFrom(cell, _235, (a010: rt.Vec): rt.Vec => { - return rt.vecFrom(a010.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); + let cell: rs.RefCell> = new rs.RefCell(held(46)); + const _235: rs.RefCell> = new rs.RefCell(source(47)); + cell = rs.refCellCloneFrom(cell, _235, (a010: rs.Vec): rs.Vec => { + return rs.vecFrom(a010.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); _17([cell.value], out); - let deep: rt.Vec[] | undefined = [held(52)]; - const _256: rt.Vec[] | undefined = [source(53)]; - deep = rt.optionCloneFrom(deep, _256, (a011: rt.Vec[]): rt.Vec[] => { - return a011.map((a012: rt.Vec): rt.Vec => { - return ((a013: rt.Vec): rt.Vec => { - return rt.vecFrom(a013.items.map(copy$array_u64)); + let deep: rs.Vec[] | undefined = [held(52)]; + const _256: rs.Vec[] | undefined = [source(53)]; + deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { + return a011.map((a012: rs.Vec): rs.Vec => { + return ((a013: rs.Vec): rs.Vec => { + return rs.vecFrom(a013.items.map(copy$array_u64)); })(a012); }); - }, undefined, rt.sliceCloneFromSliceFn((a014: rt.Vec): rt.Vec => { - return ((a015: rt.Vec): rt.Vec => { - return rt.vecFrom(a015.items.map(copy$array_u64)); + }, undefined, rs.sliceCloneFromSliceFn((a014: rs.Vec): rs.Vec => { + return ((a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.map(copy$array_u64)); })(a014); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64))); - const part19 = rt.iterToVec(rt.iterOption(option_map$1e3rrc6(deep, (_27: rt.Vec[]): rt.Vec => { + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64))); + const part19 = rs.iterToVec(rs.iterOption(option_map$1n6i7tn(deep, (_27: rs.Vec[]): rs.Vec => { return _27[0]; })), undefined, 12, true).items; _17(part19, out); const part20 = len(54); - const _272: rt.Iter> = rt.vecIntoIter(holds(55, part20)); - const list: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _272); + const _272: rs.Iter> = rs.vecIntoIter(holds(55, part20)); + const list: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _272); const part21 = len(58); - const _283: rt.Iter> = rt.vecIntoIter(sources(59, part21)); - const _282: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _283); - rt.listCloneFrom(list, _282, (a016: rt.Vec): rt.Vec => { - return rt.vecFrom(a016.items.map(copy$array_u64)); - }, undefined, rt.vecCloneFromFn(1280, copy$array_u64)); - const part22 = rt.iterToVec(rt.listIter(list), undefined, 12, true).items; + const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); + const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); + rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.map(copy$array_u64)); + }, undefined, rs.vecCloneFromFn(1280, copy$array_u64)); + const part22 = rs.iterToVec(rs.listIter(list), undefined, 12, true).items; _17(part22, out); const part23 = len(62); - const deque: rt.VecDeque> = rt.dequeFromVec(holds(63, part23), 12) as rt.VecDeque>; + const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); - const _308: rt.VecDeque> = rt.dequeFromVec(sources(67, part24), 12) as rt.VecDeque>; - rt.dequeCloneFrom(deque, _308, (a017: rt.Vec): rt.Vec => { - return rt.vecFrom(a017.items.map(copy$array_u64)); + const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; + rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { + return rs.vecFrom(a017.items.map(copy$array_u64)); }); - const part25 = rt.dequeToVec(deque).items; + const part25 = rs.dequeToVec(deque).items; _17(part25, out); - let heap: rt.BinaryHeap = rt.heapFrom(held(70), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - const _329: rt.BinaryHeap = rt.heapFrom(source(71), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - heap = rt.heapCloneFrom(heap, _329, 1280, copy$array_u64); + let heap: rs.BinaryHeap = rs.heapFrom(held(70), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + const _329: rs.BinaryHeap = rs.heapFrom(source(71), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + heap = rs.heapCloneFrom(heap, _329, 1280, copy$array_u64); _17([heap], out); - const heaps: rt.BinaryHeap[] = [rt.heapFrom(held(72), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)))]; - const _349: rt.BinaryHeap[] = [rt.heapFrom(source(73), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)))]; - rt.sliceCloneFromSlice(heaps, _349, (a018: rt.BinaryHeap): rt.BinaryHeap => { - return rt.heapClone(a018, copy$array_u64); - }, undefined, rt.heapCloneFromFn(1280, copy$array_u64)); - put(out, rt.vecCapacity(heaps[0], 1280)); - const deques: rt.VecDeque[] = [rt.dequeFromVec(held(74), 1280) as rt.VecDeque]; - const _367: rt.VecDeque[] = [rt.dequeFromVec(source(75), 1280) as rt.VecDeque]; - rt.sliceCloneFromSlice(deques, _367, (a019: rt.VecDeque): rt.VecDeque => { - return rt.dequeClone(a019, copy$array_u64); - }, undefined, rt.dequeCloneFromFn(copy$array_u64)); - put(out, rt.dequeCapacity(deques[0])); - let pair: [rt.Vec, rt.u8] = [held(76), 0]; - pair = rt.tupleClone([source(77), 1] as [rt.Vec, rt.u8], [(a020: rt.Vec): rt.Vec => { - return rt.vecFrom(a020.items.map(copy$array_u64)); + const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)))]; + const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)))]; + rs.sliceCloneFromSlice(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a018, copy$array_u64); + }, undefined, rs.heapCloneFromFn(1280, copy$array_u64)); + put(out, rs.vecCapacity(heaps[0], 1280)); + const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 1280) as rs.VecDeque]; + const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 1280) as rs.VecDeque]; + rs.sliceCloneFromSlice(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a019, copy$array_u64); + }, undefined, rs.dequeCloneFromFn(copy$array_u64)); + put(out, rs.dequeCapacity(deques[0])); + let pair: [rs.Vec, rs.u8] = [held(76), 0]; + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { + return rs.vecFrom(a020.items.map(copy$array_u64)); }, undefined]); - let holder: Holds.Holds = new Holds.Holds(held(78)); + let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_array160_u64(new Holds.Holds(source(79))); - _17([pair[0], holder._0 as rt.Vec], out); + _17([pair[0], holder._0 as rs.Vec], out); } -export function cloneFromSteps$tuple2_u64_u8(data: rt.ByteSlice, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { - let result!: rt.Result, rt.Vec<[rt.u64, rt.u8]>>; - let _204!: rt.Result, rt.Vec<[rt.u64, rt.u8]>>; - const _17: (a0: rt.Vec<[rt.u64, rt.u8]>[], a1: rt.ByteVec) => undefined = (vs: rt.Vec<[rt.u64, rt.u8]>[], out2: rt.ByteVec): undefined => { +export function cloneFromSteps$tuple2_u64_u8(data: rs.ByteSlice, make: (a0: rs.u8) => [rs.u64, rs.u8], out: rs.ByteVec): void { + let result!: rs.Result, rs.Vec<[rs.u64, rs.u8]>>; + let _204!: rs.Result, rs.Vec<[rs.u64, rs.u8]>>; + const _17: (a0: rs.Vec<[rs.u64, rs.u8]>[], a1: rs.ByteVec) => undefined = (vs: rs.Vec<[rs.u64, rs.u8]>[], out2: rs.ByteVec): undefined => { put(out2, vs.length); for (const _8 of vs) { put(out2, _8.items.length); - put(out2, rt.vecCapacity(_8, 16)); + put(out2, rs.vecCapacity(_8, 16)); } }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; - const held: (a0: rt.usize) => rt.Vec<[rt.u64, rt.u8]> = (i2: rt.usize): rt.Vec<[rt.u64, rt.u8]> => { - let v!: rt.Vec<[rt.u64, rt.u8]>; - let _192!: rt.u8; - const b: rt.u8 = at(i2); + const held: (a0: rs.usize) => rs.Vec<[rs.u64, rs.u8]> = (i2: rs.usize): rs.Vec<[rs.u64, rs.u8]> => { + let v!: rs.Vec<[rs.u64, rs.u8]>; + let _192!: rs.u8; + const b: rs.u8 = at(i2); if ((b & 1) === 1) { - v = rt.vecWithCapacity(b >> 4 as rt.usize, 16); + v = rs.vecWithCapacity(b >> 4 as rs.usize, 16); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - const _132: rt.u8 = rt.u8Rem(b >> 1, 6); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _132; + const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _132; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; } - const j: rt.u8 = _192; - const _243: rt.Vec<[rt.u64, rt.u8]> = v; - const _25: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(j)); + const j: rs.u8 = _192; + const _243: rs.Vec<[rs.u64, rs.u8]> = v; + const _25: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(j)); _243.items.push(_25); } }; - const source: (a0: rt.usize) => rt.Vec<[rt.u64, rt.u8]> = (i3: rt.usize): rt.Vec<[rt.u64, rt.u8]> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(i3), 10)), make), undefined, 16, true); + const source: (a0: rs.usize) => rs.Vec<[rs.u64, rs.u8]> = (i3: rs.usize): rs.Vec<[rs.u64, rs.u8]> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(i3), 10)), make), undefined, 16, true); }; - const len: (a0: rt.usize) => rt.usize = (i4: rt.usize): rt.usize => { - return rt.u8Rem(at(i4), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i4: rs.usize): rs.usize => { + return rs.u8Rem(at(i4), 4) as rs.usize; }; - const holds: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from: rt.usize, n: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (j2: rt.usize): rt.Vec<[rt.u64, rt.u8]> => { - return held(rt.usizeAdd(from, j2)); + const holds: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from: rs.usize, n: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (j2: rs.usize): rs.Vec<[rs.u64, rs.u8]> => { + return held(rs.usizeAdd(from, j2)); }), undefined, 12, true); }; - const sources: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from2: rt.usize, n2: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (j3: rt.usize): rt.Vec<[rt.u64, rt.u8]> => { - return source(rt.usizeAdd(from2, j3)); + const sources: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from2: rs.usize, n2: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (j3: rs.usize): rs.Vec<[rs.u64, rs.u8]> => { + return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; - const array: rt.Vec<[rt.u64, rt.u8]>[] = [held(0), held(1)]; - const _28: rt.Vec<[rt.u64, rt.u8]>[] = [source(2), source(3)]; - rt.sliceCloneFromSlice(array, _28, (a0: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a0.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const array: rs.Vec<[rs.u64, rs.u8]>[] = [held(0), held(1)]; + const _28: rs.Vec<[rs.u64, rs.u8]>[] = [source(2), source(3)]; + rs.sliceCloneFromSlice(array, _28, (a0: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a0.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(array, out); - const slice: rt.Vec<[rt.u64, rt.u8]>[] = [held(4), held(5), held(6)]; - rt.sliceCloneFromSlice(rt.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a02.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const slice: rs.Vec<[rs.u64, rs.u8]>[] = [held(4), held(5), held(6)]; + rs.sliceCloneFromSlice(rs.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a02.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(slice, out); - rt.sliceFill(slice, source(9), (a03: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a03.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + rs.sliceFill(slice, source(9), (a03: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a03.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(slice, out); const part6 = len(10); - const nested: rt.Vec> = holds(11, part6); + const nested: rs.Vec> = holds(11, part6); const part7 = len(14); - const _88: rt.Vec> = sources(15, part7); - rt.vecCloneFrom(nested, _88, 12, (a04: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a04.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const _88: rs.Vec> = sources(15, part7); + rs.vecCloneFrom(nested, _88, 12, (a04: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a04.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(nested.items, out); const part9 = len(18); - const into: rt.Vec> = holds(19, part9); + const into: rs.Vec> = holds(19, part9); const part10 = len(22); - const _106: rt.Vec<[rt.u64, rt.u8]>[] = rt.sliceRange(sources(23, part10).items, 0); - rt.vecCloneFrom(into, _106, 12, (a05: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a05.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const _106: rs.Vec<[rs.u64, rs.u8]>[] = rs.sliceRange(sources(23, part10).items, 0); + rs.vecCloneFrom(into, _106, 12, (a05: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a05.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(into.items, out); - const boxed: rt.Vec<[rt.u64, rt.u8]> = held(26); - const _127: rt.Vec<[rt.u64, rt.u8]> = source(27); - rt.vecCloneFrom(boxed, _127, 16, copy$tuple2_u64_u8); + const boxed: rs.Vec<[rs.u64, rs.u8]> = held(26); + const _127: rs.Vec<[rs.u64, rs.u8]> = source(27); + rs.vecCloneFrom(boxed, _127, 16, copy$tuple2_u64_u8); _17([boxed], out); const part13 = len(28); - let boxes: rt.Vec<[rt.u64, rt.u8]>[] = holds(29, part13).items; + let boxes: rs.Vec<[rs.u64, rs.u8]>[] = holds(29, part13).items; const part14 = len(32); - const _148: rt.Vec<[rt.u64, rt.u8]>[] = sources(33, part14).items; - boxes = rt.boxSliceCloneFrom(boxes, _148, (a06: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a06.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const _148: rs.Vec<[rs.u64, rs.u8]>[] = sources(33, part14).items; + boxes = rs.boxSliceCloneFrom(boxes, _148, (a06: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a06.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17(boxes, out); - let option: rt.Vec<[rt.u64, rt.u8]> | undefined = then$15ykizu(rt.u8Rem(at(36), 3) !== 0, (): rt.Vec<[rt.u64, rt.u8]> => { + let option: rs.Vec<[rs.u64, rs.u8]> | undefined = then$0tujtct(rs.u8Rem(at(36), 3) !== 0, (): rs.Vec<[rs.u64, rs.u8]> => { return held(37); }); - const _172: rt.Vec<[rt.u64, rt.u8]> | undefined = then$15ykizu(rt.u8Rem(at(38), 3) !== 0, (): rt.Vec<[rt.u64, rt.u8]> => { + const _172: rs.Vec<[rs.u64, rs.u8]> | undefined = then$0tujtct(rs.u8Rem(at(38), 3) !== 0, (): rs.Vec<[rs.u64, rs.u8]> => { return source(39); }); - option = rt.optionCloneFrom(option, _172, (a07: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a07.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); - const part16 = rt.iterToVec(rt.iterOption(option), undefined, 12, true).items; + option = rs.optionCloneFrom(option, _172, (a07: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a07.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const part16 = rs.iterToVec(rs.iterOption(option), undefined, 12, true).items; _17(part16, out); - if (rt.u8Rem(at(40), 2) === 0) { - result = rt.Ok(held(41)); + if (rs.u8Rem(at(40), 2) === 0) { + result = rs.Ok(held(41)); } else { - result = rt.Err(held(42)); + result = rs.Err(held(42)); } - const _202: rt.Place, rt.Vec<[rt.u64, rt.u8]>>> = rt.place(() => result, (value2) => result = value2); - if (rt.u8Rem(at(43), 2) === 0) { - _204 = rt.Ok(source(44)); + const _202: rs.Place, rs.Vec<[rs.u64, rs.u8]>>> = rs.place(() => result, (value2) => result = value2); + if (rs.u8Rem(at(43), 2) === 0) { + _204 = rs.Ok(source(44)); } else { - _204 = rt.Err(source(45)); + _204 = rs.Err(source(45)); } - _202.v = rt.resultCloneFrom(_202.v, _204, (a08: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a08.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8), (a09: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a09.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); - rt.byteVecPush(out, result.ok ? 1 : 0); - const part17 = [result_unwrapOrElse$17cj159(result, (v2: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { + _202.v = rs.resultCloneFrom(_202.v, _204, (a08: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a08.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8), (a09: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a09.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); + rs.byteVecPush(out, result.ok ? 1 : 0); + const part17 = [result_unwrapOrElse$02f6iwg(result, (v2: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { return v2; })]; _17(part17, out); - let cell: rt.RefCell> = new rt.RefCell(held(46)); - const _235: rt.RefCell> = new rt.RefCell(source(47)); - cell = rt.refCellCloneFrom(cell, _235, (a010: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a010.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); + let cell: rs.RefCell> = new rs.RefCell(held(46)); + const _235: rs.RefCell> = new rs.RefCell(source(47)); + cell = rs.refCellCloneFrom(cell, _235, (a010: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a010.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); _17([cell.value], out); - let deep: rt.Vec<[rt.u64, rt.u8]>[] | undefined = [held(52)]; - const _256: rt.Vec<[rt.u64, rt.u8]>[] | undefined = [source(53)]; - deep = rt.optionCloneFrom(deep, _256, (a011: rt.Vec<[rt.u64, rt.u8]>[]): rt.Vec<[rt.u64, rt.u8]>[] => { - return a011.map((a012: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return ((a013: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a013.items.map(copy$tuple2_u64_u8)); + let deep: rs.Vec<[rs.u64, rs.u8]>[] | undefined = [held(52)]; + const _256: rs.Vec<[rs.u64, rs.u8]>[] | undefined = [source(53)]; + deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec<[rs.u64, rs.u8]>[]): rs.Vec<[rs.u64, rs.u8]>[] => { + return a011.map((a012: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return ((a013: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a013.items.map(copy$tuple2_u64_u8)); })(a012); }); - }, undefined, rt.sliceCloneFromSliceFn((a014: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return ((a015: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a015.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.sliceCloneFromSliceFn((a014: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return ((a015: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a015.items.map(copy$tuple2_u64_u8)); })(a014); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8))); - const part19 = rt.iterToVec(rt.iterOption(option_map$0rgpr92(deep, (_27: rt.Vec<[rt.u64, rt.u8]>[]): rt.Vec<[rt.u64, rt.u8]> => { + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8))); + const part19 = rs.iterToVec(rs.iterOption(option_map$12r4ivp(deep, (_27: rs.Vec<[rs.u64, rs.u8]>[]): rs.Vec<[rs.u64, rs.u8]> => { return _27[0]; })), undefined, 12, true).items; _17(part19, out); const part20 = len(54); - const _272: rt.Iter> = rt.vecIntoIter(holds(55, part20)); - const list: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _272); + const _272: rs.Iter> = rs.vecIntoIter(holds(55, part20)); + const list: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _272); const part21 = len(58); - const _283: rt.Iter> = rt.vecIntoIter(sources(59, part21)); - const _282: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _283); - rt.listCloneFrom(list, _282, (a016: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a016.items.map(copy$tuple2_u64_u8)); - }, undefined, rt.vecCloneFromFn(16, copy$tuple2_u64_u8)); - const part22 = rt.iterToVec(rt.listIter(list), undefined, 12, true).items; + const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); + const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); + rs.listCloneFrom(list, _282, (a016: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a016.items.map(copy$tuple2_u64_u8)); + }, undefined, rs.vecCloneFromFn(16, copy$tuple2_u64_u8)); + const part22 = rs.iterToVec(rs.listIter(list), undefined, 12, true).items; _17(part22, out); const part23 = len(62); - const deque: rt.VecDeque> = rt.dequeFromVec(holds(63, part23), 12) as rt.VecDeque>; + const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); - const _308: rt.VecDeque> = rt.dequeFromVec(sources(67, part24), 12) as rt.VecDeque>; - rt.dequeCloneFrom(deque, _308, (a017: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a017.items.map(copy$tuple2_u64_u8)); + const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; + rs.dequeCloneFrom(deque, _308, (a017: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a017.items.map(copy$tuple2_u64_u8)); }); - const part25 = rt.dequeToVec(deque).items; + const part25 = rs.dequeToVec(deque).items; _17(part25, out); - let heap: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(held(70), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - const _329: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(source(71), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - heap = rt.heapCloneFrom(heap, _329, 16, copy$tuple2_u64_u8); + let heap: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(held(70), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + const _329: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(source(71), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + heap = rs.heapCloneFrom(heap, _329, 16, copy$tuple2_u64_u8); _17([heap], out); - const heaps: rt.BinaryHeap<[rt.u64, rt.u8]>[] = [rt.heapFrom(held(72), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])))]; - const _349: rt.BinaryHeap<[rt.u64, rt.u8]>[] = [rt.heapFrom(source(73), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])))]; - rt.sliceCloneFromSlice(heaps, _349, (a018: rt.BinaryHeap<[rt.u64, rt.u8]>): rt.BinaryHeap<[rt.u64, rt.u8]> => { - return rt.heapClone(a018, copy$tuple2_u64_u8); - }, undefined, rt.heapCloneFromFn(16, copy$tuple2_u64_u8)); - put(out, rt.vecCapacity(heaps[0], 16)); - const deques: rt.VecDeque<[rt.u64, rt.u8]>[] = [rt.dequeFromVec(held(74), 16) as rt.VecDeque<[rt.u64, rt.u8]>]; - const _367: rt.VecDeque<[rt.u64, rt.u8]>[] = [rt.dequeFromVec(source(75), 16) as rt.VecDeque<[rt.u64, rt.u8]>]; - rt.sliceCloneFromSlice(deques, _367, (a019: rt.VecDeque<[rt.u64, rt.u8]>): rt.VecDeque<[rt.u64, rt.u8]> => { - return rt.dequeClone(a019, copy$tuple2_u64_u8); - }, undefined, rt.dequeCloneFromFn(copy$tuple2_u64_u8)); - put(out, rt.dequeCapacity(deques[0])); - let pair: [rt.Vec<[rt.u64, rt.u8]>, rt.u8] = [held(76), 0]; - pair = rt.tupleClone([source(77), 1] as [rt.Vec<[rt.u64, rt.u8]>, rt.u8], [(a020: rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> => { - return rt.vecFrom(a020.items.map(copy$tuple2_u64_u8)); + const heaps: rs.BinaryHeap<[rs.u64, rs.u8]>[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))]; + const _349: rs.BinaryHeap<[rs.u64, rs.u8]>[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))]; + rs.sliceCloneFromSlice(heaps, _349, (a018: rs.BinaryHeap<[rs.u64, rs.u8]>): rs.BinaryHeap<[rs.u64, rs.u8]> => { + return rs.heapClone(a018, copy$tuple2_u64_u8); + }, undefined, rs.heapCloneFromFn(16, copy$tuple2_u64_u8)); + put(out, rs.vecCapacity(heaps[0], 16)); + const deques: rs.VecDeque<[rs.u64, rs.u8]>[] = [rs.dequeFromVec(held(74), 16) as rs.VecDeque<[rs.u64, rs.u8]>]; + const _367: rs.VecDeque<[rs.u64, rs.u8]>[] = [rs.dequeFromVec(source(75), 16) as rs.VecDeque<[rs.u64, rs.u8]>]; + rs.sliceCloneFromSlice(deques, _367, (a019: rs.VecDeque<[rs.u64, rs.u8]>): rs.VecDeque<[rs.u64, rs.u8]> => { + return rs.dequeClone(a019, copy$tuple2_u64_u8); + }, undefined, rs.dequeCloneFromFn(copy$tuple2_u64_u8)); + put(out, rs.dequeCapacity(deques[0])); + let pair: [rs.Vec<[rs.u64, rs.u8]>, rs.u8] = [held(76), 0]; + pair = rs.tupleClone([source(77), 1] as [rs.Vec<[rs.u64, rs.u8]>, rs.u8], [(a020: rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> => { + return rs.vecFrom(a020.items.map(copy$tuple2_u64_u8)); }, undefined]); - let holder: Holds.Holds<[rt.u64, rt.u8]> = new Holds.Holds(held(78)); + let holder: Holds.Holds<[rs.u64, rs.u8]> = new Holds.Holds(held(78)); holder = Holds.clone$Clone_tuple2_u64_u8(new Holds.Holds(source(79))); - _17([pair[0], holder._0 as rt.Vec<[rt.u64, rt.u8]>], out); + _17([pair[0], holder._0 as rs.Vec<[rs.u64, rs.u8]>], out); } -export function cloneFromSteps$u16(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { - let result!: rt.Result, rt.Vec>; - let _204!: rt.Result, rt.Vec>; - const _17: (a0: rt.Vec[], a1: rt.ByteVec) => undefined = (vs: rt.Vec[], out2: rt.ByteVec): undefined => { +export function cloneFromSteps$u16(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u16, out: rs.ByteVec): void { + let result!: rs.Result, rs.Vec>; + let _204!: rs.Result, rs.Vec>; + const _17: (a0: rs.Vec[], a1: rs.ByteVec) => undefined = (vs: rs.Vec[], out2: rs.ByteVec): undefined => { put(out2, vs.length); for (const _8 of vs) { put(out2, _8.items.length); - put(out2, rt.vecCapacity(_8, 2)); + put(out2, rs.vecCapacity(_8, 2)); } }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; - const held: (a0: rt.usize) => rt.Vec = (i2: rt.usize): rt.Vec => { - let v!: rt.Vec; - let _192!: rt.u8; - const b: rt.u8 = at(i2); + const held: (a0: rs.usize) => rs.Vec = (i2: rs.usize): rs.Vec => { + let v!: rs.Vec; + let _192!: rs.u8; + const b: rs.u8 = at(i2); if ((b & 1) === 1) { - v = rt.vecWithCapacity(b >> 4 as rt.usize, 2); + v = rs.vecWithCapacity(b >> 4 as rs.usize, 2); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - const _132: rt.u8 = rt.u8Rem(b >> 1, 6); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _132; + const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _132; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; } - const j: rt.u8 = _192; - const _243: rt.Vec = v; - const _25: rt.u16 = make(j); + const j: rs.u8 = _192; + const _243: rs.Vec = v; + const _25: rs.u16 = make(j); _243.items.push(_25); } }; - const source: (a0: rt.usize) => rt.Vec = (i3: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(i3), 10)), make), undefined, 2, true); + const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(i3), 10)), make), undefined, 2, true); }; - const len: (a0: rt.usize) => rt.usize = (i4: rt.usize): rt.usize => { - return rt.u8Rem(at(i4), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i4: rs.usize): rs.usize => { + return rs.u8Rem(at(i4), 4) as rs.usize; }; - const holds: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from: rt.usize, n: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (j2: rt.usize): rt.Vec => { - return held(rt.usizeAdd(from, j2)); + const holds: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from: rs.usize, n: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (j2: rs.usize): rs.Vec => { + return held(rs.usizeAdd(from, j2)); }), undefined, 12, true); }; - const sources: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from2: rt.usize, n2: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (j3: rt.usize): rt.Vec => { - return source(rt.usizeAdd(from2, j3)); + const sources: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from2: rs.usize, n2: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (j3: rs.usize): rs.Vec => { + return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; - const array: rt.Vec[] = [held(0), held(1)]; - const _28: rt.Vec[] = [source(2), source(3)]; - rt.sliceCloneFromSlice(array, _28, (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + const array: rs.Vec[] = [held(0), held(1)]; + const _28: rs.Vec[] = [source(2), source(3)]; + rs.sliceCloneFromSlice(array, _28, (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(array, out); - const slice: rt.Vec[] = [held(4), held(5), held(6)]; - rt.sliceCloneFromSlice(rt.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + const slice: rs.Vec[] = [held(4), held(5), held(6)]; + rs.sliceCloneFromSlice(rs.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(slice, out); - rt.sliceFill(slice, source(9), (a03: rt.Vec): rt.Vec => { - return rt.vecFrom(a03.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + rs.sliceFill(slice, source(9), (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(slice, out); const part6 = len(10); - const nested: rt.Vec> = holds(11, part6); + const nested: rs.Vec> = holds(11, part6); const part7 = len(14); - const _88: rt.Vec> = sources(15, part7); - rt.vecCloneFrom(nested, _88, 12, (a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + const _88: rs.Vec> = sources(15, part7); + rs.vecCloneFrom(nested, _88, 12, (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(nested.items, out); const part9 = len(18); - const into: rt.Vec> = holds(19, part9); + const into: rs.Vec> = holds(19, part9); const part10 = len(22); - const _106: rt.Vec[] = rt.sliceRange(sources(23, part10).items, 0); - rt.vecCloneFrom(into, _106, 12, (a05: rt.Vec): rt.Vec => { - return rt.vecFrom(a05.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + const _106: rs.Vec[] = rs.sliceRange(sources(23, part10).items, 0); + rs.vecCloneFrom(into, _106, 12, (a05: rs.Vec): rs.Vec => { + return rs.vecFrom(a05.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(into.items, out); - const boxed: rt.Vec = held(26); - const _127: rt.Vec = source(27); - rt.vecCloneFrom(boxed, _127, 2); + const boxed: rs.Vec = held(26); + const _127: rs.Vec = source(27); + rs.vecCloneFrom(boxed, _127, 2); _17([boxed], out); const part13 = len(28); - let boxes: rt.Vec[] = holds(29, part13).items; + let boxes: rs.Vec[] = holds(29, part13).items; const part14 = len(32); - const _148: rt.Vec[] = sources(33, part14).items; - boxes = rt.boxSliceCloneFrom(boxes, _148, (a06: rt.Vec): rt.Vec => { - return rt.vecFrom(a06.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + const _148: rs.Vec[] = sources(33, part14).items; + boxes = rs.boxSliceCloneFrom(boxes, _148, (a06: rs.Vec): rs.Vec => { + return rs.vecFrom(a06.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17(boxes, out); - let option: rt.Vec | undefined = then$06am279(rt.u8Rem(at(36), 3) !== 0, (): rt.Vec => { + let option: rs.Vec | undefined = then$0svbdod(rs.u8Rem(at(36), 3) !== 0, (): rs.Vec => { return held(37); }); - const _172: rt.Vec | undefined = then$06am279(rt.u8Rem(at(38), 3) !== 0, (): rt.Vec => { + const _172: rs.Vec | undefined = then$0svbdod(rs.u8Rem(at(38), 3) !== 0, (): rs.Vec => { return source(39); }); - option = rt.optionCloneFrom(option, _172, (a07: rt.Vec): rt.Vec => { - return rt.vecFrom(a07.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); - const part16 = rt.iterToVec(rt.iterOption(option), undefined, 12, true).items; + option = rs.optionCloneFrom(option, _172, (a07: rs.Vec): rs.Vec => { + return rs.vecFrom(a07.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); + const part16 = rs.iterToVec(rs.iterOption(option), undefined, 12, true).items; _17(part16, out); - if (rt.u8Rem(at(40), 2) === 0) { - result = rt.Ok(held(41)); + if (rs.u8Rem(at(40), 2) === 0) { + result = rs.Ok(held(41)); } else { - result = rt.Err(held(42)); + result = rs.Err(held(42)); } - const _202: rt.Place, rt.Vec>> = rt.place(() => result, (value2) => result = value2); - if (rt.u8Rem(at(43), 2) === 0) { - _204 = rt.Ok(source(44)); + const _202: rs.Place, rs.Vec>> = rs.place(() => result, (value2) => result = value2); + if (rs.u8Rem(at(43), 2) === 0) { + _204 = rs.Ok(source(44)); } else { - _204 = rt.Err(source(45)); + _204 = rs.Err(source(45)); } - _202.v = rt.resultCloneFrom(_202.v, _204, (a08: rt.Vec): rt.Vec => { - return rt.vecFrom(a08.items.slice()); - }, undefined, rt.vecCloneFromFn(2), (a09: rt.Vec): rt.Vec => { - return rt.vecFrom(a09.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); - rt.byteVecPush(out, result.ok ? 1 : 0); - const part17 = [result_unwrapOrElse$1urqnv6(result, (v2: rt.Vec): rt.Vec => { + _202.v = rs.resultCloneFrom(_202.v, _204, (a08: rs.Vec): rs.Vec => { + return rs.vecFrom(a08.items.slice()); + }, undefined, rs.vecCloneFromFn(2), (a09: rs.Vec): rs.Vec => { + return rs.vecFrom(a09.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); + rs.byteVecPush(out, result.ok ? 1 : 0); + const part17 = [result_unwrapOrElse$05mb9nr(result, (v2: rs.Vec): rs.Vec => { return v2; })]; _17(part17, out); - let cell: rt.RefCell> = new rt.RefCell(held(46)); - const _235: rt.RefCell> = new rt.RefCell(source(47)); - cell = rt.refCellCloneFrom(cell, _235, (a010: rt.Vec): rt.Vec => { - return rt.vecFrom(a010.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); + let cell: rs.RefCell> = new rs.RefCell(held(46)); + const _235: rs.RefCell> = new rs.RefCell(source(47)); + cell = rs.refCellCloneFrom(cell, _235, (a010: rs.Vec): rs.Vec => { + return rs.vecFrom(a010.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); _17([cell.value], out); - let deep: rt.Vec[] | undefined = [held(52)]; - const _256: rt.Vec[] | undefined = [source(53)]; - deep = rt.optionCloneFrom(deep, _256, (a011: rt.Vec[]): rt.Vec[] => { - return a011.map((a012: rt.Vec): rt.Vec => { - return ((a013: rt.Vec): rt.Vec => { - return rt.vecFrom(a013.items.slice()); + let deep: rs.Vec[] | undefined = [held(52)]; + const _256: rs.Vec[] | undefined = [source(53)]; + deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { + return a011.map((a012: rs.Vec): rs.Vec => { + return ((a013: rs.Vec): rs.Vec => { + return rs.vecFrom(a013.items.slice()); })(a012); }); - }, undefined, rt.sliceCloneFromSliceFn((a014: rt.Vec): rt.Vec => { - return ((a015: rt.Vec): rt.Vec => { - return rt.vecFrom(a015.items.slice()); + }, undefined, rs.sliceCloneFromSliceFn((a014: rs.Vec): rs.Vec => { + return ((a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.slice()); })(a014); - }, undefined, rt.vecCloneFromFn(2))); - const part19 = rt.iterToVec(rt.iterOption(option_map$1dj8fjk(deep, (_27: rt.Vec[]): rt.Vec => { + }, undefined, rs.vecCloneFromFn(2))); + const part19 = rs.iterToVec(rs.iterOption(option_map$03x2fqt(deep, (_27: rs.Vec[]): rs.Vec => { return _27[0]; })), undefined, 12, true).items; _17(part19, out); const part20 = len(54); - const _272: rt.Iter> = rt.vecIntoIter(holds(55, part20)); - const list: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _272); + const _272: rs.Iter> = rs.vecIntoIter(holds(55, part20)); + const list: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _272); const part21 = len(58); - const _283: rt.Iter> = rt.vecIntoIter(sources(59, part21)); - const _282: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _283); - rt.listCloneFrom(list, _282, (a016: rt.Vec): rt.Vec => { - return rt.vecFrom(a016.items.slice()); - }, undefined, rt.vecCloneFromFn(2)); - const part22 = rt.iterToVec(rt.listIter(list), undefined, 12, true).items; + const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); + const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); + rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.slice()); + }, undefined, rs.vecCloneFromFn(2)); + const part22 = rs.iterToVec(rs.listIter(list), undefined, 12, true).items; _17(part22, out); const part23 = len(62); - const deque: rt.VecDeque> = rt.dequeFromVec(holds(63, part23), 12) as rt.VecDeque>; + const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); - const _308: rt.VecDeque> = rt.dequeFromVec(sources(67, part24), 12) as rt.VecDeque>; - rt.dequeCloneFrom(deque, _308, (a017: rt.Vec): rt.Vec => { - return rt.vecFrom(a017.items.slice()); + const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; + rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { + return rs.vecFrom(a017.items.slice()); }); - const part25 = rt.dequeToVec(deque).items; + const part25 = rs.dequeToVec(deque).items; _17(part25, out); - let heap: rt.BinaryHeap = rt.heapFrom(held(70), rt.le, rt.ge, rt.lt); - const _329: rt.BinaryHeap = rt.heapFrom(source(71), rt.le, rt.ge, rt.lt); - heap = rt.heapCloneFrom(heap, _329, 2); + let heap: rs.BinaryHeap = rs.heapFrom(held(70), rs.le, rs.ge, rs.lt); + const _329: rs.BinaryHeap = rs.heapFrom(source(71), rs.le, rs.ge, rs.lt); + heap = rs.heapCloneFrom(heap, _329, 2); _17([heap], out); - const heaps: rt.BinaryHeap[] = [rt.heapFrom(held(72), rt.le, rt.ge, rt.lt)]; - const _349: rt.BinaryHeap[] = [rt.heapFrom(source(73), rt.le, rt.ge, rt.lt)]; - rt.sliceCloneFromSlice(heaps, _349, (a018: rt.BinaryHeap): rt.BinaryHeap => { - return rt.heapClone(a018, undefined); - }, undefined, rt.heapCloneFromFn(2)); - put(out, rt.vecCapacity(heaps[0], 2)); - const deques: rt.VecDeque[] = [rt.dequeFromVec(held(74), 2) as rt.VecDeque]; - const _367: rt.VecDeque[] = [rt.dequeFromVec(source(75), 2) as rt.VecDeque]; - rt.sliceCloneFromSlice(deques, _367, (a019: rt.VecDeque): rt.VecDeque => { - return rt.dequeClone(a019); - }, undefined, rt.dequeCloneFromFn()); - put(out, rt.dequeCapacity(deques[0])); - let pair: [rt.Vec, rt.u8] = [held(76), 0]; - pair = rt.tupleClone([source(77), 1] as [rt.Vec, rt.u8], [(a020: rt.Vec): rt.Vec => { - return rt.vecFrom(a020.items.slice()); + const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.le, rs.ge, rs.lt)]; + const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.le, rs.ge, rs.lt)]; + rs.sliceCloneFromSlice(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a018, undefined); + }, undefined, rs.heapCloneFromFn(2)); + put(out, rs.vecCapacity(heaps[0], 2)); + const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 2) as rs.VecDeque]; + const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 2) as rs.VecDeque]; + rs.sliceCloneFromSlice(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a019); + }, undefined, rs.dequeCloneFromFn()); + put(out, rs.dequeCapacity(deques[0])); + let pair: [rs.Vec, rs.u8] = [held(76), 0]; + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { + return rs.vecFrom(a020.items.slice()); }, undefined]); - let holder: Holds.Holds = new Holds.Holds(held(78)); + let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_u16(new Holds.Holds(source(79))); - _17([pair[0], holder._0 as rt.Vec], out); + _17([pair[0], holder._0 as rs.Vec], out); } -export function cloneFromSteps$u8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let result!: rt.Result; - let _204!: rt.Result; - const _17: (a0: rt.ByteVec[], a1: rt.ByteVec) => undefined = (vs: rt.ByteVec[], out2: rt.ByteVec): undefined => { +export function cloneFromSteps$u8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let result!: rs.Result; + let _204!: rs.Result; + const _17: (a0: rs.ByteVec[], a1: rs.ByteVec) => undefined = (vs: rs.ByteVec[], out2: rs.ByteVec): undefined => { put(out2, vs.length); for (const _8 of vs) { put(out2, _8.length); put(out2, _8.data.length); } }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; - const held: (a0: rt.usize) => rt.ByteVec = (i2: rt.usize): rt.ByteVec => { - let v!: rt.ByteVec; - let _192!: rt.u8; - const b: rt.u8 = at(i2); + const held: (a0: rs.usize) => rs.ByteVec = (i2: rs.usize): rs.ByteVec => { + let v!: rs.ByteVec; + let _192!: rs.u8; + const b: rs.u8 = at(i2); if ((b & 1) === 1) { - v = rt.byteVecWithCapacity(b >> 4 as rt.usize); + v = rs.byteVecWithCapacity(b >> 4 as rs.usize); } else { - v = new rt.ByteVec(); + v = new rs.ByteVec(); } - const _132: rt.u8 = rt.u8Rem(b >> 1, 6); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _132; + const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _132; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; } - rt.byteVecPush(v, make(_192)); + rs.byteVecPush(v, make(_192)); } }; - const source: (a0: rt.usize) => rt.ByteVec = (i3: rt.usize): rt.ByteVec => { - return rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(i3), 10)), make), undefined, true); + const source: (a0: rs.usize) => rs.ByteVec = (i3: rs.usize): rs.ByteVec => { + return rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(i3), 10)), make), undefined, true); }; - const len: (a0: rt.usize) => rt.usize = (i4: rt.usize): rt.usize => { - return rt.u8Rem(at(i4), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i4: rs.usize): rs.usize => { + return rs.u8Rem(at(i4), 4) as rs.usize; }; - const holds: (a0: rt.usize, a1: rt.usize) => rt.Vec = (from: rt.usize, n: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (j2: rt.usize): rt.ByteVec => { - return held(rt.usizeAdd(from, j2)); + const holds: (a0: rs.usize, a1: rs.usize) => rs.Vec = (from: rs.usize, n: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (j2: rs.usize): rs.ByteVec => { + return held(rs.usizeAdd(from, j2)); }), undefined, 12, true); }; - const sources: (a0: rt.usize, a1: rt.usize) => rt.Vec = (from2: rt.usize, n2: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (j3: rt.usize): rt.ByteVec => { - return source(rt.usizeAdd(from2, j3)); + const sources: (a0: rs.usize, a1: rs.usize) => rs.Vec = (from2: rs.usize, n2: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (j3: rs.usize): rs.ByteVec => { + return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; - const array: rt.ByteVec[] = [held(0), held(1)]; - const _28: rt.ByteVec[] = [source(2), source(3)]; - rt.sliceCloneFromSlice(array, _28, (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); - }, undefined, rt.byteVecCloneFromFn()); + const array: rs.ByteVec[] = [held(0), held(1)]; + const _28: rs.ByteVec[] = [source(2), source(3)]; + rs.sliceCloneFromSlice(array, _28, (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); + }, undefined, rs.byteVecCloneFromFn()); _17(array, out); - const slice: rt.ByteVec[] = [held(4), held(5), held(6)]; - rt.sliceCloneFromSlice(rt.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a02)); - }, undefined, rt.byteVecCloneFromFn()); + const slice: rs.ByteVec[] = [held(4), held(5), held(6)]; + rs.sliceCloneFromSlice(rs.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); + }, undefined, rs.byteVecCloneFromFn()); _17(slice, out); - rt.sliceFill(slice, source(9), (a03: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a03)); - }, undefined, rt.byteVecCloneFromFn()); + rs.sliceFill(slice, source(9), (a03: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a03)); + }, undefined, rs.byteVecCloneFromFn()); _17(slice, out); const part6 = len(10); - const nested: rt.Vec = holds(11, part6); + const nested: rs.Vec = holds(11, part6); const part7 = len(14); - const _88: rt.Vec = sources(15, part7); - rt.vecCloneFrom(nested, _88, 12, (a04: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a04)); - }, undefined, rt.byteVecCloneFromFn()); + const _88: rs.Vec = sources(15, part7); + rs.vecCloneFrom(nested, _88, 12, (a04: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a04)); + }, undefined, rs.byteVecCloneFromFn()); _17(nested.items, out); const part9 = len(18); - const into: rt.Vec = holds(19, part9); + const into: rs.Vec = holds(19, part9); const part10 = len(22); - const _106: rt.ByteVec[] = rt.sliceRange(sources(23, part10).items, 0); - rt.vecCloneFrom(into, _106, 12, (a05: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a05)); - }, undefined, rt.byteVecCloneFromFn()); + const _106: rs.ByteVec[] = rs.sliceRange(sources(23, part10).items, 0); + rs.vecCloneFrom(into, _106, 12, (a05: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a05)); + }, undefined, rs.byteVecCloneFromFn()); _17(into.items, out); - const boxed: rt.ByteVec = held(26); - const _127: rt.ByteVec = source(27); - rt.byteVecCloneFrom(boxed, _127); + const boxed: rs.ByteVec = held(26); + const _127: rs.ByteVec = source(27); + rs.byteVecCloneFrom(boxed, _127); _17([boxed], out); const part13 = len(28); - let boxes: rt.ByteVec[] = holds(29, part13).items; + let boxes: rs.ByteVec[] = holds(29, part13).items; const part14 = len(32); - const _148: rt.ByteVec[] = sources(33, part14).items; - boxes = rt.boxSliceCloneFrom(boxes, _148, (a06: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a06)); - }, undefined, rt.byteVecCloneFromFn()); + const _148: rs.ByteVec[] = sources(33, part14).items; + boxes = rs.boxSliceCloneFrom(boxes, _148, (a06: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a06)); + }, undefined, rs.byteVecCloneFromFn()); _17(boxes, out); - let option: rt.ByteVec | undefined = then$0ozmvid(rt.u8Rem(at(36), 3) !== 0, (): rt.ByteVec => { + let option: rs.ByteVec | undefined = then$17csa2h(rs.u8Rem(at(36), 3) !== 0, (): rs.ByteVec => { return held(37); }); - const _172: rt.ByteVec | undefined = then$0ozmvid(rt.u8Rem(at(38), 3) !== 0, (): rt.ByteVec => { + const _172: rs.ByteVec | undefined = then$17csa2h(rs.u8Rem(at(38), 3) !== 0, (): rs.ByteVec => { return source(39); }); - option = rt.optionCloneFrom(option, _172, (a07: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a07)); - }, undefined, rt.byteVecCloneFromFn()); - const part16 = rt.iterToVec(rt.iterOption(option), undefined, 12, true).items; + option = rs.optionCloneFrom(option, _172, (a07: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a07)); + }, undefined, rs.byteVecCloneFromFn()); + const part16 = rs.iterToVec(rs.iterOption(option), undefined, 12, true).items; _17(part16, out); - if (rt.u8Rem(at(40), 2) === 0) { - result = rt.Ok(held(41)); + if (rs.u8Rem(at(40), 2) === 0) { + result = rs.Ok(held(41)); } else { - result = rt.Err(held(42)); + result = rs.Err(held(42)); } - const _202: rt.Place> = rt.place(() => result, (value2) => result = value2); - if (rt.u8Rem(at(43), 2) === 0) { - _204 = rt.Ok(source(44)); + const _202: rs.Place> = rs.place(() => result, (value2) => result = value2); + if (rs.u8Rem(at(43), 2) === 0) { + _204 = rs.Ok(source(44)); } else { - _204 = rt.Err(source(45)); + _204 = rs.Err(source(45)); } - _202.v = rt.resultCloneFrom(_202.v, _204, (a08: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a08)); - }, undefined, rt.byteVecCloneFromFn(), (a09: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a09)); - }, undefined, rt.byteVecCloneFromFn()); - rt.byteVecPush(out, result.ok ? 1 : 0); - const part17 = [result_unwrapOrElse$1bt75f9(result, (v2: rt.ByteVec): rt.ByteVec => { + _202.v = rs.resultCloneFrom(_202.v, _204, (a08: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a08)); + }, undefined, rs.byteVecCloneFromFn(), (a09: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a09)); + }, undefined, rs.byteVecCloneFromFn()); + rs.byteVecPush(out, result.ok ? 1 : 0); + const part17 = [result_unwrapOrElse$0pqj9wx(result, (v2: rs.ByteVec): rs.ByteVec => { return v2; })]; _17(part17, out); - let cell: rt.RefCell = new rt.RefCell(held(46)); - const _235: rt.RefCell = new rt.RefCell(source(47)); - cell = rt.refCellCloneFrom(cell, _235, (a010: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a010)); - }, undefined, rt.byteVecCloneFromFn()); + let cell: rs.RefCell = new rs.RefCell(held(46)); + const _235: rs.RefCell = new rs.RefCell(source(47)); + cell = rs.refCellCloneFrom(cell, _235, (a010: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a010)); + }, undefined, rs.byteVecCloneFromFn()); _17([cell.value], out); - let deep: rt.ByteVec[] | undefined = [held(52)]; - const _256: rt.ByteVec[] | undefined = [source(53)]; - deep = rt.optionCloneFrom(deep, _256, (a011: rt.ByteVec[]): rt.ByteVec[] => { - return a011.map((a012: rt.ByteVec): rt.ByteVec => { - return ((a013: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a013)); + let deep: rs.ByteVec[] | undefined = [held(52)]; + const _256: rs.ByteVec[] | undefined = [source(53)]; + deep = rs.optionCloneFrom(deep, _256, (a011: rs.ByteVec[]): rs.ByteVec[] => { + return a011.map((a012: rs.ByteVec): rs.ByteVec => { + return ((a013: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a013)); })(a012); }); - }, undefined, rt.sliceCloneFromSliceFn((a014: rt.ByteVec): rt.ByteVec => { - return ((a015: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a015)); + }, undefined, rs.sliceCloneFromSliceFn((a014: rs.ByteVec): rs.ByteVec => { + return ((a015: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a015)); })(a014); - }, undefined, rt.byteVecCloneFromFn())); - const part19 = rt.iterToVec(rt.iterOption(option_map$1p5j86b(deep, (_27: rt.ByteVec[]): rt.ByteVec => { + }, undefined, rs.byteVecCloneFromFn())); + const part19 = rs.iterToVec(rs.iterOption(option_map$1o9z3sm(deep, (_27: rs.ByteVec[]): rs.ByteVec => { return _27[0]; })), undefined, 12, true).items; _17(part19, out); const part20 = len(54); - const _272: rt.Iter = rt.vecIntoIter(holds(55, part20)); - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _272); + const _272: rs.Iter = rs.vecIntoIter(holds(55, part20)); + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _272); const part21 = len(58); - const _283: rt.Iter = rt.vecIntoIter(sources(59, part21)); - const _282: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _283); - rt.listCloneFrom(list, _282, (a016: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a016)); - }, undefined, rt.byteVecCloneFromFn()); - const part22 = rt.iterToVec(rt.listIter(list), undefined, 12, true).items; + const _283: rs.Iter = rs.vecIntoIter(sources(59, part21)); + const _282: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _283); + rs.listCloneFrom(list, _282, (a016: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a016)); + }, undefined, rs.byteVecCloneFromFn()); + const part22 = rs.iterToVec(rs.listIter(list), undefined, 12, true).items; _17(part22, out); const part23 = len(62); - const deque: rt.VecDeque = rt.dequeFromVec(holds(63, part23), 12) as rt.VecDeque; + const deque: rs.VecDeque = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque; const part24 = len(66); - const _308: rt.VecDeque = rt.dequeFromVec(sources(67, part24), 12) as rt.VecDeque; - rt.dequeCloneFrom(deque, _308, (a017: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a017)); + const _308: rs.VecDeque = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque; + rs.dequeCloneFrom(deque, _308, (a017: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a017)); }); - const part25 = rt.dequeToVec(deque).items; + const part25 = rs.dequeToVec(deque).items; _17(part25, out); - let heap: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(held(70)), rt.le, rt.ge, rt.lt); - const _329: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(source(71)), rt.le, rt.ge, rt.lt); - heap = rt.heapCloneFrom(heap, _329, 1); - const part26 = [rt.byteVecFromVec(heap)]; + let heap: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(held(70)), rs.le, rs.ge, rs.lt); + const _329: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(source(71)), rs.le, rs.ge, rs.lt); + heap = rs.heapCloneFrom(heap, _329, 1); + const part26 = [rs.byteVecFromVec(heap)]; _17(part26, out); - const heaps: rt.BinaryHeap[] = [rt.heapFrom(rt.byteVecToVec(held(72)), rt.le, rt.ge, rt.lt)]; - const _349: rt.BinaryHeap[] = [rt.heapFrom(rt.byteVecToVec(source(73)), rt.le, rt.ge, rt.lt)]; - rt.sliceCloneFromSlice(heaps, _349, (a018: rt.BinaryHeap): rt.BinaryHeap => { - return rt.heapClone(a018, undefined); - }, undefined, rt.heapCloneFromFn(1)); - put(out, rt.vecCapacity(heaps[0], 1)); - const deques: rt.VecDeque[] = [rt.dequeFromVec(rt.byteVecToVec(held(74)), 1, true) as rt.VecDeque]; - const _367: rt.VecDeque[] = [rt.dequeFromVec(rt.byteVecToVec(source(75)), 1, true) as rt.VecDeque]; - rt.sliceCloneFromSlice(deques, _367, (a019: rt.VecDeque): rt.VecDeque => { - return rt.dequeClone(a019); - }, undefined, rt.dequeCloneFromFn()); - put(out, rt.dequeCapacity(deques[0])); - let pair: [rt.ByteVec, rt.u8] = [held(76), 0]; - pair = rt.tupleClone([source(77), 1] as [rt.ByteVec, rt.u8], [(a020: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a020)); + const heaps: rs.BinaryHeap[] = [rs.heapFrom(rs.byteVecToVec(held(72)), rs.le, rs.ge, rs.lt)]; + const _349: rs.BinaryHeap[] = [rs.heapFrom(rs.byteVecToVec(source(73)), rs.le, rs.ge, rs.lt)]; + rs.sliceCloneFromSlice(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a018, undefined); + }, undefined, rs.heapCloneFromFn(1)); + put(out, rs.vecCapacity(heaps[0], 1)); + const deques: rs.VecDeque[] = [rs.dequeFromVec(rs.byteVecToVec(held(74)), 1, true) as rs.VecDeque]; + const _367: rs.VecDeque[] = [rs.dequeFromVec(rs.byteVecToVec(source(75)), 1, true) as rs.VecDeque]; + rs.sliceCloneFromSlice(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a019); + }, undefined, rs.dequeCloneFromFn()); + put(out, rs.dequeCapacity(deques[0])); + let pair: [rs.ByteVec, rs.u8] = [held(76), 0]; + pair = rs.tupleClone([source(77), 1] as [rs.ByteVec, rs.u8], [(a020: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a020)); }, undefined]); - let holder: Holds.Holds = new Holds.Holds(held(78)); + let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_u8(new Holds.Holds(source(79))); - _17([pair[0], holder._0 as rt.ByteVec], out); + _17([pair[0], holder._0 as rs.ByteVec], out); } -export function cloneFromSteps$unit(data: rt.ByteSlice, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { - let result!: rt.Result, rt.Vec>; - let _204!: rt.Result, rt.Vec>; - const _17: (a0: rt.Vec[], a1: rt.ByteVec) => undefined = (vs: rt.Vec[], out2: rt.ByteVec): undefined => { +export function cloneFromSteps$unit(data: rs.ByteSlice, make: (a0: rs.u8) => undefined, out: rs.ByteVec): void { + let result!: rs.Result, rs.Vec>; + let _204!: rs.Result, rs.Vec>; + const _17: (a0: rs.Vec[], a1: rs.ByteVec) => undefined = (vs: rs.Vec[], out2: rs.ByteVec): undefined => { put(out2, vs.length); for (const _8 of vs) { put(out2, _8.items.length); - put(out2, rt.vecCapacity(_8, 0)); + put(out2, rs.vecCapacity(_8, 0)); } }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 53) ^ (data.length & 0xff)); }; - const held: (a0: rt.usize) => rt.Vec = (i2: rt.usize): rt.Vec => { - let v!: rt.Vec; - let _192!: rt.u8; - const b: rt.u8 = at(i2); + const held: (a0: rs.usize) => rs.Vec = (i2: rs.usize): rs.Vec => { + let v!: rs.Vec; + let _192!: rs.u8; + const b: rs.u8 = at(i2); if ((b & 1) === 1) { - v = rt.vecWithCapacity(b >> 4 as rt.usize, 0); + v = rs.vecWithCapacity(b >> 4 as rs.usize, 0); } else { - v = new rt.Vec(); + v = new rs.Vec(); } - const _132: rt.u8 = rt.u8Rem(b >> 1, 6); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _132; + const _132: rs.u8 = rs.u8Rem(b >> 1, 6); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _132; while (true) { if (!((_192 = iterStart++) < iterEnd)) { return v; } - const j: rt.u8 = _192; - const _243: rt.Vec = v; + const j: rs.u8 = _192; + const _243: rs.Vec = v; make(j); _243.items.push(undefined); } }; - const source: (a0: rt.usize) => rt.Vec = (i3: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(i3), 10)), make), undefined, 0, true); + const source: (a0: rs.usize) => rs.Vec = (i3: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(i3), 10)), make), undefined, 0, true); }; - const len: (a0: rt.usize) => rt.usize = (i4: rt.usize): rt.usize => { - return rt.u8Rem(at(i4), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i4: rs.usize): rs.usize => { + return rs.u8Rem(at(i4), 4) as rs.usize; }; - const holds: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from: rt.usize, n: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (j2: rt.usize): rt.Vec => { - return held(rt.usizeAdd(from, j2)); + const holds: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from: rs.usize, n: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (j2: rs.usize): rs.Vec => { + return held(rs.usizeAdd(from, j2)); }), undefined, 12, true); }; - const sources: (a0: rt.usize, a1: rt.usize) => rt.Vec> = (from2: rt.usize, n2: rt.usize): rt.Vec> => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (j3: rt.usize): rt.Vec => { - return source(rt.usizeAdd(from2, j3)); + const sources: (a0: rs.usize, a1: rs.usize) => rs.Vec> = (from2: rs.usize, n2: rs.usize): rs.Vec> => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (j3: rs.usize): rs.Vec => { + return source(rs.usizeAdd(from2, j3)); }), undefined, 12, true); }; - const array: rt.Vec[] = [held(0), held(1)]; - const _28: rt.Vec[] = [source(2), source(3)]; - rt.sliceCloneFromSlice(array, _28, (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + const array: rs.Vec[] = [held(0), held(1)]; + const _28: rs.Vec[] = [source(2), source(3)]; + rs.sliceCloneFromSlice(array, _28, (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(array, out); - const slice: rt.Vec[] = [held(4), held(5), held(6)]; - rt.sliceCloneFromSlice(rt.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + const slice: rs.Vec[] = [held(4), held(5), held(6)]; + rs.sliceCloneFromSlice(rs.sliceRangeMut(slice, 1), [source(7), source(8)], (a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(slice, out); - rt.sliceFill(slice, source(9), (a03: rt.Vec): rt.Vec => { - return rt.vecFrom(a03.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + rs.sliceFill(slice, source(9), (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(slice, out); const part6 = len(10); - const nested: rt.Vec> = holds(11, part6); + const nested: rs.Vec> = holds(11, part6); const part7 = len(14); - const _88: rt.Vec> = sources(15, part7); - rt.vecCloneFrom(nested, _88, 12, (a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + const _88: rs.Vec> = sources(15, part7); + rs.vecCloneFrom(nested, _88, 12, (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(nested.items, out); const part9 = len(18); - const into: rt.Vec> = holds(19, part9); + const into: rs.Vec> = holds(19, part9); const part10 = len(22); - const _106: rt.Vec[] = rt.sliceRange(sources(23, part10).items, 0); - rt.vecCloneFrom(into, _106, 12, (a05: rt.Vec): rt.Vec => { - return rt.vecFrom(a05.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + const _106: rs.Vec[] = rs.sliceRange(sources(23, part10).items, 0); + rs.vecCloneFrom(into, _106, 12, (a05: rs.Vec): rs.Vec => { + return rs.vecFrom(a05.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(into.items, out); - const boxed: rt.Vec = held(26); - const _127: rt.Vec = source(27); - rt.vecCloneFrom(boxed, _127, 0); + const boxed: rs.Vec = held(26); + const _127: rs.Vec = source(27); + rs.vecCloneFrom(boxed, _127, 0); _17([boxed], out); const part13 = len(28); - let boxes: rt.Vec[] = holds(29, part13).items; + let boxes: rs.Vec[] = holds(29, part13).items; const part14 = len(32); - const _148: rt.Vec[] = sources(33, part14).items; - boxes = rt.boxSliceCloneFrom(boxes, _148, (a06: rt.Vec): rt.Vec => { - return rt.vecFrom(a06.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + const _148: rs.Vec[] = sources(33, part14).items; + boxes = rs.boxSliceCloneFrom(boxes, _148, (a06: rs.Vec): rs.Vec => { + return rs.vecFrom(a06.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17(boxes, out); - let option: rt.Vec | undefined = then$1svdnnn(rt.u8Rem(at(36), 3) !== 0, (): rt.Vec => { + let option: rs.Vec | undefined = then$0g2g1ls(rs.u8Rem(at(36), 3) !== 0, (): rs.Vec => { return held(37); }); - const _172: rt.Vec | undefined = then$1svdnnn(rt.u8Rem(at(38), 3) !== 0, (): rt.Vec => { + const _172: rs.Vec | undefined = then$0g2g1ls(rs.u8Rem(at(38), 3) !== 0, (): rs.Vec => { return source(39); }); - option = rt.optionCloneFrom(option, _172, (a07: rt.Vec): rt.Vec => { - return rt.vecFrom(a07.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); - const part16 = rt.iterToVec(rt.iterOption(option), undefined, 12, true).items; + option = rs.optionCloneFrom(option, _172, (a07: rs.Vec): rs.Vec => { + return rs.vecFrom(a07.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); + const part16 = rs.iterToVec(rs.iterOption(option), undefined, 12, true).items; _17(part16, out); - if (rt.u8Rem(at(40), 2) === 0) { - result = rt.Ok(held(41)); + if (rs.u8Rem(at(40), 2) === 0) { + result = rs.Ok(held(41)); } else { - result = rt.Err(held(42)); + result = rs.Err(held(42)); } - const _202: rt.Place, rt.Vec>> = rt.place(() => result, (value2) => result = value2); - if (rt.u8Rem(at(43), 2) === 0) { - _204 = rt.Ok(source(44)); + const _202: rs.Place, rs.Vec>> = rs.place(() => result, (value2) => result = value2); + if (rs.u8Rem(at(43), 2) === 0) { + _204 = rs.Ok(source(44)); } else { - _204 = rt.Err(source(45)); + _204 = rs.Err(source(45)); } - _202.v = rt.resultCloneFrom(_202.v, _204, (a08: rt.Vec): rt.Vec => { - return rt.vecFrom(a08.items.slice()); - }, undefined, rt.vecCloneFromFn(0), (a09: rt.Vec): rt.Vec => { - return rt.vecFrom(a09.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); - rt.byteVecPush(out, result.ok ? 1 : 0); - const part17 = [result_unwrapOrElse$1341i4f(result, (v2: rt.Vec): rt.Vec => { + _202.v = rs.resultCloneFrom(_202.v, _204, (a08: rs.Vec): rs.Vec => { + return rs.vecFrom(a08.items.slice()); + }, undefined, rs.vecCloneFromFn(0), (a09: rs.Vec): rs.Vec => { + return rs.vecFrom(a09.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); + rs.byteVecPush(out, result.ok ? 1 : 0); + const part17 = [result_unwrapOrElse$01ys8fc(result, (v2: rs.Vec): rs.Vec => { return v2; })]; _17(part17, out); - let cell: rt.RefCell> = new rt.RefCell(held(46)); - const _235: rt.RefCell> = new rt.RefCell(source(47)); - cell = rt.refCellCloneFrom(cell, _235, (a010: rt.Vec): rt.Vec => { - return rt.vecFrom(a010.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); + let cell: rs.RefCell> = new rs.RefCell(held(46)); + const _235: rs.RefCell> = new rs.RefCell(source(47)); + cell = rs.refCellCloneFrom(cell, _235, (a010: rs.Vec): rs.Vec => { + return rs.vecFrom(a010.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); _17([cell.value], out); - let deep: rt.Vec[] | undefined = [held(52)]; - const _256: rt.Vec[] | undefined = [source(53)]; - deep = rt.optionCloneFrom(deep, _256, (a011: rt.Vec[]): rt.Vec[] => { - return a011.map((a012: rt.Vec): rt.Vec => { - return ((a013: rt.Vec): rt.Vec => { - return rt.vecFrom(a013.items.slice()); + let deep: rs.Vec[] | undefined = [held(52)]; + const _256: rs.Vec[] | undefined = [source(53)]; + deep = rs.optionCloneFrom(deep, _256, (a011: rs.Vec[]): rs.Vec[] => { + return a011.map((a012: rs.Vec): rs.Vec => { + return ((a013: rs.Vec): rs.Vec => { + return rs.vecFrom(a013.items.slice()); })(a012); }); - }, undefined, rt.sliceCloneFromSliceFn((a014: rt.Vec): rt.Vec => { - return ((a015: rt.Vec): rt.Vec => { - return rt.vecFrom(a015.items.slice()); + }, undefined, rs.sliceCloneFromSliceFn((a014: rs.Vec): rs.Vec => { + return ((a015: rs.Vec): rs.Vec => { + return rs.vecFrom(a015.items.slice()); })(a014); - }, undefined, rt.vecCloneFromFn(0))); - const part19 = rt.iterToVec(rt.iterOption(option_map$0197mxk(deep, (_25: rt.Vec[]): rt.Vec => { + }, undefined, rs.vecCloneFromFn(0))); + const part19 = rs.iterToVec(rs.iterOption(option_map$1d4d0v7(deep, (_25: rs.Vec[]): rs.Vec => { return _25[0]; })), undefined, 12, true).items; _17(part19, out); const part20 = len(54); - const _272: rt.Iter> = rt.vecIntoIter(holds(55, part20)); - const list: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _272); + const _272: rs.Iter> = rs.vecIntoIter(holds(55, part20)); + const list: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _272); const part21 = len(58); - const _283: rt.Iter> = rt.vecIntoIter(sources(59, part21)); - const _282: rt.LinkedList> = rt.listExtend(rt.listNew() as rt.LinkedList>, _283); - rt.listCloneFrom(list, _282, (a016: rt.Vec): rt.Vec => { - return rt.vecFrom(a016.items.slice()); - }, undefined, rt.vecCloneFromFn(0)); - const part22 = rt.iterToVec(rt.listIter(list), undefined, 12, true).items; + const _283: rs.Iter> = rs.vecIntoIter(sources(59, part21)); + const _282: rs.LinkedList> = rs.listExtend(rs.listNew() as rs.LinkedList>, _283); + rs.listCloneFrom(list, _282, (a016: rs.Vec): rs.Vec => { + return rs.vecFrom(a016.items.slice()); + }, undefined, rs.vecCloneFromFn(0)); + const part22 = rs.iterToVec(rs.listIter(list), undefined, 12, true).items; _17(part22, out); const part23 = len(62); - const deque: rt.VecDeque> = rt.dequeFromVec(holds(63, part23), 12) as rt.VecDeque>; + const deque: rs.VecDeque> = rs.dequeFromVec(holds(63, part23), 12) as rs.VecDeque>; const part24 = len(66); - const _308: rt.VecDeque> = rt.dequeFromVec(sources(67, part24), 12) as rt.VecDeque>; - rt.dequeCloneFrom(deque, _308, (a017: rt.Vec): rt.Vec => { - return rt.vecFrom(a017.items.slice()); + const _308: rs.VecDeque> = rs.dequeFromVec(sources(67, part24), 12) as rs.VecDeque>; + rs.dequeCloneFrom(deque, _308, (a017: rs.Vec): rs.Vec => { + return rs.vecFrom(a017.items.slice()); }); - const part25 = rt.dequeToVec(deque).items; + const part25 = rs.dequeToVec(deque).items; _17(part25, out); - let heap: rt.BinaryHeap = rt.heapFrom(held(70), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); - const _329: rt.BinaryHeap = rt.heapFrom(source(71), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); - heap = rt.heapCloneFrom(heap, _329, 0); + let heap: rs.BinaryHeap = rs.heapFrom(held(70), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing)); + const _329: rs.BinaryHeap = rs.heapFrom(source(71), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing)); + heap = rs.heapCloneFrom(heap, _329, 0); _17([heap], out); - const heaps: rt.BinaryHeap[] = [rt.heapFrom(held(72), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing))]; - const _349: rt.BinaryHeap[] = [rt.heapFrom(source(73), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing))]; - rt.sliceCloneFromSlice(heaps, _349, (a018: rt.BinaryHeap): rt.BinaryHeap => { - return rt.heapClone(a018, undefined); - }, undefined, rt.heapCloneFromFn(0)); - put(out, rt.vecCapacity(heaps[0], 0)); - const deques: rt.VecDeque[] = [rt.dequeFromVec(held(74), 0) as rt.VecDeque]; - const _367: rt.VecDeque[] = [rt.dequeFromVec(source(75), 0) as rt.VecDeque]; - rt.sliceCloneFromSlice(deques, _367, (a019: rt.VecDeque): rt.VecDeque => { - return rt.dequeClone(a019); - }, undefined, rt.dequeCloneFromFn()); - put(out, rt.dequeCapacity(deques[0])); - let pair: [rt.Vec, rt.u8] = [held(76), 0]; - pair = rt.tupleClone([source(77), 1] as [rt.Vec, rt.u8], [(a020: rt.Vec): rt.Vec => { - return rt.vecFrom(a020.items.slice()); + const heaps: rs.BinaryHeap[] = [rs.heapFrom(held(72), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing))]; + const _349: rs.BinaryHeap[] = [rs.heapFrom(source(73), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing))]; + rs.sliceCloneFromSlice(heaps, _349, (a018: rs.BinaryHeap): rs.BinaryHeap => { + return rs.heapClone(a018, undefined); + }, undefined, rs.heapCloneFromFn(0)); + put(out, rs.vecCapacity(heaps[0], 0)); + const deques: rs.VecDeque[] = [rs.dequeFromVec(held(74), 0) as rs.VecDeque]; + const _367: rs.VecDeque[] = [rs.dequeFromVec(source(75), 0) as rs.VecDeque]; + rs.sliceCloneFromSlice(deques, _367, (a019: rs.VecDeque): rs.VecDeque => { + return rs.dequeClone(a019); + }, undefined, rs.dequeCloneFromFn()); + put(out, rs.dequeCapacity(deques[0])); + let pair: [rs.Vec, rs.u8] = [held(76), 0]; + pair = rs.tupleClone([source(77), 1] as [rs.Vec, rs.u8], [(a020: rs.Vec): rs.Vec => { + return rs.vecFrom(a020.items.slice()); }, undefined]); let holder: Holds.Holds = new Holds.Holds(held(78)); holder = Holds.clone$Clone_unit(new Holds.Holds(source(79))); - _17([pair[0], holder._0 as rt.Vec], out); + _17([pair[0], holder._0 as rs.Vec], out); } /** A `VecDeque`, as `vecs` steps a `Vec`. */ -export function deques(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 5); +export function deques(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 5); if (_5 === 0) { - dequeSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + dequeSteps$u8(dataData, dataStart, dataLen, (b3: rs.u8): rs.u8 => { return b3; }, out); } else if (_5 === 1) { - dequeSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + dequeSteps$u16(dataData, dataStart, dataLen, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }, out); } else if (_5 === 2) { - dequeSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { - return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + dequeSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rs.u8): [rs.u64, rs.u8] => { + return [b2 as rs.u64, b2] as [rs.u64, rs.u8]; }, out); } else if (_5 === 3) { - dequeSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { - const _3: rt.u64 = b as rt.u64; - return Array.from({ length: 160 }, (): rt.u64 => { + dequeSteps$array160_u64(dataData, dataStart, dataLen, (b: rs.u8): rs.u64[] => { + const _3: rs.u64 = b as rs.u64; + return Array.from({ length: 160 }, (): rs.u64 => { return _3; }); }, out); } else { - dequeSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + dequeSteps$unit(dataData, dataStart, dataLen, (_2: rs.u8): undefined => {}, out); } } -export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { - let q!: rt.VecDeque; - let newLen!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 1280; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function dequeSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { + let q!: rs.VecDeque; + let newLen!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 1280; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1280) as rt.VecDeque; + q = rs.dequeWithCapacity(first >> 3 as rs.usize, 1280) as rs.VecDeque; } else { - q = rt.dequeNew(1280) as rt.VecDeque; + q = rs.dequeNew(1280) as rs.VecDeque; } - put(out, rt.dequeCapacity(q)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.dequeCapacity(q)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 28); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 28); if (_39 === 0) { - rt.dequePushBack(q, copy$array_u64(make(arg))); + rs.dequePushBack(q, copy$array_u64(make(arg))); } else if (_39 === 1) { - rt.dequePushFront(q, copy$array_u64(make(arg))); + rs.dequePushFront(q, copy$array_u64(make(arg))); } else if (_39 === 2) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 3) { - rt.dequeReserve(q, additional); + const additional: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 3) { + rs.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional); + rs.dequeReserveExact(q, additional); } } else if (_39 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + rs.dequeShrinkTo(q, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_39 === 7) { - rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + rs.dequeTruncate(q, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$array_u64(make(arg))); + rs.dequeInsert(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)), copy$array_u64(make(arg))); } else if (_39 === 9) { - rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + rs.dequeRemove(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); } else if (_39 === 10) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_26: rt.u64[]): boolean => { + rs.dequeRetain(q, (_26: rs.u64[]): boolean => { return keep(); }); } else if (_39 === 14) { - rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { - q = rt.dequeClone(q, copy$array_u64); + q = rs.dequeClone(q, copy$array_u64); } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1280) as rt.VecDeque; + q = rs.dequeFromIntoIter(rs.dequeIntoIter(q), 1280) as rs.VecDeque; } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 1280, true), 1280) as rt.VecDeque; + q = rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 1280, true), 1280) as rs.VecDeque; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.dequeIntoIter(q), (_25: rt.u64[]): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: rs.u64[]): boolean => { return keep2(); - }), "next", 1280), 1280) as rt.VecDeque; + }), "next", 1280), 1280) as rs.VecDeque; } else if (_39 === 19) { - const it: rt.Iter = rt.dequeIntoIter(q); - const _127: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _127; + const it: rs.Iter = rs.dequeIntoIter(q); + const _127: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _127; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rt.VecDeque; - const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1280) as rt.VecDeque; + q = rs.dequeFromIntoIter(it.clone({ v: copy$array_u64 }), 1280) as rs.VecDeque; + const rest: rs.VecDeque = rs.dequeFromIntoIter(it, 1280) as rs.VecDeque; put(out, rest.n); - put(out, rt.dequeCapacity(rest)); + put(out, rs.dequeCapacity(rest)); } else if (_39 === 20) { - q = rt.dequeFromArray([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))], 1280) as rt.VecDeque; + q = rs.dequeFromArray([copy$array_u64(make(arg)), copy$array_u64(make(arg)), copy$array_u64(make(arg))], 1280) as rs.VecDeque; } else if (_39 === 21) { - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1280) as rt.VecDeque; - const _158: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.dequeExtend(other, _158, undefined, true); - rt.dequeAppend(q, other); + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1280) as rs.VecDeque; + const _158: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.dequeExtend(other, _158, undefined, true); + rs.dequeAppend(q, other); put(out, other.n); - put(out, rt.dequeCapacity(other)); + put(out, rs.dequeCapacity(other)); } else if (_39 === 22 || _39 === 23) { b5: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b5; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 28) === 22) { - rt.dequeResize(q, newLen, copy$array_u64(make(arg)), copy$array_u64); + if (rs.u8Rem(op, 28) === 22) { + rs.dequeResize(q, newLen, copy$array_u64(make(arg)), copy$array_u64); } else { - rt.dequeResizeWith(q, newLen, (): rt.u64[] => { + rs.dequeResizeWith(q, newLen, (): rs.u64[] => { return make(arg); }); } } else if (_39 === 24) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + const tail: rs.VecDeque = rs.dequeSplitOff(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); put(out, tail.n); - put(out, rt.dequeCapacity(tail)); + put(out, rs.dequeCapacity(tail)); } else if (_39 === 25) { - q = rt.dequeFromVec(rt.dequeToVec(q), 1280) as rt.VecDeque; + q = rs.dequeFromVec(rs.dequeToVec(q), 1280) as rs.VecDeque; } else { - const additional2: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 26) { - tried = rt.dequeTryReserve(q, additional2); + const additional2: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 26) { + tried = rs.dequeTryReserve(q, additional2); } else { - tried = rt.dequeTryReserveExact(q, additional2); + tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } put(out, q.n); - put(out, rt.dequeCapacity(q)); + put(out, rs.dequeCapacity(q)); } } -export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { - let q!: rt.VecDeque<[rt.u64, rt.u8]>; - let newLen!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 16; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function dequeSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => [rs.u64, rs.u8], out: rs.ByteVec): void { + let q!: rs.VecDeque<[rs.u64, rs.u8]>; + let newLen!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 16; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeWithCapacity(first >> 3 as rs.usize, 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else { - q = rt.dequeNew(16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeNew(16) as rs.VecDeque<[rs.u64, rs.u8]>; } - put(out, rt.dequeCapacity(q)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.dequeCapacity(q)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 28); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 28); if (_39 === 0) { - rt.dequePushBack(q, copy$tuple2_u64_u8(make(arg))); + rs.dequePushBack(q, copy$tuple2_u64_u8(make(arg))); } else if (_39 === 1) { - rt.dequePushFront(q, copy$tuple2_u64_u8(make(arg))); + rs.dequePushFront(q, copy$tuple2_u64_u8(make(arg))); } else if (_39 === 2) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 3) { - rt.dequeReserve(q, additional); + const additional: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 3) { + rs.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional); + rs.dequeReserveExact(q, additional); } } else if (_39 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + rs.dequeShrinkTo(q, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_39 === 7) { - rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + rs.dequeTruncate(q, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg))); + rs.dequeInsert(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)), copy$tuple2_u64_u8(make(arg))); } else if (_39 === 9) { - rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + rs.dequeRemove(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); } else if (_39 === 10) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_26: [rt.u64, rt.u8]): boolean => { + rs.dequeRetain(q, (_26: [rs.u64, rs.u8]): boolean => { return keep(); }); } else if (_39 === 14) { - rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { - q = rt.dequeClone(q, copy$tuple2_u64_u8); + q = rs.dequeClone(q, copy$tuple2_u64_u8); } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeFromIntoIter(rs.dequeIntoIter(q), 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 16, true), 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.dequeIntoIter(q), (_25: [rt.u64, rt.u8]): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: [rs.u64, rs.u8]): boolean => { return keep2(); - }), "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + }), "next", 16), 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else if (_39 === 19) { - const it: rt.Iter<[rt.u64, rt.u8]> = rt.dequeIntoIter(q); - const _127: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _127; + const it: rs.Iter<[rs.u64, rs.u8]> = rs.dequeIntoIter(q); + const _127: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _127; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - const rest: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromIntoIter(it, 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeFromIntoIter(it.clone({ v: copy$tuple2_u64_u8 }), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + const rest: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromIntoIter(it, 16) as rs.VecDeque<[rs.u64, rs.u8]>; put(out, rest.n); - put(out, rt.dequeCapacity(rest)); + put(out, rs.dequeCapacity(rest)); } else if (_39 === 20) { - q = rt.dequeFromArray([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))], 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeFromArray([copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8(make(arg))], 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else if (_39 === 21) { - const other: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 16) as rt.VecDeque<[rt.u64, rt.u8]>; - const _158: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.dequeExtend(other, _158, undefined, true); - rt.dequeAppend(q, other); + const other: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 16) as rs.VecDeque<[rs.u64, rs.u8]>; + const _158: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.dequeExtend(other, _158, undefined, true); + rs.dequeAppend(q, other); put(out, other.n); - put(out, rt.dequeCapacity(other)); + put(out, rs.dequeCapacity(other)); } else if (_39 === 22 || _39 === 23) { b5: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b5; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 28) === 22) { - rt.dequeResize(q, newLen, copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8); + if (rs.u8Rem(op, 28) === 22) { + rs.dequeResize(q, newLen, copy$tuple2_u64_u8(make(arg)), copy$tuple2_u64_u8); } else { - rt.dequeResizeWith(q, newLen, (): [rt.u64, rt.u8] => { + rs.dequeResizeWith(q, newLen, (): [rs.u64, rs.u8] => { return make(arg); }); } } else if (_39 === 24) { - const tail: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeSplitOff(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + const tail: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeSplitOff(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); put(out, tail.n); - put(out, rt.dequeCapacity(tail)); + put(out, rs.dequeCapacity(tail)); } else if (_39 === 25) { - q = rt.dequeFromVec(rt.dequeToVec(q), 16) as rt.VecDeque<[rt.u64, rt.u8]>; + q = rs.dequeFromVec(rs.dequeToVec(q), 16) as rs.VecDeque<[rs.u64, rs.u8]>; } else { - const additional2: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 26) { - tried = rt.dequeTryReserve(q, additional2); + const additional2: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 26) { + tried = rs.dequeTryReserve(q, additional2); } else { - tried = rt.dequeTryReserveExact(q, additional2); + tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } put(out, q.n); - put(out, rt.dequeCapacity(q)); + put(out, rs.dequeCapacity(q)); } } -export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { - let q!: rt.VecDeque; - let newLen!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 2; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function dequeSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u16, out: rs.ByteVec): void { + let q!: rs.VecDeque; + let newLen!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 2; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 2) as rt.VecDeque; + q = rs.dequeWithCapacity(first >> 3 as rs.usize, 2) as rs.VecDeque; } else { - q = rt.dequeNew(2) as rt.VecDeque; + q = rs.dequeNew(2) as rs.VecDeque; } - put(out, rt.dequeCapacity(q)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.dequeCapacity(q)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 28); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 28); if (_39 === 0) { - rt.dequePushBack(q, make(arg)); + rs.dequePushBack(q, make(arg)); } else if (_39 === 1) { - rt.dequePushFront(q, make(arg)); + rs.dequePushFront(q, make(arg)); } else if (_39 === 2) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 3) { - rt.dequeReserve(q, additional); + const additional: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 3) { + rs.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional); + rs.dequeReserveExact(q, additional); } } else if (_39 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + rs.dequeShrinkTo(q, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_39 === 7) { - rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + rs.dequeTruncate(q, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); + rs.dequeInsert(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)), make(arg)); } else if (_39 === 9) { - rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + rs.dequeRemove(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); } else if (_39 === 10) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_26: rt.u16): boolean => { + rs.dequeRetain(q, (_26: rs.u16): boolean => { return keep(); }); } else if (_39 === 14) { - rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { - q = rt.dequeClone(q); + q = rs.dequeClone(q); } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 2) as rt.VecDeque; + q = rs.dequeFromIntoIter(rs.dequeIntoIter(q), 2) as rs.VecDeque; } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 2, true), 2) as rt.VecDeque; + q = rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 2, true), 2) as rs.VecDeque; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.dequeIntoIter(q), (_25: rt.u16): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: rs.u16): boolean => { return keep2(); - }), "next", 2), 2) as rt.VecDeque; + }), "next", 2), 2) as rs.VecDeque; } else if (_39 === 19) { - const it: rt.Iter = rt.dequeIntoIter(q); - const _127: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _127; + const it: rs.Iter = rs.dequeIntoIter(q); + const _127: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _127; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone(), 2) as rt.VecDeque; - const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 2) as rt.VecDeque; + q = rs.dequeFromIntoIter(it.clone(), 2) as rs.VecDeque; + const rest: rs.VecDeque = rs.dequeFromIntoIter(it, 2) as rs.VecDeque; put(out, rest.n); - put(out, rt.dequeCapacity(rest)); + put(out, rs.dequeCapacity(rest)); } else if (_39 === 20) { - q = rt.dequeFromArray([make(arg), make(arg), make(arg)], 2) as rt.VecDeque; + q = rs.dequeFromArray([make(arg), make(arg), make(arg)], 2) as rs.VecDeque; } else if (_39 === 21) { - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 2) as rt.VecDeque; - const _158: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.dequeExtend(other, _158, undefined, true); - rt.dequeAppend(q, other); + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 2) as rs.VecDeque; + const _158: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.dequeExtend(other, _158, undefined, true); + rs.dequeAppend(q, other); put(out, other.n); - put(out, rt.dequeCapacity(other)); + put(out, rs.dequeCapacity(other)); } else if (_39 === 22 || _39 === 23) { b5: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b5; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 28) === 22) { - rt.dequeResize(q, newLen, make(arg), undefined); + if (rs.u8Rem(op, 28) === 22) { + rs.dequeResize(q, newLen, make(arg), undefined); } else { - rt.dequeResizeWith(q, newLen, (): rt.u16 => { + rs.dequeResizeWith(q, newLen, (): rs.u16 => { return make(arg); }); } } else if (_39 === 24) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + const tail: rs.VecDeque = rs.dequeSplitOff(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); put(out, tail.n); - put(out, rt.dequeCapacity(tail)); + put(out, rs.dequeCapacity(tail)); } else if (_39 === 25) { - q = rt.dequeFromVec(rt.dequeToVec(q), 2) as rt.VecDeque; + q = rs.dequeFromVec(rs.dequeToVec(q), 2) as rs.VecDeque; } else { - const additional2: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 26) { - tried = rt.dequeTryReserve(q, additional2); + const additional2: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 26) { + tried = rs.dequeTryReserve(q, additional2); } else { - tried = rt.dequeTryReserveExact(q, additional2); + tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } put(out, q.n); - put(out, rt.dequeCapacity(q)); + put(out, rs.dequeCapacity(q)); } } -export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let q!: rt.VecDeque; - let newLen!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 1; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function dequeSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let q!: rs.VecDeque; + let newLen!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 1; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 1, true) as rt.VecDeque; + q = rs.dequeWithCapacity(first >> 3 as rs.usize, 1, true) as rs.VecDeque; } else { - q = rt.dequeNew(1, true) as rt.VecDeque; + q = rs.dequeNew(1, true) as rs.VecDeque; } - put(out, rt.dequeCapacity(q)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.dequeCapacity(q)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 28); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 28); if (_39 === 0) { - rt.dequePushBack(q, make(arg)); + rs.dequePushBack(q, make(arg)); } else if (_39 === 1) { - rt.dequePushFront(q, make(arg)); + rs.dequePushFront(q, make(arg)); } else if (_39 === 2) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 3) { - rt.dequeReserve(q, additional); + const additional: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 3) { + rs.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional); + rs.dequeReserveExact(q, additional); } } else if (_39 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + rs.dequeShrinkTo(q, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_39 === 7) { - rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + rs.dequeTruncate(q, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - rt.dequeInsert(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), make(arg)); + rs.dequeInsert(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)), make(arg)); } else if (_39 === 9) { - rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + rs.dequeRemove(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); } else if (_39 === 10) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_26: rt.u8): boolean => { + rs.dequeRetain(q, (_26: rs.u8): boolean => { return keep(); }); } else if (_39 === 14) { - rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { - q = rt.dequeClone(q); + q = rs.dequeClone(q); } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 1, true) as rt.VecDeque; + q = rs.dequeFromIntoIter(rs.dequeIntoIter(q), 1, true) as rs.VecDeque; } else if (_39 === 17) { - q = rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + q = rs.dequeFromVec(rs.byteVecToVec(rs.iterToByteVec(rs.dequeIntoIter(q), undefined, true)), 1, true) as rs.VecDeque; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.dequeIntoIter(q), (_25: rt.u8): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: rs.u8): boolean => { return keep2(); - }), "next", 1), 1, true) as rt.VecDeque; + }), "next", 1), 1, true) as rs.VecDeque; } else if (_39 === 19) { - const it: rt.Iter = rt.dequeIntoIter(q); - const _127: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _127; + const it: rs.Iter = rs.dequeIntoIter(q); + const _127: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _127; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - q = rt.dequeFromIntoIter(it.clone(), 1, true) as rt.VecDeque; - const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + q = rs.dequeFromIntoIter(it.clone(), 1, true) as rs.VecDeque; + const rest: rs.VecDeque = rs.dequeFromIntoIter(it, 1, true) as rs.VecDeque; put(out, rest.n); - put(out, rt.dequeCapacity(rest)); + put(out, rs.dequeCapacity(rest)); } else if (_39 === 20) { - q = rt.dequeFromArray(Uint8Array.of(make(arg), make(arg), make(arg)), 1, true) as rt.VecDeque; + q = rs.dequeFromArray(Uint8Array.of(make(arg), make(arg), make(arg)), 1, true) as rs.VecDeque; } else if (_39 === 21) { - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 1, true) as rt.VecDeque; - const _158: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.dequeExtend(other, _158, undefined, true); - rt.dequeAppend(q, other); + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 1, true) as rs.VecDeque; + const _158: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.dequeExtend(other, _158, undefined, true); + rs.dequeAppend(q, other); put(out, other.n); - put(out, rt.dequeCapacity(other)); + put(out, rs.dequeCapacity(other)); } else if (_39 === 22 || _39 === 23) { b5: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b5; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 28) === 22) { - rt.dequeResize(q, newLen, make(arg), undefined); + if (rs.u8Rem(op, 28) === 22) { + rs.dequeResize(q, newLen, make(arg), undefined); } else { - rt.dequeResizeWith(q, newLen, (): rt.u8 => { + rs.dequeResizeWith(q, newLen, (): rs.u8 => { return make(arg); }); } } else if (_39 === 24) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + const tail: rs.VecDeque = rs.dequeSplitOff(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); put(out, tail.n); - put(out, rt.dequeCapacity(tail)); + put(out, rs.dequeCapacity(tail)); } else if (_39 === 25) { - q = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFromVec(rt.dequeToVec(q))), 1, true) as rt.VecDeque; + q = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFromVec(rs.dequeToVec(q))), 1, true) as rs.VecDeque; } else { - const additional2: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 26) { - tried = rt.dequeTryReserve(q, additional2); + const additional2: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 26) { + tried = rs.dequeTryReserve(q, additional2); } else { - tried = rt.dequeTryReserveExact(q, additional2); + tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } put(out, q.n); - put(out, rt.dequeCapacity(q)); + put(out, rs.dequeCapacity(q)); } } -export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { - let q!: rt.VecDeque; - let newLen!: rt.usize; - let tried!: rt.Result; - const size: rt.usize = 0; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function dequeSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => undefined, out: rs.ByteVec): void { + let q!: rs.VecDeque; + let newLen!: rs.usize; + let tried!: rs.Result; + const size: rs.usize = 0; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - q = rt.dequeWithCapacity(first >> 3 as rt.usize, 0) as rt.VecDeque; + q = rs.dequeWithCapacity(first >> 3 as rs.usize, 0) as rs.VecDeque; } else { - q = rt.dequeNew(0) as rt.VecDeque; + q = rs.dequeNew(0) as rs.VecDeque; } - put(out, rt.dequeCapacity(q)); - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.dequeCapacity(q)); + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _39: rt.u8 = rt.u8Rem(op, 28); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _39: rs.u8 = rs.u8Rem(op, 28); if (_39 === 0) { - const _41: rt.VecDeque = q; + const _41: rs.VecDeque = q; make(arg); - rt.dequePushBack(_41, undefined); + rs.dequePushBack(_41, undefined); } else if (_39 === 1) { - const _43: rt.VecDeque = q; + const _43: rs.VecDeque = q; make(arg); - rt.dequePushFront(_43, undefined); + rs.dequePushFront(_43, undefined); } else if (_39 === 2) { - rt.dequePopFront(q, rt.None); + rs.dequePopFront(q, rs.None); } else if (_39 === 3 || _39 === 4) { - const additional: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 3) { - rt.dequeReserve(q, additional); + const additional: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 3) { + rs.dequeReserve(q, additional); } else { - rt.dequeReserveExact(q, additional); + rs.dequeReserveExact(q, additional); } } else if (_39 === 5) { - rt.dequeShrinkTo(q, rt.u8Rem(arg, 40) as rt.usize); + rs.dequeShrinkTo(q, rs.u8Rem(arg, 40) as rs.usize); } else if (_39 === 6) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_39 === 7) { - rt.dequeTruncate(q, rt.u8Rem(arg, 8) as rt.usize); + rs.dequeTruncate(q, rs.u8Rem(arg, 8) as rs.usize); } else if (_39 === 8) { - const _63: rt.VecDeque = q; - const _64: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + const _63: rs.VecDeque = q; + const _64: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); make(arg); - rt.dequeInsert(_63, _64, undefined); + rs.dequeInsert(_63, _64, undefined); } else if (_39 === 9) { - rt.dequeRemove(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)), rt.None); + rs.dequeRemove(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)), rs.None); } else if (_39 === 10) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make), "next"); } else if (_39 === 11) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 24)), make), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 24)), make), undefined, true); } else if (_39 === 12) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_39 === 13) { const keep: () => boolean = alternate(); - rt.dequeRetain(q, (_26: undefined): boolean => { + rs.dequeRetain(q, (_26: undefined): boolean => { return keep(); }); } else if (_39 === 14) { - rt.drop(rt.dequeDrain(q, { end: rt.min(q.n, rt.u8Rem(arg, 4) as rt.usize) })); + rs.drop(rs.dequeDrain(q, { end: rs.min(q.n, rs.u8Rem(arg, 4) as rs.usize) })); } else if (_39 === 15) { - q = rt.dequeClone(q); + q = rs.dequeClone(q); } else if (_39 === 16) { - q = rt.dequeFromIntoIter(rt.dequeIntoIter(q), 0) as rt.VecDeque; + q = rs.dequeFromIntoIter(rs.dequeIntoIter(q), 0) as rs.VecDeque; } else if (_39 === 17) { - q = rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + q = rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 0, true), 0) as rs.VecDeque; } else if (_39 === 18) { const keep2: () => boolean = alternate(); - q = rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.dequeIntoIter(q), (_25: undefined): boolean => { + q = rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.dequeIntoIter(q), (_25: undefined): boolean => { return keep2(); - }), "next", 0), 0) as rt.VecDeque; + }), "next", 0), 0) as rs.VecDeque; } else if (_39 === 19) { - const it: rt.Iter = rt.dequeIntoIter(q); - const _127: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _127; + const it: rs.Iter = rs.dequeIntoIter(q); + const _127: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _127; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next(), rt.None); + rs.iterToOption(it.next(), rs.None); } - q = rt.dequeFromIntoIter(it.clone(), 0) as rt.VecDeque; - const rest: rt.VecDeque = rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + q = rs.dequeFromIntoIter(it.clone(), 0) as rs.VecDeque; + const rest: rs.VecDeque = rs.dequeFromIntoIter(it, 0) as rs.VecDeque; put(out, rest.n); - put(out, rt.dequeCapacity(rest)); + put(out, rs.dequeCapacity(rest)); } else if (_39 === 20) { make(arg); make(arg); make(arg); - q = rt.dequeFromArray([undefined, undefined, undefined], 0) as rt.VecDeque; + q = rs.dequeFromArray([undefined, undefined, undefined], 0) as rs.VecDeque; } else if (_39 === 21) { - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 8) as rt.usize, 0) as rt.VecDeque; - const _158: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 12)), make); - rt.dequeExtend(other, _158, undefined, true); - rt.dequeAppend(q, other); + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 8) as rs.usize, 0) as rs.VecDeque; + const _158: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 12)), make); + rs.dequeExtend(other, _158, undefined, true); + rs.dequeAppend(q, other); put(out, other.n); - put(out, rt.dequeCapacity(other)); + put(out, rs.dequeCapacity(other)); } else if (_39 === 22 || _39 === 23) { b5: { if ((arg >> 5) === 6) { if (size > 0) { - newLen = rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, size), 1), (arg & 7) as rt.usize); + newLen = rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, size), 1), (arg & 7) as rs.usize); break b5; } } - newLen = rt.u8Rem(arg, 24) as rt.usize; + newLen = rs.u8Rem(arg, 24) as rs.usize; } - if (rt.u8Rem(op, 28) === 22) { - const _188: rt.VecDeque = q; + if (rs.u8Rem(op, 28) === 22) { + const _188: rs.VecDeque = q; make(arg); - rt.dequeResize(_188, newLen, undefined, undefined); + rs.dequeResize(_188, newLen, undefined, undefined); } else { - rt.dequeResizeWith(q, newLen, (): undefined => { + rs.dequeResizeWith(q, newLen, (): undefined => { make(arg); }); } } else if (_39 === 24) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1))); + const tail: rs.VecDeque = rs.dequeSplitOff(q, rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1))); put(out, tail.n); - put(out, rt.dequeCapacity(tail)); + put(out, rs.dequeCapacity(tail)); } else if (_39 === 25) { - q = rt.dequeFromVec(rt.dequeToVec(q), 0) as rt.VecDeque; + q = rs.dequeFromVec(rs.dequeToVec(q), 0) as rs.VecDeque; } else { - const additional2: rt.usize = amount(arg, q.n, size); - if (rt.u8Rem(op, 28) === 26) { - tried = rt.dequeTryReserve(q, additional2); + const additional2: rs.usize = amount(arg, q.n, size); + if (rs.u8Rem(op, 28) === 26) { + tried = rs.dequeTryReserve(q, additional2); } else { - tried = rt.dequeTryReserveExact(q, additional2); + tried = rs.dequeTryReserveExact(q, additional2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } put(out, q.n); - put(out, rt.dequeCapacity(q)); + put(out, rs.dequeCapacity(q)); } } /** A `BinaryHeap`, as `vecs` steps a `Vec`, and the `Vec` it gives up at the end. */ -export function heaps(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 5); +export function heaps(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 5); if (_5 === 0) { - heapSteps$u8(dataData, dataStart, dataLen, (b3: rt.u8): rt.u8 => { + heapSteps$u8(dataData, dataStart, dataLen, (b3: rs.u8): rs.u8 => { return b3; }, out); } else if (_5 === 1) { - heapSteps$u16(dataData, dataStart, dataLen, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + heapSteps$u16(dataData, dataStart, dataLen, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }, out); } else if (_5 === 2) { - heapSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rt.u8): [rt.u64, rt.u8] => { - return [b2 as rt.u64, b2] as [rt.u64, rt.u8]; + heapSteps$tuple2_u64_u8(dataData, dataStart, dataLen, (b2: rs.u8): [rs.u64, rs.u8] => { + return [b2 as rs.u64, b2] as [rs.u64, rs.u8]; }, out); } else if (_5 === 3) { - heapSteps$array160_u64(dataData, dataStart, dataLen, (b: rt.u8): rt.u64[] => { - const _3: rt.u64 = b as rt.u64; - return Array.from({ length: 160 }, (): rt.u64 => { + heapSteps$array160_u64(dataData, dataStart, dataLen, (b: rs.u8): rs.u64[] => { + const _3: rs.u64 = b as rs.u64; + return Array.from({ length: 160 }, (): rs.u64 => { return _3; }); }, out); } else { - heapSteps$unit(dataData, dataStart, dataLen, (_2: rt.u8): undefined => {}, out); + heapSteps$unit(dataData, dataStart, dataLen, (_2: rs.u8): undefined => {}, out); } } -export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { - let h!: rt.BinaryHeap; - let tried!: rt.Result; - const size: rt.usize = 1280; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function heapSteps$array160_u64(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { + let h!: rs.BinaryHeap; + let tried!: rs.Result; + const size: rs.usize = 1280; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - h = rt.heapWithCapacity(first >> 3 as rt.usize, 1280) as rt.BinaryHeap; + h = rs.heapWithCapacity(first >> 3 as rs.usize, 1280) as rs.BinaryHeap; } else { - h = rt.heapNew() as rt.BinaryHeap; + h = rs.heapNew() as rs.BinaryHeap; } - put(out, rt.vecCapacity(h, 1280)); - const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(h, 1280)); + const other: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.ByteSlice | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 15); + rs.idx(_25, 0); + const _31: [rs.u8, rs.u8] = [_25.data[_25.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_25, 1), 0)]; + const op: rs.u8 = _31[0]; + const arg: rs.u8 = _31[1]; + const _40: rs.u8 = rs.u8Rem(op, 15); if (_40 === 0 || _40 === 1) { - rt.heapPush(h, copy$array_u64(make(arg)), rt.cmpLe(rt.cmpSlice(rt.cmp))); + rs.heapPush(h, copy$array_u64(make(arg)), rs.cmpLe(rs.cmpSlice(rs.cmp))); } else if (_40 === 2) { - rt.heapPop(h, rt.cmpLe(rt.cmpSlice(rt.cmp))); + rs.heapPop(h, rs.cmpLe(rs.cmpSlice(rs.cmp))); } else if (_40 === 3 || _40 === 4) { - const additional: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 3) { - rt.vecReserve(h, additional, 1280); + const additional: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 3) { + rs.vecReserve(h, additional, 1280); } else { - rt.vecReserveExact(h, additional, 1280); + rs.vecReserveExact(h, additional, 1280); } } else if (_40 === 5) { - rt.vecShrinkTo(h, rt.u8Rem(arg, 40) as rt.usize, 1280); + rs.vecShrinkTo(h, rs.u8Rem(arg, 40) as rs.usize, 1280); } else if (_40 === 6) { - rt.vecShrinkTo(h, 0, 1280); + rs.vecShrinkTo(h, 0, 1280); } else if (_40 === 7) { - rt.heapClear(h); + rs.heapClear(h); } else if (_40 === 8) { - rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1280); + rs.heapExtend(h, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1280); } else if (_40 === 9) { - const _67: rt.u64[] = copy$array_u64(make(arg)); - rt.heapPush(other, _67, rt.cmpLe(rt.cmpSlice(rt.cmp))); - rt.heapAppend(h, other, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), 1280); - sized(out, other.items.length, rt.vecCapacity(other, 1280)); + const _67: rs.u64[] = copy$array_u64(make(arg)); + rs.heapPush(other, _67, rs.cmpLe(rs.cmpSlice(rs.cmp))); + rs.heapAppend(h, other, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), 1280); + sized(out, other.items.length, rs.vecCapacity(other, 1280)); } else if (_40 === 10) { - rt.drop(rt.heapDrain(h)); + rs.drop(rs.heapDrain(h)); } else if (_40 === 11) { - const _78: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + const _78: rs.PeekMut | undefined = rs.heapPeekMut(h, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); if (_78 !== undefined) { - const top: rt.PeekMut = _78; - const _82: rt.u64[] = copy$array_u64(make(arg)); - rt.peekMutDerefMut(top); + const top: rs.PeekMut = _78; + const _82: rs.u64[] = copy$array_u64(make(arg)); + rs.peekMutDerefMut(top); Object.assign(top.v, _82); } } else if (_40 === 12) { - h = rt.heapFrom(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); + h = rs.heapFrom(h, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); } else { - const additional2: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 13) { - tried = rt.vecTryReserve(h, additional2, 1280); + const additional2: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 13) { + tried = rs.vecTryReserve(h, additional2, 1280); } else { - tried = rt.vecTryReserveExact(h, additional2, 1280); + tried = rs.vecTryReserveExact(h, additional2, 1280); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, h.items.length, rt.vecCapacity(h, 1280)); + sized(out, h.items.length, rs.vecCapacity(h, 1280)); } - const cloned: rt.Vec = rt.heapClone(h, copy$array_u64); - sized(out, cloned.items.length, rt.vecCapacity(cloned, 1280)); - const sorted: rt.Vec = rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - sized(out, sorted.items.length, rt.vecCapacity(sorted, 1280)); + const cloned: rs.Vec = rs.heapClone(h, copy$array_u64); + sized(out, cloned.items.length, rs.vecCapacity(cloned, 1280)); + const sorted: rs.Vec = rs.heapIntoSortedVec(h, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + sized(out, sorted.items.length, rs.vecCapacity(sorted, 1280)); } -export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => [rt.u64, rt.u8], out: rt.ByteVec): void { - let h!: rt.BinaryHeap<[rt.u64, rt.u8]>; - let tried!: rt.Result; - const size: rt.usize = 16; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function heapSteps$tuple2_u64_u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => [rs.u64, rs.u8], out: rs.ByteVec): void { + let h!: rs.BinaryHeap<[rs.u64, rs.u8]>; + let tried!: rs.Result; + const size: rs.usize = 16; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - h = rt.heapWithCapacity(first >> 3 as rt.usize, 16) as rt.BinaryHeap<[rt.u64, rt.u8]>; + h = rs.heapWithCapacity(first >> 3 as rs.usize, 16) as rs.BinaryHeap<[rs.u64, rs.u8]>; } else { - h = rt.heapNew() as rt.BinaryHeap<[rt.u64, rt.u8]>; + h = rs.heapNew() as rs.BinaryHeap<[rs.u64, rs.u8]>; } - put(out, rt.vecCapacity(h, 16)); - const other: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapNew() as rt.BinaryHeap<[rt.u64, rt.u8]>; - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(h, 16)); + const other: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapNew() as rs.BinaryHeap<[rs.u64, rs.u8]>; + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.ByteSlice | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 15); + rs.idx(_25, 0); + const _31: [rs.u8, rs.u8] = [_25.data[_25.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_25, 1), 0)]; + const op: rs.u8 = _31[0]; + const arg: rs.u8 = _31[1]; + const _40: rs.u8 = rs.u8Rem(op, 15); if (_40 === 0 || _40 === 1) { - rt.heapPush(h, copy$tuple2_u64_u8(make(arg)), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + rs.heapPush(h, copy$tuple2_u64_u8(make(arg)), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); } else if (_40 === 2) { - rt.heapPop(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + rs.heapPop(h, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); } else if (_40 === 3 || _40 === 4) { - const additional: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 3) { - rt.vecReserve(h, additional, 16); + const additional: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 3) { + rs.vecReserve(h, additional, 16); } else { - rt.vecReserveExact(h, additional, 16); + rs.vecReserveExact(h, additional, 16); } } else if (_40 === 5) { - rt.vecShrinkTo(h, rt.u8Rem(arg, 40) as rt.usize, 16); + rs.vecShrinkTo(h, rs.u8Rem(arg, 40) as rs.usize, 16); } else if (_40 === 6) { - rt.vecShrinkTo(h, 0, 16); + rs.vecShrinkTo(h, 0, 16); } else if (_40 === 7) { - rt.heapClear(h); + rs.heapClear(h); } else if (_40 === 8) { - rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), "next", 16); + rs.heapExtend(h, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), "next", 16); } else if (_40 === 9) { - const _67: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - rt.heapPush(other, _67, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapAppend(h, other, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 16); - sized(out, other.items.length, rt.vecCapacity(other, 16)); + const _67: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); + rs.heapPush(other, _67, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapAppend(h, other, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 16); + sized(out, other.items.length, rs.vecCapacity(other, 16)); } else if (_40 === 10) { - rt.drop(rt.heapDrain(h)); + rs.drop(rs.heapDrain(h)); } else if (_40 === 11) { - const _78: rt.PeekMut<[rt.u64, rt.u8]> | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + const _78: rs.PeekMut<[rs.u64, rs.u8]> | undefined = rs.heapPeekMut(h, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); if (_78 !== undefined) { - const top: rt.PeekMut<[rt.u64, rt.u8]> = _78; - const _82: [rt.u64, rt.u8] = copy$tuple2_u64_u8(make(arg)); - rt.peekMutDerefMut(top); + const top: rs.PeekMut<[rs.u64, rs.u8]> = _78; + const _82: [rs.u64, rs.u8] = copy$tuple2_u64_u8(make(arg)); + rs.peekMutDerefMut(top); Object.assign(top.v, _82); } } else if (_40 === 12) { - h = rt.heapFrom(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + h = rs.heapFrom(h, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); } else { - const additional2: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 13) { - tried = rt.vecTryReserve(h, additional2, 16); + const additional2: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 13) { + tried = rs.vecTryReserve(h, additional2, 16); } else { - tried = rt.vecTryReserveExact(h, additional2, 16); + tried = rs.vecTryReserveExact(h, additional2, 16); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, h.items.length, rt.vecCapacity(h, 16)); + sized(out, h.items.length, rs.vecCapacity(h, 16)); } - const cloned: rt.Vec<[rt.u64, rt.u8]> = rt.heapClone(h, copy$tuple2_u64_u8); - sized(out, cloned.items.length, rt.vecCapacity(cloned, 16)); - const sorted: rt.Vec<[rt.u64, rt.u8]> = rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - sized(out, sorted.items.length, rt.vecCapacity(sorted, 16)); + const cloned: rs.Vec<[rs.u64, rs.u8]> = rs.heapClone(h, copy$tuple2_u64_u8); + sized(out, cloned.items.length, rs.vecCapacity(cloned, 16)); + const sorted: rs.Vec<[rs.u64, rs.u8]> = rs.heapIntoSortedVec(h, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + sized(out, sorted.items.length, rs.vecCapacity(sorted, 16)); } -export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u16, out: rt.ByteVec): void { - let h!: rt.BinaryHeap; - let tried!: rt.Result; - const size: rt.usize = 2; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function heapSteps$u16(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u16, out: rs.ByteVec): void { + let h!: rs.BinaryHeap; + let tried!: rs.Result; + const size: rs.usize = 2; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - h = rt.heapWithCapacity(first >> 3 as rt.usize, 2) as rt.BinaryHeap; + h = rs.heapWithCapacity(first >> 3 as rs.usize, 2) as rs.BinaryHeap; } else { - h = rt.heapNew() as rt.BinaryHeap; + h = rs.heapNew() as rs.BinaryHeap; } - put(out, rt.vecCapacity(h, 2)); - const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(h, 2)); + const other: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.ByteSlice | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 15); + rs.idx(_25, 0); + const _31: [rs.u8, rs.u8] = [_25.data[_25.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_25, 1), 0)]; + const op: rs.u8 = _31[0]; + const arg: rs.u8 = _31[1]; + const _40: rs.u8 = rs.u8Rem(op, 15); if (_40 === 0 || _40 === 1) { - rt.heapPush(h, make(arg), rt.le); + rs.heapPush(h, make(arg), rs.le); } else if (_40 === 2) { - rt.heapPop(h, rt.le); + rs.heapPop(h, rs.le); } else if (_40 === 3 || _40 === 4) { - const additional: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 3) { - rt.vecReserve(h, additional, 2); + const additional: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 3) { + rs.vecReserve(h, additional, 2); } else { - rt.vecReserveExact(h, additional, 2); + rs.vecReserveExact(h, additional, 2); } } else if (_40 === 5) { - rt.vecShrinkTo(h, rt.u8Rem(arg, 40) as rt.usize, 2); + rs.vecShrinkTo(h, rs.u8Rem(arg, 40) as rs.usize, 2); } else if (_40 === 6) { - rt.vecShrinkTo(h, 0, 2); + rs.vecShrinkTo(h, 0, 2); } else if (_40 === 7) { - rt.heapClear(h); + rs.heapClear(h); } else if (_40 === 8) { - rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make), rt.le, rt.ge, rt.lt, "next", 2); + rs.heapExtend(h, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make), rs.le, rs.ge, rs.lt, "next", 2); } else if (_40 === 9) { - const _67: rt.u16 = make(arg); - rt.heapPush(other, _67, rt.le); - rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 2); - sized(out, other.items.length, rt.vecCapacity(other, 2)); + const _67: rs.u16 = make(arg); + rs.heapPush(other, _67, rs.le); + rs.heapAppend(h, other, rs.le, rs.ge, rs.lt, 2); + sized(out, other.items.length, rs.vecCapacity(other, 2)); } else if (_40 === 10) { - rt.drop(rt.heapDrain(h)); + rs.drop(rs.heapDrain(h)); } else if (_40 === 11) { - const _78: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + const _78: rs.PeekMut | undefined = rs.heapPeekMut(h, rs.le, rs.ge, rs.lt); if (_78 !== undefined) { - const top: rt.PeekMut = _78; - const _82: rt.u16 = make(arg); - rt.peekMutDerefMut(top); + const top: rs.PeekMut = _78; + const _82: rs.u16 = make(arg); + rs.peekMutDerefMut(top); top.v = _82; } } else if (_40 === 12) { - h = rt.heapFrom(h, rt.le, rt.ge, rt.lt); + h = rs.heapFrom(h, rs.le, rs.ge, rs.lt); } else { - const additional2: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 13) { - tried = rt.vecTryReserve(h, additional2, 2); + const additional2: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 13) { + tried = rs.vecTryReserve(h, additional2, 2); } else { - tried = rt.vecTryReserveExact(h, additional2, 2); + tried = rs.vecTryReserveExact(h, additional2, 2); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, h.items.length, rt.vecCapacity(h, 2)); + sized(out, h.items.length, rs.vecCapacity(h, 2)); } - const cloned: rt.Vec = rt.heapClone(h, undefined); - sized(out, cloned.items.length, rt.vecCapacity(cloned, 2)); - const sorted: rt.Vec = rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt); - sized(out, sorted.items.length, rt.vecCapacity(sorted, 2)); + const cloned: rs.Vec = rs.heapClone(h, undefined); + sized(out, cloned.items.length, rs.vecCapacity(cloned, 2)); + const sorted: rs.Vec = rs.heapIntoSortedVec(h, rs.le, rs.ge, rs.lt); + sized(out, sorted.items.length, rs.vecCapacity(sorted, 2)); } -export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let h!: rt.BinaryHeap; - let tried!: rt.Result; - const size: rt.usize = 1; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function heapSteps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let h!: rs.BinaryHeap; + let tried!: rs.Result; + const size: rs.usize = 1; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - h = rt.heapWithCapacity(first >> 3 as rt.usize, 1) as rt.BinaryHeap; + h = rs.heapWithCapacity(first >> 3 as rs.usize, 1) as rs.BinaryHeap; } else { - h = rt.heapNew() as rt.BinaryHeap; + h = rs.heapNew() as rs.BinaryHeap; } - put(out, rt.vecCapacity(h, 1)); - const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(h, 1)); + const other: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.ByteSlice | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 15); + rs.idx(_25, 0); + const _31: [rs.u8, rs.u8] = [_25.data[_25.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_25, 1), 0)]; + const op: rs.u8 = _31[0]; + const arg: rs.u8 = _31[1]; + const _40: rs.u8 = rs.u8Rem(op, 15); if (_40 === 0 || _40 === 1) { - rt.heapPush(h, make(arg), rt.le); + rs.heapPush(h, make(arg), rs.le); } else if (_40 === 2) { - rt.heapPop(h, rt.le); + rs.heapPop(h, rs.le); } else if (_40 === 3 || _40 === 4) { - const additional: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 3) { - rt.vecReserve(h, additional, 1); + const additional: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 3) { + rs.vecReserve(h, additional, 1); } else { - rt.vecReserveExact(h, additional, 1); + rs.vecReserveExact(h, additional, 1); } } else if (_40 === 5) { - rt.vecShrinkTo(h, rt.u8Rem(arg, 40) as rt.usize, 1); + rs.vecShrinkTo(h, rs.u8Rem(arg, 40) as rs.usize, 1); } else if (_40 === 6) { - rt.vecShrinkTo(h, 0, 1); + rs.vecShrinkTo(h, 0, 1); } else if (_40 === 7) { - rt.heapClear(h); + rs.heapClear(h); } else if (_40 === 8) { - rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make), rt.le, rt.ge, rt.lt, "next", 1); + rs.heapExtend(h, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make), rs.le, rs.ge, rs.lt, "next", 1); } else if (_40 === 9) { - const _67: rt.u8 = make(arg); - rt.heapPush(other, _67, rt.le); - rt.heapAppend(h, other, rt.le, rt.ge, rt.lt, 1); - sized(out, other.items.length, rt.vecCapacity(other, 1)); + const _67: rs.u8 = make(arg); + rs.heapPush(other, _67, rs.le); + rs.heapAppend(h, other, rs.le, rs.ge, rs.lt, 1); + sized(out, other.items.length, rs.vecCapacity(other, 1)); } else if (_40 === 10) { - rt.drop(rt.heapDrain(h)); + rs.drop(rs.heapDrain(h)); } else if (_40 === 11) { - const _78: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.le, rt.ge, rt.lt); + const _78: rs.PeekMut | undefined = rs.heapPeekMut(h, rs.le, rs.ge, rs.lt); if (_78 !== undefined) { - const top: rt.PeekMut = _78; - const _82: rt.u8 = make(arg); - rt.peekMutDerefMut(top); + const top: rs.PeekMut = _78; + const _82: rs.u8 = make(arg); + rs.peekMutDerefMut(top); top.v = _82; } } else if (_40 === 12) { - h = rt.heapFrom(rt.byteVecToVec(rt.byteVecFromVec(h)), rt.le, rt.ge, rt.lt); + h = rs.heapFrom(rs.byteVecToVec(rs.byteVecFromVec(h)), rs.le, rs.ge, rs.lt); } else { - const additional2: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 13) { - tried = rt.vecTryReserve(h, additional2, 1); + const additional2: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 13) { + tried = rs.vecTryReserve(h, additional2, 1); } else { - tried = rt.vecTryReserveExact(h, additional2, 1); + tried = rs.vecTryReserveExact(h, additional2, 1); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, h.items.length, rt.vecCapacity(h, 1)); + sized(out, h.items.length, rs.vecCapacity(h, 1)); } - const cloned: rt.ByteVec = rt.byteVecFromVec(rt.heapClone(h, undefined)); + const cloned: rs.ByteVec = rs.byteVecFromVec(rs.heapClone(h, undefined)); sized(out, cloned.length, cloned.data.length); - const sorted: rt.ByteVec = rt.byteVecFromVec(rt.heapIntoSortedVec(h, rt.le, rt.ge, rt.lt)); + const sorted: rs.ByteVec = rs.byteVecFromVec(rs.heapIntoSortedVec(h, rs.le, rs.ge, rs.lt)); sized(out, sorted.length, sorted.data.length); } -export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rt.u8) => undefined, out: rt.ByteVec): void { - let h!: rt.BinaryHeap; - let tried!: rt.Result; - const size: rt.usize = 0; - const _9: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _7: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _9, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, make: (a0: rs.u8) => undefined, out: rs.ByteVec): void { + let h!: rs.BinaryHeap; + let tried!: rs.Result; + const size: rs.usize = 0; + const _9: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _7: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _9, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _7[0]; + const first: rs.u8 = _7[0]; if ((first & 1) === 1) { - h = rt.heapWithCapacity(first >> 3 as rt.usize, 0) as rt.BinaryHeap; + h = rs.heapWithCapacity(first >> 3 as rs.usize, 0) as rs.BinaryHeap; } else { - h = rt.heapNew() as rt.BinaryHeap; + h = rs.heapNew() as rs.BinaryHeap; } - put(out, rt.vecCapacity(h, 0)); - const other: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceChunks(_7[1], 2); + put(out, rs.vecCapacity(h, 0)); + const other: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const iter: rs.Iter = rs.byteSliceChunks(_7[1], 2); while (true) { - const _25: rt.ByteSlice | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.ByteSlice | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.idx(_25, 0); - const _31: [rt.u8, rt.u8] = [_25.data[_25.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_25, 1), 0)]; - const op: rt.u8 = _31[0]; - const arg: rt.u8 = _31[1]; - const _40: rt.u8 = rt.u8Rem(op, 15); + rs.idx(_25, 0); + const _31: [rs.u8, rs.u8] = [_25.data[_25.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_25, 1), 0)]; + const op: rs.u8 = _31[0]; + const arg: rs.u8 = _31[1]; + const _40: rs.u8 = rs.u8Rem(op, 15); if (_40 === 0 || _40 === 1) { - const _42: rt.BinaryHeap = h; + const _42: rs.BinaryHeap = h; make(arg); - rt.heapPush(_42, undefined, rt.cmpLe(rt.cmpNothing)); + rs.heapPush(_42, undefined, rs.cmpLe(rs.cmpNothing)); } else if (_40 === 2) { - rt.heapPop(h, rt.cmpLe(rt.cmpNothing), rt.None); + rs.heapPop(h, rs.cmpLe(rs.cmpNothing), rs.None); } else if (_40 === 3 || _40 === 4) { - const additional: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 3) { - rt.vecReserve(h, additional, 0); + const additional: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 3) { + rs.vecReserve(h, additional, 0); } else { - rt.vecReserveExact(h, additional, 0); + rs.vecReserveExact(h, additional, 0); } } else if (_40 === 5) { - rt.vecShrinkTo(h, rt.u8Rem(arg, 40) as rt.usize, 0); + rs.vecShrinkTo(h, rs.u8Rem(arg, 40) as rs.usize, 0); } else if (_40 === 6) { - rt.vecShrinkTo(h, 0, 0); + rs.vecShrinkTo(h, 0, 0); } else if (_40 === 7) { - rt.heapClear(h); + rs.heapClear(h); } else if (_40 === 8) { - rt.heapExtend(h, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 24)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make), rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing), "next", 0); + rs.heapExtend(h, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 24)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make), rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing), "next", 0); } else if (_40 === 9) { make(arg); - rt.heapPush(other, undefined, rt.cmpLe(rt.cmpNothing)); - rt.heapAppend(h, other, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing), 0); - sized(out, other.items.length, rt.vecCapacity(other, 0)); + rs.heapPush(other, undefined, rs.cmpLe(rs.cmpNothing)); + rs.heapAppend(h, other, rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing), 0); + sized(out, other.items.length, rs.vecCapacity(other, 0)); } else if (_40 === 10) { - rt.drop(rt.heapDrain(h)); + rs.drop(rs.heapDrain(h)); } else if (_40 === 11) { - const _78: rt.PeekMut | undefined = rt.heapPeekMut(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + const _78: rs.PeekMut | undefined = rs.heapPeekMut(h, rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing)); if (_78 !== undefined) { - const top: rt.PeekMut = _78; + const top: rs.PeekMut = _78; make(arg); - rt.peekMutDerefMut(top); + rs.peekMutDerefMut(top); top.v = undefined; } } else if (_40 === 12) { - h = rt.heapFrom(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); + h = rs.heapFrom(h, rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing)); } else { - const additional2: rt.usize = amount(arg, h.items.length, size); - if (rt.u8Rem(op, 15) === 13) { - tried = rt.vecTryReserve(h, additional2, 0); + const additional2: rs.usize = amount(arg, h.items.length, size); + if (rs.u8Rem(op, 15) === 13) { + tried = rs.vecTryReserve(h, additional2, 0); } else { - tried = rt.vecTryReserveExact(h, additional2, 0); + tried = rs.vecTryReserveExact(h, additional2, 0); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); } - sized(out, h.items.length, rt.vecCapacity(h, 0)); + sized(out, h.items.length, rs.vecCapacity(h, 0)); } - const cloned: rt.Vec = rt.heapClone(h, undefined); - sized(out, cloned.items.length, rt.vecCapacity(cloned, 0)); - const sorted: rt.Vec = rt.heapIntoSortedVec(h, rt.cmpLe(rt.cmpNothing), rt.cmpGe(rt.cmpNothing), rt.cmpLt(rt.cmpNothing)); - sized(out, sorted.items.length, rt.vecCapacity(sorted, 0)); + const cloned: rs.Vec = rs.heapClone(h, undefined); + sized(out, cloned.items.length, rs.vecCapacity(cloned, 0)); + const sorted: rs.Vec = rs.heapIntoSortedVec(h, rs.cmpLe(rs.cmpNothing), rs.cmpGe(rs.cmpNothing), rs.cmpLt(rs.cmpNothing)); + sized(out, sorted.items.length, rs.vecCapacity(sorted, 0)); } /** @@ -3455,78 +3455,78 @@ export function heapSteps$unit(dataData: Uint8Array, dataStart: number, dataLen: * a `Vec` of elements of another size, by a tuple's `Extend`, by `vec!`, and by * `with_capacity` past what one may hold, which panics. */ -export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.u8Rem(_2, 24) as rt.usize; +export function collects(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 24) as rs.usize; }); - const pairs2: rt.Vec<[rt.u32, rt.u32]> = rt.vecWithCapacity(rt.usizeAdd(n, rt.u8Rem(kind, 4) as rt.usize), 8); - const _15: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(new rt.Range(0, n as rt.u32), (i: rt.u32): [rt.u32, rt.u32] => { - return [i, i] as [rt.u32, rt.u32]; + const pairs2: rs.Vec<[rs.u32, rs.u32]> = rs.vecWithCapacity(rs.usizeAdd(n, rs.u8Rem(kind, 4) as rs.usize), 8); + const _15: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(new rs.Range(0, n as rs.u32), (i: rs.u32): [rs.u32, rs.u32] => { + return [i, i] as [rs.u32, rs.u32]; }); - rt.iterExtend(pairs2, _15, undefined, 8, true); - const _18: rt.u8 = rt.u8Rem(kind, 8); + rs.iterExtend(pairs2, _15, undefined, 8, true); + const _18: rs.u8 = rs.u8Rem(kind, 8); if (_18 === 0) { - const halves: rt.Vec = rt.iterToVec(rt.iterMap(rt.vecIntoIter(pairs2), (_28: [rt.u32, rt.u32]): rt.u32 => { + const halves: rs.Vec = rs.iterToVec(rs.iterMap(rs.vecIntoIter(pairs2), (_28: [rs.u32, rs.u32]): rs.u32 => { return _28[0]; }), "next", 4, true, 8); - sized(out, halves.items.length, rt.vecCapacity(halves, 4)); + sized(out, halves.items.length, rs.vecCapacity(halves, 4)); } else if (_18 === 1) { - const bytes: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 3)); - const _34: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); - rt.byteVecExtendFromSlice(bytes, _34); + const bytes: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeAdd(n, 3)); + const _34: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(n, data.length)); + rs.byteVecExtendFromSlice(bytes, _34); sized(out, bytes.length, bytes.data.length); - const odd: rt.ByteVec = rt.iterToByteVec(rt.iterFilter(rt.byteVecIntoIter(rt.byteVecFrom(rt.byteVecView(bytes))), (b5: rt.u8): boolean => { - return rt.u8Rem(b5, 2) === 1; + const odd: rs.ByteVec = rs.iterToByteVec(rs.iterFilter(rs.byteVecIntoIter(rs.byteVecFrom(rs.byteVecView(bytes))), (b5: rs.u8): boolean => { + return rs.u8Rem(b5, 2) === 1; }), "next", false, 1); sized(out, odd.length, odd.data.length); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteVecIntoIter(bytes), (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteVecIntoIter(bytes), (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }), undefined, 2, true); - sized(out, wide.items.length, rt.vecCapacity(wide, 2)); + sized(out, wide.items.length, rs.vecCapacity(wide, 2)); } else if (_18 === 2) { - const _65: rt.Iter<[rt.u32, rt.u32]> = rt.iterFilter(rt.iterSlice(pairs2.items), (_24: [rt.u32, rt.u32]): boolean => { - return rt.u32Rem(_24[0], 2) === 0; + const _65: rs.Iter<[rs.u32, rs.u32]> = rs.iterFilter(rs.iterSlice(pairs2.items), (_24: [rs.u32, rs.u32]): boolean => { + return rs.u32Rem(_24[0], 2) === 0; }); - const _64: [rt.Vec, rt.VecDeque] = rt.tupleExtend([new rt.Vec(), rt.dequeNew(4) as rt.VecDeque] as [rt.Vec, rt.VecDeque], _65, [rt.vecPart(4), rt.dequePart()]); - const a: rt.Vec = _64[0]; - const b: rt.VecDeque = _64[1]; - sized(out, a.items.length, rt.vecCapacity(a, 4)); - sized(out, b.n, rt.dequeCapacity(b)); - const _83: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(rt.iterSlice(pairs2.items), (_26: [rt.u32, rt.u32]): [rt.u8, rt.u32] => { - return [_26[0] & 0xff, _26[1]] as [rt.u8, rt.u32]; + const _64: [rs.Vec, rs.VecDeque] = rs.tupleExtend([new rs.Vec(), rs.dequeNew(4) as rs.VecDeque] as [rs.Vec, rs.VecDeque], _65, [rs.vecPart(4), rs.dequePart()]); + const a: rs.Vec = _64[0]; + const b: rs.VecDeque = _64[1]; + sized(out, a.items.length, rs.vecCapacity(a, 4)); + sized(out, b.n, rs.dequeCapacity(b)); + const _83: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(rs.iterSlice(pairs2.items), (_26: [rs.u32, rs.u32]): [rs.u8, rs.u32] => { + return [_26[0] & 0xff, _26[1]] as [rs.u8, rs.u32]; }); - const _82: [rt.ByteVec, rt.BinaryHeap] = rt.tupleExtend([new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap] as [rt.ByteVec, rt.BinaryHeap], _83, [rt.byteVecPart(), rt.heapPart(rt.le, 4)]); - const c: rt.ByteVec = _82[0]; - const d: rt.BinaryHeap = _82[1]; + const _82: [rs.ByteVec, rs.BinaryHeap] = rs.tupleExtend([new rs.ByteVec(), rs.heapNew() as rs.BinaryHeap] as [rs.ByteVec, rs.BinaryHeap], _83, [rs.byteVecPart(), rs.heapPart(rs.le, 4)]); + const c: rs.ByteVec = _82[0]; + const d: rs.BinaryHeap = _82[1]; sized(out, c.length, c.data.length); - sized(out, d.items.length, rt.vecCapacity(d, 4)); + sized(out, d.items.length, rs.vecCapacity(d, 4)); } else if (_18 === 3) { - const filled: rt.Vec = rt.vecFromElem(0, n, undefined); - sized(out, filled.items.length, rt.vecCapacity(filled, 2)); - const units: rt.Vec = rt.vecFromElem(undefined, n, undefined); - sized(out, units.items.length, rt.vecCapacity(units, 0)); + const filled: rs.Vec = rs.vecFromElem(0, n, undefined); + sized(out, filled.items.length, rs.vecCapacity(filled, 2)); + const units: rs.Vec = rs.vecFromElem(undefined, n, undefined); + sized(out, units.items.length, rs.vecCapacity(units, 0)); } else if (_18 === 4) { - put(out, rt.vecCapacity(rt.vecWithCapacity(rt.usizeSub(4294967295, n), 8), 8)); + put(out, rs.vecCapacity(rs.vecWithCapacity(rs.usizeSub(4294967295, n), 8), 8)); } else if (_18 === 5) { - put(out, rt.dequeCapacity(rt.dequeWithCapacity(rt.usizeAdd(268435456, n), 16) as rt.VecDeque<[rt.u64, rt.u64]>)); + put(out, rs.dequeCapacity(rs.dequeWithCapacity(rs.usizeAdd(268435456, n), 16) as rs.VecDeque<[rs.u64, rs.u64]>)); } else if (_18 === 6) { - const bytes2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeAdd(n, 5)); - const _126: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(n, data.length)); - rt.byteVecExtendFromSlice(bytes2, _126); - const q2: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(bytes2))), 1, true) as rt.VecDeque; - sized(out, q2.n, rt.dequeCapacity(q2)); - const heap: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(bytes2), rt.le, rt.ge, rt.lt); - sized(out, heap.items.length, rt.vecCapacity(heap, 1)); - const v2: rt.ByteVec = rt.byteVecFromVec(heap); + const bytes2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeAdd(n, 5)); + const _126: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(n, data.length)); + rs.byteVecExtendFromSlice(bytes2, _126); + const q2: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(bytes2))), 1, true) as rs.VecDeque; + sized(out, q2.n, rs.dequeCapacity(q2)); + const heap: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(bytes2), rs.le, rs.ge, rs.lt); + sized(out, heap.items.length, rs.vecCapacity(heap, 1)); + const v2: rs.ByteVec = rs.byteVecFromVec(heap); sized(out, v2.length, v2.data.length); } else { - const grown: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(rt.byteVecOf(7, n))); - const _156: rt.Iter = rt.iterFilter(new rt.Range(0, n & 0xff), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; + const grown: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(rs.byteVecOf(7, n))); + const _156: rs.Iter = rs.iterFilter(new rs.Range(0, n & 0xff), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 2) === 0; }); - rt.iterExtendBytes(grown, _156, "next"); + rs.iterExtendBytes(grown, _156, "next"); sized(out, grown.length, grown.data.length); - rt.byteVecShrinkTo(grown, rt.usizeDiv(n, 2)); + rs.byteVecShrinkTo(grown, rs.usizeDiv(n, 2)); sized(out, grown.length, grown.data.length); } } @@ -3538,151 +3538,151 @@ export function collects(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `drain` than it asked for of what there was. A `reserve` or `with_capacity` past what * one may hold panics, where `try_reserve` gives an error and keeps the capacity. */ -export function maps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _8!: [rt.HashMap, rt.HashSet]; - let _199!: rt.usize; - const _18: (a0: rt.ByteVec, a1: rt.usize[], a2: rt.usize[], a3: rt.usize[]) => undefined = (out2: rt.ByteVec, lens2: rt.usize[], caps: rt.usize[], floors2: rt.usize[]): undefined => { - let _92!: rt.usize; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 2; +export function maps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _8!: [rs.HashMap, rs.HashSet]; + let _199!: rs.usize; + const _18: (a0: rs.ByteVec, a1: rs.usize[], a2: rs.usize[], a3: rs.usize[]) => undefined = (out2: rs.ByteVec, lens2: rs.usize[], caps: rs.usize[], floors2: rs.usize[]): undefined => { + let _92!: rs.usize; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 2; while ((_92 = iterStart++) < iterEnd) { - const i2: rt.usize = _92; + const i2: rs.usize = _92; if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } put(out2, lens2[i2]); if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } - const _19: rt.usize = caps[i2]; + const _19: rs.usize = caps[i2]; if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } - const _223: rt.usize = lens2[i2]; + const _223: rs.usize = lens2[i2]; if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } - rt.byteVecPush(out2, _19 >= rt.max(_223, floors2[i2]) ? 1 : 0); + rs.byteVecPush(out2, _19 >= rs.max(_223, floors2[i2]) ? 1 : 0); } }; - const made: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.u8Rem(_2, 24) as rt.usize; + const made: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 24) as rs.usize; }); if ((kind & 1) === 1) { - _8 = [rt.hashWithCapacity(made, 58720256) as rt.HashMap, rt.hashWithCapacity(made, 469762048) as rt.HashSet] as [rt.HashMap, rt.HashSet]; + _8 = [rs.hashWithCapacity(made, 58720256) as rs.HashMap, rs.hashWithCapacity(made, 469762048) as rs.HashSet] as [rs.HashMap, rs.HashSet]; } else { - _8 = [rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet] as [rt.HashMap, rt.HashSet]; + _8 = [rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet] as [rs.HashMap, rs.HashSet]; } - let m: rt.HashMap = _8[0]; - let s: rt.HashSet = _8[1]; - const floor: rt.usize = rt.usizeMul(made, (kind & 1) as rt.usize); - const _22: rt.usize[] = [rt.hashLen(m), rt.hashLen(s)]; - const _27: rt.usize[] = [rt.hashCapacity(m), rt.hashCapacity(s)]; - const part = Array.from({ length: 2 }, (): rt.usize => { + let m: rs.HashMap = _8[0]; + let s: rs.HashSet = _8[1]; + const floor: rs.usize = rs.usizeMul(made, (kind & 1) as rs.usize); + const _22: rs.usize[] = [rs.hashLen(m), rs.hashLen(s)]; + const _27: rs.usize[] = [rs.hashCapacity(m), rs.hashCapacity(s)]; + const part = Array.from({ length: 2 }, (): rs.usize => { return floor; }); _18(out, _22, _27, part); - const iter: rt.Iter = rt.byteSliceChunks(option_unwrapOrDefault$0301ewp(rt.byteSliceGetRange(data, 1)), 2); + const iter: rs.Iter = rs.byteSliceChunks(option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 1)), 2); while (true) { - const _39: rt.ByteSlice | rt.Done = iter.next(); - if (_39 === rt.DONE) { + const _39: rs.ByteSlice | rs.Done = iter.next(); + if (_39 === rs.DONE) { break; } - rt.idx(_39, 0); - const _45: [rt.u8, rt.u8] = [_39.data[_39.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_39, 1), 0)]; - const op: rt.u8 = _45[0]; - const arg: rt.u8 = _45[1]; - const before: rt.usize[] = [rt.hashCapacity(m), rt.hashCapacity(s)]; - const lens: rt.usize[] = [rt.hashLen(m), rt.hashLen(s)]; - let floors: rt.usize[] = Array.from({ length: 2 }, (): rt.usize => { + rs.idx(_39, 0); + const _45: [rs.u8, rs.u8] = [_39.data[_39.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_39, 1), 0)]; + const op: rs.u8 = _45[0]; + const arg: rs.u8 = _45[1]; + const before: rs.usize[] = [rs.hashCapacity(m), rs.hashCapacity(s)]; + const lens: rs.usize[] = [rs.hashLen(m), rs.hashLen(s)]; + let floors: rs.usize[] = Array.from({ length: 2 }, (): rs.usize => { return 0; }); b3: { - const _64: rt.u8 = rt.u8Rem(op, 11); + const _64: rs.u8 = rs.u8Rem(op, 11); if (0 <= _64) { if (_64 <= 2) { - rt.hashInsert(m, arg as rt.u16, [op as rt.u64, arg] as [rt.u64, rt.u8]); - rt.hashAdd(s, arg); + rs.hashInsert(m, arg as rs.u16, [op as rs.u64, arg] as [rs.u64, rs.u8]); + rs.hashAdd(s, arg); break b3; } } if (_64 === 3) { - rt.hashRemove(m, arg as rt.u16); - rt.hashDelete(s, arg); + rs.hashRemove(m, arg as rs.u16); + rs.hashDelete(s, arg); } else if (_64 === 4) { - const _85: rt.usize = amount(arg, lens[0], 24); - const _84: [rt.usize, rt.usize] = [_85, amount(arg, lens[1], 1)]; - const a: rt.usize = _85; - const b: rt.usize = _84[1]; - rt.hashReserve(m, a, 58720256); - rt.hashReserve(s, b, 469762048); - floors = [rt.usizeAdd(lens[0], a), rt.usizeAdd(lens[1], b)]; + const _85: rs.usize = amount(arg, lens[0], 24); + const _84: [rs.usize, rs.usize] = [_85, amount(arg, lens[1], 1)]; + const a: rs.usize = _85; + const b: rs.usize = _84[1]; + rs.hashReserve(m, a, 58720256); + rs.hashReserve(s, b, 469762048); + floors = [rs.usizeAdd(lens[0], a), rs.usizeAdd(lens[1], b)]; } else if (_64 === 5) { - const min: rt.usize = rt.u8Rem(arg, 20) as rt.usize; - rt.hashShrinkTo(m, min); - rt.hashShrinkTo(s, min); - floors = [rt.min(before[0], rt.max(lens[0], min)), rt.min(before[1], rt.max(lens[1], min))]; + const min: rs.usize = rs.u8Rem(arg, 20) as rs.usize; + rs.hashShrinkTo(m, min); + rs.hashShrinkTo(s, min); + floors = [rs.min(before[0], rs.max(lens[0], min)), rs.min(before[1], rs.max(lens[1], min))]; } else if (_64 === 6) { - rt.hashShrinkTo(m, 0); - rt.hashShrinkTo(s, 0); + rs.hashShrinkTo(m, 0); + rs.hashShrinkTo(s, 0); } else if (_64 === 7) { - rt.hashClear(m); - rt.hashClear(s); + rs.hashClear(m); + rs.hashClear(s); floors = copy$array_usize(before); } else if (_64 === 8) { - rt.hashRetain(m, (k: rt.u16, _3: [rt.u64, rt.u8]): boolean => { - return rt.u16Rem(k, 3) !== rt.u8Rem(arg, 3) as rt.u16; + rs.hashRetain(m, (k: rs.u16, _3: [rs.u64, rs.u8]): boolean => { + return rs.u16Rem(k, 3) !== rs.u8Rem(arg, 3) as rs.u16; }); - rt.hashRetain(s, (k2: rt.u8): boolean => { - return rt.u8Rem(k2, 3) !== rt.u8Rem(arg, 3); + rs.hashRetain(s, (k2: rs.u8): boolean => { + return rs.u8Rem(k2, 3) !== rs.u8Rem(arg, 3); }); - m = rt.hashClone(m, undefined, copy$tuple2_u64_u8); - s = rt.hashClone(s, undefined, undefined); + m = rs.hashClone(m, undefined, copy$tuple2_u64_u8); + s = rs.hashClone(s, undefined, undefined); } else if (_64 === 9) { - rt.hashDrain(m); - rt.hashDrainKeys(s); + rs.hashDrain(m); + rs.hashDrainKeys(s); floors = copy$array_usize(before); } else { - const _160: rt.usize = amount(arg, lens[0], 24); - const _159: [rt.usize, rt.usize] = [_160, amount(arg, lens[1], 1)]; - const a2: rt.usize = _160; - const b2: rt.usize = _159[1]; - const iter2: rt.Iter<[rt.usize, [rt.Result, rt.usize]]> = rt.iterEnumerate(rt.iterSlice([[rt.hashTryReserve(m, a2, 58720256), a2] as [rt.Result, rt.usize], [rt.hashTryReserve(s, b2, 469762048), b2] as [rt.Result, rt.usize]])); + const _160: rs.usize = amount(arg, lens[0], 24); + const _159: [rs.usize, rs.usize] = [_160, amount(arg, lens[1], 1)]; + const a2: rs.usize = _160; + const b2: rs.usize = _159[1]; + const iter2: rs.Iter<[rs.usize, [rs.Result, rs.usize]]> = rs.iterEnumerate(rs.iterSlice([[rs.hashTryReserve(m, a2, 58720256), a2] as [rs.Result, rs.usize], [rs.hashTryReserve(s, b2, 469762048), b2] as [rs.Result, rs.usize]])); while (true) { - const _180: [rt.usize, [rt.Result, rt.usize]] | rt.Done = iter2.next(); - if (_180 === rt.DONE) { + const _180: [rs.usize, [rs.Result, rs.usize]] | rs.Done = iter2.next(); + if (_180 === rs.DONE) { break; } - const i: rt.usize = _180[0]; - const tried: rt.Result = _180[1][0]; - const n: rt.usize = _180[1][1]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(tried, f, rt.fmtUnit, rt.fmtTryReserveErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const i: rs.usize = _180[0]; + const tried: rs.Result = _180[1][0]; + const n: rs.usize = _180[1][1]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(tried, f, rs.fmtUnit, rs.fmtTryReserveErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); if (!tried.ok) { if (!(i < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); } _199 = before[i]; } else { if (!(i < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); } - _199 = rt.usizeAdd(lens[i], n); + _199 = rs.usizeAdd(lens[i], n); } if (!(i < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i); } floors[i] = _199; } } } - const part2 = [rt.hashLen(m), rt.hashLen(s)]; - const part3 = [rt.hashCapacity(m), rt.hashCapacity(s)]; + const part2 = [rs.hashLen(m), rs.hashLen(s)]; + const part3 = [rs.hashCapacity(m), rs.hashCapacity(s)]; const part4 = copy$array_usize(floors); _18(out, part2, part3, part4); } if ((kind & 128) !== 0) { - put(out, rt.hashLen(rt.hashWithCapacity(rt.usizeShr(4294967295, kind & 3), 117440512, rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet)); + put(out, rs.hashLen(rs.hashWithCapacity(rs.usizeShr(4294967295, kind & 3), 117440512, rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet)); } } diff --git a/ts/fixtures/lang/capacity/expected/core/bool.ts b/ts/fixtures/lang/capacity/expected/core/bool.ts index ae4cf20e8..859a41068 100644 --- a/ts/fixtures/lang/capacity/expected/core/bool.ts +++ b/ts/fixtures/lang/capacity/expected/core/bool.ts @@ -1,36 +1,36 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$060nyee(self: boolean, f: () => rt.Vec): rt.Vec | undefined { +export function then$1b5wr43(self: boolean, f: () => rs.Vec): rs.Vec | undefined { if (!self) { return undefined; } return f(); } -export function then$15ykizu(self: boolean, f: () => rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> | undefined { +export function then$0tujtct(self: boolean, f: () => rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> | undefined { if (!self) { return undefined; } return f(); } -export function then$06am279(self: boolean, f: () => rt.Vec): rt.Vec | undefined { +export function then$0svbdod(self: boolean, f: () => rs.Vec): rs.Vec | undefined { if (!self) { return undefined; } return f(); } -export function then$0ozmvid(self: boolean, f: () => rt.ByteVec): rt.ByteVec | undefined { +export function then$17csa2h(self: boolean, f: () => rs.ByteVec): rs.ByteVec | undefined { if (!self) { return undefined; } return f(); } -export function then$1svdnnn(self: boolean, f: () => rt.Vec): rt.Vec | undefined { +export function then$0g2g1ls(self: boolean, f: () => rs.Vec): rs.Vec | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/capacity/expected/core/option.ts b/ts/fixtures/lang/capacity/expected/core/option.ts index 8db3bd2db..781b780a5 100644 --- a/ts/fixtures/lang/capacity/expected/core/option.ts +++ b/ts/fixtures/lang/capacity/expected/core/option.ts @@ -1,64 +1,64 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function unwrapOrDefault$0301ewp(self: rt.ByteSlice | undefined): rt.ByteSlice { +export function unwrapOrDefault$0avqj0t(self: rs.ByteSlice | undefined): rs.ByteSlice { if (self === undefined) { - return rt.byteSliceFrom(new Uint8Array(0)); + return rs.byteSliceFrom(new Uint8Array(0)); } return self; } -export function map$1e3rrc6(self: rt.Vec[] | undefined, f: (a0: rt.Vec[]) => rt.Vec): rt.Vec | undefined { +export function map$1n6i7tn(self: rs.Vec[] | undefined, f: (a0: rs.Vec[]) => rs.Vec): rs.Vec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0rgpr92(self: rt.Vec<[rt.u64, rt.u8]>[] | undefined, f: (a0: rt.Vec<[rt.u64, rt.u8]>[]) => rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> | undefined { +export function map$12r4ivp(self: rs.Vec<[rs.u64, rs.u8]>[] | undefined, f: (a0: rs.Vec<[rs.u64, rs.u8]>[]) => rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1dj8fjk(self: rt.Vec[] | undefined, f: (a0: rt.Vec[]) => rt.Vec): rt.Vec | undefined { +export function map$03x2fqt(self: rs.Vec[] | undefined, f: (a0: rs.Vec[]) => rs.Vec): rs.Vec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1p5j86b(self: rt.ByteVec[] | undefined, f: (a0: rt.ByteVec[]) => rt.ByteVec): rt.ByteVec | undefined { +export function map$1o9z3sm(self: rs.ByteVec[] | undefined, f: (a0: rs.ByteVec[]) => rs.ByteVec): rs.ByteVec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0197mxk(self: rt.Vec[] | undefined, f: (a0: rt.Vec[]) => rt.Vec): rt.Vec | undefined { +export function map$1d4d0v7(self: rs.Vec[] | undefined, f: (a0: rs.Vec[]) => rs.Vec): rs.Vec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { +export function mapOr$0z4nmg2(self: [rs.u8, rs.ByteSlice] | undefined, default_: [rs.u8, rs.ByteSlice], f: (a0: [rs.u8, rs.ByteSlice]) => [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/capacity/expected/core/result.ts b/ts/fixtures/lang/capacity/expected/core/result.ts index b588b3aaa..7e048cae2 100644 --- a/ts/fixtures/lang/capacity/expected/core/result.ts +++ b/ts/fixtures/lang/capacity/expected/core/result.ts @@ -1,36 +1,36 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOrElse$1q4qcpp(self: rt.Result, rt.Vec>, op: (a0: rt.Vec) => rt.Vec): rt.Vec { +export function unwrapOrElse$128e309(self: rs.Result, rs.Vec>, op: (a0: rs.Vec) => rs.Vec): rs.Vec { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$17cj159(self: rt.Result, rt.Vec<[rt.u64, rt.u8]>>, op: (a0: rt.Vec<[rt.u64, rt.u8]>) => rt.Vec<[rt.u64, rt.u8]>): rt.Vec<[rt.u64, rt.u8]> { +export function unwrapOrElse$02f6iwg(self: rs.Result, rs.Vec<[rs.u64, rs.u8]>>, op: (a0: rs.Vec<[rs.u64, rs.u8]>) => rs.Vec<[rs.u64, rs.u8]>): rs.Vec<[rs.u64, rs.u8]> { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$1urqnv6(self: rt.Result, rt.Vec>, op: (a0: rt.Vec) => rt.Vec): rt.Vec { +export function unwrapOrElse$05mb9nr(self: rs.Result, rs.Vec>, op: (a0: rs.Vec) => rs.Vec): rs.Vec { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$1bt75f9(self: rt.Result, op: (a0: rt.ByteVec) => rt.ByteVec): rt.ByteVec { +export function unwrapOrElse$0pqj9wx(self: rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.ByteVec { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$1341i4f(self: rt.Result, rt.Vec>, op: (a0: rt.Vec) => rt.Vec): rt.Vec { +export function unwrapOrElse$01ys8fc(self: rs.Result, rs.Vec>, op: (a0: rs.Vec) => rs.Vec): rs.Vec { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/capacity/expected/harness.ts b/ts/fixtures/lang/capacity/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/capacity/expected/harness.ts +++ b/ts/fixtures/lang/capacity/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/capacity/expected/lib.ts b/ts/fixtures/lang/capacity/expected/lib.ts index 9fec297d5..4c151945f 100644 --- a/ts/fixtures/lang/capacity/expected/lib.ts +++ b/ts/fixtures/lang/capacity/expected/lib.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { vecs, cloneFroms, deques, heaps, collects, maps } from "./capacity.ts"; -export function copy$array_u64(v: rt.u64[]): rt.u64[] { +export function copy$array_u64(v: rs.u64[]): rs.u64[] { return v.slice(); } -export function copy$array_usize(v: rt.usize[]): rt.usize[] { +export function copy$array_usize(v: rs.usize[]): rs.usize[] { return v.slice(); } -export function copy$tuple2_u64_u8(v: [rt.u64, rt.u8]): [rt.u64, rt.u8] { +export function copy$tuple2_u64_u8(v: [rs.u64, rs.u8]): [rs.u64, rs.u8] { return [v[0], v[1]]; } @@ -19,14 +19,14 @@ export function copy$tuple2_u64_u8(v: [rt.u64, rt.u8]): [rt.u64, rt.u8] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["capacity::vecs", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["capacity::vecs", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { vecs(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::deques", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::deques", (a02: rs.u8, a12: rs.ByteSlice, a22: rs.ByteVec): undefined => { deques(a02, a12.data, a12.start, a12.length, a22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::heaps", (a03: rt.u8, a13: rt.ByteSlice, a23: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::heaps", (a03: rs.u8, a13: rs.ByteSlice, a23: rs.ByteVec): undefined => { heaps(a03, a13.data, a13.start, a13.length, a23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::collects", collects as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::maps", maps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::collects", collects as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::maps", maps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["capacity::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/captures/expected/captures.ts b/ts/fixtures/lang/captures/expected/captures.ts index a788a4642..7fcfeb091 100644 --- a/ts/fixtures/lang/captures/expected/captures.ts +++ b/ts/fixtures/lang/captures/expected/captures.ts @@ -1,38 +1,38 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function through$u8s(n: rt.Place, b: rt.u8): rt.u8 { - return ((): rt.u8 => { - n.v = rt.u8WrappingAdd(n.v, b); +export function through$u8s(n: rs.Place, b: rs.u8): rs.u8 { + return ((): rs.u8 => { + n.v = rs.u8WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { +export function u8s(data: rs.ByteSlice, out: rs.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u8 = rt.u8FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u8 = _18; + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u8 = rs.u8FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u8 = _18; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.u8 = ([rt.u8FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.u8, rt.ByteSlice])[0]; - const put: (a0: rt.u8) => undefined = (v: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v))); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.u8 = ([rs.u8FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.u8, rs.ByteSlice])[0]; + const put: (a0: rs.u8) => undefined = (v: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v))); }; - let n3: rt.u8 = a; - const part = ((): rt.u8 => { - n3 = rt.u8WrappingAdd(n3, b); + let n3: rs.u8 = a; + const part = ((): rs.u8 => { + n3 = rs.u8WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.u8 = (): rt.u8 => { - n3 = rt.u8WrappingMul(n3, b); + const bump2: () => rs.u8 = (): rs.u8 => { + n3 = rs.u8WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -40,42 +40,42 @@ export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.u8 => { + const part6 = ((): rs.u8 => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.u8WrappingSub(n3, a); + n3 = rs.u8WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.u8 => { - n3 = rt.u8WrappingAdd(n3, captured.length & 0xff); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.u8 => { + n3 = rs.u8WrappingAdd(n3, captured.length & 0xff); return n3; })(); put(part8); put(n3); - const part10 = once$u8_captures_u8s_closure5((): rt.u8 => { - n3 = rt.u8WrappingAdd(n3, b); + const part10 = once$u8_captures_u8s_closure5((): rs.u8 => { + n3 = rs.u8WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.u8, rt.u8] = twice$u8_captures_u8s_closure6((): rt.u8 => { - n3 = rt.u8WrappingAdd(n3, a); + const _108: [rs.u8, rs.u8] = twice$u8_captures_u8s_closure6((): rs.u8 => { + n3 = rs.u8WrappingAdd(n3, a); return n3; }); - const x: rt.u8 = _108[0]; - const y: rt.u8 = _108[1]; + const x: rs.u8 = _108[0]; + const y: rs.u8 = _108[1]; put(x); put(y); put(n3); - let m: rt.u8 = a; + let m: rs.u8 = a; let captured2 = m; const captured3 = b; - const own: () => rt.u8 = (): rt.u8 => { - captured2 = rt.u8WrappingAdd(captured2, captured3); + const own: () => rs.u8 = (): rs.u8 => { + captured2 = rs.u8WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -83,19 +83,19 @@ export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.u8, rt.u8] = [a, b]; - const part16 = ((): rt.u8 => { - pair[0] = rt.u8WrappingAdd(pair[0], pair[1]); + const pair: [rs.u8, rs.u8] = [a, b]; + const part16 = ((): rs.u8 => { + pair[0] = rs.u8WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$u8s(rt.place(() => m, (value) => m = value), b); + const part18 = through$u8s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.u8 => { - return ((): rt.u8 => { - n3 = rt.u8WrappingSub(n3, b); + const part20 = ((): rs.u8 => { + return ((): rs.u8 => { + n3 = rs.u8WrappingSub(n3, b); return n3; })(); })(); @@ -103,37 +103,37 @@ export function u8s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$u16s(n: rt.Place, b: rt.u16): rt.u16 { - return ((): rt.u16 => { - n.v = rt.u16WrappingAdd(n.v, b); +export function through$u16s(n: rs.Place, b: rs.u16): rs.u16 { + return ((): rs.u16 => { + n.v = rs.u16WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u16 = rt.u16FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u16 = _18; - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.u16 = ([rt.u16FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.u16, rt.ByteSlice])[0]; - const put: (a0: rt.u16) => undefined = (v: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v))); +export function u16s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u16 = rs.u16FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u16 = _18; + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.u16 = ([rs.u16FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.u16, rs.ByteSlice])[0]; + const put: (a0: rs.u16) => undefined = (v: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v))); }; - let n3: rt.u16 = a; - const part = ((): rt.u16 => { - n3 = rt.u16WrappingAdd(n3, b); + let n3: rs.u16 = a; + const part = ((): rs.u16 => { + n3 = rs.u16WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.u16 = (): rt.u16 => { - n3 = rt.u16WrappingMul(n3, b); + const bump2: () => rs.u16 = (): rs.u16 => { + n3 = rs.u16WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -141,42 +141,42 @@ export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.u16 => { + const part6 = ((): rs.u16 => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.u16WrappingSub(n3, a); + n3 = rs.u16WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.u16 => { - n3 = rt.u16WrappingAdd(n3, captured.length & 0xffff); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.u16 => { + n3 = rs.u16WrappingAdd(n3, captured.length & 0xffff); return n3; })(); put(part8); put(n3); - const part10 = once$u16_captures_u16s_closure5((): rt.u16 => { - n3 = rt.u16WrappingAdd(n3, b); + const part10 = once$u16_captures_u16s_closure5((): rs.u16 => { + n3 = rs.u16WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.u16, rt.u16] = twice$u16_captures_u16s_closure6((): rt.u16 => { - n3 = rt.u16WrappingAdd(n3, a); + const _108: [rs.u16, rs.u16] = twice$u16_captures_u16s_closure6((): rs.u16 => { + n3 = rs.u16WrappingAdd(n3, a); return n3; }); - const x: rt.u16 = _108[0]; - const y: rt.u16 = _108[1]; + const x: rs.u16 = _108[0]; + const y: rs.u16 = _108[1]; put(x); put(y); put(n3); - let m: rt.u16 = a; + let m: rs.u16 = a; let captured2 = m; const captured3 = b; - const own: () => rt.u16 = (): rt.u16 => { - captured2 = rt.u16WrappingAdd(captured2, captured3); + const own: () => rs.u16 = (): rs.u16 => { + captured2 = rs.u16WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -184,19 +184,19 @@ export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.u16, rt.u16] = [a, b]; - const part16 = ((): rt.u16 => { - pair[0] = rt.u16WrappingAdd(pair[0], pair[1]); + const pair: [rs.u16, rs.u16] = [a, b]; + const part16 = ((): rs.u16 => { + pair[0] = rs.u16WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$u16s(rt.place(() => m, (value) => m = value), b); + const part18 = through$u16s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.u16 => { - return ((): rt.u16 => { - n3 = rt.u16WrappingSub(n3, b); + const part20 = ((): rs.u16 => { + return ((): rs.u16 => { + n3 = rs.u16WrappingSub(n3, b); return n3; })(); })(); @@ -204,37 +204,37 @@ export function u16s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$u32s(n: rt.Place, b: rt.u32): rt.u32 { - return ((): rt.u32 => { - n.v = rt.u32WrappingAdd(n.v, b); +export function through$u32s(n: rs.Place, b: rs.u32): rs.u32 { + return ((): rs.u32 => { + n.v = rs.u32WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u32 = rt.u32FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u32 = _18; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.u32 = ([rt.u32FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.u32, rt.ByteSlice])[0]; - const put: (a0: rt.u32) => undefined = (v: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v))); +export function u32s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u32 = rs.u32FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u32 = _18; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.u32 = ([rs.u32FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.u32, rs.ByteSlice])[0]; + const put: (a0: rs.u32) => undefined = (v: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v))); }; - let n3: rt.u32 = a; - const part = ((): rt.u32 => { - n3 = rt.u32WrappingAdd(n3, b); + let n3: rs.u32 = a; + const part = ((): rs.u32 => { + n3 = rs.u32WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.u32 = (): rt.u32 => { - n3 = rt.u32WrappingMul(n3, b); + const bump2: () => rs.u32 = (): rs.u32 => { + n3 = rs.u32WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -242,42 +242,42 @@ export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.u32 => { + const part6 = ((): rs.u32 => { if (!(((b & 1) >>> 0) === 1)) { return n3; } - n3 = rt.u32WrappingSub(n3, a); + n3 = rs.u32WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.u32 => { - n3 = rt.u32WrappingAdd(n3, captured.length as rt.u32); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.u32 => { + n3 = rs.u32WrappingAdd(n3, captured.length as rs.u32); return n3; })(); put(part8); put(n3); - const part10 = once$u32_captures_u32s_closure5((): rt.u32 => { - n3 = rt.u32WrappingAdd(n3, b); + const part10 = once$u32_captures_u32s_closure5((): rs.u32 => { + n3 = rs.u32WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.u32, rt.u32] = twice$u32_captures_u32s_closure6((): rt.u32 => { - n3 = rt.u32WrappingAdd(n3, a); + const _108: [rs.u32, rs.u32] = twice$u32_captures_u32s_closure6((): rs.u32 => { + n3 = rs.u32WrappingAdd(n3, a); return n3; }); - const x: rt.u32 = _108[0]; - const y: rt.u32 = _108[1]; + const x: rs.u32 = _108[0]; + const y: rs.u32 = _108[1]; put(x); put(y); put(n3); - let m: rt.u32 = a; + let m: rs.u32 = a; let captured2 = m; const captured3 = b; - const own: () => rt.u32 = (): rt.u32 => { - captured2 = rt.u32WrappingAdd(captured2, captured3); + const own: () => rs.u32 = (): rs.u32 => { + captured2 = rs.u32WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -285,19 +285,19 @@ export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.u32, rt.u32] = [a, b]; - const part16 = ((): rt.u32 => { - pair[0] = rt.u32WrappingAdd(pair[0], pair[1]); + const pair: [rs.u32, rs.u32] = [a, b]; + const part16 = ((): rs.u32 => { + pair[0] = rs.u32WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$u32s(rt.place(() => m, (value) => m = value), b); + const part18 = through$u32s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.u32 => { - return ((): rt.u32 => { - n3 = rt.u32WrappingSub(n3, b); + const part20 = ((): rs.u32 => { + return ((): rs.u32 => { + n3 = rs.u32WrappingSub(n3, b); return n3; })(); })(); @@ -305,37 +305,37 @@ export function u32s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$u64s(n: rt.Place, b: rt.u64): rt.u64 { - return ((): rt.u64 => { - n.v = rt.u64WrappingAdd(n.v, b); +export function through$u64s(n: rs.Place, b: rs.u64): rs.u64 { + return ((): rs.u64 => { + n.v = rs.u64WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u64 = rt.u64FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u64 = _18; - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.u64 = ([rt.u64FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.u64, rt.ByteSlice])[0]; - const put: (a0: rt.u64) => undefined = (v: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v))); +export function u64s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u64 = rs.u64FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u64 = _18; + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.u64 = ([rs.u64FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.u64, rs.ByteSlice])[0]; + const put: (a0: rs.u64) => undefined = (v: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v))); }; - let n3: rt.u64 = a; - const part = ((): rt.u64 => { - n3 = rt.u64WrappingAdd(n3, b); + let n3: rs.u64 = a; + const part = ((): rs.u64 => { + n3 = rs.u64WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.u64 = (): rt.u64 => { - n3 = rt.u64WrappingMul(n3, b); + const bump2: () => rs.u64 = (): rs.u64 => { + n3 = rs.u64WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -343,42 +343,42 @@ export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.u64 => { - if (!(rt.u64And(b, 1) === 1)) { + const part6 = ((): rs.u64 => { + if (!(rs.u64And(b, 1) === 1)) { return n3; } - n3 = rt.u64WrappingSub(n3, a); + n3 = rs.u64WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.u64 => { - n3 = rt.u64WrappingAdd(n3, captured.length as rt.u64); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.u64 => { + n3 = rs.u64WrappingAdd(n3, captured.length as rs.u64); return n3; })(); put(part8); put(n3); - const part10 = once$u64_captures_u64s_closure5((): rt.u64 => { - n3 = rt.u64WrappingAdd(n3, b); + const part10 = once$u64_captures_u64s_closure5((): rs.u64 => { + n3 = rs.u64WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.u64, rt.u64] = twice$u64_captures_u64s_closure6((): rt.u64 => { - n3 = rt.u64WrappingAdd(n3, a); + const _108: [rs.u64, rs.u64] = twice$u64_captures_u64s_closure6((): rs.u64 => { + n3 = rs.u64WrappingAdd(n3, a); return n3; }); - const x: rt.u64 = _108[0]; - const y: rt.u64 = _108[1]; + const x: rs.u64 = _108[0]; + const y: rs.u64 = _108[1]; put(x); put(y); put(n3); - let m: rt.u64 = a; + let m: rs.u64 = a; let captured2 = m; const captured3 = b; - const own: () => rt.u64 = (): rt.u64 => { - captured2 = rt.u64WrappingAdd(captured2, captured3); + const own: () => rs.u64 = (): rs.u64 => { + captured2 = rs.u64WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -386,19 +386,19 @@ export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.u64, rt.u64] = [a, b]; - const part16 = ((): rt.u64 => { - pair[0] = rt.u64WrappingAdd(pair[0], pair[1]); + const pair: [rs.u64, rs.u64] = [a, b]; + const part16 = ((): rs.u64 => { + pair[0] = rs.u64WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$u64s(rt.place(() => m, (value) => m = value), b); + const part18 = through$u64s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.u64 => { - return ((): rt.u64 => { - n3 = rt.u64WrappingSub(n3, b); + const part20 = ((): rs.u64 => { + return ((): rs.u64 => { + n3 = rs.u64WrappingSub(n3, b); return n3; })(); })(); @@ -406,37 +406,37 @@ export function u64s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$u128s(n: rt.Place, b: rt.u128): rt.u128 { - return ((): rt.u128 => { - n.v = rt.u128WrappingAdd(n.v, b); +export function through$u128s(n: rs.Place, b: rs.u128): rs.u128 { + return ((): rs.u128 => { + n.v = rs.u128WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function u128s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u128 = rt.u128FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u128 = _18; - const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.u128 = ([rt.u128FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.u128, rt.ByteSlice])[0]; - const put: (a0: rt.u128) => undefined = (v: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v))); +export function u128s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u128 = rs.u128FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u128 = _18; + const buf2: Uint8Array = rs.bytes(16); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.u128 = ([rs.u128FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.u128, rs.ByteSlice])[0]; + const put: (a0: rs.u128) => undefined = (v: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v))); }; - let n3: rt.u128 = a; - const part = ((): rt.u128 => { - n3 = rt.u128WrappingAdd(n3, b); + let n3: rs.u128 = a; + const part = ((): rs.u128 => { + n3 = rs.u128WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.u128 = (): rt.u128 => { - n3 = rt.u128WrappingMul(n3, b); + const bump2: () => rs.u128 = (): rs.u128 => { + n3 = rs.u128WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -444,42 +444,42 @@ export function u128s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.u128 => { - if (!(rt.u128And(b, 1) === 1)) { + const part6 = ((): rs.u128 => { + if (!(rs.u128And(b, 1) === 1)) { return n3; } - n3 = rt.u128WrappingSub(n3, a); + n3 = rs.u128WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.u128 => { - n3 = rt.u128WrappingAdd(n3, captured.length as rt.u128); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.u128 => { + n3 = rs.u128WrappingAdd(n3, captured.length as rs.u128); return n3; })(); put(part8); put(n3); - const part10 = once$u128_captures_u128s_closure5((): rt.u128 => { - n3 = rt.u128WrappingAdd(n3, b); + const part10 = once$u128_captures_u128s_closure5((): rs.u128 => { + n3 = rs.u128WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.u128, rt.u128] = twice$u128_captures_u128s_closure6((): rt.u128 => { - n3 = rt.u128WrappingAdd(n3, a); + const _108: [rs.u128, rs.u128] = twice$u128_captures_u128s_closure6((): rs.u128 => { + n3 = rs.u128WrappingAdd(n3, a); return n3; }); - const x: rt.u128 = _108[0]; - const y: rt.u128 = _108[1]; + const x: rs.u128 = _108[0]; + const y: rs.u128 = _108[1]; put(x); put(y); put(n3); - let m: rt.u128 = a; + let m: rs.u128 = a; let captured2 = m; const captured3 = b; - const own: () => rt.u128 = (): rt.u128 => { - captured2 = rt.u128WrappingAdd(captured2, captured3); + const own: () => rs.u128 = (): rs.u128 => { + captured2 = rs.u128WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -487,19 +487,19 @@ export function u128s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.u128, rt.u128] = [a, b]; - const part16 = ((): rt.u128 => { - pair[0] = rt.u128WrappingAdd(pair[0], pair[1]); + const pair: [rs.u128, rs.u128] = [a, b]; + const part16 = ((): rs.u128 => { + pair[0] = rs.u128WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$u128s(rt.place(() => m, (value) => m = value), b); + const part18 = through$u128s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.u128 => { - return ((): rt.u128 => { - n3 = rt.u128WrappingSub(n3, b); + const part20 = ((): rs.u128 => { + return ((): rs.u128 => { + n3 = rs.u128WrappingSub(n3, b); return n3; })(); })(); @@ -507,37 +507,37 @@ export function u128s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$usizes(n: rt.Place, b: rt.usize): rt.usize { - return ((): rt.usize => { - n.v = rt.usizeWrappingAdd(n.v, b); +export function through$usizes(n: rs.Place, b: rs.usize): rs.usize { + return ((): rs.usize => { + n.v = rs.usizeWrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.usize = rt.usizeFromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.usize = _18; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.usize = ([rt.usizeFromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.usize, rt.ByteSlice])[0]; - const put: (a0: rt.usize) => undefined = (v: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v))); +export function usizes(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.usize = rs.usizeFromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.usize = _18; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.usize = ([rs.usizeFromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.usize, rs.ByteSlice])[0]; + const put: (a0: rs.usize) => undefined = (v: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v))); }; - let n3: rt.usize = a; - const part = ((): rt.usize => { - n3 = rt.usizeWrappingAdd(n3, b); + let n3: rs.usize = a; + const part = ((): rs.usize => { + n3 = rs.usizeWrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.usize = (): rt.usize => { - n3 = rt.usizeWrappingMul(n3, b); + const bump2: () => rs.usize = (): rs.usize => { + n3 = rs.usizeWrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -545,42 +545,42 @@ export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.usize => { + const part6 = ((): rs.usize => { if (!(((b & 1) >>> 0) === 1)) { return n3; } - n3 = rt.usizeWrappingSub(n3, a); + n3 = rs.usizeWrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.usize => { - n3 = rt.usizeWrappingAdd(n3, captured.length); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.usize => { + n3 = rs.usizeWrappingAdd(n3, captured.length); return n3; })(); put(part8); put(n3); - const part10 = once$usize_captures_usizes_closure5((): rt.usize => { - n3 = rt.usizeWrappingAdd(n3, b); + const part10 = once$usize_captures_usizes_closure5((): rs.usize => { + n3 = rs.usizeWrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.usize, rt.usize] = twice$usize_captures_usizes_closure6((): rt.usize => { - n3 = rt.usizeWrappingAdd(n3, a); + const _108: [rs.usize, rs.usize] = twice$usize_captures_usizes_closure6((): rs.usize => { + n3 = rs.usizeWrappingAdd(n3, a); return n3; }); - const x: rt.usize = _108[0]; - const y: rt.usize = _108[1]; + const x: rs.usize = _108[0]; + const y: rs.usize = _108[1]; put(x); put(y); put(n3); - let m: rt.usize = a; + let m: rs.usize = a; let captured2 = m; const captured3 = b; - const own: () => rt.usize = (): rt.usize => { - captured2 = rt.usizeWrappingAdd(captured2, captured3); + const own: () => rs.usize = (): rs.usize => { + captured2 = rs.usizeWrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -588,19 +588,19 @@ export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.usize, rt.usize] = [a, b]; - const part16 = ((): rt.usize => { - pair[0] = rt.usizeWrappingAdd(pair[0], pair[1]); + const pair: [rs.usize, rs.usize] = [a, b]; + const part16 = ((): rs.usize => { + pair[0] = rs.usizeWrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$usizes(rt.place(() => m, (value) => m = value), b); + const part18 = through$usizes(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.usize => { - return ((): rt.usize => { - n3 = rt.usizeWrappingSub(n3, b); + const part20 = ((): rs.usize => { + return ((): rs.usize => { + n3 = rs.usizeWrappingSub(n3, b); return n3; })(); })(); @@ -609,29 +609,29 @@ export function usizes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i8s(data: rs.ByteSlice, out: rs.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i8 = rt.i8FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i8 = _18; + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i8 = rs.i8FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i8 = _18; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.i8 = ([rt.i8FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i8, rt.ByteSlice])[0]; - const put: (a0: rt.i8) => undefined = (v: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v))); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.i8 = ([rs.i8FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i8, rs.ByteSlice])[0]; + const put: (a0: rs.i8) => undefined = (v: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v))); }; - let n3: rt.i8 = a; - const part = ((): rt.i8 => { - n3 = rt.i8WrappingAdd(n3, b); + let n3: rs.i8 = a; + const part = ((): rs.i8 => { + n3 = rs.i8WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.i8 = (): rt.i8 => { - n3 = rt.i8WrappingMul(n3, b); + const bump2: () => rs.i8 = (): rs.i8 => { + n3 = rs.i8WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -639,42 +639,42 @@ export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.i8 => { + const part6 = ((): rs.i8 => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.i8WrappingSub(n3, a); + n3 = rs.i8WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.i8 => { - n3 = rt.i8WrappingAdd(n3, (captured.length << 24) >> 24); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.i8 => { + n3 = rs.i8WrappingAdd(n3, (captured.length << 24) >> 24); return n3; })(); put(part8); put(n3); - const part10 = once$i8_captures_i8s_closure5((): rt.i8 => { - n3 = rt.i8WrappingAdd(n3, b); + const part10 = once$i8_captures_i8s_closure5((): rs.i8 => { + n3 = rs.i8WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.i8, rt.i8] = twice$i8_captures_i8s_closure6((): rt.i8 => { - n3 = rt.i8WrappingAdd(n3, a); + const _108: [rs.i8, rs.i8] = twice$i8_captures_i8s_closure6((): rs.i8 => { + n3 = rs.i8WrappingAdd(n3, a); return n3; }); - const x: rt.i8 = _108[0]; - const y: rt.i8 = _108[1]; + const x: rs.i8 = _108[0]; + const y: rs.i8 = _108[1]; put(x); put(y); put(n3); - let m: rt.i8 = a; + let m: rs.i8 = a; let captured2 = m; const captured3 = b; - const own: () => rt.i8 = (): rt.i8 => { - captured2 = rt.i8WrappingAdd(captured2, captured3); + const own: () => rs.i8 = (): rs.i8 => { + captured2 = rs.i8WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -682,19 +682,19 @@ export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.i8, rt.i8] = [a, b]; - const part16 = ((): rt.i8 => { - pair[0] = rt.i8WrappingAdd(pair[0], pair[1]); + const pair: [rs.i8, rs.i8] = [a, b]; + const part16 = ((): rs.i8 => { + pair[0] = rs.i8WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$i8s(rt.place(() => m, (value) => m = value), b); + const part18 = through$i8s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.i8 => { - return ((): rt.i8 => { - n3 = rt.i8WrappingSub(n3, b); + const part20 = ((): rs.i8 => { + return ((): rs.i8 => { + n3 = rs.i8WrappingSub(n3, b); return n3; })(); })(); @@ -702,37 +702,37 @@ export function i8s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$i8s(n: rt.Place, b: rt.i8): rt.i8 { - return ((): rt.i8 => { - n.v = rt.i8WrappingAdd(n.v, b); +export function through$i8s(n: rs.Place, b: rs.i8): rs.i8 { + return ((): rs.i8 => { + n.v = rs.i8WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i16 = rt.i16FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i16 = _18; - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.i16 = ([rt.i16FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i16, rt.ByteSlice])[0]; - const put: (a0: rt.i16) => undefined = (v: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v))); +export function i16s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i16 = rs.i16FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i16 = _18; + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.i16 = ([rs.i16FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i16, rs.ByteSlice])[0]; + const put: (a0: rs.i16) => undefined = (v: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v))); }; - let n3: rt.i16 = a; - const part = ((): rt.i16 => { - n3 = rt.i16WrappingAdd(n3, b); + let n3: rs.i16 = a; + const part = ((): rs.i16 => { + n3 = rs.i16WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.i16 = (): rt.i16 => { - n3 = rt.i16WrappingMul(n3, b); + const bump2: () => rs.i16 = (): rs.i16 => { + n3 = rs.i16WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -740,42 +740,42 @@ export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.i16 => { + const part6 = ((): rs.i16 => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.i16WrappingSub(n3, a); + n3 = rs.i16WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.i16 => { - n3 = rt.i16WrappingAdd(n3, (captured.length << 16) >> 16); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.i16 => { + n3 = rs.i16WrappingAdd(n3, (captured.length << 16) >> 16); return n3; })(); put(part8); put(n3); - const part10 = once$i16_captures_i16s_closure5((): rt.i16 => { - n3 = rt.i16WrappingAdd(n3, b); + const part10 = once$i16_captures_i16s_closure5((): rs.i16 => { + n3 = rs.i16WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.i16, rt.i16] = twice$i16_captures_i16s_closure6((): rt.i16 => { - n3 = rt.i16WrappingAdd(n3, a); + const _108: [rs.i16, rs.i16] = twice$i16_captures_i16s_closure6((): rs.i16 => { + n3 = rs.i16WrappingAdd(n3, a); return n3; }); - const x: rt.i16 = _108[0]; - const y: rt.i16 = _108[1]; + const x: rs.i16 = _108[0]; + const y: rs.i16 = _108[1]; put(x); put(y); put(n3); - let m: rt.i16 = a; + let m: rs.i16 = a; let captured2 = m; const captured3 = b; - const own: () => rt.i16 = (): rt.i16 => { - captured2 = rt.i16WrappingAdd(captured2, captured3); + const own: () => rs.i16 = (): rs.i16 => { + captured2 = rs.i16WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -783,19 +783,19 @@ export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.i16, rt.i16] = [a, b]; - const part16 = ((): rt.i16 => { - pair[0] = rt.i16WrappingAdd(pair[0], pair[1]); + const pair: [rs.i16, rs.i16] = [a, b]; + const part16 = ((): rs.i16 => { + pair[0] = rs.i16WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$i16s(rt.place(() => m, (value) => m = value), b); + const part18 = through$i16s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.i16 => { - return ((): rt.i16 => { - n3 = rt.i16WrappingSub(n3, b); + const part20 = ((): rs.i16 => { + return ((): rs.i16 => { + n3 = rs.i16WrappingSub(n3, b); return n3; })(); })(); @@ -803,37 +803,37 @@ export function i16s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$i16s(n: rt.Place, b: rt.i16): rt.i16 { - return ((): rt.i16 => { - n.v = rt.i16WrappingAdd(n.v, b); +export function through$i16s(n: rs.Place, b: rs.i16): rs.i16 { + return ((): rs.i16 => { + n.v = rs.i16WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i32 = rt.i32FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i32 = _18; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.i32 = ([rt.i32FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i32, rt.ByteSlice])[0]; - const put: (a0: rt.i32) => undefined = (v: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v))); +export function i32s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i32 = rs.i32FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i32 = _18; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.i32 = ([rs.i32FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i32, rs.ByteSlice])[0]; + const put: (a0: rs.i32) => undefined = (v: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v))); }; - let n3: rt.i32 = a; - const part = ((): rt.i32 => { - n3 = rt.i32WrappingAdd(n3, b); + let n3: rs.i32 = a; + const part = ((): rs.i32 => { + n3 = rs.i32WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.i32 = (): rt.i32 => { - n3 = rt.i32WrappingMul(n3, b); + const bump2: () => rs.i32 = (): rs.i32 => { + n3 = rs.i32WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -841,42 +841,42 @@ export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.i32 => { + const part6 = ((): rs.i32 => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.i32WrappingSub(n3, a); + n3 = rs.i32WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.i32 => { - n3 = rt.i32WrappingAdd(n3, captured.length | 0); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.i32 => { + n3 = rs.i32WrappingAdd(n3, captured.length | 0); return n3; })(); put(part8); put(n3); - const part10 = once$i32_captures_i32s_closure5((): rt.i32 => { - n3 = rt.i32WrappingAdd(n3, b); + const part10 = once$i32_captures_i32s_closure5((): rs.i32 => { + n3 = rs.i32WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.i32, rt.i32] = twice$i32_captures_i32s_closure6((): rt.i32 => { - n3 = rt.i32WrappingAdd(n3, a); + const _108: [rs.i32, rs.i32] = twice$i32_captures_i32s_closure6((): rs.i32 => { + n3 = rs.i32WrappingAdd(n3, a); return n3; }); - const x: rt.i32 = _108[0]; - const y: rt.i32 = _108[1]; + const x: rs.i32 = _108[0]; + const y: rs.i32 = _108[1]; put(x); put(y); put(n3); - let m: rt.i32 = a; + let m: rs.i32 = a; let captured2 = m; const captured3 = b; - const own: () => rt.i32 = (): rt.i32 => { - captured2 = rt.i32WrappingAdd(captured2, captured3); + const own: () => rs.i32 = (): rs.i32 => { + captured2 = rs.i32WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -884,19 +884,19 @@ export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.i32, rt.i32] = [a, b]; - const part16 = ((): rt.i32 => { - pair[0] = rt.i32WrappingAdd(pair[0], pair[1]); + const pair: [rs.i32, rs.i32] = [a, b]; + const part16 = ((): rs.i32 => { + pair[0] = rs.i32WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$i32s(rt.place(() => m, (value) => m = value), b); + const part18 = through$i32s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.i32 => { - return ((): rt.i32 => { - n3 = rt.i32WrappingSub(n3, b); + const part20 = ((): rs.i32 => { + return ((): rs.i32 => { + n3 = rs.i32WrappingSub(n3, b); return n3; })(); })(); @@ -904,37 +904,37 @@ export function i32s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$i32s(n: rt.Place, b: rt.i32): rt.i32 { - return ((): rt.i32 => { - n.v = rt.i32WrappingAdd(n.v, b); +export function through$i32s(n: rs.Place, b: rs.i32): rs.i32 { + return ((): rs.i32 => { + n.v = rs.i32WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i64 = rt.i64FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i64 = _18; - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.i64 = ([rt.i64FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i64, rt.ByteSlice])[0]; - const put: (a0: rt.i64) => undefined = (v: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v))); +export function i64s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i64 = rs.i64FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i64 = _18; + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.i64 = ([rs.i64FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i64, rs.ByteSlice])[0]; + const put: (a0: rs.i64) => undefined = (v: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v))); }; - let n3: rt.i64 = a; - const part = ((): rt.i64 => { - n3 = rt.i64WrappingAdd(n3, b); + let n3: rs.i64 = a; + const part = ((): rs.i64 => { + n3 = rs.i64WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.i64 = (): rt.i64 => { - n3 = rt.i64WrappingMul(n3, b); + const bump2: () => rs.i64 = (): rs.i64 => { + n3 = rs.i64WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -942,42 +942,42 @@ export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.i64 => { - if (!(rt.i64And(b, 1) === 1)) { + const part6 = ((): rs.i64 => { + if (!(rs.i64And(b, 1) === 1)) { return n3; } - n3 = rt.i64WrappingSub(n3, a); + n3 = rs.i64WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.i64 => { - n3 = rt.i64WrappingAdd(n3, captured.length as rt.i64); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.i64 => { + n3 = rs.i64WrappingAdd(n3, captured.length as rs.i64); return n3; })(); put(part8); put(n3); - const part10 = once$i64_captures_i64s_closure5((): rt.i64 => { - n3 = rt.i64WrappingAdd(n3, b); + const part10 = once$i64_captures_i64s_closure5((): rs.i64 => { + n3 = rs.i64WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.i64, rt.i64] = twice$i64_captures_i64s_closure6((): rt.i64 => { - n3 = rt.i64WrappingAdd(n3, a); + const _108: [rs.i64, rs.i64] = twice$i64_captures_i64s_closure6((): rs.i64 => { + n3 = rs.i64WrappingAdd(n3, a); return n3; }); - const x: rt.i64 = _108[0]; - const y: rt.i64 = _108[1]; + const x: rs.i64 = _108[0]; + const y: rs.i64 = _108[1]; put(x); put(y); put(n3); - let m: rt.i64 = a; + let m: rs.i64 = a; let captured2 = m; const captured3 = b; - const own: () => rt.i64 = (): rt.i64 => { - captured2 = rt.i64WrappingAdd(captured2, captured3); + const own: () => rs.i64 = (): rs.i64 => { + captured2 = rs.i64WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -985,19 +985,19 @@ export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.i64, rt.i64] = [a, b]; - const part16 = ((): rt.i64 => { - pair[0] = rt.i64WrappingAdd(pair[0], pair[1]); + const pair: [rs.i64, rs.i64] = [a, b]; + const part16 = ((): rs.i64 => { + pair[0] = rs.i64WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$i64s(rt.place(() => m, (value) => m = value), b); + const part18 = through$i64s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.i64 => { - return ((): rt.i64 => { - n3 = rt.i64WrappingSub(n3, b); + const part20 = ((): rs.i64 => { + return ((): rs.i64 => { + n3 = rs.i64WrappingSub(n3, b); return n3; })(); })(); @@ -1005,37 +1005,37 @@ export function i64s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$i64s(n: rt.Place, b: rt.i64): rt.i64 { - return ((): rt.i64 => { - n.v = rt.i64WrappingAdd(n.v, b); +export function through$i64s(n: rs.Place, b: rs.i64): rs.i64 { + return ((): rs.i64 => { + n.v = rs.i64WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function i128s(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.i128 = rt.i128FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i128 = _18; - const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.i128 = ([rt.i128FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i128, rt.ByteSlice])[0]; - const put: (a0: rt.i128) => undefined = (v: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v))); +export function i128s(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.i128 = rs.i128FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i128 = _18; + const buf2: Uint8Array = rs.bytes(16); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.i128 = ([rs.i128FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i128, rs.ByteSlice])[0]; + const put: (a0: rs.i128) => undefined = (v: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v))); }; - let n3: rt.i128 = a; - const part = ((): rt.i128 => { - n3 = rt.i128WrappingAdd(n3, b); + let n3: rs.i128 = a; + const part = ((): rs.i128 => { + n3 = rs.i128WrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.i128 = (): rt.i128 => { - n3 = rt.i128WrappingMul(n3, b); + const bump2: () => rs.i128 = (): rs.i128 => { + n3 = rs.i128WrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -1043,42 +1043,42 @@ export function i128s(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.i128 => { - if (!(rt.i128And(b, 1) === 1)) { + const part6 = ((): rs.i128 => { + if (!(rs.i128And(b, 1) === 1)) { return n3; } - n3 = rt.i128WrappingSub(n3, a); + n3 = rs.i128WrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.i128 => { - n3 = rt.i128WrappingAdd(n3, captured.length as rt.i128); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.i128 => { + n3 = rs.i128WrappingAdd(n3, captured.length as rs.i128); return n3; })(); put(part8); put(n3); - const part10 = once$i128_captures_i128s_closure5((): rt.i128 => { - n3 = rt.i128WrappingAdd(n3, b); + const part10 = once$i128_captures_i128s_closure5((): rs.i128 => { + n3 = rs.i128WrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.i128, rt.i128] = twice$i128_captures_i128s_closure6((): rt.i128 => { - n3 = rt.i128WrappingAdd(n3, a); + const _108: [rs.i128, rs.i128] = twice$i128_captures_i128s_closure6((): rs.i128 => { + n3 = rs.i128WrappingAdd(n3, a); return n3; }); - const x: rt.i128 = _108[0]; - const y: rt.i128 = _108[1]; + const x: rs.i128 = _108[0]; + const y: rs.i128 = _108[1]; put(x); put(y); put(n3); - let m: rt.i128 = a; + let m: rs.i128 = a; let captured2 = m; const captured3 = b; - const own: () => rt.i128 = (): rt.i128 => { - captured2 = rt.i128WrappingAdd(captured2, captured3); + const own: () => rs.i128 = (): rs.i128 => { + captured2 = rs.i128WrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -1086,19 +1086,19 @@ export function i128s(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.i128, rt.i128] = [a, b]; - const part16 = ((): rt.i128 => { - pair[0] = rt.i128WrappingAdd(pair[0], pair[1]); + const pair: [rs.i128, rs.i128] = [a, b]; + const part16 = ((): rs.i128 => { + pair[0] = rs.i128WrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$i128s(rt.place(() => m, (value) => m = value), b); + const part18 = through$i128s(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.i128 => { - return ((): rt.i128 => { - n3 = rt.i128WrappingSub(n3, b); + const part20 = ((): rs.i128 => { + return ((): rs.i128 => { + n3 = rs.i128WrappingSub(n3, b); return n3; })(); })(); @@ -1106,37 +1106,37 @@ export function i128s(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$i128s(n: rt.Place, b: rt.i128): rt.i128 { - return ((): rt.i128 => { - n.v = rt.i128WrappingAdd(n.v, b); +export function through$i128s(n: rs.Place, b: rs.i128): rs.i128 { + return ((): rs.i128 => { + n.v = rs.i128WrappingAdd(n.v, b); return n.v; })(); } /** Each way a closure writes a captured integer, from two operands taken from `data`. */ -export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.isize = rt.isizeFromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.isize = _18; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const b: rt.isize = ([rt.isizeFromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.isize, rt.ByteSlice])[0]; - const put: (a0: rt.isize) => undefined = (v: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v))); +export function isizes(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.isize = rs.isizeFromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.isize = _18; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const b: rs.isize = ([rs.isizeFromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.isize, rs.ByteSlice])[0]; + const put: (a0: rs.isize) => undefined = (v: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v))); }; - let n3: rt.isize = a; - const part = ((): rt.isize => { - n3 = rt.isizeWrappingAdd(n3, b); + let n3: rs.isize = a; + const part = ((): rs.isize => { + n3 = rs.isizeWrappingAdd(n3, b); return n3; })(); put(part); put(n3); - const bump2: () => rt.isize = (): rt.isize => { - n3 = rt.isizeWrappingMul(n3, b); + const bump2: () => rs.isize = (): rs.isize => { + n3 = rs.isizeWrappingMul(n3, b); return n3; }; const part3 = bump2(); @@ -1144,42 +1144,42 @@ export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = bump2(); put(part4); put(n3); - const part6 = ((): rt.isize => { + const part6 = ((): rs.isize => { if (!((b & 1) === 1)) { return n3; } - n3 = rt.isizeWrappingSub(n3, a); + n3 = rs.isizeWrappingSub(n3, a); return n3; })(); put(part6); put(n3); - const captured = rt.byteSliceToByteVec(_20); - const part8 = ((): rt.isize => { - n3 = rt.isizeWrappingAdd(n3, captured.length | 0); + const captured = rs.byteSliceToByteVec(_20); + const part8 = ((): rs.isize => { + n3 = rs.isizeWrappingAdd(n3, captured.length | 0); return n3; })(); put(part8); put(n3); - const part10 = once$isize_captures_isizes_closure5((): rt.isize => { - n3 = rt.isizeWrappingAdd(n3, b); + const part10 = once$isize_captures_isizes_closure5((): rs.isize => { + n3 = rs.isizeWrappingAdd(n3, b); return n3; }); put(part10); put(n3); - const _108: [rt.isize, rt.isize] = twice$isize_captures_isizes_closure6((): rt.isize => { - n3 = rt.isizeWrappingAdd(n3, a); + const _108: [rs.isize, rs.isize] = twice$isize_captures_isizes_closure6((): rs.isize => { + n3 = rs.isizeWrappingAdd(n3, a); return n3; }); - const x: rt.isize = _108[0]; - const y: rt.isize = _108[1]; + const x: rs.isize = _108[0]; + const y: rs.isize = _108[1]; put(x); put(y); put(n3); - let m: rt.isize = a; + let m: rs.isize = a; let captured2 = m; const captured3 = b; - const own: () => rt.isize = (): rt.isize => { - captured2 = rt.isizeWrappingAdd(captured2, captured3); + const own: () => rs.isize = (): rs.isize => { + captured2 = rs.isizeWrappingAdd(captured2, captured3); return captured2; }; const part13 = own(); @@ -1187,19 +1187,19 @@ export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { const part14 = own(); put(part14); put(m); - const pair: [rt.isize, rt.isize] = [a, b]; - const part16 = ((): rt.isize => { - pair[0] = rt.isizeWrappingAdd(pair[0], pair[1]); + const pair: [rs.isize, rs.isize] = [a, b]; + const part16 = ((): rs.isize => { + pair[0] = rs.isizeWrappingAdd(pair[0], pair[1]); return pair[0]; })(); put(part16); put(pair[0]); - const part18 = through$isizes(rt.place(() => m, (value) => m = value), b); + const part18 = through$isizes(rs.place(() => m, (value) => m = value), b); put(part18); put(m); - const part20 = ((): rt.isize => { - return ((): rt.isize => { - n3 = rt.isizeWrappingSub(n3, b); + const part20 = ((): rs.isize => { + return ((): rs.isize => { + n3 = rs.isizeWrappingSub(n3, b); return n3; })(); })(); @@ -1207,16 +1207,16 @@ export function isizes(data: rt.ByteSlice, out: rt.ByteVec): void { put(n3); } -export function through$isizes(n: rt.Place, b: rt.isize): rt.isize { - return ((): rt.isize => { - n.v = rt.isizeWrappingAdd(n.v, b); +export function through$isizes(n: rs.Place, b: rs.isize): rs.isize { + return ((): rs.isize => { + n.v = rs.isizeWrappingAdd(n.v, b); return n.v; })(); } /** Run [`writes`] over the integer type `kind` picks. */ -export function captures(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 12); +export function captures(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 12); if (_4 === 0) { u8s(data, out); } else if (_4 === 1) { @@ -1244,100 +1244,100 @@ export function captures(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } -export function once$i128_captures_i128s_closure5(f: () => rt.i128): rt.i128 { +export function once$i128_captures_i128s_closure5(f: () => rs.i128): rs.i128 { return f(); } -export function once$i16_captures_i16s_closure5(f: () => rt.i16): rt.i16 { +export function once$i16_captures_i16s_closure5(f: () => rs.i16): rs.i16 { return f(); } -export function once$i32_captures_i32s_closure5(f: () => rt.i32): rt.i32 { +export function once$i32_captures_i32s_closure5(f: () => rs.i32): rs.i32 { return f(); } -export function once$i64_captures_i64s_closure5(f: () => rt.i64): rt.i64 { +export function once$i64_captures_i64s_closure5(f: () => rs.i64): rs.i64 { return f(); } -export function once$i8_captures_i8s_closure5(f: () => rt.i8): rt.i8 { +export function once$i8_captures_i8s_closure5(f: () => rs.i8): rs.i8 { return f(); } -export function once$isize_captures_isizes_closure5(f: () => rt.isize): rt.isize { +export function once$isize_captures_isizes_closure5(f: () => rs.isize): rs.isize { return f(); } -export function once$u128_captures_u128s_closure5(f: () => rt.u128): rt.u128 { +export function once$u128_captures_u128s_closure5(f: () => rs.u128): rs.u128 { return f(); } -export function once$u16_captures_u16s_closure5(f: () => rt.u16): rt.u16 { +export function once$u16_captures_u16s_closure5(f: () => rs.u16): rs.u16 { return f(); } -export function once$u32_captures_u32s_closure5(f: () => rt.u32): rt.u32 { +export function once$u32_captures_u32s_closure5(f: () => rs.u32): rs.u32 { return f(); } -export function once$u64_captures_u64s_closure5(f: () => rt.u64): rt.u64 { +export function once$u64_captures_u64s_closure5(f: () => rs.u64): rs.u64 { return f(); } -export function once$u8_captures_u8s_closure5(f: () => rt.u8): rt.u8 { +export function once$u8_captures_u8s_closure5(f: () => rs.u8): rs.u8 { return f(); } -export function once$usize_captures_usizes_closure5(f: () => rt.usize): rt.usize { +export function once$usize_captures_usizes_closure5(f: () => rs.usize): rs.usize { return f(); } -export function twice$i128_captures_i128s_closure6(f: () => rt.i128): [rt.i128, rt.i128] { - return [f(), f()] as [rt.i128, rt.i128]; +export function twice$i128_captures_i128s_closure6(f: () => rs.i128): [rs.i128, rs.i128] { + return [f(), f()] as [rs.i128, rs.i128]; } -export function twice$i16_captures_i16s_closure6(f: () => rt.i16): [rt.i16, rt.i16] { - return [f(), f()] as [rt.i16, rt.i16]; +export function twice$i16_captures_i16s_closure6(f: () => rs.i16): [rs.i16, rs.i16] { + return [f(), f()] as [rs.i16, rs.i16]; } -export function twice$i32_captures_i32s_closure6(f: () => rt.i32): [rt.i32, rt.i32] { - return [f(), f()] as [rt.i32, rt.i32]; +export function twice$i32_captures_i32s_closure6(f: () => rs.i32): [rs.i32, rs.i32] { + return [f(), f()] as [rs.i32, rs.i32]; } -export function twice$i64_captures_i64s_closure6(f: () => rt.i64): [rt.i64, rt.i64] { - return [f(), f()] as [rt.i64, rt.i64]; +export function twice$i64_captures_i64s_closure6(f: () => rs.i64): [rs.i64, rs.i64] { + return [f(), f()] as [rs.i64, rs.i64]; } -export function twice$i8_captures_i8s_closure6(f: () => rt.i8): [rt.i8, rt.i8] { - return [f(), f()] as [rt.i8, rt.i8]; +export function twice$i8_captures_i8s_closure6(f: () => rs.i8): [rs.i8, rs.i8] { + return [f(), f()] as [rs.i8, rs.i8]; } -export function twice$isize_captures_isizes_closure6(f: () => rt.isize): [rt.isize, rt.isize] { - return [f(), f()] as [rt.isize, rt.isize]; +export function twice$isize_captures_isizes_closure6(f: () => rs.isize): [rs.isize, rs.isize] { + return [f(), f()] as [rs.isize, rs.isize]; } -export function twice$u128_captures_u128s_closure6(f: () => rt.u128): [rt.u128, rt.u128] { - return [f(), f()] as [rt.u128, rt.u128]; +export function twice$u128_captures_u128s_closure6(f: () => rs.u128): [rs.u128, rs.u128] { + return [f(), f()] as [rs.u128, rs.u128]; } -export function twice$u16_captures_u16s_closure6(f: () => rt.u16): [rt.u16, rt.u16] { - return [f(), f()] as [rt.u16, rt.u16]; +export function twice$u16_captures_u16s_closure6(f: () => rs.u16): [rs.u16, rs.u16] { + return [f(), f()] as [rs.u16, rs.u16]; } -export function twice$u32_captures_u32s_closure6(f: () => rt.u32): [rt.u32, rt.u32] { - return [f(), f()] as [rt.u32, rt.u32]; +export function twice$u32_captures_u32s_closure6(f: () => rs.u32): [rs.u32, rs.u32] { + return [f(), f()] as [rs.u32, rs.u32]; } -export function twice$u64_captures_u64s_closure6(f: () => rt.u64): [rt.u64, rt.u64] { - return [f(), f()] as [rt.u64, rt.u64]; +export function twice$u64_captures_u64s_closure6(f: () => rs.u64): [rs.u64, rs.u64] { + return [f(), f()] as [rs.u64, rs.u64]; } -export function twice$u8_captures_u8s_closure6(f: () => rt.u8): [rt.u8, rt.u8] { - return [f(), f()] as [rt.u8, rt.u8]; +export function twice$u8_captures_u8s_closure6(f: () => rs.u8): [rs.u8, rs.u8] { + return [f(), f()] as [rs.u8, rs.u8]; } -export function twice$usize_captures_usizes_closure6(f: () => rt.usize): [rt.usize, rt.usize] { - return [f(), f()] as [rt.usize, rt.usize]; +export function twice$usize_captures_usizes_closure6(f: () => rs.usize): [rs.usize, rs.usize] { + return [f(), f()] as [rs.usize, rs.usize]; } //# sourceMappingURL=captures.ts.map diff --git a/ts/fixtures/lang/captures/expected/harness.ts b/ts/fixtures/lang/captures/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/captures/expected/harness.ts +++ b/ts/fixtures/lang/captures/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/captures/expected/lib.ts b/ts/fixtures/lang/captures/expected/lib.ts index b46cff234..10bdc5770 100644 --- a/ts/fixtures/lang/captures/expected/lib.ts +++ b/ts/fixtures/lang/captures/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { captures } from "./captures.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["captures::captures", captures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["captures::captures", captures as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/cells/expected/cells.ts b/ts/fixtures/lang/cells/expected/cells.ts index 2a01e49c8..f192a9337 100644 --- a/ts/fixtures/lang/cells/expected/cells.ts +++ b/ts/fixtures/lang/cells/expected/cells.ts @@ -1,2324 +1,2324 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$Option_u8, out$u64, out$u8 } from "./lib.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { err$1nbmqmx, map$1ma2nl9 as result_map$1ma2nl9, map$0l5uclx as result_map$0l5uclx, map$14n87rz as result_map$14n87rz, map$0h1vl84 as result_map$0h1vl84, map$03hz3l7 as result_map$03hz3l7, map$1916nm0 as result_map$1916nm0 } from "./core/result.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { err$1yr5s3w, map$0vjzmou as result_map$0vjzmou, map$0ac8dwe as result_map$0ac8dwe, map$0zkrphe as result_map$0zkrphe, map$0w147c6 as result_map$0w147c6, map$1gelxzx as result_map$1gelxzx, map$0vfooax as result_map$0vfooax } from "./core/result.ts"; /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u8 | undefined = maybe; - const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = putMaybe as (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined; - let cell: rt.OnceCell = new rt.OnceCell(rt.None); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u8 | undefined = maybe; + const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; + let cell: rs.OnceCell = new rs.OnceCell(rs.None); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u8 | undefined | rt.None = cell.v; - if (_20 === rt.None) { - rt.byteVecPush(out, 0); + const _20: rs.u8 | undefined | rs.None = cell.v; + if (_20 === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + const _26: rs.Result = rs.onceSet(cell, make(v2), rs.None); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u8 | undefined = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u8 | undefined = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + const _34: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t2: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - seen = _44.v !== rt.None ? 1 : 0; + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t2: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + seen = _44.v !== rs.None ? 1 : 0; return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u8 | undefined | rt.None = rt.onceTake(cell, rt.None); - if (_50 === rt.None) { - rt.byteVecPush(out, 0); + const _50: rs.u8 | undefined | rs.None = rs.onceTake(cell, rs.None); + if (_50 === rs.None) { + rs.byteVecPush(out, 0); } else { - const t3: rt.u8 | undefined = _50; - rt.byteVecPush(out, 1); + const t3: rs.u8 | undefined = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - rt.onceSet(_60, make(v2 ^ 1), rt.None); + const _60: rs.OnceCell = cell; + const _57: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + rs.onceSet(_60, make(v2 ^ 1), rs.None); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t4: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - put(inner, rt.onceGetOrInit(_69, (): rt.u8 | undefined => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t4: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + put(inner, rs.onceGetOrInit(_69, (): rs.u8 | undefined => { return make(v2 ^ 1); - }, undefined, rt.None)); + }, undefined, rs.None)); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); - }, undefined, rt.None); + const _76: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); + }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceCell(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceCell(make(v2)); } else { - cell = new rt.OnceCell(rt.None); + cell = new rs.OnceCell(rs.None); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_Option_u8(cell); - const copy: rt.OnceCell = rt.onceClone(cell, undefined, rt.None); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t5: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - inner2 = rt.onceClone(_95, undefined, rt.None); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_Option_u8(cell); + const copy: rs.OnceCell = rs.onceClone(cell, undefined, rs.None); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + inner2 = rs.onceClone(_95, undefined, rs.None); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t5); - rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== rs.None ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u8 | undefined | rt.None = _112.v; - if (_116 === rt.None) { - rt.byteVecPush(out, 238); + const _116: rs.u8 | undefined | rs.None = _112.v; + if (_116 === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t7: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell, rt.None); + const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u8 | undefined = rt.optionUnwrap(cell.v, rt.None); + rs.byteVecPush(out, 1); + const _162: rs.u8 | undefined = rs.optionUnwrap(cell.v, rs.None); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const err4 = made$Option_u8(make, v2); - return err4 !== undefined ? rt.Err(err4 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err4 !== undefined ? rs.Err(err4 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1), rt.None); + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1), rs.None); const err3 = made$Option_u8(make, v2); - return err3 !== undefined ? rt.Err(err3 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err3 !== undefined ? rs.Err(err3 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const err2 = made$Option_u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$1ma2nl9(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const err2 = made$Option_u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0vjzmou(rs.onceGetOrTryInit(_179, (): rs.Result => { const err = made$Option_u8(make, v2 ^ 1); - return err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None), (_22: rt.u8 | undefined): undefined => {})), v2)); - return err2 !== undefined ? rt.Err(err2 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err !== undefined ? rs.Err(err as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None), (_22: rs.u8 | undefined): undefined => {})), v2)); + return err2 !== undefined ? rs.Err(err2 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } if (result.ok) { - const t8: rt.u8 | undefined = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u8 | undefined = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u8 | undefined | rt.None = cell.v; - if (_190 === rt.None) { - rt.byteVecPush(out, 238); + const _190: rs.u8 | undefined | rs.None = cell.v; + if (_190 === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => string = (v3: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); + let result!: rs.Result; + const make: (a0: rs.u8) => string = (v3: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); }; - const put: (a0: rt.ByteVec, a1: string) => undefined = (out2: rt.ByteVec, t10: string): undefined => { - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); }; - let cell: rt.OnceCell = new rt.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { const _20: string | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { const t: string = _26.error; - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rt.onceGetOrInit(cell, (): string => { + const _34: string = rs.onceGetOrInit(cell, (): string => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t2: string = rt.onceGetOrInit(cell, (): string => { + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t2: string = rs.onceGetOrInit(cell, (): string => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rt.onceTake(cell); + const _50: string | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { const t3: string = _50; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: string = rt.onceGetOrInit(cell, (): string => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceCell = cell; + const _57: string = rs.onceGetOrInit(cell, (): string => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t4: string = rt.onceGetOrInit(cell, (): string => { - put(inner, rt.onceGetOrInit(_69, (): string => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t4: string = rs.onceGetOrInit(cell, (): string => { + put(inner, rs.onceGetOrInit(_69, (): string => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rt.onceGetOrInit(cell, (): string => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: string = rs.onceGetOrInit(cell, (): string => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceCell(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceCell(make(v2)); } else { - cell = new rt.OnceCell(undefined); + cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_String(cell); - const copy: rt.OnceCell = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t5: string = rt.onceGetOrInit(cell, (): string => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_String(cell); + const copy: rs.OnceCell = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: string = rs.onceGetOrInit(cell, (): string => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } const _116: string | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t7: string = rt.onceGetOrInit(cell, (): string => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", rt.fmtStr)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t7: string = rs.onceGetOrInit(cell, (): string => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtStr)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.fmtStr)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.fmtStr)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtStr)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: string = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: string = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$String(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$0l5uclx(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); }), (_22: string): undefined => {})), v2)); }); } if (result.ok) { const t8: string = result.value; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } const _190: string | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u64 = wide; - const put: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, t10: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t10))); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u64 = wide; + const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(t10))); }; - let cell: rt.OnceCell = new rt.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u64 | undefined = cell.v; + const _20: rs.u64 | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u64 = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u64 = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + const _34: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t2: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t2: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u64 | undefined = rt.onceTake(cell); + const _50: rs.u64 | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.u64 = _50; - rt.byteVecPush(out, 1); + const t3: rs.u64 = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceCell = cell; + const _57: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t4: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - put(inner, rt.onceGetOrInit(_69, (): rt.u64 => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t4: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + put(inner, rs.onceGetOrInit(_69, (): rs.u64 => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceCell(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceCell(make(v2)); } else { - cell = new rt.OnceCell(undefined); + cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_u64(cell); - const copy: rt.OnceCell = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t5: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_u64(cell); + const copy: rs.OnceCell = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u64 | undefined = _112.v; + const _116: rs.u64 | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t7: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", rt.u64Debug)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u64Debug)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.u64Debug)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.u64Debug)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u64Debug)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u64 = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.u64 = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const part4 = made$u64(make, v2); - return part4 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part4); + return part4 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part4); }); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); const part3 = made$u64(make, v2); - return part3 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part3); + return part3 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part3); }); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const part2 = made$u64(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$0h1vl84(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const part2 = made$u64(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0w147c6(rs.onceGetOrTryInit(_179, (): rs.Result => { const part = made$u64(make, v2 ^ 1); - return part === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part); - }), (_22: rt.u64): undefined => {})), v2)); - return part2 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part2); + return part === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part); + }), (_22: rs.u64): undefined => {})), v2)); + return part2 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part2); }); } if (result.ok) { - const t8: rt.u64 = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u64 = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u64 | undefined = cell.v; + const _190: rs.u64 | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; }; - const put: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, t10: rt.u8): undefined => { - rt.byteVecPush(out2, t10); + const put: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, t10: rs.u8): undefined => { + rs.byteVecPush(out2, t10); }; - let cell: rt.OnceCell = new rt.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u8 | undefined = cell.v; + const _20: rs.u8 | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u8 = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u8 = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + const _34: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t2: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t2: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u8 | undefined = rt.onceTake(cell); + const _50: rs.u8 | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.u8 = _50; - rt.byteVecPush(out, 1); + const t3: rs.u8 = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceCell = cell; + const _57: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t4: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - put(inner, rt.onceGetOrInit(_69, (): rt.u8 => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t4: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + put(inner, rs.onceGetOrInit(_69, (): rs.u8 => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceCell(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceCell(make(v2)); } else { - cell = new rt.OnceCell(undefined); + cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_u8(cell); - const copy: rt.OnceCell = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t5: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_u8(cell); + const copy: rs.OnceCell = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u8 | undefined = _112.v; + const _116: rs.u8 | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t7: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", rt.u8Debug)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.u8Debug)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.u8Debug)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.u8Debug)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.u8Debug)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u8 = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.u8 = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const part4 = made$u8(make, v2); - return part4 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part4); + return part4 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part4); }); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); const part3 = made$u8(make, v2); - return part3 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part3); + return part3 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part3); }); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const part2 = made$u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$03hz3l7(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const part2 = made$u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1gelxzx(rs.onceGetOrTryInit(_179, (): rs.Result => { const part = made$u8(make, v2 ^ 1); - return part === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part); - }), (_22: rt.u8): undefined => {})), v2)); - return part2 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part2); + return part === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part); + }), (_22: rs.u8): undefined => {})), v2)); + return part2 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part2); }); } if (result.ok) { - const t8: rt.u8 = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u8 = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u8 | undefined = cell.v; + const _190: rs.u8 | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => undefined = (_2: rt.u8): undefined => {}; - const put: (a0: rt.ByteVec, a1: undefined) => undefined = (out2: rt.ByteVec, _3: undefined): undefined => { - rt.byteVecPush(out2, 170); + let result!: rs.Result; + const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; + const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { + rs.byteVecPush(out2, 170); }; - let cell: rt.OnceCell = new rt.OnceCell(rt.None); + let cell: rs.OnceCell = new rs.OnceCell(rs.None); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: undefined | rt.None = cell.v; - if (_20 === rt.None) { - rt.byteVecPush(out, 0); + const _20: undefined | rs.None = cell.v; + if (_20 === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _27: rt.OnceCell = cell; + const _27: rs.OnceCell = cell; make(v2); - if (rt.onceSet(_27, undefined, rt.None).ok) { - rt.byteVecPush(out, 1); + if (rs.onceSet(_27, undefined, rs.None).ok) { + rs.byteVecPush(out, 1); } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); put(out, undefined); } } else if (_18 === 2) { - const _34: undefined = rt.onceGetOrInit(cell, (): undefined => { + const _34: undefined = rs.onceGetOrInit(cell, (): undefined => { make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t: undefined = rt.onceGetOrInit(cell, (): undefined => { - seen = _44.v !== rt.None ? 1 : 0; + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t: undefined = rs.onceGetOrInit(cell, (): undefined => { + seen = _44.v !== rs.None ? 1 : 0; make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - if (rt.onceTake(cell, rt.None) === rt.None) { - rt.byteVecPush(out, 0); + if (rs.onceTake(cell, rs.None) === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, undefined); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: undefined = rt.onceGetOrInit(cell, (): undefined => { + const _60: rs.OnceCell = cell; + const _57: undefined = rs.onceGetOrInit(cell, (): undefined => { make(v2 ^ 1); - rt.onceSet(_60, undefined, rt.None); + rs.onceSet(_60, undefined, rs.None); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t2: undefined = rt.onceGetOrInit(cell, (): undefined => { - put(inner, rt.onceGetOrInit(_69, (): undefined => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t2: undefined = rs.onceGetOrInit(cell, (): undefined => { + put(inner, rs.onceGetOrInit(_69, (): undefined => { make(v2 ^ 1); - }, undefined, rt.None)); + }, undefined, rs.None)); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: undefined = rt.onceGetOrInit(cell, (): undefined => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); - }, undefined, rt.None); + const _76: undefined = rs.onceGetOrInit(cell, (): undefined => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); + }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { + if (rs.u8Rem(v2, 2) === 0) { make(v2); - cell = new rt.OnceCell(undefined); + cell = new rs.OnceCell(undefined); } else { - cell = new rt.OnceCell(rt.None); + cell = new rs.OnceCell(rs.None); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_unit(cell); - const copy: rt.OnceCell = rt.onceClone(cell, undefined, rt.None); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t3: undefined = rt.onceGetOrInit(cell, (): undefined => { - inner2 = rt.onceClone(_95, undefined, rt.None); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_unit(cell); + const copy: rs.OnceCell = rs.onceClone(cell, undefined, rs.None); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t3: undefined = rs.onceGetOrInit(cell, (): undefined => { + inner2 = rs.onceClone(_95, undefined, rs.None); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t3); - rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== rs.None ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - if (_112.v === rt.None) { - rt.byteVecPush(out, 238); + if (_112.v === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, undefined); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t4: undefined = rt.onceGetOrInit(cell, (): undefined => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", rt.fmtUnit, rt.None)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", rs.fmtUnit, rs.None)]; + inner3 = rs.fmtFormat([args6[0]]); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t4); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.fmtUnit, rt.None)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", rt.fmtUnit, rt.None)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - if (rt.optionAsMut(cell, rt.None) === undefined) { - rt.byteVecPush(out, 0); + if (rs.optionAsMut(cell, rs.None) === undefined) { + rs.byteVecPush(out, 0); } else { make(v2); - rt.byteVecPush(out, 1); - const _162: undefined = rt.optionUnwrap(cell.v, rt.None); + rs.byteVecPush(out, 1); + const _162: undefined = rs.optionUnwrap(cell.v, rs.None); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$unit(make, v2); - }, undefined, rt.None); + }, undefined, rs.None); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { make(v2 ^ 1); - rt.onceSet(_174, undefined, rt.None); + rs.onceSet(_174, undefined, rs.None); return made$unit(make, v2); - }, undefined, rt.None); + }, undefined, rs.None); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$unit(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$1916nm0(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$unit(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0vfooax(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$unit(make, v2 ^ 1); - }, undefined, rt.None), (_23: undefined): undefined => {})), v2)); - }, undefined, rt.None); + }, undefined, rs.None), (_23: undefined): undefined => {})), v2)); + }, undefined, rs.None); } if (result.ok) { const t5: undefined = result.value; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t5); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - if (cell.v === rt.None) { - rt.byteVecPush(out, 238); + if (cell.v === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, undefined); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function cellVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.ByteVec = (v3: rt.u8): rt.ByteVec => { - return rt.byteVecOf(v3, rt.u8Rem(v3, 4) as rt.usize); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { + return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); }; - const put: (a0: rt.ByteVec, a1: rt.ByteVec) => undefined = (out2: rt.ByteVec, t10: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteVecSlice(t10)); + const put: (a0: rs.ByteVec, a1: rs.ByteVec) => undefined = (out2: rs.ByteVec, t10: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteVecSlice(t10)); }; - let cell: rt.OnceCell = new rt.OnceCell(undefined); + let cell: rs.OnceCell = new rs.OnceCell(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.ByteVec | undefined = cell.v; + const _20: rs.ByteVec | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.ByteVec = _26.error; - rt.byteVecPush(out, 0); + const t: rs.ByteVec = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { + const _34: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceCell = cell; - const t2: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { + let seen: rs.u8 = 2; + const _44: rs.OnceCell = cell; + const t2: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.ByteVec | undefined = rt.onceTake(cell); + const _50: rs.ByteVec | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.ByteVec = _50; - rt.byteVecPush(out, 1); + const t3: rs.ByteVec = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceCell = cell; - const _57: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceCell = cell; + const _57: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceCell = cell; - const t4: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - put(inner, rt.onceGetOrInit(_69, (): rt.ByteVec => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceCell = cell; + const t4: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + put(inner, rs.onceGetOrInit(_69, (): rs.ByteVec => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceCell(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceCell(make(v2)); } else { - cell = new rt.OnceCell(undefined); + cell = new rs.OnceCell(undefined); } } else if (_18 === 9) { - const alias: rt.OnceCell = twin$ref_cell_OnceCell_Vec_u8(cell); - const copy: rt.OnceCell = rt.onceClone(cell, (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const alias: rs.OnceCell = twin$ref_cell_OnceCell_Vec_u8(cell); + const copy: rs.OnceCell = rs.onceClone(cell, (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); }); - let inner2 = undefined as rt.OnceCell | undefined; - const _95: rt.OnceCell = cell; - const t5: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - inner2 = rt.onceClone(_95, (a02: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a02)); + let inner2 = undefined as rs.OnceCell | undefined; + const _95: rs.OnceCell = cell; + const t5: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + inner2 = rs.onceClone(_95, (a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); }); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceCell | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceCell | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceCell | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceCell | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.ByteVec | undefined = _112.v; + const _116: rs.ByteVec | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceCell = cell; - const t7: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceCell", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceCell = cell; + const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceCell", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceCell", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.ByteVec | undefined = cell.v; + const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { Object.assign(_155, make(v2)); - rt.byteVecPush(out, 1); - const _162: rt.ByteVec = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.ByteVec = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$Vec_u8(make, v2); }); } else if (_166 === 2) { - const _174: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); return made$Vec_u8(make, v2); }); } else { - const _179: rt.OnceCell = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$Vec_u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$14n87rz(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceCell = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$Vec_u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0zkrphe(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$Vec_u8(make, v2 ^ 1); - }), (_22: rt.ByteVec): undefined => {})), v2)); + }), (_22: rs.ByteVec): undefined => {})), v2)); }); } if (result.ok) { - const t8: rt.ByteVec = result.value; - rt.byteVecPush(out, 1); + const t8: rs.ByteVec = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.ByteVec | undefined = cell.v; + const _190: rs.ByteVec | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps on the cell and value type `kind` picks. */ -export function cells(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const cases: rt.Vec<(a0: rt.ByteSlice, a1: rt.ByteVec) => undefined> = rt.vecFrom([(a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { +export function cells(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const cases: rs.Vec<(a0: rs.ByteSlice, a1: rs.ByteVec) => undefined> = rs.vecFrom([(a0: rs.ByteSlice, a1: rs.ByteVec): undefined => { cellU8(a0.data, a0.start, a0.length, a1); - }, (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + }, (a02: rs.ByteSlice, a12: rs.ByteVec): undefined => { lockU8(a02.data, a02.start, a02.length, a12); - }, (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { + }, (a03: rs.ByteSlice, a13: rs.ByteVec): undefined => { cellU64(a03.data, a03.start, a03.length, a13); - }, (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + }, (a04: rs.ByteSlice, a14: rs.ByteVec): undefined => { lockU64(a04.data, a04.start, a04.length, a14); - }, (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + }, (a05: rs.ByteSlice, a15: rs.ByteVec): undefined => { cellOption(a05.data, a05.start, a05.length, a15); - }, (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + }, (a06: rs.ByteSlice, a16: rs.ByteVec): undefined => { lockOption(a06.data, a06.start, a06.length, a16); - }, (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + }, (a07: rs.ByteSlice, a17: rs.ByteVec): undefined => { cellUnit(a07.data, a07.start, a07.length, a17); - }, (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + }, (a08: rs.ByteSlice, a18: rs.ByteVec): undefined => { lockUnit(a08.data, a08.start, a08.length, a18); - }, (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + }, (a09: rs.ByteSlice, a19: rs.ByteVec): undefined => { cellString(a09.data, a09.start, a09.length, a19); - }, (a010: rt.ByteSlice, a110: rt.ByteVec): undefined => { + }, (a010: rs.ByteSlice, a110: rs.ByteVec): undefined => { lockString(a010.data, a010.start, a010.length, a110); - }, (a011: rt.ByteSlice, a111: rt.ByteVec): undefined => { + }, (a011: rs.ByteSlice, a111: rs.ByteVec): undefined => { cellVec(a011.data, a011.start, a011.length, a111); - }, (a012: rt.ByteSlice, a112: rt.ByteVec): undefined => { + }, (a012: rs.ByteSlice, a112: rs.ByteVec): undefined => { lockVec(a012.data, a012.start, a012.length, a112); }]); - cases.items[rt.idx(cases.items, rt.usizeRem(kind as rt.usize, cases.items.length))](data, out); + cases.items[rs.idx(cases.items, rs.usizeRem(kind as rs.usize, cases.items.length))](data, out); } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockOption(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u8 | undefined = maybe; - const put: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = putMaybe as (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined; - let cell: rt.OnceLock = new rt.OnceLock(rt.None); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u8 | undefined = maybe; + const put: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = putMaybe as (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined; + let cell: rs.OnceLock = new rs.OnceLock(rs.None); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u8 | undefined | rt.None = cell.v; - if (_20 === rt.None) { - rt.byteVecPush(out, 0); + const _20: rs.u8 | undefined | rs.None = cell.v; + if (_20 === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2), rt.None); + const _26: rs.Result = rs.onceSet(cell, make(v2), rs.None); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u8 | undefined = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u8 | undefined = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { + const _34: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t2: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - seen = _44.v !== rt.None ? 1 : 0; + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t2: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + seen = _44.v !== rs.None ? 1 : 0; return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u8 | undefined | rt.None = rt.onceTake(cell, rt.None); - if (_50 === rt.None) { - rt.byteVecPush(out, 0); + const _50: rs.u8 | undefined | rs.None = rs.onceTake(cell, rs.None); + if (_50 === rs.None) { + rs.byteVecPush(out, 0); } else { - const t3: rt.u8 | undefined = _50; - rt.byteVecPush(out, 1); + const t3: rs.u8 | undefined = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - rt.onceSet(_60, make(v2 ^ 1), rt.None); + const _60: rs.OnceLock = cell; + const _57: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + rs.onceSet(_60, make(v2 ^ 1), rs.None); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t4: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - put(inner, rt.onceGetOrInit(_69, (): rt.u8 | undefined => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t4: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + put(inner, rs.onceGetOrInit(_69, (): rs.u8 | undefined => { return make(v2 ^ 1); - }, undefined, rt.None)); + }, undefined, rs.None)); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); - }, undefined, rt.None); + const _76: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); + }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceLock(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceLock(make(v2)); } else { - cell = new rt.OnceLock(rt.None); + cell = new rs.OnceLock(rs.None); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_Option_u8(cell); - const copy: rt.OnceLock = rt.onceClone(cell, undefined, rt.None); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t5: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - inner2 = rt.onceClone(_95, undefined, rt.None); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_Option_u8(cell); + const copy: rs.OnceLock = rs.onceClone(cell, undefined, rs.None); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + inner2 = rs.onceClone(_95, undefined, rs.None); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t5); - rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== rs.None ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u8 | undefined | rt.None = _112.v; - if (_116 === rt.None) { - rt.byteVecPush(out, 238); + const _116: rs.u8 | undefined | rs.None = _112.v; + if (_116 === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t7: rt.u8 | undefined = rt.onceGetOrInit(cell, (): rt.u8 | undefined => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t7: rs.u8 | undefined = rs.onceGetOrInit(cell, (): rs.u8 | undefined => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell, rt.None); + const _155: rs.Place | undefined = rs.optionAsMut(cell, rs.None); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u8 | undefined = rt.optionUnwrap(cell.v, rt.None); + rs.byteVecPush(out, 1); + const _162: rs.u8 | undefined = rs.optionUnwrap(cell.v, rs.None); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const err4 = made$Option_u8(make, v2); - return err4 !== undefined ? rt.Err(err4 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err4 !== undefined ? rs.Err(err4 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1), rt.None); + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1), rs.None); const err3 = made$Option_u8(make, v2); - return err3 !== undefined ? rt.Err(err3 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err3 !== undefined ? rs.Err(err3 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const err2 = made$Option_u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$1ma2nl9(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const err2 = made$Option_u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0vjzmou(rs.onceGetOrTryInit(_179, (): rs.Result => { const err = made$Option_u8(make, v2 ^ 1); - return err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None), (_22: rt.u8 | undefined): undefined => {})), v2)); - return err2 !== undefined ? rt.Err(err2 as rt.u8) : rt.Ok(out$Option_u8.p); - }, undefined, rt.None); + return err !== undefined ? rs.Err(err as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None), (_22: rs.u8 | undefined): undefined => {})), v2)); + return err2 !== undefined ? rs.Err(err2 as rs.u8) : rs.Ok(out$Option_u8.p); + }, undefined, rs.None); } if (result.ok) { - const t8: rt.u8 | undefined = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u8 | undefined = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u8 | undefined | rt.None = cell.v; - if (_190 === rt.None) { - rt.byteVecPush(out, 238); + const _190: rs.u8 | undefined | rs.None = cell.v; + if (_190 === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockString(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => string = (v3: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(v3, f)); + let result!: rs.Result; + const make: (a0: rs.u8) => string = (v3: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(v3, f)); }; - const put: (a0: rt.ByteVec, a1: string) => undefined = (out2: rt.ByteVec, t10: string): undefined => { - rt.byteVecExtendFromSlice(out2, rt.stringAsBytes(t10)); + const put: (a0: rs.ByteVec, a1: string) => undefined = (out2: rs.ByteVec, t10: string): undefined => { + rs.byteVecExtendFromSlice(out2, rs.stringAsBytes(t10)); }; - let cell: rt.OnceLock = new rt.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { const _20: string | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { const t: string = _26.error; - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: string = rt.onceGetOrInit(cell, (): string => { + const _34: string = rs.onceGetOrInit(cell, (): string => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t2: string = rt.onceGetOrInit(cell, (): string => { + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t2: string = rs.onceGetOrInit(cell, (): string => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: string | undefined = rt.onceTake(cell); + const _50: string | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { const t3: string = _50; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: string = rt.onceGetOrInit(cell, (): string => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceLock = cell; + const _57: string = rs.onceGetOrInit(cell, (): string => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t4: string = rt.onceGetOrInit(cell, (): string => { - put(inner, rt.onceGetOrInit(_69, (): string => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t4: string = rs.onceGetOrInit(cell, (): string => { + put(inner, rs.onceGetOrInit(_69, (): string => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: string = rt.onceGetOrInit(cell, (): string => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: string = rs.onceGetOrInit(cell, (): string => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceLock(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceLock(make(v2)); } else { - cell = new rt.OnceLock(undefined); + cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_String(cell); - const copy: rt.OnceLock = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t5: string = rt.onceGetOrInit(cell, (): string => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_String(cell); + const copy: rs.OnceLock = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: string = rs.onceGetOrInit(cell, (): string => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } const _116: string | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t7: string = rt.onceGetOrInit(cell, (): string => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", rt.fmtStr)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t7: string = rs.onceGetOrInit(cell, (): string => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtStr)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.fmtStr)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.fmtStr)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtStr)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: string = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: string = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$String(make, v2); }); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); return made$String(make, v2); }); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$String(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$0l5uclx(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$String(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0ac8dwe(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$String(make, v2 ^ 1); }), (_22: string): undefined => {})), v2)); }); } if (result.ok) { const t8: string = result.value; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } const _190: string | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockU64(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u64 = wide; - const put: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, t10: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(t10))); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u64 = wide; + const put: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, t10: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(t10))); }; - let cell: rt.OnceLock = new rt.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u64 | undefined = cell.v; + const _20: rs.u64 | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u64 = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u64 = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + const _34: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t2: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t2: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u64 | undefined = rt.onceTake(cell); + const _50: rs.u64 | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.u64 = _50; - rt.byteVecPush(out, 1); + const t3: rs.u64 = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceLock = cell; + const _57: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t4: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - put(inner, rt.onceGetOrInit(_69, (): rt.u64 => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t4: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + put(inner, rs.onceGetOrInit(_69, (): rs.u64 => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceLock(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceLock(make(v2)); } else { - cell = new rt.OnceLock(undefined); + cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_u64(cell); - const copy: rt.OnceLock = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t5: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_u64(cell); + const copy: rs.OnceLock = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u64 | undefined = _112.v; + const _116: rs.u64 | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t7: rt.u64 = rt.onceGetOrInit(cell, (): rt.u64 => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", rt.u64Debug)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t7: rs.u64 = rs.onceGetOrInit(cell, (): rs.u64 => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u64Debug)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.u64Debug)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.u64Debug)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u64Debug)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u64 = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.u64 = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const part4 = made$u64(make, v2); - return part4 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part4); + return part4 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part4); }); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); const part3 = made$u64(make, v2); - return part3 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part3); + return part3 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part3); }); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const part2 = made$u64(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$0h1vl84(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const part2 = made$u64(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0w147c6(rs.onceGetOrTryInit(_179, (): rs.Result => { const part = made$u64(make, v2 ^ 1); - return part === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part); - }), (_22: rt.u64): undefined => {})), v2)); - return part2 === undefined ? rt.Err(out$u64.err as rt.u8) : rt.Ok(part2); + return part === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part); + }), (_22: rs.u64): undefined => {})), v2)); + return part2 === undefined ? rs.Err(out$u64.err as rs.u8) : rs.Ok(part2); }); } if (result.ok) { - const t8: rt.u64 = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u64 = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u64 | undefined = cell.v; + const _190: rs.u64 | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockU8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.u8 = (v3: rt.u8): rt.u8 => { + let result!: rs.Result; + const make: (a0: rs.u8) => rs.u8 = (v3: rs.u8): rs.u8 => { return v3; }; - const put: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, t10: rt.u8): undefined => { - rt.byteVecPush(out2, t10); + const put: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, t10: rs.u8): undefined => { + rs.byteVecPush(out2, t10); }; - let cell: rt.OnceLock = new rt.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.u8 | undefined = cell.v; + const _20: rs.u8 | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.u8 = _26.error; - rt.byteVecPush(out, 0); + const t: rs.u8 = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + const _34: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t2: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t2: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.u8 | undefined = rt.onceTake(cell); + const _50: rs.u8 | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.u8 = _50; - rt.byteVecPush(out, 1); + const t3: rs.u8 = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceLock = cell; + const _57: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t4: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - put(inner, rt.onceGetOrInit(_69, (): rt.u8 => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t4: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + put(inner, rs.onceGetOrInit(_69, (): rs.u8 => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceLock(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceLock(make(v2)); } else { - cell = new rt.OnceLock(undefined); + cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_u8(cell); - const copy: rt.OnceLock = rt.onceClone(cell, undefined); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t5: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - inner2 = rt.onceClone(_95, undefined); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_u8(cell); + const copy: rs.OnceLock = rs.onceClone(cell, undefined); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + inner2 = rs.onceClone(_95, undefined); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.u8 | undefined = _112.v; + const _116: rs.u8 | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t7: rt.u8 = rt.onceGetOrInit(cell, (): rt.u8 => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", rt.u8Debug)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t7: rs.u8 = rs.onceGetOrInit(cell, (): rs.u8 => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.u8Debug)]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.u8Debug)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.u8Debug)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.u8Debug)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.Place | undefined = rt.optionAsMut(cell); + const _155: rs.Place | undefined = rs.optionAsMut(cell); if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { _155.v = make(v2); - rt.byteVecPush(out, 1); - const _162: rt.u8 = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.u8 = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { const part4 = made$u8(make, v2); - return part4 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part4); + return part4 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part4); }); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); const part3 = made$u8(make, v2); - return part3 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part3); + return part3 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part3); }); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - const part2 = made$u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$03hz3l7(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + const part2 = made$u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$1gelxzx(rs.onceGetOrTryInit(_179, (): rs.Result => { const part = made$u8(make, v2 ^ 1); - return part === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part); - }), (_22: rt.u8): undefined => {})), v2)); - return part2 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part2); + return part === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part); + }), (_22: rs.u8): undefined => {})), v2)); + return part2 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part2); }); } if (result.ok) { - const t8: rt.u8 = result.value; - rt.byteVecPush(out, 1); + const t8: rs.u8 = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.u8 | undefined = cell.v; + const _190: rs.u8 | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockUnit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => undefined = (_2: rt.u8): undefined => {}; - const put: (a0: rt.ByteVec, a1: undefined) => undefined = (out2: rt.ByteVec, _3: undefined): undefined => { - rt.byteVecPush(out2, 170); + let result!: rs.Result; + const make: (a0: rs.u8) => undefined = (_2: rs.u8): undefined => {}; + const put: (a0: rs.ByteVec, a1: undefined) => undefined = (out2: rs.ByteVec, _3: undefined): undefined => { + rs.byteVecPush(out2, 170); }; - let cell: rt.OnceLock = new rt.OnceLock(rt.None); + let cell: rs.OnceLock = new rs.OnceLock(rs.None); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: undefined | rt.None = cell.v; - if (_20 === rt.None) { - rt.byteVecPush(out, 0); + const _20: undefined | rs.None = cell.v; + if (_20 === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _27: rt.OnceLock = cell; + const _27: rs.OnceLock = cell; make(v2); - if (rt.onceSet(_27, undefined, rt.None).ok) { - rt.byteVecPush(out, 1); + if (rs.onceSet(_27, undefined, rs.None).ok) { + rs.byteVecPush(out, 1); } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); put(out, undefined); } } else if (_18 === 2) { - const _34: undefined = rt.onceGetOrInit(cell, (): undefined => { + const _34: undefined = rs.onceGetOrInit(cell, (): undefined => { make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t: undefined = rt.onceGetOrInit(cell, (): undefined => { - seen = _44.v !== rt.None ? 1 : 0; + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t: undefined = rs.onceGetOrInit(cell, (): undefined => { + seen = _44.v !== rs.None ? 1 : 0; make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - if (rt.onceTake(cell, rt.None) === rt.None) { - rt.byteVecPush(out, 0); + if (rs.onceTake(cell, rs.None) === rs.None) { + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, undefined); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: undefined = rt.onceGetOrInit(cell, (): undefined => { + const _60: rs.OnceLock = cell; + const _57: undefined = rs.onceGetOrInit(cell, (): undefined => { make(v2 ^ 1); - rt.onceSet(_60, undefined, rt.None); + rs.onceSet(_60, undefined, rs.None); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t2: undefined = rt.onceGetOrInit(cell, (): undefined => { - put(inner, rt.onceGetOrInit(_69, (): undefined => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t2: undefined = rs.onceGetOrInit(cell, (): undefined => { + put(inner, rs.onceGetOrInit(_69, (): undefined => { make(v2 ^ 1); - }, undefined, rt.None)); + }, undefined, rs.None)); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: undefined = rt.onceGetOrInit(cell, (): undefined => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); - }, undefined, rt.None); + const _76: undefined = rs.onceGetOrInit(cell, (): undefined => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); + }, undefined, rs.None); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { + if (rs.u8Rem(v2, 2) === 0) { make(v2); - cell = new rt.OnceLock(undefined); + cell = new rs.OnceLock(undefined); } else { - cell = new rt.OnceLock(rt.None); + cell = new rs.OnceLock(rs.None); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_unit(cell); - const copy: rt.OnceLock = rt.onceClone(cell, undefined, rt.None); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t3: undefined = rt.onceGetOrInit(cell, (): undefined => { - inner2 = rt.onceClone(_95, undefined, rt.None); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_unit(cell); + const copy: rs.OnceLock = rs.onceClone(cell, undefined, rs.None); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t3: undefined = rs.onceGetOrInit(cell, (): undefined => { + inner2 = rs.onceClone(_95, undefined, rs.None); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t3); - rt.byteVecPush(out, alias.v !== rt.None ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== rs.None ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - if (_112.v === rt.None) { - rt.byteVecPush(out, 238); + if (_112.v === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, undefined); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t4: undefined = rt.onceGetOrInit(cell, (): undefined => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", rt.fmtUnit, rt.None)]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t4: undefined = rs.onceGetOrInit(cell, (): undefined => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", rs.fmtUnit, rs.None)]; + inner3 = rs.fmtFormat([args6[0]]); make(v2); - }, undefined, rt.None); + }, undefined, rs.None); put(out, t4); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.fmtUnit, rt.None)]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", rt.fmtUnit, rt.None)]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", rs.fmtUnit, rs.None)]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - if (rt.optionAsMut(cell, rt.None) === undefined) { - rt.byteVecPush(out, 0); + if (rs.optionAsMut(cell, rs.None) === undefined) { + rs.byteVecPush(out, 0); } else { make(v2); - rt.byteVecPush(out, 1); - const _162: undefined = rt.optionUnwrap(cell.v, rt.None); + rs.byteVecPush(out, 1); + const _162: undefined = rs.optionUnwrap(cell.v, rs.None); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$unit(make, v2); - }, undefined, rt.None); + }, undefined, rs.None); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { make(v2 ^ 1); - rt.onceSet(_174, undefined, rt.None); + rs.onceSet(_174, undefined, rs.None); return made$unit(make, v2); - }, undefined, rt.None); + }, undefined, rs.None); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$unit(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$1916nm0(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$unit(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0vfooax(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$unit(make, v2 ^ 1); - }, undefined, rt.None), (_23: undefined): undefined => {})), v2)); - }, undefined, rt.None); + }, undefined, rs.None), (_23: undefined): undefined => {})), v2)); + }, undefined, rs.None); } if (result.ok) { const t5: undefined = result.value; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, t5); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - if (cell.v === rt.None) { - rt.byteVecPush(out, 238); + if (cell.v === rs.None) { + rs.byteVecPush(out, 238); } else { put(out, undefined); } } /** Steps of an operation and an operand on one cell, each putting what it read. */ -export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lockVec(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let text!: string; - let result!: rt.Result; - const make: (a0: rt.u8) => rt.ByteVec = (v3: rt.u8): rt.ByteVec => { - return rt.byteVecOf(v3, rt.u8Rem(v3, 4) as rt.usize); + let result!: rs.Result; + const make: (a0: rs.u8) => rs.ByteVec = (v3: rs.u8): rs.ByteVec => { + return rs.byteVecOf(v3, rs.u8Rem(v3, 4) as rs.usize); }; - const put: (a0: rt.ByteVec, a1: rt.ByteVec) => undefined = (out2: rt.ByteVec, t10: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteVecSlice(t10)); + const put: (a0: rs.ByteVec, a1: rs.ByteVec) => undefined = (out2: rs.ByteVec, t10: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteVecSlice(t10)); }; - let cell: rt.OnceLock = new rt.OnceLock(undefined); + let cell: rs.OnceLock = new rs.OnceLock(undefined); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const v: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const v: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const v2: rt.u8 = v; - const _18: rt.u8 = rt.u8Rem(op2, 13); + const op2: rs.u8 = op; + const v2: rs.u8 = v; + const _18: rs.u8 = rs.u8Rem(op2, 13); if (_18 === 0) { - const _20: rt.ByteVec | undefined = cell.v; + const _20: rs.ByteVec | undefined = cell.v; if (_20 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put(out, _20); } } else if (_18 === 1) { - const _26: rt.Result = rt.onceSet(cell, make(v2)); + const _26: rs.Result = rs.onceSet(cell, make(v2)); if (_26.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); } else { - const t: rt.ByteVec = _26.error; - rt.byteVecPush(out, 0); + const t: rs.ByteVec = _26.error; + rs.byteVecPush(out, 0); put(out, t); } } else if (_18 === 2) { - const _34: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { + const _34: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { return make(v2); }); put(out, _34); } else if (_18 === 3) { - let seen: rt.u8 = 2; - const _44: rt.OnceLock = cell; - const t2: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { + let seen: rs.u8 = 2; + const _44: rs.OnceLock = cell; + const t2: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { seen = _44.v !== undefined ? 1 : 0; return make(v2); }); put(out, t2); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } else if (_18 === 4) { - const _50: rt.ByteVec | undefined = rt.onceTake(cell); + const _50: rs.ByteVec | undefined = rs.onceTake(cell); if (_50 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const t3: rt.ByteVec = _50; - rt.byteVecPush(out, 1); + const t3: rs.ByteVec = _50; + rs.byteVecPush(out, 1); put(out, t3); } } else if (_18 === 5) { - const _60: rt.OnceLock = cell; - const _57: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - rt.onceSet(_60, make(v2 ^ 1)); + const _60: rs.OnceLock = cell; + const _57: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + rs.onceSet(_60, make(v2 ^ 1)); return make(v2); }); put(out, _57); } else if (_18 === 6) { - const inner: rt.ByteVec = new rt.ByteVec(); - const _69: rt.OnceLock = cell; - const t4: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - put(inner, rt.onceGetOrInit(_69, (): rt.ByteVec => { + const inner: rs.ByteVec = new rs.ByteVec(); + const _69: rs.OnceLock = cell; + const t4: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + put(inner, rs.onceGetOrInit(_69, (): rs.ByteVec => { return make(v2 ^ 1); })); return make(v2); }); put(out, t4); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(inner)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(inner)); } else if (_18 === 7) { - const _76: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v2, f)]; - rt.panicFmt(["init ", args8[0]]); + const _76: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v2, f)]; + rs.panicFmt(["init ", args8[0]]); }); put(out, _76); } else if (_18 === 8) { - if (rt.u8Rem(v2, 2) === 0) { - cell = new rt.OnceLock(make(v2)); + if (rs.u8Rem(v2, 2) === 0) { + cell = new rs.OnceLock(make(v2)); } else { - cell = new rt.OnceLock(undefined); + cell = new rs.OnceLock(undefined); } } else if (_18 === 9) { - const alias: rt.OnceLock = twin$ref_sync_OnceLock_Vec_u8(cell); - const copy: rt.OnceLock = rt.onceClone(cell, (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const alias: rs.OnceLock = twin$ref_sync_OnceLock_Vec_u8(cell); + const copy: rs.OnceLock = rs.onceClone(cell, (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); }); - let inner2 = undefined as rt.OnceLock | undefined; - const _95: rt.OnceLock = cell; - const t5: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - inner2 = rt.onceClone(_95, (a02: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a02)); + let inner2 = undefined as rs.OnceLock | undefined; + const _95: rs.OnceLock = cell; + const t5: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + inner2 = rs.onceClone(_95, (a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); }); return make(v2); }); put(out, t5); - rt.byteVecPush(out, alias.v !== undefined ? 1 : 0); - const iter: rt.Iter> = rt.iterFlatten(rt.iterSlice([copy, inner2]), (value: rt.OnceLock | undefined) => rt.iterOption(value), true, undefined, true); + rs.byteVecPush(out, alias.v !== undefined ? 1 : 0); + const iter: rs.Iter> = rs.iterFlatten(rs.iterSlice([copy, inner2]), (value: rs.OnceLock | undefined) => rs.iterOption(value), true, undefined, true); while (true) { - const _112: rt.OnceLock | rt.Done = iter.next(); - if (_112 === rt.DONE) { + const _112: rs.OnceLock | rs.Done = iter.next(); + if (_112 === rs.DONE) { break; } - const _116: rt.ByteVec | undefined = _112.v; + const _116: rs.ByteVec | undefined = _112.v; if (_116 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _116); } } } else if (_18 === 10) { let inner3: string = ""; - const _125: rt.OnceLock = cell; - const t7: rt.ByteVec = rt.onceGetOrInit(cell, (): rt.ByteVec => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.onceDebug(_125, f, "OnceLock", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - inner3 = rt.fmtFormat([args6[0]]); + const _125: rs.OnceLock = cell; + const t7: rs.ByteVec = rs.onceGetOrInit(cell, (): rs.ByteVec => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.onceDebug(_125, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + inner3 = rs.fmtFormat([args6[0]]); return make(v2); }); put(out, t7); - if (rt.u8Rem(v2, 2) === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - text = rt.fmtFormat([args2[0], " ", args2[1]]); + if (rs.u8Rem(v2, 2) === 0) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args2[0], " ", args2[1]]); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, inner3), (f: rt.Formatter) => rt.onceDebug(cell, f, "OnceLock", (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - text = rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[1])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, inner3), (f: rs.Formatter) => rs.onceDebug(cell, f, "OnceLock", (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + text = rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[1])]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } else if (_18 === 11) { - const _155: rt.ByteVec | undefined = cell.v; + const _155: rs.ByteVec | undefined = cell.v; if (_155 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { Object.assign(_155, make(v2)); - rt.byteVecPush(out, 1); - const _162: rt.ByteVec = rt.optionUnwrap(cell.v); + rs.byteVecPush(out, 1); + const _162: rs.ByteVec = rs.optionUnwrap(cell.v); put(out, _162); } } else { - const _166: rt.u8 = rt.u8Rem(v2, 4); + const _166: rs.u8 = rs.u8Rem(v2, 4); if (_166 === 0 || _166 === 1) { - result = rt.onceGetOrTryInit(cell, (): rt.Result => { + result = rs.onceGetOrTryInit(cell, (): rs.Result => { return made$Vec_u8(make, v2); }); } else if (_166 === 2) { - const _174: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - rt.onceSet(_174, make(v2 ^ 1)); + const _174: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + rs.onceSet(_174, make(v2 ^ 1)); return made$Vec_u8(make, v2); }); } else { - const _179: rt.OnceLock = cell; - result = rt.onceGetOrTryInit(cell, (): rt.Result => { - return made$Vec_u8(make, option_unwrapOr$0r2bmpr(err$1nbmqmx(result_map$14n87rz(rt.onceGetOrTryInit(_179, (): rt.Result => { + const _179: rs.OnceLock = cell; + result = rs.onceGetOrTryInit(cell, (): rs.Result => { + return made$Vec_u8(make, option_unwrapOr$1fr498u(err$1yr5s3w(result_map$0zkrphe(rs.onceGetOrTryInit(_179, (): rs.Result => { return made$Vec_u8(make, v2 ^ 1); - }), (_22: rt.ByteVec): undefined => {})), v2)); + }), (_22: rs.ByteVec): undefined => {})), v2)); }); } if (result.ok) { - const t8: rt.ByteVec = result.value; - rt.byteVecPush(out, 1); + const t8: rs.ByteVec = result.value; + rs.byteVecPush(out, 1); put(out, t8); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, result.error))); } } } - const _190: rt.ByteVec | undefined = cell.v; + const _190: rs.ByteVec | undefined = cell.v; if (_190 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { put(out, _190); } } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_Option_u8(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_Option_u8(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_String(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_String(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_Vec_u8(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_Vec_u8(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_u64(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_u64(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_u8(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_u8(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_cell_OnceCell_unit(t: rt.OnceCell): rt.OnceCell { +export function twin$ref_cell_OnceCell_unit(t: rs.OnceCell): rs.OnceCell { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_Option_u8(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_Option_u8(t: rs.OnceLock): rs.OnceLock { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_String(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_String(t: rs.OnceLock): rs.OnceLock { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_Vec_u8(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_Vec_u8(t: rs.OnceLock): rs.OnceLock { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_u64(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_u64(t: rs.OnceLock): rs.OnceLock { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_u8(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_u8(t: rs.OnceLock): rs.OnceLock { return t; } /** A clone of `t`, which for a reference is that reference. */ -export function twin$ref_sync_OnceLock_unit(t: rt.OnceLock): rt.OnceLock { +export function twin$ref_sync_OnceLock_unit(t: rs.OnceLock): rs.OnceLock { return t; } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$Option_u8(make: (a0: rt.u8) => rt.u8 | undefined, v: rt.u8): rt.u8 | undefined { - if (rt.u8Rem(v, 3) === 0) { +export function made$Option_u8(make: (a0: rs.u8) => rs.u8 | undefined, v: rs.u8): rs.u8 | undefined { + if (rs.u8Rem(v, 3) === 0) { return v; } out$Option_u8.p = make(v); @@ -2326,24 +2326,24 @@ export function made$Option_u8(make: (a0: rt.u8) => rt.u8 | undefined, v: rt.u8) } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$String(make: (a0: rt.u8) => string, v: rt.u8): rt.Result { - if (rt.u8Rem(v, 3) === 0) { - return rt.Err(v); +export function made$String(make: (a0: rs.u8) => string, v: rs.u8): rs.Result { + if (rs.u8Rem(v, 3) === 0) { + return rs.Err(v); } - return rt.Ok(make(v)); + return rs.Ok(make(v)); } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$Vec_u8(make: (a0: rt.u8) => rt.ByteVec, v: rt.u8): rt.Result { - if (rt.u8Rem(v, 3) === 0) { - return rt.Err(v); +export function made$Vec_u8(make: (a0: rs.u8) => rs.ByteVec, v: rs.u8): rs.Result { + if (rs.u8Rem(v, 3) === 0) { + return rs.Err(v); } - return rt.Ok(make(v)); + return rs.Ok(make(v)); } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$u64(make: (a0: rt.u8) => rt.u64, v: rt.u8): rt.u64 | undefined { - if (rt.u8Rem(v, 3) === 0) { +export function made$u64(make: (a0: rs.u8) => rs.u64, v: rs.u8): rs.u64 | undefined { + if (rs.u8Rem(v, 3) === 0) { out$u64.err = v; return undefined; } @@ -2351,8 +2351,8 @@ export function made$u64(make: (a0: rt.u8) => rt.u64, v: rt.u8): rt.u64 | undefi } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$u8(make: (a0: rt.u8) => rt.u8, v: rt.u8): rt.u8 | undefined { - if (rt.u8Rem(v, 3) === 0) { +export function made$u8(make: (a0: rs.u8) => rs.u8, v: rs.u8): rs.u8 | undefined { + if (rs.u8Rem(v, 3) === 0) { out$u8.err = v; return undefined; } @@ -2360,29 +2360,29 @@ export function made$u8(make: (a0: rt.u8) => rt.u8, v: rt.u8): rt.u8 | undefined } /** What `make` makes of `v`, or `v` back as an error for every third byte. */ -export function made$unit(make: (a0: rt.u8) => undefined, v: rt.u8): rt.Result { - if (rt.u8Rem(v, 3) === 0) { - return rt.Err(v); +export function made$unit(make: (a0: rs.u8) => undefined, v: rs.u8): rs.Result { + if (rs.u8Rem(v, 3) === 0) { + return rs.Err(v); } make(v); - return rt.OK; + return rs.OK; } /** A `u64` past 2^53, from one byte. */ -export function wide(v: rt.u8): rt.u64 { - return rt.u64Mul(v as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); +export function wide(v: rs.u8): rs.u64 { + return rs.u64Mul(v as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); } /** `None` for every third byte. */ -export function maybe(v: rt.u8): rt.u8 | undefined { - return thenSome$0d5am30(rt.u8Rem(v, 3) !== 0, v); +export function maybe(v: rs.u8): rs.u8 | undefined { + return thenSome$0quywni(rs.u8Rem(v, 3) !== 0, v); } -export function putMaybe(out: rt.ByteVec, t: rt.u8 | undefined): void { +export function putMaybe(out: rs.ByteVec, t: rs.u8 | undefined): void { if (t === undefined) { - rt.byteVecPush(out, 2); + rs.byteVecPush(out, 2); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(1, t))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(1, t))); } } diff --git a/ts/fixtures/lang/cells/expected/core/bool.ts b/ts/fixtures/lang/cells/expected/core/bool.ts index 17d957542..05e0dcab5 100644 --- a/ts/fixtures/lang/cells/expected/core/bool.ts +++ b/ts/fixtures/lang/cells/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/cells/expected/core/option.ts b/ts/fixtures/lang/cells/expected/core/option.ts index 0fb1b6278..020e119ff 100644 --- a/ts/fixtures/lang/cells/expected/core/option.ts +++ b/ts/fixtures/lang/cells/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/cells/expected/core/result.ts b/ts/fixtures/lang/cells/expected/core/result.ts index e51dd643c..b4dbe26e3 100644 --- a/ts/fixtures/lang/cells/expected/core/result.ts +++ b/ts/fixtures/lang/cells/expected/core/result.ts @@ -1,58 +1,58 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function err$1nbmqmx(self: rt.Result): rt.u8 | undefined { +export function err$1yr5s3w(self: rs.Result): rs.u8 | undefined { if (self.ok) { return undefined; } return self.error; } -export function map$1ma2nl9(self: rt.Result, op: (a0: rt.u8 | undefined) => undefined): rt.Result { +export function map$0vjzmou(self: rs.Result, op: (a0: rs.u8 | undefined) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function map$0l5uclx(self: rt.Result, op: (a0: string) => undefined): rt.Result { +export function map$0ac8dwe(self: rs.Result, op: (a0: string) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function map$14n87rz(self: rt.Result, op: (a0: rt.ByteVec) => undefined): rt.Result { +export function map$0zkrphe(self: rs.Result, op: (a0: rs.ByteVec) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function map$0h1vl84(self: rt.Result, op: (a0: rt.u64) => undefined): rt.Result { +export function map$0w147c6(self: rs.Result, op: (a0: rs.u64) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function map$03hz3l7(self: rt.Result, op: (a0: rt.u8) => undefined): rt.Result { +export function map$1gelxzx(self: rs.Result, op: (a0: rs.u8) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function map$1916nm0(self: rt.Result, op: (a0: undefined) => undefined): rt.Result { +export function map$0vfooax(self: rs.Result, op: (a0: undefined) => undefined): rs.Result { if (self.ok) { op(undefined); - return rt.OK; + return rs.OK; } return self; } diff --git a/ts/fixtures/lang/cells/expected/harness.ts b/ts/fixtures/lang/cells/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/cells/expected/harness.ts +++ b/ts/fixtures/lang/cells/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/cells/expected/lib.ts b/ts/fixtures/lang/cells/expected/lib.ts index e18d1ef5e..d50a6193a 100644 --- a/ts/fixtures/lang/cells/expected/lib.ts +++ b/ts/fixtures/lang/cells/expected/lib.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cells } from "./cells.ts"; -export const out$Option_u8: { p: rt.u8 | undefined } = { p: undefined as never }; +export const out$Option_u8: { p: rs.u8 | undefined } = { p: undefined as never }; export const out$u64: { err: unknown } = { err: undefined }; @@ -13,8 +13,8 @@ export const out$u8: { err: unknown } = { err: undefined }; * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["cells::cells", cells as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["cells::cells", cells as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/cells/src/cells.rs b/ts/fixtures/lang/cells/src/cells.rs index 8cdbf3d35..f996d178a 100644 --- a/ts/fixtures/lang/cells/src/cells.rs +++ b/ts/fixtures/lang/cells/src/cells.rs @@ -1,5 +1,5 @@ //! One-time cells, `OnceCell` and `OnceLock`, of values that are numbers, wide integers, -//! `Option`s whose `None` is `rt.None`, `()`, strings, and vectors: read, set, initialized, taken, +//! `Option`s whose `None` is `rs.None`, `()`, strings, and vectors: read, set, initialized, taken, //! cloned, debugged, written through `get_mut`, initialized by a function that may fail, //! and initialized again from within their own initialization, which panics. diff --git a/ts/fixtures/lang/chars/expected/chars.ts b/ts/fixtures/lang/chars/expected/chars.ts index 5c8434396..7799cfda5 100644 --- a/ts/fixtures/lang/chars/expected/chars.ts +++ b/ts/fixtures/lang/chars/expected/chars.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { eq$163p0qo as char_eq$163p0qo } from "./core/char.ts"; -import { eq$0fgf8wq as convert_eq$0fgf8wq } from "./core/char/convert.ts"; -import { eq$1rmi26t as decode_eq$1rmi26t } from "./core/char/decode.ts"; -import { isDigit$0mzngr5 } from "./core/char/methods.ts"; -import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0i0pebg as option_mapOr$0i0pebg, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; -import { eq$16wvkx3 as result_eq$16wvkx3, map$1v0rxej as result_map$1v0rxej, and$15pno2s as result_and$15pno2s, unwrapOr$1w5vhiw as result_unwrapOr$1w5vhiw } from "./core/result.ts"; +import * as rs from "./rs.ts"; +import { eq$1g188ap as char_eq$1g188ap } from "./core/char.ts"; +import { eq$1efmo6b as convert_eq$1efmo6b } from "./core/char/convert.ts"; +import { eq$1qya0xd as decode_eq$1qya0xd } from "./core/char/decode.ts"; +import { isDigit$10ivuux } from "./core/char/methods.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$1wlsr3s as option_mapOr$1wlsr3s, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { eq$1k9tumx as result_eq$1k9tumx, map$1q32zo4 as result_map$1q32zo4, and$02o4suw as result_and$02o4suw, unwrapOr$1yj84xe as result_unwrapOr$1yj84xe } from "./core/result.ts"; import { put, text } from "./harness.ts"; /** The scalars to try: the edges, then each big-endian `u32` in `data`, zero-padded. */ -export function scalars(data: rt.ByteSlice): rt.Vec { - const all: rt.Vec = rt.vecFrom([0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice()); - let rest: rt.ByteSlice = data; +export function scalars(data: rs.ByteSlice): rs.Vec { + const all: rs.Vec = rs.vecFrom([0, 127, 128, 255, 256, 2047, 2048, 55295, 55296, 56319, 56320, 57343, 57344, 65533, 65535, 65536, 1114109, 1114111, 1114112, 4294967295].slice()); + let rest: rs.ByteSlice = data; while (true) { if (!(rest.length === 0)) { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(rest.length, 4); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(rest, 0, n)); - all.items.push(rt.u32FromBeBytes(buf)); - rest = rt.byteSliceRange(rest, n); + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(rest.length, 4); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(rest, 0, n)); + all.items.push(rs.u32FromBeBytes(buf)); + rest = rs.byteSliceRange(rest, n); } else { return all; } @@ -27,7 +27,7 @@ export function scalars(data: rt.ByteSlice): rt.Vec { } /** A char's class, by a switch on its value and ranges of it. */ -export function class_(c: rt.char): rt.u8 { +export function class_(c: rs.char): rs.u8 { b1: { if (c === 0) { return 0; @@ -70,75 +70,75 @@ export function class_(c: rt.char): rt.u8 { return 2; } -export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 4); +export function chars(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 4); if (_4 === 0) { for (const _10 of scalars(data).items) { - const _14: rt.char | undefined = rt.charFromU32(_10); + const _14: rs.char | undefined = rs.charFromU32(_10); if (_14 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const c: rt.char = _14; - rt.byteVecPush(out, class_(c)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(c as rt.u32))); + const c: rs.char = _14; + rs.byteVecPush(out, class_(c)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(c as rs.u32))); } } } else if (_4 === 1) { for (const n2 of scalars(data).items) { - const c2: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(n2), (n2 & 0xff) as rt.char); - rt.byteVecPush(out, c2 & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(c2 & 0xffff))); - rt.byteVecPush(out, ((c2 << 24) >> 24) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((c2 << 16) >> 16))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(c2 as rt.i32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(c2 as rt.u64))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(c2 as rt.i128))); - rt.byteVecPush(out, ((n2 & 0xff) as rt.char) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(((c2 as rt.u32) & 0xff) as rt.u16))); + const c2: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(n2), (n2 & 0xff) as rs.char); + rs.byteVecPush(out, c2 & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(c2 & 0xffff))); + rs.byteVecPush(out, ((c2 << 24) >> 24) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((c2 << 16) >> 16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(c2 as rs.i32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(c2 as rs.u64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(c2 as rs.i128))); + rs.byteVecPush(out, ((n2 & 0xff) as rs.char) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(((c2 as rs.u32) & 0xff) as rs.u16))); } } else if (_4 === 2) { - const cs: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.vecIntoIter(scalars(data)), (a0: rt.u32): rt.char | undefined => { - return rt.charFromU32(a0); + const cs: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.vecIntoIter(scalars(data)), (a0: rs.u32): rs.char | undefined => { + return rs.charFromU32(a0); }), "next", 4, false, 4); - const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - const seen: rt.HashSet = rt.hashNew() as rt.HashSet; - const iter3: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.iterSlice(cs.items)); + const sorted: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; + const seen: rs.HashSet = rs.hashNew() as rs.HashSet; + const iter3: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.iterSlice(cs.items)); while (true) { - const _88: [rt.usize, rt.char] | rt.Done = iter3.next(); - if (_88 === rt.DONE) { + const _88: [rs.usize, rs.char] | rs.Done = iter3.next(); + if (_88 === rs.DONE) { break; } - const i: rt.usize = _88[0]; - const c3: rt.char = _88[1]; - const d: rt.char = cs.items[rt.idx(cs.items, rt.usizeRem(rt.usizeAdd(rt.usizeMul(i, 7), 3), cs.items.length))]; - rt.byteVecPush(out, (c3 < d ? 1 : 0) | (((c3 === d ? 1 : 0) << 1) & 0xff) | (((c3 >= 122 ? 1 : 0) << 2) & 0xff)); - rt.byteVecPush(out, rt.hashAdd(seen, c3) ? 1 : 0); - rt.btreeAdd(sorted, c3); + const i: rs.usize = _88[0]; + const c3: rs.char = _88[1]; + const d: rs.char = cs.items[rs.idx(cs.items, rs.usizeRem(rs.usizeAdd(rs.usizeMul(i, 7), 3), cs.items.length))]; + rs.byteVecPush(out, (c3 < d ? 1 : 0) | (((c3 === d ? 1 : 0) << 1) & 0xff) | (((c3 >= 122 ? 1 : 0) << 2) & 0xff)); + rs.byteVecPush(out, rs.hashAdd(seen, c3) ? 1 : 0); + rs.btreeAdd(sorted, c3); } - const iter4: rt.Iter = rt.btreeKeys(sorted); + const iter4: rs.Iter = rs.btreeKeys(sorted); while (true) { - const _128: rt.char | rt.Done = iter4.next(); - if (_128 === rt.DONE) { + const _128: rs.char | rs.Done = iter4.next(); + if (_128 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_128 as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_128 as rs.u32))); } } else { for (const _140 of scalars(data).items) { - const _144: rt.char | undefined = rt.charFromU32(_140); + const _144: rs.char | undefined = rs.charFromU32(_140); if (_144 !== undefined) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(_144, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 3 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 4 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 2 }, args2[0])])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(_144, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 2 }, args2[0])])); } } - const iter6: rt.Iter = rt.iterSlice([97, 39, 34, 92, 10, 0, 127, 233, 769, 173, 57344, 128512, 65438, 65439, 4447, 4448, 12644, 65440]); + const iter6: rs.Iter = rs.iterSlice([97, 39, 34, 92, 10, 0, 127, 233, 769, 173, 57344, 128512, 65438, 65439, 4447, 4448, 12644, 65440]); while (true) { - const _161: rt.char | rt.Done = iter6.next(); - if (_161 === rt.DONE) { + const _161: rs.char | rs.Done = iter6.next(); + if (_161 === rs.DONE) { break; } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDebug(_161, f), (f: rt.Formatter) => rt.fmtCharDisplay(_161, f)]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(_161, f), (f: rs.Formatter) => rs.fmtCharDisplay(_161, f)]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args4[0]), "|", args4[1]])); } } } @@ -147,209 +147,209 @@ export function chars(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Every char of one 4096-scalar block, which the input picks: each Unicode class std * tests and both case maps, by method and as a function value. */ -export function unicode(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let flags!: rt.u8; - const block: rt.u32 = rt.u32Rem(((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) << 8) | option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0)) as rt.u32, 272); - const iter: rt.Iter = rt.iterFilterMap(new rt.Range((block << 12) >>> 0, (rt.u32Add(block, 1) << 12) >>> 0), (a07: rt.u32): rt.char | undefined => { - return rt.charFromU32(a07); +export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let flags!: rs.u8; + const block: rs.u32 = rs.u32Rem(((option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) << 8) | option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0)) as rs.u32, 272); + const iter: rs.Iter = rs.iterFilterMap(new rs.Range((block << 12) >>> 0, (rs.u32Add(block, 1) << 12) >>> 0), (a07: rs.u32): rs.char | undefined => { + return rs.charFromU32(a07); }); while (true) { - const _34: rt.char | rt.Done = iter.next(); - const classes: Array<(a0: rt.char) => boolean> = [(a0: rt.char): boolean => { - return rt.charIsAlphabetic(a0); - }, (a02: rt.char): boolean => { - return rt.charIsLowercase(a02); - }, (a03: rt.char): boolean => { - return rt.charIsUppercase(a03); - }, (a04: rt.char): boolean => { - return rt.charIsAlphanumeric(a04); - }, (a05: rt.char): boolean => { - return rt.charIsControl(a05); - }, (a06: rt.char): boolean => { - return rt.charIsNumeric(a06); + const _34: rs.char | rs.Done = iter.next(); + const classes: Array<(a0: rs.char) => boolean> = [(a0: rs.char): boolean => { + return rs.charIsAlphabetic(a0); + }, (a02: rs.char): boolean => { + return rs.charIsLowercase(a02); + }, (a03: rs.char): boolean => { + return rs.charIsUppercase(a03); + }, (a04: rs.char): boolean => { + return rs.charIsAlphanumeric(a04); + }, (a05: rs.char): boolean => { + return rs.charIsControl(a05); + }, (a06: rs.char): boolean => { + return rs.charIsNumeric(a06); }]; - if (_34 === rt.DONE) { + if (_34 === rs.DONE) { break; } - const c: rt.char = _34; - if (rt.u8Rem(kind, 2) === 0) { - flags = (rt.charIsAlphabetic(c) ? 1 : 0) | (((rt.charIsLowercase(c) ? 1 : 0) << 1) & 0xff) | (((rt.charIsUppercase(c) ? 1 : 0) << 2) & 0xff) | (((rt.charIsAlphanumeric(c) ? 1 : 0) << 3) & 0xff) | (((rt.charIsControl(c) ? 1 : 0) << 4) & 0xff) | (((rt.charIsNumeric(c) ? 1 : 0) << 5) & 0xff) | (((isDigit$0mzngr5(c, 36) ? 1 : 0) << 6) & 0xff); + const c: rs.char = _34; + if (rs.u8Rem(kind, 2) === 0) { + flags = (rs.charIsAlphabetic(c) ? 1 : 0) | (((rs.charIsLowercase(c) ? 1 : 0) << 1) & 0xff) | (((rs.charIsUppercase(c) ? 1 : 0) << 2) & 0xff) | (((rs.charIsAlphanumeric(c) ? 1 : 0) << 3) & 0xff) | (((rs.charIsControl(c) ? 1 : 0) << 4) & 0xff) | (((rs.charIsNumeric(c) ? 1 : 0) << 5) & 0xff) | (((isDigit$10ivuux(c, 36) ? 1 : 0) << 6) & 0xff); } else { - flags = rt.iterFold(rt.iterEnumerate(rt.iterSlice(classes)), 0, (flags2: rt.u8, _3: [rt.usize, (a0: rt.char) => boolean]): rt.u8 => { - const i: rt.usize = _3[0]; - return flags2 | rt.u8Shl(_3[1](c) ? 1 : 0, i); + flags = rs.iterFold(rs.iterEnumerate(rs.iterSlice(classes)), 0, (flags2: rs.u8, _3: [rs.usize, (a0: rs.char) => boolean]): rs.u8 => { + const i: rs.usize = _3[0]; + return flags2 | rs.u8Shl(_3[1](c) ? 1 : 0, i); }); } - rt.byteVecPush(out, flags); - const iter2: rt.Iter = rt.iterChain(rt.charToLowercase(c), rt.charToUppercase(c)); + rs.byteVecPush(out, flags); + const iter2: rs.Iter = rs.iterChain(rs.charToLowercase(c), rs.charToUppercase(c)); while (true) { - const _91: rt.char | rt.Done = iter2.next(); - if (_91 === rt.DONE) { + const _91: rs.char | rs.Done = iter2.next(); + if (_91 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(rt.byteSliceFrom(rt.u32ToBeBytes(_91 as rt.u32)), 1)); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteSliceFrom(rs.u32ToBeBytes(_91 as rs.u32)), 1)); } - rt.byteVecPush(out, (rt.charToLowercase(c).len() & 0xff) | (((rt.charToUppercase(c).len() & 0xff) << 2) & 0xff)); + rs.byteVecPush(out, (rs.charToLowercase(c).len() & 0xff) | (((rs.charToUppercase(c).len() & 0xff) << 2) & 0xff)); } } /** What each iterator does from either end, sized, cloned, and printed partway. */ -export function walk$char_EscapeDebug(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeDebug")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const _18: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _18[0]; - const high: rt.usize | undefined = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$02k4ito(high, 255, (h: rt.usize): rt.u8 => { +export function walk$char_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _18[0]; + const high: rs.usize | undefined = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$188iunt(high, 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const copy: rt.Iter = it.clone(); - const first: rt.char | undefined = rt.iterToOption(it.next()); - const _39: rt.usize = it.len(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeDebug"), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f), (f: rt.Formatter) => rt.usizeDisplay(_39, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); - const _60: rt.char | undefined = rt.iterLast(copy.clone()); - const _64: rt.usize = rt.iterCount(copy.clone()); - const _68: rt.char | undefined = rt.iterNth(copy.clone(), 1); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_60, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.fmtOption(_68, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rt.stringExtendChars("", it); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rest), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const copy: rs.Iter = it.clone(); + const first: rs.char | undefined = rs.iterToOption(it.next()); + const _39: rs.usize = it.len(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const _60: rs.char | undefined = rs.iterLast(copy.clone()); + const _64: rs.usize = rs.iterCount(copy.clone()); + const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const rest: string = rs.stringExtendChars("", it); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ -export function walk$char_EscapeDefault(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeDefault")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const _18: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _18[0]; - const high: rt.usize | undefined = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$02k4ito(high, 255, (h: rt.usize): rt.u8 => { +export function walk$char_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _18[0]; + const high: rs.usize | undefined = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$188iunt(high, 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const copy: rt.Iter = it.clone(); - const first: rt.char | undefined = rt.iterToOption(it.next()); - const _39: rt.usize = it.len(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeDefault"), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f), (f: rt.Formatter) => rt.usizeDisplay(_39, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); - const _60: rt.char | undefined = rt.iterLast(copy.clone()); - const _64: rt.usize = rt.iterCount(copy.clone()); - const _68: rt.char | undefined = rt.iterNth(copy.clone(), 1); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_60, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.fmtOption(_68, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rt.stringExtendChars("", it); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rest), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const copy: rs.Iter = it.clone(); + const first: rs.char | undefined = rs.iterToOption(it.next()); + const _39: rs.usize = it.len(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeDefault"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const _60: rs.char | undefined = rs.iterLast(copy.clone()); + const _64: rs.usize = rs.iterCount(copy.clone()); + const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const rest: string = rs.stringExtendChars("", it); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ -export function walk$char_EscapeUnicode(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeUnicode")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const _18: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _18[0]; - const high: rt.usize | undefined = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$02k4ito(high, 255, (h: rt.usize): rt.u8 => { +export function walk$char_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _18[0]; + const high: rs.usize | undefined = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$188iunt(high, 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const copy: rt.Iter = it.clone(); - const first: rt.char | undefined = rt.iterToOption(it.next()); - const _39: rt.usize = it.len(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f), (f: rt.Formatter) => rt.usizeDisplay(_39, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); - const _60: rt.char | undefined = rt.iterLast(copy.clone()); - const _64: rt.usize = rt.iterCount(copy.clone()); - const _68: rt.char | undefined = rt.iterNth(copy.clone(), 1); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_60, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.fmtOption(_68, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rt.stringExtendChars("", it); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rest), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const copy: rs.Iter = it.clone(); + const first: rs.char | undefined = rs.iterToOption(it.next()); + const _39: rs.usize = it.len(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "EscapeUnicode"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const _60: rs.char | undefined = rs.iterLast(copy.clone()); + const _64: rs.usize = rs.iterCount(copy.clone()); + const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const rest: string = rs.stringExtendChars("", it); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ -export function walk$char_ToLowercase(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "ToLowercase")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const _18: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _18[0]; - const high: rt.usize | undefined = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$02k4ito(high, 255, (h: rt.usize): rt.u8 => { +export function walk$char_ToLowercase(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _18[0]; + const high: rs.usize | undefined = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$188iunt(high, 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const copy: rt.Iter = it.clone(); - const first: rt.char | undefined = rt.iterToOption(it.next()); - const _39: rt.usize = it.len(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "ToLowercase"), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f), (f: rt.Formatter) => rt.usizeDisplay(_39, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); - const _60: rt.char | undefined = rt.iterLast(copy.clone()); - const _64: rt.usize = rt.iterCount(copy.clone()); - const _68: rt.char | undefined = rt.iterNth(copy.clone(), 1); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_60, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.fmtOption(_68, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rt.stringExtendChars("", it); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rest), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const copy: rs.Iter = it.clone(); + const first: rs.char | undefined = rs.iterToOption(it.next()); + const _39: rs.usize = it.len(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToLowercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const _60: rs.char | undefined = rs.iterLast(copy.clone()); + const _64: rs.usize = rs.iterCount(copy.clone()); + const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const rest: string = rs.stringExtendChars("", it); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } /** What each iterator does from either end, sized, cloned, and printed partway. */ -export function walk$char_ToUppercase(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "ToUppercase")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const _18: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _18[0]; - const high: rt.usize | undefined = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$02k4ito(high, 255, (h: rt.usize): rt.u8 => { +export function walk$char_ToUppercase(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const _18: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _18[0]; + const high: rs.usize | undefined = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(it.len() & 0xff, low & 0xff, option_mapOr$188iunt(high, 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const copy: rt.Iter = it.clone(); - const first: rt.char | undefined = rt.iterToOption(it.next()); - const _39: rt.usize = it.len(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(it, f), (f: rt.Formatter) => rt.fmtCharsDebug(it, f, "ToUppercase"), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f), (f: rt.Formatter) => rt.usizeDisplay(_39, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); - const _60: rt.char | undefined = rt.iterLast(copy.clone()); - const _64: rt.usize = rt.iterCount(copy.clone()); - const _68: rt.char | undefined = rt.iterNth(copy.clone(), 1); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_60, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.fmtOption(_68, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); - const rest: string = rt.stringExtendChars("", it); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rest), (f: rt.Formatter) => rt.fmtCharsDisplay(copy, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const copy: rs.Iter = it.clone(); + const first: rs.char | undefined = rs.iterToOption(it.next()); + const _39: rs.usize = it.len(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(it, f), (f: rs.Formatter) => rs.fmtCharsDebug(it, f, "ToUppercase"), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f), (f: rs.Formatter) => rs.usizeDisplay(_39, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", args4[3], "|", args4[4]])); + const _60: rs.char | undefined = rs.iterLast(copy.clone()); + const _64: rs.usize = rs.iterCount(copy.clone()); + const _68: rs.char | undefined = rs.iterNth(copy.clone(), 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_60, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.fmtOption(_68, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", args6[2]])); + const rest: string = rs.stringExtendChars("", it); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rest), (f: rs.Formatter) => rs.fmtCharsDisplay(copy, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } /** * `char`'s case maps and escapes as iterators: what each yields from either end, its * length, its clone, and its `Display` and `Debug` before and partway through. */ -export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = rt.iterChain(rt.iterFilterMap(rt.vecIntoIter(scalars(data)), (a0: rt.u32): rt.char | undefined => { - return rt.charFromU32(a0); - }), rt.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); +export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const iter: rs.Iter = rs.iterChain(rs.iterFilterMap(rs.vecIntoIter(scalars(data)), (a0: rs.u32): rs.char | undefined => { + return rs.charFromU32(a0); + }), rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); while (true) { - const _11: rt.char | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: rs.char | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - const c: rt.char = _11; - const _15: rt.u8 = rt.u8Rem(kind, 5); + const c: rs.char = _11; + const _15: rs.u8 = rs.u8Rem(kind, 5); if (_15 === 0) { - walk$char_ToLowercase(out, rt.charToLowercase(c)); - put(out, rt.stringExtendChars("", rt.iterRev(rt.charToLowercase(c)))); + walk$char_ToLowercase(out, rs.charToLowercase(c)); + put(out, rs.stringExtendChars("", rs.iterRev(rs.charToLowercase(c)))); } else if (_15 === 1) { - walk$char_ToUppercase(out, rt.charToUppercase(c)); - const up: rt.Iter = rt.charToUppercase(c); - const _36: rt.char | undefined = rt.iterToOption(up.nextBack()); - const _39: rt.char | undefined = rt.iterToOption(up.next()); - const _42: rt.usize = up.len(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_36, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtOption(_39, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtCharsDisplay(up, f), (f: rt.Formatter) => rt.fmtCharsDebug(up, f, "ToUppercase"), (f: rt.Formatter) => rt.usizeDisplay(_42, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4]])); + walk$char_ToUppercase(out, rs.charToUppercase(c)); + const up: rs.Iter = rs.charToUppercase(c); + const _36: rs.char | undefined = rs.iterToOption(up.nextBack()); + const _39: rs.char | undefined = rs.iterToOption(up.next()); + const _42: rs.usize = up.len(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_36, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtOption(_39, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtCharsDisplay(up, f), (f: rs.Formatter) => rs.fmtCharsDebug(up, f, "ToUppercase"), (f: rs.Formatter) => rs.usizeDisplay(_42, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4]])); } else if (_15 === 2) { - walk$char_EscapeUnicode(out, rt.charEscapeUnicode(c)); + walk$char_EscapeUnicode(out, rs.charEscapeUnicode(c)); } else if (_15 === 3) { - walk$char_EscapeDebug(out, rt.charEscapeDebug(c)); + walk$char_EscapeDebug(out, rs.charEscapeDebug(c)); } else { - walk$char_EscapeDefault(out, rt.charEscapeDefault(c)); + walk$char_EscapeDefault(out, rs.charEscapeDefault(c)); } } } @@ -358,56 +358,56 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `len_utf8` and `len_utf16`, and `encode_utf8` and `encode_utf16` into buffers long * enough, written through after, or of a length the input picks, which panics when short. */ -export function encodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = rt.iterChain(rt.iterFilterMap(rt.vecIntoIter(scalars(data)), (a0: rt.u32): rt.char | undefined => { - return rt.charFromU32(a0); - }), rt.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); +export function encodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const iter: rs.Iter = rs.iterChain(rs.iterFilterMap(rs.vecIntoIter(scalars(data)), (a0: rs.u32): rs.char | undefined => { + return rs.charFromU32(a0); + }), rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); while (true) { - const _10: rt.char | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: rs.char | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const c: rt.char = _10; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.charLenUtf8(c) & 0xff, rt.charLenUtf16(c) & 0xff)), undefined, true); - const _20: rt.u8 = rt.u8Rem(kind, 3); + const c: rs.char = _10; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.charLenUtf8(c) & 0xff, rs.charLenUtf16(c) & 0xff)), undefined, true); + const _20: rs.u8 = rs.u8Rem(kind, 3); if (_20 === 0) { - const bytes: Uint8Array = rt.bytes(4).fill(170); - const s: rt.Place = rt.charEncodeUtf8(c, rt.byteSliceFrom(bytes)); - const _34: rt.usize = rt.stringLen(s.v); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s.v), (f: rt.Formatter) => rt.usizeDisplay(_34, f), (f: rt.Formatter) => rt.fmtStr(s.v, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); - s.v = rt.strToAsciiUppercase(s.v); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const units: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { + const bytes: Uint8Array = rs.bytes(4).fill(170); + const s: rs.Place = rs.charEncodeUtf8(c, rs.byteSliceFrom(bytes)); + const _34: rs.usize = rs.stringLen(s.v); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s.v), (f: rs.Formatter) => rs.usizeDisplay(_34, f), (f: rs.Formatter) => rs.fmtStr(s.v, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + s.v = rs.strToAsciiUppercase(s.v); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); + const units: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return 43690; }); - const u: rt.u16[] = rt.charEncodeUtf16(c, units); - rt.byteVecPush(out, u.length & 0xff); - rt.idx(u, 0); + const u: rs.u16[] = rs.charEncodeUtf16(c, units); + rs.byteVecPush(out, u.length & 0xff); + rs.idx(u, 0); u[0] = u[0] ^ 1; - const iter2: rt.Iter = rt.iterSlice(units); + const iter2: rs.Iter = rs.iterSlice(units); while (true) { - const _62: rt.u16 | rt.Done = iter2.next(); - if (_62 === rt.DONE) { + const _62: rs.u16 | rs.Done = iter2.next(); + if (_62 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_62))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_62))); } } else if (_20 === 1) { - const bytes2: Uint8Array = rt.bytes(7).fill(85); - rt.byteVecPush(out, rt.stringLen(rt.charEncodeUtf8(c, rt.byteSliceRange(rt.byteSliceFrom(bytes2), 2)).v) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes2)); - const units2: rt.Vec = rt.vecFromElem(7, 4, undefined); - rt.byteVecPush(out, rt.charEncodeUtf16(c, rt.sliceRangeMut(units2.items, 1)).length & 0xff); + const bytes2: Uint8Array = rs.bytes(7).fill(85); + rs.byteVecPush(out, rs.stringLen(rs.charEncodeUtf8(c, rs.byteSliceRange(rs.byteSliceFrom(bytes2), 2)).v) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes2)); + const units2: rs.Vec = rs.vecFromElem(7, 4, undefined); + rs.byteVecPush(out, rs.charEncodeUtf16(c, rs.sliceRangeMut(units2.items, 1)).length & 0xff); for (const _94 of units2.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_94))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_94))); } } else { - const n2: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.u8Rem(_2, 5) as rt.usize; + const n2: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 5) as rs.usize; }); - put(out, rt.charEncodeUtf8(c, rt.byteVecSlice(rt.byteVecOf(0, n2))).v); - rt.byteVecPush(out, rt.charEncodeUtf16(c, rt.vecFromElem(0, rt.usizeRem(n2, 3), undefined).items).length & 0xff); + put(out, rs.charEncodeUtf8(c, rs.byteVecSlice(rs.byteVecOf(0, n2))).v); + rs.byteVecPush(out, rs.charEncodeUtf16(c, rs.vecFromElem(0, rs.usizeRem(n2, 3), undefined).items).length & 0xff); } } } @@ -417,116 +417,116 @@ export function encodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * function: each char or unpaired surrogate, its error's `Display`, `Debug`, equality, and * clone, and its size hint as it goes. */ -export function decodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let it!: rt.Iter>; - const units: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (p: rt.ByteSlice): rt.u16 => { - rt.idx(p, 0); - return (p.data[p.start] << 8) | option_unwrapOr$0r2bmpr(rt.byteSliceGet(p, 1), 0); +export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let it!: rs.Iter>; + const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (p: rs.ByteSlice): rs.u16 => { + rs.idx(p, 0); + return (p.data[p.start] << 8) | option_unwrapOr$1fr498u(rs.byteSliceGet(p, 1), 0); }), undefined, 2, true); - if (rt.u8Rem(kind, 2) === 0) { - it = rt.charDecodeUtf16(rt.iterSlice(units.items)); + if (rs.u8Rem(kind, 2) === 0) { + it = rs.charDecodeUtf16(rs.iterSlice(units.items)); } else { - it = rt.charDecodeUtf16(rt.iterSlice(units.items)); + it = rs.charDecodeUtf16(rs.iterSlice(units.items)); } - let last: rt.DecodeUtf16Error | undefined = undefined; + let last: rs.DecodeUtf16Error | undefined = undefined; while (true) { - const _22: [rt.usize, rt.usize | undefined] = it.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_22[0] & 0xff, option_mapOr$02k4ito(_22[1], 255, (h: rt.usize): rt.u8 => { + const _22: [rs.usize, rs.usize | undefined] = it.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_22[0] & 0xff, option_mapOr$188iunt(_22[1], 255, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const ahead: rt.Result | undefined = rt.iterToOption(it.clone().next()); - const _33: rt.Result | rt.Done = it.next(); - if (_33 !== rt.DONE) { - const r: rt.Result = _33; - const _40: rt.Result | undefined = ahead; - const _43: rt.Result | undefined = r; - rt.byteVecPush(out, rt.eqOption(result_eq$16wvkx3)(_40, _43) ? 1 : 0); + const ahead: rs.Result | undefined = rs.iterToOption(it.clone().next()); + const _33: rs.Result | rs.Done = it.next(); + if (_33 !== rs.DONE) { + const r: rs.Result = _33; + const _40: rs.Result | undefined = ahead; + const _43: rs.Result | undefined = r; + rs.byteVecPush(out, rs.eqOption(result_eq$1k9tumx)(_40, _43) ? 1 : 0); if (r.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(r.value as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(r.value as rs.u32))); } else { - const e: rt.DecodeUtf16Error = r.error; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtDecodeUtf16ErrorDebug(e, f), (f: rt.Formatter) => rt.fmtResult(r, f, rt.fmtCharDebug, rt.fmtDecodeUtf16ErrorDebug)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", args2[2]])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(e.code))); - const _79: rt.DecodeUtf16Error | undefined = last; - const _82: rt.DecodeUtf16Error | undefined = e; - rt.byteVecPush(out, (rt.eqOption(decode_eq$1rmi26t)(_79, _82) ? 1 : 0) | (((decode_eq$1rmi26t(e, e) ? 1 : 0) << 1) & 0xff)); + const e: rs.DecodeUtf16Error = r.error; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtDecodeUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtDecodeUtf16ErrorDebug)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2]])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(e.code))); + const _79: rs.DecodeUtf16Error | undefined = last; + const _82: rs.DecodeUtf16Error | undefined = e; + rs.byteVecPush(out, (rs.eqOption(decode_eq$1qya0xd)(_79, _82) ? 1 : 0) | (((decode_eq$1qya0xd(e, e) ? 1 : 0) << 1) & 0xff)); last = e; } } else { break; } } - const s: string = rt.stringExtendChars("", rt.iterMap(rt.charDecodeUtf16(rt.iterSlice([55357, 56832])), (r2: rt.Result): rt.char => { - return result_unwrapOr$1w5vhiw(r2, 65533); + const s: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice([55357, 56832])), (r2: rs.Result): rs.char => { + return result_unwrapOr$1yj84xe(r2, 65533); })); - const lossy: string = rt.stringExtendChars("", rt.iterMap(rt.charDecodeUtf16(rt.vecIntoIter(units)), (r3: rt.Result): rt.char => { - return result_unwrapOr$1w5vhiw(r3, 63); + const lossy: string = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.vecIntoIter(units)), (r3: rs.Result): rs.char => { + return result_unwrapOr$1yj84xe(r3, 63); })); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s), (f: rt.Formatter) => rt.fmtPad(f, lossy)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, lossy)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1]])); } /** * `char::from_digit`, `is_digit`, `char::try_from` a `u32`, and `u8` and `u16` `try_from` * a `char`, with their errors and the radix panics. */ -export function converts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const radix: rt.u32 = option_mapOr$0i0pebg(rt.byteSliceFirst(data), 10, (_2: rt.u8): rt.u32 => { - return rt.u8Rem(_2, 40) as rt.u32; +export function converts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const radix: rs.u32 = option_mapOr$1wlsr3s(rs.byteSliceFirst(data), 10, (_2: rs.u8): rs.u32 => { + return rs.u8Rem(_2, 40) as rs.u32; }); - const _6: rt.u8 = rt.u8Rem(kind, 3); + const _6: rs.u8 = rs.u8Rem(kind, 3); if (_6 === 0) { - const iter: rt.Iter = rt.iterSlice([0, 1, 9, 10, 15, 35, 36, 40, 4294967295]); + const iter: rs.Iter = rs.iterSlice([0, 1, 9, 10, 15, 35, 36, 40, 4294967295]); while (true) { - const _11: rt.u32 | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: rs.u32 | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - const part3 = rt.charFromDigit(_11, radix); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args2[0]])); + const part3 = rs.charFromDigit(_11, radix); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args2[0]])); } } else if (_6 === 1) { - const iter2: rt.Iter = rt.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); + const iter2: rs.Iter = rs.iterSlice([48, 57, 97, 122, 65, 90, 47, 58, 64, 91, 96, 123, 1635, 65345]); while (true) { - const _31: rt.char | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: rs.char | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break; } - rt.byteVecPush(out, isDigit$0mzngr5(_31, radix) ? 1 : 0); + rs.byteVecPush(out, isDigit$10ivuux(_31, radix) ? 1 : 0); } } else { for (const n2 of scalars(data).items) { - const r: rt.Result = rt.charTryFrom(n2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r, f, rt.fmtCharDebug, rt.fmtCharTryFromErrorDebug)]; - put(out, rt.fmtFormat([args4[0]])); + const r: rs.Result = rs.charTryFrom(n2); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtCharDebug, rs.fmtCharTryFromErrorDebug)]; + put(out, rs.fmtFormat([args4[0]])); if (!r.ok) { - const part = new rt.CharTryFromError(); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharTryFromErrorDisplay(part, f), (f: rt.Formatter) => rt.fmtCharTryFromErrorDebug(part, f)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ align: ">", width: 45 }, args6[0]), "|", args6[1], "|", rt.fmtSpec({ alternate: true }, args6[1])])); - const _78: rt.CharTryFromError = new rt.CharTryFromError(); - rt.byteVecPush(out, convert_eq$0fgf8wq(new rt.CharTryFromError(), _78) ? 1 : 0); + const part = new rs.CharTryFromError(); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharTryFromErrorDisplay(part, f), (f: rs.Formatter) => rs.fmtCharTryFromErrorDebug(part, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 45 }, args6[0]), "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + const _78: rs.CharTryFromError = new rs.CharTryFromError(); + rs.byteVecPush(out, convert_eq$1efmo6b(new rs.CharTryFromError(), _78) ? 1 : 0); } - const _80: rt.char | undefined = rt.charFromU32(n2); + const _80: rs.char | undefined = rs.charFromU32(n2); if (_80 !== undefined) { - const c2: rt.char = _80; - const _85: [rt.Result, rt.Result] = [rt.u8TryFromChar(c2), rt.u16TryFromChar(c2)]; - const b: rt.Result = _85[0]; - const w: rt.Result = _85[1]; - const _96: rt.u64 = c2 as rt.u64; - const _98: rt.u128 = c2 as rt.u128; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(b, f, rt.u8Debug, rt.fmtTryFromCharErrorDebug), (f: rt.Formatter) => rt.fmtResult(w, f, rt.u16Debug, rt.fmtTryFromCharErrorDebug), (f: rt.Formatter) => rt.u64Display(_96, f), (f: rt.Formatter) => rt.u128Display(_98, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); - const _109: rt.Result = result_map$1v0rxej(b, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + const c2: rs.char = _80; + const _85: [rs.Result, rs.Result] = [rs.u8TryFromChar(c2), rs.u16TryFromChar(c2)]; + const b: rs.Result = _85[0]; + const w: rs.Result = _85[1]; + const _96: rs.u64 = c2 as rs.u64; + const _98: rs.u128 = c2 as rs.u128; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(b, f, rs.u8Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.fmtResult(w, f, rs.u16Debug, rs.fmtTryFromCharErrorDebug), (f: rs.Formatter) => rs.u64Display(_96, f), (f: rs.Formatter) => rs.u128Display(_98, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + const _109: rs.Result = result_map$1q32zo4(b, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; }); - if (!result_and$15pno2s(w, _109).ok) { - const part2 = new rt.TryFromCharError(); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTryFromCharErrorDisplay(part2, f), (f: rt.Formatter) => rt.fmtTryFromCharErrorDebug(part2, f)]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ align: "<", width: 35 }, args10[0]), "|", args10[1], "|", rt.fmtSpec({ alternate: true }, args10[1])])); - const _130: rt.TryFromCharError = new rt.TryFromCharError(); - rt.byteVecPush(out, char_eq$163p0qo(new rt.TryFromCharError(), _130) ? 1 : 0); + if (!result_and$02o4suw(w, _109).ok) { + const part2 = new rs.TryFromCharError(); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromCharErrorDisplay(part2, f), (f: rs.Formatter) => rs.fmtTryFromCharErrorDebug(part2, f)]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ align: "<", width: 35 }, args10[0]), "|", args10[1], "|", rs.fmtSpec({ alternate: true }, args10[1])])); + const _130: rs.TryFromCharError = new rs.TryFromCharError(); + rs.byteVecPush(out, char_eq$1g188ap(new rs.TryFromCharError(), _130) ? 1 : 0); } } } @@ -537,68 +537,68 @@ export function converts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * The methods as function values, as a pattern, a map, or a test, over text of the * harness's alphabet and the special chars. */ -export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let s: string = text(data); - s = rt.stringExtendChars(s, rt.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); + s = rs.stringExtendChars(s, rs.iterSlice([97, 90, 223, 304, 305, 453, 912, 64259, 329, 7838, 66600, 66560, 931, 39, 34, 92, 0, 9, 13, 10, 127, 769, 57344, 65279, 128512])); const s2: string = s; - const _9: rt.u8 = rt.u8Rem(kind, 3); + const _9: rs.u8 = rs.u8Rem(kind, 3); if (_9 === 0) { - const parts: rt.Vec = rt.iterToVec(rt.strSplit(s2, (a011: rt.char): boolean => { - return rt.charIsAlphabetic(a011); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s2, (a011: rs.char): boolean => { + return rs.charIsAlphabetic(a011); }), "next", 8); - const _21: string = rt.strTrimMatches(s2, (a012: rt.char): boolean => { - return rt.charIsNumeric(a012); + const _21: string = rs.strTrimMatches(s2, (a012: rs.char): boolean => { + return rs.charIsNumeric(a012); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(parts.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtStr(_21, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1]])); - const part = rt.strFind(s2, (a013: rt.char): boolean => { - return rt.charIsUppercase(a013); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(_21, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + const part = rs.strFind(s2, (a013: rs.char): boolean => { + return rs.charIsUppercase(a013); }); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args4[0]])); - const part2 = rt.strRfind(s2, (a014: rt.char): boolean => { - return rt.charIsControl(a014); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args4[0]])); + const part2 = rs.strRfind(s2, (a014: rs.char): boolean => { + return rs.charIsControl(a014); }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args6[0]])); } else if (_9 === 1) { - const lens: rt.usize = rt.iterSum(rt.iterMap(rt.strChars(s2), (a07: rt.char): rt.usize => { - return rt.charLenUtf8(a07); - }), rt.usizeAdd, 0); - const units: rt.usize = rt.iterSum(rt.iterMap(rt.strChars(s2), (a08: rt.char): rt.usize => { - return rt.charLenUtf16(a08); - }), rt.usizeAdd, 0); - const upper: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a09: rt.char): rt.Iter => { - return rt.charToUppercase(a09); + const lens: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a07: rs.char): rs.usize => { + return rs.charLenUtf8(a07); + }), rs.usizeAdd, 0); + const units: rs.usize = rs.iterSum(rs.iterMap(rs.strChars(s2), (a08: rs.char): rs.usize => { + return rs.charLenUtf16(a08); + }), rs.usizeAdd, 0); + const upper: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a09: rs.char): rs.Iter => { + return rs.charToUppercase(a09); }, undefined, true)); - const lower: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a010: rt.char): rt.Iter => { - return rt.charToLowercase(a010); + const lower: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a010: rs.char): rs.Iter => { + return rs.charToLowercase(a010); }, undefined, true)); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(lens, f), (f: rt.Formatter) => rt.usizeDisplay(units, f), (f: rt.Formatter) => rt.fmtPad(f, upper), (f: rt.Formatter) => rt.fmtPad(f, lower)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(lens, f), (f: rs.Formatter) => rs.usizeDisplay(units, f), (f: rs.Formatter) => rs.fmtPad(f, upper), (f: rs.Formatter) => rs.fmtPad(f, lower)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", args8[3]])); } else { - const escaped: string = rt.stringExtendChars("", rt.iterFlatMap(rt.strChars(s2), (a0: rt.char): rt.Iter => { - return rt.charEscapeDefault(a0); + const escaped: string = rs.stringExtendChars("", rs.iterFlatMap(rs.strChars(s2), (a0: rs.char): rs.Iter => { + return rs.charEscapeDefault(a0); }, undefined, true)); - const debug: string = rt.stringFromStrings(rt.iterMap(rt.iterMap(rt.strChars(s2), (a02: rt.char): rt.Iter => { - return rt.charEscapeDebug(a02); - }), (e: rt.Iter): string => { - return rt.fmtToString((f: rt.Formatter) => rt.fmtCharsDisplay(e, f)); + const debug: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.strChars(s2), (a02: rs.char): rs.Iter => { + return rs.charEscapeDebug(a02); + }), (e: rs.Iter): string => { + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharsDisplay(e, f)); })); - const unicode: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterMap(rt.strChars(s2), (a03: rt.char): rt.Iter => { - return rt.charEscapeUnicode(a03); - }), (e2: rt.Iter): rt.usize => { + const unicode: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.strChars(s2), (a03: rs.char): rs.Iter => { + return rs.charEscapeUnicode(a03); + }), (e2: rs.Iter): rs.usize => { return e2.len(); }), "next", 4); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, escaped), (f: rt.Formatter) => rt.fmtPad(f, debug), (f: rt.Formatter) => rt.fmtList(unicode.items, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args10[0], "|", args10[1], "|", args10[2]])); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.iterAll(rt.strChars(s2), (a04: rt.char): boolean => { - return rt.charIsAlphanumeric(a04); - }), rt.iterAny(rt.strChars(s2), (a05: rt.char): boolean => { - return rt.charIsLowercase(a05); - }), rt.iterCount(rt.iterFilter(rt.strChars(s2), (c: rt.char): boolean => { - return rt.charIsAlphanumeric(c); - })) > 3], (a06: boolean): rt.u8 => { + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, escaped), (f: rs.Formatter) => rs.fmtPad(f, debug), (f: rs.Formatter) => rs.fmtList(unicode.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args10[0], "|", args10[1], "|", args10[2]])); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterAll(rs.strChars(s2), (a04: rs.char): boolean => { + return rs.charIsAlphanumeric(a04); + }), rs.iterAny(rs.strChars(s2), (a05: rs.char): boolean => { + return rs.charIsLowercase(a05); + }), rs.iterCount(rs.iterFilter(rs.strChars(s2), (c: rs.char): boolean => { + return rs.charIsAlphanumeric(c); + })) > 3], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); } diff --git a/ts/fixtures/lang/chars/expected/core/char.ts b/ts/fixtures/lang/chars/expected/core/char.ts index 4dab3040f..35df5a98b 100644 --- a/ts/fixtures/lang/chars/expected/core/char.ts +++ b/ts/fixtures/lang/chars/expected/core/char.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function eq$163p0qo(_self: rt.TryFromCharError, _other: rt.TryFromCharError): boolean { +export function eq$1g188ap(_self: rs.TryFromCharError, _other: rs.TryFromCharError): boolean { return true; } diff --git a/ts/fixtures/lang/chars/expected/core/char/convert.ts b/ts/fixtures/lang/chars/expected/core/char/convert.ts index 2e2e4f4e9..9c4aac1a5 100644 --- a/ts/fixtures/lang/chars/expected/core/char/convert.ts +++ b/ts/fixtures/lang/chars/expected/core/char/convert.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$0fgf8wq(_self: rt.CharTryFromError, _other: rt.CharTryFromError): boolean { +export function eq$1efmo6b(_self: rs.CharTryFromError, _other: rs.CharTryFromError): boolean { return true; } diff --git a/ts/fixtures/lang/chars/expected/core/char/decode.ts b/ts/fixtures/lang/chars/expected/core/char/decode.ts index 56dd59596..6606053a8 100644 --- a/ts/fixtures/lang/chars/expected/core/char/decode.ts +++ b/ts/fixtures/lang/chars/expected/core/char/decode.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$1rmi26t(self: rt.DecodeUtf16Error, other: rt.DecodeUtf16Error): boolean { +export function eq$1qya0xd(self: rs.DecodeUtf16Error, other: rs.DecodeUtf16Error): boolean { return self.code === other.code; } diff --git a/ts/fixtures/lang/chars/expected/core/char/methods.ts b/ts/fixtures/lang/chars/expected/core/char/methods.ts index d90ab5b46..bad4a7605 100644 --- a/ts/fixtures/lang/chars/expected/core/char/methods.ts +++ b/ts/fixtures/lang/chars/expected/core/char/methods.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function isDigit$0mzngr5(self: rt.char, radix: rt.u32): boolean { - return toDigit$01k9ewn(self, radix) !== undefined; +export function isDigit$10ivuux(self: rs.char, radix: rs.u32): boolean { + return toDigit$14z95r4(self, radix) !== undefined; } -export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefined { - let value!: rt.u32; +export function toDigit$14z95r4(self: rs.char, radix: rs.u32): rs.u32 | undefined { + let value!: rs.u32; if (radix >= 2) { if (radix <= 36) { b1: { if (self > 57) { if (radix > 10) { - value = rt.u32Add((rt.u32WrappingSub(self as rt.u32, 65 as rt.u32) & 4294967263) >>> 0, 10); + value = rs.u32Add((rs.u32WrappingSub(self as rs.u32, 65 as rs.u32) & 4294967263) >>> 0, 10); break b1; } } - value = rt.u32WrappingSub(self as rt.u32, 48 as rt.u32); + value = rs.u32WrappingSub(self as rs.u32, 48 as rs.u32); } if (!(value < radix)) { return undefined; @@ -25,7 +25,7 @@ export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefine return value; } } - rt.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); + rs.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); } //# sourceMappingURL=methods.ts.map diff --git a/ts/fixtures/lang/chars/expected/core/option.ts b/ts/fixtures/lang/chars/expected/core/option.ts index 0ecc26876..a47c0d580 100644 --- a/ts/fixtures/lang/chars/expected/core/option.ts +++ b/ts/fixtures/lang/chars/expected/core/option.ts @@ -1,36 +1,36 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0k15iai(self: rt.char | undefined, default_: rt.char): rt.char { +export function unwrapOr$04rqm9m(self: rs.char | undefined, default_: rs.char): rs.char { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$0i0pebg(self: rt.u8 | undefined, default_: rt.u32, f: (a0: rt.u8) => rt.u32): rt.u32 { +export function mapOr$1wlsr3s(self: rs.u8 | undefined, default_: rs.u32, f: (a0: rs.u8) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/chars/expected/core/result.ts b/ts/fixtures/lang/chars/expected/core/result.ts index 8c81057f6..0bd0795e1 100644 --- a/ts/fixtures/lang/chars/expected/core/result.ts +++ b/ts/fixtures/lang/chars/expected/core/result.ts @@ -1,33 +1,33 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { eq$1rmi26t as decode_eq$1rmi26t } from "../core/char/decode.ts"; +import * as rs from "../rs.ts"; +import { eq$1qya0xd as decode_eq$1qya0xd } from "../core/char/decode.ts"; -export function eq$16wvkx3(self: rt.Result, other: rt.Result): boolean { +export function eq$1k9tumx(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.char }).value; + return self.value === (other as { ok: true; value: rs.char }).value; } - return decode_eq$1rmi26t(self.error, (other as { ok: false; error: rt.DecodeUtf16Error }).error); + return decode_eq$1qya0xd(self.error, (other as { ok: false; error: rs.DecodeUtf16Error }).error); } -export function map$1v0rxej(self: rt.Result, _: (a0: rt.u8) => rt.u16): rt.Result { +export function map$1q32zo4(self: rs.Result, _: (a0: rs.u8) => rs.u16): rs.Result { if (self.ok) { - return rt.Ok(self.value as rt.u16); + return rs.Ok(self.value as rs.u16); } - return self as rt.Result; + return self as rs.Result; } -export function and$15pno2s(self: rt.Result, res: rt.Result): rt.Result { +export function and$02o4suw(self: rs.Result, res: rs.Result): rs.Result { if (self.ok) { return res; } return self; } -export function unwrapOr$1w5vhiw(self: rt.Result, default_: rt.char): rt.char { +export function unwrapOr$1yj84xe(self: rs.Result, default_: rs.char): rs.char { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/chars/expected/harness.ts b/ts/fixtures/lang/chars/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/chars/expected/harness.ts +++ b/ts/fixtures/lang/chars/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/chars/expected/lib.ts b/ts/fixtures/lang/chars/expected/lib.ts index bc1898f69..43adaa71c 100644 --- a/ts/fixtures/lang/chars/expected/lib.ts +++ b/ts/fixtures/lang/chars/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { chars, unicode, iters, encodes, decodes, converts, values } from "./chars.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["chars::chars", chars as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::unicode", unicode as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::encodes", encodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::converts", converts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["chars::values", values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["chars::chars", chars as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::unicode", unicode as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::iters", iters as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::encodes", encodes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::decodes", decodes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::converts", converts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["chars::values", values as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/chunks/expected/chunks.ts b/ts/fixtures/lang/chunks/expected/chunks.ts index 45d85279a..2f05fbe8e 100644 --- a/ts/fixtures/lang/chunks/expected/chunks.ts +++ b/ts/fixtures/lang/chunks/expected/chunks.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$tuple2_ref_array4_u8_ref_slice_u8 } from "./lib.ts"; import type * as Header from "./chunks.Header.ts"; -import { mapOr$1jgrjsu as option_mapOr$1jgrjsu } from "./core/option.ts"; +import { mapOr$0oapx9n as option_mapOr$0oapx9n } from "./core/option.ts"; export function header(dataData: Uint8Array, dataStart: number, dataLen: number): Header.Header | undefined { if (dataLen >= 2) { @@ -12,7 +12,7 @@ export function header(dataData: Uint8Array, dataStart: number, dataLen: number) return undefined; } -export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 | undefined { if (!(dataLen >= 4)) { return dataLen & 0xff; } @@ -25,49 +25,49 @@ export function take4(dataData: Uint8Array, dataStart: number, dataLen: number): return undefined; } -export function word(chunk: rt.ByteSlice): rt.u32 { +export function word(chunk: rs.ByteSlice): rs.u32 { return ((chunk.data[chunk.start] << 24) | (chunk.data[chunk.start + 1] << 16) | (chunk.data[chunk.start + 2] << 8) | chunk.data[chunk.start + 3]) >>> 0; } -export function pick(a: rt.ByteSlice, b: rt.ByteSlice, first: boolean): rt.ByteSlice { +export function pick(a: rs.ByteSlice, b: rs.ByteSlice, first: boolean): rs.ByteSlice { if (!first) { return b; } return a; } -export function reader(chunk: rt.ByteSlice): (a0: rt.usize) => rt.u8 { - return (i: rt.usize): rt.u8 => { - const _3: rt.usize = rt.usizeRem(i, 2); +export function reader(chunk: rs.ByteSlice): (a0: rs.usize) => rs.u8 { + return (i: rs.usize): rs.u8 => { + const _3: rs.usize = rs.usizeRem(i, 2); if (!(_3 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _3); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _3); } return chunk.data[chunk.start + _3]; }; } -export function bump(chunk: rt.ByteSlice): void { - const _2: rt.u8 = rt.u8WrappingAdd(chunk.data[chunk.start], 1); +export function bump(chunk: rs.ByteSlice): void { + const _2: rs.u8 = rs.u8WrappingAdd(chunk.data[chunk.start], 1); chunk.data[chunk.start] = _2; chunk.data[chunk.start + 1] = chunk.data[chunk.start + 1] ^ 255; } -export function ends(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): [rt.u8, rt.ByteSlice, rt.u8] { - return [chunkData[chunkStart], new rt.ByteSlice(chunkData, chunkStart + 1, 2), chunkData[chunkStart + 3]] as [rt.u8, rt.ByteSlice, rt.u8]; +export function ends(chunkData: Uint8Array, chunkStart: number, _chunkLen: number): [rs.u8, rs.ByteSlice, rs.u8] { + return [chunkData[chunkStart], new rs.ByteSlice(chunkData, chunkStart + 1, 2), chunkData[chunkStart + 3]] as [rs.u8, rs.ByteSlice, rs.u8]; } -export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let chosen2!: rt.ByteSlice; - const _4: rt.u8 = rt.u8Rem(kind, 6); +export function chunks(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let chosen2!: rs.ByteSlice; + const _4: rs.u8 = rs.u8Rem(kind, 6); if (_4 === 0) { const _6: Header.Header | undefined = header(data.data, data.start, data.length); if (_6 !== undefined) { const h: Header.Header = _6; - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(h.tagData, h.tagStart, h.tagLen)); - rt.byteVecPush(out, h.tagData[h.tagStart + 1]); - rt.byteVecPush(out, h.restLen & 0xff); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(h.tagData, h.tagStart, h.tagLen)); + rs.byteVecPush(out, h.tagData[h.tagStart + 1]); + rs.byteVecPush(out, h.restLen & 0xff); } - const err: rt.u8 | undefined = take4(data.data, data.start, data.length); + const err: rs.u8 | undefined = take4(data.data, data.start, data.length); const part3: Uint8Array = out$tuple2_ref_array4_u8_ref_slice_u8.p_0Data; const part4: number = out$tuple2_ref_array4_u8_ref_slice_u8.p_0Start; const part5: number = out$tuple2_ref_array4_u8_ref_slice_u8.p_0Len; @@ -75,135 +75,135 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part7: number = out$tuple2_ref_array4_u8_ref_slice_u8.p_1Start; const part8: number = out$tuple2_ref_array4_u8_ref_slice_u8.p_1Len; if (err === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(word(new rt.ByteSlice(part3, part4, part5))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((part3[part4 + 1] << 8) | part3[part4 + 2]) << 16) >> 16))); - const _42: [rt.u8, rt.ByteSlice, rt.u8] = ends(part3, part4, part5); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part6, part7, part8)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(word(new rs.ByteSlice(part3, part4, part5))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((((part3[part4 + 1] << 8) | part3[part4 + 2]) << 16) >> 16))); + const _42: [rs.u8, rs.ByteSlice, rs.u8] = ends(part3, part4, part5); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_42[0], _42[2], _42[1].data[_42[1].start], _42[1].data[_42[1].start + 1], _42[1].length & 0xff))); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part6, part7, part8)); } else { - rt.byteVecPush(out, err as rt.u8); + rs.byteVecPush(out, err as rs.u8); } } else if (_4 === 1) { - const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4)); + const buf: Uint8Array = rs.bytes(4); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4)); while (true) { - const _64: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_64 === rt.DONE) { + const _64: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_64 === rs.DONE) { break; } - const i: rt.usize = _64[0]; - const _69: rt.u8 = _64[1]; + const i: rs.usize = _64[0]; + const _69: rs.u8 = _64[1]; if (!(i < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + i); } buf[i] = _69; } - const held: rt.ByteSlice = rt.byteSliceFrom(buf); - const before: Uint8Array = rt.byteSliceToArray(held); - const _73: rt.u8 = rt.u8WrappingAdd(held.data[held.start], 7); + const held: rs.ByteSlice = rs.byteSliceFrom(buf); + const before: Uint8Array = rs.byteSliceToArray(held); + const _73: rs.u8 = rs.u8WrappingAdd(held.data[held.start], 7); held.data[held.start] = _73; - const after: Uint8Array = rt.byteSliceToArray(held); + const after: Uint8Array = rs.byteSliceToArray(held); held.data.set(Uint8Array.of(9, 8, 7, 6), held.start); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(before)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(after)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(buf)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(before)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(after)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(buf)); const pair: Uint8Array = Uint8Array.of(data.length & 0xff, 3); - bump(rt.byteSliceFrom(pair)); - bump(rt.byteSliceFrom(pair)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pair)); + bump(rs.byteSliceFrom(pair)); + bump(rs.byteSliceFrom(pair)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pair)); } else if (_4 === 2) { if (data.length >= 2) { - const a: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 2); - const b: rt.ByteSlice = option_mapOr$1jgrjsu((data.length - 2 >= 2 ? [new rt.ByteSlice(data.data, data.start + 2, 2), new rt.ByteSlice(data.data, data.start + 4, data.length - 4)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined, a, (_22: [rt.ByteSlice, rt.ByteSlice]): rt.ByteSlice => { + const a: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 2); + const b: rs.ByteSlice = option_mapOr$0oapx9n((data.length - 2 >= 2 ? [new rs.ByteSlice(data.data, data.start + 2, 2), new rs.ByteSlice(data.data, data.start + 4, data.length - 4)] as [rs.ByteSlice, rs.ByteSlice] : undefined) as [rs.ByteSlice, rs.ByteSlice] | undefined, a, (_22: [rs.ByteSlice, rs.ByteSlice]): rs.ByteSlice => { return _22[0]; }); - const part2 = new rt.ByteSlice(data.data, data.start + 2, data.length - 2); - const read: (a0: rt.usize) => rt.u8 = reader(pick(a, b, rt.usizeRem(data.length, 2) === 0)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(read(0), read(1), read(3)))); - const both: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { + const part2 = new rs.ByteSlice(data.data, data.start + 2, data.length - 2); + const read: (a0: rs.usize) => rs.u8 = reader(pick(a, b, rs.usizeRem(data.length, 2) === 0)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(read(0), read(1), read(3)))); + const both: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } - const _3: rt.u8 = a.data[a.start + i2]; + const _3: rs.u8 = a.data[a.start + i2]; if (!(i2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + i2); } return _3 ^ b.data[b.start + i2]; }; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(both(0), both(1)))); - rt.byteVecExtendFromSlice(out, b); - rt.byteVecPush(out, part2.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(both(0), both(1)))); + rs.byteVecExtendFromSlice(out, b); + rs.byteVecPush(out, part2.length & 0xff); } } else if (_4 === 3) { - const lit: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); - const _143: rt.u8 | undefined = rt.byteSliceFirst(data); + const lit: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(97, 98, 99)); + const _143: rs.u8 | undefined = rs.byteSliceFirst(data); b8: { if (_143 !== undefined) { - if (rt.u8Rem(_143, 2) === 0) { + if (rs.u8Rem(_143, 2) === 0) { chosen2 = lit; break b8; } } - chosen2 = rt.byteSliceFrom(Uint8Array.of(120, 121, 122)); + chosen2 = rs.byteSliceFrom(Uint8Array.of(120, 121, 122)); } - rt.byteVecExtendFromSlice(out, chosen2); - rt.byteVecPush(out, chosen2.data[chosen2.start + 1]); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chosen2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(lit), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); + rs.byteVecExtendFromSlice(out, chosen2); + rs.byteVecPush(out, chosen2.data[chosen2.start + 1]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chosen2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(lit), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); if (data.length >= 3) { - const chunk2: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, 3); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(chunk2), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); + const chunk2: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, 3); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(chunk2), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); } } else if (_4 === 4) { - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { - const b2: rt.u8 = _2; - return Uint8Array.of(b2, rt.u8WrappingAdd(b2, 3)); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { + const b2: rs.u8 = _2; + return Uint8Array.of(b2, rs.u8WrappingAdd(b2, 3)); }), undefined, 2, true); if (pairs.items.length >= 2) { - const first2: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(pairs.items[rt.idx(pairs.items, 0)])); - const _195: rt.ByteSlice = rt.byteSliceFrom(pairs.items[rt.idx(pairs.items, 1)]); + const first2: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 0)])); + const _195: rs.ByteSlice = rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 1)]); _195.data[_195.start] = 170; - const held2: rt.ByteSlice = rt.byteSliceFrom(pairs.items[rt.idx(pairs.items, 0)]); + const held2: rs.ByteSlice = rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 0)]); held2.data[held2.start + 1] = 85; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(first2)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pairs.items[rt.idx(pairs.items, 0)])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(pairs.items[rt.idx(pairs.items, 1)])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(first2)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 0)])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(pairs.items[rs.idx(pairs.items, 1)])); } - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { - const _219: rt.ByteSlice | rt.Done = iter2.next(); - if (_219 === rt.DONE) { + const _219: rs.ByteSlice | rs.Done = iter2.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219.data[_219.start] ^ _219.data[_219.start + 1]); + rs.byteVecPush(out, _219.data[_219.start] ^ _219.data[_219.start + 1]); } - const iter3: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); + const iter3: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { - const _234: rt.ByteSlice | rt.Done = iter3.next(); - if (_234 === rt.DONE) { + const _234: rs.ByteSlice | rs.Done = iter3.next(); + if (_234 === rs.DONE) { break; } _234.data[_234.start] = _234.data[_234.start + 1]; } - const copies: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); - rt.iterExtendBytes(out, rt.iterChain(rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p: rt.ByteSlice): rt.u8 => { + const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): rs.u8 => { return p.data[p.start]; - }), rt.iterMap(rt.iterLend(rt.iterSlice(copies.items), rt.byteSliceFrom), (p2: rt.ByteSlice): rt.u8 => { + }), rs.iterMap(rs.iterLend(rs.iterSlice(copies.items), rs.byteSliceFrom), (p2: rs.ByteSlice): rs.u8 => { return p2.data[p2.start + 1]; })), undefined, true); } else { let restData3: Uint8Array = data.data; let restStart3: number = data.start; let restLen3: number = data.length; - let sum: rt.u32 = 0; + let sum: rs.u32 = 0; while (true) { const _261Data: Uint8Array = restData3; const _261Start: number = restStart3; const _261Len: number = restLen3; if (_261Len >= 3) { - sum = rt.u32WrappingAdd((((sum << 5) >>> 0) | (sum >>> 27)) >>> 0, ((_261Data[_261Start] << 8) | _261Data[_261Start + 2]) as rt.u32); - rt.byteVecPush(out, _261Data[_261Start + 1]); + sum = rs.u32WrappingAdd((((sum << 5) >>> 0) | (sum >>> 27)) >>> 0, ((_261Data[_261Start] << 8) | _261Data[_261Start + 2]) as rs.u32); + rs.byteVecPush(out, _261Data[_261Start + 1]); restData3 = _261Data; restStart3 = _261Start + 3; restLen3 = _261Len - 3; @@ -211,8 +211,8 @@ export function chunks(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData3, restStart3, restLen3)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(sum))); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(restData3, restStart3, restLen3)); } } diff --git a/ts/fixtures/lang/chunks/expected/core/option.ts b/ts/fixtures/lang/chunks/expected/core/option.ts index 3aee7a60b..214db9df7 100644 --- a/ts/fixtures/lang/chunks/expected/core/option.ts +++ b/ts/fixtures/lang/chunks/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function mapOr$1jgrjsu(self: [rt.ByteSlice, rt.ByteSlice] | undefined, default_: rt.ByteSlice, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice { +export function mapOr$0oapx9n(self: [rs.ByteSlice, rs.ByteSlice] | undefined, default_: rs.ByteSlice, f: (a0: [rs.ByteSlice, rs.ByteSlice]) => rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/chunks/expected/harness.ts b/ts/fixtures/lang/chunks/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/chunks/expected/harness.ts +++ b/ts/fixtures/lang/chunks/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/chunks/expected/lib.ts b/ts/fixtures/lang/chunks/expected/lib.ts index ed3dbd896..bd6238c86 100644 --- a/ts/fixtures/lang/chunks/expected/lib.ts +++ b/ts/fixtures/lang/chunks/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { chunks } from "./chunks.ts"; export const out$tuple2_ref_array4_u8_ref_slice_u8: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; @@ -9,8 +9,8 @@ export const out$tuple2_ref_array4_u8_ref_slice_u8: { p_0Data: Uint8Array; p_0St * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["chunks::chunks", chunks as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["chunks::chunks", chunks as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Countdown.ts b/ts/fixtures/lang/clones/expected/clones.Countdown.ts index 545128b8e..e25514bc1 100644 --- a/ts/fixtures/lang/clones/expected/clones.Countdown.ts +++ b/ts/fixtures/lang/clones/expected/clones.Countdown.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Countdown): Countdown { return { _0: self._0 }; @@ -8,16 +8,16 @@ export function clone$Clone(self: Countdown): Countdown { /** The crate's own iterator, which std's adaptors hold by value. */ export interface Countdown { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; return self._0; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=clones.Countdown.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Counted.ts b/ts/fixtures/lang/clones/expected/clones.Counted.ts index 0138cf40f..5ef9555ef 100644 --- a/ts/fixtures/lang/clones/expected/clones.Counted.ts +++ b/ts/fixtures/lang/clones/expected/clones.Counted.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id as it is cloned, as `Logged` does, but drops as nothing. */ export interface Counted { - id: rt.u8; - log: rt.RefCell; + id: rs.u8; + log: rs.RefCell; } export function clone$Clone(self: Counted): Counted { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return { id: rt.u8WrappingAdd(self.id, 1), log: self.log }; + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return { id: rs.u8WrappingAdd(self.id, 1), log: self.log }; } //# sourceMappingURL=clones.Counted.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Fussy.ts b/ts/fixtures/lang/clones/expected/clones.Fussy.ts index 52a586a92..58beb24cf 100644 --- a/ts/fixtures/lang/clones/expected/clones.Fussy.ts +++ b/ts/fixtures/lang/clones/expected/clones.Fussy.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Clones of the bytes' ids, which panic, saying which, on one of them. */ export interface Fussy { - _0: rt.u8; + _0: rs.u8; } export function clone$Clone(self: Fussy): Fussy { - if (!(rt.u8Rem(self._0, 3) === 0)) { + if (!(rs.u8Rem(self._0, 3) === 0)) { return { _0: self._0 }; } const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - rt.panicFmt(["cloning ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + rs.panicFmt(["cloning ", args2[0]]); } //# sourceMappingURL=clones.Fussy.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Kept.ts b/ts/fixtures/lang/clones/expected/clones.Kept.ts index 237450a99..d34634996 100644 --- a/ts/fixtures/lang/clones/expected/clones.Kept.ts +++ b/ts/fixtures/lang/clones/expected/clones.Kept.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Logged from "./clones.Logged.ts"; /** @@ -24,9 +24,9 @@ export function clone$Clone(self: Kept): Kept { } export function cloneFrom$Clone(self: Kept, source: Kept): void { - const _6: rt.RefCell = rt.refCellBorrowMut(self._0.log.value); - rt.iterExtendBytes(_6.value, rt.iterSlice(Uint8Array.of(252, source._0.id)), undefined, true); - rt.refMutRelease(_6); + const _6: rs.RefCell = rs.refCellBorrowMut(self._0.log.value); + rs.iterExtendBytes(_6.value, rs.iterSlice(Uint8Array.of(252, source._0.id)), undefined, true); + rs.refMutRelease(_6); self._0.id = source._0.id; } diff --git a/ts/fixtures/lang/clones/expected/clones.Logged.ts b/ts/fixtures/lang/clones/expected/clones.Logged.ts index 91dc8d4ec..d93652751 100644 --- a/ts/fixtures/lang/clones/expected/clones.Logged.ts +++ b/ts/fixtures/lang/clones/expected/clones.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops, and as it is cloned, the id with the high bit set: its clone's * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -21,21 +21,21 @@ export class Logged { } } -export function id(self: Logged): rt.u8 { +export function id(self: Logged): rs.u8 { return self.id; } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=clones.Logged.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Pair.ts b/ts/fixtures/lang/clones/expected/clones.Pair.ts index cda04b9ed..a87524e42 100644 --- a/ts/fixtures/lang/clones/expected/clones.Pair.ts +++ b/ts/fixtures/lang/clones/expected/clones.Pair.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Logged from "./clones.Logged.ts"; export function clone$Clone(self: Pair): Pair { @@ -18,7 +18,7 @@ export class Pair { } [Symbol.dispose](): void { - rt.dropAll(this.left); + rs.dropAll(this.left); } } diff --git a/ts/fixtures/lang/clones/expected/clones.Plan.ts b/ts/fixtures/lang/clones/expected/clones.Plan.ts index a9c1f193e..d5f756238 100644 --- a/ts/fixtures/lang/clones/expected/clones.Plan.ts +++ b/ts/fixtures/lang/clones/expected/clones.Plan.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** What `turns` reads by: the case's bytes, each step's taken in order. */ export interface Plan { dataData: Uint8Array; dataStart: number; dataLen: number; - at: rt.usize; + at: rs.usize; } -export function next(self: Plan): rt.u8 { - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(new rt.ByteSlice(self.dataData, self.dataStart, self.dataLen), rt.usizeRem(self.at, rt.max(self.dataLen, 1))), 0); - self.at = rt.usizeAdd(self.at, 1); - return b ^ rt.u8WrappingMul(self.at & 0xff, 29); +export function next(self: Plan): rs.u8 { + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(new rs.ByteSlice(self.dataData, self.dataStart, self.dataLen), rs.usizeRem(self.at, rs.max(self.dataLen, 1))), 0); + self.at = rs.usizeAdd(self.at, 1); + return b ^ rs.u8WrappingMul(self.at & 0xff, 29); } //# sourceMappingURL=clones.Plan.ts.map diff --git a/ts/fixtures/lang/clones/expected/clones.Slot.ts b/ts/fixtures/lang/clones/expected/clones.Slot.ts index c0c663c14..449fef4ee 100644 --- a/ts/fixtures/lang/clones/expected/clones.Slot.ts +++ b/ts/fixtures/lang/clones/expected/clones.Slot.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$clones_Slot } from "./lib.ts"; import * as Kept from "./clones.Kept.ts"; @@ -14,7 +14,7 @@ export function clone$Clone(self: Slot): Slot { return { tag: "Empty" } as Slot; } -export function cloneFrom$Clone(self: rt.Place, source: Slot): void { +export function cloneFrom$Clone(self: rs.Place, source: Slot): void { b0: { if (self.v.tag === "Held") { if (source.tag === "Held") { diff --git a/ts/fixtures/lang/clones/expected/clones.ts b/ts/fixtures/lang/clones/expected/clones.ts index 3d74bebaf..49fdb8d7a 100644 --- a/ts/fixtures/lang/clones/expected/clones.ts +++ b/ts/fixtures/lang/clones/expected/clones.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Vec_clones_Logged, drop$array1_clones_Logged, drop$array2_clones_Kept, drop$array2_clones_Logged, drop$clones_Slot, drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged, drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple2_Vec_clones_Logged_Vec_clones_Logged, drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged, drop$tuple2_clones_Logged_String, drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair, drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged, drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String, drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged, drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged, drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged, drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged, drop$tuple3_array2_clones_Logged_String_clones_Logged, drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged, drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged, drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept } from "./lib.ts"; import * as Countdown from "./clones.Countdown.ts"; import * as Counted from "./clones.Counted.ts"; @@ -10,15 +10,15 @@ import * as Logged from "./clones.Logged.ts"; import * as Pair from "./clones.Pair.ts"; import * as Plan from "./clones.Plan.ts"; import * as Slot from "./clones.Slot.ts"; -import { then$0415f7q, then$1uqvqbl } from "./core/bool.ts"; -import { isSomeAnd$09tpccf, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0y3liwu as option_map$0y3liwu, mapOr$0w6m9d0 as option_mapOr$0w6m9d0, mapOr$0bq8trh as option_mapOr$0bq8trh, mapOr$1yabfom as option_mapOr$1yabfom, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, clone$0bhdqd8 as option_clone$0bhdqd8, clone$1jx0028 as option_clone$1jx0028 } from "./core/option.ts"; +import { then$0ba40i0, then$1uqvqbl } from "./core/bool.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1kvcy6m as option_map$1kvcy6m, mapOr$0ngwgbd as option_mapOr$0ngwgbd, mapOr$1ughiwf as option_mapOr$1ughiwf, mapOr$15gmqsv as option_mapOr$15gmqsv, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$188iunt as option_mapOr$188iunt, clone$0bhdqd8 as option_clone$0bhdqd8, clone$1jx0028 as option_clone$1jx0028 } from "./core/option.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } /** @@ -26,47 +26,47 @@ export function flush(log: rt.RefCell, out: rt.ByteVec): void { * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_closure21(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_closure21(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -81,12 +81,12 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -94,9 +94,9 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -106,47 +106,47 @@ export function turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_cl * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure142_clones_iters_closure143(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure142_clones_iters_closure143(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -161,12 +161,12 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -174,9 +174,9 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -186,47 +186,47 @@ export function turns$collections_binary_heap_IntoIter_u8_clones_iters_closure14 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -241,12 +241,12 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -254,9 +254,9 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -266,47 +266,47 @@ export function turns$collections_binary_heap_Iter_u8_clones_iters_closure141_cl * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_clones_iters_closure123(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_clones_iters_closure123(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -321,12 +321,12 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -334,9 +334,9 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -346,47 +346,47 @@ export function turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_c * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -401,12 +401,12 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -414,9 +414,9 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -426,47 +426,47 @@ export function turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_c * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_clones_iters_closure127(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_clones_iters_closure127(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -481,12 +481,12 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -494,9 +494,9 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -506,47 +506,47 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_clones_iters_closure129(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_clones_iters_closure129(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -561,12 +561,12 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -574,9 +574,9 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -586,47 +586,47 @@ export function turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -641,12 +641,12 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -654,9 +654,9 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -666,47 +666,47 @@ export function turns$collections_btree_map_Values_u8_u8_clones_iters_closure125 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Difference_u8_clones_iters_closure135_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Difference_u8_clones_iters_closure135_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -721,12 +721,12 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -734,9 +734,9 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -746,47 +746,47 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Difference_u8_clones_iters_closure136_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Difference_u8_clones_iters_closure136_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -801,12 +801,12 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -814,9 +814,9 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -826,47 +826,47 @@ export function turns$collections_btree_set_Difference_u8_clones_iters_closure13 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Intersection_u8_clones_iters_closure133_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Intersection_u8_clones_iters_closure133_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -881,12 +881,12 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -894,9 +894,9 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -906,47 +906,47 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Intersection_u8_clones_iters_closure134_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Intersection_u8_clones_iters_closure134_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -961,12 +961,12 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -974,9 +974,9 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -986,47 +986,47 @@ export function turns$collections_btree_set_Intersection_u8_clones_iters_closure * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1041,12 +1041,12 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1054,9 +1054,9 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1066,47 +1066,47 @@ export function turns$collections_btree_set_Iter_u8_clones_iters_closure130_clon * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1121,12 +1121,12 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1134,9 +1134,9 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1146,47 +1146,47 @@ export function turns$collections_btree_set_Range_u8_clones_iters_closure131_clo * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_closure137_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_closure137_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1201,12 +1201,12 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1214,9 +1214,9 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1226,47 +1226,47 @@ export function turns$collections_btree_set_SymmetricDifference_u8_clones_iters_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1281,12 +1281,12 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1294,9 +1294,9 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1306,47 +1306,47 @@ export function turns$collections_btree_set_Union_u8_clones_iters_closure132_clo * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(it: rt.Iter, back: (a0: rt.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ v: Logged.clone$Clone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1361,12 +1361,12 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1374,13 +1374,13 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -1388,47 +1388,47 @@ export function turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1443,12 +1443,12 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1456,9 +1456,9 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -1468,47 +1468,47 @@ export function turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1523,12 +1523,12 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1536,9 +1536,9 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1548,47 +1548,47 @@ export function turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clon * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_Logged_clones_owned_closure10_clones_owned_closure11(it: rt.Iter, back: (a0: rt.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_Logged_clones_owned_closure10_clones_owned_closure11(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { v: Logged.clone$Clone }, o: { v: Logged.clone$Clone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ i: { v: Logged.clone$Clone }, o: { v: Logged.clone$Clone } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1603,12 +1603,12 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1616,13 +1616,13 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -1630,47 +1630,47 @@ export function turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_clones_iters_closure85_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_clones_iters_closure85_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1685,12 +1685,12 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -1698,9 +1698,9 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -1710,47 +1710,47 @@ export function turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_iters_closure83(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_iters_closure83(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1765,12 +1765,12 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1778,9 +1778,9 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -1790,47 +1790,47 @@ export function turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_iters_closure81(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_iters_closure81(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1845,12 +1845,12 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1858,9 +1858,9 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -1870,47 +1870,47 @@ export function turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure52(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure52(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = rt.iterEmpty() as rt.Iter; - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = rs.iterEmpty() as rs.Iter; + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -1925,12 +1925,12 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -1938,9 +1938,9 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -1950,47 +1950,47 @@ export function turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure5 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones_iters_closure75(it: rt.Iter<[rt.usize, rt.u8]>, back: (a0: rt.Iter<[rt.usize, rt.u8]>) => [rt.usize, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.usize, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones_iters_closure75(it: rs.Iter<[rs.usize, rs.u8]>, back: (a0: rs.Iter<[rs.usize, rs.u8]>) => [rs.usize, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.usize, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.usize, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.usize, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.usize, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.usize, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.usize, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.usize, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.usize, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.usize, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.usize, rt.u8] | undefined = back(it); + const _32: [rs.usize, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.usize, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.usize, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2005,12 +2005,12 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2018,9 +2018,9 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2030,47 +2030,47 @@ export function turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones_iters_closure72_clones_iters_closure73(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones_iters_closure72_clones_iters_closure73(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2085,12 +2085,12 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2098,9 +2098,9 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2110,47 +2110,47 @@ export function turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure1_clones_closures_closure2_clones_closures_closure3_clones_closures_closure4(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure1_clones_closures_closure2_clones_closures_closure3_clones_closures_closure4(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { f: rt.closureClone }, f: rt.closureClone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ i: { f: rs.closureClone }, f: rs.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2165,12 +2165,12 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2178,13 +2178,13 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -2192,47 +2192,47 @@ export function turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_iters_closure148_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_iters_closure148_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ f: rt.closureClone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ f: rs.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2247,12 +2247,12 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -2260,9 +2260,9 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -2272,47 +2272,47 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_i * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_iters_closure70_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_iters_closure70_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2327,12 +2327,12 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -2340,9 +2340,9 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -2352,47 +2352,47 @@ export function turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { f: rt.closureClone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ i: { f: rs.closureClone } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2407,12 +2407,12 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2420,9 +2420,9 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2432,47 +2432,47 @@ export function turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2487,12 +2487,12 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -2500,9 +2500,9 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -2512,47 +2512,47 @@ export function turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_cl * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ o: { v: rt.itself } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ o: { v: rs.itself } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2567,12 +2567,12 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2580,9 +2580,9 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2592,47 +2592,47 @@ export function turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2647,12 +2647,12 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -2660,9 +2660,9 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -2672,49 +2672,49 @@ export function turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_closure13_clones_owned_closure14(it: rt.Iter, back: (a0: rt.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_closure13_clones_owned_closure14(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { v: (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.map(Logged.clone$Clone)); + const other: rs.Iter = it.clone({ i: { v: (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(Logged.clone$Clone)); } }, o: { v: Logged.clone$Clone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2729,12 +2729,12 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2742,13 +2742,13 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -2756,47 +2756,47 @@ export function turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_c * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure106_clones_iters_closure107(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure106_clones_iters_closure107(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ v: rt.closureClone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ v: rs.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2811,12 +2811,12 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2824,9 +2824,9 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2836,47 +2836,47 @@ export function turns$iter_FromFn_clones_iters_closure105_clones_iters_closure10 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2891,12 +2891,12 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -2904,9 +2904,9 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -2916,47 +2916,47 @@ export function turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iter * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_iters_closure98_clones_iters_closure99(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_iters_closure98_clones_iters_closure99(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -2971,12 +2971,12 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -2984,9 +2984,9 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -2996,47 +2996,47 @@ export function turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_iters_closure101_clones_iters_closure102(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_iters_closure101_clones_iters_closure102(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { v: Countdown.clone$Clone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ i: { v: Countdown.clone$Clone } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3051,12 +3051,12 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3064,9 +3064,9 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3076,47 +3076,47 @@ export function turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_i * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure149_clones_iters_closure150_clones_iters_closure151_clones_iters_closure152(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure149_clones_iters_closure150_clones_iters_closure151_clones_iters_closure152(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ i: { f: rt.closureClone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ i: { f: rs.closureClone } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3131,12 +3131,12 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3144,9 +3144,9 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3156,47 +3156,47 @@ export function turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure14 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iters_closure145_clones_iters_closure146(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iters_closure145_clones_iters_closure146(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ f: rt.closureClone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ f: rs.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3211,12 +3211,12 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3224,9 +3224,9 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3236,47 +3236,47 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iter * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters_closure67_clones_iters_closure68(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters_closure67_clones_iters_closure68(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3291,12 +3291,12 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3304,9 +3304,9 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3316,47 +3316,47 @@ export function turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3371,12 +3371,12 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3384,9 +3384,9 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3396,47 +3396,47 @@ export function turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closure120_clones_iters_closure121(it: rt.Peekable, back: (a0: rt.Peekable) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closure120_clones_iters_closure121(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Peekable = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Peekable = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3451,12 +3451,12 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3464,9 +3464,9 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -3476,47 +3476,47 @@ export function turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closu * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones_iters_closure0(it: rt.Peekable, back: (a0: rt.Peekable) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones_iters_closure0(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Peekable = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Peekable = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3531,12 +3531,12 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -3544,9 +3544,9 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -3556,47 +3556,47 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_iters_closure0(it: rt.Peekable, back: (a0: rt.Peekable) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_iters_closure0(it: rs.Peekable, back: (a0: rs.Peekable) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Peekable = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Peekable = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3611,12 +3611,12 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -3624,9 +3624,9 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -3636,47 +3636,47 @@ export function turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_closure8_clones_owned_closure9(it: rt.Peekable, back: (a0: rt.Peekable) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_closure8_clones_owned_closure9(it: rs.Peekable, back: (a0: rs.Peekable) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Peekable) => Uint8Array = (it2: rt.Peekable): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Peekable) => Uint8Array = (it2: rs.Peekable): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Peekable = it.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Peekable = it.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3691,12 +3691,12 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -3704,13 +3704,13 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -3718,47 +3718,47 @@ export function turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_clos * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3773,12 +3773,12 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -3786,9 +3786,9 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -3798,47 +3798,47 @@ export function turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones_iters_closure94_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones_iters_closure94_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3853,12 +3853,12 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -3866,9 +3866,9 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -3878,47 +3878,47 @@ export function turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -3933,12 +3933,12 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -3946,9 +3946,9 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -3958,47 +3958,47 @@ export function turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iter * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4013,12 +4013,12 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -4026,9 +4026,9 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -4038,47 +4038,47 @@ export function turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clones_owned_closure16_clones_owned_closure17(it: rt.Iter, back: (a0: rt.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clones_owned_closure16_clones_owned_closure17(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ v: Logged.clone$Clone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4093,12 +4093,12 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4106,13 +4106,13 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -4120,47 +4120,47 @@ export function turns$iter_Successors_clones_Logged_clones_owned_closure15_clone * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_closure109_clones_iters_closure110(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_closure109_clones_iters_closure110(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4175,12 +4175,12 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4188,9 +4188,9 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4200,47 +4200,47 @@ export function turns$iter_Successors_u8_clones_iters_closure108_clones_iters_cl * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones_iters_closure96_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones_iters_closure96_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4255,12 +4255,12 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -4268,9 +4268,9 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -4280,47 +4280,47 @@ export function turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4335,12 +4335,12 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -4348,9 +4348,9 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -4360,47 +4360,47 @@ export function turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iter * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closure103_clones_iters_closure104(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closure103_clones_iters_closure104(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone({ i: { v: Countdown.clone$Clone } }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone({ i: { v: Countdown.clone$Clone } }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4415,12 +4415,12 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4428,9 +4428,9 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4440,47 +4440,47 @@ export function turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closu * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_iter_Filter_slice_Iter_u8_clones_iters_closure5_clones_iters_closure113_clones_iters_closure114(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_iter_Filter_slice_Iter_u8_clones_iters_closure5_clones_iters_closure113_clones_iters_closure114(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4495,12 +4495,12 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4508,9 +4508,9 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4520,47 +4520,47 @@ export function turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_i * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_closure117_clones_iters_closure118(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_closure117_clones_iters_closure118(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4575,12 +4575,12 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4588,9 +4588,9 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4600,47 +4600,47 @@ export function turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure111_clones_iters_closure112(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure111_clones_iters_closure112(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4655,12 +4655,12 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4668,9 +4668,9 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4680,47 +4680,47 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure115_clones_iters_closure116(it: rt.Iter<[rt.u8, rt.u8]>, back: (a0: rt.Iter<[rt.u8, rt.u8]>) => [rt.u8, rt.u8] | undefined, plan: Plan.Plan, put: (a0: [rt.u8, rt.u8]) => rt.u8, out: rt.ByteVec): void { +export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure115_clones_iters_closure116(it: rs.Iter<[rs.u8, rs.u8]>, back: (a0: rs.Iter<[rs.u8, rs.u8]>) => [rs.u8, rs.u8] | undefined, plan: Plan.Plan, put: (a0: [rs.u8, rs.u8]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.u8, rt.u8] | undefined; - const _44: (a0: rt.Iter<[rt.u8, rt.u8]>) => Uint8Array = (it2: rt.Iter<[rt.u8, rt.u8]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.u8, rs.u8] | undefined; + const _44: (a0: rs.Iter<[rs.u8, rs.u8]>) => Uint8Array = (it2: rs.Iter<[rs.u8, rs.u8]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.u8, rt.u8] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.u8, rs.u8] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.u8, rt.u8] | undefined = back(it); + const _32: [rs.u8, rs.u8] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.u8, rt.u8]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.u8, rs.u8]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4735,12 +4735,12 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4748,9 +4748,9 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4760,47 +4760,47 @@ export function turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure1 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_closure45(it: rt.RangeFrom, back: (a0: rt.RangeFrom) => rt.char | undefined, plan: Plan.Plan, put: (a0: rt.char) => rt.u8, out: rt.ByteVec): void { +export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_closure45(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.char | undefined, plan: Plan.Plan, put: (a0: rs.char) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.char | undefined; - const _44: (a0: rt.RangeFrom) => Uint8Array = (it2: rt.RangeFrom): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.char | undefined; + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.char | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.char | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.char | undefined = back(it); + const _32: rs.char | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.RangeFrom = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.RangeFrom = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4815,12 +4815,12 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4828,9 +4828,9 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4840,47 +4840,47 @@ export function turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_clo * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_closure43(it: rt.RangeFrom, back: (a0: rt.RangeFrom) => rt.u64 | undefined, plan: Plan.Plan, put: (a0: rt.u64) => rt.u8, out: rt.ByteVec): void { +export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_closure43(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.u64 | undefined, plan: Plan.Plan, put: (a0: rs.u64) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u64 | undefined; - const _44: (a0: rt.RangeFrom) => Uint8Array = (it2: rt.RangeFrom): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u64 | undefined; + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u64 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u64 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u64 | undefined = back(it); + const _32: rs.u64 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.RangeFrom = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.RangeFrom = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4895,12 +4895,12 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4908,9 +4908,9 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -4920,47 +4920,47 @@ export function turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_clos * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closure41(it: rt.RangeFrom, back: (a0: rt.RangeFrom) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closure41(it: rs.RangeFrom, back: (a0: rs.RangeFrom) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.RangeFrom) => Uint8Array = (it2: rt.RangeFrom): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.RangeFrom) => Uint8Array = (it2: rs.RangeFrom): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.RangeFrom = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.RangeFrom = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -4975,12 +4975,12 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -4988,9 +4988,9 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -5000,47 +5000,47 @@ export function turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closu * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_closure37(it: rt.RangeInclusive, back: (a0: rt.RangeInclusive) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_closure37(it: rs.RangeInclusive, back: (a0: rs.RangeInclusive) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.RangeInclusive) => Uint8Array = (it2: rt.RangeInclusive): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.RangeInclusive) => Uint8Array = (it2: rs.RangeInclusive): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.RangeInclusive = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.RangeInclusive = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5055,12 +5055,12 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -5068,9 +5068,9 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -5080,47 +5080,47 @@ export function turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure39(it: rt.Range, back: (a0: rt.Range) => rt.u64 | undefined, plan: Plan.Plan, put: (a0: rt.u64) => rt.u8, out: rt.ByteVec): void { +export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure39(it: rs.Range, back: (a0: rs.Range) => rs.u64 | undefined, plan: Plan.Plan, put: (a0: rs.u64) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u64 | undefined; - const _44: (a0: rt.Range) => Uint8Array = (it2: rt.Range): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u64 | undefined; + const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u64 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u64 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u64 | undefined = back(it); + const _32: rs.u64 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Range = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Range = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5135,12 +5135,12 @@ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure3 if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -5148,9 +5148,9 @@ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure3 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -5160,51 +5160,51 @@ export function turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure3 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35(it: rt.Range, back: (a0: rt.Range) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let _15!: rt.u8; +export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35(it: rs.Range, back: (a0: rs.Range) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let _15!: rs.u8; let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Range) => Uint8Array = (it2: rt.Range): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Range) => Uint8Array = (it2: rs.Range): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { const _15Some: boolean = it.start < it.end; if (_15Some) { _15 = it.start++; } if (_15Some) { - rt.byteVecPush(out, put(_15)); + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Range = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Range = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5232,9 +5232,9 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -5244,47 +5244,47 @@ export function turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5299,12 +5299,12 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5312,9 +5312,9 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5324,47 +5324,47 @@ export function turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_closure48(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_closure48(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5379,12 +5379,12 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -5392,9 +5392,9 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -5404,47 +5404,47 @@ export function turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_clo * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_closure27(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_closure27(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5459,12 +5459,12 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5472,9 +5472,9 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5484,47 +5484,47 @@ export function turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_c * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closure25(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closure25(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5539,12 +5539,12 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5552,9 +5552,9 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5564,47 +5564,47 @@ export function turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closur * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5619,12 +5619,12 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5632,9 +5632,9 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5644,47 +5644,47 @@ export function turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_c * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5699,12 +5699,12 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5712,9 +5712,9 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5724,47 +5724,47 @@ export function turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0 * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_closure31(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_closure31(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5779,12 +5779,12 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5792,9 +5792,9 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5804,47 +5804,47 @@ export function turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_ * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closure29(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closure29(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5859,12 +5859,12 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5872,9 +5872,9 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5884,47 +5884,47 @@ export function turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closu * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closure23(it: rt.Iter, back: (a0: rt.Iter) => rt.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { +export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closure23(it: rs.Iter, back: (a0: rs.Iter) => rs.ByteSlice | undefined, plan: Plan.Plan, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item!: rt.ByteSlice | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item!: rs.ByteSlice | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.ByteSlice | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.ByteSlice | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.ByteSlice | undefined = back(it); + const _32: rs.ByteSlice | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -5939,12 +5939,12 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -5952,9 +5952,9 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -5964,47 +5964,47 @@ export function turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closu * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6019,12 +6019,12 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -6032,9 +6032,9 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -6044,47 +6044,47 @@ export function turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it: rt.Iter, back: (a0: rt.Iter) => rt.char | undefined, plan: Plan.Plan, put: (a0: rt.char) => rt.u8, out: rt.ByteVec): void { +export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it: rs.Iter, back: (a0: rs.Iter) => rs.char | undefined, plan: Plan.Plan, put: (a0: rs.char) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.char | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.char | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.char | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.char | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.char | undefined = back(it); + const _32: rs.char | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6099,12 +6099,12 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -6112,9 +6112,9 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -6124,47 +6124,47 @@ export function turns$str_Chars_clones_iters_closure53_clones_iters_closure54(it * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(it: rt.Iter<[rt.usize, string]>, back: (a0: rt.Iter<[rt.usize, string]>) => [rt.usize, string] | undefined, plan: Plan.Plan, put: (a0: [rt.usize, string]) => rt.u8, out: rt.ByteVec): void { +export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(it: rs.Iter<[rs.usize, string]>, back: (a0: rs.Iter<[rs.usize, string]>) => [rs.usize, string] | undefined, plan: Plan.Plan, put: (a0: [rs.usize, string]) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: [rt.usize, string] | undefined; - const _44: (a0: rt.Iter<[rt.usize, string]>) => Uint8Array = (it2: rt.Iter<[rt.usize, string]>): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: [rs.usize, string] | undefined; + const _44: (a0: rs.Iter<[rs.usize, string]>) => Uint8Array = (it2: rs.Iter<[rs.usize, string]>): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: [rt.usize, string] | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: [rs.usize, string] | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: [rt.usize, string] | undefined = back(it); + const _32: [rs.usize, string] | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter<[rt.usize, string]> = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter<[rs.usize, string]> = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6179,12 +6179,12 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -6192,9 +6192,9 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -6204,47 +6204,47 @@ export function turns$str_MatchIndices_array2_char_clones_iters_closure64_clones * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: string | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: string | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: string | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6259,12 +6259,12 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -6272,9 +6272,9 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -6284,47 +6284,47 @@ export function turns$str_Split_char_clones_iters_closure57_clones_iters_closure * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_clones_iters_closure63(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_clones_iters_closure63(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: string | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: string | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: string | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ f: rt.closureClone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ f: rs.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6339,12 +6339,12 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -6352,9 +6352,9 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -6364,47 +6364,47 @@ export function turns$str_Split_clones_iters_closure61_clones_iters_closure62_cl * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(it: rt.Iter, back: (a0: rt.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rt.u8, out: rt.ByteVec): void { +export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(it: rs.Iter, back: (a0: rs.Iter) => string | undefined, plan: Plan.Plan, put: (a0: string) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item!: string | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: string | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: string | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: string | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone(); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone(); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6419,12 +6419,12 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos if (!_73[1]) { item = back(other); } else { - item = rt.iterToOption(other.next()); + item = rs.iterToOption(other.next()); } } else if (!_73[1]) { item = back(it); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item === undefined) { if (!first) { @@ -6432,9 +6432,9 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item)); + rs.byteVecPush(out, put(item)); } } } @@ -6444,47 +6444,47 @@ export function turns$str_Split_ref_str_clones_iters_closure59_clones_iters_clos * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_owned_closure3(it: rt.Iter, back: (a0: rt.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_owned_closure3(it: rs.Iter, back: (a0: rs.Iter) => Logged.Logged | undefined, plan: Plan.Plan, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let first!: boolean; let item3!: Logged.Logged | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: Logged.Logged | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: Logged.Logged | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { const _32: Logged.Logged | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ v: Logged.clone$Clone }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ v: Logged.clone$Clone }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6499,12 +6499,12 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -6512,13 +6512,13 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } - rt.drop(other); - rt.drop(it); + rs.drop(other); + rs.drop(it); } /** @@ -6526,47 +6526,47 @@ export function turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_ow * then the original and the clone read in turns, each from either end, as `plan` picks, * until both end: each item as `put` makes it, and each end as 0xff and which ended. */ -export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(it: rt.Iter, back: (a0: rt.Iter) => rt.u8 | undefined, plan: Plan.Plan, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { +export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(it: rs.Iter, back: (a0: rs.Iter) => rs.u8 | undefined, plan: Plan.Plan, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { let first!: boolean; - let item3!: rt.u8 | undefined; - const _44: (a0: rt.Iter) => Uint8Array = (it2: rt.Iter): Uint8Array => { - const _5: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - return Uint8Array.of(_5[0] & 0xff, option_mapOr$02k4ito(_5[1], 254, (n: rt.usize): rt.u8 => { + let item3!: rs.u8 | undefined; + const _44: (a0: rs.Iter) => Uint8Array = (it2: rs.Iter): Uint8Array => { + const _5: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + return Uint8Array.of(_5[0] & 0xff, option_mapOr$188iunt(_5[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); }; - const _8: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _8; + const _8: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _8; while (iterStart++ < iterEnd) { - const _15: rt.u8 | rt.Done = it.next(); - if (_15 !== rt.DONE) { - rt.byteVecPush(out, put(_15)); + const _15: rs.u8 | rs.Done = it.next(); + if (_15 !== rs.DONE) { + rs.byteVecPush(out, put(_15)); } } - const _25: rt.u8 = rt.u8Rem(Plan.next(plan), 4); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = _25; + const _25: rs.u8 = rs.u8Rem(Plan.next(plan), 4); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = _25; while (iterStart2++ < iterEnd2) { - const _32: rt.u8 | undefined = back(it); + const _32: rs.u8 | undefined = back(it); if (_32 !== undefined) { - rt.byteVecPush(out, put(_32)); + rs.byteVecPush(out, put(_32)); } } - const other: rt.Iter = it.clone({ v: rt.itself }); - rt.iterExtendBytes(out, rt.iterSlice(_44(it)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(_44(other)), undefined, true); + const other: rs.Iter = it.clone({ v: rs.itself }); + rs.iterExtendBytes(out, rs.iterSlice(_44(it)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_44(other)), undefined, true); let ended: boolean = false; let otherEnded: boolean = false; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 64; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 64; while (iterStart3++ < iterEnd3) { if (ended) { if (otherEnded) { break; } } - const step: rt.u8 = Plan.next(plan); + const step: rs.u8 = Plan.next(plan); b7: { if ((step & 1) === 0) { if (!ended) { @@ -6581,12 +6581,12 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur if (!_73[1]) { item3 = back(other); } else { - item3 = rt.iterToOption(other.next()); + item3 = rs.iterToOption(other.next()); } } else if (!_73[1]) { item3 = back(it); } else { - item3 = rt.iterToOption(it.next()); + item3 = rs.iterToOption(it.next()); } if (item3 === undefined) { if (!first) { @@ -6594,9 +6594,9 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur } else { ended = true; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(255, first ? 1 : 0)), undefined, true); } else { - rt.byteVecPush(out, put(item3)); + rs.byteVecPush(out, put(item3)); } } } @@ -6605,317 +6605,317 @@ export function turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closur * Each of std's iterators and adaptors, partly read and cloned, read in turns with its * clone. */ -export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _263!: [rt.ByteSlice, rt.ByteSlice]; - let _269!: rt.usize; - const plan: Plan.Plan = { dataData: data.data, dataStart: data.start, dataLen: data.length, at: kind as rt.usize }; - const n: rt.usize = option_mapOr$1surhce(rt.byteSliceFirst(data), 1, (_2: rt.u8): rt.u8 => { - return rt.u8Add(rt.u8Rem(_2, 4), 1); - }) as rt.usize; - const _9: rt.u8 = rt.u8Rem(kind, 16); +export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _263!: [rs.ByteSlice, rs.ByteSlice]; + let _269!: rs.usize; + const plan: Plan.Plan = { dataData: data.data, dataStart: data.start, dataLen: data.length, at: kind as rs.usize }; + const n: rs.usize = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 1, (_2: rs.u8): rs.u8 => { + return rs.u8Add(rs.u8Rem(_2, 4), 1); + }) as rs.usize; + const _9: rs.u8 = rs.u8Rem(kind, 16); if (_9 === 0) { - turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0(rt.iterSlice(rt.byteSliceView(data)), (it75: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it75.nextBack()); - }, plan, (x68: rt.u8): rt.u8 => { + turns$slice_Iter_u8_clones_iters_closure17_clones_iters_closure0(rs.iterSlice(rs.byteSliceView(data)), (it75: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it75.nextBack()); + }, plan, (x68: rs.u8): rs.u8 => { return x68; }, out); - turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), (it76: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it76.nextBack()); - }, plan, (x69: rt.u8): rt.u8 => { + turns$vec_IntoIter_u8_clones_iters_closure18_clones_iters_closure19(rs.byteVecIntoIter(rs.byteSliceToByteVec(data)), (it76: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it76.nextBack()); + }, plan, (x69: rs.u8): rs.u8 => { return x69; }, out); const array: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(array))), rt.iterSlice(rt.byteSliceView(data)), [false, false]); + const iter: rs.Iter<[rs.Place, rs.u8]> = rs.iterZip(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(array))), rs.iterSlice(rs.byteSliceView(data)), [false, false]); while (true) { - const _25: [rt.Place, rt.u8] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.Place, rs.u8] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } _25[0].v = _25[1]; } - turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_closure21(rt.iterSlice(array), (it77: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it77.nextBack()); - }, plan, (x70: rt.u8): rt.u8 => { + turns$array_IntoIter_u8_4_clones_iters_closure20_clones_iters_closure21(rs.iterSlice(array), (it77: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it77.nextBack()); + }, plan, (x70: rs.u8): rs.u8 => { return x70; }, out); } else if (_9 === 1) { - turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closure23(rt.byteSliceWindows(data, n), (it69: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it69.nextBack()); - }, plan, (w: rt.ByteSlice): rt.u8 => { - rt.idx(w, 0); - const _322: rt.u8 = w.data[w.start]; - const _811: rt.usize = rt.usizeSub(w.length, 1); - rt.idx(w, _811); + turns$slice_Windows_u8_clones_iters_closure22_clones_iters_closure23(rs.byteSliceWindows(data, n), (it69: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it69.nextBack()); + }, plan, (w: rs.ByteSlice): rs.u8 => { + rs.idx(w, 0); + const _322: rs.u8 = w.data[w.start]; + const _811: rs.usize = rs.usizeSub(w.length, 1); + rs.idx(w, _811); return _322 ^ w.data[w.start + _811]; }, out); - turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closure25(rt.byteSliceChunks(data, n), (it70: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it70.nextBack()); - }, plan, (c7: rt.ByteSlice): rt.u8 => { - rt.idx(c7, 0); + turns$slice_Chunks_u8_clones_iters_closure24_clones_iters_closure25(rs.byteSliceChunks(data, n), (it70: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it70.nextBack()); + }, plan, (c7: rs.ByteSlice): rs.u8 => { + rs.idx(c7, 0); return c7.data[c7.start] ^ (c7.length & 0xff); }, out); - turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_closure27(rt.byteSliceChunksExact(data, n), (it71: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it71.nextBack()); - }, plan, (c8: rt.ByteSlice): rt.u8 => { - rt.idx(c8, 0); + turns$slice_ChunksExact_u8_clones_iters_closure26_clones_iters_closure27(rs.byteSliceChunksExact(data, n), (it71: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it71.nextBack()); + }, plan, (c8: rs.ByteSlice): rs.u8 => { + rs.idx(c8, 0); return c8.data[c8.start]; }, out); - turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closure29(rt.byteSliceRchunks(data, n), (it72: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it72.nextBack()); - }, plan, (c9: rt.ByteSlice): rt.u8 => { - rt.idx(c9, 0); + turns$slice_RChunks_u8_clones_iters_closure28_clones_iters_closure29(rs.byteSliceRchunks(data, n), (it72: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it72.nextBack()); + }, plan, (c9: rs.ByteSlice): rs.u8 => { + rs.idx(c9, 0); return c9.data[c9.start] ^ (c9.length & 0xff); }, out); - turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_closure31(rt.byteSliceRchunksExact(data, n), (it73: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it73.nextBack()); - }, plan, (c10: rt.ByteSlice): rt.u8 => { - rt.idx(c10, 0); + turns$slice_RChunksExact_u8_clones_iters_closure30_clones_iters_closure31(rs.byteSliceRchunksExact(data, n), (it73: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it73.nextBack()); + }, plan, (c10: rs.ByteSlice): rs.u8 => { + rs.idx(c10, 0); return c10.data[c10.start]; }, out); - turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c11: rt.ByteSlice): Uint8Array => { - rt.idx(c11, 0); - const _328: rt.u8 = c11.data[c11.start]; - rt.idx(c11, 1); + turns$slice_Iter_array2_u8_clones_iters_closure32_clones_iters_closure33(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c11: rs.ByteSlice): Uint8Array => { + rs.idx(c11, 0); + const _328: rs.u8 = c11.data[c11.start]; + rs.idx(c11, 1); return Uint8Array.of(_328, c11.data[c11.start + 1]); - }), undefined, 2, true).items), rt.byteSliceFrom), (it74: rt.Iter): rt.ByteSlice | undefined => { - return rt.iterToOption(it74.nextBack()); - }, plan, (a6: rt.ByteSlice): rt.u8 => { + }), undefined, 2, true).items), rs.byteSliceFrom), (it74: rs.Iter): rs.ByteSlice | undefined => { + return rs.iterToOption(it74.nextBack()); + }, plan, (a6: rs.ByteSlice): rs.u8 => { return a6.data[a6.start] ^ a6.data[a6.start + 1]; }, out); } else if (_9 === 2) { - const lo: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8); - const hi: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 9), 16); - turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35(new rt.Range(lo, hi), (it59: rt.Range): rt.u8 | undefined => { - return rt.iterToOption(it59.nextBack()); - }, plan, (x59: rt.u8): rt.u8 => { + const lo: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8); + const hi: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 9), 16); + turns$ops_Range_u8_clones_iters_closure34_clones_iters_closure35(new rs.Range(lo, hi), (it59: rs.Range): rs.u8 | undefined => { + return rs.iterToOption(it59.nextBack()); + }, plan, (x59: rs.u8): rs.u8 => { return x59; }, out); - turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_closure37(new rt.RangeInclusive(lo, hi, rt.u8Step), (it60: rt.RangeInclusive): rt.u8 | undefined => { - return rt.iterToOption(it60.nextBack()); - }, plan, (x60: rt.u8): rt.u8 => { + turns$ops_RangeInclusive_u8_clones_iters_closure36_clones_iters_closure37(new rs.RangeInclusive(lo, hi, rs.u8Step), (it60: rs.RangeInclusive): rs.u8 | undefined => { + return rs.iterToOption(it60.nextBack()); + }, plan, (x60: rs.u8): rs.u8 => { return x60; }, out); - turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure39(new rt.Range(lo as rt.u64, hi as rt.u64, rt.u64Step), (it61: rt.Range): rt.u64 | undefined => { - return rt.iterToOption(it61.nextBack()); - }, plan, (x61: rt.u64): rt.u8 => { - return rt.u64Low(x61) & 0xff; + turns$ops_Range_u64_clones_iters_closure38_clones_iters_closure39(new rs.Range(lo as rs.u64, hi as rs.u64, rs.u64Step), (it61: rs.Range): rs.u64 | undefined => { + return rs.iterToOption(it61.nextBack()); + }, plan, (x61: rs.u64): rs.u8 => { + return rs.u64Low(x61) & 0xff; }, out); - turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closure41(new rt.RangeFrom(lo, rt.u8Step), (it62: rt.RangeFrom): rt.u8 | undefined => { - return rt.iterToOption(it62.next()); - }, plan, (x62: rt.u8): rt.u8 => { + turns$ops_RangeFrom_u8_clones_iters_closure40_clones_iters_closure41(new rs.RangeFrom(lo, rs.u8Step), (it62: rs.RangeFrom): rs.u8 | undefined => { + return rs.iterToOption(it62.next()); + }, plan, (x62: rs.u8): rs.u8 => { return x62; }, out); - turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_closure43(new rt.RangeFrom(rt.u64Shl(lo as rt.u64, 53), rt.u64Step), (it63: rt.RangeFrom): rt.u64 | undefined => { - return rt.iterToOption(it63.next()); - }, plan, (x63: rt.u64): rt.u8 => { - return (rt.u64Low(rt.u64Shr(x63, 50)) & 0xff) ^ (rt.u64Low(x63) & 0xff); + turns$ops_RangeFrom_u64_clones_iters_closure42_clones_iters_closure43(new rs.RangeFrom(rs.u64Shl(lo as rs.u64, 53), rs.u64Step), (it63: rs.RangeFrom): rs.u64 | undefined => { + return rs.iterToOption(it63.next()); + }, plan, (x63: rs.u64): rs.u8 => { + return (rs.u64Low(rs.u64Shr(x63, 50)) & 0xff) ^ (rs.u64Low(x63) & 0xff); }, out); - turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_closure45(new rt.RangeFrom(rt.u8Add(97, lo) as rt.char, rt.charStep), (it64: rt.RangeFrom): rt.char | undefined => { - return rt.iterToOption(it64.next()); - }, plan, (c6: rt.char): rt.u8 => { + turns$ops_RangeFrom_char_clones_iters_closure44_clones_iters_closure45(new rs.RangeFrom(rs.u8Add(97, lo) as rs.char, rs.charStep), (it64: rs.RangeFrom): rs.char | undefined => { + return rs.iterToOption(it64.next()); + }, plan, (c6: rs.char): rs.u8 => { return c6 & 0xff; }, out); - turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters_closure0(rt.iterOption(rt.byteSliceFirst(data)), (it65: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it65.nextBack()); - }, plan, (x64: rt.u8): rt.u8 => { + turns$option_IntoIter_ref_u8_clones_iters_closure46_clones_iters_closure0(rs.iterOption(rs.byteSliceFirst(data)), (it65: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it65.nextBack()); + }, plan, (x64: rs.u8): rs.u8 => { return x64; }, out); - turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_closure48(rt.iterOption(rt.byteSliceFirst(data)), (it66: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it66.nextBack()); - }, plan, (x65: rt.u8): rt.u8 => { + turns$option_IntoIter_u8_clones_iters_closure47_clones_iters_closure48(rs.iterOption(rs.byteSliceFirst(data)), (it66: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it66.nextBack()); + }, plan, (x65: rs.u8): rs.u8 => { return x65; }, out); - turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50(rt.iterOnce(n & 0xff), (it67: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it67.nextBack()); - }, plan, (x66: rt.u8): rt.u8 => { + turns$iter_Once_u8_clones_iters_closure49_clones_iters_closure50(rs.iterOnce(n & 0xff), (it67: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it67.nextBack()); + }, plan, (x66: rs.u8): rs.u8 => { return x66; }, out); - rt.iterEmpty(); - turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure52(rt.iterEmpty() as rt.Iter, (it68: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it68.nextBack()); - }, plan, (x67: rt.u8): rt.u8 => { + rs.iterEmpty(); + turns$iter_Empty_u8_clones_iters_closure51_clones_iters_closure52(rs.iterEmpty() as rs.Iter, (it68: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it68.nextBack()); + }, plan, (x67: rs.u8): rs.u8 => { return x67; }, out); } else if (_9 === 3) { - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_273: rt.u8): rt.char => { - const _518: rt.usize = rt.u8Rem(_273, 4) as rt.usize; + const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_273: rs.u8): rs.char => { + const _518: rs.usize = rs.u8Rem(_273, 4) as rs.usize; if (!(_518 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _518); } return [97, 233, 20013, 129408][_518]; })); - turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rt.strChars(text), (it53: rt.Iter): rt.char | undefined => { - return rt.iterToOption(it53.nextBack()); - }, plan, (c4: rt.char): rt.u8 => { - return rt.u32Rem(c4 as rt.u32, 251) & 0xff; + turns$str_Chars_clones_iters_closure53_clones_iters_closure54(rs.strChars(text), (it53: rs.Iter): rs.char | undefined => { + return rs.iterToOption(it53.nextBack()); + }, plan, (c4: rs.char): rs.u8 => { + return rs.u32Rem(c4 as rs.u32, 251) & 0xff; }, out); - turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rt.strBytes(text), (it54: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it54.nextBack()); - }, plan, (b15: rt.u8): rt.u8 => { + turns$str_Bytes_clones_iters_closure55_clones_iters_closure56(rs.strBytes(text), (it54: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it54.nextBack()); + }, plan, (b15: rs.u8): rs.u8 => { return b15; }, out); - turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rt.strSplit(text, "é"), (it55: rt.Iter): string | undefined => { - return rt.iterToOption(it55.nextBack()); - }, plan, (s: string): rt.u8 => { - return rt.stringLen(s) & 0xff; + turns$str_Split_char_clones_iters_closure57_clones_iters_closure58(rs.strSplit(text, "é"), (it55: rs.Iter): string | undefined => { + return rs.iterToOption(it55.nextBack()); + }, plan, (s: string): rs.u8 => { + return rs.stringLen(s) & 0xff; }, out); - turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rt.strSplit(text, "中"), (it56: rt.Iter): string | undefined => { - return rt.iterToOption(it56.next()); - }, plan, (s2: string): rt.u8 => { - return rt.stringLen(s2) & 0xff; + turns$str_Split_ref_str_clones_iters_closure59_clones_iters_closure60(rs.strSplit(text, "中"), (it56: rs.Iter): string | undefined => { + return rs.iterToOption(it56.next()); + }, plan, (s2: string): rs.u8 => { + return rs.stringLen(s2) & 0xff; }, out); const _135: string = text; - const make6 = (captured7: rt.u8): (a0: rt.char) => boolean => { - return rt.cloning((c5: rt.char): boolean => { - captured7 = rt.u8WrappingAdd(captured7, 1); + const make6 = (captured7: rs.u8): (a0: rs.char) => boolean => { + return rs.cloning((c5: rs.char): boolean => { + captured7 = rs.u8WrappingAdd(captured7, 1); if (!(c5 === 97)) { - return rt.u8Rem(captured7, 3) === 0; + return rs.u8Rem(captured7, 3) === 0; } return true; }, () => make6(captured7)); }; - turns$str_Split_clones_iters_closure61_clones_iters_closure62_clones_iters_closure63(rt.strSplit(_135, make6(0)), (it57: rt.Iter): string | undefined => { - return rt.iterToOption(it57.nextBack()); - }, plan, (s3: string): rt.u8 => { - return rt.stringLen(s3) & 0xff; + turns$str_Split_clones_iters_closure61_clones_iters_closure62_clones_iters_closure63(rs.strSplit(_135, make6(0)), (it57: rs.Iter): string | undefined => { + return rs.iterToOption(it57.nextBack()); + }, plan, (s3: string): rs.u8 => { + return rs.stringLen(s3) & 0xff; }, out); - turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rt.strMatchIndices(text, rt.patternChars([97, 129408])), (it58: rt.Iter<[rt.usize, string]>): [rt.usize, string] | undefined => { - return rt.iterToOption(it58.nextBack()); - }, plan, (_283: [rt.usize, string]): rt.u8 => { - return (_283[0] & 0xff) ^ (rt.stringLen(_283[1]) & 0xff); + turns$str_MatchIndices_array2_char_clones_iters_closure64_clones_iters_closure65(rs.strMatchIndices(text, rs.patternChars([97, 129408])), (it58: rs.Iter<[rs.usize, string]>): [rs.usize, string] | undefined => { + return rs.iterToOption(it58.nextBack()); + }, plan, (_283: [rs.usize, string]): rs.u8 => { + return (_283[0] & 0xff) ^ (rs.stringLen(_283[1]) & 0xff); }, out); } else if (_9 === 4) { - turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters_closure67_clones_iters_closure68(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (x49: rt.u8): rt.u8 => { + turns$iter_Map_slice_Iter_u8_clones_iters_closure66_clones_iters_closure67_clones_iters_closure68(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (x49: rs.u8): rs.u8 => { return x49 ^ 1; - }), (it45: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it45.nextBack()); - }, plan, (x50: rt.u8): rt.u8 => { + }), (it45: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it45.nextBack()); + }, plan, (x50: rs.u8): rs.u8 => { return x50; }, out); - turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_iters_closure70_clones_iters_closure0(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_270: rt.u8): boolean => { - return rt.u8Rem(_270, 3) !== 0; - }), (it46: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it46.nextBack()); - }, plan, (x52: rt.u8): rt.u8 => { + turns$iter_Filter_slice_Iter_u8_clones_iters_closure69_clones_iters_closure70_clones_iters_closure0(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_270: rs.u8): boolean => { + return rs.u8Rem(_270, 3) !== 0; + }), (it46: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it46.nextBack()); + }, plan, (x52: rs.u8): rs.u8 => { return x52; }, out); - turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones_iters_closure72_clones_iters_closure73(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_271: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_271, 9); - }), (it47: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it47.nextBack()); - }, plan, (x54: rt.u8): rt.u8 => { + turns$iter_FilterMap_slice_Iter_u8_clones_iters_closure71_clones_iters_closure72_clones_iters_closure73(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_271: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(_271, 9); + }), (it47: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it47.nextBack()); + }, plan, (x54: rs.u8): rs.u8 => { return x54; }, out); - turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones_iters_closure75(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (it48: rt.Iter<[rt.usize, rt.u8]>): [rt.usize, rt.u8] | undefined => { - return rt.iterToOption(it48.nextBack()); - }, plan, (_272: [rt.usize, rt.u8]): rt.u8 => { + turns$iter_Enumerate_slice_Iter_u8_clones_iters_closure74_clones_iters_closure75(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (it48: rs.Iter<[rs.usize, rs.u8]>): [rs.usize, rs.u8] | undefined => { + return rs.iterToOption(it48.nextBack()); + }, plan, (_272: [rs.usize, rs.u8]): rs.u8 => { return (_272[0] & 0xff) ^ _272[1]; }, out); - turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters_closure0(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (it49: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it49.nextBack()); - }, plan, (x55: rt.u8): rt.u8 => { + turns$iter_Rev_slice_Iter_u8_clones_iters_closure76_clones_iters_closure0(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (it49: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it49.nextBack()); + }, plan, (x55: rs.u8): rs.u8 => { return x55; }, out); - turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iters_closure0(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), n), (it50: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it50.nextBack()); - }, plan, (x56: rt.u8): rt.u8 => { + turns$iter_Skip_slice_Iter_u8_clones_iters_closure77_clones_iters_closure0(rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), n), (it50: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it50.nextBack()); + }, plan, (x56: rs.u8): rs.u8 => { return x56; }, out); - turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iters_closure0(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), rt.usizeMul(n, 2)), (it51: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it51.nextBack()); - }, plan, (x57: rt.u8): rt.u8 => { + turns$iter_Take_slice_Iter_u8_clones_iters_closure78_clones_iters_closure0(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), rs.usizeMul(n, 2)), (it51: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it51.nextBack()); + }, plan, (x57: rs.u8): rs.u8 => { return x57; }, out); - turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_iters_closure0(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(data)), n), (it52: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it52.nextBack()); - }, plan, (x58: rt.u8): rt.u8 => { + turns$iter_StepBy_slice_Iter_u8_clones_iters_closure79_clones_iters_closure0(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(data)), n), (it52: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it52.nextBack()); + }, plan, (x58: rs.u8): rs.u8 => { return x58; }, out); } else if (_9 === 5) { - turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_iters_closure81(rt.iterSlice(rt.byteSliceView(data)), (it37: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it37.nextBack()); - }, plan, (x41: rt.u8): rt.u8 => { + turns$iter_Copied_slice_Iter_u8_clones_iters_closure80_clones_iters_closure81(rs.iterSlice(rs.byteSliceView(data)), (it37: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it37.nextBack()); + }, plan, (x41: rs.u8): rs.u8 => { return x41; }, out); - turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_iters_closure83(rt.iterCloned(rt.iterSlice(rt.byteSliceView(data))), (it38: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it38.nextBack()); - }, plan, (x42: rt.u8): rt.u8 => { + turns$iter_Cloned_slice_Iter_u8_clones_iters_closure82_clones_iters_closure83(rs.iterCloned(rs.iterSlice(rs.byteSliceView(data))), (it38: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it38.nextBack()); + }, plan, (x42: rs.u8): rs.u8 => { return x42; }, out); - turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(rt.iterFuse(rt.iterSlice(rt.byteSliceView(data)), true), (it39: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it39.nextBack()); - }, plan, (x43: rt.u8): rt.u8 => { + turns$iter_Fuse_slice_Iter_u8_clones_iters_closure84_clones_iters_closure0(rs.iterFuse(rs.iterSlice(rs.byteSliceView(data)), true), (it39: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it39.nextBack()); + }, plan, (x43: rs.u8): rs.u8 => { return x43; }, out); - turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_clones_iters_closure85_clones_iters_closure0(rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterSkip(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), 1)), (it40: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it40.nextBack()); - }, plan, (x44: rt.u8): rt.u8 => { + turns$iter_Chain_slice_Iter_u8_iter_Skip_iter_Rev_slice_Iter_u8_clones_iters_closure85_clones_iters_closure0(rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterSkip(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), 1)), (it40: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it40.nextBack()); + }, plan, (x44: rs.u8): rs.u8 => { return x44; }, out); - turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_iters_closure0(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))), (it41: rt.Peekable): rt.u8 | undefined => { - return rt.iterToOption(it41.nextBack()); - }, plan, (x45: rt.u8): rt.u8 => { + turns$iter_Peekable_slice_Iter_u8_clones_iters_closure86_clones_iters_closure0(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))), (it41: rs.Peekable): rs.u8 | undefined => { + return rs.iterToOption(it41.nextBack()); + }, plan, (x45: rs.u8): rs.u8 => { return x45; }, out); - turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(rt.iterFlatMap(rt.byteSliceChunks(data, n), (c2: rt.ByteSlice): rt.Iter => { - return rt.iterSlice(rt.byteSliceView(c2)); - }, undefined, true), (it42: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it42.nextBack()); - }, plan, (x46: rt.u8): rt.u8 => { + turns$iter_FlatMap_slice_Chunks_u8_slice_Iter_u8_clones_iters_closure87_clones_iters_closure88_clones_iters_closure0(rs.iterFlatMap(rs.byteSliceChunks(data, n), (c2: rs.ByteSlice): rs.Iter => { + return rs.iterSlice(rs.byteSliceView(c2)); + }, undefined, true), (it42: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it42.nextBack()); + }, plan, (x46: rs.u8): rs.u8 => { return x46; }, out); - turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rt.iterFlatten(rt.iterMap(rt.byteSliceChunks(data, n), (c3: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(c3); - }), (value: rt.ByteVec) => rt.byteVecIntoIter(value), true), (it43: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it43.nextBack()); - }, plan, (x47: rt.u8): rt.u8 => { + turns$iter_Flatten_iter_Map_slice_Chunks_u8_clones_iters_closure89_clones_iters_closure90_clones_iters_closure91(rs.iterFlatten(rs.iterMap(rs.byteSliceChunks(data, n), (c3: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(c3); + }), (value: rs.ByteVec) => rs.byteVecIntoIter(value), true), (it43: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it43.nextBack()); + }, plan, (x47: rs.u8): rs.u8 => { return x47; }, out); - turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(rt.iterFlatten(rt.byteSliceChunks(data, n), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), (it44: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it44.nextBack()); - }, plan, (x48: rt.u8): rt.u8 => { + turns$iter_Flatten_slice_Chunks_u8_clones_iters_closure92_clones_iters_closure0(rs.iterFlatten(rs.byteSliceChunks(data, n), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), (it44: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it44.nextBack()); + }, plan, (x48: rs.u8): rs.u8 => { return x48; }, out); } else if (_9 === 6) { - turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones_iters_closure94_clones_iters_closure0(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_255: rt.u8): boolean => { - return rt.u8Rem(_255, 4) !== 0; - }), (it30: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it30.next()); - }, plan, (x31: rt.u8): rt.u8 => { + turns$iter_SkipWhile_slice_Iter_u8_clones_iters_closure93_clones_iters_closure94_clones_iters_closure0(rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(data)), (_255: rs.u8): boolean => { + return rs.u8Rem(_255, 4) !== 0; + }), (it30: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it30.next()); + }, plan, (x31: rs.u8): rs.u8 => { return x31; }, out); - turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones_iters_closure96_clones_iters_closure0(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_258: rt.u8): boolean => { - return rt.u8Rem(_258, 5) !== 0; - }), (it31: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it31.next()); - }, plan, (x33: rt.u8): rt.u8 => { + turns$iter_TakeWhile_slice_Iter_u8_clones_iters_closure95_clones_iters_closure96_clones_iters_closure0(rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(data)), (_258: rs.u8): boolean => { + return rs.u8Rem(_258, 5) !== 0; + }), (it31: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it31.next()); + }, plan, (x33: rs.u8): rs.u8 => { return x33; }, out); - turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_iters_closure98_clones_iters_closure99(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_259: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_259, 3); - }), (it32: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it32.next()); - }, plan, (x35: rt.u8): rt.u8 => { + turns$iter_MapWhile_slice_Iter_u8_clones_iters_closure97_clones_iters_closure98_clones_iters_closure99(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_259: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(_259, 3); + }), (it32: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it32.next()); + }, plan, (x35: rs.u8): rs.u8 => { return x35; }, out); - turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_iters_closure101_clones_iters_closure102(rt.iterMap(rt.iterFrom({ _0: rt.u8Mul(n & 0xff, 3) }, Countdown.next$iter_Iterator), (x36: rt.u8): rt.u8 => { + turns$iter_Map_clones_Countdown_clones_iters_closure100_clones_iters_closure101_clones_iters_closure102(rs.iterMap(rs.iterFrom({ _0: rs.u8Mul(n & 0xff, 3) }, Countdown.next$iter_Iterator), (x36: rs.u8): rs.u8 => { return x36 ^ 7; - }), (it33: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it33.next()); - }, plan, (x37: rt.u8): rt.u8 => { + }), (it33: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it33.next()); + }, plan, (x37: rs.u8): rs.u8 => { return x37; }, out); - const _236: Countdown.Countdown = { _0: rt.u8Mul(n & 0xff, 3) }; - const _240: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closure103_clones_iters_closure104(rt.iterZip(rt.iterFrom(_236, Countdown.next$iter_Iterator), _240), (it34: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it34.next()); - }, plan, (_261: [rt.u8, rt.u8]): rt.u8 => { + const _236: Countdown.Countdown = { _0: rs.u8Mul(n & 0xff, 3) }; + const _240: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + turns$iter_Zip_clones_Countdown_slice_Iter_u8_clones_iters_closure103_clones_iters_closure104(rs.iterZip(rs.iterFrom(_236, Countdown.next$iter_Iterator), _240), (it34: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it34.next()); + }, plan, (_261: [rs.u8, rs.u8]): rs.u8 => { return _261[0] ^ _261[1]; }, out); - const left: rt.usize = rt.usizeMul(n, 3); - const make5 = (captured6: rt.usize): () => rt.u8 | undefined => { - return rt.cloning((): rt.u8 | undefined => { - const _262: rt.usize | undefined = rt.usizeCheckedSub(captured6, 1); + const left: rs.usize = rs.usizeMul(n, 3); + const make5 = (captured6: rs.usize): () => rs.u8 | undefined => { + return rs.cloning((): rs.u8 | undefined => { + const _262: rs.usize | undefined = rs.usizeCheckedSub(captured6, 1); if (_262 !== undefined) { captured6 = _262; return captured6 & 0xff; @@ -6923,260 +6923,260 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return undefined; }, () => make5(captured6)); }; - turns$iter_FromFn_clones_iters_closure105_clones_iters_closure106_clones_iters_closure107(rt.iterFromFn(make5(left)), (it35: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it35.next()); - }, plan, (x38: rt.u8): rt.u8 => { + turns$iter_FromFn_clones_iters_closure105_clones_iters_closure106_clones_iters_closure107(rs.iterFromFn(make5(left)), (it35: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it35.next()); + }, plan, (x38: rs.u8): rs.u8 => { return x38; }, out); - turns$iter_Successors_u8_clones_iters_closure108_clones_iters_closure109_clones_iters_closure110(rt.iterSuccessors(rt.u8Mul(n & 0xff, 40), (_268: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_268, 17); - }), (it36: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it36.next()); - }, plan, (x40: rt.u8): rt.u8 => { + turns$iter_Successors_u8_clones_iters_closure108_clones_iters_closure109_clones_iters_closure110(rs.iterSuccessors(rs.u8Mul(n & 0xff, 40), (_268: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(_268, 17); + }), (it36: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it36.next()); + }, plan, (x40: rs.u8): rs.u8 => { return x40; }, out); } else if (_9 === 7) { - const mid: number = rt.usizeDiv(data.length, 2); + const mid: number = rs.usizeDiv(data.length, 2); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } if (!((kind & 32) === 0)) { - _263 = [new rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; + _263 = [new rs.ByteSlice(data.data, data.start + mid, data.length - mid), new rs.ByteSlice(data.data, data.start, mid)] as [rs.ByteSlice, rs.ByteSlice]; } else { - _263 = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; + _263 = [new rs.ByteSlice(data.data, data.start, mid), new rs.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rs.ByteSlice, rs.ByteSlice]; } - const a2: rt.ByteSlice = _263[0]; - const b3: rt.ByteSlice = _263[1]; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 2; + const a2: rs.ByteSlice = _263[0]; + const b3: rs.ByteSlice = _263[1]; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 2; while ((_269 = iterStart++) < iterEnd) { - const skip: rt.usize = _269; - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), [false, false]); - const _278: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = _278; + const skip: rs.usize = _269; + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(a2)), rs.iterSlice(rs.byteSliceView(b3)), [false, false]); + const _278: rs.usize = rs.usizeAdd(rs.min(a2.length, b3.length), skip); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = _278; while (iterStart2++ < iterEnd2) { zip.next(); } - turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure111_clones_iters_closure112(zip, (it26: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it26.nextBack()); - }, plan, (_234: [rt.u8, rt.u8]): rt.u8 => { + turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure111_clones_iters_closure112(zip, (it26: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it26.nextBack()); + }, plan, (_234: [rs.u8, rs.u8]): rs.u8 => { return _234[0] ^ _234[1]; }, out); - const zip2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterSlice(rt.byteSliceView(a2)), (_241: rt.u8): boolean => { + const zip2: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterSlice(rs.byteSliceView(a2)), (_241: rs.u8): boolean => { return true; - }), rt.iterFilter(rt.iterSlice(rt.byteSliceView(b3)), (_242: rt.u8): boolean => { + }), rs.iterFilter(rs.iterSlice(rs.byteSliceView(b3)), (_242: rs.u8): boolean => { return true; })); - const _299: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), skip); - let iterStart3: rt.usize = 0; - const iterEnd3: rt.usize = _299; + const _299: rs.usize = rs.usizeAdd(rs.min(a2.length, b3.length), skip); + let iterStart3: rs.usize = 0; + const iterEnd3: rs.usize = _299; while (iterStart3++ < iterEnd3) { zip2.next(); } - turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_iter_Filter_slice_Iter_u8_clones_iters_closure5_clones_iters_closure113_clones_iters_closure114(zip2, (it27: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it27.next()); - }, plan, (_244: [rt.u8, rt.u8]): rt.u8 => { + turns$iter_Zip_iter_Filter_slice_Iter_u8_clones_iters_closure4_iter_Filter_slice_Iter_u8_clones_iters_closure5_clones_iters_closure113_clones_iters_closure114(zip2, (it27: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it27.next()); + }, plan, (_244: [rs.u8, rs.u8]): rs.u8 => { return _244[0] ^ _244[1]; }, out); } - turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure115_clones_iters_closure116(rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), rt.iterSlice(rt.byteSliceView(b3)), [false, false]), (it28: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it28.nextBack()); - }, plan, (_247: [rt.u8, rt.u8]): rt.u8 => { + turns$iter_Zip_slice_Iter_u8_slice_Iter_u8_clones_iters_closure115_clones_iters_closure116(rs.iterZip(rs.iterSlice(rs.byteSliceView(a2)), rs.iterSlice(rs.byteSliceView(b3)), [false, false]), (it28: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it28.nextBack()); + }, plan, (_247: [rs.u8, rs.u8]): rs.u8 => { return _247[0] ^ _247[1]; }, out); - turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_closure117_clones_iters_closure118(rt.iterZip(rt.iterSlice(rt.byteSliceView(a2)), new rt.RangeInclusive(1, 7, rt.u8Step), "len"), (it29: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it29.next()); - }, plan, (_248: [rt.u8, rt.u8]): rt.u8 => { + turns$iter_Zip_slice_Iter_u8_ops_RangeInclusive_u8_clones_iters_closure117_clones_iters_closure118(rs.iterZip(rs.iterSlice(rs.byteSliceView(a2)), new rs.RangeInclusive(1, 7, rs.u8Step), "len"), (it29: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it29.next()); + }, plan, (_248: [rs.u8, rs.u8]): rs.u8 => { return _248[0] ^ _248[1]; }, out); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const zip3: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_254: rt.u8): rt.u8 => { - const x28: rt.u8 = _254; - const _610: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_610.value, x28); - rt.refMutRelease(_610); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const zip3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_254: rs.u8): rs.u8 => { + const x28: rs.u8 = _254; + const _610: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_610.value, x28); + rs.refMutRelease(_610); return x28; }); - const _330: rt.Iter = zip3; - const _332: rt.Iter = rt.iterSlice(rt.byteSliceView(b3)); - const zip22: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterBorrow(_330), _332, "len"); - const _335: rt.usize = rt.usizeAdd(rt.min(a2.length, b3.length), 1); - let iterStart4: rt.usize = 0; - const iterEnd4: rt.usize = _335; + const _330: rs.Iter = zip3; + const _332: rs.Iter = rs.iterSlice(rs.byteSliceView(b3)); + const zip22: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterBorrow(_330), _332, "len"); + const _335: rs.usize = rs.usizeAdd(rs.min(a2.length, b3.length), 1); + let iterStart4: rs.usize = 0; + const iterEnd4: rs.usize = _335; while (iterStart4++ < iterEnd4) { zip22.next(); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(zip3.clone(), zip3), (x29: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(zip3.clone(), zip3), (x29: rs.u8): rs.u8 => { return x29 ^ 64; }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(log, new rs.ByteVec())), undefined, true); } else if (_9 === 8) { - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); - let iterStart5: rt.usize = 0; - const iterEnd5: rt.usize = n; + const it: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + let iterStart5: rs.usize = 0; + const iterEnd5: rs.usize = n; while (iterStart5++ < iterEnd5) { - rt.byteVecPush(out, option_mapOr$1surhce(rt.peekablePeek(it), 238, (_227: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.peekablePeek(it), 238, (_227: rs.u8): rs.u8 => { return _227; })); it.next(); } - rt.byteVecPush(out, option_mapOr$1surhce(rt.peekablePeek(it), 238, (_233: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.peekablePeek(it), 238, (_233: rs.u8): rs.u8 => { return _233; })); - turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones_iters_closure0(it, (it24: rt.Peekable): rt.u8 | undefined => { - return rt.iterToOption(it24.nextBack()); - }, plan, (x26: rt.u8): rt.u8 => { + turns$iter_Peekable_slice_Iter_u8_clones_iters_closure119_clones_iters_closure0(it, (it24: rs.Peekable): rs.u8 | undefined => { + return rs.iterToOption(it24.nextBack()); + }, plan, (x26: rs.u8): rs.u8 => { return x26; }, out); - const it2: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); - while (rt.iterToOption(it2.next()) !== undefined) { - } - rt.byteVecPush(out, rt.peekablePeek(it2) !== undefined ? 1 : 0); - rt.byteVecPush(out, rt.peekablePeek(it2.clone()) !== undefined ? 1 : 0); - turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closure120_clones_iters_closure121(it2, (it25: rt.Peekable): rt.u8 | undefined => { - return rt.iterToOption(it25.nextBack()); - }, plan, (x27: rt.u8): rt.u8 => { + const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + while (rs.iterToOption(it2.next()) !== undefined) { + } + rs.byteVecPush(out, rs.peekablePeek(it2) !== undefined ? 1 : 0); + rs.byteVecPush(out, rs.peekablePeek(it2.clone()) !== undefined ? 1 : 0); + turns$iter_Peekable_iter_Copied_slice_Iter_u8_clones_iters_closure120_clones_iters_closure121(it2, (it25: rs.Peekable): rs.u8 | undefined => { + return rs.iterToOption(it25.nextBack()); + }, plan, (x27: rs.u8): rs.u8 => { return x27; }, out); } else if (_9 === 9) { - const _403: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): [rt.u8, rt.u8] => { - const b12: rt.u8 = _218; - return [rt.u8Rem(b12, 32), b12] as [rt.u8, rt.u8]; + const _403: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): [rs.u8, rs.u8] => { + const b12: rs.u8 = _218; + return [rs.u8Rem(b12, 32), b12] as [rs.u8, rs.u8]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _403, true, undefined, undefined, undefined, 2, true); - const _406: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): rt.u8 => { - return rt.u8Rem(_219, 32); + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _403, true, undefined, undefined, undefined, 2, true); + const _406: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_219: rs.u8): rs.u8 => { + return rs.u8Rem(_219, 32); }); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _406, true, undefined, undefined, 1, true); - const lo2: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 32); - turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_clones_iters_closure123(rt.btreeIter(map), (it17: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it17.nextBack()); - }, plan, (_222: [rt.u8, rt.u8]): rt.u8 => { + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _406, true, undefined, undefined, 1, true); + const lo2: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 32); + turns$collections_btree_map_Iter_u8_u8_clones_iters_closure122_clones_iters_closure123(rs.btreeIter(map), (it17: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it17.nextBack()); + }, plan, (_222: [rs.u8, rs.u8]): rs.u8 => { return _222[0] ^ _222[1]; }, out); - turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_clones_iters_closure0(rt.btreeKeys(map), (it18: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it18.nextBack()); - }, plan, (x20: rt.u8): rt.u8 => { + turns$collections_btree_map_Keys_u8_u8_clones_iters_closure124_clones_iters_closure0(rs.btreeKeys(map), (it18: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it18.nextBack()); + }, plan, (x20: rs.u8): rs.u8 => { return x20; }, out); - turns$collections_btree_map_Values_u8_u8_clones_iters_closure125_clones_iters_closure0(rt.btreeValues(map), (it19: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it19.nextBack()); - }, plan, (x21: rt.u8): rt.u8 => { + turns$collections_btree_map_Values_u8_u8_clones_iters_closure125_clones_iters_closure0(rs.btreeValues(map), (it19: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it19.nextBack()); + }, plan, (x21: rs.u8): rs.u8 => { return x21; }, out); - turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_clones_iters_closure127(rt.btreeRange(map, new rt.RangeFrom(lo2, rt.u8Step)), (it20: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it20.nextBack()); - }, plan, (_223: [rt.u8, rt.u8]): rt.u8 => { + turns$collections_btree_map_Range_u8_u8_clones_iters_closure126_clones_iters_closure127(rs.btreeRange(map, new rs.RangeFrom(lo2, rs.u8Step)), (it20: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it20.nextBack()); + }, plan, (_223: [rs.u8, rs.u8]): rs.u8 => { return _223[0] ^ _223[1]; }, out); - turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_clones_iters_closure129(rt.btreeRange(map, { end: lo2, inclusive: true }), (it21: rt.Iter<[rt.u8, rt.u8]>): [rt.u8, rt.u8] | undefined => { - return rt.iterToOption(it21.nextBack()); - }, plan, (_226: [rt.u8, rt.u8]): rt.u8 => { + turns$collections_btree_map_Range_u8_u8_clones_iters_closure128_clones_iters_closure129(rs.btreeRange(map, { end: lo2, inclusive: true }), (it21: rs.Iter<[rs.u8, rs.u8]>): [rs.u8, rs.u8] | undefined => { + return rs.iterToOption(it21.nextBack()); + }, plan, (_226: [rs.u8, rs.u8]): rs.u8 => { return _226[0] ^ _226[1]; }, out); - turns$collections_btree_set_Iter_u8_clones_iters_closure130_clones_iters_closure0(rt.btreeKeys(set), (it22: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it22.nextBack()); - }, plan, (x22: rt.u8): rt.u8 => { + turns$collections_btree_set_Iter_u8_clones_iters_closure130_clones_iters_closure0(rs.btreeKeys(set), (it22: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it22.nextBack()); + }, plan, (x22: rs.u8): rs.u8 => { return x22; }, out); - turns$collections_btree_set_Range_u8_clones_iters_closure131_clones_iters_closure0(rt.btreeRangeKeys(set, new rt.RangeFrom(lo2, rt.u8Step)), (it23: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it23.nextBack()); - }, plan, (x23: rt.u8): rt.u8 => { + turns$collections_btree_set_Range_u8_clones_iters_closure131_clones_iters_closure0(rs.btreeRangeKeys(set, new rs.RangeFrom(lo2, rs.u8Step)), (it23: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it23.nextBack()); + }, plan, (x23: rs.u8): rs.u8 => { return x23; }, out); } else if (_9 === 10) { - const _445: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): [rt.u8, rt.u8] => { - const b10: rt.u8 = _211; - return [rt.u8Rem(b10, 32), b10] as [rt.u8, rt.u8]; + const _445: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8] => { + const b10: rs.u8 = _211; + return [rs.u8Rem(b10, 32), b10] as [rs.u8, rs.u8]; }); - const map2: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _445, undefined, undefined, undefined, 469762048); - const _448: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u8 => { - return rt.u8Rem(_214, 32); + const map2: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _445, undefined, undefined, undefined, 469762048); + const _448: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): rs.u8 => { + return rs.u8Rem(_214, 32); }); - const set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _448, undefined, undefined, 469762048); - unordered$iter_Map_collections_hash_map_Iter_u8_u8_clones_iters_closure14(rt.iterMap(rt.hashIter(map2), (_215: [rt.u8, rt.u8]): rt.u8 => { + const set2: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _448, undefined, undefined, 469762048); + unordered$iter_Map_collections_hash_map_Iter_u8_u8_clones_iters_closure14(rs.iterMap(rs.hashIter(map2), (_215: [rs.u8, rs.u8]): rs.u8 => { return _215[0] ^ _215[1]; }), plan, out); - unordered$iter_Copied_collections_hash_map_Keys_u8_u8(rt.hashKeys(map2), plan, out); - unordered$iter_Copied_collections_hash_map_Values_u8_u8(rt.hashValues(map2), plan, out); - unordered$iter_Copied_collections_hash_set_Iter_u8(rt.hashKeys(set2), plan, out); + unordered$iter_Copied_collections_hash_map_Keys_u8_u8(rs.hashKeys(map2), plan, out); + unordered$iter_Copied_collections_hash_map_Values_u8_u8(rs.hashValues(map2), plan, out); + unordered$iter_Copied_collections_hash_set_Iter_u8(rs.hashKeys(set2), plan, out); } else if (_9 === 11) { - const split2: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, rt.usizeAdd(data.length, 1)); - const _480: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, split2))), (_29: rt.u8): rt.u8 => { - return rt.u8Rem(_29, 64); + const split2: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize, rs.usizeAdd(data.length, 1)); + const _480: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, split2))), (_29: rs.u8): rs.u8 => { + return rs.u8Rem(_29, 64); }); - const a3: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _480, true, undefined, undefined, 1, true); - const _485: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, split2))), (_210: rt.u8): rt.u8 => { - return rt.u8Rem(_210, 64); + const a3: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _480, true, undefined, undefined, 1, true); + const _485: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, split2))), (_210: rs.u8): rs.u8 => { + return rs.u8Rem(_210, 64); }); - const b4: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _485, true, undefined, undefined, 1, true); - turns$collections_btree_set_Union_u8_clones_iters_closure132_clones_iters_closure0(rt.btreeUnion(a3, b4), (it11: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it11.next()); - }, plan, (x14: rt.u8): rt.u8 => { + const b4: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _485, true, undefined, undefined, 1, true); + turns$collections_btree_set_Union_u8_clones_iters_closure132_clones_iters_closure0(rs.btreeUnion(a3, b4), (it11: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it11.next()); + }, plan, (x14: rs.u8): rs.u8 => { return x14; }, out); - turns$collections_btree_set_Intersection_u8_clones_iters_closure133_clones_iters_closure0(rt.btreeIntersection(a3, b4), (it12: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it12.next()); - }, plan, (x15: rt.u8): rt.u8 => { + turns$collections_btree_set_Intersection_u8_clones_iters_closure133_clones_iters_closure0(rs.btreeIntersection(a3, b4), (it12: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it12.next()); + }, plan, (x15: rs.u8): rs.u8 => { return x15; }, out); - turns$collections_btree_set_Intersection_u8_clones_iters_closure134_clones_iters_closure0(rt.btreeIntersection(b4, a3), (it13: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it13.next()); - }, plan, (x16: rt.u8): rt.u8 => { + turns$collections_btree_set_Intersection_u8_clones_iters_closure134_clones_iters_closure0(rs.btreeIntersection(b4, a3), (it13: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it13.next()); + }, plan, (x16: rs.u8): rs.u8 => { return x16; }, out); - turns$collections_btree_set_Difference_u8_clones_iters_closure135_clones_iters_closure0(rt.btreeDifference(a3, b4), (it14: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it14.next()); - }, plan, (x17: rt.u8): rt.u8 => { + turns$collections_btree_set_Difference_u8_clones_iters_closure135_clones_iters_closure0(rs.btreeDifference(a3, b4), (it14: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it14.next()); + }, plan, (x17: rs.u8): rs.u8 => { return x17; }, out); - turns$collections_btree_set_Difference_u8_clones_iters_closure136_clones_iters_closure0(rt.btreeDifference(b4, a3), (it15: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it15.next()); - }, plan, (x18: rt.u8): rt.u8 => { + turns$collections_btree_set_Difference_u8_clones_iters_closure136_clones_iters_closure0(rs.btreeDifference(b4, a3), (it15: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it15.next()); + }, plan, (x18: rs.u8): rs.u8 => { return x18; }, out); - turns$collections_btree_set_SymmetricDifference_u8_clones_iters_closure137_clones_iters_closure0(rt.btreeSymmetricDifference(a3, b4), (it16: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it16.next()); - }, plan, (x19: rt.u8): rt.u8 => { + turns$collections_btree_set_SymmetricDifference_u8_clones_iters_closure137_clones_iters_closure0(rs.btreeSymmetricDifference(a3, b4), (it16: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it16.next()); + }, plan, (x19: rs.u8): rs.u8 => { return x19; }, out); - const _520: rt.Iter = rt.btreeKeys(a3); - const a4: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _520, undefined, undefined, 469762048); - const _522: rt.Iter = rt.btreeKeys(b4); - const b5: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _522, undefined, undefined, 469762048); - unordered$iter_Copied_collections_hash_set_Union_u8_hash_RandomState(rt.hashUnion(a4, b5), plan, out); - unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_RandomState(rt.hashIntersection(a4, b5), plan, out); - unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(rt.hashDifference(a4, b5), plan, out); - unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rt.hashSymmetricDifference(a4, b5), plan, out); + const _520: rs.Iter = rs.btreeKeys(a3); + const a4: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _520, undefined, undefined, 469762048); + const _522: rs.Iter = rs.btreeKeys(b4); + const b5: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _522, undefined, undefined, 469762048); + unordered$iter_Copied_collections_hash_set_Union_u8_hash_RandomState(rs.hashUnion(a4, b5), plan, out); + unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_RandomState(rs.hashIntersection(a4, b5), plan, out); + unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(rs.hashDifference(a4, b5), plan, out); + unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rs.hashSymmetricDifference(a4, b5), plan, out); } else if (_9 === 12) { - const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; - for (const b6 of rt.byteSliceView(data)) { - if (rt.u8Rem(b6, 2) === 0) { - rt.dequePushFront(q, b6); + const q: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; + for (const b6 of rs.byteSliceView(data)) { + if (rs.u8Rem(b6, 2) === 0) { + rs.dequePushFront(q, b6); } else { - rt.dequePushBack(q, b6); + rs.dequePushBack(q, b6); } } - turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(rt.dequeIter(q), (it7: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it7.nextBack()); - }, plan, (x10: rt.u8): rt.u8 => { + turns$collections_vec_deque_Iter_u8_clones_iters_closure138_clones_iters_closure0(rs.dequeIter(q), (it7: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it7.nextBack()); + }, plan, (x10: rs.u8): rs.u8 => { return x10; }, out); - turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rt.dequeIntoIter(rt.dequeClone(q)), (it8: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it8.nextBack()); - }, plan, (x11: rt.u8): rt.u8 => { + turns$collections_vec_deque_IntoIter_u8_clones_iters_closure139_clones_iters_closure140(rs.dequeIntoIter(rs.dequeClone(q)), (it8: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it8.nextBack()); + }, plan, (x11: rs.u8): rs.u8 => { return x11; }, out); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); - turns$collections_binary_heap_Iter_u8_clones_iters_closure141_clones_iters_closure0(rt.heapIter(heap), (it9: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it9.nextBack()); - }, plan, (x12: rt.u8): rt.u8 => { + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), rs.le, rs.ge, rs.lt); + turns$collections_binary_heap_Iter_u8_clones_iters_closure141_clones_iters_closure0(rs.heapIter(heap), (it9: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it9.nextBack()); + }, plan, (x12: rs.u8): rs.u8 => { return x12; }, out); - turns$collections_binary_heap_IntoIter_u8_clones_iters_closure142_clones_iters_closure143(rt.heapIter(heap), (it10: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it10.nextBack()); - }, plan, (x13: rt.u8): rt.u8 => { + turns$collections_binary_heap_IntoIter_u8_clones_iters_closure142_clones_iters_closure143(rs.heapIter(heap), (it10: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it10.nextBack()); + }, plan, (x13: rs.u8): rs.u8 => { return x13; }, out); } else if (_9 === 13) { @@ -7184,61 +7184,61 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_9 === 14) { closures(data, plan, out); } else { - const _582: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const make = (captured: rt.u8): (a0: rt.u8) => rt.u8 => { - return rt.cloning((_24: rt.u8): rt.u8 => { - const x: rt.u8 = _24; - captured = rt.u8WrappingAdd(captured, 1); + const _582: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const make = (captured: rs.u8): (a0: rs.u8) => rs.u8 => { + return rs.cloning((_24: rs.u8): rs.u8 => { + const x: rs.u8 = _24; + captured = rs.u8WrappingAdd(captured, 1); return x ^ captured; }, () => make(captured)); }; - turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iters_closure145_clones_iters_closure146(rt.iterMap(_582, make(0)), (it3: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it3.nextBack()); - }, plan, (x2: rt.u8): rt.u8 => { + turns$iter_Map_slice_Iter_u8_clones_iters_closure144_clones_iters_closure145_clones_iters_closure146(rs.iterMap(_582, make(0)), (it3: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it3.nextBack()); + }, plan, (x2: rs.u8): rs.u8 => { return x2; }, out); - const seen: rt.ByteVec = new rt.ByteVec(); - const _588: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const make2 = (captured2: rt.ByteVec): (a0: rt.u8) => boolean => { - return rt.cloning((_26: rt.u8): boolean => { - rt.byteVecPush(captured2, _26); - return rt.usizeRem(captured2.length, 2) === 0; - }, () => make2(((a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const seen: rs.ByteVec = new rs.ByteVec(); + const _588: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const make2 = (captured2: rs.ByteVec): (a0: rs.u8) => boolean => { + return rs.cloning((_26: rs.u8): boolean => { + rs.byteVecPush(captured2, _26); + return rs.usizeRem(captured2.length, 2) === 0; + }, () => make2(((a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); })(captured2))); }; - turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_iters_closure148_clones_iters_closure0(rt.iterFilter(_588, make2(seen)), (it4: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it4.nextBack()); - }, plan, (x4: rt.u8): rt.u8 => { + turns$iter_Filter_slice_Iter_u8_clones_iters_closure147_clones_iters_closure148_clones_iters_closure0(rs.iterFilter(_588, make2(seen)), (it4: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it4.nextBack()); + }, plan, (x4: rs.u8): rs.u8 => { return x4; }, out); - const _594: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const make3 = (captured3: rt.u8): (a0: rt.u8) => undefined => { - return rt.cloning((_27: rt.u8): undefined => { - captured3 = rt.u8WrappingAdd(captured3, _27); + const _594: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const make3 = (captured3: rs.u8): (a0: rs.u8) => undefined => { + return rs.cloning((_27: rs.u8): undefined => { + captured3 = rs.u8WrappingAdd(captured3, _27); }, () => make3(captured3)); }; - turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure149_clones_iters_closure150_clones_iters_closure151_clones_iters_closure152(rt.iterMap(rt.iterInspect(_594, make3(0)), (_28: rt.u8): rt.u8 => { + turns$iter_Map_iter_Inspect_slice_Iter_u8_clones_iters_closure149_clones_iters_closure150_clones_iters_closure151_clones_iters_closure152(rs.iterMap(rs.iterInspect(_594, make3(0)), (_28: rs.u8): rs.u8 => { return _28; - }), (it5: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it5.next()); - }, plan, (x7: rt.u8): rt.u8 => { + }), (it5: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it5.next()); + }, plan, (x7: rs.u8): rs.u8 => { return x7; }, out); - const _599: rt.Iter = rt.byteSliceChunks(data, n); - const make4 = (captured4: rt.u8): (a0: rt.ByteSlice) => rt.Iter => { - return rt.cloning((c: rt.ByteSlice): rt.Iter => { - captured4 = rt.u8Add(captured4, 1); - const _45: rt.Iter = rt.iterSlice(rt.byteSliceView(c)); + const _599: rs.Iter = rs.byteSliceChunks(data, n); + const make4 = (captured4: rs.u8): (a0: rs.ByteSlice) => rs.Iter => { + return rs.cloning((c: rs.ByteSlice): rs.Iter => { + captured4 = rs.u8Add(captured4, 1); + const _45: rs.Iter = rs.iterSlice(rs.byteSliceView(c)); const captured5 = captured4; - return rt.iterMap(_45, (x8: rt.u8): rt.u8 => { + return rs.iterMap(_45, (x8: rs.u8): rs.u8 => { return x8 ^ captured5; }); }, () => make4(captured4)); }; - turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(rt.iterFlatMap(_599, make4(0), undefined, true), (it6: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it6.nextBack()); - }, plan, (x9: rt.u8): rt.u8 => { + turns$iter_FlatMap_slice_Chunks_u8_iter_Map_slice_Iter_u8_clones_iters_closure153_closure0_clones_iters_closure153_clones_iters_closure154_clones_iters_closure155(rs.iterFlatMap(_599, make4(0), undefined, true), (it6: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it6.nextBack()); + }, plan, (x9: rs.u8): rs.u8 => { return x9; }, out); } @@ -7248,247 +7248,247 @@ export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_map_Keys_u8_u8(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_map_Values_u8_u8(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_set_Difference_u8_hash_RandomState(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_RandomState(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_set_Intersection_u8_hash_RandomState(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_set_Iter_u8(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_set_SymmetricDifference_u8_hash_RandomState(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Copied_collections_hash_set_Union_u8_hash_RandomState(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Copied_collections_hash_set_Union_u8_hash_RandomState(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * `it` read up to three items, cloned, and both read to their ends: whether they read * the same, how many, and all it had, sorted, as std leaves a hash's order unspecified. */ -export function unordered$iter_Map_collections_hash_map_Iter_u8_u8_clones_iters_closure14(it: rt.Iter, plan: Plan.Plan, out: rt.ByteVec): void { - const all: rt.ByteVec = rt.iterToByteVec(rt.iterFilterMap(new rt.Range(0, rt.u8Rem(Plan.next(plan), 4)), (_2: rt.u8): rt.u8 | undefined => { - return rt.iterToOption(it.next()); +export function unordered$iter_Map_collections_hash_map_Iter_u8_u8_clones_iters_closure14(it: rs.Iter, plan: Plan.Plan, out: rs.ByteVec): void { + const all: rs.ByteVec = rs.iterToByteVec(rs.iterFilterMap(new rs.Range(0, rs.u8Rem(Plan.next(plan), 4)), (_2: rs.u8): rs.u8 | undefined => { + return rs.iterToOption(it.next()); }), "next"); - const other: rt.Iter = it.clone(); - const _17: rt.ByteVec = rt.iterToByteVec(it, "next"); - const _16: [rt.ByteVec, rt.ByteVec] = [_17, rt.iterToByteVec(other, "next")]; - const rest: rt.ByteVec = _17; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); - rt.iterExtendBytes(all, rt.byteVecIntoIter(rest), undefined, true); - rt.byteSliceView(rt.byteVecSlice(all)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(all), undefined, true); + const other: rs.Iter = it.clone(); + const _17: rs.ByteVec = rs.iterToByteVec(it, "next"); + const _16: [rs.ByteVec, rs.ByteVec] = [_17, rs.iterToByteVec(other, "next")]; + const rest: rs.ByteVec = _17; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqBytes(rest, _16[1]) ? 1 : 0, rest.length & 0xff)), undefined, true); + rs.iterExtendBytes(all, rs.byteVecIntoIter(rest), undefined, true); + rs.byteSliceView(rs.byteVecSlice(all)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(all), undefined, true); } /** * Iterators that own what they yield, each item cloned by its own `Clone` as the iterator * is, and dropped as each iterator drops. */ -export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function owned(data: rs.ByteSlice, plan: Plan.Plan, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const it: rt.Iter = rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_2: rt.u8): Logged.Logged => { + const it: rs.Iter = rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6), (_2: rs.u8): Logged.Logged => { return logged(_2 & 112); - }), undefined, 8, true), rt.drop); - rt.drop(rt.iterToOption(it.next())); - rt.drop(rt.iterToOption(it.nextBack())); - const clone: rt.Iter = it.clone({ v: Logged.clone$Clone }); + }), undefined, 8, true), rs.drop); + rs.drop(rs.iterToOption(it.next())); + rs.drop(rs.iterToOption(it.nextBack())); + const clone: rs.Iter = it.clone({ v: Logged.clone$Clone }); flush(log.value, out); - rt.drop(it); + rs.drop(it); flush(log.value, out); - turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_owned_closure3(clone, (it6: rt.Iter): Logged.Logged | undefined => { - return rt.iterToOption(it6.nextBack()); - }, plan, (x: Logged.Logged): rt.u8 => { - const _04: rt.u8 = Logged.id(x); + turns$vec_IntoIter_clones_Logged_clones_owned_closure2_clones_owned_closure3(clone, (it6: rs.Iter): Logged.Logged | undefined => { + return rs.iterToOption(it6.nextBack()); + }, plan, (x: Logged.Logged): rs.u8 => { + const _04: rs.u8 = Logged.id(x); x[Symbol.dispose](); return _04; }, out); flush(log.value, out); - turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_22: rt.u8): Logged.Logged => { + turns$collections_vec_deque_IntoIter_clones_Logged_clones_owned_closure5_clones_owned_closure6(rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_22: rs.u8): Logged.Logged => { return logged(_22 & 112); - }), undefined, 8, true), 8) as rt.VecDeque, rt.drop), (it7: rt.Iter): Logged.Logged | undefined => { - return rt.iterToOption(it7.nextBack()); - }, plan, (x2: Logged.Logged): rt.u8 => { - const _07: rt.u8 = Logged.id(x2); + }), undefined, 8, true), 8) as rs.VecDeque, rs.drop), (it7: rs.Iter): Logged.Logged | undefined => { + return rs.iterToOption(it7.nextBack()); + }, plan, (x2: Logged.Logged): rs.u8 => { + const _07: rs.u8 = Logged.id(x2); x2[Symbol.dispose](); return _07; }, out); flush(log.value, out); - const it2: rt.Peekable = rt.iterPeekable(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_24: rt.u8): Logged.Logged => { + const it2: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_24: rs.u8): Logged.Logged => { return logged(_24 & 112); - }), undefined, 8, true), rt.drop), rt.drop); - rt.byteVecPush(out, option_mapOr$1yabfom(rt.peekablePeek(it2), 238, Logged.id)); - const clone2: rt.Peekable = it2.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); + }), undefined, 8, true), rs.drop), rs.drop); + rs.byteVecPush(out, option_mapOr$15gmqsv(rs.peekablePeek(it2), 238, Logged.id)); + const clone2: rs.Peekable = it2.clone({ i: { v: Logged.clone$Clone }, v: Logged.clone$Clone }); flush(log.value, out); - rt.drop(clone2); + rs.drop(clone2); flush(log.value, out); - turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_closure8_clones_owned_closure9(it2, (it8: rt.Peekable): Logged.Logged | undefined => { - return rt.iterToOption(it8.nextBack()); - }, plan, (x3: Logged.Logged): rt.u8 => { - const _010: rt.u8 = Logged.id(x3); + turns$iter_Peekable_vec_IntoIter_clones_Logged_clones_owned_closure8_clones_owned_closure9(it2, (it8: rs.Peekable): Logged.Logged | undefined => { + return rs.iterToOption(it8.nextBack()); + }, plan, (x3: Logged.Logged): rs.u8 => { + const _010: rs.u8 = Logged.id(x3); x3[Symbol.dispose](); return _010; }, out); flush(log.value, out); - const it3: rt.Iter = rt.iterChain(rt.iterOnce(logged(1), rt.drop), rt.iterOption(logged(2), rt.drop)); - const clone3: rt.Iter = it3.clone({ i: { v: Logged.clone$Clone }, o: { v: Logged.clone$Clone } }); + const it3: rs.Iter = rs.iterChain(rs.iterOnce(logged(1), rs.drop), rs.iterOption(logged(2), rs.drop)); + const clone3: rs.Iter = it3.clone({ i: { v: Logged.clone$Clone }, o: { v: Logged.clone$Clone } }); flush(log.value, out); - rt.drop(it3); - turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_Logged_clones_owned_closure10_clones_owned_closure11(clone3, (it9: rt.Iter): Logged.Logged | undefined => { - return rt.iterToOption(it9.nextBack()); - }, plan, (x4: Logged.Logged): rt.u8 => { - const _012: rt.u8 = Logged.id(x4); + rs.drop(it3); + turns$iter_Chain_iter_Once_clones_Logged_option_IntoIter_clones_Logged_clones_owned_closure10_clones_owned_closure11(clone3, (it9: rs.Iter): Logged.Logged | undefined => { + return rs.iterToOption(it9.nextBack()); + }, plan, (x4: Logged.Logged): rs.u8 => { + const _012: rs.u8 = Logged.id(x4); x4[Symbol.dispose](); return _012; }, out); flush(log.value, out); - const it4: rt.Iter = rt.iterFlatten(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterTake(rt.byteSliceChunks(data, 3), 3), (c: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(c)), (_25: rt.u8): Logged.Logged => { + const it4: rs.Iter = rs.iterFlatten(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunks(data, 3), 3), (c: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(c)), (_25: rs.u8): Logged.Logged => { return logged(_25 & 112); }), undefined, 8, true); - }), undefined, 12, true), drop$Vec_clones_Logged), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); - rt.drop(rt.iterToOption(it4.next())); - rt.drop(rt.iterToOption(it4.nextBack())); - const clone4: rt.Iter = it4.clone({ i: { v: (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.map(Logged.clone$Clone)); + }), undefined, 12, true), drop$Vec_clones_Logged), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); + rs.drop(rs.iterToOption(it4.next())); + rs.drop(rs.iterToOption(it4.nextBack())); + const clone4: rs.Iter = it4.clone({ i: { v: (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(Logged.clone$Clone)); } }, o: { v: Logged.clone$Clone } }); flush(log.value, out); - rt.drop(it4); + rs.drop(it4); flush(log.value, out); - turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_closure13_clones_owned_closure14(clone4, (it10: rt.Iter): Logged.Logged | undefined => { - return rt.iterToOption(it10.nextBack()); - }, plan, (x5: Logged.Logged): rt.u8 => { - const _017: rt.u8 = Logged.id(x5); + turns$iter_Flatten_vec_IntoIter_Vec_clones_Logged_clones_owned_closure13_clones_owned_closure14(clone4, (it10: rs.Iter): Logged.Logged | undefined => { + return rs.iterToOption(it10.nextBack()); + }, plan, (x5: Logged.Logged): rs.u8 => { + const _017: rs.u8 = Logged.id(x5); x5[Symbol.dispose](); return _017; }, out); flush(log.value, out); - const it5: rt.Iter = rt.iterSuccessors(logged(40), (x6: Logged.Logged): Logged.Logged | undefined => { - return option_map$0y3liwu(rt.u8CheckedSub(Logged.id(x6), 13), (id2: rt.u8): Logged.Logged => { + const it5: rs.Iter = rs.iterSuccessors(logged(40), (x6: Logged.Logged): Logged.Logged | undefined => { + return option_map$1kvcy6m(rs.u8CheckedSub(Logged.id(x6), 13), (id2: rs.u8): Logged.Logged => { return logged(id2); }); - }, rt.drop); - rt.drop(rt.iterToOption(it5.next())); - const clone5: rt.Iter = it5.clone({ v: Logged.clone$Clone }); + }, rs.drop); + rs.drop(rs.iterToOption(it5.next())); + const clone5: rs.Iter = it5.clone({ v: Logged.clone$Clone }); flush(log.value, out); - turns$iter_Successors_clones_Logged_clones_owned_closure15_clones_owned_closure16_clones_owned_closure17(clone5, (it11: rt.Iter): Logged.Logged | undefined => { - return rt.iterToOption(it11.next()); - }, plan, (x7: Logged.Logged): rt.u8 => { - const _021: rt.u8 = Logged.id(x7); + turns$iter_Successors_clones_Logged_clones_owned_closure15_clones_owned_closure16_clones_owned_closure17(clone5, (it11: rs.Iter): Logged.Logged | undefined => { + return rs.iterToOption(it11.next()); + }, plan, (x7: Logged.Logged): rs.u8 => { + const _021: rs.u8 = Logged.id(x7); x7[Symbol.dispose](); return _021; }, out); - rt.drop(it5); + rs.drop(it5); flush(log.value, out); log[Symbol.dispose](); } @@ -7497,98 +7497,98 @@ export function owned(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): voi * Adaptors of closures that capture values that drop, which their clones clone and drop * with them, and closures cloned on their own. */ -export function closures(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function closures(data: rs.ByteSlice, plan: Plan.Plan, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; const _11: [Logged.Logged, Logged.Logged] = [logged(1), logged(2)]; const a: Logged.Logged = _11[0]; const b: Logged.Logged = _11[1]; - const _20: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const make = (captured: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((_2: rt.u8): rt.u8 => { + const _20: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const make = (captured: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((_2: rs.u8): rs.u8 => { return _2 ^ Logged.id(captured); }, () => make(Logged.clone$Clone(captured))), (): void => { captured[Symbol.dispose](); }); }; - const _19: rt.Iter = rt.iterMap(_20, make(a)); - const make2 = (captured2: Logged.Logged): (a0: rt.u8) => boolean => { - return rt.closure(rt.cloning((_23: rt.u8): boolean => { + const _19: rs.Iter = rs.iterMap(_20, make(a)); + const make2 = (captured2: Logged.Logged): (a0: rs.u8) => boolean => { + return rs.closure(rs.cloning((_23: rs.u8): boolean => { return _23 !== Logged.id(captured2); }, () => make2(Logged.clone$Clone(captured2))), (): void => { captured2[Symbol.dispose](); }); }; - const it: rt.Iter = rt.iterFilter(_19, make2(b)); - const clone: rt.Iter = it.clone({ i: { f: rt.closureClone }, f: rt.closureClone }); + const it: rs.Iter = rs.iterFilter(_19, make2(b)); + const clone: rs.Iter = it.clone({ i: { f: rs.closureClone }, f: rs.closureClone }); flush(log.value, out); - rt.drop(it); + rs.drop(it); flush(log.value, out); - turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure1_clones_closures_closure2_clones_closures_closure3_clones_closures_closure4(clone, (it4: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it4.nextBack()); - }, plan, (x3: rt.u8): rt.u8 => { + turns$iter_Filter_iter_Map_slice_Iter_u8_clones_closures_closure1_clones_closures_closure2_clones_closures_closure3_clones_closures_closure4(clone, (it4: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it4.nextBack()); + }, plan, (x3: rs.u8): rs.u8 => { return x3; }, out); flush(log.value, out); - const _38: [Logged.Logged, rt.u8] = [logged(3), 0]; + const _38: [Logged.Logged, rs.u8] = [logged(3), 0]; const tag: Logged.Logged = _38[0]; - const count: rt.u8 = 0; - const _43: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const make3 = (captured3: rt.u8, captured4: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((_24: rt.u8): rt.u8 => { - const x4: rt.u8 = _24; - captured3 = rt.u8WrappingAdd(captured3, Logged.id(captured4)); + const count: rs.u8 = 0; + const _43: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const make3 = (captured3: rs.u8, captured4: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((_24: rs.u8): rs.u8 => { + const x4: rs.u8 = _24; + captured3 = rs.u8WrappingAdd(captured3, Logged.id(captured4)); return x4 ^ captured3; }, () => make3(captured3, Logged.clone$Clone(captured4))), (): void => { captured4[Symbol.dispose](); }); }; - const it2: rt.Iter = rt.iterMap(_43, make3(count, tag)); + const it2: rs.Iter = rs.iterMap(_43, make3(count, tag)); it2.next(); - const clone2: rt.Iter = it2.clone({ f: rt.closureClone }); + const clone2: rs.Iter = it2.clone({ f: rs.closureClone }); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it2.next())), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(clone2.next())), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(clone2.next())), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it2.next())), undefined, true); - rt.drop(clone2); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(clone2.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(clone2.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); + rs.drop(clone2); flush(log.value, out); - rt.drop(it2); + rs.drop(it2); flush(log.value, out); const inner: Logged.Logged = logged(5); - const make4 = (captured5: rt.u8, captured6: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((x5: rt.u8): rt.u8 => { - captured5 = rt.u8WrappingAdd(captured5, x5 ^ Logged.id(captured6)); + const make4 = (captured5: rs.u8, captured6: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((x5: rs.u8): rs.u8 => { + captured5 = rs.u8WrappingAdd(captured5, x5 ^ Logged.id(captured6)); return captured5; }, () => make4(captured5, Logged.clone$Clone(captured6))), (): void => { captured6[Symbol.dispose](); }); }; - const add: (a0: rt.u8) => rt.u8 = make4(0, inner); - rt.byteVecPush(out, add(1)); + const add: (a0: rs.u8) => rs.u8 = make4(0, inner); + rs.byteVecPush(out, add(1)); const held: Logged.Logged = logged(6); - const make5 = (captured7: (a0: rt.u8) => rt.u8, captured8: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((x6: rt.u8): rt.u8 => { + const make5 = (captured7: (a0: rs.u8) => rs.u8, captured8: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((x6: rs.u8): rs.u8 => { return captured7(x6) ^ Logged.id(captured8); - }, () => make5(rt.closureClone(captured7), Logged.clone$Clone(captured8))), (): void => { - rt.drop(captured7); + }, () => make5(rs.closureClone(captured7), Logged.clone$Clone(captured8))), (): void => { + rs.drop(captured7); captured8[Symbol.dispose](); }); }; - const outer: (a0: rt.u8) => rt.u8 = make5(add, held); - const copy: (a0: rt.u8) => rt.u8 = rt.closureClone(outer); + const outer: (a0: rs.u8) => rs.u8 = make5(add, held); + const copy: (a0: rs.u8) => rs.u8 = rs.closureClone(outer); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(outer(2), copy(3), copy(4), outer(5))), undefined, true); - rt.drop(outer); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(outer(2), copy(3), copy(4), outer(5))), undefined, true); + rs.drop(outer); flush(log.value, out); - rt.drop(copy); + rs.drop(copy); flush(log.value, out); const text: string = "ab"; const tag2: Logged.Logged = logged(7); const make6 = (captured9: string, captured10: Logged.Logged): () => [string, Logged.Logged] => { - return rt.closure(rt.cloning((): [string, Logged.Logged] => { + return rs.closure(rs.cloning((): [string, Logged.Logged] => { captured9 = captured9 + "c"; return [captured9, captured10] as [string, Logged.Logged]; }, () => make6(captured9, Logged.clone$Clone(captured10))), (): void => { @@ -7596,26 +7596,26 @@ export function closures(data: rt.ByteSlice, plan: Plan.Plan, out: rt.ByteVec): }); }; const once: () => [string, Logged.Logged] = make6(text, tag2); - const twice: () => [string, Logged.Logged] = rt.closureClone(once); + const twice: () => [string, Logged.Logged] = rs.closureClone(once); flush(log.value, out); const _127: [string, Logged.Logged] = once(); const text2: string = _127[0]; const tag3: Logged.Logged = _127[1]; - rt.iterExtendBytes(out, rt.iterChain(rt.strBytes(text2), rt.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text2), rs.iterSlice(Uint8Array.of(Logged.id(tag3)))), undefined, true); tag3[Symbol.dispose](); const _139: [string, Logged.Logged] = twice(); const text3: string = _139[0]; const tag4: Logged.Logged = _139[1]; - rt.iterExtendBytes(out, rt.iterChain(rt.strBytes(text3), rt.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(text3), rs.iterSlice(Uint8Array.of(Logged.id(tag4)))), undefined, true); tag4[Symbol.dispose](); flush(log.value, out); const captured11 = data.length & 0xff; - const shared: (a0: rt.u8) => rt.u8 = (x7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(x7, captured11); + const shared: (a0: rs.u8) => rs.u8 = (x7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(x7, captured11); }; - const it3: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), shared); - const clone3: rt.Iter = rt.iterRev(it3.clone()); - rt.iterExtendBytes(out, rt.iterMap(rt.iterZip(it3, clone3, "len"), (_25: [rt.u8, rt.u8]): rt.u8 => { + const it3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), shared); + const clone3: rs.Iter = rs.iterRev(it3.clone()); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(it3, clone3, "len"), (_25: [rs.u8, rs.u8]): rs.u8 => { return _25[0] ^ _25[1]; }), undefined, true); log[Symbol.dispose](); @@ -7632,30 +7632,30 @@ export function cloned$array2_clones_Logged(x: Logged.Logged[]): Logged.Logged[] * over its own and drop what that wrote over, of none, nested, and as an `Option`, a tuple, * a derived `Clone`, a `Vec`, and a generic function clone theirs. */ -export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _13: (a0: Logged.Logged[], a1: rt.ByteVec) => undefined = (a3: Logged.Logged[], out2: rt.ByteVec): undefined => { - rt.iterExtendBytes(out2, rt.iterMap(rt.iterSlice(a3), Logged.id), undefined, true); +export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _13: (a0: Logged.Logged[], a1: rs.ByteVec) => undefined = (a3: Logged.Logged[], out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(a3), Logged.id), undefined, true); }; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 48)) & 126; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 48)) & 126; }; const three: () => Logged.Logged[] = (): Logged.Logged[] => { return [logged(at(0)), logged(at(1)), logged(at(2))]; }; - const _14: rt.u8 = rt.u8Rem(kind, 8); + const _14: rs.u8 = rs.u8Rem(kind, 8); if (_14 === 0) { const a: Logged.Logged[] = three(); const b: Logged.Logged[] = a.map(Logged.clone$Clone); flush(log.value, out); _13(b, out); - rt.dropAll(a); + rs.dropAll(a); flush(log.value, out); const c: Logged.Logged[] = b.map(Logged.clone$Clone); - rt.dropAll(b); + rs.dropAll(b); flush(log.value, out); [].map(Logged.clone$Clone); _13(c, out); @@ -7669,7 +7669,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _60: Logged.Logged = logged(part25); const part26 = at(5); const b2: Logged.Logged[] = [_54, _60, logged(part26)]; - rt.sliceCloneFromSlice(a2, b2, Logged.clone$Clone, rt.drop); + rs.sliceCloneFromSlice(a2, b2, Logged.clone$Clone, rs.drop); flush(log.value, out); _13(a2, out); const part28 = at(6); @@ -7678,7 +7678,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _90: Logged.Logged = logged(part29); const part30 = at(8); const c2: Logged.Logged[] = [_84, _90, logged(part30)]; - rt.sliceCloneFromSlice(c2, b2, Logged.clone$Clone, rt.drop); + rs.sliceCloneFromSlice(c2, b2, Logged.clone$Clone, rs.drop); flush(log.value, out); _13(c2, out); drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged([a2, b2, c2] as [Logged.Logged[], Logged.Logged[], Logged.Logged[]]); @@ -7693,15 +7693,15 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const x: Logged.Logged[] | undefined = _137[0]; const y: Logged.Logged[] | undefined = _137[1]; flush(log.value, out); - rt.byteVecPush(out, y === undefined ? 1 : 0); - const part23 = rt.optionUnwrap(x); + rs.byteVecPush(out, y === undefined ? 1 : 0); + const part23 = rs.optionUnwrap(x); _13(part23, out); - rt.dropAll(some); + rs.dropAll(some); flush(log.value, out); - rt.dropAll(x); + rs.dropAll(x); flush(log.value, out); - rt.dropAll(y); - rt.dropAll(none); + rs.dropAll(y); + rs.dropAll(none); } else if (_14 === 3) { const part13 = at(0); const _166: Logged.Logged = logged(part13); @@ -7710,7 +7710,7 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _178: string = "t"; const part15 = at(2); const tuple: [Logged.Logged[], string, Logged.Logged] = [_165, _178, logged(part15)]; - const copy: [Logged.Logged[], string, Logged.Logged] = rt.tupleClone(tuple, [(a05: Logged.Logged[]): Logged.Logged[] => { + const copy: [Logged.Logged[], string, Logged.Logged] = rs.tupleClone(tuple, [(a05: Logged.Logged[]): Logged.Logged[] => { return a05.map(Logged.clone$Clone); }, undefined, Logged.clone$Clone]); flush(log.value, out); @@ -7722,12 +7722,12 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part18 = at(4); const _200: Logged.Logged[] = [_201, logged(part18)]; const part19 = at(5); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part19, f)]; - const pair: Pair.Pair = new Pair.Pair(_200, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part19, f)]; + const pair: Pair.Pair = new Pair.Pair(_200, rs.fmtFormat([args2[0]])); const other: Pair.Pair = Pair.clone$Clone(pair); flush(log.value, out); _13(other.left, out); - rt.iterExtendBytes(out, rt.strBytes(other.tag), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(other.tag), undefined, true); drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clones_Pair([copy, pair] as [[Logged.Logged[], string, Logged.Logged], Pair.Pair]); flush(log.value, out); other[Symbol.dispose](); @@ -7745,21 +7745,21 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { return a03.map(Logged.clone$Clone); }); flush(log.value, out); - rt.dropAll(grid, drop$array2_clones_Logged); + rs.dropAll(grid, drop$array2_clones_Logged); flush(log.value, out); _13(copy2[1], out); - const _295: rt.u8 = at(4); - const words: string[] = ["a", rt.fmtToString((f: rt.Formatter) => rt.u8Display(_295, f)), ""]; - const vecs: rt.ByteVec[] = [rt.byteSliceToByteVec(data), rt.byteVecFrom(Uint8Array.of(at(5)))]; - const _308: [string[], rt.ByteVec[]] = [words.slice(), vecs.map((a04: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a04)); + const _295: rs.u8 = at(4); + const words: string[] = ["a", rs.fmtToString((f: rs.Formatter) => rs.u8Display(_295, f)), ""]; + const vecs: rs.ByteVec[] = [rs.byteSliceToByteVec(data), rs.byteVecFrom(Uint8Array.of(at(5)))]; + const _308: [string[], rs.ByteVec[]] = [words.slice(), vecs.map((a04: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a04)); })]; const words2: string[] = _308[0]; - const vecs2: rt.ByteVec[] = _308[1]; - rt.byteVecPush(vecs2[0], 1); - rt.iterExtendBytes(out, rt.strBytes(rt.strsJoin(words2, "")), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterChain(rt.iterSlice(vecs), rt.iterSlice(vecs2)), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), "next"); - rt.dropAll(copy2, drop$array2_clones_Logged); + const vecs2: rs.ByteVec[] = _308[1]; + rs.byteVecPush(vecs2[0], 1); + rs.iterExtendBytes(out, rs.strBytes(rs.strsJoin(words2, "")), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterChain(rs.iterSlice(vecs), rs.iterSlice(vecs2)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); + rs.dropAll(copy2, drop$array2_clones_Logged); flush(log.value, out); } else if (_14 === 5) { const part4 = at(0); @@ -7769,32 +7769,32 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part6 = at(2); const _351: Logged.Logged = logged(part6); const part7 = at(3); - const rows: rt.Vec = rt.vecFrom([_337, [_351, logged(part7)]]); - const copy3: rt.Vec = rt.vecFrom(rows.items.map((a0: Logged.Logged[]): Logged.Logged[] => { + const rows: rs.Vec = rs.vecFrom([_337, [_351, logged(part7)]]); + const copy3: rs.Vec = rs.vecFrom(rows.items.map((a0: Logged.Logged[]): Logged.Logged[] => { return a0.map(Logged.clone$Clone); })); flush(log.value, out); - const generic: Logged.Logged[] = cloned$array2_clones_Logged(copy3.items[rt.idx(copy3.items, 0)]); + const generic: Logged.Logged[] = cloned$array2_clones_Logged(copy3.items[rs.idx(copy3.items, 0)]); flush(log.value, out); - let sum: rt.u8 = 0; - const iter: rt.Iter = rt.iterMap(rt.iterSlice(rows.items), (a02: Logged.Logged[]): Logged.Logged[] => { + let sum: rs.u8 = 0; + const iter: rs.Iter = rs.iterMap(rs.iterSlice(rows.items), (a02: Logged.Logged[]): Logged.Logged[] => { return a02.map(Logged.clone$Clone); }); while (true) { - const _381: Logged.Logged[] | rt.Done = iter.next(); - if (_381 === rt.DONE) { + const _381: Logged.Logged[] | rs.Done = iter.next(); + if (_381 === rs.DONE) { break; } const row: Logged.Logged[] = _381; - sum = rt.u8WrappingAdd(sum, Logged.id(row[0]) ^ Logged.id(row[1])); - rt.dropAll(row); + sum = rs.u8WrappingAdd(sum, Logged.id(row[0]) ^ Logged.id(row[1])); + rs.dropAll(row); } - rt.byteVecPush(out, sum); + rs.byteVecPush(out, sum); flush(log.value, out); - drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged([rows, copy3, generic] as [rt.Vec, rt.Vec, Logged.Logged[]]); + drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged([rows, copy3, generic] as [rs.Vec, rs.Vec, Logged.Logged[]]); flush(log.value, out); } else { - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice([{ _0: at(0) }, { _0: at(1) }, { _0: at(2) }].map(Fussy.clone$Clone)), (f: Fussy.Fussy): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([{ _0: at(0) }, { _0: at(1) }, { _0: at(2) }].map(Fussy.clone$Clone)), (f: Fussy.Fussy): rs.u8 => { return f._0; }), undefined, true); } @@ -7806,102 +7806,102 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * an `Option`'s of two `Some`s is what it holds', a `Vec`'s truncates, clones over the * elements it keeps, and extends, and a slice's of arrays clones each over its own. */ -export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _156!: rt.usize; - const _14: (a0: Logged.Logged[], a1: rt.ByteVec) => undefined = (a6: Logged.Logged[], out2: rt.ByteVec): undefined => { - rt.iterExtendBytes(out2, rt.iterMap(rt.iterSlice(a6), Logged.id), undefined, true); +export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _156!: rs.usize; + const _14: (a0: Logged.Logged[], a1: rs.ByteVec) => undefined = (a6: Logged.Logged[], out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(a6), Logged.id), undefined, true); }; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), rt.u8WrappingMul(i2 & 0xff, 48)) & 126; + const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), rs.u8WrappingMul(i2 & 0xff, 48)) & 126; }; - const len: (a0: rt.usize) => rt.usize = (i3: rt.usize): rt.usize => { - return rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i3), i3 & 0xff), 4) as rt.usize; + const len: (a0: rs.usize) => rs.usize = (i3: rs.usize): rs.usize => { + return rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), i3 & 0xff), 4) as rs.usize; }; - const row: (a0: rt.usize, a1: rt.usize) => rt.Vec = (from: rt.usize, n2: rt.usize): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n2), (i4: rt.usize): Logged.Logged => { - return logged(at(rt.usizeAdd(from, i4))); + const row: (a0: rs.usize, a1: rs.usize) => rs.Vec = (from: rs.usize, n2: rs.usize): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n2), (i4: rs.usize): Logged.Logged => { + return logged(at(rs.usizeAdd(from, i4))); }), undefined, 8, true); }; - const _15: rt.u8 = rt.u8Rem(kind, 8); + const _15: rs.u8 = rs.u8Rem(kind, 8); if (_15 === 0) { - const pick: (a0: rt.usize) => Logged.Logged[] | undefined = (i13: rt.usize): Logged.Logged[] | undefined => { - return then$1uqvqbl(rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i13), 1), 2) === 1, (): Logged.Logged[] => { - return [logged(at(i13)), logged(at(rt.usizeAdd(i13, 1)))]; + const pick: (a0: rs.usize) => Logged.Logged[] | undefined = (i13: rs.usize): Logged.Logged[] | undefined => { + return then$1uqvqbl(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i13), 1), 2) === 1, (): Logged.Logged[] => { + return [logged(at(i13)), logged(at(rs.usizeAdd(i13, 1)))]; }); }; let a: Logged.Logged[] | undefined = pick(0); const b: Logged.Logged[] | undefined = pick(2); flush(log.value, out); - a = rt.optionCloneFrom(a, b, (a013: Logged.Logged[]): Logged.Logged[] => { + a = rs.optionCloneFrom(a, b, (a013: Logged.Logged[]): Logged.Logged[] => { return a013.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - rt.byteVecPush(out, a !== undefined ? 1 : 0); + rs.byteVecPush(out, a !== undefined ? 1 : 0); if (a !== undefined) { _14(a, out); } let c: Logged.Logged[] | undefined = pick(4); - c = rt.optionCloneFrom(c, a, (a014: Logged.Logged[]): Logged.Logged[] => { + c = rs.optionCloneFrom(c, a, (a014: Logged.Logged[]): Logged.Logged[] => { return a014.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged([a, b, c] as [Logged.Logged[] | undefined, Logged.Logged[] | undefined, Logged.Logged[] | undefined]); flush(log.value, out); } else if (_15 === 1) { - const pick2: (a0: rt.usize) => rt.Vec | undefined = (i12: rt.usize): rt.Vec | undefined => { - return then$0415f7q(rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i12), 1), 5) !== 0, (): rt.Vec => { + const pick2: (a0: rs.usize) => rs.Vec | undefined = (i12: rs.usize): rs.Vec | undefined => { + return then$0ba40i0(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i12), 1), 5) !== 0, (): rs.Vec => { return row(i12, len(i12)); }); }; - let a2: rt.Vec | undefined = pick2(0); - const b2: rt.Vec | undefined = pick2(4); + let a2: rs.Vec | undefined = pick2(0); + const b2: rs.Vec | undefined = pick2(4); flush(log.value, out); - a2 = rt.optionCloneFrom(a2, b2, (a012: rt.Vec): rt.Vec => { - return rt.vecFrom(a012.items.map(Logged.clone$Clone)); - }, drop$Vec_clones_Logged, rt.vecCloneFromFn(8, Logged.clone$Clone, rt.drop)); + a2 = rs.optionCloneFrom(a2, b2, (a012: rs.Vec): rs.Vec => { + return rs.vecFrom(a012.items.map(Logged.clone$Clone)); + }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); if (a2 !== undefined) { _14(a2.items, out); } - drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged([a2, b2] as [rt.Vec | undefined, rt.Vec | undefined]); + drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged([a2, b2] as [rs.Vec | undefined, rs.Vec | undefined]); flush(log.value, out); } else if (_15 === 2) { const part45 = len(0); - const a3: rt.Vec = row(0, part45); - const _101: rt.usize = len(1); - rt.vecReserve(a3, _101, 8); + const a3: rs.Vec = row(0, part45); + const _101: rs.usize = len(1); + rs.vecReserve(a3, _101, 8); const part46 = len(4); - const b3: rt.Vec = row(4, part46); + const b3: rs.Vec = row(4, part46); flush(log.value, out); - rt.vecCloneFrom(a3, b3, 8, Logged.clone$Clone, rt.drop); + rs.vecCloneFrom(a3, b3, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); _14(a3.items, out); - rt.byteVecPush(out, rt.vecCapacity(a3, 8) & 0xff); + rs.byteVecPush(out, rs.vecCapacity(a3, 8) & 0xff); const part48 = len(8); - const c2: rt.Vec = row(8, part48); - rt.vecCloneFrom(c2, b3, 8, Logged.clone$Clone, rt.drop); + const c2: rs.Vec = row(8, part48); + rs.vecCloneFrom(c2, b3, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); _14(c2.items, out); - const _146: Logged.Logged[] = rt.sliceRange(b3.items, 0); - rt.vecCloneFrom(a3, _146, 8, Logged.clone$Clone, rt.drop); + const _146: Logged.Logged[] = rs.sliceRange(b3.items, 0); + rs.vecCloneFrom(a3, _146, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); - const d: rt.Vec = new rt.Vec(); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 5; + const d: rs.Vec = new rs.Vec(); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 5; while ((_156 = iterStart++) < iterEnd) { - const part51 = at(rt.usizeAdd(12, _156)); + const part51 = at(rs.usizeAdd(12, _156)); const _162: Logged.Logged = logged(part51); d.items.push(_162); } - rt.vecCloneFrom(d, b3, 8, Logged.clone$Clone, rt.drop); + rs.vecCloneFrom(d, b3, 8, Logged.clone$Clone, rs.drop); flush(log.value, out); - rt.byteVecPush(out, rt.vecCapacity(d, 8) & 0xff); - rt.dropVec(d); - drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged([a3, b3, c2] as [rt.Vec, rt.Vec, rt.Vec]); + rs.byteVecPush(out, rs.vecCapacity(d, 8) & 0xff); + rs.dropVec(d); + drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged([a3, b3, c2] as [rs.Vec, rs.Vec, rs.Vec]); flush(log.value, out); } else if (_15 === 3) { const part36 = at(0); @@ -7921,14 +7921,14 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const part43 = at(7); const other: Logged.Logged[][] = [_217, [_231, logged(part43)]]; flush(log.value, out); - rt.sliceCloneFromSlice(grid, other, (a010: Logged.Logged[]): Logged.Logged[] => { + rs.sliceCloneFromSlice(grid, other, (a010: Logged.Logged[]): Logged.Logged[] => { return a010.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); _14(grid[1], out); - rt.sliceCloneFromSlice(grid, other, (a011: Logged.Logged[]): Logged.Logged[] => { + rs.sliceCloneFromSlice(grid, other, (a011: Logged.Logged[]): Logged.Logged[] => { return a011.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged([grid, other] as [Logged.Logged[][], Logged.Logged[][]]); flush(log.value, out); @@ -7940,7 +7940,7 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const part25 = at(2); const _287: Logged.Logged = logged(part25); const part26 = at(3); - const rows: rt.Vec = rt.vecFrom([_273, [_287, logged(part26)]]); + const rows: rs.Vec = rs.vecFrom([_273, [_287, logged(part26)]]); const part27 = at(4); const _301: Logged.Logged = logged(part27); const part28 = at(5); @@ -7950,64 +7950,64 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const part30 = at(7); const other2: Logged.Logged[][] = [_300, [_314, logged(part30)]]; flush(log.value, out); - rt.sliceCloneFromSlice(rows.items, other2, (a06: Logged.Logged[]): Logged.Logged[] => { + rs.sliceCloneFromSlice(rows.items, other2, (a06: Logged.Logged[]): Logged.Logged[] => { return a06.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - rt.sliceFill(rt.sliceRangeMut(rows.items, 0, 1), other2[1].map(Logged.clone$Clone), (a07: Logged.Logged[]): Logged.Logged[] => { + rs.sliceFill(rs.sliceRangeMut(rows.items, 0, 1), other2[1].map(Logged.clone$Clone), (a07: Logged.Logged[]): Logged.Logged[] => { return a07.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); const _349: Logged.Logged[][] = rows.items; const part31 = at(8); const _352: Logged.Logged = logged(part31); const part32 = at(9); - rt.sliceFill(_349, [_352, logged(part32)], (a08: Logged.Logged[]): Logged.Logged[] => { + rs.sliceFill(_349, [_352, logged(part32)], (a08: Logged.Logged[]): Logged.Logged[] => { return a08.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - _14(rows.items[rt.idx(rows.items, 0)], out); + _14(rows.items[rs.idx(rows.items, 0)], out); const _375: Logged.Logged[][] = []; const part34 = at(10); const _378: Logged.Logged = logged(part34); const part35 = at(11); - rt.sliceFill(_375, [_378, logged(part35)], (a09: Logged.Logged[]): Logged.Logged[] => { + rs.sliceFill(_375, [_378, logged(part35)], (a09: Logged.Logged[]): Logged.Logged[] => { return a09.map(Logged.clone$Clone); - }, drop$array2_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array2_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); - drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged([rows, other2] as [rt.Vec, Logged.Logged[][]]); + drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged([rows, other2] as [rs.Vec, Logged.Logged[][]]); flush(log.value, out); } else if (_15 === 5) { const part14 = len(0); - const _401: rt.Vec = row(0, part14); + const _401: rs.Vec = row(0, part14); const part15 = len(4); - const rows2: rt.Vec> = rt.vecFrom([_401, row(4, part15)]); + const rows2: rs.Vec> = rs.vecFrom([_401, row(4, part15)]); const part16 = len(8); - const _415: rt.Vec = row(8, part16); + const _415: rs.Vec = row(8, part16); const part17 = len(12); - const _421: rt.Vec = row(12, part17); + const _421: rs.Vec = row(12, part17); const part18 = len(16); - const other3: rt.Vec> = rt.vecFrom([_415, _421, row(16, part18)]); - const cut: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 4), (i11: rt.usize): rt.Vec => { - return row(rt.usizeAdd(20, i11), len(rt.usizeAdd(20, i11))); + const other3: rs.Vec> = rs.vecFrom([_415, _421, row(16, part18)]); + const cut: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 4), (i11: rs.usize): rs.Vec => { + return row(rs.usizeAdd(20, i11), len(rs.usizeAdd(20, i11))); }), undefined, 12, true); flush(log.value, out); - rt.vecCloneFrom(rows2, other3, 12, (a03: rt.Vec): rt.Vec => { - return rt.vecFrom(a03.items.map(Logged.clone$Clone)); - }, drop$Vec_clones_Logged, rt.vecCloneFromFn(8, Logged.clone$Clone, rt.drop)); + rs.vecCloneFrom(rows2, other3, 12, (a03: rs.Vec): rs.Vec => { + return rs.vecFrom(a03.items.map(Logged.clone$Clone)); + }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); - rt.vecCloneFrom(cut, other3, 12, (a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.map(Logged.clone$Clone)); - }, drop$Vec_clones_Logged, rt.vecCloneFromFn(8, Logged.clone$Clone, rt.drop)); + rs.vecCloneFrom(cut, other3, 12, (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.map(Logged.clone$Clone)); + }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); - _14(cut.items[rt.idx(cut.items, 0)].items, out); - const _462: rt.usize = len(1); - rt.vecTruncate(rows2, _462, drop$Vec_clones_Logged); - rt.sliceCloneFromSlice(rows2.items, rt.sliceRange(other3.items, 0, rows2.items.length), (a05: rt.Vec): rt.Vec => { - return rt.vecFrom(a05.items.map(Logged.clone$Clone)); - }, drop$Vec_clones_Logged, rt.vecCloneFromFn(8, Logged.clone$Clone, rt.drop)); + _14(cut.items[rs.idx(cut.items, 0)].items, out); + const _462: rs.usize = len(1); + rs.vecTruncate(rows2, _462, drop$Vec_clones_Logged); + rs.sliceCloneFromSlice(rows2.items, rs.sliceRange(other3.items, 0, rows2.items.length), (a05: rs.Vec): rs.Vec => { + return rs.vecFrom(a05.items.map(Logged.clone$Clone)); + }, drop$Vec_clones_Logged, rs.vecCloneFromFn(8, Logged.clone$Clone, rs.drop)); flush(log.value, out); - drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged([rows2, other3, cut] as [rt.Vec>, rt.Vec>, rt.Vec>]); + drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged([rows2, other3, cut] as [rs.Vec>, rs.Vec>, rs.Vec>]); flush(log.value, out); } else if (_15 === 6) { const part7 = len(0); @@ -8015,12 +8015,12 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const part8 = len(4); const b4: Logged.Logged[] = row(4, part8).items; flush(log.value, out); - a4 = rt.boxSliceCloneFrom(a4, b4, Logged.clone$Clone, rt.drop); + a4 = rs.boxSliceCloneFrom(a4, b4, Logged.clone$Clone, rs.drop); flush(log.value, out); _14(a4, out); - const ones: (a0: rt.usize, a1: rt.usize) => Logged.Logged[][] = (from2: rt.usize, n3: rt.usize): Logged.Logged[][] => { - return rt.iterToVec(rt.iterMap(new rt.Range(0, n3), (i10: rt.usize): Logged.Logged[] => { - return [logged(at(rt.usizeAdd(from2, i10)))]; + const ones: (a0: rs.usize, a1: rs.usize) => Logged.Logged[][] = (from2: rs.usize, n3: rs.usize): Logged.Logged[][] => { + return rs.iterToVec(rs.iterMap(new rs.Range(0, n3), (i10: rs.usize): Logged.Logged[] => { + return [logged(at(rs.usizeAdd(from2, i10)))]; }), undefined, 8, true).items; }; const part12 = len(8); @@ -8028,60 +8028,60 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo const part13 = len(12); const d2: Logged.Logged[][] = ones(12, part13); flush(log.value, out); - c3 = rt.boxSliceCloneFrom(c3, d2, (a02: Logged.Logged[]): Logged.Logged[] => { + c3 = rs.boxSliceCloneFrom(c3, d2, (a02: Logged.Logged[]): Logged.Logged[] => { return a02.map(Logged.clone$Clone); - }, drop$array1_clones_Logged, rt.sliceCloneFromSliceFn(Logged.clone$Clone, rt.drop)); + }, drop$array1_clones_Logged, rs.sliceCloneFromSliceFn(Logged.clone$Clone, rs.drop)); flush(log.value, out); drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged([a4, b4, c3, d2] as [Logged.Logged[], Logged.Logged[], Logged.Logged[][], Logged.Logged[][]]); flush(log.value, out); } else { - const kept: (a0: rt.usize) => Kept.Kept = (i5: rt.usize): Kept.Kept => { + const kept: (a0: rs.usize) => Kept.Kept = (i5: rs.usize): Kept.Kept => { return new Kept.Kept(logged(at(i5))); }; - const a5: rt.Vec = rt.vecFrom([kept(0), kept(1)]); - const _555: rt.usize = len(0); - rt.vecTruncate(a5, _555, rt.drop); - const b5: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, len(1)), (i6: rt.usize): Kept.Kept => { - return kept(rt.usizeAdd(2, i6)); + const a5: rs.Vec = rs.vecFrom([kept(0), kept(1)]); + const _555: rs.usize = len(0); + rs.vecTruncate(a5, _555, rs.drop); + const b5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, len(1)), (i6: rs.usize): Kept.Kept => { + return kept(rs.usizeAdd(2, i6)); }), undefined, 8, true); flush(log.value, out); - rt.vecCloneFrom(a5, b5, 8, Kept.clone$Clone, rt.drop, rt.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); + rs.vecCloneFrom(a5, b5, 8, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); flush(log.value, out); const grid2: Kept.Kept[][] = [[kept(5), kept(6)]]; const _586: Kept.Kept[][] = [[kept(7), kept(8)]]; - rt.sliceCloneFromSlice(grid2, _586, (a0: Kept.Kept[]): Kept.Kept[] => { + rs.sliceCloneFromSlice(grid2, _586, (a0: Kept.Kept[]): Kept.Kept[] => { return a0.map(Kept.clone$Clone); - }, drop$array2_clones_Kept, rt.sliceCloneFromSliceFn(Kept.clone$Clone, rt.drop, rt.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined))); - rt.dropAll(_586, drop$array2_clones_Kept); + }, drop$array2_clones_Kept, rs.sliceCloneFromSliceFn(Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined))); + rs.dropAll(_586, drop$array2_clones_Kept); flush(log.value, out); let some: Kept.Kept | undefined = kept(9); const _604: Kept.Kept | undefined = kept(10); - some = rt.optionCloneFrom(some, _604, Kept.clone$Clone, rt.drop, rt.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); - rt.drop(_604); + some = rs.optionCloneFrom(some, _604, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); + rs.drop(_604); flush(log.value, out); - const slot: (a0: rt.usize) => Slot.Slot = (i7: rt.usize): Slot.Slot => { - if (rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i7), 0), 3) === 0) { + const slot: (a0: rs.usize) => Slot.Slot = (i7: rs.usize): Slot.Slot => { + if (rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i7), 0), 3) === 0) { return { tag: "Empty" } as Slot.Slot; } return { tag: "Held", _0: kept(i7) } as Slot.Slot; }; const slots: Slot.Slot[] = [slot(11), slot(12)]; const _623: Slot.Slot[] = [slot(13), slot(14)]; - rt.sliceCloneFromSlice(slots, _623, Slot.clone$Clone, drop$clones_Slot, rt.cloneFromPlaceFn(Slot.cloneFrom$Clone as (a0: rt.Place, a1: Slot.Slot) => undefined)); - rt.dropAll(_623, drop$clones_Slot); + rs.sliceCloneFromSlice(slots, _623, Slot.clone$Clone, drop$clones_Slot, rs.cloneFromPlaceFn(Slot.cloneFrom$Clone as (a0: rs.Place, a1: Slot.Slot) => undefined)); + rs.dropAll(_623, drop$clones_Slot); flush(log.value, out); - const _634: rt.Iter = rt.iterMap(new rt.Range(0, len(15)), (i8: rt.usize): Kept.Kept => { - return kept(rt.usizeAdd(16, i8)); + const _634: rs.Iter = rs.iterMap(new rs.Range(0, len(15)), (i8: rs.usize): Kept.Kept => { + return kept(rs.usizeAdd(16, i8)); }); - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _634); - const _642: rt.Iter = rt.iterMap(new rt.Range(0, len(20)), (i9: rt.usize): Kept.Kept => { - return kept(rt.usizeAdd(21, i9)); + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _634); + const _642: rs.Iter = rs.iterMap(new rs.Range(0, len(20)), (i9: rs.usize): Kept.Kept => { + return kept(rs.usizeAdd(21, i9)); }); - const other4: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _642); + const other4: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _642); flush(log.value, out); - rt.listCloneFrom(list, other4, Kept.clone$Clone, rt.drop, rt.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); + rs.listCloneFrom(list, other4, Kept.clone$Clone, rs.drop, rs.cloneFromFn(Kept.cloneFrom$Clone as (a0: Kept.Kept, a1: Kept.Kept) => undefined)); flush(log.value, out); - drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept([a5, b5, grid2, some, slots, list, other4] as [rt.Vec, rt.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rt.LinkedList, rt.LinkedList]); + drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept([a5, b5, grid2, some, slots, list, other4] as [rs.Vec, rs.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rs.LinkedList, rs.LinkedList]); flush(log.value, out); } log[Symbol.dispose](); @@ -8093,157 +8093,157 @@ export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo * `Logged`, its own `Clone`, an array, an `Option`, a tuple, nested `Vec`s, and through a * generic function, with `n` from the input. */ -export function repeats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function repeats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let slot!: Slot.Slot; - const _11: (a0: Logged.Logged[], a1: rt.ByteVec) => undefined = (a: Logged.Logged[], out2: rt.ByteVec): undefined => { - rt.iterExtendBytes(out2, rt.iterMap(rt.iterSlice(a), Logged.id), undefined, true); + const _11: (a0: Logged.Logged[], a1: rs.ByteVec) => undefined = (a: Logged.Logged[], out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterMap(rs.iterSlice(a), Logged.id), undefined, true); }; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), rt.u8WrappingMul(i & 0xff, 48)) & 126; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), rs.u8WrappingMul(i & 0xff, 48)) & 126; }; - const n: (a0: rt.usize) => rt.usize = (i2: rt.usize): rt.usize => { - return rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), i2 & 0xff), 5) as rt.usize; + const n: (a0: rs.usize) => rs.usize = (i2: rs.usize): rs.usize => { + return rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), i2 & 0xff), 5) as rs.usize; }; - const _12: rt.u8 = rt.u8Rem(kind, 8); + const _12: rs.u8 = rs.u8Rem(kind, 8); if (_12 === 0) { const part18 = at(0); - const v: rt.Vec = rt.vecFromElem(logged(part18), n(1), Logged.clone$Clone, rt.drop); + const v: rs.Vec = rs.vecFromElem(logged(part18), n(1), Logged.clone$Clone, rs.drop); flush(log.value, out); _11(v.items, out); - rt.byteVecPush(out, rt.vecCapacity(v, 8) & 0xff); - rt.dropVec(v); + rs.byteVecPush(out, rs.vecCapacity(v, 8) & 0xff); + rs.dropVec(v); flush(log.value, out); } else if (_12 === 1) { - const row: rt.Vec = rt.vecWithCapacity(6, 8); - const _43: rt.Iter = rt.iterMap(new rt.Range(0, n(1)), (i3: rt.usize): Logged.Logged => { - return logged(at(rt.usizeAdd(2, i3))); + const row: rs.Vec = rs.vecWithCapacity(6, 8); + const _43: rs.Iter = rs.iterMap(new rs.Range(0, n(1)), (i3: rs.usize): Logged.Logged => { + return logged(at(rs.usizeAdd(2, i3))); }); - rt.iterExtend(row, _43, undefined, 8, true); - const v2: rt.Vec> = rt.vecFromElem(row, n(0), (a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.map(Logged.clone$Clone)); + rs.iterExtend(row, _43, undefined, 8, true); + const v2: rs.Vec> = rs.vecFromElem(row, n(0), (a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); flush(log.value, out); for (const _62 of v2.items) { _11(_62.items, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(254, rt.vecCapacity(_62, 8) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(254, rs.vecCapacity(_62, 8) & 0xff)), undefined, true); } - rt.dropVec(v2, drop$Vec_clones_Logged); + rs.dropVec(v2, drop$Vec_clones_Logged); flush(log.value, out); } else if (_12 === 2) { const part14 = at(0); const _80: Logged.Logged = logged(part14); const part15 = at(1); - const v3: rt.Vec = rt.vecFromElem([_80, logged(part15)], n(2), (a03: Logged.Logged[]): Logged.Logged[] => { + const v3: rs.Vec = rs.vecFromElem([_80, logged(part15)], n(2), (a03: Logged.Logged[]): Logged.Logged[] => { return a03.map(Logged.clone$Clone); }, drop$array2_clones_Logged); flush(log.value, out); - rt.iterForEach(rt.iterSlice(v3.items), (row3: Logged.Logged[]): undefined => { + rs.iterForEach(rs.iterSlice(v3.items), (row3: Logged.Logged[]): undefined => { _11(row3, out); }); - rt.dropVec(v3, drop$array2_clones_Logged); + rs.dropVec(v3, drop$array2_clones_Logged); flush(log.value, out); } else if (_12 === 3) { const part12 = at(0); - const v4: rt.Vec = rt.vecFromElem(new Kept.Kept(logged(part12)), n(1), Kept.clone$Clone, rt.drop); + const v4: rs.Vec = rs.vecFromElem(new Kept.Kept(logged(part12)), n(1), Kept.clone$Clone, rs.drop); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v4.items), (k: Kept.Kept): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v4.items), (k: Kept.Kept): rs.u8 => { return Logged.id(k._0); }), undefined, true); - rt.dropVec(v4); + rs.dropVec(v4); flush(log.value, out); - if (rt.u8Rem(at(2), 3) === 0) { + if (rs.u8Rem(at(2), 3) === 0) { slot = { tag: "Empty" } as Slot.Slot; } else { const part13 = at(3); slot = { tag: "Held", _0: new Kept.Kept(logged(part13)) } as Slot.Slot; } - const slots: rt.Vec = rt.vecFromElem(slot, n(4), Slot.clone$Clone, drop$clones_Slot); + const slots: rs.Vec = rs.vecFromElem(slot, n(4), Slot.clone$Clone, drop$clones_Slot); flush(log.value, out); - rt.dropVec(slots, drop$clones_Slot); + rs.dropVec(slots, drop$clones_Slot); flush(log.value, out); } else if (_12 === 4) { const part10 = at(0); - const some: rt.Vec = rt.vecFromElem(logged(part10), n(1), option_clone$1jx0028, rt.drop); - const none: rt.Vec = rt.vecFromElem(undefined as Logged.Logged | undefined, n(2), option_clone$1jx0028, rt.drop); + const some: rs.Vec = rs.vecFromElem(logged(part10), n(1), option_clone$1jx0028, rs.drop); + const none: rs.Vec = rs.vecFromElem(undefined as Logged.Logged | undefined, n(2), option_clone$1jx0028, rs.drop); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(some.items), (x: Logged.Logged | undefined): rt.u8 => { - return option_mapOr$1yabfom(x, 254, Logged.id); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(some.items), (x: Logged.Logged | undefined): rs.u8 => { + return option_mapOr$15gmqsv(x, 254, Logged.id); }), undefined, true); - rt.byteVecPush(out, none.items.length & 0xff); + rs.byteVecPush(out, none.items.length & 0xff); const part11 = at(3); - const _194: rt.u8 = at(4); - const pairs: rt.Vec<[Logged.Logged, string]> = rt.vecFromElem([logged(part11), rt.fmtToString((f: rt.Formatter) => rt.u8Display(_194, f))] as [Logged.Logged, string], n(5), (a02: [Logged.Logged, string]): [Logged.Logged, string] => { - return rt.tupleClone(a02, [Logged.clone$Clone, undefined]); + const _194: rs.u8 = at(4); + const pairs: rs.Vec<[Logged.Logged, string]> = rs.vecFromElem([logged(part11), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_194, f))] as [Logged.Logged, string], n(5), (a02: [Logged.Logged, string]): [Logged.Logged, string] => { + return rs.tupleClone(a02, [Logged.clone$Clone, undefined]); }, drop$tuple2_clones_Logged_String); flush(log.value, out); - rt.iterForEach(rt.iterSlice(pairs.items), (_2: [Logged.Logged, string]): undefined => { - rt.iterExtendBytes(out, rt.iterChain(rt.strBytes(_2[1]), rt.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); + rs.iterForEach(rs.iterSlice(pairs.items), (_2: [Logged.Logged, string]): undefined => { + rs.iterExtendBytes(out, rs.iterChain(rs.strBytes(_2[1]), rs.iterSlice(Uint8Array.of(Logged.id(_2[0])))), undefined, true); }); - drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rt.Vec, rt.Vec, rt.Vec<[Logged.Logged, string]>]); + drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String([some, none, pairs] as [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]); flush(log.value, out); } else if (_12 === 5) { const part8 = at(0); - const v5: rt.Vec> = rt.vecFromElem(rt.vecFromElem(logged(part8), n(1), Logged.clone$Clone, rt.drop), n(2), (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.map(Logged.clone$Clone)); + const v5: rs.Vec> = rs.vecFromElem(rs.vecFromElem(logged(part8), n(1), Logged.clone$Clone, rs.drop), n(2), (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); flush(log.value, out); - rt.iterForEach(rt.iterSlice(v5.items), (row2: rt.Vec): undefined => { + rs.iterForEach(rs.iterSlice(v5.items), (row2: rs.Vec): undefined => { _11(row2.items, out); }); - rt.dropVec(v5, drop$Vec_clones_Logged); + rs.dropVec(v5, drop$Vec_clones_Logged); flush(log.value, out); } else if (_12 === 6) { - const count: () => rt.usize = (): rt.usize => { - const _510: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_510.value, 251); - rt.refMutRelease(_510); + const count: () => rs.usize = (): rs.usize => { + const _510: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_510.value, 251); + rs.refMutRelease(_510); return n(1); }; const part5 = at(0); - const v6: rt.Vec = rt.vecFromElem(logged(part5), count(), Logged.clone$Clone, rt.drop); - const _255: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_255.value, 250); - rt.refMutRelease(_255); + const v6: rs.Vec = rs.vecFromElem(logged(part5), count(), Logged.clone$Clone, rs.drop); + const _255: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_255.value, 250); + rs.refMutRelease(_255); flush(log.value, out); _11(v6.items, out); const part7 = at(2); - const empty: rt.Vec = rt.vecFromElem(logged(part7), 0, Logged.clone$Clone, rt.drop); - const _276: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_276.value, 250); - rt.refMutRelease(_276); + const empty: rs.Vec = rs.vecFromElem(logged(part7), 0, Logged.clone$Clone, rs.drop); + const _276: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_276.value, 250); + rs.refMutRelease(_276); flush(log.value, out); - drop$tuple2_Vec_clones_Logged_Vec_clones_Logged([v6, empty] as [rt.Vec, rt.Vec]); + drop$tuple2_Vec_clones_Logged_Vec_clones_Logged([v6, empty] as [rs.Vec, rs.Vec]); flush(log.value, out); } else { const part = at(0); - const v7: rt.Vec = repeated$clones_Logged(logged(part), n(1)); + const v7: rs.Vec = repeated$clones_Logged(logged(part), n(1)); flush(log.value, out); _11(v7.items, out); const part3 = at(2); const _308: Logged.Logged = logged(part3); const part4 = at(3); - const rows: rt.Vec> = repeated$Vec_clones_Logged(rt.vecFrom([_308, logged(part4)]), n(4)); + const rows: rs.Vec> = repeated$Vec_clones_Logged(rs.vecFrom([_308, logged(part4)]), n(4)); flush(log.value, out); - drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged([v7, rows] as [rt.Vec, rt.Vec>]); + drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged([v7, rows] as [rs.Vec, rs.Vec>]); flush(log.value, out); } log[Symbol.dispose](); } /** `vec![x; n]` where only its bound says `x` clones. */ -export function repeated$Vec_clones_Logged(x: rt.Vec, n: rt.usize): rt.Vec> { - return rt.vecFromElem(x, n, (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.map(Logged.clone$Clone)); +export function repeated$Vec_clones_Logged(x: rs.Vec, n: rs.usize): rs.Vec> { + return rs.vecFromElem(x, n, (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.map(Logged.clone$Clone)); }, drop$Vec_clones_Logged); } /** `vec![x; n]` where only its bound says `x` clones. */ -export function repeated$clones_Logged(x: Logged.Logged, n: rt.usize): rt.Vec { - return rt.vecFromElem(x, n, Logged.clone$Clone, rt.drop); +export function repeated$clones_Logged(x: Logged.Logged, n: rs.usize): rs.Vec { + return rs.vecFromElem(x, n, Logged.clone$Clone, rs.drop); } /** @@ -8253,272 +8253,272 @@ export function repeated$clones_Logged(x: Logged.Logged, n: rt.usize): rt.Vec rt.u8 = (x2: Logged.Logged | undefined): rt.u8 => { - return option_mapOr$0bq8trh(x2, 238, (x3: Logged.Logged): rt.u8 => { - const _02: rt.u8 = Logged.id(x3); + const _11: (a0: Logged.Logged | undefined) => rs.u8 = (x2: Logged.Logged | undefined): rs.u8 => { + return option_mapOr$1ughiwf(x2, 238, (x3: Logged.Logged): rs.u8 => { + const _02: rs.u8 = Logged.id(x3); x3[Symbol.dispose](); return _02; }); }; - const _12: (a0: [rt.usize, rt.usize | undefined]) => Uint8Array = (hint: [rt.usize, rt.usize | undefined]): Uint8Array => { - return Uint8Array.of(rt.min(hint[0], 253) & 0xff, option_mapOr$02k4ito(hint[1], 254, (n2: rt.usize): rt.u8 => { + const _12: (a0: [rs.usize, rs.usize | undefined]) => Uint8Array = (hint: [rs.usize, rs.usize | undefined]): Uint8Array => { + return Uint8Array.of(rs.min(hint[0], 253) & 0xff, option_mapOr$188iunt(hint[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; })); }; - const _501: (a0: Logged.Logged) => rt.u8 = (x4: Logged.Logged): rt.u8 => { + const _501: (a0: Logged.Logged) => rs.u8 = (x4: Logged.Logged): rs.u8 => { return Logged.id(x4); }; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), rt.u8WrappingMul(i2 & 0xff, 48)) & 126; + const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), rs.u8WrappingMul(i2 & 0xff, 48)) & 126; }; - const n: (a0: rt.usize) => rt.usize = (i3: rt.usize): rt.usize => { - return rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i3), i3 & 0xff), 5) as rt.usize; + const n: (a0: rs.usize) => rs.usize = (i3: rs.usize): rs.usize => { + return rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), i3 & 0xff), 5) as rs.usize; }; - const _13: rt.u8 = rt.u8Rem(kind, 6); + const _13: rs.u8 = rs.u8Rem(kind, 6); if (_13 === 0) { const part27 = at(0); - const it: rt.Iter = rt.iterRepeat(logged(part27), Logged.clone$Clone, rt.drop); + const it: rs.Iter = rs.iterRepeat(logged(part27), Logged.clone$Clone, rs.drop); const part28 = it.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(_12(part28)), undefined, true); - const part29 = rt.iterToOption(it.next()); - rt.byteVecPush(out, _11(part29)); - const part30 = rt.iterToOption(it.nextBack()); - rt.byteVecPush(out, _11(part30)); - const _46: rt.usize = n(1); - const part31 = rt.iterNth(it, _46, rt.drop); - rt.byteVecPush(out, _11(part31)); - const _55: rt.usize = n(2); - const part32 = rt.iterNthBack(it, _55, rt.drop); - rt.byteVecPush(out, _11(part32)); + rs.iterExtendBytes(out, rs.iterSlice(_12(part28)), undefined, true); + const part29 = rs.iterToOption(it.next()); + rs.byteVecPush(out, _11(part29)); + const part30 = rs.iterToOption(it.nextBack()); + rs.byteVecPush(out, _11(part30)); + const _46: rs.usize = n(1); + const part31 = rs.iterNth(it, _46, rs.drop); + rs.byteVecPush(out, _11(part31)); + const _55: rs.usize = n(2); + const part32 = rs.iterNthBack(it, _55, rs.drop); + rs.byteVecPush(out, _11(part32)); flush(log.value, out); - const clone: rt.Iter = it.clone(); + const clone: rs.Iter = it.clone(); flush(log.value, out); - rt.drop(it); + rs.drop(it); flush(log.value, out); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterRev(rt.iterTake(clone.clone(), n(3), rt.drop)), (x11: Logged.Logged): rt.u8 => { - const _024: rt.u8 = Logged.id(x11); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterRev(rs.iterTake(clone.clone(), n(3), rs.drop)), (x11: Logged.Logged): rs.u8 => { + const _024: rs.u8 = Logged.id(x11); x11[Symbol.dispose](); return _024; }), "fold", true)), undefined, true); flush(log.value, out); - const _85: rt.usize = n(4); - const taken2: rt.Iter = rt.iterTake(clone, _85, rt.drop); - const part33 = rt.iterToOption(taken2.nextBack()); - rt.byteVecPush(out, _11(part33)); - const part34 = rt.iterNthBack(taken2, 1, rt.drop); - rt.byteVecPush(out, _11(part34)); - rt.byteVecPush(out, taken2.len() & 0xff); + const _85: rs.usize = n(4); + const taken2: rs.Iter = rs.iterTake(clone, _85, rs.drop); + const part33 = rs.iterToOption(taken2.nextBack()); + rs.byteVecPush(out, _11(part33)); + const part34 = rs.iterNthBack(taken2, 1, rs.drop); + rs.byteVecPush(out, _11(part34)); + rs.byteVecPush(out, taken2.len() & 0xff); const part35 = taken2.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(_12(part35)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_12(part35)), undefined, true); flush(log.value, out); - rt.byteVecPush(out, rt.iterRfold(taken2, 0, (acc: rt.u8, x12: Logged.Logged): rt.u8 => { - const _025: rt.u8 = rt.u8WrappingAdd(acc, Logged.id(x12)); + rs.byteVecPush(out, rs.iterRfold(taken2, 0, (acc: rs.u8, x12: Logged.Logged): rs.u8 => { + const _025: rs.u8 = rs.u8WrappingAdd(acc, Logged.id(x12)); x12[Symbol.dispose](); return _025; }, true)); flush(log.value, out); } else if (_13 === 1) { const part24 = at(0); - const it2: rt.Iter = rt.iterRepeatN(logged(part24), n(1), Logged.clone$Clone, rt.drop); - let iterStart: rt.usize = 2; - const iterEnd: rt.usize = 8; + const it2: rs.Iter = rs.iterRepeatN(logged(part24), n(1), Logged.clone$Clone, rs.drop); + let iterStart: rs.usize = 2; + const iterEnd: rs.usize = 8; while ((_132 = iterStart++) < iterEnd) { - const i: rt.usize = _132; - const _137: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0), 4); + const i: rs.usize = _132; + const _137: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0), 4); if (_137 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_137 === 1) { - item = rt.iterToOption(it2.nextBack()); + item = rs.iterToOption(it2.nextBack()); } else if (_137 === 2) { - const _145: rt.usize = rt.usizeRem(n(rt.usizeAdd(i, 8)), 3); - item = rt.iterNth(it2, _145, rt.drop); + const _145: rs.usize = rs.usizeRem(n(rs.usizeAdd(i, 8)), 3); + item = rs.iterNth(it2, _145, rs.drop); } else { - const _153: rt.usize = rt.usizeRem(n(rt.usizeAdd(i, 8)), 3); - item = rt.iterNthBack(it2, _153, rt.drop); + const _153: rs.usize = rs.usizeRem(n(rs.usizeAdd(i, 8)), 3); + item = rs.iterNthBack(it2, _153, rs.drop); } - rt.byteVecPush(out, _11(item)); - rt.byteVecPush(out, it2.len() & 0xff); + rs.byteVecPush(out, _11(item)); + rs.byteVecPush(out, it2.len() & 0xff); flush(log.value, out); if (i === 4) { - const clone2: rt.Iter = it2.clone(); + const clone2: rs.Iter = it2.clone(); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(clone2, (x10: Logged.Logged): rt.u8 => { - const _023: rt.u8 = Logged.id(x10); + rs.iterExtendBytes(out, rs.iterMap(clone2, (x10: Logged.Logged): rs.u8 => { + const _023: rs.u8 = Logged.id(x10); x10[Symbol.dispose](); return _023; }), "fold", true); flush(log.value, out); } } - rt.drop(it2); + rs.drop(it2); flush(log.value, out); } else if (_13 === 2) { const part13 = at(0); - rt.byteVecPush(out, rt.ownedCount(rt.iterRepeatN(logged(part13), n(1), Logged.clone$Clone, rt.drop), rt.drop) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterRepeatN(logged(part13), n(1), Logged.clone$Clone, rs.drop), rs.drop) & 0xff); flush(log.value, out); const part14 = at(1); - const part15 = rt.ownedLast(rt.iterRepeatN(logged(part14), n(2), Logged.clone$Clone, rt.drop), rt.drop); - rt.byteVecPush(out, _11(part15)); + const part15 = rs.ownedLast(rs.iterRepeatN(logged(part14), n(2), Logged.clone$Clone, rs.drop), rs.drop); + rs.byteVecPush(out, _11(part15)); flush(log.value, out); const part16 = at(2); - const all: rt.Vec = rt.iterToVec(rt.iterRepeatN(logged(part16), n(3), Logged.clone$Clone, rt.drop), "fold", 8, true); + const all: rs.Vec = rs.iterToVec(rs.iterRepeatN(logged(part16), n(3), Logged.clone$Clone, rs.drop), "fold", 8, true); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(all.items), Logged.id), undefined, true); - rt.dropVec(all); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(all.items), Logged.id), undefined, true); + rs.dropVec(all); flush(log.value, out); - rt.byteVecPush(out, rt.ownedCount(rt.iterRepeatN(at(3), n(4))) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.ownedLast(rt.iterRepeatN(at(4), n(5))), 238)); + rs.byteVecPush(out, rs.ownedCount(rs.iterRepeatN(at(3), n(4))) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterRepeatN(at(4), n(5))), 238)); const part17 = at(5); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterRev(rt.iterTake(rt.iterRepeatN(logged(part17), n(6), Logged.clone$Clone, rt.drop), n(7), rt.drop)), (x9: Logged.Logged): rt.u8 => { - const _019: rt.u8 = Logged.id(x9); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterRev(rs.iterTake(rs.iterRepeatN(logged(part17), n(6), Logged.clone$Clone, rs.drop), n(7), rs.drop)), (x9: Logged.Logged): rs.u8 => { + const _019: rs.u8 = Logged.id(x9); x9[Symbol.dispose](); return _019; }), "fold", true)), undefined, true); flush(log.value, out); - const counted: (a0: rt.u8) => Counted.Counted = (id2: rt.u8): Counted.Counted => { + const counted: (a0: rs.u8) => Counted.Counted = (id2: rs.u8): Counted.Counted => { return { id: id2, log: log.value }; }; const part18 = at(7); - const _289: rt.Iter = rt.iterRepeatN(counted(part18), n(8), Counted.clone$Clone); - rt.iterEmpty(); - rt.byteVecPush(out, rt.ownedCount(rt.iterChain(_289, rt.iterEmpty() as rt.Iter)) & 0xff); + const _289: rs.Iter = rs.iterRepeatN(counted(part18), n(8), Counted.clone$Clone); + rs.iterEmpty(); + rs.byteVecPush(out, rs.ownedCount(rs.iterChain(_289, rs.iterEmpty() as rs.Iter)) & 0xff); flush(log.value, out); - rt.iterEmpty(); + rs.iterEmpty(); const part19 = at(9); - const _308: rt.Iter = rt.iterRepeatN(counted(part19), n(10), Counted.clone$Clone); - rt.byteVecPush(out, option_mapOr$0w6m9d0(rt.ownedLast(rt.iterChain(rt.iterEmpty() as rt.Iter, _308)), 238, (c2: Counted.Counted): rt.u8 => { + const _308: rs.Iter = rs.iterRepeatN(counted(part19), n(10), Counted.clone$Clone); + rs.byteVecPush(out, option_mapOr$0ngwgbd(rs.ownedLast(rs.iterChain(rs.iterEmpty() as rs.Iter, _308)), 238, (c2: Counted.Counted): rs.u8 => { return c2.id; })); flush(log.value, out); - rt.byteVecPush(out, rt.ownedCount(rt.iterFlatten(rt.iterOnceWith((): rt.Iter => { - return rt.iterRepeatN({ id: 17, log: log.value }, 3, Counted.clone$Clone); + rs.byteVecPush(out, rs.ownedCount(rs.iterFlatten(rs.iterOnceWith((): rs.Iter => { + return rs.iterRepeatN({ id: 17, log: log.value }, 3, Counted.clone$Clone); }), undefined, true)) & 0xff); flush(log.value, out); const part20 = at(11); - rt.byteVecPush(out, rt.ownedCount(rt.iterFuse(rt.iterRepeatN(logged(part20), n(12), Logged.clone$Clone, rt.drop), true), rt.drop) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterFuse(rs.iterRepeatN(logged(part20), n(12), Logged.clone$Clone, rs.drop), true), rs.drop) & 0xff); flush(log.value, out); const part21 = at(6); - const zero: rt.Iter = rt.iterRepeatN(logged(part21), 0, Logged.clone$Clone, rt.drop); + const zero: rs.Iter = rs.iterRepeatN(logged(part21), 0, Logged.clone$Clone, rs.drop); flush(log.value, out); - const part22 = rt.iterToOption(zero.next()); - rt.byteVecPush(out, _11(part22)); + const part22 = rs.iterToOption(zero.next()); + rs.byteVecPush(out, _11(part22)); const part23 = zero.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(_12(part23)), undefined, true); - rt.drop(zero); + rs.iterExtendBytes(out, rs.iterSlice(_12(part23)), undefined, true); + rs.drop(zero); } else if (_13 === 3) { - if (!isSomeAnd$09tpccf(rt.byteSliceFirst(data), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 0; + if (!isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 0; })) { const part12 = at(1); - rt.byteVecPush(out, option_mapOr$0bq8trh(rt.ownedLast(rt.iterRepeat(logged(part12), Logged.clone$Clone, rt.drop), rt.drop), 238, (x8: Logged.Logged): rt.u8 => { - const _018: rt.u8 = Logged.id(x8); + rs.byteVecPush(out, option_mapOr$1ughiwf(rs.ownedLast(rs.iterRepeat(logged(part12), Logged.clone$Clone, rs.drop), rs.drop), 238, (x8: Logged.Logged): rs.u8 => { + const _018: rs.u8 = Logged.id(x8); x8[Symbol.dispose](); return _018; })); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterRepeat(at(1))) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterRepeat(at(1))) & 0xff); } } else if (_13 === 4) { const part5 = at(0); const a: Logged.Logged = logged(part5); - const make2 = (captured: Logged.Logged): () => rt.u8 => { - return rt.closure(rt.cloning((): rt.u8 => { - const _013: rt.u8 = Logged.id(captured) ^ 85; + const make2 = (captured: Logged.Logged): () => rs.u8 => { + return rs.closure(rs.cloning((): rs.u8 => { + const _013: rs.u8 = Logged.id(captured) ^ 85; captured[Symbol.dispose](); return _013; }, () => make2(Logged.clone$Clone(captured))), (): void => { captured[Symbol.dispose](); }); }; - const it6: rt.Iter = rt.iterOnceWith(make2(a)); + const it6: rs.Iter = rs.iterOnceWith(make2(a)); const part6 = it6.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(_12(part6)), undefined, true); - const clone3: rt.Iter = it6.clone({ f: rt.closureClone }); + rs.iterExtendBytes(out, rs.iterSlice(_12(part6)), undefined, true); + const clone3: rs.Iter = it6.clone({ f: rs.closureClone }); flush(log.value, out); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it6.nextBack()), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it6.nextBack()), 238)); flush(log.value, out); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it6.next()), 238)); - rt.byteVecPush(out, it6.len() & 0xff); - rt.drop(it6); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it6.next()), 238)); + rs.byteVecPush(out, it6.len() & 0xff); + rs.drop(it6); flush(log.value, out); - rt.iterExtendBytes(out, clone3, "fold", true); + rs.iterExtendBytes(out, clone3, "fold", true); flush(log.value, out); const part7 = at(1); const captured2 = logged(part7); - const it7: rt.Iter = rt.iterOnceWith(rt.closure((): Logged.Logged => { + const it7: rs.Iter = rs.iterOnceWith(rs.closure((): Logged.Logged => { return captured2; }, (): void => { captured2[Symbol.dispose](); })); flush(log.value, out); - const part8 = rt.iterToOption(it7.next()); - rt.byteVecPush(out, _11(part8)); + const part8 = rs.iterToOption(it7.next()); + rs.byteVecPush(out, _11(part8)); flush(log.value, out); const part9 = at(2); const captured3 = logged(part9); - const it8: rt.Iter = rt.iterOnceWith(rt.closure((): rt.u8 => { - const _015: rt.u8 = Logged.id(captured3); + const it8: rs.Iter = rs.iterOnceWith(rs.closure((): rs.u8 => { + const _015: rs.u8 = Logged.id(captured3); captured3[Symbol.dispose](); return _015; }, (): void => { captured3[Symbol.dispose](); })); flush(log.value, out); - rt.drop(it8); + rs.drop(it8); flush(log.value, out); const part10 = at(3); const captured4 = logged(part10); - const f: () => rt.u8 = rt.closure((): rt.u8 => { + const f: () => rs.u8 = rs.closure((): rs.u8 => { return Logged.id(captured4) ^ 51; }, (): void => { captured4[Symbol.dispose](); }); - rt.byteVecPush(out, f()); - const it9: rt.Iter = rt.iterOnceWith(rt.once(f)); + rs.byteVecPush(out, f()); + const it9: rs.Iter = rs.iterOnceWith(rs.once(f)); const part11 = it9.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(_12(part11)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_12(part11)), undefined, true); flush(log.value, out); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it9.next()), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it9.next()), 238)); flush(log.value, out); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it9.next()), 238)); - rt.drop(it9); - rt.drop(it7); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it9.next()), 238)); + rs.drop(it9); + rs.drop(it7); } else { const part = at(0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterTake(rt.iterRepeat(logged(part), Logged.clone$Clone, rt.drop), n(1), rt.drop), (x5: Logged.Logged): rt.u8 => { - const _09: rt.u8 = Logged.id(x5) ^ 1; + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(rs.iterRepeat(logged(part), Logged.clone$Clone, rs.drop), n(1), rs.drop), (x5: Logged.Logged): rs.u8 => { + const _09: rs.u8 = Logged.id(x5) ^ 1; x5[Symbol.dispose](); return _09; }), "fold", true); flush(log.value, out); const part2 = at(1); - for (const _539 of rt.iterToVec(rt.iterMap(rt.iterZip(rt.iterRepeatN(logged(part2), n(2), Logged.clone$Clone, rt.drop), rt.iterRepeat(at(3)), "len", rt.drop), (_2: [Logged.Logged, rt.u8]): [rt.u8, rt.u8] => { + for (const _539 of rs.iterToVec(rs.iterMap(rs.iterZip(rs.iterRepeatN(logged(part2), n(2), Logged.clone$Clone, rs.drop), rs.iterRepeat(at(3)), "len", rs.drop), (_2: [Logged.Logged, rs.u8]): [rs.u8, rs.u8] => { const x6: Logged.Logged = _2[0]; - const y2: rt.u8 = _2[1]; - const _010: [rt.u8, rt.u8] = [_501(x6), y2]; + const y2: rs.u8 = _2[1]; + const _010: [rs.u8, rs.u8] = [_501(x6), y2]; x6[Symbol.dispose](); return _010; }), "fold", 2, true).items) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_539[0], _539[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_539[0], _539[1])), undefined, true); } flush(log.value, out); const part4 = at(4); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterSkip(rt.iterRepeatN(logged(part4), n(5), Logged.clone$Clone, rt.drop), n(6), rt.drop), (x7: Logged.Logged): rt.u8 => { - const _011: rt.u8 = Logged.id(x7); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterSkip(rs.iterRepeatN(logged(part4), n(5), Logged.clone$Clone, rs.drop), n(6), rs.drop), (x7: Logged.Logged): rs.u8 => { + const _011: rs.u8 = Logged.id(x7); x7[Symbol.dispose](); return _011; }), "next")), undefined, true); flush(log.value, out); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterOnceWith((): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterRev(rs.iterChain(rs.iterOnceWith((): rs.u8 => { return at(7); - }), rt.iterRepeatN(at(8), n(9)))), undefined, true)), undefined, true); + }), rs.iterRepeatN(at(8), n(9)))), undefined, true)), undefined, true); } flush(log.value, out); log[Symbol.dispose](); diff --git a/ts/fixtures/lang/clones/expected/core/bool.ts b/ts/fixtures/lang/clones/expected/core/bool.ts index d433130c6..a498c7463 100644 --- a/ts/fixtures/lang/clones/expected/core/bool.ts +++ b/ts/fixtures/lang/clones/expected/core/bool.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Logged from "../clones.Logged.ts"; -export function then$0415f7q(self: boolean, f: () => rt.Vec): rt.Vec | undefined { +export function then$0ba40i0(self: boolean, f: () => rs.Vec): rs.Vec | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/clones/expected/core/option.ts b/ts/fixtures/lang/clones/expected/core/option.ts index 0de06da97..2f24cdc7c 100644 --- a/ts/fixtures/lang/clones/expected/core/option.ts +++ b/ts/fixtures/lang/clones/expected/core/option.ts @@ -1,59 +1,59 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Counted from "../clones.Counted.ts"; import * as Logged from "../clones.Logged.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0y3liwu(self: rt.u8 | undefined, f: (a0: rt.u8) => Logged.Logged): Logged.Logged | undefined { +export function map$1kvcy6m(self: rs.u8 | undefined, f: (a0: rs.u8) => Logged.Logged): Logged.Logged | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$0w6m9d0(self: Counted.Counted | undefined, default_: rt.u8, f: (a0: Counted.Counted) => rt.u8): rt.u8 { +export function mapOr$0ngwgbd(self: Counted.Counted | undefined, default_: rs.u8, f: (a0: Counted.Counted) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0bq8trh(self: Logged.Logged | undefined, default_: rt.u8, f: (a0: Logged.Logged) => rt.u8): rt.u8 { +export function mapOr$1ughiwf(self: Logged.Logged | undefined, default_: rs.u8, f: (a0: Logged.Logged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1yabfom(self: Logged.Logged | undefined, default_: rt.u8, _: (a0: Logged.Logged) => rt.u8): rt.u8 { +export function mapOr$15gmqsv(self: Logged.Logged | undefined, default_: rs.u8, _: (a0: Logged.Logged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return Logged.id(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/clones/expected/harness.ts b/ts/fixtures/lang/clones/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/clones/expected/harness.ts +++ b/ts/fixtures/lang/clones/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/clones/expected/lib.ts b/ts/fixtures/lang/clones/expected/lib.ts index 5f8086433..5779f50fe 100644 --- a/ts/fixtures/lang/clones/expected/lib.ts +++ b/ts/fixtures/lang/clones/expected/lib.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { iters, arrays, cloneFroms, repeats, sources } from "./clones.ts"; import type * as Kept from "./clones.Kept.ts"; import type * as Logged from "./clones.Logged.ts"; import type * as Pair from "./clones.Pair.ts"; import type * as Slot from "./clones.Slot.ts"; -export function drop$Vec_clones_Logged(value: rt.Vec): void { - rt.dropVec(value); +export function drop$Vec_clones_Logged(value: rs.Vec): void { + rs.dropVec(value); } export function drop$array1_clones_Logged(value: Logged.Logged[]): void { - rt.dropAll(value); + rs.dropAll(value); } export function drop$array2_clones_Kept(value: Kept.Kept[]): void { - rt.dropAll(value); + rs.dropAll(value); } export function drop$array2_clones_Logged(value: Logged.Logged[]): void { - rt.dropAll(value); + rs.dropAll(value); } export function drop$clones_Slot(_1: Slot.Slot): void { @@ -29,29 +29,29 @@ export function drop$clones_Slot(_1: Slot.Slot): void { } } -export function drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged(_1: [rt.Vec | undefined, rt.Vec | undefined]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); +export function drop$tuple2_Option_Vec_clones_Logged_Option_Vec_clones_Logged(_1: [rs.Vec | undefined, rs.Vec | undefined]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); } -export function drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged(_1: [rt.Vec, Logged.Logged[][]]): void { - rt.dropVec(_1[0], drop$array2_clones_Logged); - rt.dropAll(_1[1], drop$array2_clones_Logged); +export function drop$tuple2_Vec_array2_clones_Logged_array2_array2_clones_Logged(_1: [rs.Vec, Logged.Logged[][]]): void { + rs.dropVec(_1[0], drop$array2_clones_Logged); + rs.dropAll(_1[1], drop$array2_clones_Logged); } -export function drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [rt.Vec, rt.Vec>]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1], drop$Vec_clones_Logged); +export function drop$tuple2_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [rs.Vec, rs.Vec>]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1], drop$Vec_clones_Logged); } -export function drop$tuple2_Vec_clones_Logged_Vec_clones_Logged(_1: [rt.Vec, rt.Vec]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); +export function drop$tuple2_Vec_clones_Logged_Vec_clones_Logged(_1: [rs.Vec, rs.Vec]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); } export function drop$tuple2_array2_array2_clones_Logged_array2_array2_clones_Logged(_1: [Logged.Logged[][], Logged.Logged[][]]): void { - rt.dropAll(_1[0], drop$array2_clones_Logged); - rt.dropAll(_1[1], drop$array2_clones_Logged); + rs.dropAll(_1[0], drop$array2_clones_Logged); + rs.dropAll(_1[1], drop$array2_clones_Logged); } export function drop$tuple2_clones_Logged_String(_1: [Logged.Logged, string]): void { @@ -64,73 +64,73 @@ export function drop$tuple2_tuple3_array2_clones_Logged_String_clones_Logged_clo } export function drop$tuple3_Option_array2_clones_Logged_Option_array2_clones_Logged_Option_array2_clones_Logged(_1: [Logged.Logged[] | undefined, Logged.Logged[] | undefined, Logged.Logged[] | undefined]): void { - rt.dropAll(_1[0]); - rt.dropAll(_1[1]); - rt.dropAll(_1[2]); + rs.dropAll(_1[0]); + rs.dropAll(_1[1]); + rs.dropAll(_1[2]); } -export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rt.Vec, rt.Vec, rt.Vec<[Logged.Logged, string]>]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); - rt.dropVec(_1[2], drop$tuple2_clones_Logged_String); +export function drop$tuple3_Vec_Option_clones_Logged_Vec_Option_clones_Logged_Vec_tuple2_clones_Logged_String(_1: [rs.Vec, rs.Vec, rs.Vec<[Logged.Logged, string]>]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); + rs.dropVec(_1[2], drop$tuple2_clones_Logged_String); } -export function drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [rt.Vec>, rt.Vec>, rt.Vec>]): void { - rt.dropVec(_1[0], drop$Vec_clones_Logged); - rt.dropVec(_1[1], drop$Vec_clones_Logged); - rt.dropVec(_1[2], drop$Vec_clones_Logged); +export function drop$tuple3_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged_Vec_Vec_clones_Logged(_1: [rs.Vec>, rs.Vec>, rs.Vec>]): void { + rs.dropVec(_1[0], drop$Vec_clones_Logged); + rs.dropVec(_1[1], drop$Vec_clones_Logged); + rs.dropVec(_1[2], drop$Vec_clones_Logged); } -export function drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged(_1: [rt.Vec, rt.Vec, Logged.Logged[]]): void { - rt.dropVec(_1[0], drop$array2_clones_Logged); - rt.dropVec(_1[1], drop$array2_clones_Logged); - rt.dropAll(_1[2]); +export function drop$tuple3_Vec_array2_clones_Logged_Vec_array2_clones_Logged_array2_clones_Logged(_1: [rs.Vec, rs.Vec, Logged.Logged[]]): void { + rs.dropVec(_1[0], drop$array2_clones_Logged); + rs.dropVec(_1[1], drop$array2_clones_Logged); + rs.dropAll(_1[2]); } -export function drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged(_1: [rt.Vec, rt.Vec, rt.Vec]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); - rt.dropVec(_1[2]); +export function drop$tuple3_Vec_clones_Logged_Vec_clones_Logged_Vec_clones_Logged(_1: [rs.Vec, rs.Vec, rs.Vec]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); + rs.dropVec(_1[2]); } export function drop$tuple3_array0_clones_Logged_array0_clones_Logged_array3_clones_Logged(_1: [Logged.Logged[], Logged.Logged[], Logged.Logged[]]): void { - rt.dropAll(_1[2]); + rs.dropAll(_1[2]); } export function drop$tuple3_array2_clones_Logged_String_clones_Logged(_1: [Logged.Logged[], string, Logged.Logged]): void { - rt.dropAll(_1[0]); + rs.dropAll(_1[0]); _1[2][Symbol.dispose](); } export function drop$tuple3_array3_clones_Logged_array3_clones_Logged_array3_clones_Logged(_1: [Logged.Logged[], Logged.Logged[], Logged.Logged[]]): void { - rt.dropAll(_1[0]); - rt.dropAll(_1[1]); - rt.dropAll(_1[2]); + rs.dropAll(_1[0]); + rs.dropAll(_1[1]); + rs.dropAll(_1[2]); } export function drop$tuple4_boxed_Box_slice_clones_Logged_boxed_Box_slice_clones_Logged_boxed_Box_slice_array1_clones_Logged_boxed_Box_slice_array1_clones_Logged(_1: [Logged.Logged[], Logged.Logged[], Logged.Logged[][], Logged.Logged[][]]): void { - rt.dropAll(_1[0]); - rt.dropAll(_1[1]); - rt.dropAll(_1[2], drop$array1_clones_Logged); - rt.dropAll(_1[3], drop$array1_clones_Logged); + rs.dropAll(_1[0]); + rs.dropAll(_1[1]); + rs.dropAll(_1[2], drop$array1_clones_Logged); + rs.dropAll(_1[3], drop$array1_clones_Logged); } -export function drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept(_1: [rt.Vec, rt.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rt.LinkedList, rt.LinkedList]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); - rt.dropAll(_1[2], drop$array2_clones_Kept); - rt.drop(_1[3]); - rt.dropAll(_1[4], drop$clones_Slot); - rt.listDrop(_1[5], rt.drop); - rt.listDrop(_1[6], rt.drop); +export function drop$tuple7_Vec_clones_Kept_Vec_clones_Kept_array1_array2_clones_Kept_Option_clones_Kept_array2_clones_Slot_collections_LinkedList_clones_Kept_collections_LinkedList_clones_Kept(_1: [rs.Vec, rs.Vec, Kept.Kept[][], Kept.Kept | undefined, Slot.Slot[], rs.LinkedList, rs.LinkedList]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); + rs.dropAll(_1[2], drop$array2_clones_Kept); + rs.drop(_1[3]); + rs.dropAll(_1[4], drop$clones_Slot); + rs.listDrop(_1[5], rs.drop); + rs.listDrop(_1[6], rs.drop); } /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["clones::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::clone_froms", cloneFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::repeats", repeats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["clones::sources", sources as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["clones::iters", iters as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["clones::arrays", arrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["clones::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["clones::repeats", repeats as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["clones::sources", sources as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Boxed.ts b/ts/fixtures/lang/collections/expected/collections.Boxed.ts index fb1c0e07b..502a3919c 100644 --- a/ts/fixtures/lang/collections/expected/collections.Boxed.ts +++ b/ts/fixtures/lang/collections/expected/collections.Boxed.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Equal by the remainder by 2 and ordered by the remainder by 3 only as a `Box`. */ export interface Boxed { - _0: rt.u16; + _0: rs.u16; } //# sourceMappingURL=collections.Boxed.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Bumped.ts b/ts/fixtures/lang/collections/expected/collections.Bumped.ts index b500fab95..5f49814b4 100644 --- a/ts/fixtures/lang/collections/expected/collections.Bumped.ts +++ b/ts/fixtures/lang/collections/expected/collections.Bumped.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` type whose `Clone` does more than copy. */ export interface Bumped { - _0: rt.u8; + _0: rs.u8; } export function clone$Clone(self: Bumped): Bumped { - return { _0: rt.u8WrappingAdd(self._0, 1) }; + return { _0: rs.u8WrappingAdd(self._0, 1) }; } //# sourceMappingURL=collections.Bumped.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ByRef.ts b/ts/fixtures/lang/collections/expected/collections.ByRef.ts index 2431be7df..e0cf0da49 100644 --- a/ts/fixtures/lang/collections/expected/collections.ByRef.ts +++ b/ts/fixtures/lang/collections/expected/collections.ByRef.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Compared, ordered, and hashed only through references: equal and hashed by the @@ -8,23 +8,23 @@ import * as rt from "./rt.ts"; * remainder by 4, descending, so each composite shows which std calls. */ export interface ByRef { - _0: rt.u16; + _0: rs.u16; } export function eq$cmp_PartialEq_ref(self: ByRef, other: ByRef): boolean { - return rt.u16Rem(self._0, 2) === rt.u16Rem(other._0, 2); + return rs.u16Rem(self._0, 2) === rs.u16Rem(other._0, 2); } -export function partialCmp$cmp_PartialOrd_ref(self: ByRef, other: ByRef): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(self._0, 3), rt.u16Rem(other._0, 3)); +export function partialCmp$cmp_PartialOrd_ref(self: ByRef, other: ByRef): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(self._0, 3), rs.u16Rem(other._0, 3)); } -export function cmp$cmp_Ord_ref(self: ByRef, other: ByRef): rt.Ordering { - return rt.cmp(rt.u16Rem(other._0, 4), rt.u16Rem(self._0, 4)); +export function cmp$cmp_Ord_ref(self: ByRef, other: ByRef): rs.Ordering { + return rs.cmp(rs.u16Rem(other._0, 4), rs.u16Rem(self._0, 4)); } -export function hash$Hash_ref_hash_DefaultHasher(self: ByRef, state: rt.Hasher): void { - rt.hash16(rt.u16Rem(self._0, 2), state); +export function hash$Hash_ref_hash_DefaultHasher(self: ByRef, state: rs.Hasher): void { + rs.hash16(rs.u16Rem(self._0, 2), state); } //# sourceMappingURL=collections.ByRef.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.ByVal.ts b/ts/fixtures/lang/collections/expected/collections.ByVal.ts index 54af3b1e9..0dbc03d6f 100644 --- a/ts/fixtures/lang/collections/expected/collections.ByVal.ts +++ b/ts/fixtures/lang/collections/expected/collections.ByVal.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `ByRef`'s impls on the value itself, which std's of references forward to. */ export interface ByVal { - _0: rt.u16; + _0: rs.u16; } export function eq$cmp_PartialEq(self: ByVal, other: ByVal): boolean { - return rt.u16Rem(self._0, 2) === rt.u16Rem(other._0, 2); + return rs.u16Rem(self._0, 2) === rs.u16Rem(other._0, 2); } -export function partialCmp$cmp_PartialOrd(self: ByVal, other: ByVal): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(self._0, 3), rt.u16Rem(other._0, 3)); +export function partialCmp$cmp_PartialOrd(self: ByVal, other: ByVal): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(self._0, 3), rs.u16Rem(other._0, 3)); } -export function cmp$cmp_Ord(self: ByVal, other: ByVal): rt.Ordering { - return rt.cmp(rt.u16Rem(other._0, 4), rt.u16Rem(self._0, 4)); +export function cmp$cmp_Ord(self: ByVal, other: ByVal): rs.Ordering { + return rs.cmp(rs.u16Rem(other._0, 4), rs.u16Rem(self._0, 4)); } -export function hash$Hash_hash_DefaultHasher(self: ByVal, state: rt.Hasher): void { - rt.hash16(rt.u16Rem(self._0, 2), state); +export function hash$Hash_hash_DefaultHasher(self: ByVal, state: rs.Hasher): void { + rs.hash16(rs.u16Rem(self._0, 2), state); } //# sourceMappingURL=collections.ByVal.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Clash.ts b/ts/fixtures/lang/collections/expected/collections.Clash.ts index b0d78f317..fe4cd6a5c 100644 --- a/ts/fixtures/lang/collections/expected/collections.Clash.ts +++ b/ts/fixtures/lang/collections/expected/collections.Clash.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Clash, other: Clash): boolean { return self._0 === other._0; @@ -8,10 +8,10 @@ export function eq$cmp_PartialEq(self: Clash, other: Clash): boolean { /** A key whose `Hash` writes nothing, so every key collides. */ export interface Clash { - _0: rt.u8; + _0: rs.u8; } -export function hash$Hash_hash_DefaultHasher(_self: Clash, _2: rt.Hasher): void { +export function hash$Hash_hash_DefaultHasher(_self: Clash, _2: rs.Hasher): void { } //# sourceMappingURL=collections.Clash.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Cloned.ts b/ts/fixtures/lang/collections/expected/collections.Cloned.ts index 3331d4d0c..6312a4353 100644 --- a/ts/fixtures/lang/collections/expected/collections.Cloned.ts +++ b/ts/fixtures/lang/collections/expected/collections.Cloned.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A value that counts how far it is cloned from the one `vec!` was given, which * `vec![x; n]` clones for every element but the last, which is `x` itself. */ export interface Cloned { - depth: rt.u8; + depth: rs.u8; name: string; } export function clone$Clone(self: Cloned): Cloned { - return { depth: rt.u8Add(self.depth, 1), name: self.name }; + return { depth: rs.u8Add(self.depth, 1), name: self.name }; } //# sourceMappingURL=collections.Cloned.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Dir.ts b/ts/fixtures/lang/collections/expected/collections.Dir.ts index d3826e7a3..711fca1e1 100644 --- a/ts/fixtures/lang/collections/expected/collections.Dir.ts +++ b/ts/fixtures/lang/collections/expected/collections.Dir.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A fieldless enum whose own `Eq` and `Hash` find `Up` and `Top` equal, which their JS @@ -22,8 +22,8 @@ export function eq$cmp_PartialEq(self: Dir, other: Dir): boolean { return rising(self) === rising(other); } -export function hash$Hash_hash_DefaultHasher(self: Dir, state: rt.Hasher): void { - rt.hash8(rising(self), state); +export function hash$Hash_hash_DefaultHasher(self: Dir, state: rs.Hasher): void { + rs.hash8(rising(self), state); } //# sourceMappingURL=collections.Dir.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Fussy.ts b/ts/fixtures/lang/collections/expected/collections.Fussy.ts index 302aaf4e6..6fd9f881b 100644 --- a/ts/fixtures/lang/collections/expected/collections.Fussy.ts +++ b/ts/fixtures/lang/collections/expected/collections.Fussy.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function cmp$cmp_Ord(self: Fussy, other: Fussy): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Fussy, other: Fussy): rs.Ordering { + return rs.cmp(self._0, other._0); } /** A value whose `clone` panics on a multiple of 7, saying which. */ export interface Fussy { - _0: rt.u8; + _0: rs.u8; } export function clone$Clone(self: Fussy): Fussy { - if (!(rt.u8Rem(self._0, 7) === 0)) { + if (!(rs.u8Rem(self._0, 7) === 0)) { return { _0: self._0 }; } const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - rt.panicFmt(["cloning ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + rs.panicFmt(["cloning ", args2[0]]); } //# sourceMappingURL=collections.Fussy.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Holder.ts b/ts/fixtures/lang/collections/expected/collections.Holder.ts index 3e2ef4752..357871f21 100644 --- a/ts/fixtures/lang/collections/expected/collections.Holder.ts +++ b/ts/fixtures/lang/collections/expected/collections.Holder.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct that is not `Copy` holding a `Copy` aggregate by value. */ export interface Holder { - pair: [rt.u8, rt.u8]; + pair: [rs.u8, rs.u8]; } //# sourceMappingURL=collections.Holder.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Left.ts b/ts/fixtures/lang/collections/expected/collections.Left.ts index 12f881eae..dc7c20838 100644 --- a/ts/fixtures/lang/collections/expected/collections.Left.ts +++ b/ts/fixtures/lang/collections/expected/collections.Left.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Right from "./collections.Right.ts"; /** @@ -9,37 +9,37 @@ import type * as Right from "./collections.Right.ts"; * in order. */ export interface Left { - _0: rt.u16; - _1: rt.Cell; + _0: rs.u16; + _1: rs.Cell; } -export function log(self: Left, by: rt.u16): void { - rt.cellSet(self._1, rt.u16WrappingAdd(rt.u16WrappingMul(self._1.v, 31), self._0 ^ by)); +export function log(self: Left, by: rs.u16): void { + rs.cellSet(self._1, rs.u16WrappingAdd(rs.u16WrappingMul(self._1.v, 31), self._0 ^ by)); } export function eq$cmp_PartialEq_collections_Right(self: Left, other: Right.Right): boolean { log(self, 256); - return rt.u16Rem(self._0, 4) === rt.u16Rem(other._0, 4); + return rs.u16Rem(self._0, 4) === rs.u16Rem(other._0, 4); } export function ne$cmp_PartialEq_collections_Right(self: Left, other: Right.Right): boolean { log(self, 512); - return rt.u16Rem(self._0, 3) !== rt.u16Rem(other._0, 3); + return rs.u16Rem(self._0, 3) !== rs.u16Rem(other._0, 3); } export function eq$cmp_PartialEq_ref_collections_Right(self: Left, other: Right.Right): boolean { log(self, 2048); - return rt.u16Rem(self._0, 5) === rt.u16Rem(other._0, 5); + return rs.u16Rem(self._0, 5) === rs.u16Rem(other._0, 5); } export function eq$cmp_PartialEq_ref_collections_Left(self: Left, other: Left): boolean { log(self, 4096); - return rt.u16Rem(self._0, 2) === rt.u16Rem(other._0, 2); + return rs.u16Rem(self._0, 2) === rs.u16Rem(other._0, 2); } -export function partialCmp$cmp_PartialOrd_collections_Right(self: Left, other: Right.Right): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd_collections_Right(self: Left, other: Right.Right): rs.Ordering | undefined { log(self, 8192); - return rt.cmp(rt.u16Rem(self._0, 4), rt.u16Rem(other._0, 4)); + return rs.cmp(rs.u16Rem(self._0, 4), rs.u16Rem(other._0, 4)); } //# sourceMappingURL=collections.Left.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Logged.ts b/ts/fixtures/lang/collections/expected/collections.Logged.ts index e396e5881..0380e1c13 100644 --- a/ts/fixtures/lang/collections/expected/collections.Logged.ts +++ b/ts/fixtures/lang/collections/expected/collections.Logged.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A B-tree key ordered by its number's low byte, whose `PartialOrd`'s `le` and `lt`, which @@ -8,10 +8,10 @@ import * as rt from "./rt.ts"; * whole number to the log. */ export class Logged { - _0: rt.u16; - _1: rt.RefCell>; + _0: rs.u16; + _1: rs.RefCell>; - constructor(_0: rt.u16, _1: rt.RefCell>) { + constructor(_0: rs.u16, _1: rs.RefCell>) { this._0 = _0; this._1 = _1; } @@ -22,9 +22,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell> = rt.refCellBorrowMut(self._1); + const _5: rs.RefCell> = rs.refCellBorrowMut(self._1); _5.value.items.push(self._0); - rt.refMutRelease(_5); + rs.refMutRelease(_5); } export function eq$cmp_PartialEq(self: Logged, other: Logged): boolean { @@ -32,21 +32,21 @@ export function eq$cmp_PartialEq(self: Logged, other: Logged): boolean { } export function le$cmp_PartialOrd(self: Logged, other: Logged): boolean { - const _6: rt.RefCell> = rt.refCellBorrowMut(self._1); + const _6: rs.RefCell> = rs.refCellBorrowMut(self._1); _6.value.items.push(16384 | self._0); - rt.refMutRelease(_6); - return rt.u16Div(self._0 & 255, 2) <= rt.u16Div(other._0 & 255, 2); + rs.refMutRelease(_6); + return rs.u16Div(self._0 & 255, 2) <= rs.u16Div(other._0 & 255, 2); } export function lt$cmp_PartialOrd(self: Logged, other: Logged): boolean { - const _6: rt.RefCell> = rt.refCellBorrowMut(self._1); + const _6: rs.RefCell> = rs.refCellBorrowMut(self._1); _6.value.items.push(8192 | self._0); - rt.refMutRelease(_6); - return rt.u16Div(self._0 & 255, 2) < rt.u16Div(other._0 & 255, 2); + rs.refMutRelease(_6); + return rs.u16Div(self._0 & 255, 2) < rs.u16Div(other._0 & 255, 2); } -export function cmp$cmp_Ord(self: Logged, other: Logged): rt.Ordering { - return rt.cmp(self._0 & 255, other._0 & 255); +export function cmp$cmp_Ord(self: Logged, other: Logged): rs.Ordering { + return rs.cmp(self._0 & 255, other._0 & 255); } //# sourceMappingURL=collections.Logged.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Mixed.ts b/ts/fixtures/lang/collections/expected/collections.Mixed.ts index 50e468cef..d479b6ed2 100644 --- a/ts/fixtures/lang/collections/expected/collections.Mixed.ts +++ b/ts/fixtures/lang/collections/expected/collections.Mixed.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Equal and ordered by `PartialOrd` by value, by the remainder by 5, which std's of a @@ -8,23 +8,23 @@ import * as rt from "./rt.ts"; * the remainders by 3 and 5. */ export interface Mixed { - _0: rt.u16; + _0: rs.u16; } export function eq$cmp_PartialEq(self: Mixed, other: Mixed): boolean { - return rt.u16Rem(self._0, 5) === rt.u16Rem(other._0, 5); + return rs.u16Rem(self._0, 5) === rs.u16Rem(other._0, 5); } -export function partialCmp$cmp_PartialOrd(self: Mixed, other: Mixed): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(self._0, 5), rt.u16Rem(other._0, 5)); +export function partialCmp$cmp_PartialOrd(self: Mixed, other: Mixed): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(self._0, 5), rs.u16Rem(other._0, 5)); } -export function cmp$cmp_Ord_ref(self: Mixed, other: Mixed): rt.Ordering { - return rt.cmp(rt.u16Rem(self._0, 3), rt.u16Rem(other._0, 3)); +export function cmp$cmp_Ord_ref(self: Mixed, other: Mixed): rs.Ordering { + return rs.cmp(rs.u16Rem(self._0, 3), rs.u16Rem(other._0, 3)); } -export function hash$Hash_ref_hash_DefaultHasher(self: Mixed, state: rt.Hasher): void { - rt.hash16(rt.u16Rem(self._0, 5), state); +export function hash$Hash_ref_hash_DefaultHasher(self: Mixed, state: rs.Hasher): void { + rs.hash16(rs.u16Rem(self._0, 5), state); } //# sourceMappingURL=collections.Mixed.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Nibble.ts b/ts/fixtures/lang/collections/expected/collections.Nibble.ts index 59f79fa6f..800d2944b 100644 --- a/ts/fixtures/lang/collections/expected/collections.Nibble.ts +++ b/ts/fixtures/lang/collections/expected/collections.Nibble.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A key whose `Eq`, `Hash`, and `Ord` see only its low nibble, so two keys can be equal * while their bytes differ, and which sorts by that nibble, descending. */ export interface Nibble { - _0: rt.u8; + _0: rs.u8; } export function eq$cmp_PartialEq(self: Nibble, other: Nibble): boolean { return (self._0 & 15) === (other._0 & 15); } -export function hash$Hash_hash_DefaultHasher(self: Nibble, state: rt.Hasher): void { - rt.hash8(self._0 & 15, state); +export function hash$Hash_hash_DefaultHasher(self: Nibble, state: rs.Hasher): void { + rs.hash8(self._0 & 15, state); } -export function cmp$cmp_Ord(self: Nibble, other: Nibble): rt.Ordering { - return rt.cmp(other._0 & 15, self._0 & 15); +export function cmp$cmp_Ord(self: Nibble, other: Nibble): rs.Ordering { + return rs.cmp(other._0 & 15, self._0 & 15); } -export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Nibble, other: Nibble): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } diff --git a/ts/fixtures/lang/collections/expected/collections.Odd.ts b/ts/fixtures/lang/collections/expected/collections.Odd.ts index 0900d8476..7941ec628 100644 --- a/ts/fixtures/lang/collections/expected/collections.Odd.ts +++ b/ts/fixtures/lang/collections/expected/collections.Odd.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Right from "./collections.Right.ts"; /** @@ -8,15 +8,15 @@ import type * as Right from "./collections.Right.ts"; * std's of references would otherwise forward from. */ export interface Odd { - _0: rt.u16; + _0: rs.u16; } -export function partialCmp$cmp_PartialOrd_ref(self: Odd, other: Odd): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(self._0, 3), rt.u16Rem(other._0, 3)); +export function partialCmp$cmp_PartialOrd_ref(self: Odd, other: Odd): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(self._0, 3), rs.u16Rem(other._0, 3)); } export function eq$cmp_PartialEq_ref_collections_Right_ref(self: Odd, other: Right.Right): boolean { - return rt.u16Rem(self._0, 2) === rt.u16Rem(other._0, 2); + return rs.u16Rem(self._0, 2) === rs.u16Rem(other._0, 2); } //# sourceMappingURL=collections.Odd.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Pair.ts b/ts/fixtures/lang/collections/expected/collections.Pair.ts index e265179d1..9728bf741 100644 --- a/ts/fixtures/lang/collections/expected/collections.Pair.ts +++ b/ts/fixtures/lang/collections/expected/collections.Pair.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Pair, other: Pair): boolean { if (!(self.a === other.a)) { @@ -9,22 +9,22 @@ export function eq$cmp_PartialEq(self: Pair, other: Pair): boolean { return self.b === other.b; } -export function hash$Hash_hash_DefaultHasher(self: Pair, state: rt.Hasher): void { - rt.hash8(self.a, state); - rt.hash16(self.b, state); +export function hash$Hash_hash_DefaultHasher(self: Pair, state: rs.Hasher): void { + rs.hash8(self.a, state); + rs.hash16(self.b, state); } -export function cmp$cmp_Ord(self: Pair, other: Pair): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.a, other.a); +export function cmp$cmp_Ord(self: Pair, other: Pair): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.a, other.a); if (cmp === 0) { - return rt.cmp(self.b, other.b); + return rs.cmp(self.b, other.b); } return cmp; } export interface Pair { - a: rt.u8; - b: rt.u16; + a: rs.u8; + b: rs.u16; } //# sourceMappingURL=collections.Pair.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Picky.ts b/ts/fixtures/lang/collections/expected/collections.Picky.ts index 9fdad1988..a5fe1bae1 100644 --- a/ts/fixtures/lang/collections/expected/collections.Picky.ts +++ b/ts/fixtures/lang/collections/expected/collections.Picky.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Picky): Picky { return { _0: self._0, _1: self._1 }; @@ -11,22 +11,22 @@ export function clone$Clone(self: Picky): Picky { * `!=` find tells which std calls. Each call adds to the log, in order. */ export interface Picky { - _0: rt.u16; - _1: rt.Cell; + _0: rs.u16; + _1: rs.Cell; } -export function log(self: Picky, other: Picky, by: rt.u16): void { - rt.cellSet(self._1, rt.u16WrappingAdd(rt.u16WrappingMul(self._1.v, 31), self._0 ^ ((other._0 << 4) & 0xffff) ^ by)); +export function log(self: Picky, other: Picky, by: rs.u16): void { + rs.cellSet(self._1, rs.u16WrappingAdd(rs.u16WrappingMul(self._1.v, 31), self._0 ^ ((other._0 << 4) & 0xffff) ^ by)); } export function eq$cmp_PartialEq(self: Picky, other: Picky): boolean { log(self, other, 256); - return rt.u16Rem(self._0, 4) === rt.u16Rem(other._0, 4); + return rs.u16Rem(self._0, 4) === rs.u16Rem(other._0, 4); } export function ne$cmp_PartialEq(self: Picky, other: Picky): boolean { log(self, other, 512); - return rt.u16Rem(self._0, 3) !== rt.u16Rem(other._0, 3); + return rs.u16Rem(self._0, 3) !== rs.u16Rem(other._0, 3); } //# sourceMappingURL=collections.Picky.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Quirky.ts b/ts/fixtures/lang/collections/expected/collections.Quirky.ts index cae50536a..6564fa93d 100644 --- a/ts/fixtures/lang/collections/expected/collections.Quirky.ts +++ b/ts/fixtures/lang/collections/expected/collections.Quirky.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { then$0wlzj76 } from "./core/bool.ts"; +import * as rs from "./rs.ts"; +import { then$1f3a6te } from "./core/bool.ts"; /** * An item whose `ne` and `PartialOrd`'s tests see other remainders than its `eq` and @@ -9,60 +9,60 @@ import { then$0wlzj76 } from "./core/bool.ts"; * std calls. Each call adds to the log, in order. */ export interface Quirky { - _0: rt.u16; - _1: rt.Cell; + _0: rs.u16; + _1: rs.Cell; } -export function log(self: Quirky, other: Quirky, by: rt.u16): void { - rt.cellSet(self._1, rt.u16WrappingAdd(rt.u16WrappingMul(self._1.v, 31), self._0 ^ ((other._0 << 4) & 0xffff) ^ by)); +export function log(self: Quirky, other: Quirky, by: rs.u16): void { + rs.cellSet(self._1, rs.u16WrappingAdd(rs.u16WrappingMul(self._1.v, 31), self._0 ^ ((other._0 << 4) & 0xffff) ^ by)); } export function eq$cmp_PartialEq(self: Quirky, other: Quirky): boolean { log(self, other, 256); - return rt.u16Rem(self._0, 4) === rt.u16Rem(other._0, 4); + return rs.u16Rem(self._0, 4) === rs.u16Rem(other._0, 4); } export function ne$cmp_PartialEq(self: Quirky, other: Quirky): boolean { log(self, other, 512); - return rt.u16Rem(self._0, 3) !== rt.u16Rem(other._0, 3); + return rs.u16Rem(self._0, 3) !== rs.u16Rem(other._0, 3); } -export function partialCmp$cmp_PartialOrd(self: Quirky, other: Quirky): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Quirky, other: Quirky): rs.Ordering | undefined { let _4!: boolean; log(self, other, 768); - if (!(rt.u16Rem(self._0, 7) !== 0)) { + if (!(rs.u16Rem(self._0, 7) !== 0)) { _4 = false; } else { - _4 = rt.u16Rem(other._0, 7) !== 0; + _4 = rs.u16Rem(other._0, 7) !== 0; } - return then$0wlzj76(_4, (): rt.Ordering => { - return rt.cmp(rt.u16Rem(self._0, 5), rt.u16Rem(other._0, 5)); + return then$1f3a6te(_4, (): rs.Ordering => { + return rs.cmp(rs.u16Rem(self._0, 5), rs.u16Rem(other._0, 5)); }); } export function lt$cmp_PartialOrd(self: Quirky, other: Quirky): boolean { log(self, other, 1024); - return rt.u16Rem(self._0, 6) < rt.u16Rem(other._0, 6); + return rs.u16Rem(self._0, 6) < rs.u16Rem(other._0, 6); } export function le$cmp_PartialOrd(self: Quirky, other: Quirky): boolean { log(self, other, 1280); - return rt.u16Rem(self._0, 6) <= rt.u16Rem(other._0, 6); + return rs.u16Rem(self._0, 6) <= rs.u16Rem(other._0, 6); } export function gt$cmp_PartialOrd(self: Quirky, other: Quirky): boolean { log(self, other, 1536); - return rt.u16Rem(self._0, 6) > rt.u16Rem(other._0, 6); + return rs.u16Rem(self._0, 6) > rs.u16Rem(other._0, 6); } export function ge$cmp_PartialOrd(self: Quirky, other: Quirky): boolean { log(self, other, 1792); - return rt.u16Rem(self._0, 6) >= rt.u16Rem(other._0, 6); + return rs.u16Rem(self._0, 6) >= rs.u16Rem(other._0, 6); } -export function cmp$cmp_Ord(self: Quirky, other: Quirky): rt.Ordering { +export function cmp$cmp_Ord(self: Quirky, other: Quirky): rs.Ordering { log(self, other, 2048); - return rt.cmp(rt.u16Rem(self._0, 8), rt.u16Rem(other._0, 8)); + return rs.cmp(rs.u16Rem(self._0, 8), rs.u16Rem(other._0, 8)); } //# sourceMappingURL=collections.Quirky.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Rank.ts b/ts/fixtures/lang/collections/expected/collections.Rank.ts index 995d16da5..55fc1a70d 100644 --- a/ts/fixtures/lang/collections/expected/collections.Rank.ts +++ b/ts/fixtures/lang/collections/expected/collections.Rank.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Rank, other: Rank): boolean { if (!({ Low: 0, Mid: 1, High: 2 }[self.tag] === { Low: 0, Mid: 1, High: 2 }[other.tag])) { @@ -21,33 +21,33 @@ export function eq$cmp_PartialEq(self: Rank, other: Rank): boolean { return true; } -export function hash$Hash_hash_DefaultHasher(self: Rank, state: rt.Hasher): void { - rt.hashIsize({ Low: 0, Mid: 1, High: 2 }[self.tag], state); +export function hash$Hash_hash_DefaultHasher(self: Rank, state: rs.Hasher): void { + rs.hashIsize({ Low: 0, Mid: 1, High: 2 }[self.tag], state); if (self.tag === "Mid") { - rt.hash8(self._0, state); + rs.hash8(self._0, state); } else if (self.tag === "High") { - rt.hash8(self.x, state); - rt.hash8(self.y, state); + rs.hash8(self.x, state); + rs.hash8(self.y, state); } } -export function cmp$cmp_Ord(self: Rank, other: Rank): rt.Ordering { +export function cmp$cmp_Ord(self: Rank, other: Rank): rs.Ordering { if (self.tag === "Mid") { if (other.tag === "Mid") { - return rt.cmp(self._0, other._0); + return rs.cmp(self._0, other._0); } } else if (self.tag === "High") { if (other.tag === "High") { - const cmp: rt.Ordering = rt.cmp(self.x, other.x); + const cmp: rs.Ordering = rs.cmp(self.x, other.x); if (cmp === 0) { - return rt.cmp(self.y, other.y); + return rs.cmp(self.y, other.y); } return cmp; } } - return rt.cmp({ Low: 0, Mid: 1, High: 2 }[self.tag], { Low: 0, Mid: 1, High: 2 }[other.tag]); + return rs.cmp({ Low: 0, Mid: 1, High: 2 }[self.tag], { Low: 0, Mid: 1, High: 2 }[other.tag]); } -export type Rank = { tag: "Low" } | { tag: "Mid"; _0: rt.u8 } | { tag: "High"; x: rt.u8; y: rt.u8 }; +export type Rank = { tag: "Low" } | { tag: "Mid"; _0: rs.u8 } | { tag: "High"; x: rs.u8; y: rs.u8 }; //# sourceMappingURL=collections.Rank.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Right.ts b/ts/fixtures/lang/collections/expected/collections.Right.ts index 306c2aec5..2223a51bf 100644 --- a/ts/fixtures/lang/collections/expected/collections.Right.ts +++ b/ts/fixtures/lang/collections/expected/collections.Right.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Left from "./collections.Left.ts"; export interface Right { - _0: rt.u16; + _0: rs.u16; } export function eq$cmp_PartialEq_collections_Left(self: Right, other: Left.Left): boolean { Left.log(other, 1024); - return rt.u16Rem(self._0, 4) === rt.u16Rem(other._0, 4); + return rs.u16Rem(self._0, 4) === rs.u16Rem(other._0, 4); } //# sourceMappingURL=collections.Right.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Tally.ts b/ts/fixtures/lang/collections/expected/collections.Tally.ts index 8e2d65b7c..78a0df23c 100644 --- a/ts/fixtures/lang/collections/expected/collections.Tally.ts +++ b/ts/fixtures/lang/collections/expected/collections.Tally.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Tally { return { n: 0 }; @@ -8,7 +8,7 @@ export function default$Default(): Tally { /** A value changed in place through `get_mut` and `entry`: a JS number can't be. */ export interface Tally { - n: rt.u16; + n: rs.u16; } //# sourceMappingURL=collections.Tally.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Window.ts b/ts/fixtures/lang/collections/expected/collections.Window.ts index 676b89068..2c75e0600 100644 --- a/ts/fixtures/lang/collections/expected/collections.Window.ts +++ b/ts/fixtures/lang/collections/expected/collections.Window.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A range of its own, which logs each read of either bound. */ export interface Window { - lo: rt.u16; - hi: rt.u16; - log: rt.RefCell>; + lo: rs.u16; + hi: rs.u16; + log: rs.RefCell>; } -export function startBound$ops_RangeBounds_u16(self: Window): rt.RangeBound { - const _5: rt.RefCell> = rt.refCellBorrowMut(self.log); +export function startBound$ops_RangeBounds_u16(self: Window): rs.RangeBound { + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); _5.value.items.push(40960); - rt.refMutRelease(_5); - return { tag: "Included", _0: self.lo } as rt.RangeBound; + rs.refMutRelease(_5); + return { tag: "Included", _0: self.lo } as rs.RangeBound; } -export function endBound$ops_RangeBounds_u16(self: Window): rt.RangeBound { - const _5: rt.RefCell> = rt.refCellBorrowMut(self.log); +export function endBound$ops_RangeBounds_u16(self: Window): rs.RangeBound { + const _5: rs.RefCell> = rs.refCellBorrowMut(self.log); _5.value.items.push(45056); - rt.refMutRelease(_5); - return { tag: "Excluded", _0: self.hi } as rt.RangeBound; + rs.refMutRelease(_5); + return { tag: "Excluded", _0: self.hi } as rs.RangeBound; } //# sourceMappingURL=collections.Window.ts.map diff --git a/ts/fixtures/lang/collections/expected/collections.Wrap.ts b/ts/fixtures/lang/collections/expected/collections.Wrap.ts index d236f5708..9bc82434b 100644 --- a/ts/fixtures/lang/collections/expected/collections.Wrap.ts +++ b/ts/fixtures/lang/collections/expected/collections.Wrap.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A generic `Copy` struct. */ export class Wrap { value: T; - count: rt.u8; + count: rs.u8; - constructor(value: T, count: rt.u8) { + constructor(value: T, count: rs.u8) { this.value = value; this.count = count; } diff --git a/ts/fixtures/lang/collections/expected/collections.ts b/ts/fixtures/lang/collections/expected/collections.ts index 8fd5314b8..497552797 100644 --- a/ts/fixtures/lang/collections/expected/collections.ts +++ b/ts/fixtures/lang/collections/expected/collections.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_collections_Tally, copy$array_collections_Quirky, copy$array_tuple2_u8_u16, copy$array_tuple2_u8_u8, copy$array_u8, copy$collections_Bumped, copy$collections_Quirky, copy$collections_Tally, copy$collections_Wrap_u8, copy$tuple2_u8_collections_Tally, copy$tuple2_u8_u16, copy$tuple2_u8_u8, drop$Option_tuple2_collections_Logged_collections_Logged, drop$ops_Range_collections_Logged, drop$tuple2_collections_Logged_collections_Logged, drop$tuple2_ops_Bound_collections_Logged_ops_Bound_collections_Logged, drop$tuple2_sync_Arc_collections_Picky_u8 } from "./lib.ts"; import type * as Boxed from "./collections.Boxed.ts"; import * as Bumped from "./collections.Bumped.ts"; @@ -24,35 +24,35 @@ import * as Right from "./collections.Right.ts"; import * as Tally from "./collections.Tally.ts"; import * as Window from "./collections.Window.ts"; import * as Wrap from "./collections.Wrap.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0ltgf8p as option_map$0ltgf8p, map$1ajptuf as option_map$1ajptuf, map$0i8kclf as option_map$0i8kclf, map$09ua5et as option_map$09ua5et, map$0oc32h1 as option_map$0oc32h1, map$05nbzug as option_map$05nbzug, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$0q0ymkh as option_mapOr$0q0ymkh, mapOr$1ht002r as option_mapOr$1ht002r, mapOr$1xztl8h as option_mapOr$1xztl8h, mapOr$1w1gbwl as option_mapOr$1w1gbwl, mapOr$0bnr5nu as option_mapOr$0bnr5nu, mapOr$1nlkf9b as option_mapOr$1nlkf9b, mapOr$099335t as option_mapOr$099335t, mapOr$0z4mj8g as option_mapOr$0z4mj8g, mapOr$1surhce as option_mapOr$1surhce, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$02k4ito as option_mapOr$02k4ito, mapOr$1to2ul4 as option_mapOr$1to2ul4, mapOr$0mmpeqx as option_mapOr$0mmpeqx, clone$14nprly as option_clone$14nprly, flatten$1nwzx42 as option_flatten$1nwzx42 } from "./core/option.ts"; -import { eq$1dt73ez as result_eq$1dt73ez, eq$163neqy as result_eq$163neqy } from "./core/result.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pdxnel as option_map$1pdxnel, map$093awy8 as option_map$093awy8, map$0aug5m6 as option_map$0aug5m6, map$16w3l9s as option_map$16w3l9s, map$1y26nmr as option_map$1y26nmr, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$0f7cus0 as option_mapOr$0f7cus0, mapOr$07jk2xl as option_mapOr$07jk2xl, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0pgapuk as option_mapOr$0pgapuk, mapOr$13kt6x8 as option_mapOr$13kt6x8, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$18dcmgz as option_mapOr$18dcmgz, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$188iunt as option_mapOr$188iunt, mapOr$0955beb as option_mapOr$0955beb, mapOr$1h9hu6n as option_mapOr$1h9hu6n, clone$14nprly as option_clone$14nprly, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; +import { eq$1a91ieh as result_eq$1a91ieh, eq$122baxc as result_eq$122baxc } from "./core/result.ts"; import { put } from "./harness.ts"; /** A 64-bit key: small, or past 2^53, where it is no longer a JS number. */ -export function wide(b: rt.u8): rt.u64 { - const _2: rt.u8 = rt.u8Rem(b, 3); +export function wide(b: rs.u8): rs.u64 { + const _2: rs.u8 = rs.u8Rem(b, 3); if (_2 === 0) { - return b as rt.u64; + return b as rs.u64; } if (_2 === 1) { - return rt.u64Shl(b as rt.u64, 50); + return rs.u64Shl(b as rs.u64, 50); } - return rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b as rt.u64); + return rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b as rs.u64); } -export function rank(b: rt.u8, c: rt.u8): Rank.Rank { - const _3: rt.u8 = rt.u8Rem(b, 3); +export function rank(b: rs.u8, c: rs.u8): Rank.Rank { + const _3: rs.u8 = rs.u8Rem(b, 3); if (_3 === 0) { return { tag: "Low" } as Rank.Rank; } if (_3 === 1) { - return { tag: "Mid", _0: rt.u8Rem(c, 4) } as Rank.Rank; + return { tag: "Mid", _0: rs.u8Rem(c, 4) } as Rank.Rank; } - return { tag: "High", x: rt.u8Rem(c, 2), y: rt.u8Rem(c, 3) } as Rank.Rank; + return { tag: "High", x: rs.u8Rem(c, 2), y: rs.u8Rem(c, 3) } as Rank.Rank; } -export function rankByte(r: Rank.Rank): rt.u8 { +export function rankByte(r: Rank.Rank): rs.u8 { if (r.tag === "Low") { return 0; } @@ -63,376 +63,376 @@ export function rankByte(r: Rank.Rank): rt.u8 { } /** A `HashMap` by each kind of key, through a script of inserts, lookups, and removals. */ -export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _174!: rt.usize; - let _299!: rt.usize; - let _377!: rt.u8; - let _429!: rt.u8; - const _443: (a0: Nibble.Nibble) => rt.u64 = (n: Nibble.Nibble): rt.u64 => { - const h2: rt.Hasher = rt.hasher(); +export function hashMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _174!: rs.usize; + let _299!: rs.usize; + let _377!: rs.u8; + let _429!: rs.u8; + const _443: (a0: Nibble.Nibble) => rs.u64 = (n: Nibble.Nibble): rs.u64 => { + const h2: rs.Hasher = rs.hasher(); Nibble.hash$Hash_hash_DefaultHasher(n, h2); - return rt.hashFinish(h2); + return rs.hashFinish(h2); }; - const _4: rt.u8 = rt.u8Rem(kind, 4); + const _4: rs.u8 = rs.u8Rem(kind, 4); if (_4 === 0) { - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2, undefined, 4294967295); + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter = rs.iterStepBy(new rs.Range(0, data.length), 2, undefined, 4294967295); while (true) { - const _13: rt.usize | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.usize | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13; - rt.idx(data, i); - const _19: [rt.u8, rt.u16] = [rt.u8Rem(data.data[data.start + i], 16), option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(i, 1)), 0) as rt.u16]; - const k: rt.u8 = _19[0]; - const v: rt.u16 = _19[1]; - const _31: rt.u16 = rt.u16Rem(v, 5); + const i: rs.usize = _13; + rs.idx(data, i); + const _19: [rs.u8, rs.u16] = [rs.u8Rem(data.data[data.start + i], 16), option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(i, 1)), 0) as rs.u16]; + const k: rs.u8 = _19[0]; + const v: rs.u16 = _19[1]; + const _31: rs.u16 = rs.u16Rem(v, 5); if (_31 === 0) { - rt.byteVecPush(out, option_mapOr$099335t(rt.hashRemove(map, k), 238, (old2: rt.u16): rt.u8 => { + rs.byteVecPush(out, option_mapOr$031uhqp(rs.hashRemove(map, k), 238, (old2: rs.u16): rs.u8 => { return old2 & 0xff; })); } else if (_31 === 1) { - rt.byteVecPush(out, rt.hashContains(map, k) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(map, k) ? 1 : 0); } else if (_31 === 2) { - rt.byteVecPush(out, option_mapOr$099335t(rt.hashGet(map, k), 221, (v4: rt.u16): rt.u8 => { + rs.byteVecPush(out, option_mapOr$031uhqp(rs.hashGet(map, k), 221, (v4: rs.u16): rs.u8 => { return v4 & 0xff; })); } else { - rt.byteVecPush(out, option_mapOr$099335t(rt.hashInsert(map, k, rt.u16Mul(v, 3)), 204, (old: rt.u16): rt.u8 => { + rs.byteVecPush(out, option_mapOr$031uhqp(rs.hashInsert(map, k, rs.u16Mul(v, 3)), 204, (old: rs.u16): rs.u8 => { return old & 0xff; })); } } - rt.byteVecPush(out, rt.hashLen(map) & 0xff); - rt.byteVecPush(out, rt.hashLen(map) === 0 ? 1 : 0); - const it: rt.Iter<[rt.u8, rt.u16]> = rt.hashIter(map); - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(it)) & 0xff); - rt.byteVecPush(out, rt.iterToOption(it.next()) === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterSum(rt.iterMap(rt.hashValues(map), (v5: rt.u16): rt.u16 => { - return rt.u16Rem(v5, 256); - }), rt.u16Add, 0)))); - const _80: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_231: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { - return [_231[0], _231[1]] as [rt.u8, rt.u16]; + rs.byteVecPush(out, rs.hashLen(map) & 0xff); + rs.byteVecPush(out, rs.hashLen(map) === 0 ? 1 : 0); + const it: rs.Iter<[rs.u8, rs.u16]> = rs.hashIter(map); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(it)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it.next()) === undefined ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterSum(rs.iterMap(rs.hashValues(map), (v5: rs.u16): rs.u16 => { + return rs.u16Rem(v5, 256); + }), rs.u16Add, 0)))); + const _80: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.hashIter(map), (_231: [rs.u8, rs.u16]): [rs.u8, rs.u16] => { + return [_231[0], _231[1]] as [rs.u8, rs.u16]; }); - const iter2: rt.Iter<[rt.u8, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _80, true, undefined, undefined, "next", 4)); + const iter2: rs.Iter<[rs.u8, rs.u16]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _80, true, undefined, undefined, "next", 4)); while (true) { - const _86: [rt.u8, rt.u16] | rt.Done = iter2.next(); - if (_86 === rt.DONE) { + const _86: [rs.u8, rs.u16] | rs.Done = iter2.next(); + if (_86 === rs.DONE) { break; } - rt.byteVecPush(out, _86[0]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_86[1]))); + rs.byteVecPush(out, _86[0]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_86[1]))); } - rt.hashClear(map); - rt.byteVecPush(out, rt.hashLen(map) & 0xff); + rs.hashClear(map); + rs.byteVecPush(out, rs.hashLen(map) & 0xff); } else if (_4 === 1) { - const map2: rt.HashMap = rt.hashWithCapacity(4, 58720256, rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashMap; - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const map2: rs.HashMap = rs.hashWithCapacity(4, 58720256, rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashMap; + const iter3: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _110: [rt.usize, rt.u8] | rt.Done = iter3.next(); - if (_110 === rt.DONE) { + const _110: [rs.usize, rs.u8] | rs.Done = iter3.next(); + if (_110 === rs.DONE) { break; } - const i2: rt.usize = _110[0]; - const b: rt.u8 = _110[1]; - const k2: rt.u64 = wide(rt.u8Rem(b, 12)); - const _118: rt.u8 = rt.u8Rem(rt.u8Div(b, 12), 4); + const i2: rs.usize = _110[0]; + const b: rs.u8 = _110[1]; + const k2: rs.u64 = wide(rs.u8Rem(b, 12)); + const _118: rs.u8 = rs.u8Rem(rs.u8Div(b, 12), 4); if (_118 === 0) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map2, k2), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map2, k2), 238)); } else if (_118 === 1) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(map2, k2), 221)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(map2, k2), 221)); } else { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map2, k2, i2 & 0xff), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map2, k2, i2 & 0xff), 204)); } } - const _136: rt.Iter = rt.hashKeys(map2); - const iter4: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _136, true, undefined, "next", 8)); + const _136: rs.Iter = rs.hashKeys(map2); + const iter4: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _136, true, undefined, "next", 8)); while (true) { - const _142: rt.u64 | rt.Done = iter4.next(); - if (_142 === rt.DONE) { + const _142: rs.u64 | rs.Done = iter4.next(); + if (_142 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_142))); - rt.byteVecPush(out, rt.hashIndex(map2, _142)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_142))); + rs.byteVecPush(out, rs.hashIndex(map2, _142)); } - const _155: rt.u8 | undefined = rt.byteSliceFirst(data); + const _155: rs.u8 | undefined = rs.byteSliceFirst(data); if (_155 !== undefined) { - const _163: rt.u64 = wide(rt.u8Rem(_155, 13)); - rt.byteVecPush(out, rt.hashIndex(map2, _163)); + const _163: rs.u64 = wide(rs.u8Rem(_155, 13)); + rs.byteVecPush(out, rs.hashIndex(map2, _163)); } } else if (_4 === 2) { - const map3: rt.HashMap = rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashMap; - const pairs: rt.HashMap = rt.hashNew(rt.hashing(Pair.hash$Hash_hash_DefaultHasher as (a0: Pair.Pair, a1: rt.Hasher) => undefined, Pair.eq$cmp_PartialEq)) as rt.HashMap; - const ranks: rt.HashMap = rt.hashNew(rt.hashing(Rank.hash$Hash_hash_DefaultHasher as (a0: Rank.Rank, a1: rt.Hasher) => undefined, Rank.eq$cmp_PartialEq)) as rt.HashMap; - const tuples: rt.HashMap<[rt.u8, string], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hashStr]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, string], rt.u8>; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const map3: rs.HashMap = rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashMap; + const pairs: rs.HashMap = rs.hashNew(rs.hashing(Pair.hash$Hash_hash_DefaultHasher as (a0: Pair.Pair, a1: rs.Hasher) => undefined, Pair.eq$cmp_PartialEq)) as rs.HashMap; + const ranks: rs.HashMap = rs.hashNew(rs.hashing(Rank.hash$Hash_hash_DefaultHasher as (a0: Rank.Rank, a1: rs.Hasher) => undefined, Rank.eq$cmp_PartialEq)) as rs.HashMap; + const tuples: rs.HashMap<[rs.u8, string], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hashStr]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, string], rs.u8>; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = data.length; while ((_174 = iterStart++) < iterEnd) { - const i3: rt.usize = _174; - const _182: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _182); - const _181: rt.u8 = data.data[data.start + _182]; - rt.idx(data, i3); - const _180: [rt.u8, rt.u8] = [_181, data.data[data.start + i3]]; - const a: rt.u8 = _181; - const b3: rt.u8 = _180[1]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map3, { _0: a }, b3), 204)); - const pair: Pair.Pair = { a: rt.u8Rem(a, 4), b: rt.u16Rem(b3 as rt.u16, 3) }; - const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(pairs, pair), Tally.default$Default); - t.n = rt.u16Add(t.n, 1); + const i3: rs.usize = _174; + const _182: rs.usize = rs.usizeSub(i3, 1); + rs.idx(data, _182); + const _181: rs.u8 = data.data[data.start + _182]; + rs.idx(data, i3); + const _180: [rs.u8, rs.u8] = [_181, data.data[data.start + i3]]; + const a: rs.u8 = _181; + const b3: rs.u8 = _180[1]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map3, { _0: a }, b3), 204)); + const pair: Pair.Pair = { a: rs.u8Rem(a, 4), b: rs.u16Rem(b3 as rs.u16, 3) }; + const t: Tally.Tally = rs.entryOrInsertWith(rs.entry(pairs, pair), Tally.default$Default); + t.n = rs.u16Add(t.n, 1); const r: Rank.Rank = rank(a, b3); - const _205: Tally.Tally | undefined = rt.hashGet(ranks, r); + const _205: Tally.Tally | undefined = rs.hashGet(ranks, r); if (_205 !== undefined) { - _205.n = rt.u16Add(_205.n, 1); + _205.n = rs.u16Add(_205.n, 1); } else { - rt.hashInsert(ranks, r, { n: i3 & 0xffff }); + rs.hashInsert(ranks, r, { n: i3 & 0xffff }); } - const _216: rt.u8 = rt.u8Rem(a, 3); - const _220: rt.usize = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + const _216: rs.u8 = rs.u8Rem(a, 3); + const _220: rs.usize = rs.usizeRem(b3 as rs.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); if (!(_220 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _220); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _220); } - const t2: [rt.u8, string] = [_216, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_220]]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(tuples, t2), 187)); - if (rt.u8Rem(a, 2) === 0) { - rt.hashInsert(tuples, t2, a); + const t2: [rs.u8, string] = [_216, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_220]]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(tuples, t2), 187)); + if (rs.u8Rem(a, 2) === 0) { + rs.hashInsert(tuples, t2, a); } } - const _238: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map3), (_212: [Nibble.Nibble, rt.u8]): [rt.u8, rt.u8] => { - return [_212[0]._0, _212[1]] as [rt.u8, rt.u8]; + const _238: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.hashIter(map3), (_212: [Nibble.Nibble, rs.u8]): [rs.u8, rs.u8] => { + return [_212[0]._0, _212[1]] as [rs.u8, rs.u8]; }); - const iter6: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _238, true, undefined, undefined, "next", 2)); + const iter6: rs.Iter<[rs.u8, rs.u8]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _238, true, undefined, undefined, "next", 2)); while (true) { - const _243: [rt.u8, rt.u8] | rt.Done = iter6.next(); - if (_243 === rt.DONE) { + const _243: [rs.u8, rs.u8] | rs.Done = iter6.next(); + if (_243 === rs.DONE) { break; } - const k3: rt.u8 = _243[0]; - const v2: rt.u8 = _243[1]; - rt.byteVecPush(out, k3); - rt.byteVecPush(out, v2); + const k3: rs.u8 = _243[0]; + const v2: rs.u8 = _243[1]; + rs.byteVecPush(out, k3); + rs.byteVecPush(out, v2); } const key: Pair.Pair = { a: 9, b: 9 }; const local: Tally.Tally = { n: 7 }; - rt.hashInsert(pairs, key, copy$collections_Tally(local)); + rs.hashInsert(pairs, key, copy$collections_Tally(local)); local.n = 8; - const before: Tally.Tally = copy$collections_Tally(rt.hashIndex(pairs, key)); - const _259: Tally.Tally | undefined = rt.hashGet(pairs, key); + const before: Tally.Tally = copy$collections_Tally(rs.hashIndex(pairs, key)); + const _259: Tally.Tally | undefined = rs.hashGet(pairs, key); if (_259 !== undefined) { - _259.n = rt.u16Add(_259.n, 2); + _259.n = rs.u16Add(_259.n, 2); } - rt.byteVecPush(out, local.n & 0xff); - rt.byteVecPush(out, before.n & 0xff); - rt.byteVecPush(out, rt.hashIndex(pairs, key).n & 0xff); - const _278: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.hashIter(pairs); - const iter7: rt.Iter<[Pair.Pair, Tally.Tally]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Pair.cmp$cmp_Ord) as rt.BTreeMap, _278, true, undefined, undefined, "next", 6)); + rs.byteVecPush(out, local.n & 0xff); + rs.byteVecPush(out, before.n & 0xff); + rs.byteVecPush(out, rs.hashIndex(pairs, key).n & 0xff); + const _278: rs.Iter<[Pair.Pair, Tally.Tally]> = rs.hashIter(pairs); + const iter7: rs.Iter<[Pair.Pair, Tally.Tally]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(Pair.cmp$cmp_Ord) as rs.BTreeMap, _278, true, undefined, undefined, "next", 6)); while (true) { - const _282: [Pair.Pair, Tally.Tally] | rt.Done = iter7.next(); - if (_282 === rt.DONE) { + const _282: [Pair.Pair, Tally.Tally] | rs.Done = iter7.next(); + if (_282 === rs.DONE) { break; } const p: Pair.Pair = _282[0]; const t3: Tally.Tally = _282[1]; - rt.byteVecPush(out, p.a); - rt.byteVecPush(out, p.b & 0xff); - rt.byteVecPush(out, t3.n & 0xff); + rs.byteVecPush(out, p.a); + rs.byteVecPush(out, p.b & 0xff); + rs.byteVecPush(out, t3.n & 0xff); } - let iterStart2: rt.usize = 1; - const iterEnd2: rt.usize = data.length; + let iterStart2: rs.usize = 1; + const iterEnd2: rs.usize = data.length; while ((_299 = iterStart2++) < iterEnd2) { - const i4: rt.usize = _299; - const _307: rt.usize = rt.usizeSub(i4, 1); - rt.idx(data, _307); - const _306: rt.u8 = data.data[data.start + _307]; - rt.idx(data, i4); - const _305: [rt.u8, rt.u8] = [_306, data.data[data.start + i4]]; - const a2: rt.u8 = _306; - const b4: rt.u8 = _305[1]; + const i4: rs.usize = _299; + const _307: rs.usize = rs.usizeSub(i4, 1); + rs.idx(data, _307); + const _306: rs.u8 = data.data[data.start + _307]; + rs.idx(data, i4); + const _305: [rs.u8, rs.u8] = [_306, data.data[data.start + i4]]; + const a2: rs.u8 = _306; + const b4: rs.u8 = _305[1]; const _318: Rank.Rank = rank(b4, a2); - const t4: Tally.Tally = rt.entryOrInsertWith(rt.entryAndModify(rt.entry(ranks, _318), (t9: Tally.Tally): undefined => { + const t4: Tally.Tally = rs.entryOrInsertWith(rs.entryAndModify(rs.entry(ranks, _318), (t9: Tally.Tally): undefined => { t9.n = t9.n ^ 3; }), (): Tally.Tally => { - return { n: b4 as rt.u16 }; + return { n: b4 as rs.u16 }; }); - t4.n = rt.u16WrappingAdd(t4.n, t4.n); - rt.idx(data, i4); + t4.n = rs.u16WrappingAdd(t4.n, t4.n); + rs.idx(data, i4); const _326: Rank.Rank = rank(data.data[data.start + i4], 0); - const e: rt.Entry = rt.entry(ranks, _326); - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.byteVecPush(out, rt.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { - return { n: rankByte(k9) as rt.u16 }; + const e: rs.Entry = rs.entry(ranks, _326); + rs.byteVecPush(out, rankByte(rs.entryKey(e))); + rs.byteVecPush(out, rs.entryOrInsertWith(e, (k9: Rank.Rank): Tally.Tally => { + return { n: rankByte(k9) as rs.u16 }; }).n & 0xff); } - const copy: rt.HashMap = rt.hashClone(ranks, undefined, copy$collections_Tally); - const _340: Tally.Tally | undefined = rt.hashGet(copy, { tag: "Low" } as Rank.Rank); + const copy: rs.HashMap = rs.hashClone(ranks, undefined, copy$collections_Tally); + const _340: Tally.Tally | undefined = rs.hashGet(copy, { tag: "Low" } as Rank.Rank); if (_340 !== undefined) { _340.n = 119; } - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(ranks, { tag: "Low" } as Rank.Rank), 255, (t10: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(ranks, { tag: "Low" } as Rank.Rank), 255, (t10: Tally.Tally): rs.u8 => { return t10.n & 0xff; })); - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(copy, { tag: "Low" } as Rank.Rank), 255, (t11: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(copy, { tag: "Low" } as Rank.Rank), 255, (t11: Tally.Tally): rs.u8 => { return t11.n & 0xff; })); - rt.byteVecPush(out, option_mapOr$1to2ul4(rt.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 255, (_218: [Rank.Rank, Tally.Tally]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0955beb(rs.hashRemoveEntry(copy, { tag: "Mid", _0: 1 } as Rank.Rank), 255, (_218: [Rank.Rank, Tally.Tally]): rs.u8 => { const k10: Rank.Rank = _218[0]; const t12: Tally.Tally = _218[1]; return rankByte(k10) ^ (t12.n & 0xff); })); - const _361: rt.Iter<[rt.u8, Tally.Tally]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_227: rt.u8): [rt.u8, Tally.Tally] => { - const b8: rt.u8 = _227; - return [rt.u8Rem(b8, 8), { n: b8 as rt.u16 }] as [rt.u8, Tally.Tally]; + const _361: rs.Iter<[rs.u8, Tally.Tally]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): [rs.u8, Tally.Tally] => { + const b8: rs.u8 = _227; + return [rs.u8Rem(b8, 8), { n: b8 as rs.u16 }] as [rs.u8, Tally.Tally]; }); - const bytes: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _361, undefined, undefined, undefined, 234881024); - const copy2: rt.HashMap = rt.hashClone(bytes, undefined, copy$collections_Tally); - const iter9: rt.Iter = rt.hashValues(copy2); + const bytes: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _361, undefined, undefined, undefined, 234881024); + const copy2: rs.HashMap = rs.hashClone(bytes, undefined, copy$collections_Tally); + const iter9: rs.Iter = rs.hashValues(copy2); while (true) { - const _369: Tally.Tally | rt.Done = iter9.next(); - if (_369 === rt.DONE) { + const _369: Tally.Tally | rs.Done = iter9.next(); + if (_369 === rs.DONE) { break; } - _369.n = rt.u16Add(_369.n, 1); + _369.n = rs.u16Add(_369.n, 1); } - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_377 = iterStart3++) < iterEnd3) { - const k4: rt.u8 = _377; - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(bytes, k4), 255, (t13: Tally.Tally): rt.u8 => { + const k4: rs.u8 = _377; + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(bytes, k4), 255, (t13: Tally.Tally): rs.u8 => { return t13.n & 0xff; })); - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(copy2, k4), 255, (t14: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(copy2, k4), 255, (t14: Tally.Tally): rs.u8 => { return t14.n & 0xff; })); } - for (const b5 of rt.byteSliceView(data)) { - rt.byteVecPush(out, claim(copy2, rt.u8Rem(b5, 8), b5 as rt.u16)); + for (const b5 of rs.byteSliceView(data)) { + rs.byteVecPush(out, claim(copy2, rs.u8Rem(b5, 8), b5 as rs.u16)); } - const stamped: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashShrinkTo(stamp(stamped), 0); - rt.hashReserve(stamp(stamped), 2, 234881024); - rt.byteVecPush(out, rt.hashLen(stamped) & 0xff); - const extended: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashExtend(extended, rt.iterMap(rt.hashIter(bytes), copy$tuple2_u8_collections_Tally), undefined, undefined, undefined, 234881024); - const iter12: rt.Iter = rt.hashValues(extended); + const stamped: rs.HashMap = rs.hashNew() as rs.HashMap; + rs.hashShrinkTo(stamp(stamped), 0); + rs.hashReserve(stamp(stamped), 2, 234881024); + rs.byteVecPush(out, rs.hashLen(stamped) & 0xff); + const extended: rs.HashMap = rs.hashNew() as rs.HashMap; + rs.hashExtend(extended, rs.iterMap(rs.hashIter(bytes), copy$tuple2_u8_collections_Tally), undefined, undefined, undefined, 234881024); + const iter12: rs.Iter = rs.hashValues(extended); while (true) { - const _422: Tally.Tally | rt.Done = iter12.next(); - if (_422 === rt.DONE) { + const _422: Tally.Tally | rs.Done = iter12.next(); + if (_422 === rs.DONE) { break; } _422.n = _422.n ^ 17; } - let iterStart4: rt.u8 = 0; - const iterEnd4: rt.u8 = 8; + let iterStart4: rs.u8 = 0; + const iterEnd4: rs.u8 = 8; while ((_429 = iterStart4++) < iterEnd4) { - const k5: rt.u8 = _429; - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(bytes, k5), 255, (t15: Tally.Tally): rt.u8 => { + const k5: rs.u8 = _429; + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(bytes, k5), 255, (t15: Tally.Tally): rs.u8 => { return t15.n & 0xff; })); - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(extended, k5), 255, (t16: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(extended, k5), 255, (t16: Tally.Tally): rs.u8 => { return t16.n & 0xff; })); } - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - rt.byteVecPush(out, rt.u64Eq(_443({ _0: first }), _443({ _0: first ^ 240 })) ? 1 : 0); - const _461: [rt.Hasher, Tally.Tally] = [rt.hasher(), { n: first as rt.u16 }]; - const h: rt.Hasher = _461[0]; + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + rs.byteVecPush(out, rs.u64Eq(_443({ _0: first }), _443({ _0: first ^ 240 })) ? 1 : 0); + const _461: [rs.Hasher, Tally.Tally] = [rs.hasher(), { n: first as rs.u16 }]; + const h: rs.Hasher = _461[0]; const counted: Tally.Tally = copy$collections_Tally(_461[1]); - const _466: rt.Hasher = countedHasher(h, counted); - rt.hash16(counted.n, _466); - const want: rt.Hasher = rt.hasher(); - rt.hash16(rt.u16Add(first as rt.u16, 1), want); - rt.byteVecPush(out, rt.u64Eq(rt.hashFinish(h), rt.hashFinish(want)) ? 1 : 0); - rt.hashRetain(ranks, (r2: Rank.Rank, t17: Tally.Tally): boolean => { - if (!(rt.u16Rem(t17.n, 2) === 0)) { + const _466: rs.Hasher = countedHasher(h, counted); + rs.hash16(counted.n, _466); + const want: rs.Hasher = rs.hasher(); + rs.hash16(rs.u16Add(first as rs.u16, 1), want); + rs.byteVecPush(out, rs.u64Eq(rs.hashFinish(h), rs.hashFinish(want)) ? 1 : 0); + rs.hashRetain(ranks, (r2: Rank.Rank, t17: Tally.Tally): boolean => { + if (!(rs.u16Rem(t17.n, 2) === 0)) { return Rank.eq$cmp_PartialEq(r2, { tag: "Low" } as Rank.Rank); } return true; }); - const _486: rt.Iter<[Rank.Rank, rt.u16]> = rt.iterMap(rt.hashIter(ranks), (_230: [Rank.Rank, Tally.Tally]): [Rank.Rank, rt.u16] => { - return [_230[0], _230[1].n] as [Rank.Rank, rt.u16]; + const _486: rs.Iter<[Rank.Rank, rs.u16]> = rs.iterMap(rs.hashIter(ranks), (_230: [Rank.Rank, Tally.Tally]): [Rank.Rank, rs.u16] => { + return [_230[0], _230[1].n] as [Rank.Rank, rs.u16]; }); - const iter14: rt.Iter<[Rank.Rank, rt.u16]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(Rank.cmp$cmp_Ord) as rt.BTreeMap, _486, true, undefined, undefined, "next", 6)); + const iter14: rs.Iter<[Rank.Rank, rs.u16]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(Rank.cmp$cmp_Ord) as rs.BTreeMap, _486, true, undefined, undefined, "next", 6)); while (true) { - const _492: [Rank.Rank, rt.u16] | rt.Done = iter14.next(); - if (_492 === rt.DONE) { + const _492: [Rank.Rank, rs.u16] | rs.Done = iter14.next(); + if (_492 === rs.DONE) { break; } - rt.byteVecPush(out, rankByte(_492[0])); - rt.byteVecPush(out, _492[1] & 0xff); + rs.byteVecPush(out, rankByte(_492[0])); + rs.byteVecPush(out, _492[1] & 0xff); } - rt.byteVecPush(out, rt.hashLen(tuples) & 0xff); + rs.byteVecPush(out, rs.hashLen(tuples) & 0xff); } else { - const words: rt.HashMap = rt.hashNew() as rt.HashMap; - for (const b6 of rt.byteSliceView(data)) { - const _515: rt.usize = rt.usizeRem(b6 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + const words: rs.HashMap = rs.hashNew() as rs.HashMap; + for (const b6 of rs.byteSliceView(data)) { + const _515: rs.usize = rs.usizeRem(b6 as rs.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); if (!(_515 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _515); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _515); } - rt.byteVecPush(rt.entryOrInsertWith(rt.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]), (): rt.ByteVec => { - return new rt.ByteVec(); + rs.byteVecPush(rs.entryOrInsertWith(rs.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_515]), (): rs.ByteVec => { + return new rs.ByteVec(); }), b6); } - const lens: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - const iter16: rt.Iter<[string, rt.ByteVec]> = rt.hashIter(words); + const lens: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; + const iter16: rs.Iter<[string, rs.ByteVec]> = rs.hashIter(words); while (true) { - const _530: [string, rt.ByteVec] | rt.Done = iter16.next(); - if (_530 === rt.DONE) { + const _530: [string, rs.ByteVec] | rs.Done = iter16.next(); + if (_530 === rs.DONE) { break; } - rt.btreeInsert(lens, _530[0], _530[1].length); + rs.btreeInsert(lens, _530[0], _530[1].length); } - const iter17: rt.Iter<[string, rt.usize]> = rt.btreeIter(lens); + const iter17: rs.Iter<[string, rs.usize]> = rs.btreeIter(lens); while (true) { - const _542: [string, rt.usize] | rt.Done = iter17.next(); - if (_542 === rt.DONE) { + const _542: [string, rs.usize] | rs.Done = iter17.next(); + if (_542 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_542[0])); - rt.byteVecPush(out, _542[1] & 0xff); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_542[0])); + rs.byteVecPush(out, _542[1] & 0xff); } - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.hashDrain(words), (_2: [string, rt.ByteVec]): rt.usize => { + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashDrain(words), (_2: [string, rs.ByteVec]): rs.usize => { return _2[1].length; - }), rt.usizeAdd, 0) & 0xff); - rt.byteVecPush(out, rt.hashLen(words) === 0 ? 1 : 0); - const clashes: rt.HashMap = rt.hashNew(rt.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rt.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rt.HashMap; - const iter18: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + }), rs.usizeAdd, 0) & 0xff); + rs.byteVecPush(out, rs.hashLen(words) === 0 ? 1 : 0); + const clashes: rs.HashMap = rs.hashNew(rs.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rs.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rs.HashMap; + const iter18: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _568: [rt.usize, rt.u8] | rt.Done = iter18.next(); - if (_568 === rt.DONE) { + const _568: [rs.usize, rs.u8] | rs.Done = iter18.next(); + if (_568 === rs.DONE) { break; } - const i5: rt.usize = _568[0]; - const b7: rt.u8 = _568[1]; - const k6: Clash.Clash = { _0: rt.u8Rem(b7, 8) }; - const _576: rt.u8 = rt.u8Rem(rt.u8Div(b7, 8), 4); + const i5: rs.usize = _568[0]; + const b7: rs.u8 = _568[1]; + const k6: Clash.Clash = { _0: rs.u8Rem(b7, 8) }; + const _576: rs.u8 = rs.u8Rem(rs.u8Div(b7, 8), 4); if (_576 === 0) { - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashRemove(clashes, k6), 238, (t7: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashRemove(clashes, k6), 238, (t7: Tally.Tally): rs.u8 => { return t7.n & 0xff; })); } else if (_576 === 1) { - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(clashes, k6), 221, (t6: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(clashes, k6), 221, (t6: Tally.Tally): rs.u8 => { return t6.n & 0xff; })); } else { - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashInsert(clashes, k6, { n: i5 & 0xffff }), 204, (t5: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashInsert(clashes, k6, { n: i5 & 0xffff }), 204, (t5: Tally.Tally): rs.u8 => { return t5.n & 0xff; })); } } - rt.hashRetain(clashes, (k7: Clash.Clash, t8: Tally.Tally): boolean => { - if (!(rt.u8Rem(k7._0, 3) !== 0)) { - return rt.u16Rem(t8.n, 2) === 0; + rs.hashRetain(clashes, (k7: Clash.Clash, t8: Tally.Tally): boolean => { + if (!(rs.u8Rem(k7._0, 3) !== 0)) { + return rs.u16Rem(t8.n, 2) === 0; } return true; }); - const _596: rt.Iter = rt.iterMap(rt.hashKeys(clashes), (k8: Clash.Clash): rt.u8 => { + const _596: rs.Iter = rs.iterMap(rs.hashKeys(clashes), (k8: Clash.Clash): rs.u8 => { return k8._0; }); - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _596, true, undefined, "next", 1)), undefined, true); - const copy3: rt.HashMap = rt.hashClone(clashes, undefined, copy$collections_Tally); - rt.byteVecPush(out, rt.hashLen(copy3) & 0xff); - rt.byteVecPush(out, rt.hashContains(copy3, { _0: 1 }) ? 1 : 0); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _596, true, undefined, "next", 1)), undefined, true); + const copy3: rs.HashMap = rs.hashClone(clashes, undefined, copy$collections_Tally); + rs.byteVecPush(out, rs.hashLen(copy3) & 0xff); + rs.byteVecPush(out, rs.hashContains(copy3, { _0: 1 }) ? 1 : 0); } } @@ -440,154 +440,154 @@ export function hashMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * Matching on an entry: add to an even tally, take out an odd one, or start one. * Counts a write, and gives back the hasher. */ -export function countedHasher(h: rt.Hasher, counted: Tally.Tally): rt.Hasher { - counted.n = rt.u16Add(counted.n, 1); +export function countedHasher(h: rs.Hasher, counted: Tally.Tally): rs.Hasher { + counted.n = rs.u16Add(counted.n, 1); return h; } /** Inserts a key, and gives back the map. */ -export function stamp(map: rt.HashMap): rt.HashMap { - rt.hashInsert(map, rt.hashLen(map) & 0xff, copy$collections_Tally(Tally.default$Default())); +export function stamp(map: rs.HashMap): rs.HashMap { + rs.hashInsert(map, rs.hashLen(map) & 0xff, copy$collections_Tally(Tally.default$Default())); return map; } -export function claim(map: rt.HashMap, k: rt.u8, n: rt.u16): rt.u8 { - const _4: rt.Entry = rt.entry(map, k); - if (rt.entryOccupied(_4)) { - if (!(rt.u16Rem(rt.entryGet(_4).n, 2) === 0)) { - return rt.entryRemove(_4).n & 0xff; +export function claim(map: rs.HashMap, k: rs.u8, n: rs.u16): rs.u8 { + const _4: rs.Entry = rs.entry(map, k); + if (rs.entryOccupied(_4)) { + if (!(rs.u16Rem(rs.entryGet(_4).n, 2) === 0)) { + return rs.entryRemove(_4).n & 0xff; } - const t: Tally.Tally = rt.entryGet(_4); - t.n = rt.u16Add(t.n, n); + const t: Tally.Tally = rs.entryGet(_4); + t.n = rs.u16Add(t.n, n); return 1; } - rt.entryOrInsert(_4, { n }); + rs.entryOrInsert(_4, { n }); return 0; } /** `HashSet` and `BTreeSet`, each with the same script. */ -export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _159: (a0: Nibble.Nibble | undefined) => rt.u8 = (n2: Nibble.Nibble | undefined): rt.u8 => { - return option_mapOr$0q0ymkh(n2, 238, (n3: Nibble.Nibble): rt.u8 => { +export function sets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _159: (a0: Nibble.Nibble | undefined) => rs.u8 = (n2: Nibble.Nibble | undefined): rs.u8 => { + return option_mapOr$0f7cus0(n2, 238, (n3: Nibble.Nibble): rs.u8 => { return n3._0; }); }; - const _160: (a0: Nibble.Nibble | undefined) => rt.u8 = (n4: Nibble.Nibble | undefined): rt.u8 => { - return option_mapOr$0q0ymkh(n4, 238, (n5: Nibble.Nibble): rt.u8 => { + const _160: (a0: Nibble.Nibble | undefined) => rs.u8 = (n4: Nibble.Nibble | undefined): rs.u8 => { + return option_mapOr$0f7cus0(n4, 238, (n5: Nibble.Nibble): rs.u8 => { return n5._0; }); }; - const _4: rt.u8 = rt.u8Rem(kind, 3); + const _4: rs.u8 = rs.u8Rem(kind, 3); if (_4 === 0) { - const hashed: rt.HashSet = rt.hashNew() as rt.HashSet; - const sorted: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - for (const b of rt.byteSliceView(data)) { - const v: rt.u16 = rt.u16Rem(b as rt.u16, 24); - const _17: rt.u8 = rt.u8Rem(b, 3); + const hashed: rs.HashSet = rs.hashNew() as rs.HashSet; + const sorted: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; + for (const b of rs.byteSliceView(data)) { + const v: rs.u16 = rs.u16Rem(b as rs.u16, 24); + const _17: rs.u8 = rs.u8Rem(b, 3); if (_17 === 0) { - rt.byteVecPush(out, rt.hashDelete(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeDelete(sorted, v) ? 1 : 0); + rs.byteVecPush(out, rs.hashDelete(hashed, v) ? 1 : 0); + rs.byteVecPush(out, rs.btreeDelete(sorted, v) ? 1 : 0); } else if (_17 === 1) { - rt.byteVecPush(out, rt.hashContains(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeContains(sorted, v) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(hashed, v) ? 1 : 0); + rs.byteVecPush(out, rs.btreeContains(sorted, v) ? 1 : 0); } else { - rt.byteVecPush(out, rt.hashAdd(hashed, v) ? 1 : 0); - rt.byteVecPush(out, rt.btreeAdd(sorted, v) ? 1 : 0); + rs.byteVecPush(out, rs.hashAdd(hashed, v) ? 1 : 0); + rs.byteVecPush(out, rs.btreeAdd(sorted, v) ? 1 : 0); } } - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.hashKeys(hashed), (v4: rt.u16): boolean => { - return rt.u16Rem(v4, 2) === 1; + rs.byteVecPush(out, rs.hashLen(hashed) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.hashKeys(hashed), (v4: rs.u16): boolean => { + return rs.u16Rem(v4, 2) === 1; })) & 0xff); - const iter2: rt.Iter = rt.iterRev(rt.btreeKeys(sorted)); + const iter2: rs.Iter = rs.iterRev(rs.btreeKeys(sorted)); while (true) { - const _62: rt.u16 | rt.Done = iter2.next(); - if (_62 === rt.DONE) { + const _62: rs.u16 | rs.Done = iter2.next(); + if (_62 === rs.DONE) { break; } - rt.byteVecPush(out, _62 & 0xff); + rs.byteVecPush(out, _62 & 0xff); } - rt.byteVecPush(out, option_unwrapOr$1j4op5y(rt.btreeFirstKey(sorted), 255) & 0xff); - rt.byteVecPush(out, option_unwrapOr$1j4op5y(rt.btreeFirstKey(sorted, true), 255) & 0xff); - const probe: rt.u16 = option_mapOr$0z4mj8g(rt.byteSliceFirst(data), 0, (_22: rt.u8): rt.u16 => { - return rt.u16Rem(_22 as rt.u16, 24); + rs.byteVecPush(out, option_unwrapOr$1szdyfq(rs.btreeFirstKey(sorted), 255) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1szdyfq(rs.btreeFirstKey(sorted, true), 255) & 0xff); + const probe: rs.u16 = option_mapOr$18dcmgz(rs.byteSliceFirst(data), 0, (_22: rs.u8): rs.u16 => { + return rs.u16Rem(_22 as rs.u16, 24); }); - const iter3: rt.Iter = rt.iterSlice([rt.hashReplace(hashed, probe), rt.btreeReplace(sorted, probe), rt.btreeKey(sorted, probe)]); + const iter3: rs.Iter = rs.iterSlice([rs.hashReplace(hashed, probe), rs.btreeReplace(sorted, probe), rs.btreeKey(sorted, probe)]); while (true) { - const _94: rt.u16 | undefined | rt.Done = iter3.next(); - if (_94 === rt.DONE) { + const _94: rs.u16 | undefined | rs.Done = iter3.next(); + if (_94 === rs.DONE) { break; } - rt.byteVecPush(out, option_unwrapOr$1j4op5y(_94, 255) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1szdyfq(_94, 255) & 0xff); } - const iter4: rt.Iter = rt.iterSlice([rt.hashKey(hashed, probe, true), rt.btreeKey(sorted, probe, true), rt.btreeKey(sorted, probe, true)]); + const iter4: rs.Iter = rs.iterSlice([rs.hashKey(hashed, probe, true), rs.btreeKey(sorted, probe, true), rs.btreeKey(sorted, probe, true)]); while (true) { - const _113: rt.u16 | undefined | rt.Done = iter4.next(); - if (_113 === rt.DONE) { + const _113: rs.u16 | undefined | rs.Done = iter4.next(); + if (_113 === rs.DONE) { break; } - rt.byteVecPush(out, option_unwrapOr$1j4op5y(_113, 255) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1szdyfq(_113, 255) & 0xff); } - rt.byteVecPush(out, rt.iterToVec(rt.btreeRangeKeys(sorted, new rt.Range(4, 12)), "next", 2).items.length & 0xff); - rt.hashRetain(hashed, (v5: rt.u16): boolean => { - return rt.u16Rem(v5, 3) !== 0; + rs.byteVecPush(out, rs.iterToVec(rs.btreeRangeKeys(sorted, new rs.Range(4, 12)), "next", 2).items.length & 0xff); + rs.hashRetain(hashed, (v5: rs.u16): boolean => { + return rs.u16Rem(v5, 3) !== 0; }); - rt.btreeRetain(sorted, (v6: rt.u16): boolean => { - return rt.u16Rem(v6, 3) !== 0; + rs.btreeRetain(sorted, (v6: rs.u16): boolean => { + return rs.u16Rem(v6, 3) !== 0; }); - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(sorted), (v7: rt.u16): rt.u8 => { + rs.byteVecPush(out, rs.hashLen(hashed) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(sorted), (v7: rs.u16): rs.u8 => { return v7 & 0xff; }), undefined, true); } else if (_4 === 1) { - const nibbles: rt.BTreeSet = rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet; - const seen: rt.HashSet = rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet; - for (const b2 of rt.byteSliceView(data)) { - rt.byteVecPush(out, rt.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); - rt.byteVecPush(out, rt.hashAdd(seen, { _0: b2 }) ? 1 : 0); + const nibbles: rs.BTreeSet = rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet; + const seen: rs.HashSet = rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet; + for (const b2 of rs.byteSliceView(data)) { + rs.byteVecPush(out, rs.btreeAdd(nibbles, { _0: b2 }) ? 1 : 0); + rs.byteVecPush(out, rs.hashAdd(seen, { _0: b2 }) ? 1 : 0); } - const iter6: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(data))); + const iter6: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _166: rt.u8 | rt.Done = iter6.next(); - if (_166 === rt.DONE) { + const _166: rs.u8 | rs.Done = iter6.next(); + if (_166 === rs.DONE) { break; } - const b3: rt.u8 = _166; - const _170: rt.u8 = rt.u8Rem(b3, 3); + const b3: rs.u8 = _166; + const _170: rs.u8 = rs.u8Rem(b3, 3); if (_170 === 0) { - const part5 = rt.btreeReplace(nibbles, { _0: b3 ^ 48 }); - const _173: rt.u8 = _159(part5); - const part6 = rt.hashReplace(seen, { _0: b3 ^ 48 }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_173, _159(part6))), undefined, true); + const part5 = rs.btreeReplace(nibbles, { _0: b3 ^ 48 }); + const _173: rs.u8 = _159(part5); + const part6 = rs.hashReplace(seen, { _0: b3 ^ 48 }); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_173, _159(part6))), undefined, true); } else if (_170 === 1) { - const part3 = rt.btreeKey(nibbles, { _0: b3 ^ 80 }, true); - const _188: rt.u8 = _159(part3); - const part4 = rt.hashKey(seen, { _0: b3 ^ 80 }, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_188, _159(part4))), undefined, true); + const part3 = rs.btreeKey(nibbles, { _0: b3 ^ 80 }, true); + const _188: rs.u8 = _159(part3); + const part4 = rs.hashKey(seen, { _0: b3 ^ 80 }, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_188, _159(part4))), undefined, true); } else { - const part = rt.btreeKey(nibbles, { _0: b3 ^ 112 }); - const _205: rt.u8 = _160(part); - const part2 = rt.hashKey(seen, { _0: b3 ^ 112 }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_205, _160(part2))), undefined, true); + const part = rs.btreeKey(nibbles, { _0: b3 ^ 112 }); + const _205: rs.u8 = _160(part); + const part2 = rs.hashKey(seen, { _0: b3 ^ 112 }); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_205, _160(part2))), undefined, true); } } - rt.iterExtendBytes(out, rt.iterOption(option_map$09ua5et(rt.hashKey(seen, { _0: 0 }), (n6: Nibble.Nibble): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$16w3l9s(rs.hashKey(seen, { _0: 0 }), (n6: Nibble.Nibble): rs.u8 => { return n6._0; })), undefined, true); - const iter7: rt.Iter = rt.btreeKeys(nibbles); + const iter7: rs.Iter = rs.btreeKeys(nibbles); while (true) { - const _229: Nibble.Nibble | rt.Done = iter7.next(); - if (_229 === rt.DONE) { + const _229: Nibble.Nibble | rs.Done = iter7.next(); + if (_229 === rs.DONE) { break; } - rt.byteVecPush(out, _229._0); + rs.byteVecPush(out, _229._0); } while (true) { - const _235: Nibble.Nibble | undefined = rt.btreePopKey(nibbles, true); + const _235: Nibble.Nibble | undefined = rs.btreePopKey(nibbles, true); if (_235 !== undefined) { - rt.byteVecPush(out, _235._0); - if (rt.usizeRem(rt.btreeLen(nibbles), 2) === 0) { - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.btreePopKey(nibbles), 238, (n7: Nibble.Nibble): rt.u8 => { + rs.byteVecPush(out, _235._0); + if (rs.usizeRem(rs.btreeLen(nibbles), 2) === 0) { + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.btreePopKey(nibbles), 238, (n7: Nibble.Nibble): rs.u8 => { return n7._0; })); } @@ -595,283 +595,283 @@ export function sets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - const dirs: rt.HashSet = rt.hashNew(rt.hashing(Dir.hash$Hash_hash_DefaultHasher as (a0: Dir.Dir, a1: rt.Hasher) => undefined, Dir.eq$cmp_PartialEq, true)) as rt.HashSet; - for (const _257 of rt.byteSliceView(data)) { - const _266: rt.usize = rt.usizeRem(_257 as rt.usize, 3); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); + const dirs: rs.HashSet = rs.hashNew(rs.hashing(Dir.hash$Hash_hash_DefaultHasher as (a0: Dir.Dir, a1: rs.Hasher) => undefined, Dir.eq$cmp_PartialEq, true)) as rs.HashSet; + for (const _257 of rs.byteSliceView(data)) { + const _266: rs.usize = rs.usizeRem(_257 as rs.usize, 3); if (!(_266 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _266); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _266); } - rt.byteVecPush(out, rt.hashAdd(dirs, ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir][_266]) ? 1 : 0); + rs.byteVecPush(out, rs.hashAdd(dirs, ["Up" as Dir.Dir, "Top" as Dir.Dir, "Down" as Dir.Dir][_266]) ? 1 : 0); } - rt.byteVecPush(out, rt.hashLen(dirs) & 0xff); + rs.byteVecPush(out, rs.hashLen(dirs) & 0xff); } else { - const words: rt.BTreeSet = rt.btreeNew(rt.cmpStr) as rt.BTreeSet; - for (const _281 of rt.byteSliceView(data)) { - const _288: rt.usize = rt.usizeRem(_281 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + const words: rs.BTreeSet = rs.btreeNew(rs.cmpStr) as rs.BTreeSet; + for (const _281 of rs.byteSliceView(data)) { + const _288: rs.usize = rs.usizeRem(_281 as rs.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); if (!(_288 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _288); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _288); } - rt.btreeAdd(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_288]); + rs.btreeAdd(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_288]); } - const iter10: rt.Iter = rt.btreeKeys(words); + const iter10: rs.Iter = rs.btreeKeys(words); while (true) { - const _298: string | rt.Done = iter10.next(); - if (_298 === rt.DONE) { + const _298: string | rs.Done = iter10.next(); + if (_298 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_298)); - rt.byteVecPush(out, 0); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_298)); + rs.byteVecPush(out, 0); } - const _306: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { + const _306: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { return wide(_2); }); - const iter11: rt.Iter = rt.iterRev(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _306, true, undefined, undefined, 8, true))); + const iter11: rs.Iter = rs.iterRev(rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _306, true, undefined, undefined, 8, true))); while (true) { - const _313: rt.u64 | rt.Done = iter11.next(); - if (_313 === rt.DONE) { + const _313: rs.u64 | rs.Done = iter11.next(); + if (_313 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_313))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_313))); } } } /** `BTreeMap`: ordered by the key's `Ord`, through inserts, removals, and ranges. */ -export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let within!: rt.ByteVec; - let _185!: rt.usize; - let _365!: rt.usize; - let _422!: rt.u8; - const _4: rt.u8 = rt.u8Rem(kind, 4); +export function btreeMaps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let within!: rs.ByteVec; + let _185!: rs.usize; + let _365!: rs.usize; + let _422!: rs.u8; + const _4: rs.u8 = rs.u8Rem(kind, 4); if (_4 === 0) { - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter: rt.Iter = rt.iterStepBy(new rt.Range(0, data.length), 2, undefined, 4294967295); + const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const iter: rs.Iter = rs.iterStepBy(new rs.Range(0, data.length), 2, undefined, 4294967295); while (true) { - const _13: rt.usize | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.usize | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13; - rt.idx(data, i); - const _19: [rt.u8, rt.u8] = [rt.u8Rem(data.data[data.start + i], 32), option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(i, 1)), 0)]; - const k: rt.u8 = _19[0]; - const v: rt.u8 = _19[1]; - const _30: rt.u8 = rt.u8Rem(v, 6); + const i: rs.usize = _13; + rs.idx(data, i); + const _19: [rs.u8, rs.u8] = [rs.u8Rem(data.data[data.start + i], 32), option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(i, 1)), 0)]; + const k: rs.u8 = _19[0]; + const v: rs.u8 = _19[1]; + const _30: rs.u8 = rs.u8Rem(v, 6); if (_30 === 0) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(map, k), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(map, k), 238)); } else if (_30 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.btreePop(map), 221, (_224: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.btreePop(map), 221, (_224: [rs.u8, rs.u8]): rs.u8 => { return _224[0] ^ _224[1]; })); } else if (_30 === 2) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.btreePop(map, true), 220, (_222: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.btreePop(map, true), 220, (_222: [rs.u8, rs.u8]): rs.u8 => { return _222[0] ^ _222[1]; })); } else if (_30 === 3) { - const _42: rt.u8 | undefined = rt.btreeGet(map, k); + const _42: rs.u8 | undefined = rs.btreeGet(map, k); if (_42 !== undefined) { - const _50: rt.u8 = rt.u8WrappingAdd(_42, 1); - rt.btreeInsert(map, k, _50); + const _50: rs.u8 = rs.u8WrappingAdd(_42, 1); + rs.btreeInsert(map, k, _50); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeGet(map, k), 219)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(map, k), 219)); } else { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(map, k, v), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(map, k, v), 204)); } } - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.btreeFirst(map), 255, (_225: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.btreeFirst(map), 255, (_225: [rs.u8, rs.u8]): rs.u8 => { return _225[0]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.btreeFirst(map, true), 255, (_227: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.btreeFirst(map, true), 255, (_227: [rs.u8, rs.u8]): rs.u8 => { return _227[0]; })); - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.btreeRange(map, new rt.Range(8, 24)); + const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.btreeRange(map, new rs.Range(8, 24)); while (true) { - const _73: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_73 === rt.DONE) { + const _73: [rs.u8, rs.u8] | rs.Done = iter2.next(); + if (_73 === rs.DONE) { break; } - rt.byteVecPush(out, _73[0]); - rt.byteVecPush(out, _73[1]); + rs.byteVecPush(out, _73[0]); + rs.byteVecPush(out, _73[1]); } - const iter3: rt.Iter<[rt.u8, rt.u8]> = rt.iterRev(rt.btreeRange(map, new rt.RangeFrom(10, rt.u8Step))); + const iter3: rs.Iter<[rs.u8, rs.u8]> = rs.iterRev(rs.btreeRange(map, new rs.RangeFrom(10, rs.u8Step))); while (true) { - const _88: [rt.u8, rt.u8] | rt.Done = iter3.next(); - if (_88 === rt.DONE) { + const _88: [rs.u8, rs.u8] | rs.Done = iter3.next(); + if (_88 === rs.DONE) { break; } - rt.byteVecPush(out, _88[0] ^ _88[1]); + rs.byteVecPush(out, _88[0] ^ _88[1]); } - const iter4: rt.Iter = rt.iterMap(rt.btreeRange(map, { end: 6 }), (_228: [rt.u8, rt.u8]): rt.u8 => { + const iter4: rs.Iter = rs.iterMap(rs.btreeRange(map, { end: 6 }), (_228: [rs.u8, rs.u8]): rs.u8 => { return _228[1]; }); while (true) { - const _101: rt.u8 | rt.Done = iter4.next(); - if (_101 === rt.DONE) { + const _101: rs.u8 | rs.Done = iter4.next(); + if (_101 === rs.DONE) { break; } - rt.byteVecPush(out, _101); + rs.byteVecPush(out, _101); } - rt.iterExtendBytes(out, rt.btreeKeys(map), undefined, true); - rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.btreeKeys(map).nextBack()), 255, (k4: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeKeys(map), undefined, true); + rs.iterExtendBytes(out, rs.btreeValues(map), undefined, true); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.btreeKeys(map).nextBack()), 255, (k4: rs.u8): rs.u8 => { return k4; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(rt.btreeIter(map).next()), 255, (_229: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(rs.btreeIter(map).next()), 255, (_229: [rs.u8, rs.u8]): rs.u8 => { return _229[0] ^ _229[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(rt.btreeRange(map, new rt.RangeFrom(4, rt.u8Step)).nextBack()), 255, (_230: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(rs.btreeRange(map, new rs.RangeFrom(4, rs.u8Step)).nextBack()), 255, (_230: [rs.u8, rs.u8]): rs.u8 => { return _230[0] ^ _230[1]; })); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterMax(rt.btreeValues(map), rt.lt), 255, (v6: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterMax(rs.btreeValues(map), rs.lt), 255, (v6: rs.u8): rs.u8 => { return v6; })); - rt.btreeRemove(map, 3); - rt.byteVecPush(out, rt.btreeLen(map) & 0xff); - rt.byteVecPush(out, rt.btreeContains(map, 3) ? 1 : 0); - const lo: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 32); - const hi: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0), 32); - const _158: rt.u8 = rt.u8Rem(lo, 3); + rs.btreeRemove(map, 3); + rs.byteVecPush(out, rs.btreeLen(map) & 0xff); + rs.byteVecPush(out, rs.btreeContains(map, 3) ? 1 : 0); + const lo: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 32); + const hi: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0), 32); + const _158: rs.u8 = rs.u8Rem(lo, 3); if (_158 === 0) { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.Range(lo, hi)), (_236: [rt.u8, rt.u8]): rt.u8 => { + within = rs.iterToByteVec(rs.iterMap(rs.btreeRange(map, new rs.Range(lo, hi)), (_236: [rs.u8, rs.u8]): rs.u8 => { return _236[0]; }), "next"); } else if (_158 === 1) { - const _167: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, _167), (_235: [rt.u8, rt.u8]): rt.u8 => { + const _167: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u8Step); + within = rs.iterToByteVec(rs.iterMap(rs.btreeRange(map, _167), (_235: [rs.u8, rs.u8]): rs.u8 => { return _235[0]; }), "next"); } else { - within = rt.iterToByteVec(rt.iterMap(rt.btreeRange(map, new rt.RangeFrom(lo, rt.u8Step)), (_234: [rt.u8, rt.u8]): rt.u8 => { + within = rs.iterToByteVec(rs.iterMap(rs.btreeRange(map, new rs.RangeFrom(lo, rs.u8Step)), (_234: [rs.u8, rs.u8]): rs.u8 => { return _234[0]; }), "next"); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(within)); - rt.iterExtendBytes(out, rt.btreeValues(map), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(within)); + rs.iterExtendBytes(out, rs.btreeValues(map), undefined, true); } else if (_4 === 1) { - const ranks: rt.BTreeMap = rt.btreeNew(Rank.cmp$cmp_Ord) as rt.BTreeMap; - const pairs: rt.BTreeMap<[rt.u8, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u8>; - const wides: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; + const ranks: rs.BTreeMap = rs.btreeNew(Rank.cmp$cmp_Ord) as rs.BTreeMap; + const pairs: rs.BTreeMap<[rs.u8, rs.u8], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8], rs.u8>; + const wides: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = data.length; while ((_185 = iterStart++) < iterEnd) { - const i2: rt.usize = _185; - const _193: rt.usize = rt.usizeSub(i2, 1); - rt.idx(data, _193); - const _192: rt.u8 = data.data[data.start + _193]; - rt.idx(data, i2); - const _191: [rt.u8, rt.u8] = [_192, data.data[data.start + i2]]; - const a: rt.u8 = _192; - const b: rt.u8 = _191[1]; + const i2: rs.usize = _185; + const _193: rs.usize = rs.usizeSub(i2, 1); + rs.idx(data, _193); + const _192: rs.u8 = data.data[data.start + _193]; + rs.idx(data, i2); + const _191: [rs.u8, rs.u8] = [_192, data.data[data.start + i2]]; + const a: rs.u8 = _192; + const b: rs.u8 = _191[1]; const _203: Rank.Rank = rank(a, b); - const t: Tally.Tally = rt.entryOrInsertWith(rt.entry(ranks, _203), Tally.default$Default); - t.n = rt.u16WrappingAdd(t.n, b as rt.u16); - const _209: [rt.u8, rt.u8] = [rt.u8Rem(a, 4), rt.u8Rem(b, 4)]; - rt.btreeInsert(pairs, _209, a); - const _217: rt.u64 = wide(a); - rt.entryOrInsertMut(rt.entry(wides, _217), b); - } - const _218: Tally.Tally | undefined = rt.btreeGet(ranks, { tag: "Low" } as Rank.Rank); + const t: Tally.Tally = rs.entryOrInsertWith(rs.entry(ranks, _203), Tally.default$Default); + t.n = rs.u16WrappingAdd(t.n, b as rs.u16); + const _209: [rs.u8, rs.u8] = [rs.u8Rem(a, 4), rs.u8Rem(b, 4)]; + rs.btreeInsert(pairs, _209, a); + const _217: rs.u64 = wide(a); + rs.entryOrInsertMut(rs.entry(wides, _217), b); + } + const _218: Tally.Tally | undefined = rs.btreeGet(ranks, { tag: "Low" } as Rank.Rank); if (_218 !== undefined) { _218.n = _218.n ^ 23130; } - for (const b2 of rt.byteSliceView(data)) { - const r: Rank.Rank = rank(b2, rt.u8Div(b2, 3)); - const _233: rt.Entry = rt.entry(ranks, r); - if (!rt.entryOccupied(_233)) { - const e: rt.Entry = _233; - rt.byteVecPush(out, rankByte(rt.entryKey(e))); - rt.entryOrInsert(e, { n: b2 as rt.u16 }); - } else if (!(rt.entryGet(_233).n > 256)) { - rt.byteVecPush(out, rt.entryInsert(_233, { n: 512 }).n & 0xff); + for (const b2 of rs.byteSliceView(data)) { + const r: Rank.Rank = rank(b2, rs.u8Div(b2, 3)); + const _233: rs.Entry = rs.entry(ranks, r); + if (!rs.entryOccupied(_233)) { + const e: rs.Entry = _233; + rs.byteVecPush(out, rankByte(rs.entryKey(e))); + rs.entryOrInsert(e, { n: b2 as rs.u16 }); + } else if (!(rs.entryGet(_233).n > 256)) { + rs.byteVecPush(out, rs.entryInsert(_233, { n: 512 }).n & 0xff); } else { - rt.byteVecPush(out, rankByte(rt.entryRemoveEntry(_233)[0])); + rs.byteVecPush(out, rankByte(rs.entryRemoveEntry(_233)[0])); } } - const iter7: rt.Iter<[Rank.Rank, Tally.Tally]> = rt.btreeIter(ranks); + const iter7: rs.Iter<[Rank.Rank, Tally.Tally]> = rs.btreeIter(ranks); while (true) { - const _261: [Rank.Rank, Tally.Tally] | rt.Done = iter7.next(); - if (_261 === rt.DONE) { + const _261: [Rank.Rank, Tally.Tally] | rs.Done = iter7.next(); + if (_261 === rs.DONE) { break; } - rt.byteVecPush(out, rankByte(_261[0])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_261[1].n))); + rs.byteVecPush(out, rankByte(_261[0])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_261[1].n))); } - const iter8: rt.Iter<[[rt.u8, rt.u8], rt.u8]> = rt.btreeIter(pairs); + const iter8: rs.Iter<[[rs.u8, rs.u8], rs.u8]> = rs.btreeIter(pairs); while (true) { - const _276: [[rt.u8, rt.u8], rt.u8] | rt.Done = iter8.next(); - if (_276 === rt.DONE) { + const _276: [[rs.u8, rs.u8], rs.u8] | rs.Done = iter8.next(); + if (_276 === rs.DONE) { break; } - rt.byteVecPush(out, rt.u8Shl(_276[0][0], 4) | _276[0][1]); - rt.byteVecPush(out, _276[1]); + rs.byteVecPush(out, rs.u8Shl(_276[0][0], 4) | _276[0][1]); + rs.byteVecPush(out, _276[1]); } - const _290: rt.RangeFrom = new rt.RangeFrom(4503599627370496, rt.u64Step); - const iter9: rt.Iter<[rt.u64, rt.u8]> = rt.btreeRange(wides, _290); + const _290: rs.RangeFrom = new rs.RangeFrom(4503599627370496, rs.u64Step); + const iter9: rs.Iter<[rs.u64, rs.u8]> = rs.btreeRange(wides, _290); while (true) { - const _295: [rt.u64, rt.u8] | rt.Done = iter9.next(); - if (_295 === rt.DONE) { + const _295: [rs.u64, rs.u8] | rs.Done = iter9.next(); + if (_295 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_295[0]))); - rt.byteVecPush(out, _295[1]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_295[0]))); + rs.byteVecPush(out, _295[1]); } } else if (_4 === 2) { - const _308: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_221: rt.u8): [Fussy.Fussy, Fussy.Fussy] => { - const b8: rt.u8 = _221; + const _308: rs.Iter<[Fussy.Fussy, Fussy.Fussy]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_221: rs.u8): [Fussy.Fussy, Fussy.Fussy] => { + const b8: rs.u8 = _221; return [{ _0: b8 }, { _0: b8 ^ 90 }] as [Fussy.Fussy, Fussy.Fussy]; }); - const iter10: rt.Iter<[Fussy.Fussy, Fussy.Fussy]> = rt.btreeIter(rt.btreeClone(rt.btreeExtend(rt.btreeNew(Fussy.cmp$cmp_Ord) as rt.BTreeMap, _308, true, undefined, undefined, undefined, 2, true), Fussy.clone$Clone, Fussy.clone$Clone)); + const iter10: rs.Iter<[Fussy.Fussy, Fussy.Fussy]> = rs.btreeIter(rs.btreeClone(rs.btreeExtend(rs.btreeNew(Fussy.cmp$cmp_Ord) as rs.BTreeMap, _308, true, undefined, undefined, undefined, 2, true), Fussy.clone$Clone, Fussy.clone$Clone)); while (true) { - const _315: [Fussy.Fussy, Fussy.Fussy] | rt.Done = iter10.next(); - if (_315 === rt.DONE) { + const _315: [Fussy.Fussy, Fussy.Fussy] | rs.Done = iter10.next(); + if (_315 === rs.DONE) { break; } - rt.byteVecPush(out, _315[0]._0 ^ _315[1]._0); + rs.byteVecPush(out, _315[0]._0 ^ _315[1]._0); } } else { - const nibbles: rt.BTreeMap = rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeMap; - const words: rt.BTreeMap = rt.btreeNew(rt.cmpStr) as rt.BTreeMap; - for (const b3 of rt.byteSliceView(data)) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(nibbles, { _0: b3 }, b3), 204)); - const _341: rt.usize = rt.usizeRem(b3 as rt.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); + const nibbles: rs.BTreeMap = rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeMap; + const words: rs.BTreeMap = rs.btreeNew(rs.cmpStr) as rs.BTreeMap; + for (const b3 of rs.byteSliceView(data)) { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(nibbles, { _0: b3 }, b3), 204)); + const _341: rs.usize = rs.usizeRem(b3 as rs.usize, ["", "a", "ab", "b", "é", "", "￿", "𐀀"].length); if (!(_341 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _341); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _341); } - const t2: Tally.Tally = rt.entryOrInsertWith(rt.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_341]), Tally.default$Default); - t2.n = rt.u16Add(t2.n, 1); + const t2: Tally.Tally = rs.entryOrInsertWith(rs.entry(words, ["", "a", "ab", "b", "é", "", "￿", "𐀀"][_341]), Tally.default$Default); + t2.n = rs.u16Add(t2.n, 1); } - const iter12: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.btreeIter(nibbles); + const iter12: rs.Iter<[Nibble.Nibble, rs.u8]> = rs.btreeIter(nibbles); while (true) { - const _352: [Nibble.Nibble, rt.u8] | rt.Done = iter12.next(); - if (_352 === rt.DONE) { + const _352: [Nibble.Nibble, rs.u8] | rs.Done = iter12.next(); + if (_352 === rs.DONE) { break; } - rt.byteVecPush(out, _352[0]._0); - rt.byteVecPush(out, _352[1]); + rs.byteVecPush(out, _352[0]._0); + rs.byteVecPush(out, _352[1]); } - let iterStart2: rt.usize = 1; - const iterEnd2: rt.usize = data.length; + let iterStart2: rs.usize = 1; + const iterEnd2: rs.usize = data.length; while ((_365 = iterStart2++) < iterEnd2) { - const i3: rt.usize = _365; - const _374: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _374); + const i3: rs.usize = _365; + const _374: rs.usize = rs.usizeSub(i3, 1); + rs.idx(data, _374); const _372: Nibble.Nibble = { _0: data.data[data.start + _374] }; - rt.idx(data, i3); + rs.idx(data, i3); const _371: [Nibble.Nibble, Nibble.Nibble] = [_372, { _0: data.data[data.start + i3] }]; const a2: Nibble.Nibble = _372; const b4: Nibble.Nibble = _371[1]; - const _386: rt.usize = rt.usizeSub(i3, 1); - rt.idx(data, _386); - const _385: rt.u8 = data.data[data.start + _386]; - rt.idx(data, i3); - const _384: [rt.u8, rt.u8] = [_385, data.data[data.start + i3]]; - const x: rt.u8 = _385; - const y: rt.u8 = _384[1]; - const o: rt.Ordering = rt.orderingThen(rt.orderingReverse(Nibble.cmp$cmp_Ord(a2, b4)), (): rt.Ordering => { - return rt.cmp(y, x); + const _386: rs.usize = rs.usizeSub(i3, 1); + rs.idx(data, _386); + const _385: rs.u8 = data.data[data.start + _386]; + rs.idx(data, i3); + const _384: [rs.u8, rs.u8] = [_385, data.data[data.start + i3]]; + const x: rs.u8 = _385; + const y: rs.u8 = _384[1]; + const o: rs.Ordering = rs.orderingThen(rs.orderingReverse(Nibble.cmp$cmp_Ord(a2, b4)), (): rs.Ordering => { + return rs.cmp(y, x); }, true); - rt.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rt.orderingThen(Nibble.cmp$cmp_Ord(a2, b4), -1 as rt.Ordering) === 0 ? 1 : 0) << 2) & 0xff)); + rs.byteVecPush(out, (o < 0 ? 1 : 0) | (((o >= 0 ? 1 : 0) << 1) & 0xff) | (((rs.orderingThen(Nibble.cmp$cmp_Ord(a2, b4), -1 as rs.Ordering) === 0 ? 1 : 0) << 2) & 0xff)); if (o === -1) { _422 = 1; } else if (o === 0) { @@ -879,171 +879,171 @@ export function btreeMaps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } else { _422 = 3; } - rt.byteVecPush(out, _422); - rt.byteVecPush(out, o === 1 ? 1 : 0); + rs.byteVecPush(out, _422); + rs.byteVecPush(out, o === 1 ? 1 : 0); } - const _430: rt.Iter<[Nibble.Nibble, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [Nibble.Nibble, rt.u8] => { - const b5: rt.u8 = _2; - return [{ _0: b5 }, b5] as [Nibble.Nibble, rt.u8]; + const _430: rs.Iter<[Nibble.Nibble, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [Nibble.Nibble, rs.u8] => { + const b5: rs.u8 = _2; + return [{ _0: b5 }, b5] as [Nibble.Nibble, rs.u8]; }); - const collected: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_430, undefined, 2, true).items, 2, true, Nibble.eq$cmp_PartialEq); - const _433: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): Nibble.Nibble => { + const collected: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_430, undefined, 2, true).items, 2, true, Nibble.eq$cmp_PartialEq); + const _433: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): Nibble.Nibble => { return { _0: _216 }; }); - const keys: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_433, undefined, 1, true).items, 1, true, rt.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); - const _437: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): Nibble.Nibble => { + const keys: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_433, undefined, 1, true).items, 1, true, rs.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); + const _437: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_219: rs.u8): Nibble.Nibble => { return { _0: _219 ^ 48 }; }); - rt.btreeExtendKeys(keys, _437); - const iter14: rt.Iter<[[Nibble.Nibble, rt.u8], Nibble.Nibble]> = rt.iterZip(rt.btreeIter(collected), rt.btreeKeys(keys), "len"); + rs.btreeExtendKeys(keys, _437); + const iter14: rs.Iter<[[Nibble.Nibble, rs.u8], Nibble.Nibble]> = rs.iterZip(rs.btreeIter(collected), rs.btreeKeys(keys), "len"); while (true) { - const _446: [[Nibble.Nibble, rt.u8], Nibble.Nibble] | rt.Done = iter14.next(); - if (_446 === rt.DONE) { + const _446: [[Nibble.Nibble, rs.u8], Nibble.Nibble] | rs.Done = iter14.next(); + if (_446 === rs.DONE) { break; } - rt.byteVecPush(out, _446[0][0]._0); - rt.byteVecPush(out, _446[0][1]); - rt.byteVecPush(out, _446[1]._0); + rs.byteVecPush(out, _446[0][0]._0); + rs.byteVecPush(out, _446[0][1]); + rs.byteVecPush(out, _446[1]._0); } - rt.btreeRetain(words, (w: string, t3: Tally.Tally): boolean => { - if (!(rt.stringLen(w) > 1)) { + rs.btreeRetain(words, (w: string, t3: Tally.Tally): boolean => { + if (!(rs.stringLen(w) > 1)) { return t3.n > 1; } return true; }); - const iter15: rt.Iter<[string, Tally.Tally]> = rt.btreeIter(words); + const iter15: rs.Iter<[string, Tally.Tally]> = rs.btreeIter(words); while (true) { - const _463: [string, Tally.Tally] | rt.Done = iter15.next(); - if (_463 === rt.DONE) { + const _463: [string, Tally.Tally] | rs.Done = iter15.next(); + if (_463 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_463[0])); - rt.byteVecPush(out, _463[1].n & 0xff); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_463[0])); + rs.byteVecPush(out, _463[1].n & 0xff); } } } /** Pushes an item, and gives back the deque. */ -export function touch(q: rt.VecDeque): rt.VecDeque { - rt.dequePushBack(q, 66); +export function touch(q: rs.VecDeque): rs.VecDeque { + rs.dequePushBack(q, 66); return q; } /** `VecDeque`: a ring buffer, pushed and popped at both ends past its capacity. */ -export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { - let drained2!: rt.ByteVec; - const q: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; - const pairs: rt.VecDeque<[rt.u8, rt.u8]> = rt.dequeWithCapacity(2, 2) as rt.VecDeque<[rt.u8, rt.u8]>; - for (const b of rt.byteSliceView(data)) { - const _12: rt.u8 = rt.u8Rem(b, 7); +export function deques(data: rs.ByteSlice, out: rs.ByteVec): void { + let drained2!: rs.ByteVec; + const q: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; + const pairs: rs.VecDeque<[rs.u8, rs.u8]> = rs.dequeWithCapacity(2, 2) as rs.VecDeque<[rs.u8, rs.u8]>; + for (const b of rs.byteSliceView(data)) { + const _12: rs.u8 = rs.u8Rem(b, 7); if (_12 === 0) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequePopFront(q), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequePopFront(q), 238)); } else if (_12 === 1) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequePopBack(q), 237)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequePopBack(q), 237)); } else if (_12 === 2) { - rt.dequePushFront(q, b); + rs.dequePushFront(q, b); } else if (_12 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q), 236)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeEnd(q, true), 235)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeGet(q, rt.usizeRem(b as rt.usize, 5)), 234)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeEnd(q), 236)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeEnd(q, true), 235)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeGet(q, rs.usizeRem(b as rs.usize, 5)), 234)); } else { - rt.dequePushBack(q, b); + rs.dequePushBack(q, b); } - const _42: [rt.u8, rt.u8] = [b, q.n & 0xff]; - rt.dequePushBack(pairs, _42); + const _42: [rs.u8, rs.u8] = [b, q.n & 0xff]; + rs.dequePushBack(pairs, _42); if (pairs.n > 3) { - rt.dequePopFront(pairs); + rs.dequePopFront(pairs); } } - const at: rt.usize = option_mapOr$1t0muvr(rt.byteSliceLast(data), 0, (_2: rt.u8): rt.usize => { - return rt.usizeRem(_2 as rt.usize, 6); + const at: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceLast(data), 0, (_2: rs.u8): rs.usize => { + return rs.usizeRem(_2 as rs.usize, 6); }); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at, true), 232)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeSwapRemove(q, at), 231)); - rt.dequeShrinkTo(touch(q), 0); - rt.dequeReserve(touch(q), 1); - rt.byteVecPush(out, q.n & 0xff); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeSwapRemove(q, at, true), 232)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeSwapRemove(q, at), 231)); + rs.dequeShrinkTo(touch(q), 0); + rs.dequeReserve(touch(q), 1); + rs.byteVecPush(out, q.n & 0xff); + rs.iterExtendBytes(out, rs.iterRev(rs.dequeIter(q)), undefined, true); if (!(q.n === 0)) { - rt.byteVecPush(out, rt.dequeIndex(q, rt.usizeDiv(q.n, 2))); + rs.byteVecPush(out, rs.dequeIndex(q, rs.usizeDiv(q.n, 2))); } - rt.dequeRetain(q, (b4: rt.u8): boolean => { - return rt.u8Rem(b4, 2) === 0; + rs.dequeRetain(q, (b4: rs.u8): boolean => { + return rs.u8Rem(b4, 2) === 0; }); - rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.dequeIter(pairs); + rs.iterExtendBytes(out, rs.dequeIter(q), undefined, true); + const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.dequeIter(pairs); while (true) { - const _93: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_93 === rt.DONE) { + const _93: [rs.u8, rs.u8] | rs.Done = iter2.next(); + if (_93 === rs.DONE) { break; } - rt.byteVecPush(out, _93[0] ^ _93[1]); + rs.byteVecPush(out, _93[0] ^ _93[1]); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.dequeDrain(q, undefined), "next"))); - rt.byteVecPush(out, q.n === 0 ? 1 : 0); - const tallies: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Tally.Tally => { - return { n: _25 as rt.u16 }; - }), undefined, 2, true), 2) as rt.VecDeque; - const copy: rt.VecDeque = rt.dequeClone(tallies, copy$collections_Tally); - const _115: Tally.Tally | undefined = rt.dequeEnd(copy); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.dequeDrain(q, undefined), "next"))); + rs.byteVecPush(out, q.n === 0 ? 1 : 0); + const tallies: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): Tally.Tally => { + return { n: _25 as rs.u16 }; + }), undefined, 2, true), 2) as rs.VecDeque; + const copy: rs.VecDeque = rs.dequeClone(tallies, copy$collections_Tally); + const _115: Tally.Tally | undefined = rs.dequeEnd(copy); if (_115 !== undefined) { _115.n = _115.n ^ 255; } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t2: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(tallies), (t2: Tally.Tally): rs.u8 => { return t2.n & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t3: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(copy), (t3: Tally.Tally): rs.u8 => { return t3.n & 0xff; }), undefined, true); - const _129: rt.Iter = rt.dequeIter(tallies); - rt.dequeExtend(copy, rt.iterMap(_129, copy$collections_Tally), undefined, true); - const _131: Tally.Tally | undefined = rt.dequeEnd(copy, true); + const _129: rs.Iter = rs.dequeIter(tallies); + rs.dequeExtend(copy, rs.iterMap(_129, copy$collections_Tally), undefined, true); + const _131: Tally.Tally | undefined = rs.dequeEnd(copy, true); if (_131 !== undefined) { _131.n = _131.n ^ 255; } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(tallies), (t4: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(tallies), (t4: Tally.Tally): rs.u8 => { return t4.n & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t5: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(copy), (t5: Tally.Tally): rs.u8 => { return t5.n & 0xff; }), undefined, true); - const iter3: rt.Iter = rt.iterSlice([copy$Option_collections_Tally(rt.dequeSwapRemove(copy, at)), copy$Option_collections_Tally(rt.dequeSwapRemove(copy, at, true))]); + const iter3: rs.Iter = rs.iterSlice([copy$Option_collections_Tally(rs.dequeSwapRemove(copy, at)), copy$Option_collections_Tally(rs.dequeSwapRemove(copy, at, true))]); while (true) { - const _150: Tally.Tally | undefined | rt.Done = iter3.next(); - if (_150 === rt.DONE) { + const _150: Tally.Tally | undefined | rs.Done = iter3.next(); + if (_150 === rs.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1ht002r(_150, 230, (t6: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(_150, 230, (t6: Tally.Tally): rs.u8 => { return t6.n & 0xff; })); } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(copy), (t7: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(copy), (t7: Tally.Tally): rs.u8 => { return t7.n & 0xff; }), undefined, true); - const _162: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.dequeExtend(q, _162, undefined, true); - rt.dequeInsert(q, rt.usizeDiv(q.n, 2), 66); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.dequeRemove(q, 1), 233)); - rt.dequeTruncate(q, 5); - rt.byteVecPush(out, rt.dequeContains(q, 66, rt.same) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeIter(q)), undefined, true); - const a: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, 8); - const b2: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, 8); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; - const _201: rt.usize = rt.usizeRem(a, 4); + const _162: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.dequeExtend(q, _162, undefined, true); + rs.dequeInsert(q, rs.usizeDiv(q.n, 2), 66); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.dequeRemove(q, 1), 233)); + rs.dequeTruncate(q, 5); + rs.byteVecPush(out, rs.dequeContains(q, 66, rs.same) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterRev(rs.dequeIter(q)), undefined, true); + const a: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize, 8); + const b2: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0) as rs.usize, 8); + const q2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; + const _201: rs.usize = rs.usizeRem(a, 4); if (_201 === 0) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.Range(a, b2)), "next"); + drained2 = rs.iterToByteVec(rs.dequeDrain(q2, new rs.Range(a, b2)), "next"); } else if (_201 === 1) { - const _208: rt.RangeInclusive = new rt.RangeInclusive(a, b2, rt.usizeStep); - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, _208), "next"); + const _208: rs.RangeInclusive = new rs.RangeInclusive(a, b2, rs.usizeStep); + drained2 = rs.iterToByteVec(rs.dequeDrain(q2, _208), "next"); } else if (_201 === 2) { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, { end: b2 }), "next"); + drained2 = rs.iterToByteVec(rs.dequeDrain(q2, { end: b2 }), "next"); } else { - drained2 = rt.iterToByteVec(rt.dequeDrain(q2, new rt.RangeFrom(a, rt.usizeStep)), "next"); + drained2 = rs.iterToByteVec(rs.dequeDrain(q2, new rs.RangeFrom(a, rs.usizeStep)), "next"); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(drained2)); - rt.iterExtendBytes(out, rt.dequeIter(q2), undefined, true); - rt.byteVecPush(out, rt.dequeIndex(q2, b2)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(drained2)); + rs.iterExtendBytes(out, rs.dequeIter(q2), undefined, true); + rs.byteVecPush(out, rs.dequeIndex(q2, b2)); } /** @@ -1052,12 +1052,12 @@ export function deques(data: rt.ByteSlice, out: rt.ByteVec): void { * step, which shows the two slices std's splits it into; a range past the length or * backwards panics as std's does. */ -export function dequeRanges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _31!: rt.u8; - let it!: rt.Iter; - let item!: rt.u8 | undefined; - let _7_0!: rt.usize; - let _7_1!: rt.usize; +export function dequeRanges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _31!: rs.u8; + let it!: rs.Iter; + let item!: rs.u8 | undefined; + let _7_0!: rs.usize; + let _7_1!: rs.usize; let _7_2Data!: Uint8Array; let _7_2Start!: number; let _7_2Len!: number; @@ -1068,181 +1068,181 @@ export function dequeRanges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v _7_2Start = data.start; _7_2Len = data.length; } else { - const _13: rt.usize = rt.usizeRem(data.data[data.start] as rt.usize, 8); - const _17: rt.usize = rt.usizeRem(data.data[data.start + 1] as rt.usize, 8); + const _13: rs.usize = rs.usizeRem(data.data[data.start] as rs.usize, 8); + const _17: rs.usize = rs.usizeRem(data.data[data.start + 1] as rs.usize, 8); _7_0 = _13; _7_1 = _17; _7_2Data = data.data; _7_2Start = data.start + 2; _7_2Len = data.length - 2; } - const a: rt.usize = _7_0; - const b: rt.usize = _7_1; - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(_7_2Data, _7_2Start, _7_2Len))), undefined, 1, true), 1, true) as rt.VecDeque; - const _26: rt.u8 = rt.u8Rem(rt.u8Div(kind, 8), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _26; + const a: rs.usize = _7_0; + const b: rs.usize = _7_1; + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(_7_2Data, _7_2Start, _7_2Len))), undefined, 1, true), 1, true) as rs.VecDeque; + const _26: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _26; while ((_31 = iterStart++) < iterEnd) { - rt.dequePushFront(q, 240 | _31); + rs.dequePushFront(q, 240 | _31); } - const _39: rt.u8 = rt.u8Rem(kind, 8); + const _39: rs.u8 = rs.u8Rem(kind, 8); if (_39 === 0) { - it = rt.dequeRange(q, new rt.Range(a, b)); + it = rs.dequeRange(q, new rs.Range(a, b)); } else if (_39 === 1) { - const _44: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - it = rt.dequeRange(q, _44); + const _44: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + it = rs.dequeRange(q, _44); } else if (_39 === 2) { - it = rt.dequeRange(q, { end: b }); + it = rs.dequeRange(q, { end: b }); } else if (_39 === 3) { - it = rt.dequeRange(q, new rt.RangeFrom(a, rt.usizeStep)); + it = rs.dequeRange(q, new rs.RangeFrom(a, rs.usizeStep)); } else if (_39 === 4) { - it = rt.dequeRange(q, undefined); + it = rs.dequeRange(q, undefined); } else if (_39 === 5) { - it = rt.dequeRange(q, [{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + it = rs.dequeRange(q, [{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); } else if (_39 === 6) { - it = rt.dequeRange(q, { end: b, inclusive: true }); + it = rs.dequeRange(q, { end: b, inclusive: true }); } else { - it = rt.dequeRange(q, new rt.Range(a, a)); + it = rs.dequeRange(q, new rs.Range(a, a)); } - rt.byteVecPush(out, it.len() & 0xff); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(it, f, rt.u8Debug, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - let i2: rt.i32 = 0; + rs.byteVecPush(out, it.len() & 0xff); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + let i2: rs.i32 = 0; while (true) { - if ((rt.u8Shr(kind, rt.i32Add(5, rt.i32Rem(i2, 3))) & 1) === 1) { - item = rt.iterToOption(it.nextBack()); + if ((rs.u8Shr(kind, rs.i32Add(5, rs.i32Rem(i2, 3))) & 1) === 1) { + item = rs.iterToOption(it.nextBack()); } else { - item = rt.iterToOption(it.next()); + item = rs.iterToOption(it.next()); } if (item !== undefined) { - rt.byteVecPush(out, item); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(it, f, rt.u8Debug, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); + rs.byteVecPush(out, item); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(it, f, rs.u8Debug, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); if (i2 === 1) { - rt.iterExtendBytes(out, rt.iterRev(it.clone()), undefined, true); + rs.iterExtendBytes(out, rs.iterRev(it.clone()), undefined, true); } - i2 = rt.i32Add(i2, 1); + i2 = rs.i32Add(i2, 1); } else { - rt.byteVecPush(out, 253); - const _117: rt.RangeFrom = new rt.RangeFrom(rt.min(a, q.n), rt.usizeStep); - rt.iterExtendBytes(out, rt.iterRev(rt.dequeRange(q, _117)), undefined, true); + rs.byteVecPush(out, 253); + const _117: rs.RangeFrom = new rs.RangeFrom(rs.min(a, q.n), rs.usizeStep); + rs.iterExtendBytes(out, rs.iterRev(rs.dequeRange(q, _117)), undefined, true); return; } } } /** `vec![a, b]` and `vec![x; n]`, of bytes, numbers, `Copy` tuples, and types that clone. */ -export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { let name!: string; - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const n: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 2), 0) as rt.usize, 5); - const _16: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const n: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 2), 0) as rs.usize, 5); + const _16: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_16.ok) { name = _16.value; } else { name = "?"; } - const bytes: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(a, b, 66)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); - const pairs: rt.Vec<[rt.u8, rt.u16]> = rt.vecFrom(copy$array_tuple2_u8_u16([[a, b as rt.u16] as [rt.u8, rt.u16]]).map(copy$tuple2_u8_u16)); - pairs.items.push([b, a as rt.u16] as [rt.u8, rt.u16]); - const at = rt.idx(pairs.items, 0); + const bytes: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(a, b, 66)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); + const pairs: rs.Vec<[rs.u8, rs.u16]> = rs.vecFrom(copy$array_tuple2_u8_u16([[a, b as rs.u16] as [rs.u8, rs.u16]]).map(copy$tuple2_u8_u16)); + pairs.items.push([b, a as rs.u16] as [rs.u8, rs.u16]); + const at = rs.idx(pairs.items, 0); pairs.items[at][0] = pairs.items[at][0] ^ 255; for (const _39 of pairs.items) { - rt.byteVecPush(out, _39[0] ^ (_39[1] & 0xff)); - } - const names: rt.Vec = rt.vecFrom([name, "x", name]); - rt.byteVecPush(out, names.items.length & 0xff); - const one: rt.Vec = rt.vecFrom([{ depth: a, name: name }]); - rt.byteVecPush(out, one.items[rt.idx(one.items, 0)].depth); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecOf(b, n))); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem(rt.u16Mul(a as rt.u16, 257), n, undefined).items), (w: rt.u16): rt.u8 => { - return rt.u16Shr(w, 4) & 0xff; + rs.byteVecPush(out, _39[0] ^ (_39[1] & 0xff)); + } + const names: rs.Vec = rs.vecFrom([name, "x", name]); + rs.byteVecPush(out, names.items.length & 0xff); + const one: rs.Vec = rs.vecFrom([{ depth: a, name: name }]); + rs.byteVecPush(out, one.items[rs.idx(one.items, 0)].depth); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteVecOf(b, n))); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem(rs.u16Mul(a as rs.u16, 257), n, undefined).items), (w: rs.u16): rs.u8 => { + return rs.u16Shr(w, 4) & 0xff; }), undefined, true); - const tuples: rt.Vec<[rt.u8, rt.u8]> = rt.vecFromElem([a, b] as [rt.u8, rt.u8], n, copy$tuple2_u8_u8); + const tuples: rs.Vec<[rs.u8, rs.u8]> = rs.vecFromElem([a, b] as [rs.u8, rs.u8], n, copy$tuple2_u8_u8); if (n > 0) { - tuples.items[rt.idx(tuples.items, 0)][0] = 238; + tuples.items[rs.idx(tuples.items, 0)][0] = 238; } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(tuples.items), (t: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(tuples.items), (t: [rs.u8, rs.u8]): rs.u8 => { return t[0] ^ t[1]; }), undefined, true); - rt.byteVecPush(out, rt.vecFromElem(name, n, undefined).items.length & 0xff); - const cloned: rt.Vec = rt.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(cloned.items), (c: Cloned.Cloned): rt.u8 => { + rs.byteVecPush(out, rs.vecFromElem(name, n, undefined).items.length & 0xff); + const cloned: rs.Vec = rs.vecFromElem({ depth: 0, name }, n, Cloned.clone$Clone); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(cloned.items), (c: Cloned.Cloned): rs.u8 => { return c.depth; }), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.iterSlice(cloned.items), (c2: Cloned.Cloned): boolean => { - return rt.stringLen(c2.name) === data.length; + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(cloned.items), (c2: Cloned.Cloned): boolean => { + return rs.stringLen(c2.name) === data.length; }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.vecFromElem({ _0: b }, n, Bumped.clone$Clone).items), (o: Bumped.Bumped): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.vecFromElem({ _0: b }, n, Bumped.clone$Clone).items), (o: Bumped.Bumped): rs.u8 => { return o._0; }), undefined, true); - const pair: [rt.u8, rt.u8] = [a, b]; + const pair: [rs.u8, rs.u8] = [a, b]; const held: Bumped.Bumped = { _0: a }; - const listed: rt.Vec<[rt.u8, rt.u8]> = rt.vecFrom(copy$array_tuple2_u8_u8([pair, pair]).map(copy$tuple2_u8_u8)); - const at4 = rt.idx(listed.items, 0); + const listed: rs.Vec<[rs.u8, rs.u8]> = rs.vecFrom(copy$array_tuple2_u8_u8([pair, pair]).map(copy$tuple2_u8_u8)); + const at4 = rs.idx(listed.items, 0); listed.items[at4][0] = listed.items[at4][0] ^ 255; - const repeated: rt.Vec<[rt.u8, rt.u8]> = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); - const again: rt.Vec<[rt.u8, rt.u8]> = rt.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); - const bumps: rt.Vec = rt.vecFromElem(copy$collections_Bumped(held), n, Bumped.clone$Clone); - const kept: rt.Vec = rt.vecFromElem(copy$collections_Bumped(held), n, Bumped.clone$Clone); + const repeated: rs.Vec<[rs.u8, rs.u8]> = rs.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); + const again: rs.Vec<[rs.u8, rs.u8]> = rs.vecFromElem(copy$tuple2_u8_u8(pair), n, copy$tuple2_u8_u8); + const bumps: rs.Vec = rs.vecFromElem(copy$collections_Bumped(held), n, Bumped.clone$Clone); + const kept: rs.Vec = rs.vecFromElem(copy$collections_Bumped(held), n, Bumped.clone$Clone); if (n > 0) { - const at5 = rt.idx(repeated.items, rt.usizeSub(n, 1)); + const at5 = rs.idx(repeated.items, rs.usizeSub(n, 1)); repeated.items[at5][1] = repeated.items[at5][1] ^ 255; - const at6 = rt.idx(bumps.items, rt.usizeSub(n, 1)); + const at6 = rs.idx(bumps.items, rs.usizeSub(n, 1)); bumps.items[at6]._0 = bumps.items[at6]._0 ^ 255; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, b, listed.items[rt.idx(listed.items, 1)][0], a))); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(repeated.items), rt.iterSlice(again.items)), (t2: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b, listed.items[rs.idx(listed.items, 1)][0], a))); + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(repeated.items), rs.iterSlice(again.items)), (t2: [rs.u8, rs.u8]): rs.u8 => { return t2[1]; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(bumps.items), rt.iterSlice(kept.items)), (o2: Bumped.Bumped): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(bumps.items), rs.iterSlice(kept.items)), (o2: Bumped.Bumped): rs.u8 => { return o2._0; }), undefined, true); - const grown: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(bytes)); - const _167: rt.ByteSlice = rt.byteVecSlice(grown); - rt.idx(_167, 0); + const grown: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(bytes)); + const _167: rs.ByteSlice = rs.byteVecSlice(grown); + rs.idx(_167, 0); _167.data[_167.start] = _167.data[_167.start] ^ 255; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(grown)); - const _178: rt.ByteVec = rt.byteVecOf(b, n); - for (const _183 of rt.vecFrom([bytes, _178]).items) { - rt.byteVecPush(out, _183.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_183)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(grown)); + const _178: rs.ByteVec = rs.byteVecOf(b, n); + for (const _183 of rs.vecFrom([bytes, _178]).items) { + rs.byteVecPush(out, _183.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_183)); } - const wrapped: rt.Vec> = rt.vecFromElem(new Wrap.Wrap(a, b), n, copy$collections_Wrap_u8); + const wrapped: rs.Vec> = rs.vecFromElem(new Wrap.Wrap(a, b), n, copy$collections_Wrap_u8); if (n > 0) { - const _195: Wrap.Wrap[] = wrapped.items; - const _197: rt.usize = rt.usizeSub(n, 1); - rt.idx(_195, _197); + const _195: Wrap.Wrap[] = wrapped.items; + const _197: rs.usize = rs.usizeSub(n, 1); + rs.idx(_195, _197); _195[_197].count = _195[_197].count ^ 255; } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(wrapped.items), (w2: Wrap.Wrap): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(wrapped.items), (w2: Wrap.Wrap): rs.u8 => { return w2.value ^ w2.count; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(names.items), (s2: string): rt.u8 => { - return rt.stringLen(s2) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(names.items), (s2: string): rs.u8 => { + return rs.stringLen(s2) & 0xff; }), undefined, true); } /** Stores `p` by value in `v`. */ -export function keep(v: rt.Vec<[rt.u8, rt.u8]>, p: [rt.u8, rt.u8]): void { +export function keep(v: rs.Vec<[rs.u8, rs.u8]>, p: [rs.u8, rs.u8]): void { v.items.push(copy$tuple2_u8_u8(p)); } /** Gives back what it was given. */ -export function same(p: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function same(p: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return p; } /** Changes what it was given in place, which is its own. */ -export function bump(h: Holder.Holder): rt.u8 { +export function bump(h: Holder.Holder): rs.u8 { h.pair[0] = h.pair[0] ^ 1; return h.pair[0]; } /** Holds `pair`, for its caller to change. */ -export function hold(pair: [rt.u8, rt.u8]): Holder.Holder { +export function hold(pair: [rs.u8, rs.u8]): Holder.Holder { return { pair: copy$tuple2_u8_u8(pair) }; } @@ -1250,226 +1250,226 @@ export function hold(pair: [rt.u8, rt.u8]): Holder.Holder { * A `Copy` aggregate a std call stores by value is the container's own copy: changing * one stored element leaves the value it came from and the other elements as they were. */ -export function stores(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const pair: [rt.u8, rt.u8] = same([a, b] as [rt.u8, rt.u8]); - const changed: [rt.u8, rt.u8] = [b, a]; +export function stores(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const pair: [rs.u8, rs.u8] = same([a, b] as [rs.u8, rs.u8]); + const changed: [rs.u8, rs.u8] = [b, a]; changed[0] = changed[0] ^ 16; - const v: rt.Vec<[rt.u8, rt.u8]> = new rt.Vec(); + const v: rs.Vec<[rs.u8, rs.u8]> = new rs.Vec(); v.items.push(copy$tuple2_u8_u8(pair)); v.items.push(copy$tuple2_u8_u8(pair)); - const at = rt.idx(v.items, 0); + const at = rs.idx(v.items, 0); v.items[at][0] = v.items[at][0] ^ 1; v.items.push(copy$tuple2_u8_u8(changed)); changed[1] = changed[1] ^ 32; - const at2 = rt.idx(v.items, 2); + const at2 = rs.idx(v.items, 2); v.items[at2][0] = v.items[at2][0] ^ 4; keep(v, pair); - const at3 = rt.idx(v.items, 3); + const at3 = rs.idx(v.items, 3); v.items[at3][1] = v.items[at3][1] ^ 8; - const _30: [rt.u8, rt.u8] = copy$tuple2_u8_u8(same(pair)); + const _30: [rs.u8, rs.u8] = copy$tuple2_u8_u8(same(pair)); v.items.push(_30); - const at4 = rt.idx(v.items, 4); + const at4 = rs.idx(v.items, 4); v.items[at4][0] = v.items[at4][0] ^ 64; - const _36: [rt.u8, rt.u8] = copy$tuple2_u8_u8(changed); - rt.iterExtend(v, rt.iterSlice([copy$tuple2_u8_u8(pair), _36]), undefined, 2, true); - const at5 = rt.idx(v.items, 5); + const _36: [rs.u8, rs.u8] = copy$tuple2_u8_u8(changed); + rs.iterExtend(v, rs.iterSlice([copy$tuple2_u8_u8(pair), _36]), undefined, 2, true); + const at5 = rs.idx(v.items, 5); v.items[at5][1] = v.items[at5][1] ^ 128; - const at6 = rt.idx(v.items, 6); + const at6 = rs.idx(v.items, 6); v.items[at6][0] = v.items[at6][0] ^ 128; - const at7 = rt.idx(v.items, 0); + const at7 = rs.idx(v.items, 0); const old2 = v.items[at7]; v.items[at7] = copy$tuple2_u8_u8(pair); - const old: [rt.u8, rt.u8] = old2; - const at8 = rt.idx(v.items, 0); + const old: [rs.u8, rs.u8] = old2; + const at8 = rs.idx(v.items, 0); v.items[at8][1] = v.items[at8][1] ^ 16; - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v.items), (p: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v.items), (p: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(p[0], p[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); - const tally: Tally.Tally = { n: a as rt.u16 }; - const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - rt.dequePushBack(q, copy$collections_Tally(tally)); - rt.dequePushFront(q, copy$collections_Tally(tally)); - rt.dequeInsert(q, 1, copy$collections_Tally(tally)); - const _68: Tally.Tally | undefined = rt.dequeEnd(q); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(changed[0], changed[1], old[0], old[1]))); + const tally: Tally.Tally = { n: a as rs.u16 }; + const q: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + rs.dequePushBack(q, copy$collections_Tally(tally)); + rs.dequePushFront(q, copy$collections_Tally(tally)); + rs.dequeInsert(q, 1, copy$collections_Tally(tally)); + const _68: Tally.Tally | undefined = rs.dequeEnd(q); if (_68 !== undefined) { _68.n = _68.n ^ 1; } - const _72: Tally.Tally | undefined = rt.dequeEnd(q, true); + const _72: Tally.Tally | undefined = rs.dequeEnd(q, true); if (_72 !== undefined) { _72.n = _72.n ^ 2; } - rt.iterExtendBytes(out, rt.iterMap(rt.dequeIter(q), (t: Tally.Tally): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.dequeIter(q), (t: Tally.Tally): rs.u8 => { return t.n & 0xff; }), undefined, true); - rt.byteVecPush(out, tally.n & 0xff); - const hash: rt.HashMap = rt.hashNew() as rt.HashMap; - rt.hashInsert(hash, 0, copy$tuple2_u8_u8(pair)); - rt.hashInsert(hash, 1, copy$tuple2_u8_u8(pair)); - const _88: [rt.u8, rt.u8] | undefined = rt.hashGet(hash, 0); + rs.byteVecPush(out, tally.n & 0xff); + const hash: rs.HashMap = rs.hashNew() as rs.HashMap; + rs.hashInsert(hash, 0, copy$tuple2_u8_u8(pair)); + rs.hashInsert(hash, 1, copy$tuple2_u8_u8(pair)); + const _88: [rs.u8, rs.u8] | undefined = rs.hashGet(hash, 0); if (_88 !== undefined) { _88[0] = _88[0] ^ 1; } - const _93: [rt.u8, rt.u8] = rt.entryOrInsert(rt.entry(hash, 2), copy$tuple2_u8_u8(pair)); + const _93: [rs.u8, rs.u8] = rs.entryOrInsert(rs.entry(hash, 2), copy$tuple2_u8_u8(pair)); _93[1] = _93[1] ^ 2; - rt.iterExtendBytes(out, rt.iterFlatMap(new rt.Range(0, 3), (k: rt.u8): Uint8Array => { - return option_mapOr$1nlkf9b(rt.hashGet(hash, k), rt.bytes(2).fill(255), (p2: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(new rs.Range(0, 3), (k: rs.u8): Uint8Array => { + return option_mapOr$13kt6x8(rs.hashGet(hash, k), rs.bytes(2).fill(255), (p2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(p2[0], p2[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - rt.btreeInsert(tree, 0, copy$tuple2_u8_u8(pair)); - rt.btreeInsert(tree, 1, copy$tuple2_u8_u8(pair)); - const _106: [rt.u8, rt.u8] | undefined = rt.btreeGet(tree, 1); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const tree: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + rs.btreeInsert(tree, 0, copy$tuple2_u8_u8(pair)); + rs.btreeInsert(tree, 1, copy$tuple2_u8_u8(pair)); + const _106: [rs.u8, rs.u8] | undefined = rs.btreeGet(tree, 1); if (_106 !== undefined) { _106[1] = _106[1] ^ 1; } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeValues(tree), (p3: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeValues(tree), (p3: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(p3[0], p3[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const boxed: [rt.u8, rt.u8] = copy$tuple2_u8_u8(pair); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const boxed: [rs.u8, rs.u8] = copy$tuple2_u8_u8(pair); boxed[0] = boxed[0] ^ 1; - const holders: rt.Vec = rt.vecFrom([{ pair: copy$tuple2_u8_u8(pair) }]); + const holders: rs.Vec = rs.vecFrom([{ pair: copy$tuple2_u8_u8(pair) }]); holders.items.push({ pair: copy$tuple2_u8_u8(pair) }); - const at9 = rt.idx(holders.items, 1); + const at9 = rs.idx(holders.items, 1); holders.items[at9].pair[1] = holders.items[at9].pair[1] ^ 2; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed[0], boxed[1], holders.items[rt.idx(holders.items, 0)].pair[1], holders.items[rt.idx(holders.items, 1)].pair[1]))); - rt.byteVecPush(out, bump({ pair: copy$tuple2_u8_u8(pair) })); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed[0], boxed[1], holders.items[rs.idx(holders.items, 0)].pair[1], holders.items[rs.idx(holders.items, 1)].pair[1]))); + rs.byteVecPush(out, bump({ pair: copy$tuple2_u8_u8(pair) })); const held: Holder.Holder = hold(pair); held.pair[1] = held.pair[1] ^ 4; const _142: Holder.Holder = hold(pair); holders.items.push(_142); - const at12 = rt.idx(holders.items, 2); + const at12 = rs.idx(holders.items, 2); holders.items[at12].pair[0] = holders.items[at12].pair[0] ^ 8; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(held.pair[1], holders.items[rt.idx(holders.items, 2)].pair[0]))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(held.pair[1], holders.items[rs.idx(holders.items, 2)].pair[0]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pair[0], pair[1]))); } -export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): string | undefined | rt.None { - return rt.hashGet(self, k, rt.None); +export function get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { + return rs.hashGet(self, k, rs.None); } -export function get$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.u8 | undefined | rt.None { - return rt.hashGet(self, k, rt.None); +export function get$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rs.HashMap, k: rs.u8): rs.u8 | undefined | rs.None { + return rs.hashGet(self, k, rs.None); } -export function get$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): undefined | rt.None { - return rt.hashGet(self, k, rt.None); +export function get$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rs.HashMap, k: rs.u8): undefined | rs.None { + return rs.hashGet(self, k, rs.None); } -export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8, v: string | undefined): string | undefined | rt.None { - return rt.hashInsert(self, k, v, undefined, rt.None); +export function insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8, v: string | undefined): string | undefined | rs.None { + return rs.hashInsert(self, k, v, undefined, rs.None); } -export function insert$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8, v: rt.u8 | undefined): rt.u8 | undefined | rt.None { - return rt.hashInsert(self, k, v, undefined, rt.None); +export function insert$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rs.HashMap, k: rs.u8, v: rs.u8 | undefined): rs.u8 | undefined | rs.None { + return rs.hashInsert(self, k, v, undefined, rs.None); } -export function insert$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rt.HashMap, k: rt.u8, _: undefined): undefined | rt.None { - return rt.hashInsert(self, k, undefined, undefined, rt.None); +export function insert$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rs.HashMap, k: rs.u8, _: undefined): undefined | rs.None { + return rs.hashInsert(self, k, undefined, undefined, rs.None); } -export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): string | undefined | rt.None { - return rt.hashRemove(self, k, undefined, rt.None); +export function remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): string | undefined | rs.None { + return rs.hashRemove(self, k, undefined, rs.None); } -export function remove$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.u8 | undefined | rt.None { - return rt.hashRemove(self, k, undefined, rt.None); +export function remove$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rs.HashMap, k: rs.u8): rs.u8 | undefined | rs.None { + return rs.hashRemove(self, k, undefined, rs.None); } -export function remove$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): undefined | rt.None { - return rt.hashRemove(self, k, undefined, rt.None); +export function remove$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rs.HashMap, k: rs.u8): undefined | rs.None { + return rs.hashRemove(self, k, undefined, rs.None); } -export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rt.HashMap, k: rt.u8): rt.Place | undefined { - return rt.hashGetMut(self, k); +export function getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap, k: rs.u8): rs.Place | undefined { + return rs.hashGetMut(self, k); } -export function getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rt.HashMap, k: rt.u8): rt.Place | undefined { - return rt.hashGetMut(self, k); +export function getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rs.HashMap, k: rs.u8): rs.Place | undefined { + return rs.hashGetMut(self, k); } -export function getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rt.HashMap, k: rt.u8): rt.Place | undefined { - return rt.hashGetMut(self, k); +export function getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rs.HashMap, k: rs.u8): rs.Place | undefined { + return rs.hashGetMut(self, k); } -export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rt.HashMap): rt.Vec<[rt.u8, string | undefined]> { - const all: rt.Vec<[rt.u8, string | undefined]> = rt.iterToVec(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, string | undefined]): [rt.u8, string | undefined] => { - return [_2[0], option_clone$14nprly(_2[1])] as [rt.u8, string | undefined]; +export function sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(self: rs.HashMap): rs.Vec<[rs.u8, string | undefined]> { + const all: rs.Vec<[rs.u8, string | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, string | undefined]): [rs.u8, string | undefined] => { + return [_2[0], option_clone$14nprly(_2[1])] as [rs.u8, string | undefined]; }), "next", 16); - rt.sliceSort(all.items, rt.keyLt((_22: [rt.u8, string | undefined]): rt.u8 => { + rs.sliceSort(all.items, rs.keyLt((_22: [rs.u8, string | undefined]): rs.u8 => { return _22[0]; - }, rt.lt), 16, true); + }, rs.lt), 16, true); return all; } -export function sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rt.HashMap): rt.Vec<[rt.u8, rt.u8 | undefined]> { - const all: rt.Vec<[rt.u8, rt.u8 | undefined]> = rt.iterToVec(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { - return [_2[0], _2[1]] as [rt.u8, rt.u8 | undefined]; +export function sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(self: rs.HashMap): rs.Vec<[rs.u8, rs.u8 | undefined]> { + const all: rs.Vec<[rs.u8, rs.u8 | undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, rs.u8 | undefined]): [rs.u8, rs.u8 | undefined] => { + return [_2[0], _2[1]] as [rs.u8, rs.u8 | undefined]; }), "next", 3); - rt.sliceSort(all.items, rt.keyLt((_22: [rt.u8, rt.u8 | undefined]): rt.u8 => { + rs.sliceSort(all.items, rs.keyLt((_22: [rs.u8, rs.u8 | undefined]): rs.u8 => { return _22[0]; - }, rt.lt), 3, true); + }, rs.lt), 3, true); return all; } -export function sorted$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rt.HashMap): rt.Vec<[rt.u8, undefined]> { - const all: rt.Vec<[rt.u8, undefined]> = rt.iterToVec(rt.iterMap(rt.hashIter(self), (_2: [rt.u8, undefined]): [rt.u8, undefined] => { - const _5: rt.u8 = _2[0]; +export function sorted$collections_OptionMap_unit_collections_HashMap_u8_unit(self: rs.HashMap): rs.Vec<[rs.u8, undefined]> { + const all: rs.Vec<[rs.u8, undefined]> = rs.iterToVec(rs.iterMap(rs.hashIter(self), (_2: [rs.u8, undefined]): [rs.u8, undefined] => { + const _5: rs.u8 = _2[0]; _2[1]; - return [_5, undefined] as [rt.u8, undefined]; + return [_5, undefined] as [rs.u8, undefined]; }), "next", 1); - rt.sliceSort(all.items, rt.keyLt((_22: [rt.u8, undefined]): rt.u8 => { + rs.sliceSort(all.items, rs.keyLt((_22: [rs.u8, undefined]): rs.u8 => { return _22[0]; - }, rt.lt), 1, true); + }, rs.lt), 1, true); return all; } -export function get$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.u8 | undefined | rt.None { - return rt.btreeGet(self, k, rt.None); +export function get$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rs.BTreeMap, k: rs.u8): rs.u8 | undefined | rs.None { + return rs.btreeGet(self, k, rs.None); } -export function get$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): undefined | rt.None { - return rt.btreeGet(self, k, rt.None); +export function get$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rs.BTreeMap, k: rs.u8): undefined | rs.None { + return rs.btreeGet(self, k, rs.None); } -export function insert$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8, v: rt.u8 | undefined): rt.u8 | undefined | rt.None { - return rt.btreeInsert(self, k, v, undefined, rt.None); +export function insert$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rs.BTreeMap, k: rs.u8, v: rs.u8 | undefined): rs.u8 | undefined | rs.None { + return rs.btreeInsert(self, k, v, undefined, rs.None); } -export function insert$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8, _: undefined): undefined | rt.None { - return rt.btreeInsert(self, k, undefined, undefined, rt.None); +export function insert$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rs.BTreeMap, k: rs.u8, _: undefined): undefined | rs.None { + return rs.btreeInsert(self, k, undefined, undefined, rs.None); } -export function remove$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.u8 | undefined | rt.None { - return rt.btreeRemove(self, k, undefined, rt.None); +export function remove$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rs.BTreeMap, k: rs.u8): rs.u8 | undefined | rs.None { + return rs.btreeRemove(self, k, undefined, rs.None); } -export function remove$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): undefined | rt.None { - return rt.btreeRemove(self, k, undefined, rt.None); +export function remove$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rs.BTreeMap, k: rs.u8): undefined | rs.None { + return rs.btreeRemove(self, k, undefined, rs.None); } -export function getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rt.BTreeMap, k: rt.u8): rt.Place | undefined { - return rt.btreeGetMut(self, k); +export function getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rs.BTreeMap, k: rs.u8): rs.Place | undefined { + return rs.btreeGetMut(self, k); } -export function getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rt.BTreeMap, k: rt.u8): rt.Place | undefined { - return rt.btreeGetMut(self, k); +export function getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rs.BTreeMap, k: rs.u8): rs.Place | undefined { + return rs.btreeGetMut(self, k); } -export function sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rt.BTreeMap): rt.Vec<[rt.u8, rt.u8 | undefined]> { - return rt.iterToVec(rt.iterMap(rt.btreeIter(self), (_22: [rt.u8, rt.u8 | undefined]): [rt.u8, rt.u8 | undefined] => { - return [_22[0], _22[1]] as [rt.u8, rt.u8 | undefined]; +export function sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(self: rs.BTreeMap): rs.Vec<[rs.u8, rs.u8 | undefined]> { + return rs.iterToVec(rs.iterMap(rs.btreeIter(self), (_22: [rs.u8, rs.u8 | undefined]): [rs.u8, rs.u8 | undefined] => { + return [_22[0], _22[1]] as [rs.u8, rs.u8 | undefined]; }), undefined, 3, true); } -export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rt.BTreeMap): rt.Vec<[rt.u8, undefined]> { - return rt.iterToVec(rt.iterMap(rt.btreeIter(self), (_22: [rt.u8, undefined]): [rt.u8, undefined] => { - const _5: rt.u8 = _22[0]; +export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(self: rs.BTreeMap): rs.Vec<[rs.u8, undefined]> { + return rs.iterToVec(rs.iterMap(rs.btreeIter(self), (_22: [rs.u8, undefined]): [rs.u8, undefined] => { + const _5: rs.u8 = _22[0]; _22[1]; - return [_5, undefined] as [rt.u8, undefined]; + return [_5, undefined] as [rs.u8, undefined]; }), undefined, 1, true); } @@ -1477,268 +1477,268 @@ export function sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(s * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_String_collections_HashMap_u8_Option_String(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => string | undefined, out: rt.ByteVec): void { +export function optional$Option_String_collections_HashMap_u8_Option_String(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => string | undefined, out: rs.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(data)) { - const k: rt.u8 = rt.u8Rem(b, 8); - const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + for (const b of rs.byteSliceView(data)) { + const k: rs.u8 = rs.u8Rem(b, 8); + const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { const _24: string | undefined = value(b); const part3 = insert$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k, _24); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; - read = rt.fmtFormat([args2[0], " "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; - read = rt.fmtFormat([args4[0], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: string | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr), rt.None)]; - read = rt.fmtFormat([args6[0], " "]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: string | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr), rs.None)]; + read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rt.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map, k); if (_49 === undefined) { read = "- "; } else { - const v: rt.Place = _49; - const _53: string | undefined = value(rt.u8Div(b, 2)); + const v: rs.Place = _49; + const _53: string | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.fmtStr)]; - read = rt.fmtFormat(["=", args8[0], " "]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.fmtStr)]; + read = rs.fmtFormat(["=", args8[0], " "]); } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_String_collections_HashMap_u8_Option_String(map); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, (value: [rt.u8, string | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.fmtStr)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, string | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.fmtStr)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); } /** * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { +export function optional$Option_u8_collections_BTreeMap_u8_Option_u8(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(data)) { - const k: rt.u8 = rt.u8Rem(b, 8); - const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + for (const b of rs.byteSliceView(data)) { + const k: rs.u8 = rs.u8Rem(b, 8); + const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { - const _24: rt.u8 | undefined = value(b); + const _24: rs.u8 | undefined = value(b); const part3 = insert$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k, _24); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args2[0], " "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args4[0], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args6[0], " "]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rt.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map, k); if (_49 === undefined) { read = "- "; } else { - const v: rt.Place = _49; - const _53: rt.u8 | undefined = value(rt.u8Div(b, 2)); + const v: rs.Place = _49; + const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.u8Debug)]; - read = rt.fmtFormat(["=", args8[0], " "]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug)]; + read = rs.fmtFormat(["=", args8[0], " "]); } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_BTreeMap_u8_Option_u8(map); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); } /** * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => rt.u8 | undefined, out: rt.ByteVec): void { +export function optional$Option_u8_collections_HashMap_u8_Option_u8(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => rs.u8 | undefined, out: rs.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(data)) { - const k: rt.u8 = rt.u8Rem(b, 8); - const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + for (const b of rs.byteSliceView(data)) { + const k: rs.u8 = rs.u8Rem(b, 8); + const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { - const _24: rt.u8 | undefined = value(b); + const _24: rs.u8 | undefined = value(b); const part3 = insert$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k, _24); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args2[0], " "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args4[0], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - read = rt.fmtFormat([args6[0], " "]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rt.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map, k); if (_49 === undefined) { read = "- "; } else { - const v: rt.Place = _49; - const _53: rt.u8 | undefined = value(rt.u8Div(b, 2)); + const v: rs.Place = _49; + const _53: rs.u8 | undefined = value(rs.u8Div(b, 2)); v.v = _53; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v.v, f, rt.u8Debug)]; - read = rt.fmtFormat(["=", args8[0], " "]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v.v, f, rs.u8Debug)]; + read = rs.fmtFormat(["=", args8[0], " "]); } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_Option_u8_collections_HashMap_u8_Option_u8(map); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); } /** * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$unit_collections_BTreeMap_u8_unit(map: rt.BTreeMap, data: rt.ByteSlice, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +export function optional$unit_collections_BTreeMap_u8_unit(map: rs.BTreeMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(data)) { - const k: rt.u8 = rt.u8Rem(b, 8); - const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + for (const b of rs.byteSliceView(data)) { + const k: rs.u8 = rs.u8Rem(b, 8); + const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { value(b); const part3 = insert$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k, undefined); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args2[0], " "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args4[0], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args6[0], " "]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rt.Place | undefined = getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map, k); if (_49 === undefined) { read = "- "; } else { - const v: rt.Place = _49; - value(rt.u8Div(b, 2)); + const v: rs.Place = _49; + value(rs.u8Div(b, 2)); v.v = undefined; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(v.v, f)]; - read = rt.fmtFormat(["=", args8[0], " "]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(v.v, f)]; + read = rs.fmtFormat(["=", args8[0], " "]); } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_unit_collections_BTreeMap_u8_unit(map); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, (value: [rt.u8, undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtUnit(value[1], f)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); } /** * Run `data` on `map`, each byte a key in its low nibble and an operation above it, and * `value` making what `insert` and `get_mut` put. */ -export function optional$unit_collections_HashMap_u8_unit(map: rt.HashMap, data: rt.ByteSlice, value: (a0: rt.u8) => undefined, out: rt.ByteVec): void { +export function optional$unit_collections_HashMap_u8_unit(map: rs.HashMap, data: rs.ByteSlice, value: (a0: rs.u8) => undefined, out: rs.ByteVec): void { let read!: string; - for (const b of rt.byteSliceView(data)) { - const k: rt.u8 = rt.u8Rem(b, 8); - const _14: rt.u8 = rt.u8Rem(rt.u8Div(b, 8), 4); + for (const b of rs.byteSliceView(data)) { + const k: rs.u8 = rs.u8Rem(b, 8); + const _14: rs.u8 = rs.u8Rem(rs.u8Div(b, 8), 4); if (_14 === 0) { value(b); const part3 = insert$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k, undefined); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args2[0], " "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args2[0], " "]); } else if (_14 === 1) { const part2 = get$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args4[0], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args4[0], " "]); } else if (_14 === 2) { const part = remove$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.fmtUnit, rt.None)]; - read = rt.fmtFormat([args6[0], " "]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtUnit, rs.None)]; + read = rs.fmtFormat([args6[0], " "]); } else { - const _49: rt.Place | undefined = getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); + const _49: rs.Place | undefined = getMut$collections_OptionMap_unit_collections_HashMap_u8_unit(map, k); if (_49 === undefined) { read = "- "; } else { - const v: rt.Place = _49; - value(rt.u8Div(b, 2)); + const v: rs.Place = _49; + value(rs.u8Div(b, 2)); v.v = undefined; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(v.v, f)]; - read = rt.fmtFormat(["=", args8[0], " "]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(v.v, f)]; + read = rs.fmtFormat(["=", args8[0], " "]); } } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(read)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(read)); } const part4 = sorted$collections_OptionMap_unit_collections_HashMap_u8_unit(map); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, (value: [rt.u8, undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtUnit(value[1], f)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, (value: [rs.u8, undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtUnit(value[1], f)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); } /** `b`, unless a multiple of 3. */ -export function some(b: rt.u8): rt.u8 | undefined { - return thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); +export function some(b: rs.u8): rs.u8 | undefined { + return thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); } /** What `Default` makes of `T`, as kio's `Shared::default` makes its map. */ -export function made$collections_BTreeMap_u8_Option_u8(): rt.BTreeMap { - return rt.btreeNew(rt.cmp) as rt.BTreeMap; +export function made$collections_BTreeMap_u8_Option_u8(): rs.BTreeMap { + return rs.btreeNew(rs.cmp) as rs.BTreeMap; } /** What `Default` makes of `T`, as kio's `Shared::default` makes its map. */ -export function made$collections_HashMap_u8_Option_String(): rt.HashMap { - return rt.hashNew() as rt.HashMap; +export function made$collections_HashMap_u8_Option_String(): rs.HashMap { + return rs.hashNew() as rs.HashMap; } /** * Maps whose values are `Option`s or `()`, whose `get`, `insert`, and `remove` return an * `Option` of one: by key, by hash of a key that is an object, and in order. */ -export function optionals(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let read!: rt.u8 | undefined | rt.None; - const _4: rt.u8 = rt.u8Rem(kind, 6); +export function optionals(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let read!: rs.u8 | undefined | rs.None; + const _4: rs.u8 = rs.u8Rem(kind, 6); if (_4 === 0) { - optional$Option_u8_collections_HashMap_u8_Option_u8(rt.hashNew() as rt.HashMap, data, some, out); + optional$Option_u8_collections_HashMap_u8_Option_u8(rs.hashNew() as rs.HashMap, data, some, out); } else if (_4 === 1) { optional$Option_u8_collections_BTreeMap_u8_Option_u8(made$collections_BTreeMap_u8_Option_u8(), data, some, out); } else if (_4 === 2) { - optional$unit_collections_HashMap_u8_unit(rt.hashNew() as rt.HashMap, data, (_22: rt.u8): undefined => {}, out); + optional$unit_collections_HashMap_u8_unit(rs.hashNew() as rs.HashMap, data, (_22: rs.u8): undefined => {}, out); } else if (_4 === 3) { - optional$unit_collections_BTreeMap_u8_unit(rt.btreeNew(rt.cmp) as rt.BTreeMap, data, (_2: rt.u8): undefined => {}, out); + optional$unit_collections_BTreeMap_u8_unit(rs.btreeNew(rs.cmp) as rs.BTreeMap, data, (_2: rs.u8): undefined => {}, out); } else if (_4 === 4) { - optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rt.u8): string | undefined => { - return option_map$0oc32h1(some(b2), (b3: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b3, f)); + optional$Option_String_collections_HashMap_u8_Option_String(made$collections_HashMap_u8_Option_String(), data, (b2: rs.u8): string | undefined => { + return option_map$1y26nmr(some(b2), (b3: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b3, f)); }); }, out); } else { - const map: rt.HashMap<[rt.u8, boolean], rt.u8 | undefined> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, boolean], rt.u8 | undefined>; - for (const b of rt.byteSliceView(data)) { - const k: [rt.u8, boolean] = [rt.u8Rem(b, 4), (b & 16) !== 0]; - const _29: rt.u8 = rt.u8Rem(rt.u8Div(b, 32), 4); + const map: rs.HashMap<[rs.u8, boolean], rs.u8 | undefined> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, boolean], rs.u8 | undefined>; + for (const b of rs.byteSliceView(data)) { + const k: [rs.u8, boolean] = [rs.u8Rem(b, 4), (b & 16) !== 0]; + const _29: rs.u8 = rs.u8Rem(rs.u8Div(b, 32), 4); if (_29 === 0) { - const _34: rt.u8 | undefined = some(b); - read = rt.hashInsert(map, k, _34, undefined, rt.None); + const _34: rs.u8 | undefined = some(b); + read = rs.hashInsert(map, k, _34, undefined, rs.None); } else if (_29 === 1) { - read = rt.hashGet(map, k, rt.None); + read = rs.hashGet(map, k, rs.None); } else if (_29 === 2) { - read = rt.hashRemove(map, k, undefined, rt.None); + read = rs.hashRemove(map, k, undefined, rs.None); } else { - read = rt.entryOrInsertMut(rt.entry(map, k), undefined as rt.u8 | undefined).v; + read = rs.entryOrInsertMut(rs.entry(map, k), undefined as rs.u8 | undefined).v; } - const _50: rt.u8 | undefined = option_flatten$1nwzx42(read); - const _53: boolean = rt.hashContains(map, k); - const _56: rt.u8 | undefined | rt.None = read; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_56, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_50, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBool(_53, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); + const _50: rs.u8 | undefined = option_flatten$0ux6gqw(read); + const _53: boolean = rs.hashContains(map, k); + const _56: rs.u8 | undefined | rs.None = read; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_56, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_53, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "]))); } - const all: rt.Vec<[[rt.u8, boolean], rt.u8 | undefined]> = rt.iterToVec(rt.hashIter(map), "next", 4); - rt.sliceSort(all.items, rt.cmpLt(rt.cmpTuple<[[rt.u8, boolean], rt.u8 | undefined], rt.Ordering | undefined>([rt.cmpTuple<[rt.u8, boolean], rt.Ordering | undefined>([rt.cmp, rt.cmp]), rt.cmpOption(rt.cmp)])), 4, true); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all.items, f, (value: [[rt.u8, boolean], rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0][0], f), (f: rt.Formatter) => rt.fmtBool(value[0][1], f)], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); + const all: rs.Vec<[[rs.u8, boolean], rs.u8 | undefined]> = rs.iterToVec(rs.hashIter(map), "next", 4); + rs.sliceSort(all.items, rs.cmpLt(rs.cmpTuple<[[rs.u8, boolean], rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpTuple<[rs.u8, boolean], rs.Ordering | undefined>([rs.cmp, rs.cmp]), rs.cmpOption(rs.cmp)])), 4, true); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [[rs.u8, boolean], rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0][0], f), (f: rs.Formatter) => rs.fmtBool(value[0][1], f)], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); } } @@ -1751,1896 +1751,1896 @@ export function optionals(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi * in the runtime's, so what each yields is sorted first. The `Nibble` an op yields shows * which set's key of two equal ones std's picks. */ -export function setOps(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const mid: number = rt.usizeDiv(data.length, 2); +export function setOps(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const mid: number = rs.usizeDiv(data.length, 2); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - let left: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid); - let right: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid, data.length - mid); + let left: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid); + let right: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid, data.length - mid); b0: { - const _12: rt.u8 = rt.u8Rem(rt.u8Div(kind, 5), 6); + const _12: rs.u8 = rs.u8Rem(rs.u8Div(kind, 5), 6); if (_12 !== 0) { if (_12 === 1) { right = left; } else if (_12 === 2) { - left = rt.byteSliceFrom(Uint8Array.of()); + left = rs.byteSliceFrom(Uint8Array.of()); } else if (_12 === 3) { - const mid2: number = rt.min(data.length, 1); + const mid2: number = rs.min(data.length, 1); if (mid2 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - left = new rt.ByteSlice(data.data, data.start, mid2); - right = new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2); + left = new rs.ByteSlice(data.data, data.start, mid2); + right = new rs.ByteSlice(data.data, data.start + mid2, data.length - mid2); } else if (_12 === 4) { - const _23: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (b: rt.u8): rt.u8 => { + const _23: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (b: rs.u8): rs.u8 => { return b & (~1 & 0xff); }), undefined, true); - const _27: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (b2: rt.u8): rt.u8 => { + const _27: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (b2: rs.u8): rs.u8 => { return b2 | 1; }), undefined, true); - left = rt.byteVecSlice(_23); - right = rt.byteVecSlice(_27); + left = rs.byteVecSlice(_23); + right = rs.byteVecSlice(_27); } else { - const _39: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const all: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _39, true, undefined, undefined, 1, true); - const none: rt.BTreeSet = rt.btreeFromSorted(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.btreeDifference(all, all)); - const k: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(none, [{ tag: "Excluded", _0: k } as rt.RangeBound, { tag: "Excluded", _0: k } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound])) & 0xff); + const _39: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const all: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _39, true, undefined, undefined, 1, true); + const none: rs.BTreeSet = rs.btreeFromSorted(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.btreeDifference(all, all)); + const k: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(none, [{ tag: "Excluded", _0: k } as rs.RangeBound, { tag: "Excluded", _0: k } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound])) & 0xff); break b0; } } - const _55: rt.u8 = rt.u8Rem(kind, 5); + const _55: rs.u8 = rs.u8Rem(kind, 5); if (_55 === 0) { - setOpsOf$u8(left, right, (b6: rt.u8): rt.u8 => { - return rt.u8Rem(b6, 32); - }, (v3: rt.u8): rt.u8 => { + setOpsOf$u8(left, right, (b6: rs.u8): rs.u8 => { + return rs.u8Rem(b6, 32); + }, (v3: rs.u8): rs.u8 => { return v3; }, out); } else if (_55 === 1) { - setOpsOf$array2_u8(left, right, (b5: rt.u8): Uint8Array => { - return Uint8Array.of(rt.u8Rem(b5, 4), rt.u8Rem(rt.u8Div(b5, 4), 4)); - }, (k2: rt.ByteSlice): rt.u8 => { + setOpsOf$array2_u8(left, right, (b5: rs.u8): Uint8Array => { + return Uint8Array.of(rs.u8Rem(b5, 4), rs.u8Rem(rs.u8Div(b5, 4), 4)); + }, (k2: rs.ByteSlice): rs.u8 => { return ((k2.data[k2.start] << 4) & 0xff) | k2.data[k2.start + 1]; }, out); } else if (_55 === 2) { - setOpsOf$Option_u8(left, right, (b4: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b4, 32) !== 0, rt.u8Rem(b4, 32)); - }, (v2: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(v2, 238); + setOpsOf$Option_u8(left, right, (b4: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b4, 32) !== 0, rs.u8Rem(b4, 32)); + }, (v2: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(v2, 238); }, out); } else if (_55 === 3) { - setOpsOf$collections_Nibble(left, right, (a0: rt.u8): Nibble.Nibble => { + setOpsOf$collections_Nibble(left, right, (a0: rs.u8): Nibble.Nibble => { return { _0: a0 }; - }, (n: Nibble.Nibble): rt.u8 => { + }, (n: Nibble.Nibble): rs.u8 => { return n._0; }, out); } else { - setOpsOf$cmp_Reverse_Option_u8(left, right, (b3: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b3, 32) !== 0, rt.u8Rem(b3, 32)); - }, (v: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(v, 238); + setOpsOf$cmp_Reverse_Option_u8(left, right, (b3: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b3, 32) !== 0, rs.u8Rem(b3, 32)); + }, (v: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(v, 238); }, out); } } } -export function setOpsOf$Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 | undefined => { +export function setOpsOf$Option_u8(left: rs.ByteSlice, right: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 | undefined, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const _7: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): rs.u8 | undefined => { return make(_2); }); - const a: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _7, true, undefined, undefined, 2, true); - const _12: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): rt.u8 | undefined => { + const a: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _7, true, undefined, undefined, 2, true); + const _12: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): rs.u8 | undefined => { return make(_22); }); - const b: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _12, true, undefined, undefined, 2, true); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[a, b] as [rt.BTreeSet, rt.BTreeSet], [b, a] as [rt.BTreeSet, rt.BTreeSet]]); + const b: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _12, true, undefined, undefined, 2, true); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[a, b] as [rs.BTreeSet, rs.BTreeSet], [b, a] as [rs.BTreeSet, rs.BTreeSet]]); while (true) { - const _25: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - putAll$Option_u8_collections_btree_set_Union_Option_u8(rt.btreeUnion(_25[0], _25[1]), put, out); - putAll$Option_u8_collections_btree_set_Intersection_Option_u8(rt.btreeIntersection(_25[0], _25[1]), put, out); - putAll$Option_u8_collections_btree_set_Difference_Option_u8(rt.btreeDifference(_25[0], _25[1]), put, out); - putAll$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), put, out); - putHints$Option_u8_collections_btree_set_Union_Option_u8(rt.btreeUnion(_25[0], _25[1]), 1, out); - putHints$Option_u8_collections_btree_set_Intersection_Option_u8(rt.btreeIntersection(_25[0], _25[1]), 1, out); - putHints$Option_u8_collections_btree_set_Difference_Option_u8(rt.btreeDifference(_25[0], _25[1]), 1, out); - putHints$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), 1, out); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeUnion(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeIntersection(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeDifference(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeSymmetricDifference(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); - const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, rt.btreeUnion(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, rt.btreeIntersection(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, rt.btreeDifference(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, rt.btreeSymmetricDifference(_25[0], _25[1]))]); + putAll$Option_u8_collections_btree_set_Union_Option_u8(rs.btreeUnion(_25[0], _25[1]), put, out); + putAll$Option_u8_collections_btree_set_Intersection_Option_u8(rs.btreeIntersection(_25[0], _25[1]), put, out); + putAll$Option_u8_collections_btree_set_Difference_Option_u8(rs.btreeDifference(_25[0], _25[1]), put, out); + putAll$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), put, out); + putHints$Option_u8_collections_btree_set_Union_Option_u8(rs.btreeUnion(_25[0], _25[1]), 1, out); + putHints$Option_u8_collections_btree_set_Intersection_Option_u8(rs.btreeIntersection(_25[0], _25[1]), 1, out); + putHints$Option_u8_collections_btree_set_Difference_Option_u8(rs.btreeDifference(_25[0], _25[1]), 1, out); + putHints$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), 1, out); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeUnion(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeIntersection(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeDifference(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeSymmetricDifference(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); + const iter2: rs.Iter> = rs.iterSlice([rs.btreeFromSorted(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, rs.btreeUnion(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, rs.btreeIntersection(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, rs.btreeDifference(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, rs.btreeSymmetricDifference(_25[0], _25[1]))]); while (true) { - const _81: rt.BTreeSet | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.BTreeSet | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - const built: rt.BTreeSet = _81; - putAll$Option_u8_collections_btree_set_Iter_Option_u8(rt.btreeKeys(built), put, out); - putAll$Option_u8_iter_Rev_collections_btree_set_Iter_Option_u8(rt.iterRev(rt.btreeKeys(built)), put, out); + const built: rs.BTreeSet = _81; + putAll$Option_u8_collections_btree_set_Iter_Option_u8(rs.btreeKeys(built), put, out); + putAll$Option_u8_iter_Rev_collections_btree_set_Iter_Option_u8(rs.iterRev(rs.btreeKeys(built)), put, out); } } - const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): rt.u8 | undefined => { + const _93: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_23: rs.u8): rs.u8 | undefined => { return make(_23); }); - const a2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _93, undefined, undefined, 469762048); - const _98: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_24: rt.u8): rt.u8 | undefined => { + const a2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, _93, undefined, undefined, 469762048); + const _98: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_24: rs.u8): rs.u8 | undefined => { return make(_24); }); - const b2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _98, undefined, undefined, 469762048); - const iter3: rt.Iter<[rt.HashSet, rt.HashSet]> = rt.iterSlice([[a2, b2] as [rt.HashSet, rt.HashSet], [b2, a2] as [rt.HashSet, rt.HashSet]]); + const b2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, _98, undefined, undefined, 469762048); + const iter3: rs.Iter<[rs.HashSet, rs.HashSet]> = rs.iterSlice([[a2, b2] as [rs.HashSet, rs.HashSet], [b2, a2] as [rs.HashSet, rs.HashSet]]); while (true) { - const _111: [rt.HashSet, rt.HashSet] | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: [rs.HashSet, rs.HashSet] | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - putSorted$Option_u8(rt.iterToVec(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); - putSorted$Option_u8(rt.iterToVec(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); - putSorted$Option_u8(rt.iterToVec(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); - putSorted$Option_u8(rt.iterToVec(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); - putHints$Option_u8_collections_hash_set_Union_Option_u8_hash_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); - putHints$Option_u8_collections_hash_set_Intersection_Option_u8_hash_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); - putHints$Option_u8_collections_hash_set_Difference_Option_u8_hash_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); - putHints$Option_u8_collections_hash_set_SymmetricDifference_Option_u8_hash_RandomState(rt.hashSymmetricDifference(_111[0], _111[1]), 0, out); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashUnion(_111[0], _111[1]).next(), rt.None), 221, (v: rt.u8 | undefined): rt.u8 => { + putSorted$Option_u8(rs.iterToVec(rs.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rs.iterToVec(rs.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rs.iterToVec(rs.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$Option_u8(rs.iterToVec(rs.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); + putHints$Option_u8_collections_hash_set_Union_Option_u8_hash_RandomState(rs.hashUnion(_111[0], _111[1]), 0, out); + putHints$Option_u8_collections_hash_set_Intersection_Option_u8_hash_RandomState(rs.hashIntersection(_111[0], _111[1]), 0, out); + putHints$Option_u8_collections_hash_set_Difference_Option_u8_hash_RandomState(rs.hashDifference(_111[0], _111[1]), 0, out); + putHints$Option_u8_collections_hash_set_SymmetricDifference_Option_u8_hash_RandomState(rs.hashSymmetricDifference(_111[0], _111[1]), 0, out); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashUnion(_111[0], _111[1]).next(), rs.None), 221, (v: rs.u8 | undefined): rs.u8 => { let _3!: boolean; - if (!rt.hashContains(_111[0], v)) { - _3 = rt.hashContains(_111[1], v); + if (!rs.hashContains(_111[0], v)) { + _3 = rs.hashContains(_111[1], v); } else { _3 = true; } return _3 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashIntersection(_111[0], _111[1]).next(), rt.None), 221, (v2: rt.u8 | undefined): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashIntersection(_111[0], _111[1]).next(), rs.None), 221, (v2: rs.u8 | undefined): rs.u8 => { let _32!: boolean; - if (!rt.hashContains(_111[0], v2)) { + if (!rs.hashContains(_111[0], v2)) { _32 = false; } else { - _32 = rt.hashContains(_111[1], v2); + _32 = rs.hashContains(_111[1], v2); } return _32 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashDifference(_111[0], _111[1]).next(), rt.None), 221, (v3: rt.u8 | undefined): rt.u8 => { - return !rt.hashContains(_111[1], v3) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashDifference(_111[0], _111[1]).next(), rs.None), 221, (v3: rs.u8 | undefined): rs.u8 => { + return !rs.hashContains(_111[1], v3) ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashSymmetricDifference(_111[0], _111[1]).next(), rt.None), 221, (v4: rt.u8 | undefined): rt.u8 => { - return rt.hashContains(_111[0], v4) !== rt.hashContains(_111[1], v4) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashSymmetricDifference(_111[0], _111[1]).next(), rs.None), 221, (v4: rs.u8 | undefined): rs.u8 => { + return rs.hashContains(_111[0], v4) !== rs.hashContains(_111[1], v4) ? 1 : 0; })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); - const iter4: rt.Iter> = rt.iterSlice([rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rs.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rs.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); + const iter4: rs.Iter> = rs.iterSlice([rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); while (true) { - const _175: rt.HashSet | rt.Done = iter4.next(); - if (_175 === rt.DONE) { + const _175: rs.HashSet | rs.Done = iter4.next(); + if (_175 === rs.DONE) { break; } - putSorted$Option_u8(rt.iterToVec(rt.hashKeys(_175), "next", 4), put, out); + putSorted$Option_u8(rs.iterToVec(rs.hashKeys(_175), "next", 4), put, out); } } } -export function setOpsOf$array2_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => Uint8Array, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): Uint8Array => { +export function setOpsOf$array2_u8(left: rs.ByteSlice, right: rs.ByteSlice, make: (a0: rs.u8) => Uint8Array, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const _7: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): Uint8Array => { return make(_2); }); - const a: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, _7, true, undefined, undefined, 2, true); - const _12: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): Uint8Array => { + const a: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, _7, true, undefined, undefined, 2, true); + const _12: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): Uint8Array => { return make(_22); }); - const b: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, _12, true, undefined, undefined, 2, true); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[a, b] as [rt.BTreeSet, rt.BTreeSet], [b, a] as [rt.BTreeSet, rt.BTreeSet]]); + const b: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, _12, true, undefined, undefined, 2, true); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[a, b] as [rs.BTreeSet, rs.BTreeSet], [b, a] as [rs.BTreeSet, rs.BTreeSet]]); while (true) { - const _25: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - putAll$array2_u8_collections_btree_set_Union_array2_u8(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$array2_u8_collections_btree_set_Intersection_array2_u8(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$array2_u8_collections_btree_set_Difference_array2_u8(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putAll$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), put, out); - putHints$array2_u8_collections_btree_set_Union_array2_u8(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$array2_u8_collections_btree_set_Intersection_array2_u8(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$array2_u8_collections_btree_set_Difference_array2_u8(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - putHints$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom), 1, out); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeUnion(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeIntersection(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.btreeSymmetricDifference(_25[0], _25[1]), rt.byteSliceFrom).next()), 221, put)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); - const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeUnion(_25[0], _25[1]), copy$array_u8)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeIntersection(_25[0], _25[1]), copy$array_u8)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeDifference(_25[0], _25[1]), copy$array_u8)), rt.btreeFromSorted(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, rt.iterMap(rt.btreeSymmetricDifference(_25[0], _25[1]), copy$array_u8))]); + putAll$array2_u8_collections_btree_set_Union_array2_u8(rs.iterLend(rs.btreeUnion(_25[0], _25[1]), rs.byteSliceFrom), put, out); + putAll$array2_u8_collections_btree_set_Intersection_array2_u8(rs.iterLend(rs.btreeIntersection(_25[0], _25[1]), rs.byteSliceFrom), put, out); + putAll$array2_u8_collections_btree_set_Difference_array2_u8(rs.iterLend(rs.btreeDifference(_25[0], _25[1]), rs.byteSliceFrom), put, out); + putAll$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(rs.iterLend(rs.btreeSymmetricDifference(_25[0], _25[1]), rs.byteSliceFrom), put, out); + putHints$array2_u8_collections_btree_set_Union_array2_u8(rs.iterLend(rs.btreeUnion(_25[0], _25[1]), rs.byteSliceFrom), 1, out); + putHints$array2_u8_collections_btree_set_Intersection_array2_u8(rs.iterLend(rs.btreeIntersection(_25[0], _25[1]), rs.byteSliceFrom), 1, out); + putHints$array2_u8_collections_btree_set_Difference_array2_u8(rs.iterLend(rs.btreeDifference(_25[0], _25[1]), rs.byteSliceFrom), 1, out); + putHints$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(rs.iterLend(rs.btreeSymmetricDifference(_25[0], _25[1]), rs.byteSliceFrom), 1, out); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.btreeUnion(_25[0], _25[1]), rs.byteSliceFrom).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.btreeIntersection(_25[0], _25[1]), rs.byteSliceFrom).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.btreeDifference(_25[0], _25[1]), rs.byteSliceFrom).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.btreeSymmetricDifference(_25[0], _25[1]), rs.byteSliceFrom).next()), 221, put)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); + const iter2: rs.Iter> = rs.iterSlice([rs.btreeFromSorted(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, rs.iterMap(rs.btreeUnion(_25[0], _25[1]), copy$array_u8)), rs.btreeFromSorted(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, rs.iterMap(rs.btreeIntersection(_25[0], _25[1]), copy$array_u8)), rs.btreeFromSorted(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, rs.iterMap(rs.btreeDifference(_25[0], _25[1]), copy$array_u8)), rs.btreeFromSorted(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, rs.iterMap(rs.btreeSymmetricDifference(_25[0], _25[1]), copy$array_u8))]); while (true) { - const _81: rt.BTreeSet | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.BTreeSet | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - const built: rt.BTreeSet = _81; - putAll$array2_u8_collections_btree_set_Iter_array2_u8(rt.iterLend(rt.btreeKeys(built), rt.byteSliceFrom), put, out); - putAll$array2_u8_iter_Rev_collections_btree_set_Iter_array2_u8(rt.iterRev(rt.iterLend(rt.btreeKeys(built), rt.byteSliceFrom)), put, out); + const built: rs.BTreeSet = _81; + putAll$array2_u8_collections_btree_set_Iter_array2_u8(rs.iterLend(rs.btreeKeys(built), rs.byteSliceFrom), put, out); + putAll$array2_u8_iter_Rev_collections_btree_set_Iter_array2_u8(rs.iterRev(rs.iterLend(rs.btreeKeys(built), rs.byteSliceFrom)), put, out); } } - const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): Uint8Array => { + const _93: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_23: rs.u8): Uint8Array => { return make(_23); }); - const a2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _93, undefined, undefined, 469762048); - const _98: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_24: rt.u8): Uint8Array => { + const a2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _93, undefined, undefined, 469762048); + const _98: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_24: rs.u8): Uint8Array => { return make(_24); }); - const b2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _98, undefined, undefined, 469762048); - const iter3: rt.Iter<[rt.HashSet, rt.HashSet]> = rt.iterSlice([[a2, b2] as [rt.HashSet, rt.HashSet], [b2, a2] as [rt.HashSet, rt.HashSet]]); + const b2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _98, undefined, undefined, 469762048); + const iter3: rs.Iter<[rs.HashSet, rs.HashSet]> = rs.iterSlice([[a2, b2] as [rs.HashSet, rs.HashSet], [b2, a2] as [rs.HashSet, rs.HashSet]]); while (true) { - const _111: [rt.HashSet, rt.HashSet] | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: [rs.HashSet, rs.HashSet] | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - putSorted$array2_u8(rt.iterToVec(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$array2_u8(rt.iterToVec(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$array2_u8(rt.iterToVec(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putSorted$array2_u8(rt.iterToVec(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), "next", 4), put, out); - putHints$array2_u8_collections_hash_set_Union_array2_u8_hash_RandomState(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$array2_u8_collections_hash_set_Intersection_array2_u8_hash_RandomState(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$array2_u8_collections_hash_set_Difference_array2_u8_hash_RandomState(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - putHints$array2_u8_collections_hash_set_SymmetricDifference_array2_u8_hash_RandomState(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom), 0, out); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashUnion(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v: rt.ByteSlice): rt.u8 => { + putSorted$array2_u8(rs.iterToVec(rs.iterLend(rs.hashUnion(_111[0], _111[1]), rs.byteSliceFrom), "next", 4), put, out); + putSorted$array2_u8(rs.iterToVec(rs.iterLend(rs.hashIntersection(_111[0], _111[1]), rs.byteSliceFrom), "next", 4), put, out); + putSorted$array2_u8(rs.iterToVec(rs.iterLend(rs.hashDifference(_111[0], _111[1]), rs.byteSliceFrom), "next", 4), put, out); + putSorted$array2_u8(rs.iterToVec(rs.iterLend(rs.hashSymmetricDifference(_111[0], _111[1]), rs.byteSliceFrom), "next", 4), put, out); + putHints$array2_u8_collections_hash_set_Union_array2_u8_hash_RandomState(rs.iterLend(rs.hashUnion(_111[0], _111[1]), rs.byteSliceFrom), 0, out); + putHints$array2_u8_collections_hash_set_Intersection_array2_u8_hash_RandomState(rs.iterLend(rs.hashIntersection(_111[0], _111[1]), rs.byteSliceFrom), 0, out); + putHints$array2_u8_collections_hash_set_Difference_array2_u8_hash_RandomState(rs.iterLend(rs.hashDifference(_111[0], _111[1]), rs.byteSliceFrom), 0, out); + putHints$array2_u8_collections_hash_set_SymmetricDifference_array2_u8_hash_RandomState(rs.iterLend(rs.hashSymmetricDifference(_111[0], _111[1]), rs.byteSliceFrom), 0, out); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.hashUnion(_111[0], _111[1]), rs.byteSliceFrom).next()), 221, (v: rs.ByteSlice): rs.u8 => { let _3!: boolean; - if (!rt.hashContains(_111[0], rt.byteSliceView(v))) { - _3 = rt.hashContains(_111[1], rt.byteSliceView(v)); + if (!rs.hashContains(_111[0], rs.byteSliceView(v))) { + _3 = rs.hashContains(_111[1], rs.byteSliceView(v)); } else { _3 = true; } return _3 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashIntersection(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v2: rt.ByteSlice): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.hashIntersection(_111[0], _111[1]), rs.byteSliceFrom).next()), 221, (v2: rs.ByteSlice): rs.u8 => { let _32!: boolean; - if (!rt.hashContains(_111[0], rt.byteSliceView(v2))) { + if (!rs.hashContains(_111[0], rs.byteSliceView(v2))) { _32 = false; } else { - _32 = rt.hashContains(_111[1], rt.byteSliceView(v2)); + _32 = rs.hashContains(_111[1], rs.byteSliceView(v2)); } return _32 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v3: rt.ByteSlice): rt.u8 => { - return !rt.hashContains(_111[1], rt.byteSliceView(v3)) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.hashDifference(_111[0], _111[1]), rs.byteSliceFrom).next()), 221, (v3: rs.ByteSlice): rs.u8 => { + return !rs.hashContains(_111[1], rs.byteSliceView(v3)) ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.iterToOption(rt.iterLend(rt.hashSymmetricDifference(_111[0], _111[1]), rt.byteSliceFrom).next()), 221, (v4: rt.ByteSlice): rt.u8 => { - return rt.hashContains(_111[0], rt.byteSliceView(v4)) !== rt.hashContains(_111[1], rt.byteSliceView(v4)) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.iterToOption(rs.iterLend(rs.hashSymmetricDifference(_111[0], _111[1]), rs.byteSliceFrom).next()), 221, (v4: rs.ByteSlice): rs.u8 => { + return rs.hashContains(_111[0], rs.byteSliceView(v4)) !== rs.hashContains(_111[1], rs.byteSliceView(v4)) ? 1 : 0; })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); - const iter4: rt.Iter> = rt.iterSlice([rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, rt.iterMap(rt.hashUnion(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, rt.iterMap(rt.hashIntersection(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, rt.iterMap(rt.hashDifference(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, rt.iterMap(rt.hashSymmetricDifference(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rs.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rs.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); + const iter4: rs.Iter> = rs.iterSlice([rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, rs.iterMap(rs.hashUnion(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, rs.iterMap(rs.hashIntersection(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, rs.iterMap(rs.hashDifference(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, rs.iterMap(rs.hashSymmetricDifference(_111[0], _111[1]), copy$array_u8), undefined, undefined, 469762048)]); while (true) { - const _175: rt.HashSet | rt.Done = iter4.next(); - if (_175 === rt.DONE) { + const _175: rs.HashSet | rs.Done = iter4.next(); + if (_175 === rs.DONE) { break; } - putSorted$array2_u8(rt.iterToVec(rt.iterLend(rt.hashKeys(_175), rt.byteSliceFrom), "next", 4), put, out); + putSorted$array2_u8(rs.iterToVec(rs.iterLend(rs.hashKeys(_175), rs.byteSliceFrom), "next", 4), put, out); } } } -export function setOpsOf$cmp_Reverse_Option_u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8 | undefined, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 | undefined => { +export function setOpsOf$cmp_Reverse_Option_u8(left: rs.ByteSlice, right: rs.ByteSlice, make: (a0: rs.u8) => rs.u8 | undefined, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const _7: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): rs.u8 | undefined => { return make(_2); }); - const a: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, _7, true, undefined, undefined, 2, true); - const _12: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): rt.u8 | undefined => { + const a: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, _7, true, undefined, undefined, 2, true); + const _12: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): rs.u8 | undefined => { return make(_22); }); - const b: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, _12, true, undefined, undefined, 2, true); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[a, b] as [rt.BTreeSet, rt.BTreeSet], [b, a] as [rt.BTreeSet, rt.BTreeSet]]); + const b: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, _12, true, undefined, undefined, 2, true); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[a, b] as [rs.BTreeSet, rs.BTreeSet], [b, a] as [rs.BTreeSet, rs.BTreeSet]]); while (true) { - const _25: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - putAll$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(rt.btreeUnion(_25[0], _25[1]), put, out); - putAll$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(rt.btreeIntersection(_25[0], _25[1]), put, out); - putAll$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(rt.btreeDifference(_25[0], _25[1]), put, out); - putAll$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), put, out); - putHints$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(rt.btreeUnion(_25[0], _25[1]), 1, out); - putHints$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(rt.btreeIntersection(_25[0], _25[1]), 1, out); - putHints$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(rt.btreeDifference(_25[0], _25[1]), 1, out); - putHints$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), 1, out); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeUnion(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeIntersection(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeDifference(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.btreeSymmetricDifference(_25[0], _25[1]).next(), rt.None), 221, put)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); - const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, rt.btreeUnion(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, rt.btreeIntersection(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, rt.btreeDifference(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmpReverse(rt.cmpOption(rt.cmp))) as rt.BTreeSet, rt.btreeSymmetricDifference(_25[0], _25[1]))]); + putAll$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(rs.btreeUnion(_25[0], _25[1]), put, out); + putAll$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(rs.btreeIntersection(_25[0], _25[1]), put, out); + putAll$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(rs.btreeDifference(_25[0], _25[1]), put, out); + putAll$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), put, out); + putHints$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(rs.btreeUnion(_25[0], _25[1]), 1, out); + putHints$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(rs.btreeIntersection(_25[0], _25[1]), 1, out); + putHints$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(rs.btreeDifference(_25[0], _25[1]), 1, out); + putHints$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), 1, out); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeUnion(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeIntersection(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeDifference(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.btreeSymmetricDifference(_25[0], _25[1]).next(), rs.None), 221, put)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); + const iter2: rs.Iter> = rs.iterSlice([rs.btreeFromSorted(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, rs.btreeUnion(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, rs.btreeIntersection(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, rs.btreeDifference(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmpReverse(rs.cmpOption(rs.cmp))) as rs.BTreeSet, rs.btreeSymmetricDifference(_25[0], _25[1]))]); while (true) { - const _81: rt.BTreeSet | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.BTreeSet | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - const built: rt.BTreeSet = _81; - putAll$cmp_Reverse_Option_u8_collections_btree_set_Iter_cmp_Reverse_Option_u8(rt.btreeKeys(built), put, out); - putAll$cmp_Reverse_Option_u8_iter_Rev_collections_btree_set_Iter_cmp_Reverse_Option_u8(rt.iterRev(rt.btreeKeys(built)), put, out); + const built: rs.BTreeSet = _81; + putAll$cmp_Reverse_Option_u8_collections_btree_set_Iter_cmp_Reverse_Option_u8(rs.btreeKeys(built), put, out); + putAll$cmp_Reverse_Option_u8_iter_Rev_collections_btree_set_Iter_cmp_Reverse_Option_u8(rs.iterRev(rs.btreeKeys(built)), put, out); } } - const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): rt.u8 | undefined => { + const _93: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_23: rs.u8): rs.u8 | undefined => { return make(_23); }); - const a2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _93, undefined, undefined, 469762048); - const _98: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_24: rt.u8): rt.u8 | undefined => { + const a2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, _93, undefined, undefined, 469762048); + const _98: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_24: rs.u8): rs.u8 | undefined => { return make(_24); }); - const b2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _98, undefined, undefined, 469762048); - const iter3: rt.Iter<[rt.HashSet, rt.HashSet]> = rt.iterSlice([[a2, b2] as [rt.HashSet, rt.HashSet], [b2, a2] as [rt.HashSet, rt.HashSet]]); + const b2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, _98, undefined, undefined, 469762048); + const iter3: rs.Iter<[rs.HashSet, rs.HashSet]> = rs.iterSlice([[a2, b2] as [rs.HashSet, rs.HashSet], [b2, a2] as [rs.HashSet, rs.HashSet]]); while (true) { - const _111: [rt.HashSet, rt.HashSet] | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: [rs.HashSet, rs.HashSet] | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - putSorted$cmp_Reverse_Option_u8(rt.iterToVec(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); - putSorted$cmp_Reverse_Option_u8(rt.iterToVec(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); - putSorted$cmp_Reverse_Option_u8(rt.iterToVec(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); - putSorted$cmp_Reverse_Option_u8(rt.iterToVec(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); - putHints$cmp_Reverse_Option_u8_collections_hash_set_Union_cmp_Reverse_Option_u8_hash_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); - putHints$cmp_Reverse_Option_u8_collections_hash_set_Intersection_cmp_Reverse_Option_u8_hash_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); - putHints$cmp_Reverse_Option_u8_collections_hash_set_Difference_cmp_Reverse_Option_u8_hash_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); - putHints$cmp_Reverse_Option_u8_collections_hash_set_SymmetricDifference_cmp_Reverse_Option_u8_hash_RandomState(rt.hashSymmetricDifference(_111[0], _111[1]), 0, out); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashUnion(_111[0], _111[1]).next(), rt.None), 221, (v: rt.u8 | undefined): rt.u8 => { + putSorted$cmp_Reverse_Option_u8(rs.iterToVec(rs.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$cmp_Reverse_Option_u8(rs.iterToVec(rs.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$cmp_Reverse_Option_u8(rs.iterToVec(rs.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$cmp_Reverse_Option_u8(rs.iterToVec(rs.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); + putHints$cmp_Reverse_Option_u8_collections_hash_set_Union_cmp_Reverse_Option_u8_hash_RandomState(rs.hashUnion(_111[0], _111[1]), 0, out); + putHints$cmp_Reverse_Option_u8_collections_hash_set_Intersection_cmp_Reverse_Option_u8_hash_RandomState(rs.hashIntersection(_111[0], _111[1]), 0, out); + putHints$cmp_Reverse_Option_u8_collections_hash_set_Difference_cmp_Reverse_Option_u8_hash_RandomState(rs.hashDifference(_111[0], _111[1]), 0, out); + putHints$cmp_Reverse_Option_u8_collections_hash_set_SymmetricDifference_cmp_Reverse_Option_u8_hash_RandomState(rs.hashSymmetricDifference(_111[0], _111[1]), 0, out); + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashUnion(_111[0], _111[1]).next(), rs.None), 221, (v: rs.u8 | undefined): rs.u8 => { let _3!: boolean; - if (!rt.hashContains(_111[0], v)) { - _3 = rt.hashContains(_111[1], v); + if (!rs.hashContains(_111[0], v)) { + _3 = rs.hashContains(_111[1], v); } else { _3 = true; } return _3 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashIntersection(_111[0], _111[1]).next(), rt.None), 221, (v2: rt.u8 | undefined): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashIntersection(_111[0], _111[1]).next(), rs.None), 221, (v2: rs.u8 | undefined): rs.u8 => { let _32!: boolean; - if (!rt.hashContains(_111[0], v2)) { + if (!rs.hashContains(_111[0], v2)) { _32 = false; } else { - _32 = rt.hashContains(_111[1], v2); + _32 = rs.hashContains(_111[1], v2); } return _32 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashDifference(_111[0], _111[1]).next(), rt.None), 221, (v3: rt.u8 | undefined): rt.u8 => { - return !rt.hashContains(_111[1], v3) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashDifference(_111[0], _111[1]).next(), rs.None), 221, (v3: rs.u8 | undefined): rs.u8 => { + return !rs.hashContains(_111[1], v3) ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1xztl8h(rt.iterToOption(rt.hashSymmetricDifference(_111[0], _111[1]).next(), rt.None), 221, (v4: rt.u8 | undefined): rt.u8 => { - return rt.hashContains(_111[0], v4) !== rt.hashContains(_111[1], v4) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$1rg5gkk(rs.iterToOption(rs.hashSymmetricDifference(_111[0], _111[1]).next(), rs.None), 221, (v4: rs.u8 | undefined): rs.u8 => { + return rs.hashContains(_111[0], v4) !== rs.hashContains(_111[1], v4) ? 1 : 0; })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); - const iter4: rt.Iter> = rt.iterSlice([rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, rt.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rs.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rs.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); + const iter4: rs.Iter> = rs.iterSlice([rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, rs.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); while (true) { - const _175: rt.HashSet | rt.Done = iter4.next(); - if (_175 === rt.DONE) { + const _175: rs.HashSet | rs.Done = iter4.next(); + if (_175 === rs.DONE) { break; } - putSorted$cmp_Reverse_Option_u8(rt.iterToVec(rt.hashKeys(_175), "next", 4), put, out); + putSorted$cmp_Reverse_Option_u8(rs.iterToVec(rs.hashKeys(_175), "next", 4), put, out); } } } -export function setOpsOf$collections_Nibble(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => Nibble.Nibble, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): Nibble.Nibble => { +export function setOpsOf$collections_Nibble(left: rs.ByteSlice, right: rs.ByteSlice, make: (a0: rs.u8) => Nibble.Nibble, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const _7: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): Nibble.Nibble => { return make(_2); }); - const a: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_7, undefined, 1, true).items, 1, true, rt.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); - const _12: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): Nibble.Nibble => { + const a: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_7, undefined, 1, true).items, 1, true, rs.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); + const _12: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): Nibble.Nibble => { return make(_22); }); - const b: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_12, undefined, 1, true).items, 1, true, rt.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[a, b] as [rt.BTreeSet, rt.BTreeSet], [b, a] as [rt.BTreeSet, rt.BTreeSet]]); + const b: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_12, undefined, 1, true).items, 1, true, rs.cmpLt(Nibble.partialCmp$cmp_PartialOrd), Nibble.eq$cmp_PartialEq); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[a, b] as [rs.BTreeSet, rs.BTreeSet], [b, a] as [rs.BTreeSet, rs.BTreeSet]]); while (true) { - const _25: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - putAll$collections_Nibble_collections_btree_set_Union_collections_Nibble(rt.btreeUnion(_25[0], _25[1]), put, out); - putAll$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(rt.btreeIntersection(_25[0], _25[1]), put, out); - putAll$collections_Nibble_collections_btree_set_Difference_collections_Nibble(rt.btreeDifference(_25[0], _25[1]), put, out); - putAll$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(rt.btreeSymmetricDifference(_25[0], _25[1]), put, out); - putHints$collections_Nibble_collections_btree_set_Union_collections_Nibble(rt.btreeUnion(_25[0], _25[1]), 1, out); - putHints$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(rt.btreeIntersection(_25[0], _25[1]), 1, out); - putHints$collections_Nibble_collections_btree_set_Difference_collections_Nibble(rt.btreeDifference(_25[0], _25[1]), 1, out); - putHints$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(rt.btreeSymmetricDifference(_25[0], _25[1]), 1, out); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.btreeUnion(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.btreeIntersection(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.btreeDifference(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.btreeSymmetricDifference(_25[0], _25[1]).next()), 221, put)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); - const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeUnion(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rt.btreeFromSorted(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeIntersection(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rt.btreeFromSorted(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeDifference(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rt.btreeFromSorted(rt.btreeNew(Nibble.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeSymmetricDifference(_25[0], _25[1]), Nibble.eq$cmp_PartialEq)]); + putAll$collections_Nibble_collections_btree_set_Union_collections_Nibble(rs.btreeUnion(_25[0], _25[1]), put, out); + putAll$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(rs.btreeIntersection(_25[0], _25[1]), put, out); + putAll$collections_Nibble_collections_btree_set_Difference_collections_Nibble(rs.btreeDifference(_25[0], _25[1]), put, out); + putAll$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(rs.btreeSymmetricDifference(_25[0], _25[1]), put, out); + putHints$collections_Nibble_collections_btree_set_Union_collections_Nibble(rs.btreeUnion(_25[0], _25[1]), 1, out); + putHints$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(rs.btreeIntersection(_25[0], _25[1]), 1, out); + putHints$collections_Nibble_collections_btree_set_Difference_collections_Nibble(rs.btreeDifference(_25[0], _25[1]), 1, out); + putHints$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(rs.btreeSymmetricDifference(_25[0], _25[1]), 1, out); + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.btreeUnion(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.btreeIntersection(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.btreeDifference(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.btreeSymmetricDifference(_25[0], _25[1]).next()), 221, put)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); + const iter2: rs.Iter> = rs.iterSlice([rs.btreeFromSorted(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeUnion(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rs.btreeFromSorted(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeIntersection(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rs.btreeFromSorted(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeDifference(_25[0], _25[1]), Nibble.eq$cmp_PartialEq), rs.btreeFromSorted(rs.btreeNew(Nibble.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeSymmetricDifference(_25[0], _25[1]), Nibble.eq$cmp_PartialEq)]); while (true) { - const _81: rt.BTreeSet | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.BTreeSet | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - const built: rt.BTreeSet = _81; - putAll$collections_Nibble_collections_btree_set_Iter_collections_Nibble(rt.btreeKeys(built), put, out); - putAll$collections_Nibble_iter_Rev_collections_btree_set_Iter_collections_Nibble(rt.iterRev(rt.btreeKeys(built)), put, out); + const built: rs.BTreeSet = _81; + putAll$collections_Nibble_collections_btree_set_Iter_collections_Nibble(rs.btreeKeys(built), put, out); + putAll$collections_Nibble_iter_Rev_collections_btree_set_Iter_collections_Nibble(rs.iterRev(rs.btreeKeys(built)), put, out); } } - const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): Nibble.Nibble => { + const _93: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_23: rs.u8): Nibble.Nibble => { return make(_23); }); - const a2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, _93, undefined, undefined, 469762048); - const _98: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_24: rt.u8): Nibble.Nibble => { + const a2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, _93, undefined, undefined, 469762048); + const _98: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_24: rs.u8): Nibble.Nibble => { return make(_24); }); - const b2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, _98, undefined, undefined, 469762048); - const iter3: rt.Iter<[rt.HashSet, rt.HashSet]> = rt.iterSlice([[a2, b2] as [rt.HashSet, rt.HashSet], [b2, a2] as [rt.HashSet, rt.HashSet]]); + const b2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, _98, undefined, undefined, 469762048); + const iter3: rs.Iter<[rs.HashSet, rs.HashSet]> = rs.iterSlice([[a2, b2] as [rs.HashSet, rs.HashSet], [b2, a2] as [rs.HashSet, rs.HashSet]]); while (true) { - const _111: [rt.HashSet, rt.HashSet] | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: [rs.HashSet, rs.HashSet] | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - putSorted$collections_Nibble(rt.iterToVec(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); - putSorted$collections_Nibble(rt.iterToVec(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); - putSorted$collections_Nibble(rt.iterToVec(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); - putSorted$collections_Nibble(rt.iterToVec(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); - putHints$collections_Nibble_collections_hash_set_Union_collections_Nibble_hash_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); - putHints$collections_Nibble_collections_hash_set_Intersection_collections_Nibble_hash_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); - putHints$collections_Nibble_collections_hash_set_Difference_collections_Nibble_hash_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); - putHints$collections_Nibble_collections_hash_set_SymmetricDifference_collections_Nibble_hash_RandomState(rt.hashSymmetricDifference(_111[0], _111[1]), 0, out); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.hashUnion(_111[0], _111[1]).next()), 221, (v: Nibble.Nibble): rt.u8 => { + putSorted$collections_Nibble(rs.iterToVec(rs.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$collections_Nibble(rs.iterToVec(rs.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$collections_Nibble(rs.iterToVec(rs.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$collections_Nibble(rs.iterToVec(rs.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); + putHints$collections_Nibble_collections_hash_set_Union_collections_Nibble_hash_RandomState(rs.hashUnion(_111[0], _111[1]), 0, out); + putHints$collections_Nibble_collections_hash_set_Intersection_collections_Nibble_hash_RandomState(rs.hashIntersection(_111[0], _111[1]), 0, out); + putHints$collections_Nibble_collections_hash_set_Difference_collections_Nibble_hash_RandomState(rs.hashDifference(_111[0], _111[1]), 0, out); + putHints$collections_Nibble_collections_hash_set_SymmetricDifference_collections_Nibble_hash_RandomState(rs.hashSymmetricDifference(_111[0], _111[1]), 0, out); + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.hashUnion(_111[0], _111[1]).next()), 221, (v: Nibble.Nibble): rs.u8 => { let _3!: boolean; - if (!rt.hashContains(_111[0], v)) { - _3 = rt.hashContains(_111[1], v); + if (!rs.hashContains(_111[0], v)) { + _3 = rs.hashContains(_111[1], v); } else { _3 = true; } return _3 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.hashIntersection(_111[0], _111[1]).next()), 221, (v2: Nibble.Nibble): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.hashIntersection(_111[0], _111[1]).next()), 221, (v2: Nibble.Nibble): rs.u8 => { let _32!: boolean; - if (!rt.hashContains(_111[0], v2)) { + if (!rs.hashContains(_111[0], v2)) { _32 = false; } else { - _32 = rt.hashContains(_111[1], v2); + _32 = rs.hashContains(_111[1], v2); } return _32 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.hashDifference(_111[0], _111[1]).next()), 221, (v3: Nibble.Nibble): rt.u8 => { - return !rt.hashContains(_111[1], v3) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.hashDifference(_111[0], _111[1]).next()), 221, (v3: Nibble.Nibble): rs.u8 => { + return !rs.hashContains(_111[1], v3) ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$0q0ymkh(rt.iterToOption(rt.hashSymmetricDifference(_111[0], _111[1]).next()), 221, (v4: Nibble.Nibble): rt.u8 => { - return rt.hashContains(_111[0], v4) !== rt.hashContains(_111[1], v4) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0f7cus0(rs.iterToOption(rs.hashSymmetricDifference(_111[0], _111[1]).next()), 221, (v4: Nibble.Nibble): rs.u8 => { + return rs.hashContains(_111[0], v4) !== rs.hashContains(_111[1], v4) ? 1 : 0; })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); - const iter4: rt.Iter> = rt.iterSlice([rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, rt.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, rt.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, rt.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew(rt.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rt.HashSet, rt.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rs.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rs.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); + const iter4: rs.Iter> = rs.iterSlice([rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, rs.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, rs.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, rs.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew(rs.hashing(Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined, Nibble.eq$cmp_PartialEq)) as rs.HashSet, rs.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); while (true) { - const _175: rt.HashSet | rt.Done = iter4.next(); - if (_175 === rt.DONE) { + const _175: rs.HashSet | rs.Done = iter4.next(); + if (_175 === rs.DONE) { break; } - putSorted$collections_Nibble(rt.iterToVec(rt.hashKeys(_175), "next", 4), put, out); + putSorted$collections_Nibble(rs.iterToVec(rs.hashKeys(_175), "next", 4), put, out); } } } -export function setOpsOf$u8(left: rt.ByteSlice, right: rt.ByteSlice, make: (a0: rt.u8) => rt.u8, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const _7: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.u8 => { +export function setOpsOf$u8(left: rs.ByteSlice, right: rs.ByteSlice, make: (a0: rs.u8) => rs.u8, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const _7: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): rs.u8 => { return make(_2); }); - const a: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _7, true, undefined, undefined, 1, true); - const _12: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): rt.u8 => { + const a: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _7, true, undefined, undefined, 1, true); + const _12: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): rs.u8 => { return make(_22); }); - const b: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _12, true, undefined, undefined, 1, true); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[a, b] as [rt.BTreeSet, rt.BTreeSet], [b, a] as [rt.BTreeSet, rt.BTreeSet]]); + const b: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _12, true, undefined, undefined, 1, true); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[a, b] as [rs.BTreeSet, rs.BTreeSet], [b, a] as [rs.BTreeSet, rs.BTreeSet]]); while (true) { - const _25: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - putAll$u8_collections_btree_set_Union_u8(rt.btreeUnion(_25[0], _25[1]), put, out); - putAll$u8_collections_btree_set_Intersection_u8(rt.btreeIntersection(_25[0], _25[1]), put, out); - putAll$u8_collections_btree_set_Difference_u8(rt.btreeDifference(_25[0], _25[1]), put, out); - putAll$u8_collections_btree_set_SymmetricDifference_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), put, out); - putHints$u8_collections_btree_set_Union_u8(rt.btreeUnion(_25[0], _25[1]), 1, out); - putHints$u8_collections_btree_set_Intersection_u8(rt.btreeIntersection(_25[0], _25[1]), 1, out); - putHints$u8_collections_btree_set_Difference_u8(rt.btreeDifference(_25[0], _25[1]), 1, out); - putHints$u8_collections_btree_set_SymmetricDifference_u8(rt.btreeSymmetricDifference(_25[0], _25[1]), 1, out); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.btreeUnion(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.btreeIntersection(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.btreeDifference(_25[0], _25[1]).next()), 221, put)); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.btreeSymmetricDifference(_25[0], _25[1]).next()), 221, put)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rt.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); - const iter2: rt.Iter> = rt.iterSlice([rt.btreeFromSorted(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.btreeUnion(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.btreeIntersection(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.btreeDifference(_25[0], _25[1])), rt.btreeFromSorted(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.btreeSymmetricDifference(_25[0], _25[1]))]); + putAll$u8_collections_btree_set_Union_u8(rs.btreeUnion(_25[0], _25[1]), put, out); + putAll$u8_collections_btree_set_Intersection_u8(rs.btreeIntersection(_25[0], _25[1]), put, out); + putAll$u8_collections_btree_set_Difference_u8(rs.btreeDifference(_25[0], _25[1]), put, out); + putAll$u8_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), put, out); + putHints$u8_collections_btree_set_Union_u8(rs.btreeUnion(_25[0], _25[1]), 1, out); + putHints$u8_collections_btree_set_Intersection_u8(rs.btreeIntersection(_25[0], _25[1]), 1, out); + putHints$u8_collections_btree_set_Difference_u8(rs.btreeDifference(_25[0], _25[1]), 1, out); + putHints$u8_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_25[0], _25[1]), 1, out); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.btreeUnion(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.btreeIntersection(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.btreeDifference(_25[0], _25[1]).next()), 221, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.btreeSymmetricDifference(_25[0], _25[1]).next()), 221, put)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeIsSubset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsSuperset(_25[0], _25[1]) ? 1 : 0, rs.btreeIsDisjoint(_25[0], _25[1]) ? 1 : 0)), undefined, true); + const iter2: rs.Iter> = rs.iterSlice([rs.btreeFromSorted(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.btreeUnion(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.btreeIntersection(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.btreeDifference(_25[0], _25[1])), rs.btreeFromSorted(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.btreeSymmetricDifference(_25[0], _25[1]))]); while (true) { - const _81: rt.BTreeSet | rt.Done = iter2.next(); - if (_81 === rt.DONE) { + const _81: rs.BTreeSet | rs.Done = iter2.next(); + if (_81 === rs.DONE) { break; } - const built: rt.BTreeSet = _81; - putAll$u8_collections_btree_set_Iter_u8(rt.btreeKeys(built), put, out); - putAll$u8_iter_Rev_collections_btree_set_Iter_u8(rt.iterRev(rt.btreeKeys(built)), put, out); + const built: rs.BTreeSet = _81; + putAll$u8_collections_btree_set_Iter_u8(rs.btreeKeys(built), put, out); + putAll$u8_iter_Rev_collections_btree_set_Iter_u8(rs.iterRev(rs.btreeKeys(built)), put, out); } } - const _93: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_23: rt.u8): rt.u8 => { + const _93: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_23: rs.u8): rs.u8 => { return make(_23); }); - const a2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _93, undefined, undefined, 469762048); - const _98: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_24: rt.u8): rt.u8 => { + const a2: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _93, undefined, undefined, 469762048); + const _98: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_24: rs.u8): rs.u8 => { return make(_24); }); - const b2: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _98, undefined, undefined, 469762048); - const iter3: rt.Iter<[rt.HashSet, rt.HashSet]> = rt.iterSlice([[a2, b2] as [rt.HashSet, rt.HashSet], [b2, a2] as [rt.HashSet, rt.HashSet]]); + const b2: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _98, undefined, undefined, 469762048); + const iter3: rs.Iter<[rs.HashSet, rs.HashSet]> = rs.iterSlice([[a2, b2] as [rs.HashSet, rs.HashSet], [b2, a2] as [rs.HashSet, rs.HashSet]]); while (true) { - const _111: [rt.HashSet, rt.HashSet] | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: [rs.HashSet, rs.HashSet] | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - putSorted$u8(rt.iterToVec(rt.hashUnion(_111[0], _111[1]), "next", 4), put, out); - putSorted$u8(rt.iterToVec(rt.hashIntersection(_111[0], _111[1]), "next", 4), put, out); - putSorted$u8(rt.iterToVec(rt.hashDifference(_111[0], _111[1]), "next", 4), put, out); - putSorted$u8(rt.iterToVec(rt.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); - putHints$u8_collections_hash_set_Union_u8_hash_RandomState(rt.hashUnion(_111[0], _111[1]), 0, out); - putHints$u8_collections_hash_set_Intersection_u8_hash_RandomState(rt.hashIntersection(_111[0], _111[1]), 0, out); - putHints$u8_collections_hash_set_Difference_u8_hash_RandomState(rt.hashDifference(_111[0], _111[1]), 0, out); - putHints$u8_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rt.hashSymmetricDifference(_111[0], _111[1]), 0, out); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.hashUnion(_111[0], _111[1]).next()), 221, (v: rt.u8): rt.u8 => { + putSorted$u8(rs.iterToVec(rs.hashUnion(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rs.iterToVec(rs.hashIntersection(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rs.iterToVec(rs.hashDifference(_111[0], _111[1]), "next", 4), put, out); + putSorted$u8(rs.iterToVec(rs.hashSymmetricDifference(_111[0], _111[1]), "next", 4), put, out); + putHints$u8_collections_hash_set_Union_u8_hash_RandomState(rs.hashUnion(_111[0], _111[1]), 0, out); + putHints$u8_collections_hash_set_Intersection_u8_hash_RandomState(rs.hashIntersection(_111[0], _111[1]), 0, out); + putHints$u8_collections_hash_set_Difference_u8_hash_RandomState(rs.hashDifference(_111[0], _111[1]), 0, out); + putHints$u8_collections_hash_set_SymmetricDifference_u8_hash_RandomState(rs.hashSymmetricDifference(_111[0], _111[1]), 0, out); + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.hashUnion(_111[0], _111[1]).next()), 221, (v: rs.u8): rs.u8 => { let _3!: boolean; - if (!rt.hashContains(_111[0], v)) { - _3 = rt.hashContains(_111[1], v); + if (!rs.hashContains(_111[0], v)) { + _3 = rs.hashContains(_111[1], v); } else { _3 = true; } return _3 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.hashIntersection(_111[0], _111[1]).next()), 221, (v2: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.hashIntersection(_111[0], _111[1]).next()), 221, (v2: rs.u8): rs.u8 => { let _32!: boolean; - if (!rt.hashContains(_111[0], v2)) { + if (!rs.hashContains(_111[0], v2)) { _32 = false; } else { - _32 = rt.hashContains(_111[1], v2); + _32 = rs.hashContains(_111[1], v2); } return _32 ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.hashDifference(_111[0], _111[1]).next()), 221, (v3: rt.u8): rt.u8 => { - return !rt.hashContains(_111[1], v3) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.hashDifference(_111[0], _111[1]).next()), 221, (v3: rs.u8): rs.u8 => { + return !rs.hashContains(_111[1], v3) ? 1 : 0; })); - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(rt.hashSymmetricDifference(_111[0], _111[1]).next()), 221, (v4: rt.u8): rt.u8 => { - return rt.hashContains(_111[0], v4) !== rt.hashContains(_111[1], v4) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(rs.hashSymmetricDifference(_111[0], _111[1]).next()), 221, (v4: rs.u8): rs.u8 => { + return rs.hashContains(_111[0], v4) !== rs.hashContains(_111[1], v4) ? 1 : 0; })); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rt.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rt.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); - const iter4: rt.Iter> = rt.iterSlice([rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashIsSubset(_111[0], _111[1]) ? 1 : 0, rs.hashIsSuperset(_111[0], _111[1]) ? 1 : 0, rs.hashIsDisjoint(_111[0], _111[1]) ? 1 : 0)), undefined, true); + const iter4: rs.Iter> = rs.iterSlice([rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.hashUnion(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.hashIntersection(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.hashDifference(_111[0], _111[1]), undefined, undefined, 469762048), rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.hashSymmetricDifference(_111[0], _111[1]), undefined, undefined, 469762048)]); while (true) { - const _175: rt.HashSet | rt.Done = iter4.next(); - if (_175 === rt.DONE) { + const _175: rs.HashSet | rs.Done = iter4.next(); + if (_175 === rs.DONE) { break; } - putSorted$u8(rt.iterToVec(rt.hashKeys(_175), "next", 4), put, out); + putSorted$u8(rs.iterToVec(rs.hashKeys(_175), "next", 4), put, out); } } } /** How many `items` there are, then each. */ -export function putAll$Option_u8_collections_btree_set_Difference_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_collections_btree_set_Difference_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_collections_btree_set_Intersection_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_collections_btree_set_Intersection_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_collections_btree_set_Iter_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_collections_btree_set_Iter_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_collections_btree_set_Union_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_collections_btree_set_Union_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_iter_Rev_collections_btree_set_Iter_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_iter_Rev_collections_btree_set_Iter_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$Option_u8_vec_IntoIter_ref_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$Option_u8_vec_IntoIter_ref_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_collections_btree_set_Difference_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_collections_btree_set_Difference_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_collections_btree_set_Intersection_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_collections_btree_set_Intersection_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_collections_btree_set_Iter_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_collections_btree_set_Iter_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_collections_btree_set_Union_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_collections_btree_set_Union_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_iter_Rev_collections_btree_set_Iter_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_iter_Rev_collections_btree_set_Iter_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$array2_u8_vec_IntoIter_ref_array2_u8(items: rt.Iter, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$array2_u8_vec_IntoIter_ref_array2_u8(items: rs.Iter, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Iter_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Iter_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_iter_Rev_collections_btree_set_Iter_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_iter_Rev_collections_btree_set_Iter_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$cmp_Reverse_Option_u8_vec_IntoIter_ref_cmp_Reverse_Option_u8(items: rt.Iter, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$cmp_Reverse_Option_u8_vec_IntoIter_ref_cmp_Reverse_Option_u8(items: rs.Iter, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | undefined | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | undefined | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_collections_btree_set_Difference_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_collections_btree_set_Difference_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_collections_btree_set_Iter_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_collections_btree_set_Iter_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_collections_btree_set_Union_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_collections_btree_set_Union_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_iter_Rev_collections_btree_set_Iter_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_iter_Rev_collections_btree_set_Iter_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$collections_Nibble_vec_IntoIter_ref_collections_Nibble(items: rt.Iter, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$collections_Nibble_vec_IntoIter_ref_collections_Nibble(items: rs.Iter, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: Nibble.Nibble | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: Nibble.Nibble | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_collections_btree_set_Difference_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_collections_btree_set_Difference_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_collections_btree_set_Intersection_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_collections_btree_set_Intersection_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_collections_btree_set_Iter_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_collections_btree_set_Iter_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_collections_btree_set_SymmetricDifference_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_collections_btree_set_SymmetricDifference_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_collections_btree_set_Union_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_collections_btree_set_Union_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_iter_Rev_collections_btree_set_Iter_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_iter_Rev_collections_btree_set_Iter_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** How many `items` there are, then each. */ -export function putAll$u8_vec_IntoIter_ref_u8(items: rt.Iter, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - const at: rt.usize = out.length; - rt.byteVecPush(out, 0); - const iter: rt.Iter = items; +export function putAll$u8_vec_IntoIter_ref_u8(items: rs.Iter, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + const at: rs.usize = out.length; + rs.byteVecPush(out, 0); + const iter: rs.Iter = items; while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.byteVecPush(out, put(_9)); + rs.byteVecPush(out, put(_9)); } - const _15: rt.usize = rt.usizeSub(rt.usizeSub(out.length, at), 1); - out.data[rt.idx(out, at)] = _15 & 0xff; + const _15: rs.usize = rs.usizeSub(rs.usizeSub(out.length, at), 1); + out.data[rs.idx(out, at)] = _15 & 0xff; } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_btree_set_Difference_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_btree_set_Difference_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_btree_set_Intersection_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_btree_set_Intersection_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_btree_set_SymmetricDifference_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_btree_set_Union_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_btree_set_Union_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_hash_set_Difference_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_hash_set_Difference_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_hash_set_Intersection_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_hash_set_Intersection_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_hash_set_SymmetricDifference_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_hash_set_SymmetricDifference_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$Option_u8_collections_hash_set_Union_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$Option_u8_collections_hash_set_Union_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_btree_set_Difference_array2_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_btree_set_Difference_array2_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_btree_set_Intersection_array2_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_btree_set_Intersection_array2_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_btree_set_SymmetricDifference_array2_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_btree_set_Union_array2_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_btree_set_Union_array2_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_hash_set_Difference_array2_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_hash_set_Difference_array2_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_hash_set_Intersection_array2_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_hash_set_Intersection_array2_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_hash_set_SymmetricDifference_array2_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_hash_set_SymmetricDifference_array2_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$array2_u8_collections_hash_set_Union_array2_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$array2_u8_collections_hash_set_Union_array2_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Difference_cmp_Reverse_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Intersection_cmp_Reverse_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_btree_set_SymmetricDifference_cmp_Reverse_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_btree_set_Union_cmp_Reverse_Option_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Difference_cmp_Reverse_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Difference_cmp_Reverse_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Intersection_cmp_Reverse_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Intersection_cmp_Reverse_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_hash_set_SymmetricDifference_cmp_Reverse_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_hash_set_SymmetricDifference_cmp_Reverse_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Union_cmp_Reverse_Option_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$cmp_Reverse_Option_u8_collections_hash_set_Union_cmp_Reverse_Option_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_btree_set_Difference_collections_Nibble(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_btree_set_Difference_collections_Nibble(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_btree_set_Intersection_collections_Nibble(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_btree_set_SymmetricDifference_collections_Nibble(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_btree_set_Union_collections_Nibble(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_btree_set_Union_collections_Nibble(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_hash_set_Difference_collections_Nibble_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_hash_set_Difference_collections_Nibble_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_hash_set_Intersection_collections_Nibble_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_hash_set_Intersection_collections_Nibble_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_hash_set_SymmetricDifference_collections_Nibble_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_hash_set_SymmetricDifference_collections_Nibble_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$collections_Nibble_collections_hash_set_Union_collections_Nibble_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$collections_Nibble_collections_hash_set_Union_collections_Nibble_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_btree_set_Difference_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_btree_set_Difference_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_btree_set_Intersection_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_btree_set_Intersection_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_btree_set_SymmetricDifference_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_btree_set_SymmetricDifference_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_btree_set_Union_u8(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_btree_set_Union_u8(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_hash_set_Difference_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_hash_set_Difference_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_hash_set_Intersection_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_hash_set_Intersection_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_hash_set_SymmetricDifference_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_hash_set_SymmetricDifference_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** The size hint of `items`, and again after each of `read` more. */ -export function putHints$u8_collections_hash_set_Union_u8_hash_RandomState(items: rt.Iter, read: rt.usize, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, read, rt.usizeStep); +export function putHints$u8_collections_hash_set_Union_u8_hash_RandomState(items: rs.Iter, read: rs.usize, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, read, rs.usizeStep); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } if (_7 > 0) { items.next(); } - const _16: [rt.usize, rt.usize | undefined] = items.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$02k4ito(_16[1], 255, (n: rt.usize): rt.u8 => { + const _16: [rs.usize, rs.usize | undefined] = items.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_16[0] & 0xff, option_mapOr$188iunt(_16[1], 255, (n: rs.usize): rs.u8 => { return n & 0xff; }))), undefined, true); } } /** [`put_all`] of `items` in order. */ -export function putSorted$Option_u8(items: rt.Vec, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - rt.sliceSort(items.items, rt.cmpLt(rt.cmpOption(rt.cmp)), 4, true); - putAll$Option_u8_vec_IntoIter_ref_Option_u8(rt.vecIntoIter(items), put, out); +export function putSorted$Option_u8(items: rs.Vec, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + rs.sliceSort(items.items, rs.cmpLt(rs.cmpOption(rs.cmp)), 4, true); + putAll$Option_u8_vec_IntoIter_ref_Option_u8(rs.vecIntoIter(items), put, out); } /** [`put_all`] of `items` in order. */ -export function putSorted$array2_u8(items: rt.Vec, put: (a0: rt.ByteSlice) => rt.u8, out: rt.ByteVec): void { - rt.sliceSort(items.items, rt.cmpLt(rt.cmpBytes), 4, true); - putAll$array2_u8_vec_IntoIter_ref_array2_u8(rt.vecIntoIter(items), put, out); +export function putSorted$array2_u8(items: rs.Vec, put: (a0: rs.ByteSlice) => rs.u8, out: rs.ByteVec): void { + rs.sliceSort(items.items, rs.cmpLt(rs.cmpBytes), 4, true); + putAll$array2_u8_vec_IntoIter_ref_array2_u8(rs.vecIntoIter(items), put, out); } /** [`put_all`] of `items` in order. */ -export function putSorted$cmp_Reverse_Option_u8(items: rt.Vec, put: (a0: rt.u8 | undefined) => rt.u8, out: rt.ByteVec): void { - rt.sliceSort(items.items, rt.cmpLt(rt.cmpReverse(rt.cmpOption(rt.cmp))), 4, true); - putAll$cmp_Reverse_Option_u8_vec_IntoIter_ref_cmp_Reverse_Option_u8(rt.vecIntoIter(items), put, out); +export function putSorted$cmp_Reverse_Option_u8(items: rs.Vec, put: (a0: rs.u8 | undefined) => rs.u8, out: rs.ByteVec): void { + rs.sliceSort(items.items, rs.cmpLt(rs.cmpReverse(rs.cmpOption(rs.cmp))), 4, true); + putAll$cmp_Reverse_Option_u8_vec_IntoIter_ref_cmp_Reverse_Option_u8(rs.vecIntoIter(items), put, out); } /** [`put_all`] of `items` in order. */ -export function putSorted$collections_Nibble(items: rt.Vec, put: (a0: Nibble.Nibble) => rt.u8, out: rt.ByteVec): void { - rt.sliceSort(items.items, rt.cmpLt(Nibble.partialCmp$cmp_PartialOrd), 4, true); - putAll$collections_Nibble_vec_IntoIter_ref_collections_Nibble(rt.vecIntoIter(items), put, out); +export function putSorted$collections_Nibble(items: rs.Vec, put: (a0: Nibble.Nibble) => rs.u8, out: rs.ByteVec): void { + rs.sliceSort(items.items, rs.cmpLt(Nibble.partialCmp$cmp_PartialOrd), 4, true); + putAll$collections_Nibble_vec_IntoIter_ref_collections_Nibble(rs.vecIntoIter(items), put, out); } /** [`put_all`] of `items` in order. */ -export function putSorted$u8(items: rt.Vec, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - rt.sliceSort(items.items, rt.lt, 4, true); - putAll$u8_vec_IntoIter_ref_u8(rt.vecIntoIter(items), put, out); +export function putSorted$u8(items: rs.Vec, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + rs.sliceSort(items.items, rs.lt, 4, true); + putAll$u8_vec_IntoIter_ref_u8(rs.vecIntoIter(items), put, out); } -export function eq$cmp_PartialEq_collections_Right_u8(self: rt.u8, other: Right.Right): boolean { - return rt.u16Rem(self as rt.u16, 4) === rt.u16Rem(other._0, 4); +export function eq$cmp_PartialEq_collections_Right_u8(self: rs.u8, other: Right.Right): boolean { + return rs.u16Rem(self as rs.u16, 4) === rs.u16Rem(other._0, 4); } export function eq$cmp_PartialEq_collections_Right_array2_u8(selfData: Uint8Array, selfStart: number, _selfLen: number, other: Right.Right): boolean { - return rt.u16Rem(rt.u16Add(selfData[selfStart] as rt.u16, selfData[selfStart + 1] as rt.u16), 4) === rt.u16Rem(other._0, 4); + return rs.u16Rem(rs.u16Add(selfData[selfStart] as rs.u16, selfData[selfStart + 1] as rs.u16), 4) === rs.u16Rem(other._0, 4); } -export function partialCmp$cmp_PartialOrd_collections_Right_array2_u8(selfData: Uint8Array, selfStart: number, _selfLen: number, other: Right.Right): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(rt.u16Add(selfData[selfStart] as rt.u16, selfData[selfStart + 1] as rt.u16), 4), rt.u16Rem(other._0, 4)); +export function partialCmp$cmp_PartialOrd_collections_Right_array2_u8(selfData: Uint8Array, selfStart: number, _selfLen: number, other: Right.Right): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(rs.u16Add(selfData[selfStart] as rs.u16, selfData[selfStart + 1] as rs.u16), 4), rs.u16Rem(other._0, 4)); } /** * A `Right` against each of `data`, with the same remainders by 3 and 4 but at the * positions `kind` picks, where only `ne`'s or only `eq`'s is, and one fewer for bit 6. */ -export function rights(kind: rt.u8, data: rt.ByteSlice): rt.Vec { - const _5: [rt.usize, rt.usize] = [(kind & 7) as rt.usize, ((kind >> 3) & 7) as rt.usize]; - const byNe: rt.usize = _5[0]; - const byEq: rt.usize = _5[1]; - const step: (a0: rt.usize) => rt.u16 = (i: rt.usize): rt.u16 => { +export function rights(kind: rs.u8, data: rs.ByteSlice): rs.Vec { + const _5: [rs.usize, rs.usize] = [(kind & 7) as rs.usize, ((kind >> 3) & 7) as rs.usize]; + const byNe: rs.usize = _5[0]; + const byEq: rs.usize = _5[1]; + const step: (a0: rs.usize) => rs.u16 = (i: rs.usize): rs.u16 => { if (!(i === byEq)) { if (!(i === byNe)) { return 12; @@ -3649,20 +3649,20 @@ export function rights(kind: rt.u8, data: rt.ByteSlice): rt.Vec { } return 3; }; - const rights: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): Right.Right => { - return { _0: rt.u16Add(_2[1] as rt.u16, step(_2[0])) }; + const rights: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): Right.Right => { + return { _0: rs.u16Add(_2[1] as rs.u16, step(_2[0])) }; }), undefined, 2, true); if ((kind & 64) !== 0) { - rt.vecPop(rights); + rs.vecPop(rights); return rights; } return rights; } /** Whether a comparison found its sides equal, then the log of the calls it made. */ -export function putEq(eq: boolean, log: rt.Cell, out: rt.ByteVec): void { - rt.byteVecPush(out, eq ? 1 : 0); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.cellReplace(log, 0)).reverse()), undefined, true); +export function putEq(eq: boolean, log: rs.Cell, out: rs.ByteVec): void { + rs.byteVecPush(out, eq ? 1 : 0); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log, 0)).reverse()), undefined, true); } /** @@ -3671,328 +3671,328 @@ export function putEq(eq: boolean, log: rt.Cell, out: rt.ByteVec): void * `ne` disagree on at the positions `kind` picks, and a deque wrapped around its buffer. * Then `next_if_eq` of such sequences, matching and missing. */ -export function unlikeEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Cell = new rt.Cell(0); - const lefts: () => rt.Vec = (): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): Left.Left => { - return { _0: _23 as rt.u16, _1: log }; +export function unlikeEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Cell = new rs.Cell(0); + const lefts: () => rs.Vec = (): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): Left.Left => { + return { _0: _23 as rs.u16, _1: log }; }), undefined, 8, true); }; - const rights_: rt.Vec = rights(kind, data); - const byEq: rt.usize = ((kind >> 3) & 7) as rt.usize; - const at: (a0: rt.usize) => rt.u16 = (i: rt.usize): rt.u16 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.u16; + const rights_: rs.Vec = rights(kind, data); + const byEq: rs.usize = ((kind >> 3) & 7) as rs.usize; + const at: (a0: rs.usize) => rs.u16 = (i: rs.usize): rs.u16 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0) as rs.u16; }; const pair: () => Right.Right[] = (): Right.Right[] => { - return [{ _0: rt.u16Add(at(0), 12) }, { _0: rt.u16Add(at(1), 12) }]; + return [{ _0: rs.u16Add(at(0), 12) }, { _0: rs.u16Add(at(1), 12) }]; }; - const mine: rt.Vec = lefts(); + const mine: rs.Vec = lefts(); const _22: Right.Right[] = rights_.items; - putEq(rt.eqSeq((a: Left.Left, b6: Right.Right): boolean => { + putEq(rs.eqSeq((a: Left.Left, b6: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a, b6); })(mine, _22), log, out); - putEq(!rt.eqSeq((a2: Left.Left, b7: Right.Right): boolean => { + putEq(!rs.eqSeq((a2: Left.Left, b7: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a2, b7); })(mine, rights_), log, out); - const _32: Left.Left[] = rt.sliceRange(mine.items, 0); - const _34: Right.Right[] = rt.sliceRange(rights_.items, 0); - putEq(rt.eqSeq((a3: Left.Left, b8: Right.Right): boolean => { + const _32: Left.Left[] = rs.sliceRange(mine.items, 0); + const _34: Right.Right[] = rs.sliceRange(rights_.items, 0); + putEq(rs.eqSeq((a3: Left.Left, b8: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a3, b8); })(_32, _34), log, out); - putEq(rt.eqSeq(Right.eq$cmp_PartialEq_collections_Left)(rights_, mine), log, out); + putEq(rs.eqSeq(Right.eq$cmp_PartialEq_collections_Left)(rights_, mine), log, out); const _46: Left.Left[] = mine.items; - putEq(rt.eqSeq((a4: Left.Left, b9: Right.Right): boolean => { + putEq(rs.eqSeq((a4: Left.Left, b9: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a4, b9); })(_46, rights_), log, out); const _54: Right.Right[] = pair(); - putEq(rt.eqSeq((a5: Left.Left, b10: Right.Right): boolean => { + putEq(rs.eqSeq((a5: Left.Left, b10: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a5, b10); })(mine, _54), log, out); const _62: Right.Right[] = pair(); - putEq(rt.eqSeq((a6: Left.Left, b11: Right.Right): boolean => { + putEq(rs.eqSeq((a6: Left.Left, b11: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a6, b11); })(mine, _62), log, out); const _68: Left.Left[] = mine.items; const _71: Right.Right[] = pair(); - putEq(rt.eqSeq((a7: Left.Left, b12: Right.Right): boolean => { + putEq(rs.eqSeq((a7: Left.Left, b12: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a7, b12); })(_68, _71), log, out); const two: Left.Left[] = [{ _0: at(0), _1: log }, { _0: at(1), _1: log }]; const _89: Right.Right[] = pair(); - putEq(rt.eqSeq((a8: Left.Left, b13: Right.Right): boolean => { + putEq(rs.eqSeq((a8: Left.Left, b13: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a8, b13); })(two, _89), log, out); const _96: Right.Right[] = pair(); - putEq(!rt.eqSeq((a9: Left.Left, b14: Right.Right): boolean => { + putEq(!rs.eqSeq((a9: Left.Left, b14: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a9, b14); })(two, _96), log, out); - const _102: Right.Right[] = rt.sliceRange(rights_.items, 0); - putEq(rt.eqSeq((a10: Left.Left, b15: Right.Right): boolean => { + const _102: Right.Right[] = rs.sliceRange(rights_.items, 0); + putEq(rs.eqSeq((a10: Left.Left, b15: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a10, b15); })(two, _102), log, out); const _109: Right.Right[] = rights_.items; - putEq(rt.eqSeq((a11: Left.Left, b16: Right.Right): boolean => { + putEq(rs.eqSeq((a11: Left.Left, b16: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a11, b16); })(two, _109), log, out); - const _115: rt.Vec = new rt.Vec(); - const _117: rt.Vec = new rt.Vec(); - putEq(rt.eqSeq((a12: Left.Left, b17: Right.Right): boolean => { + const _115: rs.Vec = new rs.Vec(); + const _117: rs.Vec = new rs.Vec(); + putEq(rs.eqSeq((a12: Left.Left, b17: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a12, b17); })(_115, _117), log, out); - const _122: rt.Vec = new rt.Vec(); - putEq(rt.eqSeq((a13: Left.Left, b18: Right.Right): boolean => { + const _122: rs.Vec = new rs.Vec(); + putEq(rs.eqSeq((a13: Left.Left, b18: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a13, b18); })(_122, rights_), log, out); const _128: Right.Right[] = []; - putEq(rt.eqSeq((a14: Left.Left, b19: Right.Right): boolean => { + putEq(rs.eqSeq((a14: Left.Left, b19: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a14, b19); })(mine, _128), log, out); - const _133: rt.ByteVec = rt.byteSliceToByteVec(data); - putEq(rt.eqSeq(eq$cmp_PartialEq_collections_Right_u8)(_133, rights_), log, out); + const _133: rs.ByteVec = rs.byteSliceToByteVec(data); + putEq(rs.eqSeq(eq$cmp_PartialEq_collections_Right_u8)(_133, rights_), log, out); const _140: Right.Right[] = rights_.items; - putEq(rt.eqSeq(eq$cmp_PartialEq_collections_Right_u8)(data, _140), log, out); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _36: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + putEq(rs.eqSeq(eq$cmp_PartialEq_collections_Right_u8)(data, _140), log, out); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _36: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_36, c.data[c.start + 1]); }), undefined, 2, true); - const _148: Uint8Array[] = rt.sliceRange(pairs.items, 0); - const _150: Right.Right[] = rt.sliceRange(rights_.items, 0, rt.min(pairs.items.length, rights_.items.length)); - putEq(rt.eqSeq((a15: Uint8Array, b20: Right.Right): boolean => { - return ((a0: rt.ByteSlice, a1: Right.Right): boolean => { + const _148: Uint8Array[] = rs.sliceRange(pairs.items, 0); + const _150: Right.Right[] = rs.sliceRange(rights_.items, 0, rs.min(pairs.items.length, rights_.items.length)); + putEq(rs.eqSeq((a15: Uint8Array, b20: Right.Right): boolean => { + return ((a0: rs.ByteSlice, a1: Right.Right): boolean => { return eq$cmp_PartialEq_collections_Right_array2_u8(a0.data, a0.start, a0.length, a1); - })(rt.byteSliceFrom(a15), b20); + })(rs.byteSliceFrom(a15), b20); })(_148, _150), log, out); - const _162: rt.Vec> = rt.vecFrom([lefts(), lefts()]); - const _169: Right.Right[][] = [rights_.items, rt.sliceRange(rights_.items, 0)]; - putEq(rt.eqSeq(rt.eqSeq((a16: Left.Left, b21: Right.Right): boolean => { + const _162: rs.Vec> = rs.vecFrom([lefts(), lefts()]); + const _169: Right.Right[][] = [rights_.items, rs.sliceRange(rights_.items, 0)]; + putEq(rs.eqSeq(rs.eqSeq((a16: Left.Left, b21: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a16, b21); }))(_162, _169), log, out); - const refs: rt.Vec = rt.iterToVec(rt.iterSlice(rights_.items), undefined, 4, true); - putEq(rt.eqSeq(Left.eq$cmp_PartialEq_ref_collections_Right)(mine, refs), log, out); - const _187: rt.Vec = rt.iterToVec(rt.iterSlice(mine.items), undefined, 4, true); - putEq(rt.eqSeq((a17: Left.Left, b22: Right.Right): boolean => { + const refs: rs.Vec = rs.iterToVec(rs.iterSlice(rights_.items), undefined, 4, true); + putEq(rs.eqSeq(Left.eq$cmp_PartialEq_ref_collections_Right)(mine, refs), log, out); + const _187: rs.Vec = rs.iterToVec(rs.iterSlice(mine.items), undefined, 4, true); + putEq(rs.eqSeq((a17: Left.Left, b22: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a17, b22); })(_187, refs), log, out); - const _199: rt.Vec = rt.iterToVec(rt.iterSlice(lefts().items), undefined, 4, true); - putEq(rt.eqSeq(Left.eq$cmp_PartialEq_ref_collections_Left)(mine, _199), log, out); - const _210: rt.Vec = rt.iterToVec(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Odd.Odd => { - return { _0: _25 as rt.u16 }; + const _199: rs.Vec = rs.iterToVec(rs.iterSlice(lefts().items), undefined, 4, true); + putEq(rs.eqSeq(Left.eq$cmp_PartialEq_ref_collections_Left)(mine, _199), log, out); + const _210: rs.Vec = rs.iterToVec(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): Odd.Odd => { + return { _0: _25 as rs.u16 }; }), undefined, 2, true).items), undefined, 4, true); - putEq(rt.eqSeq(Odd.eq$cmp_PartialEq_ref_collections_Right_ref)(_210, refs), log, out); - const half: rt.usize = rt.usizeDiv(data.length, 2); - const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; - const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); + putEq(rs.eqSeq(Odd.eq$cmp_PartialEq_ref_collections_Right_ref)(_210, refs), log, out); + const half: rs.usize = rs.usizeDiv(data.length, 2); + const q: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; + const iter: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, half)))); while (true) { - const _226: rt.u8 | rt.Done = iter.next(); - if (_226 === rt.DONE) { + const _226: rs.u8 | rs.Done = iter.next(); + if (_226 === rs.DONE) { break; } - const _232: Left.Left = { _0: _226 as rt.u16, _1: log }; - rt.dequePushFront(q, _232); + const _232: Left.Left = { _0: _226 as rs.u16, _1: log }; + rs.dequePushFront(q, _232); } - for (const _239 of rt.byteSliceView(rt.byteSliceRange(data, half))) { - const _245: Left.Left = { _0: _239 as rt.u16, _1: log }; - rt.dequePushBack(q, _245); + for (const _239 of rs.byteSliceView(rs.byteSliceRange(data, half))) { + const _245: Left.Left = { _0: _239 as rs.u16, _1: log }; + rs.dequePushBack(q, _245); } const _252: Right.Right[] = rights_.items; - putEq(rt.eqSeq((a18: Left.Left, b24: Right.Right): boolean => { + putEq(rs.eqSeq((a18: Left.Left, b24: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a18, b24); })(q, _252), log, out); - putEq(rt.eqSeq((a19: Left.Left, b25: Right.Right): boolean => { + putEq(rs.eqSeq((a19: Left.Left, b25: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a19, b25); })(q, rights_), log, out); const _264: Right.Right[] = rights_.items; - putEq(!rt.eqSeq((a20: Left.Left, b26: Right.Right): boolean => { + putEq(!rs.eqSeq((a20: Left.Left, b26: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a20, b26); })(q, _264), log, out); const _272: Right.Right[] = rights_.items; - putEq(rt.eqSeq((a21: Left.Left, b27: Right.Right): boolean => { + putEq(rs.eqSeq((a21: Left.Left, b27: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a21, b27); })(q, _272), log, out); const _279: Right.Right[] = pair(); - putEq(rt.eqSeq((a22: Left.Left, b28: Right.Right): boolean => { + putEq(rs.eqSeq((a22: Left.Left, b28: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a22, b28); })(q, _279), log, out); const _287: Right.Right[] = pair(); - putEq(rt.eqSeq((a23: Left.Left, b29: Right.Right): boolean => { + putEq(rs.eqSeq((a23: Left.Left, b29: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a23, b29); })(q, _287), log, out); const _295: Right.Right[] = pair(); - putEq(rt.eqSeq((a24: Left.Left, b30: Right.Right): boolean => { + putEq(rs.eqSeq((a24: Left.Left, b30: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a24, b30); })(q, _295), log, out); - const bytes: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; - const iter3: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, half)))); + const bytes: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; + const iter3: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, half)))); while (true) { - const _305: rt.u8 | rt.Done = iter3.next(); - if (_305 === rt.DONE) { + const _305: rs.u8 | rs.Done = iter3.next(); + if (_305 === rs.DONE) { break; } - rt.dequePushFront(bytes, _305); + rs.dequePushFront(bytes, _305); } - const _313: rt.ByteSlice = rt.byteSliceRange(data, half); - rt.dequeExtend(bytes, rt.iterSlice(rt.byteSliceView(_313)), undefined, true); - const stepped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_27: [rt.usize, rt.u8]): rt.u8 => { + const _313: rs.ByteSlice = rs.byteSliceRange(data, half); + rs.dequeExtend(bytes, rs.iterSlice(rs.byteSliceView(_313)), undefined, true); + const stepped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_27: [rs.usize, rs.u8]): rs.u8 => { return _27[1] ^ (_27[0] === byEq ? 1 : 0); }), undefined, true); - putEq(rt.eqSeq(rt.same)(bytes, stepped), log, out); - putEq(rt.eqSeq(rt.same)(bytes, data), log, out); - const _334: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 0)); - putEq(rt.eqSeq(rt.same)(bytes, _334), log, out); - const wide: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.dequeIter(bytes), (_28: rt.u8): rt.u16 => { - return _28 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; - const wrapped: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - const iter4: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(stepped)))); + putEq(rs.eqSeq(rs.same)(bytes, stepped), log, out); + putEq(rs.eqSeq(rs.same)(bytes, data), log, out); + const _334: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 0)); + putEq(rs.eqSeq(rs.same)(bytes, _334), log, out); + const wide: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(bytes), (_28: rs.u8): rs.u16 => { + return _28 as rs.u16; + }), undefined, 2, true), 2) as rs.VecDeque; + const wrapped: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + const iter4: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(stepped)))); while (true) { - const _351: rt.u8 | rt.Done = iter4.next(); - if (_351 === rt.DONE) { + const _351: rs.u8 | rs.Done = iter4.next(); + if (_351 === rs.DONE) { break; } - rt.dequePushFront(wrapped, _351 as rt.u16); + rs.dequePushFront(wrapped, _351 as rs.u16); } - putEq(rt.eqSeq(rt.same)(wide, wrapped), log, out); - const _366: rt.Vec> = rt.vecFrom([rt.dequeClone(wide)]); - const _371: rt.VecDeque[] = [wrapped]; - putEq(rt.eqSlice(rt.eqSeq(rt.same))(_366, _371), log, out); - const it: rt.Peekable> = rt.iterPeekable(rt.vecIntoIter(rt.vecFrom([lefts(), lefts(), lefts()]))); - const exact: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Right.Right => { - return { _0: _29 as rt.u16 }; + putEq(rs.eqSeq(rs.same)(wide, wrapped), log, out); + const _366: rs.Vec> = rs.vecFrom([rs.dequeClone(wide)]); + const _371: rs.VecDeque[] = [wrapped]; + putEq(rs.eqSlice(rs.eqSeq(rs.same))(_366, _371), log, out); + const it: rs.Peekable> = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom([lefts(), lefts(), lefts()]))); + const exact: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Right.Right => { + return { _0: _29 as rs.u16 }; }), undefined, 2, true); - putEq(rt.peekableNextIfEq(it, exact.items, (a02: rt.Vec, a110: Right.Right[]): boolean => { - return rt.eqSeq((a25: Left.Left, b34: Right.Right): boolean => { + putEq(rs.peekableNextIfEq(it, exact.items, (a02: rs.Vec, a110: Right.Right[]): boolean => { + return rs.eqSeq((a25: Left.Left, b34: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a25, b34); })(a02, a110); }) !== undefined, log, out); - putEq(rt.peekableNextIfEq(it, rights_.items, (a03: rt.Vec, a111: Right.Right[]): boolean => { - return rt.eqSeq((a26: Left.Left, b35: Right.Right): boolean => { + putEq(rs.peekableNextIfEq(it, rights_.items, (a03: rs.Vec, a111: Right.Right[]): boolean => { + return rs.eqSeq((a26: Left.Left, b35: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a26, b35); })(a03, a111); }) !== undefined, log, out); - const _409: Right.Right[] = rt.sliceRange(exact.items, 0, half); - putEq(rt.peekableNextIfEq(it, _409, (a04: rt.Vec, a112: Right.Right[]): boolean => { - return rt.eqSeq((a27: Left.Left, b36: Right.Right): boolean => { + const _409: Right.Right[] = rs.sliceRange(exact.items, 0, half); + putEq(rs.peekableNextIfEq(it, _409, (a04: rs.Vec, a112: Right.Right[]): boolean => { + return rs.eqSeq((a27: Left.Left, b36: Right.Right): boolean => { return !Left.ne$cmp_PartialEq_collections_Right(a27, b36); })(a04, a112); }) !== undefined, log, out); - rt.byteVecPush(out, rt.iterCount(it) & 0xff); - const it2: rt.Peekable> = rt.iterPeekable(rt.vecIntoIter(rt.vecFrom([rt.dequeClone(bytes), bytes]))); - const _430: rt.ByteVec = rt.byteSliceToByteVec(data); - putEq(rt.peekableNextIfEq(it2, _430, (a05: rt.VecDeque, a113: rt.ByteVec): boolean => { - return rt.eqSeq(rt.same)(a05, a113); + rs.byteVecPush(out, rs.iterCount(it) & 0xff); + const it2: rs.Peekable> = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom([rs.dequeClone(bytes), bytes]))); + const _430: rs.ByteVec = rs.byteSliceToByteVec(data); + putEq(rs.peekableNextIfEq(it2, _430, (a05: rs.VecDeque, a113: rs.ByteVec): boolean => { + return rs.eqSeq(rs.same)(a05, a113); }) !== undefined, log, out); - putEq(rt.peekableNextIfEq(it2, stepped, (a06: rt.VecDeque, a114: rt.ByteVec): boolean => { - return rt.eqSeq(rt.same)(a06, a114); + putEq(rs.peekableNextIfEq(it2, stepped, (a06: rs.VecDeque, a114: rs.ByteVec): boolean => { + return rs.eqSeq(rs.same)(a06, a114); }) !== undefined, log, out); - rt.byteVecPush(out, rt.iterCount(it2) & 0xff); + rs.byteVecPush(out, rs.iterCount(it2) & 0xff); } /** * `v` in a deque wrapped around its buffer: the first half pushed to the front backwards, * the rest to the back. */ -export function wrapped$collections_Picky(v: Picky.Picky[]): rt.VecDeque { - const half: rt.usize = rt.usizeDiv(v.length, 2); - const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; - const iter: rt.Iter = rt.iterRev(rt.iterSlice(rt.sliceRange(v, 0, half))); +export function wrapped$collections_Picky(v: Picky.Picky[]): rs.VecDeque { + const half: rs.usize = rs.usizeDiv(v.length, 2); + const q: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; + const iter: rs.Iter = rs.iterRev(rs.iterSlice(rs.sliceRange(v, 0, half))); while (true) { - const _12: Picky.Picky | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: Picky.Picky | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } const _18: Picky.Picky = Picky.clone$Clone(_12); - rt.dequePushFront(q, _18); + rs.dequePushFront(q, _18); } - const _21: rt.Iter = rt.iterMap(rt.iterSlice(rt.sliceRange(v, half)), Picky.clone$Clone); - rt.dequeExtend(q, _21, undefined, true); + const _21: rs.Iter = rs.iterMap(rs.iterSlice(rs.sliceRange(v, half)), Picky.clone$Clone); + rs.dequeExtend(q, _21, undefined, true); return q; } /** `f` of each of `v`. */ -export function each$collections_Picky_Option_collections_Picky_collections_own_nes_closure10(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky | undefined): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Picky_Option_collections_Picky_collections_own_nes_closure10(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky | undefined): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_Option_collections_Picky_collections_own_nes_closure11(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky | undefined): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Picky_Option_collections_Picky_collections_own_nes_closure11(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky | undefined): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_borrow_Cow_slice_collections_Picky_collections_own_nes_closure18(v: Picky.Picky[], f: (a0: Picky.Picky) => rt.Cow): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Picky_borrow_Cow_slice_collections_Picky_collections_own_nes_closure18(v: Picky.Picky[], f: (a0: Picky.Picky) => rs.Cow): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure14(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 4, true); +export function each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure14(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 4, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure15(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 4, true); +export function each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure15(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 4, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure12(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure12(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure13(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure13(v: Picky.Picky[], f: (a0: Picky.Picky) => Picky.Picky): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure16(v: Picky.Picky[], f: (a0: Picky.Picky) => rt.Arc): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 4, true); +export function each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure16(v: Picky.Picky[], f: (a0: Picky.Picky) => rs.Arc): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 4, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure17(v: Picky.Picky[], f: (a0: Picky.Picky) => rt.Arc): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 4, true); +export function each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure17(v: Picky.Picky[], f: (a0: Picky.Picky) => rs.Arc): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 4, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure6(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rt.u8]): rt.Vec<[Picky.Picky, rt.u8]> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure6(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rs.u8]): rs.Vec<[Picky.Picky, rs.u8]> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure7(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rt.u8]): rt.Vec<[Picky.Picky, rt.u8]> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure7(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rs.u8]): rs.Vec<[Picky.Picky, rs.u8]> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure8(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rt.u8]): rt.Vec<[Picky.Picky, rt.u8]> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure8(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rs.u8]): rs.Vec<[Picky.Picky, rs.u8]> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure9(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rt.u8]): rt.Vec<[Picky.Picky, rt.u8]> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure9(v: Picky.Picky[], f: (a0: Picky.Picky) => [Picky.Picky, rs.u8]): rs.Vec<[Picky.Picky, rs.u8]> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure2(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rt.Cell): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure2(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rs.Cell): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure3(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rt.Cell): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 8, true); +export function each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure3(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rs.Cell): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 8, true); } /** `f` of each of `v`. */ -export function each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure4(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rt.RefCell): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure4(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rs.RefCell): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** `f` of each of `v`. */ -export function each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure5(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rt.RefCell): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v), f), undefined, 12, true); +export function each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure5(v: Quirky.Quirky[], f: (a0: Quirky.Quirky) => rs.RefCell): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v), f), undefined, 12, true); } /** @@ -4002,17 +4002,17 @@ export function each$collections_Quirky_cell_RefCell_collections_Quirky_collecti * lengths, empty, nested, and with items `eq` and `ne` disagree on at the positions * `kind` picks. */ -export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _34: (a0: Picky.Picky[], a1: rt.usize) => rt.u16 = (v: Picky.Picky[], i: rt.usize): rt.u16 => { - return option_mapOr$0bnr5nu(rt.sliceGet(v, i), 0, (p: Picky.Picky): rt.u16 => { +export function ownNes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _34: (a0: Picky.Picky[], a1: rs.usize) => rs.u16 = (v: Picky.Picky[], i: rs.usize): rs.u16 => { + return option_mapOr$0pgapuk(rs.sliceGet(v, i), 0, (p: Picky.Picky): rs.u16 => { return p._0; }); }; - const log: rt.Cell = new rt.Cell(0); - const _7: [rt.usize, rt.usize] = [(kind & 7) as rt.usize, ((kind >> 3) & 7) as rt.usize]; - const byNe: rt.usize = _7[0]; - const byEq: rt.usize = _7[1]; - const step: (a0: rt.usize) => rt.u16 = (i2: rt.usize): rt.u16 => { + const log: rs.Cell = new rs.Cell(0); + const _7: [rs.usize, rs.usize] = [(kind & 7) as rs.usize, ((kind >> 3) & 7) as rs.usize]; + const byNe: rs.usize = _7[0]; + const byEq: rs.usize = _7[1]; + const step: (a0: rs.usize) => rs.u16 = (i2: rs.usize): rs.u16 => { if (!(i2 === byEq)) { if (!(i2 === byNe)) { return 12; @@ -4021,275 +4021,275 @@ export function ownNes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } return 3; }; - const a: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Picky.Picky => { - return { _0: _2 as rt.u16, _1: log }; + const a: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Picky.Picky => { + return { _0: _2 as rs.u16, _1: log }; }), undefined, 8, true); - const b: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_22: [rt.usize, rt.u8]): Picky.Picky => { - return { _0: rt.u16Add(_22[1] as rt.u16, step(_22[0])), _1: log }; + const b: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_22: [rs.usize, rs.u8]): Picky.Picky => { + return { _0: rs.u16Add(_22[1] as rs.u16, step(_22[0])), _1: log }; }), undefined, 8, true); if ((kind & 64) !== 0) { - rt.vecPop(b); + rs.vecPop(b); } - const one: (a0: Picky.Picky[], a1: rt.usize) => Picky.Picky = (v2: Picky.Picky[], i4: rt.usize): Picky.Picky => { + const one: (a0: Picky.Picky[], a1: rs.usize) => Picky.Picky = (v2: Picky.Picky[], i4: rs.usize): Picky.Picky => { return { _0: _34(v2, i4), _1: log }; }; - putEq(rt.eqSlice((a2: Picky.Picky, b2: Picky.Picky): boolean => { + putEq(rs.eqSlice((a2: Picky.Picky, b2: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a2, b2); })(a, b), log, out); - putEq(!rt.eqSlice((a3: Picky.Picky, b3: Picky.Picky): boolean => { + putEq(!rs.eqSlice((a3: Picky.Picky, b3: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a3, b3); })(a, b), log, out); - const _50: Picky.Picky[] = rt.sliceRange(a.items, 0); - const _52: Picky.Picky[] = rt.sliceRange(b.items, 0); - putEq(rt.eqSlice((a4: Picky.Picky, b4: Picky.Picky): boolean => { + const _50: Picky.Picky[] = rs.sliceRange(a.items, 0); + const _52: Picky.Picky[] = rs.sliceRange(b.items, 0); + putEq(rs.eqSlice((a4: Picky.Picky, b4: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a4, b4); })(_50, _52), log, out); - const _59: Picky.Picky[] = rt.sliceRange(a.items, 0); - const _63: Picky.Picky[] = rt.sliceRange(b.items, 0); - putEq(!rt.eqSlice((a5: Picky.Picky, b5: Picky.Picky): boolean => { + const _59: Picky.Picky[] = rs.sliceRange(a.items, 0); + const _63: Picky.Picky[] = rs.sliceRange(b.items, 0); + putEq(!rs.eqSlice((a5: Picky.Picky, b5: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a5, b5); })(_59, _63), log, out); - const _69: rt.Vec = new rt.Vec(); - const _71: rt.Vec = new rt.Vec(); - putEq(rt.eqSlice((a6: Picky.Picky, b6: Picky.Picky): boolean => { + const _69: rs.Vec = new rs.Vec(); + const _71: rs.Vec = new rs.Vec(); + putEq(rs.eqSlice((a6: Picky.Picky, b6: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a6, b6); })(_69, _71), log, out); - const _76: rt.Vec = new rt.Vec(); - putEq(!rt.eqSlice((a7: Picky.Picky, b7: Picky.Picky): boolean => { + const _76: rs.Vec = new rs.Vec(); + putEq(!rs.eqSlice((a7: Picky.Picky, b7: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a7, b7); })(_76, b), log, out); const _81: [Picky.Picky[], Picky.Picky[]] = [[one(a.items, 0), one(a.items, 1)], [one(b.items, 0), one(b.items, 1)]]; const pa: Picky.Picky[] = _81[0]; const pb: Picky.Picky[] = _81[1]; - putEq(rt.eqSlice((a8: Picky.Picky, b8: Picky.Picky): boolean => { + putEq(rs.eqSlice((a8: Picky.Picky, b8: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a8, b8); })(pa, pb), log, out); - putEq(!rt.eqSlice((a9: Picky.Picky, b9: Picky.Picky): boolean => { + putEq(!rs.eqSlice((a9: Picky.Picky, b9: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a9, b9); })(pa, pb), log, out); - const _117: Picky.Picky[] = rt.sliceRange(b.items, 0); - putEq(rt.eqSlice((a10: Picky.Picky, b10: Picky.Picky): boolean => { + const _117: Picky.Picky[] = rs.sliceRange(b.items, 0); + putEq(rs.eqSlice((a10: Picky.Picky, b10: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a10, b10); })(pa, _117), log, out); - const _123: rt.Vec> = rt.vecFrom([rt.vecFrom(a.items.map(Picky.clone$Clone)), rt.vecFrom(a.items.map(Picky.clone$Clone))]); - const _130: rt.Vec[] = [rt.vecFrom(a.items.map(Picky.clone$Clone)), rt.vecFrom(b.items.map(Picky.clone$Clone))]; - putEq(rt.eqSlice(rt.eqSlice((a11: Picky.Picky, b11: Picky.Picky): boolean => { + const _123: rs.Vec> = rs.vecFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(a.items.map(Picky.clone$Clone))]); + const _130: rs.Vec[] = [rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(b.items.map(Picky.clone$Clone))]; + putEq(rs.eqSlice(rs.eqSlice((a11: Picky.Picky, b11: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a11, b11); }))(_123, _130), log, out); - const _139: rt.Vec> = rt.vecFrom([rt.vecFrom(a.items.map(Picky.clone$Clone)), rt.vecFrom(b.items.map(Picky.clone$Clone))]); - const _146: rt.Vec[] = [rt.vecFrom(a.items.map(Picky.clone$Clone)), rt.vecFrom(a.items.map(Picky.clone$Clone))]; - putEq(!rt.eqSlice(rt.eqSlice((a12: Picky.Picky, b12: Picky.Picky): boolean => { + const _139: rs.Vec> = rs.vecFrom([rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(b.items.map(Picky.clone$Clone))]); + const _146: rs.Vec[] = [rs.vecFrom(a.items.map(Picky.clone$Clone)), rs.vecFrom(a.items.map(Picky.clone$Clone))]; + putEq(!rs.eqSlice(rs.eqSlice((a12: Picky.Picky, b12: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a12, b12); }))(_139, _146), log, out); - const tuple: (a0: Picky.Picky[]) => [Picky.Picky, rt.u8, Picky.Picky] = (v3: Picky.Picky[]): [Picky.Picky, rt.u8, Picky.Picky] => { - return [one(v3, 0), _34(v3, 2) & 0xff, one(v3, 1)] as [Picky.Picky, rt.u8, Picky.Picky]; + const tuple: (a0: Picky.Picky[]) => [Picky.Picky, rs.u8, Picky.Picky] = (v3: Picky.Picky[]): [Picky.Picky, rs.u8, Picky.Picky] => { + return [one(v3, 0), _34(v3, 2) & 0xff, one(v3, 1)] as [Picky.Picky, rs.u8, Picky.Picky]; }; - const _158: [Picky.Picky, rt.u8, Picky.Picky] = tuple(a.items); - const _164: [Picky.Picky, rt.u8, Picky.Picky] = tuple(b.items); - putEq(!rt.eqTuple([(a13: Picky.Picky, b13: Picky.Picky): boolean => { + const _158: [Picky.Picky, rs.u8, Picky.Picky] = tuple(a.items); + const _164: [Picky.Picky, rs.u8, Picky.Picky] = tuple(b.items); + putEq(!rs.eqTuple([(a13: Picky.Picky, b13: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a13, b13); - }, rt.same, (a14: Picky.Picky, b14: Picky.Picky): boolean => { + }, rs.same, (a14: Picky.Picky, b14: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a14, b14); }])(_158, _164), log, out); - const _173: [Picky.Picky, rt.u8, Picky.Picky] = tuple(a.items); - const _179: [Picky.Picky, rt.u8, Picky.Picky] = tuple(b.items); - putEq(rt.eqTuple([Picky.eq$cmp_PartialEq, rt.same, Picky.eq$cmp_PartialEq])(_173, _179), log, out); - const _188: [[Picky.Picky, rt.u8, Picky.Picky], rt.u8] = [tuple(a.items), 1]; - const _195: [[Picky.Picky, rt.u8, Picky.Picky], rt.u8] = [tuple(b.items), 1]; - putEq(!rt.eqTuple([rt.eqTuple([(a15: Picky.Picky, b15: Picky.Picky): boolean => { + const _173: [Picky.Picky, rs.u8, Picky.Picky] = tuple(a.items); + const _179: [Picky.Picky, rs.u8, Picky.Picky] = tuple(b.items); + putEq(rs.eqTuple([Picky.eq$cmp_PartialEq, rs.same, Picky.eq$cmp_PartialEq])(_173, _179), log, out); + const _188: [[Picky.Picky, rs.u8, Picky.Picky], rs.u8] = [tuple(a.items), 1]; + const _195: [[Picky.Picky, rs.u8, Picky.Picky], rs.u8] = [tuple(b.items), 1]; + putEq(!rs.eqTuple([rs.eqTuple([(a15: Picky.Picky, b15: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a15, b15); - }, rt.same, (a16: Picky.Picky, b16: Picky.Picky): boolean => { + }, rs.same, (a16: Picky.Picky, b16: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a16, b16); - }]), rt.same])(_188, _195), log, out); - const _205: rt.Vec<[Picky.Picky, rt.u8]> = each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure6(a.items, (p2: Picky.Picky): [Picky.Picky, rt.u8] => { - return [Picky.clone$Clone(p2), p2._0 & 0xff] as [Picky.Picky, rt.u8]; + }]), rs.same])(_188, _195), log, out); + const _205: rs.Vec<[Picky.Picky, rs.u8]> = each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure6(a.items, (p2: Picky.Picky): [Picky.Picky, rs.u8] => { + return [Picky.clone$Clone(p2), p2._0 & 0xff] as [Picky.Picky, rs.u8]; }); - const _209: rt.Vec<[Picky.Picky, rt.u8]> = each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure7(b.items, (p3: Picky.Picky): [Picky.Picky, rt.u8] => { - return [Picky.clone$Clone(p3), p3._0 & 0xff] as [Picky.Picky, rt.u8]; + const _209: rs.Vec<[Picky.Picky, rs.u8]> = each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure7(b.items, (p3: Picky.Picky): [Picky.Picky, rs.u8] => { + return [Picky.clone$Clone(p3), p3._0 & 0xff] as [Picky.Picky, rs.u8]; }); - putEq(rt.eqSlice(rt.eqTuple([(a17: Picky.Picky, b17: Picky.Picky): boolean => { + putEq(rs.eqSlice(rs.eqTuple([(a17: Picky.Picky, b17: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a17, b17); - }, rt.same]))(_205, _209), log, out); - const _217: [Picky.Picky, rt.u8][] = rt.sliceRange(each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure8(a.items, (p4: Picky.Picky): [Picky.Picky, rt.u8] => { - return [Picky.clone$Clone(p4), p4._0 & 0xff] as [Picky.Picky, rt.u8]; + }, rs.same]))(_205, _209), log, out); + const _217: [Picky.Picky, rs.u8][] = rs.sliceRange(each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure8(a.items, (p4: Picky.Picky): [Picky.Picky, rs.u8] => { + return [Picky.clone$Clone(p4), p4._0 & 0xff] as [Picky.Picky, rs.u8]; }).items, 0); - const _224: [Picky.Picky, rt.u8][] = rt.sliceRange(each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure9(b.items, (p5: Picky.Picky): [Picky.Picky, rt.u8] => { - return [Picky.clone$Clone(p5), p5._0 & 0xff] as [Picky.Picky, rt.u8]; + const _224: [Picky.Picky, rs.u8][] = rs.sliceRange(each$collections_Picky_tuple2_collections_Picky_u8_collections_own_nes_closure9(b.items, (p5: Picky.Picky): [Picky.Picky, rs.u8] => { + return [Picky.clone$Clone(p5), p5._0 & 0xff] as [Picky.Picky, rs.u8]; }).items, 0); - putEq(!rt.eqSlice(rt.eqTuple([(a18: Picky.Picky, b18: Picky.Picky): boolean => { + putEq(!rs.eqSlice(rs.eqTuple([(a18: Picky.Picky, b18: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a18, b18); - }, rt.same]))(_217, _224), log, out); + }, rs.same]))(_217, _224), log, out); const _233: [Picky.Picky | undefined] = [one(a.items, 0)]; const _241: [Picky.Picky | undefined] = [one(b.items, 0)]; - putEq(!rt.eqTuple([rt.eqOption(Picky.eq$cmp_PartialEq)])(_233, _241), log, out); + putEq(!rs.eqTuple([rs.eqOption(Picky.eq$cmp_PartialEq)])(_233, _241), log, out); const _252: [Picky.Picky] = [one(a.items, 0)]; const _260: [Picky.Picky] = [one(b.items, 0)]; - putEq(!rt.eqTuple([Picky.eq$cmp_PartialEq])(_252, _260), log, out); + putEq(!rs.eqTuple([Picky.eq$cmp_PartialEq])(_252, _260), log, out); const _271: [Picky.Picky] = [one(a.items, 0)]; const _279: [Picky.Picky] = [one(b.items, 0)]; - putEq(!rt.eqTuple([(a19: Picky.Picky, b19: Picky.Picky): boolean => { + putEq(!rs.eqTuple([(a19: Picky.Picky, b19: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a19, b19); }])(_271, _279), log, out); const _290: [Picky.Picky] = [one(a.items, 0)]; const _298: [Picky.Picky] = [one(b.items, 0)]; - putEq(!rt.eqTuple([(a20: Picky.Picky, b20: Picky.Picky): boolean => { + putEq(!rs.eqTuple([(a20: Picky.Picky, b20: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a20, b20); }])(_290, _298), log, out); - const _309: rt.Vec = each$collections_Picky_Option_collections_Picky_collections_own_nes_closure10(a.items, (p6: Picky.Picky): Picky.Picky | undefined => { + const _309: rs.Vec = each$collections_Picky_Option_collections_Picky_collections_own_nes_closure10(a.items, (p6: Picky.Picky): Picky.Picky | undefined => { return Picky.clone$Clone(p6); }); - const _313: rt.Vec = each$collections_Picky_Option_collections_Picky_collections_own_nes_closure11(b.items, (p7: Picky.Picky): Picky.Picky | undefined => { + const _313: rs.Vec = each$collections_Picky_Option_collections_Picky_collections_own_nes_closure11(b.items, (p7: Picky.Picky): Picky.Picky | undefined => { return Picky.clone$Clone(p7); }); - putEq(rt.eqSlice(rt.eqOption(Picky.eq$cmp_PartialEq))(_309, _313), log, out); - const _320: rt.Vec = each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure12(a.items, (p8: Picky.Picky): Picky.Picky => { + putEq(rs.eqSlice(rs.eqOption(Picky.eq$cmp_PartialEq))(_309, _313), log, out); + const _320: rs.Vec = each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure12(a.items, (p8: Picky.Picky): Picky.Picky => { return Picky.clone$Clone(p8); }); - const _324: rt.Vec = each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure13(b.items, (p9: Picky.Picky): Picky.Picky => { + const _324: rs.Vec = each$collections_Picky_cmp_Reverse_collections_Picky_collections_own_nes_closure13(b.items, (p9: Picky.Picky): Picky.Picky => { return Picky.clone$Clone(p9); }); - putEq(rt.eqSlice(Picky.eq$cmp_PartialEq)(_320, _324), log, out); - const _331: rt.Vec = each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure14(a.items, (p10: Picky.Picky): Picky.Picky => { + putEq(rs.eqSlice(Picky.eq$cmp_PartialEq)(_320, _324), log, out); + const _331: rs.Vec = each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure14(a.items, (p10: Picky.Picky): Picky.Picky => { return Picky.clone$Clone(p10); }); - const _335: rt.Vec = each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure15(b.items, (p11: Picky.Picky): Picky.Picky => { + const _335: rs.Vec = each$collections_Picky_boxed_Box_collections_Picky_collections_own_nes_closure15(b.items, (p11: Picky.Picky): Picky.Picky => { return Picky.clone$Clone(p11); }); - putEq(rt.eqSlice((a21: Picky.Picky, b21: Picky.Picky): boolean => { + putEq(rs.eqSlice((a21: Picky.Picky, b21: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a21, b21); })(_331, _335), log, out); - const arc: rt.Arc = new rt.Arc(one(a.items, 0)); - const _349: rt.Arc = rt.arcClone(arc); - putEq(!rt.eqArc((a22: Picky.Picky, b22: Picky.Picky): boolean => { + const arc: rs.Arc = new rs.Arc(one(a.items, 0)); + const _349: rs.Arc = rs.arcClone(arc); + putEq(!rs.eqArc((a22: Picky.Picky, b22: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a22, b22); }, true)(arc, _349), log, out); _349[Symbol.dispose](); - const _356: rt.Arc = rt.arcClone(arc); - putEq(rt.eqArc(Picky.eq$cmp_PartialEq, true)(arc, _356), log, out); + const _356: rs.Arc = rs.arcClone(arc); + putEq(rs.eqArc(Picky.eq$cmp_PartialEq, true)(arc, _356), log, out); _356[Symbol.dispose](); - const _362: rt.Arc = new rt.Arc(one(a.items, 0)); - const _369: rt.Arc = new rt.Arc(one(b.items, 0)); - putEq(!rt.eqArc((a23: Picky.Picky, b23: Picky.Picky): boolean => { + const _362: rs.Arc = new rs.Arc(one(a.items, 0)); + const _369: rs.Arc = new rs.Arc(one(b.items, 0)); + putEq(!rs.eqArc((a23: Picky.Picky, b23: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a23, b23); }, true)(_362, _369), log, out); _369[Symbol.dispose](); _362[Symbol.dispose](); - const floated: rt.Arc<[Picky.Picky, rt.f32]> = new rt.Arc([one(a.items, 0), 0.5] as [Picky.Picky, rt.f32]); - const _387: rt.Arc<[Picky.Picky, rt.f32]> = rt.arcClone(floated); - putEq(!rt.eqArc(rt.eqTuple([(a24: Picky.Picky, b24: Picky.Picky): boolean => { + const floated: rs.Arc<[Picky.Picky, rs.f32]> = new rs.Arc([one(a.items, 0), 0.5] as [Picky.Picky, rs.f32]); + const _387: rs.Arc<[Picky.Picky, rs.f32]> = rs.arcClone(floated); + putEq(!rs.eqArc(rs.eqTuple([(a24: Picky.Picky, b24: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a24, b24); - }, rt.same]))(floated, _387), log, out); + }, rs.same]))(floated, _387), log, out); _387[Symbol.dispose](); - const _394: rt.Arc<[Picky.Picky, rt.f32]> = new rt.Arc([one(b.items, 0), 0.5] as [Picky.Picky, rt.f32]); - putEq(!rt.eqArc(rt.eqTuple([(a25: Picky.Picky, b25: Picky.Picky): boolean => { + const _394: rs.Arc<[Picky.Picky, rs.f32]> = new rs.Arc([one(b.items, 0), 0.5] as [Picky.Picky, rs.f32]); + putEq(!rs.eqArc(rs.eqTuple([(a25: Picky.Picky, b25: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a25, b25); - }, rt.same]))(floated, _394), log, out); + }, rs.same]))(floated, _394), log, out); _394[Symbol.dispose](); - const _405: rt.Arc = new rt.Arc(one(a.items, 1)); - const _412: rt.Arc = new rt.Arc(one(b.items, 1)); - putEq(!rt.eqArc((a26: Picky.Picky, b26: Picky.Picky): boolean => { + const _405: rs.Arc = new rs.Arc(one(a.items, 1)); + const _412: rs.Arc = new rs.Arc(one(b.items, 1)); + putEq(!rs.eqArc((a26: Picky.Picky, b26: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a26, b26); }, true)(_405, _412), log, out); _412[Symbol.dispose](); _405[Symbol.dispose](); - const shared: rt.Vec> = each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure16(a.items, (p12: Picky.Picky): rt.Arc => { - return new rt.Arc(Picky.clone$Clone(p12)); + const shared: rs.Vec> = each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure16(a.items, (p12: Picky.Picky): rs.Arc => { + return new rs.Arc(Picky.clone$Clone(p12)); }); - const _426: rt.Vec> = rt.vecFrom(shared.items.map((a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const _426: rs.Vec> = rs.vecFrom(shared.items.map((a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); })); - putEq(rt.eqSlice(rt.eqArc((a27: Picky.Picky, b27: Picky.Picky): boolean => { + putEq(rs.eqSlice(rs.eqArc((a27: Picky.Picky, b27: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a27, b27); }, true))(shared, _426), log, out); - rt.dropVec(_426); - const _433: rt.Vec> = each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure17(b.items, (p13: Picky.Picky): rt.Arc => { - return new rt.Arc(Picky.clone$Clone(p13)); + rs.dropVec(_426); + const _433: rs.Vec> = each$collections_Picky_sync_Arc_collections_Picky_collections_own_nes_closure17(b.items, (p13: Picky.Picky): rs.Arc => { + return new rs.Arc(Picky.clone$Clone(p13)); }); - putEq(rt.eqSlice(rt.eqArc((a28: Picky.Picky, b28: Picky.Picky): boolean => { + putEq(rs.eqSlice(rs.eqArc((a28: Picky.Picky, b28: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a28, b28); }, true))(shared, _433), log, out); - rt.dropVec(_433); - const _440: [rt.Arc, rt.u8] = [rt.arcClone(arc), 0]; - const _444: [rt.Arc, rt.u8] = [new rt.Arc(one(b.items, 0)), 0]; - putEq(!rt.eqTuple([rt.eqArc((a29: Picky.Picky, b29: Picky.Picky): boolean => { + rs.dropVec(_433); + const _440: [rs.Arc, rs.u8] = [rs.arcClone(arc), 0]; + const _444: [rs.Arc, rs.u8] = [new rs.Arc(one(b.items, 0)), 0]; + putEq(!rs.eqTuple([rs.eqArc((a29: Picky.Picky, b29: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a29, b29); - }, true), rt.same])(_440, _444), log, out); + }, true), rs.same])(_440, _444), log, out); drop$tuple2_sync_Arc_collections_Picky_u8(_444); drop$tuple2_sync_Arc_collections_Picky_u8(_440); - const _455: rt.VecDeque = wrapped$collections_Picky(a.items); - const _459: rt.VecDeque = wrapped$collections_Picky(b.items); - putEq(rt.eqSeq((a30: Picky.Picky, b30: Picky.Picky): boolean => { + const _455: rs.VecDeque = wrapped$collections_Picky(a.items); + const _459: rs.VecDeque = wrapped$collections_Picky(b.items); + putEq(rs.eqSeq((a30: Picky.Picky, b30: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a30, b30); })(_455, _459), log, out); - const _466: rt.VecDeque = wrapped$collections_Picky(a.items); - const _470: rt.VecDeque = wrapped$collections_Picky(b.items); - putEq(!rt.eqSeq((a31: Picky.Picky, b31: Picky.Picky): boolean => { + const _466: rs.VecDeque = wrapped$collections_Picky(a.items); + const _470: rs.VecDeque = wrapped$collections_Picky(b.items); + putEq(!rs.eqSeq((a31: Picky.Picky, b31: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a31, b31); })(_466, _470), log, out); - const _477: rt.VecDeque = wrapped$collections_Picky(a.items); - putEq(rt.eqSeq((a32: Picky.Picky, b32: Picky.Picky): boolean => { + const _477: rs.VecDeque = wrapped$collections_Picky(a.items); + putEq(rs.eqSeq((a32: Picky.Picky, b32: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a32, b32); })(_477, b), log, out); - const _485: rt.VecDeque = wrapped$collections_Picky(a.items); - const _490: Picky.Picky[] = rt.sliceRange(b.items, 0); - putEq(rt.eqSeq((a33: Picky.Picky, b33: Picky.Picky): boolean => { + const _485: rs.VecDeque = wrapped$collections_Picky(a.items); + const _490: Picky.Picky[] = rs.sliceRange(b.items, 0); + putEq(rs.eqSeq((a33: Picky.Picky, b33: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a33, b33); })(_485, _490), log, out); const _496: [Picky.Picky] = [one(a.items, 0)]; const _504: [Picky.Picky] = [one(b.items, 0)]; - putEq(!rt.eqTuple([Picky.eq$cmp_PartialEq])(_496, _504), log, out); + putEq(!rs.eqTuple([Picky.eq$cmp_PartialEq])(_496, _504), log, out); putEq(Picky.eq$cmp_PartialEq(one(a.items, 1), one(b.items, 1)), log, out); - const _531: [rt.Cow, rt.Cow] = [new rt.Borrowed(rt.sliceRange(a.items, 0)), rt.vecFrom(b.items.map(Picky.clone$Clone))]; - const ca: rt.Cow = _531[0]; - const cb: rt.Cow = _531[1]; - putEq(rt.eqSlice((a34: Picky.Picky, b34: Picky.Picky): boolean => { + const _531: [rs.Cow, rs.Cow] = [new rs.Borrowed(rs.sliceRange(a.items, 0)), rs.vecFrom(b.items.map(Picky.clone$Clone))]; + const ca: rs.Cow = _531[0]; + const cb: rs.Cow = _531[1]; + putEq(rs.eqSlice((a34: Picky.Picky, b34: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a34, b34); - })(rt.cowSlice(ca), rt.cowSlice(cb)), log, out); - putEq(!rt.eqSlice((a35: Picky.Picky, b35: Picky.Picky): boolean => { + })(rs.cowSlice(ca), rs.cowSlice(cb)), log, out); + putEq(!rs.eqSlice((a35: Picky.Picky, b35: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a35, b35); - })(rt.cowSlice(ca), rt.cowSlice(cb)), log, out); - const _553: Picky.Picky[] = rt.sliceRange(b.items, 0); - putEq(rt.eqSlice((a36: Picky.Picky, b36: Picky.Picky): boolean => { + })(rs.cowSlice(ca), rs.cowSlice(cb)), log, out); + const _553: Picky.Picky[] = rs.sliceRange(b.items, 0); + putEq(rs.eqSlice((a36: Picky.Picky, b36: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a36, b36); - })(rt.cowSlice(ca), _553), log, out); - putEq(!rt.eqSlice((a37: Picky.Picky, b37: Picky.Picky): boolean => { + })(rs.cowSlice(ca), _553), log, out); + putEq(!rs.eqSlice((a37: Picky.Picky, b37: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a37, b37); - })(rt.cowSlice(cb), a), log, out); - putEq(rt.eqSlice((a38: Picky.Picky, b38: Picky.Picky): boolean => { + })(rs.cowSlice(cb), a), log, out); + putEq(rs.eqSlice((a38: Picky.Picky, b38: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a38, b38); - })(b, rt.cowSlice(ca)), log, out); - const _570: Picky.Picky[] = rt.sliceRange(a.items, 0); - putEq(!rt.eqSlice((a39: Picky.Picky, b39: Picky.Picky): boolean => { + })(b, rs.cowSlice(ca)), log, out); + const _570: Picky.Picky[] = rs.sliceRange(a.items, 0); + putEq(!rs.eqSlice((a39: Picky.Picky, b39: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a39, b39); - })(_570, rt.cowSlice(cb)), log, out); - const _576: Picky.Picky[] = rt.cowSlice(cb); - putEq(rt.eqSlice((a40: Picky.Picky, b40: Picky.Picky): boolean => { + })(_570, rs.cowSlice(cb)), log, out); + const _576: Picky.Picky[] = rs.cowSlice(cb); + putEq(rs.eqSlice((a40: Picky.Picky, b40: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a40, b40); })(_576, pa), log, out); - const owned: rt.Vec> = each$collections_Picky_borrow_Cow_slice_collections_Picky_collections_own_nes_closure18(a.items, (p14: Picky.Picky): rt.Cow => { - return rt.vecFrom([Picky.clone$Clone(p14)]); + const owned: rs.Vec> = each$collections_Picky_borrow_Cow_slice_collections_Picky_collections_own_nes_closure18(a.items, (p14: Picky.Picky): rs.Cow => { + return rs.vecFrom([Picky.clone$Clone(p14)]); }); - const borrowed: rt.Vec> = rt.iterToVec(rt.iterMap(rt.sliceChunks(b.items, 1), (a02: Picky.Picky[]): rt.Cow => { - return new rt.Borrowed(a02); + const borrowed: rs.Vec> = rs.iterToVec(rs.iterMap(rs.sliceChunks(b.items, 1), (a02: Picky.Picky[]): rs.Cow => { + return new rs.Borrowed(a02); }), undefined, 12, true); - putEq(!rt.eqSlice(rt.cowBy(rt.eqSlice((a41: Picky.Picky, b41: Picky.Picky): boolean => { + putEq(!rs.eqSlice(rs.cowBy(rs.eqSlice((a41: Picky.Picky, b41: Picky.Picky): boolean => { return !Picky.ne$cmp_PartialEq(a41, b41); })))(owned, borrowed), log, out); - rt.dropVec(shared); + rs.dropVec(shared); floated[Symbol.dispose](); arc[Symbol.dispose](); } -export function putOrder(order: rt.Ordering | undefined, log: rt.Cell, out: rt.ByteVec): void { - rt.byteVecPush(out, option_mapOr$1e4a1e0(order, 9, (o: rt.Ordering): rt.u8 => { +export function putOrder(order: rs.Ordering | undefined, log: rs.Cell, out: rs.ByteVec): void { + rs.byteVecPush(out, option_mapOr$14runhi(order, 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.cellReplace(log, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log, 0)).reverse()), undefined, true); } -export function putCmp(order: rt.Ordering, log: rt.Cell, out: rt.ByteVec): void { - rt.byteVecPush(out, order & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.cellReplace(log, 0)).reverse()), undefined, true); +export function putCmp(order: rs.Ordering, log: rs.Cell, out: rs.ByteVec): void { + rs.byteVecPush(out, order & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log, 0)).reverse()), undefined, true); } /** @@ -4299,350 +4299,350 @@ export function putCmp(order: rt.Ordering, log: rt.Cell, out: rt.ByteVec * B-tree keys, and a `RefCell` against itself. Then, as `kind` picks, a `RefCell` compared * while mutably borrowed, which panics, or held by an `Arc` that finds itself equal first. */ -export function cellEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function cellEqs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _688!: [Quirky.Quirky, Quirky.Quirky]; - let _mutable!: rt.RefCell; - const log: rt.Cell = new rt.Cell(0); - const at: (a0: rt.usize) => rt.u16 = (i: rt.usize): rt.u16 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.u16; + let _mutable!: rs.RefCell; + const log: rs.Cell = new rs.Cell(0); + const at: (a0: rs.usize) => rs.u16 = (i: rs.usize): rs.u16 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0) as rs.u16; }; const _8: [Quirky.Quirky, Quirky.Quirky] = [{ _0: at(0), _1: log }, { _0: at(1), _1: log }]; const x: Quirky.Quirky = _8[0]; const y: Quirky.Quirky = _8[1]; - const maybe: (a0: rt.usize) => rt.u8 | undefined = (i2: rt.usize): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u16Rem(at(i2), 3) !== 0, at(i2) & 0xff); + const maybe: (a0: rs.usize) => rs.u8 | undefined = (i2: rs.usize): rs.u8 | undefined => { + return thenSome$0quywni(rs.u16Rem(at(i2), 3) !== 0, at(i2) & 0xff); }; - const _23: [rt.Cell, rt.Cell] = [new rt.Cell(copy$collections_Quirky(x)), new rt.Cell(copy$collections_Quirky(y))]; - const ca: rt.Cell = _23[0]; - const cb: rt.Cell = _23[1]; - putEq(rt.cellBy(Quirky.eq$cmp_PartialEq)(ca, cb), log, out); - putEq(!rt.cellBy(Quirky.eq$cmp_PartialEq)(ca, cb), log, out); - putEq(rt.cellBy(Quirky.lt$cmp_PartialOrd)(ca, cb), log, out); - putEq(rt.cellBy(Quirky.le$cmp_PartialOrd)(ca, cb), log, out); - putEq(rt.cellBy(Quirky.gt$cmp_PartialOrd)(ca, cb), log, out); - putEq(rt.cellBy(Quirky.ge$cmp_PartialOrd)(ca, cb), log, out); - putOrder(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd)(ca, cb), log, out); - putCmp(rt.cellBy(Quirky.cmp$cmp_Ord)(ca, cb), log, out); - const _68: [rt.RefCell, rt.RefCell] = [new rt.RefCell(copy$collections_Quirky(x)), new rt.RefCell(copy$collections_Quirky(y))]; - const ra: rt.RefCell = _68[0]; - const rb: rt.RefCell = _68[1]; - putEq(rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); - putEq(!rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); - putEq(rt.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, rb), log, out); - putEq(rt.refCellBy(Quirky.le$cmp_PartialOrd)(ra, rb), log, out); - putEq(rt.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, rb), log, out); - putEq(rt.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, rb), log, out); - putOrder(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, rb), log, out); - putCmp(rt.refCellBy(Quirky.cmp$cmp_Ord)(ra, rb), log, out); - putEq(rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, ra), log, out); - putEq(!rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, ra), log, out); - putEq(rt.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, ra), log, out); - putEq(rt.refCellBy(Quirky.le$cmp_PartialOrd)(ra, ra), log, out); - putEq(rt.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, ra), log, out); - putEq(rt.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, ra), log, out); - putOrder(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, ra), log, out); - putCmp(rt.refCellBy(Quirky.cmp$cmp_Ord)(ra, ra), log, out); - const _153: [rt.Cell, rt.Cell] = [new rt.Cell(at(0) & 0xff), new rt.Cell(at(1) & 0xff)]; - const na: rt.Cell = _153[0]; - const nb: rt.Cell = _153[1]; - putEq(rt.cellBy(rt.same)(na, nb), log, out); - putEq(!rt.cellBy(rt.same)(na, nb), log, out); - putEq(rt.cellBy(rt.cmp)(na, nb) === -1, log, out); - const order = rt.cellBy(rt.cmp)(na, nb); + const _23: [rs.Cell, rs.Cell] = [new rs.Cell(copy$collections_Quirky(x)), new rs.Cell(copy$collections_Quirky(y))]; + const ca: rs.Cell = _23[0]; + const cb: rs.Cell = _23[1]; + putEq(rs.cellBy(Quirky.eq$cmp_PartialEq)(ca, cb), log, out); + putEq(!rs.cellBy(Quirky.eq$cmp_PartialEq)(ca, cb), log, out); + putEq(rs.cellBy(Quirky.lt$cmp_PartialOrd)(ca, cb), log, out); + putEq(rs.cellBy(Quirky.le$cmp_PartialOrd)(ca, cb), log, out); + putEq(rs.cellBy(Quirky.gt$cmp_PartialOrd)(ca, cb), log, out); + putEq(rs.cellBy(Quirky.ge$cmp_PartialOrd)(ca, cb), log, out); + putOrder(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd)(ca, cb), log, out); + putCmp(rs.cellBy(Quirky.cmp$cmp_Ord)(ca, cb), log, out); + const _68: [rs.RefCell, rs.RefCell] = [new rs.RefCell(copy$collections_Quirky(x)), new rs.RefCell(copy$collections_Quirky(y))]; + const ra: rs.RefCell = _68[0]; + const rb: rs.RefCell = _68[1]; + putEq(rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); + putEq(!rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.le$cmp_PartialOrd)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, rb), log, out); + putOrder(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, rb), log, out); + putCmp(rs.refCellBy(Quirky.cmp$cmp_Ord)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, ra), log, out); + putEq(!rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, ra), log, out); + putEq(rs.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, ra), log, out); + putEq(rs.refCellBy(Quirky.le$cmp_PartialOrd)(ra, ra), log, out); + putEq(rs.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, ra), log, out); + putEq(rs.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, ra), log, out); + putOrder(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, ra), log, out); + putCmp(rs.refCellBy(Quirky.cmp$cmp_Ord)(ra, ra), log, out); + const _153: [rs.Cell, rs.Cell] = [new rs.Cell(at(0) & 0xff), new rs.Cell(at(1) & 0xff)]; + const na: rs.Cell = _153[0]; + const nb: rs.Cell = _153[1]; + putEq(rs.cellBy(rs.same)(na, nb), log, out); + putEq(!rs.cellBy(rs.same)(na, nb), log, out); + putEq(rs.cellBy(rs.cmp)(na, nb) === -1, log, out); + const order = rs.cellBy(rs.cmp)(na, nb); putEq(order !== undefined && order <= 0, log, out); - putEq(rt.cellBy(rt.cmp)(na, nb) === 1, log, out); - const order2 = rt.cellBy(rt.cmp)(na, nb); + putEq(rs.cellBy(rs.cmp)(na, nb) === 1, log, out); + const order2 = rs.cellBy(rs.cmp)(na, nb); putEq(order2 !== undefined && order2 >= 0, log, out); - putOrder(rt.cellBy(rt.cmp)(na, nb), log, out); - putCmp(rt.cellBy(rt.cmp)(na, nb), log, out); - const _206: [rt.Cell, rt.Cell] = [new rt.Cell(maybe(0)), new rt.Cell(maybe(1))]; - const oa: rt.Cell = _206[0]; - const ob: rt.Cell = _206[1]; - putEq(rt.cellBy(rt.same)(oa, ob), log, out); - putEq(!rt.cellBy(rt.same)(oa, ob), log, out); - putEq(rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob) === -1, log, out); - const order3 = rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob); + putOrder(rs.cellBy(rs.cmp)(na, nb), log, out); + putCmp(rs.cellBy(rs.cmp)(na, nb), log, out); + const _206: [rs.Cell, rs.Cell] = [new rs.Cell(maybe(0)), new rs.Cell(maybe(1))]; + const oa: rs.Cell = _206[0]; + const ob: rs.Cell = _206[1]; + putEq(rs.cellBy(rs.same)(oa, ob), log, out); + putEq(!rs.cellBy(rs.same)(oa, ob), log, out); + putEq(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob) === -1, log, out); + const order3 = rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob); putEq(order3 !== undefined && order3 <= 0, log, out); - putEq(rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob) === 1, log, out); - const order4 = rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob); + putEq(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob) === 1, log, out); + const order4 = rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob); putEq(order4 !== undefined && order4 >= 0, log, out); - putOrder(rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob), log, out); - putCmp(rt.cellBy(rt.cmpOption(rt.cmp))(oa, ob), log, out); - const _261: rt.u16 = at(0); - const _267: rt.u16 = at(1); - const _257: [rt.RefCell, rt.RefCell] = [new rt.RefCell(rt.fmtToString((f: rt.Formatter) => rt.u16Display(_261, f))), new rt.RefCell(rt.fmtToString((f: rt.Formatter) => rt.u16Display(_267, f)))]; - const sa: rt.RefCell = _257[0]; - const sb: rt.RefCell = _257[1]; - putEq(rt.refCellBy(rt.same)(sa, sb), log, out); - putEq(!rt.refCellBy(rt.same)(sa, sb), log, out); - putEq(rt.refCellBy(rt.cmpStr)(sa, sb) === -1, log, out); - const order5 = rt.refCellBy(rt.cmpStr)(sa, sb); + putOrder(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob), log, out); + putCmp(rs.cellBy(rs.cmpOption(rs.cmp))(oa, ob), log, out); + const _261: rs.u16 = at(0); + const _267: rs.u16 = at(1); + const _257: [rs.RefCell, rs.RefCell] = [new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_261, f))), new rs.RefCell(rs.fmtToString((f: rs.Formatter) => rs.u16Display(_267, f)))]; + const sa: rs.RefCell = _257[0]; + const sb: rs.RefCell = _257[1]; + putEq(rs.refCellBy(rs.same)(sa, sb), log, out); + putEq(!rs.refCellBy(rs.same)(sa, sb), log, out); + putEq(rs.refCellBy(rs.cmpStr)(sa, sb) === -1, log, out); + const order5 = rs.refCellBy(rs.cmpStr)(sa, sb); putEq(order5 !== undefined && order5 <= 0, log, out); - putEq(rt.refCellBy(rt.cmpStr)(sa, sb) === 1, log, out); - const order6 = rt.refCellBy(rt.cmpStr)(sa, sb); + putEq(rs.refCellBy(rs.cmpStr)(sa, sb) === 1, log, out); + const order6 = rs.refCellBy(rs.cmpStr)(sa, sb); putEq(order6 !== undefined && order6 >= 0, log, out); - putOrder(rt.refCellBy(rt.cmpStr)(sa, sb), log, out); - putCmp(rt.refCellBy(rt.cmpStr)(sa, sb), log, out); - const _312: [rt.RefCell>, rt.RefCell>] = [new rt.RefCell(new rt.RefCell(copy$collections_Quirky(x))), new rt.RefCell(new rt.RefCell(copy$collections_Quirky(y)))]; - const rra: rt.RefCell> = _312[0]; - const rrb: rt.RefCell> = _312[1]; - const held: rt.RefCell> = rt.refCellBorrow(rra); - const _inner: rt.RefCell = rt.refCellBorrow(held.value); - putEq(rt.refCellBy(rt.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); - putEq(!rt.refCellBy(rt.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.lt$cmp_PartialOrd))(rra, rrb), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.le$cmp_PartialOrd))(rra, rrb), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.gt$cmp_PartialOrd))(rra, rrb), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.ge$cmp_PartialOrd))(rra, rrb), log, out); - putOrder(rt.refCellBy(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(rra, rrb), log, out); - putCmp(rt.refCellBy(rt.refCellBy(Quirky.cmp$cmp_Ord))(rra, rrb), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rra), log, out); - putEq(!rt.refCellBy(rt.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rra), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.lt$cmp_PartialOrd))(rra, rra), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.le$cmp_PartialOrd))(rra, rra), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.gt$cmp_PartialOrd))(rra, rra), log, out); - putEq(rt.refCellBy(rt.refCellBy(Quirky.ge$cmp_PartialOrd))(rra, rra), log, out); - putOrder(rt.refCellBy(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(rra, rra), log, out); - putCmp(rt.refCellBy(rt.refCellBy(Quirky.cmp$cmp_Ord))(rra, rra), log, out); - rt.refRelease(_inner); - rt.refRelease(held); - const _404: [rt.RefCell>, rt.RefCell>] = [new rt.RefCell(new rt.Cell(copy$collections_Quirky(x))), new rt.RefCell(new rt.Cell(copy$collections_Quirky(y)))]; - const rca: rt.RefCell> = _404[0]; - const rcb: rt.RefCell> = _404[1]; - putEq(rt.refCellBy(rt.cellBy(Quirky.eq$cmp_PartialEq))(rca, rcb), log, out); - putEq(!rt.refCellBy(rt.cellBy(Quirky.eq$cmp_PartialEq))(rca, rcb), log, out); - putEq(rt.refCellBy(rt.cellBy(Quirky.lt$cmp_PartialOrd))(rca, rcb), log, out); - putEq(rt.refCellBy(rt.cellBy(Quirky.le$cmp_PartialOrd))(rca, rcb), log, out); - putEq(rt.refCellBy(rt.cellBy(Quirky.gt$cmp_PartialOrd))(rca, rcb), log, out); - putEq(rt.refCellBy(rt.cellBy(Quirky.ge$cmp_PartialOrd))(rca, rcb), log, out); - putOrder(rt.refCellBy(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(rca, rcb), log, out); - putCmp(rt.refCellBy(rt.cellBy(Quirky.cmp$cmp_Ord))(rca, rcb), log, out); - const _452: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _455: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putEq(rt.eqOption(rt.cellBy(Quirky.eq$cmp_PartialEq))(_452, _455), log, out); - const _461: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _464: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putEq(!rt.eqOption(rt.cellBy(Quirky.eq$cmp_PartialEq))(_461, _464), log, out); - const _470: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _473: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putEq(rt.cmpOption(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_470, _473) === -1, log, out); - const _479: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _482: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - const order7 = rt.cmpOption(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_479, _482); + putOrder(rs.refCellBy(rs.cmpStr)(sa, sb), log, out); + putCmp(rs.refCellBy(rs.cmpStr)(sa, sb), log, out); + const _312: [rs.RefCell>, rs.RefCell>] = [new rs.RefCell(new rs.RefCell(copy$collections_Quirky(x))), new rs.RefCell(new rs.RefCell(copy$collections_Quirky(y)))]; + const rra: rs.RefCell> = _312[0]; + const rrb: rs.RefCell> = _312[1]; + const held: rs.RefCell> = rs.refCellBorrow(rra); + const _inner: rs.RefCell = rs.refCellBorrow(held.value); + putEq(rs.refCellBy(rs.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); + putEq(!rs.refCellBy(rs.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.lt$cmp_PartialOrd))(rra, rrb), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.le$cmp_PartialOrd))(rra, rrb), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.gt$cmp_PartialOrd))(rra, rrb), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.ge$cmp_PartialOrd))(rra, rrb), log, out); + putOrder(rs.refCellBy(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(rra, rrb), log, out); + putCmp(rs.refCellBy(rs.refCellBy(Quirky.cmp$cmp_Ord))(rra, rrb), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rra), log, out); + putEq(!rs.refCellBy(rs.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rra), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.lt$cmp_PartialOrd))(rra, rra), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.le$cmp_PartialOrd))(rra, rra), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.gt$cmp_PartialOrd))(rra, rra), log, out); + putEq(rs.refCellBy(rs.refCellBy(Quirky.ge$cmp_PartialOrd))(rra, rra), log, out); + putOrder(rs.refCellBy(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(rra, rra), log, out); + putCmp(rs.refCellBy(rs.refCellBy(Quirky.cmp$cmp_Ord))(rra, rra), log, out); + rs.refRelease(_inner); + rs.refRelease(held); + const _404: [rs.RefCell>, rs.RefCell>] = [new rs.RefCell(new rs.Cell(copy$collections_Quirky(x))), new rs.RefCell(new rs.Cell(copy$collections_Quirky(y)))]; + const rca: rs.RefCell> = _404[0]; + const rcb: rs.RefCell> = _404[1]; + putEq(rs.refCellBy(rs.cellBy(Quirky.eq$cmp_PartialEq))(rca, rcb), log, out); + putEq(!rs.refCellBy(rs.cellBy(Quirky.eq$cmp_PartialEq))(rca, rcb), log, out); + putEq(rs.refCellBy(rs.cellBy(Quirky.lt$cmp_PartialOrd))(rca, rcb), log, out); + putEq(rs.refCellBy(rs.cellBy(Quirky.le$cmp_PartialOrd))(rca, rcb), log, out); + putEq(rs.refCellBy(rs.cellBy(Quirky.gt$cmp_PartialOrd))(rca, rcb), log, out); + putEq(rs.refCellBy(rs.cellBy(Quirky.ge$cmp_PartialOrd))(rca, rcb), log, out); + putOrder(rs.refCellBy(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(rca, rcb), log, out); + putCmp(rs.refCellBy(rs.cellBy(Quirky.cmp$cmp_Ord))(rca, rcb), log, out); + const _452: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _455: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putEq(rs.eqOption(rs.cellBy(Quirky.eq$cmp_PartialEq))(_452, _455), log, out); + const _461: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _464: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putEq(!rs.eqOption(rs.cellBy(Quirky.eq$cmp_PartialEq))(_461, _464), log, out); + const _470: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _473: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putEq(rs.cmpOption(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_470, _473) === -1, log, out); + const _479: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _482: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + const order7 = rs.cmpOption(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_479, _482); putEq(order7 !== undefined && order7 <= 0, log, out); - const _488: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _491: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putEq(rt.cmpOption(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_488, _491) === 1, log, out); - const _497: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _500: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - const order8 = rt.cmpOption(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_497, _500); + const _488: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _491: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putEq(rs.cmpOption(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_488, _491) === 1, log, out); + const _497: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _500: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + const order8 = rs.cmpOption(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_497, _500); putEq(order8 !== undefined && order8 >= 0, log, out); - const _506: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _509: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putOrder(rt.cmpOption(rt.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_506, _509), log, out); - const _515: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(x)); - const _518: rt.Cell | undefined = new rt.Cell(copy$collections_Quirky(y)); - putCmp(rt.cmpOption(rt.cellBy(Quirky.cmp$cmp_Ord))(_515, _518), log, out); - const _524: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _527: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(rt.eqTuple([rt.refCellBy(Quirky.eq$cmp_PartialEq), Quirky.eq$cmp_PartialEq])(_524, _527), log, out); - const _533: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _536: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(!rt.eqTuple([rt.refCellBy(Quirky.eq$cmp_PartialEq), (a: Quirky.Quirky, b: Quirky.Quirky): boolean => { + const _506: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _509: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putOrder(rs.cmpOption(rs.cellBy(Quirky.partialCmp$cmp_PartialOrd))(_506, _509), log, out); + const _515: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(x)); + const _518: rs.Cell | undefined = new rs.Cell(copy$collections_Quirky(y)); + putCmp(rs.cmpOption(rs.cellBy(Quirky.cmp$cmp_Ord))(_515, _518), log, out); + const _524: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _527: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(rs.eqTuple([rs.refCellBy(Quirky.eq$cmp_PartialEq), Quirky.eq$cmp_PartialEq])(_524, _527), log, out); + const _533: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _536: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(!rs.eqTuple([rs.refCellBy(Quirky.eq$cmp_PartialEq), (a: Quirky.Quirky, b: Quirky.Quirky): boolean => { return !Quirky.ne$cmp_PartialEq(a, b); }])(_533, _536), log, out); - const _542: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _545: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(rt.testTuple([rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.lt$cmp_PartialOrd, -1)(_542, _545), log, out); - const _551: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _554: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(rt.testTuple([rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.le$cmp_PartialOrd, -1)(_551, _554), log, out); - const _560: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _563: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(rt.testTuple([rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.gt$cmp_PartialOrd, 1)(_560, _563), log, out); - const _569: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _572: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putEq(rt.testTuple([rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.ge$cmp_PartialOrd, 1)(_569, _572), log, out); - const _578: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _581: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putOrder(rt.cmpTuple<[rt.RefCell, Quirky.Quirky], rt.Ordering | undefined>([rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd), Quirky.partialCmp$cmp_PartialOrd])(_578, _581), log, out); - const _587: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(x)), x]; - const _590: [rt.RefCell, Quirky.Quirky] = [new rt.RefCell(copy$collections_Quirky(y)), y]; - putCmp(rt.cmpTuple<[rt.RefCell, Quirky.Quirky], rt.Ordering>([rt.refCellBy(Quirky.cmp$cmp_Ord), Quirky.cmp$cmp_Ord])(_587, _590), log, out); - const _595: [rt.Vec, rt.Vec] = [rt.vecFrom(copy$array_collections_Quirky([x, y, x]).map(copy$collections_Quirky)), rt.vecFrom(copy$array_collections_Quirky([y, y, x]).map(copy$collections_Quirky))]; - const va: rt.Vec = _595[0]; - const vb: rt.Vec = _595[1]; - const _603: rt.RefCell> = new rt.RefCell(rt.vecFrom(va.items.map(copy$collections_Quirky))); - const _607: rt.RefCell> = new rt.RefCell(rt.vecFrom(vb.items.map(copy$collections_Quirky))); - putEq(rt.refCellBy(rt.eqSlice((a2: Quirky.Quirky, b2: Quirky.Quirky): boolean => { + const _542: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _545: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(rs.testTuple([rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.lt$cmp_PartialOrd, -1)(_542, _545), log, out); + const _551: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _554: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(rs.testTuple([rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.le$cmp_PartialOrd, -1)(_551, _554), log, out); + const _560: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _563: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(rs.testTuple([rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.gt$cmp_PartialOrd, 1)(_560, _563), log, out); + const _569: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _572: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putEq(rs.testTuple([rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)], Quirky.ge$cmp_PartialOrd, 1)(_569, _572), log, out); + const _578: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _581: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putOrder(rs.cmpTuple<[rs.RefCell, Quirky.Quirky], rs.Ordering | undefined>([rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd), Quirky.partialCmp$cmp_PartialOrd])(_578, _581), log, out); + const _587: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(x)), x]; + const _590: [rs.RefCell, Quirky.Quirky] = [new rs.RefCell(copy$collections_Quirky(y)), y]; + putCmp(rs.cmpTuple<[rs.RefCell, Quirky.Quirky], rs.Ordering>([rs.refCellBy(Quirky.cmp$cmp_Ord), Quirky.cmp$cmp_Ord])(_587, _590), log, out); + const _595: [rs.Vec, rs.Vec] = [rs.vecFrom(copy$array_collections_Quirky([x, y, x]).map(copy$collections_Quirky)), rs.vecFrom(copy$array_collections_Quirky([y, y, x]).map(copy$collections_Quirky))]; + const va: rs.Vec = _595[0]; + const vb: rs.Vec = _595[1]; + const _603: rs.RefCell> = new rs.RefCell(rs.vecFrom(va.items.map(copy$collections_Quirky))); + const _607: rs.RefCell> = new rs.RefCell(rs.vecFrom(vb.items.map(copy$collections_Quirky))); + putEq(rs.refCellBy(rs.eqSlice((a2: Quirky.Quirky, b2: Quirky.Quirky): boolean => { return !Quirky.ne$cmp_PartialEq(a2, b2); }))(_603, _607), log, out); - const _614: rt.Cell = new rt.Cell(rt.sliceRange(va.items, 0)); - const _618: rt.Cell = new rt.Cell(rt.sliceRange(vb.items, 0)); - putEq(!rt.cellBy(rt.eqSlice((a3: Quirky.Quirky, b3: Quirky.Quirky): boolean => { + const _614: rs.Cell = new rs.Cell(rs.sliceRange(va.items, 0)); + const _618: rs.Cell = new rs.Cell(rs.sliceRange(vb.items, 0)); + putEq(!rs.cellBy(rs.eqSlice((a3: Quirky.Quirky, b3: Quirky.Quirky): boolean => { return !Quirky.ne$cmp_PartialEq(a3, b3); }))(_614, _618), log, out); - const _625: rt.Vec> = each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure2(va.items, (_2: Quirky.Quirky): rt.Cell => { - return new rt.Cell(copy$collections_Quirky(copy$collections_Quirky(_2))); + const _625: rs.Vec> = each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure2(va.items, (_2: Quirky.Quirky): rs.Cell => { + return new rs.Cell(copy$collections_Quirky(copy$collections_Quirky(_2))); }); - const _629: rt.Vec> = each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure3(vb.items, (_22: Quirky.Quirky): rt.Cell => { - return new rt.Cell(copy$collections_Quirky(copy$collections_Quirky(_22))); + const _629: rs.Vec> = each$collections_Quirky_Cell_collections_Quirky_collections_cell_eqs_closure3(vb.items, (_22: Quirky.Quirky): rs.Cell => { + return new rs.Cell(copy$collections_Quirky(copy$collections_Quirky(_22))); }); - putEq(rt.eqSlice(rt.cellBy(Quirky.eq$cmp_PartialEq))(_625, _629), log, out); - const _636: rt.Vec> = each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure4(va.items, (_26: Quirky.Quirky): rt.RefCell => { - return new rt.RefCell(copy$collections_Quirky(copy$collections_Quirky(_26))); + putEq(rs.eqSlice(rs.cellBy(Quirky.eq$cmp_PartialEq))(_625, _629), log, out); + const _636: rs.Vec> = each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure4(va.items, (_26: Quirky.Quirky): rs.RefCell => { + return new rs.RefCell(copy$collections_Quirky(copy$collections_Quirky(_26))); }); - const _640: rt.Vec> = each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure5(vb.items, (_28: Quirky.Quirky): rt.RefCell => { - return new rt.RefCell(copy$collections_Quirky(copy$collections_Quirky(_28))); + const _640: rs.Vec> = each$collections_Quirky_cell_RefCell_collections_Quirky_collections_cell_eqs_closure5(vb.items, (_28: Quirky.Quirky): rs.RefCell => { + return new rs.RefCell(copy$collections_Quirky(copy$collections_Quirky(_28))); }); - putEq(!rt.eqSlice(rt.refCellBy(Quirky.eq$cmp_PartialEq))(_636, _640), log, out); - const _647: [rt.Cell, rt.RefCell] = [new rt.Cell(copy$collections_Quirky(x)), new rt.RefCell(copy$collections_Quirky(y))]; - const _651: [rt.Cell, rt.RefCell] = [new rt.Cell(copy$collections_Quirky(y)), new rt.RefCell(copy$collections_Quirky(x))]; - putEq(!rt.eqTuple([rt.cellBy(Quirky.eq$cmp_PartialEq), rt.refCellBy(Quirky.eq$cmp_PartialEq)])(_647, _651), log, out); - const _658: rt.Arc> = new rt.Arc(new rt.RefCell(copy$collections_Quirky(x))); - const _661: rt.Arc> = new rt.Arc(new rt.RefCell(copy$collections_Quirky(y))); - putEq(!rt.eqArc(rt.refCellBy(Quirky.eq$cmp_PartialEq), true)(_658, _661), log, out); + putEq(!rs.eqSlice(rs.refCellBy(Quirky.eq$cmp_PartialEq))(_636, _640), log, out); + const _647: [rs.Cell, rs.RefCell] = [new rs.Cell(copy$collections_Quirky(x)), new rs.RefCell(copy$collections_Quirky(y))]; + const _651: [rs.Cell, rs.RefCell] = [new rs.Cell(copy$collections_Quirky(y)), new rs.RefCell(copy$collections_Quirky(x))]; + putEq(!rs.eqTuple([rs.cellBy(Quirky.eq$cmp_PartialEq), rs.refCellBy(Quirky.eq$cmp_PartialEq)])(_647, _651), log, out); + const _658: rs.Arc> = new rs.Arc(new rs.RefCell(copy$collections_Quirky(x))); + const _661: rs.Arc> = new rs.Arc(new rs.RefCell(copy$collections_Quirky(y))); + putEq(!rs.eqArc(rs.refCellBy(Quirky.eq$cmp_PartialEq), true)(_658, _661), log, out); _661[Symbol.dispose](); _658[Symbol.dispose](); - putEq(copy$collections_Quirky(rt.ordMax(new rt.Cell(copy$collections_Quirky(x)), new rt.Cell(copy$collections_Quirky(y)), rt.cellBy(Quirky.lt$cmp_PartialOrd)).v)._0 === x._0, log, out); - const _679: rt.RefCell = rt.refCellBorrow(rt.ordMin(new rt.RefCell(copy$collections_Quirky(x)), new rt.RefCell(copy$collections_Quirky(y)), rt.refCellBy(Quirky.lt$cmp_PartialOrd))); + putEq(copy$collections_Quirky(rs.ordMax(new rs.Cell(copy$collections_Quirky(x)), new rs.Cell(copy$collections_Quirky(y)), rs.cellBy(Quirky.lt$cmp_PartialOrd)).v)._0 === x._0, log, out); + const _679: rs.RefCell = rs.refCellBorrow(rs.ordMin(new rs.RefCell(copy$collections_Quirky(x)), new rs.RefCell(copy$collections_Quirky(y)), rs.refCellBy(Quirky.lt$cmp_PartialOrd))); putEq(_679.value._0 === x._0, log, out); - rt.refRelease(_679); - if (!(rt.u16Rem(x._0, 6) <= rt.u16Rem(y._0, 6))) { + rs.refRelease(_679); + if (!(rs.u16Rem(x._0, 6) <= rs.u16Rem(y._0, 6))) { _688 = [y, x] as [Quirky.Quirky, Quirky.Quirky]; } else { _688 = [x, y] as [Quirky.Quirky, Quirky.Quirky]; } const lo: Quirky.Quirky = _688[0]; const hi: Quirky.Quirky = _688[1]; - rt.byteVecPush(out, copy$collections_Quirky(rt.ordClamp(new rt.Cell({ _0: at(2), _1: log }), new rt.Cell(copy$collections_Quirky(lo)), new rt.Cell(copy$collections_Quirky(hi)), rt.cellBy(Quirky.le$cmp_PartialOrd), rt.cellBy(Quirky.lt$cmp_PartialOrd), rt.cellBy(Quirky.gt$cmp_PartialOrd)).v)._0 & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.cellReplace(log, 0)).reverse()), undefined, true); - const once: (a0: rt.usize, a1: Quirky.Quirky) => rt.OnceCell = (i3: rt.usize, v: Quirky.Quirky): rt.OnceCell => { - const cell: rt.OnceCell = new rt.OnceCell(undefined); - if (rt.u16Rem(at(i3), 4) !== 0) { - rt.onceSet(cell, copy$collections_Quirky(v)); + rs.byteVecPush(out, copy$collections_Quirky(rs.ordClamp(new rs.Cell({ _0: at(2), _1: log }), new rs.Cell(copy$collections_Quirky(lo)), new rs.Cell(copy$collections_Quirky(hi)), rs.cellBy(Quirky.le$cmp_PartialOrd), rs.cellBy(Quirky.lt$cmp_PartialOrd), rs.cellBy(Quirky.gt$cmp_PartialOrd)).v)._0 & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log, 0)).reverse()), undefined, true); + const once: (a0: rs.usize, a1: Quirky.Quirky) => rs.OnceCell = (i3: rs.usize, v: Quirky.Quirky): rs.OnceCell => { + const cell: rs.OnceCell = new rs.OnceCell(undefined); + if (rs.u16Rem(at(i3), 4) !== 0) { + rs.onceSet(cell, copy$collections_Quirky(v)); return cell; } return cell; }; - const _719: rt.OnceCell = once(2, x); - const _723: rt.OnceCell = once(3, y); - putEq(rt.cellBy(rt.eqOption(Quirky.eq$cmp_PartialEq))(_719, _723), log, out); - const _730: rt.OnceCell = once(2, x); - const _734: rt.OnceCell = once(3, y); - putEq(!rt.cellBy(rt.eqOption(Quirky.eq$cmp_PartialEq))(_730, _734), log, out); - const _741: rt.OnceCell = new rt.OnceCell(maybe(0)); - const _746: rt.OnceCell = new rt.OnceCell(maybe(1)); - putEq(rt.cellBy(rt.same)(_741, _746), log, out); - const lock: (a0: rt.usize, a1: Quirky.Quirky) => rt.OnceLock = (i4: rt.usize, v2: Quirky.Quirky): rt.OnceLock => { - const lock2: rt.OnceLock = new rt.OnceLock(undefined); - if (rt.u16Rem(at(i4), 4) !== 1) { - rt.onceSet(lock2, copy$collections_Quirky(v2)); + const _719: rs.OnceCell = once(2, x); + const _723: rs.OnceCell = once(3, y); + putEq(rs.cellBy(rs.eqOption(Quirky.eq$cmp_PartialEq))(_719, _723), log, out); + const _730: rs.OnceCell = once(2, x); + const _734: rs.OnceCell = once(3, y); + putEq(!rs.cellBy(rs.eqOption(Quirky.eq$cmp_PartialEq))(_730, _734), log, out); + const _741: rs.OnceCell = new rs.OnceCell(maybe(0)); + const _746: rs.OnceCell = new rs.OnceCell(maybe(1)); + putEq(rs.cellBy(rs.same)(_741, _746), log, out); + const lock: (a0: rs.usize, a1: Quirky.Quirky) => rs.OnceLock = (i4: rs.usize, v2: Quirky.Quirky): rs.OnceLock => { + const lock2: rs.OnceLock = new rs.OnceLock(undefined); + if (rs.u16Rem(at(i4), 4) !== 1) { + rs.onceSet(lock2, copy$collections_Quirky(v2)); return lock2; } return lock2; }; - const _756: rt.OnceLock = lock(2, x); - const _760: rt.OnceLock = lock(3, y); - putEq(!rt.cellBy(rt.eqOption(Quirky.eq$cmp_PartialEq))(_756, _760), log, out); - const _767: rt.OnceCell> = new rt.OnceCell(new rt.RefCell(copy$collections_Quirky(x))); - const _770: rt.OnceCell> = new rt.OnceCell(new rt.RefCell(copy$collections_Quirky(y))); - putEq(!rt.cellBy(rt.eqOption(rt.refCellBy(Quirky.eq$cmp_PartialEq)))(_767, _770), log, out); - const _774: rt.Iter> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.Cell => { - return new rt.Cell(rt.u8Rem(_29, 8)); + const _756: rs.OnceLock = lock(2, x); + const _760: rs.OnceLock = lock(3, y); + putEq(!rs.cellBy(rs.eqOption(Quirky.eq$cmp_PartialEq))(_756, _760), log, out); + const _767: rs.OnceCell> = new rs.OnceCell(new rs.RefCell(copy$collections_Quirky(x))); + const _770: rs.OnceCell> = new rs.OnceCell(new rs.RefCell(copy$collections_Quirky(y))); + putEq(!rs.cellBy(rs.eqOption(rs.refCellBy(Quirky.eq$cmp_PartialEq)))(_767, _770), log, out); + const _774: rs.Iter> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.Cell => { + return new rs.Cell(rs.u8Rem(_29, 8)); }); - const set: rt.BTreeSet> = rt.btreeExtendKeys(rt.btreeNew(rt.cellBy(rt.cmp)) as rt.BTreeSet>, _774, true, undefined, undefined, 1, true); - rt.byteVecPush(out, rt.btreeLen(set) & 0xff); - const _785: rt.Cell = new rt.Cell(rt.u8Rem(at(0) & 0xff, 8)); - rt.byteVecPush(out, rt.btreeContains(set, _785) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set), (c: rt.Cell): rt.u8 => { + const set: rs.BTreeSet> = rs.btreeExtendKeys(rs.btreeNew(rs.cellBy(rs.cmp)) as rs.BTreeSet>, _774, true, undefined, undefined, 1, true); + rs.byteVecPush(out, rs.btreeLen(set) & 0xff); + const _785: rs.Cell = new rs.Cell(rs.u8Rem(at(0) & 0xff, 8)); + rs.byteVecPush(out, rs.btreeContains(set, _785) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set), (c: rs.Cell): rs.u8 => { return c.v; }), undefined, true); - const _797: rt.Iter<[rt.RefCell, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_213: [rt.usize, rt.u8]): [rt.RefCell, rt.usize] => { - const i5: rt.usize = _213[0]; - return [new rt.RefCell(rt.u8Rem(_213[1], 8)), i5] as [rt.RefCell, rt.usize]; + const _797: rs.Iter<[rs.RefCell, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_213: [rs.usize, rs.u8]): [rs.RefCell, rs.usize] => { + const i5: rs.usize = _213[0]; + return [new rs.RefCell(rs.u8Rem(_213[1], 8)), i5] as [rs.RefCell, rs.usize]; }); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.btreeGet(rt.btreeExtend(rt.btreeNew(rt.refCellBy(rt.cmp)) as rt.BTreeMap, rt.usize>, _797, true, undefined, undefined, undefined, 12, true), new rt.RefCell(rt.u8Rem(at(1) & 0xff, 8))), 255, (_215: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.btreeGet(rs.btreeExtend(rs.btreeNew(rs.refCellBy(rs.cmp)) as rs.BTreeMap, rs.usize>, _797, true, undefined, undefined, undefined, 12, true), new rs.RefCell(rs.u8Rem(at(1) & 0xff, 8))), 255, (_215: rs.usize): rs.u8 => { return _215 & 0xff; })); - const _814: rt.RefCell = rt.refCellBorrowMut(ra); + const _814: rs.RefCell = rs.refCellBorrowMut(ra); _814.value = copy$collections_Quirky(y); - rt.refMutRelease(_814); - const _821: rt.RefCell> = rt.refCellBorrowMut(rra); - const _818: rt.RefCell = rt.refCellBorrowMut(_821.value); + rs.refMutRelease(_814); + const _821: rs.RefCell> = rs.refCellBorrowMut(rra); + const _818: rs.RefCell = rs.refCellBorrowMut(_821.value); _818.value = copy$collections_Quirky(x); - rt.refMutRelease(_818); - rt.refMutRelease(_821); - const _828: rt.RefCell> = rt.refCellBorrow(rra); - const _826: rt.RefCell = _828.value; - putEq(rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, _826), log, out); - rt.refRelease(_828); - const _836: rt.RefCell> = rt.refCellBorrow(rra); - const _834: rt.RefCell = _836.value; - putEq(!rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, _834), log, out); - rt.refRelease(_836); - const _844: rt.RefCell> = rt.refCellBorrow(rra); - const _842: rt.RefCell = _844.value; - putEq(rt.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, _842), log, out); - rt.refRelease(_844); - const _852: rt.RefCell> = rt.refCellBorrow(rra); - const _850: rt.RefCell = _852.value; - putEq(rt.refCellBy(Quirky.le$cmp_PartialOrd)(ra, _850), log, out); - rt.refRelease(_852); - const _860: rt.RefCell> = rt.refCellBorrow(rra); - const _858: rt.RefCell = _860.value; - putEq(rt.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, _858), log, out); - rt.refRelease(_860); - const _868: rt.RefCell> = rt.refCellBorrow(rra); - const _866: rt.RefCell = _868.value; - putEq(rt.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, _866), log, out); - rt.refRelease(_868); - const _876: rt.RefCell> = rt.refCellBorrow(rra); - const _874: rt.RefCell = _876.value; - putOrder(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, _874), log, out); - rt.refRelease(_876); - const _884: rt.RefCell> = rt.refCellBorrow(rra); - const _882: rt.RefCell = _884.value; - putCmp(rt.refCellBy(Quirky.cmp$cmp_Ord)(ra, _882), log, out); - rt.refRelease(_884); - const shared: rt.Arc> = new rt.Arc(new rt.RefCell(copy$collections_Quirky(x))); + rs.refMutRelease(_818); + rs.refMutRelease(_821); + const _828: rs.RefCell> = rs.refCellBorrow(rra); + const _826: rs.RefCell = _828.value; + putEq(rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, _826), log, out); + rs.refRelease(_828); + const _836: rs.RefCell> = rs.refCellBorrow(rra); + const _834: rs.RefCell = _836.value; + putEq(!rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, _834), log, out); + rs.refRelease(_836); + const _844: rs.RefCell> = rs.refCellBorrow(rra); + const _842: rs.RefCell = _844.value; + putEq(rs.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, _842), log, out); + rs.refRelease(_844); + const _852: rs.RefCell> = rs.refCellBorrow(rra); + const _850: rs.RefCell = _852.value; + putEq(rs.refCellBy(Quirky.le$cmp_PartialOrd)(ra, _850), log, out); + rs.refRelease(_852); + const _860: rs.RefCell> = rs.refCellBorrow(rra); + const _858: rs.RefCell = _860.value; + putEq(rs.refCellBy(Quirky.gt$cmp_PartialOrd)(ra, _858), log, out); + rs.refRelease(_860); + const _868: rs.RefCell> = rs.refCellBorrow(rra); + const _866: rs.RefCell = _868.value; + putEq(rs.refCellBy(Quirky.ge$cmp_PartialOrd)(ra, _866), log, out); + rs.refRelease(_868); + const _876: rs.RefCell> = rs.refCellBorrow(rra); + const _874: rs.RefCell = _876.value; + putOrder(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd)(ra, _874), log, out); + rs.refRelease(_876); + const _884: rs.RefCell> = rs.refCellBorrow(rra); + const _882: rs.RefCell = _884.value; + putCmp(rs.refCellBy(Quirky.cmp$cmp_Ord)(ra, _882), log, out); + rs.refRelease(_884); + const shared: rs.Arc> = new rs.Arc(new rs.RefCell(copy$collections_Quirky(x))); b1: { - const _890: rt.u8 = rt.u8Rem(kind, 6); + const _890: rs.u8 = rs.u8Rem(kind, 6); if (_890 === 0) { shared[Symbol.dispose](); break b1; } if (_890 === 1) { - _mutable = rt.refCellBorrowMut(ra); + _mutable = rs.refCellBorrowMut(ra); } else if (_890 === 2) { - _mutable = rt.refCellBorrowMut(rb); + _mutable = rs.refCellBorrowMut(rb); } else { - _mutable = rt.refCellBorrowMut(shared.value); + _mutable = rs.refCellBorrowMut(shared.value); } - const _897: rt.u8 = rt.u8Rem(kind, 6); + const _897: rs.u8 = rs.u8Rem(kind, 6); if (_897 === 1) { - putEq(rt.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.eq$cmp_PartialEq)(ra, rb), log, out); } else if (_897 === 2) { - putEq(rt.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, rb), log, out); + putEq(rs.refCellBy(Quirky.lt$cmp_PartialOrd)(ra, rb), log, out); } else if (_897 === 3) { - const _910: rt.Arc> = rt.arcClone(shared); - putEq(rt.eqArc(rt.refCellBy(Quirky.eq$cmp_PartialEq), true)(shared, _910), log, out); + const _910: rs.Arc> = rs.arcClone(shared); + putEq(rs.eqArc(rs.refCellBy(Quirky.eq$cmp_PartialEq), true)(shared, _910), log, out); _910[Symbol.dispose](); } else if (_897 === 4) { - const _916: rt.Arc> = new rt.Arc(new rt.RefCell(copy$collections_Quirky(y))); - putEq(!rt.eqArc(rt.refCellBy(Quirky.eq$cmp_PartialEq), true)(shared, _916), log, out); + const _916: rs.Arc> = new rs.Arc(new rs.RefCell(copy$collections_Quirky(y))); + putEq(!rs.eqArc(rs.refCellBy(Quirky.eq$cmp_PartialEq), true)(shared, _916), log, out); _916[Symbol.dispose](); } else { - const _922: rt.Arc> = rt.arcClone(shared); - putOrder(rt.cmpArc(rt.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(shared, _922), log, out); + const _922: rs.Arc> = rs.arcClone(shared); + putOrder(rs.cmpArc(rs.refCellBy(Quirky.partialCmp$cmp_PartialOrd))(shared, _922), log, out); _922[Symbol.dispose](); } - const held2: rt.RefCell> = rt.refCellBorrow(rra); - const _inner2: rt.RefCell = rt.refCellBorrowMut(held2.value); - putEq(rt.refCellBy(rt.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); - rt.refMutRelease(_inner2); - rt.refRelease(held2); - rt.refMutRelease(_mutable); + const held2: rs.RefCell> = rs.refCellBorrow(rra); + const _inner2: rs.RefCell = rs.refCellBorrowMut(held2.value); + putEq(rs.refCellBy(rs.refCellBy(Quirky.eq$cmp_PartialEq))(rra, rrb), log, out); + rs.refMutRelease(_inner2); + rs.refRelease(held2); + rs.refMutRelease(_mutable); shared[Symbol.dispose](); } } @@ -4653,77 +4653,77 @@ export function cellEqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * what they point at, against a reference by the impl against it, and of byte arrays, * both by value and through references. */ -export function unlikeCompares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _9: (a0: rt.Ordering | undefined, a1: rt.Cell, a2: rt.ByteVec) => undefined = (o: rt.Ordering | undefined, log2: rt.Cell, out2: rt.ByteVec): undefined => { - rt.byteVecPush(out2, option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function unlikeCompares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _9: (a0: rs.Ordering | undefined, a1: rs.Cell, a2: rs.ByteVec) => undefined = (o: rs.Ordering | undefined, log2: rs.Cell, out2: rs.ByteVec): undefined => { + rs.byteVecPush(out2, option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; })); - rt.iterExtendBytes(out2, rt.iterSlice(rt.u16ToBeBytes(rt.cellReplace(log2, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out2, rs.iterSlice(rs.u16ToBeBytes(rs.cellReplace(log2, 0)).reverse()), undefined, true); }; - const log: rt.Cell = new rt.Cell(0); - const lefts: () => rt.Vec = (): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Left.Left => { - return { _0: _25 as rt.u16, _1: log }; + const log: rs.Cell = new rs.Cell(0); + const lefts: () => rs.Vec = (): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): Left.Left => { + return { _0: _25 as rs.u16, _1: log }; }), undefined, 8, true); }; - const rights_: () => rt.Vec = (): rt.Vec => { + const rights_: () => rs.Vec = (): rs.Vec => { return rights(kind, data); }; - const _12: [rt.Vec, rt.Vec] = [lefts(), rights_()]; - const mine: rt.Vec = _12[0]; - const theirs: rt.Vec = _12[1]; - const refs: rt.Vec = rt.iterToVec(rt.iterSlice(theirs.items), undefined, 4, true); - putEq(rt.iterEq(rt.iterSlice(mine.items), rt.iterSlice(theirs.items), Left.eq$cmp_PartialEq_collections_Right, true), log, out); - putEq(!rt.iterEq(rt.iterSlice(mine.items), rt.iterSlice(theirs.items), Left.eq$cmp_PartialEq_collections_Right, true), log, out); - putEq(rt.iterEq(rt.vecIntoIter(lefts()), rt.vecIntoIter(rights_()), Left.eq$cmp_PartialEq_collections_Right, true), log, out); - putEq(rt.iterEq(rt.vecIntoIter(lefts()), rt.iterSlice(refs.items), Left.eq$cmp_PartialEq_ref_collections_Right, true), log, out); - putEq(!rt.iterEq(rt.vecIntoIter(lefts()), rt.iterSlice(mine.items), Left.eq$cmp_PartialEq_ref_collections_Left, true), log, out); - const odds: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): Odd.Odd => { - return { _0: _27 as rt.u16 }; + const _12: [rs.Vec, rs.Vec] = [lefts(), rights_()]; + const mine: rs.Vec = _12[0]; + const theirs: rs.Vec = _12[1]; + const refs: rs.Vec = rs.iterToVec(rs.iterSlice(theirs.items), undefined, 4, true); + putEq(rs.iterEq(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.eq$cmp_PartialEq_collections_Right, true), log, out); + putEq(!rs.iterEq(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.eq$cmp_PartialEq_collections_Right, true), log, out); + putEq(rs.iterEq(rs.vecIntoIter(lefts()), rs.vecIntoIter(rights_()), Left.eq$cmp_PartialEq_collections_Right, true), log, out); + putEq(rs.iterEq(rs.vecIntoIter(lefts()), rs.iterSlice(refs.items), Left.eq$cmp_PartialEq_ref_collections_Right, true), log, out); + putEq(!rs.iterEq(rs.vecIntoIter(lefts()), rs.iterSlice(mine.items), Left.eq$cmp_PartialEq_ref_collections_Left, true), log, out); + const odds: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): Odd.Odd => { + return { _0: _27 as rs.u16 }; }), undefined, 2, true); - putEq(rt.iterEq(rt.iterSlice(odds.items), rt.iterSlice(refs.items), Odd.eq$cmp_PartialEq_ref_collections_Right_ref, true), log, out); - const part = rt.iterCmp(rt.iterSlice(odds.items), rt.iterRev(rt.iterSlice(odds.items)), Odd.partialCmp$cmp_PartialOrd_ref); + putEq(rs.iterEq(rs.iterSlice(odds.items), rs.iterSlice(refs.items), Odd.eq$cmp_PartialEq_ref_collections_Right_ref, true), log, out); + const part = rs.iterCmp(rs.iterSlice(odds.items), rs.iterRev(rs.iterSlice(odds.items)), Odd.partialCmp$cmp_PartialOrd_ref); _9(part, log, out); - putEq(rt.iterEq(rt.iterSlice(rt.byteSliceView(data)), rt.vecIntoIter(rights_()), eq$cmp_PartialEq_collections_Right_u8, true), log, out); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _35: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + putEq(rs.iterEq(rs.iterSlice(rs.byteSliceView(data)), rs.vecIntoIter(rights_()), eq$cmp_PartialEq_collections_Right_u8, true), log, out); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _35: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_35, c.data[c.start + 1]); }), undefined, 2, true); - putEq(rt.iterEq(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.vecIntoIter(rights_()), (a: Uint8Array, b3: Right.Right): boolean => { - return ((a0: rt.ByteSlice, a1: Right.Right): boolean => { + putEq(rs.iterEq(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a: Uint8Array, b3: Right.Right): boolean => { + return ((a0: rs.ByteSlice, a1: Right.Right): boolean => { return eq$cmp_PartialEq_collections_Right_array2_u8(a0.data, a0.start, a0.length, a1); - })(rt.byteSliceFrom(a), b3); + })(rs.byteSliceFrom(a), b3); }, true), log, out); - putEq(rt.iterEq(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.iterSlice(theirs.items), (a02: rt.ByteSlice, a12: Right.Right): boolean => { + putEq(rs.iterEq(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterSlice(theirs.items), (a02: rs.ByteSlice, a12: Right.Right): boolean => { return eq$cmp_PartialEq_collections_Right_array2_u8(a02.data, a02.start, a02.length, a12); }, true), log, out); - const part3 = rt.iterCmp(rt.iterSlice(mine.items), rt.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); + const part3 = rs.iterCmp(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); _9(part3, log, out); - const part5 = rt.iterCmp(rt.vecIntoIter(lefts()), rt.vecIntoIter(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right); + const part5 = rs.iterCmp(rs.vecIntoIter(lefts()), rs.vecIntoIter(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right); _9(part5, log, out); - putEq(rt.iterCmp(rt.vecIntoIter(lefts()), rt.vecIntoIter(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right) === -1, log, out); - const order = rt.iterCmp(rt.iterSlice(mine.items), rt.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); + putEq(rs.iterCmp(rs.vecIntoIter(lefts()), rs.vecIntoIter(rights_()), Left.partialCmp$cmp_PartialOrd_collections_Right) === -1, log, out); + const order = rs.iterCmp(rs.iterSlice(mine.items), rs.iterSlice(theirs.items), Left.partialCmp$cmp_PartialOrd_collections_Right); putEq(order !== undefined && order >= 0, log, out); - const part7 = rt.iterCmp(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.vecIntoIter(rights_()), (a2: Uint8Array, b4: Right.Right): rt.Ordering | undefined => { - return ((a03: rt.ByteSlice, a13: Right.Right): rt.Ordering | undefined => { + const part7 = rs.iterCmp(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.vecIntoIter(rights_()), (a2: Uint8Array, b4: Right.Right): rs.Ordering | undefined => { + return ((a03: rs.ByteSlice, a13: Right.Right): rs.Ordering | undefined => { return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a03.data, a03.start, a03.length, a13); - })(rt.byteSliceFrom(a2), b4); + })(rs.byteSliceFrom(a2), b4); }); _9(part7, log, out); - const part9 = rt.iterCmp(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.iterSlice(theirs.items), (a04: rt.ByteSlice, a14: Right.Right): rt.Ordering | undefined => { + const part9 = rs.iterCmp(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterSlice(theirs.items), (a04: rs.ByteSlice, a14: Right.Right): rs.Ordering | undefined => { return partialCmp$cmp_PartialOrd_collections_Right_array2_u8(a04.data, a04.start, a04.length, a14); }); _9(part9, log, out); } export function eq$cmp_PartialEq_boxed_Box_collections_Boxed(self: Boxed.Boxed, other: Boxed.Boxed): boolean { - return rt.u16Rem(self._0, 2) === rt.u16Rem(other._0, 2); + return rs.u16Rem(self._0, 2) === rs.u16Rem(other._0, 2); } -export function partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed(self: Boxed.Boxed, other: Boxed.Boxed): rt.Ordering | undefined { - return rt.cmp(rt.u16Rem(self._0, 3), rt.u16Rem(other._0, 3)); +export function partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed(self: Boxed.Boxed, other: Boxed.Boxed): rs.Ordering | undefined { + return rs.cmp(rs.u16Rem(self._0, 3), rs.u16Rem(other._0, 3)); } /** @@ -4731,924 +4731,924 @@ export function partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed(self: Boxe * impls: `&ByRef`'s, `ByVal`'s through `&ByVal`, `Mixed`'s and `&Mixed`'s, and each * through `&&T`. Then `Box`'s. */ -export function refOrders(_kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let data2!: rt.ByteSlice; +export function refOrders(_kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let data2!: rs.ByteSlice; if (!(data.length === 0)) { data2 = data; } else { - data2 = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(0)), 0); + data2 = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(0)), 0); } - const byRef: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): ByRef.ByRef => { - return { _0: _2 as rt.u16 }; + const byRef: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): ByRef.ByRef => { + return { _0: _2 as rs.u16 }; }), undefined, 2, true); - const byVal: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_29: rt.u8): ByVal.ByVal => { - return { _0: _29 as rt.u16 }; + const byVal: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_29: rs.u8): ByVal.ByVal => { + return { _0: _29 as rs.u16 }; }), undefined, 2, true); - const mixed: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_212: rt.u8): Mixed.Mixed => { - return { _0: _212 as rt.u16 }; + const mixed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_212: rs.u8): Mixed.Mixed => { + return { _0: _212 as rs.u16 }; }), undefined, 2, true); - const iter: rt.Iter<[rt.usize, rt.usize]> = rt.iterZip(new rt.Range(0, data2.length), rt.iterRev(new rt.Range(0, data2.length)), "len"); + const iter: rs.Iter<[rs.usize, rs.usize]> = rs.iterZip(new rs.Range(0, data2.length), rs.iterRev(new rs.Range(0, data2.length)), "len"); while (true) { - const _30: [rt.usize, rt.usize] | rt.Done = iter.next(); - if (_30 === rt.DONE) { + const _30: [rs.usize, rs.usize] | rs.Done = iter.next(); + if (_30 === rs.DONE) { break; } - const i: rt.usize = _30[0]; - const j: rt.usize = _30[1]; - const at = rt.idx(byRef.items, i); - const at2 = rt.idx(byRef.items, j); + const i: rs.usize = _30[0]; + const j: rs.usize = _30[1]; + const at = rs.idx(byRef.items, i); + const at2 = rs.idx(byRef.items, j); const part = byRef.items[at]; const part2 = byRef.items[at2]; const a: ByRef.ByRef = part; const b: ByRef.ByRef = part2; const _48: [ByRef.ByRef] = [a]; const _50: [ByRef.ByRef] = [b]; - const _46: boolean = rt.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_48, _50); + const _46: boolean = rs.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_48, _50); const _53: [ByRef.ByRef] = [a]; const _55: [ByRef.ByRef] = [b]; - const _51: boolean = !rt.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_53, _55); + const _51: boolean = !rs.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_53, _55); const _58: [ByRef.ByRef] = [a]; const _60: [ByRef.ByRef] = [b]; - const _56: boolean = rt.cmpTuple<[ByRef.ByRef], rt.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_58, _60) === -1; - const _63: [rt.u8, ByRef.ByRef] = [7, a]; - const _65: [rt.u8, ByRef.ByRef] = [7, b]; - const order = rt.cmpTuple<[rt.u8, ByRef.ByRef], rt.Ordering | undefined>([rt.cmp, ByRef.partialCmp$cmp_PartialOrd_ref])(_63, _65); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_46, _51, _56, order !== undefined && order >= 0], (a0: boolean): rt.u8 => { + const _56: boolean = rs.cmpTuple<[ByRef.ByRef], rs.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_58, _60) === -1; + const _63: [rs.u8, ByRef.ByRef] = [7, a]; + const _65: [rs.u8, ByRef.ByRef] = [7, b]; + const order = rs.cmpTuple<[rs.u8, ByRef.ByRef], rs.Ordering | undefined>([rs.cmp, ByRef.partialCmp$cmp_PartialOrd_ref])(_63, _65); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_46, _51, _56, order !== undefined && order >= 0], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); const _70: [ByRef.ByRef] = [a]; const _72: [ByRef.ByRef] = [b]; - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpTuple<[ByRef.ByRef], rt.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_70, _72))); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpTuple<[ByRef.ByRef], rs.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_70, _72))); const _78: [ByRef.ByRef] = [a]; const _80: [ByRef.ByRef] = [b]; - const _76: rt.Ordering = rt.cmpTuple<[ByRef.ByRef], rt.Ordering>([ByRef.cmp$cmp_Ord_ref])(_78, _80); - const _83: [rt.u8, ByRef.ByRef] = [7, a]; - const _85: [rt.u8, ByRef.ByRef] = [7, b]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_76, rt.cmpTuple<[rt.u8, ByRef.ByRef], rt.Ordering>([rt.cmp, ByRef.cmp$cmp_Ord_ref])(_83, _85)], cmpByte$ref_orders)), undefined, true); + const _76: rs.Ordering = rs.cmpTuple<[ByRef.ByRef], rs.Ordering>([ByRef.cmp$cmp_Ord_ref])(_78, _80); + const _83: [rs.u8, ByRef.ByRef] = [7, a]; + const _85: [rs.u8, ByRef.ByRef] = [7, b]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_76, rs.cmpTuple<[rs.u8, ByRef.ByRef], rs.Ordering>([rs.cmp, ByRef.cmp$cmp_Ord_ref])(_83, _85)], cmpByte$ref_orders)), undefined, true); const _91: ByRef.ByRef | undefined = a; const _93: ByRef.ByRef | undefined = b; - const _88: rt.u8 = orderByte$ref_orders(rt.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_91, _93)); + const _88: rs.u8 = orderByte$ref_orders(rs.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_91, _93)); const _97: ByRef.ByRef | undefined = a; const _99: ByRef.ByRef | undefined = b; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_88, cmpByte$ref_orders(rt.cmpOption(ByRef.cmp$cmp_Ord_ref)(_97, _99)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_88, cmpByte$ref_orders(rs.cmpOption(ByRef.cmp$cmp_Ord_ref)(_97, _99)))), undefined, true); const _105: ByRef.ByRef | undefined = a; const _107: ByRef.ByRef | undefined = b; - const _103: boolean = rt.eqOption(ByRef.eq$cmp_PartialEq_ref)(_105, _107); + const _103: boolean = rs.eqOption(ByRef.eq$cmp_PartialEq_ref)(_105, _107); const _110: ByRef.ByRef | undefined = a; const _112: ByRef.ByRef | undefined = b; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_103, rt.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_110, _112) === -1], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_103, rs.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_110, _112) === -1], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, result_eq$1dt73ez(rt.Ok(a), rt.Ok(b)) ? 1 : 0); + rs.byteVecPush(out, result_eq$1a91ieh(rs.Ok(a), rs.Ok(b)) ? 1 : 0); const _125: ByRef.ByRef[] = [a, b]; - const _123: ByRef.ByRef[] = rt.sliceRange(_125, 0); + const _123: ByRef.ByRef[] = rs.sliceRange(_125, 0); const _128: ByRef.ByRef[] = [b, a]; - const _126: ByRef.ByRef[] = rt.sliceRange(_128, 0); - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_123, _126))); + const _126: ByRef.ByRef[] = rs.sliceRange(_128, 0); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_123, _126))); const _134: ByRef.ByRef[] = [a, b]; const _136: ByRef.ByRef[] = [b, a]; - const _132: rt.Ordering = rt.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_134, _136); - const _139: rt.Vec = rt.vecFrom([a]); - const _142: rt.Vec = rt.vecFrom([b]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_132, rt.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_139, _142)], cmpByte$ref_orders)), undefined, true); + const _132: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_134, _136); + const _139: rs.Vec = rs.vecFrom([a]); + const _142: rs.Vec = rs.vecFrom([b]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_132, rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_139, _142)], cmpByte$ref_orders)), undefined, true); const _149: ByRef.ByRef[] = [a, b]; const _151: ByRef.ByRef[] = [b, a]; - const _147: boolean = rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_149, _151); + const _147: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_149, _151); const _155: ByRef.ByRef[] = [a]; - const _153: ByRef.ByRef[] = rt.sliceRange(_155, 0); + const _153: ByRef.ByRef[] = rs.sliceRange(_155, 0); const _158: ByRef.ByRef[] = [b]; - const _156: ByRef.ByRef[] = rt.sliceRange(_158, 0); - const _152: boolean = rt.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_153, _156) === -1; - const _161: rt.Vec = rt.vecFrom([a, b]); - const _164: rt.Vec = rt.vecFrom([b, a]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_147, _152, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a03: boolean): rt.u8 => { + const _156: ByRef.ByRef[] = rs.sliceRange(_158, 0); + const _152: boolean = rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_153, _156) === -1; + const _161: rs.Vec = rs.vecFrom([a, b]); + const _164: rs.Vec = rs.vecFrom([b, a]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_147, _152, !rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_161, _164)], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - const _170: rt.VecDeque = rt.dequeFromArray([a, b], 4) as rt.VecDeque; - const _173: rt.VecDeque = rt.dequeFromArray([b, a], 4) as rt.VecDeque; - rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); + const _170: rs.VecDeque = rs.dequeFromArray([a, b], 4) as rs.VecDeque; + const _173: rs.VecDeque = rs.dequeFromArray([b, a], 4) as rs.VecDeque; + rs.byteVecPush(out, rs.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_170, _173) ? 1 : 0); const _180: ByRef.ByRef = a; const _182: ByRef.ByRef = b; - const _177: rt.u8 = orderByte$ref_orders(rt.cmpReverse(ByRef.partialCmp$cmp_PartialOrd_ref)(_180, _182)); + const _177: rs.u8 = orderByte$ref_orders(rs.cmpReverse(ByRef.partialCmp$cmp_PartialOrd_ref)(_180, _182)); const _186: ByRef.ByRef = a; const _188: ByRef.ByRef = b; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_177, cmpByte$ref_orders(rt.cmpReverse(ByRef.cmp$cmp_Ord_ref)(_186, _188)))), undefined, true); - const _194: rt.Cell = new rt.Cell(a); - const _196: rt.Cell = new rt.Cell(b); - const _191: rt.u8 = orderByte$ref_orders(rt.cellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_194, _196)); - const _200: rt.RefCell = new rt.RefCell(a); - const _202: rt.RefCell = new rt.RefCell(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_191, cmpByte$ref_orders(rt.refCellBy(ByRef.cmp$cmp_Ord_ref)(_200, _202)))), undefined, true); - const _208: rt.Cell = new rt.Cell(a); - const _210: rt.Cell = new rt.Cell(b); - const _206: boolean = rt.cellBy(ByRef.eq$cmp_PartialEq_ref)(_208, _210); - const _213: rt.RefCell = new rt.RefCell(a); - const _215: rt.RefCell = new rt.RefCell(b); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_206, rt.refCellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_213, _215) === -1], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_177, cmpByte$ref_orders(rs.cmpReverse(ByRef.cmp$cmp_Ord_ref)(_186, _188)))), undefined, true); + const _194: rs.Cell = new rs.Cell(a); + const _196: rs.Cell = new rs.Cell(b); + const _191: rs.u8 = orderByte$ref_orders(rs.cellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_194, _196)); + const _200: rs.RefCell = new rs.RefCell(a); + const _202: rs.RefCell = new rs.RefCell(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_191, cmpByte$ref_orders(rs.refCellBy(ByRef.cmp$cmp_Ord_ref)(_200, _202)))), undefined, true); + const _208: rs.Cell = new rs.Cell(a); + const _210: rs.Cell = new rs.Cell(b); + const _206: boolean = rs.cellBy(ByRef.eq$cmp_PartialEq_ref)(_208, _210); + const _213: rs.RefCell = new rs.RefCell(a); + const _215: rs.RefCell = new rs.RefCell(b); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_206, rs.refCellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_213, _215) === -1], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(orderByte$ref_orders(rt.iterCmp(rt.iterSlice([a, b]), rt.iterSlice([b, a]), ByRef.partialCmp$cmp_PartialOrd_ref)), cmpByte$ref_orders(rt.iterCmp(rt.iterSlice([a]), rt.iterSlice([b]), ByRef.cmp$cmp_Ord_ref)))), undefined, true); - const _236: boolean = rt.iterEq(rt.iterSlice([a, b]), rt.iterSlice([b, a]), ByRef.eq$cmp_PartialEq_ref, true); - const _240: boolean = rt.iterCmp(rt.iterSlice([a]), rt.iterSlice([b]), ByRef.partialCmp$cmp_PartialOrd_ref) === -1; - const order2 = rt.iterCmp(rt.iterSlice([a]), rt.iterSlice([b]), ByRef.partialCmp$cmp_PartialOrd_ref); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_236, _240, order2 !== undefined && order2 >= 0], (a05: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(orderByte$ref_orders(rs.iterCmp(rs.iterSlice([a, b]), rs.iterSlice([b, a]), ByRef.partialCmp$cmp_PartialOrd_ref)), cmpByte$ref_orders(rs.iterCmp(rs.iterSlice([a]), rs.iterSlice([b]), ByRef.cmp$cmp_Ord_ref)))), undefined, true); + const _236: boolean = rs.iterEq(rs.iterSlice([a, b]), rs.iterSlice([b, a]), ByRef.eq$cmp_PartialEq_ref, true); + const _240: boolean = rs.iterCmp(rs.iterSlice([a]), rs.iterSlice([b]), ByRef.partialCmp$cmp_PartialOrd_ref) === -1; + const order2 = rs.iterCmp(rs.iterSlice([a]), rs.iterSlice([b]), ByRef.partialCmp$cmp_PartialOrd_ref); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_236, _240, order2 !== undefined && order2 >= 0], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); const _256: boolean = ByRef.eq$cmp_PartialEq_ref(a, b); const _260: boolean = !ByRef.eq$cmp_PartialEq_ref(a, b); const _264: boolean = ByRef.partialCmp$cmp_PartialOrd_ref(a, b) === -1; const order3 = ByRef.partialCmp$cmp_PartialOrd_ref(a, b); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_256, _260, _264, order3 !== undefined && order3 >= 0, ByRef.eq$cmp_PartialEq_ref(a, b), ByRef.partialCmp$cmp_PartialOrd_ref(a, b) === 1], (a06: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_256, _260, _264, order3 !== undefined && order3 >= 0, ByRef.eq$cmp_PartialEq_ref(a, b), ByRef.partialCmp$cmp_PartialOrd_ref(a, b) === 1], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByRef.partialCmp$cmp_PartialOrd_ref(a, b), ByRef.partialCmp$cmp_PartialOrd_ref(a, b)], orderByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByRef.cmp$cmp_Ord_ref(a, b), ByRef.cmp$cmp_Ord_ref(a, b)], cmpByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.ordMax(a, b, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordMin(a, b, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordMax(a, b, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordClamp(a, b, b, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref), rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), rt.cmpGt(ByRef.partialCmp$cmp_PartialOrd_ref))._0], (v4: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByRef.partialCmp$cmp_PartialOrd_ref(a, b), ByRef.partialCmp$cmp_PartialOrd_ref(a, b)], orderByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByRef.cmp$cmp_Ord_ref(a, b), ByRef.cmp$cmp_Ord_ref(a, b)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.ordMax(a, b, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordMin(a, b, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordMax(a, b, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordClamp(a, b, b, rs.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref), rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), rs.cmpGt(ByRef.partialCmp$cmp_PartialOrd_ref))._0], (v4: rs.u16): rs.u8 => { return v4 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_collections_ByRef(a)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_collections_ByRef(a)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_collections_ByRef(a)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_collections_ByRef(a)), undefined, true); const _323: Uint8Array = copy$array_u8(hashed$ref_orders_tuple1_ref_collections_ByRef([a] as [ByRef.ByRef])); const _325: Uint8Array = copy$array_u8(hashed$ref_orders_Option_ref_collections_ByRef(a)); const _327: Uint8Array = copy$array_u8(hashed$ref_orders_array2_ref_collections_ByRef([a, b])); const _332: ByRef.ByRef[] = [a]; - const iter2: rt.Iter = rt.iterSlice([_323, _325, _327, copy$array_u8(hashed$ref_orders_ref_slice_ref_collections_ByRef(rt.sliceRange(_332, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_collections_ByRef(rt.vecFrom([b])))]); + const iter2: rs.Iter = rs.iterSlice([_323, _325, _327, copy$array_u8(hashed$ref_orders_ref_slice_ref_collections_ByRef(rs.sliceRange(_332, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_collections_ByRef(rs.vecFrom([b])))]); while (true) { - const _337: Uint8Array | rt.Done = iter2.next(); - if (_337 === rt.DONE) { + const _337: Uint8Array | rs.Done = iter2.next(); + if (_337 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(_337), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_337), undefined, true); } - const at3 = rt.idx(byRef.items, i); - const at4 = rt.idx(byRef.items, j); + const at3 = rs.idx(byRef.items, i); + const at4 = rs.idx(byRef.items, j); const part3 = byRef.items[at3]; const part4 = byRef.items[at4]; const a2: ByRef.ByRef = part3; const b2: ByRef.ByRef = part4; const _359: [ByRef.ByRef] = [a2]; const _361: [ByRef.ByRef] = [b2]; - const _357: boolean = rt.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_359, _361); + const _357: boolean = rs.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_359, _361); const _364: [ByRef.ByRef] = [a2]; const _366: [ByRef.ByRef] = [b2]; - const _362: boolean = !rt.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_364, _366); + const _362: boolean = !rs.eqTuple([ByRef.eq$cmp_PartialEq_ref])(_364, _366); const _369: [ByRef.ByRef] = [a2]; const _371: [ByRef.ByRef] = [b2]; - const _367: boolean = rt.cmpTuple<[ByRef.ByRef], rt.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_369, _371) === -1; - const _374: [rt.u8, ByRef.ByRef] = [7, a2]; - const _376: [rt.u8, ByRef.ByRef] = [7, b2]; - const order4 = rt.cmpTuple<[rt.u8, ByRef.ByRef], rt.Ordering | undefined>([rt.cmp, ByRef.partialCmp$cmp_PartialOrd_ref])(_374, _376); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_357, _362, _367, order4 !== undefined && order4 >= 0], (a07: boolean): rt.u8 => { + const _367: boolean = rs.cmpTuple<[ByRef.ByRef], rs.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_369, _371) === -1; + const _374: [rs.u8, ByRef.ByRef] = [7, a2]; + const _376: [rs.u8, ByRef.ByRef] = [7, b2]; + const order4 = rs.cmpTuple<[rs.u8, ByRef.ByRef], rs.Ordering | undefined>([rs.cmp, ByRef.partialCmp$cmp_PartialOrd_ref])(_374, _376); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_357, _362, _367, order4 !== undefined && order4 >= 0], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); const _381: [ByRef.ByRef] = [a2]; const _383: [ByRef.ByRef] = [b2]; - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpTuple<[ByRef.ByRef], rt.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_381, _383))); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpTuple<[ByRef.ByRef], rs.Ordering | undefined>([ByRef.partialCmp$cmp_PartialOrd_ref])(_381, _383))); const _389: [ByRef.ByRef] = [a2]; const _391: [ByRef.ByRef] = [b2]; - const _387: rt.Ordering = rt.cmpTuple<[ByRef.ByRef], rt.Ordering>([ByRef.cmp$cmp_Ord_ref])(_389, _391); - const _394: [rt.u8, ByRef.ByRef] = [7, a2]; - const _396: [rt.u8, ByRef.ByRef] = [7, b2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_387, rt.cmpTuple<[rt.u8, ByRef.ByRef], rt.Ordering>([rt.cmp, ByRef.cmp$cmp_Ord_ref])(_394, _396)], cmpByte$ref_orders)), undefined, true); + const _387: rs.Ordering = rs.cmpTuple<[ByRef.ByRef], rs.Ordering>([ByRef.cmp$cmp_Ord_ref])(_389, _391); + const _394: [rs.u8, ByRef.ByRef] = [7, a2]; + const _396: [rs.u8, ByRef.ByRef] = [7, b2]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_387, rs.cmpTuple<[rs.u8, ByRef.ByRef], rs.Ordering>([rs.cmp, ByRef.cmp$cmp_Ord_ref])(_394, _396)], cmpByte$ref_orders)), undefined, true); const _402: ByRef.ByRef | undefined = a2; const _404: ByRef.ByRef | undefined = b2; - const _399: rt.u8 = orderByte$ref_orders(rt.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_402, _404)); + const _399: rs.u8 = orderByte$ref_orders(rs.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_402, _404)); const _408: ByRef.ByRef | undefined = a2; const _410: ByRef.ByRef | undefined = b2; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_399, cmpByte$ref_orders(rt.cmpOption(ByRef.cmp$cmp_Ord_ref)(_408, _410)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_399, cmpByte$ref_orders(rs.cmpOption(ByRef.cmp$cmp_Ord_ref)(_408, _410)))), undefined, true); const _416: ByRef.ByRef | undefined = a2; const _418: ByRef.ByRef | undefined = b2; - const _414: boolean = rt.eqOption(ByRef.eq$cmp_PartialEq_ref)(_416, _418); + const _414: boolean = rs.eqOption(ByRef.eq$cmp_PartialEq_ref)(_416, _418); const _421: ByRef.ByRef | undefined = a2; const _423: ByRef.ByRef | undefined = b2; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_414, rt.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_421, _423) === -1], (a08: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_414, rs.cmpOption(ByRef.partialCmp$cmp_PartialOrd_ref)(_421, _423) === -1], (a08: boolean): rs.u8 => { return a08 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, result_eq$1dt73ez(rt.Ok(a2), rt.Ok(b2)) ? 1 : 0); + rs.byteVecPush(out, result_eq$1a91ieh(rs.Ok(a2), rs.Ok(b2)) ? 1 : 0); const _436: ByRef.ByRef[] = [a2, b2]; - const _434: ByRef.ByRef[] = rt.sliceRange(_436, 0); + const _434: ByRef.ByRef[] = rs.sliceRange(_436, 0); const _439: ByRef.ByRef[] = [b2, a2]; - const _437: ByRef.ByRef[] = rt.sliceRange(_439, 0); - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_434, _437))); + const _437: ByRef.ByRef[] = rs.sliceRange(_439, 0); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_434, _437))); const _445: ByRef.ByRef[] = [a2, b2]; const _447: ByRef.ByRef[] = [b2, a2]; - const _443: rt.Ordering = rt.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_445, _447); - const _450: rt.Vec = rt.vecFrom([a2]); - const _453: rt.Vec = rt.vecFrom([b2]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_443, rt.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_450, _453)], cmpByte$ref_orders)), undefined, true); + const _443: rs.Ordering = rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_445, _447); + const _450: rs.Vec = rs.vecFrom([a2]); + const _453: rs.Vec = rs.vecFrom([b2]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_443, rs.cmpSlice(ByRef.cmp$cmp_Ord_ref)(_450, _453)], cmpByte$ref_orders)), undefined, true); const _460: ByRef.ByRef[] = [a2, b2]; const _462: ByRef.ByRef[] = [b2, a2]; - const _458: boolean = rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_460, _462); + const _458: boolean = rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_460, _462); const _466: ByRef.ByRef[] = [a2]; - const _464: ByRef.ByRef[] = rt.sliceRange(_466, 0); + const _464: ByRef.ByRef[] = rs.sliceRange(_466, 0); const _469: ByRef.ByRef[] = [b2]; - const _467: ByRef.ByRef[] = rt.sliceRange(_469, 0); - const _463: boolean = rt.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_464, _467) === -1; - const _472: rt.Vec = rt.vecFrom([a2, b2]); - const _475: rt.Vec = rt.vecFrom([b2, a2]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_458, _463, !rt.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a09: boolean): rt.u8 => { + const _467: ByRef.ByRef[] = rs.sliceRange(_469, 0); + const _463: boolean = rs.cmpSlice(ByRef.partialCmp$cmp_PartialOrd_ref)(_464, _467) === -1; + const _472: rs.Vec = rs.vecFrom([a2, b2]); + const _475: rs.Vec = rs.vecFrom([b2, a2]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_458, _463, !rs.eqSlice(ByRef.eq$cmp_PartialEq_ref)(_472, _475)], (a09: boolean): rs.u8 => { return a09 ? 1 : 0; })), undefined, true); - const _481: rt.VecDeque = rt.dequeFromArray([a2, b2], 4) as rt.VecDeque; - const _484: rt.VecDeque = rt.dequeFromArray([b2, a2], 4) as rt.VecDeque; - rt.byteVecPush(out, rt.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); + const _481: rs.VecDeque = rs.dequeFromArray([a2, b2], 4) as rs.VecDeque; + const _484: rs.VecDeque = rs.dequeFromArray([b2, a2], 4) as rs.VecDeque; + rs.byteVecPush(out, rs.eqSeq(ByRef.eq$cmp_PartialEq_ref)(_481, _484) ? 1 : 0); const _491: ByRef.ByRef = a2; const _493: ByRef.ByRef = b2; - const _488: rt.u8 = orderByte$ref_orders(rt.cmpReverse(ByRef.partialCmp$cmp_PartialOrd_ref)(_491, _493)); + const _488: rs.u8 = orderByte$ref_orders(rs.cmpReverse(ByRef.partialCmp$cmp_PartialOrd_ref)(_491, _493)); const _497: ByRef.ByRef = a2; const _499: ByRef.ByRef = b2; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_488, cmpByte$ref_orders(rt.cmpReverse(ByRef.cmp$cmp_Ord_ref)(_497, _499)))), undefined, true); - const _505: rt.Cell = new rt.Cell(a2); - const _507: rt.Cell = new rt.Cell(b2); - const _502: rt.u8 = orderByte$ref_orders(rt.cellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_505, _507)); - const _511: rt.RefCell = new rt.RefCell(a2); - const _513: rt.RefCell = new rt.RefCell(b2); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_502, cmpByte$ref_orders(rt.refCellBy(ByRef.cmp$cmp_Ord_ref)(_511, _513)))), undefined, true); - const _519: rt.Cell = new rt.Cell(a2); - const _521: rt.Cell = new rt.Cell(b2); - const _517: boolean = rt.cellBy(ByRef.eq$cmp_PartialEq_ref)(_519, _521); - const _524: rt.RefCell = new rt.RefCell(a2); - const _526: rt.RefCell = new rt.RefCell(b2); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_517, rt.refCellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_524, _526) === -1], (a010: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_488, cmpByte$ref_orders(rs.cmpReverse(ByRef.cmp$cmp_Ord_ref)(_497, _499)))), undefined, true); + const _505: rs.Cell = new rs.Cell(a2); + const _507: rs.Cell = new rs.Cell(b2); + const _502: rs.u8 = orderByte$ref_orders(rs.cellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_505, _507)); + const _511: rs.RefCell = new rs.RefCell(a2); + const _513: rs.RefCell = new rs.RefCell(b2); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_502, cmpByte$ref_orders(rs.refCellBy(ByRef.cmp$cmp_Ord_ref)(_511, _513)))), undefined, true); + const _519: rs.Cell = new rs.Cell(a2); + const _521: rs.Cell = new rs.Cell(b2); + const _517: boolean = rs.cellBy(ByRef.eq$cmp_PartialEq_ref)(_519, _521); + const _524: rs.RefCell = new rs.RefCell(a2); + const _526: rs.RefCell = new rs.RefCell(b2); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_517, rs.refCellBy(ByRef.partialCmp$cmp_PartialOrd_ref)(_524, _526) === -1], (a010: boolean): rs.u8 => { return a010 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(orderByte$ref_orders(rt.iterCmp(rt.iterSlice([a2, b2]), rt.iterSlice([b2, a2]), ByRef.partialCmp$cmp_PartialOrd_ref)), cmpByte$ref_orders(rt.iterCmp(rt.iterSlice([a2]), rt.iterSlice([b2]), ByRef.cmp$cmp_Ord_ref)))), undefined, true); - const _547: boolean = rt.iterEq(rt.iterSlice([a2, b2]), rt.iterSlice([b2, a2]), ByRef.eq$cmp_PartialEq_ref, true); - const _551: boolean = rt.iterCmp(rt.iterSlice([a2]), rt.iterSlice([b2]), ByRef.partialCmp$cmp_PartialOrd_ref) === -1; - const order5 = rt.iterCmp(rt.iterSlice([a2]), rt.iterSlice([b2]), ByRef.partialCmp$cmp_PartialOrd_ref); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_547, _551, order5 !== undefined && order5 >= 0], (a011: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(orderByte$ref_orders(rs.iterCmp(rs.iterSlice([a2, b2]), rs.iterSlice([b2, a2]), ByRef.partialCmp$cmp_PartialOrd_ref)), cmpByte$ref_orders(rs.iterCmp(rs.iterSlice([a2]), rs.iterSlice([b2]), ByRef.cmp$cmp_Ord_ref)))), undefined, true); + const _547: boolean = rs.iterEq(rs.iterSlice([a2, b2]), rs.iterSlice([b2, a2]), ByRef.eq$cmp_PartialEq_ref, true); + const _551: boolean = rs.iterCmp(rs.iterSlice([a2]), rs.iterSlice([b2]), ByRef.partialCmp$cmp_PartialOrd_ref) === -1; + const order5 = rs.iterCmp(rs.iterSlice([a2]), rs.iterSlice([b2]), ByRef.partialCmp$cmp_PartialOrd_ref); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_547, _551, order5 !== undefined && order5 >= 0], (a011: boolean): rs.u8 => { return a011 ? 1 : 0; })), undefined, true); const _567: boolean = ByRef.eq$cmp_PartialEq_ref(a2, b2); const _570: boolean = !ByRef.eq$cmp_PartialEq_ref(a2, b2); const _573: boolean = ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2) === -1; const order6 = ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_567, _570, _573, order6 !== undefined && order6 >= 0, ByRef.eq$cmp_PartialEq_ref(a2, b2), ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2) === 1], (a012: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_567, _570, _573, order6 !== undefined && order6 >= 0, ByRef.eq$cmp_PartialEq_ref(a2, b2), ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2) === 1], (a012: boolean): rs.u8 => { return a012 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2), ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2)], orderByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByRef.cmp$cmp_Ord_ref(a2, b2), ByRef.cmp$cmp_Ord_ref(a2, b2)], cmpByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.ordMax(a2, b2, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordMin(a2, b2, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordMax(a2, b2, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rt.ordClamp(a2, b2, b2, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref), rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), rt.cmpGt(ByRef.partialCmp$cmp_PartialOrd_ref))._0], (v5: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2), ByRef.partialCmp$cmp_PartialOrd_ref(a2, b2)], orderByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByRef.cmp$cmp_Ord_ref(a2, b2), ByRef.cmp$cmp_Ord_ref(a2, b2)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.ordMax(a2, b2, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordMin(a2, b2, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordMax(a2, b2, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref))._0, rs.ordClamp(a2, b2, b2, rs.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref), rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), rs.cmpGt(ByRef.partialCmp$cmp_PartialOrd_ref))._0], (v5: rs.u16): rs.u8 => { return v5 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_collections_ByRef(a2)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_ref_collections_ByRef(a2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_collections_ByRef(a2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_ref_collections_ByRef(a2)), undefined, true); const _630: Uint8Array = copy$array_u8(hashed$ref_orders_tuple1_ref_ref_collections_ByRef([a2] as [ByRef.ByRef])); const _632: Uint8Array = copy$array_u8(hashed$ref_orders_Option_ref_ref_collections_ByRef(a2)); const _634: Uint8Array = copy$array_u8(hashed$ref_orders_array2_ref_ref_collections_ByRef([a2, b2])); const _639: ByRef.ByRef[] = [a2]; - const iter3: rt.Iter = rt.iterSlice([_630, _632, _634, copy$array_u8(hashed$ref_orders_ref_slice_ref_ref_collections_ByRef(rt.sliceRange(_639, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_ref_collections_ByRef(rt.vecFrom([b2])))]); + const iter3: rs.Iter = rs.iterSlice([_630, _632, _634, copy$array_u8(hashed$ref_orders_ref_slice_ref_ref_collections_ByRef(rs.sliceRange(_639, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_ref_collections_ByRef(rs.vecFrom([b2])))]); while (true) { - const _644: Uint8Array | rt.Done = iter3.next(); - if (_644 === rt.DONE) { + const _644: Uint8Array | rs.Done = iter3.next(); + if (_644 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(_644), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_644), undefined, true); } - const at5 = rt.idx(byVal.items, i); - const at6 = rt.idx(byVal.items, j); + const at5 = rs.idx(byVal.items, i); + const at6 = rs.idx(byVal.items, j); const part5 = byVal.items[at5]; const part6 = byVal.items[at6]; const a3: ByVal.ByVal = part5; const b3: ByVal.ByVal = part6; const _662: [ByVal.ByVal] = [a3]; const _664: [ByVal.ByVal] = [b3]; - const _660: boolean = rt.eqTuple([ByVal.eq$cmp_PartialEq])(_662, _664); + const _660: boolean = rs.eqTuple([ByVal.eq$cmp_PartialEq])(_662, _664); const _667: [ByVal.ByVal] = [a3]; const _669: [ByVal.ByVal] = [b3]; - const _665: boolean = !rt.eqTuple([ByVal.eq$cmp_PartialEq])(_667, _669); + const _665: boolean = !rs.eqTuple([ByVal.eq$cmp_PartialEq])(_667, _669); const _672: [ByVal.ByVal] = [a3]; const _674: [ByVal.ByVal] = [b3]; - const _670: boolean = rt.cmpTuple<[ByVal.ByVal], rt.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_672, _674) === -1; - const _677: [rt.u8, ByVal.ByVal] = [7, a3]; - const _679: [rt.u8, ByVal.ByVal] = [7, b3]; - const order7 = rt.cmpTuple<[rt.u8, ByVal.ByVal], rt.Ordering | undefined>([rt.cmp, ByVal.partialCmp$cmp_PartialOrd])(_677, _679); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_660, _665, _670, order7 !== undefined && order7 >= 0], (a013: boolean): rt.u8 => { + const _670: boolean = rs.cmpTuple<[ByVal.ByVal], rs.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_672, _674) === -1; + const _677: [rs.u8, ByVal.ByVal] = [7, a3]; + const _679: [rs.u8, ByVal.ByVal] = [7, b3]; + const order7 = rs.cmpTuple<[rs.u8, ByVal.ByVal], rs.Ordering | undefined>([rs.cmp, ByVal.partialCmp$cmp_PartialOrd])(_677, _679); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_660, _665, _670, order7 !== undefined && order7 >= 0], (a013: boolean): rs.u8 => { return a013 ? 1 : 0; })), undefined, true); const _684: [ByVal.ByVal] = [a3]; const _686: [ByVal.ByVal] = [b3]; - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpTuple<[ByVal.ByVal], rt.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_684, _686))); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpTuple<[ByVal.ByVal], rs.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_684, _686))); const _692: [ByVal.ByVal] = [a3]; const _694: [ByVal.ByVal] = [b3]; - const _690: rt.Ordering = rt.cmpTuple<[ByVal.ByVal], rt.Ordering>([ByVal.cmp$cmp_Ord])(_692, _694); - const _697: [rt.u8, ByVal.ByVal] = [7, a3]; - const _699: [rt.u8, ByVal.ByVal] = [7, b3]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_690, rt.cmpTuple<[rt.u8, ByVal.ByVal], rt.Ordering>([rt.cmp, ByVal.cmp$cmp_Ord])(_697, _699)], cmpByte$ref_orders)), undefined, true); + const _690: rs.Ordering = rs.cmpTuple<[ByVal.ByVal], rs.Ordering>([ByVal.cmp$cmp_Ord])(_692, _694); + const _697: [rs.u8, ByVal.ByVal] = [7, a3]; + const _699: [rs.u8, ByVal.ByVal] = [7, b3]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_690, rs.cmpTuple<[rs.u8, ByVal.ByVal], rs.Ordering>([rs.cmp, ByVal.cmp$cmp_Ord])(_697, _699)], cmpByte$ref_orders)), undefined, true); const _705: ByVal.ByVal | undefined = a3; const _707: ByVal.ByVal | undefined = b3; - const _702: rt.u8 = orderByte$ref_orders(rt.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_705, _707)); + const _702: rs.u8 = orderByte$ref_orders(rs.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_705, _707)); const _711: ByVal.ByVal | undefined = a3; const _713: ByVal.ByVal | undefined = b3; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_702, cmpByte$ref_orders(rt.cmpOption(ByVal.cmp$cmp_Ord)(_711, _713)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_702, cmpByte$ref_orders(rs.cmpOption(ByVal.cmp$cmp_Ord)(_711, _713)))), undefined, true); const _719: ByVal.ByVal | undefined = a3; const _721: ByVal.ByVal | undefined = b3; - const _717: boolean = rt.eqOption(ByVal.eq$cmp_PartialEq)(_719, _721); + const _717: boolean = rs.eqOption(ByVal.eq$cmp_PartialEq)(_719, _721); const _724: ByVal.ByVal | undefined = a3; const _726: ByVal.ByVal | undefined = b3; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_717, rt.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_724, _726) === -1], (a014: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_717, rs.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_724, _726) === -1], (a014: boolean): rs.u8 => { return a014 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, result_eq$163neqy(rt.Ok(a3), rt.Ok(b3)) ? 1 : 0); + rs.byteVecPush(out, result_eq$122baxc(rs.Ok(a3), rs.Ok(b3)) ? 1 : 0); const _739: ByVal.ByVal[] = [a3, b3]; - const _737: ByVal.ByVal[] = rt.sliceRange(_739, 0); + const _737: ByVal.ByVal[] = rs.sliceRange(_739, 0); const _742: ByVal.ByVal[] = [b3, a3]; - const _740: ByVal.ByVal[] = rt.sliceRange(_742, 0); - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_737, _740))); + const _740: ByVal.ByVal[] = rs.sliceRange(_742, 0); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_737, _740))); const _748: ByVal.ByVal[] = [a3, b3]; const _750: ByVal.ByVal[] = [b3, a3]; - const _746: rt.Ordering = rt.cmpSlice(ByVal.cmp$cmp_Ord)(_748, _750); - const _753: rt.Vec = rt.vecFrom([a3]); - const _756: rt.Vec = rt.vecFrom([b3]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_746, rt.cmpSlice(ByVal.cmp$cmp_Ord)(_753, _756)], cmpByte$ref_orders)), undefined, true); + const _746: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_748, _750); + const _753: rs.Vec = rs.vecFrom([a3]); + const _756: rs.Vec = rs.vecFrom([b3]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_746, rs.cmpSlice(ByVal.cmp$cmp_Ord)(_753, _756)], cmpByte$ref_orders)), undefined, true); const _763: ByVal.ByVal[] = [a3, b3]; const _765: ByVal.ByVal[] = [b3, a3]; - const _761: boolean = rt.eqSlice(ByVal.eq$cmp_PartialEq)(_763, _765); + const _761: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_763, _765); const _769: ByVal.ByVal[] = [a3]; - const _767: ByVal.ByVal[] = rt.sliceRange(_769, 0); + const _767: ByVal.ByVal[] = rs.sliceRange(_769, 0); const _772: ByVal.ByVal[] = [b3]; - const _770: ByVal.ByVal[] = rt.sliceRange(_772, 0); - const _766: boolean = rt.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_767, _770) === -1; - const _775: rt.Vec = rt.vecFrom([a3, b3]); - const _778: rt.Vec = rt.vecFrom([b3, a3]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_761, _766, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a015: boolean): rt.u8 => { + const _770: ByVal.ByVal[] = rs.sliceRange(_772, 0); + const _766: boolean = rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_767, _770) === -1; + const _775: rs.Vec = rs.vecFrom([a3, b3]); + const _778: rs.Vec = rs.vecFrom([b3, a3]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_761, _766, !rs.eqSlice(ByVal.eq$cmp_PartialEq)(_775, _778)], (a015: boolean): rs.u8 => { return a015 ? 1 : 0; })), undefined, true); - const _784: rt.VecDeque = rt.dequeFromArray([a3, b3], 4) as rt.VecDeque; - const _787: rt.VecDeque = rt.dequeFromArray([b3, a3], 4) as rt.VecDeque; - rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); + const _784: rs.VecDeque = rs.dequeFromArray([a3, b3], 4) as rs.VecDeque; + const _787: rs.VecDeque = rs.dequeFromArray([b3, a3], 4) as rs.VecDeque; + rs.byteVecPush(out, rs.eqSeq(ByVal.eq$cmp_PartialEq)(_784, _787) ? 1 : 0); const _794: ByVal.ByVal = a3; const _796: ByVal.ByVal = b3; - const _791: rt.u8 = orderByte$ref_orders(rt.cmpReverse(ByVal.partialCmp$cmp_PartialOrd)(_794, _796)); + const _791: rs.u8 = orderByte$ref_orders(rs.cmpReverse(ByVal.partialCmp$cmp_PartialOrd)(_794, _796)); const _800: ByVal.ByVal = a3; const _802: ByVal.ByVal = b3; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_791, cmpByte$ref_orders(rt.cmpReverse(ByVal.cmp$cmp_Ord)(_800, _802)))), undefined, true); - const _808: rt.Cell = new rt.Cell(a3); - const _810: rt.Cell = new rt.Cell(b3); - const _805: rt.u8 = orderByte$ref_orders(rt.cellBy(ByVal.partialCmp$cmp_PartialOrd)(_808, _810)); - const _814: rt.RefCell = new rt.RefCell(a3); - const _816: rt.RefCell = new rt.RefCell(b3); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_805, cmpByte$ref_orders(rt.refCellBy(ByVal.cmp$cmp_Ord)(_814, _816)))), undefined, true); - const _822: rt.Cell = new rt.Cell(a3); - const _824: rt.Cell = new rt.Cell(b3); - const _820: boolean = rt.cellBy(ByVal.eq$cmp_PartialEq)(_822, _824); - const _827: rt.RefCell = new rt.RefCell(a3); - const _829: rt.RefCell = new rt.RefCell(b3); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_820, rt.refCellBy(ByVal.partialCmp$cmp_PartialOrd)(_827, _829) === -1], (a016: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_791, cmpByte$ref_orders(rs.cmpReverse(ByVal.cmp$cmp_Ord)(_800, _802)))), undefined, true); + const _808: rs.Cell = new rs.Cell(a3); + const _810: rs.Cell = new rs.Cell(b3); + const _805: rs.u8 = orderByte$ref_orders(rs.cellBy(ByVal.partialCmp$cmp_PartialOrd)(_808, _810)); + const _814: rs.RefCell = new rs.RefCell(a3); + const _816: rs.RefCell = new rs.RefCell(b3); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_805, cmpByte$ref_orders(rs.refCellBy(ByVal.cmp$cmp_Ord)(_814, _816)))), undefined, true); + const _822: rs.Cell = new rs.Cell(a3); + const _824: rs.Cell = new rs.Cell(b3); + const _820: boolean = rs.cellBy(ByVal.eq$cmp_PartialEq)(_822, _824); + const _827: rs.RefCell = new rs.RefCell(a3); + const _829: rs.RefCell = new rs.RefCell(b3); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_820, rs.refCellBy(ByVal.partialCmp$cmp_PartialOrd)(_827, _829) === -1], (a016: boolean): rs.u8 => { return a016 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(orderByte$ref_orders(rt.iterCmp(rt.iterSlice([a3, b3]), rt.iterSlice([b3, a3]), ByVal.partialCmp$cmp_PartialOrd)), cmpByte$ref_orders(rt.iterCmp(rt.iterSlice([a3]), rt.iterSlice([b3]), ByVal.cmp$cmp_Ord)))), undefined, true); - const _850: boolean = rt.iterEq(rt.iterSlice([a3, b3]), rt.iterSlice([b3, a3]), ByVal.eq$cmp_PartialEq, true); - const _854: boolean = rt.iterCmp(rt.iterSlice([a3]), rt.iterSlice([b3]), ByVal.partialCmp$cmp_PartialOrd) === -1; - const order8 = rt.iterCmp(rt.iterSlice([a3]), rt.iterSlice([b3]), ByVal.partialCmp$cmp_PartialOrd); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_850, _854, order8 !== undefined && order8 >= 0], (a017: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(orderByte$ref_orders(rs.iterCmp(rs.iterSlice([a3, b3]), rs.iterSlice([b3, a3]), ByVal.partialCmp$cmp_PartialOrd)), cmpByte$ref_orders(rs.iterCmp(rs.iterSlice([a3]), rs.iterSlice([b3]), ByVal.cmp$cmp_Ord)))), undefined, true); + const _850: boolean = rs.iterEq(rs.iterSlice([a3, b3]), rs.iterSlice([b3, a3]), ByVal.eq$cmp_PartialEq, true); + const _854: boolean = rs.iterCmp(rs.iterSlice([a3]), rs.iterSlice([b3]), ByVal.partialCmp$cmp_PartialOrd) === -1; + const order8 = rs.iterCmp(rs.iterSlice([a3]), rs.iterSlice([b3]), ByVal.partialCmp$cmp_PartialOrd); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_850, _854, order8 !== undefined && order8 >= 0], (a017: boolean): rs.u8 => { return a017 ? 1 : 0; })), undefined, true); const _870: boolean = ByVal.eq$cmp_PartialEq(a3, b3); const _873: boolean = !ByVal.eq$cmp_PartialEq(a3, b3); const _876: boolean = ByVal.partialCmp$cmp_PartialOrd(a3, b3) === -1; const order9 = ByVal.partialCmp$cmp_PartialOrd(a3, b3); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_870, _873, _876, order9 !== undefined && order9 >= 0, ByVal.eq$cmp_PartialEq(a3, b3), ByVal.partialCmp$cmp_PartialOrd(a3, b3) === 1], (a018: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_870, _873, _876, order9 !== undefined && order9 >= 0, ByVal.eq$cmp_PartialEq(a3, b3), ByVal.partialCmp$cmp_PartialOrd(a3, b3) === 1], (a018: boolean): rs.u8 => { return a018 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByVal.partialCmp$cmp_PartialOrd(a3, b3), ByVal.partialCmp$cmp_PartialOrd(a3, b3)], orderByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByVal.cmp$cmp_Ord(a3, b3), ByVal.cmp$cmp_Ord(a3, b3)], cmpByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.ordMax(a3, b3, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordMin(a3, b3, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordMax(a3, b3, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordClamp(a3, b3, b3, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd), rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd), rt.cmpGt(ByVal.partialCmp$cmp_PartialOrd))._0], (v6: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByVal.partialCmp$cmp_PartialOrd(a3, b3), ByVal.partialCmp$cmp_PartialOrd(a3, b3)], orderByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByVal.cmp$cmp_Ord(a3, b3), ByVal.cmp$cmp_Ord(a3, b3)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.ordMax(a3, b3, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordMin(a3, b3, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordMax(a3, b3, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordClamp(a3, b3, b3, rs.cmpLe(ByVal.partialCmp$cmp_PartialOrd), rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd), rs.cmpGt(ByVal.partialCmp$cmp_PartialOrd))._0], (v6: rs.u16): rs.u8 => { return v6 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_collections_ByVal(a3)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_collections_ByVal(a3)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_collections_ByVal(a3)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_collections_ByVal(a3)), undefined, true); const _933: Uint8Array = copy$array_u8(hashed$ref_orders_tuple1_ref_collections_ByVal([a3] as [ByVal.ByVal])); const _935: Uint8Array = copy$array_u8(hashed$ref_orders_Option_ref_collections_ByVal(a3)); const _937: Uint8Array = copy$array_u8(hashed$ref_orders_array2_ref_collections_ByVal([a3, b3])); const _942: ByVal.ByVal[] = [a3]; - const iter4: rt.Iter = rt.iterSlice([_933, _935, _937, copy$array_u8(hashed$ref_orders_ref_slice_ref_collections_ByVal(rt.sliceRange(_942, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_collections_ByVal(rt.vecFrom([b3])))]); + const iter4: rs.Iter = rs.iterSlice([_933, _935, _937, copy$array_u8(hashed$ref_orders_ref_slice_ref_collections_ByVal(rs.sliceRange(_942, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_collections_ByVal(rs.vecFrom([b3])))]); while (true) { - const _947: Uint8Array | rt.Done = iter4.next(); - if (_947 === rt.DONE) { + const _947: Uint8Array | rs.Done = iter4.next(); + if (_947 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(_947), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_947), undefined, true); } - const at7 = rt.idx(byVal.items, i); - const at8 = rt.idx(byVal.items, j); + const at7 = rs.idx(byVal.items, i); + const at8 = rs.idx(byVal.items, j); const part7 = byVal.items[at7]; const part8 = byVal.items[at8]; const a4: ByVal.ByVal = part7; const b4: ByVal.ByVal = part8; const _969: [ByVal.ByVal] = [a4]; const _971: [ByVal.ByVal] = [b4]; - const _967: boolean = rt.eqTuple([ByVal.eq$cmp_PartialEq])(_969, _971); + const _967: boolean = rs.eqTuple([ByVal.eq$cmp_PartialEq])(_969, _971); const _974: [ByVal.ByVal] = [a4]; const _976: [ByVal.ByVal] = [b4]; - const _972: boolean = !rt.eqTuple([ByVal.eq$cmp_PartialEq])(_974, _976); + const _972: boolean = !rs.eqTuple([ByVal.eq$cmp_PartialEq])(_974, _976); const _979: [ByVal.ByVal] = [a4]; const _981: [ByVal.ByVal] = [b4]; - const _977: boolean = rt.cmpTuple<[ByVal.ByVal], rt.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_979, _981) === -1; - const _984: [rt.u8, ByVal.ByVal] = [7, a4]; - const _986: [rt.u8, ByVal.ByVal] = [7, b4]; - const order10 = rt.cmpTuple<[rt.u8, ByVal.ByVal], rt.Ordering | undefined>([rt.cmp, ByVal.partialCmp$cmp_PartialOrd])(_984, _986); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_967, _972, _977, order10 !== undefined && order10 >= 0], (a019: boolean): rt.u8 => { + const _977: boolean = rs.cmpTuple<[ByVal.ByVal], rs.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_979, _981) === -1; + const _984: [rs.u8, ByVal.ByVal] = [7, a4]; + const _986: [rs.u8, ByVal.ByVal] = [7, b4]; + const order10 = rs.cmpTuple<[rs.u8, ByVal.ByVal], rs.Ordering | undefined>([rs.cmp, ByVal.partialCmp$cmp_PartialOrd])(_984, _986); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_967, _972, _977, order10 !== undefined && order10 >= 0], (a019: boolean): rs.u8 => { return a019 ? 1 : 0; })), undefined, true); const _991: [ByVal.ByVal] = [a4]; const _993: [ByVal.ByVal] = [b4]; - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpTuple<[ByVal.ByVal], rt.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_991, _993))); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpTuple<[ByVal.ByVal], rs.Ordering | undefined>([ByVal.partialCmp$cmp_PartialOrd])(_991, _993))); const _999: [ByVal.ByVal] = [a4]; const _1001: [ByVal.ByVal] = [b4]; - const _997: rt.Ordering = rt.cmpTuple<[ByVal.ByVal], rt.Ordering>([ByVal.cmp$cmp_Ord])(_999, _1001); - const _1004: [rt.u8, ByVal.ByVal] = [7, a4]; - const _1006: [rt.u8, ByVal.ByVal] = [7, b4]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_997, rt.cmpTuple<[rt.u8, ByVal.ByVal], rt.Ordering>([rt.cmp, ByVal.cmp$cmp_Ord])(_1004, _1006)], cmpByte$ref_orders)), undefined, true); + const _997: rs.Ordering = rs.cmpTuple<[ByVal.ByVal], rs.Ordering>([ByVal.cmp$cmp_Ord])(_999, _1001); + const _1004: [rs.u8, ByVal.ByVal] = [7, a4]; + const _1006: [rs.u8, ByVal.ByVal] = [7, b4]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_997, rs.cmpTuple<[rs.u8, ByVal.ByVal], rs.Ordering>([rs.cmp, ByVal.cmp$cmp_Ord])(_1004, _1006)], cmpByte$ref_orders)), undefined, true); const _1012: ByVal.ByVal | undefined = a4; const _1014: ByVal.ByVal | undefined = b4; - const _1009: rt.u8 = orderByte$ref_orders(rt.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_1012, _1014)); + const _1009: rs.u8 = orderByte$ref_orders(rs.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_1012, _1014)); const _1018: ByVal.ByVal | undefined = a4; const _1020: ByVal.ByVal | undefined = b4; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_1009, cmpByte$ref_orders(rt.cmpOption(ByVal.cmp$cmp_Ord)(_1018, _1020)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_1009, cmpByte$ref_orders(rs.cmpOption(ByVal.cmp$cmp_Ord)(_1018, _1020)))), undefined, true); const _1026: ByVal.ByVal | undefined = a4; const _1028: ByVal.ByVal | undefined = b4; - const _1024: boolean = rt.eqOption(ByVal.eq$cmp_PartialEq)(_1026, _1028); + const _1024: boolean = rs.eqOption(ByVal.eq$cmp_PartialEq)(_1026, _1028); const _1031: ByVal.ByVal | undefined = a4; const _1033: ByVal.ByVal | undefined = b4; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1024, rt.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_1031, _1033) === -1], (a020: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1024, rs.cmpOption(ByVal.partialCmp$cmp_PartialOrd)(_1031, _1033) === -1], (a020: boolean): rs.u8 => { return a020 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, result_eq$163neqy(rt.Ok(a4), rt.Ok(b4)) ? 1 : 0); + rs.byteVecPush(out, result_eq$122baxc(rs.Ok(a4), rs.Ok(b4)) ? 1 : 0); const _1046: ByVal.ByVal[] = [a4, b4]; - const _1044: ByVal.ByVal[] = rt.sliceRange(_1046, 0); + const _1044: ByVal.ByVal[] = rs.sliceRange(_1046, 0); const _1049: ByVal.ByVal[] = [b4, a4]; - const _1047: ByVal.ByVal[] = rt.sliceRange(_1049, 0); - rt.byteVecPush(out, orderByte$ref_orders(rt.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1044, _1047))); + const _1047: ByVal.ByVal[] = rs.sliceRange(_1049, 0); + rs.byteVecPush(out, orderByte$ref_orders(rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1044, _1047))); const _1055: ByVal.ByVal[] = [a4, b4]; const _1057: ByVal.ByVal[] = [b4, a4]; - const _1053: rt.Ordering = rt.cmpSlice(ByVal.cmp$cmp_Ord)(_1055, _1057); - const _1060: rt.Vec = rt.vecFrom([a4]); - const _1063: rt.Vec = rt.vecFrom([b4]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1053, rt.cmpSlice(ByVal.cmp$cmp_Ord)(_1060, _1063)], cmpByte$ref_orders)), undefined, true); + const _1053: rs.Ordering = rs.cmpSlice(ByVal.cmp$cmp_Ord)(_1055, _1057); + const _1060: rs.Vec = rs.vecFrom([a4]); + const _1063: rs.Vec = rs.vecFrom([b4]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1053, rs.cmpSlice(ByVal.cmp$cmp_Ord)(_1060, _1063)], cmpByte$ref_orders)), undefined, true); const _1070: ByVal.ByVal[] = [a4, b4]; const _1072: ByVal.ByVal[] = [b4, a4]; - const _1068: boolean = rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1070, _1072); + const _1068: boolean = rs.eqSlice(ByVal.eq$cmp_PartialEq)(_1070, _1072); const _1076: ByVal.ByVal[] = [a4]; - const _1074: ByVal.ByVal[] = rt.sliceRange(_1076, 0); + const _1074: ByVal.ByVal[] = rs.sliceRange(_1076, 0); const _1079: ByVal.ByVal[] = [b4]; - const _1077: ByVal.ByVal[] = rt.sliceRange(_1079, 0); - const _1073: boolean = rt.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1074, _1077) === -1; - const _1082: rt.Vec = rt.vecFrom([a4, b4]); - const _1085: rt.Vec = rt.vecFrom([b4, a4]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1068, _1073, !rt.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a021: boolean): rt.u8 => { + const _1077: ByVal.ByVal[] = rs.sliceRange(_1079, 0); + const _1073: boolean = rs.cmpSlice(ByVal.partialCmp$cmp_PartialOrd)(_1074, _1077) === -1; + const _1082: rs.Vec = rs.vecFrom([a4, b4]); + const _1085: rs.Vec = rs.vecFrom([b4, a4]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1068, _1073, !rs.eqSlice(ByVal.eq$cmp_PartialEq)(_1082, _1085)], (a021: boolean): rs.u8 => { return a021 ? 1 : 0; })), undefined, true); - const _1091: rt.VecDeque = rt.dequeFromArray([a4, b4], 4) as rt.VecDeque; - const _1094: rt.VecDeque = rt.dequeFromArray([b4, a4], 4) as rt.VecDeque; - rt.byteVecPush(out, rt.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); + const _1091: rs.VecDeque = rs.dequeFromArray([a4, b4], 4) as rs.VecDeque; + const _1094: rs.VecDeque = rs.dequeFromArray([b4, a4], 4) as rs.VecDeque; + rs.byteVecPush(out, rs.eqSeq(ByVal.eq$cmp_PartialEq)(_1091, _1094) ? 1 : 0); const _1101: ByVal.ByVal = a4; const _1103: ByVal.ByVal = b4; - const _1098: rt.u8 = orderByte$ref_orders(rt.cmpReverse(ByVal.partialCmp$cmp_PartialOrd)(_1101, _1103)); + const _1098: rs.u8 = orderByte$ref_orders(rs.cmpReverse(ByVal.partialCmp$cmp_PartialOrd)(_1101, _1103)); const _1107: ByVal.ByVal = a4; const _1109: ByVal.ByVal = b4; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_1098, cmpByte$ref_orders(rt.cmpReverse(ByVal.cmp$cmp_Ord)(_1107, _1109)))), undefined, true); - const _1115: rt.Cell = new rt.Cell(a4); - const _1117: rt.Cell = new rt.Cell(b4); - const _1112: rt.u8 = orderByte$ref_orders(rt.cellBy(ByVal.partialCmp$cmp_PartialOrd)(_1115, _1117)); - const _1121: rt.RefCell = new rt.RefCell(a4); - const _1123: rt.RefCell = new rt.RefCell(b4); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_1112, cmpByte$ref_orders(rt.refCellBy(ByVal.cmp$cmp_Ord)(_1121, _1123)))), undefined, true); - const _1129: rt.Cell = new rt.Cell(a4); - const _1131: rt.Cell = new rt.Cell(b4); - const _1127: boolean = rt.cellBy(ByVal.eq$cmp_PartialEq)(_1129, _1131); - const _1134: rt.RefCell = new rt.RefCell(a4); - const _1136: rt.RefCell = new rt.RefCell(b4); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1127, rt.refCellBy(ByVal.partialCmp$cmp_PartialOrd)(_1134, _1136) === -1], (a022: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_1098, cmpByte$ref_orders(rs.cmpReverse(ByVal.cmp$cmp_Ord)(_1107, _1109)))), undefined, true); + const _1115: rs.Cell = new rs.Cell(a4); + const _1117: rs.Cell = new rs.Cell(b4); + const _1112: rs.u8 = orderByte$ref_orders(rs.cellBy(ByVal.partialCmp$cmp_PartialOrd)(_1115, _1117)); + const _1121: rs.RefCell = new rs.RefCell(a4); + const _1123: rs.RefCell = new rs.RefCell(b4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_1112, cmpByte$ref_orders(rs.refCellBy(ByVal.cmp$cmp_Ord)(_1121, _1123)))), undefined, true); + const _1129: rs.Cell = new rs.Cell(a4); + const _1131: rs.Cell = new rs.Cell(b4); + const _1127: boolean = rs.cellBy(ByVal.eq$cmp_PartialEq)(_1129, _1131); + const _1134: rs.RefCell = new rs.RefCell(a4); + const _1136: rs.RefCell = new rs.RefCell(b4); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1127, rs.refCellBy(ByVal.partialCmp$cmp_PartialOrd)(_1134, _1136) === -1], (a022: boolean): rs.u8 => { return a022 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(orderByte$ref_orders(rt.iterCmp(rt.iterSlice([a4, b4]), rt.iterSlice([b4, a4]), ByVal.partialCmp$cmp_PartialOrd)), cmpByte$ref_orders(rt.iterCmp(rt.iterSlice([a4]), rt.iterSlice([b4]), ByVal.cmp$cmp_Ord)))), undefined, true); - const _1157: boolean = rt.iterEq(rt.iterSlice([a4, b4]), rt.iterSlice([b4, a4]), ByVal.eq$cmp_PartialEq, true); - const _1161: boolean = rt.iterCmp(rt.iterSlice([a4]), rt.iterSlice([b4]), ByVal.partialCmp$cmp_PartialOrd) === -1; - const order11 = rt.iterCmp(rt.iterSlice([a4]), rt.iterSlice([b4]), ByVal.partialCmp$cmp_PartialOrd); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1157, _1161, order11 !== undefined && order11 >= 0], (a023: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(orderByte$ref_orders(rs.iterCmp(rs.iterSlice([a4, b4]), rs.iterSlice([b4, a4]), ByVal.partialCmp$cmp_PartialOrd)), cmpByte$ref_orders(rs.iterCmp(rs.iterSlice([a4]), rs.iterSlice([b4]), ByVal.cmp$cmp_Ord)))), undefined, true); + const _1157: boolean = rs.iterEq(rs.iterSlice([a4, b4]), rs.iterSlice([b4, a4]), ByVal.eq$cmp_PartialEq, true); + const _1161: boolean = rs.iterCmp(rs.iterSlice([a4]), rs.iterSlice([b4]), ByVal.partialCmp$cmp_PartialOrd) === -1; + const order11 = rs.iterCmp(rs.iterSlice([a4]), rs.iterSlice([b4]), ByVal.partialCmp$cmp_PartialOrd); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1157, _1161, order11 !== undefined && order11 >= 0], (a023: boolean): rs.u8 => { return a023 ? 1 : 0; })), undefined, true); const _1177: boolean = ByVal.eq$cmp_PartialEq(a4, b4); const _1180: boolean = !ByVal.eq$cmp_PartialEq(a4, b4); const _1183: boolean = ByVal.partialCmp$cmp_PartialOrd(a4, b4) === -1; const order12 = ByVal.partialCmp$cmp_PartialOrd(a4, b4); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1177, _1180, _1183, order12 !== undefined && order12 >= 0, ByVal.eq$cmp_PartialEq(a4, b4), ByVal.partialCmp$cmp_PartialOrd(a4, b4) === 1], (a024: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1177, _1180, _1183, order12 !== undefined && order12 >= 0, ByVal.eq$cmp_PartialEq(a4, b4), ByVal.partialCmp$cmp_PartialOrd(a4, b4) === 1], (a024: boolean): rs.u8 => { return a024 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByVal.partialCmp$cmp_PartialOrd(a4, b4), ByVal.partialCmp$cmp_PartialOrd(a4, b4)], orderByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([ByVal.cmp$cmp_Ord(a4, b4), ByVal.cmp$cmp_Ord(a4, b4)], cmpByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.ordMax(a4, b4, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordMin(a4, b4, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordMax(a4, b4, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rt.ordClamp(a4, b4, b4, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd), rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd), rt.cmpGt(ByVal.partialCmp$cmp_PartialOrd))._0], (v7: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByVal.partialCmp$cmp_PartialOrd(a4, b4), ByVal.partialCmp$cmp_PartialOrd(a4, b4)], orderByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([ByVal.cmp$cmp_Ord(a4, b4), ByVal.cmp$cmp_Ord(a4, b4)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.ordMax(a4, b4, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordMin(a4, b4, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordMax(a4, b4, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd))._0, rs.ordClamp(a4, b4, b4, rs.cmpLe(ByVal.partialCmp$cmp_PartialOrd), rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd), rs.cmpGt(ByVal.partialCmp$cmp_PartialOrd))._0], (v7: rs.u16): rs.u8 => { return v7 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_collections_ByVal(a4)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_ref_ref_ref_collections_ByVal(a4)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_collections_ByVal(a4)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_ref_ref_ref_collections_ByVal(a4)), undefined, true); const _1240: Uint8Array = copy$array_u8(hashed$ref_orders_tuple1_ref_ref_collections_ByVal([a4] as [ByVal.ByVal])); const _1242: Uint8Array = copy$array_u8(hashed$ref_orders_Option_ref_ref_collections_ByVal(a4)); const _1244: Uint8Array = copy$array_u8(hashed$ref_orders_array2_ref_ref_collections_ByVal([a4, b4])); const _1249: ByVal.ByVal[] = [a4]; - const iter5: rt.Iter = rt.iterSlice([_1240, _1242, _1244, copy$array_u8(hashed$ref_orders_ref_slice_ref_ref_collections_ByVal(rt.sliceRange(_1249, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_ref_collections_ByVal(rt.vecFrom([b4])))]); + const iter5: rs.Iter = rs.iterSlice([_1240, _1242, _1244, copy$array_u8(hashed$ref_orders_ref_slice_ref_ref_collections_ByVal(rs.sliceRange(_1249, 0))), copy$array_u8(hashed$ref_orders_Vec_ref_ref_collections_ByVal(rs.vecFrom([b4])))]); while (true) { - const _1254: Uint8Array | rt.Done = iter5.next(); - if (_1254 === rt.DONE) { + const _1254: Uint8Array | rs.Done = iter5.next(); + if (_1254 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(_1254), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_1254), undefined, true); } - const at9 = rt.idx(mixed.items, i); - const at10 = rt.idx(mixed.items, j); + const at9 = rs.idx(mixed.items, i); + const at10 = rs.idx(mixed.items, j); const part9 = mixed.items[at9]; const part10 = mixed.items[at10]; const a5: Mixed.Mixed = part9; const b5: Mixed.Mixed = part10; const _1271: [Mixed.Mixed] = [a5]; const _1273: [Mixed.Mixed] = [b5]; - const _1269: boolean = rt.cmpTuple<[Mixed.Mixed], rt.Ordering | undefined>([Mixed.partialCmp$cmp_PartialOrd])(_1271, _1273) === -1; + const _1269: boolean = rs.cmpTuple<[Mixed.Mixed], rs.Ordering | undefined>([Mixed.partialCmp$cmp_PartialOrd])(_1271, _1273) === -1; const _1276: Mixed.Mixed | undefined = a5; const _1278: Mixed.Mixed | undefined = b5; - const order13 = rt.cmpOption(Mixed.partialCmp$cmp_PartialOrd)(_1276, _1278); + const order13 = rs.cmpOption(Mixed.partialCmp$cmp_PartialOrd)(_1276, _1278); const _1274: boolean = order13 !== undefined && order13 <= 0; const _1281: Mixed.Mixed[] = [a5]; const _1283: Mixed.Mixed[] = [b5]; - const _1279: boolean = rt.eqSlice(Mixed.eq$cmp_PartialEq)(_1281, _1283); - const _1286: rt.Vec = rt.vecFrom([a5]); - const _1289: rt.Vec = rt.vecFrom([b5]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1269, _1274, _1279, rt.cmpSlice(Mixed.partialCmp$cmp_PartialOrd)(_1286, _1289) === -1], (a025: boolean): rt.u8 => { + const _1279: boolean = rs.eqSlice(Mixed.eq$cmp_PartialEq)(_1281, _1283); + const _1286: rs.Vec = rs.vecFrom([a5]); + const _1289: rs.Vec = rs.vecFrom([b5]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1269, _1274, _1279, rs.cmpSlice(Mixed.partialCmp$cmp_PartialOrd)(_1286, _1289) === -1], (a025: boolean): rs.u8 => { return a025 ? 1 : 0; })), undefined, true); const _1294: [Mixed.Mixed] = [a5]; const _1296: [Mixed.Mixed] = [b5]; - const _1292: rt.Ordering = rt.cmpTuple<[Mixed.Mixed], rt.Ordering>([Mixed.cmp$cmp_Ord_ref])(_1294, _1296); + const _1292: rs.Ordering = rs.cmpTuple<[Mixed.Mixed], rs.Ordering>([Mixed.cmp$cmp_Ord_ref])(_1294, _1296); const _1299: Mixed.Mixed | undefined = a5; const _1301: Mixed.Mixed | undefined = b5; - const _1297: rt.Ordering = rt.cmpOption(Mixed.cmp$cmp_Ord_ref)(_1299, _1301); + const _1297: rs.Ordering = rs.cmpOption(Mixed.cmp$cmp_Ord_ref)(_1299, _1301); const _1304: Mixed.Mixed[] = [a5]; const _1306: Mixed.Mixed[] = [b5]; - const _1302: rt.Ordering = rt.cmpSlice(Mixed.cmp$cmp_Ord_ref)(_1304, _1306); + const _1302: rs.Ordering = rs.cmpSlice(Mixed.cmp$cmp_Ord_ref)(_1304, _1306); const _1309: Mixed.Mixed = a5; const _1311: Mixed.Mixed = b5; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1292, _1297, _1302, rt.cmpReverse(Mixed.cmp$cmp_Ord_ref)(_1309, _1311)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1292, _1297, _1302, rs.cmpReverse(Mixed.cmp$cmp_Ord_ref)(_1309, _1311)], cmpByte$ref_orders)), undefined, true); const _1319: [Mixed.Mixed] = [a5]; const _1322: [Mixed.Mixed] = [b5]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.cmpTuple<[Mixed.Mixed], rt.Ordering>([Mixed.cmp$cmp_Ord_ref])(_1319, _1322), rt.iterCmp(rt.iterSlice([a5]), rt.iterSlice([b5]), Mixed.cmp$cmp_Ord_ref), rt.iterCmp(rt.iterSlice([a5]), rt.iterSlice([b5]), Mixed.cmp$cmp_Ord_ref)], cmpByte$ref_orders)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_tuple1_ref_collections_Mixed([a5] as [Mixed.Mixed])), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(hashed$ref_orders_array1_ref_ref_collections_Mixed([a5])), undefined, true); - const _1351: rt.usize = data2.length; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.cmpTuple<[Mixed.Mixed], rs.Ordering>([Mixed.cmp$cmp_Ord_ref])(_1319, _1322), rs.iterCmp(rs.iterSlice([a5]), rs.iterSlice([b5]), Mixed.cmp$cmp_Ord_ref), rs.iterCmp(rs.iterSlice([a5]), rs.iterSlice([b5]), Mixed.cmp$cmp_Ord_ref)], cmpByte$ref_orders)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_tuple1_ref_collections_Mixed([a5] as [Mixed.Mixed])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(hashed$ref_orders_array1_ref_ref_collections_Mixed([a5])), undefined, true); + const _1351: rs.usize = data2.length; if (!(i < _1351)) { - rt.panic("index out of bounds: the len is " + _1351 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + _1351 + " but the index is " + i); } - const _1347: Boxed.Boxed = { _0: data2.data[data2.start + i] as rt.u16 }; - const _1357: rt.usize = data2.length; + const _1347: Boxed.Boxed = { _0: data2.data[data2.start + i] as rs.u16 }; + const _1357: rs.usize = data2.length; if (!(j < _1357)) { - rt.panic("index out of bounds: the len is " + _1357 + " but the index is " + j); + rs.panic("index out of bounds: the len is " + _1357 + " but the index is " + j); } - const _1346: [Boxed.Boxed, Boxed.Boxed] = [_1347, { _0: data2.data[data2.start + j] as rt.u16 }]; + const _1346: [Boxed.Boxed, Boxed.Boxed] = [_1347, { _0: data2.data[data2.start + j] as rs.u16 }]; const a6: Boxed.Boxed = _1347; const b6: Boxed.Boxed = _1346[1]; const _1364: [Boxed.Boxed] = [a6]; const _1367: [Boxed.Boxed] = [b6]; - const _1362: boolean = rt.eqTuple([eq$cmp_PartialEq_boxed_Box_collections_Boxed])(_1364, _1367); + const _1362: boolean = rs.eqTuple([eq$cmp_PartialEq_boxed_Box_collections_Boxed])(_1364, _1367); const _1371: [Boxed.Boxed] = [a6]; const _1374: [Boxed.Boxed] = [b6]; - const _1369: boolean = rt.cmpTuple<[Boxed.Boxed], rt.Ordering | undefined>([partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed])(_1371, _1374) === -1; + const _1369: boolean = rs.cmpTuple<[Boxed.Boxed], rs.Ordering | undefined>([partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed])(_1371, _1374) === -1; const _1378: Boxed.Boxed | undefined = a6; const _1381: Boxed.Boxed | undefined = b6; - const order14 = rt.cmpOption(partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed)(_1378, _1381); + const order14 = rs.cmpOption(partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed)(_1378, _1381); const _1376: boolean = order14 !== undefined && order14 >= 0; const _1385: Boxed.Boxed[] = [a6]; const _1388: Boxed.Boxed[] = [b6]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_1362, _1369, _1376, !rt.eqSlice(eq$cmp_PartialEq_boxed_Box_collections_Boxed)(_1385, _1388)], (a026: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_1362, _1369, _1376, !rs.eqSlice(eq$cmp_PartialEq_boxed_Box_collections_Boxed)(_1385, _1388)], (a026: boolean): rs.u8 => { return a026 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.iterEq(rt.iterSlice([a6]), rt.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), !rt.iterEq(rt.iterSlice([a6]), rt.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), rt.iterCmp(rt.iterSlice([a6]), rt.iterSlice([b6]), partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed) === -1], (a027: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterEq(rs.iterSlice([a6]), rs.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), !rs.iterEq(rs.iterSlice([a6]), rs.iterSlice([b6]), eq$cmp_PartialEq_boxed_Box_collections_Boxed, true), rs.iterCmp(rs.iterSlice([a6]), rs.iterSlice([b6]), partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed) === -1], (a027: boolean): rs.u8 => { return a027 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, orderByte$ref_orders(rt.iterCmp(rt.iterSlice([a6]), rt.iterSlice([b6]), partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed))); + rs.byteVecPush(out, orderByte$ref_orders(rs.iterCmp(rs.iterSlice([a6]), rs.iterSlice([b6]), partialCmp$cmp_PartialOrd_boxed_Box_collections_Boxed))); } - const _1431: [rt.Vec, rt.ByteVec] = [rt.iterToVec(rt.iterSlice(byRef.items), undefined, 4, true), out]; - const xs: rt.Vec = _1431[0]; - const sorted: rt.Vec = rt.vecFrom(xs.items.slice()); - rt.sliceSort(sorted.items, rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted.items), (x4: ByRef.ByRef): rt.u8 => { + const _1431: [rs.Vec, rs.ByteVec] = [rs.iterToVec(rs.iterSlice(byRef.items), undefined, 4, true), out]; + const xs: rs.Vec = _1431[0]; + const sorted: rs.Vec = rs.vecFrom(xs.items.slice()); + rs.sliceSort(sorted.items, rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (x4: ByRef.ByRef): rs.u8 => { return x4._0 & 0xff; }), undefined, true); - const set: rt.BTreeSet = rt.btreeNew(ByRef.cmp$cmp_Ord_ref) as rt.BTreeSet; - const map: rt.BTreeMap<[ByRef.ByRef], rt.usize> = rt.btreeNew(rt.cmpTuple<[ByRef.ByRef], rt.Ordering>([ByRef.cmp$cmp_Ord_ref])) as rt.BTreeMap<[ByRef.ByRef], rt.usize>; - const iter6: rt.Iter<[rt.usize, ByRef.ByRef]> = rt.iterEnumerate(rt.iterSlice(xs.items)); + const set: rs.BTreeSet = rs.btreeNew(ByRef.cmp$cmp_Ord_ref) as rs.BTreeSet; + const map: rs.BTreeMap<[ByRef.ByRef], rs.usize> = rs.btreeNew(rs.cmpTuple<[ByRef.ByRef], rs.Ordering>([ByRef.cmp$cmp_Ord_ref])) as rs.BTreeMap<[ByRef.ByRef], rs.usize>; + const iter6: rs.Iter<[rs.usize, ByRef.ByRef]> = rs.iterEnumerate(rs.iterSlice(xs.items)); while (true) { - const _1454: [rt.usize, ByRef.ByRef] | rt.Done = iter6.next(); - if (_1454 === rt.DONE) { + const _1454: [rs.usize, ByRef.ByRef] | rs.Done = iter6.next(); + if (_1454 === rs.DONE) { break; } - const i2: rt.usize = _1454[0]; + const i2: rs.usize = _1454[0]; const x: ByRef.ByRef = _1454[1]; - rt.byteVecPush(out, rt.btreeAdd(set, x) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeInsert(map, [x] as [ByRef.ByRef], i2), (i5: rt.usize): rt.u8 => { + rs.byteVecPush(out, rs.btreeAdd(set, x) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeInsert(map, [x] as [ByRef.ByRef], i2), (i5: rs.usize): rs.u8 => { return i5 & 0xff; })), undefined, true); } - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set), (x5: ByRef.ByRef): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set), (x5: ByRef.ByRef): rs.u8 => { return x5._0 & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map), (_214: [[ByRef.ByRef], rt.usize]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map), (_214: [[ByRef.ByRef], rs.usize]): Uint8Array => { return Uint8Array.of(_214[0][0]._0 & 0xff, _214[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0ltgf8p(rt.btreeKey(set, xs.items[rt.idx(xs.items, 0)]), (x6: ByRef.ByRef): rt.u8 => { + }), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$1pdxnel(rs.btreeKey(set, xs.items[rs.idx(xs.items, 0)]), (x6: ByRef.ByRef): rs.u8 => { return x6._0 & 0xff; })), undefined, true); - const _1484: rt.Iter = rt.iterSlice(xs.items); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined, ByRef.eq$cmp_PartialEq_ref)) as rt.HashSet, _1484, undefined, undefined, 234881024)) & 0xff); - const _1493: rt.Iter<[ByRef.ByRef, ByRef.ByRef | undefined]> = rt.iterMap(rt.iterSlice(xs.items), (_216: ByRef.ByRef): [ByRef.ByRef, ByRef.ByRef | undefined] => { + const _1484: rs.Iter = rs.iterSlice(xs.items); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined, ByRef.eq$cmp_PartialEq_ref)) as rs.HashSet, _1484, undefined, undefined, 234881024)) & 0xff); + const _1493: rs.Iter<[ByRef.ByRef, ByRef.ByRef | undefined]> = rs.iterMap(rs.iterSlice(xs.items), (_216: ByRef.ByRef): [ByRef.ByRef, ByRef.ByRef | undefined] => { const x7: ByRef.ByRef = _216; return [x7, x7] as [ByRef.ByRef, ByRef.ByRef | undefined]; }); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined, rt.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)]), rt.eqTuple([ByRef.eq$cmp_PartialEq_ref, rt.eqOption(ByRef.eq$cmp_PartialEq_ref)]))) as rt.HashSet<[ByRef.ByRef, ByRef.ByRef | undefined]>, _1493, undefined, undefined, 117440512)) & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0ltgf8p(rt.iterMax(rt.iterSlice(xs.items), rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref)), (x8: ByRef.ByRef): rt.u8 => { + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined, rs.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)]), rs.eqTuple([ByRef.eq$cmp_PartialEq_ref, rs.eqOption(ByRef.eq$cmp_PartialEq_ref)]))) as rs.HashSet<[ByRef.ByRef, ByRef.ByRef | undefined]>, _1493, undefined, undefined, 117440512)) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$1pdxnel(rs.iterMax(rs.iterSlice(xs.items), rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref)), (x8: ByRef.ByRef): rs.u8 => { return x8._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0ltgf8p(rt.iterMin(rt.iterSlice(xs.items), rt.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref)), (x9: ByRef.ByRef): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$1pdxnel(rs.iterMin(rs.iterSlice(xs.items), rs.cmpLt(ByRef.partialCmp$cmp_PartialOrd_ref)), (x9: ByRef.ByRef): rs.u8 => { return x9._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0ltgf8p(rt.sliceFirst(xs.items), (first: ByRef.ByRef): rt.u8 => { - return rt.sliceContains(rt.sliceRange(xs.items, 1), first, ByRef.eq$cmp_PartialEq_ref) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterOption(option_map$1pdxnel(rs.sliceFirst(xs.items), (first: ByRef.ByRef): rs.u8 => { + return rs.sliceContains(rs.sliceRange(xs.items, 1), first, ByRef.eq$cmp_PartialEq_ref) ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, rt.sliceIsSorted(xs.items, rt.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecFrom(xs.items.slice()), 4) as rt.VecDeque, xs.items[rt.idx(xs.items, rt.usizeDiv(xs.items.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); - const _1541: [rt.Vec, rt.ByteVec] = [rt.iterToVec(rt.iterSlice(byVal.items), undefined, 4, true), out]; - const xs2: rt.Vec = _1541[0]; - const sorted2: rt.Vec = rt.vecFrom(xs2.items.slice()); - rt.sliceSort(sorted2.items, rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted2.items), (x10: ByVal.ByVal): rt.u8 => { + rs.byteVecPush(out, rs.sliceIsSorted(xs.items, rs.cmpLe(ByRef.partialCmp$cmp_PartialOrd_ref)) ? 1 : 0); + rs.byteVecPush(out, rs.dequeContains(rs.dequeFromVec(rs.vecFrom(xs.items.slice()), 4) as rs.VecDeque, xs.items[rs.idx(xs.items, rs.usizeDiv(xs.items.length, 2))], ByRef.eq$cmp_PartialEq_ref) ? 1 : 0); + const _1541: [rs.Vec, rs.ByteVec] = [rs.iterToVec(rs.iterSlice(byVal.items), undefined, 4, true), out]; + const xs2: rs.Vec = _1541[0]; + const sorted2: rs.Vec = rs.vecFrom(xs2.items.slice()); + rs.sliceSort(sorted2.items, rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted2.items), (x10: ByVal.ByVal): rs.u8 => { return x10._0 & 0xff; }), undefined, true); - const set2: rt.BTreeSet = rt.btreeNew(ByVal.cmp$cmp_Ord) as rt.BTreeSet; - const map2: rt.BTreeMap<[ByVal.ByVal], rt.usize> = rt.btreeNew(rt.cmpTuple<[ByVal.ByVal], rt.Ordering>([ByVal.cmp$cmp_Ord])) as rt.BTreeMap<[ByVal.ByVal], rt.usize>; - const iter7: rt.Iter<[rt.usize, ByVal.ByVal]> = rt.iterEnumerate(rt.iterSlice(xs2.items)); + const set2: rs.BTreeSet = rs.btreeNew(ByVal.cmp$cmp_Ord) as rs.BTreeSet; + const map2: rs.BTreeMap<[ByVal.ByVal], rs.usize> = rs.btreeNew(rs.cmpTuple<[ByVal.ByVal], rs.Ordering>([ByVal.cmp$cmp_Ord])) as rs.BTreeMap<[ByVal.ByVal], rs.usize>; + const iter7: rs.Iter<[rs.usize, ByVal.ByVal]> = rs.iterEnumerate(rs.iterSlice(xs2.items)); while (true) { - const _1564: [rt.usize, ByVal.ByVal] | rt.Done = iter7.next(); - if (_1564 === rt.DONE) { + const _1564: [rs.usize, ByVal.ByVal] | rs.Done = iter7.next(); + if (_1564 === rs.DONE) { break; } - const i3: rt.usize = _1564[0]; + const i3: rs.usize = _1564[0]; const x2: ByVal.ByVal = _1564[1]; - rt.byteVecPush(out, rt.btreeAdd(set2, x2) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeInsert(map2, [x2] as [ByVal.ByVal], i3), (i7: rt.usize): rt.u8 => { + rs.byteVecPush(out, rs.btreeAdd(set2, x2) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeInsert(map2, [x2] as [ByVal.ByVal], i3), (i7: rs.usize): rs.u8 => { return i7 & 0xff; })), undefined, true); } - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set2), (x11: ByVal.ByVal): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set2), (x11: ByVal.ByVal): rs.u8 => { return x11._0 & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map2), (_222: [[ByVal.ByVal], rt.usize]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map2), (_222: [[ByVal.ByVal], rs.usize]): Uint8Array => { return Uint8Array.of(_222[0][0]._0 & 0xff, _222[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1ajptuf(rt.btreeKey(set2, xs2.items[rt.idx(xs2.items, 0)]), (x12: ByVal.ByVal): rt.u8 => { + }), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$093awy8(rs.btreeKey(set2, xs2.items[rs.idx(xs2.items, 0)]), (x12: ByVal.ByVal): rs.u8 => { return x12._0 & 0xff; })), undefined, true); - const _1594: rt.Iter = rt.iterSlice(xs2.items); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined, ByVal.eq$cmp_PartialEq)) as rt.HashSet, _1594, undefined, undefined, 234881024)) & 0xff); - const _1603: rt.Iter<[ByVal.ByVal, ByVal.ByVal | undefined]> = rt.iterMap(rt.iterSlice(xs2.items), (_226: ByVal.ByVal): [ByVal.ByVal, ByVal.ByVal | undefined] => { + const _1594: rs.Iter = rs.iterSlice(xs2.items); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined, ByVal.eq$cmp_PartialEq)) as rs.HashSet, _1594, undefined, undefined, 234881024)) & 0xff); + const _1603: rs.Iter<[ByVal.ByVal, ByVal.ByVal | undefined]> = rs.iterMap(rs.iterSlice(xs2.items), (_226: ByVal.ByVal): [ByVal.ByVal, ByVal.ByVal | undefined] => { const x13: ByVal.ByVal = _226; return [x13, x13] as [ByVal.ByVal, ByVal.ByVal | undefined]; }); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined, rt.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)]), rt.eqTuple([ByVal.eq$cmp_PartialEq, rt.eqOption(ByVal.eq$cmp_PartialEq)]))) as rt.HashSet<[ByVal.ByVal, ByVal.ByVal | undefined]>, _1603, undefined, undefined, 117440512)) & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1ajptuf(rt.iterMax(rt.iterSlice(xs2.items), rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd)), (x14: ByVal.ByVal): rt.u8 => { + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined, rs.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)]), rs.eqTuple([ByVal.eq$cmp_PartialEq, rs.eqOption(ByVal.eq$cmp_PartialEq)]))) as rs.HashSet<[ByVal.ByVal, ByVal.ByVal | undefined]>, _1603, undefined, undefined, 117440512)) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$093awy8(rs.iterMax(rs.iterSlice(xs2.items), rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd)), (x14: ByVal.ByVal): rs.u8 => { return x14._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1ajptuf(rt.iterMin(rt.iterSlice(xs2.items), rt.cmpLt(ByVal.partialCmp$cmp_PartialOrd)), (x15: ByVal.ByVal): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$093awy8(rs.iterMin(rs.iterSlice(xs2.items), rs.cmpLt(ByVal.partialCmp$cmp_PartialOrd)), (x15: ByVal.ByVal): rs.u8 => { return x15._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1ajptuf(rt.sliceFirst(xs2.items), (first2: ByVal.ByVal): rt.u8 => { - return rt.sliceContains(rt.sliceRange(xs2.items, 1), first2, ByVal.eq$cmp_PartialEq) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterOption(option_map$093awy8(rs.sliceFirst(xs2.items), (first2: ByVal.ByVal): rs.u8 => { + return rs.sliceContains(rs.sliceRange(xs2.items, 1), first2, ByVal.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, rt.sliceIsSorted(xs2.items, rt.cmpLe(ByVal.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecFrom(xs2.items.slice()), 4) as rt.VecDeque, xs2.items[rt.idx(xs2.items, rt.usizeDiv(xs2.items.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); - const _1651: [rt.Vec, rt.ByteVec] = [rt.iterToVec(rt.iterSlice(mixed.items), undefined, 4, true), out]; - const xs3: rt.Vec = _1651[0]; - const sorted3: rt.Vec = rt.vecFrom(xs3.items.slice()); - rt.sliceSort(sorted3.items, rt.cmpLt(Mixed.partialCmp$cmp_PartialOrd), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted3.items), (x16: Mixed.Mixed): rt.u8 => { + rs.byteVecPush(out, rs.sliceIsSorted(xs2.items, rs.cmpLe(ByVal.partialCmp$cmp_PartialOrd)) ? 1 : 0); + rs.byteVecPush(out, rs.dequeContains(rs.dequeFromVec(rs.vecFrom(xs2.items.slice()), 4) as rs.VecDeque, xs2.items[rs.idx(xs2.items, rs.usizeDiv(xs2.items.length, 2))], ByVal.eq$cmp_PartialEq) ? 1 : 0); + const _1651: [rs.Vec, rs.ByteVec] = [rs.iterToVec(rs.iterSlice(mixed.items), undefined, 4, true), out]; + const xs3: rs.Vec = _1651[0]; + const sorted3: rs.Vec = rs.vecFrom(xs3.items.slice()); + rs.sliceSort(sorted3.items, rs.cmpLt(Mixed.partialCmp$cmp_PartialOrd), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted3.items), (x16: Mixed.Mixed): rs.u8 => { return x16._0 & 0xff; }), undefined, true); - const set3: rt.BTreeSet = rt.btreeNew(Mixed.cmp$cmp_Ord_ref) as rt.BTreeSet; - const map3: rt.BTreeMap<[Mixed.Mixed], rt.usize> = rt.btreeNew(rt.cmpTuple<[Mixed.Mixed], rt.Ordering>([Mixed.cmp$cmp_Ord_ref])) as rt.BTreeMap<[Mixed.Mixed], rt.usize>; - const iter8: rt.Iter<[rt.usize, Mixed.Mixed]> = rt.iterEnumerate(rt.iterSlice(xs3.items)); + const set3: rs.BTreeSet = rs.btreeNew(Mixed.cmp$cmp_Ord_ref) as rs.BTreeSet; + const map3: rs.BTreeMap<[Mixed.Mixed], rs.usize> = rs.btreeNew(rs.cmpTuple<[Mixed.Mixed], rs.Ordering>([Mixed.cmp$cmp_Ord_ref])) as rs.BTreeMap<[Mixed.Mixed], rs.usize>; + const iter8: rs.Iter<[rs.usize, Mixed.Mixed]> = rs.iterEnumerate(rs.iterSlice(xs3.items)); while (true) { - const _1674: [rt.usize, Mixed.Mixed] | rt.Done = iter8.next(); - if (_1674 === rt.DONE) { + const _1674: [rs.usize, Mixed.Mixed] | rs.Done = iter8.next(); + if (_1674 === rs.DONE) { break; } - const i4: rt.usize = _1674[0]; + const i4: rs.usize = _1674[0]; const x3: Mixed.Mixed = _1674[1]; - rt.byteVecPush(out, rt.btreeAdd(set3, x3) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeInsert(map3, [x3] as [Mixed.Mixed], i4), (i9: rt.usize): rt.u8 => { + rs.byteVecPush(out, rs.btreeAdd(set3, x3) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeInsert(map3, [x3] as [Mixed.Mixed], i4), (i9: rs.usize): rs.u8 => { return i9 & 0xff; })), undefined, true); } - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set3), (x17: Mixed.Mixed): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set3), (x17: Mixed.Mixed): rs.u8 => { return x17._0 & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(rt.btreeIter(map3), (_233: [[Mixed.Mixed], rt.usize]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(rs.btreeIter(map3), (_233: [[Mixed.Mixed], rs.usize]): Uint8Array => { return Uint8Array.of(_233[0][0]._0 & 0xff, _233[1] & 0xff); - }), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0i8kclf(rt.btreeKey(set3, xs3.items[rt.idx(xs3.items, 0)]), (x18: Mixed.Mixed): rt.u8 => { + }), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0aug5m6(rs.btreeKey(set3, xs3.items[rs.idx(xs3.items, 0)]), (x18: Mixed.Mixed): rs.u8 => { return x18._0 & 0xff; })), undefined, true); - const _1704: rt.Iter = rt.iterSlice(xs3.items); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rt.Hasher) => undefined, Mixed.eq$cmp_PartialEq)) as rt.HashSet, _1704, undefined, undefined, 234881024)) & 0xff); - const _1713: rt.Iter<[Mixed.Mixed, Mixed.Mixed | undefined]> = rt.iterMap(rt.iterSlice(xs3.items), (_247: Mixed.Mixed): [Mixed.Mixed, Mixed.Mixed | undefined] => { + const _1704: rs.Iter = rs.iterSlice(xs3.items); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined, Mixed.eq$cmp_PartialEq)) as rs.HashSet, _1704, undefined, undefined, 234881024)) & 0xff); + const _1713: rs.Iter<[Mixed.Mixed, Mixed.Mixed | undefined]> = rs.iterMap(rs.iterSlice(xs3.items), (_247: Mixed.Mixed): [Mixed.Mixed, Mixed.Mixed | undefined] => { const x19: Mixed.Mixed = _247; return [x19, x19] as [Mixed.Mixed, Mixed.Mixed | undefined]; }); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rt.Hasher) => undefined, rt.hashOption(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rt.Hasher) => undefined)]), rt.eqTuple([Mixed.eq$cmp_PartialEq, rt.eqOption(Mixed.eq$cmp_PartialEq)]))) as rt.HashSet<[Mixed.Mixed, Mixed.Mixed | undefined]>, _1713, undefined, undefined, 117440512)) & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0i8kclf(rt.iterMax(rt.iterSlice(xs3.items), rt.cmpLt(Mixed.partialCmp$cmp_PartialOrd)), (x20: Mixed.Mixed): rt.u8 => { + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined, rs.hashOption(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined)]), rs.eqTuple([Mixed.eq$cmp_PartialEq, rs.eqOption(Mixed.eq$cmp_PartialEq)]))) as rs.HashSet<[Mixed.Mixed, Mixed.Mixed | undefined]>, _1713, undefined, undefined, 117440512)) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0aug5m6(rs.iterMax(rs.iterSlice(xs3.items), rs.cmpLt(Mixed.partialCmp$cmp_PartialOrd)), (x20: Mixed.Mixed): rs.u8 => { return x20._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0i8kclf(rt.iterMin(rt.iterSlice(xs3.items), rt.cmpLt(Mixed.partialCmp$cmp_PartialOrd)), (x21: Mixed.Mixed): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0aug5m6(rs.iterMin(rs.iterSlice(xs3.items), rs.cmpLt(Mixed.partialCmp$cmp_PartialOrd)), (x21: Mixed.Mixed): rs.u8 => { return x21._0 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0i8kclf(rt.sliceFirst(xs3.items), (first3: Mixed.Mixed): rt.u8 => { - return rt.sliceContains(rt.sliceRange(xs3.items, 1), first3, Mixed.eq$cmp_PartialEq) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterOption(option_map$0aug5m6(rs.sliceFirst(xs3.items), (first3: Mixed.Mixed): rs.u8 => { + return rs.sliceContains(rs.sliceRange(xs3.items, 1), first3, Mixed.eq$cmp_PartialEq) ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, rt.sliceIsSorted(xs3.items, rt.cmpLe(Mixed.partialCmp$cmp_PartialOrd)) ? 1 : 0); - rt.byteVecPush(out, rt.dequeContains(rt.dequeFromVec(rt.vecFrom(xs3.items.slice()), 4) as rt.VecDeque, xs3.items[rt.idx(xs3.items, rt.usizeDiv(xs3.items.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); + rs.byteVecPush(out, rs.sliceIsSorted(xs3.items, rs.cmpLe(Mixed.partialCmp$cmp_PartialOrd)) ? 1 : 0); + rs.byteVecPush(out, rs.dequeContains(rs.dequeFromVec(rs.vecFrom(xs3.items.slice()), 4) as rs.VecDeque, xs3.items[rs.idx(xs3.items, rs.usizeDiv(xs3.items.length, 2))], Mixed.eq$cmp_PartialEq) ? 1 : 0); } export function hashed$ref_orders_Option_ref_collections_ByRef(value: ByRef.ByRef | undefined): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_Option_ref_collections_ByVal(value: ByVal.ByVal | undefined): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_Option_ref_ref_collections_ByRef(value: ByRef.ByRef | undefined): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashOption(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_Option_ref_ref_collections_ByVal(value: ByVal.ByVal | undefined): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashOption(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } -export function hashed$ref_orders_Vec_ref_collections_ByRef(value: rt.Vec): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); +export function hashed$ref_orders_Vec_ref_collections_ByRef(value: rs.Vec): Uint8Array { + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } -export function hashed$ref_orders_Vec_ref_collections_ByVal(value: rt.Vec): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); +export function hashed$ref_orders_Vec_ref_collections_ByVal(value: rs.Vec): Uint8Array { + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } -export function hashed$ref_orders_Vec_ref_ref_collections_ByRef(value: rt.Vec): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); +export function hashed$ref_orders_Vec_ref_ref_collections_ByRef(value: rs.Vec): Uint8Array { + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } -export function hashed$ref_orders_Vec_ref_ref_collections_ByVal(value: rt.Vec): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); +export function hashed$ref_orders_Vec_ref_ref_collections_ByVal(value: rs.Vec): Uint8Array { + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array1_ref_ref_collections_Mixed(value: Mixed.Mixed[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_array2_ref_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_collections_ByRef(value: ByRef.ByRef): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByRef.hash$Hash_ref_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_collections_ByVal(value: ByVal.ByVal): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByVal.hash$Hash_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_ref_collections_ByRef(value: ByRef.ByRef): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByRef.hash$Hash_ref_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_ref_collections_ByVal(value: ByVal.ByVal): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByVal.hash$Hash_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_ref_ref_collections_ByRef(value: ByRef.ByRef): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByRef.hash$Hash_ref_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_ref_ref_collections_ByVal(value: ByVal.ByVal): Uint8Array { - const h: rt.Hasher = rt.hasher(); + const h: rs.Hasher = rs.hasher(); ByVal.hash$Hash_hash_DefaultHasher(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_slice_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_slice_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_slice_ref_ref_collections_ByRef(value: ByRef.ByRef[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_ref_slice_ref_ref_collections_ByVal(value: ByVal.ByVal[]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined)(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined)(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_tuple1_ref_collections_ByRef(value: [ByRef.ByRef]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined])(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined])(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_tuple1_ref_collections_ByVal(value: [ByVal.ByVal]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined])(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined])(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_tuple1_ref_collections_Mixed(value: [Mixed.Mixed]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rt.Hasher) => undefined])(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([Mixed.hash$Hash_ref_hash_DefaultHasher as (a0: Mixed.Mixed, a1: rs.Hasher) => undefined])(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_tuple1_ref_ref_collections_ByRef(value: [ByRef.ByRef]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rt.Hasher) => undefined])(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([ByRef.hash$Hash_ref_hash_DefaultHasher as (a0: ByRef.ByRef, a1: rs.Hasher) => undefined])(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } export function hashed$ref_orders_tuple1_ref_ref_collections_ByVal(value: [ByVal.ByVal]): Uint8Array { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rt.Hasher) => undefined])(value, h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([ByVal.hash$Hash_hash_DefaultHasher as (a0: ByVal.ByVal, a1: rs.Hasher) => undefined])(value, h); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); } -export function orderByte$ref_orders(o: rt.Ordering | undefined): rt.u8 { - return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function orderByte$ref_orders(o: rs.Ordering | undefined): rs.u8 { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); } -export function cmpByte$ref_orders(o: rt.Ordering): rt.u8 { +export function cmpByte$ref_orders(o: rs.Ordering): rs.u8 { return o & 0xff; } @@ -5658,140 +5658,140 @@ export function cmpByte$ref_orders(o: rt.Ordering): rt.u8 { * each is read, and what stays, each sorted. Read part way, it takes out only what it * read, and the rest stays. */ -export function extracts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _176!: rt.u8; - const keep: rt.u8 = option_mapOr$1surhce(rt.byteSliceFirst(data), 2, (b: rt.u8): rt.u8 => { - return rt.u8Add(rt.u8Rem(b, 3), 2); +export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _176!: rs.u8; + const keep: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 2, (b: rs.u8): rs.u8 => { + return rs.u8Add(rs.u8Rem(b, 3), 2); }); - const _6: rt.u8 = rt.u8Rem(kind, 3); + const _6: rs.u8 = rs.u8Rem(kind, 3); if (_6 === 0) { - const _9: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): [rt.u8, rt.u16] => { - const b6: rt.u8 = _212; - return [rt.u8Rem(b6, 16), b6 as rt.u16] as [rt.u8, rt.u16]; + const _9: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): [rs.u8, rs.u16] => { + const b6: rs.u8 = _212; + return [rs.u8Rem(b6, 16), b6 as rs.u16] as [rs.u8, rs.u16]; }); - const map: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _9, undefined, undefined, undefined, 234881024); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashExtractIfMut(map, (_213: rt.u8, _311: rt.Place): boolean => { + const map: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _9, undefined, undefined, undefined, 234881024); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashExtractIfMut(map, (_213: rs.u8, _311: rs.Place): boolean => { return true; - }).sizeHint()[1], 254, (n: rt.usize): rt.u8 => { + }).sizeHint()[1], 254, (n: rs.usize): rs.u8 => { return n & 0xff; })); - const _19: rt.Iter<[rt.u8, rt.u16]> = rt.hashExtractIfMut(map, (k4: rt.u8, v: rt.Place): boolean => { - v.v = rt.u16Add(v.v, 1); - return rt.u8Rem(k4, keep) === 0; + const _19: rs.Iter<[rs.u8, rs.u16]> = rs.hashExtractIfMut(map, (k4: rs.u8, v: rs.Place): boolean => { + v.v = rs.u16Add(v.v, 1); + return rs.u8Rem(k4, keep) === 0; }); - const taken: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _19, true, undefined, undefined, "next", 4); - const _24: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map), (_214: [rt.u8, rt.u16]): [rt.u8, rt.u16] => { - return [_214[0], _214[1]] as [rt.u8, rt.u16]; + const taken: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _19, true, undefined, undefined, "next", 4); + const _24: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.hashIter(map), (_214: [rs.u8, rs.u16]): [rs.u8, rs.u16] => { + return [_214[0], _214[1]] as [rs.u8, rs.u16]; }); - const kept: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _24, true, undefined, undefined, "next", 4); - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterChain(rt.iterChain(rt.btreeIter(taken), rt.iterSlice([[255, 65535] as [rt.u8, rt.u16]])), rt.btreeIter(kept)); + const kept: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _24, true, undefined, undefined, "next", 4); + const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterChain(rs.iterChain(rs.btreeIter(taken), rs.iterSlice([[255, 65535] as [rs.u8, rs.u16]])), rs.btreeIter(kept)); while (true) { - const _38: [rt.u8, rt.u16] | rt.Done = iter.next(); - if (_38 === rt.DONE) { + const _38: [rs.u8, rs.u16] | rs.Done = iter.next(); + if (_38 === rs.DONE) { break; } - rt.byteVecPush(out, _38[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_38[1])), undefined, true); - } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterToOption(rt.hashExtractIfMut(map, (k5: rt.u8, _312: rt.Place): boolean => { - return rt.u8Rem(k5, 2) === 0; - }).next()) !== undefined ? 1 : 0, rt.hashLen(map) & 0xff)), undefined, true); - const _63: rt.Iter<[rt.u8, rt.ByteVec]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): [rt.u8, rt.ByteVec] => { - const b7: rt.u8 = _215; - return [rt.u8Rem(b7, 8), rt.byteVecFrom(Uint8Array.of(b7))] as [rt.u8, rt.ByteVec]; + rs.byteVecPush(out, _38[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_38[1])), undefined, true); + } + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.iterToOption(rs.hashExtractIfMut(map, (k5: rs.u8, _312: rs.Place): boolean => { + return rs.u8Rem(k5, 2) === 0; + }).next()) !== undefined ? 1 : 0, rs.hashLen(map) & 0xff)), undefined, true); + const _63: rs.Iter<[rs.u8, rs.ByteVec]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): [rs.u8, rs.ByteVec] => { + const b7: rs.u8 = _215; + return [rs.u8Rem(b7, 8), rs.byteVecFrom(Uint8Array.of(b7))] as [rs.u8, rs.ByteVec]; }); - const words: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _63, undefined, undefined, undefined, 58720256); - const _66: rt.Iter<[rt.u8, rt.ByteVec]> = rt.hashExtractIf(words, (k6: rt.u8, v2: rt.ByteVec): boolean => { - rt.byteVecPush(v2, k6); - return rt.u8Rem(v2.data[rt.idx(v2, 0)], keep) === 0; + const words: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _63, undefined, undefined, undefined, 58720256); + const _66: rs.Iter<[rs.u8, rs.ByteVec]> = rs.hashExtractIf(words, (k6: rs.u8, v2: rs.ByteVec): boolean => { + rs.byteVecPush(v2, k6); + return rs.u8Rem(v2.data[rs.idx(v2, 0)], keep) === 0; }); - const iter2: rt.Iter<[rt.u8, rt.ByteVec]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _66, true, undefined, undefined, "next", 16)); + const iter2: rs.Iter<[rs.u8, rs.ByteVec]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _66, true, undefined, undefined, "next", 16)); while (true) { - const _73: [rt.u8, rt.ByteVec] | rt.Done = iter2.next(); - if (_73 === rt.DONE) { + const _73: [rs.u8, rs.ByteVec] | rs.Done = iter2.next(); + if (_73 === rs.DONE) { break; } - rt.byteVecPush(out, _73[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(_73[1])), undefined, true); + rs.byteVecPush(out, _73[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(_73[1])), undefined, true); } - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.hashValues(words), (a0: rt.ByteVec): rt.usize => { + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.hashValues(words), (a0: rs.ByteVec): rs.usize => { return a0.length; - }), rt.usizeAdd, 0) & 0xff); + }), rs.usizeAdd, 0) & 0xff); } else if (_6 === 1) { - const _88: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Pair.Pair => { - const b4: rt.u8 = _210; - return { a: rt.u8Rem(b4, 8), b: rt.u8Rem(b4, 3) as rt.u16 }; + const _88: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): Pair.Pair => { + const b4: rs.u8 = _210; + return { a: rs.u8Rem(b4, 8), b: rs.u8Rem(b4, 3) as rs.u16 }; }); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Pair.hash$Hash_hash_DefaultHasher as (a0: Pair.Pair, a1: rt.Hasher) => undefined, Pair.eq$cmp_PartialEq)) as rt.HashSet, _88, undefined, undefined, 234881024); - const _91: rt.Iter = rt.hashExtractKeysIf(set, (p: Pair.Pair): boolean => { - return rt.u16Rem(p.a as rt.u16, keep as rt.u16) === p.b; + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Pair.hash$Hash_hash_DefaultHasher as (a0: Pair.Pair, a1: rs.Hasher) => undefined, Pair.eq$cmp_PartialEq)) as rs.HashSet, _88, undefined, undefined, 234881024); + const _91: rs.Iter = rs.hashExtractKeysIf(set, (p: Pair.Pair): boolean => { + return rs.u16Rem(p.a as rs.u16, keep as rs.u16) === p.b; }); - const taken3: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Pair.cmp$cmp_Ord) as rt.BTreeSet, _91, true, undefined, "next", 4); - const _96: rt.Iter = rt.hashKeys(set); - const kept2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(Pair.cmp$cmp_Ord) as rt.BTreeSet, _96, true, undefined, "next", 4); - const iter3: rt.Iter = rt.iterChain(rt.iterChain(rt.btreeKeys(taken3), rt.iterSlice([{ a: 255, b: 0 }])), rt.btreeKeys(kept2)); + const taken3: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(Pair.cmp$cmp_Ord) as rs.BTreeSet, _91, true, undefined, "next", 4); + const _96: rs.Iter = rs.hashKeys(set); + const kept2: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(Pair.cmp$cmp_Ord) as rs.BTreeSet, _96, true, undefined, "next", 4); + const iter3: rs.Iter = rs.iterChain(rs.iterChain(rs.btreeKeys(taken3), rs.iterSlice([{ a: 255, b: 0 }])), rs.btreeKeys(kept2)); while (true) { - const _108: Pair.Pair | rt.Done = iter3.next(); - if (_108 === rt.DONE) { + const _108: Pair.Pair | rs.Done = iter3.next(); + if (_108 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_108.a, _108.b & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_108.a, _108.b & 0xff)), undefined, true); } - const _118: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const bytes: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _118, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.iterCount(rt.hashExtractKeysIf(bytes, (b5: rt.u8): boolean => { - return rt.u8Rem(b5, keep) === 1; + const _118: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const bytes: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _118, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.iterCount(rs.hashExtractKeysIf(bytes, (b5: rs.u8): boolean => { + return rs.u8Rem(b5, keep) === 1; })) & 0xff); - rt.byteVecPush(out, rt.hashLen(bytes) & 0xff); - rt.byteVecPush(out, rt.iterToOption(rt.hashExtractKeysIf(bytes, (_211: rt.u8): boolean => { + rs.byteVecPush(out, rs.hashLen(bytes) & 0xff); + rs.byteVecPush(out, rs.iterToOption(rs.hashExtractKeysIf(bytes, (_211: rs.u8): boolean => { return false; }).next()) === undefined ? 1 : 0); } else { - const _140: rt.Iter<[Clash.Clash, Tally.Tally]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [Clash.Clash, Tally.Tally] => { - const b2: rt.u8 = _2; - return [{ _0: rt.u8Rem(b2, 8) }, { n: b2 as rt.u16 }] as [Clash.Clash, Tally.Tally]; + const _140: rs.Iter<[Clash.Clash, Tally.Tally]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [Clash.Clash, Tally.Tally] => { + const b2: rs.u8 = _2; + return [{ _0: rs.u8Rem(b2, 8) }, { n: b2 as rs.u16 }] as [Clash.Clash, Tally.Tally]; }); - const map2: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rt.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rt.HashMap, _140, undefined, undefined, undefined, 234881024); - const _143: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashExtractIf(map2, (k2: Clash.Clash, t: Tally.Tally): boolean => { - t.n = rt.u16Add(t.n, k2._0 as rt.u16); - return rt.u16Rem(t.n, keep as rt.u16) === 0; - }), (_22: [Clash.Clash, Tally.Tally]): [rt.u8, rt.u16] => { - return [_22[0]._0, _22[1].n] as [rt.u8, rt.u16]; + const map2: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rs.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rs.HashMap, _140, undefined, undefined, undefined, 234881024); + const _143: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.hashExtractIf(map2, (k2: Clash.Clash, t: Tally.Tally): boolean => { + t.n = rs.u16Add(t.n, k2._0 as rs.u16); + return rs.u16Rem(t.n, keep as rs.u16) === 0; + }), (_22: [Clash.Clash, Tally.Tally]): [rs.u8, rs.u16] => { + return [_22[0]._0, _22[1].n] as [rs.u8, rs.u16]; }); - const taken4: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _143, true, undefined, undefined, "next", 4); - const _149: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.hashIter(map2), (_23: [Clash.Clash, Tally.Tally]): [rt.u8, rt.u16] => { - return [_23[0]._0, _23[1].n] as [rt.u8, rt.u16]; + const taken4: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _143, true, undefined, undefined, "next", 4); + const _149: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.hashIter(map2), (_23: [Clash.Clash, Tally.Tally]): [rs.u8, rs.u16] => { + return [_23[0]._0, _23[1].n] as [rs.u8, rs.u16]; }); - const kept3: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _149, true, undefined, undefined, "next", 4); - const iter4: rt.Iter<[rt.u8, rt.u16]> = rt.iterChain(rt.iterChain(rt.btreeIter(taken4), rt.iterSlice([[255, 65535] as [rt.u8, rt.u16]])), rt.btreeIter(kept3)); + const kept3: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _149, true, undefined, undefined, "next", 4); + const iter4: rs.Iter<[rs.u8, rs.u16]> = rs.iterChain(rs.iterChain(rs.btreeIter(taken4), rs.iterSlice([[255, 65535] as [rs.u8, rs.u16]])), rs.btreeIter(kept3)); while (true) { - const _163: [rt.u8, rt.u16] | rt.Done = iter4.next(); - if (_163 === rt.DONE) { + const _163: [rs.u8, rs.u16] | rs.Done = iter4.next(); + if (_163 === rs.DONE) { break; } - rt.byteVecPush(out, _163[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_163[1])), undefined, true); + rs.byteVecPush(out, _163[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_163[1])), undefined, true); } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_176 = iterStart++) < iterEnd) { - rt.byteVecPush(out, option_mapOr$1ht002r(rt.hashGet(map2, { _0: _176 }), 238, (t3: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07jk2xl(rs.hashGet(map2, { _0: _176 }), 238, (t3: Tally.Tally): rs.u8 => { return t3.n & 0xff; })); } - const _187: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): Clash.Clash => { - return { _0: rt.u8Rem(_26, 6) }; + const _187: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): Clash.Clash => { + return { _0: rs.u8Rem(_26, 6) }; }); - const set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rt.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rt.HashSet, _187, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.iterCount(rt.hashExtractKeysIf(set2, (c: Clash.Clash): boolean => { - return rt.u8Rem(c._0, keep) === 0; + const set2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Clash.hash$Hash_hash_DefaultHasher as (a0: Clash.Clash, a1: rs.Hasher) => undefined, Clash.eq$cmp_PartialEq)) as rs.HashSet, _187, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.iterCount(rs.hashExtractKeysIf(set2, (c: Clash.Clash): boolean => { + return rs.u8Rem(c._0, keep) === 0; })) & 0xff); - const kept4: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.hashKeys(set2), (c2: Clash.Clash): rt.u8 => { + const kept4: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.hashKeys(set2), (c2: Clash.Clash): rs.u8 => { return c2._0; }), "next"); - rt.byteSliceView(rt.byteVecSlice(kept4)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(kept4), undefined, true); - rt.byteVecPush(out, rt.hashContains(set2, { _0: 0 }) ? 1 : 0); + rs.byteSliceView(rs.byteVecSlice(kept4)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(kept4), undefined, true); + rs.byteVecPush(out, rs.hashContains(set2, { _0: 0 }) ? 1 : 0); } } @@ -5799,30 +5799,30 @@ export function extracts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * The range form `form` picks of `lo` and `hi`, which may be backwards or empty and * excluded at both ends, neither of which `extract_if` panics on. */ -export function form(form: rt.u8, lo: rt.u16, hi: rt.u16): [rt.RangeBound, rt.RangeBound] { - const _4: rt.u8 = rt.u8Rem(form, 8); +export function form(form: rs.u8, lo: rs.u16, hi: rs.u16): [rs.RangeBound, rs.RangeBound] { + const _4: rs.u8 = rs.u8Rem(form, 8); if (_4 === 0) { - return [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 1) { - return [{ tag: "Included", _0: lo } as rt.RangeBound, { tag: "Excluded", _0: hi } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Included", _0: lo } as rs.RangeBound, { tag: "Excluded", _0: hi } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 2) { - return [{ tag: "Included", _0: lo } as rt.RangeBound, { tag: "Included", _0: hi } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Included", _0: lo } as rs.RangeBound, { tag: "Included", _0: hi } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 3) { - return [{ tag: "Included", _0: lo } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Included", _0: lo } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 4) { - return [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: hi } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: hi } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 5) { - return [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: hi } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: hi } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } if (_4 === 6) { - return [{ tag: "Excluded", _0: lo } as rt.RangeBound, { tag: "Excluded", _0: hi } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Excluded", _0: lo } as rs.RangeBound, { tag: "Excluded", _0: hi } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } - return [{ tag: "Excluded", _0: lo } as rt.RangeBound, { tag: "Included", _0: lo } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]; + return [{ tag: "Excluded", _0: lo } as rs.RangeBound, { tag: "Included", _0: lo } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]; } /** @@ -5834,149 +5834,149 @@ export function form(form: rt.u8, lo: rt.u16, hi: rt.u16): [rt.RangeBound rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function btreeExtracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const n: rt.u16 = rt.u16Mul(at(0) as rt.u16, 2); - const _13: [rt.u16, rt.u16] = [rt.u16Mul(at(1) as rt.u16, 2), rt.u16Mul(at(2) as rt.u16, 2)]; - const lo: rt.u16 = _13[0]; - const hi: rt.u16 = _13[1]; - const _28: [rt.u16, rt.u8] = [rt.u8Add(rt.u8Rem(at(3), 5), 1) as rt.u16, at(4)]; - const every: rt.u16 = _28[0]; - const limit: rt.u8 = _28[1]; - const range: [rt.RangeBound, rt.RangeBound] = form(at(5), lo, hi); - const _44: rt.u8 = rt.u8Rem(kind, 3); + const n: rs.u16 = rs.u16Mul(at(0) as rs.u16, 2); + const _13: [rs.u16, rs.u16] = [rs.u16Mul(at(1) as rs.u16, 2), rs.u16Mul(at(2) as rs.u16, 2)]; + const lo: rs.u16 = _13[0]; + const hi: rs.u16 = _13[1]; + const _28: [rs.u16, rs.u8] = [rs.u8Add(rs.u8Rem(at(3), 5), 1) as rs.u16, at(4)]; + const every: rs.u16 = _28[0]; + const limit: rs.u8 = _28[1]; + const range: [rs.RangeBound, rs.RangeBound] = form(at(5), lo, hi); + const _44: rs.u8 = rs.u8Rem(kind, 3); if (_44 === 0) { - const _47: rt.Iter<[rt.u16, rt.u16]> = rt.iterMap(new rt.Range(0, n), (k7: rt.u16): [rt.u16, rt.u16] => { - return [k7, k7 ^ 256] as [rt.u16, rt.u16]; + const _47: rs.Iter<[rs.u16, rs.u16]> = rs.iterMap(new rs.Range(0, n), (k7: rs.u16): [rs.u16, rs.u16] => { + return [k7, k7 ^ 256] as [rs.u16, rs.u16]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _47, true, undefined, undefined, undefined, 4, true); - const it: rt.Iter<[rt.u16, rt.u16]> = rt.btreeExtractIfMut(map, range, (k8: rt.u16, v2: rt.Place): boolean => { - v2.v = rt.u16Add(v2.v, 1); - return rt.u16Rem(k8 ^ limit as rt.u16, every) === 0; + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _47, true, undefined, undefined, undefined, 4, true); + const it: rs.Iter<[rs.u16, rs.u16]> = rs.btreeExtractIfMut(map, range, (k8: rs.u16, v2: rs.Place): boolean => { + v2.v = rs.u16Add(v2.v, 1); + return rs.u16Rem(k8 ^ limit as rs.u16, every) === 0; }); - const _62: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeExtractIf(it, f, rt.u16Debug, rt.u16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_62[0], f), (f: rt.Formatter) => rt.fmtOption(_62[1], f, rt.usizeDebug)], f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1]])); - const _72: rt.Iter<[rt.u16, rt.u16]> = it; - const _74: rt.usize = limit as rt.usize; - const taken: rt.Vec<[rt.u16, rt.u16]> = rt.iterToVec(rt.iterTake(rt.iterBorrow(_72), _74), "next", 4); - const _83: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(taken.items, f, (value: [rt.u16, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(value[0], f), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtBTreeExtractIf(it, f, rt.u16Debug, rt.u16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_83[0], f), (f: rt.Formatter) => rt.fmtOption(_83[1], f, rt.usizeDebug)], f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2]])); - if (rt.u8Rem(limit, 2) === 0) { - const _104: [rt.u16, rt.u16] | undefined = rt.iterToOption(it.next()); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_104, f, (value: [rt.u16, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(value[0], f), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtBTreeExtractIf(it, f, rt.u16Debug, rt.u16Debug)]; - put(out, rt.fmtFormat([args6[0], " ", rt.fmtSpec({ alternate: true }, args6[1])])); - } - const _122: rt.usize = rt.btreeLen(map); - const _125: rt.Vec<[rt.u16, rt.u16]> = rt.iterToVec(rt.iterStepBy(rt.btreeIter(map), 7), "next", 8); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_122, f), (f: rt.Formatter) => rt.fmtList(_125.items, f, (value: [rt.u16, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(value[0], f), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args8[0], " ", args8[1]])); - const taken2: rt.Vec<[rt.u16, rt.u16]> = rt.iterToVec(rt.btreeExtractIfMut(map, undefined, (_217: rt.u16, v3: rt.Place): boolean => { - return rt.u16Rem(v3.v, 3) === 0; + const _62: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_62[0], f), (f: rs.Formatter) => rs.fmtOption(_62[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + const _72: rs.Iter<[rs.u16, rs.u16]> = it; + const _74: rs.usize = limit as rs.usize; + const taken: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterTake(rs.iterBorrow(_72), _74), "next", 4); + const _83: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_83[0], f), (f: rs.Formatter) => rs.fmtOption(_83[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]])); + if (rs.u8Rem(limit, 2) === 0) { + const _104: [rs.u16, rs.u16] | undefined = rs.iterToOption(it.next()); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_104, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it, f, rs.u16Debug, rs.u16Debug)]; + put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1])])); + } + const _122: rs.usize = rs.btreeLen(map); + const _125: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterStepBy(rs.btreeIter(map), 7), "next", 8); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_122, f), (f: rs.Formatter) => rs.fmtList(_125.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args8[0], " ", args8[1]])); + const taken2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.btreeExtractIfMut(map, undefined, (_217: rs.u16, v3: rs.Place): boolean => { + return rs.u16Rem(v3.v, 3) === 0; }), "next", 4); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(taken2.items, f, (value: [rt.u16, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(value[0], f), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtMap(rt.btreeIter(map), f, rt.u16Debug, rt.u16Debug)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken2.items, f, (value: [rs.u16, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(value[0], f), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u16Debug, rs.u16Debug)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1]])); } else if (_44 === 1) { - const _152: rt.Iter = rt.iterMap(new rt.Range(0, n), (k5: rt.u16): rt.u16 => { - return rt.u16Rem(rt.u16Mul(k5, 3), rt.u16Add(n, 1)); + const _152: rs.Iter = rs.iterMap(new rs.Range(0, n), (k5: rs.u16): rs.u16 => { + return rs.u16Rem(rs.u16Mul(k5, 3), rs.u16Add(n, 1)); }); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _152, true, undefined, undefined, 2, true); - const it2: rt.Iter = rt.btreeExtractKeysIf(set, range, (k6: rt.u16): boolean => { - return rt.u16Rem(k6, every) !== 0; + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _152, true, undefined, undefined, 2, true); + const it2: rs.Iter = rs.btreeExtractKeysIf(set, range, (k6: rs.u16): boolean => { + return rs.u16Rem(k6, every) !== 0; }); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeExtractIf(it2, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args12[0]])); - const _174: rt.Iter = it2; - const _176: rt.usize = limit as rt.usize; - const taken3: rt.Vec = rt.iterToVec(rt.iterTake(rt.iterBorrow(_174), _176), "next", 2); - const _185: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(taken3.items, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtBTreeExtractIf(it2, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_185[0], f), (f: rt.Formatter) => rt.fmtOption(_185[1], f, rt.usizeDebug)], f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2]])); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSet(rt.btreeKeys(set), f, rt.u16Debug)]; - put(out, rt.fmtFormat([args16[0]])); - const part3 = rt.btreeExtractKeysIf(rt.btreeNew(rt.cmp) as rt.BTreeSet, range, (_212: rt.u16): boolean => { + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args12[0]])); + const _174: rs.Iter = it2; + const _176: rs.usize = limit as rs.usize; + const taken3: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterBorrow(_174), _176), "next", 2); + const _185: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(taken3.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBTreeExtractIf(it2, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_185[0], f), (f: rs.Formatter) => rs.fmtOption(_185[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u16Debug)]; + put(out, rs.fmtFormat([args16[0]])); + const part3 = rs.btreeExtractKeysIf(rs.btreeNew(rs.cmp) as rs.BTreeSet, range, (_212: rs.u16): boolean => { return true; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeExtractIf(part3, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args18[0]])); - rt.btreeClear(set); - const part4 = rt.btreeExtractKeysIf(set, undefined, (_216: rt.u16): boolean => { + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part3, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args18[0]])); + rs.btreeClear(set); + const part4 = rs.btreeExtractKeysIf(set, undefined, (_216: rs.u16): boolean => { return true; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeExtractIf(part4, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeExtractIf(part4, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args20[0]])); } else { - const log: rt.RefCell> = new rt.RefCell(new rt.Vec()); - const _243: rt.Iter<[Logged.Logged, Logged.Logged]> = rt.iterMap(new rt.Range(0, rt.u16Div(n, 2)), (k: rt.u16): [Logged.Logged, Logged.Logged] => { + const log: rs.RefCell> = new rs.RefCell(new rs.Vec()); + const _243: rs.Iter<[Logged.Logged, Logged.Logged]> = rs.iterMap(new rs.Range(0, rs.u16Div(n, 2)), (k: rs.u16): [Logged.Logged, Logged.Logged] => { return [new Logged.Logged(k, log), new Logged.Logged(4096 | k, log)] as [Logged.Logged, Logged.Logged]; }); - const map2: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Logged.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_243, undefined, 16, true).items, 16, true, Logged.eq$cmp_PartialEq, rt.drop, rt.drop); + const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Logged.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_243, undefined, 16, true).items, 16, true, Logged.eq$cmp_PartialEq, rs.drop, rs.drop); const guard: Logged.Logged = new Logged.Logged(2048, log); - const _253: [Logged.Logged, Logged.Logged] = [new Logged.Logged(2304 | rt.u16Div(lo, 2), log), new Logged.Logged(2304 | rt.u16Div(hi, 2), log)]; - const _266: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: _253[0] } as rt.RangeBound, { tag: "Included", _0: _253[1] } as rt.RangeBound]; + const _253: [Logged.Logged, Logged.Logged] = [new Logged.Logged(2304 | rs.u16Div(lo, 2), log), new Logged.Logged(2304 | rs.u16Div(hi, 2), log)]; + const _266: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: _253[0] } as rs.RangeBound, { tag: "Included", _0: _253[1] } as rs.RangeBound]; const captured = guard; const captured2 = every; - const _269: (a0: Logged.Logged, a1: Logged.Logged) => boolean = rt.closure((k2: Logged.Logged, v: Logged.Logged): boolean => { + const _269: (a0: Logged.Logged, a1: Logged.Logged) => boolean = rs.closure((k2: Logged.Logged, v: Logged.Logged): boolean => { v._0 = v._0 ^ 512; - return rt.u16Rem(k2._0, captured2) === 0; + return rs.u16Rem(k2._0, captured2) === 0; }, (): void => { captured[Symbol.dispose](); }); - const it3: rt.Iter<[Logged.Logged, Logged.Logged]> = ((range2) => rt.btreeExtractIf(map2, range2, _269, Logged.le$cmp_PartialOrd, Logged.lt$cmp_PartialOrd, () => drop$tuple2_ops_Bound_collections_Logged_ops_Bound_collections_Logged(range2)))(_266); - const _272: rt.Iter<[Logged.Logged, Logged.Logged]> = it3; - const _274: rt.usize = rt.u8Rem(limit, 8) as rt.usize; - const taken4: rt.Vec<[Logged.Logged, Logged.Logged]> = rt.iterToVec(rt.iterTake(rt.iterBorrow(_272), _274, drop$tuple2_collections_Logged_collections_Logged), "next", 16); - rt.drop(it3); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(taken4.items), (_2: [Logged.Logged, Logged.Logged]): Uint8Array => { + const it3: rs.Iter<[Logged.Logged, Logged.Logged]> = ((range2) => rs.btreeExtractIf(map2, range2, _269, Logged.le$cmp_PartialOrd, Logged.lt$cmp_PartialOrd, () => drop$tuple2_ops_Bound_collections_Logged_ops_Bound_collections_Logged(range2)))(_266); + const _272: rs.Iter<[Logged.Logged, Logged.Logged]> = it3; + const _274: rs.usize = rs.u8Rem(limit, 8) as rs.usize; + const taken4: rs.Vec<[Logged.Logged, Logged.Logged]> = rs.iterToVec(rs.iterTake(rs.iterBorrow(_272), _274, drop$tuple2_collections_Logged_collections_Logged), "next", 16); + rs.drop(it3); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(taken4.items), (_2: [Logged.Logged, Logged.Logged]): Uint8Array => { return Uint8Array.of(_2[0]._0 & 0xff, _2[1]._0 & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.dropVec(taken4, drop$tuple2_collections_Logged_collections_Logged); - const _287: rt.Range = new rt.Range(new Logged.Logged(2560 | rt.u16Div(lo, 4), log), new Logged.Logged(2560 | rt.u16Div(hi, 4), log)); - const it4: rt.Iter<[Logged.Logged, Logged.Logged]> = ((range3) => rt.btreeExtractIf(map2, range3, (_23: Logged.Logged, _38: Logged.Logged): boolean => { + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.dropVec(taken4, drop$tuple2_collections_Logged_collections_Logged); + const _287: rs.Range = new rs.Range(new Logged.Logged(2560 | rs.u16Div(lo, 4), log), new Logged.Logged(2560 | rs.u16Div(hi, 4), log)); + const it4: rs.Iter<[Logged.Logged, Logged.Logged]> = ((range3) => rs.btreeExtractIf(map2, range3, (_23: Logged.Logged, _38: Logged.Logged): boolean => { return false; }, Logged.le$cmp_PartialOrd, Logged.lt$cmp_PartialOrd, () => drop$ops_Range_collections_Logged(range3)))(_287); - const _302: [Logged.Logged, Logged.Logged] | undefined = rt.iterToOption(it4.next()); - rt.byteVecPush(out, _302 === undefined ? 1 : 0); + const _302: [Logged.Logged, Logged.Logged] | undefined = rs.iterToOption(it4.next()); + rs.byteVecPush(out, _302 === undefined ? 1 : 0); drop$Option_tuple2_collections_Logged_collections_Logged(_302); - rt.drop(it4); - rt.iterForEach(rt.btreeIter(map2, rt.drop, rt.drop), (a0: [Logged.Logged, Logged.Logged]): undefined => { + rs.drop(it4); + rs.iterForEach(rs.btreeIter(map2, rs.drop, rs.drop), (a0: [Logged.Logged, Logged.Logged]): undefined => { drop$tuple2_collections_Logged_collections_Logged(a0); }, true); - const bytes: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const window: (a0: rt.u16, a1: rt.u16) => Window.Window = (lo2: rt.u16, hi2: rt.u16): Window.Window => { + const bytes: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const window: (a0: rs.u16, a1: rs.u16) => Window.Window = (lo2: rs.u16, hi2: rs.u16): Window.Window => { return { lo: lo2, hi: hi2, log }; }; const _315: Window.Window = window(0, 9); - rt.iterForEach(rt.btreeExtractIfMut(bytes, rt.boundsOf(_315, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), (_26: rt.u16, _310: rt.Place): boolean => { + rs.iterForEach(rs.btreeExtractIfMut(bytes, rs.boundsOf(_315, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), (_26: rs.u16, _310: rs.Place): boolean => { return true; - }), (_a02: [rt.u16, rt.u8]): undefined => { + }), (_a02: [rs.u16, rs.u8]): undefined => { undefined; }); - rt.btreeInsert(bytes, 1, 1); - rt.btreeRemove(bytes, 1); + rs.btreeInsert(bytes, 1, 1); + rs.btreeRemove(bytes, 1); const _326: Window.Window = window(0, 9); - rt.iterForEach(rt.btreeExtractIfMut(bytes, rt.boundsOf(_326, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), (_27: rt.u16, _311: rt.Place): boolean => { + rs.iterForEach(rs.btreeExtractIfMut(bytes, rs.boundsOf(_326, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), (_27: rs.u16, _311: rs.Place): boolean => { return true; - }), (_a03: [rt.u16, rt.u8]): undefined => { + }), (_a03: [rs.u16, rs.u8]): undefined => { undefined; }); - const _331: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(new rt.Range(0, n), (k3: rt.u16): [rt.u16, rt.u8] => { - return [k3, k3 & 0xff] as [rt.u16, rt.u8]; + const _331: rs.Iter<[rs.u16, rs.u8]> = rs.iterMap(new rs.Range(0, n), (k3: rs.u16): [rs.u16, rs.u8] => { + return [k3, k3 & 0xff] as [rs.u16, rs.u8]; }); - rt.btreeExtend(bytes, _331); - const _336: Window.Window = window(rt.u16Div(lo, 2), rt.u16Div(hi, 2)); - const _343: (a0: rt.u16, a1: rt.Place) => boolean = (k4: rt.u16, _314: rt.Place): boolean => { - return rt.u16Rem(k4, every) === 0; + rs.btreeExtend(bytes, _331); + const _336: Window.Window = window(rs.u16Div(lo, 2), rs.u16Div(hi, 2)); + const _343: (a0: rs.u16, a1: rs.Place) => boolean = (k4: rs.u16, _314: rs.Place): boolean => { + return rs.u16Rem(k4, every) === 0; }; - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToVec(rt.btreeExtractIfMut(bytes, rt.boundsOf(_336, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), _343), "next", 4).items), (_210: [rt.u16, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.iterToVec(rs.btreeExtractIfMut(bytes, rs.boundsOf(_336, Window.startBound$ops_RangeBounds_u16, Window.endBound$ops_RangeBounds_u16), _343), "next", 4).items), (_210: [rs.u16, rs.u8]): rs.u8 => { return _210[1]; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.refCellReplace(log, new rt.Vec()).items), (e: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(e); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(rs.refCellReplace(log, new rs.Vec()).items), (e: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(e); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } diff --git a/ts/fixtures/lang/collections/expected/core/bool.ts b/ts/fixtures/lang/collections/expected/core/bool.ts index 2cc2d5775..3bede20ec 100644 --- a/ts/fixtures/lang/collections/expected/core/bool.ts +++ b/ts/fixtures/lang/collections/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function then$0wlzj76(self: boolean, f: () => rt.Ordering): rt.Ordering | undefined { +export function then$1f3a6te(self: boolean, f: () => rs.Ordering): rs.Ordering | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/collections/expected/core/option.ts b/ts/fixtures/lang/collections/expected/core/option.ts index f45aa2806..8c46ae06e 100644 --- a/ts/fixtures/lang/collections/expected/core/option.ts +++ b/ts/fixtures/lang/collections/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as ByRef from "../collections.ByRef.ts"; import type * as ByVal from "../collections.ByVal.ts"; import type * as Mixed from "../collections.Mixed.ts"; @@ -9,154 +9,154 @@ import type * as Picky from "../collections.Picky.ts"; import type * as Rank from "../collections.Rank.ts"; import type * as Tally from "../collections.Tally.ts"; -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0ltgf8p(self: ByRef.ByRef | undefined, f: (a0: ByRef.ByRef) => rt.u8): rt.u8 | undefined { +export function map$1pdxnel(self: ByRef.ByRef | undefined, f: (a0: ByRef.ByRef) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1ajptuf(self: ByVal.ByVal | undefined, f: (a0: ByVal.ByVal) => rt.u8): rt.u8 | undefined { +export function map$093awy8(self: ByVal.ByVal | undefined, f: (a0: ByVal.ByVal) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0i8kclf(self: Mixed.Mixed | undefined, f: (a0: Mixed.Mixed) => rt.u8): rt.u8 | undefined { +export function map$0aug5m6(self: Mixed.Mixed | undefined, f: (a0: Mixed.Mixed) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$09ua5et(self: Nibble.Nibble | undefined, f: (a0: Nibble.Nibble) => rt.u8): rt.u8 | undefined { +export function map$16w3l9s(self: Nibble.Nibble | undefined, f: (a0: Nibble.Nibble) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0oc32h1(self: rt.u8 | undefined, f: (a0: rt.u8) => string): string | undefined { +export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$05nbzug(self: rt.usize | undefined, f: (a0: rt.usize) => rt.u8): rt.u8 | undefined { +export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0q0ymkh(self: Nibble.Nibble | undefined, default_: rt.u8, f: (a0: Nibble.Nibble) => rt.u8): rt.u8 { +export function mapOr$0f7cus0(self: Nibble.Nibble | undefined, default_: rs.u8, f: (a0: Nibble.Nibble) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ht002r(self: Tally.Tally | undefined, default_: rt.u8, f: (a0: Tally.Tally) => rt.u8): rt.u8 { +export function mapOr$07jk2xl(self: Tally.Tally | undefined, default_: rs.u8, f: (a0: Tally.Tally) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1xztl8h(self: rt.u8 | undefined | rt.None, default_: rt.u8, f: (a0: rt.u8 | undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$1rg5gkk(self: rs.u8 | undefined | rs.None, default_: rs.u8, f: (a0: rs.u8 | undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(self); } -export function mapOr$1w1gbwl(self: rt.ByteSlice | undefined, default_: rt.u8, f: (a0: rt.ByteSlice) => rt.u8): rt.u8 { +export function mapOr$1lwzqm5(self: rs.ByteSlice | undefined, default_: rs.u8, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0bnr5nu(self: Picky.Picky | undefined, default_: rt.u16, f: (a0: Picky.Picky) => rt.u16): rt.u16 { +export function mapOr$0pgapuk(self: Picky.Picky | undefined, default_: rs.u16, f: (a0: Picky.Picky) => rs.u16): rs.u16 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1nlkf9b(self: [rt.u8, rt.u8] | undefined, default_: Uint8Array, f: (a0: [rt.u8, rt.u8]) => Uint8Array): Uint8Array { +export function mapOr$13kt6x8(self: [rs.u8, rs.u8] | undefined, default_: Uint8Array, f: (a0: [rs.u8, rs.u8]) => Uint8Array): Uint8Array { if (self === undefined) { return default_; } return f(self); } -export function mapOr$099335t(self: rt.u16 | undefined, default_: rt.u8, f: (a0: rt.u16) => rt.u8): rt.u8 { +export function mapOr$031uhqp(self: rs.u16 | undefined, default_: rs.u8, f: (a0: rs.u16) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0z4mj8g(self: rt.u8 | undefined, default_: rt.u16, f: (a0: rt.u8) => rt.u16): rt.u16 { +export function mapOr$18dcmgz(self: rs.u8 | undefined, default_: rs.u16, f: (a0: rs.u8) => rs.u16): rs.u16 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1to2ul4(self: [Rank.Rank, Tally.Tally] | undefined, default_: rt.u8, f: (a0: [Rank.Rank, Tally.Tally]) => rt.u8): rt.u8 { +export function mapOr$0955beb(self: [Rank.Rank, Tally.Tally] | undefined, default_: rs.u8, f: (a0: [Rank.Rank, Tally.Tally]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0mmpeqx(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -170,8 +170,8 @@ export function clone$14nprly(self: string | undefined): string | undefined { return self; } -export function flatten$1nwzx42(self: rt.u8 | undefined | rt.None): rt.u8 | undefined { - if (self === rt.None) { +export function flatten$0ux6gqw(self: rs.u8 | undefined | rs.None): rs.u8 | undefined { + if (self === rs.None) { return undefined; } return self; diff --git a/ts/fixtures/lang/collections/expected/core/result.ts b/ts/fixtures/lang/collections/expected/core/result.ts index 4d5345cb0..c9d394094 100644 --- a/ts/fixtures/lang/collections/expected/core/result.ts +++ b/ts/fixtures/lang/collections/expected/core/result.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as ByRef from "../collections.ByRef.ts"; import * as ByVal from "../collections.ByVal.ts"; -export function eq$1dt73ez(self: rt.Result, other: rt.Result): boolean { +export function eq$1a91ieh(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return ByRef.eq$cmp_PartialEq_ref(self.value, (other as { ok: true; value: ByRef.ByRef }).value); } - return self.error === (other as { ok: false; error: rt.u8 }).error; + return self.error === (other as { ok: false; error: rs.u8 }).error; } -export function eq$163neqy(self: rt.Result, other: rt.Result): boolean { +export function eq$122baxc(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return ByVal.eq$cmp_PartialEq(self.value, (other as { ok: true; value: ByVal.ByVal }).value); } - return self.error === (other as { ok: false; error: rt.u8 }).error; + return self.error === (other as { ok: false; error: rs.u8 }).error; } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/collections/expected/harness.ts b/ts/fixtures/lang/collections/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/collections/expected/harness.ts +++ b/ts/fixtures/lang/collections/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/collections/expected/lib.ts b/ts/fixtures/lang/collections/expected/lib.ts index 89cfafd7e..5e84e9cac 100644 --- a/ts/fixtures/lang/collections/expected/lib.ts +++ b/ts/fixtures/lang/collections/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { hashMaps, sets, btreeMaps, deques, dequeRanges, vecs, stores, optionals, setOps, unlikeEqs, ownNes, cellEqs, unlikeCompares, refOrders, extracts, btreeExtracts } from "./collections.ts"; import type * as Bumped from "./collections.Bumped.ts"; import type * as Logged from "./collections.Logged.ts"; @@ -17,11 +17,11 @@ export function copy$array_collections_Quirky(v: Quirky.Quirky[]): Quirky.Quirky return v.map(copy$collections_Quirky); } -export function copy$array_tuple2_u8_u16(v: [rt.u8, rt.u16][]): [rt.u8, rt.u16][] { +export function copy$array_tuple2_u8_u16(v: [rs.u8, rs.u16][]): [rs.u8, rs.u16][] { return v.map(copy$tuple2_u8_u16); } -export function copy$array_tuple2_u8_u8(v: [rt.u8, rt.u8][]): [rt.u8, rt.u8][] { +export function copy$array_tuple2_u8_u8(v: [rs.u8, rs.u8][]): [rs.u8, rs.u8][] { return v.map(copy$tuple2_u8_u8); } @@ -41,19 +41,19 @@ export function copy$collections_Tally(v: Tally.Tally): Tally.Tally { return { n: v.n }; } -export function copy$collections_Wrap_u8(v: Wrap.Wrap): Wrap.Wrap { +export function copy$collections_Wrap_u8(v: Wrap.Wrap): Wrap.Wrap { return new Wrap.Wrap(v.value, v.count); } -export function copy$tuple2_u8_collections_Tally(v: [rt.u8, Tally.Tally]): [rt.u8, Tally.Tally] { +export function copy$tuple2_u8_collections_Tally(v: [rs.u8, Tally.Tally]): [rs.u8, Tally.Tally] { return [v[0], copy$collections_Tally(v[1])]; } -export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } @@ -63,7 +63,7 @@ export function drop$Option_tuple2_collections_Logged_collections_Logged(_1: [Lo } } -export function drop$ops_Bound_collections_Logged(_1: rt.RangeBound): void { +export function drop$ops_Bound_collections_Logged(_1: rs.RangeBound): void { if (_1.tag === "Included") { (_1 as { tag: "Included"; _0: Logged.Logged })._0[Symbol.dispose](); } else if (_1.tag === "Excluded") { @@ -71,8 +71,8 @@ export function drop$ops_Bound_collections_Logged(_1: rt.RangeBound): void { - rt.dropAll([value.start, value.end]); +export function drop$ops_Range_collections_Logged(value: rs.Range): void { + rs.dropAll([value.start, value.end]); } export function drop$tuple2_collections_Logged_collections_Logged(_1: [Logged.Logged, Logged.Logged]): void { @@ -80,12 +80,12 @@ export function drop$tuple2_collections_Logged_collections_Logged(_1: [Logged.Lo _1[1][Symbol.dispose](); } -export function drop$tuple2_ops_Bound_collections_Logged_ops_Bound_collections_Logged(_1: [rt.RangeBound, rt.RangeBound]): void { +export function drop$tuple2_ops_Bound_collections_Logged_ops_Bound_collections_Logged(_1: [rs.RangeBound, rs.RangeBound]): void { drop$ops_Bound_collections_Logged(_1[0]); drop$ops_Bound_collections_Logged(_1[1]); } -export function drop$tuple2_sync_Arc_collections_Picky_u8(_1: [rt.Arc, rt.u8]): void { +export function drop$tuple2_sync_Arc_collections_Picky_u8(_1: [rs.Arc, rs.u8]): void { _1[0][Symbol.dispose](); } @@ -93,14 +93,14 @@ export function drop$tuple2_sync_Arc_collections_Picky_u8(_1: [rt.Arc undefined]> { - return rt.vecFrom([["collections::hash_maps", hashMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::sets", sets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deques", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["collections::hash_maps", hashMaps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::sets", sets as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_maps", btreeMaps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::deques", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { deques(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::vecs", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::vecs", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { vecs(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::stores", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::stores", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { stores(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::deque_ranges", dequeRanges as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::extracts", extracts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["collections::btree_extracts", btreeExtracts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::optionals", optionals as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::set_ops", setOps as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_eqs", unlikeEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::own_nes", ownNes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::cell_eqs", cellEqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::unlike_compares", unlikeCompares as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::ref_orders", refOrders as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::deque_ranges", dequeRanges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::extracts", extracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["collections::btree_extracts", btreeExtracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/combinators/expected/combinators.ts b/ts/fixtures/lang/combinators/expected/combinators.ts index 620c656f2..c2a3567f0 100644 --- a/ts/fixtures/lang/combinators/expected/combinators.ts +++ b/ts/fixtures/lang/combinators/expected/combinators.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Result_array2_u32_u16, copy$array_u32 } from "./lib.ts"; -import { isSomeAnd$09tpccf, isNoneOr$1s1o3ss, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrElse$1badkpb as option_unwrapOrElse$1badkpb, unwrapOrElse$13moxzl as option_unwrapOrElse$13moxzl, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw as option_unwrapOrDefault$0wx44sw, unwrapOrDefault$1q0ps0j as option_unwrapOrDefault$1q0ps0j, map$0oc32h1 as option_map$0oc32h1, map$0ejznqm as option_map$0ejznqm, map$0jg2jop as option_map$0jg2jop, map$0cs071d as option_map$0cs071d, inspect$0di0vx1 as option_inspect$0di0vx1, mapOr$0mmpeqx as option_mapOr$0mmpeqx, mapOr$099335t as option_mapOr$099335t, mapOr$1surhce as option_mapOr$1surhce, mapOrElse$1g6d36t as option_mapOrElse$1g6d36t, okOr$07zal2e as option_okOr$07zal2e, okOr$0m6xlfp as option_okOr$0m6xlfp, okOr$1vxk0yk as option_okOr$1vxk0yk, okOrElse$0awp3vn as option_okOrElse$0awp3vn, okOrElse$1v98j0a as option_okOrElse$1v98j0a, and$06om98g as option_and$06om98g, andThen$17ch833 as option_andThen$17ch833, filter$1855tjj, filter$0v80fk8, or$1loyskh as option_or$1loyskh, orElse$05gzawv as option_orElse$05gzawv, orElse$15bv4ho as option_orElse$15bv4ho, xor$0kctyix, zip$1deudzj, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; -import { isOkAnd$0jj0nkw, isErrAnd$0b01a39, ok$1c77lmd, err$05f656d, asRef$1glrxiq, map$1qqg34g as result_map$1qqg34g, map$132mdj8 as result_map$132mdj8, mapOr$1mu5bvh as result_mapOr$1mu5bvh, mapOrElse$0jxx67n as result_mapOrElse$0jxx67n, mapErr$12w1s5x as result_mapErr$12w1s5x, mapErr$1lsqfgi as result_mapErr$1lsqfgi, inspect$16o3gle as result_inspect$16o3gle, inspectErr$06tv5sa, unwrapOrDefault$1exw7nd as result_unwrapOrDefault$1exw7nd, and$0l7ltae as result_and$0l7ltae, andThen$0hd6ik8 as result_andThen$0hd6ik8, or$1xcfx3w as result_or$1xcfx3w, orElse$13ay4um as result_orElse$13ay4um, unwrapOr$0a4h2e7 as result_unwrapOr$0a4h2e7, unwrapOrElse$1reohq9 as result_unwrapOrElse$1reohq9, unwrapOrElse$009ibtw as result_unwrapOrElse$009ibtw, copied$0ma6p21, clone$04fntvl as result_clone$04fntvl } from "./core/result.ts"; +import { isSomeAnd$1s2u5lz, isNoneOr$0xn3i4j, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrElse$1badkpb as option_unwrapOrElse$1badkpb, unwrapOrElse$0wd124z as option_unwrapOrElse$0wd124z, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$1y26nmr as option_map$1y26nmr, map$1px2rk4 as option_map$1px2rk4, map$1ek423e as option_map$1ek423e, map$1yjmt5m as option_map$1yjmt5m, inspect$1sa9a1m as option_inspect$1sa9a1m, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$031uhqp as option_mapOr$031uhqp, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOrElse$0moj49b as option_mapOrElse$0moj49b, okOr$12zia2c as option_okOr$12zia2c, okOr$19jxvkb as option_okOr$19jxvkb, okOr$1j8owgb as option_okOr$1j8owgb, okOrElse$1usib9z as option_okOrElse$1usib9z, okOrElse$0cs4x8k as option_okOrElse$0cs4x8k, and$02hlbkj as option_and$02hlbkj, andThen$195hx6l as option_andThen$195hx6l, filter$1855tjj, filter$0hq86nl, or$0ar58vy as option_or$0ar58vy, orElse$05gzawv as option_orElse$05gzawv, orElse$1xazu5k as option_orElse$1xazu5k, xor$0x5qjg4, zip$0p00b0o, clone$14nprly as option_clone$14nprly } from "./core/option.ts"; +import { isOkAnd$1poqzjs, isErrAnd$0ecrrmy, ok$08qo4au, err$0zs6b4d, asRef$0qzh9or, map$0jdlh8o as result_map$0jdlh8o, map$044vsgj as result_map$044vsgj, mapOr$1yz3viz as result_mapOr$1yz3viz, mapOrElse$0eu5k5b as result_mapOrElse$0eu5k5b, mapErr$12sqndm as result_mapErr$12sqndm, mapErr$16o3r40 as result_mapErr$16o3r40, inspect$1lvk7wu as result_inspect$1lvk7wu, inspectErr$0nqm52c, unwrapOrDefault$0ysbycw as result_unwrapOrDefault$0ysbycw, and$1cozx1j as result_and$1cozx1j, andThen$19hld68 as result_andThen$19hld68, or$1sapa01 as result_or$1sapa01, orElse$009jxpk as result_orElse$009jxpk, unwrapOr$137i3aj as result_unwrapOr$137i3aj, unwrapOrElse$1d4fano as result_unwrapOrElse$1d4fano, unwrapOrElse$1iet7cd as result_unwrapOrElse$1iet7cd, copied$10r3llp, clone$1dcpug1 as result_clone$1dcpug1 } from "./core/result.ts"; /** Run case `kind % 4` over `data`, whose bytes pick each `Some` or `None`, `Ok` or `Err`. */ -export function combinators(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 | undefined = filter$0v80fk8(rt.byteSliceFirst(data), (x: rt.u8): boolean => { - return rt.u8Rem(x, 3) !== 0; +export function combinators(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 | undefined = filter$0hq86nl(rs.byteSliceFirst(data), (x: rs.u8): boolean => { + return rs.u8Rem(x, 3) !== 0; }); - const b: rt.u8 | undefined = filter$0v80fk8(rt.byteSliceGet(data, 1), (x2: rt.u8): boolean => { - return rt.u8Rem(x2, 5) !== 0; + const b: rs.u8 | undefined = filter$0hq86nl(rs.byteSliceGet(data, 1), (x2: rs.u8): boolean => { + return rs.u8Rem(x2, 5) !== 0; }); - const limit: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 2), 128); - const _13: rt.u8 = rt.u8Rem(kind, 4); + const limit: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 2), 128); + const _13: rs.u8 = rs.u8Rem(kind, 4); if (_13 === 0) { options(a, b, limit, out); } else if (_13 === 1) { @@ -26,220 +26,220 @@ export function combinators(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v } } -export function options(a: rt.u8 | undefined, b: rt.u8 | undefined, limit: rt.u8, out: rt.ByteVec): void { - rt.byteVecPush(out, isSomeAnd$09tpccf(a, (x: rt.u8): boolean => { - rt.byteVecPush(out, 160); +export function options(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8, out: rs.ByteVec): void { + rs.byteVecPush(out, isSomeAnd$1s2u5lz(a, (x: rs.u8): boolean => { + rs.byteVecPush(out, 160); return x > limit; }) ? 1 : 0); - rt.byteVecPush(out, isNoneOr$1s1o3ss(b, (x2: rt.u8): boolean => { - rt.byteVecPush(out, 161); + rs.byteVecPush(out, isNoneOr$0xn3i4j(b, (x2: rs.u8): boolean => { + rs.byteVecPush(out, 161); return x2 < limit; }) ? 1 : 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(option_andThen$17ch833(option_andThen$17ch833(a, (x3: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedAdd(x3, limit); - }), (x4: rt.u8): rt.u8 | undefined => { - rt.byteVecPush(out, 162); - return option_map$0cs071d(b, (y: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(option_andThen$195hx6l(option_andThen$195hx6l(a, (x3: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedAdd(x3, limit); + }), (x4: rs.u8): rs.u8 | undefined => { + rs.byteVecPush(out, 162); + return option_map$1yjmt5m(b, (y: rs.u8): rs.u8 => { return x4 ^ y; }); }), 238)); - rt.byteVecPush(out, option_mapOr$1surhce(filter$0v80fk8(a, (x5: rt.u8): boolean => { - rt.byteVecPush(out, 163); + rs.byteVecPush(out, option_mapOr$0vxw5sq(filter$0hq86nl(a, (x5: rs.u8): boolean => { + rs.byteVecPush(out, 163); return x5 > limit; - }), 221, (x6: rt.u8): rt.u8 => { - return rt.u8Div(x6, 3); + }), 221, (x6: rs.u8): rs.u8 => { + return rs.u8Div(x6, 3); })); - rt.byteVecPush(out, option_mapOrElse$1g6d36t(option_orElse$15bv4ho(a, (): rt.u8 | undefined => { - rt.byteVecPush(out, 164); + rs.byteVecPush(out, option_mapOrElse$0moj49b(option_orElse$1xazu5k(a, (): rs.u8 | undefined => { + rs.byteVecPush(out, 164); return b; - }), (): rt.u8 => { - rt.byteVecPush(out, 165); + }), (): rs.u8 => { + rs.byteVecPush(out, 165); return 204; - }, (x7: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(x7, 3); + }, (x7: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(x7, 3); })); - rt.byteVecPush(out, option_unwrapOrDefault$1q0ps0j(xor$0kctyix(a, b))); - rt.byteVecPush(out, option_unwrapOrElse$13moxzl(option_and$06om98g(a, b), (): rt.u8 => { - rt.byteVecPush(out, 166); + rs.byteVecPush(out, option_unwrapOrDefault$03apme8(xor$0x5qjg4(a, b))); + rs.byteVecPush(out, option_unwrapOrElse$0wd124z(option_and$02hlbkj(a, b), (): rs.u8 => { + rs.byteVecPush(out, 166); return 187; })); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(option_or$1loyskh(a, b), 170)); - rt.byteVecPush(out, option_mapOr$0mmpeqx(zip$1deudzj(a, b), 0, (_2: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingAdd(_2[0], _2[1]); + rs.byteVecPush(out, option_unwrapOr$1fr498u(option_or$0ar58vy(a, b), 170)); + rs.byteVecPush(out, option_mapOr$1h9hu6n(zip$0p00b0o(a, b), 0, (_2: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingAdd(_2[0], _2[1]); })); - rt.byteVecPush(out, option_inspect$0di0vx1(a, (x9: rt.u8): undefined => { - rt.byteVecPush(out, x9); + rs.byteVecPush(out, option_inspect$1sa9a1m(a, (x9: rs.u8): undefined => { + rs.byteVecPush(out, x9); }) !== undefined ? 1 : 0); - push(result_map$132mdj8(option_okOrElse$1v98j0a(b, (): rt.u16 => { - rt.byteVecPush(out, 167); - return ((limit as rt.u16) << 1) & 0xffff; - }), (x10: rt.u8): rt.u8 => { + push(result_map$044vsgj(option_okOrElse$0cs4x8k(b, (): rs.u16 => { + rs.byteVecPush(out, 167); + return ((limit as rs.u16) << 1) & 0xffff; + }), (x10: rs.u8): rs.u8 => { return x10 ^ limit; }), out); } -export function results(a: rt.u8 | undefined, b: rt.u8 | undefined, limit: rt.u8, out: rt.ByteVec): void { - const r: rt.Result = option_okOr$0m6xlfp(a, rt.u16Mul(limit as rt.u16, 3)); - const s: rt.Result = option_okOrElse$1v98j0a(b, (): rt.u16 => { +export function results(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8, out: rs.ByteVec): void { + const r: rs.Result = option_okOr$19jxvkb(a, rs.u16Mul(limit as rs.u16, 3)); + const s: rs.Result = option_okOrElse$0cs4x8k(b, (): rs.u16 => { return 511; }); - push(result_mapErr$1lsqfgi(result_map$132mdj8(r, (x: rt.u8): rt.u8 => { - rt.byteVecPush(out, 177); - return rt.u8WrappingAdd(x, limit); - }), (e: rt.u16): rt.u16 => { - rt.byteVecPush(out, 178); - return rt.u16WrappingAdd(e, 1); + push(result_mapErr$16o3r40(result_map$044vsgj(r, (x: rs.u8): rs.u8 => { + rs.byteVecPush(out, 177); + return rs.u8WrappingAdd(x, limit); + }), (e: rs.u16): rs.u16 => { + rs.byteVecPush(out, 178); + return rs.u16WrappingAdd(e, 1); }), out); - push(result_orElse$13ay4um(result_andThen$0hd6ik8(r, (x2: rt.u8): rt.Result => { - return option_okOr$0m6xlfp(rt.u8CheckedMul(x2, limit), 7); - }), (e2: rt.u16): rt.Result => { - rt.byteVecPush(out, 179); - if (rt.u16Rem(e2, 2) === 0) { - return rt.Ok(1); + push(result_orElse$009jxpk(result_andThen$19hld68(r, (x2: rs.u8): rs.Result => { + return option_okOr$19jxvkb(rs.u8CheckedMul(x2, limit), 7); + }), (e2: rs.u16): rs.Result => { + rs.byteVecPush(out, 179); + if (rs.u16Rem(e2, 2) === 0) { + return rs.Ok(1); } - return rt.Err(e2); + return rs.Err(e2); }), out); - rt.byteVecPush(out, isOkAnd$0jj0nkw(r, (v: rt.u8): boolean => { + rs.byteVecPush(out, isOkAnd$1poqzjs(r, (v: rs.u8): boolean => { return v > 3; }) ? 1 : 0); - rt.byteVecPush(out, isErrAnd$0b01a39(s, (e3: rt.u16): boolean => { - rt.byteVecPush(out, 180); + rs.byteVecPush(out, isErrAnd$0ecrrmy(s, (e3: rs.u16): boolean => { + rs.byteVecPush(out, 180); return e3 > 256; }) ? 1 : 0); - rt.byteVecPush(out, result_mapOr$1mu5bvh(r, 17, (v2: rt.u8): rt.u8 => { - return rt.u8Div(v2, 2); + rs.byteVecPush(out, result_mapOr$1yz3viz(r, 17, (v2: rs.u8): rs.u8 => { + return rs.u8Div(v2, 2); })); - rt.byteVecPush(out, result_mapOrElse$0jxx67n(s, (e4: rt.u16): rt.u8 => { + rs.byteVecPush(out, result_mapOrElse$0eu5k5b(s, (e4: rs.u16): rs.u8 => { return e4 & 0xff; - }, (v3: rt.u8): rt.u8 => { + }, (v3: rs.u8): rs.u8 => { return v3 ^ 85; })); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ok$1c77lmd(r), 0)); - rt.byteVecPush(out, option_mapOr$099335t(err$05f656d(s), 0, (e5: rt.u16): rt.u8 => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(ok$08qo4au(r), 0)); + rs.byteVecPush(out, option_mapOr$031uhqp(err$0zs6b4d(s), 0, (e5: rs.u16): rs.u8 => { return (e5 >> 8) & 0xff; })); - rt.byteVecPush(out, result_unwrapOrDefault$1exw7nd(result_and$0l7ltae(r, s))); - rt.byteVecPush(out, result_unwrapOrElse$1reohq9(result_or$1xcfx3w(r, s), (e6: rt.u16): rt.u8 => { + rs.byteVecPush(out, result_unwrapOrDefault$0ysbycw(result_and$1cozx1j(r, s))); + rs.byteVecPush(out, result_unwrapOrElse$1d4fano(result_or$1sapa01(r, s), (e6: rs.u16): rs.u8 => { return e6 & 0xff; })); - rt.byteVecPush(out, inspectErr$06tv5sa(result_inspect$16o3gle(s, (v4: rt.u8): undefined => { - rt.byteVecPush(out, v4); - }), (e7: rt.u16): undefined => { - rt.byteVecPush(out, e7 & 0xff); + rs.byteVecPush(out, inspectErr$0nqm52c(result_inspect$1lvk7wu(s, (v4: rs.u8): undefined => { + rs.byteVecPush(out, v4); + }), (e7: rs.u16): undefined => { + rs.byteVecPush(out, e7 & 0xff); }).ok ? 1 : 0); - rt.byteVecPush(out, result_unwrapOr$0a4h2e7(copied$0ma6p21(result_mapErr$1lsqfgi(asRef$1glrxiq(r), (e8: rt.u16): rt.u16 => { + rs.byteVecPush(out, result_unwrapOr$137i3aj(copied$10r3llp(result_mapErr$16o3r40(asRef$0qzh9or(r), (e8: rs.u16): rs.u16 => { return e8; })), 34)); } /** Values JS shares where Rust clones or moves them. */ -export function owned(a: rt.u8 | undefined, b: rt.u8 | undefined, out: rt.ByteVec): void { - let matched!: rt.Result; - const s: string | undefined = option_map$0oc32h1(a, (x2: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(x2, f)); +export function owned(a: rs.u8 | undefined, b: rs.u8 | undefined, out: rs.ByteVec): void { + let matched!: rs.Result; + const s: string | undefined = option_map$1y26nmr(a, (x2: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(x2, f)); }); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(option_unwrapOrDefault$165pyh5(filter$1855tjj(option_clone$14nprly(s), (s2: string): boolean => { - return rt.stringLen(s2) > 1; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(filter$1855tjj(option_clone$14nprly(s), (s2: string): boolean => { + return rs.stringLen(s2) > 1; })))); - rt.byteVecPush(out, 124); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(option_unwrapOrElse$1badkpb(option_orElse$05gzawv(s, (): string | undefined => { - return option_map$0oc32h1(b, (y2: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(y2, f)); + rs.byteVecPush(out, 124); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrElse$1badkpb(option_orElse$05gzawv(s, (): string | undefined => { + return option_map$1y26nmr(b, (y2: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(y2, f)); }); }), (): string => { return "-"; }))); - rt.byteVecPush(out, 124); - const v: rt.Result = option_okOrElse$0awp3vn(option_map$0ejznqm(a, (x3: rt.u8): rt.ByteVec => { - return rt.byteVecOf(x3, 2); + rs.byteVecPush(out, 124); + const v: rs.Result = option_okOrElse$1usib9z(option_map$1px2rk4(a, (x3: rs.u8): rs.ByteVec => { + return rs.byteVecOf(x3, 2); }), (): string => { return "none"; }); - const copy: rt.Result = result_clone$04fntvl(v); + const copy: rs.Result = result_clone$1dcpug1(v); if (copy.ok) { - rt.byteVecPush(copy.value, 7); + rs.byteVecPush(copy.value, 7); } - const grown: rt.Result = result_map$1qqg34g(result_clone$04fntvl(v), (v3: rt.ByteVec): rt.ByteVec => { - rt.byteVecPush(v3, 9); + const grown: rs.Result = result_map$0jdlh8o(result_clone$1dcpug1(v), (v3: rs.ByteVec): rs.ByteVec => { + rs.byteVecPush(v3, 9); return v3; }); - const iter: rt.Iter> = rt.iterSlice([v, copy, grown]); + const iter: rs.Iter> = rs.iterSlice([v, copy, grown]); while (true) { - const _36: rt.Result | rt.Done = iter.next(); - if (_36 === rt.DONE) { + const _36: rs.Result | rs.Done = iter.next(); + if (_36 === rs.DONE) { break; } - const r: rt.Result = _36; + const r: rs.Result = _36; if (r.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(r.value)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(r.value)); } else { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(r.error)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(r.error)); } - rt.byteVecPush(out, 124); + rs.byteVecPush(out, 124); } - rt.byteVecPush(out, option_unwrapOrDefault$0wx44sw(option_map$0ejznqm(filter$0v80fk8(b, (y3: rt.u8): boolean => { - return rt.u8Rem(y3, 2) === 0; - }), (y4: rt.u8): rt.ByteVec => { - return rt.byteVecFrom(Uint8Array.of(y4)); + rs.byteVecPush(out, option_unwrapOrDefault$0w012ed(option_map$1px2rk4(filter$0hq86nl(b, (y3: rs.u8): boolean => { + return rs.u8Rem(y3, 2) === 0; + }), (y4: rs.u8): rs.ByteVec => { + return rs.byteVecFrom(Uint8Array.of(y4)); })).length & 0xff); - const pair: rt.Result = option_okOr$07zal2e(option_map$0jg2jop(a, (x4: rt.u8): rt.u32[] => { - return [x4 as rt.u32, 2]; + const pair: rs.Result = option_okOr$12zia2c(option_map$1ek423e(a, (x4: rs.u8): rs.u32[] => { + return [x4 as rs.u32, 2]; }), 3); - const wide: rt.Result = copy$Result_array2_u32_u16(result_mapErr$12w1s5x(pair, (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; + const wide: rs.Result = copy$Result_array2_u32_u16(result_mapErr$12sqndm(pair, (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; })); if (wide.ok) { wide.value[0] = 9; } if (pair.ok) { - matched = rt.Ok(copy$array_u32(pair.value)); + matched = rs.Ok(copy$array_u32(pair.value)); } else { - matched = rt.Err(pair.error as rt.u16); + matched = rs.Err(pair.error as rs.u16); } if (matched.ok) { matched.value[1] = 8; } - const iter2: rt.Iter> = rt.iterSlice([copy$Result_array2_u32_u16(result_mapErr$12w1s5x(pair, (a02: rt.u8): rt.u16 => { - return a02 as rt.u16; + const iter2: rs.Iter> = rs.iterSlice([copy$Result_array2_u32_u16(result_mapErr$12sqndm(pair, (a02: rs.u8): rs.u16 => { + return a02 as rs.u16; })), copy$Result_array2_u32_u16(wide), copy$Result_array2_u32_u16(matched)]); while (true) { - const _79: rt.Result | rt.Done = iter2.next(); - if (_79 === rt.DONE) { + const _79: rs.Result | rs.Done = iter2.next(); + if (_79 === rs.DONE) { break; } - const r2: rt.Result = _79; + const r2: rs.Result = _79; if (r2.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(r2.value[0] & 0xff, r2.value[1] & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(r2.value[0] & 0xff, r2.value[1] & 0xff))); } else { - rt.byteVecPush(out, r2.error & 0xff); + rs.byteVecPush(out, r2.error & 0xff); } } } /** A panic inside a closure std calls. */ -export function panics(a: rt.u8 | undefined, b: rt.u8 | undefined, limit: rt.u8, out: rt.ByteVec): void { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(option_andThen$17ch833(a, (x: rt.u8): rt.u8 | undefined => { +export function panics(a: rs.u8 | undefined, b: rs.u8 | undefined, limit: rs.u8, out: rs.ByteVec): void { + rs.byteVecPush(out, option_unwrapOr$1fr498u(option_andThen$195hx6l(a, (x: rs.u8): rs.u8 | undefined => { if (!(x === limit)) { return b; } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(x, f)]; - rt.panicFmt(["closure saw ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(x, f)]; + rs.panicFmt(["closure saw ", args2[0]]); }), 1)); - rt.byteVecPush(out, result_unwrapOrElse$009ibtw(option_okOr$1vxk0yk(b, limit), (e: rt.u8): rt.u8 => { - if (rt.u8Rem(e, 4) === 0) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(e, f)]; - rt.panicFmt(["error ", args4[0]]); + rs.byteVecPush(out, result_unwrapOrElse$1iet7cd(option_okOr$1j8owgb(b, limit), (e: rs.u8): rs.u8 => { + if (rs.u8Rem(e, 4) === 0) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(e, f)]; + rs.panicFmt(["error ", args4[0]]); } else { return e; } })); } -export function push(r: rt.Result, out: rt.ByteVec): void { +export function push(r: rs.Result, out: rs.ByteVec): void { if (r.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(1, r.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(1, r.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(r.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(r.error))); } } diff --git a/ts/fixtures/lang/combinators/expected/core/option.ts b/ts/fixtures/lang/combinators/expected/core/option.ts index 51a5cfe35..70968496d 100644 --- a/ts/fixtures/lang/combinators/expected/core/option.ts +++ b/ts/fixtures/lang/combinators/expected/core/option.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function isNoneOr$1s1o3ss(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isNoneOr$0xn3i4j(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return true; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -30,7 +30,7 @@ export function unwrapOrElse$1badkpb(self: string | undefined, f: () => string): return self; } -export function unwrapOrElse$13moxzl(self: rt.u8 | undefined, f: () => rt.u8): rt.u8 { +export function unwrapOrElse$0wd124z(self: rs.u8 | undefined, f: () => rs.u8): rs.u8 { if (self === undefined) { return f(); } @@ -44,126 +44,126 @@ export function unwrapOrDefault$165pyh5(self: string | undefined): string { return self; } -export function unwrapOrDefault$0wx44sw(self: rt.ByteVec | undefined): rt.ByteVec { +export function unwrapOrDefault$0w012ed(self: rs.ByteVec | undefined): rs.ByteVec { if (self === undefined) { - return new rt.ByteVec(); + return new rs.ByteVec(); } return self; } -export function unwrapOrDefault$1q0ps0j(self: rt.u8 | undefined): rt.u8 { +export function unwrapOrDefault$03apme8(self: rs.u8 | undefined): rs.u8 { if (self === undefined) { return 0; } return self; } -export function map$0oc32h1(self: rt.u8 | undefined, f: (a0: rt.u8) => string): string | undefined { +export function map$1y26nmr(self: rs.u8 | undefined, f: (a0: rs.u8) => string): string | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0ejznqm(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.ByteVec): rt.ByteVec | undefined { +export function map$1px2rk4(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.ByteVec): rs.ByteVec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0jg2jop(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u32[]): rt.u32[] | undefined { +export function map$1ek423e(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u32[]): rs.u32[] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function inspect$0di0vx1(self: rt.u8 | undefined, f: (a0: rt.u8) => undefined): rt.u8 | undefined { +export function inspect$1sa9a1m(self: rs.u8 | undefined, f: (a0: rs.u8) => undefined): rs.u8 | undefined { if (self !== undefined) { f(self); } return self; } -export function mapOr$0mmpeqx(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$099335t(self: rt.u16 | undefined, default_: rt.u8, f: (a0: rt.u16) => rt.u8): rt.u8 { +export function mapOr$031uhqp(self: rs.u16 | undefined, default_: rs.u8, f: (a0: rs.u16) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOrElse$1g6d36t(self: rt.u8 | undefined, default_: () => rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOrElse$0moj49b(self: rs.u8 | undefined, default_: () => rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_(); } return f(self); } -export function okOr$07zal2e(self: rt.u32[] | undefined, err: rt.u8): rt.Result { +export function okOr$12zia2c(self: rs.u32[] | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$0m6xlfp(self: rt.u8 | undefined, err: rt.u16): rt.Result { +export function okOr$19jxvkb(self: rs.u8 | undefined, err: rs.u16): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$1vxk0yk(self: rt.u8 | undefined, err: rt.u8): rt.Result { +export function okOr$1j8owgb(self: rs.u8 | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOrElse$0awp3vn(self: rt.ByteVec | undefined, err: () => string): rt.Result { +export function okOrElse$1usib9z(self: rs.ByteVec | undefined, err: () => string): rs.Result { if (self === undefined) { - return rt.Err(err()); + return rs.Err(err()); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOrElse$1v98j0a(self: rt.u8 | undefined, err: () => rt.u16): rt.Result { +export function okOrElse$0cs4x8k(self: rs.u8 | undefined, err: () => rs.u16): rs.Result { if (self === undefined) { - return rt.Err(err()); + return rs.Err(err()); } - return rt.Ok(self); + return rs.Ok(self); } -export function and$06om98g(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { +export function and$02hlbkj(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return undefined; } return optb; } -export function andThen$17ch833(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { +export function andThen$195hx6l(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return undefined; } @@ -180,9 +180,9 @@ export function filter$1855tjj(self: string | undefined, predicate: (a0: string) return undefined; } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } @@ -190,7 +190,7 @@ export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) = return undefined; } -export function or$1loyskh(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { +export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return optb; } @@ -204,15 +204,15 @@ export function orElse$05gzawv(self: string | undefined, f: () => string | undef return self; } -export function orElse$15bv4ho(self: rt.u8 | undefined, f: () => rt.u8 | undefined): rt.u8 | undefined { +export function orElse$1xazu5k(self: rs.u8 | undefined, f: () => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return f(); } return self; } -export function xor$0kctyix(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { - let _0!: rt.u8 | undefined; +export function xor$0x5qjg4(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { + let _0!: rs.u8 | undefined; b0: { if (self === undefined) { if (optb !== undefined) { @@ -228,12 +228,12 @@ export function xor$0kctyix(self: rt.u8 | undefined, optb: rt.u8 | undefined): r return _0; } -export function zip$1deudzj(self: rt.u8 | undefined, other: rt.u8 | undefined): [rt.u8, rt.u8] | undefined { - let _0!: [rt.u8, rt.u8] | undefined; +export function zip$0p00b0o(self: rs.u8 | undefined, other: rs.u8 | undefined): [rs.u8, rs.u8] | undefined { + let _0!: [rs.u8, rs.u8] | undefined; b0: { if (self !== undefined) { if (other !== undefined) { - _0 = [self, other] as [rt.u8, rt.u8]; + _0 = [self, other] as [rs.u8, rs.u8]; break b0; } } diff --git a/ts/fixtures/lang/combinators/expected/core/result.ts b/ts/fixtures/lang/combinators/expected/core/result.ts index 3374c9a05..e76381103 100644 --- a/ts/fixtures/lang/combinators/expected/core/result.ts +++ b/ts/fixtures/lang/combinators/expected/core/result.ts @@ -1,166 +1,166 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isOkAnd$0jj0nkw(self: rt.Result, f: (a0: rt.u8) => boolean): boolean { +export function isOkAnd$1poqzjs(self: rs.Result, f: (a0: rs.u8) => boolean): boolean { if (self.ok) { return f(self.value); } return false; } -export function isErrAnd$0b01a39(self: rt.Result, f: (a0: rt.u16) => boolean): boolean { +export function isErrAnd$0ecrrmy(self: rs.Result, f: (a0: rs.u16) => boolean): boolean { if (self.ok) { return false; } return f(self.error); } -export function ok$1c77lmd(self: rt.Result): rt.u8 | undefined { +export function ok$08qo4au(self: rs.Result): rs.u8 | undefined { if (self.ok) { return self.value; } return undefined; } -export function err$05f656d(self: rt.Result): rt.u16 | undefined { +export function err$0zs6b4d(self: rs.Result): rs.u16 | undefined { if (self.ok) { return undefined; } return self.error; } -export function asRef$1glrxiq(self: rt.Result): rt.Result { +export function asRef$0qzh9or(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function map$1qqg34g(self: rt.Result, op: (a0: rt.ByteVec) => rt.ByteVec): rt.Result { +export function map$0jdlh8o(self: rs.Result, op: (a0: rs.ByteVec) => rs.ByteVec): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } return self; } -export function map$132mdj8(self: rt.Result, op: (a0: rt.u8) => rt.u8): rt.Result { +export function map$044vsgj(self: rs.Result, op: (a0: rs.u8) => rs.u8): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } return self; } -export function mapOr$1mu5bvh(self: rt.Result, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$1yz3viz(self: rs.Result, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self.ok) { return f(self.value); } return default_; } -export function mapOrElse$0jxx67n(self: rt.Result, default_: (a0: rt.u16) => rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOrElse$0eu5k5b(self: rs.Result, default_: (a0: rs.u16) => rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self.ok) { return f(self.value); } return default_(self.error); } -export function mapErr$12w1s5x(self: rt.Result, _: (a0: rt.u8) => rt.u16): rt.Result { +export function mapErr$12sqndm(self: rs.Result, _: (a0: rs.u8) => rs.u16): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(self.error as rt.u16); + return rs.Err(self.error as rs.u16); } -export function mapErr$1lsqfgi(self: rt.Result, op: (a0: rt.u16) => rt.u16): rt.Result { +export function mapErr$16o3r40(self: rs.Result, op: (a0: rs.u16) => rs.u16): rs.Result { if (self.ok) { return self; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function inspect$16o3gle(self: rt.Result, f: (a0: rt.u8) => undefined): rt.Result { +export function inspect$1lvk7wu(self: rs.Result, f: (a0: rs.u8) => undefined): rs.Result { if (self.ok) { f(self.value); } return self; } -export function inspectErr$06tv5sa(self: rt.Result, f: (a0: rt.u16) => undefined): rt.Result { +export function inspectErr$0nqm52c(self: rs.Result, f: (a0: rs.u16) => undefined): rs.Result { if (!self.ok) { f(self.error); } return self; } -export function unwrapOrDefault$1exw7nd(self: rt.Result): rt.u8 { +export function unwrapOrDefault$0ysbycw(self: rs.Result): rs.u8 { if (self.ok) { return self.value; } return 0; } -export function and$0l7ltae(self: rt.Result, res: rt.Result): rt.Result { +export function and$1cozx1j(self: rs.Result, res: rs.Result): rs.Result { if (self.ok) { return res; } return self; } -export function andThen$0hd6ik8(self: rt.Result, op: (a0: rt.u8) => rt.Result): rt.Result { +export function andThen$19hld68(self: rs.Result, op: (a0: rs.u8) => rs.Result): rs.Result { if (self.ok) { return op(self.value); } return self; } -export function or$1xcfx3w(self: rt.Result, res: rt.Result): rt.Result { +export function or$1sapa01(self: rs.Result, res: rs.Result): rs.Result { if (self.ok) { return self; } return res; } -export function orElse$13ay4um(self: rt.Result, op: (a0: rt.u16) => rt.Result): rt.Result { +export function orElse$009jxpk(self: rs.Result, op: (a0: rs.u16) => rs.Result): rs.Result { if (self.ok) { return self; } return op(self.error); } -export function unwrapOr$0a4h2e7(self: rt.Result, default_: rt.u8): rt.u8 { +export function unwrapOr$137i3aj(self: rs.Result, default_: rs.u8): rs.u8 { if (self.ok) { return self.value; } return default_; } -export function unwrapOrElse$1reohq9(self: rt.Result, op: (a0: rt.u16) => rt.u8): rt.u8 { +export function unwrapOrElse$1d4fano(self: rs.Result, op: (a0: rs.u16) => rs.u8): rs.u8 { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$009ibtw(self: rt.Result, op: (a0: rt.u8) => rt.u8): rt.u8 { +export function unwrapOrElse$1iet7cd(self: rs.Result, op: (a0: rs.u8) => rs.u8): rs.u8 { if (self.ok) { return self.value; } return op(self.error); } -export function copied$0ma6p21(self: rt.Result): rt.Result { +export function copied$10r3llp(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } return self; } -export function clone$04fntvl(self: rt.Result): rt.Result { +export function clone$1dcpug1(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(rt.byteVecFrom(rt.byteVecView(self.value))); + return rs.Ok(rs.byteVecFrom(rs.byteVecView(self.value))); } - return rt.Err(self.error); + return rs.Err(self.error); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/combinators/expected/harness.ts b/ts/fixtures/lang/combinators/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/combinators/expected/harness.ts +++ b/ts/fixtures/lang/combinators/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/combinators/expected/lib.ts b/ts/fixtures/lang/combinators/expected/lib.ts index e4a68e18f..b7ce88a89 100644 --- a/ts/fixtures/lang/combinators/expected/lib.ts +++ b/ts/fixtures/lang/combinators/expected/lib.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { combinators } from "./combinators.ts"; -export function copy$Result_array2_u32_u16(v: rt.Result): rt.Result { - return v.ok ? rt.Ok(copy$array_u32(v.value)) : rt.Err(v.error); +export function copy$Result_array2_u32_u16(v: rs.Result): rs.Result { + return v.ok ? rs.Ok(copy$array_u32(v.value)) : rs.Err(v.error); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } @@ -15,8 +15,8 @@ export function copy$array_u32(v: rt.u32[]): rt.u32[] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["combinators::combinators", combinators as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["combinators::combinators", combinators as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/constants/expected/constants.ts b/ts/fixtures/lang/constants/expected/constants.ts index 0bd10ec33..5fd5d6e11 100644 --- a/ts/fixtures/lang/constants/expected/constants.ts +++ b/ts/fixtures/lang/constants/expected/constants.ts @@ -1,51 +1,51 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `T`'s constants compared with [`Mid`]'s. */ -export function against$u16(out: rt.ByteVec): void { - let _255!: rt.u8; - let _259!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a0: boolean): rt.u8 => { +export function against$u16(out: rs.ByteVec): void { + let _255!: rs.u8; + let _259!: rs.u8; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a03: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, rt.u64Lt(2, 2), rt.u64Le(2, 2), rt.u64Gt(2, 2), rt.u64Ge(2, 2)], (a05: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, rs.u64Lt(2, 2), rs.u64Le(2, 2), rs.u64Gt(2, 2), rs.u64Ge(2, 2)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, rt.i128Lt(0, 0), rt.i128Le(0, 0), rt.i128Gt(0, 0), rt.i128Ge(0, 0)], (a06: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, rs.i128Lt(0, 0), rs.i128Le(0, 0), rs.i128Gt(0, 0), rs.i128Ge(0, 0)], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a07: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a08: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a08: boolean): rs.u8 => { return a08 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a09: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a09: boolean): rs.u8 => { return a09 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a010: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a010: boolean): rs.u8 => { return a010 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-2, -2), rt.i128Ne(-2, -2), rt.i128Lt(-2, -2), rt.i128Le(-2, -2), rt.i128Gt(-2, -2), rt.i128Ge(-2, -2)], (a011: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.i128Eq(-2, -2), rs.i128Ne(-2, -2), rs.i128Lt(-2, -2), rs.i128Le(-2, -2), rs.i128Gt(-2, -2), rs.i128Ge(-2, -2)], (a011: boolean): rs.u8 => { return a011 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(2 as rt.char) === 2 as rt.char, (2 as rt.char) !== 2 as rt.char, (2 as rt.char) < (2 as rt.char), (2 as rt.char) <= (2 as rt.char), (2 as rt.char) > (2 as rt.char), (2 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([(2 as rs.char) === 2 as rs.char, (2 as rs.char) !== 2 as rs.char, (2 as rs.char) < (2 as rs.char), (2 as rs.char) <= (2 as rs.char), (2 as rs.char) > (2 as rs.char), (2 as rs.char) >= (2 as rs.char)], (a012: boolean): rs.u8 => { return a012 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a013: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a013: boolean): rs.u8 => { return a013 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a014: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a014: boolean): rs.u8 => { return a014 ? 1 : 0; })), undefined, true); if (false) { @@ -53,59 +53,59 @@ export function against$u16(out: rt.ByteVec): void { } else { _255 = 1; } - rt.byteVecPush(out, _255); + rs.byteVecPush(out, _255); if (true) { _259 = 4; } else { _259 = 3; } - rt.byteVecPush(out, _259); + rs.byteVecPush(out, _259); } /** `T`'s constants compared with [`Mid`]'s. */ -export function against$u64(out: rt.ByteVec): void { - let _255!: rt.u8; - let _259!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a0: boolean): rt.u8 => { +export function against$u64(out: rs.ByteVec): void { + let _255!: rs.u8; + let _259!: rs.u8; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a03: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.u64Lt(3, 2), rt.u64Le(3, 2), rt.u64Gt(3, 2), rt.u64Ge(3, 2)], (a05: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, rs.u64Lt(3, 2), rs.u64Le(3, 2), rs.u64Gt(3, 2), rs.u64Ge(3, 2)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.i128Lt(1, 0), rt.i128Le(1, 0), rt.i128Gt(1, 0), rt.i128Ge(1, 0)], (a06: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, rs.i128Lt(1, 0), rs.i128Le(1, 0), rs.i128Gt(1, 0), rs.i128Ge(1, 0)], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a07: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a08: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a08: boolean): rs.u8 => { return a08 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a09: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a09: boolean): rs.u8 => { return a09 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a010: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a010: boolean): rs.u8 => { return a010 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-1, -2), rt.i128Ne(-1, -2), rt.i128Lt(-1, -2), rt.i128Le(-1, -2), rt.i128Gt(-1, -2), rt.i128Ge(-1, -2)], (a011: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.i128Eq(-1, -2), rs.i128Ne(-1, -2), rs.i128Lt(-1, -2), rs.i128Le(-1, -2), rs.i128Gt(-1, -2), rs.i128Ge(-1, -2)], (a011: boolean): rs.u8 => { return a011 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(3 as rt.char) === 2 as rt.char, (3 as rt.char) !== 2 as rt.char, (3 as rt.char) < (2 as rt.char), (3 as rt.char) <= (2 as rt.char), (3 as rt.char) > (2 as rt.char), (3 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([(3 as rs.char) === 2 as rs.char, (3 as rs.char) !== 2 as rs.char, (3 as rs.char) < (2 as rs.char), (3 as rs.char) <= (2 as rs.char), (3 as rs.char) > (2 as rs.char), (3 as rs.char) >= (2 as rs.char)], (a012: boolean): rs.u8 => { return a012 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a013: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a013: boolean): rs.u8 => { return a013 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a014: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a014: boolean): rs.u8 => { return a014 ? 1 : 0; })), undefined, true); if (true) { @@ -113,59 +113,59 @@ export function against$u64(out: rt.ByteVec): void { } else { _255 = 1; } - rt.byteVecPush(out, _255); + rs.byteVecPush(out, _255); if (true) { _259 = 4; } else { _259 = 3; } - rt.byteVecPush(out, _259); + rs.byteVecPush(out, _259); } /** `T`'s constants compared with [`Mid`]'s. */ -export function against$u8(out: rt.ByteVec): void { - let _255!: rt.u8; - let _259!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a0: boolean): rt.u8 => { +export function against$u8(out: rs.ByteVec): void { + let _255!: rs.u8; + let _259!: rs.u8; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a03: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.u64Lt(1, 2), rt.u64Le(1, 2), rt.u64Gt(1, 2), rt.u64Ge(1, 2)], (a05: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, rs.u64Lt(1, 2), rs.u64Le(1, 2), rs.u64Gt(1, 2), rs.u64Ge(1, 2)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, rt.i128Lt(-1, 0), rt.i128Le(-1, 0), rt.i128Gt(-1, 0), rt.i128Ge(-1, 0)], (a06: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, rs.i128Lt(-1, 0), rs.i128Le(-1, 0), rs.i128Gt(-1, 0), rs.i128Ge(-1, 0)], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a07: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a08: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a08: boolean): rs.u8 => { return a08 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a09: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a09: boolean): rs.u8 => { return a09 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a010: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a010: boolean): rs.u8 => { return a010 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-3, -2), rt.i128Ne(-3, -2), rt.i128Lt(-3, -2), rt.i128Le(-3, -2), rt.i128Gt(-3, -2), rt.i128Ge(-3, -2)], (a011: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.i128Eq(-3, -2), rs.i128Ne(-3, -2), rs.i128Lt(-3, -2), rs.i128Le(-3, -2), rs.i128Gt(-3, -2), rs.i128Ge(-3, -2)], (a011: boolean): rs.u8 => { return a011 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(1 as rt.char) === 2 as rt.char, (1 as rt.char) !== 2 as rt.char, (1 as rt.char) < (2 as rt.char), (1 as rt.char) <= (2 as rt.char), (1 as rt.char) > (2 as rt.char), (1 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([(1 as rs.char) === 2 as rs.char, (1 as rs.char) !== 2 as rs.char, (1 as rs.char) < (2 as rs.char), (1 as rs.char) <= (2 as rs.char), (1 as rs.char) > (2 as rs.char), (1 as rs.char) >= (2 as rs.char)], (a012: boolean): rs.u8 => { return a012 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a013: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a013: boolean): rs.u8 => { return a013 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a014: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a014: boolean): rs.u8 => { return a014 ? 1 : 0; })), undefined, true); if (true) { @@ -173,59 +173,59 @@ export function against$u8(out: rt.ByteVec): void { } else { _255 = 1; } - rt.byteVecPush(out, _255); + rs.byteVecPush(out, _255); if (false) { _259 = 4; } else { _259 = 3; } - rt.byteVecPush(out, _259); + rs.byteVecPush(out, _259); } /** `T`'s constants compared with [`Mid`]'s. */ -export function against$unit(out: rt.ByteVec): void { - let _255!: rt.u8; - let _259!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a0: boolean): rt.u8 => { +export function against$unit(out: rs.ByteVec): void { + let _255!: rs.u8; + let _259!: rs.u8; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a03: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64) === 2, ({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64) !== 2, rt.u64Lt({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Le({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Gt({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2), rt.u64Ge({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 2)], (a05: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64) === 2, ({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64) !== 2, rs.u64Lt({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, 2), rs.u64Le({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, 2), rs.u64Gt({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, 2), rs.u64Ge({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, 2)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) === 0, ({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) !== 0, rt.i128Lt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Le({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Gt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0), rt.i128Ge({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, 0)], (a06: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) === 0, ({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) !== 0, rs.i128Lt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, 0), rs.i128Le({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, 0), rs.i128Gt({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, 0), rs.i128Ge({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, 0)], (a06: boolean): rs.u8 => { return a06 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, true, true, false, false], (a07: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, true, true, false, false], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a08: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a08: boolean): rs.u8 => { return a08 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a09: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a09: boolean): rs.u8 => { return a09 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, false, false], (a010: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, false, false], (a010: boolean): rs.u8 => { return a010 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.i128Eq(-2147483648, -2), rt.i128Ne(-2147483648, -2), rt.i128Lt(-2147483648, -2), rt.i128Le(-2147483648, -2), rt.i128Gt(-2147483648, -2), rt.i128Ge(-2147483648, -2)], (a011: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.i128Eq(-2147483648, -2), rs.i128Ne(-2147483648, -2), rs.i128Lt(-2147483648, -2), rs.i128Le(-2147483648, -2), rs.i128Gt(-2147483648, -2), rs.i128Ge(-2147483648, -2)], (a011: boolean): rs.u8 => { return a011 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([(255 as rt.char) === 2 as rt.char, (255 as rt.char) !== 2 as rt.char, (255 as rt.char) < (2 as rt.char), (255 as rt.char) <= (2 as rt.char), (255 as rt.char) > (2 as rt.char), (255 as rt.char) >= (2 as rt.char)], (a012: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([(255 as rs.char) === 2 as rs.char, (255 as rs.char) !== 2 as rs.char, (255 as rs.char) < (2 as rs.char), (255 as rs.char) <= (2 as rs.char), (255 as rs.char) > (2 as rs.char), (255 as rs.char) >= (2 as rs.char)], (a012: boolean): rs.u8 => { return a012 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, true, false, false, true, true], (a013: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, true, false, false, true, true], (a013: boolean): rs.u8 => { return a013 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([true, false, false, true, false, true], (a014: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([true, false, false, true, false, true], (a014: boolean): rs.u8 => { return a014 ? 1 : 0; })), undefined, true); if (true) { @@ -233,17 +233,17 @@ export function against$unit(out: rt.ByteVec): void { } else { _255 = 1; } - rt.byteVecPush(out, _255); + rs.byteVecPush(out, _255); if (true) { _259 = 4; } else { _259 = 3; } - rt.byteVecPush(out, _259); + rs.byteVecPush(out, _259); } /** The constants of each type compared with [`Mid`]'s. */ -export function compares(out: rt.ByteVec): void { +export function compares(out: rs.ByteVec): void { against$u8(out); against$u16(out); against$u64(out); diff --git a/ts/fixtures/lang/constants/expected/harness.ts b/ts/fixtures/lang/constants/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/constants/expected/harness.ts +++ b/ts/fixtures/lang/constants/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/constants/expected/lib.ts b/ts/fixtures/lang/constants/expected/lib.ts index c883dd531..35e4d82a1 100644 --- a/ts/fixtures/lang/constants/expected/lib.ts +++ b/ts/fixtures/lang/constants/expected/lib.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { compares } from "./constants.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["constants::compares", (_22: rt.u8, _32: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["constants::compares", (_22: rs.u8, _32: rs.ByteSlice, out: rs.ByteVec): undefined => { compares(out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/conversions/expected/conversions.Held.ts b/ts/fixtures/lang/conversions/expected/conversions.Held.ts index 71be3c013..f735618b9 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Held.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Held.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Holds a value in a field. */ export class Held { @@ -11,7 +11,7 @@ export class Held { } [Symbol.dispose](): void { - rt.drop(this.value); + rs.drop(this.value); } } diff --git a/ts/fixtures/lang/conversions/expected/conversions.Kept.ts b/ts/fixtures/lang/conversions/expected/conversions.Kept.ts index 8a880a554..7db4c6134 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Kept.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Kept.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Cloned into by its own `clone_from`, which keeps the id it held. */ export interface Kept { - id: rt.u8; - from: rt.u8; + id: rs.u8; + from: rs.u8; } export function cloneFrom$Clone(self: Kept, source: Kept): void { diff --git a/ts/fixtures/lang/conversions/expected/conversions.Logged.ts b/ts/fixtures/lang/conversions/expected/conversions.Logged.ts index a140f01bf..5bc8bbce0 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Logged.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Logged.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { byte, LOG } from "./conversions.ts"; /** @@ -8,10 +8,10 @@ import { byte, LOG } from "./conversions.ts"; * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -23,40 +23,40 @@ export class Logged { } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } -export function cmp$cmp_Ord(self: Logged, other: Logged): rt.Ordering { - return rt.cmp(self.id, other.id); +export function cmp$cmp_Ord(self: Logged, other: Logged): rs.Ordering { + return rs.cmp(self.id, other.id); } -export function partialCmp$cmp_PartialOrd(self: Logged, other: Logged): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Logged, other: Logged): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } /** The value `data` makes from `at`. */ -export function make$conversions_Value(data: rt.ByteSlice, at: rt.usize): Logged { - return new Logged(byte(data, at) & 127, ((a0: rt.Arc>): rt.Arc> => { - return rt.arcClone(a0); +export function make$conversions_Value(data: rs.ByteSlice, at: rs.usize): Logged { + return new Logged(byte(data, at) & 127, ((a0: rs.Arc>): rs.Arc> => { + return rs.arcClone(a0); })(LOG.get())); } /** Its bytes. */ -export function put$conversions_Value(self: Logged, out: rt.ByteVec): void { - rt.byteVecPush(out, self.id); - rt.byteVecPush(out, 253); - const _10: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.iterExtendBytes(out, rt.byteVecDrain(_10.value, undefined), "fold", true); - rt.refMutRelease(_10); +export function put$conversions_Value(self: Logged, out: rs.ByteVec): void { + rs.byteVecPush(out, self.id); + rs.byteVecPush(out, 253); + const _10: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.iterExtendBytes(out, rs.byteVecDrain(_10.value, undefined), "fold", true); + rs.refMutRelease(_10); } //# sourceMappingURL=conversions.Logged.ts.map diff --git a/ts/fixtures/lang/conversions/expected/conversions.Named.ts b/ts/fixtures/lang/conversions/expected/conversions.Named.ts index fc02f4d9e..a4dbbebc1 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.Named.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.Named.ts @@ -1,38 +1,38 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { byte, make$conversions_Value_String, put$conversions_Value_String as conversions_put$conversions_Value_String } from "./conversions.ts"; export function clone$Clone(self: Named): Named { return { id: self.id, name: self.name }; } -export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Named, other: Named): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.id, other.id); +export function cmp$cmp_Ord(self: Named, other: Named): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.id, other.id); if (cmp === 0) { - return rt.cmpStr(self.name, other.name); + return rs.cmpStr(self.name, other.name); } return cmp; } /** A struct, which JS holds as an object. */ export interface Named { - id: rt.u16; + id: rs.u16; name: string; } /** The value `data` makes from `at`. */ -export function make$conversions_Value(data: rt.ByteSlice, at: rt.usize): Named { - return { id: rt.u8Rem(byte(data, at), 4) as rt.u16, name: make$conversions_Value_String(data, rt.usizeAdd(at, 1)) }; +export function make$conversions_Value(data: rs.ByteSlice, at: rs.usize): Named { + return { id: rs.u8Rem(byte(data, at), 4) as rs.u16, name: make$conversions_Value_String(data, rs.usizeAdd(at, 1)) }; } /** Its bytes. */ -export function put$conversions_Value(self: Named, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(self.id)), undefined, true); +export function put$conversions_Value(self: Named, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(self.id)), undefined, true); conversions_put$conversions_Value_String(self.name, out); } diff --git a/ts/fixtures/lang/conversions/expected/conversions.ts b/ts/fixtures/lang/conversions/expected/conversions.ts index c6dd2c1f3..91a63c3c1 100644 --- a/ts/fixtures/lang/conversions/expected/conversions.ts +++ b/ts/fixtures/lang/conversions/expected/conversions.ts @@ -1,186 +1,186 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_Option_u16, copy$array_array0_u8, copy$array_array1_u8, copy$array_array2_u32, copy$array_array3_u8, copy$array_array40_u8, copy$array_u32, copy$array_u64, copy$array_u8, drop$tuple2_conversions_Logged_u8 } from "./lib.ts"; import * as Held from "./conversions.Held.ts"; import * as Kept from "./conversions.Kept.ts"; import * as Logged from "./conversions.Logged.ts"; import * as Named from "./conversions.Named.ts"; -import { thenSome$0b23a33 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, clone$08xidb9 as option_clone$08xidb9, clone$14nprly as option_clone$14nprly, clone$13oewp0 as option_clone$13oewp0, clone$0xuzdx9 as option_clone$0xuzdx9, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1md9w7g as option_clone$1md9w7g, clone$1qp57nz as option_clone$1qp57nz, clone$08560de as option_clone$08560de } from "./core/option.ts"; +import { thenSome$1gvhopg } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, clone$0wpatp7 as option_clone$0wpatp7, clone$14nprly as option_clone$14nprly, clone$13oewp0 as option_clone$13oewp0, clone$0xr8mw0 as option_clone$0xr8mw0, clone$17fv6u9 as option_clone$17fv6u9, clone$0fp7wpk as option_clone$0fp7wpk, clone$1lfse5o as option_clone$1lfse5o, clone$08wmfj8 as option_clone$08wmfj8, clone$1aebjgp as option_clone$1aebjgp } from "./core/option.ts"; /** The byte at `at`, past `data`'s end its index. */ -export function byte(data: rt.ByteSlice, at: rt.usize): rt.u8 { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at), at & 0xff); +export function byte(data: rs.ByteSlice, at: rs.usize): rs.u8 { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, at), at & 0xff); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_u8(data: rt.ByteSlice, at: rt.usize): rt.u8 { +export function make$conversions_Value_u8(data: rs.ByteSlice, at: rs.usize): rs.u8 { return byte(data, at); } /** Its bytes. */ -export function put$conversions_Value_u8(self: rt.u8, out: rt.ByteVec): void { - rt.byteVecPush(out, self); +export function put$conversions_Value_u8(self: rs.u8, out: rs.ByteVec): void { + rs.byteVecPush(out, self); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_u32(data: rt.ByteSlice, at: rt.usize): rt.u32 { - return rt.u32Mul(byte(data, at) as rt.u32, 16843009); +export function make$conversions_Value_u32(data: rs.ByteSlice, at: rs.usize): rs.u32 { + return rs.u32Mul(byte(data, at) as rs.u32, 16843009); } /** Its bytes. */ -export function put$conversions_Value_u32(self: rt.u32, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(self)), undefined, true); +export function put$conversions_Value_u32(self: rs.u32, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(self)), undefined, true); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_u64(data: rt.ByteSlice, at: rt.usize): rt.u64 { - return rt.u64Or(rt.u64Shl(byte(data, at) as rt.u64, 56), byte(data, rt.usizeAdd(at, 1)) as rt.u64); +export function make$conversions_Value_u64(data: rs.ByteSlice, at: rs.usize): rs.u64 { + return rs.u64Or(rs.u64Shl(byte(data, at) as rs.u64, 56), byte(data, rs.usizeAdd(at, 1)) as rs.u64); } /** Its bytes. */ -export function put$conversions_Value_u64(self: rt.u64, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(self)), undefined, true); +export function put$conversions_Value_u64(self: rs.u64, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(self)), undefined, true); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_String(data: rt.ByteSlice, at: rt.usize): string { - const part = rt.u8Rem(byte(data, at), 16); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; - return rt.fmtFormat(["s", args2[0]]); +export function make$conversions_Value_String(data: rs.ByteSlice, at: rs.usize): string { + const part = rs.u8Rem(byte(data, at), 16); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; + return rs.fmtFormat(["s", args2[0]]); } /** Its bytes. */ -export function put$conversions_Value_String(self: string, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(self))), undefined, true); - rt.byteVecPush(out, 255); +export function put$conversions_Value_String(self: string, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(self))), undefined, true); + rs.byteVecPush(out, 255); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_Option_u16(data: rt.ByteSlice, at: rt.usize): rt.u16 | undefined { - const b: rt.u8 = byte(data, at); - return thenSome$0b23a33(rt.u8Rem(b, 4) !== 0, ((b as rt.u16) << 4) & 0xffff); +export function make$conversions_Value_Option_u16(data: rs.ByteSlice, at: rs.usize): rs.u16 | undefined { + const b: rs.u8 = byte(data, at); + return thenSome$1gvhopg(rs.u8Rem(b, 4) !== 0, ((b as rs.u16) << 4) & 0xffff); } /** Its bytes. */ -export function put$conversions_Value_Option_u16(self: rt.u16 | undefined, out: rt.ByteVec): void { +export function put$conversions_Value_Option_u16(self: rs.u16 | undefined, out: rs.ByteVec): void { if (self === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(self)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(self)), undefined, true); } } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array0_u8(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return rt.u8Rem(byte(data, rt.usizeAdd(at, i)), 4); +export function make$conversions_Value_array0_u8(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(0, (i: rs.usize): rs.u8 => { + return rs.u8Rem(byte(data, rs.usizeAdd(at, i)), 4); }); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array1_u8(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return rt.u8Rem(byte(data, rt.usizeAdd(at, i)), 4); +export function make$conversions_Value_array1_u8(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(1, (i: rs.usize): rs.u8 => { + return rs.u8Rem(byte(data, rs.usizeAdd(at, i)), 4); }); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array2_u8(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(2, (i: rt.usize): rt.u8 => { - return rt.u8Rem(byte(data, rt.usizeAdd(at, i)), 4); +export function make$conversions_Value_array2_u8(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(2, (i: rs.usize): rs.u8 => { + return rs.u8Rem(byte(data, rs.usizeAdd(at, i)), 4); }); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array3_u8(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return rt.u8Rem(byte(data, rt.usizeAdd(at, i)), 4); +export function make$conversions_Value_array3_u8(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(3, (i: rs.usize): rs.u8 => { + return rs.u8Rem(byte(data, rs.usizeAdd(at, i)), 4); }); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array40_u8(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(40, (i: rt.usize): rt.u8 => { - return rt.u8Rem(byte(data, rt.usizeAdd(at, i)), 4); +export function make$conversions_Value_array40_u8(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(40, (i: rs.usize): rs.u8 => { + return rs.u8Rem(byte(data, rs.usizeAdd(at, i)), 4); }); } /** Its bytes. */ -export function put$conversions_Value_array0_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$conversions_Value_array0_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } /** Its bytes. */ -export function put$conversions_Value_array1_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$conversions_Value_array1_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } /** Its bytes. */ -export function put$conversions_Value_array3_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$conversions_Value_array3_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } /** Its bytes. */ -export function put$conversions_Value_array40_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$conversions_Value_array40_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } /** The value `data` makes from `at`. */ -export function make$conversions_Value_array2_u32(data: rt.ByteSlice, at: rt.usize): rt.u32[] { - return [rt.u8Rem(byte(data, at), 4) as rt.u32, ((byte(data, rt.usizeAdd(at, 1)) as rt.u32) << 20) >>> 0]; +export function make$conversions_Value_array2_u32(data: rs.ByteSlice, at: rs.usize): rs.u32[] { + return [rs.u8Rem(byte(data, at), 4) as rs.u32, ((byte(data, rs.usizeAdd(at, 1)) as rs.u32) << 20) >>> 0]; } /** Its bytes. */ -export function put$conversions_Value_array2_u32(self: rt.u32[], out: rt.ByteVec): void { +export function put$conversions_Value_array2_u32(self: rs.u32[], out: rs.ByteVec): void { for (const _5 of self) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(_5)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(_5)), undefined, true); } } /** The value `data` makes from `at`. */ -export function make$conversions_Value_Vec_u32(data: rt.ByteSlice, at: rt.usize): rt.Vec { - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(byte(data, at), 4) as rt.usize), (i: rt.usize): rt.u32 => { - return byte(data, rt.usizeAdd(rt.usizeAdd(at, i), 1)) as rt.u32; +export function make$conversions_Value_Vec_u32(data: rs.ByteSlice, at: rs.usize): rs.Vec { + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(byte(data, at), 4) as rs.usize), (i: rs.usize): rs.u32 => { + return byte(data, rs.usizeAdd(rs.usizeAdd(at, i), 1)) as rs.u32; }), undefined, 4, true); } /** Its bytes. */ -export function put$conversions_Value_Vec_u32(self: rt.Vec, out: rt.ByteVec): void { - rt.byteVecPush(out, self.items.length & 0xff); +export function put$conversions_Value_Vec_u32(self: rs.Vec, out: rs.ByteVec): void { + rs.byteVecPush(out, self.items.length & 0xff); for (const _8 of self.items) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(_8)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(_8)), undefined, true); } } /** The value `data` makes from `at`. */ -export function make$conversions_Value_Vec_u8(data: rt.ByteSlice, at: rt.usize): rt.ByteVec { - return rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.u8Rem(byte(data, at), 4) as rt.usize), (i: rt.usize): rt.u8 => { - return byte(data, rt.usizeAdd(rt.usizeAdd(at, i), 1)); +export function make$conversions_Value_Vec_u8(data: rs.ByteSlice, at: rs.usize): rs.ByteVec { + return rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.u8Rem(byte(data, at), 4) as rs.usize), (i: rs.usize): rs.u8 => { + return byte(data, rs.usizeAdd(rs.usizeAdd(at, i), 1)); }), undefined, true); } /** Its bytes. */ -export function put$conversions_Value_Vec_u8(self: rt.ByteVec, out: rt.ByteVec): void { - rt.byteVecPush(out, self.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(self)); +export function put$conversions_Value_Vec_u8(self: rs.ByteVec, out: rs.ByteVec): void { + rs.byteVecPush(out, self.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(self)); } -export const LOG: rt.LocalKey>> = /* @__PURE__ */ new rt.LocalKey((): rt.Arc> => { +export const LOG: rs.LocalKey>> = /* @__PURE__ */ new rs.LocalKey((): rs.Arc> => { return LOG$init(undefined); -}, true, rt.drop); +}, true, rs.drop); -export function LOG$init(_1: undefined): rt.Arc> { - return new rt.Arc(new rt.RefCell(new rt.ByteVec())); +export function LOG$init(_1: undefined): rs.Arc> { + return new rs.Arc(new rs.RefCell(new rs.ByteVec())); } /** * Runs each conversion of the type `kind` picks, but a slice of one `u8`, whose `&mut` * no slice can view, and [`searched`] of those that order. */ -export function conversions(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 14); +export function conversions(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 14); if (_5 === 0) { ordered$u32(data, out); } else if (_5 === 1) { @@ -209,10 +209,10 @@ export function conversions(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v converted$u8(data, out); searched$u8(data, out); } else { - ((log: rt.Arc>): undefined => { - const _52: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_52.value); - rt.refMutRelease(_52); + ((log: rs.Arc>): undefined => { + const _52: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_52.value); + rs.refMutRelease(_52); })(LOG.get()); converted$conversions_Logged(data, out); lentOne$conversions_Logged(data, out); @@ -225,7 +225,7 @@ export function conversions(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): v } /** Each conversion of a `T` that orders. */ -export function ordered$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { converted$Option_u16(data, out); lentOne$Option_u16(data, out); lentThrough$Option_u16(data, out); @@ -233,7 +233,7 @@ export function ordered$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$String(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$String(data: rs.ByteSlice, out: rs.ByteVec): void { converted$String(data, out); lentOne$String(data, out); lentThrough$String(data, out); @@ -241,7 +241,7 @@ export function ordered$String(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { converted$Vec_u32(data, out); lentOne$Vec_u32(data, out); lentThrough$Vec_u32(data, out); @@ -249,7 +249,7 @@ export function ordered$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { converted$Vec_u8(data, out); lentOne$Vec_u8(data, out); lentThrough$Vec_u8(data, out); @@ -257,7 +257,7 @@ export function ordered$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { converted$array0_u8(data, out); lentOne$array0_u8(data, out); lentThrough$array0_u8(data, out); @@ -265,7 +265,7 @@ export function ordered$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { converted$array1_u8(data, out); lentOne$array1_u8(data, out); lentThrough$array1_u8(data, out); @@ -273,7 +273,7 @@ export function ordered$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { converted$array2_u32(data, out); lentOne$array2_u32(data, out); lentThrough$array2_u32(data, out); @@ -281,7 +281,7 @@ export function ordered$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { converted$array3_u8(data, out); lentOne$array3_u8(data, out); lentThrough$array3_u8(data, out); @@ -289,7 +289,7 @@ export function ordered$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { converted$array40_u8(data, out); lentOne$array40_u8(data, out); lentThrough$array40_u8(data, out); @@ -297,7 +297,7 @@ export function ordered$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { converted$conversions_Named(data, out); lentOne$conversions_Named(data, out); lentThrough$conversions_Named(data, out); @@ -305,7 +305,7 @@ export function ordered$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): } /** Each conversion of a `T` that orders. */ -export function ordered$u32(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$u32(data: rs.ByteSlice, out: rs.ByteVec): void { converted$u32(data, out); lentOne$u32(data, out); lentThrough$u32(data, out); @@ -313,7 +313,7 @@ export function ordered$u32(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T` that orders. */ -export function ordered$u64(data: rt.ByteSlice, out: rt.ByteVec): void { +export function ordered$u64(data: rs.ByteSlice, out: rs.ByteVec): void { converted$u64(data, out); lentOne$u64(data, out); lentThrough$u64(data, out); @@ -321,187 +321,187 @@ export function ordered$u64(data: rt.ByteSlice, out: rt.ByteVec): void { } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$Option_u16(to: rt.Place, from: rt.u16 | undefined): void { +export function cloneFromParam$Option_u16(to: rs.Place, from: rs.u16 | undefined): void { to.v = from; } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$String(to: rt.Place, from: string): void { +export function cloneFromParam$String(to: rs.Place, from: string): void { to.v = from; } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$Vec_u32(to: rt.Vec, from: rt.Vec): void { - rt.vecCloneFrom(to, from, 4); +export function cloneFromParam$Vec_u32(to: rs.Vec, from: rs.Vec): void { + rs.vecCloneFrom(to, from, 4); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$Vec_u8(to: rt.ByteVec, from: rt.ByteVec): void { - rt.byteVecCloneFrom(to, from); +export function cloneFromParam$Vec_u8(to: rs.ByteVec, from: rs.ByteVec): void { + rs.byteVecCloneFrom(to, from); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array0_u8(to: rt.ByteSlice, from: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneFromParam$array0_u8(to: rs.ByteSlice, from: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array1_u8(to: rt.ByteSlice, from: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneFromParam$array1_u8(to: rs.ByteSlice, from: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array2_u32(to: rt.u32[], from: rt.u32[]): void { - rt.replaceIn(to, copy$array_u32(from)); +export function cloneFromParam$array2_u32(to: rs.u32[], from: rs.u32[]): void { + rs.replaceIn(to, copy$array_u32(from)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array3_u8(to: rt.ByteSlice, from: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneFromParam$array3_u8(to: rs.ByteSlice, from: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$array40_u8(to: rt.ByteSlice, from: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneFromParam$array40_u8(to: rs.ByteSlice, from: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$conversions_Logged(to: Logged.Logged, from: Logged.Logged): void { - rt.replaceIn(to, Logged.clone$Clone(from))[Symbol.dispose](); + rs.replaceIn(to, Logged.clone$Clone(from))[Symbol.dispose](); } /** `clone_from` through a `&mut` whose place only the caller knows. */ export function cloneFromParam$conversions_Named(to: Named.Named, from: Named.Named): void { - rt.replaceIn(to, Named.clone$Clone(from)); + rs.replaceIn(to, Named.clone$Clone(from)); } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$u32(to: rt.Place, from: rt.u32): void { +export function cloneFromParam$u32(to: rs.Place, from: rs.u32): void { to.v = from; } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$u64(to: rt.Place, from: rt.u64): void { +export function cloneFromParam$u64(to: rs.Place, from: rs.u64): void { to.v = from; } /** `clone_from` through a `&mut` whose place only the caller knows. */ -export function cloneFromParam$u8(to: rt.Place, from: rt.u8): void { +export function cloneFromParam$u8(to: rs.Place, from: rs.u8): void { to.v = from; } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$Option_u16(from: rt.u16 | undefined, to: rt.Place): void { +export function cloneIntoParam$Option_u16(from: rs.u16 | undefined, to: rs.Place): void { to.v = from; } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$String(from: string, to: rt.Place): void { +export function cloneIntoParam$String(from: string, to: rs.Place): void { to.v = from; } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$Vec_u32(from: rt.Vec, to: rt.Vec): void { - rt.vecCloneFrom(to, from, 4); +export function cloneIntoParam$Vec_u32(from: rs.Vec, to: rs.Vec): void { + rs.vecCloneFrom(to, from, 4); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$Vec_u8(from: rt.ByteVec, to: rt.ByteVec): void { - rt.byteVecCloneFrom(to, from); +export function cloneIntoParam$Vec_u8(from: rs.ByteVec, to: rs.ByteVec): void { + rs.byteVecCloneFrom(to, from); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array0_u8(from: rt.ByteSlice, to: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneIntoParam$array0_u8(from: rs.ByteSlice, to: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array1_u8(from: rt.ByteSlice, to: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneIntoParam$array1_u8(from: rs.ByteSlice, to: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array2_u32(from: rt.u32[], to: rt.u32[]): void { - rt.replaceIn(to, copy$array_u32(from)); +export function cloneIntoParam$array2_u32(from: rs.u32[], to: rs.u32[]): void { + rs.replaceIn(to, copy$array_u32(from)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array3_u8(from: rt.ByteSlice, to: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneIntoParam$array3_u8(from: rs.ByteSlice, to: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$array40_u8(from: rt.ByteSlice, to: rt.ByteSlice): void { - to.data.set(rt.byteSliceToArray(from), to.start); +export function cloneIntoParam$array40_u8(from: rs.ByteSlice, to: rs.ByteSlice): void { + to.data.set(rs.byteSliceToArray(from), to.start); } /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$conversions_Logged(from: Logged.Logged, to: Logged.Logged): void { - rt.replaceIn(to, Logged.clone$Clone(from))[Symbol.dispose](); + rs.replaceIn(to, Logged.clone$Clone(from))[Symbol.dispose](); } /** `clone_into` through a `&mut` whose place only the caller knows. */ export function cloneIntoParam$conversions_Named(from: Named.Named, to: Named.Named): void { - rt.replaceIn(to, Named.clone$Clone(from)); + rs.replaceIn(to, Named.clone$Clone(from)); } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$u32(from: rt.u32, to: rt.Place): void { +export function cloneIntoParam$u32(from: rs.u32, to: rs.Place): void { to.v = from; } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$u64(from: rt.u64, to: rt.Place): void { +export function cloneIntoParam$u64(from: rs.u64, to: rs.Place): void { to.v = from; } /** `clone_into` through a `&mut` whose place only the caller knows. */ -export function cloneIntoParam$u8(from: rt.u8, to: rt.Place): void { +export function cloneIntoParam$u8(from: rs.u8, to: rs.Place): void { to.v = from; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$Option_u16(s: Array, value: rt.u16 | undefined): rt.u16 | undefined { - rt.idx(s, 0); - const _8: rt.u16 | undefined = value; +export function writeFirst$Option_u16(s: Array, value: rs.u16 | undefined): rs.u16 | undefined { + rs.idx(s, 0); + const _8: rs.u16 | undefined = value; const old2 = s[0]; s[0] = _8; - const old: rt.u16 | undefined = old2; - const _10: rt.u16 | undefined = value; - rt.idx(s, 0); + const old: rs.u16 | undefined = old2; + const _10: rs.u16 | undefined = value; + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$String(s: string[], value: string): string { - rt.idx(s, 0); + rs.idx(s, 0); const _8: string = value; const old2 = s[0]; s[0] = _8; const old: string = old2; const _10: string = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$Vec_u32(s: rt.Vec[], value: rt.Vec): rt.Vec { - rt.idx(s, 0); - const old: rt.Vec = rt.sliceReplace(s, 0, rt.vecFrom(value.items.slice())); - const _10: rt.Vec = value; - rt.idx(s, 0); +export function writeFirst$Vec_u32(s: rs.Vec[], value: rs.Vec): rs.Vec { + rs.idx(s, 0); + const old: rs.Vec = rs.sliceReplace(s, 0, rs.vecFrom(value.items.slice())); + const _10: rs.Vec = value; + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$Vec_u8(s: rt.ByteVec[], value: rt.ByteVec): rt.ByteVec { - rt.idx(s, 0); - const old: rt.ByteVec = rt.sliceReplace(s, 0, rt.byteVecFrom(rt.byteVecView(value))); - const _10: rt.ByteVec = value; - rt.idx(s, 0); +export function writeFirst$Vec_u8(s: rs.ByteVec[], value: rs.ByteVec): rs.ByteVec { + rs.idx(s, 0); + const old: rs.ByteVec = rs.sliceReplace(s, 0, rs.byteVecFrom(rs.byteVecView(value))); + const _10: rs.ByteVec = value; + rs.idx(s, 0); s[0] = _10; return old; } @@ -509,11 +509,11 @@ export function writeFirst$Vec_u8(s: rt.ByteVec[], value: rt.ByteVec): rt.ByteVe /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$array0_u8(s: Uint8Array[], value: Uint8Array): Uint8Array { value = copy$array_u8(value); - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - const old: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(value))); + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + const old: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); const _10: Uint8Array = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } @@ -521,25 +521,25 @@ export function writeFirst$array0_u8(s: Uint8Array[], value: Uint8Array): Uint8A /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$array1_u8(s: Uint8Array[], value: Uint8Array): Uint8Array { value = copy$array_u8(value); - rt.idx(s, 0); - const _3: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _8: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(value))); - const old2 = rt.byteSliceToArray(_3); + rs.idx(s, 0); + const _3: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); + const old2 = rs.byteSliceToArray(_3); _3.data.set(_8, _3.start); const old: Uint8Array = old2; const _10: Uint8Array = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$array2_u32(s: rt.u32[][], value: rt.u32[]): rt.u32[] { +export function writeFirst$array2_u32(s: rs.u32[][], value: rs.u32[]): rs.u32[] { value = copy$array_u32(value); - rt.idx(s, 0); - const old: rt.u32[] = rt.sliceReplace(s, 0, copy$array_u32(copy$array_u32(value))); - const _10: rt.u32[] = value; - rt.idx(s, 0); + rs.idx(s, 0); + const old: rs.u32[] = rs.sliceReplace(s, 0, copy$array_u32(copy$array_u32(value))); + const _10: rs.u32[] = value; + rs.idx(s, 0); s[0] = _10; return old; } @@ -547,14 +547,14 @@ export function writeFirst$array2_u32(s: rt.u32[][], value: rt.u32[]): rt.u32[] /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$array3_u8(s: Uint8Array[], value: Uint8Array): Uint8Array { value = copy$array_u8(value); - rt.idx(s, 0); - const _3: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _8: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(value))); - const old2 = rt.byteSliceToArray(_3); + rs.idx(s, 0); + const _3: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); + const old2 = rs.byteSliceToArray(_3); _3.data.set(_8, _3.start); const old: Uint8Array = old2; const _10: Uint8Array = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } @@ -562,24 +562,24 @@ export function writeFirst$array3_u8(s: Uint8Array[], value: Uint8Array): Uint8A /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$array40_u8(s: Uint8Array[], value: Uint8Array): Uint8Array { value = copy$array_u8(value); - rt.idx(s, 0); - const _3: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _8: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(value))); - const old2 = rt.byteSliceToArray(_3); + rs.idx(s, 0); + const _3: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _8: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(value))); + const old2 = rs.byteSliceToArray(_3); _3.data.set(_8, _3.start); const old: Uint8Array = old2; const _10: Uint8Array = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$conversions_Logged(s: Logged.Logged[], value: Logged.Logged): Logged.Logged { - rt.idx(s, 0); - const old: Logged.Logged = rt.sliceReplace(s, 0, Logged.clone$Clone(value)); + rs.idx(s, 0); + const old: Logged.Logged = rs.sliceReplace(s, 0, Logged.clone$Clone(value)); const _10: Logged.Logged = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0][Symbol.dispose](); s[0] = _10; return old; @@ -587,116 +587,116 @@ export function writeFirst$conversions_Logged(s: Logged.Logged[], value: Logged. /** A whole write into what a slice holds, as a function given any slice makes it. */ export function writeFirst$conversions_Named(s: Named.Named[], value: Named.Named): Named.Named { - rt.idx(s, 0); - const old: Named.Named = rt.sliceReplace(s, 0, Named.clone$Clone(value)); + rs.idx(s, 0); + const old: Named.Named = rs.sliceReplace(s, 0, Named.clone$Clone(value)); const _10: Named.Named = value; - rt.idx(s, 0); + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$u32(s: rt.u32[], value: rt.u32): rt.u32 { - rt.idx(s, 0); - const _8: rt.u32 = value; +export function writeFirst$u32(s: rs.u32[], value: rs.u32): rs.u32 { + rs.idx(s, 0); + const _8: rs.u32 = value; const old2 = s[0]; s[0] = _8; - const old: rt.u32 = old2; - const _10: rt.u32 = value; - rt.idx(s, 0); + const old: rs.u32 = old2; + const _10: rs.u32 = value; + rs.idx(s, 0); s[0] = _10; return old; } /** A whole write into what a slice holds, as a function given any slice makes it. */ -export function writeFirst$u64(s: rt.u64[], value: rt.u64): rt.u64 { - rt.idx(s, 0); - const _8: rt.u64 = value; +export function writeFirst$u64(s: rs.u64[], value: rs.u64): rs.u64 { + rs.idx(s, 0); + const _8: rs.u64 = value; const old2 = s[0]; s[0] = _8; - const old: rt.u64 = old2; - const _10: rt.u64 = value; - rt.idx(s, 0); + const old: rs.u64 = old2; + const _10: rs.u64 = value; + rs.idx(s, 0); s[0] = _10; return old; } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$Option_u16(s: Array[], value: Array): Array { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_Option_u16(value)); +export function replaceFirst$Option_u16(s: Array[], value: Array): Array { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_Option_u16(value)); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$String(s: string[][], value: string[]): string[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, value); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$Vec_u32(s: rt.Vec[][], value: rt.Vec[]): rt.Vec[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, value, 1); +export function replaceFirst$Vec_u32(s: rs.Vec[][], value: rs.Vec[]): rs.Vec[] { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$Vec_u8(s: rt.ByteVec[][], value: rt.ByteVec[]): rt.ByteVec[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, value, 1); +export function replaceFirst$Vec_u8(s: rs.ByteVec[][], value: rs.ByteVec[]): rs.ByteVec[] { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array0_u8(s: Uint8Array[][], value: Uint8Array[]): Uint8Array[] { - rt.idx(s, 0); + rs.idx(s, 0); return copy$array_array0_u8(value); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array1_u8(s: Uint8Array[][], value: Uint8Array[]): Uint8Array[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_array1_u8(value), 1); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_array1_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$array2_u32(s: rt.u32[][][], value: rt.u32[][]): rt.u32[][] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_array2_u32(value), 1); +export function replaceFirst$array2_u32(s: rs.u32[][][], value: rs.u32[][]): rs.u32[][] { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_array2_u32(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array3_u8(s: Uint8Array[][], value: Uint8Array[]): Uint8Array[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_array3_u8(value), 1); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_array3_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$array40_u8(s: Uint8Array[][], value: Uint8Array[]): Uint8Array[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_array40_u8(value), 1); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_array40_u8(value), 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$conversions_Logged(s: Logged.Logged[][], value: Logged.Logged[]): Logged.Logged[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, value, 1); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ export function replaceFirst$conversions_Named(s: Named.Named[][], value: Named.Named[]): Named.Named[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, value, 1); + rs.idx(s, 0); + return rs.sliceReplace(s, 0, value, 1); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$u32(s: rt.u32[][], value: rt.u32[]): rt.u32[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_u32(value)); +export function replaceFirst$u32(s: rs.u32[][], value: rs.u32[]): rs.u32[] { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_u32(value)); } /** `mem::replace` of the first array, as a function given any slice of them makes it. */ -export function replaceFirst$u64(s: rt.u64[][], value: rt.u64[]): rt.u64[] { - rt.idx(s, 0); - return rt.sliceReplace(s, 0, copy$array_u64(value)); +export function replaceFirst$u64(s: rs.u64[][], value: rs.u64[]): rs.u64[] { + rs.idx(s, 0); + return rs.sliceReplace(s, 0, copy$array_u64(value)); } /** @@ -705,59 +705,59 @@ export function replaceFirst$u64(s: rt.u64[][], value: rt.u64[]): rt.u64[] { * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$Option_u16(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Array = rt.sliceOfPlace(to); +export function lentParam$Option_u16(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Array = rs.sliceOfPlace(to); put$conversions_Value_Option_u16(writeFirst$Option_u16(s, make$conversions_Value_Option_u16(data, 18)), out); - let other: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 19); - rt.idx(s, 0); + let other: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 19); + rs.idx(s, 0); const swapped = s[0]; s[0] = other; other = swapped; put$conversions_Value_Option_u16(other, out); - rt.idx(s, 0); + rs.idx(s, 0); const swapped2 = other; other = s[0]; s[0] = swapped2; put$conversions_Value_Option_u16(other, out); - const t: Array = rt.vecFrom([make$conversions_Value_Option_u16(data, 20), make$conversions_Value_Option_u16(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); + const t: Array = rs.vecFrom([make$conversions_Value_Option_u16(data, 20), make$conversions_Value_Option_u16(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); const swapped3 = s[0]; s[0] = t[1]; t[1] = swapped3; - rt.idx(t, 0); - rt.idx(s, 0); + rs.idx(t, 0); + rs.idx(s, 0); const swapped4 = t[0]; t[0] = s[0]; s[0] = swapped4; - rt.idx(t, 0); + rs.idx(t, 0); put$conversions_Value_Option_u16(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_Option_u16(t[1], out); - rt.idx(s, 0); - const a: Array = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: Array = [make$conversions_Value_Option_u16(data, 22)]; - put$conversions_Value_Option_u16(rt.replaceIn(a, _77)[0], out); - let by: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 23); - rt.idx(s, 0); - let r: rt.Place = rt.place(() => s[0], (value2) => s[0] = value2); - const _89: rt.Place[] = rt.sliceOfPlace(rt.place(() => r, (value3) => r = value3)); - const _91: rt.Place[] = [rt.place(() => by, (value4) => by = value4)]; - rt.replaceIn(_89, _91)[0].v = make$conversions_Value_Option_u16(data, 24); + rs.idx(s, 0); + const a: Array = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: Array = [make$conversions_Value_Option_u16(data, 22)]; + put$conversions_Value_Option_u16(rs.replaceIn(a, _77)[0], out); + let by: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 23); + rs.idx(s, 0); + let r: rs.Place = rs.place(() => s[0], (value2) => s[0] = value2); + const _89: rs.Place[] = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); + const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; + rs.replaceIn(_89, _91)[0].v = make$conversions_Value_Option_u16(data, 24); put$conversions_Value_Option_u16(r.v, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_Option_u16(s[0], out); - rt.idx(s, 0); - put$conversions_Value_Option_u16(rt.cellReplace(rt.cellOfPlace(rt.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_Option_u16(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_Option_u16(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_Option_u16(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Option_u16(replaceFirst$Option_u16(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_Option_u16(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Option_u16(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellOfPlace(rs.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_Option_u16(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_Option_u16(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Option_u16(replaceFirst$Option_u16(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_Option_u16(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Option_u16(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_Option_u16(data, 28)]])[0][0], out); + rs.idx(s, 0); s[0] = other; - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_Option_u16(s[0], out); } @@ -767,59 +767,59 @@ export function lentParam$Option_u16(to: rt.Place, data: rt. * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$String(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: string[] = rt.sliceOfPlace(to); +export function lentParam$String(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: string[] = rs.sliceOfPlace(to); put$conversions_Value_String(writeFirst$String(s, make$conversions_Value_String(data, 18)), out); let other: string = make$conversions_Value_String(data, 19); - rt.idx(s, 0); + rs.idx(s, 0); const swapped = s[0]; s[0] = other; other = swapped; put$conversions_Value_String(other, out); - rt.idx(s, 0); + rs.idx(s, 0); const swapped2 = other; other = s[0]; s[0] = swapped2; put$conversions_Value_String(other, out); - const t: string[] = rt.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); + const t: string[] = rs.vecFrom([make$conversions_Value_String(data, 20), make$conversions_Value_String(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); const swapped3 = s[0]; s[0] = t[1]; t[1] = swapped3; - rt.idx(t, 0); - rt.idx(s, 0); + rs.idx(t, 0); + rs.idx(s, 0); const swapped4 = t[0]; t[0] = s[0]; s[0] = swapped4; - rt.idx(t, 0); + rs.idx(t, 0); put$conversions_Value_String(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_String(t[1], out); - rt.idx(s, 0); - const a: string[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); + rs.idx(s, 0); + const a: string[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); const _77: string[] = [make$conversions_Value_String(data, 22)]; - put$conversions_Value_String(rt.replaceIn(a, _77)[0], out); + put$conversions_Value_String(rs.replaceIn(a, _77)[0], out); let by: string = make$conversions_Value_String(data, 23); - rt.idx(s, 0); - let r: rt.Place = rt.place(() => s[0], (value2) => s[0] = value2); - const _89: rt.Place[] = rt.sliceOfPlace(rt.place(() => r, (value3) => r = value3)); - const _91: rt.Place[] = [rt.place(() => by, (value4) => by = value4)]; - rt.replaceIn(_89, _91)[0].v = make$conversions_Value_String(data, 24); + rs.idx(s, 0); + let r: rs.Place = rs.place(() => s[0], (value2) => s[0] = value2); + const _89: rs.Place[] = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); + const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; + rs.replaceIn(_89, _91)[0].v = make$conversions_Value_String(data, 24); put$conversions_Value_String(r.v, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_String(s[0], out); - rt.idx(s, 0); - put$conversions_Value_String(rt.cellReplace(rt.cellOfPlace(rt.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_String(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_String(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_String(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_String(replaceFirst$String(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_String(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_String(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_String(rs.cellReplace(rs.cellOfPlace(rs.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_String(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_String(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_String(replaceFirst$String(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_String(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_String(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_String(data, 28)]])[0][0], out); + rs.idx(s, 0); s[0] = other; - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_String(s[0], out); } @@ -829,51 +829,51 @@ export function lentParam$String(to: rt.Place, data: rt.ByteSlice, out: * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$Vec_u32(to: rt.Vec, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.Vec[] = rt.sliceIn(to); +export function lentParam$Vec_u32(to: rs.Vec, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.Vec[] = rs.sliceIn(to); put$conversions_Value_Vec_u32(writeFirst$Vec_u32(s, make$conversions_Value_Vec_u32(data, 18)), out); - let other: rt.Vec = make$conversions_Value_Vec_u32(data, 19); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + let other: rs.Vec = make$conversions_Value_Vec_u32(data, 19); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_Vec_u32(other, out); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_Vec_u32(other, out); - const t: rt.Vec[] = rt.vecFrom([make$conversions_Value_Vec_u32(data, 20), make$conversions_Value_Vec_u32(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); - rt.sliceSwapAcross(s, 0, t, 1); - rt.idx(t, 0); - rt.idx(s, 0); - rt.sliceSwapAcross(t, 0, s, 0); - rt.idx(t, 0); + const t: rs.Vec[] = rs.vecFrom([make$conversions_Value_Vec_u32(data, 20), make$conversions_Value_Vec_u32(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); + rs.sliceSwapAcross(s, 0, t, 1); + rs.idx(t, 0); + rs.idx(s, 0); + rs.sliceSwapAcross(t, 0, s, 0); + rs.idx(t, 0); put$conversions_Value_Vec_u32(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_Vec_u32(t[1], out); - rt.idx(s, 0); - const a: rt.Vec[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: rt.Vec[] = [make$conversions_Value_Vec_u32(data, 22)]; - put$conversions_Value_Vec_u32(rt.replaceIn(a, _77, 1)[0], out); - const by: rt.Vec = make$conversions_Value_Vec_u32(data, 23); - rt.idx(s, 0); - let r: rt.Vec = s[0]; - const _89: rt.Vec[] = rt.sliceOfPlace(rt.place(() => r, (value2) => r = value2)); - const _91: rt.Vec[] = [by]; - Object.assign(rt.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u32(data, 24)); + rs.idx(s, 0); + const a: rs.Vec[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: rs.Vec[] = [make$conversions_Value_Vec_u32(data, 22)]; + put$conversions_Value_Vec_u32(rs.replaceIn(a, _77, 1)[0], out); + const by: rs.Vec = make$conversions_Value_Vec_u32(data, 23); + rs.idx(s, 0); + let r: rs.Vec = s[0]; + const _89: rs.Vec[] = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); + const _91: rs.Vec[] = [by]; + Object.assign(rs.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u32(data, 24)); put$conversions_Value_Vec_u32(r, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_Vec_u32(s[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u32(rt.cellReplace(rt.cellIn(s[0]), make$conversions_Value_Vec_u32(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_Vec_u32(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value3) => s[0] = value3)), 1), [make$conversions_Value_Vec_u32(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u32(replaceFirst$Vec_u32(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_Vec_u32(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u32(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value5) => s[0] = value5))), 2), [[make$conversions_Value_Vec_u32(data, 28)]])[0][0], out); - rt.idx(s, 0); - rt.vecCloneFrom(s[0], other, 4); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(s[0]), make$conversions_Value_Vec_u32(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value3) => s[0] = value3)), 1), [make$conversions_Value_Vec_u32(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Vec_u32(replaceFirst$Vec_u32(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_Vec_u32(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Vec_u32(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value5) => s[0] = value5))), 2), [[make$conversions_Value_Vec_u32(data, 28)]])[0][0], out); + rs.idx(s, 0); + rs.vecCloneFrom(s[0], other, 4); + rs.idx(s, 0); put$conversions_Value_Vec_u32(s[0], out); } @@ -883,51 +883,51 @@ export function lentParam$Vec_u32(to: rt.Vec, data: rt.ByteSlice, out: r * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$Vec_u8(to: rt.ByteVec, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.ByteVec[] = rt.sliceIn(to); +export function lentParam$Vec_u8(to: rs.ByteVec, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.ByteVec[] = rs.sliceIn(to); put$conversions_Value_Vec_u8(writeFirst$Vec_u8(s, make$conversions_Value_Vec_u8(data, 18)), out); - let other: rt.ByteVec = make$conversions_Value_Vec_u8(data, 19); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + let other: rs.ByteVec = make$conversions_Value_Vec_u8(data, 19); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_Vec_u8(other, out); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_Vec_u8(other, out); - const t: rt.ByteVec[] = rt.vecFrom([make$conversions_Value_Vec_u8(data, 20), make$conversions_Value_Vec_u8(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); - rt.sliceSwapAcross(s, 0, t, 1); - rt.idx(t, 0); - rt.idx(s, 0); - rt.sliceSwapAcross(t, 0, s, 0); - rt.idx(t, 0); + const t: rs.ByteVec[] = rs.vecFrom([make$conversions_Value_Vec_u8(data, 20), make$conversions_Value_Vec_u8(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); + rs.sliceSwapAcross(s, 0, t, 1); + rs.idx(t, 0); + rs.idx(s, 0); + rs.sliceSwapAcross(t, 0, s, 0); + rs.idx(t, 0); put$conversions_Value_Vec_u8(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_Vec_u8(t[1], out); - rt.idx(s, 0); - const a: rt.ByteVec[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: rt.ByteVec[] = [make$conversions_Value_Vec_u8(data, 22)]; - put$conversions_Value_Vec_u8(rt.replaceIn(a, _77, 1)[0], out); - const by: rt.ByteVec = make$conversions_Value_Vec_u8(data, 23); - rt.idx(s, 0); - let r: rt.ByteVec = s[0]; - const _89: rt.ByteVec[] = rt.sliceOfPlace(rt.place(() => r, (value2) => r = value2)); - const _91: rt.ByteVec[] = [by]; - Object.assign(rt.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u8(data, 24)); + rs.idx(s, 0); + const a: rs.ByteVec[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: rs.ByteVec[] = [make$conversions_Value_Vec_u8(data, 22)]; + put$conversions_Value_Vec_u8(rs.replaceIn(a, _77, 1)[0], out); + const by: rs.ByteVec = make$conversions_Value_Vec_u8(data, 23); + rs.idx(s, 0); + let r: rs.ByteVec = s[0]; + const _89: rs.ByteVec[] = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); + const _91: rs.ByteVec[] = [by]; + Object.assign(rs.replaceIn(_89, _91)[0], make$conversions_Value_Vec_u8(data, 24)); put$conversions_Value_Vec_u8(r, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_Vec_u8(s[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u8(rt.cellReplace(rt.cellIn(s[0]), make$conversions_Value_Vec_u8(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_Vec_u8(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value3) => s[0] = value3)), 1), [make$conversions_Value_Vec_u8(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u8(replaceFirst$Vec_u8(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_Vec_u8(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_Vec_u8(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value5) => s[0] = value5))), 2), [[make$conversions_Value_Vec_u8(data, 28)]])[0][0], out); - rt.idx(s, 0); - rt.byteVecCloneFrom(s[0], other); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(s[0]), make$conversions_Value_Vec_u8(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value3) => s[0] = value3)), 1), [make$conversions_Value_Vec_u8(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Vec_u8(replaceFirst$Vec_u8(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_Vec_u8(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_Vec_u8(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value5) => s[0] = value5))), 2), [[make$conversions_Value_Vec_u8(data, 28)]])[0][0], out); + rs.idx(s, 0); + rs.byteVecCloneFrom(s[0], other); + rs.idx(s, 0); put$conversions_Value_Vec_u8(s[0], out); } @@ -937,60 +937,60 @@ export function lentParam$Vec_u8(to: rt.ByteVec, data: rt.ByteSlice, out: rt.Byt * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array0_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(to)); - put$conversions_Value_array0_u8(rt.byteSliceFrom(writeFirst$array0_u8(s, make$conversions_Value_array0_u8(data, 18))), out); +export function lentParam$array0_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(to)); + put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(s, make$conversions_Value_array0_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 19)); - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - rt.byteSliceFrom(other); - put$conversions_Value_array0_u8(rt.byteSliceFrom(other), out); - rt.byteSliceFrom(other); - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - put$conversions_Value_array0_u8(rt.byteSliceFrom(other), out); - const t: Uint8Array[] = rt.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 20), make$conversions_Value_array0_u8(data, 21)]).map(copy$array_u8)).items; - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - rt.idx(t, 1); - rt.byteSliceFrom(t[1]); - rt.idx(t, 0); - rt.byteSliceFrom(t[0]); - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - rt.idx(t, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(t[0]), out); - rt.idx(t, 1); - put$conversions_Value_array0_u8(rt.byteSliceFrom(t[1]), out); - rt.idx(s, 0); - rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))); + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + rs.byteSliceFrom(other); + put$conversions_Value_array0_u8(rs.byteSliceFrom(other), out); + rs.byteSliceFrom(other); + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + put$conversions_Value_array0_u8(rs.byteSliceFrom(other), out); + const t: Uint8Array[] = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 20), make$conversions_Value_array0_u8(data, 21)]).map(copy$array_u8)).items; + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + rs.idx(t, 1); + rs.byteSliceFrom(t[1]); + rs.idx(t, 0); + rs.byteSliceFrom(t[0]); + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + rs.idx(t, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(t[0]), out); + rs.idx(t, 1); + put$conversions_Value_array0_u8(rs.byteSliceFrom(t[1]), out); + rs.idx(s, 0); + rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))); const _76: Uint8Array[] = [copy$array_u8(make$conversions_Value_array0_u8(data, 22))]; - put$conversions_Value_array0_u8(rt.byteSliceFrom(_76[0]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(_76[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 23)); - rt.idx(s, 0); - let r: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _89: rt.ByteSlice[] = rt.sliceOfPlace(rt.place(() => r, (value) => r = value)); - const _91: rt.ByteSlice[] = [rt.byteSliceFrom(by)]; - const _88: rt.ByteSlice[] = rt.replaceIn(_89, _91); + rs.idx(s, 0); + let r: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _89: rs.ByteSlice[] = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); + const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; + const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array0_u8(r, out); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(s[0]), out); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array0_u8(data, 25)))), out); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array0_u8(data, 26))])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(replaceFirst$array0_u8(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), [make$conversions_Value_array0_u8(data, 27)])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); - rt.idx(s, 0); - const _154: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _159: rt.ByteSlice = rt.byteSliceFrom(other); - _154.data.set(rt.byteSliceToArray(_159), _154.start); - rt.idx(s, 0); - put$conversions_Value_array0_u8(rt.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array0_u8(data, 25)))), out); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array0_u8(data, 26))])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(replaceFirst$array0_u8(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), [make$conversions_Value_array0_u8(data, 27)])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array0_u8(data, 28))]])[0][0]), out); + rs.idx(s, 0); + const _154: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _159: rs.ByteSlice = rs.byteSliceFrom(other); + _154.data.set(rs.byteSliceToArray(_159), _154.start); + rs.idx(s, 0); + put$conversions_Value_array0_u8(rs.byteSliceFrom(s[0]), out); } /** @@ -999,72 +999,72 @@ export function lentParam$array0_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: r * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array1_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(to)); - put$conversions_Value_array1_u8(rt.byteSliceFrom(writeFirst$array1_u8(s, make$conversions_Value_array1_u8(data, 18))), out); +export function lentParam$array1_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(to)); + put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(s, make$conversions_Value_array1_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 19)); - rt.idx(s, 0); - const _11: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _16: rt.ByteSlice = rt.byteSliceFrom(other); - const swapped = rt.byteSliceToArray(_11); - _11.data.set(rt.byteSliceToArray(_16), _11.start); + rs.idx(s, 0); + const _11: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _16: rs.ByteSlice = rs.byteSliceFrom(other); + const swapped = rs.byteSliceToArray(_11); + _11.data.set(rs.byteSliceToArray(_16), _11.start); _16.data.set(swapped, _16.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(other), out); - const _20: rt.ByteSlice = rt.byteSliceFrom(other); - rt.idx(s, 0); - const _21: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped2 = rt.byteSliceToArray(_20); - _20.data.set(rt.byteSliceToArray(_21), _20.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(other), out); + const _20: rs.ByteSlice = rs.byteSliceFrom(other); + rs.idx(s, 0); + const _21: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped2 = rs.byteSliceToArray(_20); + _20.data.set(rs.byteSliceToArray(_21), _20.start); _21.data.set(swapped2, _21.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(other), out); - const t: Uint8Array[] = rt.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 20), make$conversions_Value_array1_u8(data, 21)]).map(copy$array_u8)).items; - rt.idx(s, 0); - const _35: rt.ByteSlice = rt.byteSliceFrom(s[0]); - rt.idx(t, 1); - const _40: rt.ByteSlice = rt.byteSliceFrom(t[1]); - const swapped3 = rt.byteSliceToArray(_35); - _35.data.set(rt.byteSliceToArray(_40), _35.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(other), out); + const t: Uint8Array[] = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 20), make$conversions_Value_array1_u8(data, 21)]).map(copy$array_u8)).items; + rs.idx(s, 0); + const _35: rs.ByteSlice = rs.byteSliceFrom(s[0]); + rs.idx(t, 1); + const _40: rs.ByteSlice = rs.byteSliceFrom(t[1]); + const swapped3 = rs.byteSliceToArray(_35); + _35.data.set(rs.byteSliceToArray(_40), _35.start); _40.data.set(swapped3, _40.start); - rt.idx(t, 0); - const _46: rt.ByteSlice = rt.byteSliceFrom(t[0]); - rt.idx(s, 0); - const _51: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped4 = rt.byteSliceToArray(_46); - _46.data.set(rt.byteSliceToArray(_51), _46.start); + rs.idx(t, 0); + const _46: rs.ByteSlice = rs.byteSliceFrom(t[0]); + rs.idx(s, 0); + const _51: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped4 = rs.byteSliceToArray(_46); + _46.data.set(rs.byteSliceToArray(_51), _46.start); _51.data.set(swapped4, _51.start); - rt.idx(t, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(t[0]), out); - rt.idx(t, 1); - put$conversions_Value_array1_u8(rt.byteSliceFrom(t[1]), out); - rt.idx(s, 0); - const a: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))); + rs.idx(t, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(t[0]), out); + rs.idx(t, 1); + put$conversions_Value_array1_u8(rs.byteSliceFrom(t[1]), out); + rs.idx(s, 0); + const a: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 22))]; - put$conversions_Value_array1_u8(rt.byteSliceFrom(rt.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 23)); - rt.idx(s, 0); - let r: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _89: rt.ByteSlice[] = rt.sliceOfPlace(rt.place(() => r, (value) => r = value)); - const _91: rt.ByteSlice[] = [rt.byteSliceFrom(by)]; - const _88: rt.ByteSlice[] = rt.replaceIn(_89, _91); + rs.idx(s, 0); + let r: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _89: rs.ByteSlice[] = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); + const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; + const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array1_u8(r, out); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(s[0]), out); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array1_u8(data, 25)))), out); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array1_u8(data, 26))])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(replaceFirst$array1_u8(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), [make$conversions_Value_array1_u8(data, 27)])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); - rt.idx(s, 0); - const _154: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _159: rt.ByteSlice = rt.byteSliceFrom(other); - _154.data.set(rt.byteSliceToArray(_159), _154.start); - rt.idx(s, 0); - put$conversions_Value_array1_u8(rt.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array1_u8(data, 25)))), out); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array1_u8(data, 26))])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(replaceFirst$array1_u8(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), [make$conversions_Value_array1_u8(data, 27)])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array1_u8(data, 28))]])[0][0]), out); + rs.idx(s, 0); + const _154: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _159: rs.ByteSlice = rs.byteSliceFrom(other); + _154.data.set(rs.byteSliceToArray(_159), _154.start); + rs.idx(s, 0); + put$conversions_Value_array1_u8(rs.byteSliceFrom(s[0]), out); } /** @@ -1073,51 +1073,51 @@ export function lentParam$array1_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: r * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array2_u32(to: rt.u32[], data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.u32[][] = rt.sliceIn(to); +export function lentParam$array2_u32(to: rs.u32[], data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.u32[][] = rs.sliceIn(to); put$conversions_Value_array2_u32(writeFirst$array2_u32(s, make$conversions_Value_array2_u32(data, 18)), out); - let other: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + let other: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_array2_u32(other, out); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); put$conversions_Value_array2_u32(other, out); - const t: rt.u32[][] = rt.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 20), make$conversions_Value_array2_u32(data, 21)]).map(copy$array_u32)).items; - rt.idx(s, 0); - rt.idx(t, 1); - rt.sliceSwapAcross(s, 0, t, 1); - rt.idx(t, 0); - rt.idx(s, 0); - rt.sliceSwapAcross(t, 0, s, 0); - rt.idx(t, 0); + const t: rs.u32[][] = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 20), make$conversions_Value_array2_u32(data, 21)]).map(copy$array_u32)).items; + rs.idx(s, 0); + rs.idx(t, 1); + rs.sliceSwapAcross(s, 0, t, 1); + rs.idx(t, 0); + rs.idx(s, 0); + rs.sliceSwapAcross(t, 0, s, 0); + rs.idx(t, 0); put$conversions_Value_array2_u32(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_array2_u32(t[1], out); - rt.idx(s, 0); - const a: rt.u32[][] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: rt.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 22))]; - put$conversions_Value_array2_u32(rt.replaceIn(a, _77, 1)[0], out); - const by: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 23)); - rt.idx(s, 0); - let r: rt.u32[] = s[0]; - const _89: rt.u32[][] = rt.sliceOfPlace(rt.place(() => r, (value2) => r = value2)); - const _91: rt.u32[][] = [by]; - Object.assign(rt.replaceIn(_89, _91)[0], copy$array_u32(make$conversions_Value_array2_u32(data, 24))); + rs.idx(s, 0); + const a: rs.u32[][] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 22))]; + put$conversions_Value_array2_u32(rs.replaceIn(a, _77, 1)[0], out); + const by: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 23)); + rs.idx(s, 0); + let r: rs.u32[] = s[0]; + const _89: rs.u32[][] = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); + const _91: rs.u32[][] = [by]; + Object.assign(rs.replaceIn(_89, _91)[0], copy$array_u32(make$conversions_Value_array2_u32(data, 24))); put$conversions_Value_array2_u32(r, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_array2_u32(s[0], out); - rt.idx(s, 0); - put$conversions_Value_array2_u32(rt.cellReplace(rt.cellIn(s[0]), copy$array_u32(make$conversions_Value_array2_u32(data, 25))), out); - rt.idx(s, 0); - put$conversions_Value_array2_u32(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value3) => s[0] = value3)), 1), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0], out); - rt.idx(s, 0); - put$conversions_Value_array2_u32(replaceFirst$array2_u32(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_array2_u32(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_array2_u32(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value5) => s[0] = value5))), 2), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(s[0]), copy$array_u32(make$conversions_Value_array2_u32(data, 25))), out); + rs.idx(s, 0); + put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value3) => s[0] = value3)), 1), [copy$array_u32(make$conversions_Value_array2_u32(data, 26))])[0], out); + rs.idx(s, 0); + put$conversions_Value_array2_u32(replaceFirst$array2_u32(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value4) => s[0] = value4))), [make$conversions_Value_array2_u32(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_array2_u32(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value5) => s[0] = value5))), 2), [[copy$array_u32(make$conversions_Value_array2_u32(data, 28))]])[0][0], out); + rs.idx(s, 0); s[0] = copy$array_u32(other); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_array2_u32(s[0], out); } @@ -1127,72 +1127,72 @@ export function lentParam$array2_u32(to: rt.u32[], data: rt.ByteSlice, out: rt.B * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array3_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(to)); - put$conversions_Value_array3_u8(rt.byteSliceFrom(writeFirst$array3_u8(s, make$conversions_Value_array3_u8(data, 18))), out); +export function lentParam$array3_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(to)); + put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(s, make$conversions_Value_array3_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 19)); - rt.idx(s, 0); - const _11: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _16: rt.ByteSlice = rt.byteSliceFrom(other); - const swapped = rt.byteSliceToArray(_11); - _11.data.set(rt.byteSliceToArray(_16), _11.start); + rs.idx(s, 0); + const _11: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _16: rs.ByteSlice = rs.byteSliceFrom(other); + const swapped = rs.byteSliceToArray(_11); + _11.data.set(rs.byteSliceToArray(_16), _11.start); _16.data.set(swapped, _16.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(other), out); - const _20: rt.ByteSlice = rt.byteSliceFrom(other); - rt.idx(s, 0); - const _21: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped2 = rt.byteSliceToArray(_20); - _20.data.set(rt.byteSliceToArray(_21), _20.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(other), out); + const _20: rs.ByteSlice = rs.byteSliceFrom(other); + rs.idx(s, 0); + const _21: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped2 = rs.byteSliceToArray(_20); + _20.data.set(rs.byteSliceToArray(_21), _20.start); _21.data.set(swapped2, _21.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(other), out); - const t: Uint8Array[] = rt.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 20), make$conversions_Value_array3_u8(data, 21)]).map(copy$array_u8)).items; - rt.idx(s, 0); - const _35: rt.ByteSlice = rt.byteSliceFrom(s[0]); - rt.idx(t, 1); - const _40: rt.ByteSlice = rt.byteSliceFrom(t[1]); - const swapped3 = rt.byteSliceToArray(_35); - _35.data.set(rt.byteSliceToArray(_40), _35.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(other), out); + const t: Uint8Array[] = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 20), make$conversions_Value_array3_u8(data, 21)]).map(copy$array_u8)).items; + rs.idx(s, 0); + const _35: rs.ByteSlice = rs.byteSliceFrom(s[0]); + rs.idx(t, 1); + const _40: rs.ByteSlice = rs.byteSliceFrom(t[1]); + const swapped3 = rs.byteSliceToArray(_35); + _35.data.set(rs.byteSliceToArray(_40), _35.start); _40.data.set(swapped3, _40.start); - rt.idx(t, 0); - const _46: rt.ByteSlice = rt.byteSliceFrom(t[0]); - rt.idx(s, 0); - const _51: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped4 = rt.byteSliceToArray(_46); - _46.data.set(rt.byteSliceToArray(_51), _46.start); + rs.idx(t, 0); + const _46: rs.ByteSlice = rs.byteSliceFrom(t[0]); + rs.idx(s, 0); + const _51: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped4 = rs.byteSliceToArray(_46); + _46.data.set(rs.byteSliceToArray(_51), _46.start); _51.data.set(swapped4, _51.start); - rt.idx(t, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(t[0]), out); - rt.idx(t, 1); - put$conversions_Value_array3_u8(rt.byteSliceFrom(t[1]), out); - rt.idx(s, 0); - const a: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))); + rs.idx(t, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(t[0]), out); + rs.idx(t, 1); + put$conversions_Value_array3_u8(rs.byteSliceFrom(t[1]), out); + rs.idx(s, 0); + const a: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 22))]; - put$conversions_Value_array3_u8(rt.byteSliceFrom(rt.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 23)); - rt.idx(s, 0); - let r: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _89: rt.ByteSlice[] = rt.sliceOfPlace(rt.place(() => r, (value) => r = value)); - const _91: rt.ByteSlice[] = [rt.byteSliceFrom(by)]; - const _88: rt.ByteSlice[] = rt.replaceIn(_89, _91); + rs.idx(s, 0); + let r: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _89: rs.ByteSlice[] = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); + const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; + const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array3_u8(r, out); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(s[0]), out); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array3_u8(data, 25)))), out); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array3_u8(data, 26))])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(replaceFirst$array3_u8(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), [make$conversions_Value_array3_u8(data, 27)])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); - rt.idx(s, 0); - const _154: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _159: rt.ByteSlice = rt.byteSliceFrom(other); - _154.data.set(rt.byteSliceToArray(_159), _154.start); - rt.idx(s, 0); - put$conversions_Value_array3_u8(rt.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array3_u8(data, 25)))), out); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array3_u8(data, 26))])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(replaceFirst$array3_u8(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), [make$conversions_Value_array3_u8(data, 27)])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array3_u8(data, 28))]])[0][0]), out); + rs.idx(s, 0); + const _154: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _159: rs.ByteSlice = rs.byteSliceFrom(other); + _154.data.set(rs.byteSliceToArray(_159), _154.start); + rs.idx(s, 0); + put$conversions_Value_array3_u8(rs.byteSliceFrom(s[0]), out); } /** @@ -1201,72 +1201,72 @@ export function lentParam$array3_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: r * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$array40_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(to)); - put$conversions_Value_array40_u8(rt.byteSliceFrom(writeFirst$array40_u8(s, make$conversions_Value_array40_u8(data, 18))), out); +export function lentParam$array40_u8(to: rs.ByteSlice, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(to)); + put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(s, make$conversions_Value_array40_u8(data, 18))), out); const other: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 19)); - rt.idx(s, 0); - const _11: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _16: rt.ByteSlice = rt.byteSliceFrom(other); - const swapped = rt.byteSliceToArray(_11); - _11.data.set(rt.byteSliceToArray(_16), _11.start); + rs.idx(s, 0); + const _11: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _16: rs.ByteSlice = rs.byteSliceFrom(other); + const swapped = rs.byteSliceToArray(_11); + _11.data.set(rs.byteSliceToArray(_16), _11.start); _16.data.set(swapped, _16.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(other), out); - const _20: rt.ByteSlice = rt.byteSliceFrom(other); - rt.idx(s, 0); - const _21: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped2 = rt.byteSliceToArray(_20); - _20.data.set(rt.byteSliceToArray(_21), _20.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(other), out); + const _20: rs.ByteSlice = rs.byteSliceFrom(other); + rs.idx(s, 0); + const _21: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped2 = rs.byteSliceToArray(_20); + _20.data.set(rs.byteSliceToArray(_21), _20.start); _21.data.set(swapped2, _21.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(other), out); - const t: Uint8Array[] = rt.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 20), make$conversions_Value_array40_u8(data, 21)]).map(copy$array_u8)).items; - rt.idx(s, 0); - const _35: rt.ByteSlice = rt.byteSliceFrom(s[0]); - rt.idx(t, 1); - const _40: rt.ByteSlice = rt.byteSliceFrom(t[1]); - const swapped3 = rt.byteSliceToArray(_35); - _35.data.set(rt.byteSliceToArray(_40), _35.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(other), out); + const t: Uint8Array[] = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 20), make$conversions_Value_array40_u8(data, 21)]).map(copy$array_u8)).items; + rs.idx(s, 0); + const _35: rs.ByteSlice = rs.byteSliceFrom(s[0]); + rs.idx(t, 1); + const _40: rs.ByteSlice = rs.byteSliceFrom(t[1]); + const swapped3 = rs.byteSliceToArray(_35); + _35.data.set(rs.byteSliceToArray(_40), _35.start); _40.data.set(swapped3, _40.start); - rt.idx(t, 0); - const _46: rt.ByteSlice = rt.byteSliceFrom(t[0]); - rt.idx(s, 0); - const _51: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const swapped4 = rt.byteSliceToArray(_46); - _46.data.set(rt.byteSliceToArray(_51), _46.start); + rs.idx(t, 0); + const _46: rs.ByteSlice = rs.byteSliceFrom(t[0]); + rs.idx(s, 0); + const _51: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const swapped4 = rs.byteSliceToArray(_46); + _46.data.set(rs.byteSliceToArray(_51), _46.start); _51.data.set(swapped4, _51.start); - rt.idx(t, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(t[0]), out); - rt.idx(t, 1); - put$conversions_Value_array40_u8(rt.byteSliceFrom(t[1]), out); - rt.idx(s, 0); - const a: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))); + rs.idx(t, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(t[0]), out); + rs.idx(t, 1); + put$conversions_Value_array40_u8(rs.byteSliceFrom(t[1]), out); + rs.idx(s, 0); + const a: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))); const _77: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 22))]; - put$conversions_Value_array40_u8(rt.byteSliceFrom(rt.replaceIn(a, _77, 1)[0]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.replaceIn(a, _77, 1)[0]), out); const by: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 23)); - rt.idx(s, 0); - let r: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _89: rt.ByteSlice[] = rt.sliceOfPlace(rt.place(() => r, (value) => r = value)); - const _91: rt.ByteSlice[] = [rt.byteSliceFrom(by)]; - const _88: rt.ByteSlice[] = rt.replaceIn(_89, _91); + rs.idx(s, 0); + let r: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _89: rs.ByteSlice[] = rs.sliceOfPlace(rs.place(() => r, (value) => r = value)); + const _91: rs.ByteSlice[] = [rs.byteSliceFrom(by)]; + const _88: rs.ByteSlice[] = rs.replaceIn(_89, _91); const _93: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 24)); _88[0].data.set(_93, _88[0].start); put$conversions_Value_array40_u8(r, out); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(s[0]), out); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array40_u8(data, 25)))), out); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array40_u8(data, 26))])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(replaceFirst$array40_u8(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), [make$conversions_Value_array40_u8(data, 27)])[0]), out); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); - rt.idx(s, 0); - const _154: rt.ByteSlice = rt.byteSliceFrom(s[0]); - const _159: rt.ByteSlice = rt.byteSliceFrom(other); - _154.data.set(rt.byteSliceToArray(_159), _154.start); - rt.idx(s, 0); - put$conversions_Value_array40_u8(rt.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(s[0]), out); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), copy$array_u8(make$conversions_Value_array40_u8(data, 25)))), out); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0]))), 1), [copy$array_u8(make$conversions_Value_array40_u8(data, 26))])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(replaceFirst$array40_u8(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), [make$conversions_Value_array40_u8(data, 27)])[0]), out); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(s[0])))), 2), [[copy$array_u8(make$conversions_Value_array40_u8(data, 28))]])[0][0]), out); + rs.idx(s, 0); + const _154: rs.ByteSlice = rs.byteSliceFrom(s[0]); + const _159: rs.ByteSlice = rs.byteSliceFrom(other); + _154.data.set(rs.byteSliceToArray(_159), _154.start); + rs.idx(s, 0); + put$conversions_Value_array40_u8(rs.byteSliceFrom(s[0]), out); } /** @@ -1275,70 +1275,70 @@ export function lentParam$array40_u8(to: rt.ByteSlice, data: rt.ByteSlice, out: * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$conversions_Logged(to: Logged.Logged, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Logged.Logged[] = rt.sliceIn(to); +export function lentParam$conversions_Logged(to: Logged.Logged, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Logged.Logged[] = rs.sliceIn(to); const _7: Logged.Logged = writeFirst$conversions_Logged(s, Logged.make$conversions_Value(data, 18)); Logged.put$conversions_Value(_7, out); _7[Symbol.dispose](); let other: Logged.Logged = Logged.make$conversions_Value(data, 19); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); Logged.put$conversions_Value(other, out); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); Logged.put$conversions_Value(other, out); - const v: rt.Vec = rt.vecFrom([Logged.make$conversions_Value(data, 20), Logged.make$conversions_Value(data, 21)]); + const v: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 20), Logged.make$conversions_Value(data, 21)]); const t: Logged.Logged[] = v.items; - rt.idx(s, 0); - rt.idx(t, 1); - rt.sliceSwapAcross(s, 0, t, 1); - rt.idx(t, 0); - rt.idx(s, 0); - rt.sliceSwapAcross(t, 0, s, 0); - rt.idx(t, 0); + rs.idx(s, 0); + rs.idx(t, 1); + rs.sliceSwapAcross(s, 0, t, 1); + rs.idx(t, 0); + rs.idx(s, 0); + rs.sliceSwapAcross(t, 0, s, 0); + rs.idx(t, 0); Logged.put$conversions_Value(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); Logged.put$conversions_Value(t[1], out); - rt.idx(s, 0); - const a: Logged.Logged[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); + rs.idx(s, 0); + const a: Logged.Logged[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); const _77: Logged.Logged[] = [Logged.make$conversions_Value(data, 22)]; - const _76: Logged.Logged[] = rt.replaceIn(a, _77, 1); + const _76: Logged.Logged[] = rs.replaceIn(a, _77, 1); Logged.put$conversions_Value(_76[0], out); - rt.dropAll(_76); + rs.dropAll(_76); const by: Logged.Logged = Logged.make$conversions_Value(data, 23); - rt.idx(s, 0); + rs.idx(s, 0); let r: Logged.Logged = s[0]; - const _89: Logged.Logged[] = rt.sliceOfPlace(rt.place(() => r, (value2) => r = value2)); + const _89: Logged.Logged[] = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: Logged.Logged[] = [by]; - const _88: Logged.Logged[] = rt.replaceIn(_89, _91); + const _88: Logged.Logged[] = rs.replaceIn(_89, _91); const _93: Logged.Logged = Logged.make$conversions_Value(data, 24); _88[0][Symbol.dispose](); Object.assign(_88[0], _93); Logged.put$conversions_Value(r, out); - rt.idx(s, 0); + rs.idx(s, 0); Logged.put$conversions_Value(s[0], out); - rt.idx(s, 0); - const _104: Logged.Logged = rt.cellReplace(rt.cellIn(s[0]), Logged.make$conversions_Value(data, 25)); + rs.idx(s, 0); + const _104: Logged.Logged = rs.cellReplace(rs.cellIn(s[0]), Logged.make$conversions_Value(data, 25)); Logged.put$conversions_Value(_104, out); _104[Symbol.dispose](); - rt.idx(s, 0); - const old: Logged.Logged = rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value3) => s[0] = value3)), 1), [Logged.make$conversions_Value(data, 26)])[0]; + rs.idx(s, 0); + const old: Logged.Logged = rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value3) => s[0] = value3)), 1), [Logged.make$conversions_Value(data, 26)])[0]; Logged.put$conversions_Value(old, out); - rt.idx(s, 0); - const old2: Logged.Logged = replaceFirst$conversions_Logged(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value4) => s[0] = value4))), [Logged.make$conversions_Value(data, 27)])[0]; + rs.idx(s, 0); + const old2: Logged.Logged = replaceFirst$conversions_Logged(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value4) => s[0] = value4))), [Logged.make$conversions_Value(data, 27)])[0]; Logged.put$conversions_Value(old2, out); - rt.idx(s, 0); - const old3: Logged.Logged = rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value5) => s[0] = value5))), 2), [[Logged.make$conversions_Value(data, 28)]])[0][0]; + rs.idx(s, 0); + const old3: Logged.Logged = rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value5) => s[0] = value5))), 2), [[Logged.make$conversions_Value(data, 28)]])[0][0]; Logged.put$conversions_Value(old3, out); - rt.idx(s, 0); - rt.sliceReplace(s, 0, Logged.clone$Clone(other))[Symbol.dispose](); - rt.idx(s, 0); + rs.idx(s, 0); + rs.sliceReplace(s, 0, Logged.clone$Clone(other))[Symbol.dispose](); + rs.idx(s, 0); Logged.put$conversions_Value(s[0], out); old3[Symbol.dispose](); old2[Symbol.dispose](); old[Symbol.dispose](); by[Symbol.dispose](); - rt.dropVec(v); + rs.dropVec(v); other[Symbol.dispose](); } @@ -1348,51 +1348,51 @@ export function lentParam$conversions_Logged(to: Logged.Logged, data: rt.ByteSli * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$conversions_Named(to: Named.Named, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: Named.Named[] = rt.sliceIn(to); +export function lentParam$conversions_Named(to: Named.Named, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: Named.Named[] = rs.sliceIn(to); Named.put$conversions_Value(writeFirst$conversions_Named(s, Named.make$conversions_Value(data, 18)), out); let other: Named.Named = Named.make$conversions_Value(data, 19); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); Named.put$conversions_Value(other, out); - rt.idx(s, 0); - other = rt.sliceReplace(s, 0, other); + rs.idx(s, 0); + other = rs.sliceReplace(s, 0, other); Named.put$conversions_Value(other, out); - const t: Named.Named[] = rt.vecFrom([Named.make$conversions_Value(data, 20), Named.make$conversions_Value(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); - rt.sliceSwapAcross(s, 0, t, 1); - rt.idx(t, 0); - rt.idx(s, 0); - rt.sliceSwapAcross(t, 0, s, 0); - rt.idx(t, 0); + const t: Named.Named[] = rs.vecFrom([Named.make$conversions_Value(data, 20), Named.make$conversions_Value(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); + rs.sliceSwapAcross(s, 0, t, 1); + rs.idx(t, 0); + rs.idx(s, 0); + rs.sliceSwapAcross(t, 0, s, 0); + rs.idx(t, 0); Named.put$conversions_Value(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); Named.put$conversions_Value(t[1], out); - rt.idx(s, 0); - const a: Named.Named[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); + rs.idx(s, 0); + const a: Named.Named[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); const _77: Named.Named[] = [Named.make$conversions_Value(data, 22)]; - Named.put$conversions_Value(rt.replaceIn(a, _77, 1)[0], out); + Named.put$conversions_Value(rs.replaceIn(a, _77, 1)[0], out); const by: Named.Named = Named.make$conversions_Value(data, 23); - rt.idx(s, 0); + rs.idx(s, 0); let r: Named.Named = s[0]; - const _89: Named.Named[] = rt.sliceOfPlace(rt.place(() => r, (value2) => r = value2)); + const _89: Named.Named[] = rs.sliceOfPlace(rs.place(() => r, (value2) => r = value2)); const _91: Named.Named[] = [by]; - Object.assign(rt.replaceIn(_89, _91)[0], Named.make$conversions_Value(data, 24)); + Object.assign(rs.replaceIn(_89, _91)[0], Named.make$conversions_Value(data, 24)); Named.put$conversions_Value(r, out); - rt.idx(s, 0); + rs.idx(s, 0); Named.put$conversions_Value(s[0], out); - rt.idx(s, 0); - Named.put$conversions_Value(rt.cellReplace(rt.cellIn(s[0]), Named.make$conversions_Value(data, 25)), out); - rt.idx(s, 0); - Named.put$conversions_Value(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value3) => s[0] = value3)), 1), [Named.make$conversions_Value(data, 26)])[0], out); - rt.idx(s, 0); - Named.put$conversions_Value(replaceFirst$conversions_Named(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value4) => s[0] = value4))), [Named.make$conversions_Value(data, 27)])[0], out); - rt.idx(s, 0); - Named.put$conversions_Value(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value5) => s[0] = value5))), 2), [[Named.make$conversions_Value(data, 28)]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + Named.put$conversions_Value(rs.cellReplace(rs.cellIn(s[0]), Named.make$conversions_Value(data, 25)), out); + rs.idx(s, 0); + Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value3) => s[0] = value3)), 1), [Named.make$conversions_Value(data, 26)])[0], out); + rs.idx(s, 0); + Named.put$conversions_Value(replaceFirst$conversions_Named(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value4) => s[0] = value4))), [Named.make$conversions_Value(data, 27)])[0], out); + rs.idx(s, 0); + Named.put$conversions_Value(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value5) => s[0] = value5))), 2), [[Named.make$conversions_Value(data, 28)]])[0][0], out); + rs.idx(s, 0); s[0] = Named.clone$Clone(other); - rt.idx(s, 0); + rs.idx(s, 0); Named.put$conversions_Value(s[0], out); } @@ -1402,59 +1402,59 @@ export function lentParam$conversions_Named(to: Named.Named, data: rt.ByteSlice, * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$u32(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.u32[] = rt.sliceOfPlace(to); +export function lentParam$u32(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.u32[] = rs.sliceOfPlace(to); put$conversions_Value_u32(writeFirst$u32(s, make$conversions_Value_u32(data, 18)), out); - let other: rt.u32 = make$conversions_Value_u32(data, 19); - rt.idx(s, 0); + let other: rs.u32 = make$conversions_Value_u32(data, 19); + rs.idx(s, 0); const swapped = s[0]; s[0] = other; other = swapped; put$conversions_Value_u32(other, out); - rt.idx(s, 0); + rs.idx(s, 0); const swapped2 = other; other = s[0]; s[0] = swapped2; put$conversions_Value_u32(other, out); - const t: rt.u32[] = rt.vecFrom([make$conversions_Value_u32(data, 20), make$conversions_Value_u32(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); + const t: rs.u32[] = rs.vecFrom([make$conversions_Value_u32(data, 20), make$conversions_Value_u32(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); const swapped3 = s[0]; s[0] = t[1]; t[1] = swapped3; - rt.idx(t, 0); - rt.idx(s, 0); + rs.idx(t, 0); + rs.idx(s, 0); const swapped4 = t[0]; t[0] = s[0]; s[0] = swapped4; - rt.idx(t, 0); + rs.idx(t, 0); put$conversions_Value_u32(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_u32(t[1], out); - rt.idx(s, 0); - const a: rt.u32[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: rt.u32[] = [make$conversions_Value_u32(data, 22)]; - put$conversions_Value_u32(rt.replaceIn(a, _77)[0], out); - let by: rt.u32 = make$conversions_Value_u32(data, 23); - rt.idx(s, 0); - let r: rt.Place = rt.place(() => s[0], (value2) => s[0] = value2); - const _89: rt.Place[] = rt.sliceOfPlace(rt.place(() => r, (value3) => r = value3)); - const _91: rt.Place[] = [rt.place(() => by, (value4) => by = value4)]; - rt.replaceIn(_89, _91)[0].v = make$conversions_Value_u32(data, 24); + rs.idx(s, 0); + const a: rs.u32[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: rs.u32[] = [make$conversions_Value_u32(data, 22)]; + put$conversions_Value_u32(rs.replaceIn(a, _77)[0], out); + let by: rs.u32 = make$conversions_Value_u32(data, 23); + rs.idx(s, 0); + let r: rs.Place = rs.place(() => s[0], (value2) => s[0] = value2); + const _89: rs.Place[] = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); + const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; + rs.replaceIn(_89, _91)[0].v = make$conversions_Value_u32(data, 24); put$conversions_Value_u32(r.v, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_u32(s[0], out); - rt.idx(s, 0); - put$conversions_Value_u32(rt.cellReplace(rt.cellOfPlace(rt.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_u32(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_u32(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_u32(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_u32(replaceFirst$u32(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_u32(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_u32(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_u32(data, 28)]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_u32(rs.cellReplace(rs.cellOfPlace(rs.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_u32(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_u32(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_u32(replaceFirst$u32(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_u32(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_u32(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_u32(data, 28)]])[0][0], out); + rs.idx(s, 0); s[0] = other; - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_u32(s[0], out); } @@ -1464,59 +1464,59 @@ export function lentParam$u32(to: rt.Place, data: rt.ByteSlice, out: rt. * another slice's element, as an array, of a reference to it, by a cell, and nested in * arrays, and written in place. */ -export function lentParam$u64(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.u64[] = rt.sliceOfPlace(to); +export function lentParam$u64(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.u64[] = rs.sliceOfPlace(to); put$conversions_Value_u64(writeFirst$u64(s, make$conversions_Value_u64(data, 18)), out); - let other: rt.u64 = make$conversions_Value_u64(data, 19); - rt.idx(s, 0); + let other: rs.u64 = make$conversions_Value_u64(data, 19); + rs.idx(s, 0); const swapped = s[0]; s[0] = other; other = swapped; put$conversions_Value_u64(other, out); - rt.idx(s, 0); + rs.idx(s, 0); const swapped2 = other; other = s[0]; s[0] = swapped2; put$conversions_Value_u64(other, out); - const t: rt.u64[] = rt.vecFrom([make$conversions_Value_u64(data, 20), make$conversions_Value_u64(data, 21)]).items; - rt.idx(s, 0); - rt.idx(t, 1); + const t: rs.u64[] = rs.vecFrom([make$conversions_Value_u64(data, 20), make$conversions_Value_u64(data, 21)]).items; + rs.idx(s, 0); + rs.idx(t, 1); const swapped3 = s[0]; s[0] = t[1]; t[1] = swapped3; - rt.idx(t, 0); - rt.idx(s, 0); + rs.idx(t, 0); + rs.idx(s, 0); const swapped4 = t[0]; t[0] = s[0]; s[0] = swapped4; - rt.idx(t, 0); + rs.idx(t, 0); put$conversions_Value_u64(t[0], out); - rt.idx(t, 1); + rs.idx(t, 1); put$conversions_Value_u64(t[1], out); - rt.idx(s, 0); - const a: rt.u64[] = rt.sliceOfPlace(rt.place(() => s[0], (value) => s[0] = value)); - const _77: rt.u64[] = [make$conversions_Value_u64(data, 22)]; - put$conversions_Value_u64(rt.replaceIn(a, _77)[0], out); - let by: rt.u64 = make$conversions_Value_u64(data, 23); - rt.idx(s, 0); - let r: rt.Place = rt.place(() => s[0], (value2) => s[0] = value2); - const _89: rt.Place[] = rt.sliceOfPlace(rt.place(() => r, (value3) => r = value3)); - const _91: rt.Place[] = [rt.place(() => by, (value4) => by = value4)]; - rt.replaceIn(_89, _91)[0].v = make$conversions_Value_u64(data, 24); + rs.idx(s, 0); + const a: rs.u64[] = rs.sliceOfPlace(rs.place(() => s[0], (value) => s[0] = value)); + const _77: rs.u64[] = [make$conversions_Value_u64(data, 22)]; + put$conversions_Value_u64(rs.replaceIn(a, _77)[0], out); + let by: rs.u64 = make$conversions_Value_u64(data, 23); + rs.idx(s, 0); + let r: rs.Place = rs.place(() => s[0], (value2) => s[0] = value2); + const _89: rs.Place[] = rs.sliceOfPlace(rs.place(() => r, (value3) => r = value3)); + const _91: rs.Place[] = [rs.place(() => by, (value4) => by = value4)]; + rs.replaceIn(_89, _91)[0].v = make$conversions_Value_u64(data, 24); put$conversions_Value_u64(r.v, out); - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_u64(s[0], out); - rt.idx(s, 0); - put$conversions_Value_u64(rt.cellReplace(rt.cellOfPlace(rt.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_u64(data, 25)), out); - rt.idx(s, 0); - put$conversions_Value_u64(rt.cellReplace(rt.cellIn(rt.sliceOfPlace(rt.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_u64(data, 26)])[0], out); - rt.idx(s, 0); - put$conversions_Value_u64(replaceFirst$u64(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_u64(data, 27)])[0], out); - rt.idx(s, 0); - put$conversions_Value_u64(rt.cellReplace(rt.cellIn(rt.sliceIn(rt.sliceOfPlace(rt.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_u64(data, 28)]])[0][0], out); - rt.idx(s, 0); + rs.idx(s, 0); + put$conversions_Value_u64(rs.cellReplace(rs.cellOfPlace(rs.place(() => s[0], (value5) => s[0] = value5)), make$conversions_Value_u64(data, 25)), out); + rs.idx(s, 0); + put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.sliceOfPlace(rs.place(() => s[0], (value6) => s[0] = value6))), [make$conversions_Value_u64(data, 26)])[0], out); + rs.idx(s, 0); + put$conversions_Value_u64(replaceFirst$u64(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value7) => s[0] = value7))), [make$conversions_Value_u64(data, 27)])[0], out); + rs.idx(s, 0); + put$conversions_Value_u64(rs.cellReplace(rs.cellIn(rs.sliceIn(rs.sliceOfPlace(rs.place(() => s[0], (value8) => s[0] = value8))), 1), [[make$conversions_Value_u64(data, 28)]])[0][0], out); + rs.idx(s, 0); s[0] = other; - rt.idx(s, 0); + rs.idx(s, 0); put$conversions_Value_u64(s[0], out); } @@ -1524,195 +1524,195 @@ export function lentParam$u64(to: rt.Place, data: rt.ByteSlice, out: rt. * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); - lentParam$Option_u16(rt.place(() => a, (value) => a = value), data, out); - lentParam$Option_u16(rt.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rt.idx(v.items, 1); - lentParam$Option_u16(rt.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rt.idx(v.items, 0); - let _19: rt.Place = rt.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$Option_u16(rt.place(() => _19, (value5) => _19 = value5), data, out); +export function lentThrough$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); + lentParam$Option_u16(rs.place(() => a, (value) => a = value), data, out); + lentParam$Option_u16(rs.place(() => held.value, (value2) => held.value = value2), data, out); + const at = rs.idx(v.items, 1); + lentParam$Option_u16(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); + const at2 = rs.idx(v.items, 0); + let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); + lentNested$Option_u16(rs.place(() => _19, (value5) => _19 = value5), data, out); put$conversions_Value_Option_u16(a, out); put$conversions_Value_Option_u16(held.value, out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$String(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$String(data: rs.ByteSlice, out: rs.ByteVec): void { let a: string = make$conversions_Value_String(data, 0); const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - lentParam$String(rt.place(() => a, (value) => a = value), data, out); - lentParam$String(rt.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rt.idx(v.items, 1); - lentParam$String(rt.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rt.idx(v.items, 0); - let _19: rt.Place = rt.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$String(rt.place(() => _19, (value5) => _19 = value5), data, out); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + lentParam$String(rs.place(() => a, (value) => a = value), data, out); + lentParam$String(rs.place(() => held.value, (value2) => held.value = value2), data, out); + const at = rs.idx(v.items, 1); + lentParam$String(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); + const at2 = rs.idx(v.items, 0); + let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); + lentNested$String(rs.place(() => _19, (value5) => _19 = value5), data, out); put$conversions_Value_String(a, out); put$conversions_Value_String(held.value, out); - put$conversions_Value_String(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_String(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.Vec = make$conversions_Value_Vec_u32(data, 0); - const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); - const v: rt.Vec> = rt.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); +export function lentThrough$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.Vec = make$conversions_Value_Vec_u32(data, 0); + const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); + const v: rs.Vec> = rs.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); lentParam$Vec_u32(a, data, out); lentParam$Vec_u32(held.value, data, out); - lentParam$Vec_u32(v.items[rt.idx(v.items, 1)], data, out); - let _19: rt.Vec = v.items[rt.idx(v.items, 0)]; - lentNested$Vec_u32(rt.place(() => _19, (value) => _19 = value), data, out); + lentParam$Vec_u32(v.items[rs.idx(v.items, 1)], data, out); + let _19: rs.Vec = v.items[rs.idx(v.items, 0)]; + lentNested$Vec_u32(rs.place(() => _19, (value) => _19 = value), data, out); put$conversions_Value_Vec_u32(a, out); put$conversions_Value_Vec_u32(held.value, out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.ByteVec = make$conversions_Value_Vec_u8(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); +export function lentThrough$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.ByteVec = make$conversions_Value_Vec_u8(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); lentParam$Vec_u8(a, data, out); lentParam$Vec_u8(held.value, data, out); - lentParam$Vec_u8(v.items[rt.idx(v.items, 1)], data, out); - let _19: rt.ByteVec = v.items[rt.idx(v.items, 0)]; - lentNested$Vec_u8(rt.place(() => _19, (value) => _19 = value), data, out); + lentParam$Vec_u8(v.items[rs.idx(v.items, 1)], data, out); + let _19: rs.ByteVec = v.items[rs.idx(v.items, 0)]; + lentNested$Vec_u8(rs.place(() => _19, (value) => _19 = value), data, out); put$conversions_Value_Vec_u8(a, out); put$conversions_Value_Vec_u8(held.value, out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 0)); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array0_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); - lentParam$array0_u8(rt.byteSliceFrom(a), data, out); - lentParam$array0_u8(rt.byteSliceFrom(held.value), data, out); - lentParam$array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), data, out); - let _19: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - lentNested$array0_u8(rt.place(() => _19, (value) => _19 = value), data, out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); + const v: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); + lentParam$array0_u8(rs.byteSliceFrom(a), data, out); + lentParam$array0_u8(rs.byteSliceFrom(held.value), data, out); + lentParam$array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), data, out); + let _19: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + lentNested$array0_u8(rs.place(() => _19, (value) => _19 = value), data, out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 0)); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array1_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); - lentParam$array1_u8(rt.byteSliceFrom(a), data, out); - lentParam$array1_u8(rt.byteSliceFrom(held.value), data, out); - lentParam$array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), data, out); - let _19: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - lentNested$array1_u8(rt.place(() => _19, (value) => _19 = value), data, out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); + const v: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); + lentParam$array1_u8(rs.byteSliceFrom(a), data, out); + lentParam$array1_u8(rs.byteSliceFrom(held.value), data, out); + lentParam$array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), data, out); + let _19: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + lentNested$array1_u8(rs.place(() => _19, (value) => _19 = value), data, out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); - const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); +export function lentThrough$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); + const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); + const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); lentParam$array2_u32(a, data, out); lentParam$array2_u32(held.value, data, out); - lentParam$array2_u32(v.items[rt.idx(v.items, 1)], data, out); - let _19: rt.u32[] = v.items[rt.idx(v.items, 0)]; - lentNested$array2_u32(rt.place(() => _19, (value) => _19 = value), data, out); + lentParam$array2_u32(v.items[rs.idx(v.items, 1)], data, out); + let _19: rs.u32[] = v.items[rs.idx(v.items, 0)]; + lentNested$array2_u32(rs.place(() => _19, (value) => _19 = value), data, out); put$conversions_Value_array2_u32(a, out); put$conversions_Value_array2_u32(held.value, out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 0)); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array3_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); - lentParam$array3_u8(rt.byteSliceFrom(a), data, out); - lentParam$array3_u8(rt.byteSliceFrom(held.value), data, out); - lentParam$array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), data, out); - let _19: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - lentNested$array3_u8(rt.place(() => _19, (value) => _19 = value), data, out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); + const v: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); + lentParam$array3_u8(rs.byteSliceFrom(a), data, out); + lentParam$array3_u8(rs.byteSliceFrom(held.value), data, out); + lentParam$array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), data, out); + let _19: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + lentNested$array3_u8(rs.place(() => _19, (value) => _19 = value), data, out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 0)); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array40_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); - lentParam$array40_u8(rt.byteSliceFrom(a), data, out); - lentParam$array40_u8(rt.byteSliceFrom(held.value), data, out); - lentParam$array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), data, out); - let _19: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - lentNested$array40_u8(rt.place(() => _19, (value) => _19 = value), data, out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); + const v: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); + lentParam$array40_u8(rs.byteSliceFrom(a), data, out); + lentParam$array40_u8(rs.byteSliceFrom(held.value), data, out); + lentParam$array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), data, out); + let _19: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + lentNested$array40_u8(rs.place(() => _19, (value) => _19 = value), data, out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Logged.Logged = Logged.make$conversions_Value(data, 0); const held: Held.Held = new Held.Held(Logged.make$conversions_Value(data, 1)); - const v: rt.Vec = rt.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); + const v: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); lentParam$conversions_Logged(a, data, out); lentParam$conversions_Logged(held.value, data, out); - lentParam$conversions_Logged(v.items[rt.idx(v.items, 1)], data, out); - let _19: Logged.Logged = v.items[rt.idx(v.items, 0)]; - lentNested$conversions_Logged(rt.place(() => _19, (value) => _19 = value), data, out); + lentParam$conversions_Logged(v.items[rs.idx(v.items, 1)], data, out); + let _19: Logged.Logged = v.items[rs.idx(v.items, 0)]; + lentNested$conversions_Logged(rs.place(() => _19, (value) => _19 = value), data, out); Logged.put$conversions_Value(a, out); Logged.put$conversions_Value(held.value, out); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); - rt.dropVec(v); + Logged.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + Logged.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); + rs.dropVec(v); held[Symbol.dispose](); a[Symbol.dispose](); } @@ -1721,275 +1721,275 @@ export function lentThrough$conversions_Logged(data: rt.ByteSlice, out: rt.ByteV * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentThrough$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Named.Named = Named.make$conversions_Value(data, 0); const held: Held.Held = new Held.Held(Named.make$conversions_Value(data, 1)); - const v: rt.Vec = rt.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); + const v: rs.Vec = rs.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); lentParam$conversions_Named(a, data, out); lentParam$conversions_Named(held.value, data, out); - lentParam$conversions_Named(v.items[rt.idx(v.items, 1)], data, out); - let _19: Named.Named = v.items[rt.idx(v.items, 0)]; - lentNested$conversions_Named(rt.place(() => _19, (value) => _19 = value), data, out); + lentParam$conversions_Named(v.items[rs.idx(v.items, 1)], data, out); + let _19: Named.Named = v.items[rs.idx(v.items, 0)]; + lentNested$conversions_Named(rs.place(() => _19, (value) => _19 = value), data, out); Named.put$conversions_Value(a, out); Named.put$conversions_Value(held.value, out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); + Named.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + Named.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u32 = make$conversions_Value_u32(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); - lentParam$u32(rt.place(() => a, (value) => a = value), data, out); - lentParam$u32(rt.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rt.idx(v.items, 1); - lentParam$u32(rt.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rt.idx(v.items, 0); - let _19: rt.Place = rt.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$u32(rt.place(() => _19, (value5) => _19 = value5), data, out); +export function lentThrough$u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u32 = make$conversions_Value_u32(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); + lentParam$u32(rs.place(() => a, (value) => a = value), data, out); + lentParam$u32(rs.place(() => held.value, (value2) => held.value = value2), data, out); + const at = rs.idx(v.items, 1); + lentParam$u32(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); + const at2 = rs.idx(v.items, 0); + let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); + lentNested$u32(rs.place(() => _19, (value5) => _19 = value5), data, out); put$conversions_Value_u32(a, out); put$conversions_Value_u32(held.value, out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_u32(v.items[rs.idx(v.items, 1)], out); } /** * [`lent_param`] of a local, a field, an element, and through a `&mut` to a `&mut`, each * read after. */ -export function lentThrough$u64(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u64 = make$conversions_Value_u64(data, 0); - const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); - lentParam$u64(rt.place(() => a, (value) => a = value), data, out); - lentParam$u64(rt.place(() => held.value, (value2) => held.value = value2), data, out); - const at = rt.idx(v.items, 1); - lentParam$u64(rt.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); - const at2 = rt.idx(v.items, 0); - let _19: rt.Place = rt.place(() => v.items[at2], (value4) => v.items[at2] = value4); - lentNested$u64(rt.place(() => _19, (value5) => _19 = value5), data, out); +export function lentThrough$u64(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u64 = make$conversions_Value_u64(data, 0); + const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); + lentParam$u64(rs.place(() => a, (value) => a = value), data, out); + lentParam$u64(rs.place(() => held.value, (value2) => held.value = value2), data, out); + const at = rs.idx(v.items, 1); + lentParam$u64(rs.place(() => v.items[at], (value3) => v.items[at] = value3), data, out); + const at2 = rs.idx(v.items, 0); + let _19: rs.Place = rs.place(() => v.items[at2], (value4) => v.items[at2] = value4); + lentNested$u64(rs.place(() => _19, (value5) => _19 = value5), data, out); put$conversions_Value_u64(a, out); put$conversions_Value_u64(held.value, out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_u64(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_u64(v.items[rs.idx(v.items, 1)], out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$Option_u16(to: rt.Place>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$Option_u16(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$Option_u16(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$String(to: rt.Place>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$String(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$String(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$Vec_u32(to: rt.Place>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$Vec_u32(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$Vec_u32(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$Vec_u8(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$Vec_u8(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$Vec_u8(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array0_u8(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$array0_u8(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array0_u8(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array1_u8(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$array1_u8(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array1_u8(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array2_u32(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$array2_u32(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array2_u32(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array3_u8(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$array3_u8(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array3_u8(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$array40_u8(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$array40_u8(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$array40_u8(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$conversions_Logged(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$conversions_Logged(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$conversions_Logged(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$conversions_Named(to: rt.Place, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$conversions_Named(to: rs.Place, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$conversions_Named(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$u32(to: rt.Place>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$u32(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$u32(to.v, data, out); } /** [`lent_param`] of what a `&mut` to a `&mut` points at. */ -export function lentNested$u64(to: rt.Place>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentNested$u64(to: rs.Place>, data: rs.ByteSlice, out: rs.ByteVec): void { lentParam$u64(to.v, data, out); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$Option_u16(to: rt.Place, value: rt.u16 | undefined): rt.u16 | undefined { - return rt.cellReplace(rt.cellOfPlace(to), value); +export function setThrough$Option_u16(to: rs.Place, value: rs.u16 | undefined): rs.u16 | undefined { + return rs.cellReplace(rs.cellOfPlace(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$String(to: rt.Place, value: string): string { - return rt.cellReplace(rt.cellOfPlace(to), value); +export function setThrough$String(to: rs.Place, value: string): string { + return rs.cellReplace(rs.cellOfPlace(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$Vec_u32(to: rt.Vec, value: rt.Vec): rt.Vec { - return rt.cellReplace(rt.cellIn(to), value); +export function setThrough$Vec_u32(to: rs.Vec, value: rs.Vec): rs.Vec { + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$Vec_u8(to: rt.ByteVec, value: rt.ByteVec): rt.ByteVec { - return rt.cellReplace(rt.cellIn(to), value); +export function setThrough$Vec_u8(to: rs.ByteVec, value: rs.ByteVec): rs.ByteVec { + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array0_u8(to: rt.ByteSlice, value: Uint8Array): Uint8Array { - return rt.cellReplace(rt.cellIn(rt.byteSliceView(to)), copy$array_u8(value)); +export function setThrough$array0_u8(to: rs.ByteSlice, value: Uint8Array): Uint8Array { + return rs.cellReplace(rs.cellIn(rs.byteSliceView(to)), copy$array_u8(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array1_u8(to: rt.ByteSlice, value: Uint8Array): Uint8Array { - return rt.cellReplace(rt.cellIn(rt.byteSliceView(to)), copy$array_u8(value)); +export function setThrough$array1_u8(to: rs.ByteSlice, value: Uint8Array): Uint8Array { + return rs.cellReplace(rs.cellIn(rs.byteSliceView(to)), copy$array_u8(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array2_u32(to: rt.u32[], value: rt.u32[]): rt.u32[] { - return rt.cellReplace(rt.cellIn(to), copy$array_u32(value)); +export function setThrough$array2_u32(to: rs.u32[], value: rs.u32[]): rs.u32[] { + return rs.cellReplace(rs.cellIn(to), copy$array_u32(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array3_u8(to: rt.ByteSlice, value: Uint8Array): Uint8Array { - return rt.cellReplace(rt.cellIn(rt.byteSliceView(to)), copy$array_u8(value)); +export function setThrough$array3_u8(to: rs.ByteSlice, value: Uint8Array): Uint8Array { + return rs.cellReplace(rs.cellIn(rs.byteSliceView(to)), copy$array_u8(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$array40_u8(to: rt.ByteSlice, value: Uint8Array): Uint8Array { - return rt.cellReplace(rt.cellIn(rt.byteSliceView(to)), copy$array_u8(value)); +export function setThrough$array40_u8(to: rs.ByteSlice, value: Uint8Array): Uint8Array { + return rs.cellReplace(rs.cellIn(rs.byteSliceView(to)), copy$array_u8(value)); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ export function setThrough$conversions_Logged(to: Logged.Logged, value: Logged.Logged): Logged.Logged { - return rt.cellReplace(rt.cellIn(to), value); + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ export function setThrough$conversions_Named(to: Named.Named, value: Named.Named): Named.Named { - return rt.cellReplace(rt.cellIn(to), value); + return rs.cellReplace(rs.cellIn(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$u32(to: rt.Place, value: rt.u32): rt.u32 { - return rt.cellReplace(rt.cellOfPlace(to), value); +export function setThrough$u32(to: rs.Place, value: rs.u32): rs.u32 { + return rs.cellReplace(rs.cellOfPlace(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$u64(to: rt.Place, value: rt.u64): rt.u64 { - return rt.cellReplace(rt.cellOfPlace(to), value); +export function setThrough$u64(to: rs.Place, value: rs.u64): rs.u64 { + return rs.cellReplace(rs.cellOfPlace(to), value); } /** A cell of what a `&mut` whose place only the caller knows points at, written through. */ -export function setThrough$u8(to: rt.Place, value: rt.u8): rt.u8 { - return rt.cellReplace(rt.cellOfPlace(to), value); +export function setThrough$u8(to: rs.Place, value: rs.u8): rs.u8 { + return rs.cellReplace(rs.cellOfPlace(to), value); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 0); - const b: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 3); - const owned: rt.u16 | undefined = a; +export function converted$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 0); + const b: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 3); + const owned: rs.u16 | undefined = a; a = b; put$conversions_Value_Option_u16(owned, out); put$conversions_Value_Option_u16(a, out); - let c: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 6); + let c: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 6); c = owned; put$conversions_Value_Option_u16(c, out); - cloneFromParam$Option_u16(rt.place(() => c, (value) => c = value), b); - cloneIntoParam$Option_u16(owned, rt.place(() => a, (value2) => a = value2)); + cloneFromParam$Option_u16(rs.place(() => c, (value) => c = value), b); + cloneIntoParam$Option_u16(owned, rs.place(() => a, (value2) => a = value2)); put$conversions_Value_Option_u16(c, out); put$conversions_Value_Option_u16(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); + const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); held.value = c; - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); - v.items[rt.idx(v.items, 1)] = held.value; - v.items[rt.idx(v.items, 0)] = b; + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); + v.items[rs.idx(v.items, 1)] = held.value; + v.items[rs.idx(v.items, 0)] = b; put$conversions_Value_Option_u16(held.value, out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 1)], out); - const one: Array = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.u16 | undefined = one[0]; + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 1)], out); + const one: Array = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u16 | undefined = one[0]; put$conversions_Value_Option_u16(one[0], out); a = copied; put$conversions_Value_Option_u16(copied, out); put$conversions_Value_Option_u16(a, out); - const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value3) => c = value3)); - const old: rt.u16 | undefined = rt.cellReplace(cell, make$conversions_Value_Option_u16(data, 10)); - rt.cellSet(cell, make$conversions_Value_Option_u16(data, 11)); + const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); + const old: rs.u16 | undefined = rs.cellReplace(cell, make$conversions_Value_Option_u16(data, 10)); + rs.cellSet(cell, make$conversions_Value_Option_u16(data, 11)); put$conversions_Value_Option_u16(old, out); put$conversions_Value_Option_u16(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 12); - put$conversions_Value_Option_u16(setThrough$Option_u16(rt.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 0)], out); + const at5 = rs.idx(v.items, 0); + const _91: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 12); + put$conversions_Value_Option_u16(setThrough$Option_u16(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 0)], out); const borrowed = held; - rt.cellSet(rt.cellOfPlace(rt.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_Option_u16(data, 17)); + rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_Option_u16(data, 17)); put$conversions_Value_Option_u16(held.value, out); - const array: Array = [make$conversions_Value_Option_u16(data, 13), make$conversions_Value_Option_u16(data, 14), make$conversions_Value_Option_u16(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: Array = [make$conversions_Value_Option_u16(data, 13), make$conversions_Value_Option_u16(data, 14), make$conversions_Value_Option_u16(data, 15)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.u16 | undefined = b; - const _116: Array = array; - rt.idx(_116, 0); + const _114: rs.u16 | undefined = b; + const _116: Array = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: Array = array; - rt.idx(_124, 2); + const _124: Array = array; + rs.idx(_124, 2); _124[2] = c; for (const _134 of array) { put$conversions_Value_Option_u16(_134, out); } - const list: rt.Vec = rt.vecFrom([make$conversions_Value_Option_u16(data, 13), make$conversions_Value_Option_u16(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([make$conversions_Value_Option_u16(data, 13), make$conversions_Value_Option_u16(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.u16 | undefined = b; - const _165: Array = list.items; - rt.idx(_165, 0); + const _163: rs.u16 | undefined = b; + const _165: Array = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: Array = list.items; - rt.idx(_173, 1); + const _173: Array = list.items; + rs.idx(_173, 1); _173[1] = c; - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; - const _186: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 15); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; + const _186: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 15); _184.items.push(_186); none.items.push(a); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.u16 | undefined | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.u16 | undefined | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_Option_u16(_199, out); @@ -2001,7 +2001,7 @@ export function converted$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$String(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$String(data: rs.ByteSlice, out: rs.ByteVec): void { let a: string = make$conversions_Value_String(data, 0); const b: string = make$conversions_Value_String(data, 3); const owned: string = a; @@ -2011,72 +2011,72 @@ export function converted$String(data: rt.ByteSlice, out: rt.ByteVec): void { let c: string = make$conversions_Value_String(data, 6); c = owned; put$conversions_Value_String(c, out); - cloneFromParam$String(rt.place(() => c, (value) => c = value), b); - cloneIntoParam$String(owned, rt.place(() => a, (value2) => a = value2)); + cloneFromParam$String(rs.place(() => c, (value) => c = value), b); + cloneIntoParam$String(owned, rs.place(() => a, (value2) => a = value2)); put$conversions_Value_String(c, out); put$conversions_Value_String(a, out); const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); held.value = c; - const v: rt.Vec = rt.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - v.items[rt.idx(v.items, 1)] = held.value; - v.items[rt.idx(v.items, 0)] = b; + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + v.items[rs.idx(v.items, 1)] = held.value; + v.items[rs.idx(v.items, 0)] = b; put$conversions_Value_String(held.value, out); - put$conversions_Value_String(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_String(v.items[rt.idx(v.items, 1)], out); + put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); const one: string[] = [b]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecPush(out, one.length & 0xff); const copied: string = one[0]; put$conversions_Value_String(one[0], out); a = copied; put$conversions_Value_String(copied, out); put$conversions_Value_String(a, out); - const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value3) => c = value3)); - const old: string = rt.cellReplace(cell, make$conversions_Value_String(data, 10)); - rt.cellSet(cell, make$conversions_Value_String(data, 11)); + const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); + const old: string = rs.cellReplace(cell, make$conversions_Value_String(data, 10)); + rs.cellSet(cell, make$conversions_Value_String(data, 11)); put$conversions_Value_String(old, out); put$conversions_Value_String(c, out); - const at5 = rt.idx(v.items, 0); + const at5 = rs.idx(v.items, 0); const _91: string = make$conversions_Value_String(data, 12); - put$conversions_Value_String(setThrough$String(rt.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); - put$conversions_Value_String(v.items[rt.idx(v.items, 0)], out); + put$conversions_Value_String(setThrough$String(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + put$conversions_Value_String(v.items[rs.idx(v.items, 0)], out); const borrowed = held; - rt.cellSet(rt.cellOfPlace(rt.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_String(data, 17)); + rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_String(data, 17)); put$conversions_Value_String(held.value, out); const array: string[] = [make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14), make$conversions_Value_String(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: string = b; const _116: string[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: string[] = array; - rt.idx(_124, 2); + rs.idx(_124, 2); _124[2] = c; for (const _134 of array) { put$conversions_Value_String(_134, out); } - const list: rt.Vec = rt.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 13), make$conversions_Value_String(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: string = b; const _165: string[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: string[] = list.items; - rt.idx(_173, 1); + rs.idx(_173, 1); _173[1] = c; - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: string = make$conversions_Value_String(data, 15); _184.items.push(_186); none.items.push(a); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: string | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: string | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_String(_199, out); @@ -2088,83 +2088,83 @@ export function converted$String(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.Vec = make$conversions_Value_Vec_u32(data, 0); - const b: rt.Vec = make$conversions_Value_Vec_u32(data, 3); - const owned: rt.Vec = rt.vecFrom(a.items.slice()); - rt.vecCloneFrom(a, b, 4); +export function converted$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.Vec = make$conversions_Value_Vec_u32(data, 0); + const b: rs.Vec = make$conversions_Value_Vec_u32(data, 3); + const owned: rs.Vec = rs.vecFrom(a.items.slice()); + rs.vecCloneFrom(a, b, 4); put$conversions_Value_Vec_u32(owned, out); put$conversions_Value_Vec_u32(a, out); - let c: rt.Vec = make$conversions_Value_Vec_u32(data, 6); - rt.vecCloneFrom(c, owned, 4); + let c: rs.Vec = make$conversions_Value_Vec_u32(data, 6); + rs.vecCloneFrom(c, owned, 4); put$conversions_Value_Vec_u32(c, out); cloneFromParam$Vec_u32(c, b); cloneIntoParam$Vec_u32(owned, a); put$conversions_Value_Vec_u32(c, out); put$conversions_Value_Vec_u32(a, out); - const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); - rt.vecCloneFrom(held.value, c, 4); - const v: rt.Vec> = rt.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); - rt.vecCloneFrom(v.items[rt.idx(v.items, 1)], held.value, 4); - rt.vecCloneFrom(v.items[rt.idx(v.items, 0)], b, 4); + const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); + rs.vecCloneFrom(held.value, c, 4); + const v: rs.Vec> = rs.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); + rs.vecCloneFrom(v.items[rs.idx(v.items, 1)], held.value, 4); + rs.vecCloneFrom(v.items[rs.idx(v.items, 0)], b, 4); put$conversions_Value_Vec_u32(held.value, out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 1)], out); - const one: rt.Vec[] = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.Vec = rt.vecFrom(one[0].items.slice()); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 1)], out); + const one: rs.Vec[] = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.Vec = rs.vecFrom(one[0].items.slice()); put$conversions_Value_Vec_u32(one[0], out); - rt.vecCloneFrom(a, copied, 4); + rs.vecCloneFrom(a, copied, 4); put$conversions_Value_Vec_u32(copied, out); put$conversions_Value_Vec_u32(a, out); - const cell: rt.Cell> = rt.cellIn(c); - const old: rt.Vec = rt.cellReplace(cell, make$conversions_Value_Vec_u32(data, 10)); - rt.cellSet(cell, make$conversions_Value_Vec_u32(data, 11)); + const cell: rs.Cell> = rs.cellIn(c); + const old: rs.Vec = rs.cellReplace(cell, make$conversions_Value_Vec_u32(data, 10)); + rs.cellSet(cell, make$conversions_Value_Vec_u32(data, 11)); put$conversions_Value_Vec_u32(old, out); put$conversions_Value_Vec_u32(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.Vec = make$conversions_Value_Vec_u32(data, 12); + const at5 = rs.idx(v.items, 0); + const _91: rs.Vec = make$conversions_Value_Vec_u32(data, 12); put$conversions_Value_Vec_u32(setThrough$Vec_u32(v.items[at5], _91), out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 0)], out); - rt.cellSet(rt.cellIn(held.value), make$conversions_Value_Vec_u32(data, 17)); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 0)], out); + rs.cellSet(rs.cellIn(held.value), make$conversions_Value_Vec_u32(data, 17)); put$conversions_Value_Vec_u32(held.value, out); - const array: rt.Vec[] = [make$conversions_Value_Vec_u32(data, 13), make$conversions_Value_Vec_u32(data, 14), make$conversions_Value_Vec_u32(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: rs.Vec[] = [make$conversions_Value_Vec_u32(data, 13), make$conversions_Value_Vec_u32(data, 14), make$conversions_Value_Vec_u32(data, 15)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.Vec = rt.vecFrom(b.items.slice()); - const _116: rt.Vec[] = array; - rt.idx(_116, 0); + const _114: rs.Vec = rs.vecFrom(b.items.slice()); + const _116: rs.Vec[] = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: rt.Vec[] = array; - rt.idx(_124, 2); - rt.vecCloneFrom(_124[2], c, 4); + const _124: rs.Vec[] = array; + rs.idx(_124, 2); + rs.vecCloneFrom(_124[2], c, 4); for (const _134 of array) { put$conversions_Value_Vec_u32(_134, out); } - const list: rt.Vec> = rt.vecFrom([make$conversions_Value_Vec_u32(data, 13), make$conversions_Value_Vec_u32(data, 14)]); - const none: rt.Vec> = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec> = rs.vecFrom([make$conversions_Value_Vec_u32(data, 13), make$conversions_Value_Vec_u32(data, 14)]); + const none: rs.Vec> = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.Vec = rt.vecFrom(b.items.slice()); - const _165: rt.Vec[] = list.items; - rt.idx(_165, 0); + const _163: rs.Vec = rs.vecFrom(b.items.slice()); + const _165: rs.Vec[] = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: rt.Vec[] = list.items; - rt.idx(_173, 1); - rt.vecCloneFrom(_173[1], c, 4); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec> = list; - const _186: rt.Vec = make$conversions_Value_Vec_u32(data, 15); + const _173: rs.Vec[] = list.items; + rs.idx(_173, 1); + rs.vecCloneFrom(_173[1], c, 4); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec> = list; + const _186: rs.Vec = make$conversions_Value_Vec_u32(data, 15); _184.items.push(_186); - const _188: rt.Vec> = none; - const _190: rt.Vec = rt.vecFrom(a.items.slice()); + const _188: rs.Vec> = none; + const _190: rs.Vec = rs.vecFrom(a.items.slice()); _188.items.push(_190); - const iter2: rt.Iter> = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter> = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.Vec | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.Vec | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_Vec_u32(_199, out); @@ -2176,83 +2176,83 @@ export function converted$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.ByteVec = make$conversions_Value_Vec_u8(data, 0); - const b: rt.ByteVec = make$conversions_Value_Vec_u8(data, 3); - const owned: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(a)); - rt.byteVecCloneFrom(a, b); +export function converted$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.ByteVec = make$conversions_Value_Vec_u8(data, 0); + const b: rs.ByteVec = make$conversions_Value_Vec_u8(data, 3); + const owned: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(a)); + rs.byteVecCloneFrom(a, b); put$conversions_Value_Vec_u8(owned, out); put$conversions_Value_Vec_u8(a, out); - let c: rt.ByteVec = make$conversions_Value_Vec_u8(data, 6); - rt.byteVecCloneFrom(c, owned); + let c: rs.ByteVec = make$conversions_Value_Vec_u8(data, 6); + rs.byteVecCloneFrom(c, owned); put$conversions_Value_Vec_u8(c, out); cloneFromParam$Vec_u8(c, b); cloneIntoParam$Vec_u8(owned, a); put$conversions_Value_Vec_u8(c, out); put$conversions_Value_Vec_u8(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); - rt.byteVecCloneFrom(held.value, c); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); - rt.byteVecCloneFrom(v.items[rt.idx(v.items, 1)], held.value); - rt.byteVecCloneFrom(v.items[rt.idx(v.items, 0)], b); + const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); + rs.byteVecCloneFrom(held.value, c); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); + rs.byteVecCloneFrom(v.items[rs.idx(v.items, 1)], held.value); + rs.byteVecCloneFrom(v.items[rs.idx(v.items, 0)], b); put$conversions_Value_Vec_u8(held.value, out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 1)], out); - const one: rt.ByteVec[] = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(one[0])); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 1)], out); + const one: rs.ByteVec[] = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(one[0])); put$conversions_Value_Vec_u8(one[0], out); - rt.byteVecCloneFrom(a, copied); + rs.byteVecCloneFrom(a, copied); put$conversions_Value_Vec_u8(copied, out); put$conversions_Value_Vec_u8(a, out); - const cell: rt.Cell = rt.cellIn(c); - const old: rt.ByteVec = rt.cellReplace(cell, make$conversions_Value_Vec_u8(data, 10)); - rt.cellSet(cell, make$conversions_Value_Vec_u8(data, 11)); + const cell: rs.Cell = rs.cellIn(c); + const old: rs.ByteVec = rs.cellReplace(cell, make$conversions_Value_Vec_u8(data, 10)); + rs.cellSet(cell, make$conversions_Value_Vec_u8(data, 11)); put$conversions_Value_Vec_u8(old, out); put$conversions_Value_Vec_u8(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.ByteVec = make$conversions_Value_Vec_u8(data, 12); + const at5 = rs.idx(v.items, 0); + const _91: rs.ByteVec = make$conversions_Value_Vec_u8(data, 12); put$conversions_Value_Vec_u8(setThrough$Vec_u8(v.items[at5], _91), out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 0)], out); - rt.cellSet(rt.cellIn(held.value), make$conversions_Value_Vec_u8(data, 17)); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 0)], out); + rs.cellSet(rs.cellIn(held.value), make$conversions_Value_Vec_u8(data, 17)); put$conversions_Value_Vec_u8(held.value, out); - const array: rt.ByteVec[] = [make$conversions_Value_Vec_u8(data, 13), make$conversions_Value_Vec_u8(data, 14), make$conversions_Value_Vec_u8(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: rs.ByteVec[] = [make$conversions_Value_Vec_u8(data, 13), make$conversions_Value_Vec_u8(data, 14), make$conversions_Value_Vec_u8(data, 15)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(b)); - const _116: rt.ByteVec[] = array; - rt.idx(_116, 0); + const _114: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(b)); + const _116: rs.ByteVec[] = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: rt.ByteVec[] = array; - rt.idx(_124, 2); - rt.byteVecCloneFrom(_124[2], c); + const _124: rs.ByteVec[] = array; + rs.idx(_124, 2); + rs.byteVecCloneFrom(_124[2], c); for (const _134 of array) { put$conversions_Value_Vec_u8(_134, out); } - const list: rt.Vec = rt.vecFrom([make$conversions_Value_Vec_u8(data, 13), make$conversions_Value_Vec_u8(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([make$conversions_Value_Vec_u8(data, 13), make$conversions_Value_Vec_u8(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(b)); - const _165: rt.ByteVec[] = list.items; - rt.idx(_165, 0); + const _163: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(b)); + const _165: rs.ByteVec[] = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: rt.ByteVec[] = list.items; - rt.idx(_173, 1); - rt.byteVecCloneFrom(_173[1], c); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; - const _186: rt.ByteVec = make$conversions_Value_Vec_u8(data, 15); + const _173: rs.ByteVec[] = list.items; + rs.idx(_173, 1); + rs.byteVecCloneFrom(_173[1], c); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; + const _186: rs.ByteVec = make$conversions_Value_Vec_u8(data, 15); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(a)); + const _188: rs.Vec = none; + const _190: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(a)); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.ByteVec | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.ByteVec | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_Vec_u8(_199, out); @@ -2264,530 +2264,530 @@ export function converted$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 0)); const b: Uint8Array = make$conversions_Value_array0_u8(data, 3); - const owned: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(a)); - const _8: rt.ByteSlice = rt.byteSliceFrom(a); - const _9: rt.ByteSlice = rt.byteSliceFrom(b); - _8.data.set(rt.byteSliceToArray(_9), _8.start); - put$conversions_Value_array0_u8(rt.byteSliceFrom(owned), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); + const owned: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(a)); + const _8: rs.ByteSlice = rs.byteSliceFrom(a); + const _9: rs.ByteSlice = rs.byteSliceFrom(b); + _8.data.set(rs.byteSliceToArray(_9), _8.start); + put$conversions_Value_array0_u8(rs.byteSliceFrom(owned), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); const c: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 6)); - const _16: rt.ByteSlice = rt.byteSliceFrom(owned); - const _17: rt.ByteSlice = rt.byteSliceFrom(c); - _17.data.set(rt.byteSliceToArray(_16), _17.start); - put$conversions_Value_array0_u8(rt.byteSliceFrom(c), out); - cloneFromParam$array0_u8(rt.byteSliceFrom(c), rt.byteSliceFrom(b)); - cloneIntoParam$array0_u8(rt.byteSliceFrom(owned), rt.byteSliceFrom(a)); - put$conversions_Value_array0_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); + const _16: rs.ByteSlice = rs.byteSliceFrom(owned); + const _17: rs.ByteSlice = rs.byteSliceFrom(c); + _17.data.set(rs.byteSliceToArray(_16), _17.start); + put$conversions_Value_array0_u8(rs.byteSliceFrom(c), out); + cloneFromParam$array0_u8(rs.byteSliceFrom(c), rs.byteSliceFrom(b)); + cloneIntoParam$array0_u8(rs.byteSliceFrom(owned), rs.byteSliceFrom(a)); + put$conversions_Value_array0_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array0_u8(data, 1))); - const _33: rt.ByteSlice = rt.byteSliceFrom(held.value); - const _34: rt.ByteSlice = rt.byteSliceFrom(c); - _33.data.set(rt.byteSliceToArray(_34), _33.start); - const v: rt.Vec = rt.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); - const _40: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]); - const _42: rt.ByteSlice = rt.byteSliceFrom(held.value); - _40.data.set(rt.byteSliceToArray(_42), _40.start); - const _44: rt.ByteSlice = rt.byteSliceFrom(b); - const _45: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - _45.data.set(rt.byteSliceToArray(_44), _45.start); - put$conversions_Value_array0_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - rt.byteVecPush(out, one.length & 0xff); - const copied: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(one[0])); - put$conversions_Value_array0_u8(rt.byteSliceFrom(one[0]), out); - const _70: rt.ByteSlice = rt.byteSliceFrom(a); - const _71: rt.ByteSlice = rt.byteSliceFrom(copied); - _70.data.set(rt.byteSliceToArray(_71), _70.start); - put$conversions_Value_array0_u8(rt.byteSliceFrom(copied), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); - const cell: rt.Cell = rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(c))); - const old: Uint8Array = rt.cellReplace(cell, copy$array_u8(make$conversions_Value_array0_u8(data, 10))); - rt.cellSet(cell, copy$array_u8(make$conversions_Value_array0_u8(data, 11))); - put$conversions_Value_array0_u8(rt.byteSliceFrom(old), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(setThrough$array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), make$conversions_Value_array0_u8(data, 12))), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - rt.cellSet(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array0_u8(data, 17))); - put$conversions_Value_array0_u8(rt.byteSliceFrom(held.value), out); + const _33: rs.ByteSlice = rs.byteSliceFrom(held.value); + const _34: rs.ByteSlice = rs.byteSliceFrom(c); + _33.data.set(rs.byteSliceToArray(_34), _33.start); + const v: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); + const _40: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]); + const _42: rs.ByteSlice = rs.byteSliceFrom(held.value); + _40.data.set(rs.byteSliceToArray(_42), _40.start); + const _44: rs.ByteSlice = rs.byteSliceFrom(b); + const _45: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + _45.data.set(rs.byteSliceToArray(_44), _45.start); + put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); + put$conversions_Value_array0_u8(rs.byteSliceFrom(one[0]), out); + const _70: rs.ByteSlice = rs.byteSliceFrom(a); + const _71: rs.ByteSlice = rs.byteSliceFrom(copied); + _70.data.set(rs.byteSliceToArray(_71), _70.start); + put$conversions_Value_array0_u8(rs.byteSliceFrom(copied), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); + const cell: rs.Cell = rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(c))); + const old: Uint8Array = rs.cellReplace(cell, copy$array_u8(make$conversions_Value_array0_u8(data, 10))); + rs.cellSet(cell, copy$array_u8(make$conversions_Value_array0_u8(data, 11))); + put$conversions_Value_array0_u8(rs.byteSliceFrom(old), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(setThrough$array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), make$conversions_Value_array0_u8(data, 12))), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array0_u8(data, 17))); + put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array0_u8(data, 13)), copy$array_u8(make$conversions_Value_array0_u8(data, 14)), copy$array_u8(make$conversions_Value_array0_u8(data, 15))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _116: Uint8Array[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: Uint8Array[] = array; - rt.idx(_124, 2); - const _123: rt.ByteSlice = rt.byteSliceFrom(_124[2]); - const _130: rt.ByteSlice = rt.byteSliceFrom(c); - _123.data.set(rt.byteSliceToArray(_130), _123.start); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(array), rt.byteSliceFrom); + rs.idx(_124, 2); + const _123: rs.ByteSlice = rs.byteSliceFrom(_124[2]); + const _130: rs.ByteSlice = rs.byteSliceFrom(c); + _123.data.set(rs.byteSliceToArray(_130), _123.start); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); while (true) { - const _134: rt.ByteSlice | rt.Done = iter.next(); - if (_134 === rt.DONE) { + const _134: rs.ByteSlice | rs.Done = iter.next(); + if (_134 === rs.DONE) { break; } put$conversions_Value_array0_u8(_134, out); } - const list: rt.Vec = rt.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 13), make$conversions_Value_array0_u8(data, 14)]).map(copy$array_u8)); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 13), make$conversions_Value_array0_u8(data, 14)]).map(copy$array_u8)); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: Uint8Array[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: Uint8Array[] = list.items; - rt.idx(_173, 1); - const _172: rt.ByteSlice = rt.byteSliceFrom(_173[1]); - const _179: rt.ByteSlice = rt.byteSliceFrom(c); - _172.data.set(rt.byteSliceToArray(_179), _172.start); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.idx(_173, 1); + const _172: rs.ByteSlice = rs.byteSliceFrom(_173[1]); + const _179: rs.ByteSlice = rs.byteSliceFrom(c); + _172.data.set(rs.byteSliceToArray(_179), _172.start); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 15)); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(a))); + const _188: rs.Vec = none; + const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(list.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(none.items), rt.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { - const _199: rt.ByteSlice | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.ByteSlice | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_array0_u8(_199, out); } boxed$array0_u8(data, out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))), out); - rt.byteSliceFrom(c); + put$conversions_Value_array0_u8(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))), out); + rs.byteSliceFrom(c); copy$array_u8(make$conversions_Value_array0_u8(data, 16)); - put$conversions_Value_array0_u8(rt.byteSliceFrom(c), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(c), out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 0)); const b: Uint8Array = make$conversions_Value_array1_u8(data, 3); - const owned: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(a)); - const _8: rt.ByteSlice = rt.byteSliceFrom(a); - const _9: rt.ByteSlice = rt.byteSliceFrom(b); - _8.data.set(rt.byteSliceToArray(_9), _8.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(owned), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); + const owned: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(a)); + const _8: rs.ByteSlice = rs.byteSliceFrom(a); + const _9: rs.ByteSlice = rs.byteSliceFrom(b); + _8.data.set(rs.byteSliceToArray(_9), _8.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(owned), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); const c: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 6)); - const _16: rt.ByteSlice = rt.byteSliceFrom(owned); - const _17: rt.ByteSlice = rt.byteSliceFrom(c); - _17.data.set(rt.byteSliceToArray(_16), _17.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(c), out); - cloneFromParam$array1_u8(rt.byteSliceFrom(c), rt.byteSliceFrom(b)); - cloneIntoParam$array1_u8(rt.byteSliceFrom(owned), rt.byteSliceFrom(a)); - put$conversions_Value_array1_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); + const _16: rs.ByteSlice = rs.byteSliceFrom(owned); + const _17: rs.ByteSlice = rs.byteSliceFrom(c); + _17.data.set(rs.byteSliceToArray(_16), _17.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(c), out); + cloneFromParam$array1_u8(rs.byteSliceFrom(c), rs.byteSliceFrom(b)); + cloneIntoParam$array1_u8(rs.byteSliceFrom(owned), rs.byteSliceFrom(a)); + put$conversions_Value_array1_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array1_u8(data, 1))); - const _33: rt.ByteSlice = rt.byteSliceFrom(held.value); - const _34: rt.ByteSlice = rt.byteSliceFrom(c); - _33.data.set(rt.byteSliceToArray(_34), _33.start); - const v: rt.Vec = rt.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); - const _40: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]); - const _42: rt.ByteSlice = rt.byteSliceFrom(held.value); - _40.data.set(rt.byteSliceToArray(_42), _40.start); - const _44: rt.ByteSlice = rt.byteSliceFrom(b); - const _45: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - _45.data.set(rt.byteSliceToArray(_44), _45.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - rt.byteVecPush(out, one.length & 0xff); - const copied: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(one[0])); - put$conversions_Value_array1_u8(rt.byteSliceFrom(one[0]), out); - const _70: rt.ByteSlice = rt.byteSliceFrom(a); - const _71: rt.ByteSlice = rt.byteSliceFrom(copied); - _70.data.set(rt.byteSliceToArray(_71), _70.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(copied), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); - const cell: rt.Cell = rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(c))); - const old: Uint8Array = rt.cellReplace(cell, copy$array_u8(make$conversions_Value_array1_u8(data, 10))); - rt.cellSet(cell, copy$array_u8(make$conversions_Value_array1_u8(data, 11))); - put$conversions_Value_array1_u8(rt.byteSliceFrom(old), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(setThrough$array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), make$conversions_Value_array1_u8(data, 12))), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - rt.cellSet(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array1_u8(data, 17))); - put$conversions_Value_array1_u8(rt.byteSliceFrom(held.value), out); + const _33: rs.ByteSlice = rs.byteSliceFrom(held.value); + const _34: rs.ByteSlice = rs.byteSliceFrom(c); + _33.data.set(rs.byteSliceToArray(_34), _33.start); + const v: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); + const _40: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]); + const _42: rs.ByteSlice = rs.byteSliceFrom(held.value); + _40.data.set(rs.byteSliceToArray(_42), _40.start); + const _44: rs.ByteSlice = rs.byteSliceFrom(b); + const _45: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + _45.data.set(rs.byteSliceToArray(_44), _45.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); + put$conversions_Value_array1_u8(rs.byteSliceFrom(one[0]), out); + const _70: rs.ByteSlice = rs.byteSliceFrom(a); + const _71: rs.ByteSlice = rs.byteSliceFrom(copied); + _70.data.set(rs.byteSliceToArray(_71), _70.start); + put$conversions_Value_array1_u8(rs.byteSliceFrom(copied), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); + const cell: rs.Cell = rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(c))); + const old: Uint8Array = rs.cellReplace(cell, copy$array_u8(make$conversions_Value_array1_u8(data, 10))); + rs.cellSet(cell, copy$array_u8(make$conversions_Value_array1_u8(data, 11))); + put$conversions_Value_array1_u8(rs.byteSliceFrom(old), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(setThrough$array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), make$conversions_Value_array1_u8(data, 12))), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array1_u8(data, 17))); + put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 13)), copy$array_u8(make$conversions_Value_array1_u8(data, 14)), copy$array_u8(make$conversions_Value_array1_u8(data, 15))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _116: Uint8Array[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: Uint8Array[] = array; - rt.idx(_124, 2); - const _123: rt.ByteSlice = rt.byteSliceFrom(_124[2]); - const _130: rt.ByteSlice = rt.byteSliceFrom(c); - _123.data.set(rt.byteSliceToArray(_130), _123.start); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(array), rt.byteSliceFrom); + rs.idx(_124, 2); + const _123: rs.ByteSlice = rs.byteSliceFrom(_124[2]); + const _130: rs.ByteSlice = rs.byteSliceFrom(c); + _123.data.set(rs.byteSliceToArray(_130), _123.start); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); while (true) { - const _134: rt.ByteSlice | rt.Done = iter.next(); - if (_134 === rt.DONE) { + const _134: rs.ByteSlice | rs.Done = iter.next(); + if (_134 === rs.DONE) { break; } put$conversions_Value_array1_u8(_134, out); } - const list: rt.Vec = rt.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 13), make$conversions_Value_array1_u8(data, 14)]).map(copy$array_u8)); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 13), make$conversions_Value_array1_u8(data, 14)]).map(copy$array_u8)); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: Uint8Array[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: Uint8Array[] = list.items; - rt.idx(_173, 1); - const _172: rt.ByteSlice = rt.byteSliceFrom(_173[1]); - const _179: rt.ByteSlice = rt.byteSliceFrom(c); - _172.data.set(rt.byteSliceToArray(_179), _172.start); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.idx(_173, 1); + const _172: rs.ByteSlice = rs.byteSliceFrom(_173[1]); + const _179: rs.ByteSlice = rs.byteSliceFrom(c); + _172.data.set(rs.byteSliceToArray(_179), _172.start); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 15)); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(a))); + const _188: rs.Vec = none; + const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(list.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(none.items), rt.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { - const _199: rt.ByteSlice | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.ByteSlice | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_array1_u8(_199, out); } boxed$array1_u8(data, out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))), out); - const q: rt.ByteSlice = rt.byteSliceFrom(c); + put$conversions_Value_array1_u8(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))), out); + const q: rs.ByteSlice = rs.byteSliceFrom(c); const _211: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 16)); q.data.set(_211, q.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(c), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(c), out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); - const b: rt.u32[] = make$conversions_Value_array2_u32(data, 3); - const owned: rt.u32[] = copy$array_u32(a); +export function converted$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 0)); + const b: rs.u32[] = make$conversions_Value_array2_u32(data, 3); + const owned: rs.u32[] = copy$array_u32(a); a = copy$array_u32(b); put$conversions_Value_array2_u32(owned, out); put$conversions_Value_array2_u32(a, out); - let c: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 6)); + let c: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 6)); c = copy$array_u32(owned); put$conversions_Value_array2_u32(c, out); cloneFromParam$array2_u32(c, b); cloneIntoParam$array2_u32(owned, a); put$conversions_Value_array2_u32(c, out); put$conversions_Value_array2_u32(a, out); - const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); + const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); held.value = copy$array_u32(c); - const v: rt.Vec = rt.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); - v.items[rt.idx(v.items, 1)] = copy$array_u32(held.value); - v.items[rt.idx(v.items, 0)] = copy$array_u32(b); + const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); + v.items[rs.idx(v.items, 1)] = copy$array_u32(held.value); + v.items[rs.idx(v.items, 0)] = copy$array_u32(b); put$conversions_Value_array2_u32(held.value, out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 1)], out); - const one: rt.u32[][] = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.u32[] = copy$array_u32(one[0]); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); + const one: rs.u32[][] = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u32[] = copy$array_u32(one[0]); put$conversions_Value_array2_u32(one[0], out); a = copy$array_u32(copied); put$conversions_Value_array2_u32(copied, out); put$conversions_Value_array2_u32(a, out); - const cell: rt.Cell = rt.cellIn(c); - const old: rt.u32[] = rt.cellReplace(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 10))); - rt.cellSet(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 11))); + const cell: rs.Cell = rs.cellIn(c); + const old: rs.u32[] = rs.cellReplace(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 10))); + rs.cellSet(cell, copy$array_u32(make$conversions_Value_array2_u32(data, 11))); put$conversions_Value_array2_u32(old, out); put$conversions_Value_array2_u32(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.u32[] = make$conversions_Value_array2_u32(data, 12); + const at5 = rs.idx(v.items, 0); + const _91: rs.u32[] = make$conversions_Value_array2_u32(data, 12); put$conversions_Value_array2_u32(setThrough$array2_u32(v.items[at5], _91), out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 0)], out); - rt.cellSet(rt.cellIn(held.value), copy$array_u32(make$conversions_Value_array2_u32(data, 17))); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 0)], out); + rs.cellSet(rs.cellIn(held.value), copy$array_u32(make$conversions_Value_array2_u32(data, 17))); put$conversions_Value_array2_u32(held.value, out); - const array: rt.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 13)), copy$array_u32(make$conversions_Value_array2_u32(data, 14)), copy$array_u32(make$conversions_Value_array2_u32(data, 15))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 13)), copy$array_u32(make$conversions_Value_array2_u32(data, 14)), copy$array_u32(make$conversions_Value_array2_u32(data, 15))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.u32[] = copy$array_u32(copy$array_u32(b)); - const _116: rt.u32[][] = array; - rt.idx(_116, 0); + const _114: rs.u32[] = copy$array_u32(copy$array_u32(b)); + const _116: rs.u32[][] = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: rt.u32[][] = array; - rt.idx(_124, 2); + const _124: rs.u32[][] = array; + rs.idx(_124, 2); _124[2] = copy$array_u32(c); for (const _134 of array) { put$conversions_Value_array2_u32(_134, out); } - const list: rt.Vec = rt.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 13), make$conversions_Value_array2_u32(data, 14)]).map(copy$array_u32)); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 13), make$conversions_Value_array2_u32(data, 14)]).map(copy$array_u32)); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.u32[] = copy$array_u32(copy$array_u32(b)); - const _165: rt.u32[][] = list.items; - rt.idx(_165, 0); + const _163: rs.u32[] = copy$array_u32(copy$array_u32(b)); + const _165: rs.u32[][] = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: rt.u32[][] = list.items; - rt.idx(_173, 1); + const _173: rs.u32[][] = list.items; + rs.idx(_173, 1); _173[1] = copy$array_u32(c); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; - const _186: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 15)); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; + const _186: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 15)); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: rt.u32[] = copy$array_u32(copy$array_u32(a)); + const _188: rs.Vec = none; + const _190: rs.u32[] = copy$array_u32(copy$array_u32(a)); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.u32[] | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.u32[] | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_array2_u32(_199, out); } boxed$array2_u32(data, out); put$conversions_Value_array2_u32(b, out); - rt.ptrWrite(c, copy$array_u32(make$conversions_Value_array2_u32(data, 16))); + rs.ptrWrite(c, copy$array_u32(make$conversions_Value_array2_u32(data, 16))); put$conversions_Value_array2_u32(c, out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 0)); const b: Uint8Array = make$conversions_Value_array3_u8(data, 3); - const owned: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(a)); - const _8: rt.ByteSlice = rt.byteSliceFrom(a); - const _9: rt.ByteSlice = rt.byteSliceFrom(b); - _8.data.set(rt.byteSliceToArray(_9), _8.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(owned), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); + const owned: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(a)); + const _8: rs.ByteSlice = rs.byteSliceFrom(a); + const _9: rs.ByteSlice = rs.byteSliceFrom(b); + _8.data.set(rs.byteSliceToArray(_9), _8.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(owned), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); const c: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 6)); - const _16: rt.ByteSlice = rt.byteSliceFrom(owned); - const _17: rt.ByteSlice = rt.byteSliceFrom(c); - _17.data.set(rt.byteSliceToArray(_16), _17.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(c), out); - cloneFromParam$array3_u8(rt.byteSliceFrom(c), rt.byteSliceFrom(b)); - cloneIntoParam$array3_u8(rt.byteSliceFrom(owned), rt.byteSliceFrom(a)); - put$conversions_Value_array3_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); + const _16: rs.ByteSlice = rs.byteSliceFrom(owned); + const _17: rs.ByteSlice = rs.byteSliceFrom(c); + _17.data.set(rs.byteSliceToArray(_16), _17.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(c), out); + cloneFromParam$array3_u8(rs.byteSliceFrom(c), rs.byteSliceFrom(b)); + cloneIntoParam$array3_u8(rs.byteSliceFrom(owned), rs.byteSliceFrom(a)); + put$conversions_Value_array3_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array3_u8(data, 1))); - const _33: rt.ByteSlice = rt.byteSliceFrom(held.value); - const _34: rt.ByteSlice = rt.byteSliceFrom(c); - _33.data.set(rt.byteSliceToArray(_34), _33.start); - const v: rt.Vec = rt.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); - const _40: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]); - const _42: rt.ByteSlice = rt.byteSliceFrom(held.value); - _40.data.set(rt.byteSliceToArray(_42), _40.start); - const _44: rt.ByteSlice = rt.byteSliceFrom(b); - const _45: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - _45.data.set(rt.byteSliceToArray(_44), _45.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - rt.byteVecPush(out, one.length & 0xff); - const copied: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(one[0])); - put$conversions_Value_array3_u8(rt.byteSliceFrom(one[0]), out); - const _70: rt.ByteSlice = rt.byteSliceFrom(a); - const _71: rt.ByteSlice = rt.byteSliceFrom(copied); - _70.data.set(rt.byteSliceToArray(_71), _70.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(copied), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); - const cell: rt.Cell = rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(c))); - const old: Uint8Array = rt.cellReplace(cell, copy$array_u8(make$conversions_Value_array3_u8(data, 10))); - rt.cellSet(cell, copy$array_u8(make$conversions_Value_array3_u8(data, 11))); - put$conversions_Value_array3_u8(rt.byteSliceFrom(old), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(setThrough$array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), make$conversions_Value_array3_u8(data, 12))), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - rt.cellSet(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array3_u8(data, 17))); - put$conversions_Value_array3_u8(rt.byteSliceFrom(held.value), out); + const _33: rs.ByteSlice = rs.byteSliceFrom(held.value); + const _34: rs.ByteSlice = rs.byteSliceFrom(c); + _33.data.set(rs.byteSliceToArray(_34), _33.start); + const v: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); + const _40: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]); + const _42: rs.ByteSlice = rs.byteSliceFrom(held.value); + _40.data.set(rs.byteSliceToArray(_42), _40.start); + const _44: rs.ByteSlice = rs.byteSliceFrom(b); + const _45: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + _45.data.set(rs.byteSliceToArray(_44), _45.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); + put$conversions_Value_array3_u8(rs.byteSliceFrom(one[0]), out); + const _70: rs.ByteSlice = rs.byteSliceFrom(a); + const _71: rs.ByteSlice = rs.byteSliceFrom(copied); + _70.data.set(rs.byteSliceToArray(_71), _70.start); + put$conversions_Value_array3_u8(rs.byteSliceFrom(copied), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); + const cell: rs.Cell = rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(c))); + const old: Uint8Array = rs.cellReplace(cell, copy$array_u8(make$conversions_Value_array3_u8(data, 10))); + rs.cellSet(cell, copy$array_u8(make$conversions_Value_array3_u8(data, 11))); + put$conversions_Value_array3_u8(rs.byteSliceFrom(old), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(setThrough$array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), make$conversions_Value_array3_u8(data, 12))), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array3_u8(data, 17))); + put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 13)), copy$array_u8(make$conversions_Value_array3_u8(data, 14)), copy$array_u8(make$conversions_Value_array3_u8(data, 15))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _116: Uint8Array[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: Uint8Array[] = array; - rt.idx(_124, 2); - const _123: rt.ByteSlice = rt.byteSliceFrom(_124[2]); - const _130: rt.ByteSlice = rt.byteSliceFrom(c); - _123.data.set(rt.byteSliceToArray(_130), _123.start); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(array), rt.byteSliceFrom); + rs.idx(_124, 2); + const _123: rs.ByteSlice = rs.byteSliceFrom(_124[2]); + const _130: rs.ByteSlice = rs.byteSliceFrom(c); + _123.data.set(rs.byteSliceToArray(_130), _123.start); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); while (true) { - const _134: rt.ByteSlice | rt.Done = iter.next(); - if (_134 === rt.DONE) { + const _134: rs.ByteSlice | rs.Done = iter.next(); + if (_134 === rs.DONE) { break; } put$conversions_Value_array3_u8(_134, out); } - const list: rt.Vec = rt.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 13), make$conversions_Value_array3_u8(data, 14)]).map(copy$array_u8)); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 13), make$conversions_Value_array3_u8(data, 14)]).map(copy$array_u8)); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: Uint8Array[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: Uint8Array[] = list.items; - rt.idx(_173, 1); - const _172: rt.ByteSlice = rt.byteSliceFrom(_173[1]); - const _179: rt.ByteSlice = rt.byteSliceFrom(c); - _172.data.set(rt.byteSliceToArray(_179), _172.start); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.idx(_173, 1); + const _172: rs.ByteSlice = rs.byteSliceFrom(_173[1]); + const _179: rs.ByteSlice = rs.byteSliceFrom(c); + _172.data.set(rs.byteSliceToArray(_179), _172.start); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 15)); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(a))); + const _188: rs.Vec = none; + const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(list.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(none.items), rt.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { - const _199: rt.ByteSlice | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.ByteSlice | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_array3_u8(_199, out); } boxed$array3_u8(data, out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))), out); - const q: rt.ByteSlice = rt.byteSliceFrom(c); + put$conversions_Value_array3_u8(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))), out); + const q: rs.ByteSlice = rs.byteSliceFrom(c); const _211: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 16)); q.data.set(_211, q.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(c), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(c), out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const a: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 0)); const b: Uint8Array = make$conversions_Value_array40_u8(data, 3); - const owned: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(a)); - const _8: rt.ByteSlice = rt.byteSliceFrom(a); - const _9: rt.ByteSlice = rt.byteSliceFrom(b); - _8.data.set(rt.byteSliceToArray(_9), _8.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(owned), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); + const owned: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(a)); + const _8: rs.ByteSlice = rs.byteSliceFrom(a); + const _9: rs.ByteSlice = rs.byteSliceFrom(b); + _8.data.set(rs.byteSliceToArray(_9), _8.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(owned), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); const c: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 6)); - const _16: rt.ByteSlice = rt.byteSliceFrom(owned); - const _17: rt.ByteSlice = rt.byteSliceFrom(c); - _17.data.set(rt.byteSliceToArray(_16), _17.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(c), out); - cloneFromParam$array40_u8(rt.byteSliceFrom(c), rt.byteSliceFrom(b)); - cloneIntoParam$array40_u8(rt.byteSliceFrom(owned), rt.byteSliceFrom(a)); - put$conversions_Value_array40_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); + const _16: rs.ByteSlice = rs.byteSliceFrom(owned); + const _17: rs.ByteSlice = rs.byteSliceFrom(c); + _17.data.set(rs.byteSliceToArray(_16), _17.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(c), out); + cloneFromParam$array40_u8(rs.byteSliceFrom(c), rs.byteSliceFrom(b)); + cloneIntoParam$array40_u8(rs.byteSliceFrom(owned), rs.byteSliceFrom(a)); + put$conversions_Value_array40_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array40_u8(data, 1))); - const _33: rt.ByteSlice = rt.byteSliceFrom(held.value); - const _34: rt.ByteSlice = rt.byteSliceFrom(c); - _33.data.set(rt.byteSliceToArray(_34), _33.start); - const v: rt.Vec = rt.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); - const _40: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]); - const _42: rt.ByteSlice = rt.byteSliceFrom(held.value); - _40.data.set(rt.byteSliceToArray(_42), _40.start); - const _44: rt.ByteSlice = rt.byteSliceFrom(b); - const _45: rt.ByteSlice = rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]); - _45.data.set(rt.byteSliceToArray(_44), _45.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - const one: Uint8Array[] = [rt.byteSliceView(rt.byteSliceFrom(b))]; - rt.byteVecPush(out, one.length & 0xff); - const copied: Uint8Array = rt.byteSliceToArray(rt.byteSliceFrom(one[0])); - put$conversions_Value_array40_u8(rt.byteSliceFrom(one[0]), out); - const _70: rt.ByteSlice = rt.byteSliceFrom(a); - const _71: rt.ByteSlice = rt.byteSliceFrom(copied); - _70.data.set(rt.byteSliceToArray(_71), _70.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(copied), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); - const cell: rt.Cell = rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(c))); - const old: Uint8Array = rt.cellReplace(cell, copy$array_u8(make$conversions_Value_array40_u8(data, 10))); - rt.cellSet(cell, copy$array_u8(make$conversions_Value_array40_u8(data, 11))); - put$conversions_Value_array40_u8(rt.byteSliceFrom(old), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(setThrough$array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), make$conversions_Value_array40_u8(data, 12))), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 0)]), out); - rt.cellSet(rt.cellIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array40_u8(data, 17))); - put$conversions_Value_array40_u8(rt.byteSliceFrom(held.value), out); + const _33: rs.ByteSlice = rs.byteSliceFrom(held.value); + const _34: rs.ByteSlice = rs.byteSliceFrom(c); + _33.data.set(rs.byteSliceToArray(_34), _33.start); + const v: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); + const _40: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]); + const _42: rs.ByteSlice = rs.byteSliceFrom(held.value); + _40.data.set(rs.byteSliceToArray(_42), _40.start); + const _44: rs.ByteSlice = rs.byteSliceFrom(b); + const _45: rs.ByteSlice = rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]); + _45.data.set(rs.byteSliceToArray(_44), _45.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + const one: Uint8Array[] = [rs.byteSliceView(rs.byteSliceFrom(b))]; + rs.byteVecPush(out, one.length & 0xff); + const copied: Uint8Array = rs.byteSliceToArray(rs.byteSliceFrom(one[0])); + put$conversions_Value_array40_u8(rs.byteSliceFrom(one[0]), out); + const _70: rs.ByteSlice = rs.byteSliceFrom(a); + const _71: rs.ByteSlice = rs.byteSliceFrom(copied); + _70.data.set(rs.byteSliceToArray(_71), _70.start); + put$conversions_Value_array40_u8(rs.byteSliceFrom(copied), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); + const cell: rs.Cell = rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(c))); + const old: Uint8Array = rs.cellReplace(cell, copy$array_u8(make$conversions_Value_array40_u8(data, 10))); + rs.cellSet(cell, copy$array_u8(make$conversions_Value_array40_u8(data, 11))); + put$conversions_Value_array40_u8(rs.byteSliceFrom(old), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(setThrough$array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), make$conversions_Value_array40_u8(data, 12))), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 0)]), out); + rs.cellSet(rs.cellIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), copy$array_u8(make$conversions_Value_array40_u8(data, 17))); + put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); const array: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 13)), copy$array_u8(make$conversions_Value_array40_u8(data, 14)), copy$array_u8(make$conversions_Value_array40_u8(data, 15))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _114: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _116: Uint8Array[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: Uint8Array[] = array; - rt.idx(_124, 2); - const _123: rt.ByteSlice = rt.byteSliceFrom(_124[2]); - const _130: rt.ByteSlice = rt.byteSliceFrom(c); - _123.data.set(rt.byteSliceToArray(_130), _123.start); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(array), rt.byteSliceFrom); + rs.idx(_124, 2); + const _123: rs.ByteSlice = rs.byteSliceFrom(_124[2]); + const _130: rs.ByteSlice = rs.byteSliceFrom(c); + _123.data.set(rs.byteSliceToArray(_130), _123.start); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(array), rs.byteSliceFrom); while (true) { - const _134: rt.ByteSlice | rt.Done = iter.next(); - if (_134 === rt.DONE) { + const _134: rs.ByteSlice | rs.Done = iter.next(); + if (_134 === rs.DONE) { break; } put$conversions_Value_array40_u8(_134, out); } - const list: rt.Vec = rt.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 13), make$conversions_Value_array40_u8(data, 14)]).map(copy$array_u8)); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 13), make$conversions_Value_array40_u8(data, 14)]).map(copy$array_u8)); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))); + const _163: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))); const _165: Uint8Array[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: Uint8Array[] = list.items; - rt.idx(_173, 1); - const _172: rt.ByteSlice = rt.byteSliceFrom(_173[1]); - const _179: rt.ByteSlice = rt.byteSliceFrom(c); - _172.data.set(rt.byteSliceToArray(_179), _172.start); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.idx(_173, 1); + const _172: rs.ByteSlice = rs.byteSliceFrom(_173[1]); + const _179: rs.ByteSlice = rs.byteSliceFrom(c); + _172.data.set(rs.byteSliceToArray(_179), _172.start); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 15)); _184.items.push(_186); - const _188: rt.Vec = none; - const _190: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(a))); + const _188: rs.Vec = none; + const _190: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(a))); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(list.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(none.items), rt.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(list.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(none.items), rs.byteSliceFrom)); while (true) { - const _199: rt.ByteSlice | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.ByteSlice | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_array40_u8(_199, out); } boxed$array40_u8(data, out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(b))), out); - const q: rt.ByteSlice = rt.byteSliceFrom(c); + put$conversions_Value_array40_u8(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(b))), out); + const q: rs.ByteSlice = rs.byteSliceFrom(c); const _211: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 16)); q.data.set(_211, q.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(c), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(c), out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): void { let a: Logged.Logged = Logged.make$conversions_Value(data, 0); const b: Logged.Logged = Logged.make$conversions_Value(data, 3); const owned: Logged.Logged = Logged.clone$Clone(a); @@ -2809,20 +2809,20 @@ export function converted$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec const old4 = held.value; held.value = Logged.clone$Clone(c); old4[Symbol.dispose](); - const v: rt.Vec = rt.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); - const at = rt.idx(v.items, 1); + const v: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); + const at = rs.idx(v.items, 1); const old5 = v.items[at]; v.items[at] = Logged.clone$Clone(held.value); old5[Symbol.dispose](); - const at2 = rt.idx(v.items, 0); + const at2 = rs.idx(v.items, 0); const old6 = v.items[at2]; v.items[at2] = Logged.clone$Clone(b); old6[Symbol.dispose](); Logged.put$conversions_Value(held.value, out); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); + Logged.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + Logged.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); const one: Logged.Logged[] = [b]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecPush(out, one.length & 0xff); const copied: Logged.Logged = Logged.clone$Clone(one[0]); Logged.put$conversions_Value(one[0], out); const old7 = a; @@ -2830,58 +2830,58 @@ export function converted$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec old7[Symbol.dispose](); Logged.put$conversions_Value(copied, out); Logged.put$conversions_Value(a, out); - const cell: rt.Cell = rt.cellIn(c); - const old: Logged.Logged = rt.cellReplace(cell, Logged.make$conversions_Value(data, 10)); - rt.cellSet(cell, Logged.make$conversions_Value(data, 11), rt.drop); + const cell: rs.Cell = rs.cellIn(c); + const old: Logged.Logged = rs.cellReplace(cell, Logged.make$conversions_Value(data, 10)); + rs.cellSet(cell, Logged.make$conversions_Value(data, 11), rs.drop); Logged.put$conversions_Value(old, out); Logged.put$conversions_Value(c, out); - const at5 = rt.idx(v.items, 0); + const at5 = rs.idx(v.items, 0); const _91: Logged.Logged = Logged.make$conversions_Value(data, 12); const _88: Logged.Logged = setThrough$conversions_Logged(v.items[at5], _91); Logged.put$conversions_Value(_88, out); _88[Symbol.dispose](); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - rt.cellSet(rt.cellIn(held.value), Logged.make$conversions_Value(data, 17), rt.drop); + Logged.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + rs.cellSet(rs.cellIn(held.value), Logged.make$conversions_Value(data, 17), rs.drop); Logged.put$conversions_Value(held.value, out); const array: Logged.Logged[] = [Logged.make$conversions_Value(data, 13), Logged.make$conversions_Value(data, 14), Logged.make$conversions_Value(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Logged.Logged = Logged.clone$Clone(b); const _116: Logged.Logged[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0][Symbol.dispose](); _116[0] = _114; const _124: Logged.Logged[] = array; - rt.idx(_124, 2); - rt.sliceReplace(_124, 2, Logged.clone$Clone(c))[Symbol.dispose](); + rs.idx(_124, 2); + rs.sliceReplace(_124, 2, Logged.clone$Clone(c))[Symbol.dispose](); for (const _134 of array) { Logged.put$conversions_Value(_134, out); } - const list: rt.Vec = rt.vecFrom([Logged.make$conversions_Value(data, 13), Logged.make$conversions_Value(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 13), Logged.make$conversions_Value(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Logged.Logged = Logged.clone$Clone(b); const _165: Logged.Logged[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0][Symbol.dispose](); _165[0] = _163; const _173: Logged.Logged[] = list.items; - rt.idx(_173, 1); - rt.sliceReplace(_173, 1, Logged.clone$Clone(c))[Symbol.dispose](); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.idx(_173, 1); + rs.sliceReplace(_173, 1, Logged.clone$Clone(c))[Symbol.dispose](); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Logged.Logged = Logged.make$conversions_Value(data, 15); _184.items.push(_186); - const _188: rt.Vec = none; + const _188: rs.Vec = none; const _190: Logged.Logged = Logged.clone$Clone(a); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: Logged.Logged | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: Logged.Logged | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } Logged.put$conversions_Value(_199, out); @@ -2891,14 +2891,14 @@ export function converted$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec const q: Logged.Logged = c; const _211: Logged.Logged = Logged.make$conversions_Value(data, 16); q[Symbol.dispose](); - rt.ptrWrite(q, _211); + rs.ptrWrite(q, _211); Logged.put$conversions_Value(c, out); - rt.dropVec(none); - rt.dropVec(list); - rt.dropAll(array); + rs.dropVec(none); + rs.dropVec(list); + rs.dropAll(array); old[Symbol.dispose](); copied[Symbol.dispose](); - rt.dropVec(v); + rs.dropVec(v); held[Symbol.dispose](); c[Symbol.dispose](); owned[Symbol.dispose](); @@ -2907,7 +2907,7 @@ export function converted$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { +export function converted$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { let a: Named.Named = Named.make$conversions_Value(data, 0); const b: Named.Named = Named.make$conversions_Value(data, 3); const owned: Named.Named = Named.clone$Clone(a); @@ -2923,154 +2923,154 @@ export function converted$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec) Named.put$conversions_Value(a, out); const held: Held.Held = new Held.Held(Named.make$conversions_Value(data, 1)); held.value = Named.clone$Clone(c); - const v: rt.Vec = rt.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); - v.items[rt.idx(v.items, 1)] = Named.clone$Clone(held.value); - v.items[rt.idx(v.items, 0)] = Named.clone$Clone(b); + const v: rs.Vec = rs.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); + v.items[rs.idx(v.items, 1)] = Named.clone$Clone(held.value); + v.items[rs.idx(v.items, 0)] = Named.clone$Clone(b); Named.put$conversions_Value(held.value, out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); + Named.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + Named.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); const one: Named.Named[] = [b]; - rt.byteVecPush(out, one.length & 0xff); + rs.byteVecPush(out, one.length & 0xff); const copied: Named.Named = Named.clone$Clone(one[0]); Named.put$conversions_Value(one[0], out); a = Named.clone$Clone(copied); Named.put$conversions_Value(copied, out); Named.put$conversions_Value(a, out); - const cell: rt.Cell = rt.cellIn(c); - const old: Named.Named = rt.cellReplace(cell, Named.make$conversions_Value(data, 10)); - rt.cellSet(cell, Named.make$conversions_Value(data, 11)); + const cell: rs.Cell = rs.cellIn(c); + const old: Named.Named = rs.cellReplace(cell, Named.make$conversions_Value(data, 10)); + rs.cellSet(cell, Named.make$conversions_Value(data, 11)); Named.put$conversions_Value(old, out); Named.put$conversions_Value(c, out); - const at5 = rt.idx(v.items, 0); + const at5 = rs.idx(v.items, 0); const _91: Named.Named = Named.make$conversions_Value(data, 12); Named.put$conversions_Value(setThrough$conversions_Named(v.items[at5], _91), out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 0)], out); - rt.cellSet(rt.cellIn(held.value), Named.make$conversions_Value(data, 17)); + Named.put$conversions_Value(v.items[rs.idx(v.items, 0)], out); + rs.cellSet(rs.cellIn(held.value), Named.make$conversions_Value(data, 17)); Named.put$conversions_Value(held.value, out); const array: Named.Named[] = [Named.make$conversions_Value(data, 13), Named.make$conversions_Value(data, 14), Named.make$conversions_Value(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); const _114: Named.Named = Named.clone$Clone(b); const _116: Named.Named[] = array; - rt.idx(_116, 0); + rs.idx(_116, 0); _116[0] = _114; const _124: Named.Named[] = array; - rt.idx(_124, 2); + rs.idx(_124, 2); _124[2] = Named.clone$Clone(c); for (const _134 of array) { Named.put$conversions_Value(_134, out); } - const list: rt.Vec = rt.vecFrom([Named.make$conversions_Value(data, 13), Named.make$conversions_Value(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([Named.make$conversions_Value(data, 13), Named.make$conversions_Value(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); const _163: Named.Named = Named.clone$Clone(b); const _165: Named.Named[] = list.items; - rt.idx(_165, 0); + rs.idx(_165, 0); _165[0] = _163; const _173: Named.Named[] = list.items; - rt.idx(_173, 1); + rs.idx(_173, 1); _173[1] = Named.clone$Clone(c); - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; const _186: Named.Named = Named.make$conversions_Value(data, 15); _184.items.push(_186); - const _188: rt.Vec = none; + const _188: rs.Vec = none; const _190: Named.Named = Named.clone$Clone(a); _188.items.push(_190); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: Named.Named | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: Named.Named | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } Named.put$conversions_Value(_199, out); } boxed$conversions_Named(data, out); Named.put$conversions_Value(b, out); - rt.ptrWrite(c, Named.make$conversions_Value(data, 16)); + rs.ptrWrite(c, Named.make$conversions_Value(data, 16)); Named.put$conversions_Value(c, out); } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u32 = make$conversions_Value_u32(data, 0); - const b: rt.u32 = make$conversions_Value_u32(data, 3); - const owned: rt.u32 = a; +export function converted$u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u32 = make$conversions_Value_u32(data, 0); + const b: rs.u32 = make$conversions_Value_u32(data, 3); + const owned: rs.u32 = a; a = b; put$conversions_Value_u32(owned, out); put$conversions_Value_u32(a, out); - let c: rt.u32 = make$conversions_Value_u32(data, 6); + let c: rs.u32 = make$conversions_Value_u32(data, 6); c = owned; put$conversions_Value_u32(c, out); - cloneFromParam$u32(rt.place(() => c, (value) => c = value), b); - cloneIntoParam$u32(owned, rt.place(() => a, (value2) => a = value2)); + cloneFromParam$u32(rs.place(() => c, (value) => c = value), b); + cloneIntoParam$u32(owned, rs.place(() => a, (value2) => a = value2)); put$conversions_Value_u32(c, out); put$conversions_Value_u32(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); + const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); held.value = c; - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); - v.items[rt.idx(v.items, 1)] = held.value; - v.items[rt.idx(v.items, 0)] = b; + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); + v.items[rs.idx(v.items, 1)] = held.value; + v.items[rs.idx(v.items, 0)] = b; put$conversions_Value_u32(held.value, out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 1)], out); - const one: rt.u32[] = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.u32 = one[0]; + put$conversions_Value_u32(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_u32(v.items[rs.idx(v.items, 1)], out); + const one: rs.u32[] = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u32 = one[0]; put$conversions_Value_u32(one[0], out); a = copied; put$conversions_Value_u32(copied, out); put$conversions_Value_u32(a, out); - const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value3) => c = value3)); - const old: rt.u32 = rt.cellReplace(cell, make$conversions_Value_u32(data, 10)); - rt.cellSet(cell, make$conversions_Value_u32(data, 11)); + const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); + const old: rs.u32 = rs.cellReplace(cell, make$conversions_Value_u32(data, 10)); + rs.cellSet(cell, make$conversions_Value_u32(data, 11)); put$conversions_Value_u32(old, out); put$conversions_Value_u32(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.u32 = make$conversions_Value_u32(data, 12); - put$conversions_Value_u32(setThrough$u32(rt.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 0)], out); + const at5 = rs.idx(v.items, 0); + const _91: rs.u32 = make$conversions_Value_u32(data, 12); + put$conversions_Value_u32(setThrough$u32(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + put$conversions_Value_u32(v.items[rs.idx(v.items, 0)], out); const borrowed = held; - rt.cellSet(rt.cellOfPlace(rt.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u32(data, 17)); + rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u32(data, 17)); put$conversions_Value_u32(held.value, out); - const array: rt.u32[] = [make$conversions_Value_u32(data, 13), make$conversions_Value_u32(data, 14), make$conversions_Value_u32(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: rs.u32[] = [make$conversions_Value_u32(data, 13), make$conversions_Value_u32(data, 14), make$conversions_Value_u32(data, 15)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.u32 = b; - const _116: rt.u32[] = array; - rt.idx(_116, 0); + const _114: rs.u32 = b; + const _116: rs.u32[] = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: rt.u32[] = array; - rt.idx(_124, 2); + const _124: rs.u32[] = array; + rs.idx(_124, 2); _124[2] = c; for (const _134 of array) { put$conversions_Value_u32(_134, out); } - const list: rt.Vec = rt.vecFrom([make$conversions_Value_u32(data, 13), make$conversions_Value_u32(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([make$conversions_Value_u32(data, 13), make$conversions_Value_u32(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.u32 = b; - const _165: rt.u32[] = list.items; - rt.idx(_165, 0); + const _163: rs.u32 = b; + const _165: rs.u32[] = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: rt.u32[] = list.items; - rt.idx(_173, 1); + const _173: rs.u32[] = list.items; + rs.idx(_173, 1); _173[1] = c; - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; - const _186: rt.u32 = make$conversions_Value_u32(data, 15); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; + const _186: rs.u32 = make$conversions_Value_u32(data, 15); _184.items.push(_186); none.items.push(a); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.u32 | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.u32 | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_u32(_199, out); @@ -3082,82 +3082,82 @@ export function converted$u32(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$u64(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u64 = make$conversions_Value_u64(data, 0); - const b: rt.u64 = make$conversions_Value_u64(data, 3); - const owned: rt.u64 = a; +export function converted$u64(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u64 = make$conversions_Value_u64(data, 0); + const b: rs.u64 = make$conversions_Value_u64(data, 3); + const owned: rs.u64 = a; a = b; put$conversions_Value_u64(owned, out); put$conversions_Value_u64(a, out); - let c: rt.u64 = make$conversions_Value_u64(data, 6); + let c: rs.u64 = make$conversions_Value_u64(data, 6); c = owned; put$conversions_Value_u64(c, out); - cloneFromParam$u64(rt.place(() => c, (value) => c = value), b); - cloneIntoParam$u64(owned, rt.place(() => a, (value2) => a = value2)); + cloneFromParam$u64(rs.place(() => c, (value) => c = value), b); + cloneIntoParam$u64(owned, rs.place(() => a, (value2) => a = value2)); put$conversions_Value_u64(c, out); put$conversions_Value_u64(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); + const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); held.value = c; - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); - v.items[rt.idx(v.items, 1)] = held.value; - v.items[rt.idx(v.items, 0)] = b; + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); + v.items[rs.idx(v.items, 1)] = held.value; + v.items[rs.idx(v.items, 0)] = b; put$conversions_Value_u64(held.value, out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 0)], out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 1)], out); - const one: rt.u64[] = [b]; - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.u64 = one[0]; + put$conversions_Value_u64(v.items[rs.idx(v.items, 0)], out); + put$conversions_Value_u64(v.items[rs.idx(v.items, 1)], out); + const one: rs.u64[] = [b]; + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u64 = one[0]; put$conversions_Value_u64(one[0], out); a = copied; put$conversions_Value_u64(copied, out); put$conversions_Value_u64(a, out); - const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value3) => c = value3)); - const old: rt.u64 = rt.cellReplace(cell, make$conversions_Value_u64(data, 10)); - rt.cellSet(cell, make$conversions_Value_u64(data, 11)); + const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); + const old: rs.u64 = rs.cellReplace(cell, make$conversions_Value_u64(data, 10)); + rs.cellSet(cell, make$conversions_Value_u64(data, 11)); put$conversions_Value_u64(old, out); put$conversions_Value_u64(c, out); - const at5 = rt.idx(v.items, 0); - const _91: rt.u64 = make$conversions_Value_u64(data, 12); - put$conversions_Value_u64(setThrough$u64(rt.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 0)], out); + const at5 = rs.idx(v.items, 0); + const _91: rs.u64 = make$conversions_Value_u64(data, 12); + put$conversions_Value_u64(setThrough$u64(rs.place(() => v.items[at5], (value4) => v.items[at5] = value4), _91), out); + put$conversions_Value_u64(v.items[rs.idx(v.items, 0)], out); const borrowed = held; - rt.cellSet(rt.cellOfPlace(rt.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u64(data, 17)); + rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u64(data, 17)); put$conversions_Value_u64(held.value, out); - const array: rt.u64[] = [make$conversions_Value_u64(data, 13), make$conversions_Value_u64(data, 14), make$conversions_Value_u64(data, 15)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([array.length, array.length], (n: rt.usize): rt.u8 => { + const array: rs.u64[] = [make$conversions_Value_u64(data, 13), make$conversions_Value_u64(data, 14), make$conversions_Value_u64(data, 15)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([array.length, array.length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.u64 = b; - const _116: rt.u64[] = array; - rt.idx(_116, 0); + const _114: rs.u64 = b; + const _116: rs.u64[] = array; + rs.idx(_116, 0); _116[0] = _114; - const _124: rt.u64[] = array; - rt.idx(_124, 2); + const _124: rs.u64[] = array; + rs.idx(_124, 2); _124[2] = c; for (const _134 of array) { put$conversions_Value_u64(_134, out); } - const list: rt.Vec = rt.vecFrom([make$conversions_Value_u64(data, 13), make$conversions_Value_u64(data, 14)]); - const none: rt.Vec = new rt.Vec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rt.usize): rt.u8 => { + const list: rs.Vec = rs.vecFrom([make$conversions_Value_u64(data, 13), make$conversions_Value_u64(data, 14)]); + const none: rs.Vec = new rs.Vec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([list.items.length, list.items.length, none.items.length, none.items.length, list.items.length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.u64 = b; - const _165: rt.u64[] = list.items; - rt.idx(_165, 0); + const _163: rs.u64 = b; + const _165: rs.u64[] = list.items; + rs.idx(_165, 0); _165[0] = _163; - const _173: rt.u64[] = list.items; - rt.idx(_173, 1); + const _173: rs.u64[] = list.items; + rs.idx(_173, 1); _173[1] = c; - rt.sliceSwap(list.items, 0, 1); - const _184: rt.Vec = list; - const _186: rt.u64 = make$conversions_Value_u64(data, 15); + rs.sliceSwap(list.items, 0, 1); + const _184: rs.Vec = list; + const _186: rs.u64 = make$conversions_Value_u64(data, 15); _184.items.push(_186); none.items.push(a); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(list.items), rt.iterSlice(none.items)); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(list.items), rs.iterSlice(none.items)); while (true) { - const _199: rt.u64 | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.u64 | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_u64(_199, out); @@ -3169,80 +3169,80 @@ export function converted$u64(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Each conversion of a `T`, its copies put after a write to what they copied. */ -export function converted$u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let a: rt.u8 = make$conversions_Value_u8(data, 0); - const b: rt.u8 = make$conversions_Value_u8(data, 3); - const owned: rt.u8 = a; +export function converted$u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let a: rs.u8 = make$conversions_Value_u8(data, 0); + const b: rs.u8 = make$conversions_Value_u8(data, 3); + const owned: rs.u8 = a; a = b; put$conversions_Value_u8(owned, out); put$conversions_Value_u8(a, out); - let c: rt.u8 = make$conversions_Value_u8(data, 6); + let c: rs.u8 = make$conversions_Value_u8(data, 6); c = owned; put$conversions_Value_u8(c, out); - cloneFromParam$u8(rt.place(() => c, (value) => c = value), b); - cloneIntoParam$u8(owned, rt.place(() => a, (value2) => a = value2)); + cloneFromParam$u8(rs.place(() => c, (value) => c = value), b); + cloneIntoParam$u8(owned, rs.place(() => a, (value2) => a = value2)); put$conversions_Value_u8(c, out); put$conversions_Value_u8(a, out); - const held: Held.Held = new Held.Held(make$conversions_Value_u8(data, 1)); + const held: Held.Held = new Held.Held(make$conversions_Value_u8(data, 1)); held.value = c; - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(make$conversions_Value_u8(data, 2), make$conversions_Value_u8(data, 4))); - v.data[rt.idx(v, 1)] = held.value; - v.data[rt.idx(v, 0)] = b; + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(make$conversions_Value_u8(data, 2), make$conversions_Value_u8(data, 4))); + v.data[rs.idx(v, 1)] = held.value; + v.data[rs.idx(v, 0)] = b; put$conversions_Value_u8(held.value, out); - put$conversions_Value_u8(v.data[rt.idx(v, 0)], out); - put$conversions_Value_u8(v.data[rt.idx(v, 1)], out); - const one: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(b)); - rt.byteVecPush(out, one.length & 0xff); - const copied: rt.u8 = one.data[one.start]; + put$conversions_Value_u8(v.data[rs.idx(v, 0)], out); + put$conversions_Value_u8(v.data[rs.idx(v, 1)], out); + const one: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(b)); + rs.byteVecPush(out, one.length & 0xff); + const copied: rs.u8 = one.data[one.start]; put$conversions_Value_u8(one.data[one.start], out); a = copied; put$conversions_Value_u8(copied, out); put$conversions_Value_u8(a, out); - const cell: rt.Cell = rt.cellOfPlace(rt.place(() => c, (value3) => c = value3)); - const old: rt.u8 = rt.cellReplace(cell, make$conversions_Value_u8(data, 10)); - rt.cellSet(cell, make$conversions_Value_u8(data, 11)); + const cell: rs.Cell = rs.cellOfPlace(rs.place(() => c, (value3) => c = value3)); + const old: rs.u8 = rs.cellReplace(cell, make$conversions_Value_u8(data, 10)); + rs.cellSet(cell, make$conversions_Value_u8(data, 11)); put$conversions_Value_u8(old, out); put$conversions_Value_u8(c, out); - const at5 = rt.idx(v, 0); - const _91: rt.u8 = make$conversions_Value_u8(data, 12); - put$conversions_Value_u8(setThrough$u8(rt.place(() => v.data[at5], (value4) => v.data[at5] = value4), _91), out); - put$conversions_Value_u8(v.data[rt.idx(v, 0)], out); + const at5 = rs.idx(v, 0); + const _91: rs.u8 = make$conversions_Value_u8(data, 12); + put$conversions_Value_u8(setThrough$u8(rs.place(() => v.data[at5], (value4) => v.data[at5] = value4), _91), out); + put$conversions_Value_u8(v.data[rs.idx(v, 0)], out); const borrowed = held; - rt.cellSet(rt.cellOfPlace(rt.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u8(data, 17)); + rs.cellSet(rs.cellOfPlace(rs.place(() => borrowed.value, (value5) => borrowed.value = value5)), make$conversions_Value_u8(data, 17)); put$conversions_Value_u8(held.value, out); const array: Uint8Array = Uint8Array.of(make$conversions_Value_u8(data, 13), make$conversions_Value_u8(data, 14), make$conversions_Value_u8(data, 15)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.byteSliceFrom(array).length, rt.byteSliceFrom(array).length], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.byteSliceFrom(array).length, rs.byteSliceFrom(array).length], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _114: rt.u8 = b; - const _116: rt.ByteSlice = rt.byteSliceFrom(array); - rt.idx(_116, 0); + const _114: rs.u8 = b; + const _116: rs.ByteSlice = rs.byteSliceFrom(array); + rs.idx(_116, 0); _116.data[_116.start] = _114; - const _124: rt.ByteSlice = rt.byteSliceFrom(array); - rt.idx(_124, 2); + const _124: rs.ByteSlice = rs.byteSliceFrom(array); + rs.idx(_124, 2); _124.data[_124.start + 2] = c; - for (const _134 of rt.byteSliceView(rt.byteSliceFrom(array))) { + for (const _134 of rs.byteSliceView(rs.byteSliceFrom(array))) { put$conversions_Value_u8(_134, out); } - const list: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(make$conversions_Value_u8(data, 13), make$conversions_Value_u8(data, 14))); - const none: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.byteVecSlice(list).length, list.length, rt.byteVecSlice(none).length, rt.byteVecSlice(none).length, rt.byteVecSlice(list).length], (n2: rt.usize): rt.u8 => { + const list: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(make$conversions_Value_u8(data, 13), make$conversions_Value_u8(data, 14))); + const none: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.byteVecSlice(list).length, list.length, rs.byteVecSlice(none).length, rs.byteVecSlice(none).length, rs.byteVecSlice(list).length], (n2: rs.usize): rs.u8 => { return n2 & 0xff; })), undefined, true); - const _163: rt.u8 = b; - const _165: rt.ByteSlice = rt.byteVecSlice(list); - rt.idx(_165, 0); + const _163: rs.u8 = b; + const _165: rs.ByteSlice = rs.byteVecSlice(list); + rs.idx(_165, 0); _165.data[_165.start] = _163; - const _173: rt.ByteSlice = rt.byteVecSlice(list); - rt.idx(_173, 1); + const _173: rs.ByteSlice = rs.byteVecSlice(list); + rs.idx(_173, 1); _173.data[_173.start + 1] = c; - rt.byteSliceSwap(rt.byteVecSlice(list), 0, 1); - rt.byteVecPush(list, make$conversions_Value_u8(data, 15)); - rt.byteVecPush(none, a); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(list))), rt.iterSlice(rt.byteVecView(none))); + rs.byteSliceSwap(rs.byteVecSlice(list), 0, 1); + rs.byteVecPush(list, make$conversions_Value_u8(data, 15)); + rs.byteVecPush(none, a); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(list))), rs.iterSlice(rs.byteVecView(none))); while (true) { - const _199: rt.u8 | rt.Done = iter2.next(); - if (_199 === rt.DONE) { + const _199: rs.u8 | rs.Done = iter2.next(); + if (_199 === rs.DONE) { break; } put$conversions_Value_u8(_199, out); @@ -3257,47 +3257,47 @@ export function converted$u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 19); +export function boxed$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 19); boxed = make$conversions_Value_Option_u16(data, 3); put$conversions_Value_Option_u16(boxed, out); - const source: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 20); + const source: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 20); boxed = source; put$conversions_Value_Option_u16(boxed, out); put$conversions_Value_Option_u16(source, out); - let nested: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 21); - nested = ((a0: rt.u16 | undefined): rt.u16 | undefined => { + let nested: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 21); + nested = ((a0: rs.u16 | undefined): rs.u16 | undefined => { return a0; })(source); put$conversions_Value_Option_u16(nested, out); - let maybe = make$conversions_Value_Option_u16(data, 22) as rt.u16 | undefined | rt.None; - maybe = option_clone$08xidb9(boxed as rt.u16 | undefined | rt.None); - maybe = option_clone$08xidb9(rt.None); - rt.byteVecPush(out, maybe === rt.None ? 1 : 0); - maybe = option_clone$08xidb9(source as rt.u16 | undefined | rt.None); - rt.iterForEach(rt.iterOption(maybe, undefined, rt.None), (x: rt.u16 | undefined): undefined => { + let maybe = make$conversions_Value_Option_u16(data, 22) as rs.u16 | undefined | rs.None; + maybe = option_clone$0wpatp7(boxed as rs.u16 | undefined | rs.None); + maybe = option_clone$0wpatp7(rs.None); + rs.byteVecPush(out, maybe === rs.None ? 1 : 0); + maybe = option_clone$0wpatp7(source as rs.u16 | undefined | rs.None); + rs.iterForEach(rs.iterOption(maybe, undefined, rs.None), (x: rs.u16 | undefined): undefined => { put$conversions_Value_Option_u16(x, out); }); - const slots: Array = [make$conversions_Value_Option_u16(data, 23), make$conversions_Value_Option_u16(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: rt.u16 | undefined): rt.u16 | undefined => { + const slots: Array = [make$conversions_Value_Option_u16(data, 23), make$conversions_Value_Option_u16(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: rs.u16 | undefined): rs.u16 | undefined => { return a02; }); for (const _73 of slots) { put$conversions_Value_Option_u16(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Array = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u16 | undefined => { - return make$conversions_Value_Option_u16(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Array = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u16 | undefined => { + return make$conversions_Value_Option_u16(data, rs.usizeAdd(26, i)); }), undefined, 4, true).items; - let into: Array = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.u16 | undefined => { - return make$conversions_Value_Option_u16(data, rt.usizeAdd(29, i2)); + let into: Array = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u16 | undefined => { + return make$conversions_Value_Option_u16(data, rs.usizeAdd(29, i2)); }), undefined, 4, true).items; - into = rt.boxSliceCloneFrom(into, whole); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.u16 | undefined | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.u16 | undefined | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_Option_u16(_108, out); @@ -3308,7 +3308,7 @@ export function boxed$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$String(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$String(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: string = make$conversions_Value_String(data, 19); boxed = make$conversions_Value_String(data, 3); put$conversions_Value_String(boxed, out); @@ -3324,31 +3324,31 @@ export function boxed$String(data: rt.ByteSlice, out: rt.ByteVec): void { let maybe: string | undefined = make$conversions_Value_String(data, 22); maybe = option_clone$14nprly(boxed); maybe = option_clone$14nprly(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$14nprly(source); - rt.iterForEach(rt.iterOption(maybe), (x: string): undefined => { + rs.iterForEach(rs.iterOption(maybe), (x: string): undefined => { put$conversions_Value_String(x, out); }); const slots: string[] = [make$conversions_Value_String(data, 23), make$conversions_Value_String(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: string): string => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: string): string => { return a02; }); for (const _73 of slots) { put$conversions_Value_String(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: string[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): string => { - return make$conversions_Value_String(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: string[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): string => { + return make$conversions_Value_String(data, rs.usizeAdd(26, i)); }), undefined, 12, true).items; - let into: string[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): string => { - return make$conversions_Value_String(data, rt.usizeAdd(29, i2)); + let into: string[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): string => { + return make$conversions_Value_String(data, rs.usizeAdd(29, i2)); }), undefined, 12, true).items; - into = rt.boxSliceCloneFrom(into, whole); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: string | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: string | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_String(_108, out); @@ -3359,71 +3359,71 @@ export function boxed$String(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const boxed: rt.Vec = make$conversions_Value_Vec_u32(data, 19); - const _8: rt.Vec = make$conversions_Value_Vec_u32(data, 3); - rt.vecCloneFrom(boxed, _8, 4); +export function boxed$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const boxed: rs.Vec = make$conversions_Value_Vec_u32(data, 19); + const _8: rs.Vec = make$conversions_Value_Vec_u32(data, 3); + rs.vecCloneFrom(boxed, _8, 4); put$conversions_Value_Vec_u32(boxed, out); - const source: rt.Vec = make$conversions_Value_Vec_u32(data, 20); - rt.vecCloneFrom(boxed, source, 4); + const source: rs.Vec = make$conversions_Value_Vec_u32(data, 20); + rs.vecCloneFrom(boxed, source, 4); put$conversions_Value_Vec_u32(boxed, out); put$conversions_Value_Vec_u32(source, out); - const nested: rt.Vec = make$conversions_Value_Vec_u32(data, 21); - const _27: rt.Vec = ((a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.slice()); + const nested: rs.Vec = make$conversions_Value_Vec_u32(data, 21); + const _27: rs.Vec = ((a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.slice()); })(source); - rt.vecCloneFrom(nested, _27, 4); + rs.vecCloneFrom(nested, _27, 4); put$conversions_Value_Vec_u32(nested, out); - let maybe: rt.Vec | undefined = make$conversions_Value_Vec_u32(data, 22); - const _38: rt.Vec | undefined = ((a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.slice()); + let maybe: rs.Vec | undefined = make$conversions_Value_Vec_u32(data, 22); + const _38: rs.Vec | undefined = ((a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.slice()); })(boxed); - maybe = rt.optionCloneFrom(maybe, _38, (a03: rt.Vec): rt.Vec => { - return ((a04: rt.Vec): rt.Vec => { - return rt.vecFrom(a04.items.slice()); + maybe = rs.optionCloneFrom(maybe, _38, (a03: rs.Vec): rs.Vec => { + return ((a04: rs.Vec): rs.Vec => { + return rs.vecFrom(a04.items.slice()); })(a03); - }, undefined, rt.vecCloneFromFn(4)); - maybe = rt.optionCloneFrom(maybe, undefined, (a05: rt.Vec): rt.Vec => { - return ((a06: rt.Vec): rt.Vec => { - return rt.vecFrom(a06.items.slice()); + }, undefined, rs.vecCloneFromFn(4)); + maybe = rs.optionCloneFrom(maybe, undefined, (a05: rs.Vec): rs.Vec => { + return ((a06: rs.Vec): rs.Vec => { + return rs.vecFrom(a06.items.slice()); })(a05); - }, undefined, rt.vecCloneFromFn(4)); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - const _51: rt.Vec | undefined = ((a07: rt.Vec): rt.Vec => { - return rt.vecFrom(a07.items.slice()); + }, undefined, rs.vecCloneFromFn(4)); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + const _51: rs.Vec | undefined = ((a07: rs.Vec): rs.Vec => { + return rs.vecFrom(a07.items.slice()); })(source); - maybe = rt.optionCloneFrom(maybe, _51, (a08: rt.Vec): rt.Vec => { - return ((a09: rt.Vec): rt.Vec => { - return rt.vecFrom(a09.items.slice()); + maybe = rs.optionCloneFrom(maybe, _51, (a08: rs.Vec): rs.Vec => { + return ((a09: rs.Vec): rs.Vec => { + return rs.vecFrom(a09.items.slice()); })(a08); - }, undefined, rt.vecCloneFromFn(4)); - rt.iterForEach(rt.iterOption(maybe), (x: rt.Vec): undefined => { + }, undefined, rs.vecCloneFromFn(4)); + rs.iterForEach(rs.iterOption(maybe), (x: rs.Vec): undefined => { put$conversions_Value_Vec_u32(x, out); }); - const slots: rt.Vec[] = [make$conversions_Value_Vec_u32(data, 23), make$conversions_Value_Vec_u32(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a010: rt.Vec): rt.Vec => { - return ((a011: rt.Vec): rt.Vec => { - return rt.vecFrom(a011.items.slice()); + const slots: rs.Vec[] = [make$conversions_Value_Vec_u32(data, 23), make$conversions_Value_Vec_u32(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a010: rs.Vec): rs.Vec => { + return ((a011: rs.Vec): rs.Vec => { + return rs.vecFrom(a011.items.slice()); })(a010); - }, undefined, rt.vecCloneFromFn(4)); + }, undefined, rs.vecCloneFromFn(4)); for (const _73 of slots) { put$conversions_Value_Vec_u32(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.Vec[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.Vec => { - return make$conversions_Value_Vec_u32(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.Vec[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.Vec => { + return make$conversions_Value_Vec_u32(data, rs.usizeAdd(26, i)); }), undefined, 12, true).items; - let into: rt.Vec[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.Vec => { - return make$conversions_Value_Vec_u32(data, rt.usizeAdd(29, i2)); + let into: rs.Vec[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.Vec => { + return make$conversions_Value_Vec_u32(data, rs.usizeAdd(29, i2)); }), undefined, 12, true).items; - into = rt.boxSliceCloneFrom(into, whole, (a012: rt.Vec): rt.Vec => { - return rt.vecFrom(a012.items.slice()); - }, undefined, rt.vecCloneFromFn(4)); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter> = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole, (a012: rs.Vec): rs.Vec => { + return rs.vecFrom(a012.items.slice()); + }, undefined, rs.vecCloneFromFn(4)); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter> = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.Vec | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.Vec | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_Vec_u32(_108, out); @@ -3434,71 +3434,71 @@ export function boxed$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - const boxed: rt.ByteVec = make$conversions_Value_Vec_u8(data, 19); - const _8: rt.ByteVec = make$conversions_Value_Vec_u8(data, 3); - rt.byteVecCloneFrom(boxed, _8); +export function boxed$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + const boxed: rs.ByteVec = make$conversions_Value_Vec_u8(data, 19); + const _8: rs.ByteVec = make$conversions_Value_Vec_u8(data, 3); + rs.byteVecCloneFrom(boxed, _8); put$conversions_Value_Vec_u8(boxed, out); - const source: rt.ByteVec = make$conversions_Value_Vec_u8(data, 20); - rt.byteVecCloneFrom(boxed, source); + const source: rs.ByteVec = make$conversions_Value_Vec_u8(data, 20); + rs.byteVecCloneFrom(boxed, source); put$conversions_Value_Vec_u8(boxed, out); put$conversions_Value_Vec_u8(source, out); - const nested: rt.ByteVec = make$conversions_Value_Vec_u8(data, 21); - const _27: rt.ByteVec = ((a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const nested: rs.ByteVec = make$conversions_Value_Vec_u8(data, 21); + const _27: rs.ByteVec = ((a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); })(source); - rt.byteVecCloneFrom(nested, _27); + rs.byteVecCloneFrom(nested, _27); put$conversions_Value_Vec_u8(nested, out); - let maybe: rt.ByteVec | undefined = make$conversions_Value_Vec_u8(data, 22); - const _38: rt.ByteVec | undefined = ((a02: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a02)); + let maybe: rs.ByteVec | undefined = make$conversions_Value_Vec_u8(data, 22); + const _38: rs.ByteVec | undefined = ((a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); })(boxed); - maybe = rt.optionCloneFrom(maybe, _38, (a03: rt.ByteVec): rt.ByteVec => { - return ((a04: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a04)); + maybe = rs.optionCloneFrom(maybe, _38, (a03: rs.ByteVec): rs.ByteVec => { + return ((a04: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a04)); })(a03); - }, undefined, rt.byteVecCloneFromFn()); - maybe = rt.optionCloneFrom(maybe, undefined, (a05: rt.ByteVec): rt.ByteVec => { - return ((a06: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a06)); + }, undefined, rs.byteVecCloneFromFn()); + maybe = rs.optionCloneFrom(maybe, undefined, (a05: rs.ByteVec): rs.ByteVec => { + return ((a06: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a06)); })(a05); - }, undefined, rt.byteVecCloneFromFn()); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - const _51: rt.ByteVec | undefined = ((a07: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a07)); + }, undefined, rs.byteVecCloneFromFn()); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + const _51: rs.ByteVec | undefined = ((a07: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a07)); })(source); - maybe = rt.optionCloneFrom(maybe, _51, (a08: rt.ByteVec): rt.ByteVec => { - return ((a09: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a09)); + maybe = rs.optionCloneFrom(maybe, _51, (a08: rs.ByteVec): rs.ByteVec => { + return ((a09: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a09)); })(a08); - }, undefined, rt.byteVecCloneFromFn()); - rt.iterForEach(rt.iterOption(maybe), (x: rt.ByteVec): undefined => { + }, undefined, rs.byteVecCloneFromFn()); + rs.iterForEach(rs.iterOption(maybe), (x: rs.ByteVec): undefined => { put$conversions_Value_Vec_u8(x, out); }); - const slots: rt.ByteVec[] = [make$conversions_Value_Vec_u8(data, 23), make$conversions_Value_Vec_u8(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a010: rt.ByteVec): rt.ByteVec => { - return ((a011: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a011)); + const slots: rs.ByteVec[] = [make$conversions_Value_Vec_u8(data, 23), make$conversions_Value_Vec_u8(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a010: rs.ByteVec): rs.ByteVec => { + return ((a011: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a011)); })(a010); - }, undefined, rt.byteVecCloneFromFn()); + }, undefined, rs.byteVecCloneFromFn()); for (const _73 of slots) { put$conversions_Value_Vec_u8(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.ByteVec[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.ByteVec => { - return make$conversions_Value_Vec_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.ByteVec[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.ByteVec => { + return make$conversions_Value_Vec_u8(data, rs.usizeAdd(26, i)); }), undefined, 12, true).items; - let into: rt.ByteVec[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.ByteVec => { - return make$conversions_Value_Vec_u8(data, rt.usizeAdd(29, i2)); + let into: rs.ByteVec[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.ByteVec => { + return make$conversions_Value_Vec_u8(data, rs.usizeAdd(29, i2)); }), undefined, 12, true).items; - into = rt.boxSliceCloneFrom(into, whole, (a012: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a012)); - }, undefined, rt.byteVecCloneFromFn()); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole, (a012: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a012)); + }, undefined, rs.byteVecCloneFromFn()); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.ByteVec | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.ByteVec | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_Vec_u8(_108, out); @@ -3509,48 +3509,48 @@ export function boxed$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 19)); boxed = copy$array_u8(copy$array_u8(make$conversions_Value_array0_u8(data, 3))); - put$conversions_Value_array0_u8(rt.byteSliceFrom(boxed), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(boxed), out); const source: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 20)); boxed = copy$array_u8(source); - put$conversions_Value_array0_u8(rt.byteSliceFrom(boxed), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(source), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(boxed), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(source), out); let nested: Uint8Array = copy$array_u8(make$conversions_Value_array0_u8(data, 21)); const _27: Uint8Array = copy$array_u8(source); nested = ((a0: Uint8Array): Uint8Array => { return copy$array_u8(a0); })(_27); - put$conversions_Value_array0_u8(rt.byteSliceFrom(nested), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(nested), out); let maybe: Uint8Array | undefined = copy$array_u8(make$conversions_Value_array0_u8(data, 22)); maybe = option_clone$13oewp0(copy$array_u8(boxed)); maybe = option_clone$13oewp0(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$13oewp0(copy$array_u8(source)); - rt.iterForEach(rt.iterOption(maybe), (x: Uint8Array): undefined => { - put$conversions_Value_array0_u8(rt.byteSliceFrom(x), out); + rs.iterForEach(rs.iterOption(maybe), (x: Uint8Array): undefined => { + put$conversions_Value_array0_u8(rs.byteSliceFrom(x), out); }); const slots: Uint8Array[] = [copy$array_u8(make$conversions_Value_array0_u8(data, 23)), copy$array_u8(make$conversions_Value_array0_u8(data, 24))]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { return copy$array_u8(a02); }); for (const _73 of slots) { - put$conversions_Value_array0_u8(rt.byteSliceFrom(_73), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(_73), out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Uint8Array => { - return make$conversions_Value_array0_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { + return make$conversions_Value_array0_u8(data, rs.usizeAdd(26, i)); }), undefined, 0, true).items; - let into: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Uint8Array => { - return make$conversions_Value_array0_u8(data, rt.usizeAdd(29, i2)); + let into: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + return make$conversions_Value_array0_u8(data, rs.usizeAdd(29, i2)); }), undefined, 0, true).items; - into = rt.boxSliceCloneFrom(into, whole, copy$array_u8); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(into), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(whole), rt.byteSliceFrom)); + into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(into), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(whole), rs.byteSliceFrom)); while (true) { - const _108: rt.ByteSlice | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.ByteSlice | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_array0_u8(_108, out); @@ -3561,48 +3561,48 @@ export function boxed$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 19)); boxed = copy$array_u8(copy$array_u8(make$conversions_Value_array1_u8(data, 3))); - put$conversions_Value_array1_u8(rt.byteSliceFrom(boxed), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(boxed), out); const source: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 20)); boxed = copy$array_u8(source); - put$conversions_Value_array1_u8(rt.byteSliceFrom(boxed), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(source), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(boxed), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(source), out); let nested: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 21)); const _27: Uint8Array = copy$array_u8(source); nested = ((a0: Uint8Array): Uint8Array => { return copy$array_u8(a0); })(_27); - put$conversions_Value_array1_u8(rt.byteSliceFrom(nested), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(nested), out); let maybe: Uint8Array | undefined = copy$array_u8(make$conversions_Value_array1_u8(data, 22)); maybe = option_clone$13oewp0(copy$array_u8(boxed)); maybe = option_clone$13oewp0(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$13oewp0(copy$array_u8(source)); - rt.iterForEach(rt.iterOption(maybe), (x: Uint8Array): undefined => { - put$conversions_Value_array1_u8(rt.byteSliceFrom(x), out); + rs.iterForEach(rs.iterOption(maybe), (x: Uint8Array): undefined => { + put$conversions_Value_array1_u8(rs.byteSliceFrom(x), out); }); const slots: Uint8Array[] = [copy$array_u8(make$conversions_Value_array1_u8(data, 23)), copy$array_u8(make$conversions_Value_array1_u8(data, 24))]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { return copy$array_u8(a02); }); for (const _73 of slots) { - put$conversions_Value_array1_u8(rt.byteSliceFrom(_73), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(_73), out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Uint8Array => { - return make$conversions_Value_array1_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { + return make$conversions_Value_array1_u8(data, rs.usizeAdd(26, i)); }), undefined, 1, true).items; - let into: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Uint8Array => { - return make$conversions_Value_array1_u8(data, rt.usizeAdd(29, i2)); + let into: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + return make$conversions_Value_array1_u8(data, rs.usizeAdd(29, i2)); }), undefined, 1, true).items; - into = rt.boxSliceCloneFrom(into, whole, copy$array_u8); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(into), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(whole), rt.byteSliceFrom)); + into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(into), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(whole), rs.byteSliceFrom)); while (true) { - const _108: rt.ByteSlice | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.ByteSlice | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_array1_u8(_108, out); @@ -3613,48 +3613,48 @@ export function boxed$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); +export function boxed$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 19)); boxed = copy$array_u32(copy$array_u32(make$conversions_Value_array2_u32(data, 3))); put$conversions_Value_array2_u32(boxed, out); - const source: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 20)); + const source: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 20)); boxed = copy$array_u32(source); put$conversions_Value_array2_u32(boxed, out); put$conversions_Value_array2_u32(source, out); - let nested: rt.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 21)); - const _27: rt.u32[] = copy$array_u32(source); - nested = ((a0: rt.u32[]): rt.u32[] => { + let nested: rs.u32[] = copy$array_u32(make$conversions_Value_array2_u32(data, 21)); + const _27: rs.u32[] = copy$array_u32(source); + nested = ((a0: rs.u32[]): rs.u32[] => { return copy$array_u32(a0); })(_27); put$conversions_Value_array2_u32(nested, out); - let maybe: rt.u32[] | undefined = copy$array_u32(make$conversions_Value_array2_u32(data, 22)); - maybe = option_clone$0xuzdx9(copy$array_u32(boxed)); - maybe = option_clone$0xuzdx9(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$0xuzdx9(copy$array_u32(source)); - rt.iterForEach(rt.iterOption(maybe), (x: rt.u32[]): undefined => { + let maybe: rs.u32[] | undefined = copy$array_u32(make$conversions_Value_array2_u32(data, 22)); + maybe = option_clone$0xr8mw0(copy$array_u32(boxed)); + maybe = option_clone$0xr8mw0(undefined); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + maybe = option_clone$0xr8mw0(copy$array_u32(source)); + rs.iterForEach(rs.iterOption(maybe), (x: rs.u32[]): undefined => { put$conversions_Value_array2_u32(x, out); }); - const slots: rt.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 23)), copy$array_u32(make$conversions_Value_array2_u32(data, 24))]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: rt.u32[]): rt.u32[] => { + const slots: rs.u32[][] = [copy$array_u32(make$conversions_Value_array2_u32(data, 23)), copy$array_u32(make$conversions_Value_array2_u32(data, 24))]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: rs.u32[]): rs.u32[] => { return copy$array_u32(a02); }); for (const _73 of slots) { put$conversions_Value_array2_u32(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.u32[][] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u32[] => { - return make$conversions_Value_array2_u32(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.u32[][] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u32[] => { + return make$conversions_Value_array2_u32(data, rs.usizeAdd(26, i)); }), undefined, 8, true).items; - let into: rt.u32[][] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.u32[] => { - return make$conversions_Value_array2_u32(data, rt.usizeAdd(29, i2)); + let into: rs.u32[][] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u32[] => { + return make$conversions_Value_array2_u32(data, rs.usizeAdd(29, i2)); }), undefined, 8, true).items; - into = rt.boxSliceCloneFrom(into, whole, copy$array_u32); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole, copy$array_u32); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.u32[] | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.u32[] | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_array2_u32(_108, out); @@ -3665,48 +3665,48 @@ export function boxed$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 19)); boxed = copy$array_u8(copy$array_u8(make$conversions_Value_array3_u8(data, 3))); - put$conversions_Value_array3_u8(rt.byteSliceFrom(boxed), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(boxed), out); const source: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 20)); boxed = copy$array_u8(source); - put$conversions_Value_array3_u8(rt.byteSliceFrom(boxed), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(source), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(boxed), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(source), out); let nested: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 21)); const _27: Uint8Array = copy$array_u8(source); nested = ((a0: Uint8Array): Uint8Array => { return copy$array_u8(a0); })(_27); - put$conversions_Value_array3_u8(rt.byteSliceFrom(nested), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(nested), out); let maybe: Uint8Array | undefined = copy$array_u8(make$conversions_Value_array3_u8(data, 22)); maybe = option_clone$13oewp0(copy$array_u8(boxed)); maybe = option_clone$13oewp0(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$13oewp0(copy$array_u8(source)); - rt.iterForEach(rt.iterOption(maybe), (x: Uint8Array): undefined => { - put$conversions_Value_array3_u8(rt.byteSliceFrom(x), out); + rs.iterForEach(rs.iterOption(maybe), (x: Uint8Array): undefined => { + put$conversions_Value_array3_u8(rs.byteSliceFrom(x), out); }); const slots: Uint8Array[] = [copy$array_u8(make$conversions_Value_array3_u8(data, 23)), copy$array_u8(make$conversions_Value_array3_u8(data, 24))]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { return copy$array_u8(a02); }); for (const _73 of slots) { - put$conversions_Value_array3_u8(rt.byteSliceFrom(_73), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(_73), out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Uint8Array => { - return make$conversions_Value_array3_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { + return make$conversions_Value_array3_u8(data, rs.usizeAdd(26, i)); }), undefined, 3, true).items; - let into: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Uint8Array => { - return make$conversions_Value_array3_u8(data, rt.usizeAdd(29, i2)); + let into: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + return make$conversions_Value_array3_u8(data, rs.usizeAdd(29, i2)); }), undefined, 3, true).items; - into = rt.boxSliceCloneFrom(into, whole, copy$array_u8); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(into), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(whole), rt.byteSliceFrom)); + into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(into), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(whole), rs.byteSliceFrom)); while (true) { - const _108: rt.ByteSlice | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.ByteSlice | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_array3_u8(_108, out); @@ -3717,48 +3717,48 @@ export function boxed$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 19)); boxed = copy$array_u8(copy$array_u8(make$conversions_Value_array40_u8(data, 3))); - put$conversions_Value_array40_u8(rt.byteSliceFrom(boxed), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(boxed), out); const source: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 20)); boxed = copy$array_u8(source); - put$conversions_Value_array40_u8(rt.byteSliceFrom(boxed), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(source), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(boxed), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(source), out); let nested: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 21)); const _27: Uint8Array = copy$array_u8(source); nested = ((a0: Uint8Array): Uint8Array => { return copy$array_u8(a0); })(_27); - put$conversions_Value_array40_u8(rt.byteSliceFrom(nested), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(nested), out); let maybe: Uint8Array | undefined = copy$array_u8(make$conversions_Value_array40_u8(data, 22)); maybe = option_clone$13oewp0(copy$array_u8(boxed)); maybe = option_clone$13oewp0(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$13oewp0(copy$array_u8(source)); - rt.iterForEach(rt.iterOption(maybe), (x: Uint8Array): undefined => { - put$conversions_Value_array40_u8(rt.byteSliceFrom(x), out); + rs.iterForEach(rs.iterOption(maybe), (x: Uint8Array): undefined => { + put$conversions_Value_array40_u8(rs.byteSliceFrom(x), out); }); const slots: Uint8Array[] = [copy$array_u8(make$conversions_Value_array40_u8(data, 23)), copy$array_u8(make$conversions_Value_array40_u8(data, 24))]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: Uint8Array): Uint8Array => { return copy$array_u8(a02); }); for (const _73 of slots) { - put$conversions_Value_array40_u8(rt.byteSliceFrom(_73), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(_73), out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Uint8Array => { - return make$conversions_Value_array40_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Uint8Array => { + return make$conversions_Value_array40_u8(data, rs.usizeAdd(26, i)); }), undefined, 40, true).items; - let into: Uint8Array[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Uint8Array => { - return make$conversions_Value_array40_u8(data, rt.usizeAdd(29, i2)); + let into: Uint8Array[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Uint8Array => { + return make$conversions_Value_array40_u8(data, rs.usizeAdd(29, i2)); }), undefined, 40, true).items; - into = rt.boxSliceCloneFrom(into, whole, copy$array_u8); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(into), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(whole), rt.byteSliceFrom)); + into = rs.boxSliceCloneFrom(into, whole, copy$array_u8); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(into), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(whole), rs.byteSliceFrom)); while (true) { - const _108: rt.ByteSlice | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.ByteSlice | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_array40_u8(_108, out); @@ -3769,7 +3769,7 @@ export function boxed$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Logged.Logged = Logged.make$conversions_Value(data, 19); const _8: Logged.Logged = Logged.make$conversions_Value(data, 3); const old = boxed; @@ -3796,51 +3796,51 @@ export function boxed$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): v const _38: Logged.Logged | undefined = Logged.clone$Clone(boxed); const old4 = maybe; maybe = option_clone$17fv6u9(_38); - rt.drop(old4); - rt.drop(_38); + rs.drop(old4); + rs.drop(_38); const old5 = maybe; maybe = option_clone$17fv6u9(undefined); - rt.drop(old5); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.drop(old5); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); const _51: Logged.Logged | undefined = Logged.clone$Clone(source); const old6 = maybe; maybe = option_clone$17fv6u9(_51); - rt.drop(old6); - rt.drop(_51); - rt.iterForEach(rt.iterOption(maybe), (x: Logged.Logged): undefined => { + rs.drop(old6); + rs.drop(_51); + rs.iterForEach(rs.iterOption(maybe), (x: Logged.Logged): undefined => { Logged.put$conversions_Value(x, out); }); const slots: Logged.Logged[] = [Logged.make$conversions_Value(data, 23), Logged.make$conversions_Value(data, 24)]; const _64: Logged.Logged[] = slots; const _68: Logged.Logged[] = [source, boxed]; - rt.sliceCloneFromSlice(_64, _68, (a02: Logged.Logged): Logged.Logged => { + rs.sliceCloneFromSlice(_64, _68, (a02: Logged.Logged): Logged.Logged => { return Logged.clone$Clone(a02); - }, rt.drop); - rt.dropAll(_68); + }, rs.drop); + rs.dropAll(_68); for (const _73 of slots) { Logged.put$conversions_Value(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Logged.Logged[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Logged.Logged => { - return Logged.make$conversions_Value(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Logged.Logged[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Logged.Logged => { + return Logged.make$conversions_Value(data, rs.usizeAdd(26, i)); }), undefined, 8, true).items; - let into: Logged.Logged[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Logged.Logged => { - return Logged.make$conversions_Value(data, rt.usizeAdd(29, i2)); + let into: Logged.Logged[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Logged.Logged => { + return Logged.make$conversions_Value(data, rs.usizeAdd(29, i2)); }), undefined, 8, true).items; - into = rt.boxSliceCloneFrom(into, whole, Logged.clone$Clone, rt.drop); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole, Logged.clone$Clone, rs.drop); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: Logged.Logged | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: Logged.Logged | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } Logged.put$conversions_Value(_108, out); } - rt.dropAll(into); - rt.dropAll(whole); - rt.dropAll(slots); - rt.drop(maybe); + rs.dropAll(into); + rs.dropAll(whole); + rs.dropAll(slots); + rs.drop(maybe); nested[Symbol.dispose](); } @@ -3848,7 +3848,7 @@ export function boxed$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): v * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { +export function boxed$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { let boxed: Named.Named = Named.make$conversions_Value(data, 19); boxed = Named.clone$Clone(Named.make$conversions_Value(data, 3)); Named.put$conversions_Value(boxed, out); @@ -3865,31 +3865,31 @@ export function boxed$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): vo let maybe: Named.Named | undefined = Named.make$conversions_Value(data, 22); maybe = option_clone$0fp7wpk(Named.clone$Clone(boxed)); maybe = option_clone$0fp7wpk(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); maybe = option_clone$0fp7wpk(Named.clone$Clone(source)); - rt.iterForEach(rt.iterOption(maybe), (x: Named.Named): undefined => { + rs.iterForEach(rs.iterOption(maybe), (x: Named.Named): undefined => { Named.put$conversions_Value(x, out); }); const slots: Named.Named[] = [Named.make$conversions_Value(data, 23), Named.make$conversions_Value(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: Named.Named): Named.Named => { + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: Named.Named): Named.Named => { return Named.clone$Clone(a02); }); for (const _73 of slots) { Named.put$conversions_Value(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: Named.Named[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): Named.Named => { - return Named.make$conversions_Value(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: Named.Named[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): Named.Named => { + return Named.make$conversions_Value(data, rs.usizeAdd(26, i)); }), undefined, 16, true).items; - let into: Named.Named[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): Named.Named => { - return Named.make$conversions_Value(data, rt.usizeAdd(29, i2)); + let into: Named.Named[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): Named.Named => { + return Named.make$conversions_Value(data, rs.usizeAdd(29, i2)); }), undefined, 16, true).items; - into = rt.boxSliceCloneFrom(into, whole, Named.clone$Clone); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole, Named.clone$Clone); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: Named.Named | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: Named.Named | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } Named.put$conversions_Value(_108, out); @@ -3900,47 +3900,47 @@ export function boxed$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): vo * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: rt.u32 = make$conversions_Value_u32(data, 19); +export function boxed$u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: rs.u32 = make$conversions_Value_u32(data, 19); boxed = make$conversions_Value_u32(data, 3); put$conversions_Value_u32(boxed, out); - const source: rt.u32 = make$conversions_Value_u32(data, 20); + const source: rs.u32 = make$conversions_Value_u32(data, 20); boxed = source; put$conversions_Value_u32(boxed, out); put$conversions_Value_u32(source, out); - let nested: rt.u32 = make$conversions_Value_u32(data, 21); - nested = ((a0: rt.u32): rt.u32 => { + let nested: rs.u32 = make$conversions_Value_u32(data, 21); + nested = ((a0: rs.u32): rs.u32 => { return a0; })(source); put$conversions_Value_u32(nested, out); - let maybe: rt.u32 | undefined = make$conversions_Value_u32(data, 22); - maybe = option_clone$1md9w7g(boxed); - maybe = option_clone$1md9w7g(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$1md9w7g(source); - rt.iterForEach(rt.iterOption(maybe), (x: rt.u32): undefined => { + let maybe: rs.u32 | undefined = make$conversions_Value_u32(data, 22); + maybe = option_clone$1lfse5o(boxed); + maybe = option_clone$1lfse5o(undefined); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + maybe = option_clone$1lfse5o(source); + rs.iterForEach(rs.iterOption(maybe), (x: rs.u32): undefined => { put$conversions_Value_u32(x, out); }); - const slots: rt.u32[] = [make$conversions_Value_u32(data, 23), make$conversions_Value_u32(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: rt.u32): rt.u32 => { + const slots: rs.u32[] = [make$conversions_Value_u32(data, 23), make$conversions_Value_u32(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: rs.u32): rs.u32 => { return a02; }); for (const _73 of slots) { put$conversions_Value_u32(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.u32[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u32 => { - return make$conversions_Value_u32(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.u32[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u32 => { + return make$conversions_Value_u32(data, rs.usizeAdd(26, i)); }), undefined, 4, true).items; - let into: rt.u32[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.u32 => { - return make$conversions_Value_u32(data, rt.usizeAdd(29, i2)); + let into: rs.u32[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u32 => { + return make$conversions_Value_u32(data, rs.usizeAdd(29, i2)); }), undefined, 4, true).items; - into = rt.boxSliceCloneFrom(into, whole); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.u32 | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.u32 | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_u32(_108, out); @@ -3951,47 +3951,47 @@ export function boxed$u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$u64(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: rt.u64 = make$conversions_Value_u64(data, 19); +export function boxed$u64(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: rs.u64 = make$conversions_Value_u64(data, 19); boxed = make$conversions_Value_u64(data, 3); put$conversions_Value_u64(boxed, out); - const source: rt.u64 = make$conversions_Value_u64(data, 20); + const source: rs.u64 = make$conversions_Value_u64(data, 20); boxed = source; put$conversions_Value_u64(boxed, out); put$conversions_Value_u64(source, out); - let nested: rt.u64 = make$conversions_Value_u64(data, 21); - nested = ((a0: rt.u64): rt.u64 => { + let nested: rs.u64 = make$conversions_Value_u64(data, 21); + nested = ((a0: rs.u64): rs.u64 => { return a0; })(source); put$conversions_Value_u64(nested, out); - let maybe: rt.u64 | undefined = make$conversions_Value_u64(data, 22); - maybe = option_clone$1qp57nz(boxed); - maybe = option_clone$1qp57nz(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$1qp57nz(source); - rt.iterForEach(rt.iterOption(maybe), (x: rt.u64): undefined => { + let maybe: rs.u64 | undefined = make$conversions_Value_u64(data, 22); + maybe = option_clone$08wmfj8(boxed); + maybe = option_clone$08wmfj8(undefined); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + maybe = option_clone$08wmfj8(source); + rs.iterForEach(rs.iterOption(maybe), (x: rs.u64): undefined => { put$conversions_Value_u64(x, out); }); - const slots: rt.u64[] = [make$conversions_Value_u64(data, 23), make$conversions_Value_u64(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: rt.u64): rt.u64 => { + const slots: rs.u64[] = [make$conversions_Value_u64(data, 23), make$conversions_Value_u64(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: rs.u64): rs.u64 => { return a02; }); for (const _73 of slots) { put$conversions_Value_u64(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.u64[] = rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u64 => { - return make$conversions_Value_u64(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.u64[] = rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u64 => { + return make$conversions_Value_u64(data, rs.usizeAdd(26, i)); }), undefined, 8, true).items; - let into: rt.u64[] = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.u64 => { - return make$conversions_Value_u64(data, rt.usizeAdd(29, i2)); + let into: rs.u64[] = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u64 => { + return make$conversions_Value_u64(data, rs.usizeAdd(29, i2)); }), undefined, 8, true).items; - into = rt.boxSliceCloneFrom(into, whole); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(into), rt.iterSlice(whole)); + into = rs.boxSliceCloneFrom(into, whole); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(into), rs.iterSlice(whole)); while (true) { - const _108: rt.u64 | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.u64 | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_u64(_108, out); @@ -4002,47 +4002,47 @@ export function boxed$u64(data: rt.ByteSlice, out: rt.ByteVec): void { * Boxes, which clone what they hold by its own `clone_from`: a box, one in a box, in an * `Option`, and in a slice, and a boxed slice by `clone_into`. */ -export function boxed$u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: rt.u8 = make$conversions_Value_u8(data, 19); +export function boxed$u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: rs.u8 = make$conversions_Value_u8(data, 19); boxed = make$conversions_Value_u8(data, 3); put$conversions_Value_u8(boxed, out); - const source: rt.u8 = make$conversions_Value_u8(data, 20); + const source: rs.u8 = make$conversions_Value_u8(data, 20); boxed = source; put$conversions_Value_u8(boxed, out); put$conversions_Value_u8(source, out); - let nested: rt.u8 = make$conversions_Value_u8(data, 21); - nested = ((a0: rt.u8): rt.u8 => { + let nested: rs.u8 = make$conversions_Value_u8(data, 21); + nested = ((a0: rs.u8): rs.u8 => { return a0; })(source); put$conversions_Value_u8(nested, out); - let maybe: rt.u8 | undefined = make$conversions_Value_u8(data, 22); - maybe = option_clone$08560de(boxed); - maybe = option_clone$08560de(undefined); - rt.byteVecPush(out, maybe === undefined ? 1 : 0); - maybe = option_clone$08560de(source); - rt.iterForEach(rt.iterOption(maybe), (x: rt.u8): undefined => { + let maybe: rs.u8 | undefined = make$conversions_Value_u8(data, 22); + maybe = option_clone$1aebjgp(boxed); + maybe = option_clone$1aebjgp(undefined); + rs.byteVecPush(out, maybe === undefined ? 1 : 0); + maybe = option_clone$1aebjgp(source); + rs.iterForEach(rs.iterOption(maybe), (x: rs.u8): undefined => { put$conversions_Value_u8(x, out); }); - const slots: rt.u8[] = [make$conversions_Value_u8(data, 23), make$conversions_Value_u8(data, 24)]; - rt.sliceCloneFromSlice(slots, [source, boxed], (a02: rt.u8): rt.u8 => { + const slots: rs.u8[] = [make$conversions_Value_u8(data, 23), make$conversions_Value_u8(data, 24)]; + rs.sliceCloneFromSlice(slots, [source, boxed], (a02: rs.u8): rs.u8 => { return a02; }); for (const _73 of slots) { put$conversions_Value_u8(_73, out); } - const n: rt.usize = rt.u8Rem(byte(data, 25), 3) as rt.usize; - const whole: rt.ByteSlice = rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u8 => { - return make$conversions_Value_u8(data, rt.usizeAdd(26, i)); + const n: rs.usize = rs.u8Rem(byte(data, 25), 3) as rs.usize; + const whole: rs.ByteSlice = rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u8 => { + return make$conversions_Value_u8(data, rs.usizeAdd(26, i)); }), undefined, true)); - let into: rt.ByteSlice = rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.usizeRem(rt.usizeAdd(n, 1), 3)), (i2: rt.usize): rt.u8 => { - return make$conversions_Value_u8(data, rt.usizeAdd(29, i2)); + let into: rs.ByteSlice = rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.usizeRem(rs.usizeAdd(n, 1), 3)), (i2: rs.usize): rs.u8 => { + return make$conversions_Value_u8(data, rs.usizeAdd(29, i2)); }), undefined, true)); - into = rt.byteBoxSliceCloneFrom(into, whole); - rt.byteVecPush(out, into.length & 0xff); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(into)), rt.iterSlice(rt.byteSliceView(whole))); + into = rs.byteBoxSliceCloneFrom(into, whole); + rs.byteVecPush(out, into.length & 0xff); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(into)), rs.iterSlice(rs.byteSliceView(whole))); while (true) { - const _108: rt.u8 | rt.Done = iter2.next(); - if (_108 === rt.DONE) { + const _108: rs.u8 | rs.Done = iter2.next(); + if (_108 === rs.DONE) { break; } put$conversions_Value_u8(_108, out); @@ -4053,54 +4053,54 @@ export function boxed$u8(data: rt.ByteSlice, out: rt.ByteVec): void { * A box's `clone_from` of a `Vec`, which keeps its buffer, into one of a capacity `data` * picks, and of the crate's own `clone_from`. */ -export function boxedKept(data: rt.ByteSlice, out: rt.ByteVec): void { - const words: rt.Vec = rt.vecWithCapacity(rt.u8Rem(byte(data, 0), 8) as rt.usize, 4); - rt.iterExtend(words, rt.iterMap(new rt.Range(0, rt.u8Rem(byte(data, 1), 4)), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; +export function boxedKept(data: rs.ByteSlice, out: rs.ByteVec): void { + const words: rs.Vec = rs.vecWithCapacity(rs.u8Rem(byte(data, 0), 8) as rs.usize, 4); + rs.iterExtend(words, rs.iterMap(new rs.Range(0, rs.u8Rem(byte(data, 1), 4)), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; }), undefined, 4, true); - const _19: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(byte(data, 2), 6)), (a02: rt.u8): rt.u32 => { - return a02 as rt.u32; + const _19: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(byte(data, 2), 6)), (a02: rs.u8): rs.u32 => { + return a02 as rs.u32; }), undefined, 4, true); - rt.vecCloneFrom(words, _19, 4); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(words.items.length & 0xff, rt.vecCapacity(words, 4) & 0xff)), undefined, true); + rs.vecCloneFrom(words, _19, 4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(words.items.length & 0xff, rs.vecCapacity(words, 4) & 0xff)), undefined, true); const kept: Kept.Kept = { id: byte(data, 5), from: 0 }; const _40: Kept.Kept = { id: byte(data, 6), from: 0 }; Kept.cloneFrom$Clone(kept, _40); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept.id, kept.from)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(kept.id, kept.from)), undefined, true); } /** * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.u16 | undefined, rt.u16 | undefined, rt.u16 | undefined] = [make$conversions_Value_Option_u16(data, 0), make$conversions_Value_Option_u16(data, 3), make$conversions_Value_Option_u16(data, 6)]; - let a: rt.u16 | undefined = _6[0]; - const b: rt.u16 | undefined = _6[1]; - let c: rt.u16 | undefined = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); - const s: Array = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _28: rt.u16 | undefined = make$conversions_Value_Option_u16(data, 5); +export function lentOne$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.u16 | undefined, rs.u16 | undefined, rs.u16 | undefined] = [make$conversions_Value_Option_u16(data, 0), make$conversions_Value_Option_u16(data, 3), make$conversions_Value_Option_u16(data, 6)]; + let a: rs.u16 | undefined = _6[0]; + const b: rs.u16 | undefined = _6[1]; + let c: rs.u16 | undefined = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_Option_u16(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Option_u16(data, 2), make$conversions_Value_Option_u16(data, 4)]); + const s: Array = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _28: rs.u16 | undefined = make$conversions_Value_Option_u16(data, 5); const old4 = s[0]; s[0] = _28; put$conversions_Value_Option_u16(old4, out); put$conversions_Value_Option_u16(a, out); const borrowed = held; - put$conversions_Value_Option_u16(writeFirst$Option_u16(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Option_u16(data, 7)), out); + put$conversions_Value_Option_u16(writeFirst$Option_u16(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Option_u16(data, 7)), out); put$conversions_Value_Option_u16(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Option_u16(writeFirst$Option_u16(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Option_u16(data, 8)), out); - put$conversions_Value_Option_u16(v.items[rt.idx(v.items, 1)], out); - rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)).fill(b); - const iter: rt.Iter> = rt.iterSliceMut(rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))); + put$conversions_Value_Option_u16(writeFirst$Option_u16(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Option_u16(data, 8)), out); + put$conversions_Value_Option_u16(v.items[rs.idx(v.items, 1)], out); + rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)).fill(b); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { - const _61: rt.Place | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.Place | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.v = make$conversions_Value_Option_u16(data, 9); @@ -4113,34 +4113,34 @@ export function lentOne$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$String(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$String(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [string, string, string] = [make$conversions_Value_String(data, 0), make$conversions_Value_String(data, 3), make$conversions_Value_String(data, 6)]; let a: string = _6[0]; const b: string = _6[1]; let c: string = _6[2]; const held: Held.Held = new Held.Held(make$conversions_Value_String(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); - const s: string[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_String(data, 2), make$conversions_Value_String(data, 4)]); + const s: string[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); const _28: string = make$conversions_Value_String(data, 5); const old4 = s[0]; s[0] = _28; put$conversions_Value_String(old4, out); put$conversions_Value_String(a, out); const borrowed = held; - put$conversions_Value_String(writeFirst$String(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_String(data, 7)), out); + put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_String(data, 7)), out); put$conversions_Value_String(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_String(writeFirst$String(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_String(data, 8)), out); - put$conversions_Value_String(v.items[rt.idx(v.items, 1)], out); - rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)).fill(b); - const iter: rt.Iter> = rt.iterSliceMut(rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))); + put$conversions_Value_String(writeFirst$String(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_String(data, 8)), out); + put$conversions_Value_String(v.items[rs.idx(v.items, 1)], out); + rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)).fill(b); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { - const _61: rt.Place | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.Place | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.v = make$conversions_Value_String(data, 9); @@ -4153,30 +4153,30 @@ export function lentOne$String(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.Vec, rt.Vec, rt.Vec] = [make$conversions_Value_Vec_u32(data, 0), make$conversions_Value_Vec_u32(data, 3), make$conversions_Value_Vec_u32(data, 6)]; - let a: rt.Vec = _6[0]; - const b: rt.Vec = _6[1]; - let c: rt.Vec = _6[2]; - const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); - const v: rt.Vec> = rt.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); - const s: rt.Vec[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - put$conversions_Value_Vec_u32(rt.sliceReplace(s, 0, make$conversions_Value_Vec_u32(data, 5)), out); +export function lentOne$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.Vec, rs.Vec, rs.Vec] = [make$conversions_Value_Vec_u32(data, 0), make$conversions_Value_Vec_u32(data, 3), make$conversions_Value_Vec_u32(data, 6)]; + let a: rs.Vec = _6[0]; + const b: rs.Vec = _6[1]; + let c: rs.Vec = _6[2]; + const held: Held.Held> = new Held.Held(make$conversions_Value_Vec_u32(data, 1)); + const v: rs.Vec> = rs.vecFrom([make$conversions_Value_Vec_u32(data, 2), make$conversions_Value_Vec_u32(data, 4)]); + const s: rs.Vec[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + put$conversions_Value_Vec_u32(rs.sliceReplace(s, 0, make$conversions_Value_Vec_u32(data, 5)), out); put$conversions_Value_Vec_u32(a, out); const borrowed = held; - put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Vec_u32(data, 7)), out); + put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Vec_u32(data, 7)), out); put$conversions_Value_Vec_u32(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u32(data, 8)), out); - put$conversions_Value_Vec_u32(v.items[rt.idx(v.items, 1)], out); - rt.sliceFill(rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)), rt.vecFrom(b.items.slice()), (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.slice()); - }, undefined, rt.vecCloneFromFn(4)); - for (const _61 of rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))) { + put$conversions_Value_Vec_u32(writeFirst$Vec_u32(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u32(data, 8)), out); + put$conversions_Value_Vec_u32(v.items[rs.idx(v.items, 1)], out); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.vecFrom(b.items.slice()), (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.slice()); + }, undefined, rs.vecCloneFromFn(4)); + for (const _61 of rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))) { Object.assign(_61, make$conversions_Value_Vec_u32(data, 9)); } put$conversions_Value_Vec_u32(c, out); @@ -4187,30 +4187,30 @@ export function lentOne$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.ByteVec, rt.ByteVec, rt.ByteVec] = [make$conversions_Value_Vec_u8(data, 0), make$conversions_Value_Vec_u8(data, 3), make$conversions_Value_Vec_u8(data, 6)]; - let a: rt.ByteVec = _6[0]; - const b: rt.ByteVec = _6[1]; - let c: rt.ByteVec = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); - const s: rt.ByteVec[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - put$conversions_Value_Vec_u8(rt.sliceReplace(s, 0, make$conversions_Value_Vec_u8(data, 5)), out); +export function lentOne$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.ByteVec, rs.ByteVec, rs.ByteVec] = [make$conversions_Value_Vec_u8(data, 0), make$conversions_Value_Vec_u8(data, 3), make$conversions_Value_Vec_u8(data, 6)]; + let a: rs.ByteVec = _6[0]; + const b: rs.ByteVec = _6[1]; + let c: rs.ByteVec = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_Vec_u8(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_Vec_u8(data, 2), make$conversions_Value_Vec_u8(data, 4)]); + const s: rs.ByteVec[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + put$conversions_Value_Vec_u8(rs.sliceReplace(s, 0, make$conversions_Value_Vec_u8(data, 5)), out); put$conversions_Value_Vec_u8(a, out); const borrowed = held; - put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Vec_u8(data, 7)), out); + put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_Vec_u8(data, 7)), out); put$conversions_Value_Vec_u8(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u8(data, 8)), out); - put$conversions_Value_Vec_u8(v.items[rt.idx(v.items, 1)], out); - rt.sliceFill(rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)), rt.byteVecFrom(rt.byteVecView(b)), (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); - }, undefined, rt.byteVecCloneFromFn()); - for (const _61 of rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))) { + put$conversions_Value_Vec_u8(writeFirst$Vec_u8(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_Vec_u8(data, 8)), out); + put$conversions_Value_Vec_u8(v.items[rs.idx(v.items, 1)], out); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), rs.byteVecFrom(rs.byteVecView(b)), (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); + }, undefined, rs.byteVecCloneFromFn()); + for (const _61 of rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))) { Object.assign(_61, make$conversions_Value_Vec_u8(data, 9)); } put$conversions_Value_Vec_u8(c, out); @@ -4221,99 +4221,99 @@ export function lentOne$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Uint8Array, Uint8Array, Uint8Array] = [copy$array_u8(make$conversions_Value_array0_u8(data, 0)), copy$array_u8(make$conversions_Value_array0_u8(data, 3)), copy$array_u8(make$conversions_Value_array0_u8(data, 6))]; const a: Uint8Array = _6[0]; const b: Uint8Array = _6[1]; const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array0_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a))); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - rt.byteSliceFrom(s[0]); - put$conversions_Value_array0_u8(rt.byteSliceFrom(copy$array_u8(make$conversions_Value_array0_u8(data, 5))), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(writeFirst$array0_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), make$conversions_Value_array0_u8(data, 7))), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(writeFirst$array0_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]))), make$conversions_Value_array0_u8(data, 8))), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - rt.sliceFill(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(c))), copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))), copy$array_u8); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a)))), rt.byteSliceFrom); + const v: rs.Vec = rs.vecFrom(copy$array_array0_u8([make$conversions_Value_array0_u8(data, 2), make$conversions_Value_array0_u8(data, 4)]).map(copy$array_u8)); + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + rs.byteSliceFrom(s[0]); + put$conversions_Value_array0_u8(rs.byteSliceFrom(copy$array_u8(make$conversions_Value_array0_u8(data, 5))), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array0_u8(data, 7))), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(writeFirst$array0_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array0_u8(data, 8))), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); while (true) { - const _61: rt.ByteSlice | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.ByteSlice | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.data.set(copy$array_u8(make$conversions_Value_array0_u8(data, 9)), _61.start); } - put$conversions_Value_array0_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array0_u8(rt.byteSliceFrom(a), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array0_u8(rs.byteSliceFrom(a), out); } /** * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Uint8Array, Uint8Array, Uint8Array] = [copy$array_u8(make$conversions_Value_array1_u8(data, 0)), copy$array_u8(make$conversions_Value_array1_u8(data, 3)), copy$array_u8(make$conversions_Value_array1_u8(data, 6))]; const a: Uint8Array = _6[0]; const b: Uint8Array = _6[1]; const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array1_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a))); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _23: rt.ByteSlice = rt.byteSliceFrom(s[0]); + const v: rs.Vec = rs.vecFrom(copy$array_array1_u8([make$conversions_Value_array1_u8(data, 2), make$conversions_Value_array1_u8(data, 4)]).map(copy$array_u8)); + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _23: rs.ByteSlice = rs.byteSliceFrom(s[0]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array1_u8(data, 5)); - const old4 = rt.byteSliceToArray(_23); + const old4 = rs.byteSliceToArray(_23); _23.data.set(_28, _23.start); - put$conversions_Value_array1_u8(rt.byteSliceFrom(old4), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(writeFirst$array1_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), make$conversions_Value_array1_u8(data, 7))), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(writeFirst$array1_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]))), make$conversions_Value_array1_u8(data, 8))), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - rt.sliceFill(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(c))), copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))), copy$array_u8); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a)))), rt.byteSliceFrom); + put$conversions_Value_array1_u8(rs.byteSliceFrom(old4), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array1_u8(data, 7))), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(writeFirst$array1_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array1_u8(data, 8))), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); while (true) { - const _61: rt.ByteSlice | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.ByteSlice | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.data.set(copy$array_u8(make$conversions_Value_array1_u8(data, 9)), _61.start); } - put$conversions_Value_array1_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array1_u8(rt.byteSliceFrom(a), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array1_u8(rs.byteSliceFrom(a), out); } /** * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[], rt.u32[]] = [copy$array_u32(make$conversions_Value_array2_u32(data, 0)), copy$array_u32(make$conversions_Value_array2_u32(data, 3)), copy$array_u32(make$conversions_Value_array2_u32(data, 6))]; - let a: rt.u32[] = _6[0]; - const b: rt.u32[] = _6[1]; - let c: rt.u32[] = _6[2]; - const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); - const s: rt.u32[][] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - put$conversions_Value_array2_u32(rt.sliceReplace(s, 0, copy$array_u32(make$conversions_Value_array2_u32(data, 5))), out); +export function lentOne$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[], rs.u32[]] = [copy$array_u32(make$conversions_Value_array2_u32(data, 0)), copy$array_u32(make$conversions_Value_array2_u32(data, 3)), copy$array_u32(make$conversions_Value_array2_u32(data, 6))]; + let a: rs.u32[] = _6[0]; + const b: rs.u32[] = _6[1]; + let c: rs.u32[] = _6[2]; + const held: Held.Held = new Held.Held(copy$array_u32(make$conversions_Value_array2_u32(data, 1))); + const v: rs.Vec = rs.vecFrom(copy$array_array2_u32([make$conversions_Value_array2_u32(data, 2), make$conversions_Value_array2_u32(data, 4)]).map(copy$array_u32)); + const s: rs.u32[][] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + put$conversions_Value_array2_u32(rs.sliceReplace(s, 0, copy$array_u32(make$conversions_Value_array2_u32(data, 5))), out); put$conversions_Value_array2_u32(a, out); const borrowed = held; - put$conversions_Value_array2_u32(writeFirst$array2_u32(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_array2_u32(data, 7)), out); + put$conversions_Value_array2_u32(writeFirst$array2_u32(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_array2_u32(data, 7)), out); put$conversions_Value_array2_u32(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_array2_u32(writeFirst$array2_u32(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_array2_u32(data, 8)), out); - put$conversions_Value_array2_u32(v.items[rt.idx(v.items, 1)], out); - rt.sliceFill(rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)), copy$array_u32(copy$array_u32(b)), copy$array_u32); - for (const _61 of rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))) { + put$conversions_Value_array2_u32(writeFirst$array2_u32(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_array2_u32(data, 8)), out); + put$conversions_Value_array2_u32(v.items[rs.idx(v.items, 1)], out); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), copy$array_u32(copy$array_u32(b)), copy$array_u32); + for (const _61 of rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))) { Object.assign(_61, copy$array_u32(make$conversions_Value_array2_u32(data, 9))); } put$conversions_Value_array2_u32(c, out); @@ -4324,105 +4324,105 @@ export function lentOne$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Uint8Array, Uint8Array, Uint8Array] = [copy$array_u8(make$conversions_Value_array3_u8(data, 0)), copy$array_u8(make$conversions_Value_array3_u8(data, 3)), copy$array_u8(make$conversions_Value_array3_u8(data, 6))]; const a: Uint8Array = _6[0]; const b: Uint8Array = _6[1]; const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array3_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a))); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _23: rt.ByteSlice = rt.byteSliceFrom(s[0]); + const v: rs.Vec = rs.vecFrom(copy$array_array3_u8([make$conversions_Value_array3_u8(data, 2), make$conversions_Value_array3_u8(data, 4)]).map(copy$array_u8)); + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _23: rs.ByteSlice = rs.byteSliceFrom(s[0]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array3_u8(data, 5)); - const old4 = rt.byteSliceToArray(_23); + const old4 = rs.byteSliceToArray(_23); _23.data.set(_28, _23.start); - put$conversions_Value_array3_u8(rt.byteSliceFrom(old4), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(writeFirst$array3_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), make$conversions_Value_array3_u8(data, 7))), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(writeFirst$array3_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]))), make$conversions_Value_array3_u8(data, 8))), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - rt.sliceFill(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(c))), copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))), copy$array_u8); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a)))), rt.byteSliceFrom); + put$conversions_Value_array3_u8(rs.byteSliceFrom(old4), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array3_u8(data, 7))), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(writeFirst$array3_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array3_u8(data, 8))), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); while (true) { - const _61: rt.ByteSlice | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.ByteSlice | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.data.set(copy$array_u8(make$conversions_Value_array3_u8(data, 9)), _61.start); } - put$conversions_Value_array3_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array3_u8(rt.byteSliceFrom(a), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array3_u8(rs.byteSliceFrom(a), out); } /** * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Uint8Array, Uint8Array, Uint8Array] = [copy$array_u8(make$conversions_Value_array40_u8(data, 0)), copy$array_u8(make$conversions_Value_array40_u8(data, 3)), copy$array_u8(make$conversions_Value_array40_u8(data, 6))]; const a: Uint8Array = _6[0]; const b: Uint8Array = _6[1]; const c: Uint8Array = _6[2]; const held: Held.Held = new Held.Held(copy$array_u8(make$conversions_Value_array40_u8(data, 1))); - const v: rt.Vec = rt.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); - const s: Uint8Array[] = rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a))); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _23: rt.ByteSlice = rt.byteSliceFrom(s[0]); + const v: rs.Vec = rs.vecFrom(copy$array_array40_u8([make$conversions_Value_array40_u8(data, 2), make$conversions_Value_array40_u8(data, 4)]).map(copy$array_u8)); + const s: Uint8Array[] = rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a))); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _23: rs.ByteSlice = rs.byteSliceFrom(s[0]); const _28: Uint8Array = copy$array_u8(make$conversions_Value_array40_u8(data, 5)); - const old4 = rt.byteSliceToArray(_23); + const old4 = rs.byteSliceToArray(_23); _23.data.set(_28, _23.start); - put$conversions_Value_array40_u8(rt.byteSliceFrom(old4), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(writeFirst$array40_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(held.value))), make$conversions_Value_array40_u8(data, 7))), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(held.value), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(writeFirst$array40_u8(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]))), make$conversions_Value_array40_u8(data, 8))), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(v.items[rt.idx(v.items, 1)]), out); - rt.sliceFill(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(c))), copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(b))), copy$array_u8); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(rt.sliceIn(rt.byteSliceView(rt.byteSliceFrom(a)))), rt.byteSliceFrom); + put$conversions_Value_array40_u8(rs.byteSliceFrom(old4), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(held.value))), make$conversions_Value_array40_u8(data, 7))), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(held.value), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(writeFirst$array40_u8(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]))), make$conversions_Value_array40_u8(data, 8))), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(v.items[rs.idx(v.items, 1)]), out); + rs.sliceFill(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(c))), copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(b))), copy$array_u8); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(rs.sliceIn(rs.byteSliceView(rs.byteSliceFrom(a)))), rs.byteSliceFrom); while (true) { - const _61: rt.ByteSlice | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.ByteSlice | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.data.set(copy$array_u8(make$conversions_Value_array40_u8(data, 9)), _61.start); } - put$conversions_Value_array40_u8(rt.byteSliceFrom(c), out); - put$conversions_Value_array40_u8(rt.byteSliceFrom(a), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(c), out); + put$conversions_Value_array40_u8(rs.byteSliceFrom(a), out); } /** * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Logged.Logged, Logged.Logged, Logged.Logged] = [Logged.make$conversions_Value(data, 0), Logged.make$conversions_Value(data, 3), Logged.make$conversions_Value(data, 6)]; let a: Logged.Logged = _6[0]; const b: Logged.Logged = _6[1]; let c: Logged.Logged = _6[2]; const held: Held.Held = new Held.Held(Logged.make$conversions_Value(data, 1)); - const v: rt.Vec = rt.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); - const s: Logged.Logged[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const old: Logged.Logged = rt.sliceReplace(s, 0, Logged.make$conversions_Value(data, 5)); + const v: rs.Vec = rs.vecFrom([Logged.make$conversions_Value(data, 2), Logged.make$conversions_Value(data, 4)]); + const s: Logged.Logged[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const old: Logged.Logged = rs.sliceReplace(s, 0, Logged.make$conversions_Value(data, 5)); Logged.put$conversions_Value(old, out); Logged.put$conversions_Value(a, out); const borrowed = held; - const old2: Logged.Logged = writeFirst$conversions_Logged(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), Logged.make$conversions_Value(data, 7)); + const old2: Logged.Logged = writeFirst$conversions_Logged(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), Logged.make$conversions_Value(data, 7)); Logged.put$conversions_Value(old2, out); Logged.put$conversions_Value(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - const old3: Logged.Logged = writeFirst$conversions_Logged(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Logged.make$conversions_Value(data, 8)); + const old3: Logged.Logged = writeFirst$conversions_Logged(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Logged.make$conversions_Value(data, 8)); Logged.put$conversions_Value(old3, out); - Logged.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); - rt.sliceFill(rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)), Logged.clone$Clone(b), Logged.clone$Clone, rt.drop); - for (const _61 of rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))) { + Logged.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), Logged.clone$Clone(b), Logged.clone$Clone, rs.drop); + for (const _61 of rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))) { const _65: Logged.Logged = Logged.make$conversions_Value(data, 9); _61[Symbol.dispose](); Object.assign(_61, _65); @@ -4432,7 +4432,7 @@ export function lentOne$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): old3[Symbol.dispose](); old2[Symbol.dispose](); old[Symbol.dispose](); - rt.dropVec(v); + rs.dropVec(v); held[Symbol.dispose](); c[Symbol.dispose](); b[Symbol.dispose](); @@ -4443,28 +4443,28 @@ export function lentOne$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lentOne$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { const _6: [Named.Named, Named.Named, Named.Named] = [Named.make$conversions_Value(data, 0), Named.make$conversions_Value(data, 3), Named.make$conversions_Value(data, 6)]; let a: Named.Named = _6[0]; const b: Named.Named = _6[1]; let c: Named.Named = _6[2]; const held: Held.Held = new Held.Held(Named.make$conversions_Value(data, 1)); - const v: rt.Vec = rt.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); - const s: Named.Named[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - Named.put$conversions_Value(rt.sliceReplace(s, 0, Named.make$conversions_Value(data, 5)), out); + const v: rs.Vec = rs.vecFrom([Named.make$conversions_Value(data, 2), Named.make$conversions_Value(data, 4)]); + const s: Named.Named[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + Named.put$conversions_Value(rs.sliceReplace(s, 0, Named.make$conversions_Value(data, 5)), out); Named.put$conversions_Value(a, out); const borrowed = held; - Named.put$conversions_Value(writeFirst$conversions_Named(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), Named.make$conversions_Value(data, 7)), out); + Named.put$conversions_Value(writeFirst$conversions_Named(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), Named.make$conversions_Value(data, 7)), out); Named.put$conversions_Value(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - Named.put$conversions_Value(writeFirst$conversions_Named(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Named.make$conversions_Value(data, 8)), out); - Named.put$conversions_Value(v.items[rt.idx(v.items, 1)], out); - rt.sliceFill(rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)), Named.clone$Clone(b), Named.clone$Clone); - for (const _61 of rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))) { + Named.put$conversions_Value(writeFirst$conversions_Named(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), Named.make$conversions_Value(data, 8)), out); + Named.put$conversions_Value(v.items[rs.idx(v.items, 1)], out); + rs.sliceFill(rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)), Named.clone$Clone(b), Named.clone$Clone); + for (const _61 of rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))) { Object.assign(_61, Named.make$conversions_Value(data, 9)); } Named.put$conversions_Value(c, out); @@ -4475,34 +4475,34 @@ export function lentOne$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$u32(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.u32, rt.u32, rt.u32] = [make$conversions_Value_u32(data, 0), make$conversions_Value_u32(data, 3), make$conversions_Value_u32(data, 6)]; - let a: rt.u32 = _6[0]; - const b: rt.u32 = _6[1]; - let c: rt.u32 = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); - const s: rt.u32[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _28: rt.u32 = make$conversions_Value_u32(data, 5); +export function lentOne$u32(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.u32, rs.u32, rs.u32] = [make$conversions_Value_u32(data, 0), make$conversions_Value_u32(data, 3), make$conversions_Value_u32(data, 6)]; + let a: rs.u32 = _6[0]; + const b: rs.u32 = _6[1]; + let c: rs.u32 = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_u32(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u32(data, 2), make$conversions_Value_u32(data, 4)]); + const s: rs.u32[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _28: rs.u32 = make$conversions_Value_u32(data, 5); const old4 = s[0]; s[0] = _28; put$conversions_Value_u32(old4, out); put$conversions_Value_u32(a, out); const borrowed = held; - put$conversions_Value_u32(writeFirst$u32(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_u32(data, 7)), out); + put$conversions_Value_u32(writeFirst$u32(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_u32(data, 7)), out); put$conversions_Value_u32(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_u32(writeFirst$u32(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u32(data, 8)), out); - put$conversions_Value_u32(v.items[rt.idx(v.items, 1)], out); - rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)).fill(b); - const iter: rt.Iter> = rt.iterSliceMut(rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))); + put$conversions_Value_u32(writeFirst$u32(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u32(data, 8)), out); + put$conversions_Value_u32(v.items[rs.idx(v.items, 1)], out); + rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)).fill(b); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { - const _61: rt.Place | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.Place | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.v = make$conversions_Value_u32(data, 9); @@ -4515,34 +4515,34 @@ export function lentOne$u32(data: rt.ByteSlice, out: rt.ByteVec): void { * Slices and arrays of one value of a local, a field, and an element, written through as * a whole, the old value read out, and through std's slice methods. */ -export function lentOne$u64(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.u64, rt.u64, rt.u64] = [make$conversions_Value_u64(data, 0), make$conversions_Value_u64(data, 3), make$conversions_Value_u64(data, 6)]; - let a: rt.u64 = _6[0]; - const b: rt.u64 = _6[1]; - let c: rt.u64 = _6[2]; - const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); - const v: rt.Vec = rt.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); - const s: rt.u64[] = rt.sliceOfPlace(rt.place(() => a, (value) => a = value)); - rt.byteVecPush(out, s.length & 0xff); - rt.idx(s, 0); - const _28: rt.u64 = make$conversions_Value_u64(data, 5); +export function lentOne$u64(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.u64, rs.u64, rs.u64] = [make$conversions_Value_u64(data, 0), make$conversions_Value_u64(data, 3), make$conversions_Value_u64(data, 6)]; + let a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; + let c: rs.u64 = _6[2]; + const held: Held.Held = new Held.Held(make$conversions_Value_u64(data, 1)); + const v: rs.Vec = rs.vecFrom([make$conversions_Value_u64(data, 2), make$conversions_Value_u64(data, 4)]); + const s: rs.u64[] = rs.sliceOfPlace(rs.place(() => a, (value) => a = value)); + rs.byteVecPush(out, s.length & 0xff); + rs.idx(s, 0); + const _28: rs.u64 = make$conversions_Value_u64(data, 5); const old4 = s[0]; s[0] = _28; put$conversions_Value_u64(old4, out); put$conversions_Value_u64(a, out); const borrowed = held; - put$conversions_Value_u64(writeFirst$u64(rt.sliceOfPlace(rt.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_u64(data, 7)), out); + put$conversions_Value_u64(writeFirst$u64(rs.sliceOfPlace(rs.place(() => borrowed.value, (value2) => borrowed.value = value2)), make$conversions_Value_u64(data, 7)), out); put$conversions_Value_u64(held.value, out); - const at = rt.idx(v.items, 1); + const at = rs.idx(v.items, 1); const borrowed2 = v.items; const borrowed3 = at; - put$conversions_Value_u64(writeFirst$u64(rt.sliceOfPlace(rt.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u64(data, 8)), out); - put$conversions_Value_u64(v.items[rt.idx(v.items, 1)], out); - rt.sliceOfPlace(rt.place(() => c, (value4) => c = value4)).fill(b); - const iter: rt.Iter> = rt.iterSliceMut(rt.sliceOfPlace(rt.place(() => a, (value5) => a = value5))); + put$conversions_Value_u64(writeFirst$u64(rs.sliceOfPlace(rs.place(() => borrowed2[borrowed3], (value3) => borrowed2[borrowed3] = value3)), make$conversions_Value_u64(data, 8)), out); + put$conversions_Value_u64(v.items[rs.idx(v.items, 1)], out); + rs.sliceOfPlace(rs.place(() => c, (value4) => c = value4)).fill(b); + const iter: rs.Iter> = rs.iterSliceMut(rs.sliceOfPlace(rs.place(() => a, (value5) => a = value5))); while (true) { - const _61: rt.Place | rt.Done = iter.next(); - if (_61 === rt.DONE) { + const _61: rs.Place | rs.Done = iter.next(); + if (_61 === rs.DONE) { break; } _61.v = make$conversions_Value_u64(data, 9); @@ -4556,52 +4556,52 @@ export function lentOne$u64(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.u16 | undefined => { +export function searched$Option_u16(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u16 | undefined => { return make$conversions_Value_Option_u16(data, i2); }), undefined, 4, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpOption(rt.cmp)), 4, true); - const tagged: rt.Vec<[rt.u16 | undefined, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterCloned(rt.iterSlice(v.items)), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 6, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpOption(rs.cmp)), 4, true); + const tagged: rs.Vec<[rs.u16 | undefined, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 6, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Array = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.u16 | undefined, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Array = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.u16 | undefined, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.u16 | undefined = make$conversions_Value_Option_u16(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmpOption(rt.cmp)), rt.sliceBinarySearchBy(s, (e: rt.u16 | undefined): rt.Ordering => { + const x: rs.u16 | undefined = make$conversions_Value_Option_u16(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpOption(rs.cmp)), rs.sliceBinarySearchBy(s, (e: rs.u16 | undefined): rs.Ordering => { put$conversions_Value_Option_u16(e, out); - return rt.cmpOption(rt.cmp)(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.u16 | undefined, rt.u8]): rt.u16 | undefined => { - rt.byteVecPush(out, _2[1]); + return rs.cmpOption(rs.cmp)(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u16 | undefined, rs.u8]): rs.u16 | undefined => { + rs.byteVecPush(out, _2[1]); return _2[0]; - }, rt.cmpOption(rt.cmp)), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.u16 | undefined): boolean => { + }, rs.cmpOption(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.u16 | undefined): boolean => { put$conversions_Value_Option_u16(e2, out); - return rt.cmpOption(rt.cmp)(e2, x) === -1; + return rs.cmpOption(rs.cmp)(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4612,52 +4612,52 @@ export function searched$Option_u16(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$String(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): string => { +export function searched$String(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): string => { return make$conversions_Value_String(data, i2); }), undefined, 12, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpStr), 12, true); - const tagged: rt.Vec<[string, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterCloned(rt.iterSlice(v.items)), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 16, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpStr), 12, true); + const tagged: rs.Vec<[string, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: string[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [string, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: string[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [string, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: string = make$conversions_Value_String(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmpStr), rt.sliceBinarySearchBy(s, (e: string): rt.Ordering => { + const x: string = make$conversions_Value_String(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpStr), rs.sliceBinarySearchBy(s, (e: string): rs.Ordering => { put$conversions_Value_String(e, out); - return rt.cmpStr(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [string, rt.u8]): string => { - rt.byteVecPush(out, _2[1]); + return rs.cmpStr(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [string, rs.u8]): string => { + rs.byteVecPush(out, _2[1]); return _2[0]; - }, rt.cmpStr), rt.Ok(rt.slicePartitionPoint(s, (e2: string): boolean => { + }, rs.cmpStr), rs.Ok(rs.slicePartitionPoint(s, (e2: string): boolean => { put$conversions_Value_String(e2, out); - return rt.cmpStr(e2, x) === -1; + return rs.cmpStr(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4668,54 +4668,54 @@ export function searched$String(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.Vec => { +export function searched$Vec_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.Vec => { return make$conversions_Value_Vec_u32(data, i2); }), undefined, 12, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpSlice(rt.cmp)), 12, true); - const tagged: rt.Vec<[rt.Vec, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterSlice(v.items), (a0: rt.Vec): rt.Vec => { - return rt.vecFrom(a0.items.slice()); - }), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 16, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpSlice(rs.cmp)), 12, true); + const tagged: rs.Vec<[rs.Vec, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), (a0: rs.Vec): rs.Vec => { + return rs.vecFrom(a0.items.slice()); + }), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: rt.Vec[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.Vec, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: rs.Vec[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.Vec, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.Vec = make$conversions_Value_Vec_u32(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmpSlice(rt.cmp)), rt.sliceBinarySearchBy(s, (e: rt.Vec): rt.Ordering => { + const x: rs.Vec = make$conversions_Value_Vec_u32(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(s, (e: rs.Vec): rs.Ordering => { put$conversions_Value_Vec_u32(e, out); - return rt.cmpSlice(rt.cmp)(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.Vec, rt.u8]): rt.Vec => { - rt.byteVecPush(out, _2[1]); - return rt.vecFrom(_2[0].items.slice()); - }, rt.cmpSlice(rt.cmp)), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.Vec): boolean => { + return rs.cmpSlice(rs.cmp)(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.Vec, rs.u8]): rs.Vec => { + rs.byteVecPush(out, _2[1]); + return rs.vecFrom(_2[0].items.slice()); + }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.Vec): boolean => { put$conversions_Value_Vec_u32(e2, out); - return rt.cmpSlice(rt.cmp)(e2, x) === -1; + return rs.cmpSlice(rs.cmp)(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4726,54 +4726,54 @@ export function searched$Vec_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.ByteVec => { +export function searched$Vec_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.ByteVec => { return make$conversions_Value_Vec_u8(data, i2); }), undefined, 12, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpBytes), 12, true); - const tagged: rt.Vec<[rt.ByteVec, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterSlice(v.items), (a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); - }), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 16, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpBytes), 12, true); + const tagged: rs.Vec<[rs.ByteVec, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), (a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); + }), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: rt.ByteVec[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.ByteVec, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: rs.ByteVec[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.ByteVec, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.ByteVec = make$conversions_Value_Vec_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmpBytes), rt.sliceBinarySearchBy(s, (e: rt.ByteVec): rt.Ordering => { + const x: rs.ByteVec = make$conversions_Value_Vec_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpBytes), rs.sliceBinarySearchBy(s, (e: rs.ByteVec): rs.Ordering => { put$conversions_Value_Vec_u8(e, out); - return rt.cmpBytes(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.ByteVec, rt.u8]): rt.ByteVec => { - rt.byteVecPush(out, _2[1]); - return rt.byteVecFrom(rt.byteVecView(_2[0])); - }, rt.cmpBytes), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.ByteVec): boolean => { + return rs.cmpBytes(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.ByteVec, rs.u8]): rs.ByteVec => { + rs.byteVecPush(out, _2[1]); + return rs.byteVecFrom(rs.byteVecView(_2[0])); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.ByteVec): boolean => { put$conversions_Value_Vec_u8(e2, out); - return rt.cmpBytes(e2, x) === -1; + return rs.cmpBytes(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4784,57 +4784,57 @@ export function searched$Vec_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Uint8Array => { +export function searched$array0_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array0_u8(data, i2); }), undefined, 0, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpBytes), 0, true); - const tagged: rt.Vec<[Uint8Array, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterLend(rt.iterSlice(v.items), rt.byteSliceFrom), rt.byteSliceToArray), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 1, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpBytes), 0, true); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 1, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Uint8Array[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Uint8Array, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Uint8Array[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Uint8Array, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Uint8Array = make$conversions_Value_array0_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const _59: rt.ByteSlice = rt.byteSliceFrom(x); - const _58: (a0: rt.ByteSlice) => rt.Ordering = (e: rt.ByteSlice): rt.Ordering => { + const x: Uint8Array = make$conversions_Value_array0_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _59: rs.ByteSlice = rs.byteSliceFrom(x); + const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array0_u8(e, out); - return rt.cmpBytes(e, _59); + return rs.cmpBytes(e, _59); }; - const _66: rt.ByteSlice = rt.byteSliceFrom(x); - const _65: (a0: rt.ByteSlice) => boolean = (e3: rt.ByteSlice): boolean => { + const _66: rs.ByteSlice = rs.byteSliceFrom(x); + const _65: (a0: rs.ByteSlice) => boolean = (e3: rs.ByteSlice): boolean => { put$conversions_Value_array0_u8(e3, out); - return rt.cmpBytes(e3, _66) === -1; + return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, rt.byteSliceView(rt.byteSliceFrom(x)), rt.cmpBytes), rt.sliceBinarySearchBy(s, (held) => _58(rt.byteSliceFrom(held))), rt.sliceBinarySearchByKey(t, rt.byteSliceView(rt.byteSliceFrom(x)), (_2: [Uint8Array, rt.u8]): Uint8Array => { - const e2: rt.ByteSlice = rt.byteSliceFrom(_2[0]); - rt.byteVecPush(out, _2[1]); - return rt.byteSliceToArray(e2); - }, rt.cmpBytes), rt.Ok(rt.slicePartitionPoint(s, (held2) => _65(rt.byteSliceFrom(held2))))]); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); + rs.byteVecPush(out, _2[1]); + return rs.byteSliceToArray(e2); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4845,57 +4845,57 @@ export function searched$array0_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Uint8Array => { +export function searched$array1_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array1_u8(data, i2); }), undefined, 1, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpBytes), 1, true); - const tagged: rt.Vec<[Uint8Array, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterLend(rt.iterSlice(v.items), rt.byteSliceFrom), rt.byteSliceToArray), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 2, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpBytes), 1, true); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 2, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Uint8Array[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Uint8Array, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Uint8Array[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Uint8Array, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Uint8Array = make$conversions_Value_array1_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const _59: rt.ByteSlice = rt.byteSliceFrom(x); - const _58: (a0: rt.ByteSlice) => rt.Ordering = (e: rt.ByteSlice): rt.Ordering => { + const x: Uint8Array = make$conversions_Value_array1_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _59: rs.ByteSlice = rs.byteSliceFrom(x); + const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array1_u8(e, out); - return rt.cmpBytes(e, _59); + return rs.cmpBytes(e, _59); }; - const _66: rt.ByteSlice = rt.byteSliceFrom(x); - const _65: (a0: rt.ByteSlice) => boolean = (e3: rt.ByteSlice): boolean => { + const _66: rs.ByteSlice = rs.byteSliceFrom(x); + const _65: (a0: rs.ByteSlice) => boolean = (e3: rs.ByteSlice): boolean => { put$conversions_Value_array1_u8(e3, out); - return rt.cmpBytes(e3, _66) === -1; + return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, rt.byteSliceView(rt.byteSliceFrom(x)), rt.cmpBytes), rt.sliceBinarySearchBy(s, (held) => _58(rt.byteSliceFrom(held))), rt.sliceBinarySearchByKey(t, rt.byteSliceView(rt.byteSliceFrom(x)), (_2: [Uint8Array, rt.u8]): Uint8Array => { - const e2: rt.ByteSlice = rt.byteSliceFrom(_2[0]); - rt.byteVecPush(out, _2[1]); - return rt.byteSliceToArray(e2); - }, rt.cmpBytes), rt.Ok(rt.slicePartitionPoint(s, (held2) => _65(rt.byteSliceFrom(held2))))]); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); + rs.byteVecPush(out, _2[1]); + return rs.byteSliceToArray(e2); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4906,52 +4906,52 @@ export function searched$array1_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.u32[] => { +export function searched$array2_u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u32[] => { return make$conversions_Value_array2_u32(data, i2); }), undefined, 8, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpSlice(rt.cmp)), 8, true); - const tagged: rt.Vec<[rt.u32[], rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterSlice(v.items), copy$array_u32), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 12, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpSlice(rs.cmp)), 8, true); + const tagged: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), copy$array_u32), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 12, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: rt.u32[][] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.u32[], rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: rs.u32[][] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.u32[], rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.u32[] = make$conversions_Value_array2_u32(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmpSlice(rt.cmp)), rt.sliceBinarySearchBy(s, (e: rt.u32[]): rt.Ordering => { + const x: rs.u32[] = make$conversions_Value_array2_u32(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmpSlice(rs.cmp)), rs.sliceBinarySearchBy(s, (e: rs.u32[]): rs.Ordering => { put$conversions_Value_array2_u32(e, out); - return rt.cmpSlice(rt.cmp)(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.u32[], rt.u8]): rt.u32[] => { - rt.byteVecPush(out, _2[1]); + return rs.cmpSlice(rs.cmp)(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u32[], rs.u8]): rs.u32[] => { + rs.byteVecPush(out, _2[1]); return copy$array_u32(_2[0]); - }, rt.cmpSlice(rt.cmp)), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.u32[]): boolean => { + }, rs.cmpSlice(rs.cmp)), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.u32[]): boolean => { put$conversions_Value_array2_u32(e2, out); - return rt.cmpSlice(rt.cmp)(e2, x) === -1; + return rs.cmpSlice(rs.cmp)(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -4962,57 +4962,57 @@ export function searched$array2_u32(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Uint8Array => { +export function searched$array3_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array3_u8(data, i2); }), undefined, 3, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpBytes), 3, true); - const tagged: rt.Vec<[Uint8Array, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterLend(rt.iterSlice(v.items), rt.byteSliceFrom), rt.byteSliceToArray), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 4, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpBytes), 3, true); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 4, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Uint8Array[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Uint8Array, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Uint8Array[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Uint8Array, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Uint8Array = make$conversions_Value_array3_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const _59: rt.ByteSlice = rt.byteSliceFrom(x); - const _58: (a0: rt.ByteSlice) => rt.Ordering = (e: rt.ByteSlice): rt.Ordering => { + const x: Uint8Array = make$conversions_Value_array3_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _59: rs.ByteSlice = rs.byteSliceFrom(x); + const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array3_u8(e, out); - return rt.cmpBytes(e, _59); + return rs.cmpBytes(e, _59); }; - const _66: rt.ByteSlice = rt.byteSliceFrom(x); - const _65: (a0: rt.ByteSlice) => boolean = (e3: rt.ByteSlice): boolean => { + const _66: rs.ByteSlice = rs.byteSliceFrom(x); + const _65: (a0: rs.ByteSlice) => boolean = (e3: rs.ByteSlice): boolean => { put$conversions_Value_array3_u8(e3, out); - return rt.cmpBytes(e3, _66) === -1; + return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, rt.byteSliceView(rt.byteSliceFrom(x)), rt.cmpBytes), rt.sliceBinarySearchBy(s, (held) => _58(rt.byteSliceFrom(held))), rt.sliceBinarySearchByKey(t, rt.byteSliceView(rt.byteSliceFrom(x)), (_2: [Uint8Array, rt.u8]): Uint8Array => { - const e2: rt.ByteSlice = rt.byteSliceFrom(_2[0]); - rt.byteVecPush(out, _2[1]); - return rt.byteSliceToArray(e2); - }, rt.cmpBytes), rt.Ok(rt.slicePartitionPoint(s, (held2) => _65(rt.byteSliceFrom(held2))))]); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); + rs.byteVecPush(out, _2[1]); + return rs.byteSliceToArray(e2); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -5023,57 +5023,57 @@ export function searched$array3_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Uint8Array => { +export function searched$array40_u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Uint8Array => { return make$conversions_Value_array40_u8(data, i2); }), undefined, 40, true); - rt.sliceSort(v.items, rt.cmpLt(rt.cmpBytes), 40, true); - const tagged: rt.Vec<[Uint8Array, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterLend(rt.iterSlice(v.items), rt.byteSliceFrom), rt.byteSliceToArray), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 41, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(rs.cmpBytes), 40, true); + const tagged: rs.Vec<[Uint8Array, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterLend(rs.iterSlice(v.items), rs.byteSliceFrom), rs.byteSliceToArray), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 41, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Uint8Array[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Uint8Array, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Uint8Array[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Uint8Array, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Uint8Array = make$conversions_Value_array40_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const _59: rt.ByteSlice = rt.byteSliceFrom(x); - const _58: (a0: rt.ByteSlice) => rt.Ordering = (e: rt.ByteSlice): rt.Ordering => { + const x: Uint8Array = make$conversions_Value_array40_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _59: rs.ByteSlice = rs.byteSliceFrom(x); + const _58: (a0: rs.ByteSlice) => rs.Ordering = (e: rs.ByteSlice): rs.Ordering => { put$conversions_Value_array40_u8(e, out); - return rt.cmpBytes(e, _59); + return rs.cmpBytes(e, _59); }; - const _66: rt.ByteSlice = rt.byteSliceFrom(x); - const _65: (a0: rt.ByteSlice) => boolean = (e3: rt.ByteSlice): boolean => { + const _66: rs.ByteSlice = rs.byteSliceFrom(x); + const _65: (a0: rs.ByteSlice) => boolean = (e3: rs.ByteSlice): boolean => { put$conversions_Value_array40_u8(e3, out); - return rt.cmpBytes(e3, _66) === -1; + return rs.cmpBytes(e3, _66) === -1; }; - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, rt.byteSliceView(rt.byteSliceFrom(x)), rt.cmpBytes), rt.sliceBinarySearchBy(s, (held) => _58(rt.byteSliceFrom(held))), rt.sliceBinarySearchByKey(t, rt.byteSliceView(rt.byteSliceFrom(x)), (_2: [Uint8Array, rt.u8]): Uint8Array => { - const e2: rt.ByteSlice = rt.byteSliceFrom(_2[0]); - rt.byteVecPush(out, _2[1]); - return rt.byteSliceToArray(e2); - }, rt.cmpBytes), rt.Ok(rt.slicePartitionPoint(s, (held2) => _65(rt.byteSliceFrom(held2))))]); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, rs.byteSliceView(rs.byteSliceFrom(x)), rs.cmpBytes), rs.sliceBinarySearchBy(s, (held) => _58(rs.byteSliceFrom(held))), rs.sliceBinarySearchByKey(t, rs.byteSliceView(rs.byteSliceFrom(x)), (_2: [Uint8Array, rs.u8]): Uint8Array => { + const e2: rs.ByteSlice = rs.byteSliceFrom(_2[0]); + rs.byteVecPush(out, _2[1]); + return rs.byteSliceToArray(e2); + }, rs.cmpBytes), rs.Ok(rs.slicePartitionPoint(s, (held2) => _65(rs.byteSliceFrom(held2))))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -5084,58 +5084,58 @@ export function searched$array40_u8(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Logged.Logged => { +export function searched$conversions_Logged(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Logged.Logged => { return Logged.make$conversions_Value(data, i2); }), undefined, 8, true); - rt.sliceSort(v.items, rt.cmpLt(Logged.partialCmp$cmp_PartialOrd), 8, true); - const tagged: rt.Vec<[Logged.Logged, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterSlice(v.items), Logged.clone$Clone), new rt.RangeFrom(0, rt.u8Step), "len", rt.drop), undefined, 12, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(Logged.partialCmp$cmp_PartialOrd), 8, true); + const tagged: rs.Vec<[Logged.Logged, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), Logged.clone$Clone), new rs.RangeFrom(0, rs.u8Step), "len", rs.drop), undefined, 12, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Logged.Logged[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Logged.Logged, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Logged.Logged[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Logged.Logged, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Logged.Logged = Logged.make$conversions_Value(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, Logged.cmp$cmp_Ord), rt.sliceBinarySearchBy(s, (e: Logged.Logged): rt.Ordering => { + const x: Logged.Logged = Logged.make$conversions_Value(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, Logged.cmp$cmp_Ord), rs.sliceBinarySearchBy(s, (e: Logged.Logged): rs.Ordering => { Logged.put$conversions_Value(e, out); return Logged.cmp$cmp_Ord(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [Logged.Logged, rt.u8]): Logged.Logged => { - rt.byteVecPush(out, _2[1]); + }), rs.sliceBinarySearchByKey(t, x, (_2: [Logged.Logged, rs.u8]): Logged.Logged => { + rs.byteVecPush(out, _2[1]); return Logged.clone$Clone(_2[0]); - }, Logged.cmp$cmp_Ord, rt.drop), rt.Ok(rt.slicePartitionPoint(s, (e2: Logged.Logged): boolean => { + }, Logged.cmp$cmp_Ord, rs.drop), rs.Ok(rs.slicePartitionPoint(s, (e2: Logged.Logged): boolean => { Logged.put$conversions_Value(e2, out); return Logged.partialCmp$cmp_PartialOrd(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } x[Symbol.dispose](); } } - rt.dropVec(tagged, drop$tuple2_conversions_Logged_u8); - rt.dropVec(v); + rs.dropVec(tagged, drop$tuple2_conversions_Logged_u8); + rs.dropVec(v); } /** @@ -5143,52 +5143,52 @@ export function searched$conversions_Logged(data: rt.ByteSlice, out: rt.ByteVec) * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): Named.Named => { +export function searched$conversions_Named(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): Named.Named => { return Named.make$conversions_Value(data, i2); }), undefined, 16, true); - rt.sliceSort(v.items, rt.cmpLt(Named.partialCmp$cmp_PartialOrd), 16, true); - const tagged: rt.Vec<[Named.Named, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterMap(rt.iterSlice(v.items), Named.clone$Clone), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 20, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.cmpLt(Named.partialCmp$cmp_PartialOrd), 16, true); + const tagged: rs.Vec<[Named.Named, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterMap(rs.iterSlice(v.items), Named.clone$Clone), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 20, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: Named.Named[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [Named.Named, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: Named.Named[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [Named.Named, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: Named.Named = Named.make$conversions_Value(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, Named.cmp$cmp_Ord), rt.sliceBinarySearchBy(s, (e: Named.Named): rt.Ordering => { + const x: Named.Named = Named.make$conversions_Value(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, Named.cmp$cmp_Ord), rs.sliceBinarySearchBy(s, (e: Named.Named): rs.Ordering => { Named.put$conversions_Value(e, out); return Named.cmp$cmp_Ord(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [Named.Named, rt.u8]): Named.Named => { - rt.byteVecPush(out, _2[1]); + }), rs.sliceBinarySearchByKey(t, x, (_2: [Named.Named, rs.u8]): Named.Named => { + rs.byteVecPush(out, _2[1]); return Named.clone$Clone(_2[0]); - }, Named.cmp$cmp_Ord), rt.Ok(rt.slicePartitionPoint(s, (e2: Named.Named): boolean => { + }, Named.cmp$cmp_Ord), rs.Ok(rs.slicePartitionPoint(s, (e2: Named.Named): boolean => { Named.put$conversions_Value(e2, out); return Named.partialCmp$cmp_PartialOrd(e2, x) === -1; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -5199,52 +5199,52 @@ export function searched$conversions_Named(data: rt.ByteSlice, out: rt.ByteVec): * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$u32(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.u32 => { +export function searched$u32(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u32 => { return make$conversions_Value_u32(data, i2); }), undefined, 4, true); - rt.sliceSort(v.items, rt.lt, 4, true); - const tagged: rt.Vec<[rt.u32, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterCloned(rt.iterSlice(v.items)), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 8, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.lt, 4, true); + const tagged: rs.Vec<[rs.u32, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 8, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: rt.u32[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.u32, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: rs.u32[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.u32, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.u32 = make$conversions_Value_u32(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmp), rt.sliceBinarySearchBy(s, (e: rt.u32): rt.Ordering => { + const x: rs.u32 = make$conversions_Value_u32(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmp), rs.sliceBinarySearchBy(s, (e: rs.u32): rs.Ordering => { put$conversions_Value_u32(e, out); - return rt.cmp(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.u32, rt.u8]): rt.u32 => { - rt.byteVecPush(out, _2[1]); + return rs.cmp(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u32, rs.u8]): rs.u32 => { + rs.byteVecPush(out, _2[1]); return _2[0]; - }, rt.cmp), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.u32): boolean => { + }, rs.cmp), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.u32): boolean => { put$conversions_Value_u32(e2, out); return e2 < x; }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -5255,52 +5255,52 @@ export function searched$u32(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$u64(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.u64 => { +export function searched$u64(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u64 => { return make$conversions_Value_u64(data, i2); }), undefined, 8, true); - rt.sliceSort(v.items, rt.lt, 8, true); - const tagged: rt.Vec<[rt.u64, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterCloned(rt.iterSlice(v.items)), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 16, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.items.length]); + rs.sliceSort(v.items, rs.lt, 8, true); + const tagged: rs.Vec<[rs.u64, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(v.items)), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 16, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.items.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const s: rt.u64[] = rt.sliceRange(v.items, 0, rt.min(_24, v.items.length)); - const t: [rt.u64, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const s: rs.u64[] = rs.sliceRange(v.items, 0, rs.min(_24, v.items.length)); + const t: [rs.u64, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.u64 = make$conversions_Value_u64(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const iter3: rt.Iter> = rt.iterSlice([rt.sliceBinarySearch(s, x, rt.cmp), rt.sliceBinarySearchBy(s, (e: rt.u64): rt.Ordering => { + const x: rs.u64 = make$conversions_Value_u64(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const iter3: rs.Iter> = rs.iterSlice([rs.sliceBinarySearch(s, x, rs.cmp), rs.sliceBinarySearchBy(s, (e: rs.u64): rs.Ordering => { put$conversions_Value_u64(e, out); - return rt.cmp(e, x); - }), rt.sliceBinarySearchByKey(t, x, (_2: [rt.u64, rt.u8]): rt.u64 => { - rt.byteVecPush(out, _2[1]); + return rs.cmp(e, x); + }), rs.sliceBinarySearchByKey(t, x, (_2: [rs.u64, rs.u8]): rs.u64 => { + rs.byteVecPush(out, _2[1]); return _2[0]; - }, rt.cmp), rt.Ok(rt.slicePartitionPoint(s, (e2: rt.u64): boolean => { + }, rs.cmp), rs.Ok(rs.slicePartitionPoint(s, (e2: rs.u64): boolean => { put$conversions_Value_u64(e2, out); - return rt.u64Lt(e2, x); + return rs.u64Lt(e2, x); }))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } @@ -5311,104 +5311,104 @@ export function searched$u64(data: rt.ByteSlice, out: rt.ByteVec): void { * repeat: `Ok` or `Err` as a byte, then the index. Then the same by a closure that logs * each element it probes, by a key that logs each index it probes, and `partition_point`. */ -export function searched$u8(data: rt.ByteSlice, out: rt.ByteVec): void { - let _45!: rt.usize; - let _75!: [rt.u8, rt.usize]; - const v: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, rt.min(data.length, 24)), (i2: rt.usize): rt.u8 => { +export function searched$u8(data: rs.ByteSlice, out: rs.ByteVec): void { + let _45!: rs.usize; + let _75!: [rs.u8, rs.usize]; + const v: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, rs.min(data.length, 24)), (i2: rs.usize): rs.u8 => { return make$conversions_Value_u8(data, i2); }), undefined, true); - rt.byteSliceView(rt.byteVecSlice(v)).sort(); - const tagged: rt.Vec<[rt.u8, rt.u8]> = rt.iterToVec(rt.iterZip(rt.iterCloned(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v)))), new rt.RangeFrom(0, rt.u8Step), "len"), undefined, 2, true); - const iter: rt.Iter = rt.iterSlice([0, 1, 2, 3, v.length]); + rs.byteSliceView(rs.byteVecSlice(v)).sort(); + const tagged: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterZip(rs.iterCloned(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v)))), new rs.RangeFrom(0, rs.u8Step), "len"), undefined, 2, true); + const iter: rs.Iter = rs.iterSlice([0, 1, 2, 3, v.length]); l1: while (true) { - const _24: rt.usize | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.usize | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const part = rt.min(_24, v.length); - const s: rt.ByteSlice = rt.byteSliceRange(rt.byteVecSlice(v), 0, part); - const t: [rt.u8, rt.u8][] = rt.sliceRange(tagged.items, 0, s.length); - const _40: rt.usize = rt.usizeAdd(rt.min(data.length, 8), 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _40; + const part = rs.min(_24, v.length); + const s: rs.ByteSlice = rs.byteSliceRange(rs.byteVecSlice(v), 0, part); + const t: [rs.u8, rs.u8][] = rs.sliceRange(tagged.items, 0, s.length); + const _40: rs.usize = rs.usizeAdd(rs.min(data.length, 8), 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _40; while (true) { if (!((_45 = iterStart++) < iterEnd)) { continue l1; } - const x: rt.u8 = make$conversions_Value_u8(data, rt.usizeAdd(rt.usizeMul(_45, 2), 1)); - const _55: rt.Result = rt.sliceBinarySearch(rt.byteSliceView(s), x, rt.cmp); - const _58: (a0: rt.u8) => rt.Ordering = (e: rt.u8): rt.Ordering => { + const x: rs.u8 = make$conversions_Value_u8(data, rs.usizeAdd(rs.usizeMul(_45, 2), 1)); + const _55: rs.Result = rs.sliceBinarySearch(rs.byteSliceView(s), x, rs.cmp); + const _58: (a0: rs.u8) => rs.Ordering = (e: rs.u8): rs.Ordering => { put$conversions_Value_u8(e, out); - return rt.cmp(e, x); + return rs.cmp(e, x); }; - const _57: rt.Result = rt.sliceBinarySearchBy(rt.byteSliceView(s), _58); - const _60: rt.Result = rt.sliceBinarySearchByKey(t, x, (_2: [rt.u8, rt.u8]): rt.u8 => { - rt.byteVecPush(out, _2[1]); + const _57: rs.Result = rs.sliceBinarySearchBy(rs.byteSliceView(s), _58); + const _60: rs.Result = rs.sliceBinarySearchByKey(t, x, (_2: [rs.u8, rs.u8]): rs.u8 => { + rs.byteVecPush(out, _2[1]); return _2[0]; - }, rt.cmp); - const _65: (a0: rt.u8) => boolean = (e2: rt.u8): boolean => { + }, rs.cmp); + const _65: (a0: rs.u8) => boolean = (e2: rs.u8): boolean => { put$conversions_Value_u8(e2, out); return e2 < x; }; - const iter3: rt.Iter> = rt.iterSlice([_55, _57, _60, rt.Ok(rt.slicePartitionPoint(rt.byteSliceView(s), _65))]); + const iter3: rs.Iter> = rs.iterSlice([_55, _57, _60, rs.Ok(rs.slicePartitionPoint(rs.byteSliceView(s), _65))]); while (true) { - const _69: rt.Result | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.Result | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } - const found2: rt.Result = _69; + const found2: rs.Result = _69; if (found2.ok) { - _75 = [1, found2.value] as [rt.u8, rt.usize]; + _75 = [1, found2.value] as [rs.u8, rs.usize]; } else { - _75 = [0, found2.error] as [rt.u8, rt.usize]; + _75 = [0, found2.error] as [rs.u8, rs.usize]; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_75[0], _75[1] & 0xff)), undefined, true); } } } } /** What wasm32 lays out each value in, and a slice or a `str` of what `data` holds. */ -export function measured(data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.usize = data.length; - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { - return _2 as rt.u64; +export function measured(data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.usize = data.length; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { + return _2 as rs.u64; }), undefined, 8, true); - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.char => { - return _25 as rt.char; + const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.char => { + return _25 as rs.char; })); Named.make$conversions_Value(data, 0); - const _13: rt.usize = rt.byteSliceRange(data, 0, 0).length; - rt.byteSliceRange(data, 0, 0); - const _12: [rt.usize, rt.usize] = [_13, 1]; - const _19: [rt.usize, rt.usize] = [data.length, 1]; - const _23: rt.usize = rt.sliceRange(wide.items, 0).length * 8; - rt.sliceRange(wide.items, 0); - const _22: [rt.usize, rt.usize] = [_23, 8]; - const _29: [rt.usize, rt.usize] = [rt.stringLen(text), 1]; - const _36: [rt.usize, rt.usize] = [4, 4]; - const _41: [rt.usize, rt.usize] = [16, 16]; - [n & 0xff, n & 0xffff] as [rt.u8, rt.u16]; - const _49: rt.usize = 4; - [n & 0xff, n & 0xffff] as [rt.u8, rt.u16]; - const _48: [rt.usize, rt.usize] = [_49, 2]; - const _59: [rt.usize, rt.usize] = [8, 4]; - const _72: rt.u16 = n & 0xffff; - Array.from({ length: 3 }, (): rt.u16 => { + const _13: rs.usize = rs.byteSliceRange(data, 0, 0).length; + rs.byteSliceRange(data, 0, 0); + const _12: [rs.usize, rs.usize] = [_13, 1]; + const _19: [rs.usize, rs.usize] = [data.length, 1]; + const _23: rs.usize = rs.sliceRange(wide.items, 0).length * 8; + rs.sliceRange(wide.items, 0); + const _22: [rs.usize, rs.usize] = [_23, 8]; + const _29: [rs.usize, rs.usize] = [rs.stringLen(text), 1]; + const _36: [rs.usize, rs.usize] = [4, 4]; + const _41: [rs.usize, rs.usize] = [16, 16]; + [n & 0xff, n & 0xffff] as [rs.u8, rs.u16]; + const _49: rs.usize = 4; + [n & 0xff, n & 0xffff] as [rs.u8, rs.u16]; + const _48: [rs.usize, rs.usize] = [_49, 2]; + const _59: [rs.usize, rs.usize] = [8, 4]; + const _72: rs.u16 = n & 0xffff; + Array.from({ length: 3 }, (): rs.u16 => { return _72; }); - const _69: rt.usize = 6; - const _76: rt.u16 = n & 0xffff; - const iter: rt.Iter<[rt.usize, rt.usize]> = rt.iterSlice([_12, _19, _22, _29, _36, _41, _48, _59, [_69, 2] as [rt.usize, rt.usize], [16, 4] as [rt.usize, rt.usize], [12, 4] as [rt.usize, rt.usize], [0, 1] as [rt.usize, rt.usize]]); + const _69: rs.usize = 6; + const _76: rs.u16 = n & 0xffff; + const iter: rs.Iter<[rs.usize, rs.usize]> = rs.iterSlice([_12, _19, _22, _29, _36, _41, _48, _59, [_69, 2] as [rs.usize, rs.usize], [16, 4] as [rs.usize, rs.usize], [12, 4] as [rs.usize, rs.usize], [0, 1] as [rs.usize, rs.usize]]); while (true) { - const _94: [rt.usize, rt.usize] | rt.Done = iter.next(); - Array.from({ length: 3 }, (): rt.u16 => { + const _94: [rs.usize, rs.usize] | rs.Done = iter.next(); + Array.from({ length: 3 }, (): rs.u16 => { return _76; }); - if (_94 === rt.DONE) { + if (_94 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_94[0] & 0xff, _94[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_94[0] & 0xff, _94[1] & 0xff)), undefined, true); } } @@ -5416,20 +5416,20 @@ export function measured(data: rt.ByteSlice, out: rt.ByteVec): void { * Raw pointers of references to the bytes of arrays and to objects, compared by where * they point, and an array of an `u8`. */ -export function pointed(data: rt.ByteSlice, out: rt.ByteVec): void { +export function pointed(data: rs.ByteSlice, out: rs.ByteVec): void { const _5: [Uint8Array, Uint8Array] = [make$conversions_Value_array2_u8(data, 0), make$conversions_Value_array2_u8(data, 2)]; const a: Uint8Array = copy$array_u8(_5[0]); const b: Uint8Array = copy$array_u8(_5[1]); const _10: [Named.Named, Named.Named] = [Named.make$conversions_Value(data, 0), Named.make$conversions_Value(data, 3)]; const x: Named.Named = _10[0]; const y: Named.Named = _10[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.byteSliceSame(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(a))), rt.byteSliceFrom(a)), rt.byteSliceSame(rt.byteSliceFrom(rt.byteSliceView(rt.byteSliceFrom(a))), rt.byteSliceFrom(b)), x === x, x === y], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.byteSliceSame(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(a))), rs.byteSliceFrom(a)), rs.byteSliceSame(rs.byteSliceFrom(rs.byteSliceView(rs.byteSliceFrom(a))), rs.byteSliceFrom(b)), x === x, x === y], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const p: rt.ByteSlice = rt.byteSliceFrom(a); + const p: rs.ByteSlice = rs.byteSliceFrom(a); p.data[p.start] = p.data[p.start] ^ 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(a)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a[1]))); } //# sourceMappingURL=conversions.ts.map diff --git a/ts/fixtures/lang/conversions/expected/core/bool.ts b/ts/fixtures/lang/conversions/expected/core/bool.ts index a30c8f5aa..c60a4259b 100644 --- a/ts/fixtures/lang/conversions/expected/core/bool.ts +++ b/ts/fixtures/lang/conversions/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0b23a33(self: boolean, t: rt.u16): rt.u16 | undefined { +export function thenSome$1gvhopg(self: boolean, t: rs.u16): rs.u16 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/conversions/expected/core/option.ts b/ts/fixtures/lang/conversions/expected/core/option.ts index 2f091178e..ef47d15d4 100644 --- a/ts/fixtures/lang/conversions/expected/core/option.ts +++ b/ts/fixtures/lang/conversions/expected/core/option.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$array_u32, copy$array_u8 } from "../lib.ts"; import * as Logged from "../conversions.Logged.ts"; import * as Named from "../conversions.Named.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function clone$08xidb9(self: rt.u16 | undefined | rt.None): rt.u16 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function clone$0wpatp7(self: rs.u16 | undefined | rs.None): rs.u16 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return self; } @@ -33,7 +33,7 @@ export function clone$13oewp0(self: Uint8Array | undefined): Uint8Array | undefi return copy$array_u8(self); } -export function clone$0xuzdx9(self: rt.u32[] | undefined): rt.u32[] | undefined { +export function clone$0xr8mw0(self: rs.u32[] | undefined): rs.u32[] | undefined { if (self === undefined) { return undefined; } @@ -54,21 +54,21 @@ export function clone$0fp7wpk(self: Named.Named | undefined): Named.Named | unde return Named.clone$Clone(self); } -export function clone$1md9w7g(self: rt.u32 | undefined): rt.u32 | undefined { +export function clone$1lfse5o(self: rs.u32 | undefined): rs.u32 | undefined { if (self === undefined) { return undefined; } return self; } -export function clone$1qp57nz(self: rt.u64 | undefined): rt.u64 | undefined { +export function clone$08wmfj8(self: rs.u64 | undefined): rs.u64 | undefined { if (self === undefined) { return undefined; } return self; } -export function clone$08560de(self: rt.u8 | undefined): rt.u8 | undefined { +export function clone$1aebjgp(self: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/conversions/expected/harness.ts b/ts/fixtures/lang/conversions/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/conversions/expected/harness.ts +++ b/ts/fixtures/lang/conversions/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/conversions/expected/lib.ts b/ts/fixtures/lang/conversions/expected/lib.ts index cc8c7694d..b3658134d 100644 --- a/ts/fixtures/lang/conversions/expected/lib.ts +++ b/ts/fixtures/lang/conversions/expected/lib.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { conversions } from "./conversions.ts"; import type * as Logged from "./conversions.Logged.ts"; -export function copy$array_Option_u16(v: Array): Array { +export function copy$array_Option_u16(v: Array): Array { return v.slice(); } @@ -16,7 +16,7 @@ export function copy$array_array1_u8(v: Uint8Array[]): Uint8Array[] { return v.map(copy$array_u8); } -export function copy$array_array2_u32(v: rt.u32[][]): rt.u32[][] { +export function copy$array_array2_u32(v: rs.u32[][]): rs.u32[][] { return v.map(copy$array_u32); } @@ -28,11 +28,11 @@ export function copy$array_array40_u8(v: Uint8Array[]): Uint8Array[] { return v.map(copy$array_u8); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } -export function copy$array_u64(v: rt.u64[]): rt.u64[] { +export function copy$array_u64(v: rs.u64[]): rs.u64[] { return v.slice(); } @@ -40,7 +40,7 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function drop$tuple2_conversions_Logged_u8(_1: [Logged.Logged, rt.u8]): void { +export function drop$tuple2_conversions_Logged_u8(_1: [Logged.Logged, rs.u8]): void { _1[0][Symbol.dispose](); } @@ -48,8 +48,8 @@ export function drop$tuple2_conversions_Logged_u8(_1: [Logged.Logged, rt.u8]): v * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["conversions::conversions", conversions as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["conversions::conversions", conversions as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/counts/expected/core/bool.ts b/ts/fixtures/lang/counts/expected/core/bool.ts index 92c35ccbe..b60272ce7 100644 --- a/ts/fixtures/lang/counts/expected/core/bool.ts +++ b/ts/fixtures/lang/counts/expected/core/bool.ts @@ -1,43 +1,43 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function then$1i5jtpz(self: boolean, f: () => rt.Arc): rt.Arc | undefined { +export function then$1qgzik7(self: boolean, f: () => rs.Arc): rs.Arc | undefined { if (!self) { return undefined; } return f(); } -export function then$1vw965y(self: boolean, f: () => rt.Arc<[rt.u16, rt.u8]>): rt.Arc<[rt.u16, rt.u8]> | undefined { +export function then$12a283y(self: boolean, f: () => rs.Arc<[rs.u16, rs.u8]>): rs.Arc<[rs.u16, rs.u8]> | undefined { if (!self) { return undefined; } return f(); } -export function then$0duifht(self: boolean, f: () => rt.Arc): rt.Arc | undefined { +export function then$1vmvrid(self: boolean, f: () => rs.Arc): rs.Arc | undefined { if (!self) { return undefined; } return f(); } -export function then$0kpp40i(self: boolean, f: () => rt.Weak<[rt.u8, rt.u8] | undefined>): rt.Weak<[rt.u8, rt.u8] | undefined> | undefined { +export function then$0mwg5pd(self: boolean, f: () => rs.Weak<[rs.u8, rs.u8] | undefined>): rs.Weak<[rs.u8, rs.u8] | undefined> | undefined { if (!self) { return undefined; } return f(); } -export function then$0t3e9mp(self: boolean, f: () => rt.Weak<[rt.u16, rt.u8]>): rt.Weak<[rt.u16, rt.u8]> | undefined { +export function then$1rzp7o9(self: boolean, f: () => rs.Weak<[rs.u16, rs.u8]>): rs.Weak<[rs.u16, rs.u8]> | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/counts/expected/core/option.ts b/ts/fixtures/lang/counts/expected/core/option.ts index 3ccf0567b..7c8277fb4 100644 --- a/ts/fixtures/lang/counts/expected/core/option.ts +++ b/ts/fixtures/lang/counts/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$tuple2_u8_u8 } from "../lib.ts"; import type * as ArcNode from "../counts.ArcNode.ts"; import type * as ArcShared from "../counts.ArcShared.ts"; @@ -18,147 +18,147 @@ export function unwrapOr$0ujf6zi(self: Twin.Twin | undefined, default_: Twin.Twi return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1srhyy0(self: rt.Arc | undefined, _: (a0: rt.Arc) => rt.Arc): rt.Arc | undefined { +export function map$0lz7sqj(self: rs.Arc | undefined, _: (a0: rs.Arc) => rs.Arc): rs.Arc | undefined { if (self === undefined) { return undefined; } - return rt.arcClone(self); + return rs.arcClone(self); } -export function map$13pnxtn(self: rt.Arc | undefined, _: (a0: rt.Arc) => Noisy.Noisy): Noisy.Noisy | undefined { +export function map$1lu9jov(self: rs.Arc | undefined, _: (a0: rs.Arc) => Noisy.Noisy): Noisy.Noisy | undefined { if (self === undefined) { return undefined; } return self.value; } -export function map$0ufgkyq(self: rt.Arc | undefined, _: (a0: rt.Arc) => rt.u8): rt.u8 | undefined { +export function map$03x79zo(self: rs.Arc | undefined, _: (a0: rs.Arc) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return self.value; } -export function mapOr$1xztl8h(self: rt.u8 | undefined | rt.None, default_: rt.u8, f: (a0: rt.u8 | undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$1rg5gkk(self: rs.u8 | undefined | rs.None, default_: rs.u8, f: (a0: rs.u8 | undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(self); } -export function mapOr$036yrbw(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$025sl8y(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ndy2gq(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$1kjo972(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1qmxzyf(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$1wnjpxi(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1q3ff8g(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$1gfk3jk(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ailw2a(self: Counted.Counted | undefined, default_: rt.u8, f: (a0: Counted.Counted) => rt.u8): rt.u8 { +export function mapOr$0gign7l(self: Counted.Counted | undefined, default_: rs.u8, f: (a0: Counted.Counted) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$09pasix(self: rt.Vec> | undefined, default_: rt.u8, f: (a0: rt.Vec>) => rt.u8): rt.u8 { +export function mapOr$1e2t3oz(self: rs.Vec> | undefined, default_: rs.u8, f: (a0: rs.Vec>) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1hh0iyl(self: ArcShared.ArcShared | undefined, default_: rt.u8, f: (a0: ArcShared.ArcShared) => rt.u8): rt.u8 { +export function mapOr$1pgbs4c(self: ArcShared.ArcShared | undefined, default_: rs.u8, f: (a0: ArcShared.ArcShared) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1iuqai4(self: Noisy.Noisy | undefined, default_: rt.u8, f: (a0: Noisy.Noisy) => rt.u8): rt.u8 { +export function mapOr$114r0pa(self: Noisy.Noisy | undefined, default_: rs.u8, f: (a0: Noisy.Noisy) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1kfudqo(self: RcShared.RcShared | undefined, default_: rt.u8, f: (a0: RcShared.RcShared) => rt.u8): rt.u8 { +export function mapOr$1jfh4wo(self: RcShared.RcShared | undefined, default_: rs.u8, f: (a0: RcShared.RcShared) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0dgmbpi(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$1jexokn(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1cxzjxo(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1p1hmiu(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(copy$tuple2_u8_u8(self)); } -export function mapOr$06rr3sb(self: rt.u8 | undefined, default_: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { +export function mapOr$19a4gco(self: rs.u8 | undefined, default_: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return default_; } return f(self); } -export function asDeref$0hypa7g(self: rt.Arc | undefined): Noisy.Noisy | undefined { - return map$13pnxtn(self, (a0: rt.Arc): Noisy.Noisy => { +export function asDeref$0hjiqyl(self: rs.Arc | undefined): Noisy.Noisy | undefined { + return map$1lu9jov(self, (a0: rs.Arc): Noisy.Noisy => { return a0.value; }); } -export function asDeref$0s3650c(self: rt.Arc | undefined): rt.u8 | undefined { - return map$0ufgkyq(self, (a0: rt.Arc): rt.u8 => { +export function asDeref$1l62o5g(self: rs.Arc | undefined): rs.u8 | undefined { + return map$03x79zo(self, (a0: rs.Arc): rs.u8 => { return a0.value; }); } -export function filter$1qg98un(self: rt.Arc | undefined, predicate: (a0: rt.Arc) => boolean): rt.Arc | undefined { +export function filter$1gn36in(self: rs.Arc | undefined, predicate: (a0: rs.Arc) => boolean): rs.Arc | undefined { if (self !== undefined) { - const x: rt.Arc = self; + const x: rs.Arc = self; if (!predicate(x)) { x[Symbol.dispose](); } else { @@ -168,11 +168,11 @@ export function filter$1qg98un(self: rt.Arc | undefined, predicate: return undefined; } -export function filter$09u55oo(self: rt.Vec> | undefined, predicate: (a0: rt.Vec>) => boolean): rt.Vec> | undefined { +export function filter$02g8l8j(self: rs.Vec> | undefined, predicate: (a0: rs.Vec>) => boolean): rs.Vec> | undefined { if (self !== undefined) { - const x: rt.Vec> = self; + const x: rs.Vec> = self; if (!predicate(x)) { - rt.dropVec(x); + rs.dropVec(x); } else { return x; } @@ -216,7 +216,7 @@ export function filter$14b5774(self: RcShared.RcShared | undefined, predicate: ( return undefined; } -export function or$1loyskh(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { +export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return optb; } diff --git a/ts/fixtures/lang/counts/expected/counts.ArcHolder.ts b/ts/fixtures/lang/counts/expected/counts.ArcHolder.ts index 3b9105fba..2582cab53 100644 --- a/ts/fixtures/lang/counts/expected/counts.ArcHolder.ts +++ b/ts/fixtures/lang/counts/expected/counts.ArcHolder.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Holds a handle that doesn't keep its value. */ export class ArcHolder { - weak: rt.Weak; + weak: rs.Weak; - constructor(weak: rt.Weak) { + constructor(weak: rs.Weak) { this.weak = weak; } diff --git a/ts/fixtures/lang/counts/expected/counts.ArcNode.ts b/ts/fixtures/lang/counts/expected/counts.ArcNode.ts index 935443393..528b66fcb 100644 --- a/ts/fixtures/lang/counts/expected/counts.ArcNode.ts +++ b/ts/fixtures/lang/counts/expected/counts.ArcNode.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Noisy from "./counts.Noisy.ts"; /** @@ -8,12 +8,12 @@ import type * as Noisy from "./counts.Noisy.ts"; * the first read then. */ export class ArcNode { - this: rt.Weak; - more: rt.Vec>; + this: rs.Weak; + more: rs.Vec>; noisy: Noisy.Noisy; seen: Uint8Array; - constructor(this_: rt.Weak, more: rt.Vec>, noisy: Noisy.Noisy, seen: Uint8Array) { + constructor(this_: rs.Weak, more: rs.Vec>, noisy: Noisy.Noisy, seen: Uint8Array) { this.this = this_; this.more = more; this.noisy = noisy; @@ -22,19 +22,19 @@ export class ArcNode { [Symbol.dispose](): void { this.this[Symbol.dispose](); - rt.dropVec(this.more); + rs.dropVec(this.more); this.noisy[Symbol.dispose](); } } -function new_(this_: rt.Weak, noisy: Noisy.Noisy, more: rt.u8): ArcNode { - const _4: rt.Weak = rt.weakClone(this_); - const _5: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, more), (_2: rt.u8): rt.Weak => { - return rt.weakClone(this_); +function new_(this_: rs.Weak, noisy: Noisy.Noisy, more: rs.u8): ArcNode { + const _4: rs.Weak = rs.weakClone(this_); + const _5: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, more), (_2: rs.u8): rs.Weak => { + return rs.weakClone(this_); }), undefined, 4, true); - const _13: rt.Arc | undefined = rt.weakUpgrade(this_); - const _0: ArcNode = new ArcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rt.weakWeakCount(this_) & 0xff)); - rt.drop(_13); + const _13: rs.Arc | undefined = rs.weakUpgrade(this_); + const _0: ArcNode = new ArcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rs.weakWeakCount(this_) & 0xff)); + rs.drop(_13); return _0; } diff --git a/ts/fixtures/lang/counts/expected/counts.ArcReleasing.ts b/ts/fixtures/lang/counts/expected/counts.ArcReleasing.ts index 5ab2d3ecc..8f0e2631c 100644 --- a/ts/fixtures/lang/counts/expected/counts.ArcReleasing.ts +++ b/ts/fixtures/lang/counts/expected/counts.ArcReleasing.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing } from "./lib.ts"; /** @@ -8,11 +8,11 @@ import { drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing } from "./lib.ts"; * id when it drops. */ export class ArcReleasing { - id: rt.u8; - others: rt.Arc>>>; - log: rt.Arc>; + id: rs.u8; + others: rs.Arc>>>; + log: rs.Arc>; - constructor(id: rt.u8, others: rt.Arc>>>, log: rt.Arc>) { + constructor(id: rs.u8, others: rs.Arc>>>, log: rs.Arc>) { this.id = id; this.others = others; this.log = log; @@ -20,22 +20,22 @@ export class ArcReleasing { [Symbol.dispose](): void { drop$ops_Drop(this); - rt.arcDrop(this.others, drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing); + rs.arcDrop(this.others, drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing); this.log[Symbol.dispose](); } } export function clone$Clone(self: ArcReleasing): ArcReleasing { - const _5: rt.RefCell>> = rt.refCellBorrowMut(self.others.value); - rt.vecTruncate(_5.value, 0, rt.drop); - rt.refMutRelease(_5); - return new ArcReleasing(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.others), rt.arcClone(self.log)); + const _5: rs.RefCell>> = rs.refCellBorrowMut(self.others.value); + rs.vecTruncate(_5.value, 0, rs.drop); + rs.refMutRelease(_5); + return new ArcReleasing(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.others), rs.arcClone(self.log)); } export function drop$ops_Drop(self: ArcReleasing): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=counts.ArcReleasing.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.ArcShared.ts b/ts/fixtures/lang/counts/expected/counts.ArcShared.ts index 9eca8d749..55d943bca 100644 --- a/ts/fixtures/lang/counts/expected/counts.ArcShared.ts +++ b/ts/fixtures/lang/counts/expected/counts.ArcShared.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Noisy from "./counts.Noisy.ts"; /** Holds a handle, and clones it with a derived `Clone`. */ export class ArcShared { - noisy: rt.Arc; - tag: rt.u8; + noisy: rs.Arc; + tag: rs.u8; - constructor(noisy: rt.Arc, tag: rt.u8) { + constructor(noisy: rs.Arc, tag: rs.u8) { this.noisy = noisy; this.tag = tag; } @@ -19,7 +19,7 @@ export class ArcShared { } export function clone$Clone(self: ArcShared): ArcShared { - return new ArcShared(rt.arcClone(self.noisy), self.tag); + return new ArcShared(rs.arcClone(self.noisy), self.tag); } //# sourceMappingURL=counts.ArcShared.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.Counted.ts b/ts/fixtures/lang/counts/expected/counts.Counted.ts index 21d69fb10..94e2db7c2 100644 --- a/ts/fixtures/lang/counts/expected/counts.Counted.ts +++ b/ts/fixtures/lang/counts/expected/counts.Counted.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` value whose `Clone`, written by hand, counts each clone. */ export interface Counted { - id: rt.u8; - clones: rt.Cell; + id: rs.u8; + clones: rs.Cell; } export function clone$Clone(self: Counted): Counted { - rt.cellSet(self.clones, rt.u8WrappingAdd(self.clones.v, 1)); - return { id: rt.u8WrappingAdd(self.id, 1), clones: self.clones }; + rs.cellSet(self.clones, rs.u8WrappingAdd(self.clones.v, 1)); + return { id: rs.u8WrappingAdd(self.id, 1), clones: self.clones }; } //# sourceMappingURL=counts.Counted.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.Id.ts b/ts/fixtures/lang/counts/expected/counts.Id.ts index dde87284d..1d0febb2c 100644 --- a/ts/fixtures/lang/counts/expected/counts.Id.ts +++ b/ts/fixtures/lang/counts/expected/counts.Id.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What a trait object of a `Noisy` reads. */ -export type Id = { id$Id: () => rt.u8 }; +export type Id = { id$Id: () => rs.u8 }; //# sourceMappingURL=counts.Id.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.Noisy.ts b/ts/fixtures/lang/counts/expected/counts.Noisy.ts index 15f212cab..886cca3d5 100644 --- a/ts/fixtures/lang/counts/expected/counts.Noisy.ts +++ b/ts/fixtures/lang/counts/expected/counts.Noisy.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id when it drops, so the last strong drop shows where it happens. */ export class Noisy { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -19,16 +19,16 @@ export class Noisy { } export function clone$Clone(self: Noisy): Noisy { - return new Noisy(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + return new Noisy(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Noisy): void { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.mutexUnlock(_5); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.mutexUnlock(_5); } -export function id$counts_Id(self: Noisy): rt.u8 { +export function id$counts_Id(self: Noisy): rs.u8 { return self.id; } diff --git a/ts/fixtures/lang/counts/expected/counts.RcHolder.ts b/ts/fixtures/lang/counts/expected/counts.RcHolder.ts index 8ece327a8..fa3728044 100644 --- a/ts/fixtures/lang/counts/expected/counts.RcHolder.ts +++ b/ts/fixtures/lang/counts/expected/counts.RcHolder.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Holds a handle that doesn't keep its value. */ export class RcHolder { - weak: rt.Weak; + weak: rs.Weak; - constructor(weak: rt.Weak) { + constructor(weak: rs.Weak) { this.weak = weak; } diff --git a/ts/fixtures/lang/counts/expected/counts.RcNode.ts b/ts/fixtures/lang/counts/expected/counts.RcNode.ts index fbb1d9d04..76c14cdbd 100644 --- a/ts/fixtures/lang/counts/expected/counts.RcNode.ts +++ b/ts/fixtures/lang/counts/expected/counts.RcNode.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Noisy from "./counts.Noisy.ts"; /** @@ -8,12 +8,12 @@ import type * as Noisy from "./counts.Noisy.ts"; * the first read then. */ export class RcNode { - this: rt.Weak; - more: rt.Vec>; + this: rs.Weak; + more: rs.Vec>; noisy: Noisy.Noisy; seen: Uint8Array; - constructor(this_: rt.Weak, more: rt.Vec>, noisy: Noisy.Noisy, seen: Uint8Array) { + constructor(this_: rs.Weak, more: rs.Vec>, noisy: Noisy.Noisy, seen: Uint8Array) { this.this = this_; this.more = more; this.noisy = noisy; @@ -22,19 +22,19 @@ export class RcNode { [Symbol.dispose](): void { this.this[Symbol.dispose](); - rt.dropVec(this.more); + rs.dropVec(this.more); this.noisy[Symbol.dispose](); } } -function new_(this_: rt.Weak, noisy: Noisy.Noisy, more: rt.u8): RcNode { - const _4: rt.Weak = rt.weakClone(this_); - const _5: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, more), (_2: rt.u8): rt.Weak => { - return rt.weakClone(this_); +function new_(this_: rs.Weak, noisy: Noisy.Noisy, more: rs.u8): RcNode { + const _4: rs.Weak = rs.weakClone(this_); + const _5: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, more), (_2: rs.u8): rs.Weak => { + return rs.weakClone(this_); }), undefined, 4, true); - const _13: rt.Arc | undefined = rt.weakUpgrade(this_); - const _0: RcNode = new RcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rt.weakWeakCount(this_) & 0xff)); - rt.drop(_13); + const _13: rs.Arc | undefined = rs.weakUpgrade(this_); + const _0: RcNode = new RcNode(_4, _5, noisy, Uint8Array.of(_13 === undefined ? 1 : 0, this_.arc.strong & 0xff, rs.weakWeakCount(this_) & 0xff)); + rs.drop(_13); return _0; } diff --git a/ts/fixtures/lang/counts/expected/counts.RcReleasing.ts b/ts/fixtures/lang/counts/expected/counts.RcReleasing.ts index cbf276e6b..0fa33c68d 100644 --- a/ts/fixtures/lang/counts/expected/counts.RcReleasing.ts +++ b/ts/fixtures/lang/counts/expected/counts.RcReleasing.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$cell_RefCell_Vec_Rc_counts_RcReleasing } from "./lib.ts"; /** @@ -8,11 +8,11 @@ import { drop$cell_RefCell_Vec_Rc_counts_RcReleasing } from "./lib.ts"; * id when it drops. */ export class RcReleasing { - id: rt.u8; - others: rt.Arc>>>; - log: rt.Arc>; + id: rs.u8; + others: rs.Arc>>>; + log: rs.Arc>; - constructor(id: rt.u8, others: rt.Arc>>>, log: rt.Arc>) { + constructor(id: rs.u8, others: rs.Arc>>>, log: rs.Arc>) { this.id = id; this.others = others; this.log = log; @@ -20,22 +20,22 @@ export class RcReleasing { [Symbol.dispose](): void { drop$ops_Drop(this); - rt.arcDrop(this.others, drop$cell_RefCell_Vec_Rc_counts_RcReleasing); + rs.arcDrop(this.others, drop$cell_RefCell_Vec_Rc_counts_RcReleasing); this.log[Symbol.dispose](); } } export function clone$Clone(self: RcReleasing): RcReleasing { - const _5: rt.RefCell>> = rt.refCellBorrowMut(self.others.value); - rt.vecTruncate(_5.value, 0, rt.drop); - rt.refMutRelease(_5); - return new RcReleasing(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.others), rt.arcClone(self.log)); + const _5: rs.RefCell>> = rs.refCellBorrowMut(self.others.value); + rs.vecTruncate(_5.value, 0, rs.drop); + rs.refMutRelease(_5); + return new RcReleasing(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.others), rs.arcClone(self.log)); } export function drop$ops_Drop(self: RcReleasing): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=counts.RcReleasing.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.RcShared.ts b/ts/fixtures/lang/counts/expected/counts.RcShared.ts index 1945288be..c69fa75c8 100644 --- a/ts/fixtures/lang/counts/expected/counts.RcShared.ts +++ b/ts/fixtures/lang/counts/expected/counts.RcShared.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Noisy from "./counts.Noisy.ts"; /** Holds a handle, and clones it with a derived `Clone`. */ export class RcShared { - noisy: rt.Arc; - tag: rt.u8; + noisy: rs.Arc; + tag: rs.u8; - constructor(noisy: rt.Arc, tag: rt.u8) { + constructor(noisy: rs.Arc, tag: rs.u8) { this.noisy = noisy; this.tag = tag; } @@ -19,7 +19,7 @@ export class RcShared { } export function clone$Clone(self: RcShared): RcShared { - return new RcShared(rt.arcClone(self.noisy), self.tag); + return new RcShared(rs.arcClone(self.noisy), self.tag); } //# sourceMappingURL=counts.RcShared.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.Twin.ts b/ts/fixtures/lang/counts/expected/counts.Twin.ts index 781e59cbd..500c436e1 100644 --- a/ts/fixtures/lang/counts/expected/counts.Twin.ts +++ b/ts/fixtures/lang/counts/expected/counts.Twin.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` value with a derived `Clone`. */ export interface Twin { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=counts.Twin.ts.map diff --git a/ts/fixtures/lang/counts/expected/counts.ts b/ts/fixtures/lang/counts/expected/counts.ts index 1eeae9022..4009a2eda 100644 --- a/ts/fixtures/lang/counts/expected/counts.ts +++ b/ts/fixtures/lang/counts/expected/counts.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$array_u8, copy$tuple2_u16_u8, copy$tuple2_u8_u8, drop$Vec_Rc_counts_Noisy, drop$Vec_sync_Arc_counts_Noisy, drop$cell_RefCell_Vec_Rc_counts_RcReleasing, drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing, drop$tuple2_Option_rc_Weak_tuple2_u16_u8_Option_Rc_tuple2_u16_u8, drop$tuple2_Option_sync_Weak_tuple2_u16_u8_Option_sync_Arc_tuple2_u16_u8, drop$tuple5_Vec_Rc_counts_Noisy_Vec_Rc_counts_Noisy_Vec_counts_RcShared_Vec_counts_Noisy_Vec_Vec_Rc_counts_Noisy, drop$tuple5_Vec_sync_Arc_counts_Noisy_Vec_sync_Arc_counts_Noisy_Vec_counts_ArcShared_Vec_counts_Noisy_Vec_Vec_sync_Arc_counts_Noisy, of$counts_Noisy } from "./lib.ts"; -import { thenSome$0d5am30, then$1i5jtpz, then$1vw965y, then$0duifht, then$0kpp40i, then$0t3e9mp } from "./core/bool.ts"; -import { unwrapOr$0ujf6zi as option_unwrapOr$0ujf6zi, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1srhyy0 as option_map$1srhyy0, mapOr$1xztl8h as option_mapOr$1xztl8h, mapOr$036yrbw as option_mapOr$036yrbw, mapOr$1ndy2gq as option_mapOr$1ndy2gq, mapOr$1qmxzyf as option_mapOr$1qmxzyf, mapOr$1q3ff8g as option_mapOr$1q3ff8g, mapOr$1ailw2a as option_mapOr$1ailw2a, mapOr$09pasix as option_mapOr$09pasix, mapOr$1hh0iyl as option_mapOr$1hh0iyl, mapOr$1iuqai4 as option_mapOr$1iuqai4, mapOr$1kfudqo as option_mapOr$1kfudqo, mapOr$1surhce as option_mapOr$1surhce, mapOr$0dgmbpi as option_mapOr$0dgmbpi, mapOr$1cxzjxo as option_mapOr$1cxzjxo, mapOr$06rr3sb as option_mapOr$06rr3sb, asDeref$0hypa7g as option_asDeref$0hypa7g, asDeref$0s3650c as option_asDeref$0s3650c, filter$1qg98un, filter$09u55oo, filter$1asvriw, filter$1gka6nq, filter$14b5774, or$1loyskh as option_or$1loyskh } from "./core/option.ts"; +import { thenSome$0quywni, then$1qgzik7, then$12a283y, then$1vmvrid, then$0mwg5pd, then$1rzp7o9 } from "./core/bool.ts"; +import { unwrapOr$0ujf6zi as option_unwrapOr$0ujf6zi, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0lz7sqj as option_map$0lz7sqj, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$025sl8y as option_mapOr$025sl8y, mapOr$1kjo972 as option_mapOr$1kjo972, mapOr$1wnjpxi as option_mapOr$1wnjpxi, mapOr$1gfk3jk as option_mapOr$1gfk3jk, mapOr$0gign7l as option_mapOr$0gign7l, mapOr$1e2t3oz as option_mapOr$1e2t3oz, mapOr$1pgbs4c as option_mapOr$1pgbs4c, mapOr$114r0pa as option_mapOr$114r0pa, mapOr$1jfh4wo as option_mapOr$1jfh4wo, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1jexokn as option_mapOr$1jexokn, mapOr$1p1hmiu as option_mapOr$1p1hmiu, mapOr$19a4gco as option_mapOr$19a4gco, asDeref$0hjiqyl as option_asDeref$0hjiqyl, asDeref$1l62o5g as option_asDeref$1l62o5g, filter$1gn36in, filter$02g8l8j, filter$1asvriw, filter$1gka6nq, filter$14b5774, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; import * as ArcHolder from "./counts.ArcHolder.ts"; import * as ArcNode from "./counts.ArcNode.ts"; import * as ArcReleasing from "./counts.ArcReleasing.ts"; @@ -18,11 +18,11 @@ import * as RcShared from "./counts.RcShared.ts"; import type * as Twin from "./counts.Twin.ts"; /** Puts what dropped since the last flush. */ -export function flush(log: rt.Mutex, out: rt.ByteVec): void { - const log2: rt.Mutex = rt.mutexLock(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log2.value)); - rt.byteVecClear(log2.value); - rt.mutexUnlock(log2); +export function flush(log: rs.Mutex, out: rs.ByteVec): void { + const log2: rs.Mutex = rs.mutexLock(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log2.value)); + rs.byteVecClear(log2.value); + rs.mutexUnlock(log2); } /** @@ -32,291 +32,291 @@ export function flush(log: rt.Mutex, out: rt.ByteVec): void { * keeps the allocation `as_ptr` points at only when no other handle, strong or weak, * shares it, and a read through `as_ptr` sees each write. */ -export function addressedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const strong: rt.Vec> = rt.vecFrom([new rt.Arc([0, 1] as [rt.u8, rt.u8])]); - const weak: rt.Vec> = new rt.Vec(); - let bytes: rt.Arc = new rt.Arc(Uint8Array.of(2, 3)); - const number: rt.Arc = new rt.Arc(4); - let maybe: rt.Arc<[rt.u8, rt.u8] | undefined> = new rt.Arc([5, 6] as [rt.u8, rt.u8]); - let unread: rt.Arc<[rt.u16, rt.u8]> = new rt.Arc([7, 8] as [rt.u16, rt.u8]); - let unit: rt.Arc = new rt.Arc(undefined); - for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = rt.usizeRem(op >> 3 as rt.usize, strong.items.length); +export function addressedArcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const strong: rs.Vec> = rs.vecFrom([new rs.Arc([0, 1] as [rs.u8, rs.u8])]); + const weak: rs.Vec> = new rs.Vec(); + let bytes: rs.Arc = new rs.Arc(Uint8Array.of(2, 3)); + const number: rs.Arc = new rs.Arc(4); + let maybe: rs.Arc<[rs.u8, rs.u8] | undefined> = new rs.Arc([5, 6] as [rs.u8, rs.u8]); + let unread: rs.Arc<[rs.u16, rs.u8]> = new rs.Arc([7, 8] as [rs.u16, rs.u8]); + let unit: rs.Arc = new rs.Arc(undefined); + for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = rs.usizeRem(op >> 3 as rs.usize, strong.items.length); b2: { - const _32: rt.u8 = rt.u8Rem(op, 6); + const _32: rs.u8 = rs.u8Rem(op, 6); if (_32 === 0) { - const _35: rt.Arc<[rt.u8, rt.u8]> = new rt.Arc([op, 0] as [rt.u8, rt.u8]); + const _35: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([op, 0] as [rs.u8, rs.u8]); strong.items.push(_35); } else if (_32 === 1) { - const again: rt.Arc<[rt.u8, rt.u8]> = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); + const again: rs.Arc<[rs.u8, rs.u8]> = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); strong.items.push(again); } else if (_32 === 2) { - const _43: rt.Weak<[rt.u8, rt.u8]> = new rt.Weak(strong.items[rt.idx(strong.items, pick)]); + const _43: rs.Weak<[rs.u8, rs.u8]> = new rs.Weak(strong.items[rs.idx(strong.items, pick)]); weak.items.push(_43); } else if (_32 === 3) { if (strong.items.length > 1) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, pick)[Symbol.dispose](); + rs.vecSwapRemove(strong, pick)[Symbol.dispose](); break b2; } } - rt.vecTruncate(weak, 0, rt.drop); + rs.vecTruncate(weak, 0, rs.drop); } else if (_32 === 4) { - const arc8 = strong.items[rt.idx(strong.items, pick)]; - const before: [rt.u8, rt.u8] = rt.arcRaw(arc8, arc8.value, "Arc"); - const at3 = rt.idx(strong.items, pick); - const _57: [rt.u8, rt.u8] = rt.arcMakeMut(rt.place(() => strong.items[at3], (value5) => strong.items[at3] = value5), copy$tuple2_u8_u8, rt.drop, copy$tuple2_u8_u8); + const arc8 = strong.items[rs.idx(strong.items, pick)]; + const before: [rs.u8, rs.u8] = rs.arcRaw(arc8, arc8.value, "Arc"); + const at3 = rs.idx(strong.items, pick); + const _57: [rs.u8, rs.u8] = rs.arcMakeMut(rs.place(() => strong.items[at3], (value5) => strong.items[at3] = value5), copy$tuple2_u8_u8, rs.drop, copy$tuple2_u8_u8); _57[1] = _57[1] ^ op; - const arc9 = strong.items[rt.idx(strong.items, pick)]; - const after: [rt.u8, rt.u8] = rt.arcRaw(arc9, arc9.value, "Arc"); - rt.byteVecPush(out, before === after ? 1 : 0); - rt.byteVecPush(out, after === strong.items[rt.idx(strong.items, pick)].value ? 1 : 0); - rt.byteVecPush(out, after[1]); + const arc9 = strong.items[rs.idx(strong.items, pick)]; + const after: [rs.u8, rs.u8] = rs.arcRaw(arc9, arc9.value, "Arc"); + rs.byteVecPush(out, before === after ? 1 : 0); + rs.byteVecPush(out, after === strong.items[rs.idx(strong.items, pick)].value ? 1 : 0); + rs.byteVecPush(out, after[1]); } else { - const shadow: rt.Arc | undefined = then$1i5jtpz((op & 128) !== 0, (): rt.Arc => { - return rt.arcClone(bytes); + const shadow: rs.Arc | undefined = then$1qgzik7((op & 128) !== 0, (): rs.Arc => { + return rs.arcClone(bytes); }); - const before2: rt.ByteSlice = rt.byteSliceFrom(bytes.value); - const _82: rt.ByteSlice = rt.byteSliceFrom(rt.arcMakeMut(rt.place(() => bytes, (value) => bytes = value), copy$array_u8, rt.drop, copy$array_u8)); + const before2: rs.ByteSlice = rs.byteSliceFrom(bytes.value); + const _82: rs.ByteSlice = rs.byteSliceFrom(rs.arcMakeMut(rs.place(() => bytes, (value) => bytes = value), copy$array_u8, rs.drop, copy$array_u8)); _82.data[_82.start] = _82.data[_82.start] ^ op; - const after2: rt.ByteSlice = rt.byteSliceFrom(bytes.value); - rt.byteVecPush(out, rt.byteSliceSame(before2, after2) ? 1 : 0); - rt.byteVecExtendFromSlice(out, after2); - rt.drop(shadow); + const after2: rs.ByteSlice = rs.byteSliceFrom(bytes.value); + rs.byteVecPush(out, rs.byteSliceSame(before2, after2) ? 1 : 0); + rs.byteVecExtendFromSlice(out, after2); + rs.drop(shadow); const arc = number; - const at: rt.Place = rt.arcRaw(arc, rt.arcPlace(arc), "Arc"); - const _97: rt.Place | undefined = rt.arcGetMutPlace(number); + const at: rs.Place = rs.arcRaw(arc, rs.arcPlace(arc), "Arc"); + const _97: rs.Place | undefined = rs.arcGetMutPlace(number); if (_97 !== undefined) { _97.v = _97.v ^ op; } - rt.byteVecPush(out, at.v); - const kept: rt.Weak<[rt.u8, rt.u8] | undefined> | undefined = then$0kpp40i((op & 64) !== 0, (): rt.Weak<[rt.u8, rt.u8] | undefined> => { - return new rt.Weak(maybe); + rs.byteVecPush(out, at.v); + const kept: rs.Weak<[rs.u8, rs.u8] | undefined> | undefined = then$0mwg5pd((op & 64) !== 0, (): rs.Weak<[rs.u8, rs.u8] | undefined> => { + return new rs.Weak(maybe); }); - const _108: [rt.u8, rt.u8] | undefined = rt.arcMakeMutPlace(rt.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u8_u8, rt.drop, copy$Option_tuple2_u8_u8).v; + const _108: [rs.u8, rs.u8] | undefined = rs.arcMakeMutPlace(rs.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u8_u8, rs.drop, copy$Option_tuple2_u8_u8).v; if (_108 !== undefined) { _108[0] = _108[0] ^ op; } - rt.byteVecPush(out, option_mapOr$1cxzjxo(copy$Option_tuple2_u8_u8(maybe.value), 253, (_2: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1p1hmiu(copy$Option_tuple2_u8_u8(maybe.value), 253, (_2: [rs.u8, rs.u8]): rs.u8 => { return _2[0]; })); - rt.drop(kept); - const kept2: rt.Weak<[rt.u16, rt.u8]> | undefined = then$0t3e9mp((op & 64) !== 0, (): rt.Weak<[rt.u16, rt.u8]> => { - return new rt.Weak(unread); + rs.drop(kept); + const kept2: rs.Weak<[rs.u16, rs.u8]> | undefined = then$1rzp7o9((op & 64) !== 0, (): rs.Weak<[rs.u16, rs.u8]> => { + return new rs.Weak(unread); }); - const shadow2: rt.Arc<[rt.u16, rt.u8]> | undefined = then$1vw965y((op & 32) !== 0, (): rt.Arc<[rt.u16, rt.u8]> => { - return rt.arcClone(unread); + const shadow2: rs.Arc<[rs.u16, rs.u8]> | undefined = then$12a283y((op & 32) !== 0, (): rs.Arc<[rs.u16, rs.u8]> => { + return rs.arcClone(unread); }); const arc2 = unread; - const before3: [rt.u16, rt.u8] = rt.arcRaw(arc2, arc2.value, "Arc"); - const pair: [rt.u16, rt.u8] = copy$tuple2_u16_u8(rt.arcMakeMut(rt.place(() => unread, (value3) => unread = value3), copy$tuple2_u16_u8, rt.drop, copy$tuple2_u16_u8)); + const before3: [rs.u16, rs.u8] = rs.arcRaw(arc2, arc2.value, "Arc"); + const pair: [rs.u16, rs.u8] = copy$tuple2_u16_u8(rs.arcMakeMut(rs.place(() => unread, (value3) => unread = value3), copy$tuple2_u16_u8, rs.drop, copy$tuple2_u16_u8)); const arc3 = unread; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before3 === rt.arcRaw(arc3, arc3.value, "Arc") ? 1 : 0, pair[1])), undefined, true); - drop$tuple2_Option_sync_Weak_tuple2_u16_u8_Option_sync_Arc_tuple2_u16_u8([kept2, shadow2] as [rt.Weak<[rt.u16, rt.u8]> | undefined, rt.Arc<[rt.u16, rt.u8]> | undefined]); - const other: rt.Arc = new rt.Arc(undefined); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before3 === rs.arcRaw(arc3, arc3.value, "Arc") ? 1 : 0, pair[1])), undefined, true); + drop$tuple2_Option_sync_Weak_tuple2_u16_u8_Option_sync_Arc_tuple2_u16_u8([kept2, shadow2] as [rs.Weak<[rs.u16, rs.u8]> | undefined, rs.Arc<[rs.u16, rs.u8]> | undefined]); + const other: rs.Arc = new rs.Arc(undefined); const arc4 = unit; - const before4: rt.Place = rt.arcRaw(arc4, rt.arcPlace(arc4), "Arc"); - const shadow3: rt.Arc | undefined = then$0duifht((op & 128) !== 0, (): rt.Arc => { - return rt.arcClone(unit); + const before4: rs.Place = rs.arcRaw(arc4, rs.arcPlace(arc4), "Arc"); + const shadow3: rs.Arc | undefined = then$1vmvrid((op & 128) !== 0, (): rs.Arc => { + return rs.arcClone(unit); }); - rt.arcMakeMutPlace(rt.place(() => unit, (value4) => unit = value4), undefined, rt.drop); + rs.arcMakeMutPlace(rs.place(() => unit, (value4) => unit = value4), undefined, rs.drop); const arc5 = unit; - const _155: rt.u8 = before4 === rt.arcRaw(arc5, rt.arcPlace(arc5), "Arc") ? 1 : 0; + const _155: rs.u8 = before4 === rs.arcRaw(arc5, rs.arcPlace(arc5), "Arc") ? 1 : 0; const arc6 = other; - const _161: rt.Place = rt.arcRaw(arc6, rt.arcPlace(arc6), "Arc"); + const _161: rs.Place = rs.arcRaw(arc6, rs.arcPlace(arc6), "Arc"); const arc7 = unit; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_155, _161 === rt.arcRaw(arc7, rt.arcPlace(arc7), "Arc") ? 1 : 0)), undefined, true); - rt.drop(shadow3); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_155, _161 === rs.arcRaw(arc7, rs.arcPlace(arc7), "Arc") ? 1 : 0)), undefined, true); + rs.drop(shadow3); other[Symbol.dispose](); } } - const at8 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(strong.items[at8].value[0], strong.items[at8].value[1], strong.items[at8].strong & 0xff))); + const at8 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(strong.items[at8].value[0], strong.items[at8].value[1], strong.items[at8].strong & 0xff))); } unit[Symbol.dispose](); unread[Symbol.dispose](); maybe[Symbol.dispose](); number[Symbol.dispose](); bytes[Symbol.dispose](); - rt.dropVec(weak); - rt.dropVec(strong); + rs.dropVec(weak); + rs.dropVec(strong); } /** * Each byte an operation on pools of strong and weak handles, the rest of it the * handle it picks; each puts what it read. */ -export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const strong: rt.Vec> = new rt.Vec(); - const weak: rt.Vec> = new rt.Vec(); - l1: for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = op >> 4 as rt.usize; - const _19: rt.u8 = rt.u8Rem(op, 12); +export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const strong: rs.Vec> = new rs.Vec(); + const weak: rs.Vec> = new rs.Vec(); + l1: for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = op >> 4 as rs.usize; + const _19: rs.u8 = rs.u8Rem(op, 12); if (_19 === 0) { - const _22: rt.Arc = new rt.Arc(new Noisy.Noisy(op, rt.arcClone(log))); + const _22: rs.Arc = new rs.Arc(new Noisy.Noisy(op, rs.arcClone(log))); strong.items.push(_22); continue; } if (_19 === 1) { if (!(strong.items.length === 0)) { - const again: rt.Arc = rt.arcClone(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const again: rs.Arc = rs.arcClone(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); strong.items.push(again); continue; } } else if (_19 === 2) { if (!(strong.items.length === 0)) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, rt.usizeRem(pick, strong.items.length))[Symbol.dispose](); + rs.vecSwapRemove(strong, rs.usizeRem(pick, strong.items.length))[Symbol.dispose](); continue; } } if (!(strong.items.length === 0)) { - const _49: Noisy.Noisy | undefined = rt.arcIntoInner(rt.vecSwapRemove(strong, rt.usizeRem(pick, strong.items.length))); + const _49: Noisy.Noisy | undefined = rs.arcIntoInner(rs.vecSwapRemove(strong, rs.usizeRem(pick, strong.items.length))); if (_49 === undefined) { - rt.byteVecPush(out, 251); + rs.byteVecPush(out, 251); continue; } const noisy: Noisy.Noisy = _49; - rt.byteVecPush(out, noisy.id); + rs.byteVecPush(out, noisy.id); noisy[Symbol.dispose](); continue; } } else if (_19 === 3) { if (!(strong.items.length === 0)) { - const _62: rt.Weak = new rt.Weak(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const _62: rs.Weak = new rs.Weak(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); weak.items.push(_62); continue; } } else if (_19 === 4) { if (!(weak.items.length === 0)) { - const again2: rt.Weak = rt.weakClone(weak.items[rt.idx(weak.items, rt.usizeRem(pick, weak.items.length))]); + const again2: rs.Weak = rs.weakClone(weak.items[rs.idx(weak.items, rs.usizeRem(pick, weak.items.length))]); weak.items.push(again2); continue; } } else if (_19 === 5) { if (!(weak.items.length === 0)) { - rt.vecSwapRemove(weak, rt.usizeRem(pick, weak.items.length))[Symbol.dispose](); + rs.vecSwapRemove(weak, rs.usizeRem(pick, weak.items.length))[Symbol.dispose](); continue; } } else if (_19 === 6) { if (!(weak.items.length === 0)) { - const _90: rt.Arc | undefined = rt.weakUpgrade(weak.items[rt.idx(weak.items, rt.usizeRem(pick, weak.items.length))]); + const _90: rs.Arc | undefined = rs.weakUpgrade(weak.items[rs.idx(weak.items, rs.usizeRem(pick, weak.items.length))]); if (_90 === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); continue; } - const up: rt.Arc = _90; - rt.byteVecPush(out, up.value.id); + const up: rs.Arc = _90; + rs.byteVecPush(out, up.value.id); strong.items.push(up); continue; } } else { if (_19 === 7) { - const _106: rt.Weak = new rt.Weak(); + const _106: rs.Weak = new rs.Weak(); weak.items.push(_106); continue; } if (_19 === 8) { if (!(strong.items.length === 0)) { - const at3 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - const held: rt.Weak | undefined = new rt.Weak(strong.items[at3]); - const kept: ArcHolder.ArcHolder = new ArcHolder.ArcHolder(new rt.Weak(strong.items[at3])); - const captured2 = new rt.Weak(strong.items[at3]); - const read: () => rt.u8 = rt.closure((): rt.u8 => { - return option_mapOr$036yrbw(rt.weakUpgrade(captured2), 253, (s: rt.Arc): rt.u8 => { - const _02: rt.u8 = s.value.id; + const at3 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + const held: rs.Weak | undefined = new rs.Weak(strong.items[at3]); + const kept: ArcHolder.ArcHolder = new ArcHolder.ArcHolder(new rs.Weak(strong.items[at3])); + const captured2 = new rs.Weak(strong.items[at3]); + const read: () => rs.u8 = rs.closure((): rs.u8 => { + return option_mapOr$025sl8y(rs.weakUpgrade(captured2), 253, (s: rs.Arc): rs.u8 => { + const _02: rs.u8 = s.value.id; s[Symbol.dispose](); return _02; }); }, (): void => { captured2[Symbol.dispose](); }); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); - rt.byteVecPush(out, read()); - rt.drop(held); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.byteVecPush(out, read()); + rs.drop(held); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); kept[Symbol.dispose](); - rt.drop(read); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.drop(read); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); continue; } } else if (_19 === 9) { if (!(strong.items.length === 0)) { - const _140: Noisy.Noisy | undefined = rt.arcGetMut(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const _140: Noisy.Noisy | undefined = rs.arcGetMut(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); if (_140 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); continue; } _140.id = _140.id ^ 16; - rt.byteVecPush(out, _140.id); + rs.byteVecPush(out, _140.id); continue; } } else if (_19 === 10) { if (!(strong.items.length === 0)) { - const at = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - const noisy2: Noisy.Noisy = rt.arcMakeMut(rt.place(() => strong.items[at], (value) => strong.items[at] = value), Noisy.clone$Clone, rt.drop); + const at = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + const noisy2: Noisy.Noisy = rs.arcMakeMut(rs.place(() => strong.items[at], (value) => strong.items[at] = value), Noisy.clone$Clone, rs.drop); noisy2.id = noisy2.id ^ 32; - rt.byteVecPush(out, noisy2.id); - rt.byteVecPush(out, strong.items[at].strong & 0xff); - rt.byteVecPush(out, strong.items[at].weak & 0xff); + rs.byteVecPush(out, noisy2.id); + rs.byteVecPush(out, strong.items[at].strong & 0xff); + rs.byteVecPush(out, strong.items[at].weak & 0xff); continue; } } } for (const _171 of strong.items) { - rt.byteVecPush(out, _171.strong & 0xff); - rt.byteVecPush(out, _171.weak & 0xff); + rs.byteVecPush(out, _171.strong & 0xff); + rs.byteVecPush(out, _171.weak & 0xff); } - const iterS3: rt.Weak[] = weak.items; + const iterS3: rs.Weak[] = weak.items; let iterI3: number = 0; while (true) { - const _184: rt.Weak | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; - if (_184 === rt.DONE) { + const _184: rs.Weak | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; + if (_184 === rs.DONE) { continue l1; } - rt.byteVecPush(out, _184.arc.strong & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(_184) & 0xff); + rs.byteVecPush(out, _184.arc.strong & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(_184) & 0xff); } } - const _194: rt.Arc | undefined = rt.sliceLast(strong.items); + const _194: rs.Arc | undefined = rs.sliceLast(strong.items); if (_194 !== undefined) { - const _200: rt.Arc = rt.arcClone(_194); - const object: rt.Arc = new rt.ArcDyn(_200, new of$counts_Noisy(_200.value)); - const weakObject: rt.Weak = new rt.Weak(object); - rt.byteVecPush(out, _194.weak & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(weakObject) & 0xff); - rt.byteVecPush(out, option_mapOr$1qmxzyf(rt.weakUpgrade(weakObject), 253, (o: rt.Arc): rt.u8 => { - const _03: rt.u8 = o.value.id$Id(); + const _200: rs.Arc = rs.arcClone(_194); + const object: rs.Arc = new rs.ArcDyn(_200, new of$counts_Noisy(_200.value)); + const weakObject: rs.Weak = new rs.Weak(object); + rs.byteVecPush(out, _194.weak & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(weakObject) & 0xff); + rs.byteVecPush(out, option_mapOr$1wnjpxi(rs.weakUpgrade(weakObject), 253, (o: rs.Arc): rs.u8 => { + const _03: rs.u8 = o.value.id$Id(); o[Symbol.dispose](); return _03; })); object[Symbol.dispose](); - rt.byteVecPush(out, weakObject.arc.strong & 0xff); + rs.byteVecPush(out, weakObject.arc.strong & 0xff); weakObject[Symbol.dispose](); } - new rt.Arc(new Noisy.Noisy(224, rt.arcClone(log)))[Symbol.dispose](); - const _228: rt.Arc | undefined = option_map$1srhyy0(rt.sliceFirst(strong.items), (a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + new rs.Arc(new Noisy.Noisy(224, rs.arcClone(log)))[Symbol.dispose](); + const _228: rs.Arc | undefined = option_map$0lz7sqj(rs.sliceFirst(strong.items), (a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); }); - rt.byteVecPush(out, option_mapOr$1iuqai4(option_asDeref$0hypa7g(_228), 253, (noisy3: Noisy.Noisy): rt.u8 => { + rs.byteVecPush(out, option_mapOr$114r0pa(option_asDeref$0hjiqyl(_228), 253, (noisy3: Noisy.Noisy): rs.u8 => { return noisy3.id; })); - rt.drop(_228); - rt.dropVec(strong); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak.items), (w: rt.Weak): rt.u8 => { - const _54: rt.Arc | undefined = rt.weakUpgrade(w); - const _06: rt.u8 = _54 === undefined ? 1 : 0; - rt.drop(_54); + rs.drop(_228); + rs.dropVec(strong); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(weak.items), (w: rs.Weak): rs.u8 => { + const _54: rs.Arc | undefined = rs.weakUpgrade(w); + const _06: rs.u8 = _54 === undefined ? 1 : 0; + rs.drop(_54); return _06; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak.items), (w2: rt.Weak): rt.u8 => { - return rt.weakWeakCount(w2) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(weak.items), (w2: rs.Weak): rs.u8 => { + return rs.weakWeakCount(w2) & 0xff; }), undefined, true); - rt.dropVec(weak); - const _250: rt.Mutex = rt.mutexLock(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_250.value)); - rt.mutexUnlock(_250); + rs.dropVec(weak); + const _250: rs.Mutex = rs.mutexLock(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_250.value)); + rs.mutexUnlock(_250); log[Symbol.dispose](); } @@ -326,138 +326,138 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { * `Noisy` whose own `Clone` runs, or a `Vec` of handles. Each clone is kept or * dropped, and each byte puts the picked handle's count and what dropped. */ -export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function clonedArcs(data: rs.ByteSlice, out: rs.ByteVec): void { let _191: boolean = false; let _192: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const handles: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (id: rt.u8): rt.Arc => { - return new rt.Arc(new Noisy.Noisy(rt.u8Mul(id, 16), rt.arcClone(log))); + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const handles: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (id: rs.u8): rs.Arc => { + return new rs.Arc(new Noisy.Noisy(rs.u8Mul(id, 16), rs.arcClone(log))); }), undefined, 4, true); - const kept: rt.Vec> = new rt.Vec(); - const shared: rt.Vec = new rt.Vec(); - const noisy: rt.Vec = new rt.Vec(); - const lists: rt.Vec>> = new rt.Vec(); - for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = op >> 4 as rt.usize; - const at = rt.idx(handles.items, rt.usizeRem(pick, handles.items.length)); + const kept: rs.Vec> = new rs.Vec(); + const shared: rs.Vec = new rs.Vec(); + const noisy: rs.Vec = new rs.Vec(); + const lists: rs.Vec>> = new rs.Vec(); + for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = op >> 4 as rs.usize; + const at = rs.idx(handles.items, rs.usizeRem(pick, handles.items.length)); const keep: boolean = (op & 8) !== 0; b2: { - const _34: rt.u8 = rt.u8Rem(op, 8); + const _34: rs.u8 = rs.u8Rem(op, 8); if (_34 === 0) { - const _37: rt.Arc | undefined = rt.sliceGet(handles.items, rt.usizeRem(pick, 4)); - const again: rt.Arc | undefined = _37 === undefined ? undefined : rt.arcClone(_37); - rt.byteVecPush(out, option_mapOr$036yrbw(again, 253, (h: rt.Arc): rt.u8 => { + const _37: rs.Arc | undefined = rs.sliceGet(handles.items, rs.usizeRem(pick, 4)); + const again: rs.Arc | undefined = _37 === undefined ? undefined : rs.arcClone(_37); + rs.byteVecPush(out, option_mapOr$025sl8y(again, 253, (h: rs.Arc): rs.u8 => { return h.value.id; })); - const _48: rt.Arc | undefined = filter$1qg98un(again, (_210: rt.Arc): boolean => { + const _48: rs.Arc | undefined = filter$1gn36in(again, (_210: rs.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold", 4, true); + rs.iterExtend(kept, rs.iterOption(_48, rs.drop), "fold", 4, true); } else if (_34 === 1) { - const _54: rt.Place> | undefined = rt.sliceGetMut(handles.items, rt.usizeRem(pick, handles.items.length)); - const _61: rt.Arc | undefined = filter$1qg98un(_54 === undefined ? undefined : rt.arcClone(_54.v), (_29: rt.Arc): boolean => { + const _54: rs.Place> | undefined = rs.sliceGetMut(handles.items, rs.usizeRem(pick, handles.items.length)); + const _61: rs.Arc | undefined = filter$1gn36in(_54 === undefined ? undefined : rs.arcClone(_54.v), (_29: rs.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold", 4, true); + rs.iterExtend(kept, rs.iterOption(_61, rs.drop), "fold", 4, true); } else if (_34 === 2) { - const _70: ArcShared.ArcShared[] = [new ArcShared.ArcShared(rt.arcClone(handles.items[at]), op)]; - const _67: ArcShared.ArcShared | undefined = rt.sliceFirst(_70); + const _70: ArcShared.ArcShared[] = [new ArcShared.ArcShared(rs.arcClone(handles.items[at]), op)]; + const _67: ArcShared.ArcShared | undefined = rs.sliceFirst(_70); const one: ArcShared.ArcShared | undefined = _67 === undefined ? undefined : ArcShared.clone$Clone(_67); - rt.dropAll(_70); - rt.byteVecPush(out, option_mapOr$1hh0iyl(one, 253, (s: ArcShared.ArcShared): rt.u8 => { + rs.dropAll(_70); + rs.byteVecPush(out, option_mapOr$1pgbs4c(one, 253, (s: ArcShared.ArcShared): rs.u8 => { return s.tag ^ s.noisy.value.id; })); const _77: ArcShared.ArcShared | undefined = filter$1asvriw(one, (_26: ArcShared.ArcShared): boolean => { return keep; }); - rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold", 8, true); + rs.iterExtend(shared, rs.iterOption(_77, rs.drop), "fold", 8, true); } else if (_34 === 3) { - const made2: Noisy.Noisy = new Noisy.Noisy(op, rt.arcClone(log)); + const made2: Noisy.Noisy = new Noisy.Noisy(op, rs.arcClone(log)); const _84: Noisy.Noisy | undefined = made2; const one2: Noisy.Noisy | undefined = _84 === undefined ? undefined : Noisy.clone$Clone(_84); - rt.byteVecPush(out, option_mapOr$1iuqai4(one2, 253, (n2: Noisy.Noisy): rt.u8 => { + rs.byteVecPush(out, option_mapOr$114r0pa(one2, 253, (n2: Noisy.Noisy): rs.u8 => { return n2.id; })); const _92: Noisy.Noisy | undefined = filter$1gka6nq(one2, (_25: Noisy.Noisy): boolean => { return keep; }); - rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold", 8, true); + rs.iterExtend(noisy, rs.iterOption(_92, rs.drop), "fold", 8, true); made2[Symbol.dispose](); } else if (_34 === 4) { - const all: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(handles.items), (a02: rt.Arc): rt.Arc => { - return rt.arcClone(a02); + const all: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(handles.items), (a02: rs.Arc): rs.Arc => { + return rs.arcClone(a02); }), undefined, 4, true); _191 = true; - rt.byteVecPush(out, handles.items[at].strong & 0xff); + rs.byteVecPush(out, handles.items[at].strong & 0xff); if (keep) { _191 = false; lists.items.push(all); } if (_191) { - rt.dropVec(all); + rs.dropVec(all); } _191 = false; } else if (_34 === 5) { - const again3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(shared.items), ArcShared.clone$Clone), undefined, 8, true); + const again3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(shared.items), ArcShared.clone$Clone), undefined, 8, true); _192 = true; - const ids: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(noisy.items), Noisy.clone$Clone), undefined, 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(ids.items), (n: Noisy.Noisy): rt.u8 => { + const ids: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(noisy.items), Noisy.clone$Clone), undefined, 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(ids.items), (n: Noisy.Noisy): rs.u8 => { return n.id; }), undefined, true); if (keep) { _192 = false; - rt.iterExtend(shared, rt.vecIntoIter(again3, rt.drop), "fold", 8, true); + rs.iterExtend(shared, rs.vecIntoIter(again3, rs.drop), "fold", 8, true); } - rt.dropVec(ids); + rs.dropVec(ids); if (_192) { - rt.dropVec(again3); + rs.dropVec(again3); } _192 = false; } else if (_34 === 6) { - const _125: rt.Vec> | undefined = rt.sliceFirst(lists.items); - const list: rt.Vec> | undefined = _125 === undefined ? undefined : rt.vecFrom(_125.items.map((a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const _125: rs.Vec> | undefined = rs.sliceFirst(lists.items); + const list: rs.Vec> | undefined = _125 === undefined ? undefined : rs.vecFrom(_125.items.map((a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); })); - rt.byteVecPush(out, option_mapOr$09pasix(list, 253, (l: rt.Vec>): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1e2t3oz(list, 253, (l: rs.Vec>): rs.u8 => { return l.items.length & 0xff; })); - const _134: rt.Vec> | undefined = filter$09u55oo(list, (_2: rt.Vec>): boolean => { + const _134: rs.Vec> | undefined = filter$02g8l8j(list, (_2: rs.Vec>): boolean => { return keep; }); - rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_sync_Arc_counts_Noisy), "fold", 12, true); + rs.iterExtend(lists, rs.iterOption(_134, drop$Vec_sync_Arc_counts_Noisy), "fold", 12, true); } else { - const _137: rt.u8 = op >> 6; + const _137: rs.u8 = op >> 6; if (_137 === 0) { if (!(kept.items.length === 0)) { - rt.vecRemove(kept, 0)[Symbol.dispose](); + rs.vecRemove(kept, 0)[Symbol.dispose](); break b2; } } else if (_137 === 1) { if (!(shared.items.length === 0)) { - rt.vecRemove(shared, 0)[Symbol.dispose](); + rs.vecRemove(shared, 0)[Symbol.dispose](); break b2; } } else if (_137 === 2) { if (!(noisy.items.length === 0)) { - rt.vecRemove(noisy, 0)[Symbol.dispose](); + rs.vecRemove(noisy, 0)[Symbol.dispose](); break b2; } } else if (_137 === 3) { if (handles.items.length > 1) { - rt.vecRemove(handles, rt.usizeRem(pick, handles.items.length))[Symbol.dispose](); + rs.vecRemove(handles, rs.usizeRem(pick, handles.items.length))[Symbol.dispose](); break b2; } } - rt.dropVec(rt.vecPop(lists)); + rs.dropVec(rs.vecPop(lists)); } } - rt.byteVecPush(out, handles.items[rt.idx(handles.items, rt.usizeRem(pick, handles.items.length))].strong & 0xff); + rs.byteVecPush(out, handles.items[rs.idx(handles.items, rs.usizeRem(pick, handles.items.length))].strong & 0xff); flush(log.value, out); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(handles.items), (h2: rt.Arc): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(handles.items), (h2: rs.Arc): rs.u8 => { return h2.strong & 0xff; }), undefined, true); - drop$tuple5_Vec_sync_Arc_counts_Noisy_Vec_sync_Arc_counts_Noisy_Vec_counts_ArcShared_Vec_counts_Noisy_Vec_Vec_sync_Arc_counts_Noisy([handles, kept, shared, noisy, lists] as [rt.Vec>, rt.Vec>, rt.Vec, rt.Vec, rt.Vec>>]); + drop$tuple5_Vec_sync_Arc_counts_Noisy_Vec_sync_Arc_counts_Noisy_Vec_counts_ArcShared_Vec_counts_Noisy_Vec_Vec_sync_Arc_counts_Noisy([handles, kept, shared, noisy, lists] as [rs.Vec>, rs.Vec>, rs.Vec, rs.Vec, rs.Vec>>]); flush(log.value, out); log[Symbol.dispose](); } @@ -468,23 +468,23 @@ export function clonedArcs(data: rt.ByteSlice, out: rt.ByteVec): void { * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { - let node!: rt.Arc; +export function cyclicArcs(data: rs.ByteSlice, out: rs.ByteVec): void { + let node!: rs.Arc; let _95: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const kept: rt.Vec> = new rt.Vec(); - const outside: rt.Vec> = new rt.Vec(); - for (const op of rt.byteSliceView(data)) { - const _15: rt.Arc> = rt.arcClone(log); + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const kept: rs.Vec> = new rs.Vec(); + const outside: rs.Vec> = new rs.Vec(); + for (const op of rs.byteSliceView(data)) { + const _15: rs.Arc> = rs.arcClone(log); _95 = true; const noisy: Noisy.Noisy = new Noisy.Noisy(op, _15); - const more: rt.u8 = rt.u8Rem(op >> 2, 4); - const _23: rt.u8 = rt.u8Rem(op, 4); + const more: rs.u8 = rs.u8Rem(op >> 2, 4); + const _23: rs.u8 = rs.u8Rem(op, 4); if (_23 === 0) { _95 = false; const captured5 = noisy; const captured6 = more; - node = rt.arcNewCyclic(rt.closure((this_4: rt.Weak): ArcNode.ArcNode => { + node = rs.arcNewCyclic(rs.closure((this_4: rs.Weak): ArcNode.ArcNode => { return ArcNode.new(this_4, captured5, captured6); }, (): void => { captured5[Symbol.dispose](); @@ -493,8 +493,8 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { _95 = false; const captured3 = noisy; const captured4 = more; - node = rt.arcNewCyclic(rt.closure((this_3: rt.Weak): ArcNode.ArcNode => { - const _03: ArcNode.ArcNode = ArcNode.new(this_3, new Noisy.Noisy(captured3.id ^ 128, rt.arcClone(captured3.log)), captured4); + node = rs.arcNewCyclic(rs.closure((this_3: rs.Weak): ArcNode.ArcNode => { + const _03: ArcNode.ArcNode = ArcNode.new(this_3, new Noisy.Noisy(captured3.id ^ 128, rs.arcClone(captured3.log)), captured4); captured3[Symbol.dispose](); return _03; }, (): void => { @@ -504,35 +504,35 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { _95 = false; const captured = noisy; const captured2 = more; - node = rt.arcNewCyclic(rt.once(rt.closure((this_2: rt.Weak): ArcNode.ArcNode => { - return ArcNode.new(this_2, new Noisy.Noisy(captured.id ^ 64, rt.arcClone(captured.log)), captured2); + node = rs.arcNewCyclic(rs.once(rs.closure((this_2: rs.Weak): ArcNode.ArcNode => { + return ArcNode.new(this_2, new Noisy.Noisy(captured.id ^ 64, rs.arcClone(captured.log)), captured2); }, (): void => { captured[Symbol.dispose](); }))); } else { - node = rt.arcNewCyclic((this_: rt.Weak): ArcNode.ArcNode => { - return ArcNode.new(this_, new Noisy.Noisy(238, rt.arcClone(log)), more); + node = rs.arcNewCyclic((this_: rs.Weak): ArcNode.ArcNode => { + return ArcNode.new(this_, new Noisy.Noisy(238, rs.arcClone(log)), more); }); } - rt.iterExtendBytes(out, rt.iterSlice(copy$array_u8(node.value.seen)), undefined, true); - rt.byteVecPush(out, node.strong & 0xff); - rt.byteVecPush(out, node.weak & 0xff); - rt.byteVecPush(out, node.value.more.items.length & 0xff); - rt.byteVecPush(out, option_mapOr$0dgmbpi(rt.weakUpgrade(node.value.this), 253, (n: rt.Arc): rt.u8 => { - const _05: rt.u8 = n.value.noisy.id; + rs.iterExtendBytes(out, rs.iterSlice(copy$array_u8(node.value.seen)), undefined, true); + rs.byteVecPush(out, node.strong & 0xff); + rs.byteVecPush(out, node.weak & 0xff); + rs.byteVecPush(out, node.value.more.items.length & 0xff); + rs.byteVecPush(out, option_mapOr$1jexokn(rs.weakUpgrade(node.value.this), 253, (n: rs.Arc): rs.u8 => { + const _05: rs.u8 = n.value.noisy.id; n[Symbol.dispose](); return _05; })); const _59: ArcNode.ArcNode = node.value; - const _62: rt.Weak = new rt.Weak(node); - rt.byteVecPush(out, _59.this.arc === _62.arc ? 1 : 0); + const _62: rs.Weak = new rs.Weak(node); + rs.byteVecPush(out, _59.this.arc === _62.arc ? 1 : 0); _62[Symbol.dispose](); - rt.byteVecPush(out, node.weak & 0xff); - const _69: rt.u8 = op >> 6; + rs.byteVecPush(out, node.weak & 0xff); + const _69: rs.u8 = op >> 6; if (_69 === 0) { kept.items.push(node); } else if (_69 === 1) { - const _76: rt.Weak = new rt.Weak(node); + const _76: rs.Weak = new rs.Weak(node); outside.items.push(_76); node[Symbol.dispose](); } else { @@ -544,12 +544,12 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { } _95 = false; } - rt.dropVec(kept); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(outside.items), (w: rt.Weak): rt.u8 => { + rs.dropVec(kept); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(outside.items), (w: rs.Weak): rs.u8 => { return w.arc.strong & 0xff; }), undefined, true); flush(log.value, out); - rt.dropVec(outside); + rs.dropVec(outside); log[Symbol.dispose](); } @@ -558,122 +558,122 @@ export function cyclicArcs(data: rt.ByteSlice, out: rt.ByteVec): void { * the rest of it the handle it picks; each puts what it read and the picked * handle's counts. */ -export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { - let _52!: rt.Place | undefined; - let value2!: rt.Place; - const strong: rt.Vec> = rt.vecFrom([new rt.Arc(0)]); - const weak: rt.Vec> = new rt.Vec(); - const iterS: Uint8Array = rt.byteSliceView(data); +export function uniqueArcs(data: rs.ByteSlice, out: rs.ByteVec): void { + let _52!: rs.Place | undefined; + let value2!: rs.Place; + const strong: rs.Vec> = rs.vecFrom([new rs.Arc(0)]); + const weak: rs.Vec> = new rs.Vec(); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _11: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - const getMut: (a0: rt.Place>) => rt.Place | undefined = (a0: rt.Place>): rt.Place | undefined => { - return rt.arcGetMutPlace(a0.v); + const _11: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + const getMut: (a0: rs.Place>) => rs.Place | undefined = (a0: rs.Place>): rs.Place | undefined => { + return rs.arcGetMutPlace(a0.v); }; - const makeMut: (a0: rt.Place>) => rt.Place = (a02: rt.Place>): rt.Place => { - return rt.arcMakeMutPlace(a02, undefined, rt.drop); + const makeMut: (a0: rs.Place>) => rs.Place = (a02: rs.Place>): rs.Place => { + return rs.arcMakeMutPlace(a02, undefined, rs.drop); }; - if (_11 === rt.DONE) { + if (_11 === rs.DONE) { break; } - const op: rt.u8 = _11; - const pick: rt.usize = rt.usizeRem(op >> 3 as rt.usize, strong.items.length); + const op: rs.u8 = _11; + const pick: rs.usize = rs.usizeRem(op >> 3 as rs.usize, strong.items.length); b2: { - const _24: rt.u8 = rt.u8Rem(op, 7); + const _24: rs.u8 = rs.u8Rem(op, 7); if (_24 === 0) { - const _27: rt.Arc = new rt.Arc(op); + const _27: rs.Arc = new rs.Arc(op); strong.items.push(_27); } else if (_24 === 1) { - const again: rt.Arc = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); + const again: rs.Arc = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); strong.items.push(again); } else if (_24 === 2) { - const _34: rt.Weak = new rt.Weak(strong.items[rt.idx(strong.items, pick)]); + const _34: rs.Weak = new rs.Weak(strong.items[rs.idx(strong.items, pick)]); weak.items.push(_34); } else if (_24 === 3) { if (strong.items.length > 1) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, pick)[Symbol.dispose](); + rs.vecSwapRemove(strong, pick)[Symbol.dispose](); break b2; } } if (!(strong.items.length > 1)) { - rt.vecTruncate(weak, 0, rt.drop); + rs.vecTruncate(weak, 0, rs.drop); } else { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.arcIntoInner(rt.vecSwapRemove(strong, pick)), 251)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.arcIntoInner(rs.vecSwapRemove(strong, pick)), 251)); } } else if (_24 === 4) { if (!((op & 128) === 0)) { - const at5 = rt.idx(strong.items, pick); - _52 = getMut(rt.place(() => strong.items[at5], (value5) => strong.items[at5] = value5)); + const at5 = rs.idx(strong.items, pick); + _52 = getMut(rs.place(() => strong.items[at5], (value5) => strong.items[at5] = value5)); } else { - _52 = rt.arcGetMutPlace(strong.items[rt.idx(strong.items, pick)]); + _52 = rs.arcGetMutPlace(strong.items[rs.idx(strong.items, pick)]); } if (_52 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { - const value: rt.Place = _52; - value.v = rt.u8WrappingAdd(value.v, op); - rt.byteVecPush(out, value.v); + const value: rs.Place = _52; + value.v = rs.u8WrappingAdd(value.v, op); + rs.byteVecPush(out, value.v); } } else if (_24 === 5) { if (!((op & 128) === 0)) { - const at3 = rt.idx(strong.items, pick); - value2 = makeMut(rt.place(() => strong.items[at3], (value4) => strong.items[at3] = value4)); + const at3 = rs.idx(strong.items, pick); + value2 = makeMut(rs.place(() => strong.items[at3], (value4) => strong.items[at3] = value4)); } else { - const at2 = rt.idx(strong.items, pick); - value2 = rt.arcMakeMutPlace(rt.place(() => strong.items[at2], (value3) => strong.items[at2] = value3), undefined, rt.drop); + const at2 = rs.idx(strong.items, pick); + value2 = rs.arcMakeMutPlace(rs.place(() => strong.items[at2], (value3) => strong.items[at2] = value3), undefined, rs.drop); } value2.v = value2.v ^ op; - rt.byteVecPush(out, value2.v); + rs.byteVecPush(out, value2.v); } else { - const pinned: rt.Arc = new rt.Arc(op); - const held: rt.Arc | undefined = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pinned.value, option_unwrapOr$0r2bmpr(option_asDeref$0s3650c(held), 251)))); - rt.drop(held); + const pinned: rs.Arc = new rs.Arc(op); + const held: rs.Arc | undefined = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pinned.value, option_unwrapOr$1fr498u(option_asDeref$1l62o5g(held), 251)))); + rs.drop(held); pinned[Symbol.dispose](); } } - const at8 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(strong.items[at8].value, strong.items[at8].strong & 0xff, strong.items[at8].weak & 0xff))); + const at8 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(strong.items[at8].value, strong.items[at8].strong & 0xff, strong.items[at8].weak & 0xff))); } for (const _110 of weak.items) { - rt.byteVecPush(out, option_mapOr$1q3ff8g(rt.weakUpgrade(_110), 253, (s: rt.Arc): rt.u8 => { - const _03: rt.u8 = s.value; + rs.byteVecPush(out, option_mapOr$1gfk3jk(rs.weakUpgrade(_110), 253, (s: rs.Arc): rs.u8 => { + const _03: rs.u8 = s.value; s[Symbol.dispose](); return _03; })); - rt.byteVecPush(out, _110.arc.strong & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(_110) & 0xff); + rs.byteVecPush(out, _110.arc.strong & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(_110) & 0xff); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(strong.items), (s2: rt.Arc): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(strong.items), (s2: rs.Arc): rs.u8 => { return s2.value; }), undefined, true); - const others: rt.Arc>>> = new rt.Arc(new rt.RefCell(new rt.Vec())); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - let first: rt.Arc = new rt.Arc(new ArcReleasing.ArcReleasing(data.length & 0xff, rt.arcClone(others), rt.arcClone(log))); - const shared: rt.u8 = option_mapOr$1surhce(rt.byteSliceFirst(data), 1, (b: rt.u8): rt.u8 => { - return rt.u8Add(rt.u8Rem(b, 3), 1); + const others: rs.Arc>>> = new rs.Arc(new rs.RefCell(new rs.Vec())); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + let first: rs.Arc = new rs.Arc(new ArcReleasing.ArcReleasing(data.length & 0xff, rs.arcClone(others), rs.arcClone(log))); + const shared: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 1, (b: rs.u8): rs.u8 => { + return rs.u8Add(rs.u8Rem(b, 3), 1); }); - const _147: rt.RefCell>> = rt.refCellBorrowMut(others.value); - const _150: rt.Iter> = rt.iterMap(new rt.Range(0, shared), (_2: rt.u8): rt.Arc => { - return rt.arcClone(first); + const _147: rs.RefCell>> = rs.refCellBorrowMut(others.value); + const _150: rs.Iter> = rs.iterMap(new rs.Range(0, shared), (_2: rs.u8): rs.Arc => { + return rs.arcClone(first); }); - rt.iterExtend(_147.value, _150, undefined, 4, true); - rt.refMutRelease(_147); - const _154: ArcReleasing.ArcReleasing = rt.arcMakeMut(rt.place(() => first, (value6) => first = value6), ArcReleasing.clone$Clone, rt.drop); + rs.iterExtend(_147.value, _150, undefined, 4, true); + rs.refMutRelease(_147); + const _154: ArcReleasing.ArcReleasing = rs.arcMakeMut(rs.place(() => first, (value6) => first = value6), ArcReleasing.clone$Clone, rs.drop); _154.id = _154.id ^ 64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.value.id, first.strong & 0xff))); - const _170: rt.RefCell = rt.refCellBorrow(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_170.value)); - rt.refRelease(_170); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(first.value.id, first.strong & 0xff))); + const _170: rs.RefCell = rs.refCellBorrow(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_170.value)); + rs.refRelease(_170); first[Symbol.dispose](); - const _179: rt.RefCell = rt.refCellBorrow(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_179.value)); - rt.refRelease(_179); + const _179: rs.RefCell = rs.refCellBorrow(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_179.value)); + rs.refRelease(_179); log[Symbol.dispose](); - rt.arcDrop(others, drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing); - rt.dropVec(weak); - rt.dropVec(strong); + rs.arcDrop(others, drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing); + rs.dropVec(weak); + rs.dropVec(strong); } /** @@ -683,114 +683,114 @@ export function uniqueArcs(data: rt.ByteSlice, out: rt.ByteVec): void { * keeps the allocation `as_ptr` points at only when no other handle, strong or weak, * shares it, and a read through `as_ptr` sees each write. */ -export function addressedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const strong: rt.Vec> = rt.vecFrom([new rt.Arc([0, 1] as [rt.u8, rt.u8])]); - const weak: rt.Vec> = new rt.Vec(); - let bytes: rt.Arc = new rt.Arc(Uint8Array.of(2, 3)); - const number: rt.Arc = new rt.Arc(4); - let maybe: rt.Arc<[rt.u8, rt.u8] | undefined> = new rt.Arc([5, 6] as [rt.u8, rt.u8]); - let unread: rt.Arc<[rt.u16, rt.u8]> = new rt.Arc([7, 8] as [rt.u16, rt.u8]); - let unit: rt.Arc = new rt.Arc(undefined); - for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = rt.usizeRem(op >> 3 as rt.usize, strong.items.length); +export function addressedRcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const strong: rs.Vec> = rs.vecFrom([new rs.Arc([0, 1] as [rs.u8, rs.u8])]); + const weak: rs.Vec> = new rs.Vec(); + let bytes: rs.Arc = new rs.Arc(Uint8Array.of(2, 3)); + const number: rs.Arc = new rs.Arc(4); + let maybe: rs.Arc<[rs.u8, rs.u8] | undefined> = new rs.Arc([5, 6] as [rs.u8, rs.u8]); + let unread: rs.Arc<[rs.u16, rs.u8]> = new rs.Arc([7, 8] as [rs.u16, rs.u8]); + let unit: rs.Arc = new rs.Arc(undefined); + for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = rs.usizeRem(op >> 3 as rs.usize, strong.items.length); b2: { - const _32: rt.u8 = rt.u8Rem(op, 6); + const _32: rs.u8 = rs.u8Rem(op, 6); if (_32 === 0) { - const _35: rt.Arc<[rt.u8, rt.u8]> = new rt.Arc([op, 0] as [rt.u8, rt.u8]); + const _35: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([op, 0] as [rs.u8, rs.u8]); strong.items.push(_35); } else if (_32 === 1) { - const again: rt.Arc<[rt.u8, rt.u8]> = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); + const again: rs.Arc<[rs.u8, rs.u8]> = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); strong.items.push(again); } else if (_32 === 2) { - const _43: rt.Weak<[rt.u8, rt.u8]> = new rt.Weak(strong.items[rt.idx(strong.items, pick)]); + const _43: rs.Weak<[rs.u8, rs.u8]> = new rs.Weak(strong.items[rs.idx(strong.items, pick)]); weak.items.push(_43); } else if (_32 === 3) { if (strong.items.length > 1) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, pick)[Symbol.dispose](); + rs.vecSwapRemove(strong, pick)[Symbol.dispose](); break b2; } } - rt.vecTruncate(weak, 0, rt.drop); + rs.vecTruncate(weak, 0, rs.drop); } else if (_32 === 4) { - const arc8 = strong.items[rt.idx(strong.items, pick)]; - const before: [rt.u8, rt.u8] = rt.arcRaw(arc8, arc8.value, "Rc"); - const at3 = rt.idx(strong.items, pick); - const _57: [rt.u8, rt.u8] = rt.arcMakeMut(rt.place(() => strong.items[at3], (value5) => strong.items[at3] = value5), copy$tuple2_u8_u8, rt.drop, copy$tuple2_u8_u8); + const arc8 = strong.items[rs.idx(strong.items, pick)]; + const before: [rs.u8, rs.u8] = rs.arcRaw(arc8, arc8.value, "Rc"); + const at3 = rs.idx(strong.items, pick); + const _57: [rs.u8, rs.u8] = rs.arcMakeMut(rs.place(() => strong.items[at3], (value5) => strong.items[at3] = value5), copy$tuple2_u8_u8, rs.drop, copy$tuple2_u8_u8); _57[1] = _57[1] ^ op; - const arc9 = strong.items[rt.idx(strong.items, pick)]; - const after: [rt.u8, rt.u8] = rt.arcRaw(arc9, arc9.value, "Rc"); - rt.byteVecPush(out, before === after ? 1 : 0); - rt.byteVecPush(out, after === strong.items[rt.idx(strong.items, pick)].value ? 1 : 0); - rt.byteVecPush(out, after[1]); + const arc9 = strong.items[rs.idx(strong.items, pick)]; + const after: [rs.u8, rs.u8] = rs.arcRaw(arc9, arc9.value, "Rc"); + rs.byteVecPush(out, before === after ? 1 : 0); + rs.byteVecPush(out, after === strong.items[rs.idx(strong.items, pick)].value ? 1 : 0); + rs.byteVecPush(out, after[1]); } else { - const shadow: rt.Arc | undefined = then$1i5jtpz((op & 128) !== 0, (): rt.Arc => { - return rt.arcClone(bytes); + const shadow: rs.Arc | undefined = then$1qgzik7((op & 128) !== 0, (): rs.Arc => { + return rs.arcClone(bytes); }); - const before2: rt.ByteSlice = rt.byteSliceFrom(bytes.value); - const _82: rt.ByteSlice = rt.byteSliceFrom(rt.arcMakeMut(rt.place(() => bytes, (value) => bytes = value), copy$array_u8, rt.drop, copy$array_u8)); + const before2: rs.ByteSlice = rs.byteSliceFrom(bytes.value); + const _82: rs.ByteSlice = rs.byteSliceFrom(rs.arcMakeMut(rs.place(() => bytes, (value) => bytes = value), copy$array_u8, rs.drop, copy$array_u8)); _82.data[_82.start] = _82.data[_82.start] ^ op; - const after2: rt.ByteSlice = rt.byteSliceFrom(bytes.value); - rt.byteVecPush(out, rt.byteSliceSame(before2, after2) ? 1 : 0); - rt.byteVecExtendFromSlice(out, after2); - rt.drop(shadow); + const after2: rs.ByteSlice = rs.byteSliceFrom(bytes.value); + rs.byteVecPush(out, rs.byteSliceSame(before2, after2) ? 1 : 0); + rs.byteVecExtendFromSlice(out, after2); + rs.drop(shadow); const arc = number; - const at: rt.Place = rt.arcRaw(arc, rt.arcPlace(arc), "Rc"); - const _97: rt.Place | undefined = rt.arcGetMutPlace(number); + const at: rs.Place = rs.arcRaw(arc, rs.arcPlace(arc), "Rc"); + const _97: rs.Place | undefined = rs.arcGetMutPlace(number); if (_97 !== undefined) { _97.v = _97.v ^ op; } - rt.byteVecPush(out, at.v); - const kept: rt.Weak<[rt.u8, rt.u8] | undefined> | undefined = then$0kpp40i((op & 64) !== 0, (): rt.Weak<[rt.u8, rt.u8] | undefined> => { - return new rt.Weak(maybe); + rs.byteVecPush(out, at.v); + const kept: rs.Weak<[rs.u8, rs.u8] | undefined> | undefined = then$0mwg5pd((op & 64) !== 0, (): rs.Weak<[rs.u8, rs.u8] | undefined> => { + return new rs.Weak(maybe); }); - const _108: [rt.u8, rt.u8] | undefined = rt.arcMakeMutPlace(rt.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u8_u8, rt.drop, copy$Option_tuple2_u8_u8).v; + const _108: [rs.u8, rs.u8] | undefined = rs.arcMakeMutPlace(rs.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u8_u8, rs.drop, copy$Option_tuple2_u8_u8).v; if (_108 !== undefined) { _108[0] = _108[0] ^ op; } - rt.byteVecPush(out, option_mapOr$1cxzjxo(copy$Option_tuple2_u8_u8(maybe.value), 253, (_2: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1p1hmiu(copy$Option_tuple2_u8_u8(maybe.value), 253, (_2: [rs.u8, rs.u8]): rs.u8 => { return _2[0]; })); - rt.drop(kept); - const kept2: rt.Weak<[rt.u16, rt.u8]> | undefined = then$0t3e9mp((op & 64) !== 0, (): rt.Weak<[rt.u16, rt.u8]> => { - return new rt.Weak(unread); + rs.drop(kept); + const kept2: rs.Weak<[rs.u16, rs.u8]> | undefined = then$1rzp7o9((op & 64) !== 0, (): rs.Weak<[rs.u16, rs.u8]> => { + return new rs.Weak(unread); }); - const shadow2: rt.Arc<[rt.u16, rt.u8]> | undefined = then$1vw965y((op & 32) !== 0, (): rt.Arc<[rt.u16, rt.u8]> => { - return rt.arcClone(unread); + const shadow2: rs.Arc<[rs.u16, rs.u8]> | undefined = then$12a283y((op & 32) !== 0, (): rs.Arc<[rs.u16, rs.u8]> => { + return rs.arcClone(unread); }); const arc2 = unread; - const before3: [rt.u16, rt.u8] = rt.arcRaw(arc2, arc2.value, "Rc"); - const pair: [rt.u16, rt.u8] = copy$tuple2_u16_u8(rt.arcMakeMut(rt.place(() => unread, (value3) => unread = value3), copy$tuple2_u16_u8, rt.drop, copy$tuple2_u16_u8)); + const before3: [rs.u16, rs.u8] = rs.arcRaw(arc2, arc2.value, "Rc"); + const pair: [rs.u16, rs.u8] = copy$tuple2_u16_u8(rs.arcMakeMut(rs.place(() => unread, (value3) => unread = value3), copy$tuple2_u16_u8, rs.drop, copy$tuple2_u16_u8)); const arc3 = unread; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before3 === rt.arcRaw(arc3, arc3.value, "Rc") ? 1 : 0, pair[1])), undefined, true); - drop$tuple2_Option_rc_Weak_tuple2_u16_u8_Option_Rc_tuple2_u16_u8([kept2, shadow2] as [rt.Weak<[rt.u16, rt.u8]> | undefined, rt.Arc<[rt.u16, rt.u8]> | undefined]); - const other: rt.Arc = new rt.Arc(undefined); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before3 === rs.arcRaw(arc3, arc3.value, "Rc") ? 1 : 0, pair[1])), undefined, true); + drop$tuple2_Option_rc_Weak_tuple2_u16_u8_Option_Rc_tuple2_u16_u8([kept2, shadow2] as [rs.Weak<[rs.u16, rs.u8]> | undefined, rs.Arc<[rs.u16, rs.u8]> | undefined]); + const other: rs.Arc = new rs.Arc(undefined); const arc4 = unit; - const before4: rt.Place = rt.arcRaw(arc4, rt.arcPlace(arc4), "Rc"); - const shadow3: rt.Arc | undefined = then$0duifht((op & 128) !== 0, (): rt.Arc => { - return rt.arcClone(unit); + const before4: rs.Place = rs.arcRaw(arc4, rs.arcPlace(arc4), "Rc"); + const shadow3: rs.Arc | undefined = then$1vmvrid((op & 128) !== 0, (): rs.Arc => { + return rs.arcClone(unit); }); - rt.arcMakeMutPlace(rt.place(() => unit, (value4) => unit = value4), undefined, rt.drop); + rs.arcMakeMutPlace(rs.place(() => unit, (value4) => unit = value4), undefined, rs.drop); const arc5 = unit; - const _155: rt.u8 = before4 === rt.arcRaw(arc5, rt.arcPlace(arc5), "Rc") ? 1 : 0; + const _155: rs.u8 = before4 === rs.arcRaw(arc5, rs.arcPlace(arc5), "Rc") ? 1 : 0; const arc6 = other; - const _161: rt.Place = rt.arcRaw(arc6, rt.arcPlace(arc6), "Rc"); + const _161: rs.Place = rs.arcRaw(arc6, rs.arcPlace(arc6), "Rc"); const arc7 = unit; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_155, _161 === rt.arcRaw(arc7, rt.arcPlace(arc7), "Rc") ? 1 : 0)), undefined, true); - rt.drop(shadow3); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_155, _161 === rs.arcRaw(arc7, rs.arcPlace(arc7), "Rc") ? 1 : 0)), undefined, true); + rs.drop(shadow3); other[Symbol.dispose](); } } - const at8 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(strong.items[at8].value[0], strong.items[at8].value[1], strong.items[at8].strong & 0xff))); + const at8 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(strong.items[at8].value[0], strong.items[at8].value[1], strong.items[at8].strong & 0xff))); } unit[Symbol.dispose](); unread[Symbol.dispose](); maybe[Symbol.dispose](); number[Symbol.dispose](); bytes[Symbol.dispose](); - rt.dropVec(weak); - rt.dropVec(strong); + rs.dropVec(weak); + rs.dropVec(strong); } /** @@ -799,138 +799,138 @@ export function addressedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { * `Noisy` whose own `Clone` runs, or a `Vec` of handles. Each clone is kept or * dropped, and each byte puts the picked handle's count and what dropped. */ -export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function clonedRcs(data: rs.ByteSlice, out: rs.ByteVec): void { let _191: boolean = false; let _192: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const handles: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (id: rt.u8): rt.Arc => { - return new rt.Arc(new Noisy.Noisy(rt.u8Mul(id, 16), rt.arcClone(log))); + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const handles: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (id: rs.u8): rs.Arc => { + return new rs.Arc(new Noisy.Noisy(rs.u8Mul(id, 16), rs.arcClone(log))); }), undefined, 4, true); - const kept: rt.Vec> = new rt.Vec(); - const shared: rt.Vec = new rt.Vec(); - const noisy: rt.Vec = new rt.Vec(); - const lists: rt.Vec>> = new rt.Vec(); - for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = op >> 4 as rt.usize; - const at = rt.idx(handles.items, rt.usizeRem(pick, handles.items.length)); + const kept: rs.Vec> = new rs.Vec(); + const shared: rs.Vec = new rs.Vec(); + const noisy: rs.Vec = new rs.Vec(); + const lists: rs.Vec>> = new rs.Vec(); + for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = op >> 4 as rs.usize; + const at = rs.idx(handles.items, rs.usizeRem(pick, handles.items.length)); const keep: boolean = (op & 8) !== 0; b2: { - const _34: rt.u8 = rt.u8Rem(op, 8); + const _34: rs.u8 = rs.u8Rem(op, 8); if (_34 === 0) { - const _37: rt.Arc | undefined = rt.sliceGet(handles.items, rt.usizeRem(pick, 4)); - const again: rt.Arc | undefined = _37 === undefined ? undefined : rt.arcClone(_37); - rt.byteVecPush(out, option_mapOr$036yrbw(again, 253, (h: rt.Arc): rt.u8 => { + const _37: rs.Arc | undefined = rs.sliceGet(handles.items, rs.usizeRem(pick, 4)); + const again: rs.Arc | undefined = _37 === undefined ? undefined : rs.arcClone(_37); + rs.byteVecPush(out, option_mapOr$025sl8y(again, 253, (h: rs.Arc): rs.u8 => { return h.value.id; })); - const _48: rt.Arc | undefined = filter$1qg98un(again, (_210: rt.Arc): boolean => { + const _48: rs.Arc | undefined = filter$1gn36in(again, (_210: rs.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_48, rt.drop), "fold", 4, true); + rs.iterExtend(kept, rs.iterOption(_48, rs.drop), "fold", 4, true); } else if (_34 === 1) { - const _54: rt.Place> | undefined = rt.sliceGetMut(handles.items, rt.usizeRem(pick, handles.items.length)); - const _61: rt.Arc | undefined = filter$1qg98un(_54 === undefined ? undefined : rt.arcClone(_54.v), (_29: rt.Arc): boolean => { + const _54: rs.Place> | undefined = rs.sliceGetMut(handles.items, rs.usizeRem(pick, handles.items.length)); + const _61: rs.Arc | undefined = filter$1gn36in(_54 === undefined ? undefined : rs.arcClone(_54.v), (_29: rs.Arc): boolean => { return keep; }); - rt.iterExtend(kept, rt.iterOption(_61, rt.drop), "fold", 4, true); + rs.iterExtend(kept, rs.iterOption(_61, rs.drop), "fold", 4, true); } else if (_34 === 2) { - const _70: RcShared.RcShared[] = [new RcShared.RcShared(rt.arcClone(handles.items[at]), op)]; - const _67: RcShared.RcShared | undefined = rt.sliceFirst(_70); + const _70: RcShared.RcShared[] = [new RcShared.RcShared(rs.arcClone(handles.items[at]), op)]; + const _67: RcShared.RcShared | undefined = rs.sliceFirst(_70); const one: RcShared.RcShared | undefined = _67 === undefined ? undefined : RcShared.clone$Clone(_67); - rt.dropAll(_70); - rt.byteVecPush(out, option_mapOr$1kfudqo(one, 253, (s: RcShared.RcShared): rt.u8 => { + rs.dropAll(_70); + rs.byteVecPush(out, option_mapOr$1jfh4wo(one, 253, (s: RcShared.RcShared): rs.u8 => { return s.tag ^ s.noisy.value.id; })); const _77: RcShared.RcShared | undefined = filter$14b5774(one, (_26: RcShared.RcShared): boolean => { return keep; }); - rt.iterExtend(shared, rt.iterOption(_77, rt.drop), "fold", 8, true); + rs.iterExtend(shared, rs.iterOption(_77, rs.drop), "fold", 8, true); } else if (_34 === 3) { - const made2: Noisy.Noisy = new Noisy.Noisy(op, rt.arcClone(log)); + const made2: Noisy.Noisy = new Noisy.Noisy(op, rs.arcClone(log)); const _84: Noisy.Noisy | undefined = made2; const one2: Noisy.Noisy | undefined = _84 === undefined ? undefined : Noisy.clone$Clone(_84); - rt.byteVecPush(out, option_mapOr$1iuqai4(one2, 253, (n2: Noisy.Noisy): rt.u8 => { + rs.byteVecPush(out, option_mapOr$114r0pa(one2, 253, (n2: Noisy.Noisy): rs.u8 => { return n2.id; })); const _92: Noisy.Noisy | undefined = filter$1gka6nq(one2, (_25: Noisy.Noisy): boolean => { return keep; }); - rt.iterExtend(noisy, rt.iterOption(_92, rt.drop), "fold", 8, true); + rs.iterExtend(noisy, rs.iterOption(_92, rs.drop), "fold", 8, true); made2[Symbol.dispose](); } else if (_34 === 4) { - const all: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(handles.items), (a02: rt.Arc): rt.Arc => { - return rt.arcClone(a02); + const all: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(handles.items), (a02: rs.Arc): rs.Arc => { + return rs.arcClone(a02); }), undefined, 4, true); _191 = true; - rt.byteVecPush(out, handles.items[at].strong & 0xff); + rs.byteVecPush(out, handles.items[at].strong & 0xff); if (keep) { _191 = false; lists.items.push(all); } if (_191) { - rt.dropVec(all); + rs.dropVec(all); } _191 = false; } else if (_34 === 5) { - const again3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(shared.items), RcShared.clone$Clone), undefined, 8, true); + const again3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(shared.items), RcShared.clone$Clone), undefined, 8, true); _192 = true; - const ids: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(noisy.items), Noisy.clone$Clone), undefined, 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(ids.items), (n: Noisy.Noisy): rt.u8 => { + const ids: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(noisy.items), Noisy.clone$Clone), undefined, 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(ids.items), (n: Noisy.Noisy): rs.u8 => { return n.id; }), undefined, true); if (keep) { _192 = false; - rt.iterExtend(shared, rt.vecIntoIter(again3, rt.drop), "fold", 8, true); + rs.iterExtend(shared, rs.vecIntoIter(again3, rs.drop), "fold", 8, true); } - rt.dropVec(ids); + rs.dropVec(ids); if (_192) { - rt.dropVec(again3); + rs.dropVec(again3); } _192 = false; } else if (_34 === 6) { - const _125: rt.Vec> | undefined = rt.sliceFirst(lists.items); - const list: rt.Vec> | undefined = _125 === undefined ? undefined : rt.vecFrom(_125.items.map((a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const _125: rs.Vec> | undefined = rs.sliceFirst(lists.items); + const list: rs.Vec> | undefined = _125 === undefined ? undefined : rs.vecFrom(_125.items.map((a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); })); - rt.byteVecPush(out, option_mapOr$09pasix(list, 253, (l: rt.Vec>): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1e2t3oz(list, 253, (l: rs.Vec>): rs.u8 => { return l.items.length & 0xff; })); - const _134: rt.Vec> | undefined = filter$09u55oo(list, (_2: rt.Vec>): boolean => { + const _134: rs.Vec> | undefined = filter$02g8l8j(list, (_2: rs.Vec>): boolean => { return keep; }); - rt.iterExtend(lists, rt.iterOption(_134, drop$Vec_Rc_counts_Noisy), "fold", 12, true); + rs.iterExtend(lists, rs.iterOption(_134, drop$Vec_Rc_counts_Noisy), "fold", 12, true); } else { - const _137: rt.u8 = op >> 6; + const _137: rs.u8 = op >> 6; if (_137 === 0) { if (!(kept.items.length === 0)) { - rt.vecRemove(kept, 0)[Symbol.dispose](); + rs.vecRemove(kept, 0)[Symbol.dispose](); break b2; } } else if (_137 === 1) { if (!(shared.items.length === 0)) { - rt.vecRemove(shared, 0)[Symbol.dispose](); + rs.vecRemove(shared, 0)[Symbol.dispose](); break b2; } } else if (_137 === 2) { if (!(noisy.items.length === 0)) { - rt.vecRemove(noisy, 0)[Symbol.dispose](); + rs.vecRemove(noisy, 0)[Symbol.dispose](); break b2; } } else if (_137 === 3) { if (handles.items.length > 1) { - rt.vecRemove(handles, rt.usizeRem(pick, handles.items.length))[Symbol.dispose](); + rs.vecRemove(handles, rs.usizeRem(pick, handles.items.length))[Symbol.dispose](); break b2; } } - rt.dropVec(rt.vecPop(lists)); + rs.dropVec(rs.vecPop(lists)); } } - rt.byteVecPush(out, handles.items[rt.idx(handles.items, rt.usizeRem(pick, handles.items.length))].strong & 0xff); + rs.byteVecPush(out, handles.items[rs.idx(handles.items, rs.usizeRem(pick, handles.items.length))].strong & 0xff); flush(log.value, out); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(handles.items), (h2: rt.Arc): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(handles.items), (h2: rs.Arc): rs.u8 => { return h2.strong & 0xff; }), undefined, true); - drop$tuple5_Vec_Rc_counts_Noisy_Vec_Rc_counts_Noisy_Vec_counts_RcShared_Vec_counts_Noisy_Vec_Vec_Rc_counts_Noisy([handles, kept, shared, noisy, lists] as [rt.Vec>, rt.Vec>, rt.Vec, rt.Vec, rt.Vec>>]); + drop$tuple5_Vec_Rc_counts_Noisy_Vec_Rc_counts_Noisy_Vec_counts_RcShared_Vec_counts_Noisy_Vec_Vec_Rc_counts_Noisy([handles, kept, shared, noisy, lists] as [rs.Vec>, rs.Vec>, rs.Vec, rs.Vec, rs.Vec>>]); flush(log.value, out); log[Symbol.dispose](); } @@ -941,23 +941,23 @@ export function clonedRcs(data: rt.ByteSlice, out: rt.ByteVec): void { * handles to itself; then kept, dropped, or dropped with a handle outside. Each puts what it read and what * dropped. */ -export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { - let node!: rt.Arc; +export function cyclicRcs(data: rs.ByteSlice, out: rs.ByteVec): void { + let node!: rs.Arc; let _95: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const kept: rt.Vec> = new rt.Vec(); - const outside: rt.Vec> = new rt.Vec(); - for (const op of rt.byteSliceView(data)) { - const _15: rt.Arc> = rt.arcClone(log); + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const kept: rs.Vec> = new rs.Vec(); + const outside: rs.Vec> = new rs.Vec(); + for (const op of rs.byteSliceView(data)) { + const _15: rs.Arc> = rs.arcClone(log); _95 = true; const noisy: Noisy.Noisy = new Noisy.Noisy(op, _15); - const more: rt.u8 = rt.u8Rem(op >> 2, 4); - const _23: rt.u8 = rt.u8Rem(op, 4); + const more: rs.u8 = rs.u8Rem(op >> 2, 4); + const _23: rs.u8 = rs.u8Rem(op, 4); if (_23 === 0) { _95 = false; const captured5 = noisy; const captured6 = more; - node = rt.arcNewCyclic(rt.closure((this_4: rt.Weak): RcNode.RcNode => { + node = rs.arcNewCyclic(rs.closure((this_4: rs.Weak): RcNode.RcNode => { return RcNode.new(this_4, captured5, captured6); }, (): void => { captured5[Symbol.dispose](); @@ -966,8 +966,8 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { _95 = false; const captured3 = noisy; const captured4 = more; - node = rt.arcNewCyclic(rt.closure((this_3: rt.Weak): RcNode.RcNode => { - const _03: RcNode.RcNode = RcNode.new(this_3, new Noisy.Noisy(captured3.id ^ 128, rt.arcClone(captured3.log)), captured4); + node = rs.arcNewCyclic(rs.closure((this_3: rs.Weak): RcNode.RcNode => { + const _03: RcNode.RcNode = RcNode.new(this_3, new Noisy.Noisy(captured3.id ^ 128, rs.arcClone(captured3.log)), captured4); captured3[Symbol.dispose](); return _03; }, (): void => { @@ -977,35 +977,35 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { _95 = false; const captured = noisy; const captured2 = more; - node = rt.arcNewCyclic(rt.once(rt.closure((this_2: rt.Weak): RcNode.RcNode => { - return RcNode.new(this_2, new Noisy.Noisy(captured.id ^ 64, rt.arcClone(captured.log)), captured2); + node = rs.arcNewCyclic(rs.once(rs.closure((this_2: rs.Weak): RcNode.RcNode => { + return RcNode.new(this_2, new Noisy.Noisy(captured.id ^ 64, rs.arcClone(captured.log)), captured2); }, (): void => { captured[Symbol.dispose](); }))); } else { - node = rt.arcNewCyclic((this_: rt.Weak): RcNode.RcNode => { - return RcNode.new(this_, new Noisy.Noisy(238, rt.arcClone(log)), more); + node = rs.arcNewCyclic((this_: rs.Weak): RcNode.RcNode => { + return RcNode.new(this_, new Noisy.Noisy(238, rs.arcClone(log)), more); }); } - rt.iterExtendBytes(out, rt.iterSlice(copy$array_u8(node.value.seen)), undefined, true); - rt.byteVecPush(out, node.strong & 0xff); - rt.byteVecPush(out, node.weak & 0xff); - rt.byteVecPush(out, node.value.more.items.length & 0xff); - rt.byteVecPush(out, option_mapOr$1ndy2gq(rt.weakUpgrade(node.value.this), 253, (n: rt.Arc): rt.u8 => { - const _05: rt.u8 = n.value.noisy.id; + rs.iterExtendBytes(out, rs.iterSlice(copy$array_u8(node.value.seen)), undefined, true); + rs.byteVecPush(out, node.strong & 0xff); + rs.byteVecPush(out, node.weak & 0xff); + rs.byteVecPush(out, node.value.more.items.length & 0xff); + rs.byteVecPush(out, option_mapOr$1kjo972(rs.weakUpgrade(node.value.this), 253, (n: rs.Arc): rs.u8 => { + const _05: rs.u8 = n.value.noisy.id; n[Symbol.dispose](); return _05; })); const _59: RcNode.RcNode = node.value; - const _62: rt.Weak = new rt.Weak(node); - rt.byteVecPush(out, _59.this.arc === _62.arc ? 1 : 0); + const _62: rs.Weak = new rs.Weak(node); + rs.byteVecPush(out, _59.this.arc === _62.arc ? 1 : 0); _62[Symbol.dispose](); - rt.byteVecPush(out, node.weak & 0xff); - const _69: rt.u8 = op >> 6; + rs.byteVecPush(out, node.weak & 0xff); + const _69: rs.u8 = op >> 6; if (_69 === 0) { kept.items.push(node); } else if (_69 === 1) { - const _76: rt.Weak = new rt.Weak(node); + const _76: rs.Weak = new rs.Weak(node); outside.items.push(_76); node[Symbol.dispose](); } else { @@ -1017,12 +1017,12 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { } _95 = false; } - rt.dropVec(kept); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(outside.items), (w: rt.Weak): rt.u8 => { + rs.dropVec(kept); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(outside.items), (w: rs.Weak): rs.u8 => { return w.arc.strong & 0xff; }), undefined, true); flush(log.value, out); - rt.dropVec(outside); + rs.dropVec(outside); log[Symbol.dispose](); } @@ -1030,177 +1030,177 @@ export function cyclicRcs(data: rt.ByteSlice, out: rt.ByteVec): void { * Each byte an operation on pools of strong and weak handles, the rest of it the * handle it picks; each puts what it read. */ -export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - const strong: rt.Vec> = new rt.Vec(); - const weak: rt.Vec> = new rt.Vec(); - l1: for (const op of rt.byteSliceView(data)) { - const pick: rt.usize = op >> 4 as rt.usize; - const _19: rt.u8 = rt.u8Rem(op, 12); +export function rcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + const strong: rs.Vec> = new rs.Vec(); + const weak: rs.Vec> = new rs.Vec(); + l1: for (const op of rs.byteSliceView(data)) { + const pick: rs.usize = op >> 4 as rs.usize; + const _19: rs.u8 = rs.u8Rem(op, 12); if (_19 === 0) { - const _22: rt.Arc = new rt.Arc(new Noisy.Noisy(op, rt.arcClone(log))); + const _22: rs.Arc = new rs.Arc(new Noisy.Noisy(op, rs.arcClone(log))); strong.items.push(_22); continue; } if (_19 === 1) { if (!(strong.items.length === 0)) { - const again: rt.Arc = rt.arcClone(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const again: rs.Arc = rs.arcClone(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); strong.items.push(again); continue; } } else if (_19 === 2) { if (!(strong.items.length === 0)) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, rt.usizeRem(pick, strong.items.length))[Symbol.dispose](); + rs.vecSwapRemove(strong, rs.usizeRem(pick, strong.items.length))[Symbol.dispose](); continue; } } if (!(strong.items.length === 0)) { - const _49: Noisy.Noisy | undefined = rt.arcIntoInner(rt.vecSwapRemove(strong, rt.usizeRem(pick, strong.items.length))); + const _49: Noisy.Noisy | undefined = rs.arcIntoInner(rs.vecSwapRemove(strong, rs.usizeRem(pick, strong.items.length))); if (_49 === undefined) { - rt.byteVecPush(out, 251); + rs.byteVecPush(out, 251); continue; } const noisy: Noisy.Noisy = _49; - rt.byteVecPush(out, noisy.id); + rs.byteVecPush(out, noisy.id); noisy[Symbol.dispose](); continue; } } else if (_19 === 3) { if (!(strong.items.length === 0)) { - const _62: rt.Weak = new rt.Weak(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const _62: rs.Weak = new rs.Weak(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); weak.items.push(_62); continue; } } else if (_19 === 4) { if (!(weak.items.length === 0)) { - const again2: rt.Weak = rt.weakClone(weak.items[rt.idx(weak.items, rt.usizeRem(pick, weak.items.length))]); + const again2: rs.Weak = rs.weakClone(weak.items[rs.idx(weak.items, rs.usizeRem(pick, weak.items.length))]); weak.items.push(again2); continue; } } else if (_19 === 5) { if (!(weak.items.length === 0)) { - rt.vecSwapRemove(weak, rt.usizeRem(pick, weak.items.length))[Symbol.dispose](); + rs.vecSwapRemove(weak, rs.usizeRem(pick, weak.items.length))[Symbol.dispose](); continue; } } else if (_19 === 6) { if (!(weak.items.length === 0)) { - const _90: rt.Arc | undefined = rt.weakUpgrade(weak.items[rt.idx(weak.items, rt.usizeRem(pick, weak.items.length))]); + const _90: rs.Arc | undefined = rs.weakUpgrade(weak.items[rs.idx(weak.items, rs.usizeRem(pick, weak.items.length))]); if (_90 === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); continue; } - const up: rt.Arc = _90; - rt.byteVecPush(out, up.value.id); + const up: rs.Arc = _90; + rs.byteVecPush(out, up.value.id); strong.items.push(up); continue; } } else { if (_19 === 7) { - const _106: rt.Weak = new rt.Weak(); + const _106: rs.Weak = new rs.Weak(); weak.items.push(_106); continue; } if (_19 === 8) { if (!(strong.items.length === 0)) { - const at3 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - const held: rt.Weak | undefined = new rt.Weak(strong.items[at3]); - const kept: RcHolder.RcHolder = new RcHolder.RcHolder(new rt.Weak(strong.items[at3])); - const captured2 = new rt.Weak(strong.items[at3]); - const read: () => rt.u8 = rt.closure((): rt.u8 => { - return option_mapOr$036yrbw(rt.weakUpgrade(captured2), 253, (s: rt.Arc): rt.u8 => { - const _02: rt.u8 = s.value.id; + const at3 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + const held: rs.Weak | undefined = new rs.Weak(strong.items[at3]); + const kept: RcHolder.RcHolder = new RcHolder.RcHolder(new rs.Weak(strong.items[at3])); + const captured2 = new rs.Weak(strong.items[at3]); + const read: () => rs.u8 = rs.closure((): rs.u8 => { + return option_mapOr$025sl8y(rs.weakUpgrade(captured2), 253, (s: rs.Arc): rs.u8 => { + const _02: rs.u8 = s.value.id; s[Symbol.dispose](); return _02; }); }, (): void => { captured2[Symbol.dispose](); }); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); - rt.byteVecPush(out, read()); - rt.drop(held); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.byteVecPush(out, read()); + rs.drop(held); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); kept[Symbol.dispose](); - rt.drop(read); - rt.byteVecPush(out, strong.items[at3].weak & 0xff); + rs.drop(read); + rs.byteVecPush(out, strong.items[at3].weak & 0xff); continue; } } else if (_19 === 9) { if (!(strong.items.length === 0)) { - const _140: Noisy.Noisy | undefined = rt.arcGetMut(strong.items[rt.idx(strong.items, rt.usizeRem(pick, strong.items.length))]); + const _140: Noisy.Noisy | undefined = rs.arcGetMut(strong.items[rs.idx(strong.items, rs.usizeRem(pick, strong.items.length))]); if (_140 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); continue; } _140.id = _140.id ^ 16; - rt.byteVecPush(out, _140.id); + rs.byteVecPush(out, _140.id); continue; } } else if (_19 === 10) { if (!(strong.items.length === 0)) { - const at = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - const noisy2: Noisy.Noisy = rt.arcMakeMut(rt.place(() => strong.items[at], (value) => strong.items[at] = value), Noisy.clone$Clone, rt.drop); + const at = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + const noisy2: Noisy.Noisy = rs.arcMakeMut(rs.place(() => strong.items[at], (value) => strong.items[at] = value), Noisy.clone$Clone, rs.drop); noisy2.id = noisy2.id ^ 32; - rt.byteVecPush(out, noisy2.id); - rt.byteVecPush(out, strong.items[at].strong & 0xff); - rt.byteVecPush(out, strong.items[at].weak & 0xff); + rs.byteVecPush(out, noisy2.id); + rs.byteVecPush(out, strong.items[at].strong & 0xff); + rs.byteVecPush(out, strong.items[at].weak & 0xff); continue; } } } for (const _171 of strong.items) { - rt.byteVecPush(out, _171.strong & 0xff); - rt.byteVecPush(out, _171.weak & 0xff); + rs.byteVecPush(out, _171.strong & 0xff); + rs.byteVecPush(out, _171.weak & 0xff); } - const iterS3: rt.Weak[] = weak.items; + const iterS3: rs.Weak[] = weak.items; let iterI3: number = 0; while (true) { - const _184: rt.Weak | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; - if (_184 === rt.DONE) { + const _184: rs.Weak | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; + if (_184 === rs.DONE) { continue l1; } - rt.byteVecPush(out, _184.arc.strong & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(_184) & 0xff); + rs.byteVecPush(out, _184.arc.strong & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(_184) & 0xff); } } - const _194: rt.Arc | undefined = rt.sliceLast(strong.items); + const _194: rs.Arc | undefined = rs.sliceLast(strong.items); if (_194 !== undefined) { - const _200: rt.Arc = rt.arcClone(_194); - const object: rt.Arc = new rt.ArcDyn(_200, new of$counts_Noisy(_200.value)); - const weakObject: rt.Weak = new rt.Weak(object); - rt.byteVecPush(out, _194.weak & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(weakObject) & 0xff); - rt.byteVecPush(out, option_mapOr$1qmxzyf(rt.weakUpgrade(weakObject), 253, (o: rt.Arc): rt.u8 => { - const _03: rt.u8 = o.value.id$Id(); + const _200: rs.Arc = rs.arcClone(_194); + const object: rs.Arc = new rs.ArcDyn(_200, new of$counts_Noisy(_200.value)); + const weakObject: rs.Weak = new rs.Weak(object); + rs.byteVecPush(out, _194.weak & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(weakObject) & 0xff); + rs.byteVecPush(out, option_mapOr$1wnjpxi(rs.weakUpgrade(weakObject), 253, (o: rs.Arc): rs.u8 => { + const _03: rs.u8 = o.value.id$Id(); o[Symbol.dispose](); return _03; })); object[Symbol.dispose](); - rt.byteVecPush(out, weakObject.arc.strong & 0xff); + rs.byteVecPush(out, weakObject.arc.strong & 0xff); weakObject[Symbol.dispose](); } - new rt.Arc(new Noisy.Noisy(224, rt.arcClone(log)))[Symbol.dispose](); - const _228: rt.Arc | undefined = option_map$1srhyy0(rt.sliceFirst(strong.items), (a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + new rs.Arc(new Noisy.Noisy(224, rs.arcClone(log)))[Symbol.dispose](); + const _228: rs.Arc | undefined = option_map$0lz7sqj(rs.sliceFirst(strong.items), (a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); }); - rt.byteVecPush(out, option_mapOr$1iuqai4(option_asDeref$0hypa7g(_228), 253, (noisy3: Noisy.Noisy): rt.u8 => { + rs.byteVecPush(out, option_mapOr$114r0pa(option_asDeref$0hjiqyl(_228), 253, (noisy3: Noisy.Noisy): rs.u8 => { return noisy3.id; })); - rt.drop(_228); - rt.dropVec(strong); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak.items), (w: rt.Weak): rt.u8 => { - const _54: rt.Arc | undefined = rt.weakUpgrade(w); - const _06: rt.u8 = _54 === undefined ? 1 : 0; - rt.drop(_54); + rs.drop(_228); + rs.dropVec(strong); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(weak.items), (w: rs.Weak): rs.u8 => { + const _54: rs.Arc | undefined = rs.weakUpgrade(w); + const _06: rs.u8 = _54 === undefined ? 1 : 0; + rs.drop(_54); return _06; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(weak.items), (w2: rt.Weak): rt.u8 => { - return rt.weakWeakCount(w2) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(weak.items), (w2: rs.Weak): rs.u8 => { + return rs.weakWeakCount(w2) & 0xff; }), undefined, true); - rt.dropVec(weak); - const _250: rt.Mutex = rt.mutexLock(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_250.value)); - rt.mutexUnlock(_250); + rs.dropVec(weak); + const _250: rs.Mutex = rs.mutexLock(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_250.value)); + rs.mutexUnlock(_250); log[Symbol.dispose](); } @@ -1209,122 +1209,122 @@ export function rcs(data: rt.ByteSlice, out: rt.ByteVec): void { * the rest of it the handle it picks; each puts what it read and the picked * handle's counts. */ -export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { - let _52!: rt.Place | undefined; - let value2!: rt.Place; - const strong: rt.Vec> = rt.vecFrom([new rt.Arc(0)]); - const weak: rt.Vec> = new rt.Vec(); - const iterS: Uint8Array = rt.byteSliceView(data); +export function uniqueRcs(data: rs.ByteSlice, out: rs.ByteVec): void { + let _52!: rs.Place | undefined; + let value2!: rs.Place; + const strong: rs.Vec> = rs.vecFrom([new rs.Arc(0)]); + const weak: rs.Vec> = new rs.Vec(); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _11: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - const getMut: (a0: rt.Place>) => rt.Place | undefined = (a0: rt.Place>): rt.Place | undefined => { - return rt.arcGetMutPlace(a0.v); + const _11: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + const getMut: (a0: rs.Place>) => rs.Place | undefined = (a0: rs.Place>): rs.Place | undefined => { + return rs.arcGetMutPlace(a0.v); }; - const makeMut: (a0: rt.Place>) => rt.Place = (a02: rt.Place>): rt.Place => { - return rt.arcMakeMutPlace(a02, undefined, rt.drop); + const makeMut: (a0: rs.Place>) => rs.Place = (a02: rs.Place>): rs.Place => { + return rs.arcMakeMutPlace(a02, undefined, rs.drop); }; - if (_11 === rt.DONE) { + if (_11 === rs.DONE) { break; } - const op: rt.u8 = _11; - const pick: rt.usize = rt.usizeRem(op >> 3 as rt.usize, strong.items.length); + const op: rs.u8 = _11; + const pick: rs.usize = rs.usizeRem(op >> 3 as rs.usize, strong.items.length); b2: { - const _24: rt.u8 = rt.u8Rem(op, 7); + const _24: rs.u8 = rs.u8Rem(op, 7); if (_24 === 0) { - const _27: rt.Arc = new rt.Arc(op); + const _27: rs.Arc = new rs.Arc(op); strong.items.push(_27); } else if (_24 === 1) { - const again: rt.Arc = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); + const again: rs.Arc = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); strong.items.push(again); } else if (_24 === 2) { - const _34: rt.Weak = new rt.Weak(strong.items[rt.idx(strong.items, pick)]); + const _34: rs.Weak = new rs.Weak(strong.items[rs.idx(strong.items, pick)]); weak.items.push(_34); } else if (_24 === 3) { if (strong.items.length > 1) { if ((op & 128) === 0) { - rt.vecSwapRemove(strong, pick)[Symbol.dispose](); + rs.vecSwapRemove(strong, pick)[Symbol.dispose](); break b2; } } if (!(strong.items.length > 1)) { - rt.vecTruncate(weak, 0, rt.drop); + rs.vecTruncate(weak, 0, rs.drop); } else { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.arcIntoInner(rt.vecSwapRemove(strong, pick)), 251)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.arcIntoInner(rs.vecSwapRemove(strong, pick)), 251)); } } else if (_24 === 4) { if (!((op & 128) === 0)) { - const at5 = rt.idx(strong.items, pick); - _52 = getMut(rt.place(() => strong.items[at5], (value5) => strong.items[at5] = value5)); + const at5 = rs.idx(strong.items, pick); + _52 = getMut(rs.place(() => strong.items[at5], (value5) => strong.items[at5] = value5)); } else { - _52 = rt.arcGetMutPlace(strong.items[rt.idx(strong.items, pick)]); + _52 = rs.arcGetMutPlace(strong.items[rs.idx(strong.items, pick)]); } if (_52 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { - const value: rt.Place = _52; - value.v = rt.u8WrappingAdd(value.v, op); - rt.byteVecPush(out, value.v); + const value: rs.Place = _52; + value.v = rs.u8WrappingAdd(value.v, op); + rs.byteVecPush(out, value.v); } } else if (_24 === 5) { if (!((op & 128) === 0)) { - const at3 = rt.idx(strong.items, pick); - value2 = makeMut(rt.place(() => strong.items[at3], (value4) => strong.items[at3] = value4)); + const at3 = rs.idx(strong.items, pick); + value2 = makeMut(rs.place(() => strong.items[at3], (value4) => strong.items[at3] = value4)); } else { - const at2 = rt.idx(strong.items, pick); - value2 = rt.arcMakeMutPlace(rt.place(() => strong.items[at2], (value3) => strong.items[at2] = value3), undefined, rt.drop); + const at2 = rs.idx(strong.items, pick); + value2 = rs.arcMakeMutPlace(rs.place(() => strong.items[at2], (value3) => strong.items[at2] = value3), undefined, rs.drop); } value2.v = value2.v ^ op; - rt.byteVecPush(out, value2.v); + rs.byteVecPush(out, value2.v); } else { - const pinned: rt.Arc = new rt.Arc(op); - const held: rt.Arc | undefined = rt.arcClone(strong.items[rt.idx(strong.items, pick)]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(pinned.value, option_unwrapOr$0r2bmpr(option_asDeref$0s3650c(held), 251)))); - rt.drop(held); + const pinned: rs.Arc = new rs.Arc(op); + const held: rs.Arc | undefined = rs.arcClone(strong.items[rs.idx(strong.items, pick)]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(pinned.value, option_unwrapOr$1fr498u(option_asDeref$1l62o5g(held), 251)))); + rs.drop(held); pinned[Symbol.dispose](); } } - const at8 = rt.idx(strong.items, rt.usizeRem(pick, strong.items.length)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(strong.items[at8].value, strong.items[at8].strong & 0xff, strong.items[at8].weak & 0xff))); + const at8 = rs.idx(strong.items, rs.usizeRem(pick, strong.items.length)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(strong.items[at8].value, strong.items[at8].strong & 0xff, strong.items[at8].weak & 0xff))); } for (const _110 of weak.items) { - rt.byteVecPush(out, option_mapOr$1q3ff8g(rt.weakUpgrade(_110), 253, (s: rt.Arc): rt.u8 => { - const _03: rt.u8 = s.value; + rs.byteVecPush(out, option_mapOr$1gfk3jk(rs.weakUpgrade(_110), 253, (s: rs.Arc): rs.u8 => { + const _03: rs.u8 = s.value; s[Symbol.dispose](); return _03; })); - rt.byteVecPush(out, _110.arc.strong & 0xff); - rt.byteVecPush(out, rt.weakWeakCount(_110) & 0xff); + rs.byteVecPush(out, _110.arc.strong & 0xff); + rs.byteVecPush(out, rs.weakWeakCount(_110) & 0xff); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(strong.items), (s2: rt.Arc): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(strong.items), (s2: rs.Arc): rs.u8 => { return s2.value; }), undefined, true); - const others: rt.Arc>>> = new rt.Arc(new rt.RefCell(new rt.Vec())); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - let first: rt.Arc = new rt.Arc(new RcReleasing.RcReleasing(data.length & 0xff, rt.arcClone(others), rt.arcClone(log))); - const shared: rt.u8 = option_mapOr$1surhce(rt.byteSliceFirst(data), 1, (b: rt.u8): rt.u8 => { - return rt.u8Add(rt.u8Rem(b, 3), 1); + const others: rs.Arc>>> = new rs.Arc(new rs.RefCell(new rs.Vec())); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + let first: rs.Arc = new rs.Arc(new RcReleasing.RcReleasing(data.length & 0xff, rs.arcClone(others), rs.arcClone(log))); + const shared: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 1, (b: rs.u8): rs.u8 => { + return rs.u8Add(rs.u8Rem(b, 3), 1); }); - const _147: rt.RefCell>> = rt.refCellBorrowMut(others.value); - const _150: rt.Iter> = rt.iterMap(new rt.Range(0, shared), (_2: rt.u8): rt.Arc => { - return rt.arcClone(first); + const _147: rs.RefCell>> = rs.refCellBorrowMut(others.value); + const _150: rs.Iter> = rs.iterMap(new rs.Range(0, shared), (_2: rs.u8): rs.Arc => { + return rs.arcClone(first); }); - rt.iterExtend(_147.value, _150, undefined, 4, true); - rt.refMutRelease(_147); - const _154: RcReleasing.RcReleasing = rt.arcMakeMut(rt.place(() => first, (value6) => first = value6), RcReleasing.clone$Clone, rt.drop); + rs.iterExtend(_147.value, _150, undefined, 4, true); + rs.refMutRelease(_147); + const _154: RcReleasing.RcReleasing = rs.arcMakeMut(rs.place(() => first, (value6) => first = value6), RcReleasing.clone$Clone, rs.drop); _154.id = _154.id ^ 64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.value.id, first.strong & 0xff))); - const _170: rt.RefCell = rt.refCellBorrow(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_170.value)); - rt.refRelease(_170); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(first.value.id, first.strong & 0xff))); + const _170: rs.RefCell = rs.refCellBorrow(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_170.value)); + rs.refRelease(_170); first[Symbol.dispose](); - const _179: rt.RefCell = rt.refCellBorrow(log.value); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_179.value)); - rt.refRelease(_179); + const _179: rs.RefCell = rs.refCellBorrow(log.value); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_179.value)); + rs.refRelease(_179); log[Symbol.dispose](); - rt.arcDrop(others, drop$cell_RefCell_Vec_Rc_counts_RcReleasing); - rt.dropVec(weak); - rt.dropVec(strong); + rs.arcDrop(others, drop$cell_RefCell_Vec_Rc_counts_RcReleasing); + rs.dropVec(weak); + rs.dropVec(strong); } /** @@ -1332,84 +1332,84 @@ export function uniqueRcs(data: rt.ByteSlice, out: rt.ByteVec): void { * `Counted`, and through `Option<&mut>` a byte and an `Option`; each puts what it made * and how many clones `Counted` counted. */ -export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { - const clones: rt.Cell = new rt.Cell(0); - const counted: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Counted.Counted => { +export function copies(data: rs.ByteSlice, out: rs.ByteVec): void { + const clones: rs.Cell = new rs.Cell(0); + const counted: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Counted.Counted => { return { id: _2, clones }; }), undefined, 8, true); - const twins: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Twin.Twin => { - const b: rt.u8 = _22; + const twins: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): Twin.Twin => { + const b: rs.u8 = _22; return { _0: b, _1: ~b & 0xff }; }), undefined, 2, true); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const maybes: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u8 | undefined => { - const b2: rt.u8 = _23; - return thenSome$0d5am30(rt.u8Rem(b2, 3) !== 0, b2); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const maybes: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): rs.u8 | undefined => { + const b2: rs.u8 = _23; + return thenSome$0quywni(rs.u8Rem(b2, 3) !== 0, b2); }), undefined, 2, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _20: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_20 === rt.DONE) { + const _20: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_20 === rs.DONE) { break; } - const i: rt.usize = _20[0]; - const op: rt.u8 = _20[1]; - const pick: rt.usize = rt.usizeRem(op >> 3 as rt.usize, data.length); - const _33: rt.u8 = rt.u8Rem(op, 8); + const i: rs.usize = _20[0]; + const op: rs.u8 = _20[1]; + const pick: rs.usize = rs.usizeRem(op >> 3 as rs.usize, data.length); + const _33: rs.u8 = rs.u8Rem(op, 8); if (_33 === 6) { - const _36: rt.Place | undefined = rt.sliceGetMut(rt.byteSliceView(rt.byteVecSlice(bytes)), pick); - const byte: rt.u8 | undefined = _36 === undefined ? undefined : _36.v; - const _44: rt.ByteSlice = rt.byteVecSlice(bytes); - const _46: rt.usize = rt.usizeAdd(i, pick); - const _43: rt.Place | undefined = rt.sliceGetMut(rt.byteSliceView(_44), _46); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(option_or$1loyskh(_43 === undefined ? undefined : _43.v, byte), 253)); - const _48: rt.Place | undefined = rt.sliceGetMut(rt.byteSliceView(rt.byteVecSlice(bytes)), i); + const _36: rs.Place | undefined = rs.sliceGetMut(rs.byteSliceView(rs.byteVecSlice(bytes)), pick); + const byte: rs.u8 | undefined = _36 === undefined ? undefined : _36.v; + const _44: rs.ByteSlice = rs.byteVecSlice(bytes); + const _46: rs.usize = rs.usizeAdd(i, pick); + const _43: rs.Place | undefined = rs.sliceGetMut(rs.byteSliceView(_44), _46); + rs.byteVecPush(out, option_unwrapOr$1fr498u(option_or$0ar58vy(_43 === undefined ? undefined : _43.v, byte), 253)); + const _48: rs.Place | undefined = rs.sliceGetMut(rs.byteSliceView(rs.byteVecSlice(bytes)), i); if (_48 !== undefined) { _48.v = _48.v ^ op; } } else if (_33 === 7) { - const _54: rt.Place | undefined = rt.sliceGetMut(maybes.items, pick); - rt.byteVecPush(out, option_mapOr$1xztl8h(_54 === undefined ? rt.None : _54.v, 253, (m: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(m, 252); + const _54: rs.Place | undefined = rs.sliceGetMut(maybes.items, pick); + rs.byteVecPush(out, option_mapOr$1rg5gkk(_54 === undefined ? rs.None : _54.v, 253, (m: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(m, 252); })); - const _60: rt.Place | undefined = rt.sliceGetMut(maybes.items, rt.usizeAdd(i, pick)); - rt.byteVecPush(out, option_mapOr$1xztl8h(_60 === undefined ? rt.None : _60.v, 253, (m2: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(m2, 252); + const _60: rs.Place | undefined = rs.sliceGetMut(maybes.items, rs.usizeAdd(i, pick)); + rs.byteVecPush(out, option_mapOr$1rg5gkk(_60 === undefined ? rs.None : _60.v, 253, (m2: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(m2, 252); })); - const _67: rt.Place | undefined = rt.sliceGetMut(maybes.items, pick); + const _67: rs.Place | undefined = rs.sliceGetMut(maybes.items, pick); if (_67 !== undefined) { - _67.v = option_mapOr$06rr3sb(_67.v, op, (_24: rt.u8): rt.u8 | undefined => { + _67.v = option_mapOr$19a4gco(_67.v, op, (_24: rs.u8): rs.u8 | undefined => { return undefined; }); } } else if (_33 === 0) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, pick), 253)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 253)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceGet(data, pick), 253)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 253)); } else if (_33 === 1) { - const twin: Twin.Twin = option_unwrapOr$0ujf6zi(rt.sliceGet(twins.items, pick), { _0: 0, _1: 0 }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(twin._0, twin._1)), undefined, true); + const twin: Twin.Twin = option_unwrapOr$0ujf6zi(rs.sliceGet(twins.items, pick), { _0: 0, _1: 0 }); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(twin._0, twin._1)), undefined, true); } else if (_33 === 2) { - const _95: Counted.Counted | undefined = rt.sliceGet(counted.items, pick); - rt.byteVecPush(out, option_mapOr$1ailw2a(_95 === undefined ? undefined : Counted.clone$Clone(_95), 253, (c4: Counted.Counted): rt.u8 => { + const _95: Counted.Counted | undefined = rs.sliceGet(counted.items, pick); + rs.byteVecPush(out, option_mapOr$0gign7l(_95 === undefined ? undefined : Counted.clone$Clone(_95), 253, (c4: Counted.Counted): rs.u8 => { return c4.id; })); } else if (_33 === 3) { - rt.byteVecPush(out, option_mapOr$1ailw2a(rt.sliceGet(counted.items, pick), 253, (c3: Counted.Counted): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0gign7l(rs.sliceGet(counted.items, pick), 253, (c3: Counted.Counted): rs.u8 => { return c3.id; })); } else if (_33 === 4) { - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(counted.items), Counted.clone$Clone), (c2: Counted.Counted): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterMap(rs.iterSlice(counted.items), Counted.clone$Clone), (c2: Counted.Counted): rs.u8 => { return c2.id; }), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(counted.items), (c: Counted.Counted): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(counted.items), (c: Counted.Counted): rs.u8 => { return c.id; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterCloned(rt.iterSlice(twins.items)), (t: Twin.Twin): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterCloned(rs.iterSlice(twins.items)), (t: Twin.Twin): rs.u8 => { return t._0 ^ t._1; }), undefined, true); } - rt.byteVecPush(out, clones.v); + rs.byteVecPush(out, clones.v); } } diff --git a/ts/fixtures/lang/counts/expected/harness.ts b/ts/fixtures/lang/counts/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/counts/expected/harness.ts +++ b/ts/fixtures/lang/counts/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/counts/expected/lib.ts b/ts/fixtures/lang/counts/expected/lib.ts index 8f1f2e2f3..8a622699a 100644 --- a/ts/fixtures/lang/counts/expected/lib.ts +++ b/ts/fixtures/lang/counts/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { addressedArcs, arcs, clonedArcs, cyclicArcs, uniqueArcs, addressedRcs, clonedRcs, cyclicRcs, rcs, uniqueRcs, copies } from "./counts.ts"; import type * as ArcReleasing from "./counts.ArcReleasing.ts"; import type * as ArcShared from "./counts.ArcShared.ts"; @@ -8,7 +8,7 @@ import * as Noisy from "./counts.Noisy.ts"; import type * as RcReleasing from "./counts.RcReleasing.ts"; import type * as RcShared from "./counts.RcShared.ts"; -export function copy$Option_tuple2_u8_u8(v: [rt.u8, rt.u8] | undefined): [rt.u8, rt.u8] | undefined { +export function copy$Option_tuple2_u8_u8(v: [rs.u8, rs.u8] | undefined): [rs.u8, rs.u8] | undefined { return v === undefined ? v : copy$tuple2_u8_u8(v); } @@ -16,54 +16,54 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$tuple2_u16_u8(v: [rt.u16, rt.u8]): [rt.u16, rt.u8] { +export function copy$tuple2_u16_u8(v: [rs.u16, rs.u8]): [rs.u16, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } -export function drop$Vec_Rc_counts_Noisy(value: rt.Vec>): void { - rt.dropVec(value); +export function drop$Vec_Rc_counts_Noisy(value: rs.Vec>): void { + rs.dropVec(value); } -export function drop$Vec_sync_Arc_counts_Noisy(value: rt.Vec>): void { - rt.dropVec(value); +export function drop$Vec_sync_Arc_counts_Noisy(value: rs.Vec>): void { + rs.dropVec(value); } -export function drop$cell_RefCell_Vec_Rc_counts_RcReleasing(value: rt.RefCell>>): void { - rt.dropVec(value.value); +export function drop$cell_RefCell_Vec_Rc_counts_RcReleasing(value: rs.RefCell>>): void { + rs.dropVec(value.value); } -export function drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing(value: rt.RefCell>>): void { - rt.dropVec(value.value); +export function drop$cell_RefCell_Vec_sync_Arc_counts_ArcReleasing(value: rs.RefCell>>): void { + rs.dropVec(value.value); } -export function drop$tuple2_Option_rc_Weak_tuple2_u16_u8_Option_Rc_tuple2_u16_u8(_1: [rt.Weak<[rt.u16, rt.u8]> | undefined, rt.Arc<[rt.u16, rt.u8]> | undefined]): void { - rt.drop(_1[0]); - rt.drop(_1[1]); +export function drop$tuple2_Option_rc_Weak_tuple2_u16_u8_Option_Rc_tuple2_u16_u8(_1: [rs.Weak<[rs.u16, rs.u8]> | undefined, rs.Arc<[rs.u16, rs.u8]> | undefined]): void { + rs.drop(_1[0]); + rs.drop(_1[1]); } -export function drop$tuple2_Option_sync_Weak_tuple2_u16_u8_Option_sync_Arc_tuple2_u16_u8(_1: [rt.Weak<[rt.u16, rt.u8]> | undefined, rt.Arc<[rt.u16, rt.u8]> | undefined]): void { - rt.drop(_1[0]); - rt.drop(_1[1]); +export function drop$tuple2_Option_sync_Weak_tuple2_u16_u8_Option_sync_Arc_tuple2_u16_u8(_1: [rs.Weak<[rs.u16, rs.u8]> | undefined, rs.Arc<[rs.u16, rs.u8]> | undefined]): void { + rs.drop(_1[0]); + rs.drop(_1[1]); } -export function drop$tuple5_Vec_Rc_counts_Noisy_Vec_Rc_counts_Noisy_Vec_counts_RcShared_Vec_counts_Noisy_Vec_Vec_Rc_counts_Noisy(_1: [rt.Vec>, rt.Vec>, rt.Vec, rt.Vec, rt.Vec>>]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); - rt.dropVec(_1[2]); - rt.dropVec(_1[3]); - rt.dropVec(_1[4], drop$Vec_Rc_counts_Noisy); +export function drop$tuple5_Vec_Rc_counts_Noisy_Vec_Rc_counts_Noisy_Vec_counts_RcShared_Vec_counts_Noisy_Vec_Vec_Rc_counts_Noisy(_1: [rs.Vec>, rs.Vec>, rs.Vec, rs.Vec, rs.Vec>>]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); + rs.dropVec(_1[2]); + rs.dropVec(_1[3]); + rs.dropVec(_1[4], drop$Vec_Rc_counts_Noisy); } -export function drop$tuple5_Vec_sync_Arc_counts_Noisy_Vec_sync_Arc_counts_Noisy_Vec_counts_ArcShared_Vec_counts_Noisy_Vec_Vec_sync_Arc_counts_Noisy(_1: [rt.Vec>, rt.Vec>, rt.Vec, rt.Vec, rt.Vec>>]): void { - rt.dropVec(_1[0]); - rt.dropVec(_1[1]); - rt.dropVec(_1[2]); - rt.dropVec(_1[3]); - rt.dropVec(_1[4], drop$Vec_sync_Arc_counts_Noisy); +export function drop$tuple5_Vec_sync_Arc_counts_Noisy_Vec_sync_Arc_counts_Noisy_Vec_counts_ArcShared_Vec_counts_Noisy_Vec_Vec_sync_Arc_counts_Noisy(_1: [rs.Vec>, rs.Vec>, rs.Vec, rs.Vec, rs.Vec>>]): void { + rs.dropVec(_1[0]); + rs.dropVec(_1[1]); + rs.dropVec(_1[2]); + rs.dropVec(_1[3]); + rs.dropVec(_1[4], drop$Vec_sync_Arc_counts_Noisy); } export class of$counts_Noisy { @@ -77,7 +77,7 @@ export class of$counts_Noisy { this.v[Symbol.dispose](); } - id$Id(): rt.u8 { + id$Id(): rs.u8 { return Noisy.id$counts_Id(this.v); } } @@ -86,30 +86,30 @@ export class of$counts_Noisy { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["counts::arcs", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["counts::arcs", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { arcs(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::rcs", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::rcs", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { rcs(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_arcs", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::cyclic_arcs", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { cyclicArcs(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cyclic_rcs", (_213: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::cyclic_rcs", (_213: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { cyclicRcs(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_arcs", (_214: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::unique_arcs", (_214: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { uniqueArcs(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::unique_rcs", (_215: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::unique_rcs", (_215: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { uniqueRcs(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_arcs", (_216: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::cloned_arcs", (_216: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { clonedArcs(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::cloned_rcs", (_217: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::cloned_rcs", (_217: rs.u8, data8: rs.ByteSlice, out8: rs.ByteVec): undefined => { clonedRcs(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::copies", (_218: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::copies", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { copies(data9, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::addressed_arcs", (_219: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::addressed_arcs", (_219: rs.u8, data10: rs.ByteSlice, out10: rs.ByteVec): undefined => { addressedArcs(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["counts::addressed_rcs", (_220: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["counts::addressed_rcs", (_220: rs.u8, data11: rs.ByteSlice, out11: rs.ByteVec): undefined => { addressedRcs(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/cows/expected/core/option.ts b/ts/fixtures/lang/cows/expected/core/option.ts index fa7115f2f..5bd9ecef4 100644 --- a/ts/fixtures/lang/cows/expected/core/option.ts +++ b/ts/fixtures/lang/cows/expected/core/option.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { borrows } from "../cows.ts"; -export function unwrapOr$1qh6z5m(self: rt.StrCow | undefined, default_: rt.StrCow): rt.StrCow { +export function unwrapOr$0jw3da9(self: rs.StrCow | undefined, default_: rs.StrCow): rs.StrCow { if (self === undefined) { return default_; } @@ -17,49 +17,49 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$00b7lvf(self: rt.StrCow | undefined, _: (a0: rt.StrCow) => string): string | undefined { +export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => string): string | undefined { if (self === undefined) { return undefined; } - return rt.strCowStr(self); + return rs.strCowStr(self); } -export function map$1li8gst(self: string | undefined, _: (a0: string) => rt.StrCow): rt.StrCow | undefined { +export function map$1g811lq(self: string | undefined, _: (a0: string) => rs.StrCow): rs.StrCow | undefined { if (self === undefined) { return undefined; } - return new rt.Borrowed(self); + return new rs.Borrowed(self); } -export function mapOr$0lcrgk1(self: string | undefined, default_: rt.u8, f: (a0: string) => rt.u8): rt.u8 { +export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1612aex(self: rt.char | undefined, default_: rt.usize, _: (a0: rt.char) => rt.usize): rt.usize { +export function mapOr$1je44uu(self: rs.char | undefined, default_: rs.usize, _: (a0: rs.char) => rs.usize): rs.usize { if (self === undefined) { return default_; } - return rt.charLenUtf8(self); + return rs.charLenUtf8(self); } -export function mapOr$1nwl1hk(self: rt.StrCow | undefined, default_: rt.u8, _: (a0: rt.StrCow) => rt.u8): rt.u8 { +export function mapOr$03q317x(self: rs.StrCow | undefined, default_: rs.u8, _: (a0: rs.StrCow) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/cows/expected/cows.Named.ts b/ts/fixtures/lang/cows/expected/cows.Named.ts index 82262d455..666855c14 100644 --- a/ts/fixtures/lang/cows/expected/cows.Named.ts +++ b/ts/fixtures/lang/cows/expected/cows.Named.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Named): Named { - return { name: rt.strCowClone(self.name), id: self.id }; + return { name: rs.strCowClone(self.name), id: self.id }; } -export function fmt$fmt_Debug(self: Named, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Named, f: rs.Formatter): rs.Result { const _3: string = "Named"; const _4: string = "name"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(rt.strCowStr(self.name), f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(self.name), f); const _7: string = "id"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.id, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.id, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function default$Default(): Named { @@ -23,53 +23,53 @@ export function eq$cmp_PartialEq(self: Named, other: Named): boolean { if (!(self.id === other.id)) { return false; } - return rt.strCowStr(self.name) === rt.strCowStr(other.name); + return rs.strCowStr(self.name) === rs.strCowStr(other.name); } -export function hash$Hash_hash_DefaultHasher(self: Named, state: rt.Hasher): void { - rt.hashCow(rt.hashStr)(self.name, state); - rt.hash8(self.id, state); +export function hash$Hash_hash_DefaultHasher(self: Named, state: rs.Hasher): void { + rs.hashCow(rs.hashStr)(self.name, state); + rs.hash8(self.id, state); } -export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Named, other: Named): rt.Ordering { - const cmp: rt.Ordering = rt.cowBy(rt.cmpStr)(self.name, other.name); +export function cmp$cmp_Ord(self: Named, other: Named): rs.Ordering { + const cmp: rs.Ordering = rs.cowBy(rs.cmpStr)(self.name, other.name); if (cmp === 0) { - return rt.cmp(self.id, other.id); + return rs.cmp(self.id, other.id); } return cmp; } /** A `Cow` in a field, with each derived impl reading it. */ export interface Named { - name: rt.StrCow; - id: rt.u8; + name: rs.StrCow; + id: rs.u8; } /** Borrowed unless it has to make the text, as moq-net's `Relative::new` is. */ -function new_(s: string, id: rt.u8): Named { - let name!: rt.StrCow; - const trimmed: string = rt.strTrimEndMatches(s, "/"); +function new_(s: string, id: rs.u8): Named { + let name!: rs.StrCow; + const trimmed: string = rs.strTrimEndMatches(s, "/"); if (!(trimmed.length === 0)) { - name = new rt.Borrowed(trimmed); + name = new rs.Borrowed(trimmed); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(id, f)]; - name = rt.fmtFormat(["#", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(id, f)]; + name = rs.fmtFormat(["#", args2[0]]); } return { name, id }; } /** Through `to_mut` of the field. */ -export function tag(self: Named, c: rt.char): void { - self.name = rt.strCowStr(self.name); +export function tag(self: Named, c: rs.char): void { + self.name = rs.strCowStr(self.name); self.name = self.name + String.fromCodePoint(c); } export function intoOwned(self: Named): Named { - return { name: rt.strCowStr(self.name), id: self.id }; + return { name: rs.strCowStr(self.name), id: self.id }; } export { new_ as new }; diff --git a/ts/fixtures/lang/cows/expected/cows.Run.ts b/ts/fixtures/lang/cows/expected/cows.Run.ts index dd98e7661..33d165fef 100644 --- a/ts/fixtures/lang/cows/expected/cows.Run.ts +++ b/ts/fixtures/lang/cows/expected/cows.Run.ts @@ -1,46 +1,46 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Run): Run { - return { words: rt.cowClone(self.words) }; + return { words: rs.cowClone(self.words) }; } -export function fmt$fmt_Debug(self: Run, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Run, f: rs.Formatter): rs.Result { const _3: string = "Run"; const _4: string = "words"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.cowSlice(self.words), f, rt.u16Debug); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5)); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.cowSlice(self.words), f, rs.u16Debug); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); } export function default$Default(): Run { - return { words: new rt.Vec() }; + return { words: new rs.Vec() }; } export function eq$cmp_PartialEq(self: Run, other: Run): boolean { - return rt.eqSlice(rt.same)(rt.cowSlice(self.words), rt.cowSlice(other.words)); + return rs.eqSlice(rs.same)(rs.cowSlice(self.words), rs.cowSlice(other.words)); } -export function hash$Hash_hash_DefaultHasher(self: Run, state: rt.Hasher): void { - rt.hashCow(rt.hashInts(2))(self.words, state); +export function hash$Hash_hash_DefaultHasher(self: Run, state: rs.Hasher): void { + rs.hashCow(rs.hashInts(2))(self.words, state); } /** A `Cow<[T]>` in a field, with each derived impl reading it. */ export interface Run { - words: rt.Cow; + words: rs.Cow; } /** Through `to_mut` of the field. */ export function bump(self: Run): void { - const owned = rt.cowIntoOwned(self.words); + const owned = rs.cowIntoOwned(self.words); self.words = owned; - const iter: rt.Iter> = rt.iterSliceMut(owned.items); + const iter: rs.Iter> = rs.iterSliceMut(owned.items); while (true) { - const _8: rt.Place | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: rs.Place | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } - _8.v = rt.u16WrappingAdd(_8.v, 1); + _8.v = rs.u16WrappingAdd(_8.v, 1); } } diff --git a/ts/fixtures/lang/cows/expected/cows.Tally.ts b/ts/fixtures/lang/cows/expected/cows.Tally.ts index 8a3d899be..c64512278 100644 --- a/ts/fixtures/lang/cows/expected/cows.Tally.ts +++ b/ts/fixtures/lang/cows/expected/cows.Tally.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An item whose `Clone` and `Drop` log, so what a `Cow` clones and drops shows. */ export class Tally { - _0: rt.u8; - _1: rt.Cell; + _0: rs.u8; + _1: rs.Cell; - constructor(_0: rt.u8, _1: rt.Cell) { + constructor(_0: rs.u8, _1: rs.Cell) { this._0 = _0; this._1 = _1; } @@ -18,12 +18,12 @@ export class Tally { } export function clone$Clone(self: Tally): Tally { - rt.cellSet(self._1, rt.u32Add(rt.u32Add(rt.u32Mul(self._1.v, 7), self._0 as rt.u32), 1)); - return new Tally(rt.u8WrappingAdd(self._0, 100), self._1); + rs.cellSet(self._1, rs.u32Add(rs.u32Add(rs.u32Mul(self._1.v, 7), self._0 as rs.u32), 1)); + return new Tally(rs.u8WrappingAdd(self._0, 100), self._1); } export function drop$ops_Drop(self: Tally): void { - rt.cellSet(self._1, rt.u32Add(rt.u32Mul(self._1.v, 3), self._0 as rt.u32)); + rs.cellSet(self._1, rs.u32Add(rs.u32Mul(self._1.v, 3), self._0 as rs.u32)); } //# sourceMappingURL=cows.Tally.ts.map diff --git a/ts/fixtures/lang/cows/expected/cows.ts b/ts/fixtures/lang/cows/expected/cows.ts index dd82c734f..86183f7de 100644 --- a/ts/fixtures/lang/cows/expected/cows.ts +++ b/ts/fixtures/lang/cows/expected/cows.ts @@ -1,176 +1,176 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$1qh6z5m as option_unwrapOr$1qh6z5m, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$00b7lvf as option_map$00b7lvf, map$1li8gst as option_map$1li8gst, mapOr$0lcrgk1 as option_mapOr$0lcrgk1, mapOr$1612aex as option_mapOr$1612aex, mapOr$1nwl1hk as option_mapOr$1nwl1hk } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$0jw3da9 as option_unwrapOr$0jw3da9, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$167hjon as option_map$167hjon, map$1g811lq as option_map$1g811lq, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$1je44uu as option_mapOr$1je44uu, mapOr$03q317x as option_mapOr$03q317x } from "./core/option.ts"; import * as Named from "./cows.Named.ts"; import * as Run from "./cows.Run.ts"; import * as Tally from "./cows.Tally.ts"; import { put, text } from "./harness.ts"; /** `to_mut` of a `Result`'s payload, which the store rebuilds the `Result` around. */ -export function exclaimed(r: rt.Result): rt.Result { +export function exclaimed(r: rs.Result): rs.Result { if (r.ok) { - r = { ok: true, value: rt.strCowStr(r.value) }; + r = { ok: true, value: rs.strCowStr(r.value) }; return { ok: true, value: r.value + "!" }; } return r; } -export function cow(s: string, owned: boolean): rt.StrCow { +export function cow(s: string, owned: boolean): rs.StrCow { if (!owned) { - return new rt.Borrowed(s); + return new rs.Borrowed(s); } return s; } -export function cows(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let r!: rt.Result; +export function cows(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let r!: rs.Result; const s: string = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").next()), ""); - const _14: rt.u8 = rt.u8Rem(kind, 6); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); + const _14: rs.u8 = rs.u8Rem(kind, 6); if (_14 === 0) { - const c: rt.StrCow = cow(s, owned); - rt.byteVecPush(out, rt.stringLen(rt.strCowStr(c)) & 0xff); - rt.byteVecPush(out, rt.strCowStr(c).length === 0 ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.strChars(rt.strCowStr(c))) & 0xff); - put(out, rt.strCowStr(c)); - put(out, rt.strCowStr(c)); - put(out, rt.strCowStr(rt.strCowClone(c))); - put(out, rt.strCowStr(c)); - put(out, rt.strCowStr(c)); - put(out, rt.strCowStr("")); - put(out, rt.strCowStr(new rt.Borrowed("fallback"))); - put(out, rt.strCowStr(s)); - const shared: rt.Arc = new rt.Arc(rt.strCowStr(new rt.Borrowed(s))); + const c: rs.StrCow = cow(s, owned); + rs.byteVecPush(out, rs.stringLen(rs.strCowStr(c)) & 0xff); + rs.byteVecPush(out, rs.strCowStr(c).length === 0 ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.strChars(rs.strCowStr(c))) & 0xff); + put(out, rs.strCowStr(c)); + put(out, rs.strCowStr(c)); + put(out, rs.strCowStr(rs.strCowClone(c))); + put(out, rs.strCowStr(c)); + put(out, rs.strCowStr(c)); + put(out, rs.strCowStr("")); + put(out, rs.strCowStr(new rs.Borrowed("fallback"))); + put(out, rs.strCowStr(s)); + const shared: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); put(out, shared.value); - put(out, rt.strCowStr(option_unwrapOr$1qh6z5m(option_map$1li8gst(rt.iterNth(rt.strSplit(s, "\\"), 1), (a0: string): rt.StrCow => { - return new rt.Borrowed(a0); - }), new rt.Borrowed("fallback")))); - put(out, rt.strCowStr(cow(first, owned))); + put(out, rs.strCowStr(option_unwrapOr$0jw3da9(option_map$1g811lq(rs.iterNth(rs.strSplit(s, "\\"), 1), (a0: string): rs.StrCow => { + return new rs.Borrowed(a0); + }), new rs.Borrowed("fallback")))); + put(out, rs.strCowStr(cow(first, owned))); put(out, first); shared[Symbol.dispose](); } else if (_14 === 1) { - let c2: rt.StrCow = cow(s, owned); - c2 = rt.strCowStr(c2); + let c2: rs.StrCow = cow(s, owned); + c2 = rs.strCowStr(c2); c2 = c2 + "!"; - c2 = rt.strCowStr(c2); + c2 = rs.strCowStr(c2); c2 = c2 + "?"; c2 = c2 + "𐀀"; - put(out, rt.strCowStr(c2)); + put(out, rs.strCowStr(c2)); put(out, s); - const v: rt.Vec = rt.vecFrom([cow(first, owned), cow(s, !owned)]); - const at = rt.idx(v.items, 1); - v.items[at] = rt.strCowStr(v.items[at]); + const v: rs.Vec = rs.vecFrom([cow(first, owned), cow(s, !owned)]); + const at = rs.idx(v.items, 1); + v.items[at] = rs.strCowStr(v.items[at]); v.items[at] = v.items[at] + "v"; for (const _124 of v.items) { - put(out, rt.strCowStr(_124)); - } - put(out, rt.strCowStr(c2)); - let joined: rt.StrCow = rt.strCowAdd(rt.strCowAdd(cow("", owned), new rt.Borrowed(first)), cow(s, !owned)); - const _145: rt.StrCow = cow("", !owned); - joined = rt.strCowAdd(joined, _145); - joined = rt.strCowAdd(joined, new rt.Borrowed("+")); - put(out, rt.strCowStr(joined)); + put(out, rs.strCowStr(_124)); + } + put(out, rs.strCowStr(c2)); + let joined: rs.StrCow = rs.strCowAdd(rs.strCowAdd(cow("", owned), new rs.Borrowed(first)), cow(s, !owned)); + const _145: rs.StrCow = cow("", !owned); + joined = rs.strCowAdd(joined, _145); + joined = rs.strCowAdd(joined, new rs.Borrowed("+")); + put(out, rs.strCowStr(joined)); if ((kind & 64) === 0) { - r = rt.Ok(cow(first, owned)); + r = rs.Ok(cow(first, owned)); } else { - r = rt.Err(kind); + r = rs.Err(kind); } - const _156: rt.Result = exclaimed(r); + const _156: rs.Result = exclaimed(r); if (_156.ok) { - put(out, rt.strCowStr(_156.value)); + put(out, rs.strCowStr(_156.value)); } else { - rt.byteVecPush(out, _156.error); + rs.byteVecPush(out, _156.error); } } else if (_14 === 2) { - const a: rt.StrCow = cow(s, owned); - const b: rt.StrCow = cow(first, !owned); - const iter2: rt.Iter = rt.iterSlice([rt.strCowStr(a) === first, rt.strCowStr(a) === first, rt.strCowStr(a) === s, first === rt.strCowStr(a), s === rt.strCowStr(a), rt.strCowStr(a) === rt.strCowStr(b), rt.strCowStr(a) !== rt.strCowStr(b), rt.cowBy(rt.cmpStr)(a, b) < 0, rt.cowBy(rt.cmpStr)(a, b) >= 0, rt.cowBy(rt.cmpStr)(a, b) === 1]); + const a: rs.StrCow = cow(s, owned); + const b: rs.StrCow = cow(first, !owned); + const iter2: rs.Iter = rs.iterSlice([rs.strCowStr(a) === first, rs.strCowStr(a) === first, rs.strCowStr(a) === s, first === rs.strCowStr(a), s === rs.strCowStr(a), rs.strCowStr(a) === rs.strCowStr(b), rs.strCowStr(a) !== rs.strCowStr(b), rs.cowBy(rs.cmpStr)(a, b) < 0, rs.cowBy(rs.cmpStr)(a, b) >= 0, rs.cowBy(rs.cmpStr)(a, b) === 1]); while (true) { - const _205: boolean | rt.Done = iter2.next(); - if (_205 === rt.DONE) { + const _205: boolean | rs.Done = iter2.next(); + if (_205 === rs.DONE) { break; } - rt.byteVecPush(out, _205 ? 1 : 0); + rs.byteVecPush(out, _205 ? 1 : 0); } - const _216: rt.StrCow = rt.strCowClone(b); - rt.byteVecPush(out, rt.strCowStr(rt.ordMax(a, _216, rt.cmpLt(rt.cowBy(rt.cmpStr)))) === rt.strCowStr(b) ? 1 : 0); + const _216: rs.StrCow = rs.strCowClone(b); + rs.byteVecPush(out, rs.strCowStr(rs.ordMax(a, _216, rs.cmpLt(rs.cowBy(rs.cmpStr)))) === rs.strCowStr(b) ? 1 : 0); } else if (_14 === 3) { const n: Named.Named = Named.new(first, kind); const m2: Named.Named = Named.clone$Clone(n); Named.tag(n, 120); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rt.Formatter) => Named.fmt$fmt_Debug(m2, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1]])); - rt.byteVecPush(out, Named.eq$cmp_PartialEq(n, m2) ? 1 : 0); - rt.byteVecPush(out, Named.cmp$cmp_Ord(n, m2) > 0 ? 1 : 0); - rt.byteVecPush(out, Named.partialCmp$cmp_PartialOrd(n, m2) === -1 ? 1 : 0); - put(out, rt.strCowStr(Named.intoOwned(n).name)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(n, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(m2, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + rs.byteVecPush(out, Named.eq$cmp_PartialEq(n, m2) ? 1 : 0); + rs.byteVecPush(out, Named.cmp$cmp_Ord(n, m2) > 0 ? 1 : 0); + rs.byteVecPush(out, Named.partialCmp$cmp_PartialOrd(n, m2) === -1 ? 1 : 0); + put(out, rs.strCowStr(Named.intoOwned(n).name)); const _270: Named.Named = Named.default$Default(); const _272: Named.Named = Named.new("", kind); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rt.Formatter) => Named.fmt$fmt_Debug(_272, f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Named.fmt$fmt_Debug(_270, f), (f: rs.Formatter) => Named.fmt$fmt_Debug(_272, f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1]])); } else if (_14 === 4) { - const counts: rt.BTreeMap = rt.btreeNew(rt.cowBy(rt.cmpStr)) as rt.BTreeMap; - const iter3: rt.Iter<[rt.usize, string]> = rt.iterEnumerate(rt.strSplit(s, "/")); + const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; + const iter3: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.strSplit(s, "/")); while (true) { - const _286: [rt.usize, string] | rt.Done = iter3.next(); - if (_286 === rt.DONE) { + const _286: [rs.usize, string] | rs.Done = iter3.next(); + if (_286 === rs.DONE) { break; } - const _294: rt.StrCow = cow(_286[1], rt.usizeRem(_286[0], 2) === 1 === owned); - const _291: rt.Place = rt.entryOrInsertMut(rt.entry(counts, _294), 0); - _291.v = rt.u8Add(_291.v, 1); + const _294: rs.StrCow = cow(_286[1], rs.usizeRem(_286[0], 2) === 1 === owned); + const _291: rs.Place = rs.entryOrInsertMut(rs.entry(counts, _294), 0); + _291.v = rs.u8Add(_291.v, 1); } - const iter4: rt.Iter<[rt.StrCow, rt.u8]> = rt.btreeIter(counts); + const iter4: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); while (true) { - const _303: [rt.StrCow, rt.u8] | rt.Done = iter4.next(); - if (_303 === rt.DONE) { + const _303: [rs.StrCow, rs.u8] | rs.Done = iter4.next(); + if (_303 === rs.DONE) { break; } - put(out, rt.strCowStr(_303[0])); - rt.byteVecPush(out, _303[1]); + put(out, rs.strCowStr(_303[0])); + rs.byteVecPush(out, _303[1]); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeGet(counts, first), 255)); - const names: rt.HashSet = rt.hashNew(rt.hashing(Named.hash$Hash_hash_DefaultHasher as (a0: Named.Named, a1: rt.Hasher) => undefined, Named.eq$cmp_PartialEq)) as rt.HashSet; - const iter5: rt.Iter = rt.strSplit(s, "/"); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, first), 255)); + const names: rs.HashSet = rs.hashNew(rs.hashing(Named.hash$Hash_hash_DefaultHasher as (a0: Named.Named, a1: rs.Hasher) => undefined, Named.eq$cmp_PartialEq)) as rs.HashSet; + const iter5: rs.Iter = rs.strSplit(s, "/"); while (true) { - const _323: string | rt.Done = iter5.next(); - if (_323 === rt.DONE) { + const _323: string | rs.Done = iter5.next(); + if (_323 === rs.DONE) { break; } const _329: Named.Named = Named.new(_323, 0); - rt.hashAdd(names, _329); + rs.hashAdd(names, _329); } - rt.byteVecPush(out, rt.hashLen(names) & 0xff); + rs.byteVecPush(out, rs.hashLen(names) & 0xff); const _339: Named.Named = Named.new(first, 0); - rt.byteVecPush(out, rt.hashContains(names, _339) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(names, _339) ? 1 : 0); } else { - const c4: rt.StrCow = cow(s, owned); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rt.strCowStr(c4)), (f: rt.Formatter) => rt.fmtStr(rt.strCowStr(c4), f)]; - put(out, rt.fmtFormat(["[", args6[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 3 }, args6[0]), "|", args6[1], "]"])); + const c4: rs.StrCow = cow(s, owned); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(c4)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(c4), f)]; + put(out, rs.fmtFormat(["[", args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 3 }, args6[0]), "|", args6[1], "]"])); const part2 = cow(first, owned); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: rt.StrCow, f: rt.Formatter) => rt.fmtStr(rt.strCowStr(value), f))]; - put(out, rt.fmtFormat([args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: rs.StrCow, f: rs.Formatter) => rs.fmtStr(rs.strCowStr(value), f))]; + put(out, rs.fmtFormat([args8[0]])); } } /** Whether `c` borrows, as a match tells. */ -export function borrows(c: rt.StrCow): rt.u8 { - if (c instanceof rt.Borrowed) { +export function borrows(c: rs.StrCow): rs.u8 { + if (c instanceof rs.Borrowed) { return 1; } return 0; } /** Point `s` at `to`, through the `&mut` a caller passes. */ -export function repointStr(s: rt.Place, to: string): void { +export function repointStr(s: rs.Place, to: string): void { s.v = to; } /** A clone of `t`, through a generic. */ -export function cloned$borrow_Cow_str(t: rt.StrCow): rt.StrCow { - return rt.strCowClone(t); +export function cloned$borrow_Cow_str(t: rs.StrCow): rs.StrCow { + return rs.strCowClone(t); } /** @@ -178,535 +178,535 @@ export function cloned$borrow_Cow_str(t: rt.StrCow): rt.StrCow { * clones, joins, and changes one, matched on by reference, in place, and by value, and * held in collections and fields. */ -export function variants(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function variants(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let made2!: string; - let _184!: rt.StrCow; + let _184!: rs.StrCow; const s: string = text(data); const owned: boolean = (kind & 128) !== 0; - const first: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").next()), ""); - const rest: string = option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, "/").nextBack()), ""); - const _21: rt.u8 = rt.u8Rem(kind, 3); + const first: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").next()), ""); + const rest: string = option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, "/").nextBack()), ""); + const _21: rs.u8 = rs.u8Rem(kind, 3); if (_21 === 0) { - const c: rt.StrCow = cow(s, owned); - const _27: rt.StrCow = rt.strCowClone(c); - const _29: rt.StrCow = cloned$borrow_Cow_str(c); - const _31: rt.StrCow = new rt.Borrowed(first); - const _32: rt.StrCow = s; - const _35: rt.StrCow = new rt.Borrowed(s); - const _37: rt.StrCow = new rt.Borrowed(first); - const _38: rt.StrCow = ""; - const _39: rt.StrCow = rt.stringExtendChars("", rt.iterRev(rt.strChars(first))); - const iterS: rt.StrCow[] = [_27, _29, _31, _32, _35, _37, _38, new rt.Borrowed("fallback"), _39]; + const c: rs.StrCow = cow(s, owned); + const _27: rs.StrCow = rs.strCowClone(c); + const _29: rs.StrCow = cloned$borrow_Cow_str(c); + const _31: rs.StrCow = new rs.Borrowed(first); + const _32: rs.StrCow = s; + const _35: rs.StrCow = new rs.Borrowed(s); + const _37: rs.StrCow = new rs.Borrowed(first); + const _38: rs.StrCow = ""; + const _39: rs.StrCow = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); + const iterS: rs.StrCow[] = [_27, _29, _31, _32, _35, _37, _38, new rs.Borrowed("fallback"), _39]; for (const _45 of iterS) { - rt.byteVecPush(out, borrows(_45)); - put(out, rt.strCowStr(_45)); - } - let m: rt.StrCow = cow(first, owned); - m = rt.strCowStr(m); - rt.byteVecPush(out, borrows(m)); - put(out, rt.strCowStr(cow(rest, owned))); - const iter2: rt.Iter<[string, string]> = rt.iterSlice([["", rest] as [string, string], [first, ""] as [string, string], [first, rest] as [string, string], ["", ""] as [string, string]]); + rs.byteVecPush(out, borrows(_45)); + put(out, rs.strCowStr(_45)); + } + let m: rs.StrCow = cow(first, owned); + m = rs.strCowStr(m); + rs.byteVecPush(out, borrows(m)); + put(out, rs.strCowStr(cow(rest, owned))); + const iter2: rs.Iter<[string, string]> = rs.iterSlice([["", rest] as [string, string], [first, ""] as [string, string], [first, rest] as [string, string], ["", ""] as [string, string]]); while (true) { - const _74: [string, string] | rt.Done = iter2.next(); - if (_74 === rt.DONE) { + const _74: [string, string] | rs.Done = iter2.next(); + if (_74 === rs.DONE) { break; } - const iter3: rt.Iter<[boolean, boolean]> = rt.iterSlice([[false, false] as [boolean, boolean], [false, true] as [boolean, boolean], [true, false] as [boolean, boolean], [true, true] as [boolean, boolean]]); + const iter3: rs.Iter<[boolean, boolean]> = rs.iterSlice([[false, false] as [boolean, boolean], [false, true] as [boolean, boolean], [true, false] as [boolean, boolean], [true, true] as [boolean, boolean]]); while (true) { - const _86: [boolean, boolean] | rt.Done = iter3.next(); - if (_86 === rt.DONE) { + const _86: [boolean, boolean] | rs.Done = iter3.next(); + if (_86 === rs.DONE) { break; } const lo: boolean = _86[0]; const ro: boolean = _86[1]; - const joined: rt.StrCow = rt.strCowAdd(cow(_74[0], lo), cow(_74[1], ro)); - rt.byteVecPush(out, borrows(joined)); - put(out, rt.strCowStr(joined)); - let j: rt.StrCow = cow(_74[0], lo); - j = rt.strCowAdd(j, new rt.Borrowed(_74[1])); - rt.byteVecPush(out, borrows(j)); - rt.byteVecPush(out, borrows(rt.strCowAdd(cow(_74[0], lo), new rt.Borrowed(_74[1])))); + const joined: rs.StrCow = rs.strCowAdd(cow(_74[0], lo), cow(_74[1], ro)); + rs.byteVecPush(out, borrows(joined)); + put(out, rs.strCowStr(joined)); + let j: rs.StrCow = cow(_74[0], lo); + j = rs.strCowAdd(j, new rs.Borrowed(_74[1])); + rs.byteVecPush(out, borrows(j)); + rs.byteVecPush(out, borrows(rs.strCowAdd(cow(_74[0], lo), new rs.Borrowed(_74[1])))); } } } else if (_21 === 1) { - let c2: rt.StrCow = cow(s, owned); - if (c2 instanceof rt.Borrowed) { - put(out, (c2 as rt.Borrowed).slice); + let c2: rs.StrCow = cow(s, owned); + if (c2 instanceof rs.Borrowed) { + put(out, (c2 as rs.Borrowed).slice); } else { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); put(out, c2 as string); } - if (!(c2 instanceof rt.Borrowed)) { + if (!(c2 instanceof rs.Borrowed)) { (c2 as string) = (c2 as string) + "!"; } - put(out, rt.strCowStr(c2)); - const kept: rt.StrCow = rt.strCowClone(c2); - if (c2 instanceof rt.Borrowed) { - (c2 as rt.Borrowed).slice = first; + put(out, rs.strCowStr(c2)); + const kept: rs.StrCow = rs.strCowClone(c2); + if (c2 instanceof rs.Borrowed) { + (c2 as rs.Borrowed).slice = first; } - if (!(c2 instanceof rt.Borrowed)) { - const _137: string = rt.stringExtendChars("", rt.iterRev(rt.strChars(first))); + if (!(c2 instanceof rs.Borrowed)) { + const _137: string = rs.stringExtendChars("", rs.iterRev(rs.strChars(first))); (c2 as string) = _137; } - put(out, rt.strCowStr(c2)); - put(out, rt.strCowStr(kept)); - rt.byteVecPush(out, borrows(kept)); - let e: rt.StrCow = cow(s, !owned); - const kept2: rt.StrCow = rt.strCowClone(e); - if (e instanceof rt.Borrowed) { - const borrowed = e as rt.Borrowed; - repointStr(rt.place(() => borrowed.slice as string, (value) => borrowed.slice = value), rest); + put(out, rs.strCowStr(c2)); + put(out, rs.strCowStr(kept)); + rs.byteVecPush(out, borrows(kept)); + let e: rs.StrCow = cow(s, !owned); + const kept2: rs.StrCow = rs.strCowClone(e); + if (e instanceof rs.Borrowed) { + const borrowed = e as rs.Borrowed; + repointStr(rs.place(() => borrowed.slice as string, (value) => borrowed.slice = value), rest); put(out, borrowed.slice); borrowed.slice = first; } else { - const _162: rt.usize = option_mapOr$1612aex(rt.iterToOption(rt.strChars(e as string).next()), 0, (a05: rt.char): rt.usize => { - return rt.charLenUtf8(a05); + const _162: rs.usize = option_mapOr$1je44uu(rs.iterToOption(rs.strChars(e as string).next()), 0, (a05: rs.char): rs.usize => { + return rs.charLenUtf8(a05); }); - (e as string) = rt.stringTruncate(e as string, _162); + (e as string) = rs.stringTruncate(e as string, _162); (e as string) = (e as string) + "?"; } - put(out, rt.strCowStr(e)); - put(out, rt.strCowStr(kept2)); - if (c2 instanceof rt.Borrowed) { - made2 = rt.strToUppercase((c2 as rt.Borrowed).slice); + put(out, rs.strCowStr(e)); + put(out, rs.strCowStr(kept2)); + if (c2 instanceof rs.Borrowed) { + made2 = rs.strToUppercase((c2 as rs.Borrowed).slice); } else { made2 = c2 as string; } put(out, made2); - let d: rt.StrCow = cow(first, !owned); + let d: rs.StrCow = cow(first, !owned); b18: { - if (d instanceof rt.Borrowed) { - if (!((d as rt.Borrowed).slice.length === 0)) { - _184 = rt.stringExtendChars("", rt.iterSkip(rt.strChars((d as rt.Borrowed).slice), 1)); + if (d instanceof rs.Borrowed) { + if (!((d as rs.Borrowed).slice.length === 0)) { + _184 = rs.stringExtendChars("", rs.iterSkip(rs.strChars((d as rs.Borrowed).slice), 1)); break b18; } } _184 = d; } d = _184; - rt.byteVecPush(out, borrows(d)); - put(out, rt.strCowStr(d)); - const _199: rt.StrCow | undefined = cow(rest, owned); + rs.byteVecPush(out, borrows(d)); + put(out, rs.strCowStr(d)); + const _199: rs.StrCow | undefined = cow(rest, owned); if (_199 !== undefined) { - if (_199 instanceof rt.Borrowed) { - put(out, (_199 as rt.Borrowed).slice); + if (_199 instanceof rs.Borrowed) { + put(out, (_199 as rs.Borrowed).slice); } } } else { - const parts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.strSplit(s, "/")), (_2: [rt.usize, string]): rt.StrCow => { - return cow(_2[1], rt.usizeRem(_2[0], 2) === 1 === owned); + const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.strSplit(s, "/")), (_2: [rs.usize, string]): rs.StrCow => { + return cow(_2[1], rs.usizeRem(_2[0], 2) === 1 === owned); }), "next", 12); for (const _216 of parts.items) { - rt.byteVecPush(out, borrows(_216)); + rs.byteVecPush(out, borrows(_216)); } - put(out, rt.strsJoin(parts.items.map(rt.strCowStr), "+")); - put(out, rt.strsJoin(parts.items.map(rt.strCowStr), "")); - const collected: string = rt.stringFromStrings(rt.iterMap(rt.iterMap(rt.iterRev(rt.iterSlice(parts.items)), (a0: rt.StrCow): rt.StrCow => { - return rt.strCowClone(a0); - }), rt.strCowStr)); + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "+")); + put(out, rs.strsJoin(parts.items.map(rs.strCowStr), "")); + const collected: string = rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterRev(rs.iterSlice(parts.items)), (a0: rs.StrCow): rs.StrCow => { + return rs.strCowClone(a0); + }), rs.strCowStr)); let extended: string = rest; - const _244: rt.Iter = rt.iterMap(rt.iterSlice(parts.items), (a02: rt.StrCow): rt.StrCow => { - return rt.strCowClone(a02); + const _244: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (a02: rs.StrCow): rs.StrCow => { + return rs.strCowClone(a02); }); - extended = rt.stringExtend(extended, rt.iterMap(_244, rt.strCowStr)); - const _251: rt.Iter<[rt.StrCow, rt.usize]> = rt.iterMap(rt.iterSlice(parts.items), (p: rt.StrCow): [rt.StrCow, rt.usize] => { - return [rt.strCowClone(p), rt.stringLen(rt.strCowStr(p))] as [rt.StrCow, rt.usize]; + extended = rs.stringExtend(extended, rs.iterMap(_244, rs.strCowStr)); + const _251: rs.Iter<[rs.StrCow, rs.usize]> = rs.iterMap(rs.iterSlice(parts.items), (p: rs.StrCow): [rs.StrCow, rs.usize] => { + return [rs.strCowClone(p), rs.stringLen(rs.strCowStr(p))] as [rs.StrCow, rs.usize]; }); - const _250: [string, rt.Vec] = rt.tupleExtend(["", new rt.Vec()] as [string, rt.Vec], _251, [rt.STRING_COW_PART, rt.vecPart(4)]); + const _250: [string, rs.Vec] = rs.tupleExtend(["", new rs.Vec()] as [string, rs.Vec], _251, [rs.STRING_COW_PART, rs.vecPart(4)]); const texts: string = _250[0]; - const lens: rt.Vec = _250[1]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, collected), (f: rt.Formatter) => rt.fmtPad(f, extended), (f: rt.Formatter) => rt.fmtPad(f, texts), (f: rt.Formatter) => rt.fmtList(lens.items, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]])); - const counts: rt.BTreeMap = rt.btreeNew(rt.cowBy(rt.cmpStr)) as rt.BTreeMap; - const iter5: rt.Iter = rt.iterRev(rt.iterSlice(parts.items)); + const lens: rs.Vec = _250[1]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, collected), (f: rs.Formatter) => rs.fmtPad(f, extended), (f: rs.Formatter) => rs.fmtPad(f, texts), (f: rs.Formatter) => rs.fmtList(lens.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]])); + const counts: rs.BTreeMap = rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeMap; + const iter5: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); while (true) { - const _280: rt.StrCow | rt.Done = iter5.next(); - if (_280 === rt.DONE) { + const _280: rs.StrCow | rs.Done = iter5.next(); + if (_280 === rs.DONE) { break; } - const _287: rt.StrCow = rt.strCowClone(_280); - const _284: rt.Place = rt.entryOrInsertMut(rt.entry(counts, _287), 0); - _284.v = rt.u8Add(_284.v, 1); + const _287: rs.StrCow = rs.strCowClone(_280); + const _284: rs.Place = rs.entryOrInsertMut(rs.entry(counts, _287), 0); + _284.v = rs.u8Add(_284.v, 1); } - const iter6: rt.Iter<[rt.StrCow, rt.u8]> = rt.btreeIter(counts); + const iter6: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); while (true) { - const _292: [rt.StrCow, rt.u8] | rt.Done = iter6.next(); - if (_292 === rt.DONE) { + const _292: [rs.StrCow, rs.u8] | rs.Done = iter6.next(); + if (_292 === rs.DONE) { break; } - rt.byteVecPush(out, borrows(_292[0])); - rt.byteVecPush(out, _292[1]); + rs.byteVecPush(out, borrows(_292[0])); + rs.byteVecPush(out, _292[1]); } - const _301: [rt.StrCow, rt.u8] | undefined = rt.btreeGetKeyValue(counts, first); + const _301: [rs.StrCow, rs.u8] | undefined = rs.btreeGetKeyValue(counts, first); if (_301 !== undefined) { - rt.byteVecPush(out, borrows(_301[0])); + rs.byteVecPush(out, borrows(_301[0])); } - const iter7: rt.Iter<[rt.StrCow, rt.u8]> = rt.btreeRange(counts, [{ tag: "Included", _0: first } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + const iter7: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeRange(counts, [{ tag: "Included", _0: first } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); while (true) { - const _314: [rt.StrCow, rt.u8] | rt.Done = iter7.next(); - if (_314 === rt.DONE) { + const _314: [rs.StrCow, rs.u8] | rs.Done = iter7.next(); + if (_314 === rs.DONE) { break; } - put(out, rt.strCowStr(_314[0])); - rt.byteVecPush(out, _314[1]); + put(out, rs.strCowStr(_314[0])); + rs.byteVecPush(out, _314[1]); } - const iter8: rt.Iter<[rt.StrCow, rt.Place]> = rt.btreeRangeMut(counts, [{ tag: "Excluded", _0: rest } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + const iter8: rs.Iter<[rs.StrCow, rs.Place]> = rs.btreeRangeMut(counts, [{ tag: "Excluded", _0: rest } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); while (true) { - const _330: [rt.StrCow, rt.Place] | rt.Done = iter8.next(); - if (_330 === rt.DONE) { + const _330: [rs.StrCow, rs.Place] | rs.Done = iter8.next(); + if (_330 === rs.DONE) { break; } - _330[1].v = rt.u8Add(_330[1].v, 1); + _330[1].v = rs.u8Add(_330[1].v, 1); } - const _336: rt.Iter = rt.iterMap(rt.btreeKeys(counts), (a03: rt.StrCow): rt.StrCow => { - return rt.strCowClone(a03); + const _336: rs.Iter = rs.iterMap(rs.btreeKeys(counts), (a03: rs.StrCow): rs.StrCow => { + return rs.strCowClone(a03); }); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cowBy(rt.cmpStr)) as rt.BTreeSet, _336, true, undefined, undefined, 12, true), [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rest } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]), borrows), "next"); - const _347: rt.Iter<[rt.StrCow, rt.u8]> = rt.btreeIter(counts); - const hashed: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashCow(rt.hashStr), rt.cowBy(rt.same), true)) as rt.HashMap, _347, undefined, undefined, undefined, 58720256); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(hashed, first), 255)); - rt.byteVecPush(out, rt.hashContains(hashed, rest) ? 1 : 0); - const both: rt.HashSet = rt.hashNew(rt.hashing(rt.hashCow(rt.hashStr), rt.cowBy(rt.same), true)) as rt.HashSet; - const _361: rt.StrCow = cow(first, owned); - rt.hashAdd(both, _361); - const _366: rt.StrCow = cow(first, !owned); - rt.byteVecPush(out, rt.hashAdd(both, _366) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(both) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cowBy(rs.cmpStr)) as rs.BTreeSet, _336, true, undefined, undefined, 12, true), [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rest } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]), borrows), "next"); + const _347: rs.Iter<[rs.StrCow, rs.u8]> = rs.btreeIter(counts); + const hashed: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashMap, _347, undefined, undefined, undefined, 58720256); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(hashed, first), 255)); + rs.byteVecPush(out, rs.hashContains(hashed, rest) ? 1 : 0); + const both: rs.HashSet = rs.hashNew(rs.hashing(rs.hashCow(rs.hashStr), rs.cowBy(rs.same), true)) as rs.HashSet; + const _361: rs.StrCow = cow(first, owned); + rs.hashAdd(both, _361); + const _366: rs.StrCow = cow(first, !owned); + rs.byteVecPush(out, rs.hashAdd(both, _366) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(both) & 0xff); const named: Named.Named = Named.new(first, kind); - rt.byteVecPush(out, borrows(named.name)); + rs.byteVecPush(out, borrows(named.name)); Named.tag(named, 120); - rt.byteVecPush(out, borrows(named.name)); - const o2: rt.StrCow | undefined = rt.iterNth(rt.vecIntoIter(parts), 1); - rt.byteVecPush(out, option_mapOr$1nwl1hk(o2, 2, borrows)); - rt.byteVecPush(out, option_mapOr$0lcrgk1(option_map$00b7lvf(o2, (a04: rt.StrCow): string => { - return rt.strCowStr(a04); - }), 0, (t: string): rt.u8 => { - return rt.stringLen(t) & 0xff; + rs.byteVecPush(out, borrows(named.name)); + const o2: rs.StrCow | undefined = rs.iterNth(rs.vecIntoIter(parts), 1); + rs.byteVecPush(out, option_mapOr$03q317x(o2, 2, borrows)); + rs.byteVecPush(out, option_mapOr$1nyk1yj(option_map$167hjon(o2, (a04: rs.StrCow): string => { + return rs.strCowStr(a04); + }), 0, (t: string): rs.u8 => { + return rs.stringLen(t) & 0xff; })); } } /** A slice of `u16`s read from `data`, two bytes each. */ -export function words(data: rt.ByteSlice): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): rt.u16 => { - rt.idx(c, 0); - return (((c.data[c.start] as rt.u16) << 8) & 0xffff) | rt.optionUnwrap(rt.byteSliceLast(c)) as rt.u16; +export function words(data: rs.ByteSlice): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (c: rs.ByteSlice): rs.u16 => { + rs.idx(c, 0); + return (((c.data[c.start] as rs.u16) << 8) & 0xffff) | rs.optionUnwrap(rs.byteSliceLast(c)) as rs.u16; }), undefined, 2, true); } -export function cowOf(v: rt.u16[], owned: boolean): rt.Cow { +export function cowOf(v: rs.u16[], owned: boolean): rs.Cow { if (!owned) { - return new rt.Borrowed(v); + return new rs.Borrowed(v); } - return rt.vecFrom(v.slice()); + return rs.vecFrom(v.slice()); } -export function putWords(out: rt.ByteVec, v: rt.u16[]): void { - rt.byteVecPush(out, v.length & 0xff); +export function putWords(out: rs.ByteVec, v: rs.u16[]): void { + rs.byteVecPush(out, v.length & 0xff); for (const _8 of v) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_8))); } } -export function hashed$Vec_u8(v: rt.ByteVec): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(v, h); - return rt.hashFinish(h); +export function hashed$Vec_u8(v: rs.ByteVec): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(v, h); + return rs.hashFinish(h); } -export function hashed$borrow_Cow_slice_u16(v: rt.Cow): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashCow(rt.hashInts(2))(v, h); - return rt.hashFinish(h); +export function hashed$borrow_Cow_slice_u16(v: rs.Cow): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashCow(rs.hashInts(2))(v, h); + return rs.hashFinish(h); } -export function hashed$borrow_Cow_slice_u8(v: rt.ByteCow): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(v, h); - return rt.hashFinish(h); +export function hashed$borrow_Cow_slice_u8(v: rs.ByteCow): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(v, h); + return rs.hashFinish(h); } -export function hashed$slice_u16(v: rt.u16[]): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(v, h); - return rt.hashFinish(h); +export function hashed$slice_u16(v: rs.u16[]): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(v, h); + return rs.hashFinish(h); } -export function hashed$slice_u8(v: rt.ByteSlice): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(v, h); - return rt.hashFinish(h); +export function hashed$slice_u8(v: rs.ByteSlice): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(v, h); + return rs.hashFinish(h); } /** * `Cow<[u16]>`: made each way, collected, and read, changed through `to_mut`, compared, * ordered, and hashed against each sequence, matched on, and held in a field and as a key. */ -export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let made!: rt.Vec; - let _359!: rt.Cow; - let c4!: rt.Cow; - const v: rt.Vec = words(data); +export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let made!: rs.Vec; + let _359!: rs.Cow; + let c4!: rs.Cow; + const v: rs.Vec = words(data); const owned: boolean = (kind & 128) !== 0; - const half: rt.u16[] = rt.sliceRange(v.items, 0, rt.usizeDiv(v.items.length, 2)); - const _15: rt.u8 = rt.u8Rem(kind, 6); + const half: rs.u16[] = rs.sliceRange(v.items, 0, rs.usizeDiv(v.items.length, 2)); + const _15: rs.u8 = rs.u8Rem(kind, 6); if (_15 === 0) { - const c: rt.Cow = cowOf(v.items, owned); - rt.byteVecPush(out, rt.cowSlice(c).length & 0xff); - rt.byteVecPush(out, rt.cowSlice(c).length === 0 ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterFold(rt.iterSlice(rt.cowSlice(c)), 0, (a2: rt.u16, w: rt.u16): rt.u16 => { - return rt.u16WrappingAdd(a2, w); + const c: rs.Cow = cowOf(v.items, owned); + rs.byteVecPush(out, rs.cowSlice(c).length & 0xff); + rs.byteVecPush(out, rs.cowSlice(c).length === 0 ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterFold(rs.iterSlice(rs.cowSlice(c)), 0, (a2: rs.u16, w: rs.u16): rs.u16 => { + return rs.u16WrappingAdd(a2, w); })))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.sliceFirst(rt.cowSlice(c)), 65535)))); - putWords(out, rt.cowSlice(c)); - putWords(out, rt.cowSlice(c)); - putWords(out, rt.cowSlice(rt.cowClone(c))); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.cowSlice(c), f, rt.u16Debug)]; - put(out, rt.fmtFormat([args2[0]])); - putWords(out, rt.cowIntoOwned(c).items); - putWords(out, rt.cowSlice(new rt.Vec())); - const iter: rt.Iter> = rt.iterSlice([new rt.Borrowed(half), rt.vecFrom(v.items.slice()), new rt.Borrowed(v.items), new rt.Borrowed([3, 1, 4]), rt.iterToVec(rt.iterRev(rt.iterSlice(v.items)), undefined, 2, true)]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(rs.sliceFirst(rs.cowSlice(c)), 65535)))); + putWords(out, rs.cowSlice(c)); + putWords(out, rs.cowSlice(c)); + putWords(out, rs.cowSlice(rs.cowClone(c))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.cowSlice(c), f, rs.u16Debug)]; + put(out, rs.fmtFormat([args2[0]])); + putWords(out, rs.cowIntoOwned(c).items); + putWords(out, rs.cowSlice(new rs.Vec())); + const iter: rs.Iter> = rs.iterSlice([new rs.Borrowed(half), rs.vecFrom(v.items.slice()), new rs.Borrowed(v.items), new rs.Borrowed([3, 1, 4]), rs.iterToVec(rs.iterRev(rs.iterSlice(v.items)), undefined, 2, true)]); while (true) { - const _100: rt.Cow | rt.Done = iter.next(); - if (_100 === rt.DONE) { + const _100: rs.Cow | rs.Done = iter.next(); + if (_100 === rs.DONE) { break; } - putWords(out, rt.cowSlice(_100)); + putWords(out, rs.cowSlice(_100)); } - putWords(out, rt.cowIntoOwned(cowOf(half, owned)).items); + putWords(out, rs.cowIntoOwned(cowOf(half, owned)).items); } else if (_15 === 1) { - let c2: rt.Cow = cowOf(v.items, owned); - const owned4 = rt.cowIntoOwned(c2); + let c2: rs.Cow = cowOf(v.items, owned); + const owned4 = rs.cowIntoOwned(c2); c2 = owned4; owned4.items.push(7); - const owned5 = rt.cowIntoOwned(c2); + const owned5 = rs.cowIntoOwned(c2); c2 = owned5; - const m: rt.Vec = owned5; - const _119: rt.Place | undefined = rt.sliceFirstMut(m.items); + const m: rs.Vec = owned5; + const _119: rs.Place | undefined = rs.sliceFirstMut(m.items); if (_119 !== undefined) { _119.v = _119.v ^ 65535; } m.items.push(9); - putWords(out, rt.cowSlice(c2)); + putWords(out, rs.cowSlice(c2)); putWords(out, v.items); - const cs: rt.Vec> = rt.vecFrom([cowOf(half, owned), cowOf(v.items, !owned)]); - const at = rt.idx(cs.items, 1); - const owned6 = rt.cowIntoOwned(cs.items[at]); + const cs: rs.Vec> = rs.vecFrom([cowOf(half, owned), cowOf(v.items, !owned)]); + const at = rs.idx(cs.items, 1); + const owned6 = rs.cowIntoOwned(cs.items[at]); cs.items[at] = owned6; - rt.vecTruncate(owned6, 1); + rs.vecTruncate(owned6, 1); for (const _144 of cs.items) { - putWords(out, rt.cowSlice(_144)); + putWords(out, rs.cowSlice(_144)); } const run: Run.Run = { words: cowOf(half, owned) }; const before: Run.Run = Run.clone$Clone(run); Run.bump(run); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rt.Formatter) => Run.fmt$fmt_Debug(before, f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(run, f), (f: rs.Formatter) => Run.fmt$fmt_Debug(before, f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1]])); putWords(out, half); - putWords(out, rt.cowIntoOwned(c2).items); + putWords(out, rs.cowIntoOwned(c2).items); } else if (_15 === 2) { - const a: rt.Cow = cowOf(v.items, owned); - const b: rt.Cow = cowOf(half, !owned); - const _182: rt.u16 = option_unwrapOr$1j4op5y(rt.sliceFirst(v.items), 0); - const array: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { + const a: rs.Cow = cowOf(v.items, owned); + const b: rs.Cow = cowOf(half, !owned); + const _182: rs.u16 = option_unwrapOr$1szdyfq(rs.sliceFirst(v.items), 0); + const array: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return _182; }); - const _188: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), rt.cowSlice(b)); - const _191: boolean = !rt.eqSlice(rt.same)(rt.cowSlice(a), rt.cowSlice(b)); - const _194: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), half); - const _201: rt.u16[] = rt.sliceRange(v.items, 0); - const _197: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), _201); - const _203: boolean = rt.eqSlice(rt.same)(rt.cowSlice(a), v); - const _209: rt.Vec = rt.vecFrom(half.slice()); - const _206: boolean = !rt.eqSlice(rt.same)(rt.cowSlice(a), _209); - const _210: boolean = rt.eqSlice(rt.same)(half, rt.cowSlice(b)); - const _213: boolean = rt.eqSlice(rt.same)(v, rt.cowSlice(a)); - const _219: rt.u16[] = rt.sliceRange(v.items, 0); - const _216: boolean = !rt.eqSlice(rt.same)(_219, rt.cowSlice(a)); - const _223: rt.u16[] = rt.cowSlice(a); - const _222: boolean = rt.eqSlice(rt.same)(_223, array); - const _227: rt.u16[] = rt.cowSlice(b); - const _229: rt.u16[] = rt.sliceRange(array, 0, rt.min(half.length, 2)); - const _226: boolean = rt.eqSlice(rt.same)(_227, _229); - const _234: boolean = rt.cowBy(rt.cmpSlice(rt.cmp))(a, b) < 0; - const _238: boolean = rt.cowBy(rt.cmpSlice(rt.cmp))(a, b) === 1; - const _244: boolean = rt.cowBy(rt.cmpSlice(rt.cmp))(a, b) === -1; - const order = rt.cowBy(rt.cmpSlice(rt.cmp))(a, b); + const _188: boolean = rs.eqSlice(rs.same)(rs.cowSlice(a), rs.cowSlice(b)); + const _191: boolean = !rs.eqSlice(rs.same)(rs.cowSlice(a), rs.cowSlice(b)); + const _194: boolean = rs.eqSlice(rs.same)(rs.cowSlice(a), half); + const _201: rs.u16[] = rs.sliceRange(v.items, 0); + const _197: boolean = rs.eqSlice(rs.same)(rs.cowSlice(a), _201); + const _203: boolean = rs.eqSlice(rs.same)(rs.cowSlice(a), v); + const _209: rs.Vec = rs.vecFrom(half.slice()); + const _206: boolean = !rs.eqSlice(rs.same)(rs.cowSlice(a), _209); + const _210: boolean = rs.eqSlice(rs.same)(half, rs.cowSlice(b)); + const _213: boolean = rs.eqSlice(rs.same)(v, rs.cowSlice(a)); + const _219: rs.u16[] = rs.sliceRange(v.items, 0); + const _216: boolean = !rs.eqSlice(rs.same)(_219, rs.cowSlice(a)); + const _223: rs.u16[] = rs.cowSlice(a); + const _222: boolean = rs.eqSlice(rs.same)(_223, array); + const _227: rs.u16[] = rs.cowSlice(b); + const _229: rs.u16[] = rs.sliceRange(array, 0, rs.min(half.length, 2)); + const _226: boolean = rs.eqSlice(rs.same)(_227, _229); + const _234: boolean = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b) < 0; + const _238: boolean = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b) === 1; + const _244: boolean = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b) === -1; + const order = rs.cowBy(rs.cmpSlice(rs.cmp))(a, b); const _247: boolean = order !== undefined && order >= 0; - const _250: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u16(a), hashed$slice_u16(rt.sliceRange(v.items, 0))); - const _256: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u16(b), hashed$slice_u16(half)); - const _262: rt.Cow = rt.ordMax(rt.cowClone(a), rt.cowClone(b), rt.cmpLt(rt.cowBy(rt.cmpSlice(rt.cmp)))); - const iter3: rt.Iter = rt.iterSlice([_188, _191, _194, _197, _203, _206, _210, _213, _216, _222, _226, _234, _238, _244, _247, _250, _256, rt.eqSlice(rt.same)(rt.cowSlice(_262), rt.cowSlice(b))]); + const _250: boolean = rs.u64Eq(hashed$borrow_Cow_slice_u16(a), hashed$slice_u16(rs.sliceRange(v.items, 0))); + const _256: boolean = rs.u64Eq(hashed$borrow_Cow_slice_u16(b), hashed$slice_u16(half)); + const _262: rs.Cow = rs.ordMax(rs.cowClone(a), rs.cowClone(b), rs.cmpLt(rs.cowBy(rs.cmpSlice(rs.cmp)))); + const iter3: rs.Iter = rs.iterSlice([_188, _191, _194, _197, _203, _206, _210, _213, _216, _222, _226, _234, _238, _244, _247, _250, _256, rs.eqSlice(rs.same)(rs.cowSlice(_262), rs.cowSlice(b))]); while (true) { - const _270: boolean | rt.Done = iter3.next(); - if (_270 === rt.DONE) { + const _270: boolean | rs.Done = iter3.next(); + if (_270 === rs.DONE) { break; } - rt.byteVecPush(out, _270 ? 1 : 0); + rs.byteVecPush(out, _270 ? 1 : 0); } } else if (_15 === 3) { - let c3: rt.Cow = cowOf(v.items, owned); - if (c3 instanceof rt.Borrowed) { - putWords(out, (c3 as rt.Borrowed).slice); + let c3: rs.Cow = cowOf(v.items, owned); + if (c3 instanceof rs.Borrowed) { + putWords(out, (c3 as rs.Borrowed).slice); } else { - rt.byteVecPush(out, 238); - putWords(out, (c3 as rt.Vec).items); - } - if (!(c3 instanceof rt.Borrowed)) { - (c3 as rt.Vec).items.push(5); - } - putWords(out, rt.cowSlice(c3)); - const kept: rt.Cow = rt.cowClone(c3); - if (c3 instanceof rt.Borrowed) { - (c3 as rt.Borrowed).slice = half; - } - if (!(c3 instanceof rt.Borrowed)) { - const _302: rt.Vec = rt.iterToVec(rt.iterRev(rt.iterSlice(half)), undefined, 2, true); - (c3 as rt.Vec) = _302; - } - putWords(out, rt.cowSlice(c3)); - putWords(out, rt.cowSlice(kept)); - let e: rt.Cow = cowOf(v.items, !owned); - const kept2: rt.Cow = rt.cowClone(e); - if (e instanceof rt.Borrowed) { - const borrowed = e as rt.Borrowed; - repoint$u16(rt.place(() => borrowed.slice as rt.u16[], (value5) => borrowed.slice = value5), half); - rt.byteVecPush(out, borrowed.slice.length & 0xff); - borrowed.slice = rt.sliceRange(v.items, 0, rt.min(v.items.length, 1)); - rt.byteVecPush(out, borrowed.slice.length & 0xff); + rs.byteVecPush(out, 238); + putWords(out, (c3 as rs.Vec).items); + } + if (!(c3 instanceof rs.Borrowed)) { + (c3 as rs.Vec).items.push(5); + } + putWords(out, rs.cowSlice(c3)); + const kept: rs.Cow = rs.cowClone(c3); + if (c3 instanceof rs.Borrowed) { + (c3 as rs.Borrowed).slice = half; + } + if (!(c3 instanceof rs.Borrowed)) { + const _302: rs.Vec = rs.iterToVec(rs.iterRev(rs.iterSlice(half)), undefined, 2, true); + (c3 as rs.Vec) = _302; + } + putWords(out, rs.cowSlice(c3)); + putWords(out, rs.cowSlice(kept)); + let e: rs.Cow = cowOf(v.items, !owned); + const kept2: rs.Cow = rs.cowClone(e); + if (e instanceof rs.Borrowed) { + const borrowed = e as rs.Borrowed; + repoint$u16(rs.place(() => borrowed.slice as rs.u16[], (value5) => borrowed.slice = value5), half); + rs.byteVecPush(out, borrowed.slice.length & 0xff); + borrowed.slice = rs.sliceRange(v.items, 0, rs.min(v.items.length, 1)); + rs.byteVecPush(out, borrowed.slice.length & 0xff); } else { - rt.vecTruncate(e as rt.Vec, 1); - const _336: rt.Vec = rt.vecFrom(half.slice()); - (e as rt.Vec) = _336; - rt.byteVecPush(out, (e as rt.Vec).items.length & 0xff); - } - putWords(out, rt.cowSlice(e)); - putWords(out, rt.cowSlice(kept2)); - if (c3 instanceof rt.Borrowed) { - made = rt.iterToVec(rt.iterRev(rt.iterSlice((c3 as rt.Borrowed).slice)), undefined, 2, true); + rs.vecTruncate(e as rs.Vec, 1); + const _336: rs.Vec = rs.vecFrom(half.slice()); + (e as rs.Vec) = _336; + rs.byteVecPush(out, (e as rs.Vec).items.length & 0xff); + } + putWords(out, rs.cowSlice(e)); + putWords(out, rs.cowSlice(kept2)); + if (c3 instanceof rs.Borrowed) { + made = rs.iterToVec(rs.iterRev(rs.iterSlice((c3 as rs.Borrowed).slice)), undefined, 2, true); } else { - made = c3 as rt.Vec; + made = c3 as rs.Vec; } putWords(out, made.items); - let d: rt.Cow = cowOf(half, !owned); + let d: rs.Cow = cowOf(half, !owned); b16: { - if (d instanceof rt.Borrowed) { - if ((d as rt.Borrowed).slice.length > 1) { - _359 = rt.vecFrom(rt.sliceRange((d as rt.Borrowed).slice, 1).slice()); + if (d instanceof rs.Borrowed) { + if ((d as rs.Borrowed).slice.length > 1) { + _359 = rs.vecFrom(rs.sliceRange((d as rs.Borrowed).slice, 1).slice()); break b16; } } _359 = d; } d = _359; - putWords(out, rt.cowSlice(d)); + putWords(out, rs.cowSlice(d)); } else if (_15 === 4) { - const counts: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cowBy(rt.cmpSlice(rt.cmp))) as rt.BTreeMap, rt.u8>; - const iter4: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunks(v.items, 2)); + const counts: rs.BTreeMap, rs.u8> = rs.btreeNew(rs.cowBy(rs.cmpSlice(rs.cmp))) as rs.BTreeMap, rs.u8>; + const iter4: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceChunks(v.items, 2)); while (true) { - const _379: [rt.usize, rt.u16[]] | rt.Done = iter4.next(); - if (_379 === rt.DONE) { + const _379: [rs.usize, rs.u16[]] | rs.Done = iter4.next(); + if (_379 === rs.DONE) { break; } - const _387: rt.Cow = cowOf(_379[1], rt.usizeRem(_379[0], 2) === 1 === owned); - const _384: rt.Place = rt.entryOrInsertMut(rt.entry(counts, _387), 0); - _384.v = rt.u8Add(_384.v, 1); + const _387: rs.Cow = cowOf(_379[1], rs.usizeRem(_379[0], 2) === 1 === owned); + const _384: rs.Place = rs.entryOrInsertMut(rs.entry(counts, _387), 0); + _384.v = rs.u8Add(_384.v, 1); } - const iter5: rt.Iter<[rt.Cow, rt.u8]> = rt.btreeIter(counts); + const iter5: rs.Iter<[rs.Cow, rs.u8]> = rs.btreeIter(counts); while (true) { - const _396: [rt.Cow, rt.u8] | rt.Done = iter5.next(); - if (_396 === rt.DONE) { + const _396: [rs.Cow, rs.u8] | rs.Done = iter5.next(); + if (_396 === rs.DONE) { break; } - putWords(out, rt.cowSlice(_396[0])); - rt.byteVecPush(out, _396[1]); + putWords(out, rs.cowSlice(_396[0])); + rs.byteVecPush(out, _396[1]); } - const _411: rt.Cow = cowOf(half, owned); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeGet(counts, _411), 255)); - const runs: rt.HashSet = rt.hashNew(rt.hashing(Run.hash$Hash_hash_DefaultHasher as (a0: Run.Run, a1: rt.Hasher) => undefined, Run.eq$cmp_PartialEq)) as rt.HashSet; - const iter6: rt.Iter = rt.sliceChunks(v.items, 3); + const _411: rs.Cow = cowOf(half, owned); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(counts, _411), 255)); + const runs: rs.HashSet = rs.hashNew(rs.hashing(Run.hash$Hash_hash_DefaultHasher as (a0: Run.Run, a1: rs.Hasher) => undefined, Run.eq$cmp_PartialEq)) as rs.HashSet; + const iter6: rs.Iter = rs.sliceChunks(v.items, 3); while (true) { - const _418: rt.u16[] | rt.Done = iter6.next(); - if (_418 === rt.DONE) { + const _418: rs.u16[] | rs.Done = iter6.next(); + if (_418 === rs.DONE) { break; } const _424: Run.Run = { words: cowOf(_418, owned) }; - rt.hashAdd(runs, _424); + rs.hashAdd(runs, _424); } - rt.byteVecPush(out, rt.hashLen(runs) & 0xff); - const _435: Run.Run = { words: cowOf(rt.sliceRange(v.items, 0, rt.min(v.items.length, 3)), !owned) }; - rt.byteVecPush(out, rt.hashContains(runs, _435) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(runs) & 0xff); + const _435: Run.Run = { words: cowOf(rs.sliceRange(v.items, 0, rs.min(v.items.length, 3)), !owned) }; + rs.byteVecPush(out, rs.hashContains(runs, _435) ? 1 : 0); const part4 = Run.default$Default(); - const args6: rt.Fmt[] = [(f: rt.Formatter) => Run.fmt$fmt_Debug(part4, f)]; - put(out, rt.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Run.fmt$fmt_Debug(part4, f)]; + put(out, rs.fmtFormat([args6[0]])); } else { - const log: rt.Cell = new rt.Cell(0); - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): Tally.Tally => { + const log: rs.Cell = new rs.Cell(0); + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Tally.Tally => { return new Tally.Tally(_2, log); }), undefined, 8, true); if (!owned) { - c4 = new rt.Borrowed(rt.sliceRange(items.items, 0)); + c4 = new rs.Borrowed(rs.sliceRange(items.items, 0)); } else { - c4 = rt.vecFrom(items.items.map(Tally.clone$Clone)); - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const copy: rt.Cow = rt.cowClone(c4, Tally.clone$Clone); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - rt.cowDrop(copy); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const _490: rt.Place> = rt.place(() => c4, (value) => c4 = value); - if (_490.v instanceof rt.Borrowed) { - const _493: Tally.Tally[] = rt.sliceRange(items.items, rt.min(items.items.length, 1)); - (_490.v as rt.Borrowed).slice = _493; - } - rt.byteVecPush(out, rt.cowSlice(c4).length & 0xff); - const _506: rt.Place> = rt.place(() => c4, (value2) => c4 = value2); - const owned2 = rt.cowIntoOwned(_506.v, Tally.clone$Clone); + c4 = rs.vecFrom(items.items.map(Tally.clone$Clone)); + } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const copy: rs.Cow = rs.cowClone(c4, Tally.clone$Clone); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + rs.cowDrop(copy); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const _490: rs.Place> = rs.place(() => c4, (value) => c4 = value); + if (_490.v instanceof rs.Borrowed) { + const _493: Tally.Tally[] = rs.sliceRange(items.items, rs.min(items.items.length, 1)); + (_490.v as rs.Borrowed).slice = _493; + } + rs.byteVecPush(out, rs.cowSlice(c4).length & 0xff); + const _506: rs.Place> = rs.place(() => c4, (value2) => c4 = value2); + const owned2 = rs.cowIntoOwned(_506.v, Tally.clone$Clone); _506.v = owned2; - rt.drop(rt.vecPop(owned2)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const _515: rt.Place> = rt.place(() => c4, (value3) => c4 = value3); - const owned3 = rt.cowIntoOwned(_515.v, Tally.clone$Clone); + rs.drop(rs.vecPop(owned2)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const _515: rs.Place> = rs.place(() => c4, (value3) => c4 = value3); + const owned3 = rs.cowIntoOwned(_515.v, Tally.clone$Clone); _515.v = owned3; owned3.items.push(new Tally.Tally(9, log)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const _524: rt.Place> = rt.place(() => c4, (value4) => c4 = value4); - if (!(_524.v instanceof rt.Borrowed)) { - const _527: rt.Vec = rt.vecFrom([new Tally.Tally(7, log), new Tally.Tally(8, log)]); - rt.dropVec(_524.v as rt.Vec); - (_524.v as rt.Vec) = _527; - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const kept3: rt.Vec = rt.cowIntoOwned(c4, Tally.clone$Clone); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(kept3.items), (t: Tally.Tally): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const _524: rs.Place> = rs.place(() => c4, (value4) => c4 = value4); + if (!(_524.v instanceof rs.Borrowed)) { + const _527: rs.Vec = rs.vecFrom([new Tally.Tally(7, log), new Tally.Tally(8, log)]); + rs.dropVec(_524.v as rs.Vec); + (_524.v as rs.Vec) = _527; + } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const kept3: rs.Vec = rs.cowIntoOwned(c4, Tally.clone$Clone); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(kept3.items), (t: Tally.Tally): rs.u8 => { return t._0; }), undefined, true); - rt.dropVec(kept3); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const cloned: rt.Vec = rt.cowIntoOwned(new rt.Borrowed(rt.sliceRange(items.items, 0)), Tally.clone$Clone); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - rt.dropVec(cloned); - rt.dropVec(items); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(log.v))); + rs.dropVec(kept3); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const cloned: rs.Vec = rs.cowIntoOwned(new rs.Borrowed(rs.sliceRange(items.items, 0)), Tally.clone$Clone); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + rs.dropVec(cloned); + rs.dropVec(items); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(log.v))); } } /** Point `s` at `to`, through the `&mut` a caller passes. */ -export function repoint$u16(s: rt.Place, to: rt.u16[]): void { +export function repoint$u16(s: rs.Place, to: rs.u16[]): void { s.v = to; } /** Point `s` at `to`, through the `&mut` a caller passes. */ -export function repoint$u8(s: rt.Place, to: rt.ByteSlice): void { +export function repoint$u8(s: rs.Place, to: rs.ByteSlice): void { s.v = to; } -export function made(s: rt.ByteSlice, owned: boolean): rt.ByteCow { +export function made(s: rs.ByteSlice, owned: boolean): rs.ByteCow { if (!owned) { return s; } - return rt.byteSliceToByteVec(s); + return rs.byteSliceToByteVec(s); } /** @@ -714,94 +714,94 @@ export function made(s: rt.ByteSlice, owned: boolean): rt.ByteCow { * touching what it borrowed, compared against each form of bytes, hashed, printed, and * matched on. */ -export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _85!: boolean; const owned: boolean = (kind & 128) !== 0; - const half: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeDiv(data.length, 2)); - let c: rt.ByteCow = made(data, owned); - rt.byteVecPush(out, rt.byteCowSlice(c).length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(rt.byteCowSlice(c), 0, rt.min(rt.byteCowSlice(c).length, 3))); - const _35: rt.ByteCow = made(half, !owned); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rt.byteCowSlice(c)), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rt.byteCowSlice(_35)), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1]])); - const _47: rt.ByteCow = made(half, !owned); - const _44: boolean = rt.eqBytes(c, _47); - const _49: boolean = rt.eqBytes(c, data); - const _55: rt.ByteVec = rt.byteSliceToByteVec(data); - const _52: boolean = rt.eqBytes(c, _55); - const _56: boolean = !rt.eqBytes(c, half); - const _59: boolean = rt.eqBytes(rt.byteCowSlice(c), rt.byteSliceFrom(Uint8Array.of(0, 0))); - const _63: boolean = rt.eqBytes(data, c); - const _66: boolean = !rt.eqBytes(rt.byteSliceToByteVec(data), c); - const _74: rt.ByteCow = made(half, owned); - const _70: boolean = rt.cmpBytes(c, _74) > 0; - const _75: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$slice_u8(data)); - const _79: boolean = rt.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$Vec_u8(rt.byteSliceToByteVec(data))); - if (c instanceof rt.ByteSlice) { + const half: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeDiv(data.length, 2)); + let c: rs.ByteCow = made(data, owned); + rs.byteVecPush(out, rs.byteCowSlice(c).length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteCowSlice(c), 0, rs.min(rs.byteCowSlice(c).length, 3))); + const _35: rs.ByteCow = made(half, !owned); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(c)), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(_35)), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1]])); + const _47: rs.ByteCow = made(half, !owned); + const _44: boolean = rs.eqBytes(c, _47); + const _49: boolean = rs.eqBytes(c, data); + const _55: rs.ByteVec = rs.byteSliceToByteVec(data); + const _52: boolean = rs.eqBytes(c, _55); + const _56: boolean = !rs.eqBytes(c, half); + const _59: boolean = rs.eqBytes(rs.byteCowSlice(c), rs.byteSliceFrom(Uint8Array.of(0, 0))); + const _63: boolean = rs.eqBytes(data, c); + const _66: boolean = !rs.eqBytes(rs.byteSliceToByteVec(data), c); + const _74: rs.ByteCow = made(half, owned); + const _70: boolean = rs.cmpBytes(c, _74) > 0; + const _75: boolean = rs.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$slice_u8(data)); + const _79: boolean = rs.u64Eq(hashed$borrow_Cow_slice_u8(c), hashed$Vec_u8(rs.byteSliceToByteVec(data))); + if (c instanceof rs.ByteSlice) { _85 = true; } else { _85 = false; } - const iter: rt.Iter = rt.iterSlice([_44, _49, _52, _56, _59, _63, _66, _70, _75, _79, _85]); + const iter: rs.Iter = rs.iterSlice([_44, _49, _52, _56, _59, _63, _66, _70, _75, _79, _85]); while (true) { - const _89: boolean | rt.Done = iter.next(); - if (_89 === rt.DONE) { + const _89: boolean | rs.Done = iter.next(); + if (_89 === rs.DONE) { break; } - rt.byteVecPush(out, _89 ? 1 : 0); + rs.byteVecPush(out, _89 ? 1 : 0); } if ((kind & 64) !== 0) { - const kept: rt.ByteCow = rt.byteCowClone(c); - if (c instanceof rt.ByteSlice) { - (c as rt.ByteSlice) = half; + const kept: rs.ByteCow = rs.byteCowClone(c); + if (c instanceof rs.ByteSlice) { + (c as rs.ByteSlice) = half; } else { - const _103: rt.ByteVec = rt.byteSliceToByteVec(half); - (c as rt.ByteVec) = _103; + const _103: rs.ByteVec = rs.byteSliceToByteVec(half); + (c as rs.ByteVec) = _103; } - rt.byteVecExtendFromSlice(out, rt.byteCowSlice(kept)); - let e: rt.ByteCow = made(data, !owned); - if (e instanceof rt.ByteSlice) { - repoint$u8(rt.place(() => (e as rt.ByteSlice) as rt.ByteSlice, (value) => (e as rt.ByteSlice) = value), half); + rs.byteVecExtendFromSlice(out, rs.byteCowSlice(kept)); + let e: rs.ByteCow = made(data, !owned); + if (e instanceof rs.ByteSlice) { + repoint$u8(rs.place(() => (e as rs.ByteSlice) as rs.ByteSlice, (value) => (e as rs.ByteSlice) = value), half); } else { - rt.byteVecTruncate(e as rt.ByteVec, 1); + rs.byteVecTruncate(e as rs.ByteVec, 1); } - rt.byteVecExtendFromSlice(out, rt.byteCowSlice(e)); + rs.byteVecExtendFromSlice(out, rs.byteCowSlice(e)); } - const _118: rt.u8 = rt.u8Rem(kind, 3); + const _118: rs.u8 = rs.u8Rem(kind, 3); if (_118 === 0) { - const owned3 = rt.byteCowIntoOwned(c); + const owned3 = rs.byteCowIntoOwned(c); c = owned3; - rt.byteVecPush(owned3, kind); - const owned4 = rt.byteCowIntoOwned(c); + rs.byteVecPush(owned3, kind); + const owned4 = rs.byteCowIntoOwned(c); c = owned4; - rt.byteVecExtendFromSlice(owned4, half); - rt.byteVecExtendFromSlice(out, rt.byteCowSlice(c)); + rs.byteVecExtendFromSlice(owned4, half); + rs.byteVecExtendFromSlice(out, rs.byteCowSlice(c)); } else if (_118 === 1) { - const owned2 = rt.byteCowIntoOwned(c); + const owned2 = rs.byteCowIntoOwned(c); c = owned2; - const _129: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteVecSlice(owned2))); + const _129: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteVecSlice(owned2))); if (_129 !== undefined) { - _129.v = rt.u8WrappingAdd(_129.v, 1); + _129.v = rs.u8WrappingAdd(_129.v, 1); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteCowIntoOwned(c))); - } else if (c instanceof rt.ByteSlice) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSlice(rt.byteSliceView(c as rt.ByteSlice))), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteCowIntoOwned(c))); + } else if (c instanceof rs.ByteSlice) { + rs.iterExtendBytes(out, rs.iterRev(rs.iterSlice(rs.byteSliceView(c as rs.ByteSlice))), undefined, true); } else { - const v2: rt.ByteVec = c as rt.ByteVec; - rt.byteSliceView(rt.byteVecSlice(v2)).reverse(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); + const v2: rs.ByteVec = c as rs.ByteVec; + rs.byteSliceView(rs.byteVecSlice(v2)).reverse(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v2)); } - rt.byteVecExtendFromSlice(out, data); - rt.byteVecPush(out, rt.byteCowSlice(new rt.ByteVec()).length & 0xff); - const iter2: rt.Iter = rt.iterSlice([rt.byteVecSlice(rt.byteSliceToByteVec(data)), rt.byteSliceFrom(Uint8Array.of(7, 8)), rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): rt.u8 => { + rs.byteVecExtendFromSlice(out, data); + rs.byteVecPush(out, rs.byteCowSlice(new rs.ByteVec()).length & 0xff); + const iter2: rs.Iter = rs.iterSlice([rs.byteVecSlice(rs.byteSliceToByteVec(data)), rs.byteSliceFrom(Uint8Array.of(7, 8)), rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.u8 => { return b ^ 1; }), undefined, true)]); while (true) { - const _174: rt.ByteCow | rt.Done = iter2.next(); - if (_174 === rt.DONE) { + const _174: rs.ByteCow | rs.Done = iter2.next(); + if (_174 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteCowSlice(_174)); + rs.byteVecExtendFromSlice(out, rs.byteCowSlice(_174)); } } @@ -811,138 +811,138 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * the source's length, each item it keeps cloned over; any other is the source's clone, * made before what it replaces drops. */ -export function cloneFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let c!: rt.Cow; - let from!: rt.Cow; +export function cloneFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let c!: rs.Cow; + let from!: rs.Cow; let _60!: boolean; - let c2!: rt.Cow; - let c3!: rt.ByteCow; - let c4!: rt.Cow; - let _157!: rt.Cow; - const _32: (a0: Tally.Tally[]) => rt.ByteVec = (items: Tally.Tally[]): rt.ByteVec => { - return rt.iterToByteVec(rt.iterMap(rt.iterSlice(items), (t: Tally.Tally): rt.u8 => { + let c2!: rs.Cow; + let c3!: rs.ByteCow; + let c4!: rs.Cow; + let _157!: rs.Cow; + const _32: (a0: Tally.Tally[]) => rs.ByteVec = (items: Tally.Tally[]): rs.ByteVec => { + return rs.iterToByteVec(rs.iterMap(rs.iterSlice(items), (t: Tally.Tally): rs.u8 => { return t._0; }), undefined, true); }; const _6: [boolean, boolean] = [(kind & 1) !== 0, (kind & 2) !== 0]; const intoOwned: boolean = _6[0]; const fromOwned: boolean = _6[1]; - const mid2: number = rt.usizeDiv(data.length, 2); + const mid2: number = rs.usizeDiv(data.length, 2); if (mid2 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const left: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid2); - const right: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2); - const _17: rt.u8 = rt.u8Rem(rt.u8Div(kind, 4), 4); + const left: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid2); + const right: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid2, data.length - mid2); + const _17: rs.u8 = rs.u8Rem(rs.u8Div(kind, 4), 4); if (_17 === 0) { - const log: rt.Cell = new rt.Cell(0); - const first: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_26: rt.u8): Tally.Tally => { + const log: rs.Cell = new rs.Cell(0); + const first: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_26: rs.u8): Tally.Tally => { return new Tally.Tally(_26, log); }), undefined, 8, true); - const second: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_27: rt.u8): Tally.Tally => { + const second: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_27: rs.u8): Tally.Tally => { return new Tally.Tally(_27, log); }), undefined, 8, true); if (!intoOwned) { - c = new rt.Borrowed(rt.sliceRange(first.items, 0)); + c = new rs.Borrowed(rs.sliceRange(first.items, 0)); } else { - c = rt.vecFrom(first.items.map(Tally.clone$Clone)); + c = rs.vecFrom(first.items.map(Tally.clone$Clone)); } if (!fromOwned) { - from = new rt.Borrowed(rt.sliceRange(second.items, 0)); + from = new rs.Borrowed(rs.sliceRange(second.items, 0)); } else { - from = rt.vecFrom(second.items.map(Tally.clone$Clone)); + from = rs.vecFrom(second.items.map(Tally.clone$Clone)); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - const _50: rt.Place> = rt.place(() => c, (value4) => c = value4); - _50.v = rt.cowCloneFrom(_50.v, from, 8, Tally.clone$Clone, rt.drop); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.cellReplace(log, 0)))); - if (!(c instanceof rt.Borrowed)) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + const _50: rs.Place> = rs.place(() => c, (value4) => c = value4); + _50.v = rs.cowCloneFrom(_50.v, from, 8, Tally.clone$Clone, rs.drop); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.cellReplace(log, 0)))); + if (!(c instanceof rs.Borrowed)) { _60 = true; } else { _60 = false; } - rt.byteVecPush(out, _60 ? 1 : 0); - const part = rt.cowSlice(c); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_32(part)), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_32(first.items)), undefined, true); - rt.cowDrop(from); - rt.cowDrop(c); - rt.dropVec(second); - rt.dropVec(first); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(log.v))); + rs.byteVecPush(out, _60 ? 1 : 0); + const part = rs.cowSlice(c); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_32(part)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_32(first.items)), undefined, true); + rs.cowDrop(from); + rs.cowDrop(c); + rs.dropVec(second); + rs.dropVec(first); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(log.v))); } else if (_17 === 1) { - const words_: rt.Vec = rt.vecWithCapacity(rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 16) as rt.usize, 2); - const _89: rt.Vec = words(left); - rt.iterExtend(words_, rt.vecIntoIter(_89), undefined, 2, true); - const from2: rt.Vec = words(right); + const words_: rs.Vec = rs.vecWithCapacity(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 16) as rs.usize, 2); + const _89: rs.Vec = words(left); + rs.iterExtend(words_, rs.vecIntoIter(_89), undefined, 2, true); + const from2: rs.Vec = words(right); if (!intoOwned) { - c2 = new rt.Borrowed([7]); + c2 = new rs.Borrowed([7]); } else { c2 = words_; } - const _96: rt.Place> = rt.place(() => c2, (value) => c2 = value); - const _98: rt.Cow = cowOf(from2.items, fromOwned); - _96.v = rt.cowCloneFrom(_96.v, _98, 2); - putWords(out, rt.cowSlice(c2)); - const _104: rt.Cow = c2; - if (!(_104 instanceof rt.Borrowed)) { - rt.byteVecPush(out, rt.vecCapacity(_104 as rt.Vec, 2) & 0xff); - } - rt.byteVecPush(out, rt.vecCapacity(rt.cowIntoOwned(cowOf(from2.items, false)), 2) & 0xff); - const bytes: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceLast(data), 0), 32) as rt.usize); - rt.byteVecExtendFromSlice(bytes, right); + const _96: rs.Place> = rs.place(() => c2, (value) => c2 = value); + const _98: rs.Cow = cowOf(from2.items, fromOwned); + _96.v = rs.cowCloneFrom(_96.v, _98, 2); + putWords(out, rs.cowSlice(c2)); + const _104: rs.Cow = c2; + if (!(_104 instanceof rs.Borrowed)) { + rs.byteVecPush(out, rs.vecCapacity(_104 as rs.Vec, 2) & 0xff); + } + rs.byteVecPush(out, rs.vecCapacity(rs.cowIntoOwned(cowOf(from2.items, false)), 2) & 0xff); + const bytes: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceLast(data), 0), 32) as rs.usize); + rs.byteVecExtendFromSlice(bytes, right); if (!intoOwned) { - c3 = rt.byteSliceFrom(Uint8Array.of(120)); + c3 = rs.byteSliceFrom(Uint8Array.of(120)); } else { c3 = bytes; } - const _132: rt.Place = rt.place(() => c3, (value2) => c3 = value2); - const _134: rt.ByteCow = made(left, fromOwned); - _132.v = rt.byteCowCloneFrom(_132.v, _134); - rt.byteVecExtendFromSlice(out, rt.byteCowSlice(c3)); - const _138: rt.ByteCow = c3; - if (!(_138 instanceof rt.ByteSlice)) { - rt.byteVecPush(out, (_138 as rt.ByteVec).data.length & 0xff); + const _132: rs.Place = rs.place(() => c3, (value2) => c3 = value2); + const _134: rs.ByteCow = made(left, fromOwned); + _132.v = rs.byteCowCloneFrom(_132.v, _134); + rs.byteVecExtendFromSlice(out, rs.byteCowSlice(c3)); + const _138: rs.ByteCow = c3; + if (!(_138 instanceof rs.ByteSlice)) { + rs.byteVecPush(out, (_138 as rs.ByteVec).data.length & 0xff); } - const nested: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (_2: rt.u8): rt.ByteVec => { - return rt.byteVecWithCapacity(rt.u8Rem(_2, 8) as rt.usize); + const nested: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (_2: rs.u8): rs.ByteVec => { + return rs.byteVecWithCapacity(rs.u8Rem(_2, 8) as rs.usize); }), undefined, 12, true); - const from3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (_22: rt.u8): rt.ByteVec => { - const b2: rt.u8 = _22; - return rt.byteVecOf(b2, rt.u8Rem(b2, 3) as rt.usize); + const from3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (_22: rs.u8): rs.ByteVec => { + const b2: rs.u8 = _22; + return rs.byteVecOf(b2, rs.u8Rem(b2, 3) as rs.usize); }), undefined, 12, true); if (!intoOwned) { - const _153: rt.ByteVec[] = []; - c4 = new rt.Borrowed(_153); + const _153: rs.ByteVec[] = []; + c4 = new rs.Borrowed(_153); } else { c4 = nested; } - const _155: rt.Place> = rt.place(() => c4, (value3) => c4 = value3); + const _155: rs.Place> = rs.place(() => c4, (value3) => c4 = value3); if (!fromOwned) { - _157 = new rt.Borrowed(rt.sliceRange(from3.items, 0)); + _157 = new rs.Borrowed(rs.sliceRange(from3.items, 0)); } else { - _157 = rt.vecFrom(from3.items.map((a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + _157 = rs.vecFrom(from3.items.map((a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); })); } - _155.v = rt.cowCloneFrom(_155.v, _157, 12, (a02: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a02)); - }, undefined, rt.byteVecCloneFromFn()); - const iter: rt.Iter = rt.iterSlice(rt.cowSlice(c4)); + _155.v = rs.cowCloneFrom(_155.v, _157, 12, (a02: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a02)); + }, undefined, rs.byteVecCloneFromFn()); + const iter: rs.Iter = rs.iterSlice(rs.cowSlice(c4)); while (true) { - const _167: rt.ByteVec | rt.Done = iter.next(); - if (_167 === rt.DONE) { + const _167: rs.ByteVec | rs.Done = iter.next(); + if (_167 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_167.length & 0xff, _167.data.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_167.length & 0xff, _167.data.length & 0xff)), undefined, true); } } else { const _179: [string, string] = [text(left), text(right)]; const to: string = _179[0]; const from4: string = _179[1]; - let c5: rt.StrCow = cow(to, intoOwned); - c5 = rt.strCowClone(cow(from4, fromOwned)); - put(out, rt.strCowStr(c5)); + let c5: rs.StrCow = cow(to, intoOwned); + c5 = rs.strCowClone(cow(from4, fromOwned)); + put(out, rs.strCowStr(c5)); } } diff --git a/ts/fixtures/lang/cows/expected/harness.ts b/ts/fixtures/lang/cows/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/cows/expected/harness.ts +++ b/ts/fixtures/lang/cows/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/cows/expected/lib.ts b/ts/fixtures/lang/cows/expected/lib.ts index 1bd215fa3..e25fcc00d 100644 --- a/ts/fixtures/lang/cows/expected/lib.ts +++ b/ts/fixtures/lang/cows/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cows, variants, slices, bytes, cloneFroms } from "./cows.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["cows::cows", cows as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::slices", slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::bytes", bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::clone_froms", cloneFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["cows::variants", variants as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["cows::cows", cows as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["cows::slices", slices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["cows::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["cows::clone_froms", cloneFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["cows::variants", variants as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/cycles/expected/core/bool.ts b/ts/fixtures/lang/cycles/expected/core/bool.ts index 17d957542..05e0dcab5 100644 --- a/ts/fixtures/lang/cycles/expected/core/bool.ts +++ b/ts/fixtures/lang/cycles/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/cycles/expected/core/option.ts b/ts/fixtures/lang/cycles/expected/core/option.ts index 5b8107486..615e21112 100644 --- a/ts/fixtures/lang/cycles/expected/core/option.ts +++ b/ts/fixtures/lang/cycles/expected/core/option.ts @@ -1,58 +1,58 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Logged from "../cycles.Logged.ts"; -export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$0yvilko(self: rs.ByteSlice | undefined, default_: rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1u07cey(self: Logged.Logged | undefined, f: (a0: Logged.Logged) => rt.u8): rt.u8 | undefined { +export function map$191eeea(self: Logged.Logged | undefined, f: (a0: Logged.Logged) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$05nbzug(self: rt.usize | undefined, f: (a0: rt.usize) => rt.u8): rt.u8 | undefined { +export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$0djjvgl(self: Logged.Logged | undefined, default_: rt.u8, f: (a0: Logged.Logged) => rt.u8): rt.u8 { +export function mapOr$15g5xra(self: Logged.Logged | undefined, default_: rs.u8, f: (a0: Logged.Logged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$06gg5x7(self: [rt.usize, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.usize, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$0i0fno7(self: [rs.usize, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.usize, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/cycles/expected/cycles.Countdown.ts b/ts/fixtures/lang/cycles/expected/cycles.Countdown.ts index ae018acec..d7a5d41b9 100644 --- a/ts/fixtures/lang/cycles/expected/cycles.Countdown.ts +++ b/ts/fixtures/lang/cycles/expected/cycles.Countdown.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Countdown): Countdown { return { _0: self._0 }; @@ -8,16 +8,16 @@ export function clone$Clone(self: Countdown): Countdown { /** The crate's own iterator, which `cycle` clones by its `Clone`. */ export interface Countdown { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; return self._0; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=cycles.Countdown.ts.map diff --git a/ts/fixtures/lang/cycles/expected/cycles.Logged.ts b/ts/fixtures/lang/cycles/expected/cycles.Logged.ts index 8233d0ade..2437d2e44 100644 --- a/ts/fixtures/lang/cycles/expected/cycles.Logged.ts +++ b/ts/fixtures/lang/cycles/expected/cycles.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops, and as it is cloned, the id with the high bit set: its clone's * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -21,29 +21,29 @@ export class Logged { } } -export function id(self: Logged): rt.u8 { +export function id(self: Logged): rs.u8 { return self.id; } /** Logs `x`, as a closure that holds it is called. */ -export function called(self: Logged, x: rt.u8): rt.u8 { - const _6: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_6.value, 64 | (x & 63)); - rt.refMutRelease(_6); +export function called(self: Logged, x: rs.u8): rs.u8 { + const _6: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_6.value, 64 | (x & 63)); + rs.refMutRelease(_6); return x ^ self.id; } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=cycles.Logged.ts.map diff --git a/ts/fixtures/lang/cycles/expected/cycles.ts b/ts/fixtures/lang/cycles/expected/cycles.ts index 7efe684bb..2fe8bc4f7 100644 --- a/ts/fixtures/lang/cycles/expected/cycles.ts +++ b/ts/fixtures/lang/cycles/expected/cycles.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1u07cey as option_map$1u07cey, map$05nbzug as option_map$05nbzug, mapOr$0djjvgl as option_mapOr$0djjvgl, mapOr$1surhce as option_mapOr$1surhce, mapOr$06gg5x7 as option_mapOr$06gg5x7, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$191eeea as option_map$191eeea, map$14ju55r as option_map$14ju55r, mapOr$15g5xra as option_mapOr$15g5xra, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import * as Countdown from "./cycles.Countdown.ts"; import * as Logged from "./cycles.Logged.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } /** @@ -19,46 +19,46 @@ export function flush(log: rt.RefCell, out: rt.ByteVec): void { * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$cycles_Countdown_cycles_cycles_closure4(it: Countdown.Countdown, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(rt.iterFrom(it, Countdown.next$iter_Iterator), { v: Countdown.clone$Clone }); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$cycles_Countdown_cycles_cycles_closure4(it: Countdown.Countdown, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(rs.iterFrom(it, Countdown.next$iter_Iterator), { v: Countdown.clone$Clone }); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -67,46 +67,46 @@ export function read$cycles_Countdown_cycles_cycles_closure4(it: Countdown.Count * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -115,46 +115,46 @@ export function read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_c * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -163,50 +163,50 @@ export function read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(it: rt.Iter, steps: rt.ByteSlice, put: (a0: Logged.Logged) => rt.u8, out: rt.ByteVec): void { +export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(it: rs.Iter, steps: rs.ByteSlice, put: (a0: Logged.Logged) => rs.u8, out: rs.ByteVec): void { let item!: Logged.Logged | undefined; - const it2: rt.Iter = rt.iterCycle(it, { i: { v: Logged.clone$Clone } }); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { + const it2: rs.Iter = rs.iterCycle(it, { i: { v: Logged.clone$Clone } }); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; const nth: (a0: Logged.Logged) => boolean = (_2: Logged.Logged): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n, rt.drop); + item = rs.iterNth(it2, n, rs.drop); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: Logged.Logged): boolean => { + item = rs.iterFind(it2, (item3: Logged.Logged): boolean => { return nth(item3); - }, rt.drop); + }, rs.drop); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: Logged.Logged): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: Logged.Logged): boolean => { const _02: boolean = nth(item2); item2[Symbol.dispose](); return _02; - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$0djjvgl(item, 238, put)); + rs.byteVecPush(out, option_mapOr$15g5xra(item, 238, put)); } - rt.drop(it2); + rs.drop(it2); } /** @@ -214,46 +214,46 @@ export function read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6 * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Empty_u8_cycles_cycles_closure3(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -262,46 +262,46 @@ export function read$iter_Empty_u8_cycles_cycles_closure3(it: rt.Iter, st * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt.Iter<[rt.usize, rt.u8]>, steps: rt.ByteSlice, put: (a0: [rt.usize, rt.u8]) => rt.u8, out: rt.ByteVec): void { - let item!: [rt.usize, rt.u8] | undefined; - const it2: rt.Iter<[rt.usize, rt.u8]> = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rs.Iter<[rs.usize, rs.u8]>, steps: rs.ByteSlice, put: (a0: [rs.usize, rs.u8]) => rs.u8, out: rs.ByteVec): void { + let item!: [rs.usize, rs.u8] | undefined; + const it2: rs.Iter<[rs.usize, rs.u8]> = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: [rt.usize, rt.u8]) => boolean = (_2: [rt.usize, rt.u8]): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: [rs.usize, rs.u8]) => boolean = (_2: [rs.usize, rs.u8]): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: [rt.usize, rt.u8]): boolean => { + item = rs.iterFind(it2, (item3: [rs.usize, rs.u8]): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: [rt.usize, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: [rs.usize, rs.u8]): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$06gg5x7(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0i0fno7(item, 238, put)); } } @@ -310,48 +310,48 @@ export function read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(it: rt. * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it, { i: { f: rt.closureClone }, f: rt.closureClone }); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it, { i: { f: rs.closureClone }, f: rs.closureClone }); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } - rt.drop(it2); + rs.drop(it2); } /** @@ -359,46 +359,46 @@ export function read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closure * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -407,46 +407,46 @@ export function read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cyc * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -455,46 +455,46 @@ export function read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(it: rt. * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.Peekable, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rs.Peekable, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -503,46 +503,46 @@ export function read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(it: rt.P * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -551,46 +551,46 @@ export function read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -599,46 +599,46 @@ export function read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(it: rt.Ite * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -647,46 +647,46 @@ export function read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter< * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeInclusive, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rs.RangeInclusive, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -695,46 +695,46 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure6(it: rt.RangeIn * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeInclusive, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rs.RangeInclusive, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -743,46 +743,46 @@ export function read$ops_RangeInclusive_u8_cycles_cycles_closure7(it: rt.RangeIn * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$ops_Range_u8_cycles_cycles_closure5(it: rs.Range, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -791,46 +791,46 @@ export function read$ops_Range_u8_cycles_cycles_closure5(it: rt.Range, st * or `find` or `position` of the item a count picks, each item as `put` makes it, or * 0xee for none. */ -export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -839,46 +839,46 @@ export function read$option_IntoIter_u8_cycles_cycles_closure2(it: rt.Iter, steps: rt.ByteSlice, put: (a0: rt.u8) => rt.u8, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const it2: rt.Iter = rt.iterCycle(it); - const _8: [rt.usize, rt.usize | undefined] = it2.sizeHint(); - const lower: rt.usize = _8[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$02k4ito(_8[1], 254, (n2: rt.usize): rt.u8 => { +export function read$slice_Iter_u8_cycles_cycles_closure1(it: rs.Iter, steps: rs.ByteSlice, put: (a0: rs.u8) => rs.u8, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const it2: rs.Iter = rs.iterCycle(it); + const _8: [rs.usize, rs.usize | undefined] = it2.sizeHint(); + const lower: rs.usize = _8[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(lower & 0xff, (lower >>> 24) & 0xff, option_mapOr$188iunt(_8[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 12); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 12); while (true) { - const _22: rt.u8 | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: rs.u8 | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const step: rt.u8 = _22; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 9); - let left: rt.usize = n; - const nth: (a0: rt.u8) => boolean = (_2: rt.u8): boolean => { + const step: rs.u8 = _22; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 9); + let left: rs.usize = n; + const nth: (a0: rs.u8) => boolean = (_2: rs.u8): boolean => { const hit: boolean = left === 0; - left = rt.usizeWrappingSub(left, 1); + left = rs.usizeWrappingSub(left, 1); return hit; }; - const _36: rt.u8 = step & 3; + const _36: rs.u8 = step & 3; if (_36 === 0) { - item = rt.iterToOption(it2.next()); + item = rs.iterToOption(it2.next()); } else if (_36 === 1) { - item = rt.iterNth(it2, n); + item = rs.iterNth(it2, n); } else if (_36 === 2) { - item = rt.iterFind(it2, (item3: rt.u8): boolean => { + item = rs.iterFind(it2, (item3: rs.u8): boolean => { return nth(item3); }); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(it2, (item2: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(it2, (item2: rs.u8): boolean => { return nth(item2); - }), 238, (i: rt.usize): rt.u8 => { + }), 238, (i: rs.usize): rs.u8 => { return i & 0xff; })); continue; } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, put)); + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, put)); } } @@ -886,168 +886,168 @@ export function read$slice_Iter_u8_cycles_cycles_closure1(it: rt.Iter, st * `cycle` of std's iterators and adaptors and of the crate's own, each partly read, * empty, or both, the first byte of `data` a count and the rest the steps `read` takes. */ -export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - const n: rt.usize = option_mapOr$1surhce(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.u8 => { - return rt.u8Rem(_2, 5); - }) as rt.usize; - const steps: rt.ByteSlice = option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 1), rt.byteSliceFrom(Uint8Array.of())); - const _12: rt.u8 = rt.u8Rem(kind, 6); +export function cycles(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + const n: rs.usize = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.u8 => { + return rs.u8Rem(_2, 5); + }) as rs.usize; + const steps: rs.ByteSlice = option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 1), rs.byteSliceFrom(Uint8Array.of())); + const _12: rs.u8 = rs.u8Rem(kind, 6); if (_12 === 0) { - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.iterNth(it, n); - read$slice_Iter_u8_cycles_cycles_closure1(it, steps, (x18: rt.u8): rt.u8 => { + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.iterNth(it, n); + read$slice_Iter_u8_cycles_cycles_closure1(it, steps, (x18: rs.u8): rs.u8 => { return x18; }, out); - const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.iterForEach(rt.iterBorrow(it2), (_a03: rt.u8): undefined => { + const it2: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.iterForEach(rs.iterBorrow(it2), (_a03: rs.u8): undefined => { undefined; }); - read$slice_Iter_u8_cycles_cycles_closure1(it2, steps, (x19: rt.u8): rt.u8 => { + read$slice_Iter_u8_cycles_cycles_closure1(it2, steps, (x19: rs.u8): rs.u8 => { return x19; }, out); - read$slice_Iter_u8_cycles_cycles_closure1(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0))), steps, (x20: rt.u8): rt.u8 => { + read$slice_Iter_u8_cycles_cycles_closure1(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0))), steps, (x20: rs.u8): rs.u8 => { return x20; }, out); - read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), n), steps, (x21: rt.u8): rt.u8 => { + read$iter_Take_slice_Iter_u8_cycles_cycles_closure1(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), n), steps, (x21: rs.u8): rs.u8 => { return x21; }, out); - read$option_IntoIter_u8_cycles_cycles_closure2(rt.iterOption(n & 0xff), steps, (x22: rt.u8): rt.u8 => { + read$option_IntoIter_u8_cycles_cycles_closure2(rs.iterOption(n & 0xff), steps, (x22: rs.u8): rs.u8 => { return x22; }, out); - rt.iterEmpty(); - read$iter_Empty_u8_cycles_cycles_closure3(rt.iterEmpty() as rt.Iter, steps, (x23: rt.u8): rt.u8 => { + rs.iterEmpty(); + read$iter_Empty_u8_cycles_cycles_closure3(rs.iterEmpty() as rs.Iter, steps, (x23: rs.u8): rs.u8 => { return x23; }, out); - read$cycles_Countdown_cycles_cycles_closure4({ _0: rt.u8Mul(n & 0xff, 2) }, steps, (x24: rt.u8): rt.u8 => { + read$cycles_Countdown_cycles_cycles_closure4({ _0: rs.u8Mul(n & 0xff, 2) }, steps, (x24: rs.u8): rs.u8 => { return x24; }, out); } else if (_12 === 1) { - const lo: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8); - const hi: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 9), 12); - read$ops_Range_u8_cycles_cycles_closure5(new rt.Range(lo, hi), steps, (x8: rt.u8): rt.u8 => { + const lo: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8); + const hi: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 9), 12); + read$ops_Range_u8_cycles_cycles_closure5(new rs.Range(lo, hi), steps, (x8: rs.u8): rs.u8 => { return x8; }, out); - const range: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u8Step); + const range: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u8Step); range.next(); - read$ops_RangeInclusive_u8_cycles_cycles_closure6(range.clone(), steps, (x9: rt.u8): rt.u8 => { + read$ops_RangeInclusive_u8_cycles_cycles_closure6(range.clone(), steps, (x9: rs.u8): rs.u8 => { return x9; }, out); - rt.iterForEach(rt.iterBorrow(range), (_a02: rt.u8): undefined => { + rs.iterForEach(rs.iterBorrow(range), (_a02: rs.u8): undefined => { undefined; }); - read$ops_RangeInclusive_u8_cycles_cycles_closure7(range, steps, (x10: rt.u8): rt.u8 => { + read$ops_RangeInclusive_u8_cycles_cycles_closure7(range, steps, (x10: rs.u8): rs.u8 => { return x10; }, out); - read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): boolean => { - return rt.u8Rem(_25, 3) !== 0; - }), steps, (x12: rt.u8): rt.u8 => { + read$iter_Filter_slice_Iter_u8_cycles_cycles_closure8_cycles_cycles_closure1(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): boolean => { + return rs.u8Rem(_25, 3) !== 0; + }), steps, (x12: rs.u8): rs.u8 => { return x12; }, out); - read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterTake(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), 2)), steps, (x13: rt.u8): rt.u8 => { + read$iter_Chain_slice_Iter_u8_iter_Take_iter_Rev_slice_Iter_u8_cycles_cycles_closure1(rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterTake(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), 2)), steps, (x13: rs.u8): rs.u8 => { return x13; }, out); - read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(data)), rt.usizeAdd(n, 1)), steps, (x14: rt.u8): rt.u8 => { + read$iter_StepBy_slice_Iter_u8_cycles_cycles_closure1(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(data)), rs.usizeAdd(n, 1)), steps, (x14: rs.u8): rs.u8 => { return x14; }, out); - read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), n), steps, (x15: rt.u8): rt.u8 => { + read$iter_Skip_slice_Iter_u8_cycles_cycles_closure1(rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), n), steps, (x15: rs.u8): rs.u8 => { return x15; }, out); - read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), steps, (_29: [rt.usize, rt.u8]): rt.u8 => { + read$iter_Enumerate_slice_Iter_u8_cycles_cycles_closure9(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), steps, (_29: [rs.usize, rs.u8]): rs.u8 => { return (_29[0] & 0xff) ^ _29[1]; }, out); - const peeked: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); - rt.peekablePeek(peeked); - read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(peeked, steps, (x16: rt.u8): rt.u8 => { + const peeked: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + rs.peekablePeek(peeked); + read$iter_Peekable_slice_Iter_u8_cycles_cycles_closure1(peeked, steps, (x16: rs.u8): rs.u8 => { return x16; }, out); - read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rt.iterFlatten(rt.byteSliceChunks(data, rt.usizeAdd(n, 1)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), steps, (x17: rt.u8): rt.u8 => { + read$iter_Flatten_slice_Chunks_u8_cycles_cycles_closure1(rs.iterFlatten(rs.byteSliceChunks(data, rs.usizeAdd(n, 1)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), steps, (x17: rs.u8): rs.u8 => { return x17; }, out); } else if (_12 === 2) { - const m: rt.usize = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceLast(data), 0), 40) as rt.usize; - rt.iterExtendBytes(out, rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next"); - rt.byteVecPush(out, rt.ownedCount(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m)) & 0xff); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), 0, (a: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a, _3); + const m: rs.usize = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceLast(data), 0), 40) as rs.usize; + rs.iterExtendBytes(out, rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))), m), "next"); + rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))), m)) & 0xff); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))), m), 0, (a: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a, _3); })); - rt.iterExtendBytes(out, rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(107, 101, 121)))))), (_22: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(107, 101, 121)))))), (_22: [rs.u8, rs.u8]): rs.u8 => { return _22[0] ^ _22[1]; }), "next"); - rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(rt.iterSkip(rt.iterCycle(new rt.RangeInclusive(1, 3, rt.u8Step)), n), 2), m), "next"); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), "next")), undefined, true); - rt.byteVecPush(out, rt.iterAny(rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))), m), (_23: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterStepBy(rs.iterSkip(rs.iterCycle(new rs.RangeInclusive(1, 3, rs.u8Step)), n), 2), m), "next"); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))), m), "next")), undefined, true); + rs.byteVecPush(out, rs.iterAny(rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))), m), (_23: rs.u8): boolean => { return _23 === 7; }) ? 1 : 0); - rt.byteVecPush(out, rt.ownedCount(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0))))) & 0xff); - rt.iterExtendBytes(out, rt.iterOption(rt.iterLast(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))))), undefined, true); - rt.iterExtendBytes(out, rt.iterTake(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))), m), "next"); - const at: rt.Arc> = new rt.Arc(new rt.Cell(0)); - const make = (captured: rt.Arc>): () => rt.u8 | undefined => { - return rt.closure(rt.cloning((): rt.u8 | undefined => { - const a2: rt.u8 = captured.value.v; - rt.cellSet(captured.value, rt.u8WrappingAdd(a2, 1)); - const _1110: rt.usize = rt.u8Rem(a2, 5) as rt.usize; + rs.byteVecPush(out, rs.ownedCount(rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0))))) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(rs.iterLast(rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0)))))), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0)))), m), "next"); + const at: rs.Arc> = new rs.Arc(new rs.Cell(0)); + const make = (captured: rs.Arc>): () => rs.u8 | undefined => { + return rs.closure(rs.cloning((): rs.u8 | undefined => { + const a2: rs.u8 = captured.value.v; + rs.cellSet(captured.value, rs.u8WrappingAdd(a2, 1)); + const _1110: rs.usize = rs.u8Rem(a2, 5) as rs.usize; if (!(_1110 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _1110); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _1110); } - return thenSome$0d5am30([true, false, true, false, false][_1110], a2); - }, () => make(((a0: rt.Arc>): rt.Arc> => { - return rt.arcClone(a0); + return thenSome$0quywni([true, false, true, false, false][_1110], a2); + }, () => make(((a0: rs.Arc>): rs.Arc> => { + return rs.arcClone(a0); })(captured))), (): void => { captured[Symbol.dispose](); }); }; - const pausing: rt.Iter = rt.iterFromFn(make(at)); - rt.byteVecPush(out, rt.ownedCount(rt.iterTake(rt.iterCycle(pausing.clone({ v: rt.closureClone }), { v: rt.closureClone }), m)) & 0xff); - const it3: rt.Iter = rt.iterCycle(pausing.clone({ v: rt.closureClone }), { v: rt.closureClone }); - const _180: rt.usize = rt.usizeRem(m, 9); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _180; + const pausing: rs.Iter = rs.iterFromFn(make(at)); + rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterCycle(pausing.clone({ v: rs.closureClone }), { v: rs.closureClone }), m)) & 0xff); + const it3: rs.Iter = rs.iterCycle(pausing.clone({ v: rs.closureClone }), { v: rs.closureClone }); + const _180: rs.usize = rs.usizeRem(m, 9); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _180; while (iterStart++ < iterEnd) { - rt.byteVecPush(out, option_mapOr$1surhce(rt.iterToOption(it3.next()), 238, (x6: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(rs.iterToOption(it3.next()), 238, (x6: rs.u8): rs.u8 => { return x6; })); } - rt.byteVecPush(out, rt.ownedCount(rt.iterTake(rt.iterBorrow(it3), m)) & 0xff); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterCycle(pausing, { v: rt.closureClone }), m), 0, (a3: rt.u8, x7: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a3, x7); + rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterBorrow(it3), m)) & 0xff); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterCycle(pausing, { v: rs.closureClone }), m), 0, (a3: rs.u8, x7: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a3, x7); }, true)); - rt.drop(it3); + rs.drop(it3); } else if (_12 === 3) { closures(data, steps, out); } else if (_12 === 4) { owned(data, n, steps, out); } else { - const it4: rt.Iter = rt.iterCycle(rt.iterSlice(rt.byteSliceView(data))); - rt.iterNth(it4, n); - const clone: rt.Iter = it4.clone(); - const iter2: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 16); + const it4: rs.Iter = rs.iterCycle(rs.iterSlice(rs.byteSliceView(data))); + rs.iterNth(it4, n); + const clone: rs.Iter = it4.clone(); + const iter2: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 16); while (true) { - const _210: rt.u8 | rt.Done = iter2.next(); - if (_210 === rt.DONE) { + const _210: rs.u8 | rs.Done = iter2.next(); + if (_210 === rs.DONE) { break; } - const step: rt.u8 = _210; - const _215: rt.u8 = step & 3; + const step: rs.u8 = _210; + const _215: rs.u8 = step & 3; if (_215 === 0) { - item = rt.iterToOption(it4.next()); + item = rs.iterToOption(it4.next()); } else if (_215 === 1) { - item = rt.iterToOption(clone.next()); + item = rs.iterToOption(clone.next()); } else if (_215 === 2) { - item = rt.iterNth(it4, rt.usizeRem(step >> 2 as rt.usize, 9)); + item = rs.iterNth(it4, rs.usizeRem(step >> 2 as rs.usize, 9)); } else { - item = rt.iterNth(clone, rt.usizeRem(step >> 2 as rt.usize, 9)); + item = rs.iterNth(clone, rs.usizeRem(step >> 2 as rs.usize, 9)); } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, (x: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, (x: rs.u8): rs.u8 => { return x; })); } - rt.byteVecPush(out, rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))).clone().sizeHint()[0] & 0xff); - read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it4.clone(), steps, (x2: rt.u8): rt.u8 => { + rs.byteVecPush(out, rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0)))).clone().sizeHint()[0] & 0xff); + read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(it4.clone(), steps, (x2: rs.u8): rs.u8 => { return x2; }, out); - read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(rt.iterCycle(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, 0)))), steps, (x3: rt.u8): rt.u8 => { + read$iter_Cycle_slice_Iter_u8_cycles_cycles_closure1(rs.iterCycle(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, 0)))), steps, (x3: rs.u8): rs.u8 => { return x3; }, out); } @@ -1057,103 +1057,103 @@ export function cycles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Adaptors whose closures log as they are called and hold a value that logs as it is * cloned and dropped: when each clone of them is made, and when each drops. */ -export function closures(data: rt.ByteSlice, steps: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function closures(data: rs.ByteSlice, steps: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; const tag: Logged.Logged = logged(16); - const _13: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); - const make = (captured: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((_2: rt.u8): rt.u8 => { + const _13: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3); + const make = (captured: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((_2: rs.u8): rs.u8 => { return Logged.called(captured, _2); }, () => make(Logged.clone$Clone(captured))), (): void => { captured[Symbol.dispose](); }); }; - const it: rt.Iter = rt.iterMap(_13, make(tag)); + const it: rs.Iter = rs.iterMap(_13, make(tag)); it.next(); - const it2: rt.Iter = rt.iterCycle(it, { f: rt.closureClone }); + const it2: rs.Iter = rs.iterCycle(it, { f: rs.closureClone }); flush(log.value, out); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 7; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 7; while (iterStart++ < iterEnd) { - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it2.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); } flush(log.value, out); - let left: rt.usize = rt.usizeRem(data.length, 5); - rt.iterExtendBytes(out, rt.iterOption(rt.iterFind(it2, (_22: rt.u8): boolean => { - left = rt.usizeWrappingSub(left, 1); + let left: rs.usize = rs.usizeRem(data.length, 5); + rs.iterExtendBytes(out, rs.iterOption(rs.iterFind(it2, (_22: rs.u8): boolean => { + left = rs.usizeWrappingSub(left, 1); return left === 4294967295; })), undefined, true); flush(log.value, out); - let left2: rt.usize = rt.usizeRem(data.length, 7); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.iterPosition(it2, (_25: rt.u8): boolean => { - left2 = rt.usizeWrappingSub(left2, 1); + let left2: rs.usize = rs.usizeRem(data.length, 7); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.iterPosition(it2, (_25: rs.u8): boolean => { + left2 = rs.usizeWrappingSub(left2, 1); return left2 === 4294967295; - }), (i: rt.usize): rt.u8 => { + }), (i: rs.usize): rs.u8 => { return i & 0xff; })), undefined, true); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(it2, 5)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(it2, 5)), undefined, true); flush(log.value, out); - rt.drop(it2); + rs.drop(it2); flush(log.value, out); - const _71: [Logged.Logged, rt.u8] = [logged(32), 0]; + const _71: [Logged.Logged, rs.u8] = [logged(32), 0]; const tag2: Logged.Logged = _71[0]; - const count: rt.u8 = 0; - const _76: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4); - const make2 = (captured2: rt.u8, captured3: Logged.Logged): (a0: rt.u8) => rt.u8 => { - return rt.closure(rt.cloning((_27: rt.u8): rt.u8 => { - const x2: rt.u8 = _27; - captured2 = rt.u8WrappingAdd(captured2, 1); + const count: rs.u8 = 0; + const _76: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4); + const make2 = (captured2: rs.u8, captured3: Logged.Logged): (a0: rs.u8) => rs.u8 => { + return rs.closure(rs.cloning((_27: rs.u8): rs.u8 => { + const x2: rs.u8 = _27; + captured2 = rs.u8WrappingAdd(captured2, 1); return Logged.called(captured3, x2) ^ captured2; }, () => make2(captured2, Logged.clone$Clone(captured3))), (): void => { captured3[Symbol.dispose](); }); }; - const it3: rt.Iter = rt.iterMap(_76, make2(count, tag2)); + const it3: rs.Iter = rs.iterMap(_76, make2(count, tag2)); const gate: Logged.Logged = logged(48); - const make3 = (captured4: Logged.Logged): (a0: rt.u8) => boolean => { - return rt.closure(rt.cloning((_28: rt.u8): boolean => { + const make3 = (captured4: Logged.Logged): (a0: rs.u8) => boolean => { + return rs.closure(rs.cloning((_28: rs.u8): boolean => { return (Logged.called(captured4, _28) & 3) !== 0; }, () => make3(Logged.clone$Clone(captured4))), (): void => { captured4[Symbol.dispose](); }); }; - read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(rt.iterFilter(it3, make3(gate)), steps, (x4: rt.u8): rt.u8 => { + read$iter_Filter_iter_Map_iter_Take_slice_Iter_u8_cycles_closures_closure5_cycles_closures_closure6_cycles_closures_closure7(rs.iterFilter(it3, make3(gate)), steps, (x4: rs.u8): rs.u8 => { return x4; }, out); flush(log.value, out); - const left3: rt.Arc> = new rt.Arc(new rt.Cell(rt.usizeRem(data.length, 4))); + const left3: rs.Arc> = new rs.Arc(new rs.Cell(rs.usizeRem(data.length, 4))); const tag3: Logged.Logged = logged(56); - const make4 = (captured5: rt.Arc>, captured6: Logged.Logged): () => rt.u8 | undefined => { - return rt.closure(rt.cloning((): rt.u8 | undefined => { - const _29: rt.usize | undefined = rt.usizeCheckedSub(captured5.value.v, 1); + const make4 = (captured5: rs.Arc>, captured6: Logged.Logged): () => rs.u8 | undefined => { + return rs.closure(rs.cloning((): rs.u8 | undefined => { + const _29: rs.usize | undefined = rs.usizeCheckedSub(captured5.value.v, 1); if (_29 !== undefined) { - const l: rt.usize = _29; - rt.cellSet(captured5.value, l); + const l: rs.usize = _29; + rs.cellSet(captured5.value, l); return Logged.called(captured6, l & 0xff); } return undefined; - }, () => make4(((a0: rt.Arc>): rt.Arc> => { - return rt.arcClone(a0); + }, () => make4(((a0: rs.Arc>): rs.Arc> => { + return rs.arcClone(a0); })(captured5), Logged.clone$Clone(captured6))), (): void => { captured5[Symbol.dispose](); captured6[Symbol.dispose](); }); }; - const it6: rt.Iter = rt.iterCycle(rt.iterFromFn(make4(left3, tag3)), { v: rt.closureClone }); + const it6: rs.Iter = rs.iterCycle(rs.iterFromFn(make4(left3, tag3)), { v: rs.closureClone }); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it6.next())), undefined, true); - rt.byteVecPush(out, rt.iterPosition(it6, (_210: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it6.next())), undefined, true); + rs.byteVecPush(out, rs.iterPosition(it6, (_210: rs.u8): boolean => { return false; }) === undefined ? 1 : 0); flush(log.value, out); - rt.byteVecPush(out, rt.iterToOption(it6.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterNth(it6, 2) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterToOption(it6.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterNth(it6, 2) === undefined ? 1 : 0); flush(log.value, out); - rt.drop(it6); + rs.drop(it6); flush(log.value, out); log[Symbol.dispose](); } @@ -1162,64 +1162,64 @@ export function closures(data: rt.ByteSlice, steps: rt.ByteSlice, out: rt.ByteVe * Iterators that own their items, each cloned as the iterator is at each wrap, and * dropped as `nth` skips them and as the cycle drops what it holds and its clone. */ -export function owned(data: rt.ByteSlice, n: rt.usize, steps: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function owned(data: rs.ByteSlice, n: rs.usize, steps: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const it: rt.Iter = rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): Logged.Logged => { + const it: rs.Iter = rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Logged.Logged => { return logged(_2 & 112); - }), undefined, 8, true), rt.drop); - rt.drop(rt.iterToOption(it.next())); + }), undefined, 8, true), rs.drop); + rs.drop(rs.iterToOption(it.next())); flush(log.value, out); - const it2: rt.Iter = rt.iterCycle(it, { v: Logged.clone$Clone }); + const it2: rs.Iter = rs.iterCycle(it, { v: Logged.clone$Clone }); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1u07cey(rt.iterNth(it2, n, rt.drop), (x: Logged.Logged): rt.u8 => { - const _03: rt.u8 = Logged.id(x); + rs.iterExtendBytes(out, rs.iterOption(option_map$191eeea(rs.iterNth(it2, n, rs.drop), (x: Logged.Logged): rs.u8 => { + const _03: rs.u8 = Logged.id(x); x[Symbol.dispose](); return _03; })), undefined, true); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1u07cey(rt.iterNth(it2, rt.usizeAdd(n, 3), rt.drop), (x2: Logged.Logged): rt.u8 => { - const _04: rt.u8 = Logged.id(x2); + rs.iterExtendBytes(out, rs.iterOption(option_map$191eeea(rs.iterNth(it2, rs.usizeAdd(n, 3), rs.drop), (x2: Logged.Logged): rs.u8 => { + const _04: rs.u8 = Logged.id(x2); x2[Symbol.dispose](); return _04; })), undefined, true); flush(log.value, out); - let left: rt.usize = rt.usizeMul(n, 2); - rt.iterExtendBytes(out, rt.iterOption(option_map$1u07cey(rt.iterFind(it2, (_22: Logged.Logged): boolean => { - left = rt.usizeWrappingSub(left, 1); + let left: rs.usize = rs.usizeMul(n, 2); + rs.iterExtendBytes(out, rs.iterOption(option_map$191eeea(rs.iterFind(it2, (_22: Logged.Logged): boolean => { + left = rs.usizeWrappingSub(left, 1); return left === 4294967295; - }, rt.drop), (x3: Logged.Logged): rt.u8 => { - const _06: rt.u8 = Logged.id(x3); + }, rs.drop), (x3: Logged.Logged): rs.u8 => { + const _06: rs.u8 = Logged.id(x3); x3[Symbol.dispose](); return _06; })), undefined, true); flush(log.value, out); - const clone: rt.Iter = it2.clone({ i: { v: Logged.clone$Clone } }); + const clone: rs.Iter = it2.clone({ i: { v: Logged.clone$Clone } }); flush(log.value, out); - rt.drop(it2); + rs.drop(it2); flush(log.value, out); - read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(clone, steps, (x4: Logged.Logged): rt.u8 => { - const _07: rt.u8 = Logged.id(x4); + read$iter_Cycle_vec_IntoIter_cycles_Logged_cycles_owned_closure6(clone, steps, (x4: Logged.Logged): rs.u8 => { + const _07: rs.u8 = Logged.id(x4); x4[Symbol.dispose](); return _07; }, out); flush(log.value, out); - const it3: rt.Iter = rt.iterCycle(rt.vecIntoIter(new rt.Vec(), rt.drop), { v: Logged.clone$Clone }); - const _75: Logged.Logged | undefined = rt.iterNth(it3, 3, rt.drop); - rt.byteVecPush(out, _75 === undefined ? 1 : 0); - rt.drop(_75); - const _81: Logged.Logged | undefined = rt.iterFind(it3, (_24: Logged.Logged): boolean => { + const it3: rs.Iter = rs.iterCycle(rs.vecIntoIter(new rs.Vec(), rs.drop), { v: Logged.clone$Clone }); + const _75: Logged.Logged | undefined = rs.iterNth(it3, 3, rs.drop); + rs.byteVecPush(out, _75 === undefined ? 1 : 0); + rs.drop(_75); + const _81: Logged.Logged | undefined = rs.iterFind(it3, (_24: Logged.Logged): boolean => { return true; - }, rt.drop); - rt.byteVecPush(out, _81 === undefined ? 1 : 0); - rt.drop(_81); - const _85: [rt.usize, rt.usize | undefined] = it3.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_85[0] & 0xff, option_mapOr$02k4ito(_85[1], 254, (n2: rt.usize): rt.u8 => { + }, rs.drop); + rs.byteVecPush(out, _81 === undefined ? 1 : 0); + rs.drop(_81); + const _85: [rs.usize, rs.usize | undefined] = it3.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_85[0] & 0xff, option_mapOr$188iunt(_85[1], 254, (n2: rs.usize): rs.u8 => { return n2 & 0xff; }))), undefined, true); - rt.drop(it3); + rs.drop(it3); log[Symbol.dispose](); } diff --git a/ts/fixtures/lang/cycles/expected/harness.ts b/ts/fixtures/lang/cycles/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/cycles/expected/harness.ts +++ b/ts/fixtures/lang/cycles/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/cycles/expected/lib.ts b/ts/fixtures/lang/cycles/expected/lib.ts index cb19a7017..2c441462c 100644 --- a/ts/fixtures/lang/cycles/expected/lib.ts +++ b/ts/fixtures/lang/cycles/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cycles } from "./cycles.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["cycles::cycles", cycles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["cycles::cycles", cycles as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/defaults/expected/core/bool.ts b/ts/fixtures/lang/defaults/expected/core/bool.ts index 088964177..4bd39446d 100644 --- a/ts/fixtures/lang/defaults/expected/core/bool.ts +++ b/ts/fixtures/lang/defaults/expected/core/bool.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Made from "../defaults.Made.ts"; export function then$1j955kq(self: boolean, _: () => Made.Made): Made.Made | undefined { @@ -10,7 +10,7 @@ export function then$1j955kq(self: boolean, _: () => Made.Made): Made.Made | und return Made.default$Default(); } -export function then$1t2ieki(self: boolean, f: () => [rt.u64 | undefined, Made.Made]): [rt.u64 | undefined, Made.Made] | undefined { +export function then$0t24p36(self: boolean, f: () => [rs.u64 | undefined, Made.Made]): [rs.u64 | undefined, Made.Made] | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/defaults/expected/core/option.ts b/ts/fixtures/lang/defaults/expected/core/option.ts index e5cf68221..f7a9db409 100644 --- a/ts/fixtures/lang/defaults/expected/core/option.ts +++ b/ts/fixtures/lang/defaults/expected/core/option.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Made from "../defaults.Made.ts"; -export function unwrapOrDefault$0k1p6nh(self: [rt.u64 | undefined, Made.Made] | undefined): [rt.u64 | undefined, Made.Made] { +export function unwrapOrDefault$0ddgm4x(self: [rs.u64 | undefined, Made.Made] | undefined): [rs.u64 | undefined, Made.Made] { if (self === undefined) { return [undefined, Made.default$Default()]; } return self; } -export function map$155qrdr(self: rt.Arc | undefined, f: (a0: rt.Arc) => rt.u64): rt.u64 | undefined { +export function map$1ubvkfe(self: rs.Arc | undefined, f: (a0: rs.Arc) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/defaults/expected/defaults.Bare.ts b/ts/fixtures/lang/defaults/expected/defaults.Bare.ts index 189ef56a6..fe9d500cd 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Bare.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Bare.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Bare, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Bare"); +export function fmt$fmt_Debug(_self: Bare, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Bare"); } /** A type without a `Default`, whose empty array still has one. */ diff --git a/ts/fixtures/lang/defaults/expected/defaults.Made.ts b/ts/fixtures/lang/defaults/expected/defaults.Made.ts index c483f6edd..d85d379b0 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Made.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Made.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Made, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Made, f: rs.Formatter): rs.Result { const _3: string = "Made"; const _4: string = "n"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u64Debug(self.n, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self.n, f); const _7: string = "tag"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(self.tag, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(self.tag, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A type of the crate's own, whose `Default` impl is no zero value. */ export interface Made { - n: rt.u64; + n: rs.u64; tag: string; } diff --git a/ts/fixtures/lang/defaults/expected/defaults.Slot.ts b/ts/fixtures/lang/defaults/expected/defaults.Slot.ts index 914911e71..61f028b61 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.Slot.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.Slot.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { map$155qrdr as option_map$155qrdr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { map$1ubvkfe as option_map$1ubvkfe } from "./core/option.ts"; import type * as Made from "./defaults.Made.ts"; export function default$Default(): Slot { - return new Slot(new rt.Weak()); + return new Slot(new rs.Weak()); } /** A placeholder that upgrades once it points at something. */ export class Slot { - weak: rt.Weak; + weak: rs.Weak; - constructor(weak: rt.Weak) { + constructor(weak: rs.Weak) { this.weak = weak; } @@ -21,9 +21,9 @@ export class Slot { } } -export function get(self: Slot): rt.u64 | undefined { - return option_map$155qrdr(rt.weakUpgrade(self.weak), (made: rt.Arc): rt.u64 => { - const _02: rt.u64 = made.value.n; +export function get(self: Slot): rs.u64 | undefined { + return option_map$1ubvkfe(rs.weakUpgrade(self.weak), (made: rs.Arc): rs.u64 => { + const _02: rs.u64 = made.value.n; made[Symbol.dispose](); return _02; }); diff --git a/ts/fixtures/lang/defaults/expected/defaults.ts b/ts/fixtures/lang/defaults/expected/defaults.ts index 72b4e6935..e84e8f09b 100644 --- a/ts/fixtures/lang/defaults/expected/defaults.ts +++ b/ts/fixtures/lang/defaults/expected/defaults.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8 } from "./lib.ts"; -import { then$1j955kq, then$1t2ieki } from "./core/bool.ts"; -import { unwrapOrDefault$0k1p6nh as option_unwrapOrDefault$0k1p6nh } from "./core/option.ts"; +import { then$1j955kq, then$0t24p36 } from "./core/bool.ts"; +import { unwrapOrDefault$0ddgm4x as option_unwrapOrDefault$0ddgm4x } from "./core/option.ts"; import * as Bare from "./defaults.Bare.ts"; import * as Made from "./defaults.Made.ts"; import * as Slot from "./defaults.Slot.ts"; @@ -21,17 +21,17 @@ export function made$defaults_Made(): Made.Made { } /** What a generic caller makes, as kio's `Producer::default` makes its `T`. */ -export function made$sync_Arc_defaults_Made(): rt.Arc { - return new rt.Arc(Made.default$Default()); +export function made$sync_Arc_defaults_Made(): rs.Arc { + return new rs.Arc(Made.default$Default()); } /** What a generic caller makes, as kio's `Producer::default` makes its `T`. */ -export function made$sync_Weak_defaults_Made(): rt.Weak { - return new rt.Weak(); +export function made$sync_Weak_defaults_Made(): rs.Weak { + return new rs.Weak(); } /** What a generic caller makes, as kio's `Producer::default` makes its `T`. */ -export function made$tuple4_unit_tuple2_u8_bool_array0_defaults_Made_array0_defaults_Bare(): [undefined, [rt.u8, boolean], Made.Made[], Bare.Bare[]] { +export function made$tuple4_unit_tuple2_u8_bool_array0_defaults_Made_array0_defaults_Bare(): [undefined, [rs.u8, boolean], Made.Made[], Bare.Bare[]] { return [undefined, [0, false], [], []]; } @@ -41,78 +41,78 @@ export function made$unit(): void { } /** Each byte an operation, its value the operand; each puts what it read. */ -export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { +export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { let s!: string; - for (const op of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(op, 9); + for (const op of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(op, 9); if (_10 === 0) { made$unit(); - const pair: [rt.u64 | undefined, Made.Made] = [undefined, Made.default$Default()]; - const nested: [undefined, [rt.u8, boolean], Made.Made[], Bare.Bare[]] = made$tuple4_unit_tuple2_u8_bool_array0_defaults_Made_array0_defaults_Bare(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(pair[0], f, rt.u64Debug), (f: rt.Formatter) => Made.fmt$fmt_Debug(pair[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtUnit(nested[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(nested[1][0], f), (f: rt.Formatter) => rt.fmtBool(nested[1][1], f)], f), (f: rt.Formatter) => rt.fmtList(nested[2], f, (value: Made.Made, f: rt.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtList(nested[3], f, (value: Bare.Bare, f: rt.Formatter) => Bare.fmt$fmt_Debug(value, f))], f)]; - s = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const pair: [rs.u64 | undefined, Made.Made] = [undefined, Made.default$Default()]; + const nested: [undefined, [rs.u8, boolean], Made.Made[], Bare.Bare[]] = made$tuple4_unit_tuple2_u8_bool_array0_defaults_Made_array0_defaults_Bare(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(pair[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(pair[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(nested[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(nested[1][0], f), (f: rs.Formatter) => rs.fmtBool(nested[1][1], f)], f), (f: rs.Formatter) => rs.fmtList(nested[2], f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(nested[3], f, (value: Bare.Bare, f: rs.Formatter) => Bare.fmt$fmt_Debug(value, f))], f)]; + s = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); } else if (_10 === 1) { const made: Made.Made[] = made$array2_defaults_Made(); - const grid: rt.u64[][] = Array.from({ length: 3 }, (): rt.u64[] => { - return Array.from({ length: 2 }, (): rt.u64 => { + const grid: rs.u64[][] = Array.from({ length: 3 }, (): rs.u64[] => { + return Array.from({ length: 2 }, (): rs.u64 => { return 0; }); }); - const _35: rt.ByteSlice = rt.byteSliceFrom(madeBytes(op)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(made, f, (value: Made.Made, f: rt.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtList(grid, f, (value: rt.u64[], f: rt.Formatter) => rt.fmtList(value, f, rt.u64Debug)), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_35), f, rt.u8Debug)]; - s = rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); + const _35: rs.ByteSlice = rs.byteSliceFrom(madeBytes(op)); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(made, f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(grid, f, (value: rs.u64[], f: rs.Formatter) => rs.fmtList(value, f, rs.u64Debug)), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_35), f, rs.u8Debug)]; + s = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2]]); } else if (_10 === 2) { - const counts: rt.Atomic[] = Array.from({ length: 4 }, (): rt.Atomic => { - return new rt.Atomic(0); + const counts: rs.Atomic[] = Array.from({ length: 4 }, (): rs.Atomic => { + return new rs.Atomic(0); }); - const _45: rt.usize = rt.u8Rem(op, 4) as rt.usize; + const _45: rs.usize = rs.u8Rem(op, 4) as rs.usize; if (!(_45 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _45); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _45); } - rt.atomicStore(counts[_45], op as rt.u64, 0); - rt.atomicFetch(counts[0], rt.u64WrappingAdd, 1, 0); - const part2 = rt.iterToVec(rt.iterMap(rt.iterSlice(counts), (c: rt.Atomic): rt.u64 => { - return rt.atomicLoad(c, 0); + rs.atomicStore(counts[_45], op as rs.u64, 0); + rs.atomicFetch(counts[0], rs.u64WrappingAdd, 1, 0); + const part2 = rs.iterToVec(rs.iterMap(rs.iterSlice(counts), (c: rs.Atomic): rs.u64 => { + return rs.atomicLoad(c, 0); }), undefined, 8, true); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, rt.u64Debug)]; - s = rt.fmtFormat([args6[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u64Debug)]; + s = rs.fmtFormat([args6[0]]); } else if (_10 === 3) { const boxed: Made.Made = Made.default$Default(); - const shared: rt.Arc = made$sync_Arc_defaults_Made(); - const again: rt.Arc = rt.arcClone(shared); + const shared: rs.Arc = made$sync_Arc_defaults_Made(); + const again: rs.Arc = rs.arcClone(shared); const _76: Made.Made = shared.value; - const _79: rt.usize = again.strong; - const args8: rt.Fmt[] = [(f: rt.Formatter) => Made.fmt$fmt_Debug(boxed, f), (f: rt.Formatter) => Made.fmt$fmt_Debug(_76, f), (f: rt.Formatter) => rt.usizeDisplay(_79, f)]; - s = rt.fmtFormat([args8[0], " ", args8[1], " ", args8[2]]); + const _79: rs.usize = again.strong; + const args8: rs.Fmt[] = [(f: rs.Formatter) => Made.fmt$fmt_Debug(boxed, f), (f: rs.Formatter) => Made.fmt$fmt_Debug(_76, f), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; + s = rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2]]); again[Symbol.dispose](); shared[Symbol.dispose](); } else if (_10 === 4) { - const part = option_unwrapOrDefault$0k1p6nh(then$1t2ieki(rt.u8Rem(op, 3) === 0, (): [rt.u64 | undefined, Made.Made] => { - return [op as rt.u64, Made.default$Default()] as [rt.u64 | undefined, Made.Made]; + const part = option_unwrapOrDefault$0ddgm4x(then$0t24p36(rs.u8Rem(op, 3) === 0, (): [rs.u64 | undefined, Made.Made] => { + return [op as rs.u64, Made.default$Default()] as [rs.u64 | undefined, Made.Made]; })); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part[0], f, rt.u64Debug), (f: rt.Formatter) => Made.fmt$fmt_Debug(part[1], f)], f)]; - s = rt.fmtFormat([args10[0]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part[0], f, rs.u64Debug), (f: rs.Formatter) => Made.fmt$fmt_Debug(part[1], f)], f)]; + s = rs.fmtFormat([args10[0]]); } else if (_10 === 5) { - const empty: rt.Weak = new rt.Weak(); - const default_: rt.Weak = made$sync_Weak_defaults_Made(); - const arc: rt.Arc = new rt.Arc(Made.default$Default()); - const live: rt.Weak = new rt.Weak(arc); - const copy: rt.Weak = rt.weakClone(empty); - const _117: rt.Arc | undefined = rt.weakUpgrade(empty); + const empty: rs.Weak = new rs.Weak(); + const default_: rs.Weak = made$sync_Weak_defaults_Made(); + const arc: rs.Arc = new rs.Arc(Made.default$Default()); + const live: rs.Weak = new rs.Weak(arc); + const copy: rs.Weak = rs.weakClone(empty); + const _117: rs.Arc | undefined = rs.weakUpgrade(empty); const _115: boolean = _117 === undefined; - const _120: rt.usize = default_.arc.strong; + const _120: rs.usize = default_.arc.strong; const _123: boolean = empty.arc === default_.arc; const _127: boolean = empty.arc === copy.arc; const _131: boolean = empty.arc === live.arc; - const _137: rt.Arc | undefined = rt.weakUpgrade(copy); + const _137: rs.Arc | undefined = rs.weakUpgrade(copy); const _135: boolean = _137 === undefined; - const _142: rt.Arc | undefined = rt.weakUpgrade(live); + const _142: rs.Arc | undefined = rs.weakUpgrade(live); const _140: boolean = _142 !== undefined; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_115, f), (f: rt.Formatter) => rt.usizeDisplay(_120, f), (f: rt.Formatter) => rt.fmtBool(_123, f), (f: rt.Formatter) => rt.fmtBool(_127, f), (f: rt.Formatter) => rt.fmtBool(_131, f), (f: rt.Formatter) => rt.fmtBool(_135, f), (f: rt.Formatter) => rt.fmtBool(_140, f)]; - const _111: string = rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6]]); - rt.drop(_142); - rt.drop(_137); - rt.drop(_117); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_115, f), (f: rs.Formatter) => rs.usizeDisplay(_120, f), (f: rs.Formatter) => rs.fmtBool(_123, f), (f: rs.Formatter) => rs.fmtBool(_127, f), (f: rs.Formatter) => rs.fmtBool(_131, f), (f: rs.Formatter) => rs.fmtBool(_135, f), (f: rs.Formatter) => rs.fmtBool(_140, f)]; + const _111: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4], " ", args12[5], " ", args12[6]]); + rs.drop(_142); + rs.drop(_137); + rs.drop(_117); s = _111; copy[Symbol.dispose](); live[Symbol.dispose](); @@ -121,69 +121,69 @@ export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { empty[Symbol.dispose](); } else if (_10 === 6) { const slot: Slot.Slot = Slot.default$Default(); - const before: rt.u64 | undefined = Slot.get(slot); - const arc2: rt.Arc = new rt.Arc({ n: op as rt.u64, tag: Made.default$Default().tag }); - const _161: rt.Weak = new rt.Weak(arc2); + const before: rs.u64 | undefined = Slot.get(slot); + const arc2: rs.Arc = new rs.Arc({ n: op as rs.u64, tag: Made.default$Default().tag }); + const _161: rs.Weak = new rs.Weak(arc2); slot.weak[Symbol.dispose](); slot.weak = _161; - const _167: rt.u64 | undefined = Slot.get(slot); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(before, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtOption(_167, f, rt.u64Debug)]; - s = rt.fmtFormat([args14[0], " ", args14[1]]); + const _167: rs.u64 | undefined = Slot.get(slot); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(before, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtOption(_167, f, rs.u64Debug)]; + s = rs.fmtFormat([args14[0], " ", args14[1]]); arc2[Symbol.dispose](); slot[Symbol.dispose](); } else if (_10 === 7) { - let boxed2: Made.Made | undefined = then$1j955kq(rt.u8Rem(op, 3) === 0, (): Made.Made => { + let boxed2: Made.Made | undefined = then$1j955kq(rs.u8Rem(op, 3) === 0, (): Made.Made => { return Made.default$Default(); }); - const _179: rt.u64 = op as rt.u64; + const _179: rs.u64 = op as rs.u64; if (boxed2 === undefined) { boxed2 = Made.default$Default(); } - (boxed2 as Made.Made).n = rt.u64Add((boxed2 as Made.Made).n, _179); - let slots = undefined as Array | undefined; - const _184: rt.u8 | undefined = op; + (boxed2 as Made.Made).n = rs.u64Add((boxed2 as Made.Made).n, _179); + let slots = undefined as Array | undefined; + const _184: rs.u8 | undefined = op; if (slots === undefined) { - slots = Array.from({ length: 3 }, (): rt.u8 | undefined => { + slots = Array.from({ length: 3 }, (): rs.u8 | undefined => { return undefined; }); } - const _187: rt.usize = rt.u8Rem(op, 3) as rt.usize; + const _187: rs.usize = rs.u8Rem(op, 3) as rs.usize; if (!(_187 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _187); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _187); } - (slots as Array)[_187] = _184; - const cell: rt.OnceCell> = new rt.OnceCell(undefined); - const shared2: rt.Arc = rt.arcClone(rt.onceGetOrInit(cell, (): rt.Arc => { - return new rt.Arc(Made.default$Default()); + (slots as Array)[_187] = _184; + const cell: rs.OnceCell> = new rs.OnceCell(undefined); + const shared2: rs.Arc = rs.arcClone(rs.onceGetOrInit(cell, (): rs.Arc => { + return new rs.Arc(Made.default$Default()); })); const _199: Made.Made = shared2.value; - const _202: rt.usize = shared2.strong; - const _207: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(boxed2, f, (value: Made.Made, f: rt.Formatter) => Made.fmt$fmt_Debug(value, f)); - const _208: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(slots, f, (value: Array, f: rt.Formatter) => rt.fmtList(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))); + const _202: rs.usize = shared2.strong; + const _207: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(boxed2, f, (value: Made.Made, f: rs.Formatter) => Made.fmt$fmt_Debug(value, f)); + const _208: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(slots, f, (value: Array, f: rs.Formatter) => rs.fmtList(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))); const arg2 = _199.n; - const args16: rt.Fmt[] = [_207, _208, (f: rt.Formatter) => rt.u64Display(arg2, f), (f: rt.Formatter) => rt.usizeDisplay(_202, f)]; - s = rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); + const args16: rs.Fmt[] = [_207, _208, (f: rs.Formatter) => rs.u64Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + s = rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3]]); shared2[Symbol.dispose](); cell[Symbol.dispose](); } else { const made2: Made.Made = made$defaults_Made(); - const _218: rt.u64 = rt.u64Add(made2.n, op as rt.u64); - const _224: rt.Fmt = (f: rt.Formatter) => rt.u64Display(_218, f); + const _218: rs.u64 = rs.u64Add(made2.n, op as rs.u64); + const _224: rs.Fmt = (f: rs.Formatter) => rs.u64Display(_218, f); const arg = made2.tag; - const args18: rt.Fmt[] = [_224, (f: rt.Formatter) => rt.fmtPad(f, arg)]; - s = rt.fmtFormat([args18[0], " ", args18[1]]); + const args18: rs.Fmt[] = [_224, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + s = rs.fmtFormat([args18[0], " ", args18[1]]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 10); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 10); } } /** `[u8; 4]`'s default, written past its first byte. */ -export function madeBytes(op: rt.u8): Uint8Array { - const bytes: Uint8Array = copy$array_u8(rt.bytes(4)); - const _3: rt.usize = rt.u8Rem(op, 4) as rt.usize; +export function madeBytes(op: rs.u8): Uint8Array { + const bytes: Uint8Array = copy$array_u8(rs.bytes(4)); + const _3: rs.usize = rs.u8Rem(op, 4) as rs.usize; if (!(_3 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _3); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _3); } bytes[_3] = op; return copy$array_u8(bytes); diff --git a/ts/fixtures/lang/defaults/expected/harness.ts b/ts/fixtures/lang/defaults/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/defaults/expected/harness.ts +++ b/ts/fixtures/lang/defaults/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/defaults/expected/lib.ts b/ts/fixtures/lang/defaults/expected/lib.ts index 56d350e97..5a96bf5b8 100644 --- a/ts/fixtures/lang/defaults/expected/lib.ts +++ b/ts/fixtures/lang/defaults/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { defaults } from "./defaults.ts"; export function copy$array_u8(v: Uint8Array): Uint8Array { @@ -11,10 +11,10 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["defaults::defaults", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["defaults::defaults", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { defaults(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/drops/expected/core/option.ts b/ts/fixtures/lang/drops/expected/core/option.ts index 0fb1b6278..020e119ff 100644 --- a/ts/fixtures/lang/drops/expected/core/option.ts +++ b/ts/fixtures/lang/drops/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/drops/expected/drops.Chain.ts b/ts/fixtures/lang/drops/expected/drops.Chain.ts index f76b64caa..7c13d5526 100644 --- a/ts/fixtures/lang/drops/expected/drops.Chain.ts +++ b/ts/fixtures/lang/drops/expected/drops.Chain.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Holds itself through a box alone, so one class's glue still drops every instance. */ export class Chain { @@ -13,8 +13,8 @@ export class Chain { } [Symbol.dispose](): void { - rt.drop(this.v); - rt.drop(this.next); + rs.drop(this.v); + rs.drop(this.next); } } diff --git a/ts/fixtures/lang/drops/expected/drops.Guard.ts b/ts/fixtures/lang/drops/expected/drops.Guard.ts index 96cd5ccc0..54692f267 100644 --- a/ts/fixtures/lang/drops/expected/drops.Guard.ts +++ b/ts/fixtures/lang/drops/expected/drops.Guard.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Logged from "./drops.Logged.ts"; /** Logs its mark by a `Drop` impl of every instance, before what it holds drops. */ export class Guard { - mark: rt.u8; + mark: rs.u8; value: T; - log: rt.RefCell; + log: rs.RefCell; - constructor(mark: rt.u8, value: T, log: rt.RefCell) { + constructor(mark: rs.u8, value: T, log: rs.RefCell) { this.mark = mark; this.value = value; this.log = log; @@ -17,9 +17,9 @@ export class Guard { } export function drop$ops_Drop_drops_Logged(self: Guard): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, self.mark); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, self.mark); + rs.refMutRelease(_5); } //# sourceMappingURL=drops.Guard.ts.map diff --git a/ts/fixtures/lang/drops/expected/drops.InBox.ts b/ts/fixtures/lang/drops/expected/drops.InBox.ts index 8d3d5eaa5..d44b13622 100644 --- a/ts/fixtures/lang/drops/expected/drops.InBox.ts +++ b/ts/fixtures/lang/drops/expected/drops.InBox.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Guard from "./drops.Guard.ts"; export class InBox { b: Guard.Guard; - v: rt.Vec>; + v: rs.Vec>; - constructor(b: Guard.Guard, v: rt.Vec>) { + constructor(b: Guard.Guard, v: rs.Vec>) { this.b = b; this.v = v; } diff --git a/ts/fixtures/lang/drops/expected/drops.InOption.ts b/ts/fixtures/lang/drops/expected/drops.InOption.ts index 021731f4c..359bada9a 100644 --- a/ts/fixtures/lang/drops/expected/drops.InOption.ts +++ b/ts/fixtures/lang/drops/expected/drops.InOption.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Either from "./drops.Either.ts"; export class InOption { o: Either.Either | undefined; - cell: rt.OnceCell>; + cell: rs.OnceCell>; - constructor(o: Either.Either | undefined, cell: rt.OnceCell>) { + constructor(o: Either.Either | undefined, cell: rs.OnceCell>) { this.o = o; this.cell = cell; } diff --git a/ts/fixtures/lang/drops/expected/drops.InPlain.ts b/ts/fixtures/lang/drops/expected/drops.InPlain.ts index 0e2857168..07dab7113 100644 --- a/ts/fixtures/lang/drops/expected/drops.InPlain.ts +++ b/ts/fixtures/lang/drops/expected/drops.InPlain.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Either from "./drops.Either.ts"; import type * as Plain from "./drops.Plain.ts"; export class InPlain { - p: Plain.Plain>; + p: Plain.Plain>; t: [Either.Either, T]; - constructor(p: Plain.Plain>, t: [Either.Either, T]) { + constructor(p: Plain.Plain>, t: [Either.Either, T]) { this.p = p; this.t = t; } diff --git a/ts/fixtures/lang/drops/expected/drops.InResult.ts b/ts/fixtures/lang/drops/expected/drops.InResult.ts index 04c1d93ff..f78ddca69 100644 --- a/ts/fixtures/lang/drops/expected/drops.InResult.ts +++ b/ts/fixtures/lang/drops/expected/drops.InResult.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Logged from "./drops.Logged.ts"; export class InResult { - r: rt.Result; + r: rs.Result; after: T; - constructor(r: rt.Result, after: T) { + constructor(r: rs.Result, after: T) { this.r = r; this.after = after; } diff --git a/ts/fixtures/lang/drops/expected/drops.Logged.ts b/ts/fixtures/lang/drops/expected/drops.Logged.ts index 453cb5289..8ede872a4 100644 --- a/ts/fixtures/lang/drops/expected/drops.Logged.ts +++ b/ts/fixtures/lang/drops/expected/drops.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its byte as it drops. */ export class Logged { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -18,9 +18,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=drops.Logged.ts.map diff --git a/ts/fixtures/lang/drops/expected/drops.Plain.ts b/ts/fixtures/lang/drops/expected/drops.Plain.ts index 2a043a25f..93692ff35 100644 --- a/ts/fixtures/lang/drops/expected/drops.Plain.ts +++ b/ts/fixtures/lang/drops/expected/drops.Plain.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** One class's glue drops every instance of it. */ export class Plain { u: U; - n: rt.u8; + n: rs.u8; - constructor(u: U, n: rt.u8) { + constructor(u: U, n: rs.u8) { this.u = u; this.n = n; } diff --git a/ts/fixtures/lang/drops/expected/drops.Tree.ts b/ts/fixtures/lang/drops/expected/drops.Tree.ts index 2a9d77440..57b843728 100644 --- a/ts/fixtures/lang/drops/expected/drops.Tree.ts +++ b/ts/fixtures/lang/drops/expected/drops.Tree.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Either from "./drops.Either.ts"; /** Holds itself through a `Vec`, beside an enum. */ export class Tree { e: Either.Either; - kids: rt.Vec>; + kids: rs.Vec>; - constructor(e: Either.Either, kids: rt.Vec>) { + constructor(e: Either.Either, kids: rs.Vec>) { this.e = e; this.kids = kids; } diff --git a/ts/fixtures/lang/drops/expected/drops.ts b/ts/fixtures/lang/drops/expected/drops.ts index 7bb985f59..6d266fee6 100644 --- a/ts/fixtures/lang/drops/expected/drops.ts +++ b/ts/fixtures/lang/drops/expected/drops.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_unit_drops_Either_drops_Logged, drop$drops_Deep_drops_Logged, drop$drops_Either_drops_Logged, drop$drops_Guard_drops_Logged, drop$drops_InBox_drops_Logged, drop$drops_InEnum_drops_Logged, drop$drops_InGuard_drops_Logged, drop$drops_InOption_drops_Logged, drop$drops_InPlain_drops_Logged, drop$drops_InResult_drops_Logged, drop$drops_Ping_drops_Logged, drop$drops_Tree_drops_Logged } from "./lib.ts"; import { then$1luo4u8, then$1xsk056, then$1nn0mgt } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Chain from "./drops.Chain.ts"; import * as Deep from "./drops.Deep.ts"; import type * as Either from "./drops.Either.ts"; @@ -24,13 +24,13 @@ import * as Tree from "./drops.Tree.ts"; * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_Chain_drops_Logged_drops_drops_closure12(make: (a0: rt.u8) => Chain.Chain, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_Chain_drops_Logged_drops_drops_closure12(make: (a0: rs.u8) => Chain.Chain, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: Chain.Chain = make(0); const _b: Chain.Chain = make(64); @@ -46,17 +46,17 @@ export function ways$drops_Chain_drops_Logged_drops_drops_closure12(make: (a0: r mark(); a[Symbol.dispose](); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), rt.drop); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), rs.drop); mark(); if (!(v.items.length === 0)) { - rt.vecSwapRemove(v, 0)[Symbol.dispose](); + rs.vecSwapRemove(v, 0)[Symbol.dispose](); mark(); } - rt.dropVec(v); + rs.dropVec(v); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); a2[Symbol.dispose](); mark(); b[Symbol.dispose](); @@ -68,13 +68,13 @@ export function ways$drops_Chain_drops_Logged_drops_drops_closure12(make: (a0: r * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_Deep_drops_Logged_drops_drops_closure9(make: (a0: rt.u8) => Deep.Deep, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_Deep_drops_Logged_drops_drops_closure9(make: (a0: rs.u8) => Deep.Deep, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: Deep.Deep = make(0); const _b: Deep.Deep = make(64); @@ -90,20 +90,20 @@ export function ways$drops_Deep_drops_Logged_drops_drops_closure9(make: (a0: rt. mark(); drop$drops_Deep_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_Deep_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_Deep_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_Deep_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_Deep_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_Deep_drops_Logged); + rs.dropVec(v, drop$drops_Deep_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_Deep_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_Deep_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_Deep_drops_Logged); + rs.arcDrop(b, drop$drops_Deep_drops_Logged); mark(); } } @@ -112,13 +112,13 @@ export function ways$drops_Deep_drops_Logged_drops_drops_closure9(make: (a0: rt. * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InBox_drops_Logged_drops_drops_closure8(make: (a0: rt.u8) => InBox.InBox, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InBox_drops_Logged_drops_drops_closure8(make: (a0: rs.u8) => InBox.InBox, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InBox.InBox = make(0); const _b: InBox.InBox = make(64); @@ -134,20 +134,20 @@ export function ways$drops_InBox_drops_Logged_drops_drops_closure8(make: (a0: rt mark(); drop$drops_InBox_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InBox_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InBox_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InBox_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InBox_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InBox_drops_Logged); + rs.dropVec(v, drop$drops_InBox_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InBox_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InBox_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InBox_drops_Logged); + rs.arcDrop(b, drop$drops_InBox_drops_Logged); mark(); } } @@ -156,13 +156,13 @@ export function ways$drops_InBox_drops_Logged_drops_drops_closure8(make: (a0: rt * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InEnum_drops_Logged_drops_drops_closure4(make: (a0: rt.u8) => InEnum.InEnum, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InEnum_drops_Logged_drops_drops_closure4(make: (a0: rs.u8) => InEnum.InEnum, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InEnum.InEnum = make(0); const _b: InEnum.InEnum = make(64); @@ -178,20 +178,20 @@ export function ways$drops_InEnum_drops_Logged_drops_drops_closure4(make: (a0: r mark(); drop$drops_InEnum_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InEnum_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InEnum_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InEnum_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InEnum_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InEnum_drops_Logged); + rs.dropVec(v, drop$drops_InEnum_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InEnum_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InEnum_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InEnum_drops_Logged); + rs.arcDrop(b, drop$drops_InEnum_drops_Logged); mark(); } } @@ -200,13 +200,13 @@ export function ways$drops_InEnum_drops_Logged_drops_drops_closure4(make: (a0: r * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InGuard_drops_Logged_drops_drops_closure3(make: (a0: rt.u8) => InGuard.InGuard, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InGuard_drops_Logged_drops_drops_closure3(make: (a0: rs.u8) => InGuard.InGuard, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InGuard.InGuard = make(0); const _b: InGuard.InGuard = make(64); @@ -222,20 +222,20 @@ export function ways$drops_InGuard_drops_Logged_drops_drops_closure3(make: (a0: mark(); drop$drops_InGuard_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InGuard_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InGuard_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InGuard_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InGuard_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InGuard_drops_Logged); + rs.dropVec(v, drop$drops_InGuard_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InGuard_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InGuard_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InGuard_drops_Logged); + rs.arcDrop(b, drop$drops_InGuard_drops_Logged); mark(); } } @@ -244,13 +244,13 @@ export function ways$drops_InGuard_drops_Logged_drops_drops_closure3(make: (a0: * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InOption_drops_Logged_drops_drops_closure6(make: (a0: rt.u8) => InOption.InOption, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InOption_drops_Logged_drops_drops_closure6(make: (a0: rs.u8) => InOption.InOption, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InOption.InOption = make(0); const _b: InOption.InOption = make(64); @@ -266,20 +266,20 @@ export function ways$drops_InOption_drops_Logged_drops_drops_closure6(make: (a0: mark(); drop$drops_InOption_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InOption_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InOption_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InOption_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InOption_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InOption_drops_Logged); + rs.dropVec(v, drop$drops_InOption_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InOption_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InOption_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InOption_drops_Logged); + rs.arcDrop(b, drop$drops_InOption_drops_Logged); mark(); } } @@ -288,13 +288,13 @@ export function ways$drops_InOption_drops_Logged_drops_drops_closure6(make: (a0: * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InPlain_drops_Logged_drops_drops_closure7(make: (a0: rt.u8) => InPlain.InPlain, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InPlain_drops_Logged_drops_drops_closure7(make: (a0: rs.u8) => InPlain.InPlain, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InPlain.InPlain = make(0); const _b: InPlain.InPlain = make(64); @@ -310,20 +310,20 @@ export function ways$drops_InPlain_drops_Logged_drops_drops_closure7(make: (a0: mark(); drop$drops_InPlain_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InPlain_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InPlain_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InPlain_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InPlain_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InPlain_drops_Logged); + rs.dropVec(v, drop$drops_InPlain_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InPlain_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InPlain_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InPlain_drops_Logged); + rs.arcDrop(b, drop$drops_InPlain_drops_Logged); mark(); } } @@ -332,13 +332,13 @@ export function ways$drops_InPlain_drops_Logged_drops_drops_closure7(make: (a0: * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_InResult_drops_Logged_drops_drops_closure5(make: (a0: rt.u8) => InResult.InResult, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_InResult_drops_Logged_drops_drops_closure5(make: (a0: rs.u8) => InResult.InResult, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: InResult.InResult = make(0); const _b: InResult.InResult = make(64); @@ -354,20 +354,20 @@ export function ways$drops_InResult_drops_Logged_drops_drops_closure5(make: (a0: mark(); drop$drops_InResult_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_InResult_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_InResult_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_InResult_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_InResult_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_InResult_drops_Logged); + rs.dropVec(v, drop$drops_InResult_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_InResult_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_InResult_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_InResult_drops_Logged); + rs.arcDrop(b, drop$drops_InResult_drops_Logged); mark(); } } @@ -376,13 +376,13 @@ export function ways$drops_InResult_drops_Logged_drops_drops_closure5(make: (a0: * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_Ping_drops_Logged_drops_drops_closure11(make: (a0: rt.u8) => Ping.Ping, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_Ping_drops_Logged_drops_drops_closure11(make: (a0: rs.u8) => Ping.Ping, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: Ping.Ping = make(0); const _b: Ping.Ping = make(64); @@ -398,20 +398,20 @@ export function ways$drops_Ping_drops_Logged_drops_drops_closure11(make: (a0: rt mark(); drop$drops_Ping_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_Ping_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_Ping_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_Ping_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_Ping_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_Ping_drops_Logged); + rs.dropVec(v, drop$drops_Ping_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_Ping_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_Ping_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_Ping_drops_Logged); + rs.arcDrop(b, drop$drops_Ping_drops_Logged); mark(); } } @@ -420,13 +420,13 @@ export function ways$drops_Ping_drops_Logged_drops_drops_closure11(make: (a0: rt * Two of what `make` makes, each from its own base of bytes, dropped by the way `how` * picks. */ -export function ways$drops_Tree_drops_Logged_drops_drops_closure10(make: (a0: rt.u8) => Tree.Tree, how: rt.u8, log: rt.RefCell): void { +export function ways$drops_Tree_drops_Logged_drops_drops_closure10(make: (a0: rs.u8) => Tree.Tree, how: rs.u8, log: rs.RefCell): void { const mark: () => undefined = (): undefined => { - const _4: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_4.value, 254); - rt.refMutRelease(_4); + const _4: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_4.value, 254); + rs.refMutRelease(_4); }; - const _5: rt.u8 = rt.u8Rem(how, 4); + const _5: rs.u8 = rs.u8Rem(how, 4); if (_5 === 0) { const _a: Tree.Tree = make(0); const _b: Tree.Tree = make(64); @@ -442,20 +442,20 @@ export function ways$drops_Tree_drops_Logged_drops_drops_closure10(make: (a0: rt mark(); drop$drops_Tree_drops_Logged(a); } else if (_5 === 2) { - const v: rt.Vec> = rt.vecFrom([make(0), make(64), make(128)]); - rt.vecTruncate(v, rt.usizeRem(how >> 2 as rt.usize, 3), drop$drops_Tree_drops_Logged); + const v: rs.Vec> = rs.vecFrom([make(0), make(64), make(128)]); + rs.vecTruncate(v, rs.usizeRem(how >> 2 as rs.usize, 3), drop$drops_Tree_drops_Logged); mark(); if (!(v.items.length === 0)) { - drop$drops_Tree_drops_Logged(rt.vecSwapRemove(v, 0)); + drop$drops_Tree_drops_Logged(rs.vecSwapRemove(v, 0)); mark(); } - rt.dropVec(v, drop$drops_Tree_drops_Logged); + rs.dropVec(v, drop$drops_Tree_drops_Logged); } else { - const a2: rt.Arc> = new rt.Arc(make(0)); - const b: rt.Arc> = rt.arcClone(a2); - rt.arcDrop(a2, drop$drops_Tree_drops_Logged); + const a2: rs.Arc> = new rs.Arc(make(0)); + const b: rs.Arc> = rs.arcClone(a2); + rs.arcDrop(a2, drop$drops_Tree_drops_Logged); mark(); - rt.arcDrop(b, drop$drops_Tree_drops_Logged); + rs.arcDrop(b, drop$drops_Tree_drops_Logged); mark(); } } @@ -464,105 +464,105 @@ export function ways$drops_Tree_drops_Logged_drops_drops_closure10(make: (a0: rt * Case `kind % 12`, its variants picked by the first byte of `data` and its drops by the * second. */ -export function drops(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function drops(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _99: boolean = false; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const pick: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const how: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const l: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const pick: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const how: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const l: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, log); }; - const either: (a0: rt.u8) => Either.Either = (id2: rt.u8): Either.Either => { - const _3: rt.u8 = rt.u8Rem(pick, 3); + const either: (a0: rs.u8) => Either.Either = (id2: rs.u8): Either.Either => { + const _3: rs.u8 = rs.u8Rem(pick, 3); if (_3 === 0) { return { tag: "Left", _0: l(id2) } as Either.Either; } if (_3 === 1) { - return { tag: "Right", _0: l(id2), _1: l(rt.u8Add(id2, 1)) } as Either.Either; + return { tag: "Right", _0: l(id2), _1: l(rs.u8Add(id2, 1)) } as Either.Either; } return { tag: "Neither" } as Either.Either; }; - const guard: (a0: rt.u8) => Guard.Guard = (id3: rt.u8): Guard.Guard => { + const guard: (a0: rs.u8) => Guard.Guard = (id3: rs.u8): Guard.Guard => { return new Guard.Guard(id3 | 32, l(id3), log); }; - const inGuard: (a0: rt.u8) => InGuard.InGuard = (b: rt.u8): InGuard.InGuard => { - return new InGuard.InGuard(guard(rt.u8Add(b, 1)), l(rt.u8Add(b, 2))); + const inGuard: (a0: rs.u8) => InGuard.InGuard = (b: rs.u8): InGuard.InGuard => { + return new InGuard.InGuard(guard(rs.u8Add(b, 1)), l(rs.u8Add(b, 2))); }; - const inEnum: (a0: rt.u8) => InEnum.InEnum = (b2: rt.u8): InEnum.InEnum => { - return new InEnum.InEnum(either(rt.u8Add(b2, 1)), l(rt.u8Add(b2, 3))); + const inEnum: (a0: rs.u8) => InEnum.InEnum = (b2: rs.u8): InEnum.InEnum => { + return new InEnum.InEnum(either(rs.u8Add(b2, 1)), l(rs.u8Add(b2, 3))); }; - const _27: rt.u8 = rt.u8Rem(kind, 12); + const _27: rs.u8 = rs.u8Rem(kind, 12); if (_27 === 0) { ways$drops_InGuard_drops_Logged_drops_drops_closure3(inGuard, how, log); } else if (_27 === 1) { ways$drops_InEnum_drops_Logged_drops_drops_closure4(inEnum, how, log); } else if (_27 === 2) { - ways$drops_InResult_drops_Logged_drops_drops_closure5((b10: rt.u8): InResult.InResult => { - let _318!: rt.Result; + ways$drops_InResult_drops_Logged_drops_drops_closure5((b10: rs.u8): InResult.InResult => { + let _318!: rs.Result; if (!((pick & 1) === 0)) { - _318 = rt.Err(l(rt.u8Add(b10, 1))); + _318 = rs.Err(l(rs.u8Add(b10, 1))); } else { - _318 = rt.Ok(l(rt.u8Add(b10, 1))); + _318 = rs.Ok(l(rs.u8Add(b10, 1))); } - return new InResult.InResult(_318, l(rt.u8Add(b10, 2))); + return new InResult.InResult(_318, l(rs.u8Add(b10, 2))); }, how, log); } else if (_27 === 3) { - ways$drops_InOption_drops_Logged_drops_drops_closure6((b9: rt.u8): InOption.InOption => { - const cell: rt.OnceCell> = new rt.OnceCell(undefined); + ways$drops_InOption_drops_Logged_drops_drops_closure6((b9: rs.u8): InOption.InOption => { + const cell: rs.OnceCell> = new rs.OnceCell(undefined); if ((pick & 4) !== 0) { - const _915: Either.Either = either(rt.u8Add(b9, 4)); - drop$Result_unit_drops_Either_drops_Logged(rt.onceSet(cell, _915)); + const _915: Either.Either = either(rs.u8Add(b9, 4)); + drop$Result_unit_drops_Either_drops_Logged(rs.onceSet(cell, _915)); } return new InOption.InOption(then$1nn0mgt((pick & 8) !== 0, (): Either.Either => { - return either(rt.u8Add(b9, 1)); + return either(rs.u8Add(b9, 1)); }), cell); }, how, log); } else if (_27 === 4) { - ways$drops_InPlain_drops_Logged_drops_drops_closure7((b8: rt.u8): InPlain.InPlain => { - return new InPlain.InPlain(new Plain.Plain(rt.vecFrom([l(rt.u8Add(b8, 1)), l(rt.u8Add(b8, 2))]), b8), [either(rt.u8Add(b8, 3)), l(rt.u8Add(b8, 5))] as [Either.Either, Logged.Logged]); + ways$drops_InPlain_drops_Logged_drops_drops_closure7((b8: rs.u8): InPlain.InPlain => { + return new InPlain.InPlain(new Plain.Plain(rs.vecFrom([l(rs.u8Add(b8, 1)), l(rs.u8Add(b8, 2))]), b8), [either(rs.u8Add(b8, 3)), l(rs.u8Add(b8, 5))] as [Either.Either, Logged.Logged]); }, how, log); } else if (_27 === 5) { - ways$drops_InBox_drops_Logged_drops_drops_closure8((b7: rt.u8): InBox.InBox => { - return new InBox.InBox(guard(rt.u8Add(b7, 1)), rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(pick, 3)), (i2: rt.u8): Guard.Guard => { - return guard(rt.u8Add(rt.u8Add(b7, 2), i2)); + ways$drops_InBox_drops_Logged_drops_drops_closure8((b7: rs.u8): InBox.InBox => { + return new InBox.InBox(guard(rs.u8Add(b7, 1)), rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(pick, 3)), (i2: rs.u8): Guard.Guard => { + return guard(rs.u8Add(rs.u8Add(b7, 2), i2)); }), undefined, 16, true)); }, how, log); } else if (_27 === 6) { - ways$drops_Deep_drops_Logged_drops_drops_closure9((b6: rt.u8): Deep.Deep => { - return new Deep.Deep(inGuard(b6), l(rt.u8Add(b6, 3))); + ways$drops_Deep_drops_Logged_drops_drops_closure9((b6: rs.u8): Deep.Deep => { + return new Deep.Deep(inGuard(b6), l(rs.u8Add(b6, 3))); }, how, log); } else if (_27 === 7) { - ways$drops_Tree_drops_Logged_drops_drops_closure10((b5: rt.u8): Tree.Tree => { - return new Tree.Tree(either(rt.u8Add(b5, 1)), rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(pick, 3)), (i: rt.u8): Tree.Tree => { - return new Tree.Tree(either(rt.u8Add(rt.u8Add(b5, 3), rt.u8Mul(2, i))), new rt.Vec()); + ways$drops_Tree_drops_Logged_drops_drops_closure10((b5: rs.u8): Tree.Tree => { + return new Tree.Tree(either(rs.u8Add(b5, 1)), rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(pick, 3)), (i: rs.u8): Tree.Tree => { + return new Tree.Tree(either(rs.u8Add(rs.u8Add(b5, 3), rs.u8Mul(2, i))), new rs.Vec()); }), undefined, 32, true)); }, how, log); } else if (_27 === 8) { - ways$drops_Ping_drops_Logged_drops_drops_closure11((b4: rt.u8): Ping.Ping => { + ways$drops_Ping_drops_Logged_drops_drops_closure11((b4: rs.u8): Ping.Ping => { return new Ping.Ping(new Pong.Pong(then$1xsk056((pick & 8) !== 0, (): Ping.Ping => { - return new Ping.Ping(undefined, l(rt.u8Add(b4, 3))); - }), either(rt.u8Add(b4, 1))), l(rt.u8Add(b4, 4))); + return new Ping.Ping(undefined, l(rs.u8Add(b4, 3))); + }), either(rs.u8Add(b4, 1))), l(rs.u8Add(b4, 4))); }, how, log); } else if (_27 === 9) { - ways$drops_Chain_drops_Logged_drops_drops_closure12((b3: rt.u8): Chain.Chain => { - return new Chain.Chain(l(rt.u8Add(b3, 1)), then$1luo4u8((pick & 8) !== 0, (): Chain.Chain => { - return new Chain.Chain(l(rt.u8Add(b3, 2)), undefined); + ways$drops_Chain_drops_Logged_drops_drops_closure12((b3: rs.u8): Chain.Chain => { + return new Chain.Chain(l(rs.u8Add(b3, 1)), then$1luo4u8((pick & 8) !== 0, (): Chain.Chain => { + return new Chain.Chain(l(rs.u8Add(b3, 2)), undefined); })); }, how, log); } else if (_27 === 10) { const s: InGuard.InGuard = inGuard(0); _99 = true; const after: Logged.Logged = s.after; - const _71: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_71.value, 254); - rt.refMutRelease(_71); + const _71: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_71.value, 254); + rs.refMutRelease(_71); if ((pick & 1) === 0) { _99 = false; after[Symbol.dispose](); } - const _80: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_80.value, 254); - rt.refMutRelease(_80); + const _80: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_80.value, 254); + rs.refMutRelease(_80); if (_99) { after[Symbol.dispose](); } @@ -572,14 +572,14 @@ export function drops(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _83: InEnum.InEnum = inEnum(0); const after2: Logged.Logged = _83.after; drop$drops_Either_drops_Logged(_83.e); - const _89: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_89.value, 254); - rt.refMutRelease(_89); + const _89: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_89.value, 254); + rs.refMutRelease(_89); after2[Symbol.dispose](); } - const _97: rt.RefCell = rt.refCellBorrow(log); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_97.value))), undefined, true); - rt.refRelease(_97); + const _97: rs.RefCell = rs.refCellBorrow(log); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_97.value))), undefined, true); + rs.refRelease(_97); } //# sourceMappingURL=drops.ts.map diff --git a/ts/fixtures/lang/drops/expected/harness.ts b/ts/fixtures/lang/drops/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/drops/expected/harness.ts +++ b/ts/fixtures/lang/drops/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/drops/expected/lib.ts b/ts/fixtures/lang/drops/expected/lib.ts index fb44f7b18..f87445c74 100644 --- a/ts/fixtures/lang/drops/expected/lib.ts +++ b/ts/fixtures/lang/drops/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drops } from "./drops.ts"; import type * as Deep from "./drops.Deep.ts"; import type * as Either from "./drops.Either.ts"; @@ -35,7 +35,7 @@ export function drop$Option_drops_Either_drops_Logged(_1: Either.Either): void { +export function drop$Result_drops_Logged_drops_Logged(_1: rs.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -43,7 +43,7 @@ export function drop$Result_drops_Logged_drops_Logged(_1: rt.Result>): void { +export function drop$Result_unit_drops_Either_drops_Logged(_1: rs.Result>): void { if (!_1.ok) { drop$drops_Either_drops_Logged(_1.error); } @@ -70,7 +70,7 @@ export function drop$drops_Guard_drops_Logged(_1: Guard.Guard): v export function drop$drops_InBox_drops_Logged(_1: InBox.InBox): void { drop$drops_Guard_drops_Logged(_1.b); - rt.dropVec(_1.v, drop$drops_Guard_drops_Logged); + rs.dropVec(_1.v, drop$drops_Guard_drops_Logged); } export function drop$drops_InEnum_drops_Logged(_1: InEnum.InEnum): void { @@ -89,7 +89,7 @@ export function drop$drops_InOption_drops_Logged(_1: InOption.InOption): void { - drop$drops_Plain_Vec_drops_Logged(_1.p as Plain.Plain>); + drop$drops_Plain_Vec_drops_Logged(_1.p as Plain.Plain>); drop$tuple2_drops_Either_drops_Logged_drops_Logged(_1.t); } @@ -103,8 +103,8 @@ export function drop$drops_Ping_drops_Logged(_1: Ping.Ping): void _1.v[Symbol.dispose](); } -export function drop$drops_Plain_Vec_drops_Logged(_1: Plain.Plain>): void { - rt.dropVec(_1.u); +export function drop$drops_Plain_Vec_drops_Logged(_1: Plain.Plain>): void { + rs.dropVec(_1.u); } export function drop$drops_Pong_drops_Logged(_1: Pong.Pong): void { @@ -114,7 +114,7 @@ export function drop$drops_Pong_drops_Logged(_1: Pong.Pong): void export function drop$drops_Tree_drops_Logged(_1: Tree.Tree): void { drop$drops_Either_drops_Logged(_1.e); - rt.dropVec(_1.kids, drop$drops_Tree_drops_Logged); + rs.dropVec(_1.kids, drop$drops_Tree_drops_Logged); } export function drop$tuple2_drops_Either_drops_Logged_drops_Logged(_1: [Either.Either, Logged.Logged]): void { @@ -126,8 +126,8 @@ export function drop$tuple2_drops_Either_drops_Logged_drops_Logged(_1: [Either.E * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["drops::drops", drops as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["drops::drops", drops as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/durations/expected/core/bool.ts b/ts/fixtures/lang/durations/expected/core/bool.ts index f2c0f81f2..90b0c5a13 100644 --- a/ts/fixtures/lang/durations/expected/core/bool.ts +++ b/ts/fixtures/lang/durations/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1jqdi5p(self: boolean, t: rt.Duration): rt.Duration | undefined { +export function thenSome$00rtwed(self: boolean, t: rs.Duration): rs.Duration | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/durations/expected/durations.Twice.ts b/ts/fixtures/lang/durations/expected/durations.Twice.ts index 802c244cc..ece96b534 100644 --- a/ts/fixtures/lang/durations/expected/durations.Twice.ts +++ b/ts/fixtures/lang/durations/expected/durations.Twice.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The crate's own `+=` onto a `Duration`, which adds twice. */ export interface Twice { - _0: rt.Duration; + _0: rs.Duration; } //# sourceMappingURL=durations.Twice.ts.map diff --git a/ts/fixtures/lang/durations/expected/durations.Window.ts b/ts/fixtures/lang/durations/expected/durations.Window.ts index a6d20266b..270f075fb 100644 --- a/ts/fixtures/lang/durations/expected/durations.Window.ts +++ b/ts/fixtures/lang/durations/expected/durations.Window.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Window, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Window, f: rs.Formatter): rs.Result { const _3: string = "Window"; const _4: string = "start"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.durationDebug(self.start, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.durationDebug(self.start, f); const _7: string = "len"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.len, f, rt.durationDebug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.len, f, rs.durationDebug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function default$Default(): Window { @@ -16,29 +16,29 @@ export function default$Default(): Window { } export function eq$cmp_PartialEq(self: Window, other: Window): boolean { - if (!rt.durationEq(self.start, other.start)) { + if (!rs.durationEq(self.start, other.start)) { return false; } - return rt.eqOption(rt.durationEq)(self.len, other.len); + return rs.eqOption(rs.durationEq)(self.len, other.len); } -export function hash$Hash_hash_DefaultHasher(self: Window, state: rt.Hasher): void { - rt.durationHash(self.start, state); - rt.hashOption(rt.durationHash)(self.len, state); +export function hash$Hash_hash_DefaultHasher(self: Window, state: rs.Hasher): void { + rs.durationHash(self.start, state); + rs.hashOption(rs.durationHash)(self.len, state); } -export function cmp$cmp_Ord(self: Window, other: Window): rt.Ordering { - const cmp: rt.Ordering = rt.durationCmp(self.start, other.start); +export function cmp$cmp_Ord(self: Window, other: Window): rs.Ordering { + const cmp: rs.Ordering = rs.durationCmp(self.start, other.start); if (cmp === 0) { - return rt.cmpOption(rt.durationCmp)(self.len, other.len); + return rs.cmpOption(rs.durationCmp)(self.len, other.len); } return cmp; } /** A `Duration` in a field, through each derived impl. */ export interface Window { - start: rt.Duration; - len: rt.Duration | undefined; + start: rs.Duration; + len: rs.Duration | undefined; } //# sourceMappingURL=durations.Window.ts.map diff --git a/ts/fixtures/lang/durations/expected/durations.ts b/ts/fixtures/lang/durations/expected/durations.ts index 53d5c91c3..edc5ffa87 100644 --- a/ts/fixtures/lang/durations/expected/durations.ts +++ b/ts/fixtures/lang/durations/expected/durations.ts @@ -1,242 +1,242 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$durations_Window } from "./lib.ts"; -import { thenSome$1jqdi5p } from "./core/bool.ts"; +import { thenSome$00rtwed } from "./core/bool.ts"; import type * as Twice from "./durations.Twice.ts"; import * as Window from "./durations.Window.ts"; import { put } from "./harness.ts"; /** A `u64` and a `u32` from the front of `data`, big-endian and zero-padded. */ -export function take(data: rt.ByteSlice): [rt.u64, rt.u32, rt.ByteSlice] { - const buf: Uint8Array = rt.bytes(12); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const s0: rt.u8 = buf[0]; - const s1: rt.u8 = buf[1]; - const s2: rt.u8 = buf[2]; - const s3: rt.u8 = buf[3]; - const s4: rt.u8 = buf[4]; - const s5: rt.u8 = buf[5]; - const s6: rt.u8 = buf[6]; - const s7: rt.u8 = buf[7]; - const n0: rt.u8 = buf[8]; - const n1: rt.u8 = buf[9]; - const n2: rt.u8 = buf[10]; - const n3: rt.u8 = buf[11]; - return [rt.u64FromBeBytes(Uint8Array.of(s0, s1, s2, s3, s4, s5, s6, s7)), ((n0 << 24) | (n1 << 16) | (n2 << 8) | n3) >>> 0, rt.byteSliceRange(data, n)] as [rt.u64, rt.u32, rt.ByteSlice]; +export function take(data: rs.ByteSlice): [rs.u64, rs.u32, rs.ByteSlice] { + const buf: Uint8Array = rs.bytes(12); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const s0: rs.u8 = buf[0]; + const s1: rs.u8 = buf[1]; + const s2: rs.u8 = buf[2]; + const s3: rs.u8 = buf[3]; + const s4: rs.u8 = buf[4]; + const s5: rs.u8 = buf[5]; + const s6: rs.u8 = buf[6]; + const s7: rs.u8 = buf[7]; + const n0: rs.u8 = buf[8]; + const n1: rs.u8 = buf[9]; + const n2: rs.u8 = buf[10]; + const n3: rs.u8 = buf[11]; + return [rs.u64FromBeBytes(Uint8Array.of(s0, s1, s2, s3, s4, s5, s6, s7)), ((n0 << 24) | (n1 << 16) | (n2 << 8) | n3) >>> 0, rs.byteSliceRange(data, n)] as [rs.u64, rs.u32, rs.ByteSlice]; } /** A `Duration` from the front of `data`, whose nanoseconds never carry. */ -export function duration(data: rt.ByteSlice): [rt.Duration, rt.ByteSlice] { - const _5: [rt.u64, rt.u32, rt.ByteSlice] = take(data); - return [rt.durationNew(_5[0], rt.u32Rem(_5[1], 1000000000)), _5[2]] as [rt.Duration, rt.ByteSlice]; +export function duration(data: rs.ByteSlice): [rs.Duration, rs.ByteSlice] { + const _5: [rs.u64, rs.u32, rs.ByteSlice] = take(data); + return [rs.durationNew(_5[0], rs.u32Rem(_5[1], 1000000000)), _5[2]] as [rs.Duration, rs.ByteSlice]; } -export function putDuration(out: rt.ByteVec, d: rt.Duration): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.durationAsSecs(d)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.durationSubsecNanos(d)))); +export function putDuration(out: rs.ByteVec, d: rs.Duration): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.durationAsSecs(d)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.durationSubsecNanos(d)))); } -export function putOpt(out: rt.ByteVec, d: rt.Duration | undefined): void { +export function putOpt(out: rs.ByteVec, d: rs.Duration | undefined): void { if (d === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const d2: rt.Duration = d; - rt.byteVecPush(out, 1); + const d2: rs.Duration = d; + rs.byteVecPush(out, 1); putDuration(out, d2); } } -export function addAssign$ops_AddAssign_durations_Twice_time_Duration(self: rt.Place, by: Twice.Twice): void { - self.v = rt.durationAdd(self.v, by._0); - self.v = rt.durationAdd(self.v, by._0); +export function addAssign$ops_AddAssign_durations_Twice_time_Duration(self: rs.Place, by: Twice.Twice): void { + self.v = rs.durationAdd(self.v, by._0); + self.v = rs.durationAdd(self.v, by._0); } -/** `-=` through a `&mut`, which is an `rt.Place`. */ -export function shrink(d: rt.Place, by: rt.Duration): void { - d.v = rt.durationSub(d.v, by); +/** `-=` through a `&mut`, which is an `rs.Place`. */ +export function shrink(d: rs.Place, by: rs.Duration): void { + d.v = rs.durationSub(d.v, by); } -export function durations(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.Duration, rt.ByteSlice] = duration(data); - const a: rt.Duration = _6[0]; - const _9: [rt.Duration, rt.ByteSlice] = duration(_6[1]); - const b: rt.Duration = _9[0]; - const word: Uint8Array = rt.bytes(4); - const k: rt.usize = rt.min(_9[1].length, rt.byteSliceFrom(word).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(word), 0, k), rt.byteSliceRange(_9[1], 0, k)); - const n: rt.u32 = rt.u32FromBeBytes(word); - const _24: rt.u8 = rt.u8Rem(kind, 14); +export function durations(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.Duration, rs.ByteSlice] = duration(data); + const a: rs.Duration = _6[0]; + const _9: [rs.Duration, rs.ByteSlice] = duration(_6[1]); + const b: rs.Duration = _9[0]; + const word: Uint8Array = rs.bytes(4); + const k: rs.usize = rs.min(_9[1].length, rs.byteSliceFrom(word).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(word), 0, k), rs.byteSliceRange(_9[1], 0, k)); + const n: rs.u32 = rs.u32FromBeBytes(word); + const _24: rs.u8 = rs.u8Rem(kind, 14); if (_24 === 0) { - const _28: [rt.u64, rt.u32, rt.ByteSlice] = take(data); - putDuration(out, rt.durationNew(_28[0], _28[1])); + const _28: [rs.u64, rs.u32, rs.ByteSlice] = take(data); + putDuration(out, rs.durationNew(_28[0], _28[1])); } else if (_24 === 1) { - const units: rt.u64 = take(data)[0]; - putDuration(out, rt.durationFromSecs(units)); - putDuration(out, rt.durationFromMillis(units)); - putDuration(out, rt.durationFromMicros(units)); - putDuration(out, rt.durationFromNanos(units)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.durationAsSecs(b)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.durationSubsecMillis(b)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.durationSubsecMicros(b)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.durationAsMillis(b)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.durationAsMicros(b)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.durationAsNanos(b)))); - rt.byteVecPush(out, rt.durationIsZero(b) ? 1 : 0); + const units: rs.u64 = take(data)[0]; + putDuration(out, rs.durationFromSecs(units)); + putDuration(out, rs.durationFromMillis(units)); + putDuration(out, rs.durationFromMicros(units)); + putDuration(out, rs.durationFromNanos(units)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.durationAsSecs(b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.durationSubsecMillis(b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.durationSubsecMicros(b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.durationAsMillis(b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.durationAsMicros(b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.durationAsNanos(b)))); + rs.byteVecPush(out, rs.durationIsZero(b) ? 1 : 0); } else if (_24 === 2) { - putOpt(out, rt.durationCheckedAdd(a, b)); - putOpt(out, rt.durationCheckedSub(a, b)); - putOpt(out, rt.durationCheckedMul(a, n)); - putOpt(out, rt.durationCheckedDiv(a, n)); - putDuration(out, rt.durationSaturatingAdd(a, b)); - putDuration(out, rt.durationSaturatingSub(a, b)); - putDuration(out, rt.durationSaturatingMul(a, n)); - putDuration(out, rt.durationAbsDiff(a, b)); + putOpt(out, rs.durationCheckedAdd(a, b)); + putOpt(out, rs.durationCheckedSub(a, b)); + putOpt(out, rs.durationCheckedMul(a, n)); + putOpt(out, rs.durationCheckedDiv(a, n)); + putDuration(out, rs.durationSaturatingAdd(a, b)); + putDuration(out, rs.durationSaturatingSub(a, b)); + putDuration(out, rs.durationSaturatingMul(a, n)); + putDuration(out, rs.durationAbsDiff(a, b)); } else if (_24 === 3) { - putDuration(out, rt.durationAdd(a, b)); + putDuration(out, rs.durationAdd(a, b)); } else if (_24 === 4) { - putDuration(out, rt.durationSub(a, b)); + putDuration(out, rs.durationSub(a, b)); } else if (_24 === 5) { - putDuration(out, rt.durationTimes(n, a)); - putDuration(out, rt.durationMul(a, n)); + putDuration(out, rs.durationTimes(n, a)); + putDuration(out, rs.durationMul(a, n)); } else if (_24 === 6) { - putDuration(out, rt.durationDiv(a, n)); + putDuration(out, rs.durationDiv(a, n)); } else if (_24 === 7) { - const _105: boolean = rt.durationEq(a, b); - const _108: boolean = !rt.durationEq(a, b); - const _111: boolean = rt.durationCmp(a, b) === -1; - const order = rt.durationCmp(a, b); + const _105: boolean = rs.durationEq(a, b); + const _108: boolean = !rs.durationEq(a, b); + const _111: boolean = rs.durationCmp(a, b) === -1; + const order = rs.durationCmp(a, b); const _114: boolean = order !== undefined && order <= 0; - const _117: boolean = rt.durationCmp(a, b) === 1; - const order2 = rt.durationCmp(a, b); + const _117: boolean = rs.durationCmp(a, b) === 1; + const order2 = rs.durationCmp(a, b); const _120: boolean = order2 !== undefined && order2 >= 0; - const _123: boolean = rt.durationCmp(a, b) < 0; - const _127: boolean = rt.durationCmp(a, b) === 1; - const _135: rt.Duration | undefined = a; - const _137: rt.Duration | undefined = b; - const _133: boolean = rt.eqOption(rt.durationEq)(_135, _137); - const _140: rt.Duration | undefined = a; - const iter: rt.Iter = rt.iterSlice([_105, _108, _111, _114, _117, _120, _123, _127, _133, rt.eqOption(rt.durationEq)(_140, undefined)]); + const _123: boolean = rs.durationCmp(a, b) < 0; + const _127: boolean = rs.durationCmp(a, b) === 1; + const _135: rs.Duration | undefined = a; + const _137: rs.Duration | undefined = b; + const _133: boolean = rs.eqOption(rs.durationEq)(_135, _137); + const _140: rs.Duration | undefined = a; + const iter: rs.Iter = rs.iterSlice([_105, _108, _111, _114, _117, _120, _123, _127, _133, rs.eqOption(rs.durationEq)(_140, undefined)]); while (true) { - const _144: boolean | rt.Done = iter.next(); - if (_144 === rt.DONE) { + const _144: boolean | rs.Done = iter.next(); + if (_144 === rs.DONE) { break; } - rt.byteVecPush(out, _144 ? 1 : 0); + rs.byteVecPush(out, _144 ? 1 : 0); } - putDuration(out, rt.ordMax(a, b, rt.cmpLt(rt.durationCmp))); - putDuration(out, rt.ordMin(a, b, rt.cmpLt(rt.durationCmp))); - const seen: rt.BTreeMap = rt.btreeNew(rt.durationCmp) as rt.BTreeMap; - const iter2: rt.Iter<[rt.usize, rt.Duration]> = rt.iterEnumerate(rt.iterSlice([a, b, { secs: 1, nanos: 500000000 }, a, { secs: 0, nanos: 0 }])); + putDuration(out, rs.ordMax(a, b, rs.cmpLt(rs.durationCmp))); + putDuration(out, rs.ordMin(a, b, rs.cmpLt(rs.durationCmp))); + const seen: rs.BTreeMap = rs.btreeNew(rs.durationCmp) as rs.BTreeMap; + const iter2: rs.Iter<[rs.usize, rs.Duration]> = rs.iterEnumerate(rs.iterSlice([a, b, { secs: 1, nanos: 500000000 }, a, { secs: 0, nanos: 0 }])); while (true) { - const _160: [rt.usize, rt.Duration] | rt.Done = iter2.next(); - if (_160 === rt.DONE) { + const _160: [rs.usize, rs.Duration] | rs.Done = iter2.next(); + if (_160 === rs.DONE) { break; } - rt.btreeInsert(seen, _160[1], _160[0] & 0xff); + rs.btreeInsert(seen, _160[1], _160[0] & 0xff); } - const iter3: rt.Iter<[rt.Duration, rt.u8]> = rt.btreeIter(seen); + const iter3: rs.Iter<[rs.Duration, rs.u8]> = rs.btreeIter(seen); while (true) { - const _171: [rt.Duration, rt.u8] | rt.Done = iter3.next(); - if (_171 === rt.DONE) { + const _171: [rs.Duration, rs.u8] | rs.Done = iter3.next(); + if (_171 === rs.DONE) { break; } putDuration(out, _171[0]); - rt.byteVecPush(out, _171[1]); + rs.byteVecPush(out, _171[1]); } - const _181: rt.Iter = rt.iterSlice([a, b, { secs: 1, nanos: 500000000 }]); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.durationHash, rt.durationEq)) as rt.HashSet, _181, undefined, undefined, 58720256); - rt.byteVecPush(out, rt.hashLen(set) & 0xff); - const _192: rt.Duration = rt.durationNew(rt.durationAsSecs(a), rt.durationSubsecNanos(a)); - rt.byteVecPush(out, rt.hashContains(set, _192) ? 1 : 0); + const _181: rs.Iter = rs.iterSlice([a, b, { secs: 1, nanos: 500000000 }]); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.durationHash, rs.durationEq)) as rs.HashSet, _181, undefined, undefined, 58720256); + rs.byteVecPush(out, rs.hashLen(set) & 0xff); + const _192: rs.Duration = rs.durationNew(rs.durationAsSecs(a), rs.durationSubsecNanos(a)); + rs.byteVecPush(out, rs.hashContains(set, _192) ? 1 : 0); } else if (_24 === 8) { - const c: rt.Duration = rt.durationNew(0, rt.durationSubsecNanos(b)); - const d2: rt.Duration = rt.durationFromNanos(rt.u32Rem(n, 1000000) as rt.u64); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.durationDebug(a, f), (f: rt.Formatter) => rt.durationDebug(c, f), (f: rt.Formatter) => rt.durationDebug(d2, f), (f: rt.Formatter) => rt.fmtOption(b, f, rt.durationDebug)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", rt.fmtSpec({ align: ">", width: 16 }, args2[1]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 14 }, args2[2]), "|", rt.fmtSpec({ align: "<", width: 12 }, args2[1]), "|", rt.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", args2[3]])); - const p: rt.usize = rt.u32Rem(n, 13) as rt.usize; - const _234: rt.Duration | undefined = b; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.durationDebug(a, f), (f: rt.Formatter) => rt.durationDebug(c, f), (f: rt.Formatter) => rt.durationDebug(d2, f), rt.fmtCount(p), (f: rt.Formatter) => rt.fmtOption(_234, f, rt.durationDebug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 0 }, args4[0]), "|", rt.fmtSpec({ precision: 3 }, args4[0]), "|", rt.fmtSpec({ precision: 1 }, args4[1]), "|", rt.fmtSpec({ precision: 12 }, args4[2]), "|", rt.fmtSpec({ plus: true }, args4[0]), "|", rt.fmtSpec({ plus: true, width: 12, precision: 2 }, args4[1]), "|", rt.fmtSpec({ align: "<", width: 10, precision: 1 }, args4[2]), "|", rt.fmtSpec({ precision: rt.fmtCountOf(args4[3]) }, args4[0]), "|", rt.fmtSpec({ precision: 1 }, args4[4])])); - const iter4: rt.Iter = rt.iterSlice([1500000000, 2500000000, 1250000, 1350000, 999500, 1999999999]); + const c: rs.Duration = rs.durationNew(0, rs.durationSubsecNanos(b)); + const d2: rs.Duration = rs.durationFromNanos(rs.u32Rem(n, 1000000) as rs.u64); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), (f: rs.Formatter) => rs.fmtOption(b, f, rs.durationDebug)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", rs.fmtSpec({ align: ">", width: 16 }, args2[1]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 14 }, args2[2]), "|", rs.fmtSpec({ align: "<", width: 12 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", args2[3]])); + const p: rs.usize = rs.u32Rem(n, 13) as rs.usize; + const _234: rs.Duration | undefined = b; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(a, f), (f: rs.Formatter) => rs.durationDebug(c, f), (f: rs.Formatter) => rs.durationDebug(d2, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtOption(_234, f, rs.durationDebug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 3 }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[1]), "|", rs.fmtSpec({ precision: 12 }, args4[2]), "|", rs.fmtSpec({ plus: true }, args4[0]), "|", rs.fmtSpec({ plus: true, width: 12, precision: 2 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 10, precision: 1 }, args4[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[3]) }, args4[0]), "|", rs.fmtSpec({ precision: 1 }, args4[4])])); + const iter4: rs.Iter = rs.iterSlice([1500000000, 2500000000, 1250000, 1350000, 999500, 1999999999]); while (true) { - const _250: rt.u64 | rt.Done = iter4.next(); - if (_250 === rt.DONE) { + const _250: rs.u64 | rs.Done = iter4.next(); + if (_250 === rs.DONE) { break; } - const part = rt.durationFromNanos(_250); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.durationDebug(part, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 0 }, args6[0]), " ", rt.fmtSpec({ precision: 1 }, args6[0]), " ", rt.fmtSpec({ precision: 2 }, args6[0])])); + const part = rs.durationFromNanos(_250); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(part, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 2 }, args6[0])])); } } else if (_24 === 10) { - let c2: rt.Duration = a; - c2 = rt.durationAdd(c2, b); + let c2: rs.Duration = a; + c2 = rs.durationAdd(c2, b); putDuration(out, c2); const w: Window.Window = { start: c2, len: b }; - w.start = rt.durationSub(w.start, b); + w.start = rs.durationSub(w.start, b); putDuration(out, w.start); if (w.len !== undefined) { - const _283: rt.Duration = rt.ordMin(a, b, rt.cmpLt(rt.durationCmp)); - w.len = rt.durationSub(w.len, _283); + const _283: rs.Duration = rs.ordMin(a, b, rs.cmpLt(rs.durationCmp)); + w.len = rs.durationSub(w.len, _283); } putOpt(out, w.len); - const v: rt.Duration[] = [a, b]; - v[1] = rt.durationAdd(v[1], a); + const v: rs.Duration[] = [a, b]; + v[1] = rs.durationAdd(v[1], a); putDuration(out, v[1]); - shrink(rt.place(() => v[0], (value) => v[0] = value), b); + shrink(rs.place(() => v[0], (value) => v[0] = value), b); putDuration(out, v[0]); - let d5: rt.Duration = a; + let d5: rs.Duration = a; const _306: Twice.Twice = { _0: b }; - addAssign$ops_AddAssign_durations_Twice_time_Duration(rt.place(() => d5, (value2) => d5 = value2), _306); + addAssign$ops_AddAssign_durations_Twice_time_Duration(rs.place(() => d5, (value2) => d5 = value2), _306); putDuration(out, d5); } else if (_24 === 11) { - let c3: rt.Duration = a; - c3 = rt.durationMul(c3, n); + let c3: rs.Duration = a; + c3 = rs.durationMul(c3, n); putDuration(out, c3); - const v2: rt.Vec = rt.vecFrom([a]); - const at = rt.idx(v2.items, 0); - v2.items[at] = rt.durationDiv(v2.items[at], n); - putDuration(out, v2.items[rt.idx(v2.items, 0)]); + const v2: rs.Vec = rs.vecFrom([a]); + const at = rs.idx(v2.items, 0); + v2.items[at] = rs.durationDiv(v2.items[at], n); + putDuration(out, v2.items[rs.idx(v2.items, 0)]); } else if (_24 === 12) { - const units2: rt.u64 = take(data)[0]; - const wide: Uint8Array = rt.bytes(16); - const k2: rt.usize = rt.min(data.length, rt.byteSliceFrom(wide).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, k2), rt.byteSliceRange(data, 0, k2)); - putDuration(out, rt.durationFromMins(units2)); - putDuration(out, rt.durationFromHours(units2)); - putDuration(out, rt.durationFromNanosU128(rt.u128FromBeBytes(wide))); + const units2: rs.u64 = take(data)[0]; + const wide: Uint8Array = rs.bytes(16); + const k2: rs.usize = rs.min(data.length, rs.byteSliceFrom(wide).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(wide), 0, k2), rs.byteSliceRange(data, 0, k2)); + putDuration(out, rs.durationFromMins(units2)); + putDuration(out, rs.durationFromHours(units2)); + putDuration(out, rs.durationFromNanosU128(rs.u128FromBeBytes(wide))); } else if (_24 === 13) { - const _346: rt.Duration = rt.durationNew(0, rt.u32Rem(n, 1000000000)); - const parts: rt.Duration[] = [a, b, _346]; - putDuration(out, rt.durationSum(rt.iterSlice(parts))); - putDuration(out, rt.durationSum(rt.iterSlice([b, a]))); - putDuration(out, rt.durationSum(rt.iterFilter(rt.iterSlice(parts), (d7: rt.Duration): boolean => { - return !rt.durationIsZero(d7); + const _346: rs.Duration = rs.durationNew(0, rs.u32Rem(n, 1000000000)); + const parts: rs.Duration[] = [a, b, _346]; + putDuration(out, rs.durationSum(rs.iterSlice(parts))); + putDuration(out, rs.durationSum(rs.iterSlice([b, a]))); + putDuration(out, rs.durationSum(rs.iterFilter(rs.iterSlice(parts), (d7: rs.Duration): boolean => { + return !rs.durationIsZero(d7); }))); } else { - const iter5: rt.Iter = rt.iterSlice([{ secs: 0, nanos: 0 }, { secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, { secs: 0, nanos: 999 }]); + const iter5: rs.Iter = rs.iterSlice([{ secs: 0, nanos: 0 }, { secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, { secs: 0, nanos: 999 }]); while (true) { - const _367: rt.Duration | rt.Done = iter5.next(); - if (_367 === rt.DONE) { + const _367: rs.Duration | rs.Done = iter5.next(); + if (_367 === rs.DONE) { break; } putDuration(out, _367); } putDuration(out, { secs: 1, nanos: 500000000 }); putDuration(out, { secs: 0, nanos: 0 }); - putOpt(out, rt.durationCheckedAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, rt.durationFromNanos(1))); - const _379: rt.Duration | undefined = thenSome$1jqdi5p(rt.durationCmp(b, { secs: 1, nanos: 500000000 }) === 1, b); + putOpt(out, rs.durationCheckedAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromNanos(1))); + const _379: rs.Duration | undefined = thenSome$00rtwed(rs.durationCmp(b, { secs: 1, nanos: 500000000 }) === 1, b); const w2: Window.Window = { start: a, len: _379 }; const _388: Window.Window = Window.default$Default(); - rt.byteVecPush(out, Window.eq$cmp_PartialEq(w2, _388) ? 1 : 0); - rt.byteVecPush(out, Window.cmp$cmp_Ord(w2, { start: b, len: undefined }) < 0 ? 1 : 0); + rs.byteVecPush(out, Window.eq$cmp_PartialEq(w2, _388) ? 1 : 0); + rs.byteVecPush(out, Window.cmp$cmp_Ord(w2, { start: b, len: undefined }) < 0 ? 1 : 0); const _400: Window.Window = copy$durations_Window(Window.default$Default()); - const _398: rt.Iter = rt.iterSlice([copy$durations_Window(w2), copy$durations_Window(w2), _400]); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Window.hash$Hash_hash_DefaultHasher as (a0: Window.Window, a1: rt.Hasher) => undefined, Window.eq$cmp_PartialEq)) as rt.HashSet, _398, undefined, undefined, 29360128)) & 0xff); + const _398: rs.Iter = rs.iterSlice([copy$durations_Window(w2), copy$durations_Window(w2), _400]); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Window.hash$Hash_hash_DefaultHasher as (a0: Window.Window, a1: rs.Hasher) => undefined, Window.eq$cmp_PartialEq)) as rs.HashSet, _398, undefined, undefined, 29360128)) & 0xff); const _413: Window.Window = Window.default$Default(); - const args8: rt.Fmt[] = [(f: rt.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rt.Formatter) => Window.fmt$fmt_Debug(_413, f)]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[1])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Window.fmt$fmt_Debug(w2, f), (f: rs.Formatter) => Window.fmt$fmt_Debug(_413, f)]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[1])])); } } diff --git a/ts/fixtures/lang/durations/expected/harness.ts b/ts/fixtures/lang/durations/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/durations/expected/harness.ts +++ b/ts/fixtures/lang/durations/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/durations/expected/lib.ts b/ts/fixtures/lang/durations/expected/lib.ts index f0ca38cb9..5721257ae 100644 --- a/ts/fixtures/lang/durations/expected/lib.ts +++ b/ts/fixtures/lang/durations/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { durations } from "./durations.ts"; import type * as Window from "./durations.Window.ts"; @@ -12,8 +12,8 @@ export function copy$durations_Window(v: Window.Window): Window.Window { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["durations::durations", durations as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["durations::durations", durations as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/durations/src/durations.rs b/ts/fixtures/lang/durations/src/durations.rs index 46c47e583..03d0b75c5 100644 --- a/ts/fixtures/lang/durations/src/durations.rs +++ b/ts/fixtures/lang/durations/src/durations.rs @@ -60,7 +60,7 @@ impl std::ops::AddAssign for Duration { } } -/// `-=` through a `&mut`, which is an `rt.Place`. +/// `-=` through a `&mut`, which is an `rs.Place`. fn shrink(d: &mut Duration, by: Duration) { *d -= by; } diff --git a/ts/fixtures/lang/dyns/expected/core/bool.ts b/ts/fixtures/lang/dyns/expected/core/bool.ts index 17d957542..05e0dcab5 100644 --- a/ts/fixtures/lang/dyns/expected/core/bool.ts +++ b/ts/fixtures/lang/dyns/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/dyns/expected/core/option.ts b/ts/fixtures/lang/dyns/expected/core/option.ts index 6b19dda9b..62a00721a 100644 --- a/ts/fixtures/lang/dyns/expected/core/option.ts +++ b/ts/fixtures/lang/dyns/expected/core/option.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Any from "../core/any.Any.ts"; import type * as Shape from "../dyns.Shape.ts"; import type * as Tagged from "../dyns.Tagged.ts"; -export function isSomeAnd$13v37g1(self: rt.Arc | undefined, f: (a0: rt.Arc) => boolean): boolean { +export function isSomeAnd$11ghftu(self: rs.Arc | undefined, f: (a0: rs.Arc) => boolean): boolean { if (self === undefined) { return false; } @@ -19,105 +19,105 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1p9q0qv(self: rt.Arc> | undefined, f: (a0: rt.Arc>) => rt.u32): rt.u32 | undefined { +export function map$1rkcfqi(self: rs.Arc> | undefined, f: (a0: rs.Arc>) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1i542n2(self: rt.Arc | undefined, f: (a0: rt.Arc) => rt.u32): rt.u32 | undefined { +export function map$1mach0o(self: rs.Arc | undefined, f: (a0: rs.Arc) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0oedb57(self: rt.Arc> | undefined, f: (a0: rt.Arc>) => [rt.usize, rt.usize | undefined]): [rt.usize, rt.usize | undefined] | undefined { +export function map$1b57zy8(self: rs.Arc> | undefined, f: (a0: rs.Arc>) => [rs.usize, rs.usize | undefined]): [rs.usize, rs.usize | undefined] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$08a6hpg(self: Tagged.Tagged | undefined, f: (a0: Tagged.Tagged) => rt.u8): rt.u8 | undefined { +export function map$11l9b8r(self: Tagged.Tagged | undefined, f: (a0: Tagged.Tagged) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1qfllpb(self: rt.Iter | undefined, f: (a0: rt.Iter) => rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function map$0vt270f(self: rs.Iter | undefined, f: (a0: rs.Iter) => rs.u8 | undefined): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1qzd1bs(self: rt.Arc> | undefined, f: (a0: rt.Arc>) => rt.u32): rt.u32 | undefined { +export function map$13cu53u(self: rs.Arc> | undefined, f: (a0: rs.Arc>) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0j05j69(self: rt.Arc | undefined, f: (a0: rt.Arc) => rt.u32): rt.u32 | undefined { +export function map$1bn5ufk(self: rs.Arc | undefined, f: (a0: rs.Arc) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0z7s8q7(self: [Tagged.Tagged, Tagged.Tagged] | undefined, f: (a0: [Tagged.Tagged, Tagged.Tagged]) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$1aeqf1p(self: [Tagged.Tagged, Tagged.Tagged] | undefined, f: (a0: [Tagged.Tagged, Tagged.Tagged]) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { +export function mapOr$0z4nmg2(self: [rs.u8, rs.ByteSlice] | undefined, default_: [rs.u8, rs.ByteSlice], f: (a0: [rs.u8, rs.ByteSlice]) => [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] { if (self === undefined) { return default_; } return f(self); } -export function mapOr$06rr3sb(self: rt.u8 | undefined, default_: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { +export function mapOr$19a4gco(self: rs.u8 | undefined, default_: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return default_; } return f(self); } -export function andThen$0v0bj8w(self: rt.Iter | undefined, f: (a0: rt.Iter) => Tagged.Tagged | undefined): Tagged.Tagged | undefined { +export function andThen$1xlvufy(self: rs.Iter | undefined, f: (a0: rs.Iter) => Tagged.Tagged | undefined): Tagged.Tagged | undefined { if (self === undefined) { return undefined; } return f(self); } -export function andThen$0ntiuws(self: rt.Iter | undefined, f: (a0: rt.Iter) => rt.u8 | undefined): rt.u8 | undefined { +export function andThen$0imujmv(self: rs.Iter | undefined, f: (a0: rs.Iter) => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/dyns/expected/core/result.ts b/ts/fixtures/lang/dyns/expected/core/result.ts index c6d3b1521..2df1cc1b8 100644 --- a/ts/fixtures/lang/dyns/expected/core/result.ts +++ b/ts/fixtures/lang/dyns/expected/core/result.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Result_sync_Arc_u32_sync_Arc_dyn_Any_marker_Sync_marker_Send, drop$Result_tuple2_usize_u32_Rc_dyn_Any, drop$Result_tuple2_usize_u8_sync_Arc_dyn_Any_marker_Sync_marker_Send, drop$Result_u16_boxed_Box_dyn_Any } from "../lib.ts"; import type * as Any from "../core/any.Any.ts"; import type * as Shape from "../dyns.Shape.ts"; import type * as Square from "../dyns.Square.ts"; -export function ok$00p9ap8(self: rt.Result, rt.Arc>): rt.Arc | undefined { - let _0!: rt.Arc | undefined; +export function ok$1oks8md(self: rs.Result, rs.Arc>): rs.Arc | undefined { + let _0!: rs.Arc | undefined; if (self.ok) { _0 = self.value; } else { @@ -20,8 +20,8 @@ export function ok$00p9ap8(self: rt.Result, rt.Arc>): rt return _0; } -export function ok$1vbcgd7(self: rt.Result<[rt.usize, rt.u32], rt.Arc>): [rt.usize, rt.u32] | undefined { - let _0!: [rt.usize, rt.u32] | undefined; +export function ok$0y6a1w6(self: rs.Result<[rs.usize, rs.u32], rs.Arc>): [rs.usize, rs.u32] | undefined { + let _0!: [rs.usize, rs.u32] | undefined; if (self.ok) { _0 = self.value; } else { @@ -34,8 +34,8 @@ export function ok$1vbcgd7(self: rt.Result<[rt.usize, rt.u32], rt.Arc>) return _0; } -export function ok$0lceojf(self: rt.Result<[rt.usize, rt.u8], rt.Arc>): [rt.usize, rt.u8] | undefined { - let _0!: [rt.usize, rt.u8] | undefined; +export function ok$1lmsnde(self: rs.Result<[rs.usize, rs.u8], rs.Arc>): [rs.usize, rs.u8] | undefined { + let _0!: [rs.usize, rs.u8] | undefined; if (self.ok) { _0 = self.value; } else { @@ -48,8 +48,8 @@ export function ok$0lceojf(self: rt.Result<[rt.usize, rt.u8], rt.Arc>): return _0; } -export function ok$1a014tb(self: rt.Result): rt.u16 | undefined { - let _0!: rt.u16 | undefined; +export function ok$1wwd922(self: rs.Result): rs.u16 | undefined { + let _0!: rs.u16 | undefined; if (self.ok) { _0 = self.value; } else { @@ -62,35 +62,35 @@ export function ok$1a014tb(self: rt.Result): rt.u16 | undefined return _0; } -export function map$1v8vvnp(self: rt.Result, rt.Arc>, op: (a0: rt.Arc) => [rt.usize, rt.u32]): rt.Result<[rt.usize, rt.u32], rt.Arc> { +export function map$0njbm3o(self: rs.Result, rs.Arc>, op: (a0: rs.Arc) => [rs.usize, rs.u32]): rs.Result<[rs.usize, rs.u32], rs.Arc> { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result<[rt.usize, rt.u32], rt.Arc>; + return self as rs.Result<[rs.usize, rs.u32], rs.Arc>; } -export function map$1p3mw15(self: rt.Result, op: (a0: Square.Square) => rt.u16): rt.Result { +export function map$0tx2z7o(self: rs.Result, op: (a0: Square.Square) => rs.u16): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function map$1wuk0uc(self: rt.Result, rt.BorrowError>, op: (a0: rt.RefCell) => rt.u8): rt.Result { +export function map$11lf952(self: rs.Result, rs.BorrowError>, op: (a0: rs.RefCell) => rs.u8): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function map$0zujxcv(self: rt.Result, rt.Arc>, op: (a0: rt.Arc<[rt.u8, rt.u8]>) => [rt.usize, rt.u8]): rt.Result<[rt.usize, rt.u8], rt.Arc> { +export function map$0f0ko1g(self: rs.Result, rs.Arc>, op: (a0: rs.Arc<[rs.u8, rs.u8]>) => [rs.usize, rs.u8]): rs.Result<[rs.usize, rs.u8], rs.Arc> { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result<[rt.usize, rt.u8], rt.Arc>; + return self as rs.Result<[rs.usize, rs.u8], rs.Arc>; } -export function unwrapOr$09hp2h5(self: rt.Result, default_: rt.u8): rt.u8 { +export function unwrapOr$0k78oya(self: rs.Result, default_: rs.u8): rs.u8 { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/dyns/expected/core/task/poll.ts b/ts/fixtures/lang/dyns/expected/core/task/poll.ts index df9d71c12..052886668 100644 --- a/ts/fixtures/lang/dyns/expected/core/task/poll.ts +++ b/ts/fixtures/lang/dyns/expected/core/task/poll.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function isReady$1ntq2i8(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$1olyx0w(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; diff --git a/ts/fixtures/lang/dyns/expected/dyns.Chunks.ts b/ts/fixtures/lang/dyns/expected/dyns.Chunks.ts index 475d0c19e..d1ebf2956 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Chunks.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Chunks.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Lends its bytes as parts, as moq's transports lend a stream's chunks. */ -export type Chunks = { chunks$Chunks: () => rt.Iter }; +export type Chunks = { chunks$Chunks: () => rs.Iter }; //# sourceMappingURL=dyns.Chunks.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Countdown.ts b/ts/fixtures/lang/dyns/expected/dyns.Countdown.ts index 0402b4d23..d231b461a 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Countdown.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Countdown.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { DROPS } from "./dyns.ts"; /** The crate's own iterator, counting down, which logs 200 as it drops. */ export class Countdown { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } @@ -16,18 +16,18 @@ export class Countdown { } } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; return self._0; } - return rt.DONE; + return rs.DONE; } export function drop$ops_Drop(_self: Countdown): void { - rt.localKeyWithBorrowMut(DROPS, (d: rt.ByteVec): undefined => { - rt.byteVecPush(d, 200); + rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): undefined => { + rs.byteVecPush(d, 200); }); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Guarded.ts b/ts/fixtures/lang/dyns/expected/dyns.Guarded.ts index e525e306a..6a909f6fa 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Guarded.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Guarded.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Held from "./dyns.Held.ts"; import type * as Noisy from "./dyns.Noisy.ts"; import type * as Shape from "./dyns.Shape.ts"; /** A struct with a `Drop` impl of its own, which runs before its fields drop. */ export class Guarded { - log: rt.Arc>; + log: rs.Arc>; value: T; - constructor(log: rt.Arc>, value: T) { + constructor(log: rs.Arc>, value: T) { this.log = log; this.value = value; } } export function drop$ops_Drop_dyn_dyns_Shape(self: Guarded): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 238); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 238); + rs.refMutRelease(_5); } export function drop$ops_Drop_dyns_Held(self: Guarded): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 238); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 238); + rs.refMutRelease(_5); } export function drop$ops_Drop_dyns_Noisy(self: Guarded): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 238); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 238); + rs.refMutRelease(_5); } //# sourceMappingURL=dyns.Guarded.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Held.ts b/ts/fixtures/lang/dyns/expected/dyns.Held.ts index 255b678e6..cc5f246b7 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Held.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Held.ts @@ -1,41 +1,41 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$dyns_Held } from "./lib.ts"; import * as Noisy from "./dyns.Noisy.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Held): rt.u8 { +export function sides$dyns_Shape(_self: Held): rs.u8 { return 4; } -export function intoArea$dyns_Shape(self: Held): rt.u32 { - const _0: rt.u32 = rt.u32WrappingAdd(area$dyns_Shape(self), 1); +export function intoArea$dyns_Shape(self: Held): rs.u32 { + const _0: rs.u32 = rs.u32WrappingAdd(area$dyns_Shape(self), 1); drop$dyns_Held(self); return _0; } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Held, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Held, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Held, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Held, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } /** An enum, which JS copies, holding a value that drops. */ export type Held = { tag: "Empty" } | { tag: "Full"; _0: Noisy.Noisy }; -export function area$dyns_Shape(self: Held): rt.u32 { +export function area$dyns_Shape(self: Held): rs.u32 { if (self.tag === "Empty") { return 0; } return Noisy.area$dyns_Shape(self._0); } -export function grow$dyns_Shape(self: rt.Place, by: rt.u8): void { +export function grow$dyns_Shape(self: rs.Place, by: rs.u8): void { if (self.v.tag !== "Empty") { Noisy.grow$dyns_Shape(self.v._0, by); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Hits.ts b/ts/fixtures/lang/dyns/expected/dyns.Hits.ts index 94a502691..56092d03f 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Hits.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Hits.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Hits): rt.u8 { +export function sides$dyns_Shape(_self: Hits): rs.u8 { return 4; } -export function intoArea$dyns_Shape(self: Hits): rt.u32 { - return rt.u32WrappingAdd(area$dyns_Shape(self), 1); +export function intoArea$dyns_Shape(self: Hits): rs.u32 { + return rs.u32WrappingAdd(area$dyns_Shape(self), 1); } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Hits, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Hits, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Hits, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Hits, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } /** Counts its calls, which every `Arc` of it sees. */ export interface Hits { - _0: rt.Atomic; + _0: rs.Atomic; } -export function area$dyns_Shape(self: Hits): rt.u32 { - return rt.atomicFetch(self._0, rt.u32WrappingAdd, 1, 0); +export function area$dyns_Shape(self: Hits): rs.u32 { + return rs.atomicFetch(self._0, rs.u32WrappingAdd, 1, 0); } -export function grow$dyns_Shape(self: Hits, by: rt.u8): void { - const _3: rt.u32 = rt.u32WrappingAdd(self._0.v, by as rt.u32); +export function grow$dyns_Shape(self: Hits, by: rs.u8): void { + const _3: rs.u32 = rs.u32WrappingAdd(self._0.v, by as rs.u32); self._0.v = _3; } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Hook.ts b/ts/fixtures/lang/dyns/expected/dyns.Hook.ts index b63d9fbae..431a745a9 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Hook.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Hook.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A boxed callback kept in a struct, as kio keeps its waiters' polls. */ export class Hook { - f: (a0: rt.u8) => rt.u32; + f: (a0: rs.u8) => rs.u32; - constructor(f: (a0: rt.u8) => rt.u32) { + constructor(f: (a0: rs.u8) => rs.u32) { this.f = f; } [Symbol.dispose](): void { - rt.drop(this.f); + rs.drop(this.f); } } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Keyed.ts b/ts/fixtures/lang/dyns/expected/dyns.Keyed.ts index 13db6f844..0aff1ddb4 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Keyed.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Keyed.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A trait over `Any`, whose objects upcast to `dyn Any`. */ -export type Keyed = { key$Keyed: () => rt.u32 }; +export type Keyed = { key$Keyed: () => rs.u32 }; //# sourceMappingURL=dyns.Keyed.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Lease.ts b/ts/fixtures/lang/dyns/expected/dyns.Lease.ts index 8d5b70a2e..fd8d368fe 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Lease.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Lease.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Lease { - _0: rt.ByteVec; - _1: rt.usize; + _0: rs.ByteVec; + _1: rs.usize; } -export function chunks$dyns_Chunks(self: Lease): rt.Iter { - return rt.iterDyn(rt.byteSliceChunks(rt.byteVecSlice(self._0), self._1)); +export function chunks$dyns_Chunks(self: Lease): rs.Iter { + return rs.iterDyn(rs.byteSliceChunks(rs.byteVecSlice(self._0), self._1)); } //# sourceMappingURL=dyns.Lease.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Looped.ts b/ts/fixtures/lang/dyns/expected/dyns.Looped.ts index 76133d5d0..2d0eac212 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Looped.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Looped.ts @@ -1,35 +1,35 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Shape from "./dyns.Shape.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Looped): rt.u8 { +export function sides$dyns_Shape(_self: Looped): rs.u8 { return 4; } -export function intoArea$dyns_Shape(self: Looped): rt.u32 { - const _0: rt.u32 = rt.u32WrappingAdd(area$dyns_Shape(self), 1); +export function intoArea$dyns_Shape(self: Looped): rs.u32 { + const _0: rs.u32 = rs.u32WrappingAdd(area$dyns_Shape(self), 1); self[Symbol.dispose](); return _0; } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Looped, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Looped, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Looped, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Looped, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } /** A shape holding a `Weak` of itself as a trait object, made inside `Rc::new_cyclic`. */ export class Looped { - side: rt.u8; - me: rt.Weak; + side: rs.u8; + me: rs.Weak; - constructor(side: rt.u8, me: rt.Weak) { + constructor(side: rs.u8, me: rs.Weak) { this.side = side; this.me = me; } @@ -39,12 +39,12 @@ export class Looped { } } -export function area$dyns_Shape(self: Looped): rt.u32 { - return rt.u32Add(self.side as rt.u32, 1); +export function area$dyns_Shape(self: Looped): rs.u32 { + return rs.u32Add(self.side as rs.u32, 1); } -export function grow$dyns_Shape(self: Looped, by: rt.u8): void { - self.side = rt.u8WrappingAdd(self.side, by); +export function grow$dyns_Shape(self: Looped, by: rs.u8): void { + self.side = rs.u8WrappingAdd(self.side, by); } //# sourceMappingURL=dyns.Looped.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Named.ts b/ts/fixtures/lang/dyns/expected/dyns.Named.ts index 62eed4cdc..bce537b7b 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Named.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Named.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export type Named = - | { label$Named: () => string; fmt$Debug: (a0: rt.Formatter) => rt.Result; area$Shape: () => rt.u32; grow$Shape: (a0: rt.u8) => void; sides$Shape: () => rt.u8; intoArea$Shape: () => rt.u32; larger$Shape: (a0: rt.u32) => rt.u32; tally$Shape: (a0: rt.Place) => void }; + | { label$Named: () => string; fmt$Debug: (a0: rs.Formatter) => rs.Result; area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; //# sourceMappingURL=dyns.Named.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts b/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts index f75b059fb..3a6ac733c 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Noisy.ts @@ -1,34 +1,34 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Noisy): rt.u8 { +export function sides$dyns_Shape(_self: Noisy): rs.u8 { return 4; } -export function intoArea$dyns_Shape(self: Noisy): rt.u32 { - const _0: rt.u32 = rt.u32WrappingAdd(area$dyns_Shape(self), 1); +export function intoArea$dyns_Shape(self: Noisy): rs.u32 { + const _0: rs.u32 = rs.u32WrappingAdd(area$dyns_Shape(self), 1); self[Symbol.dispose](); return _0; } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Noisy, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Noisy, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Noisy, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Noisy, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } /** A shape that notes its id in a log as it drops. */ export class Noisy { - _0: rt.u8; - _1: rt.Arc>; + _0: rs.u8; + _1: rs.Arc>; - constructor(_0: rt.u8, _1: rt.Arc>) { + constructor(_0: rs.u8, _1: rs.Arc>) { this._0 = _0; this._1 = _1; } @@ -39,18 +39,18 @@ export class Noisy { } } -export function area$dyns_Shape(self: Noisy): rt.u32 { - return self._0 as rt.u32; +export function area$dyns_Shape(self: Noisy): rs.u32 { + return self._0 as rs.u32; } -export function grow$dyns_Shape(self: Noisy, by: rt.u8): void { - self._0 = rt.u8WrappingAdd(self._0, by); +export function grow$dyns_Shape(self: Noisy, by: rs.u8): void { + self._0 = rs.u8WrappingAdd(self._0, by); } export function drop$ops_Drop(self: Noisy): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1.value); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1.value); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=dyns.Noisy.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Resuming.ts b/ts/fixtures/lang/dyns/expected/dyns.Resuming.ts index 58727756b..c0c4927be 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Resuming.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Resuming.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Counts down to its end, then starts over, as a fused iterator never does. */ export interface Resuming { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Resuming): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Resuming): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 === undefined) { self._0 = 2; - return rt.DONE; + return rs.DONE; } - const n: rt.u8 = _2; + const n: rs.u8 = _2; self._0 = n; return n; } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Shape.ts b/ts/fixtures/lang/dyns/expected/dyns.Shape.ts index c4821353c..39c1aa984 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Shape.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Shape.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export type Shape = - | { area$Shape: () => rt.u32; grow$Shape: (a0: rt.u8) => void; sides$Shape: () => rt.u8; intoArea$Shape: () => rt.u32; larger$Shape: (a0: rt.u32) => rt.u32; tally$Shape: (a0: rt.Place) => void }; + | { area$Shape: () => rs.u32; grow$Shape: (a0: rs.u8) => void; sides$Shape: () => rs.u8; intoArea$Shape: () => rs.u32; larger$Shape: (a0: rs.u32) => rs.u32; tally$Shape: (a0: rs.Place) => void }; //# sourceMappingURL=dyns.Shape.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Shown.ts b/ts/fixtures/lang/dyns/expected/dyns.Shown.ts index e0275f585..91b44f57c 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Shown.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Shown.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Writes a `&dyn Debug` by calling its `fmt`, not through a placeholder. */ export interface Shown { - _0: rt.Fmt; + _0: rs.Fmt; } -export function fmt$fmt_Debug(self: Shown, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Shown, f: rs.Formatter): rs.Result { return self._0(f); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Square.ts b/ts/fixtures/lang/dyns/expected/dyns.Square.ts index 2f400fa58..a5f817b9a 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Square.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Square.ts @@ -1,51 +1,51 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$dyns_Square } from "./lib.ts"; import type * as Any from "./core/any.Any.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Square): rt.u8 { +export function sides$dyns_Shape(_self: Square): rs.u8 { return 4; } -export function intoArea$dyns_Shape(self: Square): rt.u32 { - return rt.u32WrappingAdd(area$dyns_Shape(self), 1); +export function intoArea$dyns_Shape(self: Square): rs.u32 { + return rs.u32WrappingAdd(area$dyns_Shape(self), 1); } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Square, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Square, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Square, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Square, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } -export function fmt$fmt_Debug(self: Square, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Square, f: rs.Formatter): rs.Result { const _3: string = "Square"; const _4: string = "side"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self.side, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5)); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.side, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); } export interface Square { - side: rt.u16; + side: rs.u16; } -export function area$dyns_Shape(self: Square): rt.u32 { - return rt.u32Mul(self.side as rt.u32, self.side as rt.u32); +export function area$dyns_Shape(self: Square): rs.u32 { + return rs.u32Mul(self.side as rs.u32, self.side as rs.u32); } -export function grow$dyns_Shape(self: Square, by: rt.u8): void { - self.side = rt.u16WrappingAdd(self.side, by as rt.u16); +export function grow$dyns_Shape(self: Square, by: rs.u8): void { + self.side = rs.u16WrappingAdd(self.side, by as rs.u16); } export function label$dyns_Named(self: Square): string { const arg = self.side; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg, f)]; - return rt.fmtFormat(["square ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; + return rs.fmtFormat(["square ", args2[0]]); } export function asAny$dyns_Erased(self: Square): Any.Any { @@ -56,8 +56,8 @@ export function asAnyMut$dyns_Erased(self: Square): Any.Any { return new of$dyns_Square(self); } -export function key$dyns_Keyed(self: Square): rt.u32 { - return self.side as rt.u32; +export function key$dyns_Keyed(self: Square): rs.u32 { + return self.side as rs.u32; } //# sourceMappingURL=dyns.Square.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tagged.ts b/ts/fixtures/lang/dyns/expected/dyns.Tagged.ts index fc6438c2d..3f9d4699f 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tagged.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tagged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { DROPS } from "./dyns.ts"; /** Logs its tag as it drops. */ export class Tagged { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } @@ -17,8 +17,8 @@ export class Tagged { } export function drop$ops_Drop(self: Tagged): void { - rt.localKeyWithBorrowMut(DROPS, (d: rt.ByteVec): undefined => { - rt.byteVecPush(d, self._0); + rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): undefined => { + rs.byteVecPush(d, self._0); }); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tail.ts b/ts/fixtures/lang/dyns/expected/dyns.Tail.ts index f8cb827cb..7ec64153e 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tail.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tail.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Noisy from "./dyns.Noisy.ts"; /** @@ -8,11 +8,11 @@ import type * as Noisy from "./dyns.Noisy.ts"; * before it stay where they are, and drop before it. */ export class Tail { - count: rt.u8; + count: rs.u8; head: Noisy.Noisy; value: T; - constructor(count: rt.u8, head: Noisy.Noisy, value: T) { + constructor(count: rs.u8, head: Noisy.Noisy, value: T) { this.count = count; this.head = head; this.value = value; @@ -20,7 +20,7 @@ export class Tail { [Symbol.dispose](): void { this.head[Symbol.dispose](); - rt.drop(this.value); + rs.drop(this.value); } } diff --git a/ts/fixtures/lang/dyns/expected/dyns.Ticks.ts b/ts/fixtures/lang/dyns/expected/dyns.Ticks.ts index 47d63a26b..8f9479273 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Ticks.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Ticks.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A future of the crate's own, which JS keeps as an object: pending until it has counted * down, waking its waker each time, and noting its count as it drops. */ export class Ticks { - left: rt.u8; - polls: rt.u8; - log: rt.Arc>; + left: rs.u8; + polls: rs.u8; + log: rs.Arc>; - constructor(left: rt.u8, polls: rt.u8, log: rt.Arc>) { + constructor(left: rs.u8, polls: rs.u8, log: rs.Arc>) { this.left = left; this.polls = polls; this.log = log; @@ -23,22 +23,22 @@ export class Ticks { } } -export function poll$Future(self: Ticks, cx: rt.Context): rt.Poll { - const _3: rt.u8 = rt.u8WrappingAdd(self.polls, 1); +export function poll$Future(self: Ticks, cx: rs.Context): rs.Poll { + const _3: rs.u8 = rs.u8WrappingAdd(self.polls, 1); self.polls = _3; - const _9: rt.u8 | undefined = rt.u8CheckedSub(self.left, 1); + const _9: rs.u8 | undefined = rs.u8CheckedSub(self.left, 1); if (_9 === undefined) { return self.polls; } self.left = _9; cx.wakeByRef(); - return rt.Pending; + return rs.Pending; } export function drop$ops_Drop(self: Ticks): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 240 | self.polls); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 240 | self.polls); + rs.refMutRelease(_5); } //# sourceMappingURL=dyns.Ticks.ts.map diff --git a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts index e1e2a0652..c8358a26c 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.Tri.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.Tri.ts @@ -1,71 +1,71 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$dyns_Tri, ofPlace$dyns_Tri } from "./lib.ts"; import type * as Any from "./core/any.Any.ts"; /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape(self: Tri, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape(self), other); +export function larger$dyns_Shape(self: Tri, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape(self: Tri, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape(self: Tri, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape(self)); } -export function fmt$fmt_Debug(self: Tri, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Tri, f: rs.Formatter): rs.Result { if (self.tag === "Flat") { - return rt.fmtWriteStr(f, "Flat"); + return rs.fmtWriteStr(f, "Flat"); } const _6: string = "Tall"; - const _7: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); + const _7: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); } /** An enum, which JS copies, so `&mut self` reaches it through a place. */ -export type Tri = { tag: "Flat" } | { tag: "Tall"; _0: rt.u8 }; +export type Tri = { tag: "Flat" } | { tag: "Tall"; _0: rs.u8 }; -export function area$dyns_Shape(self: Tri): rt.u32 { +export function area$dyns_Shape(self: Tri): rs.u32 { if (self.tag === "Flat") { return 0; } - return rt.u32Mul(self._0 as rt.u32, 3); + return rs.u32Mul(self._0 as rs.u32, 3); } -export function grow$dyns_Shape(self: rt.Place, by: rt.u8): void { +export function grow$dyns_Shape(self: rs.Place, by: rs.u8): void { let _3!: Tri; if (self.v.tag === "Flat") { - if (!(rt.u8Rem(by, 2) === 0)) { + if (!(rs.u8Rem(by, 2) === 0)) { _3 = { tag: "Tall", _0: by } as Tri; } else { _3 = { tag: "Flat" } as Tri; } } else { - _3 = { tag: "Tall", _0: rt.u8WrappingAdd(self.v._0, by) } as Tri; + _3 = { tag: "Tall", _0: rs.u8WrappingAdd(self.v._0, by) } as Tri; } self.v = _3; } /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape(_self: Tri): rt.u8 { +export function sides$dyns_Shape(_self: Tri): rs.u8 { return 3; } -export function intoArea$dyns_Shape(self: Tri): rt.u32 { - return rt.u32WrappingMul(area$dyns_Shape(self), 2); +export function intoArea$dyns_Shape(self: Tri): rs.u32 { + return rs.u32WrappingMul(area$dyns_Shape(self), 2); } export function label$dyns_Named(self: Tri): string { - const args2: rt.Fmt[] = [(f: rt.Formatter) => fmt$fmt_Debug(self, f)]; - return rt.fmtFormat(["tri ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => fmt$fmt_Debug(self, f)]; + return rs.fmtFormat(["tri ", args2[0]]); } export function asAny$dyns_Erased(self: Tri): Any.Any { return new of$dyns_Tri(self); } -export function asAnyMut$dyns_Erased(self: rt.Place): Any.Any { +export function asAnyMut$dyns_Erased(self: rs.Place): Any.Any { return new ofPlace$dyns_Tri(self); } diff --git a/ts/fixtures/lang/dyns/expected/dyns.ts b/ts/fixtures/lang/dyns/expected/dyns.ts index 87584c5cb..cb9f1628e 100644 --- a/ts/fixtures/lang/dyns/expected/dyns.ts +++ b/ts/fixtures/lang/dyns/expected/dyns.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$dyns_Tri, drop$Result_Rc_dyns_Noisy_Rc_dyn_Any, drop$Result_Rc_dyns_Square_Rc_dyn_Any, drop$Result_Rc_dyns_Tri_Rc_dyn_Any, drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError, drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError, drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError, drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape, drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape, drop$cell_RefCell_dyns_Guarded_dyns_Held, drop$dyns_Guarded_dyns_Held, drop$dyns_Guarded_dyns_Noisy, drop$tuple2_dyns_Tagged_dyns_Tagged, of$Option_u8, of$dyns_Hits, of$dyns_Lease, of$dyns_Looped, of$dyns_Noisy, of$dyns_Square, of$dyns_Tri, of$ref_str, of$tuple2_u8_u8, of$u32, of$u8, of$unit, ofPlace$Option_u8, ofPlace$dyns_Held, ofPlace$dyns_Tri, ofPlace$u32, ofPlace$u8, ofPlace$unit } from "./lib.ts"; import type * as Any from "./core/any.Any.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; -import { isSomeAnd$13v37g1, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1p9q0qv as option_map$1p9q0qv, map$1i542n2 as option_map$1i542n2, map$0oedb57 as option_map$0oedb57, map$08a6hpg as option_map$08a6hpg, map$1qfllpb as option_map$1qfllpb, map$0cs071d as option_map$0cs071d, map$1qzd1bs as option_map$1qzd1bs, map$0j05j69 as option_map$0j05j69, map$0z7s8q7 as option_map$0z7s8q7, mapOr$1surhce as option_mapOr$1surhce, mapOr$1ttssgs as option_mapOr$1ttssgs, mapOr$06rr3sb as option_mapOr$06rr3sb, andThen$0v0bj8w as option_andThen$0v0bj8w, andThen$0ntiuws as option_andThen$0ntiuws } from "./core/option.ts"; -import { ok$00p9ap8, ok$1vbcgd7, ok$0lceojf, ok$1a014tb, map$1v8vvnp as result_map$1v8vvnp, map$1p3mw15 as result_map$1p3mw15, map$1wuk0uc as result_map$1wuk0uc, map$0zujxcv as result_map$0zujxcv, unwrapOr$09hp2h5 as result_unwrapOr$09hp2h5 } from "./core/result.ts"; -import { isReady$1ntq2i8 } from "./core/task/poll.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; +import { isSomeAnd$11ghftu, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1rkcfqi as option_map$1rkcfqi, map$1mach0o as option_map$1mach0o, map$1b57zy8 as option_map$1b57zy8, map$11l9b8r as option_map$11l9b8r, map$0vt270f as option_map$0vt270f, map$1yjmt5m as option_map$1yjmt5m, map$13cu53u as option_map$13cu53u, map$1bn5ufk as option_map$1bn5ufk, map$1aeqf1p as option_map$1aeqf1p, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0z4nmg2 as option_mapOr$0z4nmg2, mapOr$19a4gco as option_mapOr$19a4gco, andThen$1xlvufy as option_andThen$1xlvufy, andThen$0imujmv as option_andThen$0imujmv } from "./core/option.ts"; +import { ok$1oks8md, ok$0y6a1w6, ok$1lmsnde, ok$1wwd922, map$0njbm3o as result_map$0njbm3o, map$0tx2z7o as result_map$0tx2z7o, map$11lf952 as result_map$11lf952, map$0f0ko1g as result_map$0f0ko1g, unwrapOr$0k78oya as result_unwrapOr$0k78oya } from "./core/result.ts"; +import { isReady$1olyx0w } from "./core/task/poll.ts"; import type * as Chunks from "./dyns.Chunks.ts"; import * as Countdown from "./dyns.Countdown.ts"; import type * as dyns_Erased from "./dyns.Erased.ts"; @@ -29,50 +29,50 @@ import * as Tri from "./dyns.Tri.ts"; import { put } from "./harness.ts"; /** Provided, and overridden by one impl. */ -export function sides$dyns_Shape_u32(_self: rt.u32): rt.u8 { +export function sides$dyns_Shape_u32(_self: rs.u32): rs.u8 { return 4; } -export function intoArea$dyns_Shape_u32(self: rt.u32): rt.u32 { - return rt.u32WrappingAdd(area$dyns_Shape_u32(self), 1); +export function intoArea$dyns_Shape_u32(self: rs.u32): rs.u32 { + return rs.u32WrappingAdd(area$dyns_Shape_u32(self), 1); } /** Over early-bound lifetimes, which its signature takes as arguments too. */ -export function larger$dyns_Shape_u32(self: rt.u32, other: rt.u32): rt.u32 { - return rt.max(area$dyns_Shape_u32(self), other); +export function larger$dyns_Shape_u32(self: rs.u32, other: rs.u32): rs.u32 { + return rs.max(area$dyns_Shape_u32(self), other); } -/** Writes through a `&mut` to a number, which is an `rt.Place`. */ -export function tally$dyns_Shape_u32(self: rt.u32, sum: rt.Place): void { - sum.v = rt.u32WrappingAdd(sum.v, area$dyns_Shape_u32(self)); +/** Writes through a `&mut` to a number, which is an `rs.Place`. */ +export function tally$dyns_Shape_u32(self: rs.u32, sum: rs.Place): void { + sum.v = rs.u32WrappingAdd(sum.v, area$dyns_Shape_u32(self)); } -export function area$dyns_Shape_u32(self: rt.u32): rt.u32 { +export function area$dyns_Shape_u32(self: rs.u32): rs.u32 { return self; } -export function grow$dyns_Shape_u32(self: rt.Place, by: rt.u8): void { - self.v = rt.u32WrappingMul(self.v, by as rt.u32); +export function grow$dyns_Shape_u32(self: rs.Place, by: rs.u8): void { + self.v = rs.u32WrappingMul(self.v, by as rs.u32); } -export function total(shapes: Shape.Shape[]): rt.u32 { - return rt.iterFold(rt.iterSlice(shapes), 0, (sum: rt.u32, s: Shape.Shape): rt.u32 => { - return rt.u32WrappingAdd(sum, s.area$Shape()); +export function total(shapes: Shape.Shape[]): rs.u32 { + return rs.iterFold(rs.iterSlice(shapes), 0, (sum: rs.u32, s: Shape.Shape): rs.u32 => { + return rs.u32WrappingAdd(sum, s.area$Shape()); }); } -export function growTwice(s: Shape.Shape, by: rt.u8): void { +export function growTwice(s: Shape.Shape, by: rs.u8): void { s.grow$Shape(by); - s.grow$Shape(rt.u8WrappingAdd(by, 1)); + s.grow$Shape(rs.u8WrappingAdd(by, 1)); } /** Over a type parameter that the trait object instantiates. */ -export function sidesOf$dyn_dyns_Shape(s: Shape.Shape): rt.u8 { +export function sidesOf$dyn_dyns_Shape(s: Shape.Shape): rs.u8 { return s.sides$Shape(); } /** Over a type parameter that the trait object instantiates. */ -export function sidesOf$dyns_Square(s: Square.Square): rt.u8 { +export function sidesOf$dyns_Square(s: Square.Square): rs.u8 { return Square.sides$dyns_Shape(s); } @@ -80,12 +80,12 @@ export function upcast(n: Named.Named): Shape.Shape { return n; } -export function make(kind: rt.u8, n: rt.u8): Named.Named { +export function make(kind: rs.u8, n: rs.u8): Named.Named { let _10!: Tri.Tri; - if (rt.u8Rem(kind, 2) === 0) { - return new of$dyns_Square({ side: n as rt.u16 }); + if (rs.u8Rem(kind, 2) === 0) { + return new of$dyns_Square({ side: n as rs.u16 }); } - if (!(rt.u8Rem(n, 3) === 0)) { + if (!(rs.u8Rem(n, 3) === 0)) { _10 = { tag: "Tall", _0: n } as Tri.Tri; } else { _10 = { tag: "Flat" } as Tri.Tri; @@ -93,225 +93,225 @@ export function make(kind: rt.u8, n: rt.u8): Named.Named { return new of$dyns_Tri(_10); } -export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let tri!: Tri.Tri; - let _109!: rt.usize; + let _109!: rs.usize; if (dataLen >= 3) { - const _12: [rt.u8, rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1], dataData[dataStart + 2]]; - const a: rt.u8 = _12[0]; - const b: rt.u8 = _12[1]; - const c: rt.u8 = _12[2]; - const sq: Square.Square = { side: a as rt.u16 }; - if (!(rt.u8Rem(b, 2) === 0)) { + const _12: [rs.u8, rs.u8, rs.u8] = [dataData[dataStart], dataData[dataStart + 1], dataData[dataStart + 2]]; + const a: rs.u8 = _12[0]; + const b: rs.u8 = _12[1]; + const c: rs.u8 = _12[2]; + const sq: Square.Square = { side: a as rs.u16 }; + if (!(rs.u8Rem(b, 2) === 0)) { tri = { tag: "Tall", _0: b } as Tri.Tri; } else { tri = { tag: "Flat" } as Tri.Tri; } - let n: rt.u32 = c as rt.u32; + let n: rs.u32 = c as rs.u32; const part = total([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - put(out, rt.fmtFormat([args2[0], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + put(out, rs.fmtFormat([args2[0], " "])); growTwice(new of$dyns_Square(sq), b); - growTwice(new ofPlace$dyns_Tri(rt.place(() => tri, (value) => tri = value)), c); - growTwice(new ofPlace$u32(rt.place(() => n, (value2) => n = value2)), a); + growTwice(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), c); + growTwice(new ofPlace$u32(rs.place(() => n, (value2) => n = value2)), a); const arg = sq.side; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rt.Formatter) => rt.u32Display(n, f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); - const _78: rt.u8 = sidesOf$dyn_dyns_Shape(new of$dyns_Tri(tri)); - const _82: rt.u8 = sidesOf$dyns_Square(sq); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_78, f), (f: rt.Formatter) => rt.u8Display(_82, f)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " "])); - const shapes: rt.Vec = new rt.Vec(); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(tri, f), (f: rs.Formatter) => rs.u32Display(n, f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "])); + const _78: rs.u8 = sidesOf$dyn_dyns_Shape(new of$dyns_Tri(tri)); + const _82: rs.u8 = sidesOf$dyns_Square(sq); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_78, f), (f: rs.Formatter) => rs.u8Display(_82, f)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + const shapes: rs.Vec = new rs.Vec(); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 3, dataLen - 3)))); while (true) { - const _94: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_94 === rt.DONE) { + const _94: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_94 === rs.DONE) { break; } - const i: rt.usize = _94[0]; - const x: rt.u8 = _94[1]; - const _101: Named.Named = make(rt.u8WrappingAdd(x, i & 0xff), x); + const i: rs.usize = _94[0]; + const x: rs.u8 = _94[1]; + const _101: Named.Named = make(rs.u8WrappingAdd(x, i & 0xff), x); shapes.items.push(_101); } - const _106: rt.usize = shapes.items.length; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _106; + const _106: rs.usize = shapes.items.length; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _106; while ((_109 = iterStart++) < iterEnd) { - const i2: rt.usize = _109; - const at = rt.idx(shapes.items, i2); - const s: rt.Place = rt.place(() => shapes.items[at], (value3) => shapes.items[at] = value3); - if (rt.usizeRem(i2, 2) === 0) { + const i2: rs.usize = _109; + const at = rs.idx(shapes.items, i2); + const s: rs.Place = rs.place(() => shapes.items[at], (value3) => shapes.items[at] = value3); + if (rs.usizeRem(i2, 2) === 0) { s.v.grow$Shape(a); } const _129: string = s.v.label$Named(); - const _132: rt.u32 = s.v.area$Shape(); - const _135: rt.u8 = sidesOf$dyn_dyns_Shape(upcast(s.v)); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _129), (f: rt.Formatter) => rt.u32Display(_132, f), (f: rt.Formatter) => rt.u8Display(_135, f), (f: rt.Formatter) => s.v.fmt$Debug(f)]; - put(out, rt.fmtFormat([args8[0], ":", args8[1], ":", args8[2], ":", args8[3], " "])); + const _132: rs.u32 = s.v.area$Shape(); + const _135: rs.u8 = sidesOf$dyn_dyns_Shape(upcast(s.v)); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => rs.u32Display(_132, f), (f: rs.Formatter) => rs.u8Display(_135, f), (f: rs.Formatter) => s.v.fmt$Debug(f)]; + put(out, rs.fmtFormat([args8[0], ":", args8[1], ":", args8[2], ":", args8[3], " "])); } - let sum: rt.u32 = 0; + let sum: rs.u32 = 0; for (const _150 of shapes.items) { - _150.tally$Shape(rt.place(() => sum, (value4) => sum = value4)); + _150.tally$Shape(rs.place(() => sum, (value4) => sum = value4)); } const _167: Tri.Tri = tri; - const at2 = rt.idx(shapes.items, 0); - const _165: Shown.Shown = { _0: (f: rt.Formatter) => Tri.fmt$fmt_Debug(_167, f) }; - const _169: rt.u32 = shapes.items[at2].larger$Shape(b as rt.u32); - const _175: rt.u32 = sum; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_175, f), (f: rt.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rt.Formatter) => rt.u32Display(_169, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "])); + const at2 = rs.idx(shapes.items, 0); + const _165: Shown.Shown = { _0: (f: rs.Formatter) => Tri.fmt$fmt_Debug(_167, f) }; + const _169: rs.u32 = shapes.items[at2].larger$Shape(b as rs.u32); + const _175: rs.u32 = sum; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_175, f), (f: rs.Formatter) => Shown.fmt$fmt_Debug(_165, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "])); for (const s2 of shapes.items) { - sum = rt.u32WrappingAdd(sum, s2.intoArea$Shape()); + sum = rs.u32WrappingAdd(sum, s2.intoArea$Shape()); } - const _203: rt.u32 = new of$u32(n).intoArea$Shape(); - const _204: rt.u32 = sum; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_204, f), (f: rt.Formatter) => rt.u32Display(_203, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1]])); + const _203: rs.u32 = new of$u32(n).intoArea$Shape(); + const _204: rs.u32 = sum; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_204, f), (f: rs.Formatter) => rs.u32Display(_203, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1]])); } } -export function counts$dyn_dyns_Named(arcs: rt.Arc[]): string { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { - const _42: rt.usize = a.strong; - return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); +export function counts$dyn_dyns_Named(arcs: rs.Arc[]): string { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(arcs), (a: rs.Arc): string => { + const _42: rs.usize = a.strong; + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); }), undefined, 12, true).items, ","); } -export function counts$dyn_dyns_Shape(arcs: rt.Arc[]): string { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { - const _42: rt.usize = a.strong; - return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); +export function counts$dyn_dyns_Shape(arcs: rs.Arc[]): string { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(arcs), (a: rs.Arc): string => { + const _42: rs.usize = a.strong; + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); }), undefined, 12, true).items, ","); } -export function counts$dyns_Hits(arcs: rt.Arc[]): string { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { - const _42: rt.usize = a.strong; - return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); +export function counts$dyns_Hits(arcs: rs.Arc[]): string { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(arcs), (a: rs.Arc): string => { + const _42: rs.usize = a.strong; + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); }), undefined, 12, true).items, ","); } -export function counts$dyns_Square(arcs: rt.Arc[]): string { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(arcs), (a: rt.Arc): string => { - const _42: rt.usize = a.strong; - return rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_42, f)); +export function counts$dyns_Square(arcs: rs.Arc[]): string { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(arcs), (a: rs.Arc): string => { + const _42: rs.usize = a.strong; + return rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_42, f)); }), undefined, 12, true).items, ","); } -export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen >= 2) { - const sq: rt.Arc = new rt.Arc({ side: dataData[dataStart] as rt.u16 }); - const _13: rt.Arc = rt.arcClone(sq); - const named: rt.Arc = new rt.ArcDyn(_13, new of$dyns_Square(_13.value)); - const _16: rt.Arc = rt.arcClone(sq); - const again: rt.Arc = new rt.ArcDyn(_16, new of$dyns_Square(_16.value)); - const shape: rt.Arc = rt.arcClone(named); - const up: rt.Arc = rt.arcClone(again); + const sq: rs.Arc = new rs.Arc({ side: dataData[dataStart] as rs.u16 }); + const _13: rs.Arc = rs.arcClone(sq); + const named: rs.Arc = new rs.ArcDyn(_13, new of$dyns_Square(_13.value)); + const _16: rs.Arc = rs.arcClone(sq); + const again: rs.Arc = new rs.ArcDyn(_16, new of$dyns_Square(_16.value)); + const shape: rs.Arc = rs.arcClone(named); + const up: rs.Arc = rs.arcClone(again); const part = counts$dyns_Square([sq]); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - put(out, rt.fmtFormat([args2[0], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + put(out, rs.fmtFormat([args2[0], " "])); const _49: string = named.value.label$Named(); - const _53: rt.u32 = shape.value.area$Shape(); - const _57: rt.u8 = sidesOf$dyn_dyns_Shape(up.value); + const _53: rs.u32 = shape.value.area$Shape(); + const _57: rs.u8 = sidesOf$dyn_dyns_Shape(up.value); const _62: Named.Named = named.value; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _49), (f: rt.Formatter) => rt.u32Display(_53, f), (f: rt.Formatter) => rt.u8Display(_57, f), (f: rt.Formatter) => _62.fmt$Debug(f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); - const _73: [rt.Weak, rt.Weak] = [new rt.Weak(shape), new rt.Weak(up)]; - const weak: rt.Weak = _73[0]; - const other: rt.Weak = _73[1]; - const _86: boolean = rt.arcPtrEq(named, again); - const _90: boolean = rt.arcPtrEq(shape, up); - const _94: boolean = rt.arcPtrEq(weak.arc, other.arc); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_86, f), (f: rt.Formatter) => rt.fmtBool(_90, f), (f: rt.Formatter) => rt.fmtBool(_94, f)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _49), (f: rs.Formatter) => rs.u32Display(_53, f), (f: rs.Formatter) => rs.u8Display(_57, f), (f: rs.Formatter) => _62.fmt$Debug(f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + const _73: [rs.Weak, rs.Weak] = [new rs.Weak(shape), new rs.Weak(up)]; + const weak: rs.Weak = _73[0]; + const other: rs.Weak = _73[1]; + const _86: boolean = rs.arcPtrEq(named, again); + const _90: boolean = rs.arcPtrEq(shape, up); + const _94: boolean = rs.arcPtrEq(weak.arc, other.arc); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_86, f), (f: rs.Formatter) => rs.fmtBool(_90, f), (f: rs.Formatter) => rs.fmtBool(_94, f)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "])); sq[Symbol.dispose](); named[Symbol.dispose](); const _113: string = counts$dyn_dyns_Named([again]); - const _119: rt.usize = weak.arc.strong; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _113), (f: rt.Formatter) => rt.usizeDisplay(_119, f)]; - put(out, rt.fmtFormat([args8[0], " ", args8[1], " "])); - const upgraded: rt.u32 | undefined = option_map$1i542n2(rt.weakUpgrade(weak), (s: rt.Arc): rt.u32 => { - const _0: rt.u32 = s.value.area$Shape(); + const _119: rs.usize = weak.arc.strong; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _113), (f: rs.Formatter) => rs.usizeDisplay(_119, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + const upgraded: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(weak), (s: rs.Arc): rs.u32 => { + const _0: rs.u32 = s.value.area$Shape(); s[Symbol.dispose](); return _0; }); again[Symbol.dispose](); const part2 = counts$dyn_dyns_Shape([up]); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part2)]; - put(out, rt.fmtFormat([args10[0], " "])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; + put(out, rs.fmtFormat([args10[0], " "])); up[Symbol.dispose](); const _156: string = counts$dyn_dyns_Shape([shape]); - const _164: rt.Arc | undefined = rt.weakUpgrade(weak); + const _164: rs.Arc | undefined = rs.weakUpgrade(weak); const _162: boolean = _164 !== undefined; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _156), (f: rt.Formatter) => rt.fmtBool(_162, f), (f: rt.Formatter) => rt.fmtOption(upgraded, f, rt.u32Debug)]; - const _152: string = rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]); - rt.drop(_164); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _156), (f: rs.Formatter) => rs.fmtBool(_162, f), (f: rs.Formatter) => rs.fmtOption(upgraded, f, rs.u32Debug)]; + const _152: string = rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "]); + rs.drop(_164); put(out, _152); shape[Symbol.dispose](); - const _184: rt.Arc | undefined = rt.weakUpgrade(weak); + const _184: rs.Arc | undefined = rs.weakUpgrade(weak); const _182: boolean = _184 === undefined; - const _187: rt.usize = other.arc.strong; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_182, f), (f: rt.Formatter) => rt.usizeDisplay(_187, f)]; - const _178: string = rt.fmtFormat([args14[0], " ", args14[1], " "]); - rt.drop(_184); + const _187: rs.usize = other.arc.strong; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_182, f), (f: rs.Formatter) => rs.usizeDisplay(_187, f)]; + const _178: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + rs.drop(_184); put(out, _178); - const hits: rt.Arc = new rt.Arc({ _0: new rt.Atomic(dataData[dataStart + 1] as rt.u32) }); - const objects: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (_2: rt.i32): rt.Arc => { - const _34: rt.Arc = rt.arcClone(hits); - return new rt.ArcDyn(_34, new of$dyns_Hits(_34.value)); + const hits: rs.Arc = new rs.Arc({ _0: new rs.Atomic(dataData[dataStart + 1] as rs.u32) }); + const objects: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (_2: rs.i32): rs.Arc => { + const _34: rs.Arc = rs.arcClone(hits); + return new rs.ArcDyn(_34, new of$dyns_Hits(_34.value)); }), undefined, 8, true); - const sum: rt.u32 = rt.iterFold(rt.iterSlice(objects.items), 0, (sum2: rt.u32, s2: rt.Arc): rt.u32 => { - return rt.u32WrappingAdd(sum2, s2.value.area$Shape()); + const sum: rs.u32 = rs.iterFold(rs.iterSlice(objects.items), 0, (sum2: rs.u32, s2: rs.Arc): rs.u32 => { + return rs.u32WrappingAdd(sum2, s2.value.area$Shape()); }); - const _216: rt.u32 = rt.atomicLoad(hits.value._0, 0); + const _216: rs.u32 = rs.atomicLoad(hits.value._0, 0); const _222: string = counts$dyns_Hits([hits]); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.u32Display(_216, f), (f: rt.Formatter) => rt.fmtPad(f, _222)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); - rt.dropVec(objects); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.u32Display(_216, f), (f: rs.Formatter) => rs.fmtPad(f, _222)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " "])); + rs.dropVec(objects); const part3 = counts$dyns_Hits([hits]); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part3)]; - put(out, rt.fmtFormat([args18[0], " "])); - const _253: rt.Arc = new rt.Arc(dataData[dataStart + 1] as rt.u32); - const n: rt.Arc = new rt.ArcDyn(_253, new of$u32(_253.value)); - const _257: rt.Arc = new rt.Arc(dataData[dataStart + 1] as rt.u32); - const m: rt.Arc = new rt.ArcDyn(_257, new of$u32(_257.value)); - const _268: rt.u32 = n.value.area$Shape(); - const _272: boolean = rt.arcPtrEq(n, m); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_268, f), (f: rt.Formatter) => rt.fmtBool(_272, f)]; - put(out, rt.fmtFormat([args20[0], " ", args20[1], " "])); - const tris: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rt.u8): rt.Arc => { - const x: rt.u8 = _23; - const _43: rt.u8 = rt.u8Rem(x, 3); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; + put(out, rs.fmtFormat([args18[0], " "])); + const _253: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); + const n: rs.Arc = new rs.ArcDyn(_253, new of$u32(_253.value)); + const _257: rs.Arc = new rs.Arc(dataData[dataStart + 1] as rs.u32); + const m: rs.Arc = new rs.ArcDyn(_257, new of$u32(_257.value)); + const _268: rs.u32 = n.value.area$Shape(); + const _272: boolean = rs.arcPtrEq(n, m); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_268, f), (f: rs.Formatter) => rs.fmtBool(_272, f)]; + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + const tris: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_23: rs.u8): rs.Arc => { + const x: rs.u8 = _23; + const _43: rs.u8 = rs.u8Rem(x, 3); if (_43 === 0) { - const _72: rt.Arc = new rt.Arc({ tag: "Flat" } as Tri.Tri); - return new rt.ArcDyn(_72, new of$dyns_Tri(_72.value)); + const _72: rs.Arc = new rs.Arc({ tag: "Flat" } as Tri.Tri); + return new rs.ArcDyn(_72, new of$dyns_Tri(_72.value)); } if (_43 === 1) { - const _92: rt.Arc = new rt.Arc({ tag: "Tall", _0: x } as Tri.Tri); - return new rt.ArcDyn(_92, new of$dyns_Tri(_92.value)); + const _92: rs.Arc = new rs.Arc({ tag: "Tall", _0: x } as Tri.Tri); + return new rs.ArcDyn(_92, new of$dyns_Tri(_92.value)); } - const _112: rt.Arc = new rt.Arc({ side: x as rt.u16 }); - return new rt.ArcDyn(_112, new of$dyns_Square(_112.value)); + const _112: rs.Arc = new rs.Arc({ side: x as rs.u16 }); + return new rs.ArcDyn(_112, new of$dyns_Square(_112.value)); }), undefined, 8, true); - const kept: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterStepBy(rt.iterSlice(tris.items), 2), (a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const kept: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterStepBy(rs.iterSlice(tris.items), 2), (a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); }), undefined, 8, true); for (const _292 of tris.items) { const _304: string = _292.value.label$Named(); - const _307: rt.u32 = _292.value.area$Shape(); - const _310: rt.usize = _292.strong; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _304), (f: rt.Formatter) => rt.u32Display(_307, f), (f: rt.Formatter) => rt.usizeDisplay(_310, f)]; - put(out, rt.fmtFormat([args22[0], ":", args22[1], ":", args22[2], " "])); + const _307: rs.u32 = _292.value.area$Shape(); + const _310: rs.usize = _292.strong; + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _304), (f: rs.Formatter) => rs.u32Display(_307, f), (f: rs.Formatter) => rs.usizeDisplay(_310, f)]; + put(out, rs.fmtFormat([args22[0], ":", args22[1], ":", args22[2], " "])); } - rt.dropVec(tris); - let total: rt.u32 = 0; + rs.dropVec(tris); + let total: rs.u32 = 0; for (const _322 of kept.items) { - _322.value.tally$Shape(rt.place(() => total, (value) => total = value)); + _322.value.tally$Shape(rs.place(() => total, (value) => total = value)); } - const _337: string = counts$dyn_dyns_Named(rt.iterToVec(rt.iterSlice(kept.items), undefined, 4, true).items); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(total, f), (f: rt.Formatter) => rt.fmtPad(f, _337)]; - put(out, rt.fmtFormat([args24[0], " ", args24[1]])); - rt.dropVec(kept); + const _337: string = counts$dyn_dyns_Named(rs.iterToVec(rs.iterSlice(kept.items), undefined, 4, true).items); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(total, f), (f: rs.Formatter) => rs.fmtPad(f, _337)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + rs.dropVec(kept); m[Symbol.dispose](); n[Symbol.dispose](); hits[Symbol.dispose](); @@ -320,15 +320,15 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, } } -export function asAny$dyns_Erased_u32(self: rt.u32): Any.Any { +export function asAny$dyns_Erased_u32(self: rs.u32): Any.Any { return new of$u32(self); } -export function asAnyMut$dyns_Erased_u32(self: rt.Place): Any.Any { +export function asAnyMut$dyns_Erased_u32(self: rs.Place): Any.Any { return new ofPlace$u32(self); } -export function key$dyns_Keyed_u32(self: rt.u32): rt.u32 { +export function key$dyns_Keyed_u32(self: rs.u32): rs.u32 { return self; } @@ -337,18 +337,18 @@ export function kind(a: Any.Any): string { const _2: Square.Square | undefined = a instanceof of$dyns_Square ? a.v : undefined; if (_2 !== undefined) { const arg = _2.side; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg, f)]; - return rt.fmtFormat(["square ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f)]; + return rs.fmtFormat(["square ", args2[0]]); } - const _13: rt.u32 | undefined = a instanceof of$u32 ? a.v : a instanceof ofPlace$u32 ? a.v.v : undefined; + const _13: rs.u32 | undefined = a instanceof of$u32 ? a.v : a instanceof ofPlace$u32 ? a.v.v : undefined; if (_13 !== undefined) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_13, f)]; - return rt.fmtFormat(["u32 ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_13, f)]; + return rs.fmtFormat(["u32 ", args4[0]]); } const _24: Tri.Tri | undefined = a instanceof of$dyns_Tri ? a.v : a instanceof ofPlace$dyns_Tri ? a.v.v : undefined; if (_24 !== undefined) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => Tri.fmt$fmt_Debug(_24, f)]; - return rt.fmtFormat(["tri ", args6[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_24, f)]; + return rs.fmtFormat(["tri ", args6[0]]); } if (!(a instanceof of$u8 || a instanceof ofPlace$u8)) { return "other"; @@ -357,13 +357,13 @@ export function kind(a: Any.Any): string { } /** Bumps the number or enum `a` holds where it is. */ -export function bump(a: Any.Any, by: rt.u8): boolean { - const _3: rt.Place | undefined = a instanceof of$u32 ? a : a instanceof ofPlace$u32 ? a.v : undefined; +export function bump(a: Any.Any, by: rs.u8): boolean { + const _3: rs.Place | undefined = a instanceof of$u32 ? a : a instanceof ofPlace$u32 ? a.v : undefined; if (_3 !== undefined) { - _3.v = rt.u32WrappingAdd(_3.v, by as rt.u32); + _3.v = rs.u32WrappingAdd(_3.v, by as rs.u32); return true; } - const _9: rt.Place | undefined = a instanceof of$dyns_Tri ? a : a instanceof ofPlace$dyns_Tri ? a.v : undefined; + const _9: rs.Place | undefined = a instanceof of$dyns_Tri ? a : a instanceof ofPlace$dyns_Tri ? a.v : undefined; if (_9 !== undefined) { Tri.grow$dyns_Shape(_9, by); return true; @@ -388,100 +388,100 @@ export function isA$u32(e: dyns_Erased.Erased): boolean { return (_4 instanceof of$u32 ? _4.v : _4 instanceof ofPlace$u32 ? _4.v.v : undefined) !== undefined; } -export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let tri!: Tri.Tri; let _237!: Any.Any; if (dataLen >= 2) { - const _10: [rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1]]; - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; - const sq: Square.Square = { side: a as rt.u16 }; - if (!(rt.u8Rem(b, 2) === 0)) { + const _10: [rs.u8, rs.u8] = [dataData[dataStart], dataData[dataStart + 1]]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; + const sq: Square.Square = { side: a as rs.u16 }; + if (!(rs.u8Rem(b, 2) === 0)) { tri = { tag: "Tall", _0: b } as Tri.Tri; } else { tri = { tag: "Flat" } as Tri.Tri; } - let n: rt.u32 = b as rt.u32; - const iter: rt.Iter = rt.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n), new of$u8(a), new of$ref_str("str")]); + let n: rs.u32 = b as rs.u32; + const iter: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n), new of$u8(a), new of$ref_str("str")]); while (true) { - const _33: Any.Any | rt.Done = iter.next(); - if (_33 === rt.DONE) { + const _33: Any.Any | rs.Done = iter.next(); + if (_33 === rs.DONE) { break; } const part = kind(_33); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - put(out, rt.fmtFormat([args2[0], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + put(out, rs.fmtFormat([args2[0], " "])); } const _51: boolean = bump(new of$dyns_Square(sq), a); - const _54: boolean = bump(new ofPlace$dyns_Tri(rt.place(() => tri, (value) => tri = value)), b); - const _57: boolean = bump(new ofPlace$u32(rt.place(() => n, (value2) => n = value2)), a); - let _63: rt.u8 = 0; - const hit: [boolean, boolean, boolean, boolean] = [_51, _54, _57, bump(new ofPlace$u8(rt.place(() => _63, (value3) => _63 = value3)), a)]; + const _54: boolean = bump(new ofPlace$dyns_Tri(rs.place(() => tri, (value) => tri = value)), b); + const _57: boolean = bump(new ofPlace$u32(rs.place(() => n, (value2) => n = value2)), a); + let _63: rs.u8 = 0; + const hit: [boolean, boolean, boolean, boolean] = [_51, _54, _57, bump(new ofPlace$u8(rs.place(() => _63, (value3) => _63 = value3)), a)]; const _72: Tri.Tri = tri; const arg = sq.side; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rt.Formatter) => rt.u32Display(n, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(hit[0], f), (f: rt.Formatter) => rt.fmtBool(hit[1], f), (f: rt.Formatter) => rt.fmtBool(hit[2], f), (f: rt.Formatter) => rt.fmtBool(hit[3], f)], f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); - const iter2: rt.Iter = rt.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_72, f), (f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(hit[0], f), (f: rs.Formatter) => rs.fmtBool(hit[1], f), (f: rs.Formatter) => rs.fmtBool(hit[2], f), (f: rs.Formatter) => rs.fmtBool(hit[3], f)], f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " "])); + const iter2: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$dyns_Tri(tri), new of$u32(n)]); while (true) { - const _91: dyns_Erased.Erased | rt.Done = iter2.next(); - if (_91 === rt.DONE) { + const _91: dyns_Erased.Erased | rs.Done = iter2.next(); + if (_91 === rs.DONE) { break; } const _103: boolean = isA$dyns_Square(_91); const _105: boolean = isA$u32(_91); const _107: string = kind(_91.asAny$Erased()); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_103, f), (f: rt.Formatter) => rt.fmtBool(_105, f), (f: rt.Formatter) => rt.fmtPad(f, _107)]; - put(out, rt.fmtFormat([args6[0], args6[1], args6[2], " "])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_103, f), (f: rs.Formatter) => rs.fmtBool(_105, f), (f: rs.Formatter) => rs.fmtPad(f, _107)]; + put(out, rs.fmtFormat([args6[0], args6[1], args6[2], " "])); } - let m: rt.u32 = a as rt.u32; - const _119: Any.Any = new ofPlace$u32(rt.place(() => m, (value4) => m = value4)).asAnyMut$Erased(); - const _118: rt.Place | undefined = _119 instanceof of$u32 ? _119 : _119 instanceof ofPlace$u32 ? _119.v : undefined; + let m: rs.u32 = a as rs.u32; + const _119: Any.Any = new ofPlace$u32(rs.place(() => m, (value4) => m = value4)).asAnyMut$Erased(); + const _118: rs.Place | undefined = _119 instanceof of$u32 ? _119 : _119 instanceof ofPlace$u32 ? _119.v : undefined; if (_118 !== undefined) { - _118.v = rt.u32WrappingMul(_118.v, 3); + _118.v = rs.u32WrappingMul(_118.v, 3); } - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(m, f)]; - put(out, rt.fmtFormat([args8[0], " "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(m, f)]; + put(out, rs.fmtFormat([args8[0], " "])); const unit: Any.Any = new of$unit(undefined); - const part2 = [unit instanceof of$unit ? unit.v : unit instanceof ofPlace$unit ? unit.v.v : rt.None, unit instanceof of$Option_u8 || unit instanceof ofPlace$Option_u8] as [undefined | rt.None, boolean]; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part2[0], f, rt.fmtUnit, rt.None), (f: rt.Formatter) => rt.fmtBool(part2[1], f)], f)]; - put(out, rt.fmtFormat([args10[0], " "])); - let some: rt.u8 | undefined = a; - let none: rt.u8 | undefined = undefined; - const iter3: rt.Iter = rt.iterSlice([new ofPlace$Option_u8(rt.place(() => some, (value5) => some = value5)), new ofPlace$Option_u8(rt.place(() => none, (value6) => none = value6)), new ofPlace$u32(rt.place(() => n, (value7) => n = value7))]); + const part2 = [unit instanceof of$unit ? unit.v : unit instanceof ofPlace$unit ? unit.v.v : rs.None, unit instanceof of$Option_u8 || unit instanceof ofPlace$Option_u8] as [undefined | rs.None, boolean]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part2[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtBool(part2[1], f)], f)]; + put(out, rs.fmtFormat([args10[0], " "])); + let some: rs.u8 | undefined = a; + let none: rs.u8 | undefined = undefined; + const iter3: rs.Iter = rs.iterSlice([new ofPlace$Option_u8(rs.place(() => some, (value5) => some = value5)), new ofPlace$Option_u8(rs.place(() => none, (value6) => none = value6)), new ofPlace$u32(rs.place(() => n, (value7) => n = value7))]); while (true) { - const _167: Any.Any | rt.Done = iter3.next(); - if (_167 === rt.DONE) { + const _167: Any.Any | rs.Done = iter3.next(); + if (_167 === rs.DONE) { break; } - const part3 = [_167 instanceof of$unit ? _167.v : _167 instanceof ofPlace$unit ? _167.v.v : rt.None, _167 instanceof of$Option_u8 ? _167.v : _167 instanceof ofPlace$Option_u8 ? _167.v.v : rt.None] as [undefined | rt.None, rt.u8 | undefined | rt.None]; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part3[0], f, rt.fmtUnit, rt.None), (f: rt.Formatter) => rt.fmtOption(part3[1], f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)], f)]; - put(out, rt.fmtFormat([args12[0]])); - const _189: rt.Place | undefined = _167 instanceof of$Option_u8 ? _167 : _167 instanceof ofPlace$Option_u8 ? _167.v : undefined; + const part3 = [_167 instanceof of$unit ? _167.v : _167 instanceof ofPlace$unit ? _167.v.v : rs.None, _167 instanceof of$Option_u8 ? _167.v : _167 instanceof ofPlace$Option_u8 ? _167.v.v : rs.None] as [undefined | rs.None, rs.u8 | undefined | rs.None]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part3[0], f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(part3[1], f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)], f)]; + put(out, rs.fmtFormat([args12[0]])); + const _189: rs.Place | undefined = _167 instanceof of$Option_u8 ? _167 : _167 instanceof ofPlace$Option_u8 ? _167.v : undefined; if (_189 !== undefined) { - _189.v = option_mapOr$06rr3sb(_189.v, b, (_2: rt.u8): rt.u8 | undefined => { + _189.v = option_mapOr$19a4gco(_189.v, b, (_2: rs.u8): rs.u8 | undefined => { return undefined; }); } const arg2 = (_167 instanceof of$unit ? _167 : _167 instanceof ofPlace$unit ? _167.v : undefined) !== undefined; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(arg2, f)]; - put(out, rt.fmtFormat([args14[0], " "])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg2, f)]; + put(out, rs.fmtFormat([args14[0], " "])); } - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(some, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(none, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " "])); - const boxes: rt.Vec = new rt.Vec(); - const iter4: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(some, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + const boxes: rs.Vec = new rs.Vec(); + const iter4: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)))); while (true) { - const _229: [rt.usize, rt.u8] | rt.Done = iter4.next(); - if (_229 === rt.DONE) { + const _229: [rs.usize, rs.u8] | rs.Done = iter4.next(); + if (_229 === rs.DONE) { break; } - const i: rt.usize = _229[0]; - const x: rt.u8 = _229[1]; - const _238: rt.u8 = rt.u8Rem(x, 4); + const i: rs.usize = _229[0]; + const x: rs.u8 = _229[1]; + const _238: rs.u8 = rs.u8Rem(x, 4); if (_238 === 0) { _237 = new of$u8(x); } else if (_238 === 1) { - _237 = new of$u32(x as rt.u32); + _237 = new of$u32(x as rs.u32); } else if (_238 === 2) { _237 = new of$dyns_Tri({ tag: "Tall", _0: x } as Tri.Tri); } else { @@ -489,537 +489,537 @@ export function anys(dataData: Uint8Array, dataStart: number, dataLen: number, o } boxes.items.push(_237); } - const kept: rt.Vec = new rt.Vec(); - const iter5: rt.Iter<[rt.usize, Any.Any]> = rt.iterEnumerate(rt.vecIntoIter(boxes, rt.drop)); + const kept: rs.Vec = new rs.Vec(); + const iter5: rs.Iter<[rs.usize, Any.Any]> = rs.iterEnumerate(rs.vecIntoIter(boxes, rs.drop)); while (true) { - const _256: [rt.usize, Any.Any] | rt.Done = iter5.next(); - if (_256 === rt.DONE) { + const _256: [rs.usize, Any.Any] | rs.Done = iter5.next(); + if (_256 === rs.DONE) { break; } - const i2: rt.usize = _256[0]; + const i2: rs.usize = _256[0]; const boxed: Any.Any = _256[1]; - const _261: rt.Result = boxed instanceof of$u32 ? rt.Ok(boxed.v) : rt.Err(boxed); + const _261: rs.Result = boxed instanceof of$u32 ? rs.Ok(boxed.v) : rs.Err(boxed); if (_261.ok) { const part5 = _261.value; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - put(out, rt.fmtFormat(["n", args18[0], " "])); - } else if (!(rt.usizeRem(i2, 2) === 0)) { + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + put(out, rs.fmtFormat(["n", args18[0], " "])); + } else if (!(rs.usizeRem(i2, 2) === 0)) { const other2: Any.Any = _261.error; - const _282: rt.Result = other2 instanceof of$u8 ? rt.Ok(other2.v) : rt.Err(other2); + const _282: rs.Result = other2 instanceof of$u8 ? rs.Ok(other2.v) : rs.Err(other2); if (_282.ok) { const arg3 = _282.value; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg3, f)]; - put(out, rt.fmtFormat(["u8 ", args20[0], " "])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f)]; + put(out, rs.fmtFormat(["u8 ", args20[0], " "])); } else { const other3: Any.Any = _282.error; const part4 = kind(other3); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part4)]; - put(out, rt.fmtFormat([args22[0], " "])); - rt.drop(other3); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; + put(out, rs.fmtFormat([args22[0], " "])); + rs.drop(other3); } } else { kept.items.push(_261.error); } } - rt.drop(iter5); - const iter6: rt.Iter> = rt.iterRev(rt.iterSliceMut(kept.items)); + rs.drop(iter5); + const iter6: rs.Iter> = rs.iterRev(rs.iterSliceMut(kept.items)); while (true) { - const _316: rt.Place | rt.Done = iter6.next(); - if (_316 === rt.DONE) { + const _316: rs.Place | rs.Done = iter6.next(); + if (_316 === rs.DONE) { break; } const _328: string = kind(_316.v); const _331: boolean = bump(_316.v, a); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _328), (f: rt.Formatter) => rt.fmtBool(_331, f)]; - put(out, rt.fmtFormat([args24[0], ":", args24[1], " "])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _328), (f: rs.Formatter) => rs.fmtBool(_331, f)]; + put(out, rs.fmtFormat([args24[0], ":", args24[1], " "])); } - const _339: rt.Arc<[rt.u8, rt.u8]> = new rt.Arc([a, b] as [rt.u8, rt.u8]); - const hold: rt.Arc = new rt.ArcDyn(_339, new of$tuple2_u8_u8(_339.value)); + const _339: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([a, b] as [rs.u8, rs.u8]); + const hold: rs.Arc = new rs.ArcDyn(_339, new of$tuple2_u8_u8(_339.value)); const _358: Any.Any = hold.value; - const held: rt.Arc[] = [rt.arcClone(hold), rt.arcClone(hold)]; - const _354: rt.usize = hold.strong; - const _357: [rt.u8, rt.u8] | undefined = _358 instanceof of$tuple2_u8_u8 ? _358.v : undefined; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_354, f), (f: rt.Formatter) => rt.fmtOption(_357, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args26[0], " ", args26[1], " "])); - rt.dropAll(held); + const held: rs.Arc[] = [rs.arcClone(hold), rs.arcClone(hold)]; + const _354: rs.usize = hold.strong; + const _357: [rs.u8, rs.u8] | undefined = _358 instanceof of$tuple2_u8_u8 ? _358.v : undefined; + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_354, f), (f: rs.Formatter) => rs.fmtOption(_357, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " "])); + rs.dropAll(held); const part6 = hold.strong; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part6, f)]; - put(out, rt.fmtFormat([args28[0], " "])); - const _381: rt.Result, rt.Arc> = rt.arcDowncast(hold, of$u8, (object) => object.v); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; + put(out, rs.fmtFormat([args28[0], " "])); + const _381: rs.Result, rs.Arc> = rs.arcDowncast(hold, of$u8, (object) => object.v); if (_381.ok) { - rt.panic("internal error: entered unreachable code"); + rs.panic("internal error: entered unreachable code"); } else { - const part7 = ok$0lceojf(result_map$0zujxcv(rt.arcDowncast(_381.error, of$tuple2_u8_u8, (object) => object.v), (t: rt.Arc<[rt.u8, rt.u8]>): [rt.usize, rt.u8] => { - const _02: [rt.usize, rt.u8] = [t.strong, t.value[0]]; + const part7 = ok$1lmsnde(result_map$0f0ko1g(rs.arcDowncast(_381.error, of$tuple2_u8_u8, (object) => object.v), (t: rs.Arc<[rs.u8, rs.u8]>): [rs.usize, rs.u8] => { + const _02: [rs.usize, rs.u8] = [t.strong, t.value[0]]; t[Symbol.dispose](); return _02; })); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part7, f, (value: [rt.usize, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args30[0], " "])); - let n3: rt.u32 = a as rt.u32; - const iter7: rt.Iter = rt.iterSlice([new of$dyns_Square(sq), new of$u32(n3)]); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args30[0], " "])); + let n3: rs.u32 = a as rs.u32; + const iter7: rs.Iter = rs.iterSlice([new of$dyns_Square(sq), new of$u32(n3)]); while (true) { - const _407: Keyed.Keyed | rt.Done = iter7.next(); - if (_407 === rt.DONE) { + const _407: Keyed.Keyed | rs.Done = iter7.next(); + if (_407 === rs.DONE) { break; } const any: Any.Any = _407; - const _420: rt.u32 = _407.key$Keyed(); + const _420: rs.u32 = _407.key$Keyed(); const _422: string = kind(any); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_420, f), (f: rt.Formatter) => rt.fmtPad(f, _422)]; - put(out, rt.fmtFormat([args32[0], args32[1], " "])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_420, f), (f: rs.Formatter) => rs.fmtPad(f, _422)]; + put(out, rs.fmtFormat([args32[0], args32[1], " "])); } - const part8 = bump(new ofPlace$u32(rt.place(() => n3, (value8) => n3 = value8)), b); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part8, f)]; - put(out, rt.fmtFormat([args34[0], " "])); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n3, f)]; - put(out, rt.fmtFormat([args36[0], " "])); - const any3: Any.Any = new of$dyns_Square({ side: b as rt.u16 }); - const part9 = ok$1a014tb(result_map$1p3mw15(any3 instanceof of$dyns_Square ? rt.Ok(any3.v) : rt.Err(any3), (sq2: Square.Square): rt.u16 => { + const part8 = bump(new ofPlace$u32(rs.place(() => n3, (value8) => n3 = value8)), b); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; + put(out, rs.fmtFormat([args34[0], " "])); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f)]; + put(out, rs.fmtFormat([args36[0], " "])); + const any3: Any.Any = new of$dyns_Square({ side: b as rs.u16 }); + const part9 = ok$1wwd922(result_map$0tx2z7o(any3 instanceof of$dyns_Square ? rs.Ok(any3.v) : rs.Err(any3), (sq2: Square.Square): rs.u16 => { return sq2.side; })); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args38[0], " "])); - const _477: rt.Arc = new rt.Arc(n3); - const shared: rt.Arc = new rt.ArcDyn(_477, new of$u32(_477.value)); - const weak2: rt.Weak = new rt.Weak(shared); - const any4: rt.Arc = shared; + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args38[0], " "])); + const _477: rs.Arc = new rs.Arc(n3); + const shared: rs.Arc = new rs.ArcDyn(_477, new of$u32(_477.value)); + const weak2: rs.Weak = new rs.Weak(shared); + const any4: rs.Arc = shared; const _496: Any.Any = any4.value; - const _491: boolean = isSomeAnd$13v37g1(rt.weakUpgrade(weak2), (a2: rt.Arc): boolean => { + const _491: boolean = isSomeAnd$11ghftu(rs.weakUpgrade(weak2), (a2: rs.Arc): boolean => { const _32: Any.Any = a2.value; const _04: boolean = _32 instanceof of$u32 || _32 instanceof ofPlace$u32; a2[Symbol.dispose](); return _04; }); - const _495: rt.u32 | undefined = _496 instanceof of$u32 ? _496.v : _496 instanceof ofPlace$u32 ? _496.v.v : undefined; - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_491, f), (f: rt.Formatter) => rt.fmtOption(_495, f, rt.u32Debug)]; - put(out, rt.fmtFormat([args40[0], " ", args40[1], " "])); - const typed2: [rt.usize, rt.u32] | undefined = ok$1vbcgd7(result_map$1v8vvnp(rt.arcDowncast(any4, of$u32, (object) => object.v), (n4: rt.Arc): [rt.usize, rt.u32] => { - const _05: [rt.usize, rt.u32] = [n4.strong, n4.value]; + const _495: rs.u32 | undefined = _496 instanceof of$u32 ? _496.v : _496 instanceof ofPlace$u32 ? _496.v.v : undefined; + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_491, f), (f: rs.Formatter) => rs.fmtOption(_495, f, rs.u32Debug)]; + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); + const typed2: [rs.usize, rs.u32] | undefined = ok$0y6a1w6(result_map$0njbm3o(rs.arcDowncast(any4, of$u32, (object) => object.v), (n4: rs.Arc): [rs.usize, rs.u32] => { + const _05: [rs.usize, rs.u32] = [n4.strong, n4.value]; n4[Symbol.dispose](); return _05; })); - const _516: rt.Arc | undefined = rt.weakUpgrade(weak2); + const _516: rs.Arc | undefined = rs.weakUpgrade(weak2); const _514: boolean = _516 !== undefined; - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(typed2, f, (value: [rt.usize, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtBool(_514, f)]; - const _510: string = rt.fmtFormat([args42[0], " ", args42[1]]); - rt.drop(_516); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(typed2, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_514, f)]; + const _510: string = rs.fmtFormat([args42[0], " ", args42[1]]); + rs.drop(_516); put(out, _510); weak2[Symbol.dispose](); - rt.dropVec(kept); + rs.dropVec(kept); } } } -export function twice(f: (a0: rt.u8) => rt.u8, x: rt.u8): rt.u8 { +export function twice(f: (a0: rs.u8) => rs.u8, x: rs.u8): rs.u8 { return f(f(x)); } -export function bumpAll(f: (a0: rt.u8) => undefined, xs: rt.ByteSlice): void { - for (const _5 of rt.byteSliceView(xs)) { +export function bumpAll(f: (a0: rs.u8) => undefined, xs: rs.ByteSlice): void { + for (const _5 of rs.byteSliceView(xs)) { f(_5); } } /** Over a lifetime the call picks, as `form_urlencoded`'s encoder override is. */ -export function firstWord(f: (a0: string) => string, s: string): rt.usize { - return rt.stringLen(f(s)); +export function firstWord(f: (a0: string) => string, s: string): rs.usize { + return rs.stringLen(f(s)); } -export function adder(by: rt.u8): (a0: rt.u8) => rt.u8 { +export function adder(by: rs.u8): (a0: rs.u8) => rs.u8 { const captured = by; - return (x: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(x, captured); + return (x: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(x, captured); }; } -export function halve(x: rt.u8): rt.u8 { - return rt.u8Div(x, 2); +export function halve(x: rs.u8): rs.u8 { + return rs.u8Div(x, 2); } -export function flip(x: rt.u8): rt.u8 { +export function flip(x: rs.u8): rs.u8 { return x ^ 90; } -export function fns(data: rt.ByteSlice, out: rt.ByteVec): void { - let ptr!: (a0: rt.u8) => rt.u8; +export function fns(data: rs.ByteSlice, out: rs.ByteVec): void { + let ptr!: (a0: rs.u8) => rs.u8; if (data.length >= 2) { - const _10: [rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1]]; - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; - const mul: (a0: rt.u8) => rt.u8 = (x: rt.u8): rt.u8 => { - return rt.u8WrappingMul(x, b); + const _10: [rs.u8, rs.u8] = [data.data[data.start], data.data[data.start + 1]]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; + const mul: (a0: rs.u8) => rs.u8 = (x: rs.u8): rs.u8 => { + return rs.u8WrappingMul(x, b); }; - if (!(rt.u8Rem(b, 2) === 0)) { + if (!(rs.u8Rem(b, 2) === 0)) { ptr = flip; } else { ptr = halve; } - const _27: rt.u8 = twice(mul, a); - const _31: rt.u8 = twice(halve, a); - const _35: rt.u8 = twice(ptr, a); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_27, f), (f: rt.Formatter) => rt.u8Display(_31, f), (f: rt.Formatter) => rt.u8Display(_35, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + const _27: rs.u8 = twice(mul, a); + const _31: rs.u8 = twice(halve, a); + const _35: rs.u8 = twice(ptr, a); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_27, f), (f: rs.Formatter) => rs.u8Display(_31, f), (f: rs.Formatter) => rs.u8Display(_35, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); const part = firstWord((s: string): string => { - return option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, " ").next()), ""); + return option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, " ").next()), ""); }, "ab cd"); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; - put(out, rt.fmtFormat([args4[0], " "])); - let sum: rt.u32 = 0; - const seen: rt.ByteVec = new rt.ByteVec(); - bumpAll((x2: rt.u8): undefined => { - sum = rt.u32WrappingAdd(sum, x2 as rt.u32); - rt.byteVecPush(seen, x2); - }, rt.byteSliceRange(data, 2)); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(seen), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " "])); - const fs: rt.Vec<(a0: rt.u8) => rt.u8> = rt.vecFrom([adder(a), halve, mul, ptr]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; + put(out, rs.fmtFormat([args4[0], " "])); + let sum: rs.u32 = 0; + const seen: rs.ByteVec = new rs.ByteVec(); + bumpAll((x2: rs.u8): undefined => { + sum = rs.u32WrappingAdd(sum, x2 as rs.u32); + rs.byteVecPush(seen, x2); + }, rs.byteSliceRange(data, 2)); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(seen), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + const fs: rs.Vec<(a0: rs.u8) => rs.u8> = rs.vecFrom([adder(a), halve, mul, ptr]); const captured = a; - const _94: (a0: rt.u8) => rt.u8 = (x3: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(twice(halve, x3), captured); + const _94: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(twice(halve, x3), captured); }; fs.items.push(_94); - rt.sliceSwap(fs.items, 0, rt.usizeRem(b as rt.usize, fs.items.length)); - let captured2: rt.u8 = 0; - const hook: Hook.Hook = new Hook.Hook((x4: rt.u8): rt.u32 => { - captured2 = rt.u8WrappingAdd(captured2, x4); - return rt.u32Mul(captured2 as rt.u32, 3); + rs.sliceSwap(fs.items, 0, rs.usizeRem(b as rs.usize, fs.items.length)); + let captured2: rs.u8 = 0; + const hook: Hook.Hook = new Hook.Hook((x4: rs.u8): rs.u32 => { + captured2 = rs.u8WrappingAdd(captured2, x4); + return rs.u32Mul(captured2 as rs.u32, 3); }); - const iter: rt.Iter<[rt.usize, (a0: rt.u8) => rt.u8]> = rt.iterEnumerate(rt.iterSlice(fs.items)); + const iter: rs.Iter<[rs.usize, (a0: rs.u8) => rs.u8]> = rs.iterEnumerate(rs.iterSlice(fs.items)); while (true) { - const _115: [rt.usize, (a0: rt.u8) => rt.u8] | rt.Done = iter.next(); - if (_115 === rt.DONE) { + const _115: [rs.usize, (a0: rs.u8) => rs.u8] | rs.Done = iter.next(); + if (_115 === rs.DONE) { break; } - const i: rt.usize = _115[0]; - const y: rt.u8 = _115[1](option_unwrapOr$0r2bmpr(rt.byteSliceGet(rt.byteSliceRange(data, 2), i), b)); - const _133: rt.u32 = hook.f(y); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(y, f), (f: rt.Formatter) => rt.u32Display(_133, f)]; - put(out, rt.fmtFormat([args8[0], ":", args8[1], " "])); + const i: rs.usize = _115[0]; + const y: rs.u8 = _115[1](option_unwrapOr$1fr498u(rs.byteSliceGet(rs.byteSliceRange(data, 2), i), b)); + const _133: rs.u32 = hook.f(y); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(y, f), (f: rs.Formatter) => rs.u32Display(_133, f)]; + put(out, rs.fmtFormat([args8[0], ":", args8[1], " "])); } - const _142: (a0: rt.u8) => rt.u32 = (x5: rt.u8): rt.u32 => { - return x5 as rt.u32; + const _142: (a0: rs.u8) => rs.u32 = (x5: rs.u8): rs.u32 => { + return x5 as rs.u32; }; - rt.drop(hook.f); + rs.drop(hook.f); hook.f = _142; const part4 = hook.f(a); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - put(out, rt.fmtFormat([args10[0], " "])); - const captured3 = rt.byteVecFrom(Uint8Array.of(a)); - const part6 = ((x6: rt.u8): rt.ByteVec => { - const list2: rt.ByteVec = captured3; - rt.byteVecPush(list2, x6); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + put(out, rs.fmtFormat([args10[0], " "])); + const captured3 = rs.byteVecFrom(Uint8Array.of(a)); + const part6 = ((x6: rs.u8): rs.ByteVec => { + const list2: rs.ByteVec = captured3; + rs.byteVecPush(list2, x6); return list2; })(b); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(part6), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args12[0], " "])); - const part7 = rt.once(rt.optionUnwrap(rt.vecPop(fs)))(a); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part7, f)]; - put(out, rt.fmtFormat([args14[0], " "])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part6), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args12[0], " "])); + const part7 = rs.once(rs.optionUnwrap(rs.vecPop(fs)))(a); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part7, f)]; + put(out, rs.fmtFormat([args14[0], " "])); const captured4 = b; - const _196: rt.Arc<(a0: rt.u8) => rt.u8> = new rt.Arc((x7: rt.u8): rt.u8 => { + const _196: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x7: rs.u8): rs.u8 => { return x7 ^ captured4; }); - const shared: rt.Arc<(a0: rt.u8) => rt.u8> = new rt.ArcDyn(_196, _196.value); - const other: rt.Arc<(a0: rt.u8) => rt.u8> = rt.arcClone(shared); - const _208: rt.u8 = shared.value(a); - const _213: rt.u8 = other.value(b); - const _218: rt.usize = other.strong; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_208, f), (f: rt.Formatter) => rt.u8Display(_213, f), (f: rt.Formatter) => rt.usizeDisplay(_218, f)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2]])); + const shared: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.ArcDyn(_196, _196.value); + const other: rs.Arc<(a0: rs.u8) => rs.u8> = rs.arcClone(shared); + const _208: rs.u8 = shared.value(a); + const _213: rs.u8 = other.value(b); + const _218: rs.usize = other.strong; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_208, f), (f: rs.Formatter) => rs.u8Display(_213, f), (f: rs.Formatter) => rs.usizeDisplay(_218, f)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2]])); other[Symbol.dispose](); shared[Symbol.dispose](); hook[Symbol.dispose](); - rt.dropVec(fs); + rs.dropVec(fs); } } -export const DROPS: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(DROPS$init, false); +export const DROPS: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(DROPS$init, false); -export function DROPS$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function DROPS$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } /** Puts what dropped since the last call. */ -export function dropped(out: rt.ByteVec): void { - const part = rt.localKeyWithBorrowMut(DROPS, (d: rt.ByteVec): rt.ByteVec => { - return rt.replaceIn(d, new rt.ByteVec()); +export function dropped(out: rs.ByteVec): void { + const part = rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): rs.ByteVec => { + return rs.replaceIn(d, new rs.ByteVec()); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(part), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(part), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " "])); } /** Each of the vtable's methods, then std's adaptors over the borrow, then by value. */ -export function read(it: rt.Iter, out: rt.ByteVec): void { - const hint: [rt.usize, rt.usize | undefined] = rt.iterBorrow(it).sizeHint(); - const first: rt.u8 | undefined = rt.iterToOption(it.next()); - const third: rt.u8 | undefined = rt.iterNth(it, 1); - const pair: rt.ByteVec = rt.iterToByteVec(rt.iterTake(rt.iterStepBy(rt.iterBorrow(it), 2), 2), "next"); - const rest: rt.u32 = rt.iterSum(rt.iterMap(rt.iterBorrow(it), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(hint[0], f), (f: rt.Formatter) => rt.fmtOption(hint[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtOption(first, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(third, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(pair), f, rt.u8Debug), (f: rt.Formatter) => rt.u32Display(rest, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "])); +export function read(it: rs.Iter, out: rs.ByteVec): void { + const hint: [rs.usize, rs.usize | undefined] = rs.iterBorrow(it).sizeHint(); + const first: rs.u8 | undefined = rs.iterToOption(it.next()); + const third: rs.u8 | undefined = rs.iterNth(it, 1); + const pair: rs.ByteVec = rs.iterToByteVec(rs.iterTake(rs.iterStepBy(rs.iterBorrow(it), 2), 2), "next"); + const rest: rs.u32 = rs.iterSum(rs.iterMap(rs.iterBorrow(it), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0], f), (f: rs.Formatter) => rs.fmtOption(hint[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair), f, rs.u8Debug), (f: rs.Formatter) => rs.u32Display(rest, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " "])); } /** * The first value at or past `from` that `f` answers, from either end, as moq's model * scans its groups. */ -export function scan$dyns_iters_closure1(map: rt.BTreeMap, from: rt.u64, rev: boolean, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { - const scan: (a0: rt.Iter<[rt.u64, rt.u8]>) => rt.u8 | undefined = (range: rt.Iter<[rt.u64, rt.u8]>): rt.u8 | undefined => { +export function scan$dyns_iters_closure1(map: rs.BTreeMap, from: rs.u64, rev: boolean, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { + const scan: (a0: rs.Iter<[rs.u64, rs.u8]>) => rs.u8 | undefined = (range: rs.Iter<[rs.u64, rs.u8]>): rs.u8 | undefined => { if (!rev) { - return rt.iterFindMap(rt.iterMap(rt.iterBorrow(range), (_22: [rt.u64, rt.u8]): rt.u8 => { + return rs.iterFindMap(rs.iterMap(rs.iterBorrow(range), (_22: [rs.u64, rs.u8]): rs.u8 => { return _22[1]; }), f); } - return rt.iterFindMap(rt.iterRev(rt.iterBorrow(range)), (_2: [rt.u64, rt.u8]): rt.u8 | undefined => { + return rs.iterFindMap(rs.iterRev(rs.iterBorrow(range)), (_2: [rs.u64, rs.u8]): rs.u8 | undefined => { return f(_2[1]); }); }; - const part2 = rt.iterDyn(rt.iterBorrow(rt.btreeRange(map, new rt.RangeFrom(from, rt.u64Step)))); + const part2 = rs.iterDyn(rs.iterBorrow(rs.btreeRange(map, new rs.RangeFrom(from, rs.u64Step)))); return scan(part2); } /** The length on either side of an item, and an upcast that reads the rest. */ -export function lens(it: rt.Iter): string { - const before: rt.usize = rt.iterBorrow(it).len(); - const first: rt.u8 | undefined = rt.iterToOption(it.next()); - const after: rt.usize = rt.iterBorrow(it).len(); - const back: rt.u8 | undefined = rt.iterLast(rt.iterBorrow(it)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(before, f), (f: rt.Formatter) => rt.fmtOption(first, f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDisplay(after, f), (f: rt.Formatter) => rt.fmtOption(back, f, rt.u8Debug)]; - return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); +export function lens(it: rs.Iter): string { + const before: rs.usize = rs.iterBorrow(it).len(); + const first: rs.u8 | undefined = rs.iterToOption(it.next()); + const after: rs.usize = rs.iterBorrow(it).len(); + const back: rs.u8 | undefined = rs.iterLast(rs.iterBorrow(it)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(before, f), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(after, f), (f: rs.Formatter) => rs.fmtOption(back, f, rs.u8Debug)]; + return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); } -export function tagged(tags: rt.ByteSlice): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(tags)), (_22: rt.u8): Tagged.Tagged => { +export function tagged(tags: rs.ByteSlice): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(tags)), (_22: rs.u8): Tagged.Tagged => { return new Tagged.Tagged(_22); }), undefined, 1, true); } -export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { +export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length >= 2) { - const _10: [rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1]]; - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; - read(rt.iterDyn(rt.iterBorrow(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))))), out); - read(rt.iterDyn(rt.iterBorrow(new rt.Range(a, b))), out); - const down: Countdown.Countdown = new Countdown.Countdown(rt.u8Rem(a, 16)); - read(rt.iterDyn(rt.iterFrom(down, Countdown.next$iter_Iterator)), out); + const _10: [rs.u8, rs.u8] = [data.data[data.start], data.data[data.start + 1]]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; + read(rs.iterDyn(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))))), out); + read(rs.iterDyn(rs.iterBorrow(new rs.Range(a, b))), out); + const down: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(a, 16)); + read(rs.iterDyn(rs.iterFrom(down, Countdown.next$iter_Iterator)), out); dropped(out); down[Symbol.dispose](); dropped(out); - const _33: rt.Iter<[rt.u64, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2)))), (_2: [rt.usize, rt.u8]): [rt.u64, rt.u8] => { - return [_2[0] as rt.u64, _2[1]] as [rt.u64, rt.u8]; + const _33: rs.Iter<[rs.u64, rs.u8]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2)))), (_2: [rs.usize, rs.u8]): [rs.u64, rs.u8] => { + return [_2[0] as rs.u64, _2[1]] as [rs.u64, rs.u8]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _33, true, undefined, undefined, undefined, 16, true); - const _44: rt.u8 | undefined = scan$dyns_iters_closure1(map, rt.u8Rem(a, 8) as rt.u64, false, (v: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(v, 2) === 1, v); + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _33, true, undefined, undefined, undefined, 16, true); + const _44: rs.u8 | undefined = scan$dyns_iters_closure1(map, rs.u8Rem(a, 8) as rs.u64, false, (v: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(v, 2) === 1, v); }); - const _50: rt.u8 | undefined = scan$dyns_iters_closure1(map, rt.u8Rem(b, 8) as rt.u64, true, (v2: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(v2, 2) === 1, v2); + const _50: rs.u8 | undefined = scan$dyns_iters_closure1(map, rs.u8Rem(b, 8) as rs.u64, true, (v2: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(v2, 2) === 1, v2); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_44, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_50, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " "])); - const part = lens(rt.iterDyn(rt.iterBorrow(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2)))))); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - put(out, rt.fmtFormat([args4[0], " "])); - const _79: rt.usize = rt.usizeRem(a as rt.usize, rt.usizeAdd(rt.byteSliceRange(data, 2).length, 1)); - const slice: rt.ByteSlice = rt.byteSliceRange(data, 2); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_44, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_50, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " "])); + const part = lens(rs.iterDyn(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2)))))); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + put(out, rs.fmtFormat([args4[0], " "])); + const _79: rs.usize = rs.usizeRem(a as rs.usize, rs.usizeAdd(rs.byteSliceRange(data, 2).length, 1)); + const slice: rs.ByteSlice = rs.byteSliceRange(data, 2); if (_79 > slice.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const front: rt.ByteSlice = new rt.ByteSlice(slice.data, slice.start, _79); - const back: rt.ByteSlice = new rt.ByteSlice(slice.data, slice.start + _79, slice.length - _79); - const boxed: rt.Iter = rt.iterDyn(rt.vecIntoIter(tagged(front), rt.drop)); - const ends: [rt.u8 | undefined, rt.u8 | undefined] = [option_map$08a6hpg(rt.iterToOption(boxed.next()), (t: Tagged.Tagged): rt.u8 => { - const _04: rt.u8 = t._0; + const front: rs.ByteSlice = new rs.ByteSlice(slice.data, slice.start, _79); + const back: rs.ByteSlice = new rs.ByteSlice(slice.data, slice.start + _79, slice.length - _79); + const boxed: rs.Iter = rs.iterDyn(rs.vecIntoIter(tagged(front), rs.drop)); + const ends: [rs.u8 | undefined, rs.u8 | undefined] = [option_map$11l9b8r(rs.iterToOption(boxed.next()), (t: Tagged.Tagged): rs.u8 => { + const _04: rs.u8 = t._0; t[Symbol.dispose](); return _04; - }), option_map$08a6hpg(rt.iterToOption(boxed.nextBack()), (t2: Tagged.Tagged): rt.u8 => { - const _05: rt.u8 = t2._0; + }), option_map$11l9b8r(rs.iterToOption(boxed.nextBack()), (t2: Tagged.Tagged): rs.u8 => { + const _05: rs.u8 = t2._0; t2[Symbol.dispose](); return _05; })]; - const nth: rt.u8 | undefined = option_map$08a6hpg(rt.iterNth(rt.iterBox(boxed), 1, rt.drop), (t3: Tagged.Tagged): rt.u8 => { - const _06: rt.u8 = t3._0; + const nth: rs.u8 | undefined = option_map$11l9b8r(rs.iterNth(rs.iterBox(boxed), 1, rs.drop), (t3: Tagged.Tagged): rs.u8 => { + const _06: rs.u8 = t3._0; t3[Symbol.dispose](); return _06; }); dropped(out); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(ends[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(ends[1], f, rt.u8Debug)], f), (f: rt.Formatter) => rt.fmtOption(nth, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " "])); - rt.drop(boxed); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(ends[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtOption(nth, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " "])); + rs.drop(boxed); dropped(out); - const last: rt.u8 | undefined = option_map$08a6hpg(rt.ownedLast(rt.iterBox(rt.iterDyn(rt.iterChain(rt.vecIntoIter(tagged(front), rt.drop), rt.vecIntoIter(tagged(back), rt.drop)))), rt.drop), (t4: Tagged.Tagged): rt.u8 => { - const _07: rt.u8 = t4._0; + const last: rs.u8 | undefined = option_map$11l9b8r(rs.ownedLast(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(front), rs.drop), rs.vecIntoIter(tagged(back), rs.drop)))), rs.drop), (t4: Tagged.Tagged): rs.u8 => { + const _07: rs.u8 = t4._0; t4[Symbol.dispose](); return _07; }); dropped(out); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(last, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args8[0], " "])); - const part2 = rt.ownedCount(rt.iterBox(rt.iterDyn(rt.iterChain(rt.vecIntoIter(tagged(back), rt.drop), rt.vecIntoIter(tagged(front), rt.drop)))), rt.drop); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part2, f)]; - put(out, rt.fmtFormat([args10[0], " "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args8[0], " "])); + const part2 = rs.ownedCount(rs.iterBox(rs.iterDyn(rs.iterChain(rs.vecIntoIter(tagged(back), rs.drop), rs.vecIntoIter(tagged(front), rs.drop)))), rs.drop); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; + put(out, rs.fmtFormat([args10[0], " "])); dropped(out); - const own: rt.Iter = rt.iterDyn(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(b, 16)), Countdown.next$iter_Iterator, rt.drop)); - let sum: rt.u32 = 0; - const iter: rt.Iter = rt.iterBox(own); + const own: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 16)), Countdown.next$iter_Iterator, rs.drop)); + let sum: rs.u32 = 0; + const iter: rs.Iter = rs.iterBox(own); while (true) { - const _166: rt.u8 | rt.Done = iter.next(); - if (_166 === rt.DONE) { + const _166: rs.u8 | rs.Done = iter.next(); + if (_166 === rs.DONE) { break; } - sum = rt.u32WrappingAdd(sum, _166 as rt.u32); + sum = rs.u32WrappingAdd(sum, _166 as rs.u32); } - rt.drop(iter); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f)]; - put(out, rt.fmtFormat([args12[0], " "])); + rs.drop(iter); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; + put(out, rs.fmtFormat([args12[0], " "])); dropped(out); - const nested: rt.Iter = rt.iterDyn(rt.iterBox(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(a, 8)), Countdown.next$iter_Iterator, rt.drop))); - const inner: Countdown.Countdown = new Countdown.Countdown(rt.u8Rem(b, 8)); - const first: rt.u8 | undefined = rt.iterToOption(rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterFrom(inner, Countdown.next$iter_Iterator)))).next()); - const second: rt.u8 | undefined = rt.iterToOption(Countdown.next$iter_Iterator(inner)); - const erased: rt.Iter = rt.iterDyn(new rt.Range(rt.u8Rem(a, 4), rt.u8Rem(b, 8))); - const third: rt.u8 | undefined = rt.iterToOption(rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterBorrow(erased)))).next()); - const doubled: Countdown.Countdown = new Countdown.Countdown(rt.u8Rem(a, 8)); - const fourth: rt.u8 | undefined = rt.iterToOption(rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterFrom(doubled, Countdown.next$iter_Iterator)))).next()); - const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterBox(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(b, 8)), Countdown.next$iter_Iterator, rt.drop)), (x3: rt.u8): rt.u8 => { + const nested: rs.Iter = rs.iterDyn(rs.iterBox(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop))); + const inner: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(b, 8)); + const first: rs.u8 | undefined = rs.iterToOption(rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterFrom(inner, Countdown.next$iter_Iterator)))).next()); + const second: rs.u8 | undefined = rs.iterToOption(Countdown.next$iter_Iterator(inner)); + const erased: rs.Iter = rs.iterDyn(new rs.Range(rs.u8Rem(a, 4), rs.u8Rem(b, 8))); + const third: rs.u8 | undefined = rs.iterToOption(rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterBorrow(erased)))).next()); + const doubled: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(a, 8)); + const fourth: rs.u8 | undefined = rs.iterToOption(rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterFrom(doubled, Countdown.next$iter_Iterator)))).next()); + const mapped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterBox(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop)), (x3: rs.u8): rs.u8 => { return x3 ^ 1; }), "next"); - const _233: rt.ByteVec = rt.iterToByteVec(rt.iterBox(nested), "next"); - const _235: rt.usize = rt.ownedCount(rt.iterBox(erased)); - const _238: rt.usize = rt.ownedCount(rt.iterBox(rt.iterFrom(doubled, Countdown.next$iter_Iterator, rt.drop))); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_233), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(first, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(second, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(third, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(fourth, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(mapped), f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDisplay(_235, f), (f: rt.Formatter) => rt.usizeDisplay(_238, f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4], " ", args14[5], " ", args14[6], " ", args14[7], " "])); + const _233: rs.ByteVec = rs.iterToByteVec(rs.iterBox(nested), "next"); + const _235: rs.usize = rs.ownedCount(rs.iterBox(erased)); + const _238: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(doubled, Countdown.next$iter_Iterator, rs.drop))); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_233), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(third, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(fourth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(mapped), f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_235, f), (f: rs.Formatter) => rs.usizeDisplay(_238, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", args14[3], " ", args14[4], " ", args14[5], " ", args14[6], " ", args14[7], " "])); dropped(out); inner[Symbol.dispose](); dropped(out); - const _262: [Countdown.Countdown, rt.Range] = [new Countdown.Countdown(rt.u8Rem(a, 8)), new rt.Range(rt.u8Rem(a, 4), rt.u8Rem(b, 8))]; + const _262: [Countdown.Countdown, rs.Range] = [new Countdown.Countdown(rs.u8Rem(a, 8)), new rs.Range(rs.u8Rem(a, 4), rs.u8Rem(b, 8))]; const own2: Countdown.Countdown = _262[0]; - const range: rt.Range = _262[1]; - const hints: [rt.usize, rt.usize | undefined][] = rt.arrayMap([rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterFrom(own2, Countdown.next$iter_Iterator)))), rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterBorrow(range))))], (it: rt.Iter): [rt.usize, rt.usize | undefined] => { + const range: rs.Range = _262[1]; + const hints: [rs.usize, rs.usize | undefined][] = rs.arrayMap([rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterFrom(own2, Countdown.next$iter_Iterator)))), rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterBorrow(range))))], (it: rs.Iter): [rs.usize, rs.usize | undefined] => { return it.sizeHint(); }); - let held: Countdown.Countdown = new Countdown.Countdown(rt.u8Rem(b, 8)); - let lent2: rt.Place = rt.place(() => held, (value4) => held = value4); - const layered: rt.Place> = rt.place(() => lent2, (value5) => lent2 = value5); - const fifth: rt.u8 | undefined = rt.iterToOption(rt.iterDyn(rt.iterBorrow(rt.iterBox(rt.iterFrom(layered.v.v, Countdown.next$iter_Iterator)))).next()); - const sixth: rt.u8 | undefined = rt.iterToOption(Countdown.next$iter_Iterator(layered.v.v)); - const _301: rt.usize = rt.ownedCount(rt.iterBox(rt.iterFrom(held, Countdown.next$iter_Iterator, rt.drop))); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(hints, f, (value: [rt.usize, rt.usize | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.usizeDebug)], f)), (f: rt.Formatter) => rt.fmtOption(fifth, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(sixth, f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDisplay(_301, f)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3], " "])); + let held: Countdown.Countdown = new Countdown.Countdown(rs.u8Rem(b, 8)); + let lent2: rs.Place = rs.place(() => held, (value4) => held = value4); + const layered: rs.Place> = rs.place(() => lent2, (value5) => lent2 = value5); + const fifth: rs.u8 | undefined = rs.iterToOption(rs.iterDyn(rs.iterBorrow(rs.iterBox(rs.iterFrom(layered.v.v, Countdown.next$iter_Iterator)))).next()); + const sixth: rs.u8 | undefined = rs.iterToOption(Countdown.next$iter_Iterator(layered.v.v)); + const _301: rs.usize = rs.ownedCount(rs.iterBox(rs.iterFrom(held, Countdown.next$iter_Iterator, rs.drop))); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(hints, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f)), (f: rs.Formatter) => rs.fmtOption(fifth, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(sixth, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_301, f)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " ", args16[3], " "])); dropped(out); own2[Symbol.dispose](); dropped(out); - const seen2: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const zipped: () => rt.Iter<[rt.u8, rt.u8]> = (): rt.Iter<[rt.u8, rt.u8]> => { - return rt.iterZip(rt.iterMap(rt.iterChain(new rt.Range(0, rt.u8Rem(a, 4)), new rt.Range(2, 2)), (x4: rt.u8): rt.u8 => { - const _66: rt.RefCell = rt.refCellBorrowMut(seen2); - rt.byteVecPush(_66.value, x4); - rt.refMutRelease(_66); + const seen2: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const zipped: () => rs.Iter<[rs.u8, rs.u8]> = (): rs.Iter<[rs.u8, rs.u8]> => { + return rs.iterZip(rs.iterMap(rs.iterChain(new rs.Range(0, rs.u8Rem(a, 4)), new rs.Range(2, 2)), (x4: rs.u8): rs.u8 => { + const _66: rs.RefCell = rs.refCellBorrowMut(seen2); + rs.byteVecPush(_66.value, x4); + rs.refMutRelease(_66); return x4; - }), new rt.Range(0, rt.u8Rem(b, 4)), "len"); + }), new rs.Range(0, rs.u8Rem(b, 4)), "len"); }; - const owned: rt.Vec<[rt.u8, rt.u8]> = rt.iterToVec(rt.iterBox(zipped()), "next", 2); - const lent3: rt.Vec<[rt.u8, rt.u8]> = rt.iterToVec(rt.iterBorrow(rt.iterBox(rt.iterBorrow(zipped()))), "next", 2); - const _339: rt.RefCell = rt.refCellBorrow(seen2); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(owned.items, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtList(lent3.items, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_339.value), f, rt.u8Debug)]; - const _335: string = rt.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); - rt.refRelease(_339); + const owned: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBox(zipped()), "next", 2); + const lent3: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterBorrow(rs.iterBox(rs.iterBorrow(zipped()))), "next", 2); + const _339: rs.RefCell = rs.refCellBorrow(seen2); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(owned.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(lent3.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_339.value), f, rs.u8Debug)]; + const _335: string = rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " "]); + rs.refRelease(_339); put(out, _335); - const split: Chunks.Chunks = new of$dyns_Lease({ _0: rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)), _1: rt.usizeAdd(rt.u8Rem(b, 4) as rt.usize, 1) }); - const lens_: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterBox(split.chunks$Chunks()), (a0: rt.ByteSlice): rt.usize => { + const split: Chunks.Chunks = new of$dyns_Lease({ _0: rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)), _1: rs.usizeAdd(rs.u8Rem(b, 4) as rs.usize, 1) }); + const lens_: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterBox(split.chunks$Chunks()), (a0: rs.ByteSlice): rs.usize => { return a0.length; }), "next", 4); - const _369: rt.usize = rt.ownedCount(rt.iterBox(split.chunks$Chunks())); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(lens_.items, f, rt.usizeDebug), (f: rt.Formatter) => rt.usizeDisplay(_369, f)]; - put(out, rt.fmtFormat([args20[0], " ", args20[1], " "])); - const part3 = drain(rt.iterDyn(rt.iterBorrow(rt.iterFuse(rt.iterFrom({ _0: rt.u8Rem(a, 4) }, Resuming.next$iter_Iterator))))); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part3)]; - put(out, rt.fmtFormat([args22[0], " "])); - const resuming: Resuming.Resuming = { _0: rt.u8Rem(b, 4) }; - const up: rt.Iter = rt.iterDyn(rt.iterFrom(resuming, Resuming.next$iter_Iterator)); - const part4 = [rt.iterToOption(up.next()), rt.iterToOption(up.next()), rt.iterToOption(up.next()), rt.iterToOption(up.next()), rt.iterToOption(up.next())] as [rt.u8 | undefined, rt.u8 | undefined, rt.u8 | undefined, rt.u8 | undefined, rt.u8 | undefined]; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part4[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(part4[1], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(part4[2], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(part4[3], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(part4[4], f, rt.u8Debug)], f)]; - put(out, rt.fmtFormat([args24[0], " "])); - const boxed3: rt.Iter = rt.iterDyn(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(a, 8)), Countdown.next$iter_Iterator, rt.drop)); + const _369: rs.usize = rs.ownedCount(rs.iterBox(split.chunks$Chunks())); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lens_.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_369, f)]; + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); + const part3 = drain(rs.iterDyn(rs.iterBorrow(rs.iterFuse(rs.iterFrom({ _0: rs.u8Rem(a, 4) }, Resuming.next$iter_Iterator))))); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part3)]; + put(out, rs.fmtFormat([args22[0], " "])); + const resuming: Resuming.Resuming = { _0: rs.u8Rem(b, 4) }; + const up: rs.Iter = rs.iterDyn(rs.iterFrom(resuming, Resuming.next$iter_Iterator)); + const part4 = [rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next()), rs.iterToOption(up.next())] as [rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined, rs.u8 | undefined]; + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[2], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[3], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(part4[4], f, rs.u8Debug)], f)]; + put(out, rs.fmtFormat([args24[0], " "])); + const boxed3: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(a, 8)), Countdown.next$iter_Iterator, rs.drop)); const part5 = drain(boxed3); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part5)]; - put(out, rt.fmtFormat([args26[0], " "])); - rt.drop(boxed3); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; + put(out, rs.fmtFormat([args26[0], " "])); + rs.drop(boxed3); dropped(out); - const concrete: rt.Arc> = new rt.Arc(rt.vecIntoIter(tagged(front), rt.drop)); - const shared: rt.Arc> = new rt.ArcDyn(concrete, rt.iterDyn(concrete.value)); - const other: rt.Arc> = rt.arcClone(shared); - const weak: rt.Weak> = new rt.Weak(other); - const _456: [rt.usize, rt.usize | undefined] = other.value.sizeHint(); - const _460: boolean = rt.arcGetMut(shared) === undefined; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_456[0], f), (f: rt.Formatter) => rt.fmtOption(_456[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtBool(_460, f)]; - put(out, rt.fmtFormat([args28[0], " ", args28[1], " "])); + const concrete: rs.Arc> = new rs.Arc(rs.vecIntoIter(tagged(front), rs.drop)); + const shared: rs.Arc> = new rs.ArcDyn(concrete, rs.iterDyn(concrete.value)); + const other: rs.Arc> = rs.arcClone(shared); + const weak: rs.Weak> = new rs.Weak(other); + const _456: [rs.usize, rs.usize | undefined] = other.value.sizeHint(); + const _460: boolean = rs.arcGetMut(shared) === undefined; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_456[0], f), (f: rs.Formatter) => rs.fmtOption(_456[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_460, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); other[Symbol.dispose](); weak[Symbol.dispose](); - const taken: rt.u8 | undefined = option_map$08a6hpg(option_andThen$0v0bj8w(rt.arcGetMut(shared), (it2: rt.Iter): Tagged.Tagged | undefined => { - return rt.iterToOption(it2.next()); - }), (t5: Tagged.Tagged): rt.u8 => { - const _014: rt.u8 = t5._0; + const taken: rs.u8 | undefined = option_map$11l9b8r(option_andThen$1xlvufy(rs.arcGetMut(shared), (it2: rs.Iter): Tagged.Tagged | undefined => { + return rs.iterToOption(it2.next()); + }), (t5: Tagged.Tagged): rs.u8 => { + const _014: rs.u8 = t5._0; t5[Symbol.dispose](); return _014; }); dropped(out); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(taken, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args30[0], " "])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(taken, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args30[0], " "])); shared[Symbol.dispose](); dropped(out); - const _492: rt.Arc> = new rt.Arc(rt.byteVecIntoIter(rt.byteSliceToByteVec(back))); - const exact: rt.Arc> = new rt.ArcDyn(_492, rt.iterDyn(_492.value)); - const up2: rt.Arc> = rt.arcClone(exact); - const _506: rt.usize = exact.value.len(); - const _510: rt.u8 | undefined | rt.None = option_map$1qfllpb(rt.arcGetMut(up2), (it3: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it3.next()); + const _492: rs.Arc> = new rs.Arc(rs.byteVecIntoIter(rs.byteSliceToByteVec(back))); + const exact: rs.Arc> = new rs.ArcDyn(_492, rs.iterDyn(_492.value)); + const up2: rs.Arc> = rs.arcClone(exact); + const _506: rs.usize = exact.value.len(); + const _510: rs.u8 | undefined | rs.None = option_map$0vt270f(rs.arcGetMut(up2), (it3: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it3.next()); }); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_506, f), (f: rt.Formatter) => rt.fmtOption(_510, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None)]; - put(out, rt.fmtFormat([args32[0], " ", args32[1], " "])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_506, f), (f: rs.Formatter) => rs.fmtOption(_510, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1], " "])); exact[Symbol.dispose](); - const next: rt.u8 | undefined = option_andThen$0ntiuws(rt.arcGetMut(up2), (it4: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it4.next()); + const next: rs.u8 | undefined = option_andThen$0imujmv(rs.arcGetMut(up2), (it4: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it4.next()); }); - const _530: [rt.usize, rt.usize | undefined] = up2.value.sizeHint(); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(next, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_530[0], f), (f: rt.Formatter) => rt.fmtOption(_530[1], f, rt.usizeDebug)], f)]; - put(out, rt.fmtFormat([args34[0], " ", args34[1], " "])); - const fromBox: rt.Arc> = new rt.Arc(rt.iterDyn(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(b, 8)), Countdown.next$iter_Iterator, rt.drop))); - const part6 = option_andThen$0ntiuws(rt.arcGetMut(fromBox), (it5: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(it5.next()); + const _530: [rs.usize, rs.usize | undefined] = up2.value.sizeHint(); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_530[0], f), (f: rs.Formatter) => rs.fmtOption(_530[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args34[0], " ", args34[1], " "])); + const fromBox: rs.Arc> = new rs.Arc(rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop))); + const part6 = option_andThen$0imujmv(rs.arcGetMut(fromBox), (it5: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(it5.next()); }); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args36[0], " "])); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args36[0], " "])); fromBox[Symbol.dispose](); dropped(out); - const counted2: rt.Arc = new rt.Arc(new Countdown.Countdown(rt.u8Rem(a, 8))); - const weak3: rt.Weak> = rt.weakDyn(new rt.Weak(counted2), (arc: rt.Arc): rt.Arc> => { - return new rt.ArcDyn(arc, rt.iterDyn(rt.iterFrom(arc.value, Countdown.next$iter_Iterator, rt.drop))); + const counted2: rs.Arc = new rs.Arc(new Countdown.Countdown(rs.u8Rem(a, 8))); + const weak3: rs.Weak> = rs.weakDyn(new rs.Weak(counted2), (arc: rs.Arc): rs.Arc> => { + return new rs.ArcDyn(arc, rs.iterDyn(rs.iterFrom(arc.value, Countdown.next$iter_Iterator, rs.drop))); }); - const part7 = option_map$0oedb57(rt.weakUpgrade(weak3), (it6: rt.Arc>): [rt.usize, rt.usize | undefined] => { - const _018: [rt.usize, rt.usize | undefined] = it6.value.sizeHint(); + const part7 = option_map$1b57zy8(rs.weakUpgrade(weak3), (it6: rs.Arc>): [rs.usize, rs.usize | undefined] => { + const _018: [rs.usize, rs.usize | undefined] = it6.value.sizeHint(); it6[Symbol.dispose](); return _018; }); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part7, f, (value: [rt.usize, rt.usize | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.usizeDebug)], f))]; - put(out, rt.fmtFormat([args38[0], " "])); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, (value: [rs.usize, rs.usize | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.usizeDebug)], f))]; + put(out, rs.fmtFormat([args38[0], " "])); counted2[Symbol.dispose](); - const _596: rt.Arc> | undefined = rt.weakUpgrade(weak3); + const _596: rs.Arc> | undefined = rs.weakUpgrade(weak3); const part8 = _596 === undefined; - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part8, f)]; - const _590: string = rt.fmtFormat([args40[0], " "]); - rt.drop(_596); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; + const _590: string = rs.fmtFormat([args40[0], " "]); + rs.drop(_596); put(out, _590); dropped(out); - const pinned: rt.Iter = rt.iterDyn(rt.iterFrom(new Countdown.Countdown(rt.u8Rem(b, 8)), Countdown.next$iter_Iterator, rt.drop)); - const part9 = rt.iterToOption(pinned.next()); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args42[0]])); - rt.drop(pinned); + const pinned: rs.Iter = rs.iterDyn(rs.iterFrom(new Countdown.Countdown(rs.u8Rem(b, 8)), Countdown.next$iter_Iterator, rs.drop)); + const part9 = rs.iterToOption(pinned.next()); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args42[0]])); + rs.drop(pinned); dropped(out); weak3[Symbol.dispose](); up2[Symbol.dispose](); @@ -1027,12 +1027,12 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { } /** What `it` yields up to its end and twice past it. */ -export function drain(it: rt.Iter): string { - const items: rt.ByteVec = rt.iterToByteVec(rt.iterBorrow(it), "next"); - const _7: rt.u8 | undefined = rt.iterToOption(it.next()); - const _9: rt.u8 | undefined = rt.iterToOption(it.next()); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(items), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_7, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_9, f, rt.u8Debug)]; - return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); +export function drain(it: rs.Iter): string { + const items: rs.ByteVec = rs.iterToByteVec(rs.iterBorrow(it), "next"); + const _7: rs.u8 | undefined = rs.iterToOption(it.next()); + const _9: rs.u8 | undefined = rs.iterToOption(it.next()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(items), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_7, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_9, f, rs.u8Debug)]; + return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); } /** @@ -1040,172 +1040,172 @@ export function drain(it: rt.Iter): string { * an `Rc` or an `Arc`, a `Pin`, and an `Rc` or an `Arc` made from a box of one. Counts, * upgrades, `downcast`, and what drops when. */ -export function pointers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let f!: rt.Arc<(a0: rt.u8) => rt.u8>; +export function pointers(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let f!: rs.Arc<(a0: rs.u8) => rs.u8>; let _595: boolean = false; if (dataLen >= 2) { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const sq: rt.Arc = new rt.Arc({ side: dataData[dataStart] as rt.u16 }); - const weak2: rt.Weak = rt.weakDyn(new rt.Weak(sq), (arc: rt.Arc): rt.Arc => { - return new rt.ArcDyn(arc, new of$dyns_Square(arc.value)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const sq: rs.Arc = new rs.Arc({ side: dataData[dataStart] as rs.u16 }); + const weak2: rs.Weak = rs.weakDyn(new rs.Weak(sq), (arc: rs.Arc): rs.Arc => { + return new rs.ArcDyn(arc, new of$dyns_Square(arc.value)); }); - const _19: rt.Arc = rt.arcClone(sq); - const named: rt.Arc = new rt.ArcDyn(_19, new of$dyns_Square(_19.value)); - const shape: rt.Arc = rt.arcClone(named); - const other: rt.Weak = new rt.Weak(shape); + const _19: rs.Arc = rs.arcClone(sq); + const named: rs.Arc = new rs.ArcDyn(_19, new of$dyns_Square(_19.value)); + const shape: rs.Arc = rs.arcClone(named); + const other: rs.Weak = new rs.Weak(shape); const _34: string = named.value.label$Named(); - const _38: rt.u32 = shape.value.area$Shape(); - const _42: rt.usize = sq.strong; - const _45: rt.usize = weak2.arc.strong; - const _48: rt.usize = rt.weakWeakCount(weak2); - const _51: boolean = rt.arcPtrEq(weak2.arc, other.arc); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _34), (f: rt.Formatter) => rt.u32Display(_38, f), (f: rt.Formatter) => rt.usizeDisplay(_42, f), (f: rt.Formatter) => rt.usizeDisplay(_45, f), (f: rt.Formatter) => rt.usizeDisplay(_48, f), (f: rt.Formatter) => rt.fmtBool(_51, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " "])); - const again: rt.Weak = rt.weakClone(weak2); + const _38: rs.u32 = shape.value.area$Shape(); + const _42: rs.usize = sq.strong; + const _45: rs.usize = weak2.arc.strong; + const _48: rs.usize = rs.weakWeakCount(weak2); + const _51: boolean = rs.arcPtrEq(weak2.arc, other.arc); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _34), (f: rs.Formatter) => rs.u32Display(_38, f), (f: rs.Formatter) => rs.usizeDisplay(_42, f), (f: rs.Formatter) => rs.usizeDisplay(_45, f), (f: rs.Formatter) => rs.usizeDisplay(_48, f), (f: rs.Formatter) => rs.fmtBool(_51, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " "])); + const again: rs.Weak = rs.weakClone(weak2); sq[Symbol.dispose](); named[Symbol.dispose](); - const _75: rt.u32 | undefined = option_map$1i542n2(rt.weakUpgrade(again), (s: rt.Arc): rt.u32 => { - const _0: rt.u32 = s.value.area$Shape(); + const _75: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(again), (s: rs.Arc): rs.u32 => { + const _0: rs.u32 = s.value.area$Shape(); s[Symbol.dispose](); return _0; }); - const _79: rt.usize = shape.strong; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_75, f, rt.u32Debug), (f: rt.Formatter) => rt.usizeDisplay(_79, f)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " "])); + const _79: rs.usize = shape.strong; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_75, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_79, f)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " "])); shape[Symbol.dispose](); - const _97: rt.Arc | undefined = rt.weakUpgrade(weak2); + const _97: rs.Arc | undefined = rs.weakUpgrade(weak2); const _95: boolean = _97 === undefined; - const _102: rt.Arc | undefined = rt.weakUpgrade(again); + const _102: rs.Arc | undefined = rs.weakUpgrade(again); const _100: boolean = _102 === undefined; - const _105: rt.usize = weak2.arc.strong; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_95, f), (f: rt.Formatter) => rt.fmtBool(_100, f), (f: rt.Formatter) => rt.usizeDisplay(_105, f)]; - const _91: string = rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]); - rt.drop(_102); - rt.drop(_97); + const _105: rs.usize = weak2.arc.strong; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtBool(_100, f), (f: rs.Formatter) => rs.usizeDisplay(_105, f)]; + const _91: string = rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2], " "]); + rs.drop(_102); + rs.drop(_97); put(out, _91); - const noisy: rt.Arc = new rt.Arc(new Noisy.Noisy(dataData[dataStart + 1], rt.arcClone(log))); - const weak4: rt.Weak = rt.weakDyn(new rt.Weak(noisy), (arc2: rt.Arc): rt.Arc => { - return new rt.ArcDyn(arc2, new of$dyns_Noisy(arc2.value)); + const noisy: rs.Arc = new rs.Arc(new Noisy.Noisy(dataData[dataStart + 1], rs.arcClone(log))); + const weak4: rs.Weak = rs.weakDyn(new rs.Weak(noisy), (arc2: rs.Arc): rs.Arc => { + return new rs.ArcDyn(arc2, new of$dyns_Noisy(arc2.value)); }); - const part = option_map$1i542n2(rt.weakUpgrade(weak4), (s2: rt.Arc): rt.u32 => { - const _02: rt.u32 = s2.value.area$Shape(); + const part = option_map$1mach0o(rs.weakUpgrade(weak4), (s2: rs.Arc): rs.u32 => { + const _02: rs.u32 = s2.value.area$Shape(); s2[Symbol.dispose](); return _02; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.u32Debug)]; - put(out, rt.fmtFormat([args8[0], " "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; + put(out, rs.fmtFormat([args8[0], " "])); noisy[Symbol.dispose](); - const _147: rt.Arc | undefined = rt.weakUpgrade(weak4); + const _147: rs.Arc | undefined = rs.weakUpgrade(weak4); const _145: boolean = _147 === undefined; - const _150: rt.RefCell = rt.refCellBorrow(log.value); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_145, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_150.value), f, rt.u8Debug)]; - const _141: string = rt.fmtFormat([args10[0], " ", args10[1], " "]); - rt.refRelease(_150); - rt.drop(_147); + const _150: rs.RefCell = rs.refCellBorrow(log.value); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_145, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_150.value), f, rs.u8Debug)]; + const _141: string = rs.fmtFormat([args10[0], " ", args10[1], " "]); + rs.refRelease(_150); + rs.drop(_147); put(out, _141); - const looped: rt.Arc = rt.arcNewCyclic((me: rt.Weak): Looped.Looped => { - return new Looped.Looped(dataData[dataStart], rt.weakDyn(rt.weakClone(me), (arc3: rt.Arc): rt.Arc => { - return new rt.ArcDyn(arc3, new of$dyns_Looped(arc3.value)); + const looped: rs.Arc = rs.arcNewCyclic((me: rs.Weak): Looped.Looped => { + return new Looped.Looped(dataData[dataStart], rs.weakDyn(rs.weakClone(me), (arc3: rs.Arc): rs.Arc => { + return new rs.ArcDyn(arc3, new of$dyns_Looped(arc3.value)); })); }); - const _168: rt.u32 | undefined = option_map$1i542n2(rt.weakUpgrade(looped.value.me), (s3: rt.Arc): rt.u32 => { - const _04: rt.u32 = s3.value.area$Shape(); + const _168: rs.u32 | undefined = option_map$1mach0o(rs.weakUpgrade(looped.value.me), (s3: rs.Arc): rs.u32 => { + const _04: rs.u32 = s3.value.area$Shape(); s3[Symbol.dispose](); return _04; }); - const _174: rt.usize = looped.strong; - const _177: rt.usize = looped.weak; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_168, f, rt.u32Debug), (f: rt.Formatter) => rt.usizeDisplay(_174, f), (f: rt.Formatter) => rt.usizeDisplay(_177, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); - const pinned: Shape.Shape = new of$dyns_Noisy(new Noisy.Noisy(rt.u8WrappingAdd(dataData[dataStart], 1), rt.arcClone(log))); - let n: rt.u32 = dataData[dataStart + 1] as rt.u32; - const borrowed2: Shape.Shape = new ofPlace$u32(rt.place(() => n, (value) => n = value)); - const _205: rt.u32 = pinned.area$Shape(); - const _209: rt.u8 = pinned.sides$Shape(); - const _213: rt.u32 = borrowed2.area$Shape(); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_205, f), (f: rt.Formatter) => rt.u8Display(_209, f), (f: rt.Formatter) => rt.u32Display(_213, f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); - rt.drop(pinned); - const _230: rt.RefCell = rt.refCellBorrow(log.value); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_230.value), f, rt.u8Debug)]; - const _226: string = rt.fmtFormat([args16[0], " "]); - rt.refRelease(_230); + const _174: rs.usize = looped.strong; + const _177: rs.usize = looped.weak; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_168, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_174, f), (f: rs.Formatter) => rs.usizeDisplay(_177, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " "])); + const pinned: Shape.Shape = new of$dyns_Noisy(new Noisy.Noisy(rs.u8WrappingAdd(dataData[dataStart], 1), rs.arcClone(log))); + let n: rs.u32 = dataData[dataStart + 1] as rs.u32; + const borrowed2: Shape.Shape = new ofPlace$u32(rs.place(() => n, (value) => n = value)); + const _205: rs.u32 = pinned.area$Shape(); + const _209: rs.u8 = pinned.sides$Shape(); + const _213: rs.u32 = borrowed2.area$Shape(); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_205, f), (f: rs.Formatter) => rs.u8Display(_209, f), (f: rs.Formatter) => rs.u32Display(_213, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + rs.drop(pinned); + const _230: rs.RefCell = rs.refCellBorrow(log.value); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_230.value), f, rs.u8Debug)]; + const _226: string = rs.fmtFormat([args16[0], " "]); + rs.refRelease(_230); put(out, _226); - const boxes: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rt.u8): Shape.Shape => { - const x2: rt.u8 = _2; - const _43: rt.u8 = rt.u8Rem(x2, 3); + const boxes: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): Shape.Shape => { + const x2: rs.u8 = _2; + const _43: rs.u8 = rs.u8Rem(x2, 3); if (_43 === 0) { - return new of$dyns_Noisy(new Noisy.Noisy(x2, rt.arcClone(log))); + return new of$dyns_Noisy(new Noisy.Noisy(x2, rs.arcClone(log))); } if (_43 === 1) { - return new of$u32(x2 as rt.u32); + return new of$u32(x2 as rs.u32); } return new of$dyns_Tri({ tag: "Tall", _0: x2 } as Tri.Tri); }), undefined, 8, true); - const rcs: rt.Vec> = new rt.Vec(); - const arcs: rt.Vec> = new rt.Vec(); - const iter: rt.Iter<[rt.usize, Shape.Shape]> = rt.iterEnumerate(rt.vecIntoIter(boxes, rt.drop)); + const rcs: rs.Vec> = new rs.Vec(); + const arcs: rs.Vec> = new rs.Vec(); + const iter: rs.Iter<[rs.usize, Shape.Shape]> = rs.iterEnumerate(rs.vecIntoIter(boxes, rs.drop)); while (true) { - const _249: [rt.usize, Shape.Shape] | rt.Done = iter.next(); - if (_249 === rt.DONE) { + const _249: [rs.usize, Shape.Shape] | rs.Done = iter.next(); + if (_249 === rs.DONE) { break; } - const i: rt.usize = _249[0]; + const i: rs.usize = _249[0]; const boxed: Shape.Shape = _249[1]; - if (rt.usizeRem(i, 2) === 0) { - const _257: rt.Arc = new rt.Arc(boxed); + if (rs.usizeRem(i, 2) === 0) { + const _257: rs.Arc = new rs.Arc(boxed); rcs.items.push(_257); } else { - const _259: rt.Arc = new rt.Arc(boxed); + const _259: rs.Arc = new rs.Arc(boxed); arcs.items.push(_259); } } - rt.drop(iter); - const kept: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterStepBy(rt.iterSlice(rcs.items), 2), (a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + rs.drop(iter); + const kept: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterStepBy(rs.iterSlice(rcs.items), 2), (a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); }), undefined, 8, true); - const part2 = rt.iterToVec(rt.iterChain(rt.iterMap(rt.iterSlice(rcs.items), (s4: rt.Arc): rt.u32 => { + const part2 = rs.iterToVec(rs.iterChain(rs.iterMap(rs.iterSlice(rcs.items), (s4: rs.Arc): rs.u32 => { return s4.value.area$Shape(); - }), rt.iterMap(rt.iterSlice(arcs.items), (s5: rt.Arc): rt.u32 => { + }), rs.iterMap(rs.iterSlice(arcs.items), (s5: rs.Arc): rs.u32 => { return s5.value.area$Shape(); })), undefined, 4, true); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, rt.u32Debug)]; - put(out, rt.fmtFormat([args18[0], " "])); - const _291: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_291.value); - rt.refMutRelease(_291); - rt.dropVec(arcs); - const _304: rt.RefCell = rt.refCellBorrow(log.value); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_304.value), f, rt.u8Debug)]; - const _300: string = rt.fmtFormat([args20[0], " "]); - rt.refRelease(_304); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)]; + put(out, rs.fmtFormat([args18[0], " "])); + const _291: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_291.value); + rs.refMutRelease(_291); + rs.dropVec(arcs); + const _304: rs.RefCell = rs.refCellBorrow(log.value); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_304.value), f, rs.u8Debug)]; + const _300: string = rs.fmtFormat([args20[0], " "]); + rs.refRelease(_304); put(out, _300); - rt.dropVec(rcs); - const _321: rt.RefCell = rt.refCellBorrow(log.value); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_321.value), f, rt.u8Debug)]; - const _317: string = rt.fmtFormat([args22[0], " "]); - rt.refRelease(_321); + rs.dropVec(rcs); + const _321: rs.RefCell = rs.refCellBorrow(log.value); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_321.value), f, rs.u8Debug)]; + const _317: string = rs.fmtFormat([args22[0], " "]); + rs.refRelease(_321); put(out, _317); - rt.dropVec(kept); - const _337: rt.RefCell = rt.refCellBorrow(log.value); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_337.value), f, rt.u8Debug)]; - const _333: string = rt.fmtFormat([args24[0], " "]); - rt.refRelease(_337); + rs.dropVec(kept); + const _337: rs.RefCell = rs.refCellBorrow(log.value); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_337.value), f, rs.u8Debug)]; + const _333: string = rs.fmtFormat([args24[0], " "]); + rs.refRelease(_337); put(out, _333); - const _345: rt.Arc = new rt.Arc({ side: dataData[dataStart + 1] as rt.u16 }); - const any: rt.Arc = new rt.ArcDyn(_345, new of$dyns_Square(_345.value)); - const _351: rt.Result, rt.Arc> = rt.arcDowncast(rt.arcClone(any), of$dyns_Tri, (object) => object.v); + const _345: rs.Arc = new rs.Arc({ side: dataData[dataStart + 1] as rs.u16 }); + const any: rs.Arc = new rs.ArcDyn(_345, new of$dyns_Square(_345.value)); + const _351: rs.Result, rs.Arc> = rs.arcDowncast(rs.arcClone(any), of$dyns_Tri, (object) => object.v); const wrong: boolean = !_351.ok; drop$Result_Rc_dyns_Tri_Rc_dyn_Any(_351); - const _355: rt.Result, rt.Arc> = rt.arcDowncast(any, of$dyns_Square, (object) => object.v); + const _355: rs.Result, rs.Arc> = rs.arcDowncast(any, of$dyns_Square, (object) => object.v); if (_355.ok) { - const sq2: rt.Arc = _355.value; + const sq2: rs.Arc = _355.value; const _365: Square.Square = sq2.value; - const _368: rt.usize = sq2.strong; - const _372: rt.Fmt = (f: rt.Formatter) => rt.fmtBool(wrong, f); + const _368: rs.usize = sq2.strong; + const _372: rs.Fmt = (f: rs.Formatter) => rs.fmtBool(wrong, f); const arg = _365.side; - const args26: rt.Fmt[] = [_372, (f: rt.Formatter) => rt.u16Display(arg, f), (f: rt.Formatter) => rt.usizeDisplay(_368, f)]; - put(out, rt.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " "])); + const args26: rs.Fmt[] = [_372, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", args26[2], " "])); sq2[Symbol.dispose](); } else { put(out, "none "); @@ -1213,27 +1213,27 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe if (!_355.ok) { drop$Result_Rc_dyns_Square_Rc_dyn_Any(_355); } - const any2: rt.Arc = new rt.Arc(new of$dyns_Noisy(new Noisy.Noisy(rt.u8WrappingAdd(dataData[dataStart + 1], 1), rt.arcClone(log)))); - const held: rt.Arc = rt.arcClone(any2); + const any2: rs.Arc = new rs.Arc(new of$dyns_Noisy(new Noisy.Noisy(rs.u8WrappingAdd(dataData[dataStart + 1], 1), rs.arcClone(log)))); + const held: rs.Arc = rs.arcClone(any2); _595 = true; b5: { - const _388: [rt.Result, rt.Arc>, rt.Result, rt.Arc>] = [rt.arcDowncast(rt.arcClone(any2), of$dyns_Noisy, (object) => object.v), rt.arcDowncast(rt.arcClone(held), of$dyns_Noisy, (object) => object.v)]; + const _388: [rs.Result, rs.Arc>, rs.Result, rs.Arc>] = [rs.arcDowncast(rs.arcClone(any2), of$dyns_Noisy, (object) => object.v), rs.arcDowncast(rs.arcClone(held), of$dyns_Noisy, (object) => object.v)]; if (_388[0].ok) { if (_388[1].ok) { - const x: rt.Arc = (_388[0] as { ok: true; value: rt.Arc }).value; - const y: rt.Arc = (_388[1] as { ok: true; value: rt.Arc }).value; - const _403: rt.Arc = rt.arcClone(x); - const _402: rt.Arc = new rt.ArcDyn(_403, new of$dyns_Noisy(_403.value)); - const _406: rt.Arc = rt.arcClone(y); - const _401: [rt.Arc, rt.Arc] = [_402, new rt.ArcDyn(_406, new of$dyns_Noisy(_406.value))]; - const ex: rt.Arc = _402; - const ey: rt.Arc = _401[1]; + const x: rs.Arc = (_388[0] as { ok: true; value: rs.Arc }).value; + const y: rs.Arc = (_388[1] as { ok: true; value: rs.Arc }).value; + const _403: rs.Arc = rs.arcClone(x); + const _402: rs.Arc = new rs.ArcDyn(_403, new of$dyns_Noisy(_403.value)); + const _406: rs.Arc = rs.arcClone(y); + const _401: [rs.Arc, rs.Arc] = [_402, new rs.ArcDyn(_406, new of$dyns_Noisy(_406.value))]; + const ex: rs.Arc = _402; + const ey: rs.Arc = _401[1]; const _416: boolean = x === y; - const _420: boolean = rt.arcPtrEq(ex, ey); - const _424: boolean = rt.arcPtrEq(ex, held); - const _428: rt.usize = x.strong; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_416, f), (f: rt.Formatter) => rt.fmtBool(_420, f), (f: rt.Formatter) => rt.fmtBool(_424, f), (f: rt.Formatter) => rt.usizeDisplay(_428, f)]; - put(out, rt.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " "])); + const _420: boolean = rs.arcPtrEq(ex, ey); + const _424: boolean = rs.arcPtrEq(ex, held); + const _428: rs.usize = x.strong; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_416, f), (f: rs.Formatter) => rs.fmtBool(_420, f), (f: rs.Formatter) => rs.fmtBool(_424, f), (f: rs.Formatter) => rs.usizeDisplay(_428, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " "])); ey[Symbol.dispose](); ex[Symbol.dispose](); y[Symbol.dispose](); @@ -1242,34 +1242,34 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe } } if (_388[0].ok) { - (_388[0] as { ok: true; value: rt.Arc }).value[Symbol.dispose](); + (_388[0] as { ok: true; value: rs.Arc }).value[Symbol.dispose](); } else { drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_388[0]); } if (_388[1].ok) { - (_388[1] as { ok: true; value: rt.Arc }).value[Symbol.dispose](); + (_388[1] as { ok: true; value: rs.Arc }).value[Symbol.dispose](); } else { drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_388[1]); } } - const _440: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_440.value); - rt.refMutRelease(_440); - const _444: rt.Result, rt.Arc> = rt.arcDowncast(any2, of$dyns_Noisy, (object) => object.v); + const _440: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_440.value); + rs.refMutRelease(_440); + const _444: rs.Result, rs.Arc> = rs.arcDowncast(any2, of$dyns_Noisy, (object) => object.v); if (_444.ok) { - const n2: rt.Arc = _444.value; + const n2: rs.Arc = _444.value; const _455: Noisy.Noisy = n2.value; - const _458: rt.usize = n2.strong; + const _458: rs.usize = n2.strong; const arg2 = _455._0; - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg2, f), (f: rt.Formatter) => rt.usizeDisplay(_458, f)]; - put(out, rt.fmtFormat([args30[0], " ", args30[1], " "])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.usizeDisplay(_458, f)]; + put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); _595 = false; held[Symbol.dispose](); - const _475: rt.usize = n2.strong; - const _478: rt.RefCell = rt.refCellBorrow(log.value); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_475, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_478.value), f, rt.u8Debug)]; - const _471: string = rt.fmtFormat([args32[0], " ", args32[1], " "]); - rt.refRelease(_478); + const _475: rs.usize = n2.strong; + const _478: rs.RefCell = rs.refCellBorrow(log.value); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_475, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_478.value), f, rs.u8Debug)]; + const _471: string = rs.fmtFormat([args32[0], " ", args32[1], " "]); + rs.refRelease(_478); put(out, _471); n2[Symbol.dispose](); } else { @@ -1278,29 +1278,29 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe if (!_444.ok) { drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_444); } - const _495: rt.RefCell = rt.refCellBorrow(log.value); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_495.value), f, rt.u8Debug)]; - const _491: string = rt.fmtFormat([args34[0], " "]); - rt.refRelease(_495); + const _495: rs.RefCell = rs.refCellBorrow(log.value); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_495.value), f, rs.u8Debug)]; + const _491: string = rs.fmtFormat([args34[0], " "]); + rs.refRelease(_495); put(out, _491); - const part3 = option_map$0j05j69(ok$00p9ap8(rt.arcDowncast(new rt.Arc(new of$u32(dataData[dataStart] as rt.u32)), of$u32, (object) => object.v)), (n3: rt.Arc): rt.u32 => { - const _09: rt.u32 = n3.value; + const part3 = option_map$1bn5ufk(ok$1oks8md(rs.arcDowncast(new rs.Arc(new of$u32(dataData[dataStart] as rs.u32)), of$u32, (object) => object.v)), (n3: rs.Arc): rs.u32 => { + const _09: rs.u32 = n3.value; n3[Symbol.dispose](); return _09; }); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.u32Debug)]; - put(out, rt.fmtFormat([args36[0], " "])); - const _523: rt.Arc<(a0: rt.u8) => rt.u8> = new rt.Arc((x3: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(x3, dataData[dataStart]); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; + put(out, rs.fmtFormat([args36[0], " "])); + const _523: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x3: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(x3, dataData[dataStart]); }); - f = new rt.ArcDyn(_523, _523.value); - const g: rt.Arc<(a0: rt.u8) => rt.u8> = new rt.Arc((x4: rt.u8): rt.u8 => { + f = new rs.ArcDyn(_523, _523.value); + const g: rs.Arc<(a0: rs.u8) => rs.u8> = new rs.Arc((x4: rs.u8): rs.u8 => { return x4 ^ dataData[dataStart + 1]; }); - const _537: rt.u8 = f.value(dataData[dataStart + 1]); - const _543: rt.u8 = g.value(dataData[dataStart]); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_537, f), (f: rt.Formatter) => rt.u8Display(_543, f)]; - put(out, rt.fmtFormat([args38[0], " ", args38[1]])); + const _537: rs.u8 = f.value(dataData[dataStart + 1]); + const _543: rs.u8 = g.value(dataData[dataStart]); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_537, f), (f: rs.Formatter) => rs.u8Display(_543, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1]])); g[Symbol.dispose](); f[Symbol.dispose](); if (_595) { @@ -1317,9 +1317,9 @@ export function pointers(dataData: Uint8Array, dataStart: number, dataLen: numbe } /** A tag of `t`, below 0x80, which logs it with the high bit set as it is made. */ -export function made(t: rt.u8): Tagged.Tagged { - rt.localKeyWithBorrowMut(DROPS, (d: rt.ByteVec): undefined => { - rt.byteVecPush(d, t | 128); +export function made(t: rs.u8): Tagged.Tagged { + rs.localKeyWithBorrowMut(DROPS, (d: rs.ByteVec): undefined => { + rs.byteVecPush(d, t | 128); }); return new Tagged.Tagged(t); } @@ -1330,26 +1330,26 @@ export function made(t: rt.u8): Tagged.Tagged { * which makes and drops each skipped pair a side at a time, where its folds make the pair * whole. */ -export function skipped(data: rt.ByteSlice): rt.Iter<[Tagged.Tagged, Tagged.Tagged]> { - const _4: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, [0, data] as [rt.u8, rt.ByteSlice], (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function skipped(data: rs.ByteSlice): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> { + const _4: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, [0, data] as [rs.u8, rs.ByteSlice], (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const n: rt.u8 = _4[0]; - const _10: rt.usize = rt.usizeRem(n as rt.usize, rt.usizeAdd(_4[1].length, 1)); - const slice: rt.ByteSlice = _4[1]; + const n: rs.u8 = _4[0]; + const _10: rs.usize = rs.usizeRem(n as rs.usize, rs.usizeAdd(_4[1].length, 1)); + const slice: rs.ByteSlice = _4[1]; if (_10 > slice.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - return rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(slice.data, slice.start, _10))), (_24: rt.u8): Tagged.Tagged => { + return rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(slice.data, slice.start, _10))), (_24: rs.u8): Tagged.Tagged => { return made(_24 & 63); - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(slice.data, slice.start + _10, slice.length - _10))), (_25: rt.u8): Tagged.Tagged => { + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(slice.data, slice.start + _10, slice.length - _10))), (_25: rs.u8): Tagged.Tagged => { return made((_25 & 63) | 64); - }), [true, true], rt.drop, rt.drop), rt.u8Rem(n, 3) as rt.usize, drop$tuple2_dyns_Tagged_dyns_Tagged); + }), [true, true], rs.drop, rs.drop), rs.u8Rem(n, 3) as rs.usize, drop$tuple2_dyns_Tagged_dyns_Tagged); } -export function tags(pair: [Tagged.Tagged, Tagged.Tagged] | undefined): [rt.u8, rt.u8] | undefined { - return option_map$0z7s8q7(pair, (p: [Tagged.Tagged, Tagged.Tagged]): [rt.u8, rt.u8] => { - const _02: [rt.u8, rt.u8] = [p[0]._0, p[1]._0]; +export function tags(pair: [Tagged.Tagged, Tagged.Tagged] | undefined): [rs.u8, rs.u8] | undefined { + return option_map$1aeqf1p(pair, (p: [Tagged.Tagged, Tagged.Tagged]): [rs.u8, rs.u8] => { + const _02: [rs.u8, rs.u8] = [p[0]._0, p[1]._0]; drop$tuple2_dyns_Tagged_dyns_Tagged(p); return _02; }); @@ -1361,552 +1361,552 @@ export function tags(pair: [Tagged.Tagged, Tagged.Tagged] | undefined): [rt.u8, * the double-ended and exact-size methods to `I`, and reads by `next` for the rest, its * `advance_by` and folds included. */ -export function boxes(data: rt.ByteSlice, out: rt.ByteVec): void { - const it: () => rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rt.Iter<[Tagged.Tagged, Tagged.Tagged]> => { +export function boxes(data: rs.ByteSlice, out: rs.ByteVec): void { + const it: () => rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> => { return skipped(data); }; - const boxed: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); - const hint: [[rt.usize, rt.usize | undefined], rt.usize] = [rt.iterBox(boxed).sizeHint(), rt.iterBox(boxed).len()]; - const ends: [[rt.u8, rt.u8] | undefined, [rt.u8, rt.u8] | undefined] = [tags(rt.iterToOption(boxed.next())), tags(rt.iterToOption(boxed.nextBack()))]; - const nths: [[rt.u8, rt.u8] | undefined, [rt.u8, rt.u8] | undefined] = [tags(rt.iterNth(rt.iterBox(boxed), 1, drop$tuple2_dyns_Tagged_dyns_Tagged)), tags(rt.iterNthBack(rt.iterBox(boxed), 0, drop$tuple2_dyns_Tagged_dyns_Tagged))]; + const boxed: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); + const hint: [[rs.usize, rs.usize | undefined], rs.usize] = [rs.iterBox(boxed).sizeHint(), rs.iterBox(boxed).len()]; + const ends: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterToOption(boxed.next())), tags(rs.iterToOption(boxed.nextBack()))]; + const nths: [[rs.u8, rs.u8] | undefined, [rs.u8, rs.u8] | undefined] = [tags(rs.iterNth(rs.iterBox(boxed), 1, drop$tuple2_dyns_Tagged_dyns_Tagged)), tags(rs.iterNthBack(rs.iterBox(boxed), 0, drop$tuple2_dyns_Tagged_dyns_Tagged))]; dropped(out); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(hint[0][0], f), (f: rt.Formatter) => rt.fmtOption(hint[0][1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.usizeDebug(hint[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(ends[0], f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(ends[1], f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(nths[0], f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(nths[1], f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))], f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(hint[0][0], f), (f: rs.Formatter) => rs.fmtOption(hint[0][1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.usizeDebug(hint[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(ends[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(ends[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(nths[0], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(nths[1], f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))], f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " "])); dropped(out); - const part = tags(rt.ownedLast(rt.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args4[0], " "])); + const part = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args4[0], " "])); dropped(out); - const part2 = tags(rt.ownedLast(rt.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args6[0], " "])); + const part2 = tags(rs.ownedLast(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args6[0], " "])); dropped(out); - const part3 = rt.ownedCount(rt.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; - put(out, rt.fmtFormat([args8[0], " "])); + const part3 = rs.ownedCount(rs.iterBox(it()), drop$tuple2_dyns_Tagged_dyns_Tagged); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; + put(out, rs.fmtFormat([args8[0], " "])); dropped(out); - const sum: rt.u32 = rt.iterFold(rt.iterBox(it()), 0, (n3: rt.u32, _3: [Tagged.Tagged, Tagged.Tagged]): rt.u32 => { + const sum: rs.u32 = rs.iterFold(rs.iterBox(it()), 0, (n3: rs.u32, _3: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x: Tagged.Tagged = _3[0]; const y: Tagged.Tagged = _3[1]; - const _02: rt.u32 = rt.u32WrappingAdd(rt.u32WrappingMul(n3, 7), (x._0 ^ y._0) as rt.u32); + const _02: rs.u32 = rs.u32WrappingAdd(rs.u32WrappingMul(n3, 7), (x._0 ^ y._0) as rs.u32); y[Symbol.dispose](); x[Symbol.dispose](); return _02; }); dropped(out); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f)]; - put(out, rt.fmtFormat([args10[0], " "])); - rt.iterForEach(rt.iterBox(it()), (_24: [Tagged.Tagged, Tagged.Tagged]): undefined => { + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; + put(out, rs.fmtFormat([args10[0], " "])); + rs.iterForEach(rs.iterBox(it()), (_24: [Tagged.Tagged, Tagged.Tagged]): undefined => { const x2: Tagged.Tagged = _24[0]; const y2: Tagged.Tagged = _24[1]; const arg = x2._0; - const _142: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg, f); + const _142: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg, f); const arg2 = y2._0; - const args44: rt.Fmt[] = [_142, (f: rt.Formatter) => rt.u8Display(arg2, f)]; - put(out, rt.fmtFormat([args44[0], " ", args44[1], " "])); + const args44: rs.Fmt[] = [_142, (f: rs.Formatter) => rs.u8Display(arg2, f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " "])); y2[Symbol.dispose](); x2[Symbol.dispose](); }); dropped(out); - const found: rt.usize | undefined = rt.iterPosition(rt.iterBox(it()), (_25: [Tagged.Tagged, Tagged.Tagged]): boolean => { + const found: rs.usize | undefined = rs.iterPosition(rs.iterBox(it()), (_25: [Tagged.Tagged, Tagged.Tagged]): boolean => { const x3: Tagged.Tagged = _25[0]; - const _03: boolean = rt.u8Rem(x3._0, 2) === 1; + const _03: boolean = rs.u8Rem(x3._0, 2) === 1; x3[Symbol.dispose](); _25[1][Symbol.dispose](); return _03; }); dropped(out); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(found, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args12[0], " "])); - const found2: [rt.u8, rt.u8] | undefined = tags(rt.iterFind(rt.iterBox(it()), (_26: [Tagged.Tagged, Tagged.Tagged]): boolean => { - return rt.u8Rem(_26[1]._0, 3) === 0; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args12[0], " "])); + const found2: [rs.u8, rs.u8] | undefined = tags(rs.iterFind(rs.iterBox(it()), (_26: [Tagged.Tagged, Tagged.Tagged]): boolean => { + return rs.u8Rem(_26[1]._0, 3) === 0; }, drop$tuple2_dyns_Tagged_dyns_Tagged)); dropped(out); - const _148: boolean = rt.iterAny(rt.iterBox(it()), (_28: [Tagged.Tagged, Tagged.Tagged]): boolean => { + const _148: boolean = rs.iterAny(rs.iterBox(it()), (_28: [Tagged.Tagged, Tagged.Tagged]): boolean => { const x4: Tagged.Tagged = _28[0]; const _05: boolean = x4._0 > 8; x4[Symbol.dispose](); _28[1][Symbol.dispose](); return _05; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(found2, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtBool(_148, f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " "])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtBool(_148, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " "])); dropped(out); - const part4 = tags(rt.iterMaxByKey(rt.iterBox(it()), (p: [Tagged.Tagged, Tagged.Tagged]): rt.u8 => { + const part4 = tags(rs.iterMaxByKey(rs.iterBox(it()), (p: [Tagged.Tagged, Tagged.Tagged]): rs.u8 => { return p[1]._0; - }, rt.lt, undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args16[0], " "])); + }, rs.lt, undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args16[0], " "])); dropped(out); - const all: rt.Vec<[rt.u8, rt.u8]> = rt.iterToVec(rt.iterMap(rt.vecIntoIter(rt.iterToVec(rt.iterBox(it()), "next", 2), drop$tuple2_dyns_Tagged_dyns_Tagged), (p2: [Tagged.Tagged, Tagged.Tagged]): [rt.u8, rt.u8] => { - const _07: [rt.u8, rt.u8] = [p2[0]._0, p2[1]._0]; + const all: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterBox(it()), "next", 2), drop$tuple2_dyns_Tagged_dyns_Tagged), (p2: [Tagged.Tagged, Tagged.Tagged]): [rs.u8, rs.u8] => { + const _07: [rs.u8, rs.u8] = [p2[0]._0, p2[1]._0]; drop$tuple2_dyns_Tagged_dyns_Tagged(p2); return _07; }), "next", 2, true, 2); dropped(out); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all.items, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args18[0], " "])); - const back: rt.u32 = rt.iterFold(rt.iterRev(rt.iterBox(it())), 0, (n4: rt.u32, _33: [Tagged.Tagged, Tagged.Tagged]): rt.u32 => { + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args18[0], " "])); + const back: rs.u32 = rs.iterFold(rs.iterRev(rs.iterBox(it())), 0, (n4: rs.u32, _33: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x5: Tagged.Tagged = _33[0]; const y3: Tagged.Tagged = _33[1]; - const _08: rt.u32 = rt.u32WrappingAdd(rt.u32WrappingMul(n4, 5), (x5._0 ^ y3._0) as rt.u32); + const _08: rs.u32 = rs.u32WrappingAdd(rs.u32WrappingMul(n4, 5), (x5._0 ^ y3._0) as rs.u32); y3[Symbol.dispose](); x5[Symbol.dispose](); return _08; }); dropped(out); - const _208: rt.u32 = rt.iterSum(rt.iterMap(rt.iterBox(it()), (_211: [Tagged.Tagged, Tagged.Tagged]): rt.u32 => { + const _208: rs.u32 = rs.iterSum(rs.iterMap(rs.iterBox(it()), (_211: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x6: Tagged.Tagged = _211[0]; const y4: Tagged.Tagged = _211[1]; - const _09: rt.u32 = rt.u32Add(x6._0 as rt.u32, y4._0 as rt.u32); + const _09: rs.u32 = rs.u32Add(x6._0 as rs.u32, y4._0 as rs.u32); y4[Symbol.dispose](); x6[Symbol.dispose](); return _09; - }), rt.u32Add, 0); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(back, f), (f: rt.Formatter) => rt.u32Display(_208, f)]; - put(out, rt.fmtFormat([args20[0], " ", args20[1], " "])); + }), rs.u32Add, 0); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(back, f), (f: rs.Formatter) => rs.u32Display(_208, f)]; + put(out, rs.fmtFormat([args20[0], " ", args20[1], " "])); dropped(out); - const _227: rt.usize = rt.ownedCount(rt.iterSkip(rt.iterBox(it()), 1, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); - const _232: rt.usize = rt.ownedCount(rt.iterStepBy(rt.iterBox(it()), 2, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_227, f), (f: rt.Formatter) => rt.usizeDisplay(_232, f)]; - put(out, rt.fmtFormat([args22[0], " ", args22[1], " "])); + const _227: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterBox(it()), 1, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); + const _232: rs.usize = rs.ownedCount(rs.iterStepBy(rs.iterBox(it()), 2, drop$tuple2_dyns_Tagged_dyns_Tagged), drop$tuple2_dyns_Tagged_dyns_Tagged); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_227, f), (f: rs.Formatter) => rs.usizeDisplay(_232, f)]; + put(out, rs.fmtFormat([args22[0], " ", args22[1], " "])); dropped(out); - const _253: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = rt.iterChain(rt.iterBox(it()), rt.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const part5 = tags(rt.iterNth(_253, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - const _246: string = rt.fmtFormat([args24[0], " "]); - rt.drop(_253); + const _253: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(it()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const part5 = tags(rs.iterNth(_253, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + const _246: string = rs.fmtFormat([args24[0], " "]); + rs.drop(_253); put(out, _246); dropped(out); - const last: [rt.u8, rt.u8] | undefined = tags(rt.ownedLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it()))), drop$tuple2_dyns_Tagged_dyns_Tagged)); + const last: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it()))), drop$tuple2_dyns_Tagged_dyns_Tagged)); dropped(out); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(last, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args26[0], " "])); - const boxed3: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); - const _285: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = rt.iterChain(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed3))), rt.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const nth: [rt.u8, rt.u8] | undefined = tags(rt.iterNth(_285, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - rt.drop(_285); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args26[0], " "])); + const boxed3: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); + const _285: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const nth: [rs.u8, rs.u8] | undefined = tags(rs.iterNth(_285, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); + rs.drop(_285); dropped(out); - const n: rt.usize = rt.ownedCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed3))), drop$tuple2_dyns_Tagged_dyns_Tagged); + const n: rs.usize = rs.ownedCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed3))), drop$tuple2_dyns_Tagged_dyns_Tagged); dropped(out); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(nth, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.usizeDisplay(n, f)]; - put(out, rt.fmtFormat([args28[0], " ", args28[1], " "])); - const boxed4: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); - const first: [rt.u8, rt.u8] | undefined = tags(rt.iterToOption(boxed4.next())); - const sum2: rt.u32 = rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed4))), 0, (n5: rt.u32, _34: [Tagged.Tagged, Tagged.Tagged]): rt.u32 => { + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(n, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " "])); + const boxed4: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = it(); + const first: [rs.u8, rs.u8] | undefined = tags(rs.iterToOption(boxed4.next())); + const sum2: rs.u32 = rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed4))), 0, (n5: rs.u32, _34: [Tagged.Tagged, Tagged.Tagged]): rs.u32 => { const x7: Tagged.Tagged = _34[0]; const y5: Tagged.Tagged = _34[1]; - const _010: rt.u32 = rt.u32WrappingAdd(n5, (x7._0 ^ y5._0) as rt.u32); + const _010: rs.u32 = rs.u32WrappingAdd(n5, (x7._0 ^ y5._0) as rs.u32); y5[Symbol.dispose](); x7[Symbol.dispose](); return _010; }); dropped(out); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.u32Display(sum2, f)]; - put(out, rt.fmtFormat([args30[0], " ", args30[1], " "])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(sum2, f)]; + put(out, rs.fmtFormat([args30[0], " ", args30[1], " "])); dropped(out); - const n2: rt.u8 = option_mapOr$1surhce(rt.byteSliceFirst(data), 0, (n6: rt.u8): rt.u8 => { - return rt.u8Rem(n6, 4); + const n2: rs.u8 = option_mapOr$0vxw5sq(rs.byteSliceFirst(data), 0, (n6: rs.u8): rs.u8 => { + return rs.u8Rem(n6, 4); }); - const seen: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const logged: () => rt.Iter<[rt.u8, rt.u8]> = (): rt.Iter<[rt.u8, rt.u8]> => { - return rt.iterZip(rt.iterMap(rt.iterChain(new rt.Range(0, n2), new rt.Range(n2, rt.u8Add(n2, 2))), (x8: rt.u8): rt.u8 => { - const _612: rt.RefCell = rt.refCellBorrowMut(seen); - rt.byteVecPush(_612.value, x8); - rt.refMutRelease(_612); + const seen: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const logged: () => rs.Iter<[rs.u8, rs.u8]> = (): rs.Iter<[rs.u8, rs.u8]> => { + return rs.iterZip(rs.iterMap(rs.iterChain(new rs.Range(0, n2), new rs.Range(n2, rs.u8Add(n2, 2))), (x8: rs.u8): rs.u8 => { + const _612: rs.RefCell = rs.refCellBorrowMut(seen); + rs.byteVecPush(_612.value, x8); + rs.refMutRelease(_612); return x8; - }), new rt.Range(0, rt.u8Rem(n2, 3)), "len"); + }), new rs.Range(0, rs.u8Rem(n2, 3)), "len"); }; - const last2: [rt.u8, rt.u8] | undefined = rt.iterLast(rt.iterBox(logged())); - const _351: [rt.u8, rt.u8] | undefined = rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(logged())))); - const _354: rt.RefCell = rt.refCellBorrow(seen); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(last2, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(_351, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_354.value), f, rt.u8Debug)]; - const _347: string = rt.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); - rt.refRelease(_354); + const last2: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBox(logged())); + const _351: [rs.u8, rs.u8] | undefined = rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(logged())))); + const _354: rs.RefCell = rs.refCellBorrow(seen); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last2, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(_351, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; + const _347: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + rs.refRelease(_354); put(out, _347); - const part6 = tags(rt.ownedLast(rt.iterBox(rt.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args34[0], " "])); + const part6 = tags(rs.ownedLast(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args34[0], " "])); dropped(out); - const part7 = rt.ownedCount(rt.iterBox(rt.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; - put(out, rt.fmtFormat([args36[0], " "])); + const part7 = rs.ownedCount(rs.iterBox(rs.iterBorrow(skipped(data))), drop$tuple2_dyns_Tagged_dyns_Tagged); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; + put(out, rs.fmtFormat([args36[0], " "])); dropped(out); - const erased: () => rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rt.Iter<[Tagged.Tagged, Tagged.Tagged]> => { - return rt.iterDyn(skipped(data)); + const erased: () => rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = (): rs.Iter<[Tagged.Tagged, Tagged.Tagged]> => { + return rs.iterDyn(skipped(data)); }; - const _410: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = rt.iterChain(rt.iterBox(erased()), rt.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const part8 = tags(rt.iterNth(_410, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - const _403: string = rt.fmtFormat([args38[0], " "]); - rt.drop(_410); + const _410: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBox(erased()), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const part8 = tags(rs.iterNth(_410, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + const _403: string = rs.fmtFormat([args38[0], " "]); + rs.drop(_410); put(out, _403); dropped(out); - const _427: [rt.u8, rt.u8] | undefined = tags(rt.ownedLast(rt.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged)); - const _432: rt.usize = rt.ownedCount(rt.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_427, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.usizeDisplay(_432, f)]; - put(out, rt.fmtFormat([args40[0], " ", args40[1], " "])); + const _427: [rs.u8, rs.u8] | undefined = tags(rs.ownedLast(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged)); + const _432: rs.usize = rs.ownedCount(rs.iterBox(erased()), drop$tuple2_dyns_Tagged_dyns_Tagged); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_427, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.usizeDisplay(_432, f)]; + put(out, rs.fmtFormat([args40[0], " ", args40[1], " "])); dropped(out); - const boxed6: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = erased(); - const _455: rt.Iter<[Tagged.Tagged, Tagged.Tagged]> = rt.iterChain(rt.iterBorrow(boxed6), rt.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const part9 = tags(rt.iterNth(_455, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))]; - const _448: string = rt.fmtFormat([args42[0], " "]); - rt.drop(_455); + const boxed6: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = erased(); + const _455: rs.Iter<[Tagged.Tagged, Tagged.Tagged]> = rs.iterChain(rs.iterBorrow(boxed6), rs.iterOption(undefined as [Tagged.Tagged, Tagged.Tagged] | undefined, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const part9 = tags(rs.iterNth(_455, 1, drop$tuple2_dyns_Tagged_dyns_Tagged)); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))]; + const _448: string = rs.fmtFormat([args42[0], " "]); + rs.drop(_455); put(out, _448); dropped(out); - rt.drop(boxed6); + rs.drop(boxed6); dropped(out); } /** Through a `&mut` to a struct whose last field is a trait object. */ -export function bumpTail(t: Tail.Tail, by: rt.u8): rt.u32 { - t.count = rt.u8WrappingAdd(t.count, by); +export function bumpTail(t: Tail.Tail, by: rs.u8): rs.u32 { + t.count = rs.u8WrappingAdd(t.count, by); Noisy.grow$dyns_Shape(t.head, by); t.value.grow$Shape(by); return t.value.area$Shape(); } -export function tails(data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: rt.Arc undefined>>; +export function tails(data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: rs.Arc undefined>>; if (data.length >= 3) { - const _12: [rt.u8, rt.u8, rt.u8] = [data.data[data.start], data.data[data.start + 1], data.data[data.start + 2]]; - const a: rt.u8 = _12[0]; - const b: rt.u8 = _12[1]; - const c: rt.u8 = _12[2]; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const sq: rt.Arc> = new rt.Arc(new rt.RefCell({ side: a as rt.u16 })); - const n: rt.Arc> = new rt.Arc(new rt.RefCell(b as rt.u32)); - const tri: rt.Arc> = new rt.Arc(new rt.RefCell({ tag: "Tall", _0: c } as Tri.Tri)); - const _32: rt.Arc> = rt.arcClone(sq); - const _31: rt.Arc> = new rt.ArcDyn(_32, rt.tailDyn(_32.value, { value: (value: rt.RefCell) => new of$dyns_Square(value.value) })); - const _35: rt.Arc> = rt.arcClone(n); - const _34: rt.Arc> = new rt.ArcDyn(_35, rt.tailDyn(_35.value, { value: (value2: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value2)) })); - const _38: rt.Arc> = rt.arcClone(tri); - const _37: rt.Arc> = new rt.ArcDyn(_38, rt.tailDyn(_38.value, { value: (value3: rt.RefCell) => new ofPlace$dyns_Tri(rt.valuePlace(value3)) })); - const _41: rt.Arc> = new rt.Arc(new rt.RefCell(new Noisy.Noisy(a ^ b, rt.arcClone(log)))); - const shapes: rt.Vec>> = rt.vecFrom([_31, _34, _37, new rt.ArcDyn(_41, rt.tailDyn(_41.value, { value: (value4: rt.RefCell) => new of$dyns_Noisy(value4.value) }, rt.drop))]); - const iter: rt.Iter<[rt.usize, rt.Arc>]> = rt.iterEnumerate(rt.iterSlice(shapes.items)); + const _12: [rs.u8, rs.u8, rs.u8] = [data.data[data.start], data.data[data.start + 1], data.data[data.start + 2]]; + const a: rs.u8 = _12[0]; + const b: rs.u8 = _12[1]; + const c: rs.u8 = _12[2]; + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const sq: rs.Arc> = new rs.Arc(new rs.RefCell({ side: a as rs.u16 })); + const n: rs.Arc> = new rs.Arc(new rs.RefCell(b as rs.u32)); + const tri: rs.Arc> = new rs.Arc(new rs.RefCell({ tag: "Tall", _0: c } as Tri.Tri)); + const _32: rs.Arc> = rs.arcClone(sq); + const _31: rs.Arc> = new rs.ArcDyn(_32, rs.tailDyn(_32.value, { value: (value: rs.RefCell) => new of$dyns_Square(value.value) })); + const _35: rs.Arc> = rs.arcClone(n); + const _34: rs.Arc> = new rs.ArcDyn(_35, rs.tailDyn(_35.value, { value: (value2: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value2)) })); + const _38: rs.Arc> = rs.arcClone(tri); + const _37: rs.Arc> = new rs.ArcDyn(_38, rs.tailDyn(_38.value, { value: (value3: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value3)) })); + const _41: rs.Arc> = new rs.Arc(new rs.RefCell(new Noisy.Noisy(a ^ b, rs.arcClone(log)))); + const shapes: rs.Vec>> = rs.vecFrom([_31, _34, _37, new rs.ArcDyn(_41, rs.tailDyn(_41.value, { value: (value4: rs.RefCell) => new of$dyns_Noisy(value4.value) }, rs.drop))]); + const iter: rs.Iter<[rs.usize, rs.Arc>]> = rs.iterEnumerate(rs.iterSlice(shapes.items)); while (true) { - const _53: [rt.usize, rt.Arc>] | rt.Done = iter.next(); - if (_53 === rt.DONE) { + const _53: [rs.usize, rs.Arc>] | rs.Done = iter.next(); + if (_53 === rs.DONE) { break; } - const i: rt.usize = _53[0]; - const _61: rt.RefCell = rt.refCellBorrowMut(_53[1].value); - const _63: rt.u8 = rt.u8WrappingAdd(c, i & 0xff); + const i: rs.usize = _53[0]; + const _61: rs.RefCell = rs.refCellBorrowMut(_53[1].value); + const _63: rs.u8 = rs.u8WrappingAdd(c, i & 0xff); _61.value.grow$Shape(_63); - rt.refMutRelease(_61); + rs.refMutRelease(_61); } - const areas: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(shapes.items), (s3: rt.Arc>): rt.u32 => { - const _5: rt.RefCell = rt.refCellBorrow(s3.value); - const _0: rt.u32 = _5.value.area$Shape(); - rt.refRelease(_5); + const areas: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(shapes.items), (s3: rs.Arc>): rs.u32 => { + const _5: rs.RefCell = rs.refCellBorrow(s3.value); + const _0: rs.u32 = _5.value.area$Shape(); + rs.refRelease(_5); return _0; }), undefined, 4, true); - const _80: rt.RefCell = rt.refCellBorrow(sq.value); + const _80: rs.RefCell = rs.refCellBorrow(sq.value); const _78: Square.Square = _80.value; - const _84: rt.RefCell = rt.refCellBorrow(n.value); - const _88: rt.RefCell = rt.refCellBorrow(tri.value); - const _93: rt.Fmt = (f: rt.Formatter) => rt.fmtList(areas.items, f, rt.u32Debug); + const _84: rs.RefCell = rs.refCellBorrow(n.value); + const _88: rs.RefCell = rs.refCellBorrow(tri.value); + const _93: rs.Fmt = (f: rs.Formatter) => rs.fmtList(areas.items, f, rs.u32Debug); const arg = _78.side; - const args2: rt.Fmt[] = [_93, (f: rt.Formatter) => rt.u16Display(arg, f), (f: rt.Formatter) => rt.u32Display(_84.value, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; - const _74: string = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]); - rt.refRelease(_88); - rt.refRelease(_84); - rt.refRelease(_80); + const args2: rs.Fmt[] = [_93, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => rs.u32Display(_84.value, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_88.value, f)]; + const _74: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "]); + rs.refRelease(_88); + rs.refRelease(_84); + rs.refRelease(_80); put(out, _74); - const held: rt.RefCell = rt.refCellBorrowMut(n.value); - const shared: rt.RefCell = rt.refCellBorrow(shapes.items[rt.idx(shapes.items, 0)].value); - const _116: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(shapes.items[rt.idx(shapes.items, 1)].value); + const held: rs.RefCell = rs.refCellBorrowMut(n.value); + const shared: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 0)].value); + const _116: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(shapes.items[rs.idx(shapes.items, 1)].value); const _114: boolean = !_116.ok; - const _123: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(sq.value); + const _123: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(sq.value); const _121: boolean = !_123.ok; - const _127: rt.u8 = result_unwrapOr$09hp2h5(result_map$1wuk0uc(rt.refCellTryBorrow(shapes.items[rt.idx(shapes.items, 0)].value), (s4: rt.RefCell): rt.u8 => { - const _02: rt.u8 = s4.value.sides$Shape(); - rt.refRelease(s4); + const _127: rs.u8 = result_unwrapOr$0k78oya(result_map$11lf952(rs.refCellTryBorrow(shapes.items[rs.idx(shapes.items, 0)].value), (s4: rs.RefCell): rs.u8 => { + const _02: rs.u8 = s4.value.sides$Shape(); + rs.refRelease(s4); return _02; }), 0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_114, f), (f: rt.Formatter) => rt.fmtBool(_121, f), (f: rt.Formatter) => rt.u8Display(_127, f)]; - const _110: string = rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_114, f), (f: rs.Formatter) => rs.fmtBool(_121, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + const _110: string = rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " "]); drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_123); drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_116); put(out, _110); - rt.refMutRelease(held); - rt.refRelease(shared); - const r: rt.RefCell = rt.refCellBorrow(shapes.items[rt.idx(shapes.items, 2)].value); - const _155: rt.Result, rt.BorrowMutError> = rt.refCellTryBorrowMut(tri.value); + rs.refMutRelease(held); + rs.refRelease(shared); + const r: rs.RefCell = rs.refCellBorrow(shapes.items[rs.idx(shapes.items, 2)].value); + const _155: rs.Result, rs.BorrowMutError> = rs.refCellTryBorrowMut(tri.value); const _153: boolean = !_155.ok; - const _159: rt.u8 = r.value.sides$Shape(); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_153, f), (f: rt.Formatter) => rt.u8Display(_159, f)]; - const _149: string = rt.fmtFormat([args6[0], " ", args6[1], " "]); + const _159: rs.u8 = r.value.sides$Shape(); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.u8Display(_159, f)]; + const _149: string = rs.fmtFormat([args6[0], " ", args6[1], " "]); drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_155); put(out, _149); - rt.refRelease(r); - const _175: rt.usize = sq.strong; - const _178: rt.usize = shapes.items[rt.idx(shapes.items, 1)].strong; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_175, f), (f: rt.Formatter) => rt.usizeDisplay(_178, f)]; - put(out, rt.fmtFormat([args8[0], " ", args8[1], " "])); - const _187: rt.Arc> = new rt.Arc(new rt.RefCell({ tag: "Flat" } as Tri.Tri)); - const named: rt.Arc> = new rt.ArcDyn(_187, rt.tailDyn(_187.value, { value: (value5: rt.RefCell) => new ofPlace$dyns_Tri(rt.valuePlace(value5)) })); - const _193: rt.RefCell = rt.refCellBorrowMut(named.value); + rs.refRelease(r); + const _175: rs.usize = sq.strong; + const _178: rs.usize = shapes.items[rs.idx(shapes.items, 1)].strong; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_175, f), (f: rs.Formatter) => rs.usizeDisplay(_178, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " "])); + const _187: rs.Arc> = new rs.Arc(new rs.RefCell({ tag: "Flat" } as Tri.Tri)); + const named: rs.Arc> = new rs.ArcDyn(_187, rs.tailDyn(_187.value, { value: (value5: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value5)) })); + const _193: rs.RefCell = rs.refCellBorrowMut(named.value); _193.value.grow$Shape(b); - rt.refMutRelease(_193); - const _197: rt.Arc> = rt.arcClone(named); - const upcast: rt.Arc> = new rt.ArcDyn(_197, rt.tailDyn(_197.value, { value: (value6: rt.RefCell) => value6.value }, rt.drop)); - const _202: rt.RefCell = rt.refCellBorrowMut(upcast.value); + rs.refMutRelease(_193); + const _197: rs.Arc> = rs.arcClone(named); + const upcast: rs.Arc> = new rs.ArcDyn(_197, rs.tailDyn(_197.value, { value: (value6: rs.RefCell) => value6.value }, rs.drop)); + const _202: rs.RefCell = rs.refCellBorrowMut(upcast.value); _202.value.grow$Shape(a); - rt.refMutRelease(_202); - const _217: rt.RefCell = rt.refCellBorrow(named.value); + rs.refMutRelease(_202); + const _217: rs.RefCell = rs.refCellBorrow(named.value); const _214: string = _217.value.label$Named(); - const _224: rt.RefCell = rt.refCellBorrow(upcast.value); - const _221: rt.u32 = _224.value.area$Shape(); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(named.value, f, (value: Named.Named, f: rt.Formatter) => value.fmt$Debug(f)), (f: rt.Formatter) => rt.fmtPad(f, _214), (f: rt.Formatter) => rt.u32Display(_221, f)]; - const _209: string = rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]); - rt.refRelease(_224); - rt.refRelease(_217); + const _224: rs.RefCell = rs.refCellBorrow(upcast.value); + const _221: rs.u32 = _224.value.area$Shape(); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f)), (f: rs.Formatter) => rs.fmtPad(f, _214), (f: rs.Formatter) => rs.u32Display(_221, f)]; + const _209: string = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " "]); + rs.refRelease(_224); + rs.refRelease(_217); put(out, _209); - const _held: rt.RefCell = rt.refCellBorrowMut(named.value); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.refCellDebug(named.value, f, (value: Named.Named, f: rt.Formatter) => value.fmt$Debug(f))]; - put(out, rt.fmtFormat([args12[0], " "])); - rt.refMutRelease(_held); - const noisy: rt.Arc> = new rt.Arc(new rt.RefCell(new Noisy.Noisy(c, rt.arcClone(log)))); - const _254: rt.Arc> = rt.arcClone(noisy); - const shape: rt.Arc> = new rt.ArcDyn(_254, rt.tailDyn(_254.value, { value: (value7: rt.RefCell) => new of$dyns_Noisy(value7.value) }, rt.drop)); - const weak: rt.Weak> = new rt.Weak(shape); + const _held: rs.RefCell = rs.refCellBorrowMut(named.value); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.refCellDebug(named.value, f, (value: Named.Named, f: rs.Formatter) => value.fmt$Debug(f))]; + put(out, rs.fmtFormat([args12[0], " "])); + rs.refMutRelease(_held); + const noisy: rs.Arc> = new rs.Arc(new rs.RefCell(new Noisy.Noisy(c, rs.arcClone(log)))); + const _254: rs.Arc> = rs.arcClone(noisy); + const shape: rs.Arc> = new rs.ArcDyn(_254, rs.tailDyn(_254.value, { value: (value7: rs.RefCell) => new of$dyns_Noisy(value7.value) }, rs.drop)); + const weak: rs.Weak> = new rs.Weak(shape); noisy[Symbol.dispose](); - const _268: rt.RefCell = rt.refCellBorrow(log.value); - const _272: rt.u32 | undefined = option_map$1p9q0qv(rt.weakUpgrade(weak), (s5: rt.Arc>): rt.u32 => { - const _52: rt.RefCell = rt.refCellBorrow(s5.value); - const _03: rt.u32 = _52.value.area$Shape(); - rt.refRelease(_52); + const _268: rs.RefCell = rs.refCellBorrow(log.value); + const _272: rs.u32 | undefined = option_map$1rkcfqi(rs.weakUpgrade(weak), (s5: rs.Arc>): rs.u32 => { + const _52: rs.RefCell = rs.refCellBorrow(s5.value); + const _03: rs.u32 = _52.value.area$Shape(); + rs.refRelease(_52); s5[Symbol.dispose](); return _03; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_268.value), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_272, f, rt.u32Debug)]; - const _264: string = rt.fmtFormat([args14[0], " ", args14[1], " "]); - rt.refRelease(_268); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_268.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_272, f, rs.u32Debug)]; + const _264: string = rs.fmtFormat([args14[0], " ", args14[1], " "]); + rs.refRelease(_268); put(out, _264); shape[Symbol.dispose](); - const _289: rt.RefCell = rt.refCellBorrow(log.value); - const _295: rt.Arc> | undefined = rt.weakUpgrade(weak); + const _289: rs.RefCell = rs.refCellBorrow(log.value); + const _295: rs.Arc> | undefined = rs.weakUpgrade(weak); const _293: boolean = _295 === undefined; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_289.value), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBool(_293, f)]; - const _285: string = rt.fmtFormat([args16[0], " ", args16[1], " "]); - rt.drop(_295); - rt.refRelease(_289); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_289.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBool(_293, f)]; + const _285: string = rs.fmtFormat([args16[0], " ", args16[1], " "]); + rs.drop(_295); + rs.refRelease(_289); put(out, _285); - rt.dropVec(shapes); - const _311: rt.RefCell = rt.refCellBorrow(log.value); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_311.value), f, rt.u8Debug)]; - const _307: string = rt.fmtFormat([args18[0], " "]); - rt.refRelease(_311); + rs.dropVec(shapes); + const _311: rs.RefCell = rs.refCellBorrow(log.value); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_311.value), f, rs.u8Debug)]; + const _307: string = rs.fmtFormat([args18[0], " "]); + rs.refRelease(_311); put(out, _307); - const _321: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_321.value); - rt.refMutRelease(_321); - const m: rt.Arc> = new rt.Arc(new rt.Mutex({ tag: "Flat" } as Tri.Tri)); - const _328: rt.Arc> = rt.arcClone(m); - const locked: rt.Arc> = new rt.ArcDyn(_328, rt.tailDyn(_328.value, { value: (value8: rt.Mutex) => new ofPlace$dyns_Tri(rt.valuePlace(value8)) })); - const _333: rt.Mutex = rt.mutexLock(locked.value); + const _321: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_321.value); + rs.refMutRelease(_321); + const m: rs.Arc> = new rs.Arc(new rs.Mutex({ tag: "Flat" } as Tri.Tri)); + const _328: rs.Arc> = rs.arcClone(m); + const locked: rs.Arc> = new rs.ArcDyn(_328, rs.tailDyn(_328.value, { value: (value8: rs.Mutex) => new ofPlace$dyns_Tri(rs.valuePlace(value8)) })); + const _333: rs.Mutex = rs.mutexLock(locked.value); _333.value.grow$Shape(b); - rt.mutexUnlock(_333); - const _guard: rt.Mutex = rt.mutexLock(m.value); - const _351: rt.Result, rt.TryLockError>> = rt.mutexTryLock(locked.value); + rs.mutexUnlock(_333); + const _guard: rs.Mutex = rs.mutexLock(m.value); + const _351: rs.Result, rs.TryLockError>> = rs.mutexTryLock(locked.value); const part = !_351.ok; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - const _345: string = rt.fmtFormat([args20[0], " "]); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + const _345: string = rs.fmtFormat([args20[0], " "]); drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_351); put(out, _345); - rt.mutexUnlock(_guard); - const weak2: rt.Weak> = new rt.Weak(locked); - const area: rt.u32 | undefined = option_map$1qzd1bs(rt.weakUpgrade(weak2), (l: rt.Arc>): rt.u32 => { - const _54: rt.Mutex = rt.mutexLock(l.value); - const _04: rt.u32 = _54.value.area$Shape(); - rt.mutexUnlock(_54); + rs.mutexUnlock(_guard); + const weak2: rs.Weak> = new rs.Weak(locked); + const area: rs.u32 | undefined = option_map$13cu53u(rs.weakUpgrade(weak2), (l: rs.Arc>): rs.u32 => { + const _54: rs.Mutex = rs.mutexLock(l.value); + const _04: rs.u32 = _54.value.area$Shape(); + rs.mutexUnlock(_54); l[Symbol.dispose](); return _04; }); - const _372: rt.Mutex = rt.mutexLock(m.value); - const _377: rt.usize = m.strong; - const args22: rt.Fmt[] = [(f: rt.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rt.Formatter) => rt.fmtOption(area, f, rt.u32Debug), (f: rt.Formatter) => rt.usizeDisplay(_377, f)]; - const _368: string = rt.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " "]); - rt.mutexUnlock(_372); + const _372: rs.Mutex = rs.mutexLock(m.value); + const _377: rs.usize = m.strong; + const args22: rs.Fmt[] = [(f: rs.Formatter) => Tri.fmt$fmt_Debug(_372.value, f), (f: rs.Formatter) => rs.fmtOption(area, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_377, f)]; + const _368: string = rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " "]); + rs.mutexUnlock(_372); put(out, _368); - const rw: rt.Arc> = new rt.Arc(new rt.RefCell(c as rt.u32)); - const _390: rt.Arc> = rt.arcClone(rw); - const lock: rt.Arc> = new rt.ArcDyn(_390, rt.tailDyn(_390.value, { value: (value9: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value9)) })); - const _395: rt.RefCell = rt.rwLockWrite(lock.value); + const rw: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); + const _390: rs.Arc> = rs.arcClone(rw); + const lock: rs.Arc> = new rs.ArcDyn(_390, rs.tailDyn(_390.value, { value: (value9: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value9)) })); + const _395: rs.RefCell = rs.rwLockWrite(lock.value); _395.value.grow$Shape(a); - rt.refMutRelease(_395); - const _read: rt.RefCell = rt.rwLockRead(rw.value); - const _413: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock.value); + rs.refMutRelease(_395); + const _read: rs.RefCell = rs.rwLockRead(rw.value); + const _413: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock.value); const _411: boolean = !_413.ok; - const _420: rt.RefCell = rt.rwLockRead(lock.value); - const _417: rt.u32 = _420.value.area$Shape(); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_411, f), (f: rt.Formatter) => rt.u32Display(_417, f)]; - const _407: string = rt.fmtFormat([args24[0], " ", args24[1], " "]); - rt.refRelease(_420); + const _420: rs.RefCell = rs.rwLockRead(lock.value); + const _417: rs.u32 = _420.value.area$Shape(); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_411, f), (f: rs.Formatter) => rs.u32Display(_417, f)]; + const _407: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + rs.refRelease(_420); drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_413); put(out, _407); - rt.refRelease(_read); - const _437: rt.RefCell = rt.rwLockRead(rw.value); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_437.value, f)]; - const _433: string = rt.fmtFormat([args26[0], " "]); - rt.refRelease(_437); + rs.refRelease(_read); + const _437: rs.RefCell = rs.rwLockRead(rw.value); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_437.value, f)]; + const _433: string = rs.fmtFormat([args26[0], " "]); + rs.refRelease(_437); put(out, _433); - const t: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rt.arcClone(log)), c as rt.u32); - const area2: rt.u32 = bumpTail(rt.tailDyn(t, { value: (value10: Tail.Tail) => new ofPlace$u32(rt.place(() => value10.value, (value11) => value10.value = value11)) }), b); - const shared2: Tail.Tail = rt.tailDyn(t, { value: (value12: Tail.Tail) => new ofPlace$u32(rt.place(() => value12.value, (value13) => value12.value = value13)) }); - const _465: rt.u32 = shared2.value.area$Shape(); - const _470: rt.Fmt = (f: rt.Formatter) => rt.u32Display(area2, f); + const t: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), c as rs.u32); + const area2: rs.u32 = bumpTail(rs.tailDyn(t, { value: (value10: Tail.Tail) => new ofPlace$u32(rs.place(() => value10.value, (value11) => value10.value = value11)) }), b); + const shared2: Tail.Tail = rs.tailDyn(t, { value: (value12: Tail.Tail) => new ofPlace$u32(rs.place(() => value12.value, (value13) => value12.value = value13)) }); + const _465: rs.u32 = shared2.value.area$Shape(); + const _470: rs.Fmt = (f: rs.Formatter) => rs.u32Display(area2, f); const arg2 = shared2.count; - const _471: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg2, f); + const _471: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg2, f); const arg3 = shared2.head._0; - const _472: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg3, f); - const _473: rt.Fmt = (f: rt.Formatter) => rt.u32Display(_465, f); + const _472: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg3, f); + const _473: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_465, f); const arg4 = t.value; - const args28: rt.Fmt[] = [_470, _471, _472, _473, (f: rt.Formatter) => rt.u32Display(arg4, f)]; - put(out, rt.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " "])); - const cell: rt.Arc>> = new rt.Arc(new rt.RefCell(new Tail.Tail(b, new Noisy.Noisy(a, rt.arcClone(log)), { side: b as rt.u16 }))); - const _486: rt.Arc>> = rt.arcClone(cell); - const nested: rt.Arc>> = new rt.ArcDyn(_486, rt.tailDyn(_486.value, { value: (value14: rt.RefCell>) => rt.tailDyn(value14.value, { value: (value15: Tail.Tail) => new of$dyns_Square(value15.value) }) }, rt.drop)); - const _491: rt.RefCell> = rt.refCellBorrowMut(nested.value); - const area3: rt.u32 = bumpTail(_491.value, c); - rt.refMutRelease(_491); - const _504: rt.RefCell> = rt.refCellBorrow(cell.value); + const args28: rs.Fmt[] = [_470, _471, _472, _473, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " "])); + const cell: rs.Arc>> = new rs.Arc(new rs.RefCell(new Tail.Tail(b, new Noisy.Noisy(a, rs.arcClone(log)), { side: b as rs.u16 }))); + const _486: rs.Arc>> = rs.arcClone(cell); + const nested: rs.Arc>> = new rs.ArcDyn(_486, rs.tailDyn(_486.value, { value: (value14: rs.RefCell>) => rs.tailDyn(value14.value, { value: (value15: Tail.Tail) => new of$dyns_Square(value15.value) }) }, rs.drop)); + const _491: rs.RefCell> = rs.refCellBorrowMut(nested.value); + const area3: rs.u32 = bumpTail(_491.value, c); + rs.refMutRelease(_491); + const _504: rs.RefCell> = rs.refCellBorrow(cell.value); const _502: Tail.Tail = _504.value; - const _510: rt.RefCell> = rt.refCellBorrow(cell.value); + const _510: rs.RefCell> = rs.refCellBorrow(cell.value); const _508: Tail.Tail = _510.value; - const _515: rt.Fmt = (f: rt.Formatter) => rt.u32Display(area3, f); + const _515: rs.Fmt = (f: rs.Formatter) => rs.u32Display(area3, f); const arg5 = _502.count; - const _516: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg5, f); + const _516: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg5, f); const arg6 = _508.value.side; - const args30: rt.Fmt[] = [_515, _516, (f: rt.Formatter) => rt.u16Display(arg6, f)]; - const _498: string = rt.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); - rt.refRelease(_510); - rt.refRelease(_504); + const args30: rs.Fmt[] = [_515, _516, (f: rs.Formatter) => rs.u16Display(arg6, f)]; + const _498: string = rs.fmtFormat([args30[0], " ", args30[1], " ", args30[2], " "]); + rs.refRelease(_510); + rs.refRelease(_504); put(out, _498); cell[Symbol.dispose](); t[Symbol.dispose](); - const _531: rt.RefCell = rt.refCellBorrow(log.value); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_531.value), f, rt.u8Debug)]; - const _527: string = rt.fmtFormat([args32[0], " "]); - rt.refRelease(_531); + const _531: rs.RefCell = rs.refCellBorrow(log.value); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_531.value), f, rs.u8Debug)]; + const _527: string = rs.fmtFormat([args32[0], " "]); + rs.refRelease(_531); put(out, _527); nested[Symbol.dispose](); - const boxed: Tail.Tail = rt.tailDyn(new Tail.Tail(c, new Noisy.Noisy(c, rt.arcClone(log)), new Noisy.Noisy(rt.u8WrappingAdd(c, 1), rt.arcClone(log))), { value: (value17: Tail.Tail) => new of$dyns_Noisy(value17.value) }, rt.drop); + const boxed: Tail.Tail = rs.tailDyn(new Tail.Tail(c, new Noisy.Noisy(c, rs.arcClone(log)), new Noisy.Noisy(rs.u8WrappingAdd(c, 1), rs.arcClone(log))), { value: (value17: Tail.Tail) => new of$dyns_Noisy(value17.value) }, rs.drop); const part2 = boxed.value.area$Shape(); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - put(out, rt.fmtFormat([args34[0], " "])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + put(out, rs.fmtFormat([args34[0], " "])); boxed[Symbol.dispose](); - const _572: rt.RefCell = rt.refCellBorrow(log.value); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_572.value), f, rt.u8Debug)]; - const _568: string = rt.fmtFormat([args36[0], " "]); - rt.refRelease(_572); + const _572: rs.RefCell = rs.refCellBorrow(log.value); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_572.value), f, rs.u8Debug)]; + const _568: string = rs.fmtFormat([args36[0], " "]); + rs.refRelease(_572); put(out, _568); - const pinned: Tail.Tail = rt.tailDyn(new Tail.Tail(a, new Noisy.Noisy(a, rt.arcClone(log)), { tag: "Tall", _0: b } as Tri.Tri), { value: (value19: Tail.Tail) => new ofPlace$dyns_Tri(rt.place(() => value19.value, (value20) => value19.value = value20)) }, rt.drop); - const own: rt.Arc> = new rt.Arc(new rt.RefCell(a as rt.u32)); - const weak4: rt.Weak> = rt.weakDyn(new rt.Weak(own), (arc: rt.Arc>): rt.Arc> => { - return new rt.ArcDyn(arc, rt.tailDyn(arc.value, { value: (value21: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value21)) })); + const pinned: Tail.Tail = rs.tailDyn(new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), { tag: "Tall", _0: b } as Tri.Tri), { value: (value19: Tail.Tail) => new ofPlace$dyns_Tri(rs.place(() => value19.value, (value20) => value19.value = value20)) }, rs.drop); + const own: rs.Arc> = new rs.Arc(new rs.RefCell(a as rs.u32)); + const weak4: rs.Weak> = rs.weakDyn(new rs.Weak(own), (arc: rs.Arc>): rs.Arc> => { + return new rs.ArcDyn(arc, rs.tailDyn(arc.value, { value: (value21: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value21)) })); }); - const _592: rt.Arc> | undefined = rt.weakUpgrade(weak4); + const _592: rs.Arc> | undefined = rs.weakUpgrade(weak4); if (_592 !== undefined) { - const s: rt.Arc> = _592; - const _599: rt.RefCell = rt.refCellBorrowMut(s.value); + const s: rs.Arc> = _592; + const _599: rs.RefCell = rs.refCellBorrowMut(s.value); _599.value.grow$Shape(c); - rt.refMutRelease(_599); + rs.refMutRelease(_599); s[Symbol.dispose](); } const _610: Tail.Tail = pinned; - const _613: rt.u32 = pinned.value.area$Shape(); - const _618: rt.RefCell = rt.refCellBorrow(own.value); - const _622: rt.usize = weak4.arc.strong; + const _613: rs.u32 = pinned.value.area$Shape(); + const _618: rs.RefCell = rs.refCellBorrow(own.value); + const _622: rs.usize = weak4.arc.strong; const arg7 = _610.count; - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg7, f), (f: rt.Formatter) => rt.u32Display(_613, f), (f: rt.Formatter) => rt.u32Display(_618.value, f), (f: rt.Formatter) => rt.usizeDisplay(_622, f)]; - const _606: string = rt.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " ", args38[3], " "]); - rt.refRelease(_618); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg7, f), (f: rs.Formatter) => rs.u32Display(_613, f), (f: rs.Formatter) => rs.u32Display(_618.value, f), (f: rs.Formatter) => rs.usizeDisplay(_622, f)]; + const _606: string = rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " ", args38[3], " "]); + rs.refRelease(_618); put(out, _606); pinned[Symbol.dispose](); - const _640: rt.RefCell = rt.refCellBorrow(log.value); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_640.value), f, rt.u8Debug)]; - const _636: string = rt.fmtFormat([args40[0], " "]); - rt.refRelease(_640); + const _640: rs.RefCell = rs.refCellBorrow(log.value); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_640.value), f, rs.u8Debug)]; + const _636: string = rs.fmtFormat([args40[0], " "]); + rs.refRelease(_640); put(out, _636); - const shared3: rt.Arc> = new rt.Arc(rt.tailDyn(new rt.RefCell(new Noisy.Noisy(b, rt.arcClone(log))), { value: (value22: rt.RefCell) => new of$dyns_Noisy(value22.value) }, rt.drop)); - const again: rt.Arc> = rt.arcClone(shared3); - const _659: rt.RefCell = rt.refCellBorrowMut(again.value); + const shared3: rs.Arc> = new rs.Arc(rs.tailDyn(new rs.RefCell(new Noisy.Noisy(b, rs.arcClone(log))), { value: (value22: rs.RefCell) => new of$dyns_Noisy(value22.value) }, rs.drop)); + const again: rs.Arc> = rs.arcClone(shared3); + const _659: rs.RefCell = rs.refCellBorrowMut(again.value); _659.value.grow$Shape(a); - rt.refMutRelease(_659); + rs.refMutRelease(_659); shared3[Symbol.dispose](); - const _674: rt.RefCell = rt.refCellBorrow(again.value); - const _671: rt.u32 = _674.value.area$Shape(); - const _678: rt.RefCell = rt.refCellBorrow(log.value); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_671, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_678.value), f, rt.u8Debug)]; - const _667: string = rt.fmtFormat([args42[0], " ", args42[1], " "]); - rt.refRelease(_678); - rt.refRelease(_674); + const _674: rs.RefCell = rs.refCellBorrow(again.value); + const _671: rs.u32 = _674.value.area$Shape(); + const _678: rs.RefCell = rs.refCellBorrow(log.value); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_671, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_678.value), f, rs.u8Debug)]; + const _667: string = rs.fmtFormat([args42[0], " ", args42[1], " "]); + rs.refRelease(_678); + rs.refRelease(_674); put(out, _667); again[Symbol.dispose](); - const _695: rt.RefCell = rt.refCellBorrow(log.value); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_695.value), f, rt.u8Debug)]; - const _691: string = rt.fmtFormat([args44[0], " "]); - rt.refRelease(_695); + const _695: rs.RefCell = rs.refCellBorrow(log.value); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_695.value), f, rs.u8Debug)]; + const _691: string = rs.fmtFormat([args44[0], " "]); + rs.refRelease(_695); put(out, _691); - const guarded: rt.Vec> = rt.vecFrom([rt.tailDyn(new Guarded.Guarded(rt.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(a, rt.arcClone(log)) } as Held.Held), { value: (value23: Guarded.Guarded) => new ofPlace$dyns_Held(rt.place(() => value23.value, (value24) => value23.value = value24)) }, drop$dyns_Guarded_dyns_Held), rt.tailDyn(new Guarded.Guarded(rt.arcClone(log), new Noisy.Noisy(b, rt.arcClone(log))), { value: (value25: Guarded.Guarded) => new of$dyns_Noisy(value25.value) }, drop$dyns_Guarded_dyns_Noisy), rt.tailDyn(new Guarded.Guarded(rt.arcClone(log), { tag: "Empty" } as Held.Held), { value: (value27: Guarded.Guarded) => new ofPlace$dyns_Held(rt.place(() => value27.value, (value28) => value27.value = value28)) }, drop$dyns_Guarded_dyns_Held)]); - const _728: rt.Arc>> = new rt.Arc(new rt.RefCell(new Guarded.Guarded(rt.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(c, rt.arcClone(log)) } as Held.Held))); - const cell2: rt.Arc>> = new rt.ArcDyn(_728, rt.tailDyn(_728.value, { value: (value29: rt.RefCell>) => rt.tailDyn(value29.value, { value: (value30: Guarded.Guarded) => new ofPlace$dyns_Held(rt.place(() => value30.value, (value31) => value30.value = value31)) }) }, drop$cell_RefCell_dyns_Guarded_dyns_Held)); - const _741: rt.RefCell> = rt.refCellBorrowMut(cell2.value); + const guarded: rs.Vec> = rs.vecFrom([rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(a, rs.arcClone(log)) } as Held.Held), { value: (value23: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value23.value, (value24) => value23.value = value24)) }, drop$dyns_Guarded_dyns_Held), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), new Noisy.Noisy(b, rs.arcClone(log))), { value: (value25: Guarded.Guarded) => new of$dyns_Noisy(value25.value) }, drop$dyns_Guarded_dyns_Noisy), rs.tailDyn(new Guarded.Guarded(rs.arcClone(log), { tag: "Empty" } as Held.Held), { value: (value27: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value27.value, (value28) => value27.value = value28)) }, drop$dyns_Guarded_dyns_Held)]); + const _728: rs.Arc>> = new rs.Arc(new rs.RefCell(new Guarded.Guarded(rs.arcClone(log), { tag: "Full", _0: new Noisy.Noisy(c, rs.arcClone(log)) } as Held.Held))); + const cell2: rs.Arc>> = new rs.ArcDyn(_728, rs.tailDyn(_728.value, { value: (value29: rs.RefCell>) => rs.tailDyn(value29.value, { value: (value30: Guarded.Guarded) => new ofPlace$dyns_Held(rs.place(() => value30.value, (value31) => value30.value = value31)) }) }, drop$cell_RefCell_dyns_Guarded_dyns_Held)); + const _741: rs.RefCell> = rs.refCellBorrowMut(cell2.value); _741.value.value.grow$Shape(a); - rt.refMutRelease(_741); - const areas2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(guarded.items), (g: Guarded.Guarded): rt.u32 => { + rs.refMutRelease(_741); + const areas2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(guarded.items), (g: Guarded.Guarded): rs.u32 => { return g.value.area$Shape(); }), undefined, 4, true); - const _761: rt.RefCell> = rt.refCellBorrow(cell2.value); - const _757: rt.u32 = _761.value.value.area$Shape(); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(areas2.items, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_757, f)]; - const _753: string = rt.fmtFormat([args46[0], " ", args46[1], " "]); - rt.refRelease(_761); + const _761: rs.RefCell> = rs.refCellBorrow(cell2.value); + const _757: rs.u32 = _761.value.value.area$Shape(); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(areas2.items, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_757, f)]; + const _753: string = rs.fmtFormat([args46[0], " ", args46[1], " "]); + rs.refRelease(_761); put(out, _753); - const _773: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_773.value); - rt.refMutRelease(_773); - rt.dropVec(guarded, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape); - const _785: rt.RefCell = rt.refCellBorrow(log.value); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_785.value), f, rt.u8Debug)]; - const _781: string = rt.fmtFormat([args48[0], " "]); - rt.refRelease(_785); + const _773: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_773.value); + rs.refMutRelease(_773); + rs.dropVec(guarded, drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape); + const _785: rs.RefCell = rs.refCellBorrow(log.value); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_785.value), f, rs.u8Debug)]; + const _781: string = rs.fmtFormat([args48[0], " "]); + rs.refRelease(_785); put(out, _781); - rt.arcDrop(cell2, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape); - const _801: rt.RefCell = rt.refCellBorrow(log.value); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_801.value), f, rt.u8Debug)]; - const _797: string = rt.fmtFormat([args50[0], " "]); - rt.refRelease(_801); + rs.arcDrop(cell2, drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape); + const _801: rs.RefCell = rs.refCellBorrow(log.value); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_801.value), f, rs.u8Debug)]; + const _797: string = rs.fmtFormat([args50[0], " "]); + rs.refRelease(_801); put(out, _797); - const t2: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(a, rt.arcClone(log)), b as rt.u32); - const apart: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rt.arcClone(log)), b as rt.u32); - const _822: Tail.Tail = rt.tailDyn(t2, { value: (value32: Tail.Tail) => new ofPlace$u32(rt.place(() => value32.value, (value33) => value32.value = value33)) }); - const _824: Tail.Tail = rt.tailDyn(t2, { value: (value34: Tail.Tail) => new ofPlace$u32(rt.place(() => value34.value, (value35) => value34.value = value35)) }); - const _826: Tail.Tail = rt.tailDyn(apart, { value: (value36: Tail.Tail) => new ofPlace$u32(rt.place(() => value36.value, (value37) => value36.value = value37)) }); - const cell3: rt.Arc> = new rt.Arc(new rt.RefCell(c as rt.u32)); - const _835: rt.Arc> = rt.arcClone(cell3); - const _834: rt.Arc> = new rt.ArcDyn(_835, rt.tailDyn(_835.value, { value: (value38: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value38)) })); - const _838: rt.Arc> = rt.arcClone(cell3); - const _833: [rt.Arc>, rt.Arc>] = [_834, new rt.ArcDyn(_838, rt.tailDyn(_838.value, { value: (value39: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value39)) }))]; - const r2: rt.Arc> = _834; - const s2: rt.Arc> = _833[1]; - const _841: rt.Arc> = new rt.Arc(new rt.RefCell(c as rt.u32)); - const other: rt.Arc> = new rt.ArcDyn(_841, rt.tailDyn(_841.value, { value: (value40: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value40)) })); - const _846: [rt.Weak>, rt.Weak>] = [new rt.Weak(r2), new rt.Weak(s2)]; - const u: rt.Weak> = _846[0]; - const v: rt.Weak> = _846[1]; - const _859: boolean = rt.tailSame(_822, _824); - const _863: boolean = rt.tailSame(_822, _826); - const _867: boolean = rt.arcPtrEq(r2, s2); - const _871: boolean = rt.arcPtrEq(r2, other); - const _875: boolean = rt.arcPtrEq(u.arc, v.arc); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_859, f), (f: rt.Formatter) => rt.fmtBool(_863, f), (f: rt.Formatter) => rt.fmtBool(_867, f), (f: rt.Formatter) => rt.fmtBool(_871, f), (f: rt.Formatter) => rt.fmtBool(_875, f)]; - put(out, rt.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " ", args52[4], " "])); + const t2: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(a, rs.arcClone(log)), b as rs.u32); + const apart: Tail.Tail = new Tail.Tail(a, new Noisy.Noisy(b, rs.arcClone(log)), b as rs.u32); + const _822: Tail.Tail = rs.tailDyn(t2, { value: (value32: Tail.Tail) => new ofPlace$u32(rs.place(() => value32.value, (value33) => value32.value = value33)) }); + const _824: Tail.Tail = rs.tailDyn(t2, { value: (value34: Tail.Tail) => new ofPlace$u32(rs.place(() => value34.value, (value35) => value34.value = value35)) }); + const _826: Tail.Tail = rs.tailDyn(apart, { value: (value36: Tail.Tail) => new ofPlace$u32(rs.place(() => value36.value, (value37) => value36.value = value37)) }); + const cell3: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); + const _835: rs.Arc> = rs.arcClone(cell3); + const _834: rs.Arc> = new rs.ArcDyn(_835, rs.tailDyn(_835.value, { value: (value38: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value38)) })); + const _838: rs.Arc> = rs.arcClone(cell3); + const _833: [rs.Arc>, rs.Arc>] = [_834, new rs.ArcDyn(_838, rs.tailDyn(_838.value, { value: (value39: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value39)) }))]; + const r2: rs.Arc> = _834; + const s2: rs.Arc> = _833[1]; + const _841: rs.Arc> = new rs.Arc(new rs.RefCell(c as rs.u32)); + const other: rs.Arc> = new rs.ArcDyn(_841, rs.tailDyn(_841.value, { value: (value40: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value40)) })); + const _846: [rs.Weak>, rs.Weak>] = [new rs.Weak(r2), new rs.Weak(s2)]; + const u: rs.Weak> = _846[0]; + const v: rs.Weak> = _846[1]; + const _859: boolean = rs.tailSame(_822, _824); + const _863: boolean = rs.tailSame(_822, _826); + const _867: boolean = rs.arcPtrEq(r2, s2); + const _871: boolean = rs.arcPtrEq(r2, other); + const _875: boolean = rs.arcPtrEq(u.arc, v.arc); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_859, f), (f: rs.Formatter) => rs.fmtBool(_863, f), (f: rs.Formatter) => rs.fmtBool(_867, f), (f: rs.Formatter) => rs.fmtBool(_871, f), (f: rs.Formatter) => rs.fmtBool(_875, f)]; + put(out, rs.fmtFormat([args52[0], " ", args52[1], " ", args52[2], " ", args52[3], " ", args52[4], " "])); v[Symbol.dispose](); u[Symbol.dispose](); other[Symbol.dispose](); @@ -1915,83 +1915,83 @@ export function tails(data: rt.ByteSlice, out: rt.ByteVec): void { cell3[Symbol.dispose](); apart[Symbol.dispose](); t2[Symbol.dispose](); - const _889: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_889.value); - rt.refMutRelease(_889); - let sum: rt.u32 = 0; - const _894: rt.Arc undefined>> = new rt.Arc(new rt.RefCell((x2: rt.u8): undefined => { - sum = rt.u32WrappingAdd(sum, x2 as rt.u32); + const _889: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_889.value); + rs.refMutRelease(_889); + let sum: rs.u32 = 0; + const _894: rs.Arc undefined>> = new rs.Arc(new rs.RefCell((x2: rs.u8): undefined => { + sum = rs.u32WrappingAdd(sum, x2 as rs.u32); })); - f = new rt.ArcDyn(_894, rt.tailDyn(_894.value, { value: (value41: rt.RefCell<(a0: rt.u8) => undefined>) => value41.value })); - for (const x of rt.byteSliceView(rt.byteSliceRange(data, 3))) { - const _907: rt.RefCell<(a0: rt.u8) => undefined> = rt.refCellBorrowMut(f.value); + f = new rs.ArcDyn(_894, rs.tailDyn(_894.value, { value: (value41: rs.RefCell<(a0: rs.u8) => undefined>) => value41.value })); + for (const x of rs.byteSliceView(rs.byteSliceRange(data, 3))) { + const _907: rs.RefCell<(a0: rs.u8) => undefined> = rs.refCellBorrowMut(f.value); _907.value(x); - rt.refMutRelease(_907); + rs.refMutRelease(_907); } f[Symbol.dispose](); - const shown: rt.RefCell = rt.tailDyn(new rt.RefCell({ tag: "Tall", _0: c } as Tri.Tri), { value: (value42: rt.RefCell): rt.Fmt => { - const arg8 = rt.valuePlace(value42); - return (f: rt.Formatter) => Tri.fmt$fmt_Debug(arg8.v, f); + const shown: rs.RefCell = rs.tailDyn(new rs.RefCell({ tag: "Tall", _0: c } as Tri.Tri), { value: (value42: rs.RefCell): rs.Fmt => { + const arg8 = rs.valuePlace(value42); + return (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg8.v, f); } }); - const any: Tail.Tail = rt.tailDyn(new Tail.Tail(b, new Noisy.Noisy(b, rt.arcClone(log)), c as rt.u32), { value: (value43: Tail.Tail) => new ofPlace$u32(rt.place(() => value43.value, (value44) => value43.value = value44)) }, rt.drop); - const _923: rt.Arc>> = new rt.Arc(new rt.Mutex(rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3)))))); - const it: rt.Arc>> = new rt.ArcDyn(_923, rt.tailDyn(_923.value, { value: (value45: rt.Mutex>) => rt.iterDyn(rt.iterBorrow(value45.value)) })); - const _931: rt.Mutex> = rt.mutexLock(it.value); - const next: rt.u8 | undefined = rt.iterToOption(_931.value.next()); - rt.mutexUnlock(_931); - const _943: rt.u32 | undefined = any.value instanceof of$u32 ? any.value.v : any.value instanceof ofPlace$u32 ? any.value.v.v : undefined; + const any: Tail.Tail = rs.tailDyn(new Tail.Tail(b, new Noisy.Noisy(b, rs.arcClone(log)), c as rs.u32), { value: (value43: Tail.Tail) => new ofPlace$u32(rs.place(() => value43.value, (value44) => value43.value = value44)) }, rs.drop); + const _923: rs.Arc>> = new rs.Arc(new rs.Mutex(rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3)))))); + const it: rs.Arc>> = new rs.ArcDyn(_923, rs.tailDyn(_923.value, { value: (value45: rs.Mutex>) => rs.iterDyn(rs.iterBorrow(value45.value)) })); + const _931: rs.Mutex> = rs.mutexLock(it.value); + const next: rs.u8 | undefined = rs.iterToOption(_931.value.next()); + rs.mutexUnlock(_931); + const _943: rs.u32 | undefined = any.value instanceof of$u32 ? any.value.v : any.value instanceof ofPlace$u32 ? any.value.v.v : undefined; const _946: boolean = any.value instanceof of$u8 || any.value instanceof ofPlace$u8; - const _952: rt.Mutex> = rt.mutexLock(it.value); - const _949: rt.u8 | undefined = rt.iterToOption(_952.value.next()); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.refCellDebug(shown, f, (value: rt.Fmt, f: rt.Formatter) => value(f)), (f: rt.Formatter) => rt.fmtOption(_943, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtBool(_946, f), (f: rt.Formatter) => rt.fmtOption(next, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_949, f, rt.u8Debug)]; - const _939: string = rt.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]); - rt.mutexUnlock(_952); + const _952: rs.Mutex> = rs.mutexLock(it.value); + const _949: rs.u8 | undefined = rs.iterToOption(_952.value.next()); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.refCellDebug(shown, f, (value: rs.Fmt, f: rs.Formatter) => value(f)), (f: rs.Formatter) => rs.fmtOption(_943, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_946, f), (f: rs.Formatter) => rs.fmtOption(next, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_949, f, rs.u8Debug)]; + const _939: string = rs.fmtFormat([args54[0], " ", args54[1], " ", args54[2], " ", args54[3], " ", args54[4], " ", args54[5], " "]); + rs.mutexUnlock(_952); put(out, _939); - const _968: rt.u8 | undefined = option_map$0cs071d(rt.byteSliceFirst(rt.byteSliceRange(data, 3)), (x3: rt.u8): rt.u8 => { - return rt.u8Rem(x3, 4); + const _968: rs.u8 | undefined = option_map$1yjmt5m(rs.byteSliceFirst(rs.byteSliceRange(data, 3)), (x3: rs.u8): rs.u8 => { + return rs.u8Rem(x3, 4); }); b6: { if (_968 !== undefined) { if (_968 === 0) { - const _shared: rt.RefCell = rt.refCellBorrow(n.value); - const _975: rt.Arc> = rt.arcClone(n); - const dynamic: rt.Arc> = new rt.ArcDyn(_975, rt.tailDyn(_975.value, { value: (value47: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value47)) })); - const _980: rt.RefCell = rt.refCellBorrowMut(dynamic.value); + const _shared: rs.RefCell = rs.refCellBorrow(n.value); + const _975: rs.Arc> = rs.arcClone(n); + const dynamic: rs.Arc> = new rs.ArcDyn(_975, rs.tailDyn(_975.value, { value: (value47: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value47)) })); + const _980: rs.RefCell = rs.refCellBorrowMut(dynamic.value); _980.value.grow$Shape(1); - rt.refMutRelease(_980); + rs.refMutRelease(_980); dynamic[Symbol.dispose](); - rt.refRelease(_shared); + rs.refRelease(_shared); break b6; } if (_968 === 1) { - const _984: rt.Arc> = rt.arcClone(n); - const dynamic2: rt.Arc> = new rt.ArcDyn(_984, rt.tailDyn(_984.value, { value: (value46: rt.RefCell) => new ofPlace$u32(rt.valuePlace(value46)) })); - const _held2: rt.RefCell = rt.refCellBorrowMut(dynamic2.value); - const _997: rt.RefCell = rt.refCellBorrow(n.value); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_997.value, f)]; - const _993: string = rt.fmtFormat([args56[0]]); - rt.refRelease(_997); + const _984: rs.Arc> = rs.arcClone(n); + const dynamic2: rs.Arc> = new rs.ArcDyn(_984, rs.tailDyn(_984.value, { value: (value46: rs.RefCell) => new ofPlace$u32(rs.valuePlace(value46)) })); + const _held2: rs.RefCell = rs.refCellBorrowMut(dynamic2.value); + const _997: rs.RefCell = rs.refCellBorrow(n.value); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_997.value, f)]; + const _993: string = rs.fmtFormat([args56[0]]); + rs.refRelease(_997); put(out, _993); - rt.refMutRelease(_held2); + rs.refMutRelease(_held2); dynamic2[Symbol.dispose](); break b6; } if (_968 === 2) { - const _guard2: rt.Mutex = rt.mutexLock(m.value); - const _1019: rt.Mutex = rt.mutexLock(locked.value); + const _guard2: rs.Mutex = rs.mutexLock(m.value); + const _1019: rs.Mutex = rs.mutexLock(locked.value); const part3 = _1019.value.area$Shape(); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - const _1012: string = rt.fmtFormat([args58[0]]); - rt.mutexUnlock(_1019); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + const _1012: string = rs.fmtFormat([args58[0]]); + rs.mutexUnlock(_1019); put(out, _1012); - rt.mutexUnlock(_guard2); + rs.mutexUnlock(_guard2); break b6; } } - const _1034: rt.RefCell = rt.refCellBorrow(n.value); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1034.value, f)]; - const _1030: string = rt.fmtFormat([args60[0]]); - rt.refRelease(_1034); + const _1034: rs.RefCell = rs.refCellBorrow(n.value); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1034.value, f)]; + const _1030: string = rs.fmtFormat([args60[0]]); + rs.refRelease(_1034); put(out, _1030); } it[Symbol.dispose](); @@ -2014,274 +2014,274 @@ export function tails(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Polls `f` until it is ready, at most `max` times: how many it took and its output. */ -export function pollTail(f: rt.Mutex>, max: rt.u8): [rt.u8, rt.u8 | undefined] { - let _8!: rt.u8; - const cx: rt.Context = rt.NOOP_WAKER; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = max; +export function pollTail(f: rs.Mutex>, max: rs.u8): [rs.u8, rs.u8 | undefined] { + let _8!: rs.u8; + const cx: rs.Context = rs.NOOP_WAKER; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = max; while ((_8 = iterStart++) < iterEnd) { - const i: rt.u8 = _8; - const _16: rt.Mutex> = rt.mutexLock(f); - const _12: rt.Poll = _16.value.poll(cx); - if (_12 !== rt.Pending) { - const _0: [rt.u8, rt.u8 | undefined] = [rt.u8Add(i, 1), _12]; - rt.mutexUnlock(_16); + const i: rs.u8 = _8; + const _16: rs.Mutex> = rs.mutexLock(f); + const _12: rs.Poll = _16.value.poll(cx); + if (_12 !== rs.Pending) { + const _0: [rs.u8, rs.u8 | undefined] = [rs.u8Add(i, 1), _12]; + rs.mutexUnlock(_16); return _0; } - rt.mutexUnlock(_16); + rs.mutexUnlock(_16); } - return [max, undefined] as [rt.u8, rt.u8 | undefined]; + return [max, undefined] as [rs.u8, rs.u8 | undefined]; } /** Through a raw pointer to a trait object, as `&mut` to it would. */ -export function growRaw(p: Shape.Shape, by: rt.u8): rt.u32 { +export function growRaw(p: Shape.Shape, by: rs.u8): rs.u32 { p.grow$Shape(by); return p.area$Shape(); } -export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let ready!: rt.u8 | undefined; +export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let ready!: rs.u8 | undefined; if (dataLen >= 3) { - const _11: [rt.u8, rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1], dataData[dataStart + 2]]; - const a: rt.u8 = _11[0]; - const b: rt.u8 = _11[1]; - const c: rt.u8 = _11[2]; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const n: rt.Cell = new rt.Cell(a as rt.u32); - const sq: rt.Cell = new rt.Cell({ side: b as rt.u16 }); - const tri: rt.Cell = new rt.Cell({ tag: "Tall", _0: c } as Tri.Tri); - const iter: rt.Iter<[rt.usize, rt.Cell]> = rt.iterEnumerate(rt.iterSlice([rt.tailDyn(n, { v: (value: rt.Cell) => new ofPlace$u32(value) }), rt.tailDyn(sq, { v: (value2: rt.Cell) => new of$dyns_Square(value2.v) }), rt.tailDyn(tri, { v: (value3: rt.Cell) => new ofPlace$dyns_Tri(value3) })])); + const _11: [rs.u8, rs.u8, rs.u8] = [dataData[dataStart], dataData[dataStart + 1], dataData[dataStart + 2]]; + const a: rs.u8 = _11[0]; + const b: rs.u8 = _11[1]; + const c: rs.u8 = _11[2]; + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const n: rs.Cell = new rs.Cell(a as rs.u32); + const sq: rs.Cell = new rs.Cell({ side: b as rs.u16 }); + const tri: rs.Cell = new rs.Cell({ tag: "Tall", _0: c } as Tri.Tri); + const iter: rs.Iter<[rs.usize, rs.Cell]> = rs.iterEnumerate(rs.iterSlice([rs.tailDyn(n, { v: (value: rs.Cell) => new ofPlace$u32(value) }), rs.tailDyn(sq, { v: (value2: rs.Cell) => new of$dyns_Square(value2.v) }), rs.tailDyn(tri, { v: (value3: rs.Cell) => new ofPlace$dyns_Tri(value3) })])); while (true) { - const _36: [rt.usize, rt.Cell] | rt.Done = iter.next(); - if (_36 === rt.DONE) { + const _36: [rs.usize, rs.Cell] | rs.Done = iter.next(); + if (_36 === rs.DONE) { break; } - _36[1].v.grow$Shape(rt.u8WrappingAdd(c, _36[0] & 0xff)); + _36[1].v.grow$Shape(rs.u8WrappingAdd(c, _36[0] & 0xff)); } - const area: rt.u32 = rt.tailDyn(tri, { v: (value4: rt.Cell) => new ofPlace$dyns_Tri(value4) }).v.area$Shape(); - const _58: rt.u32 = n.v; + const area: rs.u32 = rs.tailDyn(tri, { v: (value4: rs.Cell) => new ofPlace$dyns_Tri(value4) }).v.area$Shape(); + const _58: rs.u32 = n.v; const _61: Square.Square = sq.v; const _64: Tri.Tri = copy$dyns_Tri(tri.v); - const _68: rt.Fmt = (f: rt.Formatter) => rt.u32Display(_58, f); + const _68: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_58, f); const arg = _61.side; - const args2: rt.Fmt[] = [_68, (f: rt.Formatter) => rt.u16Display(arg, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rt.Formatter) => rt.u32Display(area, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "])); - const noisy: rt.Arc> = new rt.Arc(new rt.Cell(new Noisy.Noisy(a, rt.arcClone(log)))); - const _80: rt.Arc> = rt.arcClone(noisy); - const cell: rt.Arc> = new rt.ArcDyn(_80, rt.tailDyn(_80.value, { v: (value5: rt.Cell) => new of$dyns_Noisy(value5.v) }, rt.drop)); - const area2: rt.u32 = growRaw(cell.value.v, b); + const args2: rs.Fmt[] = [_68, (f: rs.Formatter) => rs.u16Display(arg, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_64, f), (f: rs.Formatter) => rs.u32Display(area, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " "])); + const noisy: rs.Arc> = new rs.Arc(new rs.Cell(new Noisy.Noisy(a, rs.arcClone(log)))); + const _80: rs.Arc> = rs.arcClone(noisy); + const cell: rs.Arc> = new rs.ArcDyn(_80, rs.tailDyn(_80.value, { v: (value5: rs.Cell) => new of$dyns_Noisy(value5.v) }, rs.drop)); + const area2: rs.u32 = growRaw(cell.value.v, b); noisy[Symbol.dispose](); - const _95: rt.RefCell = rt.refCellBorrow(log.value); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(area2, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_95.value), f, rt.u8Debug)]; - const _91: string = rt.fmtFormat([args4[0], " ", args4[1], " "]); - rt.refRelease(_95); + const _95: rs.RefCell = rs.refCellBorrow(log.value); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area2, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_95.value), f, rs.u8Debug)]; + const _91: string = rs.fmtFormat([args4[0], " ", args4[1], " "]); + rs.refRelease(_95); put(out, _91); cell[Symbol.dispose](); - const _113: rt.RefCell = rt.refCellBorrow(log.value); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_113.value), f, rt.u8Debug)]; - const _109: string = rt.fmtFormat([args6[0], " "]); - rt.refRelease(_113); + const _113: rs.RefCell = rs.refCellBorrow(log.value); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_113.value), f, rs.u8Debug)]; + const _109: string = rs.fmtFormat([args6[0], " "]); + rs.refRelease(_113); put(out, _109); - const _123: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_123.value); - rt.refMutRelease(_123); - const u: rt.Arc> = new rt.Arc(new rt.Cell({ tag: "Flat" } as Tri.Tri)); - const _130: rt.Arc> = rt.arcClone(u); - const shape: rt.Arc> = new rt.ArcDyn(_130, rt.tailDyn(_130.value, { v: (value6: rt.Cell) => new ofPlace$dyns_Tri(value6) })); + const _123: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_123.value); + rs.refMutRelease(_123); + const u: rs.Arc> = new rs.Arc(new rs.Cell({ tag: "Flat" } as Tri.Tri)); + const _130: rs.Arc> = rs.arcClone(u); + const shape: rs.Arc> = new rs.ArcDyn(_130, rs.tailDyn(_130.value, { v: (value6: rs.Cell) => new ofPlace$dyns_Tri(value6) })); shape.value.v.grow$Shape(a); - const area3: rt.u32 = growRaw(shape.value.v, b); - const boxed: rt.Cell = rt.tailDyn(new rt.Cell(new Noisy.Noisy(c, rt.arcClone(log))), { v: (value7: rt.Cell) => new of$dyns_Noisy(value7.v) }, rt.drop); + const area3: rs.u32 = growRaw(shape.value.v, b); + const boxed: rs.Cell = rs.tailDyn(new rs.Cell(new Noisy.Noisy(c, rs.arcClone(log))), { v: (value7: rs.Cell) => new of$dyns_Noisy(value7.v) }, rs.drop); boxed.v.grow$Shape(a); const _158: Tri.Tri = copy$dyns_Tri(u.value.v); - const _163: rt.u32 = boxed.v.area$Shape(); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(area3, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rt.Formatter) => rt.u32Display(_163, f)]; - put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); + const _163: rs.u32 = boxed.v.area$Shape(); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(area3, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_158, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", args8[2], " "])); boxed[Symbol.dispose](); - const _183: rt.RefCell = rt.refCellBorrow(log.value); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_183.value), f, rt.u8Debug)]; - const _179: string = rt.fmtFormat([args10[0], " "]); - rt.refRelease(_183); + const _183: rs.RefCell = rs.refCellBorrow(log.value); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_183.value), f, rs.u8Debug)]; + const _179: string = rs.fmtFormat([args10[0], " "]); + rs.refRelease(_183); put(out, _179); - const _193: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_193.value); - rt.refMutRelease(_193); - const kept: Noisy.Noisy = new Noisy.Noisy(a, rt.arcClone(log)); + const _193: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_193.value); + rs.refMutRelease(_193); + const kept: Noisy.Noisy = new Noisy.Noisy(a, rs.arcClone(log)); let held: Tri.Tri = copy$dyns_Tri({ tag: "Tall", _0: b } as Tri.Tri); const m: Shape.Shape = new of$dyns_Noisy(kept); m.grow$Shape(c); - const t: Shape.Shape = new ofPlace$dyns_Tri(rt.place(() => held, (value8) => held = value8)); + const t: Shape.Shape = new ofPlace$dyns_Tri(rs.place(() => held, (value8) => held = value8)); t.grow$Shape(a); - const _218: rt.u32 = m.area$Shape(); - const _222: rt.u32 = t.area$Shape(); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_218, f), (f: rt.Formatter) => rt.u32Display(_222, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " "])); - const _244: rt.u32 = new of$dyns_Noisy(new Noisy.Noisy(b, rt.arcClone(log))).area$Shape(); + const _218: rs.u32 = m.area$Shape(); + const _222: rs.u32 = t.area$Shape(); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_218, f), (f: rs.Formatter) => rs.u32Display(_222, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " "])); + const _244: rs.u32 = new of$dyns_Noisy(new Noisy.Noisy(b, rs.arcClone(log))).area$Shape(); const _248: Noisy.Noisy = kept; const _250: Tri.Tri = held; - const _253: rt.Fmt = (f: rt.Formatter) => rt.u32Display(_244, f); + const _253: rs.Fmt = (f: rs.Formatter) => rs.u32Display(_244, f); const arg2 = _248._0; - const args14: rt.Fmt[] = [_253, (f: rt.Formatter) => rt.u8Display(arg2, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); - const _267: rt.RefCell = rt.refCellBorrow(log.value); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_267.value), f, rt.u8Debug)]; - const _263: string = rt.fmtFormat([args16[0], " "]); - rt.refRelease(_267); + const args14: rs.Fmt[] = [_253, (f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_250, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " "])); + const _267: rs.RefCell = rs.refCellBorrow(log.value); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_267.value), f, rs.u8Debug)]; + const _263: string = rs.fmtFormat([args16[0], " "]); + rs.refRelease(_267); put(out, _263); - rt.drop(new of$dyns_Noisy(kept)); - const _285: rt.RefCell = rt.refCellBorrow(log.value); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_285.value), f, rt.u8Debug)]; - const _281: string = rt.fmtFormat([args18[0], " "]); - rt.refRelease(_285); + rs.drop(new of$dyns_Noisy(kept)); + const _285: rs.RefCell = rs.refCellBorrow(log.value); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_285.value), f, rs.u8Debug)]; + const _281: string = rs.fmtFormat([args18[0], " "]); + rs.refRelease(_285); put(out, _281); - const _295: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_295.value); - rt.refMutRelease(_295); - const ticks: rt.Arc> = new rt.Arc(new rt.Mutex(new Ticks.Ticks(rt.u8Rem(a, 4), 0, rt.arcClone(log)))); - const _306: rt.Arc> = rt.arcClone(ticks); - const future: rt.Arc>> = new rt.ArcDyn(_306, rt.tailDyn(_306.value, { value: (value9: rt.Mutex) => new rt.DynFuture(value9.value, Ticks.poll$Future, rt.drop) }, rt.drop)); - const first: [rt.u8, rt.u8 | undefined] = pollTail(future.value, rt.u8Rem(b, 3)); - const _316: rt.Mutex = rt.mutexLock(ticks.value); - const polls: rt.u8 = _316.value.polls; - rt.mutexUnlock(_316); - const rest: [rt.u8, rt.u8 | undefined] = pollTail(future.value, 8); + const _295: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_295.value); + rs.refMutRelease(_295); + const ticks: rs.Arc> = new rs.Arc(new rs.Mutex(new Ticks.Ticks(rs.u8Rem(a, 4), 0, rs.arcClone(log)))); + const _306: rs.Arc> = rs.arcClone(ticks); + const future: rs.Arc>> = new rs.ArcDyn(_306, rs.tailDyn(_306.value, { value: (value9: rs.Mutex) => new rs.DynFuture(value9.value, Ticks.poll$Future, rs.drop) }, rs.drop)); + const first: [rs.u8, rs.u8 | undefined] = pollTail(future.value, rs.u8Rem(b, 3)); + const _316: rs.Mutex = rs.mutexLock(ticks.value); + const polls: rs.u8 = _316.value.polls; + rs.mutexUnlock(_316); + const rest: [rs.u8, rs.u8 | undefined] = pollTail(future.value, 8); ticks[Symbol.dispose](); - const _332: rt.RefCell = rt.refCellBorrow(log.value); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(first[0], f), (f: rt.Formatter) => rt.fmtOption(first[1], f, rt.u8Debug)], f), (f: rt.Formatter) => rt.u8Display(polls, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(rest[0], f), (f: rt.Formatter) => rt.fmtOption(rest[1], f, rt.u8Debug)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_332.value), f, rt.u8Debug)]; - const _328: string = rt.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3], " "]); - rt.refRelease(_332); + const _332: rs.RefCell = rs.refCellBorrow(log.value); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(first[0], f), (f: rs.Formatter) => rs.fmtOption(first[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Display(polls, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(rest[0], f), (f: rs.Formatter) => rs.fmtOption(rest[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_332.value), f, rs.u8Debug)]; + const _328: string = rs.fmtFormat([args20[0], " ", args20[1], " ", args20[2], " ", args20[3], " "]); + rs.refRelease(_332); put(out, _328); future[Symbol.dispose](); - const _354: rt.RefCell = rt.refCellBorrow(log.value); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_354.value), f, rt.u8Debug)]; - const _350: string = rt.fmtFormat([args22[0], " "]); - rt.refRelease(_354); + const _354: rs.RefCell = rs.refCellBorrow(log.value); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_354.value), f, rs.u8Debug)]; + const _350: string = rs.fmtFormat([args22[0], " "]); + rs.refRelease(_354); put(out, _350); - const _364: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_364.value); - rt.refMutRelease(_364); - const owned: Noisy.Noisy = new Noisy.Noisy(c, rt.arcClone(log)); - const block: rt.Arc>> = new rt.Arc(new rt.RefCell(new restsFuture$closure0(owned._0))); - const _374: rt.Arc>> = rt.arcClone(block); - const erased: rt.Arc>> = new rt.ArcDyn(_374, rt.tailDyn(_374.value, { value: (value10: rt.RefCell>) => value10.value }, rt.drop)); - const cx: rt.Context = rt.NOOP_WAKER; - const borrowed: rt.RefCell> = rt.refCellBorrowMut(erased.value); - const _382: rt.Poll = borrowed.value.poll(cx); - if (_382 !== rt.Pending) { + const _364: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_364.value); + rs.refMutRelease(_364); + const owned: Noisy.Noisy = new Noisy.Noisy(c, rs.arcClone(log)); + const block: rs.Arc>> = new rs.Arc(new rs.RefCell(new restsFuture$closure0(owned._0))); + const _374: rs.Arc>> = rs.arcClone(block); + const erased: rs.Arc>> = new rs.ArcDyn(_374, rs.tailDyn(_374.value, { value: (value10: rs.RefCell>) => value10.value }, rs.drop)); + const cx: rs.Context = rs.NOOP_WAKER; + const borrowed: rs.RefCell> = rs.refCellBorrowMut(erased.value); + const _382: rs.Poll = borrowed.value.poll(cx); + if (_382 !== rs.Pending) { ready = _382; } else { ready = undefined; } - rt.refMutRelease(borrowed); + rs.refMutRelease(borrowed); block[Symbol.dispose](); - const _398: rt.RefCell = rt.refCellBorrow(log.value); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(ready, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_398.value), f, rt.u8Debug)]; - const _394: string = rt.fmtFormat([args24[0], " ", args24[1], " "]); - rt.refRelease(_398); + const _398: rs.RefCell = rs.refCellBorrow(log.value); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(ready, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_398.value), f, rs.u8Debug)]; + const _394: string = rs.fmtFormat([args24[0], " ", args24[1], " "]); + rs.refRelease(_398); put(out, _394); erased[Symbol.dispose](); - const _416: rt.RefCell = rt.refCellBorrow(log.value); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_416.value), f, rt.u8Debug)]; - const _412: string = rt.fmtFormat([args26[0], " "]); - rt.refRelease(_416); + const _416: rs.RefCell = rs.refCellBorrow(log.value); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_416.value), f, rs.u8Debug)]; + const _412: string = rs.fmtFormat([args26[0], " "]); + rs.refRelease(_416); put(out, _412); - const _426: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_426.value); - rt.refMutRelease(_426); - const side: Square.Square = { side: a as rt.u16 }; - let num: rt.u32 = b as rt.u32; - const t2: Tail.Tail = new Tail.Tail(c, new Noisy.Noisy(c, rt.arcClone(log)), { tag: "Tall", _0: a } as Tri.Tri); - const _439: [Shape.Shape, Shape.Shape] = [rt.rawUnsize(side, (p3) => new of$dyns_Square(p3)), rt.rawUnsize(rt.place(() => num, (value11) => num = value11), (p4) => new ofPlace$u32(p4))]; + const _426: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_426.value); + rs.refMutRelease(_426); + const side: Square.Square = { side: a as rs.u16 }; + let num: rs.u32 = b as rs.u32; + const t2: Tail.Tail = new Tail.Tail(c, new Noisy.Noisy(c, rs.arcClone(log)), { tag: "Tall", _0: a } as Tri.Tri); + const _439: [Shape.Shape, Shape.Shape] = [rs.rawUnsize(side, (p3) => new of$dyns_Square(p3)), rs.rawUnsize(rs.place(() => num, (value11) => num = value11), (p4) => new ofPlace$u32(p4))]; const p: Shape.Shape = _439[0]; const q: Shape.Shape = _439[1]; - const r: Shape.Shape = rt.rawUnsize(side, (p5) => new of$dyns_Square(p5)); - const tail: Tail.Tail = rt.rawUnsize(t2, (p6) => rt.tailDyn(p6, { value: (value12: Tail.Tail) => new ofPlace$dyns_Tri(rt.place(() => value12.value, (value13) => value12.value = value13)) }, rt.drop)); - const areas: [rt.u32, rt.u32, rt.u32] = [growRaw(p, c), growRaw(q, a), r.area$Shape()]; - tail.count = rt.u8WrappingAdd(tail.count, a); - const area4: rt.u32 = growRaw(tail.value, b); - const _471: rt.Fmt = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(areas[0], f), (f: rt.Formatter) => rt.u32Debug(areas[1], f), (f: rt.Formatter) => rt.u32Debug(areas[2], f)], f); - const _472: rt.Fmt = (f: rt.Formatter) => rt.u32Display(area4, f); + const r: Shape.Shape = rs.rawUnsize(side, (p5) => new of$dyns_Square(p5)); + const tail: Tail.Tail = rs.rawUnsize(t2, (p6) => rs.tailDyn(p6, { value: (value12: Tail.Tail) => new ofPlace$dyns_Tri(rs.place(() => value12.value, (value13) => value12.value = value13)) }, rs.drop)); + const areas: [rs.u32, rs.u32, rs.u32] = [growRaw(p, c), growRaw(q, a), r.area$Shape()]; + tail.count = rs.u8WrappingAdd(tail.count, a); + const area4: rs.u32 = growRaw(tail.value, b); + const _471: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(areas[0], f), (f: rs.Formatter) => rs.u32Debug(areas[1], f), (f: rs.Formatter) => rs.u32Debug(areas[2], f)], f); + const _472: rs.Fmt = (f: rs.Formatter) => rs.u32Display(area4, f); const arg3 = side.side; - const _473: rt.Fmt = (f: rt.Formatter) => rt.u16Display(arg3, f); - const _474: rt.Fmt = (f: rt.Formatter) => rt.u32Display(num, f); + const _473: rs.Fmt = (f: rs.Formatter) => rs.u16Display(arg3, f); + const _474: rs.Fmt = (f: rs.Formatter) => rs.u32Display(num, f); const arg4 = t2.count; - const _475: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg4, f); + const _475: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg4, f); const arg5 = t2.value; - const args28: rt.Fmt[] = [_471, _472, _473, _474, _475, (f: rt.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; - put(out, rt.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " ", args28[5], " "])); + const args28: rs.Fmt[] = [_471, _472, _473, _474, _475, (f: rs.Formatter) => Tri.fmt$fmt_Debug(arg5, f)]; + put(out, rs.fmtFormat([args28[0], " ", args28[1], " ", args28[2], " ", args28[3], " ", args28[4], " ", args28[5], " "])); t2[Symbol.dispose](); - const _489: rt.RefCell = rt.refCellBorrow(log.value); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(_489.value), f, rt.u8Debug)]; - const _485: string = rt.fmtFormat([args30[0], " "]); - rt.refRelease(_489); + const _489: rs.RefCell = rs.refCellBorrow(log.value); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(_489.value), f, rs.u8Debug)]; + const _485: string = rs.fmtFormat([args30[0], " "]); + rs.refRelease(_489); put(out, _485); - let sq2: rt.Cell = new rt.Cell({ side: c as rt.u16 }); - let tri2: rt.RefCell = new rt.RefCell({ tag: "Tall", _0: a } as Tri.Tri); - const p2: rt.Place> = rt.rawUnsizePlace(rt.place(() => sq2, (value14) => sq2 = value14), (p7) => rt.tailDyn(p7, { v: (value15: rt.Cell) => new of$dyns_Square(value15.v) })); - const q2: rt.Place> = rt.rawUnsizePlace(rt.place(() => tri2, (value16) => tri2 = value16), (p8) => rt.tailDyn(p8, { value: (value17: rt.RefCell) => new ofPlace$dyns_Tri(rt.valuePlace(value17)) })); + let sq2: rs.Cell = new rs.Cell({ side: c as rs.u16 }); + let tri2: rs.RefCell = new rs.RefCell({ tag: "Tall", _0: a } as Tri.Tri); + const p2: rs.Place> = rs.rawUnsizePlace(rs.place(() => sq2, (value14) => sq2 = value14), (p7) => rs.tailDyn(p7, { v: (value15: rs.Cell) => new of$dyns_Square(value15.v) })); + const q2: rs.Place> = rs.rawUnsizePlace(rs.place(() => tri2, (value16) => tri2 = value16), (p8) => rs.tailDyn(p8, { value: (value17: rs.RefCell) => new ofPlace$dyns_Tri(rs.valuePlace(value17)) })); p2.v.v.grow$Shape(b); - const _512: rt.RefCell = rt.refCellBorrowMut(q2.v); + const _512: rs.RefCell = rs.refCellBorrowMut(q2.v); _512.value.grow$Shape(c); - rt.refMutRelease(_512); - const _514: rt.u32 = p2.v.v.area$Shape(); - const _521: rt.RefCell = rt.refCellBorrow(q2.v); - const areas2: [rt.u32, rt.u32] = [_514, _521.value.area$Shape()]; - rt.refRelease(_521); + rs.refMutRelease(_512); + const _514: rs.u32 = p2.v.v.area$Shape(); + const _521: rs.RefCell = rs.refCellBorrow(q2.v); + const areas2: [rs.u32, rs.u32] = [_514, _521.value.area$Shape()]; + rs.refRelease(_521); const _531: Square.Square = sq2.v; - const _534: rt.RefCell = rt.refCellBorrow(tri2); - const _538: rt.Fmt = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(areas2[0], f), (f: rt.Formatter) => rt.u32Debug(areas2[1], f)], f); + const _534: rs.RefCell = rs.refCellBorrow(tri2); + const _538: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(areas2[0], f), (f: rs.Formatter) => rs.u32Debug(areas2[1], f)], f); const arg6 = _531.side; - const args32: rt.Fmt[] = [_538, (f: rt.Formatter) => rt.u16Display(arg6, f), (f: rt.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; - const _527: string = rt.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); - rt.refRelease(_534); + const args32: rs.Fmt[] = [_538, (f: rs.Formatter) => rs.u16Display(arg6, f), (f: rs.Formatter) => Tri.fmt$fmt_Debug(_534.value, f)]; + const _527: string = rs.fmtFormat([args32[0], " ", args32[1], " ", args32[2], " "]); + rs.refRelease(_534); put(out, _527); - const _546: [Ticks.Ticks, Noisy.Noisy, Tail.Tail] = [new Ticks.Ticks(rt.u8Rem(b, 3), 0, rt.arcClone(log)), new Noisy.Noisy(a, rt.arcClone(log)), new Tail.Tail(b, new Noisy.Noisy(b, rt.arcClone(log)), new Noisy.Noisy(c, rt.arcClone(log)))]; + const _546: [Ticks.Ticks, Noisy.Noisy, Tail.Tail] = [new Ticks.Ticks(rs.u8Rem(b, 3), 0, rs.arcClone(log)), new Noisy.Noisy(a, rs.arcClone(log)), new Tail.Tail(b, new Noisy.Noisy(b, rs.arcClone(log)), new Noisy.Noisy(c, rs.arcClone(log)))]; const ticks2: Ticks.Ticks = _546[0]; const noisy2: Noisy.Noisy = _546[1]; const tail2: Tail.Tail = _546[2]; - const _571: [rt.Future, Shape.Shape, Tail.Tail] = [rt.rawUnsize(ticks2, (p9) => new rt.DynFuture(p9, Ticks.poll$Future, rt.drop)), rt.rawUnsize(noisy2, (p10) => new of$dyns_Noisy(p10)), rt.rawUnsize(tail2, (p11) => rt.tailDyn(p11, { value: (value18: Tail.Tail) => new of$dyns_Noisy(value18.value) }, rt.drop))]; - const ticks3: rt.Future = _571[0]; + const _571: [rs.Future, Shape.Shape, Tail.Tail] = [rs.rawUnsize(ticks2, (p9) => new rs.DynFuture(p9, Ticks.poll$Future, rs.drop)), rs.rawUnsize(noisy2, (p10) => new of$dyns_Noisy(p10)), rs.rawUnsize(tail2, (p11) => rs.tailDyn(p11, { value: (value18: Tail.Tail) => new of$dyns_Noisy(value18.value) }, rs.drop))]; + const ticks3: rs.Future = _571[0]; const noisy3: Shape.Shape = _571[1]; const tail3: Tail.Tail = _571[2]; - const polled: boolean = isReady$1ntq2i8(ticks3.poll(rt.NOOP_WAKER)); + const polled: boolean = isReady$1olyx0w(ticks3.poll(rs.NOOP_WAKER)); noisy3.grow$Shape(c); - rt.drop(ticks3); - rt.drop(noisy3); + rs.drop(ticks3); + rs.drop(noisy3); tail3[Symbol.dispose](); - const _599: rt.RefCell = rt.refCellBorrow(log.value); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(polled, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(_599.value), f, rt.u8Debug)]; - const _595: string = rt.fmtFormat([args34[0], " ", args34[1], " "]); - rt.refRelease(_599); + const _599: rs.RefCell = rs.refCellBorrow(log.value); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(polled, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(_599.value), f, rs.u8Debug)]; + const _595: string = rs.fmtFormat([args34[0], " ", args34[1], " "]); + rs.refRelease(_599); put(out, _595); - const _611: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_611.value); - rt.refMutRelease(_611); - const cell2: rt.Cell> = rt.tailDyn(new rt.Cell(new Countdown.Countdown(rt.u8Rem(a, 8))), { v: (value20: rt.Cell) => rt.iterDyn(rt.iterFrom(value20.v, Countdown.next$iter_Iterator)) }, rt.drop); - const first2: rt.u8 | undefined = rt.iterToOption(cell2.v.next()); - const _624: rt.Arc> = new rt.Arc(new rt.Mutex(new Countdown.Countdown(rt.u8Rem(b, 8)))); - const locked: rt.Arc>> = new rt.ArcDyn(_624, rt.tailDyn(_624.value, { value: (value21: rt.Mutex) => rt.iterDyn(rt.iterFrom(value21.value, Countdown.next$iter_Iterator)) }, rt.drop)); - const _632: rt.Mutex> = rt.mutexLock(locked.value); - const second: rt.u8 | undefined = rt.iterToOption(_632.value.next()); - rt.mutexUnlock(_632); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first2, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(second, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args36[0], " ", args36[1], " "])); + const _611: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_611.value); + rs.refMutRelease(_611); + const cell2: rs.Cell> = rs.tailDyn(new rs.Cell(new Countdown.Countdown(rs.u8Rem(a, 8))), { v: (value20: rs.Cell) => rs.iterDyn(rs.iterFrom(value20.v, Countdown.next$iter_Iterator)) }, rs.drop); + const first2: rs.u8 | undefined = rs.iterToOption(cell2.v.next()); + const _624: rs.Arc> = new rs.Arc(new rs.Mutex(new Countdown.Countdown(rs.u8Rem(b, 8)))); + const locked: rs.Arc>> = new rs.ArcDyn(_624, rs.tailDyn(_624.value, { value: (value21: rs.Mutex) => rs.iterDyn(rs.iterFrom(value21.value, Countdown.next$iter_Iterator)) }, rs.drop)); + const _632: rs.Mutex> = rs.mutexLock(locked.value); + const second: rs.u8 | undefined = rs.iterToOption(_632.value.next()); + rs.mutexUnlock(_632); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first2, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(second, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1], " "])); cell2[Symbol.dispose](); dropped(out); locked[Symbol.dispose](); dropped(out); - let slot: rt.Cell = (undefined as unknown) as rt.Cell; - const thin: rt.Place> = rt.place(() => slot, (value22) => slot = value22); - const wide: rt.Place> = rt.rawUnsizePlace(thin, (p12) => rt.tailDyn(p12, { v: (value23: rt.Cell) => new ofPlace$u32(value23) })); - const null_: boolean = wide === rt.NULL; - thin.v = new rt.Cell(a as rt.u32); + let slot: rs.Cell = (undefined as unknown) as rs.Cell; + const thin: rs.Place> = rs.place(() => slot, (value22) => slot = value22); + const wide: rs.Place> = rs.rawUnsizePlace(thin, (p12) => rs.tailDyn(p12, { v: (value23: rs.Cell) => new ofPlace$u32(value23) })); + const null_: boolean = wide === rs.NULL; + thin.v = new rs.Cell(a as rs.u32); wide.v.v.grow$Shape(b); - const area5: rt.u32 = wide.v.v.area$Shape(); - const _677: rt.u32 = slot.v; - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(null_, f), (f: rt.Formatter) => rt.u32Display(area5, f), (f: rt.Formatter) => rt.u32Display(_677, f)]; - put(out, rt.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); - const shown: rt.Fmt = rt.rawUnsize(side, (p13) => rt.fmtOwned(p13, (value: Square.Square, f: rt.Formatter) => Square.fmt$fmt_Debug(value, f))); - const _703: boolean = rt.rawUnsize(rt.NULL, (p14) => new of$dyns_Square(p14)) === rt.NULL; - const args40: rt.Fmt[] = [(f: rt.Formatter) => shown(f), (f: rt.Formatter) => rt.fmtBool(_703, f)]; - put(out, rt.fmtFormat([args40[0], " ", args40[1]])); + const area5: rs.u32 = wide.v.v.area$Shape(); + const _677: rs.u32 = slot.v; + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(null_, f), (f: rs.Formatter) => rs.u32Display(area5, f), (f: rs.Formatter) => rs.u32Display(_677, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", args38[2], " "])); + const shown: rs.Fmt = rs.rawUnsize(side, (p13) => rs.fmtOwned(p13, (value: Square.Square, f: rs.Formatter) => Square.fmt$fmt_Debug(value, f))); + const _703: boolean = rs.rawUnsize(rs.NULL, (p14) => new of$dyns_Square(p14)) === rs.NULL; + const args40: rs.Fmt[] = [(f: rs.Formatter) => shown(f), (f: rs.Formatter) => rs.fmtBool(_703, f)]; + put(out, rs.fmtFormat([args40[0], " ", args40[1]])); owned[Symbol.dispose](); shape[Symbol.dispose](); u[Symbol.dispose](); @@ -2291,22 +2291,22 @@ export function rests(dataData: Uint8Array, dataStart: number, dataLen: number, export class restsFuture$closure0 { #state: number = 0; - #owned0: rt.u8; + #owned0: rs.u8; - constructor(owned0: rt.u8) { + constructor(owned0: rs.u8) { this.#owned0 = owned0; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = this.#owned0; + const _0: rs.Poll = this.#owned0; this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } diff --git a/ts/fixtures/lang/dyns/expected/harness.ts b/ts/fixtures/lang/dyns/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/dyns/expected/harness.ts +++ b/ts/fixtures/lang/dyns/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/dyns/expected/lib.ts b/ts/fixtures/lang/dyns/expected/lib.ts index 36dd00f99..2e4aa84f8 100644 --- a/ts/fixtures/lang/dyns/expected/lib.ts +++ b/ts/fixtures/lang/dyns/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Any from "./core/any.Any.ts"; import { sides$dyns_Shape_u32, intoArea$dyns_Shape_u32, larger$dyns_Shape_u32, tally$dyns_Shape_u32, area$dyns_Shape_u32, grow$dyns_Shape_u32, dyns, shared, asAny$dyns_Erased_u32, asAnyMut$dyns_Erased_u32, key$dyns_Keyed_u32, anys, fns, iters, pointers, boxes, tails, rests } from "./dyns.ts"; import * as Guarded from "./dyns.Guarded.ts"; @@ -21,7 +21,7 @@ export function copy$dyns_Tri(v: Tri.Tri): Tri.Tri { return v; } -export function drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_1: rt.Result, rt.Arc>): void { +export function drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_1: rs.Result, rs.Arc>): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -29,7 +29,7 @@ export function drop$Result_Rc_dyns_Noisy_Rc_dyn_Any(_1: rt.Result, rt.Arc>): void { +export function drop$Result_Rc_dyns_Square_Rc_dyn_Any(_1: rs.Result, rs.Arc>): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -37,7 +37,7 @@ export function drop$Result_Rc_dyns_Square_Rc_dyn_Any(_1: rt.Result, rt.Arc>): void { +export function drop$Result_Rc_dyns_Tri_Rc_dyn_Any(_1: rs.Result, rs.Arc>): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -45,25 +45,25 @@ export function drop$Result_Rc_dyns_Tri_Rc_dyn_Any(_1: rt.Result } } -export function drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_dyns_Square_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_1: rt.Result, rt.BorrowMutError>): void { +export function drop$Result_cell_RefMut_dyns_Tri_cell_BorrowMutError(_1: rs.Result, rs.BorrowMutError>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } } -export function drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_dyn_dyns_Shape_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_sync_Arc_u32_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rt.Result, rt.Arc>): void { +export function drop$Result_sync_Arc_u32_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rs.Result, rs.Arc>): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -71,37 +71,37 @@ export function drop$Result_sync_Arc_u32_sync_Arc_dyn_Any_marker_Sync_marker_Sen } } -export function drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_dyn_dyns_Shape_sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_1.error); } } -export function drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockWriteGuard_dyn_dyns_Shape_sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_1.error); } } -export function drop$Result_tuple2_usize_u32_Rc_dyn_Any(_1: rt.Result<[rt.usize, rt.u32], rt.Arc>): void { +export function drop$Result_tuple2_usize_u32_Rc_dyn_Any(_1: rs.Result<[rs.usize, rs.u32], rs.Arc>): void { if (!_1.ok) { _1.error[Symbol.dispose](); } } -export function drop$Result_tuple2_usize_u8_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rt.Result<[rt.usize, rt.u8], rt.Arc>): void { +export function drop$Result_tuple2_usize_u8_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rs.Result<[rs.usize, rs.u8], rs.Arc>): void { if (!_1.ok) { _1.error[Symbol.dispose](); } } -export function drop$Result_u16_boxed_Box_dyn_Any(_1: rt.Result): void { +export function drop$Result_u16_boxed_Box_dyn_Any(_1: rs.Result): void { if (!_1.ok) { - rt.drop(_1.error); + rs.drop(_1.error); } } @@ -109,18 +109,18 @@ export function drop$boxed_Box_dyns_Guarded_dyn_dyns_Shape(value: Guarded.Guarde drop$dyns_Guarded_dyn_dyns_Shape(value); } -export function drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape(value: rt.RefCell>): void { +export function drop$cell_RefCell_dyns_Guarded_dyn_dyns_Shape(value: rs.RefCell>): void { drop$dyns_Guarded_dyn_dyns_Shape(value.value); } -export function drop$cell_RefCell_dyns_Guarded_dyns_Held(value: rt.RefCell>): void { +export function drop$cell_RefCell_dyns_Guarded_dyns_Held(value: rs.RefCell>): void { drop$dyns_Guarded_dyns_Held(value.value); } export function drop$dyns_Guarded_dyn_dyns_Shape(_1: Guarded.Guarded): void { Guarded.drop$ops_Drop_dyn_dyns_Shape(_1); _1.log[Symbol.dispose](); - rt.drop(_1.value); + rs.drop(_1.value); } export function drop$dyns_Guarded_dyns_Held(_1: Guarded.Guarded): void { @@ -141,15 +141,15 @@ export function drop$dyns_Held(_1: Held.Held): void { } } -export function drop$sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_dyn_dyns_Shape(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockWriteGuard_dyn_dyns_Shape(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refMutRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refMutRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } @@ -159,9 +159,9 @@ export function drop$tuple2_dyns_Tagged_dyns_Tagged(_1: [Tagged.Tagged, Tagged.T } export class of$Option_u8 { - v: rt.u8 | undefined; + v: rs.u8 | undefined; - constructor(v: rt.u8 | undefined) { + constructor(v: rs.u8 | undefined) { this.v = v; } } @@ -173,27 +173,27 @@ export class of$dyns_Hits { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Hits.area$dyns_Shape(this.v); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Hits.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Hits.intoArea$dyns_Shape(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Hits.larger$dyns_Shape(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Hits.sides$dyns_Shape(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Hits.tally$dyns_Shape(this.v, a); } } @@ -205,7 +205,7 @@ export class of$dyns_Lease { this.v = v; } - chunks$Chunks(): rt.Iter { + chunks$Chunks(): rs.Iter { return Lease.chunks$dyns_Chunks(this.v); } } @@ -221,27 +221,27 @@ export class of$dyns_Looped { this.v[Symbol.dispose](); } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Looped.area$dyns_Shape(this.v); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Looped.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Looped.intoArea$dyns_Shape(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Looped.larger$dyns_Shape(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Looped.sides$dyns_Shape(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Looped.tally$dyns_Shape(this.v, a); } } @@ -257,27 +257,27 @@ export class of$dyns_Noisy { this.v[Symbol.dispose](); } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Noisy.area$dyns_Shape(this.v); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Noisy.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Noisy.intoArea$dyns_Shape(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Noisy.larger$dyns_Shape(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Noisy.sides$dyns_Shape(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Noisy.tally$dyns_Shape(this.v, a); } } @@ -289,7 +289,7 @@ export class of$dyns_Square { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Square.area$dyns_Shape(this.v); } @@ -301,19 +301,19 @@ export class of$dyns_Square { return Square.asAnyMut$dyns_Erased(this.v); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Square.fmt$fmt_Debug(this.v, a); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Square.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Square.intoArea$dyns_Shape(this.v); } - key$Keyed(): rt.u32 { + key$Keyed(): rs.u32 { return Square.key$dyns_Keyed(this.v); } @@ -321,15 +321,15 @@ export class of$dyns_Square { return Square.label$dyns_Named(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Square.larger$dyns_Shape(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Square.sides$dyns_Shape(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Square.tally$dyns_Shape(this.v, a); } } @@ -341,7 +341,7 @@ export class of$dyns_Tri { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Tri.area$dyns_Shape(this.v); } @@ -353,15 +353,15 @@ export class of$dyns_Tri { return Tri.asAnyMut$dyns_Erased(this); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Tri.fmt$fmt_Debug(this.v, a); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Tri.grow$dyns_Shape(this, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Tri.intoArea$dyns_Shape(this.v); } @@ -369,15 +369,15 @@ export class of$dyns_Tri { return Tri.label$dyns_Named(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Tri.larger$dyns_Shape(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Tri.sides$dyns_Shape(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Tri.tally$dyns_Shape(this.v, a); } } @@ -391,21 +391,21 @@ export class of$ref_str { } export class of$tuple2_u8_u8 { - v: [rt.u8, rt.u8]; + v: [rs.u8, rs.u8]; - constructor(v: [rt.u8, rt.u8]) { + constructor(v: [rs.u8, rs.u8]) { this.v = v; } } export class of$u32 { - v: rt.u32; + v: rs.u32; - constructor(v: rt.u32) { + constructor(v: rs.u32) { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return area$dyns_Shape_u32(this.v); } @@ -417,35 +417,35 @@ export class of$u32 { return asAnyMut$dyns_Erased_u32(this); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return grow$dyns_Shape_u32(this, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return intoArea$dyns_Shape_u32(this.v); } - key$Keyed(): rt.u32 { + key$Keyed(): rs.u32 { return key$dyns_Keyed_u32(this.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return larger$dyns_Shape_u32(this.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return sides$dyns_Shape_u32(this.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return tally$dyns_Shape_u32(this.v, a); } } export class of$u8 { - v: rt.u8; + v: rs.u8; - constructor(v: rt.u8) { + constructor(v: rs.u8) { this.v = v; } } @@ -459,17 +459,17 @@ export class of$unit { } export class ofPlace$Option_u8 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } export class ofPlace$dyns_Held { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } @@ -477,51 +477,51 @@ export class ofPlace$dyns_Held { drop$dyns_Held(this.v.v); } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Held.area$dyns_Shape(this.v.v); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Held.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Held.intoArea$dyns_Shape(this.v.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Held.larger$dyns_Shape(this.v.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Held.sides$dyns_Shape(this.v.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Held.tally$dyns_Shape(this.v.v, a); } } export class ofPlace$dyns_Tri { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return Tri.area$dyns_Shape(this.v.v); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Tri.fmt$fmt_Debug(this.v.v, a); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return Tri.grow$dyns_Shape(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return Tri.intoArea$dyns_Shape(this.v.v); } @@ -529,27 +529,27 @@ export class ofPlace$dyns_Tri { return Tri.label$dyns_Named(this.v.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return Tri.larger$dyns_Shape(this.v.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return Tri.sides$dyns_Shape(this.v.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return Tri.tally$dyns_Shape(this.v.v, a); } } export class ofPlace$u32 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - area$Shape(): rt.u32 { + area$Shape(): rs.u32 { return area$dyns_Shape_u32(this.v.v); } @@ -561,43 +561,43 @@ export class ofPlace$u32 { return asAnyMut$dyns_Erased_u32(this.v); } - grow$Shape(a: rt.u8): void { + grow$Shape(a: rs.u8): void { return grow$dyns_Shape_u32(this.v, a); } - intoArea$Shape(): rt.u32 { + intoArea$Shape(): rs.u32 { return intoArea$dyns_Shape_u32(this.v.v); } - key$Keyed(): rt.u32 { + key$Keyed(): rs.u32 { return key$dyns_Keyed_u32(this.v.v); } - larger$Shape(a: rt.u32): rt.u32 { + larger$Shape(a: rs.u32): rs.u32 { return larger$dyns_Shape_u32(this.v.v, a); } - sides$Shape(): rt.u8 { + sides$Shape(): rs.u8 { return sides$dyns_Shape_u32(this.v.v); } - tally$Shape(a: rt.Place): void { + tally$Shape(a: rs.Place): void { return tally$dyns_Shape_u32(this.v.v, a); } } export class ofPlace$u8 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } export class ofPlace$unit { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } @@ -606,26 +606,26 @@ export class ofPlace$unit { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["dyns::dyns", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["dyns::dyns", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { dyns(data.data, data.start, data.length, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::shared", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::shared", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { shared(data2.data, data2.start, data2.length, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::anys", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::anys", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { anys(data3.data, data3.start, data3.length, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::fns", (_213: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::fns", (_213: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { fns(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::pointers", (_214: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::pointers", (_214: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { pointers(data5.data, data5.start, data5.length, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::iters", (_215: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::iters", (_215: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { iters(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::boxes", (_216: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::boxes", (_216: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { boxes(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::tails", (_217: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::tails", (_217: rs.u8, data8: rs.ByteSlice, out8: rs.ByteVec): undefined => { tails(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["dyns::rests", (_218: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["dyns::rests", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { rests(data9.data, data9.start, data9.length, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/dyns/src/dyns.rs b/ts/fixtures/lang/dyns/src/dyns.rs index 4264ef209..ec0a99d63 100644 --- a/ts/fixtures/lang/dyns/src/dyns.rs +++ b/ts/fixtures/lang/dyns/src/dyns.rs @@ -46,7 +46,7 @@ pub(crate) trait Shape { fn larger<'a: 'b, 'b>(&'a self, other: &'b u32) -> u32 { self.area().max(*other) } - /// Writes through a `&mut` to a number, which is an `rt.Place`. + /// Writes through a `&mut` to a number, which is an `rs.Place`. fn tally(&self, sum: &mut u32) { *sum = sum.wrapping_add(self.area()); } @@ -402,7 +402,7 @@ pub fn anys(data: &[u8], out: &mut Vec) { } put(out, &format!("{m} ")); - // Of types that can be `undefined`, whose `None` is `rt.None`. + // Of types that can be `undefined`, whose `None` is `rs.None`. let unit: &dyn Any = &(); put( out, diff --git a/ts/fixtures/lang/edits/expected/core/bool.ts b/ts/fixtures/lang/edits/expected/core/bool.ts index 74b84934f..f544192df 100644 --- a/ts/fixtures/lang/edits/expected/core/bool.ts +++ b/ts/fixtures/lang/edits/expected/core/bool.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Tracked from "../edits.Tracked.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/edits/expected/core/option.ts b/ts/fixtures/lang/edits/expected/core/option.ts index 15367f327..fcfeeb6f7 100644 --- a/ts/fixtures/lang/edits/expected/core/option.ts +++ b/ts/fixtures/lang/edits/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Named from "../edits.Named.ts"; export function unwrapOr$039uout(self: Named.Named[] | undefined, default_: Named.Named[]): Named.Named[] { @@ -10,21 +10,21 @@ export function unwrapOr$039uout(self: Named.Named[] | undefined, default_: Name return self; } -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0xa0bn7(self: Named.Named | undefined, f: (a0: Named.Named) => rt.u16): rt.u16 | undefined { +export function map$0igpqq7(self: Named.Named | undefined, f: (a0: Named.Named) => rs.u16): rs.u16 | undefined { if (self === undefined) { return undefined; } @@ -38,14 +38,14 @@ export function map$1u8sh4f(self: Named.Named | undefined, _: (a0: Named.Named) return [self]; } -export function mapOr$14njs1h(self: Named.Named | undefined, default_: rt.u16, f: (a0: Named.Named) => rt.u16): rt.u16 { +export function mapOr$1ifckq6(self: Named.Named | undefined, default_: rs.u16, f: (a0: Named.Named) => rs.u16): rs.u16 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1llunel(self: rt.u16 | undefined, default_: rt.u16, f: (a0: rt.u16) => rt.u16): rt.u16 { +export function mapOr$1wei0sy(self: rs.u16 | undefined, default_: rs.u16, f: (a0: rs.u16) => rs.u16): rs.u16 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/edits/expected/edits.Down.ts b/ts/fixtures/lang/edits/expected/edits.Down.ts index 6714674c2..04298bc3c 100644 --- a/ts/fixtures/lang/edits/expected/edits.Down.ts +++ b/ts/fixtures/lang/edits/expected/edits.Down.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The crate's own iterator, counting down to zero. */ export interface Down { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Down): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Down): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; return self._0; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=edits.Down.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Held.ts b/ts/fixtures/lang/edits/expected/edits.Held.ts index 544e94aec..a75c01a66 100644 --- a/ts/fixtures/lang/edits/expected/edits.Held.ts +++ b/ts/fixtures/lang/edits/expected/edits.Held.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Tracked from "./edits.Tracked.ts"; /** A range that holds what drops, as a splice takes it. */ export class Held { - _0: rt.usize; + _0: rs.usize; _1: Tracked.Tracked; - constructor(_0: rt.usize, _1: Tracked.Tracked) { + constructor(_0: rs.usize, _1: Tracked.Tracked) { this._0 = _0; this._1 = _1; } @@ -18,12 +18,12 @@ export class Held { } } -export function startBound$ops_RangeBounds_usize(self: Held): rt.RangeBound { - return { tag: "Included", _0: self._0 } as rt.RangeBound; +export function startBound$ops_RangeBounds_usize(self: Held): rs.RangeBound { + return { tag: "Included", _0: self._0 } as rs.RangeBound; } -export function endBound$ops_RangeBounds_usize(_self: Held): rt.RangeBound { - return { tag: "Unbounded" } as rt.RangeBound; +export function endBound$ops_RangeBounds_usize(_self: Held): rs.RangeBound { + return { tag: "Unbounded" } as rs.RangeBound; } //# sourceMappingURL=edits.Held.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Hinted.ts b/ts/fixtures/lang/edits/expected/edits.Hinted.ts index 4648f481a..9e5239fbb 100644 --- a/ts/fixtures/lang/edits/expected/edits.Hinted.ts +++ b/ts/fixtures/lang/edits/expected/edits.Hinted.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { then$0p4vbxd } from "./core/bool.ts"; import * as Tracked from "./edits.Tracked.ts"; @@ -9,24 +9,24 @@ import * as Tracked from "./edits.Tracked.ts"; * is one at odd counts while any are left. */ export interface Hinted { - n: rt.u8; - i: rt.u8; - log: rt.RefCell; + n: rs.u8; + i: rs.u8; + log: rs.RefCell; } -export function next$iter_Iterator(self: Hinted): Tracked.Tracked | rt.Done { - const _7: rt.RefCell = self.log; - return rt.iterFromOption(then$0p4vbxd(self.i < self.n, (): Tracked.Tracked => { - self.i = rt.u8Add(self.i, 1); - return new Tracked.Tracked(rt.u8Add(208, self.i), 0, _7); +export function next$iter_Iterator(self: Hinted): Tracked.Tracked | rs.Done { + const _7: rs.RefCell = self.log; + return rs.iterFromOption(then$0p4vbxd(self.i < self.n, (): Tracked.Tracked => { + self.i = rs.u8Add(self.i, 1); + return new Tracked.Tracked(rs.u8Add(208, self.i), 0, _7); })); } -export function sizeHint$iter_Iterator(self: Hinted): [rt.usize, rt.usize | undefined] { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, 213); - rt.refMutRelease(_5); - return [rt.min(rt.u8Rem(self.i, 2), rt.u8Sub(self.n, self.i)) as rt.usize, undefined] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator(self: Hinted): [rs.usize, rs.usize | undefined] { + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, 213); + rs.refMutRelease(_5); + return [rs.min(rs.u8Rem(self.i, 2), rs.u8Sub(self.n, self.i)) as rs.usize, undefined] as [rs.usize, rs.usize | undefined]; } //# sourceMappingURL=edits.Hinted.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Lean.ts b/ts/fixtures/lang/edits/expected/edits.Lean.ts index 72e2a45ed..c3cca2da0 100644 --- a/ts/fixtures/lang/edits/expected/edits.Lean.ts +++ b/ts/fixtures/lang/edits/expected/edits.Lean.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * An order whose `partial_cmp` leans on its first operand, an odd one less than any, and * whose `cmp` is by value, so what `Ord`'s defaults call, with which operand first, shows. */ export interface Lean { - _0: rt.u8; + _0: rs.u8; } -export function partialCmp$cmp_PartialOrd(self: Lean, other: Lean): rt.Ordering | undefined { - if (rt.u8Rem(self._0, 2) === 1) { +export function partialCmp$cmp_PartialOrd(self: Lean, other: Lean): rs.Ordering | undefined { + if (rs.u8Rem(self._0, 2) === 1) { return -1; } - return rt.cmp(self._0, other._0); + return rs.cmp(self._0, other._0); } //# sourceMappingURL=edits.Lean.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Logged.ts b/ts/fixtures/lang/edits/expected/edits.Logged.ts index 1af48be7d..a120c00ea 100644 --- a/ts/fixtures/lang/edits/expected/edits.Logged.ts +++ b/ts/fixtures/lang/edits/expected/edits.Logged.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Logged { return new Logged(0, undefined); @@ -11,10 +11,10 @@ export function default$Default(): Logged { * drops. */ export class Logged { - id: rt.u8; - log: rt.RefCell | undefined; + id: rs.u8; + log: rs.RefCell | undefined; - constructor(id: rt.u8, log: rt.RefCell | undefined) { + constructor(id: rs.u8, log: rs.RefCell | undefined) { this.id = id; this.log = log; } @@ -26,9 +26,9 @@ export class Logged { export function drop$ops_Drop(self: Logged): void { if (self.log !== undefined) { - const _7: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_7.value, self.id); - rt.refMutRelease(_7); + const _7: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_7.value, self.id); + rs.refMutRelease(_7); } } diff --git a/ts/fixtures/lang/edits/expected/edits.Named.ts b/ts/fixtures/lang/edits/expected/edits.Named.ts index 078d926c6..d989f5ebf 100644 --- a/ts/fixtures/lang/edits/expected/edits.Named.ts +++ b/ts/fixtures/lang/edits/expected/edits.Named.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Named): Named { return { id: self.id, name: self.name }; @@ -13,11 +13,11 @@ export function eq$cmp_PartialEq(self: Named, other: Named): boolean { return self.name === other.name; } -export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rt.Ordering | undefined { - const cmp: rt.Ordering | undefined = rt.cmp(self.id, other.id); +export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rs.Ordering | undefined { + const cmp: rs.Ordering | undefined = rs.cmp(self.id, other.id); if (cmp !== undefined) { if (cmp === 0) { - return rt.cmpStr(self.name, other.name); + return rs.cmpStr(self.name, other.name); } } return cmp; @@ -25,7 +25,7 @@ export function partialCmp$cmp_PartialOrd(self: Named, other: Named): rt.Orderin /** An element that is not `Copy`, cloned and compared field by field. */ export interface Named { - id: rt.u16; + id: rs.u16; name: string; } diff --git a/ts/fixtures/lang/edits/expected/edits.Stamp.ts b/ts/fixtures/lang/edits/expected/edits.Stamp.ts index 53b799b3d..78fea3dca 100644 --- a/ts/fixtures/lang/edits/expected/edits.Stamp.ts +++ b/ts/fixtures/lang/edits/expected/edits.Stamp.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function partialCmp$cmp_PartialOrd(self: Stamp, other: Stamp): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Stamp, other: Stamp): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Stamp, other: Stamp): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Stamp, other: Stamp): rs.Ordering { + return rs.cmp(self._0, other._0); } /** The crate's own order, whose `min`, `max`, and `clamp` are `Ord`'s defaults. */ export interface Stamp { - _0: rt.u8; + _0: rs.u8; } //# sourceMappingURL=edits.Stamp.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Tally.ts b/ts/fixtures/lang/edits/expected/edits.Tally.ts index 50b840940..28df292eb 100644 --- a/ts/fixtures/lang/edits/expected/edits.Tally.ts +++ b/ts/fixtures/lang/edits/expected/edits.Tally.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What `mem::take` leaves its own `Default` in place of. */ export interface Tally { - n: rt.u8; - names: rt.Vec; + n: rs.u8; + names: rs.Vec; } export function default$Default(): Tally { - return { n: 7, names: rt.vecFrom(["fresh"]) }; + return { n: 7, names: rs.vecFrom(["fresh"]) }; } //# sourceMappingURL=edits.Tally.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Tracked.ts b/ts/fixtures/lang/edits/expected/edits.Tracked.ts index 24150e485..57399a82a 100644 --- a/ts/fixtures/lang/edits/expected/edits.Tracked.ts +++ b/ts/fixtures/lang/edits/expected/edits.Tracked.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs `0xcc` and its id as it clones, and its id and how many clones from the first it is * as it drops, so which of a vector's values are clones, and when each drops, shows. */ export class Tracked { - id: rt.u8; - copies: rt.u8; - log: rt.RefCell; + id: rs.u8; + copies: rs.u8; + log: rs.RefCell; - constructor(id: rt.u8, copies: rt.u8, log: rt.RefCell) { + constructor(id: rs.u8, copies: rs.u8, log: rs.RefCell) { this.id = id; this.copies = copies; this.log = log; @@ -23,20 +23,20 @@ export class Tracked { } export function clone$Clone(self: Tracked): Tracked { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.iterExtendBytes(_5.value, rt.iterSlice(Uint8Array.of(204, self.id)), undefined, true); - rt.refMutRelease(_5); - return new Tracked(self.id, rt.u8Add(self.copies, 1), self.log); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.iterExtendBytes(_5.value, rs.iterSlice(Uint8Array.of(204, self.id)), undefined, true); + rs.refMutRelease(_5); + return new Tracked(self.id, rs.u8Add(self.copies, 1), self.log); } export function drop$ops_Drop(self: Tracked): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.iterExtendBytes(_5.value, rt.iterSlice(Uint8Array.of(self.id, self.copies)), undefined, true); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.iterExtendBytes(_5.value, rs.iterSlice(Uint8Array.of(self.id, self.copies)), undefined, true); + rs.refMutRelease(_5); } -export function cmp$cmp_Ord(self: Tracked, other: Tracked): rt.Ordering { - return rt.cmp(self.id, other.id); +export function cmp$cmp_Ord(self: Tracked, other: Tracked): rs.Ordering { + return rs.cmp(self.id, other.id); } //# sourceMappingURL=edits.Tracked.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.Units.ts b/ts/fixtures/lang/edits/expected/edits.Units.ts index e6e9f8d85..3d7797f2b 100644 --- a/ts/fixtures/lang/edits/expected/edits.Units.ts +++ b/ts/fixtures/lang/edits/expected/edits.Units.ts @@ -1,30 +1,30 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `n` units, logging each `size_hint` read of them, whose lower bound is none. */ export interface Units { - n: rt.u8; - log: rt.RefCell; + n: rs.u8; + log: rs.RefCell; } -export function next$iter_Iterator(self: Units): undefined | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self.n, 1); +export function next$iter_Iterator(self: Units): undefined | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self.n, 1); if (_2 !== undefined) { self.n = _2; - const _10: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_10.value, self.n); - rt.refMutRelease(_10); + const _10: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_10.value, self.n); + rs.refMutRelease(_10); return undefined; } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator(self: Units): [rt.usize, rt.usize | undefined] { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, 213); - rt.refMutRelease(_5); - return [0, undefined] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator(self: Units): [rs.usize, rs.usize | undefined] { + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, 213); + rs.refMutRelease(_5); + return [0, undefined] as [rs.usize, rs.usize | undefined]; } //# sourceMappingURL=edits.Units.ts.map diff --git a/ts/fixtures/lang/edits/expected/edits.ts b/ts/fixtures/lang/edits/expected/edits.ts index 9953272d8..910ad37b3 100644 --- a/ts/fixtures/lang/edits/expected/edits.ts +++ b/ts/fixtures/lang/edits/expected/edits.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_array2_u16, copy$array_u16, copy$array_u8, copy$tuple2_u8_u16 } from "./lib.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$039uout as option_unwrapOr$039uout, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0xa0bn7 as option_map$0xa0bn7, map$1u8sh4f as option_map$1u8sh4f, mapOr$14njs1h as option_mapOr$14njs1h, mapOr$1llunel as option_mapOr$1llunel, filter$184yuq2, clone$0vcwlo5 as option_clone$0vcwlo5 } from "./core/option.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$039uout as option_unwrapOr$039uout, unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0igpqq7 as option_map$0igpqq7, map$1u8sh4f as option_map$1u8sh4f, mapOr$1ifckq6 as option_mapOr$1ifckq6, mapOr$1wei0sy as option_mapOr$1wei0sy, filter$184yuq2, clone$0vcwlo5 as option_clone$0vcwlo5 } from "./core/option.ts"; import * as Down from "./edits.Down.ts"; import * as Held from "./edits.Held.ts"; import * as Hinted from "./edits.Hinted.ts"; @@ -26,64 +26,64 @@ export function optional$edits_Named(n: Named.Named): Named.Named | undefined { return n; } -export function putU16s(out: rt.ByteVec, v: rt.u16[]): void { +export function putU16s(out: rs.ByteVec, v: rs.u16[]): void { for (const _5 of v) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_5))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_5))); } - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } -export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _104: (a0: rt.u16) => Named.Named = (w: rt.u16): Named.Named => { - return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8Div(w & 0xff, 16)))) }; +export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _104: (a0: rs.u16) => Named.Named = (w: rs.u16): Named.Named => { + return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8Div(w & 0xff, 16)))) }; }; - const _604: (a0: rt.u16) => Named.Named = (w2: rt.u16): Named.Named => { - return { id: w2, name: text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + const _604: (a0: rs.u16) => Named.Named = (w2: rs.u16): Named.Named => { + return { id: w2, name: text(rs.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; }; - const _605: (a0: Named.Named[]) => rt.Vec = (v8: Named.Named[]): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(v8), (n: Named.Named): rt.u16 => { + const _605: (a0: Named.Named[]) => rs.Vec = (v8: Named.Named[]): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(v8), (n: Named.Named): rs.u16 => { return n.id; }), undefined, 2, true); }; - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 3); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 3); }), undefined, 2, true); - const at: (a0: rt.usize) => rt.u8 = (i3: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i3), 0); + const at: (a0: rs.usize) => rs.u8 = (i3: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), 0); }; - const _8: rt.u8 = rt.u8Rem(kind, 8); + const _8: rs.u8 = rs.u8Rem(kind, 8); if (_8 === 0) { - const v: rt.Vec = rt.vecFrom(words.items.slice()); - const seen: rt.Vec = new rt.Vec(); - rt.vecRetain(v, (_227: rt.u16): boolean => { - const x4: rt.u16 = _227; + const v: rs.Vec = rs.vecFrom(words.items.slice()); + const seen: rs.Vec = new rs.Vec(); + rs.vecRetain(v, (_227: rs.u16): boolean => { + const x4: rs.u16 = _227; seen.items.push(x4); - return rt.u16Rem(x4, 4) !== 0; + return rs.u16Rem(x4, 4) !== 0; }); putU16s(out, seen.items); putU16s(out, v.items); - const pairs: rt.Vec<[rt.u16, rt.u16]> = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_229: rt.u16): [rt.u16, rt.u16] => { - return [_229, 0] as [rt.u16, rt.u16]; + const pairs: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_229: rs.u16): [rs.u16, rs.u16] => { + return [_229, 0] as [rs.u16, rs.u16]; }), undefined, 4, true); - rt.vecRetain(pairs, (p3: [rt.u16, rt.u16]): boolean => { - p3[1] = rt.u16Div(p3[0], 2); - return rt.u16Rem(p3[0], 3) === 0; + rs.vecRetain(pairs, (p3: [rs.u16, rs.u16]): boolean => { + p3[1] = rs.u16Div(p3[0], 2); + return rs.u16Rem(p3[0], 3) === 0; }); for (const _33 of pairs.items) { putU16s(out, [_33[0], _33[1]]); } - const names: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_233: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_233))); + const names: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_233: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(_233))); }), undefined, 12, true); - rt.vecRetain(names, (s3: string): boolean => { - return rt.stringLen(s3) > 1; + rs.vecRetain(names, (s3: string): boolean => { + return rs.stringLen(s3) > 1; }); - rt.byteVecPush(out, names.items.length & 0xff); - const v2: rt.Vec = rt.vecFrom(words.items.slice()); + rs.byteVecPush(out, names.items.length & 0xff); + const v2: rs.Vec = rs.vecFrom(words.items.slice()); while (true) { - const _55: rt.u16 | undefined = rt.vecPopIfMut(v2, (x5: rt.Place): boolean => { + const _55: rs.u16 | undefined = rs.vecPopIfMut(v2, (x5: rs.Place): boolean => { x5.v = x5.v ^ 1; - return rt.u16Rem(x5.v, 4) !== 0; + return rs.u16Rem(x5.v, 4) !== 0; }); if (_55 !== undefined) { putU16s(out, [_55]); @@ -93,9 +93,9 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } putU16s(out, v2.items); while (true) { - const _66: string | undefined = rt.vecPopIfMut(names, (s4: rt.Place): boolean => { + const _66: string | undefined = rs.vecPopIfMut(names, (s4: rs.Place): boolean => { s4.v = s4.v + "."; - return rt.usizeRem(rt.stringLen(s4.v), 3) !== 0; + return rs.usizeRem(rs.stringLen(s4.v), 3) !== 0; }); if (_66 !== undefined) { put(out, _66); @@ -106,38 +106,38 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { for (const _76 of names.items) { put(out, _76); } - const part8 = rt.usizeSaturatingSub(data.length, 1); - const stop: rt.u16 = rt.u16Mul(at(part8) as rt.u16, 3); + const part8 = rs.usizeSaturatingSub(data.length, 1); + const stop: rs.u16 = rs.u16Mul(at(part8) as rs.u16, 3); if ((kind & 128) !== 0) { - rt.vecRetain(v2, (_237: rt.u16): boolean => { - const x6: rt.u16 = _237; + rs.vecRetain(v2, (_237: rs.u16): boolean => { + const x6: rs.u16 = _237; if (!(x6 === stop)) { return true; } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(x6, f)]; - rt.panicFmt(["retain stopped at ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(x6, f)]; + rs.panicFmt(["retain stopped at ", args4[0]]); }); } } else if (_8 === 1) { - const v3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_223: rt.u8): rt.u16 => { - return rt.u8Rem(_223, 4) as rt.u16; + const v3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): rs.u16 => { + return rs.u8Rem(_223, 4) as rs.u16; }), undefined, 2, true); - rt.vecDedupBy(v3, rt.same); + rs.vecDedupBy(v3, rs.same); putU16s(out, v3.items); - const keyed: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_224: rt.u16): Named.Named => { + const keyed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_224: rs.u16): Named.Named => { return _104(_224); }), undefined, 16, true); - rt.vecDedupByKey(keyed, (n3: Named.Named): rt.u16 => { - return rt.u16Div(n3.id, 24); - }, rt.same); + rs.vecDedupByKey(keyed, (n3: Named.Named): rs.u16 => { + return rs.u16Div(n3.id, 24); + }, rs.same); for (const _117 of keyed.items) { putU16s(out, [_117.id]); } - const tested: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_225: rt.u16): Named.Named => { + const tested: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): Named.Named => { return _104(_225); }), undefined, 16, true); - const seen2: rt.Vec = new rt.Vec(); - rt.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { + const seen2: rs.Vec = new rs.Vec(); + rs.vecDedupBy(tested, (a3: Named.Named, b10: Named.Named): boolean => { seen2.items.push(a3.id); seen2.items.push(b10.id); return a3.name === b10.name; @@ -146,461 +146,461 @@ export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { for (const _144 of tested.items) { put(out, _144.name); } - const names2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_226, 3)))); + const names2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_226, 3)))); }), undefined, 12, true); - rt.vecDedupBy(names2, rt.same); - rt.byteVecPush(out, names2.items.length & 0xff); + rs.vecDedupBy(names2, rs.same); + rs.byteVecPush(out, names2.items.length & 0xff); } else if (_8 === 2) { - const v4: rt.Vec = rt.vecFrom(words.items.slice()); - rt.sliceSort(v4.items, rt.lt, 2, true); + const v4: rs.Vec = rs.vecFrom(words.items.slice()); + rs.sliceSort(v4.items, rs.lt, 2, true); putU16s(out, v4.items); - const v5: rt.Vec = rt.vecFrom(words.items.slice()); - rt.sliceSortUnstable(v5.items, rt.cmpLt((a: rt.u16, b6: rt.u16): rt.Ordering => { - return rt.cmp(b6, a); + const v5: rs.Vec = rs.vecFrom(words.items.slice()); + rs.sliceSortUnstable(v5.items, rs.cmpLt((a: rs.u16, b6: rs.u16): rs.Ordering => { + return rs.cmp(b6, a); }), 2, true, true); putU16s(out, v5.items); - const pairs2: rt.Vec<[rt.u16, rt.u16]> = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(words.items)), (_216: [rt.usize, rt.u16]): [rt.u16, rt.u16] => { - return [rt.u16Rem(_216[1], 5), _216[0] & 0xffff] as [rt.u16, rt.u16]; + const pairs2: rs.Vec<[rs.u16, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(words.items)), (_216: [rs.usize, rs.u16]): [rs.u16, rs.u16] => { + return [rs.u16Rem(_216[1], 5), _216[0] & 0xffff] as [rs.u16, rs.u16]; }), undefined, 4, true); - rt.sliceSort(pairs2.items, rt.keyLt((p2: [rt.u16, rt.u16]): rt.u16 => { + rs.sliceSort(pairs2.items, rs.keyLt((p2: [rs.u16, rs.u16]): rs.u16 => { return p2[0]; - }, rt.lt), 4, true); + }, rs.lt), 4, true); for (const _188 of pairs2.items) { putU16s(out, [_188[0], _188[1]]); } - rt.sliceSortUnstable(pairs2.items, rt.keyLt((_218: [rt.u16, rt.u16]): [rt.u16, rt.u16, rt.u16] => { - const a2: rt.u16 = _218[0]; - const b7: rt.u16 = _218[1]; - return [rt.u16Rem(b7, 3), a2, b7] as [rt.u16, rt.u16, rt.u16]; - }, rt.cmpLt(rt.cmpTuple<[rt.u16, rt.u16, rt.u16], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))), 4, true, true); + rs.sliceSortUnstable(pairs2.items, rs.keyLt((_218: [rs.u16, rs.u16]): [rs.u16, rs.u16, rs.u16] => { + const a2: rs.u16 = _218[0]; + const b7: rs.u16 = _218[1]; + return [rs.u16Rem(b7, 3), a2, b7] as [rs.u16, rs.u16, rs.u16]; + }, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.u16, rs.u16], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))), 4, true, true); for (const _205 of pairs2.items) { putU16s(out, [_205[0], _205[1]]); } - rt.sliceSort(pairs2.items, rt.cmpLt((x3: [rt.u16, rt.u16], y: [rt.u16, rt.u16]): rt.Ordering => { - return rt.cmp(y[1], x3[1]); + rs.sliceSort(pairs2.items, rs.cmpLt((x3: [rs.u16, rs.u16], y: [rs.u16, rs.u16]): rs.Ordering => { + return rs.cmp(y[1], x3[1]); }), 4, true); for (const _222 of pairs2.items) { putU16s(out, [_222[0], _222[1]]); } - const options: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_220: rt.u16): rt.u16 | undefined => { - const w8: rt.u16 = _220; - if (!(rt.u16Rem(w8, 2) === 0)) { + const options: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_220: rs.u16): rs.u16 | undefined => { + const w8: rs.u16 = _220; + if (!(rs.u16Rem(w8, 2) === 0)) { return w8; } return undefined; }), undefined, 4, true); - rt.sliceSortUnstable(options.items, rt.cmpLt(rt.cmpOption(rt.cmp)), 4, true, true); + rs.sliceSortUnstable(options.items, rs.cmpLt(rs.cmpOption(rs.cmp)), 4, true, true); for (const _244 of options.items) { - putU16s(out, [option_mapOr$1llunel(_244, 65535, (o: rt.u16): rt.u16 => { + putU16s(out, [option_mapOr$1wei0sy(_244, 65535, (o: rs.u16): rs.u16 => { return o; })]); } - const names3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_221: rt.u8): string => { - const b8: rt.u8 = _221; - return text(rt.byteSliceFrom(Uint8Array.of(b8, rt.u8Div(b8, 16)))); + const names3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_221: rs.u8): string => { + const b8: rs.u8 = _221; + return text(rs.byteSliceFrom(Uint8Array.of(b8, rs.u8Div(b8, 16)))); }), undefined, 12, true); - rt.sliceSort(names3.items, rt.cmpLt(rt.cmpStr), 12, true); + rs.sliceSort(names3.items, rs.cmpLt(rs.cmpStr), 12, true); for (const _263 of names3.items) { put(out, _263); } } else if (_8 === 3) { - const v6: rt.Vec = rt.vecFrom(words.items.slice()); - putU16s(out, [option_unwrapOr$1j4op5y(rt.sliceLast(v6.items), 65535)]); - const runs: rt.Vec<[rt.u16, rt.u16 | undefined]> = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_210: rt.u16): [rt.u16, rt.u16 | undefined] => { - return [_210, undefined] as [rt.u16, rt.u16 | undefined]; + const v6: rs.Vec = rs.vecFrom(words.items.slice()); + putU16s(out, [option_unwrapOr$1szdyfq(rs.sliceLast(v6.items), 65535)]); + const runs: rs.Vec<[rs.u16, rs.u16 | undefined]> = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_210: rs.u16): [rs.u16, rs.u16 | undefined] => { + return [_210, undefined] as [rs.u16, rs.u16 | undefined]; }), undefined, 6, true); - const _285: [rt.u16, rt.u16 | undefined] | undefined = rt.sliceLast(runs.items); + const _285: [rs.u16, rs.u16 | undefined] | undefined = rs.sliceLast(runs.items); if (_285 !== undefined) { _285[1] = _285[0]; } - const _292: [rt.u16, rt.u16 | undefined] | undefined = rt.sliceFirst(runs.items); + const _292: [rs.u16, rs.u16 | undefined] | undefined = rs.sliceFirst(runs.items); if (_292 !== undefined) { - _292[0] = rt.u16Add(_292[0], 1); + _292[0] = rs.u16Add(_292[0], 1); } for (const _301 of runs.items) { - putU16s(out, [_301[0], option_unwrapOr$1j4op5y(_301[1], 65535)]); + putU16s(out, [_301[0], option_unwrapOr$1szdyfq(_301[1], 65535)]); } v6.items.reverse(); putU16s(out, v6.items); - const named: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_212: rt.u16): Named.Named => { - const w6: rt.u16 = _212; - return { id: w6, name: text(rt.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; + const named: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_212: rs.u16): Named.Named => { + const w6: rs.u16 = _212; + return { id: w6, name: text(rs.byteSliceFrom(Uint8Array.of(w6 & 0xff))) }; }), undefined, 16, true); - const probe: Named.Named = { id: rt.u16Mul(at(1) as rt.u16, 3), name: text(rt.byteSliceFrom(Uint8Array.of(rt.u8WrappingMul(at(1), 3)))) }; - rt.byteVecPush(out, rt.sliceContains(named.items, probe, Named.eq$cmp_PartialEq) ? 1 : 0); - rt.byteVecPush(out, rt.sliceContains(words.items, rt.u16Mul(at(2) as rt.u16, 3), rt.same) ? 1 : 0); - const _361: rt.u8 = at(3); - rt.byteVecPush(out, rt.byteSliceView(data).includes(_361) ? 1 : 0); - const _366: [rt.usize, rt.usize] = [rt.usizeRem(at(0) as rt.usize, 8), rt.usizeRem(at(1) as rt.usize, 8)]; - const i: rt.usize = _366[0]; - const j: rt.usize = _366[1]; - const moved: rt.Vec = rt.vecFrom(words.items.slice()); - putU16s(out, [rt.vecSwapRemove(moved, i)]); + const probe: Named.Named = { id: rs.u16Mul(at(1) as rs.u16, 3), name: text(rs.byteSliceFrom(Uint8Array.of(rs.u8WrappingMul(at(1), 3)))) }; + rs.byteVecPush(out, rs.sliceContains(named.items, probe, Named.eq$cmp_PartialEq) ? 1 : 0); + rs.byteVecPush(out, rs.sliceContains(words.items, rs.u16Mul(at(2) as rs.u16, 3), rs.same) ? 1 : 0); + const _361: rs.u8 = at(3); + rs.byteVecPush(out, rs.byteSliceView(data).includes(_361) ? 1 : 0); + const _366: [rs.usize, rs.usize] = [rs.usizeRem(at(0) as rs.usize, 8), rs.usizeRem(at(1) as rs.usize, 8)]; + const i: rs.usize = _366[0]; + const j: rs.usize = _366[1]; + const moved: rs.Vec = rs.vecFrom(words.items.slice()); + putU16s(out, [rs.vecSwapRemove(moved, i)]); putU16s(out, moved.items); - rt.sliceSwap(moved.items, i, j); + rs.sliceSwap(moved.items, i, j); putU16s(out, moved.items); } else if (_8 === 4) { - const named2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_28: rt.u16): Named.Named => { - const w4: rt.u16 = _28; - return { id: w4, name: text(rt.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; + const named2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_28: rs.u16): Named.Named => { + const w4: rs.u16 = _28; + return { id: w4, name: text(rs.byteSliceFrom(Uint8Array.of(w4 & 0xff))) }; }), undefined, 16, true); - const cloned: rt.Vec = rt.vecFrom(named2.items.map(Named.clone$Clone)); - rt.byteVecPush(out, rt.eqSlice(Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); - const changed: rt.Vec = rt.vecFrom(named2.items.map(Named.clone$Clone)); - const _411: Named.Named | undefined = rt.sliceFirst(changed.items); + const cloned: rs.Vec = rs.vecFrom(named2.items.map(Named.clone$Clone)); + rs.byteVecPush(out, rs.eqSlice(Named.eq$cmp_PartialEq)(cloned, named2) ? 1 : 0); + const changed: rs.Vec = rs.vecFrom(named2.items.map(Named.clone$Clone)); + const _411: Named.Named | undefined = rs.sliceFirst(changed.items); if (_411 !== undefined) { _411.name = _411.name + "!"; } - rt.byteVecPush(out, rt.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); - rt.byteVecPush(out, !rt.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); - rt.byteVecPush(out, rt.cmpSlice(Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); - const _435: Named.Named[] = rt.sliceRange(named2.items, 0, rt.usizeDiv(named2.items.length, 2)); - rt.vecExtendFromSlice(changed, _435, 16, Named.clone$Clone); - rt.byteVecPush(out, changed.items.length & 0xff); - const nested: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.Vec => { - const b5: rt.u8 = _29; - return rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(b5, 3)), (i4: rt.u8): rt.u16 => { - return rt.u16Add(i4 as rt.u16, b5 as rt.u16); + rs.byteVecPush(out, rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); + rs.byteVecPush(out, !rs.eqSlice(Named.eq$cmp_PartialEq)(changed, named2) ? 1 : 0); + rs.byteVecPush(out, rs.cmpSlice(Named.partialCmp$cmp_PartialOrd)(changed, named2) === -1 ? 1 : 0); + const _435: Named.Named[] = rs.sliceRange(named2.items, 0, rs.usizeDiv(named2.items.length, 2)); + rs.vecExtendFromSlice(changed, _435, 16, Named.clone$Clone); + rs.byteVecPush(out, changed.items.length & 0xff); + const nested: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.Vec => { + const b5: rs.u8 = _29; + return rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(b5, 3)), (i4: rs.u8): rs.u16 => { + return rs.u16Add(i4 as rs.u16, b5 as rs.u16); }), undefined, 2, true); }), undefined, 12, true); - const _453: rt.Vec> = rt.vecFrom(nested.items.map((a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.slice()); + const _453: rs.Vec> = rs.vecFrom(nested.items.map((a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.slice()); })); - rt.byteVecPush(out, rt.eqSlice(rt.eqSlice(rt.same))(_453, nested) ? 1 : 0); - const pair: [string, rt.u8] = [text(data), at(0)]; - const copy: [string, rt.u8] = rt.tupleClone(pair, [undefined, undefined]); + rs.byteVecPush(out, rs.eqSlice(rs.eqSlice(rs.same))(_453, nested) ? 1 : 0); + const pair: [string, rs.u8] = [text(data), at(0)]; + const copy: [string, rs.u8] = rs.tupleClone(pair, [undefined, undefined]); put(out, copy[0]); - const _470: [rt.u8, string] = [copy[1], copy[0]]; - const _474: [rt.u8, string] = [at(1), pair[0]]; - rt.byteVecPush(out, rt.cmpTuple<[rt.u8, string], rt.Ordering | undefined>([rt.cmp, rt.cmpStr])(_470, _474) === 1 ? 1 : 0); - const _483: [rt.u8, rt.u8] = [at(0), at(1)]; - const _491: [rt.u8, rt.u8] = [at(1), at(0)]; - rt.byteVecPush(out, rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])(_483, _491) === -1 ? 1 : 0); - const grown: rt.Vec = rt.vecFrom(words.items.slice()); - rt.vecExtendFromSlice(grown, words.items, 2); + const _470: [rs.u8, string] = [copy[1], copy[0]]; + const _474: [rs.u8, string] = [at(1), pair[0]]; + rs.byteVecPush(out, rs.cmpTuple<[rs.u8, string], rs.Ordering | undefined>([rs.cmp, rs.cmpStr])(_470, _474) === 1 ? 1 : 0); + const _483: [rs.u8, rs.u8] = [at(0), at(1)]; + const _491: [rs.u8, rs.u8] = [at(1), at(0)]; + rs.byteVecPush(out, rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])(_483, _491) === -1 ? 1 : 0); + const grown: rs.Vec = rs.vecFrom(words.items.slice()); + rs.vecExtendFromSlice(grown, words.items, 2); putU16s(out, grown.items); } else if (_8 === 5) { - let tally: Tally.Tally = { n: at(0), names: rt.vecFrom([text(data)]) }; + let tally: Tally.Tally = { n: at(0), names: rs.vecFrom([text(data)]) }; const default_ = Tally.default$Default(); const taken3 = tally; tally = default_; - rt.byteVecPush(out, taken3.n); - rt.byteVecPush(out, tally.n); - put(out, tally.names.items[rt.idx(tally.names.items, 0)]); - let queue: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(words.items), undefined, 2, true), 2) as rt.VecDeque; - const default_2 = rt.dequeNew(2) as rt.VecDeque; + rs.byteVecPush(out, taken3.n); + rs.byteVecPush(out, tally.n); + put(out, tally.names.items[rs.idx(tally.names.items, 0)]); + let queue: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(words.items), undefined, 2, true), 2) as rs.VecDeque; + const default_2 = rs.dequeNew(2) as rs.VecDeque; const taken4 = queue; queue = default_2; - rt.byteVecPush(out, taken4.n & 0xff); - rt.byteVecPush(out, queue.n & 0xff); - const _540: rt.Iter = rt.iterSlice(words.items); - let set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _540, true, undefined, undefined, 2, true); - const default_3 = rt.btreeNew(rt.cmp) as rt.BTreeSet; + rs.byteVecPush(out, taken4.n & 0xff); + rs.byteVecPush(out, queue.n & 0xff); + const _540: rs.Iter = rs.iterSlice(words.items); + let set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _540, true, undefined, undefined, 2, true); + const default_3 = rs.btreeNew(rs.cmp) as rs.BTreeSet; const taken5 = set; set = default_3; - rt.byteVecPush(out, rt.btreeLen(taken5) & 0xff); - rt.byteVecPush(out, rt.btreeLen(set) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.btreeLen(taken5) & 0xff); + rs.byteVecPush(out, rs.btreeLen(set) === 0 ? 1 : 0); const _557: [Stamp.Stamp, Stamp.Stamp, Stamp.Stamp] = [{ _0: at(0) }, { _0: at(1) }, { _0: at(2) }]; const x2: Stamp.Stamp = _557[0]; const lo: Stamp.Stamp = _557[1]; const hi: Stamp.Stamp = _557[2]; - rt.byteVecPush(out, rt.ordMax(x2, lo, rt.cmpLt(Stamp.partialCmp$cmp_PartialOrd))._0); - rt.byteVecPush(out, rt.ordMin(x2, lo, rt.cmpLt(Stamp.partialCmp$cmp_PartialOrd))._0); - rt.byteVecPush(out, rt.ordClamp(x2, lo, hi, rt.cmpLe(Stamp.partialCmp$cmp_PartialOrd), rt.cmpLt(Stamp.partialCmp$cmp_PartialOrd), rt.cmpGt(Stamp.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordMax(x2, lo, rs.cmpLt(Stamp.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordMin(x2, lo, rs.cmpLt(Stamp.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordClamp(x2, lo, hi, rs.cmpLe(Stamp.partialCmp$cmp_PartialOrd), rs.cmpLt(Stamp.partialCmp$cmp_PartialOrd), rs.cmpGt(Stamp.partialCmp$cmp_PartialOrd))._0); const _582: [Lean.Lean, Lean.Lean, Lean.Lean] = [{ _0: at(0) }, { _0: at(1) }, { _0: at(2) }]; const p: Lean.Lean = _582[0]; const q: Lean.Lean = _582[1]; const r: Lean.Lean = _582[2]; - rt.byteVecPush(out, rt.ordMax(p, q, rt.cmpLt(Lean.partialCmp$cmp_PartialOrd))._0); - rt.byteVecPush(out, rt.ordMin(p, q, rt.cmpLt(Lean.partialCmp$cmp_PartialOrd))._0); - rt.byteVecPush(out, rt.ordClamp(p, q, r, rt.cmpLe(Lean.partialCmp$cmp_PartialOrd), rt.cmpLt(Lean.partialCmp$cmp_PartialOrd), rt.cmpGt(Lean.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordMax(p, q, rs.cmpLt(Lean.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordMin(p, q, rs.cmpLt(Lean.partialCmp$cmp_PartialOrd))._0); + rs.byteVecPush(out, rs.ordClamp(p, q, r, rs.cmpLe(Lean.partialCmp$cmp_PartialOrd), rs.cmpLt(Lean.partialCmp$cmp_PartialOrd), rs.cmpGt(Lean.partialCmp$cmp_PartialOrd))._0); } else if (_8 === 6) { - const v7: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (_23: rt.u16): Named.Named => { + const v7: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (_23: rs.u16): Named.Named => { return _604(_23); }), undefined, 16, true); - const _615: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); + const _615: rs.usize = rs.usizeRem(at(0) as rs.usize, 8); const _621: Named.Named = _604(511); - rt.vecInsert(v7, _615, _621); + rs.vecInsert(v7, _615, _621); putU16s(out, _605(v7.items).items); - const _634: rt.usize = rt.usizeRem(at(1) as rt.usize, 8); - const removed: Named.Named = rt.vecRemove(v7, _634); + const _634: rs.usize = rs.usizeRem(at(1) as rs.usize, 8); + const removed: Named.Named = rs.vecRemove(v7, _634); putU16s(out, [removed.id]); - const kept: rt.Vec = rt.vecFrom(v7.items.map(Named.clone$Clone)); - const _649: rt.usize = rt.usizeRem(at(2) as rt.usize, 4); - rt.vecTruncate(v7, _649); + const kept: rs.Vec = rs.vecFrom(v7.items.map(Named.clone$Clone)); + const _649: rs.usize = rs.usizeRem(at(2) as rs.usize, 4); + rs.vecTruncate(v7, _649); putU16s(out, _605(v7.items).items); - rt.vecTruncate(v7, 0); - rt.byteVecPush(out, v7.items.length === 0 ? 1 : 0); + rs.vecTruncate(v7, 0); + rs.byteVecPush(out, v7.items.length === 0 ? 1 : 0); const boxed: Named.Named = removed; const copy2: Named.Named = Named.clone$Clone(boxed); copy2.name = copy2.name + "!"; put(out, boxed.name); put(out, copy2.name); const held: Named.Named | undefined = filter$184yuq2(boxed, (_27: Named.Named): boolean => { - return rt.u8Rem(at(3), 2) === 0; + return rs.u8Rem(at(3), 2) === 0; }); - rt.byteVecPush(out, option_map$0xa0bn7(option_clone$0vcwlo5(held), (b3: Named.Named): rt.u16 => { + rs.byteVecPush(out, option_map$0igpqq7(option_clone$0vcwlo5(held), (b3: Named.Named): rs.u16 => { return b3.id; - }) === option_map$0xa0bn7(held, (b4: Named.Named): rt.u16 => { + }) === option_map$0igpqq7(held, (b4: Named.Named): rs.u16 => { return b4.id; }) ? 1 : 0); - const some: rt.Vec | undefined = rt.vecFrom(kept.items.map(Named.clone$Clone)); - const _701: rt.Vec | undefined = rt.vecFrom(kept.items.map(Named.clone$Clone)); - rt.byteVecPush(out, rt.eqOption(rt.eqSlice(Named.eq$cmp_PartialEq))(some, _701) ? 1 : 0); - rt.byteVecPush(out, rt.eqOption(rt.eqSlice(Named.eq$cmp_PartialEq))(some, undefined) ? 1 : 0); - const _714: rt.Vec | undefined = new rt.Vec(); - rt.byteVecPush(out, !rt.eqOption(rt.eqSlice(Named.eq$cmp_PartialEq))(some, _714) ? 1 : 0); + const some: rs.Vec | undefined = rs.vecFrom(kept.items.map(Named.clone$Clone)); + const _701: rs.Vec | undefined = rs.vecFrom(kept.items.map(Named.clone$Clone)); + rs.byteVecPush(out, rs.eqOption(rs.eqSlice(Named.eq$cmp_PartialEq))(some, _701) ? 1 : 0); + rs.byteVecPush(out, rs.eqOption(rs.eqSlice(Named.eq$cmp_PartialEq))(some, undefined) ? 1 : 0); + const _714: rs.Vec | undefined = new rs.Vec(); + rs.byteVecPush(out, !rs.eqOption(rs.eqSlice(Named.eq$cmp_PartialEq))(some, _714) ? 1 : 0); const _720: Named.Named | undefined = optional$edits_Named(_604(5)); const _725: Named.Named | undefined = optional$Option_edits_Named(undefined); - rt.byteVecPush(out, rt.eqOption(Named.eq$cmp_PartialEq)(_720, _725) ? 1 : 0); - const part3 = at(4) as rt.u16; - rt.byteVecPush(out, option_mapOr$14njs1h(optional$edits_Named(_604(part3)), 65535, (n2: Named.Named): rt.u16 => { + rs.byteVecPush(out, rs.eqOption(Named.eq$cmp_PartialEq)(_720, _725) ? 1 : 0); + const part3 = at(4) as rs.u16; + rs.byteVecPush(out, option_mapOr$1ifckq6(optional$edits_Named(_604(part3)), 65535, (n2: Named.Named): rs.u16 => { return n2.id; }) & 0xff); - const part4 = option_unwrapOr$039uout(option_map$1u8sh4f(rt.sliceFirst(kept.items), (a0: Named.Named): Named.Named[] => { + const part4 = option_unwrapOr$039uout(option_map$1u8sh4f(rs.sliceFirst(kept.items), (a0: Named.Named): Named.Named[] => { return [a0]; }), kept.items); putU16s(out, _605(part4).items); const part5 = [_604(7)]; putU16s(out, _605(part5).items); - const _764: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(at(5))); - rt.idx(_764, 0); - rt.byteVecPush(out, _764.data[_764.start]); - const part6 = rt.fromUtf8ErrorClone(rt.resultUnwrapErr(rt.stringFromUtf8(rt.byteVecFrom(Uint8Array.of(97, 255, at(6)))), rt.fmtStr)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(part6, f)]; - put(out, rt.fmtFormat([args2[0]])); - rt.byteVecPush(out, 16 & 0xff); - rt.byteVecPush(out, 16 & 0xff); - rt.byteVecPush(out, 4 & 0xff); - rt.byteVecPush(out, 6 & 0xff); - rt.byteVecPush(out, rt.u8Mul(4 & 0xff, 1 & 0xff)); + const _764: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(at(5))); + rs.idx(_764, 0); + rs.byteVecPush(out, _764.data[_764.start]); + const part6 = rs.fromUtf8ErrorClone(rs.resultUnwrapErr(rs.stringFromUtf8(rs.byteVecFrom(Uint8Array.of(97, 255, at(6)))), rs.fmtStr)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(part6, f)]; + put(out, rs.fmtFormat([args2[0]])); + rs.byteVecPush(out, 16 & 0xff); + rs.byteVecPush(out, 16 & 0xff); + rs.byteVecPush(out, 4 & 0xff); + rs.byteVecPush(out, 6 & 0xff); + rs.byteVecPush(out, rs.u8Mul(4 & 0xff, 1 & 0xff)); } else { const s2: string = text(data); - const sep: rt.char[] = [47, 97]; - rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(sep)) ? 1 : 0); - rt.byteVecPush(out, rt.strContains(s2, rt.patternChars(rt.sliceRange(sep, 0))) ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.strSplit(s2, rt.patternChars(sep))) & 0xff); - rt.byteVecPush(out, rt.strEndsWith(s2, "/") ? 1 : 0); - rt.byteVecPush(out, rt.strEndsWith(s2, "😀") ? 1 : 0); - rt.byteVecPush(out, rt.strEndsWith(s2, (c: rt.char): boolean => { - return rt.isAsciiDigit(c); + const sep: rs.char[] = [47, 97]; + rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(sep)) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s2, rs.patternChars(rs.sliceRange(sep, 0))) ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.strSplit(s2, rs.patternChars(sep))) & 0xff); + rs.byteVecPush(out, rs.strEndsWith(s2, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2, "😀") ? 1 : 0); + rs.byteVecPush(out, rs.strEndsWith(s2, (c: rs.char): boolean => { + return rs.isAsciiDigit(c); }) ? 1 : 0); - const _848: [string, string] | undefined = rt.strSplitOnce(s2, "/"); + const _848: [string, string] | undefined = rs.strSplitOnce(s2, "/"); if (_848 === undefined) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { put(out, _848[0]); put(out, _848[1]); } - const _857: [string, string] | undefined = rt.strSplitOnce(s2, "a0"); + const _857: [string, string] | undefined = rs.strSplitOnce(s2, "a0"); if (_857 === undefined) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { put(out, _857[0]); put(out, _857[1]); } - const iter11: rt.RangeInclusive = new rt.RangeInclusive(0, rt.usizeAdd(rt.stringLen(s2), 1), rt.usizeStep); + const iter11: rs.RangeInclusive = new rs.RangeInclusive(0, rs.usizeAdd(rs.stringLen(s2), 1), rs.usizeStep); while (true) { - const _872: rt.usize | rt.Done = iter11.next(); - if (_872 === rt.DONE) { + const _872: rs.usize | rs.Done = iter11.next(); + if (_872 === rs.DONE) { break; } - rt.byteVecPush(out, rt.strIsCharBoundary(s2, _872) ? 1 : 0); + rs.byteVecPush(out, rs.strIsCharBoundary(s2, _872) ? 1 : 0); } - rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.strBytes(s2)), 3), undefined, true); - rt.byteVecPush(out, rt.strBytes(s2).len() & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.strBytes(s2), (_22: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.strBytes(s2)), 3), undefined, true); + rs.byteVecPush(out, rs.strBytes(s2).len() & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.strBytes(s2), (_22: rs.u8): boolean => { return _22 >= 128; })) & 0xff); } } /** - * [`edits`]'s methods of bytes, which are an `rt.ByteVec` or `rt.ByteSlice` rather than an + * [`edits`]'s methods of bytes, which are an `rs.ByteVec` or `rs.ByteSlice` rather than an * array, on every short prefix of the input and on a slice that starts past its storage's, * and those that lend a closure another element JS copies, as its place. */ -export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), 0); +export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), 0); }; - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 3); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 3); }), undefined, 2, true); - const prefixes: rt.Iter = rt.iterChain(rt.iterMap(new rt.Range(0, rt.min(data.length, 3)), (n3: rt.usize): rt.ByteSlice => { - return rt.byteSliceRange(data, 0, n3); - }), rt.iterSlice([data])); - const _15: rt.u8 = rt.u8Rem(kind, 4); + const prefixes: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, rs.min(data.length, 3)), (n3: rs.usize): rs.ByteSlice => { + return rs.byteSliceRange(data, 0, n3); + }), rs.iterSlice([data])); + const _15: rs.u8 = rs.u8Rem(kind, 4); if (_15 === 0) { - const iter: rt.Iter = prefixes; + const iter: rs.Iter = prefixes; while (true) { - const _20: rt.ByteSlice | rt.Done = iter.next(); - if (_20 === rt.DONE) { + const _20: rs.ByteSlice | rs.Done = iter.next(); + if (_20 === rs.DONE) { break; } - const v: rt.ByteVec = rt.byteSliceToByteVec(_20); - const seen: rt.ByteVec = new rt.ByteVec(); - rt.byteVecRetain(v, (_22: rt.u8): boolean => { - const b11: rt.u8 = _22; - rt.byteVecPush(seen, b11); - return rt.u8Rem(b11, 3) !== 0; + const v: rs.ByteVec = rs.byteSliceToByteVec(_20); + const seen: rs.ByteVec = new rs.ByteVec(); + rs.byteVecRetain(v, (_22: rs.u8): boolean => { + const b11: rs.u8 = _22; + rs.byteVecPush(seen, b11); + return rs.u8Rem(b11, 3) !== 0; }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); - const v2: rt.ByteVec = rt.byteSliceToByteVec(_20); - rt.byteVecRetainMut(v2, (b12: rt.Place): boolean => { - b12.v = rt.u8WrappingAdd(b12.v, 1); - return rt.u8Rem(b12.v, 4) !== 0; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(seen)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); + const v2: rs.ByteVec = rs.byteSliceToByteVec(_20); + rs.byteVecRetainMut(v2, (b12: rs.Place): boolean => { + b12.v = rs.u8WrappingAdd(b12.v, 1); + return rs.u8Rem(b12.v, 4) !== 0; }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v2)); while (true) { - const _42: rt.u8 | undefined = rt.byteVecPopIf(v2, (b13: rt.Place): boolean => { + const _42: rs.u8 | undefined = rs.byteVecPopIf(v2, (b13: rs.Place): boolean => { b13.v = b13.v ^ 128; - return rt.u8Rem(b13.v, 3) !== 0; + return rs.u8Rem(b13.v, 3) !== 0; }); if (_42 !== undefined) { - rt.byteVecPush(out, _42); + rs.byteVecPush(out, _42); } else { break; } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); - rt.byteVecPush(out, 254); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v2)); + rs.byteVecPush(out, 254); } - const halves: rt.Vec = rt.vecFrom(words.items.slice()); - rt.vecRetainMut(halves, (x2: rt.Place): boolean => { - x2.v = rt.u16Div(x2.v, 2); - return rt.u16Rem(x2.v, 3) !== 0; + const halves: rs.Vec = rs.vecFrom(words.items.slice()); + rs.vecRetainMut(halves, (x2: rs.Place): boolean => { + x2.v = rs.u16Div(x2.v, 2); + return rs.u16Rem(x2.v, 3) !== 0; }); putU16s(out, halves.items); } else if (_15 === 1) { - const iter2: rt.Iter = prefixes; + const iter2: rs.Iter = prefixes; while (true) { - const _61: rt.ByteSlice | rt.Done = iter2.next(); - if (_61 === rt.DONE) { + const _61: rs.ByteSlice | rs.Done = iter2.next(); + if (_61 === rs.DONE) { break; } - const v3: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(_61)), (b7: rt.u8): rt.u8 => { - return rt.u8Rem(b7, 4); + const v3: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_61)), (b7: rs.u8): rs.u8 => { + return rs.u8Rem(b7, 4); }), undefined, true); - rt.byteVecDedup(v3); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v3)); - const v4: rt.ByteVec = rt.byteSliceToByteVec(_61); - const seen2: rt.ByteVec = new rt.ByteVec(); - rt.byteVecDedupByMut(v4, (a3: rt.Place, b8: rt.Place): boolean => { - rt.byteVecExtendFromSlice(seen2, rt.byteSliceFrom(Uint8Array.of(a3.v, b8.v))); - b8.v = rt.u8WrappingAdd(b8.v, 1); - return rt.u8Div(a3.v, 32) === rt.u8Div(b8.v, 32); + rs.byteVecDedup(v3); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v3)); + const v4: rs.ByteVec = rs.byteSliceToByteVec(_61); + const seen2: rs.ByteVec = new rs.ByteVec(); + rs.byteVecDedupByMut(v4, (a3: rs.Place, b8: rs.Place): boolean => { + rs.byteVecExtendFromSlice(seen2, rs.byteSliceFrom(Uint8Array.of(a3.v, b8.v))); + b8.v = rs.u8WrappingAdd(b8.v, 1); + return rs.u8Div(a3.v, 32) === rs.u8Div(b8.v, 32); }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen2)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v4)); - const v5: rt.ByteVec = rt.byteSliceToByteVec(_61); - rt.byteVecDedupByKeyMut(v5, (b9: rt.Place): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(seen2)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v4)); + const v5: rs.ByteVec = rs.byteSliceToByteVec(_61); + rs.byteVecDedupByKeyMut(v5, (b9: rs.Place): rs.u8 => { b9.v = b9.v ^ 1; - return rt.u8Div(b9.v, 64); - }, rt.same); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v5)); - rt.byteVecPush(out, 254); - } - const v6: rt.Vec = rt.vecFrom(words.items.slice()); - rt.vecDedupByMut(v6, (a4: rt.Place, b10: rt.Place): boolean => { - b10.v = rt.u16Add(b10.v, 1); - return rt.u16Div(a4.v, 8) === rt.u16Div(b10.v, 8); + return rs.u8Div(b9.v, 64); + }, rs.same); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v5)); + rs.byteVecPush(out, 254); + } + const v6: rs.Vec = rs.vecFrom(words.items.slice()); + rs.vecDedupByMut(v6, (a4: rs.Place, b10: rs.Place): boolean => { + b10.v = rs.u16Add(b10.v, 1); + return rs.u16Div(a4.v, 8) === rs.u16Div(b10.v, 8); }); putU16s(out, v6.items); - const v7: rt.Vec = rt.vecFrom(words.items.slice()); - rt.vecDedupByKeyMut(v7, (x: rt.Place): rt.u16 => { + const v7: rs.Vec = rs.vecFrom(words.items.slice()); + rs.vecDedupByKeyMut(v7, (x: rs.Place): rs.u16 => { x.v = x.v ^ 1; - return rt.u16Div(x.v, 16); - }, rt.same); + return rs.u16Div(x.v, 16); + }, rs.same); putU16s(out, v7.items); } else if (_15 === 2) { - const iter3: rt.Iter = prefixes; + const iter3: rs.Iter = prefixes; while (true) { - const _109: rt.ByteSlice | rt.Done = iter3.next(); - if (_109 === rt.DONE) { + const _109: rs.ByteSlice | rs.Done = iter3.next(); + if (_109 === rs.DONE) { break; } - const v8: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.byteSliceView(rt.byteVecSlice(v8)).sort(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v8)); - const v9: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.byteSliceView(rt.byteVecSlice(v9)).sort(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v9)); - const v10: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.sliceSort(rt.byteSliceView(rt.byteVecSlice(v10)), rt.cmpLt((a: rt.u8, b3: rt.u8): rt.Ordering => { - return rt.cmp(b3, a); + const v8: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.byteSliceView(rs.byteVecSlice(v8)).sort(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v8)); + const v9: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.byteSliceView(rs.byteVecSlice(v9)).sort(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v9)); + const v10: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.sliceSort(rs.byteSliceView(rs.byteVecSlice(v10)), rs.cmpLt((a: rs.u8, b3: rs.u8): rs.Ordering => { + return rs.cmp(b3, a); }), 1, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v10)); - const v11: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.sliceSort(rt.byteSliceView(rt.byteVecSlice(v11)), rt.keyLt((b4: rt.u8): rt.u8 => { - return rt.u8Rem(b4, 5); - }, rt.lt), 1, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v11)); - const v12: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.sliceSortUnstable(rt.byteSliceView(rt.byteVecSlice(v12)), rt.keyLt((b5: rt.u8): rt.u8 => { - return rt.u8WrappingMul(b5, 13); - }, rt.lt), 1, true, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v12)); - const v13: rt.ByteVec = rt.byteSliceToByteVec(_109); - rt.sliceSortUnstable(rt.byteSliceView(rt.byteVecSlice(v13)), rt.cmpLt((a2: rt.u8, b6: rt.u8): rt.Ordering => { - return rt.cmp(b6 ^ 85, a2 ^ 85); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v10)); + const v11: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.sliceSort(rs.byteSliceView(rs.byteVecSlice(v11)), rs.keyLt((b4: rs.u8): rs.u8 => { + return rs.u8Rem(b4, 5); + }, rs.lt), 1, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v11)); + const v12: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.sliceSortUnstable(rs.byteSliceView(rs.byteVecSlice(v12)), rs.keyLt((b5: rs.u8): rs.u8 => { + return rs.u8WrappingMul(b5, 13); + }, rs.lt), 1, true, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v12)); + const v13: rs.ByteVec = rs.byteSliceToByteVec(_109); + rs.sliceSortUnstable(rs.byteSliceView(rs.byteVecSlice(v13)), rs.cmpLt((a2: rs.u8, b6: rs.u8): rs.Ordering => { + return rs.cmp(b6 ^ 85, a2 ^ 85); }), 1, true, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v13)); - const v14: rt.ByteVec = rt.byteSliceToByteVec(_109); - const part3 = rt.min(v14.length, 1); - const tail: rt.ByteSlice = rt.byteSliceRange(rt.byteVecSlice(v14), part3); - rt.byteSliceView(tail).sort(); - rt.byteSliceView(tail).reverse(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v14)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceLast(rt.byteVecSlice(v14)), 253)); - const part4 = rt.min(v14.length, 1); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceLast(rt.byteSliceRange(rt.byteVecSlice(v14), part4)), 253)); - rt.byteSliceView(rt.byteVecSlice(v14)).reverse(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v14)); - rt.byteVecPush(out, 254); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v13)); + const v14: rs.ByteVec = rs.byteSliceToByteVec(_109); + const part3 = rs.min(v14.length, 1); + const tail: rs.ByteSlice = rs.byteSliceRange(rs.byteVecSlice(v14), part3); + rs.byteSliceView(tail).sort(); + rs.byteSliceView(tail).reverse(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v14)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceLast(rs.byteVecSlice(v14)), 253)); + const part4 = rs.min(v14.length, 1); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceLast(rs.byteSliceRange(rs.byteVecSlice(v14), part4)), 253)); + rs.byteSliceView(rs.byteVecSlice(v14)).reverse(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v14)); + rs.byteVecPush(out, 254); } } else { - const _192: [rt.usize, rt.usize] = [rt.usizeRem(at(0) as rt.usize, 8), rt.usizeRem(at(1) as rt.usize, 8)]; - const i: rt.usize = _192[0]; - const j: rt.usize = _192[1]; - const v15: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteVecInsert(v15, rt.min(i, v15.length), 170); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v15)); - rt.byteVecPush(out, rt.byteVecSwapRemove(v15, rt.usizeRem(j, v15.length))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v15)); + const _192: [rs.usize, rs.usize] = [rs.usizeRem(at(0) as rs.usize, 8), rs.usizeRem(at(1) as rs.usize, 8)]; + const i: rs.usize = _192[0]; + const j: rs.usize = _192[1]; + const v15: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteVecInsert(v15, rs.min(i, v15.length), 170); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v15)); + rs.byteVecPush(out, rs.byteVecSwapRemove(v15, rs.usizeRem(j, v15.length))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v15)); if (!(v15.length === 0)) { - rt.byteVecPush(out, rt.byteVecRemove(v15, rt.usizeRem(i, v15.length))); + rs.byteVecPush(out, rs.byteVecRemove(v15, rs.usizeRem(i, v15.length))); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v15)); - const part = rt.min(v15.length, 1); - const tail2: rt.ByteSlice = rt.byteSliceRange(rt.byteVecSlice(v15), part); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v15)); + const part = rs.min(v15.length, 1); + const tail2: rs.ByteSlice = rs.byteSliceRange(rs.byteVecSlice(v15), part); if (!(tail2.length === 0)) { - rt.byteSliceSwap(tail2, rt.usizeRem(i, tail2.length), rt.usizeRem(j, tail2.length)); + rs.byteSliceSwap(tail2, rs.usizeRem(i, tail2.length), rs.usizeRem(j, tail2.length)); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v15)); - const _257: rt.u8 = rt.u8Rem(at(2), 5); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v15)); + const _257: rs.u8 = rs.u8Rem(at(2), 5); if (_257 === 0) { - rt.byteVecInsert(v15, i, 187); + rs.byteVecInsert(v15, i, 187); } else if (_257 === 1) { - rt.byteVecPush(out, rt.byteVecRemove(v15, i)); + rs.byteVecPush(out, rs.byteVecRemove(v15, i)); } else if (_257 === 2) { - rt.byteVecPush(out, rt.byteVecSwapRemove(v15, j)); + rs.byteVecPush(out, rs.byteVecSwapRemove(v15, j)); } else if (_257 === 3) { - const part2 = rt.usizeRem(i, 3); - rt.byteSliceSwap(rt.byteSliceRange(rt.byteVecSlice(v15), part2), i, j); + const part2 = rs.usizeRem(i, 3); + rs.byteSliceSwap(rs.byteSliceRange(rs.byteVecSlice(v15), part2), i, j); } else { - rt.byteSliceSwap(rt.byteVecSlice(v15), i, j); + rs.byteSliceSwap(rs.byteVecSlice(v15), i, j); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v15)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v15)); } } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$Option_u8_u8_Option_u8_Option_T_replace_u8(_: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined, place: rt.Place, value: rt.u8): rt.u8 | undefined { - return ((a0: rt.Place, a1: rt.u8): rt.u8 | undefined => { +export function apply$Option_u8_u8_Option_u8_Option_T_replace_u8(_: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined, place: rs.Place, value: rs.u8): rs.u8 | undefined { + return ((a0: rs.Place, a1: rs.u8): rs.u8 | undefined => { const old = a0.v; a0.v = a1; return old; @@ -608,8 +608,8 @@ export function apply$Option_u8_u8_Option_u8_Option_T_replace_u8(_: (a0: rt.Plac } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_String_String_mem_replace_String(_: (a0: rt.Place, a1: string) => string, place: rt.Place, value: string): string { - return ((a0: rt.Place, a1: string): string => { +export function apply$String_String_String_mem_replace_String(_: (a0: rs.Place, a1: string) => string, place: rs.Place, value: string): string { + return ((a0: rs.Place, a1: string): string => { const old = a0.v; a0.v = a1; return old; @@ -617,15 +617,15 @@ export function apply$String_String_String_mem_replace_String(_: (a0: rt.Place, a1: rt.char) => undefined, place: rt.Place, value: rt.char): void { - ((a0: rt.Place, a1: rt.char): undefined => { +export function apply$String_char_unit_String_push(_: (a0: rs.Place, a1: rs.char) => undefined, place: rs.Place, value: rs.char): void { + ((a0: rs.Place, a1: rs.char): undefined => { a0.v = a0.v + String.fromCodePoint(a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rt.Place, a1: rt.Place) => undefined, place: rt.Place, value: rt.Place): void { - ((a0: rt.Place, a1: rt.Place): undefined => { +export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rs.Place, a1: rs.Place) => undefined, place: rs.Place, value: rs.Place): void { + ((a0: rs.Place, a1: rs.Place): undefined => { const swapped = a0.v; a0.v = a1.v; a1.v = swapped; @@ -633,15 +633,15 @@ export function apply$String_mut_String_unit_mem_swap_String(_: (a0: rt.Place, a1: string) => undefined, place: rt.Place, value: string): void { - ((a0: rt.Place, a1: string): undefined => { +export function apply$String_ref_String_unit_Clone_clone_from_String(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { + ((a0: rs.Place, a1: string): undefined => { a0.v = a1; })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$String_ref_str_unit_String_push_str(_: (a0: rt.Place, a1: string) => undefined, place: rt.Place, value: string): void { - ((a0: rt.Place, a1: string): undefined => { +export function apply$String_ref_str_unit_String_push_str(_: (a0: rs.Place, a1: string) => undefined, place: rs.Place, value: string): void { + ((a0: rs.Place, a1: string): undefined => { a0.v = a0.v + a1; })(place, value); } @@ -649,20 +649,20 @@ export function apply$String_ref_str_unit_String_push_str(_: (a0: rt.Place Logged.Logged, place: Logged.Logged, value: Logged.Logged): Logged.Logged { return ((a0: Logged.Logged, a1: Logged.Logged): Logged.Logged => { - return rt.replaceIn(a0, a1); + return rs.replaceIn(a0, a1); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ export function apply$edits_Logged_mut_edits_Logged_unit_mem_swap_edits_Logged(_: (a0: Logged.Logged, a1: Logged.Logged) => undefined, place: Logged.Logged, value: Logged.Logged): void { ((a0: Logged.Logged, a1: Logged.Logged): undefined => { - Object.assign(a0, rt.replaceIn(a1, a0)); + Object.assign(a0, rs.replaceIn(a1, a0)); })(place, value); } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$u8_mut_u8_unit_mem_swap_u8(_: (a0: rt.Place, a1: rt.Place) => undefined, place: rt.Place, value: rt.Place): void { - ((a0: rt.Place, a1: rt.Place): undefined => { +export function apply$u8_mut_u8_unit_mem_swap_u8(_: (a0: rs.Place, a1: rs.Place) => undefined, place: rs.Place, value: rs.Place): void { + ((a0: rs.Place, a1: rs.Place): undefined => { const swapped = a0.v; a0.v = a1.v; a1.v = swapped; @@ -670,8 +670,8 @@ export function apply$u8_mut_u8_unit_mem_swap_u8(_: (a0: rt.Place, a1: rt } /** `f` of `place` and `value`, as a function value of two parameters is called. */ -export function apply$u8_u8_u8_mem_replace_u8(_: (a0: rt.Place, a1: rt.u8) => rt.u8, place: rt.Place, value: rt.u8): rt.u8 { - return ((a0: rt.Place, a1: rt.u8): rt.u8 => { +export function apply$u8_u8_u8_mem_replace_u8(_: (a0: rs.Place, a1: rs.u8) => rs.u8, place: rs.Place, value: rs.u8): rs.u8 { + return ((a0: rs.Place, a1: rs.u8): rs.u8 => { const old = a0.v; a0.v = a1; return old; @@ -684,189 +684,189 @@ export function apply$u8_u8_u8_mem_replace_u8(_: (a0: rt.Place, a1: rt.u8 * writes in place, and of values that drop; and other function values that a call * lowers differently, as `next`. */ -export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _5: rt.u8 = rt.u8Rem(kind, 4); + const _5: rs.u8 = rs.u8Rem(kind, 4); if (_5 === 0) { - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes))), (a019: rt.Place): rt.u8 => { + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes))), (a019: rs.Place): rs.u8 => { const taken7 = a019.v; a019.v = 0; return taken7; }), undefined, true))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); - const held: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (a020: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(a020); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); + const held: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (a020: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a020); }), undefined, 12, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(held.items), (a021: rt.ByteVec): rt.ByteVec => { - return rt.replaceIn(a021, new rt.ByteVec()); - }), undefined, 12, true).items), (a022: rt.ByteVec): rt.usize => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(held.items), (a021: rs.ByteVec): rs.ByteVec => { + return rs.replaceIn(a021, new rs.ByteVec()); + }), undefined, 12, true).items), (a022: rs.ByteVec): rs.usize => { return a022.length; - }), (n2: rt.usize): rt.u8 => { + }), (n2: rs.usize): rs.u8 => { return n2 & 0xff; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(held.items), (a023: rt.ByteVec): rt.usize => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterMap(rs.iterSlice(held.items), (a023: rs.ByteVec): rs.usize => { return a023.length; - }), (n3: rt.usize): rt.u8 => { + }), (n3: rs.usize): rs.u8 => { return n3 & 0xff; }), undefined, true); - const texts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_210))); + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(_210))); }), undefined, 12, true); - put(out, rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterSliceMut(texts.items)), (a024: rt.Place): string => { + put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSliceMut(texts.items)), (a024: rs.Place): string => { const taken9 = a024.v; a024.v = ""; return taken9; }), undefined, 12, true).items, "")); - put(out, rt.strsJoin(texts.items, "")); + put(out, rs.strsJoin(texts.items, "")); } else if (_5 === 1) { - let n: rt.u8 = at(0); - const _66: rt.u8 = at(1); - rt.byteVecPush(out, apply$u8_u8_u8_mem_replace_u8((a08: rt.Place, a17: rt.u8): rt.u8 => { + let n: rs.u8 = at(0); + const _66: rs.u8 = at(1); + rs.byteVecPush(out, apply$u8_u8_u8_mem_replace_u8((a08: rs.Place, a17: rs.u8): rs.u8 => { const old6 = a08.v; a08.v = a17; return old6; - }, rt.place(() => n, (value3) => n = value3), _66)); - rt.byteVecPush(out, n); - const replace: (a0: rt.Place, a1: rt.u8) => rt.u8 = (a09: rt.Place, a18: rt.u8): rt.u8 => { + }, rs.place(() => n, (value3) => n = value3), _66)); + rs.byteVecPush(out, n); + const replace: (a0: rs.Place, a1: rs.u8) => rs.u8 = (a09: rs.Place, a18: rs.u8): rs.u8 => { const old7 = a09.v; a09.v = a18; return old7; }; - const _75: rt.u8 = at(2); - rt.byteVecPush(out, replace(rt.place(() => n, (value4) => n = value4), _75)); - rt.byteVecPush(out, n); + const _75: rs.u8 = at(2); + rs.byteVecPush(out, replace(rs.place(() => n, (value4) => n = value4), _75)); + rs.byteVecPush(out, n); let s: string = text(data); - const _83: string = text(rt.byteSliceFrom(Uint8Array.of(at(0)))); - put(out, apply$String_String_String_mem_replace_String((a010: rt.Place, a19: string): string => { + const _83: string = text(rs.byteSliceFrom(Uint8Array.of(at(0)))); + put(out, apply$String_String_String_mem_replace_String((a010: rs.Place, a19: string): string => { const old8 = a010.v; a010.v = a19; return old8; - }, rt.place(() => s, (value5) => s = value5), _83)); + }, rs.place(() => s, (value5) => s = value5), _83)); put(out, s); - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - const old2: rt.ByteVec = ((a011: rt.ByteVec): rt.ByteVec => { - return rt.replaceIn(a011, new rt.ByteVec()); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + const old2: rs.ByteVec = ((a011: rs.ByteVec): rs.ByteVec => { + return rs.replaceIn(a011, new rs.ByteVec()); })(v); - rt.byteVecPush(out, old2.length & 0xff); - rt.byteVecPush(out, v.length & 0xff); - let held2: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(at(0), 2) === 0, at(1)); - const _121: rt.u8 = at(2); - rt.iterExtendBytes(out, rt.iterOption(apply$Option_u8_u8_Option_u8_Option_T_replace_u8((a012: rt.Place, a110: rt.u8): rt.u8 | undefined => { + rs.byteVecPush(out, old2.length & 0xff); + rs.byteVecPush(out, v.length & 0xff); + let held2: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(at(0), 2) === 0, at(1)); + const _121: rs.u8 = at(2); + rs.iterExtendBytes(out, rs.iterOption(apply$Option_u8_u8_Option_u8_Option_T_replace_u8((a012: rs.Place, a110: rs.u8): rs.u8 | undefined => { const old9 = a012.v; a012.v = a110; return old9; - }, rt.place(() => held2, (value6) => held2 = value6), _121)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(held2), undefined, true); - apply$String_ref_str_unit_String_push_str((a013: rt.Place, a111: string): undefined => { + }, rs.place(() => held2, (value6) => held2 = value6), _121)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(held2), undefined, true); + apply$String_ref_str_unit_String_push_str((a013: rs.Place, a111: string): undefined => { a013.v = a013.v + a111; - }, rt.place(() => s, (value7) => s = value7), "+"); - apply$String_char_unit_String_push((a014: rt.Place, a112: rt.char): undefined => { + }, rs.place(() => s, (value7) => s = value7), "+"); + apply$String_char_unit_String_push((a014: rs.Place, a112: rs.char): undefined => { a014.v = a014.v + String.fromCodePoint(a112); - }, rt.place(() => s, (value8) => s = value8), 33); - const _136: rt.usize = old2.length; - const _134: string = rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_136, f)); - apply$String_ref_String_unit_Clone_clone_from_String((a015: rt.Place, a113: string): undefined => { + }, rs.place(() => s, (value8) => s = value8), 33); + const _136: rs.usize = old2.length; + const _134: string = rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_136, f)); + apply$String_ref_String_unit_Clone_clone_from_String((a015: rs.Place, a113: string): undefined => { a015.v = a113; - }, rt.place(() => s, (value9) => s = value9), _134); + }, rs.place(() => s, (value9) => s = value9), _134); put(out, s); - const bytes2: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.iterForEach(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes2))), (a016: rt.Place): undefined => { - a016.v = rt.toAsciiUppercase(a016.v); + const bytes2: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.iterForEach(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes2))), (a016: rs.Place): undefined => { + a016.v = rs.toAsciiUppercase(a016.v); }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes2)); - const next: (a0: rt.Iter) => rt.u8 | undefined = (a017: rt.Iter): rt.u8 | undefined => { - return rt.iterToOption(a017.next()); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes2)); + const next: (a0: rs.Iter) => rs.u8 | undefined = (a017: rs.Iter): rs.u8 | undefined => { + return rs.iterToOption(a017.next()); }; - const it: rt.Iter = rt.byteVecIntoIter(bytes2); + const it: rs.Iter = rs.byteVecIntoIter(bytes2); while (true) { - const _152: rt.u8 | undefined = next(it); + const _152: rs.u8 | undefined = next(it); if (_152 !== undefined) { - rt.byteVecPush(out, _152); + rs.byteVecPush(out, _152); } else { break; } } - rt.byteVecPush(out, next(it) === undefined ? 1 : 0); - const next2: (a0: Down.Down) => rt.u8 | undefined = (a018: Down.Down): rt.u8 | undefined => { - return rt.iterToOption(Down.next$iter_Iterator(a018)); + rs.byteVecPush(out, next(it) === undefined ? 1 : 0); + const next2: (a0: Down.Down) => rs.u8 | undefined = (a018: Down.Down): rs.u8 | undefined => { + return rs.iterToOption(Down.next$iter_Iterator(a018)); }; - const down: Down.Down = { _0: rt.u8Rem(at(0), 4) }; + const down: Down.Down = { _0: rs.u8Rem(at(0), 4) }; while (true) { - const _170: rt.u8 | undefined = next2(down); + const _170: rs.u8 | undefined = next2(down); if (_170 !== undefined) { - rt.byteVecPush(out, _170); + rs.byteVecPush(out, _170); } else { break; } } - rt.byteVecPush(out, next2(down) === undefined ? 1 : 0); + rs.byteVecPush(out, next2(down) === undefined ? 1 : 0); } else if (_5 === 2) { - const _183: [rt.u8, rt.u8] = [at(0), at(1)]; - let a: rt.u8 = _183[0]; - let b3: rt.u8 = _183[1]; - apply$u8_mut_u8_unit_mem_swap_u8((a05: rt.Place, a14: rt.Place): undefined => { + const _183: [rs.u8, rs.u8] = [at(0), at(1)]; + let a: rs.u8 = _183[0]; + let b3: rs.u8 = _183[1]; + apply$u8_mut_u8_unit_mem_swap_u8((a05: rs.Place, a14: rs.Place): undefined => { const swapped2 = a05.v; a05.v = a14.v; a14.v = swapped2; - }, rt.place(() => a, (value) => a = value), rt.place(() => b3, (value2) => b3 = value2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a, b3)), undefined, true); - const _200: [rt.ByteVec, rt.ByteVec] = [rt.byteSliceToByteVec(data), rt.byteVecFrom(Uint8Array.of(at(2)))]; - const x: rt.ByteVec = _200[0]; - const y: rt.ByteVec = _200[1]; - ((a06: rt.ByteVec, a15: rt.ByteVec): undefined => { - Object.assign(a06, rt.replaceIn(a15, a06)); + }, rs.place(() => a, (value) => a = value), rs.place(() => b3, (value2) => b3 = value2)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a, b3)), undefined, true); + const _200: [rs.ByteVec, rs.ByteVec] = [rs.byteSliceToByteVec(data), rs.byteVecFrom(Uint8Array.of(at(2)))]; + const x: rs.ByteVec = _200[0]; + const y: rs.ByteVec = _200[1]; + ((a06: rs.ByteVec, a15: rs.ByteVec): undefined => { + Object.assign(a06, rs.replaceIn(a15, a06)); })(x, y); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(x)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(y)); - const texts2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(_22))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(x)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(y)); + const texts2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(_22))); }), undefined, 12, true); - const others: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_26: rt.u8): string => { - const b6: rt.u8 = _26; - return text(rt.byteSliceFrom(Uint8Array.of(b6, b6))); + const others: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_26: rs.u8): string => { + const b6: rs.u8 = _26; + return text(rs.byteSliceFrom(Uint8Array.of(b6, b6))); }), undefined, 12, true); - rt.iterForEach(rt.iterZip(rt.iterSliceMut(texts2.items), rt.iterSliceMut(others.items), [false, false]), (_27: [rt.Place, rt.Place]): undefined => { - apply$String_mut_String_unit_mem_swap_String((a07: rt.Place, a16: rt.Place): undefined => { + rs.iterForEach(rs.iterZip(rs.iterSliceMut(texts2.items), rs.iterSliceMut(others.items), [false, false]), (_27: [rs.Place, rs.Place]): undefined => { + apply$String_mut_String_unit_mem_swap_String((a07: rs.Place, a16: rs.Place): undefined => { const swapped4 = a07.v; a07.v = a16.v; a16.v = swapped4; }, _27[0], _27[1]); }); - put(out, rt.strsJoin(texts2.items, "")); - put(out, rt.strsJoin(others.items, "")); + put(out, rs.strsJoin(texts2.items, "")); + put(out, rs.strsJoin(others.items, "")); } else { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { return new Logged.Logged(id, log); }; - const held3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Logged.Logged => { + const held3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Logged.Logged => { return logged(_2); }), undefined, 8, true); - const taken4: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(held3.items), (a0: Logged.Logged): Logged.Logged => { - return rt.replaceIn(a0, Logged.default$Default()); + const taken4: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(held3.items), (a0: Logged.Logged): Logged.Logged => { + return rs.replaceIn(a0, Logged.default$Default()); }), undefined, 8, true); - const _260: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_260.value, 240); - rt.refMutRelease(_260); - rt.dropVec(taken4); - const _266: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_266.value, 241); - rt.refMutRelease(_266); + const _260: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_260.value, 240); + rs.refMutRelease(_260); + rs.dropVec(taken4); + const _266: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_266.value, 241); + rs.refMutRelease(_266); const part = at(0); const one: Logged.Logged = logged(part); const part2 = at(1); const _277: Logged.Logged = logged(part2); apply$edits_Logged_edits_Logged_edits_Logged_mem_replace_edits_Logged((a02: Logged.Logged, a1: Logged.Logged): Logged.Logged => { - return rt.replaceIn(a02, a1); + return rs.replaceIn(a02, a1); }, one, _277)[Symbol.dispose](); - const _286: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_286.value, 242); - rt.refMutRelease(_286); + const _286: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_286.value, 242); + rs.refMutRelease(_286); const replace2: (a0: Logged.Logged, a1: Logged.Logged) => Logged.Logged = (a03: Logged.Logged, a12: Logged.Logged): Logged.Logged => { - return rt.replaceIn(a03, a12); + return rs.replaceIn(a03, a12); }; const part3 = at(2); const _291: Logged.Logged = logged(part3); @@ -874,24 +874,24 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part4 = at(3); const other: Logged.Logged = logged(part4); apply$edits_Logged_mut_edits_Logged_unit_mem_swap_edits_Logged((a04: Logged.Logged, a13: Logged.Logged): undefined => { - Object.assign(a04, rt.replaceIn(a13, a04)); + Object.assign(a04, rs.replaceIn(a13, a04)); }, one, other); - const _309: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_309.value, 243); - rt.refMutRelease(_309); + const _309: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_309.value, 243); + rs.refMutRelease(_309); other[Symbol.dispose](); - const _316: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_316.value, 244); - rt.refMutRelease(_316); + const _316: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_316.value, 244); + rs.refMutRelease(_316); old3[Symbol.dispose](); - const _322: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_322.value, 245); - rt.refMutRelease(_322); + const _322: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_322.value, 245); + rs.refMutRelease(_322); one[Symbol.dispose](); - rt.dropVec(held3); - const _328: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_328.value)); - rt.refRelease(_328); + rs.dropVec(held3); + const _328: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_328.value)); + rs.refRelease(_328); } } @@ -899,22 +899,22 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * The range of `0..=len + 1` two bytes pick, which may be past `len` or end before it * starts. */ -export function picked(a: rt.u8, b: rt.u8, len: rt.usize): rt.Range { - return new rt.Range(rt.usizeRem(a as rt.usize, rt.usizeAdd(len, 2)), rt.usizeRem(b as rt.usize, rt.usizeAdd(len, 2))); +export function picked(a: rs.u8, b: rs.u8, len: rs.usize): rs.Range { + return new rs.Range(rs.usizeRem(a as rs.usize, rs.usizeAdd(len, 2)), rs.usizeRem(b as rs.usize, rs.usizeAdd(len, 2))); } /** * `q` with its items moved from the front to the back `n % 8` times, which wraps them past * the end of its buffer. */ -export function wrap$edits_Named(q: rt.VecDeque, n: rt.u8): void { - const _5: rt.u8 = rt.u8Rem(n, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _5; +export function wrap$edits_Named(q: rs.VecDeque, n: rs.u8): void { + const _5: rs.u8 = rs.u8Rem(n, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _5; while (iterStart++ < iterEnd) { - const _11: Named.Named | undefined = rt.dequePopFront(q); + const _11: Named.Named | undefined = rs.dequePopFront(q); if (_11 !== undefined) { - rt.dequePushBack(q, _11); + rs.dequePushBack(q, _11); } } } @@ -923,14 +923,14 @@ export function wrap$edits_Named(q: rt.VecDeque, n: rt.u8): void { * `q` with its items moved from the front to the back `n % 8` times, which wraps them past * the end of its buffer. */ -export function wrap$edits_Tracked(q: rt.VecDeque, n: rt.u8): void { - const _5: rt.u8 = rt.u8Rem(n, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _5; +export function wrap$edits_Tracked(q: rs.VecDeque, n: rs.u8): void { + const _5: rs.u8 = rs.u8Rem(n, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _5; while (iterStart++ < iterEnd) { - const _11: Tracked.Tracked | undefined = rt.dequePopFront(q); + const _11: Tracked.Tracked | undefined = rs.dequePopFront(q); if (_11 !== undefined) { - rt.dequePushBack(q, _11); + rs.dequePushBack(q, _11); } } } @@ -939,14 +939,14 @@ export function wrap$edits_Tracked(q: rt.VecDeque, n: rt.u8): v * `q` with its items moved from the front to the back `n % 8` times, which wraps them past * the end of its buffer. */ -export function wrap$u16(q: rt.VecDeque, n: rt.u8): void { - const _5: rt.u8 = rt.u8Rem(n, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _5; +export function wrap$u16(q: rs.VecDeque, n: rs.u8): void { + const _5: rs.u8 = rs.u8Rem(n, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _5; while (iterStart++ < iterEnd) { - const _11: rt.u16 | undefined = rt.dequePopFront(q); + const _11: rs.u16 | undefined = rs.dequePopFront(q); if (_11 !== undefined) { - rt.dequePushBack(q, _11); + rs.dequePushBack(q, _11); } } } @@ -955,14 +955,14 @@ export function wrap$u16(q: rt.VecDeque, n: rt.u8): void { * `q` with its items moved from the front to the back `n % 8` times, which wraps them past * the end of its buffer. */ -export function wrap$u8(q: rt.VecDeque, n: rt.u8): void { - const _5: rt.u8 = rt.u8Rem(n, 8); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _5; +export function wrap$u8(q: rs.VecDeque, n: rs.u8): void { + const _5: rs.u8 = rs.u8Rem(n, 8); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _5; while (iterStart++ < iterEnd) { - const _11: rt.u8 | undefined = rt.dequePopFront(q); + const _11: rs.u8 | undefined = rs.dequePopFront(q); if (_11 !== undefined) { - rt.dequePushBack(q, _11); + rs.dequePushBack(q, _11); } } } @@ -972,550 +972,550 @@ export function wrap$u8(q: rt.VecDeque, n: rt.u8): void { * `extend_from_within`: which values clone, in order, and when each removed one drops, * against a closure that owns one; whether a value written after it is shared with * another, of objects and of arrays and tuples JS holds by reference; bytes, which are an - * `rt.ByteVec`; `Vec::from` of a deque; and a deque's `range_mut` of items JS copies. Each + * `rs.ByteVec`; `Vec::from` of a deque; and a deque's `range_mut` of items JS copies. Each * panics with std's message past the end. */ -export function resizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _11: (a0: Tracked.Tracked[]) => rt.ByteVec = (v7: Tracked.Tracked[]): rt.ByteVec => { - return rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(v7), (t: Tracked.Tracked): Uint8Array => { +export function resizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _11: (a0: Tracked.Tracked[]) => rs.ByteVec = (v7: Tracked.Tracked[]): rs.ByteVec => { + return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(v7), (t: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t.id, t.copies); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); }; - const _196: (a0: rt.u16) => Named.Named = (w: rt.u16): Named.Named => { - return { id: w, name: text(rt.byteSliceFrom(Uint8Array.of(w & 0xff))) }; + const _196: (a0: rs.u16) => Named.Named = (w: rs.u16): Named.Named => { + return { id: w, name: text(rs.byteSliceFrom(Uint8Array.of(w & 0xff))) }; }; - const at: (a0: rt.usize) => rt.u8 = (i6: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i6), 0); + const at: (a0: rs.usize) => rs.u8 = (i6: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i6), 0); }; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const tracked: (a0: rt.u8) => Tracked.Tracked = (id: rt.u8): Tracked.Tracked => { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const tracked: (a0: rs.u8) => Tracked.Tracked = (id: rs.u8): Tracked.Tracked => { return new Tracked.Tracked(id, 0, log); }; - const mark: (a0: rt.u8) => undefined = (m: rt.u8): undefined => { - const _52: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_52.value, m); - rt.refMutRelease(_52); + const mark: (a0: rs.u8) => undefined = (m: rs.u8): undefined => { + const _52: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_52.value, m); + rs.refMutRelease(_52); }; - const _12: rt.u8 = rt.u8Rem(kind, 6); + const _12: rs.u8 = rs.u8Rem(kind, 6); if (_12 === 0) { - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_229: rt.u8): Tracked.Tracked => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6), (_229: rs.u8): Tracked.Tracked => { return tracked(_229); }), undefined, 8, true); - const _22: rt.usize = rt.u8Rem(at(0), 10) as rt.usize; + const _22: rs.usize = rs.u8Rem(at(0), 10) as rs.usize; const _28: Tracked.Tracked = tracked(160); - rt.vecResize(v, _22, _28, 8, Tracked.clone$Clone, rt.drop); + rs.vecResize(v, _22, _28, 8, Tracked.clone$Clone, rs.drop); mark(240); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v.items)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v.items)), undefined, true); const owned: Tracked.Tracked = tracked(224); - const _45: rt.usize = rt.u8Rem(at(1), 10) as rt.usize; - let captured3: rt.u8 = 0; + const _45: rs.usize = rs.u8Rem(at(1), 10) as rs.usize; + let captured3: rs.u8 = 0; const captured4 = owned; - const _51: () => Tracked.Tracked = rt.closure((): Tracked.Tracked => { - captured3 = rt.u8Add(captured3, 1); - return new Tracked.Tracked(rt.u8Add(captured4.id, captured3), 0, captured4.log); + const _51: () => Tracked.Tracked = rs.closure((): Tracked.Tracked => { + captured3 = rs.u8Add(captured3, 1); + return new Tracked.Tracked(rs.u8Add(captured4.id, captured3), 0, captured4.log); }, (): void => { captured4[Symbol.dispose](); }); - rt.dropAfter(_51, () => rt.vecResizeWith(v, _45, _51, 8, rt.drop)); + rs.dropAfter(_51, () => rs.vecResizeWith(v, _45, _51, 8, rs.drop)); mark(241); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v.items)), undefined, true); - const _63: rt.usize = rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(v.items.length, 1)); - const tail: rt.Vec = rt.vecSplitOff(v, _63); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v.items)), undefined, true); + const _63: rs.usize = rs.usizeRem(at(2) as rs.usize, rs.usizeAdd(v.items.length, 1)); + const tail: rs.Vec = rs.vecSplitOff(v, _63); mark(242); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(tail.items)), undefined, true); - const _84: rt.RangeFrom = new rt.RangeFrom(rt.min(picked(at(3), at(4), v.items.length).start, v.items.length), rt.usizeStep); - rt.vecExtendFromWithin(v, _84, 8, Tracked.clone$Clone); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(tail.items)), undefined, true); + const _84: rs.RangeFrom = new rs.RangeFrom(rs.min(picked(at(3), at(4), v.items.length).start, v.items.length), rs.usizeStep); + rs.vecExtendFromWithin(v, _84, 8, Tracked.clone$Clone); mark(243); - rt.vecAppend(v, tail, 8); - rt.byteVecPush(out, tail.items.length & 0xff); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v.items)), undefined, true); + rs.vecAppend(v, tail, 8); + rs.byteVecPush(out, tail.items.length & 0xff); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v.items)), undefined, true); mark(244); - rt.dropVec(tail); - rt.dropVec(v); - const _121: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_121.value)); - rt.refRelease(_121); - const v2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_234: rt.u8): rt.u16 => { - return ((_234 as rt.u16) << 4) & 0xffff; + rs.dropVec(tail); + rs.dropVec(v); + const _121: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_121.value)); + rs.refRelease(_121); + const v2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_234: rs.u8): rs.u16 => { + return ((_234 as rs.u16) << 4) & 0xffff; }), undefined, 2, true); - const _127: rt.u8 = (kind >> 3) & 3; + const _127: rs.u8 = (kind >> 3) & 3; if (_127 === 0) { - const _133: rt.usize = rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(v2.items.length, 2)); - rt.vecSplitOff(v2, _133); + const _133: rs.usize = rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(v2.items.length, 2)); + rs.vecSplitOff(v2, _133); } else if (_127 === 1) { - const _144: rt.Range = picked(at(5), at(6), v2.items.length); - rt.vecExtendFromWithin(v2, _144, 2, undefined); + const _144: rs.Range = picked(at(5), at(6), v2.items.length); + rs.vecExtendFromWithin(v2, _144, 2, undefined); } else if (_127 === 2) { - const _154: rt.RangeInclusive = new rt.RangeInclusive(rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(v2.items.length, 2)), rt.usizeRem(at(6) as rt.usize, rt.usizeAdd(v2.items.length, 2)), rt.usizeStep); - rt.vecExtendFromWithin(v2, _154, 2, undefined); + const _154: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(v2.items.length, 2)), rs.usizeRem(at(6) as rs.usize, rs.usizeAdd(v2.items.length, 2)), rs.usizeStep); + rs.vecExtendFromWithin(v2, _154, 2, undefined); } else { - const _176: { end: rt.usize; inclusive: true } = { end: rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(v2.items.length, 2)), inclusive: true }; - rt.vecExtendFromWithin(v2, _176, 2, undefined); + const _176: { end: rs.usize; inclusive: true } = { end: rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(v2.items.length, 2)), inclusive: true }; + rs.vecExtendFromWithin(v2, _176, 2, undefined); } for (const _190 of v2.items) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_190)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_190)), undefined, true); } } else if (_12 === 1) { - const v3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_225: rt.u8): Named.Named => { - return _196(_225 as rt.u16); + const v3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_225: rs.u8): Named.Named => { + return _196(_225 as rs.u16); }), undefined, 16, true); - const _205: rt.usize = rt.u8Rem(at(0), 8) as rt.usize; + const _205: rs.usize = rs.u8Rem(at(0), 8) as rs.usize; const _211: Named.Named = _196(511); - rt.vecResize(v3, _205, _211, 16, Named.clone$Clone); - rt.vecExtendFromWithin(v3, undefined, 16, Named.clone$Clone); - const iter2: rt.Iter<[rt.usize, Named.Named]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(v3.items)), 1), 2); + rs.vecResize(v3, _205, _211, 16, Named.clone$Clone); + rs.vecExtendFromWithin(v3, undefined, 16, Named.clone$Clone); + const iter2: rs.Iter<[rs.usize, Named.Named]> = rs.iterStepBy(rs.iterSkip(rs.iterEnumerate(rs.iterSlice(v3.items)), 1), 2); while (true) { - const _224: [rt.usize, Named.Named] | rt.Done = iter2.next(); - if (_224 === rt.DONE) { + const _224: [rs.usize, Named.Named] | rs.Done = iter2.next(); + if (_224 === rs.DONE) { break; } - const i: rt.usize = _224[0]; + const i: rs.usize = _224[0]; _224[1].name = _224[1].name + "!"; - _224[1].id = rt.u16Add(_224[1].id, i & 0xffff); + _224[1].id = rs.u16Add(_224[1].id, i & 0xffff); } for (const _236 of v3.items) { put(out, _236.name); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_236.id)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_236.id)), undefined, true); } - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_226: rt.u8): rt.u16[] => { - return [_226 as rt.u16, 0]; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_226: rs.u8): rs.u16[] => { + return [_226 as rs.u16, 0]; }), undefined, 4, true); - const _252: rt.usize = rt.u8Rem(at(1), 7) as rt.usize; - const _258: rt.u16[] = [7, 7]; - rt.vecResize(pairs, _252, _258, 4, copy$array_u16); - const _261: rt.RangeFrom = new rt.RangeFrom(rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(pairs.items.length, 1)), rt.usizeStep); - rt.vecExtendFromWithin(pairs, _261, 4, copy$array_u16); - const tuples: rt.Vec<[rt.u8, rt.u16]> = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_227: rt.u8): [rt.u8, rt.u16] => { - return [_227, 1] as [rt.u8, rt.u16]; + const _252: rs.usize = rs.u8Rem(at(1), 7) as rs.usize; + const _258: rs.u16[] = [7, 7]; + rs.vecResize(pairs, _252, _258, 4, copy$array_u16); + const _261: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(2) as rs.usize, rs.usizeAdd(pairs.items.length, 1)), rs.usizeStep); + rs.vecExtendFromWithin(pairs, _261, 4, copy$array_u16); + const tuples: rs.Vec<[rs.u8, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_227: rs.u8): [rs.u8, rs.u16] => { + return [_227, 1] as [rs.u8, rs.u16]; }), undefined, 4, true); - const _278: rt.usize = rt.u8Rem(at(3), 7) as rt.usize; - const _284: () => [rt.u8, rt.u16] = (): [rt.u8, rt.u16] => { - return [at(4), 2] as [rt.u8, rt.u16]; + const _278: rs.usize = rs.u8Rem(at(3), 7) as rs.usize; + const _284: () => [rs.u8, rs.u16] = (): [rs.u8, rs.u16] => { + return [at(4), 2] as [rs.u8, rs.u16]; }; - rt.vecResizeWith(tuples, _278, _284, 4); - const _288: { end: rt.usize } = { end: rt.usizeDiv(tuples.items.length, 2) }; - rt.vecExtendFromWithin(tuples, _288, 4, copy$tuple2_u8_u16); - const moved: rt.Vec = rt.vecSplitOff(pairs, rt.usizeDiv(pairs.items.length, 2)); - const iter4: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.iterChain(rt.iterSlice(pairs.items), rt.iterSlice(moved.items))); + rs.vecResizeWith(tuples, _278, _284, 4); + const _288: { end: rs.usize } = { end: rs.usizeDiv(tuples.items.length, 2) }; + rs.vecExtendFromWithin(tuples, _288, 4, copy$tuple2_u8_u16); + const moved: rs.Vec = rs.vecSplitOff(pairs, rs.usizeDiv(pairs.items.length, 2)); + const iter4: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterChain(rs.iterSlice(pairs.items), rs.iterSlice(moved.items))); while (true) { - const _309: [rt.usize, rt.u16[]] | rt.Done = iter4.next(); - if (_309 === rt.DONE) { + const _309: [rs.usize, rs.u16[]] | rs.Done = iter4.next(); + if (_309 === rs.DONE) { break; } - const i2: rt.usize = _309[0]; - const _315: rt.usize = rt.usizeRem(i2, 2); + const i2: rs.usize = _309[0]; + const _315: rs.usize = rs.usizeRem(i2, 2); if (!(_315 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _315); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _315); } - _309[1][_315] = rt.u16Add(_309[1][_315], i2 & 0xffff); + _309[1][_315] = rs.u16Add(_309[1][_315], i2 & 0xffff); } - const iter5: rt.Iter<[rt.u8, rt.u16]> = rt.iterStepBy(rt.iterSlice(tuples.items), 2); + const iter5: rs.Iter<[rs.u8, rs.u16]> = rs.iterStepBy(rs.iterSlice(tuples.items), 2); while (true) { - const _325: [rt.u8, rt.u16] | rt.Done = iter5.next(); - if (_325 === rt.DONE) { + const _325: [rs.u8, rs.u16] | rs.Done = iter5.next(); + if (_325 === rs.DONE) { break; } - _325[1] = rt.u16Add(_325[1], 10); + _325[1] = rs.u16Add(_325[1], 10); } - rt.vecAppend(pairs, moved, 4); - const iter6: rt.Iter = rt.iterFlatten(rt.iterSlice(pairs.items), (value: rt.u16[]) => rt.iterSlice(value), true, 2); + rs.vecAppend(pairs, moved, 4); + const iter6: rs.Iter = rs.iterFlatten(rs.iterSlice(pairs.items), (value: rs.u16[]) => rs.iterSlice(value), true, 2); while (true) { - const _339: rt.u16 | rt.Done = iter6.next(); - if (_339 === rt.DONE) { + const _339: rs.u16 | rs.Done = iter6.next(); + if (_339 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_339)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_339)), undefined, true); } for (const _349 of tuples.items) { - rt.byteVecPush(out, _349[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_349[1])), undefined, true); - } - rt.byteVecPush(out, moved.items.length & 0xff); - const keys: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.byteSliceChunksExact(data, 2), 3), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _324: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + rs.byteVecPush(out, _349[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_349[1])), undefined, true); + } + rs.byteVecPush(out, moved.items.length & 0xff); + const keys: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _324: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_324, c.data[c.start + 1]); }), undefined, 2, true); - const _369: rt.usize = rt.u8Rem(at(5), 6) as rt.usize; + const _369: rs.usize = rs.u8Rem(at(5), 6) as rs.usize; const _375: Uint8Array = Uint8Array.of(9, 9); - rt.vecResize(keys, _369, _375, 2, copy$array_u8); - rt.vecExtendFromWithin(keys, undefined, 2, copy$array_u8); - const rest: rt.Vec = rt.vecSplitOff(keys, rt.usizeDiv(keys.items.length, 3)); - const iter8: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterStepBy(rt.iterEnumerate(rt.iterChain(rt.iterLend(rt.iterSlice(keys.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(rest.items), rt.byteSliceFrom))), 2); + rs.vecResize(keys, _369, _375, 2, copy$array_u8); + rs.vecExtendFromWithin(keys, undefined, 2, copy$array_u8); + const rest: rs.Vec = rs.vecSplitOff(keys, rs.usizeDiv(keys.items.length, 3)); + const iter8: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterStepBy(rs.iterEnumerate(rs.iterChain(rs.iterLend(rs.iterSlice(keys.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(rest.items), rs.byteSliceFrom))), 2); while (true) { - const _395: [rt.usize, rt.ByteSlice] | rt.Done = iter8.next(); - if (_395 === rt.DONE) { + const _395: [rs.usize, rs.ByteSlice] | rs.Done = iter8.next(); + if (_395 === rs.DONE) { break; } - const _400: rt.usize = rt.usizeRem(_395[0], 2); + const _400: rs.usize = rs.usizeRem(_395[0], 2); if (!(_400 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _400); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _400); } _395[1].data[_395[1].start + _400] = _395[1].data[_395[1].start + _400] ^ 255; } - rt.vecAppend(keys, rest, 2); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(keys.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); + rs.vecAppend(keys, rest, 2); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(keys.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); } else if (_12 === 2) { - const iter9: rt.Iter = rt.iterChain(rt.iterMap(new rt.Range(0, rt.min(data.length, 3)), (n3: rt.usize): rt.ByteSlice => { - return rt.byteSliceRange(data, 0, n3); - }), rt.iterSlice([data])); + const iter9: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, rs.min(data.length, 3)), (n3: rs.usize): rs.ByteSlice => { + return rs.byteSliceRange(data, 0, n3); + }), rs.iterSlice([data])); while (true) { - const _420: rt.ByteSlice | rt.Done = iter9.next(); - if (_420 === rt.DONE) { + const _420: rs.ByteSlice | rs.Done = iter9.next(); + if (_420 === rs.DONE) { break; } - const at2: (a0: rt.usize) => rt.u8 = (i7: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(_420, i7), 0); + const at2: (a0: rs.usize) => rs.u8 = (i7: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(_420, i7), 0); }; - const v4: rt.ByteVec = rt.byteSliceToByteVec(_420); - const _428: rt.usize = rt.u8Rem(at2(0), 9) as rt.usize; - rt.byteVecResize(v4, _428, 170); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v4)); - let n: rt.u8 = 0; - const _440: rt.usize = rt.u8Rem(at2(1), 9) as rt.usize; - const _446: () => rt.u8 = (): rt.u8 => { - n = rt.u8Add(n, 3); + const v4: rs.ByteVec = rs.byteSliceToByteVec(_420); + const _428: rs.usize = rs.u8Rem(at2(0), 9) as rs.usize; + rs.byteVecResize(v4, _428, 170); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v4)); + let n: rs.u8 = 0; + const _440: rs.usize = rs.u8Rem(at2(1), 9) as rs.usize; + const _446: () => rs.u8 = (): rs.u8 => { + n = rs.u8Add(n, 3); return n; }; - rt.byteVecResizeWith(v4, _440, _446); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v4)); - const _453: rt.RangeFrom = new rt.RangeFrom(rt.usizeRem(at2(2) as rt.usize, rt.usizeAdd(v4.length, 1)), rt.usizeStep); - rt.byteVecExtendFromWithin(v4, _453); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v4)); - const _469: rt.usize = rt.usizeRem(at2(3) as rt.usize, rt.usizeAdd(v4.length, 1)); - const tail2: rt.ByteVec = rt.byteVecSplitOff(v4, _469); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(tail2)); - rt.byteVecPush(tail2, 187); - rt.byteVecAppend(v4, tail2); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v4)); - rt.byteVecPush(out, tail2.length & 0xff); - rt.byteVecPush(out, 254); - } - const v5: rt.ByteVec = rt.byteSliceToByteVec(data); + rs.byteVecResizeWith(v4, _440, _446); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v4)); + const _453: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at2(2) as rs.usize, rs.usizeAdd(v4.length, 1)), rs.usizeStep); + rs.byteVecExtendFromWithin(v4, _453); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v4)); + const _469: rs.usize = rs.usizeRem(at2(3) as rs.usize, rs.usizeAdd(v4.length, 1)); + const tail2: rs.ByteVec = rs.byteVecSplitOff(v4, _469); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tail2)); + rs.byteVecPush(tail2, 187); + rs.byteVecAppend(v4, tail2); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v4)); + rs.byteVecPush(out, tail2.length & 0xff); + rs.byteVecPush(out, 254); + } + const v5: rs.ByteVec = rs.byteSliceToByteVec(data); if (((kind >> 3) & 1) === 0) { - const _503: rt.usize = rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(v5.length, 2)); - rt.byteVecSplitOff(v5, _503); + const _503: rs.usize = rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(v5.length, 2)); + rs.byteVecSplitOff(v5, _503); } else { - const _514: rt.Range = picked(at(5), at(6), v5.length); - rt.byteVecExtendFromWithin(v5, _514); + const _514: rs.Range = picked(at(5), at(6), v5.length); + rs.byteVecExtendFromWithin(v5, _514); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v5)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v5)); } else if (_12 === 3) { - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_214: rt.u8): Tracked.Tracked => { + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_214: rs.u8): Tracked.Tracked => { return tracked(_214); - }), undefined, 8, true), 8) as rt.VecDeque; - const _534: rt.u8 = at(0); + }), undefined, 8, true), 8) as rs.VecDeque; + const _534: rs.u8 = at(0); wrap$edits_Tracked(q, _534); - const _539: rt.usize = rt.u8Rem(at(1), 9) as rt.usize; + const _539: rs.usize = rs.u8Rem(at(1), 9) as rs.usize; const _545: Tracked.Tracked = tracked(160); - rt.dequeResize(q, _539, _545, Tracked.clone$Clone, rt.drop); + rs.dequeResize(q, _539, _545, Tracked.clone$Clone, rs.drop); mark(240); const owned2: Tracked.Tracked = tracked(224); - const _556: rt.usize = rt.u8Rem(at(2), 9) as rt.usize; - let captured: rt.u8 = 0; + const _556: rs.usize = rs.u8Rem(at(2), 9) as rs.usize; + let captured: rs.u8 = 0; const captured2 = owned2; - const _562: () => Tracked.Tracked = rt.closure((): Tracked.Tracked => { - captured = rt.u8Add(captured, 1); - return new Tracked.Tracked(rt.u8Add(captured2.id, captured), 0, captured2.log); + const _562: () => Tracked.Tracked = rs.closure((): Tracked.Tracked => { + captured = rs.u8Add(captured, 1); + return new Tracked.Tracked(rs.u8Add(captured2.id, captured), 0, captured2.log); }, (): void => { captured2[Symbol.dispose](); }); - rt.dropAfter(_562, () => rt.dequeResizeWith(q, _556, _562, rt.drop)); + rs.dropAfter(_562, () => rs.dequeResizeWith(q, _556, _562, rs.drop)); mark(241); - const _568: rt.usize = rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(q.n, 1)); - const tail3: rt.VecDeque = rt.dequeSplitOff(q, _568); + const _568: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.usizeAdd(q.n, 1)); + const tail3: rs.VecDeque = rs.dequeSplitOff(q, _568); mark(242); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(tail3), (t2: Tracked.Tracked): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(tail3), (t2: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t2.id, t2.copies); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); const _587: Tracked.Tracked = tracked(208); - rt.dequePushFront(tail3, _587); - rt.dequeAppend(q, tail3); - rt.byteVecPush(out, tail3.n & 0xff); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (t3: Tracked.Tracked): Uint8Array => { + rs.dequePushFront(tail3, _587); + rs.dequeAppend(q, tail3); + rs.byteVecPush(out, tail3.n & 0xff); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (t3: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t3.id, t3.copies); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); mark(243); - const v6: rt.Vec = rt.dequeToVec(q); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v6.items)), undefined, true); + const v6: rs.Vec = rs.dequeToVec(q); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v6.items)), undefined, true); mark(244); - rt.dropVec(v6); - rt.dequeDrop(tail3, rt.drop); - const _619: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_619.value)); - rt.refRelease(_619); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_222: rt.u8): rt.u16 => { - return _222 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; - const _627: rt.usize = rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(q2.n, 2)); - rt.dequeSplitOff(q2, _627); - rt.byteVecPush(out, q2.n & 0xff); + rs.dropVec(v6); + rs.dequeDrop(tail3, rs.drop); + const _619: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_619.value)); + rs.refRelease(_619); + const q2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_222: rs.u8): rs.u16 => { + return _222 as rs.u16; + }), undefined, 2, true), 2) as rs.VecDeque; + const _627: rs.usize = rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(q2.n, 2)); + rs.dequeSplitOff(q2, _627); + rs.byteVecPush(out, q2.n & 0xff); } else if (_12 === 4) { - const q3: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16 => { - return _29 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; - const _646: rt.u8 = at(0); + const q3: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.u16 => { + return _29 as rs.u16; + }), undefined, 2, true), 2) as rs.VecDeque; + const _646: rs.u8 = at(0); wrap$u16(q3, _646); - const r: rt.Range = picked(at(1), at(2), q3.n); - const _660: [rt.usize, rt.usize] = [rt.min(r.start, q3.n), rt.min(r.end, q3.n)]; - const lo: rt.usize = _660[0]; - const hi: rt.usize = _660[1]; - const _673: rt.Range = new rt.Range(rt.min(lo, hi), hi); - const iter10: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.dequeRangeMut(q3, _673)); + const r: rs.Range = picked(at(1), at(2), q3.n); + const _660: [rs.usize, rs.usize] = [rs.min(r.start, q3.n), rs.min(r.end, q3.n)]; + const lo: rs.usize = _660[0]; + const hi: rs.usize = _660[1]; + const _673: rs.Range = new rs.Range(rs.min(lo, hi), hi); + const iter10: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.dequeRangeMut(q3, _673)); while (true) { - const _676: [rt.usize, rt.Place] | rt.Done = iter10.next(); - if (_676 === rt.DONE) { + const _676: [rs.usize, rs.Place] | rs.Done = iter10.next(); + if (_676 === rs.DONE) { break; } - _676[1].v = rt.u16Add(_676[1].v, rt.u16Mul(256, rt.u16Add(_676[0] & 0xffff, 1))); + _676[1].v = rs.u16Add(_676[1].v, rs.u16Mul(256, rs.u16Add(_676[0] & 0xffff, 1))); } - const _689: rt.RangeFrom = new rt.RangeFrom(rt.min(lo, hi), rt.usizeStep); - const _691: rt.Place | undefined = rt.iterToOption(rt.dequeRangeMut(q3, _689).nextBack()); + const _689: rs.RangeFrom = new rs.RangeFrom(rs.min(lo, hi), rs.usizeStep); + const _691: rs.Place | undefined = rs.iterToOption(rs.dequeRangeMut(q3, _689).nextBack()); if (_691 !== undefined) { _691.v = _691.v ^ 65535; } - const iter11: rt.Iter = rt.dequeIter(q3); + const iter11: rs.Iter = rs.dequeIter(q3); while (true) { - const _698: rt.u16 | rt.Done = iter11.next(); - if (_698 === rt.DONE) { + const _698: rs.u16 | rs.Done = iter11.next(); + if (_698 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_698)), undefined, true); - } - const named: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.dequeIter(q3), (_212: rt.u16): Named.Named => { - const w2: rt.u16 = _212; - return { id: w2, name: text(rt.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; - }), undefined, 16, true), 16) as rt.VecDeque; - const _712: rt.Range = new rt.Range(rt.min(lo, hi), hi); - const iter12: rt.Iter = rt.dequeRange(named, _712); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_698)), undefined, true); + } + const named: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(q3), (_212: rs.u16): Named.Named => { + const w2: rs.u16 = _212; + return { id: w2, name: text(rs.byteSliceFrom(Uint8Array.of(w2 & 0xff))) }; + }), undefined, 16, true), 16) as rs.VecDeque; + const _712: rs.Range = new rs.Range(rs.min(lo, hi), hi); + const iter12: rs.Iter = rs.dequeRange(named, _712); while (true) { - const _715: Named.Named | rt.Done = iter12.next(); - if (_715 === rt.DONE) { + const _715: Named.Named | rs.Done = iter12.next(); + if (_715 === rs.DONE) { break; } _715.name = _715.name + "+"; } - const iter13: rt.Iter = rt.dequeIter(named); + const iter13: rs.Iter = rs.dequeIter(named); while (true) { - const _724: Named.Named | rt.Done = iter13.next(); - if (_724 === rt.DONE) { + const _724: Named.Named | rs.Done = iter13.next(); + if (_724 === rs.DONE) { break; } put(out, _724.name); } - const bytes2: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; - const _735: rt.Place | rt.Done = rt.dequeRangeMut(bytes2, undefined).next(); - if (_735 !== rt.DONE) { - _735.v = rt.u8WrappingAdd(_735.v, 1); + const bytes2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; + const _735: rs.Place | rs.Done = rs.dequeRangeMut(bytes2, undefined).next(); + if (_735 !== rs.DONE) { + _735.v = rs.u8WrappingAdd(_735.v, 1); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecFromVec(rt.dequeToVec(bytes2)))); - const _751: rt.Range = picked(at(3), at(4), q3.n); - const iter14: rt.Iter> = rt.dequeRangeMut(q3, _751); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteVecFromVec(rs.dequeToVec(bytes2)))); + const _751: rs.Range = picked(at(3), at(4), q3.n); + const iter14: rs.Iter> = rs.dequeRangeMut(q3, _751); while (true) { - const _761: rt.Place | rt.Done = iter14.next(); - if (_761 === rt.DONE) { + const _761: rs.Place | rs.Done = iter14.next(); + if (_761 === rs.DONE) { break; } - _761.v = rt.u16Add(_761.v, 1); + _761.v = rs.u16Add(_761.v, 1); } - rt.byteVecPush(out, q3.n & 0xff); + rs.byteVecPush(out, q3.n & 0xff); } else { - const q4: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; - const _775: rt.u8 = at(0); + const q4: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; + const _775: rs.u8 = at(0); wrap$u8(q4, _775); - const _780: rt.usize = rt.u8Rem(at(1), 9) as rt.usize; - rt.dequeResize(q4, _780, 170, undefined); - let n2: rt.u8 = 0; - const _789: rt.usize = rt.u8Rem(at(2), 9) as rt.usize; - const _795: () => rt.u8 = (): rt.u8 => { - n2 = rt.u8Add(n2, 3); + const _780: rs.usize = rs.u8Rem(at(1), 9) as rs.usize; + rs.dequeResize(q4, _780, 170, undefined); + let n2: rs.u8 = 0; + const _789: rs.usize = rs.u8Rem(at(2), 9) as rs.usize; + const _795: () => rs.u8 = (): rs.u8 => { + n2 = rs.u8Add(n2, 3); return n2; }; - rt.dequeResizeWith(q4, _789, _795); - const _799: rt.usize = rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(q4.n, 1)); - const tail4: rt.VecDeque = rt.dequeSplitOff(q4, _799); - rt.iterExtendBytes(out, rt.dequeIter(tail4), undefined, true); - rt.dequePushFront(tail4, 221); - rt.dequeAppend(q4, tail4); - rt.iterExtendBytes(out, rt.dequeIter(q4), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.byteVecFromVec(rt.dequeToVec(q4)))); - const pairs2: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_25: rt.u8): rt.u16[] => { - return [_25 as rt.u16, 0]; - }), undefined, 4, true), 4) as rt.VecDeque; - const _831: rt.usize = rt.u8Rem(at(4), 7) as rt.usize; - const _837: rt.u16[] = [7, 7]; - rt.dequeResize(pairs2, _831, _837, copy$array_u16); - const moved2: rt.VecDeque = rt.dequeSplitOff(pairs2, rt.usizeDiv(pairs2.n, 2)); - const iter15: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.iterChain(rt.dequeIter(pairs2), rt.dequeIter(moved2))); + rs.dequeResizeWith(q4, _789, _795); + const _799: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.usizeAdd(q4.n, 1)); + const tail4: rs.VecDeque = rs.dequeSplitOff(q4, _799); + rs.iterExtendBytes(out, rs.dequeIter(tail4), undefined, true); + rs.dequePushFront(tail4, 221); + rs.dequeAppend(q4, tail4); + rs.iterExtendBytes(out, rs.dequeIter(q4), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.byteVecFromVec(rs.dequeToVec(q4)))); + const pairs2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_25: rs.u8): rs.u16[] => { + return [_25 as rs.u16, 0]; + }), undefined, 4, true), 4) as rs.VecDeque; + const _831: rs.usize = rs.u8Rem(at(4), 7) as rs.usize; + const _837: rs.u16[] = [7, 7]; + rs.dequeResize(pairs2, _831, _837, copy$array_u16); + const moved2: rs.VecDeque = rs.dequeSplitOff(pairs2, rs.usizeDiv(pairs2.n, 2)); + const iter15: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterChain(rs.dequeIter(pairs2), rs.dequeIter(moved2))); while (true) { - const _852: [rt.usize, rt.u16[]] | rt.Done = iter15.next(); - if (_852 === rt.DONE) { + const _852: [rs.usize, rs.u16[]] | rs.Done = iter15.next(); + if (_852 === rs.DONE) { break; } - const i5: rt.usize = _852[0]; - const _858: rt.usize = rt.usizeRem(i5, 2); + const i5: rs.usize = _852[0]; + const _858: rs.usize = rs.usizeRem(i5, 2); if (!(_858 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _858); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _858); } - _852[1][_858] = rt.u16Add(_852[1][_858], i5 & 0xffff); + _852[1][_858] = rs.u16Add(_852[1][_858], i5 & 0xffff); } - rt.dequeAppend(pairs2, moved2); - const iter16: rt.Iter = rt.iterFlatten(rt.iterSlice(rt.dequeToVec(pairs2).items), (value: rt.u16[]) => rt.iterSlice(value), true, 2); + rs.dequeAppend(pairs2, moved2); + const iter16: rs.Iter = rs.iterFlatten(rs.iterSlice(rs.dequeToVec(pairs2).items), (value: rs.u16[]) => rs.iterSlice(value), true, 2); while (true) { - const _873: rt.u16 | rt.Done = iter16.next(); - if (_873 === rt.DONE) { + const _873: rs.u16 | rs.Done = iter16.next(); + if (_873 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_873)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_873)), undefined, true); } } } /** A range within `0..=len` two bytes pick. */ -export function within(a: rt.u8, b: rt.u8, len: rt.usize): rt.Range { - const start: rt.usize = rt.usizeRem(a as rt.usize, rt.usizeAdd(len, 1)); - return new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(b as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1)))); +export function within(a: rs.u8, b: rs.u8, len: rs.usize): rs.Range { + const start: rs.usize = rs.usizeRem(a as rs.usize, rs.usizeAdd(len, 1)); + return new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(b as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1)))); } /** * `v.splice(r, items)`, read `read % 4` times from alternate ends and then dropped, each * step marked. */ -export function spliced$Vec_edits_Tracked(v: rt.Vec, r: rt.Range, items: rt.Vec, read: rt.u8, log: rt.RefCell): void { - let _12!: rt.u8; +export function spliced$Vec_edits_Tracked(v: rs.Vec, r: rs.Range, items: rs.Vec, read: rs.u8, log: rs.RefCell): void { + let _12!: rs.u8; let t!: Tracked.Tracked | undefined; - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(v, r, 8, rt.drop), rt.vecIntoIter(items, rt.drop), true, true); - const _9: rt.u8 = rt.u8Rem(read, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(v, r, 8, rs.drop), rs.vecIntoIter(items, rs.drop), true, true); + const _9: rs.u8 = rs.u8Rem(read, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if (rt.u8Rem(_12, 2) === 0) { - t = rt.iterToOption(s.next()); + if (rs.u8Rem(_12, 2) === 0) { + t = rs.iterToOption(s.next()); } else { - t = rt.iterToOption(s.nextBack()); + t = rs.iterToOption(s.nextBack()); } - const _24: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_24.value, 240); - rt.refMutRelease(_24); - rt.drop(t); + const _24: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_24.value, 240); + rs.refMutRelease(_24); + rs.drop(t); } - rt.drop(s); - const _32: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_32.value, 241); - rt.refMutRelease(_32); + rs.drop(s); + const _32: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_32.value, 241); + rs.refMutRelease(_32); } /** * `v.splice(r, items)`, read `read % 4` times from alternate ends and then dropped, each * step marked. */ -export function spliced$edits_Hinted(v: rt.Vec, r: rt.Range, items: Hinted.Hinted, read: rt.u8, log: rt.RefCell): void { - let _12!: rt.u8; +export function spliced$edits_Hinted(v: rs.Vec, r: rs.Range, items: Hinted.Hinted, read: rs.u8, log: rs.RefCell): void { + let _12!: rs.u8; let t!: Tracked.Tracked | undefined; - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(v, r, 8, rt.drop), rt.iterFrom(items, Hinted.next$iter_Iterator, undefined, { hint: Hinted.sizeHint$iter_Iterator })); - const _9: rt.u8 = rt.u8Rem(read, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(v, r, 8, rs.drop), rs.iterFrom(items, Hinted.next$iter_Iterator, undefined, { hint: Hinted.sizeHint$iter_Iterator })); + const _9: rs.u8 = rs.u8Rem(read, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if (rt.u8Rem(_12, 2) === 0) { - t = rt.iterToOption(s.next()); + if (rs.u8Rem(_12, 2) === 0) { + t = rs.iterToOption(s.next()); } else { - t = rt.iterToOption(s.nextBack()); + t = rs.iterToOption(s.nextBack()); } - const _24: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_24.value, 240); - rt.refMutRelease(_24); - rt.drop(t); + const _24: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_24.value, 240); + rs.refMutRelease(_24); + rs.drop(t); } - rt.drop(s); - const _32: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_32.value, 241); - rt.refMutRelease(_32); + rs.drop(s); + const _32: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_32.value, 241); + rs.refMutRelease(_32); } /** * `v.splice(r, items)`, read `read % 4` times from alternate ends and then dropped, each * step marked. */ -export function spliced$iter_Chain_vec_IntoIter_edits_Tracked_iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure18_edits_extracts_closure15(v: rt.Vec, r: rt.Range, items: rt.Iter, read: rt.u8, log: rt.RefCell): void { - let _12!: rt.u8; +export function spliced$iter_Chain_vec_IntoIter_edits_Tracked_iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure18_edits_extracts_closure15(v: rs.Vec, r: rs.Range, items: rs.Iter, read: rs.u8, log: rs.RefCell): void { + let _12!: rs.u8; let t!: Tracked.Tracked | undefined; - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(v, r, 8, rt.drop), items, false, true); - const _9: rt.u8 = rt.u8Rem(read, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(v, r, 8, rs.drop), items, false, true); + const _9: rs.u8 = rs.u8Rem(read, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if (rt.u8Rem(_12, 2) === 0) { - t = rt.iterToOption(s.next()); + if (rs.u8Rem(_12, 2) === 0) { + t = rs.iterToOption(s.next()); } else { - t = rt.iterToOption(s.nextBack()); + t = rs.iterToOption(s.nextBack()); } - const _24: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_24.value, 240); - rt.refMutRelease(_24); - rt.drop(t); + const _24: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_24.value, 240); + rs.refMutRelease(_24); + rs.drop(t); } - rt.drop(s); - const _32: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_32.value, 241); - rt.refMutRelease(_32); + rs.drop(s); + const _32: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_32.value, 241); + rs.refMutRelease(_32); } /** * `v.splice(r, items)`, read `read % 4` times from alternate ends and then dropped, each * step marked. */ -export function spliced$iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure16_edits_extracts_closure15(v: rt.Vec, r: rt.Range, items: rt.Iter, read: rt.u8, log: rt.RefCell): void { - let _12!: rt.u8; +export function spliced$iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure16_edits_extracts_closure15(v: rs.Vec, r: rs.Range, items: rs.Iter, read: rs.u8, log: rs.RefCell): void { + let _12!: rs.u8; let t!: Tracked.Tracked | undefined; - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(v, r, 8, rt.drop), items, false, true); - const _9: rt.u8 = rt.u8Rem(read, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(v, r, 8, rs.drop), items, false, true); + const _9: rs.u8 = rs.u8Rem(read, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if (rt.u8Rem(_12, 2) === 0) { - t = rt.iterToOption(s.next()); + if (rs.u8Rem(_12, 2) === 0) { + t = rs.iterToOption(s.next()); } else { - t = rt.iterToOption(s.nextBack()); + t = rs.iterToOption(s.nextBack()); } - const _24: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_24.value, 240); - rt.refMutRelease(_24); - rt.drop(t); + const _24: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_24.value, 240); + rs.refMutRelease(_24); + rs.drop(t); } - rt.drop(s); - const _32: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_32.value, 241); - rt.refMutRelease(_32); + rs.drop(s); + const _32: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_32.value, 241); + rs.refMutRelease(_32); } /** * `v.splice(r, items)`, read `read % 4` times from alternate ends and then dropped, each * step marked. */ -export function spliced$iter_Map_ops_Range_u8_edits_extracts_closure15(v: rt.Vec, r: rt.Range, items: rt.Iter, read: rt.u8, log: rt.RefCell): void { - let _12!: rt.u8; +export function spliced$iter_Map_ops_Range_u8_edits_extracts_closure15(v: rs.Vec, r: rs.Range, items: rs.Iter, read: rs.u8, log: rs.RefCell): void { + let _12!: rs.u8; let t!: Tracked.Tracked | undefined; - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(v, r, 8, rt.drop), items, true, true); - const _9: rt.u8 = rt.u8Rem(read, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(v, r, 8, rs.drop), items, true, true); + const _9: rs.u8 = rs.u8Rem(read, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if (rt.u8Rem(_12, 2) === 0) { - t = rt.iterToOption(s.next()); + if (rs.u8Rem(_12, 2) === 0) { + t = rs.iterToOption(s.next()); } else { - t = rt.iterToOption(s.nextBack()); + t = rs.iterToOption(s.nextBack()); } - const _24: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_24.value, 240); - rt.refMutRelease(_24); - rt.drop(t); + const _24: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_24.value, 240); + rs.refMutRelease(_24); + rs.drop(t); } - rt.drop(s); - const _32: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_32.value, 241); - rt.refMutRelease(_32); + rs.drop(s); + const _32: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_32.value, 241); + rs.refMutRelease(_32); } /** @@ -1526,291 +1526,291 @@ export function spliced$iter_Map_ops_Range_u8_edits_extracts_closure15(v: rt.Vec * splice by iterators whose lower bound is exact, short, or none. Each panics with std's * message past the end. */ -export function extracts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let i4!: rt.usize; - const _11: (a0: Tracked.Tracked[]) => rt.ByteVec = (v3: Tracked.Tracked[]): rt.ByteVec => { - return rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(v3), (t2: Tracked.Tracked): Uint8Array => { +export function extracts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let i4!: rs.usize; + const _11: (a0: Tracked.Tracked[]) => rs.ByteVec = (v3: Tracked.Tracked[]): rs.ByteVec => { + return rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(v3), (t2: Tracked.Tracked): Uint8Array => { return Uint8Array.of(t2.id, t2.copies); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); }; - const at: (a0: rt.usize) => rt.u8 = (i5: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i5), 0); + const at: (a0: rs.usize) => rs.u8 = (i5: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i5), 0); }; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const tracked: (a0: rt.u8) => Tracked.Tracked = (id: rt.u8): Tracked.Tracked => { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const tracked: (a0: rs.u8) => Tracked.Tracked = (id: rs.u8): Tracked.Tracked => { return new Tracked.Tracked(id, 0, log); }; - const mark: (a0: rt.u8) => undefined = (m: rt.u8): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_5.value, m); - rt.refMutRelease(_5); + const mark: (a0: rs.u8) => undefined = (m: rs.u8): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_5.value, m); + rs.refMutRelease(_5); }; - const _12: rt.u8 = rt.u8Rem(kind, 5); + const _12: rs.u8 = rs.u8Rem(kind, 5); if (_12 === 0) { - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 8), (_222: rt.u8): Tracked.Tracked => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 8), (_222: rs.u8): Tracked.Tracked => { return tracked(_222); }), undefined, 8, true); - const r: rt.Range = within(at(0), at(1), v.items.length); + const r: rs.Range = within(at(0), at(1), v.items.length); const captured2 = tracked(224); - const it: rt.Iter = rt.vecExtractIf(v, r, rt.closure((t5: Tracked.Tracked): boolean => { - const _715: rt.RefCell = rt.refCellBorrowMut(captured2.log); - rt.iterExtendBytes(_715.value, rt.iterSlice(Uint8Array.of(225, t5.id)), undefined, true); - rt.refMutRelease(_715); - t5.copies = rt.u8Add(t5.copies, 1); - return rt.u8Rem(t5.id, 3) === rt.u8Rem(captured2.id, 3); + const it: rs.Iter = rs.vecExtractIf(v, r, rs.closure((t5: Tracked.Tracked): boolean => { + const _715: rs.RefCell = rs.refCellBorrowMut(captured2.log); + rs.iterExtendBytes(_715.value, rs.iterSlice(Uint8Array.of(225, t5.id)), undefined, true); + rs.refMutRelease(_715); + t5.copies = rs.u8Add(t5.copies, 1); + return rs.u8Rem(t5.id, 3) === rs.u8Rem(captured2.id, 3); }, (): void => { captured2[Symbol.dispose](); })); - const _37: rt.u8 = rt.u8Rem(at(2), 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _37; + const _37: rs.u8 = rs.u8Rem(at(2), 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _37; while (iterStart++ < iterEnd) { - const t: Tracked.Tracked | undefined = rt.iterToOption(it.next()); + const t: Tracked.Tracked | undefined = rs.iterToOption(it.next()); mark(240); - rt.drop(t); + rs.drop(t); } - rt.drop(it); + rs.drop(it); mark(241); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v.items)), undefined, true); - rt.dropVec(v); - const _67: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_67.value)); - rt.refRelease(_67); - const w: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): rt.u16 => { - return _226 as rt.u16; + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v.items)), undefined, true); + rs.dropVec(v); + const _67: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_67.value)); + rs.refRelease(_67); + const w: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): rs.u16 => { + return _226 as rs.u16; }), undefined, 2, true); - const r2: rt.Range = within(at(3), at(4), w.items.length); - const it2: rt.Iter = rt.vecExtractIfMut(w, r2, (x: rt.Place): boolean => { - x.v = rt.u16Add(x.v, 256); + const r2: rs.Range = within(at(3), at(4), w.items.length); + const it2: rs.Iter = rs.vecExtractIfMut(w, r2, (x: rs.Place): boolean => { + x.v = rs.u16Add(x.v, 256); return (x.v & 1) === 1; }); - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 3; + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 3; while (iterStart2++ < iterEnd2) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtVecExtractIf(it2, f, rt.u16Debug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args2[0]])))), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it2, f, rs.u16Debug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0]])))), undefined, true); it2.next(); } - rt.drop(it2); + rs.drop(it2); for (const _108 of w.items) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_108)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_108)), undefined, true); } - const named2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_227: rt.u8): Named.Named => { - const b12: rt.u8 = _227; - return { id: b12 as rt.u16, name: text(rt.byteSliceFrom(Uint8Array.of(b12))) }; + const named2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_227: rs.u8): Named.Named => { + const b12: rs.u8 = _227; + return { id: b12 as rs.u16, name: text(rs.byteSliceFrom(Uint8Array.of(b12))) }; }), undefined, 16, true); - const taken: rt.Vec = rt.iterToVec(rt.vecExtractIf(named2, undefined, (n9: Named.Named): boolean => { + const taken: rs.Vec = rs.iterToVec(rs.vecExtractIf(named2, undefined, (n9: Named.Named): boolean => { n9.name = n9.name + "+"; - return rt.u16Rem(n9.id, 2) === 0; + return rs.u16Rem(n9.id, 2) === 0; }), "next", 16); - const iter4: rt.Iter = rt.iterChain(rt.iterSlice(named2.items), rt.iterSlice(taken.items)); + const iter4: rs.Iter = rs.iterChain(rs.iterSlice(named2.items), rs.iterSlice(taken.items)); while (true) { - const _130: Named.Named | rt.Done = iter4.next(); - if (_130 === rt.DONE) { + const _130: Named.Named | rs.Done = iter4.next(); + if (_130 === rs.DONE) { break; } put(out, _130.name); } - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const _140: rt.RangeFrom = new rt.RangeFrom(rt.usizeRem(at(5) as rt.usize, rt.usizeAdd(data.length, 1)), rt.usizeStep); - const it3: rt.Iter = rt.byteVecExtractIf(bytes, _140, (b13: rt.Place): boolean => { - b13.v = rt.u8WrappingAdd(b13.v, 1); - return rt.u8Rem(b13.v, 3) === 0; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const _140: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(5) as rs.usize, rs.usizeAdd(data.length, 1)), rs.usizeStep); + const it3: rs.Iter = rs.byteVecExtractIf(bytes, _140, (b13: rs.Place): boolean => { + b13.v = rs.u8WrappingAdd(b13.v, 1); + return rs.u8Rem(b13.v, 3) === 0; }); - const first: rt.u8 | undefined = rt.iterToOption(it3.next()); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtVecExtractIf(it3, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(first, f, rt.u8Debug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args4[0], args4[1]])))), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(it3, "next"))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); - rt.vecExtractIfMut(w, undefined, (x2: rt.Place): boolean => { - return rt.u16Rem(x2.v, 2) === 0; + const first: rs.u8 | undefined = rs.iterToOption(it3.next()); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecExtractIf(it3, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(first, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]])))), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(it3, "next"))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); + rs.vecExtractIfMut(w, undefined, (x2: rs.Place): boolean => { + return rs.u16Rem(x2.v, 2) === 0; }).next(); - rt.byteVecPush(out, w.items.length & 0xff); - rt.byteVecExtractIf(bytes, undefined, (b14: rt.Place): boolean => { - return rt.u8Rem(b14.v, 2) === 0; + rs.byteVecPush(out, w.items.length & 0xff); + rs.byteVecExtractIf(bytes, undefined, (b14: rs.Place): boolean => { + return rs.u8Rem(b14.v, 2) === 0; }).next(); - rt.byteVecPush(out, bytes.length & 0xff); + rs.byteVecPush(out, bytes.length & 0xff); if ((kind & 128) !== 0) { - const _199: rt.Range = picked(at(6), at(7), w.items.length); - rt.drop(rt.vecExtractIfMut(w, _199, (_228: rt.Place): boolean => { + const _199: rs.Range = picked(at(6), at(7), w.items.length); + rs.drop(rs.vecExtractIfMut(w, _199, (_228: rs.Place): boolean => { return true; })); } } else if (_12 === 1) { - const v2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_214: rt.u8): Tracked.Tracked => { + const v2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6), (_214: rs.u8): Tracked.Tracked => { return tracked(_214); }), undefined, 8, true); - const r3: rt.Range = within(at(0), at(1), v2.items.length); + const r3: rs.Range = within(at(0), at(1), v2.items.length); if ((kind & 32) !== 0) { r3.end = v2.items.length; } const owned2: Tracked.Tracked = tracked(224); - const n: rt.u8 = rt.u8Rem(at(2), 6); + const n: rs.u8 = rs.u8Rem(at(2), 6); const captured = owned2; - const make: (a0: rt.u8) => Tracked.Tracked = rt.closure((i6: rt.u8): Tracked.Tracked => { - const _713: rt.RefCell = rt.refCellBorrowMut(captured.log); - rt.iterExtendBytes(_713.value, rt.iterSlice(Uint8Array.of(225, i6)), undefined, true); - rt.refMutRelease(_713); - return new Tracked.Tracked(rt.u8Add(176, i6), 0, captured.log); + const make: (a0: rs.u8) => Tracked.Tracked = rs.closure((i6: rs.u8): Tracked.Tracked => { + const _713: rs.RefCell = rs.refCellBorrowMut(captured.log); + rs.iterExtendBytes(_713.value, rs.iterSlice(Uint8Array.of(225, i6)), undefined, true); + rs.refMutRelease(_713); + return new Tracked.Tracked(rs.u8Add(176, i6), 0, captured.log); }, (): void => { captured[Symbol.dispose](); }); - const read: rt.u8 = at(3); - const _240: rt.u8 = (kind >> 3) & 3; + const read: rs.u8 = at(3); + const _240: rs.u8 = (kind >> 3) & 3; if (!((kind & 64) !== 0)) { if (_240 === 0) { - const _254: rt.Range = r3; - const _255: rt.Iter = rt.iterMap(new rt.Range(0, n), make); + const _254: rs.Range = r3; + const _255: rs.Iter = rs.iterMap(new rs.Range(0, n), make); spliced$iter_Map_ops_Range_u8_edits_extracts_closure15(v2, _254, _255, read, log); } else if (_240 === 1) { - const _259: rt.Range = r3; - const _260: rt.Iter = rt.iterMap(rt.iterFilter(new rt.Range(0, n), (i9: rt.u8): boolean => { - return rt.u8Rem(i9, 2) === 0; + const _259: rs.Range = r3; + const _260: rs.Iter = rs.iterMap(rs.iterFilter(new rs.Range(0, n), (i9: rs.u8): boolean => { + return rs.u8Rem(i9, 2) === 0; }), make); spliced$iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure16_edits_extracts_closure15(v2, _259, _260, read, log); } else if (_240 === 2) { - const first2: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 3)), (i7: rt.u8): Tracked.Tracked => { - return tracked(rt.u8Add(192, i7)); + const first2: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(n, 3)), (i7: rs.u8): Tracked.Tracked => { + return tracked(rs.u8Add(192, i7)); }), undefined, 8, true); - const _272: rt.Range = r3; - const _273: rt.Iter = rt.iterChain(rt.vecIntoIter(first2, rt.drop), rt.iterMap(rt.iterFilter(new rt.Range(0, n), (i8: rt.u8): boolean => { - return rt.u8Rem(i8, 2) === 1; + const _272: rs.Range = r3; + const _273: rs.Iter = rs.iterChain(rs.vecIntoIter(first2, rs.drop), rs.iterMap(rs.iterFilter(new rs.Range(0, n), (i8: rs.u8): boolean => { + return rs.u8Rem(i8, 2) === 1; }), make)); spliced$iter_Chain_vec_IntoIter_edits_Tracked_iter_Map_iter_Filter_ops_Range_u8_edits_extracts_closure18_edits_extracts_closure15(v2, _272, _273, read, log); } else { - const items: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, n), make), "fold", 8, true); + const items: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, n), make), "fold", 8, true); spliced$Vec_edits_Tracked(v2, r3, items, read, log); } } else { - rt.drop(make); + rs.drop(make); spliced$edits_Hinted(v2, r3, { n, i: 0, log }, read, log); } - const start: rt.usize = rt.usizeRem(at(17) as rt.usize, rt.usizeAdd(v2.items.length, 1)); + const start: rs.usize = rs.usizeRem(at(17) as rs.usize, rs.usizeAdd(v2.items.length, 1)); mark(242); const _301: Held.Held = new Held.Held(start, tracked(113)); - const _305: rt.Result = rt.Err(tracked(119)); - rt.drop(rt.spliceFrom(rt.dropAfter(_301, (range) => rt.vecSplice(v2, rt.boundsOf(range, Held.startBound$ops_RangeBounds_usize, Held.endBound$ops_RangeBounds_usize), 8, rt.drop), rt.drop), rt.iterResult(_305, rt.drop, rt.drop), true, true)); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(v2.items)), undefined, true); - rt.dropVec(v2); - const _319: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_319.value)); - rt.refRelease(_319); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_216: rt.u8): rt.u16[] => { - return [_216 as rt.u16, 0]; + const _305: rs.Result = rs.Err(tracked(119)); + rs.drop(rs.spliceFrom(rs.dropAfter(_301, (range) => rs.vecSplice(v2, rs.boundsOf(range, Held.startBound$ops_RangeBounds_usize, Held.endBound$ops_RangeBounds_usize), 8, rs.drop), rs.drop), rs.iterResult(_305, rs.drop, rs.drop), true, true)); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(v2.items)), undefined, true); + rs.dropVec(v2); + const _319: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_319.value)); + rs.refRelease(_319); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_216: rs.u8): rs.u16[] => { + return [_216 as rs.u16, 0]; }), undefined, 4, true); - const fill: rt.u16[] = [7, 8]; - const r4: rt.Range = within(at(4), at(5), pairs.items.length); - const _337: rt.Iter = rt.iterMap(new rt.Range(0, rt.u8Rem(at(6), 4)), (_219: rt.u8): rt.u16[] => { + const fill: rs.u16[] = [7, 8]; + const r4: rs.Range = within(at(4), at(5), pairs.items.length); + const _337: rs.Iter = rs.iterMap(new rs.Range(0, rs.u8Rem(at(6), 4)), (_219: rs.u8): rs.u16[] => { return copy$array_u16(fill); }); - const s: rt.Iter = rt.spliceFrom(rt.vecSplice(pairs, r4, 4), _337, true); - const first3: rt.u16[] | undefined = rt.iterToOption(s.next()); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtVecSplice(s, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))), (f: rt.Formatter) => rt.fmtOption(first3, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args6[0], args6[1]])))), undefined, true); - const removed: rt.Vec = rt.iterToVec(rt.iterChain(rt.iterOption(copy$Option_array2_u16(first3)), s), "next", 4); - const iter5: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.iterSlice(pairs.items)); + const s: rs.Iter = rs.spliceFrom(rs.vecSplice(pairs, r4, 4), _337, true); + const first3: rs.u16[] | undefined = rs.iterToOption(s.next()); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))), (f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args6[0], args6[1]])))), undefined, true); + const removed: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterOption(copy$Option_array2_u16(first3)), s), "next", 4); + const iter5: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterSlice(pairs.items)); while (true) { - const _372: [rt.usize, rt.u16[]] | rt.Done = iter5.next(); - if (_372 === rt.DONE) { + const _372: [rs.usize, rs.u16[]] | rs.Done = iter5.next(); + if (_372 === rs.DONE) { break; } - const i: rt.usize = _372[0]; - const _378: rt.usize = rt.usizeRem(i, 2); + const i: rs.usize = _372[0]; + const _378: rs.usize = rs.usizeRem(i, 2); if (!(_378 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _378); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _378); } - _372[1][_378] = rt.u16Add(_372[1][_378], i & 0xffff); + _372[1][_378] = rs.u16Add(_372[1][_378], i & 0xffff); } - const iter6: rt.Iter = rt.iterFlatten(rt.iterChain(rt.iterSlice(pairs.items), rt.iterSlice(removed.items)), (value: rt.u16[]) => rt.iterSlice(value), true, 2); + const iter6: rs.Iter = rs.iterFlatten(rs.iterChain(rs.iterSlice(pairs.items), rs.iterSlice(removed.items)), (value: rs.u16[]) => rs.iterSlice(value), true, 2); while (true) { - const _390: rt.u16 | rt.Done = iter6.next(); - if (_390 === rt.DONE) { + const _390: rs.u16 | rs.Done = iter6.next(); + if (_390 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_390)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_390)), undefined, true); } - const bytes2: rt.ByteVec = rt.byteSliceToByteVec(data); - const r5: rt.Range = within(at(7), at(8), bytes2.length); - const _409: rt.Iter = rt.iterFilter(rt.iterTake(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.u8Rem(at(9), 8) as rt.usize), (b9: rt.u8): boolean => { - return rt.u8Rem(b9, 2) === 0; + const bytes2: rs.ByteVec = rs.byteSliceToByteVec(data); + const r5: rs.Range = within(at(7), at(8), bytes2.length); + const _409: rs.Iter = rs.iterFilter(rs.iterTake(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.u8Rem(at(9), 8) as rs.usize), (b9: rs.u8): boolean => { + return rs.u8Rem(b9, 2) === 0; }); - const s2: rt.Iter = rt.spliceFrom(rt.byteVecSplice(bytes2, r5), _409); - const back: rt.u8 | undefined = rt.iterToOption(s2.nextBack()); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtVecSplice(s2, f, rt.u8Debug, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtCounted(value, f, "Take", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args8[0]])))), undefined, true); - rt.drop(s2); - rt.iterExtendBytes(out, rt.iterOption(back), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes2)); - const tail: rt.ByteVec = rt.byteSliceToByteVec(data); - const _453: rt.RangeFrom = new rt.RangeFrom(rt.usizeRem(at(10) as rt.usize, rt.usizeAdd(tail.length, 1)), rt.usizeStep); + const s2: rs.Iter = rs.spliceFrom(rs.byteVecSplice(bytes2, r5), _409); + const back: rs.u8 | undefined = rs.iterToOption(s2.nextBack()); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s2, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtCounted(value, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args8[0]])))), undefined, true); + rs.drop(s2); + rs.iterExtendBytes(out, rs.iterOption(back), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes2)); + const tail: rs.ByteVec = rs.byteSliceToByteVec(data); + const _453: rs.RangeFrom = new rs.RangeFrom(rs.usizeRem(at(10) as rs.usize, rs.usizeAdd(tail.length, 1)), rs.usizeStep); const _454: Uint8Array = Uint8Array.of(170, 187); - const s3: rt.Iter = rt.spliceFrom(rt.byteVecSplice(tail, _453), rt.iterSlice(_454), true); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtVecSplice(s3, f, rt.u8Debug, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["IntoIter"]))]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args10[0]])))), undefined, true); - rt.iterExtendBytes(out, rt.iterRev(s3), "next"); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(tail)); - const hints: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const units: rt.Vec = rt.vecFromElem(undefined, rt.u8Rem(at(13), 4) as rt.usize, undefined); - const r6: rt.Range = within(at(14), at(15), units.items.length); - const _493: Units.Units = { n: rt.u8Rem(at(16), 5), log: hints }; - rt.drop(rt.spliceFrom(rt.vecSplice(units, r6, 0), rt.iterFrom(_493, Units.next$iter_Iterator, undefined, { hint: Units.sizeHint$iter_Iterator }))); - rt.byteVecPush(out, units.items.length & 0xff); - const _508: rt.RefCell = rt.refCellBorrow(hints); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_508.value)); - rt.refRelease(_508); + const s3: rs.Iter = rs.spliceFrom(rs.byteVecSplice(tail, _453), rs.iterSlice(_454), true); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtVecSplice(s3, f, rs.u8Debug, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"]))]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args10[0]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterRev(s3), "next"); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tail)); + const hints: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const units: rs.Vec = rs.vecFromElem(undefined, rs.u8Rem(at(13), 4) as rs.usize, undefined); + const r6: rs.Range = within(at(14), at(15), units.items.length); + const _493: Units.Units = { n: rs.u8Rem(at(16), 5), log: hints }; + rs.drop(rs.spliceFrom(rs.vecSplice(units, r6, 0), rs.iterFrom(_493, Units.next$iter_Iterator, undefined, { hint: Units.sizeHint$iter_Iterator }))); + rs.byteVecPush(out, units.items.length & 0xff); + const _508: rs.RefCell = rs.refCellBorrow(hints); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_508.value)); + rs.refRelease(_508); if ((kind & 128) !== 0) { - const _515: rt.Range = picked(at(11), at(12), tail.length); - rt.drop(rt.spliceFrom(rt.byteVecSplice(tail, _515), rt.iterSlice(Uint8Array.of()), true)); + const _515: rs.Range = picked(at(11), at(12), tail.length); + rs.drop(rs.spliceFrom(rs.byteVecSplice(tail, _515), rs.iterSlice(Uint8Array.of()), true)); } } else if (_12 === 2) { - const flat: rt.Vec = rt.vecIntoFlattened(rt.iterToVec(rt.iterMap(rt.iterTake(rt.byteSliceChunksExact(data, 2), 3), (c: rt.ByteSlice): Tracked.Tracked[] => { - rt.idx(c, 0); + const flat: rs.Vec = rs.vecIntoFlattened(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Tracked.Tracked[] => { + rs.idx(c, 0); const _315: Tracked.Tracked = tracked(c.data[c.start]); - rt.idx(c, 1); + rs.idx(c, 1); return [_315, tracked(c.data[c.start + 1])]; }), undefined, 16, true), 2, 8); mark(240); - const _536: rt.usize = rt.u8Rem(at(0), 4) as rt.usize; - rt.vecTruncate(flat, _536, rt.drop); + const _536: rs.usize = rs.u8Rem(at(0), 4) as rs.usize; + rs.vecTruncate(flat, _536, rs.drop); mark(241); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(flat.items)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(flat.items)), undefined, true); const leaked: Tracked.Tracked[] = flat.items; - const _553: Tracked.Tracked | undefined = rt.sliceFirst(leaked); + const _553: Tracked.Tracked | undefined = rs.sliceFirst(leaked); if (_553 !== undefined) { - _553.copies = rt.u8Add(_553.copies, 5); - } - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(leaked)), undefined, true); - const _566: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_566.value)); - rt.refRelease(_566); - const flat2: rt.Vec = rt.vecIntoFlattened(rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 3), (c2: rt.ByteSlice): rt.u16[] => { - rt.idx(c2, 0); - const _318: rt.u16 = c2.data[c2.start] as rt.u16; - rt.idx(c2, 1); - const _87: rt.u16 = c2.data[c2.start + 1] as rt.u16; - rt.idx(c2, 2); - return [_318, _87, c2.data[c2.start + 2] as rt.u16]; + _553.copies = rs.u8Add(_553.copies, 5); + } + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(leaked)), undefined, true); + const _566: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_566.value)); + rs.refRelease(_566); + const flat2: rs.Vec = rs.vecIntoFlattened(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 3), (c2: rs.ByteSlice): rs.u16[] => { + rs.idx(c2, 0); + const _318: rs.u16 = c2.data[c2.start] as rs.u16; + rs.idx(c2, 1); + const _87: rs.u16 = c2.data[c2.start + 1] as rs.u16; + rs.idx(c2, 2); + return [_318, _87, c2.data[c2.start + 2] as rs.u16]; }), undefined, 6, true), 3, 2); - const iter7: rt.Iter<[rt.usize, rt.Place]> = rt.iterStepBy(rt.iterEnumerate(rt.iterSliceMut(flat2.items)), 2); + const iter7: rs.Iter<[rs.usize, rs.Place]> = rs.iterStepBy(rs.iterEnumerate(rs.iterSliceMut(flat2.items)), 2); while (true) { - const _579: [rt.usize, rt.Place] | rt.Done = iter7.next(); - if (_579 === rt.DONE) { + const _579: [rs.usize, rs.Place] | rs.Done = iter7.next(); + if (_579 === rs.DONE) { break; } - _579[1].v = rt.u16Add(_579[1].v, _579[0] & 0xffff); + _579[1].v = rs.u16Add(_579[1].v, _579[0] & 0xffff); } for (const _589 of flat2.items) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_589)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_589)), undefined, true); } - const flat3: rt.Vec = rt.vecIntoFlattened(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_29: rt.u8): Named.Named[] => { - const b5: rt.u8 = _29; - const n8: Named.Named = { id: b5 as rt.u16, name: text(rt.byteSliceFrom(Uint8Array.of(b5))) }; + const flat3: rs.Vec = rs.vecIntoFlattened(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_29: rs.u8): Named.Named[] => { + const b5: rs.u8 = _29; + const n8: Named.Named = { id: b5 as rs.u16, name: text(rs.byteSliceFrom(Uint8Array.of(b5))) }; return [Named.clone$Clone(n8), n8]; }), undefined, 32, true), 2, 16); - const iter9: rt.Iter = rt.iterStepBy(rt.iterSlice(flat3.items), 2); + const iter9: rs.Iter = rs.iterStepBy(rs.iterSlice(flat3.items), 2); while (true) { - const _607: Named.Named | rt.Done = iter9.next(); - if (_607 === rt.DONE) { + const _607: Named.Named | rs.Done = iter9.next(); + if (_607 === rs.DONE) { break; } _607.name = _607.name + "!"; @@ -1818,159 +1818,159 @@ export function extracts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void for (const _616 of flat3.items) { put(out, _616.name); } - const flat4: rt.ByteVec = rt.byteVecIntoFlattened(rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c3: rt.ByteSlice): Uint8Array => { - rt.idx(c3, 0); - const _320: rt.u8 = c3.data[c3.start]; - rt.idx(c3, 1); + const flat4: rs.ByteVec = rs.byteVecIntoFlattened(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c3: rs.ByteSlice): Uint8Array => { + rs.idx(c3, 0); + const _320: rs.u8 = c3.data[c3.start]; + rs.idx(c3, 1); return Uint8Array.of(_320, c3.data[c3.start + 1]); }), undefined, 2, true), 2); - rt.byteVecPush(flat4, 204); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(flat4)); - const leaked2: rt.u16[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(flat4))), (_213: rt.u8): rt.u16 => { - return _213 as rt.u16; + rs.byteVecPush(flat4, 204); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(flat4)); + const leaked2: rs.u16[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(flat4))), (_213: rs.u8): rs.u16 => { + return _213 as rs.u16; }), undefined, 2, true).items; leaked2.reverse(); - const _639: rt.Place | undefined = rt.sliceFirstMut(leaked2); + const _639: rs.Place | undefined = rs.sliceFirstMut(leaked2); if (_639 !== undefined) { _639.v = _639.v ^ 65535; } - const iter11: rt.Iter = rt.iterSlice(leaked2); + const iter11: rs.Iter = rs.iterSlice(leaked2); while (true) { - const _646: rt.u16 | rt.Done = iter11.next(); - if (_646 === rt.DONE) { + const _646: rs.u16 | rs.Done = iter11.next(); + if (_646 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_646)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_646)), undefined, true); } - const leaked3: rt.ByteSlice = rt.byteVecSlice(flat4); - rt.byteSliceRotateLeft(leaked3, rt.usizeDiv(leaked3.length, 2)); - rt.byteVecExtendFromSlice(out, leaked3); + const leaked3: rs.ByteSlice = rs.byteVecSlice(flat4); + rs.byteSliceRotateLeft(leaked3, rs.usizeDiv(leaked3.length, 2)); + rs.byteVecExtendFromSlice(out, leaked3); } else if (_12 === 3) { - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 7), (_25: rt.u8): Tracked.Tracked => { + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 7), (_25: rs.u8): Tracked.Tracked => { return tracked(_25); - }), undefined, 8, true), 8) as rt.VecDeque; - const _670: rt.u8 = at(0); + }), undefined, 8, true), 8) as rs.VecDeque; + const _670: rs.u8 = at(0); wrap$edits_Tracked(q, _670); const part2 = at(1); const probe: Tracked.Tracked = tracked(part2); - const found: rt.Result = rt.dequeBinarySearchByKey(q, probe, (t3: Tracked.Tracked): Tracked.Tracked => { - const _63: rt.RefCell = rt.refCellBorrowMut(t3.log); - rt.iterExtendBytes(_63.value, rt.iterSlice(Uint8Array.of(225, t3.id)), undefined, true); - rt.refMutRelease(_63); + const found: rs.Result = rs.dequeBinarySearchByKey(q, probe, (t3: Tracked.Tracked): Tracked.Tracked => { + const _63: rs.RefCell = rs.refCellBorrowMut(t3.log); + rs.iterExtendBytes(_63.value, rs.iterSlice(Uint8Array.of(225, t3.id)), undefined, true); + rs.refMutRelease(_63); return new Tracked.Tracked(t3.id, 9, t3.log); - }, Tracked.cmp$cmp_Ord, rt.drop); + }, Tracked.cmp$cmp_Ord, rs.drop); mark(240); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(found, f, rt.usizeDebug, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args12[0]])))), undefined, true); - const part3 = rt.dequeBinarySearch(q, probe, Tracked.cmp$cmp_Ord); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part3, f, rt.usizeDebug, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args14[0]])))), undefined, true); - rt.byteVecPush(out, rt.dequePartitionPoint(q, (t4: Tracked.Tracked): boolean => { + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found, f, rs.usizeDebug, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args12[0]])))), undefined, true); + const part3 = rs.dequeBinarySearch(q, probe, Tracked.cmp$cmp_Ord); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.usizeDebug, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args14[0]])))), undefined, true); + rs.byteVecPush(out, rs.dequePartitionPoint(q, (t4: Tracked.Tracked): boolean => { return t4.id < probe.id; }) & 0xff); - const n2: rt.usize = q.n; - const _722: rt.usize = rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(n2, 1)); - rt.dequeRotate(q, _722); - const _732: rt.usize = rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(n2, 1)); - rt.dequeRotate(q, _732, true); + const n2: rs.usize = q.n; + const _722: rs.usize = rs.usizeRem(at(2) as rs.usize, rs.usizeAdd(n2, 1)); + rs.dequeRotate(q, _722); + const _732: rs.usize = rs.usizeRem(at(3) as rs.usize, rs.usizeAdd(n2, 1)); + rs.dequeRotate(q, _732, true); if (n2 > 0) { - const _743: rt.usize = rt.usizeRem(at(4) as rt.usize, n2); - const _749: rt.usize = rt.usizeRem(at(5) as rt.usize, n2); - rt.dequeSwap(q, _743, _749); + const _743: rs.usize = rs.usizeRem(at(4) as rs.usize, n2); + const _749: rs.usize = rs.usizeRem(at(5) as rs.usize, n2); + rs.dequeSwap(q, _743, _749); } - for (const _759 of rt.dequeMakeContiguous(q)) { - _759.copies = rt.u8Add(_759.copies, 1); + for (const _759 of rs.dequeMakeContiguous(q)) { + _759.copies = rs.u8Add(_759.copies, 1); } - const _766: [Tracked.Tracked[], Tracked.Tracked[]] = rt.dequeAsSlices(q); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(_766[0])), undefined, true); - rt.byteVecPush(out, 254); - rt.iterExtendBytes(out, rt.byteVecIntoIter(_11(_766[1])), undefined, true); + const _766: [Tracked.Tracked[], Tracked.Tracked[]] = rs.dequeAsSlices(q); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(_766[0])), undefined, true); + rs.byteVecPush(out, 254); + rs.iterExtendBytes(out, rs.byteVecIntoIter(_11(_766[1])), undefined, true); mark(241); probe[Symbol.dispose](); - rt.dequeDrop(q, rt.drop); - const _784: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_784.value)); - rt.refRelease(_784); - const q2: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.u16 => { - return _28 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; - const n3: rt.usize = q2.n; - const _792: rt.u8 = (kind >> 3) & 3; + rs.dequeDrop(q, rs.drop); + const _784: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_784.value)); + rs.refRelease(_784); + const q2: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.u16 => { + return _28 as rs.u16; + }), undefined, 2, true), 2) as rs.VecDeque; + const n3: rs.usize = q2.n; + const _792: rs.u8 = (kind >> 3) & 3; if (!((kind & 128) === 0)) { if (_792 === 0) { - const _799: rt.usize = rt.usizeAdd(n3, rt.u8Rem(at(6), 2) as rt.usize); - rt.dequeRotate(q2, _799); + const _799: rs.usize = rs.usizeAdd(n3, rs.u8Rem(at(6), 2) as rs.usize); + rs.dequeRotate(q2, _799); } else if (_792 === 1) { - const _808: rt.usize = rt.usizeAdd(n3, rt.u8Rem(at(6), 2) as rt.usize); - rt.dequeRotate(q2, _808, true); + const _808: rs.usize = rs.usizeAdd(n3, rs.u8Rem(at(6), 2) as rs.usize); + rs.dequeRotate(q2, _808, true); } else if (_792 === 2) { - const _817: rt.usize = rt.min(n3, at(6) as rt.usize); - rt.dequeSwap(q2, _817, 0); + const _817: rs.usize = rs.min(n3, at(6) as rs.usize); + rs.dequeSwap(q2, _817, 0); } else { - const _823: rt.usize = rt.min(n3, at(6) as rt.usize); - rt.dequeSwap(q2, 0, _823); + const _823: rs.usize = rs.min(n3, at(6) as rs.usize); + rs.dequeSwap(q2, 0, _823); } } - rt.byteVecPush(out, q2.n & 0xff); + rs.byteVecPush(out, q2.n & 0xff); } else { - const q3: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return _2 as rt.u16; - }), undefined, 2, true), 2) as rt.VecDeque; - const _837: rt.u8 = at(0); + const q3: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return _2 as rs.u16; + }), undefined, 2, true), 2) as rs.VecDeque; + const _837: rs.u8 = at(0); wrap$u16(q3, _837); - rt.dequePushFront(q3, 511); - const iter13: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.dequeMakeContiguous(q3))); + rs.dequePushFront(q3, 511); + const iter13: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.dequeMakeContiguous(q3))); while (true) { - const _848: [rt.usize, rt.Place] | rt.Done = iter13.next(); - if (_848 === rt.DONE) { + const _848: [rs.usize, rs.Place] | rs.Done = iter13.next(); + if (_848 === rs.DONE) { break; } - _848[1].v = rt.u16Add(_848[1].v, _848[0] & 0xffff); + _848[1].v = rs.u16Add(_848[1].v, _848[0] & 0xffff); } - rt.dequeRotate(q3, rt.usizeDiv(q3.n, 3), true); - const iter14: rt.Iter = rt.dequeIter(q3); + rs.dequeRotate(q3, rs.usizeDiv(q3.n, 3), true); + const iter14: rs.Iter = rs.dequeIter(q3); while (true) { - const _864: rt.u16 | rt.Done = iter14.next(); - if (_864 === rt.DONE) { + const _864: rs.u16 | rs.Done = iter14.next(); + if (_864 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_864)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_864)), undefined, true); } - const bytes4: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), 1, true) as rt.VecDeque; - const _876: rt.u8 = at(1); + const bytes4: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), 1, true) as rs.VecDeque; + const _876: rs.u8 = at(1); wrap$u8(bytes4, _876); - rt.dequePushFront(bytes4, 221); - rt.byteSliceView(rt.dequeByteMakeContiguous(bytes4)).reverse(); - rt.dequeRotate(bytes4, rt.usizeDiv(bytes4.n, 2)); + rs.dequePushFront(bytes4, 221); + rs.byteSliceView(rs.dequeByteMakeContiguous(bytes4)).reverse(); + rs.dequeRotate(bytes4, rs.usizeDiv(bytes4.n, 2)); if (bytes4.n > 1) { - rt.dequeSwap(bytes4, 0, rt.usizeSub(bytes4.n, 1)); - } - rt.iterExtendBytes(out, rt.dequeIter(bytes4), undefined, true); - const _904: [rt.ByteSlice, rt.ByteSlice] = rt.dequeByteSlices(bytes4); - rt.byteVecPush(out, _904[0].length & 0xff); - rt.byteVecPush(out, _904[1].length & 0xff); - const named4: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_22: rt.u8): Named.Named => { - const b2: rt.u8 = _22; - return { id: b2 as rt.u16, name: text(rt.byteSliceFrom(Uint8Array.of(b2))) }; - }), undefined, 16, true), 16) as rt.VecDeque; - const _918: rt.u8 = at(2); + rs.dequeSwap(bytes4, 0, rs.usizeSub(bytes4.n, 1)); + } + rs.iterExtendBytes(out, rs.dequeIter(bytes4), undefined, true); + const _904: [rs.ByteSlice, rs.ByteSlice] = rs.dequeByteSlices(bytes4); + rs.byteVecPush(out, _904[0].length & 0xff); + rs.byteVecPush(out, _904[1].length & 0xff); + const named4: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6), (_22: rs.u8): Named.Named => { + const b2: rs.u8 = _22; + return { id: b2 as rs.u16, name: text(rs.byteSliceFrom(Uint8Array.of(b2))) }; + }), undefined, 16, true), 16) as rs.VecDeque; + const _918: rs.u8 = at(2); wrap$edits_Named(named4, _918); - rt.sliceSort(rt.dequeMakeContiguous(named4), rt.keyLt((n4: Named.Named): rt.u16 => { + rs.sliceSort(rs.dequeMakeContiguous(named4), rs.keyLt((n4: Named.Named): rs.u16 => { return n4.id; - }, rt.lt), 16, true); - const probe2: rt.u16 = at(3) as rt.u16; - const part = rt.dequeBinarySearchBy(named4, (n5: Named.Named): rt.Ordering => { - return rt.cmp(n5.id, probe2); + }, rs.lt), 16, true); + const probe2: rs.u16 = at(3) as rs.u16; + const part = rs.dequeBinarySearchBy(named4, (n5: Named.Named): rs.Ordering => { + return rs.cmp(n5.id, probe2); }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part, f, rt.usizeDebug, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args16[0]])))), undefined, true); - const _947: string = text(rt.byteSliceFrom(Uint8Array.of(at(3)))); - const found4: rt.Result = rt.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): string => { + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part, f, rs.usizeDebug, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args16[0]])))), undefined, true); + const _947: string = text(rs.byteSliceFrom(Uint8Array.of(at(3)))); + const found4: rs.Result = rs.dequeBinarySearchByKey(named4, _947, (n6: Named.Named): string => { return n6.name; - }, rt.cmpStr); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(found4, f, rt.usizeDebug, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args18[0]])))), undefined, true); - rt.byteVecPush(out, rt.dequePartitionPoint(named4, (n7: Named.Named): boolean => { + }, rs.cmpStr); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(found4, f, rs.usizeDebug, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args18[0]])))), undefined, true); + rs.byteVecPush(out, rs.dequePartitionPoint(named4, (n7: Named.Named): boolean => { return n7.id <= probe2; }) & 0xff); if (found4.ok) { @@ -1978,14 +1978,14 @@ export function extracts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { i4 = found4.error; } - const _974: Named.Named | undefined = rt.dequeGet(named4, i4); + const _974: Named.Named | undefined = rs.dequeGet(named4, i4); if (_974 !== undefined) { _974.name = _974.name + "?"; } - const iter15: rt.Iter = rt.dequeIter(named4); + const iter15: rs.Iter = rs.dequeIter(named4); while (true) { - const _984: Named.Named | rt.Done = iter15.next(); - if (_984 === rt.DONE) { + const _984: Named.Named | rs.Done = iter15.next(); + if (_984 === rs.DONE) { break; } put(out, _984.name); diff --git a/ts/fixtures/lang/edits/expected/harness.ts b/ts/fixtures/lang/edits/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/edits/expected/harness.ts +++ b/ts/fixtures/lang/edits/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/edits/expected/lib.ts b/ts/fixtures/lang/edits/expected/lib.ts index 93ad2e234..f226cafa9 100644 --- a/ts/fixtures/lang/edits/expected/lib.ts +++ b/ts/fixtures/lang/edits/expected/lib.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { edits, bytes, values, resizes, extracts } from "./edits.ts"; -export function copy$Option_array2_u16(v: rt.u16[] | undefined): rt.u16[] | undefined { +export function copy$Option_array2_u16(v: rs.u16[] | undefined): rs.u16[] | undefined { return v === undefined ? v : copy$array_u16(v); } -export function copy$array_u16(v: rt.u16[]): rt.u16[] { +export function copy$array_u16(v: rs.u16[]): rs.u16[] { return v.slice(); } @@ -15,7 +15,7 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } @@ -23,8 +23,8 @@ export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["edits::edits", edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::bytes", bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::values", values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::resizes", resizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["edits::extracts", extracts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["edits::edits", edits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["edits::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["edits::values", values as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["edits::resizes", resizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["edits::extracts", extracts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/edits/src/edits.rs b/ts/fixtures/lang/edits/src/edits.rs index 043cd6c6a..316dd2896 100644 --- a/ts/fixtures/lang/edits/src/edits.rs +++ b/ts/fixtures/lang/edits/src/edits.rs @@ -371,7 +371,7 @@ pub fn edits(kind: u8, data: &[u8], out: &mut Vec) { } } -/// [`edits`]'s methods of bytes, which are an `rt.ByteVec` or `rt.ByteSlice` rather than an +/// [`edits`]'s methods of bytes, which are an `rs.ByteVec` or `rs.ByteSlice` rather than an /// array, on every short prefix of the input and on a slice that starts past its storage's, /// and those that lend a closure another element JS copies, as its place. pub fn bytes(kind: u8, data: &[u8], out: &mut Vec) { @@ -726,7 +726,7 @@ fn wrap(q: &mut VecDeque, n: u8) { /// `extend_from_within`: which values clone, in order, and when each removed one drops, /// against a closure that owns one; whether a value written after it is shared with /// another, of objects and of arrays and tuples JS holds by reference; bytes, which are an -/// `rt.ByteVec`; `Vec::from` of a deque; and a deque's `range_mut` of items JS copies. Each +/// `rs.ByteVec`; `Vec::from` of a deque; and a deque's `range_mut` of items JS copies. Each /// panics with std's message past the end. pub fn resizes(kind: u8, data: &[u8], out: &mut Vec) { let at = |i: usize| data.get(i).copied().unwrap_or(0); diff --git a/ts/fixtures/lang/elements/expected/core/bool.ts b/ts/fixtures/lang/elements/expected/core/bool.ts index 92f51ca46..12daf914b 100644 --- a/ts/fixtures/lang/elements/expected/core/bool.ts +++ b/ts/fixtures/lang/elements/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$03chm1q(self: boolean, t: [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function thenSome$06c3xh5(self: boolean, t: [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/elements/expected/core/option.ts b/ts/fixtures/lang/elements/expected/core/option.ts index 2a5f005a2..37d0b1d08 100644 --- a/ts/fixtures/lang/elements/expected/core/option.ts +++ b/ts/fixtures/lang/elements/expected/core/option.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1fmzefe(self: rt.u8 | undefined, f: (a0: rt.u8) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$1pv2dfs(self: rs.u8 | undefined, f: (a0: rs.u8) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$0grxkdu(self: rt.u32[] | undefined, default_: rt.u32, f: (a0: rt.u32[]) => rt.u32): rt.u32 { +export function mapOr$17byac0(self: rs.u32[] | undefined, default_: rs.u32, f: (a0: rs.u32[]) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1nlkf9b(self: [rt.u8, rt.u8] | undefined, default_: Uint8Array, f: (a0: [rt.u8, rt.u8]) => Uint8Array): Uint8Array { +export function mapOr$13kt6x8(self: [rs.u8, rs.u8] | undefined, default_: Uint8Array, f: (a0: [rs.u8, rs.u8]) => Uint8Array): Uint8Array { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/elements/expected/elements.Inline.ts b/ts/fixtures/lang/elements/expected/elements.Inline.ts index b5c7daf82..f2786ee76 100644 --- a/ts/fixtures/lang/elements/expected/elements.Inline.ts +++ b/ts/fixtures/lang/elements/expected/elements.Inline.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$mem_MaybeUninit_array_Option_tuple2_u8_u8 } from "./lib.ts"; /** @@ -8,101 +8,101 @@ import { copy$Option_tuple2_u8_u8, copy$mem_MaybeUninit_array_Option_tuple2_u8_u * inserted and removed by moving the rest through pointers, and dropped in place. */ export class Inline { - len: rt.usize; - items: rt.ArrayOf; + len: rs.usize; + items: rs.ArrayOf; - constructor(len: rt.usize, items: rt.ArrayOf) { + constructor(len: rs.usize, items: rs.ArrayOf) { this.len = len; this.items = items; } } -export function new$Option_tuple2_u8_u8(): Inline<[rt.u8, rt.u8] | undefined> { - return new Inline(0, copy$mem_MaybeUninit_array_Option_tuple2_u8_u8((new Array(4) as unknown) as Array<[rt.u8, rt.u8] | undefined>)); +export function new$Option_tuple2_u8_u8(): Inline<[rs.u8, rs.u8] | undefined> { + return new Inline(0, copy$mem_MaybeUninit_array_Option_tuple2_u8_u8((new Array(4) as unknown) as Array<[rs.u8, rs.u8] | undefined>)); } -export function new$sync_Arc_u8(): Inline> { - return new Inline(0, (new Array(4) as unknown) as rt.Arc[]); +export function new$sync_Arc_u8(): Inline> { + return new Inline(0, (new Array(4) as unknown) as rs.Arc[]); } -export function ptr$Option_tuple2_u8_u8(self: Inline<[rt.u8, rt.u8] | undefined>): rt.Place<[rt.u8, rt.u8] | undefined> { - return rt.sliceAsPtr(self.items as Array<[rt.u8, rt.u8] | undefined>); +export function ptr$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>): rs.Place<[rs.u8, rs.u8] | undefined> { + return rs.sliceAsPtr(self.items as Array<[rs.u8, rs.u8] | undefined>); } -export function ptr$sync_Arc_u8(self: Inline>): rt.Place> { - return rt.sliceAsPtr(self.items as rt.Arc[]); +export function ptr$sync_Arc_u8(self: Inline>): rs.Place> { + return rs.sliceAsPtr(self.items as rs.Arc[]); } -export function asSlice$Option_tuple2_u8_u8(self: Inline<[rt.u8, rt.u8] | undefined>): Array<[rt.u8, rt.u8] | undefined> { - return rt.ptrSlice(rt.sliceAsPtr(self.items as Array<[rt.u8, rt.u8] | undefined>), self.len); +export function asSlice$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>): Array<[rs.u8, rs.u8] | undefined> { + return rs.ptrSlice(rs.sliceAsPtr(self.items as Array<[rs.u8, rs.u8] | undefined>), self.len); } -export function asSlice$sync_Arc_u8(self: Inline>): rt.Arc[] { - return rt.ptrSlice(rt.sliceAsPtr(self.items as rt.Arc[]), self.len); +export function asSlice$sync_Arc_u8(self: Inline>): rs.Arc[] { + return rs.ptrSlice(rs.sliceAsPtr(self.items as rs.Arc[]), self.len); } -export function insert$Option_tuple2_u8_u8(self: Inline<[rt.u8, rt.u8] | undefined>, at: rt.usize, value: [rt.u8, rt.u8] | undefined): void { +export function insert$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>, at: rs.usize, value: [rs.u8, rs.u8] | undefined): void { if (self.len < 4) { if (at <= self.len) { - const len: rt.usize = self.len; - const p: rt.Place<[rt.u8, rt.u8] | undefined> = rt.ptrAdd(ptr$Option_tuple2_u8_u8(self), at); - rt.ptrCopy(p, rt.ptrAdd(p, 1), rt.usizeSub(len, at), copy$Option_tuple2_u8_u8); + const len: rs.usize = self.len; + const p: rs.Place<[rs.u8, rs.u8] | undefined> = rs.ptrAdd(ptr$Option_tuple2_u8_u8(self), at); + rs.ptrCopy(p, rs.ptrAdd(p, 1), rs.usizeSub(len, at), copy$Option_tuple2_u8_u8); p.v = copy$Option_tuple2_u8_u8(value); - self.len = rt.usizeAdd(self.len, 1); + self.len = rs.usizeAdd(self.len, 1); return; } } - rt.panic("assertion failed: self.len < 4 && at <= self.len"); + rs.panic("assertion failed: self.len < 4 && at <= self.len"); } -export function insert$sync_Arc_u8(self: Inline>, at: rt.usize, value: rt.Arc): void { +export function insert$sync_Arc_u8(self: Inline>, at: rs.usize, value: rs.Arc): void { if (self.len < 4) { if (at <= self.len) { - const len: rt.usize = self.len; - const p: rt.Place> = rt.ptrAdd(ptr$sync_Arc_u8(self), at); - rt.ptrCopy(p, rt.ptrAdd(p, 1), rt.usizeSub(len, at)); + const len: rs.usize = self.len; + const p: rs.Place> = rs.ptrAdd(ptr$sync_Arc_u8(self), at); + rs.ptrCopy(p, rs.ptrAdd(p, 1), rs.usizeSub(len, at)); p.v = value; - self.len = rt.usizeAdd(self.len, 1); + self.len = rs.usizeAdd(self.len, 1); return; } } - rt.panic("assertion failed: self.len < 4 && at <= self.len"); + rs.panic("assertion failed: self.len < 4 && at <= self.len"); } -export function remove$Option_tuple2_u8_u8(self: Inline<[rt.u8, rt.u8] | undefined>, at: rt.usize): [rt.u8, rt.u8] | undefined { +export function remove$Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>, at: rs.usize): [rs.u8, rs.u8] | undefined { if (!(at < self.len)) { - rt.panic("assertion failed: at < self.len"); + rs.panic("assertion failed: at < self.len"); } else { - self.len = rt.usizeSub(self.len, 1); - const len: rt.usize = self.len; - const p: rt.Place<[rt.u8, rt.u8] | undefined> = rt.ptrAdd(ptr$Option_tuple2_u8_u8(self), at); - const value: [rt.u8, rt.u8] | undefined = copy$Option_tuple2_u8_u8(p.v); - rt.ptrCopy(rt.ptrAdd(p, 1), p, rt.usizeSub(len, at), copy$Option_tuple2_u8_u8); + self.len = rs.usizeSub(self.len, 1); + const len: rs.usize = self.len; + const p: rs.Place<[rs.u8, rs.u8] | undefined> = rs.ptrAdd(ptr$Option_tuple2_u8_u8(self), at); + const value: [rs.u8, rs.u8] | undefined = copy$Option_tuple2_u8_u8(p.v); + rs.ptrCopy(rs.ptrAdd(p, 1), p, rs.usizeSub(len, at), copy$Option_tuple2_u8_u8); return value; } } -export function remove$sync_Arc_u8(self: Inline>, at: rt.usize): rt.Arc { +export function remove$sync_Arc_u8(self: Inline>, at: rs.usize): rs.Arc { if (!(at < self.len)) { - rt.panic("assertion failed: at < self.len"); + rs.panic("assertion failed: at < self.len"); } else { - self.len = rt.usizeSub(self.len, 1); - const len: rt.usize = self.len; - const p: rt.Place> = rt.ptrAdd(ptr$sync_Arc_u8(self), at); - const value: rt.Arc = p.v; - rt.ptrCopy(rt.ptrAdd(p, 1), p, rt.usizeSub(len, at)); + self.len = rs.usizeSub(self.len, 1); + const len: rs.usize = self.len; + const p: rs.Place> = rs.ptrAdd(ptr$sync_Arc_u8(self), at); + const value: rs.Arc = p.v; + rs.ptrCopy(rs.ptrAdd(p, 1), p, rs.usizeSub(len, at)); return value; } } -export function drop$ops_Drop_Option_tuple2_u8_u8(self: Inline<[rt.u8, rt.u8] | undefined>): void { - const len: rt.usize = self.len; - new rt.RawSlice(ptr$Option_tuple2_u8_u8(self), len); +export function drop$ops_Drop_Option_tuple2_u8_u8(self: Inline<[rs.u8, rs.u8] | undefined>): void { + const len: rs.usize = self.len; + new rs.RawSlice(ptr$Option_tuple2_u8_u8(self), len); } -export function drop$ops_Drop_sync_Arc_u8(self: Inline>): void { - const len: rt.usize = self.len; - rt.dropAll(new rt.RawSlice(ptr$sync_Arc_u8(self), len).deref()); +export function drop$ops_Drop_sync_Arc_u8(self: Inline>): void { + const len: rs.usize = self.len; + rs.dropAll(new rs.RawSlice(ptr$sync_Arc_u8(self), len).deref()); } //# sourceMappingURL=elements.Inline.ts.map diff --git a/ts/fixtures/lang/elements/expected/elements.Storage.ts b/ts/fixtures/lang/elements/expected/elements.Storage.ts index 6b9471060..64cc05005 100644 --- a/ts/fixtures/lang/elements/expected/elements.Storage.ts +++ b/ts/fixtures/lang/elements/expected/elements.Storage.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export class Storage { - data: rt.Place; - capacity: rt.usize; + data: rs.Place; + capacity: rs.usize; - constructor(data: rt.Place, capacity: rt.usize) { + constructor(data: rs.Place, capacity: rs.usize) { this.data = data; this.capacity = capacity; } @@ -16,26 +16,26 @@ export class Storage { } } -function new_(capacity: rt.usize): Storage { - const boxed: rt.ByteSlice = rt.byteVecSlice(rt.byteVecOf(0, capacity)); - const capacity2: rt.usize = boxed.length; - return new Storage(rt.rawByteSliceOf(boxed).ptr, capacity2); +function new_(capacity: rs.usize): Storage { + const boxed: rs.ByteSlice = rs.byteVecSlice(rs.byteVecOf(0, capacity)); + const capacity2: rs.usize = boxed.length; + return new Storage(rs.rawByteSliceOf(boxed).ptr, capacity2); } -export function write(self: Storage, offset: rt.usize, src: rt.ByteSlice): void { - if (!(rt.usizeAdd(offset, src.length) <= self.capacity)) { - rt.panic("assertion failed: offset + src.len() <= self.capacity"); +export function write(self: Storage, offset: rs.usize, src: rs.ByteSlice): void { + if (!(rs.usizeAdd(offset, src.length) <= self.capacity)) { + rs.panic("assertion failed: offset + src.len() <= self.capacity"); } else { - rt.ptrCopy(rt.byteSliceAsPtr(src), rt.ptrAdd(self.data, offset), src.length); + rs.ptrCopy(rs.byteSliceAsPtr(src), rs.ptrAdd(self.data, offset), src.length); } } -export function read(self: Storage, len: rt.usize): rt.ByteSlice { - return rt.ptrByteSlice(self.data, len, true); +export function read(self: Storage, len: rs.usize): rs.ByteSlice { + return rs.ptrByteSlice(self.data, len, true); } export function drop$ops_Drop(self: Storage): void { - new rt.RawSlice(self.data, self.capacity).derefBytes(false); + new rs.RawSlice(self.data, self.capacity).derefBytes(false); } export { new_ as new }; diff --git a/ts/fixtures/lang/elements/expected/elements.ts b/ts/fixtures/lang/elements/expected/elements.ts index f2e28bb27..77a66b2b6 100644 --- a/ts/fixtures/lang/elements/expected/elements.ts +++ b/ts/fixtures/lang/elements/expected/elements.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$array_Option_tuple2_u8_u8, drop$elements_Inline_Option_tuple2_u8_u8, drop$elements_Inline_sync_Arc_u8 } from "./lib.ts"; -import { thenSome$03chm1q } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1fmzefe as option_map$1fmzefe, mapOr$0grxkdu as option_mapOr$0grxkdu, mapOr$1nlkf9b as option_mapOr$1nlkf9b } from "./core/option.ts"; +import { thenSome$06c3xh5 } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1pv2dfs as option_map$1pv2dfs, mapOr$17byac0 as option_mapOr$17byac0, mapOr$13kt6x8 as option_mapOr$13kt6x8 } from "./core/option.ts"; import { offsetFrom } from "./elements/mine/ptr.ts"; import { fromRawPartsMut } from "./elements/mine/raw.ts"; import * as Inline from "./elements.Inline.ts"; @@ -13,77 +13,77 @@ import * as Storage from "./elements.Storage.ts"; * A `Vec`'s elements moved within it as `insert` and `remove` move them, and copied to * another, read back through slices made of the pointers. */ -export function vecs(data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { - return rt.u32Mul(_2 as rt.u32, 3); +export function vecs(data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { + return rs.u32Mul(_2 as rs.u32, 3); }), undefined, 4, true); - rt.iterExtend(v, rt.iterSlice([7, 8]), undefined, 4, true); - const len: rt.usize = v.items.length; - const at: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, rt.usizeSub(len, 1)); - const p: rt.Place = rt.sliceAsPtr(v.items); - rt.ptrCopy(rt.ptrAdd(p, at), rt.ptrAdd(p, rt.usizeAdd(at, 1)), rt.usizeSub(rt.usizeSub(len, at), 1)); - rt.ptrAdd(p, at).v = 1000; - emit(rt.ptrSlice(p, len), out); - rt.ptrCopy(rt.ptrAdd(p, rt.usizeAdd(at, 1)), rt.ptrAdd(p, at), rt.usizeSub(rt.usizeSub(len, at), 1)); - rt.ptrAdd(rt.ptrAdd(p, rt.usizeSub(len, 1)), -0).v = 2000; - emit(rt.ptrSlice(p, len), out); - const end: rt.Place = rt.ptrAdd(p, len); - const last: rt.Place = rt.ptrAdd(end, -1); - const _54: rt.Place = rt.ptrWrappingAdd(last, -1, 4, 4); - _54.v = rt.u32Add(_54.v, 1); - const _56: rt.Place = rt.ptrWrappingAdd(rt.ptrWrappingAdd(p, 1, 4, 4), -1, 4, 4); - _56.v = rt.u32Add(_56.v, 5); - rt.byteVecPush(out, rt.ptrOffsetFrom(end, p) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(p, last) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(last, last) & 0xff); - const part: rt.u32[] = rt.ptrSlice(rt.ptrAdd(p, at), rt.usizeSub(len, at)); - rt.idx(part, 0); - part[0] = rt.u32Add(part[0], 3); + rs.iterExtend(v, rs.iterSlice([7, 8]), undefined, 4, true); + const len: rs.usize = v.items.length; + const at: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize, rs.usizeSub(len, 1)); + const p: rs.Place = rs.sliceAsPtr(v.items); + rs.ptrCopy(rs.ptrAdd(p, at), rs.ptrAdd(p, rs.usizeAdd(at, 1)), rs.usizeSub(rs.usizeSub(len, at), 1)); + rs.ptrAdd(p, at).v = 1000; + emit(rs.ptrSlice(p, len), out); + rs.ptrCopy(rs.ptrAdd(p, rs.usizeAdd(at, 1)), rs.ptrAdd(p, at), rs.usizeSub(rs.usizeSub(len, at), 1)); + rs.ptrAdd(rs.ptrAdd(p, rs.usizeSub(len, 1)), -0).v = 2000; + emit(rs.ptrSlice(p, len), out); + const end: rs.Place = rs.ptrAdd(p, len); + const last: rs.Place = rs.ptrAdd(end, -1); + const _54: rs.Place = rs.ptrWrappingAdd(last, -1, 4, 4); + _54.v = rs.u32Add(_54.v, 1); + const _56: rs.Place = rs.ptrWrappingAdd(rs.ptrWrappingAdd(p, 1, 4, 4), -1, 4, 4); + _56.v = rs.u32Add(_56.v, 5); + rs.byteVecPush(out, rs.ptrOffsetFrom(end, p) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(p, last) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(last, last) & 0xff); + const part: rs.u32[] = rs.ptrSlice(rs.ptrAdd(p, at), rs.usizeSub(len, at)); + rs.idx(part, 0); + part[0] = rs.u32Add(part[0], 3); part.reverse(); - const w: rt.Vec = rt.vecFromElem(0, len, undefined); - rt.ptrCopy(p, rt.sliceAsPtr(w.items), len); - rt.ptrCopy(p, rt.ptrAdd(rt.sliceAsPtr(w.items), at), 1); - rt.ptrCopy(p, rt.ptrAdd(rt.sliceAsPtr(w.items), rt.usizeSub(len, 1)), 1); + const w: rs.Vec = rs.vecFromElem(0, len, undefined); + rs.ptrCopy(p, rs.sliceAsPtr(w.items), len); + rs.ptrCopy(p, rs.ptrAdd(rs.sliceAsPtr(w.items), at), 1); + rs.ptrCopy(p, rs.ptrAdd(rs.sliceAsPtr(w.items), rs.usizeSub(len, 1)), 1); emit(w.items, out); emit(v.items, out); - rt.byteVecPush(out, rt.ptrAdd(rt.sliceAsPtr(v.items), rt.usizeDiv(len, 2)).v & 0xff); - rt.byteVecPush(out, rt.ptrSlice(rt.DANGLING, 0).length & 0xff); + rs.byteVecPush(out, rs.ptrAdd(rs.sliceAsPtr(v.items), rs.usizeDiv(len, 2)).v & 0xff); + rs.byteVecPush(out, rs.ptrSlice(rs.DANGLING, 0).length & 0xff); } /** An array's elements, from a pointer to one, to the array, and to its first. */ -export function arrays(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { - const a: rt.u16[] = [n as rt.u16, 1, 2, 3, 4]; - const i: rt.usize = rt.usizeRem(n as rt.usize, 4); +export function arrays(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { + const a: rs.u16[] = [n as rs.u16, 1, 2, 3, 4]; + const i: rs.usize = rs.usizeRem(n as rs.usize, 4); if (!(i < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + i); } - const at: rt.Place = rt.sliceAsPtr(a, i); + const at: rs.Place = rs.sliceAsPtr(a, i); at.v = 99; - const whole: rt.Place = rt.sliceAsPtr(a); - const _18: rt.Place = rt.ptrAdd(whole, rt.usizeAdd(i, 1)); - _18.v = rt.u16Add(_18.v, 10); - const _22: rt.u16 = n as rt.u16; - const _23: rt.Place = rt.ptrAdd(whole, 4); - _23.v = rt.u16Add(_23.v, _22); - const first: rt.Place = rt.sliceAsPtr(a); - rt.byteVecPush(out, rt.ptrOffsetFrom(at, whole) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(first, at) & 0xff); - const p: rt.Place = first; - const _37: rt.Place = rt.ptrAdd(p, 2); - _37.v = rt.u16Add(_37.v, 1); - const _40: rt.Place = rt.ptrAdd(rt.ptrAdd(p, 3), -3); - _40.v = rt.u16Add(_40.v, 2); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.ptrAdd(p, 4), p) & 0xff); - const tail: rt.RawSlice = new rt.RawSlice(rt.ptrAdd(p, i), rt.usizeSub(5, i)); - rt.byteVecPush(out, tail.deref().length & 0xff); + const whole: rs.Place = rs.sliceAsPtr(a); + const _18: rs.Place = rs.ptrAdd(whole, rs.usizeAdd(i, 1)); + _18.v = rs.u16Add(_18.v, 10); + const _22: rs.u16 = n as rs.u16; + const _23: rs.Place = rs.ptrAdd(whole, 4); + _23.v = rs.u16Add(_23.v, _22); + const first: rs.Place = rs.sliceAsPtr(a); + rs.byteVecPush(out, rs.ptrOffsetFrom(at, whole) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(first, at) & 0xff); + const p: rs.Place = first; + const _37: rs.Place = rs.ptrAdd(p, 2); + _37.v = rs.u16Add(_37.v, 1); + const _40: rs.Place = rs.ptrAdd(rs.ptrAdd(p, 3), -3); + _40.v = rs.u16Add(_40.v, 2); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.ptrAdd(p, 4), p) & 0xff); + const tail: rs.RawSlice = new rs.RawSlice(rs.ptrAdd(p, i), rs.usizeSub(5, i)); + rs.byteVecPush(out, tail.deref().length & 0xff); tail.ptr.v = 7; - const unit: rt.Place = rt.DANGLING_UNIT; - n as rt.usize; - rt.byteVecPush(out, unit === unit ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(a), (x: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + const unit: rs.Place = rs.DANGLING_UNIT; + n as rs.usize; + rs.byteVecPush(out, unit === unit ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(a), (x: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } @@ -92,32 +92,32 @@ export function arrays(data: rt.ByteSlice, out: rt.ByteVec): void { * segment keeps its storage: written by copies at offsets, read by slices of it, and * freed as the slice it was. */ -export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { - const segment: Storage.Storage = Storage.new(rt.usizeAdd(data.length, 4)); +export function segments(data: rs.ByteSlice, out: rs.ByteVec): void { + const segment: Storage.Storage = Storage.new(rs.usizeAdd(data.length, 4)); Storage.write(segment, 0, data); - Storage.write(segment, data.length, rt.byteSliceFrom(Uint8Array.of(1, 2, 3, 4))); - rt.byteVecExtendFromSlice(out, Storage.read(segment, rt.usizeAdd(data.length, 4))); - const p: rt.Place = segment.data; - rt.ptrCopy(p, rt.ptrAdd(p, 2), data.length); - rt.byteVecExtendFromSlice(out, Storage.read(segment, rt.usizeAdd(data.length, 4))); - rt.ptrCopy(rt.ptrAdd(p, 3), rt.ptrAdd(p, 1), data.length); - const _36: rt.Place = rt.ptrAdd(p, rt.usizeAdd(data.length, 3)); + Storage.write(segment, data.length, rs.byteSliceFrom(Uint8Array.of(1, 2, 3, 4))); + rs.byteVecExtendFromSlice(out, Storage.read(segment, rs.usizeAdd(data.length, 4))); + const p: rs.Place = segment.data; + rs.ptrCopy(p, rs.ptrAdd(p, 2), data.length); + rs.byteVecExtendFromSlice(out, Storage.read(segment, rs.usizeAdd(data.length, 4))); + rs.ptrCopy(rs.ptrAdd(p, 3), rs.ptrAdd(p, 1), data.length); + const _36: rs.Place = rs.ptrAdd(p, rs.usizeAdd(data.length, 3)); _36.v = _36.v ^ 255; - rt.byteVecExtendFromSlice(out, Storage.read(segment, rt.usizeAdd(data.length, 4))); - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteVecPush(v, 9); - const a: Uint8Array = rt.bytes(4); - const p2: rt.Place = rt.byteVecAsPtr(v); - const _52: rt.Place = rt.ptrAdd(p2, rt.usizeSub(v.length, 1)); - _52.v = rt.u8Add(_52.v, 1); - rt.ptrCopy(p2, rt.byteSliceAsPtr(rt.byteSliceFrom(a)), rt.min(v.length, 4)); - const byte: rt.Place = rt.ptrAdd(rt.byteSliceAsPtr(rt.byteSliceFrom(a)), 1); - rt.ptrAdd(byte, 2).v = 85; - rt.byteVecExtendFromSlice(out, rt.ptrByteSlice(rt.ptrAdd(byte, -1), 4, true)); - const one: rt.Place = rt.sliceAsPtr(a, 2); + rs.byteVecExtendFromSlice(out, Storage.read(segment, rs.usizeAdd(data.length, 4))); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteVecPush(v, 9); + const a: Uint8Array = rs.bytes(4); + const p2: rs.Place = rs.byteVecAsPtr(v); + const _52: rs.Place = rs.ptrAdd(p2, rs.usizeSub(v.length, 1)); + _52.v = rs.u8Add(_52.v, 1); + rs.ptrCopy(p2, rs.byteSliceAsPtr(rs.byteSliceFrom(a)), rs.min(v.length, 4)); + const byte: rs.Place = rs.ptrAdd(rs.byteSliceAsPtr(rs.byteSliceFrom(a)), 1); + rs.ptrAdd(byte, 2).v = 85; + rs.byteVecExtendFromSlice(out, rs.ptrByteSlice(rs.ptrAdd(byte, -1), 4, true)); + const one: rs.Place = rs.sliceAsPtr(a, 2); one.v = one.v ^ 15; - rt.byteVecPush(out, one.v); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rs.byteVecPush(out, one.v); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); segment[Symbol.dispose](); } @@ -125,77 +125,77 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { * Shared values and `Option`s of pairs moved through an inline array, counting the * shared values' owners, and a pair changed in place after its copy moved. */ -export function inline(data: rt.ByteSlice, out: rt.ByteVec): void { - let item!: rt.Arc; - const shared: rt.Arc = new rt.Arc(0); - const held: Inline.Inline> = Inline.new$sync_Arc_u8(); - const pairs: Inline.Inline<[rt.u8, rt.u8] | undefined> = Inline.new$Option_tuple2_u8_u8(); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function inline(data: rs.ByteSlice, out: rs.ByteVec): void { + let item!: rs.Arc; + const shared: rs.Arc = new rs.Arc(0); + const held: Inline.Inline> = Inline.new$sync_Arc_u8(); + const pairs: Inline.Inline<[rs.u8, rs.u8] | undefined> = Inline.new$Option_tuple2_u8_u8(); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _10: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const i: rt.usize = _10[0]; - const n: rt.u8 = _10[1]; + const i: rs.usize = _10[0]; + const n: rs.u8 = _10[1]; if (held.len === 4) { - const gone: rt.Arc = Inline.remove$sync_Arc_u8(held, rt.usizeRem(n as rt.usize, 4)); - rt.byteVecPush(out, gone.value); - Inline.remove$Option_tuple2_u8_u8(pairs, rt.usizeRem(n as rt.usize, 4)); + const gone: rs.Arc = Inline.remove$sync_Arc_u8(held, rs.usizeRem(n as rs.usize, 4)); + rs.byteVecPush(out, gone.value); + Inline.remove$Option_tuple2_u8_u8(pairs, rs.usizeRem(n as rs.usize, 4)); gone[Symbol.dispose](); } - const at: rt.usize = rt.usizeRem(n as rt.usize, rt.usizeAdd(held.len, 1)); - if (rt.u8Rem(n, 3) === 0) { - item = rt.arcClone(shared); + const at: rs.usize = rs.usizeRem(n as rs.usize, rs.usizeAdd(held.len, 1)); + if (rs.u8Rem(n, 3) === 0) { + item = rs.arcClone(shared); } else { - item = new rt.Arc(n); + item = new rs.Arc(n); } Inline.insert$sync_Arc_u8(held, at, item); - const _46: [rt.u8, rt.u8] | undefined = thenSome$03chm1q(rt.u8Rem(n, 2) === 0, [n, i & 0xff] as [rt.u8, rt.u8]); + const _46: [rs.u8, rs.u8] | undefined = thenSome$06c3xh5(rs.u8Rem(n, 2) === 0, [n, i & 0xff] as [rs.u8, rs.u8]); Inline.insert$Option_tuple2_u8_u8(pairs, at, _46); - const _52: [rt.u8, rt.u8] | undefined | rt.None = rt.sliceFirst(Inline.asSlice$Option_tuple2_u8_u8(pairs), rt.None); - if (_52 !== rt.None) { + const _52: [rs.u8, rs.u8] | undefined | rs.None = rs.sliceFirst(Inline.asSlice$Option_tuple2_u8_u8(pairs), rs.None); + if (_52 !== rs.None) { if (_52 !== undefined) { - rt.byteVecPush(out, _52[0]); + rs.byteVecPush(out, _52[0]); } } const pointer = Inline.ptr$Option_tuple2_u8_u8(pairs); - const _60: rt.Place<[rt.u8, rt.u8] | undefined> | undefined = pointer === rt.NULL ? undefined : pointer; + const _60: rs.Place<[rs.u8, rs.u8] | undefined> | undefined = pointer === rs.NULL ? undefined : pointer; if (_60 !== undefined) { if (_60.v !== undefined) { - _60.v[1] = rt.u8WrappingAdd(_60.v[1], 1); + _60.v[1] = rs.u8WrappingAdd(_60.v[1], 1); } } - rt.byteVecPush(out, shared.strong & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(Inline.asSlice$sync_Arc_u8(held)), (x: rt.Arc): rt.u8 => { + rs.byteVecPush(out, shared.strong & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(Inline.asSlice$sync_Arc_u8(held)), (x: rs.Arc): rs.u8 => { return x.value; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(Inline.asSlice$Option_tuple2_u8_u8(pairs)), (p: [rt.u8, rt.u8] | undefined): Uint8Array => { - return option_mapOr$1nlkf9b(p, Uint8Array.of(0, 0), (_2: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(Inline.asSlice$Option_tuple2_u8_u8(pairs)), (p: [rs.u8, rs.u8] | undefined): Uint8Array => { + return option_mapOr$13kt6x8(p, Uint8Array.of(0, 0), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } drop$elements_Inline_sync_Arc_u8(held); - rt.byteVecPush(out, shared.strong & 0xff); - const src: rt.Vec<[rt.u8, rt.u8] | undefined> = rt.vecFrom(copy$array_Option_tuple2_u8_u8([[1, 2] as [rt.u8, rt.u8], undefined, option_map$1fmzefe(rt.byteSliceFirst(data), (_22: rt.u8): [rt.u8, rt.u8] => { - return [_22, 4] as [rt.u8, rt.u8]; + rs.byteVecPush(out, shared.strong & 0xff); + const src: rs.Vec<[rs.u8, rs.u8] | undefined> = rs.vecFrom(copy$array_Option_tuple2_u8_u8([[1, 2] as [rs.u8, rs.u8], undefined, option_map$1pv2dfs(rs.byteSliceFirst(data), (_22: rs.u8): [rs.u8, rs.u8] => { + return [_22, 4] as [rs.u8, rs.u8]; })]).map(copy$Option_tuple2_u8_u8)); - const dst: rt.Vec<[rt.u8, rt.u8] | undefined> = rt.vecFromElem(undefined as [rt.u8, rt.u8] | undefined, 3, copy$Option_tuple2_u8_u8); - rt.ptrCopy(rt.sliceAsPtr(src.items), rt.sliceAsPtr(dst.items), 3, copy$Option_tuple2_u8_u8); - const at2 = rt.idx(dst.items, 0); + const dst: rs.Vec<[rs.u8, rs.u8] | undefined> = rs.vecFromElem(undefined as [rs.u8, rs.u8] | undefined, 3, copy$Option_tuple2_u8_u8); + rs.ptrCopy(rs.sliceAsPtr(src.items), rs.sliceAsPtr(dst.items), 3, copy$Option_tuple2_u8_u8); + const at2 = rs.idx(dst.items, 0); if (dst.items[at2] !== undefined) { dst.items[at2][0] = 9; } - const at3 = rt.idx(src.items, 2); + const at3 = rs.idx(src.items, 2); if (src.items[at3] !== undefined) { src.items[at3][1] = 8; } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(src.items), rt.iterSlice(dst.items)), (p2: [rt.u8, rt.u8] | undefined): Uint8Array => { - return option_mapOr$1nlkf9b(p2, Uint8Array.of(0, 0), (_25: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterChain(rs.iterSlice(src.items), rs.iterSlice(dst.items)), (p2: [rs.u8, rs.u8] | undefined): Uint8Array => { + return option_mapOr$13kt6x8(p2, Uint8Array.of(0, 0), (_25: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_25[0], _25[1]); }); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); drop$elements_Inline_Option_tuple2_u8_u8(pairs); shared[Symbol.dispose](); } @@ -208,129 +208,129 @@ export function inline(data: rt.ByteSlice, out: rt.ByteVec): void { * address, kept by empty raw slices, and cast from pointers to arrays, the crate's * functions named as std's, and byte pointers into one buffer through its views. */ -export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { - let _200!: rt.Result<[rt.u32, rt.u32], rt.u8>; - let _206!: rt.u8; - for (const n of rt.byteSliceView(data)) { +export function edges(data: rs.ByteSlice, out: rs.ByteVec): void { + let _200!: rs.Result<[rs.u32, rs.u32], rs.u8>; + let _206!: rs.u8; + for (const n of rs.byteSliceView(data)) { const bytes: Uint8Array = Uint8Array.of(n, 1, 2, 3); - const p: rt.Place = rt.byteSliceAsPtr(rt.byteSliceFrom(bytes)); - const q: rt.Place = rt.sliceAsPtr([n as rt.u16, 7, 8]); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.ptrWrappingAdd(p, 4294967295, 1, 1), 1, 1, 1).v); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.ptrWrappingAdd(p, 2147483648, 1, 1), 2147483648, 1, 1).v); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.ptrWrappingAdd(p, -4294967295, 1, 1), -1, 1, 1).v); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.ptrWrappingAdd(rt.ptrWrappingAdd(q, 2147483648, 2, 2), 1, 2, 2).v).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(rt.ptrWrappingAdd(rt.ptrWrappingAdd(rt.ptrWrappingAdd(q, 3221225472, 2, 2), 1 << 30, 2, 2), 2, 2, 2).v).reverse()), undefined, true); - let lone: rt.u32 = rt.u32Add(n as rt.u32, 42); - const at: rt.Place = rt.place(() => lone, (value) => lone = value); - const _63: rt.u32[] = rt.ptrSlice(at, 1); - rt.idx(_63, 0); - rt.byteVecPush(out, _63[0] & 0xff); - const _68: rt.u32[] = rt.ptrSlice(at, 1); - rt.idx(_68, 0); - _68[0] = rt.u32Add(_68[0], 1); - rt.byteVecPush(out, rt.ptrAdd(rt.ptrAdd(at, 1), -1).v & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.ptrAdd(at, 1), at) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.sliceAsPtr(rt.ptrSlice(at, 0)), at) & 0xff); - rt.byteVecPush(out, lone & 0xff); - let byte: rt.u8 = n ^ 90; - const _97: rt.ByteSlice = rt.ptrByteSlice(rt.place(() => byte, (value2) => byte = value2), 1, true); - rt.idx(_97, 0); - rt.byteVecPush(out, _97.data[_97.start]); - const a: rt.u32[] = [n as rt.u32, 1, 2, 3]; - const base: rt.Place = rt.sliceAsPtr(a); - const part: rt.u32[] = rt.sliceRangeMut(a, 1, 3); - rt.idx(part, 1); - const at2: rt.Place = rt.sliceAsPtr(part, 1); - rt.byteVecPush(out, rt.ptrOffsetFrom(at2, base) & 0xff); - at2.v = rt.u32Add(at2.v, 5); - const got: rt.Place = rt.optionUnwrap(rt.sliceGetMut(part, 0)); - rt.byteVecPush(out, rt.ptrOffsetFrom(got, base) & 0xff); - rt.byteVecPush(out, rt.ptrAdd(got, -1).v & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.sliceAsPtr(rt.ptrSlice(rt.ptrAdd(at2, 1), 0)), base) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.byteSliceAsPtr(rt.ptrByteSlice(rt.ptrAdd(rt.byteSliceAsPtr(rt.byteSliceFrom(bytes)), 2), 0, true)), p) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(a), (_2: rt.u32): rt.u8 => { + const p: rs.Place = rs.byteSliceAsPtr(rs.byteSliceFrom(bytes)); + const q: rs.Place = rs.sliceAsPtr([n as rs.u16, 7, 8]); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.ptrWrappingAdd(p, 4294967295, 1, 1), 1, 1, 1).v); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.ptrWrappingAdd(p, 2147483648, 1, 1), 2147483648, 1, 1).v); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.ptrWrappingAdd(p, -4294967295, 1, 1), -1, 1, 1).v); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.ptrWrappingAdd(rs.ptrWrappingAdd(q, 2147483648, 2, 2), 1, 2, 2).v).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(rs.ptrWrappingAdd(rs.ptrWrappingAdd(rs.ptrWrappingAdd(q, 3221225472, 2, 2), 1 << 30, 2, 2), 2, 2, 2).v).reverse()), undefined, true); + let lone: rs.u32 = rs.u32Add(n as rs.u32, 42); + const at: rs.Place = rs.place(() => lone, (value) => lone = value); + const _63: rs.u32[] = rs.ptrSlice(at, 1); + rs.idx(_63, 0); + rs.byteVecPush(out, _63[0] & 0xff); + const _68: rs.u32[] = rs.ptrSlice(at, 1); + rs.idx(_68, 0); + _68[0] = rs.u32Add(_68[0], 1); + rs.byteVecPush(out, rs.ptrAdd(rs.ptrAdd(at, 1), -1).v & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.ptrAdd(at, 1), at) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.sliceAsPtr(rs.ptrSlice(at, 0)), at) & 0xff); + rs.byteVecPush(out, lone & 0xff); + let byte: rs.u8 = n ^ 90; + const _97: rs.ByteSlice = rs.ptrByteSlice(rs.place(() => byte, (value2) => byte = value2), 1, true); + rs.idx(_97, 0); + rs.byteVecPush(out, _97.data[_97.start]); + const a: rs.u32[] = [n as rs.u32, 1, 2, 3]; + const base: rs.Place = rs.sliceAsPtr(a); + const part: rs.u32[] = rs.sliceRangeMut(a, 1, 3); + rs.idx(part, 1); + const at2: rs.Place = rs.sliceAsPtr(part, 1); + rs.byteVecPush(out, rs.ptrOffsetFrom(at2, base) & 0xff); + at2.v = rs.u32Add(at2.v, 5); + const got: rs.Place = rs.optionUnwrap(rs.sliceGetMut(part, 0)); + rs.byteVecPush(out, rs.ptrOffsetFrom(got, base) & 0xff); + rs.byteVecPush(out, rs.ptrAdd(got, -1).v & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.sliceAsPtr(rs.ptrSlice(rs.ptrAdd(at2, 1), 0)), base) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.byteSliceAsPtr(rs.ptrByteSlice(rs.ptrAdd(rs.byteSliceAsPtr(rs.byteSliceFrom(bytes)), 2), 0, true)), p) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(a), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); - const lanes: rt.u32[] = [n as rt.u32, 4, 5, 6]; - const first: rt.Place = rt.sliceAsPtr(rt.sliceRange(lanes, 1, 3)); - rt.byteVecPush(out, rt.ptrAdd(first, 1).v & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.ptrAdd(first, 2), first) & 0xff); - const _170: rt.u32[] = rt.ptrSlice(rt.ptrAdd(first, 1), 1); - rt.idx(_170, 0); - rt.byteVecPush(out, _170[0] & 0xff); - const _177: [rt.u32, rt.u8] = [n as rt.u32, n]; - let x: rt.u32 = _177[0]; - let y: rt.u8 = n; - rt.byteVecPush(out, offsetFrom(rt.place(() => x, (value3) => x = value3), rt.place(() => x, (value4) => x = value4)) & 0xff); - rt.byteVecPush(out, fromRawPartsMut(rt.place(() => y, (value5) => y = value5), 2)); - const item = (undefined as unknown) as rt.Result<[rt.u32, rt.u32], rt.u8>; - const item2 = (undefined as unknown) as rt.Result<[rt.u32, rt.u32], rt.u8>; - const dst: rt.Result<[rt.u32, rt.u32], rt.u8>[] = Array.from({ length: 2 }, (): rt.Result<[rt.u32, rt.u32], rt.u8> => { + const lanes: rs.u32[] = [n as rs.u32, 4, 5, 6]; + const first: rs.Place = rs.sliceAsPtr(rs.sliceRange(lanes, 1, 3)); + rs.byteVecPush(out, rs.ptrAdd(first, 1).v & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.ptrAdd(first, 2), first) & 0xff); + const _170: rs.u32[] = rs.ptrSlice(rs.ptrAdd(first, 1), 1); + rs.idx(_170, 0); + rs.byteVecPush(out, _170[0] & 0xff); + const _177: [rs.u32, rs.u8] = [n as rs.u32, n]; + let x: rs.u32 = _177[0]; + let y: rs.u8 = n; + rs.byteVecPush(out, offsetFrom(rs.place(() => x, (value3) => x = value3), rs.place(() => x, (value4) => x = value4)) & 0xff); + rs.byteVecPush(out, fromRawPartsMut(rs.place(() => y, (value5) => y = value5), 2)); + const item = (undefined as unknown) as rs.Result<[rs.u32, rs.u32], rs.u8>; + const item2 = (undefined as unknown) as rs.Result<[rs.u32, rs.u32], rs.u8>; + const dst: rs.Result<[rs.u32, rs.u32], rs.u8>[] = Array.from({ length: 2 }, (): rs.Result<[rs.u32, rs.u32], rs.u8> => { return item2; }); - rt.ptrCopy(rt.sliceAsPtr(Array.from({ length: 2 }, (): rt.Result<[rt.u32, rt.u32], rt.u8> => { + rs.ptrCopy(rs.sliceAsPtr(Array.from({ length: 2 }, (): rs.Result<[rs.u32, rs.u32], rs.u8> => { return item; - })), rt.sliceAsPtr(dst), 2); + })), rs.sliceAsPtr(dst), 2); if (!((n & 1) === 0)) { - _200 = rt.Err(n); + _200 = rs.Err(n); } else { - _200 = rt.Ok([x, 1] as [rt.u32, rt.u32]); + _200 = rs.Ok([x, 1] as [rs.u32, rs.u32]); } - const uninit = rt.place(() => dst[1], (value6) => dst[1] = value6); + const uninit = rs.place(() => dst[1], (value6) => dst[1] = value6); uninit.v = _200; uninit; - const _207: rt.Result<[rt.u32, rt.u32], rt.u8> = dst[1]; + const _207: rs.Result<[rs.u32, rs.u32], rs.u8> = dst[1]; if (_207.ok) { - _206 = rt.u32Add(_207.value[0], _207.value[1]) & 0xff; + _206 = rs.u32Add(_207.value[0], _207.value[1]) & 0xff; } else { _206 = _207.error; } - rt.byteVecPush(out, _206); - const null_: rt.Place = rt.NULL; - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.ptrWrappingAdd(null_, 1, 4, 4), -1, 4, 4) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(null_, n as rt.usize, 4, 4) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(null_, 1 << 30, 4, 4) === rt.NULL ? 1 : 0); - const _237: [rt.Place, rt.Place] = [rt.ptrWrappingAdd(null_, rt.usizeAdd(n as rt.usize, 1), 4, 4), rt.ptrWrappingAdd(null_, rt.usizeAdd(n as rt.usize, 1), 4, 4)]; - rt.byteVecPush(out, rt.ptrOffsetFrom(_237[0], _237[1]) & 0xff); - const dangling: rt.Place = rt.DANGLING; - rt.byteVecPush(out, rt.ptrWrappingAdd(dangling, -1, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(dangling, 4294967295, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.ptrWrappingAdd(dangling, -(n as rt.usize), 2, 2), n as rt.usize, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.DANGLING, rt.isizeSub(rt.u8Rem(n, 3) as rt.isize, 1), 8, 8) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, new rt.RawSlice(rt.NULL, 0).ptr === rt.NULL ? 1 : 0); - rt.byteVecPush(out, new rt.RawSlice(rt.NULL, 0).ptr === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(new rt.RawSlice(rt.DANGLING, 0).ptr, -1, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, new rt.RawSlice(rt.NULL, 0).ptr === rt.NULL ? 1 : 0); - rt.byteVecPush(out, new rt.RawSlice(rt.NULL, 0).ptr === rt.NULL ? 1 : 0); - const none2: rt.ByteSlice = rt.ptrByteSlice(rt.DANGLING, 0, true); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.byteSliceAsPtr(none2), -1, 1, 1) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.byteSliceAsPtr(rt.byteSliceRange(none2, 0, 0)), -1, 1, 1) === rt.NULL ? 1 : 0); - const wide2: rt.u16[] = rt.ptrSlice(rt.DANGLING, 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.sliceAsPtr(rt.sliceRange(wide2, 0, 0)), -1, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.sliceAsPtr(rt.optionUnwrap(rt.sliceGetRange(wide2, 0, 0))), -1, 2, 2) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, new rt.RawSlice(rt.sliceAsPtr(rt.NULL), 3).ptr === rt.NULL ? 1 : 0); - const row: rt.u32[] = [n as rt.u32, 9, 10]; - const unsizedLanes: rt.RawSlice = new rt.RawSlice(rt.sliceAsPtr(row), 3); - rt.byteVecPush(out, unsizedLanes.ptr === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrAdd(unsizedLanes.ptr, 2).v & 0xff); - rt.byteVecPush(out, rt.ptrWrappingAdd(new rt.RawSlice(rt.ptrWrappingAdd(rt.NULL, rt.usizeAdd(rt.u8Rem(n, 3) as rt.usize, 1), 4, 4), 0).ptr, -rt.usizeAdd(rt.u8Rem(n, 3) as rt.usize, 1), 4, 4) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.sliceAsPtr(rt.NULL) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.byteSliceAsPtr(rt.NULL), n as rt.usize, 1, 1) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrWrappingAdd(rt.sliceAsPtr(rt.DANGLING), -1, 2, 2) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, _206); + const null_: rs.Place = rs.NULL; + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.ptrWrappingAdd(null_, 1, 4, 4), -1, 4, 4) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(null_, n as rs.usize, 4, 4) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(null_, 1 << 30, 4, 4) === rs.NULL ? 1 : 0); + const _237: [rs.Place, rs.Place] = [rs.ptrWrappingAdd(null_, rs.usizeAdd(n as rs.usize, 1), 4, 4), rs.ptrWrappingAdd(null_, rs.usizeAdd(n as rs.usize, 1), 4, 4)]; + rs.byteVecPush(out, rs.ptrOffsetFrom(_237[0], _237[1]) & 0xff); + const dangling: rs.Place = rs.DANGLING; + rs.byteVecPush(out, rs.ptrWrappingAdd(dangling, -1, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(dangling, 4294967295, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.ptrWrappingAdd(dangling, -(n as rs.usize), 2, 2), n as rs.usize, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.DANGLING, rs.isizeSub(rs.u8Rem(n, 3) as rs.isize, 1), 8, 8) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.NULL, 0).ptr === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.NULL, 0).ptr === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(new rs.RawSlice(rs.DANGLING, 0).ptr, -1, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.NULL, 0).ptr === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.NULL, 0).ptr === rs.NULL ? 1 : 0); + const none2: rs.ByteSlice = rs.ptrByteSlice(rs.DANGLING, 0, true); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.byteSliceAsPtr(none2), -1, 1, 1) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.byteSliceAsPtr(rs.byteSliceRange(none2, 0, 0)), -1, 1, 1) === rs.NULL ? 1 : 0); + const wide2: rs.u16[] = rs.ptrSlice(rs.DANGLING, 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.sliceRange(wide2, 0, 0)), -1, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.optionUnwrap(rs.sliceGetRange(wide2, 0, 0))), -1, 2, 2) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, new rs.RawSlice(rs.sliceAsPtr(rs.NULL), 3).ptr === rs.NULL ? 1 : 0); + const row: rs.u32[] = [n as rs.u32, 9, 10]; + const unsizedLanes: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(row), 3); + rs.byteVecPush(out, unsizedLanes.ptr === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrAdd(unsizedLanes.ptr, 2).v & 0xff); + rs.byteVecPush(out, rs.ptrWrappingAdd(new rs.RawSlice(rs.ptrWrappingAdd(rs.NULL, rs.usizeAdd(rs.u8Rem(n, 3) as rs.usize, 1), 4, 4), 0).ptr, -rs.usizeAdd(rs.u8Rem(n, 3) as rs.usize, 1), 4, 4) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.sliceAsPtr(rs.NULL) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.byteSliceAsPtr(rs.NULL), n as rs.usize, 1, 1) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrWrappingAdd(rs.sliceAsPtr(rs.DANGLING), -1, 2, 2) === rs.NULL ? 1 : 0); } - const bytes2: Uint8Array = Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 1, 2, 3, 4, 5); - const s: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(bytes2), 1); - const base2: rt.Place = rt.byteSliceAsPtr(s); - const first2: rt.Place = rt.optionUnwrap(rt.iterToOption(rt.iterSliceMut(rt.byteSliceView(s)).next())); - const last: rt.Place = rt.optionUnwrap(rt.iterLast(rt.iterSliceMut(rt.byteSliceView(s)))); - const part2: rt.Place = rt.byteSliceAsPtr(rt.byteSliceSplitAt(s, 2)[1]); - rt.byteVecPush(out, rt.ptrOffsetFrom(first2, base2) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(last, base2) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(base2, last) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(part2, first2) & 0xff); - const _433: rt.Place = rt.ptrAdd(last, rt.ptrOffsetFrom(part2, last)); + const bytes2: Uint8Array = Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 1, 2, 3, 4, 5); + const s: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(bytes2), 1); + const base2: rs.Place = rs.byteSliceAsPtr(s); + const first2: rs.Place = rs.optionUnwrap(rs.iterToOption(rs.iterSliceMut(rs.byteSliceView(s)).next())); + const last: rs.Place = rs.optionUnwrap(rs.iterLast(rs.iterSliceMut(rs.byteSliceView(s)))); + const part2: rs.Place = rs.byteSliceAsPtr(rs.byteSliceSplitAt(s, 2)[1]); + rs.byteVecPush(out, rs.ptrOffsetFrom(first2, base2) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(last, base2) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(base2, last) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(part2, first2) & 0xff); + const _433: rs.Place = rs.ptrAdd(last, rs.ptrOffsetFrom(part2, last)); _433.v = _433.v ^ 255; - rt.iterExtendBytes(out, rt.iterSlice(bytes2), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(bytes2), undefined, true); } /** @@ -338,184 +338,184 @@ export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { * through, whole and in part, of bytes too, made longer than what is there and never * read past it, `NonNull`'s, a boxed slice's, and null's. */ -export function rawSlices(data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const v: rt.Vec = rt.iterToVec(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; - }), rt.iterSlice([5, 6, 7])), undefined, 4, true); - const len: rt.usize = v.items.length; - const p: rt.RawSlice = new rt.RawSlice(rt.sliceAsPtr(v.items), len); - rt.idx(p, 0); - const _19: rt.u32 = rt.u32Add(p.deref()[0], 1); +export function rawSlices(data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const v: rs.Vec = rs.iterToVec(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; + }), rs.iterSlice([5, 6, 7])), undefined, 4, true); + const len: rs.usize = v.items.length; + const p: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(v.items), len); + rs.idx(p, 0); + const _19: rs.u32 = rs.u32Add(p.deref()[0], 1); p.deref()[0] = _19; - const _20: rt.u32 = n as rt.u32; - const _21: rt.usize = rt.usizeSub(len, 1); - rt.idx(p, _21); + const _20: rs.u32 = n as rs.u32; + const _21: rs.usize = rs.usizeSub(len, 1); + rs.idx(p, _21); p.deref()[_21] = _20; - rt.byteVecPush(out, p.deref().length & 0xff); - rt.byteVecPush(out, p.length & 0xff); - rt.idx(p, 1); - rt.byteVecPush(out, p.deref()[1] & 0xff); - const tail: rt.u32[] = rt.sliceRangeMut(p.deref(), 1); - rt.idx(tail, 0); + rs.byteVecPush(out, p.deref().length & 0xff); + rs.byteVecPush(out, p.length & 0xff); + rs.idx(p, 1); + rs.byteVecPush(out, p.deref()[1] & 0xff); + const tail: rs.u32[] = rs.sliceRangeMut(p.deref(), 1); + rs.idx(tail, 0); tail[0] = 9; - rt.byteVecPush(out, rt.iterSum(rt.iterSlice(p.deref()), rt.u32Add, 0) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterSlice(p.deref()), rs.u32Add, 0) & 0xff); emit(v.items, out); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.iterExtendBytes(bytes, rt.iterSlice(Uint8Array.of(3, 4)), undefined, true); - const b: rt.RawSlice = new rt.RawSlice(rt.byteVecAsPtr(bytes), bytes.length); - rt.idx(b, 0); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.iterExtendBytes(bytes, rs.iterSlice(Uint8Array.of(3, 4)), undefined, true); + const b: rs.RawSlice = new rs.RawSlice(rs.byteVecAsPtr(bytes), bytes.length); + rs.idx(b, 0); const slice2 = b.derefBytes(false); const slice3 = b.derefBytes(false); slice3.data[slice3.start] = slice2.data[slice2.start] ^ 255; - const _67: rt.usize = rt.usizeSub(b.derefBytes(false).length, 1); - rt.idx(b, _67); + const _67: rs.usize = rs.usizeSub(b.derefBytes(false).length, 1); + rs.idx(b, _67); const slice4 = b.derefBytes(false); - rt.byteVecPush(out, slice4.data[slice4.start + _67]); - rt.byteVecPush(out, rt.byteSliceRange(b.derefBytes(false), 1).length & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - const short: rt.u32[] = [n as rt.u32, 1]; - const long: rt.RawSlice = new rt.RawSlice(rt.sliceAsPtr(short), 10); - rt.byteVecPush(out, long.length & 0xff); - rt.byteVecPush(out, rt.ptrAdd(long.ptr, 1).v & 0xff); - const pointer = rt.sliceAsPtr(v.items); - const nn: rt.RawSlice = new rt.RawSlice(rt.optionUnwrap(pointer === rt.NULL ? undefined : pointer), 2); - rt.byteVecPush(out, nn.length & 0xff); - const _103: rt.RawSlice = nn; - rt.idx(_103, 1); + rs.byteVecPush(out, slice4.data[slice4.start + _67]); + rs.byteVecPush(out, rs.byteSliceRange(b.derefBytes(false), 1).length & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + const short: rs.u32[] = [n as rs.u32, 1]; + const long: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(short), 10); + rs.byteVecPush(out, long.length & 0xff); + rs.byteVecPush(out, rs.ptrAdd(long.ptr, 1).v & 0xff); + const pointer = rs.sliceAsPtr(v.items); + const nn: rs.RawSlice = new rs.RawSlice(rs.optionUnwrap(pointer === rs.NULL ? undefined : pointer), 2); + rs.byteVecPush(out, nn.length & 0xff); + const _103: rs.RawSlice = nn; + rs.idx(_103, 1); _103.deref()[1] = 11; - const _110: rt.u32[] = nn.deref(); - rt.idx(_110, 1); - rt.byteVecPush(out, _110[1] & 0xff); + const _110: rs.u32[] = nn.deref(); + rs.idx(_110, 1); + rs.byteVecPush(out, _110[1] & 0xff); const pointer2 = nn; - rt.byteVecPush(out, option_mapOr$0grxkdu(pointer2.ptr === rt.NULL ? undefined : pointer2.deref(), 0, (s: rt.u32[]): rt.u32 => { - rt.idx(s, 0); + rs.byteVecPush(out, option_mapOr$17byac0(pointer2.ptr === rs.NULL ? undefined : pointer2.deref(), 0, (s: rs.u32[]): rs.u32 => { + rs.idx(s, 0); return s[0]; }) & 0xff); - const _121: rt.u32[] = nn.deref(); - rt.idx(_121, 0); + const _121: rs.u32[] = nn.deref(); + rs.idx(_121, 0); _121[0] = 12; - const pointer3 = rt.byteVecAsPtr(bytes); - const two: rt.RawSlice = new rt.RawSlice(rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3), 2); - const _132: rt.ByteSlice = two.derefBytes(false); - rt.idx(_132, 1); + const pointer3 = rs.byteVecAsPtr(bytes); + const two: rs.RawSlice = new rs.RawSlice(rs.optionUnwrap(pointer3 === rs.NULL ? undefined : pointer3), 2); + const _132: rs.ByteSlice = two.derefBytes(false); + rs.idx(_132, 1); _132.data[_132.start + 1] = _132.data[_132.start + 1] ^ 15; - const _140: rt.ByteSlice = two.derefBytes(true); - rt.idx(_140, 1); - rt.byteVecPush(out, _140.data[_140.start + 1]); - const null_: rt.RawSlice = new rt.RawSlice(rt.NULL, 0); + const _140: rs.ByteSlice = two.derefBytes(true); + rs.idx(_140, 1); + rs.byteVecPush(out, _140.data[_140.start + 1]); + const null_: rs.RawSlice = new rs.RawSlice(rs.NULL, 0); const pointer4 = null_; - rt.byteVecPush(out, (pointer4.ptr === rt.NULL ? undefined : pointer4) === undefined ? 1 : 0); + rs.byteVecPush(out, (pointer4.ptr === rs.NULL ? undefined : pointer4) === undefined ? 1 : 0); const pointer5 = null_; - rt.byteVecPush(out, (pointer5.ptr === rt.NULL ? undefined : pointer5.deref()) === undefined ? 1 : 0); - const raw: rt.RawSlice = rt.rawSliceOf(rt.vecFrom([n as rt.u32, 2, 3]).items); - rt.idx(raw, 2); + rs.byteVecPush(out, (pointer5.ptr === rs.NULL ? undefined : pointer5.deref()) === undefined ? 1 : 0); + const raw: rs.RawSlice = rs.rawSliceOf(rs.vecFrom([n as rs.u32, 2, 3]).items); + rs.idx(raw, 2); raw.deref()[2] = 8; emit(raw.deref(), out); - const whole2: rt.RawSlice = new rt.RawSlice(rt.sliceAsPtr(short), 2); - const ofRef: rt.RawSlice = rt.rawSliceOf(rt.sliceRange(v.items, 1, 3)); - rt.byteVecPush(out, rt.usizeAdd(whole2.length, ofRef.length) & 0xff); - rt.idx(ofRef, 1); - rt.byteVecPush(out, ofRef.deref()[1] & 0xff); + const whole2: rs.RawSlice = new rs.RawSlice(rs.sliceAsPtr(short), 2); + const ofRef: rs.RawSlice = rs.rawSliceOf(rs.sliceRange(v.items, 1, 3)); + rs.byteVecPush(out, rs.usizeAdd(whole2.length, ofRef.length) & 0xff); + rs.idx(ofRef, 1); + rs.byteVecPush(out, ofRef.deref()[1] & 0xff); emit(v.items, out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); } /** * Empty slices made from pointers into no array, a dangling one and one off null, each * part of which keeps the pointer as Rust's does: after moving back to address 0 it is null. */ -export function emptyParts(data: rt.ByteSlice, out: rt.ByteVec): void { - const _130: (a0: rt.Place) => rt.u8 = (p2: rt.Place): rt.u8 => { - return rt.ptrWrappingAdd(p2, -1, 1, 1) === rt.NULL ? 1 : 0; +export function emptyParts(data: rs.ByteSlice, out: rs.ByteVec): void { + const _130: (a0: rs.Place) => rs.u8 = (p2: rs.Place): rs.u8 => { + return rs.ptrWrappingAdd(p2, -1, 1, 1) === rs.NULL ? 1 : 0; }; - const k: rt.usize = rt.usizeAdd(rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 4) as rt.usize, 1); - const wide: rt.Place = rt.DANGLING; - const off: rt.Place = rt.ptrWrappingAdd(rt.NULL, k, 2, 2); - const iter: rt.Iter<[rt.u16[], rt.usize]> = rt.iterSlice([[rt.ptrSlice(wide, 0), 1] as [rt.u16[], rt.usize], [rt.ptrSlice(off, 0), k] as [rt.u16[], rt.usize]]); + const k: rs.usize = rs.usizeAdd(rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 4) as rs.usize, 1); + const wide: rs.Place = rs.DANGLING; + const off: rs.Place = rs.ptrWrappingAdd(rs.NULL, k, 2, 2); + const iter: rs.Iter<[rs.u16[], rs.usize]> = rs.iterSlice([[rs.ptrSlice(wide, 0), 1] as [rs.u16[], rs.usize], [rs.ptrSlice(off, 0), k] as [rs.u16[], rs.usize]]); while (true) { - const _23: [rt.u16[], rt.usize] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.u16[], rs.usize] | rs.Done = iter.next(); + if (_23 === rs.DONE) { break; } - const back: rt.usize = _23[1]; - const null_: (a0: rt.Place) => rt.u8 = (p3: rt.Place): rt.u8 => { - return rt.ptrWrappingAdd(p3, -back, 2, 2) === rt.NULL ? 1 : 0; + const back: rs.usize = _23[1]; + const null_: (a0: rs.Place) => rs.u8 = (p3: rs.Place): rs.u8 => { + return rs.ptrWrappingAdd(p3, -back, 2, 2) === rs.NULL ? 1 : 0; }; - const _32: [rt.u16[], rt.u16[]] = rt.sliceSplitAt(_23[0], 0); - const part = rt.sliceAsPtr(_32[0]); - const _35: rt.u8 = null_(part); - const part2 = rt.sliceAsPtr(_32[1]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, null_(part2))), undefined, true); - const _45: [rt.u16[], rt.u16[]] = rt.optionUnwrap(rt.sliceSplitAtChecked(_23[0], 0)); - const part3 = rt.sliceAsPtr(_45[0]); - const _49: rt.u8 = null_(part3); - const part4 = rt.sliceAsPtr(_45[1]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_49, null_(part4))), undefined, true); - const part5 = rt.sliceAsPtr(rt.partsRemainder(rt.sliceChunksExact(_23[0], 2))); - rt.byteVecPush(out, null_(part5)); - const part6 = rt.sliceAsPtr(rt.partsRemainder(rt.sliceRchunksExact(_23[0], 3))); - rt.byteVecPush(out, null_(part6)); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceSplit(_23[0], (_2: rt.u16): boolean => { + const _32: [rs.u16[], rs.u16[]] = rs.sliceSplitAt(_23[0], 0); + const part = rs.sliceAsPtr(_32[0]); + const _35: rs.u8 = null_(part); + const part2 = rs.sliceAsPtr(_32[1]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, null_(part2))), undefined, true); + const _45: [rs.u16[], rs.u16[]] = rs.optionUnwrap(rs.sliceSplitAtChecked(_23[0], 0)); + const part3 = rs.sliceAsPtr(_45[0]); + const _49: rs.u8 = null_(part3); + const part4 = rs.sliceAsPtr(_45[1]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_49, null_(part4))), undefined, true); + const part5 = rs.sliceAsPtr(rs.partsRemainder(rs.sliceChunksExact(_23[0], 2))); + rs.byteVecPush(out, null_(part5)); + const part6 = rs.sliceAsPtr(rs.partsRemainder(rs.sliceRchunksExact(_23[0], 3))); + rs.byteVecPush(out, null_(part6)); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceSplit(_23[0], (_2: rs.u16): boolean => { return _2 === 0; - }), (part7: rt.u16[]): rt.u8 => { - return null_(rt.sliceAsPtr(part7)); + }), (part7: rs.u16[]): rs.u8 => { + return null_(rs.sliceAsPtr(part7)); }), "next"); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceRsplit(_23[0], (_22: rt.u16): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.sliceRsplit(_23[0], (_22: rs.u16): boolean => { return _22 === 0; - }), (part9: rt.u16[]): rt.u8 => { - return null_(rt.sliceAsPtr(part9)); + }), (part9: rs.u16[]): rs.u8 => { + return null_(rs.sliceAsPtr(part9)); }), "next"); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceSplitn(_23[0], 2, (_24: rt.u16): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.sliceSplitn(_23[0], 2, (_24: rs.u16): boolean => { return _24 === 0; - }), (part11: rt.u16[]): rt.u8 => { - return null_(rt.sliceAsPtr(part11)); + }), (part11: rs.u16[]): rs.u8 => { + return null_(rs.sliceAsPtr(part11)); }), "next"); - const part13 = rt.sliceAsPtr(rt.optionUnwrap(rt.sliceGetRange(_23[0], 0, 0))); - rt.byteVecPush(out, null_(part13)); - const part14 = rt.sliceAsPtr(rt.optionUnwrap(rt.sliceLastChunk(_23[0], 0))); - rt.byteVecPush(out, null_(part14)); - const part15 = rt.sliceAsPtr(rt.optionUnwrap(rt.sliceGetRange(_23[0], 0))); - rt.byteVecPush(out, null_(part15)); - const part16 = rt.sliceAsPtr(rt.sliceRange(_23[0], 0, 0)); - rt.byteVecPush(out, null_(part16)); - rt.byteVecPush(out, rt.sliceSplitFirst(_23[0]) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.sliceChunks(_23[0], 2)) & 0xff); + const part13 = rs.sliceAsPtr(rs.optionUnwrap(rs.sliceGetRange(_23[0], 0, 0))); + rs.byteVecPush(out, null_(part13)); + const part14 = rs.sliceAsPtr(rs.optionUnwrap(rs.sliceLastChunk(_23[0], 0))); + rs.byteVecPush(out, null_(part14)); + const part15 = rs.sliceAsPtr(rs.optionUnwrap(rs.sliceGetRange(_23[0], 0))); + rs.byteVecPush(out, null_(part15)); + const part16 = rs.sliceAsPtr(rs.sliceRange(_23[0], 0, 0)); + rs.byteVecPush(out, null_(part16)); + rs.byteVecPush(out, rs.sliceSplitFirst(_23[0]) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunks(_23[0], 2)) & 0xff); } - const byte: rt.Place = rt.DANGLING; - const s: rt.ByteSlice = rt.ptrByteSlice(byte, 0, false); - const part17 = rt.byteSliceAsPtr(s); - rt.byteVecPush(out, _130(part17)); - const _139: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(s, 0); - const part18 = rt.byteSliceAsPtr(_139[0]); - const _142: rt.u8 = _130(part18); - const part19 = rt.byteSliceAsPtr(_139[1]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_142, _130(part19))), undefined, true); - const part20 = rt.byteSliceAsPtr(rt.byteSliceRange(s, 0)); - rt.byteVecPush(out, _130(part20)); - const part21 = rt.byteSliceAsPtr(rt.optionUnwrap(rt.iterToOption(rt.byteSliceSplit(s, (_25: rt.u8): boolean => { + const byte: rs.Place = rs.DANGLING; + const s: rs.ByteSlice = rs.ptrByteSlice(byte, 0, false); + const part17 = rs.byteSliceAsPtr(s); + rs.byteVecPush(out, _130(part17)); + const _139: [rs.ByteSlice, rs.ByteSlice] = rs.byteSliceSplitAt(s, 0); + const part18 = rs.byteSliceAsPtr(_139[0]); + const _142: rs.u8 = _130(part18); + const part19 = rs.byteSliceAsPtr(_139[1]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_142, _130(part19))), undefined, true); + const part20 = rs.byteSliceAsPtr(rs.byteSliceRange(s, 0)); + rs.byteVecPush(out, _130(part20)); + const part21 = rs.byteSliceAsPtr(rs.optionUnwrap(rs.iterToOption(rs.byteSliceSplit(s, (_25: rs.u8): boolean => { return _25 === 0; }).next()))); - rt.byteVecPush(out, _130(part21)); - const raw: rt.RawSlice = new rt.RawSlice(off, 0); - rt.byteVecPush(out, raw.length & 0xff); - rt.byteVecPush(out, rt.ptrWrappingAdd(raw.ptr, -k, 2, 2) === rt.NULL ? 1 : 0); - const part22 = rt.ptrWrappingAdd(new rt.RawSlice(byte, 0).ptr, 0, 1, 1); - rt.byteVecPush(out, _130(part22)); - let lone: rt.u8 = data.length & 0xff; - const p: rt.Place = rt.place(() => lone, (value) => lone = value); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.byteSliceAsPtr(rt.ptrByteSlice(p, 0, true)), p) & 0xff); - rt.byteVecPush(out, rt.ptrOffsetFrom(rt.byteSliceAsPtr(rt.ptrByteSlice(rt.ptrAdd(p, 1), 0, true)), p) & 0xff); - let held: rt.u8 = lone; - const q: rt.Place = rt.place(() => held, (value2) => held = value2); - const r: rt.ByteSlice = rt.ptrByteSlice(q, 0, false); - rt.byteVecPush(out, rt.u8Add(r.length & 0xff, rt.ptrOffsetFrom(rt.byteSliceAsPtr(r), q) & 0xff)); + rs.byteVecPush(out, _130(part21)); + const raw: rs.RawSlice = new rs.RawSlice(off, 0); + rs.byteVecPush(out, raw.length & 0xff); + rs.byteVecPush(out, rs.ptrWrappingAdd(raw.ptr, -k, 2, 2) === rs.NULL ? 1 : 0); + const part22 = rs.ptrWrappingAdd(new rs.RawSlice(byte, 0).ptr, 0, 1, 1); + rs.byteVecPush(out, _130(part22)); + let lone: rs.u8 = data.length & 0xff; + const p: rs.Place = rs.place(() => lone, (value) => lone = value); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.byteSliceAsPtr(rs.ptrByteSlice(p, 0, true)), p) & 0xff); + rs.byteVecPush(out, rs.ptrOffsetFrom(rs.byteSliceAsPtr(rs.ptrByteSlice(rs.ptrAdd(p, 1), 0, true)), p) & 0xff); + let held: rs.u8 = lone; + const q: rs.Place = rs.place(() => held, (value2) => held = value2); + const r: rs.ByteSlice = rs.ptrByteSlice(q, 0, false); + rs.byteVecPush(out, rs.u8Add(r.length & 0xff, rs.ptrOffsetFrom(rs.byteSliceAsPtr(r), q) & 0xff)); } -export function emit(values: rt.u32[], out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(values), (x: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); +export function emit(values: rs.u32[], out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(values), (x: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); } //# sourceMappingURL=elements.ts.map diff --git a/ts/fixtures/lang/elements/expected/elements/mine/ptr.ts b/ts/fixtures/lang/elements/expected/elements/mine/ptr.ts index 63614033e..899c7db2d 100644 --- a/ts/fixtures/lang/elements/expected/elements/mine/ptr.ts +++ b/ts/fixtures/lang/elements/expected/elements/mine/ptr.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function offsetFrom(a: rt.Place, b: rt.Place): rt.isize { - return rt.isizeAdd(a.v | 0, b.v | 0); +export function offsetFrom(a: rs.Place, b: rs.Place): rs.isize { + return rs.isizeAdd(a.v | 0, b.v | 0); } //# sourceMappingURL=ptr.ts.map diff --git a/ts/fixtures/lang/elements/expected/elements/mine/raw.ts b/ts/fixtures/lang/elements/expected/elements/mine/raw.ts index 5534e81f9..3e3c3de03 100644 --- a/ts/fixtures/lang/elements/expected/elements/mine/raw.ts +++ b/ts/fixtures/lang/elements/expected/elements/mine/raw.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function fromRawPartsMut(p: rt.Place, n: rt.usize): rt.u8 { - return rt.u8WrappingAdd(p.v, n & 0xff); +export function fromRawPartsMut(p: rs.Place, n: rs.usize): rs.u8 { + return rs.u8WrappingAdd(p.v, n & 0xff); } //# sourceMappingURL=raw.ts.map diff --git a/ts/fixtures/lang/elements/expected/harness.ts b/ts/fixtures/lang/elements/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/elements/expected/harness.ts +++ b/ts/fixtures/lang/elements/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/elements/expected/lib.ts b/ts/fixtures/lang/elements/expected/lib.ts index cd6b36fd5..8c3aa4158 100644 --- a/ts/fixtures/lang/elements/expected/lib.ts +++ b/ts/fixtures/lang/elements/expected/lib.ts @@ -1,40 +1,40 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { vecs, arrays, segments, inline, edges, rawSlices, emptyParts } from "./elements.ts"; import * as Inline from "./elements.Inline.ts"; -export function copy$Option_tuple2_u8_u8(v: [rt.u8, rt.u8] | undefined): [rt.u8, rt.u8] | undefined { +export function copy$Option_tuple2_u8_u8(v: [rs.u8, rs.u8] | undefined): [rs.u8, rs.u8] | undefined { return v === undefined ? v : copy$tuple2_u8_u8(v); } -export function copy$array_Option_tuple2_u8_u8(v: Array<[rt.u8, rt.u8] | undefined>): Array<[rt.u8, rt.u8] | undefined> { +export function copy$array_Option_tuple2_u8_u8(v: Array<[rs.u8, rs.u8] | undefined>): Array<[rs.u8, rs.u8] | undefined> { return v.map(copy$Option_tuple2_u8_u8); } -export function copy$mem_MaybeUninit_Option_tuple2_u8_u8(v: [rt.u8, rt.u8] | undefined): [rt.u8, rt.u8] | undefined { +export function copy$mem_MaybeUninit_Option_tuple2_u8_u8(v: [rs.u8, rs.u8] | undefined): [rs.u8, rs.u8] | undefined { if (v === undefined) { return v; } return v === undefined ? v : copy$tuple2_u8_u8(v); } -export function copy$mem_MaybeUninit_array_Option_tuple2_u8_u8(v: Array<[rt.u8, rt.u8] | undefined>): Array<[rt.u8, rt.u8] | undefined> { +export function copy$mem_MaybeUninit_array_Option_tuple2_u8_u8(v: Array<[rs.u8, rs.u8] | undefined>): Array<[rs.u8, rs.u8] | undefined> { if (v === undefined) { return v; } return v.map(copy$mem_MaybeUninit_Option_tuple2_u8_u8); } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } -export function drop$elements_Inline_Option_tuple2_u8_u8(_1: Inline.Inline<[rt.u8, rt.u8] | undefined>): void { +export function drop$elements_Inline_Option_tuple2_u8_u8(_1: Inline.Inline<[rs.u8, rs.u8] | undefined>): void { Inline.drop$ops_Drop_Option_tuple2_u8_u8(_1); } -export function drop$elements_Inline_sync_Arc_u8(_1: Inline.Inline>): void { +export function drop$elements_Inline_sync_Arc_u8(_1: Inline.Inline>): void { Inline.drop$ops_Drop_sync_Arc_u8(_1); } @@ -42,22 +42,22 @@ export function drop$elements_Inline_sync_Arc_u8(_1: Inline.Inline * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["elements::vecs", (_24: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["elements::vecs", (_24: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { vecs(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::arrays", (_25: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::arrays", (_25: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { arrays(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::segments", (_26: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::segments", (_26: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { segments(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::inline", (_27: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::inline", (_27: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { inline(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::edges", (_28: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::edges", (_28: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { edges(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::raw_slices", (_29: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::raw_slices", (_29: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { rawSlices(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::empty_parts", (_210: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["elements::empty_parts", (_210: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { emptyParts(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/ends/expected/core/bool.ts b/ts/fixtures/lang/ends/expected/core/bool.ts index e49e44c3d..71a11ac63 100644 --- a/ts/fixtures/lang/ends/expected/core/bool.ts +++ b/ts/fixtures/lang/ends/expected/core/bool.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$185ufyt(self: boolean, t: rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function thenSome$1ctlqen(self: boolean, t: rs.u8 | undefined): rs.u8 | undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function then$19svsql(self: boolean, f: () => undefined): undefined | rt.None { +export function then$1czl1m8(self: boolean, f: () => undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } f(); return undefined; diff --git a/ts/fixtures/lang/ends/expected/core/option.ts b/ts/fixtures/lang/ends/expected/core/option.ts index dab8b1672..606245ba6 100644 --- a/ts/fixtures/lang/ends/expected/core/option.ts +++ b/ts/fixtures/lang/ends/expected/core/option.ts @@ -1,64 +1,64 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isNoneOr$1s1o3ss(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isNoneOr$0xn3i4j(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return true; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1sj2ls1(self: [rt.usize, rt.u8] | undefined, f: (a0: [rt.usize, rt.u8]) => rt.u8): rt.u8 | undefined { +export function map$0h22a1a(self: [rs.usize, rs.u8] | undefined, f: (a0: [rs.usize, rs.u8]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1fmzefe(self: rt.u8 | undefined, f: (a0: rt.u8) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$1pv2dfs(self: rs.u8 | undefined, f: (a0: rs.u8) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0vbopjd(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.usize): rt.usize | undefined { +export function map$1asu3fq(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.usize): rs.usize | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$05nbzug(self: rt.usize | undefined, f: (a0: rt.usize) => rt.u8): rt.u8 | undefined { +export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function or$1loyskh(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { +export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return optb; } diff --git a/ts/fixtures/lang/ends/expected/ends.Counted.ts b/ts/fixtures/lang/ends/expected/ends.Counted.ts index 0f7eea5c0..9e59d439b 100644 --- a/ts/fixtures/lang/ends/expected/ends.Counted.ts +++ b/ts/fixtures/lang/ends/expected/ends.Counted.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Run from "./ends.Run.ts"; /** A `Run` whose `len` is its own, which reads the run's, as hashlink's `Values` does. */ @@ -8,21 +8,21 @@ export interface Counted { _0: Run.Run; } -export function next$iter_Iterator(self: Counted): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Counted): rs.u8 | rs.Done { return Run.next$iter_Iterator(self._0); } -export function sizeHint$iter_Iterator(self: Counted): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator(self: Counted): [rs.usize, rs.usize | undefined] { return Run.sizeHint$iter_Iterator(self._0); } -export function nextBack$iter_DoubleEndedIterator(self: Counted): rt.u8 | undefined { +export function nextBack$iter_DoubleEndedIterator(self: Counted): rs.u8 | undefined { return Run.nextBack$iter_DoubleEndedIterator(self._0); } -export function len$iter_ExactSizeIterator(self: Counted): rt.usize { +export function len$iter_ExactSizeIterator(self: Counted): rs.usize { Run.logged(self._0, 108); - return rt.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len(); + return rs.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len(); } //# sourceMappingURL=ends.Counted.ts.map diff --git a/ts/fixtures/lang/ends/expected/ends.Flicker.ts b/ts/fixtures/lang/ends/expected/ends.Flicker.ts index 55c15133c..2ce27f85c 100644 --- a/ts/fixtures/lang/ends/expected/ends.Flicker.ts +++ b/ts/fixtures/lang/ends/expected/ends.Flicker.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; /** * Yields every other call to `next`, from either end, ending between: a `FusedIterator` * that isn't, which std's `fuse` reads on from as it would one that is. */ export interface Flicker { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Flicker): rt.u8 | rt.Done { - self._0 = rt.u8WrappingAdd(self._0, 1); - return rt.iterFromOption(thenSome$0d5am30(rt.u8Rem(self._0, 2) === 0, self._0)); +export function next$iter_Iterator(self: Flicker): rs.u8 | rs.Done { + self._0 = rs.u8WrappingAdd(self._0, 1); + return rs.iterFromOption(thenSome$0quywni(rs.u8Rem(self._0, 2) === 0, self._0)); } -export function nextBack$iter_DoubleEndedIterator(self: Flicker): rt.u8 | undefined { - self._0 = rt.u8WrappingAdd(self._0, 3); - return thenSome$0d5am30(rt.u8Rem(self._0, 2) === 0, self._0); +export function nextBack$iter_DoubleEndedIterator(self: Flicker): rs.u8 | undefined { + self._0 = rs.u8WrappingAdd(self._0, 3); + return thenSome$0quywni(rs.u8Rem(self._0, 2) === 0, self._0); } //# sourceMappingURL=ends.Flicker.ts.map diff --git a/ts/fixtures/lang/ends/expected/ends.Guard.ts b/ts/fixtures/lang/ends/expected/ends.Guard.ts index e62688766..1fc3b500e 100644 --- a/ts/fixtures/lang/ends/expected/ends.Guard.ts +++ b/ts/fixtures/lang/ends/expected/ends.Guard.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs `G` as it drops. */ export class Guard { - _0: rt.RefCell; + _0: rs.RefCell; - constructor(_0: rt.RefCell) { + constructor(_0: rs.RefCell) { this._0 = _0; } @@ -16,9 +16,9 @@ export class Guard { } export function drop$ops_Drop(self: Guard): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._0); - rt.byteVecPush(_5.value, 71); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._0); + rs.byteVecPush(_5.value, 71); + rs.refMutRelease(_5); } //# sourceMappingURL=ends.Guard.ts.map diff --git a/ts/fixtures/lang/ends/expected/ends.Lapse.ts b/ts/fixtures/lang/ends/expected/ends.Lapse.ts index c68bc0568..200a58b42 100644 --- a/ts/fixtures/lang/ends/expected/ends.Lapse.ts +++ b/ts/fixtures/lang/ends/expected/ends.Lapse.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Flicker from "./ends.Flicker.ts"; /** As `Flicker`, without its `FusedIterator`, so std's `fuse` ends it at its first `None`. */ @@ -8,7 +8,7 @@ export interface Lapse { _0: Flicker.Flicker; } -export function next$iter_Iterator(self: Lapse): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Lapse): rs.u8 | rs.Done { return Flicker.next$iter_Iterator(self._0); } diff --git a/ts/fixtures/lang/ends/expected/ends.Overrides.ts b/ts/fixtures/lang/ends/expected/ends.Overrides.ts index dc27c7857..3f5f54aea 100644 --- a/ts/fixtures/lang/ends/expected/ends.Overrides.ts +++ b/ts/fixtures/lang/ends/expected/ends.Overrides.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { isNoneOr$1s1o3ss } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { isNoneOr$0xn3i4j } from "./core/option.ts"; import * as Run from "./ends.Run.ts"; /** @@ -18,47 +18,47 @@ export interface Overrides { _0: Run.Run; } -export function next$iter_Iterator(self: Overrides): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Overrides): rs.u8 | rs.Done { return Run.next$iter_Iterator(self._0); } -export function sizeHint$iter_Iterator(self: Overrides): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator(self: Overrides): [rs.usize, rs.usize | undefined] { return Run.sizeHint$iter_Iterator(self._0); } -export function nth$iter_Iterator(self: Overrides, n: rt.usize): rt.u8 | undefined { +export function nth$iter_Iterator(self: Overrides, n: rs.usize): rs.u8 | undefined { Run.logged(self._0, 78); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = n; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = n; while (iterStart++ < iterEnd) { - if (Run.next$iter_Iterator(self._0) === rt.DONE) { + if (Run.next$iter_Iterator(self._0) === rs.DONE) { return undefined; } } - return rt.iterToOption(Run.next$iter_Iterator(self._0)); + return rs.iterToOption(Run.next$iter_Iterator(self._0)); } -export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32(self: Overrides, init: rt.u32 | undefined, f: (a0: rt.u32 | undefined, a1: rt.u8) => rt.u32 | undefined): rt.u32 | undefined { +export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32(self: Overrides, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: rs.u8) => rs.u32 | undefined): rs.u32 | undefined { Run.logged(self._0, 102); - let acc: rt.u32 | undefined = init; + let acc: rs.u32 | undefined = init; while (true) { - const _7: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_7 !== rt.DONE) { + const _7: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_7 !== rs.DONE) { acc = f(acc, _7); } else { break; } } - rt.drop(f); + rs.drop(f); return acc; } -export function fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(self: Overrides, init: rt.u8, f: (a0: rt.u8, a1: rt.u8) => rt.u8): rt.u8 { +export function fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(self: Overrides, init: rs.u8, f: (a0: rs.u8, a1: rs.u8) => rs.u8): rs.u8 { Run.logged(self._0, 102); - let acc: rt.u8 = init; + let acc: rs.u8 = init; while (true) { - const _7: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_7 !== rt.DONE) { + const _7: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_7 !== rs.DONE) { acc = f(acc, _7); } else { return acc; @@ -66,40 +66,40 @@ export function fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(self: } } -export function count$iter_Iterator(self: Overrides): rt.usize { +export function count$iter_Iterator(self: Overrides): rs.usize { Run.logged(self._0, 99); - return Run.left(self._0) as rt.usize; + return Run.left(self._0) as rs.usize; } -export function last$iter_Iterator(self: Overrides): rt.u8 | undefined { +export function last$iter_Iterator(self: Overrides): rs.u8 | undefined { Run.logged(self._0, 76); return Run.nextBack$iter_DoubleEndedIterator(self._0); } -export function find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(self: Overrides, p: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(self: Overrides, p: (a0: rs.u8) => boolean): rs.u8 | undefined { Run.logged(self._0, 70); while (true) { - const _5: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_5 !== rt.DONE) { - const b: rt.u8 = _5; + const _5: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_5 !== rs.DONE) { + const b: rs.u8 = _5; if (p(b)) { - rt.drop(p); + rs.drop(p); return b; } } else { break; } } - rt.drop(p); + rs.drop(p); return undefined; } -export function find$iter_Iterator_ends_found_closure11_ends_Overrides(self: Overrides, p: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function find$iter_Iterator_ends_found_closure11_ends_Overrides(self: Overrides, p: (a0: rs.u8) => boolean): rs.u8 | undefined { Run.logged(self._0, 70); while (true) { - const _5: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_5 !== rt.DONE) { - const b: rt.u8 = _5; + const _5: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_5 !== rs.DONE) { + const b: rs.u8 = _5; if (p(b)) { return b; } @@ -110,38 +110,38 @@ export function find$iter_Iterator_ends_found_closure11_ends_Overrides(self: Ove return undefined; } -export function findMap$iter_Iterator_Option_u8_ends_found_closure14_ends_Overrides(self: Overrides, f: (a0: rt.u8) => rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { +export function findMap$iter_Iterator_Option_u8_ends_found_closure14_ends_Overrides(self: Overrides, f: (a0: rs.u8) => rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { Run.logged(self._0, 77); - return rt.iterFindMap(rt.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f, rt.None); + return rs.iterFindMap(rs.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f, rs.None); } -export function findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32(self: Overrides, f: (a0: rt.u8) => rt.u32 | undefined): rt.u32 | undefined { +export function findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32(self: Overrides, f: (a0: rs.u8) => rs.u32 | undefined): rs.u32 | undefined { Run.logged(self._0, 77); - return rt.dropAfter(f, () => rt.iterFindMap(rt.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f)); + return rs.dropAfter(f, () => rs.iterFindMap(rs.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f)); } -export function findMap$iter_Iterator_u8_ends_found_closure13_ends_Overrides(self: Overrides, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { +export function findMap$iter_Iterator_u8_ends_found_closure13_ends_Overrides(self: Overrides, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { Run.logged(self._0, 77); - return rt.iterFindMap(rt.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f); + return rs.iterFindMap(rs.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), f); } -export function forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit(self: Overrides, f: (a0: rt.u8) => undefined): void { +export function forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit(self: Overrides, f: (a0: rs.u8) => undefined): void { Run.logged(self._0, 69); while (true) { - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { f(_5); } else { break; } } - rt.drop(f); + rs.drop(f); } -export function forEach$iter_Iterator_ends_folded_closure11_ends_Overrides(self: Overrides, f: (a0: rt.u8) => undefined): void { +export function forEach$iter_Iterator_ends_folded_closure11_ends_Overrides(self: Overrides, f: (a0: rs.u8) => undefined): void { Run.logged(self._0, 69); while (true) { - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { f(_5); } else { @@ -150,10 +150,10 @@ export function forEach$iter_Iterator_ends_folded_closure11_ends_Overrides(self: } } -export function forEach$iter_Iterator_ends_found_closure22_ends_Overrides(self: Overrides, f: (a0: rt.u8) => undefined): void { +export function forEach$iter_Iterator_ends_found_closure22_ends_Overrides(self: Overrides, f: (a0: rs.u8) => undefined): void { Run.logged(self._0, 69); while (true) { - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { f(_5); } else { @@ -162,51 +162,51 @@ export function forEach$iter_Iterator_ends_found_closure22_ends_Overrides(self: } } -export function reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(self: Overrides, f: (a0: rt.u8, a1: rt.u8) => rt.u8): rt.u8 | undefined { +export function reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(self: Overrides, f: (a0: rs.u8, a1: rs.u8) => rs.u8): rs.u8 | undefined { Run.logged(self._0, 68); - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { - return rt.iterFold(rt.iterFromFn((): rt.u8 | undefined => { + return rs.iterFold(rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }), _5, f, undefined, true); } - rt.drop(f); + rs.drop(f); return undefined; } -export function reduce$iter_Iterator_ends_found_closure20_ends_Overrides(self: Overrides, f: (a0: rt.u8, a1: rt.u8) => rt.u8): rt.u8 | undefined { +export function reduce$iter_Iterator_ends_found_closure20_ends_Overrides(self: Overrides, f: (a0: rs.u8, a1: rs.u8) => rs.u8): rs.u8 | undefined { Run.logged(self._0, 68); - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { - return rt.iterFold(rt.iterFromFn((): rt.u8 | undefined => { + return rs.iterFold(rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }), _5, f, true); } return undefined; } -export function all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool(self: Overrides, f: (a0: rt.u8) => boolean): boolean { +export function all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool(self: Overrides, f: (a0: rs.u8) => boolean): boolean { Run.logged(self._0, 65); while (true) { - const _5: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_5 !== rt.DONE) { + const _5: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_5 !== rs.DONE) { if (!f(_5)) { - rt.drop(f); + rs.drop(f); return false; } } else { break; } } - rt.drop(f); + rs.drop(f); return true; } -export function all$iter_Iterator_ends_found_closure21_ends_Overrides(self: Overrides, f: (a0: rt.u8) => boolean): boolean { +export function all$iter_Iterator_ends_found_closure21_ends_Overrides(self: Overrides, f: (a0: rs.u8) => boolean): boolean { Run.logged(self._0, 65); while (true) { - const _5: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_5 !== rt.DONE) { + const _5: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_5 !== rs.DONE) { if (!f(_5)) { return false; } @@ -217,14 +217,14 @@ export function all$iter_Iterator_ends_found_closure21_ends_Overrides(self: Over return true; } -export function position$iter_Iterator_ends_found_closure18_ends_Overrides(self: Overrides, p: (a0: rt.u8) => boolean): rt.usize | undefined { +export function position$iter_Iterator_ends_found_closure18_ends_Overrides(self: Overrides, p: (a0: rs.u8) => boolean): rs.usize | undefined { Run.logged(self._0, 80); - let i: rt.usize = 0; + let i: rs.usize = 0; while (true) { - const _6: rt.u8 | rt.Done = Run.next$iter_Iterator(self._0); - if (_6 !== rt.DONE) { + const _6: rs.u8 | rs.Done = Run.next$iter_Iterator(self._0); + if (_6 !== rs.DONE) { if (!p(_6)) { - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } else { return i; } @@ -235,14 +235,14 @@ export function position$iter_Iterator_ends_found_closure18_ends_Overrides(self: return undefined; } -export function max$iter_Iterator(self: Overrides): rt.u8 | undefined { +export function max$iter_Iterator(self: Overrides): rs.u8 | undefined { Run.logged(self._0, 88); - let best: rt.u8 | undefined = undefined; + let best: rs.u8 | undefined = undefined; while (true) { - const _5: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _5: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_5 !== undefined) { - const b: rt.u8 = _5; - if (isNoneOr$1s1o3ss(best, (m: rt.u8): boolean => { + const b: rs.u8 = _5; + if (isNoneOr$0xn3i4j(best, (m: rs.u8): boolean => { return b > m; })) { best = b; @@ -253,17 +253,17 @@ export function max$iter_Iterator(self: Overrides): rt.u8 | undefined { } } -export function isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool(self: Overrides, compare: (a0: rt.u8, a1: rt.u8) => boolean): boolean { +export function isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool(self: Overrides, compare: (a0: rs.u8, a1: rs.u8) => boolean): boolean { let _0!: boolean; Run.logged(self._0, 83); - const _6: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _6: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); b1: { if (_6 !== undefined) { - let last: rt.u8 = _6; + let last: rs.u8 = _6; while (true) { - const _9: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _9: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_9 !== undefined) { - const b: rt.u8 = _9; + const b: rs.u8 = _9; if (!compare(b, last)) { _0 = false; break b1; @@ -273,26 +273,26 @@ export function isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_r break; } } - rt.drop(compare); + rs.drop(compare); return true; } _0 = true; } - rt.drop(compare); + rs.drop(compare); return _0; } -export function isSortedBy$iter_Iterator_ends_found_closure17_ends_Overrides(self: Overrides, compare: (a0: rt.u8, a1: rt.u8) => boolean): boolean { +export function isSortedBy$iter_Iterator_ends_found_closure17_ends_Overrides(self: Overrides, compare: (a0: rs.u8, a1: rs.u8) => boolean): boolean { let _0!: boolean; Run.logged(self._0, 83); - const _6: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _6: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); b1: { if (_6 !== undefined) { - let last: rt.u8 = _6; + let last: rs.u8 = _6; while (true) { - const _9: rt.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); + const _9: rs.u8 | undefined = Run.nextBack$iter_DoubleEndedIterator(self._0); if (_9 !== undefined) { - const b: rt.u8 = _9; + const b: rs.u8 = _9; if (!compare(b, last)) { _0 = false; break b1; @@ -302,33 +302,33 @@ export function isSortedBy$iter_Iterator_ends_found_closure17_ends_Overrides(sel break; } } - rt.drop(compare); + rs.drop(compare); return true; } _0 = true; } - rt.drop(compare); + rs.drop(compare); return _0; } -export function collect$iter_Iterator_Vec_u8(self: Overrides): rt.ByteVec { +export function collect$iter_Iterator_Vec_u8(self: Overrides): rs.ByteVec { Run.logged(self._0, 67); - return rt.iterToByteVec(rt.iterRev(rt.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rt.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rt.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rt.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rt.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rt.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rt.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rt.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + return rs.iterToByteVec(rs.iterRev(rs.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rs.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rs.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rs.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rs.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rs.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rs.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rs.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } -export function collect$iter_Iterator_boxed_Box_slice_u8(self: Overrides): rt.ByteSlice { +export function collect$iter_Iterator_boxed_Box_slice_u8(self: Overrides): rs.ByteSlice { Run.logged(self._0, 67); - return rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rt.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rt.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rt.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rt.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rt.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rt.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rt.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); + return rs.byteVecSlice(rs.iterToByteVec(rs.iterRev(rs.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rs.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rs.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rs.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rs.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rs.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rs.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rs.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); } -export function eq$iter_Iterator_ops_Range_u8(self: Overrides, other: rt.Range): boolean { +export function eq$iter_Iterator_ops_Range_u8(self: Overrides, other: rs.Range): boolean { Run.logged(self._0, 81); - return rt.iterEq(rt.iterRev(rt.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rt.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rt.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rt.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rt.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rt.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rt.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rt.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.same, undefined, true); + return rs.iterEq(rs.iterRev(rs.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rs.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rs.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rs.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rs.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rs.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rs.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rs.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true); } -export function partialCmp$iter_Iterator_ops_Range_u8(self: Overrides, other: rt.Range): rt.Ordering | undefined { +export function partialCmp$iter_Iterator_ops_Range_u8(self: Overrides, other: rs.Range): rs.Ordering | undefined { Run.logged(self._0, 79); - return rt.iterCmp(rt.iterRev(rt.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rt.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rt.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rt.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rt.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rt.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rt.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rt.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true); + return rs.iterCmp(rs.iterRev(rs.iterFrom(self, next$iter_Iterator, undefined, { hint: sizeHint$iter_Iterator, nth: (it: Overrides, n) => rs.iterFromOption(nth$iter_Iterator(it, n)), fold: fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: count$iter_Iterator, last: (it: Overrides) => rs.iterFromOption(last$iter_Iterator(it)), find: (it: Overrides, f) => rs.iterFromOption(find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides, f) => rs.iterFromOption(reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides) => rs.iterFromOption(nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides, n) => rs.iterFromOption(nthBack$iter_DoubleEndedIterator(it, n)), rfold: rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides, f) => rs.iterFromOption(rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); } export function byRef$iter_Iterator(self: Overrides): Overrides { @@ -336,14 +336,14 @@ export function byRef$iter_Iterator(self: Overrides): Overrides { return self; } -export function nextBack$iter_DoubleEndedIterator(self: Overrides): rt.u8 | undefined { +export function nextBack$iter_DoubleEndedIterator(self: Overrides): rs.u8 | undefined { return Run.nextBack$iter_DoubleEndedIterator(self._0); } -export function nthBack$iter_DoubleEndedIterator(self: Overrides, n: rt.usize): rt.u8 | undefined { +export function nthBack$iter_DoubleEndedIterator(self: Overrides, n: rs.usize): rs.u8 | undefined { Run.logged(self._0, 66); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = n; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = n; while (iterStart++ < iterEnd) { if (Run.nextBack$iter_DoubleEndedIterator(self._0) === undefined) { return undefined; @@ -352,51 +352,51 @@ export function nthBack$iter_DoubleEndedIterator(self: Overrides, n: rt.usize): return Run.nextBack$iter_DoubleEndedIterator(self._0); } -export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32(self: Overrides, init: rt.u32 | undefined, f: (a0: rt.u32 | undefined, a1: rt.u8) => rt.u32 | undefined): rt.u32 | undefined { +export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32(self: Overrides, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: rs.u8) => rs.u32 | undefined): rs.u32 | undefined { Run.logged(self._0, 114); - const _6: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { + const _6: rs.Iter = rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }); let captured = f; - return rt.iterFold(_6, init, rt.closure((acc: rt.u32 | undefined, b: rt.u8): rt.u32 | undefined => { + return rs.iterFold(_6, init, rs.closure((acc: rs.u32 | undefined, b: rs.u8): rs.u32 | undefined => { return captured(acc, b); }, (): void => { - rt.drop(captured); + rs.drop(captured); }), undefined, true); } -export function rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(self: Overrides, init: rt.u8, f: (a0: rt.u8, a1: rt.u8) => rt.u8): rt.u8 { +export function rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(self: Overrides, init: rs.u8, f: (a0: rs.u8, a1: rs.u8) => rs.u8): rs.u8 { Run.logged(self._0, 114); - const _6: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { + const _6: rs.Iter = rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }); let captured = f; - return rt.iterFold(_6, init, (acc: rt.u8, b: rt.u8): rt.u8 => { + return rs.iterFold(_6, init, (acc: rs.u8, b: rs.u8): rs.u8 => { return captured(acc, b); }, true); } -export function rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(self: Overrides, p: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(self: Overrides, p: (a0: rs.u8) => boolean): rs.u8 | undefined { Run.logged(self._0, 82); - const _6: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { + const _6: rs.Iter = rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }); let captured = p; - const _9: (a0: rt.u8) => boolean = rt.closure((b: rt.u8): boolean => { + const _9: (a0: rs.u8) => boolean = rs.closure((b: rs.u8): boolean => { return captured(b); }, (): void => { - rt.drop(captured); + rs.drop(captured); }); - return rt.dropAfter(_9, () => rt.iterFind(_6, _9)); + return rs.dropAfter(_9, () => rs.iterFind(_6, _9)); } -export function rfind$iter_DoubleEndedIterator_ends_found_closure12_ends_Overrides(self: Overrides, p: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function rfind$iter_DoubleEndedIterator_ends_found_closure12_ends_Overrides(self: Overrides, p: (a0: rs.u8) => boolean): rs.u8 | undefined { Run.logged(self._0, 82); - const _6: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { + const _6: rs.Iter = rs.iterFromFn((): rs.u8 | undefined => { return Run.nextBack$iter_DoubleEndedIterator(self._0); }); let captured = p; - return rt.iterFind(_6, (b: rt.u8): boolean => { + return rs.iterFind(_6, (b: rs.u8): boolean => { return captured(b); }); } diff --git a/ts/fixtures/lang/ends/expected/ends.Pairs.ts b/ts/fixtures/lang/ends/expected/ends.Pairs.ts index ef6060d49..e3bcc3c60 100644 --- a/ts/fixtures/lang/ends/expected/ends.Pairs.ts +++ b/ts/fixtures/lang/ends/expected/ends.Pairs.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { map$1fmzefe as option_map$1fmzefe } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { map$1pv2dfs as option_map$1pv2dfs } from "./core/option.ts"; import * as Overrides from "./ends.Overrides.ts"; import * as Run from "./ends.Run.ts"; @@ -11,71 +11,71 @@ import * as Run from "./ends.Run.ts"; */ export class Pairs { _0: I; - _1: rt.RefCell; + _1: rs.RefCell; - constructor(_0: I, _1: rt.RefCell) { + constructor(_0: I, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } } -export function next$iter_Iterator_boxed_Box_ends_Overrides(self: Pairs): [rt.u8, rt.u8] | rt.Done { - return rt.iterFromOption(option_map$1fmzefe(rt.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function next$iter_Iterator_boxed_Box_ends_Overrides(self: Pairs): [rs.u8, rs.u8] | rs.Done { + return rs.iterFromOption(option_map$1pv2dfs(rs.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; })); } -export function next$iter_Iterator_ends_Overrides(self: Pairs): [rt.u8, rt.u8] | rt.Done { - return rt.iterFromOption(option_map$1fmzefe(rt.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function next$iter_Iterator_ends_Overrides(self: Pairs): [rs.u8, rs.u8] | rs.Done { + return rs.iterFromOption(option_map$1pv2dfs(rs.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; })); } -export function next$iter_Iterator_ends_Run(self: Pairs): [rt.u8, rt.u8] | rt.Done { - return rt.iterFromOption(option_map$1fmzefe(rt.iterToOption(Run.next$iter_Iterator(self._0)), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function next$iter_Iterator_ends_Run(self: Pairs): [rs.u8, rs.u8] | rs.Done { + return rs.iterFromOption(option_map$1pv2dfs(rs.iterToOption(Run.next$iter_Iterator(self._0)), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; })); } -export function next$iter_Iterator_mut_ends_Overrides(self: Pairs): [rt.u8, rt.u8] | rt.Done { - return rt.iterFromOption(option_map$1fmzefe(rt.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function next$iter_Iterator_mut_ends_Overrides(self: Pairs): [rs.u8, rs.u8] | rs.Done { + return rs.iterFromOption(option_map$1pv2dfs(rs.iterToOption(Overrides.next$iter_Iterator(self._0)), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; })); } -export function collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rt.Vec<[rt.u8, rt.u8]> { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, 75); - rt.refMutRelease(_5); - return rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterBox(rt.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rs.Vec<[rs.u8, rs.u8]> { + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, 75); + rs.refMutRelease(_5); + return rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterBox(rs.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; }), "next", 2); } -export function collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rt.Vec<[rt.u8, rt.u8]> { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, 75); - rt.refMutRelease(_5); - return rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rs.Vec<[rs.u8, rs.u8]> { + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, 75); + rs.refMutRelease(_5); + return rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; }), "next", 2); } -export function collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(self: Pairs): rt.Vec<[rt.u8, rt.u8]> { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, 75); - rt.refMutRelease(_5); - return rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(self: Pairs): rs.Vec<[rs.u8, rs.u8]> { + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, 75); + rs.refMutRelease(_5); + return rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterFrom(self._0, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; }), "next", 2); } -export function collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rt.Vec<[rt.u8, rt.u8]> { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, 75); - rt.refMutRelease(_5); - return rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b: rt.u8): [rt.u8, rt.u8] => { - return [rt.u8Div(b, 2), b] as [rt.u8, rt.u8]; +export function collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(self: Pairs): rs.Vec<[rs.u8, rs.u8]> { + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, 75); + rs.refMutRelease(_5); + return rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterFrom(self._0, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b: rs.u8): [rs.u8, rs.u8] => { + return [rs.u8Div(b, 2), b] as [rs.u8, rs.u8]; }), "next", 2); } diff --git a/ts/fixtures/lang/ends/expected/ends.Run.ts b/ts/fixtures/lang/ends/expected/ends.Run.ts index cf2990809..1465356c4 100644 --- a/ts/fixtures/lang/ends/expected/ends.Run.ts +++ b/ts/fixtures/lang/ends/expected/ends.Run.ts @@ -1,56 +1,56 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { map$0vbopjd as option_map$0vbopjd } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { map$1asu3fq as option_map$1asu3fq } from "./core/option.ts"; /** * The items `front..back`, read from either end, logging each call of its methods: `n`, * `b`, `h`, and `l`, each with how many items it has left. */ export interface Run { - front: rt.u8; - back: rt.u8; + front: rs.u8; + back: rs.u8; /** * What `size_hint` adds to its upper bound, or `None` for none: past 0, it lies, and * std's `len` of it panics. */ - over: rt.u8 | undefined; - log: rt.RefCell; + over: rs.u8 | undefined; + log: rs.RefCell; } -export function left(self: Run): rt.u8 { - return rt.u8Sub(self.back, self.front); +export function left(self: Run): rs.u8 { + return rs.u8Sub(self.back, self.front); } -export function logged(self: Run, what: rt.u8): void { - const _6: rt.RefCell = rt.refCellBorrowMut(self.log); +export function logged(self: Run, what: rs.u8): void { + const _6: rs.RefCell = rs.refCellBorrowMut(self.log); const _7: Uint8Array = Uint8Array.of(what, left(self)); - rt.iterExtendBytes(_6.value, rt.iterSlice(_7), undefined, true); - rt.refMutRelease(_6); + rs.iterExtendBytes(_6.value, rs.iterSlice(_7), undefined, true); + rs.refMutRelease(_6); } -export function next$iter_Iterator(self: Run): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Run): rs.u8 | rs.Done { logged(self, 110); if (!(self.front === self.back)) { - self.front = rt.u8Add(self.front, 1); - return rt.u8Sub(self.front, 1); + self.front = rs.u8Add(self.front, 1); + return rs.u8Sub(self.front, 1); } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator(self: Run): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator(self: Run): [rs.usize, rs.usize | undefined] { logged(self, 104); - const left_: rt.usize = left(self) as rt.usize; - const _5: rt.usize | undefined = option_map$0vbopjd(self.over, (over: rt.u8): rt.usize => { - return rt.usizeAdd(left_, over as rt.usize); + const left_: rs.usize = left(self) as rs.usize; + const _5: rs.usize | undefined = option_map$1asu3fq(self.over, (over: rs.u8): rs.usize => { + return rs.usizeAdd(left_, over as rs.usize); }); - return [left_, _5] as [rt.usize, rt.usize | undefined]; + return [left_, _5] as [rs.usize, rs.usize | undefined]; } -export function nextBack$iter_DoubleEndedIterator(self: Run): rt.u8 | undefined { +export function nextBack$iter_DoubleEndedIterator(self: Run): rs.u8 | undefined { logged(self, 98); if (!(self.front === self.back)) { - self.back = rt.u8Sub(self.back, 1); + self.back = rs.u8Sub(self.back, 1); return self.back; } return undefined; diff --git a/ts/fixtures/lang/ends/expected/ends.ts b/ts/fixtures/lang/ends/expected/ends.ts index 06d7a88fe..45ed8e289 100644 --- a/ts/fixtures/lang/ends/expected/ends.ts +++ b/ts/fixtures/lang/ends/expected/ends.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$185ufyt, thenSome$0d5am30, then$19svsql } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1sj2ls1 as option_map$1sj2ls1, map$05nbzug as option_map$05nbzug, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$02k4ito as option_mapOr$02k4ito, or$1loyskh as option_or$1loyskh } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { thenSome$1ctlqen, thenSome$0quywni, then$1czl1m8 } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0h22a1a as option_map$0h22a1a, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$188iunt as option_mapOr$188iunt, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; import * as Counted from "./ends.Counted.ts"; import * as Flicker from "./ends.Flicker.ts"; import * as Guard from "./ends.Guard.ts"; @@ -12,16 +12,16 @@ import * as Pairs from "./ends.Pairs.ts"; import * as Run from "./ends.Run.ts"; /** An item, or 0xff for `None`. */ -export function put(out: rt.ByteVec, item: rt.u8 | undefined): void { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(item, 255)); +export function put(out: rs.ByteVec, item: rs.u8 | undefined): void { + rs.byteVecPush(out, option_unwrapOr$1fr498u(item, 255)); } /** A hint, the upper bound 0xff for `None`. */ -export function putHint(out: rt.ByteVec, _2: [rt.usize, rt.usize | undefined]): void { - const lower: rt.usize = _2[0]; - const upper: rt.usize | undefined = _2[1]; - rt.byteVecPush(out, lower & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(upper, 255, (upper2: rt.usize): rt.u8 => { +export function putHint(out: rs.ByteVec, _2: [rs.usize, rs.usize | undefined]): void { + const lower: rs.usize = _2[0]; + const upper: rs.usize | undefined = _2[1]; + rs.byteVecPush(out, lower & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(upper, 255, (upper2: rs.usize): rs.u8 => { return upper2 & 0xff; })); } @@ -30,9 +30,9 @@ export function putHint(out: rt.ByteVec, _2: [rt.usize, rt.usize | undefined]): * A `Vec` collected or extended by `items`, by its length and capacity: what std reserved * by their hints. */ -export function putVec(out: rt.ByteVec, v: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(v.length & 0xff, v.data.length & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); +export function putVec(out: rs.ByteVec, v: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(v.length & 0xff, v.data.length & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); } /** @@ -43,54 +43,54 @@ export function putVec(out: rt.ByteVec, v: rt.ByteVec): void { * eighteenth, by value, borrowed, or boxed, with what each read and each call of its * methods logged. */ -export function ends(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let over!: rt.u8 | undefined; - let item!: rt.u8 | undefined; +export function ends(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let over!: rs.u8 | undefined; + let item!: rs.u8 | undefined; if (dataLen >= 2) { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const over2: rt.u8 = rt.u8Shr(dataData[dataStart], 4) & 3; + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const over2: rs.u8 = rs.u8Shr(dataData[dataStart], 4) & 3; if (over2 === 0) { over = undefined; } else { - over = rt.u8Sub(over2, 1); + over = rs.u8Sub(over2, 1); } - const run: Run.Run = { front: 0, back: rt.u8Rem(dataData[dataStart], 16), over, log }; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2))), 8); + const run: Run.Run = { front: 0, back: rs.u8Rem(dataData[dataStart], 16), over, log }; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), 8); while (true) { - const _25: rt.u8 | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.u8 | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - const step: rt.u8 = _25; - const _29: rt.u8 = rt.u8Rem(step, 8); + const step: rs.u8 = _25; + const _29: rs.u8 = rs.u8Rem(step, 8); if (_29 === 0) { - put(out, rt.iterToOption(Run.next$iter_Iterator(run))); + put(out, rs.iterToOption(Run.next$iter_Iterator(run))); } else if (_29 === 1) { put(out, Run.nextBack$iter_DoubleEndedIterator(run)); } else if (_29 === 2) { - const _37: rt.usize = rt.usizeRem(step >> 3 as rt.usize, 4); - put(out, rt.iterNthBack(rt.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _37)); + const _37: rs.usize = rs.usizeRem(step >> 3 as rs.usize, 4); + put(out, rs.iterNthBack(rs.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _37)); } else if (_29 === 3) { - rt.byteVecPush(out, rt.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else if (_29 === 4) { putHint(out, Run.sizeHint$iter_Iterator(run)); } else if (_29 === 5) { if (!((step & 8) === 0)) { put(out, Run.nextBack$iter_DoubleEndedIterator(run)); } else { - put(out, rt.iterToOption(rt.iterRev(rt.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })).next())); + put(out, rs.iterToOption(rs.iterRev(rs.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })).next())); } } else if (_29 === 6) { - rt.byteVecPush(out, rt.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else { - const _62: rt.usize = rt.usizeRem(step >> 3 as rt.usize, 4); - put(out, rt.iterNth(rt.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _62)); + const _62: rs.usize = rs.usizeRem(step >> 3 as rs.usize, 4); + put(out, rs.iterNth(rs.iterFrom(run, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _62)); } } - const k: rt.usize = rt.u8Shr(dataData[dataStart + 1], 4) as rt.usize; - const pick: rt.u8 = rt.u8Rem(dataData[dataStart + 1], 16); + const k: rs.usize = rs.u8Shr(dataData[dataStart + 1], 4) as rs.usize; + const pick: rs.u8 = rs.u8Rem(dataData[dataStart + 1], 16); b4: { - const _72: rt.u8 = rt.u8Rem(kind, 22); + const _72: rs.u8 = rs.u8Rem(kind, 22); if (_72 === 0) { consumed$ends_Run(run, pick, k, out); } else if (_72 === 1) { @@ -108,11 +108,11 @@ export function ends(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } else if (_72 === 11) { folded$boxed_Box_ends_Overrides({ _0: run }, pick, k, log, out); } else if (_72 === 12) { - consumed$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure0(rt.iterMap(rt.iterFrom({ _0: run }, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b2: rt.u8): rt.u8 => { + consumed$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure0(rs.iterMap(rs.iterFrom({ _0: run }, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b2: rs.u8): rs.u8 => { return b2; }), pick, k, out); } else if (_72 === 13) { - folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(rt.iterMap(rt.iterFrom({ _0: run }, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b: rt.u8): rt.u8 => { + folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(rs.iterMap(rs.iterFrom({ _0: run }, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b: rs.u8): rs.u8 => { return b; }), pick, k, log, out); } else if (_72 === 14) { @@ -136,14 +136,14 @@ export function ends(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } else if (_72 === 2 || _72 === 7) { fuses(dataData[dataStart + 1], out); } else { - let bits: rt.u8 = dataData[dataStart + 1]; + let bits: rs.u8 = dataData[dataStart + 1]; while (true) { if ((bits & 1) === 0) { - item = rt.iterToOption(Run.next$iter_Iterator(run)); + item = rs.iterToOption(Run.next$iter_Iterator(run)); } else { item = Run.nextBack$iter_DoubleEndedIterator(run); } - bits = rt.intRotateRight(bits, 1, 8, false); + bits = rs.intRotateRight(bits, 1, 8, false); put(out, item); if (item === undefined) { put(out, Run.nextBack$iter_DoubleEndedIterator(run)); @@ -152,468 +152,468 @@ export function ends(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataL } } } - rt.byteVecPush(out, 254); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log.value), undefined, true); + rs.byteVecPush(out, 254); + rs.iterExtendBytes(out, rs.byteVecIntoIter(log.value), undefined, true); } } /** `it`, consumed by std's adaptor or consumer `pick`, with `k` its count where it takes one. */ -export function consumed$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, out: rt.ByteVec): void { - let _32!: rt.u8 | undefined; +export function consumed$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, out: rs.ByteVec): void { + let _32!: rs.u8 | undefined; if (pick === 0) { - putVec(out, rt.iterToByteVec(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), "next")); + putVec(out, rs.iterToByteVec(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), "next")); } else if (pick === 1) { - putVec(out, rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); + putVec(out, rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); } else if (pick === 2) { - rt.byteVecPush(out, rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))).len() & 0xff); + rs.byteVecPush(out, rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))).len() & 0xff); } else if (pick === 3) { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterRev(rt.iterEnumerate(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))), (_211: [rt.usize, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterRev(rs.iterEnumerate(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))), (_211: [rs.usize, rs.u8]): Uint8Array => { return Uint8Array.of(_211[0] & 0xff, _211[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), "next"); + }, (value: Uint8Array) => rs.iterSlice(value), false, 2), "next"); } else if (pick === 4) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSkip(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterSkip(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), k)), "next"); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterTake(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterTake(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), k)), "next"); } else if (pick === 6) { const _27: Overrides.Overrides = it; - const _28: rt.usize = rt.max(k, 1); - rt.iterExtendBytes(out, rt.iterRev(rt.iterStepBy(rt.iterBox(rt.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _28)), "next"); + const _28: rs.usize = rs.max(k, 1); + rs.iterExtendBytes(out, rs.iterRev(rs.iterStepBy(rs.iterBox(rs.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _28)), "next"); } else if (pick === 7) { - put(out, option_map$05nbzug(rt.iterRposition(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b8: rt.u8): boolean => { - return rt.u8Rem(b8, 3) === 0; - }), (i3: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterRposition(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b8: rs.u8): boolean => { + return rs.u8Rem(b8, 3) === 0; + }), (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); } else if (pick === 8) { - const _33: rt.usize = rt.usizeRem(k, 4); + const _33: rs.usize = rs.usizeRem(k, 4); if (_33 === 0) { const _37: Overrides.Overrides = it; - const _38: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterSkip(rt.iterBox(rt.iterFrom(_37, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _38), (b7: rt.u8): boolean => { - return rt.u8Rem(b7, 3) === 0; + const _38: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterSkip(rs.iterBox(rs.iterFrom(_37, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _38), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) === 0; }); } else if (_33 === 1) { const _42: Overrides.Overrides = it; - const _43: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterTake(rt.iterBox(rt.iterFrom(_42, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _43), (b6: rt.u8): boolean => { - return rt.u8Rem(b6, 3) === 0; + const _43: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterTake(rs.iterBox(rs.iterFrom(_42, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _43), (b6: rs.u8): boolean => { + return rs.u8Rem(b6, 3) === 0; }); } else if (_33 === 2) { - _32 = option_map$1sj2ls1(rt.iterRfind(rt.iterEnumerate(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (_2: [rt.usize, rt.u8]): boolean => { - return rt.u8Rem(rt.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; - }), (_210: [rt.usize, rt.u8]): rt.u8 => { + _32 = option_map$0h22a1a(rs.iterRfind(rs.iterEnumerate(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (_2: [rs.usize, rs.u8]): boolean => { + return rs.u8Rem(rs.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; + }), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }); } else { const _51: Overrides.Overrides = it; - const _52: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - _32 = rt.iterRfind(rt.iterStepBy(rt.iterBox(rt.iterFrom(_51, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _52), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 3) === 0; + const _52: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + _32 = rs.iterRfind(rs.iterStepBy(rs.iterBox(rs.iterFrom(_51, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _52), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 3) === 0; }); } put(out, _32); } else if (pick === 9) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); } else if (pick === 10) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b2: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.iterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b2: rs.u8): rs.u8 => { return b2 ^ 85; })), k), "next"); } else if (pick === 11) { - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(170)); - const _67: rt.Iter = rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k); - rt.iterExtendBytes(v, _67, "next"); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(170)); + const _67: rs.Iter = rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k); + rs.iterExtendBytes(v, _67, "next"); putVec(out, v); - rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); + rs.byteVecPush(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); } else if (pick === 12) { - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), new rt.Range(0, 5)); + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), new rs.Range(0, 5)); while (true) { - const _79: [rt.u8, rt.u8] | undefined = rt.iterToOption(zip.nextBack()); + const _79: [rs.u8, rs.u8] | undefined = rs.iterToOption(zip.nextBack()); if (_79 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); } else { break; } } } else if (pick === 13) { - const fused: rt.Iter = rt.iterFuse(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); - put(out, rt.iterToOption(fused.nextBack())); - rt.byteVecPush(out, fused.len() & 0xff); - rt.iterExtendBytes(out, fused, "next"); + const fused: rs.Iter = rs.iterFuse(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); + put(out, rs.iterToOption(fused.nextBack())); + rs.byteVecPush(out, fused.len() & 0xff); + rs.iterExtendBytes(out, fused, "next"); } else if (pick === 14) { - put(out, rt.iterNth(rt.iterRev(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8)))), k)); + put(out, rs.iterNth(rs.iterRev(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8)))), k)); } else { - const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, peek.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(peek), "next"); + const peek: rs.Peekable = rs.iterPeekable(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, peek.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(peek), "next"); } } /** `it`, consumed by std's adaptor or consumer `pick`, with `k` its count where it takes one. */ -export function consumed$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure0(it: rt.Iter, pick: rt.u8, k: rt.usize, out: rt.ByteVec): void { - let _32!: rt.u8 | undefined; +export function consumed$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure0(it: rs.Iter, pick: rs.u8, k: rs.usize, out: rs.ByteVec): void { + let _32!: rs.u8 | undefined; if (pick === 0) { - putVec(out, rt.iterToByteVec(rt.iterRev(rt.iterBox(it)), "next")); + putVec(out, rs.iterToByteVec(rs.iterRev(rs.iterBox(it)), "next")); } else if (pick === 1) { - putVec(out, rt.iterToByteVec(rt.iterBox(it), "next")); + putVec(out, rs.iterToByteVec(rs.iterBox(it), "next")); } else if (pick === 2) { - rt.byteVecPush(out, rt.iterRev(rt.iterBox(it)).len() & 0xff); + rs.byteVecPush(out, rs.iterRev(rs.iterBox(it)).len() & 0xff); } else if (pick === 3) { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterRev(rt.iterEnumerate(rt.iterBox(it))), (_211: [rt.usize, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterRev(rs.iterEnumerate(rs.iterBox(it))), (_211: [rs.usize, rs.u8]): Uint8Array => { return Uint8Array.of(_211[0] & 0xff, _211[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), "next"); + }, (value: Uint8Array) => rs.iterSlice(value), false, 2), "next"); } else if (pick === 4) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSkip(rt.iterBox(it), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterSkip(rs.iterBox(it), k)), "next"); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterTake(rt.iterBox(it), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterTake(rs.iterBox(it), k)), "next"); } else if (pick === 6) { - const _27: rt.Iter = it; - const _28: rt.usize = rt.max(k, 1); - rt.iterExtendBytes(out, rt.iterRev(rt.iterStepBy(rt.iterBox(_27), _28)), "next"); + const _27: rs.Iter = it; + const _28: rs.usize = rs.max(k, 1); + rs.iterExtendBytes(out, rs.iterRev(rs.iterStepBy(rs.iterBox(_27), _28)), "next"); } else if (pick === 7) { - put(out, option_map$05nbzug(rt.iterRposition(rt.iterBox(it), (b8: rt.u8): boolean => { - return rt.u8Rem(b8, 3) === 0; - }), (i3: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterRposition(rs.iterBox(it), (b8: rs.u8): boolean => { + return rs.u8Rem(b8, 3) === 0; + }), (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); } else if (pick === 8) { - const _33: rt.usize = rt.usizeRem(k, 4); + const _33: rs.usize = rs.usizeRem(k, 4); if (_33 === 0) { - const _37: rt.Iter = it; - const _38: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterSkip(rt.iterBox(_37), _38), (b7: rt.u8): boolean => { - return rt.u8Rem(b7, 3) === 0; + const _37: rs.Iter = it; + const _38: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterSkip(rs.iterBox(_37), _38), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) === 0; }); } else if (_33 === 1) { - const _42: rt.Iter = it; - const _43: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterTake(rt.iterBox(_42), _43), (b6: rt.u8): boolean => { - return rt.u8Rem(b6, 3) === 0; + const _42: rs.Iter = it; + const _43: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterTake(rs.iterBox(_42), _43), (b6: rs.u8): boolean => { + return rs.u8Rem(b6, 3) === 0; }); } else if (_33 === 2) { - _32 = option_map$1sj2ls1(rt.iterRfind(rt.iterEnumerate(rt.iterBox(it)), (_2: [rt.usize, rt.u8]): boolean => { - return rt.u8Rem(rt.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; - }), (_210: [rt.usize, rt.u8]): rt.u8 => { + _32 = option_map$0h22a1a(rs.iterRfind(rs.iterEnumerate(rs.iterBox(it)), (_2: [rs.usize, rs.u8]): boolean => { + return rs.u8Rem(rs.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; + }), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }); } else { - const _51: rt.Iter = it; - const _52: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - _32 = rt.iterRfind(rt.iterStepBy(rt.iterBox(_51), _52), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 3) === 0; + const _51: rs.Iter = it; + const _52: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + _32 = rs.iterRfind(rs.iterStepBy(rs.iterBox(_51), _52), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 3) === 0; }); } put(out, _32); } else if (pick === 9) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(it)))); + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(it)))); } else if (pick === 10) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.iterMap(rt.iterBox(it), (b2: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.iterMap(rs.iterBox(it), (b2: rs.u8): rs.u8 => { return b2 ^ 85; })), k), "next"); } else if (pick === 11) { - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(170)); - const _67: rt.Iter = rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))), k); - rt.iterExtendBytes(v, _67, "next"); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(170)); + const _67: rs.Iter = rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it))), k); + rs.iterExtendBytes(v, _67, "next"); putVec(out, v); - rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); + rs.byteVecPush(out, rs.iterBox(it).len() & 0xff); } else if (pick === 12) { - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterBox(it), new rt.Range(0, 5)); + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterBox(it), new rs.Range(0, 5)); while (true) { - const _79: [rt.u8, rt.u8] | undefined = rt.iterToOption(zip.nextBack()); + const _79: [rs.u8, rs.u8] | undefined = rs.iterToOption(zip.nextBack()); if (_79 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); } else { break; } } } else if (pick === 13) { - const fused: rt.Iter = rt.iterFuse(rt.iterBox(it)); - put(out, rt.iterToOption(fused.nextBack())); - rt.byteVecPush(out, fused.len() & 0xff); - rt.iterExtendBytes(out, fused, "next"); + const fused: rs.Iter = rs.iterFuse(rs.iterBox(it)); + put(out, rs.iterToOption(fused.nextBack())); + rs.byteVecPush(out, fused.len() & 0xff); + rs.iterExtendBytes(out, fused, "next"); } else if (pick === 14) { - put(out, rt.iterNth(rt.iterRev(rt.iterChain(rt.iterBox(it), rt.iterSlice(Uint8Array.of(7, 8)))), k)); + put(out, rs.iterNth(rs.iterRev(rs.iterChain(rs.iterBox(it), rs.iterSlice(Uint8Array.of(7, 8)))), k)); } else { - const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(it)); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, peek.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(peek), "next"); + const peek: rs.Peekable = rs.iterPeekable(rs.iterBox(it)); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, peek.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(peek), "next"); } } /** `it`, consumed by std's adaptor or consumer `pick`, with `k` its count where it takes one. */ -export function consumed$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usize, out: rt.ByteVec): void { - let _32!: rt.u8 | undefined; +export function consumed$ends_Counted(it: Counted.Counted, pick: rs.u8, k: rs.usize, out: rs.ByteVec): void { + let _32!: rs.u8 | undefined; if (pick === 0) { - putVec(out, rt.iterToByteVec(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), "next")); + putVec(out, rs.iterToByteVec(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), "next")); } else if (pick === 1) { - putVec(out, rt.iterToByteVec(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next")); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next")); } else if (pick === 2) { - rt.byteVecPush(out, rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })).len() & 0xff); + rs.byteVecPush(out, rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })).len() & 0xff); } else if (pick === 3) { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterRev(rt.iterEnumerate(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))), (_211: [rt.usize, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterRev(rs.iterEnumerate(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))), (_211: [rs.usize, rs.u8]): Uint8Array => { return Uint8Array.of(_211[0] & 0xff, _211[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), "next"); + }, (value: Uint8Array) => rs.iterSlice(value), false, 2), "next"); } else if (pick === 4) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSkip(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterSkip(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k)), "next"); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterTake(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterTake(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k)), "next"); } else if (pick === 6) { const _27: Counted.Counted = it; - const _28: rt.usize = rt.max(k, 1); - rt.iterExtendBytes(out, rt.iterRev(rt.iterStepBy(rt.iterFrom(_27, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _28)), "next"); + const _28: rs.usize = rs.max(k, 1); + rs.iterExtendBytes(out, rs.iterRev(rs.iterStepBy(rs.iterFrom(_27, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _28)), "next"); } else if (pick === 7) { - put(out, option_map$05nbzug(rt.iterRposition(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b8: rt.u8): boolean => { - return rt.u8Rem(b8, 3) === 0; - }), (i3: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterRposition(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b8: rs.u8): boolean => { + return rs.u8Rem(b8, 3) === 0; + }), (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); } else if (pick === 8) { - const _33: rt.usize = rt.usizeRem(k, 4); + const _33: rs.usize = rs.usizeRem(k, 4); if (_33 === 0) { const _37: Counted.Counted = it; - const _38: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterSkip(rt.iterFrom(_37, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _38), (b7: rt.u8): boolean => { - return rt.u8Rem(b7, 3) === 0; + const _38: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterSkip(rs.iterFrom(_37, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _38), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) === 0; }); } else if (_33 === 1) { const _42: Counted.Counted = it; - const _43: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterTake(rt.iterFrom(_42, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _43), (b6: rt.u8): boolean => { - return rt.u8Rem(b6, 3) === 0; + const _43: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterTake(rs.iterFrom(_42, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _43), (b6: rs.u8): boolean => { + return rs.u8Rem(b6, 3) === 0; }); } else if (_33 === 2) { - _32 = option_map$1sj2ls1(rt.iterRfind(rt.iterEnumerate(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), (_2: [rt.usize, rt.u8]): boolean => { - return rt.u8Rem(rt.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; - }), (_210: [rt.usize, rt.u8]): rt.u8 => { + _32 = option_map$0h22a1a(rs.iterRfind(rs.iterEnumerate(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), (_2: [rs.usize, rs.u8]): boolean => { + return rs.u8Rem(rs.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; + }), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }); } else { const _51: Counted.Counted = it; - const _52: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - _32 = rt.iterRfind(rt.iterStepBy(rt.iterFrom(_51, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _52), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 3) === 0; + const _52: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + _32 = rs.iterRfind(rs.iterStepBy(rs.iterFrom(_51, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _52), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 3) === 0; }); } put(out, _32); } else if (pick === 9) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } else if (pick === 10) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b2: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.iterMap(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b2: rs.u8): rs.u8 => { return b2 ^ 85; })), k), "next"); } else if (pick === 11) { - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(170)); - const _67: rt.Iter = rt.iterTake(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k); - rt.iterExtendBytes(v, _67, "next"); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(170)); + const _67: rs.Iter = rs.iterTake(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), k); + rs.iterExtendBytes(v, _67, "next"); putVec(out, v); - rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); + rs.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } else if (pick === 12) { - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), new rt.Range(0, 5)); + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), new rs.Range(0, 5)); while (true) { - const _79: [rt.u8, rt.u8] | undefined = rt.iterToOption(zip.nextBack()); + const _79: [rs.u8, rs.u8] | undefined = rs.iterToOption(zip.nextBack()); if (_79 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); } else { break; } } } else if (pick === 13) { - const fused: rt.Iter = rt.iterFuse(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); - put(out, rt.iterToOption(fused.nextBack())); - rt.byteVecPush(out, fused.len() & 0xff); - rt.iterExtendBytes(out, fused, "next"); + const fused: rs.Iter = rs.iterFuse(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); + put(out, rs.iterToOption(fused.nextBack())); + rs.byteVecPush(out, fused.len() & 0xff); + rs.iterExtendBytes(out, fused, "next"); } else if (pick === 14) { - put(out, rt.iterNth(rt.iterRev(rt.iterChain(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rt.iterSlice(Uint8Array.of(7, 8)))), k)); + put(out, rs.iterNth(rs.iterRev(rs.iterChain(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rs.iterSlice(Uint8Array.of(7, 8)))), k)); } else { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, peek.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(peek), "next"); + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, peek.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(peek), "next"); } } /** `it`, consumed by std's adaptor or consumer `pick`, with `k` its count where it takes one. */ -export function consumed$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, out: rt.ByteVec): void { - let _32!: rt.u8 | undefined; +export function consumed$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, out: rs.ByteVec): void { + let _32!: rs.u8 | undefined; if (pick === 0) { - putVec(out, rt.iterToByteVec(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); + putVec(out, rs.iterToByteVec(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); } else if (pick === 1) { putVec(out, Overrides.collect$iter_Iterator_Vec_u8(it)); } else if (pick === 2) { - rt.byteVecPush(out, rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); + rs.byteVecPush(out, rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); } else if (pick === 3) { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterRev(rt.iterEnumerate(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (_211: [rt.usize, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterRev(rs.iterEnumerate(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (_211: [rs.usize, rs.u8]): Uint8Array => { return Uint8Array.of(_211[0] & 0xff, _211[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), "next"); + }, (value: Uint8Array) => rs.iterSlice(value), false, 2), "next"); } else if (pick === 4) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSkip(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterSkip(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), k)), "next"); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterTake(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterTake(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), k)), "next"); } else if (pick === 6) { const _27: Overrides.Overrides = it; - const _28: rt.usize = rt.max(k, 1); - rt.iterExtendBytes(out, rt.iterRev(rt.iterStepBy(rt.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _28)), "next"); + const _28: rs.usize = rs.max(k, 1); + rs.iterExtendBytes(out, rs.iterRev(rs.iterStepBy(rs.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _28)), "next"); } else if (pick === 7) { - put(out, option_map$05nbzug(rt.iterRposition(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b8: rt.u8): boolean => { - return rt.u8Rem(b8, 3) === 0; - }), (i3: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterRposition(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b8: rs.u8): boolean => { + return rs.u8Rem(b8, 3) === 0; + }), (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); } else if (pick === 8) { - const _33: rt.usize = rt.usizeRem(k, 4); + const _33: rs.usize = rs.usizeRem(k, 4); if (_33 === 0) { const _37: Overrides.Overrides = it; - const _38: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterSkip(rt.iterFrom(_37, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _38), (b7: rt.u8): boolean => { - return rt.u8Rem(b7, 3) === 0; + const _38: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterSkip(rs.iterFrom(_37, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _38), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) === 0; }); } else if (_33 === 1) { const _42: Overrides.Overrides = it; - const _43: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterTake(rt.iterFrom(_42, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _43), (b6: rt.u8): boolean => { - return rt.u8Rem(b6, 3) === 0; + const _43: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterTake(rs.iterFrom(_42, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _43), (b6: rs.u8): boolean => { + return rs.u8Rem(b6, 3) === 0; }); } else if (_33 === 2) { - _32 = option_map$1sj2ls1(rt.iterRfind(rt.iterEnumerate(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (_2: [rt.usize, rt.u8]): boolean => { - return rt.u8Rem(rt.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; - }), (_210: [rt.usize, rt.u8]): rt.u8 => { + _32 = option_map$0h22a1a(rs.iterRfind(rs.iterEnumerate(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (_2: [rs.usize, rs.u8]): boolean => { + return rs.u8Rem(rs.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; + }), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }); } else { const _51: Overrides.Overrides = it; - const _52: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - _32 = rt.iterRfind(rt.iterStepBy(rt.iterFrom(_51, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _52), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 3) === 0; + const _52: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + _32 = rs.iterRfind(rs.iterStepBy(rs.iterFrom(_51, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _52), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 3) === 0; }); } put(out, _32); } else if (pick === 9) { - put(out, rt.ownedLast(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); + put(out, rs.ownedLast(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); } else if (pick === 10) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b2: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.iterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b2: rs.u8): rs.u8 => { return b2 ^ 85; })), k), "next"); } else if (pick === 11) { - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(170)); - const _67: rt.Iter = rt.iterTake(rt.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k); - rt.iterExtendBytes(v, _67, "next"); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(170)); + const _67: rs.Iter = rs.iterTake(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k); + rs.iterExtendBytes(v, _67, "next"); putVec(out, v); - rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); } else if (pick === 12) { - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), new rt.Range(0, 5)); + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), new rs.Range(0, 5)); while (true) { - const _79: [rt.u8, rt.u8] | undefined = rt.iterToOption(zip.nextBack()); + const _79: [rs.u8, rs.u8] | undefined = rs.iterToOption(zip.nextBack()); if (_79 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); } else { break; } } } else if (pick === 13) { - const fused: rt.Iter = rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); - put(out, rt.iterToOption(fused.nextBack())); - rt.byteVecPush(out, fused.len() & 0xff); - rt.iterExtendBytes(out, fused, "next"); + const fused: rs.Iter = rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); + put(out, rs.iterToOption(fused.nextBack())); + rs.byteVecPush(out, fused.len() & 0xff); + rs.iterExtendBytes(out, fused, "next"); } else if (pick === 14) { - put(out, rt.iterNth(rt.iterRev(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8)))), k)); + put(out, rs.iterNth(rs.iterRev(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8)))), k)); } else { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, peek.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(peek), "next"); + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, peek.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(peek), "next"); } } /** `it`, consumed by std's adaptor or consumer `pick`, with `k` its count where it takes one. */ -export function consumed$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, out: rt.ByteVec): void { - let _32!: rt.u8 | undefined; +export function consumed$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, out: rs.ByteVec): void { + let _32!: rs.u8 | undefined; if (pick === 0) { - putVec(out, rt.iterToByteVec(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), "next")); + putVec(out, rs.iterToByteVec(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), "next")); } else if (pick === 1) { - putVec(out, rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); } else if (pick === 2) { - rt.byteVecPush(out, rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })).len() & 0xff); + rs.byteVecPush(out, rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })).len() & 0xff); } else if (pick === 3) { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterRev(rt.iterEnumerate(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))), (_211: [rt.usize, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterRev(rs.iterEnumerate(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))), (_211: [rs.usize, rs.u8]): Uint8Array => { return Uint8Array.of(_211[0] & 0xff, _211[1]); - }, (value: Uint8Array) => rt.iterSlice(value), false, 2), "next"); + }, (value: Uint8Array) => rs.iterSlice(value), false, 2), "next"); } else if (pick === 4) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterSkip(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterSkip(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)), "next"); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)), "next"); } else if (pick === 6) { const _27: Run.Run = it; - const _28: rt.usize = rt.max(k, 1); - rt.iterExtendBytes(out, rt.iterRev(rt.iterStepBy(rt.iterFrom(_27, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _28)), "next"); + const _28: rs.usize = rs.max(k, 1); + rs.iterExtendBytes(out, rs.iterRev(rs.iterStepBy(rs.iterFrom(_27, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _28)), "next"); } else if (pick === 7) { - put(out, option_map$05nbzug(rt.iterRposition(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b8: rt.u8): boolean => { - return rt.u8Rem(b8, 3) === 0; - }), (i3: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterRposition(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b8: rs.u8): boolean => { + return rs.u8Rem(b8, 3) === 0; + }), (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); } else if (pick === 8) { - const _33: rt.usize = rt.usizeRem(k, 4); + const _33: rs.usize = rs.usizeRem(k, 4); if (_33 === 0) { const _37: Run.Run = it; - const _38: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterSkip(rt.iterFrom(_37, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _38), (b7: rt.u8): boolean => { - return rt.u8Rem(b7, 3) === 0; + const _38: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterSkip(rs.iterFrom(_37, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _38), (b7: rs.u8): boolean => { + return rs.u8Rem(b7, 3) === 0; }); } else if (_33 === 1) { const _42: Run.Run = it; - const _43: rt.usize = rt.usizeDiv(k, 4); - _32 = rt.iterRfind(rt.iterTake(rt.iterFrom(_42, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _43), (b6: rt.u8): boolean => { - return rt.u8Rem(b6, 3) === 0; + const _43: rs.usize = rs.usizeDiv(k, 4); + _32 = rs.iterRfind(rs.iterTake(rs.iterFrom(_42, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _43), (b6: rs.u8): boolean => { + return rs.u8Rem(b6, 3) === 0; }); } else if (_33 === 2) { - _32 = option_map$1sj2ls1(rt.iterRfind(rt.iterEnumerate(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (_2: [rt.usize, rt.u8]): boolean => { - return rt.u8Rem(rt.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; - }), (_210: [rt.usize, rt.u8]): rt.u8 => { + _32 = option_map$0h22a1a(rs.iterRfind(rs.iterEnumerate(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (_2: [rs.usize, rs.u8]): boolean => { + return rs.u8Rem(rs.u8Add(_2[0] & 0xff, _2[1]), 3) === 0; + }), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }); } else { const _51: Run.Run = it; - const _52: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - _32 = rt.iterRfind(rt.iterStepBy(rt.iterFrom(_51, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _52), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 3) === 0; + const _52: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + _32 = rs.iterRfind(rs.iterStepBy(rs.iterFrom(_51, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _52), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 3) === 0; }); } put(out, _32); } else if (pick === 9) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } else if (pick === 10) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterRev(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b2: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTake(rs.iterRev(rs.iterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b2: rs.u8): rs.u8 => { return b2 ^ 85; })), k), "next"); } else if (pick === 11) { - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(170)); - const _67: rt.Iter = rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k); - rt.iterExtendBytes(v, _67, "next"); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(170)); + const _67: rs.Iter = rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k); + rs.iterExtendBytes(v, _67, "next"); putVec(out, v); - rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else if (pick === 12) { - const zip: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), new rt.Range(0, 5)); + const zip: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), new rs.Range(0, 5)); while (true) { - const _79: [rt.u8, rt.u8] | undefined = rt.iterToOption(zip.nextBack()); + const _79: [rs.u8, rs.u8] | undefined = rs.iterToOption(zip.nextBack()); if (_79 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_79[0], _79[1])), undefined, true); } else { break; } } } else if (pick === 13) { - const fused: rt.Iter = rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); - put(out, rt.iterToOption(fused.nextBack())); - rt.byteVecPush(out, fused.len() & 0xff); - rt.iterExtendBytes(out, fused, "next"); + const fused: rs.Iter = rs.iterFuse(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); + put(out, rs.iterToOption(fused.nextBack())); + rs.byteVecPush(out, fused.len() & 0xff); + rs.iterExtendBytes(out, fused, "next"); } else if (pick === 14) { - put(out, rt.iterNth(rt.iterRev(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8)))), k)); + put(out, rs.iterNth(rs.iterRev(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8)))), k)); } else { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, peek.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(peek), "next"); + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, peek.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(peek), "next"); } } @@ -622,121 +622,121 @@ export function consumed$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, out: rt * `nth`, `count`, or `last`, picked by `pick`, with `k` its count where it takes one. One * fold panics past `k` items, with what was logged so far. */ -export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _50!: Uint8Array; - let r3!: rt.Result; + let r3!: rs.Result; let _66!: Uint8Array; - let _84!: rt.u8 | undefined; + let _84!: rs.u8 | undefined; let _99!: Uint8Array; - const k8: rt.u8 = k & 0xff; + const k8: rs.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a16, 3) ^ b22; + rs.byteVecPush(out, rs.iterFold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a16: rs.u8, b22: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a16, 3) ^ b22; }, true)); } else if (pick === 1) { const _10: Overrides.Overrides = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { + const _11: (a0: rs.u8, a1: rs.u8) => rs.u8 = (a15: rs.u8, b21: rs.u8): rs.u8 => { if (!(k < 15)) { if (!(b21 !== 2)) { - const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; - rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a15, 3) ^ b21; + return rs.u8WrappingMul(a15, 3) ^ b21; }; - rt.byteVecPush(out, rt.iterRfold(rt.iterBox(rt.iterFrom(_10, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, _11, true)); + rs.byteVecPush(out, rs.iterRfold(rs.iterBox(rs.iterFrom(_10, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, _11, true)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 2)) { - if (!(rt.usizeRem(k, 4) === 3)) { - const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { - const _416: rt.u8 = rt.u8Rem(b20, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 2)) { + if (!(rs.usizeRem(k, 4) === 3)) { + const r2: rs.u8 | undefined | rs.None = rs.iterTryRfold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), undefined as rs.u8 | undefined, (a14: rs.u8 | undefined, b20: rs.u8): rs.u8 | undefined | rs.None => { + const _416: rs.u8 = rs.u8Rem(b20, 3); if (_416 === 0) { - return rt.None; + return rs.None; } if (_416 === 1) { return undefined; } - return option_or$1loyskh(a14, b20); - }, true, undefined, rt.None); - if (r2 === rt.None) { + return option_or$0ar58vy(a14, b20); + }, true, undefined, rs.None); + if (r2 === rs.None) { _50 = Uint8Array.of(1, 0); } else { - _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + _50 = Uint8Array.of(0, option_unwrapOr$1fr498u(r2, 255)); } - rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_50), undefined, true); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } else { - const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { - return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { - rt.byteVecPush(out, b19); + const _38: (a0: rs.u8) => undefined | rs.None = (b19: rs.u8): undefined | rs.None => { + return then$1czl1m8(b19 !== rs.u8Div(k8, 4), (): undefined => { + rs.byteVecPush(out, b19); }); }; - rt.byteVecPush(out, rt.iterTryForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + rs.byteVecPush(out, rs.iterTryForEach(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _38, true, undefined, rs.None) !== rs.None ? 1 : 0); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } else { - const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + const _29: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a13: rs.u8, b18: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b18 !== rs.u8Div(k8, 4), a13 ^ b18); }; - put(out, rt.iterTryFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _29, true)); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + put(out, rs.iterTryFold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _29, true)); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b17 !== k8, a12 ^ b17); + const _19: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a12: rs.u8, b17: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b17 !== k8, a12 ^ b17); }; - put(out, rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _19, true)); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + put(out, rs.iterTryRfold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _19, true)); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } else if (pick === 3) { - if (rt.usizeRem(k, 2) === 0) { - const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { - if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a11 ^ b16); + if (rs.usizeRem(k, 2) === 0) { + const _60: (a0: rs.u8, a1: rs.u8) => rs.Result = (a11: rs.u8, b16: rs.u8): rs.Result => { + if (!(rs.u8Rem(b16, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a11 ^ b16); } - return rt.Err(b16); + return rs.Err(b16); }; - r3 = rt.iterTryRfold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _60); + r3 = rs.iterTryRfold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _60); } else { - const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { - if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a10 ^ b15); + const _63: (a0: rs.u8, a1: rs.u8) => rs.Result = (a10: rs.u8, b15: rs.u8): rs.Result => { + if (!(rs.u8Rem(b15, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a10 ^ b15); } - return rt.Err(b15); + return rs.Err(b15); }; - r3 = rt.iterTryFold(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _63); + r3 = rs.iterTryFold(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _63); } if (r3.ok) { _66 = Uint8Array.of(0, r3.value); } else { _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); - put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); + rs.iterExtendBytes(out, rs.iterSlice(_66), undefined, true); + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 1)) { - const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(rs.usizeRem(k, 2) === 1)) { + const r5: rs.Result = rs.iterTryRfold(rs.iterRev(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), 0, (a9: rs.u8, b14: rs.u8): rs.Result => { if (!(b14 > k8)) { - return rt.Ok(a9 ^ b14); + return rs.Ok(a9 ^ b14); } - return rt.Err(b14); + return rs.Err(b14); }); if (r5.ok) { _99 = Uint8Array.of(0, r5.value); } else { _99 = Uint8Array.of(1, r5.error); } - rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); - rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(_99), undefined, true); + rs.byteVecPush(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); } else { - const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), (b13: rt.u8): rt.Result => { - if (!(b13 > rt.u8Div(k8, 2))) { - rt.byteVecPush(out, b13); - return rt.OK; + const r4: rs.Result = rs.iterTryForEach(rs.iterRev(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), (b13: rs.u8): rs.Result => { + if (!(b13 > rs.u8Div(k8, 2))) { + rs.byteVecPush(out, b13); + return rs.OK; } - return rt.Err(b13); + return rs.Err(b13); }); if (r4.ok) { _84 = undefined; @@ -744,122 +744,122 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r _84 = r4.error; } put(out, _84); - rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); + rs.byteVecPush(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b12: rt.u8): rt.u8 => { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.ownedCount(rs.iterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b12: rs.u8): rs.u8 => { return b12 ^ 1; })) & 0xff); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))) & 0xff); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); } else { - put(out, rt.ownedLast(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); + put(out, rs.ownedLast(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 1)) { + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 1)) { const _140: Overrides.Overrides = it; - const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + const _141: (a0: rs.u8) => boolean = (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) === rs.u8Rem(k8, 3); }; - const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterBox(rt.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); - const a4: rt.ByteVec = _139[0]; - const b4: rt.ByteVec = _139[1]; + const _139: [rs.ByteVec, rs.ByteVec] = rs.iterPartition(rs.iterBox(rs.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _141, [new rs.ByteVec() as rs.ByteVec, new rs.ByteVec() as rs.ByteVec], rs.byteVecPart(), true); + const a4: rs.ByteVec = _139[0]; + const b4: rs.ByteVec = _139[1]; putVec(out, a4); putVec(out, b4); } else { - rt.iterForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b10: rt.u8): undefined => { - rt.byteVecPush(out, b10); + rs.iterForEach(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b10: rs.u8): undefined => { + rs.byteVecPush(out, b10); }, true); } } else { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0, true) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0, true) & 0xff); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 3); - }, rt.lt, true)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMinByKey(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 3); + }, rs.lt, true)); } else { - put(out, rt.iterMax(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.lt, true)); + put(out, rs.iterMax(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.lt, true)); } } else if (pick === 9) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8))))); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8)))) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8)))) & 0xff); } } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _175: Overrides.Overrides = it; - const _176: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(rt.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _176))); + const _176: rs.usize = rs.usizeDiv(k, 2); + put(out, rs.ownedLast(rs.iterSkip(rs.iterBox(rs.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _176))); } else { const _170: Overrides.Overrides = it; - const _171: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(rt.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _171)) & 0xff); + const _171: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.ownedCount(rs.iterSkip(rs.iterBox(rs.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _171)) & 0xff); } } else if (pick === 11) { - const _178: rt.usize = rt.usizeRem(k, 4); + const _178: rs.usize = rs.usizeRem(k, 4); if (_178 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a8, 5) ^ b8; + rs.byteVecPush(out, rs.iterFold(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), 1, (a8: rs.u8, b8: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a8, 5) ^ b8; }, true)); } else if (_178 === 1) { - put(out, rt.iterNth(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), rt.usizeDiv(k, 4))); + put(out, rs.iterNth(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), rs.usizeDiv(k, 4))); } else if (_178 === 2) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a7, 5) ^ b7; + rs.byteVecPush(out, rs.iterRfold(rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), 1, (a7: rs.u8, b7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { const _196: Overrides.Overrides = it; - const _197: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterBox(rt.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _197); - put(out, rt.iterToOption(skip.next())); - put(out, rt.iterToOption(skip.nextBack())); + const _197: rs.usize = rs.usizeDiv(k, 2); + const skip: rs.Iter = rs.iterSkip(rs.iterBox(rs.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _197); + put(out, rs.iterToOption(skip.next())); + put(out, rs.iterToOption(skip.nextBack())); } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _216: Overrides.Overrides = it; - const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + const _217: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined = (s: rs.Place, b5: rs.u8): rs.u8 | undefined => { s.v = s.v ^ b5; - return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + return thenSome$0quywni(s.v !== rs.u8Div(k8, 2), s.v); }; - const scan: rt.Iter = rt.iterScan(rt.iterBox(rt.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _217, true); - putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); - put(out, rt.iterToOption(scan.next())); - rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + const scan: rs.Iter = rs.iterScan(rs.iterBox(rs.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 0, _217, true); + putVec(out, rs.iterToByteVec(rs.iterBorrow(scan), "next")); + put(out, rs.iterToOption(scan.next())); + rs.byteVecPush(out, rs.iterFold(scan, 0, (a6: rs.u8, b6: rs.u8): rs.u8 => { return a6 ^ b6; }, true)); } else { const _210: Overrides.Overrides = it; - const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(rt.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _211), "next")); + const _211: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + putVec(out, rs.iterToByteVec(rs.iterStepBy(rs.iterBox(rs.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _211), "next")); } } else if (pick === 14) { - if (!(rt.usizeRem(k, 2) === 0)) { - const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, rt.ownedCount(peek) & 0xff); + if (!(rs.usizeRem(k, 2) === 0)) { + const peek: rs.Peekable = rs.iterPeekable(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, rs.ownedCount(peek) & 0xff); } else { - put(out, rt.ownedLast(rt.iterFuse(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); + put(out, rs.ownedLast(rs.iterFuse(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))))); } } else { - const _249: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a5, 1); + const _249: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), _249), 0, (a5: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8Add(a5, 1); })); - put(out, rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))))); - rt.byteVecPush(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); + put(out, rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))))); + rs.byteVecPush(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })).len() & 0xff); } } @@ -868,121 +868,121 @@ export function folded$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: r * `nth`, `count`, or `last`, picked by `pick`, with `k` its count where it takes one. One * fold panics past `k` items, with what was logged so far. */ -export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: rt.Iter, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: rs.Iter, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _50!: Uint8Array; - let r3!: rt.Result; + let r3!: rs.Result; let _66!: Uint8Array; - let _84!: rt.u8 | undefined; + let _84!: rs.u8 | undefined; let _99!: Uint8Array; - const k8: rt.u8 = k & 0xff; + const k8: rs.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterBox(it), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a16, 3) ^ b22; + rs.byteVecPush(out, rs.iterFold(rs.iterBox(it), 1, (a16: rs.u8, b22: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a16, 3) ^ b22; }, true)); } else if (pick === 1) { - const _10: rt.Iter = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { + const _10: rs.Iter = it; + const _11: (a0: rs.u8, a1: rs.u8) => rs.u8 = (a15: rs.u8, b21: rs.u8): rs.u8 => { if (!(k < 15)) { if (!(b21 !== 2)) { - const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; - rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a15, 3) ^ b21; + return rs.u8WrappingMul(a15, 3) ^ b21; }; - rt.byteVecPush(out, rt.iterRfold(rt.iterBox(_10), 1, _11, true)); + rs.byteVecPush(out, rs.iterRfold(rs.iterBox(_10), 1, _11, true)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 2)) { - if (!(rt.usizeRem(k, 4) === 3)) { - const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterBox(it), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { - const _416: rt.u8 = rt.u8Rem(b20, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 2)) { + if (!(rs.usizeRem(k, 4) === 3)) { + const r2: rs.u8 | undefined | rs.None = rs.iterTryRfold(rs.iterBox(it), undefined as rs.u8 | undefined, (a14: rs.u8 | undefined, b20: rs.u8): rs.u8 | undefined | rs.None => { + const _416: rs.u8 = rs.u8Rem(b20, 3); if (_416 === 0) { - return rt.None; + return rs.None; } if (_416 === 1) { return undefined; } - return option_or$1loyskh(a14, b20); - }, true, undefined, rt.None); - if (r2 === rt.None) { + return option_or$0ar58vy(a14, b20); + }, true, undefined, rs.None); + if (r2 === rs.None) { _50 = Uint8Array.of(1, 0); } else { - _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + _50 = Uint8Array.of(0, option_unwrapOr$1fr498u(r2, 255)); } - rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); - rt.iterExtendBytes(out, rt.iterBox(it), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_50), undefined, true); + rs.iterExtendBytes(out, rs.iterBox(it), "next"); } else { - const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { - return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { - rt.byteVecPush(out, b19); + const _38: (a0: rs.u8) => undefined | rs.None = (b19: rs.u8): undefined | rs.None => { + return then$1czl1m8(b19 !== rs.u8Div(k8, 4), (): undefined => { + rs.byteVecPush(out, b19); }); }; - rt.byteVecPush(out, rt.iterTryForEach(rt.iterBox(it), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); - rt.iterExtendBytes(out, rt.iterBox(it), "next"); + rs.byteVecPush(out, rs.iterTryForEach(rs.iterBox(it), _38, true, undefined, rs.None) !== rs.None ? 1 : 0); + rs.iterExtendBytes(out, rs.iterBox(it), "next"); } } else { - const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + const _29: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a13: rs.u8, b18: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b18 !== rs.u8Div(k8, 4), a13 ^ b18); }; - put(out, rt.iterTryFold(rt.iterBox(it), 0, _29, true)); - rt.iterExtendBytes(out, rt.iterBox(it), "next"); + put(out, rs.iterTryFold(rs.iterBox(it), 0, _29, true)); + rs.iterExtendBytes(out, rs.iterBox(it), "next"); } } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b17 !== k8, a12 ^ b17); + const _19: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a12: rs.u8, b17: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b17 !== k8, a12 ^ b17); }; - put(out, rt.iterTryRfold(rt.iterBox(it), 0, _19, true)); - rt.iterExtendBytes(out, rt.iterBox(it), "next"); + put(out, rs.iterTryRfold(rs.iterBox(it), 0, _19, true)); + rs.iterExtendBytes(out, rs.iterBox(it), "next"); } } else if (pick === 3) { - if (rt.usizeRem(k, 2) === 0) { - const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { - if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a11 ^ b16); + if (rs.usizeRem(k, 2) === 0) { + const _60: (a0: rs.u8, a1: rs.u8) => rs.Result = (a11: rs.u8, b16: rs.u8): rs.Result => { + if (!(rs.u8Rem(b16, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a11 ^ b16); } - return rt.Err(b16); + return rs.Err(b16); }; - r3 = rt.iterTryRfold(rt.iterBox(it), 0, _60); + r3 = rs.iterTryRfold(rs.iterBox(it), 0, _60); } else { - const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { - if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a10 ^ b15); + const _63: (a0: rs.u8, a1: rs.u8) => rs.Result = (a10: rs.u8, b15: rs.u8): rs.Result => { + if (!(rs.u8Rem(b15, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a10 ^ b15); } - return rt.Err(b15); + return rs.Err(b15); }; - r3 = rt.iterTryFold(rt.iterBox(it), 0, _63); + r3 = rs.iterTryFold(rs.iterBox(it), 0, _63); } if (r3.ok) { _66 = Uint8Array.of(0, r3.value); } else { _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); - put(out, rt.iterToOption(it.next())); + rs.iterExtendBytes(out, rs.iterSlice(_66), undefined, true); + put(out, rs.iterToOption(it.next())); } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 1)) { - const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it)))), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(rs.usizeRem(k, 2) === 1)) { + const r5: rs.Result = rs.iterTryRfold(rs.iterRev(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it)))), 0, (a9: rs.u8, b14: rs.u8): rs.Result => { if (!(b14 > k8)) { - return rt.Ok(a9 ^ b14); + return rs.Ok(a9 ^ b14); } - return rt.Err(b14); + return rs.Err(b14); }); if (r5.ok) { _99 = Uint8Array.of(0, r5.value); } else { _99 = Uint8Array.of(1, r5.error); } - rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); - rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(_99), undefined, true); + rs.byteVecPush(out, rs.iterBox(it).len() & 0xff); } else { - const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it)))), (b13: rt.u8): rt.Result => { - if (!(b13 > rt.u8Div(k8, 2))) { - rt.byteVecPush(out, b13); - return rt.OK; + const r4: rs.Result = rs.iterTryForEach(rs.iterRev(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it)))), (b13: rs.u8): rs.Result => { + if (!(b13 > rs.u8Div(k8, 2))) { + rs.byteVecPush(out, b13); + return rs.OK; } - return rt.Err(b13); + return rs.Err(b13); }); if (r4.ok) { _84 = undefined; @@ -990,122 +990,122 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: _84 = r4.error; } put(out, _84); - rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); + rs.byteVecPush(out, rs.iterBox(it).len() & 0xff); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterBox(it), (b12: rt.u8): rt.u8 => { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.ownedCount(rs.iterMap(rs.iterBox(it), (b12: rs.u8): rs.u8 => { return b12 ^ 1; })) & 0xff); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterBox(it)) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterBox(it)) & 0xff); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(it)))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(it)))); } else { - put(out, rt.ownedLast(rt.iterBox(it))); + put(out, rs.ownedLast(rs.iterBox(it))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 1)) { - const _140: rt.Iter = it; - const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 1)) { + const _140: rs.Iter = it; + const _141: (a0: rs.u8) => boolean = (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) === rs.u8Rem(k8, 3); }; - const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterBox(_140), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); - const a4: rt.ByteVec = _139[0]; - const b4: rt.ByteVec = _139[1]; + const _139: [rs.ByteVec, rs.ByteVec] = rs.iterPartition(rs.iterBox(_140), _141, [new rs.ByteVec() as rs.ByteVec, new rs.ByteVec() as rs.ByteVec], rs.byteVecPart(), true); + const a4: rs.ByteVec = _139[0]; + const b4: rs.ByteVec = _139[1]; putVec(out, a4); putVec(out, b4); } else { - rt.iterForEach(rt.iterBox(it), (b10: rt.u8): undefined => { - rt.byteVecPush(out, b10); + rs.iterForEach(rs.iterBox(it), (b10: rs.u8): undefined => { + rs.byteVecPush(out, b10); }, true); } } else { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterBox(it), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0, true) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterBox(it), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0, true) & 0xff); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterBox(it), (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 3); - }, rt.lt, true)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMinByKey(rs.iterBox(it), (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 3); + }, rs.lt, true)); } else { - put(out, rt.iterMax(rt.iterBox(it), rt.lt, true)); + put(out, rs.iterMax(rs.iterBox(it), rs.lt, true)); } } else if (pick === 9) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterChain(rt.iterBox(it), rt.iterSlice(Uint8Array.of(7, 8))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterChain(rs.iterBox(it), rs.iterSlice(Uint8Array.of(7, 8))))); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterChain(rt.iterBox(it), rt.iterSlice(Uint8Array.of(7, 8)))) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterChain(rs.iterBox(it), rs.iterSlice(Uint8Array.of(7, 8)))) & 0xff); } } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _175: rt.Iter = it; - const _176: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterBox(_175), _176))); + if (!(rs.usizeRem(k, 2) === 0)) { + const _175: rs.Iter = it; + const _176: rs.usize = rs.usizeDiv(k, 2); + put(out, rs.ownedLast(rs.iterSkip(rs.iterBox(_175), _176))); } else { - const _170: rt.Iter = it; - const _171: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterBox(_170), _171)) & 0xff); + const _170: rs.Iter = it; + const _171: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.ownedCount(rs.iterSkip(rs.iterBox(_170), _171)) & 0xff); } } else if (pick === 11) { - const _178: rt.usize = rt.usizeRem(k, 4); + const _178: rs.usize = rs.usizeRem(k, 4); if (_178 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterBox(it)), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a8, 5) ^ b8; + rs.byteVecPush(out, rs.iterFold(rs.iterRev(rs.iterBox(it)), 1, (a8: rs.u8, b8: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a8, 5) ^ b8; }, true)); } else if (_178 === 1) { - put(out, rt.iterNth(rt.iterRev(rt.iterBox(it)), rt.usizeDiv(k, 4))); + put(out, rs.iterNth(rs.iterRev(rs.iterBox(it)), rs.usizeDiv(k, 4))); } else if (_178 === 2) { - put(out, rt.ownedLast(rt.iterRev(rt.iterBox(it)))); + put(out, rs.ownedLast(rs.iterRev(rs.iterBox(it)))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterBox(it)), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a7, 5) ^ b7; + rs.byteVecPush(out, rs.iterRfold(rs.iterRev(rs.iterBox(it)), 1, (a7: rs.u8, b7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { - const _196: rt.Iter = it; - const _197: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterBox(_196), _197); - put(out, rt.iterToOption(skip.next())); - put(out, rt.iterToOption(skip.nextBack())); + const _196: rs.Iter = it; + const _197: rs.usize = rs.usizeDiv(k, 2); + const skip: rs.Iter = rs.iterSkip(rs.iterBox(_196), _197); + put(out, rs.iterToOption(skip.next())); + put(out, rs.iterToOption(skip.nextBack())); } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _216: rt.Iter = it; - const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + if (!(rs.usizeRem(k, 2) === 0)) { + const _216: rs.Iter = it; + const _217: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined = (s: rs.Place, b5: rs.u8): rs.u8 | undefined => { s.v = s.v ^ b5; - return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + return thenSome$0quywni(s.v !== rs.u8Div(k8, 2), s.v); }; - const scan: rt.Iter = rt.iterScan(rt.iterBox(_216), 0, _217, true); - putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); - put(out, rt.iterToOption(scan.next())); - rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + const scan: rs.Iter = rs.iterScan(rs.iterBox(_216), 0, _217, true); + putVec(out, rs.iterToByteVec(rs.iterBorrow(scan), "next")); + put(out, rs.iterToOption(scan.next())); + rs.byteVecPush(out, rs.iterFold(scan, 0, (a6: rs.u8, b6: rs.u8): rs.u8 => { return a6 ^ b6; }, true)); } else { - const _210: rt.Iter = it; - const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterBox(_210), _211), "next")); + const _210: rs.Iter = it; + const _211: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + putVec(out, rs.iterToByteVec(rs.iterStepBy(rs.iterBox(_210), _211), "next")); } } else if (pick === 14) { - if (!(rt.usizeRem(k, 2) === 0)) { - const peek: rt.Peekable = rt.iterPeekable(rt.iterBox(it)); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, rt.ownedCount(peek) & 0xff); + if (!(rs.usizeRem(k, 2) === 0)) { + const peek: rs.Peekable = rs.iterPeekable(rs.iterBox(it)); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, rs.ownedCount(peek) & 0xff); } else { - put(out, rt.ownedLast(rt.iterFuse(rt.iterBox(it)))); + put(out, rs.ownedLast(rs.iterFuse(rs.iterBox(it)))); } } else { - const _249: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a5, 1); + const _249: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it))), _249), 0, (a5: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8Add(a5, 1); })); - put(out, rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(it))))); - rt.byteVecPush(out, rt.iterBox(it).len() & 0xff); + put(out, rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(it))))); + rs.byteVecPush(out, rs.iterBox(it).len() & 0xff); } } @@ -1114,121 +1114,121 @@ export function folded$boxed_Box_iter_Map_ends_Overrides_ends_ends_closure1(it: * `nth`, `count`, or `last`, picked by `pick`, with `k` its count where it takes one. One * fold panics past `k` items, with what was logged so far. */ -export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function folded$ends_Counted(it: Counted.Counted, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _50!: Uint8Array; - let r3!: rt.Result; + let r3!: rs.Result; let _66!: Uint8Array; - let _84!: rt.u8 | undefined; + let _84!: rs.u8 | undefined; let _99!: Uint8Array; - const k8: rt.u8 = k & 0xff; + const k8: rs.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a16, 3) ^ b22; + rs.byteVecPush(out, rs.iterFold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, (a16: rs.u8, b22: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { const _10: Counted.Counted = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { + const _11: (a0: rs.u8, a1: rs.u8) => rs.u8 = (a15: rs.u8, b21: rs.u8): rs.u8 => { if (!(k < 15)) { if (!(b21 !== 2)) { - const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; - rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a15, 3) ^ b21; + return rs.u8WrappingMul(a15, 3) ^ b21; }; - rt.byteVecPush(out, rt.iterRfold(rt.iterFrom(_10, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, _11)); + rs.byteVecPush(out, rs.iterRfold(rs.iterFrom(_10, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 1, _11)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 2)) { - if (!(rt.usizeRem(k, 4) === 3)) { - const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { - const _416: rt.u8 = rt.u8Rem(b20, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 2)) { + if (!(rs.usizeRem(k, 4) === 3)) { + const r2: rs.u8 | undefined | rs.None = rs.iterTryRfold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), undefined as rs.u8 | undefined, (a14: rs.u8 | undefined, b20: rs.u8): rs.u8 | undefined | rs.None => { + const _416: rs.u8 = rs.u8Rem(b20, 3); if (_416 === 0) { - return rt.None; + return rs.None; } if (_416 === 1) { return undefined; } - return option_or$1loyskh(a14, b20); - }, true, undefined, rt.None); - if (r2 === rt.None) { + return option_or$0ar58vy(a14, b20); + }, true, undefined, rs.None); + if (r2 === rs.None) { _50 = Uint8Array.of(1, 0); } else { - _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + _50 = Uint8Array.of(0, option_unwrapOr$1fr498u(r2, 255)); } - rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_50), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } else { - const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { - return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { - rt.byteVecPush(out, b19); + const _38: (a0: rs.u8) => undefined | rs.None = (b19: rs.u8): undefined | rs.None => { + return then$1czl1m8(b19 !== rs.u8Div(k8, 4), (): undefined => { + rs.byteVecPush(out, b19); }); }; - rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); + rs.byteVecPush(out, rs.iterTryForEach(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _38, true, undefined, rs.None) !== rs.None ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } } else { - const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + const _29: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a13: rs.u8, b18: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b18 !== rs.u8Div(k8, 4), a13 ^ b18); }; - put(out, rt.iterTryFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _29, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); + put(out, rs.iterTryFold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _29, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b17 !== k8, a12 ^ b17); + const _19: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a12: rs.u8, b17: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b17 !== k8, a12 ^ b17); }; - put(out, rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _19, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); + put(out, rs.iterTryRfold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _19, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), "next"); } } else if (pick === 3) { - if (rt.usizeRem(k, 2) === 0) { - const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { - if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a11 ^ b16); + if (rs.usizeRem(k, 2) === 0) { + const _60: (a0: rs.u8, a1: rs.u8) => rs.Result = (a11: rs.u8, b16: rs.u8): rs.Result => { + if (!(rs.u8Rem(b16, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a11 ^ b16); } - return rt.Err(b16); + return rs.Err(b16); }; - r3 = rt.iterTryRfold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _60); + r3 = rs.iterTryRfold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _60); } else { - const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { - if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a10 ^ b15); + const _63: (a0: rs.u8, a1: rs.u8) => rs.Result = (a10: rs.u8, b15: rs.u8): rs.Result => { + if (!(rs.u8Rem(b15, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a10 ^ b15); } - return rt.Err(b15); + return rs.Err(b15); }; - r3 = rt.iterTryFold(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _63); + r3 = rs.iterTryFold(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _63); } if (r3.ok) { _66 = Uint8Array.of(0, r3.value); } else { _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); - put(out, rt.iterToOption(Counted.next$iter_Iterator(it))); + rs.iterExtendBytes(out, rs.iterSlice(_66), undefined, true); + put(out, rs.iterToOption(Counted.next$iter_Iterator(it))); } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 1)) { - const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(rs.usizeRem(k, 2) === 1)) { + const r5: rs.Result = rs.iterTryRfold(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 0, (a9: rs.u8, b14: rs.u8): rs.Result => { if (!(b14 > k8)) { - return rt.Ok(a9 ^ b14); + return rs.Ok(a9 ^ b14); } - return rt.Err(b14); + return rs.Err(b14); }); if (r5.ok) { _99 = Uint8Array.of(0, r5.value); } else { _99 = Uint8Array.of(1, r5.error); } - rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); - rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(_99), undefined, true); + rs.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } else { - const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), (b13: rt.u8): rt.Result => { - if (!(b13 > rt.u8Div(k8, 2))) { - rt.byteVecPush(out, b13); - return rt.OK; + const r4: rs.Result = rs.iterTryForEach(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), (b13: rs.u8): rs.Result => { + if (!(b13 > rs.u8Div(k8, 2))) { + rs.byteVecPush(out, b13); + return rs.OK; } - return rt.Err(b13); + return rs.Err(b13); }); if (r4.ok) { _84 = undefined; @@ -1236,122 +1236,122 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz _84 = r4.error; } put(out, _84); - rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); + rs.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b12: rt.u8): rt.u8 => { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b12: rs.u8): rs.u8 => { return b12 ^ 1; })) & 0xff); } else { - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })) & 0xff); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } else { - put(out, rt.iterLast(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); + put(out, rs.iterLast(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 1)) { + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 1)) { const _140: Counted.Counted = it; - const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + const _141: (a0: rs.u8) => boolean = (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) === rs.u8Rem(k8, 3); }; - const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart()); - const a4: rt.ByteVec = _139[0]; - const b4: rt.ByteVec = _139[1]; + const _139: [rs.ByteVec, rs.ByteVec] = rs.iterPartition(rs.iterFrom(_140, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _141, [new rs.ByteVec() as rs.ByteVec, new rs.ByteVec() as rs.ByteVec], rs.byteVecPart()); + const a4: rs.ByteVec = _139[0]; + const b4: rs.ByteVec = _139[1]; putVec(out, a4); putVec(out, b4); } else { - rt.iterForEach(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b10: rt.u8): undefined => { - rt.byteVecPush(out, b10); + rs.iterForEach(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b10: rs.u8): undefined => { + rs.byteVecPush(out, b10); }); } } else { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0) & 0xff); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 3); - }, rt.lt)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMinByKey(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 3); + }, rs.lt)); } else { - put(out, rt.iterMax(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rt.lt)); + put(out, rs.iterMax(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rs.lt)); } } else if (pick === 9) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterLast(rt.iterChain(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rt.iterSlice(Uint8Array.of(7, 8))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterLast(rs.iterChain(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rs.iterSlice(Uint8Array.of(7, 8))))); } else { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rt.iterSlice(Uint8Array.of(7, 8)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), rs.iterSlice(Uint8Array.of(7, 8)))) & 0xff); } } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _175: Counted.Counted = it; - const _176: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_175, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _176))); + const _176: rs.usize = rs.usizeDiv(k, 2); + put(out, rs.iterLast(rs.iterSkip(rs.iterFrom(_175, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _176))); } else { const _170: Counted.Counted = it; - const _171: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_170, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _171)) & 0xff); + const _171: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterFrom(_170, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _171)) & 0xff); } } else if (pick === 11) { - const _178: rt.usize = rt.usizeRem(k, 4); + const _178: rs.usize = rs.usizeRem(k, 4); if (_178 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a8, 5) ^ b8; + rs.byteVecPush(out, rs.iterFold(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a8: rs.u8, b8: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a8, 5) ^ b8; })); } else if (_178 === 1) { - put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), rt.usizeDiv(k, 4))); + put(out, rs.iterNth(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), rs.usizeDiv(k, 4))); } else if (_178 === 2) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a7, 5) ^ b7; + rs.byteVecPush(out, rs.iterRfold(rs.iterRev(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })), 1, (a7: rs.u8, b7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a7, 5) ^ b7; })); } } else if (pick === 12) { const _196: Counted.Counted = it; - const _197: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _197); - put(out, rt.iterToOption(skip.next())); - put(out, rt.iterToOption(skip.nextBack())); + const _197: rs.usize = rs.usizeDiv(k, 2); + const skip: rs.Iter = rs.iterSkip(rs.iterFrom(_196, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _197); + put(out, rs.iterToOption(skip.next())); + put(out, rs.iterToOption(skip.nextBack())); } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _216: Counted.Counted = it; - const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + const _217: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined = (s: rs.Place, b5: rs.u8): rs.u8 | undefined => { s.v = s.v ^ b5; - return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + return thenSome$0quywni(s.v !== rs.u8Div(k8, 2), s.v); }; - const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _217, true); - putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); - put(out, rt.iterToOption(scan.next())); - rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + const scan: rs.Iter = rs.iterScan(rs.iterFrom(_216, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), 0, _217, true); + putVec(out, rs.iterToByteVec(rs.iterBorrow(scan), "next")); + put(out, rs.iterToOption(scan.next())); + rs.byteVecPush(out, rs.iterFold(scan, 0, (a6: rs.u8, b6: rs.u8): rs.u8 => { return a6 ^ b6; })); } else { const _210: Counted.Counted = it; - const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _211), "next")); + const _211: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + putVec(out, rs.iterToByteVec(rs.iterStepBy(rs.iterFrom(_210, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _211), "next")); } } else if (pick === 14) { - if (!(rt.usizeRem(k, 2) === 0)) { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, rt.iterCount(peek) & 0xff); + if (!(rs.usizeRem(k, 2) === 0)) { + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, rs.iterCount(peek) & 0xff); } else { - put(out, rt.iterLast(rt.iterFuse(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); + put(out, rs.iterLast(rs.iterFuse(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator })))); } } else { - const _249: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a5, 1); + const _249: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }), _249), 0, (a5: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8Add(a5, 1); })); - put(out, rt.iterLast(rt.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rt.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); - rt.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); + put(out, rs.iterLast(rs.iterFrom(it, Counted.next$iter_Iterator, undefined, { hint: Counted.sizeHint$iter_Iterator, back: (it: Counted.Counted) => rs.iterFromOption(Counted.nextBack$iter_DoubleEndedIterator(it)), len: Counted.len$iter_ExactSizeIterator }))); + rs.byteVecPush(out, Counted.len$iter_ExactSizeIterator(it) & 0xff); } } @@ -1360,119 +1360,119 @@ export function folded$ends_Counted(it: Counted.Counted, pick: rt.u8, k: rt.usiz * `nth`, `count`, or `last`, picked by `pick`, with `k` its count where it takes one. One * fold panics past `k` items, with what was logged so far. */ -export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function folded$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _50!: Uint8Array; - let r3!: rt.Result; + let r3!: rs.Result; let _66!: Uint8Array; - let _84!: rt.u8 | undefined; + let _84!: rs.u8 | undefined; let _99!: Uint8Array; - const k8: rt.u8 = k & 0xff; + const k8: rs.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, Overrides.fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(it, 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a16, 3) ^ b22; + rs.byteVecPush(out, Overrides.fold$iter_Iterator_u8_ends_folded_closure0_ends_Overrides(it, 1, (a16: rs.u8, b22: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { - rt.byteVecPush(out, Overrides.rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(it, 1, (a15: rt.u8, b21: rt.u8): rt.u8 => { + rs.byteVecPush(out, Overrides.rfold$iter_DoubleEndedIterator_u8_ends_folded_closure1_ends_Overrides(it, 1, (a15: rs.u8, b21: rs.u8): rs.u8 => { if (!(k < 15)) { if (!(b21 !== 2)) { - const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; - rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a15, 3) ^ b21; + return rs.u8WrappingMul(a15, 3) ^ b21; })); } else if (pick === 2) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 2)) { - if (!(rt.usizeRem(k, 4) === 3)) { - const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { - const _416: rt.u8 = rt.u8Rem(b20, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 2)) { + if (!(rs.usizeRem(k, 4) === 3)) { + const r2: rs.u8 | undefined | rs.None = rs.iterTryRfold(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), undefined as rs.u8 | undefined, (a14: rs.u8 | undefined, b20: rs.u8): rs.u8 | undefined | rs.None => { + const _416: rs.u8 = rs.u8Rem(b20, 3); if (_416 === 0) { - return rt.None; + return rs.None; } if (_416 === 1) { return undefined; } - return option_or$1loyskh(a14, b20); - }, true, undefined, rt.None); - if (r2 === rt.None) { + return option_or$0ar58vy(a14, b20); + }, true, undefined, rs.None); + if (r2 === rs.None) { _50 = Uint8Array.of(1, 0); } else { - _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + _50 = Uint8Array.of(0, option_unwrapOr$1fr498u(r2, 255)); } - rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_50), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } else { - const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { - return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { - rt.byteVecPush(out, b19); + const _38: (a0: rs.u8) => undefined | rs.None = (b19: rs.u8): undefined | rs.None => { + return then$1czl1m8(b19 !== rs.u8Div(k8, 4), (): undefined => { + rs.byteVecPush(out, b19); }); }; - rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.byteVecPush(out, rs.iterTryForEach(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _38, true, undefined, rs.None) !== rs.None ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } } else { - const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + const _29: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a13: rs.u8, b18: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b18 !== rs.u8Div(k8, 4), a13 ^ b18); }; - put(out, rt.iterTryFold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _29, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + put(out, rs.iterTryFold(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _29, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b17 !== k8, a12 ^ b17); + const _19: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a12: rs.u8, b17: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b17 !== k8, a12 ^ b17); }; - put(out, rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _19, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + put(out, rs.iterTryRfold(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _19, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } } else if (pick === 3) { - if (rt.usizeRem(k, 2) === 0) { - const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { - if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a11 ^ b16); + if (rs.usizeRem(k, 2) === 0) { + const _60: (a0: rs.u8, a1: rs.u8) => rs.Result = (a11: rs.u8, b16: rs.u8): rs.Result => { + if (!(rs.u8Rem(b16, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a11 ^ b16); } - return rt.Err(b16); + return rs.Err(b16); }; - r3 = rt.iterTryRfold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _60); + r3 = rs.iterTryRfold(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _60); } else { - const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { - if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a10 ^ b15); + const _63: (a0: rs.u8, a1: rs.u8) => rs.Result = (a10: rs.u8, b15: rs.u8): rs.Result => { + if (!(rs.u8Rem(b15, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a10 ^ b15); } - return rt.Err(b15); + return rs.Err(b15); }; - r3 = rt.iterTryFold(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _63); + r3 = rs.iterTryFold(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), 0, _63); } if (r3.ok) { _66 = Uint8Array.of(0, r3.value); } else { _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); - put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); + rs.iterExtendBytes(out, rs.iterSlice(_66), undefined, true); + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 1)) { - const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(rs.usizeRem(k, 2) === 1)) { + const r5: rs.Result = rs.iterTryRfold(rs.iterRev(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), 0, (a9: rs.u8, b14: rs.u8): rs.Result => { if (!(b14 > k8)) { - return rt.Ok(a9 ^ b14); + return rs.Ok(a9 ^ b14); } - return rt.Err(b14); + return rs.Err(b14); }); if (r5.ok) { _99 = Uint8Array.of(0, r5.value); } else { _99 = Uint8Array.of(1, r5.error); } - rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); - rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(_99), undefined, true); + rs.byteVecPush(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); } else { - const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b13: rt.u8): rt.Result => { - if (!(b13 > rt.u8Div(k8, 2))) { - rt.byteVecPush(out, b13); - return rt.OK; + const r4: rs.Result = rs.iterTryForEach(rs.iterRev(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b13: rs.u8): rs.Result => { + if (!(b13 > rs.u8Div(k8, 2))) { + rs.byteVecPush(out, b13); + return rs.OK; } - return rt.Err(b13); + return rs.Err(b13); }); if (r4.ok) { _84 = undefined; @@ -1480,122 +1480,122 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r _84 = r4.error; } put(out, _84); - rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.ownedCount(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b12: rt.u8): rt.u8 => { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.ownedCount(rs.iterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b12: rs.u8): rs.u8 => { return b12 ^ 1; })) & 0xff); } else { - rt.byteVecPush(out, Overrides.count$iter_Iterator(it) & 0xff); + rs.byteVecPush(out, Overrides.count$iter_Iterator(it) & 0xff); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); } else { put(out, Overrides.last$iter_Iterator(it)); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 1)) { + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 1)) { const _140: Overrides.Overrides = it; - const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + const _141: (a0: rs.u8) => boolean = (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) === rs.u8Rem(k8, 3); }; - const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart(), true); - const a4: rt.ByteVec = _139[0]; - const b4: rt.ByteVec = _139[1]; + const _139: [rs.ByteVec, rs.ByteVec] = rs.iterPartition(rs.iterFrom(_140, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _141, [new rs.ByteVec() as rs.ByteVec, new rs.ByteVec() as rs.ByteVec], rs.byteVecPart(), true); + const a4: rs.ByteVec = _139[0]; + const b4: rs.ByteVec = _139[1]; putVec(out, a4); putVec(out, b4); } else { - Overrides.forEach$iter_Iterator_ends_folded_closure11_ends_Overrides(it, (b10: rt.u8): undefined => { - rt.byteVecPush(out, b10); + Overrides.forEach$iter_Iterator_ends_folded_closure11_ends_Overrides(it, (b10: rs.u8): undefined => { + rs.byteVecPush(out, b10); }); } } else { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0, true) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0, true) & 0xff); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 3); - }, rt.lt, true)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMinByKey(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 3); + }, rs.lt, true)); } else { put(out, Overrides.max$iter_Iterator(it)); } } else if (pick === 9) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.ownedLast(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.ownedLast(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8))))); } else { - rt.byteVecPush(out, rt.ownedCount(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8)))) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8)))) & 0xff); } } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _175: Overrides.Overrides = it; - const _176: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.ownedLast(rt.iterSkip(rt.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _176))); + const _176: rs.usize = rs.usizeDiv(k, 2); + put(out, rs.ownedLast(rs.iterSkip(rs.iterFrom(_175, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _176))); } else { const _170: Overrides.Overrides = it; - const _171: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.ownedCount(rt.iterSkip(rt.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _171)) & 0xff); + const _171: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.ownedCount(rs.iterSkip(rs.iterFrom(_170, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _171)) & 0xff); } } else if (pick === 11) { - const _178: rt.usize = rt.usizeRem(k, 4); + const _178: rs.usize = rs.usizeRem(k, 4); if (_178 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a8, 5) ^ b8; + rs.byteVecPush(out, rs.iterFold(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a8: rs.u8, b8: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a8, 5) ^ b8; }, true)); } else if (_178 === 1) { - put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.usizeDiv(k, 4))); + put(out, rs.iterNth(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.usizeDiv(k, 4))); } else if (_178 === 2) { - put(out, rt.ownedLast(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); + put(out, rs.ownedLast(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a7, 5) ^ b7; + rs.byteVecPush(out, rs.iterRfold(rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), 1, (a7: rs.u8, b7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a7, 5) ^ b7; }, true)); } } else if (pick === 12) { const _196: Overrides.Overrides = it; - const _197: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _197); - put(out, rt.iterToOption(skip.next())); - put(out, rt.iterToOption(skip.nextBack())); + const _197: rs.usize = rs.usizeDiv(k, 2); + const skip: rs.Iter = rs.iterSkip(rs.iterFrom(_196, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _197); + put(out, rs.iterToOption(skip.next())); + put(out, rs.iterToOption(skip.nextBack())); } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _216: Overrides.Overrides = it; - const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + const _217: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined = (s: rs.Place, b5: rs.u8): rs.u8 | undefined => { s.v = s.v ^ b5; - return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + return thenSome$0quywni(s.v !== rs.u8Div(k8, 2), s.v); }; - const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), 0, _217, true); - putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); - put(out, rt.iterToOption(scan.next())); - rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + const scan: rs.Iter = rs.iterScan(rs.iterFrom(_216, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), 0, _217, true); + putVec(out, rs.iterToByteVec(rs.iterBorrow(scan), "next")); + put(out, rs.iterToOption(scan.next())); + rs.byteVecPush(out, rs.iterFold(scan, 0, (a6: rs.u8, b6: rs.u8): rs.u8 => { return a6 ^ b6; }, true)); } else { const _210: Overrides.Overrides = it; - const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _211), "next")); + const _211: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + putVec(out, rs.iterToByteVec(rs.iterStepBy(rs.iterFrom(_210, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _211), "next")); } } else if (pick === 14) { - if (!(rt.usizeRem(k, 2) === 0)) { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, rt.ownedCount(peek) & 0xff); + if (!(rs.usizeRem(k, 2) === 0)) { + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, rs.ownedCount(peek) & 0xff); } else { - put(out, rt.ownedLast(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); + put(out, rs.ownedLast(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })))); } } else { - const _249: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a5, 1); + const _249: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _249), 0, (a5: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8Add(a5, 1); })); - put(out, rt.iterLast(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))); - rt.byteVecPush(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); + put(out, rs.iterLast(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))); + rs.byteVecPush(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }).len() & 0xff); } } @@ -1604,121 +1604,121 @@ export function folded$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: r * `nth`, `count`, or `last`, picked by `pick`, with `k` its count where it takes one. One * fold panics past `k` items, with what was logged so far. */ -export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function folded$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _50!: Uint8Array; - let r3!: rt.Result; + let r3!: rs.Result; let _66!: Uint8Array; - let _84!: rt.u8 | undefined; + let _84!: rs.u8 | undefined; let _99!: Uint8Array; - const k8: rt.u8 = k & 0xff; + const k8: rs.u8 = k & 0xff; if (pick === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, (a16: rt.u8, b22: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a16, 3) ^ b22; + rs.byteVecPush(out, rs.iterFold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, (a16: rs.u8, b22: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a16, 3) ^ b22; })); } else if (pick === 1) { const _10: Run.Run = it; - const _11: (a0: rt.u8, a1: rt.u8) => rt.u8 = (a15: rt.u8, b21: rt.u8): rt.u8 => { + const _11: (a0: rs.u8, a1: rs.u8) => rs.u8 = (a15: rs.u8, b21: rs.u8): rs.u8 => { if (!(k < 15)) { if (!(b21 !== 2)) { - const _1110: rt.ByteSlice = rt.byteVecSlice(rt.refCellBorrow(log).value); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b21, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_1110), f, rt.u8Debug)]; - rt.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); + const _1110: rs.ByteSlice = rs.byteVecSlice(rs.refCellBorrow(log).value); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b21, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_1110), f, rs.u8Debug)]; + rs.panicFmt(["rfold at ", args2[0], " after ", args2[1]]); } } - return rt.u8WrappingMul(a15, 3) ^ b21; + return rs.u8WrappingMul(a15, 3) ^ b21; }; - rt.byteVecPush(out, rt.iterRfold(rt.iterFrom(_10, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, _11)); + rs.byteVecPush(out, rs.iterRfold(rs.iterFrom(_10, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 1, _11)); } else if (pick === 2) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 2)) { - if (!(rt.usizeRem(k, 4) === 3)) { - const r2: rt.u8 | undefined | rt.None = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), undefined as rt.u8 | undefined, (a14: rt.u8 | undefined, b20: rt.u8): rt.u8 | undefined | rt.None => { - const _416: rt.u8 = rt.u8Rem(b20, 3); + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 2)) { + if (!(rs.usizeRem(k, 4) === 3)) { + const r2: rs.u8 | undefined | rs.None = rs.iterTryRfold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), undefined as rs.u8 | undefined, (a14: rs.u8 | undefined, b20: rs.u8): rs.u8 | undefined | rs.None => { + const _416: rs.u8 = rs.u8Rem(b20, 3); if (_416 === 0) { - return rt.None; + return rs.None; } if (_416 === 1) { return undefined; } - return option_or$1loyskh(a14, b20); - }, true, undefined, rt.None); - if (r2 === rt.None) { + return option_or$0ar58vy(a14, b20); + }, true, undefined, rs.None); + if (r2 === rs.None) { _50 = Uint8Array.of(1, 0); } else { - _50 = Uint8Array.of(0, option_unwrapOr$0r2bmpr(r2, 255)); + _50 = Uint8Array.of(0, option_unwrapOr$1fr498u(r2, 255)); } - rt.iterExtendBytes(out, rt.iterSlice(_50), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_50), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } else { - const _38: (a0: rt.u8) => undefined | rt.None = (b19: rt.u8): undefined | rt.None => { - return then$19svsql(b19 !== rt.u8Div(k8, 4), (): undefined => { - rt.byteVecPush(out, b19); + const _38: (a0: rs.u8) => undefined | rs.None = (b19: rs.u8): undefined | rs.None => { + return then$1czl1m8(b19 !== rs.u8Div(k8, 4), (): undefined => { + rs.byteVecPush(out, b19); }); }; - rt.byteVecPush(out, rt.iterTryForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _38, true, undefined, rt.None) !== rt.None ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.byteVecPush(out, rs.iterTryForEach(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _38, true, undefined, rs.None) !== rs.None ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else { - const _29: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a13: rt.u8, b18: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b18 !== rt.u8Div(k8, 4), a13 ^ b18); + const _29: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a13: rs.u8, b18: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b18 !== rs.u8Div(k8, 4), a13 ^ b18); }; - put(out, rt.iterTryFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _29, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + put(out, rs.iterTryFold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _29, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else { - const _19: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a12: rt.u8, b17: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b17 !== k8, a12 ^ b17); + const _19: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a12: rs.u8, b17: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b17 !== k8, a12 ^ b17); }; - put(out, rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _19, true)); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + put(out, rs.iterTryRfold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _19, true)); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else if (pick === 3) { - if (rt.usizeRem(k, 2) === 0) { - const _60: (a0: rt.u8, a1: rt.u8) => rt.Result = (a11: rt.u8, b16: rt.u8): rt.Result => { - if (!(rt.u8Rem(b16, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a11 ^ b16); + if (rs.usizeRem(k, 2) === 0) { + const _60: (a0: rs.u8, a1: rs.u8) => rs.Result = (a11: rs.u8, b16: rs.u8): rs.Result => { + if (!(rs.u8Rem(b16, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a11 ^ b16); } - return rt.Err(b16); + return rs.Err(b16); }; - r3 = rt.iterTryRfold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _60); + r3 = rs.iterTryRfold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _60); } else { - const _63: (a0: rt.u8, a1: rt.u8) => rt.Result = (a10: rt.u8, b15: rt.u8): rt.Result => { - if (!(rt.u8Rem(b15, 4) === rt.u8Rem(k8, 4))) { - return rt.Ok(a10 ^ b15); + const _63: (a0: rs.u8, a1: rs.u8) => rs.Result = (a10: rs.u8, b15: rs.u8): rs.Result => { + if (!(rs.u8Rem(b15, 4) === rs.u8Rem(k8, 4))) { + return rs.Ok(a10 ^ b15); } - return rt.Err(b15); + return rs.Err(b15); }; - r3 = rt.iterTryFold(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _63); + r3 = rs.iterTryFold(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _63); } if (r3.ok) { _66 = Uint8Array.of(0, r3.value); } else { _66 = Uint8Array.of(1, r3.error); } - rt.iterExtendBytes(out, rt.iterSlice(_66), undefined, true); - put(out, rt.iterToOption(Run.next$iter_Iterator(it))); + rs.iterExtendBytes(out, rs.iterSlice(_66), undefined, true); + put(out, rs.iterToOption(Run.next$iter_Iterator(it))); } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 1)) { - const r5: rt.Result = rt.iterTryRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 0, (a9: rt.u8, b14: rt.u8): rt.Result => { + if (!(rs.usizeRem(k, 2) === 1)) { + const r5: rs.Result = rs.iterTryRfold(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 0, (a9: rs.u8, b14: rs.u8): rs.Result => { if (!(b14 > k8)) { - return rt.Ok(a9 ^ b14); + return rs.Ok(a9 ^ b14); } - return rt.Err(b14); + return rs.Err(b14); }); if (r5.ok) { _99 = Uint8Array.of(0, r5.value); } else { _99 = Uint8Array.of(1, r5.error); } - rt.iterExtendBytes(out, rt.iterSlice(_99), undefined, true); - rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(_99), undefined, true); + rs.byteVecPush(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } else { - const r4: rt.Result = rt.iterTryForEach(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b13: rt.u8): rt.Result => { - if (!(b13 > rt.u8Div(k8, 2))) { - rt.byteVecPush(out, b13); - return rt.OK; + const r4: rs.Result = rs.iterTryForEach(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b13: rs.u8): rs.Result => { + if (!(b13 > rs.u8Div(k8, 2))) { + rs.byteVecPush(out, b13); + return rs.OK; } - return rt.Err(b13); + return rs.Err(b13); }); if (r4.ok) { _84 = undefined; @@ -1726,122 +1726,122 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R _84 = r4.error; } put(out, _84); - rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b12: rt.u8): rt.u8 => { + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b12: rs.u8): rs.u8 => { return b12 ^ 1; })) & 0xff); } else { - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })) & 0xff); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } else { - put(out, rt.iterLast(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); + put(out, rs.iterLast(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 4) === 0)) { - if (!(rt.usizeRem(k, 4) === 1)) { + if (!(rs.usizeRem(k, 4) === 0)) { + if (!(rs.usizeRem(k, 4) === 1)) { const _140: Run.Run = it; - const _141: (a0: rt.u8) => boolean = (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) === rt.u8Rem(k8, 3); + const _141: (a0: rs.u8) => boolean = (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) === rs.u8Rem(k8, 3); }; - const _139: [rt.ByteVec, rt.ByteVec] = rt.iterPartition(rt.iterFrom(_140, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _141, [new rt.ByteVec() as rt.ByteVec, new rt.ByteVec() as rt.ByteVec], rt.byteVecPart()); - const a4: rt.ByteVec = _139[0]; - const b4: rt.ByteVec = _139[1]; + const _139: [rs.ByteVec, rs.ByteVec] = rs.iterPartition(rs.iterFrom(_140, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _141, [new rs.ByteVec() as rs.ByteVec, new rs.ByteVec() as rs.ByteVec], rs.byteVecPart()); + const a4: rs.ByteVec = _139[0]; + const b4: rs.ByteVec = _139[1]; putVec(out, a4); putVec(out, b4); } else { - rt.iterForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b10: rt.u8): undefined => { - rt.byteVecPush(out, b10); + rs.iterForEach(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b10: rs.u8): undefined => { + rs.byteVecPush(out, b10); }); } } else { - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; - }), rt.u32Add, 0) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; + }), rs.u32Add, 0) & 0xff); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMinByKey(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 3); - }, rt.lt)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMinByKey(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 3); + }, rs.lt)); } else { - put(out, rt.iterMax(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.lt)); + put(out, rs.iterMax(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt)); } } else if (pick === 9) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterLast(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8))))); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterLast(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8))))); } else { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8)))) & 0xff); } } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _175: Run.Run = it; - const _176: rt.usize = rt.usizeDiv(k, 2); - put(out, rt.iterLast(rt.iterSkip(rt.iterFrom(_175, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _176))); + const _176: rs.usize = rs.usizeDiv(k, 2); + put(out, rs.iterLast(rs.iterSkip(rs.iterFrom(_175, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _176))); } else { const _170: Run.Run = it; - const _171: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterFrom(_170, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _171)) & 0xff); + const _171: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterFrom(_170, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _171)) & 0xff); } } else if (pick === 11) { - const _178: rt.usize = rt.usizeRem(k, 4); + const _178: rs.usize = rs.usizeRem(k, 4); if (_178 === 0) { - rt.byteVecPush(out, rt.iterFold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a8: rt.u8, b8: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a8, 5) ^ b8; + rs.byteVecPush(out, rs.iterFold(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a8: rs.u8, b8: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a8, 5) ^ b8; })); } else if (_178 === 1) { - put(out, rt.iterNth(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), rt.usizeDiv(k, 4))); + put(out, rs.iterNth(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), rs.usizeDiv(k, 4))); } else if (_178 === 2) { - put(out, rt.iterLast(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); + put(out, rs.iterLast(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } else { - rt.byteVecPush(out, rt.iterRfold(rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a7: rt.u8, b7: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a7, 5) ^ b7; + rs.byteVecPush(out, rs.iterRfold(rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), 1, (a7: rs.u8, b7: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a7, 5) ^ b7; })); } } else if (pick === 12) { const _196: Run.Run = it; - const _197: rt.usize = rt.usizeDiv(k, 2); - const skip: rt.Iter = rt.iterSkip(rt.iterFrom(_196, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _197); - put(out, rt.iterToOption(skip.next())); - put(out, rt.iterToOption(skip.nextBack())); + const _197: rs.usize = rs.usizeDiv(k, 2); + const skip: rs.Iter = rs.iterSkip(rs.iterFrom(_196, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _197); + put(out, rs.iterToOption(skip.next())); + put(out, rs.iterToOption(skip.nextBack())); } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _216: Run.Run = it; - const _217: (a0: rt.Place, a1: rt.u8) => rt.u8 | undefined = (s: rt.Place, b5: rt.u8): rt.u8 | undefined => { + const _217: (a0: rs.Place, a1: rs.u8) => rs.u8 | undefined = (s: rs.Place, b5: rs.u8): rs.u8 | undefined => { s.v = s.v ^ b5; - return thenSome$0d5am30(s.v !== rt.u8Div(k8, 2), s.v); + return thenSome$0quywni(s.v !== rs.u8Div(k8, 2), s.v); }; - const scan: rt.Iter = rt.iterScan(rt.iterFrom(_216, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _217, true); - putVec(out, rt.iterToByteVec(rt.iterBorrow(scan), "next")); - put(out, rt.iterToOption(scan.next())); - rt.byteVecPush(out, rt.iterFold(scan, 0, (a6: rt.u8, b6: rt.u8): rt.u8 => { + const scan: rs.Iter = rs.iterScan(rs.iterFrom(_216, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), 0, _217, true); + putVec(out, rs.iterToByteVec(rs.iterBorrow(scan), "next")); + put(out, rs.iterToOption(scan.next())); + rs.byteVecPush(out, rs.iterFold(scan, 0, (a6: rs.u8, b6: rs.u8): rs.u8 => { return a6 ^ b6; })); } else { const _210: Run.Run = it; - const _211: rt.usize = rt.usizeAdd(rt.usizeDiv(k, 4), 1); - putVec(out, rt.iterToByteVec(rt.iterStepBy(rt.iterFrom(_210, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _211), "next")); + const _211: rs.usize = rs.usizeAdd(rs.usizeDiv(k, 4), 1); + putVec(out, rs.iterToByteVec(rs.iterStepBy(rs.iterFrom(_210, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _211), "next")); } } else if (pick === 14) { - if (!(rt.usizeRem(k, 2) === 0)) { - const peek: rt.Peekable = rt.iterPeekable(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); - put(out, rt.peekablePeek(peek)); - rt.byteVecPush(out, rt.iterCount(peek) & 0xff); + if (!(rs.usizeRem(k, 2) === 0)) { + const peek: rs.Peekable = rs.iterPeekable(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); + put(out, rs.peekablePeek(peek)); + rs.byteVecPush(out, rs.iterCount(peek) & 0xff); } else { - put(out, rt.iterLast(rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); + put(out, rs.iterLast(rs.iterFuse(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })))); } } else { - const _249: rt.usize = rt.usizeDiv(k, 2); - rt.byteVecPush(out, rt.iterFold(rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _249), 0, (a5: rt.u8, _3: rt.u8): rt.u8 => { - return rt.u8Add(a5, 1); + const _249: rs.usize = rs.usizeDiv(k, 2); + rs.byteVecPush(out, rs.iterFold(rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _249), 0, (a5: rs.u8, _3: rs.u8): rs.u8 => { + return rs.u8Add(a5, 1); })); - put(out, rt.iterLast(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); - rt.byteVecPush(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); + put(out, rs.iterLast(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }))); + rs.byteVecPush(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }).len() & 0xff); } } @@ -1850,222 +1850,222 @@ export function folded$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.R * `for_each`, `reduce`, `all`, or `is_sorted_by`, or that read it by `try_fold` beside * them, picked by `pick`, with `k` what each tests against. */ -export function found$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function found$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _107!: Uint8Array; - let _125!: rt.u8 | undefined; - const k8: rt.u8 = k & 0xff; + let _125!: rs.u8 | undefined; + const k8: rs.u8 = k & 0xff; if (pick === 0) { const _8: Overrides.Overrides = it; - const _9: (a0: rt.u8) => boolean = (b34: rt.u8): boolean => { - return rt.u8Rem(b34, 3) !== rt.u8Rem(k8, 3); + const _9: (a0: rs.u8) => boolean = (b34: rs.u8): boolean => { + return rs.u8Rem(b34, 3) !== rs.u8Rem(k8, 3); }; - rt.iterExtendBytes(out, rt.iterFilter(rt.iterBox(rt.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _9), "next"); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterBox(rs.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _9), "next"); } else if (pick === 1) { const _13: Overrides.Overrides = it; - const _14: (a0: rt.u8) => boolean = (b33: rt.u8): boolean => { - return rt.u8Rem(b33, 2) === rt.u8Rem(k8, 2); + const _14: (a0: rs.u8) => boolean = (b33: rs.u8): boolean => { + return rs.u8Rem(b33, 2) === rs.u8Rem(k8, 2); }; - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterBox(rt.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _14)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterBox(rs.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _14)), "next"); } else if (pick === 2) { const _17: Overrides.Overrides = it; - const _18: (a0: rt.u8) => rt.u8 | undefined = (b32: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b32, 3) !== rt.u8Rem(k8, 3), b32 ^ 15); + const _18: (a0: rs.u8) => rs.u8 | undefined = (b32: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b32, 3) !== rs.u8Rem(k8, 3), b32 ^ 15); }; - rt.iterExtendBytes(out, rt.iterFilterMap(rt.iterBox(rt.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _18), "next"); + rs.iterExtendBytes(out, rs.iterFilterMap(rs.iterBox(rs.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _18), "next"); } else if (pick === 3) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _27: Overrides.Overrides = it; - const _28: (a0: rt.u8) => boolean = (_220: rt.u8): boolean => { - return _220 < rt.u8Div(k8, 2); + const _28: (a0: rs.u8) => boolean = (_220: rs.u8): boolean => { + return _220 < rs.u8Div(k8, 2); }; - rt.iterExtendBytes(out, rt.iterSkipWhile(rt.iterBox(rt.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _28), "next"); + rs.iterExtendBytes(out, rs.iterSkipWhile(rs.iterBox(rs.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _28), "next"); } else { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b30: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b30, 3) !== 1, b30); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b30: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b30, 3) !== 1, b30); })), "next"); } } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8))), (b29: rt.u8): boolean => { - return rt.u8Rem(b29, 2) === 1; + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8))), (b29: rs.u8): boolean => { + return rs.u8Rem(b29, 2) === 1; })), "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8))), (b28: rt.u8): boolean => { - return rt.u8Rem(b28, 2) === 1; + rs.iterExtendBytes(out, rs.iterFilter(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8))), (b28: rs.u8): boolean => { + return rs.u8Rem(b28, 2) === 1; }), "next"); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - const fused: rt.Iter = rt.iterFilter(rt.iterFuse(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b27: rt.u8): boolean => { - return rt.u8Rem(b27, 4) === rt.u8Rem(k8, 4); + if (!(rs.usizeRem(k, 2) === 0)) { + const fused: rs.Iter = rs.iterFilter(rs.iterFuse(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b27: rs.u8): boolean => { + return rs.u8Rem(b27, 4) === rs.u8Rem(k8, 4); }); - put(out, rt.iterToOption(fused.nextBack())); - put(out, rt.iterToOption(fused.nextBack())); - rt.iterExtendBytes(out, fused, "next"); + put(out, rs.iterToOption(fused.nextBack())); + put(out, rs.iterToOption(fused.nextBack())); + rs.iterExtendBytes(out, fused, "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFuse(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b26: rt.u8): boolean => { - return rt.u8Rem(b26, 4) !== rt.u8Rem(k8, 4); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFuse(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), (b26: rs.u8): boolean => { + return rs.u8Rem(b26, 4) !== rs.u8Rem(k8, 4); }), "next"); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _83: (a0: rt.u8) => boolean = (_217: rt.u8): boolean => { - return _217 > rt.u8Div(k8, 2); + if (!(rs.usizeRem(k, 2) === 0)) { + const _83: (a0: rs.u8) => boolean = (_217: rs.u8): boolean => { + return _217 > rs.u8Div(k8, 2); }; - put(out, rt.iterFind(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _83)); - const _88: (a0: rt.u8) => boolean = (_218: rt.u8): boolean => { - return _218 > rt.u8Div(k8, 2); + put(out, rs.iterFind(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _83)); + const _88: (a0: rs.u8) => boolean = (_218: rs.u8): boolean => { + return _218 > rs.u8Div(k8, 2); }; - put(out, rt.iterRfind(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _88)); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + put(out, rs.iterRfind(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _88)); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } else { - const rev: rt.Iter = rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); - put(out, rt.iterFind(rev, (_213: rt.u8): boolean => { + const rev: rs.Iter = rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))); + put(out, rs.iterFind(rev, (_213: rs.u8): boolean => { return _213 < k8; })); - put(out, rt.iterRfind(rev, (_215: rt.u8): boolean => { + put(out, rs.iterRfind(rev, (_215: rs.u8): boolean => { return _215 < k8; })); - rt.iterExtendBytes(out, rev, "next"); + rs.iterExtendBytes(out, rev, "next"); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _104: (a0: rt.u8) => rt.u8 | undefined | rt.None = (b21: rt.u8): rt.u8 | undefined | rt.None => { - return thenSome$185ufyt(b21 >= rt.u8Div(k8, 2), thenSome$0d5am30(rt.u8Rem(b21, 2) === 0, b21)); + if (!(rs.usizeRem(k, 2) === 0)) { + const _104: (a0: rs.u8) => rs.u8 | undefined | rs.None = (b21: rs.u8): rs.u8 | undefined | rs.None => { + return thenSome$1ctlqen(b21 >= rs.u8Div(k8, 2), thenSome$0quywni(rs.u8Rem(b21, 2) === 0, b21)); }; - const found: rt.u8 | undefined | rt.None = rt.iterFindMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _104, rt.None); - if (found === rt.None) { + const found: rs.u8 | undefined | rs.None = rs.iterFindMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _104, rs.None); + if (found === rs.None) { _107 = Uint8Array.of(2, 0); } else if (found === undefined) { _107 = Uint8Array.of(1, 0); } else { _107 = Uint8Array.of(0, found); } - rt.iterExtendBytes(out, rt.iterSlice(_107), undefined, true); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_107), undefined, true); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } else { - const _98: (a0: rt.u8) => rt.u8 | undefined = (b20: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b20 > rt.u8Div(k8, 2), b20 ^ 1); + const _98: (a0: rs.u8) => rs.u8 | undefined = (b20: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b20 > rs.u8Div(k8, 2), b20 ^ 1); }; - put(out, rt.iterFindMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _98)); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + put(out, rs.iterFindMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _98)); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(Uint8Array.of(170))); - rt.listExtend(list, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "fold"); - rt.iterExtendBytes(out, rt.listIter(list), undefined, true); + if (!(rs.usizeRem(k, 2) === 0)) { + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(Uint8Array.of(170))); + rs.listExtend(list, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "fold"); + rs.iterExtendBytes(out, rs.listIter(list), undefined, true); } else { const _117: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBox(rt.iterFrom(_117, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterBox(rs.iterFrom(_117, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); } } else if (pick === 9) { - const _126: rt.usize = rt.usizeRem(k, 4); + const _126: rs.usize = rs.usizeRem(k, 4); if (_126 === 0) { - _125 = rt.iterMax(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.lt, true); + _125 = rs.iterMax(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.lt, true); } else if (_126 === 1) { - _125 = rt.iterMin(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.lt, true); + _125 = rs.iterMin(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.lt, true); } else if (_126 === 2) { - _125 = rt.iterMaxBy(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a4: rt.u8, b19: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a4, 3), rt.u8Rem(b19, 3)); + _125 = rs.iterMaxBy(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a4: rs.u8, b19: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a4, 3), rs.u8Rem(b19, 3)); }, true); } else { const guard: Guard.Guard = new Guard.Guard(log); const _132: Overrides.Overrides = it; const captured2 = guard; - _125 = rt.iterMinBy(rt.iterBox(rt.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.closure((a3: rt.u8, b18: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a3, 3), rt.u8Rem(b18, 3)); + _125 = rs.iterMinBy(rs.iterBox(rs.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.closure((a3: rs.u8, b18: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a3, 3), rs.u8Rem(b18, 3)); }, (): void => { captured2[Symbol.dispose](); }), true, undefined, true); } put(out, _125); } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const guard2: Guard.Guard = new Guard.Guard(log); const _144: Overrides.Overrides = it; const captured = guard2; - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterBox(rt.iterFrom(_144, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.closure((a2: rt.u8, b17: rt.u8): boolean => { - return rt.u8Div(a2, 2) <= rt.u8Div(b17, 2); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterBox(rs.iterFrom(_144, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.closure((a2: rs.u8, b17: rs.u8): boolean => { + return rs.u8Div(a2, 2) <= rs.u8Div(b17, 2); }, (): void => { captured[Symbol.dispose](); - }), true, undefined, rt.drop) ? 1 : 0); + }), true, undefined, rs.drop) ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.le, true) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.le, true) ? 1 : 0); } } else if (pick === 11) { - const _150: (a0: rt.u8) => boolean = (b15: rt.u8): boolean => { - return b15 === rt.u8Div(k8, 2); + const _150: (a0: rs.u8) => boolean = (b15: rs.u8): boolean => { + return b15 === rs.u8Div(k8, 2); }; - put(out, option_map$05nbzug(rt.iterPosition(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _150), (i2: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _150), (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - put(out, rt.iterReduce(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a: rt.u8, b16: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a, 3) ^ b16; + put(out, rs.iterReduce(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (a: rs.u8, b16: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a, 3) ^ b16; }, true)); } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b14: rt.u8): undefined => { - rt.byteVecPush(out, b14); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterForEach(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b14: rs.u8): undefined => { + rs.byteVecPush(out, b14); }, true); } else { - const _162: (a0: rt.u8) => boolean = (b13: rt.u8): boolean => { - return b13 !== rt.u8Div(k8, 2); + const _162: (a0: rs.u8) => boolean = (b13: rs.u8): boolean => { + return b13 !== rs.u8Div(k8, 2); }; - rt.byteVecPush(out, rt.iterAll(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _162) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + rs.byteVecPush(out, rs.iterAll(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), _162) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMin(rt.iterFilterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b12: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b12, 3) !== 1, b12); - }), rt.lt, true)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMin(rs.iterFilterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b12: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b12, 3) !== 1, b12); + }), rs.lt, true)); } else { - put(out, rt.iterMax(rt.iterFilter(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) !== 1; - }), rt.lt, true)); + put(out, rs.iterMax(rs.iterFilter(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 1; + }), rs.lt, true)); } } else if (pick === 14) { - const filter: rt.Iter = rt.iterFilter(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b9: rt.u8): boolean => { - return rt.u8Rem(b9, 2) === 0; + const filter: rs.Iter = rs.iterFilter(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b9: rs.u8): boolean => { + return rs.u8Rem(b9, 2) === 0; }); - rt.byteVecPush(out, rt.iterAny(filter, (b10: rt.u8): boolean => { - return b10 > rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAny(filter, (b10: rs.u8): boolean => { + return b10 > rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filter, "next"); + rs.iterExtendBytes(out, filter, "next"); } else { - const _187: rt.usize = rt.usizeRem(k, 4); + const _187: rs.usize = rs.usizeRem(k, 4); if (_187 === 0) { - const skip: rt.Iter = rt.iterSkipWhile(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (_29: rt.u8): boolean => { + const skip: rs.Iter = rs.iterSkipWhile(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (_29: rs.u8): boolean => { return _29 < 2; }); - put(out, option_map$05nbzug(rt.iterPosition(skip, (b8: rt.u8): boolean => { - return b8 > rt.u8Div(k8, 2); - }), (i: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(skip, (b8: rs.u8): boolean => { + return b8 > rs.u8Div(k8, 2); + }), (i: rs.usize): rs.u8 => { return i & 0xff; })); - rt.iterExtendBytes(out, skip, "next"); + rs.iterExtendBytes(out, skip, "next"); } else if (_187 === 1) { - const filterMap: rt.Iter = rt.iterFilterMap(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b5: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b5, 3) !== 0, b5); + const filterMap: rs.Iter = rs.iterFilterMap(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b5: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, b5); }); - rt.byteVecPush(out, rt.iterAll(filterMap, (b6: rt.u8): boolean => { - return b6 !== rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAll(filterMap, (b6: rs.u8): boolean => { + return b6 !== rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filterMap, "next"); + rs.iterExtendBytes(out, filterMap, "next"); } else if (_187 === 2) { - const chain: rt.Iter = rt.iterFilter(rt.iterChain(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rt.iterSlice(Uint8Array.of(7, 8))), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; + const chain: rs.Iter = rs.iterFilter(rs.iterChain(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), rs.iterSlice(Uint8Array.of(7, 8))), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 2) === 0; }); - put(out, rt.iterFind(chain, (_2: rt.u8): boolean => { - return _2 > rt.u8Div(k8, 2); + put(out, rs.iterFind(chain, (_2: rs.u8): boolean => { + return _2 > rs.u8Div(k8, 2); })); - rt.iterExtendBytes(out, chain, "next"); + rs.iterExtendBytes(out, chain, "next"); } else { - put(out, rt.iterToOption(rt.iterFilter(rt.iterFuse(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 1; + put(out, rs.iterToOption(rs.iterFilter(rs.iterFuse(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })))), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 1; }).next())); - rt.iterExtendBytes(out, rt.iterRev(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }))), "next"); } } } @@ -2075,216 +2075,216 @@ export function found$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt * `for_each`, `reduce`, `all`, or `is_sorted_by`, or that read it by `try_fold` beside * them, picked by `pick`, with `k` what each tests against. */ -export function found$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function found$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _107!: Uint8Array; - let _125!: rt.u8 | undefined; - const k8: rt.u8 = k & 0xff; + let _125!: rs.u8 | undefined; + const k8: rs.u8 = k & 0xff; if (pick === 0) { const _8: Overrides.Overrides = it; - const _9: (a0: rt.u8) => boolean = (b34: rt.u8): boolean => { - return rt.u8Rem(b34, 3) !== rt.u8Rem(k8, 3); + const _9: (a0: rs.u8) => boolean = (b34: rs.u8): boolean => { + return rs.u8Rem(b34, 3) !== rs.u8Rem(k8, 3); }; - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _9), "next"); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _9), "next"); } else if (pick === 1) { const _13: Overrides.Overrides = it; - const _14: (a0: rt.u8) => boolean = (b33: rt.u8): boolean => { - return rt.u8Rem(b33, 2) === rt.u8Rem(k8, 2); + const _14: (a0: rs.u8) => boolean = (b33: rs.u8): boolean => { + return rs.u8Rem(b33, 2) === rs.u8Rem(k8, 2); }; - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _14)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _14)), "next"); } else if (pick === 2) { const _17: Overrides.Overrides = it; - const _18: (a0: rt.u8) => rt.u8 | undefined = (b32: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b32, 3) !== rt.u8Rem(k8, 3), b32 ^ 15); + const _18: (a0: rs.u8) => rs.u8 | undefined = (b32: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b32, 3) !== rs.u8Rem(k8, 3), b32 ^ 15); }; - rt.iterExtendBytes(out, rt.iterFilterMap(rt.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _18), "next"); + rs.iterExtendBytes(out, rs.iterFilterMap(rs.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _18), "next"); } else if (pick === 3) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _27: Overrides.Overrides = it; - const _28: (a0: rt.u8) => boolean = (_220: rt.u8): boolean => { - return _220 < rt.u8Div(k8, 2); + const _28: (a0: rs.u8) => boolean = (_220: rs.u8): boolean => { + return _220 < rs.u8Div(k8, 2); }; - rt.iterExtendBytes(out, rt.iterSkipWhile(rt.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _28), "next"); + rs.iterExtendBytes(out, rs.iterSkipWhile(rs.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), _28), "next"); } else { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b30: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b30, 3) !== 1, b30); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b30: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b30, 3) !== 1, b30); })), "next"); } } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b29: rt.u8): boolean => { - return rt.u8Rem(b29, 2) === 1; + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b29: rs.u8): boolean => { + return rs.u8Rem(b29, 2) === 1; })), "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b28: rt.u8): boolean => { - return rt.u8Rem(b28, 2) === 1; + rs.iterExtendBytes(out, rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b28: rs.u8): boolean => { + return rs.u8Rem(b28, 2) === 1; }), "next"); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - const fused: rt.Iter = rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b27: rt.u8): boolean => { - return rt.u8Rem(b27, 4) === rt.u8Rem(k8, 4); + if (!(rs.usizeRem(k, 2) === 0)) { + const fused: rs.Iter = rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b27: rs.u8): boolean => { + return rs.u8Rem(b27, 4) === rs.u8Rem(k8, 4); }); - put(out, rt.iterToOption(fused.nextBack())); - put(out, rt.iterToOption(fused.nextBack())); - rt.iterExtendBytes(out, fused, "next"); + put(out, rs.iterToOption(fused.nextBack())); + put(out, rs.iterToOption(fused.nextBack())); + rs.iterExtendBytes(out, fused, "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b26: rt.u8): boolean => { - return rt.u8Rem(b26, 4) !== rt.u8Rem(k8, 4); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), (b26: rs.u8): boolean => { + return rs.u8Rem(b26, 4) !== rs.u8Rem(k8, 4); }), "next"); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, Overrides.find$iter_Iterator_ends_found_closure11_ends_Overrides(it, (_217: rt.u8): boolean => { - return _217 > rt.u8Div(k8, 2); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, Overrides.find$iter_Iterator_ends_found_closure11_ends_Overrides(it, (_217: rs.u8): boolean => { + return _217 > rs.u8Div(k8, 2); })); - put(out, Overrides.rfind$iter_DoubleEndedIterator_ends_found_closure12_ends_Overrides(it, (_218: rt.u8): boolean => { - return _218 > rt.u8Div(k8, 2); + put(out, Overrides.rfind$iter_DoubleEndedIterator_ends_found_closure12_ends_Overrides(it, (_218: rs.u8): boolean => { + return _218 > rs.u8Div(k8, 2); })); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } else { - const rev: rt.Iter = rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); - put(out, rt.iterFind(rev, (_213: rt.u8): boolean => { + const rev: rs.Iter = rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })); + put(out, rs.iterFind(rev, (_213: rs.u8): boolean => { return _213 < k8; })); - put(out, rt.iterRfind(rev, (_215: rt.u8): boolean => { + put(out, rs.iterRfind(rev, (_215: rs.u8): boolean => { return _215 < k8; })); - rt.iterExtendBytes(out, rev, "next"); + rs.iterExtendBytes(out, rev, "next"); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - const found: rt.u8 | undefined | rt.None = Overrides.findMap$iter_Iterator_Option_u8_ends_found_closure14_ends_Overrides(it, (b21: rt.u8): rt.u8 | undefined | rt.None => { - return thenSome$185ufyt(b21 >= rt.u8Div(k8, 2), thenSome$0d5am30(rt.u8Rem(b21, 2) === 0, b21)); + if (!(rs.usizeRem(k, 2) === 0)) { + const found: rs.u8 | undefined | rs.None = Overrides.findMap$iter_Iterator_Option_u8_ends_found_closure14_ends_Overrides(it, (b21: rs.u8): rs.u8 | undefined | rs.None => { + return thenSome$1ctlqen(b21 >= rs.u8Div(k8, 2), thenSome$0quywni(rs.u8Rem(b21, 2) === 0, b21)); }); - if (found === rt.None) { + if (found === rs.None) { _107 = Uint8Array.of(2, 0); } else if (found === undefined) { _107 = Uint8Array.of(1, 0); } else { _107 = Uint8Array.of(0, found); } - rt.iterExtendBytes(out, rt.iterSlice(_107), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_107), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } else { - put(out, Overrides.findMap$iter_Iterator_u8_ends_found_closure13_ends_Overrides(it, (b20: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b20 > rt.u8Div(k8, 2), b20 ^ 1); + put(out, Overrides.findMap$iter_Iterator_u8_ends_found_closure13_ends_Overrides(it, (b20: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b20 > rs.u8Div(k8, 2), b20 ^ 1); })); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(Uint8Array.of(170))); - rt.listExtend(list, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "fold"); - rt.iterExtendBytes(out, rt.listIter(list), undefined, true); + if (!(rs.usizeRem(k, 2) === 0)) { + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(Uint8Array.of(170))); + rs.listExtend(list, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "fold"); + rs.iterExtendBytes(out, rs.listIter(list), undefined, true); } else { const _117: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_117)), true, undefined, undefined, 1, true)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_117)), true, undefined, undefined, 1, true)), undefined, true); } } else if (pick === 9) { - const _126: rt.usize = rt.usizeRem(k, 4); + const _126: rs.usize = rs.usizeRem(k, 4); if (_126 === 0) { _125 = Overrides.max$iter_Iterator(it); } else if (_126 === 1) { - _125 = rt.iterMin(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.lt, true); + _125 = rs.iterMin(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.lt, true); } else if (_126 === 2) { - _125 = rt.iterMaxBy(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (a4: rt.u8, b19: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a4, 3), rt.u8Rem(b19, 3)); + _125 = rs.iterMaxBy(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (a4: rs.u8, b19: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a4, 3), rs.u8Rem(b19, 3)); }, true); } else { const guard: Guard.Guard = new Guard.Guard(log); const _132: Overrides.Overrides = it; const captured2 = guard; - _125 = rt.iterMinBy(rt.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.closure((a3: rt.u8, b18: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a3, 3), rt.u8Rem(b18, 3)); + _125 = rs.iterMinBy(rs.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.closure((a3: rs.u8, b18: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a3, 3), rs.u8Rem(b18, 3)); }, (): void => { captured2[Symbol.dispose](); }), true, undefined, true); } put(out, _125); } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const guard2: Guard.Guard = new Guard.Guard(log); const _144: Overrides.Overrides = it; const captured = guard2; - rt.byteVecPush(out, Overrides.isSortedBy$iter_Iterator_ends_found_closure17_ends_Overrides(_144, rt.closure((a2: rt.u8, b17: rt.u8): boolean => { - return rt.u8Div(a2, 2) <= rt.u8Div(b17, 2); + rs.byteVecPush(out, Overrides.isSortedBy$iter_Iterator_ends_found_closure17_ends_Overrides(_144, rs.closure((a2: rs.u8, b17: rs.u8): boolean => { + return rs.u8Div(a2, 2) <= rs.u8Div(b17, 2); }, (): void => { captured[Symbol.dispose](); })) ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.le, true) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.le, true) ? 1 : 0); } } else if (pick === 11) { - put(out, option_map$05nbzug(Overrides.position$iter_Iterator_ends_found_closure18_ends_Overrides(it, (b15: rt.u8): boolean => { - return b15 === rt.u8Div(k8, 2); - }), (i2: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(Overrides.position$iter_Iterator_ends_found_closure18_ends_Overrides(it, (b15: rs.u8): boolean => { + return b15 === rs.u8Div(k8, 2); + }), (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - put(out, Overrides.reduce$iter_Iterator_ends_found_closure20_ends_Overrides(it, (a: rt.u8, b16: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a, 3) ^ b16; + put(out, Overrides.reduce$iter_Iterator_ends_found_closure20_ends_Overrides(it, (a: rs.u8, b16: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a, 3) ^ b16; })); } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - Overrides.forEach$iter_Iterator_ends_found_closure22_ends_Overrides(it, (b14: rt.u8): undefined => { - rt.byteVecPush(out, b14); + if (!(rs.usizeRem(k, 2) === 0)) { + Overrides.forEach$iter_Iterator_ends_found_closure22_ends_Overrides(it, (b14: rs.u8): undefined => { + rs.byteVecPush(out, b14); }); } else { - rt.byteVecPush(out, Overrides.all$iter_Iterator_ends_found_closure21_ends_Overrides(it, (b13: rt.u8): boolean => { - return b13 !== rt.u8Div(k8, 2); + rs.byteVecPush(out, Overrides.all$iter_Iterator_ends_found_closure21_ends_Overrides(it, (b13: rs.u8): boolean => { + return b13 !== rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), "next"); } } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMin(rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b12: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b12, 3) !== 1, b12); - }), rt.lt, true)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMin(rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b12: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b12, 3) !== 1, b12); + }), rs.lt, true)); } else { - put(out, rt.iterMax(rt.iterFilter(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) !== 1; - }), rt.lt, true)); + put(out, rs.iterMax(rs.iterFilter(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 1; + }), rs.lt, true)); } } else if (pick === 14) { - const filter: rt.Iter = rt.iterFilter(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b9: rt.u8): boolean => { - return rt.u8Rem(b9, 2) === 0; + const filter: rs.Iter = rs.iterFilter(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b9: rs.u8): boolean => { + return rs.u8Rem(b9, 2) === 0; }); - rt.byteVecPush(out, rt.iterAny(filter, (b10: rt.u8): boolean => { - return b10 > rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAny(filter, (b10: rs.u8): boolean => { + return b10 > rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filter, "next"); + rs.iterExtendBytes(out, filter, "next"); } else { - const _187: rt.usize = rt.usizeRem(k, 4); + const _187: rs.usize = rs.usizeRem(k, 4); if (_187 === 0) { - const skip: rt.Iter = rt.iterSkipWhile(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (_29: rt.u8): boolean => { + const skip: rs.Iter = rs.iterSkipWhile(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (_29: rs.u8): boolean => { return _29 < 2; }); - put(out, option_map$05nbzug(rt.iterPosition(skip, (b8: rt.u8): boolean => { - return b8 > rt.u8Div(k8, 2); - }), (i: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(skip, (b8: rs.u8): boolean => { + return b8 > rs.u8Div(k8, 2); + }), (i: rs.usize): rs.u8 => { return i & 0xff; })); - rt.iterExtendBytes(out, skip, "next"); + rs.iterExtendBytes(out, skip, "next"); } else if (_187 === 1) { - const filterMap: rt.Iter = rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b5: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b5, 3) !== 0, b5); + const filterMap: rs.Iter = rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), (b5: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, b5); }); - rt.byteVecPush(out, rt.iterAll(filterMap, (b6: rt.u8): boolean => { - return b6 !== rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAll(filterMap, (b6: rs.u8): boolean => { + return b6 !== rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filterMap, "next"); + rs.iterExtendBytes(out, filterMap, "next"); } else if (_187 === 2) { - const chain: rt.Iter = rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; + const chain: rs.Iter = rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 2) === 0; }); - put(out, rt.iterFind(chain, (_2: rt.u8): boolean => { - return _2 > rt.u8Div(k8, 2); + put(out, rs.iterFind(chain, (_2: rs.u8): boolean => { + return _2 > rs.u8Div(k8, 2); })); - rt.iterExtendBytes(out, chain, "next"); + rs.iterExtendBytes(out, chain, "next"); } else { - put(out, rt.iterToOption(rt.iterFilter(rt.iterFuse(rt.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 1; + put(out, rs.iterToOption(rs.iterFilter(rs.iterFuse(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 1; }).next())); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"); } } } @@ -2294,222 +2294,222 @@ export function found$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt * `for_each`, `reduce`, `all`, or `is_sorted_by`, or that read it by `try_fold` beside * them, picked by `pick`, with `k` what each tests against. */ -export function found$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function found$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _107!: Uint8Array; - let _125!: rt.u8 | undefined; - const k8: rt.u8 = k & 0xff; + let _125!: rs.u8 | undefined; + const k8: rs.u8 = k & 0xff; if (pick === 0) { const _8: Run.Run = it; - const _9: (a0: rt.u8) => boolean = (b34: rt.u8): boolean => { - return rt.u8Rem(b34, 3) !== rt.u8Rem(k8, 3); + const _9: (a0: rs.u8) => boolean = (b34: rs.u8): boolean => { + return rs.u8Rem(b34, 3) !== rs.u8Rem(k8, 3); }; - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFrom(_8, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _9), "next"); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFrom(_8, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _9), "next"); } else if (pick === 1) { const _13: Run.Run = it; - const _14: (a0: rt.u8) => boolean = (b33: rt.u8): boolean => { - return rt.u8Rem(b33, 2) === rt.u8Rem(k8, 2); + const _14: (a0: rs.u8) => boolean = (b33: rs.u8): boolean => { + return rs.u8Rem(b33, 2) === rs.u8Rem(k8, 2); }; - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterFrom(_13, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _14)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterFrom(_13, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _14)), "next"); } else if (pick === 2) { const _17: Run.Run = it; - const _18: (a0: rt.u8) => rt.u8 | undefined = (b32: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b32, 3) !== rt.u8Rem(k8, 3), b32 ^ 15); + const _18: (a0: rs.u8) => rs.u8 | undefined = (b32: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b32, 3) !== rs.u8Rem(k8, 3), b32 ^ 15); }; - rt.iterExtendBytes(out, rt.iterFilterMap(rt.iterFrom(_17, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _18), "next"); + rs.iterExtendBytes(out, rs.iterFilterMap(rs.iterFrom(_17, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _18), "next"); } else if (pick === 3) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _27: Run.Run = it; - const _28: (a0: rt.u8) => boolean = (_220: rt.u8): boolean => { - return _220 < rt.u8Div(k8, 2); + const _28: (a0: rs.u8) => boolean = (_220: rs.u8): boolean => { + return _220 < rs.u8Div(k8, 2); }; - rt.iterExtendBytes(out, rt.iterSkipWhile(rt.iterFrom(_27, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _28), "next"); + rs.iterExtendBytes(out, rs.iterSkipWhile(rs.iterFrom(_27, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _28), "next"); } else { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b30: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b30, 3) !== 1, b30); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b30: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b30, 3) !== 1, b30); })), "next"); } } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b29: rt.u8): boolean => { - return rt.u8Rem(b29, 2) === 1; + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b29: rs.u8): boolean => { + return rs.u8Rem(b29, 2) === 1; })), "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b28: rt.u8): boolean => { - return rt.u8Rem(b28, 2) === 1; + rs.iterExtendBytes(out, rs.iterFilter(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b28: rs.u8): boolean => { + return rs.u8Rem(b28, 2) === 1; }), "next"); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - const fused: rt.Iter = rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b27: rt.u8): boolean => { - return rt.u8Rem(b27, 4) === rt.u8Rem(k8, 4); + if (!(rs.usizeRem(k, 2) === 0)) { + const fused: rs.Iter = rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b27: rs.u8): boolean => { + return rs.u8Rem(b27, 4) === rs.u8Rem(k8, 4); }); - put(out, rt.iterToOption(fused.nextBack())); - put(out, rt.iterToOption(fused.nextBack())); - rt.iterExtendBytes(out, fused, "next"); + put(out, rs.iterToOption(fused.nextBack())); + put(out, rs.iterToOption(fused.nextBack())); + rs.iterExtendBytes(out, fused, "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b26: rt.u8): boolean => { - return rt.u8Rem(b26, 4) !== rt.u8Rem(k8, 4); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b26: rs.u8): boolean => { + return rs.u8Rem(b26, 4) !== rs.u8Rem(k8, 4); }), "next"); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _83: (a0: rt.u8) => boolean = (_217: rt.u8): boolean => { - return _217 > rt.u8Div(k8, 2); + if (!(rs.usizeRem(k, 2) === 0)) { + const _83: (a0: rs.u8) => boolean = (_217: rs.u8): boolean => { + return _217 > rs.u8Div(k8, 2); }; - put(out, rt.iterFind(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _83)); - const _88: (a0: rt.u8) => boolean = (_218: rt.u8): boolean => { - return _218 > rt.u8Div(k8, 2); + put(out, rs.iterFind(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _83)); + const _88: (a0: rs.u8) => boolean = (_218: rs.u8): boolean => { + return _218 > rs.u8Div(k8, 2); }; - put(out, rt.iterRfind(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _88)); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + put(out, rs.iterRfind(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _88)); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } else { - const rev: rt.Iter = rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); - put(out, rt.iterFind(rev, (_213: rt.u8): boolean => { + const rev: rs.Iter = rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); + put(out, rs.iterFind(rev, (_213: rs.u8): boolean => { return _213 < k8; })); - put(out, rt.iterRfind(rev, (_215: rt.u8): boolean => { + put(out, rs.iterRfind(rev, (_215: rs.u8): boolean => { return _215 < k8; })); - rt.iterExtendBytes(out, rev, "next"); + rs.iterExtendBytes(out, rev, "next"); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _104: (a0: rt.u8) => rt.u8 | undefined | rt.None = (b21: rt.u8): rt.u8 | undefined | rt.None => { - return thenSome$185ufyt(b21 >= rt.u8Div(k8, 2), thenSome$0d5am30(rt.u8Rem(b21, 2) === 0, b21)); + if (!(rs.usizeRem(k, 2) === 0)) { + const _104: (a0: rs.u8) => rs.u8 | undefined | rs.None = (b21: rs.u8): rs.u8 | undefined | rs.None => { + return thenSome$1ctlqen(b21 >= rs.u8Div(k8, 2), thenSome$0quywni(rs.u8Rem(b21, 2) === 0, b21)); }; - const found: rt.u8 | undefined | rt.None = rt.iterFindMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _104, rt.None); - if (found === rt.None) { + const found: rs.u8 | undefined | rs.None = rs.iterFindMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _104, rs.None); + if (found === rs.None) { _107 = Uint8Array.of(2, 0); } else if (found === undefined) { _107 = Uint8Array.of(1, 0); } else { _107 = Uint8Array.of(0, found); } - rt.iterExtendBytes(out, rt.iterSlice(_107), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_107), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } else { - const _98: (a0: rt.u8) => rt.u8 | undefined = (b20: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b20 > rt.u8Div(k8, 2), b20 ^ 1); + const _98: (a0: rs.u8) => rs.u8 | undefined = (b20: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b20 > rs.u8Div(k8, 2), b20 ^ 1); }; - put(out, rt.iterFindMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _98)); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + put(out, rs.iterFindMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _98)); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(Uint8Array.of(170))); - rt.listExtend(list, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); - rt.iterExtendBytes(out, rt.listIter(list), undefined, true); + if (!(rs.usizeRem(k, 2) === 0)) { + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(Uint8Array.of(170))); + rs.listExtend(list, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })); + rs.iterExtendBytes(out, rs.listIter(list), undefined, true); } else { const _117: Run.Run = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterFrom(_117, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_117, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); } } else if (pick === 9) { - const _126: rt.usize = rt.usizeRem(k, 4); + const _126: rs.usize = rs.usizeRem(k, 4); if (_126 === 0) { - _125 = rt.iterMax(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.lt); + _125 = rs.iterMax(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt); } else if (_126 === 1) { - _125 = rt.iterMin(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.lt); + _125 = rs.iterMin(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt); } else if (_126 === 2) { - _125 = rt.iterMaxBy(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a4: rt.u8, b19: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a4, 3), rt.u8Rem(b19, 3)); + _125 = rs.iterMaxBy(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a4: rs.u8, b19: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a4, 3), rs.u8Rem(b19, 3)); }); } else { const guard: Guard.Guard = new Guard.Guard(log); const _132: Run.Run = it; const captured2 = guard; - _125 = rt.iterMinBy(rt.iterFrom(_132, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.closure((a3: rt.u8, b18: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a3, 3), rt.u8Rem(b18, 3)); + _125 = rs.iterMinBy(rs.iterFrom(_132, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.closure((a3: rs.u8, b18: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a3, 3), rs.u8Rem(b18, 3)); }, (): void => { captured2[Symbol.dispose](); }), undefined, undefined, true); } put(out, _125); } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const guard2: Guard.Guard = new Guard.Guard(log); const _144: Run.Run = it; const captured = guard2; - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterFrom(_144, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.closure((a2: rt.u8, b17: rt.u8): boolean => { - return rt.u8Div(a2, 2) <= rt.u8Div(b17, 2); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterFrom(_144, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.closure((a2: rs.u8, b17: rs.u8): boolean => { + return rs.u8Div(a2, 2) <= rs.u8Div(b17, 2); }, (): void => { captured[Symbol.dispose](); - }), undefined, undefined, rt.drop) ? 1 : 0); + }), undefined, undefined, rs.drop) ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.le) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.le) ? 1 : 0); } } else if (pick === 11) { - const _150: (a0: rt.u8) => boolean = (b15: rt.u8): boolean => { - return b15 === rt.u8Div(k8, 2); + const _150: (a0: rs.u8) => boolean = (b15: rs.u8): boolean => { + return b15 === rs.u8Div(k8, 2); }; - put(out, option_map$05nbzug(rt.iterPosition(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _150), (i2: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _150), (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - put(out, rt.iterReduce(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a: rt.u8, b16: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a, 3) ^ b16; + put(out, rs.iterReduce(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (a: rs.u8, b16: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a, 3) ^ b16; })); } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b14: rt.u8): undefined => { - rt.byteVecPush(out, b14); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterForEach(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b14: rs.u8): undefined => { + rs.byteVecPush(out, b14); }); } else { - const _162: (a0: rt.u8) => boolean = (b13: rt.u8): boolean => { - return b13 !== rt.u8Div(k8, 2); + const _162: (a0: rs.u8) => boolean = (b13: rs.u8): boolean => { + return b13 !== rs.u8Div(k8, 2); }; - rt.byteVecPush(out, rt.iterAll(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _162) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.byteVecPush(out, rs.iterAll(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), _162) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"); } } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMin(rt.iterFilterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b12: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b12, 3) !== 1, b12); - }), rt.lt)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMin(rs.iterFilterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b12: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b12, 3) !== 1, b12); + }), rs.lt)); } else { - put(out, rt.iterMax(rt.iterFilter(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) !== 1; - }), rt.lt)); + put(out, rs.iterMax(rs.iterFilter(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 1; + }), rs.lt)); } } else if (pick === 14) { - const filter: rt.Iter = rt.iterFilter(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b9: rt.u8): boolean => { - return rt.u8Rem(b9, 2) === 0; + const filter: rs.Iter = rs.iterFilter(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b9: rs.u8): boolean => { + return rs.u8Rem(b9, 2) === 0; }); - rt.byteVecPush(out, rt.iterAny(filter, (b10: rt.u8): boolean => { - return b10 > rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAny(filter, (b10: rs.u8): boolean => { + return b10 > rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filter, "next"); + rs.iterExtendBytes(out, filter, "next"); } else { - const _187: rt.usize = rt.usizeRem(k, 4); + const _187: rs.usize = rs.usizeRem(k, 4); if (_187 === 0) { - const skip: rt.Iter = rt.iterSkipWhile(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (_29: rt.u8): boolean => { + const skip: rs.Iter = rs.iterSkipWhile(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (_29: rs.u8): boolean => { return _29 < 2; }); - put(out, option_map$05nbzug(rt.iterPosition(skip, (b8: rt.u8): boolean => { - return b8 > rt.u8Div(k8, 2); - }), (i: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(skip, (b8: rs.u8): boolean => { + return b8 > rs.u8Div(k8, 2); + }), (i: rs.usize): rs.u8 => { return i & 0xff; })); - rt.iterExtendBytes(out, skip, "next"); + rs.iterExtendBytes(out, skip, "next"); } else if (_187 === 1) { - const filterMap: rt.Iter = rt.iterFilterMap(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b5: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b5, 3) !== 0, b5); + const filterMap: rs.Iter = rs.iterFilterMap(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), (b5: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, b5); }); - rt.byteVecPush(out, rt.iterAll(filterMap, (b6: rt.u8): boolean => { - return b6 !== rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAll(filterMap, (b6: rs.u8): boolean => { + return b6 !== rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filterMap, "next"); + rs.iterExtendBytes(out, filterMap, "next"); } else if (_187 === 2) { - const chain: rt.Iter = rt.iterFilter(rt.iterChain(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; + const chain: rs.Iter = rs.iterFilter(rs.iterChain(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 2) === 0; }); - put(out, rt.iterFind(chain, (_2: rt.u8): boolean => { - return _2 > rt.u8Div(k8, 2); + put(out, rs.iterFind(chain, (_2: rs.u8): boolean => { + return _2 > rs.u8Div(k8, 2); })); - rt.iterExtendBytes(out, chain, "next"); + rs.iterExtendBytes(out, chain, "next"); } else { - put(out, rt.iterToOption(rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 1; + put(out, rs.iterToOption(rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 1; }).next())); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) })), "next"); } } } @@ -2519,222 +2519,222 @@ export function found$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.Re * `for_each`, `reduce`, `all`, or `is_sorted_by`, or that read it by `try_fold` beside * them, picked by `pick`, with `k` what each tests against. */ -export function found$mut_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { +export function found$mut_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { let _107!: Uint8Array; - let _125!: rt.u8 | undefined; - const k8: rt.u8 = k & 0xff; + let _125!: rs.u8 | undefined; + const k8: rs.u8 = k & 0xff; if (pick === 0) { const _8: Overrides.Overrides = it; - const _9: (a0: rt.u8) => boolean = (b34: rt.u8): boolean => { - return rt.u8Rem(b34, 3) !== rt.u8Rem(k8, 3); + const _9: (a0: rs.u8) => boolean = (b34: rs.u8): boolean => { + return rs.u8Rem(b34, 3) !== rs.u8Rem(k8, 3); }; - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _9), "next"); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFrom(_8, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _9), "next"); } else if (pick === 1) { const _13: Overrides.Overrides = it; - const _14: (a0: rt.u8) => boolean = (b33: rt.u8): boolean => { - return rt.u8Rem(b33, 2) === rt.u8Rem(k8, 2); + const _14: (a0: rs.u8) => boolean = (b33: rs.u8): boolean => { + return rs.u8Rem(b33, 2) === rs.u8Rem(k8, 2); }; - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _14)), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterFrom(_13, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _14)), "next"); } else if (pick === 2) { const _17: Overrides.Overrides = it; - const _18: (a0: rt.u8) => rt.u8 | undefined = (b32: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b32, 3) !== rt.u8Rem(k8, 3), b32 ^ 15); + const _18: (a0: rs.u8) => rs.u8 | undefined = (b32: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b32, 3) !== rs.u8Rem(k8, 3), b32 ^ 15); }; - rt.iterExtendBytes(out, rt.iterFilterMap(rt.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _18), "next"); + rs.iterExtendBytes(out, rs.iterFilterMap(rs.iterFrom(_17, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _18), "next"); } else if (pick === 3) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const _27: Overrides.Overrides = it; - const _28: (a0: rt.u8) => boolean = (_220: rt.u8): boolean => { - return _220 < rt.u8Div(k8, 2); + const _28: (a0: rs.u8) => boolean = (_220: rs.u8): boolean => { + return _220 < rs.u8Div(k8, 2); }; - rt.iterExtendBytes(out, rt.iterSkipWhile(rt.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _28), "next"); + rs.iterExtendBytes(out, rs.iterSkipWhile(rs.iterFrom(_27, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _28), "next"); } else { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b30: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b30, 3) !== 1, b30); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b30: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b30, 3) !== 1, b30); })), "next"); } } else if (pick === 4) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterExtendBytes(out, rt.iterRev(rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b29: rt.u8): boolean => { - return rt.u8Rem(b29, 2) === 1; + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterExtendBytes(out, rs.iterRev(rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b29: rs.u8): boolean => { + return rs.u8Rem(b29, 2) === 1; })), "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b28: rt.u8): boolean => { - return rt.u8Rem(b28, 2) === 1; + rs.iterExtendBytes(out, rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b28: rs.u8): boolean => { + return rs.u8Rem(b28, 2) === 1; }), "next"); } } else if (pick === 5) { - if (!(rt.usizeRem(k, 2) === 0)) { - const fused: rt.Iter = rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b27: rt.u8): boolean => { - return rt.u8Rem(b27, 4) === rt.u8Rem(k8, 4); + if (!(rs.usizeRem(k, 2) === 0)) { + const fused: rs.Iter = rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b27: rs.u8): boolean => { + return rs.u8Rem(b27, 4) === rs.u8Rem(k8, 4); }); - put(out, rt.iterToOption(fused.nextBack())); - put(out, rt.iterToOption(fused.nextBack())); - rt.iterExtendBytes(out, fused, "next"); + put(out, rs.iterToOption(fused.nextBack())); + put(out, rs.iterToOption(fused.nextBack())); + rs.iterExtendBytes(out, fused, "next"); } else { - rt.iterExtendBytes(out, rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b26: rt.u8): boolean => { - return rt.u8Rem(b26, 4) !== rt.u8Rem(k8, 4); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b26: rs.u8): boolean => { + return rs.u8Rem(b26, 4) !== rs.u8Rem(k8, 4); }), "next"); } } else if (pick === 6) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _83: (a0: rt.u8) => boolean = (_217: rt.u8): boolean => { - return _217 > rt.u8Div(k8, 2); + if (!(rs.usizeRem(k, 2) === 0)) { + const _83: (a0: rs.u8) => boolean = (_217: rs.u8): boolean => { + return _217 > rs.u8Div(k8, 2); }; - put(out, rt.iterFind(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _83)); - const _88: (a0: rt.u8) => boolean = (_218: rt.u8): boolean => { - return _218 > rt.u8Div(k8, 2); + put(out, rs.iterFind(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _83)); + const _88: (a0: rs.u8) => boolean = (_218: rs.u8): boolean => { + return _218 > rs.u8Div(k8, 2); }; - put(out, rt.iterRfind(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _88)); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); + put(out, rs.iterRfind(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _88)); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); } else { - const rev: rt.Iter = rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })); - put(out, rt.iterFind(rev, (_213: rt.u8): boolean => { + const rev: rs.Iter = rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })); + put(out, rs.iterFind(rev, (_213: rs.u8): boolean => { return _213 < k8; })); - put(out, rt.iterRfind(rev, (_215: rt.u8): boolean => { + put(out, rs.iterRfind(rev, (_215: rs.u8): boolean => { return _215 < k8; })); - rt.iterExtendBytes(out, rev, "next"); + rs.iterExtendBytes(out, rev, "next"); } } else if (pick === 7) { - if (!(rt.usizeRem(k, 2) === 0)) { - const _104: (a0: rt.u8) => rt.u8 | undefined | rt.None = (b21: rt.u8): rt.u8 | undefined | rt.None => { - return thenSome$185ufyt(b21 >= rt.u8Div(k8, 2), thenSome$0d5am30(rt.u8Rem(b21, 2) === 0, b21)); + if (!(rs.usizeRem(k, 2) === 0)) { + const _104: (a0: rs.u8) => rs.u8 | undefined | rs.None = (b21: rs.u8): rs.u8 | undefined | rs.None => { + return thenSome$1ctlqen(b21 >= rs.u8Div(k8, 2), thenSome$0quywni(rs.u8Rem(b21, 2) === 0, b21)); }; - const found: rt.u8 | undefined | rt.None = rt.iterFindMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _104, rt.None); - if (found === rt.None) { + const found: rs.u8 | undefined | rs.None = rs.iterFindMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _104, rs.None); + if (found === rs.None) { _107 = Uint8Array.of(2, 0); } else if (found === undefined) { _107 = Uint8Array.of(1, 0); } else { _107 = Uint8Array.of(0, found); } - rt.iterExtendBytes(out, rt.iterSlice(_107), undefined, true); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); + rs.iterExtendBytes(out, rs.iterSlice(_107), undefined, true); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); } else { - const _98: (a0: rt.u8) => rt.u8 | undefined = (b20: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b20 > rt.u8Div(k8, 2), b20 ^ 1); + const _98: (a0: rs.u8) => rs.u8 | undefined = (b20: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b20 > rs.u8Div(k8, 2), b20 ^ 1); }; - put(out, rt.iterFindMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _98)); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); + put(out, rs.iterFindMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _98)); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); } } else if (pick === 8) { - if (!(rt.usizeRem(k, 2) === 0)) { - const list: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(Uint8Array.of(170))); - rt.listExtend(list, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })); - rt.iterExtendBytes(out, rt.listIter(list), undefined, true); + if (!(rs.usizeRem(k, 2) === 0)) { + const list: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(Uint8Array.of(170))); + rs.listExtend(list, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })); + rs.iterExtendBytes(out, rs.listIter(list), undefined, true); } else { const _117: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterFrom(_117, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_117, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); } } else if (pick === 9) { - const _126: rt.usize = rt.usizeRem(k, 4); + const _126: rs.usize = rs.usizeRem(k, 4); if (_126 === 0) { - _125 = rt.iterMax(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.lt); + _125 = rs.iterMax(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.lt); } else if (_126 === 1) { - _125 = rt.iterMin(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.lt); + _125 = rs.iterMin(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.lt); } else if (_126 === 2) { - _125 = rt.iterMaxBy(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (a4: rt.u8, b19: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a4, 3), rt.u8Rem(b19, 3)); + _125 = rs.iterMaxBy(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (a4: rs.u8, b19: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a4, 3), rs.u8Rem(b19, 3)); }); } else { const guard: Guard.Guard = new Guard.Guard(log); const _132: Overrides.Overrides = it; const captured2 = guard; - _125 = rt.iterMinBy(rt.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.closure((a3: rt.u8, b18: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Rem(a3, 3), rt.u8Rem(b18, 3)); + _125 = rs.iterMinBy(rs.iterFrom(_132, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.closure((a3: rs.u8, b18: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Rem(a3, 3), rs.u8Rem(b18, 3)); }, (): void => { captured2[Symbol.dispose](); }), undefined, undefined, true); } put(out, _125); } else if (pick === 10) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const guard2: Guard.Guard = new Guard.Guard(log); const _144: Overrides.Overrides = it; const captured = guard2; - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterFrom(_144, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.closure((a2: rt.u8, b17: rt.u8): boolean => { - return rt.u8Div(a2, 2) <= rt.u8Div(b17, 2); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterFrom(_144, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.closure((a2: rs.u8, b17: rs.u8): boolean => { + return rs.u8Div(a2, 2) <= rs.u8Div(b17, 2); }, (): void => { captured[Symbol.dispose](); - }), undefined, undefined, rt.drop) ? 1 : 0); + }), undefined, undefined, rs.drop) ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.le) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.le) ? 1 : 0); } } else if (pick === 11) { - const _150: (a0: rt.u8) => boolean = (b15: rt.u8): boolean => { - return b15 === rt.u8Div(k8, 2); + const _150: (a0: rs.u8) => boolean = (b15: rs.u8): boolean => { + return b15 === rs.u8Div(k8, 2); }; - put(out, option_map$05nbzug(rt.iterPosition(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _150), (i2: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _150), (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - put(out, rt.iterReduce(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (a: rt.u8, b16: rt.u8): rt.u8 => { - return rt.u8WrappingMul(a, 3) ^ b16; + put(out, rs.iterReduce(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (a: rs.u8, b16: rs.u8): rs.u8 => { + return rs.u8WrappingMul(a, 3) ^ b16; })); } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.iterForEach(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b14: rt.u8): undefined => { - rt.byteVecPush(out, b14); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.iterForEach(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b14: rs.u8): undefined => { + rs.byteVecPush(out, b14); }); } else { - const _162: (a0: rt.u8) => boolean = (b13: rt.u8): boolean => { - return b13 !== rt.u8Div(k8, 2); + const _162: (a0: rs.u8) => boolean = (b13: rs.u8): boolean => { + return b13 !== rs.u8Div(k8, 2); }; - rt.byteVecPush(out, rt.iterAll(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _162) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); + rs.byteVecPush(out, rs.iterAll(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), _162) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"); } } else if (pick === 13) { - if (!(rt.usizeRem(k, 2) === 0)) { - put(out, rt.iterMin(rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b12: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b12, 3) !== 1, b12); - }), rt.lt)); + if (!(rs.usizeRem(k, 2) === 0)) { + put(out, rs.iterMin(rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b12: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b12, 3) !== 1, b12); + }), rs.lt)); } else { - put(out, rt.iterMax(rt.iterFilter(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) !== 1; - }), rt.lt)); + put(out, rs.iterMax(rs.iterFilter(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 1; + }), rs.lt)); } } else if (pick === 14) { - const filter: rt.Iter = rt.iterFilter(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b9: rt.u8): boolean => { - return rt.u8Rem(b9, 2) === 0; + const filter: rs.Iter = rs.iterFilter(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b9: rs.u8): boolean => { + return rs.u8Rem(b9, 2) === 0; }); - rt.byteVecPush(out, rt.iterAny(filter, (b10: rt.u8): boolean => { - return b10 > rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAny(filter, (b10: rs.u8): boolean => { + return b10 > rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filter, "next"); + rs.iterExtendBytes(out, filter, "next"); } else { - const _187: rt.usize = rt.usizeRem(k, 4); + const _187: rs.usize = rs.usizeRem(k, 4); if (_187 === 0) { - const skip: rt.Iter = rt.iterSkipWhile(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (_29: rt.u8): boolean => { + const skip: rs.Iter = rs.iterSkipWhile(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (_29: rs.u8): boolean => { return _29 < 2; }); - put(out, option_map$05nbzug(rt.iterPosition(skip, (b8: rt.u8): boolean => { - return b8 > rt.u8Div(k8, 2); - }), (i: rt.usize): rt.u8 => { + put(out, option_map$14ju55r(rs.iterPosition(skip, (b8: rs.u8): boolean => { + return b8 > rs.u8Div(k8, 2); + }), (i: rs.usize): rs.u8 => { return i & 0xff; })); - rt.iterExtendBytes(out, skip, "next"); + rs.iterExtendBytes(out, skip, "next"); } else if (_187 === 1) { - const filterMap: rt.Iter = rt.iterFilterMap(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b5: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b5, 3) !== 0, b5); + const filterMap: rs.Iter = rs.iterFilterMap(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), (b5: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, b5); }); - rt.byteVecPush(out, rt.iterAll(filterMap, (b6: rt.u8): boolean => { - return b6 !== rt.u8Div(k8, 2); + rs.byteVecPush(out, rs.iterAll(filterMap, (b6: rs.u8): boolean => { + return b6 !== rs.u8Div(k8, 2); }) ? 1 : 0); - rt.iterExtendBytes(out, filterMap, "next"); + rs.iterExtendBytes(out, filterMap, "next"); } else if (_187 === 2) { - const chain: rt.Iter = rt.iterFilter(rt.iterChain(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.iterSlice(Uint8Array.of(7, 8))), (b3: rt.u8): boolean => { - return rt.u8Rem(b3, 2) === 0; + const chain: rs.Iter = rs.iterFilter(rs.iterChain(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.iterSlice(Uint8Array.of(7, 8))), (b3: rs.u8): boolean => { + return rs.u8Rem(b3, 2) === 0; }); - put(out, rt.iterFind(chain, (_2: rt.u8): boolean => { - return _2 > rt.u8Div(k8, 2); + put(out, rs.iterFind(chain, (_2: rs.u8): boolean => { + return _2 > rs.u8Div(k8, 2); })); - rt.iterExtendBytes(out, chain, "next"); + rs.iterExtendBytes(out, chain, "next"); } else { - put(out, rt.iterToOption(rt.iterFilter(rt.iterFuse(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 1; + put(out, rs.iterToOption(rs.iterFilter(rs.iterFuse(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 1; }).next())); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) })), "next"); } } } @@ -2745,82 +2745,82 @@ export function found$mut_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k * comparisons that call its `eq` or `partial_cmp`, or read through its `by_ref`, picked by * `pick`. */ -export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - const _8: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 255, (o2: rt.Ordering): rt.u8 => { +export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { - return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { + const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { + return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; b0: { - const other: rt.Range = new rt.Range(0, k & 0xff); + const other: rs.Range = new rs.Range(0, k & 0xff); if (pick === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); } else if (pick === 1) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")))), undefined, true); } else if (pick === 2) { - const _17: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_17.value)), undefined, true); + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); _17[Symbol.dispose](); } else if (pick === 3) { - const _22: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_22.value)), undefined, true); + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); _22[Symbol.dispose](); } else if (pick === 4) { const _25: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBox(rt.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterBox(rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), true, undefined, "next", 1)), undefined, true); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapFrom(rt.iterToVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next", 1), rt.le, rt.ge, rt.lt))), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); } else if (pick === 6) { const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.vecIntoIter(Pairs.collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rt.iterExtendBytes(out, _9(part4), "fold", true); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_boxed_Box_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), "fold", true); } else if (pick === 7) { const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterFrom(_40, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part3), "fold", true); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), "fold", true); } else if (pick === 8) { const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterBox(rt.iterFrom(_46, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides)), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part2), "fold", true); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_boxed_Box_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), "fold", true); } else if (pick === 9) { - rt.byteVecPush(out, rt.iterEq(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.same, undefined, true) ? 1 : 0); + rs.byteVecPush(out, rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); } else if (pick === 10) { - rt.byteVecPush(out, !rt.iterEq(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.same, undefined, true) ? 1 : 0); + rs.byteVecPush(out, !rs.iterEq(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.same, undefined, true) ? 1 : 0); } else if (pick === 11) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCmp(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true) === 1 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === 1 ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterCmp(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true) === -1 ? 1 : 0); + rs.byteVecPush(out, rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true) === -1 ? 1 : 0); } } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - const order2 = rt.iterCmp(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true); - rt.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); } else { - const order = rt.iterCmp(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true); - rt.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + const order = rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); } } else if (pick === 13) { - rt.byteVecPush(out, _8(rt.iterCmp(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rt.cmp, true))); + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), other, rs.cmp, true))); } else { if (pick === 14) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k)) & 0xff); - const iter: rt.Place = rt.place(() => it, (value3) => it = value3); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }))), k)) & 0xff); + const iter: rs.Place = rs.place(() => it, (value3) => it = value3); while (true) { - const _88: rt.u8 | rt.Done = Overrides.next$iter_Iterator(iter.v); - if (_88 === rt.DONE) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); + if (_88 === rs.DONE) { break b0; } - rt.byteVecPush(out, _88); + rs.byteVecPush(out, _88); } } - put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); - putVec(out, rt.iterToByteVec(rt.iterBox(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rt.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterBox(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), fold: Overrides.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, count: Overrides.count$iter_Iterator, last: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.last$iter_Iterator(it)), find: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.find$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)), findMap: Overrides.findMap$iter_Iterator_u32_boxed_Box_dyn_ops_FnMut_tuple1_u8_Option_u32, forEach: Overrides.forEach$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_unit, reduce: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.reduce$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_u8_u8_u8(it, f)), all: Overrides.all$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple1_u8_bool, isSortedBy: Overrides.isSortedBy$iter_Iterator_boxed_Box_dyn_ops_FnMut_tuple2_ref_u8_ref_u8_bool, back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Overrides.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_u8_Option_u32, rfind: (it: Overrides.Overrides, f) => rs.iterFromOption(Overrides.rfind$iter_DoubleEndedIterator_boxed_Box_dyn_ops_FnMut_tuple1_ref_u8_bool(it, f)) })), "next")); } } } @@ -2831,81 +2831,81 @@ export function collected$boxed_Box_ends_Overrides(it: Overrides.Overrides, pick * comparisons that call its `eq` or `partial_cmp`, or read through its `by_ref`, picked by * `pick`. */ -export function collected$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - const _8: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 255, (o2: rt.Ordering): rt.u8 => { +export function collected$ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { - return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { + const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { + return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; b0: { - const other: rt.Range = new rt.Range(0, k & 0xff); + const other: rs.Range = new rs.Range(0, k & 0xff); if (pick === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(Overrides.collect$iter_Iterator_boxed_Box_slice_u8(it))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(Overrides.collect$iter_Iterator_boxed_Box_slice_u8(it))), undefined, true); } else if (pick === 1) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1)))), undefined, true); } else if (pick === 2) { - const _17: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_17.value)), undefined, true); + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); _17[Symbol.dispose](); } else if (pick === 3) { - const _22: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_22.value)), undefined, true); + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", true, 1))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); _22[Symbol.dispose](); } else if (pick === 4) { const _25: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_25)), true, undefined, undefined, 1, true)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(_25)), true, undefined, undefined, 1, true)), undefined, true); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapFrom(rt.iterToVec(rt.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", 1, true, 1), rt.le, rt.ge, rt.lt))), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.byteVecIntoIter(Overrides.collect$iter_Iterator_Vec_u8(it)), "next", 1, true, 1), rs.le, rs.ge, rs.lt))), undefined, true); } else if (pick === 6) { const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.vecIntoIter(Pairs.collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rt.iterExtendBytes(out, _9(part4), "fold", true); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), "fold", true); } else if (pick === 7) { const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterFrom(_40, Pairs.next$iter_Iterator_ends_Overrides), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part3), "fold", true); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), "fold", true); } else if (pick === 8) { const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterBox(rt.iterFrom(_46, Pairs.next$iter_Iterator_ends_Overrides)), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part2), "fold", true); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), "fold", true); } else if (pick === 9) { - rt.byteVecPush(out, Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); + rs.byteVecPush(out, Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); } else if (pick === 10) { - rt.byteVecPush(out, !Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); + rs.byteVecPush(out, !Overrides.eq$iter_Iterator_ops_Range_u8(it, other) ? 1 : 0); } else if (pick === 11) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === 1 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === 1 ? 1 : 0); } else { - rt.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === -1 ? 1 : 0); + rs.byteVecPush(out, Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other) === -1 ? 1 : 0); } } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { + if (!(rs.usizeRem(k, 2) === 0)) { const order2 = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); - rt.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); } else { const order = Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other); - rt.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); } } else if (pick === 13) { - rt.byteVecPush(out, _8(Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other))); + rs.byteVecPush(out, _8(Overrides.partialCmp$iter_Iterator_ops_Range_u8(it, other))); } else { if (pick === 14) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(Overrides.byRef$iter_Iterator(it), Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); const iter: Overrides.Overrides = Overrides.byRef$iter_Iterator(it); while (true) { - const _88: rt.u8 | rt.Done = Overrides.next$iter_Iterator(iter); - if (_88 === rt.DONE) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter); + if (_88 === rs.DONE) { break b0; } - rt.byteVecPush(out, _88); + rs.byteVecPush(out, _88); } } - put(out, rt.iterToOption(Overrides.next$iter_Iterator(Overrides.byRef$iter_Iterator(it)))); + put(out, rs.iterToOption(Overrides.next$iter_Iterator(Overrides.byRef$iter_Iterator(it)))); putVec(out, Overrides.collect$iter_Iterator_Vec_u8(it)); } } @@ -2917,82 +2917,82 @@ export function collected$ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k * comparisons that call its `eq` or `partial_cmp`, or read through its `by_ref`, picked by * `pick`. */ -export function collected$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - const _8: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 255, (o2: rt.Ordering): rt.u8 => { +export function collected$ends_Run(it: Run.Run, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { - return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { + const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { + return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; b0: { - const other: rt.Range = new rt.Range(0, k & 0xff); + const other: rs.Range = new rs.Range(0, k & 0xff); if (pick === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); } else if (pick === 1) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")))), undefined, true); } else if (pick === 2) { - const _17: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_17.value)), undefined, true); + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); _17[Symbol.dispose](); } else if (pick === 3) { - const _22: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_22.value)), undefined, true); + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); _22[Symbol.dispose](); } else if (pick === 4) { const _25: Run.Run = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterFrom(_25, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), true, undefined, "next", 1)), undefined, true); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapFrom(rt.iterToVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next", 1), rt.le, rt.ge, rt.lt))), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); } else if (pick === 6) { const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.vecIntoIter(Pairs.collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rt.iterExtendBytes(out, _9(part4), undefined, true); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_ends_Run_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), undefined, true); } else if (pick === 7) { const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterFrom(_40, Pairs.next$iter_Iterator_ends_Run), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part3), undefined, true); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_ends_Run), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), undefined, true); } else if (pick === 8) { const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterBox(rt.iterFrom(_46, Pairs.next$iter_Iterator_ends_Run)), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part2), undefined, true); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_ends_Run)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), undefined, true); } else if (pick === 9) { - rt.byteVecPush(out, rt.iterEq(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.same) ? 1 : 0); + rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); } else if (pick === 10) { - rt.byteVecPush(out, !rt.iterEq(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.same) ? 1 : 0); + rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.same) ? 1 : 0); } else if (pick === 11) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCmp(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.cmp) === 1 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === 1 ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterCmp(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.cmp) === -1 ? 1 : 0); + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp) === -1 ? 1 : 0); } } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - const order2 = rt.iterCmp(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.cmp); - rt.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); } else { - const order = rt.iterCmp(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.cmp); - rt.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + const order = rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); } } else if (pick === 13) { - rt.byteVecPush(out, _8(rt.iterCmp(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rt.cmp))); + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), other, rs.cmp))); } else { if (pick === 14) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), k)) & 0xff); const iter: Run.Run = it; while (true) { - const _88: rt.u8 | rt.Done = Run.next$iter_Iterator(iter); - if (_88 === rt.DONE) { + const _88: rs.u8 | rs.Done = Run.next$iter_Iterator(iter); + if (_88 === rs.DONE) { break b0; } - rt.byteVecPush(out, _88); + rs.byteVecPush(out, _88); } } - put(out, rt.iterToOption(Run.next$iter_Iterator(it))); - putVec(out, rt.iterToByteVec(rt.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rt.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); + put(out, rs.iterToOption(Run.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Run.next$iter_Iterator, undefined, { hint: Run.sizeHint$iter_Iterator, back: (it: Run.Run) => rs.iterFromOption(Run.nextBack$iter_DoubleEndedIterator(it)) }), "next")); } } } @@ -3003,82 +3003,82 @@ export function collected$ends_Run(it: Run.Run, pick: rt.u8, k: rt.usize, log: r * comparisons that call its `eq` or `partial_cmp`, or read through its `by_ref`, picked by * `pick`. */ -export function collected$mut_ends_Overrides(it: Overrides.Overrides, pick: rt.u8, k: rt.usize, log: rt.RefCell, out: rt.ByteVec): void { - const _8: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 255, (o2: rt.Ordering): rt.u8 => { +export function collected$mut_ends_Overrides(it: Overrides.Overrides, pick: rs.u8, k: rs.usize, log: rs.RefCell, out: rs.ByteVec): void { + const _8: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 255, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const _9: (a0: rt.BTreeMap) => rt.Iter = (map: rt.BTreeMap): rt.Iter => { - return rt.iterFlatMap(rt.btreeIter(map), (_2: [rt.u8, rt.u8]): Uint8Array => { + const _9: (a0: rs.BTreeMap) => rs.Iter = (map: rs.BTreeMap): rs.Iter => { + return rs.iterFlatMap(rs.btreeIter(map), (_2: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_2[0], _2[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2); }; b0: { - const other: rt.Range = new rt.Range(0, k & 0xff); + const other: rs.Range = new rs.Range(0, k & 0xff); if (pick === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); } else if (pick === 1) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")))), undefined, true); } else if (pick === 2) { - const _17: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_17.value)), undefined, true); + const _17: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_17.value)), undefined, true); _17[Symbol.dispose](); } else if (pick === 3) { - const _22: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(_22.value)), undefined, true); + const _22: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next"))); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(_22.value)), undefined, true); _22[Symbol.dispose](); } else if (pick === 4) { const _25: Overrides.Overrides = it; - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterFrom(_25, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), true, undefined, "next", 1)), undefined, true); } else if (pick === 5) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapFrom(rt.iterToVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next", 1), rt.le, rt.ge, rt.lt))), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapFrom(rs.iterToVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next", 1), rs.le, rs.ge, rs.lt))), undefined, true); } else if (pick === 6) { const _33: Pairs.Pairs = new Pairs.Pairs(it, log); - const part4 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.vecIntoIter(Pairs.collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); - rt.iterExtendBytes(out, _9(part4), undefined, true); + const part4 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.vecIntoIter(Pairs.collect$iter_Iterator_mut_ends_Overrides_Vec_tuple2_u8_u8(_33)), true, undefined, undefined, undefined, 2, true); + rs.iterExtendBytes(out, _9(part4), undefined, true); } else if (pick === 7) { const _40: Pairs.Pairs = new Pairs.Pairs(it, log); - const part3 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterFrom(_40, Pairs.next$iter_Iterator_mut_ends_Overrides), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part3), undefined, true); + const part3 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterFrom(_40, Pairs.next$iter_Iterator_mut_ends_Overrides), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part3), undefined, true); } else if (pick === 8) { const _46: Pairs.Pairs = new Pairs.Pairs(it, log); - const part2 = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterBox(rt.iterFrom(_46, Pairs.next$iter_Iterator_mut_ends_Overrides)), true, undefined, undefined, "next", 2); - rt.iterExtendBytes(out, _9(part2), undefined, true); + const part2 = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterBox(rs.iterFrom(_46, Pairs.next$iter_Iterator_mut_ends_Overrides)), true, undefined, undefined, "next", 2); + rs.iterExtendBytes(out, _9(part2), undefined, true); } else if (pick === 9) { - rt.byteVecPush(out, rt.iterEq(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.same) ? 1 : 0); + rs.byteVecPush(out, rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); } else if (pick === 10) { - rt.byteVecPush(out, !rt.iterEq(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.same) ? 1 : 0); + rs.byteVecPush(out, !rs.iterEq(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.same) ? 1 : 0); } else if (pick === 11) { - if (!(rt.usizeRem(k, 2) === 0)) { - rt.byteVecPush(out, rt.iterCmp(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.cmp) === 1 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === 1 ? 1 : 0); } else { - rt.byteVecPush(out, rt.iterCmp(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.cmp) === -1 ? 1 : 0); + rs.byteVecPush(out, rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp) === -1 ? 1 : 0); } } else if (pick === 12) { - if (!(rt.usizeRem(k, 2) === 0)) { - const order2 = rt.iterCmp(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.cmp); - rt.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); + if (!(rs.usizeRem(k, 2) === 0)) { + const order2 = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); + rs.byteVecPush(out, order2 !== undefined && order2 >= 0 ? 1 : 0); } else { - const order = rt.iterCmp(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.cmp); - rt.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + const order = rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); } } else if (pick === 13) { - rt.byteVecPush(out, _8(rt.iterCmp(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rt.cmp))); + rs.byteVecPush(out, _8(rs.iterCmp(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), other, rs.cmp))); } else { if (pick === 14) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); - const iter: rt.Place = rt.place(() => it, (value3) => it = value3); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), k)) & 0xff); + const iter: rs.Place = rs.place(() => it, (value3) => it = value3); while (true) { - const _88: rt.u8 | rt.Done = Overrides.next$iter_Iterator(iter.v); - if (_88 === rt.DONE) { + const _88: rs.u8 | rs.Done = Overrides.next$iter_Iterator(iter.v); + if (_88 === rs.DONE) { break b0; } - rt.byteVecPush(out, _88); + rs.byteVecPush(out, _88); } } - put(out, rt.iterToOption(Overrides.next$iter_Iterator(it))); - putVec(out, rt.iterToByteVec(rt.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rt.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rt.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")); + put(out, rs.iterToOption(Overrides.next$iter_Iterator(it))); + putVec(out, rs.iterToByteVec(rs.iterFrom(it, Overrides.next$iter_Iterator, undefined, { hint: Overrides.sizeHint$iter_Iterator, nth: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nth$iter_Iterator(it, n)), back: (it: Overrides.Overrides) => rs.iterFromOption(Overrides.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Overrides.Overrides, n) => rs.iterFromOption(Overrides.nthBack$iter_DoubleEndedIterator(it, n)) }), "next")); } } } @@ -3087,26 +3087,26 @@ export function collected$mut_ends_Overrides(it: Overrides.Overrides, pick: rt.u * `fuse` of a `Flicker`, which reads on past its first `None`, or of a `Lapse`, which * doesn't, read by the bits of `bits` from either end. */ -export function fuses(bits: rt.u8, out: rt.ByteVec): void { - let _12!: rt.i32; - const start: rt.u8 = bits >> 4; - const fused: rt.Iter = rt.iterFuse(rt.iterFrom({ _0: start }, Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rt.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }), true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 6; +export function fuses(bits: rs.u8, out: rs.ByteVec): void { + let _12!: rs.i32; + const start: rs.u8 = bits >> 4; + const fused: rs.Iter = rs.iterFuse(rs.iterFrom({ _0: start }, Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rs.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }), true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 6; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(bits, rt.i32Rem(_12, 4)) & 1) === 0) { - put(out, rt.iterToOption(fused.next())); + if ((rs.u8Shr(bits, rs.i32Rem(_12, 4)) & 1) === 0) { + put(out, rs.iterToOption(fused.next())); } else { - put(out, rt.iterToOption(fused.nextBack())); + put(out, rs.iterToOption(fused.nextBack())); } } - const lapsed: rt.Iter = rt.iterFuse(rt.iterFrom({ _0: { _0: start } }, Lapse.next$iter_Iterator)); - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 4; + const lapsed: rs.Iter = rs.iterFuse(rs.iterFrom({ _0: { _0: start } }, Lapse.next$iter_Iterator)); + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 4; while (iterStart2++ < iterEnd2) { - put(out, rt.iterToOption(lapsed.next())); + put(out, rs.iterToOption(lapsed.next())); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterFlatten(rt.iterSlice([{ _0: start }, { _0: rt.u8WrappingAdd(start, 1) }]), (value: Flicker.Flicker) => rt.iterFrom(value, Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rt.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }), true), 5), "next")), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterFlatten(rs.iterSlice([{ _0: start }, { _0: rs.u8WrappingAdd(start, 1) }]), (value: Flicker.Flicker) => rs.iterFrom(value, Flicker.next$iter_Iterator, undefined, { back: (it: Flicker.Flicker) => rs.iterFromOption(Flicker.nextBack$iter_DoubleEndedIterator(it)) }), true), 5), "next")), undefined, true); } //# sourceMappingURL=ends.ts.map diff --git a/ts/fixtures/lang/ends/expected/harness.ts b/ts/fixtures/lang/ends/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/ends/expected/harness.ts +++ b/ts/fixtures/lang/ends/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/ends/expected/lib.ts b/ts/fixtures/lang/ends/expected/lib.ts index 3c58f481a..37606e5ca 100644 --- a/ts/fixtures/lang/ends/expected/lib.ts +++ b/ts/fixtures/lang/ends/expected/lib.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { ends } from "./ends.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["ends::ends", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["ends::ends", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { ends(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/ends/src/ends.rs b/ts/fixtures/lang/ends/src/ends.rs index 5e17be81b..27396d8ff 100644 --- a/ts/fixtures/lang/ends/src/ends.rs +++ b/ts/fixtures/lang/ends/src/ends.rs @@ -667,7 +667,7 @@ fn found + ExactSizeIterator>( put(out, it.find_map(|b| (b > k8 / 2).then_some(b ^ 1))); out.extend(it); } - // Of a found value whose `None` is `rt.None`. + // Of a found value whose `None` is `rs.None`. 7 => { let found = it.find_map(|b| (b >= k8 / 2).then_some((b % 2 == 0).then_some(b))); out.extend(match found { diff --git a/ts/fixtures/lang/errors/expected/alloc/string.ts b/ts/fixtures/lang/errors/expected/alloc/string.ts index b2cfd6bd2..9fc3f0119 100644 --- a/ts/fixtures/lang/errors/expected/alloc/string.ts +++ b/ts/fixtures/lang/errors/expected/alloc/string.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { eq$1v93ipo as str_error_eq$1v93ipo } from "../core/str/error.ts"; +import * as rs from "../rs.ts"; +import { eq$0jlawuy as str_error_eq$0jlawuy } from "../core/str/error.ts"; -export function eq$09knsz6(self: rt.FromUtf8Error, other: rt.FromUtf8Error): boolean { - if (!rt.eqBytes(self.bytes, other.bytes)) { +export function eq$1enuhj8(self: rs.FromUtf8Error, other: rs.FromUtf8Error): boolean { + if (!rs.eqBytes(self.bytes, other.bytes)) { return false; } - return str_error_eq$1v93ipo(self.error, other.error); + return str_error_eq$0jlawuy(self.error, other.error); } //# sourceMappingURL=string.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/bool.ts b/ts/fixtures/lang/errors/expected/core/bool.ts index 5c7547377..62da03799 100644 --- a/ts/fixtures/lang/errors/expected/core/bool.ts +++ b/ts/fixtures/lang/errors/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$0afp4no(self: boolean, f: () => rt.Result): rt.Result | undefined { +export function then$11t2u23(self: boolean, f: () => rs.Result): rs.Result | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/errors/expected/core/char/convert.ts b/ts/fixtures/lang/errors/expected/core/char/convert.ts index 3db60cfdb..73b7bf87e 100644 --- a/ts/fixtures/lang/errors/expected/core/char/convert.ts +++ b/ts/fixtures/lang/errors/expected/core/char/convert.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$09vw48j(self: rt.ParseCharError, other: rt.ParseCharError): boolean { +export function eq$15envri(self: rs.ParseCharError, other: rs.ParseCharError): boolean { return self.kind === other.kind; } diff --git a/ts/fixtures/lang/errors/expected/core/char/methods.ts b/ts/fixtures/lang/errors/expected/core/char/methods.ts index 992b1a141..5b52ab359 100644 --- a/ts/fixtures/lang/errors/expected/core/char/methods.ts +++ b/ts/fixtures/lang/errors/expected/core/char/methods.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefined { - let value!: rt.u32; +export function toDigit$14z95r4(self: rs.char, radix: rs.u32): rs.u32 | undefined { + let value!: rs.u32; if (radix >= 2) { if (radix <= 36) { b1: { if (self > 57) { if (radix > 10) { - value = rt.u32Add((rt.u32WrappingSub(self as rt.u32, 65 as rt.u32) & 4294967263) >>> 0, 10); + value = rs.u32Add((rs.u32WrappingSub(self as rs.u32, 65 as rs.u32) & 4294967263) >>> 0, 10); break b1; } } - value = rt.u32WrappingSub(self as rt.u32, 48 as rt.u32); + value = rs.u32WrappingSub(self as rs.u32, 48 as rs.u32); } if (!(value < radix)) { return undefined; @@ -21,7 +21,7 @@ export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefine return value; } } - rt.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); + rs.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); } //# sourceMappingURL=methods.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/error.Error.ts b/ts/fixtures/lang/errors/expected/core/error.Error.ts index 50334eb4f..aa60671e4 100644 --- a/ts/fixtures/lang/errors/expected/core/error.Error.ts +++ b/ts/fixtures/lang/errors/expected/core/error.Error.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; export type Error = - | { source$Error: () => Error | undefined; fmt$Display: (a0: rt.Formatter) => rt.Result; fmt$Debug: (a0: rt.Formatter) => rt.Result }; + | { source$Error: () => Error | undefined; fmt$Display: (a0: rs.Formatter) => rs.Result; fmt$Debug: (a0: rs.Formatter) => rs.Result }; //# sourceMappingURL=error.Error.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/fmt.ts b/ts/fixtures/lang/errors/expected/core/fmt.ts index 4c44659b3..bd23c2a73 100644 --- a/ts/fixtures/lang/errors/expected/core/fmt.ts +++ b/ts/fixtures/lang/errors/expected/core/fmt.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function eq$08q6k9m(_self: rt.FmtError, _other: rt.FmtError): boolean { +export function eq$1pgfit3(_self: rs.FmtError, _other: rs.FmtError): boolean { return true; } diff --git a/ts/fixtures/lang/errors/expected/core/num.ts b/ts/fixtures/lang/errors/expected/core/num.ts index 1824fd8bb..b0f1424aa 100644 --- a/ts/fixtures/lang/errors/expected/core/num.ts +++ b/ts/fixtures/lang/errors/expected/core/num.ts @@ -1,50 +1,50 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { toDigit$01k9ewn } from "../core/char/methods.ts"; +import * as rs from "../rs.ts"; +import { toDigit$14z95r4 } from "../core/char/methods.ts"; -export function canNotOverflow$0q497dn(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$05izqtt(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(16, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(16, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0aqh4yo(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$0bdyog2(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(1, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(1, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0uown4l(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$14pvtu0(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(4, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(4, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$03q1vv8(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$09fz75c(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(8, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(8, 2), isSignedTy ? 1 : 0); } -export function fromAsciiBytesRadixPanic(radix: rt.u32): never { - doPanic$0sx2e1f(radix); +export function fromAsciiBytesRadixPanic(radix: rs.u32): never { + doPanic$16ya8t2(radix); } -export function doPanic$0sx2e1f(radix: rt.u32): never { - runtime$0bn0geu(radix); +export function doPanic$16ya8t2(radix: rs.u32): never { + runtime$0o4i17s(radix); } -export function runtime$0bn0geu(radix: rt.u32): never { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(radix, f)]; - rt.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$0o4i17s(radix: rs.u32): never { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); } -export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -52,11 +52,11 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128); + const isSignedTy: boolean = rs.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -70,7 +70,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -89,31 +89,31 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i128 = 0; + let result: rs.i128 = 0; b5: { - if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$05izqtt(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i128 = _92 as rt.i128; + const x4: rs.i128 = _92 as rs.i128; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i128 | undefined = rt.i128CheckedSub(result, x4); + const _103: rs.i128 | undefined = rs.i128CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -125,23 +125,23 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i128 = _67 as rt.i128; + const x3: rs.i128 = _67 as rs.i128; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i128 | undefined = rt.i128CheckedAdd(result, x3); + const _78: rs.i128 | undefined = rs.i128CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -154,16 +154,16 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingSub(result, _49 as rt.i128); + result = rs.i128WrappingSub(result, _49 as rs.i128); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -173,30 +173,30 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingAdd(result, _32 as rt.i128); + result = rs.i128WrappingAdd(result, _32 as rs.i128); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1amlmta(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -208,7 +208,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -222,7 +222,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -241,31 +241,31 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i8 = 0; + let result: rs.i8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i8 = (_92 << 24) >> 24; + const x4: rs.i8 = (_92 << 24) >> 24; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i8 | undefined = rt.i8CheckedSub(result, x4); + const _103: rs.i8 | undefined = rs.i8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -277,23 +277,23 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i8 = (_67 << 24) >> 24; + const x3: rs.i8 = (_67 << 24) >> 24; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i8 | undefined = rt.i8CheckedAdd(result, x3); + const _78: rs.i8 | undefined = rs.i8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -306,16 +306,16 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingSub(result, (_49 << 24) >> 24); + result = rs.i8WrappingSub(result, (_49 << 24) >> 24); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -325,46 +325,46 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingAdd(result, (_32 << 24) >> 24); + result = rs.i8WrappingAdd(result, (_32 << 24) >> 24); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromStr$0zyj6he(src: string): rt.Result { - return fromStrRadix$0366bau(src, 10); +export function fromStr$1el0yvy(src: string): rs.Result { + return fromStrRadix$0cysu2u(src, 10); } -export function fromStr$029r9bb(src: string): rt.Result { - return fromStrRadix$0dg9fx3(src, 10); +export function fromStr$1amqoj7(src: string): rs.Result { + return fromStrRadix$0qyezqs(src, 10); } -export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); +export function fromStrRadix$0cysu2u(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1r0rye7(rs.stringAsBytes(src), radix); } -export function fromStrRadix$0dg9fx3(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0k9pjln(rt.stringAsBytes(src), radix); +export function fromStrRadix$0qyezqs(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1amlmta(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$15o252c(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -376,7 +376,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -390,7 +390,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value6 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -409,31 +409,31 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u32 = 0; + let result: rs.u32 = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _84: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _84: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_84 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u32 = _84; + const x4: rs.u32 = _84; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _95: rt.u32 | undefined = rt.u32CheckedSub(result, x4); + const _95: rs.u32 | undefined = rs.u32CheckedSub(result, x4); if (_95 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _95; digitsData = restData5; @@ -445,23 +445,23 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _61: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _61: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_61 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u32 = _61; + const x3: rs.u32 = _61; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _72: rt.u32 | undefined = rt.u32CheckedAdd(result, x3); + const _72: rs.u32 | undefined = rs.u32CheckedAdd(result, x3); if (_72 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _72; digitsData = restData4; @@ -474,16 +474,16 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _46: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _46: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_46 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingSub(result, _46); + result = rs.u32WrappingSub(result, _46); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -493,30 +493,30 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _31: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _31: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_31 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingAdd(result, _31); + result = rs.u32WrappingAdd(result, _31); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0zwqu7x(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -524,11 +524,11 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.u64Gt(0, 0); + const isSignedTy: boolean = rs.u64Gt(0, 0); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -542,7 +542,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -561,31 +561,31 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u64 = 0; + let result: rs.u64 = 0; b5: { - if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$09fz75c(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u64 = _92 as rt.u64; + const x4: rs.u64 = _92 as rs.u64; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u64 | undefined = rt.u64CheckedSub(result, x4); + const _103: rs.u64 | undefined = rs.u64CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -597,23 +597,23 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u64 = _67 as rt.u64; + const x3: rs.u64 = _67 as rs.u64; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u64 | undefined = rt.u64CheckedAdd(result, x3); + const _78: rs.u64 | undefined = rs.u64CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -626,16 +626,16 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingSub(result, _49 as rt.u64); + result = rs.u64WrappingSub(result, _49 as rs.u64); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -645,30 +645,30 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingAdd(result, _32 as rt.u64); + result = rs.u64WrappingAdd(result, _32 as rs.u64); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1djtuzq(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -680,7 +680,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -694,7 +694,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -713,31 +713,31 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u8 = 0; + let result: rs.u8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u8 = _92 & 0xff; + const x4: rs.u8 = _92 & 0xff; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u8 | undefined = rt.u8CheckedSub(result, x4); + const _103: rs.u8 | undefined = rs.u8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -749,23 +749,23 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u8 = _67 & 0xff; + const x3: rs.u8 = _67 & 0xff; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u8 | undefined = rt.u8CheckedAdd(result, x3); + const _78: rs.u8 | undefined = rs.u8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -778,16 +778,16 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingSub(result, _49 & 0xff); + result = rs.u8WrappingSub(result, _49 & 0xff); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -797,43 +797,43 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingAdd(result, _32 & 0xff); + result = rs.u8WrappingAdd(result, _32 & 0xff); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromStr$1ypcnp8(src: string): rt.Result { - return fromStrRadix$1gp4jqq(src, 10); +export function fromStr$0bkyuqf(src: string): rs.Result { + return fromStrRadix$0al5jri(src, 10); } -export function fromStr$1s51v8m(src: string): rt.Result { - return fromStrRadix$1s6gdoj(src, 10); +export function fromStr$1t58fis(src: string): rs.Result { + return fromStrRadix$1osjin2(src, 10); } -export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); +export function fromStrRadix$0al5jri(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0zwqu7x(rs.stringAsBytes(src), radix); } -export function fromStrRadix$1s6gdoj(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$037x42t(rt.stringAsBytes(src), radix); +export function fromStrRadix$1osjin2(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1djtuzq(rs.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/num/error.ts b/ts/fixtures/lang/errors/expected/core/num/error.ts index d369ddbdc..95ddd0e2e 100644 --- a/ts/fixtures/lang/errors/expected/core/num/error.ts +++ b/ts/fixtures/lang/errors/expected/core/num/error.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$1nf2rde(self: rt.TryFromIntError, other: rt.TryFromIntError): boolean { +export function eq$0reiexw(self: rs.TryFromIntError, other: rs.TryFromIntError): boolean { return self.kind === other.kind; } -export function eq$18sin5z(self: rt.ParseIntError, other: rt.ParseIntError): boolean { +export function eq$1uroq6x(self: rs.ParseIntError, other: rs.ParseIntError): boolean { return self.kind === other.kind; } diff --git a/ts/fixtures/lang/errors/expected/core/num/float_parse.ts b/ts/fixtures/lang/errors/expected/core/num/float_parse.ts index ad65346da..7041c9640 100644 --- a/ts/fixtures/lang/errors/expected/core/num/float_parse.ts +++ b/ts/fixtures/lang/errors/expected/core/num/float_parse.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$1horntk(self: rt.ParseFloatError, other: rt.ParseFloatError): boolean { +export function eq$02gt5co(self: rs.ParseFloatError, other: rs.ParseFloatError): boolean { return self.kind === other.kind; } diff --git a/ts/fixtures/lang/errors/expected/core/num/nonzero.ts b/ts/fixtures/lang/errors/expected/core/num/nonzero.ts index 84efe0fe9..66bc66f02 100644 --- a/ts/fixtures/lang/errors/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/errors/expected/core/num/nonzero.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$1xmrosk as num_fromAsciiBytesRadixImpl$1xmrosk } from "../../core/num.ts"; +import * as rs from "../../rs.ts"; +import { fromAsciiBytesRadixImpl$15o252c as num_fromAsciiBytesRadixImpl$15o252c } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$1e6dyne(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1xmrosk(src, radix); +export function fromAsciiBytesRadixImpl$0x21uh8(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$15o252c(src, radix); if (_3.ok) { - const _7: rt.u32 | undefined = rt.nonZero(_3.value); + const _7: rs.u32 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$0pscojv(src: string): rt.Result { - return fromStrRadix$14vzugb(src, 10); +export function fromStr$1qv4pqe(src: string): rs.Result { + return fromStrRadix$1y934te(src, 10); } -export function fromStrRadix$14vzugb(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1e6dyne(rt.stringAsBytes(src), radix); +export function fromStrRadix$1y934te(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0x21uh8(rs.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/option.ts b/ts/fixtures/lang/errors/expected/core/option.ts index 505393c7b..3b97f687d 100644 --- a/ts/fixtures/lang/errors/expected/core/option.ts +++ b/ts/fixtures/lang/errors/expected/core/option.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Error from "../core/error.Error.ts"; import type * as Failure from "../errors.Failure.ts"; -export function map$0frk5o8(self: Error.Error | undefined, f: (a0: Error.Error) => [boolean, rt.IntErrorKind | undefined]): [boolean, rt.IntErrorKind | undefined] | undefined { +export function map$1hw1osb(self: Error.Error | undefined, f: (a0: Error.Error) => [boolean, rs.IntErrorKind | undefined]): [boolean, rs.IntErrorKind | undefined] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$03ygfmn(self: Failure.Failure | undefined, f: (a0: Failure.Failure) => rt.u8): rt.u8 | undefined { +export function map$0jqf1o0(self: Failure.Failure | undefined, f: (a0: Failure.Failure) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0ukfexb(self: rt.ParseIntError | undefined, f: (a0: rt.ParseIntError) => rt.IntErrorKind): rt.IntErrorKind | undefined { +export function map$0p4jgzx(self: rs.ParseIntError | undefined, f: (a0: rs.ParseIntError) => rs.IntErrorKind): rs.IntErrorKind | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/errors/expected/core/result.ts b/ts/fixtures/lang/errors/expected/core/result.ts index 1113d981a..cb538e3b5 100644 --- a/ts/fixtures/lang/errors/expected/core/result.ts +++ b/ts/fixtures/lang/errors/expected/core/result.ts @@ -1,285 +1,285 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { eq$09knsz6 as string_eq$09knsz6 } from "../alloc/string.ts"; -import { eq$09vw48j as convert_eq$09vw48j } from "../core/char/convert.ts"; +import * as rs from "../rs.ts"; +import { eq$1enuhj8 as string_eq$1enuhj8 } from "../alloc/string.ts"; +import { eq$15envri as convert_eq$15envri } from "../core/char/convert.ts"; import type * as Error from "../core/error.Error.ts"; -import { eq$08q6k9m as fmt_eq$08q6k9m } from "../core/fmt.ts"; -import { eq$1nf2rde as num_error_eq$1nf2rde, eq$18sin5z as num_error_eq$18sin5z } from "../core/num/error.ts"; -import { eq$1horntk as float_parse_eq$1horntk } from "../core/num/float_parse.ts"; -import { eq$1v93ipo as str_error_eq$1v93ipo, eq$1f3e51k as str_error_eq$1f3e51k } from "../core/str/error.ts"; -import { eq$0dhyfbb as time_eq$0dhyfbb } from "../core/time.ts"; +import { eq$1pgfit3 as fmt_eq$1pgfit3 } from "../core/fmt.ts"; +import { eq$0reiexw as num_error_eq$0reiexw, eq$1uroq6x as num_error_eq$1uroq6x } from "../core/num/error.ts"; +import { eq$02gt5co as float_parse_eq$02gt5co } from "../core/num/float_parse.ts"; +import { eq$0jlawuy as str_error_eq$0jlawuy, eq$1lr55px as str_error_eq$1lr55px } from "../core/str/error.ts"; +import { eq$14r5ify as time_eq$14r5ify } from "../core/time.ts"; import type * as Failure from "../errors.Failure.ts"; -export function eq$04qb8k3(self: rt.Result, other: rt.Result): boolean { +export function eq$0ypn0py(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u8 | undefined }).value; + return self.value === (other as { ok: true; value: rs.u8 | undefined }).value; } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$10fppe8(self: rt.Result, rt.ParseBoolError>, other: rt.Result, rt.ParseBoolError>): boolean { +export function eq$1amzj8d(self: rs.Result, rs.ParseBoolError>, other: rs.Result, rs.ParseBoolError>): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return eq$04iua4k(self.value, (other as { ok: true; value: rt.Result }).value); + return eq$1w4olsu(self.value, (other as { ok: true; value: rs.Result }).value); } - return str_error_eq$1f3e51k(self.error, (other as { ok: false; error: rt.ParseBoolError }).error); + return str_error_eq$1lr55px(self.error, (other as { ok: false; error: rs.ParseBoolError }).error); } -export function eq$0ecfqx9(self: rt.Result, other: rt.Result): boolean { +export function eq$1357wj0(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return self.value === (other as { ok: true; value: string }).value; } - return string_eq$09knsz6(self.error, (other as { ok: false; error: rt.FromUtf8Error }).error); + return string_eq$1enuhj8(self.error, (other as { ok: false; error: rs.FromUtf8Error }).error); } -export function eq$0nlhjpf(self: rt.Result, other: rt.Result): boolean { +export function eq$0q0qbov(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return self.value === (other as { ok: true; value: boolean }).value; } - return str_error_eq$1f3e51k(self.error, (other as { ok: false; error: rt.ParseBoolError }).error); + return str_error_eq$1lr55px(self.error, (other as { ok: false; error: rs.ParseBoolError }).error); } -export function eq$04iua4k(self: rt.Result, other: rt.Result): boolean { +export function eq$1w4olsu(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.char }).value; + return self.value === (other as { ok: true; value: rs.char }).value; } - return convert_eq$09vw48j(self.error, (other as { ok: false; error: rt.ParseCharError }).error); + return convert_eq$15envri(self.error, (other as { ok: false; error: rs.ParseCharError }).error); } -export function eq$1dhtbkj(self: rt.Result, other: rt.Result): boolean { +export function eq$1nt6phd(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.f64 }).value; + return self.value === (other as { ok: true; value: rs.f64 }).value; } - return float_parse_eq$1horntk(self.error, (other as { ok: false; error: rt.ParseFloatError }).error); + return float_parse_eq$02gt5co(self.error, (other as { ok: false; error: rs.ParseFloatError }).error); } -export function eq$0pe0qmq(self: rt.Result, other: rt.Result): boolean { +export function eq$0y6o605(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.i128Eq(self.value, (other as { ok: true; value: rt.i128 }).value); + return rs.i128Eq(self.value, (other as { ok: true; value: rs.i128 }).value); } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$1mpp8xa(self: rt.Result, other: rt.Result): boolean { +export function eq$1ow2tmy(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.i8 }).value; + return self.value === (other as { ok: true; value: rs.i8 }).value; } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$0grmb7g(self: rt.Result, other: rt.Result): boolean { +export function eq$17fo3dq(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.i8 }).value; + return self.value === (other as { ok: true; value: rs.i8 }).value; } - return num_error_eq$1nf2rde(self.error, (other as { ok: false; error: rt.TryFromIntError }).error); + return num_error_eq$0reiexw(self.error, (other as { ok: false; error: rs.TryFromIntError }).error); } -export function eq$19kc15f(self: rt.Result, other: rt.Result): boolean { +export function eq$0trkzzw(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u32 }).value; + return self.value === (other as { ok: true; value: rs.u32 }).value; } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$0rj0czq(self: rt.Result, other: rt.Result): boolean { +export function eq$1fss0tv(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return self.value === (other as { ok: true; value: string }).value; } - return str_error_eq$1v93ipo(self.error, (other as { ok: false; error: rt.Utf8Error }).error); + return str_error_eq$0jlawuy(self.error, (other as { ok: false; error: rs.Utf8Error }).error); } -export function eq$1hq3neq(self: rt.Result, other: rt.Result): boolean { +export function eq$0rz6big(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.durationEq(self.value, (other as { ok: true; value: rt.Duration }).value); + return rs.durationEq(self.value, (other as { ok: true; value: rs.Duration }).value); } - return time_eq$0dhyfbb(self.error, (other as { ok: false; error: rt.TryFromFloatSecsError }).error); + return time_eq$14r5ify(self.error, (other as { ok: false; error: rs.TryFromFloatSecsError }).error); } -export function eq$08241oi(self: rt.Result, other: rt.Result): boolean { +export function eq$06v73px(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u16 }).value; + return self.value === (other as { ok: true; value: rs.u16 }).value; } return true; } -export function eq$0bl30vt(self: rt.Result, other: rt.Result): boolean { +export function eq$096f56j(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.u64Eq(self.value, (other as { ok: true; value: rt.u64 }).value); + return rs.u64Eq(self.value, (other as { ok: true; value: rs.u64 }).value); } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$1fkhuzl(self: rt.Result, other: rt.Result): boolean { +export function eq$031vf96(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u8 }).value; + return self.value === (other as { ok: true; value: rs.u8 }).value; } - return self.error === (other as { ok: false; error: rt.IntErrorKind }).error; + return self.error === (other as { ok: false; error: rs.IntErrorKind }).error; } -export function eq$0p1bb4y(self: rt.Result, other: rt.Result): boolean { +export function eq$1qyqhny(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u8 }).value; + return self.value === (other as { ok: true; value: rs.u8 }).value; } - return num_error_eq$18sin5z(self.error, (other as { ok: false; error: rt.ParseIntError }).error); + return num_error_eq$1uroq6x(self.error, (other as { ok: false; error: rs.ParseIntError }).error); } -export function eq$0ktbno8(self: rt.Result, other: rt.Result): boolean { +export function eq$0hvarbg(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return true; } - return rt.tryReserveErrorEq(self.error, (other as { ok: false; error: rt.TryReserveError }).error); + return rs.tryReserveErrorEq(self.error, (other as { ok: false; error: rs.TryReserveError }).error); } -export function eq$03gbayb(self: rt.Result, other: rt.Result): boolean { +export function eq$03c8d7v(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { return true; } - return fmt_eq$08q6k9m(self.error, (other as { ok: false; error: rt.FmtError }).error); + return fmt_eq$1pgfit3(self.error, (other as { ok: false; error: rs.FmtError }).error); } -export function err$1ujom0k(self: rt.Result): rt.ParseBoolError | undefined { +export function err$11tr79p(self: rs.Result): rs.ParseBoolError | undefined { if (self.ok) { return undefined; } return self.error; } -export function err$02r96h1(self: rt.Result): rt.ParseCharError | undefined { +export function err$0bvotqj(self: rs.Result): rs.ParseCharError | undefined { if (self.ok) { return undefined; } return self.error; } -export function err$0jf6smd(self: rt.Result): rt.ParseIntError | undefined { +export function err$1tv7qwu(self: rs.Result): rs.ParseIntError | undefined { if (self.ok) { return undefined; } return self.error; } -export function err$0bqdhnn(self: rt.Result): rt.TryReserveError | undefined { +export function err$069ojhs(self: rs.Result): rs.TryReserveError | undefined { if (self.ok) { return undefined; } return self.error; } -export function map$0fm1w6u(self: rt.Result, op: (a0: boolean) => rt.Result): rt.Result, rt.ParseBoolError> { +export function map$1w6ihbb(self: rs.Result, op: (a0: boolean) => rs.Result): rs.Result, rs.ParseBoolError> { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result, rt.ParseBoolError>; + return self as rs.Result, rs.ParseBoolError>; } -export function map$0d23w2b(self: rt.Result, op: (a0: Failure.Failure) => rt.u8): rt.Result { +export function map$18dk705(self: rs.Result, op: (a0: Failure.Failure) => rs.u8): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function map$0r57egs(self: rt.Result, op: (a0: rt.u8) => rt.u8 | undefined): rt.Result { +export function map$07r5pce(self: rs.Result, op: (a0: rs.u8) => rs.u8 | undefined): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function mapErr$1ibyj9t(self: rt.Result>, op: (a0: rt.Result) => rt.Result): rt.Result> { +export function mapErr$1scmdah(self: rs.Result>, op: (a0: rs.Result) => rs.Result): rs.Result> { if (self.ok) { - return self as rt.Result>; + return self as rs.Result>; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function mapErr$0pzoye2(self: rt.Result, op: (a0: Error.Error) => rt.Result): rt.Result> { +export function mapErr$0ka0di9(self: rs.Result, op: (a0: Error.Error) => rs.Result): rs.Result> { if (self.ok) { - return self as rt.Result>; + return self as rs.Result>; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function mapErr$09yhde7(self: rt.Result, op: (a0: Error.Error) => string): rt.Result { +export function mapErr$1a5uolr(self: rs.Result, op: (a0: Error.Error) => string): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function mapErr$1ff8zoy(self: rt.Result, _: (a0: rt.ParseIntError) => Failure.Failure): rt.Result { +export function mapErr$09oysgi(self: rs.Result, _: (a0: rs.ParseIntError) => Failure.Failure): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err({ tag: "Parse", _0: self.error } as Failure.Failure); + return rs.Err({ tag: "Parse", _0: self.error } as Failure.Failure); } -export function mapErr$0u5yxjj(self: rt.Result, op: (a0: rt.ParseIntError) => rt.IntErrorKind): rt.Result { +export function mapErr$1xpyw31(self: rs.Result, op: (a0: rs.ParseIntError) => rs.IntErrorKind): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function clone$1nmm6up(self: rt.Result): rt.Result { +export function clone$0688qis(self: rs.Result): rs.Result { if (self.ok) { - return rt.OK; + return rs.OK; } - return rt.Err(self.error); + return rs.Err(self.error); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/str.ts b/ts/fixtures/lang/errors/expected/core/str.ts index 9624812ec..3c30854da 100644 --- a/ts/fixtures/lang/errors/expected/core/str.ts +++ b/ts/fixtures/lang/errors/expected/core/str.ts @@ -1,32 +1,32 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m } from "../core/num.ts"; -import { fromStr$0pscojv as nonzero_fromStr$0pscojv } from "../core/num/nonzero.ts"; -import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; +import * as rs from "../rs.ts"; +import { fromStr$1el0yvy as num_fromStr$1el0yvy, fromStr$1amqoj7 as num_fromStr$1amqoj7, fromStr$0bkyuqf as num_fromStr$0bkyuqf, fromStr$1t58fis as num_fromStr$1t58fis } from "../core/num.ts"; +import { fromStr$1qv4pqe as nonzero_fromStr$1qv4pqe } from "../core/num/nonzero.ts"; +import { fromStr$1dw9076 as traits_fromStr$1dw9076 } from "../core/str/traits.ts"; -export function parse$0vh4cry(self: string): rt.Result { - return traits_fromStr$05d44vn(self); +export function parse$1yfzdza(self: string): rs.Result { + return traits_fromStr$1dw9076(self); } -export function parse$082ztwj(self: string): rt.Result { - return num_fromStr$0zyj6he(self); +export function parse$1kyj9pm(self: string): rs.Result { + return num_fromStr$1el0yvy(self); } -export function parse$14z7a72(self: string): rt.Result { - return num_fromStr$029r9bb(self); +export function parse$02m1946(self: string): rs.Result { + return num_fromStr$1amqoj7(self); } -export function parse$00ibreq(self: string): rt.Result { - return nonzero_fromStr$0pscojv(self); +export function parse$04z9euf(self: string): rs.Result { + return nonzero_fromStr$1qv4pqe(self); } -export function parse$0o4ono0(self: string): rt.Result { - return num_fromStr$1ypcnp8(self); +export function parse$092epd5(self: string): rs.Result { + return num_fromStr$0bkyuqf(self); } -export function parse$0vh70p5(self: string): rt.Result { - return num_fromStr$1s51v8m(self); +export function parse$1brosjp(self: string): rs.Result { + return num_fromStr$1t58fis(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/str/error.ts b/ts/fixtures/lang/errors/expected/core/str/error.ts index fadadf2b0..41a340e50 100644 --- a/ts/fixtures/lang/errors/expected/core/str/error.ts +++ b/ts/fixtures/lang/errors/expected/core/str/error.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$1v93ipo(self: rt.Utf8Error, other: rt.Utf8Error): boolean { +export function eq$0jlawuy(self: rs.Utf8Error, other: rs.Utf8Error): boolean { if (!(self.validUpTo === other.validUpTo)) { return false; } return self.errorLen === other.errorLen; } -export function eq$1f3e51k(_self: rt.ParseBoolError, _other: rt.ParseBoolError): boolean { +export function eq$1lr55px(_self: rs.ParseBoolError, _other: rs.ParseBoolError): boolean { return true; } diff --git a/ts/fixtures/lang/errors/expected/core/str/traits.ts b/ts/fixtures/lang/errors/expected/core/str/traits.ts index ecae3ef54..bf0ccbaec 100644 --- a/ts/fixtures/lang/errors/expected/core/str/traits.ts +++ b/ts/fixtures/lang/errors/expected/core/str/traits.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function fromStr$05d44vn(s: string): rt.Result { +export function fromStr$1dw9076(s: string): rs.Result { if (!(s === "true")) { if (!(s === "false")) { - return rt.Err(new rt.ParseBoolError()); + return rs.Err(new rs.ParseBoolError()); } - return rt.Ok(false); + return rs.Ok(false); } - return rt.Ok(true); + return rs.Ok(true); } //# sourceMappingURL=traits.ts.map diff --git a/ts/fixtures/lang/errors/expected/core/time.ts b/ts/fixtures/lang/errors/expected/core/time.ts index 880a57409..6634ac2e5 100644 --- a/ts/fixtures/lang/errors/expected/core/time.ts +++ b/ts/fixtures/lang/errors/expected/core/time.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function eq$0dhyfbb(self: rt.TryFromFloatSecsError, other: rt.TryFromFloatSecsError): boolean { +export function eq$14r5ify(self: rs.TryFromFloatSecsError, other: rs.TryFromFloatSecsError): boolean { return self.kind === other.kind; } diff --git a/ts/fixtures/lang/errors/expected/errors.Coded.ts b/ts/fixtures/lang/errors/expected/errors.Coded.ts index c36407a49..039a84bae 100644 --- a/ts/fixtures/lang/errors/expected/errors.Coded.ts +++ b/ts/fixtures/lang/errors/expected/errors.Coded.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Error from "./core/error.Error.ts"; /** The crate's own trait over `Error`, as moq's transports' errors are. */ export type Coded = - | { code$Coded: () => rt.u8; source$Error: () => Error.Error | undefined; fmt$Display: (a0: rt.Formatter) => rt.Result; fmt$Debug: (a0: rt.Formatter) => rt.Result }; + | { code$Coded: () => rs.u8; source$Error: () => Error.Error | undefined; fmt$Display: (a0: rs.Formatter) => rs.Result; fmt$Debug: (a0: rs.Formatter) => rs.Result }; //# sourceMappingURL=errors.Coded.ts.map diff --git a/ts/fixtures/lang/errors/expected/errors.Failure.ts b/ts/fixtures/lang/errors/expected/errors.Failure.ts index 72d696930..a5b9d67ff 100644 --- a/ts/fixtures/lang/errors/expected/errors.Failure.ts +++ b/ts/fixtures/lang/errors/expected/errors.Failure.ts @@ -1,42 +1,42 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$errors_Leaf, of$num_ParseIntError } from "./lib.ts"; import type * as Error from "./core/error.Error.ts"; import * as Leaf from "./errors.Leaf.ts"; -export function fmt$fmt_Debug(self: Failure, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Failure, f: rs.Formatter): rs.Result { if (self.tag === "Short") { const _5: string = "Short"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Wrapped") { const _9: string = "Wrapped"; - const _10: rt.Fmt = (f: rt.Formatter) => Leaf.fmt$fmt_Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _9), _10)); + const _10: rs.Fmt = (f: rs.Formatter) => Leaf.fmt$fmt_Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _9), _10)); } const _13: string = "Parse"; - const _14: rt.Fmt = (f: rt.Formatter) => rt.fmtParseIntErrorDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _13), _14)); + const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtParseIntErrorDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _13), _14)); } /** An error whose source is the crate's, std's, or none. */ export type Failure = - | { tag: "Short"; _0: rt.u8 } + | { tag: "Short"; _0: rs.u8 } | { tag: "Wrapped"; _0: Leaf.Leaf } - | { tag: "Parse"; _0: rt.ParseIntError }; + | { tag: "Parse"; _0: rs.ParseIntError }; -export function fmt$fmt_Display(self: Failure, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Failure, f: rs.Formatter): rs.Result { if (self.tag === "Short") { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - return rt.fmtWriteFmt(f, ["short by ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + return rs.fmtWriteFmt(f, ["short by ", args2[0]]); } if (self.tag === "Wrapped") { - return rt.fmtWriteStr(f, "wrapped"); + return rs.fmtWriteStr(f, "wrapped"); } - return rt.fmtWriteStr(f, "unparsed"); + return rs.fmtWriteStr(f, "unparsed"); } export function source$Error(self: Failure): Error.Error | undefined { @@ -49,7 +49,7 @@ export function source$Error(self: Failure): Error.Error | undefined { return new of$num_ParseIntError(self._0); } -export function code$errors_Coded(self: Failure): rt.u8 { +export function code$errors_Coded(self: Failure): rs.u8 { if (self.tag === "Short") { return self._0; } diff --git a/ts/fixtures/lang/errors/expected/errors.Leaf.ts b/ts/fixtures/lang/errors/expected/errors.Leaf.ts index 11dbd3866..adc7a56e9 100644 --- a/ts/fixtures/lang/errors/expected/errors.Leaf.ts +++ b/ts/fixtures/lang/errors/expected/errors.Leaf.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { DROPPED } from "./errors.ts"; -import { set$0st49po, get$1ei2eoj } from "./std/thread/local.ts"; +import { set$1ljkjlf, get$0q7640n } from "./std/thread/local.ts"; -export function fmt$fmt_Debug(self: Leaf, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Leaf, f: rs.Formatter): rs.Result { const _3: string = "Leaf"; const _4: string = "code"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.code, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5)); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.code, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); } /** The crate's error without a source of its own, which counts its drops. */ export class Leaf { - code: rt.u8; + code: rs.u8; - constructor(code: rt.u8) { + constructor(code: rs.u8) { this.code = code; } @@ -24,14 +24,14 @@ export class Leaf { } } -export function fmt$fmt_Display(self: Leaf, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Leaf, f: rs.Formatter): rs.Result { const arg = self.code; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - return rt.fmtWriteFmt(f, ["leaf ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + return rs.fmtWriteFmt(f, ["leaf ", args2[0]]); } export function drop$ops_Drop(self: Leaf): void { - set$0st49po(DROPPED, rt.u32WrappingAdd(rt.u32WrappingMul(get$1ei2eoj(DROPPED), 10), rt.u8Rem(self.code, 10) as rt.u32)); + set$1ljkjlf(DROPPED, rs.u32WrappingAdd(rs.u32WrappingMul(get$0q7640n(DROPPED), 10), rs.u8Rem(self.code, 10) as rs.u32)); } //# sourceMappingURL=errors.Leaf.ts.map diff --git a/ts/fixtures/lang/errors/expected/errors.Transported.ts b/ts/fixtures/lang/errors/expected/errors.Transported.ts index 081db29f2..97a28ebe0 100644 --- a/ts/fixtures/lang/errors/expected/errors.Transported.ts +++ b/ts/fixtures/lang/errors/expected/errors.Transported.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Error from "./core/error.Error.ts"; import type * as Coded from "./errors.Coded.ts"; -export function fmt$fmt_Debug(self: Transported, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Transported, f: rs.Formatter): rs.Result { const _3: string = "Transported"; - const _4: rt.Fmt = (f: rt.Formatter) => self._0.fmt$Debug(f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => self._0.fmt$Debug(f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } /** A boxed `Coded`, forwarding `Error` to it, as moq's boxed transport error does. */ @@ -19,11 +19,11 @@ export class Transported { } [Symbol.dispose](): void { - rt.drop(this._0); + rs.drop(this._0); } } -export function fmt$fmt_Display(self: Transported, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Transported, f: rs.Formatter): rs.Result { return self._0.fmt$Display(f); } diff --git a/ts/fixtures/lang/errors/expected/errors.ts b/ts/fixtures/lang/errors/expected/errors.ts index c4f4020e8..85aa909bf 100644 --- a/ts/fixtures/lang/errors/expected/errors.ts +++ b/ts/fixtures/lang/errors/expected/errors.ts @@ -1,468 +1,468 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send, drop$errors_Failure, of$boxed_Box_errors_Failure, of$collections_TryReserveError, of$errors_Failure, of$errors_Leaf, of$errors_Transported, of$num_ParseIntError, of$ref_errors_Failure, of$ref_errors_Leaf, ofPlace$collections_TryReserveError, ofPlace$errors_Failure, ofPlace$num_ParseIntError } from "./lib.ts"; -import { then$0afp4no } from "./core/bool.ts"; -import { eq$09vw48j as convert_eq$09vw48j } from "./core/char/convert.ts"; +import { then$11t2u23 } from "./core/bool.ts"; +import { eq$15envri as convert_eq$15envri } from "./core/char/convert.ts"; import type * as Error from "./core/error.Error.ts"; -import { fromStr$1s51v8m as num_fromStr$1s51v8m } from "./core/num.ts"; -import { eq$18sin5z as num_error_eq$18sin5z } from "./core/num/error.ts"; -import { map$0frk5o8 as option_map$0frk5o8, map$03ygfmn as option_map$03ygfmn, map$0ukfexb as option_map$0ukfexb } from "./core/option.ts"; -import { eq$04qb8k3 as result_eq$04qb8k3, eq$10fppe8 as result_eq$10fppe8, eq$0ecfqx9 as result_eq$0ecfqx9, eq$0nlhjpf as result_eq$0nlhjpf, eq$04iua4k as result_eq$04iua4k, eq$1dhtbkj as result_eq$1dhtbkj, eq$0pe0qmq as result_eq$0pe0qmq, eq$1mpp8xa as result_eq$1mpp8xa, eq$0grmb7g as result_eq$0grmb7g, eq$19kc15f as result_eq$19kc15f, eq$0rj0czq as result_eq$0rj0czq, eq$1hq3neq as result_eq$1hq3neq, eq$08241oi as result_eq$08241oi, eq$0bl30vt as result_eq$0bl30vt, eq$1fkhuzl as result_eq$1fkhuzl, eq$0p1bb4y as result_eq$0p1bb4y, eq$0ktbno8 as result_eq$0ktbno8, eq$03gbayb as result_eq$03gbayb, err$1ujom0k, err$02r96h1, err$0jf6smd, err$0bqdhnn, map$0fm1w6u as result_map$0fm1w6u, map$0d23w2b as result_map$0d23w2b, map$0r57egs as result_map$0r57egs, mapErr$1ibyj9t as result_mapErr$1ibyj9t, mapErr$0pzoye2 as result_mapErr$0pzoye2, mapErr$09yhde7 as result_mapErr$09yhde7, mapErr$1ff8zoy as result_mapErr$1ff8zoy, mapErr$0u5yxjj as result_mapErr$0u5yxjj, clone$1nmm6up as result_clone$1nmm6up } from "./core/result.ts"; -import { parse$0vh4cry, parse$082ztwj, parse$14z7a72, parse$00ibreq, parse$0o4ono0, parse$0vh70p5 } from "./core/str.ts"; -import { eq$1f3e51k as str_error_eq$1f3e51k } from "./core/str/error.ts"; +import { fromStr$1t58fis as num_fromStr$1t58fis } from "./core/num.ts"; +import { eq$1uroq6x as num_error_eq$1uroq6x } from "./core/num/error.ts"; +import { map$1hw1osb as option_map$1hw1osb, map$0jqf1o0 as option_map$0jqf1o0, map$0p4jgzx as option_map$0p4jgzx } from "./core/option.ts"; +import { eq$0ypn0py as result_eq$0ypn0py, eq$1amzj8d as result_eq$1amzj8d, eq$1357wj0 as result_eq$1357wj0, eq$0q0qbov as result_eq$0q0qbov, eq$1w4olsu as result_eq$1w4olsu, eq$1nt6phd as result_eq$1nt6phd, eq$0y6o605 as result_eq$0y6o605, eq$1ow2tmy as result_eq$1ow2tmy, eq$17fo3dq as result_eq$17fo3dq, eq$0trkzzw as result_eq$0trkzzw, eq$1fss0tv as result_eq$1fss0tv, eq$0rz6big as result_eq$0rz6big, eq$06v73px as result_eq$06v73px, eq$096f56j as result_eq$096f56j, eq$031vf96 as result_eq$031vf96, eq$1qyqhny as result_eq$1qyqhny, eq$0hvarbg as result_eq$0hvarbg, eq$03c8d7v as result_eq$03c8d7v, err$11tr79p, err$0bvotqj, err$1tv7qwu, err$069ojhs, map$1w6ihbb as result_map$1w6ihbb, map$18dk705 as result_map$18dk705, map$07r5pce as result_map$07r5pce, mapErr$1scmdah as result_mapErr$1scmdah, mapErr$0ka0di9 as result_mapErr$0ka0di9, mapErr$1a5uolr as result_mapErr$1a5uolr, mapErr$09oysgi as result_mapErr$09oysgi, mapErr$1xpyw31 as result_mapErr$1xpyw31, clone$0688qis as result_clone$0688qis } from "./core/result.ts"; +import { parse$1yfzdza, parse$1kyj9pm, parse$02m1946, parse$04z9euf, parse$092epd5, parse$1brosjp } from "./core/str.ts"; +import { eq$1lr55px as str_error_eq$1lr55px } from "./core/str/error.ts"; import type * as Coded from "./errors.Coded.ts"; import * as Failure from "./errors.Failure.ts"; import * as Leaf from "./errors.Leaf.ts"; import * as Transported from "./errors.Transported.ts"; import { put } from "./harness.ts"; -import { set$0st49po, get$1ei2eoj } from "./std/thread/local.ts"; +import { set$1ljkjlf, get$0q7640n } from "./std/thread/local.ts"; /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Option_Result_u8_num_ParseIntError(values: Array | undefined>, out: rt.ByteVec): void { +export function pairs$Option_Result_u8_num_ParseIntError(values: Array | undefined>, out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: Array | undefined> = values; + const iterS2: Array | undefined> = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | undefined | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | undefined | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result | undefined = _11; - rt.byteVecPush(out, (rt.eqOption(result_eq$0p1bb4y)(a, b) ? 1 : 0) | (((!rt.eqOption(result_eq$0p1bb4y)(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result | undefined = _11; + rs.byteVecPush(out, (rs.eqOption(result_eq$1qyqhny)(a, b) ? 1 : 0) | (((!rs.eqOption(result_eq$1qyqhny)(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_Option_u8_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_Option_u8_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$04qb8k3(a, b) ? 1 : 0) | (((!result_eq$04qb8k3(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0ypn0py(a, b) ? 1 : 0) | (((!result_eq$0ypn0py(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError(values: rt.Result, rt.ParseBoolError>[], out: rt.ByteVec): void { +export function pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError(values: rs.Result, rs.ParseBoolError>[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result, rt.ParseBoolError>[] = values; + const iterS2: rs.Result, rs.ParseBoolError>[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result, rt.ParseBoolError> | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result, rs.ParseBoolError> | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result, rt.ParseBoolError> = _11; - rt.byteVecPush(out, (result_eq$10fppe8(a, b) ? 1 : 0) | (((!result_eq$10fppe8(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result, rs.ParseBoolError> = _11; + rs.byteVecPush(out, (result_eq$1amzj8d(a, b) ? 1 : 0) | (((!result_eq$1amzj8d(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_String_string_FromUtf8Error(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_String_string_FromUtf8Error(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0ecfqx9(a, b) ? 1 : 0) | (((!result_eq$0ecfqx9(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1357wj0(a, b) ? 1 : 0) | (((!result_eq$1357wj0(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_bool_str_ParseBoolError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_bool_str_ParseBoolError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0nlhjpf(a, b) ? 1 : 0) | (((!result_eq$0nlhjpf(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0q0qbov(a, b) ? 1 : 0) | (((!result_eq$0q0qbov(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_char_char_ParseCharError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_char_char_ParseCharError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$04iua4k(a, b) ? 1 : 0) | (((!result_eq$04iua4k(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1w4olsu(a, b) ? 1 : 0) | (((!result_eq$1w4olsu(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_f64_num_ParseFloatError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_f64_num_ParseFloatError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$1dhtbkj(a, b) ? 1 : 0) | (((!result_eq$1dhtbkj(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1nt6phd(a, b) ? 1 : 0) | (((!result_eq$1nt6phd(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_i128_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_i128_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0pe0qmq(a, b) ? 1 : 0) | (((!result_eq$0pe0qmq(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0y6o605(a, b) ? 1 : 0) | (((!result_eq$0y6o605(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_i8_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_i8_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$1mpp8xa(a, b) ? 1 : 0) | (((!result_eq$1mpp8xa(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1ow2tmy(a, b) ? 1 : 0) | (((!result_eq$1ow2tmy(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_i8_num_TryFromIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_i8_num_TryFromIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0grmb7g(a, b) ? 1 : 0) | (((!result_eq$0grmb7g(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$17fo3dq(a, b) ? 1 : 0) | (((!result_eq$17fo3dq(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_num_NonZero_u32_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_num_NonZero_u32_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$19kc15f(a, b) ? 1 : 0) | (((!result_eq$19kc15f(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0trkzzw(a, b) ? 1 : 0) | (((!result_eq$0trkzzw(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_ref_str_str_Utf8Error(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_ref_str_str_Utf8Error(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0rj0czq(a, b) ? 1 : 0) | (((!result_eq$0rj0czq(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1fss0tv(a, b) ? 1 : 0) | (((!result_eq$1fss0tv(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_time_Duration_time_TryFromFloatSecsError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_time_Duration_time_TryFromFloatSecsError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$1hq3neq(a, b) ? 1 : 0) | (((!result_eq$1hq3neq(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0rz6big(a, b) ? 1 : 0) | (((!result_eq$0rz6big(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_u16_never(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_u16_never(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$08241oi(a, b) ? 1 : 0) | (((!result_eq$08241oi(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$06v73px(a, b) ? 1 : 0) | (((!result_eq$06v73px(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_u64_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_u64_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0bl30vt(a, b) ? 1 : 0) | (((!result_eq$0bl30vt(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$096f56j(a, b) ? 1 : 0) | (((!result_eq$096f56j(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_u8_num_IntErrorKind(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_u8_num_IntErrorKind(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$1fkhuzl(a, b) ? 1 : 0) | (((!result_eq$1fkhuzl(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$031vf96(a, b) ? 1 : 0) | (((!result_eq$031vf96(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_u8_num_ParseIntError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_u8_num_ParseIntError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0p1bb4y(a, b) ? 1 : 0) | (((!result_eq$0p1bb4y(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$1qyqhny(a, b) ? 1 : 0) | (((!result_eq$1qyqhny(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_unit_collections_TryReserveError(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_unit_collections_TryReserveError(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$0ktbno8(a, b) ? 1 : 0) | (((!result_eq$0ktbno8(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$0hvarbg(a, b) ? 1 : 0) | (((!result_eq$0hvarbg(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Result_unit_fmt_Error(values: rt.Result[], out: rt.ByteVec): void { +export function pairs$Result_unit_fmt_Error(values: rs.Result[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Result[] = values; + const iterS2: rs.Result[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Result | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Result | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Result = _11; - rt.byteVecPush(out, (result_eq$03gbayb(a, b) ? 1 : 0) | (((!result_eq$03gbayb(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Result = _11; + rs.byteVecPush(out, (result_eq$03c8d7v(a, b) ? 1 : 0) | (((!result_eq$03c8d7v(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$Vec_Result_bool_str_ParseBoolError(values: rt.Vec>[], out: rt.ByteVec): void { +export function pairs$Vec_Result_bool_str_ParseBoolError(values: rs.Vec>[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.Vec>[] = values; + const iterS2: rs.Vec>[] = values; let iterI2: number = 0; while (true) { - const _11: rt.Vec> | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.Vec> | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.Vec> = _11; - rt.byteVecPush(out, (rt.eqSlice(result_eq$0nlhjpf)(a, b) ? 1 : 0) | (((!rt.eqSlice(result_eq$0nlhjpf)(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.Vec> = _11; + rs.byteVecPush(out, (rs.eqSlice(result_eq$0q0qbov)(a, b) ? 1 : 0) | (((!rs.eqSlice(result_eq$0q0qbov)(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$char_ParseCharError(values: rt.ParseCharError[], out: rt.ByteVec): void { +export function pairs$char_ParseCharError(values: rs.ParseCharError[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.ParseCharError[] = values; + const iterS2: rs.ParseCharError[] = values; let iterI2: number = 0; while (true) { - const _11: rt.ParseCharError | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.ParseCharError | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.ParseCharError = _11; - rt.byteVecPush(out, (convert_eq$09vw48j(a, b) ? 1 : 0) | (((!convert_eq$09vw48j(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.ParseCharError = _11; + rs.byteVecPush(out, (convert_eq$15envri(a, b) ? 1 : 0) | (((!convert_eq$15envri(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$collections_TryReserveError(values: rt.TryReserveError[], out: rt.ByteVec): void { +export function pairs$collections_TryReserveError(values: rs.TryReserveError[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.TryReserveError[] = values; + const iterS2: rs.TryReserveError[] = values; let iterI2: number = 0; while (true) { - const _11: rt.TryReserveError | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.TryReserveError | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.TryReserveError = _11; - rt.byteVecPush(out, (rt.tryReserveErrorEq(a, b) ? 1 : 0) | (((!rt.tryReserveErrorEq(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.TryReserveError = _11; + rs.byteVecPush(out, (rs.tryReserveErrorEq(a, b) ? 1 : 0) | (((!rs.tryReserveErrorEq(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$num_ParseIntError(values: rt.ParseIntError[], out: rt.ByteVec): void { +export function pairs$num_ParseIntError(values: rs.ParseIntError[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.ParseIntError[] = values; + const iterS2: rs.ParseIntError[] = values; let iterI2: number = 0; while (true) { - const _11: rt.ParseIntError | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.ParseIntError | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.ParseIntError = _11; - rt.byteVecPush(out, (num_error_eq$18sin5z(a, b) ? 1 : 0) | (((!num_error_eq$18sin5z(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.ParseIntError = _11; + rs.byteVecPush(out, (num_error_eq$1uroq6x(a, b) ? 1 : 0) | (((!num_error_eq$1uroq6x(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$str_ParseBoolError(values: rt.ParseBoolError[], out: rt.ByteVec): void { +export function pairs$str_ParseBoolError(values: rs.ParseBoolError[], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: rt.ParseBoolError[] = values; + const iterS2: rs.ParseBoolError[] = values; let iterI2: number = 0; while (true) { - const _11: rt.ParseBoolError | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: rs.ParseBoolError | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: rt.ParseBoolError = _11; - rt.byteVecPush(out, (str_error_eq$1f3e51k(a, b) ? 1 : 0) | (((!str_error_eq$1f3e51k(a, b) ? 1 : 0) << 1) & 0xff)); + const b: rs.ParseBoolError = _11; + rs.byteVecPush(out, (str_error_eq$1lr55px(a, b) ? 1 : 0) | (((!str_error_eq$1lr55px(a, b) ? 1 : 0) << 1) & 0xff)); } } } /** Each pair's `==` and `!=`, a bit each. */ -export function pairs$tuple2_Result_char_char_ParseCharError_usize(values: [rt.Result, rt.usize][], out: rt.ByteVec): void { +export function pairs$tuple2_Result_char_char_ParseCharError_usize(values: [rs.Result, rs.usize][], out: rs.ByteVec): void { l1: for (const a of values) { - const iterS2: [rt.Result, rt.usize][] = values; + const iterS2: [rs.Result, rs.usize][] = values; let iterI2: number = 0; while (true) { - const _11: [rt.Result, rt.usize] | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_11 === rt.DONE) { + const _11: [rs.Result, rs.usize] | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_11 === rs.DONE) { continue l1; } - const b: [rt.Result, rt.usize] = _11; - rt.byteVecPush(out, (rt.eqTuple([result_eq$04iua4k, rt.same])(a, b) ? 1 : 0) | (((!rt.eqTuple([result_eq$04iua4k, rt.same])(a, b) ? 1 : 0) << 1) & 0xff)); + const b: [rs.Result, rs.usize] = _11; + rs.byteVecPush(out, (rs.eqTuple([result_eq$1w4olsu, rs.same])(a, b) ? 1 : 0) | (((!rs.eqTuple([result_eq$1w4olsu, rs.same])(a, b) ? 1 : 0) << 1) & 0xff)); } } } -export function parsed$bool(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0vh4cry(s); +export function parsed$bool(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$1yfzdza(s); }), undefined, 1, true); } -export function parsed$char(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return rt.charFromStr(s); +export function parsed$char(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return rs.charFromStr(s); }), undefined, 8, true); } -export function parsed$f64(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return rt.f64FromStr(s); +export function parsed$f64(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return rs.f64FromStr(s); }), undefined, 16, true); } -export function parsed$i128(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$082ztwj(s); +export function parsed$i128(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$1kyj9pm(s); }), undefined, 32, true); } -export function parsed$i8(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$14z7a72(s); +export function parsed$i8(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$02m1946(s); }), undefined, 2, true); } -export function parsed$num_NonZero_u32(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$00ibreq(s); +export function parsed$num_NonZero_u32(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$04z9euf(s); }), undefined, 8, true); } -export function parsed$u64(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0o4ono0(s); +export function parsed$u64(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$092epd5(s); }), undefined, 16, true); } -export function parsed$u8(all: string[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterSlice(all), (s: string): rt.Result => { - return parse$0vh70p5(s); +export function parsed$u8(all: string[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterSlice(all), (s: string): rs.Result => { + return parse$1brosjp(s); }), undefined, 2, true); } @@ -470,19 +470,19 @@ export function parsed$u8(all: string[]): rt.Vec = rt.vecFrom(["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice()); + const all: rs.Vec = rs.vecFrom(["", "0", "-0", "1", "-1", "+", "a", "ab", "😀", "true", "false", "127", "128", "-128", "-129", "256", "18446744073709551615", "18446744073709551616", "-170141183460469231731687303715884105729", "1.5", "1e400", "NaN", "inf"].slice()); all.items.push(input); - const bytes: rt.Vec = rt.vecFrom([rt.byteSliceFrom(Uint8Array.of()), rt.byteSliceFrom(Uint8Array.of(97)), rt.byteSliceFrom(Uint8Array.of(255)), rt.byteSliceFrom(Uint8Array.of(97, 255)), rt.byteSliceFrom(Uint8Array.of(195)), rt.byteSliceFrom(Uint8Array.of(97, 195)), rt.byteSliceFrom(Uint8Array.of(224, 128)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152)), rt.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rt.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice()); + const bytes: rs.Vec = rs.vecFrom([rs.byteSliceFrom(Uint8Array.of()), rs.byteSliceFrom(Uint8Array.of(97)), rs.byteSliceFrom(Uint8Array.of(255)), rs.byteSliceFrom(Uint8Array.of(97, 255)), rs.byteSliceFrom(Uint8Array.of(195)), rs.byteSliceFrom(Uint8Array.of(97, 195)), rs.byteSliceFrom(Uint8Array.of(224, 128)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152)), rs.byteSliceFrom(Uint8Array.of(240, 159, 152, 128)), rs.byteSliceFrom(Uint8Array.of(237, 160, 128))].slice()); bytes.items.push(data); - const _32: rt.u8 = rt.u8Rem(kind, 16); + const _32: rs.u8 = rs.u8Rem(kind, 16); if (_32 === 0) { pairs$Result_bool_str_ParseBoolError(parsed$bool(all.items).items, out); } else if (_32 === 1) { @@ -500,113 +500,113 @@ export function eqs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_32 === 7) { pairs$Result_f64_num_ParseFloatError(parsed$f64(all.items).items, out); } else if (_32 === 8) { - const ints: rt.Vec = rt.vecFrom([0, 127, 128, -128, -129, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, { hi: -0x80000000, lo: 0 } as rt.i64]); - const _78: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.i64 => { - return rt.i64Mul((_218 << 24) >> 24 as rt.i64, 2); + const ints: rs.Vec = rs.vecFrom([0, 127, 128, -128, -129, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64, { hi: -0x80000000, lo: 0 } as rs.i64]); + const _78: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.i64 => { + return rs.i64Mul((_218 << 24) >> 24 as rs.i64, 2); }); - rt.iterExtend(ints, _78, undefined, 8, true); - pairs$Result_i8_num_TryFromIntError(rt.iterToVec(rt.iterMap(rt.vecIntoIter(ints), (a02: rt.i64): rt.Result => { - return rt.i8TryFrom(a02); + rs.iterExtend(ints, _78, undefined, 8, true); + pairs$Result_i8_num_TryFromIntError(rs.iterToVec(rs.iterMap(rs.vecIntoIter(ints), (a02: rs.i64): rs.Result => { + return rs.i8TryFrom(a02); }), undefined, 2, true).items, out); } else if (_32 === 9) { - pairs$Result_ref_str_str_Utf8Error(rt.iterToVec(rt.iterMap(rt.iterSlice(bytes.items), (b7: rt.ByteSlice): rt.Result => { - return rt.strFromUtf8(b7); + pairs$Result_ref_str_str_Utf8Error(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b7: rs.ByteSlice): rs.Result => { + return rs.strFromUtf8(b7); }), undefined, 12, true).items, out); } else if (_32 === 10) { - pairs$Result_String_string_FromUtf8Error(rt.iterToVec(rt.iterMap(rt.iterSlice(bytes.items), (b6: rt.ByteSlice): rt.Result => { - return rt.stringFromUtf8(rt.byteSliceToByteVec(b6)); + pairs$Result_String_string_FromUtf8Error(rs.iterToVec(rs.iterMap(rs.iterSlice(bytes.items), (b6: rs.ByteSlice): rs.Result => { + return rs.stringFromUtf8(rs.byteSliceToByteVec(b6)); }), undefined, 20, true).items, out); } else if (_32 === 11) { - const secs: rt.Vec = rt.vecFrom([0.0, -0.0, 1.5, -1.0, NaN, Infinity, -Infinity, 1e30]); - const _105: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): rt.f64 => { - return ((_211 << 24) >> 24 as rt.f64) / 4.0; + const secs: rs.Vec = rs.vecFrom([0.0, -0.0, 1.5, -1.0, NaN, Infinity, -Infinity, 1e30]); + const _105: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): rs.f64 => { + return ((_211 << 24) >> 24 as rs.f64) / 4.0; }); - rt.iterExtend(secs, _105, undefined, 8, true); - pairs$Result_time_Duration_time_TryFromFloatSecsError(rt.iterToVec(rt.iterMap(rt.vecIntoIter(secs), (a0: rt.f64): rt.Result => { - return rt.durationTryFromSecsF64(a0); + rs.iterExtend(secs, _105, undefined, 8, true); + pairs$Result_time_Duration_time_TryFromFloatSecsError(rs.iterToVec(rs.iterMap(rs.vecIntoIter(secs), (a0: rs.f64): rs.Result => { + return rs.durationTryFromSecsF64(a0); }), undefined, 16, true).items, out); } else if (_32 === 12) { - pairs$Result_Option_u8_num_ParseIntError(rt.iterToVec(rt.iterMap(rt.iterSlice(all.items), (s6: string): rt.Result => { - return result_map$0r57egs(parse$0vh70p5(s6), (v11: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(v11, 1); + pairs$Result_Option_u8_num_ParseIntError(rs.iterToVec(rs.iterMap(rs.iterSlice(all.items), (s6: string): rs.Result => { + return result_map$07r5pce(parse$1brosjp(s6), (v11: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(v11, 1); }); }), undefined, 2, true).items, out); - pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError(rt.iterToVec(rt.iterMap(rt.iterSlice(all.items), (s7: string): rt.Result, rt.ParseBoolError> => { + pairs$Result_Result_char_char_ParseCharError_str_ParseBoolError(rs.iterToVec(rs.iterMap(rs.iterSlice(all.items), (s7: string): rs.Result, rs.ParseBoolError> => { const _610: string = s7; - return result_map$0fm1w6u(parse$0vh4cry(s7), (_210: boolean): rt.Result => { - return rt.charFromStr(_610); + return result_map$1w6ihbb(parse$1yfzdza(s7), (_210: boolean): rs.Result => { + return rs.charFromStr(_610); }); }), undefined, 8, true).items, out); - pairs$Result_u8_num_IntErrorKind(rt.iterToVec(rt.iterMap(rt.iterSlice(all.items), (s8: string): rt.Result => { - return result_mapErr$0u5yxjj(parse$0vh70p5(s8), (e: rt.ParseIntError): rt.IntErrorKind => { + pairs$Result_u8_num_IntErrorKind(rs.iterToVec(rs.iterMap(rs.iterSlice(all.items), (s8: string): rs.Result => { + return result_mapErr$1xpyw31(parse$1brosjp(s8), (e: rs.ParseIntError): rs.IntErrorKind => { return e.kind; }); }), undefined, 2, true).items, out); } else if (_32 === 13) { - pairs$Result_u16_never(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.Result => { - return rt.Ok(_22 as rt.u16); + pairs$Result_u16_never(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.Result => { + return rs.Ok(_22 as rs.u16); }), undefined, 2, true).items, out); - pairs$Result_unit_fmt_Error(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.Result => { - if (!(rt.u8Rem(_25, 2) === 0)) { - return rt.Err(new rt.FmtError()); + pairs$Result_unit_fmt_Error(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.Result => { + if (!(rs.u8Rem(_25, 2) === 0)) { + return rs.Err(new rs.FmtError()); } - return rt.OK; + return rs.OK; }), undefined, 1, true).items, out); } else if (_32 === 14) { - const v7: rt.Vec> = rt.iterToVec(rt.iterFlatMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6), (_2: rt.u8): rt.Result[] => { - let n!: rt.usize; - const b2: rt.u8 = _2; - if (!(rt.u8Rem(b2, 2) === 0)) { - n = rt.usizeSub(4294967295, b2 as rt.usize); + const v7: rs.Vec> = rs.iterToVec(rs.iterFlatMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6), (_2: rs.u8): rs.Result[] => { + let n!: rs.usize; + const b2: rs.u8 = _2; + if (!(rs.u8Rem(b2, 2) === 0)) { + n = rs.usizeSub(4294967295, b2 as rs.usize); } else { - n = b2 as rt.usize; + n = b2 as rs.usize; } - const text: string = rt.strSlice("ab", 0, rt.u8Rem(b2, 3) as rt.usize); - return [rt.byteVecTryReserve(new rt.ByteVec(), n), rt.stringTryReserve(text, n), rt.dequeTryReserve(rt.dequeNew(2) as rt.VecDeque, n), rt.hashTryReserve(rt.hashNew() as rt.HashSet, n, 469762048)]; - }, (value: rt.Result[]) => rt.iterSlice(value), true, 4), undefined, 8, true); - pairs$collections_TryReserveError(rt.iterToVec(rt.iterFilterMap(rt.iterSlice(v7.items), (r: rt.Result): rt.TryReserveError | undefined => { - return err$0bqdhnn(result_clone$1nmm6up(r)); + const text: string = rs.strSlice("ab", 0, rs.u8Rem(b2, 3) as rs.usize); + return [rs.byteVecTryReserve(new rs.ByteVec(), n), rs.stringTryReserve(text, n), rs.dequeTryReserve(rs.dequeNew(2) as rs.VecDeque, n), rs.hashTryReserve(rs.hashNew() as rs.HashSet, n, 469762048)]; + }, (value: rs.Result[]) => rs.iterSlice(value), true, 4), undefined, 8, true); + pairs$collections_TryReserveError(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(v7.items), (r: rs.Result): rs.TryReserveError | undefined => { + return err$069ojhs(result_clone$0688qis(r)); }), "next", 8).items, out); - pairs$Result_unit_collections_TryReserveError(rt.slicesJoin([rt.vecFrom(v7.items.map(result_clone$1nmm6up)), v7], 8, undefined, rt.asSlice, result_clone$1nmm6up).items, out); + pairs$Result_unit_collections_TryReserveError(rs.slicesJoin([rs.vecFrom(v7.items.map(result_clone$0688qis)), v7], 8, undefined, rs.asSlice, result_clone$0688qis).items, out); } else { - pairs$Option_Result_u8_num_ParseIntError(rt.iterToVec(rt.iterMap(rt.iterSlice(all.items), (s: string): rt.Result | undefined => { + pairs$Option_Result_u8_num_ParseIntError(rs.iterToVec(rs.iterMap(rs.iterSlice(all.items), (s: string): rs.Result | undefined => { const _73: string = s; - return then$0afp4no(!(s.length === 0), (): rt.Result => { - return parse$0vh70p5(_73); + return then$11t2u23(!(s.length === 0), (): rs.Result => { + return parse$1brosjp(_73); }); }), undefined, 2, true).items, out); - pairs$Vec_Result_bool_str_ParseBoolError(rt.iterToVec(rt.iterMap(rt.sliceChunks(all.items, 2), parsed$bool), undefined, 12, true).items, out); - pairs$tuple2_Result_char_char_ParseCharError_usize(rt.iterToVec(rt.iterMap(rt.iterSlice(all.items), (s2: string): [rt.Result, rt.usize] => { - return [rt.charFromStr(s2), rt.usizeRem(rt.stringLen(s2), 2)] as [rt.Result, rt.usize]; + pairs$Vec_Result_bool_str_ParseBoolError(rs.iterToVec(rs.iterMap(rs.sliceChunks(all.items, 2), parsed$bool), undefined, 12, true).items, out); + pairs$tuple2_Result_char_char_ParseCharError_usize(rs.iterToVec(rs.iterMap(rs.iterSlice(all.items), (s2: string): [rs.Result, rs.usize] => { + return [rs.charFromStr(s2), rs.usizeRem(rs.stringLen(s2), 2)] as [rs.Result, rs.usize]; }), undefined, 12, true).items, out); - pairs$char_ParseCharError(rt.iterToVec(rt.iterFilterMap(rt.iterSlice(all.items), (s3: string): rt.ParseCharError | undefined => { - return err$02r96h1(rt.charFromStr(s3)); + pairs$char_ParseCharError(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(all.items), (s3: string): rs.ParseCharError | undefined => { + return err$0bvotqj(rs.charFromStr(s3)); }), "next", 1).items, out); - pairs$str_ParseBoolError(rt.iterToVec(rt.iterFilterMap(rt.iterSlice(all.items), (s4: string): rt.ParseBoolError | undefined => { - return err$1ujom0k(parse$0vh4cry(s4)); + pairs$str_ParseBoolError(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(all.items), (s4: string): rs.ParseBoolError | undefined => { + return err$11tr79p(parse$1yfzdza(s4)); }), "next", 0).items, out); - pairs$num_ParseIntError(rt.iterToVec(rt.iterFilterMap(rt.iterSlice(all.items), (s5: string): rt.ParseIntError | undefined => { - return err$0jf6smd(parse$14z7a72(s5)); + pairs$num_ParseIntError(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(all.items), (s5: string): rs.ParseIntError | undefined => { + return err$1tv7qwu(parse$02m1946(s5)); }), "next", 1).items, out); } } -export const DROPPED: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(DROPPED$init, false); +export const DROPPED: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(DROPPED$init, false); -export function DROPPED$init(): rt.Cell { - return new rt.Cell(0); +export function DROPPED$init(): rs.Cell { + return new rs.Cell(0); } /** Each error in the chain, by `Display` and `Debug`. */ export function chain(e: Error.Error): string { - const args2: rt.Fmt[] = [(f: rt.Formatter) => e.fmt$Display(f), (f: rt.Formatter) => e.fmt$Debug(f)]; - let s: string = rt.fmtFormat([args2[0], " ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => e.fmt$Display(f), (f: rs.Formatter) => e.fmt$Debug(f)]; + let s: string = rs.fmtFormat([args2[0], " ", args2[1]]); let cur: Error.Error | undefined = e.source$Error(); while (true) { if (cur !== undefined) { const c: Error.Error = cur; - const args4: rt.Fmt[] = [(f: rt.Formatter) => c.fmt$Display(f), (f: rt.Formatter) => c.fmt$Debug(f)]; - const _17: string = rt.fmtFormat([" <- ", args4[0], " ", args4[1]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => c.fmt$Display(f), (f: rs.Formatter) => c.fmt$Debug(f)]; + const _17: string = rs.fmtFormat([" <- ", args4[0], " ", args4[1]]); s = s + _17; cur = c.source$Error(); } else { @@ -615,202 +615,202 @@ export function chain(e: Error.Error): string { } } -export function failure(kind: rt.u8, n: rt.u8): Failure.Failure { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function failure(kind: rs.u8, n: rs.u8): Failure.Failure { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { return { tag: "Short", _0: n } as Failure.Failure; } if (_3 === 1) { return { tag: "Wrapped", _0: new Leaf.Leaf(n) } as Failure.Failure; } - const _11: rt.usize = rt.u8Rem(n, 3) as rt.usize; + const _11: rs.usize = rs.u8Rem(n, 3) as rs.usize; if (!(_11 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _11); } - return { tag: "Parse", _0: rt.resultUnwrapErr(num_fromStr$1s51v8m(["", "x", "999"][_11]), rt.u8Debug) } as Failure.Failure; + return { tag: "Parse", _0: rs.resultUnwrapErr(num_fromStr$1t58fis(["", "x", "999"][_11]), rs.u8Debug) } as Failure.Failure; } /** `?` boxes a `Failure` as a `dyn Error`, as does `into`. */ -export function checked(kind: rt.u8, n: rt.u8): rt.Result { - if (!(rt.u8Rem(n, 4) === 0)) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - const _8: rt.Result = result_mapErr$1ff8zoy(num_fromStr$1s51v8m(rt.fmtFormat([args2[0], args2[0]])), (a0: rt.ParseIntError): Failure.Failure => { +export function checked(kind: rs.u8, n: rs.u8): rs.Result { + if (!(rs.u8Rem(n, 4) === 0)) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + const _8: rs.Result = result_mapErr$09oysgi(num_fromStr$1t58fis(rs.fmtFormat([args2[0], args2[0]])), (a0: rs.ParseIntError): Failure.Failure => { return { tag: "Parse", _0: a0 }; }); if (_8.ok) { - return rt.Ok(_8.value); + return rs.Ok(_8.value); } - return rt.Err(new of$errors_Failure((_8 as { ok: false; error: Failure.Failure }).error)); + return rs.Err(new of$errors_Failure((_8 as { ok: false; error: Failure.Failure }).error)); } - return rt.Err(new of$errors_Failure(failure(kind, n))); + return rs.Err(new of$errors_Failure(failure(kind, n))); } /** `?` boxes the error of a `Vec` reserving past the most `u64`s it holds. */ -export function reserve(n: rt.u8): rt.Result { - const _2: rt.Result = rt.vecTryReserve(new rt.Vec(), rt.usizeAdd(rt.usizeAdd(rt.usizeDiv(2147483647, 8), 1), n as rt.usize), 8); +export function reserve(n: rs.u8): rs.Result { + const _2: rs.Result = rs.vecTryReserve(new rs.Vec(), rs.usizeAdd(rs.usizeAdd(rs.usizeDiv(2147483647, 8), 1), n as rs.usize), 8); if (_2.ok) { - return rt.OK; + return rs.OK; } - return rt.Err(new of$collections_TryReserveError((_2 as { ok: false; error: rt.TryReserveError }).error)); + return rs.Err(new of$collections_TryReserveError((_2 as { ok: false; error: rs.TryReserveError }).error)); } -export function objects(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function objects(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let f!: Failure.Failure; if (dataLen >= 2) { - const _10: [rt.u8, rt.u8] = [dataData[dataStart], dataData[dataStart + 1]]; - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; + const _10: [rs.u8, rs.u8] = [dataData[dataStart], dataData[dataStart + 1]]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; const _24: Failure.Failure = failure(a, b); const _21: string = chain(new of$errors_Failure(_24)); const _29: Leaf.Leaf = new Leaf.Leaf(a); const _26: string = chain(new of$errors_Leaf(_29)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _21), (f: rt.Formatter) => rt.fmtPad(f, _26)]; - const _17: string = rt.fmtFormat([args2[0], " | ", args2[1], " | "]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _21), (f: rs.Formatter) => rs.fmtPad(f, _26)]; + const _17: string = rs.fmtFormat([args2[0], " | ", args2[1], " | "]); _29[Symbol.dispose](); drop$errors_Failure(_24); put(out, _17); - const part = chain(new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1s51v8m("x"), rt.u8Debug))); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - put(out, rt.fmtFormat([args4[0], " | "])); - const reserved: Error.Error = rt.resultUnwrapErr(reserve(a), rt.fmtUnit); + const part = chain(new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + put(out, rs.fmtFormat([args4[0], " | "])); + const reserved: Error.Error = rs.resultUnwrapErr(reserve(a), rs.fmtUnit); const _63: string = chain(reserved); const _66: boolean = reserved instanceof of$collections_TryReserveError || reserved instanceof ofPlace$collections_TryReserveError; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _63), (f: rt.Formatter) => reserved.fmt$Debug(f), (f: rt.Formatter) => rt.fmtBool(_66, f)]; - put(out, rt.fmtFormat([args6[0], " ", rt.fmtSpec({ alternate: true }, args6[1]), " ", args6[2], " | "])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _63), (f: rs.Formatter) => reserved.fmt$Debug(f), (f: rs.Formatter) => rs.fmtBool(_66, f)]; + put(out, rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[1]), " ", args6[2], " | "])); const held: Failure.Failure = failure(a, b); const _86: string = chain(new of$boxed_Box_errors_Failure(held)); const _90: string = chain(new of$ref_errors_Failure(held)); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _86), (f: rt.Formatter) => rt.fmtPad(f, _90)]; - put(out, rt.fmtFormat([args8[0], " | ", args8[1], " | "])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _86), (f: rs.Formatter) => rs.fmtPad(f, _90)]; + put(out, rs.fmtFormat([args8[0], " | ", args8[1], " | "])); const coded: Coded.Coded = new of$errors_Failure(failure(b, a)); const up: Error.Error = coded; - const _111: rt.u8 = coded.code$Coded(); + const _111: rs.u8 = coded.code$Coded(); const _114: string = chain(up); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_111, f), (f: rt.Formatter) => rt.fmtPad(f, _114)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " | "])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_111, f), (f: rs.Formatter) => rs.fmtPad(f, _114)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " | "])); const boxed: Transported.Transported = new Transported.Transported(coded); const _129: string = chain(new of$errors_Transported(boxed)); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _129), (f: rt.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; - put(out, rt.fmtFormat([args12[0], " ", rt.fmtSpec({ alternate: true }, args12[1]), " | "])); - set$0st49po(DROPPED, 0); - const results: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rt.u8): rt.Result => { - const n: rt.u8 = _2; - return checked(rt.u8WrappingAdd(a, n), n); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _129), (f: rs.Formatter) => Transported.fmt$fmt_Debug(boxed, f)]; + put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[1]), " | "])); + set$1ljkjlf(DROPPED, 0); + const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2))), (_2: rs.u8): rs.Result => { + const n: rs.u8 = _2; + return checked(rs.u8WrappingAdd(a, n), n); }), undefined, 8, true); for (const _149 of results.items) { if (_149.ok) { const arg = _149.value; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - put(out, rt.fmtFormat([args14[0], " "])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + put(out, rs.fmtFormat([args14[0], " "])); } else { const part2 = chain(_149.error); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part2)]; - put(out, rt.fmtFormat([args16[0], " "])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part2)]; + put(out, rs.fmtFormat([args16[0], " "])); } } - rt.dropVec(results, drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send); - const part3 = get$1ei2eoj(DROPPED); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - put(out, rt.fmtFormat(["| ", args18[0], " "])); - set$0st49po(DROPPED, 0); + rs.dropVec(results, drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send); + const part3 = get$0q7640n(DROPPED); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + put(out, rs.fmtFormat(["| ", args18[0], " "])); + set$1ljkjlf(DROPPED, 0); const leaf: Leaf.Leaf = new Leaf.Leaf(b); const borrowed: Error.Error = new of$ref_errors_Leaf(leaf); const part4 = chain(borrowed); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part4)]; - put(out, rt.fmtFormat([args20[0], " "])); - rt.drop(borrowed); - const part5 = get$1ei2eoj(DROPPED); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - put(out, rt.fmtFormat([args22[0], " "])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; + put(out, rs.fmtFormat([args20[0], " "])); + rs.drop(borrowed); + const part5 = get$0q7640n(DROPPED); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + put(out, rs.fmtFormat([args22[0], " "])); leaf[Symbol.dispose](); - const part6 = get$1ei2eoj(DROPPED); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - put(out, rt.fmtFormat([args24[0], " | "])); + const part6 = get$0q7640n(DROPPED); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + put(out, rs.fmtFormat([args24[0], " | "])); const coded2: Coded.Coded = new of$errors_Failure(failure(a, b)); const part7 = downcast(coded2); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part7)]; - put(out, rt.fmtFormat([args26[0], " "])); - const errors: rt.Vec = rt.vecFrom([coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rt.resultUnwrapErr(num_fromStr$1s51v8m("x"), rt.u8Debug))]); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part7)]; + put(out, rs.fmtFormat([args26[0], " "])); + const errors: rs.Vec = rs.vecFrom([coded2, new of$errors_Leaf(new Leaf.Leaf(a)), new of$num_ParseIntError(rs.resultUnwrapErr(num_fromStr$1t58fis("x"), rs.u8Debug))]); for (const _277 of errors.items) { const part8 = downcast(_277); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part8)]; - put(out, rt.fmtFormat([args28[0], " "])); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part8)]; + put(out, rs.fmtFormat([args28[0], " "])); } const leaf2: Leaf.Leaf = new Leaf.Leaf(a); const e: Error.Error = new of$errors_Leaf(leaf2); const _298: Leaf.Leaf | undefined = e instanceof of$errors_Leaf ? e.v : undefined; if (_298 !== undefined) { - _298.code = rt.u8WrappingAdd(_298.code, b); + _298.code = rs.u8WrappingAdd(_298.code, b); } const arg2 = leaf2.code; - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg2, f)]; - put(out, rt.fmtFormat([args30[0], " "])); - set$0st49po(DROPPED, 0); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f)]; + put(out, rs.fmtFormat([args30[0], " "])); + set$1ljkjlf(DROPPED, 0); for (const e2 of errors.items) { - const _324: rt.Result = e2 instanceof of$errors_Failure ? rt.Ok(e2.v) : rt.Err(e2); + const _324: rs.Result = e2 instanceof of$errors_Failure ? rs.Ok(e2.v) : rs.Err(e2); if (_324.ok) { f = _324.value; - const _334: rt.u8 = Failure.code$errors_Coded(f); - const _337: rt.u32 = get$1ei2eoj(DROPPED); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_334, f), (f: rt.Formatter) => rt.u32Display(_337, f)]; - put(out, rt.fmtFormat(["failure ", args32[0], " ", args32[1], " "])); + const _334: rs.u8 = Failure.code$errors_Coded(f); + const _337: rs.u32 = get$0q7640n(DROPPED); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_334, f), (f: rs.Formatter) => rs.u32Display(_337, f)]; + put(out, rs.fmtFormat(["failure ", args32[0], " ", args32[1], " "])); drop$errors_Failure(f); } else { const e3: Error.Error = _324.error; - const _345: rt.Result = e3 instanceof of$errors_Leaf ? rt.Ok(e3.v) : rt.Err(e3); + const _345: rs.Result = e3 instanceof of$errors_Leaf ? rs.Ok(e3.v) : rs.Err(e3); if (_345.ok) { const l: Leaf.Leaf = _345.value; - const _356: rt.u32 = get$1ei2eoj(DROPPED); + const _356: rs.u32 = get$0q7640n(DROPPED); const arg3 = l.code; - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg3, f), (f: rt.Formatter) => rt.u32Display(_356, f)]; - put(out, rt.fmtFormat(["leaf ", args34[0], " ", args34[1], " "])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg3, f), (f: rs.Formatter) => rs.u32Display(_356, f)]; + put(out, rs.fmtFormat(["leaf ", args34[0], " ", args34[1], " "])); l[Symbol.dispose](); } else { const e4: Error.Error = _345.error; - const args36: rt.Fmt[] = [(f: rt.Formatter) => e4.fmt$Display(f)]; - put(out, rt.fmtFormat([args36[0], " "])); - rt.drop(e4); + const args36: rs.Fmt[] = [(f: rs.Formatter) => e4.fmt$Display(f)]; + put(out, rs.fmtFormat([args36[0], " "])); + rs.drop(e4); } } } - const part9 = get$1ei2eoj(DROPPED); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part9, f)]; - put(out, rt.fmtFormat([args38[0], " "])); - const part10 = result_mapErr$1ibyj9t(result_mapErr$0pzoye2(checked(b, rt.u8WrappingMul(a, 4)), (e5: Error.Error): rt.Result => { - return result_map$0d23w2b(e5 instanceof of$errors_Failure ? rt.Ok(e5.v) : rt.Err(e5), (f2: Failure.Failure): rt.u8 => { - const _03: rt.u8 = Failure.code$errors_Coded(f2); + const part9 = get$0q7640n(DROPPED); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; + put(out, rs.fmtFormat([args38[0], " "])); + const part10 = result_mapErr$1scmdah(result_mapErr$0ka0di9(checked(b, rs.u8WrappingMul(a, 4)), (e5: Error.Error): rs.Result => { + return result_map$18dk705(e5 instanceof of$errors_Failure ? rs.Ok(e5.v) : rs.Err(e5), (f2: Failure.Failure): rs.u8 => { + const _03: rs.u8 = Failure.code$errors_Coded(f2); drop$errors_Failure(f2); return _03; }); - }), (e6: rt.Result): rt.Result => { - return result_mapErr$09yhde7(e6, (e7: Error.Error): string => { - const _05: string = rt.fmtToString((f: rt.Formatter) => e7.fmt$Display(f)); - rt.drop(e7); + }), (e6: rs.Result): rs.Result => { + return result_mapErr$1a5uolr(e6, (e7: Error.Error): string => { + const _05: string = rs.fmtToString((f: rs.Formatter) => e7.fmt$Display(f)); + rs.drop(e7); return _05; }); }); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part10, f, rt.u8Debug, (value: rt.Result, f: rt.Formatter) => rt.fmtResult(value, f, rt.u8Debug, rt.fmtStr))]; - put(out, rt.fmtFormat([args40[0]])); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part10, f, rs.u8Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; + put(out, rs.fmtFormat([args40[0]])); leaf2[Symbol.dispose](); boxed[Symbol.dispose](); drop$errors_Failure(held); - rt.drop(reserved); + rs.drop(reserved); } } /** Which of the crate's errors and std's `e` and its source are, and the `Failure` it holds. */ export function downcast(e: Error.Error): string { const is: [boolean, boolean, boolean] = [e instanceof of$errors_Failure || e instanceof ofPlace$errors_Failure, e instanceof of$errors_Leaf, e instanceof of$num_ParseIntError || e instanceof ofPlace$num_ParseIntError]; - const source: [boolean, rt.IntErrorKind | undefined] | undefined = option_map$0frk5o8(e.source$Error(), (s: Error.Error): [boolean, rt.IntErrorKind | undefined] => { - return [s instanceof of$errors_Leaf, option_map$0ukfexb(s instanceof of$num_ParseIntError ? s.v : s instanceof ofPlace$num_ParseIntError ? s.v.v : undefined, (p: rt.ParseIntError): rt.IntErrorKind => { + const source: [boolean, rs.IntErrorKind | undefined] | undefined = option_map$1hw1osb(e.source$Error(), (s: Error.Error): [boolean, rs.IntErrorKind | undefined] => { + return [s instanceof of$errors_Leaf, option_map$0p4jgzx(s instanceof of$num_ParseIntError ? s.v : s instanceof ofPlace$num_ParseIntError ? s.v.v : undefined, (p: rs.ParseIntError): rs.IntErrorKind => { return p.kind; - })] as [boolean, rt.IntErrorKind | undefined]; + })] as [boolean, rs.IntErrorKind | undefined]; }); - const _12: rt.u8 | undefined = option_map$03ygfmn(e instanceof of$errors_Failure ? e.v : e instanceof ofPlace$errors_Failure ? e.v.v : undefined, (f: Failure.Failure): rt.u8 => { + const _12: rs.u8 | undefined = option_map$0jqf1o0(e instanceof of$errors_Failure ? e.v : e instanceof ofPlace$errors_Failure ? e.v.v : undefined, (f: Failure.Failure): rs.u8 => { return Failure.code$errors_Coded(f); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(is[0], f), (f: rt.Formatter) => rt.fmtBool(is[1], f), (f: rt.Formatter) => rt.fmtBool(is[2], f)], f), (f: rt.Formatter) => rt.fmtOption(source, f, (value: [boolean, rt.IntErrorKind | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, (value: rt.IntErrorKind, f: rt.Formatter) => rt.fmtWriteStr(f, value))], f)), (f: rt.Formatter) => rt.fmtOption(_12, f, rt.u8Debug)]; - return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(is[0], f), (f: rs.Formatter) => rs.fmtBool(is[1], f), (f: rs.Formatter) => rs.fmtBool(is[2], f)], f), (f: rs.Formatter) => rs.fmtOption(source, f, (value: [boolean, rs.IntErrorKind | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, (value: rs.IntErrorKind, f: rs.Formatter) => rs.fmtWriteStr(f, value))], f)), (f: rs.Formatter) => rs.fmtOption(_12, f, rs.u8Debug)]; + return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]); } //# sourceMappingURL=errors.ts.map diff --git a/ts/fixtures/lang/errors/expected/harness.ts b/ts/fixtures/lang/errors/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/errors/expected/harness.ts +++ b/ts/fixtures/lang/errors/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/errors/expected/lib.ts b/ts/fixtures/lang/errors/expected/lib.ts index 1ae5910eb..92b5b0d51 100644 --- a/ts/fixtures/lang/errors/expected/lib.ts +++ b/ts/fixtures/lang/errors/expected/lib.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Error from "./core/error.Error.ts"; import { eqs, objects } from "./errors.ts"; import * as Failure from "./errors.Failure.ts"; import * as Leaf from "./errors.Leaf.ts"; import * as Transported from "./errors.Transported.ts"; -export function drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send(_1: rt.Result): void { +export function drop$Result_u8_boxed_Box_dyn_Error_marker_Sync_marker_Send(_1: rs.Result): void { if (!_1.ok) { - rt.drop(_1.error); + rs.drop(_1.error); } } @@ -30,11 +30,11 @@ export class of$boxed_Box_errors_Failure { drop$errors_Failure(this.v); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Display(this.v, a); } @@ -44,18 +44,18 @@ export class of$boxed_Box_errors_Failure { } export class of$collections_TryReserveError { - v: rt.TryReserveError; + v: rs.TryReserveError; - constructor(v: rt.TryReserveError) { + constructor(v: rs.TryReserveError) { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { - return rt.fmtTryReserveErrorDebug(this.v, a); + fmt$Debug(a: rs.Formatter): rs.Result { + return rs.fmtTryReserveErrorDebug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { - return rt.fmtTryReserveErrorDisplay(this.v, a); + fmt$Display(a: rs.Formatter): rs.Result { + return rs.fmtTryReserveErrorDisplay(this.v, a); } source$Error(): Error.Error | undefined { @@ -74,15 +74,15 @@ export class of$errors_Failure { drop$errors_Failure(this.v); } - code$Coded(): rt.u8 { + code$Coded(): rs.u8 { return Failure.code$errors_Coded(this.v); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Display(this.v, a); } @@ -102,11 +102,11 @@ export class of$errors_Leaf { this.v[Symbol.dispose](); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Leaf.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Leaf.fmt$fmt_Display(this.v, a); } @@ -126,11 +126,11 @@ export class of$errors_Transported { this.v[Symbol.dispose](); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Transported.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Transported.fmt$fmt_Display(this.v, a); } @@ -140,18 +140,18 @@ export class of$errors_Transported { } export class of$num_ParseIntError { - v: rt.ParseIntError; + v: rs.ParseIntError; - constructor(v: rt.ParseIntError) { + constructor(v: rs.ParseIntError) { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { - return rt.fmtParseIntErrorDebug(this.v, a); + fmt$Debug(a: rs.Formatter): rs.Result { + return rs.fmtParseIntErrorDebug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { - return rt.fmtParseIntErrorDisplay(this.v, a); + fmt$Display(a: rs.Formatter): rs.Result { + return rs.fmtParseIntErrorDisplay(this.v, a); } source$Error(): Error.Error | undefined { @@ -166,11 +166,11 @@ export class of$ref_errors_Failure { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Display(this.v, a); } @@ -186,11 +186,11 @@ export class of$ref_errors_Leaf { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Leaf.fmt$fmt_Debug(this.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Leaf.fmt$fmt_Display(this.v, a); } @@ -200,18 +200,18 @@ export class of$ref_errors_Leaf { } export class ofPlace$collections_TryReserveError { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { - return rt.fmtTryReserveErrorDebug(this.v.v, a); + fmt$Debug(a: rs.Formatter): rs.Result { + return rs.fmtTryReserveErrorDebug(this.v.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { - return rt.fmtTryReserveErrorDisplay(this.v.v, a); + fmt$Display(a: rs.Formatter): rs.Result { + return rs.fmtTryReserveErrorDisplay(this.v.v, a); } source$Error(): Error.Error | undefined { @@ -220,9 +220,9 @@ export class ofPlace$collections_TryReserveError { } export class ofPlace$errors_Failure { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } @@ -230,11 +230,11 @@ export class ofPlace$errors_Failure { drop$errors_Failure(this.v.v); } - fmt$Debug(a: rt.Formatter): rt.Result { + fmt$Debug(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Debug(this.v.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { + fmt$Display(a: rs.Formatter): rs.Result { return Failure.fmt$fmt_Display(this.v.v, a); } @@ -244,18 +244,18 @@ export class ofPlace$errors_Failure { } export class ofPlace$num_ParseIntError { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - fmt$Debug(a: rt.Formatter): rt.Result { - return rt.fmtParseIntErrorDebug(this.v.v, a); + fmt$Debug(a: rs.Formatter): rs.Result { + return rs.fmtParseIntErrorDebug(this.v.v, a); } - fmt$Display(a: rt.Formatter): rt.Result { - return rt.fmtParseIntErrorDisplay(this.v.v, a); + fmt$Display(a: rs.Formatter): rs.Result { + return rs.fmtParseIntErrorDisplay(this.v.v, a); } source$Error(): Error.Error | undefined { @@ -267,10 +267,10 @@ export class ofPlace$num_ParseIntError { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["errors::eqs", eqs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["errors::objects", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["errors::eqs", eqs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["errors::objects", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { objects(data.data, data.start, data.length, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/errors/expected/std/thread/local.ts b/ts/fixtures/lang/errors/expected/std/thread/local.ts index 68c0c768b..afb3c24a6 100644 --- a/ts/fixtures/lang/errors/expected/std/thread/local.ts +++ b/ts/fixtures/lang/errors/expected/std/thread/local.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function set$0st49po(self: rt.LocalKey>, value: rt.u32): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell | undefined, cell: rt.Cell): undefined => { +export function set$1ljkjlf(self: rs.LocalKey>, value: rs.u32): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell | undefined, cell: rs.Cell): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function get$1ei2eoj(self: rt.LocalKey>): rt.u32 { - return ((a0: rt.Cell): rt.u32 => { +export function get$0q7640n(self: rs.LocalKey>): rs.u32 { + return ((a0: rs.Cell): rs.u32 => { return a0.v; })(self.get()); } diff --git a/ts/fixtures/lang/fields/expected/core/option.ts b/ts/fixtures/lang/fields/expected/core/option.ts index 659e3e1e0..33bef1f6f 100644 --- a/ts/fixtures/lang/fields/expected/core/option.ts +++ b/ts/fixtures/lang/fields/expected/core/option.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function okOr$1w08zpl(self: rt.ByteSlice | undefined, err: rt.usize): rt.Result { +export function okOr$032o4ic(self: rs.ByteSlice | undefined, err: rs.usize): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/fields/expected/core/result.ts b/ts/fixtures/lang/fields/expected/core/result.ts index d90131781..9324f2475 100644 --- a/ts/fixtures/lang/fields/expected/core/result.ts +++ b/ts/fixtures/lang/fields/expected/core/result.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function ok$04yj0hm(self: rt.Result): rt.ByteSlice | undefined { +export function ok$19nq1jt(self: rs.Result): rs.ByteSlice | undefined { if (self.ok) { return self.value; } return undefined; } -export function inspectErr$0g3nypv(self: rt.Result, f: (a0: rt.usize) => undefined): rt.Result { +export function inspectErr$0vkwi4s(self: rs.Result, f: (a0: rs.usize) => undefined): rs.Result { if (!self.ok) { f(self.error); } diff --git a/ts/fixtures/lang/fields/expected/fields.Couple.ts b/ts/fixtures/lang/fields/expected/fields.Couple.ts index dc36c07bd..d8f6a90b9 100644 --- a/ts/fixtures/lang/fields/expected/fields.Couple.ts +++ b/ts/fixtures/lang/fields/expected/fields.Couple.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Couple, f: rt.Formatter): rt.Result { - const arg = new rt.ByteSlice(self.headData, self.headStart, self.headLen); - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg), f, rt.u8Debug); - const arg2 = new rt.ByteSlice(self.wordData, self.wordStart, self.wordLen); +export function fmt$fmt_Debug(self: Couple, f: rs.Formatter): rs.Result { + const arg = new rs.ByteSlice(self.headData, self.headStart, self.headLen); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); + const arg2 = new rs.ByteSlice(self.wordData, self.wordStart, self.wordLen); const _3: string = "Couple"; const _4: string = "head"; const _7: string = "word"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg2), f, rt.u8Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$cmp_PartialEq(self: Couple, other: Couple): boolean { - if (!rt.byteSliceEq(new rt.ByteSlice(self.headData, self.headStart, self.headLen), new rt.ByteSlice(other.headData, other.headStart, other.headLen))) { + if (!rs.byteSliceEq(new rs.ByteSlice(self.headData, self.headStart, self.headLen), new rs.ByteSlice(other.headData, other.headStart, other.headLen))) { return false; } - return rt.eqBytes(new rt.ByteSlice(self.wordData, self.wordStart, self.wordLen), new rt.ByteSlice(other.wordData, other.wordStart, other.wordLen)); + return rs.eqBytes(new rs.ByteSlice(self.wordData, self.wordStart, self.wordLen), new rs.ByteSlice(other.wordData, other.wordStart, other.wordLen)); } /** A `Copy` struct of a slice and an array's reference. */ diff --git a/ts/fixtures/lang/fields/expected/fields.Exposed.ts b/ts/fixtures/lang/fields/expected/fields.Exposed.ts index 6626b285d..fedeb6186 100644 --- a/ts/fixtures/lang/fields/expected/fields.Exposed.ts +++ b/ts/fixtures/lang/fields/expected/fields.Exposed.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Exposed, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Exposed, f: rs.Formatter): rs.Result { const _3: string = "Exposed"; const _4: string = "buf"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(self.buf), f, rt.u8Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(self.buf), f, rs.u8Debug); const _7: string = "at"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.at, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.at, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A `pub` field, which stays whole. */ export interface Exposed { - buf: rt.ByteSlice; - at: rt.u8; + buf: rs.ByteSlice; + at: rs.u8; } //# sourceMappingURL=fields.Exposed.ts.map diff --git a/ts/fixtures/lang/fields/expected/fields.Glued.ts b/ts/fixtures/lang/fields/expected/fields.Glued.ts index 5c0b69d37..237352562 100644 --- a/ts/fixtures/lang/fields/expected/fields.Glued.ts +++ b/ts/fixtures/lang/fields/expected/fields.Glued.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Glued, f: rt.Formatter): rt.Result { - const arg = new rt.ByteSlice(self._0Data, self._0Start, self._0Len); - const _4: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg), f, rt.u8Debug); - const arg2 = new rt.ByteSlice(self._1Data, self._1Start, self._1Len); +export function fmt$fmt_Debug(self: Glued, f: rs.Formatter): rs.Result { + const arg = new rs.ByteSlice(self._0Data, self._0Start, self._0Len); + const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); + const arg2 = new rs.ByteSlice(self._1Data, self._1Start, self._1Len); const _3: string = "Glued"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg2), f, rt.u8Debug); - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); } /** A tuple struct of two slices, one a constant's. */ diff --git a/ts/fixtures/lang/fields/expected/fields.Labeled.ts b/ts/fixtures/lang/fields/expected/fields.Labeled.ts index a9a9b9886..3de00bc59 100644 --- a/ts/fixtures/lang/fields/expected/fields.Labeled.ts +++ b/ts/fixtures/lang/fields/expected/fields.Labeled.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A generic struct holding a slice beside its parameter. */ export class Labeled { @@ -17,10 +17,10 @@ export class Labeled { } } -export function sum$u8(self: Labeled): rt.u32 { - return rt.u32Add(rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(self.bytesData, self.bytesStart, self.bytesLen))), (_22: rt.u8): rt.u32 => { - return _22 as rt.u32; - }), rt.u32Add, 0), self.tag as rt.u32); +export function sum$u8(self: Labeled): rs.u32 { + return rs.u32Add(rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(self.bytesData, self.bytesStart, self.bytesLen))), (_22: rs.u8): rs.u32 => { + return _22 as rs.u32; + }), rs.u32Add, 0), self.tag as rs.u32); } //# sourceMappingURL=fields.Labeled.ts.map diff --git a/ts/fixtures/lang/fields/expected/fields.Scanner.ts b/ts/fixtures/lang/fields/expected/fields.Scanner.ts index d55deafda..1bdf3c9fe 100644 --- a/ts/fixtures/lang/fields/expected/fields.Scanner.ts +++ b/ts/fixtures/lang/fields/expected/fields.Scanner.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { okOr$1w08zpl as option_okOr$1w08zpl } from "./core/option.ts"; -import { ok$04yj0hm, inspectErr$0g3nypv } from "./core/result.ts"; +import * as rs from "./rs.ts"; +import { okOr$032o4ic as option_okOr$032o4ic } from "./core/option.ts"; +import { ok$19nq1jt, inspectErr$0vkwi4s } from "./core/result.ts"; export function clone$Clone(self: Scanner): Scanner { - const _2: rt.ByteSlice = new rt.ByteSlice(self.bufData, self.bufStart, self.bufLen); + const _2: rs.ByteSlice = new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen); return { bufData: _2.data, bufStart: _2.start, bufLen: _2.length, read: self.read }; } -export function fmt$fmt_Debug(self: Scanner, f: rt.Formatter): rt.Result { - const arg = new rt.ByteSlice(self.bufData, self.bufStart, self.bufLen); +export function fmt$fmt_Debug(self: Scanner, f: rs.Formatter): rs.Result { + const arg = new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen); const _3: string = "Scanner"; const _4: string = "buf"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg), f, rt.u8Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg), f, rs.u8Debug); const _7: string = "read"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self.read, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.read, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$cmp_PartialEq(self: Scanner, other: Scanner): boolean { - if (!rt.byteSliceEq(new rt.ByteSlice(self.bufData, self.bufStart, self.bufLen), new rt.ByteSlice(other.bufData, other.bufStart, other.bufLen))) { + if (!rs.byteSliceEq(new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen), new rs.ByteSlice(other.bufData, other.bufStart, other.bufLen))) { return false; } return self.read === other.read; @@ -31,10 +31,10 @@ export interface Scanner { bufData: Uint8Array; bufStart: number; bufLen: number; - read: rt.usize; + read: rs.usize; } -export function take(self: Scanner, n: rt.usize): rt.ByteSlice | undefined { +export function take(self: Scanner, n: rs.usize): rs.ByteSlice | undefined { const _10Data: Uint8Array = self.bufData; const _10Start: number = self.bufStart; const _10Len: number = self.bufLen; @@ -42,19 +42,19 @@ export function take(self: Scanner, n: rt.usize): rt.ByteSlice | undefined { self.bufData = _10Data; self.bufStart = _10Start + n; self.bufLen = _10Len - n; - self.read = rt.usizeAdd(self.read, n); - return new rt.ByteSlice(_10Data, _10Start, n); + self.read = rs.usizeAdd(self.read, n); + return new rs.ByteSlice(_10Data, _10Start, n); } return undefined; } /** A read undone by a closure that captured the field's `&mut` and the old value. */ -export function takeOrRewind(self: Scanner, n: rt.usize): rt.ByteSlice | undefined { +export function takeOrRewind(self: Scanner, n: rs.usize): rs.ByteSlice | undefined { const startData: Uint8Array = self.bufData; const startStart: number = self.bufStart; const startLen: number = self.bufLen; if (take(self, 1) !== undefined) { - return ok$04yj0hm(inspectErr$0g3nypv(option_okOr$1w08zpl(take(self, n), n), (_2: rt.usize): undefined => { + return ok$19nq1jt(inspectErr$0vkwi4s(option_okOr$032o4ic(take(self, n), n), (_2: rs.usize): undefined => { self.bufData = startData; self.bufStart = startStart; self.bufLen = startLen; @@ -63,8 +63,8 @@ export function takeOrRewind(self: Scanner, n: rt.usize): rt.ByteSlice | undefin return undefined; } -export function rest(self: Scanner): rt.ByteSlice { - const taken = new rt.ByteSlice(self.bufData, self.bufStart, self.bufLen); +export function rest(self: Scanner): rs.ByteSlice { + const taken = new rs.ByteSlice(self.bufData, self.bufStart, self.bufLen); self.bufData = new Uint8Array(0); self.bufStart = 0; self.bufLen = 0; diff --git a/ts/fixtures/lang/fields/expected/fields.Sentry.ts b/ts/fixtures/lang/fields/expected/fields.Sentry.ts index e98c76507..9207a92dc 100644 --- a/ts/fixtures/lang/fields/expected/fields.Sentry.ts +++ b/ts/fixtures/lang/fields/expected/fields.Sentry.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct that drops, a class, holding a slice. */ export class Sentry { bufData: Uint8Array; bufStart: number; bufLen: number; - out: rt.ByteVec; + out: rs.ByteVec; - constructor(bufData: Uint8Array, bufStart: number, bufLen: number, out: rt.ByteVec) { + constructor(bufData: Uint8Array, bufStart: number, bufLen: number, out: rs.ByteVec) { this.bufData = bufData; this.bufStart = bufStart; this.bufLen = bufLen; @@ -22,7 +22,7 @@ export class Sentry { } export function drop$ops_Drop(self: Sentry): void { - rt.byteVecPush(self.out, self.bufLen & 0xff); + rs.byteVecPush(self.out, self.bufLen & 0xff); } //# sourceMappingURL=fields.Sentry.ts.map diff --git a/ts/fixtures/lang/fields/expected/fields.ts b/ts/fixtures/lang/fields/expected/fields.ts index 293326ca6..99bb6eaad 100644 --- a/ts/fixtures/lang/fields/expected/fields.ts +++ b/ts/fixtures/lang/fields/expected/fields.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$fields_Couple } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Couple from "./fields.Couple.ts"; import * as Exposed from "./fields.Exposed.ts"; import * as Glued from "./fields.Glued.ts"; @@ -11,23 +11,23 @@ import * as Scanner from "./fields.Scanner.ts"; import * as Sentry from "./fields.Sentry.ts"; /** Advance a slice through a `&mut` to it. */ -export function skipInto(buf: rt.Place, n: rt.usize): void { - buf.v = rt.byteSliceRange(buf.v, rt.min(n, buf.v.length)); +export function skipInto(buf: rs.Place, n: rs.usize): void { + buf.v = rs.byteSliceRange(buf.v, rs.min(n, buf.v.length)); } export const SCANNER: Scanner.Scanner = { bufData: Uint8Array.of(120, 121, 122), bufStart: 0, bufLen: 3, read: 1 }; -export function fields(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function fields(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let two!: Glued.Glued; - const n: rt.usize = rt.u8Rem(kind, 5) as rt.usize; - const _8: rt.ByteSlice = rt.byteSliceRange(data, rt.min(n, data.length)); - rt.byteVecPush(out, (kind as rt.usize) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(new rt.ByteSlice(_8.data, _8.start, _8.length), 0, rt.min(_8.length, 2))); + const n: rs.usize = rs.u8Rem(kind, 5) as rs.usize; + const _8: rs.ByteSlice = rs.byteSliceRange(data, rs.min(n, data.length)); + rs.byteVecPush(out, (kind as rs.usize) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(new rs.ByteSlice(_8.data, _8.start, _8.length), 0, rs.min(_8.length, 2))); const r: Scanner.Scanner = { bufData: data.data, bufStart: data.start, bufLen: data.length, read: 0 }; while (true) { - const _22: rt.ByteSlice | undefined = Scanner.take(r, rt.max(n, 1)); + const _22: rs.ByteSlice | undefined = Scanner.take(r, rs.max(n, 1)); if (_22 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(_22, 0, rt.min(_22.length, 1))); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(_22, 0, rs.min(_22.length, 1))); if (r.read > 12) { break; } @@ -36,92 +36,92 @@ export function fields(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } const r2: Scanner.Scanner = { bufData: data.data, bufStart: data.start, bufLen: data.length, read: 0 }; - const _36: rt.ByteSlice | undefined = Scanner.takeOrRewind(r2, rt.usizeAdd(n, 3)); + const _36: rs.ByteSlice | undefined = Scanner.takeOrRewind(r2, rs.usizeAdd(n, 3)); if (_36 === undefined) { - rt.byteVecPush(out, 200); + rs.byteVecPush(out, 200); } else { - rt.byteVecPush(out, _36.length & 0xff); + rs.byteVecPush(out, _36.length & 0xff); } - rt.byteVecPush(out, r2.bufLen & 0xff); + rs.byteVecPush(out, r2.bufLen & 0xff); const before: Scanner.Scanner = Scanner.clone$Clone(r2); Scanner.take(r2, 1); - rt.byteVecPush(out, Scanner.eq$cmp_PartialEq(before, r2) ? 1 : 0); - rt.byteVecPush(out, before.bufLen & 0xff); - rt.byteVecPush(out, Scanner.rest(r2).length & 0xff); - rt.byteVecPush(out, r2.bufLen & 0xff); + rs.byteVecPush(out, Scanner.eq$cmp_PartialEq(before, r2) ? 1 : 0); + rs.byteVecPush(out, before.bufLen & 0xff); + rs.byteVecPush(out, Scanner.rest(r2).length & 0xff); + rs.byteVecPush(out, r2.bufLen & 0xff); const s: Scanner.Scanner = { bufData: data.data, bufStart: data.start, bufLen: data.length, read: 0 }; - const _70: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); - const old2 = new rt.ByteSlice(s.bufData, s.bufStart, s.bufLen); + const _70: rs.ByteSlice = rs.byteSliceRange(data, rs.usizeDiv(data.length, 2)); + const old2 = new rs.ByteSlice(s.bufData, s.bufStart, s.bufLen); s.bufData = _70.data; s.bufStart = _70.start; s.bufLen = _70.length; - rt.byteVecPush(out, rt.usizeSub(old2.length, s.bufLen) & 0xff); - const swapped = new rt.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen); + rs.byteVecPush(out, rs.usizeSub(old2.length, s.bufLen) & 0xff); + const swapped = new rs.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen); r2.bufData = s.bufData; r2.bufStart = s.bufStart; r2.bufLen = s.bufLen; s.bufData = swapped.data; s.bufStart = swapped.start; s.bufLen = swapped.length; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(r2.bufLen & 0xff, s.bufLen & 0xff))); - skipInto(rt.place(() => new rt.ByteSlice(s.bufData, s.bufStart, s.bufLen), (value): void => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(r2.bufLen & 0xff, s.bufLen & 0xff))); + skipInto(rs.place(() => new rs.ByteSlice(s.bufData, s.bufStart, s.bufLen), (value): void => { s.bufData = value.data; s.bufStart = value.start; s.bufLen = value.length; }), n); - rt.byteVecPush(out, s.bufLen & 0xff); - skipInto(rt.place(() => new rt.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), (value2): void => { + rs.byteVecPush(out, s.bufLen & 0xff); + skipInto(rs.place(() => new rs.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), (value2): void => { r2.bufData = value2.data; r2.bufStart = value2.start; r2.bufLen = value2.length; }), 1); - const _99: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), rt.min(new rt.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen).length, 1)); + const _99: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), rs.min(new rs.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen).length, 1)); r2.bufData = _99.data; r2.bufStart = _99.start; r2.bufLen = _99.length; - rt.byteVecPush(out, r2.bufLen & 0xff); - const _106: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), rt.usizeDiv(r2.bufLen, 2)); + rs.byteVecPush(out, r2.bufLen & 0xff); + const _106: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(r2.bufData, r2.bufStart, r2.bufLen), rs.usizeDiv(r2.bufLen, 2)); r2.bufData = _106.data; r2.bufStart = _106.start; r2.bufLen = _106.length; - rt.byteVecPush(out, r2.bufLen & 0xff); - const _114: rt.ByteSlice | undefined = rt.byteSliceGetRange(data, 0, 2); + rs.byteVecPush(out, r2.bufLen & 0xff); + const _114: rs.ByteSlice | undefined = rs.byteSliceGetRange(data, 0, 2); if (_114 !== undefined) { const p: Couple.Couple = { headData: data.data, headStart: data.start, headLen: data.length, wordData: _114.data, wordStart: _114.start, wordLen: _114.length }; const q: Couple.Couple = copy$fields_Couple(p); - const _119: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(p.headData, p.headStart, p.headLen), 1); + const _119: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(p.headData, p.headStart, p.headLen), 1); p.headData = _119.data; p.headStart = _119.start; p.headLen = _119.length; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(p.headLen & 0xff, q.headLen & 0xff, Couple.eq$cmp_PartialEq(p, q) ? 1 : 0))); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(q.wordData, q.wordStart, q.wordLen)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Couple.fmt$fmt_Debug(p, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(p.headLen & 0xff, q.headLen & 0xff, Couple.eq$cmp_PartialEq(p, q) ? 1 : 0))); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(q.wordData, q.wordStart, q.wordLen)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Couple.fmt$fmt_Debug(p, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } - const _148: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 3)); + const _148: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); const open: Exposed.Exposed = { buf: _148, at: kind }; - const args4: rt.Fmt[] = [(f: rt.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rt.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], args4[1]]))); - rt.byteVecPush(out, kind ^ (_148.length & 0xff)); - if (!(rt.u8Rem(kind, 2) === 0)) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => Exposed.fmt$fmt_Debug(open, f), (f: rs.Formatter) => Scanner.fmt$fmt_Debug(r2, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], args4[1]]))); + rs.byteVecPush(out, kind ^ (_148.length & 0xff)); + if (!(rs.u8Rem(kind, 2) === 0)) { const _175: Glued.Glued = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; two = { _0Data: data.data, _0Start: data.start, _0Len: data.length, _1Data: _175._0Data, _1Start: _175._0Start, _1Len: _175._0Len }; } else { two = { _0Data: Uint8Array.of(97, 98), _0Start: 0, _0Len: 2, _1Data: Uint8Array.of(), _1Start: 0, _1Len: 0 }; } - const args6: rt.Fmt[] = [(f: rt.Formatter) => Glued.fmt$fmt_Debug(two, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args6[0]]))); - rt.byteVecPush(out, rt.usizeAdd(two._0Len, two._1Len) & 0xff); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Glued.fmt$fmt_Debug(two, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0]]))); + rs.byteVecPush(out, rs.usizeAdd(two._0Len, two._1Len) & 0xff); const _195: Scanner.Scanner = SCANNER; - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(_195.bufData, _195.bufStart, _195.bufLen)); - rt.byteVecPush(out, SCANNER.read & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(Labeled.sum$u8(new Labeled.Labeled(kind, data.data, data.start, data.length))).reverse())); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(_195.bufData, _195.bufStart, _195.bufLen)); + rs.byteVecPush(out, SCANNER.read & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(Labeled.sum$u8(new Labeled.Labeled(kind, data.data, data.start, data.length))).reverse())); const g: Sentry.Sentry = new Sentry.Sentry(data.data, data.start, data.length, out); - const _208: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(g.bufData, g.bufStart, g.bufLen), rt.min(g.bufLen, 2)); + const _208: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(g.bufData, g.bufStart, g.bufLen), rs.min(g.bufLen, 2)); g.bufData = _208.data; g.bufStart = _208.start; g.bufLen = _208.length; - rt.byteVecPush(g.out, option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(g.bufData, g.bufStart, g.bufLen)), 0)); + rs.byteVecPush(g.out, option_unwrapOr$1fr498u(rs.byteSliceFirst(new rs.ByteSlice(g.bufData, g.bufStart, g.bufLen)), 0)); g[Symbol.dispose](); } diff --git a/ts/fixtures/lang/fields/expected/harness.ts b/ts/fixtures/lang/fields/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/fields/expected/harness.ts +++ b/ts/fixtures/lang/fields/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/fields/expected/lib.ts b/ts/fixtures/lang/fields/expected/lib.ts index 3589fb4e7..f7f1d1961 100644 --- a/ts/fixtures/lang/fields/expected/lib.ts +++ b/ts/fixtures/lang/fields/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { fields } from "./fields.ts"; import type * as Couple from "./fields.Couple.ts"; @@ -12,8 +12,8 @@ export function copy$fields_Couple(v: Couple.Couple): Couple.Couple { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["fields::fields", fields as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["fields::fields", fields as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/floats/expected/core/option.ts b/ts/fixtures/lang/floats/expected/core/option.ts index e5dca53c1..c7d86c3b5 100644 --- a/ts/fixtures/lang/floats/expected/core/option.ts +++ b/ts/fixtures/lang/floats/expected/core/option.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1ayoj7n(self: rt.f64 | undefined, default_: rt.f64): rt.f64 { +export function unwrapOr$1wlr8ha(self: rs.f64 | undefined, default_: rs.f64): rs.f64 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$15zxk73(self: rt.u8 | undefined, default_: rt.u64, f: (a0: rt.u8) => rt.u64): rt.u64 { +export function mapOr$1imzf9s(self: rs.u8 | undefined, default_: rs.u64, f: (a0: rs.u8) => rs.u64): rs.u64 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/floats/expected/floats.Gauge.ts b/ts/fixtures/lang/floats/expected/floats.Gauge.ts index 9eee4bb70..24c8eab20 100644 --- a/ts/fixtures/lang/floats/expected/floats.Gauge.ts +++ b/ts/fixtures/lang/floats/expected/floats.Gauge.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Gauge, other: Gauge): boolean { if (!(self.level === other.level)) { @@ -15,8 +15,8 @@ export function default$Default(): Gauge { /** A struct with an `f64` field, changed in place through a `&mut`. */ export interface Gauge { - level: rt.f64; - peak: rt.f64 | undefined; + level: rs.f64; + peak: rs.f64 | undefined; } //# sourceMappingURL=floats.Gauge.ts.map diff --git a/ts/fixtures/lang/floats/expected/floats.Reading.ts b/ts/fixtures/lang/floats/expected/floats.Reading.ts index 9f7dbc572..d39210ead 100644 --- a/ts/fixtures/lang/floats/expected/floats.Reading.ts +++ b/ts/fixtures/lang/floats/expected/floats.Reading.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Reading, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Reading, f: rs.Formatter): rs.Result { const _3: string = "Reading"; const _4: string = "level"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.f64Debug(self.level, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.f64Debug(self.level, f); const _7: string = "peak"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.peak, f, rt.f64Debug); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.peak, f, rs.f64Debug); const _10: string = "history"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.history.items, f, rt.f64Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f64Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } /** A reading whose derived `Debug` writes each `f64` with the placeholder's options. */ export interface Reading { - level: rt.f64; - peak: rt.f64 | undefined; - history: rt.Vec; + level: rs.f64; + peak: rs.f64 | undefined; + history: rs.Vec; } //# sourceMappingURL=floats.Reading.ts.map diff --git a/ts/fixtures/lang/floats/expected/floats.ts b/ts/fixtures/lang/floats/expected/floats.ts index 69c7a0959..3344cb76f 100644 --- a/ts/fixtures/lang/floats/expected/floats.ts +++ b/ts/fixtures/lang/floats/expected/floats.ts @@ -1,70 +1,70 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$1ayoj7n as option_unwrapOr$1ayoj7n, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$15zxk73 as option_mapOr$15zxk73 } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1wlr8ha as option_unwrapOr$1wlr8ha, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, mapOr$1imzf9s as option_mapOr$1imzf9s } from "./core/option.ts"; import * as Gauge from "./floats.Gauge.ts"; import * as Reading from "./floats.Reading.ts"; import { put } from "./harness.ts"; /** An `f64` from the front of `data`, its bits big-endian and zero-padded. */ -export function take(data: rt.ByteSlice): [rt.f64, rt.ByteSlice] { - const _4: [rt.u64, rt.ByteSlice] = takeBits(data); - return [rt.f64FromBits(_4[0]), _4[1]] as [rt.f64, rt.ByteSlice]; +export function take(data: rs.ByteSlice): [rs.f64, rs.ByteSlice] { + const _4: [rs.u64, rs.ByteSlice] = takeBits(data); + return [rs.f64FromBits(_4[0]), _4[1]] as [rs.f64, rs.ByteSlice]; } /** The bits [`take`] reads, as a seed, which no NaN quieted on the way. */ -export function takeBits(data: rt.ByteSlice): [rt.u64, rt.ByteSlice] { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - return [rt.u64FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u64, rt.ByteSlice]; +export function takeBits(data: rs.ByteSlice): [rs.u64, rs.ByteSlice] { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + return [rs.u64FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.u64, rs.ByteSlice]; } /** `x`'s bits, any NaN as `f64::NAN`'s. */ -export function putF64(out: rt.ByteVec, x: rt.f64): void { - let x2!: rt.f64; +export function putF64(out: rs.ByteVec, x: rs.f64): void { + let x2!: rs.f64; if (!Number.isNaN(x)) { x2 = x; } else { x2 = NaN; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(x2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(x2)))); } -export function putDuration(out: rt.ByteVec, d: rt.Duration): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.durationAsSecs(d)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.durationSubsecNanos(d)))); +export function putDuration(out: rs.ByteVec, d: rs.Duration): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.durationAsSecs(d)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.durationSubsecNanos(d)))); } /** What `try_from_secs_f64` made, or its error printed both ways. */ -export function putSecs(out: rt.ByteVec, d: rt.Result): void { +export function putSecs(out: rs.ByteVec, d: rs.Result): void { if (d.ok) { putDuration(out, d.value); } else { - const e: rt.TryFromFloatSecsError = d.error; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", rt.fmtSpec({ alternate: true }, args2[1])])); + const e: rs.TryFromFloatSecsError = d.error; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", rs.fmtSpec({ alternate: true }, args2[1])])); } } -export function raise(level: rt.Place, by: rt.f64): void { +export function raise(level: rs.Place, by: rs.f64): void { level.v = level.v + by; level.v = level.v * 2.0; } -export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function floats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let zeros!: boolean; - let _242!: rt.f64; - const _6: [rt.f64, rt.ByteSlice] = take(data); - const a: rt.f64 = _6[0]; - const _9: [rt.f64, rt.ByteSlice] = take(_6[1]); - const b: rt.f64 = _9[0]; - const _10: rt.u8 = rt.u8Rem(kind, 10); + let _242!: rs.f64; + const _6: [rs.f64, rs.ByteSlice] = take(data); + const a: rs.f64 = _6[0]; + const _9: [rs.f64, rs.ByteSlice] = take(_6[1]); + const b: rs.f64 = _9[0]; + const _10: rs.u8 = rs.u8Rem(kind, 10); if (_10 === 0) { - const iter: rt.Iter = rt.iterSlice([a + b, a - b, a * b, a / b, a % b, -a, a + 1.5, 0.1 * a]); + const iter: rs.Iter = rs.iterSlice([a + b, a - b, a * b, a / b, a % b, -a, a + 1.5, 0.1 * a]); while (true) { - const _23: rt.f64 | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: rs.f64 | rs.Done = iter.next(); + if (_23 === rs.DONE) { break; } putF64(out, _23); @@ -76,17 +76,17 @@ export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const _34: boolean = a > b; const _35: boolean = a >= b; const _36: boolean = a === 0.0; - const _37: boolean = rt.f64PartialCmp(a, b) === -1; - const order = rt.f64PartialCmp(a, b); - const iter2: rt.Iter = rt.iterSlice([_30, _31, _32, _33, _34, _35, _36, _37, order !== undefined && order >= 0]); + const _37: boolean = rs.f64PartialCmp(a, b) === -1; + const order = rs.f64PartialCmp(a, b); + const iter2: rs.Iter = rs.iterSlice([_30, _31, _32, _33, _34, _35, _36, _37, order !== undefined && order >= 0]); while (true) { - const _45: boolean | rt.Done = iter2.next(); - if (_45 === rt.DONE) { + const _45: boolean | rs.Done = iter2.next(); + if (_45 === rs.DONE) { break; } - rt.byteVecPush(out, _45 ? 1 : 0); + rs.byteVecPush(out, _45 ? 1 : 0); } - let c: rt.f64 = a; + let c: rs.f64 = a; c = c + b; c = c - 0.25; c = c * b; @@ -94,55 +94,55 @@ export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { c = c % a; putF64(out, c); } else if (_10 === 1) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.u8FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.u16FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.usizeFromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(rt.i8FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(rt.i16FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(rt.i32FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128FromF64(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeFromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.u8FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.u16FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.usizeFromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(rs.i8FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.i16FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(rs.i32FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128FromF64(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(rs.isizeFromF64(a)))); } else if (_10 === 2) { - const wide: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, 16); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(data, 0, n)); - const v: rt.u128 = rt.u128FromBeBytes(wide); - const iter3: rt.Iter = rt.iterSlice([(rt.u128Low(v) & 0xff) as rt.f64, (rt.u128Low(v) & 0xffff) as rt.f64, rt.u128Low(v) as rt.f64, rt.u64ToF64(rt.u64Cast(v)), rt.u128ToF64(v), rt.u128Low(v) as rt.f64, (rt.u128Low(v) << 24) >> 24 as rt.f64, (rt.u128Low(v) << 16) >> 16 as rt.f64, (rt.u128Low(v) | 0) as rt.f64, rt.i64ToF64(rt.i64Cast(v)), rt.i128ToF64(rt.i128Cast(v)), (rt.u128Low(v) | 0) as rt.f64, rt.u128Low(v) as rt.f64, (rt.u128Low(v) << 16) >> 16 as rt.f64, rt.u128And(v, 1) === 1 ? 1.0 : 0.0, (rt.u128Low(v) & 0xff) as rt.f64, 1.8446744073709552e19, -9.223372036854776e18, 3.402823669209385e38]); + const wide: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, 16); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(wide), 0, n), rs.byteSliceRange(data, 0, n)); + const v: rs.u128 = rs.u128FromBeBytes(wide); + const iter3: rs.Iter = rs.iterSlice([(rs.u128Low(v) & 0xff) as rs.f64, (rs.u128Low(v) & 0xffff) as rs.f64, rs.u128Low(v) as rs.f64, rs.u64ToF64(rs.u64Cast(v)), rs.u128ToF64(v), rs.u128Low(v) as rs.f64, (rs.u128Low(v) << 24) >> 24 as rs.f64, (rs.u128Low(v) << 16) >> 16 as rs.f64, (rs.u128Low(v) | 0) as rs.f64, rs.i64ToF64(rs.i64Cast(v)), rs.i128ToF64(rs.i128Cast(v)), (rs.u128Low(v) | 0) as rs.f64, rs.u128Low(v) as rs.f64, (rs.u128Low(v) << 16) >> 16 as rs.f64, rs.u128And(v, 1) === 1 ? 1.0 : 0.0, (rs.u128Low(v) & 0xff) as rs.f64, 1.8446744073709552e19, -9.223372036854776e18, 3.402823669209385e38]); while (true) { - const _163: rt.f64 | rt.Done = iter3.next(); - if (_163 === rt.DONE) { + const _163: rs.f64 | rs.Done = iter3.next(); + if (_163 === rs.DONE) { break; } putF64(out, _163); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromF64(rt.u64ToF64(rt.u64Cast(v)))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128FromF64(rt.i128ToF64(rt.i128Cast(v)))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromF64(rs.u64ToF64(rs.u64Cast(v)))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128FromF64(rs.i128ToF64(rs.i128Cast(v)))))); } else if (_10 === 3) { - const iter4: rt.Iter = rt.iterSlice([Math.floor(a), Math.ceil(a), Math.trunc(a), rt.f64Round(a), rt.f64RoundTiesEven(a), rt.f64Fract(a), Math.abs(a), rt.f64Signum(a), Math.sqrt(a), 1 / a, a * 57.29577951308232, a * 0.017453292519943295]); + const iter4: rs.Iter = rs.iterSlice([Math.floor(a), Math.ceil(a), Math.trunc(a), rs.f64Round(a), rs.f64RoundTiesEven(a), rs.f64Fract(a), Math.abs(a), rs.f64Signum(a), Math.sqrt(a), 1 / a, a * 57.29577951308232, a * 0.017453292519943295]); while (true) { - const _197: rt.f64 | rt.Done = iter4.next(); - if (_197 === rt.DONE) { + const _197: rs.f64 | rs.Done = iter4.next(); + if (_197 === rs.DONE) { break; } putF64(out, _197); } } else if (_10 === 4) { - const iter5: rt.Iter = rt.iterSlice([Number.isNaN(a), Number.isFinite(a), rt.f64IsInfinite(a), rt.f64IsNormal(a), rt.f64IsSubnormal(a), rt.f64IsSignPositive(a), rt.f64IsSignNegative(a)]); + const iter5: rs.Iter = rs.iterSlice([Number.isNaN(a), Number.isFinite(a), rs.f64IsInfinite(a), rs.f64IsNormal(a), rs.f64IsSubnormal(a), rs.f64IsSignPositive(a), rs.f64IsSignNegative(a)]); while (true) { - const _212: boolean | rt.Done = iter5.next(); - if (_212 === rt.DONE) { + const _212: boolean | rs.Done = iter5.next(); + if (_212 === rs.DONE) { break; } - rt.byteVecPush(out, _212 ? 1 : 0); + rs.byteVecPush(out, _212 ? 1 : 0); } - const iter6: rt.Iter = rt.iterSlice([rt.f64Copysign(a, b), rt.f64Copysign(1.5, a), rt.f64NextUp(a), rt.f64NextDown(a)]); + const iter6: rs.Iter = rs.iterSlice([rs.f64Copysign(a, b), rs.f64Copysign(1.5, a), rs.f64NextUp(a), rs.f64NextDown(a)]); while (true) { - const _225: rt.f64 | rt.Done = iter6.next(); - if (_225 === rt.DONE) { + const _225: rs.f64 | rs.Done = iter6.next(); + if (_225 === rs.DONE) { break; } putF64(out, _225); @@ -153,13 +153,13 @@ export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { zeros = b === 0.0; } - const iter7: rt.Iter = rt.iterSlice([rt.f64Max(a, b), rt.f64Min(a, b)]); + const iter7: rs.Iter = rs.iterSlice([rs.f64Max(a, b), rs.f64Min(a, b)]); while (true) { - const _237: rt.f64 | rt.Done = iter7.next(); - if (_237 === rt.DONE) { + const _237: rs.f64 | rs.Done = iter7.next(); + if (_237 === rs.DONE) { break; } - const x5: rt.f64 = _237; + const x5: rs.f64 = _237; if (!zeros) { _242 = x5; } else { @@ -167,101 +167,101 @@ export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } putF64(out, _242); } - const iter8: rt.Iter = rt.iterSlice([rt.f64Midpoint(a, b), rt.f64DivEuclid(a, b), rt.f64RemEuclid(a, b)]); + const iter8: rs.Iter = rs.iterSlice([rs.f64Midpoint(a, b), rs.f64DivEuclid(a, b), rs.f64RemEuclid(a, b)]); while (true) { - const _250: rt.f64 | rt.Done = iter8.next(); - if (_250 === rt.DONE) { + const _250: rs.f64 | rs.Done = iter8.next(); + if (_250 === rs.DONE) { break; } putF64(out, _250); } - rt.byteVecPush(out, rt.f64TotalCmp(a, b) & 0xff); - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.f64PartialCmp(a, b), 9, (o: rt.Ordering): rt.u8 => { + rs.byteVecPush(out, rs.f64TotalCmp(a, b) & 0xff); + rs.byteVecPush(out, option_mapOr$14runhi(rs.f64PartialCmp(a, b), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); } else if (_10 === 6) { if (!Number.isNaN(a)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(a)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f64ToBeBytes(a))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f64ToLeBytes(a))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f64ToLeBytes(a))); - const be: Uint8Array = rt.f64ToBeBytes(a); - const le: Uint8Array = rt.f64ToLeBytes(a); - const iter9: rt.Iter = rt.iterSlice([rt.f64FromBeBytes(be), rt.f64FromLeBytes(le), rt.f64FromLeBytes(le)]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f64ToBeBytes(a))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f64ToLeBytes(a))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f64ToLeBytes(a))); + const be: Uint8Array = rs.f64ToBeBytes(a); + const le: Uint8Array = rs.f64ToLeBytes(a); + const iter9: rs.Iter = rs.iterSlice([rs.f64FromBeBytes(be), rs.f64FromLeBytes(le), rs.f64FromLeBytes(le)]); while (true) { - const _292: rt.f64 | rt.Done = iter9.next(); - if (_292 === rt.DONE) { + const _292: rs.f64 | rs.Done = iter9.next(); + if (_292 === rs.DONE) { break; } putF64(out, _292); } } - putF64(out, rt.f64FromBits(rt.u64Xor(rt.f64ToBits(a), 1))); + putF64(out, rs.f64FromBits(rs.u64Xor(rs.f64ToBits(a), 1))); } else if (_10 === 7) { - const n2: rt.i32 = rt.i32Rem(rt.u64Low(rt.f64ToBits(b)) | 0, 64); - const _310: [rt.f64, rt.f64] = rt.f64SinCos(a); - const s: rt.f64 = _310[0]; - const c2: rt.f64 = _310[1]; - const iter10: rt.Iter = rt.iterSlice([Math.sin(a), Math.cos(a), Math.tan(a), Math.asin(a), Math.acos(a), Math.atan(a), Math.atan2(a, b), Math.sinh(a), Math.cosh(a), Math.tanh(a), Math.asinh(a), Math.acosh(a), rt.f64Atanh(a), Math.exp(a), Math.pow(2, a), Math.expm1(a), Math.log(a), Math.log(a) / Math.log(b), Math.log2(a), Math.log10(a), Math.log1p(a), rt.f64Powf(a, b), rt.f64Powi(a, n2), Math.cbrt(a), Math.hypot(a, b), s, c2]); + const n2: rs.i32 = rs.i32Rem(rs.u64Low(rs.f64ToBits(b)) | 0, 64); + const _310: [rs.f64, rs.f64] = rs.f64SinCos(a); + const s: rs.f64 = _310[0]; + const c2: rs.f64 = _310[1]; + const iter10: rs.Iter = rs.iterSlice([Math.sin(a), Math.cos(a), Math.tan(a), Math.asin(a), Math.acos(a), Math.atan(a), Math.atan2(a, b), Math.sinh(a), Math.cosh(a), Math.tanh(a), Math.asinh(a), Math.acosh(a), rs.f64Atanh(a), Math.exp(a), Math.pow(2, a), Math.expm1(a), Math.log(a), Math.log(a) / Math.log(b), Math.log2(a), Math.log10(a), Math.log1p(a), rs.f64Powf(a, b), rs.f64Powi(a, n2), Math.cbrt(a), Math.hypot(a, b), s, c2]); while (true) { - const _339: rt.f64 | rt.Done = iter10.next(); - if (_339 === rt.DONE) { + const _339: rs.f64 | rs.Done = iter10.next(); + if (_339 === rs.DONE) { break; } putF64(out, _339); } } else if (_10 === 8) { - const d: rt.Duration = rt.durationNew(rt.u64Shl(option_mapOr$15zxk73(rt.byteSliceFirst(_9[1]), 0, (_2: rt.u8): rt.u64 => { - return _2 as rt.u64; + const d: rs.Duration = rs.durationNew(rs.u64Shl(option_mapOr$1imzf9s(rs.byteSliceFirst(_9[1]), 0, (_2: rs.u8): rs.u64 => { + return _2 as rs.u64; }), 20), 123456789); - putF64(out, rt.durationAsSecsF64(d)); - const _355: rt.Duration = rt.durationFromMillis(1500); - putF64(out, rt.durationDivDurationF64(d, _355)); - putF64(out, rt.durationDivDurationF64({ secs: 0, nanos: 0 }, { secs: 0, nanos: 0 })); - putSecs(out, rt.durationTryFromSecsF64(a)); - putSecs(out, rt.durationTryFromSecsF64(Math.abs(a))); - putSecs(out, rt.durationTryFromSecsF64(Math.abs(a) * 1e-9)); - const _367: rt.u8 = rt.u8Rem(rt.u8Div(kind, 10), 4); + putF64(out, rs.durationAsSecsF64(d)); + const _355: rs.Duration = rs.durationFromMillis(1500); + putF64(out, rs.durationDivDurationF64(d, _355)); + putF64(out, rs.durationDivDurationF64({ secs: 0, nanos: 0 }, { secs: 0, nanos: 0 })); + putSecs(out, rs.durationTryFromSecsF64(a)); + putSecs(out, rs.durationTryFromSecsF64(Math.abs(a))); + putSecs(out, rs.durationTryFromSecsF64(Math.abs(a) * 1e-9)); + const _367: rs.u8 = rs.u8Rem(rs.u8Div(kind, 10), 4); if (_367 === 0) { - putDuration(out, rt.durationFromSecsF64(a)); + putDuration(out, rs.durationFromSecsF64(a)); } else if (_367 === 1) { - putDuration(out, rt.durationMulF64(d, a)); + putDuration(out, rs.durationMulF64(d, a)); } else if (_367 === 2) { - putDuration(out, rt.durationDivF64(d, a)); + putDuration(out, rs.durationDivF64(d, a)); } else { - putDuration(out, rt.durationMulF64({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, b)); + putDuration(out, rs.durationMulF64({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, b)); } } else { - const iter11: rt.Iter = rt.iterSlice([1.7976931348623157e308, -1.7976931348623157e308, 2.2250738585072014e-308, 2.220446049250313e-16, Infinity, -Infinity, NaN, -0.0, 3.141592653589793, 6.283185307179586, 2.718281828459045, 1.4142135623730951, 0.7071067811865476, 0.6931471805599453, 2.302585092994046, 1.4426950408889634, 0.4342944819032518, 1.5707963267948966, 0.3183098861837907, 1e-300, 123456789.125, 0.5]); + const iter11: rs.Iter = rs.iterSlice([1.7976931348623157e308, -1.7976931348623157e308, 2.2250738585072014e-308, 2.220446049250313e-16, Infinity, -Infinity, NaN, -0.0, 3.141592653589793, 6.283185307179586, 2.718281828459045, 1.4142135623730951, 0.7071067811865476, 0.6931471805599453, 2.302585092994046, 1.4426950408889634, 0.4342944819032518, 1.5707963267948966, 0.3183098861837907, 1e-300, 123456789.125, 0.5]); while (true) { - const _377: rt.f64 | rt.Done = iter11.next(); - if (_377 === rt.DONE) { + const _377: rs.f64 | rs.Done = iter11.next(); + if (_377 === rs.DONE) { break; } putF64(out, _377); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(rt.f64FromBits({ hi: 0xfff80000, lo: 0x123 } as rt.u64))))); - rt.byteVecPush(out, rt.f64IsSignNegative(rt.f64FromBits({ hi: 0xfff80000, lo: 0x123 } as rt.u64)) ? 1 : 0); - const v2: rt.f64[] = [a, b, 0.5]; - putF64(out, rt.iterSum(rt.iterSlice(v2), rt.f64Add, -0.0)); - putF64(out, rt.iterProduct(rt.iterSlice(v2), rt.f64Mul, 1.0)); - const _403: rt.f64[] = []; - putF64(out, rt.iterSum(rt.iterSlice(_403), rt.f64Add, -0.0)); - putF64(out, rt.iterSum(rt.iterSlice([-0.0, -0.0]), rt.f64Add, -0.0)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(rs.f64FromBits({ hi: 0xfff80000, lo: 0x123 } as rs.u64))))); + rs.byteVecPush(out, rs.f64IsSignNegative(rs.f64FromBits({ hi: 0xfff80000, lo: 0x123 } as rs.u64)) ? 1 : 0); + const v2: rs.f64[] = [a, b, 0.5]; + putF64(out, rs.iterSum(rs.iterSlice(v2), rs.f64Add, -0.0)); + putF64(out, rs.iterProduct(rs.iterSlice(v2), rs.f64Mul, 1.0)); + const _403: rs.f64[] = []; + putF64(out, rs.iterSum(rs.iterSlice(_403), rs.f64Add, -0.0)); + putF64(out, rs.iterSum(rs.iterSlice([-0.0, -0.0]), rs.f64Add, -0.0)); putF64(out, 0.0); const g: Gauge.Gauge = { level: a, peak: b }; - raise(rt.place(() => g.level, (value) => g.level = value), b); + raise(rs.place(() => g.level, (value) => g.level = value), b); if (g.peak !== undefined) { - const _417: rt.f64 = rt.f64Max(g.peak, g.level); + const _417: rs.f64 = rs.f64Max(g.peak, g.level); g.peak = _417; } putF64(out, g.level); - putF64(out, option_unwrapOr$1ayoj7n(g.peak, -1.0)); + putF64(out, option_unwrapOr$1wlr8ha(g.peak, -1.0)); const _430: Gauge.Gauge = Gauge.default$Default(); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq(g, _430) ? 1 : 0); - rt.byteVecPush(out, g.peak === b ? 1 : 0); - let local: rt.f64 = a; - raise(rt.place(() => local, (value2) => local = value2), 1.0); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq(g, _430) ? 1 : 0); + rs.byteVecPush(out, g.peak === b ? 1 : 0); + let local: rs.f64 = a; + raise(rs.place(() => local, (value2) => local = value2), 1.0); putF64(out, local); } } @@ -273,90 +273,90 @@ export function floats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * each side of where the runtime's fast path ends. Each result follows its operands, which * `fma.ts` rounds exactly where native's differs. */ -export function mulAdds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _52!: [rt.f64, rt.f64, rt.f64]; - let _102!: rt.f64; - let ea4!: rt.i64; +export function mulAdds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _52!: [rs.f64, rs.f64, rs.f64]; + let _102!: rs.f64; + let ea4!: rs.i64; b0: { - if (!(rt.u8Rem(kind, 2) === 0)) { - let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 32; + if (!(rs.u8Rem(kind, 2) === 0)) { + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 32; while (true) { if (!(iterStart++ < iterEnd)) { break b0; } - const r: rt.u64 = step(rt.place(() => state, (value) => state = value)); - const pick: (a0: rt.u32, a1: rt.u64) => rt.i64 = (shift: rt.u32, n: rt.u64): rt.i64 => { - return rt.i64Cast(rt.u64Rem(rt.u64Shr(r, shift), n)); + const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); + const pick: (a0: rs.u32, a1: rs.u64) => rs.i64 = (shift: rs.u32, n: rs.u64): rs.i64 => { + return rs.i64Cast(rs.u64Rem(rs.u64Shr(r, shift), n)); }; - const ea: rt.i64 = rt.i64Sub(pick(8, 64), 32); - const e: rt.i64 = rt.i64Sub(pick(16, 64), 32); - const a2: rt.f64 = near(step(rt.place(() => state, (value2) => state = value2)), ea); - const b2: rt.f64 = near(step(rt.place(() => state, (value3) => state = value3)), rt.i64Sub(e, ea)); - const c2: rt.u64 = step(rt.place(() => state, (value4) => state = value4)); - const _53: rt.u64 = rt.u64Rem(r, 6); + const ea: rs.i64 = rs.i64Sub(pick(8, 64), 32); + const e: rs.i64 = rs.i64Sub(pick(16, 64), 32); + const a2: rs.f64 = near(step(rs.place(() => state, (value2) => state = value2)), ea); + const b2: rs.f64 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i64Sub(e, ea)); + const c2: rs.u64 = step(rs.place(() => state, (value4) => state = value4)); + const _53: rs.u64 = rs.u64Rem(r, 6); if (_53 === 0) { - _52 = [rt.f64FromBits(r), rt.f64FromBits(step(rt.place(() => state, (value5) => state = value5))), rt.f64FromBits(c2)] as [rt.f64, rt.f64, rt.f64]; + _52 = [rs.f64FromBits(r), rs.f64FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f64FromBits(c2)] as [rs.f64, rs.f64, rs.f64]; } else if (_53 === 1) { - _52 = [a2, b2, -(a2 * b2)] as [rt.f64, rt.f64, rt.f64]; + _52 = [a2, b2, -(a2 * b2)] as [rs.f64, rs.f64, rs.f64]; } else if (_53 === 2) { - if (!(rt.u64Shr(r, 63) === 0)) { - const c4: rt.f64 = near(c2, e); - _52 = [a2, (rt.f64NextUp(Math.abs(c4)) - Math.abs(c4)) * 0.5 / a2, c4] as [rt.f64, rt.f64, rt.f64]; + if (!(rs.u64Shr(r, 63) === 0)) { + const c4: rs.f64 = near(c2, e); + _52 = [a2, (rs.f64NextUp(Math.abs(c4)) - Math.abs(c4)) * 0.5 / a2, c4] as [rs.f64, rs.f64, rs.f64]; } else { - const p: rt.f64 = Math.abs(a2 * b2); - const _70: rt.usize = rt.i64Low(pick(24, 5)); + const p: rs.f64 = Math.abs(a2 * b2); + const _70: rs.usize = rs.i64Low(pick(24, 5)); if (!(_70 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _70); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _70); } - const half: rt.f64 = [0.5, -0.5, 0.25, -0.75, 1.5][_70]; - _52 = [a2, b2, (rt.f64NextUp(p) - p) * half] as [rt.f64, rt.f64, rt.f64]; + const half: rs.f64 = [0.5, -0.5, 0.25, -0.75, 1.5][_70]; + _52 = [a2, b2, (rs.f64NextUp(p) - p) * half] as [rs.f64, rs.f64, rs.f64]; } } else if (_53 === 3) { - const ea2: rt.i64 = rt.i64Sub(pick(24, 1000), 500); - const e2: rt.i64 = rt.i64Sub(-1000, pick(40, 100)); - const _97: [rt.f64, rt.f64] = [near(r, ea2), near(c2, rt.i64Sub(e2, ea2))]; - const a4: rt.f64 = _97[0]; - const b4: rt.f64 = _97[1]; - if (!(rt.u64Shr(r, 63) === 0)) { - _102 = near(rt.u64Shr(c2, 1), rt.i64Sub(rt.i64Add(e2, pick(48, 60)), 30)); + const ea2: rs.i64 = rs.i64Sub(pick(24, 1000), 500); + const e2: rs.i64 = rs.i64Sub(-1000, pick(40, 100)); + const _97: [rs.f64, rs.f64] = [near(r, ea2), near(c2, rs.i64Sub(e2, ea2))]; + const a4: rs.f64 = _97[0]; + const b4: rs.f64 = _97[1]; + if (!(rs.u64Shr(r, 63) === 0)) { + _102 = near(rs.u64Shr(c2, 1), rs.i64Sub(rs.i64Add(e2, pick(48, 60)), 30)); } else { _102 = -(a4 * b4); } - _52 = [a4, b4, _102] as [rt.f64, rt.f64, rt.f64]; + _52 = [a4, b4, _102] as [rs.f64, rs.f64, rs.f64]; } else if (_53 === 4) { - const ea3: rt.i64 = rt.i64Add(990, pick(24, 60)); - const a5: rt.f64 = near(r, ea3); - const b5: rt.f64 = near(c2, rt.i64Sub(rt.i64Add(rt.i64Sub(1023, ea3), pick(40, 4)), 1)); - _52 = [a5, b5, rt.f64Copysign(near(rt.u64Shr(c2, 1), rt.i64Add(1020, pick(48, 4))), -(a5 * b5))] as [rt.f64, rt.f64, rt.f64]; + const ea3: rs.i64 = rs.i64Add(990, pick(24, 60)); + const a5: rs.f64 = near(r, ea3); + const b5: rs.f64 = near(c2, rs.i64Sub(rs.i64Add(rs.i64Sub(1023, ea3), pick(40, 4)), 1)); + _52 = [a5, b5, rs.f64Copysign(near(rs.u64Shr(c2, 1), rs.i64Add(1020, pick(48, 4))), -(a5 * b5))] as [rs.f64, rs.f64, rs.f64]; } else { - if (!(rt.u64Shr(r, 63) === 0)) { - ea4 = rt.i64Sub(pick(24, 1000), 500); + if (!(rs.u64Shr(r, 63) === 0)) { + ea4 = rs.i64Sub(pick(24, 1000), 500); } else { - ea4 = rt.i64Add(990, pick(24, 10)); + ea4 = rs.i64Add(990, pick(24, 10)); } - const _161: [rt.f64, rt.f64] = [near(r, ea4), near(c2, rt.i64Sub(rt.i64Sub(rt.i64Add(-968, pick(40, 8)), 4), ea4))]; - const a6: rt.f64 = _161[0]; - const b6: rt.f64 = _161[1]; - const p2: rt.f64 = Math.abs(a6 * b6); - _52 = [a6, b6, (rt.f64NextUp(p2) - p2) * 0.5] as [rt.f64, rt.f64, rt.f64]; + const _161: [rs.f64, rs.f64] = [near(r, ea4), near(c2, rs.i64Sub(rs.i64Sub(rs.i64Add(-968, pick(40, 8)), 4), ea4))]; + const a6: rs.f64 = _161[0]; + const b6: rs.f64 = _161[1]; + const p2: rs.f64 = Math.abs(a6 * b6); + _52 = [a6, b6, (rs.f64NextUp(p2) - p2) * 0.5] as [rs.f64, rs.f64, rs.f64]; } putMulAdd(out, _52[0], _52[1], _52[2]); } } - const _9: [rt.f64, rt.ByteSlice] = take(data); - const a: rt.f64 = _9[0]; - const _12: [rt.f64, rt.ByteSlice] = take(_9[1]); + const _9: [rs.f64, rs.ByteSlice] = take(data); + const a: rs.f64 = _9[0]; + const _12: [rs.f64, rs.ByteSlice] = take(_9[1]); putMulAdd(out, a, _12[0], take(_12[1])[0]); } } -export function putMulAdd(out: rt.ByteVec, a: rt.f64, b: rt.f64, c: rt.f64): void { - const iter: rt.Iter = rt.iterSlice([a, b, c, rt.f64MulAdd(a, b, c)]); +export function putMulAdd(out: rs.ByteVec, a: rs.f64, b: rs.f64, c: rs.f64): void { + const iter: rs.Iter = rs.iterSlice([a, b, c, rs.f64MulAdd(a, b, c)]); while (true) { - const _9: rt.f64 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.f64 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } putF64(out, _9); @@ -364,15 +364,15 @@ export function putMulAdd(out: rt.ByteVec, a: rt.f64, b: rt.f64, c: rt.f64): voi } /** A double of exponent `e`, or the nearest a finite one has, with the significand and sign of `bits`. */ -export function near(bits: rt.u64, e: rt.i64): rt.f64 { - return rt.f64FromBits(rt.u64Or(rt.u64And(bits, { hi: 0x800fffff, lo: 0xffffffff } as rt.u64), rt.u64Shl(rt.u64Cast(rt.i64Clamp(rt.i64Add(e, 1023), 0, 2046)), 52))); +export function near(bits: rs.u64, e: rs.i64): rs.f64 { + return rs.f64FromBits(rs.u64Or(rs.u64And(bits, { hi: 0x800fffff, lo: 0xffffffff } as rs.u64), rs.u64Shl(rs.u64Cast(rs.i64Clamp(rs.i64Add(e, 1023), 0, 2046)), 52))); } /** xorshift64, for the doubles and decimals a case makes from its seed. */ -export function step(state: rt.Place): rt.u64 { - state.v = rt.u64Xor(state.v, rt.u64Shl(state.v, 13)); - state.v = rt.u64Xor(state.v, rt.u64Shr(state.v, 7)); - state.v = rt.u64Xor(state.v, rt.u64Shl(state.v, 17)); +export function step(state: rs.Place): rs.u64 { + state.v = rs.u64Xor(state.v, rs.u64Shl(state.v, 13)); + state.v = rs.u64Xor(state.v, rs.u64Shr(state.v, 7)); + state.v = rs.u64Xor(state.v, rs.u64Shl(state.v, 17)); return state.v; } @@ -380,52 +380,52 @@ export function step(state: rt.Place): rt.u64 { * `f64`'s `Display`, `Debug`, `LowerExp`, and `UpperExp`, with a precision from the byte * after the double, which rounds the exact value half to even, and every other option. */ -export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.f64, rt.ByteSlice] = take(data); - const a: rt.f64 = _6[0]; - const p: rt.usize = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_6[1]), 0) as rt.usize; +export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.f64, rs.ByteSlice] = take(data); + const a: rs.f64 = _6[0]; + const p: rs.usize = option_unwrapOr$1fr498u(rs.byteSliceFirst(_6[1]), 0) as rs.usize; b0: { - const w: rt.usize = rt.usizeDiv(p, 4); - const _13: rt.u8 = rt.u8Rem(kind, 5); + const w: rs.usize = rs.usizeDiv(p, 4); + const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(a, f), (f: rt.Formatter) => rt.f64Debug(a, f), (f: rt.Formatter) => rt.f64LowerExp(a, f), (f: rt.Formatter) => rt.f64UpperExp(a, f), rt.fmtCount(p)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[0]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[1]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[2]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[3]), " ", rt.fmtSpec({ plus: true }, args2[0]), " ", rt.fmtSpec({ plus: true }, args2[1]), " ", rt.fmtSpec({ plus: true, precision: rt.fmtCountOf(args2[4]) }, args2[2])])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(a, f), (f: rt.Formatter) => rt.f64LowerExp(a, f), (f: rt.Formatter) => rt.f64Debug(a, f), (f: rt.Formatter) => rt.f64UpperExp(a, f), rt.fmtCount(w), rt.fmtCount(p)]; - put(out, rt.fmtFormat([rt.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rt.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rt.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rt.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rt.fmtSpec({ alternate: true }, args4[2]), "|", rt.fmtSpec({ debugHex: "x" }, args4[2]), "|", rt.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rt.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 10 }, args4[2]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args4[4]), precision: rt.fmtCountOf(args4[5]) }, args4[0]), "|", rt.fmtSpec({ fill: "é", align: "<", width: rt.fmtCountOf(args4[4]) }, args4[2])])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.f64Display(a, f))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f), (f: rs.Formatter) => rs.f64UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 10 }, args4[2]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0]), "|", rs.fmtSpec({ fill: "é", align: "<", width: rs.fmtCountOf(args4[4]) }, args4[2])])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f64Display(a, f))); } else if (_13 === 1) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(a, f), (f: rt.Formatter) => rt.f64LowerExp(a, f), (f: rt.Formatter) => rt.f64Debug(a, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 1100 }, args6[0]), " ", rt.fmtSpec({ precision: 800 }, args6[1]), " ", rt.fmtSpec({ precision: 1100 }, args6[2]), " ", rt.fmtSpec({ precision: 65535 }, args6[0])])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(a, f), (f: rs.Formatter) => rs.f64LowerExp(a, f), (f: rs.Formatter) => rs.f64Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 1100 }, args6[0]), " ", rs.fmtSpec({ precision: 800 }, args6[1]), " ", rs.fmtSpec({ precision: 1100 }, args6[2]), " ", rs.fmtSpec({ precision: 65535 }, args6[0])])); } else if (_13 === 2) { - const _72: [rt.f64, rt.ByteSlice] = take(_6[1]); - const b: rt.f64 = _72[0]; - const c: rt.f64 = take(_72[1])[0]; - putF64(out, rt.f64Clamp(a, b, c)); + const _72: [rs.f64, rs.ByteSlice] = take(_6[1]); + const b: rs.f64 = _72[0]; + const c: rs.f64 = take(_72[1])[0]; + putF64(out, rs.f64Clamp(a, b, c)); } else if (_13 === 3) { - const _78: rt.f64 | undefined = a * 0.5; - const _80: rt.Vec = rt.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); + const _78: rs.f64 | undefined = a * 0.5; + const _80: rs.Vec = rs.vecFrom([a, -0.0, 1e-7, 1e16, NaN]); const part = { level: a, peak: _78, history: _80 }; - const args8: rt.Fmt[] = [(f: rt.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", rt.fmtSpec({ precision: 2 }, args8[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); } else { - let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 64; + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 64; while (iterStart++ < iterEnd) { - const x: rt.f64 = rt.f64FromBits(step(rt.place(() => state, (value) => state = value))); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(x, f), (f: rt.Formatter) => rt.f64Debug(x, f), (f: rt.Formatter) => rt.f64LowerExp(x, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + const x: rs.f64 = rs.f64FromBits(step(rs.place(() => state, (value) => state = value))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); } - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 64; + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 64; while (true) { if (!(iterStart2++ < iterEnd2)) { break b0; } - const r2: rt.u64 = step(rt.place(() => state, (value2) => state = value2)); - const x2: rt.f64 = rt.u64ToF64(rt.u64Shr(r2, 11)) / rt.u64ToF64(rt.u64Shl(1, rt.u64Add(rt.u64Rem(r2, 24), 1))); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Debug(x2, f), (f: rt.Formatter) => rt.f64LowerExp(x2, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1]])); + const r2: rs.u64 = step(rs.place(() => state, (value2) => state = value2)); + const x2: rs.f64 = rs.u64ToF64(rs.u64Shr(r2, 11)) / rs.u64ToF64(rs.u64Shl(1, rs.u64Add(rs.u64Rem(r2, 24), 1))); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(x2, f), (f: rs.Formatter) => rs.f64LowerExp(x2, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1]])); } } } @@ -435,67 +435,67 @@ export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `str::parse::` by std's grammar, with its errors, of the input as text, of bytes * mapped into the grammar's alphabet, or of decimals made from a seed. */ -export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _60!: rt.usize; +export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _60!: rs.usize; b0: { - const _4: rt.u8 = rt.u8Rem(kind, 3); + const _4: rs.u8 = rs.u8Rem(kind, 3); if (_4 === 0) { - const _6: rt.Result = rt.strFromUtf8(data); + const _6: rs.Result = rs.strFromUtf8(data); if (_6.ok) { one(_6.value, out); } } else if (_4 === 1) { let s: string = ""; - for (const b of rt.byteSliceView(data)) { - const _21: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); - const _22: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); - rt.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rt.char); + for (const b of rs.byteSliceView(data)) { + const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); + const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); + rs.idx(_21, _22); + s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); } one(s, out); } else { - let state: rt.u64 = rt.u64Or(takeBits(data)[0], 1); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 16; + let state: rs.u64 = rs.u64Or(takeBits(data)[0], 1); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 16; while (true) { if (!(iterStart++ < iterEnd)) { break b0; } - const r: rt.u64 = step(rt.place(() => state, (value) => state = value)); - const len: rt.usize = rt.u64Low(rt.u64Add(rt.u64Rem(r, 40), 1)); - const point: rt.usize = rt.usizeRem(rt.u64Low(rt.u64Shr(r, 8)), rt.usizeAdd(len, 1)); + const r: rs.u64 = step(rs.place(() => state, (value) => state = value)); + const len: rs.usize = rs.u64Low(rs.u64Add(rs.u64Rem(r, 40), 1)); + const point: rs.usize = rs.usizeRem(rs.u64Low(rs.u64Shr(r, 8)), rs.usizeAdd(len, 1)); let s2: string = ""; - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = len; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = len; while ((_60 = iterStart2++) < iterEnd2) { if (_60 === point) { s2 = s2 + "."; } - const _69: rt.char = rt.u8Add(48, rt.u64Low(rt.u64Rem(step(rt.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rt.char; + const _69: rs.char = rs.u8Add(48, rs.u64Low(rs.u64Rem(step(rs.place(() => state, (value2) => state = value2)), 10)) & 0xff) as rs.char; s2 = s2 + String.fromCodePoint(_69); } - const _85: rt.i64 = rt.i64Sub(rt.i64Cast(rt.u64Rem(rt.u64Shr(r, 16), 700)), 350); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s2), (f: rt.Formatter) => rt.i64Display(_85, f)]; - one(rt.fmtFormat([args2[0], "e", args2[1]]), out); + const _85: rs.i64 = rs.i64Sub(rs.i64Cast(rs.u64Rem(rs.u64Shr(r, 16), 700)), 350); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_85, f)]; + one(rs.fmtFormat([args2[0], "e", args2[1]]), out); } } } } /** What parsing `s` makes: the double's bits and its `Debug`, or the error printed each way. */ -export function one(s: string, out: rt.ByteVec): void { - const _4: rt.Result = rt.f64FromStr(s); +export function one(s: string, out: rs.ByteVec): void { + const _4: rs.Result = rs.f64FromStr(s); if (_4.ok) { - const v: rt.f64 = _4.value; + const v: rs.f64 = _4.value; putF64(out, v); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Debug(v, f)]; - put(out, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Debug(v, f)]; + put(out, rs.fmtFormat([args2[0]])); } else { - const e: rt.ParseFloatError = _4.error; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseFloatErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtParseFloatErrorDebug(e, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", rt.fmtSpec({ alternate: true }, args4[1]), "|", rt.fmtSpec({ align: ">", width: 30 }, args4[0]), "|", rt.fmtSpec({ precision: 7 }, args4[0])])); + const e: rs.ParseFloatError = _4.error; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 30 }, args4[0]), "|", rs.fmtSpec({ precision: 7 }, args4[0])])); } - rt.byteVecPush(out, rt.f64FromStr(s).ok ? 1 : 0); + rs.byteVecPush(out, rs.f64FromStr(s).ok ? 1 : 0); } //# sourceMappingURL=floats.ts.map diff --git a/ts/fixtures/lang/floats/expected/harness.ts b/ts/fixtures/lang/floats/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/floats/expected/harness.ts +++ b/ts/fixtures/lang/floats/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/floats/expected/lib.ts b/ts/fixtures/lang/floats/expected/lib.ts index 8529e7971..e84932e58 100644 --- a/ts/fixtures/lang/floats/expected/lib.ts +++ b/ts/fixtures/lang/floats/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { floats, mulAdds, formats, parses } from "./floats.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["floats::floats", floats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::formats", formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::parses", parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["floats::mul_adds", mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["floats::floats", floats as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["floats::formats", formats as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["floats::parses", parses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["floats::mul_adds", mulAdds as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/folds/expected/core/bool.ts b/ts/fixtures/lang/folds/expected/core/bool.ts index 34b3adb7e..f6a210986 100644 --- a/ts/fixtures/lang/folds/expected/core/bool.ts +++ b/ts/fixtures/lang/folds/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0tjggir(self: boolean, t: rt.i64): rt.i64 | undefined { +export function thenSome$179x8nl(self: boolean, t: rs.i64): rs.i64 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/folds/expected/core/option.ts b/ts/fixtures/lang/folds/expected/core/option.ts index 8031b9007..a53671e99 100644 --- a/ts/fixtures/lang/folds/expected/core/option.ts +++ b/ts/fixtures/lang/folds/expected/core/option.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$13980cl(self: rt.Vec | undefined, f: (a0: rt.Vec) => rt.usize): rt.usize | undefined { +export function map$122xb11(self: rs.Vec | undefined, f: (a0: rs.Vec) => rs.usize): rs.usize | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1c7fhtg(self: rt.ByteVec | undefined, f: (a0: rt.ByteVec) => rt.usize): rt.usize | undefined { +export function map$0qp7by0(self: rs.ByteVec | undefined, f: (a0: rs.ByteVec) => rs.usize): rs.usize | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/folds/expected/core/result.ts b/ts/fixtures/lang/folds/expected/core/result.ts index 1f0b63e6e..1b2887d76 100644 --- a/ts/fixtures/lang/folds/expected/core/result.ts +++ b/ts/fixtures/lang/folds/expected/core/result.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$0ip8nd6(self: rt.Result, undefined>, op: (a0: rt.Vec) => rt.usize): rt.Result { +export function map$1eib7de(self: rs.Result, undefined>, op: (a0: rs.Vec) => rs.usize): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return rt.ERR; + return rs.ERR; } -export function map$1w3j91w(self: rt.Result, op: (a0: rt.ByteVec) => rt.usize): rt.Result { +export function map$0vle1ww(self: rs.Result, op: (a0: rs.ByteVec) => rs.usize): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return rt.ERR; + return rs.ERR; } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/folds/expected/folds.ts b/ts/fixtures/lang/folds/expected/folds.ts index 4905cd16d..000d41739 100644 --- a/ts/fixtures/lang/folds/expected/folds.ts +++ b/ts/fixtures/lang/folds/expected/folds.ts @@ -1,253 +1,253 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0tjggir, thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$13980cl as option_map$13980cl, map$1c7fhtg as option_map$1c7fhtg } from "./core/option.ts"; -import { map$0ip8nd6 as result_map$0ip8nd6, map$1w3j91w as result_map$1w3j91w } from "./core/result.ts"; +import * as rs from "./rs.ts"; +import { thenSome$179x8nl, thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$122xb11 as option_map$122xb11, map$0qp7by0 as option_map$0qp7by0 } from "./core/option.ts"; +import { map$1eib7de as result_map$1eib7de, map$0vle1ww as result_map$0vle1ww } from "./core/result.ts"; import { put } from "./harness.ts"; /** `r`'s state after `v`, what read it returned. */ -export function state$i64_Option_i64(out: rt.ByteVec, v: rt.i64 | undefined, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.i64Debug), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_Option_i64(out: rs.ByteVec, v: rs.i64 | undefined, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.i64Debug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_Option_tuple2_i64_usize(out: rt.ByteVec, v: [rt.i64, rt.usize] | undefined, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.i64, rt.usize], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i64Debug(value[0], f), (f: rt.Formatter) => rt.usizeDebug(value[1], f)], f)), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_Option_tuple2_i64_usize(out: rs.ByteVec, v: [rs.i64, rs.usize] | undefined, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.i64, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_Option_tuple2_usize_i64(out: rt.ByteVec, v: [rt.usize, rt.i64] | undefined, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.usize, rt.i64], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.i64Debug(value[1], f)], f)), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_Option_tuple2_usize_i64(out: rs.ByteVec, v: [rs.usize, rs.i64] | undefined, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.i64], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.i64Debug(value[1], f)], f)), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_Option_usize(out: rt.ByteVec, v: rt.usize | undefined, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.usizeDebug), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_Result_usize_unit(out: rt.ByteVec, v: rt.Result, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(v, f, rt.usizeDebug, rt.fmtUnit), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_Result_usize_unit(out: rs.ByteVec, v: rs.Result, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_bool(out: rt.ByteVec, v: boolean, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(v, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_tuple2_Option_i64_Option_i64(out: rt.ByteVec, v: [rt.i64 | undefined, rt.i64 | undefined], r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.i64Debug)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_tuple2_Option_i64_Option_i64(out: rs.ByteVec, v: [rs.i64 | undefined, rs.i64 | undefined], r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.i64Debug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_tuple2_Option_i64_Option_usize(out: rt.ByteVec, v: [rt.i64 | undefined, rt.usize | undefined], r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_tuple2_Option_i64_Option_usize(out: rs.ByteVec, v: [rs.i64 | undefined, rs.usize | undefined], r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_tuple2_Option_i64_usize(out: rt.ByteVec, v: [rt.i64 | undefined, rt.usize], r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.i64Debug), (f: rt.Formatter) => rt.usizeDebug(v[1], f)], f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_tuple2_Option_i64_usize(out: rs.ByteVec, v: [rs.i64 | undefined, rs.usize], r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_unit(out: rt.ByteVec, _: undefined, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$i64_usize(out: rt.ByteVec, v: rt.usize, r: rt.RangeInclusive): void { - const _12: rt.i64 = rt.rangeInclusiveStart(r); - const _14: rt.i64 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(v, f), (f: rt.Formatter) => rt.i64Debug(_12, f), (f: rt.Formatter) => rt.i64Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$i64_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusive): void { + const _12: rs.i64 = rs.rangeInclusiveStart(r); + const _14: rs.i64 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.i64Debug(_12, f), (f: rs.Formatter) => rs.i64Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_Option_tuple2_u8_usize(out: rt.ByteVec, v: [rt.u8, rt.usize] | undefined, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.u8, rt.usize], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.usizeDebug(value[1], f)], f)), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_Option_tuple2_u8_usize(out: rs.ByteVec, v: [rs.u8, rs.usize] | undefined, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_Option_tuple2_usize_u8(out: rt.ByteVec, v: [rt.usize, rt.u8] | undefined, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, (value: [rt.usize, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_Option_tuple2_usize_u8(out: rs.ByteVec, v: [rs.usize, rs.u8] | undefined, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, (value: [rs.usize, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_Option_u8(out: rt.ByteVec, v: rt.u8 | undefined, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.u8Debug), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_Option_u8(out: rs.ByteVec, v: rs.u8 | undefined, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.u8Debug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_Option_usize(out: rt.ByteVec, v: rt.usize | undefined, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(v, f, rt.usizeDebug), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_Option_usize(out: rs.ByteVec, v: rs.usize | undefined, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(v, f, rs.usizeDebug), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_Result_usize_unit(out: rt.ByteVec, v: rt.Result, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(v, f, rt.usizeDebug, rt.fmtUnit), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_Result_usize_unit(out: rs.ByteVec, v: rs.Result, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(v, f, rs.usizeDebug, rs.fmtUnit), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_bool(out: rt.ByteVec, v: boolean, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(v, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_bool(out: rs.ByteVec, v: boolean, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_tuple2_Option_u8_Option_u8(out: rt.ByteVec, v: [rt.u8 | undefined, rt.u8 | undefined], r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.u8Debug)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_tuple2_Option_u8_Option_u8(out: rs.ByteVec, v: [rs.u8 | undefined, rs.u8 | undefined], r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.u8Debug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_tuple2_Option_u8_Option_usize(out: rt.ByteVec, v: [rt.u8 | undefined, rt.usize | undefined], r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(v[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_tuple2_Option_u8_Option_usize(out: rs.ByteVec, v: [rs.u8 | undefined, rs.usize | undefined], r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(v[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_tuple2_Option_u8_usize(out: rt.ByteVec, v: [rt.u8 | undefined, rt.usize], r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(v[0], f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDebug(v[1], f)], f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_tuple2_Option_u8_usize(out: rs.ByteVec, v: [rs.u8 | undefined, rs.usize], r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(v[0], f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDebug(v[1], f)], f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_unit(out: rt.ByteVec, _: undefined, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_unit(out: rs.ByteVec, _: undefined, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** `r`'s state after `v`, what read it returned. */ -export function state$u8_usize(out: rt.ByteVec, v: rt.usize, r: rt.RangeInclusive): void { - const _12: rt.u8 = rt.rangeInclusiveStart(r); - const _14: rt.u8 = rt.rangeInclusiveEnd(r); - const _16: boolean = rt.rangeInclusiveIsEmpty(r); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(v, f), (f: rt.Formatter) => rt.u8Debug(_12, f), (f: rt.Formatter) => rt.u8Debug(_14, f), (f: rt.Formatter) => rt.fmtBool(_16, f), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); +export function state$u8_usize(out: rs.ByteVec, v: rs.usize, r: rs.RangeInclusive): void { + const _12: rs.u8 = rs.rangeInclusiveStart(r); + const _14: rs.u8 = rs.rangeInclusiveEnd(r); + const _16: boolean = rs.rangeInclusiveIsEmpty(r); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(v, f), (f: rs.Formatter) => rs.u8Debug(_12, f), (f: rs.Formatter) => rs.u8Debug(_14, f), (f: rs.Formatter) => rs.fmtBool(_16, f), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])); } /** * Each read of empty, single, and full ranges of the integer type `kind` picks, and at * its limits. */ -export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function folds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _8: [rt.u8, rt.u8, rt.usize] = [at(0), at(1), rt.usizeRem(at(2) as rt.usize, 6)]; - const a: rt.u8 = _8[0]; - const b: rt.u8 = _8[1]; - const n: rt.usize = _8[2]; - if (rt.u8Rem(kind, 2) === 0) { - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterSlice([[a, b] as [rt.u8, rt.u8], [a, a] as [rt.u8, rt.u8], [b, a] as [rt.u8, rt.u8], [rt.u8Sub(255, rt.u8Rem(a, 4)), 255] as [rt.u8, rt.u8], [255, 255] as [rt.u8, rt.u8], [0, rt.u8Rem(a, 4)] as [rt.u8, rt.u8]]); + const _8: [rs.u8, rs.u8, rs.usize] = [at(0), at(1), rs.usizeRem(at(2) as rs.usize, 6)]; + const a: rs.u8 = _8[0]; + const b: rs.u8 = _8[1]; + const n: rs.usize = _8[2]; + if (rs.u8Rem(kind, 2) === 0) { + const iter: rs.Iter<[rs.u8, rs.u8]> = rs.iterSlice([[a, b] as [rs.u8, rs.u8], [a, a] as [rs.u8, rs.u8], [b, a] as [rs.u8, rs.u8], [rs.u8Sub(255, rs.u8Rem(a, 4)), 255] as [rs.u8, rs.u8], [255, 255] as [rs.u8, rs.u8], [0, rs.u8Rem(a, 4)] as [rs.u8, rs.u8]]); while (true) { - const _38: [rt.u8, rt.u8] | rt.Done = iter.next(); - if (_38 === rt.DONE) { + const _38: [rs.u8, rs.u8] | rs.Done = iter.next(); + if (_38 === rs.DONE) { break; } - const lo: rt.u8 = _38[0]; - const hi: rt.u8 = _38[1]; - const lo2: rt.u8 = lo; - const hi2: rt.u8 = hi; - const n2: rt.usize = n; - const k: rt.u8 | undefined = rt.iterNth(new rt.RangeInclusive(lo2, hi2, rt.u8Step), n2); - const isK: (a0: rt.u8) => boolean = (x41: rt.u8): boolean => { + const lo: rs.u8 = _38[0]; + const hi: rs.u8 = _38[1]; + const lo2: rs.u8 = lo; + const hi2: rs.u8 = hi; + const n2: rs.usize = n; + const k: rs.u8 | undefined = rs.iterNth(new rs.RangeInclusive(lo2, hi2, rs.u8Step), n2); + const isK: (a0: rs.u8) => boolean = (x41: rs.u8): boolean => { return x41 === k; }; - const below: (a0: rt.u8) => boolean = (x42: rt.u8): boolean => { + const below: (a0: rs.u8) => boolean = (x42: rs.u8): boolean => { if (k === undefined) { return true; } return x42 < k; }; - const r: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const iter2: rt.RangeInclusive = r; - while (iter2.next() !== rt.DONE) { + const r: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const iter2: rs.RangeInclusive = r; + while (iter2.next() !== rs.DONE) { } state$u8_unit(out, undefined, r); - const r2: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const iter3: rt.RangeInclusive = r2; + const r2: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const iter3: rs.RangeInclusive = r2; while (true) { - const _69: rt.u8 | rt.Done = iter3.next(); - if (_69 === rt.DONE) { + const _69: rs.u8 | rs.Done = iter3.next(); + if (_69 === rs.DONE) { break; } if (isK(_69)) { @@ -255,354 +255,354 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } state$u8_unit(out, undefined, r2); - const r3: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterRfind(r3, isK), r3); - const r4: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterRfind(r4, (_223: rt.u8): boolean => { + const r3: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterRfind(r3, isK), r3); + const r4: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterRfind(r4, (_223: rs.u8): boolean => { return false; }), r4); - const r5: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r5), (x43: rt.u8): rt.u8 => { + const r5: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterMap(rs.iterBorrow(r5), (x43: rs.u8): rs.u8 => { return x43; })), r5); - const r6: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r6), (x44: rt.u8): rt.u8 => { + const r6: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterMap(rs.iterBorrow(r6), (x44: rs.u8): rs.u8 => { return x44; })), r6); - const r7: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r7), (x45: rt.u8): rt.u8 => { + const r7: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_usize(out, rs.iterPosition(rs.iterMap(rs.iterBorrow(r7), (x45: rs.u8): rs.u8 => { return x45; - }), (x46: rt.u8): boolean => { + }), (x46: rs.u8): boolean => { return isK(x46); }), r7); - const r8: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r8), (x47: rt.u8): rt.u8 => { + const r8: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterRfind(rs.iterMap(rs.iterBorrow(r8), (x47: rs.u8): rs.u8 => { return x47; }), isK), r8); - const r9: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r9), (x48: rt.u8): rt.u8 => { + const r9: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterFold(rs.iterMap(rs.iterBorrow(r9), (x48: rs.u8): rs.u8 => { return x48; - }), 0, (n6: rt.usize, _332: rt.u8): rt.usize => { - return rt.usizeAdd(n6, 1); + }), 0, (n6: rs.usize, _332: rs.u8): rs.usize => { + return rs.usizeAdd(n6, 1); }), r9); - const r10: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterNth(rt.iterMap(rt.iterBorrow(r10), (x49: rt.u8): rt.u8 => { + const r10: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterNth(rs.iterMap(rs.iterBorrow(r10), (x49: rs.u8): rs.u8 => { return x49; }), n2), r10); - const r11: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterNthBack(rt.iterMap(rt.iterBorrow(r11), (x50: rt.u8): rt.u8 => { + const r11: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterNthBack(rs.iterMap(rs.iterBorrow(r11), (x50: rs.u8): rs.u8 => { return x50; }), n2), r11); - const r12: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r12), (x51: rt.u8): rt.u8 => { + const r12: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterMax(rs.iterRev(rs.iterMap(rs.iterBorrow(r12), (x51: rs.u8): rs.u8 => { return x51; - })), rt.lt), r12); - const r13: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterBorrow(r13), (x52: rt.u8): rt.u8 => { + })), rs.lt), r12); + const r13: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterMap(rs.iterBorrow(r13), (x52: rs.u8): rs.u8 => { return x52; }), undefined, true).length, r13); - const r14: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r14), (_226: rt.u8): undefined => {})), r14); - const r15: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r15), (_228: rt.u8): undefined => {}), (x53: rt.u8): boolean => { + const r14: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterInspect(rs.iterBorrow(r14), (_226: rs.u8): undefined => {})), r14); + const r15: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_bool(out, rs.iterAny(rs.iterInspect(rs.iterBorrow(r15), (_228: rs.u8): undefined => {}), (x53: rs.u8): boolean => { return isK(x53); }), r15); - const r16: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterInspect(rt.iterBorrow(r16), (_229: rt.u8): undefined => {}), "next").length, r16); - const r17: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _191: rt.RangeInclusive = r17; - const _193: (a0: rt.u8) => boolean = (x54: rt.u8): boolean => { + const r16: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterInspect(rs.iterBorrow(r16), (_229: rs.u8): undefined => {}), "next").length, r16); + const r17: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _191: rs.RangeInclusive = r17; + const _193: (a0: rs.u8) => boolean = (x54: rs.u8): boolean => { return !isK(x54); }; - state$u8_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_191), _193)), r17); - const r18: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r18), isK).next()), r18); - const r19: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r19), isK).nextBack()), r19); - const r20: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterFilter(rt.iterBorrow(r20), (_230: rt.u8): boolean => { + state$u8_usize(out, rs.iterCount(rs.iterFilter(rs.iterBorrow(_191), _193)), r17); + const r18: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterToOption(rs.iterFilter(rs.iterBorrow(r18), isK).next()), r18); + const r19: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterToOption(rs.iterFilter(rs.iterBorrow(r19), isK).nextBack()), r19); + const r20: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterFilter(rs.iterBorrow(r20), (_230: rs.u8): boolean => { return true; }), "next").length, r20); - const r21: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _225: rt.RangeInclusive = r21; - const _227: (a0: rt.u8) => rt.u8 | undefined = (x55: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(!isK(x55), x55); + const r21: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _225: rs.RangeInclusive = r21; + const _227: (a0: rs.u8) => rs.u8 | undefined = (x55: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(!isK(x55), x55); }; - state$u8_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_225), _227)), r21); - const r22: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _235: rt.RangeInclusive = r22; - const _237: (a0: rt.u8) => rt.u8 | undefined = (x56: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(isK(x56), x56); + state$u8_usize(out, rs.iterCount(rs.iterFilterMap(rs.iterBorrow(_225), _227)), r21); + const r22: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _235: rs.RangeInclusive = r22; + const _237: (a0: rs.u8) => rs.u8 | undefined = (x56: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(isK(x56), x56); }; - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_235), _237).next()), r22); - const r23: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _245: rt.RangeInclusive = r23; - const _247: (a0: rt.u8) => rt.u8 | undefined = (x57: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(isK(x57), x57); + state$u8_Option_u8(out, rs.iterToOption(rs.iterFilterMap(rs.iterBorrow(_235), _237).next()), r22); + const r23: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _245: rs.RangeInclusive = r23; + const _247: (a0: rs.u8) => rs.u8 | undefined = (x57: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(isK(x57), x57); }; - state$u8_Option_u8(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_245), _247).nextBack()), r23); - const r24: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r24))), r24); - const r25: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r25)), (_231: [rt.usize, rt.u8]): boolean => { + state$u8_Option_u8(out, rs.iterToOption(rs.iterFilterMap(rs.iterBorrow(_245), _247).nextBack()), r23); + const r24: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterEnumerate(rs.iterBorrow(r24))), r24); + const r25: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_usize(out, rs.iterPosition(rs.iterEnumerate(rs.iterBorrow(r25)), (_231: [rs.usize, rs.u8]): boolean => { return isK(_231[1]); }), r25); - const r26: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_tuple2_usize_u8(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r26))), r26); - const r27: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _278: rt.RangeInclusive = r27; - const _280: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_278), _280)), r27); - const r28: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi2, hi2, rt.u8Step), rt.iterBorrow(r28))), r28); - const r29: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _295: rt.RangeInclusive = r29; - const _297: rt.RangeInclusive = new rt.RangeInclusive(hi2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_295), _297), (x59: rt.u8): boolean => { + const r26: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_tuple2_usize_u8(out, rs.iterLast(rs.iterEnumerate(rs.iterBorrow(r26))), r26); + const r27: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _278: rs.RangeInclusive = r27; + const _280: rs.RangeInclusive = new rs.RangeInclusive(lo2, lo2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterChain(rs.iterBorrow(_278), _280)), r27); + const r28: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterChain(new rs.RangeInclusive(hi2, hi2, rs.u8Step), rs.iterBorrow(r28))), r28); + const r29: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _295: rs.RangeInclusive = r29; + const _297: rs.RangeInclusive = new rs.RangeInclusive(hi2, hi2, rs.u8Step); + state$u8_bool(out, rs.iterAny(rs.iterChain(rs.iterBorrow(_295), _297), (x59: rs.u8): boolean => { return isK(x59); }), r29); - const r30: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _306: rt.RangeInclusive = r30; - const _308: rt.RangeInclusive = new rt.RangeInclusive(lo2, lo2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_306), _308))), r30); - const r31: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r31))), r31); - const r32: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r32)), (x60: rt.u8): boolean => { + const r30: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _306: rs.RangeInclusive = r30; + const _308: rs.RangeInclusive = new rs.RangeInclusive(lo2, lo2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterRev(rs.iterChain(rs.iterBorrow(_306), _308))), r30); + const r31: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterRev(rs.iterBorrow(r31))), r31); + const r32: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_usize(out, rs.iterPosition(rs.iterRev(rs.iterBorrow(r32)), (x60: rs.u8): boolean => { return isK(x60); }), r32); - const r33: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r33)), rt.lt), r33); - const r34: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r34)))), r34); - const r35: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r35), n2)), r35); - const r36: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _353: rt.RangeInclusive = r36; - const _355: rt.usize = rt.usizeAdd(n2, 1); - state$u8_Option_u8(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_353), _355), rt.lt), r36); - const r37: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r37), n2)), r37); - const r38: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r38), n2), (x61: rt.u8): rt.u8 => { + const r33: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterMin(rs.iterRev(rs.iterBorrow(r33)), rs.lt), r33); + const r34: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterRev(rs.iterRev(rs.iterBorrow(r34)))), r34); + const r35: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterTake(rs.iterBorrow(r35), n2)), r35); + const r36: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _353: rs.RangeInclusive = r36; + const _355: rs.usize = rs.usizeAdd(n2, 1); + state$u8_Option_u8(out, rs.iterMax(rs.iterTake(rs.iterBorrow(_353), _355), rs.lt), r36); + const r37: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterTake(rs.iterBorrow(r37), n2)), r37); + const r38: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterMap(rs.iterTake(rs.iterBorrow(r38), n2), (x61: rs.u8): rs.u8 => { return x61; })), r38); - const r39: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r39), 4294967295), rt.lt), r39); - const r40: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r40), n2))), r40); - const r41: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r41), n2).next()), r41); - const r42: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r42), n2)), r42); - const r43: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r43), n2)), r43); - const r44: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r44), n2), rt.lt), r44); - const r45: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterSkip(rt.iterBorrow(r45), n2), "next").length, r45); - const r46: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r46), below).next()), r46); - const r47: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r47), below)), r47); - const r48: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r48), below)), r48); - const r49: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r49), (_232: rt.u8): boolean => { + const r39: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterMin(rs.iterTake(rs.iterBorrow(r39), 4294967295), rs.lt), r39); + const r40: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterEnumerate(rs.iterTake(rs.iterBorrow(r40), n2))), r40); + const r41: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterToOption(rs.iterSkip(rs.iterBorrow(r41), n2).next()), r41); + const r42: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterSkip(rs.iterBorrow(r42), n2)), r42); + const r43: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterSkip(rs.iterBorrow(r43), n2)), r43); + const r44: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterMax(rs.iterSkip(rs.iterBorrow(r44), n2), rs.lt), r44); + const r45: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterSkip(rs.iterBorrow(r45), n2), "next").length, r45); + const r46: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterToOption(rs.iterSkipWhile(rs.iterBorrow(r46), below).next()), r46); + const r47: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterSkipWhile(rs.iterBorrow(r47), below)), r47); + const r48: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterTakeWhile(rs.iterBorrow(r48), below)), r48); + const r49: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterTakeWhile(rs.iterBorrow(r49), (_232: rs.u8): boolean => { return true; })), r49); - const r50: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterTakeWhile(rt.iterBorrow(r50), below), "next").length, r50); - const r51: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _468: rt.RangeInclusive = r51; - const _470: (a0: rt.u8) => rt.u8 | undefined = (x62: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(below(x62), x62); + const r50: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterTakeWhile(rs.iterBorrow(r50), below), "next").length, r50); + const r51: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _468: rs.RangeInclusive = r51; + const _470: (a0: rs.u8) => rs.u8 | undefined = (x62: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(below(x62), x62); }; - state$u8_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_468), _470)), r51); - const r52: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r52), (x63: rt.u8): rt.u8 | undefined => { + state$u8_usize(out, rs.iterCount(rs.iterMapWhile(rs.iterBorrow(_468), _470)), r51); + const r52: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterMapWhile(rs.iterBorrow(r52), (x63: rs.u8): rs.u8 | undefined => { return x63; })), r52); - const r53: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterMapWhile(rt.iterBorrow(r53), (x64: rt.u8): rt.u8 | undefined => { + const r53: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterMapWhile(rs.iterBorrow(r53), (x64: rs.u8): rs.u8 | undefined => { return x64; }), "next").length, r53); - const r54: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r54), true)), r54); - const r55: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r55), true)), (x65: rt.u8): boolean => { + const r54: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterFuse(rs.iterBorrow(r54), true)), r54); + const r55: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_bool(out, rs.iterAny(rs.iterRev(rs.iterFuse(rs.iterBorrow(r55), true)), (x65: rs.u8): boolean => { return isK(x65); }), r55); - const r56: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const p: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r56)); - state$u8_tuple2_Option_u8_usize(out, [rt.peekablePeek(p), rt.iterCount(p)] as [rt.u8 | undefined, rt.usize], r56); - const r57: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const p2: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r57)); - state$u8_tuple2_Option_u8_Option_u8(out, [rt.peekablePeek(p2), rt.iterLast(rt.iterRev(p2))] as [rt.u8 | undefined, rt.u8 | undefined], r57); - const r58: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const p3: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r58)); - state$u8_tuple2_Option_u8_Option_usize(out, [rt.peekablePeek(p3), rt.iterPosition(p3, (x66: rt.u8): boolean => { + const r56: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const p: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r56)); + state$u8_tuple2_Option_u8_usize(out, [rs.peekablePeek(p), rs.iterCount(p)] as [rs.u8 | undefined, rs.usize], r56); + const r57: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const p2: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r57)); + state$u8_tuple2_Option_u8_Option_u8(out, [rs.peekablePeek(p2), rs.iterLast(rs.iterRev(p2))] as [rs.u8 | undefined, rs.u8 | undefined], r57); + const r58: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const p3: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r58)); + state$u8_tuple2_Option_u8_Option_usize(out, [rs.peekablePeek(p3), rs.iterPosition(p3, (x66: rs.u8): boolean => { return isK(x66); - })] as [rt.u8 | undefined, rt.usize | undefined], r58); - const r59: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r59))), r59); - const r60: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const p4: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r60)); - const iter4: rt.Peekable = p4; + })] as [rs.u8 | undefined, rs.usize | undefined], r58); + const r59: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterPeekable(rs.iterBorrow(r59))), r59); + const r60: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const p4: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r60)); + const iter4: rs.Peekable = p4; while (true) { - const _563: rt.u8 | rt.Done = iter4.next(); - if (_563 === rt.DONE) { + const _563: rs.u8 | rs.Done = iter4.next(); + if (_563 === rs.DONE) { break; } if (isK(_563)) { break; } } - state$u8_Option_u8(out, rt.peekablePeek(p4), r60); - const r61: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r61), (x67: rt.u8): rt.u8 | undefined => { + state$u8_Option_u8(out, rs.peekablePeek(p4), r60); + const r61: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterFlatMap(rs.iterBorrow(r61), (x67: rs.u8): rs.u8 | undefined => { return x67; - }, (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true)), r61); - const r62: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r62), (x68: rt.u8): rt.u8 | undefined => { + }, (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true)), r61); + const r62: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterToOption(rs.iterFlatMap(rs.iterBorrow(r62), (x68: rs.u8): rs.u8 | undefined => { return x68; - }, (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true).next()), r62); - const r63: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _594: rt.RangeInclusive = r63; - const _596: (a0: rt.u8) => rt.RangeInclusive = (x69: rt.u8): rt.RangeInclusive => { - return new rt.RangeInclusive(lo2, x69, rt.u8Step); + }, (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true).next()), r62); + const r63: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _594: rs.RangeInclusive = r63; + const _596: (a0: rs.u8) => rs.RangeInclusive = (x69: rs.u8): rs.RangeInclusive => { + return new rs.RangeInclusive(lo2, x69, rs.u8Step); }; - state$u8_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_594), _596), undefined, true)), r63); - const r64: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _604: rt.RangeInclusive = r64; - const _606: (a0: rt.u8) => rt.RangeInclusive = (x70: rt.u8): rt.RangeInclusive => { - return new rt.RangeInclusive(x70, hi2, rt.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterFlatten(rs.iterMap(rs.iterBorrow(_594), _596), undefined, true)), r63); + const r64: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _604: rs.RangeInclusive = r64; + const _606: (a0: rs.u8) => rs.RangeInclusive = (x70: rs.u8): rs.RangeInclusive => { + return new rs.RangeInclusive(x70, hi2, rs.u8Step); }; - state$u8_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_604), _606, undefined, true), (x71: rt.u8): boolean => { + state$u8_Option_usize(out, rs.iterPosition(rs.iterFlatMap(rs.iterBorrow(_604), _606, undefined, true), (x71: rs.u8): boolean => { return isK(x71); }), r64); - const r65: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r65), (x72: rt.u8): Uint8Array => { + const r65: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterRev(rs.iterFlatMap(rs.iterBorrow(r65), (x72: rs.u8): Uint8Array => { return Uint8Array.of(x72, x72); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2))), r65); - const r66: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _623: rt.RangeInclusive = r66; - const _625: rt.usize = rt.usizeAdd(n2, 1); - state$u8_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_623), _625)), r66); - const r67: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r67), new rt.Range(0, n2), "len"), (_233: [rt.u8, rt.usize]): boolean => { + }, (value: Uint8Array) => rs.iterSlice(value), true, 2))), r65); + const r66: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _623: rs.RangeInclusive = r66; + const _625: rs.usize = rs.usizeAdd(n2, 1); + state$u8_usize(out, rs.iterCount(rs.iterStepBy(rs.iterBorrow(_623), _625)), r66); + const r67: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_bool(out, rs.iterAny(rs.iterZip(rs.iterBorrow(r67), new rs.Range(0, n2), "len"), (_233: [rs.u8, rs.usize]): boolean => { return false; }), r67); - const r68: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterCount(rt.iterZip(rt.iterBorrow(r68), new rt.Range(0, n2), "len")), r68); - const r69: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_tuple2_u8_usize(out, rt.iterLast(rt.iterZip(rt.iterBorrow(r69), new rt.Range(0, n2), "len")), r69); - const r70: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_usize(out, rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterBorrow(r70), new rt.Range(0, n2), "len"), (_236: [rt.u8, rt.usize]): rt.u8 => { + const r68: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterCount(rs.iterZip(rs.iterBorrow(r68), new rs.Range(0, n2), "len")), r68); + const r69: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_tuple2_u8_usize(out, rs.iterLast(rs.iterZip(rs.iterBorrow(r69), new rs.Range(0, n2), "len")), r69); + const r70: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_usize(out, rs.iterToByteVec(rs.iterMap(rs.iterZip(rs.iterBorrow(r70), new rs.Range(0, n2), "len"), (_236: [rs.u8, rs.usize]): rs.u8 => { return _236[0]; }), undefined, true).length, r70); - const r71: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Option_usize(out, rt.iterPosition(rt.iterZip(rt.iterBorrow(r71), new rt.Range(0, n2), "len"), (_238: [rt.u8, rt.usize]): boolean => { + const r71: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Option_usize(out, rs.iterPosition(rs.iterZip(rs.iterBorrow(r71), new rs.Range(0, n2), "len"), (_238: [rs.u8, rs.usize]): boolean => { return false; }), r71); - const r72: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - state$u8_Result_usize_unit(out, result_map$1w3j91w(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r72), (x74: rt.u8): rt.Result => { - return rt.Ok(x74); - }), (values: rt.Iter) => rt.iterToByteVec(values)), (v161: rt.ByteVec): rt.usize => { + const r72: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + state$u8_Result_usize_unit(out, result_map$0vle1ww(rs.iterCollectResult(rs.iterMap(rs.iterBorrow(r72), (x74: rs.u8): rs.Result => { + return rs.Ok(x74); + }), (values: rs.Iter) => rs.iterToByteVec(values)), (v161: rs.ByteVec): rs.usize => { return v161.length; }), r72); - const r73: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const _685: rt.RangeInclusive = r73; - const _687: (a0: rt.u8) => rt.u8 | undefined = (x75: rt.u8): rt.u8 | undefined => { + const r73: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const _685: rs.RangeInclusive = r73; + const _687: (a0: rs.u8) => rs.u8 | undefined = (x75: rs.u8): rs.u8 | undefined => { if (!isK(x75)) { return x75; } return undefined; }; - state$u8_Option_usize(out, option_map$1c7fhtg(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_685), _687), (values: rt.Iter) => rt.iterToByteVec(values)), (v162: rt.ByteVec): rt.usize => { + state$u8_Option_usize(out, option_map$0qp7by0(rs.iterCollectOption(rs.iterMap(rs.iterBorrow(_685), _687), (values: rs.Iter) => rs.iterToByteVec(values)), (v162: rs.ByteVec): rs.usize => { return v162.length; }), r73); - const r74: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const v73: rt.ByteVec = new rt.ByteVec(); - const _697: rt.Iter = rt.iterMap(rt.iterBorrow(r74), (x76: rt.u8): rt.u8 => { + const r74: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const v73: rs.ByteVec = new rs.ByteVec(); + const _697: rs.Iter = rs.iterMap(rs.iterBorrow(r74), (x76: rs.u8): rs.u8 => { return x76; }); - rt.iterExtendBytes(v73, _697, undefined, true); + rs.iterExtendBytes(v73, _697, undefined, true); state$u8_usize(out, v73.length, r74); - const r75: rt.RangeInclusive = new rt.RangeInclusive(lo2, hi2, rt.u8Step); - const v75: rt.ByteVec = new rt.ByteVec(); - const _708: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r75), (_239: rt.u8): boolean => { + const r75: rs.RangeInclusive = new rs.RangeInclusive(lo2, hi2, rs.u8Step); + const v75: rs.ByteVec = new rs.ByteVec(); + const _708: rs.Iter = rs.iterTakeWhile(rs.iterBorrow(r75), (_239: rs.u8): boolean => { return true; }); - rt.iterExtendBytes(v75, _708, "next"); + rs.iterExtendBytes(v75, _708, "next"); state$u8_usize(out, v75.length, r75); - const lo3: rt.u8 = lo; - const hi3: rt.u8 = hi; - const n3: rt.usize = n; - const k2: rt.u8 | undefined = rt.iterNth(new rt.RangeInclusive(lo3, hi3, rt.u8Step), n3); - const isK2: (a0: rt.u8) => boolean = (x77: rt.u8): boolean => { + const lo3: rs.u8 = lo; + const hi3: rs.u8 = hi; + const n3: rs.usize = n; + const k2: rs.u8 | undefined = rs.iterNth(new rs.RangeInclusive(lo3, hi3, rs.u8Step), n3); + const isK2: (a0: rs.u8) => boolean = (x77: rs.u8): boolean => { return x77 === k2; }; - const r76: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(r76, isK2), r76); - const r77: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(r77, (_240: rt.u8): boolean => { + const r76: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_usize(out, rs.iterRposition(r76, isK2), r76); + const r77: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_usize(out, rs.iterRposition(r77, (_240: rs.u8): boolean => { return false; }), r77); - const r78: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterTake(rt.iterBorrow(r78), n3))), r78); - const r79: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(rt.iterTake(rt.iterBorrow(r79), n3), isK2), r79); - const r80: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_u8(out, rt.iterLast(rt.iterRev(rt.iterSkip(rt.iterBorrow(r80), n3))), r80); - const r81: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(rt.iterSkip(rt.iterBorrow(r81), n3), isK2), r81); - const r82: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_tuple2_usize_u8(out, rt.iterLast(rt.iterRev(rt.iterEnumerate(rt.iterBorrow(r82)))), r82); - const r83: rt.RangeInclusive = new rt.RangeInclusive(lo3, hi3, rt.u8Step); - state$u8_Option_usize(out, rt.iterRposition(rt.iterEnumerate(rt.iterBorrow(r83)), (_241: [rt.usize, rt.u8]): boolean => { + const r78: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterRev(rs.iterTake(rs.iterBorrow(r78), n3))), r78); + const r79: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_usize(out, rs.iterRposition(rs.iterTake(rs.iterBorrow(r79), n3), isK2), r79); + const r80: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_u8(out, rs.iterLast(rs.iterRev(rs.iterSkip(rs.iterBorrow(r80), n3))), r80); + const r81: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_usize(out, rs.iterRposition(rs.iterSkip(rs.iterBorrow(r81), n3), isK2), r81); + const r82: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_tuple2_usize_u8(out, rs.iterLast(rs.iterRev(rs.iterEnumerate(rs.iterBorrow(r82)))), r82); + const r83: rs.RangeInclusive = new rs.RangeInclusive(lo3, hi3, rs.u8Step); + state$u8_Option_usize(out, rs.iterRposition(rs.iterEnumerate(rs.iterBorrow(r83)), (_241: [rs.usize, rs.u8]): boolean => { return isK2(_241[1]); }), r83); } } else { - const _786: [rt.i64, rt.i64] = [rt.i64Sub(a as rt.i64, 128), rt.i64Sub(b as rt.i64, 128)]; - const a2: rt.i64 = _786[0]; - const b2: rt.i64 = _786[1]; - const low: rt.i64 = rt.i64Add({ hi: -0x80000000, lo: 0 } as rt.i64, rt.u8Rem(at(0), 4) as rt.i64); - const high: rt.i64 = rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, rt.u8Rem(at(1), 4) as rt.i64); - const _811: [rt.i64, rt.i64] = [a2, b2]; - const _812: [rt.i64, rt.i64] = [a2, a2]; - const _813: [rt.i64, rt.i64] = [b2, a2]; - const iter5: rt.Iter<[rt.i64, rt.i64]> = rt.iterSlice([_811, _812, _813, [{ hi: -0x80000000, lo: 0 } as rt.i64, low] as [rt.i64, rt.i64], [{ hi: -0x80000000, lo: 0 } as rt.i64, { hi: -0x80000000, lo: 0 } as rt.i64] as [rt.i64, rt.i64], [high, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64] as [rt.i64, rt.i64]]); + const _786: [rs.i64, rs.i64] = [rs.i64Sub(a as rs.i64, 128), rs.i64Sub(b as rs.i64, 128)]; + const a2: rs.i64 = _786[0]; + const b2: rs.i64 = _786[1]; + const low: rs.i64 = rs.i64Add({ hi: -0x80000000, lo: 0 } as rs.i64, rs.u8Rem(at(0), 4) as rs.i64); + const high: rs.i64 = rs.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rs.i64, rs.u8Rem(at(1), 4) as rs.i64); + const _811: [rs.i64, rs.i64] = [a2, b2]; + const _812: [rs.i64, rs.i64] = [a2, a2]; + const _813: [rs.i64, rs.i64] = [b2, a2]; + const iter5: rs.Iter<[rs.i64, rs.i64]> = rs.iterSlice([_811, _812, _813, [{ hi: -0x80000000, lo: 0 } as rs.i64, low] as [rs.i64, rs.i64], [{ hi: -0x80000000, lo: 0 } as rs.i64, { hi: -0x80000000, lo: 0 } as rs.i64] as [rs.i64, rs.i64], [high, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64] as [rs.i64, rs.i64]]); while (true) { - const _818: [rt.i64, rt.i64] | rt.Done = iter5.next(); - if (_818 === rt.DONE) { + const _818: [rs.i64, rs.i64] | rs.Done = iter5.next(); + if (_818 === rs.DONE) { break; } - const _826: [rt.i64, rt.i64, rt.usize] = [_818[0], _818[1], n]; - const lo5: rt.i64 = _826[0]; - const hi5: rt.i64 = _826[1]; - const n4: rt.usize = n; - const k3: rt.i64 | undefined = rt.iterNth(new rt.RangeInclusive(lo5, hi5, rt.i64Step), n4); - const isK3: (a0: rt.i64) => boolean = (x5: rt.i64): boolean => { - return rt.eqOption(rt.i64Eq)(x5, k3); + const _826: [rs.i64, rs.i64, rs.usize] = [_818[0], _818[1], n]; + const lo5: rs.i64 = _826[0]; + const hi5: rs.i64 = _826[1]; + const n4: rs.usize = n; + const k3: rs.i64 | undefined = rs.iterNth(new rs.RangeInclusive(lo5, hi5, rs.i64Step), n4); + const isK3: (a0: rs.i64) => boolean = (x5: rs.i64): boolean => { + return rs.eqOption(rs.i64Eq)(x5, k3); }; - const below2: (a0: rt.i64) => boolean = (x6: rt.i64): boolean => { + const below2: (a0: rs.i64) => boolean = (x6: rs.i64): boolean => { if (k3 === undefined) { return true; } - return rt.i64Lt(x6, k3); + return rs.i64Lt(x6, k3); }; - const r84: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const iter6: rt.RangeInclusive = r84; - while (iter6.next() !== rt.DONE) { + const r84: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const iter6: rs.RangeInclusive = r84; + while (iter6.next() !== rs.DONE) { } state$i64_unit(out, undefined, r84); - const r85: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const iter7: rt.RangeInclusive = r85; + const r85: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const iter7: rs.RangeInclusive = r85; while (true) { - const _849: rt.i64 | rt.Done = iter7.next(); - if (_849 === rt.DONE) { + const _849: rs.i64 | rs.Done = iter7.next(); + if (_849 === rs.DONE) { break; } if (isK3(_849)) { @@ -610,286 +610,286 @@ export function folds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } state$i64_unit(out, undefined, r85); - const r86: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(r86, isK3), r86); - const r87: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(r87, (_2: rt.i64): boolean => { + const r86: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterRfind(r86, isK3), r86); + const r87: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterRfind(r87, (_2: rs.i64): boolean => { return false; }), r87); - const r88: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterBorrow(r88), (x7: rt.i64): rt.i64 => { + const r88: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterMap(rs.iterBorrow(r88), (x7: rs.i64): rs.i64 => { return x7; })), r88); - const r89: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterMap(rt.iterBorrow(r89), (x8: rt.i64): rt.i64 => { + const r89: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterMap(rs.iterBorrow(r89), (x8: rs.i64): rs.i64 => { return x8; })), r89); - const r90: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_usize(out, rt.iterPosition(rt.iterMap(rt.iterBorrow(r90), (x9: rt.i64): rt.i64 => { + const r90: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_usize(out, rs.iterPosition(rs.iterMap(rs.iterBorrow(r90), (x9: rs.i64): rs.i64 => { return x9; - }), (x10: rt.i64): boolean => { + }), (x10: rs.i64): boolean => { return isK3(x10); }), r90); - const r91: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterRfind(rt.iterMap(rt.iterBorrow(r91), (x11: rt.i64): rt.i64 => { + const r91: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterRfind(rs.iterMap(rs.iterBorrow(r91), (x11: rs.i64): rs.i64 => { return x11; }), isK3), r91); - const r92: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterFold(rt.iterMap(rt.iterBorrow(r92), (x12: rt.i64): rt.i64 => { + const r92: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterFold(rs.iterMap(rs.iterBorrow(r92), (x12: rs.i64): rs.i64 => { return x12; - }), 0, (n5: rt.usize, _39: rt.i64): rt.usize => { - return rt.usizeAdd(n5, 1); + }), 0, (n5: rs.usize, _39: rs.i64): rs.usize => { + return rs.usizeAdd(n5, 1); }), r92); - const r93: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterNth(rt.iterMap(rt.iterBorrow(r93), (x13: rt.i64): rt.i64 => { + const r93: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterNth(rs.iterMap(rs.iterBorrow(r93), (x13: rs.i64): rs.i64 => { return x13; }), n4), r93); - const r94: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterNthBack(rt.iterMap(rt.iterBorrow(r94), (x14: rt.i64): rt.i64 => { + const r94: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterNthBack(rs.iterMap(rs.iterBorrow(r94), (x14: rs.i64): rs.i64 => { return x14; }), n4), r94); - const r95: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterMax(rt.iterRev(rt.iterMap(rt.iterBorrow(r95), (x15: rt.i64): rt.i64 => { + const r95: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterMax(rs.iterRev(rs.iterMap(rs.iterBorrow(r95), (x15: rs.i64): rs.i64 => { return x15; - })), rt.lt), r95); - const r96: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterMap(rt.iterBorrow(r96), (x16: rt.i64): rt.i64 => { + })), rs.lt), r95); + const r96: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterMap(rs.iterBorrow(r96), (x16: rs.i64): rs.i64 => { return x16; }), undefined, 8, true).items.length, r96); - const r97: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterInspect(rt.iterBorrow(r97), (_210: rt.i64): undefined => {})), r97); - const r98: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterInspect(rt.iterBorrow(r98), (_211: rt.i64): undefined => {}), (x17: rt.i64): boolean => { + const r97: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterInspect(rs.iterBorrow(r97), (_210: rs.i64): undefined => {})), r97); + const r98: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_bool(out, rs.iterAny(rs.iterInspect(rs.iterBorrow(r98), (_211: rs.i64): undefined => {}), (x17: rs.i64): boolean => { return isK3(x17); }), r98); - const r99: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterInspect(rt.iterBorrow(r99), (_212: rt.i64): undefined => {}), "next", 8).items.length, r99); - const r100: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _971: rt.RangeInclusive = r100; - const _973: (a0: rt.i64) => boolean = (x18: rt.i64): boolean => { + const r99: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterInspect(rs.iterBorrow(r99), (_212: rs.i64): undefined => {}), "next", 8).items.length, r99); + const r100: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _971: rs.RangeInclusive = r100; + const _973: (a0: rs.i64) => boolean = (x18: rs.i64): boolean => { return !isK3(x18); }; - state$i64_usize(out, rt.iterCount(rt.iterFilter(rt.iterBorrow(_971), _973)), r100); - const r101: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r101), isK3).next()), r101); - const r102: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilter(rt.iterBorrow(r102), isK3).nextBack()), r102); - const r103: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterFilter(rt.iterBorrow(r103), (_213: rt.i64): boolean => { + state$i64_usize(out, rs.iterCount(rs.iterFilter(rs.iterBorrow(_971), _973)), r100); + const r101: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterToOption(rs.iterFilter(rs.iterBorrow(r101), isK3).next()), r101); + const r102: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterToOption(rs.iterFilter(rs.iterBorrow(r102), isK3).nextBack()), r102); + const r103: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterFilter(rs.iterBorrow(r103), (_213: rs.i64): boolean => { return true; }), "next", 8).items.length, r103); - const r104: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1005: rt.RangeInclusive = r104; - const _1007: (a0: rt.i64) => rt.i64 | undefined = (x19: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(!isK3(x19), x19); + const r104: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1005: rs.RangeInclusive = r104; + const _1007: (a0: rs.i64) => rs.i64 | undefined = (x19: rs.i64): rs.i64 | undefined => { + return thenSome$179x8nl(!isK3(x19), x19); }; - state$i64_usize(out, rt.iterCount(rt.iterFilterMap(rt.iterBorrow(_1005), _1007)), r104); - const r105: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1015: rt.RangeInclusive = r105; - const _1017: (a0: rt.i64) => rt.i64 | undefined = (x20: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(isK3(x20), x20); + state$i64_usize(out, rs.iterCount(rs.iterFilterMap(rs.iterBorrow(_1005), _1007)), r104); + const r105: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1015: rs.RangeInclusive = r105; + const _1017: (a0: rs.i64) => rs.i64 | undefined = (x20: rs.i64): rs.i64 | undefined => { + return thenSome$179x8nl(isK3(x20), x20); }; - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_1015), _1017).next()), r105); - const r106: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1025: rt.RangeInclusive = r106; - const _1027: (a0: rt.i64) => rt.i64 | undefined = (x21: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(isK3(x21), x21); + state$i64_Option_i64(out, rs.iterToOption(rs.iterFilterMap(rs.iterBorrow(_1015), _1017).next()), r105); + const r106: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1025: rs.RangeInclusive = r106; + const _1027: (a0: rs.i64) => rs.i64 | undefined = (x21: rs.i64): rs.i64 | undefined => { + return thenSome$179x8nl(isK3(x21), x21); }; - state$i64_Option_i64(out, rt.iterToOption(rt.iterFilterMap(rt.iterBorrow(_1025), _1027).nextBack()), r106); - const r107: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterBorrow(r107))), r107); - const r108: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_usize(out, rt.iterPosition(rt.iterEnumerate(rt.iterBorrow(r108)), (_214: [rt.usize, rt.i64]): boolean => { + state$i64_Option_i64(out, rs.iterToOption(rs.iterFilterMap(rs.iterBorrow(_1025), _1027).nextBack()), r106); + const r107: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterEnumerate(rs.iterBorrow(r107))), r107); + const r108: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_usize(out, rs.iterPosition(rs.iterEnumerate(rs.iterBorrow(r108)), (_214: [rs.usize, rs.i64]): boolean => { return isK3(_214[1]); }), r108); - const r109: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_tuple2_usize_i64(out, rt.iterLast(rt.iterEnumerate(rt.iterBorrow(r109))), r109); - const r110: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1058: rt.RangeInclusive = r110; - const _1060: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterChain(rt.iterBorrow(_1058), _1060)), r110); - const r111: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterChain(new rt.RangeInclusive(hi5, hi5, rt.i64Step), rt.iterBorrow(r111))), r111); - const r112: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1075: rt.RangeInclusive = r112; - const _1077: rt.RangeInclusive = new rt.RangeInclusive(hi5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterChain(rt.iterBorrow(_1075), _1077), (x23: rt.i64): boolean => { + const r109: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_tuple2_usize_i64(out, rs.iterLast(rs.iterEnumerate(rs.iterBorrow(r109))), r109); + const r110: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1058: rs.RangeInclusive = r110; + const _1060: rs.RangeInclusive = new rs.RangeInclusive(lo5, lo5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterChain(rs.iterBorrow(_1058), _1060)), r110); + const r111: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterChain(new rs.RangeInclusive(hi5, hi5, rs.i64Step), rs.iterBorrow(r111))), r111); + const r112: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1075: rs.RangeInclusive = r112; + const _1077: rs.RangeInclusive = new rs.RangeInclusive(hi5, hi5, rs.i64Step); + state$i64_bool(out, rs.iterAny(rs.iterChain(rs.iterBorrow(_1075), _1077), (x23: rs.i64): boolean => { return isK3(x23); }), r112); - const r113: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1086: rt.RangeInclusive = r113; - const _1088: rt.RangeInclusive = new rt.RangeInclusive(lo5, lo5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterChain(rt.iterBorrow(_1086), _1088))), r113); - const r114: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterRev(rt.iterBorrow(r114))), r114); - const r115: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_usize(out, rt.iterPosition(rt.iterRev(rt.iterBorrow(r115)), (x24: rt.i64): boolean => { + const r113: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1086: rs.RangeInclusive = r113; + const _1088: rs.RangeInclusive = new rs.RangeInclusive(lo5, lo5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterRev(rs.iterChain(rs.iterBorrow(_1086), _1088))), r113); + const r114: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterRev(rs.iterBorrow(r114))), r114); + const r115: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_usize(out, rs.iterPosition(rs.iterRev(rs.iterBorrow(r115)), (x24: rs.i64): boolean => { return isK3(x24); }), r115); - const r116: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterMin(rt.iterRev(rt.iterBorrow(r116)), rt.lt), r116); - const r117: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterRev(rt.iterBorrow(r117)))), r117); - const r118: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterTake(rt.iterBorrow(r118), n4)), r118); - const r119: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1133: rt.RangeInclusive = r119; - const _1135: rt.usize = rt.usizeAdd(n4, 1); - state$i64_Option_i64(out, rt.iterMax(rt.iterTake(rt.iterBorrow(_1133), _1135), rt.lt), r119); - const r120: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r120), n4)), r120); - const r121: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterMap(rt.iterTake(rt.iterBorrow(r121), n4), (x25: rt.i64): rt.i64 => { + const r116: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterMin(rs.iterRev(rs.iterBorrow(r116)), rs.lt), r116); + const r117: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterRev(rs.iterRev(rs.iterBorrow(r117)))), r117); + const r118: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterTake(rs.iterBorrow(r118), n4)), r118); + const r119: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1133: rs.RangeInclusive = r119; + const _1135: rs.usize = rs.usizeAdd(n4, 1); + state$i64_Option_i64(out, rs.iterMax(rs.iterTake(rs.iterBorrow(_1133), _1135), rs.lt), r119); + const r120: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterTake(rs.iterBorrow(r120), n4)), r120); + const r121: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterMap(rs.iterTake(rs.iterBorrow(r121), n4), (x25: rs.i64): rs.i64 => { return x25; })), r121); - const r122: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterMin(rt.iterTake(rt.iterBorrow(r122), 4294967295), rt.lt), r122); - const r123: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterEnumerate(rt.iterTake(rt.iterBorrow(r123), n4))), r123); - const r124: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterSkip(rt.iterBorrow(r124), n4).next()), r124); - const r125: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterSkip(rt.iterBorrow(r125), n4)), r125); - const r126: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterSkip(rt.iterBorrow(r126), n4)), r126); - const r127: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterMax(rt.iterSkip(rt.iterBorrow(r127), n4), rt.lt), r127); - const r128: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterSkip(rt.iterBorrow(r128), n4), "next", 8).items.length, r128); - const r129: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterSkipWhile(rt.iterBorrow(r129), below2).next()), r129); - const r130: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterSkipWhile(rt.iterBorrow(r130), below2)), r130); - const r131: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterTakeWhile(rt.iterBorrow(r131), below2)), r131); - const r132: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterTakeWhile(rt.iterBorrow(r132), (_215: rt.i64): boolean => { + const r122: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterMin(rs.iterTake(rs.iterBorrow(r122), 4294967295), rs.lt), r122); + const r123: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterEnumerate(rs.iterTake(rs.iterBorrow(r123), n4))), r123); + const r124: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterToOption(rs.iterSkip(rs.iterBorrow(r124), n4).next()), r124); + const r125: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterSkip(rs.iterBorrow(r125), n4)), r125); + const r126: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterSkip(rs.iterBorrow(r126), n4)), r126); + const r127: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterMax(rs.iterSkip(rs.iterBorrow(r127), n4), rs.lt), r127); + const r128: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterSkip(rs.iterBorrow(r128), n4), "next", 8).items.length, r128); + const r129: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterToOption(rs.iterSkipWhile(rs.iterBorrow(r129), below2).next()), r129); + const r130: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterSkipWhile(rs.iterBorrow(r130), below2)), r130); + const r131: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterTakeWhile(rs.iterBorrow(r131), below2)), r131); + const r132: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterTakeWhile(rs.iterBorrow(r132), (_215: rs.i64): boolean => { return true; })), r132); - const r133: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterTakeWhile(rt.iterBorrow(r133), below2), "next", 8).items.length, r133); - const r134: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1248: rt.RangeInclusive = r134; - const _1250: (a0: rt.i64) => rt.i64 | undefined = (x26: rt.i64): rt.i64 | undefined => { - return thenSome$0tjggir(below2(x26), x26); + const r133: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterTakeWhile(rs.iterBorrow(r133), below2), "next", 8).items.length, r133); + const r134: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1248: rs.RangeInclusive = r134; + const _1250: (a0: rs.i64) => rs.i64 | undefined = (x26: rs.i64): rs.i64 | undefined => { + return thenSome$179x8nl(below2(x26), x26); }; - state$i64_usize(out, rt.iterCount(rt.iterMapWhile(rt.iterBorrow(_1248), _1250)), r134); - const r135: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterMapWhile(rt.iterBorrow(r135), (x27: rt.i64): rt.i64 | undefined => { + state$i64_usize(out, rs.iterCount(rs.iterMapWhile(rs.iterBorrow(_1248), _1250)), r134); + const r135: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterMapWhile(rs.iterBorrow(r135), (x27: rs.i64): rs.i64 | undefined => { return x27; })), r135); - const r136: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterMapWhile(rt.iterBorrow(r136), (x28: rt.i64): rt.i64 | undefined => { + const r136: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterMapWhile(rs.iterBorrow(r136), (x28: rs.i64): rs.i64 | undefined => { return x28; }), "next", 8).items.length, r136); - const r137: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterFuse(rt.iterBorrow(r137), true)), r137); - const r138: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterRev(rt.iterFuse(rt.iterBorrow(r138), true)), (x29: rt.i64): boolean => { + const r137: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterFuse(rs.iterBorrow(r137), true)), r137); + const r138: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_bool(out, rs.iterAny(rs.iterRev(rs.iterFuse(rs.iterBorrow(r138), true)), (x29: rs.i64): boolean => { return isK3(x29); }), r138); - const r139: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const p5: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r139)); - state$i64_tuple2_Option_i64_usize(out, [rt.peekablePeek(p5), rt.iterCount(p5)] as [rt.i64 | undefined, rt.usize], r139); - const r140: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const p6: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r140)); - state$i64_tuple2_Option_i64_Option_i64(out, [rt.peekablePeek(p6), rt.iterLast(rt.iterRev(p6))] as [rt.i64 | undefined, rt.i64 | undefined], r140); - const r141: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const p7: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r141)); - state$i64_tuple2_Option_i64_Option_usize(out, [rt.peekablePeek(p7), rt.iterPosition(p7, (x30: rt.i64): boolean => { + const r139: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const p5: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r139)); + state$i64_tuple2_Option_i64_usize(out, [rs.peekablePeek(p5), rs.iterCount(p5)] as [rs.i64 | undefined, rs.usize], r139); + const r140: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const p6: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r140)); + state$i64_tuple2_Option_i64_Option_i64(out, [rs.peekablePeek(p6), rs.iterLast(rs.iterRev(p6))] as [rs.i64 | undefined, rs.i64 | undefined], r140); + const r141: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const p7: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r141)); + state$i64_tuple2_Option_i64_Option_usize(out, [rs.peekablePeek(p7), rs.iterPosition(p7, (x30: rs.i64): boolean => { return isK3(x30); - })] as [rt.i64 | undefined, rt.usize | undefined], r141); - const r142: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterPeekable(rt.iterBorrow(r142))), r142); - const r143: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const p8: rt.Peekable = rt.iterPeekable(rt.iterBorrow(r143)); - const iter8: rt.Peekable = p8; + })] as [rs.i64 | undefined, rs.usize | undefined], r141); + const r142: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterPeekable(rs.iterBorrow(r142))), r142); + const r143: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const p8: rs.Peekable = rs.iterPeekable(rs.iterBorrow(r143)); + const iter8: rs.Peekable = p8; while (true) { - const _1343: rt.i64 | rt.Done = iter8.next(); - if (_1343 === rt.DONE) { + const _1343: rs.i64 | rs.Done = iter8.next(); + if (_1343 === rs.DONE) { break; } if (isK3(_1343)) { break; } } - state$i64_Option_i64(out, rt.peekablePeek(p8), r143); - const r144: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterFlatMap(rt.iterBorrow(r144), (x31: rt.i64): rt.i64 | undefined => { + state$i64_Option_i64(out, rs.peekablePeek(p8), r143); + const r144: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterFlatMap(rs.iterBorrow(r144), (x31: rs.i64): rs.i64 | undefined => { return x31; - }, (value: rt.i64 | undefined) => rt.iterOption(value), true, undefined, true)), r144); - const r145: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterToOption(rt.iterFlatMap(rt.iterBorrow(r145), (x32: rt.i64): rt.i64 | undefined => { + }, (value: rs.i64 | undefined) => rs.iterOption(value), true, undefined, true)), r144); + const r145: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterToOption(rs.iterFlatMap(rs.iterBorrow(r145), (x32: rs.i64): rs.i64 | undefined => { return x32; - }, (value: rt.i64 | undefined) => rt.iterOption(value), true, undefined, true).next()), r145); - const r146: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1374: rt.RangeInclusive = r146; - const _1376: (a0: rt.i64) => rt.RangeInclusive = (x33: rt.i64): rt.RangeInclusive => { - return new rt.RangeInclusive(lo5, x33, rt.i64Step); + }, (value: rs.i64 | undefined) => rs.iterOption(value), true, undefined, true).next()), r145); + const r146: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1374: rs.RangeInclusive = r146; + const _1376: (a0: rs.i64) => rs.RangeInclusive = (x33: rs.i64): rs.RangeInclusive => { + return new rs.RangeInclusive(lo5, x33, rs.i64Step); }; - state$i64_usize(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterBorrow(_1374), _1376), undefined, true)), r146); - const r147: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1384: rt.RangeInclusive = r147; - const _1386: (a0: rt.i64) => rt.RangeInclusive = (x34: rt.i64): rt.RangeInclusive => { - return new rt.RangeInclusive(x34, hi5, rt.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterFlatten(rs.iterMap(rs.iterBorrow(_1374), _1376), undefined, true)), r146); + const r147: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1384: rs.RangeInclusive = r147; + const _1386: (a0: rs.i64) => rs.RangeInclusive = (x34: rs.i64): rs.RangeInclusive => { + return new rs.RangeInclusive(x34, hi5, rs.i64Step); }; - state$i64_Option_usize(out, rt.iterPosition(rt.iterFlatMap(rt.iterBorrow(_1384), _1386, undefined, true), (x35: rt.i64): boolean => { + state$i64_Option_usize(out, rs.iterPosition(rs.iterFlatMap(rs.iterBorrow(_1384), _1386, undefined, true), (x35: rs.i64): boolean => { return isK3(x35); }), r147); - const r148: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_i64(out, rt.iterLast(rt.iterRev(rt.iterFlatMap(rt.iterBorrow(r148), (x36: rt.i64): rt.i64[] => { + const r148: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_i64(out, rs.iterLast(rs.iterRev(rs.iterFlatMap(rs.iterBorrow(r148), (x36: rs.i64): rs.i64[] => { return [x36, x36]; - }, (value: rt.i64[]) => rt.iterSlice(value), true, 2))), r148); - const r149: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1403: rt.RangeInclusive = r149; - const _1405: rt.usize = rt.usizeAdd(n4, 1); - state$i64_usize(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(_1403), _1405)), r149); - const r150: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_bool(out, rt.iterAny(rt.iterZip(rt.iterBorrow(r150), new rt.Range(0, n4), "len"), (_219: [rt.i64, rt.usize]): boolean => { + }, (value: rs.i64[]) => rs.iterSlice(value), true, 2))), r148); + const r149: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1403: rs.RangeInclusive = r149; + const _1405: rs.usize = rs.usizeAdd(n4, 1); + state$i64_usize(out, rs.iterCount(rs.iterStepBy(rs.iterBorrow(_1403), _1405)), r149); + const r150: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_bool(out, rs.iterAny(rs.iterZip(rs.iterBorrow(r150), new rs.Range(0, n4), "len"), (_219: [rs.i64, rs.usize]): boolean => { return false; }), r150); - const r151: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterCount(rt.iterZip(rt.iterBorrow(r151), new rt.Range(0, n4), "len")), r151); - const r152: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_tuple2_i64_usize(out, rt.iterLast(rt.iterZip(rt.iterBorrow(r152), new rt.Range(0, n4), "len")), r152); - const r153: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_usize(out, rt.iterToVec(rt.iterMap(rt.iterZip(rt.iterBorrow(r153), new rt.Range(0, n4), "len"), (_220: [rt.i64, rt.usize]): rt.i64 => { + const r151: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterCount(rs.iterZip(rs.iterBorrow(r151), new rs.Range(0, n4), "len")), r151); + const r152: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_tuple2_i64_usize(out, rs.iterLast(rs.iterZip(rs.iterBorrow(r152), new rs.Range(0, n4), "len")), r152); + const r153: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_usize(out, rs.iterToVec(rs.iterMap(rs.iterZip(rs.iterBorrow(r153), new rs.Range(0, n4), "len"), (_220: [rs.i64, rs.usize]): rs.i64 => { return _220[0]; }), undefined, 8, true).items.length, r153); - const r154: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Option_usize(out, rt.iterPosition(rt.iterZip(rt.iterBorrow(r154), new rt.Range(0, n4), "len"), (_221: [rt.i64, rt.usize]): boolean => { + const r154: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Option_usize(out, rs.iterPosition(rs.iterZip(rs.iterBorrow(r154), new rs.Range(0, n4), "len"), (_221: [rs.i64, rs.usize]): boolean => { return false; }), r154); - const r155: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - state$i64_Result_usize_unit(out, result_map$0ip8nd6(rt.iterCollectResult(rt.iterMap(rt.iterBorrow(r155), (x38: rt.i64): rt.Result => { - return rt.Ok(x38); - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 8)), (v159: rt.Vec): rt.usize => { + const r155: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + state$i64_Result_usize_unit(out, result_map$1eib7de(rs.iterCollectResult(rs.iterMap(rs.iterBorrow(r155), (x38: rs.i64): rs.Result => { + return rs.Ok(x38); + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 8)), (v159: rs.Vec): rs.usize => { return v159.items.length; }), r155); - const r156: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const _1465: rt.RangeInclusive = r156; - const _1467: (a0: rt.i64) => rt.i64 | undefined = (x39: rt.i64): rt.i64 | undefined => { + const r156: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const _1465: rs.RangeInclusive = r156; + const _1467: (a0: rs.i64) => rs.i64 | undefined = (x39: rs.i64): rs.i64 | undefined => { if (!isK3(x39)) { return x39; } return undefined; }; - state$i64_Option_usize(out, option_map$13980cl(rt.iterCollectOption(rt.iterMap(rt.iterBorrow(_1465), _1467), (values: rt.Iter) => rt.iterToVec(values, undefined, 8)), (v160: rt.Vec): rt.usize => { + state$i64_Option_usize(out, option_map$122xb11(rs.iterCollectOption(rs.iterMap(rs.iterBorrow(_1465), _1467), (values: rs.Iter) => rs.iterToVec(values, undefined, 8)), (v160: rs.Vec): rs.usize => { return v160.items.length; }), r156); - const r157: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const v156: rt.Vec = new rt.Vec(); - const _1477: rt.Iter = rt.iterMap(rt.iterBorrow(r157), (x40: rt.i64): rt.i64 => { + const r157: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const v156: rs.Vec = new rs.Vec(); + const _1477: rs.Iter = rs.iterMap(rs.iterBorrow(r157), (x40: rs.i64): rs.i64 => { return x40; }); - rt.iterExtend(v156, _1477, undefined, 8, true); + rs.iterExtend(v156, _1477, undefined, 8, true); state$i64_usize(out, v156.items.length, r157); - const r158: rt.RangeInclusive = new rt.RangeInclusive(lo5, hi5, rt.i64Step); - const v158: rt.Vec = new rt.Vec(); - const _1488: rt.Iter = rt.iterTakeWhile(rt.iterBorrow(r158), (_222: rt.i64): boolean => { + const r158: rs.RangeInclusive = new rs.RangeInclusive(lo5, hi5, rs.i64Step); + const v158: rs.Vec = new rs.Vec(); + const _1488: rs.Iter = rs.iterTakeWhile(rs.iterBorrow(r158), (_222: rs.i64): boolean => { return true; }); - rt.iterExtend(v158, _1488, "next", 8); + rs.iterExtend(v158, _1488, "next", 8); state$i64_usize(out, v158.items.length, r158); } } diff --git a/ts/fixtures/lang/folds/expected/harness.ts b/ts/fixtures/lang/folds/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/folds/expected/harness.ts +++ b/ts/fixtures/lang/folds/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/folds/expected/lib.ts b/ts/fixtures/lang/folds/expected/lib.ts index dda232ae6..b61cf266a 100644 --- a/ts/fixtures/lang/folds/expected/lib.ts +++ b/ts/fixtures/lang/folds/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { folds } from "./folds.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["folds::folds", folds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["folds::folds", folds as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/futures/expected/awaits.Countdown.ts b/ts/fixtures/lang/futures/expected/awaits.Countdown.ts index 1847da264..404776f4b 100644 --- a/ts/fixtures/lang/futures/expected/awaits.Countdown.ts +++ b/ts/fixtures/lang/futures/expected/awaits.Countdown.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Noted from "./awaits.Noted.ts"; /** The crate's own iterator, counting down to zero, which logs as it drops. */ export class Countdown { - _0: rt.u8; - _1: rt.Arc>; + _0: rs.u8; + _1: rs.Arc>; - constructor(_0: rt.u8, _1: rt.Arc>) { + constructor(_0: rs.u8, _1: rs.Arc>) { this._0 = _0; this._1 = _1; } @@ -19,19 +19,19 @@ export class Countdown { } } -export function next$iter_Iterator(self: Countdown): Noted.Noted | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Countdown): Noted.Noted | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; - return new Noted.Noted(self._0, rt.arcClone(self._1)); + return new Noted.Noted(self._0, rs.arcClone(self._1)); } - return rt.DONE; + return rs.DONE; } export function drop$ops_Drop(self: Countdown): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1.value); - rt.byteVecPush(_5.value, 192 | self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1.value); + rs.byteVecPush(_5.value, 192 | self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=awaits.Countdown.ts.map diff --git a/ts/fixtures/lang/futures/expected/awaits.Noted.ts b/ts/fixtures/lang/futures/expected/awaits.Noted.ts index d90648f6c..be41a5f7e 100644 --- a/ts/fixtures/lang/futures/expected/awaits.Noted.ts +++ b/ts/fixtures/lang/futures/expected/awaits.Noted.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A byte that writes itself into the log as it drops. */ export class Noted { - _0: rt.u8; - _1: rt.Arc>; + _0: rs.u8; + _1: rs.Arc>; - constructor(_0: rt.u8, _1: rt.Arc>) { + constructor(_0: rs.u8, _1: rs.Arc>) { this._0 = _0; this._1 = _1; } @@ -19,21 +19,21 @@ export class Noted { } export function drop$ops_Drop(self: Noted): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1.value); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1.value); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } export function eq$cmp_PartialEq(self: Noted, other: Noted): boolean { return self._0 === other._0; } -export function partialCmp$cmp_PartialOrd(self: Noted, other: Noted): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Noted, other: Noted): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Noted, other: Noted): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Noted, other: Noted): rs.Ordering { + return rs.cmp(self._0, other._0); } //# sourceMappingURL=awaits.Noted.ts.map diff --git a/ts/fixtures/lang/futures/expected/awaits.Yield.ts b/ts/fixtures/lang/futures/expected/awaits.Yield.ts index 064de9b15..5511dcca0 100644 --- a/ts/fixtures/lang/futures/expected/awaits.Yield.ts +++ b/ts/fixtures/lang/futures/expected/awaits.Yield.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Pending on its first poll, which wakes its task, and ready on the next. */ export interface Yield { _0: boolean; } -export function poll$Future(self: Yield, cx: rt.Context): rt.Poll { +export function poll$Future(self: Yield, cx: rs.Context): rs.Poll { if (!self._0) { self._0 = true; cx.wakeByRef(); - return rt.Pending; + return rs.Pending; } return undefined; } diff --git a/ts/fixtures/lang/futures/expected/awaits.ts b/ts/fixtures/lang/futures/expected/awaits.ts index 9731ee069..411784547 100644 --- a/ts/fixtures/lang/futures/expected/awaits.ts +++ b/ts/fixtures/lang/futures/expected/awaits.ts @@ -1,74 +1,74 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Countdown from "./awaits.Countdown.ts"; import * as Noted from "./awaits.Noted.ts"; import * as Yield from "./awaits.Yield.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** * The iterators `kind` picks, each over at most 16 bytes, dropped after each number of * polls until one is ready, with what each drop logs. */ -export function awaits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 16)); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const items: () => rt.Iter = (): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_22: rt.u8): Noted.Noted => { - return new Noted.Noted(_22, rt.arcClone(log)); +export function awaits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 16)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const items: () => rs.Iter = (): rs.Iter => { + return rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_22: rs.u8): Noted.Noted => { + return new Noted.Noted(_22, rs.arcClone(log)); }); }; - const _13: rt.u8 = rt.u8Rem(kind, 11); + const _13: rs.u8 = rs.u8Rem(kind, 11); if (_13 === 0) { - run$awaits_each_closure0_Vec_awaits_Noted_awaits_awaits_closure1((): rt.Future => { - return new eachFuture$Vec_awaits_Noted(rt.iterToVec(items(), undefined, 8, true)); + run$awaits_each_closure0_Vec_awaits_Noted_awaits_awaits_closure1((): rs.Future => { + return new eachFuture$Vec_awaits_Noted(rs.iterToVec(items(), undefined, 8, true)); }, log.value, out); } else if (_13 === 1) { - run$awaits_each_closure0_collections_VecDeque_awaits_Noted_awaits_awaits_closure2((): rt.Future => { - return new eachFuture$collections_VecDeque_awaits_Noted(rt.dequeFromVec(rt.iterToVec(items(), undefined, 8, true), 8) as rt.VecDeque); + run$awaits_each_closure0_collections_VecDeque_awaits_Noted_awaits_awaits_closure2((): rs.Future => { + return new eachFuture$collections_VecDeque_awaits_Noted(rs.dequeFromVec(rs.iterToVec(items(), undefined, 8, true), 8) as rs.VecDeque); }, log.value, out); } else if (_13 === 2) { - run$awaits_each_closure0_collections_btree_set_IntoIter_awaits_Noted_awaits_awaits_closure3((): rt.Future => { - const _413: rt.Iter = items(); - return new eachFuture$collections_btree_set_IntoIter_awaits_Noted(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(Noted.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_413, undefined, 8, true).items, 8, true, rt.cmpLt(Noted.partialCmp$cmp_PartialOrd), Noted.eq$cmp_PartialEq, rt.drop), rt.drop)); + run$awaits_each_closure0_collections_btree_set_IntoIter_awaits_Noted_awaits_awaits_closure3((): rs.Future => { + const _413: rs.Iter = items(); + return new eachFuture$collections_btree_set_IntoIter_awaits_Noted(rs.btreeKeys(rs.btreeCollectKeys(rs.btreeNew(Noted.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_413, undefined, 8, true).items, 8, true, rs.cmpLt(Noted.partialCmp$cmp_PartialOrd), Noted.eq$cmp_PartialEq, rs.drop), rs.drop)); }, log.value, out); } else if (_13 === 3) { - run$awaits_each_closure0_collections_btree_map_IntoValues_u8_awaits_Noted_awaits_awaits_closure4((): rt.Future => { - const _412: rt.Iter<[rt.u8, Noted.Noted]> = rt.iterMap(items(), (l2: Noted.Noted): [rt.u8, Noted.Noted] => { - return [l2._0, l2] as [rt.u8, Noted.Noted]; + run$awaits_each_closure0_collections_btree_map_IntoValues_u8_awaits_Noted_awaits_awaits_closure4((): rs.Future => { + const _412: rs.Iter<[rs.u8, Noted.Noted]> = rs.iterMap(items(), (l2: Noted.Noted): [rs.u8, Noted.Noted] => { + return [l2._0, l2] as [rs.u8, Noted.Noted]; }); - return new eachFuture$collections_btree_map_IntoValues_u8_awaits_Noted(rt.btreeValues(rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToVec(_412, undefined, 12, true).items, 12, true, undefined, undefined, rt.drop), undefined, rt.drop)); + return new eachFuture$collections_btree_map_IntoValues_u8_awaits_Noted(rs.btreeValues(rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_412, undefined, 12, true).items, 12, true, undefined, undefined, rs.drop), undefined, rs.drop)); }, log.value, out); } else if (_13 === 4) { - run$awaits_each_closure0_awaits_Countdown_awaits_awaits_closure5((): rt.Future => { - return new eachFuture$awaits_Countdown(new Countdown.Countdown(data2.length & 0xff, rt.arcClone(log))); + run$awaits_each_closure0_awaits_Countdown_awaits_awaits_closure5((): rs.Future => { + return new eachFuture$awaits_Countdown(new Countdown.Countdown(data2.length & 0xff, rs.arcClone(log))); }, log.value, out); } else if (_13 === 5) { - run$awaits_each_closure0_iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted_awaits_awaits_closure6((): rt.Future => { - return new eachFuture$iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted(rt.iterStepBy(rt.iterSkip(rt.iterRev(rt.vecIntoIter(rt.iterToVec(items(), undefined, 8, true), rt.drop)), 1, rt.drop), 2, rt.drop)); + run$awaits_each_closure0_iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted_awaits_awaits_closure6((): rs.Future => { + return new eachFuture$iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted(rs.iterStepBy(rs.iterSkip(rs.iterRev(rs.vecIntoIter(rs.iterToVec(items(), undefined, 8, true), rs.drop)), 1, rs.drop), 2, rs.drop)); }, log.value, out); } else if (_13 === 6) { - run$awaits_each_closure0_iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted_awaits_awaits_closure7((): rt.Future => { - return new eachFuture$iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted(rt.iterChain(rt.iterFilter(rt.vecIntoIter(rt.iterToVec(items(), undefined, 8, true), rt.drop), (l: Noted.Noted): boolean => { - return rt.u8Rem(l._0, 3) !== 0; - }, rt.drop), rt.dequeIntoIter(rt.dequeFromVec(rt.iterToVec(items(), undefined, 8, true), 8) as rt.VecDeque, rt.drop))); + run$awaits_each_closure0_iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted_awaits_awaits_closure7((): rs.Future => { + return new eachFuture$iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted(rs.iterChain(rs.iterFilter(rs.vecIntoIter(rs.iterToVec(items(), undefined, 8, true), rs.drop), (l: Noted.Noted): boolean => { + return rs.u8Rem(l._0, 3) !== 0; + }, rs.drop), rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(items(), undefined, 8, true), 8) as rs.VecDeque, rs.drop))); }, log.value, out); } else if (_13 === 7) { - run$awaits_drain_closure0_awaits_awaits_closure8((): rt.Future => { - return new drainFuture(rt.iterToVec(items(), undefined, 8, true), rt.usizeDiv(data2.length, 2)); + run$awaits_drain_closure0_awaits_awaits_closure8((): rs.Future => { + return new drainFuture(rs.iterToVec(items(), undefined, 8, true), rs.usizeDiv(data2.length, 2)); }, log.value, out); } else if (_13 === 8) { - run$awaits_inline_closure0_awaits_awaits_closure9((): rt.Future => { - return inline(rt.byteSliceToByteVec(data2)); + run$awaits_inline_closure0_awaits_awaits_closure9((): rs.Future => { + return inline(rs.byteSliceToByteVec(data2)); }, log.value, out); } else if (_13 === 9) { - run$awaits_borrowed_closure0_awaits_awaits_closure10((): rt.Future => { - return new borrowedFuture(rt.iterToVec(items(), undefined, 8, true)); + run$awaits_borrowed_closure0_awaits_awaits_closure10((): rs.Future => { + return new borrowedFuture(rs.iterToVec(items(), undefined, 8, true)); }, log.value, out); } else { - run$awaits_hashed_closure0_awaits_awaits_closure11((): rt.Future => { - const _32: rt.Iter = rt.iterSlice(rt.byteSliceView(data2)); - return new hashedFuture(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _32, undefined, undefined, 469762048)); + run$awaits_hashed_closure0_awaits_awaits_closure11((): rs.Future => { + const _32: rs.Iter = rs.iterSlice(rs.byteSliceView(data2)); + return new hashedFuture(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _32, undefined, undefined, 469762048)); }, log.value, out); } log[Symbol.dispose](); @@ -78,29 +78,29 @@ export function awaits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_borrowed_closure0_awaits_awaits_closure10(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_borrowed_closure0_awaits_awaits_closure10(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -111,29 +111,29 @@ export function run$awaits_borrowed_closure0_awaits_awaits_closure10(make: () => * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_drain_closure0_awaits_awaits_closure8(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_drain_closure0_awaits_awaits_closure8(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -144,29 +144,29 @@ export function run$awaits_drain_closure0_awaits_awaits_closure8(make: () => rt. * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_Vec_awaits_Noted_awaits_awaits_closure1(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_Vec_awaits_Noted_awaits_awaits_closure1(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -177,29 +177,29 @@ export function run$awaits_each_closure0_Vec_awaits_Noted_awaits_awaits_closure1 * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_awaits_Countdown_awaits_awaits_closure5(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_awaits_Countdown_awaits_awaits_closure5(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -210,29 +210,29 @@ export function run$awaits_each_closure0_awaits_Countdown_awaits_awaits_closure5 * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_collections_VecDeque_awaits_Noted_awaits_awaits_closure2(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_collections_VecDeque_awaits_Noted_awaits_awaits_closure2(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -243,29 +243,29 @@ export function run$awaits_each_closure0_collections_VecDeque_awaits_Noted_await * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_collections_btree_map_IntoValues_u8_awaits_Noted_awaits_awaits_closure4(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_collections_btree_map_IntoValues_u8_awaits_Noted_awaits_awaits_closure4(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -276,29 +276,29 @@ export function run$awaits_each_closure0_collections_btree_map_IntoValues_u8_awa * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_collections_btree_set_IntoIter_awaits_Noted_awaits_awaits_closure3(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_collections_btree_set_IntoIter_awaits_Noted_awaits_awaits_closure3(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -309,29 +309,29 @@ export function run$awaits_each_closure0_collections_btree_set_IntoIter_awaits_N * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted_awaits_awaits_closure7(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted_awaits_awaits_closure7(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -342,29 +342,29 @@ export function run$awaits_each_closure0_iter_Chain_iter_Filter_vec_IntoIter_awa * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_each_closure0_iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted_awaits_awaits_closure6(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_each_closure0_iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted_awaits_awaits_closure6(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -375,29 +375,29 @@ export function run$awaits_each_closure0_iter_StepBy_iter_Skip_iter_Rev_vec_Into * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_hashed_closure0_awaits_awaits_closure11(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_hashed_closure0_awaits_awaits_closure11(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -408,29 +408,29 @@ export function run$awaits_hashed_closure0_awaits_awaits_closure11(make: () => r * Each future `make` makes, polled one more time than the last until one is ready, then * dropped: what it gives, or that it is still pending, and what dropping it logs. */ -export function run$awaits_inline_closure0_awaits_awaits_closure9(make: () => rt.Future, log: rt.RefCell, out: rt.ByteVec): void { - const cx: rt.Context = rt.NOOP_WAKER; - const iter: rt.RangeFrom = new rt.RangeFrom(0, rt.i32Step); +export function run$awaits_inline_closure0_awaits_awaits_closure9(make: () => rs.Future, log: rs.RefCell, out: rs.ByteVec): void { + const cx: rs.Context = rs.NOOP_WAKER; + const iter: rs.RangeFrom = new rs.RangeFrom(0, rs.i32Step); while (true) { - const _9: rt.i32 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.i32 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const polls: rt.i32 = _9; - const f: rt.Future = make(); - const ready: rt.u8 | undefined = rt.iterFindMap(new rt.Range(0, polls), (_2: rt.i32): rt.u8 | undefined => { - const _3: rt.Poll = f.poll(cx); - if (_3 !== rt.Pending) { + const polls: rs.i32 = _9; + const f: rs.Future = make(); + const ready: rs.u8 | undefined = rs.iterFindMap(new rs.Range(0, polls), (_2: rs.i32): rs.u8 | undefined => { + const _3: rs.Poll = f.poll(cx); + if (_3 !== rs.Pending) { return _3; } return undefined; }); - const _25: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_25.value, 254); - rt.refMutRelease(_25); - rt.drop(f); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(ready, 238)); - rt.byteVecAppend(out, rt.refCellReplace(log, new rt.ByteVec())); + const _25: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_25.value, 254); + rs.refMutRelease(_25); + rs.drop(f); + rs.byteVecPush(out, option_unwrapOr$1fr498u(ready, 238)); + rs.byteVecAppend(out, rs.refCellReplace(log, new rs.ByteVec())); if (ready !== undefined) { break; } @@ -439,48 +439,48 @@ export function run$awaits_inline_closure0_awaits_awaits_closure9(make: () => rt export class eachFuture$Vec_awaits_Noted { #state: number = 0; - #items: rt.Vec; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.Vec; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.Vec) { + constructor(items: rs.Vec) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.dropVec(this.#items); + rs.dropVec(this.#items); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.Vec = this.#items; + const items: rs.Vec = this.#items; this.#sum = 0; - this.#iter = rt.vecIntoIter(items, rt.drop); + this.#iter = rs.vecIntoIter(items, rs.drop); bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -489,14 +489,14 @@ export class eachFuture$Vec_awaits_Noted { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -505,7 +505,7 @@ export class eachFuture$Vec_awaits_Noted { export class eachFuture$awaits_Countdown { #state: number = 0; #items: Countdown.Countdown; - #sum!: rt.u8; + #sum!: rs.u8; #iter!: Countdown.Countdown; #item!: Noted.Noted; #awaitee!: Yield.Yield; @@ -523,7 +523,7 @@ export class eachFuture$awaits_Countdown { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { @@ -536,16 +536,16 @@ export class eachFuture$awaits_Countdown { continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = Countdown.next$iter_Iterator(this.#iter); - if (_5 === rt.DONE) { + const _5: Noted.Noted | rs.Done = Countdown.next$iter_Iterator(this.#iter); + if (_5 === rs.DONE) { this.#iter[Symbol.dispose](); - const _0: rt.Poll = this.#sum; + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -554,14 +554,14 @@ export class eachFuture$awaits_Countdown { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -569,48 +569,48 @@ export class eachFuture$awaits_Countdown { export class eachFuture$collections_VecDeque_awaits_Noted { #state: number = 0; - #items: rt.VecDeque; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.VecDeque; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.VecDeque) { + constructor(items: rs.VecDeque) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.dequeDrop(this.#items, rt.drop); + rs.dequeDrop(this.#items, rs.drop); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.VecDeque = this.#items; + const items: rs.VecDeque = this.#items; this.#sum = 0; - this.#iter = rt.dequeIntoIter(items, rt.drop); + this.#iter = rs.dequeIntoIter(items, rs.drop); bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -619,14 +619,14 @@ export class eachFuture$collections_VecDeque_awaits_Noted { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -634,48 +634,48 @@ export class eachFuture$collections_VecDeque_awaits_Noted { export class eachFuture$collections_btree_map_IntoValues_u8_awaits_Noted { #state: number = 0; - #items: rt.Iter; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.Iter; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.Iter) { + constructor(items: rs.Iter) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#items); + rs.drop(this.#items); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.Iter = this.#items; + const items: rs.Iter = this.#items; this.#sum = 0; this.#iter = items; bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -684,14 +684,14 @@ export class eachFuture$collections_btree_map_IntoValues_u8_awaits_Noted { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -699,48 +699,48 @@ export class eachFuture$collections_btree_map_IntoValues_u8_awaits_Noted { export class eachFuture$collections_btree_set_IntoIter_awaits_Noted { #state: number = 0; - #items: rt.Iter; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.Iter; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.Iter) { + constructor(items: rs.Iter) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#items); + rs.drop(this.#items); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.Iter = this.#items; + const items: rs.Iter = this.#items; this.#sum = 0; this.#iter = items; bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -749,14 +749,14 @@ export class eachFuture$collections_btree_set_IntoIter_awaits_Noted { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -764,48 +764,48 @@ export class eachFuture$collections_btree_set_IntoIter_awaits_Noted { export class eachFuture$iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_awaits_closure7_closure0_collections_vec_deque_IntoIter_awaits_Noted { #state: number = 0; - #items: rt.Iter; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.Iter; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.Iter) { + constructor(items: rs.Iter) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#items); + rs.drop(this.#items); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.Iter = this.#items; + const items: rs.Iter = this.#items; this.#sum = 0; this.#iter = items; bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -814,14 +814,14 @@ export class eachFuture$iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_ bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -829,48 +829,48 @@ export class eachFuture$iter_Chain_iter_Filter_vec_IntoIter_awaits_Noted_awaits_ export class eachFuture$iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted { #state: number = 0; - #items: rt.Iter; - #sum!: rt.u8; - #iter!: rt.Iter; + #items: rs.Iter; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(items: rt.Iter) { + constructor(items: rs.Iter) { this.#items = items; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#items); + rs.drop(this.#items); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); + rs.drop(this.#iter); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const items: rt.Iter = this.#items; + const items: rs.Iter = this.#items; this.#sum = 0; this.#iter = items; bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - rt.drop(this.#iter); - const _0: rt.Poll = this.#sum; + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + rs.drop(this.#iter); + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -879,14 +879,14 @@ export class eachFuture$iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -894,52 +894,52 @@ export class eachFuture$iter_StepBy_iter_Skip_iter_Rev_vec_IntoIter_awaits_Noted export class drainFuture { #state: number = 0; - #v: rt.Vec; - #from: rt.usize; - #sum!: rt.u8; - #iter!: rt.Iter; + #v: rs.Vec; + #from: rs.usize; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(v: rt.Vec, from: rt.usize) { + constructor(v: rs.Vec, from: rs.usize) { this.#v = v; this.#from = from; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.dropVec(this.#v); + rs.dropVec(this.#v); } else if (this.#state === 3) { this.#item[Symbol.dispose](); - rt.drop(this.#iter); - rt.dropVec(this.#v); + rs.drop(this.#iter); + rs.dropVec(this.#v); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const from: rt.usize = this.#from; + const from: rs.usize = this.#from; this.#sum = 0; - this.#iter = rt.vecDrain(this.#v, new rt.RangeFrom(from, rt.usizeStep), rt.drop); + this.#iter = rs.vecDrain(this.#v, new rs.RangeFrom(from, rs.usizeStep), rs.drop); bb0 = 3; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 9; continue; } case 3: - const _8: Noted.Noted | rt.Done = this.#iter.next(); - if (_8 === rt.DONE) { - rt.drop(this.#iter); - const _28: rt.u8 = rt.u8WrappingAdd(this.#sum, this.#v.items.length & 0xff); - rt.dropVec(this.#v); + const _8: Noted.Noted | rs.Done = this.#iter.next(); + if (_8 === rs.DONE) { + rs.drop(this.#iter); + const _28: rs.u8 = rs.u8WrappingAdd(this.#sum, this.#v.items.length & 0xff); + rs.dropVec(this.#v); this.#state = 1; return _28; } @@ -948,45 +948,45 @@ export class drainFuture { bb0 = 9; continue; case 9: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); this.#item[Symbol.dispose](); bb0 = 3; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } } /** `for n in v` in an `async` block, and a range, which step in place outside one. */ -export function inline(v: rt.ByteVec): rt.Future { +export function inline(v: rs.ByteVec): rs.Future { return new inlineFuture$closure0(v); } export class inlineFuture$closure0 { #state: number = 0; - #v: rt.ByteVec; - #sum!: rt.u8; - #len!: rt.usize; - #iter!: rt.Iter; - #saved!: rt.u8; - #awaitee!: rt.Ready; + #v: rs.ByteVec; + #sum!: rs.u8; + #len!: rs.usize; + #iter!: rs.Iter; + #saved!: rs.u8; + #awaitee!: rs.Ready; #awaitee$2!: Yield.Yield; - #iter$2!: rt.Range; - #i!: rt.usize; + #iter$2!: rs.Range; + #i!: rs.usize; - constructor(v: rt.ByteVec) { + constructor(v: rs.ByteVec) { this.#v = v; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { - let _34!: rt.usize; + poll(_2: rs.Context): rs.Poll { + let _34!: rs.usize; let bb0: number = 0; while (true) { switch (bb0) { @@ -994,12 +994,12 @@ export class inlineFuture$closure0 { if (this.#state === 0) { this.#sum = 0; this.#len = this.#v.length; - this.#iter = rt.byteVecIntoIter(this.#v); + this.#iter = rs.byteVecIntoIter(this.#v); bb0 = 3; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { if (this.#state === 3) { bb0 = 10; @@ -1013,41 +1013,41 @@ export class inlineFuture$closure0 { continue; } case 3: - const _6: rt.u8 | rt.Done = this.#iter.next(); - if (_6 === rt.DONE) { - this.#iter$2 = new rt.Range(0, this.#len); + const _6: rs.u8 | rs.Done = this.#iter.next(); + if (_6 === rs.DONE) { + this.#iter$2 = new rs.Range(0, this.#len); bb0 = 24; continue; } - const n: rt.u8 = _6; + const n: rs.u8 = _6; this.#saved = this.#sum; - this.#awaitee = new rt.Ready(n); + this.#awaitee = new rs.Ready(n); bb0 = 10; continue; case 10: - const _13: rt.Poll = this.#awaitee.poll(_2); - if (_13 !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#saved, _13); + const _13: rs.Poll = this.#awaitee.poll(_2); + if (_13 !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#saved, _13); this.#awaitee$2 = { _0: false }; bb0 = 17; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 17: - if (Yield.poll$Future(this.#awaitee$2, _2) !== rt.Pending) { + if (Yield.poll$Future(this.#awaitee$2, _2) !== rs.Pending) { bb0 = 3; continue; } this.#state = 4; - return rt.Pending; + return rs.Pending; case 24: const _34Some: boolean = this.#iter$2.start < this.#iter$2.end; if (_34Some) { _34 = this.#iter$2.start++; } if (!_34Some) { - const _0: rt.Poll = this.#sum; + const _0: rs.Poll = this.#sum; this.#state = 1; return _0; } @@ -1056,13 +1056,13 @@ export class inlineFuture$closure0 { bb0 = 29; continue; case 29: - if (Yield.poll$Future(this.#awaitee$2, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(rt.u8WrappingMul(this.#sum, 3), this.#i & 0xff); + if (Yield.poll$Future(this.#awaitee$2, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(rs.u8WrappingMul(this.#sum, 3), this.#i & 0xff); bb0 = 24; continue; } this.#state = 5; - return rt.Pending; + return rs.Pending; } } } @@ -1070,37 +1070,37 @@ export class inlineFuture$closure0 { export class borrowedFuture { #state: number = 0; - #v: rt.Vec; - #sum!: rt.u8; - #iter!: rt.Iter; + #v: rs.Vec; + #sum!: rs.u8; + #iter!: rs.Iter; #item!: Noted.Noted; #awaitee!: Yield.Yield; - constructor(v: rt.Vec) { + constructor(v: rs.Vec) { this.#v = v; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.dropVec(this.#v); + rs.dropVec(this.#v); } else if (this.#state === 3 || this.#state === 4 || this.#state === 5) { - rt.dropVec(this.#v); + rs.dropVec(this.#v); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { this.#sum = 0; - this.#iter = rt.iterSlice(this.#v.items); + this.#iter = rs.iterSlice(this.#v.items); bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { if (this.#state === 3) { bb0 = 8; @@ -1114,9 +1114,9 @@ export class borrowedFuture { continue; } case 2: - const _5: Noted.Noted | rt.Done = this.#iter.next(); - if (_5 === rt.DONE) { - this.#iter = rt.iterSlice(this.#v.items); + const _5: Noted.Noted | rs.Done = this.#iter.next(); + if (_5 === rs.DONE) { + this.#iter = rs.iterSlice(this.#v.items); bb0 = 15; continue; } @@ -1125,18 +1125,18 @@ export class borrowedFuture { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - const _18: rt.u8 = rt.u8WrappingAdd(this.#item._0, 1); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + const _18: rs.u8 = rs.u8WrappingAdd(this.#item._0, 1); this.#item._0 = _18; bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 15: - const _22: Noted.Noted | rt.Done = this.#iter.next(); - if (_22 === rt.DONE) { - this.#iter = rt.iterRev(rt.iterSlice(this.#v.items)); + const _22: Noted.Noted | rs.Done = this.#iter.next(); + if (_22 === rs.DONE) { + this.#iter = rs.iterRev(rs.iterSlice(this.#v.items)); bb0 = 30; continue; } @@ -1145,18 +1145,18 @@ export class borrowedFuture { bb0 = 20; continue; case 20: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#item._0); bb0 = 15; continue; } this.#state = 4; - return rt.Pending; + return rs.Pending; case 30: - const _43: Noted.Noted | rt.Done = this.#iter.next(); - if (_43 === rt.DONE) { - const _60: rt.u8 = this.#sum; - rt.dropVec(this.#v); + const _43: Noted.Noted | rs.Done = this.#iter.next(); + if (_43 === rs.DONE) { + const _60: rs.u8 = this.#sum; + rs.dropVec(this.#v); this.#state = 1; return _60; } @@ -1165,13 +1165,13 @@ export class borrowedFuture { bb0 = 35; continue; case 35: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(rt.u8WrappingMul(this.#sum, 7), this.#item._0); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(rs.u8WrappingMul(this.#sum, 7), this.#item._0); bb0 = 30; continue; } this.#state = 5; - return rt.Pending; + return rs.Pending; } } } @@ -1179,43 +1179,43 @@ export class borrowedFuture { export class hashedFuture { #state: number = 0; - #set: rt.HashSet; - #sum!: rt.u8; - #count!: rt.u8; - #iter!: rt.Iter; - #n!: rt.u8; + #set: rs.HashSet; + #sum!: rs.u8; + #count!: rs.u8; + #iter!: rs.Iter; + #n!: rs.u8; #awaitee!: Yield.Yield; - constructor(set: rt.HashSet) { + constructor(set: rs.HashSet) { this.#set = set; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const set: rt.HashSet = this.#set; + const set: rs.HashSet = this.#set; this.#sum = 0; this.#count = 0; - this.#iter = rt.hashKeys(set); + this.#iter = rs.hashKeys(set); bb0 = 2; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 8; continue; } case 2: - const _6: rt.u8 | rt.Done = this.#iter.next(); - if (_6 === rt.DONE) { - const _0: rt.Poll = this.#sum ^ this.#count; + const _6: rs.u8 | rs.Done = this.#iter.next(); + if (_6 === rs.DONE) { + const _0: rs.Poll = this.#sum ^ this.#count; this.#state = 1; return _0; } @@ -1224,14 +1224,14 @@ export class hashedFuture { bb0 = 8; continue; case 8: - if (Yield.poll$Future(this.#awaitee, _2) !== rt.Pending) { - this.#sum = rt.u8WrappingAdd(this.#sum, this.#n); - this.#count = rt.u8Add(this.#count, 1); + if (Yield.poll$Future(this.#awaitee, _2) !== rs.Pending) { + this.#sum = rs.u8WrappingAdd(this.#sum, this.#n); + this.#count = rs.u8Add(this.#count, 1); bb0 = 2; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } diff --git a/ts/fixtures/lang/futures/expected/core/option.ts b/ts/fixtures/lang/futures/expected/core/option.ts index 1b83f77ea..51bf76f90 100644 --- a/ts/fixtures/lang/futures/expected/core/option.ts +++ b/ts/fixtures/lang/futures/expected/core/option.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$13g654t(self: rt.Waker | undefined, default_: rt.Place, _: (a0: rt.Waker) => rt.Place): rt.Place { +export function mapOr$1ntkzhx(self: rs.Waker | undefined, default_: rs.Place, _: (a0: rs.Waker) => rs.Place): rs.Place { if (self === undefined) { return default_; } - return self.data as rt.Place; + return self.data as rs.Place; } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } diff --git a/ts/fixtures/lang/futures/expected/core/task/poll.ts b/ts/fixtures/lang/futures/expected/core/task/poll.ts index 096dffd4f..9543a1330 100644 --- a/ts/fixtures/lang/futures/expected/core/task/poll.ts +++ b/ts/fixtures/lang/futures/expected/core/task/poll.ts @@ -1,59 +1,59 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import type * as Logged from "../../futures.Logged.ts"; -export function eq$11qt6c3(self: rt.Poll | rt.OuterPending, other: rt.Poll | rt.OuterPending): boolean { - if (!((self !== rt.OuterPending ? 0 : 1) === (other !== rt.OuterPending ? 0 : 1))) { +export function eq$1o5v7fd(self: rs.Poll | rs.OuterPending, other: rs.Poll | rs.OuterPending): boolean { + if (!((self !== rs.OuterPending ? 0 : 1) === (other !== rs.OuterPending ? 0 : 1))) { return false; } - if (self !== rt.OuterPending) { - if (other !== rt.OuterPending) { - return eq$1h9nnoh(self, other); + if (self !== rs.OuterPending) { + if (other !== rs.OuterPending) { + return eq$1qrb1lw(self, other); } } return true; } -export function eq$1h9nnoh(self: rt.Poll, other: rt.Poll): boolean { - if (!((self !== rt.Pending ? 0 : 1) === (other !== rt.Pending ? 0 : 1))) { +export function eq$1qrb1lw(self: rs.Poll, other: rs.Poll): boolean { + if (!((self !== rs.Pending ? 0 : 1) === (other !== rs.Pending ? 0 : 1))) { return false; } - if (self !== rt.Pending) { - if (other !== rt.Pending) { + if (self !== rs.Pending) { + if (other !== rs.Pending) { return self === other; } } return true; } -export function map$0fx224j(self: rt.Poll, f: (a0: rt.u8 | undefined) => rt.u8 | undefined): rt.Poll { - if (self !== rt.Pending) { +export function map$1jzbsum(self: rs.Poll, f: (a0: rs.u8 | undefined) => rs.u8 | undefined): rs.Poll { + if (self !== rs.Pending) { return f(self); } - return rt.Pending; + return rs.Pending; } -export function isReady$1tqk3za(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$01y72dm(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isReady$1ntq2i8(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$1olyx0w(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isPending$1405yze(self: rt.Poll): boolean { - return !isReady$1tqk3za(self); +export function isPending$0bap0yh(self: rs.Poll): boolean { + return !isReady$01y72dm(self); } -export function isPending$0vrdvv1(self: rt.Poll): boolean { - return !isReady$1ntq2i8(self); +export function isPending$189w6zf(self: rs.Poll): boolean { + return !isReady$1olyx0w(self); } //# sourceMappingURL=poll.ts.map diff --git a/ts/fixtures/lang/futures/expected/core/task/wake.ts b/ts/fixtures/lang/futures/expected/core/task/wake.ts index c0f52f750..9a58ac896 100644 --- a/ts/fixtures/lang/futures/expected/core/task/wake.ts +++ b/ts/fixtures/lang/futures/expected/core/task/wake.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$0n9bv8t(self: rt.RawWaker, other: rt.RawWaker): boolean { +export function eq$1ohvggu(self: rs.RawWaker, other: rs.RawWaker): boolean { if (!(self.data === other.data)) { return false; } - return eq$0xaykl8(self.vtable, other.vtable); + return eq$1obrnmy(self.vtable, other.vtable); } -export function eq$0xaykl8(self: rt.WakerVTable, other: rt.WakerVTable): boolean { +export function eq$1obrnmy(self: rs.WakerVTable, other: rs.WakerVTable): boolean { if (self.clone === other.clone) { if (self.wake === other.wake) { if (self.wakeByRef === other.wakeByRef) { diff --git a/ts/fixtures/lang/futures/expected/futures.Count.ts b/ts/fixtures/lang/futures/expected/futures.Count.ts index 0551e2902..c9b6cdc92 100644 --- a/ts/fixtures/lang/futures/expected/futures.Count.ts +++ b/ts/fixtures/lang/futures/expected/futures.Count.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Counts the wakes through it. */ export interface Count { - _0: rt.Atomic; + _0: rs.Atomic; } -export function wake$task_Wake(self: rt.Arc): void { - rt.atomicFetch(self.value._0, rt.u8WrappingAdd, 1, 0); +export function wake$task_Wake(self: rs.Arc): void { + rs.atomicFetch(self.value._0, rs.u8WrappingAdd, 1, 0); self[Symbol.dispose](); } diff --git a/ts/fixtures/lang/futures/expected/futures.Held.ts b/ts/fixtures/lang/futures/expected/futures.Held.ts index 1688ee7b7..e923d8092 100644 --- a/ts/fixtures/lang/futures/expected/futures.Held.ts +++ b/ts/fixtures/lang/futures/expected/futures.Held.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A waker a struct holds. */ export class Held { - waker: rt.Waker; + waker: rs.Waker; - constructor(waker: rt.Waker) { + constructor(waker: rs.Waker) { this.waker = waker; } diff --git a/ts/fixtures/lang/futures/expected/futures.Later.ts b/ts/fixtures/lang/futures/expected/futures.Later.ts index d4aae532c..54e5190be 100644 --- a/ts/fixtures/lang/futures/expected/futures.Later.ts +++ b/ts/fixtures/lang/futures/expected/futures.Later.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The crate's own `IntoFuture`, whose future is std's `Ready`. */ export interface Later { - _0: rt.u8; + _0: rs.u8; } -export function intoFuture$future_IntoFuture(self: Later): rt.Ready { - return new rt.Ready(rt.u8WrappingAdd(self._0, 1)); +export function intoFuture$future_IntoFuture(self: Later): rs.Ready { + return new rs.Ready(rs.u8WrappingAdd(self._0, 1)); } //# sourceMappingURL=futures.Later.ts.map diff --git a/ts/fixtures/lang/futures/expected/futures.Logged.ts b/ts/fixtures/lang/futures/expected/futures.Logged.ts index 436be604b..c62deaaec 100644 --- a/ts/fixtures/lang/futures/expected/futures.Logged.ts +++ b/ts/fixtures/lang/futures/expected/futures.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A byte that writes itself into the log as it drops. */ export class Logged { - _0: rt.u8; - _1: rt.Arc>; + _0: rs.u8; + _1: rs.Arc>; - constructor(_0: rt.u8, _1: rt.Arc>) { + constructor(_0: rs.u8, _1: rs.Arc>) { this._0 = _0; this._1 = _1; } @@ -19,9 +19,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1.value); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1.value); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=futures.Logged.ts.map diff --git a/ts/fixtures/lang/futures/expected/futures.ts b/ts/fixtures/lang/futures/expected/futures.ts index 79788c457..e06851200 100644 --- a/ts/fixtures/lang/futures/expected/futures.ts +++ b/ts/fixtures/lang/futures/expected/futures.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$task_Poll_futures_Logged, drop$tuple2_task_Waker_Option_task_Waker, drop$tuple3_futures_Held_Option_task_Waker_array2_task_Waker } from "./lib.ts"; -import { isSomeAnd$09tpccf, filter$0v80fk8 } from "./core/option.ts"; -import { eq$11qt6c3 as poll_eq$11qt6c3, eq$1h9nnoh as poll_eq$1h9nnoh, map$0fx224j as poll_map$0fx224j, isReady$1ntq2i8, isPending$1405yze, isPending$0vrdvv1 } from "./core/task/poll.ts"; +import { isSomeAnd$1s2u5lz, filter$0hq86nl } from "./core/option.ts"; +import { eq$1o5v7fd as poll_eq$1o5v7fd, eq$1qrb1lw as poll_eq$1qrb1lw, map$1jzbsum as poll_map$1jzbsum, isReady$1olyx0w, isPending$0bap0yh, isPending$189w6zf } from "./core/task/poll.ts"; import * as Count from "./futures.Count.ts"; import * as Held from "./futures.Held.ts"; import * as Later from "./futures.Later.ts"; @@ -11,8 +11,8 @@ import * as Logged from "./futures.Logged.ts"; import { put, text } from "./harness.ts"; /** The futures and polls `kind` picks. */ -export function futures(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 8); +export function futures(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 8); if (_4 === 0) { readies(data, out); } else if (_4 === 1) { @@ -33,246 +33,246 @@ export function futures(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$dyn_Future_usize(f: rt.Future): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$dyn_Future_usize(f: rs.Future): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Pending_futures_Logged(f: rt.Future): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Pending_futures_Logged(f: rs.Future): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Pending_u8(f: rt.Future): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Pending_u8(f: rs.Future): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_String(f: rt.Ready): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Ready_String(f: rs.Ready): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_Vec_u8(f: rt.Ready): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Ready_Vec_u8(f: rs.Ready): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_futures_Logged(f: rt.Ready): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Ready_futures_Logged(f: rs.Ready): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$future_Ready_u8(f: rt.Ready): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$future_Ready_u8(f: rs.Ready): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$futures_dropped_closure0(f: rt.Future): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$futures_dropped_closure0(f: rs.Future): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** What one poll of `f` gives, with a waker that does nothing. */ -export function pollOnce$futures_readies_closure0(f: rt.Future): rt.Poll { - return f.poll(rt.NOOP_WAKER); +export function pollOnce$futures_readies_closure0(f: rs.Future): rs.Poll { + return f.poll(rs.NOOP_WAKER); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Pending_futures_Logged(out: rt.ByteVec, _value: rt.Future): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "Pending")]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "Pending")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Pending_futures_Logged(out: rs.ByteVec, _value: rs.Future): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "Pending")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_PollFn_futures_pendings_closure0(out: rt.ByteVec, _value: rt.Future): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "PollFn")]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "PollFn")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_PollFn_futures_pendings_closure0(out: rs.ByteVec, _value: rs.Future): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "PollFn")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_Option_Option_u8(out: rt.ByteVec, value: rt.Ready): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, (value: rt.u8 | undefined | rt.None, f: rt.Formatter) => rt.fmtOption(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None))]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, (value: rt.u8 | undefined | rt.None, f: rt.Formatter) => rt.fmtOption(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_Option_Option_u8(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined | rs.None, f: rs.Formatter) => rs.fmtOption(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_Option_u8(out: rt.ByteVec, value: rt.Ready): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_Option_u8(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_String(out: rt.ByteVec, value: rt.Ready): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.fmtStr)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.fmtStr)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_String(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtStr)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_u8(out: rt.ByteVec, value: rt.Ready): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.u8Debug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_u8(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.u8Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$future_Ready_unit(out: rt.ByteVec, value: rt.Ready): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.fmtUnit)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => value.debug(f, rt.fmtUnit)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$future_Ready_unit(out: rs.ByteVec, value: rs.Ready): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => value.debug(f, rs.fmtUnit)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_Option_u8(out: rt.ByteVec, value: rt.Poll): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_Option_u8(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_Result_u8_String(out: rt.ByteVec, value: rt.Poll>): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.Result, f: rt.Formatter) => rt.fmtResult(value, f, rt.u8Debug, rt.fmtStr))]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.Result, f: rt.Formatter) => rt.fmtResult(value, f, rt.u8Debug, rt.fmtStr))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_Result_u8_String(out: rs.ByteVec, value: rs.Poll>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtStr))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_String(out: rt.ByteVec, value: rt.Poll): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.fmtStr)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.fmtStr)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_String(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtStr)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_array2_u8(out: rt.ByteVec, value: rt.Poll): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_array2_u8(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_task_Poll_u8(out: rt.ByteVec, value: rt.Poll | rt.OuterPending): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.Poll, f: rt.Formatter) => rt.fmtPoll(value, f, rt.u8Debug), rt.OuterPending)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, (value: rt.Poll, f: rt.Formatter) => rt.fmtPoll(value, f, rt.u8Debug), rt.OuterPending)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_task_Poll_u8(out: rs.ByteVec, value: rs.Poll | rs.OuterPending): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, (value: rs.Poll, f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug), rs.OuterPending)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_u8(out: rt.ByteVec, value: rt.Poll): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.u8Debug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_u8(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.u8Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** `value` written by `Debug`, plain and with `#`, apart by a byte no UTF-8 holds. */ -export function debug$task_Poll_unit(out: rt.ByteVec, value: rt.Poll): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.fmtUnit)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(value, f, rt.fmtUnit)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); +export function debug$task_Poll_unit(out: rs.ByteVec, value: rs.Poll): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(value, f, rs.fmtUnit)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); } /** * Each byte through a `Ready`, by a poll, `into_inner`, an `.await`, and a clone, with * each written before and after it gives its value. */ -export function readies(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const b of rt.byteSliceView(data)) { - const r: rt.Ready = new rt.Ready(b); +export function readies(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const b of rs.byteSliceView(data)) { + const r: rs.Ready = new rs.Ready(b); debug$future_Ready_u8(out, r); - const copy: rt.Ready = r.clone(); - const _16: rt.Poll = pollOnce$future_Ready_u8(r); - if (_16 !== rt.Pending) { - rt.byteVecPush(out, _16); + const copy: rs.Ready = r.clone(); + const _16: rs.Poll = pollOnce$future_Ready_u8(r); + if (_16 !== rs.Pending) { + rs.byteVecPush(out, _16); } else { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } debug$future_Ready_u8(out, r); debug$future_Ready_u8(out, r.clone()); - rt.byteVecPush(out, copy.intoInner()); - const pinned: rt.Future = new readiesFuture$closure0(b); - const _33: rt.Poll = pollOnce$futures_readies_closure0(pinned); - if (_33 !== rt.Pending) { - rt.byteVecPush(out, _33); + rs.byteVecPush(out, copy.intoInner()); + const pinned: rs.Future = new readiesFuture$closure0(b); + const _33: rs.Poll = pollOnce$futures_readies_closure0(pinned); + if (_33 !== rs.Pending) { + rs.byteVecPush(out, _33); } else { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } - rt.drop(pinned); + rs.drop(pinned); } - debug$future_Ready_unit(out, new rt.Ready(undefined)); - debug$future_Ready_Option_u8(out, new rt.Ready(rt.byteSliceFirst(data))); - debug$future_Ready_Option_Option_u8(out, new rt.Ready(rt.None as rt.u8 | undefined | rt.None)); - const text_: rt.Ready = new rt.Ready(text(data)); + debug$future_Ready_unit(out, new rs.Ready(undefined)); + debug$future_Ready_Option_u8(out, new rs.Ready(rs.byteSliceFirst(data))); + debug$future_Ready_Option_Option_u8(out, new rs.Ready(rs.None as rs.u8 | undefined | rs.None)); + const text_: rs.Ready = new rs.Ready(text(data)); debug$future_Ready_String(out, text_); - const _52: rt.Poll = pollOnce$future_Ready_String(text_); - if (_52 !== rt.Pending) { - rt.iterExtendBytes(out, rt.strBytes(_52), undefined, true); + const _52: rs.Poll = pollOnce$future_Ready_String(text_); + if (_52 !== rs.Pending) { + rs.iterExtendBytes(out, rs.strBytes(_52), undefined, true); } debug$future_Ready_String(out, text_); - const boxed: rt.Future = new rt.Ready(data.length); - const _67: rt.Poll = pollOnce$dyn_Future_usize(boxed); - if (_67 !== rt.Pending) { - rt.byteVecPush(out, _67 & 0xff); + const boxed: rs.Future = new rs.Ready(data.length); + const _67: rs.Poll = pollOnce$dyn_Future_usize(boxed); + if (_67 !== rs.Pending) { + rs.byteVecPush(out, _67 & 0xff); } - rt.drop(boxed); + rs.drop(boxed); } export class readiesFuture$closure0 { #state: number = 0; - #b: rt.u8; - #saved!: rt.u8; - #awaitee!: rt.Ready; + #b: rs.u8; + #saved!: rs.u8; + #awaitee!: rs.Ready; - constructor(b: rt.u8) { + constructor(b: rs.u8) { this.#b = b; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { if (this.#state === 0) { - this.#awaitee = new rt.Ready(this.#b ^ 90); + this.#awaitee = new rs.Ready(this.#b ^ 90); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { break b0; } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { this.#saved = _7; this.#awaitee = Later.intoFuture$future_IntoFuture({ _0: this.#b }); } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _18: rt.Poll = this.#awaitee.poll(_2); - if (_18 !== rt.Pending) { - const _0: rt.Poll = rt.u8WrappingAdd(this.#saved, _18); + const _18: rs.Poll = this.#awaitee.poll(_2); + if (_18 !== rs.Pending) { + const _0: rs.Poll = rs.u8WrappingAdd(this.#saved, _18); this.#state = 1; return _0; } this.#state = 4; - return rt.Pending; + return rs.Pending; } } @@ -280,73 +280,73 @@ export class readiesFuture$closure0 { * A `Ready`'s value drops with it unless a poll or `into_inner` gave it away, in order with * the values around it. */ -export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { +export function dropped(data: rs.ByteSlice, out: rs.ByteVec): void { let _103: boolean = false; let _102: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _10: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const i: rt.usize = _10[0]; - const b: rt.u8 = _10[1]; - const before: Logged.Logged = new Logged.Logged(b, rt.arcClone(log)); - const r: rt.Ready = new rt.Ready(new Logged.Logged(b ^ 128, rt.arcClone(log)), rt.drop); + const i: rs.usize = _10[0]; + const b: rs.u8 = _10[1]; + const before: Logged.Logged = new Logged.Logged(b, rs.arcClone(log)); + const r: rs.Ready = new rs.Ready(new Logged.Logged(b ^ 128, rs.arcClone(log)), rs.drop); _103 = true; - const _25: rt.Arc> = rt.arcClone(log); + const _25: rs.Arc> = rs.arcClone(log); _102 = true; const after: Logged.Logged = new Logged.Logged(b ^ 64, _25); - const _28: rt.usize = rt.usizeRem(i, 6); + const _28: rs.usize = rs.usizeRem(i, 6); if (_28 !== 0) { if (_28 === 1) { _103 = false; r[Symbol.dispose](); } else if (_28 === 2) { - const _31: rt.Poll = pollOnce$future_Ready_futures_Logged(r); - if (_31 !== rt.Pending) { + const _31: rs.Poll = pollOnce$future_Ready_futures_Logged(r); + if (_31 !== rs.Pending) { const v: Logged.Logged = _31; - const _39: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_39.value, 240); - rt.refMutRelease(_39); + const _39: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_39.value, 240); + rs.refMutRelease(_39); v[Symbol.dispose](); } - const _46: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_46.value, 241); - rt.refMutRelease(_46); + const _46: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_46.value, 241); + rs.refMutRelease(_46); } else if (_28 === 3) { _103 = false; const v2: Logged.Logged = r.intoInner(); _102 = false; after[Symbol.dispose](); - const _56: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_56.value, v2._0); - rt.refMutRelease(_56); + const _56: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_56.value, v2._0); + rs.refMutRelease(_56); v2[Symbol.dispose](); } else if (_28 === 4) { - const clone: rt.Ready> = new rt.Ready(new rt.Arc(new Logged.Logged(b ^ 32, rt.arcClone(log))), rt.drop); - const copy: rt.Ready> = clone.clone((a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const clone: rs.Ready> = new rs.Ready(new rs.Arc(new Logged.Logged(b ^ 32, rs.arcClone(log))), rs.drop); + const copy: rs.Ready> = clone.clone((a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); }); clone[Symbol.dispose](); - const _71: rt.Arc = copy.intoInner(); - const count: rt.usize = _71.strong; + const _71: rs.Arc = copy.intoInner(); + const count: rs.usize = _71.strong; _71[Symbol.dispose](); - const _75: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_75.value, count & 0xff); - rt.refMutRelease(_75); + const _75: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_75.value, count & 0xff); + rs.refMutRelease(_75); } else { _103 = false; - const pinned: rt.Future = new droppedFuture$closure0(r); - const _83: rt.Poll = pollOnce$futures_dropped_closure0(pinned); - if (_83 !== rt.Pending) { - const v3: rt.u8 = _83; - const _89: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_89.value, v3); - rt.refMutRelease(_89); + const pinned: rs.Future = new droppedFuture$closure0(r); + const _83: rs.Poll = pollOnce$futures_dropped_closure0(pinned); + if (_83 !== rs.Pending) { + const v3: rs.u8 = _83; + const _89: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_89.value, v3); + rs.refMutRelease(_89); } - rt.drop(pinned); + rs.drop(pinned); } } before[Symbol.dispose](); @@ -359,18 +359,18 @@ export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { } _103 = false; } - const _98: rt.RefCell = rt.refCellBorrow(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_98.value))), undefined, true); - rt.refRelease(_98); + const _98: rs.RefCell = rs.refCellBorrow(log.value); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_98.value))), undefined, true); + rs.refRelease(_98); log[Symbol.dispose](); } export class droppedFuture$closure0 { #state: number = 0; - #r: rt.Ready; - #awaitee!: rt.Ready; + #r: rs.Ready; + #awaitee!: rs.Ready; - constructor(r: rt.Ready) { + constructor(r: rs.Ready) { this.#r = r; } @@ -382,80 +382,80 @@ export class droppedFuture$closure0 { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#r; } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { const _3: Logged.Logged = _6; this.#awaitee[Symbol.dispose](); - const _14: rt.u8 = _3._0; + const _14: rs.u8 = _3._0; _3[Symbol.dispose](); this.#state = 1; return _14; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** A `Ready` polled after giving its value panics, as std's does, as does `into_inner`. */ -export function repolled(data: rt.ByteSlice, out: rt.ByteVec): void { - const r: rt.Ready = new rt.Ready(data.length & 0xff); - const _6: rt.Poll = pollOnce$future_Ready_u8(r); - if (_6 !== rt.Pending) { - rt.byteVecPush(out, _6); +export function repolled(data: rs.ByteSlice, out: rs.ByteVec): void { + const r: rs.Ready = new rs.Ready(data.length & 0xff); + const _6: rs.Poll = pollOnce$future_Ready_u8(r); + if (_6 !== rs.Pending) { + rs.byteVecPush(out, _6); } - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (b: rt.u8): boolean => { - return rt.u8Rem(b, 2) === 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (b: rs.u8): boolean => { + return rs.u8Rem(b, 2) === 0; })) { - rt.byteVecPush(out, isReady$1ntq2i8(pollOnce$future_Ready_u8(r)) ? 1 : 0); + rs.byteVecPush(out, isReady$1olyx0w(pollOnce$future_Ready_u8(r)) ? 1 : 0); } - rt.byteVecPush(out, r.intoInner()); + rs.byteVecPush(out, r.intoInner()); } /** `into_inner` of a `Ready` a poll already took. */ -export function reread(data: rt.ByteSlice, out: rt.ByteVec): void { - const r: rt.Ready = new rt.Ready(rt.byteSliceToByteVec(data)); - if (rt.usizeRem(data.length, 2) === 0) { +export function reread(data: rs.ByteSlice, out: rs.ByteVec): void { + const r: rs.Ready = new rs.Ready(rs.byteSliceToByteVec(data)); + if (rs.usizeRem(data.length, 2) === 0) { pollOnce$future_Ready_Vec_u8(r); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(r.intoInner()), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(r.intoInner()), undefined, true); } /** * `pending()` is never ready, however often polled, through a box and cloned, and holds * nothing to drop; `poll_fn`'s future writes only its name. */ -export function pendings(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const _6: rt.Future = rt.NEVER; - rt.NEVER; - const boxed: rt.Future = rt.NEVER; - for (const _11 of rt.byteSliceView(data)) { - const held: Logged.Logged = new Logged.Logged(_11, rt.arcClone(log)); - const _22: rt.Poll = pollOnce$future_Pending_futures_Logged(_6); - rt.byteVecPush(out, isPending$1405yze(_22) ? 1 : 0); +export function pendings(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const _6: rs.Future = rs.NEVER; + rs.NEVER; + const boxed: rs.Future = rs.NEVER; + for (const _11 of rs.byteSliceView(data)) { + const held: Logged.Logged = new Logged.Logged(_11, rs.arcClone(log)); + const _22: rs.Poll = pollOnce$future_Pending_futures_Logged(_6); + rs.byteVecPush(out, isPending$0bap0yh(_22) ? 1 : 0); drop$task_Poll_futures_Logged(_22); - rt.byteVecPush(out, isPending$0vrdvv1(pollOnce$future_Pending_u8(boxed)) ? 1 : 0); - const _38: rt.Poll = pollOnce$future_Pending_futures_Logged(rt.NEVER); - rt.byteVecPush(out, isPending$1405yze(_38) ? 1 : 0); + rs.byteVecPush(out, isPending$189w6zf(pollOnce$future_Pending_u8(boxed)) ? 1 : 0); + const _38: rs.Poll = pollOnce$future_Pending_futures_Logged(rs.NEVER); + rs.byteVecPush(out, isPending$0bap0yh(_38) ? 1 : 0); drop$task_Poll_futures_Logged(_38); held[Symbol.dispose](); } debug$future_Pending_futures_Logged(out, _6); - debug$future_Pending_futures_Logged(out, rt.NEVER); + debug$future_Pending_futures_Logged(out, rs.NEVER); const captured = data.length; - debug$future_PollFn_futures_pendings_closure0(out, new rt.PollFn((_2: rt.Context): rt.Poll => { + debug$future_PollFn_futures_pendings_closure0(out, new rs.PollFn((_2: rs.Context): rs.Poll => { return captured; })); undefined; - const _59: rt.RefCell = rt.refCellBorrow(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_59.value))), undefined, true); - rt.refRelease(_59); + const _59: rs.RefCell = rs.refCellBorrow(log.value); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_59.value))), undefined, true); + rs.refRelease(_59); log[Symbol.dispose](); } @@ -463,32 +463,32 @@ export function pendings(data: rt.ByteSlice, out: rt.ByteVec): void { * `Poll`s written, plain, with `#`, and through a width, which reaches what each holds, * and made `From` what they hold. */ -export function polls(data: rt.ByteSlice, out: rt.ByteVec): void { - let q!: rt.Poll; - let r!: rt.Poll>; - for (const b of rt.byteSliceView(data)) { - const p: rt.Poll = b; - if (!(rt.u8Rem(b, 3) === 0)) { +export function polls(data: rs.ByteSlice, out: rs.ByteVec): void { + let q!: rs.Poll; + let r!: rs.Poll>; + for (const b of rs.byteSliceView(data)) { + const p: rs.Poll = b; + if (!(rs.u8Rem(b, 3) === 0)) { q = b; } else { - q = rt.Pending; + q = rs.Pending; } debug$task_Poll_u8(out, p); debug$task_Poll_u8(out, q); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPoll(q, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtPoll(p, f, rt.u8Debug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args2[1]), "|", rt.fmtSpec({ zero: true, width: 8 }, args2[1])])); - debug$task_Poll_Option_u8(out, poll_map$0fx224j(b as rt.Poll, (o: rt.u8 | undefined): rt.u8 | undefined => { - return filter$0v80fk8(o, (v: rt.u8): boolean => { - return rt.u8Rem(v, 2) === 0; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPoll(q, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtPoll(p, f, rs.u8Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ align: "<", alternate: true, debugHex: "x", width: 5 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[1])])); + debug$task_Poll_Option_u8(out, poll_map$1jzbsum(b as rs.Poll, (o: rs.u8 | undefined): rs.u8 | undefined => { + return filter$0hq86nl(o, (v: rs.u8): boolean => { + return rs.u8Rem(v, 2) === 0; }); })); - const _38: rt.u8 = rt.u8Rem(b, 3); + const _38: rs.u8 = rs.u8Rem(b, 3); if (_38 === 0) { - r = rt.Pending; + r = rs.Pending; } else if (_38 === 1) { - r = rt.Ok(b); + r = rs.Ok(b); } else { - r = rt.Err(rt.fmtToString((f: rt.Formatter) => rt.u8Display(b, f))); + r = rs.Err(rs.fmtToString((f: rs.Formatter) => rs.u8Display(b, f))); } debug$task_Poll_Result_u8_String(out, r); debug$task_Poll_task_Poll_u8(out, nested(b)); @@ -499,55 +499,55 @@ export function polls(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A `Poll` of a `Poll`, whose own `Pending` is apart from the one it holds. */ -export function nested(b: rt.u8): rt.Poll | rt.OuterPending { - const _2: rt.u8 = rt.u8Rem(b, 3); +export function nested(b: rs.u8): rs.Poll | rs.OuterPending { + const _2: rs.u8 = rs.u8Rem(b, 3); if (_2 === 0) { - return rt.OuterPending; + return rs.OuterPending; } if (_2 === 1) { - return rt.Pending; + return rs.Pending; } - return b as rt.Poll; + return b as rs.Poll; } /** * What hashing a `Poll` writes: its variant, then what it holds, as std's derived `Hash` * writes them. */ -export function hashes(data: rt.ByteSlice, out: rt.ByteVec): void { - const polls: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Poll => { - const b2: rt.u8 = _2; - if (!(rt.u8Rem(b2, 4) === 0)) { +export function hashes(data: rs.ByteSlice, out: rs.ByteVec): void { + const polls: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Poll => { + const b2: rs.u8 = _2; + if (!(rs.u8Rem(b2, 4) === 0)) { return b2; } - return rt.Pending; + return rs.Pending; }), undefined, 2, true); for (const _9 of polls.items) { - const h: rt.Hasher = rt.hasher(); - rt.hashPoll(rt.hash8)(_9, h); - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.hashFinish(h))), undefined, true); + const h: rs.Hasher = rs.hasher(); + rs.hashPoll(rs.hash8)(_9, h); + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(rs.hashFinish(h))), undefined, true); } - const h2: rt.Hasher = rt.hasher(); - rt.hashSlice(rt.hashPoll(rt.hash8))(polls, h2); - rt.hashPoll(rt.hashOption(rt.hashUsize))(data.length as rt.Poll, h2); - rt.hashPoll(rt.hashOption(rt.hashStr))(rt.Pending, h2); - for (const _35 of rt.byteSliceView(data)) { - const _41: rt.Poll | rt.OuterPending = nested(_35); - rt.hashPoll(rt.hashPoll(rt.hash8), rt.OuterPending)(_41, h2); + const h2: rs.Hasher = rs.hasher(); + rs.hashSlice(rs.hashPoll(rs.hash8))(polls, h2); + rs.hashPoll(rs.hashOption(rs.hashUsize))(data.length as rs.Poll, h2); + rs.hashPoll(rs.hashOption(rs.hashStr))(rs.Pending, h2); + for (const _35 of rs.byteSliceView(data)) { + const _41: rs.Poll | rs.OuterPending = nested(_35); + rs.hashPoll(rs.hashPoll(rs.hash8), rs.OuterPending)(_41, h2); } - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.hashFinish(h2))), undefined, true); - const _48: rt.Iter> = rt.iterSlice(polls.items); - const set: rt.HashSet> = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashPoll(rt.hash8), poll_eq$1h9nnoh)) as rt.HashSet>, _48, undefined, undefined, 469762048); - const _53: rt.Iter | rt.OuterPending> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.Poll | rt.OuterPending => { + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(rs.hashFinish(h2))), undefined, true); + const _48: rs.Iter> = rs.iterSlice(polls.items); + const set: rs.HashSet> = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashPoll(rs.hash8), poll_eq$1qrb1lw)) as rs.HashSet>, _48, undefined, undefined, 469762048); + const _53: rs.Iter | rs.OuterPending> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.Poll | rs.OuterPending => { return nested(_22); }); - const nests: rt.HashSet | rt.OuterPending> = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashPoll(rt.hashPoll(rt.hash8), rt.OuterPending), poll_eq$11qt6c3)) as rt.HashSet | rt.OuterPending>, _53, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashLen(set) & 0xff); - rt.byteVecPush(out, rt.hashLen(nests) & 0xff); - rt.byteVecPush(out, rt.hashContains(set, rt.Pending) ? 1 : 0); - rt.byteVecPush(out, rt.hashContains(nests, rt.Pending) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u8 => { - return rt.hashContains(set, _23 as rt.Poll) ? 1 : 0; + const nests: rs.HashSet | rs.OuterPending> = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashPoll(rs.hashPoll(rs.hash8), rs.OuterPending), poll_eq$1o5v7fd)) as rs.HashSet | rs.OuterPending>, _53, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashLen(set) & 0xff); + rs.byteVecPush(out, rs.hashLen(nests) & 0xff); + rs.byteVecPush(out, rs.hashContains(set, rs.Pending) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(nests, rs.Pending) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): rs.u8 => { + return rs.hashContains(set, _23 as rs.Poll) ? 1 : 0; }), undefined, true); } @@ -556,56 +556,56 @@ export function hashes(data: rt.ByteSlice, out: rt.ByteVec): void { * wake the same task, when std keeps the one it had: one in a variable, a field, an * `Option`, which clones over what it holds by the waker's own, and an array. */ -export function wakers(data: rt.ByteSlice, out: rt.ByteVec): void { - let source!: rt.Waker; - let from!: rt.Waker | undefined; - const a: rt.Arc = new rt.Arc({ _0: new rt.Atomic(0) }); - const b: rt.Arc = new rt.Arc({ _0: new rt.Atomic(0) }); - let w: rt.Waker = rt.arcWaker(rt.arcClone(a), Count.wake$task_Wake as (a0: rt.Arc) => undefined, (arc: rt.Arc) => arc[Symbol.dispose]()); - const held: Held.Held = new Held.Held(rt.NOOP_WAKER.clone()); - let maybe = undefined as rt.Waker | undefined; - const pair: rt.Waker[] = [rt.NOOP_WAKER.clone(), rt.arcWaker(rt.arcClone(b), Count.wake$task_Wake as (a0: rt.Arc) => undefined, (arc2: rt.Arc) => arc2[Symbol.dispose]())]; - for (const byte of rt.byteSliceView(data)) { - const _29: rt.u8 = rt.u8Rem(byte, 3); +export function wakers(data: rs.ByteSlice, out: rs.ByteVec): void { + let source!: rs.Waker; + let from!: rs.Waker | undefined; + const a: rs.Arc = new rs.Arc({ _0: new rs.Atomic(0) }); + const b: rs.Arc = new rs.Arc({ _0: new rs.Atomic(0) }); + let w: rs.Waker = rs.arcWaker(rs.arcClone(a), Count.wake$task_Wake as (a0: rs.Arc) => undefined, (arc: rs.Arc) => arc[Symbol.dispose]()); + const held: Held.Held = new Held.Held(rs.NOOP_WAKER.clone()); + let maybe = undefined as rs.Waker | undefined; + const pair: rs.Waker[] = [rs.NOOP_WAKER.clone(), rs.arcWaker(rs.arcClone(b), Count.wake$task_Wake as (a0: rs.Arc) => undefined, (arc2: rs.Arc) => arc2[Symbol.dispose]())]; + for (const byte of rs.byteSliceView(data)) { + const _29: rs.u8 = rs.u8Rem(byte, 3); if (_29 === 0) { - source = rt.arcWaker(rt.arcClone(a), Count.wake$task_Wake as (a0: rt.Arc) => undefined, (arc4: rt.Arc) => arc4[Symbol.dispose]()); + source = rs.arcWaker(rs.arcClone(a), Count.wake$task_Wake as (a0: rs.Arc) => undefined, (arc4: rs.Arc) => arc4[Symbol.dispose]()); } else if (_29 === 1) { - source = rt.arcWaker(rt.arcClone(b), Count.wake$task_Wake as (a0: rt.Arc) => undefined, (arc3: rt.Arc) => arc3[Symbol.dispose]()); + source = rs.arcWaker(rs.arcClone(b), Count.wake$task_Wake as (a0: rs.Arc) => undefined, (arc3: rs.Arc) => arc3[Symbol.dispose]()); } else { - source = rt.NOOP_WAKER.clone(); + source = rs.NOOP_WAKER.clone(); } - w = rt.wakerCloneFrom(w, source); - held.waker = rt.wakerCloneFrom(held.waker, w); - if (rt.u8Rem(byte, 4) === 0) { + w = rs.wakerCloneFrom(w, source); + held.waker = rs.wakerCloneFrom(held.waker, w); + if (rs.u8Rem(byte, 4) === 0) { from = undefined; } else { from = source.clone(); } - maybe = rt.optionCloneFrom(maybe, from, (a0: rt.Waker): rt.Waker => { + maybe = rs.optionCloneFrom(maybe, from, (a0: rs.Waker): rs.Waker => { return a0.clone(); - }, rt.drop, rt.wakerCloneFromFn()); - const _53: rt.Waker[] = [w.clone(), source.clone()]; - rt.sliceCloneFromSlice(pair, _53, (a02: rt.Waker): rt.Waker => { + }, rs.drop, rs.wakerCloneFromFn()); + const _53: rs.Waker[] = [w.clone(), source.clone()]; + rs.sliceCloneFromSlice(pair, _53, (a02: rs.Waker): rs.Waker => { return a02.clone(); - }, rt.drop, rt.wakerCloneFromFn()); - rt.dropAll(_53); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); - rt.byteVecPush(out, rt.willWake(w, source) ? 1 : 0); + }, rs.drop, rs.wakerCloneFromFn()); + rs.dropAll(_53); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); + rs.byteVecPush(out, rs.willWake(w, source) ? 1 : 0); w.wakeByRef(); held.waker.wakeByRef(); if (maybe !== undefined) { maybe.wakeByRef(); } - rt.iterForEach(rt.iterSlice(pair), (a03: rt.Waker): undefined => { + rs.iterForEach(rs.iterSlice(pair), (a03: rs.Waker): undefined => { a03.wakeByRef(); }); - drop$tuple2_task_Waker_Option_task_Waker([source, from] as [rt.Waker, rt.Waker | undefined]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); + drop$tuple2_task_Waker_Option_task_Waker([source, from] as [rs.Waker, rs.Waker | undefined]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); } w[Symbol.dispose](); - drop$tuple3_futures_Held_Option_task_Waker_array2_task_Waker([held, maybe, pair] as [Held.Held, rt.Waker | undefined, rt.Waker[]]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(a.value._0, 0), rt.atomicLoad(b.value._0, 0))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); + drop$tuple3_futures_Held_Option_task_Waker_array2_task_Waker([held, maybe, pair] as [Held.Held, rs.Waker | undefined, rs.Waker[]]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.atomicLoad(a.value._0, 0), rs.atomicLoad(b.value._0, 0))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.strong & 0xff, b.strong & 0xff)), undefined, true); b[Symbol.dispose](); a[Symbol.dispose](); } diff --git a/ts/fixtures/lang/futures/expected/harness.ts b/ts/fixtures/lang/futures/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/futures/expected/harness.ts +++ b/ts/fixtures/lang/futures/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/futures/expected/lib.ts b/ts/fixtures/lang/futures/expected/lib.ts index 8b15fe3ce..544ad23f5 100644 --- a/ts/fixtures/lang/futures/expected/lib.ts +++ b/ts/fixtures/lang/futures/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { awaits } from "./awaits.ts"; import { futures } from "./futures.ts"; import type * as Held from "./futures.Held.ts"; @@ -8,43 +8,43 @@ import type * as Logged from "./futures.Logged.ts"; import { raw } from "./raw.ts"; import type * as Task from "./raw.Task.ts"; -export function copy$task_RawWakerVTable(v: rt.WakerVTable): rt.WakerVTable { - return rt.wakerVTable(v.clone, v.wake, v.wakeByRef, v.drop); +export function copy$task_RawWakerVTable(v: rs.WakerVTable): rs.WakerVTable { + return rs.wakerVTable(v.clone, v.wake, v.wakeByRef, v.drop); } -export function drop$task_Poll_futures_Logged(_1: rt.Poll): void { - if (_1 !== rt.Pending) { +export function drop$task_Poll_futures_Logged(_1: rs.Poll): void { + if (_1 !== rs.Pending) { _1[Symbol.dispose](); } } -export function drop$tuple2_task_Waker_Option_task_Waker(_1: [rt.Waker, rt.Waker | undefined]): void { +export function drop$tuple2_task_Waker_Option_task_Waker(_1: [rs.Waker, rs.Waker | undefined]): void { _1[0][Symbol.dispose](); - rt.drop(_1[1]); + rs.drop(_1[1]); } -export function drop$tuple2_task_Waker_sync_Arc_raw_Task(_1: [rt.Waker, rt.Arc]): void { +export function drop$tuple2_task_Waker_sync_Arc_raw_Task(_1: [rs.Waker, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } -export function drop$tuple2_task_Waker_task_Waker(_1: [rt.Waker, rt.Waker]): void { +export function drop$tuple2_task_Waker_task_Waker(_1: [rs.Waker, rs.Waker]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } -export function drop$tuple3_futures_Held_Option_task_Waker_array2_task_Waker(_1: [Held.Held, rt.Waker | undefined, rt.Waker[]]): void { +export function drop$tuple3_futures_Held_Option_task_Waker_array2_task_Waker(_1: [Held.Held, rs.Waker | undefined, rs.Waker[]]): void { _1[0][Symbol.dispose](); - rt.drop(_1[1]); - rt.dropAll(_1[2]); + rs.drop(_1[1]); + rs.dropAll(_1[2]); } /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["futures::futures", futures as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["raw::raw", raw as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["awaits::awaits", awaits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["futures::futures", futures as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["raw::raw", raw as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["awaits::awaits", awaits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/futures/expected/raw.Byte.ts b/ts/fixtures/lang/futures/expected/raw.Byte.ts index ccfe333ea..90cb59c76 100644 --- a/ts/fixtures/lang/futures/expected/raw.Byte.ts +++ b/ts/fixtures/lang/futures/expected/raw.Byte.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** One aligned to a byte, whose dangling pointer is `()`'s. */ export interface Byte { - _0: rt.u8; + _0: rs.u8; } //# sourceMappingURL=raw.Byte.ts.map diff --git a/ts/fixtures/lang/futures/expected/raw.Counter.ts b/ts/fixtures/lang/futures/expected/raw.Counter.ts index 2dfd8206c..f61d95e88 100644 --- a/ts/fixtures/lang/futures/expected/raw.Counter.ts +++ b/ts/fixtures/lang/futures/expected/raw.Counter.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Counts the wakes through it. */ export interface Counter { - _0: rt.Atomic; + _0: rs.Atomic; } -export function wake$task_Wake(self: rt.Arc): void { - rt.atomicFetch(self.value._0, rt.u8WrappingAdd, 1, 0); +export function wake$task_Wake(self: rs.Arc): void { + rs.atomicFetch(self.value._0, rs.u8WrappingAdd, 1, 0); self[Symbol.dispose](); } diff --git a/ts/fixtures/lang/futures/expected/raw.Note.ts b/ts/fixtures/lang/futures/expected/raw.Note.ts index 1578d873d..ed41fa75b 100644 --- a/ts/fixtures/lang/futures/expected/raw.Note.ts +++ b/ts/fixtures/lang/futures/expected/raw.Note.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What a waker of vtable `BOXED` or `BORROWED` points at, which its functions read. */ export interface Note { - id: rt.u8; + id: rs.u8; /** Wide enough that a `Note` aligns past `()`. */ - calls: rt.Cell; + calls: rs.Cell; } //# sourceMappingURL=raw.Note.ts.map diff --git a/ts/fixtures/lang/futures/expected/raw.Task.ts b/ts/fixtures/lang/futures/expected/raw.Task.ts index 2a5a263bb..4e91e6b2b 100644 --- a/ts/fixtures/lang/futures/expected/raw.Task.ts +++ b/ts/fixtures/lang/futures/expected/raw.Task.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { LOG } from "./raw.ts"; /** A task a waker's data is the `Arc` of, by `Arc::into_raw`, which logs its drop. */ export class Task { - id: rt.u8; - wakes: rt.Cell; + id: rs.u8; + wakes: rs.Cell; - constructor(id: rt.u8, wakes: rt.Cell) { + constructor(id: rs.u8, wakes: rs.Cell) { this.id = id; this.wakes = wakes; } @@ -19,8 +19,8 @@ export class Task { } export function drop$ops_Drop(self: Task): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(68, self.id, self.wakes.v)), undefined, true); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(68, self.id, self.wakes.v)), undefined, true); }); } diff --git a/ts/fixtures/lang/futures/expected/raw.Yields.ts b/ts/fixtures/lang/futures/expected/raw.Yields.ts index 357ce5981..7125292f1 100644 --- a/ts/fixtures/lang/futures/expected/raw.Yields.ts +++ b/ts/fixtures/lang/futures/expected/raw.Yields.ts @@ -1,50 +1,50 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A future that is pending `self.0` times, waking its task by a clone of the waker it * holds until the next poll, or by reference, before each. */ export class Yields { - _0: rt.u8; - _1: rt.Waker | undefined; + _0: rs.u8; + _1: rs.Waker | undefined; - constructor(_0: rt.u8, _1: rt.Waker | undefined) { + constructor(_0: rs.u8, _1: rs.Waker | undefined) { this._0 = _0; this._1 = _1; } [Symbol.dispose](): void { - rt.drop(this._1); + rs.drop(this._1); } } -export function poll$Future(self: Yields, cx: rt.Context): rt.Poll { +export function poll$Future(self: Yields, cx: rs.Context): rs.Poll { const _5: Yields = self; const taken = _5._1; _5._1 = undefined; - const _3: rt.Waker | undefined = taken; + const _3: rs.Waker | undefined = taken; if (_3 !== undefined) { _3.wake(); } if (!(self._0 === 0)) { const _14: Yields = self; - _14._0 = rt.u8Sub(_14._0, 1); - const _18: rt.u8 = rt.u8Rem(self._0, 3); + _14._0 = rs.u8Sub(_14._0, 1); + const _18: rs.u8 = rs.u8Rem(self._0, 3); if (_18 === 0) { cx.wakeByRef(); } else if (_18 === 1) { - const _25: rt.Waker | undefined = cx.clone(); + const _25: rs.Waker | undefined = cx.clone(); const _29: Yields = self; - rt.drop(_29._1); + rs.drop(_29._1); _29._1 = _25; } else { - const w: rt.Waker = cx.clone(); + const w: rs.Waker = cx.clone(); w.wakeByRef(); w[Symbol.dispose](); } - return rt.Pending; + return rs.Pending; } return 170; } diff --git a/ts/fixtures/lang/futures/expected/raw.ts b/ts/fixtures/lang/futures/expected/raw.ts index a8ed807bb..3eba23058 100644 --- a/ts/fixtures/lang/futures/expected/raw.ts +++ b/ts/fixtures/lang/futures/expected/raw.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$task_RawWakerVTable, drop$tuple2_task_Waker_sync_Arc_raw_Task, drop$tuple2_task_Waker_task_Waker } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$13g654t as option_mapOr$13g654t } from "./core/option.ts"; -import { eq$0n9bv8t as wake_eq$0n9bv8t, eq$0xaykl8 as wake_eq$0xaykl8 } from "./core/task/wake.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$1ntkzhx as option_mapOr$1ntkzhx } from "./core/option.ts"; +import { eq$1ohvggu as wake_eq$1ohvggu, eq$1obrnmy as wake_eq$1obrnmy } from "./core/task/wake.ts"; import type * as Byte from "./raw.Byte.ts"; import * as Counter from "./raw.Counter.ts"; import type * as Note from "./raw.Note.ts"; import * as Task from "./raw.Task.ts"; import * as Yields from "./raw.Yields.ts"; -import { set$08o17gp, get$0lasdfu, take$122f15k } from "./std/thread/local.ts"; +import { set$15db765, get$1htgqdl, take$1snv7rd } from "./std/thread/local.ts"; /** The wakers `kind` picks. */ -export function raw(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 7); +export function raw(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 7); if (_5 === 0) { calls(data, out); } else if (_5 === 1) { @@ -29,102 +29,102 @@ export function raw(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { tasks(data, out); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(take$122f15k(LOG)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(take$1snv7rd(LOG)), undefined, true); } -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LOG$init, false); +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); -export function LOG$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function LOG$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } -export const WOKEN: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(WOKEN$init, false); +export const WOKEN: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(WOKEN$init, false); -export function WOKEN$init(): rt.Cell { - return new rt.Cell(false); +export function WOKEN$init(): rs.Cell { + return new rs.Cell(false); } /** Log a call of function `call` of vtable `TABLE` on `data`. */ -export function note$101(call: rt.u8, data: rt.Place): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, 101, data === rt.NULL ? 1 : 0)), undefined, true); +export function note$101(call: rs.u8, data: rs.Place): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, 101, data === rs.NULL ? 1 : 0)), undefined, true); }); } /** Log a call of function `call` of vtable `TABLE` on `data`. */ -export function note$97(call: rt.u8, data: rt.Place): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, 97, data === rt.NULL ? 1 : 0)), undefined, true); +export function note$97(call: rs.u8, data: rs.Place): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, 97, data === rs.NULL ? 1 : 0)), undefined, true); }); } /** Log a call of function `call` of vtable `TABLE` on `data`. */ -export function note$98(call: rt.u8, data: rt.Place): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, 98, data === rt.NULL ? 1 : 0)), undefined, true); +export function note$98(call: rs.u8, data: rs.Place): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, 98, data === rs.NULL ? 1 : 0)), undefined, true); }); } -export function onClone$97(data: rt.Place): rt.RawWaker { +export function onClone$97(data: rs.Place): rs.RawWaker { note$97(99, data); return { data, vtable: A }; } /** `B`'s clone, which clones into a waker of vtable `A`. */ -export function cloneIntoA(data: rt.Place): rt.RawWaker { +export function cloneIntoA(data: rs.Place): rs.RawWaker { note$98(99, data); return { data, vtable: A }; } -export function onWake$97(data: rt.Place): void { +export function onWake$97(data: rs.Place): void { note$97(119, data); } -export function onWake$98(data: rt.Place): void { +export function onWake$98(data: rs.Place): void { note$98(119, data); } -export function onWakeByRef$97(data: rt.Place): void { +export function onWakeByRef$97(data: rs.Place): void { note$97(114, data); } -export function onWakeByRef$98(data: rt.Place): void { +export function onWakeByRef$98(data: rs.Place): void { note$98(114, data); } -export function onDrop$101(data: rt.Place): void { +export function onDrop$101(data: rs.Place): void { note$101(100, data); } -export function onDrop$97(data: rt.Place): void { +export function onDrop$97(data: rs.Place): void { note$97(100, data); } -export function onDrop$98(data: rt.Place): void { +export function onDrop$98(data: rs.Place): void { note$98(100, data); } -export const A: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(onClone$97, onWake$97 as (a0: rt.Place) => undefined, onWakeByRef$97 as (a0: rt.Place) => undefined, onDrop$97 as (a0: rt.Place) => undefined); +export const A: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(onClone$97, onWake$97 as (a0: rs.Place) => undefined, onWakeByRef$97 as (a0: rs.Place) => undefined, onDrop$97 as (a0: rs.Place) => undefined); -export const B: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(cloneIntoA, onWake$98 as (a0: rt.Place) => undefined, onWakeByRef$98 as (a0: rt.Place) => undefined, onDrop$98 as (a0: rt.Place) => undefined); +export const B: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(cloneIntoA, onWake$98 as (a0: rs.Place) => undefined, onWakeByRef$98 as (a0: rs.Place) => undefined, onDrop$98 as (a0: rs.Place) => undefined); -export const A_AGAIN: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(onClone$97, onWake$97 as (a0: rt.Place) => undefined, onWakeByRef$97 as (a0: rt.Place) => undefined, onDrop$97 as (a0: rt.Place) => undefined); +export const A_AGAIN: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(onClone$97, onWake$97 as (a0: rs.Place) => undefined, onWakeByRef$97 as (a0: rs.Place) => undefined, onDrop$97 as (a0: rs.Place) => undefined); /** Data that is null, or dangling, which no other data is. */ -export function dataOf(byte: rt.u8): rt.Place { - if (rt.u8Rem(byte, 2) === 0) { - return rt.NULL; +export function dataOf(byte: rs.u8): rs.Place { + if (rs.u8Rem(byte, 2) === 0) { + return rs.NULL; } - return rt.DANGLING_UNIT; + return rs.DANGLING_UNIT; } /** * A waker of vtable `A`, `B`, or `A_AGAIN`, as `byte` picks, made through `from_raw` or * `new`. */ -export function waker(byte: rt.u8): rt.Waker { - let vtable!: rt.WakerVTable; - const _3: rt.u8 = rt.u8Rem(byte, 3); +export function waker(byte: rs.u8): rs.Waker { + let vtable!: rs.WakerVTable; + const _3: rs.u8 = rs.u8Rem(byte, 3); if (_3 === 0) { vtable = A; } else if (_3 === 1) { @@ -132,32 +132,32 @@ export function waker(byte: rt.u8): rt.Waker { } else { vtable = A_AGAIN; } - const data: rt.Place = dataOf(rt.u8Div(byte, 3)); - if (rt.u8Rem(rt.u8Div(byte, 6), 2) === 0) { - return rt.wakerFromRaw({ data, vtable }); + const data: rs.Place = dataOf(rs.u8Div(byte, 3)); + if (rs.u8Rem(rs.u8Div(byte, 6), 2) === 0) { + return rs.wakerFromRaw({ data, vtable }); } - return new rt.VTableWaker(data, vtable); + return new rs.VTableWaker(data, vtable); } /** * Each byte a waker, cloned, woken by reference and by value, dropped, forgotten, or never * used, and those it made dropped in reverse. */ -export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { +export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { let _39: boolean = false; - const kept: rt.Vec = new rt.Vec(); - for (const byte of rt.byteSliceView(data)) { - const w: rt.Waker = waker(byte); + const kept: rs.Vec = new rs.Vec(); + for (const byte of rs.byteSliceView(data)) { + const w: rs.Waker = waker(byte); _39 = true; - rt.byteVecPush(out, (w.data as rt.Place) === rt.NULL ? 1 : 0); - const _17: rt.u8 = rt.u8Rem(rt.u8Div(byte, 12), 6); + rs.byteVecPush(out, (w.data as rs.Place) === rs.NULL ? 1 : 0); + const _17: rs.u8 = rs.u8Rem(rs.u8Div(byte, 12), 6); if (_17 === 0) { w.wakeByRef(); } else if (_17 === 1) { _39 = false; w.wake(); } else if (_17 === 2) { - const _24: rt.Waker = w.clone(); + const _24: rs.Waker = w.clone(); kept.items.push(_24); } else if (_17 === 3) { _39 = false; @@ -171,88 +171,88 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { _39 = false; } while (true) { - const _32: rt.Waker | undefined = rt.vecPop(kept); + const _32: rs.Waker | undefined = rs.vecPop(kept); if (_32 !== undefined) { - const w2: rt.Waker = _32; + const w2: rs.Waker = _32; w2.wakeByRef(); w2[Symbol.dispose](); } else { break; } } - rt.dropVec(kept); + rs.dropVec(kept); } /** * Wakers cloned over others by `clone_from`, which keeps one that would wake the same * task and else drops it after cloning the source; and `will_wake` of each pair. */ -export function clones(data: rt.ByteSlice, out: rt.ByteVec): void { - let held: rt.Waker = waker(0); - let maybe = undefined as rt.Waker | undefined; - const iter: rt.Iter = rt.byteSliceChunks(data, 2); +export function clones(data: rs.ByteSlice, out: rs.ByteVec): void { + let held: rs.Waker = waker(0); + let maybe = undefined as rs.Waker | undefined; + const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { - const _8: rt.ByteSlice | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: rs.ByteSlice | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } - rt.idx(_8, 0); - const source: rt.Waker = waker(_8.data[_8.start]); - const other: rt.Waker = waker(option_unwrapOr$0r2bmpr(rt.byteSliceGet(_8, 1), 0)); - rt.byteVecPush(out, rt.willWake(source, other) ? 1 : 0); - rt.byteVecPush(out, rt.willWake(held, source) ? 1 : 0); - held = rt.wakerCloneFrom(held, source); - const _37: rt.Waker | undefined = other.clone(); - maybe = rt.optionCloneFrom(maybe, _37, (a0: rt.Waker): rt.Waker => { + rs.idx(_8, 0); + const source: rs.Waker = waker(_8.data[_8.start]); + const other: rs.Waker = waker(option_unwrapOr$1fr498u(rs.byteSliceGet(_8, 1), 0)); + rs.byteVecPush(out, rs.willWake(source, other) ? 1 : 0); + rs.byteVecPush(out, rs.willWake(held, source) ? 1 : 0); + held = rs.wakerCloneFrom(held, source); + const _37: rs.Waker | undefined = other.clone(); + maybe = rs.optionCloneFrom(maybe, _37, (a0: rs.Waker): rs.Waker => { return a0.clone(); - }, rt.drop, rt.wakerCloneFromFn()); - rt.drop(_37); - rt.byteVecPush(out, rt.willWake(held, source) ? 1 : 0); - const _50: rt.Waker = source.clone(); - rt.byteVecPush(out, rt.willWake(source, _50) ? 1 : 0); + }, rs.drop, rs.wakerCloneFromFn()); + rs.drop(_37); + rs.byteVecPush(out, rs.willWake(held, source) ? 1 : 0); + const _50: rs.Waker = source.clone(); + rs.byteVecPush(out, rs.willWake(source, _50) ? 1 : 0); _50[Symbol.dispose](); - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, 124); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, 124); }); other[Symbol.dispose](); source[Symbol.dispose](); } - rt.drop(maybe); + rs.drop(maybe); held[Symbol.dispose](); } -export function execClone(data: rt.Place): rt.RawWaker { +export function execClone(data: rs.Place): rs.RawWaker { note$101(99, data); return { data, vtable: EXEC }; } -export function execWake(data: rt.Place): void { +export function execWake(data: rs.Place): void { note$101(119, data); - set$08o17gp(WOKEN, true); + set$15db765(WOKEN, true); } -export function execWakeByRef(data: rt.Place): void { +export function execWakeByRef(data: rs.Place): void { note$101(114, data); - set$08o17gp(WOKEN, true); + set$15db765(WOKEN, true); } -export const EXEC: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(execClone, execWake as (a0: rt.Place) => undefined, execWakeByRef as (a0: rt.Place) => undefined, onDrop$101 as (a0: rt.Place) => undefined); +export const EXEC: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(execClone, execWake as (a0: rs.Place) => undefined, execWakeByRef as (a0: rs.Place) => undefined, onDrop$101 as (a0: rs.Place) => undefined); /** Poll `f` until it is ready, again only once its task wakes. */ -export function blockOn$future_Pending_u8(f: rt.Future): rt.u8 | undefined { - let _0!: rt.u8 | undefined; - let _13!: rt.Poll; - const waker: rt.Waker = rt.wakerFromRaw({ data: rt.NULL, vtable: EXEC }); - const cx: rt.Context = waker; - const f2: rt.Future = f; +export function blockOn$future_Pending_u8(f: rs.Future): rs.u8 | undefined { + let _0!: rs.u8 | undefined; + let _13!: rs.Poll; + const waker: rs.Waker = rs.wakerFromRaw({ data: rs.NULL, vtable: EXEC }); + const cx: rs.Context = waker; + const f2: rs.Future = f; b0: { while (true) { - set$08o17gp(WOKEN, false); + set$15db765(WOKEN, false); _13 = f2.poll(cx); - if (_13 !== rt.Pending) { + if (_13 !== rs.Pending) { break; } - if (!get$0lasdfu(WOKEN)) { + if (!get$1htgqdl(WOKEN)) { _0 = undefined; break b0; } @@ -264,50 +264,50 @@ export function blockOn$future_Pending_u8(f: rt.Future): rt.u8 | undefine } /** Poll `f` until it is ready, again only once its task wakes. */ -export function blockOn$raw_executor_closure1(f: rt.Future): rt.u8 | undefined { - let _0!: rt.u8 | undefined; - let _13!: rt.Poll; - const waker: rt.Waker = rt.wakerFromRaw({ data: rt.NULL, vtable: EXEC }); - const cx: rt.Context = waker; - const pinned: rt.Future = f; - const f2: rt.Future = pinned; +export function blockOn$raw_executor_closure1(f: rs.Future): rs.u8 | undefined { + let _0!: rs.u8 | undefined; + let _13!: rs.Poll; + const waker: rs.Waker = rs.wakerFromRaw({ data: rs.NULL, vtable: EXEC }); + const cx: rs.Context = waker; + const pinned: rs.Future = f; + const f2: rs.Future = pinned; b0: { while (true) { - set$08o17gp(WOKEN, false); + set$15db765(WOKEN, false); _13 = f2.poll(cx); - if (_13 !== rt.Pending) { + if (_13 !== rs.Pending) { break; } - if (!get$0lasdfu(WOKEN)) { + if (!get$1htgqdl(WOKEN)) { _0 = undefined; break b0; } } _0 = _13; } - rt.drop(pinned); + rs.drop(pinned); waker[Symbol.dispose](); return _0; } /** An `async` block awaiting a `Yields` of each byte, polled to its end by `block_on`. */ -export function executor(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterOption(blockOn$raw_executor_closure1(new executorFuture$closure1(rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): rt.u8 => { - return rt.u8Rem(b, 5); +export function executor(data: rs.ByteSlice, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterOption(blockOn$raw_executor_closure1(new executorFuture$closure1(rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.u8 => { + return rs.u8Rem(b, 5); }), undefined, true)))), undefined, true); - rt.NEVER; - rt.byteVecPush(out, blockOn$future_Pending_u8(rt.NEVER) === undefined ? 1 : 0); + rs.NEVER; + rs.byteVecPush(out, blockOn$future_Pending_u8(rs.NEVER) === undefined ? 1 : 0); } export class executorFuture$closure1 { #state: number = 0; - #counts: rt.ByteVec; - #iter!: rt.Iter; - #n!: rt.u8; - #saved!: rt.u8; + #counts: rs.ByteVec; + #iter!: rs.Iter; + #n!: rs.u8; + #saved!: rs.u8; #awaitee!: Yields.Yields; - constructor(counts: rt.ByteVec) { + constructor(counts: rs.ByteVec) { this.#counts = counts; } @@ -317,27 +317,27 @@ export class executorFuture$closure1 { } } - poll(_2: rt.Context): rt.Poll { - let sum!: rt.u8; + poll(_2: rs.Context): rs.Poll { + let sum!: rs.u8; let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { sum = 0; - this.#iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(this.#counts))); + this.#iter = rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(this.#counts))); bb0 = 4; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 10; continue; } case 4: - const _7: rt.u8 | rt.Done = this.#iter.next(); - if (_7 === rt.DONE) { + const _7: rs.u8 | rs.Done = this.#iter.next(); + if (_7 === rs.DONE) { this.#state = 1; return sum; } @@ -347,76 +347,76 @@ export class executorFuture$closure1 { bb0 = 10; continue; case 10: - const _16: rt.Poll = Yields.poll$Future(this.#awaitee, _2); - if (_16 !== rt.Pending) { - const result: rt.u8 = _16; + const _16: rs.Poll = Yields.poll$Future(this.#awaitee, _2); + if (_16 !== rs.Pending) { + const result: rs.u8 = _16; this.#awaitee[Symbol.dispose](); - sum = rt.u8WrappingAdd(rt.u8WrappingAdd(this.#saved, result), this.#n); + sum = rs.u8WrappingAdd(rs.u8WrappingAdd(this.#saved, result), this.#n); bb0 = 4; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } } /** `==` of vtables compares their functions, not where they are, as `will_wake` does. */ -export function vtables(data: rt.ByteSlice, out: rt.ByteVec): void { - const tables: rt.WakerVTable[] = [A, B, A_AGAIN, EXEC]; - for (const byte of rt.byteSliceView(data)) { - const _18: rt.usize = rt.u8Rem(byte, 4) as rt.usize; +export function vtables(data: rs.ByteSlice, out: rs.ByteVec): void { + const tables: rs.WakerVTable[] = [A, B, A_AGAIN, EXEC]; + for (const byte of rs.byteSliceView(data)) { + const _18: rs.usize = rs.u8Rem(byte, 4) as rs.usize; if (!(_18 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _18); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _18); } - const _23: rt.usize = rt.u8Rem(rt.u8Div(byte, 4), 4) as rt.usize; + const _23: rs.usize = rs.u8Rem(rs.u8Div(byte, 4), 4) as rs.usize; if (!(_23 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _23); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _23); } const part = tables[_18]; const part2 = tables[_23]; - const l: rt.WakerVTable = part; - const r: rt.WakerVTable = part2; - rt.byteVecPush(out, wake_eq$0xaykl8(l, r) ? 1 : 0); - rt.byteVecPush(out, !wake_eq$0xaykl8(l, r) ? 1 : 0); - const _39: [rt.Waker, rt.Waker] = [waker(rt.u8Rem(byte, 3)), waker(rt.u8Rem(rt.u8Div(byte, 4), 3))]; - const wl: rt.Waker = _39[0]; - const wr: rt.Waker = _39[1]; - rt.byteVecPush(out, wake_eq$0xaykl8(wl.vtable, wr.vtable) ? 1 : 0); - rt.byteVecPush(out, rt.willWake(wl, wr) ? 1 : 0); - rt.byteVecPush(out, wake_eq$0n9bv8t({ data: dataOf(byte), vtable: l }, { data: dataOf(byte >> 1), vtable: r }) ? 1 : 0); + const l: rs.WakerVTable = part; + const r: rs.WakerVTable = part2; + rs.byteVecPush(out, wake_eq$1obrnmy(l, r) ? 1 : 0); + rs.byteVecPush(out, !wake_eq$1obrnmy(l, r) ? 1 : 0); + const _39: [rs.Waker, rs.Waker] = [waker(rs.u8Rem(byte, 3)), waker(rs.u8Rem(rs.u8Div(byte, 4), 3))]; + const wl: rs.Waker = _39[0]; + const wr: rs.Waker = _39[1]; + rs.byteVecPush(out, wake_eq$1obrnmy(wl.vtable, wr.vtable) ? 1 : 0); + rs.byteVecPush(out, rs.willWake(wl, wr) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1ohvggu({ data: dataOf(byte), vtable: l }, { data: dataOf(byte >> 1), vtable: r }) ? 1 : 0); } - const copy: rt.WakerVTable = copy$task_RawWakerVTable(A); - const raw: rt.RawWaker = { data: rt.NULL, vtable: A }; - for (const byte2 of rt.byteSliceView(data)) { - const _87: rt.usize = rt.u8Rem(byte2, 4) as rt.usize; + const copy: rs.WakerVTable = copy$task_RawWakerVTable(A); + const raw: rs.RawWaker = { data: rs.NULL, vtable: A }; + for (const byte2 of rs.byteSliceView(data)) { + const _87: rs.usize = rs.u8Rem(byte2, 4) as rs.usize; if (!(_87 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _87); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _87); } replace(copy, tables[_87]); replaceRaw(raw, byte2); - rt.byteVecPush(out, wake_eq$0xaykl8(copy, B) ? 1 : 0); - const _103: rt.RawWaker = { data: dataOf(byte2), vtable: B }; - rt.byteVecPush(out, wake_eq$0n9bv8t(raw, _103) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1obrnmy(copy, B) ? 1 : 0); + const _103: rs.RawWaker = { data: dataOf(byte2), vtable: B }; + rs.byteVecPush(out, wake_eq$1ohvggu(raw, _103) ? 1 : 0); } - rt.byteVecPush(out, wake_eq$0xaykl8(A, A_AGAIN) ? 1 : 0); - const noop: rt.Waker = rt.NOOP_WAKER; - rt.byteVecPush(out, wake_eq$0xaykl8(noop.vtable, rt.NOOP_WAKER.vtable) ? 1 : 0); - rt.byteVecPush(out, wake_eq$0xaykl8(noop.vtable, A) ? 1 : 0); - rt.byteVecPush(out, (noop.data as rt.Place) === rt.NULL ? 1 : 0); - const borrowed: rt.Waker = new rt.VTableWaker(noop.data as rt.Place, noop.vtable); + rs.byteVecPush(out, wake_eq$1obrnmy(A, A_AGAIN) ? 1 : 0); + const noop: rs.Waker = rs.NOOP_WAKER; + rs.byteVecPush(out, wake_eq$1obrnmy(noop.vtable, rs.NOOP_WAKER.vtable) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1obrnmy(noop.vtable, A) ? 1 : 0); + rs.byteVecPush(out, (noop.data as rs.Place) === rs.NULL ? 1 : 0); + const borrowed: rs.Waker = new rs.VTableWaker(noop.data as rs.Place, noop.vtable); borrowed.wakeByRef(); - rt.byteVecPush(out, rt.willWake(borrowed, noop) ? 1 : 0); + rs.byteVecPush(out, rs.willWake(borrowed, noop) ? 1 : 0); } /** Write `by`'s functions over `table`'s. */ -export function replace(table: rt.WakerVTable, by: rt.WakerVTable): void { +export function replace(table: rs.WakerVTable, by: rs.WakerVTable): void { Object.assign(table, copy$task_RawWakerVTable(by)); } /** Write a raw waker of vtable `B` over `raw`. */ -export function replaceRaw(raw: rt.RawWaker, byte: rt.u8): void { +export function replaceRaw(raw: rs.RawWaker, byte: rs.u8): void { Object.assign(raw, { data: dataOf(byte), vtable: B }); } @@ -424,22 +424,22 @@ export function replaceRaw(raw: rt.RawWaker, byte: rt.u8): void { * `RawWaker::from` an `Arc` of a `Wake` impl, whose vtable is the one `Waker::from` gives, * and which counts the `Arc` as a waker does. */ -export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const count: rt.Arc = new rt.Arc({ _0: new rt.Atomic(0) }); - const from: rt.Waker = rt.arcWaker(rt.arcClone(count), Counter.wake$task_Wake as (a0: rt.Arc) => undefined, (arc: rt.Arc) => arc[Symbol.dispose]()); - const raw: rt.RawWaker = rt.arcRawWaker(rt.arcClone(count), Counter.wake$task_Wake as (a0: rt.Arc) => undefined, (arc2: rt.Arc) => arc2[Symbol.dispose]()); - const other: rt.RawWaker = rt.arcRawWaker(new rt.Arc({ _0: new rt.Atomic(0) }), Counter.wake$task_Wake as (a0: rt.Arc) => undefined, (arc3: rt.Arc) => arc3[Symbol.dispose]()); - const _21: rt.RawWaker = { data: from.data as rt.Place, vtable: from.vtable }; - rt.byteVecPush(out, wake_eq$0n9bv8t(raw, _21) ? 1 : 0); - rt.byteVecPush(out, wake_eq$0n9bv8t(raw, other) ? 1 : 0); - const w: rt.Waker = rt.wakerFromRaw(raw); - rt.byteVecPush(out, rt.willWake(w, from) ? 1 : 0); - rt.byteVecPush(out, wake_eq$0xaykl8(w.vtable, from.vtable) ? 1 : 0); - rt.byteVecPush(out, wake_eq$0xaykl8(w.vtable, A) ? 1 : 0); - rt.wakerFromRaw(other)[Symbol.dispose](); - rt.byteVecPush(out, count.strong & 0xff); - for (const _58 of rt.byteSliceView(data)) { - const _63: rt.u8 = rt.u8Rem(_58, 4); +export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const count: rs.Arc = new rs.Arc({ _0: new rs.Atomic(0) }); + const from: rs.Waker = rs.arcWaker(rs.arcClone(count), Counter.wake$task_Wake as (a0: rs.Arc) => undefined, (arc: rs.Arc) => arc[Symbol.dispose]()); + const raw: rs.RawWaker = rs.arcRawWaker(rs.arcClone(count), Counter.wake$task_Wake as (a0: rs.Arc) => undefined, (arc2: rs.Arc) => arc2[Symbol.dispose]()); + const other: rs.RawWaker = rs.arcRawWaker(new rs.Arc({ _0: new rs.Atomic(0) }), Counter.wake$task_Wake as (a0: rs.Arc) => undefined, (arc3: rs.Arc) => arc3[Symbol.dispose]()); + const _21: rs.RawWaker = { data: from.data as rs.Place, vtable: from.vtable }; + rs.byteVecPush(out, wake_eq$1ohvggu(raw, _21) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1ohvggu(raw, other) ? 1 : 0); + const w: rs.Waker = rs.wakerFromRaw(raw); + rs.byteVecPush(out, rs.willWake(w, from) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1obrnmy(w.vtable, from.vtable) ? 1 : 0); + rs.byteVecPush(out, wake_eq$1obrnmy(w.vtable, A) ? 1 : 0); + rs.wakerFromRaw(other)[Symbol.dispose](); + rs.byteVecPush(out, count.strong & 0xff); + for (const _58 of rs.byteSliceView(data)) { + const _63: rs.u8 = rs.u8Rem(_58, 4); if (_63 === 0) { w.wakeByRef(); } else if (_63 === 1) { @@ -447,12 +447,12 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_63 === 2) { w.clone()[Symbol.dispose](); } else { - new rt.VTableWaker(w.data as rt.Place, w.vtable).wakeByRef(); + new rs.VTableWaker(w.data as rs.Place, w.vtable).wakeByRef(); } - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); } - drop$tuple2_task_Waker_task_Waker([w, from] as [rt.Waker, rt.Waker]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(count.value._0, 0), count.strong & 0xff)), undefined, true); + drop$tuple2_task_Waker_task_Waker([w, from] as [rs.Waker, rs.Waker]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.atomicLoad(count.value._0, 0), count.strong & 0xff)), undefined, true); count[Symbol.dispose](); } @@ -460,209 +460,209 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { * The `Note` a waker's data points at, cast back from `*const ()` by `as`, `cast`, or * through a `*mut`. */ -export function noteOf(data: rt.Place): Note.Note { +export function noteOf(data: rs.Place): Note.Note { let note2!: Note.Note; - const _3: rt.u8 = rt.u8Rem((rt.ptrUnerase(data, "raw::Note", 2) as Note.Note).id, 3); + const _3: rs.u8 = rs.u8Rem((rs.ptrUnerase(data, "raw::Note", 2) as Note.Note).id, 3); if (_3 === 0) { - note2 = rt.ptrUnerase(data, "raw::Note", 2) as Note.Note; + note2 = rs.ptrUnerase(data, "raw::Note", 2) as Note.Note; } else if (_3 === 1) { - note2 = rt.ptrUnerase(data, "raw::Note", 2) as Note.Note; + note2 = rs.ptrUnerase(data, "raw::Note", 2) as Note.Note; } else { - note2 = rt.ptrUnerase(data, "raw::Note", 2) as Note.Note; + note2 = rs.ptrUnerase(data, "raw::Note", 2) as Note.Note; } const note: Note.Note = note2; - const _11: rt.u16 = rt.u16WrappingAdd(note.calls.v, 1); - rt.cellSet(note.calls, _11); + const _11: rs.u16 = rs.u16WrappingAdd(note.calls.v, 1); + rs.cellSet(note.calls, _11); return note; } /** Each call of a vtable `TABLE`'s function `call` on the `Note` its data points at. */ -export function heard$120(call: rt.u8, data: rt.Place): void { +export function heard$120(call: rs.u8, data: rs.Place): void { const note: Note.Note = noteOf(data); - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, 120, note.id, note.calls.v & 0xff)), undefined, true); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, 120, note.id, note.calls.v & 0xff)), undefined, true); }); } /** Each call of a vtable `TABLE`'s function `call` on the `Note` its data points at. */ -export function heard$121(call: rt.u8, data: rt.Place): void { +export function heard$121(call: rs.u8, data: rs.Place): void { const note: Note.Note = noteOf(data); - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, 121, note.id, note.calls.v & 0xff)), undefined, true); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, 121, note.id, note.calls.v & 0xff)), undefined, true); }); } /** `heard` of `CALL`, as a vtable's function. */ -export function hear$120_114(data: rt.Place): void { +export function hear$120_114(data: rs.Place): void { heard$120(114, data); } /** `heard` of `CALL`, as a vtable's function. */ -export function hear$121_100(data: rt.Place): void { +export function hear$121_100(data: rs.Place): void { heard$121(100, data); } /** `heard` of `CALL`, as a vtable's function. */ -export function hear$121_114(data: rt.Place): void { +export function hear$121_114(data: rs.Place): void { heard$121(114, data); } /** `heard` of `CALL`, as a vtable's function. */ -export function hear$121_119(data: rt.Place): void { +export function hear$121_119(data: rs.Place): void { heard$121(119, data); } /** Each clone a box of a `Note` of its own, which the waker's drop frees. */ -export function boxedClone(data: rt.Place): rt.RawWaker { +export function boxedClone(data: rs.Place): rs.RawWaker { heard$120(99, data); - return { data: rt.ptrErase({ id: rt.u8WrappingAdd(noteOf(data).id, 1), calls: new rt.Cell(0) }, "raw::Note", 2), vtable: BOXED }; + return { data: rs.ptrErase({ id: rs.u8WrappingAdd(noteOf(data).id, 1), calls: new rs.Cell(0) }, "raw::Note", 2), vtable: BOXED }; } -export function boxedWake(data: rt.Place): void { +export function boxedWake(data: rs.Place): void { heard$120(119, data); boxedDrop(data); } -export function boxedDrop(data: rt.Place): void { +export function boxedDrop(data: rs.Place): void { heard$120(100, data); - const note: Note.Note = rt.ptrUnerase(data, "raw::Note", 2) as Note.Note; - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, note.id); + const note: Note.Note = rs.ptrUnerase(data, "raw::Note", 2) as Note.Note; + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, note.id); }); } -export const BOXED: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(boxedClone, boxedWake as (a0: rt.Place) => undefined, hear$120_114 as (a0: rt.Place) => undefined, boxedDrop as (a0: rt.Place) => undefined); +export const BOXED: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(boxedClone, boxedWake as (a0: rs.Place) => undefined, hear$120_114 as (a0: rs.Place) => undefined, boxedDrop as (a0: rs.Place) => undefined); /** Wakers of a `Note` the caller keeps, which cloning shares. */ -export function borrowedClone(data: rt.Place): rt.RawWaker { +export function borrowedClone(data: rs.Place): rs.RawWaker { heard$121(99, data); return { data, vtable: BORROWED }; } -export const BORROWED: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(borrowedClone, hear$121_119 as (a0: rt.Place) => undefined, hear$121_114 as (a0: rt.Place) => undefined, hear$121_100 as (a0: rt.Place) => undefined); +export const BORROWED: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(borrowedClone, hear$121_119 as (a0: rs.Place) => undefined, hear$121_114 as (a0: rs.Place) => undefined, hear$121_100 as (a0: rs.Place) => undefined); /** * Waker data cast to `*const ()` by each way std has, from a reference, a `*mut`, a box, * and a `NonNull`, which the vtable's functions cast back and read; and erased pointers * compared, null and dangling ones among them. */ -export function erased(data: rt.ByteSlice, out: rt.ByteVec): void { - let w!: rt.Waker; - const kept: Note.Note = { id: 64, calls: new rt.Cell(0) }; - const other: Note.Note = { id: 65, calls: new rt.Cell(0) }; - const shared: rt.Place = rt.ptrErase(kept, "raw::Note", 2); - rt.byteVecPush(out, shared === rt.ptrErase(kept, "raw::Note", 2) ? 1 : 0); - rt.byteVecPush(out, shared === rt.ptrErase(other, "raw::Note", 2) ? 1 : 0); - rt.byteVecPush(out, shared === rt.ptrErase(kept, "raw::Note", 2) ? 1 : 0); - const first: rt.Waker = new rt.VTableWaker(shared, BORROWED); - const second: rt.Waker = new rt.VTableWaker(rt.ptrErase(other, "raw::Note", 2), BORROWED); - rt.byteVecPush(out, rt.willWake(first, second) ? 1 : 0); - const _47: rt.Waker = new rt.VTableWaker(rt.ptrErase(kept, "raw::Note", 2), BORROWED); - rt.byteVecPush(out, rt.willWake(first, _47) ? 1 : 0); +export function erased(data: rs.ByteSlice, out: rs.ByteVec): void { + let w!: rs.Waker; + const kept: Note.Note = { id: 64, calls: new rs.Cell(0) }; + const other: Note.Note = { id: 65, calls: new rs.Cell(0) }; + const shared: rs.Place = rs.ptrErase(kept, "raw::Note", 2); + rs.byteVecPush(out, shared === rs.ptrErase(kept, "raw::Note", 2) ? 1 : 0); + rs.byteVecPush(out, shared === rs.ptrErase(other, "raw::Note", 2) ? 1 : 0); + rs.byteVecPush(out, shared === rs.ptrErase(kept, "raw::Note", 2) ? 1 : 0); + const first: rs.Waker = new rs.VTableWaker(shared, BORROWED); + const second: rs.Waker = new rs.VTableWaker(rs.ptrErase(other, "raw::Note", 2), BORROWED); + rs.byteVecPush(out, rs.willWake(first, second) ? 1 : 0); + const _47: rs.Waker = new rs.VTableWaker(rs.ptrErase(kept, "raw::Note", 2), BORROWED); + rs.byteVecPush(out, rs.willWake(first, _47) ? 1 : 0); _47[Symbol.dispose](); - const wakers: rt.Vec = new rt.Vec(); - for (const byte of rt.byteSliceView(data)) { - const id: rt.u8 = byte & 63; - const _60: rt.u8 = byte >> 6; + const wakers: rs.Vec = new rs.Vec(); + for (const byte of rs.byteSliceView(data)) { + const id: rs.u8 = byte & 63; + const _60: rs.u8 = byte >> 6; if (_60 === 0) { w = first.clone(); } else if (_60 === 1) { w = second.clone(); } else if (_60 === 2) { - w = new rt.VTableWaker(rt.ptrErase({ id, calls: new rt.Cell(0) }, "raw::Note", 2), BOXED); + w = new rs.VTableWaker(rs.ptrErase({ id, calls: new rs.Cell(0) }, "raw::Note", 2), BOXED); } else { - w = rt.wakerFromRaw({ data: rt.ptrErase({ id, calls: new rt.Cell(0) }, "raw::Note", 2), vtable: BOXED }); + w = rs.wakerFromRaw({ data: rs.ptrErase({ id, calls: new rs.Cell(0) }, "raw::Note", 2), vtable: BOXED }); } - const _80: rt.u8 = rt.u8Rem(byte, 3); + const _80: rs.u8 = rs.u8Rem(byte, 3); if (_80 === 0) { w.wakeByRef(); } else if (_80 === 1) { - const _84: rt.Waker = w.clone(); + const _84: rs.Waker = w.clone(); wakers.items.push(_84); } - if (rt.u8Rem(byte, 4) === 0) { + if (rs.u8Rem(byte, 4) === 0) { w.wake(); } else { wakers.items.push(w); } - rt.byteVecPush(out, noteOf(option_mapOr$13g654t(rt.sliceLast(wakers.items), shared, (a0: rt.Waker): rt.Place => { - return a0.data as rt.Place; + rs.byteVecPush(out, noteOf(option_mapOr$1ntkzhx(rs.sliceLast(wakers.items), shared, (a0: rs.Waker): rs.Place => { + return a0.data as rs.Place; })).id); } while (true) { - const _99: rt.Waker | undefined = rt.vecPop(wakers); + const _99: rs.Waker | undefined = rs.vecPop(wakers); if (_99 !== undefined) { - const w2: rt.Waker = _99; + const w2: rs.Waker = _99; w2.wakeByRef(); w2[Symbol.dispose](); } else { break; } } - drop$tuple2_task_Waker_task_Waker([first, second] as [rt.Waker, rt.Waker]); - const _110: Note.Note = rt.ptrUnerase(rt.ptrErase(kept, "raw::Note", 2), "raw::Note", 2) as Note.Note; + drop$tuple2_task_Waker_task_Waker([first, second] as [rs.Waker, rs.Waker]); + const _110: Note.Note = rs.ptrUnerase(rs.ptrErase(kept, "raw::Note", 2), "raw::Note", 2) as Note.Note; _110.id = _110.id ^ 15; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept.id, kept.calls.v & 0xff, other.calls.v & 0xff)), undefined, true); - const null_: rt.Place = rt.ptrErase(rt.NULL, "raw::Note", 2); - rt.byteVecPush(out, null_ === rt.NULL ? 1 : 0); - rt.byteVecPush(out, (rt.ptrUnerase(null_, "raw::Note", 2) as Note.Note) === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.ptrErase(rt.NULL, "raw::Note", 2) === rt.NULL ? 1 : 0); - const unit: rt.Place = rt.DANGLING_UNIT; - const note2: rt.Place = rt.ptrErase(rt.DANGLING, "raw::Note", 2); - const byte2: rt.Place = rt.ptrErase(rt.DANGLING, "raw::Byte", 1); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([unit === note2, unit === byte2, note2 === byte2, note2 === rt.NULL], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(kept.id, kept.calls.v & 0xff, other.calls.v & 0xff)), undefined, true); + const null_: rs.Place = rs.ptrErase(rs.NULL, "raw::Note", 2); + rs.byteVecPush(out, null_ === rs.NULL ? 1 : 0); + rs.byteVecPush(out, (rs.ptrUnerase(null_, "raw::Note", 2) as Note.Note) === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.ptrErase(rs.NULL, "raw::Note", 2) === rs.NULL ? 1 : 0); + const unit: rs.Place = rs.DANGLING_UNIT; + const note2: rs.Place = rs.ptrErase(rs.DANGLING, "raw::Note", 2); + const byte2: rs.Place = rs.ptrErase(rs.DANGLING, "raw::Byte", 1); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([unit === note2, unit === byte2, note2 === byte2, note2 === rs.NULL], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, (rt.ptrUnerase(note2, "raw::Note", 2) as Note.Note) === rt.DANGLING ? 1 : 0); - const through2: rt.Place = rt.ptrErase(rt.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte, "raw::Byte", 1); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([through2 === note2, through2 === unit, (rt.ptrUnerase(through2, "raw::Note", 2) as Note.Note) === rt.NULL], (a03: boolean): rt.u8 => { + rs.byteVecPush(out, (rs.ptrUnerase(note2, "raw::Note", 2) as Note.Note) === rs.DANGLING ? 1 : 0); + const through2: rs.Place = rs.ptrErase(rs.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte, "raw::Byte", 1); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([through2 === note2, through2 === unit, (rs.ptrUnerase(through2, "raw::Note", 2) as Note.Note) === rs.NULL], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, rt.ptrErase(rt.ptrUnerase(byte2, "raw::Note", 2) as Note.Note, "raw::Note", 2) === unit ? 1 : 0); - const _174: [Byte.Byte, Byte.Byte] = [rt.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte, rt.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte]; + rs.byteVecPush(out, rs.ptrErase(rs.ptrUnerase(byte2, "raw::Note", 2) as Note.Note, "raw::Note", 2) === unit ? 1 : 0); + const _174: [Byte.Byte, Byte.Byte] = [rs.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte, rs.ptrUnerase(note2, "raw::Byte", 1) as Byte.Byte]; const a: Byte.Byte = _174[0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([a === _174[1], a === rt.DANGLING, a === rt.NULL], (a04: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([a === _174[1], a === rs.DANGLING, a === rs.NULL], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.dropVec(wakers); + rs.dropVec(wakers); } /** The `Task` a waker's data is the `Arc` of, borrowed, which a wake notes, and its count. */ -export function woken(call: rt.u8, data: rt.Place): void { - const task: rt.Arc = rt.arcFromRaw(rt.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc"); +export function woken(call: rs.u8, data: rs.Place): void { + const task: rs.Arc = rs.arcFromRaw(rs.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc"); const _8: Task.Task = task.value; - const _11: rt.u8 = rt.u8WrappingAdd(task.value.wakes.v, 1); - rt.cellSet(_8.wakes, _11); - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(call, task.value.id, task.strong & 0xff)), undefined, true); + const _11: rs.u8 = rs.u8WrappingAdd(task.value.wakes.v, 1); + rs.cellSet(_8.wakes, _11); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(call, task.value.id, task.strong & 0xff)), undefined, true); }); } -export function taskClone(data: rt.Place): rt.RawWaker { - rt.arcClone(rt.arcFromRaw(rt.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")); +export function taskClone(data: rs.Place): rs.RawWaker { + rs.arcClone(rs.arcFromRaw(rs.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")); undefined; return { data, vtable: TASK }; } -export function taskWake(data: rt.Place): void { +export function taskWake(data: rs.Place): void { woken(119, data); - rt.arcFromRaw(rt.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")[Symbol.dispose](); + rs.arcFromRaw(rs.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")[Symbol.dispose](); } -export function taskWakeByRef(data: rt.Place): void { +export function taskWakeByRef(data: rs.Place): void { woken(114, data); } -export function taskDrop(data: rt.Place): void { - rt.arcFromRaw(rt.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")[Symbol.dispose](); +export function taskDrop(data: rs.Place): void { + rs.arcFromRaw(rs.ptrUnerase(data, "raw::Task", 1) as Task.Task, "Arc")[Symbol.dispose](); } -export const TASK: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(taskClone, taskWake as (a0: rt.Place) => undefined, taskWakeByRef as (a0: rt.Place) => undefined, taskDrop as (a0: rt.Place) => undefined); +export const TASK: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(taskClone, taskWake as (a0: rs.Place) => undefined, taskWakeByRef as (a0: rs.Place) => undefined, taskDrop as (a0: rs.Place) => undefined); /** A waker of `task`, which holds one count of it. */ -export function taskWaker(task: rt.Arc): rt.Waker { +export function taskWaker(task: rs.Arc): rs.Waker { const arc = task; - return new rt.VTableWaker(rt.ptrErase(rt.arcRaw(arc, arc.value, "Arc"), "raw::Task", 1), TASK); + return new rs.VTableWaker(rs.ptrErase(rs.arcRaw(arc, arc.value, "Arc"), "raw::Task", 1), TASK); } /** @@ -670,75 +670,75 @@ export function taskWaker(task: rt.Arc): rt.Waker { * and dropped as each byte says, each counting the `Arc` as std's do, so the `Task` drops * with the last; and polling a future to its end. */ -export function tasks(data: rt.ByteSlice, out: rt.ByteVec): void { - let _101!: rt.Poll; - const task: rt.Arc = new rt.Arc(new Task.Task(1, new rt.Cell(0))); - const wakers: rt.Vec = rt.vecFrom([taskWaker(rt.arcClone(task))]); - for (const byte of rt.byteSliceView(data)) { +export function tasks(data: rs.ByteSlice, out: rs.ByteVec): void { + let _101!: rs.Poll; + const task: rs.Arc = new rs.Arc(new Task.Task(1, new rs.Cell(0))); + const wakers: rs.Vec = rs.vecFrom([taskWaker(rs.arcClone(task))]); + for (const byte of rs.byteSliceView(data)) { b2: { - const _18: rt.u8 = rt.u8Rem(byte, 5); + const _18: rs.u8 = rs.u8Rem(byte, 5); if (_18 === 0) { - const _21: rt.Waker = wakers.items[rt.idx(wakers.items, rt.usizeRem(byte as rt.usize, wakers.items.length))].clone(); + const _21: rs.Waker = wakers.items[rs.idx(wakers.items, rs.usizeRem(byte as rs.usize, wakers.items.length))].clone(); wakers.items.push(_21); break b2; } if (_18 === 1) { if (wakers.items.length > 1) { - rt.vecSwapRemove(wakers, rt.usizeRem(byte as rt.usize, wakers.items.length)).wake(); + rs.vecSwapRemove(wakers, rs.usizeRem(byte as rs.usize, wakers.items.length)).wake(); break b2; } } else { if (_18 === 2) { - wakers.items[rt.idx(wakers.items, rt.usizeRem(byte as rt.usize, wakers.items.length))].wakeByRef(); + wakers.items[rs.idx(wakers.items, rs.usizeRem(byte as rs.usize, wakers.items.length))].wakeByRef(); break b2; } if (_18 === 3) { if (wakers.items.length > 1) { - rt.vecSwapRemove(wakers, rt.usizeRem(byte as rt.usize, wakers.items.length))[Symbol.dispose](); + rs.vecSwapRemove(wakers, rs.usizeRem(byte as rs.usize, wakers.items.length))[Symbol.dispose](); break b2; } } } - rt.byteVecPush(out, rt.willWake(wakers.items[rt.idx(wakers.items, 0)], wakers.items[rt.idx(wakers.items, rt.usizeRem(byte as rt.usize, wakers.items.length))]) ? 1 : 0); + rs.byteVecPush(out, rs.willWake(wakers.items[rs.idx(wakers.items, 0)], wakers.items[rs.idx(wakers.items, rs.usizeRem(byte as rs.usize, wakers.items.length))]) ? 1 : 0); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(task.strong & 0xff, wakers.items.length & 0xff, task.value.wakes.v)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(task.strong & 0xff, wakers.items.length & 0xff, task.value.wakes.v)), undefined, true); } task[Symbol.dispose](); while (true) { - const _80: rt.Waker | undefined = rt.vecPop(wakers); + const _80: rs.Waker | undefined = rs.vecPop(wakers); if (_80 !== undefined) { _80.wake(); } else { break; } } - const task2: rt.Arc = new rt.Arc(new Task.Task(2, new rt.Cell(0))); - const waker: rt.Waker = taskWaker(rt.arcClone(task2)); - const cx: rt.Context = waker; - const pinned: rt.Future = new tasksFuture$closure1(rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): rt.u8 => { - return rt.u8Rem(b, 4); + const task2: rs.Arc = new rs.Arc(new Task.Task(2, new rs.Cell(0))); + const waker: rs.Waker = taskWaker(rs.arcClone(task2)); + const cx: rs.Context = waker; + const pinned: rs.Future = new tasksFuture$closure1(rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.u8 => { + return rs.u8Rem(b, 4); }), undefined, true)); - const f: rt.Future = pinned; + const f: rs.Future = pinned; while (true) { _101 = f.poll(cx); - if (_101 !== rt.Pending) { + if (_101 !== rs.Pending) { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_101, task2.value.wakes.v, task2.strong & 0xff)), undefined, true); - drop$tuple2_task_Waker_sync_Arc_raw_Task([waker, task2] as [rt.Waker, rt.Arc]); - rt.drop(pinned); - rt.dropVec(wakers); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_101, task2.value.wakes.v, task2.strong & 0xff)), undefined, true); + drop$tuple2_task_Waker_sync_Arc_raw_Task([waker, task2] as [rs.Waker, rs.Arc]); + rs.drop(pinned); + rs.dropVec(wakers); } export class tasksFuture$closure1 { #state: number = 0; - #counts: rt.ByteVec; - #iter!: rt.Iter; - #saved!: rt.u8; + #counts: rs.ByteVec; + #iter!: rs.Iter; + #saved!: rs.u8; #awaitee!: Yields.Yields; - constructor(counts: rt.ByteVec) { + constructor(counts: rs.ByteVec) { this.#counts = counts; } @@ -748,46 +748,46 @@ export class tasksFuture$closure1 { } } - poll(_2: rt.Context): rt.Poll { - let sum!: rt.u8; + poll(_2: rs.Context): rs.Poll { + let sum!: rs.u8; let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { sum = 0; - this.#iter = rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(this.#counts))); + this.#iter = rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(this.#counts))); bb0 = 4; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 10; continue; } case 4: - const _7: rt.u8 | rt.Done = this.#iter.next(); - if (_7 === rt.DONE) { + const _7: rs.u8 | rs.Done = this.#iter.next(); + if (_7 === rs.DONE) { this.#state = 1; return sum; } - const n: rt.u8 = _7; + const n: rs.u8 = _7; this.#saved = sum; this.#awaitee = new Yields.Yields(n, undefined); bb0 = 10; continue; case 10: - const _15: rt.Poll = Yields.poll$Future(this.#awaitee, _2); - if (_15 !== rt.Pending) { - const result: rt.u8 = _15; + const _15: rs.Poll = Yields.poll$Future(this.#awaitee, _2); + if (_15 !== rs.Pending) { + const result: rs.u8 = _15; this.#awaitee[Symbol.dispose](); - sum = rt.u8WrappingAdd(this.#saved, result); + sum = rs.u8WrappingAdd(this.#saved, result); bb0 = 4; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } diff --git a/ts/fixtures/lang/futures/expected/std/thread/local.ts b/ts/fixtures/lang/futures/expected/std/thread/local.ts index 137323f2b..b92fe1d98 100644 --- a/ts/fixtures/lang/futures/expected/std/thread/local.ts +++ b/ts/fixtures/lang/futures/expected/std/thread/local.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function set$08o17gp(self: rt.LocalKey>, value: boolean): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell | undefined, cell: rt.Cell): undefined => { +export function set$15db765(self: rs.LocalKey>, value: boolean): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell | undefined, cell: rs.Cell): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function get$0lasdfu(self: rt.LocalKey>): boolean { - return ((a0: rt.Cell): boolean => { +export function get$1htgqdl(self: rs.LocalKey>): boolean { + return ((a0: rs.Cell): boolean => { return a0.v; })(self.get()); } -export function take$122f15k(self: rt.LocalKey>): rt.ByteVec { - return ((a0: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(a0, new rt.ByteVec()); +export function take$1snv7rd(self: rs.LocalKey>): rs.ByteVec { + return ((a0: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(a0, new rs.ByteVec()); })(self.get()); } diff --git a/ts/fixtures/lang/hashes/expected/core/bool.ts b/ts/fixtures/lang/hashes/expected/core/bool.ts index 5207f04fe..329386e9a 100644 --- a/ts/fixtures/lang/hashes/expected/core/bool.ts +++ b/ts/fixtures/lang/hashes/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0n2gkz4(self: boolean, t: rt.i32): rt.i32 | undefined { +export function thenSome$05ku0zn(self: boolean, t: rs.i32): rs.i32 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/hashes/expected/core/option.ts b/ts/fixtures/lang/hashes/expected/core/option.ts index a1a70d4eb..85552d450 100644 --- a/ts/fixtures/lang/hashes/expected/core/option.ts +++ b/ts/fixtures/lang/hashes/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0k15iai(self: rt.char | undefined, default_: rt.char): rt.char { +export function unwrapOr$04rqm9m(self: rs.char | undefined, default_: rs.char): rs.char { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/hashes/expected/core/result.ts b/ts/fixtures/lang/hashes/expected/core/result.ts index 9f3171569..baa84c2c2 100644 --- a/ts/fixtures/lang/hashes/expected/core/result.ts +++ b/ts/fixtures/lang/hashes/expected/core/result.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$01jdcm7(self: rt.Result, default_: string): string { +export function unwrapOr$0a3q6xs(self: rs.Result, default_: string): string { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/hashes/expected/harness.ts b/ts/fixtures/lang/hashes/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/hashes/expected/harness.ts +++ b/ts/fixtures/lang/hashes/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Bare.ts b/ts/fixtures/lang/hashes/expected/hashes.Bare.ts index a09a30f6b..13b8a4733 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Bare.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Bare.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { record } from "./hashes.ts"; /** @@ -8,20 +8,20 @@ import { record } from "./hashes.ts"; * method is std's, which writes through them. */ export interface Bare { - _0: rt.RefCell; + _0: rs.RefCell; } -export function finish$hash_Hasher(self: Bare): rt.u64 { - const _5: rt.RefCell = rt.refCellBorrow(self._0); - const _0: rt.u64 = _5.value.length as rt.u64; - rt.refRelease(_5); +export function finish$hash_Hasher(self: Bare): rs.u64 { + const _5: rs.RefCell = rs.refCellBorrow(self._0); + const _0: rs.u64 = _5.value.length as rs.u64; + rs.refRelease(_5); return _0; } /** The methods of `hashes::Bare<'_>`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: Bare, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: Bare, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher }; -export function write$hash_Hasher(self: Bare, bytes: rt.ByteSlice): void { +export function write$hash_Hasher(self: Bare, bytes: rs.ByteSlice): void { record(self._0, 119, bytes); } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Build.ts b/ts/fixtures/lang/hashes/expected/hashes.Build.ts index 67303cc16..2b385bb9b 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Build.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Build.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { record } from "./hashes.ts"; import * as Full from "./hashes.Full.ts"; /** What builds a [`Full`], logging that it did. */ export interface Build { - _0: rt.RefCell; + _0: rs.RefCell; } export function buildHasher$hash_BuildHasher(self: Build): Full.Full { - record(self._0, 98, rt.byteSliceFrom(Uint8Array.of())); + record(self._0, 98, rs.byteSliceFrom(Uint8Array.of())); return new Full.Full(self._0); } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Counted.ts b/ts/fixtures/lang/hashes/expected/hashes.Counted.ts index c99b86657..e617d451f 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Counted.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Counted.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A value that counts its drops, hashed as its byte. */ export class Counted { - _0: rt.u8; - _1: rt.Cell; + _0: rs.u8; + _1: rs.Cell; - constructor(_0: rt.u8, _1: rt.Cell) { + constructor(_0: rs.u8, _1: rs.Cell) { this._0 = _0; this._1 = _1; } @@ -17,12 +17,12 @@ export class Counted { } } -export function hash$Hash_hash_DefaultHasher(self: Counted, state: rt.Hasher): void { - rt.hash8(self._0, state); +export function hash$Hash_hash_DefaultHasher(self: Counted, state: rs.Hasher): void { + rs.hash8(self._0, state); } export function drop$ops_Drop(self: Counted): void { - rt.cellSet(self._1, rt.u8Add(self._1.v, 1)); + rs.cellSet(self._1, rs.u8Add(self._1.v, 1)); } //# sourceMappingURL=hashes.Counted.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Dir.ts b/ts/fixtures/lang/hashes/expected/hashes.Dir.ts index c6a68a3a6..7fa3683d5 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Dir.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Dir.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Full from "./hashes.Full.ts"; import * as Partial from "./hashes.Partial.ts"; import * as Switch from "./hashes.Switch.ts"; -export function hash$Hash_hash_DefaultHasher(self: Dir, state: rt.Hasher): void { - rt.hashIsize({ Up: 0, Down: 1 }[self], state); +export function hash$Hash_hash_DefaultHasher(self: Dir, state: rs.Hasher): void { + rs.hashIsize({ Up: 0, Down: 1 }[self], state); } export function hash$Hash_hashes_Bare(self: Dir, state: Bare.Bare): void { - rt.hashIsize({ Up: 0, Down: 1 }[self], new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashIsize({ Up: 0, Down: 1 }[self], new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } export function hash$Hash_hashes_Full(self: Dir, state: Full.Full): void { - rt.hashIsize({ Up: 0, Down: 1 }[self], new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashIsize({ Up: 0, Down: 1 }[self], new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } export function hash$Hash_hashes_Partial(self: Dir, state: Partial.Partial): void { - rt.hashIsize({ Up: 0, Down: 1 }[self], new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashIsize({ Up: 0, Down: 1 }[self], new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } -export function hash$Hash_hashes_Switch(self: Dir, state: rt.Place): void { - rt.hashIsize({ Up: 0, Down: 1 }[self], new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Dir, state: rs.Place): void { + rs.hashIsize({ Up: 0, Down: 1 }[self], new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } /** A fieldless enum, which is a JS string, hashed by its `isize` discriminant. */ diff --git a/ts/fixtures/lang/hashes/expected/hashes.Fnv.ts b/ts/fixtures/lang/hashes/expected/hashes.Fnv.ts index 222fd05f8..85cdfba03 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Fnv.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Fnv.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * FNV-1a, a `Hasher` of the crate's own that logs nothing, so a map may call it as often * as it likes. */ export interface Fnv { - _0: rt.u64; + _0: rs.u64; } export function default$Default(): Fnv { - return { _0: { hi: 0xcbf29ce4, lo: 0x84222325 } as rt.u64 }; + return { _0: { hi: 0xcbf29ce4, lo: 0x84222325 } as rs.u64 }; } -export function finish$hash_Hasher(self: Fnv): rt.u64 { +export function finish$hash_Hasher(self: Fnv): rs.u64 { return self._0; } /** The methods of `hashes::Fnv`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: Fnv, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: Fnv, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher }; -export function write$hash_Hasher(self: Fnv, bytes: rt.ByteSlice): void { - for (const b of rt.byteSliceView(bytes)) { - self._0 = rt.u64WrappingMul(rt.u64Xor(self._0, b as rt.u64), 1099511628211); +export function write$hash_Hasher(self: Fnv, bytes: rs.ByteSlice): void { + for (const b of rs.byteSliceView(bytes)) { + self._0 = rs.u64WrappingMul(rs.u64Xor(self._0, b as rs.u64), 1099511628211); } } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Full.ts b/ts/fixtures/lang/hashes/expected/hashes.Full.ts index 253112563..7e196f811 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Full.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Full.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { record } from "./hashes.ts"; /** @@ -8,9 +8,9 @@ import { record } from "./hashes.ts"; * its drop, as `finish` returns what it logged so far. */ export class Full { - _0: rt.RefCell; + _0: rs.RefCell; - constructor(_0: rt.RefCell) { + constructor(_0: rs.RefCell) { this._0 = _0; } @@ -19,79 +19,79 @@ export class Full { } } -export function finish$hash_Hasher(self: Full): rt.u64 { - record(self._0, 102, rt.byteSliceFrom(Uint8Array.of())); - const _9: rt.RefCell = rt.refCellBorrow(self._0); - const _0: rt.u64 = rt.u64Mul(_9.value.length as rt.u64, { hi: 0x9e3779b9, lo: 0x7f4a7c15 } as rt.u64); - rt.refRelease(_9); +export function finish$hash_Hasher(self: Full): rs.u64 { + record(self._0, 102, rs.byteSliceFrom(Uint8Array.of())); + const _9: rs.RefCell = rs.refCellBorrow(self._0); + const _0: rs.u64 = rs.u64Mul(_9.value.length as rs.u64, { hi: 0x9e3779b9, lo: 0x7f4a7c15 } as rs.u64); + rs.refRelease(_9); return _0; } /** The methods of `hashes::Full<'_>`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: Full, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: Full, a1: rt.u8) => undefined, u16: writeU16$hash_Hasher as (a0: Full, a1: rt.u16) => undefined, u32: writeU32$hash_Hasher as (a0: Full, a1: rt.u32) => undefined, u64: writeU64$hash_Hasher as (a0: Full, a1: rt.u64) => undefined, u128: writeU128$hash_Hasher as (a0: Full, a1: rt.u128) => undefined, usize: writeUsize$hash_Hasher as (a0: Full, a1: rt.usize) => undefined, i8: writeI8$hash_Hasher as (a0: Full, a1: rt.i8) => undefined, i16: writeI16$hash_Hasher as (a0: Full, a1: rt.i16) => undefined, i32: writeI32$hash_Hasher as (a0: Full, a1: rt.i32) => undefined, i64: writeI64$hash_Hasher as (a0: Full, a1: rt.i64) => undefined, i128: writeI128$hash_Hasher as (a0: Full, a1: rt.i128) => undefined, isize: writeIsize$hash_Hasher as (a0: Full, a1: rt.isize) => undefined, prefix: writeLengthPrefix$hash_Hasher as (a0: Full, a1: rt.usize) => undefined, str: writeStr$hash_Hasher as (a0: Full, a1: string) => undefined }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: Full, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: Full, a1: rs.u8) => undefined, u16: writeU16$hash_Hasher as (a0: Full, a1: rs.u16) => undefined, u32: writeU32$hash_Hasher as (a0: Full, a1: rs.u32) => undefined, u64: writeU64$hash_Hasher as (a0: Full, a1: rs.u64) => undefined, u128: writeU128$hash_Hasher as (a0: Full, a1: rs.u128) => undefined, usize: writeUsize$hash_Hasher as (a0: Full, a1: rs.usize) => undefined, i8: writeI8$hash_Hasher as (a0: Full, a1: rs.i8) => undefined, i16: writeI16$hash_Hasher as (a0: Full, a1: rs.i16) => undefined, i32: writeI32$hash_Hasher as (a0: Full, a1: rs.i32) => undefined, i64: writeI64$hash_Hasher as (a0: Full, a1: rs.i64) => undefined, i128: writeI128$hash_Hasher as (a0: Full, a1: rs.i128) => undefined, isize: writeIsize$hash_Hasher as (a0: Full, a1: rs.isize) => undefined, prefix: writeLengthPrefix$hash_Hasher as (a0: Full, a1: rs.usize) => undefined, str: writeStr$hash_Hasher as (a0: Full, a1: string) => undefined }; -export function write$hash_Hasher(self: Full, bytes: rt.ByteSlice): void { +export function write$hash_Hasher(self: Full, bytes: rs.ByteSlice): void { record(self._0, 119, bytes); } -export function writeU8$hash_Hasher(self: Full, i: rt.u8): void { - record(self._0, 1, rt.byteSliceFrom(rt.u8ToBeBytes(i).reverse())); +export function writeU8$hash_Hasher(self: Full, i: rs.u8): void { + record(self._0, 1, rs.byteSliceFrom(rs.u8ToBeBytes(i).reverse())); } -export function writeU16$hash_Hasher(self: Full, i: rt.u16): void { - record(self._0, 2, rt.byteSliceFrom(rt.u16ToBeBytes(i).reverse())); +export function writeU16$hash_Hasher(self: Full, i: rs.u16): void { + record(self._0, 2, rs.byteSliceFrom(rs.u16ToBeBytes(i).reverse())); } -export function writeU32$hash_Hasher(self: Full, i: rt.u32): void { - record(self._0, 3, rt.byteSliceFrom(rt.u32ToBeBytes(i).reverse())); +export function writeU32$hash_Hasher(self: Full, i: rs.u32): void { + record(self._0, 3, rs.byteSliceFrom(rs.u32ToBeBytes(i).reverse())); } -export function writeU64$hash_Hasher(self: Full, i: rt.u64): void { - record(self._0, 4, rt.byteSliceFrom(rt.u64ToBeBytes(i).reverse())); +export function writeU64$hash_Hasher(self: Full, i: rs.u64): void { + record(self._0, 4, rs.byteSliceFrom(rs.u64ToBeBytes(i).reverse())); } -export function writeU128$hash_Hasher(self: Full, i: rt.u128): void { - record(self._0, 5, rt.byteSliceFrom(rt.u128ToBeBytes(i).reverse())); +export function writeU128$hash_Hasher(self: Full, i: rs.u128): void { + record(self._0, 5, rs.byteSliceFrom(rs.u128ToBeBytes(i).reverse())); } -export function writeUsize$hash_Hasher(self: Full, i: rt.usize): void { - record(self._0, 6, rt.byteSliceFrom(rt.usizeToBeBytes(i).reverse())); +export function writeUsize$hash_Hasher(self: Full, i: rs.usize): void { + record(self._0, 6, rs.byteSliceFrom(rs.usizeToBeBytes(i).reverse())); } -export function writeI8$hash_Hasher(self: Full, i: rt.i8): void { - record(self._0, 7, rt.byteSliceFrom(rt.i8ToBeBytes(i).reverse())); +export function writeI8$hash_Hasher(self: Full, i: rs.i8): void { + record(self._0, 7, rs.byteSliceFrom(rs.i8ToBeBytes(i).reverse())); } -export function writeI16$hash_Hasher(self: Full, i: rt.i16): void { - record(self._0, 8, rt.byteSliceFrom(rt.i16ToBeBytes(i).reverse())); +export function writeI16$hash_Hasher(self: Full, i: rs.i16): void { + record(self._0, 8, rs.byteSliceFrom(rs.i16ToBeBytes(i).reverse())); } -export function writeI32$hash_Hasher(self: Full, i: rt.i32): void { - record(self._0, 9, rt.byteSliceFrom(rt.i32ToBeBytes(i).reverse())); +export function writeI32$hash_Hasher(self: Full, i: rs.i32): void { + record(self._0, 9, rs.byteSliceFrom(rs.i32ToBeBytes(i).reverse())); } -export function writeI64$hash_Hasher(self: Full, i: rt.i64): void { - record(self._0, 10, rt.byteSliceFrom(rt.i64ToBeBytes(i).reverse())); +export function writeI64$hash_Hasher(self: Full, i: rs.i64): void { + record(self._0, 10, rs.byteSliceFrom(rs.i64ToBeBytes(i).reverse())); } -export function writeI128$hash_Hasher(self: Full, i: rt.i128): void { - record(self._0, 11, rt.byteSliceFrom(rt.i128ToBeBytes(i).reverse())); +export function writeI128$hash_Hasher(self: Full, i: rs.i128): void { + record(self._0, 11, rs.byteSliceFrom(rs.i128ToBeBytes(i).reverse())); } -export function writeIsize$hash_Hasher(self: Full, i: rt.isize): void { - record(self._0, 12, rt.byteSliceFrom(rt.isizeToBeBytes(i).reverse())); +export function writeIsize$hash_Hasher(self: Full, i: rs.isize): void { + record(self._0, 12, rs.byteSliceFrom(rs.isizeToBeBytes(i).reverse())); } -export function writeLengthPrefix$hash_Hasher(self: Full, len: rt.usize): void { - record(self._0, 112, rt.byteSliceFrom(rt.usizeToBeBytes(len).reverse())); +export function writeLengthPrefix$hash_Hasher(self: Full, len: rs.usize): void { + record(self._0, 112, rs.byteSliceFrom(rs.usizeToBeBytes(len).reverse())); } export function writeStr$hash_Hasher(self: Full, s: string): void { - record(self._0, 115, rt.stringAsBytes(s)); + record(self._0, 115, rs.stringAsBytes(s)); } export function drop$ops_Drop(self: Full): void { - record(self._0, 100, rt.byteSliceFrom(Uint8Array.of())); + record(self._0, 100, rs.byteSliceFrom(Uint8Array.of())); } //# sourceMappingURL=hashes.Full.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Holder.ts b/ts/fixtures/lang/hashes/expected/hashes.Holder.ts index e2fd96f16..f6205ced2 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Holder.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Holder.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$hashes_Switch } from "./lib.ts"; import type * as Switch from "./hashes.Switch.ts"; /** A [`Switch`] held in a field, hashed into through a `&mut` to the field. */ export class Holder { - tag: rt.u8; + tag: rs.u8; h: Switch.Switch; - constructor(tag: rt.u8, h: Switch.Switch) { + constructor(tag: rs.u8, h: Switch.Switch) { this.tag = tag; this.h = h; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Index.ts b/ts/fixtures/lang/hashes/expected/hashes.Index.ts index eba57d8a8..3f63782f4 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Index.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Index.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Index, other: Index): boolean { - if (!rt.hashEq(rt.same)(self.names, other.names)) { + if (!rs.hashEq(rs.same)(self.names, other.names)) { return false; } - return rt.hashEq()(self.seen, other.seen); + return rs.hashEq()(self.seen, other.seen); } /** A type whose derived `PartialEq` compares the maps it holds. */ export interface Index { - names: rt.HashMap; - seen: rt.HashSet<[rt.u8, boolean]>; + names: rs.HashMap; + seen: rs.HashSet<[rs.u8, boolean]>; } //# sourceMappingURL=hashes.Index.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Key.ts b/ts/fixtures/lang/hashes/expected/hashes.Key.ts index cb8ca525a..8679e175e 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Key.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Key.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Fnv from "./hashes.Fnv.ts"; import * as Tally from "./hashes.Tally.ts"; @@ -15,36 +15,36 @@ export function eq$cmp_PartialEq(self: Key, other: Key): boolean { return self._1 === other._1; } -export function hash$Hash_hash_DefaultHasher(self: Key, state: rt.Hasher): void { - rt.hash16(self._0, state); - rt.hashStr(self._1, state); +export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { + rs.hash16(self._0, state); + rs.hashStr(self._1, state); } export function hash$Hash_hashes_Fnv(self: Key, state: Fnv.Fnv): void { - rt.hash16(self._0, new rt.OwnHasher(state, Fnv.hasher$hash_Hasher)); - rt.hashStr(self._1, new rt.OwnHasher(state, Fnv.hasher$hash_Hasher)); + rs.hash16(self._0, new rs.OwnHasher(state, Fnv.hasher$hash_Hasher)); + rs.hashStr(self._1, new rs.OwnHasher(state, Fnv.hasher$hash_Hasher)); } export function hash$Hash_hashes_Tally(self: Key, state: Tally.Tally): void { - rt.hash16(self._0, new rt.OwnHasher(state, Tally.hasher$hash_Hasher)); - rt.hashStr(self._1, new rt.OwnHasher(state, Tally.hasher$hash_Hasher)); + rs.hash16(self._0, new rs.OwnHasher(state, Tally.hasher$hash_Hasher)); + rs.hashStr(self._1, new rs.OwnHasher(state, Tally.hasher$hash_Hasher)); } -export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Key, other: Key): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self._0, other._0); if (cmp === 0) { - return rt.cmpStr(self._1, other._1); + return rs.cmpStr(self._1, other._1); } return cmp; } /** A key that is a JS object. */ export interface Key { - _0: rt.u16; + _0: rs.u16; _1: string; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Logged.ts b/ts/fixtures/lang/hashes/expected/hashes.Logged.ts index 9f979883f..f2b812e87 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Logged.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { record } from "./hashes.ts"; import * as Full from "./hashes.Full.ts"; import * as Switch from "./hashes.Switch.ts"; /** A value whose `Hash` calls a method std provides of the hasher, and logs its drop. */ export class Logged { - _0: rt.i16; - _1: rt.RefCell; + _0: rs.i16; + _1: rs.RefCell; - constructor(_0: rt.i16, _1: rt.RefCell) { + constructor(_0: rs.i16, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -25,13 +25,13 @@ export function hash$Hash_hashes_Full(self: Logged, state: Full.Full): void { Full.writeLengthPrefix$hash_Hasher(state, 2); } -export function hash$Hash_hashes_Switch(self: Logged, state: rt.Place): void { - rt.hashI16(self._0, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hashPrefix(2, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Logged, state: rs.Place): void { + rs.hashI16(self._0, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashPrefix(2, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } export function drop$ops_Drop(self: Logged): void { - record(self._1, 68, rt.byteSliceFrom(Uint8Array.of())); + record(self._1, 68, rs.byteSliceFrom(Uint8Array.of())); } //# sourceMappingURL=hashes.Logged.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Nibble.ts b/ts/fixtures/lang/hashes/expected/hashes.Nibble.ts index 472d8f0df..ade7db5e0 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Nibble.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Nibble.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Full from "./hashes.Full.ts"; import * as Partial from "./hashes.Partial.ts"; @@ -8,27 +8,27 @@ import * as Switch from "./hashes.Switch.ts"; /** A key whose `Hash` sees only its low nibble. */ export interface Nibble { - _0: rt.u8; + _0: rs.u8; } -export function hash$Hash_hash_DefaultHasher(self: Nibble, state: rt.Hasher): void { - rt.hash8(self._0 & 15, state); +export function hash$Hash_hash_DefaultHasher(self: Nibble, state: rs.Hasher): void { + rs.hash8(self._0 & 15, state); } export function hash$Hash_hashes_Bare(self: Nibble, state: Bare.Bare): void { - rt.hash8(self._0 & 15, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hash8(self._0 & 15, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } export function hash$Hash_hashes_Full(self: Nibble, state: Full.Full): void { - rt.hash8(self._0 & 15, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hash8(self._0 & 15, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } export function hash$Hash_hashes_Partial(self: Nibble, state: Partial.Partial): void { - rt.hash8(self._0 & 15, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hash8(self._0 & 15, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } -export function hash$Hash_hashes_Switch(self: Nibble, state: rt.Place): void { - rt.hash8(self._0 & 15, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Nibble, state: rs.Place): void { + rs.hash8(self._0 & 15, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } //# sourceMappingURL=hashes.Nibble.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Noisy.ts b/ts/fixtures/lang/hashes/expected/hashes.Noisy.ts index 2a9365ed5..2b9141145 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Noisy.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Noisy.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { event } from "./hashes.ts"; /** A value that logs its clone and its drop. */ export class Noisy { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Numbered.ts b/ts/fixtures/lang/hashes/expected/hashes.Numbered.ts index b3cb268a8..f8b9a5978 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Numbered.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Numbered.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { event } from "./hashes.ts"; import type * as Fnv from "./hashes.Fnv.ts"; @@ -9,9 +9,9 @@ import type * as Fnv from "./hashes.Fnv.ts"; * clone, and each drop, and seeds its [`Fnv`] by its number. */ export class Numbered { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } @@ -21,7 +21,7 @@ export class Numbered { } export function buildHasher$hash_BuildHasher(self: Numbered): Fnv.Fnv { - return { _0: rt.u64Xor({ hi: 0xcbf29ce4, lo: 0x84222325 } as rt.u64, self._0 as rt.u64) }; + return { _0: rs.u64Xor({ hi: 0xcbf29ce4, lo: 0x84222325 } as rs.u64, self._0 as rs.u64) }; } export function default$Default(): Numbered { @@ -31,7 +31,7 @@ export function default$Default(): Numbered { export function clone$Clone(self: Numbered): Numbered { event(99, self._0); - return new Numbered(rt.u8WrappingAdd(self._0, 1)); + return new Numbered(rs.u8WrappingAdd(self._0, 1)); } export function drop$ops_Drop(self: Numbered): void { diff --git a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts index 984429ab2..7471a87ff 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Packet.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Packet.ts @@ -1,57 +1,57 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Full from "./hashes.Full.ts"; import * as Partial from "./hashes.Partial.ts"; import * as Switch from "./hashes.Switch.ts"; -export function hash$Hash_hash_DefaultHasher(self: Packet, state: rt.Hasher): void { - rt.hash64(self.id, state); - rt.hash8(self.flags, state); - rt.hashStr(self.name, state); - rt.hashInts(2)(self.tags, state); - rt.hashOption(rt.hashI32)(self.next, state); +export function hash$Hash_hash_DefaultHasher(self: Packet, state: rs.Hasher): void { + rs.hash64(self.id, state); + rs.hash8(self.flags, state); + rs.hashStr(self.name, state); + rs.hashInts(2)(self.tags, state); + rs.hashOption(rs.hashI32)(self.next, state); } export function hash$Hash_hashes_Bare(self: Packet, state: Bare.Bare): void { - rt.hash64(self.id, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); - rt.hash8(self.flags, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); - rt.hashStr(self.name, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); - rt.hashInts(2)(self.tags, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); - rt.hashOption(rt.hashI32)(self.next, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hash64(self.id, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hash8(self.flags, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashStr(self.name, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashInts(2)(self.tags, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashOption(rs.hashI32)(self.next, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } export function hash$Hash_hashes_Full(self: Packet, state: Full.Full): void { - rt.hash64(self.id, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); - rt.hash8(self.flags, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); - rt.hashStr(self.name, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); - rt.hashInts(2)(self.tags, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); - rt.hashOption(rt.hashI32)(self.next, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hash64(self.id, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hash8(self.flags, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashStr(self.name, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashInts(2)(self.tags, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashOption(rs.hashI32)(self.next, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } export function hash$Hash_hashes_Partial(self: Packet, state: Partial.Partial): void { - rt.hash64(self.id, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); - rt.hash8(self.flags, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); - rt.hashStr(self.name, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); - rt.hashInts(2)(self.tags, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); - rt.hashOption(rt.hashI32)(self.next, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hash64(self.id, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hash8(self.flags, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashStr(self.name, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashInts(2)(self.tags, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashOption(rs.hashI32)(self.next, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } -export function hash$Hash_hashes_Switch(self: Packet, state: rt.Place): void { - rt.hash64(self.id, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hash8(self.flags, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hashStr(self.name, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hashInts(2)(self.tags, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hashOption(rt.hashI32)(self.next, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Packet, state: rs.Place): void { + rs.hash64(self.id, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hash8(self.flags, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashStr(self.name, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashInts(2)(self.tags, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashOption(rs.hashI32)(self.next, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } export interface Packet { - id: rt.u64; - flags: rt.u8; + id: rs.u64; + flags: rs.u8; name: string; - tags: rt.Vec; - next: rt.i32 | undefined; + tags: rs.Vec; + next: rs.i32 | undefined; } //# sourceMappingURL=hashes.Packet.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Partial.ts b/ts/fixtures/lang/hashes/expected/hashes.Partial.ts index 51fa5c301..a35c53565 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Partial.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Partial.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { record } from "./hashes.ts"; /** @@ -8,33 +8,33 @@ import { record } from "./hashes.ts"; * std's signed ones, length prefix, and `write_str` write. */ export interface Partial { - _0: rt.RefCell; + _0: rs.RefCell; } -export function finish$hash_Hasher(self: Partial): rt.u64 { - const _5: rt.RefCell = rt.refCellBorrow(self._0); - const _0: rt.u64 = _5.value.length as rt.u64; - rt.refRelease(_5); +export function finish$hash_Hasher(self: Partial): rs.u64 { + const _5: rs.RefCell = rs.refCellBorrow(self._0); + const _0: rs.u64 = _5.value.length as rs.u64; + rs.refRelease(_5); return _0; } /** The methods of `hashes::Partial<'_>`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: Partial, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: Partial, a1: rt.u8) => undefined, u64: writeU64$hash_Hasher as (a0: Partial, a1: rt.u64) => undefined, usize: writeUsize$hash_Hasher as (a0: Partial, a1: rt.usize) => undefined }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: Partial, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: Partial, a1: rs.u8) => undefined, u64: writeU64$hash_Hasher as (a0: Partial, a1: rs.u64) => undefined, usize: writeUsize$hash_Hasher as (a0: Partial, a1: rs.usize) => undefined }; -export function write$hash_Hasher(self: Partial, bytes: rt.ByteSlice): void { +export function write$hash_Hasher(self: Partial, bytes: rs.ByteSlice): void { record(self._0, 119, bytes); } -export function writeU8$hash_Hasher(self: Partial, i: rt.u8): void { - record(self._0, 1, rt.byteSliceFrom(Uint8Array.of(i))); +export function writeU8$hash_Hasher(self: Partial, i: rs.u8): void { + record(self._0, 1, rs.byteSliceFrom(Uint8Array.of(i))); } -export function writeU64$hash_Hasher(self: Partial, i: rt.u64): void { - record(self._0, 4, rt.byteSliceFrom(rt.u64ToBeBytes(i).reverse())); +export function writeU64$hash_Hasher(self: Partial, i: rs.u64): void { + record(self._0, 4, rs.byteSliceFrom(rs.u64ToBeBytes(i).reverse())); } -export function writeUsize$hash_Hasher(self: Partial, i: rt.usize): void { - record(self._0, 6, rt.byteSliceFrom(rt.usizeToBeBytes(i).reverse())); +export function writeUsize$hash_Hasher(self: Partial, i: rs.usize): void { + record(self._0, 6, rs.byteSliceFrom(rs.usizeToBeBytes(i).reverse())); } //# sourceMappingURL=hashes.Partial.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Priorities$random.ts b/ts/fixtures/lang/hashes/expected/hashes.Priorities$random.ts index a8b51a7eb..bb7402171 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Priorities$random.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Priorities$random.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$random_Default(): Priorities { - return { state: rt.randomState() }; + return { state: rs.randomState() }; } export interface Priorities { - state: rt.RandomState; + state: rs.RandomState; } //# sourceMappingURL=hashes.Priorities$random.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Seeded.ts b/ts/fixtures/lang/hashes/expected/hashes.Seeded.ts index 93a09526c..28cf0f776 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Seeded.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Seeded.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$hashes_Switch } from "./lib.ts"; import { record } from "./hashes.ts"; import * as Switch from "./hashes.Switch.ts"; @@ -19,13 +19,13 @@ export class Seeded { } export function buildHasher$hash_BuildHasher(self: Seeded): Switch.Switch { - let log!: rt.RefCell; + let log!: rs.RefCell; if (self._0.tag === "Log") { log = self._0._0; } else { log = self._0._0; } - record(log, 98, rt.byteSliceFrom(Uint8Array.of())); + record(log, 98, rs.byteSliceFrom(Uint8Array.of())); return Switch.clone$Clone(self._0); } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Shape.ts b/ts/fixtures/lang/hashes/expected/hashes.Shape.ts index a69f1dfb8..464b0002c 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Shape.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Shape.ts @@ -1,64 +1,64 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Full from "./hashes.Full.ts"; import * as Partial from "./hashes.Partial.ts"; import * as Switch from "./hashes.Switch.ts"; -export function hash$Hash_hash_DefaultHasher(self: Shape, state: rt.Hasher): void { - rt.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], state); +export function hash$Hash_hash_DefaultHasher(self: Shape, state: rs.Hasher): void { + rs.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], state); if (self.tag === "Line") { - rt.hash32(self._0, state); + rs.hash32(self._0, state); } else if (self.tag === "Rect") { - rt.hashI16(self.w, state); - rt.hashI16(self.h, state); + rs.hashI16(self.w, state); + rs.hashI16(self.h, state); } } export function hash$Hash_hashes_Bare(self: Shape, state: Bare.Bare): void { - rt.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); if (self.tag === "Line") { - rt.hash32(self._0, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hash32(self._0, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } else if (self.tag === "Rect") { - rt.hashI16(self.w, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); - rt.hashI16(self.h, new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashI16(self.w, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hashI16(self.h, new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } } export function hash$Hash_hashes_Full(self: Shape, state: Full.Full): void { - rt.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rs.OwnHasher(state, Full.hasher$hash_Hasher)); if (self.tag === "Line") { - rt.hash32(self._0, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hash32(self._0, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } else if (self.tag === "Rect") { - rt.hashI16(self.w, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); - rt.hashI16(self.h, new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashI16(self.w, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hashI16(self.h, new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } } export function hash$Hash_hashes_Partial(self: Shape, state: Partial.Partial): void { - rt.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); if (self.tag === "Line") { - rt.hash32(self._0, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hash32(self._0, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } else if (self.tag === "Rect") { - rt.hashI16(self.w, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); - rt.hashI16(self.h, new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashI16(self.w, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hashI16(self.h, new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } } -export function hash$Hash_hashes_Switch(self: Shape, state: rt.Place): void { - rt.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Shape, state: rs.Place): void { + rs.hashIsize({ Dot: 0, Line: 1, Rect: 2 }[self.tag], new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); if (self.tag === "Line") { - rt.hash32(self._0, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hash32(self._0, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } else if (self.tag === "Rect") { - rt.hashI16(self.w, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); - rt.hashI16(self.h, new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashI16(self.w, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); + rs.hashI16(self.h, new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } } export type Shape = | { tag: "Dot" } - | { tag: "Line"; _0: rt.u32 } - | { tag: "Rect"; w: rt.i16; h: rt.i16 }; + | { tag: "Line"; _0: rs.u32 } + | { tag: "Rect"; w: rs.i16; h: rs.i16 }; //# sourceMappingURL=hashes.Shape.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Sided.ts b/ts/fixtures/lang/hashes/expected/hashes.Sided.ts index c379f202a..c12641330 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Sided.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Sided.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { call } from "./hashes.ts"; /** @@ -8,13 +8,13 @@ import { call } from "./hashes.ts"; * whose key std hashes, and whose `eq` it calls with the other's as its argument. */ export interface Sided { - n: rt.u8; - side: rt.u8; + n: rs.u8; + side: rs.u8; } -export function hash$Hash_hash_DefaultHasher(self: Sided, state: rt.Hasher): void { +export function hash$Hash_hash_DefaultHasher(self: Sided, state: rs.Hasher): void { call(104, self.side, 0, self.n); - rt.hash8(self.n, state); + rs.hash8(self.n, state); } export function eq$cmp_PartialEq(self: Sided, other: Sided): boolean { diff --git a/ts/fixtures/lang/hashes/expected/hashes.Small.ts b/ts/fixtures/lang/hashes/expected/hashes.Small.ts index 1d382ecc0..f81764157 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Small.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Small.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Full from "./hashes.Full.ts"; import * as Partial from "./hashes.Partial.ts"; import * as Switch from "./hashes.Switch.ts"; -export function hash$Hash_hash_DefaultHasher(self: Small, state: rt.Hasher): void { - rt.hash8({ Low: 3, High: 200 }[self], state); +export function hash$Hash_hash_DefaultHasher(self: Small, state: rs.Hasher): void { + rs.hash8({ Low: 3, High: 200 }[self], state); } export function hash$Hash_hashes_Bare(self: Small, state: Bare.Bare): void { - rt.hash8({ Low: 3, High: 200 }[self], new rt.OwnHasher(state, Bare.hasher$hash_Hasher)); + rs.hash8({ Low: 3, High: 200 }[self], new rs.OwnHasher(state, Bare.hasher$hash_Hasher)); } export function hash$Hash_hashes_Full(self: Small, state: Full.Full): void { - rt.hash8({ Low: 3, High: 200 }[self], new rt.OwnHasher(state, Full.hasher$hash_Hasher)); + rs.hash8({ Low: 3, High: 200 }[self], new rs.OwnHasher(state, Full.hasher$hash_Hasher)); } export function hash$Hash_hashes_Partial(self: Small, state: Partial.Partial): void { - rt.hash8({ Low: 3, High: 200 }[self], new rt.OwnHasher(state, Partial.hasher$hash_Hasher)); + rs.hash8({ Low: 3, High: 200 }[self], new rs.OwnHasher(state, Partial.hasher$hash_Hasher)); } -export function hash$Hash_hashes_Switch(self: Small, state: rt.Place): void { - rt.hash8({ Low: 3, High: 200 }[self], new rt.OwnHasher(state, Switch.hasher$hash_Hasher)); +export function hash$Hash_hashes_Switch(self: Small, state: rs.Place): void { + rs.hash8({ Low: 3, High: 200 }[self], new rs.OwnHasher(state, Switch.hasher$hash_Hasher)); } /** A `u8` discriminant, which the derive writes as a byte. */ diff --git a/ts/fixtures/lang/hashes/expected/hashes.Spread.ts b/ts/fixtures/lang/hashes/expected/hashes.Spread.ts index 2a0c2af7c..f94edfd70 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Spread.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Spread.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Spread { return { _0: 0 }; @@ -8,7 +8,7 @@ export function default$Default(): Spread { /** What builds a [`Spreader`] of its seed. */ export interface Spread { - _0: rt.u64; + _0: rs.u64; } //# sourceMappingURL=hashes.Spread.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Switch.ts b/ts/fixtures/lang/hashes/expected/hashes.Switch.ts index 10e8a4f3a..2b4ea4dcb 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Switch.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Switch.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$hashes_Switch } from "./lib.ts"; import { record } from "./hashes.ts"; @@ -17,68 +17,68 @@ export function clone$Clone(self: Switch): Switch { * through its `&mut` must land in the original, its variant too. */ export type Switch = - | { tag: "Log"; _0: rt.RefCell } - | { tag: "Sum"; _0: rt.RefCell; _1: rt.u64 }; + | { tag: "Log"; _0: rs.RefCell } + | { tag: "Sum"; _0: rs.RefCell; _1: rs.u64 }; -export function finish$hash_Hasher(self: Switch): rt.u64 { +export function finish$hash_Hasher(self: Switch): rs.u64 { if (self.tag === "Log") { - const log: rt.RefCell = self._0; - record(log, 102, rt.byteSliceFrom(Uint8Array.of())); - const _10: rt.RefCell = rt.refCellBorrow(log); - const _0: rt.u64 = _10.value.length as rt.u64; - rt.refRelease(_10); + const log: rs.RefCell = self._0; + record(log, 102, rs.byteSliceFrom(Uint8Array.of())); + const _10: rs.RefCell = rs.refCellBorrow(log); + const _0: rs.u64 = _10.value.length as rs.u64; + rs.refRelease(_10); return _0; } - const log2: rt.RefCell = self._0; - const sum: rt.u64 = self._1; - record(log2, 70, rt.byteSliceFrom(rt.u64ToBeBytes(sum).reverse())); + const log2: rs.RefCell = self._0; + const sum: rs.u64 = self._1; + record(log2, 70, rs.byteSliceFrom(rs.u64ToBeBytes(sum).reverse())); return sum; } /** The methods of `hashes::Switch<'_>`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl> = { write: write$hash_Hasher as (a0: rt.Place, a1: rt.ByteSlice) => undefined, finish: (h: rt.Place) => finish$hash_Hasher(h.v), u8: writeU8$hash_Hasher as (a0: rt.Place, a1: rt.u8) => undefined }; +export const hasher$hash_Hasher: rs.HasherImpl> = { write: write$hash_Hasher as (a0: rs.Place, a1: rs.ByteSlice) => undefined, finish: (h: rs.Place) => finish$hash_Hasher(h.v), u8: writeU8$hash_Hasher as (a0: rs.Place, a1: rs.u8) => undefined }; -export function write$hash_Hasher(self: rt.Place, bytes: rt.ByteSlice): void { +export function write$hash_Hasher(self: rs.Place, bytes: rs.ByteSlice): void { b0: { if (self.v.tag === "Log") { record(self.v._0, 119, bytes); } else { - const iterS: Uint8Array = rt.byteSliceView(bytes); + const iterS: Uint8Array = rs.byteSliceView(bytes); let iterI: number = 0; while (true) { - const _8: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_8 === rt.DONE) { + const _8: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_8 === rs.DONE) { break b0; } - const _12: rt.u64 = rt.u64WrappingAdd(rt.u64WrappingMul(self.v._1, 31), _8 as rt.u64); + const _12: rs.u64 = rs.u64WrappingAdd(rs.u64WrappingMul(self.v._1, 31), _8 as rs.u64); self.v._1 = _12; } } } } -export function writeU8$hash_Hasher(self: rt.Place, i: rt.u8): void { +export function writeU8$hash_Hasher(self: rs.Place, i: rs.u8): void { if (self.v.tag === "Log") { - if (!(rt.u8Rem(i, 4) === 0)) { - record(self.v._0, 1, rt.byteSliceFrom(Uint8Array.of(i))); + if (!(rs.u8Rem(i, 4) === 0)) { + record(self.v._0, 1, rs.byteSliceFrom(Uint8Array.of(i))); } else { - const _9: Switch = { tag: "Sum", _0: self.v._0, _1: i as rt.u64 }; + const _9: Switch = { tag: "Sum", _0: self.v._0, _1: i as rs.u64 }; drop$hashes_Switch(self.v); self.v = _9; } } else { - self.v._1 = rt.u64Xor(self.v._1, rt.u64Shl(i as rt.u64, 56)); + self.v._1 = rs.u64Xor(self.v._1, rs.u64Shl(i as rs.u64, 56)); } } -export function drop$ops_Drop(self: rt.Place): void { - let log!: rt.RefCell; +export function drop$ops_Drop(self: rs.Place): void { + let log!: rs.RefCell; if (self.v.tag === "Log") { log = self.v._0; } else { log = self.v._0; } - record(log, 100, rt.byteSliceFrom(Uint8Array.of())); + record(log, 100, rs.byteSliceFrom(Uint8Array.of())); } //# sourceMappingURL=hashes.Switch.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts b/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts index 42dac65f4..506a9e320 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Tallied.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Tallied { - const _1: rt.u8 = 0; + const _1: rs.u8 = 0; undefined; return { tag: _1, state: undefined }; } export function clone$Clone(self: Tallied): Tallied { - const _2: rt.u8 = self.tag; + const _2: rs.u8 = self.tag; undefined; return { tag: _2, state: undefined }; } -export function fmt$fmt_Debug(self: Tallied, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Tallied, f: rs.Formatter): rs.Result { const _3: string = "Tallied"; const _4: string = "tag"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.tag, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); const _7: string = "state"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteStr(f, "BuildHasherDefault"); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$cmp_PartialEq(self: Tallied, other: Tallied): boolean { @@ -32,7 +32,7 @@ export function eq$cmp_PartialEq(self: Tallied, other: Tallied): boolean { /** `BuildHasherDefault` held in a field, its impls derived. */ export interface Tallied { - tag: rt.u8; + tag: rs.u8; state: undefined; } diff --git a/ts/fixtures/lang/hashes/expected/hashes.Tally.ts b/ts/fixtures/lang/hashes/expected/hashes.Tally.ts index f1e18f887..20e0dc911 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.Tally.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.Tally.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { event } from "./hashes.ts"; /** @@ -8,9 +8,9 @@ import { event } from "./hashes.ts"; * `Default` makes, each byte written, each finish, and each drop. */ export class Tally { - _0: rt.u64; + _0: rs.u64; - constructor(_0: rt.u64) { + constructor(_0: rs.u64) { this._0 = _0; } @@ -24,23 +24,23 @@ export function default$Default(): Tally { return new Tally(0); } -export function finish$hash_Hasher(self: Tally): rt.u64 { - event(102, rt.u64Low(self._0) & 0xff); +export function finish$hash_Hasher(self: Tally): rs.u64 { + event(102, rs.u64Low(self._0) & 0xff); return self._0; } /** The methods of `hashes::Tally`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: Tally, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: Tally, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher }; -export function write$hash_Hasher(self: Tally, bytes: rt.ByteSlice): void { - for (const b of rt.byteSliceView(bytes)) { +export function write$hash_Hasher(self: Tally, bytes: rs.ByteSlice): void { + for (const b of rs.byteSliceView(bytes)) { event(119, b); - self._0 = rt.u64WrappingAdd(rt.u64WrappingMul(self._0, 31), b as rt.u64); + self._0 = rs.u64WrappingAdd(rs.u64WrappingMul(self._0, 31), b as rs.u64); } } export function drop$ops_Drop(self: Tally): void { - event(100, rt.u64Low(self._0) & 0xff); + event(100, rs.u64Low(self._0) & 0xff); } //# sourceMappingURL=hashes.Tally.ts.map diff --git a/ts/fixtures/lang/hashes/expected/hashes.ts b/ts/fixtures/lang/hashes/expected/hashes.ts index 73c95838d..6f000b995 100644 --- a/ts/fixtures/lang/hashes/expected/hashes.ts +++ b/ts/fixtures/lang/hashes/expected/hashes.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Option_tuple2_u8_hashes_Noisy, drop$hashes_Switch, drop$tuple2_hashes_Seeded_hashes_Seeded } from "./lib.ts"; -import { thenSome$0n2gkz4 } from "./core/bool.ts"; -import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7 } from "./core/result.ts"; +import { thenSome$05ku0zn } from "./core/bool.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs } from "./core/result.ts"; import { put, text } from "./harness.ts"; import * as Bare from "./hashes.Bare.ts"; import * as Build from "./hashes.Build.ts"; @@ -32,448 +32,448 @@ import * as Tallied from "./hashes.Tallied.ts"; import * as Tally from "./hashes.Tally.ts"; /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Option_Option_u8(value: rt.u8 | undefined | rt.None, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hashOption(rt.hash8), rt.None)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Option_Option_u8(value: rs.u8 | undefined | rs.None, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hashOption(rs.hash8), rs.None)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Option_Vec_u8(value: rt.ByteVec | undefined, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hashBytes)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Option_Vec_u8(value: rs.ByteVec | undefined, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hashBytes)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Option_array2_u8(value: Uint8Array | undefined, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hashBytes)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Option_array2_u8(value: Uint8Array | undefined, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hashBytes)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Option_num_NonZero_u32(value: rt.u32 | undefined, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hash32)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Option_num_NonZero_u32(value: rs.u32 | undefined, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hash32)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Option_u32(value: rt.u32 | undefined, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hash32)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Option_u32(value: rs.u32 | undefined, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hash32)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$String(value: string, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashStr(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$String(value: string, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashStr(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Vec_u16(value: rt.Vec, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Vec_u16(value: rs.Vec, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$Vec_u8(value: rt.ByteVec, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$Vec_u8(value: rs.ByteVec, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array0_u8(value: rt.ByteSlice, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$array0_u8(value: rs.ByteSlice, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array2_hashes_Dir(value: Dir.Dir[], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashSlice(Dir.hash$Hash_hash_DefaultHasher as (a0: Dir.Dir, a1: rt.Hasher) => undefined)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$array2_hashes_Dir(value: Dir.Dir[], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashSlice(Dir.hash$Hash_hash_DefaultHasher as (a0: Dir.Dir, a1: rs.Hasher) => undefined)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array2_u8(value: rt.ByteSlice, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$array2_u8(value: rs.ByteSlice, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array3_u32(value: rt.u32[], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(4)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$array3_u32(value: rs.u32[], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(4)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$array3_u8(value: rt.ByteSlice, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$array3_u8(value: rs.ByteSlice, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$bool(value: boolean, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash8(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$bool(value: boolean, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash8(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$char(value: rt.char, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash32(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$char(value: rs.char, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash32(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$cmp_Ordering(value: rt.Ordering, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$cmp_Ordering(value: rs.Ordering, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$cmp_Reverse_u16(value: rt.u16, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash16(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$cmp_Reverse_u16(value: rs.u16, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash16(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$hashes_Nibble(value: Nibble.Nibble, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); +export function digest$hashes_Nibble(value: Nibble.Nibble, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); Nibble.hash$Hash_hash_DefaultHasher(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$hashes_Packet(value: Packet.Packet, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); +export function digest$hashes_Packet(value: Packet.Packet, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); Packet.hash$Hash_hash_DefaultHasher(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$hashes_Shape(value: Shape.Shape, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); +export function digest$hashes_Shape(value: Shape.Shape, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); Shape.hash$Hash_hash_DefaultHasher(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$i128(value: rt.i128, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI128(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$i128(value: rs.i128, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI128(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$i16(value: rt.i16, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI16(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$i16(value: rs.i16, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI16(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$i32(value: rt.i32, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI32(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$i32(value: rs.i32, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI32(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$i64(value: rt.i64, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI64(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$i64(value: rs.i64, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI64(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$i8(value: rt.i8, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$i8(value: rs.i8, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$isize(value: rt.isize, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashIsize(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$isize(value: rs.isize, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashIsize(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$slice_u16(value: rt.u16[], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$slice_u16(value: rs.u16[], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$slice_u8(value: rt.ByteSlice, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$slice_u8(value: rs.ByteSlice, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$str(value: string, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashStr(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$str(value: string, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashStr(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$sync_Arc_Vec_u8(value: rt.Arc, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashBytes)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$sync_Arc_Vec_u8(value: rs.Arc, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashBytes)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$sync_Arc_array3_u8(value: rt.Arc, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashBytes)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$sync_Arc_array3_u8(value: rs.Arc, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashBytes)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$sync_Arc_str(value: rt.Arc, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashStr)(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$sync_Arc_str(value: rs.Arc, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashStr)(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$time_Duration(value: rt.Duration, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.durationHash(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$time_Duration(value: rs.Duration, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.durationHash(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple2_array0_u8_Option_array0_u8(value: [Uint8Array, Uint8Array | undefined], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([rt.hashBytes, rt.hashOption(rt.hashBytes)])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple2_array0_u8_Option_array0_u8(value: [Uint8Array, Uint8Array | undefined], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([rs.hashBytes, rs.hashOption(rs.hashBytes)])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple2_array2_u8_array3_u8(value: [Uint8Array, Uint8Array], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([rt.hashBytes, rt.hashBytes])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple2_array2_u8_array3_u8(value: [Uint8Array, Uint8Array], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([rs.hashBytes, rs.hashBytes])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple2_hashes_Small_hashes_Small(value: [Small.Small, Small.Small], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([Small.hash$Hash_hash_DefaultHasher as (a0: Small.Small, a1: rt.Hasher) => undefined, Small.hash$Hash_hash_DefaultHasher as (a0: Small.Small, a1: rt.Hasher) => undefined])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple2_hashes_Small_hashes_Small(value: [Small.Small, Small.Small], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([Small.hash$Hash_hash_DefaultHasher as (a0: Small.Small, a1: rs.Hasher) => undefined, Small.hash$Hash_hash_DefaultHasher as (a0: Small.Small, a1: rs.Hasher) => undefined])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple2_ref_slice_u8_u8(value: [rt.ByteSlice, rt.u8], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([rt.hashBytes, rt.hash8])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple2_ref_slice_u8_u8(value: [rs.ByteSlice, rs.u8], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([rs.hashBytes, rs.hash8])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple2_ref_str_usize(value: [string, rt.usize], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([rt.hashStr, rt.hashUsize])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple2_ref_str_usize(value: [string, rs.usize], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([rs.hashStr, rs.hashUsize])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$tuple3_u8_ref_str_u64(value: [rt.u8, string, rt.u64], out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashTuple([rt.hash8, rt.hashStr, rt.hash64])(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$tuple3_u8_ref_str_u64(value: [rs.u8, string, rs.u64], out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashTuple([rs.hash8, rs.hashStr, rs.hash64])(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$u128(value: rt.u128, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash128(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$u128(value: rs.u128, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash128(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$u16(value: rt.u16, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash16(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$u16(value: rs.u16, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash16(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$u32(value: rt.u32, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash32(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$u32(value: rs.u32, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash32(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$u64(value: rt.u64, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash64(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$u64(value: rs.u64, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash64(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$u8(value: rt.u8, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hash8(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$u8(value: rs.u8, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hash8(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** `DefaultHasher::new`'s hash of `value`, little-endian. */ -export function digest$usize(value: rt.usize, out: rt.ByteVec): void { - const h: rt.Hasher = rt.hasher(); - rt.hashUsize(value, h); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); +export function digest$usize(value: rs.usize, out: rs.ByteVec): void { + const h: rs.Hasher = rs.hasher(); + rs.hashUsize(value, h); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } /** The bytes of `data` from `at`, as many as fit, as one big-endian number. */ -export function wide(data: rt.ByteSlice, at: rt.usize, n: rt.usize): rt.u128 { - let _10!: rt.usize; - let v: rt.u128 = 0; - const _7: rt.usize = rt.usizeAdd(at, n); - let iterStart: rt.usize = at; - const iterEnd: rt.usize = _7; +export function wide(data: rs.ByteSlice, at: rs.usize, n: rs.usize): rs.u128 { + let _10!: rs.usize; + let v: rs.u128 = 0; + const _7: rs.usize = rs.usizeAdd(at, n); + let iterStart: rs.usize = at; + const iterEnd: rs.usize = _7; while (true) { if (!((_10 = iterStart++) < iterEnd)) { return v; } - v = rt.u128Or(rt.u128Shl(v, 8), option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, _10), 0) as rt.u128); + v = rs.u128Or(rs.u128Shl(v, 8), option_unwrapOr$1fr498u(rs.byteSliceGet(data, _10), 0) as rs.u128); } } /** The hash of a value of each type `kind` picks, made of `data`. */ -export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function values(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let shape!: Shape.Shape; - const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n3: rt.usize): rt.u128 => { + const w: (a0: rs.usize, a1: rs.usize) => rs.u128 = (at: rs.usize, n3: rs.usize): rs.u128 => { return wide(data, at, n3); }; - const _5: rt.u8 = rt.u8Rem(kind, 5); + const _5: rs.u8 = rs.u8Rem(kind, 5); if (_5 === 0) { - const _9: [rt.u128, rt.u64] = [w(0, 16), rt.u64Cast(w(3, 8))]; - const a: rt.u128 = _9[0]; - const b: rt.u64 = _9[1]; - digest$u8(rt.u128Low(a) & 0xff, out); - digest$u16(rt.u128Low(a) & 0xffff, out); - digest$u32(rt.u128Low(a), out); + const _9: [rs.u128, rs.u64] = [w(0, 16), rs.u64Cast(w(3, 8))]; + const a: rs.u128 = _9[0]; + const b: rs.u64 = _9[1]; + digest$u8(rs.u128Low(a) & 0xff, out); + digest$u16(rs.u128Low(a) & 0xffff, out); + digest$u32(rs.u128Low(a), out); digest$u64(b, out); - digest$u64(rt.u64Shr(b, rt.usizeRem(data.length, 64)), out); + digest$u64(rs.u64Shr(b, rs.usizeRem(data.length, 64)), out); digest$u128(a, out); - digest$i8((rt.u128Low(a) << 24) >> 24, out); - digest$i16((rt.u128Low(a) << 16) >> 16, out); - digest$i32(rt.u128Low(a) | 0, out); - digest$i64(rt.i64Cast(b), out); - digest$i64(rt.i64Shr(rt.i64Cast(b), 11), out); - digest$i128(rt.i128Cast(a), out); - digest$i128(rt.i128Shr(rt.i128Cast(a), 70), out); - digest$usize(rt.u128Low(a), out); - digest$isize(rt.u128Low(a) | 0, out); - digest$bool(rt.u128And(a, 1) === 1, out); - digest$char(option_unwrapOr$0k15iai(rt.charFromU32((rt.u128Low(a) & 2097151) >>> 0), 1114111), out); + digest$i8((rs.u128Low(a) << 24) >> 24, out); + digest$i16((rs.u128Low(a) << 16) >> 16, out); + digest$i32(rs.u128Low(a) | 0, out); + digest$i64(rs.i64Cast(b), out); + digest$i64(rs.i64Shr(rs.i64Cast(b), 11), out); + digest$i128(rs.i128Cast(a), out); + digest$i128(rs.i128Shr(rs.i128Cast(a), 70), out); + digest$usize(rs.u128Low(a), out); + digest$isize(rs.u128Low(a) | 0, out); + digest$bool(rs.u128And(a, 1) === 1, out); + digest$char(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), out); } else if (_5 === 1) { - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é ✓ 😀"); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); digest$str(text, out); digest$String(text, out); digest$str("", out); - digest$tuple2_ref_str_usize([text, rt.stringLen(text)] as [string, rt.usize], out); - const arc: rt.Arc = new rt.Arc(text); + digest$tuple2_ref_str_usize([text, rs.stringLen(text)] as [string, rs.usize], out); + const arc: rs.Arc = new rs.Arc(text); digest$sync_Arc_str(arc, out); arc[Symbol.dispose](); } else if (_5 === 2) { - const n: rt.u32 = rt.u128Low(w(0, 4)); + const n: rs.u32 = rs.u128Low(w(0, 4)); digest$Option_u32(n, out); digest$Option_u32(undefined, out); digest$Option_Option_u8(n & 0xff, out); - digest$tuple3_u8_ref_str_u64([n & 0xff, "pair", rt.u64Cast(w(4, 8))] as [rt.u8, string, rt.u64], out); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u16 => { - return rt.u16Mul(_23 as rt.u16, 257); + digest$tuple3_u8_ref_str_u64([n & 0xff, "pair", rs.u64Cast(w(4, 8))] as [rs.u8, string, rs.u64], out); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): rs.u16 => { + return rs.u16Mul(_23 as rs.u16, 257); }), undefined, 2, true); digest$Vec_u16(words, out); - digest$slice_u16(rt.sliceRange(words.items, rt.usizeDiv(words.items.length, 2)), out); + digest$slice_u16(rs.sliceRange(words.items, rs.usizeDiv(words.items.length, 2)), out); digest$array3_u32([n, (n ^ 1) >>> 0, n >>> 3], out); - digest$cmp_Ordering(rt.cmp(n & 0xff, rt.u128Low(w(4, 1)) & 0xff), out); - digest$time_Duration(rt.durationNew(rt.u64Cast(w(0, 6)), rt.u32Rem(n, 1000000000)), out); + digest$cmp_Ordering(rs.cmp(n & 0xff, rs.u128Low(w(4, 1)) & 0xff), out); + digest$time_Duration(rs.durationNew(rs.u64Cast(w(0, 6)), rs.u32Rem(n, 1000000000)), out); digest$cmp_Reverse_u16(n & 0xffff, out); - digest$Option_num_NonZero_u32(rt.nonZero((n | 1) >>> 0), out); + digest$Option_num_NonZero_u32(rs.nonZero((n | 1) >>> 0), out); } else if (_5 === 3) { - const n2: rt.u64 = rt.u64Cast(w(0, 8)); - digest$hashes_Packet({ id: n2, flags: option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), name: result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "?"), tags: rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return _2 as rt.u16; - }), undefined, 2, true), next: thenSome$0n2gkz4(rt.u64Rem(n2, 3) !== 0, rt.u64Low(n2) | 0) }, out); - const _188: rt.u64 = rt.u64Rem(n2, 3); + const n2: rs.u64 = rs.u64Cast(w(0, 8)); + digest$hashes_Packet({ id: n2, flags: option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), name: result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "?"), tags: rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return _2 as rs.u16; + }), undefined, 2, true), next: thenSome$05ku0zn(rs.u64Rem(n2, 3) !== 0, rs.u64Low(n2) | 0) }, out); + const _188: rs.u64 = rs.u64Rem(n2, 3); if (_188 === 0) { shape = { tag: "Dot" } as Shape.Shape; } else if (_188 === 1) { - shape = { tag: "Line", _0: rt.u64Low(n2) } as Shape.Shape; + shape = { tag: "Line", _0: rs.u64Low(n2) } as Shape.Shape; } else { - shape = { tag: "Rect", w: (rt.u64Low(n2) << 16) >> 16, h: (rt.u64Low(rt.u64Shr(n2, 16)) << 16) >> 16 } as Shape.Shape; + shape = { tag: "Rect", w: (rs.u64Low(n2) << 16) >> 16, h: (rs.u64Low(rs.u64Shr(n2, 16)) << 16) >> 16 } as Shape.Shape; } digest$hashes_Shape(shape, out); digest$array2_hashes_Dir(["Up" as Dir.Dir, "Down" as Dir.Dir], out); digest$tuple2_hashes_Small_hashes_Small(["Low" as Small.Small, "High" as Small.Small], out); - digest$hashes_Nibble({ _0: rt.u64Low(n2) & 0xff }, out); + digest$hashes_Nibble({ _0: rs.u64Low(n2) & 0xff }, out); } else { - const h: rt.Hasher = rt.hasher(); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const h: rs.Hasher = rs.hasher(); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _212: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_212 === rt.DONE) { + const _212: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_212 === rs.DONE) { break; } - const i: rt.usize = _212[0]; - const b2: rt.u8 = _212[1]; - const v: rt.u128 = w(i, 16); - const _220: rt.u8 = rt.u8Rem(b2, 14); + const i: rs.usize = _212[0]; + const b2: rs.u8 = _212[1]; + const v: rs.u128 = w(i, 16); + const _220: rs.u8 = rs.u8Rem(b2, 14); if (_220 === 0) { - rt.hash8(rt.u128Low(v) & 0xff, h); + rs.hash8(rs.u128Low(v) & 0xff, h); } else if (_220 === 1) { - rt.hash16(rt.u128Low(v) & 0xffff, h); + rs.hash16(rs.u128Low(v) & 0xffff, h); } else if (_220 === 2) { - rt.hash32(rt.u128Low(v), h); + rs.hash32(rs.u128Low(v), h); } else if (_220 === 3) { - rt.hash64(rt.u64Cast(v), h); + rs.hash64(rs.u64Cast(v), h); } else if (_220 === 4) { - rt.hash128(v, h); + rs.hash128(v, h); } else if (_220 === 5) { - rt.hashUsize(rt.u128Low(v), h); + rs.hashUsize(rs.u128Low(v), h); } else if (_220 === 6) { - rt.hashI8((rt.u128Low(v) << 24) >> 24, h); + rs.hashI8((rs.u128Low(v) << 24) >> 24, h); } else if (_220 === 7) { - rt.hashI16((rt.u128Low(v) << 16) >> 16, h); + rs.hashI16((rs.u128Low(v) << 16) >> 16, h); } else if (_220 === 8) { - rt.hashI32(rt.u128Low(v) | 0, h); + rs.hashI32(rs.u128Low(v) | 0, h); } else if (_220 === 9) { - rt.hashI64(rt.i64Cast(v), h); + rs.hashI64(rs.i64Cast(v), h); } else if (_220 === 10) { - rt.hashI128(rt.i128Cast(v), h); + rs.hashI128(rs.i128Cast(v), h); } else if (_220 === 11) { - rt.hashIsize(rt.u128Low(v) | 0, h); + rs.hashIsize(rs.u128Low(v) | 0, h); } else if (_220 === 12) { - rt.hashWrite(rt.byteSliceRange(data, i), h); + rs.hashWrite(rs.byteSliceRange(data, i), h); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashFinish(h)).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashFinish(h)).reverse())); } } @@ -482,51 +482,51 @@ export function values(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * builds hash a value alike, through a reference too, and values `Hash` sees as equal * alike, so ordering by its hashes leaves the same set. `hash_one` drops what it takes. */ -export function random(data: rt.ByteSlice, out: rt.ByteVec): void { - const s: rt.RandomState = rt.randomState(); - const copy: rt.RandomState = s; +export function random(data: rs.ByteSlice, out: rs.ByteVec): void { + const s: rs.RandomState = rs.randomState(); + const copy: rs.RandomState = s; const other: Priorities$random.Priorities = Priorities$random.default$random_Default(); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - const i: rt.usize = _11[0]; - const b: rt.u8 = _11[1]; - const n: rt.u64 = rt.u64Cast(wide(data, i, 8)); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(rt.byteSliceRange(data, i)), "✓"); - const built: rt.Hasher = rt.buildHasher(s); - rt.hash64(n, built); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), n, rt.hash64), rt.hashFinish(built)) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), n, rt.hash64), rt.hashOne(rt.buildHasher(copy), n, rt.hash64)) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), n, rt.hash64), rt.hashOne(rt.buildHasher(s), n, rt.hash64)) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(other.state), text, rt.hashStr), rt.hashOne(rt.buildHasher(other.state), text, rt.hashStr)) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), [b, text] as [rt.u8, string], rt.hashTuple([rt.hash8, rt.hashStr])), rt.hashOne(rt.buildHasher(copy), [b, text] as [rt.u8, string], rt.hashTuple([rt.hash8, rt.hashStr]))) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), { _0: b }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined), rt.hashOne(rt.buildHasher(s), { _0: b ^ 240 }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rt.Hasher) => undefined)) ? 1 : 0); - const arc: rt.Arc = new rt.Arc(text); - const _84: rt.Arc = rt.arcClone(arc); - rt.byteVecPush(out, rt.u64Eq(rt.hashOne(rt.buildHasher(s), _84, rt.hashArc(rt.hashStr), rt.drop), rt.hashOne(rt.buildHasher(s), arc, rt.hashArc(rt.hashStr))) ? 1 : 0); - rt.byteVecPush(out, arc.strong & 0xff); - const drops: rt.Cell = new rt.Cell(0); + const i: rs.usize = _11[0]; + const b: rs.u8 = _11[1]; + const n: rs.u64 = rs.u64Cast(wide(data, i, 8)); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(rs.byteSliceRange(data, i)), "✓"); + const built: rs.Hasher = rs.buildHasher(s); + rs.hash64(n, built); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashFinish(built)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(copy), n, rs.hash64)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), n, rs.hash64), rs.hashOne(rs.buildHasher(s), n, rs.hash64)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr), rs.hashOne(rs.buildHasher(other.state), text, rs.hashStr)) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr])), rs.hashOne(rs.buildHasher(copy), [b, text] as [rs.u8, string], rs.hashTuple([rs.hash8, rs.hashStr]))) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), { _0: b }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined), rs.hashOne(rs.buildHasher(s), { _0: b ^ 240 }, Nibble.hash$Hash_hash_DefaultHasher as (a0: Nibble.Nibble, a1: rs.Hasher) => undefined)) ? 1 : 0); + const arc: rs.Arc = new rs.Arc(text); + const _84: rs.Arc = rs.arcClone(arc); + rs.byteVecPush(out, rs.u64Eq(rs.hashOne(rs.buildHasher(s), _84, rs.hashArc(rs.hashStr), rs.drop), rs.hashOne(rs.buildHasher(s), arc, rs.hashArc(rs.hashStr))) ? 1 : 0); + rs.byteVecPush(out, arc.strong & 0xff); + const drops: rs.Cell = new rs.Cell(0); const counted: Counted.Counted = new Counted.Counted(b, drops); - const _99: rt.u64 = rt.hashOne(rt.buildHasher(s), counted, Counted.hash$Hash_hash_DefaultHasher as (a0: Counted.Counted, a1: rt.Hasher) => undefined); + const _99: rs.u64 = rs.hashOne(rs.buildHasher(s), counted, Counted.hash$Hash_hash_DefaultHasher as (a0: Counted.Counted, a1: rs.Hasher) => undefined); const _104: Counted.Counted = new Counted.Counted(b, drops); - rt.byteVecPush(out, rt.u64Eq(_99, rt.hashOne(rt.buildHasher(s), _104, Counted.hash$Hash_hash_DefaultHasher as (a0: Counted.Counted, a1: rt.Hasher) => undefined, rt.drop)) ? 1 : 0); - rt.byteVecPush(out, drops.v); + rs.byteVecPush(out, rs.u64Eq(_99, rs.hashOne(rs.buildHasher(s), _104, Counted.hash$Hash_hash_DefaultHasher as (a0: Counted.Counted, a1: rs.Hasher) => undefined, rs.drop)) ? 1 : 0); + rs.byteVecPush(out, drops.v); counted[Symbol.dispose](); - rt.byteVecPush(out, drops.v); + rs.byteVecPush(out, drops.v); arc[Symbol.dispose](); } - const keys: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u64 => { - return rt.u64Mul(_2 as rt.u64, 1103823438081); + const keys: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u64 => { + return rs.u64Mul(_2 as rs.u64, 1103823438081); }), undefined, 8, true); - rt.sliceSort(keys.items, rt.keyLt((k2: rt.u64): rt.u64 => { - return rt.hashOne(rt.buildHasher(other.state), k2, rt.hash64); - }, rt.lt), 8, true); - rt.sliceSort(keys.items, rt.lt, 8, true); + rs.sliceSort(keys.items, rs.keyLt((k2: rs.u64): rs.u64 => { + return rs.hashOne(rs.buildHasher(other.state), k2, rs.hash64); + }, rs.lt), 8, true); + rs.sliceSort(keys.items, rs.lt, 8, true); for (const _127 of keys.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_127).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_127).reverse())); } } @@ -535,389 +535,389 @@ export function random(data: rt.ByteSlice, out: rt.ByteVec): void { * `Vec`: its length as a `usize`, then the bytes. Held in a tuple, an `Option`, and an * `Arc` too, and through `RandomState`'s `hash_one`, which hashes each form alike. */ -export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, rt.min(data.length, 5), rt.usizeStep); +export function bytes(data: rs.ByteSlice, out: rs.ByteVec): void { + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, rs.min(data.length, 5), rs.usizeStep); while (true) { - const _8: rt.usize | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: rs.usize | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } - const i: rt.usize = _8; - const s: rt.ByteSlice = rt.byteSliceRange(data, 0, i); + const i: rs.usize = _8; + const s: rs.ByteSlice = rs.byteSliceRange(data, 0, i); digest$slice_u8(s, out); - digest$Vec_u8(rt.byteSliceToByteVec(s), out); - digest$tuple2_ref_slice_u8_u8([s, i & 0xff] as [rt.ByteSlice, rt.u8], out); - digest$Option_Vec_u8(rt.byteSliceToByteVec(s), out); - const _28: rt.Arc = new rt.Arc(rt.byteSliceToByteVec(s)); + digest$Vec_u8(rs.byteSliceToByteVec(s), out); + digest$tuple2_ref_slice_u8_u8([s, i & 0xff] as [rs.ByteSlice, rs.u8], out); + digest$Option_Vec_u8(rs.byteSliceToByteVec(s), out); + const _28: rs.Arc = new rs.Arc(rs.byteSliceToByteVec(s)); digest$sync_Arc_Vec_u8(_28, out); _28[Symbol.dispose](); } - digest$array0_u8(rt.byteSliceFrom(Uint8Array.of()), out); + digest$array0_u8(rs.byteSliceFrom(Uint8Array.of()), out); digest$tuple2_array0_u8_Option_array0_u8([Uint8Array.of(), Uint8Array.of()] as [Uint8Array, Uint8Array | undefined], out); - const state: rt.RandomState = rt.randomState(); - const iter2: rt.Iter = rt.byteSliceWindows(data, 3); + const state: rs.RandomState = rs.randomState(); + const iter2: rs.Iter = rs.byteSliceWindows(data, 3); while (true) { - const _41: rt.ByteSlice | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: rs.ByteSlice | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } - rt.idx(_41, 0); - const _46: rt.u8 = _41.data[_41.start]; - rt.idx(_41, 1); - const _50: rt.u8 = _41.data[_41.start + 1]; - rt.idx(_41, 2); + rs.idx(_41, 0); + const _46: rs.u8 = _41.data[_41.start]; + rs.idx(_41, 1); + const _50: rs.u8 = _41.data[_41.start + 1]; + rs.idx(_41, 2); const a: Uint8Array = Uint8Array.of(_46, _50, _41.data[_41.start + 2]); - rt.idx(_41, 0); - const _59: rt.u8 = rt.u8Rem(_41.data[_41.start], 2); - rt.idx(_41, 1); - const pair: Uint8Array = Uint8Array.of(_59, rt.u8Rem(_41.data[_41.start + 1], 2)); - digest$array3_u8(rt.byteSliceFrom(a), out); - digest$array2_u8(rt.byteSliceFrom(pair), out); + rs.idx(_41, 0); + const _59: rs.u8 = rs.u8Rem(_41.data[_41.start], 2); + rs.idx(_41, 1); + const pair: Uint8Array = Uint8Array.of(_59, rs.u8Rem(_41.data[_41.start + 1], 2)); + digest$array3_u8(rs.byteSliceFrom(a), out); + digest$array2_u8(rs.byteSliceFrom(pair), out); digest$tuple2_array2_u8_array3_u8([pair, a] as [Uint8Array, Uint8Array], out); digest$Option_array2_u8(pair, out); - const _83: rt.Arc = new rt.Arc(a); + const _83: rs.Arc = new rs.Arc(a); digest$sync_Arc_array3_u8(_83, out); _83[Symbol.dispose](); - const _87: rt.u64 = rt.hashOne(rt.buildHasher(state), a, rt.hashBytes); - const _91: rt.ByteSlice = rt.byteSliceRange(_41, 0, 3); - rt.byteVecPush(out, rt.u64Eq(_87, rt.hashOne(rt.buildHasher(state), _91, rt.hashBytes)) ? 1 : 0); - const _98: rt.ByteSlice = rt.byteSliceFrom(a); - const _96: rt.u64 = rt.hashOne(rt.buildHasher(state), _98, rt.hashBytes); - const _101: rt.ByteVec = rt.byteSliceToByteVec(_41); - rt.byteVecPush(out, rt.u64Eq(_96, rt.hashOne(rt.buildHasher(state), _101, rt.hashBytes)) ? 1 : 0); - const _107: [Uint8Array, rt.u8] = [pair, 1]; - const _105: rt.u64 = rt.hashOne(rt.buildHasher(state), _107, rt.hashTuple([rt.hashBytes, rt.hash8])); - const _110: [rt.ByteSlice, rt.u8] = [rt.byteSliceRange(_41, 0, 2), 1]; - rt.byteVecPush(out, rt.u64Eq(_105, rt.hashOne(rt.buildHasher(state), _110, rt.hashTuple([rt.hashBytes, rt.hash8]))) ? 1 : 0); + const _87: rs.u64 = rs.hashOne(rs.buildHasher(state), a, rs.hashBytes); + const _91: rs.ByteSlice = rs.byteSliceRange(_41, 0, 3); + rs.byteVecPush(out, rs.u64Eq(_87, rs.hashOne(rs.buildHasher(state), _91, rs.hashBytes)) ? 1 : 0); + const _98: rs.ByteSlice = rs.byteSliceFrom(a); + const _96: rs.u64 = rs.hashOne(rs.buildHasher(state), _98, rs.hashBytes); + const _101: rs.ByteVec = rs.byteSliceToByteVec(_41); + rs.byteVecPush(out, rs.u64Eq(_96, rs.hashOne(rs.buildHasher(state), _101, rs.hashBytes)) ? 1 : 0); + const _107: [Uint8Array, rs.u8] = [pair, 1]; + const _105: rs.u64 = rs.hashOne(rs.buildHasher(state), _107, rs.hashTuple([rs.hashBytes, rs.hash8])); + const _110: [rs.ByteSlice, rs.u8] = [rs.byteSliceRange(_41, 0, 2), 1]; + rs.byteVecPush(out, rs.u64Eq(_105, rs.hashOne(rs.buildHasher(state), _110, rs.hashTuple([rs.hashBytes, rs.hash8]))) ? 1 : 0); } - const _116: rt.u64 = rt.hashOne(rt.buildHasher(state), Uint8Array.of(), rt.hashBytes); - const _120: rt.ByteVec = new rt.ByteVec(); - rt.byteVecPush(out, rt.u64Eq(_116, rt.hashOne(rt.buildHasher(state), _120, rt.hashBytes)) ? 1 : 0); + const _116: rs.u64 = rs.hashOne(rs.buildHasher(state), Uint8Array.of(), rs.hashBytes); + const _120: rs.ByteVec = new rs.ByteVec(); + rs.byteVecPush(out, rs.u64Eq(_116, rs.hashOne(rs.buildHasher(state), _120, rs.hashBytes)) ? 1 : 0); } /** Log a call of `tag`'s method, given `bytes`, as its tag, their count, and them. */ -export function record(log: rt.RefCell, tag: rt.u8, bytes: rt.ByteSlice): void { - const log2: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(log2.value, tag); - rt.byteVecPush(log2.value, bytes.length & 0xff); - rt.byteVecExtendFromSlice(log2.value, bytes); - rt.refMutRelease(log2); +export function record(log: rs.RefCell, tag: rs.u8, bytes: rs.ByteSlice): void { + const log2: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(log2.value, tag); + rs.byteVecPush(log2.value, bytes.length & 0xff); + rs.byteVecExtendFromSlice(log2.value, bytes); + rs.refMutRelease(log2); } /** Hash values of std's types and the crate's, made of `data`, into `h`. */ -export function hashInto$hashes_Bare(h: Bare.Bare, data: rt.ByteSlice): void { - const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n: rt.usize): rt.u128 => { +export function hashInto$hashes_Bare(h: Bare.Bare, data: rs.ByteSlice): void { + const w: (a0: rs.usize, a1: rs.usize) => rs.u128 = (at: rs.usize, n: rs.usize): rs.u128 => { return wide(data, at, n); }; - const _6: [rt.u128, rt.u64] = [w(0, 16), rt.u64Cast(w(3, 8))]; - const a: rt.u128 = _6[0]; - const b: rt.u64 = _6[1]; - rt.hash8(rt.u128Low(a) & 0xff, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash32(rt.u128Low(a), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash64(b, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash64(rt.u64Shr(b, rt.usizeRem(data.length, 64)), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash128(a, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI8((rt.u128Low(a) << 24) >> 24, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI16((rt.u128Low(a) << 16) >> 16, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI64(rt.i64Cast(b), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI64(rt.i64Shr(rt.i64Cast(b), 11), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI128(rt.i128Cast(a), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI128(rt.i128Shr(rt.i128Cast(a), 70), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashUsize(rt.u128Low(a), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashIsize(rt.u128Low(a) | 0, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash8(rt.u128And(a, 1) === 1, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash32(option_unwrapOr$0k15iai(rt.charFromU32((rt.u128Low(a) & 2097151) >>> 0), 1114111), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é ✓ 😀"); - rt.hashStr(text, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashStr(text, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashNothing(undefined, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _88: [string, rt.u8, rt.u64 | undefined] = [text, rt.u128Low(a) & 0xff, b]; - rt.hashTuple([rt.hashStr, rt.hash8, rt.hashOption(rt.hash64)])(_88, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashOption(rt.hash32)(undefined, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _95: rt.Arc = new rt.Arc(text); - rt.hashArc(rt.hashStr)(_95, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _6: [rs.u128, rs.u64] = [w(0, 16), rs.u64Cast(w(3, 8))]; + const a: rs.u128 = _6[0]; + const b: rs.u64 = _6[1]; + rs.hash8(rs.u128Low(a) & 0xff, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash32(rs.u128Low(a), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash64(b, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash64(rs.u64Shr(b, rs.usizeRem(data.length, 64)), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash128(a, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI8((rs.u128Low(a) << 24) >> 24, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI16((rs.u128Low(a) << 16) >> 16, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI64(rs.i64Cast(b), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI64(rs.i64Shr(rs.i64Cast(b), 11), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI128(rs.i128Cast(a), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI128(rs.i128Shr(rs.i128Cast(a), 70), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashUsize(rs.u128Low(a), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashIsize(rs.u128Low(a) | 0, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash8(rs.u128And(a, 1) === 1, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); + rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashStr(text, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashNothing(undefined, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; + rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashOption(rs.hash32)(undefined, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _95: rs.Arc = new rs.Arc(text); + rs.hashArc(rs.hashStr)(_95, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); _95[Symbol.dispose](); - rt.hashBytes(data, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceToByteVec(data), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceFrom(Uint8Array.of(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff)), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + rs.hashBytes(data, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceToByteVec(data), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceFrom(Uint8Array.of(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff)), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - rt.hashInts(2)(words, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _111: rt.u16[] = rt.sliceRange(words.items, rt.usizeDiv(words.items.length, 2)); - rt.hashInts(2)(_111, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _120: rt.u64[] = [b, rt.u64Shl(b, 40), rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b)]; - rt.hashInts(8)(_120, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _128: rt.i128[] = [rt.i128Cast(a), rt.i128Neg(rt.i128Cast(a))]; - rt.hashInts(16)(_128, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _135: rt.isize[] = [rt.u128Low(a) | 0, -1]; - rt.hashInts(4)(_135, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _139: boolean[] = [rt.u128And(a, 1) === 0, true]; - rt.hashSlice(rt.hash8)(_139, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashSlice(rt.hash32)([233, 120], new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _146: rt.u16[] = [rt.u128Low(a) & 0xffff, 3]; - rt.hashSlice(rt.hash16)(_146, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _152: rt.Vec<[rt.u8, string]> = rt.vecFrom([[rt.u128Low(a) & 0xff, "pair"] as [rt.u8, string], [0, ""] as [rt.u8, string]]); - rt.hashSlice(rt.hashTuple([rt.hash8, rt.hashStr]))(_152, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI8(rt.cmp(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.durationHash(rt.durationNew(b, rt.u32Rem(rt.u128Low(a), 1000000000)), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _177: rt.u32 | undefined = rt.nonZero((rt.u128Low(a) | 1) >>> 0); - rt.hashOption(rt.hash32)(_177, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _182: rt.Range = new rt.Range(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff); - rt.rangeHash(rt.hash8)(_182, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _187: rt.RangeInclusive = new rt.RangeInclusive(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff, rt.u8Step); - rt.rangeHash(rt.hash8)(_187, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - const _193: rt.u8 = rt.u128Low(a) & 0xff; + rs.hashInts(2)(words, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _111: rs.u16[] = rs.sliceRange(words.items, rs.usizeDiv(words.items.length, 2)); + rs.hashInts(2)(_111, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; + rs.hashInts(8)(_120, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; + rs.hashInts(16)(_128, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; + rs.hashInts(4)(_135, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; + rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; + rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); + rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.durationHash(rs.durationNew(b, rs.u32Rem(rs.u128Low(a), 1000000000)), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _177: rs.u32 | undefined = rs.nonZero((rs.u128Low(a) | 1) >>> 0); + rs.hashOption(rs.hash32)(_177, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _182: rs.Range = new rs.Range(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff); + rs.rangeHash(rs.hash8)(_182, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); + rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + const _193: rs.u8 = rs.u128Low(a) & 0xff; const _194: string = text; - const _195: rt.i32 | undefined = thenSome$0n2gkz4(rt.u64Rem(b, 3) !== 0, rt.u64Low(b) | 0); + const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Bare({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); - Shape.hash$Hash_hashes_Bare({ tag: "Rect", w: (rt.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rt.hashSlice(rt.hashOwn(Dir.hash$Hash_hashes_Bare as (a0: Dir.Dir, a1: Bare.Bare) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashTuple([rt.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined), rt.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - Nibble.hash$Hash_hashes_Bare({ _0: rt.u128Low(a) & 0xff }, h); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashIsize(rt.isizeNeg(rt.u128Low(a) | 0), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); - rt.hashI64(rt.i64Neg(rt.i64Cast(b)), new rt.OwnHasher(h, Bare.hasher$hash_Hasher)); + Shape.hash$Hash_hashes_Bare({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Bare as (a0: Dir.Dir, a1: Bare.Bare) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Bare as (a0: Small.Small, a1: Bare.Bare) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + Nibble.hash$Hash_hashes_Bare({ _0: rs.u128Low(a) & 0xff }, h); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashIsize(rs.isizeNeg(rs.u128Low(a) | 0), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); + rs.hashI64(rs.i64Neg(rs.i64Cast(b)), new rs.OwnHasher(h, Bare.hasher$hash_Hasher)); } /** Hash values of std's types and the crate's, made of `data`, into `h`. */ -export function hashInto$hashes_Full(h: Full.Full, data: rt.ByteSlice): void { - const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n: rt.usize): rt.u128 => { +export function hashInto$hashes_Full(h: Full.Full, data: rs.ByteSlice): void { + const w: (a0: rs.usize, a1: rs.usize) => rs.u128 = (at: rs.usize, n: rs.usize): rs.u128 => { return wide(data, at, n); }; - const _6: [rt.u128, rt.u64] = [w(0, 16), rt.u64Cast(w(3, 8))]; - const a: rt.u128 = _6[0]; - const b: rt.u64 = _6[1]; - rt.hash8(rt.u128Low(a) & 0xff, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash32(rt.u128Low(a), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash64(b, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash64(rt.u64Shr(b, rt.usizeRem(data.length, 64)), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash128(a, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI8((rt.u128Low(a) << 24) >> 24, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI16((rt.u128Low(a) << 16) >> 16, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI64(rt.i64Cast(b), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI64(rt.i64Shr(rt.i64Cast(b), 11), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI128(rt.i128Cast(a), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI128(rt.i128Shr(rt.i128Cast(a), 70), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashUsize(rt.u128Low(a), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashIsize(rt.u128Low(a) | 0, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash8(rt.u128And(a, 1) === 1, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash32(option_unwrapOr$0k15iai(rt.charFromU32((rt.u128Low(a) & 2097151) >>> 0), 1114111), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é ✓ 😀"); - rt.hashStr(text, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashStr(text, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashNothing(undefined, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _88: [string, rt.u8, rt.u64 | undefined] = [text, rt.u128Low(a) & 0xff, b]; - rt.hashTuple([rt.hashStr, rt.hash8, rt.hashOption(rt.hash64)])(_88, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashOption(rt.hash32)(undefined, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _95: rt.Arc = new rt.Arc(text); - rt.hashArc(rt.hashStr)(_95, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); + const _6: [rs.u128, rs.u64] = [w(0, 16), rs.u64Cast(w(3, 8))]; + const a: rs.u128 = _6[0]; + const b: rs.u64 = _6[1]; + rs.hash8(rs.u128Low(a) & 0xff, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash32(rs.u128Low(a), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash64(b, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash64(rs.u64Shr(b, rs.usizeRem(data.length, 64)), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash128(a, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI8((rs.u128Low(a) << 24) >> 24, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI16((rs.u128Low(a) << 16) >> 16, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI64(rs.i64Cast(b), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI64(rs.i64Shr(rs.i64Cast(b), 11), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI128(rs.i128Cast(a), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI128(rs.i128Shr(rs.i128Cast(a), 70), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashUsize(rs.u128Low(a), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashIsize(rs.u128Low(a) | 0, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash8(rs.u128And(a, 1) === 1, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); + rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashStr(text, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashNothing(undefined, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; + rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashOption(rs.hash32)(undefined, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _95: rs.Arc = new rs.Arc(text); + rs.hashArc(rs.hashStr)(_95, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); _95[Symbol.dispose](); - rt.hashBytes(data, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceToByteVec(data), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceFrom(Uint8Array.of(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff)), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + rs.hashBytes(data, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceToByteVec(data), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceFrom(Uint8Array.of(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff)), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - rt.hashInts(2)(words, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _111: rt.u16[] = rt.sliceRange(words.items, rt.usizeDiv(words.items.length, 2)); - rt.hashInts(2)(_111, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _120: rt.u64[] = [b, rt.u64Shl(b, 40), rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b)]; - rt.hashInts(8)(_120, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _128: rt.i128[] = [rt.i128Cast(a), rt.i128Neg(rt.i128Cast(a))]; - rt.hashInts(16)(_128, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _135: rt.isize[] = [rt.u128Low(a) | 0, -1]; - rt.hashInts(4)(_135, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _139: boolean[] = [rt.u128And(a, 1) === 0, true]; - rt.hashSlice(rt.hash8)(_139, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashSlice(rt.hash32)([233, 120], new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _146: rt.u16[] = [rt.u128Low(a) & 0xffff, 3]; - rt.hashSlice(rt.hash16)(_146, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _152: rt.Vec<[rt.u8, string]> = rt.vecFrom([[rt.u128Low(a) & 0xff, "pair"] as [rt.u8, string], [0, ""] as [rt.u8, string]]); - rt.hashSlice(rt.hashTuple([rt.hash8, rt.hashStr]))(_152, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashI8(rt.cmp(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.durationHash(rt.durationNew(b, rt.u32Rem(rt.u128Low(a), 1000000000)), new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _177: rt.u32 | undefined = rt.nonZero((rt.u128Low(a) | 1) >>> 0); - rt.hashOption(rt.hash32)(_177, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _182: rt.Range = new rt.Range(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff); - rt.rangeHash(rt.hash8)(_182, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _187: rt.RangeInclusive = new rt.RangeInclusive(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff, rt.u8Step); - rt.rangeHash(rt.hash8)(_187, new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - const _193: rt.u8 = rt.u128Low(a) & 0xff; + rs.hashInts(2)(words, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _111: rs.u16[] = rs.sliceRange(words.items, rs.usizeDiv(words.items.length, 2)); + rs.hashInts(2)(_111, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; + rs.hashInts(8)(_120, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; + rs.hashInts(16)(_128, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; + rs.hashInts(4)(_135, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; + rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; + rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); + rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.durationHash(rs.durationNew(b, rs.u32Rem(rs.u128Low(a), 1000000000)), new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _177: rs.u32 | undefined = rs.nonZero((rs.u128Low(a) | 1) >>> 0); + rs.hashOption(rs.hash32)(_177, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _182: rs.Range = new rs.Range(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff); + rs.rangeHash(rs.hash8)(_182, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); + rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + const _193: rs.u8 = rs.u128Low(a) & 0xff; const _194: string = text; - const _195: rt.i32 | undefined = thenSome$0n2gkz4(rt.u64Rem(b, 3) !== 0, rt.u64Low(b) | 0); + const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Full({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); - Shape.hash$Hash_hashes_Full({ tag: "Rect", w: (rt.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rt.hashSlice(rt.hashOwn(Dir.hash$Hash_hashes_Full as (a0: Dir.Dir, a1: Full.Full) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - rt.hashTuple([rt.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined), rt.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rt.OwnHasher(h, Full.hasher$hash_Hasher)); - Nibble.hash$Hash_hashes_Full({ _0: rt.u128Low(a) & 0xff }, h); - Full.writeI32$hash_Hasher(h, rt.u128Low(a) | 0); - Full.writeIsize$hash_Hasher(h, rt.isizeNeg(rt.u128Low(a) | 0)); - Full.writeI64$hash_Hasher(h, rt.i64Neg(rt.i64Cast(b))); + Shape.hash$Hash_hashes_Full({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Full as (a0: Dir.Dir, a1: Full.Full) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Full as (a0: Small.Small, a1: Full.Full) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Full.hasher$hash_Hasher)); + Nibble.hash$Hash_hashes_Full({ _0: rs.u128Low(a) & 0xff }, h); + Full.writeI32$hash_Hasher(h, rs.u128Low(a) | 0); + Full.writeIsize$hash_Hasher(h, rs.isizeNeg(rs.u128Low(a) | 0)); + Full.writeI64$hash_Hasher(h, rs.i64Neg(rs.i64Cast(b))); } /** Hash values of std's types and the crate's, made of `data`, into `h`. */ -export function hashInto$hashes_Partial(h: Partial.Partial, data: rt.ByteSlice): void { - const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n: rt.usize): rt.u128 => { +export function hashInto$hashes_Partial(h: Partial.Partial, data: rs.ByteSlice): void { + const w: (a0: rs.usize, a1: rs.usize) => rs.u128 = (at: rs.usize, n: rs.usize): rs.u128 => { return wide(data, at, n); }; - const _6: [rt.u128, rt.u64] = [w(0, 16), rt.u64Cast(w(3, 8))]; - const a: rt.u128 = _6[0]; - const b: rt.u64 = _6[1]; - rt.hash8(rt.u128Low(a) & 0xff, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash32(rt.u128Low(a), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash64(b, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash64(rt.u64Shr(b, rt.usizeRem(data.length, 64)), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash128(a, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI8((rt.u128Low(a) << 24) >> 24, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI16((rt.u128Low(a) << 16) >> 16, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI64(rt.i64Cast(b), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI64(rt.i64Shr(rt.i64Cast(b), 11), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI128(rt.i128Cast(a), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI128(rt.i128Shr(rt.i128Cast(a), 70), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashUsize(rt.u128Low(a), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashIsize(rt.u128Low(a) | 0, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash8(rt.u128And(a, 1) === 1, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash32(option_unwrapOr$0k15iai(rt.charFromU32((rt.u128Low(a) & 2097151) >>> 0), 1114111), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é ✓ 😀"); - rt.hashStr(text, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashStr(text, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashNothing(undefined, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _88: [string, rt.u8, rt.u64 | undefined] = [text, rt.u128Low(a) & 0xff, b]; - rt.hashTuple([rt.hashStr, rt.hash8, rt.hashOption(rt.hash64)])(_88, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashOption(rt.hash32)(undefined, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _95: rt.Arc = new rt.Arc(text); - rt.hashArc(rt.hashStr)(_95, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _6: [rs.u128, rs.u64] = [w(0, 16), rs.u64Cast(w(3, 8))]; + const a: rs.u128 = _6[0]; + const b: rs.u64 = _6[1]; + rs.hash8(rs.u128Low(a) & 0xff, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash32(rs.u128Low(a), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash64(b, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash64(rs.u64Shr(b, rs.usizeRem(data.length, 64)), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash128(a, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI8((rs.u128Low(a) << 24) >> 24, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI16((rs.u128Low(a) << 16) >> 16, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI64(rs.i64Cast(b), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI64(rs.i64Shr(rs.i64Cast(b), 11), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI128(rs.i128Cast(a), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI128(rs.i128Shr(rs.i128Cast(a), 70), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashUsize(rs.u128Low(a), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashIsize(rs.u128Low(a) | 0, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash8(rs.u128And(a, 1) === 1, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); + rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashStr(text, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashNothing(undefined, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; + rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashOption(rs.hash32)(undefined, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _95: rs.Arc = new rs.Arc(text); + rs.hashArc(rs.hashStr)(_95, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); _95[Symbol.dispose](); - rt.hashBytes(data, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceToByteVec(data), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceFrom(Uint8Array.of(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff)), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + rs.hashBytes(data, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceToByteVec(data), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceFrom(Uint8Array.of(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff)), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - rt.hashInts(2)(words, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _111: rt.u16[] = rt.sliceRange(words.items, rt.usizeDiv(words.items.length, 2)); - rt.hashInts(2)(_111, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _120: rt.u64[] = [b, rt.u64Shl(b, 40), rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b)]; - rt.hashInts(8)(_120, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _128: rt.i128[] = [rt.i128Cast(a), rt.i128Neg(rt.i128Cast(a))]; - rt.hashInts(16)(_128, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _135: rt.isize[] = [rt.u128Low(a) | 0, -1]; - rt.hashInts(4)(_135, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _139: boolean[] = [rt.u128And(a, 1) === 0, true]; - rt.hashSlice(rt.hash8)(_139, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashSlice(rt.hash32)([233, 120], new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _146: rt.u16[] = [rt.u128Low(a) & 0xffff, 3]; - rt.hashSlice(rt.hash16)(_146, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _152: rt.Vec<[rt.u8, string]> = rt.vecFrom([[rt.u128Low(a) & 0xff, "pair"] as [rt.u8, string], [0, ""] as [rt.u8, string]]); - rt.hashSlice(rt.hashTuple([rt.hash8, rt.hashStr]))(_152, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI8(rt.cmp(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.durationHash(rt.durationNew(b, rt.u32Rem(rt.u128Low(a), 1000000000)), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _177: rt.u32 | undefined = rt.nonZero((rt.u128Low(a) | 1) >>> 0); - rt.hashOption(rt.hash32)(_177, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _182: rt.Range = new rt.Range(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff); - rt.rangeHash(rt.hash8)(_182, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _187: rt.RangeInclusive = new rt.RangeInclusive(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff, rt.u8Step); - rt.rangeHash(rt.hash8)(_187, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - const _193: rt.u8 = rt.u128Low(a) & 0xff; + rs.hashInts(2)(words, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _111: rs.u16[] = rs.sliceRange(words.items, rs.usizeDiv(words.items.length, 2)); + rs.hashInts(2)(_111, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; + rs.hashInts(8)(_120, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; + rs.hashInts(16)(_128, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; + rs.hashInts(4)(_135, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; + rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; + rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); + rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.durationHash(rs.durationNew(b, rs.u32Rem(rs.u128Low(a), 1000000000)), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _177: rs.u32 | undefined = rs.nonZero((rs.u128Low(a) | 1) >>> 0); + rs.hashOption(rs.hash32)(_177, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _182: rs.Range = new rs.Range(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff); + rs.rangeHash(rs.hash8)(_182, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); + rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + const _193: rs.u8 = rs.u128Low(a) & 0xff; const _194: string = text; - const _195: rt.i32 | undefined = thenSome$0n2gkz4(rt.u64Rem(b, 3) !== 0, rt.u64Low(b) | 0); + const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Partial({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); - Shape.hash$Hash_hashes_Partial({ tag: "Rect", w: (rt.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rt.hashSlice(rt.hashOwn(Dir.hash$Hash_hashes_Partial as (a0: Dir.Dir, a1: Partial.Partial) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashTuple([rt.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined), rt.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - Nibble.hash$Hash_hashes_Partial({ _0: rt.u128Low(a) & 0xff }, h); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashIsize(rt.isizeNeg(rt.u128Low(a) | 0), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); - rt.hashI64(rt.i64Neg(rt.i64Cast(b)), new rt.OwnHasher(h, Partial.hasher$hash_Hasher)); + Shape.hash$Hash_hashes_Partial({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Partial as (a0: Dir.Dir, a1: Partial.Partial) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Partial as (a0: Small.Small, a1: Partial.Partial) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + Nibble.hash$Hash_hashes_Partial({ _0: rs.u128Low(a) & 0xff }, h); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashIsize(rs.isizeNeg(rs.u128Low(a) | 0), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); + rs.hashI64(rs.i64Neg(rs.i64Cast(b)), new rs.OwnHasher(h, Partial.hasher$hash_Hasher)); } /** Hash values of std's types and the crate's, made of `data`, into `h`. */ -export function hashInto$hashes_Switch(h: rt.Place, data: rt.ByteSlice): void { - const w: (a0: rt.usize, a1: rt.usize) => rt.u128 = (at: rt.usize, n: rt.usize): rt.u128 => { +export function hashInto$hashes_Switch(h: rs.Place, data: rs.ByteSlice): void { + const w: (a0: rs.usize, a1: rs.usize) => rs.u128 = (at: rs.usize, n: rs.usize): rs.u128 => { return wide(data, at, n); }; - const _6: [rt.u128, rt.u64] = [w(0, 16), rt.u64Cast(w(3, 8))]; - const a: rt.u128 = _6[0]; - const b: rt.u64 = _6[1]; - rt.hash8(rt.u128Low(a) & 0xff, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash32(rt.u128Low(a), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash64(b, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash64(rt.u64Shr(b, rt.usizeRem(data.length, 64)), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash128(a, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI8((rt.u128Low(a) << 24) >> 24, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI16((rt.u128Low(a) << 16) >> 16, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI64(rt.i64Cast(b), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI64(rt.i64Shr(rt.i64Cast(b), 11), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI128(rt.i128Cast(a), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI128(rt.i128Shr(rt.i128Cast(a), 70), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashUsize(rt.u128Low(a), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashIsize(rt.u128Low(a) | 0, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash8(rt.u128And(a, 1) === 1, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash32(option_unwrapOr$0k15iai(rt.charFromU32((rt.u128Low(a) & 2097151) >>> 0), 1114111), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é ✓ 😀"); - rt.hashStr(text, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashStr(text, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashNothing(undefined, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _88: [string, rt.u8, rt.u64 | undefined] = [text, rt.u128Low(a) & 0xff, b]; - rt.hashTuple([rt.hashStr, rt.hash8, rt.hashOption(rt.hash64)])(_88, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashOption(rt.hash32)(undefined, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _95: rt.Arc = new rt.Arc(text); - rt.hashArc(rt.hashStr)(_95, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _6: [rs.u128, rs.u64] = [w(0, 16), rs.u64Cast(w(3, 8))]; + const a: rs.u128 = _6[0]; + const b: rs.u64 = _6[1]; + rs.hash8(rs.u128Low(a) & 0xff, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash32(rs.u128Low(a), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash64(b, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash64(rs.u64Shr(b, rs.usizeRem(data.length, 64)), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash128(a, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI8((rs.u128Low(a) << 24) >> 24, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI16((rs.u128Low(a) << 16) >> 16, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI64(rs.i64Cast(b), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI64(rs.i64Shr(rs.i64Cast(b), 11), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI128(rs.i128Cast(a), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI128(rs.i128Shr(rs.i128Cast(a), 70), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashUsize(rs.u128Low(a), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashIsize(rs.u128Low(a) | 0, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash8(rs.u128And(a, 1) === 1, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash32(option_unwrapOr$04rqm9m(rs.charFromU32((rs.u128Low(a) & 2097151) >>> 0), 1114111), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é ✓ 😀"); + rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashStr(text, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashNothing(undefined, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _88: [string, rs.u8, rs.u64 | undefined] = [text, rs.u128Low(a) & 0xff, b]; + rs.hashTuple([rs.hashStr, rs.hash8, rs.hashOption(rs.hash64)])(_88, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashOption(rs.hash32)(undefined, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _95: rs.Arc = new rs.Arc(text); + rs.hashArc(rs.hashStr)(_95, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); _95[Symbol.dispose](); - rt.hashBytes(data, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceToByteVec(data), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashBytes(rt.byteSliceFrom(Uint8Array.of(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff)), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + rs.hashBytes(data, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceToByteVec(data), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashBytes(rs.byteSliceFrom(Uint8Array.of(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff)), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - rt.hashInts(2)(words, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _111: rt.u16[] = rt.sliceRange(words.items, rt.usizeDiv(words.items.length, 2)); - rt.hashInts(2)(_111, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _120: rt.u64[] = [b, rt.u64Shl(b, 40), rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b)]; - rt.hashInts(8)(_120, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _128: rt.i128[] = [rt.i128Cast(a), rt.i128Neg(rt.i128Cast(a))]; - rt.hashInts(16)(_128, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _135: rt.isize[] = [rt.u128Low(a) | 0, -1]; - rt.hashInts(4)(_135, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _139: boolean[] = [rt.u128And(a, 1) === 0, true]; - rt.hashSlice(rt.hash8)(_139, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashSlice(rt.hash32)([233, 120], new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _146: rt.u16[] = [rt.u128Low(a) & 0xffff, 3]; - rt.hashSlice(rt.hash16)(_146, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _152: rt.Vec<[rt.u8, string]> = rt.vecFrom([[rt.u128Low(a) & 0xff, "pair"] as [rt.u8, string], [0, ""] as [rt.u8, string]]); - rt.hashSlice(rt.hashTuple([rt.hash8, rt.hashStr]))(_152, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI8(rt.cmp(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.durationHash(rt.durationNew(b, rt.u32Rem(rt.u128Low(a), 1000000000)), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hash16(rt.u128Low(a) & 0xffff, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _177: rt.u32 | undefined = rt.nonZero((rt.u128Low(a) | 1) >>> 0); - rt.hashOption(rt.hash32)(_177, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _182: rt.Range = new rt.Range(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff); - rt.rangeHash(rt.hash8)(_182, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _187: rt.RangeInclusive = new rt.RangeInclusive(rt.u128Low(a) & 0xff, rt.u64Low(b) & 0xff, rt.u8Step); - rt.rangeHash(rt.hash8)(_187, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - const _193: rt.u8 = rt.u128Low(a) & 0xff; + rs.hashInts(2)(words, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _111: rs.u16[] = rs.sliceRange(words.items, rs.usizeDiv(words.items.length, 2)); + rs.hashInts(2)(_111, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _120: rs.u64[] = [b, rs.u64Shl(b, 40), rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b)]; + rs.hashInts(8)(_120, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _128: rs.i128[] = [rs.i128Cast(a), rs.i128Neg(rs.i128Cast(a))]; + rs.hashInts(16)(_128, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _135: rs.isize[] = [rs.u128Low(a) | 0, -1]; + rs.hashInts(4)(_135, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _139: boolean[] = [rs.u128And(a, 1) === 0, true]; + rs.hashSlice(rs.hash8)(_139, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashSlice(rs.hash32)([233, 120], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _146: rs.u16[] = [rs.u128Low(a) & 0xffff, 3]; + rs.hashSlice(rs.hash16)(_146, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _152: rs.Vec<[rs.u8, string]> = rs.vecFrom([[rs.u128Low(a) & 0xff, "pair"] as [rs.u8, string], [0, ""] as [rs.u8, string]]); + rs.hashSlice(rs.hashTuple([rs.hash8, rs.hashStr]))(_152, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI8(rs.cmp(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.durationHash(rs.durationNew(b, rs.u32Rem(rs.u128Low(a), 1000000000)), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hash16(rs.u128Low(a) & 0xffff, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _177: rs.u32 | undefined = rs.nonZero((rs.u128Low(a) | 1) >>> 0); + rs.hashOption(rs.hash32)(_177, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _182: rs.Range = new rs.Range(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff); + rs.rangeHash(rs.hash8)(_182, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _187: rs.RangeInclusive = new rs.RangeInclusive(rs.u128Low(a) & 0xff, rs.u64Low(b) & 0xff, rs.u8Step); + rs.rangeHash(rs.hash8)(_187, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + const _193: rs.u8 = rs.u128Low(a) & 0xff; const _194: string = text; - const _195: rt.i32 | undefined = thenSome$0n2gkz4(rt.u64Rem(b, 3) !== 0, rt.u64Low(b) | 0); + const _195: rs.i32 | undefined = thenSome$05ku0zn(rs.u64Rem(b, 3) !== 0, rs.u64Low(b) | 0); Packet.hash$Hash_hashes_Switch({ id: b, flags: _193, name: _194, tags: words, next: _195 }, h); - Shape.hash$Hash_hashes_Switch({ tag: "Rect", w: (rt.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); - rt.hashSlice(rt.hashOwn(Dir.hash$Hash_hashes_Switch as (a0: Dir.Dir, a1: rt.Place) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashTuple([rt.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rt.Place) => undefined), rt.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rt.Place) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - Nibble.hash$Hash_hashes_Switch({ _0: rt.u128Low(a) & 0xff }, h); - rt.hashI32(rt.u128Low(a) | 0, new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashIsize(rt.isizeNeg(rt.u128Low(a) | 0), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); - rt.hashI64(rt.i64Neg(rt.i64Cast(b)), new rt.OwnHasher(h, Switch.hasher$hash_Hasher)); + Shape.hash$Hash_hashes_Switch({ tag: "Rect", w: (rs.u128Low(a) << 16) >> 16, h: -1 } as Shape.Shape, h); + rs.hashSlice(rs.hashOwn(Dir.hash$Hash_hashes_Switch as (a0: Dir.Dir, a1: rs.Place) => undefined))(["Up" as Dir.Dir, "Down" as Dir.Dir], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashTuple([rs.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rs.Place) => undefined), rs.hashOwn(Small.hash$Hash_hashes_Switch as (a0: Small.Small, a1: rs.Place) => undefined)])(["Low" as Small.Small, "High" as Small.Small], new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + Nibble.hash$Hash_hashes_Switch({ _0: rs.u128Low(a) & 0xff }, h); + rs.hashI32(rs.u128Low(a) | 0, new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashIsize(rs.isizeNeg(rs.u128Low(a) | 0), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); + rs.hashI64(rs.i64Neg(rs.i64Cast(b)), new rs.OwnHasher(h, Switch.hasher$hash_Hasher)); } /** @@ -926,42 +926,42 @@ export function hashInto$hashes_Switch(h: rt.Place, data: rt.Byte * one that writes some, through which std's others write. Then `BuildHasher::hash_one` * of one, which builds its hasher, hashes, finishes, and drops the hasher, then the value. */ -export function own(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); +export function own(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const full: Full.Full = new Full.Full(log); hashInto$hashes_Full(full, data); - const finish: rt.u64 = Full.finish$hash_Hasher(full); + const finish: rs.u64 = Full.finish$hash_Hasher(full); full[Symbol.dispose](); const bare: Bare.Bare = { _0: log }; hashInto$hashes_Bare(bare, data); const partial: Partial.Partial = { _0: log }; hashInto$hashes_Partial(partial, data); const build: Build.Build = { _0: log }; - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "✓"); - const n: rt.u16 = rt.u128Low(wide(data, 0, 2)) & 0xffff; - const _29: rt.u64 = Bare.finish$hash_Hasher(bare); - const _31: rt.u64 = Partial.finish$hash_Hasher(partial); - const _33: rt.u64 = rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), n, rt.hash16, undefined, rt.drop); - const _36: rt.u64 = rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), text, rt.hashStr, undefined, rt.drop); - const _41: rt.Arc = new rt.Arc(text); - const _38: rt.u64 = rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _41, rt.hashArc(rt.hashStr), undefined, rt.drop); - const _44: [rt.u8, string] = [n & 0xff, text]; - const _42: rt.u64 = rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _44, rt.hashTuple([rt.hash8, rt.hashStr]), undefined, rt.drop); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); + const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; + const _29: rs.u64 = Bare.finish$hash_Hasher(bare); + const _31: rs.u64 = Partial.finish$hash_Hasher(partial); + const _33: rs.u64 = rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), n, rs.hash16, undefined, rs.drop); + const _36: rs.u64 = rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), text, rs.hashStr, undefined, rs.drop); + const _41: rs.Arc = new rs.Arc(text); + const _38: rs.u64 = rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _41, rs.hashArc(rs.hashStr), undefined, rs.drop); + const _44: [rs.u8, string] = [n & 0xff, text]; + const _42: rs.u64 = rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _44, rs.hashTuple([rs.hash8, rs.hashStr]), undefined, rs.drop); const _48: Logged.Logged = new Logged.Logged((n << 16) >> 16, log); - const _46: rt.u64 = rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _48, rt.hashOwn(Logged.hash$Hash_hashes_Full as (a0: Logged.Logged, a1: Full.Full) => undefined), rt.drop, rt.drop); + const _46: rs.u64 = rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _48, rs.hashOwn(Logged.hash$Hash_hashes_Full as (a0: Logged.Logged, a1: Full.Full) => undefined), rs.drop, rs.drop); const _54: Logged.Logged = new Logged.Logged(-1, log); - const hashes: rt.u64[] = [finish, _29, _31, _33, _36, _38, _42, _46, rt.hashOne(new rt.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _54, rt.hashOwn(Logged.hash$Hash_hashes_Full as (a0: Logged.Logged, a1: Full.Full) => undefined), undefined, rt.drop)]; + const hashes: rs.u64[] = [finish, _29, _31, _33, _36, _38, _42, _46, rs.hashOne(new rs.OwnHasher(Build.buildHasher$hash_BuildHasher(build), Full.hasher$hash_Hasher), _54, rs.hashOwn(Logged.hash$Hash_hashes_Full as (a0: Logged.Logged, a1: Full.Full) => undefined), undefined, rs.drop)]; _54[Symbol.dispose](); _41[Symbol.dispose](); - const iter: rt.Iter = rt.iterSlice(hashes); + const iter: rs.Iter = rs.iterSlice(hashes); while (true) { - const _58: rt.u64 | rt.Done = iter.next(); - if (_58 === rt.DONE) { + const _58: rs.u64 | rs.Done = iter.next(); + if (_58 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_58).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_58).reverse())); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log.value)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log.value)); } /** @@ -969,58 +969,58 @@ export function own(data: rt.ByteSlice, out: rt.ByteVec): void { * what it then holds: one bound to a local, one held in a field, and one * `BuildHasher::hash_one` builds of one held in the state, which drops before the value. */ -export function copied(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const n: rt.u16 = rt.u128Low(wide(data, 0, 2)) & 0xffff; +export function copied(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; let local = { tag: "Log", _0: log } as Switch.Switch; - hashInto$hashes_Switch(rt.place(() => local, (value) => local = value), data); + hashInto$hashes_Switch(rs.place(() => local, (value) => local = value), data); const holder: Holder.Holder = new Holder.Holder(n & 0xff, { tag: "Log", _0: log } as Switch.Switch); - const _17: rt.u8 = (n & 0xff) | 1; - Switch.writeU8$hash_Hasher(rt.place(() => holder.h, (value2) => holder.h = value2), _17); - rt.hash16(n, new rt.OwnHasher(rt.place(() => holder.h, (value3) => holder.h = value3), Switch.hasher$hash_Hasher)); - const _24: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); - hashInto$hashes_Switch(rt.place(() => holder.h, (value4) => holder.h = value4), _24); - const text: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "✓"); + const _17: rs.u8 = (n & 0xff) | 1; + Switch.writeU8$hash_Hasher(rs.place(() => holder.h, (value2) => holder.h = value2), _17); + rs.hash16(n, new rs.OwnHasher(rs.place(() => holder.h, (value3) => holder.h = value3), Switch.hasher$hash_Hasher)); + const _24: rs.ByteSlice = rs.byteSliceRange(data, rs.usizeDiv(data.length, 2)); + hashInto$hashes_Switch(rs.place(() => holder.h, (value4) => holder.h = value4), _24); + const text: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); const seeded: Seeded.Seeded = new Seeded.Seeded({ tag: "Log", _0: log } as Switch.Switch); - const summing: Seeded.Seeded = new Seeded.Seeded({ tag: "Sum", _0: log, _1: n as rt.u64 } as Switch.Switch); - const _40: rt.u64 = Switch.finish$hash_Hasher(local); - const _42: rt.u64 = Switch.finish$hash_Hasher(holder.h); - const _44: rt.u64 = holder.tag as rt.u64; - const _46: rt.u64 = rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), n, rt.hash16, undefined, (h2: rt.Place) => drop$hashes_Switch(h2.v)); - const _49: rt.u64 = rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), text, rt.hashStr, undefined, (h3: rt.Place) => drop$hashes_Switch(h3.v)); - const _53: [rt.u8, string] = [n & 0xff, text]; - const _51: rt.u64 = rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), _53, rt.hashTuple([rt.hash8, rt.hashStr]), undefined, (h4: rt.Place) => drop$hashes_Switch(h4.v)); + const summing: Seeded.Seeded = new Seeded.Seeded({ tag: "Sum", _0: log, _1: n as rs.u64 } as Switch.Switch); + const _40: rs.u64 = Switch.finish$hash_Hasher(local); + const _42: rs.u64 = Switch.finish$hash_Hasher(holder.h); + const _44: rs.u64 = holder.tag as rs.u64; + const _46: rs.u64 = rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), n, rs.hash16, undefined, (h2: rs.Place) => drop$hashes_Switch(h2.v)); + const _49: rs.u64 = rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), text, rs.hashStr, undefined, (h3: rs.Place) => drop$hashes_Switch(h3.v)); + const _53: [rs.u8, string] = [n & 0xff, text]; + const _51: rs.u64 = rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), _53, rs.hashTuple([rs.hash8, rs.hashStr]), undefined, (h4: rs.Place) => drop$hashes_Switch(h4.v)); const _57: Logged.Logged = new Logged.Logged((n << 16) >> 16, log); - const _55: rt.u64 = rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), _57, rt.hashOwn(Logged.hash$Hash_hashes_Switch as (a0: Logged.Logged, a1: rt.Place) => undefined), rt.drop, (h5: rt.Place) => drop$hashes_Switch(h5.v)); + const _55: rs.u64 = rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(seeded) }, Switch.hasher$hash_Hasher), _57, rs.hashOwn(Logged.hash$Hash_hashes_Switch as (a0: Logged.Logged, a1: rs.Place) => undefined), rs.drop, (h5: rs.Place) => drop$hashes_Switch(h5.v)); const _63: Logged.Logged = new Logged.Logged(-1, log); - const hashes: rt.u64[] = [_40, _42, _44, _46, _49, _51, _55, rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(summing) }, Switch.hasher$hash_Hasher), _63, rt.hashOwn(Logged.hash$Hash_hashes_Switch as (a0: Logged.Logged, a1: rt.Place) => undefined), undefined, (h6: rt.Place) => drop$hashes_Switch(h6.v)), rt.hashOne(new rt.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(summing) }, Switch.hasher$hash_Hasher), data, rt.hashBytes, undefined, (h7: rt.Place) => drop$hashes_Switch(h7.v))]; + const hashes: rs.u64[] = [_40, _42, _44, _46, _49, _51, _55, rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(summing) }, Switch.hasher$hash_Hasher), _63, rs.hashOwn(Logged.hash$Hash_hashes_Switch as (a0: Logged.Logged, a1: rs.Place) => undefined), undefined, (h6: rs.Place) => drop$hashes_Switch(h6.v)), rs.hashOne(new rs.OwnHasher({ v: Seeded.buildHasher$hash_BuildHasher(summing) }, Switch.hasher$hash_Hasher), data, rs.hashBytes, undefined, (h7: rs.Place) => drop$hashes_Switch(h7.v))]; _63[Symbol.dispose](); drop$hashes_Switch(local); holder[Symbol.dispose](); drop$tuple2_hashes_Seeded_hashes_Seeded([seeded, summing] as [Seeded.Seeded, Seeded.Seeded]); - const iter: rt.Iter = rt.iterSlice(hashes); + const iter: rs.Iter = rs.iterSlice(hashes); while (true) { - const _75: rt.u64 | rt.Done = iter.next(); - if (_75 === rt.DONE) { + const _75: rs.u64 | rs.Done = iter.next(); + if (_75 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_75).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_75).reverse())); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log.value)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log.value)); } -export const EVENTS: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(EVENTS$init, false); +export const EVENTS: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(EVENTS$init, false); -export function EVENTS$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function EVENTS$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } /** Log `what` happened to the value numbered `n`. */ -export function event(what: rt.u8, n: rt.u8): void { - ((events: rt.RefCell): undefined => { - const _52: rt.RefCell = rt.refCellBorrowMut(events); - rt.iterExtendBytes(_52.value, rt.iterSlice(Uint8Array.of(what, n)), undefined, true); - rt.refMutRelease(_52); +export function event(what: rs.u8, n: rs.u8): void { + ((events: rs.RefCell): undefined => { + const _52: rs.RefCell = rs.refCellBorrowMut(events); + rs.iterExtendBytes(_52.value, rs.iterSlice(Uint8Array.of(what, n)), undefined, true); + rs.refMutRelease(_52); })(EVENTS.get()); } @@ -1032,105 +1032,105 @@ export function event(what: rt.u8, n: rt.u8): void { * entry say what they drop or clone, and only sorted what they hold, as std's order is * its own. */ -export function maps(data: rt.ByteSlice, out: rt.ByteVec): void { - ((events: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(events); - rt.byteVecClear(_5.value); - rt.refMutRelease(_5); +export function maps(data: rs.ByteSlice, out: rs.ByteVec): void { + ((events: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(events); + rs.byteVecClear(_5.value); + rs.refMutRelease(_5); })(EVENTS.get()); - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 7); - const keyed: rt.HashMap = rt.hashWithCapacity(data.length, 58720256, rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq), new Numbered.Numbered(first)) as rt.HashMap; - const seen: rt.HashSet = rt.hashNew(undefined, new Numbered.Numbered(1)) as rt.HashSet; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 7); + const keyed: rs.HashMap = rs.hashWithCapacity(data.length, 58720256, rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq), new Numbered.Numbered(first)) as rs.HashMap; + const seen: rs.HashSet = rs.hashNew(undefined, new Numbered.Numbered(1)) as rs.HashSet; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _17: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_17 === rt.DONE) { + const _17: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_17 === rs.DONE) { break; } - const i: rt.usize = _17[0]; - const b: rt.u8 = _17[1]; - const _26: rt.u16 = rt.u8Rem(b, 8) as rt.u16; - const bounds = rt.sliceIndexBounds(new rt.RangeInclusive(i, i, rt.usizeStep), data.length); - const _25: Key.Key = { _0: _26, _1: text(rt.byteSliceRange(data, bounds[0], bounds[1])) }; - const _22: rt.Place = rt.entryOrInsertWithMut(rt.entry(keyed, _25), (): rt.u8 => { + const i: rs.usize = _17[0]; + const b: rs.u8 = _17[1]; + const _26: rs.u16 = rs.u8Rem(b, 8) as rs.u16; + const bounds = rs.sliceIndexBounds(new rs.RangeInclusive(i, i, rs.usizeStep), data.length); + const _25: Key.Key = { _0: _26, _1: text(rs.byteSliceRange(data, bounds[0], bounds[1])) }; + const _22: rs.Place = rs.entryOrInsertWithMut(rs.entry(keyed, _25), (): rs.u8 => { return 0; }); - _22.v = rt.u8Add(_22.v, 1); - rt.byteVecPush(out, rt.hashAdd(seen, rt.u8Rem(b, 16)) ? 1 : 0); - const _44: Key.Key = { _0: (rt.u8Rem(b, 8) ^ 1) as rt.u16, _1: text(rt.byteSliceFrom(Uint8Array.of(b ^ 1))) }; - rt.byteVecPush(out, rt.hashContains(keyed, _44) ? 1 : 0); + _22.v = rs.u8Add(_22.v, 1); + rs.byteVecPush(out, rs.hashAdd(seen, rs.u8Rem(b, 16)) ? 1 : 0); + const _44: Key.Key = { _0: (rs.u8Rem(b, 8) ^ 1) as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(b ^ 1))) }; + rs.byteVecPush(out, rs.hashContains(keyed, _44) ? 1 : 0); } - const held: rt.Vec<[Key.Key, rt.u8]> = rt.iterToVec(rt.hashIter(keyed), "next", 8); - rt.sliceSort(held.items, rt.cmpLt(rt.cmpTuple<[Key.Key, rt.u8], rt.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rt.cmp])), 8, true); + const held: rs.Vec<[Key.Key, rs.u8]> = rs.iterToVec(rs.hashIter(keyed), "next", 8); + rs.sliceSort(held.items, rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _63 of held.items) { - rt.byteVecPush(out, _63[0]._0 & 0xff); + rs.byteVecPush(out, _63[0]._0 & 0xff); put(out, _63[0]._1); - rt.byteVecPush(out, _63[1]); + rs.byteVecPush(out, _63[1]); } - const probe: Key.Key = { _0: first as rt.u16, _1: text(rt.byteSliceFrom(Uint8Array.of(first))) }; - rt.byteVecPush(out, (keyed.s as Numbered.Numbered)._0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(new rt.OwnHasher(Numbered.buildHasher$hash_BuildHasher(keyed.s as Numbered.Numbered), Fnv.hasher$hash_Hasher), probe, rt.hashOwn(Key.hash$Hash_hashes_Fnv as (a0: Key.Key, a1: Fnv.Fnv) => undefined))).reverse())); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(new rt.OwnHasher(Numbered.buildHasher$hash_BuildHasher(seen.s as Numbered.Numbered), Fnv.hasher$hash_Hasher), first, rt.hash8)).reverse())); - const noisy: rt.HashMap = rt.hashNew(undefined, new Numbered.Numbered(5)) as rt.HashMap; - rt.drop(rt.hashInsert(noisy, first, new Noisy.Noisy(first))); - const copy: rt.HashMap = rt.hashClone(noisy, undefined, Noisy.clone$Clone, Numbered.clone$Clone); - rt.byteVecPush(out, (copy.s as Numbered.Numbered)._0); - rt.hashDrop(noisy, undefined, rt.drop, rt.drop); - const entries: rt.Iter<[rt.u8, Noisy.Noisy]> = rt.hashIter(copy, undefined, rt.drop, rt.drop); + const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; + rs.byteVecPush(out, (keyed.s as Numbered.Numbered)._0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(new rs.OwnHasher(Numbered.buildHasher$hash_BuildHasher(keyed.s as Numbered.Numbered), Fnv.hasher$hash_Hasher), probe, rs.hashOwn(Key.hash$Hash_hashes_Fnv as (a0: Key.Key, a1: Fnv.Fnv) => undefined))).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(new rs.OwnHasher(Numbered.buildHasher$hash_BuildHasher(seen.s as Numbered.Numbered), Fnv.hasher$hash_Hasher), first, rs.hash8)).reverse())); + const noisy: rs.HashMap = rs.hashNew(undefined, new Numbered.Numbered(5)) as rs.HashMap; + rs.drop(rs.hashInsert(noisy, first, new Noisy.Noisy(first))); + const copy: rs.HashMap = rs.hashClone(noisy, undefined, Noisy.clone$Clone, Numbered.clone$Clone); + rs.byteVecPush(out, (copy.s as Numbered.Numbered)._0); + rs.hashDrop(noisy, undefined, rs.drop, rs.drop); + const entries: rs.Iter<[rs.u8, Noisy.Noisy]> = rs.hashIter(copy, undefined, rs.drop, rs.drop); event(105, 0); - drop$Option_tuple2_u8_hashes_Noisy(rt.iterToOption(entries.next())); - rt.drop(entries); - let made: rt.HashMap = rt.hashNew(undefined, Numbered.default$Default()) as rt.HashMap; - rt.drop(rt.hashInsert(made, 2, new Noisy.Noisy(2))); - const default_ = rt.hashNew(undefined, Numbered.default$Default()) as rt.HashMap; + drop$Option_tuple2_u8_hashes_Noisy(rs.iterToOption(entries.next())); + rs.drop(entries); + let made: rs.HashMap = rs.hashNew(undefined, Numbered.default$Default()) as rs.HashMap; + rs.drop(rs.hashInsert(made, 2, new Noisy.Noisy(2))); + const default_ = rs.hashNew(undefined, Numbered.default$Default()) as rs.HashMap; const taken2 = made; made = default_; - const taken: rt.HashMap = taken2; - rt.byteVecPush(out, rt.hashLen(taken) & 0xff); - rt.byteVecPush(out, rt.hashLen(made) & 0xff); - const _136: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b2: rt.u8): rt.u8 => { - return rt.u8Rem(b2, 4); + const taken: rs.HashMap = taken2; + rs.byteVecPush(out, rs.hashLen(taken) & 0xff); + rs.byteVecPush(out, rs.hashLen(made) & 0xff); + const _136: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 => { + return rs.u8Rem(b2, 4); }); - const small: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, Numbered.default$Default()) as rt.HashSet, _136, undefined, undefined, 469762048); - const union: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, Numbered.default$Default()) as rt.HashSet, rt.hashUnion(small, seen), undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashLen(union) & 0xff); - rt.byteVecPush(out, rt.hashIsSubset(small, seen) ? 1 : 0); - rt.hashExtendKeys(seen, rt.hashKeys(small, undefined, undefined, rt.drop), undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); - const keys: rt.Vec = rt.iterToVec(rt.hashKeys(keyed, undefined, undefined, rt.drop), "next", 16); - rt.sliceSort(keys.items, rt.cmpLt(Key.partialCmp$cmp_PartialOrd), 16, true); - rt.byteVecPush(out, keys.items.length & 0xff); - const iter3: rt.Iter = rt.hashValues(taken, rt.drop, undefined, rt.drop); + const small: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, Numbered.default$Default()) as rs.HashSet, _136, undefined, undefined, 469762048); + const union: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, Numbered.default$Default()) as rs.HashSet, rs.hashUnion(small, seen), undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashLen(union) & 0xff); + rs.byteVecPush(out, rs.hashIsSubset(small, seen) ? 1 : 0); + rs.hashExtendKeys(seen, rs.hashKeys(small, undefined, undefined, rs.drop), undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); + const keys: rs.Vec = rs.iterToVec(rs.hashKeys(keyed, undefined, undefined, rs.drop), "next", 16); + rs.sliceSort(keys.items, rs.cmpLt(Key.partialCmp$cmp_PartialOrd), 16, true); + rs.byteVecPush(out, keys.items.length & 0xff); + const iter3: rs.Iter = rs.hashValues(taken, rs.drop, undefined, rs.drop); while (true) { - const _169: Noisy.Noisy | rt.Done = iter3.next(); - if (_169 === rt.DONE) { + const _169: Noisy.Noisy | rs.Done = iter3.next(); + if (_169 === rs.DONE) { break; } const value: Noisy.Noisy = _169; event(118, value._0); value[Symbol.dispose](); } - rt.drop(iter3); - rt.hashDrop(union, undefined, undefined, rt.drop); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(((events2: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(events2, new rt.ByteVec()); + rs.drop(iter3); + rs.hashDrop(union, undefined, undefined, rs.drop); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(((events2: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(events2, new rs.ByteVec()); })(EVENTS.get()))); - rt.hashDrop(made, undefined, rt.drop, rt.drop); - rt.hashDrop(seen, undefined, undefined, rt.drop); + rs.hashDrop(made, undefined, rs.drop, rs.drop); + rs.hashDrop(seen, undefined, undefined, rs.drop); } -export const CALLS: rt.LocalKey>> = /* @__PURE__ */ new rt.LocalKey(CALLS$init, false); +export const CALLS: rs.LocalKey>> = /* @__PURE__ */ new rs.LocalKey(CALLS$init, false); -export function CALLS$init(): rt.RefCell> { - return new rt.RefCell(new rt.Vec()); +export function CALLS$init(): rs.RefCell> { + return new rs.RefCell(new rs.Vec()); } /** Log a call of `what` on the value of `side` holding `n`, given one of `other`. */ -export function call(what: rt.u8, side: rt.u8, other: rt.u8, n: rt.u8): void { - ((calls: rt.RefCell>): undefined => { - const _5: rt.RefCell> = rt.refCellBorrowMut(calls); +export function call(what: rs.u8, side: rs.u8, other: rs.u8, n: rs.u8): void { + ((calls: rs.RefCell>): undefined => { + const _5: rs.RefCell> = rs.refCellBorrowMut(calls); _5.value.items.push(((what << 24) | (side << 16) | (other << 8) | n) >>> 0); - rt.refMutRelease(_5); + rs.refMutRelease(_5); })(CALLS.get()); } @@ -1139,30 +1139,30 @@ export function call(what: rt.u8, side: rt.u8, other: rt.u8, n: rt.u8): void { * entry at most, else sorted if it visited every entry, else nothing, as which entries it * visits before one differs follows std's order. */ -export function compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(a: rt.HashMap, b: rt.HashMap, len: rt.usize, out: rt.ByteVec): void { - ((calls2: rt.RefCell>): undefined => { - const _5: rt.RefCell> = rt.refCellBorrowMut(calls2); - rt.vecTruncate(_5.value, 0); - rt.refMutRelease(_5); +export function compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(a: rs.HashMap, b: rs.HashMap, len: rs.usize, out: rs.ByteVec): void { + ((calls2: rs.RefCell>): undefined => { + const _5: rs.RefCell> = rs.refCellBorrowMut(calls2); + rs.vecTruncate(_5.value, 0); + rs.refMutRelease(_5); })(CALLS.get()); - const equal: boolean = rt.hashEq(Sided.eq$cmp_PartialEq)(a, b); - rt.byteVecPush(out, equal ? 1 : 0); - rt.byteVecPush(out, !rt.hashEq(Sided.eq$cmp_PartialEq)(a, b) ? 1 : 0); - const calls: rt.Vec = ((calls3: rt.RefCell>): rt.Vec => { - return rt.refCellReplace(calls3, new rt.Vec()); + const equal: boolean = rs.hashEq(Sided.eq$cmp_PartialEq)(a, b); + rs.byteVecPush(out, equal ? 1 : 0); + rs.byteVecPush(out, !rs.hashEq(Sided.eq$cmp_PartialEq)(a, b) ? 1 : 0); + const calls: rs.Vec = ((calls3: rs.RefCell>): rs.Vec => { + return rs.refCellReplace(calls3, new rs.Vec()); })(CALLS.get()); if (len > 1) { if (!equal) { - rt.vecTruncate(calls, 0); + rs.vecTruncate(calls, 0); } } - rt.vecTruncate(calls, rt.usizeDiv(calls.items.length, 2)); + rs.vecTruncate(calls, rs.usizeDiv(calls.items.length, 2)); if (len > 1) { - rt.sliceSort(calls.items, rt.lt, 4, true); + rs.sliceSort(calls.items, rs.lt, 4, true); } - rt.byteVecPush(out, calls.items.length & 0xff); + rs.byteVecPush(out, calls.items.length & 0xff); for (const _39 of calls.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_39))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_39))); } } @@ -1171,30 +1171,30 @@ export function compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Sp * entry at most, else sorted if it visited every entry, else nothing, as which entries it * visits before one differs follows std's order. */ -export function compared$collections_HashSet_hashes_Sided_hashes_Spread(a: rt.HashSet, b: rt.HashSet, len: rt.usize, out: rt.ByteVec): void { - ((calls2: rt.RefCell>): undefined => { - const _5: rt.RefCell> = rt.refCellBorrowMut(calls2); - rt.vecTruncate(_5.value, 0); - rt.refMutRelease(_5); +export function compared$collections_HashSet_hashes_Sided_hashes_Spread(a: rs.HashSet, b: rs.HashSet, len: rs.usize, out: rs.ByteVec): void { + ((calls2: rs.RefCell>): undefined => { + const _5: rs.RefCell> = rs.refCellBorrowMut(calls2); + rs.vecTruncate(_5.value, 0); + rs.refMutRelease(_5); })(CALLS.get()); - const equal: boolean = rt.hashEq()(a, b); - rt.byteVecPush(out, equal ? 1 : 0); - rt.byteVecPush(out, !rt.hashEq()(a, b) ? 1 : 0); - const calls: rt.Vec = ((calls3: rt.RefCell>): rt.Vec => { - return rt.refCellReplace(calls3, new rt.Vec()); + const equal: boolean = rs.hashEq()(a, b); + rs.byteVecPush(out, equal ? 1 : 0); + rs.byteVecPush(out, !rs.hashEq()(a, b) ? 1 : 0); + const calls: rs.Vec = ((calls3: rs.RefCell>): rs.Vec => { + return rs.refCellReplace(calls3, new rs.Vec()); })(CALLS.get()); if (len > 1) { if (!equal) { - rt.vecTruncate(calls, 0); + rs.vecTruncate(calls, 0); } } - rt.vecTruncate(calls, rt.usizeDiv(calls.items.length, 2)); + rs.vecTruncate(calls, rs.usizeDiv(calls.items.length, 2)); if (len > 1) { - rt.sliceSort(calls.items, rt.lt, 4, true); + rs.sliceSort(calls.items, rs.lt, 4, true); } - rt.byteVecPush(out, calls.items.length & 0xff); + rs.byteVecPush(out, calls.items.length & 0xff); for (const _39 of calls.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_39))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_39))); } } @@ -1207,147 +1207,147 @@ export function compared$collections_HashSet_hashes_Sided_hashes_Spread(a: rt.Ha * the last, or of one byte flipped. Then maps of a `RandomState`, which compare their keys * as JS does, and maps in a `Vec` and in a type that derives `PartialEq`. */ -export function equal(data: rt.ByteSlice, out: rt.ByteVec): void { - const _8: (a0: rt.u8, a1: rt.ByteSlice) => rt.HashSet = (side: rt.u8, bytes: rt.ByteSlice): rt.HashSet => { - const _52: Spread.Spread = { _0: side as rt.u64 }; - const s: rt.HashSet = rt.hashNew(rt.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rt.Hasher) => undefined, Sided.eq$cmp_PartialEq), _52) as rt.HashSet; - const iterS: Uint8Array = rt.byteSliceView(bytes); +export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { + const _8: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (side: rs.u8, bytes: rs.ByteSlice): rs.HashSet => { + const _52: Spread.Spread = { _0: side as rs.u64 }; + const s: rs.HashSet = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _52) as rs.HashSet; + const iterS: Uint8Array = rs.byteSliceView(bytes); let iterI: number = 0; while (true) { - const _9: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_9 === rs.DONE) { return s; } - rt.hashAdd(s, { n: _9 & 127, side }); + rs.hashAdd(s, { n: _9 & 127, side }); } }; - const _96: (a0: rt.ByteSlice) => rt.HashMap = (bytes2: rt.ByteSlice): rt.HashMap => { - const m: rt.HashMap = rt.hashNew() as rt.HashMap; - const iterS2: Uint8Array = rt.byteSliceView(bytes2); + const _96: (a0: rs.ByteSlice) => rs.HashMap = (bytes2: rs.ByteSlice): rs.HashMap => { + const m: rs.HashMap = rs.hashNew() as rs.HashMap; + const iterS2: Uint8Array = rs.byteSliceView(bytes2); let iterI2: number = 0; while (true) { - const _64: rt.u8 | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_64 === rt.DONE) { + const _64: rs.u8 | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_64 === rs.DONE) { return m; } - const b2: rt.u8 = _64; - const _102: rt.u16 = b2 as rt.u16; - const _113: rt.Place = rt.entryOrInsertWithMut(rt.entry(m, rt.u8Rem(b2, 8)), (): rt.u16 => { + const b2: rs.u8 = _64; + const _102: rs.u16 = b2 as rs.u16; + const _113: rs.Place = rs.entryOrInsertWithMut(rs.entry(m, rs.u8Rem(b2, 8)), (): rs.u16 => { return 0; }); - _113.v = rt.u16Add(_113.v, _102); + _113.v = rs.u16Add(_113.v, _102); } }; - const _123: (a0: rt.ByteSlice) => rt.HashSet = (bytes3: rt.ByteSlice): rt.HashSet => { - const _3: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes3)), (_2: rt.u8): string => { - return text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(_2, 4)))); + const _123: (a0: rs.ByteSlice) => rs.HashSet = (bytes3: rs.ByteSlice): rs.HashSet => { + const _3: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (_2: rs.u8): string => { + return text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(_2, 4)))); }); - return rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _3, undefined, undefined, 117440512); + return rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _3, undefined, undefined, 117440512); }; - const _175: (a0: rt.ByteSlice) => hashes_Index.Index = (bytes4: rt.ByteSlice): hashes_Index.Index => { - const _46: rt.Iter<[rt.u8, string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes4)), (_22: rt.u8): [rt.u8, string] => { - const b4: rt.u8 = _22; - return [rt.u8Rem(b4, 8), text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(b4, 3))))] as [rt.u8, string]; + const _175: (a0: rs.ByteSlice) => hashes_Index.Index = (bytes4: rs.ByteSlice): hashes_Index.Index => { + const _46: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_22: rs.u8): [rs.u8, string] => { + const b4: rs.u8 = _22; + return [rs.u8Rem(b4, 8), text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(b4, 3))))] as [rs.u8, string]; }); - const _33: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _46, undefined, undefined, undefined, 58720256); - const _75: rt.Iter<[rt.u8, boolean]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes4)), (_23: rt.u8): [rt.u8, boolean] => { - const b5: rt.u8 = _23; - return [rt.u8Rem(b5, 5), rt.u8Rem(b5, 2) === 0] as [rt.u8, boolean]; + const _33: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _46, undefined, undefined, undefined, 58720256); + const _75: rs.Iter<[rs.u8, boolean]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes4)), (_23: rs.u8): [rs.u8, boolean] => { + const b5: rs.u8 = _23; + return [rs.u8Rem(b5, 5), rs.u8Rem(b5, 2) === 0] as [rs.u8, boolean]; }); - return { names: _33, seen: rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same]))) as rt.HashSet<[rt.u8, boolean]>, _75, undefined, undefined, 469762048) }; + return { names: _33, seen: rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashSet<[rs.u8, boolean]>, _75, undefined, undefined, 469762048) }; }; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const map: (a0: rt.u8, a1: rt.ByteSlice) => rt.HashMap = (side2: rt.u8, bytes5: rt.ByteSlice): rt.HashMap => { - const _58: Spread.Spread = { _0: rt.u64Add(rt.u64Mul(side2 as rt.u64, 65537), first as rt.u64) }; - const m2: rt.HashMap = rt.hashNew(rt.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rt.Hasher) => undefined, Sided.eq$cmp_PartialEq), _58) as rt.HashMap; - const iterS3: Uint8Array = rt.byteSliceView(bytes5); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const map: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap = (side2: rs.u8, bytes5: rs.ByteSlice): rs.HashMap => { + const _58: Spread.Spread = { _0: rs.u64Add(rs.u64Mul(side2 as rs.u64, 65537), first as rs.u64) }; + const m2: rs.HashMap = rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), _58) as rs.HashMap; + const iterS3: Uint8Array = rs.byteSliceView(bytes5); let iterI3: number = 0; while (true) { - const _1510: rt.u8 | rt.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rt.DONE; - if (_1510 === rt.DONE) { + const _1510: rs.u8 | rs.Done = iterI3 < iterS3.length ? iterS3[iterI3++] : rs.DONE; + if (_1510 === rs.DONE) { return m2; } - const b6: rt.u8 = _1510; + const b6: rs.u8 = _1510; const _212: Sided.Sided = { n: b6 & 127, side: side2 }; - const _232: Sided.Sided = { n: b6 >> 6, side: rt.u8Add(side2, 2) }; - rt.hashInsert(m2, _212, _232); + const _232: Sided.Sided = { n: b6 >> 6, side: rs.u8Add(side2, 2) }; + rs.hashInsert(m2, _212, _232); } }; - const reversed: rt.ByteVec = rt.iterToByteVec(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), undefined, true); - const flipped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_210: [rt.usize, rt.u8]): rt.u8 => { - const i: rt.usize = _210[0]; - const b7: rt.u8 = _210[1]; - if (!(i === rt.usizeDiv(data.length, 2))) { + const reversed: rs.ByteVec = rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); + const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_210: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _210[0]; + const b7: rs.u8 = _210[1]; + if (!(i === rs.usizeDiv(data.length, 2))) { return b7; } return b7 ^ 65; }), undefined, true); - const shorter: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeSaturatingSub(data.length, 1)); - const left: rt.HashMap = map(1, data); - const part2 = rt.byteVecSlice(reversed); - const _27: rt.HashMap = map(2, part2); - const _32: rt.HashMap = map(2, data); - const _35: rt.HashMap = map(2, shorter); - const part3 = rt.byteVecSlice(flipped); - const iter: rt.Iter> = rt.iterSlice([_27, _32, _35, map(2, part3)]); + const shorter: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeSaturatingSub(data.length, 1)); + const left: rs.HashMap = map(1, data); + const part2 = rs.byteVecSlice(reversed); + const _27: rs.HashMap = map(2, part2); + const _32: rs.HashMap = map(2, data); + const _35: rs.HashMap = map(2, shorter); + const part3 = rs.byteVecSlice(flipped); + const iter: rs.Iter> = rs.iterSlice([_27, _32, _35, map(2, part3)]); while (true) { - const _44: rt.HashMap | rt.Done = iter.next(); - if (_44 === rt.DONE) { + const _44: rs.HashMap | rs.Done = iter.next(); + if (_44 === rs.DONE) { break; } - const right: rt.HashMap = _44; - const _51: rt.usize = rt.hashLen(left); + const right: rs.HashMap = _44; + const _51: rs.usize = rs.hashLen(left); compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(left, right, _51, out); - const _56: rt.usize = rt.hashLen(left); + const _56: rs.usize = rs.hashLen(left); compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(right, left, _56, out); } - const left2: rt.HashSet = _8(1, data); - const part4 = rt.byteVecSlice(reversed); - const _63: rt.HashSet = _8(2, part4); - const _68: rt.HashSet = _8(2, shorter); - const part5 = rt.byteVecSlice(flipped); - const iter2: rt.Iter> = rt.iterSlice([_63, _68, _8(2, part5)]); + const left2: rs.HashSet = _8(1, data); + const part4 = rs.byteVecSlice(reversed); + const _63: rs.HashSet = _8(2, part4); + const _68: rs.HashSet = _8(2, shorter); + const part5 = rs.byteVecSlice(flipped); + const iter2: rs.Iter> = rs.iterSlice([_63, _68, _8(2, part5)]); while (true) { - const _77: rt.HashSet | rt.Done = iter2.next(); - if (_77 === rt.DONE) { + const _77: rs.HashSet | rs.Done = iter2.next(); + if (_77 === rs.DONE) { break; } - const right2: rt.HashSet = _77; - const _84: rt.usize = rt.hashLen(left2); + const right2: rs.HashSet = _77; + const _84: rs.usize = rs.hashLen(left2); compared$collections_HashSet_hashes_Sided_hashes_Spread(left2, right2, _84, out); - const _89: rt.usize = rt.hashLen(left2); + const _89: rs.usize = rs.hashLen(left2); compared$collections_HashSet_hashes_Sided_hashes_Spread(right2, left2, _89, out); } - compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(rt.hashNew(rt.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rt.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rt.HashMap, rt.hashNew(rt.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rt.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rt.HashMap, 0, out); - const _101: rt.HashMap = _96(data); - const part6 = rt.byteVecSlice(reversed); - const _105: rt.HashMap = _96(part6); - rt.byteVecPush(out, rt.hashEq(rt.same)(_101, _105) ? 1 : 0); - const _114: rt.HashMap = _96(data); - const part7 = rt.byteVecSlice(flipped); - const _118: rt.HashMap = _96(part7); - rt.byteVecPush(out, !rt.hashEq(rt.same)(_114, _118) ? 1 : 0); - const _128: rt.HashSet = _123(data); - const part8 = rt.byteVecSlice(reversed); - const _132: rt.HashSet = _123(part8); - rt.byteVecPush(out, rt.hashEq()(_128, _132) ? 1 : 0); - const _141: rt.HashSet = _123(data); - const _145: rt.HashSet = _123(shorter); - rt.byteVecPush(out, rt.hashEq()(_141, _145) ? 1 : 0); - const _154: rt.HashSet = _123(data); - const part9 = rt.byteVecSlice(flipped); - const _152: rt.Vec> = rt.vecFrom([_154, _123(part9)]); - const part10 = rt.byteVecSlice(reversed); - const _165: rt.HashSet = _123(part10); - const part11 = rt.byteVecSlice(flipped); - const _163: rt.Vec> = rt.vecFrom([_165, _123(part11)]); - rt.byteVecPush(out, rt.eqSeq(rt.hashEq())(_152, _163) ? 1 : 0); + compared$collections_HashMap_hashes_Sided_hashes_Sided_hashes_Spread(rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rs.HashMap, rs.hashNew(rs.hashing(Sided.hash$Hash_hash_DefaultHasher as (a0: Sided.Sided, a1: rs.Hasher) => undefined, Sided.eq$cmp_PartialEq), Spread.default$Default()) as rs.HashMap, 0, out); + const _101: rs.HashMap = _96(data); + const part6 = rs.byteVecSlice(reversed); + const _105: rs.HashMap = _96(part6); + rs.byteVecPush(out, rs.hashEq(rs.same)(_101, _105) ? 1 : 0); + const _114: rs.HashMap = _96(data); + const part7 = rs.byteVecSlice(flipped); + const _118: rs.HashMap = _96(part7); + rs.byteVecPush(out, !rs.hashEq(rs.same)(_114, _118) ? 1 : 0); + const _128: rs.HashSet = _123(data); + const part8 = rs.byteVecSlice(reversed); + const _132: rs.HashSet = _123(part8); + rs.byteVecPush(out, rs.hashEq()(_128, _132) ? 1 : 0); + const _141: rs.HashSet = _123(data); + const _145: rs.HashSet = _123(shorter); + rs.byteVecPush(out, rs.hashEq()(_141, _145) ? 1 : 0); + const _154: rs.HashSet = _123(data); + const part9 = rs.byteVecSlice(flipped); + const _152: rs.Vec> = rs.vecFrom([_154, _123(part9)]); + const part10 = rs.byteVecSlice(reversed); + const _165: rs.HashSet = _123(part10); + const part11 = rs.byteVecSlice(flipped); + const _163: rs.Vec> = rs.vecFrom([_165, _123(part11)]); + rs.byteVecPush(out, rs.eqSeq(rs.hashEq())(_152, _163) ? 1 : 0); const _180: hashes_Index.Index = _175(data); - const part12 = rt.byteVecSlice(reversed); - rt.byteVecPush(out, hashes_Index.eq$cmp_PartialEq(_180, _175(part12)) ? 1 : 0); + const part12 = rs.byteVecSlice(reversed); + rs.byteVecPush(out, hashes_Index.eq$cmp_PartialEq(_180, _175(part12)) ? 1 : 0); const _193: hashes_Index.Index = _175(data); - const part13 = rt.byteVecSlice(flipped); - rt.byteVecPush(out, !hashes_Index.eq$cmp_PartialEq(_193, _175(part13)) ? 1 : 0); + const part13 = rs.byteVecSlice(flipped); + rs.byteVecPush(out, !hashes_Index.eq$cmp_PartialEq(_193, _175(part13)) ? 1 : 0); } /** @@ -1356,92 +1356,92 @@ export function equal(data: rt.ByteSlice, out: rt.ByteVec): void { * `Default`, once per hash. Then hash maps and sets that hold one, which find their keys * whatever it hashes them to, and say only sorted what they hold, as std's order is its own. */ -export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { - ((events: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(events); - rt.byteVecClear(_5.value); - rt.refMutRelease(_5); +export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { + ((events: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(events); + rs.byteVecClear(_5.value); + rs.refMutRelease(_5); })(EVENTS.get()); - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 7); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 7); Tallied.default$Default(); const held: Tallied.Tallied = { tag: first, state: undefined }; const cloned: Tallied.Tallied = Tallied.clone$Clone(held); - rt.byteVecPush(out, true ? 1 : 0); - rt.byteVecPush(out, false ? 1 : 0); - rt.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, cloned) ? 1 : 0); + rs.byteVecPush(out, true ? 1 : 0); + rs.byteVecPush(out, false ? 1 : 0); + rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, cloned) ? 1 : 0); const _36: Tallied.Tallied = Tallied.default$Default(); - rt.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, _36) ? 1 : 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "BuildHasherDefault"), (f: rt.Formatter) => rt.fmtOption(undefined, f, (_value: undefined, f: rt.Formatter) => rt.fmtWriteStr(f, "BuildHasherDefault"), rt.None), (f: rt.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rt.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", rt.fmtSpec({ alternate: true }, args2[3])])); - const word: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "✓"); - const n: rt.u16 = rt.u128Low(wide(data, 0, 2)) & 0xffff; + rs.byteVecPush(out, Tallied.eq$cmp_PartialEq(held, _36) ? 1 : 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), (f: rs.Formatter) => rs.fmtOption(undefined, f, (_value: undefined, f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault"), rs.None), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(cloned, f), (f: rs.Formatter) => Tallied.fmt$fmt_Debug(held, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", rs.fmtSpec({ alternate: true }, args2[3])])); + const word: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "✓"); + const n: rs.u16 = rs.u128Low(wide(data, 0, 2)) & 0xffff; const built: Tally.Tally = Tally.default$Default(); - rt.hash16(n, new rt.OwnHasher(built, Tally.hasher$hash_Hasher)); - const _66: rt.u64 = Tally.finish$hash_Hasher(built); - const _68: rt.u64 = rt.hashOne(new rt.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), n, rt.hash16, undefined, rt.drop); - const _70: rt.u64 = rt.hashOne(new rt.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), word, rt.hashStr, undefined, rt.drop); - const _74: [rt.u8, string] = [n & 0xff, word]; - const _72: rt.u64 = rt.hashOne(new rt.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _74, rt.hashTuple([rt.hash8, rt.hashStr]), undefined, rt.drop); + rs.hash16(n, new rs.OwnHasher(built, Tally.hasher$hash_Hasher)); + const _66: rs.u64 = Tally.finish$hash_Hasher(built); + const _68: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), n, rs.hash16, undefined, rs.drop); + const _70: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), word, rs.hashStr, undefined, rs.drop); + const _74: [rs.u8, string] = [n & 0xff, word]; + const _72: rs.u64 = rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _74, rs.hashTuple([rs.hash8, rs.hashStr]), undefined, rs.drop); const _79: Key.Key = { _0: n, _1: word }; - const hashes: rt.u64[] = [_66, _68, _70, _72, rt.hashOne(new rt.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _79, rt.hashOwn(Key.hash$Hash_hashes_Tally as (a0: Key.Key, a1: Tally.Tally) => undefined), undefined, rt.drop)]; + const hashes: rs.u64[] = [_66, _68, _70, _72, rs.hashOne(new rs.OwnHasher(Tally.default$Default(), Tally.hasher$hash_Hasher), _79, rs.hashOwn(Key.hash$Hash_hashes_Tally as (a0: Key.Key, a1: Tally.Tally) => undefined), undefined, rs.drop)]; built[Symbol.dispose](); - const iter: rt.Iter = rt.iterSlice(hashes); + const iter: rs.Iter = rs.iterSlice(hashes); while (true) { - const _85: rt.u64 | rt.Done = iter.next(); - if (_85 === rt.DONE) { + const _85: rs.u64 | rs.Done = iter.next(); + if (_85 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(_85).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(_85).reverse())); } - const keyed: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq), undefined) as rt.HashMap; - const seen: rt.HashSet = rt.hashWithCapacity(data.length, 469762048, undefined, undefined) as rt.HashSet; - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const keyed: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq), undefined) as rs.HashMap; + const seen: rs.HashSet = rs.hashWithCapacity(data.length, 469762048, undefined, undefined) as rs.HashSet; + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _101: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_101 === rt.DONE) { + const _101: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_101 === rs.DONE) { break; } - const i: rt.usize = _101[0]; - const b: rt.u8 = _101[1]; - const _110: rt.u16 = rt.u8Rem(b, 8) as rt.u16; - const bounds = rt.sliceIndexBounds(new rt.RangeInclusive(i, i, rt.usizeStep), data.length); - const _109: Key.Key = { _0: _110, _1: text(rt.byteSliceRange(data, bounds[0], bounds[1])) }; - const _106: rt.Place = rt.entryOrInsertWithMut(rt.entry(keyed, _109), (): rt.u8 => { + const i: rs.usize = _101[0]; + const b: rs.u8 = _101[1]; + const _110: rs.u16 = rs.u8Rem(b, 8) as rs.u16; + const bounds = rs.sliceIndexBounds(new rs.RangeInclusive(i, i, rs.usizeStep), data.length); + const _109: Key.Key = { _0: _110, _1: text(rs.byteSliceRange(data, bounds[0], bounds[1])) }; + const _106: rs.Place = rs.entryOrInsertWithMut(rs.entry(keyed, _109), (): rs.u8 => { return 0; }); - _106.v = rt.u8Add(_106.v, 1); - rt.byteVecPush(out, rt.hashAdd(seen, rt.u8Rem(b, 16)) ? 1 : 0); - const _128: Key.Key = { _0: (rt.u8Rem(b, 8) ^ 1) as rt.u16, _1: text(rt.byteSliceFrom(Uint8Array.of(b ^ 1))) }; - rt.byteVecPush(out, rt.hashContains(keyed, _128) ? 1 : 0); + _106.v = rs.u8Add(_106.v, 1); + rs.byteVecPush(out, rs.hashAdd(seen, rs.u8Rem(b, 16)) ? 1 : 0); + const _128: Key.Key = { _0: (rs.u8Rem(b, 8) ^ 1) as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(b ^ 1))) }; + rs.byteVecPush(out, rs.hashContains(keyed, _128) ? 1 : 0); } - const entries: rt.Vec<[Key.Key, rt.u8]> = rt.iterToVec(rt.hashIter(keyed), "next", 8); - rt.sliceSort(entries.items, rt.cmpLt(rt.cmpTuple<[Key.Key, rt.u8], rt.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rt.cmp])), 8, true); + const entries: rs.Vec<[Key.Key, rs.u8]> = rs.iterToVec(rs.hashIter(keyed), "next", 8); + rs.sliceSort(entries.items, rs.cmpLt(rs.cmpTuple<[Key.Key, rs.u8], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 8, true); for (const _147 of entries.items) { - rt.byteVecPush(out, _147[0]._0 & 0xff); + rs.byteVecPush(out, _147[0]._0 & 0xff); put(out, _147[0]._1); - rt.byteVecPush(out, _147[1]); + rs.byteVecPush(out, _147[1]); } - const probe: Key.Key = { _0: first as rt.u16, _1: text(rt.byteSliceFrom(Uint8Array.of(first))) }; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(new rt.OwnHasher(Fnv.default$Default(), Fnv.hasher$hash_Hasher), probe, rt.hashOwn(Key.hash$Hash_hashes_Fnv as (a0: Key.Key, a1: Fnv.Fnv) => undefined))).reverse())); - rt.hashClone(seen, undefined, undefined, (_a0: undefined): undefined => { + const probe: Key.Key = { _0: first as rs.u16, _1: text(rs.byteSliceFrom(Uint8Array.of(first))) }; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(new rs.OwnHasher(Fnv.default$Default(), Fnv.hasher$hash_Hasher), probe, rs.hashOwn(Key.hash$Hash_hashes_Fnv as (a0: Key.Key, a1: Fnv.Fnv) => undefined))).reverse())); + rs.hashClone(seen, undefined, undefined, (_a0: undefined): undefined => { return undefined; }).s as undefined; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(new rt.OwnHasher(Fnv.default$Default(), Fnv.hasher$hash_Hasher), first, rt.hash8)).reverse())); - rt.byteVecPush(out, true ? 1 : 0); - const _195: rt.HashMap = rt.hashClone(keyed, Key.clone$Clone, undefined, (_a02: undefined): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(new rs.OwnHasher(Fnv.default$Default(), Fnv.hasher$hash_Hasher), first, rs.hash8)).reverse())); + rs.byteVecPush(out, true ? 1 : 0); + const _195: rs.HashMap = rs.hashClone(keyed, Key.clone$Clone, undefined, (_a02: undefined): undefined => { return undefined; }); - rt.byteVecPush(out, rt.hashEq(rt.same)(keyed, _195) ? 1 : 0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "BuildHasherDefault")]; - put(out, rt.fmtFormat([args4[0]])); - const _212: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b2: rt.u8): rt.u8 => { - return rt.u8Rem(b2, 4); + rs.byteVecPush(out, rs.hashEq(rs.same)(keyed, _195) ? 1 : 0); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "BuildHasherDefault")]; + put(out, rs.fmtFormat([args4[0]])); + const _212: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): rs.u8 => { + return rs.u8Rem(b2, 4); }); - const small: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, undefined) as rt.HashSet, _212, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(undefined, undefined) as rt.HashSet, rt.hashUnion(small, seen), undefined, undefined, 469762048)) & 0xff); - rt.byteVecPush(out, rt.hashIsSubset(small, seen) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(((events2: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(events2, new rt.ByteVec()); + const small: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, undefined) as rs.HashSet, _212, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(undefined, undefined) as rs.HashSet, rs.hashUnion(small, seen), undefined, undefined, 469762048)) & 0xff); + rs.byteVecPush(out, rs.hashIsSubset(small, seen) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(((events2: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(events2, new rs.ByteVec()); })(EVENTS.get()))); } diff --git a/ts/fixtures/lang/hashes/expected/lib.ts b/ts/fixtures/lang/hashes/expected/lib.ts index a7f34c619..332702923 100644 --- a/ts/fixtures/lang/hashes/expected/lib.ts +++ b/ts/fixtures/lang/hashes/expected/lib.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { values, random, bytes, own, copied as hashes_copied, maps, equal, defaults } from "./hashes.ts"; import type * as Noisy from "./hashes.Noisy.ts"; import type * as Seeded from "./hashes.Seeded.ts"; import * as Switch from "./hashes.Switch.ts"; -export function drop$Option_tuple2_u8_hashes_Noisy(_1: [rt.u8, Noisy.Noisy] | undefined): void { +export function drop$Option_tuple2_u8_hashes_Noisy(_1: [rs.u8, Noisy.Noisy] | undefined): void { if (_1 !== undefined) { drop$tuple2_u8_hashes_Noisy(_1); } } export function drop$hashes_Switch(_1: Switch.Switch): void { - Switch.drop$ops_Drop(rt.place(() => _1, (value) => _1 = value)); + Switch.drop$ops_Drop(rs.place(() => _1, (value) => _1 = value)); } export function drop$tuple2_hashes_Seeded_hashes_Seeded(_1: [Seeded.Seeded, Seeded.Seeded]): void { @@ -21,7 +21,7 @@ export function drop$tuple2_hashes_Seeded_hashes_Seeded(_1: [Seeded.Seeded, Seed _1[1][Symbol.dispose](); } -export function drop$tuple2_u8_hashes_Noisy(_1: [rt.u8, Noisy.Noisy]): void { +export function drop$tuple2_u8_hashes_Noisy(_1: [rs.u8, Noisy.Noisy]): void { _1[1][Symbol.dispose](); } @@ -29,22 +29,22 @@ export function drop$tuple2_u8_hashes_Noisy(_1: [rt.u8, Noisy.Noisy]): void { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["hashes::values", values as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::random", (_27: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["hashes::values", values as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::random", (_27: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { random(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::bytes", (_28: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::bytes", (_28: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { bytes(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::own", (_29: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::own", (_29: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { own(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::copied", (_210: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::copied", (_210: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { hashes_copied(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::maps", (_211: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::maps", (_211: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { maps(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::equal", (_212: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::equal", (_212: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { equal(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::defaults", (_213: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hashes::defaults", (_213: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { defaults(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/heap/expected/core/bool.ts b/ts/fixtures/lang/heap/expected/core/bool.ts index f2fe3b556..e7d1e9944 100644 --- a/ts/fixtures/lang/heap/expected/core/bool.ts +++ b/ts/fixtures/lang/heap/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0j2n934(self: boolean, t: [rt.u8, rt.u16]): [rt.u8, rt.u16] | undefined { +export function thenSome$17jb8m8(self: boolean, t: [rs.u8, rs.u16]): [rs.u8, rs.u16] | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/heap/expected/core/option.ts b/ts/fixtures/lang/heap/expected/core/option.ts index e8fe34dd4..6e00070ba 100644 --- a/ts/fixtures/lang/heap/expected/core/option.ts +++ b/ts/fixtures/lang/heap/expected/core/option.ts @@ -1,41 +1,41 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Fault from "../heap.Fault.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$0hi5qhf(self: [rt.u8, rt.u16] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u16]) => rt.u8): rt.u8 { +export function mapOr$12lsao8(self: [rs.u8, rs.u16] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u16]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1qo6t0j(self: rt.u8 | undefined, default_: rt.u32, _: (a0: rt.u8) => rt.u32): rt.u32 { +export function mapOr$1diq86f(self: rs.u8 | undefined, default_: rs.u32, _: (a0: rs.u8) => rs.u32): rs.u32 { if (self === undefined) { return default_; } - return self as rt.u32; + return self as rs.u32; } -export function okOr$1rxv64q(self: rt.Place | undefined, err: Fault.Fault): rt.Result, Fault.Fault> { +export function okOr$122zmjk(self: rs.Place | undefined, err: Fault.Fault): rs.Result, Fault.Fault> { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$169x1m6(self: rt.usize | undefined, err: Fault.Fault): rt.Result { +export function okOr$0ybd6oa(self: rs.usize | undefined, err: Fault.Fault): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/heap/expected/core/result.ts b/ts/fixtures/lang/heap/expected/core/result.ts index 4e95691c7..0ffd93ad8 100644 --- a/ts/fixtures/lang/heap/expected/core/result.ts +++ b/ts/fixtures/lang/heap/expected/core/result.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Fault from "../heap.Fault.ts"; -export function mapErr$0fesv1f(self: rt.Result, op: (a0: rt.LayoutError) => Fault.Fault): rt.Result { +export function mapErr$10q8nna(self: rs.Result, op: (a0: rs.LayoutError) => Fault.Fault): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/heap/expected/harness.ts b/ts/fixtures/lang/heap/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/heap/expected/harness.ts +++ b/ts/fixtures/lang/heap/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/heap/expected/heap.Fault.ts b/ts/fixtures/lang/heap/expected/heap.Fault.ts index 4e6910d82..3232f600f 100644 --- a/ts/fixtures/lang/heap/expected/heap.Fault.ts +++ b/ts/fixtures/lang/heap/expected/heap.Fault.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Fault, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Fault, f: rs.Formatter): rs.Result { if (self.tag === "Overflow") { - return rt.fmtWriteStr(f, "Overflow"); + return rs.fmtWriteStr(f, "Overflow"); } const _6: string = "Alloc"; const _7: string = "layout"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtLayoutDebug(self.layout, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _6), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtLayoutDebug(self.layout, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _6), _7, _8)); } -export type Fault = { tag: "Overflow" } | { tag: "Alloc"; layout: rt.Layout }; +export type Fault = { tag: "Overflow" } | { tag: "Alloc"; layout: rs.Layout }; //# sourceMappingURL=heap.Fault.ts.map diff --git a/ts/fixtures/lang/heap/expected/heap.Spill.ts b/ts/fixtures/lang/heap/expected/heap.Spill.ts index a08cf48ac..99ca9a213 100644 --- a/ts/fixtures/lang/heap/expected/heap.Spill.ts +++ b/ts/fixtures/lang/heap/expected/heap.Spill.ts @@ -1,59 +1,59 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { okOr$1rxv64q as option_okOr$1rxv64q } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { okOr$122zmjk as option_okOr$122zmjk } from "./core/option.ts"; import { layoutArray$Option_tuple2_u8_u16, layoutArray$sync_Arc_u8, layoutArray$u32, deallocate$Option_tuple2_u8_u16, deallocate$sync_Arc_u8, deallocate$u32 } from "./heap.ts"; import type * as Fault from "./heap.Fault.ts"; /** A spilled vector's storage: `len` of `cap` values written into memory from `alloc`. */ export class Spill { - ptr: rt.Ptr; - cap: rt.usize; - len: rt.usize; + ptr: rs.Ptr; + cap: rs.usize; + len: rs.usize; - constructor(ptr: rt.Ptr, cap: rt.usize, len: rt.usize) { + constructor(ptr: rs.Ptr, cap: rs.usize, len: rs.usize) { this.ptr = ptr; this.cap = cap; this.len = len; } } -export function new$Option_tuple2_u8_u16(cap: rt.usize): rt.Result, Fault.Fault> { - const _2: rt.Result = layoutArray$Option_tuple2_u8_u16(cap); +export function new$Option_tuple2_u8_u16(cap: rs.usize): rs.Result, Fault.Fault> { + const _2: rs.Result = layoutArray$Option_tuple2_u8_u16(cap); if (_2.ok) { - const layout: rt.Layout = _2.value; - const pointer = rt.alloc(layout); - const _8: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _2.value; + const pointer = rs.alloc(layout); + const _8: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_8.ok) { - return rt.Ok(new Spill(rt.allocAs(_8.value, 6, "std::option::Option<(u8, u16)>"), cap, 0)); + return rs.Ok(new Spill(rs.allocAs(_8.value, 6, "std::option::Option<(u8, u16)>"), cap, 0)); } return _8; } return _2; } -export function new$sync_Arc_u8(cap: rt.usize): rt.Result>, Fault.Fault> { - const _2: rt.Result = layoutArray$sync_Arc_u8(cap); +export function new$sync_Arc_u8(cap: rs.usize): rs.Result>, Fault.Fault> { + const _2: rs.Result = layoutArray$sync_Arc_u8(cap); if (_2.ok) { - const layout: rt.Layout = _2.value; - const pointer = rt.alloc(layout); - const _8: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _2.value; + const pointer = rs.alloc(layout); + const _8: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_8.ok) { - return rt.Ok(new Spill(rt.allocAs(_8.value, 4, "std::sync::Arc"), cap, 0)); + return rs.Ok(new Spill(rs.allocAs(_8.value, 4, "std::sync::Arc"), cap, 0)); } return _8; } return _2; } -export function new$u32(cap: rt.usize): rt.Result, Fault.Fault> { - const _2: rt.Result = layoutArray$u32(cap); +export function new$u32(cap: rs.usize): rs.Result, Fault.Fault> { + const _2: rs.Result = layoutArray$u32(cap); if (_2.ok) { - const layout: rt.Layout = _2.value; - const pointer = rt.alloc(layout); - const _8: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _2.value; + const pointer = rs.alloc(layout); + const _8: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_8.ok) { - return rt.Ok(new Spill(rt.allocAs(_8.value, 4, "u32"), cap, 0)); + return rs.Ok(new Spill(rs.allocAs(_8.value, 4, "u32"), cap, 0)); } return _8; } @@ -61,23 +61,23 @@ export function new$u32(cap: rt.usize): rt.Result, Fault.Fault> { } /** Grows or shrinks to `cap`, dropping what no longer fits. */ -export function resize$Option_tuple2_u8_u16(self: Spill<[rt.u8, rt.u16] | undefined>, cap: rt.usize): rt.Result { +export function resize$Option_tuple2_u8_u16(self: Spill<[rs.u8, rs.u16] | undefined>, cap: rs.usize): rs.Result { while (self.len > cap) { - self.len = rt.usizeSub(self.len, 1); - rt.ptrAdd(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, self.len); + self.len = rs.usizeSub(self.len, 1); + rs.ptrAdd(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, self.len); } - const _11: rt.Result = layoutArray$Option_tuple2_u8_u16(self.cap); + const _11: rs.Result = layoutArray$Option_tuple2_u8_u16(self.cap); if (_11.ok) { - const _18: rt.Result = layoutArray$Option_tuple2_u8_u16(cap); + const _18: rs.Result = layoutArray$Option_tuple2_u8_u16(cap); if (_18.ok) { - const layout: rt.Layout = _18.value; - const pointer = rt.realloc(rt.allocBytes(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, 6, "std::option::Option<(u8, u16)>"), layout.size); - const _30: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _18.value; + const pointer = rs.realloc(rs.allocBytes(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, 6, "std::option::Option<(u8, u16)>"), layout.size); + const _30: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_30.ok) { - const _29: rt.Place<[rt.u8, rt.u16] | undefined> = rt.allocAs(_30.value, 6, "std::option::Option<(u8, u16)>"); - (self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>) = _29; + const _29: rs.Place<[rs.u8, rs.u16] | undefined> = rs.allocAs(_30.value, 6, "std::option::Option<(u8, u16)>"); + (self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>) = _29; self.cap = cap; - return rt.OK; + return rs.OK; } return _30; } @@ -87,23 +87,23 @@ export function resize$Option_tuple2_u8_u16(self: Spill<[rt.u8, rt.u16] | undefi } /** Grows or shrinks to `cap`, dropping what no longer fits. */ -export function resize$sync_Arc_u8(self: Spill>, cap: rt.usize): rt.Result { +export function resize$sync_Arc_u8(self: Spill>, cap: rs.usize): rs.Result { while (self.len > cap) { - self.len = rt.usizeSub(self.len, 1); - rt.ptrAdd(self.ptr as rt.Place>, self.len).v[Symbol.dispose](); + self.len = rs.usizeSub(self.len, 1); + rs.ptrAdd(self.ptr as rs.Place>, self.len).v[Symbol.dispose](); } - const _11: rt.Result = layoutArray$sync_Arc_u8(self.cap); + const _11: rs.Result = layoutArray$sync_Arc_u8(self.cap); if (_11.ok) { - const _18: rt.Result = layoutArray$sync_Arc_u8(cap); + const _18: rs.Result = layoutArray$sync_Arc_u8(cap); if (_18.ok) { - const layout: rt.Layout = _18.value; - const pointer = rt.realloc(rt.allocBytes(self.ptr as rt.Place>, 4, "std::sync::Arc"), layout.size); - const _30: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _18.value; + const pointer = rs.realloc(rs.allocBytes(self.ptr as rs.Place>, 4, "std::sync::Arc"), layout.size); + const _30: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_30.ok) { - const _29: rt.Place> = rt.allocAs(_30.value, 4, "std::sync::Arc"); - (self.ptr as rt.Place>) = _29; + const _29: rs.Place> = rs.allocAs(_30.value, 4, "std::sync::Arc"); + (self.ptr as rs.Place>) = _29; self.cap = cap; - return rt.OK; + return rs.OK; } return _30; } @@ -113,23 +113,23 @@ export function resize$sync_Arc_u8(self: Spill>, cap: rt.usize): r } /** Grows or shrinks to `cap`, dropping what no longer fits. */ -export function resize$u32(self: Spill, cap: rt.usize): rt.Result { +export function resize$u32(self: Spill, cap: rs.usize): rs.Result { while (self.len > cap) { - self.len = rt.usizeSub(self.len, 1); - rt.ptrAdd(self.ptr as rt.Place, self.len); + self.len = rs.usizeSub(self.len, 1); + rs.ptrAdd(self.ptr as rs.Place, self.len); } - const _11: rt.Result = layoutArray$u32(self.cap); + const _11: rs.Result = layoutArray$u32(self.cap); if (_11.ok) { - const _18: rt.Result = layoutArray$u32(cap); + const _18: rs.Result = layoutArray$u32(cap); if (_18.ok) { - const layout: rt.Layout = _18.value; - const pointer = rt.realloc(rt.allocBytes(self.ptr as rt.Place, 4, "u32"), layout.size); - const _30: rt.Result, Fault.Fault> = option_okOr$1rxv64q(pointer === rt.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); + const layout: rs.Layout = _18.value; + const pointer = rs.realloc(rs.allocBytes(self.ptr as rs.Place, 4, "u32"), layout.size); + const _30: rs.Result, Fault.Fault> = option_okOr$122zmjk(pointer === rs.NULL ? undefined : pointer, { tag: "Alloc", layout } as Fault.Fault); if (_30.ok) { - const _29: rt.Place = rt.allocAs(_30.value, 4, "u32"); - (self.ptr as rt.Place) = _29; + const _29: rs.Place = rs.allocAs(_30.value, 4, "u32"); + (self.ptr as rs.Place) = _29; self.cap = cap; - return rt.OK; + return rs.OK; } return _30; } @@ -138,64 +138,64 @@ export function resize$u32(self: Spill, cap: rt.usize): rt.Result, value: [rt.u8, rt.u16] | undefined): rt.Result { +export function push$Option_tuple2_u8_u16(self: Spill<[rs.u8, rs.u16] | undefined>, value: [rs.u8, rs.u16] | undefined): rs.Result { if (self.len === self.cap) { - const _6: rt.Result = resize$Option_tuple2_u8_u16(self, rt.usizeAdd(rt.usizeMul(self.cap, 2), 1)); + const _6: rs.Result = resize$Option_tuple2_u8_u16(self, rs.usizeAdd(rs.usizeMul(self.cap, 2), 1)); if (!_6.ok) { return _6; } } - rt.ptrAdd(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, self.len).v = value; - self.len = rt.usizeAdd(self.len, 1); - return rt.OK; + rs.ptrAdd(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, self.len).v = value; + self.len = rs.usizeAdd(self.len, 1); + return rs.OK; } -export function push$sync_Arc_u8(self: Spill>, value: rt.Arc): rt.Result { +export function push$sync_Arc_u8(self: Spill>, value: rs.Arc): rs.Result { if (self.len === self.cap) { - const _6: rt.Result = resize$sync_Arc_u8(self, rt.usizeAdd(rt.usizeMul(self.cap, 2), 1)); + const _6: rs.Result = resize$sync_Arc_u8(self, rs.usizeAdd(rs.usizeMul(self.cap, 2), 1)); if (!_6.ok) { value[Symbol.dispose](); return _6; } } - rt.ptrAdd(self.ptr as rt.Place>, self.len).v = value; - self.len = rt.usizeAdd(self.len, 1); - return rt.OK; + rs.ptrAdd(self.ptr as rs.Place>, self.len).v = value; + self.len = rs.usizeAdd(self.len, 1); + return rs.OK; } -export function push$u32(self: Spill, value: rt.u32): rt.Result { +export function push$u32(self: Spill, value: rs.u32): rs.Result { if (self.len === self.cap) { - const _6: rt.Result = resize$u32(self, rt.usizeAdd(rt.usizeMul(self.cap, 2), 1)); + const _6: rs.Result = resize$u32(self, rs.usizeAdd(rs.usizeMul(self.cap, 2), 1)); if (!_6.ok) { return _6; } } - rt.ptrAdd(self.ptr as rt.Place, self.len).v = value; - self.len = rt.usizeAdd(self.len, 1); - return rt.OK; + rs.ptrAdd(self.ptr as rs.Place, self.len).v = value; + self.len = rs.usizeAdd(self.len, 1); + return rs.OK; } -export function asSlice$Option_tuple2_u8_u16(self: Spill<[rt.u8, rt.u16] | undefined>): Array<[rt.u8, rt.u16] | undefined> { - return rt.ptrSlice(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, self.len); +export function asSlice$Option_tuple2_u8_u16(self: Spill<[rs.u8, rs.u16] | undefined>): Array<[rs.u8, rs.u16] | undefined> { + return rs.ptrSlice(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, self.len); } -export function asSlice$u32(self: Spill): rt.u32[] { - return rt.ptrSlice(self.ptr as rt.Place, self.len); +export function asSlice$u32(self: Spill): rs.u32[] { + return rs.ptrSlice(self.ptr as rs.Place, self.len); } -export function drop$ops_Drop_Option_tuple2_u8_u16(self: Spill<[rt.u8, rt.u16] | undefined>): void { - new rt.RawSlice(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, self.len); - deallocate$Option_tuple2_u8_u16(self.ptr as rt.Place<[rt.u8, rt.u16] | undefined>, self.cap); +export function drop$ops_Drop_Option_tuple2_u8_u16(self: Spill<[rs.u8, rs.u16] | undefined>): void { + new rs.RawSlice(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, self.len); + deallocate$Option_tuple2_u8_u16(self.ptr as rs.Place<[rs.u8, rs.u16] | undefined>, self.cap); } -export function drop$ops_Drop_sync_Arc_u8(self: Spill>): void { - rt.dropAll(new rt.RawSlice(self.ptr as rt.Place>, self.len).deref()); - deallocate$sync_Arc_u8(self.ptr as rt.Place>, self.cap); +export function drop$ops_Drop_sync_Arc_u8(self: Spill>): void { + rs.dropAll(new rs.RawSlice(self.ptr as rs.Place>, self.len).deref()); + deallocate$sync_Arc_u8(self.ptr as rs.Place>, self.cap); } -export function drop$ops_Drop_u32(self: Spill): void { - new rt.RawSlice(self.ptr as rt.Place, self.len); - deallocate$u32(self.ptr as rt.Place, self.cap); +export function drop$ops_Drop_u32(self: Spill): void { + new rs.RawSlice(self.ptr as rs.Place, self.len); + deallocate$u32(self.ptr as rs.Place, self.cap); } //# sourceMappingURL=heap.Spill.ts.map diff --git a/ts/fixtures/lang/heap/expected/heap.ts b/ts/fixtures/lang/heap/expected/heap.ts index 33530a09d..06bf1e31a 100644 --- a/ts/fixtures/lang/heap/expected/heap.ts +++ b/ts/fixtures/lang/heap/expected/heap.ts @@ -1,95 +1,95 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$heap_Spill_Option_tuple2_u8_u16, drop$heap_Spill_sync_Arc_u8, drop$heap_Spill_u32 } from "./lib.ts"; -import { thenSome$0j2n934 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$0hi5qhf as option_mapOr$0hi5qhf, mapOr$1qo6t0j as option_mapOr$1qo6t0j, okOr$169x1m6 as option_okOr$169x1m6 } from "./core/option.ts"; -import { mapErr$0fesv1f as result_mapErr$0fesv1f } from "./core/result.ts"; +import { thenSome$17jb8m8 } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$12lsao8 as option_mapOr$12lsao8, mapOr$1diq86f as option_mapOr$1diq86f, okOr$0ybd6oa as option_okOr$0ybd6oa } from "./core/option.ts"; +import { mapErr$10q8nna as result_mapErr$10q8nna } from "./core/result.ts"; import * as Fault from "./heap.Fault.ts"; import * as Spill from "./heap.Spill.ts"; -export function layoutArray$Option_tuple2_u8_u16(n: rt.usize): rt.Result { - const _2: rt.Result = option_okOr$169x1m6(rt.usizeCheckedMul(6, n), { tag: "Overflow" } as Fault.Fault); +export function layoutArray$Option_tuple2_u8_u16(n: rs.usize): rs.Result { + const _2: rs.Result = option_okOr$0ybd6oa(rs.usizeCheckedMul(6, n), { tag: "Overflow" } as Fault.Fault); if (_2.ok) { - return result_mapErr$0fesv1f(rt.layoutFromSizeAlign(_2.value, 2), (_22: rt.LayoutError): Fault.Fault => { + return result_mapErr$10q8nna(rs.layoutFromSizeAlign(_2.value, 2), (_22: rs.LayoutError): Fault.Fault => { return { tag: "Overflow" } as Fault.Fault; }); } return _2; } -export function layoutArray$sync_Arc_u8(n: rt.usize): rt.Result { - const _2: rt.Result = option_okOr$169x1m6(rt.usizeCheckedMul(4, n), { tag: "Overflow" } as Fault.Fault); +export function layoutArray$sync_Arc_u8(n: rs.usize): rs.Result { + const _2: rs.Result = option_okOr$0ybd6oa(rs.usizeCheckedMul(4, n), { tag: "Overflow" } as Fault.Fault); if (_2.ok) { - return result_mapErr$0fesv1f(rt.layoutFromSizeAlign(_2.value, 4), (_22: rt.LayoutError): Fault.Fault => { + return result_mapErr$10q8nna(rs.layoutFromSizeAlign(_2.value, 4), (_22: rs.LayoutError): Fault.Fault => { return { tag: "Overflow" } as Fault.Fault; }); } return _2; } -export function layoutArray$u32(n: rt.usize): rt.Result { - const _2: rt.Result = option_okOr$169x1m6(rt.usizeCheckedMul(4, n), { tag: "Overflow" } as Fault.Fault); +export function layoutArray$u32(n: rs.usize): rs.Result { + const _2: rs.Result = option_okOr$0ybd6oa(rs.usizeCheckedMul(4, n), { tag: "Overflow" } as Fault.Fault); if (_2.ok) { - return result_mapErr$0fesv1f(rt.layoutFromSizeAlign(_2.value, 4), (_22: rt.LayoutError): Fault.Fault => { + return result_mapErr$10q8nna(rs.layoutFromSizeAlign(_2.value, 4), (_22: rs.LayoutError): Fault.Fault => { return { tag: "Overflow" } as Fault.Fault; }); } return _2; } -export function deallocate$Option_tuple2_u8_u16(ptr: rt.Place<[rt.u8, rt.u16] | undefined>, cap: rt.usize): void { - rt.resultUnwrap(layoutArray$Option_tuple2_u8_u16(cap), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - rt.dealloc(rt.allocBytes(ptr, 6, "std::option::Option<(u8, u16)>")); +export function deallocate$Option_tuple2_u8_u16(ptr: rs.Place<[rs.u8, rs.u16] | undefined>, cap: rs.usize): void { + rs.resultUnwrap(layoutArray$Option_tuple2_u8_u16(cap), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + rs.dealloc(rs.allocBytes(ptr, 6, "std::option::Option<(u8, u16)>")); } -export function deallocate$sync_Arc_u8(ptr: rt.Place>, cap: rt.usize): void { - rt.resultUnwrap(layoutArray$sync_Arc_u8(cap), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - rt.dealloc(rt.allocBytes(ptr, 4, "std::sync::Arc")); +export function deallocate$sync_Arc_u8(ptr: rs.Place>, cap: rs.usize): void { + rs.resultUnwrap(layoutArray$sync_Arc_u8(cap), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + rs.dealloc(rs.allocBytes(ptr, 4, "std::sync::Arc")); } -export function deallocate$u32(ptr: rt.Place, cap: rt.usize): void { - rt.resultUnwrap(layoutArray$u32(cap), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - rt.dealloc(rt.allocBytes(ptr, 4, "u32")); +export function deallocate$u32(ptr: rs.Place, cap: rs.usize): void { + rs.resultUnwrap(layoutArray$u32(cap), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + rs.dealloc(rs.allocBytes(ptr, 4, "u32")); } /** * Values pushed into, and kept or dropped by resizing, storage of `u32`s, of `Arc`s, * whose strong counts show each drop, and of `Option` pairs. */ -export function spills(data: rt.ByteSlice, out: rt.ByteVec): void { - const shared: rt.Arc = new rt.Arc(7); - const ints: Spill.Spill = rt.resultUnwrap(Spill.new$u32(1), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - const arcs: Spill.Spill> = rt.resultUnwrap(Spill.new$sync_Arc_u8(2), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - const pairs: Spill.Spill<[rt.u8, rt.u16] | undefined> = rt.resultUnwrap(Spill.new$Option_tuple2_u8_u16(1), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - for (const b of rt.byteSliceView(data)) { - const _17: rt.u8 = rt.u8Rem(b, 4); +export function spills(data: rs.ByteSlice, out: rs.ByteVec): void { + const shared: rs.Arc = new rs.Arc(7); + const ints: Spill.Spill = rs.resultUnwrap(Spill.new$u32(1), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + const arcs: Spill.Spill> = rs.resultUnwrap(Spill.new$sync_Arc_u8(2), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + const pairs: Spill.Spill<[rs.u8, rs.u16] | undefined> = rs.resultUnwrap(Spill.new$Option_tuple2_u8_u16(1), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + for (const b of rs.byteSliceView(data)) { + const _17: rs.u8 = rs.u8Rem(b, 4); if (_17 === 0) { - rt.resultUnwrap(Spill.push$u32(ints, rt.u32Mul(b as rt.u32, 1000)), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); + rs.resultUnwrap(Spill.push$u32(ints, rs.u32Mul(b as rs.u32, 1000)), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); } else if (_17 === 1) { - const _26: rt.Arc = rt.arcClone(shared); - rt.resultUnwrap(Spill.push$sync_Arc_u8(arcs, _26), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); + const _26: rs.Arc = rs.arcClone(shared); + rs.resultUnwrap(Spill.push$sync_Arc_u8(arcs, _26), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); } else if (_17 === 2) { - const _30: [rt.u8, rt.u16] | undefined = thenSome$0j2n934((b & 8) !== 0, [b, ((b as rt.u16) << 4) & 0xffff] as [rt.u8, rt.u16]); - rt.resultUnwrap(Spill.push$Option_tuple2_u8_u16(pairs, _30), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); + const _30: [rs.u8, rs.u16] | undefined = thenSome$17jb8m8((b & 8) !== 0, [b, ((b as rs.u16) << 4) & 0xffff] as [rs.u8, rs.u16]); + rs.resultUnwrap(Spill.push$Option_tuple2_u8_u16(pairs, _30), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); } else { - const cap: rt.usize = rt.usizeAdd(rt.usizeRem(b >> 2 as rt.usize, 5), 1); - rt.resultUnwrap(Spill.resize$u32(ints, cap), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); - rt.resultUnwrap(Spill.resize$sync_Arc_u8(arcs, cap), (value: Fault.Fault, f: rt.Formatter) => Fault.fmt$fmt_Debug(value, f)); + const cap: rs.usize = rs.usizeAdd(rs.usizeRem(b >> 2 as rs.usize, 5), 1); + rs.resultUnwrap(Spill.resize$u32(ints, cap), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); + rs.resultUnwrap(Spill.resize$sync_Arc_u8(arcs, cap), (value: Fault.Fault, f: rs.Formatter) => Fault.fmt$fmt_Debug(value, f)); } - rt.byteVecPush(out, shared.strong & 0xff); + rs.byteVecPush(out, shared.strong & 0xff); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(Spill.asSlice$u32(ints)), (x: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); - rt.byteVecPush(out, ints.cap & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(Spill.asSlice$Option_tuple2_u8_u16(pairs)), (p: [rt.u8, rt.u16] | undefined): rt.u8 => { - return option_mapOr$0hi5qhf(p, 0, (_2: [rt.u8, rt.u16]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(Spill.asSlice$u32(ints)), (x: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); + rs.byteVecPush(out, ints.cap & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(Spill.asSlice$Option_tuple2_u8_u16(pairs)), (p: [rs.u8, rs.u16] | undefined): rs.u8 => { + return option_mapOr$12lsao8(p, 0, (_2: [rs.u8, rs.u16]): rs.u8 => { return _2[0] ^ (_2[1] & 0xff); }); }), undefined, true); drop$heap_Spill_sync_Arc_u8(arcs); - rt.byteVecPush(out, shared.strong & 0xff); + rs.byteVecPush(out, shared.strong & 0xff); drop$heap_Spill_Option_tuple2_u8_u16(pairs); drop$heap_Spill_u32(ints); shared[Symbol.dispose](); @@ -100,91 +100,91 @@ export function spills(data: rt.ByteSlice, out: rt.ByteVec): void { * last whole value, which `realloc` grows by too few bytes to hold one more, and pointers * freed through `cast`. */ -export function remnants(data: rt.ByteSlice, out: rt.ByteVec): void { - const pointer = rt.alloc(rt.resultUnwrap(rt.layoutArray(rt.usizeAdd(data.length, 1), 4, 4), rt.fmtLayoutErrorDebug)); - const slots: rt.Place = rt.allocAs(rt.optionUnwrap(pointer === rt.NULL ? undefined : pointer), 4, "u32"); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function remnants(data: rs.ByteSlice, out: rs.ByteVec): void { + const pointer = rs.alloc(rs.resultUnwrap(rs.layoutArray(rs.usizeAdd(data.length, 1), 4, 4), rs.fmtLayoutErrorDebug)); + const slots: rs.Place = rs.allocAs(rs.optionUnwrap(pointer === rs.NULL ? undefined : pointer), 4, "u32"); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _16: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_16 === rt.DONE) { + const _16: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_16 === rs.DONE) { break; } - const i: rt.usize = _16[0]; - const b: rt.u8 = _16[1]; - rt.ptrAdd(slots, i).v = ((((b as rt.u32) << 8) >>> 0) | 1) >>> 0; + const i: rs.usize = _16[0]; + const b: rs.u8 = _16[1]; + rs.ptrAdd(slots, i).v = ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; } - const words: rt.Place = slots; - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.ptrSlice(words, data.length)), (x: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(x).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); - rt.dealloc(rt.allocBytes(words, 4, "u32")); - const pointer2 = rt.alloc(rt.resultUnwrap(rt.layoutFromSizeAlign(9, 4), rt.fmtLayoutErrorDebug)); - const pair: rt.Place = rt.allocAs(rt.optionUnwrap(pointer2 === rt.NULL ? undefined : pointer2), 4, "u32"); - const first: rt.u32 = option_mapOr$1qo6t0j(rt.byteSliceFirst(data), 0, (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; + const words: rs.Place = slots; + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(rs.ptrSlice(words, data.length)), (x: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(x).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); + rs.dealloc(rs.allocBytes(words, 4, "u32")); + const pointer2 = rs.alloc(rs.resultUnwrap(rs.layoutFromSizeAlign(9, 4), rs.fmtLayoutErrorDebug)); + const pair: rs.Place = rs.allocAs(rs.optionUnwrap(pointer2 === rs.NULL ? undefined : pointer2), 4, "u32"); + const first: rs.u32 = option_mapOr$1diq86f(rs.byteSliceFirst(data), 0, (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; }); pair.v = first; - rt.ptrAdd(pair, 1).v = rt.u32Mul(first, 3); - const pointer3 = rt.realloc(rt.allocBytes(pair, 4, "u32"), 11); - const grown2: rt.Place = rt.allocAs(rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3), 4, "u32"); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice([grown2.v, rt.ptrAdd(grown2, 1).v]), (x2: rt.u32): Uint8Array => { - return rt.u32ToBeBytes(x2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 4), undefined, true); - rt.dealloc(rt.allocBytes(grown2, 4, "u32")); - const one: rt.Layout = { size: 1, align: 1 }; - const pointer4 = rt.alloc(one); - const byte: rt.Place = rt.allocAs(rt.optionUnwrap(pointer4 === rt.NULL ? undefined : pointer4), 1, "u8"); + rs.ptrAdd(pair, 1).v = rs.u32Mul(first, 3); + const pointer3 = rs.realloc(rs.allocBytes(pair, 4, "u32"), 11); + const grown2: rs.Place = rs.allocAs(rs.optionUnwrap(pointer3 === rs.NULL ? undefined : pointer3), 4, "u32"); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice([grown2.v, rs.ptrAdd(grown2, 1).v]), (x2: rs.u32): Uint8Array => { + return rs.u32ToBeBytes(x2).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 4), undefined, true); + rs.dealloc(rs.allocBytes(grown2, 4, "u32")); + const one: rs.Layout = { size: 1, align: 1 }; + const pointer4 = rs.alloc(one); + const byte: rs.Place = rs.allocAs(rs.optionUnwrap(pointer4 === rs.NULL ? undefined : pointer4), 1, "u8"); byte.v = first & 0xff; - const pointer5 = rt.realloc(rt.allocBytes(byte, 1, "u8"), 2); - const two2: rt.Place = rt.allocAs(rt.optionUnwrap(pointer5 === rt.NULL ? undefined : pointer5), 1, "u8"); - rt.ptrAdd(two2, 1).v = 7; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(two2.v, rt.ptrAdd(two2, 1).v)), undefined, true); - const _107: rt.Place = rt.allocBytes(two2, 1, "u8"); - rt.resultUnwrap(rt.layoutArray(2, 1, 1), rt.fmtLayoutErrorDebug); - rt.dealloc(_107); + const pointer5 = rs.realloc(rs.allocBytes(byte, 1, "u8"), 2); + const two2: rs.Place = rs.allocAs(rs.optionUnwrap(pointer5 === rs.NULL ? undefined : pointer5), 1, "u8"); + rs.ptrAdd(two2, 1).v = 7; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(two2.v, rs.ptrAdd(two2, 1).v)), undefined, true); + const _107: rs.Place = rs.allocBytes(two2, 1, "u8"); + rs.resultUnwrap(rs.layoutArray(2, 1, 1), rs.fmtLayoutErrorDebug); + rs.dealloc(_107); } /** * `Layout`s made of sizes and alignments up to wasm32's `isize::MAX`, and of arrays of * `u64`s and of values of no bytes, and what `Debug` and `Display` write of each. */ -export function layouts(data: rt.ByteSlice, out: rt.ByteVec): void { - let align!: rt.usize; - const iter: rt.Iter = rt.byteSliceChunks(data, 5); +export function layouts(data: rs.ByteSlice, out: rs.ByteVec): void { + let align!: rs.usize; + const iter: rs.Iter = rs.byteSliceChunks(data, 5); while (true) { - const _6: rt.ByteSlice | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.ByteSlice | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } - const word: Uint8Array = rt.bytes(4); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(word), 0, rt.min(_6.length, 4)), rt.byteSliceRange(_6, 0, rt.min(_6.length, 4))); - const size: rt.usize = rt.u32FromBeBytes(word.slice().reverse()) as rt.usize; - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(_6, 4), 0); + const word: Uint8Array = rs.bytes(4); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(word), 0, rs.min(_6.length, 4)), rs.byteSliceRange(_6, 0, rs.min(_6.length, 4))); + const size: rs.usize = rs.u32FromBeBytes(word.slice().reverse()) as rs.usize; + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(_6, 4), 0); if ((b & 128) === 0) { - align = b as rt.usize; + align = b as rs.usize; } else { - align = rt.usizeShl(1, rt.u8Rem(b, 32)); + align = rs.usizeShl(1, rs.u8Rem(b, 32)); } - const made: rt.Result = rt.layoutFromSizeAlign(size, align); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(made, f, rt.fmtLayoutDebug, rt.fmtLayoutErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); + const made: rs.Result = rs.layoutFromSizeAlign(size, align); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(made, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); if (!made.ok) { - rt.iterExtendBytes(out, rt.strBytes(rt.fmtToString((f: rt.Formatter) => rt.fmtLayoutErrorDisplay(rt.LAYOUT_ERROR, f))), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.fmtToString((f: rs.Formatter) => rs.fmtLayoutErrorDisplay(rs.LAYOUT_ERROR, f))), undefined, true); } - const part3 = rt.layoutArray(rt.usizeShr(size, rt.u8Rem(b, 8)), 8, 8); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part3, f, rt.fmtLayoutDebug, rt.fmtLayoutErrorDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - const unit: rt.Layout = rt.resultUnwrap(rt.layoutArray(size, 0, 1), rt.fmtLayoutErrorDebug); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(unit.size & 0xff, unit.align & 0xff)), undefined, true); + const part3 = rs.layoutArray(rs.usizeShr(size, rs.u8Rem(b, 8)), 8, 8); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part3, f, rs.fmtLayoutDebug, rs.fmtLayoutErrorDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + const unit: rs.Layout = rs.resultUnwrap(rs.layoutArray(size, 0, 1), rs.fmtLayoutErrorDebug); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(unit.size & 0xff, unit.align & 0xff)), undefined, true); } const _92: Fault.Fault = { tag: "Alloc", layout: { size: 16, align: 8 } }; - const _94: rt.Layout = { size: 4, align: 4 }; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rt.Formatter) => rt.fmtLayoutDebug(_94, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); - rt.byteVecPush(out, 8 & 0xff); + const _94: rs.Layout = { size: 4, align: 4 }; + const args6: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(_92, f), (f: rs.Formatter) => rs.fmtLayoutDebug(_94, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.byteVecPush(out, 8 & 0xff); const arg = { tag: "Overflow" } as Fault.Fault; - const args8: rt.Fmt[] = [(f: rt.Formatter) => Fault.fmt$fmt_Debug(arg, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args8[0]])), undefined, true); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Fault.fmt$fmt_Debug(arg, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args8[0]])), undefined, true); } //# sourceMappingURL=heap.ts.map diff --git a/ts/fixtures/lang/heap/expected/lib.ts b/ts/fixtures/lang/heap/expected/lib.ts index 1826ab5bb..c0346c86f 100644 --- a/ts/fixtures/lang/heap/expected/lib.ts +++ b/ts/fixtures/lang/heap/expected/lib.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { spills, remnants, layouts } from "./heap.ts"; import * as Spill from "./heap.Spill.ts"; -export function drop$heap_Spill_Option_tuple2_u8_u16(_1: Spill.Spill<[rt.u8, rt.u16] | undefined>): void { +export function drop$heap_Spill_Option_tuple2_u8_u16(_1: Spill.Spill<[rs.u8, rs.u16] | undefined>): void { Spill.drop$ops_Drop_Option_tuple2_u8_u16(_1); } -export function drop$heap_Spill_sync_Arc_u8(_1: Spill.Spill>): void { +export function drop$heap_Spill_sync_Arc_u8(_1: Spill.Spill>): void { Spill.drop$ops_Drop_sync_Arc_u8(_1); } -export function drop$heap_Spill_u32(_1: Spill.Spill): void { +export function drop$heap_Spill_u32(_1: Spill.Spill): void { Spill.drop$ops_Drop_u32(_1); } @@ -20,14 +20,14 @@ export function drop$heap_Spill_u32(_1: Spill.Spill): void { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["heap::spills", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["heap::spills", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { spills(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["heap::layouts", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["heap::layouts", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { layouts(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["heap::remnants", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["heap::remnants", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { remnants(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/hints/expected/core/bool.ts b/ts/fixtures/lang/hints/expected/core/bool.ts index 492c81ecd..b92d1f157 100644 --- a/ts/fixtures/lang/hints/expected/core/bool.ts +++ b/ts/fixtures/lang/hints/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1ugl8af(self: boolean, t: rt.u64): rt.u64 | undefined { +export function thenSome$0be218t(self: boolean, t: rs.u64): rs.u64 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/hints/expected/core/option.ts b/ts/fixtures/lang/hints/expected/core/option.ts index f084d456d..6e675e43c 100644 --- a/ts/fixtures/lang/hints/expected/core/option.ts +++ b/ts/fixtures/lang/hints/expected/core/option.ts @@ -1,58 +1,58 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Unit from "../hints.Unit.ts"; -export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$0yvilko(self: rs.ByteSlice | undefined, default_: rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1imnnei(self: rt.Vec | undefined, default_: rt.usize, f: (a0: rt.Vec) => rt.usize): rt.usize { +export function mapOr$1srande(self: rs.Vec | undefined, default_: rs.usize, f: (a0: rs.Vec) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0v5bfoa(self: rt.Vec | undefined, default_: rt.usize, f: (a0: rt.Vec) => rt.usize): rt.usize { +export function mapOr$1jtsi2n(self: rs.Vec | undefined, default_: rs.usize, f: (a0: rs.Vec) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0iae8yu(self: rt.Vec<[rt.u64, rt.u8]> | undefined, default_: rt.usize, f: (a0: rt.Vec<[rt.u64, rt.u8]>) => rt.usize): rt.usize { +export function mapOr$1tgduhr(self: rs.Vec<[rs.u64, rs.u8]> | undefined, default_: rs.usize, f: (a0: rs.Vec<[rs.u64, rs.u8]>) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1tx3bdh(self: rt.Vec<[rt.u8, rt.u8, rt.u8]> | undefined, default_: rt.usize, f: (a0: rt.Vec<[rt.u8, rt.u8, rt.u8]>) => rt.usize): rt.usize { +export function mapOr$0vgdmy4(self: rs.Vec<[rs.u8, rs.u8, rs.u8]> | undefined, default_: rs.usize, f: (a0: rs.Vec<[rs.u8, rs.u8, rs.u8]>) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0phbwf3(self: rt.Vec | undefined, default_: rt.usize, f: (a0: rt.Vec) => rt.usize): rt.usize { +export function mapOr$09ae03o(self: rs.Vec | undefined, default_: rs.usize, f: (a0: rs.Vec) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$08xwngs(self: rt.ByteVec | undefined, default_: rt.usize, f: (a0: rt.ByteVec) => rt.usize): rt.usize { +export function mapOr$19z8yie(self: rs.ByteVec | undefined, default_: rs.usize, f: (a0: rs.ByteVec) => rs.usize): rs.usize { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/hints/expected/core/result.ts b/ts/fixtures/lang/hints/expected/core/result.ts index 56fd6599d..9e87925d1 100644 --- a/ts/fixtures/lang/hints/expected/core/result.ts +++ b/ts/fixtures/lang/hints/expected/core/result.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0u9zzk3(self: rt.Result, default_: rt.u32): rt.u32 { +export function unwrapOr$0i7x980(self: rs.Result, default_: rs.u32): rs.u32 { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/hints/expected/harness.ts b/ts/fixtures/lang/hints/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/hints/expected/harness.ts +++ b/ts/fixtures/lang/hints/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/hints/expected/hints.Countdown.ts b/ts/fixtures/lang/hints/expected/hints.Countdown.ts index cac7ee2e1..88a4da012 100644 --- a/ts/fixtures/lang/hints/expected/hints.Countdown.ts +++ b/ts/fixtures/lang/hints/expected/hints.Countdown.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An iterator of the crate's own, which keeps std's hint. */ export interface Countdown { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { self._0 = _2; return self._0; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=hints.Countdown.ts.map diff --git a/ts/fixtures/lang/hints/expected/hints.Endless.ts b/ts/fixtures/lang/hints/expected/hints.Endless.ts index 0c9b1bb93..9145a7873 100644 --- a/ts/fixtures/lang/hints/expected/hints.Endless.ts +++ b/ts/fixtures/lang/hints/expected/hints.Endless.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An iterator of the crate's own that never ends. */ export interface Endless { - _0: rt.u64; + _0: rs.u64; } -export function next$iter_Iterator(self: Endless): rt.u64 | rt.Done { +export function next$iter_Iterator(self: Endless): rs.u64 | rs.Done { return self._0; } diff --git a/ts/fixtures/lang/hints/expected/hints.Most.ts b/ts/fixtures/lang/hints/expected/hints.Most.ts index a22d89cd3..0a5a4bff3 100644 --- a/ts/fixtures/lang/hints/expected/hints.Most.ts +++ b/ts/fixtures/lang/hints/expected/hints.Most.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * The most of each element type std's collections hold on wasm32, past which they panic @@ -8,10 +8,10 @@ import * as rt from "./rt.ts"; * of it, and a hash map of it to a `u32`. */ export interface Most { - vec: rt.u64; - pairs: rt.u64; - set: rt.u64; - map: rt.u64; + vec: rs.u64; + pairs: rs.u64; + set: rs.u64; + map: rs.u64; } //# sourceMappingURL=hints.Most.ts.map diff --git a/ts/fixtures/lang/hints/expected/hints.Unit.ts b/ts/fixtures/lang/hints/expected/hints.Unit.ts index 01dcf846e..4e7b35b3a 100644 --- a/ts/fixtures/lang/hints/expected/hints.Unit.ts +++ b/ts/fixtures/lang/hints/expected/hints.Unit.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(_self: Unit): Unit { return {}; @@ -10,15 +10,15 @@ export function eq$cmp_PartialEq(_self: Unit, _other: Unit): boolean { return true; } -export function partialCmp$cmp_PartialOrd(_self: Unit, _other: Unit): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(_self: Unit, _other: Unit): rs.Ordering | undefined { return 0; } -export function cmp$cmp_Ord(_self: Unit, _other: Unit): rt.Ordering { +export function cmp$cmp_Ord(_self: Unit, _other: Unit): rs.Ordering { return 0; } -export function hash$Hash_hash_DefaultHasher(_self: Unit, _state: rt.Hasher): void { +export function hash$Hash_hash_DefaultHasher(_self: Unit, _state: rs.Hasher): void { } /** Zero-sized, whose derived `clone` assigns nothing. */ diff --git a/ts/fixtures/lang/hints/expected/hints.ts b/ts/fixtures/lang/hints/expected/hints.ts index fd4353c5d..cbfef7d04 100644 --- a/ts/fixtures/lang/hints/expected/hints.ts +++ b/ts/fixtures/lang/hints/expected/hints.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$1ugl8af } from "./core/bool.ts"; -import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1imnnei as option_mapOr$1imnnei, mapOr$0v5bfoa as option_mapOr$0v5bfoa, mapOr$0iae8yu as option_mapOr$0iae8yu, mapOr$1tx3bdh as option_mapOr$1tx3bdh, mapOr$0phbwf3 as option_mapOr$0phbwf3, mapOr$08xwngs as option_mapOr$08xwngs } from "./core/option.ts"; -import { unwrapOr$0u9zzk3 as result_unwrapOr$0u9zzk3 } from "./core/result.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0be218t } from "./core/bool.ts"; +import { unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$1srande as option_mapOr$1srande, mapOr$1jtsi2n as option_mapOr$1jtsi2n, mapOr$1tgduhr as option_mapOr$1tgduhr, mapOr$0vgdmy4 as option_mapOr$0vgdmy4, mapOr$09ae03o as option_mapOr$09ae03o, mapOr$19z8yie as option_mapOr$19z8yie } from "./core/option.ts"; +import { unwrapOr$0i7x980 as result_unwrapOr$0i7x980 } from "./core/result.ts"; import * as Countdown from "./hints.Countdown.ts"; import * as Endless from "./hints.Endless.ts"; import type * as Most from "./hints.Most.ts"; import * as Unit from "./hints.Unit.ts"; /** A hint, as four bytes each, the upper bound after whether it has one. */ -export function put(out: rt.ByteVec, _2: [rt.usize, rt.usize | undefined]): void { - const lower: rt.usize = _2[0]; - const upper: rt.usize | undefined = _2[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(lower as rt.u32))); +export function put(out: rs.ByteVec, _2: [rs.usize, rs.usize | undefined]): void { + const lower: rs.usize = _2[0]; + const upper: rs.usize | undefined = _2[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(lower as rs.u32))); if (upper === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const upper2: rt.usize = upper; - rt.byteVecPush(out, 1); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(upper2 as rt.u32))); + const upper2: rs.usize = upper; + rs.byteVecPush(out, 1); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(upper2 as rs.u32))); } } @@ -27,17 +27,17 @@ export function put(out: rt.ByteVec, _2: [rt.usize, rt.usize | undefined]): void * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$array_IntoIter_u8_3(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$array_IntoIter_u8_3(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -47,17 +47,17 @@ export function walk$array_IntoIter_u8_3(it: rt.Iter, steps: rt.u8, out: * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_binary_heap_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_binary_heap_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -67,17 +67,17 @@ export function walk$collections_binary_heap_Iter_u8(it: rt.Iter, steps: * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_btree_map_Iter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_btree_map_Iter_u8_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -87,17 +87,17 @@ export function walk$collections_btree_map_Iter_u8_u8(it: rt.Iter<[rt.u8, rt.u8] * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_btree_map_Range_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_btree_map_Range_u8_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -107,17 +107,17 @@ export function walk$collections_btree_map_Range_u8_u8(it: rt.Iter<[rt.u8, rt.u8 * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_btree_map_Values_u8_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_btree_map_Values_u8_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -127,17 +127,17 @@ export function walk$collections_btree_map_Values_u8_u8(it: rt.Iter, step * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_btree_set_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_btree_set_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -147,38 +147,38 @@ export function walk$collections_btree_set_Iter_u8(it: rt.Iter, steps: rt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_vec_deque_Drain_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_vec_deque_Drain_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } - rt.drop(it); + rs.drop(it); } /** * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$collections_vec_deque_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$collections_vec_deque_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -188,17 +188,17 @@ export function walk$collections_vec_deque_Iter_u8(it: rt.Iter, steps: rt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Chain_iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure28_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Chain_iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure28_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -208,17 +208,17 @@ export function walk$iter_Chain_iter_Flatten_iter_Map_ops_Range_u64_hints_hints_ * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Chain_ops_Range_u32_ops_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Chain_ops_Range_u32_ops_Range_u32(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -228,17 +228,17 @@ export function walk$iter_Chain_ops_Range_u32_ops_Range_u32(it: rt.Iter, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Chain_ops_Range_u64_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Chain_ops_Range_u64_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -248,17 +248,17 @@ export function walk$iter_Chain_ops_Range_u64_ops_Range_u64(it: rt.Iter, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Cloned_slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Cloned_slice_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -268,17 +268,17 @@ export function walk$iter_Cloned_slice_Iter_u8(it: rt.Iter, steps: rt.u8, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Copied_slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Copied_slice_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -288,17 +288,17 @@ export function walk$iter_Copied_slice_Iter_u8(it: rt.Iter, steps: rt.u8, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Empty_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Empty_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -308,17 +308,17 @@ export function walk$iter_Empty_u8(it: rt.Iter, steps: rt.u8, out: rt.Byt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Enumerate_ops_Range_u32(it: rt.Iter<[rt.usize, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Enumerate_ops_Range_u32(it: rs.Iter<[rs.usize, rs.u32]>, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -328,17 +328,17 @@ export function walk$iter_Enumerate_ops_Range_u32(it: rt.Iter<[rt.usize, rt.u32] * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FilterMap_ops_Range_u64_hints_hints_closure2(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FilterMap_ops_Range_u64_hints_hints_closure2(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -348,17 +348,17 @@ export function walk$iter_FilterMap_ops_Range_u64_hints_hints_closure2(it: rt.It * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Filter_ops_Range_u64_hints_hints_closure1(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Filter_ops_Range_u64_hints_hints_closure1(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -368,17 +368,17 @@ export function walk$iter_Filter_ops_Range_u64_hints_hints_closure1(it: rt.Iter< * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -388,17 +388,17 @@ export function walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16 * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -408,17 +408,17 @@ export function walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10 * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_hints_hints_closure17_closure0_hints_hints_closure17(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_hints_hints_closure17_closure0_hints_hints_closure17(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -428,17 +428,17 @@ export function walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_ * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_array2_u64_2_hints_hints_closure14(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_array2_u64_2_hints_hints_closure14(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -448,17 +448,17 @@ export function walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_arra * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -468,17 +468,17 @@ export function walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(it: * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -488,17 +488,17 @@ export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(i * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -508,17 +508,17 @@ export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(i * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -528,17 +528,17 @@ export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(i * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure9(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure9(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -548,17 +548,17 @@ export function walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure9(it * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -568,17 +568,17 @@ export function walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(i * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_slice_Chunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_slice_Chunks_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -588,17 +588,17 @@ export function walk$iter_Flatten_slice_Chunks_u8(it: rt.Iter, steps: rt. * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Flatten_slice_Iter_array2_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Flatten_slice_Iter_array2_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -608,17 +608,17 @@ export function walk$iter_Flatten_slice_Iter_array2_u8(it: rt.Iter, steps * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Fuse_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Fuse_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -628,17 +628,17 @@ export function walk$iter_Fuse_ops_Range_u64(it: rt.Iter, steps: rt.u8, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Inspect_ops_Range_u64_hints_hints_closure8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Inspect_ops_Range_u64_hints_hints_closure8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -648,17 +648,17 @@ export function walk$iter_Inspect_ops_Range_u64_hints_hints_closure8(it: rt.Iter * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Map_ops_Range_u64_hints_hints_closure7(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Map_ops_Range_u64_hints_hints_closure7(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -668,17 +668,17 @@ export function walk$iter_Map_ops_Range_u64_hints_hints_closure7(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Once_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -688,17 +688,17 @@ export function walk$iter_Once_u64(it: rt.Iter, steps: rt.u8, out: rt.By * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Rev_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Rev_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -708,17 +708,17 @@ export function walk$iter_Rev_ops_Range_u64(it: rt.Iter, steps: rt.u8, o * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_StepBy_iter_Rev_iter_Zip_ops_Range_u32_ops_Range_u32(it: rt.Iter<[rt.u32, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_StepBy_iter_Rev_iter_Zip_ops_Range_u32_ops_Range_u32(it: rs.Iter<[rs.u32, rs.u32]>, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -728,17 +728,17 @@ export function walk$iter_StepBy_iter_Rev_iter_Zip_ops_Range_u32_ops_Range_u32(i * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_StepBy_ops_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_StepBy_ops_Range_u32(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -748,17 +748,17 @@ export function walk$iter_StepBy_ops_Range_u32(it: rt.Iter, steps: rt.u8 * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_StepBy_slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_StepBy_slice_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -768,17 +768,17 @@ export function walk$iter_StepBy_slice_Iter_u8(it: rt.Iter, steps: rt.u8, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Take_ops_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Take_ops_Range_u32(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -788,17 +788,17 @@ export function walk$iter_Take_ops_Range_u32(it: rt.Iter, steps: rt.u8, * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$iter_Zip_slice_Iter_u8_iter_Skip_slice_Iter_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$iter_Zip_slice_Iter_u8_iter_Skip_slice_Iter_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -808,19 +808,19 @@ export function walk$iter_Zip_slice_Iter_u8_iter_Skip_slice_Iter_u8(it: rt.Iter< * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$mut_iter_Chain_ops_Range_u64_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; - put(out, rt.iterBorrow(it).sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; +export function walk$mut_iter_Chain_ops_Range_u64_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; + put(out, rs.iterBorrow(it).sizeHint()); + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } - put(out, rt.iterBorrow(it).sizeHint()); + put(out, rs.iterBorrow(it).sizeHint()); } } @@ -828,19 +828,19 @@ export function walk$mut_iter_Chain_ops_Range_u64_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; - put(out, rt.iterBorrow(it).sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; +export function walk$mut_slice_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; + put(out, rs.iterBorrow(it).sizeHint()); + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } - put(out, rt.iterBorrow(it).sizeHint()); + put(out, rs.iterBorrow(it).sizeHint()); } } @@ -848,17 +848,17 @@ export function walk$mut_slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_RangeInclusive_i8(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_RangeInclusive_i8(it: rs.RangeInclusive, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -868,17 +868,17 @@ export function walk$ops_RangeInclusive_i8(it: rt.RangeInclusive, steps: * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_RangeInclusive_u32(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_RangeInclusive_u32(it: rs.RangeInclusive, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -888,17 +888,17 @@ export function walk$ops_RangeInclusive_u32(it: rt.RangeInclusive, steps * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_RangeInclusive_u64(it: rt.RangeInclusive, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_RangeInclusive_u64(it: rs.RangeInclusive, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -908,17 +908,17 @@ export function walk$ops_RangeInclusive_u64(it: rt.RangeInclusive, steps * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_i128(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_i128(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -928,17 +928,17 @@ export function walk$ops_Range_i128(it: rt.Range, steps: rt.u8, out: rt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_i32(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_i32(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { it.start < it.end ? it.start++ : undefined; } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -948,17 +948,17 @@ export function walk$ops_Range_i32(it: rt.Range, steps: rt.u8, out: rt.B * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_i64(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_i64(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -968,17 +968,17 @@ export function walk$ops_Range_i64(it: rt.Range, steps: rt.u8, out: rt.B * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_u128(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_u128(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -988,17 +988,17 @@ export function walk$ops_Range_u128(it: rt.Range, steps: rt.u8, out: rt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_u32(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_u32(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { it.start < it.end ? it.start++ : undefined; } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1008,17 +1008,17 @@ export function walk$ops_Range_u32(it: rt.Range, steps: rt.u8, out: rt.B * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_u64(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_u64(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1028,17 +1028,17 @@ export function walk$ops_Range_u64(it: rt.Range, steps: rt.u8, out: rt.B * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_u8(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_u8(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { it.start < it.end ? it.start++ : undefined; } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1048,17 +1048,17 @@ export function walk$ops_Range_u8(it: rt.Range, steps: rt.u8, out: rt.Byt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$ops_Range_usize(it: rt.Range, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$ops_Range_usize(it: rs.Range, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { it.start < it.end ? it.start++ : undefined; } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1068,17 +1068,17 @@ export function walk$ops_Range_usize(it: rt.Range, steps: rt.u8, out: * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$option_IntoIter_ref_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$option_IntoIter_ref_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1088,17 +1088,17 @@ export function walk$option_IntoIter_ref_u8(it: rt.Iter, steps: rt.u8, ou * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_ChunksExact_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_ChunksExact_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1108,17 +1108,17 @@ export function walk$slice_ChunksExact_u8(it: rt.Iter, steps: rt.u * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_Chunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_Chunks_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1128,17 +1128,17 @@ export function walk$slice_Chunks_u8(it: rt.Iter, steps: rt.u8, ou * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1148,17 +1148,17 @@ export function walk$slice_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.Byt * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_RChunksExact_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_RChunksExact_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1168,17 +1168,17 @@ export function walk$slice_RChunksExact_u8(it: rt.Iter, steps: rt. * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_RChunks_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_RChunks_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1188,17 +1188,17 @@ export function walk$slice_RChunks_u8(it: rt.Iter, steps: rt.u8, o * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$slice_Windows_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$slice_Windows_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1208,17 +1208,17 @@ export function walk$slice_Windows_u8(it: rt.Iter, steps: rt.u8, o * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$str_Bytes(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$str_Bytes(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1228,17 +1228,17 @@ export function walk$str_Bytes(it: rt.Iter, steps: rt.u8, out: rt.ByteVec * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$str_Chars(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$str_Chars(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } @@ -1248,451 +1248,451 @@ export function walk$str_Chars(it: rt.Iter, steps: rt.u8, out: rt.ByteV * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$string_Drain(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$string_Drain(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } - rt.drop(it); + rs.drop(it); } /** * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$vec_Drain_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$vec_Drain_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } - rt.drop(it); + rs.drop(it); } /** * `it`'s hint, and again after each of up to three items, read from the back where * `steps` has the item's bit set. */ -export function walk$vec_IntoIter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { - let _12!: rt.u8; +export function walk$vec_IntoIter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { + let _12!: rs.u8; put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while ((_12 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _12)) & 1) === 0) { - rt.iterToOption(it.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _12)) & 1) === 0) { + rs.iterToOption(it.next()); } else { - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$collections_hash_map_Drain_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$collections_hash_map_Drain_u8_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$collections_hash_map_IntoIter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$collections_hash_map_IntoIter_u8_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$collections_hash_map_Iter_u8_u8(it: rt.Iter<[rt.u8, rt.u8]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$collections_hash_map_Iter_u8_u8(it: rs.Iter<[rs.u8, rs.u8]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$collections_hash_map_Keys_u8_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$collections_hash_map_Keys_u8_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$collections_hash_set_Iter_u8(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$collections_hash_set_Iter_u8(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$hints_Countdown(it: Countdown.Countdown, steps: rt.u8, out: rt.ByteVec): void { - put(out, rt.iterFrom(it, Countdown.next$iter_Iterator).sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; +export function walkFront$hints_Countdown(it: Countdown.Countdown, steps: rs.u8, out: rs.ByteVec): void { + put(out, rs.iterFrom(it, Countdown.next$iter_Iterator).sizeHint()); + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(Countdown.next$iter_Iterator(it)); - put(out, rt.iterFrom(it, Countdown.next$iter_Iterator).sizeHint()); + rs.iterToOption(Countdown.next$iter_Iterator(it)); + put(out, rs.iterFrom(it, Countdown.next$iter_Iterator).sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Chain_iter_Map_iter_Zip_ops_Range_u64_ops_Range_u64_hints_hints_closure30_iter_Once_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Chain_iter_Map_iter_Zip_ops_Range_u64_ops_Range_u64_hints_hints_closure30_iter_Once_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Chain_iter_Take_hints_Endless_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Chain_iter_Take_hints_Endless_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Filter_hints_Endless_hints_hints_closure6(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Filter_hints_Endless_hints_hints_closure6(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_FromFn_hints_hints_closure20(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_FromFn_hints_hints_closure20(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_FromFn_hints_hints_closure23(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_FromFn_hints_hints_closure23(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Fuse_hints_Countdown(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Fuse_hints_Countdown(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Fuse_hints_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Fuse_hints_Endless(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Fuse_iter_Take_hints_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Fuse_iter_Take_hints_Endless(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_MapWhile_ops_Range_u64_hints_hints_closure5(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_MapWhile_ops_Range_u64_hints_hints_closure5(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Peekable_iter_Filter_ops_Range_u64_hints_hints_closure29(it: rt.Peekable, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Peekable_iter_Filter_ops_Range_u64_hints_hints_closure29(it: rs.Peekable, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_SkipWhile_ops_Range_u64_hints_hints_closure3(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_SkipWhile_ops_Range_u64_hints_hints_closure3(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Skip_hints_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Skip_hints_Endless(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Skip_iter_Flatten_iter_Map_ops_Range_u32_hints_hints_closure31(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Skip_iter_Flatten_iter_Map_ops_Range_u32_hints_hints_closure31(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Skip_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Skip_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_StepBy_ops_Range_u32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_StepBy_ops_Range_u32(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_StepBy_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_StepBy_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Successors_u64_hints_hints_closure21(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Successors_u64_hints_hints_closure21(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Successors_u8_hints_hints_closure22(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Successors_u8_hints_hints_closure22(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_TakeWhile_ops_Range_u64_hints_hints_closure4(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_TakeWhile_ops_Range_u64_hints_hints_closure4(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Take_hints_Endless(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Take_hints_Endless(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Take_iter_FlatMap_ops_Range_u64_ops_Range_u64_hints_hints_closure32(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Take_iter_FlatMap_ops_Range_u64_ops_Range_u64_hints_hints_closure32(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Take_iter_Skip_iter_Chain_ops_Range_u64_ops_Range_u64(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Take_iter_Skip_iter_Chain_ops_Range_u64_ops_Range_u64(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Zip_hints_Endless_ops_Range_u32(it: rt.Iter<[rt.u64, rt.u32]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Zip_hints_Endless_ops_Range_u32(it: rs.Iter<[rs.u64, rs.u32]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Zip_ops_Range_u32_hints_Endless(it: rt.Iter<[rt.u32, rt.u64]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Zip_ops_Range_u32_hints_Endless(it: rs.Iter<[rs.u32, rs.u64]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$iter_Zip_ops_Range_u64_ops_Range_u64(it: rt.Iter<[rt.u64, rt.u64]>, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$iter_Zip_ops_Range_u64_ops_Range_u64(it: rs.Iter<[rs.u64, rs.u64]>, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** As `walk`, of an iterator that reads only from the front. */ -export function walkFront$str_Split_char(it: rt.Iter, steps: rt.u8, out: rt.ByteVec): void { +export function walkFront$str_Split_char(it: rs.Iter, steps: rs.u8, out: rs.ByteVec): void { put(out, it.sizeHint()); - const _9: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _9; + const _9: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _9; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); put(out, it.sizeHint()); } } /** `n`, or `u32::MAX` past it. */ -export function u32Of(n: rt.u64): rt.u32 { - return result_unwrapOr$0u9zzk3(rt.u32TryFrom(n), 4294967295); +export function u32Of(n: rs.u64): rs.u32 { + return result_unwrapOr$0i7x980(rs.u32TryFrom(n), 4294967295); } /** @@ -1700,437 +1700,437 @@ export function u32Of(n: rt.u64): rt.u32 { * lengths `data`'s first two bytes pick or of its fourth byte on, as each reads from the * front or the back by the third byte's other bits. */ -export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function hints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _10: rt.usize = rt.usizeRem(at(0) as rt.usize, 8); + const _10: rs.usize = rs.usizeRem(at(0) as rs.usize, 8); if (!(_10 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _10); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _10); } - const _8: rt.u64 = [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rt.u64][_10]; - const _19: rt.usize = rt.usizeRem(at(1) as rt.usize, 8); + const _8: rs.u64 = [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rs.u64][_10]; + const _19: rs.usize = rs.usizeRem(at(1) as rs.usize, 8); if (!(_19 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + _19); - } - const _7: [rt.u64, rt.u64] = [_8, [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rt.u64][_19]]; - const n: rt.u64 = _8; - const m: rt.u64 = _7[1]; - const steps: rt.u8 = at(2); - const arm: rt.u8 = steps >> 5; - const bytes: rt.ByteSlice = option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 3), rt.byteSliceFrom(Uint8Array.of())); - const _37: rt.u8 = rt.u8Rem(kind, 24); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + _19); + } + const _7: [rs.u64, rs.u64] = [_8, [0, 1, 5, 2147483647, 2147483648, 4294967295, 4294967296, { hi: 0x10000000, lo: 0 } as rs.u64][_19]]; + const n: rs.u64 = _8; + const m: rs.u64 = _7[1]; + const steps: rs.u8 = at(2); + const arm: rs.u8 = steps >> 5; + const bytes: rs.ByteSlice = option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 3), rs.byteSliceFrom(Uint8Array.of())); + const _37: rs.u8 = rs.u8Rem(kind, 24); if (_37 === 0) { - const _39: rt.u8 = rt.u8Rem(arm, 5); + const _39: rs.u8 = rs.u8Rem(arm, 5); if (_39 === 0) { - walk$ops_Range_u32(new rt.Range(0, u32Of(n)), steps, out); + walk$ops_Range_u32(new rs.Range(0, u32Of(n)), steps, out); } else if (_39 === 1) { - walk$ops_Range_u32(new rt.Range(u32Of(m), u32Of(n)), steps, out); + walk$ops_Range_u32(new rs.Range(u32Of(m), u32Of(n)), steps, out); } else if (_39 === 2) { - walk$ops_Range_u8(new rt.Range(rt.u64Low(n) & 0xff, rt.u64Low(m) & 0xff), steps, out); + walk$ops_Range_u8(new rs.Range(rs.u64Low(n) & 0xff, rs.u64Low(m) & 0xff), steps, out); } else if (_39 === 3) { - walk$ops_Range_i32(new rt.Range(rt.i32Neg(rt.u64Low(n) | 0), rt.u64Low(m) | 0), steps, out); + walk$ops_Range_i32(new rs.Range(rs.i32Neg(rs.u64Low(n) | 0), rs.u64Low(m) | 0), steps, out); } else { - walk$ops_Range_usize(new rt.Range(0, rt.u64Low(n)), steps, out); + walk$ops_Range_usize(new rs.Range(0, rs.u64Low(n)), steps, out); } } else if (_37 === 1) { - const _56: rt.u8 = rt.u8Rem(arm, 4); + const _56: rs.u8 = rs.u8Rem(arm, 4); if (_56 === 0) { - walk$ops_Range_u64(new rt.Range(0, n, rt.u64Step), steps, out); + walk$ops_Range_u64(new rs.Range(0, n, rs.u64Step), steps, out); } else if (_56 === 1) { - walk$ops_Range_u64(new rt.Range({ hi: 0x80000000, lo: 0 } as rt.u64, rt.u64Add({ hi: 0x80000000, lo: 0 } as rt.u64, n), rt.u64Step), steps, out); + walk$ops_Range_u64(new rs.Range({ hi: 0x80000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x80000000, lo: 0 } as rs.u64, n), rs.u64Step), steps, out); } else if (_56 === 2) { - walk$ops_Range_i64(new rt.Range(rt.i64Neg(rt.i64Cast(n)), rt.i64Cast(m), rt.i64Step), steps, out); + walk$ops_Range_i64(new rs.Range(rs.i64Neg(rs.i64Cast(n)), rs.i64Cast(m), rs.i64Step), steps, out); } else { - walk$ops_Range_i64(new rt.Range({ hi: -0x80000000, lo: 0 } as rt.i64, rt.i64Add({ hi: -0x80000000, lo: 0 } as rt.i64, rt.i64Cast(n)), rt.i64Step), steps, out); + walk$ops_Range_i64(new rs.Range({ hi: -0x80000000, lo: 0 } as rs.i64, rs.i64Add({ hi: -0x80000000, lo: 0 } as rs.i64, rs.i64Cast(n)), rs.i64Step), steps, out); } } else if (_37 === 2) { - const _77: rt.u8 = rt.u8Rem(arm, 3); + const _77: rs.u8 = rs.u8Rem(arm, 3); if (_77 === 0) { - walk$ops_Range_u128(new rt.Range(rt.u128Shl(1, 100), rt.u128Add(rt.u128Shl(1, 100), rt.u128Cast(n)), rt.u128Step), steps, out); + walk$ops_Range_u128(new rs.Range(rs.u128Shl(1, 100), rs.u128Add(rs.u128Shl(1, 100), rs.u128Cast(n)), rs.u128Step), steps, out); } else if (_77 === 1) { - walk$ops_Range_i128(new rt.Range(rt.i128Neg(rt.i128Shl(1, 100)), rt.i128Sub(rt.i128Cast(n), rt.i128Shl(1, 100)), rt.i128Step), steps, out); + walk$ops_Range_i128(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Sub(rs.i128Cast(n), rs.i128Shl(1, 100)), rs.i128Step), steps, out); } else { - walk$ops_Range_i128(new rt.Range({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, rt.i128Step), steps, out); + walk$ops_Range_i128(new rs.Range({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, rs.i128Step), steps, out); } } else if (_37 === 3) { - const _102: rt.u8 = rt.u8Rem(arm, 5); + const _102: rs.u8 = rs.u8Rem(arm, 5); if (_102 === 0) { - walk$ops_RangeInclusive_u32(new rt.RangeInclusive(0, u32Of(n), rt.u32Step), steps, out); + walk$ops_RangeInclusive_u32(new rs.RangeInclusive(0, u32Of(n), rs.u32Step), steps, out); } else if (_102 === 1) { - walk$ops_RangeInclusive_u32(new rt.RangeInclusive(0, 4294967295, rt.u32Step), steps, out); + walk$ops_RangeInclusive_u32(new rs.RangeInclusive(0, 4294967295, rs.u32Step), steps, out); } else if (_102 === 2) { - walk$ops_RangeInclusive_i8(new rt.RangeInclusive(-128, 127, rt.i8Step), steps, out); + walk$ops_RangeInclusive_i8(new rs.RangeInclusive(-128, 127, rs.i8Step), steps, out); } else if (_102 === 3) { - walk$ops_RangeInclusive_u64(new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, n), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), steps, out); + walk$ops_RangeInclusive_u64(new rs.RangeInclusive(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step), steps, out); } else { - walk$ops_RangeInclusive_u32(new rt.RangeInclusive(u32Of(n), u32Of(m), rt.u32Step), steps, out); + walk$ops_RangeInclusive_u32(new rs.RangeInclusive(u32Of(n), u32Of(m), rs.u32Step), steps, out); } } else if (_37 === 4) { - const _114: rt.u8 = rt.u8Rem(arm, 4); + const _114: rs.u8 = rs.u8Rem(arm, 4); if (_114 === 0) { - walk$iter_Chain_ops_Range_u32_ops_Range_u32(rt.iterChain(new rt.Range(0, u32Of(rt.u64Min(n, 9))), new rt.Range(0, u32Of(m))), steps, out); + walk$iter_Chain_ops_Range_u32_ops_Range_u32(rs.iterChain(new rs.Range(0, u32Of(rs.u64Min(n, 9))), new rs.Range(0, u32Of(m))), steps, out); } else if (_114 === 1) { - walk$iter_Chain_ops_Range_u64_ops_Range_u64(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), steps, out); + walk$iter_Chain_ops_Range_u64_ops_Range_u64(rs.iterChain(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step)), steps, out); } else if (_114 === 2) { - walk$iter_Chain_ops_Range_u32_ops_Range_u32(rt.iterChain(new rt.Range(0, u32Of(n)), new rt.Range(0, 4294967295)), steps, out); + walk$iter_Chain_ops_Range_u32_ops_Range_u32(rs.iterChain(new rs.Range(0, u32Of(n)), new rs.Range(0, 4294967295)), steps, out); } else { const _131: Endless.Endless = { _0: n }; - const _132: rt.usize = rt.usizeRem(rt.u64Low(n), 9); - walkFront$iter_Chain_iter_Take_hints_Endless_ops_Range_u64(rt.iterChain(rt.iterTake(rt.iterFrom(_131, Endless.next$iter_Iterator), _132), new rt.Range(0, m, rt.u64Step)), steps, out); + const _132: rs.usize = rs.usizeRem(rs.u64Low(n), 9); + walkFront$iter_Chain_iter_Take_hints_Endless_ops_Range_u64(rs.iterChain(rs.iterTake(rs.iterFrom(_131, Endless.next$iter_Iterator), _132), new rs.Range(0, m, rs.u64Step)), steps, out); } } else if (_37 === 5) { - const _136: rt.u8 = rt.u8Rem(arm, 4); + const _136: rs.u8 = rs.u8Rem(arm, 4); if (_136 === 0) { - walkFront$iter_Zip_ops_Range_u64_ops_Range_u64(rt.iterZip(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step), "len"), steps, out); + walkFront$iter_Zip_ops_Range_u64_ops_Range_u64(rs.iterZip(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step), "len"), steps, out); } else if (_136 === 1) { const _142: Endless.Endless = { _0: n }; - const _143: rt.Range = new rt.Range(0, u32Of(m)); - walkFront$iter_Zip_hints_Endless_ops_Range_u32(rt.iterZip(rt.iterFrom(_142, Endless.next$iter_Iterator), _143), steps, out); + const _143: rs.Range = new rs.Range(0, u32Of(m)); + walkFront$iter_Zip_hints_Endless_ops_Range_u32(rs.iterZip(rs.iterFrom(_142, Endless.next$iter_Iterator), _143), steps, out); } else if (_136 === 2) { - walk$iter_Zip_slice_Iter_u8_iter_Skip_slice_Iter_u8(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterSkip(rt.iterSlice(rt.byteSliceView(bytes)), 1), [false, false]), steps, out); + walk$iter_Zip_slice_Iter_u8_iter_Skip_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterSkip(rs.iterSlice(rs.byteSliceView(bytes)), 1), [false, false]), steps, out); } else { - walkFront$iter_Zip_ops_Range_u32_hints_Endless(rt.iterZip(new rt.Range(0, u32Of(n)), rt.iterFrom({ _0: n }, Endless.next$iter_Iterator)), steps, out); + walkFront$iter_Zip_ops_Range_u32_hints_Endless(rs.iterZip(new rs.Range(0, u32Of(n)), rs.iterFrom({ _0: n }, Endless.next$iter_Iterator)), steps, out); } } else if (_37 === 6) { - const _153: rt.u8 = rt.u8Rem(arm, 4); + const _153: rs.u8 = rs.u8Rem(arm, 4); if (_153 === 0) { - walkFront$iter_Skip_ops_Range_u64(rt.iterSkip(new rt.Range(0, n, rt.u64Step), rt.u64Low(m)), steps, out); + walkFront$iter_Skip_ops_Range_u64(rs.iterSkip(new rs.Range(0, n, rs.u64Step), rs.u64Low(m)), steps, out); } else if (_153 === 1) { - walk$iter_Take_ops_Range_u32(rt.iterTake(new rt.Range(0, u32Of(n)), rt.u64Low(m)), steps, out); + walk$iter_Take_ops_Range_u32(rs.iterTake(new rs.Range(0, u32Of(n)), rs.u64Low(m)), steps, out); } else if (_153 === 2) { - walkFront$iter_Take_hints_Endless(rt.iterTake(rt.iterFrom({ _0: n }, Endless.next$iter_Iterator), rt.u64Low(m)), steps, out); + walkFront$iter_Take_hints_Endless(rs.iterTake(rs.iterFrom({ _0: n }, Endless.next$iter_Iterator), rs.u64Low(m)), steps, out); } else { const _166: Endless.Endless = { _0: n }; - const _167: rt.usize = rt.usizeRem(rt.u64Low(m), 9); - walkFront$iter_Skip_hints_Endless(rt.iterSkip(rt.iterFrom(_166, Endless.next$iter_Iterator), _167), steps, out); + const _167: rs.usize = rs.usizeRem(rs.u64Low(m), 9); + walkFront$iter_Skip_hints_Endless(rs.iterSkip(rs.iterFrom(_166, Endless.next$iter_Iterator), _167), steps, out); } } else if (_37 === 7) { - const step: rt.usize = rt.usizeAdd(rt.usizeRem(at(1) as rt.usize, 7), 1); - const _178: rt.u8 = rt.u8Rem(arm, 4); + const step: rs.usize = rs.usizeAdd(rs.usizeRem(at(1) as rs.usize, 7), 1); + const _178: rs.u8 = rs.u8Rem(arm, 4); if (_178 === 0) { - walk$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); + walk$iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); } else if (_178 === 1) { - walkFront$iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); + walkFront$iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(0, u32Of(n)), step, undefined, 4294967295), steps, out); } else if (_178 === 2) { - walkFront$iter_StepBy_ops_Range_u64(rt.iterStepBy(new rt.Range(0, n, rt.u64Step), step), steps, out); + walkFront$iter_StepBy_ops_Range_u64(rs.iterStepBy(new rs.Range(0, n, rs.u64Step), step), steps, out); } else { - walk$iter_StepBy_slice_Iter_u8(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), step), steps, out); + walk$iter_StepBy_slice_Iter_u8(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), step), steps, out); } } else if (_37 === 8) { - const _190: rt.u8 = rt.u8Rem(arm, 6); + const _190: rs.u8 = rs.u8Rem(arm, 6); if (_190 === 0) { - walk$iter_Filter_ops_Range_u64_hints_hints_closure1(rt.iterFilter(new rt.Range(0, n, rt.u64Step), (i21: rt.u64): boolean => { - return rt.u64Rem(i21, 2) === 0; + walk$iter_Filter_ops_Range_u64_hints_hints_closure1(rs.iterFilter(new rs.Range(0, n, rs.u64Step), (i21: rs.u64): boolean => { + return rs.u64Rem(i21, 2) === 0; }), steps, out); } else if (_190 === 1) { - walk$iter_FilterMap_ops_Range_u64_hints_hints_closure2(rt.iterFilterMap(new rt.Range(0, n, rt.u64Step), (i20: rt.u64): rt.u64 | undefined => { - return rt.u64CheckedSub(i20, 1); + walk$iter_FilterMap_ops_Range_u64_hints_hints_closure2(rs.iterFilterMap(new rs.Range(0, n, rs.u64Step), (i20: rs.u64): rs.u64 | undefined => { + return rs.u64CheckedSub(i20, 1); }), steps, out); } else if (_190 === 2) { - walkFront$iter_SkipWhile_ops_Range_u64_hints_hints_closure3(rt.iterSkipWhile(new rt.Range(0, n, rt.u64Step), (_253: rt.u64): boolean => { - return rt.u64Lt(_253, 2); + walkFront$iter_SkipWhile_ops_Range_u64_hints_hints_closure3(rs.iterSkipWhile(new rs.Range(0, n, rs.u64Step), (_253: rs.u64): boolean => { + return rs.u64Lt(_253, 2); }), steps, out); } else if (_190 === 3) { - walkFront$iter_TakeWhile_ops_Range_u64_hints_hints_closure4(rt.iterTakeWhile(new rt.Range(0, n, rt.u64Step), (_252: rt.u64): boolean => { - return rt.u64Lt(_252, 1); + walkFront$iter_TakeWhile_ops_Range_u64_hints_hints_closure4(rs.iterTakeWhile(new rs.Range(0, n, rs.u64Step), (_252: rs.u64): boolean => { + return rs.u64Lt(_252, 1); }), steps, out); } else if (_190 === 4) { - walkFront$iter_MapWhile_ops_Range_u64_hints_hints_closure5(rt.iterMapWhile(new rt.Range(0, n, rt.u64Step), (i17: rt.u64): rt.u64 | undefined => { - return rt.u64CheckedSub(i17, 1); + walkFront$iter_MapWhile_ops_Range_u64_hints_hints_closure5(rs.iterMapWhile(new rs.Range(0, n, rs.u64Step), (i17: rs.u64): rs.u64 | undefined => { + return rs.u64CheckedSub(i17, 1); }), steps, out); } else { - walkFront$iter_Filter_hints_Endless_hints_hints_closure6(rt.iterFilter(rt.iterFrom({ _0: n }, Endless.next$iter_Iterator), (_250: rt.u64): boolean => { + walkFront$iter_Filter_hints_Endless_hints_hints_closure6(rs.iterFilter(rs.iterFrom({ _0: n }, Endless.next$iter_Iterator), (_250: rs.u64): boolean => { return true; }), steps, out); } } else if (_37 === 9) { - const _204: rt.u8 = rt.u8Rem(arm, 6); + const _204: rs.u8 = rs.u8Rem(arm, 6); if (_204 === 0) { - walk$iter_Map_ops_Range_u64_hints_hints_closure7(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i16: rt.u64): rt.u64 => { - return rt.u64Add(i16, 1); + walk$iter_Map_ops_Range_u64_hints_hints_closure7(rs.iterMap(new rs.Range(0, n, rs.u64Step), (i16: rs.u64): rs.u64 => { + return rs.u64Add(i16, 1); }), steps, out); } else if (_204 === 1) { - walk$iter_Inspect_ops_Range_u64_hints_hints_closure8(rt.iterInspect(new rt.Range(0, n, rt.u64Step), (_248: rt.u64): undefined => {}), steps, out); + walk$iter_Inspect_ops_Range_u64_hints_hints_closure8(rs.iterInspect(new rs.Range(0, n, rs.u64Step), (_248: rs.u64): undefined => {}), steps, out); } else if (_204 === 2) { - walk$iter_Enumerate_ops_Range_u32(rt.iterEnumerate(new rt.Range(0, u32Of(n))), steps, out); + walk$iter_Enumerate_ops_Range_u32(rs.iterEnumerate(new rs.Range(0, u32Of(n))), steps, out); } else if (_204 === 3) { - walk$iter_Rev_ops_Range_u64(rt.iterRev(new rt.Range(0, n, rt.u64Step)), steps, out); + walk$iter_Rev_ops_Range_u64(rs.iterRev(new rs.Range(0, n, rs.u64Step)), steps, out); } else if (_204 === 4) { - walk$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); + walk$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), steps, out); } else { - walk$iter_Cloned_slice_Iter_u8(rt.iterCloned(rt.iterSlice(rt.byteSliceView(bytes))), steps, out); + walk$iter_Cloned_slice_Iter_u8(rs.iterCloned(rs.iterSlice(rs.byteSliceView(bytes))), steps, out); } } else if (_37 === 10) { - const _219: rt.u8 = rt.u8Rem(arm, 4); + const _219: rs.u8 = rs.u8Rem(arm, 4); if (_219 === 0) { - walkFront$iter_Fuse_hints_Endless(rt.iterFuse(rt.iterFrom({ _0: n }, Endless.next$iter_Iterator)), steps, out); + walkFront$iter_Fuse_hints_Endless(rs.iterFuse(rs.iterFrom({ _0: n }, Endless.next$iter_Iterator)), steps, out); } else if (_219 === 1) { - walkFront$iter_Fuse_iter_Take_hints_Endless(rt.iterFuse(rt.iterTake(rt.iterFrom({ _0: n }, Endless.next$iter_Iterator), 2)), steps, out); + walkFront$iter_Fuse_iter_Take_hints_Endless(rs.iterFuse(rs.iterTake(rs.iterFrom({ _0: n }, Endless.next$iter_Iterator), 2)), steps, out); } else if (_219 === 2) { - walk$iter_Fuse_ops_Range_u64(rt.iterFuse(new rt.Range(0, n, rt.u64Step), true), steps, out); + walk$iter_Fuse_ops_Range_u64(rs.iterFuse(new rs.Range(0, n, rs.u64Step), true), steps, out); } else { - walkFront$iter_Fuse_hints_Countdown(rt.iterFuse(rt.iterFrom({ _0: rt.u64Low(n) & 0xff }, Countdown.next$iter_Iterator)), steps, out); + walkFront$iter_Fuse_hints_Countdown(rs.iterFuse(rs.iterFrom({ _0: rs.u64Low(n) & 0xff }, Countdown.next$iter_Iterator)), steps, out); } } else if (_37 === 11) { - const it: rt.Peekable = rt.iterPeekable(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step))); + const it: rs.Peekable = rs.iterPeekable(rs.iterChain(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step))); put(out, it.sizeHint()); - const _240: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _240; + const _240: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _240; while (iterStart++ < iterEnd) { - rt.peekablePeek(it); + rs.peekablePeek(it); put(out, it.sizeHint()); it.next(); put(out, it.sizeHint()); } - const few: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - while (rt.iterToOption(few.next()) !== undefined) { + const few: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))); + while (rs.iterToOption(few.next()) !== undefined) { } - rt.peekablePeek(few); + rs.peekablePeek(few); put(out, few.sizeHint()); } else if (_37 === 12) { - const _267: rt.u8 = rt.u8Rem(arm, 7); + const _267: rs.u8 = rs.u8Rem(arm, 7); if (_267 === 0) { - walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure9(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i15: rt.u64): rt.u64[] => { - return Array.from({ length: 3 }, (): rt.u64 => { + walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure9(rs.iterFlatten(rs.iterMap(new rs.Range(0, n, rs.u64Step), (i15: rs.u64): rs.u64[] => { + return Array.from({ length: 3 }, (): rs.u64 => { return i15; }); - }), (value: rt.u64[]) => rt.iterSlice(value), true, 3), steps, out); + }), (value: rs.u64[]) => rs.iterSlice(value), true, 3), steps, out); } else if (_267 === 1) { - walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i14: rt.u64): rt.u64[] => { + walk$iter_FlatMap_ops_Range_u64_array1_u64_hints_hints_closure10(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (i14: rs.u64): rs.u64[] => { return [i14]; - }, (value: rt.u64[]) => rt.iterSlice(value), true, 1, true), steps, out); + }, (value: rs.u64[]) => rs.iterSlice(value), true, 1, true), steps, out); } else if (_267 === 2) { - walk$iter_Flatten_slice_Chunks_u8(rt.iterFlatten(rt.byteSliceChunks(bytes, 2), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), steps, out); + walk$iter_Flatten_slice_Chunks_u8(rs.iterFlatten(rs.byteSliceChunks(bytes, 2), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), steps, out); } else if (_267 === 3) { - walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(rt.iterFlatten(rt.iterMap(new rt.Range(0, rt.u64Min(n, 9), rt.u64Step), (i13: rt.u64): rt.Range => { - return new rt.Range(0, i13, rt.u64Step); + walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure11(rs.iterFlatten(rs.iterMap(new rs.Range(0, rs.u64Min(n, 9), rs.u64Step), (i13: rs.u64): rs.Range => { + return new rs.Range(0, i13, rs.u64Step); }), undefined, true), steps, out); } else if (_267 === 5) { - walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(rt.iterFlatten(rt.iterMap(new rt.Range(0, rt.u64Min(n, 9), rt.u64Step), (_247: rt.u64): Uint8Array => { + walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure12(rs.iterFlatten(rs.iterMap(new rs.Range(0, rs.u64Min(n, 9), rs.u64Step), (_247: rs.u64): Uint8Array => { return Uint8Array.of(); - }), (value: Uint8Array) => rt.iterSlice(value), true, 0, true), steps, out); + }), (value: Uint8Array) => rs.iterSlice(value), true, 0, true), steps, out); } else if (_267 === 6) { - put(out, rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (_i12: rt.u64): rt.u64[] => { + put(out, rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (_i12: rs.u64): rs.u64[] => { return []; - }, (value: rt.u64[]) => rt.iterSlice(value), true, 0, true).sizeHint()); + }, (value: rs.u64[]) => rs.iterSlice(value), true, 0, true).sizeHint()); } else { - walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_array2_u64_2_hints_hints_closure14(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i11: rt.u64): rt.Iter => { - const _514: rt.u64[] = Array.from({ length: 2 }, (): rt.u64 => { + walk$iter_FlatMap_ops_Range_u64_iter_Flatten_array_IntoIter_array2_u64_2_hints_hints_closure14(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (i11: rs.u64): rs.Iter => { + const _514: rs.u64[] = Array.from({ length: 2 }, (): rs.u64 => { return i11; }); - return rt.iterFlatten(rt.iterSlice(Array.from({ length: 2 }, (): rt.u64[] => { + return rs.iterFlatten(rs.iterSlice(Array.from({ length: 2 }, (): rs.u64[] => { return _514; - })), (value: rt.u64[]) => rt.iterSlice(value), true, 2); + })), (value: rs.u64[]) => rs.iterSlice(value), true, 2); }, undefined, true), steps, out); } } else if (_37 === 13) { - const _290: rt.u8 = rt.u8Rem(arm, 6); + const _290: rs.u8 = rs.u8Rem(arm, 6); if (_290 === 0) { - walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i10: rt.u64): rt.u64 | undefined => { - return rt.u64CheckedSub(i10, 2); - }), (value: rt.u64 | undefined) => rt.iterOption(value), true, undefined, true), steps, out); + walk$iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure15(rs.iterFlatten(rs.iterMap(new rs.Range(0, n, rs.u64Step), (i10: rs.u64): rs.u64 | undefined => { + return rs.u64CheckedSub(i10, 2); + }), (value: rs.u64 | undefined) => rs.iterOption(value), true, undefined, true), steps, out); } else if (_290 === 1) { - walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i9: rt.u64): rt.u64 | undefined => { - return thenSome$1ugl8af(rt.u64Rem(i9, 2) === 0, i9); - }, (value: rt.u64 | undefined) => rt.iterOption(value), true, undefined, true), steps, out); + walk$iter_FlatMap_ops_Range_u64_Option_u64_hints_hints_closure16(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (i9: rs.u64): rs.u64 | undefined => { + return thenSome$0be218t(rs.u64Rem(i9, 2) === 0, i9); + }, (value: rs.u64 | undefined) => rs.iterOption(value), true, undefined, true), steps, out); } else if (_290 === 2) { - walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (a0: rt.u64): rt.Iter => { - return rt.iterOnce(a0); + walk$iter_FlatMap_ops_Range_u64_iter_Once_u64_iter_once_u64(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (a0: rs.u64): rs.Iter => { + return rs.iterOnce(a0); }, undefined, true, undefined, true), steps, out); } else if (_290 === 3) { - walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_hints_hints_closure17_closure0_hints_hints_closure17(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i7: rt.u64): rt.Iter => { - return rt.iterFilter(rt.iterOption(i7), (i8: rt.u64): boolean => { - return rt.u64Rem(i8, 2) === 0; + walk$iter_FlatMap_ops_Range_u64_iter_Filter_option_IntoIter_u64_hints_hints_closure17_closure0_hints_hints_closure17(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (i7: rs.u64): rs.Iter => { + return rs.iterFilter(rs.iterOption(i7), (i8: rs.u64): boolean => { + return rs.u64Rem(i8, 2) === 0; }); }, undefined, true, undefined, true), steps, out); } else if (_290 === 4) { - walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_245: rt.u8): Uint8Array => { + walk$iter_Flatten_iter_Map_slice_Iter_u8_hints_hints_closure18(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_245: rs.u8): Uint8Array => { return Uint8Array.of(_245); - }), (value: Uint8Array) => rt.iterSlice(value), true, 1, true), steps, out); + }), (value: Uint8Array) => rs.iterSlice(value), true, 1, true), steps, out); } else { - walk$iter_Flatten_slice_Iter_array2_u8(rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_244: rt.u8): Uint8Array => { - const b5: rt.u8 = _244; + walk$iter_Flatten_slice_Iter_array2_u8(rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_244: rs.u8): Uint8Array => { + const b5: rs.u8 = _244; return Uint8Array.of(b5, b5); - }), undefined, 2, true).items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), steps, out); + }), undefined, 2, true).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), steps, out); } } else if (_37 === 14) { - const _312: rt.u8 = rt.u8Rem(arm, 6); + const _312: rs.u8 = rs.u8Rem(arm, 6); if (_312 === 0) { - walk$slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), steps, out); + walk$slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), steps, out); } else if (_312 === 1) { - walk$vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(bytes)), steps, out); + walk$vec_IntoIter_u8(rs.byteVecIntoIter(rs.byteSliceToByteVec(bytes)), steps, out); } else if (_312 === 2) { - walk$array_IntoIter_u8_3(rt.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); + walk$array_IntoIter_u8_3(rs.iterSlice(Uint8Array.of(at(3), at(4), at(5))), steps, out); } else if (_312 === 3) { - walk$option_IntoIter_ref_u8(rt.iterOption(rt.byteSliceFirst(bytes)), steps, out); + walk$option_IntoIter_ref_u8(rs.iterOption(rs.byteSliceFirst(bytes)), steps, out); } else if (_312 === 4) { - walk$iter_Once_u64(rt.iterOnce(n), steps, out); + walk$iter_Once_u64(rs.iterOnce(n), steps, out); } else { - rt.iterEmpty(); - walk$iter_Empty_u8(rt.iterEmpty() as rt.Iter, steps, out); + rs.iterEmpty(); + walk$iter_Empty_u8(rs.iterEmpty() as rs.Iter, steps, out); } } else if (_37 === 15) { - const _332: rt.u8 = rt.u8Rem(arm, 6); + const _332: rs.u8 = rs.u8Rem(arm, 6); if (_332 === 5) { - rt.iterFromFn((): rt.u8 | undefined => { + rs.iterFromFn((): rs.u8 | undefined => { return undefined; }); - walkFront$iter_FromFn_hints_hints_closure20(rt.iterFromFn((): rt.u8 | undefined => { + walkFront$iter_FromFn_hints_hints_closure20(rs.iterFromFn((): rs.u8 | undefined => { return undefined; }), steps, out); } else if (_332 === 0) { - walkFront$iter_Successors_u64_hints_hints_closure21(rt.iterSuccessors(rt.u64Rem(n, 4), (_242: rt.u64): rt.u64 | undefined => { - return rt.u64CheckedSub(_242, 1); + walkFront$iter_Successors_u64_hints_hints_closure21(rs.iterSuccessors(rs.u64Rem(n, 4), (_242: rs.u64): rs.u64 | undefined => { + return rs.u64CheckedSub(_242, 1); }), steps, out); } else if (_332 === 1) { - walkFront$iter_Successors_u8_hints_hints_closure22(rt.iterSuccessors(undefined as rt.u8 | undefined, (_237: rt.u8): rt.u8 | undefined => { + walkFront$iter_Successors_u8_hints_hints_closure22(rs.iterSuccessors(undefined as rs.u8 | undefined, (_237: rs.u8): rs.u8 | undefined => { return _237; }), steps, out); } else if (_332 === 2) { - walkFront$hints_Countdown({ _0: rt.u64Low(n) & 0xff }, steps, out); + walkFront$hints_Countdown({ _0: rs.u64Low(n) & 0xff }, steps, out); } else if (_332 === 3) { const captured = n; - walkFront$iter_FromFn_hints_hints_closure23(rt.iterFromFn((): rt.u64 | undefined => { + walkFront$iter_FromFn_hints_hints_closure23(rs.iterFromFn((): rs.u64 | undefined => { return captured; }), steps, out); } else { - const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + const it2: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); walk$mut_slice_Iter_u8(it2, steps, out); put(out, it2.sizeHint()); } } else if (_37 === 16) { - const s: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_29: rt.u8): rt.char => { - const _5: rt.usize = rt.u8Rem(_29, 4) as rt.usize; + const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_29: rs.u8): rs.char => { + const _5: rs.usize = rs.u8Rem(_29, 4) as rs.usize; if (!(_5 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _5); } return [97, 233, 128512, 2048][_5]; })); - const _355: rt.u8 = rt.u8Rem(arm, 4); + const _355: rs.u8 = rs.u8Rem(arm, 4); if (_355 === 0) { - walk$str_Chars(rt.strChars(s), steps, out); + walk$str_Chars(rs.strChars(s), steps, out); } else if (_355 === 1) { - walkFront$str_Split_char(rt.strSplit(s, "é"), steps, out); + walkFront$str_Split_char(rs.strSplit(s, "é"), steps, out); } else if (_355 === 2) { - walk$str_Bytes(rt.strBytes(s), steps, out); + walk$str_Bytes(rs.strBytes(s), steps, out); } else { let t: string = s; - const _379: rt.RangeFrom = new rt.RangeFrom(rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.usizeDiv(bytes.length, 2)))), (_231: rt.u8): rt.usize => { - const _512: rt.usize = rt.u8Rem(_231, 4) as rt.usize; + const _379: rs.RangeFrom = new rs.RangeFrom(rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.usizeDiv(bytes.length, 2)))), (_231: rs.u8): rs.usize => { + const _512: rs.usize = rs.u8Rem(_231, 4) as rs.usize; if (!(_512 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _512); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _512); } return [1, 2, 4, 3][_512]; - }), rt.usizeAdd, 0), rt.usizeStep); - walk$string_Drain(rt.stringDrain(rt.place(() => t, (value) => t = value), _379), steps, out); + }), rs.usizeAdd, 0), rs.usizeStep); + walk$string_Drain(rs.stringDrain(rs.place(() => t, (value) => t = value), _379), steps, out); } } else if (_37 === 17) { - const size: rt.usize = rt.usizeAdd(rt.usizeRem(at(1) as rt.usize, 4), 1); - const _388: rt.u8 = rt.u8Rem(arm, 5); + const size: rs.usize = rs.usizeAdd(rs.usizeRem(at(1) as rs.usize, 4), 1); + const _388: rs.u8 = rs.u8Rem(arm, 5); if (_388 === 0) { - walk$slice_Windows_u8(rt.byteSliceWindows(bytes, size), steps, out); + walk$slice_Windows_u8(rs.byteSliceWindows(bytes, size), steps, out); } else if (_388 === 1) { - walk$slice_Chunks_u8(rt.byteSliceChunks(bytes, size), steps, out); + walk$slice_Chunks_u8(rs.byteSliceChunks(bytes, size), steps, out); } else if (_388 === 2) { - walk$slice_ChunksExact_u8(rt.byteSliceChunksExact(bytes, size), steps, out); + walk$slice_ChunksExact_u8(rs.byteSliceChunksExact(bytes, size), steps, out); } else if (_388 === 3) { - walk$slice_RChunks_u8(rt.byteSliceRchunks(bytes, size), steps, out); + walk$slice_RChunks_u8(rs.byteSliceRchunks(bytes, size), steps, out); } else { - walk$slice_RChunksExact_u8(rt.byteSliceRchunksExact(bytes, size), steps, out); + walk$slice_RChunksExact_u8(rs.byteSliceRchunksExact(bytes, size), steps, out); } } else if (_37 === 18) { - const _396: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_27: rt.u8): [rt.u8, rt.u8] => { - const b2: rt.u8 = _27; - return [b2, b2] as [rt.u8, rt.u8]; + const _396: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_27: rs.u8): [rs.u8, rs.u8] => { + const b2: rs.u8 = _27; + return [b2, b2] as [rs.u8, rs.u8]; }); - const map: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _396, undefined, undefined, undefined, 469762048); - const _399: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _399, undefined, undefined, 469762048); - const _401: rt.u8 = rt.u8Rem(arm, 5); + const map: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _396, undefined, undefined, undefined, 469762048); + const _399: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _399, undefined, undefined, 469762048); + const _401: rs.u8 = rs.u8Rem(arm, 5); if (_401 === 0) { - walkFront$collections_hash_map_Iter_u8_u8(rt.hashIter(map), steps, out); + walkFront$collections_hash_map_Iter_u8_u8(rs.hashIter(map), steps, out); } else if (_401 === 1) { - walkFront$collections_hash_map_Keys_u8_u8(rt.hashKeys(map), steps, out); + walkFront$collections_hash_map_Keys_u8_u8(rs.hashKeys(map), steps, out); } else if (_401 === 2) { - walkFront$collections_hash_set_Iter_u8(rt.hashKeys(set), steps, out); + walkFront$collections_hash_set_Iter_u8(rs.hashKeys(set), steps, out); } else if (_401 === 3) { - walkFront$collections_hash_map_IntoIter_u8_u8(rt.hashIter(rt.hashClone(map, undefined, undefined)), steps, out); + walkFront$collections_hash_map_IntoIter_u8_u8(rs.hashIter(rs.hashClone(map, undefined, undefined)), steps, out); } else { - walkFront$collections_hash_map_Drain_u8_u8(rt.hashDrain(rt.hashClone(map, undefined, undefined)), steps, out); + walkFront$collections_hash_map_Drain_u8_u8(rs.hashDrain(rs.hashClone(map, undefined, undefined)), steps, out); } } else if (_37 === 19) { - const _417: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_26: rt.u8): [rt.u8, rt.u8] => { - const b: rt.u8 = _26; - return [b, b] as [rt.u8, rt.u8]; + const _417: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_26: rs.u8): [rs.u8, rs.u8] => { + const b: rs.u8 = _26; + return [b, b] as [rs.u8, rs.u8]; }); - const map2: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _417, true, undefined, undefined, undefined, 2, true); - const _420: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); - const set2: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _420, true, undefined, undefined, 1, true); - const _422: rt.u8 = rt.u8Rem(arm, 4); + const map2: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _417, true, undefined, undefined, undefined, 2, true); + const _420: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); + const set2: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _420, true, undefined, undefined, 1, true); + const _422: rs.u8 = rs.u8Rem(arm, 4); if (_422 === 0) { - walk$collections_btree_map_Iter_u8_u8(rt.btreeIter(map2), steps, out); + walk$collections_btree_map_Iter_u8_u8(rs.btreeIter(map2), steps, out); } else if (_422 === 1) { - const _428: rt.RangeFrom = new rt.RangeFrom(at(3), rt.u8Step); - walk$collections_btree_map_Range_u8_u8(rt.btreeRange(map2, _428), steps, out); + const _428: rs.RangeFrom = new rs.RangeFrom(at(3), rs.u8Step); + walk$collections_btree_map_Range_u8_u8(rs.btreeRange(map2, _428), steps, out); } else if (_422 === 2) { - walk$collections_btree_set_Iter_u8(rt.btreeKeys(set2), steps, out); + walk$collections_btree_set_Iter_u8(rs.btreeKeys(set2), steps, out); } else { - walk$collections_btree_map_Values_u8_u8(rt.btreeValues(map2), steps, out); + walk$collections_btree_map_Values_u8_u8(rs.btreeValues(map2), steps, out); } } else if (_37 === 20) { - const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), 1, true) as rt.VecDeque; - const v: rt.ByteVec = rt.byteSliceToByteVec(bytes); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterSlice(rt.byteSliceView(bytes)), undefined, 1, true), rt.le, rt.ge, rt.lt); - const half2: rt.usize = rt.usizeDiv(bytes.length, 2); - const _446: rt.u8 = rt.u8Rem(arm, 4); + const deque: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterSlice(rs.byteSliceView(bytes)), undefined, 1, true), 1, true) as rs.VecDeque; + const v: rs.ByteVec = rs.byteSliceToByteVec(bytes); + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(bytes)), undefined, 1, true), rs.le, rs.ge, rs.lt); + const half2: rs.usize = rs.usizeDiv(bytes.length, 2); + const _446: rs.u8 = rs.u8Rem(arm, 4); if (_446 === 0) { - walk$collections_vec_deque_Iter_u8(rt.dequeIter(deque), steps, out); + walk$collections_vec_deque_Iter_u8(rs.dequeIter(deque), steps, out); } else if (_446 === 1) { - walk$collections_vec_deque_Drain_u8(rt.dequeDrain(deque, new rt.RangeFrom(half2, rt.usizeStep)), steps, out); + walk$collections_vec_deque_Drain_u8(rs.dequeDrain(deque, new rs.RangeFrom(half2, rs.usizeStep)), steps, out); } else if (_446 === 2) { - walk$vec_Drain_u8(rt.byteVecDrain(v, { end: half2 }), steps, out); + walk$vec_Drain_u8(rs.byteVecDrain(v, { end: half2 }), steps, out); } else { - walk$collections_binary_heap_Iter_u8(rt.heapIter(heap), steps, out); + walk$collections_binary_heap_Iter_u8(rs.heapIter(heap), steps, out); } } else if (_37 === 21) { - const _458: rt.u8 = rt.u8Rem(arm, 4); + const _458: rs.u8 = rs.u8Rem(arm, 4); if (_458 === 0) { - walkFront$iter_Take_iter_Skip_iter_Chain_ops_Range_u64_ops_Range_u64(rt.iterTake(rt.iterSkip(rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)), 3), u32Of(n) as rt.usize), steps, out); + walkFront$iter_Take_iter_Skip_iter_Chain_ops_Range_u64_ops_Range_u64(rs.iterTake(rs.iterSkip(rs.iterChain(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step)), 3), u32Of(n) as rs.usize), steps, out); } else if (_458 === 1) { - walk$iter_StepBy_iter_Rev_iter_Zip_ops_Range_u32_ops_Range_u32(rt.iterStepBy(rt.iterRev(rt.iterZip(new rt.Range(0, u32Of(rt.u64Min(n, 9))), new rt.Range(0, u32Of(rt.u64Min(m, 9))), [false, false])), 2), steps, out); + walk$iter_StepBy_iter_Rev_iter_Zip_ops_Range_u32_ops_Range_u32(rs.iterStepBy(rs.iterRev(rs.iterZip(new rs.Range(0, u32Of(rs.u64Min(n, 9))), new rs.Range(0, u32Of(rs.u64Min(m, 9))), [false, false])), 2), steps, out); } else if (_458 === 2) { - walk$iter_Chain_iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure28_ops_Range_u64(rt.iterChain(rt.iterFlatten(rt.iterMap(new rt.Range(0, n, rt.u64Step), (i4: rt.u64): rt.u64[] => { - return Array.from({ length: 2 }, (): rt.u64 => { + walk$iter_Chain_iter_Flatten_iter_Map_ops_Range_u64_hints_hints_closure28_ops_Range_u64(rs.iterChain(rs.iterFlatten(rs.iterMap(new rs.Range(0, n, rs.u64Step), (i4: rs.u64): rs.u64[] => { + return Array.from({ length: 2 }, (): rs.u64 => { return i4; }); - }), (value: rt.u64[]) => rt.iterSlice(value), true, 2), new rt.Range(0, m, rt.u64Step)), steps, out); + }), (value: rs.u64[]) => rs.iterSlice(value), true, 2), new rs.Range(0, m, rs.u64Step)), steps, out); } else { - walkFront$iter_Peekable_iter_Filter_ops_Range_u64_hints_hints_closure29(rt.iterPeekable(rt.iterFilter(new rt.Range(0, n, rt.u64Step), (_22: rt.u64): boolean => { + walkFront$iter_Peekable_iter_Filter_ops_Range_u64_hints_hints_closure29(rs.iterPeekable(rs.iterFilter(new rs.Range(0, n, rs.u64Step), (_22: rs.u64): boolean => { return true; })), steps, out); } } else if (_37 === 22) { - const it3: rt.Iter = rt.iterChain(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step)); + const it3: rs.Iter = rs.iterChain(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step)); walk$mut_iter_Chain_ops_Range_u64_ops_Range_u64(it3, steps, out); put(out, it3.sizeHint()); } else { - const _492: rt.u8 = rt.u8Rem(arm, 3); + const _492: rs.u8 = rs.u8Rem(arm, 3); if (_492 === 0) { - walkFront$iter_Chain_iter_Map_iter_Zip_ops_Range_u64_ops_Range_u64_hints_hints_closure30_iter_Once_u64(rt.iterChain(rt.iterMap(rt.iterZip(new rt.Range(0, n, rt.u64Step), new rt.Range(0, m, rt.u64Step), "len"), (_2: [rt.u64, rt.u64]): rt.u64 => { + walkFront$iter_Chain_iter_Map_iter_Zip_ops_Range_u64_ops_Range_u64_hints_hints_closure30_iter_Once_u64(rs.iterChain(rs.iterMap(rs.iterZip(new rs.Range(0, n, rs.u64Step), new rs.Range(0, m, rs.u64Step), "len"), (_2: [rs.u64, rs.u64]): rs.u64 => { return _2[0]; - }), rt.iterOnce(0)), steps, out); + }), rs.iterOnce(0)), steps, out); } else if (_492 === 1) { - walkFront$iter_Skip_iter_Flatten_iter_Map_ops_Range_u32_hints_hints_closure31(rt.iterSkip(rt.iterFlatten(rt.iterMap(new rt.Range(0, u32Of(n)), (i3: rt.u32): rt.u32[] => { - return Array.from({ length: 2 }, (): rt.u32 => { + walkFront$iter_Skip_iter_Flatten_iter_Map_ops_Range_u32_hints_hints_closure31(rs.iterSkip(rs.iterFlatten(rs.iterMap(new rs.Range(0, u32Of(n)), (i3: rs.u32): rs.u32[] => { + return Array.from({ length: 2 }, (): rs.u32 => { return i3; }); - }), (value: rt.u32[]) => rt.iterSlice(value), true, 2), rt.usizeRem(rt.u64Low(m), 9)), steps, out); + }), (value: rs.u32[]) => rs.iterSlice(value), true, 2), rs.usizeRem(rs.u64Low(m), 9)), steps, out); } else { - walkFront$iter_Take_iter_FlatMap_ops_Range_u64_ops_Range_u64_hints_hints_closure32(rt.iterTake(rt.iterFlatMap(new rt.Range(0, n, rt.u64Step), (i2: rt.u64): rt.Range => { - return new rt.Range(0, i2, rt.u64Step); - }, undefined, true), rt.u64Low(m)), steps, out); + walkFront$iter_Take_iter_FlatMap_ops_Range_u64_ops_Range_u64_hints_hints_closure32(rs.iterTake(rs.iterFlatMap(new rs.Range(0, n, rs.u64Step), (i2: rs.u64): rs.Range => { + return new rs.Range(0, i2, rs.u64Step); + }, undefined, true), rs.u64Low(m)), steps, out); } } } @@ -2144,31 +2144,31 @@ export function hints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * a `TrustedLen` iterator, and after the first of another, which it reserves for again * whenever it fills. */ -export function reserves(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(rt.u8Div(kind, 13), 6); +export function reserves(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(rs.u8Div(kind, 13), 6); if (_4 === 0) { - typed$u8_hints_reserves_closure0(kind, data, (i5: rt.u32): rt.u8 => { + typed$u8_hints_reserves_closure0(kind, data, (i5: rs.u32): rs.u8 => { return i5 & 0xff; }, { vec: 2147483647, pairs: 268435455, set: 469762048, map: 117440512 }, out); } else if (_4 === 1) { - typed$u32_hints_reserves_closure1(kind, data, (i4: rt.u32): rt.u32 => { + typed$u32_hints_reserves_closure1(kind, data, (i4: rs.u32): rs.u32 => { return i4; }, { vec: 536870911, pairs: 268435455, set: 234881024, map: 117440512 }, out); } else if (_4 === 2) { - typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind, data, (i3: rt.u32): [rt.u8, rt.u8, rt.u8] => { - return [i3 & 0xff, 0, 0] as [rt.u8, rt.u8, rt.u8]; + typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind, data, (i3: rs.u32): [rs.u8, rs.u8, rs.u8] => { + return [i3 & 0xff, 0, 0] as [rs.u8, rs.u8, rs.u8]; }, { vec: 715827882, pairs: 268435455, set: 234881024, map: 117440512 }, out); } else if (_4 === 3) { - typed$tuple2_u64_u8_hints_reserves_closure3(kind, data, (i2: rt.u32): [rt.u64, rt.u8] => { - return [i2 as rt.u64, i2 & 0xff] as [rt.u64, rt.u8]; + typed$tuple2_u64_u8_hints_reserves_closure3(kind, data, (i2: rs.u32): [rs.u64, rs.u8] => { + return [i2 as rs.u64, i2 & 0xff] as [rs.u64, rs.u8]; }, { vec: 134217727, pairs: 89478485, set: 58720256, map: 58720256 }, out); } else if (_4 === 5) { - typed$hints_Unit_hints_reserves_closure4(kind, data, (_2: rt.u32): Unit.Unit => { + typed$hints_Unit_hints_reserves_closure4(kind, data, (_2: rs.u32): Unit.Unit => { return {}; }, { vec: 4294967295, pairs: 536870911, set: 536870911, map: 234881024 }, out); } else { - typed$array275_u32_hints_reserves_closure5(kind, data, (i: rt.u32): rt.u32[] => { - return Array.from({ length: 275 }, (): rt.u32 => { + typed$array275_u32_hints_reserves_closure5(kind, data, (i: rs.u32): rs.u32[] => { + return Array.from({ length: 275 }, (): rs.u32 => { return i; }); }, { vec: 1952257, pairs: 1945184, set: 917504, map: 917504 }, out); @@ -2176,2505 +2176,2505 @@ export function reserves(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** `reserves` of elements `make` makes. */ -export function typed$array275_u32_hints_reserves_closure5(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32[], most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$array275_u32_hints_reserves_closure5(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => rs.u32[], most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: rt.u32[] = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => rt.u32[] = (i2: rt.u32): rt.u32[] => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); + const seed: rs.u32[] = make(7); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => rs.u32[] = (i2: rs.u32): rs.u32[] => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32[]): boolean => { + fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: rs.u32[]): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$hints_Unit_hints_reserves_closure4(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => Unit.Unit, most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$hints_Unit_hints_reserves_closure4(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => Unit.Unit, most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); const seed: Unit.Unit = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => Unit.Unit = (i2: rt.u32): Unit.Unit => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => Unit.Unit = (i2: rs.u32): Unit.Unit => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4_hints_typed_closure2_hints_Unit_hints_reserves_closure4(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: Unit.Unit): boolean => { + fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4_hints_typed_closure2_hints_Unit_hints_reserves_closure4(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: Unit.Unit): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u64, rt.u8], most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$tuple2_u64_u8_hints_reserves_closure3(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => [rs.u64, rs.u8], most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: [rt.u64, rt.u8] = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => [rt.u64, rt.u8] = (i2: rt.u32): [rt.u64, rt.u8] => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); + const seed: [rs.u64, rs.u8] = make(7); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => [rs.u64, rs.u8] = (i2: rs.u32): [rs.u64, rs.u8] => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3_hints_typed_closure2_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: [rt.u64, rt.u8]): boolean => { + fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3_hints_typed_closure2_tuple2_u64_u8_hints_reserves_closure3(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: [rs.u64, rs.u8]): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8], most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$tuple3_u8_u8_u8_hints_reserves_closure2(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => [rs.u8, rs.u8, rs.u8], most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: [rt.u8, rt.u8, rt.u8] = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => [rt.u8, rt.u8, rt.u8] = (i2: rt.u32): [rt.u8, rt.u8, rt.u8] => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); + const seed: [rs.u8, rs.u8, rs.u8] = make(7); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => [rs.u8, rs.u8, rs.u8] = (i2: rs.u32): [rs.u8, rs.u8, rs.u8] => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2_hints_typed_closure2_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: [rt.u8, rt.u8, rt.u8]): boolean => { + fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2_hints_typed_closure2_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: [rs.u8, rs.u8, rs.u8]): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$u32_hints_reserves_closure1(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u32, most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$u32_hints_reserves_closure1(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => rs.u32, most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: rt.u32 = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => rt.u32 = (i2: rt.u32): rt.u32 => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); + const seed: rs.u32 = make(7); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => rs.u32 = (i2: rs.u32): rs.u32 => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1_hints_typed_closure2_u32_hints_reserves_closure1(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u32): boolean => { + fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1_hints_typed_closure2_u32_hints_reserves_closure1(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: rs.u32): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `reserves` of elements `make` makes. */ -export function typed$u8_hints_reserves_closure0(kind: rt.u8, data: rt.ByteSlice, make: (a0: rt.u32) => rt.u8, most: Most.Most, out: rt.ByteVec): void { - let _20!: [rt.u64, rt.u64]; - let past!: rt.u64; - let count!: rt.u64; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function typed$u8_hints_reserves_closure0(kind: rs.u8, data: rs.ByteSlice, make: (a0: rs.u32) => rs.u8, most: Most.Most, out: rs.ByteVec): void { + let _20!: [rs.u64, rs.u64]; + let past!: rs.u64; + let count!: rs.u64; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const coll: rt.u8 = rt.u8Rem(kind, 13); - const _11: rt.usize = rt.usizeRem(at(2) as rt.usize, 5); + const coll: rs.u8 = rs.u8Rem(kind, 13); + const _11: rs.usize = rs.usizeRem(at(2) as rs.usize, 5); if (!(_11 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _11); } - const limit: rt.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; + const limit: rs.u8 = Uint8Array.of(0, 1, 4, 5, 8)[_11]; if (coll === 0 || coll === 1 || coll === 3 || coll === 5 || coll === 11 || coll === 12) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 2 || coll === 4 || coll === 6) { - _20 = [2, most.vec] as [rt.u64, rt.u64]; + _20 = [2, most.vec] as [rs.u64, rs.u64]; } else if (coll === 7) { - _20 = [0, most.vec] as [rt.u64, rt.u64]; + _20 = [0, most.vec] as [rs.u64, rs.u64]; } else if (coll === 8) { - _20 = [0, most.set] as [rt.u64, rt.u64]; + _20 = [0, most.set] as [rs.u64, rs.u64]; } else if (coll === 9) { - _20 = [1, most.map] as [rt.u64, rt.u64]; + _20 = [1, most.map] as [rs.u64, rs.u64]; } else { - _20 = [0, most.pairs] as [rt.u64, rt.u64]; + _20 = [0, most.pairs] as [rs.u64, rs.u64]; } - const held: rt.u64 = _20[0]; - const most2: rt.u64 = _20[1]; + const held: rs.u64 = _20[0]; + const most2: rs.u64 = _20[1]; if (coll === 9) { - past = rt.u64Add(rt.u64Mul(2, rt.u64Sub(most2, held)), 1); + past = rs.u64Add(rs.u64Mul(2, rs.u64Sub(most2, held)), 1); } else { - past = rt.u64Add(rt.u64Sub(most2, held), 1); + past = rs.u64Add(rs.u64Sub(most2, held), 1); } - const shape: rt.u8 = rt.u8Rem(at(0), 5); - const _42: rt.u8 = rt.u8Rem(at(1), 4); + const shape: rs.u8 = rs.u8Rem(at(0), 5); + const _42: rs.u8 = rs.u8Rem(at(1), 4); if (_42 === 0) { count = 3; } else if (_42 === 1) { - count = rt.u64Add(past, shape === 1 ? 1 : 0); + count = rs.u64Add(past, shape === 1 ? 1 : 0); } else if (_42 === 2) { - count = 4294967295 as rt.u64; + count = 4294967295 as rs.u64; } else { count = 4294967296; } - const last: rt.u32 = rt.resultUnwrap(rt.u32TryFrom(rt.u64Sub(rt.u64Min(count, 4294967296), 1)), rt.fmtTryFromIntErrorDebug); - const seed: rt.u8 = make(7); - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => rt.u8 = (i2: rt.u32): rt.u8 => { - rt.cellSet(calls, rt.u8Add(calls.v, 1)); + const last: rs.u32 = rs.resultUnwrap(rs.u32TryFrom(rs.u64Sub(rs.u64Min(count, 4294967296), 1)), rs.fmtTryFromIntErrorDebug); + const seed: rs.u8 = make(7); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => rs.u8 = (i2: rs.u32): rs.u8 => { + rs.cellSet(calls, rs.u8Add(calls.v, 1)); if (!(calls.v <= limit)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { return make(i2); } }; if (shape === 0) { - fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), seed, out); + fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll, rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), seed, out); } else if (shape === 1) { - fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterSkip(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), 1), seed, out); + fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll, rs.iterSkip(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), 1), seed, out); } else if (shape === 2) { - fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0_hints_typed_closure2_u8_hints_reserves_closure0(coll, rt.iterFilter(rt.iterMap(new rt.RangeInclusive(0, last, rt.u32Step), f), (_2: rt.u8): boolean => { + fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0_hints_typed_closure2_u8_hints_reserves_closure0(coll, rs.iterFilter(rs.iterMap(new rs.RangeInclusive(0, last, rs.u32Step), f), (_2: rs.u8): boolean => { return true; }), seed, out); } else if (shape === 3) { - fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } else { - fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll, rt.iterMap(rt.iterFlatten(rt.iterSlice([new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, 2, rt.u32Step), new rt.RangeInclusive(0, last, rt.u32Step)]), undefined, true), f), seed, out); + fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll, rs.iterMap(rs.iterFlatten(rs.iterSlice([new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, 2, rs.u32Step), new rs.RangeInclusive(0, last, rs.u32Step)]), undefined, true), f), seed, out); } - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, calls.v); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$array275_u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5_hints_typed_closure2_array275_u32_hints_reserves_closure5(coll: rs.u8, items: rs.Iter, seed: rs.u32[], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 1100).items.length; + len = rs.iterToVec(items, "next", 1100).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 1100); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 1100); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1100), 1100) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 1100) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { - const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { - return [t3, 1] as [rt.u32[], rt.u32]; + const _41: [rs.u32[], rs.u32][] = [[seed, 0] as [rs.u32[], rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t3: rs.u32[]): [rs.u32[], rs.u32] => { + return [t3, 1] as [rs.u32[], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { - return [t2, 1] as [rt.u32[], rt.u32]; + const _50: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t2: rs.u32[]): [rs.u32[], rs.u32] => { + return [t2, 1] as [rs.u32[], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap, _50, true, undefined, undefined, "next", 1104)); } else if (coll === 11) { - len = option_mapOr$1imnnei(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + len = option_mapOr$1srande(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32[]): rs.u32[] | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32[] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32[]]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32[] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rs.u8, items: rs.Iter, seed: rs.u32[], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 1100).items.length; + len = rs.iterToVec(items, "next", 1100).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 1100); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 1100); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1100), 1100) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 1100) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { - const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { - return [t3, 1] as [rt.u32[], rt.u32]; + const _41: [rs.u32[], rs.u32][] = [[seed, 0] as [rs.u32[], rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t3: rs.u32[]): [rs.u32[], rs.u32] => { + return [t3, 1] as [rs.u32[], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { - return [t2, 1] as [rt.u32[], rt.u32]; + const _50: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t2: rs.u32[]): [rs.u32[], rs.u32] => { + return [t2, 1] as [rs.u32[], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap, _50, true, undefined, undefined, "next", 1104)); } else if (coll === 11) { - len = option_mapOr$1imnnei(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + len = option_mapOr$1srande(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32[]): rs.u32[] | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32[] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32[]]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32[] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$array275_u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rs.u8, items: rs.Iter, seed: rs.u32[], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 1100).items.length; + len = rs.iterToVec(items, "next", 1100).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 1100); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 1100); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1100), 1100) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 1100) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { - const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { - return [t3, 1] as [rt.u32[], rt.u32]; + const _41: [rs.u32[], rs.u32][] = [[seed, 0] as [rs.u32[], rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t3: rs.u32[]): [rs.u32[], rs.u32] => { + return [t3, 1] as [rs.u32[], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { - return [t2, 1] as [rt.u32[], rt.u32]; + const _50: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t2: rs.u32[]): [rs.u32[], rs.u32] => { + return [t2, 1] as [rs.u32[], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap, _50, true, undefined, undefined, "next", 1104)); } else if (coll === 11) { - len = option_mapOr$1imnnei(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + len = option_mapOr$1srande(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32[]): rs.u32[] | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32[] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32[]]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32[] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$array275_u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rs.u8, items: rs.Iter, seed: rs.u32[], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, undefined, 1100, true).items.length; + len = rs.iterToVec(items, undefined, 1100, true).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, undefined, 1100, true); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, undefined, 1100, true); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 1100, true); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, undefined, 1100, true); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 1100, true), 1100) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 1100, true), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 1100) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 1100, true), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 1100, true), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), undefined, 1100, true); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), undefined, 1100, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, undefined, 1100, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, items, true, undefined, undefined, 1100, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { - const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { - return [t3, 1] as [rt.u32[], rt.u32]; + const _41: [rs.u32[], rs.u32][] = [[seed, 0] as [rs.u32[], rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t3: rs.u32[]): [rs.u32[], rs.u32] => { + return [t3, 1] as [rs.u32[], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { - return [t2, 1] as [rt.u32[], rt.u32]; + const _50: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t2: rs.u32[]): [rs.u32[], rs.u32] => { + return [t2, 1] as [rs.u32[], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 1104, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap, _50, true, undefined, undefined, undefined, 1104, true)); } else if (coll === 11) { - len = option_mapOr$1imnnei(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + len = option_mapOr$1srande(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32[]): rs.u32[] | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 1100)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 1100)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32[] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32[]]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32[] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 1100)); + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 1100)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rt.u8, items: rt.Iter, seed: rt.u32[], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$array275_u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_array275_u32_hints_reserves_closure5(coll: rs.u8, items: rs.Iter, seed: rs.u32[], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 1100).items.length; + len = rs.iterToVec(items, "next", 1100).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 1100); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 1100); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 1100); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 1100); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1100), 1100) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1100), 1100) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 1100) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 1100) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1100), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1100), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpSlice(rt.cmp)), rt.cmpGe(rt.cmpSlice(rt.cmp)), rt.cmpLt(rt.cmpSlice(rt.cmp)), "next", 1100); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpSlice(rs.cmp)), rs.cmpGe(rs.cmpSlice(rs.cmp)), rs.cmpLt(rs.cmpSlice(rs.cmp)), "next", 1100); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, items, true, undefined, "next", 1100)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, items, true, undefined, "next", 1100)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet, items, undefined, undefined, 917504)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet, items, undefined, undefined, 917504)); } else if (coll === 9) { - const _41: [rt.u32[], rt.u32][] = [[seed, 0] as [rt.u32[], rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 917504); - const _46: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t3: rt.u32[]): [rt.u32[], rt.u32] => { - return [t3, 1] as [rt.u32[], rt.u32]; + const _41: [rs.u32[], rs.u32][] = [[seed, 0] as [rs.u32[], rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 917504); + const _46: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t3: rs.u32[]): [rs.u32[], rs.u32] => { + return [t3, 1] as [rs.u32[], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 917504); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 917504); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32[], rt.u32]> = rt.iterMap(items, (t2: rt.u32[]): [rt.u32[], rt.u32] => { - return [t2, 1] as [rt.u32[], rt.u32]; + const _50: rs.Iter<[rs.u32[], rs.u32]> = rs.iterMap(items, (t2: rs.u32[]): [rs.u32[], rs.u32] => { + return [t2, 1] as [rs.u32[], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap, _50, true, undefined, undefined, "next", 1104)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap, _50, true, undefined, undefined, "next", 1104)); } else if (coll === 11) { - len = option_mapOr$1imnnei(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32[]): rt.u32[] | undefined => { + len = option_mapOr$1srande(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32[]): rs.u32[] | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32[]]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32[] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32[]]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32[] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 1100)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 1100)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4_hints_typed_closure2_hints_Unit_hints_reserves_closure4(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$hints_Unit_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4_hints_typed_closure2_hints_Unit_hints_reserves_closure4(coll: rs.u8, items: rs.Iter, seed: Unit.Unit, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 0).items.length; + len = rs.iterToVec(items, "next", 0).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 0); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 0); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); - rt.iterExtend(v2, items, "next", 0); + const v2: rs.Vec = rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); + rs.iterExtend(v2, items, "next", 0); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 0), 0) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 0), 0) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 0), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 0), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)); + rs.heapExtend(h, items, rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeSet, items, true, undefined, "next", 0)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeSet, items, true, undefined, "next", 0)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashSet, items, undefined, undefined, 536870911)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashSet, items, undefined, undefined, 536870911)); } else if (coll === 9) { - const _41: [Unit.Unit, rt.u32][] = [[seed, 0] as [Unit.Unit, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 234881024); - const _46: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t3, 1] as [Unit.Unit, rt.u32]; + const _41: [Unit.Unit, rs.u32][] = [[seed, 0] as [Unit.Unit, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 234881024); + const _46: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t3, 1] as [Unit.Unit, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 234881024); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 234881024); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t2, 1] as [Unit.Unit, rt.u32]; + const _50: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t2, 1] as [Unit.Unit, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeMap, _50, true, undefined, undefined, "next", 4)); } else if (coll === 11) { - len = option_mapOr$0v5bfoa(rt.iterCollectOption(rt.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { + len = option_mapOr$1jtsi2n(rs.iterCollectOption(rs.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Unit.Unit]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, Unit.Unit]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; const t: Unit.Unit = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rs.u8, items: rs.Iter, seed: Unit.Unit, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 0).items.length; + len = rs.iterToVec(items, "next", 0).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 0); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 0); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); - rt.iterExtend(v2, items, "next", 0); + const v2: rs.Vec = rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); + rs.iterExtend(v2, items, "next", 0); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 0), 0) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 0), 0) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 0), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 0), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)); + rs.heapExtend(h, items, rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeSet, items, true, undefined, "next", 0)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeSet, items, true, undefined, "next", 0)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashSet, items, undefined, undefined, 536870911)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashSet, items, undefined, undefined, 536870911)); } else if (coll === 9) { - const _41: [Unit.Unit, rt.u32][] = [[seed, 0] as [Unit.Unit, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 234881024); - const _46: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t3, 1] as [Unit.Unit, rt.u32]; + const _41: [Unit.Unit, rs.u32][] = [[seed, 0] as [Unit.Unit, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 234881024); + const _46: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t3, 1] as [Unit.Unit, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 234881024); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 234881024); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t2, 1] as [Unit.Unit, rt.u32]; + const _50: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t2, 1] as [Unit.Unit, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeMap, _50, true, undefined, undefined, "next", 4)); } else if (coll === 11) { - len = option_mapOr$0v5bfoa(rt.iterCollectOption(rt.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { + len = option_mapOr$1jtsi2n(rs.iterCollectOption(rs.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Unit.Unit]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, Unit.Unit]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; const t: Unit.Unit = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$hints_Unit_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rs.u8, items: rs.Iter, seed: Unit.Unit, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 0).items.length; + len = rs.iterToVec(items, "next", 0).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 0); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 0); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); - rt.iterExtend(v2, items, "next", 0); + const v2: rs.Vec = rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); + rs.iterExtend(v2, items, "next", 0); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 0), 0) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 0), 0) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 0), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 0), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)); + rs.heapExtend(h, items, rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeSet, items, true, undefined, "next", 0)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeSet, items, true, undefined, "next", 0)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashSet, items, undefined, undefined, 536870911)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashSet, items, undefined, undefined, 536870911)); } else if (coll === 9) { - const _41: [Unit.Unit, rt.u32][] = [[seed, 0] as [Unit.Unit, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 234881024); - const _46: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t3, 1] as [Unit.Unit, rt.u32]; + const _41: [Unit.Unit, rs.u32][] = [[seed, 0] as [Unit.Unit, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 234881024); + const _46: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t3, 1] as [Unit.Unit, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 234881024); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 234881024); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t2, 1] as [Unit.Unit, rt.u32]; + const _50: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t2, 1] as [Unit.Unit, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeMap, _50, true, undefined, undefined, "next", 4)); } else if (coll === 11) { - len = option_mapOr$0v5bfoa(rt.iterCollectOption(rt.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { + len = option_mapOr$1jtsi2n(rs.iterCollectOption(rs.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Unit.Unit]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, Unit.Unit]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; const t: Unit.Unit = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$hints_Unit_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rs.u8, items: rs.Iter, seed: Unit.Unit, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, undefined, 0, true).items.length; + len = rs.iterToVec(items, undefined, 0, true).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, undefined, 0, true); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, undefined, 0, true); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); - rt.iterExtend(v2, items, undefined, 0, true); + const v2: rs.Vec = rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); + rs.iterExtend(v2, items, undefined, 0, true); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 0, true), 0) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 0, true), 0) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rs.VecDeque; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 0, true), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 0, true), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd), undefined, 0, true); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)); + rs.heapExtend(h, items, rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd), undefined, 0, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeSet, items, true, undefined, undefined, 0, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeSet, items, true, undefined, undefined, 0, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashSet, items, undefined, undefined, 536870911)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashSet, items, undefined, undefined, 536870911)); } else if (coll === 9) { - const _41: [Unit.Unit, rt.u32][] = [[seed, 0] as [Unit.Unit, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 234881024); - const _46: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t3, 1] as [Unit.Unit, rt.u32]; + const _41: [Unit.Unit, rs.u32][] = [[seed, 0] as [Unit.Unit, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 234881024); + const _46: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t3, 1] as [Unit.Unit, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 234881024); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 234881024); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t2, 1] as [Unit.Unit, rt.u32]; + const _50: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t2, 1] as [Unit.Unit, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 4, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeMap, _50, true, undefined, undefined, undefined, 4, true)); } else if (coll === 11) { - len = option_mapOr$0v5bfoa(rt.iterCollectOption(rt.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { + len = option_mapOr$1jtsi2n(rs.iterCollectOption(rs.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 0)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 0)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Unit.Unit]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, Unit.Unit]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; const t: Unit.Unit = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 0)); + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 0)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rt.u8, items: rt.Iter, seed: Unit.Unit, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$hints_Unit_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_hints_Unit_hints_reserves_closure4(coll: rs.u8, items: rs.Iter, seed: Unit.Unit, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 0).items.length; + len = rs.iterToVec(items, "next", 0).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 0); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 0); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); - rt.iterExtend(v2, items, "next", 0); + const v2: rs.Vec = rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone); + rs.iterExtend(v2, items, "next", 0); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 0), 0) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 0), 0) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), 0) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 0), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 0), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd)); - rt.heapExtend(h, items, rt.cmpLe(Unit.partialCmp$cmp_PartialOrd), rt.cmpGe(Unit.partialCmp$cmp_PartialOrd), rt.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(Unit.clone$Clone(seed), 2, Unit.clone$Clone), rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd)); + rs.heapExtend(h, items, rs.cmpLe(Unit.partialCmp$cmp_PartialOrd), rs.cmpGe(Unit.partialCmp$cmp_PartialOrd), rs.cmpLt(Unit.partialCmp$cmp_PartialOrd), "next", 0); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeSet, items, true, undefined, "next", 0)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeSet, items, true, undefined, "next", 0)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashSet, items, undefined, undefined, 536870911)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashSet, items, undefined, undefined, 536870911)); } else if (coll === 9) { - const _41: [Unit.Unit, rt.u32][] = [[seed, 0] as [Unit.Unit, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rt.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 234881024); - const _46: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t3, 1] as [Unit.Unit, rt.u32]; + const _41: [Unit.Unit, rs.u32][] = [[seed, 0] as [Unit.Unit, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(Unit.hash$Hash_hash_DefaultHasher as (a0: Unit.Unit, a1: rs.Hasher) => undefined, Unit.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 234881024); + const _46: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t3: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t3, 1] as [Unit.Unit, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 234881024); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 234881024); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[Unit.Unit, rt.u32]> = rt.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rt.u32] => { - return [t2, 1] as [Unit.Unit, rt.u32]; + const _50: rs.Iter<[Unit.Unit, rs.u32]> = rs.iterMap(items, (t2: Unit.Unit): [Unit.Unit, rs.u32] => { + return [t2, 1] as [Unit.Unit, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(Unit.cmp$cmp_Ord) as rt.BTreeMap, _50, true, undefined, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(Unit.cmp$cmp_Ord) as rs.BTreeMap, _50, true, undefined, undefined, "next", 4)); } else if (coll === 11) { - len = option_mapOr$0v5bfoa(rt.iterCollectOption(rt.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { + len = option_mapOr$1jtsi2n(rs.iterCollectOption(rs.iterMap(items, (a0: Unit.Unit): Unit.Unit | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, Unit.Unit]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, Unit.Unit]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; const t: Unit.Unit = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3_hints_typed_closure2_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple2_u64_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3_hints_typed_closure2_tuple2_u64_u8_hints_reserves_closure3(coll: rs.u8, items: rs.Iter<[rs.u64, rs.u8]>, seed: [rs.u64, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 16).items.length; + len = rs.iterToVec(items, "next", 16).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u64, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 16); + const v: rs.Vec<[rs.u64, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 16); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 16); + const v2: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 16); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 16), 16) as rs.VecDeque<[rs.u64, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 16), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), "next", 16); + const h: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), "next", 16); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 16)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u64, rs.u8]>, items, true, undefined, "next", 16)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashSet<[rs.u64, rs.u8]>, items, undefined, undefined, 58720256)); } else if (coll === 9) { - const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); - const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + const _41: [[rs.u64, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u64, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u64, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashMap<[rs.u64, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u64, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u64, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 24)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u64, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 24)); } else if (coll === 11) { - len = option_mapOr$0iae8yu(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + len = option_mapOr$1tgduhr(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u64, rs.u8]): [rs.u64, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)), 255, (v4: rt.Vec<[rt.u64, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)), 255, (v4: rs.Vec<[rs.u64, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u64, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u64, rs.u8]]): rs.Result<[rs.u64, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u64, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u64, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)); + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rs.u8, items: rs.Iter<[rs.u64, rs.u8]>, seed: [rs.u64, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 16).items.length; + len = rs.iterToVec(items, "next", 16).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u64, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 16); + const v: rs.Vec<[rs.u64, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 16); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 16); + const v2: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 16); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 16), 16) as rs.VecDeque<[rs.u64, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 16), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), "next", 16); + const h: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), "next", 16); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 16)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u64, rs.u8]>, items, true, undefined, "next", 16)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashSet<[rs.u64, rs.u8]>, items, undefined, undefined, 58720256)); } else if (coll === 9) { - const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); - const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + const _41: [[rs.u64, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u64, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u64, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashMap<[rs.u64, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u64, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u64, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 24)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u64, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 24)); } else if (coll === 11) { - len = option_mapOr$0iae8yu(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + len = option_mapOr$1tgduhr(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u64, rs.u8]): [rs.u64, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)), 255, (v4: rt.Vec<[rt.u64, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)), 255, (v4: rs.Vec<[rs.u64, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u64, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u64, rs.u8]]): rs.Result<[rs.u64, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u64, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u64, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)); + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple2_u64_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rs.u8, items: rs.Iter<[rs.u64, rs.u8]>, seed: [rs.u64, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 16).items.length; + len = rs.iterToVec(items, "next", 16).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u64, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 16); + const v: rs.Vec<[rs.u64, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 16); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 16); + const v2: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 16); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 16), 16) as rs.VecDeque<[rs.u64, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 16), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), "next", 16); + const h: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), "next", 16); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 16)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u64, rs.u8]>, items, true, undefined, "next", 16)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashSet<[rs.u64, rs.u8]>, items, undefined, undefined, 58720256)); } else if (coll === 9) { - const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); - const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + const _41: [[rs.u64, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u64, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u64, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashMap<[rs.u64, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u64, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u64, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 24)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u64, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 24)); } else if (coll === 11) { - len = option_mapOr$0iae8yu(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + len = option_mapOr$1tgduhr(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u64, rs.u8]): [rs.u64, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)), 255, (v4: rt.Vec<[rt.u64, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)), 255, (v4: rs.Vec<[rs.u64, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u64, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u64, rs.u8]]): rs.Result<[rs.u64, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u64, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u64, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)); + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple2_u64_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rs.u8, items: rs.Iter<[rs.u64, rs.u8]>, seed: [rs.u64, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, undefined, 16, true).items.length; + len = rs.iterToVec(items, undefined, 16, true).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u64, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, undefined, 16, true); + const v: rs.Vec<[rs.u64, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, undefined, 16, true); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 16, true); + const v2: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, undefined, 16, true); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 16, true), 16) as rt.VecDeque<[rt.u64, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 16, true), 16) as rs.VecDeque<[rs.u64, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 16, true), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 16, true), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), undefined, 16, true); + const h: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 16, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, undefined, 16, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u64, rs.u8]>, items, true, undefined, undefined, 16, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashSet<[rs.u64, rs.u8]>, items, undefined, undefined, 58720256)); } else if (coll === 9) { - const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); - const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + const _41: [[rs.u64, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u64, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u64, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashMap<[rs.u64, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u64, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u64, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 24, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u64, rs.u8], rs.u32>, _50, true, undefined, undefined, undefined, 24, true)); } else if (coll === 11) { - len = option_mapOr$0iae8yu(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + len = option_mapOr$1tgduhr(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u64, rs.u8]): [rs.u64, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, undefined, 16)), 255, (v4: rt.Vec<[rt.u64, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, undefined, 16)), 255, (v4: rs.Vec<[rs.u64, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u64, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u64, rs.u8]]): rs.Result<[rs.u64, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u64, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u64, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, undefined, 16)); + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, undefined, 16)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rt.u8, items: rt.Iter<[rt.u64, rt.u8]>, seed: [rt.u64, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple2_u64_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple2_u64_u8_hints_reserves_closure3(coll: rs.u8, items: rs.Iter<[rs.u64, rs.u8]>, seed: [rs.u64, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 16).items.length; + len = rs.iterToVec(items, "next", 16).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u64, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 16); + const v: rs.Vec<[rs.u64, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 16); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u64, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 16); + const v2: rs.Vec<[rs.u64, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 16); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 16), 16) as rt.VecDeque<[rt.u64, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 16), 16) as rs.VecDeque<[rs.u64, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u64, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 16) as rt.VecDeque<[rt.u64, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u64, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 16) as rs.VecDeque<[rs.u64, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 16), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 16), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u64, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), "next", 16); + const h: rs.BinaryHeap<[rs.u64, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), "next", 16); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u64, rt.u8]>, items, true, undefined, "next", 16)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u64, rs.u8]>, items, true, undefined, "next", 16)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashSet<[rt.u64, rt.u8]>, items, undefined, undefined, 58720256)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashSet<[rs.u64, rs.u8]>, items, undefined, undefined, 58720256)); } else if (coll === 9) { - const _41: [[rt.u64, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u64, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u64, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash64, rt.hash8]), rt.eqTuple([rt.u64Eq, rt.same]))) as rt.HashMap<[rt.u64, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 58720256); - const _46: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u64, rt.u8], rt.u32]; + const _41: [[rs.u64, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u64, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u64, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash64, rs.hash8]), rs.eqTuple([rs.u64Eq, rs.same]))) as rs.HashMap<[rs.u64, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 58720256); + const _46: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u64, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 58720256); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 58720256); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u64, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u64, rt.u8]): [[rt.u64, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u64, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u64, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u64, rs.u8]): [[rs.u64, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u64, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u64, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u64, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 24)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u64, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u64, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 24)); } else if (coll === 11) { - len = option_mapOr$0iae8yu(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u64, rt.u8]): [rt.u64, rt.u8] | undefined => { + len = option_mapOr$1tgduhr(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u64, rs.u8]): [rs.u64, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)), 255, (v4: rt.Vec<[rt.u64, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)), 255, (v4: rs.Vec<[rs.u64, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u64, rt.u8]]): rt.Result<[rt.u64, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u64, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u64, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u64, rs.u8]]): rs.Result<[rs.u64, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u64, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u64, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u64, rt.u8]>) => rt.iterToVec(values, "next", 16)); + }), (values: rs.Iter<[rs.u64, rs.u8]>) => rs.iterToVec(values, "next", 16)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2_hints_typed_closure2_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple3_u8_u8_u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2_hints_typed_closure2_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rs.u8, items: rs.Iter<[rs.u8, rs.u8, rs.u8]>, seed: [rs.u8, rs.u8, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 3).items.length; + len = rs.iterToVec(items, "next", 3).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u8, rt.u8, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 3); + const v: rs.Vec<[rs.u8, rs.u8, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 3); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u8, rt.u8, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 3); + const v2: rs.Vec<[rs.u8, rs.u8, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 3); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 3), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u8, rs.u8, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 3), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); + const h: rs.BinaryHeap<[rs.u8, rs.u8, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), "next", 3); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, "next", 3)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.u8, rs.u8]>, items, true, undefined, "next", 3)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashSet<[rs.u8, rs.u8, rs.u8]>, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _41: [[rs.u8, rs.u8, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u8, rs.u8, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$1tx3bdh(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + len = option_mapOr$0vgdmy4(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u8, rs.u8, rs.u8]): [rs.u8, rs.u8, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)), 255, (v4: rt.Vec<[rt.u8, rt.u8, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)), 255, (v4: rs.Vec<[rs.u8, rs.u8, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u8, rs.u8, rs.u8]]): rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u8, rs.u8, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)); + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rs.u8, items: rs.Iter<[rs.u8, rs.u8, rs.u8]>, seed: [rs.u8, rs.u8, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 3).items.length; + len = rs.iterToVec(items, "next", 3).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u8, rt.u8, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 3); + const v: rs.Vec<[rs.u8, rs.u8, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 3); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u8, rt.u8, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 3); + const v2: rs.Vec<[rs.u8, rs.u8, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 3); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 3), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u8, rs.u8, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 3), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); + const h: rs.BinaryHeap<[rs.u8, rs.u8, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), "next", 3); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, "next", 3)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.u8, rs.u8]>, items, true, undefined, "next", 3)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashSet<[rs.u8, rs.u8, rs.u8]>, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _41: [[rs.u8, rs.u8, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u8, rs.u8, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$1tx3bdh(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + len = option_mapOr$0vgdmy4(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u8, rs.u8, rs.u8]): [rs.u8, rs.u8, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)), 255, (v4: rt.Vec<[rt.u8, rt.u8, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)), 255, (v4: rs.Vec<[rs.u8, rs.u8, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u8, rs.u8, rs.u8]]): rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u8, rs.u8, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)); + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple3_u8_u8_u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rs.u8, items: rs.Iter<[rs.u8, rs.u8, rs.u8]>, seed: [rs.u8, rs.u8, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 3).items.length; + len = rs.iterToVec(items, "next", 3).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u8, rt.u8, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 3); + const v: rs.Vec<[rs.u8, rs.u8, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 3); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u8, rt.u8, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 3); + const v2: rs.Vec<[rs.u8, rs.u8, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 3); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 3), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u8, rs.u8, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 3), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); + const h: rs.BinaryHeap<[rs.u8, rs.u8, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), "next", 3); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, "next", 3)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.u8, rs.u8]>, items, true, undefined, "next", 3)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashSet<[rs.u8, rs.u8, rs.u8]>, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _41: [[rs.u8, rs.u8, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u8, rs.u8, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$1tx3bdh(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + len = option_mapOr$0vgdmy4(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u8, rs.u8, rs.u8]): [rs.u8, rs.u8, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)), 255, (v4: rt.Vec<[rt.u8, rt.u8, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)), 255, (v4: rs.Vec<[rs.u8, rs.u8, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u8, rs.u8, rs.u8]]): rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u8, rs.u8, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)); + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple3_u8_u8_u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rs.u8, items: rs.Iter<[rs.u8, rs.u8, rs.u8]>, seed: [rs.u8, rs.u8, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, undefined, 3, true).items.length; + len = rs.iterToVec(items, undefined, 3, true).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u8, rt.u8, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, undefined, 3, true); + const v: rs.Vec<[rs.u8, rs.u8, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, undefined, 3, true); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u8, rt.u8, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 3, true); + const v2: rs.Vec<[rs.u8, rs.u8, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, undefined, 3, true); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 3, true), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 3, true), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque<[rs.u8, rs.u8, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 3, true), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 3, true), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), undefined, 3, true); + const h: rs.BinaryHeap<[rs.u8, rs.u8, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), undefined, 3, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, undefined, 3, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.u8, rs.u8]>, items, true, undefined, undefined, 3, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashSet<[rs.u8, rs.u8, rs.u8]>, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _41: [[rs.u8, rs.u8, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u8, rs.u8, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, undefined, 8, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8, rs.u8], rs.u32>, _50, true, undefined, undefined, undefined, 8, true)); } else if (coll === 11) { - len = option_mapOr$1tx3bdh(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + len = option_mapOr$0vgdmy4(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u8, rs.u8, rs.u8]): [rs.u8, rs.u8, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, undefined, 3)), 255, (v4: rt.Vec<[rt.u8, rt.u8, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, undefined, 3)), 255, (v4: rs.Vec<[rs.u8, rs.u8, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u8, rs.u8, rs.u8]]): rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u8, rs.u8, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, undefined, 3)); + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, undefined, 3)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rt.u8, items: rt.Iter<[rt.u8, rt.u8, rt.u8]>, seed: [rt.u8, rt.u8, rt.u8], out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$tuple3_u8_u8_u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_tuple3_u8_u8_u8_hints_reserves_closure2(coll: rs.u8, items: rs.Iter<[rs.u8, rs.u8, rs.u8]>, seed: [rs.u8, rs.u8, rs.u8], out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 3).items.length; + len = rs.iterToVec(items, "next", 3).items.length; } else if (coll === 1) { - const v: rt.Vec<[rt.u8, rt.u8, rt.u8]> = new rt.Vec(); - rt.iterExtend(v, items, "next", 3); + const v: rs.Vec<[rs.u8, rs.u8, rs.u8]> = new rs.Vec(); + rs.iterExtend(v, items, "next", 3); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec<[rt.u8, rt.u8, rt.u8]> = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 3); + const v2: rs.Vec<[rs.u8, rs.u8, rs.u8]> = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 3); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 3), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 3), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>).n; } else if (coll === 4) { - const q: rt.VecDeque<[rt.u8, rt.u8, rt.u8]> = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 3) as rt.VecDeque<[rt.u8, rt.u8, rt.u8]>; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque<[rs.u8, rs.u8, rs.u8]> = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 3) as rs.VecDeque<[rs.u8, rs.u8, rs.u8]>; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 3), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 3), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap<[rt.u8, rt.u8, rt.u8]> = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp]))); - rt.heapExtend(h, items, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp])), "next", 3); + const h: rs.BinaryHeap<[rs.u8, rs.u8, rs.u8]> = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp]))); + rs.heapExtend(h, items, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp])), "next", 3); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.u8, rt.u8]>, items, true, undefined, "next", 3)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.u8, rs.u8]>, items, true, undefined, "next", 3)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashSet<[rt.u8, rt.u8, rt.u8]>, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashSet<[rs.u8, rs.u8, rs.u8]>, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [[rt.u8, rt.u8, rt.u8], rt.u32][] = [[seed, 0] as [[rt.u8, rt.u8, rt.u8], rt.u32]]; - const m: rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8, rt.u8], rt.u32>, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t3: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t3, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _41: [[rs.u8, rs.u8, rs.u8], rs.u32][] = [[seed, 0] as [[rs.u8, rs.u8, rs.u8], rs.u32]]; + const m: rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8, rs.u8], rs.u32>, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t3: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t3, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[[rt.u8, rt.u8, rt.u8], rt.u32]> = rt.iterMap(items, (t2: [rt.u8, rt.u8, rt.u8]): [[rt.u8, rt.u8, rt.u8], rt.u32] => { - return [t2, 1] as [[rt.u8, rt.u8, rt.u8], rt.u32]; + const _50: rs.Iter<[[rs.u8, rs.u8, rs.u8], rs.u32]> = rs.iterMap(items, (t2: [rs.u8, rs.u8, rs.u8]): [[rs.u8, rs.u8, rs.u8], rs.u32] => { + return [t2, 1] as [[rs.u8, rs.u8, rs.u8], rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8, rt.u8], rt.u32>, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8, rs.u8], rs.u32>, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$1tx3bdh(rt.iterCollectOption(rt.iterMap(items, (a0: [rt.u8, rt.u8, rt.u8]): [rt.u8, rt.u8, rt.u8] | undefined => { + len = option_mapOr$0vgdmy4(rs.iterCollectOption(rs.iterMap(items, (a0: [rs.u8, rs.u8, rs.u8]): [rs.u8, rs.u8, rs.u8] | undefined => { return a0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)), 255, (v4: rt.Vec<[rt.u8, rt.u8, rt.u8]>): rt.usize => { + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)), 255, (v4: rs.Vec<[rs.u8, rs.u8, rs.u8]>): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, [rt.u8, rt.u8, rt.u8]]): rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize> => { - let _0!: rt.Result<[rt.u8, rt.u8, rt.u8], rt.usize>; - const i2: rt.usize = _2[0]; - const t: [rt.u8, rt.u8, rt.u8] = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, [rs.u8, rs.u8, rs.u8]]): rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize> => { + let _0!: rs.Result<[rs.u8, rs.u8, rs.u8], rs.usize>; + const i2: rs.usize = _2[0]; + const t: [rs.u8, rs.u8, rs.u8] = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter<[rt.u8, rt.u8, rt.u8]>) => rt.iterToVec(values, "next", 3)); + }), (values: rs.Iter<[rs.u8, rs.u8, rs.u8]>) => rs.iterToVec(values, "next", 3)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1_hints_typed_closure2_u32_hints_reserves_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u32_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1_hints_typed_closure2_u32_hints_reserves_closure1(coll: rs.u8, items: rs.Iter, seed: rs.u32, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 4).items.length; + len = rs.iterToVec(items, "next", 4).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 4); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 4); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 4); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 4); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 4), 4) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 4), 4) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 4) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 4), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 4), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 4); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { - return [t3, 1] as [rt.u32, rt.u32]; + const _41: [rs.u32, rs.u32][] = [[seed, 0] as [rs.u32, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t3: rs.u32): [rs.u32, rs.u32] => { + return [t3, 1] as [rs.u32, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { - return [t2, 1] as [rt.u32, rt.u32]; + const _50: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t2: rs.u32): [rs.u32, rs.u32] => { + return [t2, 1] as [rs.u32, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$0phbwf3(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + len = option_mapOr$09ae03o(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32): rs.u32 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32 = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u32_hints_reserves_closure1(coll: rs.u8, items: rs.Iter, seed: rs.u32, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 4).items.length; + len = rs.iterToVec(items, "next", 4).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 4); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 4); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 4); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 4); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 4), 4) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 4), 4) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 4) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 4), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 4), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 4); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { - return [t3, 1] as [rt.u32, rt.u32]; + const _41: [rs.u32, rs.u32][] = [[seed, 0] as [rs.u32, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t3: rs.u32): [rs.u32, rs.u32] => { + return [t3, 1] as [rs.u32, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { - return [t2, 1] as [rt.u32, rt.u32]; + const _50: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t2: rs.u32): [rs.u32, rs.u32] => { + return [t2, 1] as [rs.u32, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$0phbwf3(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + len = option_mapOr$09ae03o(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32): rs.u32 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32 = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u32_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u32_hints_reserves_closure1(coll: rs.u8, items: rs.Iter, seed: rs.u32, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 4).items.length; + len = rs.iterToVec(items, "next", 4).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 4); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 4); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 4); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 4); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 4), 4) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 4), 4) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 4) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 4), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 4), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 4); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { - return [t3, 1] as [rt.u32, rt.u32]; + const _41: [rs.u32, rs.u32][] = [[seed, 0] as [rs.u32, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t3: rs.u32): [rs.u32, rs.u32] => { + return [t3, 1] as [rs.u32, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { - return [t2, 1] as [rt.u32, rt.u32]; + const _50: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t2: rs.u32): [rs.u32, rs.u32] => { + return [t2, 1] as [rs.u32, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$0phbwf3(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + len = option_mapOr$09ae03o(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32): rs.u32 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32 = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u32_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll: rs.u8, items: rs.Iter, seed: rs.u32, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, undefined, 4, true).items.length; + len = rs.iterToVec(items, undefined, 4, true).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, undefined, 4, true); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, undefined, 4, true); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, undefined, 4, true); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, undefined, 4, true); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 4, true), 4) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 4, true), 4) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 4) as rs.VecDeque; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 4, true), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 4, true), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 4, true); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, undefined, 4, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 4, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, undefined, 4, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { - return [t3, 1] as [rt.u32, rt.u32]; + const _41: [rs.u32, rs.u32][] = [[seed, 0] as [rs.u32, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t3: rs.u32): [rs.u32, rs.u32] => { + return [t3, 1] as [rs.u32, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { - return [t2, 1] as [rt.u32, rt.u32]; + const _50: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t2: rs.u32): [rs.u32, rs.u32] => { + return [t2, 1] as [rs.u32, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); } else if (coll === 11) { - len = option_mapOr$0phbwf3(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + len = option_mapOr$09ae03o(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32): rs.u32 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 4)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 4)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32 = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 4)); + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 4)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll: rt.u8, items: rt.Iter, seed: rt.u32, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u32_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u32_hints_reserves_closure1(coll: rs.u8, items: rs.Iter, seed: rs.u32, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToVec(items, "next", 4).items.length; + len = rs.iterToVec(items, "next", 4).items.length; } else if (coll === 1) { - const v: rt.Vec = new rt.Vec(); - rt.iterExtend(v, items, "next", 4); + const v: rs.Vec = new rs.Vec(); + rs.iterExtend(v, items, "next", 4); len = v.items.length; } else if (coll === 2) { - const v2: rt.Vec = rt.vecFromElem(seed, 2, undefined); - rt.iterExtend(v2, items, "next", 4); + const v2: rs.Vec = rs.vecFromElem(seed, 2, undefined); + rs.iterExtend(v2, items, "next", 4); len = v2.items.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 4), 4) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 4), 4) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(seed, 2, undefined), 4) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(seed, 2, undefined), 4) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 4), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 4), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.vecFromElem(seed, 2, undefined), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 4); + const h: rs.BinaryHeap = rs.heapFrom(rs.vecFromElem(seed, 2, undefined), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 4); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 4)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 4)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 234881024)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 234881024)); } else if (coll === 9) { - const _41: [rt.u32, rt.u32][] = [[seed, 0] as [rt.u32, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t3: rt.u32): [rt.u32, rt.u32] => { - return [t3, 1] as [rt.u32, rt.u32]; + const _41: [rs.u32, rs.u32][] = [[seed, 0] as [rs.u32, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t3: rs.u32): [rs.u32, rs.u32] => { + return [t3, 1] as [rs.u32, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u32, rt.u32]> = rt.iterMap(items, (t2: rt.u32): [rt.u32, rt.u32] => { - return [t2, 1] as [rt.u32, rt.u32]; + const _50: rs.Iter<[rs.u32, rs.u32]> = rs.iterMap(items, (t2: rs.u32): [rs.u32, rs.u32] => { + return [t2, 1] as [rs.u32, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$0phbwf3(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u32): rt.u32 | undefined => { + len = option_mapOr$09ae03o(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u32): rs.u32 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)), 255, (v4: rt.Vec): rt.usize => { + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)), 255, (v4: rs.Vec): rs.usize => { return v4.items.length; }); } else { - const _53: rt.Result, rt.usize> = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u32]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u32 = _2[1]; + const _53: rs.Result, rs.usize> = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u32]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u32 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 4)); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 4)); if (_53.ok) { len = _53.value.items.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0_hints_typed_closure2_u8_hints_reserves_closure0(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u8_iter_Filter_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0_hints_typed_closure2_u8_hints_reserves_closure0(coll: rs.u8, items: rs.Iter, seed: rs.u8, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToByteVec(items, "next").length; + len = rs.iterToByteVec(items, "next").length; } else if (coll === 1) { - const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items, "next"); + const v: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { - const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items, "next"); + const v2: rs.ByteVec = rs.byteVecOf(seed, 2); + rs.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1), 1, true) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1), 1, true) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(seed, 2)), 1, true) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); + const h: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteVecOf(seed, 2)), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 1); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { - const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { - return [t3, 1] as [rt.u8, rt.u32]; + const _41: [rs.u8, rs.u32][] = [[seed, 0] as [rs.u8, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t3: rs.u8): [rs.u8, rs.u32] => { + return [t3, 1] as [rs.u8, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { - return [t2, 1] as [rt.u8, rt.u32]; + const _50: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t2: rs.u8): [rs.u8, rs.u32] => { + return [t2, 1] as [rs.u8, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + len = option_mapOr$19z8yie(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u8): rs.u8 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")), 255, (v4: rs.ByteVec): rs.usize => { return v4.length; }); } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u8 = _2[1]; + const _53: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u8]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u8 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_2_hints_typed_closure1_u8_hints_reserves_closure0(coll: rs.u8, items: rs.Iter, seed: rs.u8, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToByteVec(items, "next").length; + len = rs.iterToByteVec(items, "next").length; } else if (coll === 1) { - const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items, "next"); + const v: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { - const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items, "next"); + const v2: rs.ByteVec = rs.byteVecOf(seed, 2); + rs.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1), 1, true) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1), 1, true) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(seed, 2)), 1, true) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); + const h: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteVecOf(seed, 2)), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 1); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { - const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { - return [t3, 1] as [rt.u8, rt.u32]; + const _41: [rs.u8, rs.u32][] = [[seed, 0] as [rs.u8, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t3: rs.u8): [rs.u8, rs.u32] => { + return [t3, 1] as [rs.u8, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { - return [t2, 1] as [rt.u8, rt.u32]; + const _50: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t2: rs.u8): [rs.u8, rs.u32] => { + return [t2, 1] as [rs.u8, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + len = option_mapOr$19z8yie(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u8): rs.u8 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")), 255, (v4: rs.ByteVec): rs.usize => { return v4.length; }); } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u8 = _2[1]; + const _53: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u8]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u8 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u8_iter_Map_iter_Flatten_array_IntoIter_ops_RangeInclusive_u32_3_hints_typed_closure1_u8_hints_reserves_closure0(coll: rs.u8, items: rs.Iter, seed: rs.u8, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToByteVec(items, "next").length; + len = rs.iterToByteVec(items, "next").length; } else if (coll === 1) { - const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items, "next"); + const v: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { - const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items, "next"); + const v2: rs.ByteVec = rs.byteVecOf(seed, 2); + rs.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1), 1, true) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1), 1, true) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(seed, 2)), 1, true) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); + const h: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteVecOf(seed, 2)), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 1); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { - const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { - return [t3, 1] as [rt.u8, rt.u32]; + const _41: [rs.u8, rs.u32][] = [[seed, 0] as [rs.u8, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t3: rs.u8): [rs.u8, rs.u32] => { + return [t3, 1] as [rs.u8, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { - return [t2, 1] as [rt.u8, rt.u32]; + const _50: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t2: rs.u8): [rs.u8, rs.u32] => { + return [t2, 1] as [rs.u8, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + len = option_mapOr$19z8yie(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u8): rs.u8 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")), 255, (v4: rs.ByteVec): rs.usize => { return v4.length; }); } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u8 = _2[1]; + const _53: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u8]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u8 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u8_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll: rs.u8, items: rs.Iter, seed: rs.u8, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToByteVec(items, undefined, true).length; + len = rs.iterToByteVec(items, undefined, true).length; } else if (coll === 1) { - const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items, undefined, true); + const v: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(v, items, undefined, true); len = v.length; } else if (coll === 2) { - const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items, undefined, true); + const v2: rs.ByteVec = rs.byteVecOf(seed, 2); + rs.iterExtendBytes(v2, items, undefined, true); len = v2.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, undefined, 1, true), 1, true) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, undefined, 1, true), 1, true) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; - rt.dequeExtend(q, items, undefined, true); + const q: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(seed, 2)), 1, true) as rs.VecDeque; + rs.dequeExtend(q, items, undefined, true); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, undefined, 1, true), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, undefined, 1, true), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, undefined, 1, true); + const h: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteVecOf(seed, 2)), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, undefined, 1, true); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, undefined, 1, true)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, undefined, 1, true)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { - const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { - return [t3, 1] as [rt.u8, rt.u32]; + const _41: [rs.u8, rs.u32][] = [[seed, 0] as [rs.u8, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t3: rs.u8): [rs.u8, rs.u32] => { + return [t3, 1] as [rs.u8, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { - return [t2, 1] as [rt.u8, rt.u32]; + const _50: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t2: rs.u8): [rs.u8, rs.u32] => { + return [t2, 1] as [rs.u8, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, undefined, 8, true)); } else if (coll === 11) { - len = option_mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + len = option_mapOr$19z8yie(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u8): rs.u8 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToByteVec(values)), 255, (v4: rt.ByteVec): rt.usize => { + }), (values: rs.Iter) => rs.iterToByteVec(values)), 255, (v4: rs.ByteVec): rs.usize => { return v4.length; }); } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u8 = _2[1]; + const _53: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u8]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u8 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values)); + }), (values: rs.Iter) => rs.iterToByteVec(values)); if (_53.ok) { len = _53.value.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } /** `items` collected into the collection `coll` picks, or extended into one holding `seed`. */ -export function fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll: rt.u8, items: rt.Iter, seed: rt.u8, out: rt.ByteVec): void { - let len!: rt.usize; +export function fill$u8_iter_Skip_iter_Map_ops_RangeInclusive_u32_hints_typed_closure1_u8_hints_reserves_closure0(coll: rs.u8, items: rs.Iter, seed: rs.u8, out: rs.ByteVec): void { + let len!: rs.usize; if (coll === 0) { - len = rt.iterToByteVec(items, "next").length; + len = rs.iterToByteVec(items, "next").length; } else if (coll === 1) { - const v: rt.ByteVec = new rt.ByteVec(); - rt.iterExtendBytes(v, items, "next"); + const v: rs.ByteVec = new rs.ByteVec(); + rs.iterExtendBytes(v, items, "next"); len = v.length; } else if (coll === 2) { - const v2: rt.ByteVec = rt.byteVecOf(seed, 2); - rt.iterExtendBytes(v2, items, "next"); + const v2: rs.ByteVec = rs.byteVecOf(seed, 2); + rs.iterExtendBytes(v2, items, "next"); len = v2.length; } else if (coll === 3) { - len = (rt.dequeFromVec(rt.iterToVec(items, "next", 1), 1, true) as rt.VecDeque).n; + len = (rs.dequeFromVec(rs.iterToVec(items, "next", 1), 1, true) as rs.VecDeque).n; } else if (coll === 4) { - const q: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(seed, 2)), 1, true) as rt.VecDeque; - rt.dequeExtend(q, items, "next"); + const q: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(seed, 2)), 1, true) as rs.VecDeque; + rs.dequeExtend(q, items, "next"); len = q.n; } else if (coll === 5) { - len = rt.heapFrom(rt.iterToVec(items, "next", 1), rt.le, rt.ge, rt.lt).items.length; + len = rs.heapFrom(rs.iterToVec(items, "next", 1), rs.le, rs.ge, rs.lt).items.length; } else if (coll === 6) { - const h: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteVecOf(seed, 2)), rt.le, rt.ge, rt.lt); - rt.heapExtend(h, items, rt.le, rt.ge, rt.lt, "next", 1); + const h: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteVecOf(seed, 2)), rs.le, rs.ge, rs.lt); + rs.heapExtend(h, items, rs.le, rs.ge, rs.lt, "next", 1); len = h.items.length; } else if (coll === 7) { - len = rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, items, true, undefined, "next", 1)); + len = rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, items, true, undefined, "next", 1)); } else if (coll === 8) { - len = rt.hashLen(rt.hashExtendKeys(rt.hashNew() as rt.HashSet, items, undefined, undefined, 469762048)); + len = rs.hashLen(rs.hashExtendKeys(rs.hashNew() as rs.HashSet, items, undefined, undefined, 469762048)); } else if (coll === 9) { - const _41: [rt.u8, rt.u32][] = [[seed, 0] as [rt.u8, rt.u32]]; - const m: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice(_41), undefined, undefined, undefined, 117440512); - const _46: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t3: rt.u8): [rt.u8, rt.u32] => { - return [t3, 1] as [rt.u8, rt.u32]; + const _41: [rs.u8, rs.u32][] = [[seed, 0] as [rs.u8, rs.u32]]; + const m: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice(_41), undefined, undefined, undefined, 117440512); + const _46: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t3: rs.u8): [rs.u8, rs.u32] => { + return [t3, 1] as [rs.u8, rs.u32]; }); - rt.hashExtend(m, _46, undefined, undefined, undefined, 117440512); - len = rt.hashLen(m); + rs.hashExtend(m, _46, undefined, undefined, undefined, 117440512); + len = rs.hashLen(m); } else if (coll === 10) { - const _50: rt.Iter<[rt.u8, rt.u32]> = rt.iterMap(items, (t2: rt.u8): [rt.u8, rt.u32] => { - return [t2, 1] as [rt.u8, rt.u32]; + const _50: rs.Iter<[rs.u8, rs.u32]> = rs.iterMap(items, (t2: rs.u8): [rs.u8, rs.u32] => { + return [t2, 1] as [rs.u8, rs.u32]; }); - len = rt.btreeLen(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _50, true, undefined, undefined, "next", 8)); + len = rs.btreeLen(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _50, true, undefined, undefined, "next", 8)); } else if (coll === 11) { - len = option_mapOr$08xwngs(rt.iterCollectOption(rt.iterMap(items, (a0: rt.u8): rt.u8 | undefined => { + len = option_mapOr$19z8yie(rs.iterCollectOption(rs.iterMap(items, (a0: rs.u8): rs.u8 | undefined => { return a0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")), 255, (v4: rt.ByteVec): rt.usize => { + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")), 255, (v4: rs.ByteVec): rs.usize => { return v4.length; }); } else { - const _53: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterEnumerate(items), (_2: [rt.usize, rt.u8]): rt.Result => { - let _0!: rt.Result; - const i2: rt.usize = _2[0]; - const t: rt.u8 = _2[1]; + const _53: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterEnumerate(items), (_2: [rs.usize, rs.u8]): rs.Result => { + let _0!: rs.Result; + const i2: rs.usize = _2[0]; + const t: rs.u8 = _2[1]; if (!(i2 < 3)) { - _0 = rt.Err(i2); + _0 = rs.Err(i2); } else { - _0 = rt.Ok(t); + _0 = rs.Ok(t); } return _0; - }), (values: rt.Iter) => rt.iterToByteVec(values, "next")); + }), (values: rs.Iter) => rs.iterToByteVec(values, "next")); if (_53.ok) { len = _53.value.length; } else { - len = rt.usizeAdd(256, _53.error); + len = rs.usizeAdd(256, _53.error); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(len as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(len as rs.u32))); } //# sourceMappingURL=hints.ts.map diff --git a/ts/fixtures/lang/hints/expected/lib.ts b/ts/fixtures/lang/hints/expected/lib.ts index 5b846581a..543eedfab 100644 --- a/ts/fixtures/lang/hints/expected/lib.ts +++ b/ts/fixtures/lang/hints/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { hints, reserves } from "./hints.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["hints::hints", hints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["hints::hints", hints as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hints::reserves", reserves as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/holds/expected/core/option.ts b/ts/fixtures/lang/holds/expected/core/option.ts index dbe0e10a0..5e833917e 100644 --- a/ts/fixtures/lang/holds/expected/core/option.ts +++ b/ts/fixtures/lang/holds/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/holds/expected/harness.ts b/ts/fixtures/lang/holds/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/holds/expected/harness.ts +++ b/ts/fixtures/lang/holds/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/holds/expected/holds.ts b/ts/fixtures/lang/holds/expected/holds.ts index 9cd9932ed..97a373af1 100644 --- a/ts/fixtures/lang/holds/expected/holds.ts +++ b/ts/fixtures/lang/holds/expected/holds.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8 } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import type * as Row from "./holds.Row.ts"; -export function set(x: rt.Place, v: rt.u8): void { +export function set(x: rs.Place, v: rs.u8): void { x.v = v; } -export function whole(p: [string, Row.Row, rt.u8]): rt.u8 { - return (rt.stringLen(p[0]) & 0xff) ^ p[1].cells[1] ^ p[2]; +export function whole(p: [string, Row.Row, rs.u8]): rs.u8 { + return (rs.stringLen(p[0]) & 0xff) ^ p[1].cells[1] ^ p[2]; } -export function holds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const _10: rt.u8 = rt.u8Rem(kind, 7); +export function holds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const _10: rs.u8 = rs.u8Rem(kind, 7); if (_10 === 0) { places(a, b, data, out); } else if (_10 === 1) { @@ -35,149 +35,149 @@ export function holds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** - * A `&mut` through nested indexes lent as an `rt.Place`, each index assigned again while + * A `&mut` through nested indexes lent as an `rs.Place`, each index assigned again while * it lives, and one through a reference assigned another. */ -export function places(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const item = copy$array_u8(rt.bytes(4)); +export function places(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const item = copy$array_u8(rs.bytes(4)); const grid: Uint8Array[] = Array.from({ length: 4 }, (): Uint8Array => { return copy$array_u8(item); }); - const rows: Row.Row[] = [{ cells: rt.bytes(4) }, { cells: rt.bytes(4) }, { cells: rt.bytes(4) }]; - const _16: [rt.usize, rt.usize] = [rt.u8Rem(a, 4) as rt.usize, rt.u8Rem(b, 4) as rt.usize]; - let i: rt.usize = _16[0]; - let j: rt.usize = _16[1]; - for (const k of rt.byteSliceView(data)) { - const _30: rt.usize = i; + const rows: Row.Row[] = [{ cells: rs.bytes(4) }, { cells: rs.bytes(4) }, { cells: rs.bytes(4) }]; + const _16: [rs.usize, rs.usize] = [rs.u8Rem(a, 4) as rs.usize, rs.u8Rem(b, 4) as rs.usize]; + let i: rs.usize = _16[0]; + let j: rs.usize = _16[1]; + for (const k of rs.byteSliceView(data)) { + const _30: rs.usize = i; if (!(_30 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); } - const _32: rt.usize = j; + const _32: rs.usize = j; if (!(_32 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _32); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _32); } - const _35: rt.usize = rt.usizeRem(i, 3); + const _35: rs.usize = rs.usizeRem(i, 3); if (!(_35 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _35); } - const _39: rt.usize = j; + const _39: rs.usize = j; if (!(_39 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _39); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _39); } - i = rt.usizeRem(rt.usizeAdd(i, k as rt.usize), 4); - j = rt.usizeRem(rt.usizeAdd(j, 1), 4); - set(rt.place(() => grid[_30][_32], (value) => grid[_30][_32] = value), k); - set(rt.place(() => rows[_35].cells[_39], (value2) => rows[_35].cells[_39] = value2), k ^ 1); + i = rs.usizeRem(rs.usizeAdd(i, k as rs.usize), 4); + j = rs.usizeRem(rs.usizeAdd(j, 1), 4); + set(rs.place(() => grid[_30][_32], (value) => grid[_30][_32] = value), k); + set(rs.place(() => rows[_35].cells[_39], (value2) => rows[_35].cells[_39] = value2), k ^ 1); } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 4), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 4), undefined, true); for (const _61 of rows) { - rt.iterExtendBytes(out, rt.iterSlice(_61.cells), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_61.cells), undefined, true); } - const x: Uint8Array = rt.bytes(4).fill(a); - const y: Uint8Array = rt.bytes(4).fill(b); - let r: rt.ByteSlice = rt.byteSliceFrom(x); - const _72: rt.usize = rt.u8Rem(a, 4) as rt.usize; - const _76: rt.usize = r.length; + const x: Uint8Array = rs.bytes(4).fill(a); + const y: Uint8Array = rs.bytes(4).fill(b); + let r: rs.ByteSlice = rs.byteSliceFrom(x); + const _72: rs.usize = rs.u8Rem(a, 4) as rs.usize; + const _76: rs.usize = r.length; if (!(_72 < _76)) { - rt.panic("index out of bounds: the len is " + _76 + " but the index is " + _72); + rs.panic("index out of bounds: the len is " + _76 + " but the index is " + _72); } const borrowed = r; const borrowed2 = r.start + _72; - const s: rt.Place = rt.place(() => borrowed.data[borrowed2], (value3) => borrowed.data[borrowed2] = value3); - r = rt.byteSliceFrom(y); + const s: rs.Place = rs.place(() => borrowed.data[borrowed2], (value3) => borrowed.data[borrowed2] = value3); + r = rs.byteSliceFrom(y); set(s, 9); - const _84: rt.usize = r.length; + const _84: rs.usize = r.length; if (!(0 < _84)) { - rt.panic("index out of bounds: the len is " + _84 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + _84 + " but the index is " + 0); } - const _80: rt.u8 = rt.u8WrappingAdd(r.data[r.start], 1); - const _88: rt.usize = r.length; + const _80: rs.u8 = rs.u8WrappingAdd(r.data[r.start], 1); + const _88: rs.usize = r.length; if (!(0 < _88)) { - rt.panic("index out of bounds: the len is " + _88 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + _88 + " but the index is " + 0); } r.data[r.start] = _80; - rt.iterExtendBytes(out, rt.iterSlice(x), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(y), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(x), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(y), undefined, true); } /** * Shared and mutable borrows of an element, the index assigned again before the read, * and kept across iterations. */ -export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { - let i: rt.usize = 0; - const kept: rt.Vec = new rt.Vec(); +export function indexed(data: rs.ByteSlice, out: rs.ByteVec): void { + let i: rs.usize = 0; + const kept: rs.Vec = new rs.Vec(); while (i < data.length) { - const _9: rt.usize = i; - rt.idx(data, _9); - i = rt.usizeAdd(i, 1); - rt.byteVecPush(out, data.data[data.start + _9]); + const _9: rs.usize = i; + rs.idx(data, _9); + i = rs.usizeAdd(i, 1); + rs.byteVecPush(out, data.data[data.start + _9]); kept.items.push(data.data[data.start + _9]); } - rt.iterExtendBytes(out, rt.vecIntoIter(kept), undefined, true); - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - let i2: rt.usize = 0; + rs.iterExtendBytes(out, rs.vecIntoIter(kept), undefined, true); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + let i2: rs.usize = 0; while (i2 < v.length) { - const at = rt.idx(v, i2); - i2 = rt.usizeAdd(i2, 2); - const _31: rt.u8 = rt.u8WrappingAdd(v.data[at], i2 & 0xff); + const at = rs.idx(v, i2); + i2 = rs.usizeAdd(i2, 2); + const _31: rs.u8 = rs.u8WrappingAdd(v.data[at], i2 & 0xff); v.data[at] = _31; } - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); } /** * A reborrow through a reference that is then assigned another, shared and mutable, in a * loop. */ -export function reborrows(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let x: rt.u8 = a; - let y: rt.u8 = b; - let r: rt.Place = rt.place(() => x, (value) => x = value); - const s: rt.Place = r; - r = rt.place(() => y, (value2) => y = value2); - s.v = rt.u8WrappingAdd(s.v, 1); - r.v = rt.u8WrappingAdd(r.v, 2); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(x, y)), undefined, true); - let r2: rt.u8 = a; - const kept: rt.Vec = new rt.Vec(); - for (const _25 of rt.byteSliceView(data)) { - const s2: rt.u8 = r2; +export function reborrows(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let x: rs.u8 = a; + let y: rs.u8 = b; + let r: rs.Place = rs.place(() => x, (value) => x = value); + const s: rs.Place = r; + r = rs.place(() => y, (value2) => y = value2); + s.v = rs.u8WrappingAdd(s.v, 1); + r.v = rs.u8WrappingAdd(r.v, 2); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(x, y)), undefined, true); + let r2: rs.u8 = a; + const kept: rs.Vec = new rs.Vec(); + for (const _25 of rs.byteSliceView(data)) { + const s2: rs.u8 = r2; r2 = _25; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(s2, r2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(s2, r2)), undefined, true); kept.items.push(s2); } - rt.iterExtendBytes(out, rt.vecIntoIter(kept), undefined, true); + rs.iterExtendBytes(out, rs.vecIntoIter(kept), undefined, true); } /** * A copy of a reference whose source is assigned another, and of an `Option` a range's * `next` assigns again. */ -export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let r: rt.u8 = a; - const kept: rt.Vec = new rt.Vec(); - for (const _9 of rt.byteSliceView(data)) { - const s: rt.u8 = r; +export function copies(a: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let r: rs.u8 = a; + const kept: rs.Vec = new rs.Vec(); + for (const _9 of rs.byteSliceView(data)) { + const s: rs.u8 = r; r = _9; kept.items.push(s); } - rt.iterExtendBytes(out, rt.vecIntoIter(kept), undefined, true); - const range: rt.Range = new rt.Range(0, data.length); - let cur: rt.usize | undefined = range.start < range.end ? range.start++ : undefined; + rs.iterExtendBytes(out, rs.vecIntoIter(kept), undefined, true); + const range: rs.Range = new rs.Range(0, data.length); + let cur: rs.usize | undefined = range.start < range.end ? range.start++ : undefined; const some: boolean = cur !== undefined; - const copied: rt.usize | undefined = cur; + const copied: rs.usize | undefined = cur; cur = range.start < range.end ? range.start++ : undefined; - rt.byteVecPush(out, some ? 1 : 0); - rt.byteVecPush(out, option_mapOr$02k4ito(copied, 255, (c: rt.usize): rt.u8 => { + rs.byteVecPush(out, some ? 1 : 0); + rs.byteVecPush(out, option_mapOr$188iunt(copied, 255, (c: rs.usize): rs.u8 => { return c & 0xff; })); while (true) { - const was: rt.usize | undefined = cur; + const was: rs.usize | undefined = cur; cur = range.start < range.end ? range.start++ : undefined; if (was !== undefined) { - rt.byteVecPush(out, was & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(cur, 255, (c2: rt.usize): rt.u8 => { + rs.byteVecPush(out, was & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(cur, 255, (c2: rs.usize): rs.u8 => { return c2 & 0xff; })); } else { @@ -190,132 +190,132 @@ export function copies(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Closures made in a loop that capture a reference to what that iteration reads, called * after it: an element, a payload, a field, and a value a loop breaks with. */ -export function closures(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _31!: rt.usize; - let _47!: rt.usize; +export function closures(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _31!: rs.usize; + let _47!: rs.usize; const arr: Uint8Array = Uint8Array.of(a, b, 3, 4, 5, 6, 7, 8); - const rows: Row.Row[] = [{ cells: rt.bytes(4).fill(a) }, { cells: rt.bytes(4).fill(b) }, { cells: rt.bytes(4).fill(7) }]; - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - const fs: rt.Vec<() => rt.u8> = new rt.Vec(); - for (const _17 of rt.byteSliceView(data)) { - fs.items.push((): rt.u8 => { + const rows: Row.Row[] = [{ cells: rs.bytes(4).fill(a) }, { cells: rs.bytes(4).fill(b) }, { cells: rs.bytes(4).fill(7) }]; + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + const fs: rs.Vec<() => rs.u8> = new rs.Vec(); + for (const _17 of rs.byteSliceView(data)) { + fs.items.push((): rs.u8 => { return _17; }); } - const _28: rt.usize = v.length; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _28; + const _28: rs.usize = v.length; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _28; while ((_31 = iterStart++) < iterEnd) { - const at = rt.idx(v, _31); - const _39: () => rt.u8 = (): rt.u8 => { - return rt.u8WrappingAdd(v.data[at], 1); + const at = rs.idx(v, _31); + const _39: () => rs.u8 = (): rs.u8 => { + return rs.u8WrappingAdd(v.data[at], 1); }; fs.items.push(_39); } - const _43: rt.usize = rt.byteSliceFrom(arr).length; - let rangeStart: rt.usize = 0; - const rangeEnd: rt.usize = _43; + const _43: rs.usize = rs.byteSliceFrom(arr).length; + let rangeStart: rs.usize = 0; + const rangeEnd: rs.usize = _43; while ((_47 = rangeStart++) < rangeEnd) { - const i2: rt.usize = _47; + const i2: rs.usize = _47; if (!(i2 < 8)) { - rt.panic("index out of bounds: the len is " + 8 + " but the index is " + i2); + rs.panic("index out of bounds: the len is " + 8 + " but the index is " + i2); } - fs.items.push((): rt.u8 => { + fs.items.push((): rs.u8 => { return arr[i2]; }); } - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter3: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _61: [rt.usize, rt.u8] | rt.Done = iter3.next(); - if (_61 === rt.DONE) { + const _61: [rs.usize, rs.u8] | rs.Done = iter3.next(); + if (_61 === rs.DONE) { break; } const captured = _61[0]; - const _68: () => rt.u8 = (): rt.u8 => { - return rt.u8WrappingAdd(_61[1], captured & 0xff); + const _68: () => rs.u8 = (): rs.u8 => { + return rs.u8WrappingAdd(_61[1], captured & 0xff); }; fs.items.push(_68); } const itS: Row.Row[] = rows; let itI: number = 0; while (true) { - const _74: Row.Row | rt.Done = itI < itS.length ? itS[itI++] : rt.DONE; - if (_74 !== rt.DONE) { - const cells: rt.ByteSlice = rt.byteSliceFrom(_74.cells); - fs.items.push((): rt.u8 => { + const _74: Row.Row | rs.Done = itI < itS.length ? itS[itI++] : rs.DONE; + if (_74 !== rs.DONE) { + const cells: rs.ByteSlice = rs.byteSliceFrom(_74.cells); + fs.items.push((): rs.u8 => { return cells.data[cells.start + 1]; }); } else { break; } } - for (const _86 of rt.byteSliceView(data)) { - let n: rt.u8 = _86; - while (!(rt.u8Rem(n, 3) === 0)) { - n = rt.u8WrappingAdd(n, 1); + for (const _86 of rs.byteSliceView(data)) { + let n: rs.u8 = _86; + while (!(rs.u8Rem(n, 3) === 0)) { + n = rs.u8WrappingAdd(n, 1); } - const _96: rt.usize = rt.usizeRem(_86 as rt.usize, 3); + const _96: rs.usize = rs.usizeRem(_86 as rs.usize, 3); if (!(_96 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _96); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _96); } const captured2 = n; - fs.items.push((): rt.u8 => { + fs.items.push((): rs.u8 => { return rows[_96].cells[0] ^ captured2; }); } for (const _111 of fs.items) { - rt.byteVecPush(out, _111()); + rs.byteVecPush(out, _111()); } - rt.dropVec(fs); + rs.dropVec(fs); } /** * A tuple of references and a number, read by its fields and whole after the variables * it was made of are assigned again, and one made in a loop from a variable it assigns. */ -export function parts(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: Row.Row[] = [{ cells: rt.bytes(4).fill(a) }, { cells: rt.bytes(4).fill(b) }]; +export function parts(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: Row.Row[] = [{ cells: rs.bytes(4).fill(a) }, { cells: rs.bytes(4).fill(b) }]; let s: string = "ab"; let x: Row.Row = rows[0]; - let n: rt.u8 = a; + let n: rs.u8 = a; const _17: string = s; const _18: Row.Row = x; - const pair: [string, Row.Row, rt.u8] = [_17, _18, n]; + const pair: [string, Row.Row, rs.u8] = [_17, _18, n]; s = "zzz"; x = rows[1]; - n = rt.u8WrappingAdd(n, 1); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_17)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_18.cells[0], pair[2], whole(pair))), undefined, true); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, x.cells[0] ^ n); - let total: rt.u8 = 0; - for (const _47 of rt.byteSliceView(data)) { - const p: [rt.u8, rt.u8] = [n, _47]; - n = rt.u8WrappingMul(n, 3); - total = rt.u8WrappingAdd(rt.u8WrappingAdd(total, p[0]), _47); + n = rs.u8WrappingAdd(n, 1); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_17)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_18.cells[0], pair[2], whole(pair))), undefined, true); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, x.cells[0] ^ n); + let total: rs.u8 = 0; + for (const _47 of rs.byteSliceView(data)) { + const p: [rs.u8, rs.u8] = [n, _47]; + n = rs.u8WrappingMul(n, 3); + total = rs.u8WrappingAdd(rs.u8WrappingAdd(total, p[0]), _47); } - rt.byteVecPush(out, total); + rs.byteVecPush(out, total); } /** A range's start read, then the range stepped, once and in a loop. */ -export function ranges(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _16!: rt.usize; - const range: rt.Range = new rt.Range(0, dataLen); - const before: rt.usize = range.start; - const first: rt.usize | undefined = range.start < range.end ? range.start++ : undefined; - rt.byteVecPush(out, before & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(first, 255, (f: rt.usize): rt.u8 => { +export function ranges(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _16!: rs.usize; + const range: rs.Range = new rs.Range(0, dataLen); + const before: rs.usize = range.start; + const first: rs.usize | undefined = range.start < range.end ? range.start++ : undefined; + rs.byteVecPush(out, before & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(first, 255, (f: rs.usize): rs.u8 => { return f & 0xff; })); - const range2: rt.Range = new rt.Range(0, dataLen); + const range2: rs.Range = new rs.Range(0, dataLen); while (true) { - const before2: rt.usize = range2.start; + const before2: rs.usize = range2.start; const _16Some: boolean = range2.start < range2.end; if (_16Some) { _16 = range2.start++; } if (_16Some) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2 & 0xff, _16 & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before2 & 0xff, _16 & 0xff)), undefined, true); } else { break; } diff --git a/ts/fixtures/lang/holds/expected/lib.ts b/ts/fixtures/lang/holds/expected/lib.ts index cdcd9a064..da87d3db7 100644 --- a/ts/fixtures/lang/holds/expected/lib.ts +++ b/ts/fixtures/lang/holds/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { holds } from "./holds.ts"; export function copy$array_u8(v: Uint8Array): Uint8Array { @@ -11,8 +11,8 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["holds::holds", holds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["holds::holds", holds as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/holds/src/holds.rs b/ts/fixtures/lang/holds/src/holds.rs index 9e3328f90..b1ab01e0e 100644 --- a/ts/fixtures/lang/holds/src/holds.rs +++ b/ts/fixtures/lang/holds/src/holds.rs @@ -1,5 +1,5 @@ //! Values translation holds back rather than reads once: a borrow read as its place, a -//! place lent as an `rt.Place`, a copy of a reference, an aggregate read by its parts, a +//! place lent as an `rs.Place`, a copy of a reference, an aggregate read by its parts, a //! closure's captures, and a temporary folded into its read. Each case assigns a variable //! the held value names between the hold and the read, in a loop and across its //! iterations, and the read must see what Rust read when the value was made. @@ -30,7 +30,7 @@ pub fn holds(kind: u8, data: &[u8], out: &mut Vec) { } } -/// A `&mut` through nested indexes lent as an `rt.Place`, each index assigned again while +/// A `&mut` through nested indexes lent as an `rs.Place`, each index assigned again while /// it lives, and one through a reference assigned another. fn places(a: u8, b: u8, data: &[u8], out: &mut Vec) { let mut grid = [[0u8; 4]; 4]; diff --git a/ts/fixtures/lang/ints/expected/core/char/methods.ts b/ts/fixtures/lang/ints/expected/core/char/methods.ts index 992b1a141..5b52ab359 100644 --- a/ts/fixtures/lang/ints/expected/core/char/methods.ts +++ b/ts/fixtures/lang/ints/expected/core/char/methods.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefined { - let value!: rt.u32; +export function toDigit$14z95r4(self: rs.char, radix: rs.u32): rs.u32 | undefined { + let value!: rs.u32; if (radix >= 2) { if (radix <= 36) { b1: { if (self > 57) { if (radix > 10) { - value = rt.u32Add((rt.u32WrappingSub(self as rt.u32, 65 as rt.u32) & 4294967263) >>> 0, 10); + value = rs.u32Add((rs.u32WrappingSub(self as rs.u32, 65 as rs.u32) & 4294967263) >>> 0, 10); break b1; } } - value = rt.u32WrappingSub(self as rt.u32, 48 as rt.u32); + value = rs.u32WrappingSub(self as rs.u32, 48 as rs.u32); } if (!(value < radix)) { return undefined; @@ -21,7 +21,7 @@ export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefine return value; } } - rt.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); + rs.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); } //# sourceMappingURL=methods.ts.map diff --git a/ts/fixtures/lang/ints/expected/core/num.ts b/ts/fixtures/lang/ints/expected/core/num.ts index 000e4a96c..c2f2b4ec3 100644 --- a/ts/fixtures/lang/ints/expected/core/num.ts +++ b/ts/fixtures/lang/ints/expected/core/num.ts @@ -1,57 +1,57 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { toDigit$01k9ewn } from "../core/char/methods.ts"; +import * as rs from "../rs.ts"; +import { toDigit$14z95r4 } from "../core/char/methods.ts"; -export function canNotOverflow$0q497dn(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$05izqtt(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(16, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(16, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$1wu8g18(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$0du5ub4(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(2, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(2, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0uown4l(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$14pvtu0(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(4, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(4, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$03q1vv8(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$09fz75c(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(8, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(8, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0aqh4yo(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$0bdyog2(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(1, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(1, 2), isSignedTy ? 1 : 0); } -export function fromAsciiBytesRadixPanic(radix: rt.u32): never { - doPanic$0sx2e1f(radix); +export function fromAsciiBytesRadixPanic(radix: rs.u32): never { + doPanic$16ya8t2(radix); } -export function doPanic$0sx2e1f(radix: rt.u32): never { - runtime$0bn0geu(radix); +export function doPanic$16ya8t2(radix: rs.u32): never { + runtime$0o4i17s(radix); } -export function runtime$0bn0geu(radix: rt.u32): never { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(radix, f)]; - rt.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$0o4i17s(radix: rs.u32): never { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); } -export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -59,11 +59,11 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128); + const isSignedTy: boolean = rs.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -77,7 +77,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -96,31 +96,31 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i128 = 0; + let result: rs.i128 = 0; b5: { - if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$05izqtt(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i128 = _92 as rt.i128; + const x4: rs.i128 = _92 as rs.i128; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i128 | undefined = rt.i128CheckedSub(result, x4); + const _103: rs.i128 | undefined = rs.i128CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -132,23 +132,23 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i128 = _67 as rt.i128; + const x3: rs.i128 = _67 as rs.i128; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i128 | undefined = rt.i128CheckedAdd(result, x3); + const _78: rs.i128 | undefined = rs.i128CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -161,16 +161,16 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingSub(result, _49 as rt.i128); + result = rs.i128WrappingSub(result, _49 as rs.i128); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -180,30 +180,30 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingAdd(result, _32 as rt.i128); + result = rs.i128WrappingAdd(result, _32 as rs.i128); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1gthu8q(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -215,7 +215,7 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -229,7 +229,7 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -248,31 +248,31 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i16 = 0; + let result: rs.i16 = 0; b5: { - if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0du5ub4(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i16 | undefined = rt.i16CheckedMul(result, (radix << 16) >> 16); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i16 | undefined = rs.i16CheckedMul(result, (radix << 16) >> 16); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i16 = (_92 << 16) >> 16; + const x4: rs.i16 = (_92 << 16) >> 16; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i16 | undefined = rt.i16CheckedSub(result, x4); + const _103: rs.i16 | undefined = rs.i16CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -284,23 +284,23 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i16 | undefined = rt.i16CheckedMul(result, (radix << 16) >> 16); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i16 | undefined = rs.i16CheckedMul(result, (radix << 16) >> 16); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i16 = (_67 << 16) >> 16; + const x3: rs.i16 = (_67 << 16) >> 16; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i16 | undefined = rt.i16CheckedAdd(result, x3); + const _78: rs.i16 | undefined = rs.i16CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -313,16 +313,16 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i16WrappingMul(result, (radix << 16) >> 16); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i16WrappingMul(result, (radix << 16) >> 16); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i16WrappingSub(result, (_49 << 16) >> 16); + result = rs.i16WrappingSub(result, (_49 << 16) >> 16); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -332,30 +332,30 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i16WrappingMul(result, (radix << 16) >> 16); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i16WrappingMul(result, (radix << 16) >> 16); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i16WrappingAdd(result, (_32 << 16) >> 16); + result = rs.i16WrappingAdd(result, (_32 << 16) >> 16); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$07oe1fj(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -367,7 +367,7 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -381,7 +381,7 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -400,31 +400,31 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i32 = 0; + let result: rs.i32 = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i32 | undefined = rt.i32CheckedMul(result, radix | 0); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i32 | undefined = rs.i32CheckedMul(result, radix | 0); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i32 = _92 | 0; + const x4: rs.i32 = _92 | 0; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i32 | undefined = rt.i32CheckedSub(result, x4); + const _103: rs.i32 | undefined = rs.i32CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -436,23 +436,23 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i32 | undefined = rt.i32CheckedMul(result, radix | 0); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i32 | undefined = rs.i32CheckedMul(result, radix | 0); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i32 = _67 | 0; + const x3: rs.i32 = _67 | 0; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i32 | undefined = rt.i32CheckedAdd(result, x3); + const _78: rs.i32 | undefined = rs.i32CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -465,16 +465,16 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i32WrappingMul(result, radix | 0); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i32WrappingMul(result, radix | 0); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i32WrappingSub(result, _49 | 0); + result = rs.i32WrappingSub(result, _49 | 0); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -484,30 +484,30 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i32WrappingMul(result, radix | 0); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i32WrappingMul(result, radix | 0); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i32WrappingAdd(result, _32 | 0); + result = rs.i32WrappingAdd(result, _32 | 0); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0wzunhe(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -515,11 +515,11 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.i64Gt(0, { hi: -0x80000000, lo: 0 } as rt.i64); + const isSignedTy: boolean = rs.i64Gt(0, { hi: -0x80000000, lo: 0 } as rs.i64); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -533,7 +533,7 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -552,31 +552,31 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i64 = 0; + let result: rs.i64 = 0; b5: { - if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$09fz75c(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i64 | undefined = rt.i64CheckedMul(result, radix as rt.i64); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i64 | undefined = rs.i64CheckedMul(result, radix as rs.i64); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i64 = _92 as rt.i64; + const x4: rs.i64 = _92 as rs.i64; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i64 | undefined = rt.i64CheckedSub(result, x4); + const _103: rs.i64 | undefined = rs.i64CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -588,23 +588,23 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i64 | undefined = rt.i64CheckedMul(result, radix as rt.i64); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i64 | undefined = rs.i64CheckedMul(result, radix as rs.i64); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i64 = _67 as rt.i64; + const x3: rs.i64 = _67 as rs.i64; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i64 | undefined = rt.i64CheckedAdd(result, x3); + const _78: rs.i64 | undefined = rs.i64CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -617,16 +617,16 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i64WrappingMul(result, radix as rt.i64); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i64WrappingMul(result, radix as rs.i64); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i64WrappingSub(result, _49 as rt.i64); + result = rs.i64WrappingSub(result, _49 as rs.i64); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -636,30 +636,30 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i64WrappingMul(result, radix as rt.i64); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i64WrappingMul(result, radix as rs.i64); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i64WrappingAdd(result, _32 as rt.i64); + result = rs.i64WrappingAdd(result, _32 as rs.i64); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1amlmta(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -671,7 +671,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -685,7 +685,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -704,31 +704,31 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i8 = 0; + let result: rs.i8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i8 = (_92 << 24) >> 24; + const x4: rs.i8 = (_92 << 24) >> 24; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i8 | undefined = rt.i8CheckedSub(result, x4); + const _103: rs.i8 | undefined = rs.i8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -740,23 +740,23 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i8 = (_67 << 24) >> 24; + const x3: rs.i8 = (_67 << 24) >> 24; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i8 | undefined = rt.i8CheckedAdd(result, x3); + const _78: rs.i8 | undefined = rs.i8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -769,16 +769,16 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingSub(result, (_49 << 24) >> 24); + result = rs.i8WrappingSub(result, (_49 << 24) >> 24); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -788,30 +788,30 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingAdd(result, (_32 << 24) >> 24); + result = rs.i8WrappingAdd(result, (_32 << 24) >> 24); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0d7us41(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -823,7 +823,7 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -837,7 +837,7 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -856,31 +856,31 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.isize = 0; + let result: rs.isize = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.isize | undefined = rt.isizeCheckedMul(result, radix | 0); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.isize | undefined = rs.isizeCheckedMul(result, radix | 0); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.isize = _92 | 0; + const x4: rs.isize = _92 | 0; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.isize | undefined = rt.isizeCheckedSub(result, x4); + const _103: rs.isize | undefined = rs.isizeCheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -892,23 +892,23 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.isize | undefined = rt.isizeCheckedMul(result, radix | 0); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.isize | undefined = rs.isizeCheckedMul(result, radix | 0); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.isize = _67 | 0; + const x3: rs.isize = _67 | 0; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.isize | undefined = rt.isizeCheckedAdd(result, x3); + const _78: rs.isize | undefined = rs.isizeCheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -921,16 +921,16 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.isizeWrappingMul(result, radix | 0); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.isizeWrappingMul(result, radix | 0); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.isizeWrappingSub(result, _49 | 0); + result = rs.isizeWrappingSub(result, _49 | 0); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -940,78 +940,78 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.isizeWrappingMul(result, radix | 0); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.isizeWrappingMul(result, radix | 0); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.isizeWrappingAdd(result, _32 | 0); + result = rs.isizeWrappingAdd(result, _32 | 0); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromStr$0zyj6he(src: string): rt.Result { - return fromStrRadix$0366bau(src, 10); +export function fromStr$1el0yvy(src: string): rs.Result { + return fromStrRadix$0cysu2u(src, 10); } -export function fromStr$15pqb75(src: string): rt.Result { - return fromStrRadix$0rk2yr6(src, 10); +export function fromStr$0ehcbzz(src: string): rs.Result { + return fromStrRadix$19vdb8q(src, 10); } -export function fromStr$0lmxi6o(src: string): rt.Result { - return fromStrRadix$1newkmi(src, 10); +export function fromStr$1ckv470(src: string): rs.Result { + return fromStrRadix$1ct8u92(src, 10); } -export function fromStr$116mp4t(src: string): rt.Result { - return fromStrRadix$11y6fsf(src, 10); +export function fromStr$00n8jbp(src: string): rs.Result { + return fromStrRadix$04fc4zz(src, 10); } -export function fromStr$029r9bb(src: string): rt.Result { - return fromStrRadix$0dg9fx3(src, 10); +export function fromStr$1amqoj7(src: string): rs.Result { + return fromStrRadix$0qyezqs(src, 10); } -export function fromStr$1v63ugw(src: string): rt.Result { - return fromStrRadix$16jk9zm(src, 10); +export function fromStr$0ytcpik(src: string): rs.Result { + return fromStrRadix$1nys6eo(src, 10); } -export function fromStrRadix$0366bau(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0xhcrxt(rt.stringAsBytes(src), radix); +export function fromStrRadix$0cysu2u(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1r0rye7(rs.stringAsBytes(src), radix); } -export function fromStrRadix$0rk2yr6(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0ut8llb(rt.stringAsBytes(src), radix); +export function fromStrRadix$19vdb8q(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1gthu8q(rs.stringAsBytes(src), radix); } -export function fromStrRadix$1newkmi(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1ykgy6m(rt.stringAsBytes(src), radix); +export function fromStrRadix$1ct8u92(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$07oe1fj(rs.stringAsBytes(src), radix); } -export function fromStrRadix$11y6fsf(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$01tfvb9(rt.stringAsBytes(src), radix); +export function fromStrRadix$04fc4zz(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0wzunhe(rs.stringAsBytes(src), radix); } -export function fromStrRadix$0dg9fx3(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0k9pjln(rt.stringAsBytes(src), radix); +export function fromStrRadix$0qyezqs(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1amlmta(rs.stringAsBytes(src), radix); } -export function fromStrRadix$16jk9zm(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1hpkcx2(rt.stringAsBytes(src), radix); +export function fromStrRadix$1nys6eo(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0d7us41(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0paozdl(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1019,11 +1019,11 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.u128Gt(0, 0); + const isSignedTy: boolean = rs.u128Gt(0, 0); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1037,7 +1037,7 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1056,31 +1056,31 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u128 = 0; + let result: rs.u128 = 0; b5: { - if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$05izqtt(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u128 | undefined = rt.u128CheckedMul(result, radix as rt.u128); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u128 | undefined = rs.u128CheckedMul(result, radix as rs.u128); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u128 = _92 as rt.u128; + const x4: rs.u128 = _92 as rs.u128; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u128 | undefined = rt.u128CheckedSub(result, x4); + const _103: rs.u128 | undefined = rs.u128CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1092,23 +1092,23 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u128 | undefined = rt.u128CheckedMul(result, radix as rt.u128); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u128 | undefined = rs.u128CheckedMul(result, radix as rs.u128); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u128 = _67 as rt.u128; + const x3: rs.u128 = _67 as rs.u128; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u128 | undefined = rt.u128CheckedAdd(result, x3); + const _78: rs.u128 | undefined = rs.u128CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1121,16 +1121,16 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u128WrappingMul(result, radix as rt.u128); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u128WrappingMul(result, radix as rs.u128); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u128WrappingSub(result, _49 as rt.u128); + result = rs.u128WrappingSub(result, _49 as rs.u128); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1140,30 +1140,30 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u128WrappingMul(result, radix as rt.u128); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u128WrappingMul(result, radix as rs.u128); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u128WrappingAdd(result, _32 as rt.u128); + result = rs.u128WrappingAdd(result, _32 as rs.u128); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0wd05by(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1175,7 +1175,7 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1189,7 +1189,7 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1208,31 +1208,31 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u16 = 0; + let result: rs.u16 = 0; b5: { - if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0du5ub4(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u16 | undefined = rt.u16CheckedMul(result, radix & 0xffff); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u16 | undefined = rs.u16CheckedMul(result, radix & 0xffff); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u16 = _92 & 0xffff; + const x4: rs.u16 = _92 & 0xffff; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u16 | undefined = rt.u16CheckedSub(result, x4); + const _103: rs.u16 | undefined = rs.u16CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1244,23 +1244,23 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u16 | undefined = rt.u16CheckedMul(result, radix & 0xffff); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u16 | undefined = rs.u16CheckedMul(result, radix & 0xffff); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u16 = _67 & 0xffff; + const x3: rs.u16 = _67 & 0xffff; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u16 | undefined = rt.u16CheckedAdd(result, x3); + const _78: rs.u16 | undefined = rs.u16CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1273,16 +1273,16 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u16WrappingMul(result, radix & 0xffff); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u16WrappingMul(result, radix & 0xffff); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u16WrappingSub(result, _49 & 0xffff); + result = rs.u16WrappingSub(result, _49 & 0xffff); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1292,30 +1292,30 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u16WrappingMul(result, radix & 0xffff); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u16WrappingMul(result, radix & 0xffff); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u16WrappingAdd(result, _32 & 0xffff); + result = rs.u16WrappingAdd(result, _32 & 0xffff); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$15o252c(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1327,7 +1327,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1341,7 +1341,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value6 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1360,31 +1360,31 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u32 = 0; + let result: rs.u32 = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _84: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _84: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_84 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u32 = _84; + const x4: rs.u32 = _84; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _95: rt.u32 | undefined = rt.u32CheckedSub(result, x4); + const _95: rs.u32 | undefined = rs.u32CheckedSub(result, x4); if (_95 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _95; digitsData = restData5; @@ -1396,23 +1396,23 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _61: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _61: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_61 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u32 = _61; + const x3: rs.u32 = _61; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _72: rt.u32 | undefined = rt.u32CheckedAdd(result, x3); + const _72: rs.u32 | undefined = rs.u32CheckedAdd(result, x3); if (_72 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _72; digitsData = restData4; @@ -1425,16 +1425,16 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _46: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _46: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_46 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingSub(result, _46); + result = rs.u32WrappingSub(result, _46); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1444,30 +1444,30 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _31: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _31: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_31 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingAdd(result, _31); + result = rs.u32WrappingAdd(result, _31); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0zwqu7x(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1475,11 +1475,11 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.u64Gt(0, 0); + const isSignedTy: boolean = rs.u64Gt(0, 0); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1493,7 +1493,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1512,31 +1512,31 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u64 = 0; + let result: rs.u64 = 0; b5: { - if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$09fz75c(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u64 = _92 as rt.u64; + const x4: rs.u64 = _92 as rs.u64; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u64 | undefined = rt.u64CheckedSub(result, x4); + const _103: rs.u64 | undefined = rs.u64CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1548,23 +1548,23 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u64 = _67 as rt.u64; + const x3: rs.u64 = _67 as rs.u64; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u64 | undefined = rt.u64CheckedAdd(result, x3); + const _78: rs.u64 | undefined = rs.u64CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1577,16 +1577,16 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingSub(result, _49 as rt.u64); + result = rs.u64WrappingSub(result, _49 as rs.u64); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1596,30 +1596,30 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingAdd(result, _32 as rt.u64); + result = rs.u64WrappingAdd(result, _32 as rs.u64); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1djtuzq(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1631,7 +1631,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1645,7 +1645,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1664,31 +1664,31 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u8 = 0; + let result: rs.u8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u8 = _92 & 0xff; + const x4: rs.u8 = _92 & 0xff; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u8 | undefined = rt.u8CheckedSub(result, x4); + const _103: rs.u8 | undefined = rs.u8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1700,23 +1700,23 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u8 = _67 & 0xff; + const x3: rs.u8 = _67 & 0xff; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u8 | undefined = rt.u8CheckedAdd(result, x3); + const _78: rs.u8 | undefined = rs.u8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1729,16 +1729,16 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingSub(result, _49 & 0xff); + result = rs.u8WrappingSub(result, _49 & 0xff); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1748,30 +1748,30 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingAdd(result, _32 & 0xff); + result = rs.u8WrappingAdd(result, _32 & 0xff); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1lirmeu(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1783,7 +1783,7 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1797,7 +1797,7 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1816,31 +1816,31 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.usize = 0; + let result: rs.usize = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.usize | undefined = rt.usizeCheckedMul(result, radix as rt.usize); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.usize | undefined = rs.usizeCheckedMul(result, radix as rs.usize); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.usize = _92 as rt.usize; + const x4: rs.usize = _92 as rs.usize; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.usize | undefined = rt.usizeCheckedSub(result, x4); + const _103: rs.usize | undefined = rs.usizeCheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1852,23 +1852,23 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.usize | undefined = rt.usizeCheckedMul(result, radix as rt.usize); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.usize | undefined = rs.usizeCheckedMul(result, radix as rs.usize); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.usize = _67 as rt.usize; + const x3: rs.usize = _67 as rs.usize; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.usize | undefined = rt.usizeCheckedAdd(result, x3); + const _78: rs.usize | undefined = rs.usizeCheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1881,16 +1881,16 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.usizeWrappingMul(result, radix as rt.usize); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.usizeWrappingMul(result, radix as rs.usize); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.usizeWrappingSub(result, _49 as rt.usize); + result = rs.usizeWrappingSub(result, _49 as rs.usize); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1900,75 +1900,75 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.usizeWrappingMul(result, radix as rt.usize); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.usizeWrappingMul(result, radix as rs.usize); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.usizeWrappingAdd(result, _32 as rt.usize); + result = rs.usizeWrappingAdd(result, _32 as rs.usize); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromStr$0qvzsmz(src: string): rt.Result { - return fromStrRadix$0g0g31i(src, 10); +export function fromStr$0ihvy10(src: string): rs.Result { + return fromStrRadix$09i2k2a(src, 10); } -export function fromStr$0wy2fla(src: string): rt.Result { - return fromStrRadix$0ra6q5p(src, 10); +export function fromStr$1gvvety(src: string): rs.Result { + return fromStrRadix$1wu02v6(src, 10); } -export function fromStr$07skih7(src: string): rt.Result { - return fromStrRadix$1xyg67b(src, 10); +export function fromStr$1rjp7t4(src: string): rs.Result { + return fromStrRadix$1ftrr55(src, 10); } -export function fromStr$1ypcnp8(src: string): rt.Result { - return fromStrRadix$1gp4jqq(src, 10); +export function fromStr$0bkyuqf(src: string): rs.Result { + return fromStrRadix$0al5jri(src, 10); } -export function fromStr$1s51v8m(src: string): rt.Result { - return fromStrRadix$1s6gdoj(src, 10); +export function fromStr$1t58fis(src: string): rs.Result { + return fromStrRadix$1osjin2(src, 10); } -export function fromStr$047hkg7(src: string): rt.Result { - return fromStrRadix$146bkjv(src, 10); +export function fromStr$1jgkxdq(src: string): rs.Result { + return fromStrRadix$1479ec4(src, 10); } -export function fromStrRadix$0g0g31i(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0r1q6uy(rt.stringAsBytes(src), radix); +export function fromStrRadix$09i2k2a(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0paozdl(rs.stringAsBytes(src), radix); } -export function fromStrRadix$0ra6q5p(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0q4dbht(rt.stringAsBytes(src), radix); +export function fromStrRadix$1wu02v6(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0wd05by(rs.stringAsBytes(src), radix); } -export function fromStrRadix$1xyg67b(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1xmrosk(rt.stringAsBytes(src), radix); +export function fromStrRadix$1ftrr55(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$15o252c(rs.stringAsBytes(src), radix); } -export function fromStrRadix$1gp4jqq(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$02xpj41(rt.stringAsBytes(src), radix); +export function fromStrRadix$0al5jri(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0zwqu7x(rs.stringAsBytes(src), radix); } -export function fromStrRadix$1s6gdoj(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$037x42t(rt.stringAsBytes(src), radix); +export function fromStrRadix$1osjin2(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1djtuzq(rs.stringAsBytes(src), radix); } -export function fromStrRadix$146bkjv(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1cdwgun(rt.stringAsBytes(src), radix); +export function fromStrRadix$1479ec4(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1lirmeu(rs.stringAsBytes(src), radix); } //# sourceMappingURL=num.ts.map diff --git a/ts/fixtures/lang/ints/expected/core/option.ts b/ts/fixtures/lang/ints/expected/core/option.ts index 6740bb7ac..b8f8f65db 100644 --- a/ts/fixtures/lang/ints/expected/core/option.ts +++ b/ts/fixtures/lang/ints/expected/core/option.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$11c0we2(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { +export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/ints/expected/core/result.ts b/ts/fixtures/lang/ints/expected/core/result.ts index 5ceae2928..dd9d1587e 100644 --- a/ts/fixtures/lang/ints/expected/core/result.ts +++ b/ts/fixtures/lang/ints/expected/core/result.ts @@ -1,142 +1,142 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function eq$0pee78b(self: rt.Result, other: rt.Result): boolean { +export function eq$1o2c9h9(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.i128Eq(self.value, (other as { ok: true; value: rt.i128 }).value); + return rs.i128Eq(self.value, (other as { ok: true; value: rs.i128 }).value); } return true; } -export function eq$1mi4cle(self: rt.Result, other: rt.Result): boolean { +export function eq$0zqqsur(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.i16 }).value; + return self.value === (other as { ok: true; value: rs.i16 }).value; } return true; } -export function eq$1ukayff(self: rt.Result, other: rt.Result): boolean { +export function eq$0f4q5sk(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.i32 }).value; + return self.value === (other as { ok: true; value: rs.i32 }).value; } return true; } -export function eq$1hy1is1(self: rt.Result, other: rt.Result): boolean { +export function eq$12fysd9(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.i64Eq(self.value, (other as { ok: true; value: rt.i64 }).value); + return rs.i64Eq(self.value, (other as { ok: true; value: rs.i64 }).value); } return true; } -export function eq$1hd8lo9(self: rt.Result, other: rt.Result): boolean { +export function eq$0g4cq9b(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.i8 }).value; + return self.value === (other as { ok: true; value: rs.i8 }).value; } return true; } -export function eq$0w2dfat(self: rt.Result, other: rt.Result): boolean { +export function eq$0a3yvnt(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.isize }).value; + return self.value === (other as { ok: true; value: rs.isize }).value; } return true; } -export function eq$06vyx9e(self: rt.Result, other: rt.Result): boolean { +export function eq$04o4aqp(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.u128Eq(self.value, (other as { ok: true; value: rt.u128 }).value); + return rs.u128Eq(self.value, (other as { ok: true; value: rs.u128 }).value); } return true; } -export function eq$08241oi(self: rt.Result, other: rt.Result): boolean { +export function eq$06v73px(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u16 }).value; + return self.value === (other as { ok: true; value: rs.u16 }).value; } return true; } -export function eq$0nbftnc(self: rt.Result, other: rt.Result): boolean { +export function eq$08c3ca7(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u32 }).value; + return self.value === (other as { ok: true; value: rs.u32 }).value; } return true; } -export function eq$1gq81ib(self: rt.Result, other: rt.Result): boolean { +export function eq$07qa6jl(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.u64Eq(self.value, (other as { ok: true; value: rt.u64 }).value); + return rs.u64Eq(self.value, (other as { ok: true; value: rs.u64 }).value); } return true; } -export function eq$12e5exx(self: rt.Result, other: rt.Result): boolean { +export function eq$0qlnrz6(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.u8 }).value; + return self.value === (other as { ok: true; value: rs.u8 }).value; } return true; } -export function eq$1xhgva4(self: rt.Result, other: rt.Result): boolean { +export function eq$1nxe4h7(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.usize }).value; + return self.value === (other as { ok: true; value: rs.usize }).value; } return true; } -export function unwrapOr$01jdcm7(self: rt.Result, default_: string): string { +export function unwrapOr$0a3q6xs(self: rs.Result, default_: string): string { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$0nhd29g(self: rt.Result, default_: rt.u16): rt.u16 { +export function unwrapOr$09f0got(self: rs.Result, default_: rs.u16): rs.u16 { if (self.ok) { return self.value; } return default_; } -export function unwrapOr$09i71ei(self: rt.Result, default_: rt.u64): rt.u64 { +export function unwrapOr$0z0v7fv(self: rs.Result, default_: rs.u64): rs.u64 { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/ints/expected/core/str.ts b/ts/fixtures/lang/ints/expected/core/str.ts index daa507169..8356d07d7 100644 --- a/ts/fixtures/lang/ints/expected/core/str.ts +++ b/ts/fixtures/lang/ints/expected/core/str.ts @@ -1,54 +1,54 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$15pqb75 as num_fromStr$15pqb75, fromStr$0lmxi6o as num_fromStr$0lmxi6o, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1v63ugw as num_fromStr$1v63ugw, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0wy2fla as num_fromStr$0wy2fla, fromStr$07skih7 as num_fromStr$07skih7, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m, fromStr$047hkg7 as num_fromStr$047hkg7 } from "../core/num.ts"; +import * as rs from "../rs.ts"; +import { fromStr$1el0yvy as num_fromStr$1el0yvy, fromStr$0ehcbzz as num_fromStr$0ehcbzz, fromStr$1ckv470 as num_fromStr$1ckv470, fromStr$00n8jbp as num_fromStr$00n8jbp, fromStr$1amqoj7 as num_fromStr$1amqoj7, fromStr$0ytcpik as num_fromStr$0ytcpik, fromStr$0ihvy10 as num_fromStr$0ihvy10, fromStr$1gvvety as num_fromStr$1gvvety, fromStr$1rjp7t4 as num_fromStr$1rjp7t4, fromStr$0bkyuqf as num_fromStr$0bkyuqf, fromStr$1t58fis as num_fromStr$1t58fis, fromStr$1jgkxdq as num_fromStr$1jgkxdq } from "../core/num.ts"; -export function parse$082ztwj(self: string): rt.Result { - return num_fromStr$0zyj6he(self); +export function parse$1kyj9pm(self: string): rs.Result { + return num_fromStr$1el0yvy(self); } -export function parse$15bt1cx(self: string): rt.Result { - return num_fromStr$15pqb75(self); +export function parse$00ajhlu(self: string): rs.Result { + return num_fromStr$0ehcbzz(self); } -export function parse$072345g(self: string): rt.Result { - return num_fromStr$0lmxi6o(self); +export function parse$14v13am(self: string): rs.Result { + return num_fromStr$1ckv470(self); } -export function parse$11m1f1e(self: string): rt.Result { - return num_fromStr$116mp4t(self); +export function parse$0px1msj(self: string): rs.Result { + return num_fromStr$00n8jbp(self); } -export function parse$14z7a72(self: string): rt.Result { - return num_fromStr$029r9bb(self); +export function parse$02m1946(self: string): rs.Result { + return num_fromStr$1amqoj7(self); } -export function parse$0uguq9k(self: string): rt.Result { - return num_fromStr$1v63ugw(self); +export function parse$1g90yxu(self: string): rs.Result { + return num_fromStr$0ytcpik(self); } -export function parse$069o3rw(self: string): rt.Result { - return num_fromStr$0qvzsmz(self); +export function parse$11owssr(self: string): rs.Result { + return num_fromStr$0ihvy10(self); } -export function parse$1kk1wco(self: string): rt.Result { - return num_fromStr$0wy2fla(self); +export function parse$0un0sth(self: string): rs.Result { + return num_fromStr$1gvvety(self); } -export function parse$0wgc3xh(self: string): rt.Result { - return num_fromStr$07skih7(self); +export function parse$069xxen(self: string): rs.Result { + return num_fromStr$1rjp7t4(self); } -export function parse$0o4ono0(self: string): rt.Result { - return num_fromStr$1ypcnp8(self); +export function parse$092epd5(self: string): rs.Result { + return num_fromStr$0bkyuqf(self); } -export function parse$0vh70p5(self: string): rt.Result { - return num_fromStr$1s51v8m(self); +export function parse$1brosjp(self: string): rs.Result { + return num_fromStr$1t58fis(self); } -export function parse$1i990qj(self: string): rt.Result { - return num_fromStr$047hkg7(self); +export function parse$07zoymb(self: string): rs.Result { + return num_fromStr$1jgkxdq(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/ints/expected/harness.ts b/ts/fixtures/lang/ints/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/ints/expected/harness.ts +++ b/ts/fixtures/lang/ints/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/ints/expected/ints.Scaled.ts b/ts/fixtures/lang/ints/expected/ints.Scaled.ts index b38249780..8fd9b1be6 100644 --- a/ts/fixtures/lang/ints/expected/ints.Scaled.ts +++ b/ts/fixtures/lang/ints/expected/ints.Scaled.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A type of the crate's own that `From` makes, which `try_from` converts by. */ export interface Scaled { - _0: rt.u32; + _0: rs.u32; } -export function from$convert_From_u8(b: rt.u8): Scaled { - return { _0: rt.u32Mul(b as rt.u32, 1000) }; +export function from$convert_From_u8(b: rs.u8): Scaled { + return { _0: rs.u32Mul(b as rs.u32, 1000) }; } //# sourceMappingURL=ints.Scaled.ts.map diff --git a/ts/fixtures/lang/ints/expected/ints.ts b/ts/fixtures/lang/ints/expected/ints.ts index 2f8b099e1..e9a9adbef 100644 --- a/ts/fixtures/lang/ints/expected/ints.ts +++ b/ts/fixtures/lang/ints/expected/ints.ts @@ -1,57 +1,57 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { toDigit$01k9ewn } from "./core/char/methods.ts"; -import { fromStr$0zyj6he as num_fromStr$0zyj6he, fromStr$15pqb75 as num_fromStr$15pqb75, fromStr$0lmxi6o as num_fromStr$0lmxi6o, fromStr$116mp4t as num_fromStr$116mp4t, fromStr$029r9bb as num_fromStr$029r9bb, fromStr$1v63ugw as num_fromStr$1v63ugw, fromStrRadix$0366bau as num_fromStrRadix$0366bau, fromStrRadix$0rk2yr6 as num_fromStrRadix$0rk2yr6, fromStrRadix$1newkmi as num_fromStrRadix$1newkmi, fromStrRadix$11y6fsf as num_fromStrRadix$11y6fsf, fromStrRadix$0dg9fx3 as num_fromStrRadix$0dg9fx3, fromStrRadix$16jk9zm as num_fromStrRadix$16jk9zm, fromStr$0qvzsmz as num_fromStr$0qvzsmz, fromStr$0wy2fla as num_fromStr$0wy2fla, fromStr$07skih7 as num_fromStr$07skih7, fromStr$1ypcnp8 as num_fromStr$1ypcnp8, fromStr$1s51v8m as num_fromStr$1s51v8m, fromStr$047hkg7 as num_fromStr$047hkg7, fromStrRadix$0g0g31i as num_fromStrRadix$0g0g31i, fromStrRadix$0ra6q5p as num_fromStrRadix$0ra6q5p, fromStrRadix$1xyg67b as num_fromStrRadix$1xyg67b, fromStrRadix$1gp4jqq as num_fromStrRadix$1gp4jqq, fromStrRadix$1s6gdoj as num_fromStrRadix$1s6gdoj, fromStrRadix$146bkjv as num_fromStrRadix$146bkjv } from "./core/num.ts"; -import { isSomeAnd$09tpccf, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { eq$0pee78b as result_eq$0pee78b, eq$1mi4cle as result_eq$1mi4cle, eq$1ukayff as result_eq$1ukayff, eq$1hy1is1 as result_eq$1hy1is1, eq$1hd8lo9 as result_eq$1hd8lo9, eq$0w2dfat as result_eq$0w2dfat, eq$06vyx9e as result_eq$06vyx9e, eq$08241oi as result_eq$08241oi, eq$0nbftnc as result_eq$0nbftnc, eq$1gq81ib as result_eq$1gq81ib, eq$12e5exx as result_eq$12e5exx, eq$1xhgva4 as result_eq$1xhgva4, unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7, unwrapOr$0nhd29g as result_unwrapOr$0nhd29g, unwrapOr$09i71ei as result_unwrapOr$09i71ei } from "./core/result.ts"; -import { parse$082ztwj, parse$15bt1cx, parse$072345g, parse$11m1f1e, parse$14z7a72, parse$0uguq9k, parse$069o3rw, parse$1kk1wco, parse$0wgc3xh, parse$0o4ono0, parse$0vh70p5, parse$1i990qj } from "./core/str.ts"; +import * as rs from "./rs.ts"; +import { toDigit$14z95r4 } from "./core/char/methods.ts"; +import { fromStr$1el0yvy as num_fromStr$1el0yvy, fromStr$0ehcbzz as num_fromStr$0ehcbzz, fromStr$1ckv470 as num_fromStr$1ckv470, fromStr$00n8jbp as num_fromStr$00n8jbp, fromStr$1amqoj7 as num_fromStr$1amqoj7, fromStr$0ytcpik as num_fromStr$0ytcpik, fromStrRadix$0cysu2u as num_fromStrRadix$0cysu2u, fromStrRadix$19vdb8q as num_fromStrRadix$19vdb8q, fromStrRadix$1ct8u92 as num_fromStrRadix$1ct8u92, fromStrRadix$04fc4zz as num_fromStrRadix$04fc4zz, fromStrRadix$0qyezqs as num_fromStrRadix$0qyezqs, fromStrRadix$1nys6eo as num_fromStrRadix$1nys6eo, fromStr$0ihvy10 as num_fromStr$0ihvy10, fromStr$1gvvety as num_fromStr$1gvvety, fromStr$1rjp7t4 as num_fromStr$1rjp7t4, fromStr$0bkyuqf as num_fromStr$0bkyuqf, fromStr$1t58fis as num_fromStr$1t58fis, fromStr$1jgkxdq as num_fromStr$1jgkxdq, fromStrRadix$09i2k2a as num_fromStrRadix$09i2k2a, fromStrRadix$1wu02v6 as num_fromStrRadix$1wu02v6, fromStrRadix$1ftrr55 as num_fromStrRadix$1ftrr55, fromStrRadix$0al5jri as num_fromStrRadix$0al5jri, fromStrRadix$1osjin2 as num_fromStrRadix$1osjin2, fromStrRadix$1479ec4 as num_fromStrRadix$1479ec4 } from "./core/num.ts"; +import { isSomeAnd$1s2u5lz, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { eq$1o2c9h9 as result_eq$1o2c9h9, eq$0zqqsur as result_eq$0zqqsur, eq$0f4q5sk as result_eq$0f4q5sk, eq$12fysd9 as result_eq$12fysd9, eq$0g4cq9b as result_eq$0g4cq9b, eq$0a3yvnt as result_eq$0a3yvnt, eq$04o4aqp as result_eq$04o4aqp, eq$06v73px as result_eq$06v73px, eq$08c3ca7 as result_eq$08c3ca7, eq$07qa6jl as result_eq$07qa6jl, eq$0qlnrz6 as result_eq$0qlnrz6, eq$1nxe4h7 as result_eq$1nxe4h7, unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs, unwrapOr$09f0got as result_unwrapOr$09f0got, unwrapOr$0z0v7fv as result_unwrapOr$0z0v7fv } from "./core/result.ts"; +import { parse$1kyj9pm, parse$00ajhlu, parse$14v13am, parse$0px1msj, parse$02m1946, parse$1g90yxu, parse$11owssr, parse$0un0sth, parse$069xxen, parse$092epd5, parse$1brosjp, parse$07zoymb } from "./core/str.ts"; import { put } from "./harness.ts"; import * as Scaled from "./ints.Scaled.ts"; /** Apply operation `op` to operands taken from `data`. */ -export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v3: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); - rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v3)) === v3 ? 1 : 0); +export function u8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.u8 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u8 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.u8 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v5 as rt.u128))); + const v5: rs.u8 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); } }; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.u8 = rt.u8FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u8 = _19; + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.u8 = rs.u8FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u8 = _19; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.u8 = rt.u8FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.u8 = _38; + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.u8 = rs.u8FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.u8 = _38; const buf3: Uint8Array = Uint8Array.of(0); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.u8 = ([rt.u8FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.u8, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 8); - const _70: rt.u8 = rt.u8Rem(op, 32); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.u8 = ([rs.u8FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u8, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 8); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.u8Add(a, b)); + _68(out, rs.u8Add(a, b)); } else if (_70 === 1) { - _68(out, rt.u8Sub(a, b)); + _68(out, rs.u8Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.u8Mul(a, b)); + _68(out, rs.u8Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.u8Div(a, b)); + _68(out, rs.u8Div(a, b)); } else if (_70 === 4) { - _68(out, rt.u8Rem(a, b)); + _68(out, rs.u8Rem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -59,162 +59,162 @@ export function u8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.u8Shl(a, shift)); + _68(out, rs.u8Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.u8Shr(a, shift)); + _68(out, rs.u8Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a & 0xff); } else if (_70 === 11) { - const part16 = rt.u8CheckedAdd(a, b); + const part16 = rs.u8CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.u8CheckedSub(a, b); + const part15 = rs.u8CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.u8CheckedMul(a, b); + const part14 = rs.u8CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.u8SaturatingAdd(a, b); + const part13 = rs.u8SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.u8SaturatingSub(a, b); + const part12 = rs.u8SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.u8WrappingAdd(a, b); + const part11 = rs.u8WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.u8WrappingSub(a, b); + const part10 = rs.u8WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u8LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u8LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.u8WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.u8WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.u8 = rt.u8Add(a, b); - rt.u8Mul(x, b); - rt.u8Mul(rt.u8Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.u8 = rs.u8Add(a, b); + rs.u8Mul(x, b); + rs.u8Mul(rs.u8Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.u8SaturatingMul(a, b); + const part7 = rs.u8SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.u8WrappingMul(a, b); + const part6 = rs.u8WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.u8 | undefined = rt.u8DivCeil(a, b); + const _176: rs.u8 | undefined = rs.u8DivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.u8IsMultipleOf(a, b); + const _183: boolean | undefined = rs.u8IsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.u8ToBeBytes(a).reverse(), rt.u8ToBeBytes(a).reverse(), rt.u8ToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.u8ToBeBytes(a).reverse(), rs.u8ToBeBytes(a).reverse(), rs.u8ToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.u8FromBeBytes(le.slice().reverse()); + const part = rs.u8FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.u8FromBeBytes(ne.slice().reverse()); + const part2 = rs.u8FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.u8FromBeBytes(be.slice().reverse()); + const part3 = rs.u8FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.u8FromBeBytes(be.slice().reverse()); + const part4 = rs.u8FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice(Uint8Array.of(0, 1, 255, 0, a, rt.u8Shl(a, rt.u32Rem(shift, 8)))); + const iter: rs.Iter = rs.iterSlice(Uint8Array.of(0, 1, 255, 0, a, rs.u8Shl(a, rs.u32Rem(shift, 8)))); while (true) { - const _229: rt.u8 | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.u8 | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.u8 = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8TrailingZeros(v2)))); - const _238: rt.u8 | undefined = rt.nonZero(v2); + const v2: rs.u8 = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u8TrailingZeros(v2)))); + const _238: rs.u8 | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.u8 = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u8LeadingZeros(n4)))); + const n4: rs.u8 = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u8TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u8LeadingZeros(n4)))); } } } else { - let x2: rt.u8 = a; - x2 = rt.u8Add(x2, b); - x2 = rt.u8Sub(x2, 1); - x2 = rt.u8Mul(x2, 2); + let x2: rs.u8 = a; + x2 = rs.u8Add(x2, b); + x2 = rs.u8Sub(x2, 1); + x2 = rs.u8Mul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1) & 0xff; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & (~(1 << 2) & 0xff); - x2 = rt.u8Rem(x2, 7); - x2 = rt.u8Div(x2, 3); + x2 = rs.u8Rem(x2, 7); + x2 = rs.u8Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v3: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); - rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v3)) === v3 ? 1 : 0); +export function u16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.u16 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.u16 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u16 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.u16 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v5 as rt.u128))); + const v5: rs.u16 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); } }; - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.u16 = rt.u16FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u16 = _19; - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.u16 = rt.u16FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.u16 = _38; - const buf3: Uint8Array = rt.bytes(2); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.u16 = ([rt.u16FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.u16, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 16); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.u16 = rs.u16FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u16 = _19; + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.u16 = rs.u16FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.u16 = _38; + const buf3: Uint8Array = rs.bytes(2); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.u16 = ([rs.u16FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u16, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 16); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.u16Add(a, b)); + _68(out, rs.u16Add(a, b)); } else if (_70 === 1) { - _68(out, rt.u16Sub(a, b)); + _68(out, rs.u16Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.u16Mul(a, b)); + _68(out, rs.u16Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.u16Div(a, b)); + _68(out, rs.u16Div(a, b)); } else if (_70 === 4) { - _68(out, rt.u16Rem(a, b)); + _68(out, rs.u16Rem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -222,162 +222,162 @@ export function u16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.u16Shl(a, shift)); + _68(out, rs.u16Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.u16Shr(a, shift)); + _68(out, rs.u16Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a & 0xffff); } else if (_70 === 11) { - const part16 = rt.u16CheckedAdd(a, b); + const part16 = rs.u16CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.u16CheckedSub(a, b); + const part15 = rs.u16CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.u16CheckedMul(a, b); + const part14 = rs.u16CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.u16SaturatingAdd(a, b); + const part13 = rs.u16SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.u16SaturatingSub(a, b); + const part12 = rs.u16SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.u16WrappingAdd(a, b); + const part11 = rs.u16WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.u16WrappingSub(a, b); + const part10 = rs.u16WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u16LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u16LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.u16WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.u16WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.u16 = rt.u16Add(a, b); - rt.u16Mul(x, b); - rt.u16Mul(rt.u16Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.u16 = rs.u16Add(a, b); + rs.u16Mul(x, b); + rs.u16Mul(rs.u16Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.u16SaturatingMul(a, b); + const part7 = rs.u16SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.u16WrappingMul(a, b); + const part6 = rs.u16WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.u16 | undefined = rt.u16DivCeil(a, b); + const _176: rs.u16 | undefined = rs.u16DivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.u16IsMultipleOf(a, b); + const _183: boolean | undefined = rs.u16IsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.u16ToBeBytes(a).reverse(), rt.u16ToBeBytes(a).reverse(), rt.u16ToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.u16ToBeBytes(a).reverse(), rs.u16ToBeBytes(a).reverse(), rs.u16ToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.u16FromBeBytes(le.slice().reverse()); + const part = rs.u16FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.u16FromBeBytes(ne.slice().reverse()); + const part2 = rs.u16FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.u16FromBeBytes(be.slice().reverse()); + const part3 = rs.u16FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.u16FromBeBytes(be.slice().reverse()); + const part4 = rs.u16FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 65535, 0, a, rt.u16Shl(a, rt.u32Rem(shift, 16))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 65535, 0, a, rs.u16Shl(a, rs.u32Rem(shift, 16))]); while (true) { - const _229: rt.u16 | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.u16 | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.u16 = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16TrailingZeros(v2)))); - const _238: rt.u16 | undefined = rt.nonZero(v2); + const v2: rs.u16 = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u16TrailingZeros(v2)))); + const _238: rs.u16 | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.u16 = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u16LeadingZeros(n4)))); + const n4: rs.u16 = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u16TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u16LeadingZeros(n4)))); } } } else { - let x2: rt.u16 = a; - x2 = rt.u16Add(x2, b); - x2 = rt.u16Sub(x2, 1); - x2 = rt.u16Mul(x2, 2); + let x2: rs.u16 = a; + x2 = rs.u16Add(x2, b); + x2 = rs.u16Sub(x2, 1); + x2 = rs.u16Mul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1) & 0xffff; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & (~(1 << 2) & 0xffff); - x2 = rt.u16Rem(x2, 7); - x2 = rt.u16Div(x2, 3); + x2 = rs.u16Rem(x2, 7); + x2 = rs.u16Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v3: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); - rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v3)) === v3 ? 1 : 0); +export function u32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.u32 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u32 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.u32 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v5 as rt.u128))); + const v5: rs.u32 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); } }; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.u32 = rt.u32FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u32 = _19; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.u32 = rt.u32FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.u32 = _38; - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.u32 = ([rt.u32FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.u32, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 32); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.u32 = rs.u32FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u32 = _19; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.u32 = rs.u32FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.u32 = _38; + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.u32 = ([rs.u32FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u32, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.u32Add(a, b)); + _68(out, rs.u32Add(a, b)); } else if (_70 === 1) { - _68(out, rt.u32Sub(a, b)); + _68(out, rs.u32Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.u32Mul(a, b)); + _68(out, rs.u32Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.u32Div(a, b)); + _68(out, rs.u32Div(a, b)); } else if (_70 === 4) { - _68(out, rt.u32Rem(a, b)); + _68(out, rs.u32Rem(a, b)); } else if (_70 === 5) { _68(out, (a & b) >>> 0); } else if (_70 === 6) { @@ -385,488 +385,488 @@ export function u32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, (a ^ b) >>> 0); } else if (_70 === 8) { - _68(out, rt.u32Shl(a, shift)); + _68(out, rs.u32Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.u32Shr(a, shift)); + _68(out, rs.u32Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a >>> 0); } else if (_70 === 11) { - const part16 = rt.u32CheckedAdd(a, b); + const part16 = rs.u32CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.u32CheckedSub(a, b); + const part15 = rs.u32CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.u32CheckedMul(a, b); + const part14 = rs.u32CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.u32SaturatingAdd(a, b); + const part13 = rs.u32SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.u32SaturatingSub(a, b); + const part12 = rs.u32SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.u32WrappingAdd(a, b); + const part11 = rs.u32WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.u32WrappingSub(a, b); + const part10 = rs.u32WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.u32WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.u32WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.u32 = rt.u32Add(a, b); - rt.u32Mul(x, b); - rt.u32Mul(rt.u32Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.u32 = rs.u32Add(a, b); + rs.u32Mul(x, b); + rs.u32Mul(rs.u32Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.u32SaturatingMul(a, b); + const part7 = rs.u32SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.u32WrappingMul(a, b); + const part6 = rs.u32WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.u32 | undefined = rt.u32DivCeil(a, b); + const _176: rs.u32 | undefined = rs.u32DivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.u32IsMultipleOf(a, b); + const _183: boolean | undefined = rs.u32IsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.u32ToBeBytes(a).reverse(), rt.u32ToBeBytes(a).reverse(), rt.u32ToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.u32ToBeBytes(a).reverse(), rs.u32ToBeBytes(a).reverse(), rs.u32ToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.u32FromBeBytes(le.slice().reverse()); + const part = rs.u32FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.u32FromBeBytes(ne.slice().reverse()); + const part2 = rs.u32FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.u32FromBeBytes(be.slice().reverse()); + const part3 = rs.u32FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.u32FromBeBytes(be.slice().reverse()); + const part4 = rs.u32FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 4294967295, 0, a, rt.u32Shl(a, rt.u32Rem(shift, 32))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 4294967295, 0, a, rs.u32Shl(a, rs.u32Rem(shift, 32))]); while (true) { - const _229: rt.u32 | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.u32 | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.u32 = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32TrailingZeros(v2)))); - const _238: rt.u32 | undefined = rt.nonZero(v2); + const v2: rs.u32 = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32TrailingZeros(v2)))); + const _238: rs.u32 | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.u32 = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32LeadingZeros(n4)))); + const n4: rs.u32 = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32LeadingZeros(n4)))); } } } else { - let x2: rt.u32 = a; - x2 = rt.u32Add(x2, b); - x2 = rt.u32Sub(x2, 1); - x2 = rt.u32Mul(x2, 2); + let x2: rs.u32 = a; + x2 = rs.u32Add(x2, b); + x2 = rs.u32Sub(x2, 1); + x2 = rs.u32Mul(x2, 2); x2 = x2 >>> 1; x2 = (x2 << 1) >>> 0; x2 = (x2 | (1 << 3)) >>> 0; x2 = (x2 ^ b) >>> 0; x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; - x2 = rt.u32Rem(x2, 7); - x2 = rt.u32Div(x2, 3); + x2 = rs.u32Rem(x2, 7); + x2 = rs.u32Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function u64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v3: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v3)))); - rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v3)), v3) ? 1 : 0); +export function u64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); + rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v3)), v3) ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.u64 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.u64 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u64 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.u64 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v5)))); + const v5: rs.u64 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v5)))); } }; - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.u64 = rt.u64FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u64 = _19; - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.u64 = rt.u64FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.u64 = _38; - const buf3: Uint8Array = rt.bytes(8); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.u64 = ([rt.u64FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.u64, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 64); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.u64 = rs.u64FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u64 = _19; + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.u64 = rs.u64FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.u64 = _38; + const buf3: Uint8Array = rs.bytes(8); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.u64 = ([rs.u64FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u64, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 64); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.u64Add(a, b)); + _68(out, rs.u64Add(a, b)); } else if (_70 === 1) { - _68(out, rt.u64Sub(a, b)); + _68(out, rs.u64Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.u64Mul(a, b)); + _68(out, rs.u64Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.u64Div(a, b)); + _68(out, rs.u64Div(a, b)); } else if (_70 === 4) { - _68(out, rt.u64Rem(a, b)); + _68(out, rs.u64Rem(a, b)); } else if (_70 === 5) { - _68(out, rt.u64And(a, b)); + _68(out, rs.u64And(a, b)); } else if (_70 === 6) { - _68(out, rt.u64Or(a, b)); + _68(out, rs.u64Or(a, b)); } else if (_70 === 7) { - _68(out, rt.u64Xor(a, b)); + _68(out, rs.u64Xor(a, b)); } else if (_70 === 8) { - _68(out, rt.u64Shl(a, shift)); + _68(out, rs.u64Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.u64Shr(a, shift)); + _68(out, rs.u64Shr(a, shift)); } else if (_70 === 10) { - _68(out, rt.u64Not(a)); + _68(out, rs.u64Not(a)); } else if (_70 === 11) { - const part16 = rt.u64CheckedAdd(a, b); + const part16 = rs.u64CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.u64CheckedSub(a, b); + const part15 = rs.u64CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.u64CheckedMul(a, b); + const part14 = rs.u64CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.u64SaturatingAdd(a, b); + const part13 = rs.u64SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.u64SaturatingSub(a, b); + const part12 = rs.u64SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.u64WrappingAdd(a, b); + const part11 = rs.u64WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.u64WrappingSub(a, b); + const part10 = rs.u64WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.u64Max(a, b)); + _68(out, rs.u64Max(a, b)); } else if (_70 === 21) { - _68(out, rt.u64Min(a, b)); + _68(out, rs.u64Min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, rt.u64Eq(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u64Lt(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u64Ge(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u64WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u64Lt(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u64Ge(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u64WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.u64 = rt.u64Add(a, b); - rt.u64Mul(x, b); - rt.u64Mul(rt.u64Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.u64 = rs.u64Add(a, b); + rs.u64Mul(x, b); + rs.u64Mul(rs.u64Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.u64SaturatingMul(a, b); + const part7 = rs.u64SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.u64WrappingMul(a, b); + const part6 = rs.u64WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.u64Clamp(a, b, c); + const part5 = rs.u64Clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.u64 | undefined = rt.u64DivCeil(a, b); + const _176: rs.u64 | undefined = rs.u64DivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.u64IsMultipleOf(a, b); + const _183: boolean | undefined = rs.u64IsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.u64ToBeBytes(a).reverse(), rt.u64ToBeBytes(a).reverse(), rt.u64ToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.u64ToBeBytes(a).reverse(), rs.u64ToBeBytes(a).reverse(), rs.u64ToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.u64FromBeBytes(le.slice().reverse()); + const part = rs.u64FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.u64FromBeBytes(ne.slice().reverse()); + const part2 = rs.u64FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.u64FromBeBytes(be.slice().reverse()); + const part3 = rs.u64FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.u64FromBeBytes(be.slice().reverse()); + const part4 = rs.u64FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, 0, a, rt.u64Shl(a, rt.u32Rem(shift, 64))]); + const iter: rs.Iter = rs.iterSlice([0, 1, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, 0, a, rs.u64Shl(a, rs.u32Rem(shift, 64))]); while (true) { - const _229: rt.u64 | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.u64 | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.u64 = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64TrailingZeros(v2)))); - const _238: rt.u64 | undefined = rt.nonZero(v2); + const v2: rs.u64 = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64TrailingZeros(v2)))); + const _238: rs.u64 | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.u64 = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u64LeadingZeros(n4)))); + const n4: rs.u64 = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u64LeadingZeros(n4)))); } } } else { - let x2: rt.u64 = a; - x2 = rt.u64Add(x2, b); - x2 = rt.u64Sub(x2, 1); - x2 = rt.u64Mul(x2, 2); - x2 = rt.u64Shr(x2, 1); - x2 = rt.u64Shl(x2, 1); - x2 = rt.u64Or(x2, 8); - x2 = rt.u64Xor(x2, b); - x2 = rt.u64And(x2, rt.u64Not(4)); - x2 = rt.u64Rem(x2, 7); - x2 = rt.u64Div(x2, 3); + let x2: rs.u64 = a; + x2 = rs.u64Add(x2, b); + x2 = rs.u64Sub(x2, 1); + x2 = rs.u64Mul(x2, 2); + x2 = rs.u64Shr(x2, 1); + x2 = rs.u64Shl(x2, 1); + x2 = rs.u64Or(x2, 8); + x2 = rs.u64Xor(x2, b); + x2 = rs.u64And(x2, rs.u64Not(4)); + x2 = rs.u64Rem(x2, 7); + x2 = rs.u64Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function u128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v3: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3))); - rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v3)), v3) ? 1 : 0); +export function u128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); + rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v3)), v3) ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.u128 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.u128 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.u128 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.u128 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v5))); + const v5: rs.u128 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5))); } }; - const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.u128 = rt.u128FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.u128 = _19; - const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.u128 = rt.u128FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.u128 = _38; - const buf3: Uint8Array = rt.bytes(16); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.u128 = ([rt.u128FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.u128, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 128); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.u128 = rs.u128FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.u128 = _19; + const buf2: Uint8Array = rs.bytes(16); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.u128 = rs.u128FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.u128 = _38; + const buf3: Uint8Array = rs.bytes(16); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.u128 = ([rs.u128FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.u128, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 128); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.u128Add(a, b)); + _68(out, rs.u128Add(a, b)); } else if (_70 === 1) { - _68(out, rt.u128Sub(a, b)); + _68(out, rs.u128Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.u128Mul(a, b)); + _68(out, rs.u128Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.u128Div(a, b)); + _68(out, rs.u128Div(a, b)); } else if (_70 === 4) { - _68(out, rt.u128Rem(a, b)); + _68(out, rs.u128Rem(a, b)); } else if (_70 === 5) { - _68(out, rt.u128And(a, b)); + _68(out, rs.u128And(a, b)); } else if (_70 === 6) { - _68(out, rt.u128Or(a, b)); + _68(out, rs.u128Or(a, b)); } else if (_70 === 7) { - _68(out, rt.u128Xor(a, b)); + _68(out, rs.u128Xor(a, b)); } else if (_70 === 8) { - _68(out, rt.u128Shl(a, shift)); + _68(out, rs.u128Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.u128Shr(a, shift)); + _68(out, rs.u128Shr(a, shift)); } else if (_70 === 10) { - _68(out, rt.u128Not(a)); + _68(out, rs.u128Not(a)); } else if (_70 === 11) { - const part16 = rt.u128CheckedAdd(a, b); + const part16 = rs.u128CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.u128CheckedSub(a, b); + const part15 = rs.u128CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.u128CheckedMul(a, b); + const part14 = rs.u128CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.u128SaturatingAdd(a, b); + const part13 = rs.u128SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.u128SaturatingSub(a, b); + const part12 = rs.u128SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.u128WrappingAdd(a, b); + const part11 = rs.u128WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.u128WrappingSub(a, b); + const part10 = rs.u128WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u128LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u128LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.u128Max(a, b)); + _68(out, rs.u128Max(a, b)); } else if (_70 === 21) { - _68(out, rt.u128Min(a, b)); + _68(out, rs.u128Min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, rt.u128Eq(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u128Lt(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u128Ge(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.u128WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.u128Eq(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u128Lt(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u128Ge(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u128WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.u128 = rt.u128Add(a, b); - rt.u128Mul(x, b); - rt.u128Mul(rt.u128Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.u128 = rs.u128Add(a, b); + rs.u128Mul(x, b); + rs.u128Mul(rs.u128Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.u128SaturatingMul(a, b); + const part7 = rs.u128SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.u128WrappingMul(a, b); + const part6 = rs.u128WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.u128Clamp(a, b, c); + const part5 = rs.u128Clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.u128 | undefined = rt.u128DivCeil(a, b); + const _176: rs.u128 | undefined = rs.u128DivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.u128IsMultipleOf(a, b); + const _183: boolean | undefined = rs.u128IsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.u128ToBeBytes(a).reverse(), rt.u128ToBeBytes(a).reverse(), rt.u128ToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.u128ToBeBytes(a).reverse(), rs.u128ToBeBytes(a).reverse(), rs.u128ToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.u128FromBeBytes(le.slice().reverse()); + const part = rs.u128FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.u128FromBeBytes(ne.slice().reverse()); + const part2 = rs.u128FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.u128FromBeBytes(be.slice().reverse()); + const part3 = rs.u128FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.u128FromBeBytes(be.slice().reverse()); + const part4 = rs.u128FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, a, rt.u128Shl(a, rt.u32Rem(shift, 128))]); + const iter: rs.Iter = rs.iterSlice([0, 1, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, a, rs.u128Shl(a, rs.u32Rem(shift, 128))]); while (true) { - const _229: rt.u128 | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.u128 | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.u128 = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128TrailingZeros(v2)))); - const _238: rt.u128 | undefined = rt.nonZero(v2); + const v2: rs.u128 = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u128TrailingZeros(v2)))); + const _238: rs.u128 | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.u128 = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u128LeadingZeros(n4)))); + const n4: rs.u128 = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u128TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u128LeadingZeros(n4)))); } } } else { - let x2: rt.u128 = a; - x2 = rt.u128Add(x2, b); - x2 = rt.u128Sub(x2, 1); - x2 = rt.u128Mul(x2, 2); - x2 = rt.u128Shr(x2, 1); - x2 = rt.u128Shl(x2, 1); - x2 = rt.u128Or(x2, rt.u128Shl(1, 3)); - x2 = rt.u128Xor(x2, b); - x2 = rt.u128And(x2, rt.u128Not(rt.u128Shl(1, 2))); - x2 = rt.u128Rem(x2, 7); - x2 = rt.u128Div(x2, 3); + let x2: rs.u128 = a; + x2 = rs.u128Add(x2, b); + x2 = rs.u128Sub(x2, 1); + x2 = rs.u128Mul(x2, 2); + x2 = rs.u128Shr(x2, 1); + x2 = rs.u128Shl(x2, 1); + x2 = rs.u128Or(x2, rs.u128Shl(1, 3)); + x2 = rs.u128Xor(x2, b); + x2 = rs.u128And(x2, rs.u128Not(rs.u128Shl(1, 2))); + x2 = rs.u128Rem(x2, 7); + x2 = rs.u128Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v3: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); - rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v3)) === v3 ? 1 : 0); +export function usizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); + rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.usize | undefined) => undefined = (out3: rt.ByteVec, v4: rt.usize | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.usize | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.usize = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u128ToBeBytes(v5 as rt.u128))); + const v5: rs.usize = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u128ToBeBytes(v5 as rs.u128))); } }; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.usize = rt.usizeFromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.usize = _19; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.usize = rt.usizeFromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.usize = _38; - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.usize = ([rt.usizeFromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.usize, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 32); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.usize = rs.usizeFromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.usize = _19; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.usize = rs.usizeFromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.usize = _38; + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.usize = ([rs.usizeFromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.usize, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.usizeAdd(a, b)); + _68(out, rs.usizeAdd(a, b)); } else if (_70 === 1) { - _68(out, rt.usizeSub(a, b)); + _68(out, rs.usizeSub(a, b)); } else if (_70 === 2) { - _68(out, rt.usizeMul(a, b)); + _68(out, rs.usizeMul(a, b)); } else if (_70 === 3) { - _68(out, rt.usizeDiv(a, b)); + _68(out, rs.usizeDiv(a, b)); } else if (_70 === 4) { - _68(out, rt.usizeRem(a, b)); + _68(out, rs.usizeRem(a, b)); } else if (_70 === 5) { _68(out, (a & b) >>> 0); } else if (_70 === 6) { @@ -874,162 +874,162 @@ export function usizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, (a ^ b) >>> 0); } else if (_70 === 8) { - _68(out, rt.usizeShl(a, shift)); + _68(out, rs.usizeShl(a, shift)); } else if (_70 === 9) { - _68(out, rt.usizeShr(a, shift)); + _68(out, rs.usizeShr(a, shift)); } else if (_70 === 10) { _68(out, ~a >>> 0); } else if (_70 === 11) { - const part16 = rt.usizeCheckedAdd(a, b); + const part16 = rs.usizeCheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.usizeCheckedSub(a, b); + const part15 = rs.usizeCheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.usizeCheckedMul(a, b); + const part14 = rs.usizeCheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.usizeSaturatingAdd(a, b); + const part13 = rs.usizeSaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.usizeSaturatingSub(a, b); + const part12 = rs.usizeSaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.usizeWrappingAdd(a, b); + const part11 = rs.usizeWrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.usizeWrappingSub(a, b); + const part10 = rs.usizeWrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeLeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.usizeLeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeLeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.usizeLeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.usizeWrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.usizeWrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.usize = rt.usizeAdd(a, b); - rt.usizeMul(x, b); - rt.usizeMul(rt.usizeSub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.usize = rs.usizeAdd(a, b); + rs.usizeMul(x, b); + rs.usizeMul(rs.usizeSub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.usizeSaturatingMul(a, b); + const part7 = rs.usizeSaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.usizeWrappingMul(a, b); + const part6 = rs.usizeWrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _176: rt.usize | undefined = rt.usizeDivCeil(a, b); + const _176: rs.usize | undefined = rs.usizeDivCeil(a, b); if (_176 !== undefined) { _68(out, _176); } } else if (_70 === 28) { - const _183: boolean | undefined = rt.usizeIsMultipleOf(a, b); + const _183: boolean | undefined = rs.usizeIsMultipleOf(a, b); if (_183 !== undefined) { - rt.byteVecPush(out, _183 ? 1 : 0); + rs.byteVecPush(out, _183 ? 1 : 0); } } else if (_70 === 29) { - const _192: [Uint8Array, Uint8Array, Uint8Array] = [rt.usizeToBeBytes(a).reverse(), rt.usizeToBeBytes(a).reverse(), rt.usizeToBeBytes(a)]; + const _192: [Uint8Array, Uint8Array, Uint8Array] = [rs.usizeToBeBytes(a).reverse(), rs.usizeToBeBytes(a).reverse(), rs.usizeToBeBytes(a)]; const le: Uint8Array = _192[0]; const ne: Uint8Array = _192[1]; const be: Uint8Array = _192[2]; - const part = rt.usizeFromBeBytes(le.slice().reverse()); + const part = rs.usizeFromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.usizeFromBeBytes(ne.slice().reverse()); + const part2 = rs.usizeFromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.usizeFromBeBytes(be.slice().reverse()); + const part3 = rs.usizeFromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.usizeFromBeBytes(be.slice().reverse()); + const part4 = rs.usizeFromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 4294967295, 0, a, rt.usizeShl(a, rt.u32Rem(shift, 32))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 4294967295, 0, a, rs.usizeShl(a, rs.u32Rem(shift, 32))]); while (true) { - const _229: rt.usize | rt.Done = iter.next(); - if (_229 === rt.DONE) { + const _229: rs.usize | rs.Done = iter.next(); + if (_229 === rs.DONE) { break; } - const v2: rt.usize = _229; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeTrailingZeros(v2)))); - const _238: rt.usize | undefined = rt.nonZero(v2); + const v2: rs.usize = _229; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.usizeTrailingZeros(v2)))); + const _238: rs.usize | undefined = rs.nonZero(v2); if (_238 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.usize = _238; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeTrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.usizeLeadingZeros(n4)))); + const n4: rs.usize = _238; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.usizeTrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.usizeLeadingZeros(n4)))); } } } else { - let x2: rt.usize = a; - x2 = rt.usizeAdd(x2, b); - x2 = rt.usizeSub(x2, 1); - x2 = rt.usizeMul(x2, 2); + let x2: rs.usize = a; + x2 = rs.usizeAdd(x2, b); + x2 = rs.usizeSub(x2, 1); + x2 = rs.usizeMul(x2, 2); x2 = x2 >>> 1; x2 = (x2 << 1) >>> 0; x2 = (x2 | (1 << 3)) >>> 0; x2 = (x2 ^ b) >>> 0; x2 = (x2 & (~(1 << 2) >>> 0)) >>> 0; - x2 = rt.usizeRem(x2, 7); - x2 = rt.usizeDiv(x2, 3); + x2 = rs.usizeRem(x2, 7); + x2 = rs.usizeDiv(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v3: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); - rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v3)) === v3 ? 1 : 0); +export function i8Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.i8 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.i8 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i8 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.i8 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v5 as rt.i128))); + const v5: rs.i8 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); } }; const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.i8 = rt.i8FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i8 = _19; + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.i8 = rs.i8FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i8 = _19; const buf2: Uint8Array = Uint8Array.of(0); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.i8 = rt.i8FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.i8 = _38; + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.i8 = rs.i8FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.i8 = _38; const buf3: Uint8Array = Uint8Array.of(0); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.i8 = ([rt.i8FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.i8, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 8); - const _70: rt.u8 = rt.u8Rem(op, 32); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.i8 = ([rs.i8FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i8, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 8); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.i8Add(a, b)); + _68(out, rs.i8Add(a, b)); } else if (_70 === 1) { - _68(out, rt.i8Sub(a, b)); + _68(out, rs.i8Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.i8Mul(a, b)); + _68(out, rs.i8Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.i8Div(a, b)); + _68(out, rs.i8Div(a, b)); } else if (_70 === 4) { - _68(out, rt.i8Rem(a, b)); + _68(out, rs.i8Rem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -1037,162 +1037,162 @@ export function i8Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.i8Shl(a, shift)); + _68(out, rs.i8Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.i8Shr(a, shift)); + _68(out, rs.i8Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a); } else if (_70 === 11) { - const part16 = rt.i8CheckedAdd(a, b); + const part16 = rs.i8CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.i8CheckedSub(a, b); + const part15 = rs.i8CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.i8CheckedMul(a, b); + const part14 = rs.i8CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.i8SaturatingAdd(a, b); + const part13 = rs.i8SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.i8SaturatingSub(a, b); + const part12 = rs.i8SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.i8WrappingAdd(a, b); + const part11 = rs.i8WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.i8WrappingSub(a, b); + const part10 = rs.i8WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i8LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i8LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.i8WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.i8WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.i8 = rt.i8Add(a, b); - rt.i8Mul(x, b); - rt.i8Mul(rt.i8Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.i8 = rs.i8Add(a, b); + rs.i8Mul(x, b); + rs.i8Mul(rs.i8Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.i8SaturatingMul(a, b); + const part7 = rs.i8SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.i8WrappingMul(a, b); + const part6 = rs.i8WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.i8 | undefined; + const _182 = undefined as rs.i8 | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.i8ToBeBytes(a).reverse(), rt.i8ToBeBytes(a).reverse(), rt.i8ToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.i8ToBeBytes(a).reverse(), rs.i8ToBeBytes(a).reverse(), rs.i8ToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.i8FromBeBytes(le.slice().reverse()); + const part = rs.i8FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.i8FromBeBytes(ne.slice().reverse()); + const part2 = rs.i8FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.i8FromBeBytes(be.slice().reverse()); + const part3 = rs.i8FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.i8FromBeBytes(be.slice().reverse()); + const part4 = rs.i8FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 127, -128, a, rt.i8Shl(a, rt.u32Rem(shift, 8))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 127, -128, a, rs.i8Shl(a, rs.u32Rem(shift, 8))]); while (true) { - const _233: rt.i8 | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.i8 | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.i8 = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8TrailingZeros(v2)))); - const _242: rt.i8 | undefined = rt.nonZero(v2); + const v2: rs.i8 = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i8TrailingZeros(v2)))); + const _242: rs.i8 | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.i8 = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i8LeadingZeros(n4)))); + const n4: rs.i8 = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i8TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i8LeadingZeros(n4)))); } } } else { - let x2: rt.i8 = a; - x2 = rt.i8Add(x2, b); - x2 = rt.i8Sub(x2, 1); - x2 = rt.i8Mul(x2, 2); + let x2: rs.i8 = a; + x2 = rs.i8Add(x2, b); + x2 = rs.i8Sub(x2, 1); + x2 = rs.i8Mul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1 << 24) >> 24; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & ~(1 << 2); - x2 = rt.i8Rem(x2, 7); - x2 = rt.i8Div(x2, 3); + x2 = rs.i8Rem(x2, 7); + x2 = rs.i8Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v3: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); - rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v3)) === v3 ? 1 : 0); +export function i16Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.i16 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.i16 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i16 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.i16 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v5 as rt.i128))); + const v5: rs.i16 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); } }; - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.i16 = rt.i16FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i16 = _19; - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.i16 = rt.i16FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.i16 = _38; - const buf3: Uint8Array = rt.bytes(2); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.i16 = ([rt.i16FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.i16, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 16); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.i16 = rs.i16FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i16 = _19; + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.i16 = rs.i16FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.i16 = _38; + const buf3: Uint8Array = rs.bytes(2); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.i16 = ([rs.i16FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i16, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 16); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.i16Add(a, b)); + _68(out, rs.i16Add(a, b)); } else if (_70 === 1) { - _68(out, rt.i16Sub(a, b)); + _68(out, rs.i16Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.i16Mul(a, b)); + _68(out, rs.i16Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.i16Div(a, b)); + _68(out, rs.i16Div(a, b)); } else if (_70 === 4) { - _68(out, rt.i16Rem(a, b)); + _68(out, rs.i16Rem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -1200,162 +1200,162 @@ export function i16Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.i16Shl(a, shift)); + _68(out, rs.i16Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.i16Shr(a, shift)); + _68(out, rs.i16Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a); } else if (_70 === 11) { - const part16 = rt.i16CheckedAdd(a, b); + const part16 = rs.i16CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.i16CheckedSub(a, b); + const part15 = rs.i16CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.i16CheckedMul(a, b); + const part14 = rs.i16CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.i16SaturatingAdd(a, b); + const part13 = rs.i16SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.i16SaturatingSub(a, b); + const part12 = rs.i16SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.i16WrappingAdd(a, b); + const part11 = rs.i16WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.i16WrappingSub(a, b); + const part10 = rs.i16WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i16LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i16LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.i16WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.i16WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.i16 = rt.i16Add(a, b); - rt.i16Mul(x, b); - rt.i16Mul(rt.i16Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.i16 = rs.i16Add(a, b); + rs.i16Mul(x, b); + rs.i16Mul(rs.i16Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.i16SaturatingMul(a, b); + const part7 = rs.i16SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.i16WrappingMul(a, b); + const part6 = rs.i16WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.i16 | undefined; + const _182 = undefined as rs.i16 | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.i16ToBeBytes(a).reverse(), rt.i16ToBeBytes(a).reverse(), rt.i16ToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.i16ToBeBytes(a).reverse(), rs.i16ToBeBytes(a).reverse(), rs.i16ToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.i16FromBeBytes(le.slice().reverse()); + const part = rs.i16FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.i16FromBeBytes(ne.slice().reverse()); + const part2 = rs.i16FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.i16FromBeBytes(be.slice().reverse()); + const part3 = rs.i16FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.i16FromBeBytes(be.slice().reverse()); + const part4 = rs.i16FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 32767, -32768, a, rt.i16Shl(a, rt.u32Rem(shift, 16))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 32767, -32768, a, rs.i16Shl(a, rs.u32Rem(shift, 16))]); while (true) { - const _233: rt.i16 | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.i16 | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.i16 = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16TrailingZeros(v2)))); - const _242: rt.i16 | undefined = rt.nonZero(v2); + const v2: rs.i16 = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i16TrailingZeros(v2)))); + const _242: rs.i16 | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.i16 = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i16LeadingZeros(n4)))); + const n4: rs.i16 = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i16TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i16LeadingZeros(n4)))); } } } else { - let x2: rt.i16 = a; - x2 = rt.i16Add(x2, b); - x2 = rt.i16Sub(x2, 1); - x2 = rt.i16Mul(x2, 2); + let x2: rs.i16 = a; + x2 = rs.i16Add(x2, b); + x2 = rs.i16Sub(x2, 1); + x2 = rs.i16Mul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1 << 16) >> 16; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & ~(1 << 2); - x2 = rt.i16Rem(x2, 7); - x2 = rt.i16Div(x2, 3); + x2 = rs.i16Rem(x2, 7); + x2 = rs.i16Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v3: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); - rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v3)) === v3 ? 1 : 0); +export function i32Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.i32 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.i32 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i32 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.i32 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v5 as rt.i128))); + const v5: rs.i32 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); } }; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.i32 = rt.i32FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i32 = _19; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.i32 = rt.i32FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.i32 = _38; - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.i32 = ([rt.i32FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.i32, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 32); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.i32 = rs.i32FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i32 = _19; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.i32 = rs.i32FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.i32 = _38; + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.i32 = ([rs.i32FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i32, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.i32Add(a, b)); + _68(out, rs.i32Add(a, b)); } else if (_70 === 1) { - _68(out, rt.i32Sub(a, b)); + _68(out, rs.i32Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.i32Mul(a, b)); + _68(out, rs.i32Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.i32Div(a, b)); + _68(out, rs.i32Div(a, b)); } else if (_70 === 4) { - _68(out, rt.i32Rem(a, b)); + _68(out, rs.i32Rem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -1363,488 +1363,488 @@ export function i32Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.i32Shl(a, shift)); + _68(out, rs.i32Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.i32Shr(a, shift)); + _68(out, rs.i32Shr(a, shift)); } else if (_70 === 10) { _68(out, ~a); } else if (_70 === 11) { - const part16 = rt.i32CheckedAdd(a, b); + const part16 = rs.i32CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.i32CheckedSub(a, b); + const part15 = rs.i32CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.i32CheckedMul(a, b); + const part14 = rs.i32CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.i32SaturatingAdd(a, b); + const part13 = rs.i32SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.i32SaturatingSub(a, b); + const part12 = rs.i32SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.i32WrappingAdd(a, b); + const part11 = rs.i32WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.i32WrappingSub(a, b); + const part10 = rs.i32WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i32LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i32LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.i32WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.i32WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.i32 = rt.i32Add(a, b); - rt.i32Mul(x, b); - rt.i32Mul(rt.i32Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.i32 = rs.i32Add(a, b); + rs.i32Mul(x, b); + rs.i32Mul(rs.i32Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.i32SaturatingMul(a, b); + const part7 = rs.i32SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.i32WrappingMul(a, b); + const part6 = rs.i32WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.i32 | undefined; + const _182 = undefined as rs.i32 | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.i32ToBeBytes(a).reverse(), rt.i32ToBeBytes(a).reverse(), rt.i32ToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.i32ToBeBytes(a).reverse(), rs.i32ToBeBytes(a).reverse(), rs.i32ToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.i32FromBeBytes(le.slice().reverse()); + const part = rs.i32FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.i32FromBeBytes(ne.slice().reverse()); + const part2 = rs.i32FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.i32FromBeBytes(be.slice().reverse()); + const part3 = rs.i32FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.i32FromBeBytes(be.slice().reverse()); + const part4 = rs.i32FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 2147483647, -2147483648, a, rt.i32Shl(a, rt.u32Rem(shift, 32))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 2147483647, -2147483648, a, rs.i32Shl(a, rs.u32Rem(shift, 32))]); while (true) { - const _233: rt.i32 | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.i32 | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.i32 = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32TrailingZeros(v2)))); - const _242: rt.i32 | undefined = rt.nonZero(v2); + const v2: rs.i32 = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i32TrailingZeros(v2)))); + const _242: rs.i32 | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.i32 = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i32LeadingZeros(n4)))); + const n4: rs.i32 = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i32TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i32LeadingZeros(n4)))); } } } else { - let x2: rt.i32 = a; - x2 = rt.i32Add(x2, b); - x2 = rt.i32Sub(x2, 1); - x2 = rt.i32Mul(x2, 2); + let x2: rs.i32 = a; + x2 = rs.i32Add(x2, b); + x2 = rs.i32Sub(x2, 1); + x2 = rs.i32Mul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1) | 0; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & ~(1 << 2); - x2 = rt.i32Rem(x2, 7); - x2 = rt.i32Div(x2, 3); + x2 = rs.i32Rem(x2, 7); + x2 = rs.i32Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function i64Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v3: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v3)))); - rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v3)), v3) ? 1 : 0); +export function i64Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); + rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v3)), v3) ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.i64 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.i64 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i64 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.i64 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v5)))); + const v5: rs.i64 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v5)))); } }; - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.i64 = rt.i64FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i64 = _19; - const buf2: Uint8Array = rt.bytes(8); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.i64 = rt.i64FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.i64 = _38; - const buf3: Uint8Array = rt.bytes(8); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.i64 = ([rt.i64FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.i64, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 64); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.i64 = rs.i64FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i64 = _19; + const buf2: Uint8Array = rs.bytes(8); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.i64 = rs.i64FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.i64 = _38; + const buf3: Uint8Array = rs.bytes(8); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.i64 = ([rs.i64FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i64, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 64); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.i64Add(a, b)); + _68(out, rs.i64Add(a, b)); } else if (_70 === 1) { - _68(out, rt.i64Sub(a, b)); + _68(out, rs.i64Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.i64Mul(a, b)); + _68(out, rs.i64Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.i64Div(a, b)); + _68(out, rs.i64Div(a, b)); } else if (_70 === 4) { - _68(out, rt.i64Rem(a, b)); + _68(out, rs.i64Rem(a, b)); } else if (_70 === 5) { - _68(out, rt.i64And(a, b)); + _68(out, rs.i64And(a, b)); } else if (_70 === 6) { - _68(out, rt.i64Or(a, b)); + _68(out, rs.i64Or(a, b)); } else if (_70 === 7) { - _68(out, rt.i64Xor(a, b)); + _68(out, rs.i64Xor(a, b)); } else if (_70 === 8) { - _68(out, rt.i64Shl(a, shift)); + _68(out, rs.i64Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.i64Shr(a, shift)); + _68(out, rs.i64Shr(a, shift)); } else if (_70 === 10) { - _68(out, rt.i64Not(a)); + _68(out, rs.i64Not(a)); } else if (_70 === 11) { - const part16 = rt.i64CheckedAdd(a, b); + const part16 = rs.i64CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.i64CheckedSub(a, b); + const part15 = rs.i64CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.i64CheckedMul(a, b); + const part14 = rs.i64CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.i64SaturatingAdd(a, b); + const part13 = rs.i64SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.i64SaturatingSub(a, b); + const part12 = rs.i64SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.i64WrappingAdd(a, b); + const part11 = rs.i64WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.i64WrappingSub(a, b); + const part10 = rs.i64WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i64LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i64LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.i64Max(a, b)); + _68(out, rs.i64Max(a, b)); } else if (_70 === 21) { - _68(out, rt.i64Min(a, b)); + _68(out, rs.i64Min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, rt.i64Eq(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i64Lt(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i64Ge(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i64WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.i64Eq(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i64Lt(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i64Ge(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i64WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.i64 = rt.i64Add(a, b); - rt.i64Mul(x, b); - rt.i64Mul(rt.i64Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.i64 = rs.i64Add(a, b); + rs.i64Mul(x, b); + rs.i64Mul(rs.i64Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.i64SaturatingMul(a, b); + const part7 = rs.i64SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.i64WrappingMul(a, b); + const part6 = rs.i64WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.i64Clamp(a, b, c); + const part5 = rs.i64Clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.i64 | undefined; + const _182 = undefined as rs.i64 | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.i64ToBeBytes(a).reverse(), rt.i64ToBeBytes(a).reverse(), rt.i64ToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.i64ToBeBytes(a).reverse(), rs.i64ToBeBytes(a).reverse(), rs.i64ToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.i64FromBeBytes(le.slice().reverse()); + const part = rs.i64FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.i64FromBeBytes(ne.slice().reverse()); + const part2 = rs.i64FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.i64FromBeBytes(be.slice().reverse()); + const part3 = rs.i64FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.i64FromBeBytes(be.slice().reverse()); + const part4 = rs.i64FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, { hi: -0x80000000, lo: 0 } as rt.i64, a, rt.i64Shl(a, rt.u32Rem(shift, 64))]); + const iter: rs.Iter = rs.iterSlice([0, 1, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64, { hi: -0x80000000, lo: 0 } as rs.i64, a, rs.i64Shl(a, rs.u32Rem(shift, 64))]); while (true) { - const _233: rt.i64 | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.i64 | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.i64 = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64TrailingZeros(v2)))); - const _242: rt.i64 | undefined = rt.nonZero(v2); + const v2: rs.i64 = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i64TrailingZeros(v2)))); + const _242: rs.i64 | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.i64 = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i64LeadingZeros(n4)))); + const n4: rs.i64 = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i64TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i64LeadingZeros(n4)))); } } } else { - let x2: rt.i64 = a; - x2 = rt.i64Add(x2, b); - x2 = rt.i64Sub(x2, 1); - x2 = rt.i64Mul(x2, 2); - x2 = rt.i64Shr(x2, 1); - x2 = rt.i64Shl(x2, 1); - x2 = rt.i64Or(x2, 8); - x2 = rt.i64Xor(x2, b); - x2 = rt.i64And(x2, rt.i64Not(4)); - x2 = rt.i64Rem(x2, 7); - x2 = rt.i64Div(x2, 3); + let x2: rs.i64 = a; + x2 = rs.i64Add(x2, b); + x2 = rs.i64Sub(x2, 1); + x2 = rs.i64Mul(x2, 2); + x2 = rs.i64Shr(x2, 1); + x2 = rs.i64Shl(x2, 1); + x2 = rs.i64Or(x2, 8); + x2 = rs.i64Xor(x2, b); + x2 = rs.i64And(x2, rs.i64Not(4)); + x2 = rs.i64Rem(x2, 7); + x2 = rs.i64Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function i128Op(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v3: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3))); - rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v3)), v3) ? 1 : 0); +export function i128Op(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); + rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v3)), v3) ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.i128 | undefined) => undefined = (out3: rt.ByteVec, v4: rt.i128 | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out3: rs.ByteVec, v4: rs.i128 | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.i128 = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v5))); + const v5: rs.i128 = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5))); } }; - const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.i128 = rt.i128FromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.i128 = _19; - const buf2: Uint8Array = rt.bytes(16); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.i128 = rt.i128FromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.i128 = _38; - const buf3: Uint8Array = rt.bytes(16); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.i128 = ([rt.i128FromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.i128, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 128); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.i128 = rs.i128FromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.i128 = _19; + const buf2: Uint8Array = rs.bytes(16); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.i128 = rs.i128FromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.i128 = _38; + const buf3: Uint8Array = rs.bytes(16); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.i128 = ([rs.i128FromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.i128, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 128); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.i128Add(a, b)); + _68(out, rs.i128Add(a, b)); } else if (_70 === 1) { - _68(out, rt.i128Sub(a, b)); + _68(out, rs.i128Sub(a, b)); } else if (_70 === 2) { - _68(out, rt.i128Mul(a, b)); + _68(out, rs.i128Mul(a, b)); } else if (_70 === 3) { - _68(out, rt.i128Div(a, b)); + _68(out, rs.i128Div(a, b)); } else if (_70 === 4) { - _68(out, rt.i128Rem(a, b)); + _68(out, rs.i128Rem(a, b)); } else if (_70 === 5) { - _68(out, rt.i128And(a, b)); + _68(out, rs.i128And(a, b)); } else if (_70 === 6) { - _68(out, rt.i128Or(a, b)); + _68(out, rs.i128Or(a, b)); } else if (_70 === 7) { - _68(out, rt.i128Xor(a, b)); + _68(out, rs.i128Xor(a, b)); } else if (_70 === 8) { - _68(out, rt.i128Shl(a, shift)); + _68(out, rs.i128Shl(a, shift)); } else if (_70 === 9) { - _68(out, rt.i128Shr(a, shift)); + _68(out, rs.i128Shr(a, shift)); } else if (_70 === 10) { - _68(out, rt.i128Not(a)); + _68(out, rs.i128Not(a)); } else if (_70 === 11) { - const part16 = rt.i128CheckedAdd(a, b); + const part16 = rs.i128CheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.i128CheckedSub(a, b); + const part15 = rs.i128CheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.i128CheckedMul(a, b); + const part14 = rs.i128CheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.i128SaturatingAdd(a, b); + const part13 = rs.i128SaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.i128SaturatingSub(a, b); + const part12 = rs.i128SaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.i128WrappingAdd(a, b); + const part11 = rs.i128WrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.i128WrappingSub(a, b); + const part10 = rs.i128WrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128LeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i128LeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128LeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i128LeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.i128Max(a, b)); + _68(out, rs.i128Max(a, b)); } else if (_70 === 21) { - _68(out, rt.i128Min(a, b)); + _68(out, rs.i128Min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, rt.i128Eq(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i128Lt(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i128Ge(a, b) ? 1 : 0); - rt.byteVecPush(out, rt.i128WrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.i128Eq(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i128Lt(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i128Ge(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.i128WrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.i128 = rt.i128Add(a, b); - rt.i128Mul(x, b); - rt.i128Mul(rt.i128Sub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.i128 = rs.i128Add(a, b); + rs.i128Mul(x, b); + rs.i128Mul(rs.i128Sub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.i128SaturatingMul(a, b); + const part7 = rs.i128SaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.i128WrappingMul(a, b); + const part6 = rs.i128WrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.i128Clamp(a, b, c); + const part5 = rs.i128Clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.i128 | undefined; + const _182 = undefined as rs.i128 | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.i128ToBeBytes(a).reverse(), rt.i128ToBeBytes(a).reverse(), rt.i128ToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.i128ToBeBytes(a).reverse(), rs.i128ToBeBytes(a).reverse(), rs.i128ToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.i128FromBeBytes(le.slice().reverse()); + const part = rs.i128FromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.i128FromBeBytes(ne.slice().reverse()); + const part2 = rs.i128FromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.i128FromBeBytes(be.slice().reverse()); + const part3 = rs.i128FromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.i128FromBeBytes(be.slice().reverse()); + const part4 = rs.i128FromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, a, rt.i128Shl(a, rt.u32Rem(shift, 128))]); + const iter: rs.Iter = rs.iterSlice([0, 1, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, a, rs.i128Shl(a, rs.u32Rem(shift, 128))]); while (true) { - const _233: rt.i128 | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.i128 | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.i128 = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128TrailingZeros(v2)))); - const _242: rt.i128 | undefined = rt.nonZero(v2); + const v2: rs.i128 = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i128TrailingZeros(v2)))); + const _242: rs.i128 | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.i128 = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128TrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.i128LeadingZeros(n4)))); + const n4: rs.i128 = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i128TrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.i128LeadingZeros(n4)))); } } } else { - let x2: rt.i128 = a; - x2 = rt.i128Add(x2, b); - x2 = rt.i128Sub(x2, 1); - x2 = rt.i128Mul(x2, 2); - x2 = rt.i128Shr(x2, 1); - x2 = rt.i128Shl(x2, 1); - x2 = rt.i128Or(x2, rt.i128Shl(1, 3)); - x2 = rt.i128Xor(x2, b); - x2 = rt.i128And(x2, rt.i128Not(rt.i128Shl(1, 2))); - x2 = rt.i128Rem(x2, 7); - x2 = rt.i128Div(x2, 3); + let x2: rs.i128 = a; + x2 = rs.i128Add(x2, b); + x2 = rs.i128Sub(x2, 1); + x2 = rs.i128Mul(x2, 2); + x2 = rs.i128Shr(x2, 1); + x2 = rs.i128Shl(x2, 1); + x2 = rs.i128Or(x2, rs.i128Shl(1, 3)); + x2 = rs.i128Xor(x2, b); + x2 = rs.i128And(x2, rs.i128Not(rs.i128Shl(1, 2))); + x2 = rs.i128Rem(x2, 7); + x2 = rs.i128Div(x2, 3); _68(out, x2); } } /** Apply operation `op` to operands taken from `data`. */ -export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _68: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v3: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); - rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v3)) === v3 ? 1 : 0); +export function isizeOp(op: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _68: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); + rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v3)) === v3 ? 1 : 0); }; - const _69: (a0: rt.ByteVec, a1: rt.isize | undefined) => undefined = (out3: rt.ByteVec, v4: rt.isize | undefined): undefined => { + const _69: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out3: rs.ByteVec, v4: rs.isize | undefined): undefined => { if (v4 === undefined) { - rt.byteVecPush(out3, 0); + rs.byteVecPush(out3, 0); } else { - const v5: rt.isize = v4; - rt.byteVecPush(out3, 1); - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.i128ToBeBytes(v5 as rt.i128))); + const v5: rs.isize = v4; + rs.byteVecPush(out3, 1); + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.i128ToBeBytes(v5 as rs.i128))); } }; - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _19: rt.isize = rt.isizeFromBeBytes(buf); - const _21: rt.ByteSlice = rt.byteSliceRange(data, n); - const a: rt.isize = _19; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_21.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_21, 0, n2)); - const _38: rt.isize = rt.isizeFromBeBytes(buf2); - const _40: rt.ByteSlice = rt.byteSliceRange(_21, n2); - const b: rt.isize = _38; - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(_40.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(_40, 0, n3)); - const c: rt.isize = ([rt.isizeFromBeBytes(buf3), rt.byteSliceRange(_40, n3)] as [rt.isize, rt.ByteSlice])[0]; - const shift: rt.u32 = rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_40), 0) as rt.u32, 2 * 32); - const _70: rt.u8 = rt.u8Rem(op, 32); + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _19: rs.isize = rs.isizeFromBeBytes(buf); + const _21: rs.ByteSlice = rs.byteSliceRange(data, n); + const a: rs.isize = _19; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_21.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_21, 0, n2)); + const _38: rs.isize = rs.isizeFromBeBytes(buf2); + const _40: rs.ByteSlice = rs.byteSliceRange(_21, n2); + const b: rs.isize = _38; + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(_40.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(_40, 0, n3)); + const c: rs.isize = ([rs.isizeFromBeBytes(buf3), rs.byteSliceRange(_40, n3)] as [rs.isize, rs.ByteSlice])[0]; + const shift: rs.u32 = rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(_40), 0) as rs.u32, 2 * 32); + const _70: rs.u8 = rs.u8Rem(op, 32); if (_70 === 0) { - _68(out, rt.isizeAdd(a, b)); + _68(out, rs.isizeAdd(a, b)); } else if (_70 === 1) { - _68(out, rt.isizeSub(a, b)); + _68(out, rs.isizeSub(a, b)); } else if (_70 === 2) { - _68(out, rt.isizeMul(a, b)); + _68(out, rs.isizeMul(a, b)); } else if (_70 === 3) { - _68(out, rt.isizeDiv(a, b)); + _68(out, rs.isizeDiv(a, b)); } else if (_70 === 4) { - _68(out, rt.isizeRem(a, b)); + _68(out, rs.isizeRem(a, b)); } else if (_70 === 5) { _68(out, a & b); } else if (_70 === 6) { @@ -1852,942 +1852,942 @@ export function isizeOp(op: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_70 === 7) { _68(out, a ^ b); } else if (_70 === 8) { - _68(out, rt.isizeShl(a, shift)); + _68(out, rs.isizeShl(a, shift)); } else if (_70 === 9) { - _68(out, rt.isizeShr(a, shift)); + _68(out, rs.isizeShr(a, shift)); } else if (_70 === 10) { _68(out, ~a); } else if (_70 === 11) { - const part16 = rt.isizeCheckedAdd(a, b); + const part16 = rs.isizeCheckedAdd(a, b); _69(out, part16); } else if (_70 === 12) { - const part15 = rt.isizeCheckedSub(a, b); + const part15 = rs.isizeCheckedSub(a, b); _69(out, part15); } else if (_70 === 13) { - const part14 = rt.isizeCheckedMul(a, b); + const part14 = rs.isizeCheckedMul(a, b); _69(out, part14); } else if (_70 === 14) { - const part13 = rt.isizeSaturatingAdd(a, b); + const part13 = rs.isizeSaturatingAdd(a, b); _68(out, part13); } else if (_70 === 15) { - const part12 = rt.isizeSaturatingSub(a, b); + const part12 = rs.isizeSaturatingSub(a, b); _68(out, part12); } else if (_70 === 16) { - const part11 = rt.isizeWrappingAdd(a, b); + const part11 = rs.isizeWrappingAdd(a, b); _68(out, part11); } else if (_70 === 17) { - const part10 = rt.isizeWrappingSub(a, b); + const part10 = rs.isizeWrappingSub(a, b); _68(out, part10); } else if (_70 === 18) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeLeadingOnes(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.isizeLeadingOnes(a)))); } else if (_70 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeLeadingZeros(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.isizeLeadingZeros(a)))); } else if (_70 === 20) { - _68(out, rt.max(a, b)); + _68(out, rs.max(a, b)); } else if (_70 === 21) { - _68(out, rt.min(a, b)); + _68(out, rs.min(a, b)); } else if (_70 === 22) { - rt.byteVecPush(out, a === b ? 1 : 0); - rt.byteVecPush(out, a < b ? 1 : 0); - rt.byteVecPush(out, a >= b ? 1 : 0); - rt.byteVecPush(out, rt.isizeWrappingSub(a, b) === 0 ? 1 : 0); + rs.byteVecPush(out, a === b ? 1 : 0); + rs.byteVecPush(out, a < b ? 1 : 0); + rs.byteVecPush(out, a >= b ? 1 : 0); + rs.byteVecPush(out, rs.isizeWrappingSub(a, b) === 0 ? 1 : 0); } else if (_70 === 23) { - const x: rt.isize = rt.isizeAdd(a, b); - rt.isizeMul(x, b); - rt.isizeMul(rt.isizeSub(x, b), a); - rt.byteVecPush(out, 1); + const x: rs.isize = rs.isizeAdd(a, b); + rs.isizeMul(x, b); + rs.isizeMul(rs.isizeSub(x, b), a); + rs.byteVecPush(out, 1); } else if (_70 === 24) { - const part7 = rt.isizeSaturatingMul(a, b); + const part7 = rs.isizeSaturatingMul(a, b); _68(out, part7); } else if (_70 === 25) { - const part6 = rt.isizeWrappingMul(a, b); + const part6 = rs.isizeWrappingMul(a, b); _68(out, part6); } else if (_70 === 26) { - const part5 = rt.clamp(a, b, c); + const part5 = rs.clamp(a, b, c); _68(out, part5); } else if (_70 === 27) { - const _182 = undefined as rt.isize | undefined; + const _182 = undefined as rs.isize | undefined; if (_182 !== undefined) { _68(out, _182); } } else if (_70 === 28) { const _188 = undefined as boolean | undefined; if (_188 !== undefined) { - rt.byteVecPush(out, _188 ? 1 : 0); + rs.byteVecPush(out, _188 ? 1 : 0); } } else if (_70 === 29) { - const _196: [Uint8Array, Uint8Array, Uint8Array] = [rt.isizeToBeBytes(a).reverse(), rt.isizeToBeBytes(a).reverse(), rt.isizeToBeBytes(a)]; + const _196: [Uint8Array, Uint8Array, Uint8Array] = [rs.isizeToBeBytes(a).reverse(), rs.isizeToBeBytes(a).reverse(), rs.isizeToBeBytes(a)]; const le: Uint8Array = _196[0]; const ne: Uint8Array = _196[1]; const be: Uint8Array = _196[2]; - const part = rt.isizeFromBeBytes(le.slice().reverse()); + const part = rs.isizeFromBeBytes(le.slice().reverse()); _68(out, part); - const part2 = rt.isizeFromBeBytes(ne.slice().reverse()); + const part2 = rs.isizeFromBeBytes(ne.slice().reverse()); _68(out, part2); - const part3 = rt.isizeFromBeBytes(be.slice().reverse()); + const part3 = rs.isizeFromBeBytes(be.slice().reverse()); _68(out, part3); - const part4 = rt.isizeFromBeBytes(be.slice().reverse()); + const part4 = rs.isizeFromBeBytes(be.slice().reverse()); _68(out, part4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(le)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(ne)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(be)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(le)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(ne)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(be)); } else if (_70 === 30) { - const iter: rt.Iter = rt.iterSlice([0, 1, 2147483647, -2147483648, a, rt.isizeShl(a, rt.u32Rem(shift, 32))]); + const iter: rs.Iter = rs.iterSlice([0, 1, 2147483647, -2147483648, a, rs.isizeShl(a, rs.u32Rem(shift, 32))]); while (true) { - const _233: rt.isize | rt.Done = iter.next(); - if (_233 === rt.DONE) { + const _233: rs.isize | rs.Done = iter.next(); + if (_233 === rs.DONE) { break; } - const v2: rt.isize = _233; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeTrailingZeros(v2)))); - const _242: rt.isize | undefined = rt.nonZero(v2); + const v2: rs.isize = _233; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.isizeTrailingZeros(v2)))); + const _242: rs.isize | undefined = rs.nonZero(v2); if (_242 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const n4: rt.isize = _242; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeTrailingZeros(n4)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.isizeLeadingZeros(n4)))); + const n4: rs.isize = _242; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.isizeTrailingZeros(n4)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.isizeLeadingZeros(n4)))); } } } else { - let x2: rt.isize = a; - x2 = rt.isizeAdd(x2, b); - x2 = rt.isizeSub(x2, 1); - x2 = rt.isizeMul(x2, 2); + let x2: rs.isize = a; + x2 = rs.isizeAdd(x2, b); + x2 = rs.isizeSub(x2, 1); + x2 = rs.isizeMul(x2, 2); x2 = x2 >> 1; x2 = (x2 << 1) | 0; x2 = x2 | (1 << 3); x2 = x2 ^ b; x2 = x2 & ~(1 << 2); - x2 = rt.isizeRem(x2, 7); - x2 = rt.isizeDiv(x2, 3); + x2 = rs.isizeRem(x2, 7); + x2 = rs.isizeDiv(x2, 3); _68(out, x2); } } /** Negate, which overflows at the minimum. */ -export function i8Neg(data: rt.ByteSlice, out: rt.ByteVec): void { +export function i8Neg(data: rs.ByteSlice, out: rs.ByteVec): void { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i8Neg(([rt.i8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i8, rt.ByteSlice])[0]) as rt.i128))); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i8Neg(([rs.i8FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.i8, rs.ByteSlice])[0]) as rs.i128))); } /** Negate, which overflows at the minimum. */ -export function i16Neg(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(2); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i16Neg(([rt.i16FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i16, rt.ByteSlice])[0]) as rt.i128))); +export function i16Neg(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(2); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i16Neg(([rs.i16FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.i16, rs.ByteSlice])[0]) as rs.i128))); } /** Negate, which overflows at the minimum. */ -export function i32Neg(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i32Neg(([rt.i32FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i32, rt.ByteSlice])[0]) as rt.i128))); +export function i32Neg(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i32Neg(([rs.i32FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.i32, rs.ByteSlice])[0]) as rs.i128))); } /** Negate, which overflows at the minimum. */ -export function i64Neg(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(rt.i64Neg(([rt.i64FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i64, rt.ByteSlice])[0]))))); +export function i64Neg(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(rs.i64Neg(([rs.i64FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.i64, rs.ByteSlice])[0]))))); } /** Negate, which overflows at the minimum. */ -export function i128Neg(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Neg(([rt.i128FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.i128, rt.ByteSlice])[0])))); +export function i128Neg(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Neg(([rs.i128FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.i128, rs.ByteSlice])[0])))); } /** Negate, which overflows at the minimum. */ -export function isizeNeg(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.isizeNeg(([rt.isizeFromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.isize, rt.ByteSlice])[0]) as rt.i128))); +export function isizeNeg(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.isizeNeg(([rs.isizeFromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.isize, rs.ByteSlice])[0]) as rs.i128))); } /** Cast a value of type `from` to type `to`, both indexes into the twelve types. */ -export function cast(from: rt.u8, to: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(from, 12); +export function cast(from: rs.u8, to: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(from, 12); if (_5 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const v: rt.u8 = ([rt.u8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u8, rt.ByteSlice])[0]; - const _25: rt.u8 = rt.u8Rem(to, 12); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const v: rs.u8 = ([rs.u8FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.u8, rs.ByteSlice])[0]; + const _25: rs.u8 = rs.u8Rem(to, 12); if (_25 === 0) { - const v2: rt.u8 = v; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v2))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v2, f)))); + const v2: rs.u8 = v; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v2))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v2, f)))); } else if (_25 === 1) { - const v3: rt.u16 = v as rt.u16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v3))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v3, f)))); + const v3: rs.u16 = v as rs.u16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v3))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v3, f)))); } else if (_25 === 2) { - const v4: rt.u32 = v as rt.u32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v4))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v4, f)))); + const v4: rs.u32 = v as rs.u32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v4, f)))); } else if (_25 === 3) { - const v5: rt.u64 = v as rt.u64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v5))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v5, f)))); + const v5: rs.u64 = v as rs.u64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v5))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v5, f)))); } else if (_25 === 4) { - const v6: rt.u128 = v as rt.u128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v6))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v6, f)))); + const v6: rs.u128 = v as rs.u128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v6))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v6, f)))); } else if (_25 === 5) { - const v7: rt.usize = v as rt.usize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v7))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v7, f)))); + const v7: rs.usize = v as rs.usize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v7))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v7, f)))); } else if (_25 === 6) { - const v8: rt.i8 = (v << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v8))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v8, f)))); + const v8: rs.i8 = (v << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v8, f)))); } else if (_25 === 7) { - const v9: rt.i16 = v as rt.i16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v9))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v9, f)))); + const v9: rs.i16 = v as rs.i16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v9))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v9, f)))); } else if (_25 === 8) { - const v10: rt.i32 = v as rt.i32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v10))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v10, f)))); + const v10: rs.i32 = v as rs.i32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v10))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v10, f)))); } else if (_25 === 9) { - const v11: rt.i64 = v as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v11))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v11, f)))); + const v11: rs.i64 = v as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v11))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v11, f)))); } else if (_25 === 10) { - const v12: rt.i128 = v as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v12))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v12, f)))); + const v12: rs.i128 = v as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v12))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v12, f)))); } else { - const v13: rt.isize = v as rt.isize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v13))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v13, f)))); + const v13: rs.isize = v as rs.isize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v13))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v13, f)))); } } else if (_5 === 1) { - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); - const v14: rt.u16 = ([rt.u16FromBeBytes(buf2), rt.byteSliceRange(data, n2)] as [rt.u16, rt.ByteSlice])[0]; - const _165: rt.u8 = rt.u8Rem(to, 12); + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); + const v14: rs.u16 = ([rs.u16FromBeBytes(buf2), rs.byteSliceRange(data, n2)] as [rs.u16, rs.ByteSlice])[0]; + const _165: rs.u8 = rs.u8Rem(to, 12); if (_165 === 0) { - const v15: rt.u8 = v14 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v15))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v15, f)))); + const v15: rs.u8 = v14 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v15))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v15, f)))); } else if (_165 === 1) { - const v16: rt.u16 = v14; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v16))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v16, f)))); + const v16: rs.u16 = v14; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v16))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v16, f)))); } else if (_165 === 2) { - const v17: rt.u32 = v14 as rt.u32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v17))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v17, f)))); + const v17: rs.u32 = v14 as rs.u32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v17))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v17, f)))); } else if (_165 === 3) { - const v18: rt.u64 = v14 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v18))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v18, f)))); + const v18: rs.u64 = v14 as rs.u64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v18))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v18, f)))); } else if (_165 === 4) { - const v19: rt.u128 = v14 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v19))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v19, f)))); + const v19: rs.u128 = v14 as rs.u128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v19))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v19, f)))); } else if (_165 === 5) { - const v20: rt.usize = v14 as rt.usize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v20))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v20, f)))); + const v20: rs.usize = v14 as rs.usize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v20))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v20, f)))); } else if (_165 === 6) { - const v21: rt.i8 = (v14 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v21))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v21, f)))); + const v21: rs.i8 = (v14 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v21))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v21, f)))); } else if (_165 === 7) { - const v22: rt.i16 = (v14 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v22))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v22, f)))); + const v22: rs.i16 = (v14 << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v22))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v22, f)))); } else if (_165 === 8) { - const v23: rt.i32 = v14 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v23))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v23, f)))); + const v23: rs.i32 = v14 as rs.i32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v23))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v23, f)))); } else if (_165 === 9) { - const v24: rt.i64 = v14 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v24))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v24, f)))); + const v24: rs.i64 = v14 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v24))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v24, f)))); } else if (_165 === 10) { - const v25: rt.i128 = v14 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v25))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v25, f)))); + const v25: rs.i128 = v14 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v25))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v25, f)))); } else { - const v26: rt.isize = v14 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v26))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v26, f)))); + const v26: rs.isize = v14 as rs.isize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v26))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v26, f)))); } } else if (_5 === 2) { - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); - const v27: rt.u32 = ([rt.u32FromBeBytes(buf3), rt.byteSliceRange(data, n3)] as [rt.u32, rt.ByteSlice])[0]; - const _305: rt.u8 = rt.u8Rem(to, 12); + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); + const v27: rs.u32 = ([rs.u32FromBeBytes(buf3), rs.byteSliceRange(data, n3)] as [rs.u32, rs.ByteSlice])[0]; + const _305: rs.u8 = rs.u8Rem(to, 12); if (_305 === 0) { - const v28: rt.u8 = v27 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v28))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v28, f)))); + const v28: rs.u8 = v27 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v28))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v28, f)))); } else if (_305 === 1) { - const v29: rt.u16 = v27 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v29))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v29, f)))); + const v29: rs.u16 = v27 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v29))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v29, f)))); } else if (_305 === 2) { - const v30: rt.u32 = v27; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v30))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v30, f)))); + const v30: rs.u32 = v27; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v30))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v30, f)))); } else if (_305 === 3) { - const v31: rt.u64 = v27 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v31))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v31, f)))); + const v31: rs.u64 = v27 as rs.u64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v31))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v31, f)))); } else if (_305 === 4) { - const v32: rt.u128 = v27 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v32))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v32, f)))); + const v32: rs.u128 = v27 as rs.u128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v32))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v32, f)))); } else if (_305 === 5) { - const v33: rt.usize = v27 as rt.usize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v33))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v33, f)))); + const v33: rs.usize = v27 as rs.usize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v33))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v33, f)))); } else if (_305 === 6) { - const v34: rt.i8 = (v27 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v34))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v34, f)))); + const v34: rs.i8 = (v27 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v34))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v34, f)))); } else if (_305 === 7) { - const v35: rt.i16 = (v27 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v35))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v35, f)))); + const v35: rs.i16 = (v27 << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v35))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v35, f)))); } else if (_305 === 8) { - const v36: rt.i32 = v27 | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v36))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v36, f)))); + const v36: rs.i32 = v27 | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v36))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v36, f)))); } else if (_305 === 9) { - const v37: rt.i64 = v27 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v37))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v37, f)))); + const v37: rs.i64 = v27 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v37))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v37, f)))); } else if (_305 === 10) { - const v38: rt.i128 = v27 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v38))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v38, f)))); + const v38: rs.i128 = v27 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v38))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v38, f)))); } else { - const v39: rt.isize = v27 | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v39))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v39, f)))); + const v39: rs.isize = v27 | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v39))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v39, f)))); } } else if (_5 === 3) { - const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); - const v40: rt.u64 = ([rt.u64FromBeBytes(buf4), rt.byteSliceRange(data, n4)] as [rt.u64, rt.ByteSlice])[0]; - const _445: rt.u8 = rt.u8Rem(to, 12); + const buf4: Uint8Array = rs.bytes(8); + const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); + const v40: rs.u64 = ([rs.u64FromBeBytes(buf4), rs.byteSliceRange(data, n4)] as [rs.u64, rs.ByteSlice])[0]; + const _445: rs.u8 = rs.u8Rem(to, 12); if (_445 === 0) { - const v41: rt.u8 = rt.u64Low(v40) & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v41))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v41, f)))); + const v41: rs.u8 = rs.u64Low(v40) & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v41))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v41, f)))); } else if (_445 === 1) { - const v42: rt.u16 = rt.u64Low(v40) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v42))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v42, f)))); + const v42: rs.u16 = rs.u64Low(v40) & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v42))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v42, f)))); } else if (_445 === 2) { - const v43: rt.u32 = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v43))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v43, f)))); + const v43: rs.u32 = rs.u64Low(v40); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v43))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v43, f)))); } else if (_445 === 3) { - const v44: rt.u64 = v40; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v44))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v44, f)))); + const v44: rs.u64 = v40; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v44))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v44, f)))); } else if (_445 === 4) { - const v45: rt.u128 = rt.u128Cast(v40); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v45))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v45, f)))); + const v45: rs.u128 = rs.u128Cast(v40); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v45))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v45, f)))); } else if (_445 === 5) { - const v46: rt.usize = rt.u64Low(v40); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v46))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v46, f)))); + const v46: rs.usize = rs.u64Low(v40); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v46))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v46, f)))); } else if (_445 === 6) { - const v47: rt.i8 = (rt.u64Low(v40) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v47))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v47, f)))); + const v47: rs.i8 = (rs.u64Low(v40) << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v47))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v47, f)))); } else if (_445 === 7) { - const v48: rt.i16 = (rt.u64Low(v40) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v48))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v48, f)))); + const v48: rs.i16 = (rs.u64Low(v40) << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v48))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v48, f)))); } else if (_445 === 8) { - const v49: rt.i32 = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v49))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v49, f)))); + const v49: rs.i32 = rs.u64Low(v40) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v49))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v49, f)))); } else if (_445 === 9) { - const v50: rt.i64 = rt.i64Cast(v40); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v50))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v50, f)))); + const v50: rs.i64 = rs.i64Cast(v40); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v50))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v50, f)))); } else if (_445 === 10) { - const v51: rt.i128 = rt.i128Cast(v40); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v51))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v51, f)))); + const v51: rs.i128 = rs.i128Cast(v40); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v51))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v51, f)))); } else { - const v52: rt.isize = rt.u64Low(v40) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v52))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v52, f)))); + const v52: rs.isize = rs.u64Low(v40) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v52))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v52, f)))); } } else if (_5 === 4) { - const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); - const v53: rt.u128 = ([rt.u128FromBeBytes(buf5), rt.byteSliceRange(data, n5)] as [rt.u128, rt.ByteSlice])[0]; - const _585: rt.u8 = rt.u8Rem(to, 12); + const buf5: Uint8Array = rs.bytes(16); + const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); + const v53: rs.u128 = ([rs.u128FromBeBytes(buf5), rs.byteSliceRange(data, n5)] as [rs.u128, rs.ByteSlice])[0]; + const _585: rs.u8 = rs.u8Rem(to, 12); if (_585 === 0) { - const v54: rt.u8 = rt.u128Low(v53) & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v54))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v54, f)))); + const v54: rs.u8 = rs.u128Low(v53) & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v54))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v54, f)))); } else if (_585 === 1) { - const v55: rt.u16 = rt.u128Low(v53) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v55))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v55, f)))); + const v55: rs.u16 = rs.u128Low(v53) & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v55))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v55, f)))); } else if (_585 === 2) { - const v56: rt.u32 = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v56))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v56, f)))); + const v56: rs.u32 = rs.u128Low(v53); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v56))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v56, f)))); } else if (_585 === 3) { - const v57: rt.u64 = rt.u64Cast(v53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v57))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v57, f)))); + const v57: rs.u64 = rs.u64Cast(v53); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v57))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v57, f)))); } else if (_585 === 4) { - const v58: rt.u128 = v53; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v58))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v58, f)))); + const v58: rs.u128 = v53; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v58))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v58, f)))); } else if (_585 === 5) { - const v59: rt.usize = rt.u128Low(v53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v59))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v59, f)))); + const v59: rs.usize = rs.u128Low(v53); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v59))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v59, f)))); } else if (_585 === 6) { - const v60: rt.i8 = (rt.u128Low(v53) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v60))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v60, f)))); + const v60: rs.i8 = (rs.u128Low(v53) << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v60))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v60, f)))); } else if (_585 === 7) { - const v61: rt.i16 = (rt.u128Low(v53) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v61))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v61, f)))); + const v61: rs.i16 = (rs.u128Low(v53) << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v61))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v61, f)))); } else if (_585 === 8) { - const v62: rt.i32 = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v62))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v62, f)))); + const v62: rs.i32 = rs.u128Low(v53) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v62))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v62, f)))); } else if (_585 === 9) { - const v63: rt.i64 = rt.i64Cast(v53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v63))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v63, f)))); + const v63: rs.i64 = rs.i64Cast(v53); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v63))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v63, f)))); } else if (_585 === 10) { - const v64: rt.i128 = rt.i128Cast(v53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v64))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v64, f)))); + const v64: rs.i128 = rs.i128Cast(v53); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v64))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v64, f)))); } else { - const v65: rt.isize = rt.u128Low(v53) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v65))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v65, f)))); + const v65: rs.isize = rs.u128Low(v53) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v65))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v65, f)))); } } else if (_5 === 5) { - const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); - const v66: rt.usize = ([rt.usizeFromBeBytes(buf6), rt.byteSliceRange(data, n6)] as [rt.usize, rt.ByteSlice])[0]; - const _725: rt.u8 = rt.u8Rem(to, 12); + const buf6: Uint8Array = rs.bytes(4); + const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); + const v66: rs.usize = ([rs.usizeFromBeBytes(buf6), rs.byteSliceRange(data, n6)] as [rs.usize, rs.ByteSlice])[0]; + const _725: rs.u8 = rs.u8Rem(to, 12); if (_725 === 0) { - const v67: rt.u8 = v66 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v67))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v67, f)))); + const v67: rs.u8 = v66 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v67))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v67, f)))); } else if (_725 === 1) { - const v68: rt.u16 = v66 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v68))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v68, f)))); + const v68: rs.u16 = v66 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v68))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v68, f)))); } else if (_725 === 2) { - const v69: rt.u32 = v66 as rt.u32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v69))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v69, f)))); + const v69: rs.u32 = v66 as rs.u32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v69))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v69, f)))); } else if (_725 === 3) { - const v70: rt.u64 = v66 as rt.u64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v70))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v70, f)))); + const v70: rs.u64 = v66 as rs.u64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v70))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v70, f)))); } else if (_725 === 4) { - const v71: rt.u128 = v66 as rt.u128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v71))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v71, f)))); + const v71: rs.u128 = v66 as rs.u128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v71))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v71, f)))); } else if (_725 === 5) { - const v72: rt.usize = v66; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v72))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v72, f)))); + const v72: rs.usize = v66; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v72))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v72, f)))); } else if (_725 === 6) { - const v73: rt.i8 = (v66 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v73))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v73, f)))); + const v73: rs.i8 = (v66 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v73))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v73, f)))); } else if (_725 === 7) { - const v74: rt.i16 = (v66 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v74))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v74, f)))); + const v74: rs.i16 = (v66 << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v74))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v74, f)))); } else if (_725 === 8) { - const v75: rt.i32 = v66 | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v75))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v75, f)))); + const v75: rs.i32 = v66 | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v75))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v75, f)))); } else if (_725 === 9) { - const v76: rt.i64 = v66 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v76))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v76, f)))); + const v76: rs.i64 = v66 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v76))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v76, f)))); } else if (_725 === 10) { - const v77: rt.i128 = v66 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v77))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v77, f)))); + const v77: rs.i128 = v66 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v77))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v77, f)))); } else { - const v78: rt.isize = v66 | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v78))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v78, f)))); + const v78: rs.isize = v66 | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v78))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v78, f)))); } } else if (_5 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); - const v79: rt.i8 = ([rt.i8FromBeBytes(buf7), rt.byteSliceRange(data, n7)] as [rt.i8, rt.ByteSlice])[0]; - const _865: rt.u8 = rt.u8Rem(to, 12); + const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); + const v79: rs.i8 = ([rs.i8FromBeBytes(buf7), rs.byteSliceRange(data, n7)] as [rs.i8, rs.ByteSlice])[0]; + const _865: rs.u8 = rs.u8Rem(to, 12); if (_865 === 0) { - const v80: rt.u8 = v79 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v80))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v80, f)))); + const v80: rs.u8 = v79 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v80))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v80, f)))); } else if (_865 === 1) { - const v81: rt.u16 = v79 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v81))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v81, f)))); + const v81: rs.u16 = v79 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v81))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v81, f)))); } else if (_865 === 2) { - const v82: rt.u32 = v79 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v82))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v82, f)))); + const v82: rs.u32 = v79 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v82))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v82, f)))); } else if (_865 === 3) { - const v83: rt.u64 = rt.u64Cast(v79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v83))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v83, f)))); + const v83: rs.u64 = rs.u64Cast(v79); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v83))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v83, f)))); } else if (_865 === 4) { - const v84: rt.u128 = rt.u128Cast(v79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v84))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v84, f)))); + const v84: rs.u128 = rs.u128Cast(v79); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v84))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v84, f)))); } else if (_865 === 5) { - const v85: rt.usize = v79 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v85))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v85, f)))); + const v85: rs.usize = v79 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v85))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v85, f)))); } else if (_865 === 6) { - const v86: rt.i8 = v79; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v86))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v86, f)))); + const v86: rs.i8 = v79; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v86))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v86, f)))); } else if (_865 === 7) { - const v87: rt.i16 = v79 as rt.i16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v87))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v87, f)))); + const v87: rs.i16 = v79 as rs.i16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v87))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v87, f)))); } else if (_865 === 8) { - const v88: rt.i32 = v79 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v88))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v88, f)))); + const v88: rs.i32 = v79 as rs.i32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v88))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v88, f)))); } else if (_865 === 9) { - const v89: rt.i64 = v79 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v89))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v89, f)))); + const v89: rs.i64 = v79 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v89))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v89, f)))); } else if (_865 === 10) { - const v90: rt.i128 = v79 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v90))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v90, f)))); + const v90: rs.i128 = v79 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v90))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v90, f)))); } else { - const v91: rt.isize = v79 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v91))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v91, f)))); + const v91: rs.isize = v79 as rs.isize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v91))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v91, f)))); } } else if (_5 === 7) { - const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); - const v92: rt.i16 = ([rt.i16FromBeBytes(buf8), rt.byteSliceRange(data, n8)] as [rt.i16, rt.ByteSlice])[0]; - const _1005: rt.u8 = rt.u8Rem(to, 12); + const buf8: Uint8Array = rs.bytes(2); + const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); + const v92: rs.i16 = ([rs.i16FromBeBytes(buf8), rs.byteSliceRange(data, n8)] as [rs.i16, rs.ByteSlice])[0]; + const _1005: rs.u8 = rs.u8Rem(to, 12); if (_1005 === 0) { - const v93: rt.u8 = v92 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v93))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v93, f)))); + const v93: rs.u8 = v92 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v93))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v93, f)))); } else if (_1005 === 1) { - const v94: rt.u16 = v92 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v94))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v94, f)))); + const v94: rs.u16 = v92 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v94))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v94, f)))); } else if (_1005 === 2) { - const v95: rt.u32 = v92 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v95))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v95, f)))); + const v95: rs.u32 = v92 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v95))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v95, f)))); } else if (_1005 === 3) { - const v96: rt.u64 = rt.u64Cast(v92); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v96))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v96, f)))); + const v96: rs.u64 = rs.u64Cast(v92); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v96))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v96, f)))); } else if (_1005 === 4) { - const v97: rt.u128 = rt.u128Cast(v92); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v97))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v97, f)))); + const v97: rs.u128 = rs.u128Cast(v92); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v97))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v97, f)))); } else if (_1005 === 5) { - const v98: rt.usize = v92 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v98))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v98, f)))); + const v98: rs.usize = v92 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v98))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v98, f)))); } else if (_1005 === 6) { - const v99: rt.i8 = (v92 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v99))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v99, f)))); + const v99: rs.i8 = (v92 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v99))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v99, f)))); } else if (_1005 === 7) { - const v100: rt.i16 = v92; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v100))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v100, f)))); + const v100: rs.i16 = v92; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v100))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v100, f)))); } else if (_1005 === 8) { - const v101: rt.i32 = v92 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v101))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v101, f)))); + const v101: rs.i32 = v92 as rs.i32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v101))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v101, f)))); } else if (_1005 === 9) { - const v102: rt.i64 = v92 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v102))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v102, f)))); + const v102: rs.i64 = v92 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v102))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v102, f)))); } else if (_1005 === 10) { - const v103: rt.i128 = v92 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v103))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v103, f)))); + const v103: rs.i128 = v92 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v103))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v103, f)))); } else { - const v104: rt.isize = v92 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v104))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v104, f)))); + const v104: rs.isize = v92 as rs.isize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v104))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v104, f)))); } } else if (_5 === 8) { - const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); - const v105: rt.i32 = ([rt.i32FromBeBytes(buf9), rt.byteSliceRange(data, n9)] as [rt.i32, rt.ByteSlice])[0]; - const _1145: rt.u8 = rt.u8Rem(to, 12); + const buf9: Uint8Array = rs.bytes(4); + const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); + const v105: rs.i32 = ([rs.i32FromBeBytes(buf9), rs.byteSliceRange(data, n9)] as [rs.i32, rs.ByteSlice])[0]; + const _1145: rs.u8 = rs.u8Rem(to, 12); if (_1145 === 0) { - const v106: rt.u8 = v105 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v106))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v106, f)))); + const v106: rs.u8 = v105 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v106))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v106, f)))); } else if (_1145 === 1) { - const v107: rt.u16 = v105 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v107))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v107, f)))); + const v107: rs.u16 = v105 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v107))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v107, f)))); } else if (_1145 === 2) { - const v108: rt.u32 = v105 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v108))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v108, f)))); + const v108: rs.u32 = v105 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v108))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v108, f)))); } else if (_1145 === 3) { - const v109: rt.u64 = rt.u64Cast(v105); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v109))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v109, f)))); + const v109: rs.u64 = rs.u64Cast(v105); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v109))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v109, f)))); } else if (_1145 === 4) { - const v110: rt.u128 = rt.u128Cast(v105); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v110))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v110, f)))); + const v110: rs.u128 = rs.u128Cast(v105); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v110))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v110, f)))); } else if (_1145 === 5) { - const v111: rt.usize = v105 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v111))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v111, f)))); + const v111: rs.usize = v105 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v111))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v111, f)))); } else if (_1145 === 6) { - const v112: rt.i8 = (v105 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v112))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v112, f)))); + const v112: rs.i8 = (v105 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v112))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v112, f)))); } else if (_1145 === 7) { - const v113: rt.i16 = (v105 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v113))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v113, f)))); + const v113: rs.i16 = (v105 << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v113))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v113, f)))); } else if (_1145 === 8) { - const v114: rt.i32 = v105; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v114))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v114, f)))); + const v114: rs.i32 = v105; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v114))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v114, f)))); } else if (_1145 === 9) { - const v115: rt.i64 = v105 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v115))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v115, f)))); + const v115: rs.i64 = v105 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v115))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v115, f)))); } else if (_1145 === 10) { - const v116: rt.i128 = v105 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v116))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v116, f)))); + const v116: rs.i128 = v105 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v116))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v116, f)))); } else { - const v117: rt.isize = v105 as rt.isize; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v117))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v117, f)))); + const v117: rs.isize = v105 as rs.isize; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v117))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v117, f)))); } } else if (_5 === 9) { - const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); - const v118: rt.i64 = ([rt.i64FromBeBytes(buf10), rt.byteSliceRange(data, n10)] as [rt.i64, rt.ByteSlice])[0]; - const _1285: rt.u8 = rt.u8Rem(to, 12); + const buf10: Uint8Array = rs.bytes(8); + const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); + const v118: rs.i64 = ([rs.i64FromBeBytes(buf10), rs.byteSliceRange(data, n10)] as [rs.i64, rs.ByteSlice])[0]; + const _1285: rs.u8 = rs.u8Rem(to, 12); if (_1285 === 0) { - const v119: rt.u8 = rt.i64Low(v118) & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v119))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v119, f)))); + const v119: rs.u8 = rs.i64Low(v118) & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v119))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v119, f)))); } else if (_1285 === 1) { - const v120: rt.u16 = rt.i64Low(v118) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v120))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v120, f)))); + const v120: rs.u16 = rs.i64Low(v118) & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v120))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v120, f)))); } else if (_1285 === 2) { - const v121: rt.u32 = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v121))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v121, f)))); + const v121: rs.u32 = rs.i64Low(v118); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v121))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v121, f)))); } else if (_1285 === 3) { - const v122: rt.u64 = rt.u64Cast(v118); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v122))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v122, f)))); + const v122: rs.u64 = rs.u64Cast(v118); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v122))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v122, f)))); } else if (_1285 === 4) { - const v123: rt.u128 = rt.u128Cast(v118); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v123))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v123, f)))); + const v123: rs.u128 = rs.u128Cast(v118); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v123))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v123, f)))); } else if (_1285 === 5) { - const v124: rt.usize = rt.i64Low(v118); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v124))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v124, f)))); + const v124: rs.usize = rs.i64Low(v118); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v124))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v124, f)))); } else if (_1285 === 6) { - const v125: rt.i8 = (rt.i64Low(v118) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v125))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v125, f)))); + const v125: rs.i8 = (rs.i64Low(v118) << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v125))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v125, f)))); } else if (_1285 === 7) { - const v126: rt.i16 = (rt.i64Low(v118) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v126))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v126, f)))); + const v126: rs.i16 = (rs.i64Low(v118) << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v126))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v126, f)))); } else if (_1285 === 8) { - const v127: rt.i32 = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v127))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v127, f)))); + const v127: rs.i32 = rs.i64Low(v118) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v127))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v127, f)))); } else if (_1285 === 9) { - const v128: rt.i64 = v118; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v128))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v128, f)))); + const v128: rs.i64 = v118; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v128))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v128, f)))); } else if (_1285 === 10) { - const v129: rt.i128 = rt.i128Cast(v118); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v129))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v129, f)))); + const v129: rs.i128 = rs.i128Cast(v118); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v129))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v129, f)))); } else { - const v130: rt.isize = rt.i64Low(v118) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v130))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v130, f)))); + const v130: rs.isize = rs.i64Low(v118) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v130))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v130, f)))); } } else if (_5 === 10) { - const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); - const v131: rt.i128 = ([rt.i128FromBeBytes(buf11), rt.byteSliceRange(data, n11)] as [rt.i128, rt.ByteSlice])[0]; - const _1425: rt.u8 = rt.u8Rem(to, 12); + const buf11: Uint8Array = rs.bytes(16); + const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); + const v131: rs.i128 = ([rs.i128FromBeBytes(buf11), rs.byteSliceRange(data, n11)] as [rs.i128, rs.ByteSlice])[0]; + const _1425: rs.u8 = rs.u8Rem(to, 12); if (_1425 === 0) { - const v132: rt.u8 = rt.i128Low(v131) & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v132))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v132, f)))); + const v132: rs.u8 = rs.i128Low(v131) & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v132))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v132, f)))); } else if (_1425 === 1) { - const v133: rt.u16 = rt.i128Low(v131) & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v133))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v133, f)))); + const v133: rs.u16 = rs.i128Low(v131) & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v133))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v133, f)))); } else if (_1425 === 2) { - const v134: rt.u32 = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v134))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v134, f)))); + const v134: rs.u32 = rs.i128Low(v131); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v134))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v134, f)))); } else if (_1425 === 3) { - const v135: rt.u64 = rt.u64Cast(v131); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v135))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v135, f)))); + const v135: rs.u64 = rs.u64Cast(v131); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v135))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v135, f)))); } else if (_1425 === 4) { - const v136: rt.u128 = rt.u128Cast(v131); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v136))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v136, f)))); + const v136: rs.u128 = rs.u128Cast(v131); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v136))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v136, f)))); } else if (_1425 === 5) { - const v137: rt.usize = rt.i128Low(v131); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v137))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v137, f)))); + const v137: rs.usize = rs.i128Low(v131); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v137))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v137, f)))); } else if (_1425 === 6) { - const v138: rt.i8 = (rt.i128Low(v131) << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v138))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v138, f)))); + const v138: rs.i8 = (rs.i128Low(v131) << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v138))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v138, f)))); } else if (_1425 === 7) { - const v139: rt.i16 = (rt.i128Low(v131) << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v139))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v139, f)))); + const v139: rs.i16 = (rs.i128Low(v131) << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v139))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v139, f)))); } else if (_1425 === 8) { - const v140: rt.i32 = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v140))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v140, f)))); + const v140: rs.i32 = rs.i128Low(v131) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v140))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v140, f)))); } else if (_1425 === 9) { - const v141: rt.i64 = rt.i64Cast(v131); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v141))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v141, f)))); + const v141: rs.i64 = rs.i64Cast(v131); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v141))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v141, f)))); } else if (_1425 === 10) { - const v142: rt.i128 = v131; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v142))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v142, f)))); + const v142: rs.i128 = v131; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v142))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v142, f)))); } else { - const v143: rt.isize = rt.i128Low(v131) | 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v143))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v143, f)))); + const v143: rs.isize = rs.i128Low(v131) | 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v143))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v143, f)))); } } else { - const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); - const v144: rt.isize = ([rt.isizeFromBeBytes(buf12), rt.byteSliceRange(data, n12)] as [rt.isize, rt.ByteSlice])[0]; - const _1565: rt.u8 = rt.u8Rem(to, 12); + const buf12: Uint8Array = rs.bytes(4); + const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); + const v144: rs.isize = ([rs.isizeFromBeBytes(buf12), rs.byteSliceRange(data, n12)] as [rs.isize, rs.ByteSlice])[0]; + const _1565: rs.u8 = rs.u8Rem(to, 12); if (_1565 === 0) { - const v145: rt.u8 = v144 & 0xff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(v145))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u8Display(v145, f)))); + const v145: rs.u8 = v144 & 0xff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(v145))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u8Display(v145, f)))); } else if (_1565 === 1) { - const v146: rt.u16 = v144 & 0xffff; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(v146))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u16Display(v146, f)))); + const v146: rs.u16 = v144 & 0xffff; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(v146))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u16Display(v146, f)))); } else if (_1565 === 2) { - const v147: rt.u32 = v144 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(v147))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u32Display(v147, f)))); + const v147: rs.u32 = v144 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(v147))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u32Display(v147, f)))); } else if (_1565 === 3) { - const v148: rt.u64 = rt.u64Cast(v144); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v148))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u64Display(v148, f)))); + const v148: rs.u64 = rs.u64Cast(v144); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v148))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u64Display(v148, f)))); } else if (_1565 === 4) { - const v149: rt.u128 = rt.u128Cast(v144); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(v149))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.u128Display(v149, f)))); + const v149: rs.u128 = rs.u128Cast(v144); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(v149))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.u128Display(v149, f)))); } else if (_1565 === 5) { - const v150: rt.usize = v144 >>> 0; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(v150))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v150, f)))); + const v150: rs.usize = v144 >>> 0; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(v150))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v150, f)))); } else if (_1565 === 6) { - const v151: rt.i8 = (v144 << 24) >> 24; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(v151))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i8Display(v151, f)))); + const v151: rs.i8 = (v144 << 24) >> 24; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(v151))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i8Display(v151, f)))); } else if (_1565 === 7) { - const v152: rt.i16 = (v144 << 16) >> 16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(v152))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i16Display(v152, f)))); + const v152: rs.i16 = (v144 << 16) >> 16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(v152))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i16Display(v152, f)))); } else if (_1565 === 8) { - const v153: rt.i32 = v144 as rt.i32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(v153))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i32Display(v153, f)))); + const v153: rs.i32 = v144 as rs.i32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(v153))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i32Display(v153, f)))); } else if (_1565 === 9) { - const v154: rt.i64 = v144 as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(v154))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i64Display(v154, f)))); + const v154: rs.i64 = v144 as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(v154))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i64Display(v154, f)))); } else if (_1565 === 10) { - const v155: rt.i128 = v144 as rt.i128; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(v155))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.i128Display(v155, f)))); + const v155: rs.i128 = v144 as rs.i128; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(v155))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.i128Display(v155, f)))); } else { - const v156: rt.isize = v144; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(v156))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v156, f)))); + const v156: rs.isize = v144; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(v156))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v156, f)))); } } } /** Conversions that check, and ones that cannot fail. */ -export function convert(data: rt.ByteSlice, out: rt.ByteVec): void { - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const _18: rt.u64 = rt.u64FromBeBytes(buf); - const _20: rt.ByteSlice = rt.byteSliceRange(data, n); - const wide: rt.u64 = _18; - const buf2: Uint8Array = rt.bytes(4); - const n2: rt.usize = rt.min(_20.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(_20, 0, n2)); - const signed: rt.i32 = ([rt.i32FromBeBytes(buf2), rt.byteSliceRange(_20, n2)] as [rt.i32, rt.ByteSlice])[0]; - rt.byteVecPush(out, rt.u8TryFrom(wide).ok ? 1 : 0); - const _46: rt.Result = rt.u32TryFrom(wide); +export function convert(data: rs.ByteSlice, out: rs.ByteVec): void { + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const _18: rs.u64 = rs.u64FromBeBytes(buf); + const _20: rs.ByteSlice = rs.byteSliceRange(data, n); + const wide: rs.u64 = _18; + const buf2: Uint8Array = rs.bytes(4); + const n2: rs.usize = rs.min(_20.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(_20, 0, n2)); + const signed: rs.i32 = ([rs.i32FromBeBytes(buf2), rs.byteSliceRange(_20, n2)] as [rs.i32, rs.ByteSlice])[0]; + rs.byteVecPush(out, rs.u8TryFrom(wide).ok ? 1 : 0); + const _46: rs.Result = rs.u32TryFrom(wide); if (_46.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_46.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_46.value))); } else { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } - const _53: rt.Result = rt.usizeTryFrom(signed); + const _53: rs.Result = rs.usizeTryFrom(signed); if (_53.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(_53.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(_53.value))); } else { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } - const _60: rt.Result = rt.i8TryFrom(signed); + const _60: rs.Result = rs.i8TryFrom(signed); if (_60.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(_60.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(_60.value))); } else { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(result_unwrapOr$09i71ei(rt.u64TryFrom(rt.u128Mul(rt.u128Cast(wide), 3)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(result_unwrapOr$0nhd29g(rt.u16TryFrom(signed), 65535)))); - const widened: rt.u64 = (rt.u64Low(wide) & 0xffff) as rt.u64; - const into: rt.i64 = signed as rt.i64; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(widened))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(into))); - rt.byteVecPush(out, rt.u8Add(true ? 1 : 0, false ? 1 : 0)); - const _101: Uint8Array = rt.u32ToBeBytes(signed >>> 0); - const a: rt.u8 = _101[0]; - const b: rt.u8 = _101[1]; - const c: rt.u8 = _101[2]; - const d: rt.u8 = _101[3]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((a << 24) >> 24))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((a << 8) | b))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((((a << 8) | b) << 16) >> 16))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((a << 24) | (c << 8) | d))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d))))); - const slice = rt.byteSliceFrom(Uint8Array.of(d, c, b, a)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((slice.data[slice.start] << 24) | (slice.data[slice.start + 1] << 16) | (slice.data[slice.start + 2] << 8) | slice.data[slice.start + 3]))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(fromHalves(rt.u64Low(rt.u64Shr(wide, 32)), rt.u64Low(wide))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromHalves((rt.u64Low(rt.u64Shr(wide, 40)) & 0xff) as rt.u32, (rt.u64Low(wide) & 0xffff) as rt.u32)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(2147483647))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(134217728))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(result_unwrapOr$0z0v7fv(rs.u64TryFrom(rs.u128Mul(rs.u128Cast(wide), 3)), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(result_unwrapOr$09f0got(rs.u16TryFrom(signed), 65535)))); + const widened: rs.u64 = (rs.u64Low(wide) & 0xffff) as rs.u64; + const into: rs.i64 = signed as rs.i64; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(widened))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(into))); + rs.byteVecPush(out, rs.u8Add(true ? 1 : 0, false ? 1 : 0)); + const _101: Uint8Array = rs.u32ToBeBytes(signed >>> 0); + const a: rs.u8 = _101[0]; + const b: rs.u8 = _101[1]; + const c: rs.u8 = _101[2]; + const d: rs.u8 = _101[3]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes((a << 24) >> 24))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes((a << 8) | b))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((((a << 8) | b) << 16) >> 16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(((a << 24) | (b << 16) | (c << 8) | d) >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(((b & 63) << 16) | (c << 8) | d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((a << 24) | (c << 8) | d))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromBeBytes(Uint8Array.of(d, c, b, a, a, b, c, d))))); + const slice = rs.byteSliceFrom(Uint8Array.of(d, c, b, a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((slice.data[slice.start] << 24) | (slice.data[slice.start + 1] << 16) | (slice.data[slice.start + 2] << 8) | slice.data[slice.start + 3]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(fromHalves(rs.u64Low(rs.u64Shr(wide, 32)), rs.u64Low(wide))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromHalves((rs.u64Low(rs.u64Shr(wide, 40)) & 0xff) as rs.u32, (rs.u64Low(wide) & 0xffff) as rs.u32)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(2147483647))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(134217728))); } /** A `u64` from its high and low 32 bits, as moq-net's varints join them. */ -export function fromHalves(hi: rt.u32, lo: rt.u32): rt.u64 { - return rt.u64FromHalves(hi, lo); +export function fromHalves(hi: rs.u32, lo: rs.u32): rs.u64 { + return rs.u64FromHalves(hi, lo); } /** `n` in `radix`, without a sign. */ -export function digits(n: rt.u128, radix: rt.u32): string { - const out: rt.ByteVec = new rt.ByteVec(); +export function digits(n: rs.u128, radix: rs.u32): string { + const out: rs.ByteVec = new rs.ByteVec(); while (true) { - const _8: rt.usize = rt.u128Low(rt.u128Rem(n, radix as rt.u128)); + const _8: rs.usize = rs.u128Low(rs.u128Rem(n, radix as rs.u128)); if (!(_8 < 36)) { - rt.panic("index out of bounds: the len is " + 36 + " but the index is " + _8); + rs.panic("index out of bounds: the len is " + 36 + " but the index is " + _8); } - const _7: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); - rt.byteVecPush(out, _7.data[_7.start + _8]); - n = rt.u128Div(n, radix as rt.u128); + const _7: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); + rs.byteVecPush(out, _7.data[_7.start + _8]); + n = rs.u128Div(n, radix as rs.u128); if (n === 0) { break; } } - rt.byteSliceView(rt.byteVecSlice(out)).reverse(); - return rt.resultUnwrap(rt.stringFromUtf8(out), rt.fmtFromUtf8ErrorDebug); + rs.byteSliceView(rs.byteVecSlice(out)).reverse(); + return rs.resultUnwrap(rs.stringFromUtf8(out), rs.fmtFromUtf8ErrorDebug); } /** The digits of one more than `s`, in `radix`. */ -export function succ(s: string, radix: rt.u32): string { - const out: rt.ByteVec = rt.byteSliceToByteVec(rt.stringAsBytes(s)); - const iter: rt.Iter> = rt.iterRev(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(out)))); +export function succ(s: string, radix: rs.u32): string { + const out: rs.ByteVec = rs.byteSliceToByteVec(rs.stringAsBytes(s)); + const iter: rs.Iter> = rs.iterRev(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(out)))); while (true) { - const _11: rt.Place | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: rs.Place | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - const d: rt.Place = _11; - const next: rt.usize = rt.usizeAdd(rt.optionUnwrap(rt.iterPosition(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)))), (c: rt.u8): boolean => { + const d: rs.Place = _11; + const next: rs.usize = rs.usizeAdd(rs.optionUnwrap(rs.iterPosition(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)))), (c: rs.u8): boolean => { return c === d.v; })), 1); - if (!(next < (radix as rt.usize))) { + if (!(next < (radix as rs.usize))) { d.v = 48; } else { if (!(next < 36)) { - rt.panic("index out of bounds: the len is " + 36 + " but the index is " + next); + rs.panic("index out of bounds: the len is " + 36 + " but the index is " + next); } - const _28: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); + const _28: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); d.v = _28.data[_28.start + next]; - return rt.resultUnwrap(rt.stringFromUtf8(out), rt.fmtFromUtf8ErrorDebug); + return rs.resultUnwrap(rs.stringFromUtf8(out), rs.fmtFromUtf8ErrorDebug); } } - rt.byteVecInsert(out, 0, 49); - return rt.resultUnwrap(rt.stringFromUtf8(out), rt.fmtFromUtf8ErrorDebug); + rs.byteVecInsert(out, 0, 49); + return rs.resultUnwrap(rs.stringFromUtf8(out), rs.fmtFromUtf8ErrorDebug); } /** @@ -2795,87 +2795,87 @@ export function succ(s: string, radix: rt.u32): string { * its bounds and one past them, with signs and leading zeros, at and past the length * below which std skips its overflow checks, malformed signs, and stray characters. */ -export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32): rt.Vec { +export function edges(max: rs.u128, min: rs.u128, bits: rs.usize, radix: rs.u32): rs.Vec { const _7: [string, string] = [digits(max, radix), succ(digits(max, radix), radix)]; const top: string = _7[0]; const past: string = _7[1]; const _15: string = top; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, top)]; - const _17: string = rt.fmtFormat(["+", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; + const _17: string = rs.fmtFormat(["+", args2[0]]); const _26: string = past; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, past)]; - const _28: string = rt.fmtFormat(["+", args4[0]]); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, top)]; - const all: rt.Vec = rt.vecFrom([_15, _17, _26, _28, rt.fmtFormat(["000", args6[0]])]); - const upper: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.strBytes(top), (b: rt.u8): rt.u8 => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; + const _28: string = rs.fmtFormat(["+", args4[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; + const all: rs.Vec = rs.vecFrom([_15, _17, _26, _28, rs.fmtFormat(["000", args6[0]])]); + const upper: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.strBytes(top), (b: rs.u8): rs.u8 => { if (!(b > 57)) { return b; } - return rt.u8Sub(b, 32); + return rs.u8Sub(b, 32); }), undefined, true); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, top)]; - const _54: string = rt.fmtFormat(["-", args8[0]]); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, past)]; - const _53: string[] = [_54, rt.fmtFormat(["000", args10[0]]), rt.resultUnwrap(rt.stringFromUtf8(upper), rt.fmtFromUtf8ErrorDebug)]; - rt.iterExtend(all, rt.iterSlice(_53), undefined, 12, true); - if (rt.u128Gt(min, 0)) { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, top)]; + const _54: string = rs.fmtFormat(["-", args8[0]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, past)]; + const _53: string[] = [_54, rs.fmtFormat(["000", args10[0]]), rs.resultUnwrap(rs.stringFromUtf8(upper), rs.fmtFromUtf8ErrorDebug)]; + rs.iterExtend(all, rs.iterSlice(_53), undefined, 12, true); + if (rs.u128Gt(min, 0)) { const _77: [string, string] = [digits(min, radix), succ(digits(min, radix), radix)]; const bottom: string = _77[0]; const below: string = _77[1]; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, bottom)]; - const _86: string = rt.fmtFormat(["-", args12[0]]); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, below)]; - const _95: string = rt.fmtFormat(["-", args14[0]]); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, bottom)]; - const _104: string = rt.fmtFormat(["-000", args16[0]]); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, below)]; - const _85: string[] = [_86, _95, _104, rt.fmtFormat(["-00", args18[0]])]; - rt.iterExtend(all, rt.iterSlice(_85), undefined, 12, true); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; + const _86: string = rs.fmtFormat(["-", args12[0]]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; + const _95: string = rs.fmtFormat(["-", args14[0]]); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, bottom)]; + const _104: string = rs.fmtFormat(["-000", args16[0]]); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, below)]; + const _85: string[] = [_86, _95, _104, rs.fmtFormat(["-00", args18[0]])]; + rs.iterExtend(all, rs.iterSlice(_85), undefined, 12, true); } - const unchecked: rt.usize = rt.usizeSub(rt.usizeDiv(bits, 4), rt.u128Gt(min, 0) ? 1 : 0); - const _131: rt.usize = rt.usizeSub(radix as rt.usize, 1); + const unchecked: rs.usize = rs.usizeSub(rs.usizeDiv(bits, 4), rs.u128Gt(min, 0) ? 1 : 0); + const _131: rs.usize = rs.usizeSub(radix as rs.usize, 1); if (!(_131 < 36)) { - rt.panic("index out of bounds: the len is " + 36 + " but the index is " + _131); + rs.panic("index out of bounds: the len is " + 36 + " but the index is " + _131); } - const _130: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); - const high: rt.char = _130.data[_130.start + _131] as rt.char; - const iter: rt.Iter = rt.iterSlice([rt.usizeSub(unchecked, 1), unchecked, rt.usizeAdd(unchecked, 1)]); + const _130: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); + const high: rs.char = _130.data[_130.start + _131] as rs.char; + const iter: rs.Iter = rs.iterSlice([rs.usizeSub(unchecked, 1), unchecked, rs.usizeAdd(unchecked, 1)]); while (true) { - const _142: rt.usize | rt.Done = iter.next(); - if (_142 === rt.DONE) { + const _142: rs.usize | rs.Done = iter.next(); + if (_142 === rs.DONE) { break; } - const len: rt.usize = _142; + const len: rs.usize = _142; let run: string = ""; - const _149: rt.usize = rt.max(len, 1); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _149; + const _149: rs.usize = rs.max(len, 1); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _149; while (iterStart++ < iterEnd) { run = run + String.fromCodePoint(high); } - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, run)]; - const _158: string[] = [rt.fmtFormat(["-", args20[0]]), run]; - rt.iterExtend(all, rt.iterSlice(_158), undefined, 12, true); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, run)]; + const _158: string[] = [rs.fmtFormat(["-", args20[0]]), run]; + rs.iterExtend(all, rs.iterSlice(_158), undefined, 12, true); } - const _172: rt.usize = rt.usizeRem(radix as rt.usize, 36); + const _172: rs.usize = rs.usizeRem(radix as rs.usize, 36); if (!(_172 < 36)) { - rt.panic("index out of bounds: the len is " + 36 + " but the index is " + _172); + rs.panic("index out of bounds: the len is " + 36 + " but the index is " + _172); } - const _171: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); - const stray: rt.char = _171.data[_171.start + _172] as rt.char; - const iter3: rt.Iter = rt.iterSlice(["", "+", "-", "0", "+0", "-0", "+-1", "-+1", "++1", "--1", " 1", "1 ", "1_0", "é", "1é"]); + const _171: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122)); + const stray: rs.char = _171.data[_171.start + _172] as rs.char; + const iter3: rs.Iter = rs.iterSlice(["", "+", "-", "0", "+0", "-0", "+-1", "-+1", "++1", "--1", " 1", "1 ", "1_0", "é", "1é"]); while (true) { - const _193: string | rt.Done = iter3.next(); - if (_193 === rt.DONE) { + const _193: string | rs.Done = iter3.next(); + if (_193 === rs.DONE) { break; } all.items.push(_193); } - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(stray, f)]; - const _203: string = rt.fmtFormat(["1", args22[0]]); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(stray, f)]; - const _202: string[] = [_203, rt.fmtFormat([args24[0]])]; - rt.iterExtend(all, rt.iterSlice(_202), undefined, 12, true); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; + const _203: string = rs.fmtFormat(["1", args22[0]]); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(stray, f)]; + const _202: string[] = [_203, rs.fmtFormat([args24[0]])]; + rs.iterExtend(all, rs.iterSlice(_202), undefined, 12, true); return all; } @@ -2884,191 +2884,191 @@ export function edges(max: rt.u128, min: rt.u128, bits: rt.usize, radix: rt.u32) * into the alphabet of signs and digits, every edge of every radix, or a radix of any * value, which panics outside 2 to 36 as `from_str_radix` or `char::to_digit` does. */ -export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let kind2!: rt.i32; +export function parses(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let kind2!: rs.i32; let over!: boolean; - let max!: rt.u8; - let kind3!: rt.i32; + let max!: rs.u8; + let kind3!: rs.i32; let over2!: boolean; - let max2!: rt.u8; - let kind4!: rt.i32; + let max2!: rs.u8; + let kind4!: rs.i32; let over3!: boolean; - let max3!: rt.u8; - let text!: rt.ByteSlice; - let kind5!: rt.i32; + let max3!: rs.u8; + let text!: rs.ByteSlice; + let kind5!: rs.i32; let over4!: boolean; - let max4!: rt.u8; - let kind6!: rt.i32; + let max4!: rs.u8; + let kind6!: rs.i32; let over5!: boolean; - let max5!: rt.u8; - let kind7!: rt.i32; + let max5!: rs.u8; + let kind7!: rs.i32; let over6!: boolean; - let max6!: rt.u8; - let kind8!: rt.i32; + let max6!: rs.u8; + let kind8!: rs.i32; let over7!: boolean; - let max7!: rt.u8; - let text2!: rt.ByteSlice; - let kind9!: rt.i32; + let max7!: rs.u8; + let text2!: rs.ByteSlice; + let kind9!: rs.i32; let over8!: boolean; - let max8!: rt.u8; - let kind10!: rt.i32; + let max8!: rs.u8; + let kind10!: rs.i32; let over9!: boolean; - let max9!: rt.u8; - let kind11!: rt.i32; + let max9!: rs.u8; + let kind11!: rs.i32; let over10!: boolean; - let max10!: rt.u8; - let kind12!: rt.i32; + let max10!: rs.u8; + let kind12!: rs.i32; let over11!: boolean; - let max11!: rt.u8; - let text3!: rt.ByteSlice; - let kind13!: rt.i32; + let max11!: rs.u8; + let text3!: rs.ByteSlice; + let kind13!: rs.i32; let over12!: boolean; - let max12!: rt.u8; - let kind14!: rt.i32; + let max12!: rs.u8; + let kind14!: rs.i32; let over13!: boolean; - let max13!: rt.u8; - let kind15!: rt.i32; + let max13!: rs.u8; + let kind15!: rs.i32; let over14!: boolean; - let max14!: rt.u8; - let kind16!: rt.i32; + let max14!: rs.u8; + let kind16!: rs.i32; let over15!: boolean; - let max15!: rt.u8; - let text4!: rt.ByteSlice; - let kind17!: rt.i32; + let max15!: rs.u8; + let text4!: rs.ByteSlice; + let kind17!: rs.i32; let over16!: boolean; - let max16!: rt.u8; - let kind18!: rt.i32; + let max16!: rs.u8; + let kind18!: rs.i32; let over17!: boolean; - let max17!: rt.u8; - let kind19!: rt.i32; + let max17!: rs.u8; + let kind19!: rs.i32; let over18!: boolean; - let max18!: rt.u8; - let kind20!: rt.i32; + let max18!: rs.u8; + let kind20!: rs.i32; let over19!: boolean; - let max19!: rt.u8; - let text5!: rt.ByteSlice; - let kind21!: rt.i32; + let max19!: rs.u8; + let text5!: rs.ByteSlice; + let kind21!: rs.i32; let over20!: boolean; - let max20!: rt.u8; - let kind22!: rt.i32; + let max20!: rs.u8; + let kind22!: rs.i32; let over21!: boolean; - let max21!: rt.u8; - let kind23!: rt.i32; + let max21!: rs.u8; + let kind23!: rs.i32; let over22!: boolean; - let max22!: rt.u8; - let kind24!: rt.i32; + let max22!: rs.u8; + let kind24!: rs.i32; let over23!: boolean; - let max23!: rt.u8; - let text6!: rt.ByteSlice; - let kind25!: rt.i32; + let max23!: rs.u8; + let text6!: rs.ByteSlice; + let kind25!: rs.i32; let over24!: boolean; - let max24!: rt.u8; - let kind26!: rt.i32; + let max24!: rs.u8; + let kind26!: rs.i32; let over25!: boolean; - let max25!: rt.u8; - let kind27!: rt.i32; + let max25!: rs.u8; + let kind27!: rs.i32; let over26!: boolean; - let max26!: rt.u8; - let kind28!: rt.i32; + let max26!: rs.u8; + let kind28!: rs.i32; let over27!: boolean; - let max27!: rt.u8; - let text7!: rt.ByteSlice; - let kind29!: rt.i32; + let max27!: rs.u8; + let text7!: rs.ByteSlice; + let kind29!: rs.i32; let over28!: boolean; - let max28!: rt.u8; - let kind30!: rt.i32; + let max28!: rs.u8; + let kind30!: rs.i32; let over29!: boolean; - let max29!: rt.u8; - let kind31!: rt.i32; + let max29!: rs.u8; + let kind31!: rs.i32; let over30!: boolean; - let max30!: rt.u8; - let kind32!: rt.i32; + let max30!: rs.u8; + let kind32!: rs.i32; let over31!: boolean; - let max31!: rt.u8; - let text8!: rt.ByteSlice; - let kind33!: rt.i32; + let max31!: rs.u8; + let text8!: rs.ByteSlice; + let kind33!: rs.i32; let over32!: boolean; - let max32!: rt.u8; - let kind34!: rt.i32; + let max32!: rs.u8; + let kind34!: rs.i32; let over33!: boolean; - let max33!: rt.u8; - let kind35!: rt.i32; + let max33!: rs.u8; + let kind35!: rs.i32; let over34!: boolean; - let max34!: rt.u8; - let kind36!: rt.i32; + let max34!: rs.u8; + let kind36!: rs.i32; let over35!: boolean; - let max35!: rt.u8; - let text9!: rt.ByteSlice; - let kind37!: rt.i32; + let max35!: rs.u8; + let text9!: rs.ByteSlice; + let kind37!: rs.i32; let over36!: boolean; - let max36!: rt.u8; - let kind38!: rt.i32; + let max36!: rs.u8; + let kind38!: rs.i32; let over37!: boolean; - let max37!: rt.u8; - let kind39!: rt.i32; + let max37!: rs.u8; + let kind39!: rs.i32; let over38!: boolean; - let max38!: rt.u8; - let kind40!: rt.i32; + let max38!: rs.u8; + let kind40!: rs.i32; let over39!: boolean; - let max39!: rt.u8; - let text10!: rt.ByteSlice; - let kind41!: rt.i32; + let max39!: rs.u8; + let text10!: rs.ByteSlice; + let kind41!: rs.i32; let over40!: boolean; - let max40!: rt.u8; - let kind42!: rt.i32; + let max40!: rs.u8; + let kind42!: rs.i32; let over41!: boolean; - let max41!: rt.u8; - let kind43!: rt.i32; + let max41!: rs.u8; + let kind43!: rs.i32; let over42!: boolean; - let max42!: rt.u8; - let kind44!: rt.i32; + let max42!: rs.u8; + let kind44!: rs.i32; let over43!: boolean; - let max43!: rt.u8; - let text11!: rt.ByteSlice; - let kind45!: rt.i32; + let max43!: rs.u8; + let text11!: rs.ByteSlice; + let kind45!: rs.i32; let over44!: boolean; - let max44!: rt.u8; - let kind46!: rt.i32; + let max44!: rs.u8; + let kind46!: rs.i32; let over45!: boolean; - let max45!: rt.u8; - let kind47!: rt.i32; + let max45!: rs.u8; + let kind47!: rs.i32; let over46!: boolean; - let max46!: rt.u8; - let kind48!: rt.i32; + let max46!: rs.u8; + let kind48!: rs.i32; let over47!: boolean; - let max47!: rt.u8; - let text12!: rt.ByteSlice; - let kind49!: rt.i32; + let max47!: rs.u8; + let text12!: rs.ByteSlice; + let kind49!: rs.i32; let over48!: boolean; - let max48!: rt.u8; + let max48!: rs.u8; b0: { - const _4: rt.u8 = rt.u8Rem(kind, 12); + const _4: rs.u8 = rs.u8Rem(kind, 12); if (_4 === 0) { if (dataLen !== 0) { - const first: rt.u8 = dataData[dataStart]; - const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix: rt.u32 = rt.u32Add(2, rt.u32Rem(first as rt.u32, 35)); - const _15: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first: rs.u8 = dataData[dataStart]; + const rest: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(first as rs.u32, 35)); + const _15: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_15 === 0) { - const _19: rt.Result = rt.strFromUtf8(rest); + const _19: rs.Result = rs.strFromUtf8(rest); if (_19.ok) { - const iter: rt.Iter = rt.strChars(_19.value); + const iter: rs.Iter = rs.strChars(_19.value); while (true) { - const _25: rt.char | rt.Done = iter.next(); - if (_25 === rt.DONE) { + const _25: rs.char | rs.Done = iter.next(); + if (_25 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_25, radix), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_25, radix), 99)))); } - const radix2: rt.u32 = radix; - const _40: rt.Result = num_fromStrRadix$1s6gdoj(_19.value, radix2); + const radix2: rs.u32 = radix; + const _40: rs.Result = num_fromStrRadix$1osjin2(_19.value, radix2); if (_40.ok) { const arg48 = _40.value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg48, f)]; - put(out, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg48, f)]; + put(out, rs.fmtFormat([args2[0]])); } else { - const e: rt.ParseIntError = _40.error; - const _56: rt.IntErrorKind = e.kind; + const e: rs.ParseIntError = _40.error; + const _56: rs.IntErrorKind = e.kind; if (_56 === "Empty") { kind2 = 0; } else if (_56 === "InvalidDigit") { @@ -3080,44 +3080,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind2 = 4; } - if (!(e.kind === "PosOverflow" as rt.IntErrorKind)) { - over = e.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e.kind === "PosOverflow" as rs.IntErrorKind)) { + over = e.kind !== "NegOverflow" as rs.IntErrorKind; } else { over = true; } - const _76: rt.IntErrorKind = e.kind; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _76), (f: rt.Formatter) => rt.i32Display(kind2, f), (f: rt.Formatter) => rt.fmtBool(over, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); + const _76: rs.IntErrorKind = e.kind; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _76), (f: rs.Formatter) => rs.i32Display(kind2, f), (f: rs.Formatter) => rs.fmtBool(over, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", args4[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", args4[3], "|", args4[4]])); } if (radix2 === 10) { - const parsed: rt.Result = parse$0vh70p5(_19.value); - const from: rt.Result = num_fromStr$1s51v8m(_19.value); + const parsed: rs.Result = parse$1brosjp(_19.value); + const from: rs.Result = num_fromStr$1t58fis(_19.value); if (from.ok) { - max = rt.u8Mul(from.value === 255 ? 1 : 0, 4); + max = rs.u8Mul(from.value === 255 ? 1 : 0, 4); } else { max = 2; } - rt.byteVecPush(out, rt.u8Add(parsed.ok ? 1 : 0, max)); + rs.byteVecPush(out, rs.u8Add(parsed.ok ? 1 : 0, max)); } } } else if (_15 === 1) { let s: string = ""; - for (const b of rt.byteSliceView(rest)) { - const _116: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _117: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_116, _117); - s = s + String.fromCodePoint(_116.data[_116.start + _117] as rt.char); + for (const b of rs.byteSliceView(rest)) { + const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _117: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_116, _117); + s = s + String.fromCodePoint(_116.data[_116.start + _117] as rs.char); } const _128: string = s; - const radix3: rt.u32 = radix; - const _131: rt.Result = num_fromStrRadix$1s6gdoj(_128, radix3); + const radix3: rs.u32 = radix; + const _131: rs.Result = num_fromStrRadix$1osjin2(_128, radix3); if (_131.ok) { const arg47 = _131.value; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg47, f)]; - put(out, rt.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg47, f)]; + put(out, rs.fmtFormat([args6[0]])); } else { - const e2: rt.ParseIntError = _131.error; - const _147: rt.IntErrorKind = e2.kind; + const e2: rs.ParseIntError = _131.error; + const _147: rs.IntErrorKind = e2.kind; if (_147 === "Empty") { kind3 = 0; } else if (_147 === "InvalidDigit") { @@ -3129,44 +3129,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind3 = 4; } - if (!(e2.kind === "PosOverflow" as rt.IntErrorKind)) { - over2 = e2.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e2.kind === "PosOverflow" as rs.IntErrorKind)) { + over2 = e2.kind !== "NegOverflow" as rs.IntErrorKind; } else { over2 = true; } - const _167: rt.IntErrorKind = e2.kind; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e2, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e2, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _167), (f: rt.Formatter) => rt.i32Display(kind3, f), (f: rt.Formatter) => rt.fmtBool(over2, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); + const _167: rs.IntErrorKind = e2.kind; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _167), (f: rs.Formatter) => rs.i32Display(kind3, f), (f: rs.Formatter) => rs.fmtBool(over2, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", args8[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", args8[3], "|", args8[4]])); } if (radix3 === 10) { - const parsed2: rt.Result = parse$0vh70p5(_128); - const from2: rt.Result = num_fromStr$1s51v8m(_128); + const parsed2: rs.Result = parse$1brosjp(_128); + const from2: rs.Result = num_fromStr$1t58fis(_128); if (from2.ok) { - max2 = rt.u8Mul(from2.value === 255 ? 1 : 0, 4); + max2 = rs.u8Mul(from2.value === 255 ? 1 : 0, 4); } else { max2 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed2.ok ? 1 : 0, max2)); + rs.byteVecPush(out, rs.u8Add(parsed2.ok ? 1 : 0, max2)); } } else { if (_15 === 2) { - const iter3: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter3: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _199: rt.u32 | rt.Done = iter3.next(); - if (_199 === rt.DONE) { + const _199: rs.u32 | rs.Done = iter3.next(); + if (_199 === rs.DONE) { break b0; } - const radix4: rt.u32 = _199; + const radix4: rs.u32 = _199; for (const _207 of edges(255, 0, 8, radix4).items) { - const radix5: rt.u32 = radix4; - const _218: rt.Result = num_fromStrRadix$1s6gdoj(_207, radix5); + const radix5: rs.u32 = radix4; + const _218: rs.Result = num_fromStrRadix$1osjin2(_207, radix5); if (_218.ok) { const arg46 = _218.value; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg46, f)]; - put(out, rt.fmtFormat([args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg46, f)]; + put(out, rs.fmtFormat([args10[0]])); } else { - const e3: rt.ParseIntError = _218.error; - const _234: rt.IntErrorKind = e3.kind; + const e3: rs.ParseIntError = _218.error; + const _234: rs.IntErrorKind = e3.kind; if (_234 === "Empty") { kind4 = 0; } else if (_234 === "InvalidDigit") { @@ -3178,49 +3178,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind4 = 4; } - if (!(e3.kind === "PosOverflow" as rt.IntErrorKind)) { - over3 = e3.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e3.kind === "PosOverflow" as rs.IntErrorKind)) { + over3 = e3.kind !== "NegOverflow" as rs.IntErrorKind; } else { over3 = true; } - const _254: rt.IntErrorKind = e3.kind; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e3, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e3, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _254), (f: rt.Formatter) => rt.i32Display(kind4, f), (f: rt.Formatter) => rt.fmtBool(over3, f)]; - put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); + const _254: rs.IntErrorKind = e3.kind; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e3, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e3, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _254), (f: rs.Formatter) => rs.i32Display(kind4, f), (f: rs.Formatter) => rs.fmtBool(over3, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", args12[3], "|", args12[4]])); } if (radix5 === 10) { - const parsed3: rt.Result = parse$0vh70p5(_207); - const from3: rt.Result = num_fromStr$1s51v8m(_207); + const parsed3: rs.Result = parse$1brosjp(_207); + const from3: rs.Result = num_fromStr$1t58fis(_207); if (from3.ok) { - max3 = rt.u8Mul(from3.value === 255 ? 1 : 0, 4); + max3 = rs.u8Mul(from3.value === 255 ? 1 : 0, 4); } else { max3 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed3.ok ? 1 : 0, max3)); + rs.byteVecPush(out, rs.u8Add(parsed3.ok ? 1 : 0, max3)); } } } } - const radix6: rt.u32 = ((first as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest, 1), (b24: rt.u8): boolean => { + const radix6: rs.u32 = ((first as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest, 1), (b24: rs.u8): boolean => { return (b24 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix6), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix6), 99)))); } if (!(rest.length > 2)) { - text = rt.byteSliceFrom(Uint8Array.of()); + text = rs.byteSliceFrom(Uint8Array.of()); } else { - text = rt.byteSliceRange(rest, 2); + text = rs.byteSliceRange(rest, 2); } - const _310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text), "1"); - const radix7: rt.u32 = radix6; - const _315: rt.Result = num_fromStrRadix$1s6gdoj(_310, radix7); + const _310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text), "1"); + const radix7: rs.u32 = radix6; + const _315: rs.Result = num_fromStrRadix$1osjin2(_310, radix7); if (_315.ok) { const arg45 = _315.value; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg45, f)]; - put(out, rt.fmtFormat([args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg45, f)]; + put(out, rs.fmtFormat([args14[0]])); } else { - const e4: rt.ParseIntError = _315.error; - const _331: rt.IntErrorKind = e4.kind; + const e4: rs.ParseIntError = _315.error; + const _331: rs.IntErrorKind = e4.kind; if (_331 === "Empty") { kind5 = 0; } else if (_331 === "InvalidDigit") { @@ -3232,53 +3232,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind5 = 4; } - if (!(e4.kind === "PosOverflow" as rt.IntErrorKind)) { - over4 = e4.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e4.kind === "PosOverflow" as rs.IntErrorKind)) { + over4 = e4.kind !== "NegOverflow" as rs.IntErrorKind; } else { over4 = true; } - const _351: rt.IntErrorKind = e4.kind; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e4, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e4, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _351), (f: rt.Formatter) => rt.i32Display(kind5, f), (f: rt.Formatter) => rt.fmtBool(over4, f)]; - put(out, rt.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); + const _351: rs.IntErrorKind = e4.kind; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _351), (f: rs.Formatter) => rs.i32Display(kind5, f), (f: rs.Formatter) => rs.fmtBool(over4, f)]; + put(out, rs.fmtFormat([args16[0], "|", args16[1], "|", args16[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args16[0]), "|", args16[3], "|", args16[4]])); } if (radix7 === 10) { - const parsed4: rt.Result = parse$0vh70p5(_310); - const from4: rt.Result = num_fromStr$1s51v8m(_310); + const parsed4: rs.Result = parse$1brosjp(_310); + const from4: rs.Result = num_fromStr$1t58fis(_310); if (from4.ok) { - max4 = rt.u8Mul(from4.value === 255 ? 1 : 0, 4); + max4 = rs.u8Mul(from4.value === 255 ? 1 : 0, 4); } else { max4 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed4.ok ? 1 : 0, max4)); + rs.byteVecPush(out, rs.u8Add(parsed4.ok ? 1 : 0, max4)); } } } } else if (_4 === 1) { if (dataLen !== 0) { - const first2: rt.u8 = dataData[dataStart]; - const rest2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix8: rt.u32 = rt.u32Add(2, rt.u32Rem(first2 as rt.u32, 35)); - const _389: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first2: rs.u8 = dataData[dataStart]; + const rest2: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix8: rs.u32 = rs.u32Add(2, rs.u32Rem(first2 as rs.u32, 35)); + const _389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_389 === 0) { - const _393: rt.Result = rt.strFromUtf8(rest2); + const _393: rs.Result = rs.strFromUtf8(rest2); if (_393.ok) { - const iter5: rt.Iter = rt.strChars(_393.value); + const iter5: rs.Iter = rs.strChars(_393.value); while (true) { - const _399: rt.char | rt.Done = iter5.next(); - if (_399 === rt.DONE) { + const _399: rs.char | rs.Done = iter5.next(); + if (_399 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_399, radix8), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_399, radix8), 99)))); } - const radix9: rt.u32 = radix8; - const _414: rt.Result = num_fromStrRadix$0ra6q5p(_393.value, radix9); + const radix9: rs.u32 = radix8; + const _414: rs.Result = num_fromStrRadix$1wu02v6(_393.value, radix9); if (_414.ok) { const arg44 = _414.value; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg44, f)]; - put(out, rt.fmtFormat([args18[0]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg44, f)]; + put(out, rs.fmtFormat([args18[0]])); } else { - const e5: rt.ParseIntError = _414.error; - const _430: rt.IntErrorKind = e5.kind; + const e5: rs.ParseIntError = _414.error; + const _430: rs.IntErrorKind = e5.kind; if (_430 === "Empty") { kind6 = 0; } else if (_430 === "InvalidDigit") { @@ -3290,44 +3290,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind6 = 4; } - if (!(e5.kind === "PosOverflow" as rt.IntErrorKind)) { - over5 = e5.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e5.kind === "PosOverflow" as rs.IntErrorKind)) { + over5 = e5.kind !== "NegOverflow" as rs.IntErrorKind; } else { over5 = true; } - const _450: rt.IntErrorKind = e5.kind; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e5, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e5, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _450), (f: rt.Formatter) => rt.i32Display(kind6, f), (f: rt.Formatter) => rt.fmtBool(over5, f)]; - put(out, rt.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); + const _450: rs.IntErrorKind = e5.kind; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _450), (f: rs.Formatter) => rs.i32Display(kind6, f), (f: rs.Formatter) => rs.fmtBool(over5, f)]; + put(out, rs.fmtFormat([args20[0], "|", args20[1], "|", args20[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args20[0]), "|", args20[3], "|", args20[4]])); } if (radix9 === 10) { - const parsed5: rt.Result = parse$1kk1wco(_393.value); - const from5: rt.Result = num_fromStr$0wy2fla(_393.value); + const parsed5: rs.Result = parse$0un0sth(_393.value); + const from5: rs.Result = num_fromStr$1gvvety(_393.value); if (from5.ok) { - max5 = rt.u8Mul(from5.value === 65535 ? 1 : 0, 4); + max5 = rs.u8Mul(from5.value === 65535 ? 1 : 0, 4); } else { max5 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed5.ok ? 1 : 0, max5)); + rs.byteVecPush(out, rs.u8Add(parsed5.ok ? 1 : 0, max5)); } } } else if (_389 === 1) { let s3: string = ""; - for (const b2 of rt.byteSliceView(rest2)) { - const _490: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _491: rt.usize = rt.usizeRem(b2 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_490, _491); - s3 = s3 + String.fromCodePoint(_490.data[_490.start + _491] as rt.char); + for (const b2 of rs.byteSliceView(rest2)) { + const _490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _491: rs.usize = rs.usizeRem(b2 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_490, _491); + s3 = s3 + String.fromCodePoint(_490.data[_490.start + _491] as rs.char); } const _502: string = s3; - const radix10: rt.u32 = radix8; - const _505: rt.Result = num_fromStrRadix$0ra6q5p(_502, radix10); + const radix10: rs.u32 = radix8; + const _505: rs.Result = num_fromStrRadix$1wu02v6(_502, radix10); if (_505.ok) { const arg43 = _505.value; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg43, f)]; - put(out, rt.fmtFormat([args22[0]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg43, f)]; + put(out, rs.fmtFormat([args22[0]])); } else { - const e6: rt.ParseIntError = _505.error; - const _521: rt.IntErrorKind = e6.kind; + const e6: rs.ParseIntError = _505.error; + const _521: rs.IntErrorKind = e6.kind; if (_521 === "Empty") { kind7 = 0; } else if (_521 === "InvalidDigit") { @@ -3339,44 +3339,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind7 = 4; } - if (!(e6.kind === "PosOverflow" as rt.IntErrorKind)) { - over6 = e6.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e6.kind === "PosOverflow" as rs.IntErrorKind)) { + over6 = e6.kind !== "NegOverflow" as rs.IntErrorKind; } else { over6 = true; } - const _541: rt.IntErrorKind = e6.kind; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e6, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e6, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _541), (f: rt.Formatter) => rt.i32Display(kind7, f), (f: rt.Formatter) => rt.fmtBool(over6, f)]; - put(out, rt.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); + const _541: rs.IntErrorKind = e6.kind; + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e6, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e6, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _541), (f: rs.Formatter) => rs.i32Display(kind7, f), (f: rs.Formatter) => rs.fmtBool(over6, f)]; + put(out, rs.fmtFormat([args24[0], "|", args24[1], "|", args24[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args24[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args24[0]), "|", args24[3], "|", args24[4]])); } if (radix10 === 10) { - const parsed6: rt.Result = parse$1kk1wco(_502); - const from6: rt.Result = num_fromStr$0wy2fla(_502); + const parsed6: rs.Result = parse$0un0sth(_502); + const from6: rs.Result = num_fromStr$1gvvety(_502); if (from6.ok) { - max6 = rt.u8Mul(from6.value === 65535 ? 1 : 0, 4); + max6 = rs.u8Mul(from6.value === 65535 ? 1 : 0, 4); } else { max6 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed6.ok ? 1 : 0, max6)); + rs.byteVecPush(out, rs.u8Add(parsed6.ok ? 1 : 0, max6)); } } else { if (_389 === 2) { - const iter7: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter7: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _573: rt.u32 | rt.Done = iter7.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter7.next(); + if (_573 === rs.DONE) { break b0; } - const radix11: rt.u32 = _573; + const radix11: rs.u32 = _573; for (const _581 of edges(65535, 0, 16, radix11).items) { - const radix12: rt.u32 = radix11; - const _592: rt.Result = num_fromStrRadix$0ra6q5p(_581, radix12); + const radix12: rs.u32 = radix11; + const _592: rs.Result = num_fromStrRadix$1wu02v6(_581, radix12); if (_592.ok) { const arg42 = _592.value; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg42, f)]; - put(out, rt.fmtFormat([args26[0]])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg42, f)]; + put(out, rs.fmtFormat([args26[0]])); } else { - const e7: rt.ParseIntError = _592.error; - const _608: rt.IntErrorKind = e7.kind; + const e7: rs.ParseIntError = _592.error; + const _608: rs.IntErrorKind = e7.kind; if (_608 === "Empty") { kind8 = 0; } else if (_608 === "InvalidDigit") { @@ -3388,49 +3388,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind8 = 4; } - if (!(e7.kind === "PosOverflow" as rt.IntErrorKind)) { - over7 = e7.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e7.kind === "PosOverflow" as rs.IntErrorKind)) { + over7 = e7.kind !== "NegOverflow" as rs.IntErrorKind; } else { over7 = true; } - const _628: rt.IntErrorKind = e7.kind; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e7, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e7, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _628), (f: rt.Formatter) => rt.i32Display(kind8, f), (f: rt.Formatter) => rt.fmtBool(over7, f)]; - put(out, rt.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); + const _628: rs.IntErrorKind = e7.kind; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _628), (f: rs.Formatter) => rs.i32Display(kind8, f), (f: rs.Formatter) => rs.fmtBool(over7, f)]; + put(out, rs.fmtFormat([args28[0], "|", args28[1], "|", args28[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args28[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args28[0]), "|", args28[3], "|", args28[4]])); } if (radix12 === 10) { - const parsed7: rt.Result = parse$1kk1wco(_581); - const from7: rt.Result = num_fromStr$0wy2fla(_581); + const parsed7: rs.Result = parse$0un0sth(_581); + const from7: rs.Result = num_fromStr$1gvvety(_581); if (from7.ok) { - max7 = rt.u8Mul(from7.value === 65535 ? 1 : 0, 4); + max7 = rs.u8Mul(from7.value === 65535 ? 1 : 0, 4); } else { max7 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed7.ok ? 1 : 0, max7)); + rs.byteVecPush(out, rs.u8Add(parsed7.ok ? 1 : 0, max7)); } } } } - const radix13: rt.u32 = ((first2 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest2), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest2, 1), (b23: rt.u8): boolean => { + const radix13: rs.u32 = ((first2 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest2), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest2, 1), (b23: rs.u8): boolean => { return (b23 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix13), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix13), 99)))); } if (!(rest2.length > 2)) { - text2 = rt.byteSliceFrom(Uint8Array.of()); + text2 = rs.byteSliceFrom(Uint8Array.of()); } else { - text2 = rt.byteSliceRange(rest2, 2); + text2 = rs.byteSliceRange(rest2, 2); } - const _684: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text2), "1"); - const radix14: rt.u32 = radix13; - const _689: rt.Result = num_fromStrRadix$0ra6q5p(_684, radix14); + const _684: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text2), "1"); + const radix14: rs.u32 = radix13; + const _689: rs.Result = num_fromStrRadix$1wu02v6(_684, radix14); if (_689.ok) { const arg41 = _689.value; - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg41, f)]; - put(out, rt.fmtFormat([args30[0]])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg41, f)]; + put(out, rs.fmtFormat([args30[0]])); } else { - const e8: rt.ParseIntError = _689.error; - const _705: rt.IntErrorKind = e8.kind; + const e8: rs.ParseIntError = _689.error; + const _705: rs.IntErrorKind = e8.kind; if (_705 === "Empty") { kind9 = 0; } else if (_705 === "InvalidDigit") { @@ -3442,53 +3442,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind9 = 4; } - if (!(e8.kind === "PosOverflow" as rt.IntErrorKind)) { - over8 = e8.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e8.kind === "PosOverflow" as rs.IntErrorKind)) { + over8 = e8.kind !== "NegOverflow" as rs.IntErrorKind; } else { over8 = true; } - const _725: rt.IntErrorKind = e8.kind; - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e8, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e8, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _725), (f: rt.Formatter) => rt.i32Display(kind9, f), (f: rt.Formatter) => rt.fmtBool(over8, f)]; - put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); + const _725: rs.IntErrorKind = e8.kind; + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _725), (f: rs.Formatter) => rs.i32Display(kind9, f), (f: rs.Formatter) => rs.fmtBool(over8, f)]; + put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", args32[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", args32[3], "|", args32[4]])); } if (radix14 === 10) { - const parsed8: rt.Result = parse$1kk1wco(_684); - const from8: rt.Result = num_fromStr$0wy2fla(_684); + const parsed8: rs.Result = parse$0un0sth(_684); + const from8: rs.Result = num_fromStr$1gvvety(_684); if (from8.ok) { - max8 = rt.u8Mul(from8.value === 65535 ? 1 : 0, 4); + max8 = rs.u8Mul(from8.value === 65535 ? 1 : 0, 4); } else { max8 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed8.ok ? 1 : 0, max8)); + rs.byteVecPush(out, rs.u8Add(parsed8.ok ? 1 : 0, max8)); } } } } else if (_4 === 2) { if (dataLen !== 0) { - const first3: rt.u8 = dataData[dataStart]; - const rest3: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix15: rt.u32 = rt.u32Add(2, rt.u32Rem(first3 as rt.u32, 35)); - const _763: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first3: rs.u8 = dataData[dataStart]; + const rest3: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix15: rs.u32 = rs.u32Add(2, rs.u32Rem(first3 as rs.u32, 35)); + const _763: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_763 === 0) { - const _767: rt.Result = rt.strFromUtf8(rest3); + const _767: rs.Result = rs.strFromUtf8(rest3); if (_767.ok) { - const iter9: rt.Iter = rt.strChars(_767.value); + const iter9: rs.Iter = rs.strChars(_767.value); while (true) { - const _773: rt.char | rt.Done = iter9.next(); - if (_773 === rt.DONE) { + const _773: rs.char | rs.Done = iter9.next(); + if (_773 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_773, radix15), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_773, radix15), 99)))); } - const radix16: rt.u32 = radix15; - const _788: rt.Result = num_fromStrRadix$1xyg67b(_767.value, radix16); + const radix16: rs.u32 = radix15; + const _788: rs.Result = num_fromStrRadix$1ftrr55(_767.value, radix16); if (_788.ok) { const arg40 = _788.value; - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg40, f)]; - put(out, rt.fmtFormat([args34[0]])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg40, f)]; + put(out, rs.fmtFormat([args34[0]])); } else { - const e9: rt.ParseIntError = _788.error; - const _804: rt.IntErrorKind = e9.kind; + const e9: rs.ParseIntError = _788.error; + const _804: rs.IntErrorKind = e9.kind; if (_804 === "Empty") { kind10 = 0; } else if (_804 === "InvalidDigit") { @@ -3500,44 +3500,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind10 = 4; } - if (!(e9.kind === "PosOverflow" as rt.IntErrorKind)) { - over9 = e9.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e9.kind === "PosOverflow" as rs.IntErrorKind)) { + over9 = e9.kind !== "NegOverflow" as rs.IntErrorKind; } else { over9 = true; } - const _824: rt.IntErrorKind = e9.kind; - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e9, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e9, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _824), (f: rt.Formatter) => rt.i32Display(kind10, f), (f: rt.Formatter) => rt.fmtBool(over9, f)]; - put(out, rt.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); + const _824: rs.IntErrorKind = e9.kind; + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e9, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e9, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _824), (f: rs.Formatter) => rs.i32Display(kind10, f), (f: rs.Formatter) => rs.fmtBool(over9, f)]; + put(out, rs.fmtFormat([args36[0], "|", args36[1], "|", args36[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args36[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args36[0]), "|", args36[3], "|", args36[4]])); } if (radix16 === 10) { - const parsed9: rt.Result = parse$0wgc3xh(_767.value); - const from9: rt.Result = num_fromStr$07skih7(_767.value); + const parsed9: rs.Result = parse$069xxen(_767.value); + const from9: rs.Result = num_fromStr$1rjp7t4(_767.value); if (from9.ok) { - max9 = rt.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); + max9 = rs.u8Mul(from9.value === 4294967295 ? 1 : 0, 4); } else { max9 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed9.ok ? 1 : 0, max9)); + rs.byteVecPush(out, rs.u8Add(parsed9.ok ? 1 : 0, max9)); } } } else if (_763 === 1) { let s5: string = ""; - for (const b3 of rt.byteSliceView(rest3)) { - const _864: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _865: rt.usize = rt.usizeRem(b3 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_864, _865); - s5 = s5 + String.fromCodePoint(_864.data[_864.start + _865] as rt.char); + for (const b3 of rs.byteSliceView(rest3)) { + const _864: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _865: rs.usize = rs.usizeRem(b3 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_864, _865); + s5 = s5 + String.fromCodePoint(_864.data[_864.start + _865] as rs.char); } const _876: string = s5; - const radix17: rt.u32 = radix15; - const _879: rt.Result = num_fromStrRadix$1xyg67b(_876, radix17); + const radix17: rs.u32 = radix15; + const _879: rs.Result = num_fromStrRadix$1ftrr55(_876, radix17); if (_879.ok) { const arg39 = _879.value; - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg39, f)]; - put(out, rt.fmtFormat([args38[0]])); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg39, f)]; + put(out, rs.fmtFormat([args38[0]])); } else { - const e10: rt.ParseIntError = _879.error; - const _895: rt.IntErrorKind = e10.kind; + const e10: rs.ParseIntError = _879.error; + const _895: rs.IntErrorKind = e10.kind; if (_895 === "Empty") { kind11 = 0; } else if (_895 === "InvalidDigit") { @@ -3549,44 +3549,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind11 = 4; } - if (!(e10.kind === "PosOverflow" as rt.IntErrorKind)) { - over10 = e10.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e10.kind === "PosOverflow" as rs.IntErrorKind)) { + over10 = e10.kind !== "NegOverflow" as rs.IntErrorKind; } else { over10 = true; } - const _915: rt.IntErrorKind = e10.kind; - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e10, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e10, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _915), (f: rt.Formatter) => rt.i32Display(kind11, f), (f: rt.Formatter) => rt.fmtBool(over10, f)]; - put(out, rt.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); + const _915: rs.IntErrorKind = e10.kind; + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _915), (f: rs.Formatter) => rs.i32Display(kind11, f), (f: rs.Formatter) => rs.fmtBool(over10, f)]; + put(out, rs.fmtFormat([args40[0], "|", args40[1], "|", args40[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args40[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args40[0]), "|", args40[3], "|", args40[4]])); } if (radix17 === 10) { - const parsed10: rt.Result = parse$0wgc3xh(_876); - const from10: rt.Result = num_fromStr$07skih7(_876); + const parsed10: rs.Result = parse$069xxen(_876); + const from10: rs.Result = num_fromStr$1rjp7t4(_876); if (from10.ok) { - max10 = rt.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); + max10 = rs.u8Mul(from10.value === 4294967295 ? 1 : 0, 4); } else { max10 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed10.ok ? 1 : 0, max10)); + rs.byteVecPush(out, rs.u8Add(parsed10.ok ? 1 : 0, max10)); } } else { if (_763 === 2) { - const iter11: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter11: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _947: rt.u32 | rt.Done = iter11.next(); - if (_947 === rt.DONE) { + const _947: rs.u32 | rs.Done = iter11.next(); + if (_947 === rs.DONE) { break b0; } - const radix18: rt.u32 = _947; + const radix18: rs.u32 = _947; for (const _955 of edges(4294967295, 0, 32, radix18).items) { - const radix19: rt.u32 = radix18; - const _966: rt.Result = num_fromStrRadix$1xyg67b(_955, radix19); + const radix19: rs.u32 = radix18; + const _966: rs.Result = num_fromStrRadix$1ftrr55(_955, radix19); if (_966.ok) { const arg38 = _966.value; - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg38, f)]; - put(out, rt.fmtFormat([args42[0]])); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg38, f)]; + put(out, rs.fmtFormat([args42[0]])); } else { - const e11: rt.ParseIntError = _966.error; - const _982: rt.IntErrorKind = e11.kind; + const e11: rs.ParseIntError = _966.error; + const _982: rs.IntErrorKind = e11.kind; if (_982 === "Empty") { kind12 = 0; } else if (_982 === "InvalidDigit") { @@ -3598,49 +3598,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind12 = 4; } - if (!(e11.kind === "PosOverflow" as rt.IntErrorKind)) { - over11 = e11.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e11.kind === "PosOverflow" as rs.IntErrorKind)) { + over11 = e11.kind !== "NegOverflow" as rs.IntErrorKind; } else { over11 = true; } - const _1002: rt.IntErrorKind = e11.kind; - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e11, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e11, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1002), (f: rt.Formatter) => rt.i32Display(kind12, f), (f: rt.Formatter) => rt.fmtBool(over11, f)]; - put(out, rt.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); + const _1002: rs.IntErrorKind = e11.kind; + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1002), (f: rs.Formatter) => rs.i32Display(kind12, f), (f: rs.Formatter) => rs.fmtBool(over11, f)]; + put(out, rs.fmtFormat([args44[0], "|", args44[1], "|", args44[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args44[0]), "|", args44[3], "|", args44[4]])); } if (radix19 === 10) { - const parsed11: rt.Result = parse$0wgc3xh(_955); - const from11: rt.Result = num_fromStr$07skih7(_955); + const parsed11: rs.Result = parse$069xxen(_955); + const from11: rs.Result = num_fromStr$1rjp7t4(_955); if (from11.ok) { - max11 = rt.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); + max11 = rs.u8Mul(from11.value === 4294967295 ? 1 : 0, 4); } else { max11 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed11.ok ? 1 : 0, max11)); + rs.byteVecPush(out, rs.u8Add(parsed11.ok ? 1 : 0, max11)); } } } } - const radix20: rt.u32 = ((first3 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest3), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest3, 1), (b22: rt.u8): boolean => { + const radix20: rs.u32 = ((first3 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest3), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest3, 1), (b22: rs.u8): boolean => { return (b22 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix20), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix20), 99)))); } if (!(rest3.length > 2)) { - text3 = rt.byteSliceFrom(Uint8Array.of()); + text3 = rs.byteSliceFrom(Uint8Array.of()); } else { - text3 = rt.byteSliceRange(rest3, 2); + text3 = rs.byteSliceRange(rest3, 2); } - const _1058: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text3), "1"); - const radix21: rt.u32 = radix20; - const _1063: rt.Result = num_fromStrRadix$1xyg67b(_1058, radix21); + const _1058: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text3), "1"); + const radix21: rs.u32 = radix20; + const _1063: rs.Result = num_fromStrRadix$1ftrr55(_1058, radix21); if (_1063.ok) { const arg37 = _1063.value; - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg37, f)]; - put(out, rt.fmtFormat([args46[0]])); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg37, f)]; + put(out, rs.fmtFormat([args46[0]])); } else { - const e12: rt.ParseIntError = _1063.error; - const _1079: rt.IntErrorKind = e12.kind; + const e12: rs.ParseIntError = _1063.error; + const _1079: rs.IntErrorKind = e12.kind; if (_1079 === "Empty") { kind13 = 0; } else if (_1079 === "InvalidDigit") { @@ -3652,53 +3652,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind13 = 4; } - if (!(e12.kind === "PosOverflow" as rt.IntErrorKind)) { - over12 = e12.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e12.kind === "PosOverflow" as rs.IntErrorKind)) { + over12 = e12.kind !== "NegOverflow" as rs.IntErrorKind; } else { over12 = true; } - const _1099: rt.IntErrorKind = e12.kind; - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e12, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e12, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1099), (f: rt.Formatter) => rt.i32Display(kind13, f), (f: rt.Formatter) => rt.fmtBool(over12, f)]; - put(out, rt.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); + const _1099: rs.IntErrorKind = e12.kind; + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e12, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e12, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1099), (f: rs.Formatter) => rs.i32Display(kind13, f), (f: rs.Formatter) => rs.fmtBool(over12, f)]; + put(out, rs.fmtFormat([args48[0], "|", args48[1], "|", args48[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args48[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args48[0]), "|", args48[3], "|", args48[4]])); } if (radix21 === 10) { - const parsed12: rt.Result = parse$0wgc3xh(_1058); - const from12: rt.Result = num_fromStr$07skih7(_1058); + const parsed12: rs.Result = parse$069xxen(_1058); + const from12: rs.Result = num_fromStr$1rjp7t4(_1058); if (from12.ok) { - max12 = rt.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); + max12 = rs.u8Mul(from12.value === 4294967295 ? 1 : 0, 4); } else { max12 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed12.ok ? 1 : 0, max12)); + rs.byteVecPush(out, rs.u8Add(parsed12.ok ? 1 : 0, max12)); } } } } else if (_4 === 3) { if (dataLen !== 0) { - const first4: rt.u8 = dataData[dataStart]; - const rest4: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix22: rt.u32 = rt.u32Add(2, rt.u32Rem(first4 as rt.u32, 35)); - const _1137: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first4: rs.u8 = dataData[dataStart]; + const rest4: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix22: rs.u32 = rs.u32Add(2, rs.u32Rem(first4 as rs.u32, 35)); + const _1137: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_1137 === 0) { - const _1141: rt.Result = rt.strFromUtf8(rest4); + const _1141: rs.Result = rs.strFromUtf8(rest4); if (_1141.ok) { - const iter13: rt.Iter = rt.strChars(_1141.value); + const iter13: rs.Iter = rs.strChars(_1141.value); while (true) { - const _1147: rt.char | rt.Done = iter13.next(); - if (_1147 === rt.DONE) { + const _1147: rs.char | rs.Done = iter13.next(); + if (_1147 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1147, radix22), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1147, radix22), 99)))); } - const radix23: rt.u32 = radix22; - const _1162: rt.Result = num_fromStrRadix$1gp4jqq(_1141.value, radix23); + const radix23: rs.u32 = radix22; + const _1162: rs.Result = num_fromStrRadix$0al5jri(_1141.value, radix23); if (_1162.ok) { const arg36 = _1162.value; - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg36, f)]; - put(out, rt.fmtFormat([args50[0]])); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg36, f)]; + put(out, rs.fmtFormat([args50[0]])); } else { - const e13: rt.ParseIntError = _1162.error; - const _1178: rt.IntErrorKind = e13.kind; + const e13: rs.ParseIntError = _1162.error; + const _1178: rs.IntErrorKind = e13.kind; if (_1178 === "Empty") { kind14 = 0; } else if (_1178 === "InvalidDigit") { @@ -3710,44 +3710,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind14 = 4; } - if (!(e13.kind === "PosOverflow" as rt.IntErrorKind)) { - over13 = e13.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e13.kind === "PosOverflow" as rs.IntErrorKind)) { + over13 = e13.kind !== "NegOverflow" as rs.IntErrorKind; } else { over13 = true; } - const _1198: rt.IntErrorKind = e13.kind; - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e13, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e13, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1198), (f: rt.Formatter) => rt.i32Display(kind14, f), (f: rt.Formatter) => rt.fmtBool(over13, f)]; - put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); + const _1198: rs.IntErrorKind = e13.kind; + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1198), (f: rs.Formatter) => rs.i32Display(kind14, f), (f: rs.Formatter) => rs.fmtBool(over13, f)]; + put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", args52[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", args52[3], "|", args52[4]])); } if (radix23 === 10) { - const parsed13: rt.Result = parse$0o4ono0(_1141.value); - const from13: rt.Result = num_fromStr$1ypcnp8(_1141.value); + const parsed13: rs.Result = parse$092epd5(_1141.value); + const from13: rs.Result = num_fromStr$0bkyuqf(_1141.value); if (from13.ok) { - max13 = rt.u8Mul(rt.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); + max13 = rs.u8Mul(rs.u64Eq(from13.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { max13 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed13.ok ? 1 : 0, max13)); + rs.byteVecPush(out, rs.u8Add(parsed13.ok ? 1 : 0, max13)); } } } else if (_1137 === 1) { let s7: string = ""; - for (const b4 of rt.byteSliceView(rest4)) { - const _1238: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1239: rt.usize = rt.usizeRem(b4 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_1238, _1239); - s7 = s7 + String.fromCodePoint(_1238.data[_1238.start + _1239] as rt.char); + for (const b4 of rs.byteSliceView(rest4)) { + const _1238: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1239: rs.usize = rs.usizeRem(b4 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1238, _1239); + s7 = s7 + String.fromCodePoint(_1238.data[_1238.start + _1239] as rs.char); } const _1250: string = s7; - const radix24: rt.u32 = radix22; - const _1253: rt.Result = num_fromStrRadix$1gp4jqq(_1250, radix24); + const radix24: rs.u32 = radix22; + const _1253: rs.Result = num_fromStrRadix$0al5jri(_1250, radix24); if (_1253.ok) { const arg35 = _1253.value; - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg35, f)]; - put(out, rt.fmtFormat([args54[0]])); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg35, f)]; + put(out, rs.fmtFormat([args54[0]])); } else { - const e14: rt.ParseIntError = _1253.error; - const _1269: rt.IntErrorKind = e14.kind; + const e14: rs.ParseIntError = _1253.error; + const _1269: rs.IntErrorKind = e14.kind; if (_1269 === "Empty") { kind15 = 0; } else if (_1269 === "InvalidDigit") { @@ -3759,44 +3759,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind15 = 4; } - if (!(e14.kind === "PosOverflow" as rt.IntErrorKind)) { - over14 = e14.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e14.kind === "PosOverflow" as rs.IntErrorKind)) { + over14 = e14.kind !== "NegOverflow" as rs.IntErrorKind; } else { over14 = true; } - const _1289: rt.IntErrorKind = e14.kind; - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e14, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e14, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1289), (f: rt.Formatter) => rt.i32Display(kind15, f), (f: rt.Formatter) => rt.fmtBool(over14, f)]; - put(out, rt.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); + const _1289: rs.IntErrorKind = e14.kind; + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1289), (f: rs.Formatter) => rs.i32Display(kind15, f), (f: rs.Formatter) => rs.fmtBool(over14, f)]; + put(out, rs.fmtFormat([args56[0], "|", args56[1], "|", args56[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args56[0]), "|", args56[3], "|", args56[4]])); } if (radix24 === 10) { - const parsed14: rt.Result = parse$0o4ono0(_1250); - const from14: rt.Result = num_fromStr$1ypcnp8(_1250); + const parsed14: rs.Result = parse$092epd5(_1250); + const from14: rs.Result = num_fromStr$0bkyuqf(_1250); if (from14.ok) { - max14 = rt.u8Mul(rt.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); + max14 = rs.u8Mul(rs.u64Eq(from14.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { max14 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed14.ok ? 1 : 0, max14)); + rs.byteVecPush(out, rs.u8Add(parsed14.ok ? 1 : 0, max14)); } } else { if (_1137 === 2) { - const iter15: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter15: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _1321: rt.u32 | rt.Done = iter15.next(); - if (_1321 === rt.DONE) { + const _1321: rs.u32 | rs.Done = iter15.next(); + if (_1321 === rs.DONE) { break b0; } - const radix25: rt.u32 = _1321; - for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 64, radix25).items) { - const radix26: rt.u32 = radix25; - const _1340: rt.Result = num_fromStrRadix$1gp4jqq(_1329, radix26); + const radix25: rs.u32 = _1321; + for (const _1329 of edges({ hi: 0, w2: 0, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 64, radix25).items) { + const radix26: rs.u32 = radix25; + const _1340: rs.Result = num_fromStrRadix$0al5jri(_1329, radix26); if (_1340.ok) { const arg34 = _1340.value; - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg34, f)]; - put(out, rt.fmtFormat([args58[0]])); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg34, f)]; + put(out, rs.fmtFormat([args58[0]])); } else { - const e15: rt.ParseIntError = _1340.error; - const _1356: rt.IntErrorKind = e15.kind; + const e15: rs.ParseIntError = _1340.error; + const _1356: rs.IntErrorKind = e15.kind; if (_1356 === "Empty") { kind16 = 0; } else if (_1356 === "InvalidDigit") { @@ -3808,49 +3808,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind16 = 4; } - if (!(e15.kind === "PosOverflow" as rt.IntErrorKind)) { - over15 = e15.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e15.kind === "PosOverflow" as rs.IntErrorKind)) { + over15 = e15.kind !== "NegOverflow" as rs.IntErrorKind; } else { over15 = true; } - const _1376: rt.IntErrorKind = e15.kind; - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e15, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e15, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1376), (f: rt.Formatter) => rt.i32Display(kind16, f), (f: rt.Formatter) => rt.fmtBool(over15, f)]; - put(out, rt.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); + const _1376: rs.IntErrorKind = e15.kind; + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e15, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e15, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1376), (f: rs.Formatter) => rs.i32Display(kind16, f), (f: rs.Formatter) => rs.fmtBool(over15, f)]; + put(out, rs.fmtFormat([args60[0], "|", args60[1], "|", args60[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args60[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args60[0]), "|", args60[3], "|", args60[4]])); } if (radix26 === 10) { - const parsed15: rt.Result = parse$0o4ono0(_1329); - const from15: rt.Result = num_fromStr$1ypcnp8(_1329); + const parsed15: rs.Result = parse$092epd5(_1329); + const from15: rs.Result = num_fromStr$0bkyuqf(_1329); if (from15.ok) { - max15 = rt.u8Mul(rt.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); + max15 = rs.u8Mul(rs.u64Eq(from15.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { max15 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed15.ok ? 1 : 0, max15)); + rs.byteVecPush(out, rs.u8Add(parsed15.ok ? 1 : 0, max15)); } } } } - const radix27: rt.u32 = ((first4 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest4), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest4, 1), (b21: rt.u8): boolean => { + const radix27: rs.u32 = ((first4 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest4), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest4, 1), (b21: rs.u8): boolean => { return (b21 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix27), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix27), 99)))); } if (!(rest4.length > 2)) { - text4 = rt.byteSliceFrom(Uint8Array.of()); + text4 = rs.byteSliceFrom(Uint8Array.of()); } else { - text4 = rt.byteSliceRange(rest4, 2); + text4 = rs.byteSliceRange(rest4, 2); } - const _1432: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text4), "1"); - const radix28: rt.u32 = radix27; - const _1437: rt.Result = num_fromStrRadix$1gp4jqq(_1432, radix28); + const _1432: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text4), "1"); + const radix28: rs.u32 = radix27; + const _1437: rs.Result = num_fromStrRadix$0al5jri(_1432, radix28); if (_1437.ok) { const arg33 = _1437.value; - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg33, f)]; - put(out, rt.fmtFormat([args62[0]])); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg33, f)]; + put(out, rs.fmtFormat([args62[0]])); } else { - const e16: rt.ParseIntError = _1437.error; - const _1453: rt.IntErrorKind = e16.kind; + const e16: rs.ParseIntError = _1437.error; + const _1453: rs.IntErrorKind = e16.kind; if (_1453 === "Empty") { kind17 = 0; } else if (_1453 === "InvalidDigit") { @@ -3862,53 +3862,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind17 = 4; } - if (!(e16.kind === "PosOverflow" as rt.IntErrorKind)) { - over16 = e16.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e16.kind === "PosOverflow" as rs.IntErrorKind)) { + over16 = e16.kind !== "NegOverflow" as rs.IntErrorKind; } else { over16 = true; } - const _1473: rt.IntErrorKind = e16.kind; - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e16, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e16, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1473), (f: rt.Formatter) => rt.i32Display(kind17, f), (f: rt.Formatter) => rt.fmtBool(over16, f)]; - put(out, rt.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); + const _1473: rs.IntErrorKind = e16.kind; + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1473), (f: rs.Formatter) => rs.i32Display(kind17, f), (f: rs.Formatter) => rs.fmtBool(over16, f)]; + put(out, rs.fmtFormat([args64[0], "|", args64[1], "|", args64[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args64[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args64[0]), "|", args64[3], "|", args64[4]])); } if (radix28 === 10) { - const parsed16: rt.Result = parse$0o4ono0(_1432); - const from16: rt.Result = num_fromStr$1ypcnp8(_1432); + const parsed16: rs.Result = parse$092epd5(_1432); + const from16: rs.Result = num_fromStr$0bkyuqf(_1432); if (from16.ok) { - max16 = rt.u8Mul(rt.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64) ? 1 : 0, 4); + max16 = rs.u8Mul(rs.u64Eq(from16.value, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64) ? 1 : 0, 4); } else { max16 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed16.ok ? 1 : 0, max16)); + rs.byteVecPush(out, rs.u8Add(parsed16.ok ? 1 : 0, max16)); } } } } else if (_4 === 4) { if (dataLen !== 0) { - const first5: rt.u8 = dataData[dataStart]; - const rest5: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix29: rt.u32 = rt.u32Add(2, rt.u32Rem(first5 as rt.u32, 35)); - const _1511: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first5: rs.u8 = dataData[dataStart]; + const rest5: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix29: rs.u32 = rs.u32Add(2, rs.u32Rem(first5 as rs.u32, 35)); + const _1511: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_1511 === 0) { - const _1515: rt.Result = rt.strFromUtf8(rest5); + const _1515: rs.Result = rs.strFromUtf8(rest5); if (_1515.ok) { - const iter17: rt.Iter = rt.strChars(_1515.value); + const iter17: rs.Iter = rs.strChars(_1515.value); while (true) { - const _1521: rt.char | rt.Done = iter17.next(); - if (_1521 === rt.DONE) { + const _1521: rs.char | rs.Done = iter17.next(); + if (_1521 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1521, radix29), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1521, radix29), 99)))); } - const radix30: rt.u32 = radix29; - const _1536: rt.Result = num_fromStrRadix$0g0g31i(_1515.value, radix30); + const radix30: rs.u32 = radix29; + const _1536: rs.Result = num_fromStrRadix$09i2k2a(_1515.value, radix30); if (_1536.ok) { const arg32 = _1536.value; - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg32, f)]; - put(out, rt.fmtFormat([args66[0]])); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg32, f)]; + put(out, rs.fmtFormat([args66[0]])); } else { - const e17: rt.ParseIntError = _1536.error; - const _1552: rt.IntErrorKind = e17.kind; + const e17: rs.ParseIntError = _1536.error; + const _1552: rs.IntErrorKind = e17.kind; if (_1552 === "Empty") { kind18 = 0; } else if (_1552 === "InvalidDigit") { @@ -3920,44 +3920,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind18 = 4; } - if (!(e17.kind === "PosOverflow" as rt.IntErrorKind)) { - over17 = e17.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e17.kind === "PosOverflow" as rs.IntErrorKind)) { + over17 = e17.kind !== "NegOverflow" as rs.IntErrorKind; } else { over17 = true; } - const _1572: rt.IntErrorKind = e17.kind; - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e17, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e17, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1572), (f: rt.Formatter) => rt.i32Display(kind18, f), (f: rt.Formatter) => rt.fmtBool(over17, f)]; - put(out, rt.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); + const _1572: rs.IntErrorKind = e17.kind; + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1572), (f: rs.Formatter) => rs.i32Display(kind18, f), (f: rs.Formatter) => rs.fmtBool(over17, f)]; + put(out, rs.fmtFormat([args68[0], "|", args68[1], "|", args68[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args68[0]), "|", args68[3], "|", args68[4]])); } if (radix30 === 10) { - const parsed17: rt.Result = parse$069o3rw(_1515.value); - const from17: rt.Result = num_fromStr$0qvzsmz(_1515.value); + const parsed17: rs.Result = parse$11owssr(_1515.value); + const from17: rs.Result = num_fromStr$0ihvy10(_1515.value); if (from17.ok) { - max17 = rt.u8Mul(rt.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); + max17 = rs.u8Mul(rs.u128Eq(from17.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { max17 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed17.ok ? 1 : 0, max17)); + rs.byteVecPush(out, rs.u8Add(parsed17.ok ? 1 : 0, max17)); } } } else if (_1511 === 1) { let s9: string = ""; - for (const b5 of rt.byteSliceView(rest5)) { - const _1612: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1613: rt.usize = rt.usizeRem(b5 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_1612, _1613); - s9 = s9 + String.fromCodePoint(_1612.data[_1612.start + _1613] as rt.char); + for (const b5 of rs.byteSliceView(rest5)) { + const _1612: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1613: rs.usize = rs.usizeRem(b5 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1612, _1613); + s9 = s9 + String.fromCodePoint(_1612.data[_1612.start + _1613] as rs.char); } const _1624: string = s9; - const radix31: rt.u32 = radix29; - const _1627: rt.Result = num_fromStrRadix$0g0g31i(_1624, radix31); + const radix31: rs.u32 = radix29; + const _1627: rs.Result = num_fromStrRadix$09i2k2a(_1624, radix31); if (_1627.ok) { const arg31 = _1627.value; - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg31, f)]; - put(out, rt.fmtFormat([args70[0]])); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg31, f)]; + put(out, rs.fmtFormat([args70[0]])); } else { - const e18: rt.ParseIntError = _1627.error; - const _1643: rt.IntErrorKind = e18.kind; + const e18: rs.ParseIntError = _1627.error; + const _1643: rs.IntErrorKind = e18.kind; if (_1643 === "Empty") { kind19 = 0; } else if (_1643 === "InvalidDigit") { @@ -3969,44 +3969,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind19 = 4; } - if (!(e18.kind === "PosOverflow" as rt.IntErrorKind)) { - over18 = e18.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e18.kind === "PosOverflow" as rs.IntErrorKind)) { + over18 = e18.kind !== "NegOverflow" as rs.IntErrorKind; } else { over18 = true; } - const _1663: rt.IntErrorKind = e18.kind; - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e18, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e18, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1663), (f: rt.Formatter) => rt.i32Display(kind19, f), (f: rt.Formatter) => rt.fmtBool(over18, f)]; - put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); + const _1663: rs.IntErrorKind = e18.kind; + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e18, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e18, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1663), (f: rs.Formatter) => rs.i32Display(kind19, f), (f: rs.Formatter) => rs.fmtBool(over18, f)]; + put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", args72[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", args72[3], "|", args72[4]])); } if (radix31 === 10) { - const parsed18: rt.Result = parse$069o3rw(_1624); - const from18: rt.Result = num_fromStr$0qvzsmz(_1624); + const parsed18: rs.Result = parse$11owssr(_1624); + const from18: rs.Result = num_fromStr$0ihvy10(_1624); if (from18.ok) { - max18 = rt.u8Mul(rt.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); + max18 = rs.u8Mul(rs.u128Eq(from18.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { max18 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed18.ok ? 1 : 0, max18)); + rs.byteVecPush(out, rs.u8Add(parsed18.ok ? 1 : 0, max18)); } } else { if (_1511 === 2) { - const iter19: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter19: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _1695: rt.u32 | rt.Done = iter19.next(); - if (_1695 === rt.DONE) { + const _1695: rs.u32 | rs.Done = iter19.next(); + if (_1695 === rs.DONE) { break b0; } - const radix32: rt.u32 = _1695; - for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 0, 128, radix32).items) { - const radix33: rt.u32 = radix32; - const _1713: rt.Result = num_fromStrRadix$0g0g31i(_1702, radix33); + const radix32: rs.u32 = _1695; + for (const _1702 of edges({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 0, 128, radix32).items) { + const radix33: rs.u32 = radix32; + const _1713: rs.Result = num_fromStrRadix$09i2k2a(_1702, radix33); if (_1713.ok) { const arg30 = _1713.value; - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg30, f)]; - put(out, rt.fmtFormat([args74[0]])); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg30, f)]; + put(out, rs.fmtFormat([args74[0]])); } else { - const e19: rt.ParseIntError = _1713.error; - const _1729: rt.IntErrorKind = e19.kind; + const e19: rs.ParseIntError = _1713.error; + const _1729: rs.IntErrorKind = e19.kind; if (_1729 === "Empty") { kind20 = 0; } else if (_1729 === "InvalidDigit") { @@ -4018,49 +4018,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind20 = 4; } - if (!(e19.kind === "PosOverflow" as rt.IntErrorKind)) { - over19 = e19.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e19.kind === "PosOverflow" as rs.IntErrorKind)) { + over19 = e19.kind !== "NegOverflow" as rs.IntErrorKind; } else { over19 = true; } - const _1749: rt.IntErrorKind = e19.kind; - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e19, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e19, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1749), (f: rt.Formatter) => rt.i32Display(kind20, f), (f: rt.Formatter) => rt.fmtBool(over19, f)]; - put(out, rt.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); + const _1749: rs.IntErrorKind = e19.kind; + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1749), (f: rs.Formatter) => rs.i32Display(kind20, f), (f: rs.Formatter) => rs.fmtBool(over19, f)]; + put(out, rs.fmtFormat([args76[0], "|", args76[1], "|", args76[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args76[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args76[0]), "|", args76[3], "|", args76[4]])); } if (radix33 === 10) { - const parsed19: rt.Result = parse$069o3rw(_1702); - const from19: rt.Result = num_fromStr$0qvzsmz(_1702); + const parsed19: rs.Result = parse$11owssr(_1702); + const from19: rs.Result = num_fromStr$0ihvy10(_1702); if (from19.ok) { - max19 = rt.u8Mul(rt.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); + max19 = rs.u8Mul(rs.u128Eq(from19.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { max19 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed19.ok ? 1 : 0, max19)); + rs.byteVecPush(out, rs.u8Add(parsed19.ok ? 1 : 0, max19)); } } } } - const radix34: rt.u32 = ((first5 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest5), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest5, 1), (b20: rt.u8): boolean => { + const radix34: rs.u32 = ((first5 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest5), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest5, 1), (b20: rs.u8): boolean => { return (b20 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix34), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix34), 99)))); } if (!(rest5.length > 2)) { - text5 = rt.byteSliceFrom(Uint8Array.of()); + text5 = rs.byteSliceFrom(Uint8Array.of()); } else { - text5 = rt.byteSliceRange(rest5, 2); + text5 = rs.byteSliceRange(rest5, 2); } - const _1805: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text5), "1"); - const radix35: rt.u32 = radix34; - const _1810: rt.Result = num_fromStrRadix$0g0g31i(_1805, radix35); + const _1805: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text5), "1"); + const radix35: rs.u32 = radix34; + const _1810: rs.Result = num_fromStrRadix$09i2k2a(_1805, radix35); if (_1810.ok) { const arg29 = _1810.value; - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg29, f)]; - put(out, rt.fmtFormat([args78[0]])); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg29, f)]; + put(out, rs.fmtFormat([args78[0]])); } else { - const e20: rt.ParseIntError = _1810.error; - const _1826: rt.IntErrorKind = e20.kind; + const e20: rs.ParseIntError = _1810.error; + const _1826: rs.IntErrorKind = e20.kind; if (_1826 === "Empty") { kind21 = 0; } else if (_1826 === "InvalidDigit") { @@ -4072,53 +4072,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind21 = 4; } - if (!(e20.kind === "PosOverflow" as rt.IntErrorKind)) { - over20 = e20.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e20.kind === "PosOverflow" as rs.IntErrorKind)) { + over20 = e20.kind !== "NegOverflow" as rs.IntErrorKind; } else { over20 = true; } - const _1846: rt.IntErrorKind = e20.kind; - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e20, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e20, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1846), (f: rt.Formatter) => rt.i32Display(kind21, f), (f: rt.Formatter) => rt.fmtBool(over20, f)]; - put(out, rt.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); + const _1846: rs.IntErrorKind = e20.kind; + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1846), (f: rs.Formatter) => rs.i32Display(kind21, f), (f: rs.Formatter) => rs.fmtBool(over20, f)]; + put(out, rs.fmtFormat([args80[0], "|", args80[1], "|", args80[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args80[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args80[0]), "|", args80[3], "|", args80[4]])); } if (radix35 === 10) { - const parsed20: rt.Result = parse$069o3rw(_1805); - const from20: rt.Result = num_fromStr$0qvzsmz(_1805); + const parsed20: rs.Result = parse$11owssr(_1805); + const from20: rs.Result = num_fromStr$0ihvy10(_1805); if (from20.ok) { - max20 = rt.u8Mul(rt.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128) ? 1 : 0, 4); + max20 = rs.u8Mul(rs.u128Eq(from20.value, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128) ? 1 : 0, 4); } else { max20 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed20.ok ? 1 : 0, max20)); + rs.byteVecPush(out, rs.u8Add(parsed20.ok ? 1 : 0, max20)); } } } } else if (_4 === 5) { if (dataLen !== 0) { - const first6: rt.u8 = dataData[dataStart]; - const rest6: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix36: rt.u32 = rt.u32Add(2, rt.u32Rem(first6 as rt.u32, 35)); - const _1884: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first6: rs.u8 = dataData[dataStart]; + const rest6: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix36: rs.u32 = rs.u32Add(2, rs.u32Rem(first6 as rs.u32, 35)); + const _1884: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_1884 === 0) { - const _1888: rt.Result = rt.strFromUtf8(rest6); + const _1888: rs.Result = rs.strFromUtf8(rest6); if (_1888.ok) { - const iter21: rt.Iter = rt.strChars(_1888.value); + const iter21: rs.Iter = rs.strChars(_1888.value); while (true) { - const _1894: rt.char | rt.Done = iter21.next(); - if (_1894 === rt.DONE) { + const _1894: rs.char | rs.Done = iter21.next(); + if (_1894 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_1894, radix36), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_1894, radix36), 99)))); } - const radix37: rt.u32 = radix36; - const _1909: rt.Result = num_fromStrRadix$146bkjv(_1888.value, radix37); + const radix37: rs.u32 = radix36; + const _1909: rs.Result = num_fromStrRadix$1479ec4(_1888.value, radix37); if (_1909.ok) { const arg28 = _1909.value; - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg28, f)]; - put(out, rt.fmtFormat([args82[0]])); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg28, f)]; + put(out, rs.fmtFormat([args82[0]])); } else { - const e21: rt.ParseIntError = _1909.error; - const _1925: rt.IntErrorKind = e21.kind; + const e21: rs.ParseIntError = _1909.error; + const _1925: rs.IntErrorKind = e21.kind; if (_1925 === "Empty") { kind22 = 0; } else if (_1925 === "InvalidDigit") { @@ -4130,44 +4130,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind22 = 4; } - if (!(e21.kind === "PosOverflow" as rt.IntErrorKind)) { - over21 = e21.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e21.kind === "PosOverflow" as rs.IntErrorKind)) { + over21 = e21.kind !== "NegOverflow" as rs.IntErrorKind; } else { over21 = true; } - const _1945: rt.IntErrorKind = e21.kind; - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e21, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e21, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _1945), (f: rt.Formatter) => rt.i32Display(kind22, f), (f: rt.Formatter) => rt.fmtBool(over21, f)]; - put(out, rt.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); + const _1945: rs.IntErrorKind = e21.kind; + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e21, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e21, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _1945), (f: rs.Formatter) => rs.i32Display(kind22, f), (f: rs.Formatter) => rs.fmtBool(over21, f)]; + put(out, rs.fmtFormat([args84[0], "|", args84[1], "|", args84[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args84[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args84[0]), "|", args84[3], "|", args84[4]])); } if (radix37 === 10) { - const parsed21: rt.Result = parse$1i990qj(_1888.value); - const from21: rt.Result = num_fromStr$047hkg7(_1888.value); + const parsed21: rs.Result = parse$07zoymb(_1888.value); + const from21: rs.Result = num_fromStr$1jgkxdq(_1888.value); if (from21.ok) { - max21 = rt.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); + max21 = rs.u8Mul(from21.value === 4294967295 ? 1 : 0, 4); } else { max21 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed21.ok ? 1 : 0, max21)); + rs.byteVecPush(out, rs.u8Add(parsed21.ok ? 1 : 0, max21)); } } } else if (_1884 === 1) { let s11: string = ""; - for (const b6 of rt.byteSliceView(rest6)) { - const _1985: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _1986: rt.usize = rt.usizeRem(b6 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_1985, _1986); - s11 = s11 + String.fromCodePoint(_1985.data[_1985.start + _1986] as rt.char); + for (const b6 of rs.byteSliceView(rest6)) { + const _1985: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _1986: rs.usize = rs.usizeRem(b6 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_1985, _1986); + s11 = s11 + String.fromCodePoint(_1985.data[_1985.start + _1986] as rs.char); } const _1997: string = s11; - const radix38: rt.u32 = radix36; - const _2000: rt.Result = num_fromStrRadix$146bkjv(_1997, radix38); + const radix38: rs.u32 = radix36; + const _2000: rs.Result = num_fromStrRadix$1479ec4(_1997, radix38); if (_2000.ok) { const arg27 = _2000.value; - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg27, f)]; - put(out, rt.fmtFormat([args86[0]])); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg27, f)]; + put(out, rs.fmtFormat([args86[0]])); } else { - const e22: rt.ParseIntError = _2000.error; - const _2016: rt.IntErrorKind = e22.kind; + const e22: rs.ParseIntError = _2000.error; + const _2016: rs.IntErrorKind = e22.kind; if (_2016 === "Empty") { kind23 = 0; } else if (_2016 === "InvalidDigit") { @@ -4179,44 +4179,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind23 = 4; } - if (!(e22.kind === "PosOverflow" as rt.IntErrorKind)) { - over22 = e22.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e22.kind === "PosOverflow" as rs.IntErrorKind)) { + over22 = e22.kind !== "NegOverflow" as rs.IntErrorKind; } else { over22 = true; } - const _2036: rt.IntErrorKind = e22.kind; - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e22, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e22, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2036), (f: rt.Formatter) => rt.i32Display(kind23, f), (f: rt.Formatter) => rt.fmtBool(over22, f)]; - put(out, rt.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); + const _2036: rs.IntErrorKind = e22.kind; + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2036), (f: rs.Formatter) => rs.i32Display(kind23, f), (f: rs.Formatter) => rs.fmtBool(over22, f)]; + put(out, rs.fmtFormat([args88[0], "|", args88[1], "|", args88[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args88[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args88[0]), "|", args88[3], "|", args88[4]])); } if (radix38 === 10) { - const parsed22: rt.Result = parse$1i990qj(_1997); - const from22: rt.Result = num_fromStr$047hkg7(_1997); + const parsed22: rs.Result = parse$07zoymb(_1997); + const from22: rs.Result = num_fromStr$1jgkxdq(_1997); if (from22.ok) { - max22 = rt.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); + max22 = rs.u8Mul(from22.value === 4294967295 ? 1 : 0, 4); } else { max22 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed22.ok ? 1 : 0, max22)); + rs.byteVecPush(out, rs.u8Add(parsed22.ok ? 1 : 0, max22)); } } else { if (_1884 === 2) { - const iter23: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter23: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _2068: rt.u32 | rt.Done = iter23.next(); - if (_2068 === rt.DONE) { + const _2068: rs.u32 | rs.Done = iter23.next(); + if (_2068 === rs.DONE) { break b0; } - const radix39: rt.u32 = _2068; + const radix39: rs.u32 = _2068; for (const _2076 of edges(4294967295, 0, 32, radix39).items) { - const radix40: rt.u32 = radix39; - const _2087: rt.Result = num_fromStrRadix$146bkjv(_2076, radix40); + const radix40: rs.u32 = radix39; + const _2087: rs.Result = num_fromStrRadix$1479ec4(_2076, radix40); if (_2087.ok) { const arg26 = _2087.value; - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg26, f)]; - put(out, rt.fmtFormat([args90[0]])); + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg26, f)]; + put(out, rs.fmtFormat([args90[0]])); } else { - const e23: rt.ParseIntError = _2087.error; - const _2103: rt.IntErrorKind = e23.kind; + const e23: rs.ParseIntError = _2087.error; + const _2103: rs.IntErrorKind = e23.kind; if (_2103 === "Empty") { kind24 = 0; } else if (_2103 === "InvalidDigit") { @@ -4228,49 +4228,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind24 = 4; } - if (!(e23.kind === "PosOverflow" as rt.IntErrorKind)) { - over23 = e23.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e23.kind === "PosOverflow" as rs.IntErrorKind)) { + over23 = e23.kind !== "NegOverflow" as rs.IntErrorKind; } else { over23 = true; } - const _2123: rt.IntErrorKind = e23.kind; - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e23, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e23, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2123), (f: rt.Formatter) => rt.i32Display(kind24, f), (f: rt.Formatter) => rt.fmtBool(over23, f)]; - put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); + const _2123: rs.IntErrorKind = e23.kind; + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2123), (f: rs.Formatter) => rs.i32Display(kind24, f), (f: rs.Formatter) => rs.fmtBool(over23, f)]; + put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", args92[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", args92[3], "|", args92[4]])); } if (radix40 === 10) { - const parsed23: rt.Result = parse$1i990qj(_2076); - const from23: rt.Result = num_fromStr$047hkg7(_2076); + const parsed23: rs.Result = parse$07zoymb(_2076); + const from23: rs.Result = num_fromStr$1jgkxdq(_2076); if (from23.ok) { - max23 = rt.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); + max23 = rs.u8Mul(from23.value === 4294967295 ? 1 : 0, 4); } else { max23 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed23.ok ? 1 : 0, max23)); + rs.byteVecPush(out, rs.u8Add(parsed23.ok ? 1 : 0, max23)); } } } } - const radix41: rt.u32 = ((first6 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest6), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest6, 1), (b19: rt.u8): boolean => { + const radix41: rs.u32 = ((first6 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest6), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest6, 1), (b19: rs.u8): boolean => { return (b19 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix41), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix41), 99)))); } if (!(rest6.length > 2)) { - text6 = rt.byteSliceFrom(Uint8Array.of()); + text6 = rs.byteSliceFrom(Uint8Array.of()); } else { - text6 = rt.byteSliceRange(rest6, 2); + text6 = rs.byteSliceRange(rest6, 2); } - const _2179: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text6), "1"); - const radix42: rt.u32 = radix41; - const _2184: rt.Result = num_fromStrRadix$146bkjv(_2179, radix42); + const _2179: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text6), "1"); + const radix42: rs.u32 = radix41; + const _2184: rs.Result = num_fromStrRadix$1479ec4(_2179, radix42); if (_2184.ok) { const arg25 = _2184.value; - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg25, f)]; - put(out, rt.fmtFormat([args94[0]])); + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg25, f)]; + put(out, rs.fmtFormat([args94[0]])); } else { - const e24: rt.ParseIntError = _2184.error; - const _2200: rt.IntErrorKind = e24.kind; + const e24: rs.ParseIntError = _2184.error; + const _2200: rs.IntErrorKind = e24.kind; if (_2200 === "Empty") { kind25 = 0; } else if (_2200 === "InvalidDigit") { @@ -4282,53 +4282,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind25 = 4; } - if (!(e24.kind === "PosOverflow" as rt.IntErrorKind)) { - over24 = e24.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e24.kind === "PosOverflow" as rs.IntErrorKind)) { + over24 = e24.kind !== "NegOverflow" as rs.IntErrorKind; } else { over24 = true; } - const _2220: rt.IntErrorKind = e24.kind; - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e24, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e24, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2220), (f: rt.Formatter) => rt.i32Display(kind25, f), (f: rt.Formatter) => rt.fmtBool(over24, f)]; - put(out, rt.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); + const _2220: rs.IntErrorKind = e24.kind; + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e24, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e24, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2220), (f: rs.Formatter) => rs.i32Display(kind25, f), (f: rs.Formatter) => rs.fmtBool(over24, f)]; + put(out, rs.fmtFormat([args96[0], "|", args96[1], "|", args96[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args96[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args96[0]), "|", args96[3], "|", args96[4]])); } if (radix42 === 10) { - const parsed24: rt.Result = parse$1i990qj(_2179); - const from24: rt.Result = num_fromStr$047hkg7(_2179); + const parsed24: rs.Result = parse$07zoymb(_2179); + const from24: rs.Result = num_fromStr$1jgkxdq(_2179); if (from24.ok) { - max24 = rt.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); + max24 = rs.u8Mul(from24.value === 4294967295 ? 1 : 0, 4); } else { max24 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed24.ok ? 1 : 0, max24)); + rs.byteVecPush(out, rs.u8Add(parsed24.ok ? 1 : 0, max24)); } } } } else if (_4 === 6) { if (dataLen !== 0) { - const first7: rt.u8 = dataData[dataStart]; - const rest7: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix43: rt.u32 = rt.u32Add(2, rt.u32Rem(first7 as rt.u32, 35)); - const _2258: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first7: rs.u8 = dataData[dataStart]; + const rest7: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix43: rs.u32 = rs.u32Add(2, rs.u32Rem(first7 as rs.u32, 35)); + const _2258: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_2258 === 0) { - const _2262: rt.Result = rt.strFromUtf8(rest7); + const _2262: rs.Result = rs.strFromUtf8(rest7); if (_2262.ok) { - const iter25: rt.Iter = rt.strChars(_2262.value); + const iter25: rs.Iter = rs.strChars(_2262.value); while (true) { - const _2268: rt.char | rt.Done = iter25.next(); - if (_2268 === rt.DONE) { + const _2268: rs.char | rs.Done = iter25.next(); + if (_2268 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2268, radix43), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2268, radix43), 99)))); } - const radix44: rt.u32 = radix43; - const _2283: rt.Result = num_fromStrRadix$0dg9fx3(_2262.value, radix44); + const radix44: rs.u32 = radix43; + const _2283: rs.Result = num_fromStrRadix$0qyezqs(_2262.value, radix44); if (_2283.ok) { const arg24 = _2283.value; - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg24, f)]; - put(out, rt.fmtFormat([args98[0]])); + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg24, f)]; + put(out, rs.fmtFormat([args98[0]])); } else { - const e25: rt.ParseIntError = _2283.error; - const _2299: rt.IntErrorKind = e25.kind; + const e25: rs.ParseIntError = _2283.error; + const _2299: rs.IntErrorKind = e25.kind; if (_2299 === "Empty") { kind26 = 0; } else if (_2299 === "InvalidDigit") { @@ -4340,44 +4340,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind26 = 4; } - if (!(e25.kind === "PosOverflow" as rt.IntErrorKind)) { - over25 = e25.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e25.kind === "PosOverflow" as rs.IntErrorKind)) { + over25 = e25.kind !== "NegOverflow" as rs.IntErrorKind; } else { over25 = true; } - const _2319: rt.IntErrorKind = e25.kind; - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e25, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e25, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2319), (f: rt.Formatter) => rt.i32Display(kind26, f), (f: rt.Formatter) => rt.fmtBool(over25, f)]; - put(out, rt.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); + const _2319: rs.IntErrorKind = e25.kind; + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2319), (f: rs.Formatter) => rs.i32Display(kind26, f), (f: rs.Formatter) => rs.fmtBool(over25, f)]; + put(out, rs.fmtFormat([args100[0], "|", args100[1], "|", args100[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args100[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args100[0]), "|", args100[3], "|", args100[4]])); } if (radix44 === 10) { - const parsed25: rt.Result = parse$14z7a72(_2262.value); - const from25: rt.Result = num_fromStr$029r9bb(_2262.value); + const parsed25: rs.Result = parse$02m1946(_2262.value); + const from25: rs.Result = num_fromStr$1amqoj7(_2262.value); if (from25.ok) { - max25 = rt.u8Mul(from25.value === 127 ? 1 : 0, 4); + max25 = rs.u8Mul(from25.value === 127 ? 1 : 0, 4); } else { max25 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed25.ok ? 1 : 0, max25)); + rs.byteVecPush(out, rs.u8Add(parsed25.ok ? 1 : 0, max25)); } } } else if (_2258 === 1) { let s13: string = ""; - for (const b7 of rt.byteSliceView(rest7)) { - const _2359: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _2360: rt.usize = rt.usizeRem(b7 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_2359, _2360); - s13 = s13 + String.fromCodePoint(_2359.data[_2359.start + _2360] as rt.char); + for (const b7 of rs.byteSliceView(rest7)) { + const _2359: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _2360: rs.usize = rs.usizeRem(b7 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_2359, _2360); + s13 = s13 + String.fromCodePoint(_2359.data[_2359.start + _2360] as rs.char); } const _2371: string = s13; - const radix45: rt.u32 = radix43; - const _2374: rt.Result = num_fromStrRadix$0dg9fx3(_2371, radix45); + const radix45: rs.u32 = radix43; + const _2374: rs.Result = num_fromStrRadix$0qyezqs(_2371, radix45); if (_2374.ok) { const arg23 = _2374.value; - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg23, f)]; - put(out, rt.fmtFormat([args102[0]])); + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg23, f)]; + put(out, rs.fmtFormat([args102[0]])); } else { - const e26: rt.ParseIntError = _2374.error; - const _2390: rt.IntErrorKind = e26.kind; + const e26: rs.ParseIntError = _2374.error; + const _2390: rs.IntErrorKind = e26.kind; if (_2390 === "Empty") { kind27 = 0; } else if (_2390 === "InvalidDigit") { @@ -4389,44 +4389,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind27 = 4; } - if (!(e26.kind === "PosOverflow" as rt.IntErrorKind)) { - over26 = e26.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e26.kind === "PosOverflow" as rs.IntErrorKind)) { + over26 = e26.kind !== "NegOverflow" as rs.IntErrorKind; } else { over26 = true; } - const _2410: rt.IntErrorKind = e26.kind; - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e26, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e26, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2410), (f: rt.Formatter) => rt.i32Display(kind27, f), (f: rt.Formatter) => rt.fmtBool(over26, f)]; - put(out, rt.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); + const _2410: rs.IntErrorKind = e26.kind; + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2410), (f: rs.Formatter) => rs.i32Display(kind27, f), (f: rs.Formatter) => rs.fmtBool(over26, f)]; + put(out, rs.fmtFormat([args104[0], "|", args104[1], "|", args104[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args104[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args104[0]), "|", args104[3], "|", args104[4]])); } if (radix45 === 10) { - const parsed26: rt.Result = parse$14z7a72(_2371); - const from26: rt.Result = num_fromStr$029r9bb(_2371); + const parsed26: rs.Result = parse$02m1946(_2371); + const from26: rs.Result = num_fromStr$1amqoj7(_2371); if (from26.ok) { - max26 = rt.u8Mul(from26.value === 127 ? 1 : 0, 4); + max26 = rs.u8Mul(from26.value === 127 ? 1 : 0, 4); } else { max26 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed26.ok ? 1 : 0, max26)); + rs.byteVecPush(out, rs.u8Add(parsed26.ok ? 1 : 0, max26)); } } else { if (_2258 === 2) { - const iter27: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter27: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _2442: rt.u32 | rt.Done = iter27.next(); - if (_2442 === rt.DONE) { + const _2442: rs.u32 | rs.Done = iter27.next(); + if (_2442 === rs.DONE) { break b0; } - const radix46: rt.u32 = _2442; - for (const _2453 of edges(127, rt.u128Add(127, 1), 8, radix46).items) { - const radix47: rt.u32 = radix46; - const _2464: rt.Result = num_fromStrRadix$0dg9fx3(_2453, radix47); + const radix46: rs.u32 = _2442; + for (const _2453 of edges(127, rs.u128Add(127, 1), 8, radix46).items) { + const radix47: rs.u32 = radix46; + const _2464: rs.Result = num_fromStrRadix$0qyezqs(_2453, radix47); if (_2464.ok) { const arg22 = _2464.value; - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg22, f)]; - put(out, rt.fmtFormat([args106[0]])); + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg22, f)]; + put(out, rs.fmtFormat([args106[0]])); } else { - const e27: rt.ParseIntError = _2464.error; - const _2480: rt.IntErrorKind = e27.kind; + const e27: rs.ParseIntError = _2464.error; + const _2480: rs.IntErrorKind = e27.kind; if (_2480 === "Empty") { kind28 = 0; } else if (_2480 === "InvalidDigit") { @@ -4438,49 +4438,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind28 = 4; } - if (!(e27.kind === "PosOverflow" as rt.IntErrorKind)) { - over27 = e27.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e27.kind === "PosOverflow" as rs.IntErrorKind)) { + over27 = e27.kind !== "NegOverflow" as rs.IntErrorKind; } else { over27 = true; } - const _2500: rt.IntErrorKind = e27.kind; - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e27, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e27, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2500), (f: rt.Formatter) => rt.i32Display(kind28, f), (f: rt.Formatter) => rt.fmtBool(over27, f)]; - put(out, rt.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); + const _2500: rs.IntErrorKind = e27.kind; + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e27, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e27, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2500), (f: rs.Formatter) => rs.i32Display(kind28, f), (f: rs.Formatter) => rs.fmtBool(over27, f)]; + put(out, rs.fmtFormat([args108[0], "|", args108[1], "|", args108[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args108[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args108[0]), "|", args108[3], "|", args108[4]])); } if (radix47 === 10) { - const parsed27: rt.Result = parse$14z7a72(_2453); - const from27: rt.Result = num_fromStr$029r9bb(_2453); + const parsed27: rs.Result = parse$02m1946(_2453); + const from27: rs.Result = num_fromStr$1amqoj7(_2453); if (from27.ok) { - max27 = rt.u8Mul(from27.value === 127 ? 1 : 0, 4); + max27 = rs.u8Mul(from27.value === 127 ? 1 : 0, 4); } else { max27 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed27.ok ? 1 : 0, max27)); + rs.byteVecPush(out, rs.u8Add(parsed27.ok ? 1 : 0, max27)); } } } } - const radix48: rt.u32 = ((first7 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest7), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest7, 1), (b18: rt.u8): boolean => { + const radix48: rs.u32 = ((first7 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest7), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest7, 1), (b18: rs.u8): boolean => { return (b18 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix48), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix48), 99)))); } if (!(rest7.length > 2)) { - text7 = rt.byteSliceFrom(Uint8Array.of()); + text7 = rs.byteSliceFrom(Uint8Array.of()); } else { - text7 = rt.byteSliceRange(rest7, 2); + text7 = rs.byteSliceRange(rest7, 2); } - const _2556: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text7), "1"); - const radix49: rt.u32 = radix48; - const _2561: rt.Result = num_fromStrRadix$0dg9fx3(_2556, radix49); + const _2556: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text7), "1"); + const radix49: rs.u32 = radix48; + const _2561: rs.Result = num_fromStrRadix$0qyezqs(_2556, radix49); if (_2561.ok) { const arg21 = _2561.value; - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg21, f)]; - put(out, rt.fmtFormat([args110[0]])); + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg21, f)]; + put(out, rs.fmtFormat([args110[0]])); } else { - const e28: rt.ParseIntError = _2561.error; - const _2577: rt.IntErrorKind = e28.kind; + const e28: rs.ParseIntError = _2561.error; + const _2577: rs.IntErrorKind = e28.kind; if (_2577 === "Empty") { kind29 = 0; } else if (_2577 === "InvalidDigit") { @@ -4492,53 +4492,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind29 = 4; } - if (!(e28.kind === "PosOverflow" as rt.IntErrorKind)) { - over28 = e28.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e28.kind === "PosOverflow" as rs.IntErrorKind)) { + over28 = e28.kind !== "NegOverflow" as rs.IntErrorKind; } else { over28 = true; } - const _2597: rt.IntErrorKind = e28.kind; - const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e28, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e28, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2597), (f: rt.Formatter) => rt.i32Display(kind29, f), (f: rt.Formatter) => rt.fmtBool(over28, f)]; - put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); + const _2597: rs.IntErrorKind = e28.kind; + const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2597), (f: rs.Formatter) => rs.i32Display(kind29, f), (f: rs.Formatter) => rs.fmtBool(over28, f)]; + put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", args112[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", args112[3], "|", args112[4]])); } if (radix49 === 10) { - const parsed28: rt.Result = parse$14z7a72(_2556); - const from28: rt.Result = num_fromStr$029r9bb(_2556); + const parsed28: rs.Result = parse$02m1946(_2556); + const from28: rs.Result = num_fromStr$1amqoj7(_2556); if (from28.ok) { - max28 = rt.u8Mul(from28.value === 127 ? 1 : 0, 4); + max28 = rs.u8Mul(from28.value === 127 ? 1 : 0, 4); } else { max28 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed28.ok ? 1 : 0, max28)); + rs.byteVecPush(out, rs.u8Add(parsed28.ok ? 1 : 0, max28)); } } } } else if (_4 === 7) { if (dataLen !== 0) { - const first8: rt.u8 = dataData[dataStart]; - const rest8: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix50: rt.u32 = rt.u32Add(2, rt.u32Rem(first8 as rt.u32, 35)); - const _2635: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first8: rs.u8 = dataData[dataStart]; + const rest8: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix50: rs.u32 = rs.u32Add(2, rs.u32Rem(first8 as rs.u32, 35)); + const _2635: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_2635 === 0) { - const _2639: rt.Result = rt.strFromUtf8(rest8); + const _2639: rs.Result = rs.strFromUtf8(rest8); if (_2639.ok) { - const iter29: rt.Iter = rt.strChars(_2639.value); + const iter29: rs.Iter = rs.strChars(_2639.value); while (true) { - const _2645: rt.char | rt.Done = iter29.next(); - if (_2645 === rt.DONE) { + const _2645: rs.char | rs.Done = iter29.next(); + if (_2645 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_2645, radix50), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_2645, radix50), 99)))); } - const radix51: rt.u32 = radix50; - const _2660: rt.Result = num_fromStrRadix$0rk2yr6(_2639.value, radix51); + const radix51: rs.u32 = radix50; + const _2660: rs.Result = num_fromStrRadix$19vdb8q(_2639.value, radix51); if (_2660.ok) { const arg20 = _2660.value; - const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg20, f)]; - put(out, rt.fmtFormat([args114[0]])); + const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg20, f)]; + put(out, rs.fmtFormat([args114[0]])); } else { - const e29: rt.ParseIntError = _2660.error; - const _2676: rt.IntErrorKind = e29.kind; + const e29: rs.ParseIntError = _2660.error; + const _2676: rs.IntErrorKind = e29.kind; if (_2676 === "Empty") { kind30 = 0; } else if (_2676 === "InvalidDigit") { @@ -4550,44 +4550,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind30 = 4; } - if (!(e29.kind === "PosOverflow" as rt.IntErrorKind)) { - over29 = e29.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e29.kind === "PosOverflow" as rs.IntErrorKind)) { + over29 = e29.kind !== "NegOverflow" as rs.IntErrorKind; } else { over29 = true; } - const _2696: rt.IntErrorKind = e29.kind; - const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e29, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e29, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2696), (f: rt.Formatter) => rt.i32Display(kind30, f), (f: rt.Formatter) => rt.fmtBool(over29, f)]; - put(out, rt.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); + const _2696: rs.IntErrorKind = e29.kind; + const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2696), (f: rs.Formatter) => rs.i32Display(kind30, f), (f: rs.Formatter) => rs.fmtBool(over29, f)]; + put(out, rs.fmtFormat([args116[0], "|", args116[1], "|", args116[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args116[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args116[0]), "|", args116[3], "|", args116[4]])); } if (radix51 === 10) { - const parsed29: rt.Result = parse$15bt1cx(_2639.value); - const from29: rt.Result = num_fromStr$15pqb75(_2639.value); + const parsed29: rs.Result = parse$00ajhlu(_2639.value); + const from29: rs.Result = num_fromStr$0ehcbzz(_2639.value); if (from29.ok) { - max29 = rt.u8Mul(from29.value === 32767 ? 1 : 0, 4); + max29 = rs.u8Mul(from29.value === 32767 ? 1 : 0, 4); } else { max29 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed29.ok ? 1 : 0, max29)); + rs.byteVecPush(out, rs.u8Add(parsed29.ok ? 1 : 0, max29)); } } } else if (_2635 === 1) { let s15: string = ""; - for (const b8 of rt.byteSliceView(rest8)) { - const _2736: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _2737: rt.usize = rt.usizeRem(b8 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_2736, _2737); - s15 = s15 + String.fromCodePoint(_2736.data[_2736.start + _2737] as rt.char); + for (const b8 of rs.byteSliceView(rest8)) { + const _2736: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _2737: rs.usize = rs.usizeRem(b8 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_2736, _2737); + s15 = s15 + String.fromCodePoint(_2736.data[_2736.start + _2737] as rs.char); } const _2748: string = s15; - const radix52: rt.u32 = radix50; - const _2751: rt.Result = num_fromStrRadix$0rk2yr6(_2748, radix52); + const radix52: rs.u32 = radix50; + const _2751: rs.Result = num_fromStrRadix$19vdb8q(_2748, radix52); if (_2751.ok) { const arg19 = _2751.value; - const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg19, f)]; - put(out, rt.fmtFormat([args118[0]])); + const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg19, f)]; + put(out, rs.fmtFormat([args118[0]])); } else { - const e30: rt.ParseIntError = _2751.error; - const _2767: rt.IntErrorKind = e30.kind; + const e30: rs.ParseIntError = _2751.error; + const _2767: rs.IntErrorKind = e30.kind; if (_2767 === "Empty") { kind31 = 0; } else if (_2767 === "InvalidDigit") { @@ -4599,44 +4599,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind31 = 4; } - if (!(e30.kind === "PosOverflow" as rt.IntErrorKind)) { - over30 = e30.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e30.kind === "PosOverflow" as rs.IntErrorKind)) { + over30 = e30.kind !== "NegOverflow" as rs.IntErrorKind; } else { over30 = true; } - const _2787: rt.IntErrorKind = e30.kind; - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e30, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e30, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2787), (f: rt.Formatter) => rt.i32Display(kind31, f), (f: rt.Formatter) => rt.fmtBool(over30, f)]; - put(out, rt.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); + const _2787: rs.IntErrorKind = e30.kind; + const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e30, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e30, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2787), (f: rs.Formatter) => rs.i32Display(kind31, f), (f: rs.Formatter) => rs.fmtBool(over30, f)]; + put(out, rs.fmtFormat([args120[0], "|", args120[1], "|", args120[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args120[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args120[0]), "|", args120[3], "|", args120[4]])); } if (radix52 === 10) { - const parsed30: rt.Result = parse$15bt1cx(_2748); - const from30: rt.Result = num_fromStr$15pqb75(_2748); + const parsed30: rs.Result = parse$00ajhlu(_2748); + const from30: rs.Result = num_fromStr$0ehcbzz(_2748); if (from30.ok) { - max30 = rt.u8Mul(from30.value === 32767 ? 1 : 0, 4); + max30 = rs.u8Mul(from30.value === 32767 ? 1 : 0, 4); } else { max30 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed30.ok ? 1 : 0, max30)); + rs.byteVecPush(out, rs.u8Add(parsed30.ok ? 1 : 0, max30)); } } else { if (_2635 === 2) { - const iter31: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter31: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _2819: rt.u32 | rt.Done = iter31.next(); - if (_2819 === rt.DONE) { + const _2819: rs.u32 | rs.Done = iter31.next(); + if (_2819 === rs.DONE) { break b0; } - const radix53: rt.u32 = _2819; - for (const _2830 of edges(32767, rt.u128Add(32767, 1), 16, radix53).items) { - const radix54: rt.u32 = radix53; - const _2841: rt.Result = num_fromStrRadix$0rk2yr6(_2830, radix54); + const radix53: rs.u32 = _2819; + for (const _2830 of edges(32767, rs.u128Add(32767, 1), 16, radix53).items) { + const radix54: rs.u32 = radix53; + const _2841: rs.Result = num_fromStrRadix$19vdb8q(_2830, radix54); if (_2841.ok) { const arg18 = _2841.value; - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg18, f)]; - put(out, rt.fmtFormat([args122[0]])); + const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg18, f)]; + put(out, rs.fmtFormat([args122[0]])); } else { - const e31: rt.ParseIntError = _2841.error; - const _2857: rt.IntErrorKind = e31.kind; + const e31: rs.ParseIntError = _2841.error; + const _2857: rs.IntErrorKind = e31.kind; if (_2857 === "Empty") { kind32 = 0; } else if (_2857 === "InvalidDigit") { @@ -4648,49 +4648,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind32 = 4; } - if (!(e31.kind === "PosOverflow" as rt.IntErrorKind)) { - over31 = e31.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e31.kind === "PosOverflow" as rs.IntErrorKind)) { + over31 = e31.kind !== "NegOverflow" as rs.IntErrorKind; } else { over31 = true; } - const _2877: rt.IntErrorKind = e31.kind; - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e31, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e31, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2877), (f: rt.Formatter) => rt.i32Display(kind32, f), (f: rt.Formatter) => rt.fmtBool(over31, f)]; - put(out, rt.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); + const _2877: rs.IntErrorKind = e31.kind; + const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2877), (f: rs.Formatter) => rs.i32Display(kind32, f), (f: rs.Formatter) => rs.fmtBool(over31, f)]; + put(out, rs.fmtFormat([args124[0], "|", args124[1], "|", args124[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args124[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args124[0]), "|", args124[3], "|", args124[4]])); } if (radix54 === 10) { - const parsed31: rt.Result = parse$15bt1cx(_2830); - const from31: rt.Result = num_fromStr$15pqb75(_2830); + const parsed31: rs.Result = parse$00ajhlu(_2830); + const from31: rs.Result = num_fromStr$0ehcbzz(_2830); if (from31.ok) { - max31 = rt.u8Mul(from31.value === 32767 ? 1 : 0, 4); + max31 = rs.u8Mul(from31.value === 32767 ? 1 : 0, 4); } else { max31 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed31.ok ? 1 : 0, max31)); + rs.byteVecPush(out, rs.u8Add(parsed31.ok ? 1 : 0, max31)); } } } } - const radix55: rt.u32 = ((first8 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest8), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest8, 1), (b17: rt.u8): boolean => { + const radix55: rs.u32 = ((first8 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest8), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest8, 1), (b17: rs.u8): boolean => { return (b17 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix55), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix55), 99)))); } if (!(rest8.length > 2)) { - text8 = rt.byteSliceFrom(Uint8Array.of()); + text8 = rs.byteSliceFrom(Uint8Array.of()); } else { - text8 = rt.byteSliceRange(rest8, 2); + text8 = rs.byteSliceRange(rest8, 2); } - const _2933: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text8), "1"); - const radix56: rt.u32 = radix55; - const _2938: rt.Result = num_fromStrRadix$0rk2yr6(_2933, radix56); + const _2933: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text8), "1"); + const radix56: rs.u32 = radix55; + const _2938: rs.Result = num_fromStrRadix$19vdb8q(_2933, radix56); if (_2938.ok) { const arg17 = _2938.value; - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg17, f)]; - put(out, rt.fmtFormat([args126[0]])); + const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg17, f)]; + put(out, rs.fmtFormat([args126[0]])); } else { - const e32: rt.ParseIntError = _2938.error; - const _2954: rt.IntErrorKind = e32.kind; + const e32: rs.ParseIntError = _2938.error; + const _2954: rs.IntErrorKind = e32.kind; if (_2954 === "Empty") { kind33 = 0; } else if (_2954 === "InvalidDigit") { @@ -4702,53 +4702,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind33 = 4; } - if (!(e32.kind === "PosOverflow" as rt.IntErrorKind)) { - over32 = e32.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e32.kind === "PosOverflow" as rs.IntErrorKind)) { + over32 = e32.kind !== "NegOverflow" as rs.IntErrorKind; } else { over32 = true; } - const _2974: rt.IntErrorKind = e32.kind; - const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e32, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e32, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _2974), (f: rt.Formatter) => rt.i32Display(kind33, f), (f: rt.Formatter) => rt.fmtBool(over32, f)]; - put(out, rt.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); + const _2974: rs.IntErrorKind = e32.kind; + const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _2974), (f: rs.Formatter) => rs.i32Display(kind33, f), (f: rs.Formatter) => rs.fmtBool(over32, f)]; + put(out, rs.fmtFormat([args128[0], "|", args128[1], "|", args128[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args128[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args128[0]), "|", args128[3], "|", args128[4]])); } if (radix56 === 10) { - const parsed32: rt.Result = parse$15bt1cx(_2933); - const from32: rt.Result = num_fromStr$15pqb75(_2933); + const parsed32: rs.Result = parse$00ajhlu(_2933); + const from32: rs.Result = num_fromStr$0ehcbzz(_2933); if (from32.ok) { - max32 = rt.u8Mul(from32.value === 32767 ? 1 : 0, 4); + max32 = rs.u8Mul(from32.value === 32767 ? 1 : 0, 4); } else { max32 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed32.ok ? 1 : 0, max32)); + rs.byteVecPush(out, rs.u8Add(parsed32.ok ? 1 : 0, max32)); } } } } else if (_4 === 8) { if (dataLen !== 0) { - const first9: rt.u8 = dataData[dataStart]; - const rest9: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix57: rt.u32 = rt.u32Add(2, rt.u32Rem(first9 as rt.u32, 35)); - const _3012: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first9: rs.u8 = dataData[dataStart]; + const rest9: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix57: rs.u32 = rs.u32Add(2, rs.u32Rem(first9 as rs.u32, 35)); + const _3012: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_3012 === 0) { - const _3016: rt.Result = rt.strFromUtf8(rest9); + const _3016: rs.Result = rs.strFromUtf8(rest9); if (_3016.ok) { - const iter33: rt.Iter = rt.strChars(_3016.value); + const iter33: rs.Iter = rs.strChars(_3016.value); while (true) { - const _3022: rt.char | rt.Done = iter33.next(); - if (_3022 === rt.DONE) { + const _3022: rs.char | rs.Done = iter33.next(); + if (_3022 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3022, radix57), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3022, radix57), 99)))); } - const radix58: rt.u32 = radix57; - const _3037: rt.Result = num_fromStrRadix$1newkmi(_3016.value, radix58); + const radix58: rs.u32 = radix57; + const _3037: rs.Result = num_fromStrRadix$1ct8u92(_3016.value, radix58); if (_3037.ok) { const arg16 = _3037.value; - const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg16, f)]; - put(out, rt.fmtFormat([args130[0]])); + const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg16, f)]; + put(out, rs.fmtFormat([args130[0]])); } else { - const e33: rt.ParseIntError = _3037.error; - const _3053: rt.IntErrorKind = e33.kind; + const e33: rs.ParseIntError = _3037.error; + const _3053: rs.IntErrorKind = e33.kind; if (_3053 === "Empty") { kind34 = 0; } else if (_3053 === "InvalidDigit") { @@ -4760,44 +4760,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind34 = 4; } - if (!(e33.kind === "PosOverflow" as rt.IntErrorKind)) { - over33 = e33.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e33.kind === "PosOverflow" as rs.IntErrorKind)) { + over33 = e33.kind !== "NegOverflow" as rs.IntErrorKind; } else { over33 = true; } - const _3073: rt.IntErrorKind = e33.kind; - const args132: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e33, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e33, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3073), (f: rt.Formatter) => rt.i32Display(kind34, f), (f: rt.Formatter) => rt.fmtBool(over33, f)]; - put(out, rt.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); + const _3073: rs.IntErrorKind = e33.kind; + const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e33, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e33, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3073), (f: rs.Formatter) => rs.i32Display(kind34, f), (f: rs.Formatter) => rs.fmtBool(over33, f)]; + put(out, rs.fmtFormat([args132[0], "|", args132[1], "|", args132[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args132[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args132[0]), "|", args132[3], "|", args132[4]])); } if (radix58 === 10) { - const parsed33: rt.Result = parse$072345g(_3016.value); - const from33: rt.Result = num_fromStr$0lmxi6o(_3016.value); + const parsed33: rs.Result = parse$14v13am(_3016.value); + const from33: rs.Result = num_fromStr$1ckv470(_3016.value); if (from33.ok) { - max33 = rt.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); + max33 = rs.u8Mul(from33.value === 2147483647 ? 1 : 0, 4); } else { max33 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed33.ok ? 1 : 0, max33)); + rs.byteVecPush(out, rs.u8Add(parsed33.ok ? 1 : 0, max33)); } } } else if (_3012 === 1) { let s17: string = ""; - for (const b9 of rt.byteSliceView(rest9)) { - const _3113: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3114: rt.usize = rt.usizeRem(b9 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_3113, _3114); - s17 = s17 + String.fromCodePoint(_3113.data[_3113.start + _3114] as rt.char); + for (const b9 of rs.byteSliceView(rest9)) { + const _3113: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3114: rs.usize = rs.usizeRem(b9 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3113, _3114); + s17 = s17 + String.fromCodePoint(_3113.data[_3113.start + _3114] as rs.char); } const _3125: string = s17; - const radix59: rt.u32 = radix57; - const _3128: rt.Result = num_fromStrRadix$1newkmi(_3125, radix59); + const radix59: rs.u32 = radix57; + const _3128: rs.Result = num_fromStrRadix$1ct8u92(_3125, radix59); if (_3128.ok) { const arg15 = _3128.value; - const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg15, f)]; - put(out, rt.fmtFormat([args134[0]])); + const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg15, f)]; + put(out, rs.fmtFormat([args134[0]])); } else { - const e34: rt.ParseIntError = _3128.error; - const _3144: rt.IntErrorKind = e34.kind; + const e34: rs.ParseIntError = _3128.error; + const _3144: rs.IntErrorKind = e34.kind; if (_3144 === "Empty") { kind35 = 0; } else if (_3144 === "InvalidDigit") { @@ -4809,44 +4809,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind35 = 4; } - if (!(e34.kind === "PosOverflow" as rt.IntErrorKind)) { - over34 = e34.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e34.kind === "PosOverflow" as rs.IntErrorKind)) { + over34 = e34.kind !== "NegOverflow" as rs.IntErrorKind; } else { over34 = true; } - const _3164: rt.IntErrorKind = e34.kind; - const args136: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e34, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e34, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3164), (f: rt.Formatter) => rt.i32Display(kind35, f), (f: rt.Formatter) => rt.fmtBool(over34, f)]; - put(out, rt.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); + const _3164: rs.IntErrorKind = e34.kind; + const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3164), (f: rs.Formatter) => rs.i32Display(kind35, f), (f: rs.Formatter) => rs.fmtBool(over34, f)]; + put(out, rs.fmtFormat([args136[0], "|", args136[1], "|", args136[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args136[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args136[0]), "|", args136[3], "|", args136[4]])); } if (radix59 === 10) { - const parsed34: rt.Result = parse$072345g(_3125); - const from34: rt.Result = num_fromStr$0lmxi6o(_3125); + const parsed34: rs.Result = parse$14v13am(_3125); + const from34: rs.Result = num_fromStr$1ckv470(_3125); if (from34.ok) { - max34 = rt.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); + max34 = rs.u8Mul(from34.value === 2147483647 ? 1 : 0, 4); } else { max34 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed34.ok ? 1 : 0, max34)); + rs.byteVecPush(out, rs.u8Add(parsed34.ok ? 1 : 0, max34)); } } else { if (_3012 === 2) { - const iter35: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter35: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _3196: rt.u32 | rt.Done = iter35.next(); - if (_3196 === rt.DONE) { + const _3196: rs.u32 | rs.Done = iter35.next(); + if (_3196 === rs.DONE) { break b0; } - const radix60: rt.u32 = _3196; - for (const _3207 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix60).items) { - const radix61: rt.u32 = radix60; - const _3218: rt.Result = num_fromStrRadix$1newkmi(_3207, radix61); + const radix60: rs.u32 = _3196; + for (const _3207 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix60).items) { + const radix61: rs.u32 = radix60; + const _3218: rs.Result = num_fromStrRadix$1ct8u92(_3207, radix61); if (_3218.ok) { const arg14 = _3218.value; - const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg14, f)]; - put(out, rt.fmtFormat([args138[0]])); + const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg14, f)]; + put(out, rs.fmtFormat([args138[0]])); } else { - const e35: rt.ParseIntError = _3218.error; - const _3234: rt.IntErrorKind = e35.kind; + const e35: rs.ParseIntError = _3218.error; + const _3234: rs.IntErrorKind = e35.kind; if (_3234 === "Empty") { kind36 = 0; } else if (_3234 === "InvalidDigit") { @@ -4858,49 +4858,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind36 = 4; } - if (!(e35.kind === "PosOverflow" as rt.IntErrorKind)) { - over35 = e35.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e35.kind === "PosOverflow" as rs.IntErrorKind)) { + over35 = e35.kind !== "NegOverflow" as rs.IntErrorKind; } else { over35 = true; } - const _3254: rt.IntErrorKind = e35.kind; - const args140: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e35, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e35, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3254), (f: rt.Formatter) => rt.i32Display(kind36, f), (f: rt.Formatter) => rt.fmtBool(over35, f)]; - put(out, rt.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); + const _3254: rs.IntErrorKind = e35.kind; + const args140: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3254), (f: rs.Formatter) => rs.i32Display(kind36, f), (f: rs.Formatter) => rs.fmtBool(over35, f)]; + put(out, rs.fmtFormat([args140[0], "|", args140[1], "|", args140[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args140[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args140[0]), "|", args140[3], "|", args140[4]])); } if (radix61 === 10) { - const parsed35: rt.Result = parse$072345g(_3207); - const from35: rt.Result = num_fromStr$0lmxi6o(_3207); + const parsed35: rs.Result = parse$14v13am(_3207); + const from35: rs.Result = num_fromStr$1ckv470(_3207); if (from35.ok) { - max35 = rt.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); + max35 = rs.u8Mul(from35.value === 2147483647 ? 1 : 0, 4); } else { max35 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed35.ok ? 1 : 0, max35)); + rs.byteVecPush(out, rs.u8Add(parsed35.ok ? 1 : 0, max35)); } } } } - const radix62: rt.u32 = ((first9 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest9), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest9, 1), (b16: rt.u8): boolean => { + const radix62: rs.u32 = ((first9 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest9), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest9, 1), (b16: rs.u8): boolean => { return (b16 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix62), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix62), 99)))); } if (!(rest9.length > 2)) { - text9 = rt.byteSliceFrom(Uint8Array.of()); + text9 = rs.byteSliceFrom(Uint8Array.of()); } else { - text9 = rt.byteSliceRange(rest9, 2); + text9 = rs.byteSliceRange(rest9, 2); } - const _3310: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text9), "1"); - const radix63: rt.u32 = radix62; - const _3315: rt.Result = num_fromStrRadix$1newkmi(_3310, radix63); + const _3310: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text9), "1"); + const radix63: rs.u32 = radix62; + const _3315: rs.Result = num_fromStrRadix$1ct8u92(_3310, radix63); if (_3315.ok) { const arg13 = _3315.value; - const args142: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg13, f)]; - put(out, rt.fmtFormat([args142[0]])); + const args142: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg13, f)]; + put(out, rs.fmtFormat([args142[0]])); } else { - const e36: rt.ParseIntError = _3315.error; - const _3331: rt.IntErrorKind = e36.kind; + const e36: rs.ParseIntError = _3315.error; + const _3331: rs.IntErrorKind = e36.kind; if (_3331 === "Empty") { kind37 = 0; } else if (_3331 === "InvalidDigit") { @@ -4912,53 +4912,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind37 = 4; } - if (!(e36.kind === "PosOverflow" as rt.IntErrorKind)) { - over36 = e36.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e36.kind === "PosOverflow" as rs.IntErrorKind)) { + over36 = e36.kind !== "NegOverflow" as rs.IntErrorKind; } else { over36 = true; } - const _3351: rt.IntErrorKind = e36.kind; - const args144: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e36, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e36, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3351), (f: rt.Formatter) => rt.i32Display(kind37, f), (f: rt.Formatter) => rt.fmtBool(over36, f)]; - put(out, rt.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); + const _3351: rs.IntErrorKind = e36.kind; + const args144: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e36, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e36, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3351), (f: rs.Formatter) => rs.i32Display(kind37, f), (f: rs.Formatter) => rs.fmtBool(over36, f)]; + put(out, rs.fmtFormat([args144[0], "|", args144[1], "|", args144[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args144[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args144[0]), "|", args144[3], "|", args144[4]])); } if (radix63 === 10) { - const parsed36: rt.Result = parse$072345g(_3310); - const from36: rt.Result = num_fromStr$0lmxi6o(_3310); + const parsed36: rs.Result = parse$14v13am(_3310); + const from36: rs.Result = num_fromStr$1ckv470(_3310); if (from36.ok) { - max36 = rt.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); + max36 = rs.u8Mul(from36.value === 2147483647 ? 1 : 0, 4); } else { max36 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed36.ok ? 1 : 0, max36)); + rs.byteVecPush(out, rs.u8Add(parsed36.ok ? 1 : 0, max36)); } } } } else if (_4 === 9) { if (dataLen !== 0) { - const first10: rt.u8 = dataData[dataStart]; - const rest10: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix64: rt.u32 = rt.u32Add(2, rt.u32Rem(first10 as rt.u32, 35)); - const _3389: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first10: rs.u8 = dataData[dataStart]; + const rest10: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix64: rs.u32 = rs.u32Add(2, rs.u32Rem(first10 as rs.u32, 35)); + const _3389: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_3389 === 0) { - const _3393: rt.Result = rt.strFromUtf8(rest10); + const _3393: rs.Result = rs.strFromUtf8(rest10); if (_3393.ok) { - const iter37: rt.Iter = rt.strChars(_3393.value); + const iter37: rs.Iter = rs.strChars(_3393.value); while (true) { - const _3399: rt.char | rt.Done = iter37.next(); - if (_3399 === rt.DONE) { + const _3399: rs.char | rs.Done = iter37.next(); + if (_3399 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3399, radix64), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3399, radix64), 99)))); } - const radix65: rt.u32 = radix64; - const _3414: rt.Result = num_fromStrRadix$11y6fsf(_3393.value, radix65); + const radix65: rs.u32 = radix64; + const _3414: rs.Result = num_fromStrRadix$04fc4zz(_3393.value, radix65); if (_3414.ok) { const arg12 = _3414.value; - const args146: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg12, f)]; - put(out, rt.fmtFormat([args146[0]])); + const args146: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg12, f)]; + put(out, rs.fmtFormat([args146[0]])); } else { - const e37: rt.ParseIntError = _3414.error; - const _3430: rt.IntErrorKind = e37.kind; + const e37: rs.ParseIntError = _3414.error; + const _3430: rs.IntErrorKind = e37.kind; if (_3430 === "Empty") { kind38 = 0; } else if (_3430 === "InvalidDigit") { @@ -4970,44 +4970,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind38 = 4; } - if (!(e37.kind === "PosOverflow" as rt.IntErrorKind)) { - over37 = e37.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e37.kind === "PosOverflow" as rs.IntErrorKind)) { + over37 = e37.kind !== "NegOverflow" as rs.IntErrorKind; } else { over37 = true; } - const _3450: rt.IntErrorKind = e37.kind; - const args148: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e37, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e37, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3450), (f: rt.Formatter) => rt.i32Display(kind38, f), (f: rt.Formatter) => rt.fmtBool(over37, f)]; - put(out, rt.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); + const _3450: rs.IntErrorKind = e37.kind; + const args148: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3450), (f: rs.Formatter) => rs.i32Display(kind38, f), (f: rs.Formatter) => rs.fmtBool(over37, f)]; + put(out, rs.fmtFormat([args148[0], "|", args148[1], "|", args148[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args148[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args148[0]), "|", args148[3], "|", args148[4]])); } if (radix65 === 10) { - const parsed37: rt.Result = parse$11m1f1e(_3393.value); - const from37: rt.Result = num_fromStr$116mp4t(_3393.value); + const parsed37: rs.Result = parse$0px1msj(_3393.value); + const from37: rs.Result = num_fromStr$00n8jbp(_3393.value); if (from37.ok) { - max37 = rt.u8Mul(rt.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); + max37 = rs.u8Mul(rs.i64Eq(from37.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { max37 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed37.ok ? 1 : 0, max37)); + rs.byteVecPush(out, rs.u8Add(parsed37.ok ? 1 : 0, max37)); } } } else if (_3389 === 1) { let s19: string = ""; - for (const b10 of rt.byteSliceView(rest10)) { - const _3490: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3491: rt.usize = rt.usizeRem(b10 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_3490, _3491); - s19 = s19 + String.fromCodePoint(_3490.data[_3490.start + _3491] as rt.char); + for (const b10 of rs.byteSliceView(rest10)) { + const _3490: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3491: rs.usize = rs.usizeRem(b10 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3490, _3491); + s19 = s19 + String.fromCodePoint(_3490.data[_3490.start + _3491] as rs.char); } const _3502: string = s19; - const radix66: rt.u32 = radix64; - const _3505: rt.Result = num_fromStrRadix$11y6fsf(_3502, radix66); + const radix66: rs.u32 = radix64; + const _3505: rs.Result = num_fromStrRadix$04fc4zz(_3502, radix66); if (_3505.ok) { const arg11 = _3505.value; - const args150: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg11, f)]; - put(out, rt.fmtFormat([args150[0]])); + const args150: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg11, f)]; + put(out, rs.fmtFormat([args150[0]])); } else { - const e38: rt.ParseIntError = _3505.error; - const _3521: rt.IntErrorKind = e38.kind; + const e38: rs.ParseIntError = _3505.error; + const _3521: rs.IntErrorKind = e38.kind; if (_3521 === "Empty") { kind39 = 0; } else if (_3521 === "InvalidDigit") { @@ -5019,44 +5019,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind39 = 4; } - if (!(e38.kind === "PosOverflow" as rt.IntErrorKind)) { - over38 = e38.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e38.kind === "PosOverflow" as rs.IntErrorKind)) { + over38 = e38.kind !== "NegOverflow" as rs.IntErrorKind; } else { over38 = true; } - const _3541: rt.IntErrorKind = e38.kind; - const args152: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e38, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e38, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3541), (f: rt.Formatter) => rt.i32Display(kind39, f), (f: rt.Formatter) => rt.fmtBool(over38, f)]; - put(out, rt.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); + const _3541: rs.IntErrorKind = e38.kind; + const args152: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e38, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3541), (f: rs.Formatter) => rs.i32Display(kind39, f), (f: rs.Formatter) => rs.fmtBool(over38, f)]; + put(out, rs.fmtFormat([args152[0], "|", args152[1], "|", args152[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args152[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args152[0]), "|", args152[3], "|", args152[4]])); } if (radix66 === 10) { - const parsed38: rt.Result = parse$11m1f1e(_3502); - const from38: rt.Result = num_fromStr$116mp4t(_3502); + const parsed38: rs.Result = parse$0px1msj(_3502); + const from38: rs.Result = num_fromStr$00n8jbp(_3502); if (from38.ok) { - max38 = rt.u8Mul(rt.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); + max38 = rs.u8Mul(rs.i64Eq(from38.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { max38 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed38.ok ? 1 : 0, max38)); + rs.byteVecPush(out, rs.u8Add(parsed38.ok ? 1 : 0, max38)); } } else { if (_3389 === 2) { - const iter39: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter39: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _3573: rt.u32 | rt.Done = iter39.next(); - if (_3573 === rt.DONE) { + const _3573: rs.u32 | rs.Done = iter39.next(); + if (_3573 === rs.DONE) { break b0; } - const radix67: rt.u32 = _3573; - for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rt.u128, 1), 64, radix67).items) { - const radix68: rt.u32 = radix67; - const _3595: rt.Result = num_fromStrRadix$11y6fsf(_3584, radix68); + const radix67: rs.u32 = _3573; + for (const _3584 of edges({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0, w2: 0, w1: 0x7fffffff, lo: 0xffffffff } as rs.u128, 1), 64, radix67).items) { + const radix68: rs.u32 = radix67; + const _3595: rs.Result = num_fromStrRadix$04fc4zz(_3584, radix68); if (_3595.ok) { const arg10 = _3595.value; - const args154: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg10, f)]; - put(out, rt.fmtFormat([args154[0]])); + const args154: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg10, f)]; + put(out, rs.fmtFormat([args154[0]])); } else { - const e39: rt.ParseIntError = _3595.error; - const _3611: rt.IntErrorKind = e39.kind; + const e39: rs.ParseIntError = _3595.error; + const _3611: rs.IntErrorKind = e39.kind; if (_3611 === "Empty") { kind40 = 0; } else if (_3611 === "InvalidDigit") { @@ -5068,49 +5068,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind40 = 4; } - if (!(e39.kind === "PosOverflow" as rt.IntErrorKind)) { - over39 = e39.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e39.kind === "PosOverflow" as rs.IntErrorKind)) { + over39 = e39.kind !== "NegOverflow" as rs.IntErrorKind; } else { over39 = true; } - const _3631: rt.IntErrorKind = e39.kind; - const args156: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e39, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e39, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3631), (f: rt.Formatter) => rt.i32Display(kind40, f), (f: rt.Formatter) => rt.fmtBool(over39, f)]; - put(out, rt.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); + const _3631: rs.IntErrorKind = e39.kind; + const args156: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e39, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e39, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3631), (f: rs.Formatter) => rs.i32Display(kind40, f), (f: rs.Formatter) => rs.fmtBool(over39, f)]; + put(out, rs.fmtFormat([args156[0], "|", args156[1], "|", args156[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args156[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args156[0]), "|", args156[3], "|", args156[4]])); } if (radix68 === 10) { - const parsed39: rt.Result = parse$11m1f1e(_3584); - const from39: rt.Result = num_fromStr$116mp4t(_3584); + const parsed39: rs.Result = parse$0px1msj(_3584); + const from39: rs.Result = num_fromStr$00n8jbp(_3584); if (from39.ok) { - max39 = rt.u8Mul(rt.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); + max39 = rs.u8Mul(rs.i64Eq(from39.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { max39 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed39.ok ? 1 : 0, max39)); + rs.byteVecPush(out, rs.u8Add(parsed39.ok ? 1 : 0, max39)); } } } } - const radix69: rt.u32 = ((first10 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest10), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest10, 1), (b15: rt.u8): boolean => { + const radix69: rs.u32 = ((first10 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest10), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest10, 1), (b15: rs.u8): boolean => { return (b15 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix69), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix69), 99)))); } if (!(rest10.length > 2)) { - text10 = rt.byteSliceFrom(Uint8Array.of()); + text10 = rs.byteSliceFrom(Uint8Array.of()); } else { - text10 = rt.byteSliceRange(rest10, 2); + text10 = rs.byteSliceRange(rest10, 2); } - const _3687: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text10), "1"); - const radix70: rt.u32 = radix69; - const _3692: rt.Result = num_fromStrRadix$11y6fsf(_3687, radix70); + const _3687: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text10), "1"); + const radix70: rs.u32 = radix69; + const _3692: rs.Result = num_fromStrRadix$04fc4zz(_3687, radix70); if (_3692.ok) { const arg9 = _3692.value; - const args158: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg9, f)]; - put(out, rt.fmtFormat([args158[0]])); + const args158: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg9, f)]; + put(out, rs.fmtFormat([args158[0]])); } else { - const e40: rt.ParseIntError = _3692.error; - const _3708: rt.IntErrorKind = e40.kind; + const e40: rs.ParseIntError = _3692.error; + const _3708: rs.IntErrorKind = e40.kind; if (_3708 === "Empty") { kind41 = 0; } else if (_3708 === "InvalidDigit") { @@ -5122,53 +5122,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind41 = 4; } - if (!(e40.kind === "PosOverflow" as rt.IntErrorKind)) { - over40 = e40.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e40.kind === "PosOverflow" as rs.IntErrorKind)) { + over40 = e40.kind !== "NegOverflow" as rs.IntErrorKind; } else { over40 = true; } - const _3728: rt.IntErrorKind = e40.kind; - const args160: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e40, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e40, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3728), (f: rt.Formatter) => rt.i32Display(kind41, f), (f: rt.Formatter) => rt.fmtBool(over40, f)]; - put(out, rt.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); + const _3728: rs.IntErrorKind = e40.kind; + const args160: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e40, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e40, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3728), (f: rs.Formatter) => rs.i32Display(kind41, f), (f: rs.Formatter) => rs.fmtBool(over40, f)]; + put(out, rs.fmtFormat([args160[0], "|", args160[1], "|", args160[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args160[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args160[0]), "|", args160[3], "|", args160[4]])); } if (radix70 === 10) { - const parsed40: rt.Result = parse$11m1f1e(_3687); - const from40: rt.Result = num_fromStr$116mp4t(_3687); + const parsed40: rs.Result = parse$0px1msj(_3687); + const from40: rs.Result = num_fromStr$00n8jbp(_3687); if (from40.ok) { - max40 = rt.u8Mul(rt.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64) ? 1 : 0, 4); + max40 = rs.u8Mul(rs.i64Eq(from40.value, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64) ? 1 : 0, 4); } else { max40 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed40.ok ? 1 : 0, max40)); + rs.byteVecPush(out, rs.u8Add(parsed40.ok ? 1 : 0, max40)); } } } } else if (_4 === 10) { if (dataLen !== 0) { - const first11: rt.u8 = dataData[dataStart]; - const rest11: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix71: rt.u32 = rt.u32Add(2, rt.u32Rem(first11 as rt.u32, 35)); - const _3766: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first11: rs.u8 = dataData[dataStart]; + const rest11: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix71: rs.u32 = rs.u32Add(2, rs.u32Rem(first11 as rs.u32, 35)); + const _3766: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_3766 === 0) { - const _3770: rt.Result = rt.strFromUtf8(rest11); + const _3770: rs.Result = rs.strFromUtf8(rest11); if (_3770.ok) { - const iter41: rt.Iter = rt.strChars(_3770.value); + const iter41: rs.Iter = rs.strChars(_3770.value); while (true) { - const _3776: rt.char | rt.Done = iter41.next(); - if (_3776 === rt.DONE) { + const _3776: rs.char | rs.Done = iter41.next(); + if (_3776 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_3776, radix71), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_3776, radix71), 99)))); } - const radix72: rt.u32 = radix71; - const _3791: rt.Result = num_fromStrRadix$0366bau(_3770.value, radix72); + const radix72: rs.u32 = radix71; + const _3791: rs.Result = num_fromStrRadix$0cysu2u(_3770.value, radix72); if (_3791.ok) { const arg8 = _3791.value; - const args162: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg8, f)]; - put(out, rt.fmtFormat([args162[0]])); + const args162: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg8, f)]; + put(out, rs.fmtFormat([args162[0]])); } else { - const e41: rt.ParseIntError = _3791.error; - const _3807: rt.IntErrorKind = e41.kind; + const e41: rs.ParseIntError = _3791.error; + const _3807: rs.IntErrorKind = e41.kind; if (_3807 === "Empty") { kind42 = 0; } else if (_3807 === "InvalidDigit") { @@ -5180,44 +5180,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind42 = 4; } - if (!(e41.kind === "PosOverflow" as rt.IntErrorKind)) { - over41 = e41.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e41.kind === "PosOverflow" as rs.IntErrorKind)) { + over41 = e41.kind !== "NegOverflow" as rs.IntErrorKind; } else { over41 = true; } - const _3827: rt.IntErrorKind = e41.kind; - const args164: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e41, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e41, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3827), (f: rt.Formatter) => rt.i32Display(kind42, f), (f: rt.Formatter) => rt.fmtBool(over41, f)]; - put(out, rt.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); + const _3827: rs.IntErrorKind = e41.kind; + const args164: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e41, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e41, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3827), (f: rs.Formatter) => rs.i32Display(kind42, f), (f: rs.Formatter) => rs.fmtBool(over41, f)]; + put(out, rs.fmtFormat([args164[0], "|", args164[1], "|", args164[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args164[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args164[0]), "|", args164[3], "|", args164[4]])); } if (radix72 === 10) { - const parsed41: rt.Result = parse$082ztwj(_3770.value); - const from41: rt.Result = num_fromStr$0zyj6he(_3770.value); + const parsed41: rs.Result = parse$1kyj9pm(_3770.value); + const from41: rs.Result = num_fromStr$1el0yvy(_3770.value); if (from41.ok) { - max41 = rt.u8Mul(rt.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); + max41 = rs.u8Mul(rs.i128Eq(from41.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { max41 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed41.ok ? 1 : 0, max41)); + rs.byteVecPush(out, rs.u8Add(parsed41.ok ? 1 : 0, max41)); } } } else if (_3766 === 1) { let s21: string = ""; - for (const b11 of rt.byteSliceView(rest11)) { - const _3867: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _3868: rt.usize = rt.usizeRem(b11 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_3867, _3868); - s21 = s21 + String.fromCodePoint(_3867.data[_3867.start + _3868] as rt.char); + for (const b11 of rs.byteSliceView(rest11)) { + const _3867: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _3868: rs.usize = rs.usizeRem(b11 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_3867, _3868); + s21 = s21 + String.fromCodePoint(_3867.data[_3867.start + _3868] as rs.char); } const _3879: string = s21; - const radix73: rt.u32 = radix71; - const _3882: rt.Result = num_fromStrRadix$0366bau(_3879, radix73); + const radix73: rs.u32 = radix71; + const _3882: rs.Result = num_fromStrRadix$0cysu2u(_3879, radix73); if (_3882.ok) { const arg7 = _3882.value; - const args166: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg7, f)]; - put(out, rt.fmtFormat([args166[0]])); + const args166: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg7, f)]; + put(out, rs.fmtFormat([args166[0]])); } else { - const e42: rt.ParseIntError = _3882.error; - const _3898: rt.IntErrorKind = e42.kind; + const e42: rs.ParseIntError = _3882.error; + const _3898: rs.IntErrorKind = e42.kind; if (_3898 === "Empty") { kind43 = 0; } else if (_3898 === "InvalidDigit") { @@ -5229,44 +5229,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind43 = 4; } - if (!(e42.kind === "PosOverflow" as rt.IntErrorKind)) { - over42 = e42.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e42.kind === "PosOverflow" as rs.IntErrorKind)) { + over42 = e42.kind !== "NegOverflow" as rs.IntErrorKind; } else { over42 = true; } - const _3918: rt.IntErrorKind = e42.kind; - const args168: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e42, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e42, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _3918), (f: rt.Formatter) => rt.i32Display(kind43, f), (f: rt.Formatter) => rt.fmtBool(over42, f)]; - put(out, rt.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); + const _3918: rs.IntErrorKind = e42.kind; + const args168: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e42, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e42, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _3918), (f: rs.Formatter) => rs.i32Display(kind43, f), (f: rs.Formatter) => rs.fmtBool(over42, f)]; + put(out, rs.fmtFormat([args168[0], "|", args168[1], "|", args168[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args168[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args168[0]), "|", args168[3], "|", args168[4]])); } if (radix73 === 10) { - const parsed42: rt.Result = parse$082ztwj(_3879); - const from42: rt.Result = num_fromStr$0zyj6he(_3879); + const parsed42: rs.Result = parse$1kyj9pm(_3879); + const from42: rs.Result = num_fromStr$1el0yvy(_3879); if (from42.ok) { - max42 = rt.u8Mul(rt.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); + max42 = rs.u8Mul(rs.i128Eq(from42.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { max42 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed42.ok ? 1 : 0, max42)); + rs.byteVecPush(out, rs.u8Add(parsed42.ok ? 1 : 0, max42)); } } else { if (_3766 === 2) { - const iter43: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter43: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _3950: rt.u32 | rt.Done = iter43.next(); - if (_3950 === rt.DONE) { + const _3950: rs.u32 | rs.Done = iter43.next(); + if (_3950 === rs.DONE) { break b0; } - const radix74: rt.u32 = _3950; - for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, rt.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 1), 128, radix74).items) { - const radix75: rt.u32 = radix74; - const _3972: rt.Result = num_fromStrRadix$0366bau(_3961, radix75); + const radix74: rs.u32 = _3950; + for (const _3961 of edges({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, rs.u128Add({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), 128, radix74).items) { + const radix75: rs.u32 = radix74; + const _3972: rs.Result = num_fromStrRadix$0cysu2u(_3961, radix75); if (_3972.ok) { const arg6 = _3972.value; - const args170: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg6, f)]; - put(out, rt.fmtFormat([args170[0]])); + const args170: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg6, f)]; + put(out, rs.fmtFormat([args170[0]])); } else { - const e43: rt.ParseIntError = _3972.error; - const _3988: rt.IntErrorKind = e43.kind; + const e43: rs.ParseIntError = _3972.error; + const _3988: rs.IntErrorKind = e43.kind; if (_3988 === "Empty") { kind44 = 0; } else if (_3988 === "InvalidDigit") { @@ -5278,49 +5278,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind44 = 4; } - if (!(e43.kind === "PosOverflow" as rt.IntErrorKind)) { - over43 = e43.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e43.kind === "PosOverflow" as rs.IntErrorKind)) { + over43 = e43.kind !== "NegOverflow" as rs.IntErrorKind; } else { over43 = true; } - const _4008: rt.IntErrorKind = e43.kind; - const args172: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e43, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e43, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4008), (f: rt.Formatter) => rt.i32Display(kind44, f), (f: rt.Formatter) => rt.fmtBool(over43, f)]; - put(out, rt.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); + const _4008: rs.IntErrorKind = e43.kind; + const args172: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e43, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e43, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4008), (f: rs.Formatter) => rs.i32Display(kind44, f), (f: rs.Formatter) => rs.fmtBool(over43, f)]; + put(out, rs.fmtFormat([args172[0], "|", args172[1], "|", args172[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args172[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args172[0]), "|", args172[3], "|", args172[4]])); } if (radix75 === 10) { - const parsed43: rt.Result = parse$082ztwj(_3961); - const from43: rt.Result = num_fromStr$0zyj6he(_3961); + const parsed43: rs.Result = parse$1kyj9pm(_3961); + const from43: rs.Result = num_fromStr$1el0yvy(_3961); if (from43.ok) { - max43 = rt.u8Mul(rt.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); + max43 = rs.u8Mul(rs.i128Eq(from43.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { max43 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed43.ok ? 1 : 0, max43)); + rs.byteVecPush(out, rs.u8Add(parsed43.ok ? 1 : 0, max43)); } } } } - const radix76: rt.u32 = ((first11 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest11), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest11, 1), (b14: rt.u8): boolean => { + const radix76: rs.u32 = ((first11 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest11), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest11, 1), (b14: rs.u8): boolean => { return (b14 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix76), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix76), 99)))); } if (!(rest11.length > 2)) { - text11 = rt.byteSliceFrom(Uint8Array.of()); + text11 = rs.byteSliceFrom(Uint8Array.of()); } else { - text11 = rt.byteSliceRange(rest11, 2); + text11 = rs.byteSliceRange(rest11, 2); } - const _4064: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text11), "1"); - const radix77: rt.u32 = radix76; - const _4069: rt.Result = num_fromStrRadix$0366bau(_4064, radix77); + const _4064: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text11), "1"); + const radix77: rs.u32 = radix76; + const _4069: rs.Result = num_fromStrRadix$0cysu2u(_4064, radix77); if (_4069.ok) { const arg5 = _4069.value; - const args174: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg5, f)]; - put(out, rt.fmtFormat([args174[0]])); + const args174: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg5, f)]; + put(out, rs.fmtFormat([args174[0]])); } else { - const e44: rt.ParseIntError = _4069.error; - const _4085: rt.IntErrorKind = e44.kind; + const e44: rs.ParseIntError = _4069.error; + const _4085: rs.IntErrorKind = e44.kind; if (_4085 === "Empty") { kind45 = 0; } else if (_4085 === "InvalidDigit") { @@ -5332,53 +5332,53 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind45 = 4; } - if (!(e44.kind === "PosOverflow" as rt.IntErrorKind)) { - over44 = e44.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e44.kind === "PosOverflow" as rs.IntErrorKind)) { + over44 = e44.kind !== "NegOverflow" as rs.IntErrorKind; } else { over44 = true; } - const _4105: rt.IntErrorKind = e44.kind; - const args176: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e44, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e44, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4105), (f: rt.Formatter) => rt.i32Display(kind45, f), (f: rt.Formatter) => rt.fmtBool(over44, f)]; - put(out, rt.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); + const _4105: rs.IntErrorKind = e44.kind; + const args176: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e44, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e44, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4105), (f: rs.Formatter) => rs.i32Display(kind45, f), (f: rs.Formatter) => rs.fmtBool(over44, f)]; + put(out, rs.fmtFormat([args176[0], "|", args176[1], "|", args176[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args176[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args176[0]), "|", args176[3], "|", args176[4]])); } if (radix77 === 10) { - const parsed44: rt.Result = parse$082ztwj(_4064); - const from44: rt.Result = num_fromStr$0zyj6he(_4064); + const parsed44: rs.Result = parse$1kyj9pm(_4064); + const from44: rs.Result = num_fromStr$1el0yvy(_4064); if (from44.ok) { - max44 = rt.u8Mul(rt.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128) ? 1 : 0, 4); + max44 = rs.u8Mul(rs.i128Eq(from44.value, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128) ? 1 : 0, 4); } else { max44 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed44.ok ? 1 : 0, max44)); + rs.byteVecPush(out, rs.u8Add(parsed44.ok ? 1 : 0, max44)); } } } } else if (_4 === 11) { if (dataLen !== 0) { - const first12: rt.u8 = dataData[dataStart]; - const rest12: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const radix78: rt.u32 = rt.u32Add(2, rt.u32Rem(first12 as rt.u32, 35)); - const _4143: rt.u8 = rt.u8Rem(rt.u8Div(kind, 12), 4); + const first12: rs.u8 = dataData[dataStart]; + const rest12: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const radix78: rs.u32 = rs.u32Add(2, rs.u32Rem(first12 as rs.u32, 35)); + const _4143: rs.u8 = rs.u8Rem(rs.u8Div(kind, 12), 4); if (_4143 === 0) { - const _4147: rt.Result = rt.strFromUtf8(rest12); + const _4147: rs.Result = rs.strFromUtf8(rest12); if (_4147.ok) { - const iter45: rt.Iter = rt.strChars(_4147.value); + const iter45: rs.Iter = rs.strChars(_4147.value); while (true) { - const _4153: rt.char | rt.Done = iter45.next(); - if (_4153 === rt.DONE) { + const _4153: rs.char | rs.Done = iter45.next(); + if (_4153 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(_4153, radix78), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(_4153, radix78), 99)))); } - const radix79: rt.u32 = radix78; - const _4168: rt.Result = num_fromStrRadix$16jk9zm(_4147.value, radix79); + const radix79: rs.u32 = radix78; + const _4168: rs.Result = num_fromStrRadix$1nys6eo(_4147.value, radix79); if (_4168.ok) { const arg4 = _4168.value; - const args178: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg4, f)]; - put(out, rt.fmtFormat([args178[0]])); + const args178: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg4, f)]; + put(out, rs.fmtFormat([args178[0]])); } else { - const e45: rt.ParseIntError = _4168.error; - const _4184: rt.IntErrorKind = e45.kind; + const e45: rs.ParseIntError = _4168.error; + const _4184: rs.IntErrorKind = e45.kind; if (_4184 === "Empty") { kind46 = 0; } else if (_4184 === "InvalidDigit") { @@ -5390,44 +5390,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind46 = 4; } - if (!(e45.kind === "PosOverflow" as rt.IntErrorKind)) { - over45 = e45.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e45.kind === "PosOverflow" as rs.IntErrorKind)) { + over45 = e45.kind !== "NegOverflow" as rs.IntErrorKind; } else { over45 = true; } - const _4204: rt.IntErrorKind = e45.kind; - const args180: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e45, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e45, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4204), (f: rt.Formatter) => rt.i32Display(kind46, f), (f: rt.Formatter) => rt.fmtBool(over45, f)]; - put(out, rt.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); + const _4204: rs.IntErrorKind = e45.kind; + const args180: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e45, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e45, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4204), (f: rs.Formatter) => rs.i32Display(kind46, f), (f: rs.Formatter) => rs.fmtBool(over45, f)]; + put(out, rs.fmtFormat([args180[0], "|", args180[1], "|", args180[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args180[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args180[0]), "|", args180[3], "|", args180[4]])); } if (radix79 === 10) { - const parsed45: rt.Result = parse$0uguq9k(_4147.value); - const from45: rt.Result = num_fromStr$1v63ugw(_4147.value); + const parsed45: rs.Result = parse$1g90yxu(_4147.value); + const from45: rs.Result = num_fromStr$0ytcpik(_4147.value); if (from45.ok) { - max45 = rt.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); + max45 = rs.u8Mul(from45.value === 2147483647 ? 1 : 0, 4); } else { max45 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed45.ok ? 1 : 0, max45)); + rs.byteVecPush(out, rs.u8Add(parsed45.ok ? 1 : 0, max45)); } } } else if (_4143 === 1) { let s23: string = ""; - for (const b12 of rt.byteSliceView(rest12)) { - const _4244: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); - const _4245: rt.usize = rt.usizeRem(b12 as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); - rt.idx(_4244, _4245); - s23 = s23 + String.fromCodePoint(_4244.data[_4244.start + _4245] as rt.char); + for (const b12 of rs.byteSliceView(rest12)) { + const _4244: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)); + const _4245: rs.usize = rs.usizeRem(b12 as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 97, 122, 65, 90, 95, 32, 48, 49, 56, 57, 102, 70)).length); + rs.idx(_4244, _4245); + s23 = s23 + String.fromCodePoint(_4244.data[_4244.start + _4245] as rs.char); } const _4256: string = s23; - const radix80: rt.u32 = radix78; - const _4259: rt.Result = num_fromStrRadix$16jk9zm(_4256, radix80); + const radix80: rs.u32 = radix78; + const _4259: rs.Result = num_fromStrRadix$1nys6eo(_4256, radix80); if (_4259.ok) { const arg3 = _4259.value; - const args182: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg3, f)]; - put(out, rt.fmtFormat([args182[0]])); + const args182: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg3, f)]; + put(out, rs.fmtFormat([args182[0]])); } else { - const e46: rt.ParseIntError = _4259.error; - const _4275: rt.IntErrorKind = e46.kind; + const e46: rs.ParseIntError = _4259.error; + const _4275: rs.IntErrorKind = e46.kind; if (_4275 === "Empty") { kind47 = 0; } else if (_4275 === "InvalidDigit") { @@ -5439,44 +5439,44 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind47 = 4; } - if (!(e46.kind === "PosOverflow" as rt.IntErrorKind)) { - over46 = e46.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e46.kind === "PosOverflow" as rs.IntErrorKind)) { + over46 = e46.kind !== "NegOverflow" as rs.IntErrorKind; } else { over46 = true; } - const _4295: rt.IntErrorKind = e46.kind; - const args184: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e46, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e46, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4295), (f: rt.Formatter) => rt.i32Display(kind47, f), (f: rt.Formatter) => rt.fmtBool(over46, f)]; - put(out, rt.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); + const _4295: rs.IntErrorKind = e46.kind; + const args184: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e46, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e46, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4295), (f: rs.Formatter) => rs.i32Display(kind47, f), (f: rs.Formatter) => rs.fmtBool(over46, f)]; + put(out, rs.fmtFormat([args184[0], "|", args184[1], "|", args184[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args184[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args184[0]), "|", args184[3], "|", args184[4]])); } if (radix80 === 10) { - const parsed46: rt.Result = parse$0uguq9k(_4256); - const from46: rt.Result = num_fromStr$1v63ugw(_4256); + const parsed46: rs.Result = parse$1g90yxu(_4256); + const from46: rs.Result = num_fromStr$0ytcpik(_4256); if (from46.ok) { - max46 = rt.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); + max46 = rs.u8Mul(from46.value === 2147483647 ? 1 : 0, 4); } else { max46 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed46.ok ? 1 : 0, max46)); + rs.byteVecPush(out, rs.u8Add(parsed46.ok ? 1 : 0, max46)); } } else { if (_4143 === 2) { - const iter47: rt.RangeInclusive = new rt.RangeInclusive(2, 36, rt.u32Step); + const iter47: rs.RangeInclusive = new rs.RangeInclusive(2, 36, rs.u32Step); while (true) { - const _4327: rt.u32 | rt.Done = iter47.next(); - if (_4327 === rt.DONE) { + const _4327: rs.u32 | rs.Done = iter47.next(); + if (_4327 === rs.DONE) { break b0; } - const radix81: rt.u32 = _4327; - for (const _4338 of edges(2147483647, rt.u128Add(2147483647, 1), 32, radix81).items) { - const radix82: rt.u32 = radix81; - const _4349: rt.Result = num_fromStrRadix$16jk9zm(_4338, radix82); + const radix81: rs.u32 = _4327; + for (const _4338 of edges(2147483647, rs.u128Add(2147483647, 1), 32, radix81).items) { + const radix82: rs.u32 = radix81; + const _4349: rs.Result = num_fromStrRadix$1nys6eo(_4338, radix82); if (_4349.ok) { const arg2 = _4349.value; - const args186: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; - put(out, rt.fmtFormat([args186[0]])); + const args186: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; + put(out, rs.fmtFormat([args186[0]])); } else { - const e47: rt.ParseIntError = _4349.error; - const _4365: rt.IntErrorKind = e47.kind; + const e47: rs.ParseIntError = _4349.error; + const _4365: rs.IntErrorKind = e47.kind; if (_4365 === "Empty") { kind48 = 0; } else if (_4365 === "InvalidDigit") { @@ -5488,49 +5488,49 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind48 = 4; } - if (!(e47.kind === "PosOverflow" as rt.IntErrorKind)) { - over47 = e47.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e47.kind === "PosOverflow" as rs.IntErrorKind)) { + over47 = e47.kind !== "NegOverflow" as rs.IntErrorKind; } else { over47 = true; } - const _4385: rt.IntErrorKind = e47.kind; - const args188: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e47, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e47, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4385), (f: rt.Formatter) => rt.i32Display(kind48, f), (f: rt.Formatter) => rt.fmtBool(over47, f)]; - put(out, rt.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); + const _4385: rs.IntErrorKind = e47.kind; + const args188: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e47, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e47, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4385), (f: rs.Formatter) => rs.i32Display(kind48, f), (f: rs.Formatter) => rs.fmtBool(over47, f)]; + put(out, rs.fmtFormat([args188[0], "|", args188[1], "|", args188[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args188[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args188[0]), "|", args188[3], "|", args188[4]])); } if (radix82 === 10) { - const parsed47: rt.Result = parse$0uguq9k(_4338); - const from47: rt.Result = num_fromStr$1v63ugw(_4338); + const parsed47: rs.Result = parse$1g90yxu(_4338); + const from47: rs.Result = num_fromStr$0ytcpik(_4338); if (from47.ok) { - max47 = rt.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); + max47 = rs.u8Mul(from47.value === 2147483647 ? 1 : 0, 4); } else { max47 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed47.ok ? 1 : 0, max47)); + rs.byteVecPush(out, rs.u8Add(parsed47.ok ? 1 : 0, max47)); } } } } - const radix83: rt.u32 = ((first12 as rt.u32) | (((option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest12), 0) as rt.u32) << 24) >>> 0)) >>> 0; - if (isSomeAnd$09tpccf(rt.byteSliceGet(rest12, 1), (b13: rt.u8): boolean => { + const radix83: rs.u32 = ((first12 as rs.u32) | (((option_unwrapOr$1fr498u(rs.byteSliceFirst(rest12), 0) as rs.u32) << 24) >>> 0)) >>> 0; + if (isSomeAnd$1s2u5lz(rs.byteSliceGet(rest12, 1), (b13: rs.u8): boolean => { return (b13 & 1) === 1; })) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(toDigit$01k9ewn(55, radix83), 99)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(toDigit$14z95r4(55, radix83), 99)))); } if (!(rest12.length > 2)) { - text12 = rt.byteSliceFrom(Uint8Array.of()); + text12 = rs.byteSliceFrom(Uint8Array.of()); } else { - text12 = rt.byteSliceRange(rest12, 2); + text12 = rs.byteSliceRange(rest12, 2); } - const _4441: string = result_unwrapOr$01jdcm7(rt.strFromUtf8(text12), "1"); - const radix84: rt.u32 = radix83; - const _4446: rt.Result = num_fromStrRadix$16jk9zm(_4441, radix84); + const _4441: string = result_unwrapOr$0a3q6xs(rs.strFromUtf8(text12), "1"); + const radix84: rs.u32 = radix83; + const _4446: rs.Result = num_fromStrRadix$1nys6eo(_4441, radix84); if (_4446.ok) { const arg = _4446.value; - const args190: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg, f)]; - put(out, rt.fmtFormat([args190[0]])); + const args190: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg, f)]; + put(out, rs.fmtFormat([args190[0]])); } else { - const e48: rt.ParseIntError = _4446.error; - const _4462: rt.IntErrorKind = e48.kind; + const e48: rs.ParseIntError = _4446.error; + const _4462: rs.IntErrorKind = e48.kind; if (_4462 === "Empty") { kind49 = 0; } else if (_4462 === "InvalidDigit") { @@ -5542,29 +5542,29 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } else { kind49 = 4; } - if (!(e48.kind === "PosOverflow" as rt.IntErrorKind)) { - over48 = e48.kind !== "NegOverflow" as rt.IntErrorKind; + if (!(e48.kind === "PosOverflow" as rs.IntErrorKind)) { + over48 = e48.kind !== "NegOverflow" as rs.IntErrorKind; } else { over48 = true; } - const _4482: rt.IntErrorKind = e48.kind; - const args192: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e48, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e48, f), (f: rt.Formatter) => rt.fmtWriteStr(f, _4482), (f: rt.Formatter) => rt.i32Display(kind49, f), (f: rt.Formatter) => rt.fmtBool(over48, f)]; - put(out, rt.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rt.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); + const _4482: rs.IntErrorKind = e48.kind; + const args192: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e48, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e48, f), (f: rs.Formatter) => rs.fmtWriteStr(f, _4482), (f: rs.Formatter) => rs.i32Display(kind49, f), (f: rs.Formatter) => rs.fmtBool(over48, f)]; + put(out, rs.fmtFormat([args192[0], "|", args192[1], "|", args192[2], "|", rs.fmtSpec({ align: ">", width: 42 }, args192[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args192[0]), "|", args192[3], "|", args192[4]])); } if (radix84 === 10) { - const parsed48: rt.Result = parse$0uguq9k(_4441); - const from48: rt.Result = num_fromStr$1v63ugw(_4441); + const parsed48: rs.Result = parse$1g90yxu(_4441); + const from48: rs.Result = num_fromStr$0ytcpik(_4441); if (from48.ok) { - max48 = rt.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); + max48 = rs.u8Mul(from48.value === 2147483647 ? 1 : 0, 4); } else { max48 = 2; } - rt.byteVecPush(out, rt.u8Add(parsed48.ok ? 1 : 0, max48)); + rs.byteVecPush(out, rs.u8Add(parsed48.ok ? 1 : 0, max48)); } } } } else { - rt.panic("internal error: entered unreachable code"); + rs.panic("internal error: entered unreachable code"); } } } @@ -5574,414 +5574,414 @@ export function parses(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * itself, wider, and to `usize` and `isize` where std has `From`; and a `char`'s and the * crate's own, which convert the same way. */ -export function widenings(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 13); +export function widenings(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 13); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const iter: rt.Iter = rt.iterSlice(Uint8Array.of(([rt.u8FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u8, rt.ByteSlice])[0], 0, 255)); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const iter: rs.Iter = rs.iterSlice(Uint8Array.of(([rs.u8FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.u8, rs.ByteSlice])[0], 0, 255)); while (true) { - const _27: rt.u8 | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _27: rs.u8 | rs.Done = iter.next(); + if (_27 === rs.DONE) { break; } - const v: rt.u8 = _27; - const named: rt.Result = rt.Ok(v); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes((named as { ok: true; value: rt.u8 }).value))); - const into: rt.Result = rt.Ok(v); - const w2: rt.u8 = (into as { ok: true; value: rt.u8 }).value; - rt.byteVecPush(out, (result_eq$12e5exx(into, named) ? 1 : 0) | (((w2 === v ? 1 : 0) << 1) & 0xff)); - const named2: rt.Result = rt.Ok(v as rt.u16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((named2 as { ok: true; value: rt.u16 }).value))); - const into2: rt.Result = rt.Ok(v as rt.u16); - const w4: rt.u16 = (into2 as { ok: true; value: rt.u16 }).value; - rt.byteVecPush(out, (result_eq$08241oi(into2, named2) ? 1 : 0) | (((w4 === v as rt.u16 ? 1 : 0) << 1) & 0xff)); - const named3: rt.Result = rt.Ok(v as rt.u32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named3 as { ok: true; value: rt.u32 }).value))); - const into3: rt.Result = rt.Ok(v as rt.u32); - const w6: rt.u32 = (into3 as { ok: true; value: rt.u32 }).value; - rt.byteVecPush(out, (result_eq$0nbftnc(into3, named3) ? 1 : 0) | (((w6 === v as rt.u32 ? 1 : 0) << 1) & 0xff)); - const named4: rt.Result = rt.Ok(v as rt.u64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named4 as { ok: true; value: rt.u64 }).value))); - const into4: rt.Result = rt.Ok(v as rt.u64); - const w8: rt.u64 = (into4 as { ok: true; value: rt.u64 }).value; - rt.byteVecPush(out, (result_eq$1gq81ib(into4, named4) ? 1 : 0) | (((rt.u64Eq(w8, v as rt.u64) ? 1 : 0) << 1) & 0xff)); - const named5: rt.Result = rt.Ok(v as rt.u128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named5 as { ok: true; value: rt.u128 }).value))); - const into5: rt.Result = rt.Ok(v as rt.u128); - const w10: rt.u128 = (into5 as { ok: true; value: rt.u128 }).value; - rt.byteVecPush(out, (result_eq$06vyx9e(into5, named5) ? 1 : 0) | (((rt.u128Eq(w10, v as rt.u128) ? 1 : 0) << 1) & 0xff)); - const named6: rt.Result = rt.Ok(v as rt.usize); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named6 as { ok: true; value: rt.usize }).value))); - const into6: rt.Result = rt.Ok(v as rt.usize); - const w12: rt.usize = (into6 as { ok: true; value: rt.usize }).value; - rt.byteVecPush(out, (result_eq$1xhgva4(into6, named6) ? 1 : 0) | (((w12 === v as rt.usize ? 1 : 0) << 1) & 0xff)); - const named7: rt.Result = rt.Ok(v as rt.i16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named7 as { ok: true; value: rt.i16 }).value))); - const into7: rt.Result = rt.Ok(v as rt.i16); - const w14: rt.i16 = (into7 as { ok: true; value: rt.i16 }).value; - rt.byteVecPush(out, (result_eq$1mi4cle(into7, named7) ? 1 : 0) | (((w14 === v as rt.i16 ? 1 : 0) << 1) & 0xff)); - const named8: rt.Result = rt.Ok(v as rt.i32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named8 as { ok: true; value: rt.i32 }).value))); - const into8: rt.Result = rt.Ok(v as rt.i32); - const w16: rt.i32 = (into8 as { ok: true; value: rt.i32 }).value; - rt.byteVecPush(out, (result_eq$1ukayff(into8, named8) ? 1 : 0) | (((w16 === v as rt.i32 ? 1 : 0) << 1) & 0xff)); - const named9: rt.Result = rt.Ok(v as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named9 as { ok: true; value: rt.i64 }).value))); - const into9: rt.Result = rt.Ok(v as rt.i64); - const w18: rt.i64 = (into9 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into9, named9) ? 1 : 0) | (((rt.i64Eq(w18, v as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named10: rt.Result = rt.Ok(v as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named10 as { ok: true; value: rt.i128 }).value))); - const into10: rt.Result = rt.Ok(v as rt.i128); - const w20: rt.i128 = (into10 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into10, named10) ? 1 : 0) | (((rt.i128Eq(w20, v as rt.i128) ? 1 : 0) << 1) & 0xff)); - const named11: rt.Result = rt.Ok(v as rt.isize); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named11 as { ok: true; value: rt.isize }).value))); - const into11: rt.Result = rt.Ok(v as rt.isize); - const w22: rt.isize = (into11 as { ok: true; value: rt.isize }).value; - rt.byteVecPush(out, (result_eq$0w2dfat(into11, named11) ? 1 : 0) | (((w22 === v as rt.isize ? 1 : 0) << 1) & 0xff)); + const v: rs.u8 = _27; + const named: rs.Result = rs.Ok(v); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes((named as { ok: true; value: rs.u8 }).value))); + const into: rs.Result = rs.Ok(v); + const w2: rs.u8 = (into as { ok: true; value: rs.u8 }).value; + rs.byteVecPush(out, (result_eq$0qlnrz6(into, named) ? 1 : 0) | (((w2 === v ? 1 : 0) << 1) & 0xff)); + const named2: rs.Result = rs.Ok(v as rs.u16); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes((named2 as { ok: true; value: rs.u16 }).value))); + const into2: rs.Result = rs.Ok(v as rs.u16); + const w4: rs.u16 = (into2 as { ok: true; value: rs.u16 }).value; + rs.byteVecPush(out, (result_eq$06v73px(into2, named2) ? 1 : 0) | (((w4 === v as rs.u16 ? 1 : 0) << 1) & 0xff)); + const named3: rs.Result = rs.Ok(v as rs.u32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes((named3 as { ok: true; value: rs.u32 }).value))); + const into3: rs.Result = rs.Ok(v as rs.u32); + const w6: rs.u32 = (into3 as { ok: true; value: rs.u32 }).value; + rs.byteVecPush(out, (result_eq$08c3ca7(into3, named3) ? 1 : 0) | (((w6 === v as rs.u32 ? 1 : 0) << 1) & 0xff)); + const named4: rs.Result = rs.Ok(v as rs.u64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes((named4 as { ok: true; value: rs.u64 }).value))); + const into4: rs.Result = rs.Ok(v as rs.u64); + const w8: rs.u64 = (into4 as { ok: true; value: rs.u64 }).value; + rs.byteVecPush(out, (result_eq$07qa6jl(into4, named4) ? 1 : 0) | (((rs.u64Eq(w8, v as rs.u64) ? 1 : 0) << 1) & 0xff)); + const named5: rs.Result = rs.Ok(v as rs.u128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes((named5 as { ok: true; value: rs.u128 }).value))); + const into5: rs.Result = rs.Ok(v as rs.u128); + const w10: rs.u128 = (into5 as { ok: true; value: rs.u128 }).value; + rs.byteVecPush(out, (result_eq$04o4aqp(into5, named5) ? 1 : 0) | (((rs.u128Eq(w10, v as rs.u128) ? 1 : 0) << 1) & 0xff)); + const named6: rs.Result = rs.Ok(v as rs.usize); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes((named6 as { ok: true; value: rs.usize }).value))); + const into6: rs.Result = rs.Ok(v as rs.usize); + const w12: rs.usize = (into6 as { ok: true; value: rs.usize }).value; + rs.byteVecPush(out, (result_eq$1nxe4h7(into6, named6) ? 1 : 0) | (((w12 === v as rs.usize ? 1 : 0) << 1) & 0xff)); + const named7: rs.Result = rs.Ok(v as rs.i16); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((named7 as { ok: true; value: rs.i16 }).value))); + const into7: rs.Result = rs.Ok(v as rs.i16); + const w14: rs.i16 = (into7 as { ok: true; value: rs.i16 }).value; + rs.byteVecPush(out, (result_eq$0zqqsur(into7, named7) ? 1 : 0) | (((w14 === v as rs.i16 ? 1 : 0) << 1) & 0xff)); + const named8: rs.Result = rs.Ok(v as rs.i32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((named8 as { ok: true; value: rs.i32 }).value))); + const into8: rs.Result = rs.Ok(v as rs.i32); + const w16: rs.i32 = (into8 as { ok: true; value: rs.i32 }).value; + rs.byteVecPush(out, (result_eq$0f4q5sk(into8, named8) ? 1 : 0) | (((w16 === v as rs.i32 ? 1 : 0) << 1) & 0xff)); + const named9: rs.Result = rs.Ok(v as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named9 as { ok: true; value: rs.i64 }).value))); + const into9: rs.Result = rs.Ok(v as rs.i64); + const w18: rs.i64 = (into9 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into9, named9) ? 1 : 0) | (((rs.i64Eq(w18, v as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named10: rs.Result = rs.Ok(v as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named10 as { ok: true; value: rs.i128 }).value))); + const into10: rs.Result = rs.Ok(v as rs.i128); + const w20: rs.i128 = (into10 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into10, named10) ? 1 : 0) | (((rs.i128Eq(w20, v as rs.i128) ? 1 : 0) << 1) & 0xff)); + const named11: rs.Result = rs.Ok(v as rs.isize); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes((named11 as { ok: true; value: rs.isize }).value))); + const into11: rs.Result = rs.Ok(v as rs.isize); + const w22: rs.isize = (into11 as { ok: true; value: rs.isize }).value; + rs.byteVecPush(out, (result_eq$0a3yvnt(into11, named11) ? 1 : 0) | (((w22 === v as rs.isize ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 1) { - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); - const iter2: rt.Iter = rt.iterSlice([([rt.u16FromBeBytes(buf2), rt.byteSliceRange(data, n2)] as [rt.u16, rt.ByteSlice])[0], 0, 65535]); + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); + const iter2: rs.Iter = rs.iterSlice([([rs.u16FromBeBytes(buf2), rs.byteSliceRange(data, n2)] as [rs.u16, rs.ByteSlice])[0], 0, 65535]); while (true) { - const _294: rt.u16 | rt.Done = iter2.next(); - if (_294 === rt.DONE) { + const _294: rs.u16 | rs.Done = iter2.next(); + if (_294 === rs.DONE) { break; } - const v2: rt.u16 = _294; - const named12: rt.Result = rt.Ok(v2); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((named12 as { ok: true; value: rt.u16 }).value))); - const into12: rt.Result = rt.Ok(v2); - const w24: rt.u16 = (into12 as { ok: true; value: rt.u16 }).value; - rt.byteVecPush(out, (result_eq$08241oi(into12, named12) ? 1 : 0) | (((w24 === v2 ? 1 : 0) << 1) & 0xff)); - const named13: rt.Result = rt.Ok(v2 as rt.u32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named13 as { ok: true; value: rt.u32 }).value))); - const into13: rt.Result = rt.Ok(v2 as rt.u32); - const w26: rt.u32 = (into13 as { ok: true; value: rt.u32 }).value; - rt.byteVecPush(out, (result_eq$0nbftnc(into13, named13) ? 1 : 0) | (((w26 === v2 as rt.u32 ? 1 : 0) << 1) & 0xff)); - const named14: rt.Result = rt.Ok(v2 as rt.u64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named14 as { ok: true; value: rt.u64 }).value))); - const into14: rt.Result = rt.Ok(v2 as rt.u64); - const w28: rt.u64 = (into14 as { ok: true; value: rt.u64 }).value; - rt.byteVecPush(out, (result_eq$1gq81ib(into14, named14) ? 1 : 0) | (((rt.u64Eq(w28, v2 as rt.u64) ? 1 : 0) << 1) & 0xff)); - const named15: rt.Result = rt.Ok(v2 as rt.u128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named15 as { ok: true; value: rt.u128 }).value))); - const into15: rt.Result = rt.Ok(v2 as rt.u128); - const w30: rt.u128 = (into15 as { ok: true; value: rt.u128 }).value; - rt.byteVecPush(out, (result_eq$06vyx9e(into15, named15) ? 1 : 0) | (((rt.u128Eq(w30, v2 as rt.u128) ? 1 : 0) << 1) & 0xff)); - const named16: rt.Result = rt.Ok(v2 as rt.usize); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named16 as { ok: true; value: rt.usize }).value))); - const into16: rt.Result = rt.Ok(v2 as rt.usize); - const w32: rt.usize = (into16 as { ok: true; value: rt.usize }).value; - rt.byteVecPush(out, (result_eq$1xhgva4(into16, named16) ? 1 : 0) | (((w32 === v2 as rt.usize ? 1 : 0) << 1) & 0xff)); - const named17: rt.Result = rt.Ok(v2 as rt.i32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named17 as { ok: true; value: rt.i32 }).value))); - const into17: rt.Result = rt.Ok(v2 as rt.i32); - const w34: rt.i32 = (into17 as { ok: true; value: rt.i32 }).value; - rt.byteVecPush(out, (result_eq$1ukayff(into17, named17) ? 1 : 0) | (((w34 === v2 as rt.i32 ? 1 : 0) << 1) & 0xff)); - const named18: rt.Result = rt.Ok(v2 as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named18 as { ok: true; value: rt.i64 }).value))); - const into18: rt.Result = rt.Ok(v2 as rt.i64); - const w36: rt.i64 = (into18 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into18, named18) ? 1 : 0) | (((rt.i64Eq(w36, v2 as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named19: rt.Result = rt.Ok(v2 as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named19 as { ok: true; value: rt.i128 }).value))); - const into19: rt.Result = rt.Ok(v2 as rt.i128); - const w38: rt.i128 = (into19 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into19, named19) ? 1 : 0) | (((rt.i128Eq(w38, v2 as rt.i128) ? 1 : 0) << 1) & 0xff)); + const v2: rs.u16 = _294; + const named12: rs.Result = rs.Ok(v2); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes((named12 as { ok: true; value: rs.u16 }).value))); + const into12: rs.Result = rs.Ok(v2); + const w24: rs.u16 = (into12 as { ok: true; value: rs.u16 }).value; + rs.byteVecPush(out, (result_eq$06v73px(into12, named12) ? 1 : 0) | (((w24 === v2 ? 1 : 0) << 1) & 0xff)); + const named13: rs.Result = rs.Ok(v2 as rs.u32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes((named13 as { ok: true; value: rs.u32 }).value))); + const into13: rs.Result = rs.Ok(v2 as rs.u32); + const w26: rs.u32 = (into13 as { ok: true; value: rs.u32 }).value; + rs.byteVecPush(out, (result_eq$08c3ca7(into13, named13) ? 1 : 0) | (((w26 === v2 as rs.u32 ? 1 : 0) << 1) & 0xff)); + const named14: rs.Result = rs.Ok(v2 as rs.u64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes((named14 as { ok: true; value: rs.u64 }).value))); + const into14: rs.Result = rs.Ok(v2 as rs.u64); + const w28: rs.u64 = (into14 as { ok: true; value: rs.u64 }).value; + rs.byteVecPush(out, (result_eq$07qa6jl(into14, named14) ? 1 : 0) | (((rs.u64Eq(w28, v2 as rs.u64) ? 1 : 0) << 1) & 0xff)); + const named15: rs.Result = rs.Ok(v2 as rs.u128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes((named15 as { ok: true; value: rs.u128 }).value))); + const into15: rs.Result = rs.Ok(v2 as rs.u128); + const w30: rs.u128 = (into15 as { ok: true; value: rs.u128 }).value; + rs.byteVecPush(out, (result_eq$04o4aqp(into15, named15) ? 1 : 0) | (((rs.u128Eq(w30, v2 as rs.u128) ? 1 : 0) << 1) & 0xff)); + const named16: rs.Result = rs.Ok(v2 as rs.usize); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes((named16 as { ok: true; value: rs.usize }).value))); + const into16: rs.Result = rs.Ok(v2 as rs.usize); + const w32: rs.usize = (into16 as { ok: true; value: rs.usize }).value; + rs.byteVecPush(out, (result_eq$1nxe4h7(into16, named16) ? 1 : 0) | (((w32 === v2 as rs.usize ? 1 : 0) << 1) & 0xff)); + const named17: rs.Result = rs.Ok(v2 as rs.i32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((named17 as { ok: true; value: rs.i32 }).value))); + const into17: rs.Result = rs.Ok(v2 as rs.i32); + const w34: rs.i32 = (into17 as { ok: true; value: rs.i32 }).value; + rs.byteVecPush(out, (result_eq$0f4q5sk(into17, named17) ? 1 : 0) | (((w34 === v2 as rs.i32 ? 1 : 0) << 1) & 0xff)); + const named18: rs.Result = rs.Ok(v2 as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named18 as { ok: true; value: rs.i64 }).value))); + const into18: rs.Result = rs.Ok(v2 as rs.i64); + const w36: rs.i64 = (into18 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into18, named18) ? 1 : 0) | (((rs.i64Eq(w36, v2 as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named19: rs.Result = rs.Ok(v2 as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named19 as { ok: true; value: rs.i128 }).value))); + const into19: rs.Result = rs.Ok(v2 as rs.i128); + const w38: rs.i128 = (into19 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into19, named19) ? 1 : 0) | (((rs.i128Eq(w38, v2 as rs.i128) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 2) { - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); - const iter3: rt.Iter = rt.iterSlice([([rt.u32FromBeBytes(buf3), rt.byteSliceRange(data, n3)] as [rt.u32, rt.ByteSlice])[0], 0, 4294967295]); + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); + const iter3: rs.Iter = rs.iterSlice([([rs.u32FromBeBytes(buf3), rs.byteSliceRange(data, n3)] as [rs.u32, rs.ByteSlice])[0], 0, 4294967295]); while (true) { - const _495: rt.u32 | rt.Done = iter3.next(); - if (_495 === rt.DONE) { + const _495: rs.u32 | rs.Done = iter3.next(); + if (_495 === rs.DONE) { break; } - const v3: rt.u32 = _495; - const named20: rt.Result = rt.Ok(v3); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes((named20 as { ok: true; value: rt.u32 }).value))); - const into20: rt.Result = rt.Ok(v3); - const w40: rt.u32 = (into20 as { ok: true; value: rt.u32 }).value; - rt.byteVecPush(out, (result_eq$0nbftnc(into20, named20) ? 1 : 0) | (((w40 === v3 ? 1 : 0) << 1) & 0xff)); - const named21: rt.Result = rt.Ok(v3 as rt.u64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named21 as { ok: true; value: rt.u64 }).value))); - const into21: rt.Result = rt.Ok(v3 as rt.u64); - const w42: rt.u64 = (into21 as { ok: true; value: rt.u64 }).value; - rt.byteVecPush(out, (result_eq$1gq81ib(into21, named21) ? 1 : 0) | (((rt.u64Eq(w42, v3 as rt.u64) ? 1 : 0) << 1) & 0xff)); - const named22: rt.Result = rt.Ok(v3 as rt.u128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named22 as { ok: true; value: rt.u128 }).value))); - const into22: rt.Result = rt.Ok(v3 as rt.u128); - const w44: rt.u128 = (into22 as { ok: true; value: rt.u128 }).value; - rt.byteVecPush(out, (result_eq$06vyx9e(into22, named22) ? 1 : 0) | (((rt.u128Eq(w44, v3 as rt.u128) ? 1 : 0) << 1) & 0xff)); - const named23: rt.Result = rt.Ok(v3 as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named23 as { ok: true; value: rt.i64 }).value))); - const into23: rt.Result = rt.Ok(v3 as rt.i64); - const w46: rt.i64 = (into23 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into23, named23) ? 1 : 0) | (((rt.i64Eq(w46, v3 as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named24: rt.Result = rt.Ok(v3 as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named24 as { ok: true; value: rt.i128 }).value))); - const into24: rt.Result = rt.Ok(v3 as rt.i128); - const w48: rt.i128 = (into24 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into24, named24) ? 1 : 0) | (((rt.i128Eq(w48, v3 as rt.i128) ? 1 : 0) << 1) & 0xff)); + const v3: rs.u32 = _495; + const named20: rs.Result = rs.Ok(v3); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes((named20 as { ok: true; value: rs.u32 }).value))); + const into20: rs.Result = rs.Ok(v3); + const w40: rs.u32 = (into20 as { ok: true; value: rs.u32 }).value; + rs.byteVecPush(out, (result_eq$08c3ca7(into20, named20) ? 1 : 0) | (((w40 === v3 ? 1 : 0) << 1) & 0xff)); + const named21: rs.Result = rs.Ok(v3 as rs.u64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes((named21 as { ok: true; value: rs.u64 }).value))); + const into21: rs.Result = rs.Ok(v3 as rs.u64); + const w42: rs.u64 = (into21 as { ok: true; value: rs.u64 }).value; + rs.byteVecPush(out, (result_eq$07qa6jl(into21, named21) ? 1 : 0) | (((rs.u64Eq(w42, v3 as rs.u64) ? 1 : 0) << 1) & 0xff)); + const named22: rs.Result = rs.Ok(v3 as rs.u128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes((named22 as { ok: true; value: rs.u128 }).value))); + const into22: rs.Result = rs.Ok(v3 as rs.u128); + const w44: rs.u128 = (into22 as { ok: true; value: rs.u128 }).value; + rs.byteVecPush(out, (result_eq$04o4aqp(into22, named22) ? 1 : 0) | (((rs.u128Eq(w44, v3 as rs.u128) ? 1 : 0) << 1) & 0xff)); + const named23: rs.Result = rs.Ok(v3 as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named23 as { ok: true; value: rs.i64 }).value))); + const into23: rs.Result = rs.Ok(v3 as rs.i64); + const w46: rs.i64 = (into23 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into23, named23) ? 1 : 0) | (((rs.i64Eq(w46, v3 as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named24: rs.Result = rs.Ok(v3 as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named24 as { ok: true; value: rs.i128 }).value))); + const into24: rs.Result = rs.Ok(v3 as rs.i128); + const w48: rs.i128 = (into24 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into24, named24) ? 1 : 0) | (((rs.i128Eq(w48, v3 as rs.i128) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 3) { - const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); - const iter4: rt.Iter = rt.iterSlice([([rt.u64FromBeBytes(buf4), rt.byteSliceRange(data, n4)] as [rt.u64, rt.ByteSlice])[0], 0, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64]); + const buf4: Uint8Array = rs.bytes(8); + const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); + const iter4: rs.Iter = rs.iterSlice([([rs.u64FromBeBytes(buf4), rs.byteSliceRange(data, n4)] as [rs.u64, rs.ByteSlice])[0], 0, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64]); while (true) { - const _630: rt.u64 | rt.Done = iter4.next(); - if (_630 === rt.DONE) { + const _630: rs.u64 | rs.Done = iter4.next(); + if (_630 === rs.DONE) { break; } - const v4: rt.u64 = _630; - const named25: rt.Result = rt.Ok(v4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes((named25 as { ok: true; value: rt.u64 }).value))); - const into25: rt.Result = rt.Ok(v4); - const w50: rt.u64 = (into25 as { ok: true; value: rt.u64 }).value; - rt.byteVecPush(out, (result_eq$1gq81ib(into25, named25) ? 1 : 0) | (((rt.u64Eq(w50, v4) ? 1 : 0) << 1) & 0xff)); - const named26: rt.Result = rt.Ok(rt.u128Cast(v4)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named26 as { ok: true; value: rt.u128 }).value))); - const into26: rt.Result = rt.Ok(rt.u128Cast(v4)); - const w52: rt.u128 = (into26 as { ok: true; value: rt.u128 }).value; - rt.byteVecPush(out, (result_eq$06vyx9e(into26, named26) ? 1 : 0) | (((rt.u128Eq(w52, rt.u128Cast(v4)) ? 1 : 0) << 1) & 0xff)); - const named27: rt.Result = rt.Ok(rt.i128Cast(v4)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named27 as { ok: true; value: rt.i128 }).value))); - const into27: rt.Result = rt.Ok(rt.i128Cast(v4)); - const w54: rt.i128 = (into27 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into27, named27) ? 1 : 0) | (((rt.i128Eq(w54, rt.i128Cast(v4)) ? 1 : 0) << 1) & 0xff)); + const v4: rs.u64 = _630; + const named25: rs.Result = rs.Ok(v4); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes((named25 as { ok: true; value: rs.u64 }).value))); + const into25: rs.Result = rs.Ok(v4); + const w50: rs.u64 = (into25 as { ok: true; value: rs.u64 }).value; + rs.byteVecPush(out, (result_eq$07qa6jl(into25, named25) ? 1 : 0) | (((rs.u64Eq(w50, v4) ? 1 : 0) << 1) & 0xff)); + const named26: rs.Result = rs.Ok(rs.u128Cast(v4)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes((named26 as { ok: true; value: rs.u128 }).value))); + const into26: rs.Result = rs.Ok(rs.u128Cast(v4)); + const w52: rs.u128 = (into26 as { ok: true; value: rs.u128 }).value; + rs.byteVecPush(out, (result_eq$04o4aqp(into26, named26) ? 1 : 0) | (((rs.u128Eq(w52, rs.u128Cast(v4)) ? 1 : 0) << 1) & 0xff)); + const named27: rs.Result = rs.Ok(rs.i128Cast(v4)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named27 as { ok: true; value: rs.i128 }).value))); + const into27: rs.Result = rs.Ok(rs.i128Cast(v4)); + const w54: rs.i128 = (into27 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into27, named27) ? 1 : 0) | (((rs.i128Eq(w54, rs.i128Cast(v4)) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 4) { - const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); - const iter5: rt.Iter = rt.iterSlice([([rt.u128FromBeBytes(buf5), rt.byteSliceRange(data, n5)] as [rt.u128, rt.ByteSlice])[0], 0, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128]); + const buf5: Uint8Array = rs.bytes(16); + const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); + const iter5: rs.Iter = rs.iterSlice([([rs.u128FromBeBytes(buf5), rs.byteSliceRange(data, n5)] as [rs.u128, rs.ByteSlice])[0], 0, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128]); while (true) { - const _721: rt.u128 | rt.Done = iter5.next(); - if (_721 === rt.DONE) { + const _721: rs.u128 | rs.Done = iter5.next(); + if (_721 === rs.DONE) { break; } - const v5: rt.u128 = _721; - const named28: rt.Result = rt.Ok(v5); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes((named28 as { ok: true; value: rt.u128 }).value))); - const into28: rt.Result = rt.Ok(v5); - const w56: rt.u128 = (into28 as { ok: true; value: rt.u128 }).value; - rt.byteVecPush(out, (result_eq$06vyx9e(into28, named28) ? 1 : 0) | (((rt.u128Eq(w56, v5) ? 1 : 0) << 1) & 0xff)); + const v5: rs.u128 = _721; + const named28: rs.Result = rs.Ok(v5); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes((named28 as { ok: true; value: rs.u128 }).value))); + const into28: rs.Result = rs.Ok(v5); + const w56: rs.u128 = (into28 as { ok: true; value: rs.u128 }).value; + rs.byteVecPush(out, (result_eq$04o4aqp(into28, named28) ? 1 : 0) | (((rs.u128Eq(w56, v5) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 5) { - const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); - const iter6: rt.Iter = rt.iterSlice([([rt.usizeFromBeBytes(buf6), rt.byteSliceRange(data, n6)] as [rt.usize, rt.ByteSlice])[0], 0, 4294967295]); + const buf6: Uint8Array = rs.bytes(4); + const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); + const iter6: rs.Iter = rs.iterSlice([([rs.usizeFromBeBytes(buf6), rs.byteSliceRange(data, n6)] as [rs.usize, rs.ByteSlice])[0], 0, 4294967295]); while (true) { - const _768: rt.usize | rt.Done = iter6.next(); - if (_768 === rt.DONE) { + const _768: rs.usize | rs.Done = iter6.next(); + if (_768 === rs.DONE) { break; } - const v6: rt.usize = _768; - const named29: rt.Result = rt.Ok(v6); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes((named29 as { ok: true; value: rt.usize }).value))); - const into29: rt.Result = rt.Ok(v6); - const w58: rt.usize = (into29 as { ok: true; value: rt.usize }).value; - rt.byteVecPush(out, (result_eq$1xhgva4(into29, named29) ? 1 : 0) | (((w58 === v6 ? 1 : 0) << 1) & 0xff)); + const v6: rs.usize = _768; + const named29: rs.Result = rs.Ok(v6); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes((named29 as { ok: true; value: rs.usize }).value))); + const into29: rs.Result = rs.Ok(v6); + const w58: rs.usize = (into29 as { ok: true; value: rs.usize }).value; + rs.byteVecPush(out, (result_eq$1nxe4h7(into29, named29) ? 1 : 0) | (((w58 === v6 ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); - const iter7: rt.Iter = rt.iterSlice([([rt.i8FromBeBytes(buf7), rt.byteSliceRange(data, n7)] as [rt.i8, rt.ByteSlice])[0], -128, 127]); + const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); + const iter7: rs.Iter = rs.iterSlice([([rs.i8FromBeBytes(buf7), rs.byteSliceRange(data, n7)] as [rs.i8, rs.ByteSlice])[0], -128, 127]); while (true) { - const _815: rt.i8 | rt.Done = iter7.next(); - if (_815 === rt.DONE) { + const _815: rs.i8 | rs.Done = iter7.next(); + if (_815 === rs.DONE) { break; } - const v7: rt.i8 = _815; - const named30: rt.Result = rt.Ok(v7); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((named30 as { ok: true; value: rt.i8 }).value))); - const into30: rt.Result = rt.Ok(v7); - const w60: rt.i8 = (into30 as { ok: true; value: rt.i8 }).value; - rt.byteVecPush(out, (result_eq$1hd8lo9(into30, named30) ? 1 : 0) | (((w60 === v7 ? 1 : 0) << 1) & 0xff)); - const named31: rt.Result = rt.Ok(v7 as rt.i16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named31 as { ok: true; value: rt.i16 }).value))); - const into31: rt.Result = rt.Ok(v7 as rt.i16); - const w62: rt.i16 = (into31 as { ok: true; value: rt.i16 }).value; - rt.byteVecPush(out, (result_eq$1mi4cle(into31, named31) ? 1 : 0) | (((w62 === v7 as rt.i16 ? 1 : 0) << 1) & 0xff)); - const named32: rt.Result = rt.Ok(v7 as rt.i32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named32 as { ok: true; value: rt.i32 }).value))); - const into32: rt.Result = rt.Ok(v7 as rt.i32); - const w64: rt.i32 = (into32 as { ok: true; value: rt.i32 }).value; - rt.byteVecPush(out, (result_eq$1ukayff(into32, named32) ? 1 : 0) | (((w64 === v7 as rt.i32 ? 1 : 0) << 1) & 0xff)); - const named33: rt.Result = rt.Ok(v7 as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named33 as { ok: true; value: rt.i64 }).value))); - const into33: rt.Result = rt.Ok(v7 as rt.i64); - const w66: rt.i64 = (into33 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into33, named33) ? 1 : 0) | (((rt.i64Eq(w66, v7 as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named34: rt.Result = rt.Ok(v7 as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named34 as { ok: true; value: rt.i128 }).value))); - const into34: rt.Result = rt.Ok(v7 as rt.i128); - const w68: rt.i128 = (into34 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into34, named34) ? 1 : 0) | (((rt.i128Eq(w68, v7 as rt.i128) ? 1 : 0) << 1) & 0xff)); - const named35: rt.Result = rt.Ok(v7 as rt.isize); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named35 as { ok: true; value: rt.isize }).value))); - const into35: rt.Result = rt.Ok(v7 as rt.isize); - const w70: rt.isize = (into35 as { ok: true; value: rt.isize }).value; - rt.byteVecPush(out, (result_eq$0w2dfat(into35, named35) ? 1 : 0) | (((w70 === v7 as rt.isize ? 1 : 0) << 1) & 0xff)); + const v7: rs.i8 = _815; + const named30: rs.Result = rs.Ok(v7); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes((named30 as { ok: true; value: rs.i8 }).value))); + const into30: rs.Result = rs.Ok(v7); + const w60: rs.i8 = (into30 as { ok: true; value: rs.i8 }).value; + rs.byteVecPush(out, (result_eq$0g4cq9b(into30, named30) ? 1 : 0) | (((w60 === v7 ? 1 : 0) << 1) & 0xff)); + const named31: rs.Result = rs.Ok(v7 as rs.i16); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((named31 as { ok: true; value: rs.i16 }).value))); + const into31: rs.Result = rs.Ok(v7 as rs.i16); + const w62: rs.i16 = (into31 as { ok: true; value: rs.i16 }).value; + rs.byteVecPush(out, (result_eq$0zqqsur(into31, named31) ? 1 : 0) | (((w62 === v7 as rs.i16 ? 1 : 0) << 1) & 0xff)); + const named32: rs.Result = rs.Ok(v7 as rs.i32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((named32 as { ok: true; value: rs.i32 }).value))); + const into32: rs.Result = rs.Ok(v7 as rs.i32); + const w64: rs.i32 = (into32 as { ok: true; value: rs.i32 }).value; + rs.byteVecPush(out, (result_eq$0f4q5sk(into32, named32) ? 1 : 0) | (((w64 === v7 as rs.i32 ? 1 : 0) << 1) & 0xff)); + const named33: rs.Result = rs.Ok(v7 as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named33 as { ok: true; value: rs.i64 }).value))); + const into33: rs.Result = rs.Ok(v7 as rs.i64); + const w66: rs.i64 = (into33 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into33, named33) ? 1 : 0) | (((rs.i64Eq(w66, v7 as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named34: rs.Result = rs.Ok(v7 as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named34 as { ok: true; value: rs.i128 }).value))); + const into34: rs.Result = rs.Ok(v7 as rs.i128); + const w68: rs.i128 = (into34 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into34, named34) ? 1 : 0) | (((rs.i128Eq(w68, v7 as rs.i128) ? 1 : 0) << 1) & 0xff)); + const named35: rs.Result = rs.Ok(v7 as rs.isize); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes((named35 as { ok: true; value: rs.isize }).value))); + const into35: rs.Result = rs.Ok(v7 as rs.isize); + const w70: rs.isize = (into35 as { ok: true; value: rs.isize }).value; + rs.byteVecPush(out, (result_eq$0a3yvnt(into35, named35) ? 1 : 0) | (((w70 === v7 as rs.isize ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 7) { - const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); - const iter8: rt.Iter = rt.iterSlice([([rt.i16FromBeBytes(buf8), rt.byteSliceRange(data, n8)] as [rt.i16, rt.ByteSlice])[0], -32768, 32767]); + const buf8: Uint8Array = rs.bytes(2); + const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); + const iter8: rs.Iter = rs.iterSlice([([rs.i16FromBeBytes(buf8), rs.byteSliceRange(data, n8)] as [rs.i16, rs.ByteSlice])[0], -32768, 32767]); while (true) { - const _972: rt.i16 | rt.Done = iter8.next(); - if (_972 === rt.DONE) { + const _972: rs.i16 | rs.Done = iter8.next(); + if (_972 === rs.DONE) { break; } - const v8: rt.i16 = _972; - const named36: rt.Result = rt.Ok(v8); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((named36 as { ok: true; value: rt.i16 }).value))); - const into36: rt.Result = rt.Ok(v8); - const w72: rt.i16 = (into36 as { ok: true; value: rt.i16 }).value; - rt.byteVecPush(out, (result_eq$1mi4cle(into36, named36) ? 1 : 0) | (((w72 === v8 ? 1 : 0) << 1) & 0xff)); - const named37: rt.Result = rt.Ok(v8 as rt.i32); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named37 as { ok: true; value: rt.i32 }).value))); - const into37: rt.Result = rt.Ok(v8 as rt.i32); - const w74: rt.i32 = (into37 as { ok: true; value: rt.i32 }).value; - rt.byteVecPush(out, (result_eq$1ukayff(into37, named37) ? 1 : 0) | (((w74 === v8 as rt.i32 ? 1 : 0) << 1) & 0xff)); - const named38: rt.Result = rt.Ok(v8 as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named38 as { ok: true; value: rt.i64 }).value))); - const into38: rt.Result = rt.Ok(v8 as rt.i64); - const w76: rt.i64 = (into38 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into38, named38) ? 1 : 0) | (((rt.i64Eq(w76, v8 as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named39: rt.Result = rt.Ok(v8 as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named39 as { ok: true; value: rt.i128 }).value))); - const into39: rt.Result = rt.Ok(v8 as rt.i128); - const w78: rt.i128 = (into39 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into39, named39) ? 1 : 0) | (((rt.i128Eq(w78, v8 as rt.i128) ? 1 : 0) << 1) & 0xff)); - const named40: rt.Result = rt.Ok(v8 as rt.isize); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named40 as { ok: true; value: rt.isize }).value))); - const into40: rt.Result = rt.Ok(v8 as rt.isize); - const w80: rt.isize = (into40 as { ok: true; value: rt.isize }).value; - rt.byteVecPush(out, (result_eq$0w2dfat(into40, named40) ? 1 : 0) | (((w80 === v8 as rt.isize ? 1 : 0) << 1) & 0xff)); + const v8: rs.i16 = _972; + const named36: rs.Result = rs.Ok(v8); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((named36 as { ok: true; value: rs.i16 }).value))); + const into36: rs.Result = rs.Ok(v8); + const w72: rs.i16 = (into36 as { ok: true; value: rs.i16 }).value; + rs.byteVecPush(out, (result_eq$0zqqsur(into36, named36) ? 1 : 0) | (((w72 === v8 ? 1 : 0) << 1) & 0xff)); + const named37: rs.Result = rs.Ok(v8 as rs.i32); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((named37 as { ok: true; value: rs.i32 }).value))); + const into37: rs.Result = rs.Ok(v8 as rs.i32); + const w74: rs.i32 = (into37 as { ok: true; value: rs.i32 }).value; + rs.byteVecPush(out, (result_eq$0f4q5sk(into37, named37) ? 1 : 0) | (((w74 === v8 as rs.i32 ? 1 : 0) << 1) & 0xff)); + const named38: rs.Result = rs.Ok(v8 as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named38 as { ok: true; value: rs.i64 }).value))); + const into38: rs.Result = rs.Ok(v8 as rs.i64); + const w76: rs.i64 = (into38 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into38, named38) ? 1 : 0) | (((rs.i64Eq(w76, v8 as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named39: rs.Result = rs.Ok(v8 as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named39 as { ok: true; value: rs.i128 }).value))); + const into39: rs.Result = rs.Ok(v8 as rs.i128); + const w78: rs.i128 = (into39 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into39, named39) ? 1 : 0) | (((rs.i128Eq(w78, v8 as rs.i128) ? 1 : 0) << 1) & 0xff)); + const named40: rs.Result = rs.Ok(v8 as rs.isize); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes((named40 as { ok: true; value: rs.isize }).value))); + const into40: rs.Result = rs.Ok(v8 as rs.isize); + const w80: rs.isize = (into40 as { ok: true; value: rs.isize }).value; + rs.byteVecPush(out, (result_eq$0a3yvnt(into40, named40) ? 1 : 0) | (((w80 === v8 as rs.isize ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 8) { - const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); - const iter9: rt.Iter = rt.iterSlice([([rt.i32FromBeBytes(buf9), rt.byteSliceRange(data, n9)] as [rt.i32, rt.ByteSlice])[0], -2147483648, 2147483647]); + const buf9: Uint8Array = rs.bytes(4); + const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); + const iter9: rs.Iter = rs.iterSlice([([rs.i32FromBeBytes(buf9), rs.byteSliceRange(data, n9)] as [rs.i32, rs.ByteSlice])[0], -2147483648, 2147483647]); while (true) { - const _1107: rt.i32 | rt.Done = iter9.next(); - if (_1107 === rt.DONE) { + const _1107: rs.i32 | rs.Done = iter9.next(); + if (_1107 === rs.DONE) { break; } - const v9: rt.i32 = _1107; - const named41: rt.Result = rt.Ok(v9); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes((named41 as { ok: true; value: rt.i32 }).value))); - const into41: rt.Result = rt.Ok(v9); - const w82: rt.i32 = (into41 as { ok: true; value: rt.i32 }).value; - rt.byteVecPush(out, (result_eq$1ukayff(into41, named41) ? 1 : 0) | (((w82 === v9 ? 1 : 0) << 1) & 0xff)); - const named42: rt.Result = rt.Ok(v9 as rt.i64); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named42 as { ok: true; value: rt.i64 }).value))); - const into42: rt.Result = rt.Ok(v9 as rt.i64); - const w84: rt.i64 = (into42 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into42, named42) ? 1 : 0) | (((rt.i64Eq(w84, v9 as rt.i64) ? 1 : 0) << 1) & 0xff)); - const named43: rt.Result = rt.Ok(v9 as rt.i128); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named43 as { ok: true; value: rt.i128 }).value))); - const into43: rt.Result = rt.Ok(v9 as rt.i128); - const w86: rt.i128 = (into43 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into43, named43) ? 1 : 0) | (((rt.i128Eq(w86, v9 as rt.i128) ? 1 : 0) << 1) & 0xff)); + const v9: rs.i32 = _1107; + const named41: rs.Result = rs.Ok(v9); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes((named41 as { ok: true; value: rs.i32 }).value))); + const into41: rs.Result = rs.Ok(v9); + const w82: rs.i32 = (into41 as { ok: true; value: rs.i32 }).value; + rs.byteVecPush(out, (result_eq$0f4q5sk(into41, named41) ? 1 : 0) | (((w82 === v9 ? 1 : 0) << 1) & 0xff)); + const named42: rs.Result = rs.Ok(v9 as rs.i64); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named42 as { ok: true; value: rs.i64 }).value))); + const into42: rs.Result = rs.Ok(v9 as rs.i64); + const w84: rs.i64 = (into42 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into42, named42) ? 1 : 0) | (((rs.i64Eq(w84, v9 as rs.i64) ? 1 : 0) << 1) & 0xff)); + const named43: rs.Result = rs.Ok(v9 as rs.i128); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named43 as { ok: true; value: rs.i128 }).value))); + const into43: rs.Result = rs.Ok(v9 as rs.i128); + const w86: rs.i128 = (into43 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into43, named43) ? 1 : 0) | (((rs.i128Eq(w86, v9 as rs.i128) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 9) { - const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); - const iter10: rt.Iter = rt.iterSlice([([rt.i64FromBeBytes(buf10), rt.byteSliceRange(data, n10)] as [rt.i64, rt.ByteSlice])[0], { hi: -0x80000000, lo: 0 } as rt.i64, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64]); + const buf10: Uint8Array = rs.bytes(8); + const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); + const iter10: rs.Iter = rs.iterSlice([([rs.i64FromBeBytes(buf10), rs.byteSliceRange(data, n10)] as [rs.i64, rs.ByteSlice])[0], { hi: -0x80000000, lo: 0 } as rs.i64, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64]); while (true) { - const _1198: rt.i64 | rt.Done = iter10.next(); - if (_1198 === rt.DONE) { + const _1198: rs.i64 | rs.Done = iter10.next(); + if (_1198 === rs.DONE) { break; } - const v10: rt.i64 = _1198; - const named44: rt.Result = rt.Ok(v10); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes((named44 as { ok: true; value: rt.i64 }).value))); - const into44: rt.Result = rt.Ok(v10); - const w88: rt.i64 = (into44 as { ok: true; value: rt.i64 }).value; - rt.byteVecPush(out, (result_eq$1hy1is1(into44, named44) ? 1 : 0) | (((rt.i64Eq(w88, v10) ? 1 : 0) << 1) & 0xff)); - const named45: rt.Result = rt.Ok(rt.i128Cast(v10)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named45 as { ok: true; value: rt.i128 }).value))); - const into45: rt.Result = rt.Ok(rt.i128Cast(v10)); - const w90: rt.i128 = (into45 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into45, named45) ? 1 : 0) | (((rt.i128Eq(w90, rt.i128Cast(v10)) ? 1 : 0) << 1) & 0xff)); + const v10: rs.i64 = _1198; + const named44: rs.Result = rs.Ok(v10); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes((named44 as { ok: true; value: rs.i64 }).value))); + const into44: rs.Result = rs.Ok(v10); + const w88: rs.i64 = (into44 as { ok: true; value: rs.i64 }).value; + rs.byteVecPush(out, (result_eq$12fysd9(into44, named44) ? 1 : 0) | (((rs.i64Eq(w88, v10) ? 1 : 0) << 1) & 0xff)); + const named45: rs.Result = rs.Ok(rs.i128Cast(v10)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named45 as { ok: true; value: rs.i128 }).value))); + const into45: rs.Result = rs.Ok(rs.i128Cast(v10)); + const w90: rs.i128 = (into45 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into45, named45) ? 1 : 0) | (((rs.i128Eq(w90, rs.i128Cast(v10)) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 10) { - const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); - const iter11: rt.Iter = rt.iterSlice([([rt.i128FromBeBytes(buf11), rt.byteSliceRange(data, n11)] as [rt.i128, rt.ByteSlice])[0], { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128]); + const buf11: Uint8Array = rs.bytes(16); + const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); + const iter11: rs.Iter = rs.iterSlice([([rs.i128FromBeBytes(buf11), rs.byteSliceRange(data, n11)] as [rs.i128, rs.ByteSlice])[0], { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128]); while (true) { - const _1267: rt.i128 | rt.Done = iter11.next(); - if (_1267 === rt.DONE) { + const _1267: rs.i128 | rs.Done = iter11.next(); + if (_1267 === rs.DONE) { break; } - const v11: rt.i128 = _1267; - const named46: rt.Result = rt.Ok(v11); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes((named46 as { ok: true; value: rt.i128 }).value))); - const into46: rt.Result = rt.Ok(v11); - const w92: rt.i128 = (into46 as { ok: true; value: rt.i128 }).value; - rt.byteVecPush(out, (result_eq$0pee78b(into46, named46) ? 1 : 0) | (((rt.i128Eq(w92, v11) ? 1 : 0) << 1) & 0xff)); + const v11: rs.i128 = _1267; + const named46: rs.Result = rs.Ok(v11); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes((named46 as { ok: true; value: rs.i128 }).value))); + const into46: rs.Result = rs.Ok(v11); + const w92: rs.i128 = (into46 as { ok: true; value: rs.i128 }).value; + rs.byteVecPush(out, (result_eq$1o2c9h9(into46, named46) ? 1 : 0) | (((rs.i128Eq(w92, v11) ? 1 : 0) << 1) & 0xff)); } } else if (_4 === 11) { - const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); - const iter12: rt.Iter = rt.iterSlice([([rt.isizeFromBeBytes(buf12), rt.byteSliceRange(data, n12)] as [rt.isize, rt.ByteSlice])[0], -2147483648, 2147483647]); + const buf12: Uint8Array = rs.bytes(4); + const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); + const iter12: rs.Iter = rs.iterSlice([([rs.isizeFromBeBytes(buf12), rs.byteSliceRange(data, n12)] as [rs.isize, rs.ByteSlice])[0], -2147483648, 2147483647]); while (true) { - const _1314: rt.isize | rt.Done = iter12.next(); - if (_1314 === rt.DONE) { + const _1314: rs.isize | rs.Done = iter12.next(); + if (_1314 === rs.DONE) { break; } - const v12: rt.isize = _1314; - const named47: rt.Result = rt.Ok(v12); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes((named47 as { ok: true; value: rt.isize }).value))); - const into47: rt.Result = rt.Ok(v12); - const w94: rt.isize = (into47 as { ok: true; value: rt.isize }).value; - rt.byteVecPush(out, (result_eq$0w2dfat(into47, named47) ? 1 : 0) | (((w94 === v12 ? 1 : 0) << 1) & 0xff)); + const v12: rs.isize = _1314; + const named47: rs.Result = rs.Ok(v12); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes((named47 as { ok: true; value: rs.isize }).value))); + const into47: rs.Result = rs.Ok(v12); + const w94: rs.isize = (into47 as { ok: true; value: rs.isize }).value; + rs.byteVecPush(out, (result_eq$0a3yvnt(into47, named47) ? 1 : 0) | (((w94 === v12 ? 1 : 0) << 1) & 0xff)); } } else { const buf13: Uint8Array = Uint8Array.of(0); - const n13: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf13).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf13), 0, n13), rt.byteSliceRange(data, 0, n13)); - const iter13: rt.Iter = rt.iterSlice(Uint8Array.of(([rt.u8FromBeBytes(buf13), rt.byteSliceRange(data, n13)] as [rt.u8, rt.ByteSlice])[0], 0, 255)); + const n13: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf13).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf13), 0, n13), rs.byteSliceRange(data, 0, n13)); + const iter13: rs.Iter = rs.iterSlice(Uint8Array.of(([rs.u8FromBeBytes(buf13), rs.byteSliceRange(data, n13)] as [rs.u8, rs.ByteSlice])[0], 0, 255)); while (true) { - const _1361: rt.u8 | rt.Done = iter13.next(); - if (_1361 === rt.DONE) { + const _1361: rs.u8 | rs.Done = iter13.next(); + if (_1361 === rs.DONE) { break; } - const b2: rt.u8 = _1361; - const iter14: rt.Iter = rt.iterSlice([b2 as rt.char, 0, 1114111]); + const b2: rs.u8 = _1361; + const iter14: rs.Iter = rs.iterSlice([b2 as rs.char, 0, 1114111]); while (true) { - const _1371: rt.char | rt.Done = iter14.next(); - if (_1371 === rt.DONE) { + const _1371: rs.char | rs.Done = iter14.next(); + if (_1371 === rs.DONE) { break; } - const c2: rt.char = _1371; - const _1381: [rt.Result, rt.Result, rt.Result] = [rt.Ok(c2 as rt.u32), rt.Ok(c2 as rt.u64), rt.Ok(c2 as rt.u128)]; - const a: rt.u32 = (_1381[0] as { ok: true; value: rt.u32 }).value; - const b3: rt.u64 = (_1381[1] as { ok: true; value: rt.u64 }).value; - const c3: rt.u128 = (_1381[2] as { ok: true; value: rt.u128 }).value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(a))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b3))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(c3))); + const c2: rs.char = _1371; + const _1381: [rs.Result, rs.Result, rs.Result] = [rs.Ok(c2 as rs.u32), rs.Ok(c2 as rs.u64), rs.Ok(c2 as rs.u128)]; + const a: rs.u32 = (_1381[0] as { ok: true; value: rs.u32 }).value; + const b3: rs.u64 = (_1381[1] as { ok: true; value: rs.u64 }).value; + const c3: rs.u128 = (_1381[2] as { ok: true; value: rs.u128 }).value; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(a))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(b3))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(c3))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(Scaled.from$convert_From_u8(b2)._0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(Scaled.from$convert_From_u8(b2)._0))); } } } diff --git a/ts/fixtures/lang/ints/expected/lib.ts b/ts/fixtures/lang/ints/expected/lib.ts index 4d7badb27..7a065a433 100644 --- a/ts/fixtures/lang/ints/expected/lib.ts +++ b/ts/fixtures/lang/ints/expected/lib.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses, widenings } from "./ints.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["ints::u8_op", u8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u16_op", u16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u32_op", u32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u64_op", u64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::u128_op", u128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::usize_op", usizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i8_op", i8Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i16_op", i16Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i32_op", i32Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i64_op", i64Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::i128_op", i128Op as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::isize_op", isizeOp as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::neg", neg as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::cast", cast as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::convert", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["ints::u8_op", u8Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::u16_op", u16Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::u32_op", u32Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::u64_op", u64Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::u128_op", u128Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::usize_op", usizeOp as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::i8_op", i8Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::i16_op", i16Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::i32_op", i32Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::i64_op", i64Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::i128_op", i128Op as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::isize_op", isizeOp as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::neg", neg as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::cast", cast as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::convert", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { convert(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::parses", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::parses", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { parses(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["ints::widenings", widenings as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["ints::widenings", widenings as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } /** Negate the signed type `kind` picks. */ -export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 6); +export function neg(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 6); if (_4 === 0) { i8Neg(data, out); } else if (_4 === 1) { @@ -37,11 +37,11 @@ export function neg(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Cast from the type `kind` picks to the one the next byte does, or without one, to * a type `kind` also picks. */ -export function cast(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function cast(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length === 0) { - ints_cast(kind, rt.u8Div(kind, 12), data, out); + ints_cast(kind, rs.u8Div(kind, 12), data, out); } else { - ints_cast(kind, data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1), out); + ints_cast(kind, data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1), out); } } diff --git a/ts/fixtures/lang/iters/expected/core/bool.ts b/ts/fixtures/lang/iters/expected/core/bool.ts index b4b3e3227..19206a220 100644 --- a/ts/fixtures/lang/iters/expected/core/bool.ts +++ b/ts/fixtures/lang/iters/expected/core/bool.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$185ufyt(self: boolean, t: rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function thenSome$1ctlqen(self: boolean, t: rs.u8 | undefined): rs.u8 | undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return t; } -export function thenSome$0b23a33(self: boolean, t: rt.u16): rt.u16 | undefined { +export function thenSome$1gvhopg(self: boolean, t: rs.u16): rs.u16 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { +export function thenSome$1n1oy1h(self: boolean, _: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return undefined; } diff --git a/ts/fixtures/lang/iters/expected/core/option.ts b/ts/fixtures/lang/iters/expected/core/option.ts index 5789adbe6..9038bc655 100644 --- a/ts/fixtures/lang/iters/expected/core/option.ts +++ b/ts/fixtures/lang/iters/expected/core/option.ts @@ -1,39 +1,39 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Badge from "../iters.Badge.ts"; import type * as Quarter from "../iters.Quarter.ts"; import type * as Tilt from "../iters.Tilt.ts"; -export function unwrapOr$0k15iai(self: rt.char | undefined, default_: rt.char): rt.char { +export function unwrapOr$04rqm9m(self: rs.char | undefined, default_: rs.char): rs.char { if (self === undefined) { return default_; } return self; } -export function unwrapOr$00uis1j(self: rt.i64 | undefined, default_: rt.i64): rt.i64 { +export function unwrapOr$00tqxtm(self: rs.i64 | undefined, default_: rs.i64): rs.i64 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$14m5xjm(self: [rt.usize, rt.u8] | undefined, default_: [rt.usize, rt.u8]): [rt.usize, rt.u8] { +export function unwrapOr$1g3ltyz(self: [rs.usize, rs.u8] | undefined, default_: [rs.usize, rs.u8]): [rs.usize, rs.u8] { if (self === undefined) { return default_; } return self; } -export function unwrapOr$1tvry1i(self: rt.u64 | undefined, default_: rt.u64): rt.u64 { +export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs.u64 { if (self === undefined) { return default_; } @@ -47,9 +47,9 @@ export function unwrapOrDefault$165pyh5(self: string | undefined): string { return self; } -export function unwrapOrDefault$0wx44sw(self: rt.ByteVec | undefined): rt.ByteVec { +export function unwrapOrDefault$0w012ed(self: rs.ByteVec | undefined): rs.ByteVec { if (self === undefined) { - return new rt.ByteVec(); + return new rs.ByteVec(); } return self; } @@ -61,197 +61,197 @@ export function map$1uo1d4o(self: string | undefined, _: (a0: string) => string) return self; } -export function map$0xa8rra(self: rt.Vec | undefined, f: (a0: rt.Vec) => string): string | undefined { +export function map$1bpbukm(self: rs.Vec | undefined, f: (a0: rs.Vec) => string): string | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$00b7lvf(self: rt.StrCow | undefined, _: (a0: rt.StrCow) => string): string | undefined { +export function map$167hjon(self: rs.StrCow | undefined, _: (a0: rs.StrCow) => string): string | undefined { if (self === undefined) { return undefined; } - return rt.strCowStr(self); + return rs.strCowStr(self); } -export function map$0of9gds(self: rt.u8 | undefined, f: (a0: rt.u8) => Badge.Badge): Badge.Badge | undefined { +export function map$0vu84i0(self: rs.u8 | undefined, f: (a0: rs.u8) => Badge.Badge): Badge.Badge | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1c7zybz(self: rt.u8 | undefined, _: (a0: rt.u8) => rt.u32): rt.u32 | undefined { +export function map$1806e7m(self: rs.u8 | undefined, _: (a0: rs.u8) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } - return self as rt.u32; + return self as rs.u32; } -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0p22lts(self: rt.u8 | undefined, f: (a0: rt.u8) => undefined): undefined | rt.None { +export function map$057a36e(self: rs.u8 | undefined, f: (a0: rs.u8) => undefined): undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } f(self); return undefined; } -export function map$05nbzug(self: rt.usize | undefined, f: (a0: rt.usize) => rt.u8): rt.u8 | undefined { +export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$0lcrgk1(self: string | undefined, default_: rt.u8, f: (a0: string) => rt.u8): rt.u8 { +export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0zwtv9w(self: rt.Vec | undefined, default_: rt.u8, f: (a0: rt.Vec) => rt.u8): rt.u8 { +export function mapOr$127irwp(self: rs.Vec | undefined, default_: rs.u8, f: (a0: rs.Vec) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1a3irjf(self: rt.ByteVec | undefined, default_: rt.u8, f: (a0: rt.ByteVec) => rt.u8): rt.u8 { +export function mapOr$0g5x999(self: rs.ByteVec | undefined, default_: rs.u8, f: (a0: rs.ByteVec) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0sl5app(self: Uint8Array | undefined, default_: rt.u8, f: (a0: Uint8Array) => rt.u8): rt.u8 { +export function mapOr$1i4rvy8(self: Uint8Array | undefined, default_: rs.u8, f: (a0: Uint8Array) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0atjiti(self: rt.char | undefined, default_: rt.u32, _: (a0: rt.char) => rt.u32): rt.u32 { +export function mapOr$0yzb10z(self: rs.char | undefined, default_: rs.u32, _: (a0: rs.char) => rs.u32): rs.u32 { if (self === undefined) { return default_; } - return self as rt.u32; + return self as rs.u32; } -export function mapOr$0okqj9y(self: rt.char | undefined, default_: rt.u8, f: (a0: rt.char) => rt.u8): rt.u8 { +export function mapOr$041x3r2(self: rs.char | undefined, default_: rs.u8, f: (a0: rs.char) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1lznlgz(self: Quarter.Quarter | undefined, default_: rt.u8, f: (a0: Quarter.Quarter) => rt.u8): rt.u8 { +export function mapOr$0dfpyun(self: Quarter.Quarter | undefined, default_: rs.u8, f: (a0: Quarter.Quarter) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0tmtgfi(self: Tilt.Tilt | undefined, default_: rt.u8, f: (a0: Tilt.Tilt) => rt.u8): rt.u8 { +export function mapOr$0p9po8x(self: Tilt.Tilt | undefined, default_: rs.u8, f: (a0: Tilt.Tilt) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0ev76sb(self: rt.Place | undefined, default_: rt.u8, f: (a0: rt.Place) => rt.u8): rt.u8 { +export function mapOr$02sqh24(self: rs.Place | undefined, default_: rs.u8, f: (a0: rs.Place) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0a96v80(self: [rt.ByteSlice, [rt.usize, rt.u8]] | undefined, default_: rt.u8, f: (a0: [rt.ByteSlice, [rt.usize, rt.u8]]) => rt.u8): rt.u8 { +export function mapOr$0llggqq(self: [rs.ByteSlice, [rs.usize, rs.u8]] | undefined, default_: rs.u8, f: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1vjqo89(self: [rt.u8, rt.ByteSlice] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.ByteSlice]) => rt.u8): rt.u8 { +export function mapOr$1ifh11y(self: [rs.u8, rs.ByteSlice] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.ByteSlice]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1h04da8(self: [rt.u8, [rt.u8, rt.usize]] | undefined, default_: rt.u8, f: (a0: [rt.u8, [rt.u8, rt.usize]]) => rt.u8): rt.u8 { +export function mapOr$1r07vli(self: [rs.u8, [rs.u8, rs.usize]] | undefined, default_: rs.u8, f: (a0: [rs.u8, [rs.u8, rs.usize]]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0f73bb7(self: [rt.u8, [rt.usize, rt.ByteSlice]] | undefined, default_: rt.u8, f: (a0: [rt.u8, [rt.usize, rt.ByteSlice]]) => rt.u8): rt.u8 { +export function mapOr$0olig48(self: [rs.u8, [rs.usize, rs.ByteSlice]] | undefined, default_: rs.u8, f: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0mmpeqx(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$06gg5x7(self: [rt.usize, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.usize, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$0i0fno7(self: [rs.usize, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.usize, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1dmz9kd(self: [rt.usize, [rt.u8, rt.ByteSlice]] | undefined, default_: rt.u8, f: (a0: [rt.usize, [rt.u8, rt.ByteSlice]]) => rt.u8): rt.u8 { +export function mapOr$17ts8jj(self: [rs.usize, [rs.u8, rs.ByteSlice]] | undefined, default_: rs.u8, f: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1sxa8ki(self: rt.u32 | undefined, default_: rt.u8, f: (a0: rt.u32) => rt.u8): rt.u8 { +export function mapOr$07pvkk0(self: rs.u32 | undefined, default_: rs.u8, f: (a0: rs.u32) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -264,15 +264,15 @@ export function asDeref$0w8at8i(self: string | undefined): string | undefined { }); } -export function asDeref$1qc2lbh(self: rt.StrCow | undefined): string | undefined { - return map$00b7lvf(self, (a0: rt.StrCow): string => { - return rt.strCowStr(a0); +export function asDeref$0pg0e8a(self: rs.StrCow | undefined): string | undefined { + return map$167hjon(self, (a0: rs.StrCow): string => { + return rs.strCowStr(a0); }); } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } diff --git a/ts/fixtures/lang/iters/expected/core/result.ts b/ts/fixtures/lang/iters/expected/core/result.ts index 9f3171569..baa84c2c2 100644 --- a/ts/fixtures/lang/iters/expected/core/result.ts +++ b/ts/fixtures/lang/iters/expected/core/result.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$01jdcm7(self: rt.Result, default_: string): string { +export function unwrapOr$0a3q6xs(self: rs.Result, default_: string): string { if (self.ok) { return self.value; } diff --git a/ts/fixtures/lang/iters/expected/harness.ts b/ts/fixtures/lang/iters/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/iters/expected/harness.ts +++ b/ts/fixtures/lang/iters/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/iters/expected/iters.Bag.ts b/ts/fixtures/lang/iters/expected/iters.Bag.ts index e7c80e467..57b8e8166 100644 --- a/ts/fixtures/lang/iters/expected/iters.Bag.ts +++ b/ts/fixtures/lang/iters/expected/iters.Bag.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Phase from "./iters.Phase.ts"; /** A pair that iterates as a `Phase` from each. */ export interface Bag { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } -export function intoIter$iter_IntoIterator(self: Bag): rt.Iter { +export function intoIter$iter_IntoIterator(self: Bag): rs.Iter { const _2: Phase.Phase = Phase.of(self._0); const _4: Phase.Phase = Phase.of(self._1); - return rt.iterChain(rt.iterFrom({ v: _2 }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterFrom({ v: _4 }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); + return rs.iterChain(rs.iterFrom({ v: _2 }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _4 }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); } //# sourceMappingURL=iters.Bag.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Bumped.ts b/ts/fixtures/lang/iters/expected/iters.Bumped.ts index a082fc501..0037a72dd 100644 --- a/ts/fixtures/lang/iters/expected/iters.Bumped.ts +++ b/ts/fixtures/lang/iters/expected/iters.Bumped.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` type whose `Clone` does more than copy. */ export interface Bumped { - _0: rt.u8; + _0: rs.u8; } export function clone$Clone(self: Bumped): Bumped { - return { _0: rt.u8WrappingAdd(self._0, 1) }; + return { _0: rs.u8WrappingAdd(self._0, 1) }; } //# sourceMappingURL=iters.Bumped.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Countdown.ts b/ts/fixtures/lang/iters/expected/iters.Countdown.ts index 98d8053a9..9d637c49d 100644 --- a/ts/fixtures/lang/iters/expected/iters.Countdown.ts +++ b/ts/fixtures/lang/iters/expected/iters.Countdown.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A countdown: the crate's own iterator. */ export interface Countdown { - left: rt.u8; - step: rt.u8; + left: rs.u8; + step: rs.u8; } -export function next$iter_Iterator(self: Countdown): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Countdown): rs.u8 | rs.Done { if (self.left === 0) { - return rt.DONE; + return rs.DONE; } - const left: rt.u8 = self.left; - self.left = rt.u8SaturatingSub(left, self.step); + const left: rs.u8 = self.left; + self.left = rs.u8SaturatingSub(left, self.step); return left; } diff --git a/ts/fixtures/lang/iters/expected/iters.Doubled.ts b/ts/fixtures/lang/iters/expected/iters.Doubled.ts index 590455c24..df672b6b8 100644 --- a/ts/fixtures/lang/iters/expected/iters.Doubled.ts +++ b/ts/fixtures/lang/iters/expected/iters.Doubled.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Each byte doubled, as a `Debug` list built from an iterator. */ export interface Doubled { @@ -9,12 +9,12 @@ export interface Doubled { _0Len: number; } -export function fmt$fmt_Debug(self: Doubled, f: rt.Formatter): rt.Result { - const _5: rt.DebugList = rt.fmtDebugList(f); - const _6: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(self._0Data, self._0Start, self._0Len))), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 2); +export function fmt$fmt_Debug(self: Doubled, f: rs.Formatter): rs.Result { + const _5: rs.DebugList = rs.fmtDebugList(f); + const _6: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(self._0Data, self._0Start, self._0Len))), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 2); }); - return rt.debugListFinish(rt.debugListEntries(_5, _6, rt.u16Debug)); + return rs.debugListFinish(rs.debugListEntries(_5, _6, rs.u16Debug)); } //# sourceMappingURL=iters.Doubled.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Evens.ts b/ts/fixtures/lang/iters/expected/iters.Evens.ts index b92e1a20c..94f994d3d 100644 --- a/ts/fixtures/lang/iters/expected/iters.Evens.ts +++ b/ts/fixtures/lang/iters/expected/iters.Evens.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The even bytes, read through another iterator, whose `None` ends this one. */ export interface Evens { - inner: rt.Iter; + inner: rs.Iter; } -export function next$iter_Iterator(self: Evens): rt.u8 | rt.Done { +export function next$iter_Iterator(self: Evens): rs.u8 | rs.Done { while (true) { - const _2: rt.u8 | rt.Done = self.inner.next(); - if (_2 !== rt.DONE) { - const b: rt.u8 = _2; - if (rt.u8Rem(b, 2) === 0) { + const _2: rs.u8 | rs.Done = self.inner.next(); + if (_2 !== rs.DONE) { + const b: rs.u8 = _2; + if (rs.u8Rem(b, 2) === 0) { return b; } } else { break; } } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=iters.Evens.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Gaps.ts b/ts/fixtures/lang/iters/expected/iters.Gaps.ts index 416a7da17..34e1de29b 100644 --- a/ts/fixtures/lang/iters/expected/iters.Gaps.ts +++ b/ts/fixtures/lang/iters/expected/iters.Gaps.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Every byte, or `None` where it is zero. */ export interface Gaps { dataData: Uint8Array; dataStart: number; dataLen: number; - at: rt.usize; + at: rs.usize; } -export function next$iter_Iterator(self: Gaps): rt.u8 | undefined | rt.Done { - const _3: rt.u8 | undefined = rt.byteSliceGet(new rt.ByteSlice(self.dataData, self.dataStart, self.dataLen), self.at); +export function next$iter_Iterator(self: Gaps): rs.u8 | undefined | rs.Done { + const _3: rs.u8 | undefined = rs.byteSliceGet(new rs.ByteSlice(self.dataData, self.dataStart, self.dataLen), self.at); if (_3 !== undefined) { - const b: rt.u8 = _3; - self.at = rt.usizeAdd(self.at, 1); + const b: rs.u8 = _3; + self.at = rs.usizeAdd(self.at, 1); if (!(b === 0)) { return b; } return undefined; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=iters.Gaps.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Halving.ts b/ts/fixtures/lang/iters/expected/iters.Halving.ts index ce2f4d72f..eef813354 100644 --- a/ts/fixtures/lang/iters/expected/iters.Halving.ts +++ b/ts/fixtures/lang/iters/expected/iters.Halving.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; /** A value halved until it is zero: generic, with an `impl Iterator` per instance. */ export class Halving { @@ -12,18 +12,18 @@ export class Halving { } } -export function next$iter_Iterator_u8(self: Halving): rt.u8 | rt.Done { - const value: rt.u8 = self.value; - self.value = rt.u8Div(self.value, 2); - return rt.iterFromOption(thenSome$0d5am30(value !== 0, value)); +export function next$iter_Iterator_u8(self: Halving): rs.u8 | rs.Done { + const value: rs.u8 = self.value; + self.value = rs.u8Div(self.value, 2); + return rs.iterFromOption(thenSome$0quywni(value !== 0, value)); } -export function next$iter_Iterator_u64(self: Halving): rt.u64 | rt.Done { +export function next$iter_Iterator_u64(self: Halving): rs.u64 | rs.Done { if (self.value === 0) { - return rt.DONE; + return rs.DONE; } - const value: rt.u64 = self.value; - self.value = rt.u64Shr(value, 1); + const value: rs.u64 = self.value; + self.value = rs.u64Shr(value, 1); return value; } diff --git a/ts/fixtures/lang/iters/expected/iters.Held.ts b/ts/fixtures/lang/iters/expected/iters.Held.ts index 09132b4fd..7ba74a6a2 100644 --- a/ts/fixtures/lang/iters/expected/iters.Held.ts +++ b/ts/fixtures/lang/iters/expected/iters.Held.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** An iterator in a field. */ export interface Held { - it: rt.Iter; + it: rs.Iter; } -export function skipOne(self: Held): rt.u8 { +export function skipOne(self: Held): rs.u8 { self.it.next(); - return option_unwrapOr$0r2bmpr(rt.iterToOption(self.it.next()), 187); + return option_unwrapOr$1fr498u(rs.iterToOption(self.it.next()), 187); } //# sourceMappingURL=iters.Held.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Logged.ts b/ts/fixtures/lang/iters/expected/iters.Logged.ts index 09d1908e5..2d1db348d 100644 --- a/ts/fixtures/lang/iters/expected/iters.Logged.ts +++ b/ts/fixtures/lang/iters/expected/iters.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct that logs what it has left as it drops. */ export class Logged { - left: rt.u8; - log: rt.RefCell; + left: rs.u8; + log: rs.RefCell; - constructor(left: rt.u8, log: rt.RefCell) { + constructor(left: rs.u8, log: rs.RefCell) { this.left = left; this.log = log; } @@ -17,19 +17,19 @@ export class Logged { } } -export function next$iter_Iterator(self: Logged): rt.u8 | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self.left, 1); +export function next$iter_Iterator(self: Logged): rs.u8 | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self.left, 1); if (_2 !== undefined) { self.left = _2; - return rt.u8Add(self.left, 64); + return rs.u8Add(self.left, 64); } - return rt.DONE; + return rs.DONE; } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, 128 | self.left); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, 128 | self.left); + rs.refMutRelease(_5); } //# sourceMappingURL=iters.Logged.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Noted.ts b/ts/fixtures/lang/iters/expected/iters.Noted.ts index 07a5bc63d..dfda570d1 100644 --- a/ts/fixtures/lang/iters/expected/iters.Noted.ts +++ b/ts/fixtures/lang/iters/expected/iters.Noted.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What logs a byte as it drops. */ export class Noted { - _0: rt.RefCell; - _1: rt.u8; + _0: rs.RefCell; + _1: rs.u8; - constructor(_0: rt.RefCell, _1: rt.u8) { + constructor(_0: rs.RefCell, _1: rs.u8) { this._0 = _0; this._1 = _1; } @@ -18,9 +18,9 @@ export class Noted { } export function drop$ops_Drop(self: Noted): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._0); - rt.byteVecPush(_5.value, self._1); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._0); + rs.byteVecPush(_5.value, self._1); + rs.refMutRelease(_5); } //# sourceMappingURL=iters.Noted.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Phase.ts b/ts/fixtures/lang/iters/expected/iters.Phase.ts index 46e1ff25e..50fa6b854 100644 --- a/ts/fixtures/lang/iters/expected/iters.Phase.ts +++ b/ts/fixtures/lang/iters/expected/iters.Phase.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0d5am30 } from "./core/bool.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0quywni } from "./core/bool.ts"; /** A countdown whose JS value is a string: each step a variant. */ export type Phase = "Three" | "Two" | "One" | "Done"; -export function of(b: rt.u8): Phase { - const _7: rt.usize = rt.u8Rem(b, 4) as rt.usize; +export function of(b: rs.u8): Phase { + const _7: rs.usize = rs.u8Rem(b, 4) as rs.usize; if (!(_7 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _7); } return ["Three" as Phase, "Two" as Phase, "One" as Phase, "Done" as Phase][_7]; } -export function left(self: Phase): rt.u8 { +export function left(self: Phase): rs.u8 { if (self === "Three") { return 3; } @@ -27,9 +27,9 @@ export function left(self: Phase): rt.u8 { return 0; } -export function next$iter_Iterator(self: rt.Place): rt.u8 | rt.Done { +export function next$iter_Iterator(self: rs.Place): rs.u8 | rs.Done { let _4!: Phase; - const left_: rt.u8 = left(self.v); + const left_: rs.u8 = left(self.v); if (self.v === "Three") { _4 = "Two" as Phase; } else if (self.v === "Two") { @@ -38,23 +38,23 @@ export function next$iter_Iterator(self: rt.Place): rt.u8 | rt.Done { _4 = "Done" as Phase; } self.v = _4; - return rt.iterFromOption(thenSome$0d5am30(left_ !== 0, left_)); + return rs.iterFromOption(thenSome$0quywni(left_ !== 0, left_)); } -export function sizeHint$iter_Iterator(self: Phase): [rt.usize, rt.usize | undefined] { - const left_: rt.usize = left(self) as rt.usize; - return [left_, left_] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator(self: Phase): [rs.usize, rs.usize | undefined] { + const left_: rs.usize = left(self) as rs.usize; + return [left_, left_] as [rs.usize, rs.usize | undefined]; } -export function count$iter_Iterator(self: Phase): rt.usize { - return rt.usizeAdd(left(self) as rt.usize, 10); +export function count$iter_Iterator(self: Phase): rs.usize { + return rs.usizeAdd(left(self) as rs.usize, 10); } /** From the back, it counts up, ending where the front would. */ -export function nextBack$iter_DoubleEndedIterator(self: rt.Place): rt.u8 | undefined { - const left_: rt.u8 = left(self.v); - self.v = of(rt.u8Add(rt.u8Sub(4, rt.min(left_, 3)), 1)); - return thenSome$0d5am30(left_ !== 0, rt.u8Sub(4, left_)); +export function nextBack$iter_DoubleEndedIterator(self: rs.Place): rs.u8 | undefined { + const left_: rs.u8 = left(self.v); + self.v = of(rs.u8Add(rs.u8Sub(4, rs.min(left_, 3)), 1)); + return thenSome$0quywni(left_ !== 0, rs.u8Sub(4, left_)); } //# sourceMappingURL=iters.Phase.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Quarter.ts b/ts/fixtures/lang/iters/expected/iters.Quarter.ts index eb50ca0a1..1569fe632 100644 --- a/ts/fixtures/lang/iters/expected/iters.Quarter.ts +++ b/ts/fixtures/lang/iters/expected/iters.Quarter.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A byte that equals a `u8` of the same remainder by 4, counting each comparison. */ export interface Quarter { - _0: rt.u8; - _1: rt.Cell; + _0: rs.u8; + _1: rs.Cell; } -export function eq$cmp_PartialEq_u8(self: Quarter, other: rt.u8): boolean { - rt.cellSet(self._1, rt.u8WrappingAdd(self._1.v, 1)); - return rt.u8Rem(self._0, 4) === rt.u8Rem(other, 4); +export function eq$cmp_PartialEq_u8(self: Quarter, other: rs.u8): boolean { + rs.cellSet(self._1, rs.u8WrappingAdd(self._1.v, 1)); + return rs.u8Rem(self._0, 4) === rs.u8Rem(other, 4); } //# sourceMappingURL=iters.Quarter.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Tag.ts b/ts/fixtures/lang/iters/expected/iters.Tag.ts index 8eec61d40..9ad205bed 100644 --- a/ts/fixtures/lang/iters/expected/iters.Tag.ts +++ b/ts/fixtures/lang/iters/expected/iters.Tag.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Tag): Tag { - return { bytes: rt.byteVecFrom(rt.byteVecView(self.bytes)) }; + return { bytes: rs.byteVecFrom(rs.byteVecView(self.bytes)) }; } /** A `Clone` that is not `Copy`, which `cloned` calls for each item. */ export interface Tag { - bytes: rt.ByteVec; + bytes: rs.ByteVec; } //# sourceMappingURL=iters.Tag.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Ticks.ts b/ts/fixtures/lang/iters/expected/iters.Ticks.ts index ffe67f56a..9ff2a485a 100644 --- a/ts/fixtures/lang/iters/expected/iters.Ticks.ts +++ b/ts/fixtures/lang/iters/expected/iters.Ticks.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$iters_Ticks } from "./lib.ts"; import type * as Noted from "./iters.Noted.ts"; @@ -8,21 +8,21 @@ import type * as Noted from "./iters.Noted.ts"; * An enum with a field, whose JS value is an object a `&mut` replaces, and which drops * what it holds. */ -export type Ticks = { tag: "Left"; _0: rt.u8; _1: Noted.Noted } | { tag: "Done" }; +export type Ticks = { tag: "Left"; _0: rs.u8; _1: Noted.Noted } | { tag: "Done" }; -export function next$iter_Iterator(self: rt.Place): rt.u8 | rt.Done { +export function next$iter_Iterator(self: rs.Place): rs.u8 | rs.Done { if (self.v.tag === "Left") { if (self.v._0 === 0) { - self.v._1._1 = rt.u8Add(self.v._1._1, 1); + self.v._1._1 = rs.u8Add(self.v._1._1, 1); drop$iters_Ticks(self.v); self.v = { tag: "Done" } as Ticks; - return rt.DONE; + return rs.DONE; } - self.v._0 = rt.u8Sub(self.v._0, 1); - self.v._1._1 = rt.u8Add(self.v._1._1, 1); + self.v._0 = rs.u8Sub(self.v._0, 1); + self.v._1._1 = rs.u8Add(self.v._1._1, 1); return self.v._0; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=iters.Ticks.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Tilt.ts b/ts/fixtures/lang/iters/expected/iters.Tilt.ts index 534691f73..b72c74bbe 100644 --- a/ts/fixtures/lang/iters/expected/iters.Tilt.ts +++ b/ts/fixtures/lang/iters/expected/iters.Tilt.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * An order whose `cmp` leans on its first operand, an odd one less than any, so which * operand std's `min_by_key`, `max_by_key`, `min`, and `max` put first shows. */ export interface Tilt { - _0: rt.u8; + _0: rs.u8; } -export function partialCmp$cmp_PartialOrd(self: Tilt, other: Tilt): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Tilt, other: Tilt): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Tilt, other: Tilt): rt.Ordering { - if (rt.u8Rem(self._0, 2) === 1) { +export function cmp$cmp_Ord(self: Tilt, other: Tilt): rs.Ordering { + if (rs.u8Rem(self._0, 2) === 1) { return -1; } - return rt.cmp(self._0, other._0); + return rs.cmp(self._0, other._0); } //# sourceMappingURL=iters.Tilt.ts.map diff --git a/ts/fixtures/lang/iters/expected/iters.Weighed.ts b/ts/fixtures/lang/iters/expected/iters.Weighed.ts index 82c67565d..6d31f254d 100644 --- a/ts/fixtures/lang/iters/expected/iters.Weighed.ts +++ b/ts/fixtures/lang/iters/expected/iters.Weighed.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { filter$0v80fk8 } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { filter$0hq86nl } from "./core/option.ts"; /** The bytes up to the first multiple of 3, weighing each as it returns it. */ export interface Weighed { - inner: rt.Iter; - weight: rt.u8; + inner: rs.Iter; + weight: rs.u8; } -export function next$iter_Iterator(self: Weighed): rt.u8 | rt.Done { - const item: rt.u8 | rt.Done = rt.iterFromOption(filter$0v80fk8(rt.iterToOption(self.inner.next()), (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 3) !== 0; +export function next$iter_Iterator(self: Weighed): rs.u8 | rs.Done { + const item: rs.u8 | rs.Done = rs.iterFromOption(filter$0hq86nl(rs.iterToOption(self.inner.next()), (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 3) !== 0; })); - if (item === rt.DONE) { - self.weight = rt.u8WrappingAdd(self.weight, 174); + if (item === rs.DONE) { + self.weight = rs.u8WrappingAdd(self.weight, 174); return item; } - self.weight = rt.u8WrappingAdd(self.weight, item); + self.weight = rs.u8WrappingAdd(self.weight, item); return item; } diff --git a/ts/fixtures/lang/iters/expected/iters.ts b/ts/fixtures/lang/iters/expected/iters.ts index ffa5ceea4..721a98ebf 100644 --- a/ts/fixtures/lang/iters/expected/iters.ts +++ b/ts/fixtures/lang/iters/expected/iters.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$iters_Ticks, of$u8 } from "./lib.ts"; -import { thenSome$185ufyt, thenSome$0b23a33, thenSome$0d5am30, thenSome$1j8foe9 } from "./core/bool.ts"; -import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$00uis1j as option_unwrapOr$00uis1j, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$14m5xjm as option_unwrapOr$14m5xjm, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw as option_unwrapOrDefault$0wx44sw, map$1uo1d4o as option_map$1uo1d4o, map$0xa8rra as option_map$0xa8rra, map$0of9gds as option_map$0of9gds, map$1c7zybz as option_map$1c7zybz, map$0cs071d as option_map$0cs071d, map$0p22lts as option_map$0p22lts, map$05nbzug as option_map$05nbzug, mapOr$0lcrgk1 as option_mapOr$0lcrgk1, mapOr$0zwtv9w as option_mapOr$0zwtv9w, mapOr$1a3irjf as option_mapOr$1a3irjf, mapOr$0sl5app as option_mapOr$0sl5app, mapOr$0atjiti as option_mapOr$0atjiti, mapOr$0okqj9y as option_mapOr$0okqj9y, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$1lznlgz as option_mapOr$1lznlgz, mapOr$0tmtgfi as option_mapOr$0tmtgfi, mapOr$0ev76sb as option_mapOr$0ev76sb, mapOr$1surhce as option_mapOr$1surhce, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$0a96v80 as option_mapOr$0a96v80, mapOr$1vjqo89 as option_mapOr$1vjqo89, mapOr$1h04da8 as option_mapOr$1h04da8, mapOr$0f73bb7 as option_mapOr$0f73bb7, mapOr$0mmpeqx as option_mapOr$0mmpeqx, mapOr$06gg5x7 as option_mapOr$06gg5x7, mapOr$1dmz9kd as option_mapOr$1dmz9kd, mapOr$1sxa8ki as option_mapOr$1sxa8ki, mapOr$02k4ito as option_mapOr$02k4ito, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$1qc2lbh as option_asDeref$1qc2lbh, filter$0v80fk8 } from "./core/option.ts"; -import { unwrapOr$01jdcm7 as result_unwrapOr$01jdcm7 } from "./core/result.ts"; +import { thenSome$1ctlqen, thenSome$1gvhopg, thenSome$0quywni, thenSome$1n1oy1h } from "./core/bool.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$00tqxtm as option_unwrapOr$00tqxtm, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$1g3ltyz as option_unwrapOr$1g3ltyz, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$1uo1d4o as option_map$1uo1d4o, map$1bpbukm as option_map$1bpbukm, map$0vu84i0 as option_map$0vu84i0, map$1806e7m as option_map$1806e7m, map$1yjmt5m as option_map$1yjmt5m, map$057a36e as option_map$057a36e, map$14ju55r as option_map$14ju55r, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$127irwp as option_mapOr$127irwp, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1i4rvy8 as option_mapOr$1i4rvy8, mapOr$0yzb10z as option_mapOr$0yzb10z, mapOr$041x3r2 as option_mapOr$041x3r2, mapOr$14runhi as option_mapOr$14runhi, mapOr$0dfpyun as option_mapOr$0dfpyun, mapOr$0p9po8x as option_mapOr$0p9po8x, mapOr$02sqh24 as option_mapOr$02sqh24, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$0llggqq as option_mapOr$0llggqq, mapOr$1ifh11y as option_mapOr$1ifh11y, mapOr$1r07vli as option_mapOr$1r07vli, mapOr$0olig48 as option_mapOr$0olig48, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0i0fno7 as option_mapOr$0i0fno7, mapOr$17ts8jj as option_mapOr$17ts8jj, mapOr$07pvkk0 as option_mapOr$07pvkk0, mapOr$188iunt as option_mapOr$188iunt, asDeref$0w8at8i as option_asDeref$0w8at8i, asDeref$0pg0e8a as option_asDeref$0pg0e8a, filter$0hq86nl } from "./core/option.ts"; +import { unwrapOr$0a3q6xs as result_unwrapOr$0a3q6xs } from "./core/result.ts"; import type * as Badge from "./iters.Badge.ts"; import * as Bag from "./iters.Bag.ts"; import * as Bumped from "./iters.Bumped.ts"; @@ -25,95 +25,95 @@ import * as Weighed from "./iters.Weighed.ts"; import * as Wrapper from "./iters.Wrapper.ts"; /** Adaptor chains over the input bytes, each consumed one way. */ -export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function adaptors(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { b0: { - const _4: rt.u8 = rt.u8Rem(kind, 8); + const _4: rs.u8 = rs.u8Rem(kind, 8); if (_4 === 0) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): rt.u8 => { - return rt.u8Div(_217, 2); - }), (b11: rt.u8): boolean => { - return rt.u8Rem(b11, 3) !== 0; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_217: rs.u8): rs.u8 => { + return rs.u8Div(_217, 2); + }), (b11: rs.u8): boolean => { + return rs.u8Rem(b11, 3) !== 0; }), "next"))); - for (const _18 of rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.u16 | undefined => { - const b12: rt.u8 = _218; - return thenSome$0b23a33(b12 < 100, rt.u16Mul(b12 as rt.u16, 200)); + for (const _18 of rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.u16 | undefined => { + const b12: rs.u8 = _218; + return thenSome$1gvhopg(b12 < 100, rs.u16Mul(b12 as rs.u16, 200)); }), "next", 2).items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_18))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_18))); } } else { if (_4 === 1) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterStepBy(rt.iterSkip(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), 1), 2); + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterStepBy(rs.iterSkip(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), 1), 2); while (true) { - const _32: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_32 === rt.DONE) { + const _32: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_32 === rs.DONE) { break; } - const i: rt.usize = _32[0]; - const b: rt.u8 = _32[1]; - rt.byteVecPush(out, i & 0xff); - rt.byteVecPush(out, b); + const i: rs.usize = _32[0]; + const b: rs.u8 = _32[1]; + rs.byteVecPush(out, i & 0xff); + rs.byteVecPush(out, b); } - const iter3: rt.Iter<[rt.usize, rt.u8]> = rt.iterTake(rt.iterEnumerate(rt.iterRev(rt.iterSlice(rt.byteSliceView(data)))), 3); + const iter3: rs.Iter<[rs.usize, rs.u8]> = rs.iterTake(rs.iterEnumerate(rs.iterRev(rs.iterSlice(rs.byteSliceView(data)))), 3); while (true) { - const _46: [rt.usize, rt.u8] | rt.Done = iter3.next(); - if (_46 === rt.DONE) { + const _46: [rs.usize, rs.u8] | rs.Done = iter3.next(); + if (_46 === rs.DONE) { break b0; } - rt.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); + rs.byteVecPush(out, (_46[0] & 0xff) ^ _46[1]); } } if (_4 === 2) { - const mid: number = rt.usizeDiv(data.length, 2); + const mid: number = rs.usizeDiv(data.length, 2); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const front: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid); - const back: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid, data.length - mid); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(front)), rt.iterRev(rt.iterSlice(rt.byteSliceView(back))), "len"), (_216: [rt.u8, rt.u8]): rt.u8 => { + const front: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid); + const back: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid, data.length - mid); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(front)), rs.iterRev(rs.iterSlice(rs.byteSliceView(back))), "len"), (_216: [rs.u8, rs.u8]): rs.u8 => { return _216[0] ^ _216[1]; }), undefined, true))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterChain(rt.iterSlice(rt.byteSliceView(front)), rt.iterSlice(rt.byteSliceView(back)))), undefined, true))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterRev(rs.iterChain(rs.iterSlice(rs.byteSliceView(front)), rs.iterSlice(rs.byteSliceView(back)))), undefined, true))); } else if (_4 === 3) { - const taken: rt.ByteVec = rt.iterToByteVec(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): boolean => { + const taken: rs.ByteVec = rs.iterToByteVec(rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): boolean => { return _213 !== 0; }), "next"); - const skipped: rt.ByteVec = rt.iterToByteVec(rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): boolean => { + const skipped: rs.ByteVec = rs.iterToByteVec(rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): boolean => { return _214 < 128; }), "next"); - const mapped: rt.ByteVec = rt.iterToByteVec(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedAdd(_215, 64); + const mapped: rs.ByteVec = rs.iterToByteVec(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedAdd(_215, 64); }), "next"); - rt.byteVecPush(out, taken.length & 0xff); - rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(mapped)); + rs.byteVecPush(out, taken.length & 0xff); + rs.byteVecPush(out, skipped.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(mapped)); } else if (_4 === 4) { - const words: rt.Vec = chunksByZero$iters_ChunksByZero_slice_u8(data); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(words.items), (w: rt.ByteVec): rt.Iter => { - return rt.iterRev(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w)))); + const words: rs.Vec = chunksByZero$iters_ChunksByZero_slice_u8(data); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(words.items), (w: rs.ByteVec): rs.Iter => { + return rs.iterRev(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w)))); }, undefined, true), "next"))); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterMap(rt.iterSlice(words.items), (w2: rt.ByteVec): rt.Iter => { - return rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(w2))), (_212: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(_212, 3); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFlatten(rs.iterMap(rs.iterSlice(words.items), (w2: rs.ByteVec): rs.Iter => { + return rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(w2))), (_212: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(_212, 3); }); }), undefined, true)), "next"); } else { if (_4 === 5) { - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); + const it: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _118: rt.u8 | rt.Done = it.next(); - if (_118 !== rt.DONE) { - const b2: rt.u8 = _118; - let run: rt.u8 = 1; - while (rt.peekableNextIf(it, (_211: rt.u8): boolean => { + const _118: rs.u8 | rs.Done = it.next(); + if (_118 !== rs.DONE) { + const b2: rs.u8 = _118; + let run: rs.u8 = 1; + while (rs.peekableNextIf(it, (_211: rs.u8): boolean => { return _211 === b2; }) !== undefined) { - run = rt.u8Add(run, 1); + run = rs.u8Add(run, 1); } - rt.byteVecPush(out, b2); - rt.byteVecPush(out, run); - const _133: rt.u8 | undefined = rt.peekablePeek(it); + rs.byteVecPush(out, b2); + rs.byteVecPush(out, run); + const _133: rs.u8 | undefined = rs.peekablePeek(it); if (_133 !== undefined) { - rt.byteVecPush(out, _133); + rs.byteVecPush(out, _133); } } else { break b0; @@ -121,41 +121,41 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } } if (_4 === 6) { - const it2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it2), 2), undefined, true))); - rt.byteVecPush(out, it2.len() & 0xff); - const _152: rt.u8 | undefined = rt.iterToOption(it2.nextBack()); + const it2: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it2), 2), undefined, true))); + rs.byteVecPush(out, it2.len() & 0xff); + const _152: rs.u8 | undefined = rs.iterToOption(it2.nextBack()); if (_152 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { - rt.byteVecPush(out, _152); + rs.byteVecPush(out, _152); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterStepBy(rt.iterRev(it2), 3), "next"))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterStepBy(rs.iterRev(it2), 3), "next"))); } else { - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Uint8Array => { - const b3: rt.u8 = _2; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Uint8Array => { + const b3: rs.u8 = _2; return Uint8Array.of(b3, ~b3 & 0xff); }), undefined, 2, true); - const copies: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); + const copies: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); if (!(copies.items.length === 0)) { - const _174: rt.ByteSlice = rt.byteSliceFrom(copies.items[rt.idx(copies.items, 0)]); + const _174: rs.ByteSlice = rs.byteSliceFrom(copies.items[rs.idx(copies.items, 0)]); _174.data[_174.start] = 85; } - const iter4: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(copies.items), rt.byteSliceFrom)); + const iter4: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(copies.items), rs.byteSliceFrom)); while (true) { - const _187: rt.ByteSlice | rt.Done = iter4.next(); - if (_187 === rt.DONE) { + const _187: rs.ByteSlice | rs.Done = iter4.next(); + if (_187 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _187); + rs.byteVecExtendFromSlice(out, _187); } - const v2: rt.Vec = new rt.Vec(); - const _196: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.u16 => { - return rt.u16Add(_22 as rt.u16, 1); + const v2: rs.Vec = new rs.Vec(); + const _196: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { + return rs.u16Add(_22 as rs.u16, 1); }); - rt.iterExtend(v2, _196, undefined, 2, true); - rt.byteVecPush(out, v2.items.length & 0xff); - rt.iterExtendBytes(out, rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { + rs.iterExtend(v2, _196, undefined, 2, true); + rs.byteVecPush(out, v2.items.length & 0xff); + rs.iterExtendBytes(out, rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): boolean => { return _210 > 128; }), "next"); } @@ -165,15 +165,15 @@ export function adaptors(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** The runs between zero bytes. */ -export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt.Vec { - const words: rt.Vec = new rt.Vec(); - let word: rt.ByteVec = new rt.ByteVec(); - for (const b of rt.byteSliceView(self)) { +export function chunksByZero$iters_ChunksByZero_slice_u8(self: rs.ByteSlice): rs.Vec { + const words: rs.Vec = new rs.Vec(); + let word: rs.ByteVec = new rs.ByteVec(); + for (const b of rs.byteSliceView(self)) { if (!(b === 0)) { - rt.byteVecPush(word, b); + rs.byteVecPush(word, b); } else { const taken = word; - word = new rt.ByteVec(); + word = new rs.ByteVec(); words.items.push(taken); } } @@ -182,226 +182,226 @@ export function chunksByZero$iters_ChunksByZero_slice_u8(self: rt.ByteSlice): rt } /** Consumers, and how far each reads: `log` records every item a closure sees. */ -export function consumers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.ByteVec = new rt.ByteVec(); - const _5: rt.u8 = rt.u8Rem(kind, 6); +export function consumers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.ByteVec = new rs.ByteVec(); + const _5: rs.u8 = rs.u8Rem(kind, 6); if (_5 === 0) { - rt.byteVecPush(out, rt.iterAny(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_228: rt.u8): undefined => { - rt.byteVecPush(log, _228); - }), (_229: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterAny(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_228: rs.u8): undefined => { + rs.byteVecPush(log, _228); + }), (_229: rs.u8): boolean => { return _229 > 240; }) ? 1 : 0); - rt.byteVecPush(out, rt.iterAll(rt.iterSlice(rt.byteSliceView(data)), (_230: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(rs.byteSliceView(data)), (_230: rs.u8): boolean => { return _230 !== 0; }) ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice(rt.byteSliceView(data))) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_231: rt.u8): boolean => { - return rt.u8Rem(_231, 2) === 0; + rs.byteVecPush(out, rs.iterCount(rs.iterSlice(rs.byteSliceView(data))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_231: rs.u8): boolean => { + return rs.u8Rem(_231, 2) === 0; })) & 0xff); } else if (_5 === 1) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterFind(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_220: rt.u8): undefined => { - rt.byteVecPush(log, _220); - }), (_221: rt.u8): boolean => { - return rt.u8Rem(_221, 7) === 3; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterFind(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_220: rs.u8): undefined => { + rs.byteVecPush(log, _220); + }), (_221: rs.u8): boolean => { + return rs.u8Rem(_221, 7) === 3; }), 255)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterFindMap(rt.iterSlice(rt.byteSliceView(data)), (_222: rt.u8): rt.u8 | undefined => { - const b14: rt.u8 = _222; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterFindMap(rs.iterSlice(rs.byteSliceView(data)), (_222: rs.u8): rs.u8 | undefined => { + const b14: rs.u8 = _222; if (!(b14 > 80)) { return undefined; } - return rt.u8CheckedMul(b14, 3); + return rs.u8CheckedMul(b14, 3); }), 0)); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterSlice(rt.byteSliceView(data)), (_223: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterSlice(rs.byteSliceView(data)), (_223: rs.u8): boolean => { return _223 === 64; - }), 255, (p: rt.usize): rt.u8 => { + }), 255, (p: rs.usize): rs.u8 => { return p & 0xff; })); - const short: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeDiv(data.length, 2)); - rt.byteVecPush(out, rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_224: rt.u8): rt.u8 => { - const b16: rt.u8 = _224; - rt.byteVecPush(log, b16); + const short: rs.ByteSlice = rs.byteSliceRange(data, rs.usizeDiv(data.length, 2)); + rs.byteVecPush(out, rs.iterCount(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_224: rs.u8): rs.u8 => { + const b16: rs.u8 = _224; + rs.byteVecPush(log, b16); return b16; - }), rt.iterSlice(rt.byteSliceView(short)), [true, false])) & 0xff); - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_225: rt.u8): rt.u8 => { - const b17: rt.u8 = _225; - rt.byteVecPush(log, ~b17 & 0xff); + }), rs.iterSlice(rs.byteSliceView(short)), [true, false])) & 0xff); + const iter: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_225: rs.u8): rs.u8 => { + const b17: rs.u8 = _225; + rs.byteVecPush(log, ~b17 & 0xff); return b17; - }), rt.iterSlice(rt.byteSliceView(short)), [true, false]); + }), rs.iterSlice(rs.byteSliceView(short)), [true, false]); while (true) { - const _69: [rt.u8, rt.u8] | rt.Done = iter.next(); - if (_69 === rt.DONE) { + const _69: [rs.u8, rs.u8] | rs.Done = iter.next(); + if (_69 === rs.DONE) { break; } - rt.byteVecPush(out, _69[0] ^ _69[1]); + rs.byteVecPush(out, _69[0] ^ _69[1]); } - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_226: rt.u8): undefined => { - rt.byteVecPush(log, _226); - }), (b19: rt.u8): rt.u8 => { + const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_226: rs.u8): undefined => { + rs.byteVecPush(log, _226); + }), (b19: rs.u8): rs.u8 => { return b19; - }), rt.iterSlice(rt.byteSliceView(short))); + }), rs.iterSlice(rs.byteSliceView(short))); while (true) { - const _85: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_85 === rt.DONE) { + const _85: [rs.u8, rs.u8] | rs.Done = iter2.next(); + if (_85 === rs.DONE) { break; } - rt.byteVecPush(out, _85[0] ^ _85[1]); + rs.byteVecPush(out, _85[0] ^ _85[1]); } - const back: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_227: rt.u8): rt.u8 => { + const back: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): rs.u8 => { return rotateFree$iters_RotateFree_u8(_227); - }), rt.iterSlice(rt.byteSliceView(short)), [true, false]); - const _97: [rt.u8, rt.u8] | undefined = rt.iterToOption(back.nextBack()); + }), rs.iterSlice(rs.byteSliceView(short)), [true, false]); + const _97: [rs.u8, rs.u8] | undefined = rs.iterToOption(back.nextBack()); if (_97 !== undefined) { - const a3: rt.u8 = _97[0]; - const b2: rt.u8 = _97[1]; - rt.byteVecPush(out, a3); - rt.byteVecPush(out, b2); + const a3: rs.u8 = _97[0]; + const b2: rs.u8 = _97[1]; + rs.byteVecPush(out, a3); + rs.byteVecPush(out, b2); } - rt.byteVecPush(out, back.len() & 0xff); + rs.byteVecPush(out, back.len() & 0xff); } else if (_5 === 2) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMax(rt.iterSlice(rt.byteSliceView(data)), rt.lt), 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMin(rt.iterSlice(rt.byteSliceView(data)), rt.lt), 255)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMaxByKey(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.u8 => { - return rt.u8Rem(_218, 16); - }, rt.lt), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMinByKey(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): rt.u8 => { - return rt.u8Div(_219, 16); - }, rt.lt), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterSlice(rt.byteSliceView(data))), 221)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.iterSlice(rt.byteSliceView(data)), 3), 204)); - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const _148: rt.Iter = it; - const _150: rt.usize = rt.usizeRem(data.length, 3); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNthBack(rt.iterTake(rt.iterBorrow(_148), _150), 1), 187)); - rt.byteVecPush(out, it.len() & 0xff); - const _163: rt.Iter = it; - const _165: rt.usize = rt.usizeRem(data.length, 5); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.iterTake(rt.iterBorrow(_163), _165), 2), 187)); - rt.byteVecPush(out, it.len() & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMax(rs.iterSlice(rs.byteSliceView(data)), rs.lt), 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMin(rs.iterSlice(rs.byteSliceView(data)), rs.lt), 255)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMaxByKey(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.u8 => { + return rs.u8Rem(_218, 16); + }, rs.lt), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMinByKey(rs.iterSlice(rs.byteSliceView(data)), (_219: rs.u8): rs.u8 => { + return rs.u8Div(_219, 16); + }, rs.lt), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterSlice(rs.byteSliceView(data))), 221)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterSlice(rs.byteSliceView(data)), 3), 204)); + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const _148: rs.Iter = it; + const _150: rs.usize = rs.usizeRem(data.length, 3); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNthBack(rs.iterTake(rs.iterBorrow(_148), _150), 1), 187)); + rs.byteVecPush(out, it.len() & 0xff); + const _163: rs.Iter = it; + const _165: rs.usize = rs.usizeRem(data.length, 5); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterTake(rs.iterBorrow(_163), _165), 2), 187)); + rs.byteVecPush(out, it.len() & 0xff); } else if (_5 === 3) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u64 => { - return rt.u64Mul(_214 as rt.u64, 1103823438081); - }), rt.u64Add, 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(rt.byteSliceView(data)), 0, (acc: rt.u32, _34: rt.u8): rt.u32 => { - return rt.u32WrappingAdd((acc << 3) >>> 0, ((_34 as rt.u32) ^ acc) >>> 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): rs.u64 => { + return rs.u64Mul(_214 as rs.u64, 1103823438081); + }), rs.u64Add, 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(rs.byteSliceView(data)), 0, (acc: rs.u32, _34: rs.u8): rs.u32 => { + return rs.u32WrappingAdd((acc << 3) >>> 0, ((_34 as rs.u32) ^ acc) >>> 0); })))); - rt.iterForEach(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): undefined => { - rt.byteVecPush(log, rotateFree$iters_RotateFree_u8(_216)); + rs.iterForEach(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): undefined => { + rs.byteVecPush(log, rotateFree$iters_RotateFree_u8(_216)); }); } else if (_5 === 4) { - rt.byteVecPush(out, rt.iterSum(rt.iterSlice(rt.byteSliceView(data)), rt.u8Add, 0)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterProduct(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): rt.u16 => { - return rt.u16Add(rt.u16Rem(_213 as rt.u16, 4), 1); - }), rt.u16Mul, 1)))); + rs.byteVecPush(out, rs.iterSum(rs.iterSlice(rs.byteSliceView(data)), rs.u8Add, 0)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterProduct(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): rs.u16 => { + return rs.u16Add(rs.u16Rem(_213 as rs.u16, 4), 1); + }), rs.u16Mul, 1)))); } else { - const parsed: rt.Result = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { - const b3: rt.u8 = _2; + const parsed: rs.Result = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { + const b3: rs.u8 = _2; if (!(b3 < 240)) { - return rt.Err(b3); + return rs.Err(b3); } - return rt.Ok(b3); - }), (values: rt.Iter) => rt.iterToByteVec(values)); + return rs.Ok(b3); + }), (values: rs.Iter) => rs.iterToByteVec(values)); if (parsed.ok) { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(parsed.value)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(parsed.value)); } else { - rt.byteVecPush(out, parsed.error); - } - rt.byteVecPush(out, option_mapOr$0zwtv9w(rt.iterCollectOption(rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): undefined => { - rt.byteVecPush(log, _24); - }), (_29: rt.u8): rt.u16 | undefined => { - const b5: rt.u8 = _29; - return thenSome$0b23a33(b5 !== 32, b5 as rt.u16); - }), (values: rt.Iter) => rt.iterToVec(values, "next", 2)), 255, (v2: rt.Vec): rt.u8 => { + rs.byteVecPush(out, parsed.error); + } + rs.byteVecPush(out, option_mapOr$127irwp(rs.iterCollectOption(rs.iterMap(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): undefined => { + rs.byteVecPush(log, _24); + }), (_29: rs.u8): rs.u16 | undefined => { + const b5: rs.u8 = _29; + return thenSome$1gvhopg(b5 !== 32, b5 as rs.u16); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 2)), 255, (v2: rs.Vec): rs.u8 => { return v2.items.length & 0xff; })); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); } /** * `reduce`, `max_by`, and `min_by`, whose comparators log each pair they see, and * `Peekable`'s `peek_mut` and `next_if_eq`. */ -export function reducers(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.ByteVec = new rt.ByteVec(); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMaxBy(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8, _3: rt.u8): rt.Ordering => { - const a: rt.u8 = _2; - const b: rt.u8 = _3; - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); - return rt.cmp(rt.u8Rem(a, 4), rt.u8Rem(b, 4)); +export function reducers(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.ByteVec = new rs.ByteVec(); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMaxBy(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8, _3: rs.u8): rs.Ordering => { + const a: rs.u8 = _2; + const b: rs.u8 = _3; + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(a, b)), undefined, true); + return rs.cmp(rs.u8Rem(a, 4), rs.u8Rem(b, 4)); }), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMinBy(rt.iterSlice(rt.byteSliceView(data)), (a2: rt.u8, b2: rt.u8): rt.Ordering => { - rt.iterExtendBytes(log, rt.iterSlice(Uint8Array.of(a2, b2)), undefined, true); - return rt.cmp(rt.u8Div(a2, 64), rt.u8Div(b2, 64)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMinBy(rs.iterSlice(rs.byteSliceView(data)), (a2: rs.u8, b2: rs.u8): rs.Ordering => { + rs.iterExtendBytes(log, rs.iterSlice(Uint8Array.of(a2, b2)), undefined, true); + return rs.cmp(rs.u8Div(a2, 64), rs.u8Div(b2, 64)); }), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterReduce(rt.iterSlice(rt.byteSliceView(data)), (acc: rt.u8, b3: rt.u8): rt.u8 => { - rt.byteVecPush(log, acc); - return rt.u8WrappingMul(acc, 3) ^ b3; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterReduce(rs.iterSlice(rs.byteSliceView(data)), (acc: rs.u8, b3: rs.u8): rs.u8 => { + rs.byteVecPush(log, acc); + return rs.u8WrappingMul(acc, 3) ^ b3; }), 221)); - rt.byteVecPush(out, option_mapOr$1a3irjf(rt.iterMaxBy(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.ByteVec => { - const b4: rt.u8 = _22; - return rt.byteVecOf(b4, rt.u8Rem(b4, 3) as rt.usize); - }), (a3: rt.ByteVec, b5: rt.ByteVec): rt.Ordering => { - return rt.cmp(a3.length, b5.length); - }), 204, (v: rt.ByteVec): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0g5x999(rs.iterMaxBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.ByteVec => { + const b4: rs.u8 = _22; + return rs.byteVecOf(b4, rs.u8Rem(b4, 3) as rs.usize); + }), (a3: rs.ByteVec, b5: rs.ByteVec): rs.Ordering => { + return rs.cmp(a3.length, b5.length); + }), 204, (v: rs.ByteVec): rs.u8 => { return v.length & 0xff; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterReduce(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.ByteVec => { - return rt.byteVecFrom(Uint8Array.of(_23)); - }), (a4: rt.ByteVec, b7: rt.ByteVec): rt.ByteVec => { - rt.iterExtendBytes(a4, rt.byteVecIntoIter(b7), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(option_unwrapOrDefault$0w012ed(rs.iterReduce(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): rs.ByteVec => { + return rs.byteVecFrom(Uint8Array.of(_23)); + }), (a4: rs.ByteVec, b7: rs.ByteVec): rs.ByteVec => { + rs.iterExtendBytes(a4, rs.byteVecIntoIter(b7), undefined, true); return a4; }))), undefined, true); - const it: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); - const _38: rt.Place | undefined = rt.peekablePeekMut(it, true); + const it: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + const _38: rs.Place | undefined = rs.peekablePeekMut(it, true); if (_38 !== undefined) { - _38.v = rt.u8WrappingAdd(_38.v, 1); + _38.v = rs.u8WrappingAdd(_38.v, 1); } - const _44: rt.Place | undefined = rt.peekablePeekMut(it, true); + const _44: rs.Place | undefined = rs.peekablePeekMut(it, true); if (_44 !== undefined) { _44.v = _44.v ^ 128; } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it.next()), 187)); - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.peekableNextIfEq(it, first, rt.same), 170)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it.next()), 170)); - rt.byteVecPush(out, rt.peekablePeekMut(it, true) === undefined ? 1 : 0); - const words: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.ByteVec => { - return rt.byteVecFrom(Uint8Array.of(_25)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it.next()), 187)); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it, first, rs.same), 170)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it.next()), 170)); + rs.byteVecPush(out, rs.peekablePeekMut(it, true) === undefined ? 1 : 0); + const words: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.ByteVec => { + return rs.byteVecFrom(Uint8Array.of(_25)); })); - const _73: rt.ByteVec | undefined = rt.peekablePeekMut(words, false); + const _73: rs.ByteVec | undefined = rs.peekablePeekMut(words, false); if (_73 !== undefined) { - rt.byteVecPush(_73, 153); + rs.byteVecPush(_73, 153); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(option_unwrapOrDefault$0wx44sw(rt.iterToOption(words.next()))), undefined, true); - const _87: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(first)); - rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(words, _87, rt.eqBytes), 136, (w: rt.ByteVec): rt.u8 => { - return w.data[rt.idx(w, 0)]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(option_unwrapOrDefault$0w012ed(rs.iterToOption(words.next()))), undefined, true); + const _87: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(first)); + rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(words, _87, rs.eqBytes), 136, (w: rs.ByteVec): rs.u8 => { + return w.data[rs.idx(w, 0)]; })); - rt.byteVecPush(out, rt.iterCount(words) & 0xff); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const _94: rt.Place | undefined = rt.iterMinBy(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes))), (a5: rt.Place, b9: rt.Place): rt.Ordering => { - return rt.cmp(b9.v, a5.v); + rs.byteVecPush(out, rs.iterCount(words) & 0xff); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const _94: rs.Place | undefined = rs.iterMinBy(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes))), (a5: rs.Place, b9: rs.Place): rs.Ordering => { + return rs.cmp(b9.v, a5.v); }); if (_94 !== undefined) { _94.v = 119; } - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(log), undefined, true); } -export function eq$cmp_PartialEq_iters_Quarter_u8(self: rt.u8, other: Quarter.Quarter): boolean { - rt.cellSet(other._1, rt.u8WrappingAdd(other._1.v, 16)); - return rt.u8Rem(self, 4) === rt.u8Rem(other._0, 4); +export function eq$cmp_PartialEq_iters_Quarter_u8(self: rs.u8, other: Quarter.Quarter): boolean { + rs.cellSet(other._1, rs.u8WrappingAdd(other._1.v, 16)); + return rs.u8Rem(self, 4) === rs.u8Rem(other._0, 4); } -export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rt.ByteSlice, other: Quarter.Quarter): boolean { - rt.cellSet(other._1, rt.u8WrappingAdd(other._1.v, 64)); - return rt.iterSum(rt.iterSlice(rt.byteSliceView(self)), rt.u8Add, 0) === other._0; +export function eq$cmp_PartialEq_iters_Quarter_array2_u8(self: rs.ByteSlice, other: Quarter.Quarter): boolean { + rs.cellSet(other._1, rs.u8WrappingAdd(other._1.v, 64)); + return rs.iterSum(rs.iterSlice(rs.byteSliceView(self)), rs.u8Add, 0) === other._0; } export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quarter.Quarter): boolean { - rt.cellSet(other._1, rt.u8WrappingAdd(other._1.v, 4)); - return rt.stringLen(self) === other._0 as rt.usize; + rs.cellSet(other._1, rs.u8WrappingAdd(other._1.v, 4)); + return rs.stringLen(self) === other._0 as rs.usize; } /** @@ -409,202 +409,202 @@ export function eq$cmp_PartialEq_iters_Quarter_String(self: string, other: Quart * `PartialEq`: std's across strings and slices, and the crate's own. Each matches the * first item, and a mismatch keeps the item for the next `next`. */ -export function peekedOthers(data: rt.ByteSlice, out: rt.ByteVec): void { - const _3: (a0: rt.u8) => string = (b: rt.u8): string => { - const _42: rt.char = rt.u8Add(97, rt.u8Rem(b, 3)) as rt.char; - return rt.fmtToString((f: rt.Formatter) => rt.fmtCharDisplay(_42, f)); +export function peekedOthers(data: rs.ByteSlice, out: rs.ByteVec): void { + const _3: (a0: rs.u8) => string = (b: rs.u8): string => { + const _42: rs.char = rs.u8Add(97, rs.u8Rem(b, 3)) as rs.char; + return rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_42, f)); }; - const _4: (a0: string | undefined) => rt.u8 = (w: string | undefined): rt.u8 => { - return option_mapOr$0lcrgk1(w, 170, (w2: string): rt.u8 => { - const _33: rt.ByteSlice = rt.stringAsBytes(w2); - rt.idx(_33, 0); + const _4: (a0: string | undefined) => rs.u8 = (w: string | undefined): rs.u8 => { + return option_mapOr$1nyk1yj(w, 170, (w2: string): rs.u8 => { + const _33: rs.ByteSlice = rs.stringAsBytes(w2); + rs.idx(_33, 0); return _33.data[_33.start]; }); }; - const _158: (a0: rt.Vec | undefined) => rt.u8 = (v: rt.Vec | undefined): rt.u8 => { - return option_mapOr$0zwtv9w(v, 170, (v2: rt.Vec): rt.u8 => { + const _158: (a0: rs.Vec | undefined) => rs.u8 = (v: rs.Vec | undefined): rs.u8 => { + return option_mapOr$127irwp(v, 170, (v2: rs.Vec): rs.u8 => { return v2.items.length & 0xff; }); }; - const _159: (a0: rt.u8) => rt.Vec = (b2: rt.u8): rt.Vec => { - return rt.vecFromElem(((rt.u8Rem(b2, 2) as rt.u16) << 9) & 0xffff, rt.u8Rem(b2, 3) as rt.usize, undefined); + const _159: (a0: rs.u8) => rs.Vec = (b2: rs.u8): rs.Vec => { + return rs.vecFromElem(((rs.u8Rem(b2, 2) as rs.u16) << 9) & 0xffff, rs.u8Rem(b2, 3) as rs.usize, undefined); }; - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): string => { + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): string => { return _3(_2); }), undefined, 12, true); - const _12: string | undefined = rt.sliceFirst(words.items); + const _12: string | undefined = rs.sliceFirst(words.items); const first: string = option_unwrapOrDefault$165pyh5(_12 === undefined ? undefined : _12); - const it: rt.Peekable = rt.iterPeekable(rt.vecIntoIter(rt.vecFrom(words.items.slice()))); - const part = option_asDeref$0w8at8i(rt.peekableNextIfEq(it, "a", (a0: string, a1: string): boolean => { + const it: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))); + const part = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "a", (a0: string, a1: string): boolean => { return a0 === a1; })); - rt.byteVecPush(out, _4(part)); - const part2 = option_asDeref$0w8at8i(rt.peekableNextIfEq(it, "b", (a02: string, a12: string): boolean => { + rs.byteVecPush(out, _4(part)); + const part2 = option_asDeref$0w8at8i(rs.peekableNextIfEq(it, "b", (a02: string, a12: string): boolean => { return a02 === a12; })); - rt.byteVecPush(out, _4(part2)); - const part3 = option_asDeref$0w8at8i(rt.iterToOption(it.next())); - rt.byteVecPush(out, _4(part3)); - const it2: rt.Peekable = rt.iterPeekable(rt.iterSlice(words.items)); - const part4 = option_map$1uo1d4o(rt.peekableNextIfEq(it2, first, (a03: string, a13: string): boolean => { + rs.byteVecPush(out, _4(part2)); + const part3 = option_asDeref$0w8at8i(rs.iterToOption(it.next())); + rs.byteVecPush(out, _4(part3)); + const it2: rs.Peekable = rs.iterPeekable(rs.iterSlice(words.items)); + const part4 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, first, (a03: string, a13: string): boolean => { return a03 === a13; }), (a04: string): string => { return a04; }); - rt.byteVecPush(out, _4(part4)); - const part5 = option_map$1uo1d4o(rt.peekableNextIfEq(it2, "c", (a05: string, a14: string): boolean => { + rs.byteVecPush(out, _4(part4)); + const part5 = option_map$1uo1d4o(rs.peekableNextIfEq(it2, "c", (a05: string, a14: string): boolean => { return a05 === a14; }), (a06: string): string => { return a06; }); - rt.byteVecPush(out, _4(part5)); - const part6 = option_map$1uo1d4o(rt.iterToOption(it2.next()), (a07: string): string => { + rs.byteVecPush(out, _4(part5)); + const part6 = option_map$1uo1d4o(rs.iterToOption(it2.next()), (a07: string): string => { return a07; }); - rt.byteVecPush(out, _4(part6)); - const it3: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(words.items), (a08: string): string => { + rs.byteVecPush(out, _4(part6)); + const it3: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { return a08; })); - const part7 = rt.peekableNextIfEq(it3, first, (a09: string, a15: string): boolean => { + const part7 = rs.peekableNextIfEq(it3, first, (a09: string, a15: string): boolean => { return a09 === a15; }); - rt.byteVecPush(out, _4(part7)); - const part8 = rt.iterToOption(it3.next()); - rt.byteVecPush(out, _4(part8)); - const it4: rt.Peekable> = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): rt.Vec => { - return rt.vecFrom([_3(_24)]); + rs.byteVecPush(out, _4(part7)); + const part8 = rs.iterToOption(it3.next()); + rs.byteVecPush(out, _4(part8)); + const it4: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): rs.Vec => { + return rs.vecFrom([_3(_24)]); })); - const _107: rt.Vec = rt.vecFrom([first]); - const part9 = option_map$0xa8rra(rt.peekableNextIfEq(it4, _107, (a010: rt.Vec, a16: rt.Vec): boolean => { - return rt.eqSlice(rt.same)(a010, a16); - }), (v3: rt.Vec): string => { - return v3.items[rt.idx(v3.items, 0)]; + const _107: rs.Vec = rs.vecFrom([first]); + const part9 = option_map$1bpbukm(rs.peekableNextIfEq(it4, _107, (a010: rs.Vec, a16: rs.Vec): boolean => { + return rs.eqSlice(rs.same)(a010, a16); + }), (v3: rs.Vec): string => { + return v3.items[rs.idx(v3.items, 0)]; }); - rt.byteVecPush(out, _4(part9)); - const part10 = option_map$0xa8rra(rt.iterToOption(it4.next()), (v4: rt.Vec): string => { - return v4.items[rt.idx(v4.items, 0)]; + rs.byteVecPush(out, _4(part9)); + const part10 = option_map$1bpbukm(rs.iterToOption(it4.next()), (v4: rs.Vec): string => { + return v4.items[rs.idx(v4.items, 0)]; }); - rt.byteVecPush(out, _4(part10)); - const it5: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(words.items), (w3: string): rt.StrCow => { - return new rt.Borrowed(w3); + rs.byteVecPush(out, _4(part10)); + const it5: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(words.items), (w3: string): rs.StrCow => { + return new rs.Borrowed(w3); })); - const part11 = option_asDeref$1qc2lbh(rt.peekableNextIfEq(it5, "b", (a011: rt.StrCow, a17: string): boolean => { - return rt.strCowStr(a011) === a17; + const part11 = option_asDeref$0pg0e8a(rs.peekableNextIfEq(it5, "b", (a011: rs.StrCow, a17: string): boolean => { + return rs.strCowStr(a011) === a17; })); - rt.byteVecPush(out, _4(part11)); - const part12 = option_asDeref$1qc2lbh(rt.iterToOption(it5.next())); - rt.byteVecPush(out, _4(part12)); - const part13 = option_asDeref$0w8at8i(rt.peekableNextIfEq(rt.iterPeekable(rt.vecIntoIter(rt.vecFrom(words.items.slice()))), first, (a012: string, a18: rt.StrCow): boolean => { - return a012 === rt.strCowStr(a18); + rs.byteVecPush(out, _4(part11)); + const part12 = option_asDeref$0pg0e8a(rs.iterToOption(it5.next())); + rs.byteVecPush(out, _4(part12)); + const part13 = option_asDeref$0w8at8i(rs.peekableNextIfEq(rs.iterPeekable(rs.vecIntoIter(rs.vecFrom(words.items.slice()))), first, (a012: string, a18: rs.StrCow): boolean => { + return a012 === rs.strCowStr(a18); })); - rt.byteVecPush(out, _4(part13)); - const it7: rt.Peekable> = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): rt.Vec => { + rs.byteVecPush(out, _4(part13)); + const it7: rs.Peekable> = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): rs.Vec => { return _159(_26); })); - const _172: rt.u16[] = [0]; - const _171: rt.u16[] = rt.sliceRange(_172, 0); - const part14 = rt.peekableNextIfEq(it7, _171, (a013: rt.Vec, a19: rt.u16[]): boolean => { - return rt.eqSlice(rt.same)(a013, a19); + const _172: rs.u16[] = [0]; + const _171: rs.u16[] = rs.sliceRange(_172, 0); + const part14 = rs.peekableNextIfEq(it7, _171, (a013: rs.Vec, a19: rs.u16[]): boolean => { + return rs.eqSlice(rs.same)(a013, a19); }); - rt.byteVecPush(out, _158(part14)); - const part15 = rt.peekableNextIfEq(it7, [512, 512], (a014: rt.Vec, a110: rt.u16[]): boolean => { - return rt.eqSlice(rt.same)(a014, a110); + rs.byteVecPush(out, _158(part14)); + const part15 = rs.peekableNextIfEq(it7, [512, 512], (a014: rs.Vec, a110: rs.u16[]): boolean => { + return rs.eqSlice(rs.same)(a014, a110); }); - rt.byteVecPush(out, _158(part15)); - const _189: rt.u16[] = []; - const _188: rt.u16[] = rt.sliceRange(_189, 0); - const part16 = rt.peekableNextIfEq(it7, _188, (a015: rt.Vec, a111: rt.u16[]): boolean => { - return rt.eqSlice(rt.same)(a015, a111); + rs.byteVecPush(out, _158(part15)); + const _189: rs.u16[] = []; + const _188: rs.u16[] = rs.sliceRange(_189, 0); + const part16 = rs.peekableNextIfEq(it7, _188, (a015: rs.Vec, a111: rs.u16[]): boolean => { + return rs.eqSlice(rs.same)(a015, a111); }); - rt.byteVecPush(out, _158(part16)); - const part17 = rt.iterToOption(it7.next()); - rt.byteVecPush(out, _158(part17)); - const it8: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.ByteVec => { - const b6: rt.u8 = _28; - return rt.byteVecOf(rt.u8Rem(b6, 2), rt.u8Rem(b6, 3) as rt.usize); + rs.byteVecPush(out, _158(part16)); + const part17 = rs.iterToOption(it7.next()); + rs.byteVecPush(out, _158(part17)); + const it8: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.ByteVec => { + const b6: rs.u8 = _28; + return rs.byteVecOf(rs.u8Rem(b6, 2), rs.u8Rem(b6, 3) as rs.usize); })); - const _203: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(1)), 0); - rt.byteVecPush(out, option_mapOr$1a3irjf(rt.peekableNextIfEq(it8, _203, (a016: rt.ByteVec, a112: rt.ByteSlice): boolean => { - return rt.eqBytes(a016, a112); - }), 170, (v5: rt.ByteVec): rt.u8 => { + const _203: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(1)), 0); + rs.byteVecPush(out, option_mapOr$0g5x999(rs.peekableNextIfEq(it8, _203, (a016: rs.ByteVec, a112: rs.ByteSlice): boolean => { + return rs.eqBytes(a016, a112); + }), 170, (v5: rs.ByteVec): rs.u8 => { return v5.length & 0xff; })); - rt.byteVecPush(out, option_mapOr$1a3irjf(rt.iterToOption(it8.next()), 170, (v6: rt.ByteVec): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0g5x999(rs.iterToOption(it8.next()), 170, (v6: rs.ByteVec): rs.u8 => { return v6.length & 0xff; })); - const calls: rt.Cell = new rt.Cell(0); - const it9: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _317: rt.u8 = rt.u8Rem(c.data[c.start], 2); - rt.idx(c, 1); - return Uint8Array.of(_317, rt.u8Rem(c.data[c.start + 1], 2)); + const calls: rs.Cell = new rs.Cell(0); + const it9: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _317: rs.u8 = rs.u8Rem(c.data[c.start], 2); + rs.idx(c, 1); + return Uint8Array.of(_317, rs.u8Rem(c.data[c.start + 1], 2)); })); - const _217: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(0, 1)), 0); - rt.byteVecPush(out, option_mapOr$0sl5app(rt.peekableNextIfEq(it9, _217, (a: Uint8Array, b7: rt.ByteSlice): boolean => { - return ((a017: rt.ByteSlice, a113: rt.ByteSlice): boolean => { - return rt.eqBytes(a017, a113); - })(rt.byteSliceFrom(a), b7); - }), 170, (p: Uint8Array): rt.u8 => { + const _217: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(0, 1)), 0); + rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.peekableNextIfEq(it9, _217, (a: Uint8Array, b7: rs.ByteSlice): boolean => { + return ((a017: rs.ByteSlice, a113: rs.ByteSlice): boolean => { + return rs.eqBytes(a017, a113); + })(rs.byteSliceFrom(a), b7); + }), 170, (p: Uint8Array): rs.u8 => { return p[1]; })); - rt.byteVecPush(out, option_mapOr$0sl5app(rt.iterToOption(it9.next()), 170, (p2: Uint8Array): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.iterToOption(it9.next()), 170, (p2: Uint8Array): rs.u8 => { return p2[0]; })); - rt.byteVecPush(out, option_mapOr$0sl5app(rt.peekableNextIfEq(it9, { _0: 1, _1: calls }, (a2: Uint8Array, b8: Quarter.Quarter): boolean => { - return eq$cmp_PartialEq_iters_Quarter_array2_u8(rt.byteSliceFrom(a2), b8); - }), 170, (p3: Uint8Array): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.peekableNextIfEq(it9, { _0: 1, _1: calls }, (a2: Uint8Array, b8: Quarter.Quarter): boolean => { + return eq$cmp_PartialEq_iters_Quarter_array2_u8(rs.byteSliceFrom(a2), b8); + }), 170, (p3: Uint8Array): rs.u8 => { return p3[0]; })); - rt.byteVecPush(out, option_mapOr$0sl5app(rt.iterToOption(it9.next()), 170, (p4: Uint8Array): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1i4rvy8(rs.iterToOption(it9.next()), 170, (p4: Uint8Array): rs.u8 => { return p4[1]; })); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const it10: rt.Peekable> = rt.iterPeekable(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes)))); - const _242: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _239: rt.Place | undefined = rt.peekableNextIfEq(it10, _242, (a018: rt.Place, a114: rt.u8): boolean => { + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const it10: rs.Peekable> = rs.iterPeekable(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes)))); + const _242: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _239: rs.Place | undefined = rs.peekableNextIfEq(it10, _242, (a018: rs.Place, a114: rs.u8): boolean => { return a018.v === a114; }); if (_239 !== undefined) { _239.v = _239.v ^ 64; } - rt.byteVecPush(out, option_mapOr$0ev76sb(rt.peekableNextIfEq(it10, 3, (a019: rt.Place, a115: rt.u8): boolean => { + rs.byteVecPush(out, option_mapOr$02sqh24(rs.peekableNextIfEq(it10, 3, (a019: rs.Place, a115: rs.u8): boolean => { return a019.v === a115; - }), 170, (b9: rt.Place): rt.u8 => { + }), 170, (b9: rs.Place): rs.u8 => { return b9.v; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); - const it11: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Quarter.Quarter => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); + const it11: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): Quarter.Quarter => { return { _0: _210, _1: calls }; })); - const want: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const want: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); while (true) { - const _262: Quarter.Quarter | undefined = rt.peekableNextIfEq(it11, want, Quarter.eq$cmp_PartialEq_u8); + const _262: Quarter.Quarter | undefined = rs.peekableNextIfEq(it11, want, Quarter.eq$cmp_PartialEq_u8); if (_262 !== undefined) { - rt.byteVecPush(out, _262._0); + rs.byteVecPush(out, _262._0); } else { break; } } - rt.byteVecPush(out, option_mapOr$1lznlgz(rt.iterToOption(it11.next()), 170, (q2: Quarter.Quarter): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0dfpyun(rs.iterToOption(it11.next()), 170, (q2: Quarter.Quarter): rs.u8 => { return q2._0; })); - const it12: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data))); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.peekableNextIfEq(it12, { _0: want ^ 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.peekableNextIfEq(it12, { _0: want, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); - const it13: rt.Peekable = rt.iterPeekable(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): string => { - return rt.strSlice("ab", 0, rt.u8Rem(_213, 3) as rt.usize); + const it12: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data))); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want ^ 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.peekableNextIfEq(it12, { _0: want, _1: calls }, eq$cmp_PartialEq_iters_Quarter_u8), 170)); + const it13: rs.Peekable = rs.iterPeekable(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): string => { + return rs.strSlice("ab", 0, rs.u8Rem(_213, 3) as rs.usize); })); - rt.byteVecPush(out, option_mapOr$0lcrgk1(rt.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: string): rt.u8 => { - return rt.stringLen(w4) & 0xff; + rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.peekableNextIfEq(it13, { _0: 1, _1: calls }, eq$cmp_PartialEq_iters_Quarter_String), 170, (w4: string): rs.u8 => { + return rs.stringLen(w4) & 0xff; })); - rt.byteVecPush(out, option_mapOr$0lcrgk1(rt.iterToOption(it13.next()), 170, (w5: string): rt.u8 => { - return rt.stringLen(w5) & 0xff; + rs.byteVecPush(out, option_mapOr$1nyk1yj(rs.iterToOption(it13.next()), 170, (w5: string): rs.u8 => { + return rs.stringLen(w5) & 0xff; })); - rt.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String("ab", { _0: want, _1: calls }) ? 1 : 0); - rt.byteVecPush(out, calls.v); + rs.byteVecPush(out, eq$cmp_PartialEq_iters_Quarter_String("ab", { _0: want, _1: calls }) ? 1 : 0); + rs.byteVecPush(out, calls.v); } -export function rotateFree$iters_RotateFree_u8(self: rt.u8): rt.u8 { +export function rotateFree$iters_RotateFree_u8(self: rs.u8): rs.u8 { return ((self << 1) & 0xff) | (self >> 7); } @@ -612,411 +612,411 @@ export function rotateFree$iters_RotateFree_u8(self: rt.u8): rt.u8 { * `nth` and `nth_back` through each adaptor, of a source whose reads `by_ref` or * `inspect` shows: each reads on past a `take`'s limit, or stops at it, as std's does. */ -export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let item!: rt.u8 | undefined; - let item2!: rt.u8 | undefined; - let item3!: rt.u8 | undefined; - let item4!: rt.u8 | undefined; - let item5!: rt.u8 | undefined; - let item6!: rt.u8 | undefined; - let item7!: rt.u8 | undefined; - let item8!: rt.u8 | undefined; - let item9!: rt.u8 | undefined; - let item10!: rt.u8 | undefined; - let item11!: rt.u8 | undefined; - let item12!: rt.u8 | undefined; - let item13!: rt.u8 | undefined; - let item14!: rt.u8 | undefined; - let item15!: rt.u8 | undefined; - let item16!: rt.u8 | undefined; - let item17!: rt.u8 | undefined; - let item18!: rt.u8 | undefined; - let item19!: rt.u8 | undefined; - let item20!: rt.u8 | undefined; - let item21!: [rt.usize, rt.u8] | undefined; - let item22!: [rt.usize, rt.u8] | undefined; - let item23!: rt.u8 | undefined; - let item24!: rt.u8 | undefined; - let item25!: rt.u8 | undefined; - let item26!: rt.u8 | undefined; - let item27!: [rt.u8, rt.u8] | undefined; +export function skips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let item!: rs.u8 | undefined; + let item2!: rs.u8 | undefined; + let item3!: rs.u8 | undefined; + let item4!: rs.u8 | undefined; + let item5!: rs.u8 | undefined; + let item6!: rs.u8 | undefined; + let item7!: rs.u8 | undefined; + let item8!: rs.u8 | undefined; + let item9!: rs.u8 | undefined; + let item10!: rs.u8 | undefined; + let item11!: rs.u8 | undefined; + let item12!: rs.u8 | undefined; + let item13!: rs.u8 | undefined; + let item14!: rs.u8 | undefined; + let item15!: rs.u8 | undefined; + let item16!: rs.u8 | undefined; + let item17!: rs.u8 | undefined; + let item18!: rs.u8 | undefined; + let item19!: rs.u8 | undefined; + let item20!: rs.u8 | undefined; + let item21!: [rs.usize, rs.u8] | undefined; + let item22!: [rs.usize, rs.u8] | undefined; + let item23!: rs.u8 | undefined; + let item24!: rs.u8 | undefined; + let item25!: rs.u8 | undefined; + let item26!: rs.u8 | undefined; + let item27!: [rs.u8, rs.u8] | undefined; let item28!: Uint8Array | undefined; - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.usizeRem(_2 as rt.usize, 4); + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.usizeRem(_2 as rs.usize, 4); }); - const limit: rt.usize = option_mapOr$1t0muvr(rt.byteSliceGet(data, 1), 0, (_22: rt.u8): rt.usize => { - return rt.usizeRem(_22 as rt.usize, 3); + const limit: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceGet(data, 1), 0, (_22: rs.u8): rs.usize => { + return rs.usizeRem(_22 as rs.usize, 3); }); const back: boolean = (kind & 1) === 1; - const _10: rt.u8 = rt.u8Rem(rt.u8Div(kind, 2), 14); + const _10: rs.u8 = rs.u8Rem(rs.u8Div(kind, 2), 14); if (_10 === 0) { - const rest: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it: rt.Iter = rt.iterFuse(rt.iterTake(rt.iterBorrow(rest), limit), true); + const rest: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it: rs.Iter = rs.iterFuse(rs.iterTake(rs.iterBorrow(rest), limit), true); if (!back) { - item = rt.iterNth(it, n); + item = rs.iterNth(it, n); } else { - item = rt.iterNthBack(it, n); + item = rs.iterNthBack(it, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item, 238, (_264: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item, 238, (_264: rs.u8): rs.u8 => { return _264; })); - rt.byteVecPush(out, rest.len() & 0xff); - const log: rt.ByteVec = new rt.ByteVec(); - const it2: rt.Iter = rt.iterFuse(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_267: rt.u8): undefined => { - rt.byteVecPush(log, _267); + rs.byteVecPush(out, rest.len() & 0xff); + const log: rs.ByteVec = new rs.ByteVec(); + const it2: rs.Iter = rs.iterFuse(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_267: rs.u8): undefined => { + rs.byteVecPush(log, _267); }), limit), true); if (!back) { - item2 = rt.iterNth(it2, n); + item2 = rs.iterNth(it2, n); } else { - item2 = rt.iterNthBack(it2, n); + item2 = rs.iterNthBack(it2, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item2, 238, (_268: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item2, 238, (_268: rs.u8): rs.u8 => { return _268; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); } else if (_10 === 1) { - const rest2: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const src3: rt.Iter = rest2; - const _50: rt.usize = rt.usizeAdd(limit, 1); - const it3: rt.Iter = rt.iterSkip(rt.iterTake(rt.iterBorrow(src3), _50), 1); + const rest2: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const src3: rs.Iter = rest2; + const _50: rs.usize = rs.usizeAdd(limit, 1); + const it3: rs.Iter = rs.iterSkip(rs.iterTake(rs.iterBorrow(src3), _50), 1); if (!back) { - item3 = rt.iterNth(it3, n); + item3 = rs.iterNth(it3, n); } else { - item3 = rt.iterNthBack(it3, n); + item3 = rs.iterNthBack(it3, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item3, 238, (_261: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item3, 238, (_261: rs.u8): rs.u8 => { return _261; })); - rt.byteVecPush(out, rest2.len() & 0xff); - const log2: rt.ByteVec = new rt.ByteVec(); - const it4: rt.Iter = rt.iterSkip(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_262: rt.u8): undefined => { - rt.byteVecPush(log2, _262); - }), rt.usizeAdd(limit, 1)), 1); + rs.byteVecPush(out, rest2.len() & 0xff); + const log2: rs.ByteVec = new rs.ByteVec(); + const it4: rs.Iter = rs.iterSkip(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_262: rs.u8): undefined => { + rs.byteVecPush(log2, _262); + }), rs.usizeAdd(limit, 1)), 1); if (!back) { - item4 = rt.iterNth(it4, n); + item4 = rs.iterNth(it4, n); } else { - item4 = rt.iterNthBack(it4, n); + item4 = rs.iterNthBack(it4, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item4, 238, (_263: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item4, 238, (_263: rs.u8): rs.u8 => { return _263; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log2)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log2)); } else if (_10 === 2) { - const rest3: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it5: rt.Iter = rt.iterChain(rt.iterTake(rt.iterBorrow(rest3), limit), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17))))); + const rest3: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it5: rs.Iter = rs.iterChain(rs.iterTake(rs.iterBorrow(rest3), limit), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17))))); if (!back) { - item5 = rt.iterNth(it5, n); + item5 = rs.iterNth(it5, n); } else { - item5 = rt.iterNthBack(it5, n); + item5 = rs.iterNthBack(it5, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item5, 238, (_255: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item5, 238, (_255: rs.u8): rs.u8 => { return _255; })); - rt.byteVecPush(out, rest3.len() & 0xff); - const log3: rt.ByteVec = new rt.ByteVec(); - const it6: rt.Iter = rt.iterChain(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_258: rt.u8): undefined => { - rt.byteVecPush(log3, _258); - }), limit), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17))))); + rs.byteVecPush(out, rest3.len() & 0xff); + const log3: rs.ByteVec = new rs.ByteVec(); + const it6: rs.Iter = rs.iterChain(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_258: rs.u8): undefined => { + rs.byteVecPush(log3, _258); + }), limit), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17))))); if (!back) { - item6 = rt.iterNth(it6, n); + item6 = rs.iterNth(it6, n); } else { - item6 = rt.iterNthBack(it6, n); + item6 = rs.iterNthBack(it6, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item6, 238, (_260: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item6, 238, (_260: rs.u8): rs.u8 => { return _260; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log3)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log3)); } else if (_10 === 3) { - const rest4: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const src7: rt.Iter = rest4; - const it7: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterTake(rt.iterBorrow(src7), limit)); + const rest4: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const src7: rs.Iter = rest4; + const it7: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17)))), rs.iterTake(rs.iterBorrow(src7), limit)); if (!back) { - item7 = rt.iterNth(it7, n); + item7 = rs.iterNth(it7, n); } else { - item7 = rt.iterNthBack(it7, n); + item7 = rs.iterNthBack(it7, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item7, 238, (_252: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item7, 238, (_252: rs.u8): rs.u8 => { return _252; })); - rt.byteVecPush(out, rest4.len() & 0xff); - const log4: rt.ByteVec = new rt.ByteVec(); - const src8: rt.Iter = rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_253: rt.u8): undefined => { - rt.byteVecPush(log4, _253); + rs.byteVecPush(out, rest4.len() & 0xff); + const log4: rs.ByteVec = new rs.ByteVec(); + const src8: rs.Iter = rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_253: rs.u8): undefined => { + rs.byteVecPush(log4, _253); }); - const it8: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterTake(src8, limit)); + const it8: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17)))), rs.iterTake(src8, limit)); if (!back) { - item8 = rt.iterNth(it8, n); + item8 = rs.iterNth(it8, n); } else { - item8 = rt.iterNthBack(it8, n); + item8 = rs.iterNthBack(it8, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item8, 238, (_254: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item8, 238, (_254: rs.u8): rs.u8 => { return _254; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log4)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log4)); } else if (_10 === 4) { - const rest5: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const src9: rt.Iter = rest5; - const _159: rt.usize = rt.usizeAdd(limit, 1); - const it9: rt.Iter = rt.iterStepBy(rt.iterTake(rt.iterBorrow(src9), _159), 2); + const rest5: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const src9: rs.Iter = rest5; + const _159: rs.usize = rs.usizeAdd(limit, 1); + const it9: rs.Iter = rs.iterStepBy(rs.iterTake(rs.iterBorrow(src9), _159), 2); if (!back) { - item9 = rt.iterNth(it9, n); + item9 = rs.iterNth(it9, n); } else { - item9 = rt.iterNthBack(it9, n); + item9 = rs.iterNthBack(it9, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item9, 238, (_245: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item9, 238, (_245: rs.u8): rs.u8 => { return _245; })); - rt.byteVecPush(out, rest5.len() & 0xff); - const log5: rt.ByteVec = new rt.ByteVec(); - const it10: rt.Iter = rt.iterStepBy(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_246: rt.u8): undefined => { - rt.byteVecPush(log5, _246); - }), rt.usizeAdd(limit, 1)), 2); + rs.byteVecPush(out, rest5.len() & 0xff); + const log5: rs.ByteVec = new rs.ByteVec(); + const it10: rs.Iter = rs.iterStepBy(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_246: rs.u8): undefined => { + rs.byteVecPush(log5, _246); + }), rs.usizeAdd(limit, 1)), 2); if (!back) { - item10 = rt.iterNth(it10, n); + item10 = rs.iterNth(it10, n); } else { - item10 = rt.iterNthBack(it10, n); + item10 = rs.iterNthBack(it10, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item10, 238, (_251: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item10, 238, (_251: rs.u8): rs.u8 => { return _251; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log5)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log5)); } else if (_10 === 5) { - const rest6: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it11: rt.Peekable = rt.iterPeekable(rt.iterTake(rt.iterBorrow(rest6), limit)); + const rest6: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it11: rs.Peekable = rs.iterPeekable(rs.iterTake(rs.iterBorrow(rest6), limit)); if (!back) { - item11 = rt.iterNth(it11, n); + item11 = rs.iterNth(it11, n); } else { - item11 = rt.iterNthBack(it11, n); + item11 = rs.iterNthBack(it11, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item11, 238, (_240: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item11, 238, (_240: rs.u8): rs.u8 => { return _240; })); - rt.byteVecPush(out, rest6.len() & 0xff); - const log6: rt.ByteVec = new rt.ByteVec(); - const it12: rt.Peekable = rt.iterPeekable(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_241: rt.u8): undefined => { - rt.byteVecPush(log6, _241); + rs.byteVecPush(out, rest6.len() & 0xff); + const log6: rs.ByteVec = new rs.ByteVec(); + const it12: rs.Peekable = rs.iterPeekable(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_241: rs.u8): undefined => { + rs.byteVecPush(log6, _241); }), limit)); if (!back) { - item12 = rt.iterNth(it12, n); + item12 = rs.iterNth(it12, n); } else { - item12 = rt.iterNthBack(it12, n); + item12 = rs.iterNthBack(it12, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item12, 238, (_244: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item12, 238, (_244: rs.u8): rs.u8 => { return _244; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log6)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log6)); } else if (_10 === 6) { - const rest7: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const src13: rt.Iter = rest7; - const _226: rt.usize = rt.usizeAdd(limit, 1); - const it14: rt.Peekable = rt.iterPeekable(rt.iterTake(rt.iterBorrow(src13), _226)); - rt.peekablePeek(it14); - const it13: rt.Peekable = it14; + const rest7: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const src13: rs.Iter = rest7; + const _226: rs.usize = rs.usizeAdd(limit, 1); + const it14: rs.Peekable = rs.iterPeekable(rs.iterTake(rs.iterBorrow(src13), _226)); + rs.peekablePeek(it14); + const it13: rs.Peekable = it14; if (!back) { - item13 = rt.iterNth(it13, n); + item13 = rs.iterNth(it13, n); } else { - item13 = rt.iterNthBack(it13, n); + item13 = rs.iterNthBack(it13, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item13, 238, (_233: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item13, 238, (_233: rs.u8): rs.u8 => { return _233; })); - rt.byteVecPush(out, rest7.len() & 0xff); - const log7: rt.ByteVec = new rt.ByteVec(); - const it16: rt.Peekable = rt.iterPeekable(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_236: rt.u8): undefined => { - rt.byteVecPush(log7, _236); - }), rt.usizeAdd(limit, 1))); - rt.peekablePeek(it16); - const it15: rt.Peekable = it16; + rs.byteVecPush(out, rest7.len() & 0xff); + const log7: rs.ByteVec = new rs.ByteVec(); + const it16: rs.Peekable = rs.iterPeekable(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_236: rs.u8): undefined => { + rs.byteVecPush(log7, _236); + }), rs.usizeAdd(limit, 1))); + rs.peekablePeek(it16); + const it15: rs.Peekable = it16; if (!back) { - item14 = rt.iterNth(it15, n); + item14 = rs.iterNth(it15, n); } else { - item14 = rt.iterNthBack(it15, n); + item14 = rs.iterNthBack(it15, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item14, 238, (_239: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item14, 238, (_239: rs.u8): rs.u8 => { return _239; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log7)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log7)); } else if (_10 === 7) { - const rest8: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it17: rt.Iter = rt.iterFlatten(rt.iterOnce(rt.iterTake(rt.iterBorrow(rest8), limit)), undefined, true); + const rest8: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it17: rs.Iter = rs.iterFlatten(rs.iterOnce(rs.iterTake(rs.iterBorrow(rest8), limit)), undefined, true); if (!back) { - item15 = rt.iterNth(it17, n); + item15 = rs.iterNth(it17, n); } else { - item15 = rt.iterNthBack(it17, n); + item15 = rs.iterNthBack(it17, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item15, 238, (_230: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item15, 238, (_230: rs.u8): rs.u8 => { return _230; })); - rt.byteVecPush(out, rest8.len() & 0xff); - const log8: rt.ByteVec = new rt.ByteVec(); - const it18: rt.Iter = rt.iterFlatten(rt.iterOnce(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_231: rt.u8): undefined => { - rt.byteVecPush(log8, _231); + rs.byteVecPush(out, rest8.len() & 0xff); + const log8: rs.ByteVec = new rs.ByteVec(); + const it18: rs.Iter = rs.iterFlatten(rs.iterOnce(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_231: rs.u8): undefined => { + rs.byteVecPush(log8, _231); }), limit)), undefined, true); if (!back) { - item16 = rt.iterNth(it18, n); + item16 = rs.iterNth(it18, n); } else { - item16 = rt.iterNthBack(it18, n); + item16 = rs.iterNthBack(it18, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item16, 238, (_232: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item16, 238, (_232: rs.u8): rs.u8 => { return _232; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log8)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log8)); } else if (_10 === 8) { - const rest9: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it19: rt.Iter = rt.iterTake(rt.iterBorrow(rest9), limit); + const rest9: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it19: rs.Iter = rs.iterTake(rs.iterBorrow(rest9), limit); if (!back) { - item17 = rt.iterNth(it19, n); + item17 = rs.iterNth(it19, n); } else { - item17 = rt.iterNthBack(it19, n); + item17 = rs.iterNthBack(it19, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item17, 238, (b18: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item17, 238, (b18: rs.u8): rs.u8 => { return b18; })); - rt.byteVecPush(out, rest9.len() & 0xff); - const log9: rt.ByteVec = new rt.ByteVec(); - const it20: rt.Iter = rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_229: rt.u8): undefined => { - rt.byteVecPush(log9, _229); + rs.byteVecPush(out, rest9.len() & 0xff); + const log9: rs.ByteVec = new rs.ByteVec(); + const it20: rs.Iter = rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_229: rs.u8): undefined => { + rs.byteVecPush(log9, _229); }), limit); if (!back) { - item18 = rt.iterNth(it20, n); + item18 = rs.iterNth(it20, n); } else { - item18 = rt.iterNthBack(it20, n); + item18 = rs.iterNthBack(it20, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item18, 238, (b20: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item18, 238, (b20: rs.u8): rs.u8 => { return b20; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log9)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log9)); } else if (_10 === 9) { - const rest10: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it21: rt.Iter = rt.iterCloned(rt.iterTake(rt.iterBorrow(rest10), limit)); + const rest10: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it21: rs.Iter = rs.iterCloned(rs.iterTake(rs.iterBorrow(rest10), limit)); if (!back) { - item19 = rt.iterNth(it21, n); + item19 = rs.iterNth(it21, n); } else { - item19 = rt.iterNthBack(it21, n); + item19 = rs.iterNthBack(it21, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item19, 238, (b15: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item19, 238, (b15: rs.u8): rs.u8 => { return b15; })); - rt.byteVecPush(out, rest10.len() & 0xff); - const log10: rt.ByteVec = new rt.ByteVec(); - const it22: rt.Iter = rt.iterCloned(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_224: rt.u8): undefined => { - rt.byteVecPush(log10, _224); + rs.byteVecPush(out, rest10.len() & 0xff); + const log10: rs.ByteVec = new rs.ByteVec(); + const it22: rs.Iter = rs.iterCloned(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_224: rs.u8): undefined => { + rs.byteVecPush(log10, _224); }), limit)); if (!back) { - item20 = rt.iterNth(it22, n); + item20 = rs.iterNth(it22, n); } else { - item20 = rt.iterNthBack(it22, n); + item20 = rs.iterNthBack(it22, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item20, 238, (b17: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item20, 238, (b17: rs.u8): rs.u8 => { return b17; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log10)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log10)); } else if (_10 === 10) { - const rest11: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it23: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterBorrow(rest11), limit)); + const rest11: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it23: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterTake(rs.iterBorrow(rest11), limit)); if (!back) { - item21 = rt.iterNth(it23, n); + item21 = rs.iterNth(it23, n); } else { - item21 = rt.iterNthBack(it23, n); + item21 = rs.iterNthBack(it23, n); } - rt.byteVecPush(out, option_mapOr$06gg5x7(item21, 238, (_221: [rt.usize, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0i0fno7(item21, 238, (_221: [rs.usize, rs.u8]): rs.u8 => { return _221[1] ^ (_221[0] & 0xff); })); - rt.byteVecPush(out, rest11.len() & 0xff); - const log11: rt.ByteVec = new rt.ByteVec(); - const it24: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_222: rt.u8): undefined => { - rt.byteVecPush(log11, _222); + rs.byteVecPush(out, rest11.len() & 0xff); + const log11: rs.ByteVec = new rs.ByteVec(); + const it24: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_222: rs.u8): undefined => { + rs.byteVecPush(log11, _222); }), limit)); if (!back) { - item22 = rt.iterNth(it24, n); + item22 = rs.iterNth(it24, n); } else { - item22 = rt.iterNthBack(it24, n); + item22 = rs.iterNthBack(it24, n); } - rt.byteVecPush(out, option_mapOr$06gg5x7(item22, 238, (_223: [rt.usize, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0i0fno7(item22, 238, (_223: [rs.usize, rs.u8]): rs.u8 => { return _223[1] ^ (_223[0] & 0xff); })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log11)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log11)); } else if (_10 === 11) { - const rest12: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const it25: rt.Iter = rt.iterRev(rt.iterTake(rt.iterBorrow(rest12), limit)); + const rest12: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const it25: rs.Iter = rs.iterRev(rs.iterTake(rs.iterBorrow(rest12), limit)); if (!back) { - item23 = rt.iterNth(it25, n); + item23 = rs.iterNth(it25, n); } else { - item23 = rt.iterNthBack(it25, n); + item23 = rs.iterNthBack(it25, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item23, 238, (_217: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item23, 238, (_217: rs.u8): rs.u8 => { return _217; })); - rt.byteVecPush(out, rest12.len() & 0xff); - const log12: rt.ByteVec = new rt.ByteVec(); - const it26: rt.Iter = rt.iterRev(rt.iterTake(rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_219: rt.u8): undefined => { - rt.byteVecPush(log12, _219); + rs.byteVecPush(out, rest12.len() & 0xff); + const log12: rs.ByteVec = new rs.ByteVec(); + const it26: rs.Iter = rs.iterRev(rs.iterTake(rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_219: rs.u8): undefined => { + rs.byteVecPush(log12, _219); }), limit)); if (!back) { - item24 = rt.iterNth(it26, n); + item24 = rs.iterNth(it26, n); } else { - item24 = rt.iterNthBack(it26, n); + item24 = rs.iterNthBack(it26, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item24, 238, (_220: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item24, 238, (_220: rs.u8): rs.u8 => { return _220; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log12)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log12)); } else if (_10 === 12) { - const rest13: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const src25: rt.Iter = rest13; - const it27: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(rt.iterBorrow(src25), limit), true)); + const rest13: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const src25: rs.Iter = rest13; + const it27: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17)))), rs.iterFuse(rs.iterTake(rs.iterBorrow(src25), limit), true)); if (!back) { - item25 = rt.iterNth(it27, n); + item25 = rs.iterNth(it27, n); } else { - item25 = rt.iterNthBack(it27, n); + item25 = rs.iterNthBack(it27, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item25, 238, (_212: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item25, 238, (_212: rs.u8): rs.u8 => { return _212; })); - rt.byteVecPush(out, rest13.len() & 0xff); - const log13: rt.ByteVec = new rt.ByteVec(); - const src26: rt.Iter = rt.iterInspect(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): undefined => { - rt.byteVecPush(log13, _213); + rs.byteVecPush(out, rest13.len() & 0xff); + const log13: rs.ByteVec = new rs.ByteVec(); + const src26: rs.Iter = rs.iterInspect(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): undefined => { + rs.byteVecPush(log13, _213); }); - const it28: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(17)))), rt.iterFuse(rt.iterTake(src26, limit), true)); + const it28: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(17)))), rs.iterFuse(rs.iterTake(src26, limit), true)); if (!back) { - item26 = rt.iterNth(it28, n); + item26 = rs.iterNth(it28, n); } else { - item26 = rt.iterNthBack(it28, n); + item26 = rs.iterNthBack(it28, n); } - rt.byteVecPush(out, option_mapOr$1surhce(item26, 238, (_214: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(item26, 238, (_214: rs.u8): rs.u8 => { return _214; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log13)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log13)); } else { - const rest14: rt.Iter<[rt.u8, rt.u8]> = rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { - const b3: rt.u8 = _25; - return [b3, ~b3 & 0xff] as [rt.u8, rt.u8]; + const rest14: rs.Iter<[rs.u8, rs.u8]> = rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): [rs.u8, rs.u8] => { + const b3: rs.u8 = _25; + return [b3, ~b3 & 0xff] as [rs.u8, rs.u8]; }), undefined, 2, true).items); - const it29: rt.Iter<[rt.u8, rt.u8]> = rt.iterTake(rt.iterBorrow(rest14), limit); + const it29: rs.Iter<[rs.u8, rs.u8]> = rs.iterTake(rs.iterBorrow(rest14), limit); if (!back) { - item27 = rt.iterNth(it29, n); + item27 = rs.iterNth(it29, n); } else { - item27 = rt.iterNthBack(it29, n); + item27 = rs.iterNthBack(it29, n); } - rt.byteVecPush(out, option_mapOr$0mmpeqx(item27, 238, (_28: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(item27, 238, (_28: [rs.u8, rs.u8]): rs.u8 => { return _28[0] ^ _28[1]; })); - rt.byteVecPush(out, rest14.len() & 0xff); - const rest15: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Uint8Array => { - const b5: rt.u8 = _29; + rs.byteVecPush(out, rest14.len() & 0xff); + const rest15: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Uint8Array => { + const b5: rs.u8 = _29; return Uint8Array.of(b5, ~b5 & 0xff); - }), undefined, 2, true).items), rt.byteSliceFrom); - const it30: rt.Iter = rt.iterCopied(rt.iterTake(rt.iterBorrow(rest15), limit), rt.byteSliceToArray); + }), undefined, 2, true).items), rs.byteSliceFrom); + const it30: rs.Iter = rs.iterCopied(rs.iterTake(rs.iterBorrow(rest15), limit), rs.byteSliceToArray); if (!back) { - item28 = rt.iterNth(it30, n); + item28 = rs.iterNth(it30, n); } else { - item28 = rt.iterNthBack(it30, n); + item28 = rs.iterNthBack(it30, n); } - rt.byteVecPush(out, option_mapOr$0sl5app(item28, 238, (_211: Uint8Array): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1i4rvy8(item28, 238, (_211: Uint8Array): rs.u8 => { return _211[0]; })); - rt.byteVecPush(out, rest15.len() & 0xff); + rs.byteVecPush(out, rest15.len() & 0xff); } } @@ -1024,219 +1024,219 @@ export function skips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `min_by_key` and `max_by_key` by keys that are tuples, `Reverse`s, `Option`s, and the * crate's own orders, `min` and `max` of such items, and `rposition` and `rfind`. */ -export function ranked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: (a0: rt.ByteVec, a1: [rt.usize, rt.u8] | undefined) => undefined = (out2: rt.ByteVec, found2: [rt.usize, rt.u8] | undefined): undefined => { - rt.byteVecPush(out2, option_mapOr$06gg5x7(found2, 255, (_2: [rt.usize, rt.u8]): rt.u8 => { +export function ranked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: (a0: rs.ByteVec, a1: [rs.usize, rs.u8] | undefined) => undefined = (out2: rs.ByteVec, found2: [rs.usize, rs.u8] | undefined): undefined => { + rs.byteVecPush(out2, option_mapOr$0i0fno7(found2, 255, (_2: [rs.usize, rs.u8]): rs.u8 => { return _2[0] & 0xff; })); }; - const _5: (a0: rt.u8) => rt.u8 | undefined = (b2: rt.u8): rt.u8 | undefined => { - const _3: rt.u8 = rt.u8Rem(b2, 3); + const _5: (a0: rs.u8) => rs.u8 | undefined = (b2: rs.u8): rs.u8 | undefined => { + const _3: rs.u8 = rs.u8Rem(b2, 3); if (_3 === 0) { return undefined; } if (_3 === 1) { - return rt.u8Rem(rt.u8Div(b2, 3), 4); + return rs.u8Rem(rs.u8Div(b2, 3), 4); } return 0; }; - const _55: (a0: Tilt.Tilt | undefined) => rt.u8 = (t: Tilt.Tilt | undefined): rt.u8 => { - return option_mapOr$0tmtgfi(t, 255, (t2: Tilt.Tilt): rt.u8 => { + const _55: (a0: Tilt.Tilt | undefined) => rs.u8 = (t: Tilt.Tilt | undefined): rs.u8 => { + return option_mapOr$0p9po8x(t, 255, (t2: Tilt.Tilt): rs.u8 => { return t2._0; }); }; - const _72: (a0: rt.u8) => [rt.u8, rt.u8 | undefined] = (b3: rt.u8): [rt.u8, rt.u8 | undefined] => { - return [rt.u8Rem(b3, 4), filter$0v80fk8(rt.u8Div(b3, 4), (b4: rt.u8): boolean => { - return rt.u8Rem(b4, 3) !== 0; - })] as [rt.u8, rt.u8 | undefined]; + const _72: (a0: rs.u8) => [rs.u8, rs.u8 | undefined] = (b3: rs.u8): [rs.u8, rs.u8 | undefined] => { + return [rs.u8Rem(b3, 4), filter$0hq86nl(rs.u8Div(b3, 4), (b4: rs.u8): boolean => { + return rs.u8Rem(b4, 3) !== 0; + })] as [rs.u8, rs.u8 | undefined]; }; - const items: () => rt.Iter<[rt.usize, rt.u8]> = (): rt.Iter<[rt.usize, rt.u8]> => { - return rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const items: () => rs.Iter<[rs.usize, rs.u8]> = (): rs.Iter<[rs.usize, rs.u8]> => { + return rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); }; - const tilts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): Tilt.Tilt => { - return { _0: rt.u8Rem(_27, 8) }; + const tilts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): Tilt.Tilt => { + return { _0: rs.u8Rem(_27, 8) }; }), undefined, 1, true); - const _10: rt.u8 = rt.u8Rem(kind, 4); + const _10: rs.u8 = rs.u8Rem(kind, 4); if (_10 === 0) { - const part5 = rt.iterMinByKey(items(), (_216: [rt.usize, rt.u8]): [rt.u8, rt.u8 | undefined] => { - const b12: rt.u8 = _216[1]; - return [rt.u8Rem(b12, 4), _5(b12)] as [rt.u8, rt.u8 | undefined]; - }, rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8 | undefined], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmpOption(rt.cmpReverse(rt.cmp))]))); + const part5 = rs.iterMinByKey(items(), (_216: [rs.usize, rs.u8]): [rs.u8, rs.u8 | undefined] => { + const b12: rs.u8 = _216[1]; + return [rs.u8Rem(b12, 4), _5(b12)] as [rs.u8, rs.u8 | undefined]; + }, rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmpOption(rs.cmpReverse(rs.cmp))]))); _4(out, part5); - const part6 = rt.iterMaxByKey(items(), (_217: [rt.usize, rt.u8]): [rt.u8, rt.u8 | undefined] => { - const b13: rt.u8 = _217[1]; - return [rt.u8Rem(b13, 4), _5(b13)] as [rt.u8, rt.u8 | undefined]; - }, rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8 | undefined], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmpOption(rt.cmpReverse(rt.cmp))]))); + const part6 = rs.iterMaxByKey(items(), (_217: [rs.usize, rs.u8]): [rs.u8, rs.u8 | undefined] => { + const b13: rs.u8 = _217[1]; + return [rs.u8Rem(b13, 4), _5(b13)] as [rs.u8, rs.u8 | undefined]; + }, rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8 | undefined], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmpOption(rs.cmpReverse(rs.cmp))]))); _4(out, part6); - const part8 = rt.iterMaxByKey(rt.iterFilter(items(), (_218: [rt.usize, rt.u8]): boolean => { + const part8 = rs.iterMaxByKey(rs.iterFilter(items(), (_218: [rs.usize, rs.u8]): boolean => { return _218[1] > 64; - }), (_219: [rt.usize, rt.u8]): rt.u8 | undefined => { + }), (_219: [rs.usize, rs.u8]): rs.u8 | undefined => { return _5(_219[1]); - }, rt.cmpLt(rt.cmpOption(rt.cmpReverse(rt.cmp)))); + }, rs.cmpLt(rs.cmpOption(rs.cmpReverse(rs.cmp)))); _4(out, part8); - const part9 = rt.iterMinByKey(items(), (_220: [rt.usize, rt.u8]): [boolean, rt.u64] => { - const b16: rt.u8 = _220[1]; - return [rt.u8Rem(b16, 2) === 0, rt.u8Rem(b16, 3) as rt.u64] as [boolean, rt.u64]; - }, rt.cmpLt(rt.cmpTuple<[boolean, rt.u64], rt.Ordering | undefined>([rt.cmp, rt.cmpReverse(rt.cmp)]))); + const part9 = rs.iterMinByKey(items(), (_220: [rs.usize, rs.u8]): [boolean, rs.u64] => { + const b16: rs.u8 = _220[1]; + return [rs.u8Rem(b16, 2) === 0, rs.u8Rem(b16, 3) as rs.u64] as [boolean, rs.u64]; + }, rs.cmpLt(rs.cmpTuple<[boolean, rs.u64], rs.Ordering | undefined>([rs.cmp, rs.cmpReverse(rs.cmp)]))); _4(out, part9); } else if (_10 === 1) { - const part = rt.iterMinByKey(items(), (_212: [rt.usize, rt.u8]): Tilt.Tilt => { - return { _0: rt.u8Rem(_212[1], 8) }; - }, rt.cmpLt(Tilt.partialCmp$cmp_PartialOrd)); + const part = rs.iterMinByKey(items(), (_212: [rs.usize, rs.u8]): Tilt.Tilt => { + return { _0: rs.u8Rem(_212[1], 8) }; + }, rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)); _4(out, part); - const part2 = rt.iterMaxByKey(items(), (_213: [rt.usize, rt.u8]): [boolean, Tilt.Tilt] => { - const b11: rt.u8 = _213[1]; - return [rt.u8Rem(b11, 2) === 0, { _0: rt.u8Rem(b11, 8) }] as [boolean, Tilt.Tilt]; - }, rt.cmpLt(rt.cmpTuple<[boolean, Tilt.Tilt], rt.Ordering | undefined>([rt.cmp, Tilt.partialCmp$cmp_PartialOrd]))); + const part2 = rs.iterMaxByKey(items(), (_213: [rs.usize, rs.u8]): [boolean, Tilt.Tilt] => { + const b11: rs.u8 = _213[1]; + return [rs.u8Rem(b11, 2) === 0, { _0: rs.u8Rem(b11, 8) }] as [boolean, Tilt.Tilt]; + }, rs.cmpLt(rs.cmpTuple<[boolean, Tilt.Tilt], rs.Ordering | undefined>([rs.cmp, Tilt.partialCmp$cmp_PartialOrd]))); _4(out, part2); - const part3 = rt.iterMinByKey(rt.iterSlice(tilts.items), (_214: Tilt.Tilt): Tilt.Tilt | undefined => { + const part3 = rs.iterMinByKey(rs.iterSlice(tilts.items), (_214: Tilt.Tilt): Tilt.Tilt | undefined => { return _214; - }, rt.cmpLt(rt.cmpReverse(rt.cmpOption(Tilt.partialCmp$cmp_PartialOrd)))); - rt.byteVecPush(out, _55(part3)); - const part4 = rt.iterMaxByKey(rt.iterSlice(tilts.items), (_215: Tilt.Tilt): [Tilt.Tilt, rt.u8] => { + }, rs.cmpLt(rs.cmpReverse(rs.cmpOption(Tilt.partialCmp$cmp_PartialOrd)))); + rs.byteVecPush(out, _55(part3)); + const part4 = rs.iterMaxByKey(rs.iterSlice(tilts.items), (_215: Tilt.Tilt): [Tilt.Tilt, rs.u8] => { const t9: Tilt.Tilt = _215; - return [t9, rt.u8Div(t9._0, 2)] as [Tilt.Tilt, rt.u8]; - }, rt.cmpLt(rt.cmpTuple<[Tilt.Tilt, rt.u8], rt.Ordering | undefined>([rt.cmpReverse(Tilt.partialCmp$cmp_PartialOrd), rt.cmp]))); - rt.byteVecPush(out, _55(part4)); + return [t9, rs.u8Div(t9._0, 2)] as [Tilt.Tilt, rs.u8]; + }, rs.cmpLt(rs.cmpTuple<[Tilt.Tilt, rs.u8], rs.Ordering | undefined>([rs.cmpReverse(Tilt.partialCmp$cmp_PartialOrd), rs.cmp]))); + rs.byteVecPush(out, _55(part4)); } else if (_10 === 2) { - const iter: rt.Iter<[rt.u8, rt.u8 | undefined] | undefined> = rt.iterSlice([rt.iterMax(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [rt.u8, rt.u8 | undefined] => { + const iter: rs.Iter<[rs.u8, rs.u8 | undefined] | undefined> = rs.iterSlice([rs.iterMax(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): [rs.u8, rs.u8 | undefined] => { return _72(_210); - }), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8 | undefined], rt.Ordering | undefined>([rt.cmp, rt.cmpReverse(rt.cmpOption(rt.cmp))]))), rt.iterMin(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): [rt.u8, rt.u8 | undefined] => { + }), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8 | undefined], rs.Ordering | undefined>([rs.cmp, rs.cmpReverse(rs.cmpOption(rs.cmp))]))), rs.iterMin(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8 | undefined] => { return _72(_211); - }), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8 | undefined], rt.Ordering | undefined>([rt.cmp, rt.cmpReverse(rt.cmpOption(rt.cmp))])))]); + }), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8 | undefined], rs.Ordering | undefined>([rs.cmp, rs.cmpReverse(rs.cmpOption(rs.cmp))])))]); while (true) { - const _87: [rt.u8, rt.u8 | undefined] | undefined | rt.Done = iter.next(); - if (_87 === rt.DONE) { + const _87: [rs.u8, rs.u8 | undefined] | undefined | rs.Done = iter.next(); + if (_87 === rs.DONE) { break; } - const best: [rt.u8, rt.u8 | undefined] | undefined = _87; + const best: [rs.u8, rs.u8 | undefined] | undefined = _87; if (best === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(best[0], option_unwrapOr$0r2bmpr(best[1], 255)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(best[0], option_unwrapOr$1fr498u(best[1], 255)))); } } - rt.byteVecPush(out, option_mapOr$0tmtgfi(rt.iterMax(rt.iterSlice(tilts.items), rt.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t6: Tilt.Tilt): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMax(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t6: Tilt.Tilt): rs.u8 => { return t6._0; })); - rt.byteVecPush(out, option_mapOr$0tmtgfi(rt.iterMin(rt.iterSlice(tilts.items), rt.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t7: Tilt.Tilt): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterMin(rs.iterSlice(tilts.items), rs.cmpLt(Tilt.partialCmp$cmp_PartialOrd)), 255, (t7: Tilt.Tilt): rs.u8 => { return t7._0; })); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterRposition(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): boolean => { - return rt.u8Rem(_28, 3) === 0; - }), 255, (i2: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterRposition(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): boolean => { + return rs.u8Rem(_28, 3) === 0; + }), 255, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterRfind(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): boolean => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterRfind(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): boolean => { return _29 > 128; }), 0)); - const seen: rt.ByteVec = new rt.ByteVec(); - const rest: rt.Iter = rt.iterSlice(tilts.items); + const seen: rs.ByteVec = new rs.ByteVec(); + const rest: rs.Iter = rs.iterSlice(tilts.items); rest.next(); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterRposition(rest, (t3: Tilt.Tilt): boolean => { - rt.byteVecPush(seen, t3._0); + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterRposition(rest, (t3: Tilt.Tilt): boolean => { + rs.byteVecPush(seen, t3._0); return t3._0 === 2; - }), 255, (i3: rt.usize): rt.u8 => { + }), 255, (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(seen)); - rt.byteVecPush(out, rest.len() & 0xff); - rt.byteVecPush(out, option_mapOr$0tmtgfi(rt.iterRfind(rest, (t4: Tilt.Tilt): boolean => { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(seen)); + rs.byteVecPush(out, rest.len() & 0xff); + rs.byteVecPush(out, option_mapOr$0p9po8x(rs.iterRfind(rest, (t4: Tilt.Tilt): boolean => { return t4._0 > 3; - }), 255, (t5: Tilt.Tilt): rt.u8 => { + }), 255, (t5: Tilt.Tilt): rs.u8 => { return t5._0; })); - rt.byteVecPush(out, rest.len() & 0xff); + rs.byteVecPush(out, rest.len() & 0xff); } } /** Ranges as values and as iterators. */ -export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const range: rt.Range = new rt.Range(a, b); - rt.byteVecPush(out, a); - rt.byteVecPush(out, b); - rt.byteVecPush(out, rt.rangeIsEmpty(range) ? 1 : 0); - rt.byteVecPush(out, rt.rangeContains(range, 64) ? 1 : 0); - const copy: rt.Range = range.clone(); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(copy.start < copy.end ? copy.start++ : undefined, 255)); - rt.byteVecPush(out, range.len() & 0xff); - const iter: rt.Iter = rt.iterStepBy(rt.iterRev(range), 3); +export function ranges(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const range: rs.Range = new rs.Range(a, b); + rs.byteVecPush(out, a); + rs.byteVecPush(out, b); + rs.byteVecPush(out, rs.rangeIsEmpty(range) ? 1 : 0); + rs.byteVecPush(out, rs.rangeContains(range, 64) ? 1 : 0); + const copy: rs.Range = range.clone(); + rs.byteVecPush(out, option_unwrapOr$1fr498u(copy.start < copy.end ? copy.start++ : undefined, 255)); + rs.byteVecPush(out, range.len() & 0xff); + const iter: rs.Iter = rs.iterStepBy(rs.iterRev(range), 3); while (true) { - const _37: rt.u8 | rt.Done = iter.next(); - if (_37 === rt.DONE) { + const _37: rs.u8 | rs.Done = iter.next(); + if (_37 === rs.DONE) { break; } - rt.byteVecPush(out, _37); + rs.byteVecPush(out, _37); } - const iter2: rt.Iter = rt.iterStepBy(rt.iterSkip(new rt.Range(a, b), 1), 4); + const iter2: rs.Iter = rs.iterStepBy(rs.iterSkip(new rs.Range(a, b), 1), 4); while (true) { - const _47: rt.u8 | rt.Done = iter2.next(); - if (_47 === rt.DONE) { + const _47: rs.u8 | rs.Done = iter2.next(); + if (_47 === rs.DONE) { break; } - rt.byteVecPush(out, _47); + rs.byteVecPush(out, _47); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(new rt.Range(a, b), 5), 238)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(new rt.RangeInclusive(rt.max(a, 250), 255, rt.u8Step), undefined, true))); - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.rangeInclusiveStart(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(inclusive)); - rt.byteVecPush(out, rt.rangeInclusiveContains(inclusive, b) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(new rt.RangeInclusive(32, 127, rt.u64Step), a as rt.u64) ? 1 : 0); - const near: rt.RangeInclusive = new rt.RangeInclusive(rt.max(a, 200), 255, rt.u8Step); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(near, b as rt.usize), 238)); - rt.byteVecPush(out, rt.rangeInclusiveStart(near)); - rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(near) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 255) ? 1 : 0); - rt.byteVecPush(out, rt.rangeInclusiveContains(near, 100) ? 1 : 0); - const low: rt.RangeInclusive = new rt.RangeInclusive(0, b, rt.u8Step); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNthBack(low, rt.usizeRem(a as rt.usize, 16)), 238)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(low)); - rt.byteVecPush(out, rt.rangeInclusiveContains(low, rt.u8Div(b, 2)) ? 1 : 0); - const reversed: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.iterRev(rt.iterBorrow(reversed)), a as rt.usize), 238)); - rt.byteVecPush(out, rt.rangeInclusiveEnd(reversed)); - rt.byteVecPush(out, rt.rangeInclusiveContains(reversed, a) ? 1 : 0); - const counted: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(new rt.RangeInclusive(a, b, rt.u8Step)); - const _149: [rt.usize, rt.u8] = option_unwrapOr$14m5xjm(rt.iterNth(counted, rt.usizeDiv(b as rt.usize, 4)), [221, 221] as [rt.usize, rt.u8]); - const i3: rt.usize = _149[0]; - const n: rt.u8 = _149[1]; - rt.byteVecPush(out, i3 & 0xff); - rt.byteVecPush(out, n); - rt.byteVecPush(out, option_mapOr$06gg5x7(rt.iterToOption(counted.next()), 204, (_2: [rt.usize, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(new rs.Range(a, b), 5), 238)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(new rs.RangeInclusive(rs.max(a, 250), 255, rs.u8Step), undefined, true))); + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + rs.byteVecPush(out, rs.rangeInclusiveStart(inclusive)); + rs.byteVecPush(out, rs.rangeInclusiveEnd(inclusive)); + rs.byteVecPush(out, rs.rangeInclusiveContains(inclusive, b) ? 1 : 0); + rs.byteVecPush(out, rs.rangeInclusiveContains(new rs.RangeInclusive(32, 127, rs.u64Step), a as rs.u64) ? 1 : 0); + const near: rs.RangeInclusive = new rs.RangeInclusive(rs.max(a, 200), 255, rs.u8Step); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(near, b as rs.usize), 238)); + rs.byteVecPush(out, rs.rangeInclusiveStart(near)); + rs.byteVecPush(out, rs.rangeInclusiveIsEmpty(near) ? 1 : 0); + rs.byteVecPush(out, rs.rangeInclusiveContains(near, 255) ? 1 : 0); + rs.byteVecPush(out, rs.rangeInclusiveContains(near, 100) ? 1 : 0); + const low: rs.RangeInclusive = new rs.RangeInclusive(0, b, rs.u8Step); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNthBack(low, rs.usizeRem(a as rs.usize, 16)), 238)); + rs.byteVecPush(out, rs.rangeInclusiveEnd(low)); + rs.byteVecPush(out, rs.rangeInclusiveContains(low, rs.u8Div(b, 2)) ? 1 : 0); + const reversed: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterRev(rs.iterBorrow(reversed)), a as rs.usize), 238)); + rs.byteVecPush(out, rs.rangeInclusiveEnd(reversed)); + rs.byteVecPush(out, rs.rangeInclusiveContains(reversed, a) ? 1 : 0); + const counted: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(new rs.RangeInclusive(a, b, rs.u8Step)); + const _149: [rs.usize, rs.u8] = option_unwrapOr$1g3ltyz(rs.iterNth(counted, rs.usizeDiv(b as rs.usize, 4)), [221, 221] as [rs.usize, rs.u8]); + const i3: rs.usize = _149[0]; + const n: rs.u8 = _149[1]; + rs.byteVecPush(out, i3 & 0xff); + rs.byteVecPush(out, n); + rs.byteVecPush(out, option_mapOr$0i0fno7(rs.iterToOption(counted.next()), 204, (_2: [rs.usize, rs.u8]): rs.u8 => { return _2[0] & 0xff; })); - const stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.byteVecPush(out, rt.iterCount(rt.iterStepBy(rt.iterBorrow(stepped), 3)) & 0xff); - rt.byteVecPush(out, rt.rangeInclusiveStart(stepped)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(new rt.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rt.i8Step)), (i5: rt.i8): rt.u8 => { + const stepped: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + rs.byteVecPush(out, rs.iterCount(rs.iterStepBy(rs.iterBorrow(stepped), 3)) & 0xff); + rs.byteVecPush(out, rs.rangeInclusiveStart(stepped)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(new rs.RangeInclusive((a << 24) >> 24, (b << 24) >> 24, rs.i8Step)), (i5: rs.i8): rs.u8 => { return i5 & 0xff; }), undefined, true); - const wide: rt.Range = new rt.Range(a as rt.u64, rt.u64Mul(b as rt.u64, 3), rt.u64Step); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterBorrow(wide), (n2: rt.u64): rt.u64 => { - return rt.u64Rem(n2, 5); - }), (_23: rt.u64): boolean => { + const wide: rs.Range = new rs.Range(a as rs.u64, rs.u64Mul(b as rs.u64, 3), rs.u64Step); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterBorrow(wide), (n2: rs.u64): rs.u64 => { + return rs.u64Rem(n2, 5); + }), (_23: rs.u64): boolean => { return _23 === 0; })) & 0xff); - rt.byteVecPush(out, rt.rangeIsEmpty(wide) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(new rt.Range(0, a as rt.u64, rt.u64Step), rt.u64Add, 0)))); - const edge: rt.u64 = rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), rt.u64Rem(a as rt.u64, 4)); - const past: rt.Range = new rt.Range(edge, rt.u64Add(edge, 4), rt.u64Step); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_unwrapOr$1tvry1i(rt.iterNth(past, rt.usizeRem(b as rt.usize, 3)), 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_unwrapOr$1tvry1i(rt.iterToOption(past.nextBack()), 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_unwrapOr$1tvry1i(rt.iterNth(new rt.RangeInclusive(edge, rt.u64Add(edge, 3), rt.u64Step), rt.usizeRem(b as rt.usize, 5)), 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a as rt.u64, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), (n4: rt.u64): rt.u64 => { - return rt.u64Rem(n4, 7); - }), rt.u64Add, 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_unwrapOr$1tvry1i(rt.iterMaxByKey(rt.iterRev(new rt.RangeInclusive(edge, rt.u64Add(edge, 2), rt.u64Step)), (_24: rt.u64): rt.u64 => { + rs.byteVecPush(out, rs.rangeIsEmpty(wide) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.iterSum(new rs.Range(0, a as rs.u64, rs.u64Step), rs.u64Add, 0)))); + const edge: rs.u64 = rs.u64Add(rs.u64Sub({ hi: 0x200000, lo: 0 } as rs.u64, 2), rs.u64Rem(a as rs.u64, 4)); + const past: rs.Range = new rs.Range(edge, rs.u64Add(edge, 4), rs.u64Step); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_unwrapOr$15hbiwd(rs.iterNth(past, rs.usizeRem(b as rs.usize, 3)), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_unwrapOr$15hbiwd(rs.iterToOption(past.nextBack()), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_unwrapOr$15hbiwd(rs.iterNth(new rs.RangeInclusive(edge, rs.u64Add(edge, 3), rs.u64Step), rs.usizeRem(b as rs.usize, 5)), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.iterSum(rs.iterMap(new rs.RangeInclusive(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Rem(a as rs.u64, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step), (n4: rs.u64): rs.u64 => { + return rs.u64Rem(n4, 7); + }), rs.u64Add, 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_unwrapOr$15hbiwd(rs.iterMaxByKey(rs.iterRev(new rs.RangeInclusive(edge, rs.u64Add(edge, 2), rs.u64Step)), (_24: rs.u64): rs.u64 => { return _24; - }, rt.lt), 0)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(option_unwrapOr$00uis1j(rt.iterMin(new rt.Range(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Add(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 1), rt.i64Step), rt.lt), 0)))); - for (const _295 of rt.iterToVec(rt.iterRev(rt.iterStepBy(new rt.Range(0, 48), 8, undefined, 4294967295)), undefined, 4, true).items) { - rt.byteVecPush(out, _295 & 0xff); + }, rs.lt), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(option_unwrapOr$00tqxtm(rs.iterMin(new rs.Range(rs.i64Sub(rs.i64Neg({ hi: 0x200000, lo: 0 } as rs.i64), 1), rs.i64Add(rs.i64Neg({ hi: 0x200000, lo: 0 } as rs.i64), 1), rs.i64Step), rs.lt), 0)))); + for (const _295 of rs.iterToVec(rs.iterRev(rs.iterStepBy(new rs.Range(0, 48), 8, undefined, 4294967295)), undefined, 4, true).items) { + rs.byteVecPush(out, _295 & 0xff); } updates(a, b, data, out); } @@ -1245,144 +1245,144 @@ export function ranges(data: rt.ByteSlice, out: rt.ByteVec): void { * Struct update syntax on std's ranges: the fields written run before the base, and * the rest are read from it. */ -export function updates(a: rt.u8, b: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _29!: rt.u8; - const base: rt.Range = new rt.Range(a, b); - rt.byteVecPush(out, 208); - const _7: rt.u8 = rt.u8Div(b, 2); - rt.byteVecPush(out, 209); - const made: rt.Range = new rt.Range(base.clone().start, _7); - const _14: rt.Range = base.clone(); - const whole: rt.Range = new rt.Range(_14.start, _14.end); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(made.start, _7, whole.start, whole.end))); - let iterStart: rt.u8 = rt.u8Div(a, 2); - const iterEnd: rt.u8 = base.end; +export function updates(a: rs.u8, b: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _29!: rs.u8; + const base: rs.Range = new rs.Range(a, b); + rs.byteVecPush(out, 208); + const _7: rs.u8 = rs.u8Div(b, 2); + rs.byteVecPush(out, 209); + const made: rs.Range = new rs.Range(base.clone().start, _7); + const _14: rs.Range = base.clone(); + const whole: rs.Range = new rs.Range(_14.start, _14.end); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(made.start, _7, whole.start, whole.end))); + let iterStart: rs.u8 = rs.u8Div(a, 2); + const iterEnd: rs.u8 = base.end; while ((_29 = iterStart++) < iterEnd) { - const i: rt.u8 = _29; - const _33: rt.u8 = rt.u8WrappingAdd(base.end, 1); + const i: rs.u8 = _29; + const _33: rs.u8 = rs.u8WrappingAdd(base.end, 1); base.end = _33; - rt.byteVecPush(out, i); + rs.byteVecPush(out, i); } - rt.byteVecPush(out, base.end); - const len: rt.usize = data.length; - const _41: [rt.usize, rt.usize] = [rt.min(b as rt.usize, len), rt.min(a as rt.usize, len)]; - const to: rt.usize = _41[0]; - const from: rt.usize = _41[1]; - const all: rt.Range = new rt.Range(0, len); - rt.byteVecPush(out, 210); - rt.byteVecPush(out, 211); - rt.byteVecPush(out, 212); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(data, from, all.clone().end)); - rt.byteVecPush(out, 213); - rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); - rt.byteVecPush(out, 214); - rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); + rs.byteVecPush(out, base.end); + const len: rs.usize = data.length; + const _41: [rs.usize, rs.usize] = [rs.min(b as rs.usize, len), rs.min(a as rs.usize, len)]; + const to: rs.usize = _41[0]; + const from: rs.usize = _41[1]; + const all: rs.Range = new rs.Range(0, len); + rs.byteVecPush(out, 210); + rs.byteVecPush(out, 211); + rs.byteVecPush(out, 212); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(data, from, all.clone().end)); + rs.byteVecPush(out, 213); + rs.byteVecPush(out, rs.byteSliceRange(data, 0).length & 0xff); + rs.byteVecPush(out, 214); + rs.byteVecPush(out, rs.byteSliceRange(data, 0).length & 0xff); fullRange(out); - rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); - rt.byteVecPush(out, rt.byteSliceRange(data, 0).length & 0xff); - const copied: rt.ByteVec = rt.byteSliceToByteVec(data); - const _76: rt.ByteSlice = rt.byteVecSlice(copied); - const _78: rt.Range = new rt.Range(0, to); - rt.byteSliceCopyWithin(_76, _78.start, _78.end, 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(copied)); + rs.byteVecPush(out, rs.byteSliceRange(data, 0).length & 0xff); + rs.byteVecPush(out, rs.byteSliceRange(data, 0).length & 0xff); + const copied: rs.ByteVec = rs.byteSliceToByteVec(data); + const _76: rs.ByteSlice = rs.byteVecSlice(copied); + const _78: rs.Range = new rs.Range(0, to); + rs.byteSliceCopyWithin(_76, _78.start, _78.end, 0); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(copied)); } /** `..`, logging that it was made. */ -export function fullRange(out: rt.ByteVec): undefined { - rt.byteVecPush(out, 215); +export function fullRange(out: rs.ByteVec): undefined { + rs.byteVecPush(out, 215); } /** Iterators of `Option`, which keep each `None` apart from their end. */ -export function options(data: rt.ByteSlice, out: rt.ByteVec): void { - const _83: (a0: rt.u8, a1: rt.ByteVec) => rt.u8 | undefined = (b2: rt.u8, calls2: rt.ByteVec): rt.u8 | undefined => { - rt.byteVecPush(calls2, b2); - return option_map$0cs071d(rt.u8CheckedSub(b2, 1), (b3: rt.u8): rt.u8 => { - return rt.u8Div(b3, 2); +export function options(data: rs.ByteSlice, out: rs.ByteVec): void { + const _83: (a0: rs.u8, a1: rs.ByteVec) => rs.u8 | undefined = (b2: rs.u8, calls2: rs.ByteVec): rs.u8 | undefined => { + rs.byteVecPush(calls2, b2); + return option_map$1yjmt5m(rs.u8CheckedSub(b2, 1), (b3: rs.u8): rs.u8 => { + return rs.u8Div(b3, 2); }); }; - const all: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b4, 3) === 0)) { + const all: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b4, 3) === 0)) { return b4; } return undefined; }), undefined, 2, true); - rt.byteVecPush(out, all.items.length & 0xff); - const iter: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b5, 3) === 0)) { + rs.byteVecPush(out, all.items.length & 0xff); + const iter: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b5, 3) === 0)) { return b5; } return undefined; }); while (true) { - const _15: rt.u8 | undefined | rt.Done = iter.next(); - if (_15 === rt.DONE) { + const _15: rs.u8 | undefined | rs.Done = iter.next(); + if (_15 === rs.DONE) { break; } - const item: rt.u8 | undefined = _15; + const item: rs.u8 | undefined = _15; if (item === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecPush(out, item); + rs.byteVecPush(out, item); } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b6: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b6, 3) === 0)) { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b6: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b6, 3) === 0)) { return b6; } return undefined; - }), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true), "next"))); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(all.items), (o: rt.u8 | undefined): boolean => { + }), (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true), "next"))); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterSlice(all.items), (o: rs.u8 | undefined): boolean => { return o !== undefined; })) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(second$iter_Map_slice_Iter_u8_iters_options_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b7: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b7, 3) === 0)) { + rs.byteVecPush(out, option_unwrapOr$1fr498u(second$iter_Map_slice_Iter_u8_iters_options_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b7: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b7, 3) === 0)) { return b7; } return undefined; })), 205)); - const first: rt.u8 | undefined = rt.byteSliceFirst(data); - const iter2: rt.Iter = rt.iterChain(rt.iterOption(first), rt.iterOnce(153)); + const first: rs.u8 | undefined = rs.byteSliceFirst(data); + const iter2: rs.Iter = rs.iterChain(rs.iterOption(first), rs.iterOnce(153)); while (true) { - const _49: rt.u8 | rt.Done = iter2.next(); - if (_49 === rt.DONE) { + const _49: rs.u8 | rs.Done = iter2.next(); + if (_49 === rs.DONE) { break; } - rt.byteVecPush(out, _49); + rs.byteVecPush(out, _49); } - const _57: rt.Iter = rt.iterOption(first); - rt.iterEmpty(); - rt.iterExtendBytes(out, rt.iterChain(_57, rt.iterEmpty() as rt.Iter), undefined, true); - let n: rt.u8 = 0; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFromFn((): rt.u8 | undefined => { - n = rt.u8Add(n, 1); - return thenSome$0d5am30(n < 4, n); + const _57: rs.Iter = rs.iterOption(first); + rs.iterEmpty(); + rs.iterExtendBytes(out, rs.iterChain(_57, rs.iterEmpty() as rs.Iter), undefined, true); + let n: rs.u8 = 0; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFromFn((): rs.u8 | undefined => { + n = rs.u8Add(n, 1); + return thenSome$0quywni(n < 4, n); }), "next"))); - let k: rt.u8 = 0; - rt.iterEmpty(); - const _70: rt.Iter = rt.iterFromFn((): rt.u8 | undefined => { - k = rt.u8Add(k, 1); - return thenSome$0d5am30(k !== 2, k); + let k: rs.u8 = 0; + rs.iterEmpty(); + const _70: rs.Iter = rs.iterFromFn((): rs.u8 | undefined => { + k = rs.u8Add(k, 1); + return thenSome$0quywni(k !== 2, k); }); - const gappy: rt.Iter = rt.iterChain(rt.iterEmpty() as rt.Iter, _70); - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(gappy)) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(gappy.next()), 238)); - const calls: rt.ByteVec = new rt.ByteVec(); - const first2: rt.u8 | undefined = rt.byteSliceFirst(data); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterSuccessors(first2, (b8: rt.u8): rt.u8 | undefined => { + const gappy: rs.Iter = rs.iterChain(rs.iterEmpty() as rs.Iter, _70); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(gappy)) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(gappy.next()), 238)); + const calls: rs.ByteVec = new rs.ByteVec(); + const first2: rs.u8 | undefined = rs.byteSliceFirst(data); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSuccessors(first2, (b8: rs.u8): rs.u8 | undefined => { return _83(b8, calls); - }), rt.usizeRem(data.length, 4)), "next"))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(calls)); - rt.byteVecPush(out, rt.iterCount(rt.iterSuccessors(first2, (b9: rt.u8): rt.u8 | undefined => { + }), rs.usizeRem(data.length, 4)), "next"))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(calls)); + rs.byteVecPush(out, rs.iterCount(rs.iterSuccessors(first2, (b9: rs.u8): rs.u8 | undefined => { return _83(b9, calls); })) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(calls)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(calls)); const iter3: Gaps.Gaps = { dataData: data.data, dataStart: data.start, dataLen: data.length, at: 0 }; while (true) { - const _114: rt.u8 | undefined | rt.Done = Gaps.next$iter_Iterator(iter3); - if (_114 === rt.DONE) { + const _114: rs.u8 | undefined | rs.Done = Gaps.next$iter_Iterator(iter3); + if (_114 === rs.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1surhce(_114, 170, (b10: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(_114, 170, (b10: rs.u8): rs.u8 => { return b10; })); } @@ -1390,66 +1390,66 @@ export function options(data: rt.ByteSlice, out: rt.ByteVec): void { /** * Loops over options, each item's own `Option` tested apart from the iterator's end, for - * each way JS holds `None`: `undefined`, `rt.None` where `Some` can be `undefined`, and + * each way JS holds `None`: `undefined`, `rs.None` where `Some` can be `undefined`, and * nested. */ -export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { - let _44!: rt.u8; +export function optionItems(data: rs.ByteSlice, out: rs.ByteVec): void { + let _44!: rs.u8; let _67!: boolean; - let _87!: undefined | rt.None; - let _138!: rt.u8; - const _3: (a0: rt.u8) => rt.u8 | undefined = (b4: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b4, 3) === 0)) { + let _87!: undefined | rs.None; + let _138!: rs.u8; + const _3: (a0: rs.u8) => rs.u8 | undefined = (b4: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b4, 3) === 0)) { return b4; } return undefined; }; - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u32 | undefined => { - return option_map$1c7zybz(_3(b5), (a0: rt.u8): rt.u32 => { - return a0 as rt.u32; + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u32 | undefined => { + return option_map$1806e7m(_3(b5), (a0: rs.u8): rs.u32 => { + return a0 as rs.u32; }); }), undefined, 8, true); - const units: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b6: rt.u8): undefined | rt.None => { - return option_map$0p22lts(_3(b6), (_2: rt.u8): undefined => {}); + const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b6: rs.u8): undefined | rs.None => { + return option_map$057a36e(_3(b6), (_2: rs.u8): undefined => {}); }), undefined, 1, true); - const nested: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): rt.u8 | undefined | rt.None => { - const b7: rt.u8 = _23; - const _45: rt.u8 = rt.u8Rem(b7, 4); + const nested: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): rs.u8 | undefined | rs.None => { + const b7: rs.u8 = _23; + const _45: rs.u8 = rs.u8Rem(b7, 4); if (_45 === 0) { - return rt.None; + return rs.None; } if (_45 === 1) { return undefined; } return b7; }), undefined, 2, true); - const badges: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b8: rt.u8): Badge.Badge | undefined => { - return option_map$0of9gds(_3(b8), (_24: rt.u8): Badge.Badge => { + const badges: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b8: rs.u8): Badge.Badge | undefined => { + return option_map$0vu84i0(_3(b8), (_24: rs.u8): Badge.Badge => { return new of$u8(b8); }); }), undefined, 8, true); for (const _26 of words.items) { if (_26 !== undefined) { - rt.byteVecPush(out, _26 & 0xff); + rs.byteVecPush(out, _26 & 0xff); } else { - rt.byteVecPush(out, 160); + rs.byteVecPush(out, 160); } } for (const _39 of units.items) { - if (_39 !== rt.None) { + if (_39 !== rs.None) { _44 = 161; } else { _44 = 162; } - rt.byteVecPush(out, _44); + rs.byteVecPush(out, _44); } for (const _50 of nested.items) { - if (_50 === rt.None) { - rt.byteVecPush(out, 164); + if (_50 === rs.None) { + rs.byteVecPush(out, 164); } else if (_50 === undefined) { - rt.byteVecPush(out, 163); + rs.byteVecPush(out, 163); } else { - rt.byteVecPush(out, _50); + rs.byteVecPush(out, _50); } } for (const _61 of badges.items) { @@ -1458,179 +1458,179 @@ export function optionItems(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _67 = false; } - rt.byteVecPush(out, _67 ? 1 : 0); + rs.byteVecPush(out, _67 ? 1 : 0); } - const iter5: rt.Iter> = rt.iterSliceMut(words.items); + const iter5: rs.Iter> = rs.iterSliceMut(words.items); while (true) { - const _72: rt.Place | rt.Done = iter5.next(); - if (_72 === rt.DONE) { + const _72: rs.Place | rs.Done = iter5.next(); + if (_72 === rs.DONE) { break; } if (_72.v === undefined) { _72.v = 165; } else { - _72.v = rt.u32Add(_72.v, 1); + _72.v = rs.u32Add(_72.v, 1); } } - const iter6: rt.Iter> = rt.iterSliceMut(units.items); + const iter6: rs.Iter> = rs.iterSliceMut(units.items); while (true) { - const _83: rt.Place | rt.Done = iter6.next(); - if (_83 === rt.DONE) { + const _83: rs.Place | rs.Done = iter6.next(); + if (_83 === rs.DONE) { break; } - if (_83.v === rt.None) { + if (_83.v === rs.None) { _87 = undefined; } else { - _87 = rt.None; + _87 = rs.None; } _83.v = _87; } - const iter7: rt.Iter> = rt.iterSliceMut(nested.items); + const iter7: rs.Iter> = rs.iterSliceMut(nested.items); while (true) { - const _94: rt.Place | rt.Done = iter7.next(); - if (_94 === rt.DONE) { + const _94: rs.Place | rs.Done = iter7.next(); + if (_94 === rs.DONE) { break; } - if (_94.v !== rt.None) { + if (_94.v !== rs.None) { if (_94.v !== undefined) { - _94.v = rt.u8WrappingAdd(_94.v, 1); + _94.v = rs.u8WrappingAdd(_94.v, 1); continue; } } - if (_94.v !== rt.None) { + if (_94.v !== rs.None) { _94.v = 166; } } - const iter8: rt.Iter = rt.iterSlice(words.items); + const iter8: rs.Iter = rs.iterSlice(words.items); while (true) { - const _111: rt.u32 | undefined | rt.Done = iter8.next(); - if (_111 === rt.DONE) { + const _111: rs.u32 | undefined | rs.Done = iter8.next(); + if (_111 === rs.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1sxa8ki(_111, 167, (a5: rt.u32): rt.u8 => { + rs.byteVecPush(out, option_mapOr$07pvkk0(_111, 167, (a5: rs.u32): rs.u8 => { return a5 & 0xff; })); } - rt.byteVecPush(out, present$unit(units.items)); - rt.byteVecPush(out, present$Option_u8(nested.items)); - rt.byteVecPush(out, present$ref_dyn_iters_Badge(badges.items)); + rs.byteVecPush(out, present$unit(units.items)); + rs.byteVecPush(out, present$Option_u8(nested.items)); + rs.byteVecPush(out, present$ref_dyn_iters_Badge(badges.items)); for (const a of units.items) { - if (a !== rt.None) { + if (a !== rs.None) { _138 = 168; } else { _138 = 169; } - rt.byteVecPush(out, _138); + rs.byteVecPush(out, _138); } - for (const a2 of rt.vecFrom(nested.items.slice()).items) { - if (a2 !== rt.None) { + for (const a2 of rs.vecFrom(nested.items.slice()).items) { + if (a2 !== rs.None) { if (a2 !== undefined) { - rt.byteVecPush(out, a2); + rs.byteVecPush(out, a2); continue; } } - if (a2 === rt.None) { - rt.byteVecPush(out, 170); + if (a2 === rs.None) { + rs.byteVecPush(out, 170); } } - const itS: Array = nested.items; + const itS: Array = nested.items; let itI: number = 0; while (true) { - const _157: rt.u8 | undefined | rt.None | rt.Done = itI < itS.length ? itS[itI++] : rt.DONE; - if (_157 !== rt.DONE) { - const a3: rt.u8 | undefined | rt.None = _157; - if (a3 === rt.None) { - rt.byteVecPush(out, 172); + const _157: rs.u8 | undefined | rs.None | rs.Done = itI < itS.length ? itS[itI++] : rs.DONE; + if (_157 !== rs.DONE) { + const a3: rs.u8 | undefined | rs.None = _157; + if (a3 === rs.None) { + rs.byteVecPush(out, 172); } else { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(a3, 171)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(a3, 171)); } } else { break; } } - const it2: rt.Iter = rt.iterSlice(words.items); + const it2: rs.Iter = rs.iterSlice(words.items); while (true) { - const _167: rt.u8 | undefined = firstPresent(it2); + const _167: rs.u8 | undefined = firstPresent(it2); if (_167 !== undefined) { - rt.byteVecPush(out, _167); + rs.byteVecPush(out, _167); } else { break; } } - let sum: rt.u8 = 0; - for (const _179 of rt.iterToVec(rt.iterScan(rt.iterSlice(rt.byteSliceView(data)), rt.place(() => sum, (value) => sum = value), (n: rt.Place>, _310: rt.u8): rt.u8 | undefined | rt.None => { - const b9: rt.u8 = _310; - const _55: rt.u8 = rt.u8WrappingAdd(n.v.v, b9); + let sum: rs.u8 = 0; + for (const _179 of rs.iterToVec(rs.iterScan(rs.iterSlice(rs.byteSliceView(data)), rs.place(() => sum, (value) => sum = value), (n: rs.Place>, _310: rs.u8): rs.u8 | undefined | rs.None => { + const b9: rs.u8 = _310; + const _55: rs.u8 = rs.u8WrappingAdd(n.v.v, b9); n.v.v = _55; - return thenSome$185ufyt(rt.u8Rem(b9, 5) !== 4, thenSome$0d5am30(rt.u8Rem(b9, 2) === 0, n.v.v)); - }, true, undefined, rt.None), "next", 2).items) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_179, 173)); + return thenSome$1ctlqen(rs.u8Rem(b9, 5) !== 4, thenSome$0quywni(rs.u8Rem(b9, 2) === 0, n.v.v)); + }, true, undefined, rs.None), "next", 2).items) { + rs.byteVecPush(out, option_unwrapOr$1fr498u(_179, 173)); } - rt.byteVecPush(out, sum); - rt.byteVecPush(out, rt.iterCount(rt.iterScan(rt.iterSlice(rt.byteSliceView(data)), undefined, (_25: rt.Place, _311: rt.u8): undefined | rt.None => { - return thenSome$1j8foe9(rt.u8Rem(_311, 5) !== 4, undefined); - }, true, undefined, rt.None)) & 0xff); - const weighed: Weighed.Weighed = { inner: rt.iterSlice(rt.byteSliceView(data)), weight: 0 }; + rs.byteVecPush(out, sum); + rs.byteVecPush(out, rs.iterCount(rs.iterScan(rs.iterSlice(rs.byteSliceView(data)), undefined, (_25: rs.Place, _311: rs.u8): undefined | rs.None => { + return thenSome$1n1oy1h(rs.u8Rem(_311, 5) !== 4, undefined); + }, true, undefined, rs.None)) & 0xff); + const weighed: Weighed.Weighed = { inner: rs.iterSlice(rs.byteSliceView(data)), weight: 0 }; while (true) { - const _194: rt.u8 | rt.Done = Weighed.next$iter_Iterator(weighed); - if (_194 !== rt.DONE) { - rt.byteVecPush(out, _194); + const _194: rs.u8 | rs.Done = Weighed.next$iter_Iterator(weighed); + if (_194 !== rs.DONE) { + rs.byteVecPush(out, _194); } else { break; } } - rt.byteVecPush(out, weighed.weight); + rs.byteVecPush(out, weighed.weight); } /** How many items are `Some`, of a slice of options of any `T`. */ -export function present$Option_u8(items: Array): rt.u8 { - let n: rt.u8 = 0; - const iter: rt.Iter = rt.iterSlice(items); +export function present$Option_u8(items: Array): rs.u8 { + let n: rs.u8 = 0; + const iter: rs.Iter = rs.iterSlice(items); while (true) { - const _6: rt.u8 | undefined | rt.None | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.u8 | undefined | rs.None | rs.Done = iter.next(); + if (_6 === rs.DONE) { return n; } - if (_6 !== rt.None) { - n = rt.u8Add(n, 1); + if (_6 !== rs.None) { + n = rs.u8Add(n, 1); } } } /** How many items are `Some`, of a slice of options of any `T`. */ -export function present$ref_dyn_iters_Badge(items: Array): rt.u8 { - let n: rt.u8 = 0; - const iter: rt.Iter = rt.iterSlice(items); +export function present$ref_dyn_iters_Badge(items: Array): rs.u8 { + let n: rs.u8 = 0; + const iter: rs.Iter = rs.iterSlice(items); while (true) { - const _6: Badge.Badge | undefined | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: Badge.Badge | undefined | rs.Done = iter.next(); + if (_6 === rs.DONE) { return n; } if (_6 !== undefined) { - n = rt.u8Add(n, 1); + n = rs.u8Add(n, 1); } } } /** How many items are `Some`, of a slice of options of any `T`. */ -export function present$unit(items: Array): rt.u8 { - let n: rt.u8 = 0; - const iter: rt.Iter = rt.iterSlice(items); +export function present$unit(items: Array): rs.u8 { + let n: rs.u8 = 0; + const iter: rs.Iter = rs.iterSlice(items); while (true) { - const _6: undefined | rt.None | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: undefined | rs.None | rs.Done = iter.next(); + if (_6 === rs.DONE) { return n; } - if (_6 !== rt.None) { - n = rt.u8Add(n, 1); + if (_6 !== rs.None) { + n = rs.u8Add(n, 1); } } } /** The next item through `?`, which tests for the end, and then its own `None`. */ -export function firstPresent(it: rt.Iter): rt.u8 | undefined { - const _2: rt.u32 | undefined | rt.Done = it.next(); - if (_2 !== rt.DONE) { +export function firstPresent(it: rs.Iter): rs.u8 | undefined { + const _2: rs.u32 | undefined | rs.Done = it.next(); + if (_2 !== rs.DONE) { if (_2 === undefined) { return 173; } @@ -1640,11 +1640,11 @@ export function firstPresent(it: rt.Iter): rt.u8 | undefined } /** The second item of an iterator of options, through `?`, which tests for its end. */ -export function second$iter_Map_slice_Iter_u8_iters_options_closure0(items: rt.Iter): rt.u8 | undefined { - if (items.next() !== rt.DONE) { - const _7: rt.u8 | undefined | rt.Done = items.next(); - if (_7 !== rt.DONE) { - return option_unwrapOr$0r2bmpr(_7, 171); +export function second$iter_Map_slice_Iter_u8_iters_options_closure0(items: rs.Iter): rs.u8 | undefined { + if (items.next() !== rs.DONE) { + const _7: rs.u8 | undefined | rs.Done = items.next(); + if (_7 !== rs.DONE) { + return option_unwrapOr$1fr498u(_7, 171); } return undefined; } @@ -1652,127 +1652,127 @@ export function second$iter_Map_slice_Iter_u8_iters_options_closure0(items: rt.I } /** The crate's own iterators, through `for`, adaptors, and `next`. */ -export function own(data: rt.ByteSlice, out: rt.ByteVec): void { - const left: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const step: rt.u8 = rt.max(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 1), 1); +export function own(data: rs.ByteSlice, out: rs.ByteVec): void { + const left: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const step: rs.u8 = rs.max(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 1), 1); const iter: Countdown.Countdown = { left, step }; while (true) { - const _13: rt.u8 | rt.Done = Countdown.next$iter_Iterator(iter); - if (_13 === rt.DONE) { + const _13: rs.u8 | rs.Done = Countdown.next$iter_Iterator(iter); + if (_13 === rs.DONE) { break; } - rt.byteVecPush(out, _13); + rs.byteVecPush(out, _13); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterMap(rt.iterFrom({ left, step }, Countdown.next$iter_Iterator), (n4: rt.u8): rt.u64 => { - return rt.u64Div(rt.u64Mul(n4 as rt.u64, 1000), 7); - }), rt.u64Add, 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.iterSum(rs.iterMap(rs.iterFrom({ left, step }, Countdown.next$iter_Iterator), (n4: rs.u8): rs.u64 => { + return rs.u64Div(rs.u64Mul(n4 as rs.u64, 1000), 7); + }), rs.u64Add, 0)))); const down: Countdown.Countdown = { left, step }; while (true) { - const _26: rt.u8 | rt.Done = Countdown.next$iter_Iterator(down); - if (_26 !== rt.DONE) { - if (rt.u8Rem(_26, 5) === 0) { + const _26: rs.u8 | rs.Done = Countdown.next$iter_Iterator(down); + if (_26 !== rs.DONE) { + if (rs.u8Rem(_26, 5) === 0) { break; } } else { break; } } - rt.byteVecPush(out, down.left); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom({ inner: rt.iterSlice(rt.byteSliceView(data)) }, Evens.next$iter_Iterator), "next"))); - const byRef: Evens.Evens = { inner: rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.min(data.length, 1)))) }; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterFrom(byRef, Evens.next$iter_Iterator), 2), "next"))); + rs.byteVecPush(out, down.left); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom({ inner: rs.iterSlice(rs.byteSliceView(data)) }, Evens.next$iter_Iterator), "next"))); + const byRef: Evens.Evens = { inner: rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, rs.min(data.length, 1)))) }; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterFrom(byRef, Evens.next$iter_Iterator), 2), "next"))); const iter2: Evens.Evens = byRef; while (true) { - const _60: rt.u8 | rt.Done = Evens.next$iter_Iterator(iter2); - if (_60 === rt.DONE) { + const _60: rs.u8 | rs.Done = Evens.next$iter_Iterator(iter2); + if (_60 === rs.DONE) { break; } - const n3: rt.u8 = _60; - if (!(rt.u8Rem(n3, 4) === 0)) { - rt.byteVecPush(out, n3); + const n3: rs.u8 = _60; + if (!(rs.u8Rem(n3, 4) === 0)) { + rs.byteVecPush(out, n3); } else { break; } } - rt.byteVecPush(out, rt.iterCount(rt.iterFrom(byRef, Evens.next$iter_Iterator)) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.iterToByteVec(rt.iterFrom(new Halving.Halving(left), Halving.next$iter_Iterator_u8), "next"))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.iterSum(rt.iterFrom(new Halving.Halving(rt.u64Mul(left as rt.u64, 4294967297)), Halving.next$iter_Iterator_u64), rt.u64Add, 0)))); + rs.byteVecPush(out, rs.iterCount(rs.iterFrom(byRef, Evens.next$iter_Iterator)) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.iterToByteVec(rs.iterFrom(new Halving.Halving(left), Halving.next$iter_Iterator_u8), "next"))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.iterSum(rs.iterFrom(new Halving.Halving(rs.u64Mul(left as rs.u64, 4294967297)), Halving.next$iter_Iterator_u64), rs.u64Add, 0)))); } /** * The last two bytes of `data`, as a `slice::Iter` made from the second argument: a * `for` must iterate it, not the first. */ -export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, data: rt.ByteSlice): rt.Iter { - return rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, rt.usizeSaturatingSub(data.length, 2)))); +export function tail(_headData: Uint8Array, _headStart: number, _headLen: number, data: rs.ByteSlice): rs.Iter { + return rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, rs.usizeSaturatingSub(data.length, 2)))); } /** The odd bytes, from a function returning `impl Iterator`. */ -export function odds(data: rt.ByteSlice): rt.Iter { - return rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): boolean => { - return rt.u8Rem(b, 2) === 1; +export function odds(data: rs.ByteSlice): rs.Iter { + return rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): boolean => { + return rs.u8Rem(b, 2) === 1; }); } /** Iterators as values: returned, stored, and printed. */ -export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1, 2, 3)); - const iter: rt.Iter = tail(_5.data, _5.start, _5.length, data); +export function values(data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(1, 2, 3)); + const iter: rs.Iter = tail(_5.data, _5.start, _5.length, data); while (true) { - const _8: rt.u8 | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: rs.u8 | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } - rt.byteVecPush(out, _8); + rs.byteVecPush(out, _8); } - const held: Held.Held = { it: rt.iterSlice(rt.byteSliceView(data)) }; - rt.byteVecPush(out, Held.skipOne(held)); - const iter2: rt.Iter = odds(data); + const held: Held.Held = { it: rs.iterSlice(rs.byteSliceView(data)) }; + rs.byteVecPush(out, Held.skipOne(held)); + const iter2: rs.Iter = odds(data); while (true) { - const _21: rt.u8 | rt.Done = iter2.next(); - if (_21 === rt.DONE) { + const _21: rs.u8 | rs.Done = iter2.next(); + if (_21 === rs.DONE) { break; } - rt.byteVecPush(out, _21); + rs.byteVecPush(out, _21); } - const _34: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); + const _34: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); const _31: Doubled.Doubled = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; const _33: Doubled.Doubled = { _0Data: _34.data, _0Start: _34.start, _0Len: _34.length }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rt.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1])]))); - const tags: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tag.Tag => { - const b3: rt.u8 = _2; - return { bytes: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => Doubled.fmt$fmt_Debug(_31, f), (f: rs.Formatter) => Doubled.fmt$fmt_Debug(_33, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1])]))); + const tags: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tag.Tag => { + const b3: rs.u8 = _2; + return { bytes: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(b3, ~b3 & 0xff))) }; }), undefined, 12, true); - const cloned: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(tags.items), Tag.clone$Clone), undefined, 12, true); - const iter3: rt.Iter = rt.iterSlice(cloned.items); + const cloned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(tags.items), Tag.clone$Clone), undefined, 12, true); + const iter3: rs.Iter = rs.iterSlice(cloned.items); while (true) { - const _59: Tag.Tag | rt.Done = iter3.next(); - if (_59 === rt.DONE) { + const _59: Tag.Tag | rs.Done = iter3.next(); + if (_59 === rs.DONE) { break; } - rt.byteVecPush(_59.bytes, 119); + rs.byteVecPush(_59.bytes, 119); } - const iter4: rt.Iter = rt.iterChain(rt.iterSlice(tags.items), rt.iterSlice(cloned.items)); + const iter4: rs.Iter = rs.iterChain(rs.iterSlice(tags.items), rs.iterSlice(cloned.items)); while (true) { - const _74: Tag.Tag | rt.Done = iter4.next(); - if (_74 === rt.DONE) { + const _74: Tag.Tag | rs.Done = iter4.next(); + if (_74 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_74.bytes)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_74.bytes)); } - const bumps: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Bumped.Bumped => { + const bumps: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): Bumped.Bumped => { return { _0: _22 }; }), undefined, 1, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(bumps.items), Bumped.clone$Clone), (b5: Bumped.Bumped): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterMap(rs.iterSlice(bumps.items), Bumped.clone$Clone), (b5: Bumped.Bumped): rs.u8 => { return b5._0; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(bumps.items), (b6: Bumped.Bumped): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(bumps.items), (b6: Bumped.Bumped): rs.u8 => { return b6._0; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): Wrapper.Wrapper => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): Wrapper.Wrapper => { return new Wrapper.Wrapper({ _0: _23 }); - }), undefined, 1, true).items), Wrapper.clone$Clone_iters_Bumped), (w: Wrapper.Wrapper): rt.u8 => { + }), undefined, 1, true).items), Wrapper.clone$Clone_iters_Bumped), (w: Wrapper.Wrapper): rs.u8 => { return w._0._0; }), undefined, true); } @@ -1781,41 +1781,41 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { * What std's `Option`-returning calls give, returned as is: an `Option`, whose `None` * stays apart from an item's own. */ -export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { - const _3: (a0: rt.u8 | undefined, a1: rt.ByteVec) => undefined = (b: rt.u8 | undefined, out2: rt.ByteVec): undefined => { - rt.byteVecPush(out2, option_mapOr$1surhce(b, 170, (b2: rt.u8): rt.u8 => { +export function returned(data: rs.ByteSlice, out: rs.ByteVec): void { + const _3: (a0: rs.u8 | undefined, a1: rs.ByteVec) => undefined = (b: rs.u8 | undefined, out2: rs.ByteVec): undefined => { + rs.byteVecPush(out2, option_mapOr$0vxw5sq(b, 170, (b2: rs.u8): rs.u8 => { return b2; })); }; - const _4: (a0: rt.u8 | undefined | rt.None, a1: rt.ByteVec) => undefined = (b3: rt.u8 | undefined | rt.None, out3: rt.ByteVec): undefined => { - if (b3 === rt.None) { - rt.byteVecPush(out3, 187); + const _4: (a0: rs.u8 | undefined | rs.None, a1: rs.ByteVec) => undefined = (b3: rs.u8 | undefined | rs.None, out3: rs.ByteVec): undefined => { + if (b3 === rs.None) { + rs.byteVecPush(out3, 187); } else if (b3 === undefined) { - rt.byteVecPush(out3, 204); + rs.byteVecPush(out3, 204); } else { - rt.byteVecPush(out3, b3); + rs.byteVecPush(out3, b3); } }; - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.u8Rem(_2, 4) as rt.usize; + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 4) as rs.usize; }); - const part = first$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data))); + const part = first$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data))); _3(part, out); - const part2 = back$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data))); + const part2 = back$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data))); _3(part2, out); - const part3 = nth$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data)), n); + const part3 = nth$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), n); _3(part3, out); - const part4 = last$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data))); + const part4 = last$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data))); _3(part4, out); - const part5 = first$iter_Map_slice_Iter_u8_iters_returned_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b6: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b6, 3) === 0)) { + const part5 = first$iter_Map_slice_Iter_u8_iters_returned_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b6: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b6, 3) === 0)) { return b6; } return undefined; })); _4(part5, out); - const part6 = back$iter_Map_slice_Iter_u8_iters_returned_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b7: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b7, 3) === 0)) { + const part6 = back$iter_Map_slice_Iter_u8_iters_returned_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b7: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b7, 3) === 0)) { return b7; } return undefined; @@ -1825,17 +1825,17 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { _4(part7, out); const part8 = first$iters_Countdown({ left: n & 0xff, step: 1 }); _3(part8, out); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(option_mapOr$0atjiti(first$str_Chars(rt.strChars(result_unwrapOr$01jdcm7(rt.strFromUtf8(data), "é"))), 0, (a0: rt.char): rt.u32 => { - return a0 as rt.u32; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(option_mapOr$0yzb10z(first$str_Chars(rs.strChars(result_unwrapOr$0a3q6xs(rs.strFromUtf8(data), "é"))), 0, (a0: rs.char): rs.u32 => { + return a0 as rs.u32; })).reverse()), undefined, true); - const part9 = byMut$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data))); + const part9 = byMut$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data))); _3(part9, out); const gaps: Gaps.Gaps = { dataData: data.data, dataStart: data.start, dataLen: data.length, at: 0 }; const part10 = byMut$iters_Gaps(gaps); _4(part10, out); const part11 = byMut$iters_Gaps(gaps); _4(part11, out); - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); const part12 = borrowed(it); _3(part12, out); const part13 = borrowed(it); @@ -1844,12 +1844,12 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { _3(part14, out); const part15 = fromOne(n & 0xff); _3(part15, out); - const part16 = peeked$iter_Copied_slice_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(data)))); + const part16 = peeked$iter_Copied_slice_Iter_u8(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(data)))); _3(part16, out); const part17 = at$u8(data, n); _3(part17, out); - const part18 = at$Option_u8(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b8: rt.u8): rt.u8 | undefined => { - if (!(rt.u8Rem(b8, 3) === 0)) { + const part18 = at$Option_u8(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b8: rs.u8): rs.u8 | undefined => { + if (!(rs.u8Rem(b8, 3) === 0)) { return b8; } return undefined; @@ -1857,80 +1857,80 @@ export function returned(data: rt.ByteSlice, out: rt.ByteVec): void { _4(part18, out); } -export function first$iter_Copied_slice_Iter_u8(it: rt.Iter): rt.u8 | undefined { - return rt.iterToOption(it.next()); +export function first$iter_Copied_slice_Iter_u8(it: rs.Iter): rs.u8 | undefined { + return rs.iterToOption(it.next()); } -export function first$iter_Map_slice_Iter_u8_iters_returned_closure0(it: rt.Iter): rt.u8 | undefined | rt.None { - return rt.iterToOption(it.next(), rt.None); +export function first$iter_Map_slice_Iter_u8_iters_returned_closure0(it: rs.Iter): rs.u8 | undefined | rs.None { + return rs.iterToOption(it.next(), rs.None); } -export function first$iters_Countdown(it: Countdown.Countdown): rt.u8 | undefined { - return rt.iterToOption(Countdown.next$iter_Iterator(it)); +export function first$iters_Countdown(it: Countdown.Countdown): rs.u8 | undefined { + return rs.iterToOption(Countdown.next$iter_Iterator(it)); } -export function first$iters_Gaps(it: Gaps.Gaps): rt.u8 | undefined | rt.None { - return rt.iterToOption(Gaps.next$iter_Iterator(it), rt.None); +export function first$iters_Gaps(it: Gaps.Gaps): rs.u8 | undefined | rs.None { + return rs.iterToOption(Gaps.next$iter_Iterator(it), rs.None); } -export function first$str_Chars(it: rt.Iter): rt.char | undefined { - return rt.iterToOption(it.next()); +export function first$str_Chars(it: rs.Iter): rs.char | undefined { + return rs.iterToOption(it.next()); } -export function back$iter_Copied_slice_Iter_u8(it: rt.Iter): rt.u8 | undefined { - return rt.iterToOption(it.nextBack()); +export function back$iter_Copied_slice_Iter_u8(it: rs.Iter): rs.u8 | undefined { + return rs.iterToOption(it.nextBack()); } -export function back$iter_Map_slice_Iter_u8_iters_returned_closure0(it: rt.Iter): rt.u8 | undefined | rt.None { - return rt.iterToOption(it.nextBack(), rt.None); +export function back$iter_Map_slice_Iter_u8_iters_returned_closure0(it: rs.Iter): rs.u8 | undefined | rs.None { + return rs.iterToOption(it.nextBack(), rs.None); } -export function nth$iter_Copied_slice_Iter_u8(it: rt.Iter, n: rt.usize): rt.u8 | undefined { - return rt.iterNth(it, n); +export function nth$iter_Copied_slice_Iter_u8(it: rs.Iter, n: rs.usize): rs.u8 | undefined { + return rs.iterNth(it, n); } -export function last$iter_Copied_slice_Iter_u8(it: rt.Iter): rt.u8 | undefined { - return rt.iterLast(it); +export function last$iter_Copied_slice_Iter_u8(it: rs.Iter): rs.u8 | undefined { + return rs.iterLast(it); } /** Through a `&mut` to the iterator. */ -export function byMut$iter_Copied_slice_Iter_u8(it: rt.Iter): rt.u8 | undefined { - return rt.iterToOption(it.next()); +export function byMut$iter_Copied_slice_Iter_u8(it: rs.Iter): rs.u8 | undefined { + return rs.iterToOption(it.next()); } /** Through a `&mut` to the iterator. */ -export function byMut$iters_Gaps(it: Gaps.Gaps): rt.u8 | undefined | rt.None { - return rt.iterToOption(Gaps.next$iter_Iterator(it), rt.None); +export function byMut$iters_Gaps(it: Gaps.Gaps): rs.u8 | undefined | rs.None { + return rs.iterToOption(Gaps.next$iter_Iterator(it), rs.None); } /** Through a borrow of a std iterator the function is not generic over. */ -export function borrowed(it: rt.Iter): rt.u8 | undefined { - return rt.iterToOption(it.next()); +export function borrowed(it: rs.Iter): rs.u8 | undefined { + return rs.iterToOption(it.next()); } /** Of a slice's iterator the function makes. */ -export function secondOf(data: rt.ByteSlice): rt.u8 | undefined { - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); +export function secondOf(data: rs.ByteSlice): rs.u8 | undefined { + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); it.next(); - return rt.iterToOption(it.next()); + return rs.iterToOption(it.next()); } /** Of a small range the function makes. */ -export function fromOne(n: rt.u8): rt.u8 | undefined { - const range: rt.Range = new rt.Range(1, n); +export function fromOne(n: rs.u8): rs.u8 | undefined { + const range: rs.Range = new rs.Range(1, n); return range.start < range.end ? range.start++ : undefined; } -export function peeked$iter_Copied_slice_Iter_u8(it: rt.Peekable): rt.u8 | undefined { - return rt.peekablePeek(it); +export function peeked$iter_Copied_slice_Iter_u8(it: rs.Peekable): rs.u8 | undefined { + return rs.peekablePeek(it); } -export function at$Option_u8(items: Array, i: rt.usize): rt.u8 | undefined | rt.None { - return rt.sliceGet(items, i, rt.None); +export function at$Option_u8(items: Array, i: rs.usize): rs.u8 | undefined | rs.None { + return rs.sliceGet(items, i, rs.None); } -export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { - return rt.byteSliceGet(items, i); +export function at$u8(items: rs.ByteSlice, i: rs.usize): rs.u8 | undefined { + return rs.byteSliceGet(items, i); } /** @@ -1940,3338 +1940,3338 @@ export function at$u8(items: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { * each of std's consumers, through adaptors that fold it or read it by `try_fold`, and * through a box. */ -export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _18!: [rt.ByteSlice, rt.ByteSlice]; - const _45: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2: [rt.u8, rt.u8]): rt.u8 => { +export function zips(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _18!: [rs.ByteSlice, rs.ByteSlice]; + const _45: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2: [rs.u8, rs.u8]): rs.u8 => { return _2[0] ^ _2[1]; }; - const _94: (a0: [rt.u8, rt.u8]) => rt.u8 = (_23: [rt.u8, rt.u8]): rt.u8 => { + const _94: (a0: [rs.u8, rs.u8]) => rs.u8 = (_23: [rs.u8, rs.u8]): rs.u8 => { return _23[0] ^ _23[1]; }; - const _144: (a0: [rt.u8, rt.u8]) => rt.u8 = (_25: [rt.u8, rt.u8]): rt.u8 => { + const _144: (a0: [rs.u8, rs.u8]) => rs.u8 = (_25: [rs.u8, rs.u8]): rs.u8 => { return _25[0] ^ _25[1]; }; - const _194: (a0: [rt.u8, rt.u8]) => rt.u8 = (_27: [rt.u8, rt.u8]): rt.u8 => { + const _194: (a0: [rs.u8, rs.u8]) => rs.u8 = (_27: [rs.u8, rs.u8]): rs.u8 => { return _27[0] ^ _27[1]; }; - const _240: (a0: [rt.u8, rt.u8]) => rt.u8 = (_211: [rt.u8, rt.u8]): rt.u8 => { + const _240: (a0: [rs.u8, rs.u8]) => rs.u8 = (_211: [rs.u8, rs.u8]): rs.u8 => { return _211[0] ^ _211[1]; }; - const _401: (a0: [rt.u8, rt.u8]) => rt.u8 = (_214: [rt.u8, rt.u8]): rt.u8 => { + const _401: (a0: [rs.u8, rs.u8]) => rs.u8 = (_214: [rs.u8, rs.u8]): rs.u8 => { return _214[0] ^ _214[1]; }; - const _452: (a0: [rt.u8, rt.u8]) => rt.u8 = (_216: [rt.u8, rt.u8]): rt.u8 => { + const _452: (a0: [rs.u8, rs.u8]) => rs.u8 = (_216: [rs.u8, rs.u8]): rs.u8 => { return _216[0] ^ _216[1]; }; - const _504: (a0: [rt.u8, rt.u8]) => rt.u8 = (_219: [rt.u8, rt.u8]): rt.u8 => { + const _504: (a0: [rs.u8, rs.u8]) => rs.u8 = (_219: [rs.u8, rs.u8]): rs.u8 => { return _219[0] ^ _219[1]; }; - const _556: (a0: [rt.u8, rt.u8]) => rt.u8 = (_222: [rt.u8, rt.u8]): rt.u8 => { + const _556: (a0: [rs.u8, rs.u8]) => rs.u8 = (_222: [rs.u8, rs.u8]): rs.u8 => { return _222[0] ^ _222[1]; }; - const _604: (a0: [rt.u8, rt.u8]) => rt.u8 = (_225: [rt.u8, rt.u8]): rt.u8 => { + const _604: (a0: [rs.u8, rs.u8]) => rs.u8 = (_225: [rs.u8, rs.u8]): rs.u8 => { return _225[0] ^ _225[1]; }; - const _783: (a0: [rt.u8, rt.u8]) => rt.u8 = (_228: [rt.u8, rt.u8]): rt.u8 => { + const _783: (a0: [rs.u8, rs.u8]) => rs.u8 = (_228: [rs.u8, rs.u8]): rs.u8 => { return _228[0] ^ _228[1]; }; - const _836: (a0: [rt.u8, rt.u8]) => rt.u8 = (_235: [rt.u8, rt.u8]): rt.u8 => { + const _836: (a0: [rs.u8, rs.u8]) => rs.u8 = (_235: [rs.u8, rs.u8]): rs.u8 => { return _235[0] ^ _235[1]; }; - const _890: (a0: [rt.u8, rt.u8]) => rt.u8 = (_239: [rt.u8, rt.u8]): rt.u8 => { + const _890: (a0: [rs.u8, rs.u8]) => rs.u8 = (_239: [rs.u8, rs.u8]): rs.u8 => { return _239[0] ^ _239[1]; }; - const _944: (a0: [rt.u8, rt.u8]) => rt.u8 = (_249: [rt.u8, rt.u8]): rt.u8 => { + const _944: (a0: [rs.u8, rs.u8]) => rs.u8 = (_249: [rs.u8, rs.u8]): rs.u8 => { return _249[0] ^ _249[1]; }; - const _994: (a0: [rt.u8, rt.u8]) => rt.u8 = (_257: [rt.u8, rt.u8]): rt.u8 => { + const _994: (a0: [rs.u8, rs.u8]) => rs.u8 = (_257: [rs.u8, rs.u8]): rs.u8 => { return _257[0] ^ _257[1]; }; - const _1187: (a0: [rt.u8, rt.u8]) => rt.u8 = (_260: [rt.u8, rt.u8]): rt.u8 => { + const _1187: (a0: [rs.u8, rs.u8]) => rs.u8 = (_260: [rs.u8, rs.u8]): rs.u8 => { return _260[0] ^ _260[1]; }; - const _1238: (a0: [rt.u8, rt.u8]) => rt.u8 = (_262: [rt.u8, rt.u8]): rt.u8 => { + const _1238: (a0: [rs.u8, rs.u8]) => rs.u8 = (_262: [rs.u8, rs.u8]): rs.u8 => { return _262[0] ^ _262[1]; }; - const _1290: (a0: [rt.u8, rt.u8]) => rt.u8 = (_265: [rt.u8, rt.u8]): rt.u8 => { + const _1290: (a0: [rs.u8, rs.u8]) => rs.u8 = (_265: [rs.u8, rs.u8]): rs.u8 => { return _265[0] ^ _265[1]; }; - const _1342: (a0: [rt.u8, rt.u8]) => rt.u8 = (_268: [rt.u8, rt.u8]): rt.u8 => { + const _1342: (a0: [rs.u8, rs.u8]) => rs.u8 = (_268: [rs.u8, rs.u8]): rs.u8 => { return _268[0] ^ _268[1]; }; - const _1390: (a0: [rt.u8, rt.u8]) => rt.u8 = (_271: [rt.u8, rt.u8]): rt.u8 => { + const _1390: (a0: [rs.u8, rs.u8]) => rs.u8 = (_271: [rs.u8, rs.u8]): rs.u8 => { return _271[0] ^ _271[1]; }; - const _1567: (a0: [rt.u8, rt.u8]) => rt.u8 = (_284: [rt.u8, rt.u8]): rt.u8 => { + const _1567: (a0: [rs.u8, rs.u8]) => rs.u8 = (_284: [rs.u8, rs.u8]): rs.u8 => { return _284[0] ^ _284[1]; }; - const _1618: (a0: [rt.u8, rt.u8]) => rt.u8 = (_288: [rt.u8, rt.u8]): rt.u8 => { + const _1618: (a0: [rs.u8, rs.u8]) => rs.u8 = (_288: [rs.u8, rs.u8]): rs.u8 => { return _288[0] ^ _288[1]; }; - const _1670: (a0: [rt.u8, rt.u8]) => rt.u8 = (_296: [rt.u8, rt.u8]): rt.u8 => { + const _1670: (a0: [rs.u8, rs.u8]) => rs.u8 = (_296: [rs.u8, rs.u8]): rs.u8 => { return _296[0] ^ _296[1]; }; - const _1722: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2107: [rt.u8, rt.u8]): rt.u8 => { + const _1722: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2107: [rs.u8, rs.u8]): rs.u8 => { return _2107[0] ^ _2107[1]; }; - const _1770: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2115: [rt.u8, rt.u8]): rt.u8 => { + const _1770: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2115: [rs.u8, rs.u8]): rs.u8 => { return _2115[0] ^ _2115[1]; }; - const _1946: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2118: [rt.u8, rt.u8]): rt.u8 => { + const _1946: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2118: [rs.u8, rs.u8]): rs.u8 => { return _2118[0] ^ _2118[1]; }; - const _1996: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2120: [rt.u8, rt.u8]): rt.u8 => { + const _1996: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2120: [rs.u8, rs.u8]): rs.u8 => { return _2120[0] ^ _2120[1]; }; - const _2047: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2123: [rt.u8, rt.u8]): rt.u8 => { + const _2047: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2123: [rs.u8, rs.u8]): rs.u8 => { return _2123[0] ^ _2123[1]; }; - const _2098: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2126: [rt.u8, rt.u8]): rt.u8 => { + const _2098: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2126: [rs.u8, rs.u8]): rs.u8 => { return _2126[0] ^ _2126[1]; }; - const _2145: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2129: [rt.u8, rt.u8]): rt.u8 => { + const _2145: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2129: [rs.u8, rs.u8]): rs.u8 => { return _2129[0] ^ _2129[1]; }; - const _2320: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2132: [rt.u8, rt.u8]): rt.u8 => { + const _2320: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2132: [rs.u8, rs.u8]): rs.u8 => { return _2132[0] ^ _2132[1]; }; - const _2377: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2140: [rt.u8, rt.u8]): rt.u8 => { + const _2377: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2140: [rs.u8, rs.u8]): rs.u8 => { return _2140[0] ^ _2140[1]; }; - const _2435: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2144: [rt.u8, rt.u8]): rt.u8 => { + const _2435: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2144: [rs.u8, rs.u8]): rs.u8 => { return _2144[0] ^ _2144[1]; }; - const _2493: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2154: [rt.u8, rt.u8]): rt.u8 => { + const _2493: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2154: [rs.u8, rs.u8]): rs.u8 => { return _2154[0] ^ _2154[1]; }; - const _2547: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2162: [rt.u8, rt.u8]): rt.u8 => { + const _2547: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2162: [rs.u8, rs.u8]): rs.u8 => { return _2162[0] ^ _2162[1]; }; - const mid: number = rt.usizeRem(kind >> 5 as rt.usize, rt.usizeAdd(data.length, 1)); + const mid: number = rs.usizeRem(kind >> 5 as rs.usize, rs.usizeAdd(data.length, 1)); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } if (!((kind & 8) === 0)) { - _18 = [new rt.ByteSlice(data.data, data.start + mid, data.length - mid), new rt.ByteSlice(data.data, data.start, mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rs.ByteSlice(data.data, data.start + mid, data.length - mid), new rs.ByteSlice(data.data, data.start, mid)] as [rs.ByteSlice, rs.ByteSlice]; } else { - _18 = [new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rt.ByteSlice, rt.ByteSlice]; + _18 = [new rs.ByteSlice(data.data, data.start, mid), new rs.ByteSlice(data.data, data.start + mid, data.length - mid)] as [rs.ByteSlice, rs.ByteSlice]; } - const a2: rt.ByteSlice = _18[0]; - const b2: rt.ByteSlice = _18[1]; + const a2: rs.ByteSlice = _18[0]; + const b2: rs.ByteSlice = _18[1]; const other: boolean = (kind & 4) !== 0; - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2165: rt.u8): rt.usize => { - return rt.usizeRem(_2165 as rt.usize, 4); + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2165: rs.u8): rs.usize => { + return rs.usizeRem(_2165 as rs.usize, 4); }); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _28: rt.u8 = rt.u8Rem(kind, 4); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _28: rs.u8 = rs.u8Rem(kind, 4); if (_28 === 0) { if ((kind & 16) === 0) { - const _31: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _31: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_31 === 0) { - const z: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21148: rt.u8): rt.u8 => { - const x603: rt.u8 = _21148; - const _6355: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6355.value, x603 ^ 1); - rt.refMutRelease(_6355); + const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21148: rs.u8): rs.u8 => { + const x603: rs.u8 = _21148; + const _6355: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6355.value, x603 ^ 1); + rs.refMutRelease(_6355); return x603; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21149: rt.u8): rt.u8 => { - const x604: rt.u8 = _21149; - const _6356: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6356.value, x604 ^ 2); - rt.refMutRelease(_6356); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21149: rs.u8): rs.u8 => { + const x604: rs.u8 = _21149; + const _6356: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6356.value, x604 ^ 2); + rs.refMutRelease(_6356); return x604; }), [true, true]); - const _46: rt.usize = rt.usizeRem(data.length, 8); + const _46: rs.usize = rs.usizeRem(data.length, 8); if (_46 === 0) { - rt.byteVecPush(out, rt.iterCount(z) & 0xff); + rs.byteVecPush(out, rs.iterCount(z) & 0xff); } else if (_46 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z), 238, (_21158: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z), 238, (_21158: [rs.u8, rs.u8]): rs.u8 => { return _21158[0] ^ _21158[1]; })); } else if (_46 === 2) { - rt.iterForEach(z, (p77: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _45(p77)); + rs.iterForEach(z, (p77: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _45(p77)); }); } else if (_46 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z, (_21157: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21157[0] as rt.u32, _21157[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z, (_21157: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21157[0] as rs.u32, _21157[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_46 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z, (_21156: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z, (_21156: [rs.u8, rs.u8]): rs.u8 => { return _21156[0] ^ _21156[1]; }), undefined, true)), undefined, true); } else if (_46 === 5) { - rt.byteVecPush(out, rt.iterFold(z, 0, (acc35: rt.u8, p76: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc35, 3) ^ _45(p76); + rs.byteVecPush(out, rs.iterFold(z, 0, (acc35: rs.u8, p76: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc35, 3) ^ _45(p76); })); } else if (_46 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z, (_21155: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z, (_21155: [rs.u8, rs.u8]): rs.u8 => { return _21155[0] ^ _21155[1]; - }), (x611: rt.u8): boolean => { + }), (x611: rs.u8): boolean => { return x611 === 0; }) ? 1 : 0); } else { - const z2: rt.Iter<[rt.u8, rt.u8]> = z; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z2, (_21150: [rt.u8, rt.u8]): boolean => { + const z2: rs.Iter<[rs.u8, rs.u8]> = z; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z2, (_21150: [rs.u8, rs.u8]): boolean => { return _21150[0] > _21150[1]; - }), 238, (i42: rt.usize): rt.u8 => { + }), 238, (i42: rs.usize): rs.u8 => { return i42 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z2, (_21151: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21151[0], 3) === 0; - }), 238, (_21152: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z2, (_21151: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21151[0], 3) === 0; + }), 238, (_21152: [rs.u8, rs.u8]): rs.u8 => { return _21152[0] ^ _21152[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z2, n), 238, (_21153: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z2, n), 238, (_21153: [rs.u8, rs.u8]): rs.u8 => { return _21153[0] ^ _21153[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z2.next()), 238, (_21154: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z2.next()), 238, (_21154: [rs.u8, rs.u8]): rs.u8 => { return _21154[0] ^ _21154[1]; })); } } else if (_31 === 1) { - const z3: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21137: rt.u8): rt.u8 => { - const x591: rt.u8 = _21137; - const _6351: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6351.value, x591 ^ 1); - rt.refMutRelease(_6351); + const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21137: rs.u8): rs.u8 => { + const x591: rs.u8 = _21137; + const _6351: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6351.value, x591 ^ 1); + rs.refMutRelease(_6351); return x591; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21138: rt.u8): rt.u8 => { - const x592: rt.u8 = _21138; - const _6352: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6352.value, x592 ^ 2); - rt.refMutRelease(_6352); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21138: rs.u8): rs.u8 => { + const x592: rs.u8 = _21138; + const _6352: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6352.value, x592 ^ 2); + rs.refMutRelease(_6352); return x592; }), [true, true]); - const _95: rt.usize = rt.usizeRem(data.length, 8); + const _95: rs.usize = rs.usizeRem(data.length, 8); if (_95 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z3)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z3)) & 0xff); } else if (_95 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z3)), 238, (_21147: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z3)), 238, (_21147: [rs.u8, rs.u8]): rs.u8 => { return _21147[0] ^ _21147[1]; })); } else if (_95 === 2) { - const _102: (a0: [rt.u8, rt.u8]) => undefined = (p75: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _94(p75)); + const _102: (a0: [rs.u8, rs.u8]) => undefined = (p75: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _94(p75)); }; - rt.iterForEach(rt.iterBox(z3), _102); + rs.iterForEach(rs.iterBox(z3), _102); } else if (_95 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z3), (_21146: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21146[0] as rt.u32, _21146[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z3), (_21146: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21146[0] as rs.u32, _21146[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_95 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z3), (_21145: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z3), (_21145: [rs.u8, rs.u8]): rs.u8 => { return _21145[0] ^ _21145[1]; }), "next")), undefined, true); } else if (_95 === 5) { - const _110: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc34: rt.u8, p74: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc34, 3) ^ _94(p74); + const _110: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc34: rs.u8, p74: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc34, 3) ^ _94(p74); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z3), 0, _110)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z3), 0, _110)); } else if (_95 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z3), (_21144: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z3), (_21144: [rs.u8, rs.u8]): rs.u8 => { return _21144[0] ^ _21144[1]; - }), (x599: rt.u8): boolean => { + }), (x599: rs.u8): boolean => { return x599 === 0; }) ? 1 : 0); } else { - const z4: rt.Iter<[rt.u8, rt.u8]> = z3; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z4), (_21139: [rt.u8, rt.u8]): boolean => { + const z4: rs.Iter<[rs.u8, rs.u8]> = z3; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z4), (_21139: [rs.u8, rs.u8]): boolean => { return _21139[0] > _21139[1]; - }), 238, (i41: rt.usize): rt.u8 => { + }), 238, (i41: rs.usize): rs.u8 => { return i41 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z4), (_21140: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21140[0], 3) === 0; - }), 238, (_21141: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z4), (_21140: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21140[0], 3) === 0; + }), 238, (_21141: [rs.u8, rs.u8]): rs.u8 => { return _21141[0] ^ _21141[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z4), n), 238, (_21142: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z4), n), 238, (_21142: [rs.u8, rs.u8]): rs.u8 => { return _21142[0] ^ _21142[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z4.next()), 238, (_21143: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_21143: [rs.u8, rs.u8]): rs.u8 => { return _21143[0] ^ _21143[1]; })); } } else if (_31 === 2) { - const z5: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21126: rt.u8): rt.u8 => { - const x579: rt.u8 = _21126; - const _6347: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6347.value, x579 ^ 1); - rt.refMutRelease(_6347); + const z5: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21126: rs.u8): rs.u8 => { + const x579: rs.u8 = _21126; + const _6347: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6347.value, x579 ^ 1); + rs.refMutRelease(_6347); return x579; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21127: rt.u8): rt.u8 => { - const x580: rt.u8 = _21127; - const _6348: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6348.value, x580 ^ 2); - rt.refMutRelease(_6348); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21127: rs.u8): rs.u8 => { + const x580: rs.u8 = _21127; + const _6348: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6348.value, x580 ^ 2); + rs.refMutRelease(_6348); return x580; }), [true, true]), n); - const _145: rt.usize = rt.usizeRem(data.length, 8); + const _145: rs.usize = rs.usizeRem(data.length, 8); if (_145 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z5)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z5)) & 0xff); } else if (_145 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z5)), 238, (_21136: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z5)), 238, (_21136: [rs.u8, rs.u8]): rs.u8 => { return _21136[0] ^ _21136[1]; })); } else if (_145 === 2) { - const _152: (a0: [rt.u8, rt.u8]) => undefined = (p73: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _144(p73)); + const _152: (a0: [rs.u8, rs.u8]) => undefined = (p73: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _144(p73)); }; - rt.iterForEach(rt.iterBox(z5), _152); + rs.iterForEach(rs.iterBox(z5), _152); } else if (_145 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z5), (_21135: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21135[0] as rt.u32, _21135[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z5), (_21135: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21135[0] as rs.u32, _21135[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_145 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z5), (_21134: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z5), (_21134: [rs.u8, rs.u8]): rs.u8 => { return _21134[0] ^ _21134[1]; }), "next")), undefined, true); } else if (_145 === 5) { - const _160: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc33: rt.u8, p72: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc33, 3) ^ _144(p72); + const _160: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc33: rs.u8, p72: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc33, 3) ^ _144(p72); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z5), 0, _160)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z5), 0, _160)); } else if (_145 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z5), (_21133: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z5), (_21133: [rs.u8, rs.u8]): rs.u8 => { return _21133[0] ^ _21133[1]; - }), (x587: rt.u8): boolean => { + }), (x587: rs.u8): boolean => { return x587 === 0; }) ? 1 : 0); } else { - const z6: rt.Iter<[rt.u8, rt.u8]> = z5; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z6), (_21128: [rt.u8, rt.u8]): boolean => { + const z6: rs.Iter<[rs.u8, rs.u8]> = z5; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z6), (_21128: [rs.u8, rs.u8]): boolean => { return _21128[0] > _21128[1]; - }), 238, (i40: rt.usize): rt.u8 => { + }), 238, (i40: rs.usize): rs.u8 => { return i40 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z6), (_21129: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21129[0], 3) === 0; - }), 238, (_21130: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z6), (_21129: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21129[0], 3) === 0; + }), 238, (_21130: [rs.u8, rs.u8]): rs.u8 => { return _21130[0] ^ _21130[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z6), n), 238, (_21131: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z6), n), 238, (_21131: [rs.u8, rs.u8]): rs.u8 => { return _21131[0] ^ _21131[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z6.next()), 238, (_21132: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z6.next()), 238, (_21132: [rs.u8, rs.u8]): rs.u8 => { return _21132[0] ^ _21132[1]; })); } } else if (_31 === 3) { - const _184: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21115: rt.u8): rt.u8 => { - const x567: rt.u8 = _21115; - const _6343: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6343.value, x567 ^ 1); - rt.refMutRelease(_6343); + const _184: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21115: rs.u8): rs.u8 => { + const x567: rs.u8 = _21115; + const _6343: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6343.value, x567 ^ 1); + rs.refMutRelease(_6343); return x567; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21116: rt.u8): rt.u8 => { - const x568: rt.u8 = _21116; - const _6344: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6344.value, x568 ^ 2); - rt.refMutRelease(_6344); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21116: rs.u8): rs.u8 => { + const x568: rs.u8 = _21116; + const _6344: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6344.value, x568 ^ 2); + rs.refMutRelease(_6344); return x568; }), [true, true]); - const _195: rt.usize = rt.usizeRem(data.length, 8); + const _195: rs.usize = rs.usizeRem(data.length, 8); if (_195 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184)))) & 0xff); } else if (_195 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184)))), 238, (_21125: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184)))), 238, (_21125: [rs.u8, rs.u8]): rs.u8 => { return _21125[0] ^ _21125[1]; })); } else if (_195 === 2) { - const _202: (a0: [rt.u8, rt.u8]) => undefined = (p71: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _194(p71)); + const _202: (a0: [rs.u8, rs.u8]) => undefined = (p71: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _194(p71)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184))), _202); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), _202); } else if (_195 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184))), (_21124: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21124[0] as rt.u32, _21124[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21124: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21124[0] as rs.u32, _21124[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_195 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184))), (_21123: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21123: [rs.u8, rs.u8]): rs.u8 => { return _21123[0] ^ _21123[1]; }), "next")), undefined, true); } else if (_195 === 5) { - const _210: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc32: rt.u8, p70: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc32, 3) ^ _194(p70); + const _210: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc32: rs.u8, p70: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc32, 3) ^ _194(p70); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184))), 0, _210)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), 0, _210)); } else if (_195 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_184))), (_21122: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_184))), (_21122: [rs.u8, rs.u8]): rs.u8 => { return _21122[0] ^ _21122[1]; - }), (x575: rt.u8): boolean => { + }), (x575: rs.u8): boolean => { return x575 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_184), (_21117: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_184), (_21117: [rs.u8, rs.u8]): boolean => { return _21117[0] > _21117[1]; - }), 238, (i39: rt.usize): rt.u8 => { + }), 238, (i39: rs.usize): rs.u8 => { return i39 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_184), (_21118: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21118[0], 3) === 0; - }), 238, (_21119: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_184), (_21118: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21118[0], 3) === 0; + }), 238, (_21119: [rs.u8, rs.u8]): rs.u8 => { return _21119[0] ^ _21119[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_184), n), 238, (_21120: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_184), n), 238, (_21120: [rs.u8, rs.u8]): rs.u8 => { return _21120[0] ^ _21120[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_184.next()), 238, (_21121: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_184.next()), 238, (_21121: [rs.u8, rs.u8]): rs.u8 => { return _21121[0] ^ _21121[1]; })); } } else { - const _229: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21104: rt.u8): rt.u8 => { - const x555: rt.u8 = _21104; - const _6339: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6339.value, x555 ^ 1); - rt.refMutRelease(_6339); + const _229: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21104: rs.u8): rs.u8 => { + const x555: rs.u8 = _21104; + const _6339: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6339.value, x555 ^ 1); + rs.refMutRelease(_6339); return x555; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21105: rt.u8): rt.u8 => { - const x556: rt.u8 = _21105; - const _6340: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6340.value, x556 ^ 2); - rt.refMutRelease(_6340); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21105: rs.u8): rs.u8 => { + const x556: rs.u8 = _21105; + const _6340: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6340.value, x556 ^ 2); + rs.refMutRelease(_6340); return x556; }), [true, true]), n); - const _241: rt.usize = rt.usizeRem(data.length, 8); + const _241: rs.usize = rs.usizeRem(data.length, 8); if (_241 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229)))) & 0xff); } else if (_241 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229)))), 238, (_21114: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229)))), 238, (_21114: [rs.u8, rs.u8]): rs.u8 => { return _21114[0] ^ _21114[1]; })); } else if (_241 === 2) { - const _248: (a0: [rt.u8, rt.u8]) => undefined = (p69: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _240(p69)); + const _248: (a0: [rs.u8, rs.u8]) => undefined = (p69: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _240(p69)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229))), _248); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), _248); } else if (_241 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229))), (_21113: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21113[0] as rt.u32, _21113[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21113: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21113[0] as rs.u32, _21113[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_241 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229))), (_21112: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21112: [rs.u8, rs.u8]): rs.u8 => { return _21112[0] ^ _21112[1]; }), "next")), undefined, true); } else if (_241 === 5) { - const _256: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc31: rt.u8, p68: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc31, 3) ^ _240(p68); + const _256: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc31: rs.u8, p68: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc31, 3) ^ _240(p68); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229))), 0, _256)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), 0, _256)); } else if (_241 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_229))), (_21111: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_229))), (_21111: [rs.u8, rs.u8]): rs.u8 => { return _21111[0] ^ _21111[1]; - }), (x563: rt.u8): boolean => { + }), (x563: rs.u8): boolean => { return x563 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_229), (_21106: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_229), (_21106: [rs.u8, rs.u8]): boolean => { return _21106[0] > _21106[1]; - }), 238, (i38: rt.usize): rt.u8 => { + }), 238, (i38: rs.usize): rs.u8 => { return i38 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_229), (_21107: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21107[0], 3) === 0; - }), 238, (_21108: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_229), (_21107: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21107[0], 3) === 0; + }), 238, (_21108: [rs.u8, rs.u8]): rs.u8 => { return _21108[0] ^ _21108[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_229), n), 238, (_21109: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_229), n), 238, (_21109: [rs.u8, rs.u8]): rs.u8 => { return _21109[0] ^ _21109[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_229.next()), 238, (_21110: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_229.next()), 238, (_21110: [rs.u8, rs.u8]): rs.u8 => { return _21110[0] ^ _21110[1]; })); } } } else { - const _274: rt.usize = rt.usizeRem(data.length, 8); + const _274: rs.usize = rs.usizeRem(data.length, 8); if (_274 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21101: rt.u8): rt.u8 => { - const x552: rt.u8 = _21101; - const _6337: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6337.value, x552 ^ 1); - rt.refMutRelease(_6337); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21101: rs.u8): rs.u8 => { + const x552: rs.u8 = _21101; + const _6337: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6337.value, x552 ^ 1); + rs.refMutRelease(_6337); return x552; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21102: rt.u8): rt.u8 => { - const x553: rt.u8 = _21102; - const _6338: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6338.value, x553 ^ 2); - rt.refMutRelease(_6338); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21102: rs.u8): rs.u8 => { + const x553: rs.u8 = _21102; + const _6338: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6338.value, x553 ^ 2); + rs.refMutRelease(_6338); return x553; - }), [true, true]), (_21103: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21103[0], 2) === 0; + }), [true, true]), (_21103: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21103[0], 2) === 0; })) & 0xff); } else if (_274 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21098: rt.u8): rt.u8 => { - const x549: rt.u8 = _21098; - const _6335: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6335.value, x549 ^ 1); - rt.refMutRelease(_6335); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21098: rs.u8): rs.u8 => { + const x549: rs.u8 = _21098; + const _6335: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6335.value, x549 ^ 1); + rs.refMutRelease(_6335); return x549; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21099: rt.u8): rt.u8 => { - const x550: rt.u8 = _21099; - const _6336: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6336.value, x550 ^ 2); - rt.refMutRelease(_6336); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21099: rs.u8): rs.u8 => { + const x550: rs.u8 = _21099; + const _6336: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6336.value, x550 ^ 2); + rs.refMutRelease(_6336); return x550; - }), [true, true]), (_21100: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_21100[0], _21100[1]); + }), [true, true]), (_21100: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_21100[0], _21100[1]); })) & 0xff); } else if (_274 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21095: rt.u8): rt.u8 => { - const x546: rt.u8 = _21095; - const _6333: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6333.value, x546 ^ 1); - rt.refMutRelease(_6333); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21095: rs.u8): rs.u8 => { + const x546: rs.u8 = _21095; + const _6333: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6333.value, x546 ^ 1); + rs.refMutRelease(_6333); return x546; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21096: rt.u8): rt.u8 => { - const x547: rt.u8 = _21096; - const _6334: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6334.value, x547 ^ 2); - rt.refMutRelease(_6334); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21096: rs.u8): rs.u8 => { + const x547: rs.u8 = _21096; + const _6334: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6334.value, x547 ^ 2); + rs.refMutRelease(_6334); return x547; - }), [true, true]), (_21097: [rt.u8, rt.u8]): boolean => { + }), [true, true]), (_21097: [rs.u8, rs.u8]): boolean => { return _21097[0] < 128; })) & 0xff); } else if (_274 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21092: rt.u8): rt.u8 => { - const x544: rt.u8 = _21092; - const _6331: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6331.value, x544 ^ 1); - rt.refMutRelease(_6331); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21092: rs.u8): rs.u8 => { + const x544: rs.u8 = _21092; + const _6331: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6331.value, x544 ^ 1); + rs.refMutRelease(_6331); return x544; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21093: rt.u8): rt.u8 => { - const x545: rt.u8 = _21093; - const _6332: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6332.value, x545 ^ 2); - rt.refMutRelease(_6332); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21093: rs.u8): rs.u8 => { + const x545: rs.u8 = _21093; + const _6332: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6332.value, x545 ^ 2); + rs.refMutRelease(_6332); return x545; - }), [true, true])), (_21094: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), [true, true])), (_21094: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _21094[0] & 0xff; })), 238)); } else if (_274 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21090: rt.u8): rt.u8 => { - const x542: rt.u8 = _21090; - const _6329: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6329.value, x542 ^ 1); - rt.refMutRelease(_6329); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21090: rs.u8): rs.u8 => { + const x542: rs.u8 = _21090; + const _6329: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6329.value, x542 ^ 1); + rs.refMutRelease(_6329); return x542; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21091: rt.u8): rt.u8 => { - const x543: rt.u8 = _21091; - const _6330: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6330.value, x543 ^ 2); - rt.refMutRelease(_6330); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21091: rs.u8): rs.u8 => { + const x543: rs.u8 = _21091; + const _6330: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6330.value, x543 ^ 2); + rs.refMutRelease(_6330); return x543; - }), [true, true]), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), [true, true]), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_274 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21088: rt.u8): rt.u8 => { - const x540: rt.u8 = _21088; - const _6327: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6327.value, x540 ^ 1); - rt.refMutRelease(_6327); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21088: rs.u8): rs.u8 => { + const x540: rs.u8 = _21088; + const _6327: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6327.value, x540 ^ 1); + rs.refMutRelease(_6327); return x540; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21089: rt.u8): rt.u8 => { - const x541: rt.u8 = _21089; - const _6328: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6328.value, x541 ^ 2); - rt.refMutRelease(_6328); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21089: rs.u8): rs.u8 => { + const x541: rs.u8 = _21089; + const _6328: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6328.value, x541 ^ 2); + rs.refMutRelease(_6328); return x541; }), [true, true]), n, undefined, true)) & 0xff); } else if (_274 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21086: rt.u8): rt.u8 => { - const x538: rt.u8 = _21086; - const _6325: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6325.value, x538 ^ 1); - rt.refMutRelease(_6325); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21086: rs.u8): rs.u8 => { + const x538: rs.u8 = _21086; + const _6325: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6325.value, x538 ^ 1); + rs.refMutRelease(_6325); return x538; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21087: rt.u8): rt.u8 => { - const x539: rt.u8 = _21087; - const _6326: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6326.value, x539 ^ 2); - rt.refMutRelease(_6326); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21087: rs.u8): rs.u8 => { + const x539: rs.u8 = _21087; + const _6326: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6326.value, x539 ^ 2); + rs.refMutRelease(_6326); return x539; }), [true, true]), n)) & 0xff); } else { - const p: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_21084: rt.u8): rt.u8 => { - const x536: rt.u8 = _21084; - const _6323: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6323.value, x536 ^ 1); - rt.refMutRelease(_6323); + const p: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_21084: rs.u8): rs.u8 => { + const x536: rs.u8 = _21084; + const _6323: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6323.value, x536 ^ 1); + rs.refMutRelease(_6323); return x536; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_21085: rt.u8): rt.u8 => { - const x537: rt.u8 = _21085; - const _6324: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6324.value, x537 ^ 2); - rt.refMutRelease(_6324); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_21085: rs.u8): rs.u8 => { + const x537: rs.u8 = _21085; + const _6324: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6324.value, x537 ^ 2); + rs.refMutRelease(_6324); return x537; }), [true, true])); - rt.byteVecPush(out, (rt.peekablePeek(p) !== undefined ? 1 : 0) ^ (rt.iterCount(p) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p) !== undefined ? 1 : 0) ^ (rs.iterCount(p) & 0xff)); } } } else if (_28 === 1) { if (!other) { if ((kind & 16) === 0) { - const _385: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _385: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_385 === 0) { - const z7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21073: rt.u8): rt.u8 => { - const x524: rt.u8 = _21073; - const _6319: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6319.value, x524 ^ 3); - rt.refMutRelease(_6319); + const z7: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21073: rs.u8): rs.u8 => { + const x524: rs.u8 = _21073; + const _6319: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6319.value, x524 ^ 3); + rs.refMutRelease(_6319); return x524; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21074: rt.u8): rt.u8 => { - const x525: rt.u8 = _21074; - const _6320: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6320.value, x525 ^ 4); - rt.refMutRelease(_6320); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21074: rs.u8): rs.u8 => { + const x525: rs.u8 = _21074; + const _6320: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6320.value, x525 ^ 4); + rs.refMutRelease(_6320); return x525; }), "len"); - const _402: rt.usize = rt.usizeRem(data.length, 8); + const _402: rs.usize = rs.usizeRem(data.length, 8); if (_402 === 0) { - rt.byteVecPush(out, rt.iterCount(z7) & 0xff); + rs.byteVecPush(out, rs.iterCount(z7) & 0xff); } else if (_402 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z7), 238, (_21083: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z7), 238, (_21083: [rs.u8, rs.u8]): rs.u8 => { return _21083[0] ^ _21083[1]; })); } else if (_402 === 2) { - rt.iterForEach(z7, (p67: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _401(p67)); + rs.iterForEach(z7, (p67: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _401(p67)); }); } else if (_402 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z7, (_21082: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21082[0] as rt.u32, _21082[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z7, (_21082: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21082[0] as rs.u32, _21082[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_402 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z7, (_21081: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z7, (_21081: [rs.u8, rs.u8]): rs.u8 => { return _21081[0] ^ _21081[1]; }), undefined, true)), undefined, true); } else if (_402 === 5) { - rt.byteVecPush(out, rt.iterFold(z7, 0, (acc30: rt.u8, p66: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc30, 3) ^ _401(p66); + rs.byteVecPush(out, rs.iterFold(z7, 0, (acc30: rs.u8, p66: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc30, 3) ^ _401(p66); })); } else if (_402 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z7, (_21080: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z7, (_21080: [rs.u8, rs.u8]): rs.u8 => { return _21080[0] ^ _21080[1]; - }), (x532: rt.u8): boolean => { + }), (x532: rs.u8): boolean => { return x532 === 0; }) ? 1 : 0); } else { - const z8: rt.Iter<[rt.u8, rt.u8]> = z7; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z8, (_21075: [rt.u8, rt.u8]): boolean => { + const z8: rs.Iter<[rs.u8, rs.u8]> = z7; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z8, (_21075: [rs.u8, rs.u8]): boolean => { return _21075[0] > _21075[1]; - }), 238, (i36: rt.usize): rt.u8 => { + }), 238, (i36: rs.usize): rs.u8 => { return i36 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z8, (_21076: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21076[0], 3) === 0; - }), 238, (_21077: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z8, (_21076: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21076[0], 3) === 0; + }), 238, (_21077: [rs.u8, rs.u8]): rs.u8 => { return _21077[0] ^ _21077[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z8, n), 238, (_21078: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z8, n), 238, (_21078: [rs.u8, rs.u8]): rs.u8 => { return _21078[0] ^ _21078[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z8.next()), 238, (_21079: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z8.next()), 238, (_21079: [rs.u8, rs.u8]): rs.u8 => { return _21079[0] ^ _21079[1]; })); } } else if (_385 === 1) { - const z9: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21062: rt.u8): rt.u8 => { - const x512: rt.u8 = _21062; - const _6315: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6315.value, x512 ^ 3); - rt.refMutRelease(_6315); + const z9: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21062: rs.u8): rs.u8 => { + const x512: rs.u8 = _21062; + const _6315: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6315.value, x512 ^ 3); + rs.refMutRelease(_6315); return x512; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21063: rt.u8): rt.u8 => { - const x513: rt.u8 = _21063; - const _6316: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6316.value, x513 ^ 4); - rt.refMutRelease(_6316); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21063: rs.u8): rs.u8 => { + const x513: rs.u8 = _21063; + const _6316: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6316.value, x513 ^ 4); + rs.refMutRelease(_6316); return x513; }), "len"); - const _453: rt.usize = rt.usizeRem(data.length, 8); + const _453: rs.usize = rs.usizeRem(data.length, 8); if (_453 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z9)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z9)) & 0xff); } else if (_453 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z9)), 238, (_21072: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z9)), 238, (_21072: [rs.u8, rs.u8]): rs.u8 => { return _21072[0] ^ _21072[1]; })); } else if (_453 === 2) { - const _460: (a0: [rt.u8, rt.u8]) => undefined = (p65: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _452(p65)); + const _460: (a0: [rs.u8, rs.u8]) => undefined = (p65: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _452(p65)); }; - rt.iterForEach(rt.iterBox(z9), _460); + rs.iterForEach(rs.iterBox(z9), _460); } else if (_453 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z9), (_21071: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21071[0] as rt.u32, _21071[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z9), (_21071: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21071[0] as rs.u32, _21071[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_453 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z9), (_21070: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z9), (_21070: [rs.u8, rs.u8]): rs.u8 => { return _21070[0] ^ _21070[1]; }), "next")), undefined, true); } else if (_453 === 5) { - const _468: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc29: rt.u8, p64: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc29, 3) ^ _452(p64); + const _468: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc29: rs.u8, p64: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc29, 3) ^ _452(p64); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z9), 0, _468)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z9), 0, _468)); } else if (_453 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z9), (_21069: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z9), (_21069: [rs.u8, rs.u8]): rs.u8 => { return _21069[0] ^ _21069[1]; - }), (x520: rt.u8): boolean => { + }), (x520: rs.u8): boolean => { return x520 === 0; }) ? 1 : 0); } else { - const z10: rt.Iter<[rt.u8, rt.u8]> = z9; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z10), (_21064: [rt.u8, rt.u8]): boolean => { + const z10: rs.Iter<[rs.u8, rs.u8]> = z9; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z10), (_21064: [rs.u8, rs.u8]): boolean => { return _21064[0] > _21064[1]; - }), 238, (i35: rt.usize): rt.u8 => { + }), 238, (i35: rs.usize): rs.u8 => { return i35 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z10), (_21065: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21065[0], 3) === 0; - }), 238, (_21066: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z10), (_21065: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21065[0], 3) === 0; + }), 238, (_21066: [rs.u8, rs.u8]): rs.u8 => { return _21066[0] ^ _21066[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z10), n), 238, (_21067: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z10), n), 238, (_21067: [rs.u8, rs.u8]): rs.u8 => { return _21067[0] ^ _21067[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z10.next()), 238, (_21068: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z10.next()), 238, (_21068: [rs.u8, rs.u8]): rs.u8 => { return _21068[0] ^ _21068[1]; })); } } else if (_385 === 2) { - const z11: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21051: rt.u8): rt.u8 => { - const x500: rt.u8 = _21051; - const _6311: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6311.value, x500 ^ 3); - rt.refMutRelease(_6311); + const z11: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21051: rs.u8): rs.u8 => { + const x500: rs.u8 = _21051; + const _6311: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6311.value, x500 ^ 3); + rs.refMutRelease(_6311); return x500; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21052: rt.u8): rt.u8 => { - const x501: rt.u8 = _21052; - const _6312: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6312.value, x501 ^ 4); - rt.refMutRelease(_6312); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21052: rs.u8): rs.u8 => { + const x501: rs.u8 = _21052; + const _6312: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6312.value, x501 ^ 4); + rs.refMutRelease(_6312); return x501; }), "len"), n); - const _505: rt.usize = rt.usizeRem(data.length, 8); + const _505: rs.usize = rs.usizeRem(data.length, 8); if (_505 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z11)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z11)) & 0xff); } else if (_505 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z11)), 238, (_21061: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z11)), 238, (_21061: [rs.u8, rs.u8]): rs.u8 => { return _21061[0] ^ _21061[1]; })); } else if (_505 === 2) { - const _512: (a0: [rt.u8, rt.u8]) => undefined = (p63: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _504(p63)); + const _512: (a0: [rs.u8, rs.u8]) => undefined = (p63: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _504(p63)); }; - rt.iterForEach(rt.iterBox(z11), _512); + rs.iterForEach(rs.iterBox(z11), _512); } else if (_505 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z11), (_21060: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21060[0] as rt.u32, _21060[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z11), (_21060: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21060[0] as rs.u32, _21060[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_505 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z11), (_21059: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z11), (_21059: [rs.u8, rs.u8]): rs.u8 => { return _21059[0] ^ _21059[1]; }), "next")), undefined, true); } else if (_505 === 5) { - const _520: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc28: rt.u8, p62: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc28, 3) ^ _504(p62); + const _520: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc28: rs.u8, p62: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc28, 3) ^ _504(p62); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z11), 0, _520)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z11), 0, _520)); } else if (_505 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z11), (_21058: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z11), (_21058: [rs.u8, rs.u8]): rs.u8 => { return _21058[0] ^ _21058[1]; - }), (x508: rt.u8): boolean => { + }), (x508: rs.u8): boolean => { return x508 === 0; }) ? 1 : 0); } else { - const z12: rt.Iter<[rt.u8, rt.u8]> = z11; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z12), (_21053: [rt.u8, rt.u8]): boolean => { + const z12: rs.Iter<[rs.u8, rs.u8]> = z11; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z12), (_21053: [rs.u8, rs.u8]): boolean => { return _21053[0] > _21053[1]; - }), 238, (i34: rt.usize): rt.u8 => { + }), 238, (i34: rs.usize): rs.u8 => { return i34 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z12), (_21054: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21054[0], 3) === 0; - }), 238, (_21055: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z12), (_21054: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21054[0], 3) === 0; + }), 238, (_21055: [rs.u8, rs.u8]): rs.u8 => { return _21055[0] ^ _21055[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z12), n), 238, (_21056: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z12), n), 238, (_21056: [rs.u8, rs.u8]): rs.u8 => { return _21056[0] ^ _21056[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z12.next()), 238, (_21057: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z12.next()), 238, (_21057: [rs.u8, rs.u8]): rs.u8 => { return _21057[0] ^ _21057[1]; })); } } else if (_385 === 3) { - const _544: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21040: rt.u8): rt.u8 => { - const x488: rt.u8 = _21040; - const _6307: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6307.value, x488 ^ 3); - rt.refMutRelease(_6307); + const _544: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21040: rs.u8): rs.u8 => { + const x488: rs.u8 = _21040; + const _6307: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6307.value, x488 ^ 3); + rs.refMutRelease(_6307); return x488; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21041: rt.u8): rt.u8 => { - const x489: rt.u8 = _21041; - const _6308: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6308.value, x489 ^ 4); - rt.refMutRelease(_6308); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21041: rs.u8): rs.u8 => { + const x489: rs.u8 = _21041; + const _6308: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6308.value, x489 ^ 4); + rs.refMutRelease(_6308); return x489; }), "len"); - const _557: rt.usize = rt.usizeRem(data.length, 8); + const _557: rs.usize = rs.usizeRem(data.length, 8); if (_557 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544)))) & 0xff); } else if (_557 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544)))), 238, (_21050: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544)))), 238, (_21050: [rs.u8, rs.u8]): rs.u8 => { return _21050[0] ^ _21050[1]; })); } else if (_557 === 2) { - const _564: (a0: [rt.u8, rt.u8]) => undefined = (p61: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _556(p61)); + const _564: (a0: [rs.u8, rs.u8]) => undefined = (p61: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _556(p61)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544))), _564); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), _564); } else if (_557 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544))), (_21049: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21049[0] as rt.u32, _21049[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21049: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21049[0] as rs.u32, _21049[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_557 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544))), (_21048: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21048: [rs.u8, rs.u8]): rs.u8 => { return _21048[0] ^ _21048[1]; }), "next")), undefined, true); } else if (_557 === 5) { - const _572: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc27: rt.u8, p60: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc27, 3) ^ _556(p60); + const _572: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc27: rs.u8, p60: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc27, 3) ^ _556(p60); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544))), 0, _572)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), 0, _572)); } else if (_557 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_544))), (_21047: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_544))), (_21047: [rs.u8, rs.u8]): rs.u8 => { return _21047[0] ^ _21047[1]; - }), (x496: rt.u8): boolean => { + }), (x496: rs.u8): boolean => { return x496 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_544), (_21042: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_544), (_21042: [rs.u8, rs.u8]): boolean => { return _21042[0] > _21042[1]; - }), 238, (i33: rt.usize): rt.u8 => { + }), 238, (i33: rs.usize): rs.u8 => { return i33 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_544), (_21043: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21043[0], 3) === 0; - }), 238, (_21044: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_544), (_21043: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21043[0], 3) === 0; + }), 238, (_21044: [rs.u8, rs.u8]): rs.u8 => { return _21044[0] ^ _21044[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_544), n), 238, (_21045: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_544), n), 238, (_21045: [rs.u8, rs.u8]): rs.u8 => { return _21045[0] ^ _21045[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_544.next()), 238, (_21046: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_544.next()), 238, (_21046: [rs.u8, rs.u8]): rs.u8 => { return _21046[0] ^ _21046[1]; })); } } else { - const _591: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21029: rt.u8): rt.u8 => { - const x476: rt.u8 = _21029; - const _6303: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6303.value, x476 ^ 3); - rt.refMutRelease(_6303); + const _591: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21029: rs.u8): rs.u8 => { + const x476: rs.u8 = _21029; + const _6303: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6303.value, x476 ^ 3); + rs.refMutRelease(_6303); return x476; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21030: rt.u8): rt.u8 => { - const x477: rt.u8 = _21030; - const _6304: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6304.value, x477 ^ 4); - rt.refMutRelease(_6304); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21030: rs.u8): rs.u8 => { + const x477: rs.u8 = _21030; + const _6304: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6304.value, x477 ^ 4); + rs.refMutRelease(_6304); return x477; }), "len"), n); - const _605: rt.usize = rt.usizeRem(data.length, 8); + const _605: rs.usize = rs.usizeRem(data.length, 8); if (_605 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591)))) & 0xff); } else if (_605 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591)))), 238, (_21039: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591)))), 238, (_21039: [rs.u8, rs.u8]): rs.u8 => { return _21039[0] ^ _21039[1]; })); } else if (_605 === 2) { - const _612: (a0: [rt.u8, rt.u8]) => undefined = (p59: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _604(p59)); + const _612: (a0: [rs.u8, rs.u8]) => undefined = (p59: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _604(p59)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591))), _612); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), _612); } else if (_605 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591))), (_21038: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21038[0] as rt.u32, _21038[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21038: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21038[0] as rs.u32, _21038[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_605 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591))), (_21037: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21037: [rs.u8, rs.u8]): rs.u8 => { return _21037[0] ^ _21037[1]; }), "next")), undefined, true); } else if (_605 === 5) { - const _620: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc26: rt.u8, p58: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc26, 3) ^ _604(p58); + const _620: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc26: rs.u8, p58: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc26, 3) ^ _604(p58); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591))), 0, _620)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), 0, _620)); } else if (_605 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_591))), (_21036: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_591))), (_21036: [rs.u8, rs.u8]): rs.u8 => { return _21036[0] ^ _21036[1]; - }), (x484: rt.u8): boolean => { + }), (x484: rs.u8): boolean => { return x484 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_591), (_21031: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_591), (_21031: [rs.u8, rs.u8]): boolean => { return _21031[0] > _21031[1]; - }), 238, (i32: rt.usize): rt.u8 => { + }), 238, (i32: rs.usize): rs.u8 => { return i32 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_591), (_21032: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21032[0], 3) === 0; - }), 238, (_21033: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_591), (_21032: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21032[0], 3) === 0; + }), 238, (_21033: [rs.u8, rs.u8]): rs.u8 => { return _21033[0] ^ _21033[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_591), n), 238, (_21034: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_591), n), 238, (_21034: [rs.u8, rs.u8]): rs.u8 => { return _21034[0] ^ _21034[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_591.next()), 238, (_21035: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_591.next()), 238, (_21035: [rs.u8, rs.u8]): rs.u8 => { return _21035[0] ^ _21035[1]; })); } } } else { - const _638: rt.usize = rt.usizeRem(data.length, 8); + const _638: rs.usize = rs.usizeRem(data.length, 8); if (_638 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21026: rt.u8): rt.u8 => { - const x473: rt.u8 = _21026; - const _6301: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6301.value, x473 ^ 3); - rt.refMutRelease(_6301); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21026: rs.u8): rs.u8 => { + const x473: rs.u8 = _21026; + const _6301: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6301.value, x473 ^ 3); + rs.refMutRelease(_6301); return x473; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21027: rt.u8): rt.u8 => { - const x474: rt.u8 = _21027; - const _6302: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6302.value, x474 ^ 4); - rt.refMutRelease(_6302); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21027: rs.u8): rs.u8 => { + const x474: rs.u8 = _21027; + const _6302: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6302.value, x474 ^ 4); + rs.refMutRelease(_6302); return x474; - }), "len"), (_21028: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21028[0], 2) === 0; + }), "len"), (_21028: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21028[0], 2) === 0; })) & 0xff); } else if (_638 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21023: rt.u8): rt.u8 => { - const x470: rt.u8 = _21023; - const _6299: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6299.value, x470 ^ 3); - rt.refMutRelease(_6299); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21023: rs.u8): rs.u8 => { + const x470: rs.u8 = _21023; + const _6299: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6299.value, x470 ^ 3); + rs.refMutRelease(_6299); return x470; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21024: rt.u8): rt.u8 => { - const x471: rt.u8 = _21024; - const _6300: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6300.value, x471 ^ 4); - rt.refMutRelease(_6300); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21024: rs.u8): rs.u8 => { + const x471: rs.u8 = _21024; + const _6300: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6300.value, x471 ^ 4); + rs.refMutRelease(_6300); return x471; - }), "len"), (_21025: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_21025[0], _21025[1]); + }), "len"), (_21025: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_21025[0], _21025[1]); })) & 0xff); } else if (_638 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21020: rt.u8): rt.u8 => { - const x467: rt.u8 = _21020; - const _6297: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6297.value, x467 ^ 3); - rt.refMutRelease(_6297); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21020: rs.u8): rs.u8 => { + const x467: rs.u8 = _21020; + const _6297: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6297.value, x467 ^ 3); + rs.refMutRelease(_6297); return x467; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21021: rt.u8): rt.u8 => { - const x468: rt.u8 = _21021; - const _6298: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6298.value, x468 ^ 4); - rt.refMutRelease(_6298); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21021: rs.u8): rs.u8 => { + const x468: rs.u8 = _21021; + const _6298: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6298.value, x468 ^ 4); + rs.refMutRelease(_6298); return x468; - }), "len"), (_21022: [rt.u8, rt.u8]): boolean => { + }), "len"), (_21022: [rs.u8, rs.u8]): boolean => { return _21022[0] < 128; })) & 0xff); } else if (_638 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21017: rt.u8): rt.u8 => { - const x465: rt.u8 = _21017; - const _6295: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6295.value, x465 ^ 3); - rt.refMutRelease(_6295); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21017: rs.u8): rs.u8 => { + const x465: rs.u8 = _21017; + const _6295: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6295.value, x465 ^ 3); + rs.refMutRelease(_6295); return x465; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21018: rt.u8): rt.u8 => { - const x466: rt.u8 = _21018; - const _6296: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6296.value, x466 ^ 4); - rt.refMutRelease(_6296); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21018: rs.u8): rs.u8 => { + const x466: rs.u8 = _21018; + const _6296: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6296.value, x466 ^ 4); + rs.refMutRelease(_6296); return x466; - }), "len")), (_21019: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), "len")), (_21019: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _21019[0] & 0xff; })), 238)); } else if (_638 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21015: rt.u8): rt.u8 => { - const x463: rt.u8 = _21015; - const _6293: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6293.value, x463 ^ 3); - rt.refMutRelease(_6293); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21015: rs.u8): rs.u8 => { + const x463: rs.u8 = _21015; + const _6293: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6293.value, x463 ^ 3); + rs.refMutRelease(_6293); return x463; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21016: rt.u8): rt.u8 => { - const x464: rt.u8 = _21016; - const _6294: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6294.value, x464 ^ 4); - rt.refMutRelease(_6294); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21016: rs.u8): rs.u8 => { + const x464: rs.u8 = _21016; + const _6294: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6294.value, x464 ^ 4); + rs.refMutRelease(_6294); return x464; - }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), "len"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_638 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21013: rt.u8): rt.u8 => { - const x461: rt.u8 = _21013; - const _6291: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6291.value, x461 ^ 3); - rt.refMutRelease(_6291); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21013: rs.u8): rs.u8 => { + const x461: rs.u8 = _21013; + const _6291: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6291.value, x461 ^ 3); + rs.refMutRelease(_6291); return x461; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21014: rt.u8): rt.u8 => { - const x462: rt.u8 = _21014; - const _6292: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6292.value, x462 ^ 4); - rt.refMutRelease(_6292); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21014: rs.u8): rs.u8 => { + const x462: rs.u8 = _21014; + const _6292: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6292.value, x462 ^ 4); + rs.refMutRelease(_6292); return x462; }), "len"), n)) & 0xff); } else if (_638 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21011: rt.u8): rt.u8 => { - const x459: rt.u8 = _21011; - const _6289: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6289.value, x459 ^ 3); - rt.refMutRelease(_6289); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21011: rs.u8): rs.u8 => { + const x459: rs.u8 = _21011; + const _6289: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6289.value, x459 ^ 3); + rs.refMutRelease(_6289); return x459; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21012: rt.u8): rt.u8 => { - const x460: rt.u8 = _21012; - const _6290: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6290.value, x460 ^ 4); - rt.refMutRelease(_6290); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21012: rs.u8): rs.u8 => { + const x460: rs.u8 = _21012; + const _6290: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6290.value, x460 ^ 4); + rs.refMutRelease(_6290); return x460; }), "len"), n)) & 0xff); } else { - const p2: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_21009: rt.u8): rt.u8 => { - const x457: rt.u8 = _21009; - const _6287: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6287.value, x457 ^ 3); - rt.refMutRelease(_6287); + const p2: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_21009: rs.u8): rs.u8 => { + const x457: rs.u8 = _21009; + const _6287: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6287.value, x457 ^ 3); + rs.refMutRelease(_6287); return x457; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_21010: rt.u8): rt.u8 => { - const x458: rt.u8 = _21010; - const _6288: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6288.value, x458 ^ 4); - rt.refMutRelease(_6288); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_21010: rs.u8): rs.u8 => { + const x458: rs.u8 = _21010; + const _6288: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6288.value, x458 ^ 4); + rs.refMutRelease(_6288); return x458; }), "len")); - rt.byteVecPush(out, (rt.peekablePeek(p2) !== undefined ? 1 : 0) ^ (rt.iterCount(p2) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p2) !== undefined ? 1 : 0) ^ (rs.iterCount(p2) & 0xff)); } } } else if ((kind & 16) === 0) { - const _765: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _765: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_765 === 0) { - const z13: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2998: rt.u8): rt.u8 => { - const x445: rt.u8 = _2998; - const _6283: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6283.value, x445 ^ 5); - rt.refMutRelease(_6283); + const z13: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2998: rs.u8): rs.u8 => { + const x445: rs.u8 = _2998; + const _6283: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6283.value, x445 ^ 5); + rs.refMutRelease(_6283); return x445; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2999: rt.u8): rt.u8 => { - const x446: rt.u8 = _2999; - const _6284: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6284.value, x446 ^ 6); - rt.refMutRelease(_6284); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2999: rs.u8): rs.u8 => { + const x446: rs.u8 = _2999; + const _6284: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6284.value, x446 ^ 6); + rs.refMutRelease(_6284); return x446; }), "len"); - const _784: rt.usize = rt.usizeRem(data.length, 8); + const _784: rs.usize = rs.usizeRem(data.length, 8); if (_784 === 0) { - rt.byteVecPush(out, rt.iterCount(z13) & 0xff); + rs.byteVecPush(out, rs.iterCount(z13) & 0xff); } else if (_784 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z13), 238, (_21008: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z13), 238, (_21008: [rs.u8, rs.u8]): rs.u8 => { return _21008[0] ^ _21008[1]; })); } else if (_784 === 2) { - rt.iterForEach(z13, (p57: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _783(p57)); + rs.iterForEach(z13, (p57: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _783(p57)); }); } else if (_784 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z13, (_21007: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_21007[0] as rt.u32, _21007[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z13, (_21007: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_21007[0] as rs.u32, _21007[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_784 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z13, (_21006: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z13, (_21006: [rs.u8, rs.u8]): rs.u8 => { return _21006[0] ^ _21006[1]; }), undefined, true)), undefined, true); } else if (_784 === 5) { - rt.byteVecPush(out, rt.iterFold(z13, 0, (acc25: rt.u8, p56: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc25, 3) ^ _783(p56); + rs.byteVecPush(out, rs.iterFold(z13, 0, (acc25: rs.u8, p56: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc25, 3) ^ _783(p56); })); } else if (_784 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z13, (_21005: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z13, (_21005: [rs.u8, rs.u8]): rs.u8 => { return _21005[0] ^ _21005[1]; - }), (x453: rt.u8): boolean => { + }), (x453: rs.u8): boolean => { return x453 === 0; }) ? 1 : 0); } else { - const z14: rt.Iter<[rt.u8, rt.u8]> = z13; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z14, (_21000: [rt.u8, rt.u8]): boolean => { + const z14: rs.Iter<[rs.u8, rs.u8]> = z13; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z14, (_21000: [rs.u8, rs.u8]): boolean => { return _21000[0] > _21000[1]; - }), 238, (i30: rt.usize): rt.u8 => { + }), 238, (i30: rs.usize): rs.u8 => { return i30 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z14, (_21001: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_21001[0], 3) === 0; - }), 238, (_21002: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z14, (_21001: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_21001[0], 3) === 0; + }), 238, (_21002: [rs.u8, rs.u8]): rs.u8 => { return _21002[0] ^ _21002[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z14, n), 238, (_21003: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z14, n), 238, (_21003: [rs.u8, rs.u8]): rs.u8 => { return _21003[0] ^ _21003[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z14.next()), 238, (_21004: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z14.next()), 238, (_21004: [rs.u8, rs.u8]): rs.u8 => { return _21004[0] ^ _21004[1]; })); } } else if (_765 === 1) { - const z15: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2987: rt.u8): rt.u8 => { - const x433: rt.u8 = _2987; - const _6279: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6279.value, x433 ^ 5); - rt.refMutRelease(_6279); + const z15: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2987: rs.u8): rs.u8 => { + const x433: rs.u8 = _2987; + const _6279: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6279.value, x433 ^ 5); + rs.refMutRelease(_6279); return x433; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2988: rt.u8): rt.u8 => { - const x434: rt.u8 = _2988; - const _6280: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6280.value, x434 ^ 6); - rt.refMutRelease(_6280); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2988: rs.u8): rs.u8 => { + const x434: rs.u8 = _2988; + const _6280: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6280.value, x434 ^ 6); + rs.refMutRelease(_6280); return x434; }), "len"); - const _837: rt.usize = rt.usizeRem(data.length, 8); + const _837: rs.usize = rs.usizeRem(data.length, 8); if (_837 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z15)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z15)) & 0xff); } else if (_837 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z15)), 238, (_2997: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z15)), 238, (_2997: [rs.u8, rs.u8]): rs.u8 => { return _2997[0] ^ _2997[1]; })); } else if (_837 === 2) { - const _844: (a0: [rt.u8, rt.u8]) => undefined = (p55: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _836(p55)); + const _844: (a0: [rs.u8, rs.u8]) => undefined = (p55: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _836(p55)); }; - rt.iterForEach(rt.iterBox(z15), _844); + rs.iterForEach(rs.iterBox(z15), _844); } else if (_837 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z15), (_2996: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2996[0] as rt.u32, _2996[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z15), (_2996: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2996[0] as rs.u32, _2996[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_837 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z15), (_2995: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z15), (_2995: [rs.u8, rs.u8]): rs.u8 => { return _2995[0] ^ _2995[1]; }), "next")), undefined, true); } else if (_837 === 5) { - const _852: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc24: rt.u8, p54: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc24, 3) ^ _836(p54); + const _852: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc24: rs.u8, p54: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc24, 3) ^ _836(p54); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z15), 0, _852)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z15), 0, _852)); } else if (_837 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z15), (_2994: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z15), (_2994: [rs.u8, rs.u8]): rs.u8 => { return _2994[0] ^ _2994[1]; - }), (x441: rt.u8): boolean => { + }), (x441: rs.u8): boolean => { return x441 === 0; }) ? 1 : 0); } else { - const z16: rt.Iter<[rt.u8, rt.u8]> = z15; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z16), (_2989: [rt.u8, rt.u8]): boolean => { + const z16: rs.Iter<[rs.u8, rs.u8]> = z15; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z16), (_2989: [rs.u8, rs.u8]): boolean => { return _2989[0] > _2989[1]; - }), 238, (i29: rt.usize): rt.u8 => { + }), 238, (i29: rs.usize): rs.u8 => { return i29 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z16), (_2990: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2990[0], 3) === 0; - }), 238, (_2991: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z16), (_2990: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2990[0], 3) === 0; + }), 238, (_2991: [rs.u8, rs.u8]): rs.u8 => { return _2991[0] ^ _2991[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z16), n), 238, (_2992: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z16), n), 238, (_2992: [rs.u8, rs.u8]): rs.u8 => { return _2992[0] ^ _2992[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z16.next()), 238, (_2993: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z16.next()), 238, (_2993: [rs.u8, rs.u8]): rs.u8 => { return _2993[0] ^ _2993[1]; })); } } else if (_765 === 2) { - const z17: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2976: rt.u8): rt.u8 => { - const x421: rt.u8 = _2976; - const _6275: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6275.value, x421 ^ 5); - rt.refMutRelease(_6275); + const z17: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2976: rs.u8): rs.u8 => { + const x421: rs.u8 = _2976; + const _6275: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6275.value, x421 ^ 5); + rs.refMutRelease(_6275); return x421; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2977: rt.u8): rt.u8 => { - const x422: rt.u8 = _2977; - const _6276: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6276.value, x422 ^ 6); - rt.refMutRelease(_6276); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2977: rs.u8): rs.u8 => { + const x422: rs.u8 = _2977; + const _6276: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6276.value, x422 ^ 6); + rs.refMutRelease(_6276); return x422; }), "len"), n); - const _891: rt.usize = rt.usizeRem(data.length, 8); + const _891: rs.usize = rs.usizeRem(data.length, 8); if (_891 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z17)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z17)) & 0xff); } else if (_891 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z17)), 238, (_2986: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z17)), 238, (_2986: [rs.u8, rs.u8]): rs.u8 => { return _2986[0] ^ _2986[1]; })); } else if (_891 === 2) { - const _898: (a0: [rt.u8, rt.u8]) => undefined = (p53: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _890(p53)); + const _898: (a0: [rs.u8, rs.u8]) => undefined = (p53: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _890(p53)); }; - rt.iterForEach(rt.iterBox(z17), _898); + rs.iterForEach(rs.iterBox(z17), _898); } else if (_891 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z17), (_2985: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2985[0] as rt.u32, _2985[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z17), (_2985: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2985[0] as rs.u32, _2985[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_891 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z17), (_2984: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z17), (_2984: [rs.u8, rs.u8]): rs.u8 => { return _2984[0] ^ _2984[1]; }), "next")), undefined, true); } else if (_891 === 5) { - const _906: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc23: rt.u8, p52: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc23, 3) ^ _890(p52); + const _906: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc23: rs.u8, p52: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc23, 3) ^ _890(p52); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z17), 0, _906)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z17), 0, _906)); } else if (_891 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z17), (_2983: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z17), (_2983: [rs.u8, rs.u8]): rs.u8 => { return _2983[0] ^ _2983[1]; - }), (x429: rt.u8): boolean => { + }), (x429: rs.u8): boolean => { return x429 === 0; }) ? 1 : 0); } else { - const z18: rt.Iter<[rt.u8, rt.u8]> = z17; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z18), (_2978: [rt.u8, rt.u8]): boolean => { + const z18: rs.Iter<[rs.u8, rs.u8]> = z17; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z18), (_2978: [rs.u8, rs.u8]): boolean => { return _2978[0] > _2978[1]; - }), 238, (i28: rt.usize): rt.u8 => { + }), 238, (i28: rs.usize): rs.u8 => { return i28 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z18), (_2979: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2979[0], 3) === 0; - }), 238, (_2980: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z18), (_2979: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2979[0], 3) === 0; + }), 238, (_2980: [rs.u8, rs.u8]): rs.u8 => { return _2980[0] ^ _2980[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z18), n), 238, (_2981: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z18), n), 238, (_2981: [rs.u8, rs.u8]): rs.u8 => { return _2981[0] ^ _2981[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z18.next()), 238, (_2982: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z18.next()), 238, (_2982: [rs.u8, rs.u8]): rs.u8 => { return _2982[0] ^ _2982[1]; })); } } else if (_765 === 3) { - const _930: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2965: rt.u8): rt.u8 => { - const x409: rt.u8 = _2965; - const _6271: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6271.value, x409 ^ 5); - rt.refMutRelease(_6271); + const _930: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2965: rs.u8): rs.u8 => { + const x409: rs.u8 = _2965; + const _6271: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6271.value, x409 ^ 5); + rs.refMutRelease(_6271); return x409; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2966: rt.u8): rt.u8 => { - const x410: rt.u8 = _2966; - const _6272: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6272.value, x410 ^ 6); - rt.refMutRelease(_6272); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2966: rs.u8): rs.u8 => { + const x410: rs.u8 = _2966; + const _6272: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6272.value, x410 ^ 6); + rs.refMutRelease(_6272); return x410; }), "len"); - const _945: rt.usize = rt.usizeRem(data.length, 8); + const _945: rs.usize = rs.usizeRem(data.length, 8); if (_945 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930)))) & 0xff); } else if (_945 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930)))), 238, (_2975: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930)))), 238, (_2975: [rs.u8, rs.u8]): rs.u8 => { return _2975[0] ^ _2975[1]; })); } else if (_945 === 2) { - const _952: (a0: [rt.u8, rt.u8]) => undefined = (p51: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _944(p51)); + const _952: (a0: [rs.u8, rs.u8]) => undefined = (p51: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _944(p51)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930))), _952); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), _952); } else if (_945 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930))), (_2974: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2974[0] as rt.u32, _2974[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2974: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2974[0] as rs.u32, _2974[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_945 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930))), (_2973: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2973: [rs.u8, rs.u8]): rs.u8 => { return _2973[0] ^ _2973[1]; }), "next")), undefined, true); } else if (_945 === 5) { - const _960: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc22: rt.u8, p50: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc22, 3) ^ _944(p50); + const _960: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc22: rs.u8, p50: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc22, 3) ^ _944(p50); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930))), 0, _960)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), 0, _960)); } else if (_945 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_930))), (_2972: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_930))), (_2972: [rs.u8, rs.u8]): rs.u8 => { return _2972[0] ^ _2972[1]; - }), (x417: rt.u8): boolean => { + }), (x417: rs.u8): boolean => { return x417 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_930), (_2967: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_930), (_2967: [rs.u8, rs.u8]): boolean => { return _2967[0] > _2967[1]; - }), 238, (i27: rt.usize): rt.u8 => { + }), 238, (i27: rs.usize): rs.u8 => { return i27 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_930), (_2968: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2968[0], 3) === 0; - }), 238, (_2969: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_930), (_2968: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2968[0], 3) === 0; + }), 238, (_2969: [rs.u8, rs.u8]): rs.u8 => { return _2969[0] ^ _2969[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_930), n), 238, (_2970: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_930), n), 238, (_2970: [rs.u8, rs.u8]): rs.u8 => { return _2970[0] ^ _2970[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_930.next()), 238, (_2971: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_930.next()), 238, (_2971: [rs.u8, rs.u8]): rs.u8 => { return _2971[0] ^ _2971[1]; })); } } else { - const _979: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2954: rt.u8): rt.u8 => { - const x397: rt.u8 = _2954; - const _6267: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6267.value, x397 ^ 5); - rt.refMutRelease(_6267); + const _979: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2954: rs.u8): rs.u8 => { + const x397: rs.u8 = _2954; + const _6267: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6267.value, x397 ^ 5); + rs.refMutRelease(_6267); return x397; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2955: rt.u8): rt.u8 => { - const x398: rt.u8 = _2955; - const _6268: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6268.value, x398 ^ 6); - rt.refMutRelease(_6268); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2955: rs.u8): rs.u8 => { + const x398: rs.u8 = _2955; + const _6268: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6268.value, x398 ^ 6); + rs.refMutRelease(_6268); return x398; }), "len"), n); - const _995: rt.usize = rt.usizeRem(data.length, 8); + const _995: rs.usize = rs.usizeRem(data.length, 8); if (_995 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979)))) & 0xff); } else if (_995 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979)))), 238, (_2964: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979)))), 238, (_2964: [rs.u8, rs.u8]): rs.u8 => { return _2964[0] ^ _2964[1]; })); } else if (_995 === 2) { - const _1002: (a0: [rt.u8, rt.u8]) => undefined = (p49: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _994(p49)); + const _1002: (a0: [rs.u8, rs.u8]) => undefined = (p49: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _994(p49)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979))), _1002); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), _1002); } else if (_995 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979))), (_2963: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2963[0] as rt.u32, _2963[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2963: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2963[0] as rs.u32, _2963[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_995 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979))), (_2962: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2962: [rs.u8, rs.u8]): rs.u8 => { return _2962[0] ^ _2962[1]; }), "next")), undefined, true); } else if (_995 === 5) { - const _1010: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc21: rt.u8, p48: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc21, 3) ^ _994(p48); + const _1010: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc21: rs.u8, p48: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc21, 3) ^ _994(p48); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979))), 0, _1010)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), 0, _1010)); } else if (_995 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_979))), (_2961: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_979))), (_2961: [rs.u8, rs.u8]): rs.u8 => { return _2961[0] ^ _2961[1]; - }), (x405: rt.u8): boolean => { + }), (x405: rs.u8): boolean => { return x405 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_979), (_2956: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_979), (_2956: [rs.u8, rs.u8]): boolean => { return _2956[0] > _2956[1]; - }), 238, (i26: rt.usize): rt.u8 => { + }), 238, (i26: rs.usize): rs.u8 => { return i26 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_979), (_2957: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2957[0], 3) === 0; - }), 238, (_2958: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_979), (_2957: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2957[0], 3) === 0; + }), 238, (_2958: [rs.u8, rs.u8]): rs.u8 => { return _2958[0] ^ _2958[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_979), n), 238, (_2959: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_979), n), 238, (_2959: [rs.u8, rs.u8]): rs.u8 => { return _2959[0] ^ _2959[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_979.next()), 238, (_2960: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_979.next()), 238, (_2960: [rs.u8, rs.u8]): rs.u8 => { return _2960[0] ^ _2960[1]; })); } } } else { - const _1028: rt.usize = rt.usizeRem(data.length, 8); + const _1028: rs.usize = rs.usizeRem(data.length, 8); if (_1028 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2951: rt.u8): rt.u8 => { - const x394: rt.u8 = _2951; - const _6265: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6265.value, x394 ^ 5); - rt.refMutRelease(_6265); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2951: rs.u8): rs.u8 => { + const x394: rs.u8 = _2951; + const _6265: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6265.value, x394 ^ 5); + rs.refMutRelease(_6265); return x394; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2952: rt.u8): rt.u8 => { - const x395: rt.u8 = _2952; - const _6266: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6266.value, x395 ^ 6); - rt.refMutRelease(_6266); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2952: rs.u8): rs.u8 => { + const x395: rs.u8 = _2952; + const _6266: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6266.value, x395 ^ 6); + rs.refMutRelease(_6266); return x395; - }), "len"), (_2953: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2953[0], 2) === 0; + }), "len"), (_2953: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2953[0], 2) === 0; })) & 0xff); } else if (_1028 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2948: rt.u8): rt.u8 => { - const x391: rt.u8 = _2948; - const _6263: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6263.value, x391 ^ 5); - rt.refMutRelease(_6263); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2948: rs.u8): rs.u8 => { + const x391: rs.u8 = _2948; + const _6263: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6263.value, x391 ^ 5); + rs.refMutRelease(_6263); return x391; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2949: rt.u8): rt.u8 => { - const x392: rt.u8 = _2949; - const _6264: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6264.value, x392 ^ 6); - rt.refMutRelease(_6264); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2949: rs.u8): rs.u8 => { + const x392: rs.u8 = _2949; + const _6264: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6264.value, x392 ^ 6); + rs.refMutRelease(_6264); return x392; - }), "len"), (_2950: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_2950[0], _2950[1]); + }), "len"), (_2950: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2950[0], _2950[1]); })) & 0xff); } else if (_1028 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2945: rt.u8): rt.u8 => { - const x388: rt.u8 = _2945; - const _6261: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6261.value, x388 ^ 5); - rt.refMutRelease(_6261); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2945: rs.u8): rs.u8 => { + const x388: rs.u8 = _2945; + const _6261: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6261.value, x388 ^ 5); + rs.refMutRelease(_6261); return x388; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2946: rt.u8): rt.u8 => { - const x389: rt.u8 = _2946; - const _6262: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6262.value, x389 ^ 6); - rt.refMutRelease(_6262); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2946: rs.u8): rs.u8 => { + const x389: rs.u8 = _2946; + const _6262: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6262.value, x389 ^ 6); + rs.refMutRelease(_6262); return x389; - }), "len"), (_2947: [rt.u8, rt.u8]): boolean => { + }), "len"), (_2947: [rs.u8, rs.u8]): boolean => { return _2947[0] < 128; })) & 0xff); } else if (_1028 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2942: rt.u8): rt.u8 => { - const x386: rt.u8 = _2942; - const _6259: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6259.value, x386 ^ 5); - rt.refMutRelease(_6259); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2942: rs.u8): rs.u8 => { + const x386: rs.u8 = _2942; + const _6259: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6259.value, x386 ^ 5); + rs.refMutRelease(_6259); return x386; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2943: rt.u8): rt.u8 => { - const x387: rt.u8 = _2943; - const _6260: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6260.value, x387 ^ 6); - rt.refMutRelease(_6260); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2943: rs.u8): rs.u8 => { + const x387: rs.u8 = _2943; + const _6260: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6260.value, x387 ^ 6); + rs.refMutRelease(_6260); return x387; - }), "len")), (_2944: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), "len")), (_2944: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _2944[0] & 0xff; })), 238)); } else if (_1028 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2940: rt.u8): rt.u8 => { - const x384: rt.u8 = _2940; - const _6257: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6257.value, x384 ^ 5); - rt.refMutRelease(_6257); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2940: rs.u8): rs.u8 => { + const x384: rs.u8 = _2940; + const _6257: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6257.value, x384 ^ 5); + rs.refMutRelease(_6257); return x384; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2941: rt.u8): rt.u8 => { - const x385: rt.u8 = _2941; - const _6258: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6258.value, x385 ^ 6); - rt.refMutRelease(_6258); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2941: rs.u8): rs.u8 => { + const x385: rs.u8 = _2941; + const _6258: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6258.value, x385 ^ 6); + rs.refMutRelease(_6258); return x385; - }), "len"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), "len"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1028 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2938: rt.u8): rt.u8 => { - const x382: rt.u8 = _2938; - const _6255: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6255.value, x382 ^ 5); - rt.refMutRelease(_6255); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2938: rs.u8): rs.u8 => { + const x382: rs.u8 = _2938; + const _6255: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6255.value, x382 ^ 5); + rs.refMutRelease(_6255); return x382; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2939: rt.u8): rt.u8 => { - const x383: rt.u8 = _2939; - const _6256: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6256.value, x383 ^ 6); - rt.refMutRelease(_6256); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2939: rs.u8): rs.u8 => { + const x383: rs.u8 = _2939; + const _6256: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6256.value, x383 ^ 6); + rs.refMutRelease(_6256); return x383; }), "len"), n)) & 0xff); } else if (_1028 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2936: rt.u8): rt.u8 => { - const x380: rt.u8 = _2936; - const _6253: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6253.value, x380 ^ 5); - rt.refMutRelease(_6253); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2936: rs.u8): rs.u8 => { + const x380: rs.u8 = _2936; + const _6253: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6253.value, x380 ^ 5); + rs.refMutRelease(_6253); return x380; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2937: rt.u8): rt.u8 => { - const x381: rt.u8 = _2937; - const _6254: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6254.value, x381 ^ 6); - rt.refMutRelease(_6254); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2937: rs.u8): rs.u8 => { + const x381: rs.u8 = _2937; + const _6254: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6254.value, x381 ^ 6); + rs.refMutRelease(_6254); return x381; }), "len"), n)) & 0xff); } else { - const p3: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterChain(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2934: rt.u8): rt.u8 => { - const x378: rt.u8 = _2934; - const _6251: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6251.value, x378 ^ 5); - rt.refMutRelease(_6251); + const p3: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterChain(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2934: rs.u8): rs.u8 => { + const x378: rs.u8 = _2934; + const _6251: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6251.value, x378 ^ 5); + rs.refMutRelease(_6251); return x378; - }), rt.iterSlice(rt.byteSliceView(b2))), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2935: rt.u8): rt.u8 => { - const x379: rt.u8 = _2935; - const _6252: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6252.value, x379 ^ 6); - rt.refMutRelease(_6252); + }), rs.iterSlice(rs.byteSliceView(b2))), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2935: rs.u8): rs.u8 => { + const x379: rs.u8 = _2935; + const _6252: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6252.value, x379 ^ 6); + rs.refMutRelease(_6252); return x379; }), "len")); - rt.byteVecPush(out, (rt.peekablePeek(p3) !== undefined ? 1 : 0) ^ (rt.iterCount(p3) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p3) !== undefined ? 1 : 0) ^ (rs.iterCount(p3) & 0xff)); } } } else if (_28 === 2) { if (!other) { if ((kind & 16) === 0) { - const _1171: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _1171: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1171 === 0) { - const z19: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x366: rt.u8): rt.u8 => { - const _6247: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6247.value, x366 ^ 7); - rt.refMutRelease(_6247); + const z19: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x366: rs.u8): rs.u8 => { + const _6247: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6247.value, x366 ^ 7); + rs.refMutRelease(_6247); return x366; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x367: rt.u8): rt.u8 => { - const _6248: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6248.value, x367 ^ 8); - rt.refMutRelease(_6248); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x367: rs.u8): rs.u8 => { + const _6248: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6248.value, x367 ^ 8); + rs.refMutRelease(_6248); return x367; }), "index"); - const _1188: rt.usize = rt.usizeRem(data.length, 8); + const _1188: rs.usize = rs.usizeRem(data.length, 8); if (_1188 === 0) { - rt.byteVecPush(out, rt.iterCount(z19) & 0xff); + rs.byteVecPush(out, rs.iterCount(z19) & 0xff); } else if (_1188 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z19), 238, (_2933: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z19), 238, (_2933: [rs.u8, rs.u8]): rs.u8 => { return _2933[0] ^ _2933[1]; })); } else if (_1188 === 2) { - rt.iterForEach(z19, (p47: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1187(p47)); + rs.iterForEach(z19, (p47: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1187(p47)); }); } else if (_1188 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z19, (_2932: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2932[0] as rt.u32, _2932[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z19, (_2932: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2932[0] as rs.u32, _2932[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1188 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z19, (_2931: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z19, (_2931: [rs.u8, rs.u8]): rs.u8 => { return _2931[0] ^ _2931[1]; }), "index", true, 1)), undefined, true); } else if (_1188 === 5) { - rt.byteVecPush(out, rt.iterFold(z19, 0, (acc20: rt.u8, p46: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc20, 3) ^ _1187(p46); + rs.byteVecPush(out, rs.iterFold(z19, 0, (acc20: rs.u8, p46: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc20, 3) ^ _1187(p46); })); } else if (_1188 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z19, (_2930: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z19, (_2930: [rs.u8, rs.u8]): rs.u8 => { return _2930[0] ^ _2930[1]; - }), (x374: rt.u8): boolean => { + }), (x374: rs.u8): boolean => { return x374 === 0; }) ? 1 : 0); } else { - const z20: rt.Iter<[rt.u8, rt.u8]> = z19; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z20, (_2925: [rt.u8, rt.u8]): boolean => { + const z20: rs.Iter<[rs.u8, rs.u8]> = z19; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z20, (_2925: [rs.u8, rs.u8]): boolean => { return _2925[0] > _2925[1]; - }), 238, (i24: rt.usize): rt.u8 => { + }), 238, (i24: rs.usize): rs.u8 => { return i24 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z20, (_2926: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2926[0], 3) === 0; - }), 238, (_2927: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z20, (_2926: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2926[0], 3) === 0; + }), 238, (_2927: [rs.u8, rs.u8]): rs.u8 => { return _2927[0] ^ _2927[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z20, n), 238, (_2928: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z20, n), 238, (_2928: [rs.u8, rs.u8]): rs.u8 => { return _2928[0] ^ _2928[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z20.next()), 238, (_2929: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z20.next()), 238, (_2929: [rs.u8, rs.u8]): rs.u8 => { return _2929[0] ^ _2929[1]; })); } } else if (_1171 === 1) { - const z21: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x354: rt.u8): rt.u8 => { - const _6243: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6243.value, x354 ^ 7); - rt.refMutRelease(_6243); + const z21: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x354: rs.u8): rs.u8 => { + const _6243: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6243.value, x354 ^ 7); + rs.refMutRelease(_6243); return x354; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x355: rt.u8): rt.u8 => { - const _6244: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6244.value, x355 ^ 8); - rt.refMutRelease(_6244); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x355: rs.u8): rs.u8 => { + const _6244: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6244.value, x355 ^ 8); + rs.refMutRelease(_6244); return x355; }), "index"); - const _1239: rt.usize = rt.usizeRem(data.length, 8); + const _1239: rs.usize = rs.usizeRem(data.length, 8); if (_1239 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z21)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z21)) & 0xff); } else if (_1239 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z21)), 238, (_2924: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z21)), 238, (_2924: [rs.u8, rs.u8]): rs.u8 => { return _2924[0] ^ _2924[1]; })); } else if (_1239 === 2) { - const _1246: (a0: [rt.u8, rt.u8]) => undefined = (p45: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1238(p45)); + const _1246: (a0: [rs.u8, rs.u8]) => undefined = (p45: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1238(p45)); }; - rt.iterForEach(rt.iterBox(z21), _1246); + rs.iterForEach(rs.iterBox(z21), _1246); } else if (_1239 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z21), (_2923: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2923[0] as rt.u32, _2923[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z21), (_2923: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2923[0] as rs.u32, _2923[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1239 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z21), (_2922: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z21), (_2922: [rs.u8, rs.u8]): rs.u8 => { return _2922[0] ^ _2922[1]; }), "next")), undefined, true); } else if (_1239 === 5) { - const _1254: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc19: rt.u8, p44: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc19, 3) ^ _1238(p44); + const _1254: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc19: rs.u8, p44: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc19, 3) ^ _1238(p44); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z21), 0, _1254)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z21), 0, _1254)); } else if (_1239 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z21), (_2921: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z21), (_2921: [rs.u8, rs.u8]): rs.u8 => { return _2921[0] ^ _2921[1]; - }), (x362: rt.u8): boolean => { + }), (x362: rs.u8): boolean => { return x362 === 0; }) ? 1 : 0); } else { - const z22: rt.Iter<[rt.u8, rt.u8]> = z21; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z22), (_2916: [rt.u8, rt.u8]): boolean => { + const z22: rs.Iter<[rs.u8, rs.u8]> = z21; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z22), (_2916: [rs.u8, rs.u8]): boolean => { return _2916[0] > _2916[1]; - }), 238, (i23: rt.usize): rt.u8 => { + }), 238, (i23: rs.usize): rs.u8 => { return i23 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z22), (_2917: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2917[0], 3) === 0; - }), 238, (_2918: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z22), (_2917: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2917[0], 3) === 0; + }), 238, (_2918: [rs.u8, rs.u8]): rs.u8 => { return _2918[0] ^ _2918[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z22), n), 238, (_2919: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z22), n), 238, (_2919: [rs.u8, rs.u8]): rs.u8 => { return _2919[0] ^ _2919[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z22.next()), 238, (_2920: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z22.next()), 238, (_2920: [rs.u8, rs.u8]): rs.u8 => { return _2920[0] ^ _2920[1]; })); } } else if (_1171 === 2) { - const z23: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x342: rt.u8): rt.u8 => { - const _6239: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6239.value, x342 ^ 7); - rt.refMutRelease(_6239); + const z23: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x342: rs.u8): rs.u8 => { + const _6239: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6239.value, x342 ^ 7); + rs.refMutRelease(_6239); return x342; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x343: rt.u8): rt.u8 => { - const _6240: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6240.value, x343 ^ 8); - rt.refMutRelease(_6240); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x343: rs.u8): rs.u8 => { + const _6240: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6240.value, x343 ^ 8); + rs.refMutRelease(_6240); return x343; }), "index"), n); - const _1291: rt.usize = rt.usizeRem(data.length, 8); + const _1291: rs.usize = rs.usizeRem(data.length, 8); if (_1291 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z23)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z23)) & 0xff); } else if (_1291 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z23)), 238, (_2915: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z23)), 238, (_2915: [rs.u8, rs.u8]): rs.u8 => { return _2915[0] ^ _2915[1]; })); } else if (_1291 === 2) { - const _1298: (a0: [rt.u8, rt.u8]) => undefined = (p43: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1290(p43)); + const _1298: (a0: [rs.u8, rs.u8]) => undefined = (p43: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1290(p43)); }; - rt.iterForEach(rt.iterBox(z23), _1298); + rs.iterForEach(rs.iterBox(z23), _1298); } else if (_1291 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z23), (_2914: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2914[0] as rt.u32, _2914[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z23), (_2914: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2914[0] as rs.u32, _2914[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1291 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z23), (_2913: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z23), (_2913: [rs.u8, rs.u8]): rs.u8 => { return _2913[0] ^ _2913[1]; }), "next")), undefined, true); } else if (_1291 === 5) { - const _1306: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc18: rt.u8, p42: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc18, 3) ^ _1290(p42); + const _1306: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc18: rs.u8, p42: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc18, 3) ^ _1290(p42); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z23), 0, _1306)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z23), 0, _1306)); } else if (_1291 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z23), (_2912: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z23), (_2912: [rs.u8, rs.u8]): rs.u8 => { return _2912[0] ^ _2912[1]; - }), (x350: rt.u8): boolean => { + }), (x350: rs.u8): boolean => { return x350 === 0; }) ? 1 : 0); } else { - const z24: rt.Iter<[rt.u8, rt.u8]> = z23; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z24), (_2907: [rt.u8, rt.u8]): boolean => { + const z24: rs.Iter<[rs.u8, rs.u8]> = z23; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z24), (_2907: [rs.u8, rs.u8]): boolean => { return _2907[0] > _2907[1]; - }), 238, (i22: rt.usize): rt.u8 => { + }), 238, (i22: rs.usize): rs.u8 => { return i22 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z24), (_2908: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2908[0], 3) === 0; - }), 238, (_2909: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z24), (_2908: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2908[0], 3) === 0; + }), 238, (_2909: [rs.u8, rs.u8]): rs.u8 => { return _2909[0] ^ _2909[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z24), n), 238, (_2910: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z24), n), 238, (_2910: [rs.u8, rs.u8]): rs.u8 => { return _2910[0] ^ _2910[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z24.next()), 238, (_2911: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z24.next()), 238, (_2911: [rs.u8, rs.u8]): rs.u8 => { return _2911[0] ^ _2911[1]; })); } } else if (_1171 === 3) { - const _1330: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x330: rt.u8): rt.u8 => { - const _6235: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6235.value, x330 ^ 7); - rt.refMutRelease(_6235); + const _1330: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x330: rs.u8): rs.u8 => { + const _6235: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6235.value, x330 ^ 7); + rs.refMutRelease(_6235); return x330; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x331: rt.u8): rt.u8 => { - const _6236: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6236.value, x331 ^ 8); - rt.refMutRelease(_6236); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x331: rs.u8): rs.u8 => { + const _6236: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6236.value, x331 ^ 8); + rs.refMutRelease(_6236); return x331; }), "index"); - const _1343: rt.usize = rt.usizeRem(data.length, 8); + const _1343: rs.usize = rs.usizeRem(data.length, 8); if (_1343 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330)))) & 0xff); } else if (_1343 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330)))), 238, (_2906: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330)))), 238, (_2906: [rs.u8, rs.u8]): rs.u8 => { return _2906[0] ^ _2906[1]; })); } else if (_1343 === 2) { - const _1350: (a0: [rt.u8, rt.u8]) => undefined = (p41: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1342(p41)); + const _1350: (a0: [rs.u8, rs.u8]) => undefined = (p41: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1342(p41)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330))), _1350); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), _1350); } else if (_1343 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330))), (_2905: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2905[0] as rt.u32, _2905[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2905: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2905[0] as rs.u32, _2905[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1343 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330))), (_2904: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2904: [rs.u8, rs.u8]): rs.u8 => { return _2904[0] ^ _2904[1]; }), "next")), undefined, true); } else if (_1343 === 5) { - const _1358: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc17: rt.u8, p40: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc17, 3) ^ _1342(p40); + const _1358: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc17: rs.u8, p40: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc17, 3) ^ _1342(p40); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330))), 0, _1358)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), 0, _1358)); } else if (_1343 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1330))), (_2903: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1330))), (_2903: [rs.u8, rs.u8]): rs.u8 => { return _2903[0] ^ _2903[1]; - }), (x338: rt.u8): boolean => { + }), (x338: rs.u8): boolean => { return x338 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_1330), (_2898: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1330), (_2898: [rs.u8, rs.u8]): boolean => { return _2898[0] > _2898[1]; - }), 238, (i21: rt.usize): rt.u8 => { + }), 238, (i21: rs.usize): rs.u8 => { return i21 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_1330), (_2899: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2899[0], 3) === 0; - }), 238, (_2900: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1330), (_2899: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2899[0], 3) === 0; + }), 238, (_2900: [rs.u8, rs.u8]): rs.u8 => { return _2900[0] ^ _2900[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_1330), n), 238, (_2901: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1330), n), 238, (_2901: [rs.u8, rs.u8]): rs.u8 => { return _2901[0] ^ _2901[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_1330.next()), 238, (_2902: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1330.next()), 238, (_2902: [rs.u8, rs.u8]): rs.u8 => { return _2902[0] ^ _2902[1]; })); } } else { - const _1377: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x318: rt.u8): rt.u8 => { - const _6231: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6231.value, x318 ^ 7); - rt.refMutRelease(_6231); + const _1377: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x318: rs.u8): rs.u8 => { + const _6231: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6231.value, x318 ^ 7); + rs.refMutRelease(_6231); return x318; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x319: rt.u8): rt.u8 => { - const _6232: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6232.value, x319 ^ 8); - rt.refMutRelease(_6232); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x319: rs.u8): rs.u8 => { + const _6232: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6232.value, x319 ^ 8); + rs.refMutRelease(_6232); return x319; }), "index"), n); - const _1391: rt.usize = rt.usizeRem(data.length, 8); + const _1391: rs.usize = rs.usizeRem(data.length, 8); if (_1391 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377)))) & 0xff); } else if (_1391 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377)))), 238, (_2897: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377)))), 238, (_2897: [rs.u8, rs.u8]): rs.u8 => { return _2897[0] ^ _2897[1]; })); } else if (_1391 === 2) { - const _1398: (a0: [rt.u8, rt.u8]) => undefined = (p39: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1390(p39)); + const _1398: (a0: [rs.u8, rs.u8]) => undefined = (p39: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1390(p39)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377))), _1398); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), _1398); } else if (_1391 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377))), (_2896: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2896[0] as rt.u32, _2896[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2896: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2896[0] as rs.u32, _2896[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1391 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377))), (_2895: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2895: [rs.u8, rs.u8]): rs.u8 => { return _2895[0] ^ _2895[1]; }), "next")), undefined, true); } else if (_1391 === 5) { - const _1406: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc16: rt.u8, p38: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc16, 3) ^ _1390(p38); + const _1406: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc16: rs.u8, p38: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc16, 3) ^ _1390(p38); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377))), 0, _1406)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), 0, _1406)); } else if (_1391 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1377))), (_2894: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1377))), (_2894: [rs.u8, rs.u8]): rs.u8 => { return _2894[0] ^ _2894[1]; - }), (x326: rt.u8): boolean => { + }), (x326: rs.u8): boolean => { return x326 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_1377), (_2889: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1377), (_2889: [rs.u8, rs.u8]): boolean => { return _2889[0] > _2889[1]; - }), 238, (i20: rt.usize): rt.u8 => { + }), 238, (i20: rs.usize): rs.u8 => { return i20 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_1377), (_2890: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2890[0], 3) === 0; - }), 238, (_2891: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1377), (_2890: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2890[0], 3) === 0; + }), 238, (_2891: [rs.u8, rs.u8]): rs.u8 => { return _2891[0] ^ _2891[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_1377), n), 238, (_2892: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1377), n), 238, (_2892: [rs.u8, rs.u8]): rs.u8 => { return _2892[0] ^ _2892[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_1377.next()), 238, (_2893: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1377.next()), 238, (_2893: [rs.u8, rs.u8]): rs.u8 => { return _2893[0] ^ _2893[1]; })); } } } else { - const _1424: rt.usize = rt.usizeRem(data.length, 8); + const _1424: rs.usize = rs.usizeRem(data.length, 8); if (_1424 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x315: rt.u8): rt.u8 => { - const _6229: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6229.value, x315 ^ 7); - rt.refMutRelease(_6229); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x315: rs.u8): rs.u8 => { + const _6229: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6229.value, x315 ^ 7); + rs.refMutRelease(_6229); return x315; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x316: rt.u8): rt.u8 => { - const _6230: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6230.value, x316 ^ 8); - rt.refMutRelease(_6230); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x316: rs.u8): rs.u8 => { + const _6230: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6230.value, x316 ^ 8); + rs.refMutRelease(_6230); return x316; - }), "index"), (_2888: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2888[0], 2) === 0; + }), "index"), (_2888: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2888[0], 2) === 0; })) & 0xff); } else if (_1424 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x312: rt.u8): rt.u8 => { - const _6227: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6227.value, x312 ^ 7); - rt.refMutRelease(_6227); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x312: rs.u8): rs.u8 => { + const _6227: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6227.value, x312 ^ 7); + rs.refMutRelease(_6227); return x312; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x313: rt.u8): rt.u8 => { - const _6228: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6228.value, x313 ^ 8); - rt.refMutRelease(_6228); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x313: rs.u8): rs.u8 => { + const _6228: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6228.value, x313 ^ 8); + rs.refMutRelease(_6228); return x313; - }), "index"), (_2887: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_2887[0], _2887[1]); + }), "index"), (_2887: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2887[0], _2887[1]); })) & 0xff); } else if (_1424 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x309: rt.u8): rt.u8 => { - const _6225: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6225.value, x309 ^ 7); - rt.refMutRelease(_6225); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x309: rs.u8): rs.u8 => { + const _6225: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6225.value, x309 ^ 7); + rs.refMutRelease(_6225); return x309; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x310: rt.u8): rt.u8 => { - const _6226: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6226.value, x310 ^ 8); - rt.refMutRelease(_6226); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x310: rs.u8): rs.u8 => { + const _6226: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6226.value, x310 ^ 8); + rs.refMutRelease(_6226); return x310; - }), "index"), (_2886: [rt.u8, rt.u8]): boolean => { + }), "index"), (_2886: [rs.u8, rs.u8]): boolean => { return _2886[0] < 128; })) & 0xff); } else if (_1424 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x307: rt.u8): rt.u8 => { - const _6223: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6223.value, x307 ^ 7); - rt.refMutRelease(_6223); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x307: rs.u8): rs.u8 => { + const _6223: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6223.value, x307 ^ 7); + rs.refMutRelease(_6223); return x307; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x308: rt.u8): rt.u8 => { - const _6224: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6224.value, x308 ^ 8); - rt.refMutRelease(_6224); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x308: rs.u8): rs.u8 => { + const _6224: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6224.value, x308 ^ 8); + rs.refMutRelease(_6224); return x308; - }), "index")), (_2885: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), "index")), (_2885: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _2885[0] & 0xff; })), 238)); } else if (_1424 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x305: rt.u8): rt.u8 => { - const _6221: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6221.value, x305 ^ 7); - rt.refMutRelease(_6221); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x305: rs.u8): rs.u8 => { + const _6221: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6221.value, x305 ^ 7); + rs.refMutRelease(_6221); return x305; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x306: rt.u8): rt.u8 => { - const _6222: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6222.value, x306 ^ 8); - rt.refMutRelease(_6222); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x306: rs.u8): rs.u8 => { + const _6222: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6222.value, x306 ^ 8); + rs.refMutRelease(_6222); return x306; - }), "index"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), "index"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1424 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x303: rt.u8): rt.u8 => { - const _6219: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6219.value, x303 ^ 7); - rt.refMutRelease(_6219); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x303: rs.u8): rs.u8 => { + const _6219: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6219.value, x303 ^ 7); + rs.refMutRelease(_6219); return x303; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x304: rt.u8): rt.u8 => { - const _6220: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6220.value, x304 ^ 8); - rt.refMutRelease(_6220); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x304: rs.u8): rs.u8 => { + const _6220: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6220.value, x304 ^ 8); + rs.refMutRelease(_6220); return x304; }), "index"), n)) & 0xff); } else if (_1424 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x301: rt.u8): rt.u8 => { - const _6217: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6217.value, x301 ^ 7); - rt.refMutRelease(_6217); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x301: rs.u8): rs.u8 => { + const _6217: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6217.value, x301 ^ 7); + rs.refMutRelease(_6217); return x301; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x302: rt.u8): rt.u8 => { - const _6218: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6218.value, x302 ^ 8); - rt.refMutRelease(_6218); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x302: rs.u8): rs.u8 => { + const _6218: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6218.value, x302 ^ 8); + rs.refMutRelease(_6218); return x302; }), "index"), n)) & 0xff); } else { - const p4: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), (x299: rt.u8): rt.u8 => { - const _6215: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6215.value, x299 ^ 7); - rt.refMutRelease(_6215); + const p4: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), (x299: rs.u8): rs.u8 => { + const _6215: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6215.value, x299 ^ 7); + rs.refMutRelease(_6215); return x299; - }), rt.iterMap(rt.byteVecIntoIter(rt.byteSliceToByteVec(b2)), (x300: rt.u8): rt.u8 => { - const _6216: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6216.value, x300 ^ 8); - rt.refMutRelease(_6216); + }), rs.iterMap(rs.byteVecIntoIter(rs.byteSliceToByteVec(b2)), (x300: rs.u8): rs.u8 => { + const _6216: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6216.value, x300 ^ 8); + rs.refMutRelease(_6216); return x300; }), "index")); - rt.byteVecPush(out, (rt.peekablePeek(p4) !== undefined ? 1 : 0) ^ (rt.iterCount(p4) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p4) !== undefined ? 1 : 0) ^ (rs.iterCount(p4) & 0xff)); } } } else if ((kind & 16) === 0) { - const _1551: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _1551: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1551 === 0) { - const z25: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x287: rt.u8): rt.u8 => { - const _6211: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6211.value, x287 ^ 9); - rt.refMutRelease(_6211); + const z25: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x287: rs.u8): rs.u8 => { + const _6211: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6211.value, x287 ^ 9); + rs.refMutRelease(_6211); return x287; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2875: rt.u8): rt.u8 => { - const x288: rt.u8 = _2875; - const _6212: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6212.value, x288 ^ 10); - rt.refMutRelease(_6212); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2875: rs.u8): rs.u8 => { + const x288: rs.u8 = _2875; + const _6212: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6212.value, x288 ^ 10); + rs.refMutRelease(_6212); return x288; }), "index"); - const _1568: rt.usize = rt.usizeRem(data.length, 8); + const _1568: rs.usize = rs.usizeRem(data.length, 8); if (_1568 === 0) { - rt.byteVecPush(out, rt.iterCount(z25) & 0xff); + rs.byteVecPush(out, rs.iterCount(z25) & 0xff); } else if (_1568 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z25), 238, (_2884: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z25), 238, (_2884: [rs.u8, rs.u8]): rs.u8 => { return _2884[0] ^ _2884[1]; })); } else if (_1568 === 2) { - rt.iterForEach(z25, (p37: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1567(p37)); + rs.iterForEach(z25, (p37: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1567(p37)); }); } else if (_1568 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z25, (_2883: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2883[0] as rt.u32, _2883[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z25, (_2883: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2883[0] as rs.u32, _2883[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1568 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z25, (_2882: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z25, (_2882: [rs.u8, rs.u8]): rs.u8 => { return _2882[0] ^ _2882[1]; }), "index", true, 1)), undefined, true); } else if (_1568 === 5) { - rt.byteVecPush(out, rt.iterFold(z25, 0, (acc15: rt.u8, p36: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc15, 3) ^ _1567(p36); + rs.byteVecPush(out, rs.iterFold(z25, 0, (acc15: rs.u8, p36: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc15, 3) ^ _1567(p36); })); } else if (_1568 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z25, (_2881: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z25, (_2881: [rs.u8, rs.u8]): rs.u8 => { return _2881[0] ^ _2881[1]; - }), (x295: rt.u8): boolean => { + }), (x295: rs.u8): boolean => { return x295 === 0; }) ? 1 : 0); } else { - const z26: rt.Iter<[rt.u8, rt.u8]> = z25; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z26, (_2876: [rt.u8, rt.u8]): boolean => { + const z26: rs.Iter<[rs.u8, rs.u8]> = z25; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z26, (_2876: [rs.u8, rs.u8]): boolean => { return _2876[0] > _2876[1]; - }), 238, (i18: rt.usize): rt.u8 => { + }), 238, (i18: rs.usize): rs.u8 => { return i18 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z26, (_2877: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2877[0], 3) === 0; - }), 238, (_2878: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z26, (_2877: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2877[0], 3) === 0; + }), 238, (_2878: [rs.u8, rs.u8]): rs.u8 => { return _2878[0] ^ _2878[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z26, n), 238, (_2879: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z26, n), 238, (_2879: [rs.u8, rs.u8]): rs.u8 => { return _2879[0] ^ _2879[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z26.next()), 238, (_2880: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z26.next()), 238, (_2880: [rs.u8, rs.u8]): rs.u8 => { return _2880[0] ^ _2880[1]; })); } } else if (_1551 === 1) { - const z27: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x275: rt.u8): rt.u8 => { - const _6207: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6207.value, x275 ^ 9); - rt.refMutRelease(_6207); + const z27: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x275: rs.u8): rs.u8 => { + const _6207: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6207.value, x275 ^ 9); + rs.refMutRelease(_6207); return x275; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2865: rt.u8): rt.u8 => { - const x276: rt.u8 = _2865; - const _6208: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6208.value, x276 ^ 10); - rt.refMutRelease(_6208); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2865: rs.u8): rs.u8 => { + const x276: rs.u8 = _2865; + const _6208: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6208.value, x276 ^ 10); + rs.refMutRelease(_6208); return x276; }), "index"); - const _1619: rt.usize = rt.usizeRem(data.length, 8); + const _1619: rs.usize = rs.usizeRem(data.length, 8); if (_1619 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z27)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z27)) & 0xff); } else if (_1619 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z27)), 238, (_2874: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z27)), 238, (_2874: [rs.u8, rs.u8]): rs.u8 => { return _2874[0] ^ _2874[1]; })); } else if (_1619 === 2) { - const _1626: (a0: [rt.u8, rt.u8]) => undefined = (p35: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1618(p35)); + const _1626: (a0: [rs.u8, rs.u8]) => undefined = (p35: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1618(p35)); }; - rt.iterForEach(rt.iterBox(z27), _1626); + rs.iterForEach(rs.iterBox(z27), _1626); } else if (_1619 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z27), (_2873: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2873[0] as rt.u32, _2873[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z27), (_2873: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2873[0] as rs.u32, _2873[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1619 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z27), (_2872: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z27), (_2872: [rs.u8, rs.u8]): rs.u8 => { return _2872[0] ^ _2872[1]; }), "next")), undefined, true); } else if (_1619 === 5) { - const _1634: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc14: rt.u8, p34: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc14, 3) ^ _1618(p34); + const _1634: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc14: rs.u8, p34: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc14, 3) ^ _1618(p34); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z27), 0, _1634)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z27), 0, _1634)); } else if (_1619 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z27), (_2871: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z27), (_2871: [rs.u8, rs.u8]): rs.u8 => { return _2871[0] ^ _2871[1]; - }), (x283: rt.u8): boolean => { + }), (x283: rs.u8): boolean => { return x283 === 0; }) ? 1 : 0); } else { - const z28: rt.Iter<[rt.u8, rt.u8]> = z27; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z28), (_2866: [rt.u8, rt.u8]): boolean => { + const z28: rs.Iter<[rs.u8, rs.u8]> = z27; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z28), (_2866: [rs.u8, rs.u8]): boolean => { return _2866[0] > _2866[1]; - }), 238, (i17: rt.usize): rt.u8 => { + }), 238, (i17: rs.usize): rs.u8 => { return i17 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z28), (_2867: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2867[0], 3) === 0; - }), 238, (_2868: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z28), (_2867: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2867[0], 3) === 0; + }), 238, (_2868: [rs.u8, rs.u8]): rs.u8 => { return _2868[0] ^ _2868[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z28), n), 238, (_2869: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z28), n), 238, (_2869: [rs.u8, rs.u8]): rs.u8 => { return _2869[0] ^ _2869[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z28.next()), 238, (_2870: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z28.next()), 238, (_2870: [rs.u8, rs.u8]): rs.u8 => { return _2870[0] ^ _2870[1]; })); } } else if (_1551 === 2) { - const z29: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x263: rt.u8): rt.u8 => { - const _6203: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6203.value, x263 ^ 9); - rt.refMutRelease(_6203); + const z29: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x263: rs.u8): rs.u8 => { + const _6203: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6203.value, x263 ^ 9); + rs.refMutRelease(_6203); return x263; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2855: rt.u8): rt.u8 => { - const x264: rt.u8 = _2855; - const _6204: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6204.value, x264 ^ 10); - rt.refMutRelease(_6204); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2855: rs.u8): rs.u8 => { + const x264: rs.u8 = _2855; + const _6204: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6204.value, x264 ^ 10); + rs.refMutRelease(_6204); return x264; }), "index"), n); - const _1671: rt.usize = rt.usizeRem(data.length, 8); + const _1671: rs.usize = rs.usizeRem(data.length, 8); if (_1671 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z29)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z29)) & 0xff); } else if (_1671 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z29)), 238, (_2864: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z29)), 238, (_2864: [rs.u8, rs.u8]): rs.u8 => { return _2864[0] ^ _2864[1]; })); } else if (_1671 === 2) { - const _1678: (a0: [rt.u8, rt.u8]) => undefined = (p33: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1670(p33)); + const _1678: (a0: [rs.u8, rs.u8]) => undefined = (p33: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1670(p33)); }; - rt.iterForEach(rt.iterBox(z29), _1678); + rs.iterForEach(rs.iterBox(z29), _1678); } else if (_1671 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z29), (_2863: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2863[0] as rt.u32, _2863[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z29), (_2863: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2863[0] as rs.u32, _2863[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1671 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z29), (_2862: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z29), (_2862: [rs.u8, rs.u8]): rs.u8 => { return _2862[0] ^ _2862[1]; }), "next")), undefined, true); } else if (_1671 === 5) { - const _1686: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc13: rt.u8, p32: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc13, 3) ^ _1670(p32); + const _1686: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc13: rs.u8, p32: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc13, 3) ^ _1670(p32); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z29), 0, _1686)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z29), 0, _1686)); } else if (_1671 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z29), (_2861: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z29), (_2861: [rs.u8, rs.u8]): rs.u8 => { return _2861[0] ^ _2861[1]; - }), (x271: rt.u8): boolean => { + }), (x271: rs.u8): boolean => { return x271 === 0; }) ? 1 : 0); } else { - const z30: rt.Iter<[rt.u8, rt.u8]> = z29; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z30), (_2856: [rt.u8, rt.u8]): boolean => { + const z30: rs.Iter<[rs.u8, rs.u8]> = z29; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z30), (_2856: [rs.u8, rs.u8]): boolean => { return _2856[0] > _2856[1]; - }), 238, (i16: rt.usize): rt.u8 => { + }), 238, (i16: rs.usize): rs.u8 => { return i16 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z30), (_2857: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2857[0], 3) === 0; - }), 238, (_2858: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z30), (_2857: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2857[0], 3) === 0; + }), 238, (_2858: [rs.u8, rs.u8]): rs.u8 => { return _2858[0] ^ _2858[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z30), n), 238, (_2859: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z30), n), 238, (_2859: [rs.u8, rs.u8]): rs.u8 => { return _2859[0] ^ _2859[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z30.next()), 238, (_2860: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z30.next()), 238, (_2860: [rs.u8, rs.u8]): rs.u8 => { return _2860[0] ^ _2860[1]; })); } } else if (_1551 === 3) { - const _1710: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x251: rt.u8): rt.u8 => { - const _6199: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6199.value, x251 ^ 9); - rt.refMutRelease(_6199); + const _1710: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x251: rs.u8): rs.u8 => { + const _6199: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6199.value, x251 ^ 9); + rs.refMutRelease(_6199); return x251; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2845: rt.u8): rt.u8 => { - const x252: rt.u8 = _2845; - const _6200: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6200.value, x252 ^ 10); - rt.refMutRelease(_6200); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2845: rs.u8): rs.u8 => { + const x252: rs.u8 = _2845; + const _6200: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6200.value, x252 ^ 10); + rs.refMutRelease(_6200); return x252; }), "index"); - const _1723: rt.usize = rt.usizeRem(data.length, 8); + const _1723: rs.usize = rs.usizeRem(data.length, 8); if (_1723 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710)))) & 0xff); } else if (_1723 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710)))), 238, (_2854: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710)))), 238, (_2854: [rs.u8, rs.u8]): rs.u8 => { return _2854[0] ^ _2854[1]; })); } else if (_1723 === 2) { - const _1730: (a0: [rt.u8, rt.u8]) => undefined = (p31: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1722(p31)); + const _1730: (a0: [rs.u8, rs.u8]) => undefined = (p31: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1722(p31)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710))), _1730); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), _1730); } else if (_1723 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710))), (_2853: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2853[0] as rt.u32, _2853[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2853: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2853[0] as rs.u32, _2853[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1723 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710))), (_2852: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2852: [rs.u8, rs.u8]): rs.u8 => { return _2852[0] ^ _2852[1]; }), "next")), undefined, true); } else if (_1723 === 5) { - const _1738: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc12: rt.u8, p30: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc12, 3) ^ _1722(p30); + const _1738: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc12: rs.u8, p30: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc12, 3) ^ _1722(p30); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710))), 0, _1738)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), 0, _1738)); } else if (_1723 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1710))), (_2851: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1710))), (_2851: [rs.u8, rs.u8]): rs.u8 => { return _2851[0] ^ _2851[1]; - }), (x259: rt.u8): boolean => { + }), (x259: rs.u8): boolean => { return x259 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_1710), (_2846: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1710), (_2846: [rs.u8, rs.u8]): boolean => { return _2846[0] > _2846[1]; - }), 238, (i15: rt.usize): rt.u8 => { + }), 238, (i15: rs.usize): rs.u8 => { return i15 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_1710), (_2847: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2847[0], 3) === 0; - }), 238, (_2848: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1710), (_2847: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2847[0], 3) === 0; + }), 238, (_2848: [rs.u8, rs.u8]): rs.u8 => { return _2848[0] ^ _2848[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_1710), n), 238, (_2849: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1710), n), 238, (_2849: [rs.u8, rs.u8]): rs.u8 => { return _2849[0] ^ _2849[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_1710.next()), 238, (_2850: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1710.next()), 238, (_2850: [rs.u8, rs.u8]): rs.u8 => { return _2850[0] ^ _2850[1]; })); } } else { - const _1757: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x239: rt.u8): rt.u8 => { - const _6195: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6195.value, x239 ^ 9); - rt.refMutRelease(_6195); + const _1757: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x239: rs.u8): rs.u8 => { + const _6195: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6195.value, x239 ^ 9); + rs.refMutRelease(_6195); return x239; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2835: rt.u8): rt.u8 => { - const x240: rt.u8 = _2835; - const _6196: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6196.value, x240 ^ 10); - rt.refMutRelease(_6196); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2835: rs.u8): rs.u8 => { + const x240: rs.u8 = _2835; + const _6196: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6196.value, x240 ^ 10); + rs.refMutRelease(_6196); return x240; }), "index"), n); - const _1771: rt.usize = rt.usizeRem(data.length, 8); + const _1771: rs.usize = rs.usizeRem(data.length, 8); if (_1771 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757)))) & 0xff); } else if (_1771 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757)))), 238, (_2844: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757)))), 238, (_2844: [rs.u8, rs.u8]): rs.u8 => { return _2844[0] ^ _2844[1]; })); } else if (_1771 === 2) { - const _1778: (a0: [rt.u8, rt.u8]) => undefined = (p29: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1770(p29)); + const _1778: (a0: [rs.u8, rs.u8]) => undefined = (p29: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1770(p29)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757))), _1778); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), _1778); } else if (_1771 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757))), (_2843: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2843[0] as rt.u32, _2843[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2843: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2843[0] as rs.u32, _2843[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1771 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757))), (_2842: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2842: [rs.u8, rs.u8]): rs.u8 => { return _2842[0] ^ _2842[1]; }), "next")), undefined, true); } else if (_1771 === 5) { - const _1786: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc11: rt.u8, p28: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc11, 3) ^ _1770(p28); + const _1786: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc11: rs.u8, p28: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc11, 3) ^ _1770(p28); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757))), 0, _1786)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), 0, _1786)); } else if (_1771 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_1757))), (_2841: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_1757))), (_2841: [rs.u8, rs.u8]): rs.u8 => { return _2841[0] ^ _2841[1]; - }), (x247: rt.u8): boolean => { + }), (x247: rs.u8): boolean => { return x247 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_1757), (_2836: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_1757), (_2836: [rs.u8, rs.u8]): boolean => { return _2836[0] > _2836[1]; - }), 238, (i14: rt.usize): rt.u8 => { + }), 238, (i14: rs.usize): rs.u8 => { return i14 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_1757), (_2837: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2837[0], 3) === 0; - }), 238, (_2838: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_1757), (_2837: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2837[0], 3) === 0; + }), 238, (_2838: [rs.u8, rs.u8]): rs.u8 => { return _2838[0] ^ _2838[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_1757), n), 238, (_2839: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_1757), n), 238, (_2839: [rs.u8, rs.u8]): rs.u8 => { return _2839[0] ^ _2839[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_1757.next()), 238, (_2840: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_1757.next()), 238, (_2840: [rs.u8, rs.u8]): rs.u8 => { return _2840[0] ^ _2840[1]; })); } } } else { - const _1804: rt.usize = rt.usizeRem(data.length, 8); + const _1804: rs.usize = rs.usizeRem(data.length, 8); if (_1804 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x236: rt.u8): rt.u8 => { - const _6193: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6193.value, x236 ^ 9); - rt.refMutRelease(_6193); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x236: rs.u8): rs.u8 => { + const _6193: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6193.value, x236 ^ 9); + rs.refMutRelease(_6193); return x236; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2833: rt.u8): rt.u8 => { - const x237: rt.u8 = _2833; - const _6194: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6194.value, x237 ^ 10); - rt.refMutRelease(_6194); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2833: rs.u8): rs.u8 => { + const x237: rs.u8 = _2833; + const _6194: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6194.value, x237 ^ 10); + rs.refMutRelease(_6194); return x237; - }), "index"), (_2834: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2834[0], 2) === 0; + }), "index"), (_2834: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2834[0], 2) === 0; })) & 0xff); } else if (_1804 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x233: rt.u8): rt.u8 => { - const _6191: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6191.value, x233 ^ 9); - rt.refMutRelease(_6191); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x233: rs.u8): rs.u8 => { + const _6191: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6191.value, x233 ^ 9); + rs.refMutRelease(_6191); return x233; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2831: rt.u8): rt.u8 => { - const x234: rt.u8 = _2831; - const _6192: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6192.value, x234 ^ 10); - rt.refMutRelease(_6192); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2831: rs.u8): rs.u8 => { + const x234: rs.u8 = _2831; + const _6192: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6192.value, x234 ^ 10); + rs.refMutRelease(_6192); return x234; - }), "index"), (_2832: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_2832[0], _2832[1]); + }), "index"), (_2832: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2832[0], _2832[1]); })) & 0xff); } else if (_1804 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x230: rt.u8): rt.u8 => { - const _6189: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6189.value, x230 ^ 9); - rt.refMutRelease(_6189); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x230: rs.u8): rs.u8 => { + const _6189: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6189.value, x230 ^ 9); + rs.refMutRelease(_6189); return x230; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2829: rt.u8): rt.u8 => { - const x231: rt.u8 = _2829; - const _6190: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6190.value, x231 ^ 10); - rt.refMutRelease(_6190); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2829: rs.u8): rs.u8 => { + const x231: rs.u8 = _2829; + const _6190: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6190.value, x231 ^ 10); + rs.refMutRelease(_6190); return x231; - }), "index"), (_2830: [rt.u8, rt.u8]): boolean => { + }), "index"), (_2830: [rs.u8, rs.u8]): boolean => { return _2830[0] < 128; })) & 0xff); } else if (_1804 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x228: rt.u8): rt.u8 => { - const _6187: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6187.value, x228 ^ 9); - rt.refMutRelease(_6187); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x228: rs.u8): rs.u8 => { + const _6187: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6187.value, x228 ^ 9); + rs.refMutRelease(_6187); return x228; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2827: rt.u8): rt.u8 => { - const x229: rt.u8 = _2827; - const _6188: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6188.value, x229 ^ 10); - rt.refMutRelease(_6188); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2827: rs.u8): rs.u8 => { + const x229: rs.u8 = _2827; + const _6188: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6188.value, x229 ^ 10); + rs.refMutRelease(_6188); return x229; - }), "index")), (_2828: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), "index")), (_2828: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _2828[0] & 0xff; })), 238)); } else if (_1804 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x226: rt.u8): rt.u8 => { - const _6185: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6185.value, x226 ^ 9); - rt.refMutRelease(_6185); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x226: rs.u8): rs.u8 => { + const _6185: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6185.value, x226 ^ 9); + rs.refMutRelease(_6185); return x226; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2826: rt.u8): rt.u8 => { - const x227: rt.u8 = _2826; - const _6186: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6186.value, x227 ^ 10); - rt.refMutRelease(_6186); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2826: rs.u8): rs.u8 => { + const x227: rs.u8 = _2826; + const _6186: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6186.value, x227 ^ 10); + rs.refMutRelease(_6186); return x227; - }), "index"), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), "index"), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_1804 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x224: rt.u8): rt.u8 => { - const _6183: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6183.value, x224 ^ 9); - rt.refMutRelease(_6183); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x224: rs.u8): rs.u8 => { + const _6183: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6183.value, x224 ^ 9); + rs.refMutRelease(_6183); return x224; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2825: rt.u8): rt.u8 => { - const x225: rt.u8 = _2825; - const _6184: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6184.value, x225 ^ 10); - rt.refMutRelease(_6184); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2825: rs.u8): rs.u8 => { + const x225: rs.u8 = _2825; + const _6184: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6184.value, x225 ^ 10); + rs.refMutRelease(_6184); return x225; }), "index"), n)) & 0xff); } else if (_1804 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x222: rt.u8): rt.u8 => { - const _6181: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6181.value, x222 ^ 9); - rt.refMutRelease(_6181); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x222: rs.u8): rs.u8 => { + const _6181: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6181.value, x222 ^ 9); + rs.refMutRelease(_6181); return x222; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2824: rt.u8): rt.u8 => { - const x223: rt.u8 = _2824; - const _6182: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6182.value, x223 ^ 10); - rt.refMutRelease(_6182); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2824: rs.u8): rs.u8 => { + const x223: rs.u8 = _2824; + const _6182: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6182.value, x223 ^ 10); + rs.refMutRelease(_6182); return x223; }), "index"), n)) & 0xff); } else { - const p5: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterMap(rt.iterSkip(rt.byteVecIntoIter(rt.byteSliceToByteVec(a2)), 1), (x220: rt.u8): rt.u8 => { - const _6179: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6179.value, x220 ^ 9); - rt.refMutRelease(_6179); + const p5: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterMap(rs.iterSkip(rs.byteVecIntoIter(rs.byteSliceToByteVec(a2)), 1), (x220: rs.u8): rs.u8 => { + const _6179: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6179.value, x220 ^ 9); + rs.refMutRelease(_6179); return x220; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2823: rt.u8): rt.u8 => { - const x221: rt.u8 = _2823; - const _6180: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6180.value, x221 ^ 10); - rt.refMutRelease(_6180); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2823: rs.u8): rs.u8 => { + const x221: rs.u8 = _2823; + const _6180: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6180.value, x221 ^ 10); + rs.refMutRelease(_6180); return x221; }), "index")); - rt.byteVecPush(out, (rt.peekablePeek(p5) !== undefined ? 1 : 0) ^ (rt.iterCount(p5) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p5) !== undefined ? 1 : 0) ^ (rs.iterCount(p5) & 0xff)); } } } else if (!other) { if ((kind & 16) === 0) { - const _1931: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _1931: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_1931 === 0) { - const z31: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2811: rt.u8): rt.u8 => { - const x208: rt.u8 = _2811; - const _6175: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6175.value, x208 ^ 11); - rt.refMutRelease(_6175); + const z31: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2811: rs.u8): rs.u8 => { + const x208: rs.u8 = _2811; + const _6175: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6175.value, x208 ^ 11); + rs.refMutRelease(_6175); return x208; - }), (_2812: rt.u8): boolean => { + }), (_2812: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2813: rt.u8): rt.u8 => { - const x209: rt.u8 = _2813; - const _6176: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6176.value, x209 ^ 12); - rt.refMutRelease(_6176); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2813: rs.u8): rs.u8 => { + const x209: rs.u8 = _2813; + const _6176: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6176.value, x209 ^ 12); + rs.refMutRelease(_6176); return x209; })); - const _1947: rt.usize = rt.usizeRem(data.length, 8); + const _1947: rs.usize = rs.usizeRem(data.length, 8); if (_1947 === 0) { - rt.byteVecPush(out, rt.iterCount(z31) & 0xff); + rs.byteVecPush(out, rs.iterCount(z31) & 0xff); } else if (_1947 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z31), 238, (_2822: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z31), 238, (_2822: [rs.u8, rs.u8]): rs.u8 => { return _2822[0] ^ _2822[1]; })); } else if (_1947 === 2) { - rt.iterForEach(z31, (p27: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1946(p27)); + rs.iterForEach(z31, (p27: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1946(p27)); }); } else if (_1947 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z31, (_2821: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2821[0] as rt.u32, _2821[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z31, (_2821: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2821[0] as rs.u32, _2821[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1947 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z31, (_2820: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z31, (_2820: [rs.u8, rs.u8]): rs.u8 => { return _2820[0] ^ _2820[1]; }), "next")), undefined, true); } else if (_1947 === 5) { - rt.byteVecPush(out, rt.iterFold(z31, 0, (acc10: rt.u8, p26: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc10, 3) ^ _1946(p26); + rs.byteVecPush(out, rs.iterFold(z31, 0, (acc10: rs.u8, p26: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc10, 3) ^ _1946(p26); })); } else if (_1947 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z31, (_2819: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z31, (_2819: [rs.u8, rs.u8]): rs.u8 => { return _2819[0] ^ _2819[1]; - }), (x216: rt.u8): boolean => { + }), (x216: rs.u8): boolean => { return x216 === 0; }) ? 1 : 0); } else { - const z32: rt.Iter<[rt.u8, rt.u8]> = z31; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z32, (_2814: [rt.u8, rt.u8]): boolean => { + const z32: rs.Iter<[rs.u8, rs.u8]> = z31; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z32, (_2814: [rs.u8, rs.u8]): boolean => { return _2814[0] > _2814[1]; - }), 238, (i12: rt.usize): rt.u8 => { + }), 238, (i12: rs.usize): rs.u8 => { return i12 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z32, (_2815: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2815[0], 3) === 0; - }), 238, (_2816: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z32, (_2815: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2815[0], 3) === 0; + }), 238, (_2816: [rs.u8, rs.u8]): rs.u8 => { return _2816[0] ^ _2816[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z32, n), 238, (_2817: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z32, n), 238, (_2817: [rs.u8, rs.u8]): rs.u8 => { return _2817[0] ^ _2817[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z32.next()), 238, (_2818: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z32.next()), 238, (_2818: [rs.u8, rs.u8]): rs.u8 => { return _2818[0] ^ _2818[1]; })); } } else if (_1931 === 1) { - const z33: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2799: rt.u8): rt.u8 => { - const x196: rt.u8 = _2799; - const _6171: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6171.value, x196 ^ 11); - rt.refMutRelease(_6171); + const z33: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2799: rs.u8): rs.u8 => { + const x196: rs.u8 = _2799; + const _6171: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6171.value, x196 ^ 11); + rs.refMutRelease(_6171); return x196; - }), (_2800: rt.u8): boolean => { + }), (_2800: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2801: rt.u8): rt.u8 => { - const x197: rt.u8 = _2801; - const _6172: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6172.value, x197 ^ 12); - rt.refMutRelease(_6172); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2801: rs.u8): rs.u8 => { + const x197: rs.u8 = _2801; + const _6172: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6172.value, x197 ^ 12); + rs.refMutRelease(_6172); return x197; })); - const _1997: rt.usize = rt.usizeRem(data.length, 8); + const _1997: rs.usize = rs.usizeRem(data.length, 8); if (_1997 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z33)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z33)) & 0xff); } else if (_1997 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z33)), 238, (_2810: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z33)), 238, (_2810: [rs.u8, rs.u8]): rs.u8 => { return _2810[0] ^ _2810[1]; })); } else if (_1997 === 2) { - const _2004: (a0: [rt.u8, rt.u8]) => undefined = (p25: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _1996(p25)); + const _2004: (a0: [rs.u8, rs.u8]) => undefined = (p25: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _1996(p25)); }; - rt.iterForEach(rt.iterBox(z33), _2004); + rs.iterForEach(rs.iterBox(z33), _2004); } else if (_1997 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z33), (_2809: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2809[0] as rt.u32, _2809[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z33), (_2809: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2809[0] as rs.u32, _2809[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_1997 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z33), (_2808: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z33), (_2808: [rs.u8, rs.u8]): rs.u8 => { return _2808[0] ^ _2808[1]; }), "next")), undefined, true); } else if (_1997 === 5) { - const _2012: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc9: rt.u8, p24: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc9, 3) ^ _1996(p24); + const _2012: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc9: rs.u8, p24: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc9, 3) ^ _1996(p24); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z33), 0, _2012)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z33), 0, _2012)); } else if (_1997 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z33), (_2807: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z33), (_2807: [rs.u8, rs.u8]): rs.u8 => { return _2807[0] ^ _2807[1]; - }), (x204: rt.u8): boolean => { + }), (x204: rs.u8): boolean => { return x204 === 0; }) ? 1 : 0); } else { - const z34: rt.Iter<[rt.u8, rt.u8]> = z33; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z34), (_2802: [rt.u8, rt.u8]): boolean => { + const z34: rs.Iter<[rs.u8, rs.u8]> = z33; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z34), (_2802: [rs.u8, rs.u8]): boolean => { return _2802[0] > _2802[1]; - }), 238, (i11: rt.usize): rt.u8 => { + }), 238, (i11: rs.usize): rs.u8 => { return i11 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z34), (_2803: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2803[0], 3) === 0; - }), 238, (_2804: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z34), (_2803: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2803[0], 3) === 0; + }), 238, (_2804: [rs.u8, rs.u8]): rs.u8 => { return _2804[0] ^ _2804[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z34), n), 238, (_2805: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z34), n), 238, (_2805: [rs.u8, rs.u8]): rs.u8 => { return _2805[0] ^ _2805[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z34.next()), 238, (_2806: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z34.next()), 238, (_2806: [rs.u8, rs.u8]): rs.u8 => { return _2806[0] ^ _2806[1]; })); } } else if (_1931 === 2) { - const z35: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2787: rt.u8): rt.u8 => { - const x184: rt.u8 = _2787; - const _6167: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6167.value, x184 ^ 11); - rt.refMutRelease(_6167); + const z35: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2787: rs.u8): rs.u8 => { + const x184: rs.u8 = _2787; + const _6167: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6167.value, x184 ^ 11); + rs.refMutRelease(_6167); return x184; - }), (_2788: rt.u8): boolean => { + }), (_2788: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2789: rt.u8): rt.u8 => { - const x185: rt.u8 = _2789; - const _6168: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6168.value, x185 ^ 12); - rt.refMutRelease(_6168); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2789: rs.u8): rs.u8 => { + const x185: rs.u8 = _2789; + const _6168: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6168.value, x185 ^ 12); + rs.refMutRelease(_6168); return x185; })), n); - const _2048: rt.usize = rt.usizeRem(data.length, 8); + const _2048: rs.usize = rs.usizeRem(data.length, 8); if (_2048 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z35)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z35)) & 0xff); } else if (_2048 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z35)), 238, (_2798: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z35)), 238, (_2798: [rs.u8, rs.u8]): rs.u8 => { return _2798[0] ^ _2798[1]; })); } else if (_2048 === 2) { - const _2055: (a0: [rt.u8, rt.u8]) => undefined = (p23: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2047(p23)); + const _2055: (a0: [rs.u8, rs.u8]) => undefined = (p23: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2047(p23)); }; - rt.iterForEach(rt.iterBox(z35), _2055); + rs.iterForEach(rs.iterBox(z35), _2055); } else if (_2048 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z35), (_2797: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2797[0] as rt.u32, _2797[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z35), (_2797: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2797[0] as rs.u32, _2797[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2048 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z35), (_2796: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z35), (_2796: [rs.u8, rs.u8]): rs.u8 => { return _2796[0] ^ _2796[1]; }), "next")), undefined, true); } else if (_2048 === 5) { - const _2063: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc8: rt.u8, p22: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc8, 3) ^ _2047(p22); + const _2063: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc8: rs.u8, p22: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc8, 3) ^ _2047(p22); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z35), 0, _2063)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z35), 0, _2063)); } else if (_2048 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z35), (_2795: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z35), (_2795: [rs.u8, rs.u8]): rs.u8 => { return _2795[0] ^ _2795[1]; - }), (x192: rt.u8): boolean => { + }), (x192: rs.u8): boolean => { return x192 === 0; }) ? 1 : 0); } else { - const z36: rt.Iter<[rt.u8, rt.u8]> = z35; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z36), (_2790: [rt.u8, rt.u8]): boolean => { + const z36: rs.Iter<[rs.u8, rs.u8]> = z35; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z36), (_2790: [rs.u8, rs.u8]): boolean => { return _2790[0] > _2790[1]; - }), 238, (i10: rt.usize): rt.u8 => { + }), 238, (i10: rs.usize): rs.u8 => { return i10 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z36), (_2791: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2791[0], 3) === 0; - }), 238, (_2792: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z36), (_2791: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2791[0], 3) === 0; + }), 238, (_2792: [rs.u8, rs.u8]): rs.u8 => { return _2792[0] ^ _2792[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z36), n), 238, (_2793: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z36), n), 238, (_2793: [rs.u8, rs.u8]): rs.u8 => { return _2793[0] ^ _2793[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z36.next()), 238, (_2794: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z36.next()), 238, (_2794: [rs.u8, rs.u8]): rs.u8 => { return _2794[0] ^ _2794[1]; })); } } else if (_1931 === 3) { - const _2087: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2775: rt.u8): rt.u8 => { - const x172: rt.u8 = _2775; - const _6163: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6163.value, x172 ^ 11); - rt.refMutRelease(_6163); + const _2087: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2775: rs.u8): rs.u8 => { + const x172: rs.u8 = _2775; + const _6163: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6163.value, x172 ^ 11); + rs.refMutRelease(_6163); return x172; - }), (_2776: rt.u8): boolean => { + }), (_2776: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2777: rt.u8): rt.u8 => { - const x173: rt.u8 = _2777; - const _6164: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6164.value, x173 ^ 12); - rt.refMutRelease(_6164); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2777: rs.u8): rs.u8 => { + const x173: rs.u8 = _2777; + const _6164: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6164.value, x173 ^ 12); + rs.refMutRelease(_6164); return x173; })); - const _2099: rt.usize = rt.usizeRem(data.length, 8); + const _2099: rs.usize = rs.usizeRem(data.length, 8); if (_2099 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087)))) & 0xff); } else if (_2099 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087)))), 238, (_2786: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087)))), 238, (_2786: [rs.u8, rs.u8]): rs.u8 => { return _2786[0] ^ _2786[1]; })); } else if (_2099 === 2) { - const _2106: (a0: [rt.u8, rt.u8]) => undefined = (p21: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2098(p21)); + const _2106: (a0: [rs.u8, rs.u8]) => undefined = (p21: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2098(p21)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087))), _2106); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), _2106); } else if (_2099 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087))), (_2785: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2785[0] as rt.u32, _2785[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2785: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2785[0] as rs.u32, _2785[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2099 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087))), (_2784: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2784: [rs.u8, rs.u8]): rs.u8 => { return _2784[0] ^ _2784[1]; }), "next")), undefined, true); } else if (_2099 === 5) { - const _2114: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc7: rt.u8, p20: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc7, 3) ^ _2098(p20); + const _2114: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc7: rs.u8, p20: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc7, 3) ^ _2098(p20); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087))), 0, _2114)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), 0, _2114)); } else if (_2099 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2087))), (_2783: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2087))), (_2783: [rs.u8, rs.u8]): rs.u8 => { return _2783[0] ^ _2783[1]; - }), (x180: rt.u8): boolean => { + }), (x180: rs.u8): boolean => { return x180 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_2087), (_2778: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2087), (_2778: [rs.u8, rs.u8]): boolean => { return _2778[0] > _2778[1]; - }), 238, (i9: rt.usize): rt.u8 => { + }), 238, (i9: rs.usize): rs.u8 => { return i9 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_2087), (_2779: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2779[0], 3) === 0; - }), 238, (_2780: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2087), (_2779: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2779[0], 3) === 0; + }), 238, (_2780: [rs.u8, rs.u8]): rs.u8 => { return _2780[0] ^ _2780[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_2087), n), 238, (_2781: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2087), n), 238, (_2781: [rs.u8, rs.u8]): rs.u8 => { return _2781[0] ^ _2781[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_2087.next()), 238, (_2782: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2087.next()), 238, (_2782: [rs.u8, rs.u8]): rs.u8 => { return _2782[0] ^ _2782[1]; })); } } else { - const _2133: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2763: rt.u8): rt.u8 => { - const x160: rt.u8 = _2763; - const _6159: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6159.value, x160 ^ 11); - rt.refMutRelease(_6159); + const _2133: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2763: rs.u8): rs.u8 => { + const x160: rs.u8 = _2763; + const _6159: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6159.value, x160 ^ 11); + rs.refMutRelease(_6159); return x160; - }), (_2764: rt.u8): boolean => { + }), (_2764: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2765: rt.u8): rt.u8 => { - const x161: rt.u8 = _2765; - const _6160: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6160.value, x161 ^ 12); - rt.refMutRelease(_6160); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2765: rs.u8): rs.u8 => { + const x161: rs.u8 = _2765; + const _6160: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6160.value, x161 ^ 12); + rs.refMutRelease(_6160); return x161; })), n); - const _2146: rt.usize = rt.usizeRem(data.length, 8); + const _2146: rs.usize = rs.usizeRem(data.length, 8); if (_2146 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133)))) & 0xff); } else if (_2146 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133)))), 238, (_2774: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133)))), 238, (_2774: [rs.u8, rs.u8]): rs.u8 => { return _2774[0] ^ _2774[1]; })); } else if (_2146 === 2) { - const _2153: (a0: [rt.u8, rt.u8]) => undefined = (p19: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2145(p19)); + const _2153: (a0: [rs.u8, rs.u8]) => undefined = (p19: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2145(p19)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133))), _2153); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), _2153); } else if (_2146 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133))), (_2773: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2773[0] as rt.u32, _2773[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2773: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2773[0] as rs.u32, _2773[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2146 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133))), (_2772: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2772: [rs.u8, rs.u8]): rs.u8 => { return _2772[0] ^ _2772[1]; }), "next")), undefined, true); } else if (_2146 === 5) { - const _2161: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc6: rt.u8, p18: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc6, 3) ^ _2145(p18); + const _2161: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc6: rs.u8, p18: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc6, 3) ^ _2145(p18); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133))), 0, _2161)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), 0, _2161)); } else if (_2146 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2133))), (_2771: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2133))), (_2771: [rs.u8, rs.u8]): rs.u8 => { return _2771[0] ^ _2771[1]; - }), (x168: rt.u8): boolean => { + }), (x168: rs.u8): boolean => { return x168 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_2133), (_2766: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2133), (_2766: [rs.u8, rs.u8]): boolean => { return _2766[0] > _2766[1]; - }), 238, (i8: rt.usize): rt.u8 => { + }), 238, (i8: rs.usize): rs.u8 => { return i8 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_2133), (_2767: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2767[0], 3) === 0; - }), 238, (_2768: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2133), (_2767: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2767[0], 3) === 0; + }), 238, (_2768: [rs.u8, rs.u8]): rs.u8 => { return _2768[0] ^ _2768[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_2133), n), 238, (_2769: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2133), n), 238, (_2769: [rs.u8, rs.u8]): rs.u8 => { return _2769[0] ^ _2769[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_2133.next()), 238, (_2770: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2133.next()), 238, (_2770: [rs.u8, rs.u8]): rs.u8 => { return _2770[0] ^ _2770[1]; })); } } } else { - const _2179: rt.usize = rt.usizeRem(data.length, 8); + const _2179: rs.usize = rs.usizeRem(data.length, 8); if (_2179 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2758: rt.u8): rt.u8 => { - const x157: rt.u8 = _2758; - const _6157: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6157.value, x157 ^ 11); - rt.refMutRelease(_6157); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2758: rs.u8): rs.u8 => { + const x157: rs.u8 = _2758; + const _6157: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6157.value, x157 ^ 11); + rs.refMutRelease(_6157); return x157; - }), (_2760: rt.u8): boolean => { + }), (_2760: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2761: rt.u8): rt.u8 => { - const x158: rt.u8 = _2761; - const _6158: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6158.value, x158 ^ 12); - rt.refMutRelease(_6158); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2761: rs.u8): rs.u8 => { + const x158: rs.u8 = _2761; + const _6158: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6158.value, x158 ^ 12); + rs.refMutRelease(_6158); return x158; - })), (_2762: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2762[0], 2) === 0; + })), (_2762: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2762[0], 2) === 0; })) & 0xff); } else if (_2179 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2747: rt.u8): rt.u8 => { - const x154: rt.u8 = _2747; - const _6155: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6155.value, x154 ^ 11); - rt.refMutRelease(_6155); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2747: rs.u8): rs.u8 => { + const x154: rs.u8 = _2747; + const _6155: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6155.value, x154 ^ 11); + rs.refMutRelease(_6155); return x154; - }), (_2749: rt.u8): boolean => { + }), (_2749: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2750: rt.u8): rt.u8 => { - const x155: rt.u8 = _2750; - const _6156: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6156.value, x155 ^ 12); - rt.refMutRelease(_6156); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2750: rs.u8): rs.u8 => { + const x155: rs.u8 = _2750; + const _6156: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6156.value, x155 ^ 12); + rs.refMutRelease(_6156); return x155; - })), (_2755: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_2755[0], _2755[1]); + })), (_2755: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2755[0], _2755[1]); })) & 0xff); } else if (_2179 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2734: rt.u8): rt.u8 => { - const x151: rt.u8 = _2734; - const _6153: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6153.value, x151 ^ 11); - rt.refMutRelease(_6153); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2734: rs.u8): rs.u8 => { + const x151: rs.u8 = _2734; + const _6153: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6153.value, x151 ^ 11); + rs.refMutRelease(_6153); return x151; - }), (_2739: rt.u8): boolean => { + }), (_2739: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2744: rt.u8): rt.u8 => { - const x152: rt.u8 = _2744; - const _6154: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6154.value, x152 ^ 12); - rt.refMutRelease(_6154); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2744: rs.u8): rs.u8 => { + const x152: rs.u8 = _2744; + const _6154: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6154.value, x152 ^ 12); + rs.refMutRelease(_6154); return x152; - })), (_2745: [rt.u8, rt.u8]): boolean => { + })), (_2745: [rs.u8, rs.u8]): boolean => { return _2745[0] < 128; })) & 0xff); } else if (_2179 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2716: rt.u8): rt.u8 => { - const x149: rt.u8 = _2716; - const _6151: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6151.value, x149 ^ 11); - rt.refMutRelease(_6151); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2716: rs.u8): rs.u8 => { + const x149: rs.u8 = _2716; + const _6151: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6151.value, x149 ^ 11); + rs.refMutRelease(_6151); return x149; - }), (_2721: rt.u8): boolean => { + }), (_2721: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2726: rt.u8): rt.u8 => { - const x150: rt.u8 = _2726; - const _6152: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6152.value, x150 ^ 12); - rt.refMutRelease(_6152); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2726: rs.u8): rs.u8 => { + const x150: rs.u8 = _2726; + const _6152: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6152.value, x150 ^ 12); + rs.refMutRelease(_6152); return x150; - }))), (_2727: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }))), (_2727: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _2727[0] & 0xff; })), 238)); } else if (_2179 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2696: rt.u8): rt.u8 => { - const x147: rt.u8 = _2696; - const _6149: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6149.value, x147 ^ 11); - rt.refMutRelease(_6149); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2696: rs.u8): rs.u8 => { + const x147: rs.u8 = _2696; + const _6149: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6149.value, x147 ^ 11); + rs.refMutRelease(_6149); return x147; - }), (_2701: rt.u8): boolean => { + }), (_2701: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2706: rt.u8): rt.u8 => { - const x148: rt.u8 = _2706; - const _6150: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6150.value, x148 ^ 12); - rt.refMutRelease(_6150); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2706: rs.u8): rs.u8 => { + const x148: rs.u8 = _2706; + const _6150: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6150.value, x148 ^ 12); + rs.refMutRelease(_6150); return x148; - })), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + })), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_2179 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2674: rt.u8): rt.u8 => { - const x145: rt.u8 = _2674; - const _6147: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6147.value, x145 ^ 11); - rt.refMutRelease(_6147); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2674: rs.u8): rs.u8 => { + const x145: rs.u8 = _2674; + const _6147: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6147.value, x145 ^ 11); + rs.refMutRelease(_6147); return x145; - }), (_2679: rt.u8): boolean => { + }), (_2679: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2684: rt.u8): rt.u8 => { - const x146: rt.u8 = _2684; - const _6148: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6148.value, x146 ^ 12); - rt.refMutRelease(_6148); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2684: rs.u8): rs.u8 => { + const x146: rs.u8 = _2684; + const _6148: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6148.value, x146 ^ 12); + rs.refMutRelease(_6148); return x146; })), n)) & 0xff); } else if (_2179 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2654: rt.u8): rt.u8 => { - const x143: rt.u8 = _2654; - const _6145: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6145.value, x143 ^ 11); - rt.refMutRelease(_6145); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2654: rs.u8): rs.u8 => { + const x143: rs.u8 = _2654; + const _6145: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6145.value, x143 ^ 11); + rs.refMutRelease(_6145); return x143; - }), (_2659: rt.u8): boolean => { + }), (_2659: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2664: rt.u8): rt.u8 => { - const x144: rt.u8 = _2664; - const _6146: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6146.value, x144 ^ 12); - rt.refMutRelease(_6146); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2664: rs.u8): rs.u8 => { + const x144: rs.u8 = _2664; + const _6146: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6146.value, x144 ^ 12); + rs.refMutRelease(_6146); return x144; })), n)) & 0xff); } else { - const p6: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterZip(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2633: rt.u8): rt.u8 => { - const x141: rt.u8 = _2633; - const _6143: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6143.value, x141 ^ 11); - rt.refMutRelease(_6143); + const p6: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterZip(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2633: rs.u8): rs.u8 => { + const x141: rs.u8 = _2633; + const _6143: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6143.value, x141 ^ 11); + rs.refMutRelease(_6143); return x141; - }), (_2638: rt.u8): boolean => { + }), (_2638: rs.u8): boolean => { return true; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(b2)), (_2643: rt.u8): rt.u8 => { - const x142: rt.u8 = _2643; - const _6144: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6144.value, x142 ^ 12); - rt.refMutRelease(_6144); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(b2)), (_2643: rs.u8): rs.u8 => { + const x142: rs.u8 = _2643; + const _6144: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6144.value, x142 ^ 12); + rs.refMutRelease(_6144); return x142; }))); - rt.byteVecPush(out, (rt.peekablePeek(p6) !== undefined ? 1 : 0) ^ (rt.iterCount(p6) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p6) !== undefined ? 1 : 0) ^ (rs.iterCount(p6) & 0xff)); } } } else if ((kind & 16) === 0) { - const _2298: rt.usize = rt.usizeRem(rt.usizeDiv(data.length, 8), 5); + const _2298: rs.usize = rs.usizeRem(rs.usizeDiv(data.length, 8), 5); if (_2298 === 0) { - const z37: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2556: rt.u8): rt.u8 => { - const x127: rt.u8 = _2556; - const _6137: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6137.value, x127 ^ 13); - rt.refMutRelease(_6137); + const z37: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2556: rs.u8): rs.u8 => { + const x127: rs.u8 = _2556; + const _6137: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6137.value, x127 ^ 13); + rs.refMutRelease(_6137); return x127; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2564: rt.u8): rt.u8 => { - const x128: rt.u8 = _2564; - const _6138: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6138.value, x128 ^ 14); - rt.refMutRelease(_6138); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2564: rs.u8): rs.u8 => { + const x128: rs.u8 = _2564; + const _6138: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6138.value, x128 ^ 14); + rs.refMutRelease(_6138); return x128; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2567: rt.u8): rt.u8 => { - const x129: rt.u8 = _2567; - const _6139: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6139.value, x129 ^ 15); - rt.refMutRelease(_6139); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2567: rs.u8): rs.u8 => { + const x129: rs.u8 = _2567; + const _6139: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6139.value, x129 ^ 15); + rs.refMutRelease(_6139); return x129; - }), "len"), (_2569: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2569[0][0] ^ _2569[1], _2569[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2569: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2569[0][0] ^ _2569[1], _2569[0][1]] as [rs.u8, rs.u8]; }); - const _2321: rt.usize = rt.usizeRem(data.length, 8); + const _2321: rs.usize = rs.usizeRem(data.length, 8); if (_2321 === 0) { - rt.byteVecPush(out, rt.iterCount(z37) & 0xff); + rs.byteVecPush(out, rs.iterCount(z37) & 0xff); } else if (_2321 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(z37), 238, (_2623: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(z37), 238, (_2623: [rs.u8, rs.u8]): rs.u8 => { return _2623[0] ^ _2623[1]; })); } else if (_2321 === 2) { - rt.iterForEach(z37, (p17: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2320(p17)); + rs.iterForEach(z37, (p17: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2320(p17)); }); } else if (_2321 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(z37, (_2618: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2618[0] as rt.u32, _2618[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(z37, (_2618: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2618[0] as rs.u32, _2618[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2321 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(z37, (_2613: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(z37, (_2613: [rs.u8, rs.u8]): rs.u8 => { return _2613[0] ^ _2613[1]; }), undefined, true)), undefined, true); } else if (_2321 === 5) { - rt.byteVecPush(out, rt.iterFold(z37, 0, (acc5: rt.u8, p16: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc5, 3) ^ _2320(p16); + rs.byteVecPush(out, rs.iterFold(z37, 0, (acc5: rs.u8, p16: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc5, 3) ^ _2320(p16); })); } else if (_2321 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(z37, (_2603: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(z37, (_2603: [rs.u8, rs.u8]): rs.u8 => { return _2603[0] ^ _2603[1]; - }), (x137: rt.u8): boolean => { + }), (x137: rs.u8): boolean => { return x137 === 0; }) ? 1 : 0); } else { - const z38: rt.Iter<[rt.u8, rt.u8]> = z37; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(z38, (_2572: [rt.u8, rt.u8]): boolean => { + const z38: rs.Iter<[rs.u8, rs.u8]> = z37; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(z38, (_2572: [rs.u8, rs.u8]): boolean => { return _2572[0] > _2572[1]; - }), 238, (i6: rt.usize): rt.u8 => { + }), 238, (i6: rs.usize): rs.u8 => { return i6 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(z38, (_2575: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2575[0], 3) === 0; - }), 238, (_2578: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(z38, (_2575: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2575[0], 3) === 0; + }), 238, (_2578: [rs.u8, rs.u8]): rs.u8 => { return _2578[0] ^ _2578[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z38, n), 238, (_2593: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z38, n), 238, (_2593: [rs.u8, rs.u8]): rs.u8 => { return _2593[0] ^ _2593[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z38.next()), 238, (_2598: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z38.next()), 238, (_2598: [rs.u8, rs.u8]): rs.u8 => { return _2598[0] ^ _2598[1]; })); } } else if (_2298 === 1) { - const z39: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2487: rt.u8): rt.u8 => { - const x113: rt.u8 = _2487; - const _6131: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6131.value, x113 ^ 13); - rt.refMutRelease(_6131); + const z39: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2487: rs.u8): rs.u8 => { + const x113: rs.u8 = _2487; + const _6131: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6131.value, x113 ^ 13); + rs.refMutRelease(_6131); return x113; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2492: rt.u8): rt.u8 => { - const x114: rt.u8 = _2492; - const _6132: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6132.value, x114 ^ 14); - rt.refMutRelease(_6132); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2492: rs.u8): rs.u8 => { + const x114: rs.u8 = _2492; + const _6132: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6132.value, x114 ^ 14); + rs.refMutRelease(_6132); return x114; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2502: rt.u8): rt.u8 => { - const x115: rt.u8 = _2502; - const _6133: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6133.value, x115 ^ 15); - rt.refMutRelease(_6133); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2502: rs.u8): rs.u8 => { + const x115: rs.u8 = _2502; + const _6133: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6133.value, x115 ^ 15); + rs.refMutRelease(_6133); return x115; - }), "len"), (_2510: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2510[0][0] ^ _2510[1], _2510[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2510: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2510[0][0] ^ _2510[1], _2510[0][1]] as [rs.u8, rs.u8]; }); - const _2378: rt.usize = rt.usizeRem(data.length, 8); + const _2378: rs.usize = rs.usizeRem(data.length, 8); if (_2378 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z39)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z39)) & 0xff); } else if (_2378 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z39)), 238, (_2546: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z39)), 238, (_2546: [rs.u8, rs.u8]): rs.u8 => { return _2546[0] ^ _2546[1]; })); } else if (_2378 === 2) { - const _2385: (a0: [rt.u8, rt.u8]) => undefined = (p15: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2377(p15)); + const _2385: (a0: [rs.u8, rs.u8]) => undefined = (p15: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2377(p15)); }; - rt.iterForEach(rt.iterBox(z39), _2385); + rs.iterForEach(rs.iterBox(z39), _2385); } else if (_2378 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z39), (_2541: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2541[0] as rt.u32, _2541[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z39), (_2541: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2541[0] as rs.u32, _2541[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2378 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z39), (_2536: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z39), (_2536: [rs.u8, rs.u8]): rs.u8 => { return _2536[0] ^ _2536[1]; }), "next")), undefined, true); } else if (_2378 === 5) { - const _2393: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc4: rt.u8, p14: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc4, 3) ^ _2377(p14); + const _2393: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc4: rs.u8, p14: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc4, 3) ^ _2377(p14); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z39), 0, _2393)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z39), 0, _2393)); } else if (_2378 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z39), (_2527: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z39), (_2527: [rs.u8, rs.u8]): rs.u8 => { return _2527[0] ^ _2527[1]; - }), (x123: rt.u8): boolean => { + }), (x123: rs.u8): boolean => { return x123 === 0; }) ? 1 : 0); } else { - const z40: rt.Iter<[rt.u8, rt.u8]> = z39; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z40), (_2513: [rt.u8, rt.u8]): boolean => { + const z40: rs.Iter<[rs.u8, rs.u8]> = z39; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z40), (_2513: [rs.u8, rs.u8]): boolean => { return _2513[0] > _2513[1]; - }), 238, (i5: rt.usize): rt.u8 => { + }), 238, (i5: rs.usize): rs.u8 => { return i5 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z40), (_2515: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2515[0], 3) === 0; - }), 238, (_2518: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z40), (_2515: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2515[0], 3) === 0; + }), 238, (_2518: [rs.u8, rs.u8]): rs.u8 => { return _2518[0] ^ _2518[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z40), n), 238, (_2521: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z40), n), 238, (_2521: [rs.u8, rs.u8]): rs.u8 => { return _2521[0] ^ _2521[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z40.next()), 238, (_2524: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z40.next()), 238, (_2524: [rs.u8, rs.u8]): rs.u8 => { return _2524[0] ^ _2524[1]; })); } } else if (_2298 === 2) { - const z41: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2452: rt.u8): rt.u8 => { - const x99: rt.u8 = _2452; - const _6125: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6125.value, x99 ^ 13); - rt.refMutRelease(_6125); + const z41: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2452: rs.u8): rs.u8 => { + const x99: rs.u8 = _2452; + const _6125: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6125.value, x99 ^ 13); + rs.refMutRelease(_6125); return x99; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2455: rt.u8): rt.u8 => { - const x100: rt.u8 = _2455; - const _6126: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6126.value, x100 ^ 14); - rt.refMutRelease(_6126); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2455: rs.u8): rs.u8 => { + const x100: rs.u8 = _2455; + const _6126: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6126.value, x100 ^ 14); + rs.refMutRelease(_6126); return x100; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2457: rt.u8): rt.u8 => { - const x101: rt.u8 = _2457; - const _6127: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6127.value, x101 ^ 15); - rt.refMutRelease(_6127); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2457: rs.u8): rs.u8 => { + const x101: rs.u8 = _2457; + const _6127: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6127.value, x101 ^ 15); + rs.refMutRelease(_6127); return x101; - }), "len"), (_2458: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2458[0][0] ^ _2458[1], _2458[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2458: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2458[0][0] ^ _2458[1], _2458[0][1]] as [rs.u8, rs.u8]; }), n); - const _2436: rt.usize = rt.usizeRem(data.length, 8); + const _2436: rs.usize = rs.usizeRem(data.length, 8); if (_2436 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBox(z41)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBox(z41)) & 0xff); } else if (_2436 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBox(z41)), 238, (_2482: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBox(z41)), 238, (_2482: [rs.u8, rs.u8]): rs.u8 => { return _2482[0] ^ _2482[1]; })); } else if (_2436 === 2) { - const _2443: (a0: [rt.u8, rt.u8]) => undefined = (p13: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2435(p13)); + const _2443: (a0: [rs.u8, rs.u8]) => undefined = (p13: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2435(p13)); }; - rt.iterForEach(rt.iterBox(z41), _2443); + rs.iterForEach(rs.iterBox(z41), _2443); } else if (_2436 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBox(z41), (_2474: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2474[0] as rt.u32, _2474[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBox(z41), (_2474: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2474[0] as rs.u32, _2474[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2436 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBox(z41), (_2473: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBox(z41), (_2473: [rs.u8, rs.u8]): rs.u8 => { return _2473[0] ^ _2473[1]; }), "next")), undefined, true); } else if (_2436 === 5) { - const _2451: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc3: rt.u8, p12: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc3, 3) ^ _2435(p12); + const _2451: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc3: rs.u8, p12: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc3, 3) ^ _2435(p12); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBox(z41), 0, _2451)); + rs.byteVecPush(out, rs.iterFold(rs.iterBox(z41), 0, _2451)); } else if (_2436 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBox(z41), (_2470: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBox(z41), (_2470: [rs.u8, rs.u8]): rs.u8 => { return _2470[0] ^ _2470[1]; - }), (x109: rt.u8): boolean => { + }), (x109: rs.u8): boolean => { return x109 === 0; }) ? 1 : 0); } else { - const z42: rt.Iter<[rt.u8, rt.u8]> = z41; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(z42), (_2461: [rt.u8, rt.u8]): boolean => { + const z42: rs.Iter<[rs.u8, rs.u8]> = z41; + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(z42), (_2461: [rs.u8, rs.u8]): boolean => { return _2461[0] > _2461[1]; - }), 238, (i4: rt.usize): rt.u8 => { + }), 238, (i4: rs.usize): rs.u8 => { return i4 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(z42), (_2462: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2462[0], 3) === 0; - }), 238, (_2465: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(z42), (_2462: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2462[0], 3) === 0; + }), 238, (_2465: [rs.u8, rs.u8]): rs.u8 => { return _2465[0] ^ _2465[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(z42), n), 238, (_2466: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(z42), n), 238, (_2466: [rs.u8, rs.u8]): rs.u8 => { return _2466[0] ^ _2466[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z42.next()), 238, (_2469: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z42.next()), 238, (_2469: [rs.u8, rs.u8]): rs.u8 => { return _2469[0] ^ _2469[1]; })); } } else if (_2298 === 3) { - const _2475: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2400: rt.u8): rt.u8 => { - const x85: rt.u8 = _2400; - const _6119: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6119.value, x85 ^ 13); - rt.refMutRelease(_6119); + const _2475: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2400: rs.u8): rs.u8 => { + const x85: rs.u8 = _2400; + const _6119: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6119.value, x85 ^ 13); + rs.refMutRelease(_6119); return x85; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2403: rt.u8): rt.u8 => { - const x86: rt.u8 = _2403; - const _6120: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6120.value, x86 ^ 14); - rt.refMutRelease(_6120); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2403: rs.u8): rs.u8 => { + const x86: rs.u8 = _2403; + const _6120: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6120.value, x86 ^ 14); + rs.refMutRelease(_6120); return x86; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2404: rt.u8): rt.u8 => { - const x87: rt.u8 = _2404; - const _6121: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6121.value, x87 ^ 15); - rt.refMutRelease(_6121); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2404: rs.u8): rs.u8 => { + const x87: rs.u8 = _2404; + const _6121: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6121.value, x87 ^ 15); + rs.refMutRelease(_6121); return x87; - }), "len"), (_2407: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2407[0][0] ^ _2407[1], _2407[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2407: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2407[0][0] ^ _2407[1], _2407[0][1]] as [rs.u8, rs.u8]; }); - const _2494: rt.usize = rt.usizeRem(data.length, 8); + const _2494: rs.usize = rs.usizeRem(data.length, 8); if (_2494 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475)))) & 0xff); } else if (_2494 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475)))), 238, (_2444: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475)))), 238, (_2444: [rs.u8, rs.u8]): rs.u8 => { return _2444[0] ^ _2444[1]; })); } else if (_2494 === 2) { - const _2501: (a0: [rt.u8, rt.u8]) => undefined = (p11: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2493(p11)); + const _2501: (a0: [rs.u8, rs.u8]) => undefined = (p11: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2493(p11)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475))), _2501); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), _2501); } else if (_2494 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475))), (_2434: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2434[0] as rt.u32, _2434[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2434: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2434[0] as rs.u32, _2434[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2494 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475))), (_2429: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2429: [rs.u8, rs.u8]): rs.u8 => { return _2429[0] ^ _2429[1]; }), "next")), undefined, true); } else if (_2494 === 5) { - const _2509: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc2: rt.u8, p10: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc2, 3) ^ _2493(p10); + const _2509: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc2: rs.u8, p10: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc2, 3) ^ _2493(p10); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475))), 0, _2509)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), 0, _2509)); } else if (_2494 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2475))), (_2424: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2475))), (_2424: [rs.u8, rs.u8]): rs.u8 => { return _2424[0] ^ _2424[1]; - }), (x95: rt.u8): boolean => { + }), (x95: rs.u8): boolean => { return x95 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_2475), (_2408: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2475), (_2408: [rs.u8, rs.u8]): boolean => { return _2408[0] > _2408[1]; - }), 238, (i3: rt.usize): rt.u8 => { + }), 238, (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_2475), (_2411: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2411[0], 3) === 0; - }), 238, (_2412: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2475), (_2411: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2411[0], 3) === 0; + }), 238, (_2412: [rs.u8, rs.u8]): rs.u8 => { return _2412[0] ^ _2412[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_2475), n), 238, (_2415: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2475), n), 238, (_2415: [rs.u8, rs.u8]): rs.u8 => { return _2415[0] ^ _2415[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_2475.next()), 238, (_2416: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2475.next()), 238, (_2416: [rs.u8, rs.u8]): rs.u8 => { return _2416[0] ^ _2416[1]; })); } } else { - const _2528: rt.Iter<[rt.u8, rt.u8]> = rt.iterSkip(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2350: rt.u8): rt.u8 => { - const x71: rt.u8 = _2350; - const _6113: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6113.value, x71 ^ 13); - rt.refMutRelease(_6113); + const _2528: rs.Iter<[rs.u8, rs.u8]> = rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2350: rs.u8): rs.u8 => { + const x71: rs.u8 = _2350; + const _6113: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6113.value, x71 ^ 13); + rs.refMutRelease(_6113); return x71; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2351: rt.u8): rt.u8 => { - const x72: rt.u8 = _2351; - const _6114: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6114.value, x72 ^ 14); - rt.refMutRelease(_6114); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2351: rs.u8): rs.u8 => { + const x72: rs.u8 = _2351; + const _6114: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6114.value, x72 ^ 14); + rs.refMutRelease(_6114); return x72; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2354: rt.u8): rt.u8 => { - const x73: rt.u8 = _2354; - const _6115: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6115.value, x73 ^ 15); - rt.refMutRelease(_6115); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2354: rs.u8): rs.u8 => { + const x73: rs.u8 = _2354; + const _6115: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6115.value, x73 ^ 15); + rs.refMutRelease(_6115); return x73; - }), "len"), (_2355: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2355[0][0] ^ _2355[1], _2355[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2355: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2355[0][0] ^ _2355[1], _2355[0][1]] as [rs.u8, rs.u8]; }), n); - const _2548: rt.usize = rt.usizeRem(data.length, 8); + const _2548: rs.usize = rs.usizeRem(data.length, 8); if (_2548 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528)))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528)))) & 0xff); } else if (_2548 === 1) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterLast(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528)))), 238, (_2399: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterLast(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528)))), 238, (_2399: [rs.u8, rs.u8]): rs.u8 => { return _2399[0] ^ _2399[1]; })); } else if (_2548 === 2) { - const _2555: (a0: [rt.u8, rt.u8]) => undefined = (p9: [rt.u8, rt.u8]): undefined => { - rt.byteVecPush(out, _2547(p9)); + const _2555: (a0: [rs.u8, rs.u8]) => undefined = (p9: [rs.u8, rs.u8]): undefined => { + rs.byteVecPush(out, _2547(p9)); }; - rt.iterForEach(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528))), _2555); + rs.iterForEach(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), _2555); } else if (_2548 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterSum(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528))), (_2397: [rt.u8, rt.u8]): rt.u32 => { - return rt.u32Add(_2397[0] as rt.u32, _2397[1] as rt.u32); - }), rt.u32Add, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterSum(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2397: [rs.u8, rs.u8]): rs.u32 => { + return rs.u32Add(_2397[0] as rs.u32, _2397[1] as rs.u32); + }), rs.u32Add, 0)).reverse()), undefined, true); } else if (_2548 === 4) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528))), (_2394: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2394: [rs.u8, rs.u8]): rs.u8 => { return _2394[0] ^ _2394[1]; }), "next")), undefined, true); } else if (_2548 === 5) { - const _2563: (a0: rt.u8, a1: [rt.u8, rt.u8]) => rt.u8 = (acc: rt.u8, p8: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8WrappingMul(acc, 3) ^ _2547(p8); + const _2563: (a0: rs.u8, a1: [rs.u8, rs.u8]) => rs.u8 = (acc: rs.u8, p8: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8WrappingMul(acc, 3) ^ _2547(p8); }; - rt.byteVecPush(out, rt.iterFold(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528))), 0, _2563)); + rs.byteVecPush(out, rs.iterFold(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), 0, _2563)); } else if (_2548 === 6) { - rt.byteVecPush(out, rt.iterAny(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterBorrow(_2528))), (_2386: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterAny(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterBorrow(_2528))), (_2386: [rs.u8, rs.u8]): rs.u8 => { return _2386[0] ^ _2386[1]; - }), (x81: rt.u8): boolean => { + }), (x81: rs.u8): boolean => { return x81 === 0; }) ? 1 : 0); } else { - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(rt.iterBox(_2528), (_2358: [rt.u8, rt.u8]): boolean => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(rs.iterBox(_2528), (_2358: [rs.u8, rs.u8]): boolean => { return _2358[0] > _2358[1]; - }), 238, (i2: rt.usize): rt.u8 => { + }), 238, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterFind(rt.iterBox(_2528), (_2359: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2359[0], 3) === 0; - }), 238, (_2366: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterFind(rs.iterBox(_2528), (_2359: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2359[0], 3) === 0; + }), 238, (_2366: [rs.u8, rs.u8]): rs.u8 => { return _2366[0] ^ _2366[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(rt.iterBox(_2528), n), 238, (_2371: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(rs.iterBox(_2528), n), 238, (_2371: [rs.u8, rs.u8]): rs.u8 => { return _2371[0] ^ _2371[1]; })); - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(_2528.next()), 238, (_2376: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(_2528.next()), 238, (_2376: [rs.u8, rs.u8]): rs.u8 => { return _2376[0] ^ _2376[1]; })); } } } else { - const _2581: rt.usize = rt.usizeRem(data.length, 8); + const _2581: rs.usize = rs.usizeRem(data.length, 8); if (_2581 === 0) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2340: rt.u8): rt.u8 => { - const x66: rt.u8 = _2340; - const _6109: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6109.value, x66 ^ 13); - rt.refMutRelease(_6109); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2340: rs.u8): rs.u8 => { + const x66: rs.u8 = _2340; + const _6109: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6109.value, x66 ^ 13); + rs.refMutRelease(_6109); return x66; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2342: rt.u8): rt.u8 => { - const x67: rt.u8 = _2342; - const _6110: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6110.value, x67 ^ 14); - rt.refMutRelease(_6110); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2342: rs.u8): rs.u8 => { + const x67: rs.u8 = _2342; + const _6110: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6110.value, x67 ^ 14); + rs.refMutRelease(_6110); return x67; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2343: rt.u8): rt.u8 => { - const x68: rt.u8 = _2343; - const _6111: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6111.value, x68 ^ 15); - rt.refMutRelease(_6111); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2343: rs.u8): rs.u8 => { + const x68: rs.u8 = _2343; + const _6111: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6111.value, x68 ^ 15); + rs.refMutRelease(_6111); return x68; - }), "len"), (_2346: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2346[0][0] ^ _2346[1], _2346[0][1]] as [rt.u8, rt.u8]; - }), (_2347: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(_2347[0], 2) === 0; + }), "len"), (_2346: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2346[0][0] ^ _2346[1], _2346[0][1]] as [rs.u8, rs.u8]; + }), (_2347: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(_2347[0], 2) === 0; })) & 0xff); } else if (_2581 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2309: rt.u8): rt.u8 => { - const x61: rt.u8 = _2309; - const _6105: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6105.value, x61 ^ 13); - rt.refMutRelease(_6105); + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2309: rs.u8): rs.u8 => { + const x61: rs.u8 = _2309; + const _6105: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6105.value, x61 ^ 13); + rs.refMutRelease(_6105); return x61; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2314: rt.u8): rt.u8 => { - const x62: rt.u8 = _2314; - const _6106: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6106.value, x62 ^ 14); - rt.refMutRelease(_6106); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2314: rs.u8): rs.u8 => { + const x62: rs.u8 = _2314; + const _6106: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6106.value, x62 ^ 14); + rs.refMutRelease(_6106); return x62; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2319: rt.u8): rt.u8 => { - const x63: rt.u8 = _2319; - const _6107: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6107.value, x63 ^ 15); - rt.refMutRelease(_6107); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2319: rs.u8): rs.u8 => { + const x63: rs.u8 = _2319; + const _6107: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6107.value, x63 ^ 15); + rs.refMutRelease(_6107); return x63; - }), "len"), (_2329: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2329[0][0] ^ _2329[1], _2329[0][1]] as [rt.u8, rt.u8]; - }), (_2337: [rt.u8, rt.u8]): rt.u8 | undefined => { - return rt.u8CheckedSub(_2337[0], _2337[1]); + }), "len"), (_2329: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2329[0][0] ^ _2329[1], _2329[0][1]] as [rs.u8, rs.u8]; + }), (_2337: [rs.u8, rs.u8]): rs.u8 | undefined => { + return rs.u8CheckedSub(_2337[0], _2337[1]); })) & 0xff); } else if (_2581 === 2) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkipWhile(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2287: rt.u8): rt.u8 => { - const x56: rt.u8 = _2287; - const _6101: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6101.value, x56 ^ 13); - rt.refMutRelease(_6101); + rs.byteVecPush(out, rs.iterCount(rs.iterSkipWhile(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2287: rs.u8): rs.u8 => { + const x56: rs.u8 = _2287; + const _6101: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6101.value, x56 ^ 13); + rs.refMutRelease(_6101); return x56; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2289: rt.u8): rt.u8 => { - const x57: rt.u8 = _2289; - const _6102: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6102.value, x57 ^ 14); - rt.refMutRelease(_6102); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2289: rs.u8): rs.u8 => { + const x57: rs.u8 = _2289; + const _6102: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6102.value, x57 ^ 14); + rs.refMutRelease(_6102); return x57; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2291: rt.u8): rt.u8 => { - const x58: rt.u8 = _2291; - const _6103: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6103.value, x58 ^ 15); - rt.refMutRelease(_6103); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2291: rs.u8): rs.u8 => { + const x58: rs.u8 = _2291; + const _6103: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6103.value, x58 ^ 15); + rs.refMutRelease(_6103); return x58; - }), "len"), (_2292: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2292[0][0] ^ _2292[1], _2292[0][1]] as [rt.u8, rt.u8]; - }), (_2303: [rt.u8, rt.u8]): boolean => { + }), "len"), (_2292: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2292[0][0] ^ _2292[1], _2292[0][1]] as [rs.u8, rs.u8]; + }), (_2303: [rs.u8, rs.u8]): boolean => { return _2303[0] < 128; })) & 0xff); } else if (_2581 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.iterMap(rt.iterEnumerate(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2271: rt.u8): rt.u8 => { - const x52: rt.u8 = _2271; - const _682: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_682.value, x52 ^ 13); - rt.refMutRelease(_682); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.iterMap(rs.iterEnumerate(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2271: rs.u8): rs.u8 => { + const x52: rs.u8 = _2271; + const _682: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_682.value, x52 ^ 13); + rs.refMutRelease(_682); return x52; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2275: rt.u8): rt.u8 => { - const x53: rt.u8 = _2275; - const _692: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_692.value, x53 ^ 14); - rt.refMutRelease(_692); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2275: rs.u8): rs.u8 => { + const x53: rs.u8 = _2275; + const _692: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_692.value, x53 ^ 14); + rs.refMutRelease(_692); return x53; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2276: rt.u8): rt.u8 => { - const x54: rt.u8 = _2276; - const _697: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_697.value, x54 ^ 15); - rt.refMutRelease(_697); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2276: rs.u8): rs.u8 => { + const x54: rs.u8 = _2276; + const _697: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_697.value, x54 ^ 15); + rs.refMutRelease(_697); return x54; - }), "len"), (_2282: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2282[0][0] ^ _2282[1], _2282[0][1]] as [rt.u8, rt.u8]; - })), (_2286: [rt.usize, [rt.u8, rt.u8]]): rt.u8 => { + }), "len"), (_2282: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2282[0][0] ^ _2282[1], _2282[0][1]] as [rs.u8, rs.u8]; + })), (_2286: [rs.usize, [rs.u8, rs.u8]]): rs.u8 => { return _2286[0] & 0xff; })), 238)); } else if (_2581 === 4) { - rt.byteVecPush(out, rt.iterCount(rt.iterChain(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2243: rt.u8): rt.u8 => { - const x48: rt.u8 = _2243; - const _654: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_654.value, x48 ^ 13); - rt.refMutRelease(_654); + rs.byteVecPush(out, rs.iterCount(rs.iterChain(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2243: rs.u8): rs.u8 => { + const x48: rs.u8 = _2243; + const _654: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_654.value, x48 ^ 13); + rs.refMutRelease(_654); return x48; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2247: rt.u8): rt.u8 => { - const x49: rt.u8 = _2247; - const _663: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_663.value, x49 ^ 14); - rt.refMutRelease(_663); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2247: rs.u8): rs.u8 => { + const x49: rs.u8 = _2247; + const _663: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_663.value, x49 ^ 14); + rs.refMutRelease(_663); return x49; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2258: rt.u8): rt.u8 => { - const x50: rt.u8 = _2258; - const _668: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_668.value, x50 ^ 15); - rt.refMutRelease(_668); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2258: rs.u8): rs.u8 => { + const x50: rs.u8 = _2258; + const _668: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_668.value, x50 ^ 15); + rs.refMutRelease(_668); return x50; - }), "len"), (_2262: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2262[0][0] ^ _2262[1], _2262[0][1]] as [rt.u8, rt.u8]; - }), rt.iterSlice([[1, 2] as [rt.u8, rt.u8]]))) & 0xff); + }), "len"), (_2262: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2262[0][0] ^ _2262[1], _2262[0][1]] as [rs.u8, rs.u8]; + }), rs.iterSlice([[1, 2] as [rs.u8, rs.u8]]))) & 0xff); } else if (_2581 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2216: rt.u8): rt.u8 => { - const x44: rt.u8 = _2216; - const _629: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_629.value, x44 ^ 13); - rt.refMutRelease(_629); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2216: rs.u8): rs.u8 => { + const x44: rs.u8 = _2216; + const _629: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_629.value, x44 ^ 13); + rs.refMutRelease(_629); return x44; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2220: rt.u8): rt.u8 => { - const x45: rt.u8 = _2220; - const _632: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_632.value, x45 ^ 14); - rt.refMutRelease(_632); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2220: rs.u8): rs.u8 => { + const x45: rs.u8 = _2220; + const _632: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_632.value, x45 ^ 14); + rs.refMutRelease(_632); return x45; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2230: rt.u8): rt.u8 => { - const x46: rt.u8 = _2230; - const _635: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_635.value, x46 ^ 15); - rt.refMutRelease(_635); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2230: rs.u8): rs.u8 => { + const x46: rs.u8 = _2230; + const _635: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_635.value, x46 ^ 15); + rs.refMutRelease(_635); return x46; - }), "len"), (_2234: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2234[0][0] ^ _2234[1], _2234[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2234: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2234[0][0] ^ _2234[1], _2234[0][1]] as [rs.u8, rs.u8]; }), n)) & 0xff); } else if (_2581 === 6) { - rt.byteVecPush(out, rt.iterCount(rt.iterSkip(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2190: rt.u8): rt.u8 => { - const x40: rt.u8 = _2190; - const _613: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_613.value, x40 ^ 13); - rt.refMutRelease(_613); + rs.byteVecPush(out, rs.iterCount(rs.iterSkip(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2190: rs.u8): rs.u8 => { + const x40: rs.u8 = _2190; + const _613: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_613.value, x40 ^ 13); + rs.refMutRelease(_613); return x40; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2194: rt.u8): rt.u8 => { - const x41: rt.u8 = _2194; - const _621: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_621.value, x41 ^ 14); - rt.refMutRelease(_621); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2194: rs.u8): rs.u8 => { + const x41: rs.u8 = _2194; + const _621: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_621.value, x41 ^ 14); + rs.refMutRelease(_621); return x41; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2203: rt.u8): rt.u8 => { - const x42: rt.u8 = _2203; - const _624: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_624.value, x42 ^ 15); - rt.refMutRelease(_624); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2203: rs.u8): rs.u8 => { + const x42: rs.u8 = _2203; + const _624: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_624.value, x42 ^ 15); + rs.refMutRelease(_624); return x42; - }), "len"), (_2207: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2207[0][0] ^ _2207[1], _2207[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2207: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2207[0][0] ^ _2207[1], _2207[0][1]] as [rs.u8, rs.u8]; }), n)) & 0xff); } else { - const p7: rt.Peekable<[rt.u8, rt.u8]> = rt.iterPeekable(rt.iterMap(rt.iterZip(rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(a2)), (_2167: rt.u8): rt.u8 => { - const x36: rt.u8 = _2167; - const _62: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_62.value, x36 ^ 13); - rt.refMutRelease(_62); + const p7: rs.Peekable<[rs.u8, rs.u8]> = rs.iterPeekable(rs.iterMap(rs.iterZip(rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(a2)), (_2167: rs.u8): rs.u8 => { + const x36: rs.u8 = _2167; + const _62: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_62.value, x36 ^ 13); + rs.refMutRelease(_62); return x36; - }), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(b2))), (_2170: rt.u8): rt.u8 => { - const x37: rt.u8 = _2170; - const _65: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_65.value, x37 ^ 14); - rt.refMutRelease(_65); + }), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(b2))), (_2170: rs.u8): rs.u8 => { + const x37: rs.u8 = _2170; + const _65: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_65.value, x37 ^ 14); + rs.refMutRelease(_65); return x37; - }), "len"), rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(a2))), (_2173: rt.u8): rt.u8 => { - const x38: rt.u8 = _2173; - const _67: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_67.value, x38 ^ 15); - rt.refMutRelease(_67); + }), "len"), rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(a2))), (_2173: rs.u8): rs.u8 => { + const x38: rs.u8 = _2173; + const _67: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_67.value, x38 ^ 15); + rs.refMutRelease(_67); return x38; - }), "len"), (_2176: [[rt.u8, rt.u8], rt.u8]): [rt.u8, rt.u8] => { - return [_2176[0][0] ^ _2176[1], _2176[0][1]] as [rt.u8, rt.u8]; + }), "len"), (_2176: [[rs.u8, rs.u8], rs.u8]): [rs.u8, rs.u8] => { + return [_2176[0][0] ^ _2176[1], _2176[0][1]] as [rs.u8, rs.u8]; })); - rt.byteVecPush(out, (rt.peekablePeek(p7) !== undefined ? 1 : 0) ^ (rt.iterCount(p7) & 0xff)); + rs.byteVecPush(out, (rs.peekablePeek(p7) !== undefined ? 1 : 0) ^ (rs.iterCount(p7) & 0xff)); } } - const _2759: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_2759.value)); - rt.refRelease(_2759); + const _2759: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_2759.value)); + rs.refRelease(_2759); } /** @@ -5280,59 +5280,59 @@ export function zips(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * std trims the longer side on the first pair it reads from the back, and a by-index zip * reads no item it never yields from a side that does not log, nor through `nth` it skips. */ -export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteSlice) => rt.u8 = (c: rt.ByteSlice): rt.u8 => { +export function zipsBack(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteSlice) => rs.u8 = (c: rs.ByteSlice): rs.u8 => { return c.length & 0xff; }; - const _30: (a0: [rt.u8, rt.u8]) => rt.u8 = (_2: [rt.u8, rt.u8]): rt.u8 => { + const _30: (a0: [rs.u8, rs.u8]) => rs.u8 = (_2: [rs.u8, rs.u8]): rs.u8 => { return _2[0] ^ _2[1]; }; - const _79: (a0: [rt.u8, [rt.u8, rt.usize]]) => rt.u8 = (_23: [rt.u8, [rt.u8, rt.usize]]): rt.u8 => { + const _79: (a0: [rs.u8, [rs.u8, rs.usize]]) => rs.u8 = (_23: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { return _23[0] ^ _23[1][0] ^ (_23[1][1] & 0xff); }; - const _127: (a0: [rt.u8, rt.u8]) => rt.u8 = (_27: [rt.u8, rt.u8]): rt.u8 => { + const _127: (a0: [rs.u8, rs.u8]) => rs.u8 = (_27: [rs.u8, rs.u8]): rs.u8 => { return _27[0] ^ _27[1]; }; - const _176: (a0: [rt.u8, rt.u8]) => rt.u8 = (_210: [rt.u8, rt.u8]): rt.u8 => { + const _176: (a0: [rs.u8, rs.u8]) => rs.u8 = (_210: [rs.u8, rs.u8]): rs.u8 => { return _210[0] ^ _210[1]; }; - const split: rt.usize = rt.usizeRem(option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_211: rt.u8): rt.usize => { - return _211 as rt.usize; - }), rt.usizeAdd(data.length, 1)); + const split: rs.usize = rs.usizeRem(option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_211: rs.u8): rs.usize => { + return _211 as rs.usize; + }), rs.usizeAdd(data.length, 1)); if (split > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const n: rt.usize = kind >> 5 as rt.usize; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _21: rt.u8 = rt.u8Rem(kind, 8); + const n: rs.usize = kind >> 5 as rs.usize; + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _21: rs.u8 = rs.u8Rem(kind, 8); if (_21 === 0) { - const z: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start, split))), (_262: rt.u8): rt.u8 => { - const x25: rt.u8 = _262; - const _621: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_621.value, x25 ^ 1); - rt.refMutRelease(_621); + const z: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_262: rs.u8): rs.u8 => { + const x25: rs.u8 = _262; + const _621: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_621.value, x25 ^ 1); + rs.refMutRelease(_621); return x25; - }), rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split))), [true, false]); + }), rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), [true, false]); if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z.next()), 238, (_263: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z.next()), 238, (_263: [rs.u8, rs.u8]): rs.u8 => { return _263[0] ^ _263[1]; })); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z, n), 238, (_264: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z, n), 238, (_264: [rs.u8, rs.u8]): rs.u8 => { return _264[0] ^ _264[1]; })); } while (true) { - const _43: [rt.u8, rt.u8] | undefined = rt.iterToOption(z.nextBack()); + const _43: [rs.u8, rs.u8] | undefined = rs.iterToOption(z.nextBack()); if (_43 !== undefined) { - rt.byteVecPush(out, _30(_43)); - const _53: [rt.usize, rt.usize | undefined] = z.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_53[0] & 0xff, option_mapOr$02k4ito(_53[1], 238, (u8: rt.usize): rt.u8 => { + rs.byteVecPush(out, _30(_43)); + const _53: [rs.usize, rs.usize | undefined] = z.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_53[0] & 0xff, option_mapOr$188iunt(_53[1], 238, (u8: rs.usize): rs.u8 => { return u8 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z.next()), 238, (_268: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z.next()), 238, (_268: [rs.u8, rs.u8]): rs.u8 => { return _268[0] ^ _268[1]; })); } @@ -5340,37 +5340,37 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void break; } } - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z.next()), 238, (_271: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z.next()), 238, (_271: [rs.u8, rs.u8]): rs.u8 => { return _271[0] ^ _271[1]; })); } else if (_21 === 1) { - const z2: rt.Iter<[rt.u8, [rt.u8, rt.usize]]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start, split))), rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split))), (_248: rt.u8): rt.u8 => { - const x20: rt.u8 = _248; - const _616: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_616.value, x20 ^ 2); - rt.refMutRelease(_616); + const z2: rs.Iter<[rs.u8, [rs.u8, rs.usize]]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_248: rs.u8): rs.u8 => { + const x20: rs.u8 = _248; + const _616: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_616.value, x20 ^ 2); + rs.refMutRelease(_616); return x20; - }), new rt.Range(0, data.length), [true, false]), [false, true]); + }), new rs.Range(0, data.length), [true, false]), [false, true]); if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$1h04da8(rt.iterToOption(z2.next()), 238, (_254: [rt.u8, [rt.u8, rt.usize]]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_254: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { return _254[0] ^ _254[1][0] ^ (_254[1][1] & 0xff); })); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$1h04da8(rt.iterNth(z2, n), 238, (_257: [rt.u8, [rt.u8, rt.usize]]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterNth(z2, n), 238, (_257: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { return _257[0] ^ _257[1][0] ^ (_257[1][1] & 0xff); })); } while (true) { - const _92: [rt.u8, [rt.u8, rt.usize]] | undefined = rt.iterToOption(z2.nextBack()); + const _92: [rs.u8, [rs.u8, rs.usize]] | undefined = rs.iterToOption(z2.nextBack()); if (_92 !== undefined) { - rt.byteVecPush(out, _79(_92)); - const _102: [rt.usize, rt.usize | undefined] = z2.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_102[0] & 0xff, option_mapOr$02k4ito(_102[1], 238, (u7: rt.usize): rt.u8 => { + rs.byteVecPush(out, _79(_92)); + const _102: [rs.usize, rs.usize | undefined] = z2.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_102[0] & 0xff, option_mapOr$188iunt(_102[1], 238, (u7: rs.usize): rs.u8 => { return u7 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$1h04da8(rt.iterToOption(z2.next()), 238, (_258: [rt.u8, [rt.u8, rt.usize]]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_258: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { return _258[0] ^ _258[1][0] ^ (_258[1][1] & 0xff); })); } @@ -5378,43 +5378,43 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void break; } } - rt.byteVecPush(out, option_mapOr$1h04da8(rt.iterToOption(z2.next()), 238, (_261: [rt.u8, [rt.u8, rt.usize]]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1r07vli(rs.iterToOption(z2.next()), 238, (_261: [rs.u8, [rs.u8, rs.usize]]): rs.u8 => { return _261[0] ^ _261[1][0] ^ (_261[1][1] & 0xff); })); } else if (_21 === 2) { - const z3: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start, split))), (_239: rt.u8): rt.u8 => { - const x14: rt.u8 = _239; - const _614: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_614.value, x14 ^ 3); - rt.refMutRelease(_614); + const z3: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split))), (_239: rs.u8): rs.u8 => { + const x14: rs.u8 = _239; + const _614: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_614.value, x14 ^ 3); + rs.refMutRelease(_614); return x14; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split))), (_240: rt.u8): rt.u8 => { - const x15: rt.u8 = _240; - const _615: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_615.value, x15 ^ 4); - rt.refMutRelease(_615); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_240: rs.u8): rs.u8 => { + const x15: rs.u8 = _240; + const _615: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_615.value, x15 ^ 4); + rs.refMutRelease(_615); return x15; }), [true, true]); if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z3.next()), 238, (_242: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_242: [rs.u8, rs.u8]): rs.u8 => { return _242[0] ^ _242[1]; })); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z3, n), 238, (_244: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z3, n), 238, (_244: [rs.u8, rs.u8]): rs.u8 => { return _244[0] ^ _244[1]; })); } while (true) { - const _140: [rt.u8, rt.u8] | undefined = rt.iterToOption(z3.nextBack()); + const _140: [rs.u8, rs.u8] | undefined = rs.iterToOption(z3.nextBack()); if (_140 !== undefined) { - rt.byteVecPush(out, _127(_140)); - const _150: [rt.usize, rt.usize | undefined] = z3.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_150[0] & 0xff, option_mapOr$02k4ito(_150[1], 238, (u6: rt.usize): rt.u8 => { + rs.byteVecPush(out, _127(_140)); + const _150: [rs.usize, rs.usize | undefined] = z3.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_150[0] & 0xff, option_mapOr$188iunt(_150[1], 238, (u6: rs.usize): rs.u8 => { return u6 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z3.next()), 238, (_245: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_245: [rs.u8, rs.u8]): rs.u8 => { return _245[0] ^ _245[1]; })); } @@ -5422,43 +5422,43 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void break; } } - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z3.next()), 238, (_247: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z3.next()), 238, (_247: [rs.u8, rs.u8]): rs.u8 => { return _247[0] ^ _247[1]; })); } else if (_21 === 3) { - const z4: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start, split)))), (_226: rt.u8): rt.u8 => { - const x8: rt.u8 = _226; - const _612: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_612.value, x8 ^ 5); - rt.refMutRelease(_612); + const z4: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split)))), (_226: rs.u8): rs.u8 => { + const x8: rs.u8 = _226; + const _612: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_612.value, x8 ^ 5); + rs.refMutRelease(_612); return x8; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split))), (_229: rt.u8): rt.u8 => { - const x9: rt.u8 = _229; - const _613: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_613.value, x9 ^ 6); - rt.refMutRelease(_613); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), (_229: rs.u8): rs.u8 => { + const x9: rs.u8 = _229; + const _613: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_613.value, x9 ^ 6); + rs.refMutRelease(_613); return x9; }), "len"); if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z4.next()), 238, (_232: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_232: [rs.u8, rs.u8]): rs.u8 => { return _232[0] ^ _232[1]; })); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterNth(z4, n), 238, (_235: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterNth(z4, n), 238, (_235: [rs.u8, rs.u8]): rs.u8 => { return _235[0] ^ _235[1]; })); } while (true) { - const _189: [rt.u8, rt.u8] | undefined = rt.iterToOption(z4.nextBack()); + const _189: [rs.u8, rs.u8] | undefined = rs.iterToOption(z4.nextBack()); if (_189 !== undefined) { - rt.byteVecPush(out, _176(_189)); - const _199: [rt.usize, rt.usize | undefined] = z4.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_199[0] & 0xff, option_mapOr$02k4ito(_199[1], 238, (u5: rt.usize): rt.u8 => { + rs.byteVecPush(out, _176(_189)); + const _199: [rs.usize, rs.usize | undefined] = z4.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_199[0] & 0xff, option_mapOr$188iunt(_199[1], 238, (u5: rs.usize): rs.u8 => { return u5 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z4.next()), 238, (_237: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_237: [rs.u8, rs.u8]): rs.u8 => { return _237[0] ^ _237[1]; })); } @@ -5466,142 +5466,142 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void break; } } - rt.byteVecPush(out, option_mapOr$0mmpeqx(rt.iterToOption(z4.next()), 238, (_238: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1h9hu6n(rs.iterToOption(z4.next()), 238, (_238: [rs.u8, rs.u8]): rs.u8 => { return _238[0] ^ _238[1]; })); } else if (_21 === 4) { - const at: (a0: [rt.usize, [rt.u8, rt.ByteSlice]]) => rt.u8 = (_223: [rt.usize, [rt.u8, rt.ByteSlice]]): rt.u8 => { + const at: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8 = (_223: [rs.usize, [rs.u8, rs.ByteSlice]]): rs.u8 => { return (_223[0] & 0xff) ^ _223[1][0] ^ _20(_223[1][1]); }; - const z5: rt.Iter<[rt.usize, [rt.u8, rt.ByteSlice]]> = rt.iterZip(new rt.Range(0, split), rt.iterZip(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split))), rt.byteSliceChunks(data, 2), [false, false]), [false, false]); - const at2: (a0: [rt.usize, [rt.u8, rt.ByteSlice]]) => rt.u8 = at; + const z5: rs.Iter<[rs.usize, [rs.u8, rs.ByteSlice]]> = rs.iterZip(new rs.Range(0, split), rs.iterZip(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split))), rs.byteSliceChunks(data, 2), [false, false]), [false, false]); + const at2: (a0: [rs.usize, [rs.u8, rs.ByteSlice]]) => rs.u8 = at; if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$1dmz9kd(rt.iterToOption(z5.next()), 238, at2)); + rs.byteVecPush(out, option_mapOr$17ts8jj(rs.iterToOption(z5.next()), 238, at2)); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$1dmz9kd(rt.iterNth(z5, n), 238, at2)); + rs.byteVecPush(out, option_mapOr$17ts8jj(rs.iterNth(z5, n), 238, at2)); } while (true) { - const _236: [rt.usize, [rt.u8, rt.ByteSlice]] | undefined = rt.iterToOption(z5.nextBack()); + const _236: [rs.usize, [rs.u8, rs.ByteSlice]] | undefined = rs.iterToOption(z5.nextBack()); if (_236 !== undefined) { - rt.byteVecPush(out, at2(_236)); - const _246: [rt.usize, rt.usize | undefined] = z5.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_246[0] & 0xff, option_mapOr$02k4ito(_246[1], 238, (u4: rt.usize): rt.u8 => { + rs.byteVecPush(out, at2(_236)); + const _246: [rs.usize, rs.usize | undefined] = z5.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_246[0] & 0xff, option_mapOr$188iunt(_246[1], 238, (u4: rs.usize): rs.u8 => { return u4 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$1dmz9kd(rt.iterToOption(z5.next()), 238, at2)); + rs.byteVecPush(out, option_mapOr$17ts8jj(rs.iterToOption(z5.next()), 238, at2)); } } else { break; } } - rt.byteVecPush(out, option_mapOr$1dmz9kd(rt.iterToOption(z5.next()), 238, at2)); + rs.byteVecPush(out, option_mapOr$17ts8jj(rs.iterToOption(z5.next()), 238, at2)); } else if (_21 === 5) { - const at3: (a0: [rt.ByteSlice, [rt.usize, rt.u8]]) => rt.u8 = (_217: [rt.ByteSlice, [rt.usize, rt.u8]]): rt.u8 => { - const i4: rt.usize = _217[1][0]; - const y5: rt.u8 = _217[1][1]; + const at3: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8 = (_217: [rs.ByteSlice, [rs.usize, rs.u8]]): rs.u8 => { + const i4: rs.usize = _217[1][0]; + const y5: rs.u8 = _217[1][1]; return _20(_217[0]) ^ (i4 & 0xff) ^ y5; }; - const z6: rt.Iter<[rt.ByteSlice, [rt.usize, rt.u8]]> = rt.iterZip(rt.byteSliceChunks(new rt.ByteSlice(data.data, data.start, split), 2), rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start + split, data.length - split)))), [false, false]); - const at4: (a0: [rt.ByteSlice, [rt.usize, rt.u8]]) => rt.u8 = at3; + const z6: rs.Iter<[rs.ByteSlice, [rs.usize, rs.u8]]> = rs.iterZip(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start, split), 2), rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start + split, data.length - split)))), [false, false]); + const at4: (a0: [rs.ByteSlice, [rs.usize, rs.u8]]) => rs.u8 = at3; if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$0a96v80(rt.iterToOption(z6.next()), 238, at4)); + rs.byteVecPush(out, option_mapOr$0llggqq(rs.iterToOption(z6.next()), 238, at4)); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$0a96v80(rt.iterNth(z6, n), 238, at4)); + rs.byteVecPush(out, option_mapOr$0llggqq(rs.iterNth(z6, n), 238, at4)); } while (true) { - const _281: [rt.ByteSlice, [rt.usize, rt.u8]] | undefined = rt.iterToOption(z6.nextBack()); + const _281: [rs.ByteSlice, [rs.usize, rs.u8]] | undefined = rs.iterToOption(z6.nextBack()); if (_281 !== undefined) { - rt.byteVecPush(out, at4(_281)); - const _291: [rt.usize, rt.usize | undefined] = z6.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_291[0] & 0xff, option_mapOr$02k4ito(_291[1], 238, (u3: rt.usize): rt.u8 => { + rs.byteVecPush(out, at4(_281)); + const _291: [rs.usize, rs.usize | undefined] = z6.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_291[0] & 0xff, option_mapOr$188iunt(_291[1], 238, (u3: rs.usize): rs.u8 => { return u3 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$0a96v80(rt.iterToOption(z6.next()), 238, at4)); + rs.byteVecPush(out, option_mapOr$0llggqq(rs.iterToOption(z6.next()), 238, at4)); } } else { break; } } - rt.byteVecPush(out, option_mapOr$0a96v80(rt.iterToOption(z6.next()), 238, at4)); + rs.byteVecPush(out, option_mapOr$0llggqq(rs.iterToOption(z6.next()), 238, at4)); } else if (_21 === 6) { - const logged: (a0: rt.ByteSlice) => rt.ByteSlice = (c2: rt.ByteSlice): rt.ByteSlice => { - const _68: rt.RefCell = rt.refCellBorrowMut(log); - const _712: rt.u8 = _20(c2); - rt.byteVecPush(_68.value, _712); - rt.refMutRelease(_68); + const logged: (a0: rs.ByteSlice) => rs.ByteSlice = (c2: rs.ByteSlice): rs.ByteSlice => { + const _68: rs.RefCell = rs.refCellBorrowMut(log); + const _712: rs.u8 = _20(c2); + rs.byteVecPush(_68.value, _712); + rs.refMutRelease(_68); return c2; }; - const at5: (a0: [rt.u8, rt.ByteSlice]) => rt.u8 = (_216: [rt.u8, rt.ByteSlice]): rt.u8 => { + const at5: (a0: [rs.u8, rs.ByteSlice]) => rs.u8 = (_216: [rs.u8, rs.ByteSlice]): rs.u8 => { return _216[0] ^ _20(_216[1]); }; - const z7: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterZip(new rt.Range(split & 0xff, data.length & 0xff), rt.iterMap(rt.byteSliceChunks(new rt.ByteSlice(data.data, data.start, split), 3), logged), [false, true]); - const at6: (a0: [rt.u8, rt.ByteSlice]) => rt.u8 = at5; + const z7: rs.Iter<[rs.u8, rs.ByteSlice]> = rs.iterZip(new rs.Range(split & 0xff, data.length & 0xff), rs.iterMap(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start, split), 3), logged), [false, true]); + const at6: (a0: [rs.u8, rs.ByteSlice]) => rs.u8 = at5; if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$1vjqo89(rt.iterToOption(z7.next()), 238, at6)); + rs.byteVecPush(out, option_mapOr$1ifh11y(rs.iterToOption(z7.next()), 238, at6)); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$1vjqo89(rt.iterNth(z7, n), 238, at6)); + rs.byteVecPush(out, option_mapOr$1ifh11y(rs.iterNth(z7, n), 238, at6)); } while (true) { - const _332: [rt.u8, rt.ByteSlice] | undefined = rt.iterToOption(z7.nextBack()); + const _332: [rs.u8, rs.ByteSlice] | undefined = rs.iterToOption(z7.nextBack()); if (_332 !== undefined) { - rt.byteVecPush(out, at6(_332)); - const _342: [rt.usize, rt.usize | undefined] = z7.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_342[0] & 0xff, option_mapOr$02k4ito(_342[1], 238, (u2: rt.usize): rt.u8 => { + rs.byteVecPush(out, at6(_332)); + const _342: [rs.usize, rs.usize | undefined] = z7.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_342[0] & 0xff, option_mapOr$188iunt(_342[1], 238, (u2: rs.usize): rs.u8 => { return u2 & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$1vjqo89(rt.iterToOption(z7.next()), 238, at6)); + rs.byteVecPush(out, option_mapOr$1ifh11y(rs.iterToOption(z7.next()), 238, at6)); } } else { break; } } - rt.byteVecPush(out, option_mapOr$1vjqo89(rt.iterToOption(z7.next()), 238, at6)); + rs.byteVecPush(out, option_mapOr$1ifh11y(rs.iterToOption(z7.next()), 238, at6)); } else { - const logged2: (a0: [rt.usize, rt.u8]) => rt.u8 = (_214: [rt.usize, rt.u8]): rt.u8 => { - const i2: rt.usize = _214[0]; - const x5: rt.u8 = _214[1]; - const _710: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_710.value, i2 & 0xff); - rt.refMutRelease(_710); + const logged2: (a0: [rs.usize, rs.u8]) => rs.u8 = (_214: [rs.usize, rs.u8]): rs.u8 => { + const i2: rs.usize = _214[0]; + const x5: rs.u8 = _214[1]; + const _710: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_710.value, i2 & 0xff); + rs.refMutRelease(_710); return x5; }; - const at7: (a0: [rt.u8, [rt.usize, rt.ByteSlice]]) => rt.u8 = (_215: [rt.u8, [rt.usize, rt.ByteSlice]]): rt.u8 => { + const at7: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8 = (_215: [rs.u8, [rs.usize, rs.ByteSlice]]): rs.u8 => { return _215[0] ^ (_215[1][0] & 0xff) ^ _20(_215[1][1]); }; - const z8: rt.Iter<[rt.u8, [rt.usize, rt.ByteSlice]]> = rt.iterZip(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(data.data, data.start, split)))), logged2), rt.iterEnumerate(rt.byteSliceChunks(new rt.ByteSlice(data.data, data.start + split, data.length - split), 2)), [true, false]); - const at8: (a0: [rt.u8, [rt.usize, rt.ByteSlice]]) => rt.u8 = at7; + const z8: rs.Iter<[rs.u8, [rs.usize, rs.ByteSlice]]> = rs.iterZip(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(data.data, data.start, split)))), logged2), rs.iterEnumerate(rs.byteSliceChunks(new rs.ByteSlice(data.data, data.start + split, data.length - split), 2)), [true, false]); + const at8: (a0: [rs.u8, [rs.usize, rs.ByteSlice]]) => rs.u8 = at7; if ((kind & 8) !== 0) { - rt.byteVecPush(out, option_mapOr$0f73bb7(rt.iterToOption(z8.next()), 238, at8)); + rs.byteVecPush(out, option_mapOr$0olig48(rs.iterToOption(z8.next()), 238, at8)); } if ((kind & 16) !== 0) { - rt.byteVecPush(out, option_mapOr$0f73bb7(rt.iterNth(z8, n), 238, at8)); + rs.byteVecPush(out, option_mapOr$0olig48(rs.iterNth(z8, n), 238, at8)); } while (true) { - const _381: [rt.u8, [rt.usize, rt.ByteSlice]] | undefined = rt.iterToOption(z8.nextBack()); + const _381: [rs.u8, [rs.usize, rs.ByteSlice]] | undefined = rs.iterToOption(z8.nextBack()); if (_381 !== undefined) { - rt.byteVecPush(out, at8(_381)); - const _391: [rt.usize, rt.usize | undefined] = z8.sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_391[0] & 0xff, option_mapOr$02k4ito(_391[1], 238, (u: rt.usize): rt.u8 => { + rs.byteVecPush(out, at8(_381)); + const _391: [rs.usize, rs.usize | undefined] = z8.sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_391[0] & 0xff, option_mapOr$188iunt(_391[1], 238, (u: rs.usize): rs.u8 => { return u & 0xff; }))), undefined, true); if ((kind & 24) === 24) { - rt.byteVecPush(out, option_mapOr$0f73bb7(rt.iterToOption(z8.next()), 238, at8)); + rs.byteVecPush(out, option_mapOr$0olig48(rs.iterToOption(z8.next()), 238, at8)); } } else { break; } } - rt.byteVecPush(out, option_mapOr$0f73bb7(rt.iterToOption(z8.next()), 238, at8)); + rs.byteVecPush(out, option_mapOr$0olig48(rs.iterToOption(z8.next()), 238, at8)); } - const _411: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_411.value)); - rt.refRelease(_411); + const _411: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_411.value)); + rs.refRelease(_411); } /** @@ -5609,67 +5609,67 @@ export function zipsBack(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * takes and as its own, stepping up to its type's last value, past which std's debug * build panics, and ranges of `char` across the surrogates, which they skip. */ -export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const near: rt.u8 = rt.u8Rem(a, 4); - const how: rt.u8 = kind >> 6; - const _12: rt.u8 = rt.u8Rem(kind, 16); +export function rangeFroms(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const near: rs.u8 = rs.u8Rem(a, 4); + const how: rs.u8 = kind >> 6; + const _12: rs.u8 = rs.u8Rem(kind, 16); if (_12 === 0) { - fromTop$u8_iters_range_froms_closure0(rt.u8Sub(255, near), data, how, out, (x14: rt.u8, out15: rt.ByteVec): undefined => { - rt.byteVecPush(out15, x14); + fromTop$u8_iters_range_froms_closure0(rs.u8Sub(255, near), data, how, out, (x14: rs.u8, out15: rs.ByteVec): undefined => { + rs.byteVecPush(out15, x14); }); } else if (_12 === 1) { - fromTop$u16_iters_range_froms_closure1(rt.u16Sub(65535, near as rt.u16), data, how, out, (x13: rt.u16, out14: rt.ByteVec): undefined => { - rt.iterExtendBytes(out14, rt.iterSlice(rt.u16ToBeBytes(x13).reverse()), undefined, true); + fromTop$u16_iters_range_froms_closure1(rs.u16Sub(65535, near as rs.u16), data, how, out, (x13: rs.u16, out14: rs.ByteVec): undefined => { + rs.iterExtendBytes(out14, rs.iterSlice(rs.u16ToBeBytes(x13).reverse()), undefined, true); }); } else if (_12 === 2) { - fromTop$u32_iters_range_froms_closure2(rt.u32Sub(4294967295, near as rt.u32), data, how, out, (x12: rt.u32, out13: rt.ByteVec): undefined => { - rt.iterExtendBytes(out13, rt.iterSlice(rt.u32ToBeBytes(x12).reverse()), undefined, true); + fromTop$u32_iters_range_froms_closure2(rs.u32Sub(4294967295, near as rs.u32), data, how, out, (x12: rs.u32, out13: rs.ByteVec): undefined => { + rs.iterExtendBytes(out13, rs.iterSlice(rs.u32ToBeBytes(x12).reverse()), undefined, true); }); } else if (_12 === 3) { - fromTop$u64_iters_range_froms_closure3(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, near as rt.u64), data, how, out, (x11: rt.u64, out12: rt.ByteVec): undefined => { - rt.iterExtendBytes(out12, rt.iterSlice(rt.u64ToBeBytes(x11).reverse()), undefined, true); + fromTop$u64_iters_range_froms_closure3(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, near as rs.u64), data, how, out, (x11: rs.u64, out12: rs.ByteVec): undefined => { + rs.iterExtendBytes(out12, rs.iterSlice(rs.u64ToBeBytes(x11).reverse()), undefined, true); }); } else if (_12 === 4) { - fromTop$u128_iters_range_froms_closure4(rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, near as rt.u128), data, how, out, (x10: rt.u128, out11: rt.ByteVec): undefined => { - rt.iterExtendBytes(out11, rt.iterSlice(rt.u128ToBeBytes(x10).reverse()), undefined, true); + fromTop$u128_iters_range_froms_closure4(rs.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, near as rs.u128), data, how, out, (x10: rs.u128, out11: rs.ByteVec): undefined => { + rs.iterExtendBytes(out11, rs.iterSlice(rs.u128ToBeBytes(x10).reverse()), undefined, true); }); } else if (_12 === 5) { - fromTop$usize_iters_range_froms_closure5(rt.usizeSub(4294967295, near as rt.usize), data, how, out, (x9: rt.usize, out10: rt.ByteVec): undefined => { - rt.iterExtendBytes(out10, rt.iterSlice(rt.usizeToBeBytes(x9).reverse()), undefined, true); + fromTop$usize_iters_range_froms_closure5(rs.usizeSub(4294967295, near as rs.usize), data, how, out, (x9: rs.usize, out10: rs.ByteVec): undefined => { + rs.iterExtendBytes(out10, rs.iterSlice(rs.usizeToBeBytes(x9).reverse()), undefined, true); }); } else if (_12 === 6) { - fromTop$i8_iters_range_froms_closure6(rt.i8Sub(127, (near << 24) >> 24), data, how, out, (x8: rt.i8, out9: rt.ByteVec): undefined => { - rt.iterExtendBytes(out9, rt.iterSlice(rt.i8ToBeBytes(x8).reverse()), undefined, true); + fromTop$i8_iters_range_froms_closure6(rs.i8Sub(127, (near << 24) >> 24), data, how, out, (x8: rs.i8, out9: rs.ByteVec): undefined => { + rs.iterExtendBytes(out9, rs.iterSlice(rs.i8ToBeBytes(x8).reverse()), undefined, true); }); } else if (_12 === 7) { - fromTop$i16_iters_range_froms_closure7(rt.i16Sub(32767, near as rt.i16), data, how, out, (x7: rt.i16, out8: rt.ByteVec): undefined => { - rt.iterExtendBytes(out8, rt.iterSlice(rt.i16ToBeBytes(x7).reverse()), undefined, true); + fromTop$i16_iters_range_froms_closure7(rs.i16Sub(32767, near as rs.i16), data, how, out, (x7: rs.i16, out8: rs.ByteVec): undefined => { + rs.iterExtendBytes(out8, rs.iterSlice(rs.i16ToBeBytes(x7).reverse()), undefined, true); }); } else if (_12 === 8) { - fromTop$i32_iters_range_froms_closure8(rt.i32Sub(2147483647, near as rt.i32), data, how, out, (x6: rt.i32, out7: rt.ByteVec): undefined => { - rt.iterExtendBytes(out7, rt.iterSlice(rt.i32ToBeBytes(x6).reverse()), undefined, true); + fromTop$i32_iters_range_froms_closure8(rs.i32Sub(2147483647, near as rs.i32), data, how, out, (x6: rs.i32, out7: rs.ByteVec): undefined => { + rs.iterExtendBytes(out7, rs.iterSlice(rs.i32ToBeBytes(x6).reverse()), undefined, true); }); } else if (_12 === 9) { - fromTop$i64_iters_range_froms_closure9(rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, near as rt.i64), data, how, out, (x5: rt.i64, out6: rt.ByteVec): undefined => { - rt.iterExtendBytes(out6, rt.iterSlice(rt.i64ToBeBytes(x5).reverse()), undefined, true); + fromTop$i64_iters_range_froms_closure9(rs.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rs.i64, near as rs.i64), data, how, out, (x5: rs.i64, out6: rs.ByteVec): undefined => { + rs.iterExtendBytes(out6, rs.iterSlice(rs.i64ToBeBytes(x5).reverse()), undefined, true); }); } else if (_12 === 10) { - fromTop$i128_iters_range_froms_closure10(rt.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128, near as rt.i128), data, how, out, (x4: rt.i128, out5: rt.ByteVec): undefined => { - rt.iterExtendBytes(out5, rt.iterSlice(rt.i128ToBeBytes(x4).reverse()), undefined, true); + fromTop$i128_iters_range_froms_closure10(rs.i128Sub({ hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128, near as rs.i128), data, how, out, (x4: rs.i128, out5: rs.ByteVec): undefined => { + rs.iterExtendBytes(out5, rs.iterSlice(rs.i128ToBeBytes(x4).reverse()), undefined, true); }); } else if (_12 === 11) { - fromTop$isize_iters_range_froms_closure11(rt.isizeSub(2147483647, near as rt.isize), data, how, out, (x3: rt.isize, out4: rt.ByteVec): undefined => { - rt.iterExtendBytes(out4, rt.iterSlice(rt.isizeToBeBytes(x3).reverse()), undefined, true); + fromTop$isize_iters_range_froms_closure11(rs.isizeSub(2147483647, near as rs.isize), data, how, out, (x3: rs.isize, out4: rs.ByteVec): undefined => { + rs.iterExtendBytes(out4, rs.iterSlice(rs.isizeToBeBytes(x3).reverse()), undefined, true); }); } else if (_12 === 12) { - fromTop$u64_iters_range_froms_closure12(rt.u64Add(rt.u64Sub({ hi: 0x200000, lo: 0 } as rt.u64, 2), near as rt.u64), data, how, out, (x: rt.u64, out2: rt.ByteVec): undefined => { - rt.iterExtendBytes(out2, rt.iterSlice(rt.u64ToBeBytes(x).reverse()), undefined, true); + fromTop$u64_iters_range_froms_closure12(rs.u64Add(rs.u64Sub({ hi: 0x200000, lo: 0 } as rs.u64, 2), near as rs.u64), data, how, out, (x: rs.u64, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterSlice(rs.u64ToBeBytes(x).reverse()), undefined, true); }); - fromTop$u128_iters_range_froms_closure13(rt.u128Add(rt.u128Sub(rt.u128Shl(1, 64), 2), near as rt.u128), data, how ^ 2, out, (x2: rt.u128, out3: rt.ByteVec): undefined => { - rt.iterExtendBytes(out3, rt.iterSlice(rt.u128ToBeBytes(x2).reverse()), undefined, true); + fromTop$u128_iters_range_froms_closure13(rs.u128Add(rs.u128Sub(rs.u128Shl(1, 64), 2), near as rs.u128), data, how ^ 2, out, (x2: rs.u128, out3: rs.ByteVec): undefined => { + rs.iterExtendBytes(out3, rs.iterSlice(rs.u128ToBeBytes(x2).reverse()), undefined, true); }); - rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(option_unwrapOr$00uis1j(rt.iterNth(new rt.RangeFrom(rt.i64Sub(rt.i64Neg({ hi: 0x200000, lo: 0 } as rt.i64), 2), rt.i64Step), a as rt.usize), 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.i64ToBeBytes(option_unwrapOr$00tqxtm(rs.iterNth(new rs.RangeFrom(rs.i64Sub(rs.i64Neg({ hi: 0x200000, lo: 0 } as rs.i64), 2), rs.i64Step), a as rs.usize), 0)).reverse()), undefined, true); } else if (_12 === 13) { chars(a, data, how, out); } else if (_12 === 14) { @@ -5685,48 +5685,48 @@ export function rangeFroms(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.char, a1: rt.ByteVec) => undefined): void { +export function fromTop$char_iters_chars_closure0(start: rs.char, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.char, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.char]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"); + const iter: rs.Iter<[rs.u8, rs.char]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"); while (true) { - const _13: [rt.u8, rt.char] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.char] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.char = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.char = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.charStep), "len"), (_26: [rt.u8, rt.char]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.char = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.charStep), "len"), (_26: [rs.u8, rs.char]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.char = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.char, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.char, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.char, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.char = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.char = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.charStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.char, rt.u8]): undefined => { - const x3: rt.char = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.charStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.char, rs.u8]): undefined => { + const x3: rs.char = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -5738,48 +5738,48 @@ export function fromTop$char_iters_chars_closure0(start: rt.char, data: rt.ByteS * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i128, a1: rt.ByteVec) => undefined): void { +export function fromTop$i128_iters_range_froms_closure10(start: rs.i128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i128, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"); + const iter: rs.Iter<[rs.u8, rs.i128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"); while (true) { - const _13: [rt.u8, rt.i128] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.i128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.i128 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.i128 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i128Step), "len"), (_26: [rt.u8, rt.i128]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.i128 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i128Step), "len"), (_26: [rs.u8, rs.i128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i128 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.i128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.i128, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.i128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.i128 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.i128 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i128, rt.u8]): undefined => { - const x3: rt.i128 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i128, rs.u8]): undefined => { + const x3: rs.i128 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -5791,48 +5791,48 @@ export function fromTop$i128_iters_range_froms_closure10(start: rt.i128, data: r * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i16, a1: rt.ByteVec) => undefined): void { +export function fromTop$i16_iters_range_froms_closure7(start: rs.i16, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i16, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"); + const iter: rs.Iter<[rs.u8, rs.i16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"); while (true) { - const _13: [rt.u8, rt.i16] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.i16] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.i16 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.i16 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i16Step), "len"), (_26: [rt.u8, rt.i16]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.i16 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i16Step), "len"), (_26: [rs.u8, rs.i16]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i16 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.i16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.i16, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.i16, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.i16 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.i16 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i16, rt.u8]): undefined => { - const x3: rt.i16 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i16, rs.u8]): undefined => { + const x3: rs.i16 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -5844,48 +5844,48 @@ export function fromTop$i16_iters_range_froms_closure7(start: rt.i16, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i32, a1: rt.ByteVec) => undefined): void { +export function fromTop$i32_iters_range_froms_closure8(start: rs.i32, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i32, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"); + const iter: rs.Iter<[rs.u8, rs.i32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"); while (true) { - const _13: [rt.u8, rt.i32] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.i32] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.i32 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.i32 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i32Step), "len"), (_26: [rt.u8, rt.i32]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.i32 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i32Step), "len"), (_26: [rs.u8, rs.i32]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i32 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.i32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.i32, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.i32, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.i32 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.i32 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i32, rt.u8]): undefined => { - const x3: rt.i32 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i32, rs.u8]): undefined => { + const x3: rs.i32 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -5897,48 +5897,48 @@ export function fromTop$i32_iters_range_froms_closure8(start: rt.i32, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i64, a1: rt.ByteVec) => undefined): void { +export function fromTop$i64_iters_range_froms_closure9(start: rs.i64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i64, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"); + const iter: rs.Iter<[rs.u8, rs.i64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"); while (true) { - const _13: [rt.u8, rt.i64] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.i64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.i64 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.i64 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i64Step), "len"), (_26: [rt.u8, rt.i64]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.i64 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i64Step), "len"), (_26: [rs.u8, rs.i64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i64 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.i64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.i64, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.i64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.i64 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.i64 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i64, rt.u8]): undefined => { - const x3: rt.i64 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i64, rs.u8]): undefined => { + const x3: rs.i64 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -5950,48 +5950,48 @@ export function fromTop$i64_iters_range_froms_closure9(start: rt.i64, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.i8, a1: rt.ByteVec) => undefined): void { +export function fromTop$i8_iters_range_froms_closure6(start: rs.i8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.i8, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.i8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"); + const iter: rs.Iter<[rs.u8, rs.i8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"); while (true) { - const _13: [rt.u8, rt.i8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.i8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.i8 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.i8 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.i8Step), "len"), (_26: [rt.u8, rt.i8]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.i8 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.i8Step), "len"), (_26: [rs.u8, rs.i8]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.i8 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.i8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.i8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.i8, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.i8, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.i8 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.i8 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.i8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.i8, rt.u8]): undefined => { - const x3: rt.i8 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.i8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.i8, rs.u8]): undefined => { + const x3: rs.i8 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6003,48 +6003,48 @@ export function fromTop$i8_iters_range_froms_closure6(start: rt.i8, data: rt.Byt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.isize, a1: rt.ByteVec) => undefined): void { +export function fromTop$isize_iters_range_froms_closure11(start: rs.isize, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.isize, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.isize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"); + const iter: rs.Iter<[rs.u8, rs.isize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"); while (true) { - const _13: [rt.u8, rt.isize] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.isize] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.isize = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.isize = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.isizeStep), "len"), (_26: [rt.u8, rt.isize]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.isize = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.isizeStep), "len"), (_26: [rs.u8, rs.isize]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.isize = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.isize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.isize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.isize, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.isize, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.isize = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.isize = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.isizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.isize, rt.u8]): undefined => { - const x3: rt.isize = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.isizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.isize, rs.u8]): undefined => { + const x3: rs.isize = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6056,48 +6056,48 @@ export function fromTop$isize_iters_range_froms_closure11(start: rt.isize, data: * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure13(start: rs.u128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u128, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); while (true) { - const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u128 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u128 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u128 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u128 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u128 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u128 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { - const x3: rt.u128 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { + const x3: rs.u128 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6109,48 +6109,48 @@ export function fromTop$u128_iters_range_froms_closure13(start: rt.u128, data: r * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u128, a1: rt.ByteVec) => undefined): void { +export function fromTop$u128_iters_range_froms_closure4(start: rs.u128, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u128, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u128]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u128]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"); while (true) { - const _13: [rt.u8, rt.u128] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u128] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u128 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u128 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u128Step), "len"), (_26: [rt.u8, rt.u128]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u128 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u128Step), "len"), (_26: [rs.u8, rs.u128]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u128 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u128, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u128, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u128, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u128, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u128 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u128 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u128Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u128, rt.u8]): undefined => { - const x3: rt.u128 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u128Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u128, rs.u8]): undefined => { + const x3: rs.u128 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6162,48 +6162,48 @@ export function fromTop$u128_iters_range_froms_closure4(start: rt.u128, data: rt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u16, a1: rt.ByteVec) => undefined): void { +export function fromTop$u16_iters_range_froms_closure1(start: rs.u16, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u16, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"); while (true) { - const _13: [rt.u8, rt.u16] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u16] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u16 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u16 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u16Step), "len"), (_26: [rt.u8, rt.u16]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u16 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u16Step), "len"), (_26: [rs.u8, rs.u16]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u16 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u16, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u16, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u16, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u16 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u16 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u16Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u16, rt.u8]): undefined => { - const x3: rt.u16 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u16Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u16, rs.u8]): undefined => { + const x3: rs.u16 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6215,48 +6215,48 @@ export function fromTop$u16_iters_range_froms_closure1(start: rt.u16, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u32, a1: rt.ByteVec) => undefined): void { +export function fromTop$u32_iters_range_froms_closure2(start: rs.u32, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u32, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u32]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u32]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"); while (true) { - const _13: [rt.u8, rt.u32] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u32] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u32 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u32 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u32Step), "len"), (_26: [rt.u8, rt.u32]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u32 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u32Step), "len"), (_26: [rs.u8, rs.u32]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u32 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u32, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u32, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u32, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u32 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u32 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u32Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u32, rt.u8]): undefined => { - const x3: rt.u32 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u32Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u32, rs.u8]): undefined => { + const x3: rs.u32 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6268,48 +6268,48 @@ export function fromTop$u32_iters_range_froms_closure2(start: rt.u32, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure12(start: rs.u64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u64, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); while (true) { - const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u64 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u64 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u64 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u64 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u64 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u64 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { - const x3: rt.u64 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { + const x3: rs.u64 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6321,48 +6321,48 @@ export function fromTop$u64_iters_range_froms_closure12(start: rt.u64, data: rt. * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u64, a1: rt.ByteVec) => undefined): void { +export function fromTop$u64_iters_range_froms_closure3(start: rs.u64, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u64, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u64]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u64]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"); while (true) { - const _13: [rt.u8, rt.u64] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u64] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u64 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u64 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u64Step), "len"), (_26: [rt.u8, rt.u64]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u64 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u64Step), "len"), (_26: [rs.u8, rs.u64]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u64 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u64, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u64, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u64 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u64 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u64Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u64, rt.u8]): undefined => { - const x3: rt.u64 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u64Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u64, rs.u8]): undefined => { + const x3: rs.u64 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6374,48 +6374,48 @@ export function fromTop$u64_iters_range_froms_closure3(start: rt.u64, data: rt.B * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.u8, a1: rt.ByteVec) => undefined): void { +export function fromTop$u8_iters_range_froms_closure0(start: rs.u8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.u8, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"); + const iter: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"); while (true) { - const _13: [rt.u8, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.u8 = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.u8 = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.u8Step), "len"), (_26: [rt.u8, rt.u8]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.u8 = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.u8Step), "len"), (_26: [rs.u8, rs.u8]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.u8 = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.u8, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.u8, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.u8 = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.u8 = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.u8Step), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.u8, rt.u8]): undefined => { - const x3: rt.u8 = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.u8Step), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.u8, rs.u8]): undefined => { + const x3: rs.u8 = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6427,48 +6427,48 @@ export function fromTop$u8_iters_range_froms_closure0(start: rt.u8, data: rt.Byt * it steps once more than the data has, so it panics one item sooner; folded, std's zip * of two `TrustedLen` iterators reads only as many pairs as the data has. */ -export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec, put: (a0: rt.usize, a1: rt.ByteVec) => undefined): void { +export function fromTop$usize_iters_range_froms_closure5(start: rs.usize, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec, put: (a0: rs.usize, a1: rs.ByteVec) => undefined): void { b0: { - const _6: rt.u8 = rt.u8Rem(how, 4); + const _6: rs.u8 = rs.u8Rem(how, 4); if (_6 === 0) { - const iter: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"); + const iter: rs.Iter<[rs.u8, rs.usize]> = rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"); while (true) { - const _13: [rt.u8, rt.usize] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.u8, rs.usize] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break b0; } - const b: rt.u8 = _13[0]; - const x: rt.usize = _13[1]; - rt.byteVecPush(out, b); + const b: rs.u8 = _13[0]; + const x: rs.usize = _13[1]; + rs.byteVecPush(out, b); put(x, out); } } if (_6 === 1) { - rt.iterForEach(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), new rt.RangeFrom(start, rt.usizeStep), "len"), (_26: [rt.u8, rt.usize]): undefined => { - const b4: rt.u8 = _26[0]; - const x4: rt.usize = _26[1]; - rt.byteVecPush(out, b4); + rs.iterForEach(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), new rs.RangeFrom(start, rs.usizeStep), "len"), (_26: [rs.u8, rs.usize]): undefined => { + const b4: rs.u8 = _26[0]; + const x4: rs.usize = _26[1]; + rs.byteVecPush(out, b4); put(x4, out); }); } else { if (_6 === 2) { - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _31: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_31 === rt.DONE) { + const _31: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_31 === rs.DONE) { break b0; } - const x2: rt.usize = _31[0]; - const b2: rt.u8 = _31[1]; + const x2: rs.usize = _31[0]; + const b2: rs.u8 = _31[1]; put(x2, out); - rt.byteVecPush(out, b2); + rs.byteVecPush(out, b2); } } - rt.iterForEach(rt.iterZip(new rt.RangeFrom(start, rt.usizeStep), rt.iterSlice(rt.byteSliceView(data)), "len"), (_2: [rt.usize, rt.u8]): undefined => { - const x3: rt.usize = _2[0]; - const b3: rt.u8 = _2[1]; + rs.iterForEach(rs.iterZip(new rs.RangeFrom(start, rs.usizeStep), rs.iterSlice(rs.byteSliceView(data)), "len"), (_2: [rs.usize, rs.u8]): undefined => { + const x3: rs.usize = _2[0]; + const b3: rs.u8 = _2[1]; put(x3, out); - rt.byteVecPush(out, b3); + rs.byteVecPush(out, b3); }); } } @@ -6478,52 +6478,52 @@ export function fromTop$usize_iters_range_froms_closure5(start: rt.usize, data: * `char` ranges of each kind across the surrogates, which std's `Step` skips, and up to * `char::MAX`, past which `start..` panics. */ -export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec): void { - const _8: (a0: rt.char, a1: rt.ByteVec) => undefined = (c2: rt.char, out2: rt.ByteVec): undefined => { - rt.iterExtendBytes(out2, rt.iterSlice(rt.u32ToBeBytes(c2 as rt.u32).reverse()), undefined, true); +export function chars(a: rs.u8, data: rs.ByteSlice, how: rs.u8, out: rs.ByteVec): void { + const _8: (a0: rs.char, a1: rs.ByteVec) => undefined = (c2: rs.char, out2: rs.ByteVec): undefined => { + rs.iterExtendBytes(out2, rs.iterSlice(rs.u32ToBeBytes(c2 as rs.u32).reverse()), undefined, true); }; - const near: rt.u32 = rt.u8Rem(a, 4) as rt.u32; - const gap: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(55293, near))); - fromTop$char_iters_chars_closure0(gap, data, how, out, (c3: rt.char, out3: rt.ByteVec): undefined => { - rt.iterExtendBytes(out3, rt.iterSlice(rt.u32ToBeBytes(c3 as rt.u32).reverse()), undefined, true); + const near: rs.u32 = rs.u8Rem(a, 4) as rs.u32; + const gap: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(55293, near))); + fromTop$char_iters_chars_closure0(gap, data, how, out, (c3: rs.char, out3: rs.ByteVec): undefined => { + rs.iterExtendBytes(out3, rs.iterSlice(rs.u32ToBeBytes(c3 as rs.u32).reverse()), undefined, true); }); - const top: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Sub(1114111 as rt.u32, near))); - fromTop$char_iters_chars_closure0(top, data, how, out, (c4: rt.char, out4: rt.ByteVec): undefined => { - rt.iterExtendBytes(out4, rt.iterSlice(rt.u32ToBeBytes(c4 as rt.u32).reverse()), undefined, true); + const top: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111 as rs.u32, near))); + fromTop$char_iters_chars_closure0(top, data, how, out, (c4: rs.char, out4: rs.ByteVec): undefined => { + rs.iterExtendBytes(out4, rs.iterSlice(rs.u32ToBeBytes(c4 as rs.u32).reverse()), undefined, true); }); - const n: rt.usize = data.length; - const end: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(57344, near))); - const iter: rt.Iter = rt.iterStepBy(rt.iterRev(new rt.Range(gap, end, rt.charStep)), 2); + const n: rs.usize = data.length; + const end: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(57344, near))); + const iter: rs.Iter = rs.iterStepBy(rs.iterRev(new rs.Range(gap, end, rs.charStep)), 2); while (true) { - const _30: rt.char | rt.Done = iter.next(); - if (_30 === rt.DONE) { + const _30: rs.char | rs.Done = iter.next(); + if (_30 === rs.DONE) { break; } _8(_30, out); } - const part = option_unwrapOr$0k15iai(rt.iterNth(new rt.Range(gap, end, rt.charStep), rt.usizeRem(n, 8)), 45); + const part = option_unwrapOr$04rqm9m(rs.iterNth(new rs.Range(gap, end, rs.charStep), rs.usizeRem(n, 8)), 45); _8(part, out); - const part2 = option_unwrapOr$0k15iai(rt.iterNthBack(new rt.RangeInclusive(gap, end, rt.charStep), rt.usizeRem(n, 8)), 45); + const part2 = option_unwrapOr$04rqm9m(rs.iterNthBack(new rs.RangeInclusive(gap, end, rs.charStep), rs.usizeRem(n, 8)), 45); _8(part2, out); - const part3 = option_unwrapOr$0k15iai(rt.iterNth(new rt.RangeFrom(gap, rt.charStep), rt.usizeRem(n, 8)), 45); + const part3 = option_unwrapOr$04rqm9m(rs.iterNth(new rs.RangeFrom(gap, rs.charStep), rs.usizeRem(n, 8)), 45); _8(part3, out); - const _66: [rt.usize, rt.usize | undefined] = new rt.RangeInclusive(gap, end, rt.charStep).sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_66[0] & 0xff, option_mapOr$02k4ito(_66[1], 238, (h: rt.usize): rt.u8 => { + const _66: [rs.usize, rs.usize | undefined] = new rs.RangeInclusive(gap, end, rs.charStep).sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_66[0] & 0xff, option_mapOr$188iunt(_66[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; - }), rt.iterCount(new rt.Range(gap, end, rt.charStep)) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(new rt.RangeInclusive(gap, end, rt.charStep), (c5: rt.char): rt.u8 => { - return (c5 as rt.u32) & 0xff; + }), rs.iterCount(new rs.Range(gap, end, rs.charStep)) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(new rs.RangeInclusive(gap, end, rs.charStep), (c5: rs.char): rs.u8 => { + return (c5 as rs.u32) & 0xff; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(new rt.Range(55295, 57344, rt.charStep)) & 0xff); - const last: rt.RangeInclusive = new rt.RangeInclusive(top, 1114111, rt.charStep); - const part4 = option_unwrapOr$0k15iai(rt.iterNth(last, rt.usizeRem(n, 6)), 45); + rs.byteVecPush(out, rs.iterCount(new rs.Range(55295, 57344, rs.charStep)) & 0xff); + const last: rs.RangeInclusive = new rs.RangeInclusive(top, 1114111, rs.charStep); + const part4 = option_unwrapOr$04rqm9m(rs.iterNth(last, rs.usizeRem(n, 6)), 45); _8(part4, out); - const part5 = rt.rangeInclusiveStart(last); + const part5 = rs.rangeInclusiveStart(last); _8(part5, out); - const first: rt.RangeInclusive = new rt.RangeInclusive(0, rt.optionUnwrap(rt.charFromU32(near)), rt.charStep); - const part6 = option_unwrapOr$0k15iai(rt.iterNthBack(first, rt.usizeRem(n, 6)), 45); + const first: rs.RangeInclusive = new rs.RangeInclusive(0, rs.optionUnwrap(rs.charFromU32(near)), rs.charStep); + const part6 = option_unwrapOr$04rqm9m(rs.iterNthBack(first, rs.usizeRem(n, 6)), 45); _8(part6, out); - const part7 = rt.rangeInclusiveEnd(first); + const part7 = rs.rangeInclusiveEnd(first); _8(part7, out); } @@ -6531,71 +6531,71 @@ export function chars(a: rt.u8, data: rt.ByteSlice, how: rt.u8, out: rt.ByteVec) * `start..` as what each adaptor and consumer taking an `IntoIterator` takes, and as its * own receiver. */ -export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const lo: rt.u8 = rt.u8Rem(a, 64); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - const it: () => rt.Iter = (): rt.Iter => { - return rt.iterSlice(rt.byteSliceView(data)); +export function adapted(a: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const lo: rs.u8 = rs.u8Rem(a, 64); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + const it: () => rs.Iter = (): rs.Iter => { + return rs.iterSlice(rs.byteSliceView(data)); }; - const n: rt.usize = data.length; - rt.iterExtendBytes(out, rt.iterTake(rt.iterChain(it(), new rt.RangeFrom(lo, rt.u8Step)), rt.usizeAdd(n, 3)), undefined, true); - const v: rt.ByteVec = new rt.ByteVec(); - const _22: rt.Iter = rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), 3); - rt.iterExtendBytes(v, _22, undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatten(rt.vecIntoIter(rt.vecFrom([new rt.RangeFrom(lo, rt.u8Step), new rt.RangeFrom(rt.u8Div(b, 2), rt.u8Step)])), undefined, true), 5), "next"); - rt.iterExtendBytes(out, rt.iterTake(rt.iterFlatMap(it(), (x: rt.u8): rt.RangeFrom => { - return new rt.RangeFrom(rt.u8Div(x, 4), rt.u8Step); - }, undefined, true), rt.usizeMul(n, 2)), "next"); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x2: rt.u8): rt.Range => { - return new rt.Range(rt.u8Div(x2, 32), rt.u8Div(x2, 16)); + const n: rs.usize = data.length; + rs.iterExtendBytes(out, rs.iterTake(rs.iterChain(it(), new rs.RangeFrom(lo, rs.u8Step)), rs.usizeAdd(n, 3)), undefined, true); + const v: rs.ByteVec = new rs.ByteVec(); + const _22: rs.Iter = rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), 3); + rs.iterExtendBytes(v, _22, undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(rs.iterFlatten(rs.vecIntoIter(rs.vecFrom([new rs.RangeFrom(lo, rs.u8Step), new rs.RangeFrom(rs.u8Div(b, 2), rs.u8Step)])), undefined, true), 5), "next"); + rs.iterExtendBytes(out, rs.iterTake(rs.iterFlatMap(it(), (x: rs.u8): rs.RangeFrom => { + return new rs.RangeFrom(rs.u8Div(x, 4), rs.u8Step); + }, undefined, true), rs.usizeMul(n, 2)), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(it(), (x2: rs.u8): rs.Range => { + return new rs.Range(rs.u8Div(x2, 32), rs.u8Div(x2, 16)); }), undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterMap(it(), (x3: rt.u8): rt.RangeInclusive => { - return new rt.RangeInclusive(rt.u8Div(x3, 64), rt.u8Div(x3, 32), rt.u8Step); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterMap(it(), (x3: rs.u8): rs.RangeInclusive => { + return new rs.RangeInclusive(rs.u8Div(x3, 64), rs.u8Div(x3, 32), rs.u8Step); }), undefined, true), "next"); - const _54: rt.Iter<[rt.u8, rt.usize]> = rt.iterZip(it(), new rt.RangeFrom(0, rt.usizeStep), "len"); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rt.u8, rt.usize]): rt.u8 => { + const _54: rs.Iter<[rs.u8, rs.usize]> = rs.iterZip(it(), new rs.RangeFrom(0, rs.usizeStep), "len"); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _54, true, undefined, undefined, undefined, 8, true)), (_24: [rs.u8, rs.usize]): rs.u8 => { return _24[0] ^ (_24[1] & 0xff); }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterTake(rt.iterStepBy(new rt.RangeFrom(lo, rt.u8Step), 3), 4), "next")), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(rt.stringExtendChars("", rt.iterTake(new rt.RangeFrom(97, rt.charStep), rt.usizeRem(n, 6)))), undefined, true); - const _77: [rt.usize, rt.usize | undefined] = rt.iterZip(it(), new rt.RangeFrom(lo, rt.u8Step), "len").sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$02k4ito(_77[1], 238, (h: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterTake(rs.iterStepBy(new rs.RangeFrom(lo, rs.u8Step), 3), 4), "next")), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.stringExtendChars("", rs.iterTake(new rs.RangeFrom(97, rs.charStep), rs.usizeRem(n, 6)))), undefined, true); + const _77: [rs.usize, rs.usize | undefined] = rs.iterZip(it(), new rs.RangeFrom(lo, rs.u8Step), "len").sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_77[0] & 0xff, option_mapOr$188iunt(_77[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); - const _89: [rt.usize, rt.usize | undefined] = new rt.RangeFrom(lo, rt.u8Step).sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_89[0] & 0xff, option_mapOr$02k4ito(_89[1], 238, (h2: rt.usize): rt.u8 => { + const _89: [rs.usize, rs.usize | undefined] = new rs.RangeFrom(lo, rs.u8Step).sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_89[0] & 0xff, option_mapOr$188iunt(_89[1], 238, (h2: rs.usize): rs.u8 => { return h2 & 0xff; }))), undefined, true); - const r: rt.RangeFrom = new rt.RangeFrom(lo, rt.u8Step); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(r.next()), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(r, rt.u8Rem(b, 8) as rt.usize), 238)); - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterBorrow(r), 2)) & 0xff); - rt.byteVecPush(out, r.start); - const iter: rt.RangeFrom = new rt.RangeFrom(lo, rt.u8Step); + const r: rs.RangeFrom = new rs.RangeFrom(lo, rs.u8Step); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(r.next()), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(r, rs.u8Rem(b, 8) as rs.usize), 238)); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterBorrow(r), 2)) & 0xff); + rs.byteVecPush(out, r.start); + const iter: rs.RangeFrom = new rs.RangeFrom(lo, rs.u8Step); while (true) { - const _119: rt.u8 | rt.Done = iter.next(); - if (_119 === rt.DONE) { + const _119: rs.u8 | rs.Done = iter.next(); + if (_119 === rs.DONE) { break; } - const i: rt.u8 = _119; - if (!(i > rt.u8Add(lo, 5))) { - rt.byteVecPush(out, i); + const i: rs.u8 = _119; + if (!(i > rs.u8Add(lo, 5))) { + rs.byteVecPush(out, i); } else { break; } } - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(new rt.RangeFrom(lo, rt.u8Step), (i2: rt.u8): boolean => { - return (i2 as rt.usize) >= rt.usizeAdd(n, lo as rt.usize); - }), 238, (i3: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(new rs.RangeFrom(lo, rs.u8Step), (i2: rs.u8): boolean => { + return (i2 as rs.usize) >= rs.usizeAdd(n, lo as rs.usize); + }), 238, (i3: rs.usize): rs.u8 => { return i3 & 0xff; })); - rt.iterExtendBytes(out, rt.iterTakeWhile(rt.iterFilter(rt.iterMap(rt.iterSkip(new rt.RangeFrom(lo, rt.u8Step), 2), (i4: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterTakeWhile(rs.iterFilter(rs.iterMap(rs.iterSkip(new rs.RangeFrom(lo, rs.u8Step), 2), (i4: rs.u8): rs.u8 => { return i4 ^ 1; - }), (i5: rt.u8): boolean => { - return rt.u8Rem(i5, 3) !== 0; - }), (_26: rt.u8): boolean => { - return _26 < rt.u8Add(lo, 20); + }), (i5: rs.u8): boolean => { + return rs.u8Rem(i5, 3) !== 0; + }), (_26: rs.u8): boolean => { + return _26 < rs.u8Add(lo, 20); }), "next"); } @@ -6603,27 +6603,27 @@ export function adapted(a: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Consumers that step `start..` past its type's last value, which panics in std's * debug build, as the fixture is built. */ -export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - const top: rt.u8 = rt.max(a, 250); - const _5: rt.usize = rt.usizeRem(dataLen, 8); +export function overflowed(a: rs.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + const top: rs.u8 = rs.max(a, 250); + const _5: rs.usize = rs.usizeRem(dataLen, 8); if (_5 === 0) { - rt.iterExtendBytes(out, new rt.RangeFrom(top, rt.u8Step), undefined, true); + rs.iterExtendBytes(out, new rs.RangeFrom(top, rs.u8Step), undefined, true); } else if (_5 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(new rt.RangeFrom(top, rt.u8Step), 10)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(new rs.RangeFrom(top, rs.u8Step), 10)) & 0xff); } else if (_5 === 2) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(new rt.RangeFrom(a, rt.u8Step), 300), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(new rs.RangeFrom(a, rs.u8Step), 300), 238)); } else if (_5 === 3) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(new rt.RangeFrom(a, rt.u8Step), rt.u8Sub(255, a) as rt.usize), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(new rs.RangeFrom(a, rs.u8Step), rs.u8Sub(255, a) as rs.usize), 238)); } else if (_5 === 4) { - rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(new rt.RangeFrom(a, rt.u8Step), 100), 5), "next"); + rs.iterExtendBytes(out, rs.iterTake(rs.iterStepBy(new rs.RangeFrom(a, rs.u8Step), 100), 5), "next"); } else if (_5 === 5) { - rt.byteVecPush(out, rt.iterCount(rt.iterTake(new rt.RangeFrom(rt.i8Sub(127, (rt.u8Rem(a, 4) << 24) >> 24), rt.i8Step), 5)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterTake(new rs.RangeFrom(rs.i8Sub(127, (rs.u8Rem(a, 4) << 24) >> 24), rs.i8Step), 5)) & 0xff); } else if (_5 === 6) { - rt.byteVecPush(out, option_mapOr$0okqj9y(rt.iterToOption(new rt.RangeFrom(1114111, rt.charStep).next()), 238, (c: rt.char): rt.u8 => { + rs.byteVecPush(out, option_mapOr$041x3r2(rs.iterToOption(new rs.RangeFrom(1114111, rs.charStep).next()), 238, (c: rs.char): rs.u8 => { return c & 0xff; })); } else { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(new rt.RangeFrom(top, rt.u8Step), undefined, true)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(new rs.RangeFrom(top, rs.u8Step), undefined, true)), undefined, true); } } @@ -6633,15 +6633,15 @@ export function overflowed(a: rt.u8, _dataData: Uint8Array, _dataStart: number, * width at their ends and past 2^53 and 2^64, `char`s at either side of the surrogates, * floats with NaN and the zeros, and unsigned `NonZero`s. */ -export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: rt.usize[] = rt.arrayMap([0, 1], (i: rt.usize): rt.usize => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.usize; +export function rangeMethods(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: rs.usize[] = rs.arrayMap([0, 1], (i: rs.usize): rs.usize => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0) as rs.usize; }); - const past53: rt.u64 = rt.u64Add({ hi: 0x200000, lo: 0 } as rt.u64, 1); - const past64: rt.u128 = rt.u128Add(rt.u128Shl(1, 64), 1); - const _17: rt.u8 = rt.u8Rem(kind, 19); + const past53: rs.u64 = rs.u64Add({ hi: 0x200000, lo: 0 } as rs.u64, 1); + const past64: rs.u128 = rs.u128Add(rs.u128Shl(1, 64), 1); + const _17: rs.u8 = rs.u8Rem(kind, 19); if (_17 === 0) { - stepped$u8(rt.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)), at, out); + stepped$u8(rs.byteSliceFrom(Uint8Array.of(0, 1, 2, 254, 255)), at, out); } else if (_17 === 1) { 65535 - 1; stepped$u16([0, 1, 32767, 65534, 65535], at, out); @@ -6649,9 +6649,9 @@ export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): 4294967295 - 1; stepped$u32([0, 1, 2147483648, 4294967294, 4294967295], at, out); } else if (_17 === 3) { - stepped$u64([0, 1, rt.u64Sub(past53, 2), rt.u64Sub(past53, 1), past53, { hi: 0xffffffff, lo: 0xfffffffe } as rt.u64, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64], at, out); + stepped$u64([0, 1, rs.u64Sub(past53, 2), rs.u64Sub(past53, 1), past53, { hi: 0xffffffff, lo: 0xfffffffe } as rs.u64, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64], at, out); } else if (_17 === 4) { - stepped$u128([0, 1, rt.u128Sub(past64, 2), rt.u128Sub(past64, 1), past64, rt.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, 1), { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128], at, out); + stepped$u128([0, 1, rs.u128Sub(past64, 2), rs.u128Sub(past64, 1), past64, rs.u128Sub({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, 1), { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128], at, out); } else if (_17 === 5) { 4294967295 - 1; stepped$usize([0, 1, 2147483648, 4294967294, 4294967295], at, out); @@ -6665,11 +6665,11 @@ export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): -2147483648 + 1; stepped$i32([-2147483648, -2147483647, -1, 0, 2147483647], at, out); } else if (_17 === 9) { - const past532: rt.i64 = rt.i64Cast(past53); - stepped$i64([{ hi: -0x80000000, lo: 0 } as rt.i64, rt.i64Neg(past532), -1, 0, past532, { hi: 0x7fffffff, lo: 0xfffffffe } as rt.i64, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64], at, out); + const past532: rs.i64 = rs.i64Cast(past53); + stepped$i64([{ hi: -0x80000000, lo: 0 } as rs.i64, rs.i64Neg(past532), -1, 0, past532, { hi: 0x7fffffff, lo: 0xfffffffe } as rs.i64, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64], at, out); } else if (_17 === 10) { - const past642: rt.i128 = rt.i128Cast(past64); - stepped$i128([{ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, rt.i128Add({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, 1), rt.i128Neg(past642), -1, 0, past642, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128], at, out); + const past642: rs.i128 = rs.i128Cast(past64); + stepped$i128([{ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, rs.i128Add({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, 1), rs.i128Neg(past642), -1, 0, past642, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128], at, out); } else if (_17 === 11) { 2147483647 - 1; stepped$isize([-2147483648, -1, 0, 1, 2147483646, 2147483647], at, out); @@ -6680,20 +6680,20 @@ export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): } else if (_17 === 14) { bounded$f32([NaN, -Infinity, -1.5, -0.0, 0.0, 2.5, Infinity], at, out); } else if (_17 === 15) { - stepped$num_NonZero_u8(rt.arrayMap(Uint8Array.of(1, 2, 254, 255), (n4: rt.u8): rt.u8 => { - return rt.optionUnwrap(rt.nonZero(n4)); + stepped$num_NonZero_u8(rs.arrayMap(Uint8Array.of(1, 2, 254, 255), (n4: rs.u8): rs.u8 => { + return rs.optionUnwrap(rs.nonZero(n4)); }), at, out); } else if (_17 === 16) { - stepped$num_NonZero_u64(rt.arrayMap([1, past53, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64], (n3: rt.u64): rt.u64 => { - return rt.optionUnwrap(rt.nonZero(n3)); + stepped$num_NonZero_u64(rs.arrayMap([1, past53, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64], (n3: rs.u64): rs.u64 => { + return rs.optionUnwrap(rs.nonZero(n3)); }), at, out); } else if (_17 === 17) { - stepped$num_NonZero_u128(rt.arrayMap([1, past64, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128], (n2: rt.u128): rt.u128 => { - return rt.optionUnwrap(rt.nonZero(n2)); + stepped$num_NonZero_u128(rs.arrayMap([1, past64, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128], (n2: rs.u128): rs.u128 => { + return rs.optionUnwrap(rs.nonZero(n2)); }), at, out); } else { - stepped$num_NonZero_usize(rt.arrayMap([1, 2, 4294967295], (n: rt.usize): rt.usize => { - return rt.optionUnwrap(rt.nonZero(n)); + stepped$num_NonZero_usize(rs.arrayMap([1, 2, 4294967295], (n: rs.usize): rs.usize => { + return rs.optionUnwrap(rs.nonZero(n)); }), at, out); } } @@ -6702,1900 +6702,1900 @@ export function rangeMethods(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$char(table: rt.char[], at: rt.usize[], out: rt.ByteVec): [rt.char, rt.char] { - const _6: rt.char[] = rt.arrayMap(at, (i: rt.usize): rt.char => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$char(table: rs.char[], at: rs.usize[], out: rs.ByteVec): [rs.char, rs.char] { + const _6: rs.char[] = rs.arrayMap(at, (i: rs.usize): rs.char => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.char = _6[0]; - const b: rt.char = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.charStep)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.charStep))], (a0: boolean): rt.u8 => { + const a: rs.char = _6[0]; + const b: rs.char = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.charStep)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.charStep))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.charStep), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.charStep), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.charStep), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$char_ops_Range_char(new rt.Range(a, b, rt.charStep), _19); - const _41: boolean = boundsContain$char_ops_RangeInclusive_char(new rt.RangeInclusive(a, b, rt.charStep), _19); - const _43: boolean = boundsContain$char_ops_RangeFrom_char(new rt.RangeFrom(a, rt.charStep), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.charStep), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.charStep), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.charStep), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$char_ops_Range_char(new rs.Range(a, b, rs.charStep), _19); + const _41: boolean = boundsContain$char_ops_RangeInclusive_char(new rs.RangeInclusive(a, b, rs.charStep), _19); + const _43: boolean = boundsContain$char_ops_RangeFrom_char(new rs.RangeFrom(a, rs.charStep), _19); const _45: boolean = boundsContain$char_ops_RangeTo_char({ end: b }, _19); const _47: boolean = boundsContain$char_ops_RangeToInclusive_char({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$char_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.charStep); - const _64: rt.Range = new rt.Range(_19, b, rt.charStep); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.charStep); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.charStep); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.charStep); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.charStep); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.char } = { end: b }; - const _82: { end: rt.char } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.char; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.char; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.charStep); + const _64: rs.Range = new rs.Range(_19, b, rs.charStep); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.charStep); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.charStep); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.charStep); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.char } = { end: b }; + const _82: { end: rs.char } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.char; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.char; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.char, rt.char] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.charStep)); - const start: rt.char = _94[0]; - const end: rt.char = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.charStep); - const _102: rt.Range = new rt.Range(a, b, rt.charStep); - const _113: [rt.char, rt.char] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.charStep); - const _107: { end: rt.char } = { end: b }; - const _109: { end: rt.char; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.char, rt.char] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtCharDebug(_111[0], f), (f: rt.Formatter) => rt.fmtCharDebug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtCharDebug(_113[0], f), (f: rt.Formatter) => rt.fmtCharDebug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.char }, { end: rt.char; inclusive: true }] = [new rt.RangeFrom(a, rt.charStep), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.char } = _137[1]; - const through: { end: rt.char; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.fmtCharDebug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.char, rt.char]; + const _94: [rs.char, rs.char] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.charStep)); + const start: rs.char = _94[0]; + const end: rs.char = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); + const _102: rs.Range = new rs.Range(a, b, rs.charStep); + const _113: [rs.char, rs.char] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.charStep); + const _107: { end: rs.char } = { end: b }; + const _109: { end: rs.char; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.char, rs.char] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_111[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtCharDebug(_113[0], f), (f: rs.Formatter) => rs.fmtCharDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.char }, { end: rs.char; inclusive: true }] = [new rs.RangeFrom(a, rs.charStep), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.char } = _137[1]; + const through: { end: rs.char; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.fmtCharDebug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.char, rs.char]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$f32(table: rt.f32[], at: rt.usize[], out: rt.ByteVec): [rt.f32, rt.f32] { - const _6: rt.f32[] = rt.arrayMap(at, (i: rt.usize): rt.f32 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$f32(table: rs.f32[], at: rs.usize[], out: rs.ByteVec): [rs.f32, rs.f32] { + const _6: rs.f32[] = rs.arrayMap(at, (i: rs.usize): rs.f32 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.f32 = _6[0]; - const b: rt.f32 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b))], (a0: boolean): rt.u8 => { + const a: rs.f32 = _6[0]; + const b: rs.f32 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$f32_ops_Range_f32(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$f32_ops_RangeInclusive_f32(new rt.RangeInclusive(a, b), _19); - const _43: boolean = boundsContain$f32_ops_RangeFrom_f32(new rt.RangeFrom(a), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$f32_ops_Range_f32(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$f32_ops_RangeInclusive_f32(new rs.RangeInclusive(a, b), _19); + const _43: boolean = boundsContain$f32_ops_RangeFrom_f32(new rs.RangeFrom(a), _19); const _45: boolean = boundsContain$f32_ops_RangeTo_f32({ end: b }, _19); const _47: boolean = boundsContain$f32_ops_RangeToInclusive_f32({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$f32_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a); - const _76: rt.RangeFrom = new rt.RangeFrom(_19); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.f32 } = { end: b }; - const _82: { end: rt.f32 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.f32; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.f32; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a); + const _76: rs.RangeFrom = new rs.RangeFrom(_19); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.f32 } = { end: b }; + const _82: { end: rs.f32 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.f32; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.f32; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.f32, rt.f32] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b)); - const start: rt.f32 = _94[0]; - const end: rt.f32 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.f32, rt.f32] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a); - const _107: { end: rt.f32 } = { end: b }; - const _109: { end: rt.f32; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.f32, rt.f32] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.f32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.f32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.f32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.f32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.f32Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.f32Debug(_111[0], f), (f: rt.Formatter) => rt.f32Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.f32Debug(_113[0], f), (f: rt.Formatter) => rt.f32Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.f32 }, { end: rt.f32; inclusive: true }] = [new rt.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.f32 } = _137[1]; - const through: { end: rt.f32; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.f32Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.f32, rt.f32]; + const _94: [rs.f32, rs.f32] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b)); + const start: rs.f32 = _94[0]; + const end: rs.f32 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.f32, rs.f32] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a); + const _107: { end: rs.f32 } = { end: b }; + const _109: { end: rs.f32; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.f32, rs.f32] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_111[0], f), (f: rs.Formatter) => rs.f32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f32Debug(_113[0], f), (f: rs.Formatter) => rs.f32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.f32 }, { end: rs.f32; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.f32 } = _137[1]; + const through: { end: rs.f32; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f32Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.f32, rs.f32]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$f64(table: rt.f64[], at: rt.usize[], out: rt.ByteVec): [rt.f64, rt.f64] { - const _6: rt.f64[] = rt.arrayMap(at, (i: rt.usize): rt.f64 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$f64(table: rs.f64[], at: rs.usize[], out: rs.ByteVec): [rs.f64, rs.f64] { + const _6: rs.f64[] = rs.arrayMap(at, (i: rs.usize): rs.f64 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.f64 = _6[0]; - const b: rt.f64 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b))], (a0: boolean): rt.u8 => { + const a: rs.f64 = _6[0]; + const b: rs.f64 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$f64_ops_Range_f64(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$f64_ops_RangeInclusive_f64(new rt.RangeInclusive(a, b), _19); - const _43: boolean = boundsContain$f64_ops_RangeFrom_f64(new rt.RangeFrom(a), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$f64_ops_Range_f64(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$f64_ops_RangeInclusive_f64(new rs.RangeInclusive(a, b), _19); + const _43: boolean = boundsContain$f64_ops_RangeFrom_f64(new rs.RangeFrom(a), _19); const _45: boolean = boundsContain$f64_ops_RangeTo_f64({ end: b }, _19); const _47: boolean = boundsContain$f64_ops_RangeToInclusive_f64({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$f64_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a); - const _76: rt.RangeFrom = new rt.RangeFrom(_19); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.f64 } = { end: b }; - const _82: { end: rt.f64 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.f64; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.f64; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a); + const _76: rs.RangeFrom = new rs.RangeFrom(_19); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.f64 } = { end: b }; + const _82: { end: rs.f64 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.f64; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.f64; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.f64, rt.f64] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b)); - const start: rt.f64 = _94[0]; - const end: rt.f64 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.f64, rt.f64] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a); - const _107: { end: rt.f64 } = { end: b }; - const _109: { end: rt.f64; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.f64, rt.f64] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.f64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.f64Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.f64Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.f64Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.f64Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.f64Debug(_111[0], f), (f: rt.Formatter) => rt.f64Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.f64Debug(_113[0], f), (f: rt.Formatter) => rt.f64Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.f64 }, { end: rt.f64; inclusive: true }] = [new rt.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.f64 } = _137[1]; - const through: { end: rt.f64; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.f64Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.f64, rt.f64]; + const _94: [rs.f64, rs.f64] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b)); + const start: rs.f64 = _94[0]; + const end: rs.f64 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.f64, rs.f64] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a); + const _107: { end: rs.f64 } = { end: b }; + const _109: { end: rs.f64; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.f64, rs.f64] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.f64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_111[0], f), (f: rs.Formatter) => rs.f64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.f64Debug(_113[0], f), (f: rs.Formatter) => rs.f64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.f64 }, { end: rs.f64; inclusive: true }] = [new rs.RangeFrom(a), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.f64 } = _137[1]; + const through: { end: rs.f64; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.f64Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.f64, rs.f64]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$i128(table: rt.i128[], at: rt.usize[], out: rt.ByteVec): [rt.i128, rt.i128] { - const _6: rt.i128[] = rt.arrayMap(at, (i: rt.usize): rt.i128 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$i128(table: rs.i128[], at: rs.usize[], out: rs.ByteVec): [rs.i128, rs.i128] { + const _6: rs.i128[] = rs.arrayMap(at, (i: rs.usize): rs.i128 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.i128 = _6[0]; - const b: rt.i128 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.i128Step)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.i128Step))], (a0: boolean): rt.u8 => { + const a: rs.i128 = _6[0]; + const b: rs.i128 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.i128Step)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.i128Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.i128Step), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.i128Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.i128Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$i128_ops_Range_i128(new rt.Range(a, b, rt.i128Step), _19); - const _41: boolean = boundsContain$i128_ops_RangeInclusive_i128(new rt.RangeInclusive(a, b, rt.i128Step), _19); - const _43: boolean = boundsContain$i128_ops_RangeFrom_i128(new rt.RangeFrom(a, rt.i128Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.i128Step), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.i128Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.i128Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$i128_ops_Range_i128(new rs.Range(a, b, rs.i128Step), _19); + const _41: boolean = boundsContain$i128_ops_RangeInclusive_i128(new rs.RangeInclusive(a, b, rs.i128Step), _19); + const _43: boolean = boundsContain$i128_ops_RangeFrom_i128(new rs.RangeFrom(a, rs.i128Step), _19); const _45: boolean = boundsContain$i128_ops_RangeTo_i128({ end: b }, _19); const _47: boolean = boundsContain$i128_ops_RangeToInclusive_i128({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$i128_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.i128Step); - const _64: rt.Range = new rt.Range(_19, b, rt.i128Step); - const _60: boolean = rt.rangeEq(rt.i128Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i128Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.i128Step); - const _66: boolean = rt.rangeEq(rt.i128Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.i128Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.i128Step); - const _72: boolean = !rt.rangeEq(rt.i128Eq)(_74, _76); - const _80: { end: rt.i128 } = { end: b }; - const _82: { end: rt.i128 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.i128Eq)(_80, _82); - const _86: { end: rt.i128; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.i128; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.i128Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.i128Step); + const _64: rs.Range = new rs.Range(_19, b, rs.i128Step); + const _60: boolean = rs.rangeEq(rs.i128Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.i128Step); + const _66: boolean = rs.rangeEq(rs.i128Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.i128Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.i128Step); + const _72: boolean = !rs.rangeEq(rs.i128Eq)(_74, _76); + const _80: { end: rs.i128 } = { end: b }; + const _82: { end: rs.i128 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.i128Eq)(_80, _82); + const _86: { end: rs.i128; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.i128; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.i128Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.i128, rt.i128] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.i128Step)); - const start: rt.i128 = _94[0]; - const end: rt.i128 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i128Step); - const _102: rt.Range = new rt.Range(a, b, rt.i128Step); - const _113: [rt.i128, rt.i128] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.i128Step); - const _107: { end: rt.i128 } = { end: b }; - const _109: { end: rt.i128; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.i128, rt.i128] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i128Debug(_111[0], f), (f: rt.Formatter) => rt.i128Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i128Debug(_113[0], f), (f: rt.Formatter) => rt.i128Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.i128 }, { end: rt.i128; inclusive: true }] = [new rt.RangeFrom(a, rt.i128Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.i128 } = _137[1]; - const through: { end: rt.i128; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.i128Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.i128, rt.i128]; + const _94: [rs.i128, rs.i128] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.i128Step)); + const start: rs.i128 = _94[0]; + const end: rs.i128 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); + const _102: rs.Range = new rs.Range(a, b, rs.i128Step); + const _113: [rs.i128, rs.i128] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.i128Step); + const _107: { end: rs.i128 } = { end: b }; + const _109: { end: rs.i128; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.i128, rs.i128] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_111[0], f), (f: rs.Formatter) => rs.i128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i128Debug(_113[0], f), (f: rs.Formatter) => rs.i128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.i128 }, { end: rs.i128; inclusive: true }] = [new rs.RangeFrom(a, rs.i128Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.i128 } = _137[1]; + const through: { end: rs.i128; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i128Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.i128, rs.i128]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$i16(table: rt.i16[], at: rt.usize[], out: rt.ByteVec): [rt.i16, rt.i16] { - const _6: rt.i16[] = rt.arrayMap(at, (i: rt.usize): rt.i16 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$i16(table: rs.i16[], at: rs.usize[], out: rs.ByteVec): [rs.i16, rs.i16] { + const _6: rs.i16[] = rs.arrayMap(at, (i: rs.usize): rs.i16 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.i16 = _6[0]; - const b: rt.i16 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.i16Step))], (a0: boolean): rt.u8 => { + const a: rs.i16 = _6[0]; + const b: rs.i16 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.i16Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.i16Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.i16Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$i16_ops_Range_i16(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$i16_ops_RangeInclusive_i16(new rt.RangeInclusive(a, b, rt.i16Step), _19); - const _43: boolean = boundsContain$i16_ops_RangeFrom_i16(new rt.RangeFrom(a, rt.i16Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.i16Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.i16Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$i16_ops_Range_i16(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$i16_ops_RangeInclusive_i16(new rs.RangeInclusive(a, b, rs.i16Step), _19); + const _43: boolean = boundsContain$i16_ops_RangeFrom_i16(new rs.RangeFrom(a, rs.i16Step), _19); const _45: boolean = boundsContain$i16_ops_RangeTo_i16({ end: b }, _19); const _47: boolean = boundsContain$i16_ops_RangeToInclusive_i16({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$i16_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i16Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.i16Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.i16Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.i16Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.i16 } = { end: b }; - const _82: { end: rt.i16 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.i16; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.i16; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.i16Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.i16Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.i16Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.i16 } = { end: b }; + const _82: { end: rs.i16 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.i16; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.i16; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.i16, rt.i16] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.i16Step)); - const start: rt.i16 = _94[0]; - const end: rt.i16 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i16Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.i16, rt.i16] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.i16Step); - const _107: { end: rt.i16 } = { end: b }; - const _109: { end: rt.i16; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.i16, rt.i16] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i16Debug(_111[0], f), (f: rt.Formatter) => rt.i16Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i16Debug(_113[0], f), (f: rt.Formatter) => rt.i16Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.i16 }, { end: rt.i16; inclusive: true }] = [new rt.RangeFrom(a, rt.i16Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.i16 } = _137[1]; - const through: { end: rt.i16; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.i16Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.i16, rt.i16]; + const _94: [rs.i16, rs.i16] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.i16Step)); + const start: rs.i16 = _94[0]; + const end: rs.i16 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.i16, rs.i16] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.i16Step); + const _107: { end: rs.i16 } = { end: b }; + const _109: { end: rs.i16; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.i16, rs.i16] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_111[0], f), (f: rs.Formatter) => rs.i16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i16Debug(_113[0], f), (f: rs.Formatter) => rs.i16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.i16 }, { end: rs.i16; inclusive: true }] = [new rs.RangeFrom(a, rs.i16Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.i16 } = _137[1]; + const through: { end: rs.i16; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i16Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.i16, rs.i16]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$i32(table: rt.i32[], at: rt.usize[], out: rt.ByteVec): [rt.i32, rt.i32] { - const _6: rt.i32[] = rt.arrayMap(at, (i: rt.usize): rt.i32 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$i32(table: rs.i32[], at: rs.usize[], out: rs.ByteVec): [rs.i32, rs.i32] { + const _6: rs.i32[] = rs.arrayMap(at, (i: rs.usize): rs.i32 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.i32 = _6[0]; - const b: rt.i32 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.i32Step))], (a0: boolean): rt.u8 => { + const a: rs.i32 = _6[0]; + const b: rs.i32 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.i32Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.i32Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.i32Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$i32_ops_Range_i32(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$i32_ops_RangeInclusive_i32(new rt.RangeInclusive(a, b, rt.i32Step), _19); - const _43: boolean = boundsContain$i32_ops_RangeFrom_i32(new rt.RangeFrom(a, rt.i32Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.i32Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.i32Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$i32_ops_Range_i32(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$i32_ops_RangeInclusive_i32(new rs.RangeInclusive(a, b, rs.i32Step), _19); + const _43: boolean = boundsContain$i32_ops_RangeFrom_i32(new rs.RangeFrom(a, rs.i32Step), _19); const _45: boolean = boundsContain$i32_ops_RangeTo_i32({ end: b }, _19); const _47: boolean = boundsContain$i32_ops_RangeToInclusive_i32({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$i32_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.i32Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.i32Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.i32 } = { end: b }; - const _82: { end: rt.i32 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.i32; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.i32Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.i32Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.i32 } = { end: b }; + const _82: { end: rs.i32 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.i32; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.i32, rt.i32] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.i32Step)); - const start: rt.i32 = _94[0]; - const end: rt.i32 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.i32, rt.i32] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); - const _107: { end: rt.i32 } = { end: b }; - const _109: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.i32, rt.i32] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i32Debug(_111[0], f), (f: rt.Formatter) => rt.i32Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i32Debug(_113[0], f), (f: rt.Formatter) => rt.i32Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.i32 }, { end: rt.i32; inclusive: true }] = [new rt.RangeFrom(a, rt.i32Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.i32 } = _137[1]; - const through: { end: rt.i32; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.i32Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.i32, rt.i32]; + const _94: [rs.i32, rs.i32] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.i32Step)); + const start: rs.i32 = _94[0]; + const end: rs.i32 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.i32, rs.i32] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); + const _107: { end: rs.i32 } = { end: b }; + const _109: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.i32, rs.i32] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_111[0], f), (f: rs.Formatter) => rs.i32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_113[0], f), (f: rs.Formatter) => rs.i32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.i32 }, { end: rs.i32; inclusive: true }] = [new rs.RangeFrom(a, rs.i32Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.i32 } = _137[1]; + const through: { end: rs.i32; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i32Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.i32, rs.i32]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$i64(table: rt.i64[], at: rt.usize[], out: rt.ByteVec): [rt.i64, rt.i64] { - const _6: rt.i64[] = rt.arrayMap(at, (i: rt.usize): rt.i64 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$i64(table: rs.i64[], at: rs.usize[], out: rs.ByteVec): [rs.i64, rs.i64] { + const _6: rs.i64[] = rs.arrayMap(at, (i: rs.usize): rs.i64 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.i64 = _6[0]; - const b: rt.i64 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.i64Step)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.i64Step))], (a0: boolean): rt.u8 => { + const a: rs.i64 = _6[0]; + const b: rs.i64 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.i64Step)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.i64Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.i64Step), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.i64Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.i64Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$i64_ops_Range_i64(new rt.Range(a, b, rt.i64Step), _19); - const _41: boolean = boundsContain$i64_ops_RangeInclusive_i64(new rt.RangeInclusive(a, b, rt.i64Step), _19); - const _43: boolean = boundsContain$i64_ops_RangeFrom_i64(new rt.RangeFrom(a, rt.i64Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.i64Step), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.i64Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.i64Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$i64_ops_Range_i64(new rs.Range(a, b, rs.i64Step), _19); + const _41: boolean = boundsContain$i64_ops_RangeInclusive_i64(new rs.RangeInclusive(a, b, rs.i64Step), _19); + const _43: boolean = boundsContain$i64_ops_RangeFrom_i64(new rs.RangeFrom(a, rs.i64Step), _19); const _45: boolean = boundsContain$i64_ops_RangeTo_i64({ end: b }, _19); const _47: boolean = boundsContain$i64_ops_RangeToInclusive_i64({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$i64_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.i64Step); - const _64: rt.Range = new rt.Range(_19, b, rt.i64Step); - const _60: boolean = rt.rangeEq(rt.i64Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i64Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.i64Step); - const _66: boolean = rt.rangeEq(rt.i64Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.i64Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.i64Step); - const _72: boolean = !rt.rangeEq(rt.i64Eq)(_74, _76); - const _80: { end: rt.i64 } = { end: b }; - const _82: { end: rt.i64 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.i64Eq)(_80, _82); - const _86: { end: rt.i64; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.i64; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.i64Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.i64Step); + const _64: rs.Range = new rs.Range(_19, b, rs.i64Step); + const _60: boolean = rs.rangeEq(rs.i64Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.i64Step); + const _66: boolean = rs.rangeEq(rs.i64Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.i64Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.i64Step); + const _72: boolean = !rs.rangeEq(rs.i64Eq)(_74, _76); + const _80: { end: rs.i64 } = { end: b }; + const _82: { end: rs.i64 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.i64Eq)(_80, _82); + const _86: { end: rs.i64; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.i64; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.i64Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.i64, rt.i64] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.i64Step)); - const start: rt.i64 = _94[0]; - const end: rt.i64 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i64Step); - const _102: rt.Range = new rt.Range(a, b, rt.i64Step); - const _113: [rt.i64, rt.i64] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.i64Step); - const _107: { end: rt.i64 } = { end: b }; - const _109: { end: rt.i64; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.i64, rt.i64] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i64Debug(_111[0], f), (f: rt.Formatter) => rt.i64Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i64Debug(_113[0], f), (f: rt.Formatter) => rt.i64Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.i64 }, { end: rt.i64; inclusive: true }] = [new rt.RangeFrom(a, rt.i64Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.i64 } = _137[1]; - const through: { end: rt.i64; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.i64Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.i64, rt.i64]; + const _94: [rs.i64, rs.i64] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.i64Step)); + const start: rs.i64 = _94[0]; + const end: rs.i64 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); + const _102: rs.Range = new rs.Range(a, b, rs.i64Step); + const _113: [rs.i64, rs.i64] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.i64Step); + const _107: { end: rs.i64 } = { end: b }; + const _109: { end: rs.i64; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.i64, rs.i64] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_111[0], f), (f: rs.Formatter) => rs.i64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i64Debug(_113[0], f), (f: rs.Formatter) => rs.i64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.i64 }, { end: rs.i64; inclusive: true }] = [new rs.RangeFrom(a, rs.i64Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.i64 } = _137[1]; + const through: { end: rs.i64; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i64Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.i64, rs.i64]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$i8(table: rt.i8[], at: rt.usize[], out: rt.ByteVec): [rt.i8, rt.i8] { - const _6: rt.i8[] = rt.arrayMap(at, (i: rt.usize): rt.i8 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$i8(table: rs.i8[], at: rs.usize[], out: rs.ByteVec): [rs.i8, rs.i8] { + const _6: rs.i8[] = rs.arrayMap(at, (i: rs.usize): rs.i8 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.i8 = _6[0]; - const b: rt.i8 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.i8Step))], (a0: boolean): rt.u8 => { + const a: rs.i8 = _6[0]; + const b: rs.i8 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.i8Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.i8Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.i8Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$i8_ops_Range_i8(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$i8_ops_RangeInclusive_i8(new rt.RangeInclusive(a, b, rt.i8Step), _19); - const _43: boolean = boundsContain$i8_ops_RangeFrom_i8(new rt.RangeFrom(a, rt.i8Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.i8Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.i8Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$i8_ops_Range_i8(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$i8_ops_RangeInclusive_i8(new rs.RangeInclusive(a, b, rs.i8Step), _19); + const _43: boolean = boundsContain$i8_ops_RangeFrom_i8(new rs.RangeFrom(a, rs.i8Step), _19); const _45: boolean = boundsContain$i8_ops_RangeTo_i8({ end: b }, _19); const _47: boolean = boundsContain$i8_ops_RangeToInclusive_i8({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$i8_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i8Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.i8Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.i8Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.i8Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.i8 } = { end: b }; - const _82: { end: rt.i8 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.i8; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.i8; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.i8Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.i8Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.i8Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.i8 } = { end: b }; + const _82: { end: rs.i8 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.i8; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.i8; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.i8, rt.i8] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.i8Step)); - const start: rt.i8 = _94[0]; - const end: rt.i8 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i8Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.i8, rt.i8] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.i8Step); - const _107: { end: rt.i8 } = { end: b }; - const _109: { end: rt.i8; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.i8, rt.i8] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i8Debug(_111[0], f), (f: rt.Formatter) => rt.i8Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i8Debug(_113[0], f), (f: rt.Formatter) => rt.i8Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.i8 }, { end: rt.i8; inclusive: true }] = [new rt.RangeFrom(a, rt.i8Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.i8 } = _137[1]; - const through: { end: rt.i8; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.i8Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.i8, rt.i8]; + const _94: [rs.i8, rs.i8] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.i8Step)); + const start: rs.i8 = _94[0]; + const end: rs.i8 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.i8, rs.i8] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.i8Step); + const _107: { end: rs.i8 } = { end: b }; + const _109: { end: rs.i8; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.i8, rs.i8] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_111[0], f), (f: rs.Formatter) => rs.i8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i8Debug(_113[0], f), (f: rs.Formatter) => rs.i8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.i8 }, { end: rs.i8; inclusive: true }] = [new rs.RangeFrom(a, rs.i8Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.i8 } = _137[1]; + const through: { end: rs.i8; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.i8Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.i8, rs.i8]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$isize(table: rt.isize[], at: rt.usize[], out: rt.ByteVec): [rt.isize, rt.isize] { - const _6: rt.isize[] = rt.arrayMap(at, (i: rt.usize): rt.isize => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$isize(table: rs.isize[], at: rs.usize[], out: rs.ByteVec): [rs.isize, rs.isize] { + const _6: rs.isize[] = rs.arrayMap(at, (i: rs.usize): rs.isize => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.isize = _6[0]; - const b: rt.isize = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.isizeStep))], (a0: boolean): rt.u8 => { + const a: rs.isize = _6[0]; + const b: rs.isize = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.isizeStep))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.isizeStep), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.isizeStep), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$isize_ops_Range_isize(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$isize_ops_RangeInclusive_isize(new rt.RangeInclusive(a, b, rt.isizeStep), _19); - const _43: boolean = boundsContain$isize_ops_RangeFrom_isize(new rt.RangeFrom(a, rt.isizeStep), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.isizeStep), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.isizeStep), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$isize_ops_Range_isize(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$isize_ops_RangeInclusive_isize(new rs.RangeInclusive(a, b, rs.isizeStep), _19); + const _43: boolean = boundsContain$isize_ops_RangeFrom_isize(new rs.RangeFrom(a, rs.isizeStep), _19); const _45: boolean = boundsContain$isize_ops_RangeTo_isize({ end: b }, _19); const _47: boolean = boundsContain$isize_ops_RangeToInclusive_isize({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$isize_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.isizeStep); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.isizeStep); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.isizeStep); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.isizeStep); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.isize } = { end: b }; - const _82: { end: rt.isize } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.isize; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.isize; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.isizeStep); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.isizeStep); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.isizeStep); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.isize } = { end: b }; + const _82: { end: rs.isize } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.isize; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.isize; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.isize, rt.isize] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.isizeStep)); - const start: rt.isize = _94[0]; - const end: rt.isize = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.isizeStep); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.isize, rt.isize] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.isizeStep); - const _107: { end: rt.isize } = { end: b }; - const _109: { end: rt.isize; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.isize, rt.isize] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.isizeDebug(_111[0], f), (f: rt.Formatter) => rt.isizeDebug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.isizeDebug(_113[0], f), (f: rt.Formatter) => rt.isizeDebug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.isize }, { end: rt.isize; inclusive: true }] = [new rt.RangeFrom(a, rt.isizeStep), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.isize } = _137[1]; - const through: { end: rt.isize; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.isizeDebug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.isize, rt.isize]; + const _94: [rs.isize, rs.isize] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.isizeStep)); + const start: rs.isize = _94[0]; + const end: rs.isize = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.isize, rs.isize] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.isizeStep); + const _107: { end: rs.isize } = { end: b }; + const _109: { end: rs.isize; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.isize, rs.isize] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_111[0], f), (f: rs.Formatter) => rs.isizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.isizeDebug(_113[0], f), (f: rs.Formatter) => rs.isizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.isize }, { end: rs.isize; inclusive: true }] = [new rs.RangeFrom(a, rs.isizeStep), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.isize } = _137[1]; + const through: { end: rs.isize; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.isizeDebug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.isize, rs.isize]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$num_NonZero_u128(table: rt.u128[], at: rt.usize[], out: rt.ByteVec): [rt.u128, rt.u128] { - const _6: rt.u128[] = rt.arrayMap(at, (i: rt.usize): rt.u128 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$num_NonZero_u128(table: rs.u128[], at: rs.usize[], out: rs.ByteVec): [rs.u128, rs.u128] { + const _6: rs.u128[] = rs.arrayMap(at, (i: rs.usize): rs.u128 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u128 = _6[0]; - const b: rt.u128 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128))), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)))], (a0: boolean): rt.u8 => { + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$num_NonZero_u128_ops_Range_num_NonZero_u128(new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); - const _41: boolean = boundsContain$num_NonZero_u128_ops_RangeInclusive_num_NonZero_u128(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); - const _43: boolean = boundsContain$num_NonZero_u128_ops_RangeFrom_num_NonZero_u128(new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$num_NonZero_u128_ops_Range_num_NonZero_u128(new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); + const _41: boolean = boundsContain$num_NonZero_u128_ops_RangeInclusive_num_NonZero_u128(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); + const _43: boolean = boundsContain$num_NonZero_u128_ops_RangeFrom_num_NonZero_u128(new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), _19); const _45: boolean = boundsContain$num_NonZero_u128_ops_RangeTo_num_NonZero_u128({ end: b }, _19); const _47: boolean = boundsContain$num_NonZero_u128_ops_RangeToInclusive_num_NonZero_u128({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$num_NonZero_u128_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _64: rt.Range = new rt.Range(_19, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _60: boolean = rt.rangeEq(rt.u128Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _66: boolean = rt.rangeEq(rt.u128Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _72: boolean = !rt.rangeEq(rt.u128Eq)(_74, _76); - const _80: { end: rt.u128 } = { end: b }; - const _82: { end: rt.u128 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.u128Eq)(_80, _82); - const _86: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u128; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.u128Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _64: rs.Range = new rs.Range(_19, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _60: boolean = rs.rangeEq(rs.u128Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _66: boolean = rs.rangeEq(rs.u128Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _72: boolean = !rs.rangeEq(rs.u128Eq)(_74, _76); + const _80: { end: rs.u128 } = { end: b }; + const _82: { end: rs.u128 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.u128Eq)(_80, _82); + const _86: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u128; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.u128Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u128, rt.u128] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128))); - const start: rt.u128 = _94[0]; - const end: rt.u128 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _102: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _113: [rt.u128, rt.u128] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _107: { end: rt.u128 } = { end: b }; - const _109: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u128, rt.u128] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u128Debug(_111[0], f), (f: rt.Formatter) => rt.u128Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u128Debug(_113[0], f), (f: rt.Formatter) => rt.u128Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u128 }, { end: rt.u128; inclusive: true }] = [new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u128 } = _137[1]; - const through: { end: rt.u128; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u128Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u128, rt.u128]; + const _94: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))); + const start: rs.u128 = _94[0]; + const end: rs.u128 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _102: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _113: [rs.u128, rs.u128] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _107: { end: rs.u128 } = { end: b }; + const _109: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u128, rs.u128] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u128 } = _137[1]; + const through: { end: rs.u128; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u128, rs.u128]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$num_NonZero_u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): [rt.u64, rt.u64] { - const _6: rt.u64[] = rt.arrayMap(at, (i: rt.usize): rt.u64 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$num_NonZero_u64(table: rs.u64[], at: rs.usize[], out: rs.ByteVec): [rs.u64, rs.u64] { + const _6: rs.u64[] = rs.arrayMap(at, (i: rs.usize): rs.u64 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u64 = _6[0]; - const b: rt.u64 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64))), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)))], (a0: boolean): rt.u8 => { + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$num_NonZero_u64_ops_Range_num_NonZero_u64(new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); - const _41: boolean = boundsContain$num_NonZero_u64_ops_RangeInclusive_num_NonZero_u64(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); - const _43: boolean = boundsContain$num_NonZero_u64_ops_RangeFrom_num_NonZero_u64(new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$num_NonZero_u64_ops_Range_num_NonZero_u64(new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); + const _41: boolean = boundsContain$num_NonZero_u64_ops_RangeInclusive_num_NonZero_u64(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); + const _43: boolean = boundsContain$num_NonZero_u64_ops_RangeFrom_num_NonZero_u64(new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), _19); const _45: boolean = boundsContain$num_NonZero_u64_ops_RangeTo_num_NonZero_u64({ end: b }, _19); const _47: boolean = boundsContain$num_NonZero_u64_ops_RangeToInclusive_num_NonZero_u64({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$num_NonZero_u64_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _64: rt.Range = new rt.Range(_19, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _60: boolean = rt.rangeEq(rt.u64Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _66: boolean = rt.rangeEq(rt.u64Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _72: boolean = !rt.rangeEq(rt.u64Eq)(_74, _76); - const _80: { end: rt.u64 } = { end: b }; - const _82: { end: rt.u64 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.u64Eq)(_80, _82); - const _86: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u64; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.u64Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _64: rs.Range = new rs.Range(_19, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _60: boolean = rs.rangeEq(rs.u64Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _66: boolean = rs.rangeEq(rs.u64Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _72: boolean = !rs.rangeEq(rs.u64Eq)(_74, _76); + const _80: { end: rs.u64 } = { end: b }; + const _82: { end: rs.u64 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.u64Eq)(_80, _82); + const _86: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u64; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.u64Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u64, rt.u64] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64))); - const start: rt.u64 = _94[0]; - const end: rt.u64 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _102: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _113: [rt.u64, rt.u64] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _107: { end: rt.u64 } = { end: b }; - const _109: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u64, rt.u64] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u64Debug(_111[0], f), (f: rt.Formatter) => rt.u64Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u64Debug(_113[0], f), (f: rt.Formatter) => rt.u64Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u64 }, { end: rt.u64; inclusive: true }] = [new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u64 } = _137[1]; - const through: { end: rt.u64; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u64Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u64, rt.u64]; + const _94: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))); + const start: rs.u64 = _94[0]; + const end: rs.u64 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _102: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _113: [rs.u64, rs.u64] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _107: { end: rs.u64 } = { end: b }; + const _109: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u64, rs.u64] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u64 } = _137[1]; + const through: { end: rs.u64; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u64, rs.u64]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$num_NonZero_u8(table: rt.u8[], at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { - const _6: rt.u8[] = rt.arrayMap(at, (i: rt.usize): rt.u8 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$num_NonZero_u8(table: rs.u8[], at: rs.usize[], out: rs.ByteVec): [rs.u8, rs.u8] { + const _6: rs.u8[] = rs.arrayMap(at, (i: rs.usize): rs.u8 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u8 = _6[0]; - const b: rt.u8 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)))], (a0: boolean): rt.u8 => { + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$num_NonZero_u8_ops_Range_num_NonZero_u8(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$num_NonZero_u8_ops_RangeInclusive_num_NonZero_u8(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)), _19); - const _43: boolean = boundsContain$num_NonZero_u8_ops_RangeFrom_num_NonZero_u8(new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$num_NonZero_u8_ops_Range_num_NonZero_u8(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$num_NonZero_u8_ops_RangeInclusive_num_NonZero_u8(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), _19); + const _43: boolean = boundsContain$num_NonZero_u8_ops_RangeFrom_num_NonZero_u8(new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), _19); const _45: boolean = boundsContain$num_NonZero_u8_ops_RangeTo_num_NonZero_u8({ end: b }, _19); const _47: boolean = boundsContain$num_NonZero_u8_ops_RangeToInclusive_num_NonZero_u8({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$num_NonZero_u8_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.nonZeroStep(rt.u8Step, 255)); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.nonZeroStep(rt.u8Step, 255)); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.u8 } = { end: b }; - const _82: { end: rt.u8 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u8; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.nonZeroStep(rs.u8Step, 255)); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.nonZeroStep(rs.u8Step, 255)); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.u8 } = { end: b }; + const _82: { end: rs.u8 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u8; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u8, rt.u8] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255))); - const start: rt.u8 = _94[0]; - const end: rt.u8 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.u8, rt.u8] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)); - const _107: { end: rt.u8 } = { end: b }; - const _109: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u8, rt.u8] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_111[0], f), (f: rt.Formatter) => rt.u8Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_113[0], f), (f: rt.Formatter) => rt.u8Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u8 }, { end: rt.u8; inclusive: true }] = [new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u8 } = _137[1]; - const through: { end: rt.u8; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u8Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u8, rt.u8]; + const _94: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255))); + const start: rs.u8 = _94[0]; + const end: rs.u8 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.u8, rs.u8] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)); + const _107: { end: rs.u8 } = { end: b }; + const _109: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u8, rs.u8] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u8 } = _137[1]; + const through: { end: rs.u8; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u8, rs.u8]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$num_NonZero_usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec): [rt.usize, rt.usize] { - const _6: rt.usize[] = rt.arrayMap(at, (i: rt.usize): rt.usize => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$num_NonZero_usize(table: rs.usize[], at: rs.usize[], out: rs.ByteVec): [rs.usize, rs.usize] { + const _6: rs.usize[] = rs.arrayMap(at, (i: rs.usize): rs.usize => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.usize = _6[0]; - const b: rt.usize = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)))], (a0: boolean): rt.u8 => { + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$num_NonZero_usize_ops_Range_num_NonZero_usize(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$num_NonZero_usize_ops_RangeInclusive_num_NonZero_usize(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)), _19); - const _43: boolean = boundsContain$num_NonZero_usize_ops_RangeFrom_num_NonZero_usize(new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$num_NonZero_usize_ops_Range_num_NonZero_usize(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$num_NonZero_usize_ops_RangeInclusive_num_NonZero_usize(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), _19); + const _43: boolean = boundsContain$num_NonZero_usize_ops_RangeFrom_num_NonZero_usize(new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), _19); const _45: boolean = boundsContain$num_NonZero_usize_ops_RangeTo_num_NonZero_usize({ end: b }, _19); const _47: boolean = boundsContain$num_NonZero_usize_ops_RangeToInclusive_num_NonZero_usize({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$num_NonZero_usize_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.usize } = { end: b }; - const _82: { end: rt.usize } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.usize; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.usize } = { end: b }; + const _82: { end: rs.usize } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.usize; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.usize, rt.usize] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295))); - const start: rt.usize = _94[0]; - const end: rt.usize = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.usize, rt.usize] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _107: { end: rt.usize } = { end: b }; - const _109: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.usize, rt.usize] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_111[0], f), (f: rt.Formatter) => rt.usizeDebug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_113[0], f), (f: rt.Formatter) => rt.usizeDebug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.usize }, { end: rt.usize; inclusive: true }] = [new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.usize } = _137[1]; - const through: { end: rt.usize; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.usizeDebug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.usize, rt.usize]; + const _94: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295))); + const start: rs.usize = _94[0]; + const end: rs.usize = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.usize, rs.usize] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _107: { end: rs.usize } = { end: b }; + const _109: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.usize, rs.usize] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.usize } = _137[1]; + const through: { end: rs.usize; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.usize, rs.usize]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u128(table: rt.u128[], at: rt.usize[], out: rt.ByteVec): [rt.u128, rt.u128] { - const _6: rt.u128[] = rt.arrayMap(at, (i: rt.usize): rt.u128 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$u128(table: rs.u128[], at: rs.usize[], out: rs.ByteVec): [rs.u128, rs.u128] { + const _6: rs.u128[] = rs.arrayMap(at, (i: rs.usize): rs.u128 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u128 = _6[0]; - const b: rt.u128 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.u128Step)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.u128Step))], (a0: boolean): rt.u8 => { + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.u128Step)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.u128Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.u128Step), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.u128Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.u128Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$u128_ops_Range_u128(new rt.Range(a, b, rt.u128Step), _19); - const _41: boolean = boundsContain$u128_ops_RangeInclusive_u128(new rt.RangeInclusive(a, b, rt.u128Step), _19); - const _43: boolean = boundsContain$u128_ops_RangeFrom_u128(new rt.RangeFrom(a, rt.u128Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.u128Step), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.u128Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.u128Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$u128_ops_Range_u128(new rs.Range(a, b, rs.u128Step), _19); + const _41: boolean = boundsContain$u128_ops_RangeInclusive_u128(new rs.RangeInclusive(a, b, rs.u128Step), _19); + const _43: boolean = boundsContain$u128_ops_RangeFrom_u128(new rs.RangeFrom(a, rs.u128Step), _19); const _45: boolean = boundsContain$u128_ops_RangeTo_u128({ end: b }, _19); const _47: boolean = boundsContain$u128_ops_RangeToInclusive_u128({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$u128_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.u128Step); - const _64: rt.Range = new rt.Range(_19, b, rt.u128Step); - const _60: boolean = rt.rangeEq(rt.u128Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u128Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.u128Step); - const _66: boolean = rt.rangeEq(rt.u128Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.u128Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.u128Step); - const _72: boolean = !rt.rangeEq(rt.u128Eq)(_74, _76); - const _80: { end: rt.u128 } = { end: b }; - const _82: { end: rt.u128 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.u128Eq)(_80, _82); - const _86: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u128; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.u128Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.u128Step); + const _64: rs.Range = new rs.Range(_19, b, rs.u128Step); + const _60: boolean = rs.rangeEq(rs.u128Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.u128Step); + const _66: boolean = rs.rangeEq(rs.u128Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.u128Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.u128Step); + const _72: boolean = !rs.rangeEq(rs.u128Eq)(_74, _76); + const _80: { end: rs.u128 } = { end: b }; + const _82: { end: rs.u128 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.u128Eq)(_80, _82); + const _86: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u128; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.u128Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u128, rt.u128] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.u128Step)); - const start: rt.u128 = _94[0]; - const end: rt.u128 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u128Step); - const _102: rt.Range = new rt.Range(a, b, rt.u128Step); - const _113: [rt.u128, rt.u128] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.u128Step); - const _107: { end: rt.u128 } = { end: b }; - const _109: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u128, rt.u128] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u128Debug(_111[0], f), (f: rt.Formatter) => rt.u128Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u128Debug(_113[0], f), (f: rt.Formatter) => rt.u128Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u128 }, { end: rt.u128; inclusive: true }] = [new rt.RangeFrom(a, rt.u128Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u128 } = _137[1]; - const through: { end: rt.u128; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u128Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u128, rt.u128]; + const _94: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.u128Step)); + const start: rs.u128 = _94[0]; + const end: rs.u128 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); + const _102: rs.Range = new rs.Range(a, b, rs.u128Step); + const _113: [rs.u128, rs.u128] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.u128Step); + const _107: { end: rs.u128 } = { end: b }; + const _109: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u128, rs.u128] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_111[0], f), (f: rs.Formatter) => rs.u128Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u128Debug(_113[0], f), (f: rs.Formatter) => rs.u128Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u128 }, { end: rs.u128; inclusive: true }] = [new rs.RangeFrom(a, rs.u128Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u128 } = _137[1]; + const through: { end: rs.u128; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u128Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u128, rs.u128]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u16(table: rt.u16[], at: rt.usize[], out: rt.ByteVec): [rt.u16, rt.u16] { - const _6: rt.u16[] = rt.arrayMap(at, (i: rt.usize): rt.u16 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$u16(table: rs.u16[], at: rs.usize[], out: rs.ByteVec): [rs.u16, rs.u16] { + const _6: rs.u16[] = rs.arrayMap(at, (i: rs.usize): rs.u16 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u16 = _6[0]; - const b: rt.u16 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.u16Step))], (a0: boolean): rt.u8 => { + const a: rs.u16 = _6[0]; + const b: rs.u16 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.u16Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.u16Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.u16Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$u16_ops_Range_u16(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$u16_ops_RangeInclusive_u16(new rt.RangeInclusive(a, b, rt.u16Step), _19); - const _43: boolean = boundsContain$u16_ops_RangeFrom_u16(new rt.RangeFrom(a, rt.u16Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.u16Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.u16Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$u16_ops_Range_u16(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$u16_ops_RangeInclusive_u16(new rs.RangeInclusive(a, b, rs.u16Step), _19); + const _43: boolean = boundsContain$u16_ops_RangeFrom_u16(new rs.RangeFrom(a, rs.u16Step), _19); const _45: boolean = boundsContain$u16_ops_RangeTo_u16({ end: b }, _19); const _47: boolean = boundsContain$u16_ops_RangeToInclusive_u16({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$u16_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u16Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.u16Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.u16Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.u16Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.u16 } = { end: b }; - const _82: { end: rt.u16 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.u16; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u16; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.u16Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.u16Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.u16Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.u16 } = { end: b }; + const _82: { end: rs.u16 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.u16; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u16; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u16, rt.u16] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.u16Step)); - const start: rt.u16 = _94[0]; - const end: rt.u16 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u16Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.u16, rt.u16] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.u16Step); - const _107: { end: rt.u16 } = { end: b }; - const _109: { end: rt.u16; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u16, rt.u16] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(_111[0], f), (f: rt.Formatter) => rt.u16Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u16Debug(_113[0], f), (f: rt.Formatter) => rt.u16Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u16 }, { end: rt.u16; inclusive: true }] = [new rt.RangeFrom(a, rt.u16Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u16 } = _137[1]; - const through: { end: rt.u16; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u16Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u16, rt.u16]; + const _94: [rs.u16, rs.u16] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.u16Step)); + const start: rs.u16 = _94[0]; + const end: rs.u16 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.u16, rs.u16] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.u16Step); + const _107: { end: rs.u16 } = { end: b }; + const _109: { end: rs.u16; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u16, rs.u16] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_111[0], f), (f: rs.Formatter) => rs.u16Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u16Debug(_113[0], f), (f: rs.Formatter) => rs.u16Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u16 }, { end: rs.u16; inclusive: true }] = [new rs.RangeFrom(a, rs.u16Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u16 } = _137[1]; + const through: { end: rs.u16; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u16Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u16, rs.u16]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u32(table: rt.u32[], at: rt.usize[], out: rt.ByteVec): [rt.u32, rt.u32] { - const _6: rt.u32[] = rt.arrayMap(at, (i: rt.usize): rt.u32 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$u32(table: rs.u32[], at: rs.usize[], out: rs.ByteVec): [rs.u32, rs.u32] { + const _6: rs.u32[] = rs.arrayMap(at, (i: rs.usize): rs.u32 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u32 = _6[0]; - const b: rt.u32 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.u32Step))], (a0: boolean): rt.u8 => { + const a: rs.u32 = _6[0]; + const b: rs.u32 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.u32Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.u32Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.u32Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$u32_ops_Range_u32(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$u32_ops_RangeInclusive_u32(new rt.RangeInclusive(a, b, rt.u32Step), _19); - const _43: boolean = boundsContain$u32_ops_RangeFrom_u32(new rt.RangeFrom(a, rt.u32Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.u32Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.u32Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$u32_ops_Range_u32(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$u32_ops_RangeInclusive_u32(new rs.RangeInclusive(a, b, rs.u32Step), _19); + const _43: boolean = boundsContain$u32_ops_RangeFrom_u32(new rs.RangeFrom(a, rs.u32Step), _19); const _45: boolean = boundsContain$u32_ops_RangeTo_u32({ end: b }, _19); const _47: boolean = boundsContain$u32_ops_RangeToInclusive_u32({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$u32_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u32Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.u32Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.u32Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.u32Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.u32 } = { end: b }; - const _82: { end: rt.u32 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.u32; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u32; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.u32Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.u32Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.u32Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.u32 } = { end: b }; + const _82: { end: rs.u32 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.u32; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u32; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u32, rt.u32] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.u32Step)); - const start: rt.u32 = _94[0]; - const end: rt.u32 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u32Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.u32, rt.u32] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.u32Step); - const _107: { end: rt.u32 } = { end: b }; - const _109: { end: rt.u32; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u32, rt.u32] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(_111[0], f), (f: rt.Formatter) => rt.u32Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(_113[0], f), (f: rt.Formatter) => rt.u32Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u32 }, { end: rt.u32; inclusive: true }] = [new rt.RangeFrom(a, rt.u32Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u32 } = _137[1]; - const through: { end: rt.u32; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u32Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u32, rt.u32]; + const _94: [rs.u32, rs.u32] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.u32Step)); + const start: rs.u32 = _94[0]; + const end: rs.u32 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.u32, rs.u32] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.u32Step); + const _107: { end: rs.u32 } = { end: b }; + const _109: { end: rs.u32; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u32, rs.u32] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_111[0], f), (f: rs.Formatter) => rs.u32Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(_113[0], f), (f: rs.Formatter) => rs.u32Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u32 }, { end: rs.u32; inclusive: true }] = [new rs.RangeFrom(a, rs.u32Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u32 } = _137[1]; + const through: { end: rs.u32; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u32Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u32, rs.u32]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): [rt.u64, rt.u64] { - const _6: rt.u64[] = rt.arrayMap(at, (i: rt.usize): rt.u64 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$u64(table: rs.u64[], at: rs.usize[], out: rs.ByteVec): [rs.u64, rs.u64] { + const _6: rs.u64[] = rs.arrayMap(at, (i: rs.usize): rs.u64 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.u64 = _6[0]; - const b: rt.u64 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b, rt.u64Step)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.u64Step))], (a0: boolean): rt.u8 => { + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b, rs.u64Step)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.u64Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b, rt.u64Step), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.u64Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.u64Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$u64_ops_Range_u64(new rt.Range(a, b, rt.u64Step), _19); - const _41: boolean = boundsContain$u64_ops_RangeInclusive_u64(new rt.RangeInclusive(a, b, rt.u64Step), _19); - const _43: boolean = boundsContain$u64_ops_RangeFrom_u64(new rt.RangeFrom(a, rt.u64Step), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b, rs.u64Step), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.u64Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.u64Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$u64_ops_Range_u64(new rs.Range(a, b, rs.u64Step), _19); + const _41: boolean = boundsContain$u64_ops_RangeInclusive_u64(new rs.RangeInclusive(a, b, rs.u64Step), _19); + const _43: boolean = boundsContain$u64_ops_RangeFrom_u64(new rs.RangeFrom(a, rs.u64Step), _19); const _45: boolean = boundsContain$u64_ops_RangeTo_u64({ end: b }, _19); const _47: boolean = boundsContain$u64_ops_RangeToInclusive_u64({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$u64_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b, rt.u64Step); - const _64: rt.Range = new rt.Range(_19, b, rt.u64Step); - const _60: boolean = rt.rangeEq(rt.u64Eq)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u64Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.u64Step); - const _66: boolean = rt.rangeEq(rt.u64Eq)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.u64Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.u64Step); - const _72: boolean = !rt.rangeEq(rt.u64Eq)(_74, _76); - const _80: { end: rt.u64 } = { end: b }; - const _82: { end: rt.u64 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.u64Eq)(_80, _82); - const _86: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u64; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.u64Eq)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b, rs.u64Step); + const _64: rs.Range = new rs.Range(_19, b, rs.u64Step); + const _60: boolean = rs.rangeEq(rs.u64Eq)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.u64Step); + const _66: boolean = rs.rangeEq(rs.u64Eq)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.u64Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.u64Step); + const _72: boolean = !rs.rangeEq(rs.u64Eq)(_74, _76); + const _80: { end: rs.u64 } = { end: b }; + const _82: { end: rs.u64 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.u64Eq)(_80, _82); + const _86: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u64; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.u64Eq)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u64, rt.u64] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.u64Step)); - const start: rt.u64 = _94[0]; - const end: rt.u64 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u64Step); - const _102: rt.Range = new rt.Range(a, b, rt.u64Step); - const _113: [rt.u64, rt.u64] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.u64Step); - const _107: { end: rt.u64 } = { end: b }; - const _109: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u64, rt.u64] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u64Debug(_111[0], f), (f: rt.Formatter) => rt.u64Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u64Debug(_113[0], f), (f: rt.Formatter) => rt.u64Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u64 }, { end: rt.u64; inclusive: true }] = [new rt.RangeFrom(a, rt.u64Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u64 } = _137[1]; - const through: { end: rt.u64; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u64Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u64, rt.u64]; + const _94: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.u64Step)); + const start: rs.u64 = _94[0]; + const end: rs.u64 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + const _102: rs.Range = new rs.Range(a, b, rs.u64Step); + const _113: [rs.u64, rs.u64] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.u64Step); + const _107: { end: rs.u64 } = { end: b }; + const _109: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u64, rs.u64] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_111[0], f), (f: rs.Formatter) => rs.u64Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u64Debug(_113[0], f), (f: rs.Formatter) => rs.u64Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u64 }, { end: rs.u64; inclusive: true }] = [new rs.RangeFrom(a, rs.u64Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u64 } = _137[1]; + const through: { end: rs.u64; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u64Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u64, rs.u64]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): [rt.u8, rt.u8] { - const _6: Uint8Array = rt.bytesMap(at, (i: rt.usize): rt.u8 => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec): [rs.u8, rs.u8] { + const _6: Uint8Array = rs.bytesMap(at, (i: rs.usize): rs.u8 => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table.data[table.start + _3]; }); - const a: rt.u8 = _6[0]; - const b: rt.u8 = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.u8Step))], (a0: boolean): rt.u8 => { + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.u8Step))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - for (const _19 of rt.byteSliceView(table)) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.u8Step), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.u8Step), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$u8_ops_Range_u8(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$u8_ops_RangeInclusive_u8(new rt.RangeInclusive(a, b, rt.u8Step), _19); - const _43: boolean = boundsContain$u8_ops_RangeFrom_u8(new rt.RangeFrom(a, rt.u8Step), _19); + for (const _19 of rs.byteSliceView(table)) { + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.u8Step), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.u8Step), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$u8_ops_Range_u8(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$u8_ops_RangeInclusive_u8(new rs.RangeInclusive(a, b, rs.u8Step), _19); + const _43: boolean = boundsContain$u8_ops_RangeFrom_u8(new rs.RangeFrom(a, rs.u8Step), _19); const _45: boolean = boundsContain$u8_ops_RangeTo_u8({ end: b }, _19); const _47: boolean = boundsContain$u8_ops_RangeToInclusive_u8({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$u8_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.u8Step); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.u8Step); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.u8Step); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.u8 } = { end: b }; - const _82: { end: rt.u8 } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.u8; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.u8Step); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.u8Step); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.u8Step); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.u8 } = { end: b }; + const _82: { end: rs.u8 } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.u8; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.u8, rt.u8] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.u8Step)); - const start: rt.u8 = _94[0]; - const end: rt.u8 = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.u8, rt.u8] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.u8Step); - const _107: { end: rt.u8 } = { end: b }; - const _109: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.u8, rt.u8] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_111[0], f), (f: rt.Formatter) => rt.u8Debug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_113[0], f), (f: rt.Formatter) => rt.u8Debug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.u8 }, { end: rt.u8; inclusive: true }] = [new rt.RangeFrom(a, rt.u8Step), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.u8 } = _137[1]; - const through: { end: rt.u8; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.u8Debug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.u8, rt.u8]; + const _94: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.u8Step)); + const start: rs.u8 = _94[0]; + const end: rs.u8 = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.u8, rs.u8] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.u8Step); + const _107: { end: rs.u8 } = { end: b }; + const _109: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.u8, rs.u8] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_111[0], f), (f: rs.Formatter) => rs.u8Debug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_113[0], f), (f: rs.Formatter) => rs.u8Debug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.u8 }, { end: rs.u8; inclusive: true }] = [new rs.RangeFrom(a, rs.u8Step), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.u8 } = _137[1]; + const through: { end: rs.u8; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.u8Debug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.u8, rs.u8]; } /** * Each range type's comparisons of `a` and `b`, from `table`, against each of its * values, and their `Debug`. */ -export function bounded$usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec): [rt.usize, rt.usize] { - const _6: rt.usize[] = rt.arrayMap(at, (i: rt.usize): rt.usize => { - const _3: rt.usize = rt.usizeRem(i, table.length); - rt.idx(table, _3); +export function bounded$usize(table: rs.usize[], at: rs.usize[], out: rs.ByteVec): [rs.usize, rs.usize] { + const _6: rs.usize[] = rs.arrayMap(at, (i: rs.usize): rs.usize => { + const _3: rs.usize = rs.usizeRem(i, table.length); + rs.idx(table, _3); return table[_3]; }); - const a: rt.usize = _6[0]; - const b: rt.usize = _6[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.rangeIsEmpty(new rt.Range(a, b)), rt.rangeInclusiveIsEmpty(new rt.RangeInclusive(a, b, rt.usizeStep))], (a0: boolean): rt.u8 => { + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.rangeIsEmpty(new rs.Range(a, b)), rs.rangeInclusiveIsEmpty(new rs.RangeInclusive(a, b, rs.usizeStep))], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); for (const _19 of table) { - const _24: boolean = rt.rangeContains(new rt.Range(a, b), _19); - const _27: boolean = rt.rangeInclusiveContains(new rt.RangeInclusive(a, b, rt.usizeStep), _19); - const _30: boolean = rt.rangeFromContains(new rt.RangeFrom(a, rt.usizeStep), _19); - const _33: boolean = rt.rangeToContains({ end: b }, _19); - const _36: boolean = rt.rangeToContains({ end: b, inclusive: true }, _19); - const _39: boolean = boundsContain$usize_ops_Range_usize(new rt.Range(a, b), _19); - const _41: boolean = boundsContain$usize_ops_RangeInclusive_usize(new rt.RangeInclusive(a, b, rt.usizeStep), _19); - const _43: boolean = boundsContain$usize_ops_RangeFrom_usize(new rt.RangeFrom(a, rt.usizeStep), _19); + const _24: boolean = rs.rangeContains(new rs.Range(a, b), _19); + const _27: boolean = rs.rangeInclusiveContains(new rs.RangeInclusive(a, b, rs.usizeStep), _19); + const _30: boolean = rs.rangeFromContains(new rs.RangeFrom(a, rs.usizeStep), _19); + const _33: boolean = rs.rangeToContains({ end: b }, _19); + const _36: boolean = rs.rangeToContains({ end: b, inclusive: true }, _19); + const _39: boolean = boundsContain$usize_ops_Range_usize(new rs.Range(a, b), _19); + const _41: boolean = boundsContain$usize_ops_RangeInclusive_usize(new rs.RangeInclusive(a, b, rs.usizeStep), _19); + const _43: boolean = boundsContain$usize_ops_RangeFrom_usize(new rs.RangeFrom(a, rs.usizeStep), _19); const _45: boolean = boundsContain$usize_ops_RangeTo_usize({ end: b }, _19); const _47: boolean = boundsContain$usize_ops_RangeToInclusive_usize({ end: b, inclusive: true }, _19); const _49: boolean = boundsContain$usize_ops_RangeFull(undefined, _19); - const _50: boolean = rt.boundsContains([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _55: boolean = rt.boundsContains([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], _19); - const _62: rt.Range = new rt.Range(a, b); - const _64: rt.Range = new rt.Range(_19, b); - const _60: boolean = rt.rangeEq(rt.same)(_62, _64); - const _68: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, _19, rt.usizeStep); - const _66: boolean = rt.rangeEq(rt.same)(_68, _70); - const _74: rt.RangeFrom = new rt.RangeFrom(a, rt.usizeStep); - const _76: rt.RangeFrom = new rt.RangeFrom(_19, rt.usizeStep); - const _72: boolean = !rt.rangeEq(rt.same)(_74, _76); - const _80: { end: rt.usize } = { end: b }; - const _82: { end: rt.usize } = { end: _19 }; - const _78: boolean = rt.rangeEq(rt.same)(_80, _82); - const _86: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - const _88: { end: rt.usize; inclusive: true } = { end: _19, inclusive: true }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rt.rangeEq(rt.same)(_86, _88)], (a02: boolean): rt.u8 => { + const _50: boolean = rs.boundsContains([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _55: boolean = rs.boundsContains([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], _19); + const _62: rs.Range = new rs.Range(a, b); + const _64: rs.Range = new rs.Range(_19, b); + const _60: boolean = rs.rangeEq(rs.same)(_62, _64); + const _68: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, _19, rs.usizeStep); + const _66: boolean = rs.rangeEq(rs.same)(_68, _70); + const _74: rs.RangeFrom = new rs.RangeFrom(a, rs.usizeStep); + const _76: rs.RangeFrom = new rs.RangeFrom(_19, rs.usizeStep); + const _72: boolean = !rs.rangeEq(rs.same)(_74, _76); + const _80: { end: rs.usize } = { end: b }; + const _82: { end: rs.usize } = { end: _19 }; + const _78: boolean = rs.rangeEq(rs.same)(_80, _82); + const _86: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + const _88: { end: rs.usize; inclusive: true } = { end: _19, inclusive: true }; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_24, _27, _30, _33, _36, _39, _41, _43, _45, _47, _49, _50, _55, _60, _66, _72, _78, !rs.rangeEq(rs.same)(_86, _88)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); } - const _94: [rt.usize, rt.usize] = rt.rangeInclusiveIntoInner(new rt.RangeInclusive(a, b, rt.usizeStep)); - const start: rt.usize = _94[0]; - const end: rt.usize = _94[1]; - const inclusive: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const _102: rt.Range = new rt.Range(a, b); - const _113: [rt.usize, rt.usize] = [rt.rangeInclusiveStart(inclusive), rt.rangeInclusiveEnd(inclusive)]; - const _105: rt.RangeFrom = new rt.RangeFrom(a, rt.usizeStep); - const _107: { end: rt.usize } = { end: b }; - const _109: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - const _111: [rt.usize, rt.usize] = [start, end]; - const _118: [undefined, [undefined, rt.Range]] = [undefined, [undefined, new rt.Range(1, 2)]]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_102, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(inclusive, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeFrom(_105, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeTo(_107, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_109, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_111[0], f), (f: rt.Formatter) => rt.usizeDebug(_111[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_113[0], f), (f: rt.Formatter) => rt.usizeDebug(_113[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[0], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtRangeFull(_118[1][0], f), (f: rt.Formatter) => rt.fmtRange(_118[1][1], f, rt.i32Debug)], f)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); - const _137: [rt.RangeFrom, { end: rt.usize }, { end: rt.usize; inclusive: true }] = [new rt.RangeFrom(a, rt.usizeStep), { end: b }, { end: b, inclusive: true }]; - const from: rt.RangeFrom = _137[0]; - const to: { end: rt.usize } = _137[1]; - const through: { end: rt.usize; inclusive: true } = _137[2]; - const part = [rt.rangeInclusiveStartBound(inclusive) as rt.RangeBound, rt.rangeInclusiveEndBound(inclusive) as rt.RangeBound, { tag: "Included", _0: from.start } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound, { tag: "Excluded", _0: to.end } as rt.RangeBound, { tag: "Included", _0: through.end } as rt.RangeBound]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, rt.usizeDebug))]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0]])), undefined, true); - return [a, b] as [rt.usize, rt.usize]; + const _94: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(new rs.RangeInclusive(a, b, rs.usizeStep)); + const start: rs.usize = _94[0]; + const end: rs.usize = _94[1]; + const inclusive: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const _102: rs.Range = new rs.Range(a, b); + const _113: [rs.usize, rs.usize] = [rs.rangeInclusiveStart(inclusive), rs.rangeInclusiveEnd(inclusive)]; + const _105: rs.RangeFrom = new rs.RangeFrom(a, rs.usizeStep); + const _107: { end: rs.usize } = { end: b }; + const _109: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + const _111: [rs.usize, rs.usize] = [start, end]; + const _118: [undefined, [undefined, rs.Range]] = [undefined, [undefined, new rs.Range(1, 2)]]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_102, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(inclusive, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeFrom(_105, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeTo(_107, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_109, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_111[0], f), (f: rs.Formatter) => rs.usizeDebug(_111[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_113[0], f), (f: rs.Formatter) => rs.usizeDebug(_113[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[0], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtRangeFull(_118[1][0], f), (f: rs.Formatter) => rs.fmtRange(_118[1][1], f, rs.i32Debug)], f)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7]])), undefined, true); + const _137: [rs.RangeFrom, { end: rs.usize }, { end: rs.usize; inclusive: true }] = [new rs.RangeFrom(a, rs.usizeStep), { end: b }, { end: b, inclusive: true }]; + const from: rs.RangeFrom = _137[0]; + const to: { end: rs.usize } = _137[1]; + const through: { end: rs.usize; inclusive: true } = _137[2]; + const part = [rs.rangeInclusiveStartBound(inclusive) as rs.RangeBound, rs.rangeInclusiveEndBound(inclusive) as rs.RangeBound, { tag: "Included", _0: from.start } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound, { tag: "Excluded", _0: to.end } as rs.RangeBound, { tag: "Included", _0: through.end } as rs.RangeBound]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, rs.usizeDebug))]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0]])), undefined, true); + return [a, b] as [rs.usize, rs.usize]; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_RangeFrom_char(r: rt.RangeFrom, x: rt.char): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$char_ops_RangeFrom_char(r: rs.RangeFrom, x: rs.char): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_RangeFull(_: undefined, _x: rt.char): boolean { +export function boundsContain$char_ops_RangeFull(_: undefined, _x: rs.char): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_RangeInclusive_char(r: rt.RangeInclusive, x: rt.char): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$char_ops_RangeInclusive_char(r: rs.RangeInclusive, x: rs.char): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_RangeToInclusive_char(r: { end: rt.char; inclusive: true }, x: rt.char): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$char_ops_RangeToInclusive_char(r: { end: rs.char; inclusive: true }, x: rs.char): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_RangeTo_char(r: { end: rt.char }, x: rt.char): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$char_ops_RangeTo_char(r: { end: rs.char }, x: rs.char): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$char_ops_Range_char(r: rt.Range, x: rt.char): boolean { - return rt.rangeContains(r, x); +export function boundsContain$char_ops_Range_char(r: rs.Range, x: rs.char): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_RangeFrom_f32(r: rt.RangeFrom, x: rt.f32): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$f32_ops_RangeFrom_f32(r: rs.RangeFrom, x: rs.f32): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_RangeFull(_: undefined, _x: rt.f32): boolean { +export function boundsContain$f32_ops_RangeFull(_: undefined, _x: rs.f32): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_RangeInclusive_f32(r: rt.RangeInclusive, x: rt.f32): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$f32_ops_RangeInclusive_f32(r: rs.RangeInclusive, x: rs.f32): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_RangeToInclusive_f32(r: { end: rt.f32; inclusive: true }, x: rt.f32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$f32_ops_RangeToInclusive_f32(r: { end: rs.f32; inclusive: true }, x: rs.f32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_RangeTo_f32(r: { end: rt.f32 }, x: rt.f32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$f32_ops_RangeTo_f32(r: { end: rs.f32 }, x: rs.f32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f32_ops_Range_f32(r: rt.Range, x: rt.f32): boolean { - return rt.rangeContains(r, x); +export function boundsContain$f32_ops_Range_f32(r: rs.Range, x: rs.f32): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_RangeFrom_f64(r: rt.RangeFrom, x: rt.f64): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$f64_ops_RangeFrom_f64(r: rs.RangeFrom, x: rs.f64): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_RangeFull(_: undefined, _x: rt.f64): boolean { +export function boundsContain$f64_ops_RangeFull(_: undefined, _x: rs.f64): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_RangeInclusive_f64(r: rt.RangeInclusive, x: rt.f64): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$f64_ops_RangeInclusive_f64(r: rs.RangeInclusive, x: rs.f64): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_RangeToInclusive_f64(r: { end: rt.f64; inclusive: true }, x: rt.f64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$f64_ops_RangeToInclusive_f64(r: { end: rs.f64; inclusive: true }, x: rs.f64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_RangeTo_f64(r: { end: rt.f64 }, x: rt.f64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$f64_ops_RangeTo_f64(r: { end: rs.f64 }, x: rs.f64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$f64_ops_Range_f64(r: rt.Range, x: rt.f64): boolean { - return rt.rangeContains(r, x); +export function boundsContain$f64_ops_Range_f64(r: rs.Range, x: rs.f64): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_RangeFrom_i128(r: rt.RangeFrom, x: rt.i128): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$i128_ops_RangeFrom_i128(r: rs.RangeFrom, x: rs.i128): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_RangeFull(_: undefined, _x: rt.i128): boolean { +export function boundsContain$i128_ops_RangeFull(_: undefined, _x: rs.i128): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_RangeInclusive_i128(r: rt.RangeInclusive, x: rt.i128): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$i128_ops_RangeInclusive_i128(r: rs.RangeInclusive, x: rs.i128): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_RangeToInclusive_i128(r: { end: rt.i128; inclusive: true }, x: rt.i128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i128_ops_RangeToInclusive_i128(r: { end: rs.i128; inclusive: true }, x: rs.i128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_RangeTo_i128(r: { end: rt.i128 }, x: rt.i128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i128_ops_RangeTo_i128(r: { end: rs.i128 }, x: rs.i128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i128_ops_Range_i128(r: rt.Range, x: rt.i128): boolean { - return rt.rangeContains(r, x); +export function boundsContain$i128_ops_Range_i128(r: rs.Range, x: rs.i128): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_RangeFrom_i16(r: rt.RangeFrom, x: rt.i16): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$i16_ops_RangeFrom_i16(r: rs.RangeFrom, x: rs.i16): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_RangeFull(_: undefined, _x: rt.i16): boolean { +export function boundsContain$i16_ops_RangeFull(_: undefined, _x: rs.i16): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_RangeInclusive_i16(r: rt.RangeInclusive, x: rt.i16): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$i16_ops_RangeInclusive_i16(r: rs.RangeInclusive, x: rs.i16): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_RangeToInclusive_i16(r: { end: rt.i16; inclusive: true }, x: rt.i16): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i16_ops_RangeToInclusive_i16(r: { end: rs.i16; inclusive: true }, x: rs.i16): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_RangeTo_i16(r: { end: rt.i16 }, x: rt.i16): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i16_ops_RangeTo_i16(r: { end: rs.i16 }, x: rs.i16): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i16_ops_Range_i16(r: rt.Range, x: rt.i16): boolean { - return rt.rangeContains(r, x); +export function boundsContain$i16_ops_Range_i16(r: rs.Range, x: rs.i16): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_RangeFrom_i32(r: rt.RangeFrom, x: rt.i32): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$i32_ops_RangeFrom_i32(r: rs.RangeFrom, x: rs.i32): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_RangeFull(_: undefined, _x: rt.i32): boolean { +export function boundsContain$i32_ops_RangeFull(_: undefined, _x: rs.i32): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_RangeInclusive_i32(r: rt.RangeInclusive, x: rt.i32): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$i32_ops_RangeInclusive_i32(r: rs.RangeInclusive, x: rs.i32): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_RangeToInclusive_i32(r: { end: rt.i32; inclusive: true }, x: rt.i32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i32_ops_RangeToInclusive_i32(r: { end: rs.i32; inclusive: true }, x: rs.i32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_RangeTo_i32(r: { end: rt.i32 }, x: rt.i32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i32_ops_RangeTo_i32(r: { end: rs.i32 }, x: rs.i32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i32_ops_Range_i32(r: rt.Range, x: rt.i32): boolean { - return rt.rangeContains(r, x); +export function boundsContain$i32_ops_Range_i32(r: rs.Range, x: rs.i32): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_RangeFrom_i64(r: rt.RangeFrom, x: rt.i64): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$i64_ops_RangeFrom_i64(r: rs.RangeFrom, x: rs.i64): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_RangeFull(_: undefined, _x: rt.i64): boolean { +export function boundsContain$i64_ops_RangeFull(_: undefined, _x: rs.i64): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_RangeInclusive_i64(r: rt.RangeInclusive, x: rt.i64): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$i64_ops_RangeInclusive_i64(r: rs.RangeInclusive, x: rs.i64): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_RangeToInclusive_i64(r: { end: rt.i64; inclusive: true }, x: rt.i64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i64_ops_RangeToInclusive_i64(r: { end: rs.i64; inclusive: true }, x: rs.i64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_RangeTo_i64(r: { end: rt.i64 }, x: rt.i64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i64_ops_RangeTo_i64(r: { end: rs.i64 }, x: rs.i64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i64_ops_Range_i64(r: rt.Range, x: rt.i64): boolean { - return rt.rangeContains(r, x); +export function boundsContain$i64_ops_Range_i64(r: rs.Range, x: rs.i64): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_RangeFrom_i8(r: rt.RangeFrom, x: rt.i8): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$i8_ops_RangeFrom_i8(r: rs.RangeFrom, x: rs.i8): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_RangeFull(_: undefined, _x: rt.i8): boolean { +export function boundsContain$i8_ops_RangeFull(_: undefined, _x: rs.i8): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_RangeInclusive_i8(r: rt.RangeInclusive, x: rt.i8): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$i8_ops_RangeInclusive_i8(r: rs.RangeInclusive, x: rs.i8): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_RangeToInclusive_i8(r: { end: rt.i8; inclusive: true }, x: rt.i8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i8_ops_RangeToInclusive_i8(r: { end: rs.i8; inclusive: true }, x: rs.i8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_RangeTo_i8(r: { end: rt.i8 }, x: rt.i8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$i8_ops_RangeTo_i8(r: { end: rs.i8 }, x: rs.i8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$i8_ops_Range_i8(r: rt.Range, x: rt.i8): boolean { - return rt.rangeContains(r, x); +export function boundsContain$i8_ops_Range_i8(r: rs.Range, x: rs.i8): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_RangeFrom_isize(r: rt.RangeFrom, x: rt.isize): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$isize_ops_RangeFrom_isize(r: rs.RangeFrom, x: rs.isize): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_RangeFull(_: undefined, _x: rt.isize): boolean { +export function boundsContain$isize_ops_RangeFull(_: undefined, _x: rs.isize): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_RangeInclusive_isize(r: rt.RangeInclusive, x: rt.isize): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$isize_ops_RangeInclusive_isize(r: rs.RangeInclusive, x: rs.isize): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_RangeToInclusive_isize(r: { end: rt.isize; inclusive: true }, x: rt.isize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$isize_ops_RangeToInclusive_isize(r: { end: rs.isize; inclusive: true }, x: rs.isize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_RangeTo_isize(r: { end: rt.isize }, x: rt.isize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$isize_ops_RangeTo_isize(r: { end: rs.isize }, x: rs.isize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$isize_ops_Range_isize(r: rt.Range, x: rt.isize): boolean { - return rt.rangeContains(r, x); +export function boundsContain$isize_ops_Range_isize(r: rs.Range, x: rs.isize): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_RangeFrom_num_NonZero_u128(r: rt.RangeFrom, x: rt.u128): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$num_NonZero_u128_ops_RangeFrom_num_NonZero_u128(r: rs.RangeFrom, x: rs.u128): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_RangeFull(_: undefined, _x: rt.u128): boolean { +export function boundsContain$num_NonZero_u128_ops_RangeFull(_: undefined, _x: rs.u128): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_RangeInclusive_num_NonZero_u128(r: rt.RangeInclusive, x: rt.u128): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$num_NonZero_u128_ops_RangeInclusive_num_NonZero_u128(r: rs.RangeInclusive, x: rs.u128): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_RangeToInclusive_num_NonZero_u128(r: { end: rt.u128; inclusive: true }, x: rt.u128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u128_ops_RangeToInclusive_num_NonZero_u128(r: { end: rs.u128; inclusive: true }, x: rs.u128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_RangeTo_num_NonZero_u128(r: { end: rt.u128 }, x: rt.u128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u128_ops_RangeTo_num_NonZero_u128(r: { end: rs.u128 }, x: rs.u128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u128_ops_Range_num_NonZero_u128(r: rt.Range, x: rt.u128): boolean { - return rt.rangeContains(r, x); +export function boundsContain$num_NonZero_u128_ops_Range_num_NonZero_u128(r: rs.Range, x: rs.u128): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_RangeFrom_num_NonZero_u64(r: rt.RangeFrom, x: rt.u64): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$num_NonZero_u64_ops_RangeFrom_num_NonZero_u64(r: rs.RangeFrom, x: rs.u64): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_RangeFull(_: undefined, _x: rt.u64): boolean { +export function boundsContain$num_NonZero_u64_ops_RangeFull(_: undefined, _x: rs.u64): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_RangeInclusive_num_NonZero_u64(r: rt.RangeInclusive, x: rt.u64): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$num_NonZero_u64_ops_RangeInclusive_num_NonZero_u64(r: rs.RangeInclusive, x: rs.u64): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_RangeToInclusive_num_NonZero_u64(r: { end: rt.u64; inclusive: true }, x: rt.u64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u64_ops_RangeToInclusive_num_NonZero_u64(r: { end: rs.u64; inclusive: true }, x: rs.u64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_RangeTo_num_NonZero_u64(r: { end: rt.u64 }, x: rt.u64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u64_ops_RangeTo_num_NonZero_u64(r: { end: rs.u64 }, x: rs.u64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u64_ops_Range_num_NonZero_u64(r: rt.Range, x: rt.u64): boolean { - return rt.rangeContains(r, x); +export function boundsContain$num_NonZero_u64_ops_Range_num_NonZero_u64(r: rs.Range, x: rs.u64): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_RangeFrom_num_NonZero_u8(r: rt.RangeFrom, x: rt.u8): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$num_NonZero_u8_ops_RangeFrom_num_NonZero_u8(r: rs.RangeFrom, x: rs.u8): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_RangeFull(_: undefined, _x: rt.u8): boolean { +export function boundsContain$num_NonZero_u8_ops_RangeFull(_: undefined, _x: rs.u8): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_RangeInclusive_num_NonZero_u8(r: rt.RangeInclusive, x: rt.u8): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$num_NonZero_u8_ops_RangeInclusive_num_NonZero_u8(r: rs.RangeInclusive, x: rs.u8): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_RangeToInclusive_num_NonZero_u8(r: { end: rt.u8; inclusive: true }, x: rt.u8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u8_ops_RangeToInclusive_num_NonZero_u8(r: { end: rs.u8; inclusive: true }, x: rs.u8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_RangeTo_num_NonZero_u8(r: { end: rt.u8 }, x: rt.u8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_u8_ops_RangeTo_num_NonZero_u8(r: { end: rs.u8 }, x: rs.u8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_u8_ops_Range_num_NonZero_u8(r: rt.Range, x: rt.u8): boolean { - return rt.rangeContains(r, x); +export function boundsContain$num_NonZero_u8_ops_Range_num_NonZero_u8(r: rs.Range, x: rs.u8): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_RangeFrom_num_NonZero_usize(r: rt.RangeFrom, x: rt.usize): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$num_NonZero_usize_ops_RangeFrom_num_NonZero_usize(r: rs.RangeFrom, x: rs.usize): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_RangeFull(_: undefined, _x: rt.usize): boolean { +export function boundsContain$num_NonZero_usize_ops_RangeFull(_: undefined, _x: rs.usize): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_RangeInclusive_num_NonZero_usize(r: rt.RangeInclusive, x: rt.usize): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$num_NonZero_usize_ops_RangeInclusive_num_NonZero_usize(r: rs.RangeInclusive, x: rs.usize): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_RangeToInclusive_num_NonZero_usize(r: { end: rt.usize; inclusive: true }, x: rt.usize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_usize_ops_RangeToInclusive_num_NonZero_usize(r: { end: rs.usize; inclusive: true }, x: rs.usize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_RangeTo_num_NonZero_usize(r: { end: rt.usize }, x: rt.usize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$num_NonZero_usize_ops_RangeTo_num_NonZero_usize(r: { end: rs.usize }, x: rs.usize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$num_NonZero_usize_ops_Range_num_NonZero_usize(r: rt.Range, x: rt.usize): boolean { - return rt.rangeContains(r, x); +export function boundsContain$num_NonZero_usize_ops_Range_num_NonZero_usize(r: rs.Range, x: rs.usize): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_RangeFrom_u128(r: rt.RangeFrom, x: rt.u128): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$u128_ops_RangeFrom_u128(r: rs.RangeFrom, x: rs.u128): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_RangeFull(_: undefined, _x: rt.u128): boolean { +export function boundsContain$u128_ops_RangeFull(_: undefined, _x: rs.u128): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_RangeInclusive_u128(r: rt.RangeInclusive, x: rt.u128): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$u128_ops_RangeInclusive_u128(r: rs.RangeInclusive, x: rs.u128): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_RangeToInclusive_u128(r: { end: rt.u128; inclusive: true }, x: rt.u128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u128_ops_RangeToInclusive_u128(r: { end: rs.u128; inclusive: true }, x: rs.u128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_RangeTo_u128(r: { end: rt.u128 }, x: rt.u128): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u128_ops_RangeTo_u128(r: { end: rs.u128 }, x: rs.u128): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u128_ops_Range_u128(r: rt.Range, x: rt.u128): boolean { - return rt.rangeContains(r, x); +export function boundsContain$u128_ops_Range_u128(r: rs.Range, x: rs.u128): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_RangeFrom_u16(r: rt.RangeFrom, x: rt.u16): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$u16_ops_RangeFrom_u16(r: rs.RangeFrom, x: rs.u16): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_RangeFull(_: undefined, _x: rt.u16): boolean { +export function boundsContain$u16_ops_RangeFull(_: undefined, _x: rs.u16): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_RangeInclusive_u16(r: rt.RangeInclusive, x: rt.u16): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$u16_ops_RangeInclusive_u16(r: rs.RangeInclusive, x: rs.u16): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_RangeToInclusive_u16(r: { end: rt.u16; inclusive: true }, x: rt.u16): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u16_ops_RangeToInclusive_u16(r: { end: rs.u16; inclusive: true }, x: rs.u16): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_RangeTo_u16(r: { end: rt.u16 }, x: rt.u16): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u16_ops_RangeTo_u16(r: { end: rs.u16 }, x: rs.u16): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u16_ops_Range_u16(r: rt.Range, x: rt.u16): boolean { - return rt.rangeContains(r, x); +export function boundsContain$u16_ops_Range_u16(r: rs.Range, x: rs.u16): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_RangeFrom_u32(r: rt.RangeFrom, x: rt.u32): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$u32_ops_RangeFrom_u32(r: rs.RangeFrom, x: rs.u32): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_RangeFull(_: undefined, _x: rt.u32): boolean { +export function boundsContain$u32_ops_RangeFull(_: undefined, _x: rs.u32): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_RangeInclusive_u32(r: rt.RangeInclusive, x: rt.u32): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$u32_ops_RangeInclusive_u32(r: rs.RangeInclusive, x: rs.u32): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_RangeToInclusive_u32(r: { end: rt.u32; inclusive: true }, x: rt.u32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u32_ops_RangeToInclusive_u32(r: { end: rs.u32; inclusive: true }, x: rs.u32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_RangeTo_u32(r: { end: rt.u32 }, x: rt.u32): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u32_ops_RangeTo_u32(r: { end: rs.u32 }, x: rs.u32): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u32_ops_Range_u32(r: rt.Range, x: rt.u32): boolean { - return rt.rangeContains(r, x); +export function boundsContain$u32_ops_Range_u32(r: rs.Range, x: rs.u32): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_RangeFrom_u64(r: rt.RangeFrom, x: rt.u64): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$u64_ops_RangeFrom_u64(r: rs.RangeFrom, x: rs.u64): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_RangeFull(_: undefined, _x: rt.u64): boolean { +export function boundsContain$u64_ops_RangeFull(_: undefined, _x: rs.u64): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_RangeInclusive_u64(r: rt.RangeInclusive, x: rt.u64): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$u64_ops_RangeInclusive_u64(r: rs.RangeInclusive, x: rs.u64): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_RangeToInclusive_u64(r: { end: rt.u64; inclusive: true }, x: rt.u64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u64_ops_RangeToInclusive_u64(r: { end: rs.u64; inclusive: true }, x: rs.u64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_RangeTo_u64(r: { end: rt.u64 }, x: rt.u64): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u64_ops_RangeTo_u64(r: { end: rs.u64 }, x: rs.u64): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u64_ops_Range_u64(r: rt.Range, x: rt.u64): boolean { - return rt.rangeContains(r, x); +export function boundsContain$u64_ops_Range_u64(r: rs.Range, x: rs.u64): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_RangeFrom_u8(r: rt.RangeFrom, x: rt.u8): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$u8_ops_RangeFrom_u8(r: rs.RangeFrom, x: rs.u8): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_RangeFull(_: undefined, _x: rt.u8): boolean { +export function boundsContain$u8_ops_RangeFull(_: undefined, _x: rs.u8): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_RangeInclusive_u8(r: rt.RangeInclusive, x: rt.u8): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$u8_ops_RangeInclusive_u8(r: rs.RangeInclusive, x: rs.u8): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_RangeToInclusive_u8(r: { end: rt.u8; inclusive: true }, x: rt.u8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u8_ops_RangeToInclusive_u8(r: { end: rs.u8; inclusive: true }, x: rs.u8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_RangeTo_u8(r: { end: rt.u8 }, x: rt.u8): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$u8_ops_RangeTo_u8(r: { end: rs.u8 }, x: rs.u8): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$u8_ops_Range_u8(r: rt.Range, x: rt.u8): boolean { - return rt.rangeContains(r, x); +export function boundsContain$u8_ops_Range_u8(r: rs.Range, x: rs.u8): boolean { + return rs.rangeContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_RangeFrom_usize(r: rt.RangeFrom, x: rt.usize): boolean { - return rt.rangeFromContains(r, x); +export function boundsContain$usize_ops_RangeFrom_usize(r: rs.RangeFrom, x: rs.usize): boolean { + return rs.rangeFromContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_RangeFull(_: undefined, _x: rt.usize): boolean { +export function boundsContain$usize_ops_RangeFull(_: undefined, _x: rs.usize): boolean { return true; } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_RangeInclusive_usize(r: rt.RangeInclusive, x: rt.usize): boolean { - return rt.rangeInclusiveContains(r, x); +export function boundsContain$usize_ops_RangeInclusive_usize(r: rs.RangeInclusive, x: rs.usize): boolean { + return rs.rangeInclusiveContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_RangeToInclusive_usize(r: { end: rt.usize; inclusive: true }, x: rt.usize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$usize_ops_RangeToInclusive_usize(r: { end: rs.usize; inclusive: true }, x: rs.usize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_RangeTo_usize(r: { end: rt.usize }, x: rt.usize): boolean { - return rt.rangeToContains(r, x); +export function boundsContain$usize_ops_RangeTo_usize(r: { end: rs.usize }, x: rs.usize): boolean { + return rs.rangeToContains(r, x); } /** `RangeBounds::contains`, through the trait. */ -export function boundsContain$usize_ops_Range_usize(r: rt.Range, x: rt.usize): boolean { - return rt.rangeContains(r, x); +export function boundsContain$usize_ops_Range_usize(r: rs.Range, x: rs.usize): boolean { + return rs.rangeContains(r, x); } /** @@ -8603,92 +8603,92 @@ export function boundsContain$usize_ops_Range_usize(r: rt.Range, x: rt * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$char(table: rt.char[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.char | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$char(table: rs.char[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.char | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.char, rt.char] = bounded$char(table, at, out); - const a: rt.char = _6[0]; - const b: rt.char = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.charStep); - rt.rangeHash(rt.hash32)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.charStep); - rt.rangeHash(rt.hash32)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.charStep); - rt.rangeHash(rt.hash32)(_15, h2); - const _19: { end: rt.char } = { end: b }; - rt.rangeHash(rt.hash32)(_19, h2); - const _23: { end: rt.char; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash32)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.char, rs.char] = bounded$char(table, at, out); + const a: rs.char = _6[0]; + const b: rs.char = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.charStep); + rs.rangeHash(rs.hash32)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); + rs.rangeHash(rs.hash32)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.charStep); + rs.rangeHash(rs.hash32)(_15, h2); + const _19: { end: rs.char } = { end: b }; + rs.rangeHash(rs.hash32)(_19, h2); + const _23: { end: rs.char; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash32)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.charStep); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.char | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.char | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.char | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.char | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.char, rt.char] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.char = _54[0]; - const end: rt.char = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.charStep), new rt.RangeInclusive(start, end, rt.charStep), new rt.RangeInclusive(start, end, rt.charStep)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash32), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.fmtCharDebug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.fmtCharDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.charStep); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.charStep); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.charStep); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.char, rs.char] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.char = _54[0]; + const end: rs.char = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep), new rs.RangeInclusive(start, end, rs.charStep)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.fmtCharDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.fmtCharDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.charStep); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.charStep); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.charStep); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.char): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.char): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash32)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash32)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.char, rt.char] = rt.rangeInclusiveIntoInner(r); - const start2: rt.char = _140[0]; - const end2: rt.char = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDebug(start2, f), (f: rt.Formatter) => rt.fmtCharDebug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.char, rs.char] = rs.rangeInclusiveIntoInner(r); + const start2: rs.char = _140[0]; + const end2: rs.char = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(start2, f), (f: rs.Formatter) => rs.fmtCharDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -8697,92 +8697,92 @@ export function stepped$char(table: rt.char[], at: rt.usize[], out: rt.ByteVec): * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$i128(table: rt.i128[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.i128 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$i128(table: rs.i128[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.i128 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.i128, rt.i128] = bounded$i128(table, at, out); - const a: rt.i128 = _6[0]; - const b: rt.i128 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.i128Step); - rt.rangeHash(rt.hashI128)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i128Step); - rt.rangeHash(rt.hashI128)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.i128Step); - rt.rangeHash(rt.hashI128)(_15, h2); - const _19: { end: rt.i128 } = { end: b }; - rt.rangeHash(rt.hashI128)(_19, h2); - const _23: { end: rt.i128; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashI128)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.i128, rs.i128] = bounded$i128(table, at, out); + const a: rs.i128 = _6[0]; + const b: rs.i128 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.i128Step); + rs.rangeHash(rs.hashI128)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); + rs.rangeHash(rs.hashI128)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.i128Step); + rs.rangeHash(rs.hashI128)(_15, h2); + const _19: { end: rs.i128 } = { end: b }; + rs.rangeHash(rs.hashI128)(_19, h2); + const _23: { end: rs.i128; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashI128)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i128Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.i128 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.i128 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.i128 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.i128 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.i128, rt.i128] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.i128 = _54[0]; - const end: rt.i128 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.i128Step), new rt.RangeInclusive(start, end, rt.i128Step), new rt.RangeInclusive(start, end, rt.i128Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashI128), rt.rangeEq(rt.i128Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i128Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.i128Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.i128Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i128Step); - const _111: boolean = rt.rangeEq(rt.i128Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i128Step); - const _117: boolean = rt.rangeEq(rt.i128Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i128Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.i128Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.i128, rs.i128] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.i128 = _54[0]; + const end: rs.i128 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step), new rs.RangeInclusive(start, end, rs.i128Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI128), rs.rangeEq(rs.i128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i128Step); + const _111: boolean = rs.rangeEq(rs.i128Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i128Step); + const _117: boolean = rs.rangeEq(rs.i128Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i128Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.i128Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.i128): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.i128): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashI128)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashI128)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.i128, rt.i128] = rt.rangeInclusiveIntoInner(r); - const start2: rt.i128 = _140[0]; - const end2: rt.i128 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Debug(start2, f), (f: rt.Formatter) => rt.i128Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.i128, rs.i128] = rs.rangeInclusiveIntoInner(r); + const start2: rs.i128 = _140[0]; + const end2: rs.i128 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(start2, f), (f: rs.Formatter) => rs.i128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -8791,92 +8791,92 @@ export function stepped$i128(table: rt.i128[], at: rt.usize[], out: rt.ByteVec): * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$i16(table: rt.i16[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.i16 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$i16(table: rs.i16[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.i16 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.i16, rt.i16] = bounded$i16(table, at, out); - const a: rt.i16 = _6[0]; - const b: rt.i16 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashI16)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i16Step); - rt.rangeHash(rt.hashI16)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.i16Step); - rt.rangeHash(rt.hashI16)(_15, h2); - const _19: { end: rt.i16 } = { end: b }; - rt.rangeHash(rt.hashI16)(_19, h2); - const _23: { end: rt.i16; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashI16)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.i16, rs.i16] = bounded$i16(table, at, out); + const a: rs.i16 = _6[0]; + const b: rs.i16 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashI16)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); + rs.rangeHash(rs.hashI16)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.i16Step); + rs.rangeHash(rs.hashI16)(_15, h2); + const _19: { end: rs.i16 } = { end: b }; + rs.rangeHash(rs.hashI16)(_19, h2); + const _23: { end: rs.i16; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashI16)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i16Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.i16 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.i16 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.i16 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.i16 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.i16, rt.i16] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.i16 = _54[0]; - const end: rt.i16 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.i16Step), new rt.RangeInclusive(start, end, rt.i16Step), new rt.RangeInclusive(start, end, rt.i16Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashI16), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i16Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.i16Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i16Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i16Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i16Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.i16, rs.i16] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.i16 = _54[0]; + const end: rs.i16 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step), new rs.RangeInclusive(start, end, rs.i16Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i16Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i16Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i16Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i16Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.i16): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.i16): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashI16)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashI16)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.i16, rt.i16] = rt.rangeInclusiveIntoInner(r); - const start2: rt.i16 = _140[0]; - const end2: rt.i16 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Debug(start2, f), (f: rt.Formatter) => rt.i16Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.i16, rs.i16] = rs.rangeInclusiveIntoInner(r); + const start2: rs.i16 = _140[0]; + const end2: rs.i16 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(start2, f), (f: rs.Formatter) => rs.i16Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -8885,92 +8885,92 @@ export function stepped$i16(table: rt.i16[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$i32(table: rt.i32[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.i32 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$i32(table: rs.i32[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.i32 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.i32, rt.i32] = bounded$i32(table, at, out); - const a: rt.i32 = _6[0]; - const b: rt.i32 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashI32)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - rt.rangeHash(rt.hashI32)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); - rt.rangeHash(rt.hashI32)(_15, h2); - const _19: { end: rt.i32 } = { end: b }; - rt.rangeHash(rt.hashI32)(_19, h2); - const _23: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashI32)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.i32, rs.i32] = bounded$i32(table, at, out); + const a: rs.i32 = _6[0]; + const b: rs.i32 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashI32)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + rs.rangeHash(rs.hashI32)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); + rs.rangeHash(rs.hashI32)(_15, h2); + const _19: { end: rs.i32 } = { end: b }; + rs.rangeHash(rs.hashI32)(_19, h2); + const _23: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashI32)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.i32 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.i32 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.i32 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.i32 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.i32, rt.i32] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.i32 = _54[0]; - const end: rt.i32 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.i32Step), new rt.RangeInclusive(start, end, rt.i32Step), new rt.RangeInclusive(start, end, rt.i32Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashI32), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i32Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.i32Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i32Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i32Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.i32, rs.i32] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.i32 = _54[0]; + const end: rs.i32 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step), new rs.RangeInclusive(start, end, rs.i32Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i32Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i32Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i32Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.i32): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.i32): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashI32)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashI32)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.i32, rt.i32] = rt.rangeInclusiveIntoInner(r); - const start2: rt.i32 = _140[0]; - const end2: rt.i32 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Debug(start2, f), (f: rt.Formatter) => rt.i32Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.i32, rs.i32] = rs.rangeInclusiveIntoInner(r); + const start2: rs.i32 = _140[0]; + const end2: rs.i32 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(start2, f), (f: rs.Formatter) => rs.i32Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -8979,92 +8979,92 @@ export function stepped$i32(table: rt.i32[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$i64(table: rt.i64[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.i64 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$i64(table: rs.i64[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.i64 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.i64, rt.i64] = bounded$i64(table, at, out); - const a: rt.i64 = _6[0]; - const b: rt.i64 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.i64Step); - rt.rangeHash(rt.hashI64)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i64Step); - rt.rangeHash(rt.hashI64)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.i64Step); - rt.rangeHash(rt.hashI64)(_15, h2); - const _19: { end: rt.i64 } = { end: b }; - rt.rangeHash(rt.hashI64)(_19, h2); - const _23: { end: rt.i64; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashI64)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.i64, rs.i64] = bounded$i64(table, at, out); + const a: rs.i64 = _6[0]; + const b: rs.i64 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.i64Step); + rs.rangeHash(rs.hashI64)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); + rs.rangeHash(rs.hashI64)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.i64Step); + rs.rangeHash(rs.hashI64)(_15, h2); + const _19: { end: rs.i64 } = { end: b }; + rs.rangeHash(rs.hashI64)(_19, h2); + const _23: { end: rs.i64; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashI64)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i64Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.i64 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.i64 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.i64 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.i64 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.i64, rt.i64] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.i64 = _54[0]; - const end: rt.i64 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.i64Step), new rt.RangeInclusive(start, end, rt.i64Step), new rt.RangeInclusive(start, end, rt.i64Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashI64), rt.rangeEq(rt.i64Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i64Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.i64Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.i64Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i64Step); - const _111: boolean = rt.rangeEq(rt.i64Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i64Step); - const _117: boolean = rt.rangeEq(rt.i64Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i64Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.i64Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.i64, rs.i64] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.i64 = _54[0]; + const end: rs.i64 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step), new rs.RangeInclusive(start, end, rs.i64Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI64), rs.rangeEq(rs.i64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i64Step); + const _111: boolean = rs.rangeEq(rs.i64Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i64Step); + const _117: boolean = rs.rangeEq(rs.i64Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i64Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.i64Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.i64): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.i64): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashI64)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashI64)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.i64, rt.i64] = rt.rangeInclusiveIntoInner(r); - const start2: rt.i64 = _140[0]; - const end2: rt.i64 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Debug(start2, f), (f: rt.Formatter) => rt.i64Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.i64, rs.i64] = rs.rangeInclusiveIntoInner(r); + const start2: rs.i64 = _140[0]; + const end2: rs.i64 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(start2, f), (f: rs.Formatter) => rs.i64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9073,92 +9073,92 @@ export function stepped$i64(table: rt.i64[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$i8(table: rt.i8[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.i8 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$i8(table: rs.i8[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.i8 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.i8, rt.i8] = bounded$i8(table, at, out); - const a: rt.i8 = _6[0]; - const b: rt.i8 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashI8)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i8Step); - rt.rangeHash(rt.hashI8)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.i8Step); - rt.rangeHash(rt.hashI8)(_15, h2); - const _19: { end: rt.i8 } = { end: b }; - rt.rangeHash(rt.hashI8)(_19, h2); - const _23: { end: rt.i8; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashI8)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.i8, rs.i8] = bounded$i8(table, at, out); + const a: rs.i8 = _6[0]; + const b: rs.i8 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashI8)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); + rs.rangeHash(rs.hashI8)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.i8Step); + rs.rangeHash(rs.hashI8)(_15, h2); + const _19: { end: rs.i8 } = { end: b }; + rs.rangeHash(rs.hashI8)(_19, h2); + const _23: { end: rs.i8; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashI8)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i8Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.i8 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.i8 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.i8 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.i8 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.i8, rt.i8] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.i8 = _54[0]; - const end: rt.i8 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.i8Step), new rt.RangeInclusive(start, end, rt.i8Step), new rt.RangeInclusive(start, end, rt.i8Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashI8), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.i8Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.i8Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.i8Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i8Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i8Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.i8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.i8, rs.i8] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.i8 = _54[0]; + const end: rs.i8 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step), new rs.RangeInclusive(start, end, rs.i8Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashI8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.i8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.i8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.i8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i8Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i8Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.i8Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.i8): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.i8): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashI8)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashI8)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.i8, rt.i8] = rt.rangeInclusiveIntoInner(r); - const start2: rt.i8 = _140[0]; - const end2: rt.i8 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Debug(start2, f), (f: rt.Formatter) => rt.i8Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.i8, rs.i8] = rs.rangeInclusiveIntoInner(r); + const start2: rs.i8 = _140[0]; + const end2: rs.i8 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(start2, f), (f: rs.Formatter) => rs.i8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9167,92 +9167,92 @@ export function stepped$i8(table: rt.i8[], at: rt.usize[], out: rt.ByteVec): voi * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$isize(table: rt.isize[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.isize | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$isize(table: rs.isize[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.isize | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.isize, rt.isize] = bounded$isize(table, at, out); - const a: rt.isize = _6[0]; - const b: rt.isize = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashIsize)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.isizeStep); - rt.rangeHash(rt.hashIsize)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.isizeStep); - rt.rangeHash(rt.hashIsize)(_15, h2); - const _19: { end: rt.isize } = { end: b }; - rt.rangeHash(rt.hashIsize)(_19, h2); - const _23: { end: rt.isize; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashIsize)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.isize, rs.isize] = bounded$isize(table, at, out); + const a: rs.isize = _6[0]; + const b: rs.isize = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashIsize)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); + rs.rangeHash(rs.hashIsize)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.isizeStep); + rs.rangeHash(rs.hashIsize)(_15, h2); + const _19: { end: rs.isize } = { end: b }; + rs.rangeHash(rs.hashIsize)(_19, h2); + const _23: { end: rs.isize; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashIsize)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.isizeStep); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.isize | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.isize | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.isize | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.isize | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.isize, rt.isize] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.isize = _54[0]; - const end: rt.isize = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.isizeStep), new rt.RangeInclusive(start, end, rt.isizeStep), new rt.RangeInclusive(start, end, rt.isizeStep)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashIsize), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.isizeDebug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.isizeDebug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.isizeDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.isizeStep); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.isizeStep); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.isizeStep); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.isize, rs.isize] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.isize = _54[0]; + const end: rs.isize = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep), new rs.RangeInclusive(start, end, rs.isizeStep)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashIsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.isizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.isizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.isizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.isizeStep); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.isizeStep); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.isizeStep); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.isize): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.isize): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashIsize)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashIsize)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.isize, rt.isize] = rt.rangeInclusiveIntoInner(r); - const start2: rt.isize = _140[0]; - const end2: rt.isize = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDebug(start2, f), (f: rt.Formatter) => rt.isizeDebug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.isize, rs.isize] = rs.rangeInclusiveIntoInner(r); + const start2: rs.isize = _140[0]; + const end2: rs.isize = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(start2, f), (f: rs.Formatter) => rs.isizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9261,92 +9261,92 @@ export function stepped$isize(table: rt.isize[], at: rt.usize[], out: rt.ByteVec * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$num_NonZero_u128(table: rt.u128[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u128 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$num_NonZero_u128(table: rs.u128[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u128 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u128, rt.u128] = bounded$num_NonZero_u128(table, at, out); - const a: rt.u128 = _6[0]; - const b: rt.u128 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - rt.rangeHash(rt.hash128)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - rt.rangeHash(rt.hash128)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - rt.rangeHash(rt.hash128)(_15, h2); - const _19: { end: rt.u128 } = { end: b }; - rt.rangeHash(rt.hash128)(_19, h2); - const _23: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash128)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u128, rs.u128] = bounded$num_NonZero_u128(table, at, out); + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + rs.rangeHash(rs.hash128)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + rs.rangeHash(rs.hash128)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + rs.rangeHash(rs.hash128)(_15, h2); + const _19: { end: rs.u128 } = { end: b }; + rs.rangeHash(rs.hash128)(_19, h2); + const _23: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash128)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u128 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u128 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u128 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u128 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u128, rt.u128] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u128 = _54[0]; - const end: rt.u128 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128))]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash128), rt.rangeEq(rt.u128Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u128Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u128Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _111: boolean = rt.rangeEq(rt.u128Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - const _117: boolean = rt.rangeEq(rt.u128Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.u128Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u128, rs.u128] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u128 = _54[0]; + const end: rs.u128 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128))]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + const _117: boolean = rs.rangeEq(rs.u128Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u128Step, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128)); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.u128Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u128): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u128): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash128)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash128)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u128, rt.u128] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u128 = _140[0]; - const end2: rt.u128 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Debug(start2, f), (f: rt.Formatter) => rt.u128Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u128 = _140[0]; + const end2: rs.u128 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9355,92 +9355,92 @@ export function stepped$num_NonZero_u128(table: rt.u128[], at: rt.usize[], out: * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$num_NonZero_u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u64 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$num_NonZero_u64(table: rs.u64[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u64 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u64, rt.u64] = bounded$num_NonZero_u64(table, at, out); - const a: rt.u64 = _6[0]; - const b: rt.u64 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - rt.rangeHash(rt.hash64)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - rt.rangeHash(rt.hash64)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - rt.rangeHash(rt.hash64)(_15, h2); - const _19: { end: rt.u64 } = { end: b }; - rt.rangeHash(rt.hash64)(_19, h2); - const _23: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash64)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u64, rs.u64] = bounded$num_NonZero_u64(table, at, out); + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + rs.rangeHash(rs.hash64)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + rs.rangeHash(rs.hash64)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + rs.rangeHash(rs.hash64)(_15, h2); + const _19: { end: rs.u64 } = { end: b }; + rs.rangeHash(rs.hash64)(_19, h2); + const _23: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash64)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u64 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u64 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u64 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u64 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u64, rt.u64] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u64 = _54[0]; - const end: rt.u64 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64))]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash64), rt.rangeEq(rt.u64Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u64Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u64Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _111: boolean = rt.rangeEq(rt.u64Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - const _117: boolean = rt.rangeEq(rt.u64Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.u64Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u64, rs.u64] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u64 = _54[0]; + const end: rs.u64 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64))]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + const _117: boolean = rs.rangeEq(rs.u64Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u64Step, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64)); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.u64Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u64): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u64): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash64)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash64)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u64, rt.u64] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u64 = _140[0]; - const end2: rt.u64 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Debug(start2, f), (f: rt.Formatter) => rt.u64Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u64 = _140[0]; + const end2: rs.u64 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9449,92 +9449,92 @@ export function stepped$num_NonZero_u64(table: rt.u64[], at: rt.usize[], out: rt * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$num_NonZero_u8(table: rt.u8[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u8 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$num_NonZero_u8(table: rs.u8[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u8 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u8, rt.u8] = bounded$num_NonZero_u8(table, at, out); - const a: rt.u8 = _6[0]; - const b: rt.u8 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hash8)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)); - rt.rangeHash(rt.hash8)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.u8Step, 255)); - rt.rangeHash(rt.hash8)(_15, h2); - const _19: { end: rt.u8 } = { end: b }; - rt.rangeHash(rt.hash8)(_19, h2); - const _23: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash8)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u8, rs.u8] = bounded$num_NonZero_u8(table, at, out); + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hash8)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); + rs.rangeHash(rs.hash8)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.u8Step, 255)); + rs.rangeHash(rs.hash8)(_15, h2); + const _19: { end: rs.u8 } = { end: b }; + rs.rangeHash(rs.hash8)(_19, h2); + const _23: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash8)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u8 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u8 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u8 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u8 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u8, rt.u8] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u8 = _54[0]; - const end: rt.u8 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u8Step, 255)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u8Step, 255))]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash8), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u8Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.u8Step, 255)); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u8Step, 255)); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.u8Step, 255)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u8, rs.u8] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u8 = _54[0]; + const end: rs.u8 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255))]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.u8Step, 255)); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.u8Step, 255)); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u8): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u8): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash8)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash8)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u8, rt.u8] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u8 = _140[0]; - const end2: rt.u8 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(start2, f), (f: rt.Formatter) => rt.u8Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u8 = _140[0]; + const end2: rs.u8 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9543,92 +9543,92 @@ export function stepped$num_NonZero_u8(table: rt.u8[], at: rt.usize[], out: rt.B * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$num_NonZero_usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.usize | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$num_NonZero_usize(table: rs.usize[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.usize | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.usize, rt.usize] = bounded$num_NonZero_usize(table, at, out); - const a: rt.usize = _6[0]; - const b: rt.usize = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashUsize)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)); - rt.rangeHash(rt.hashUsize)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.nonZeroStep(rt.usizeStep, 4294967295)); - rt.rangeHash(rt.hashUsize)(_15, h2); - const _19: { end: rt.usize } = { end: b }; - rt.rangeHash(rt.hashUsize)(_19, h2); - const _23: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashUsize)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.usize, rs.usize] = bounded$num_NonZero_usize(table, at, out); + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashUsize)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); + rs.rangeHash(rs.hashUsize)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.nonZeroStep(rs.usizeStep, 4294967295)); + rs.rangeHash(rs.hashUsize)(_15, h2); + const _19: { end: rs.usize } = { end: b }; + rs.rangeHash(rs.hashUsize)(_19, h2); + const _23: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashUsize)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.usize | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.usize | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.usize | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.usize | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.usize, rt.usize] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.usize = _54[0]; - const end: rt.usize = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.usizeStep, 4294967295)), new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.usizeStep, 4294967295))]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashUsize), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.usizeDebug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.usizeStep, 4294967295)); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.nonZeroStep(rt.usizeStep, 4294967295)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.usize, rs.usize] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.usize = _54[0]; + const end: rs.usize = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)), new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295))]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.nonZeroStep(rs.usizeStep, 4294967295)); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.usize): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.usize): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashUsize)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashUsize)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.usize, rt.usize] = rt.rangeInclusiveIntoInner(r); - const start2: rt.usize = _140[0]; - const end2: rt.usize = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(start2, f), (f: rt.Formatter) => rt.usizeDebug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(r); + const start2: rs.usize = _140[0]; + const end2: rs.usize = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9637,92 +9637,92 @@ export function stepped$num_NonZero_usize(table: rt.usize[], at: rt.usize[], out * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u128(table: rt.u128[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u128 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$u128(table: rs.u128[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u128 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u128, rt.u128] = bounded$u128(table, at, out); - const a: rt.u128 = _6[0]; - const b: rt.u128 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.u128Step); - rt.rangeHash(rt.hash128)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u128Step); - rt.rangeHash(rt.hash128)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.u128Step); - rt.rangeHash(rt.hash128)(_15, h2); - const _19: { end: rt.u128 } = { end: b }; - rt.rangeHash(rt.hash128)(_19, h2); - const _23: { end: rt.u128; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash128)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u128, rs.u128] = bounded$u128(table, at, out); + const a: rs.u128 = _6[0]; + const b: rs.u128 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.u128Step); + rs.rangeHash(rs.hash128)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); + rs.rangeHash(rs.hash128)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.u128Step); + rs.rangeHash(rs.hash128)(_15, h2); + const _19: { end: rs.u128 } = { end: b }; + rs.rangeHash(rs.hash128)(_19, h2); + const _23: { end: rs.u128; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash128)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u128Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u128 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u128 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u128 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u128 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u128, rt.u128] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u128 = _54[0]; - const end: rt.u128 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.u128Step), new rt.RangeInclusive(start, end, rt.u128Step), new rt.RangeInclusive(start, end, rt.u128Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash128), rt.rangeEq(rt.u128Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 29360128)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u128Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u128Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u128Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u128Step); - const _111: boolean = rt.rangeEq(rt.u128Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u128Step); - const _117: boolean = rt.rangeEq(rt.u128Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u128Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.u128Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u128, rs.u128] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u128 = _54[0]; + const end: rs.u128 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step), new rs.RangeInclusive(start, end, rs.u128Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash128), rs.rangeEq(rs.u128Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 29360128)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u128Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u128Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u128Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u128Step); + const _111: boolean = rs.rangeEq(rs.u128Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u128Step); + const _117: boolean = rs.rangeEq(rs.u128Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u128Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.u128Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u128): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u128): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash128)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash128)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u128, rt.u128] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u128 = _140[0]; - const end2: rt.u128 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Debug(start2, f), (f: rt.Formatter) => rt.u128Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u128, rs.u128] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u128 = _140[0]; + const end2: rs.u128 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(start2, f), (f: rs.Formatter) => rs.u128Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9731,92 +9731,92 @@ export function stepped$u128(table: rt.u128[], at: rt.usize[], out: rt.ByteVec): * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u16(table: rt.u16[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u16 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$u16(table: rs.u16[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u16 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u16, rt.u16] = bounded$u16(table, at, out); - const a: rt.u16 = _6[0]; - const b: rt.u16 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hash16)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u16Step); - rt.rangeHash(rt.hash16)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.u16Step); - rt.rangeHash(rt.hash16)(_15, h2); - const _19: { end: rt.u16 } = { end: b }; - rt.rangeHash(rt.hash16)(_19, h2); - const _23: { end: rt.u16; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash16)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u16, rs.u16] = bounded$u16(table, at, out); + const a: rs.u16 = _6[0]; + const b: rs.u16 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hash16)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); + rs.rangeHash(rs.hash16)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.u16Step); + rs.rangeHash(rs.hash16)(_15, h2); + const _19: { end: rs.u16 } = { end: b }; + rs.rangeHash(rs.hash16)(_19, h2); + const _23: { end: rs.u16; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash16)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u16Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u16 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u16 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u16 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u16 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u16, rt.u16] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u16 = _54[0]; - const end: rt.u16 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.u16Step), new rt.RangeInclusive(start, end, rt.u16Step), new rt.RangeInclusive(start, end, rt.u16Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash16), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u16Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u16Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u16Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u16Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u16Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u16, rs.u16] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u16 = _54[0]; + const end: rs.u16 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step), new rs.RangeInclusive(start, end, rs.u16Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash16), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u16Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u16Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u16Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u16Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u16Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u16): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u16): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash16)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash16)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u16, rt.u16] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u16 = _140[0]; - const end2: rt.u16 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Debug(start2, f), (f: rt.Formatter) => rt.u16Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u16, rs.u16] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u16 = _140[0]; + const end2: rs.u16 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(start2, f), (f: rs.Formatter) => rs.u16Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9825,92 +9825,92 @@ export function stepped$u16(table: rt.u16[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u32(table: rt.u32[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u32 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$u32(table: rs.u32[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u32 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u32, rt.u32] = bounded$u32(table, at, out); - const a: rt.u32 = _6[0]; - const b: rt.u32 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hash32)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u32Step); - rt.rangeHash(rt.hash32)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.u32Step); - rt.rangeHash(rt.hash32)(_15, h2); - const _19: { end: rt.u32 } = { end: b }; - rt.rangeHash(rt.hash32)(_19, h2); - const _23: { end: rt.u32; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash32)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u32, rs.u32] = bounded$u32(table, at, out); + const a: rs.u32 = _6[0]; + const b: rs.u32 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hash32)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); + rs.rangeHash(rs.hash32)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.u32Step); + rs.rangeHash(rs.hash32)(_15, h2); + const _19: { end: rs.u32 } = { end: b }; + rs.rangeHash(rs.hash32)(_19, h2); + const _23: { end: rs.u32; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash32)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u32Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u32 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u32 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u32 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u32 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u32, rt.u32] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u32 = _54[0]; - const end: rt.u32 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.u32Step), new rt.RangeInclusive(start, end, rt.u32Step), new rt.RangeInclusive(start, end, rt.u32Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash32), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u32Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u32Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u32Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u32Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u32Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u32, rs.u32] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u32 = _54[0]; + const end: rs.u32 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step), new rs.RangeInclusive(start, end, rs.u32Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash32), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u32Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u32Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u32Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u32Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u32): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u32): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash32)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash32)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u32, rt.u32] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u32 = _140[0]; - const end2: rt.u32 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Debug(start2, f), (f: rt.Formatter) => rt.u32Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u32, rs.u32] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u32 = _140[0]; + const end2: rs.u32 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(start2, f), (f: rs.Formatter) => rs.u32Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -9919,92 +9919,92 @@ export function stepped$u32(table: rt.u32[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u64 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$u64(table: rs.u64[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u64 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u64, rt.u64] = bounded$u64(table, at, out); - const a: rt.u64 = _6[0]; - const b: rt.u64 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b, rt.u64Step); - rt.rangeHash(rt.hash64)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u64Step); - rt.rangeHash(rt.hash64)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.u64Step); - rt.rangeHash(rt.hash64)(_15, h2); - const _19: { end: rt.u64 } = { end: b }; - rt.rangeHash(rt.hash64)(_19, h2); - const _23: { end: rt.u64; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash64)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u64, rs.u64] = bounded$u64(table, at, out); + const a: rs.u64 = _6[0]; + const b: rs.u64 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b, rs.u64Step); + rs.rangeHash(rs.hash64)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + rs.rangeHash(rs.hash64)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.u64Step); + rs.rangeHash(rs.hash64)(_15, h2); + const _19: { end: rs.u64 } = { end: b }; + rs.rangeHash(rs.hash64)(_19, h2); + const _23: { end: rs.u64; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash64)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u64Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u64 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u64 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u64 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u64 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u64, rt.u64] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u64 = _54[0]; - const end: rt.u64 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.u64Step), new rt.RangeInclusive(start, end, rt.u64Step), new rt.RangeInclusive(start, end, rt.u64Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash64), rt.rangeEq(rt.u64Eq))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 58720256)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u64Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u64Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u64Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u64Step); - const _111: boolean = rt.rangeEq(rt.u64Eq)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u64Step); - const _117: boolean = rt.rangeEq(rt.u64Eq)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u64Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.u64Eq)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u64, rs.u64] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u64 = _54[0]; + const end: rs.u64 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step), new rs.RangeInclusive(start, end, rs.u64Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash64), rs.rangeEq(rs.u64Eq))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 58720256)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u64Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u64Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u64Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u64Step); + const _111: boolean = rs.rangeEq(rs.u64Eq)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u64Step); + const _117: boolean = rs.rangeEq(rs.u64Eq)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u64Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.u64Eq)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.u64): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.u64): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash64)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash64)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u64, rt.u64] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u64 = _140[0]; - const end2: rt.u64 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Debug(start2, f), (f: rt.Formatter) => rt.u64Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u64, rs.u64] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u64 = _140[0]; + const end2: rs.u64 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(start2, f), (f: rs.Formatter) => rs.u64Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -10013,92 +10013,92 @@ export function stepped$u64(table: rt.u64[], at: rt.usize[], out: rt.ByteVec): v * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.u8 | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$u8(table: rs.ByteSlice, at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.u8 | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.u8, rt.u8] = bounded$u8(table, at, out); - const a: rt.u8 = _6[0]; - const b: rt.u8 = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hash8)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - rt.rangeHash(rt.hash8)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.u8Step); - rt.rangeHash(rt.hash8)(_15, h2); - const _19: { end: rt.u8 } = { end: b }; - rt.rangeHash(rt.hash8)(_19, h2); - const _23: { end: rt.u8; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hash8)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.u8, rs.u8] = bounded$u8(table, at, out); + const a: rs.u8 = _6[0]; + const b: rs.u8 = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hash8)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + rs.rangeHash(rs.hash8)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.u8Step); + rs.rangeHash(rs.hash8)(_15, h2); + const _19: { end: rs.u8 } = { end: b }; + rs.rangeHash(rs.hash8)(_19, h2); + const _23: { end: rs.u8; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hash8)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.u8 | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.u8 | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.u8 | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.u8 | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.u8, rt.u8] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.u8 = _54[0]; - const end: rt.u8 = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.u8Step), new rt.RangeInclusive(start, end, rt.u8Step), new rt.RangeInclusive(start, end, rt.u8Step)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hash8), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 234881024)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.u8Debug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.u8Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.u8Step); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u8Step); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.u8Step); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.u8, rs.u8] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.u8 = _54[0]; + const end: rs.u8 = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step), new rs.RangeInclusive(start, end, rs.u8Step)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hash8), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 234881024)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.u8Debug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.u8Step); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u8Step); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.u8Step); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(table)), (x: rt.u8): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(table)), (x: rs.u8): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hash8)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hash8)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.u8, rt.u8] = rt.rangeInclusiveIntoInner(r); - const start2: rt.u8 = _140[0]; - const end2: rt.u8 = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(start2, f), (f: rt.Formatter) => rt.u8Debug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.u8, rs.u8] = rs.rangeInclusiveIntoInner(r); + const start2: rs.u8 = _140[0]; + const end2: rs.u8 = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(start2, f), (f: rs.Formatter) => rs.u8Debug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -10107,92 +10107,92 @@ export function stepped$u8(table: rt.ByteSlice, at: rt.usize[], out: rt.ByteVec) * from either end, by `next` past its last item, which wraps it at its type's end, and * folded, which exhausts it at its end. Each is compared with fresh ranges and hashed. */ -export function stepped$usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec): void { - let _20!: rt.i32; - let read!: rt.usize | undefined; - const _7: (a0: (a0: rt.Hasher) => undefined) => Uint8Array = (value: (a0: rt.Hasher) => undefined): Uint8Array => { - const h: rt.Hasher = rt.hasher(); +export function stepped$usize(table: rs.usize[], at: rs.usize[], out: rs.ByteVec): void { + let _20!: rs.i32; + let read!: rs.usize | undefined; + const _7: (a0: (a0: rs.Hasher) => undefined) => Uint8Array = (value: (a0: rs.Hasher) => undefined): Uint8Array => { + const h: rs.Hasher = rs.hasher(); value(h); - return rt.u64ToBeBytes(rt.hashFinish(h)).reverse(); + return rs.u64ToBeBytes(rs.hashFinish(h)).reverse(); }; - const _6: [rt.usize, rt.usize] = bounded$usize(table, at, out); - const a: rt.usize = _6[0]; - const b: rt.usize = _6[1]; - const part2 = (h2: rt.Hasher): undefined => { - const _52: rt.Range = new rt.Range(a, b); - rt.rangeHash(rt.hashUsize)(_52, h2); - const _10: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - rt.rangeHash(rt.hashUsize)(_10, h2); - const _15: rt.RangeFrom = new rt.RangeFrom(a, rt.usizeStep); - rt.rangeHash(rt.hashUsize)(_15, h2); - const _19: { end: rt.usize } = { end: b }; - rt.rangeHash(rt.hashUsize)(_19, h2); - const _23: { end: rt.usize; inclusive: true } = { end: b, inclusive: true }; - rt.rangeHash(rt.hashUsize)(_23, h2); - rt.hashNothing(undefined, h2); + const _6: [rs.usize, rs.usize] = bounded$usize(table, at, out); + const a: rs.usize = _6[0]; + const b: rs.usize = _6[1]; + const part2 = (h2: rs.Hasher): undefined => { + const _52: rs.Range = new rs.Range(a, b); + rs.rangeHash(rs.hashUsize)(_52, h2); + const _10: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + rs.rangeHash(rs.hashUsize)(_10, h2); + const _15: rs.RangeFrom = new rs.RangeFrom(a, rs.usizeStep); + rs.rangeHash(rs.hashUsize)(_15, h2); + const _19: { end: rs.usize } = { end: b }; + rs.rangeHash(rs.hashUsize)(_19, h2); + const _23: { end: rs.usize; inclusive: true } = { end: b, inclusive: true }; + rs.rangeHash(rs.hashUsize)(_23, h2); + rs.hashNothing(undefined, h2); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part2)), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 9; + rs.iterExtendBytes(out, rs.iterSlice(_7(part2)), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 9; while ((_20 = iterStart++) < iterEnd) { - const how: rt.i32 = _20; - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const n: rt.usize = rt.usizeRem(at[0], 4); + const how: rs.i32 = _20; + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const n: rs.usize = rs.usizeRem(at[0], 4); if (how === 0) { read = undefined; } else if (how === 1) { - read = rt.iterToOption(r.next()); + read = rs.iterToOption(r.next()); } else if (how === 2) { - read = rt.iterToOption(r.nextBack()); + read = rs.iterToOption(r.nextBack()); } else if (how === 3) { - read = rt.iterLast(rt.iterTake(rt.iterBorrow(r), 300)); + read = rs.iterLast(rs.iterTake(rs.iterBorrow(r), 300)); } else if (how === 4) { - read = rt.iterLast(rt.iterTake(rt.iterRev(rt.iterBorrow(r)), 300)); + read = rs.iterLast(rs.iterTake(rs.iterRev(rs.iterBorrow(r)), 300)); } else if (how === 5) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_22: rt.i32): rt.usize | undefined => { - return rt.iterToOption(r.next()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_22: rs.i32): rs.usize | undefined => { + return rs.iterToOption(r.next()); })); } else if (how === 6) { - read = rt.iterLast(rt.iterMapWhile(new rt.Range(0, 300), (_2: rt.i32): rt.usize | undefined => { - return rt.iterToOption(r.nextBack()); + read = rs.iterLast(rs.iterMapWhile(new rs.Range(0, 300), (_2: rs.i32): rs.usize | undefined => { + return rs.iterToOption(r.nextBack()); })); } else if (how === 7) { - read = rt.iterNth(r, n); + read = rs.iterNth(r, n); } else { - read = rt.iterNthBack(r, n); - } - const _54: [rt.usize, rt.usize] = [rt.rangeInclusiveStart(r), rt.rangeInclusiveEnd(r)]; - const start: rt.usize = _54[0]; - const end: rt.usize = _54[1]; - const _62: rt.RangeInclusive[] = [new rt.RangeInclusive(a, b, rt.usizeStep), new rt.RangeInclusive(start, end, rt.usizeStep), new rt.RangeInclusive(start, end, rt.usizeStep)]; - const _77: rt.usize = rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.rangeHash(rt.hashUsize), rt.rangeEq(rt.same))) as rt.HashSet>, rt.iterSlice(_62), undefined, undefined, 117440512)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(read, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtRangeInclusive(r, f, rt.usizeDebug), (f: rt.Formatter) => rt.usizeDisplay(_77, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); - const _96: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _99: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_96, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtBound(_99, f, rt.usizeDebug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1]])), undefined, true); - const _109: boolean = rt.rangeInclusiveIsEmpty(r); - const _114: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const _111: boolean = rt.rangeEq(rt.same)(r, _114); - const _120: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.usizeStep); - const _117: boolean = rt.rangeEq(rt.same)(r, _120); - const _124: rt.RangeInclusive = new rt.RangeInclusive(start, end, rt.usizeStep); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_109, _111, _117, !rt.rangeEq(rt.same)(r, _124)], (a0: boolean): rt.u8 => { + read = rs.iterNthBack(r, n); + } + const _54: [rs.usize, rs.usize] = [rs.rangeInclusiveStart(r), rs.rangeInclusiveEnd(r)]; + const start: rs.usize = _54[0]; + const end: rs.usize = _54[1]; + const _62: rs.RangeInclusive[] = [new rs.RangeInclusive(a, b, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep), new rs.RangeInclusive(start, end, rs.usizeStep)]; + const _77: rs.usize = rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.rangeHash(rs.hashUsize), rs.rangeEq(rs.same))) as rs.HashSet>, rs.iterSlice(_62), undefined, undefined, 117440512)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(read, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtRangeInclusive(r, f, rs.usizeDebug), (f: rs.Formatter) => rs.usizeDisplay(_77, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])), undefined, true); + const _96: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _99: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_96, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBound(_99, f, rs.usizeDebug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1]])), undefined, true); + const _109: boolean = rs.rangeInclusiveIsEmpty(r); + const _114: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const _111: boolean = rs.rangeEq(rs.same)(r, _114); + const _120: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.usizeStep); + const _117: boolean = rs.rangeEq(rs.same)(r, _120); + const _124: rs.RangeInclusive = new rs.RangeInclusive(start, end, rs.usizeStep); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_109, _111, _117, !rs.rangeEq(rs.same)(r, _124)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(table), (x: rt.usize): rt.u8 => { - return rt.rangeInclusiveContains(r, x) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(table), (x: rs.usize): rs.u8 => { + return rs.rangeInclusiveContains(r, x) ? 1 : 0; }), undefined, true); - const part3 = (h3: rt.Hasher): undefined => { - rt.rangeHash(rt.hashUsize)(r, h3); + const part3 = (h3: rs.Hasher): undefined => { + rs.rangeHash(rs.hashUsize)(r, h3); }; - rt.iterExtendBytes(out, rt.iterSlice(_7(part3)), undefined, true); - const _140: [rt.usize, rt.usize] = rt.rangeInclusiveIntoInner(r); - const start2: rt.usize = _140[0]; - const end2: rt.usize = _140[1]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(start2, f), (f: rt.Formatter) => rt.usizeDebug(end2, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args6[0], " ", args6[1]])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_7(part3)), undefined, true); + const _140: [rs.usize, rs.usize] = rs.rangeInclusiveIntoInner(r); + const start2: rs.usize = _140[0]; + const end2: rs.usize = _140[1]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(start2, f), (f: rs.Formatter) => rs.usizeDebug(end2, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args6[0], " ", args6[1]])), undefined, true); } } @@ -10204,1246 +10204,1246 @@ export function stepped$usize(table: rt.usize[], at: rt.usize[], out: rt.ByteVec * on after; of floats with NaN for 0xff, against a `Vec` by value; and of `start..`, which * never ends, and panics past its type's last value. */ -export function compares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let r!: rt.u8; - let r2!: rt.u8; - let r3!: rt.u8; - let r4!: rt.u8; - let r5!: rt.u8; - let r6!: rt.u8; - let r7!: rt.u8; - const _23: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function compares(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let r!: rs.u8; + let r2!: rs.u8; + let r3!: rs.u8; + let r4!: rs.u8; + let r5!: rs.u8; + let r6!: rs.u8; + let r7!: rs.u8; + const _23: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const other: rt.ByteVec = rt.byteSliceToByteVec(data); - const _8: rt.u8 = rt.u8Rem(kind >> 4, 4); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const other: rs.ByteVec = rs.byteSliceToByteVec(data); + const _8: rs.u8 = rs.u8Rem(kind >> 4, 4); if (_8 !== 0) { if (_8 === 1) { - rt.byteVecPop(other); + rs.byteVecPop(other); } else if (_8 === 2) { - rt.byteVecPush(other, kind); + rs.byteVecPush(other, kind); } else { - const _16: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(other))); + const _16: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(other))); if (_16 !== undefined) { - _16.v = rt.u8WrappingAdd(_16.v, 1); + _16.v = rs.u8WrappingAdd(_16.v, 1); } } } - const _24: rt.u8 = kind >> 6; + const _24: rs.u8 = kind >> 6; if (_24 === 0) { - let calls: rt.u8 = 0; - const _29: rt.u8 = rt.u8Rem(kind, 16); + let calls: rs.u8 = 0; + const _29: rs.u8 = rs.u8Rem(kind, 16); if (_29 === 9) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2152: rt.u8): rt.u8 => { - const x168: rt.u8 = _2152; - const _6211: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6211.value, x168 ^ 1); - rt.refMutRelease(_6211); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2152: rs.u8): rs.u8 => { + const x168: rs.u8 = _2152; + const _6211: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6211.value, x168 ^ 1); + rs.refMutRelease(_6211); return x168; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2153: rt.u8): rt.u8 => { - const x169: rt.u8 = _2153; - const _6212: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6212.value, x169 ^ 2); - rt.refMutRelease(_6212); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2153: rs.u8): rs.u8 => { + const x169: rs.u8 = _2153; + const _6212: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6212.value, x169 ^ 2); + rs.refMutRelease(_6212); return x169; - }), rt.cmp) & 0xff); + }), rs.cmp) & 0xff); } else if (_29 === 10) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2150: rt.u8): rt.u8 => { - const x165: rt.u8 = _2150; - const _6209: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6209.value, x165 ^ 1); - rt.refMutRelease(_6209); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2150: rs.u8): rs.u8 => { + const x165: rs.u8 = _2150; + const _6209: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6209.value, x165 ^ 1); + rs.refMutRelease(_6209); return x165; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2151: rt.u8): rt.u8 => { - const x166: rt.u8 = _2151; - const _6210: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6210.value, x166 ^ 2); - rt.refMutRelease(_6210); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2151: rs.u8): rs.u8 => { + const x166: rs.u8 = _2151; + const _6210: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6210.value, x166 ^ 2); + rs.refMutRelease(_6210); return x166; - }), (x167: rt.u8, y26: rt.u8): rt.Ordering => { - calls = rt.u8Add(calls, 1); - return rt.cmp(x167, y26); + }), (x167: rs.u8, y26: rs.u8): rs.Ordering => { + calls = rs.u8Add(calls, 1); + return rs.cmp(x167, y26); }) & 0xff); } else if (_29 === 11) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2148: rt.u8): rt.u8 => { - const x162: rt.u8 = _2148; - const _6206: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6206.value, x162 ^ 1); - rt.refMutRelease(_6206); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2148: rs.u8): rs.u8 => { + const x162: rs.u8 = _2148; + const _6206: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6206.value, x162 ^ 1); + rs.refMutRelease(_6206); return x162; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2149: rt.u8): rt.u8 => { - const x163: rt.u8 = _2149; - const _6207: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6207.value, x163 ^ 2); - rt.refMutRelease(_6207); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2149: rs.u8): rs.u8 => { + const x163: rs.u8 = _2149; + const _6207: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6207.value, x163 ^ 2); + rs.refMutRelease(_6207); return x163; - }), (x164: rt.u8, y25: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x164, y25), rt.u8Add(y25, x164)); + }), (x164: rs.u8, y25: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x164, y25), rs.u8Add(y25, x164)); }) & 0xff); } else { - let calls2: rt.u8 = 0; - const _74: rt.u8 = rt.u8Rem(kind, 16); + let calls2: rs.u8 = 0; + const _74: rs.u8 = rs.u8Rem(kind, 16); if (_74 === 0) { - r = rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2146: rt.u8): rt.u8 => { - const x160: rt.u8 = _2146; - const _6204: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6204.value, x160 ^ 1); - rt.refMutRelease(_6204); + r = rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2146: rs.u8): rs.u8 => { + const x160: rs.u8 = _2146; + const _6204: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6204.value, x160 ^ 1); + rs.refMutRelease(_6204); return x160; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2147: rt.u8): rt.u8 => { - const x161: rt.u8 = _2147; - const _6205: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6205.value, x161 ^ 2); - rt.refMutRelease(_6205); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2147: rs.u8): rs.u8 => { + const x161: rs.u8 = _2147; + const _6205: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6205.value, x161 ^ 2); + rs.refMutRelease(_6205); return x161; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_74 === 1) { - r = !rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2144: rt.u8): rt.u8 => { - const x158: rt.u8 = _2144; - const _6202: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6202.value, x158 ^ 1); - rt.refMutRelease(_6202); + r = !rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2144: rs.u8): rs.u8 => { + const x158: rs.u8 = _2144; + const _6202: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6202.value, x158 ^ 1); + rs.refMutRelease(_6202); return x158; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2145: rt.u8): rt.u8 => { - const x159: rt.u8 = _2145; - const _6203: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6203.value, x159 ^ 2); - rt.refMutRelease(_6203); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2145: rs.u8): rs.u8 => { + const x159: rs.u8 = _2145; + const _6203: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6203.value, x159 ^ 2); + rs.refMutRelease(_6203); return x159; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_74 === 2) { - r = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2142: rt.u8): rt.u8 => { - const x156: rt.u8 = _2142; - const _6200: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6200.value, x156 ^ 1); - rt.refMutRelease(_6200); + r = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2142: rs.u8): rs.u8 => { + const x156: rs.u8 = _2142; + const _6200: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6200.value, x156 ^ 1); + rs.refMutRelease(_6200); return x156; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2143: rt.u8): rt.u8 => { - const x157: rt.u8 = _2143; - const _6201: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6201.value, x157 ^ 2); - rt.refMutRelease(_6201); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2143: rs.u8): rs.u8 => { + const x157: rs.u8 = _2143; + const _6201: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6201.value, x157 ^ 2); + rs.refMutRelease(_6201); return x157; - }), rt.cmp) === -1 ? 1 : 0; + }), rs.cmp) === -1 ? 1 : 0; } else if (_74 === 3) { - const order14 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2140: rt.u8): rt.u8 => { - const x154: rt.u8 = _2140; - const _6198: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6198.value, x154 ^ 1); - rt.refMutRelease(_6198); + const order14 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2140: rs.u8): rs.u8 => { + const x154: rs.u8 = _2140; + const _6198: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6198.value, x154 ^ 1); + rs.refMutRelease(_6198); return x154; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2141: rt.u8): rt.u8 => { - const x155: rt.u8 = _2141; - const _6199: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6199.value, x155 ^ 2); - rt.refMutRelease(_6199); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2141: rs.u8): rs.u8 => { + const x155: rs.u8 = _2141; + const _6199: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6199.value, x155 ^ 2); + rs.refMutRelease(_6199); return x155; - }), rt.cmp); + }), rs.cmp); r = order14 !== undefined && order14 <= 0 ? 1 : 0; } else if (_74 === 4) { - r = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2138: rt.u8): rt.u8 => { - const x152: rt.u8 = _2138; - const _6196: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6196.value, x152 ^ 1); - rt.refMutRelease(_6196); + r = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2138: rs.u8): rs.u8 => { + const x152: rs.u8 = _2138; + const _6196: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6196.value, x152 ^ 1); + rs.refMutRelease(_6196); return x152; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2139: rt.u8): rt.u8 => { - const x153: rt.u8 = _2139; - const _6197: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6197.value, x153 ^ 2); - rt.refMutRelease(_6197); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2139: rs.u8): rs.u8 => { + const x153: rs.u8 = _2139; + const _6197: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6197.value, x153 ^ 2); + rs.refMutRelease(_6197); return x153; - }), rt.cmp) === 1 ? 1 : 0; + }), rs.cmp) === 1 ? 1 : 0; } else if (_74 === 5) { - const order13 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2136: rt.u8): rt.u8 => { - const x150: rt.u8 = _2136; - const _6194: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6194.value, x150 ^ 1); - rt.refMutRelease(_6194); + const order13 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2136: rs.u8): rs.u8 => { + const x150: rs.u8 = _2136; + const _6194: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6194.value, x150 ^ 1); + rs.refMutRelease(_6194); return x150; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2137: rt.u8): rt.u8 => { - const x151: rt.u8 = _2137; - const _6195: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6195.value, x151 ^ 2); - rt.refMutRelease(_6195); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2137: rs.u8): rs.u8 => { + const x151: rs.u8 = _2137; + const _6195: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6195.value, x151 ^ 2); + rs.refMutRelease(_6195); return x151; - }), rt.cmp); + }), rs.cmp); r = order13 !== undefined && order13 >= 0 ? 1 : 0; } else if (_74 === 6) { - const part14 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2134: rt.u8): rt.u8 => { - const x148: rt.u8 = _2134; - const _6192: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6192.value, x148 ^ 1); - rt.refMutRelease(_6192); + const part14 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2134: rs.u8): rs.u8 => { + const x148: rs.u8 = _2134; + const _6192: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6192.value, x148 ^ 1); + rs.refMutRelease(_6192); return x148; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2135: rt.u8): rt.u8 => { - const x149: rt.u8 = _2135; - const _6193: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6193.value, x149 ^ 2); - rt.refMutRelease(_6193); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2135: rs.u8): rs.u8 => { + const x149: rs.u8 = _2135; + const _6193: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6193.value, x149 ^ 2); + rs.refMutRelease(_6193); return x149; - }), rt.cmp); + }), rs.cmp); r = _23(part14); } else if (_74 === 7) { - r = rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2132: rt.u8): rt.u8 => { - const x145: rt.u8 = _2132; - const _6190: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6190.value, x145 ^ 1); - rt.refMutRelease(_6190); + r = rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2132: rs.u8): rs.u8 => { + const x145: rs.u8 = _2132; + const _6190: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6190.value, x145 ^ 1); + rs.refMutRelease(_6190); return x145; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2133: rt.u8): rt.u8 => { - const x146: rt.u8 = _2133; - const _6191: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6191.value, x146 ^ 2); - rt.refMutRelease(_6191); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2133: rs.u8): rs.u8 => { + const x146: rs.u8 = _2133; + const _6191: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6191.value, x146 ^ 2); + rs.refMutRelease(_6191); return x146; - }), (x147: rt.u8, y24: rt.u8): boolean => { - calls2 = rt.u8Add(calls2, 1); + }), (x147: rs.u8, y24: rs.u8): boolean => { + calls2 = rs.u8Add(calls2, 1); return x147 === y24; }, true) ? 1 : 0; } else { - const part13 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2130: rt.u8): rt.u8 => { - const x142: rt.u8 = _2130; - const _6188: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6188.value, x142 ^ 1); - rt.refMutRelease(_6188); + const part13 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2130: rs.u8): rs.u8 => { + const x142: rs.u8 = _2130; + const _6188: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6188.value, x142 ^ 1); + rs.refMutRelease(_6188); return x142; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2131: rt.u8): rt.u8 => { - const x143: rt.u8 = _2131; - const _6189: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6189.value, x143 ^ 2); - rt.refMutRelease(_6189); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2131: rs.u8): rs.u8 => { + const x143: rs.u8 = _2131; + const _6189: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6189.value, x143 ^ 2); + rs.refMutRelease(_6189); return x143; - }), (x144: rt.u8, y23: rt.u8): rt.Ordering | undefined => { - calls2 = rt.u8Add(calls2, 1); - return rt.cmp(x144, y23); + }), (x144: rs.u8, y23: rs.u8): rs.Ordering | undefined => { + calls2 = rs.u8Add(calls2, 1); + return rs.cmp(x144, y23); }); r = _23(part13); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r, calls2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r, calls2)), undefined, true); } - rt.byteVecPush(out, calls); + rs.byteVecPush(out, calls); } else if (_24 === 1) { - const a: rt.Iter = rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2104: rt.u8): rt.u8 => { - const x125: rt.u8 = _2104; - const _6174: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6174.value, x125 ^ 3); - rt.refMutRelease(_6174); + const a: rs.Iter = rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2104: rs.u8): rs.u8 => { + const x125: rs.u8 = _2104; + const _6174: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6174.value, x125 ^ 3); + rs.refMutRelease(_6174); return x125; - }), (_2105: rt.u8): boolean => { + }), (_2105: rs.u8): boolean => { return true; }); - let calls3: rt.u8 = 0; - const _196: rt.u8 = rt.u8Rem(kind, 16); + let calls3: rs.u8 = 0; + const _196: rs.u8 = rs.u8Rem(kind, 16); if (_196 === 9) { - const _200: rt.Iter = a; - const _202: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2128: rt.u8): rt.u8 => { - const x141: rt.u8 = _2128; - const _6187: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6187.value, x141 ^ 4); - rt.refMutRelease(_6187); + const _200: rs.Iter = a; + const _202: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2128: rs.u8): rs.u8 => { + const x141: rs.u8 = _2128; + const _6187: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6187.value, x141 ^ 4); + rs.refMutRelease(_6187); return x141; - }), (_2129: rt.u8): boolean => { + }), (_2129: rs.u8): boolean => { return false; }); - rt.byteVecPush(out, rt.iterCmp(rt.iterBorrow(_200), _202, rt.cmp) & 0xff); + rs.byteVecPush(out, rs.iterCmp(rs.iterBorrow(_200), _202, rs.cmp) & 0xff); } else if (_196 === 10) { - const _212: rt.Iter = a; - const _214: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2126: rt.u8): rt.u8 => { - const x139: rt.u8 = _2126; - const _6186: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6186.value, x139 ^ 4); - rt.refMutRelease(_6186); + const _212: rs.Iter = a; + const _214: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2126: rs.u8): rs.u8 => { + const x139: rs.u8 = _2126; + const _6186: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6186.value, x139 ^ 4); + rs.refMutRelease(_6186); return x139; - }), (_2127: rt.u8): boolean => { + }), (_2127: rs.u8): boolean => { return false; }); - const _221: (a0: rt.u8, a1: rt.u8) => rt.Ordering = (x140: rt.u8, y22: rt.u8): rt.Ordering => { - calls3 = rt.u8Add(calls3, 1); - return rt.cmp(x140, y22); + const _221: (a0: rs.u8, a1: rs.u8) => rs.Ordering = (x140: rs.u8, y22: rs.u8): rs.Ordering => { + calls3 = rs.u8Add(calls3, 1); + return rs.cmp(x140, y22); }; - rt.byteVecPush(out, rt.iterCmp(rt.iterBorrow(_212), _214, _221) & 0xff); + rs.byteVecPush(out, rs.iterCmp(rs.iterBorrow(_212), _214, _221) & 0xff); } else if (_196 === 11) { - const _226: rt.Iter = a; - const _228: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2124: rt.u8): rt.u8 => { - const x137: rt.u8 = _2124; - const _6184: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6184.value, x137 ^ 4); - rt.refMutRelease(_6184); + const _226: rs.Iter = a; + const _228: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2124: rs.u8): rs.u8 => { + const x137: rs.u8 = _2124; + const _6184: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6184.value, x137 ^ 4); + rs.refMutRelease(_6184); return x137; - }), (_2125: rt.u8): boolean => { + }), (_2125: rs.u8): boolean => { return false; }); - rt.byteVecPush(out, rt.iterCmp(rt.iterBorrow(_226), _228, (x138: rt.u8, y21: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x138, y21), rt.u8Add(y21, x138)); + rs.byteVecPush(out, rs.iterCmp(rs.iterBorrow(_226), _228, (x138: rs.u8, y21: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x138, y21), rs.u8Add(y21, x138)); }) & 0xff); } else { - let calls4: rt.u8 = 0; - const _238: rt.u8 = rt.u8Rem(kind, 16); + let calls4: rs.u8 = 0; + const _238: rs.u8 = rs.u8Rem(kind, 16); if (_238 === 0) { - const _241: rt.Iter = a; - const _243: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2122: rt.u8): rt.u8 => { - const x136: rt.u8 = _2122; - const _6183: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6183.value, x136 ^ 4); - rt.refMutRelease(_6183); + const _241: rs.Iter = a; + const _243: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2122: rs.u8): rs.u8 => { + const x136: rs.u8 = _2122; + const _6183: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6183.value, x136 ^ 4); + rs.refMutRelease(_6183); return x136; - }), (_2123: rt.u8): boolean => { + }), (_2123: rs.u8): boolean => { return false; }); - r2 = rt.iterEq(rt.iterBorrow(_241), _243, rt.same) ? 1 : 0; + r2 = rs.iterEq(rs.iterBorrow(_241), _243, rs.same) ? 1 : 0; } else if (_238 === 1) { - const _251: rt.Iter = a; - const _253: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2120: rt.u8): rt.u8 => { - const x135: rt.u8 = _2120; - const _6182: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6182.value, x135 ^ 4); - rt.refMutRelease(_6182); + const _251: rs.Iter = a; + const _253: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2120: rs.u8): rs.u8 => { + const x135: rs.u8 = _2120; + const _6182: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6182.value, x135 ^ 4); + rs.refMutRelease(_6182); return x135; - }), (_2121: rt.u8): boolean => { + }), (_2121: rs.u8): boolean => { return false; }); - r2 = !rt.iterEq(rt.iterBorrow(_251), _253, rt.same) ? 1 : 0; + r2 = !rs.iterEq(rs.iterBorrow(_251), _253, rs.same) ? 1 : 0; } else if (_238 === 2) { - const _261: rt.Iter = a; - const _263: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2118: rt.u8): rt.u8 => { - const x134: rt.u8 = _2118; - const _6181: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6181.value, x134 ^ 4); - rt.refMutRelease(_6181); + const _261: rs.Iter = a; + const _263: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2118: rs.u8): rs.u8 => { + const x134: rs.u8 = _2118; + const _6181: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6181.value, x134 ^ 4); + rs.refMutRelease(_6181); return x134; - }), (_2119: rt.u8): boolean => { + }), (_2119: rs.u8): boolean => { return false; }); - r2 = rt.iterCmp(rt.iterBorrow(_261), _263, rt.cmp) === -1 ? 1 : 0; + r2 = rs.iterCmp(rs.iterBorrow(_261), _263, rs.cmp) === -1 ? 1 : 0; } else if (_238 === 3) { - const _271: rt.Iter = a; - const _273: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2116: rt.u8): rt.u8 => { - const x133: rt.u8 = _2116; - const _6180: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6180.value, x133 ^ 4); - rt.refMutRelease(_6180); + const _271: rs.Iter = a; + const _273: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2116: rs.u8): rs.u8 => { + const x133: rs.u8 = _2116; + const _6180: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6180.value, x133 ^ 4); + rs.refMutRelease(_6180); return x133; - }), (_2117: rt.u8): boolean => { + }), (_2117: rs.u8): boolean => { return false; }); - const order12 = rt.iterCmp(rt.iterBorrow(_271), _273, rt.cmp); + const order12 = rs.iterCmp(rs.iterBorrow(_271), _273, rs.cmp); r2 = order12 !== undefined && order12 <= 0 ? 1 : 0; } else if (_238 === 4) { - const _281: rt.Iter = a; - const _283: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2114: rt.u8): rt.u8 => { - const x132: rt.u8 = _2114; - const _6179: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6179.value, x132 ^ 4); - rt.refMutRelease(_6179); + const _281: rs.Iter = a; + const _283: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2114: rs.u8): rs.u8 => { + const x132: rs.u8 = _2114; + const _6179: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6179.value, x132 ^ 4); + rs.refMutRelease(_6179); return x132; - }), (_2115: rt.u8): boolean => { + }), (_2115: rs.u8): boolean => { return false; }); - r2 = rt.iterCmp(rt.iterBorrow(_281), _283, rt.cmp) === 1 ? 1 : 0; + r2 = rs.iterCmp(rs.iterBorrow(_281), _283, rs.cmp) === 1 ? 1 : 0; } else if (_238 === 5) { - const _291: rt.Iter = a; - const _293: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2112: rt.u8): rt.u8 => { - const x131: rt.u8 = _2112; - const _6178: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6178.value, x131 ^ 4); - rt.refMutRelease(_6178); + const _291: rs.Iter = a; + const _293: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2112: rs.u8): rs.u8 => { + const x131: rs.u8 = _2112; + const _6178: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6178.value, x131 ^ 4); + rs.refMutRelease(_6178); return x131; - }), (_2113: rt.u8): boolean => { + }), (_2113: rs.u8): boolean => { return false; }); - const order11 = rt.iterCmp(rt.iterBorrow(_291), _293, rt.cmp); + const order11 = rs.iterCmp(rs.iterBorrow(_291), _293, rs.cmp); r2 = order11 !== undefined && order11 >= 0 ? 1 : 0; } else if (_238 === 6) { - const _303: rt.Iter = a; - const _305: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2110: rt.u8): rt.u8 => { - const x130: rt.u8 = _2110; - const _6177: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6177.value, x130 ^ 4); - rt.refMutRelease(_6177); + const _303: rs.Iter = a; + const _305: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2110: rs.u8): rs.u8 => { + const x130: rs.u8 = _2110; + const _6177: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6177.value, x130 ^ 4); + rs.refMutRelease(_6177); return x130; - }), (_2111: rt.u8): boolean => { + }), (_2111: rs.u8): boolean => { return false; }); - const part12 = rt.iterCmp(rt.iterBorrow(_303), _305, rt.cmp); + const part12 = rs.iterCmp(rs.iterBorrow(_303), _305, rs.cmp); r2 = _23(part12); } else if (_238 === 7) { - const _313: rt.Iter = a; - const _315: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2108: rt.u8): rt.u8 => { - const x128: rt.u8 = _2108; - const _6176: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6176.value, x128 ^ 4); - rt.refMutRelease(_6176); + const _313: rs.Iter = a; + const _315: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2108: rs.u8): rs.u8 => { + const x128: rs.u8 = _2108; + const _6176: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6176.value, x128 ^ 4); + rs.refMutRelease(_6176); return x128; - }), (_2109: rt.u8): boolean => { + }), (_2109: rs.u8): boolean => { return false; }); - const _322: (a0: rt.u8, a1: rt.u8) => boolean = (x129: rt.u8, y20: rt.u8): boolean => { - calls4 = rt.u8Add(calls4, 1); + const _322: (a0: rs.u8, a1: rs.u8) => boolean = (x129: rs.u8, y20: rs.u8): boolean => { + calls4 = rs.u8Add(calls4, 1); return x129 === y20; }; - r2 = rt.iterEq(rt.iterBorrow(_313), _315, _322) ? 1 : 0; + r2 = rs.iterEq(rs.iterBorrow(_313), _315, _322) ? 1 : 0; } else { - const _327: rt.Iter = a; - const _329: rt.Iter = rt.iterSkipWhile(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_2106: rt.u8): rt.u8 => { - const x126: rt.u8 = _2106; - const _6175: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6175.value, x126 ^ 4); - rt.refMutRelease(_6175); + const _327: rs.Iter = a; + const _329: rs.Iter = rs.iterSkipWhile(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_2106: rs.u8): rs.u8 => { + const x126: rs.u8 = _2106; + const _6175: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6175.value, x126 ^ 4); + rs.refMutRelease(_6175); return x126; - }), (_2107: rt.u8): boolean => { + }), (_2107: rs.u8): boolean => { return false; }); - const _336: (a0: rt.u8, a1: rt.u8) => rt.Ordering | undefined = (x127: rt.u8, y19: rt.u8): rt.Ordering | undefined => { - calls4 = rt.u8Add(calls4, 1); - return rt.cmp(x127, y19); + const _336: (a0: rs.u8, a1: rs.u8) => rs.Ordering | undefined = (x127: rs.u8, y19: rs.u8): rs.Ordering | undefined => { + calls4 = rs.u8Add(calls4, 1); + return rs.cmp(x127, y19); }; - const part11 = rt.iterCmp(rt.iterBorrow(_327), _329, _336); + const part11 = rs.iterCmp(rs.iterBorrow(_327), _329, _336); r2 = _23(part11); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r2, calls4)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r2, calls4)), undefined, true); } - rt.byteVecPush(out, calls3); - rt.byteVecPush(out, rt.iterCount(a) & 0xff); + rs.byteVecPush(out, calls3); + rs.byteVecPush(out, rs.iterCount(a) & 0xff); } else if (_24 === 2) { - const b: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(other))), (_282: rt.u8): rt.f32 => { - const x113: rt.u8 = _282; - const _7172: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7172.value, x113 ^ 6); - rt.refMutRelease(_7172); + const b: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(other))), (_282: rs.u8): rs.f32 => { + const x113: rs.u8 = _282; + const _7172: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7172.value, x113 ^ 6); + rs.refMutRelease(_7172); if (!(x113 === 255)) { return Math.fround(x113); } return NaN; }), undefined, 4, true); - let calls5: rt.u8 = 0; - const _357: rt.u8 = rt.u8Rem(kind, 16); + let calls5: rs.u8 = 0; + const _357: rs.u8 = rs.u8Rem(kind, 16); if (_357 === 0) { - r3 = rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2103: rt.u8): rt.f32 => { - const x124: rt.u8 = _2103; - const _7181: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7181.value, x124 ^ 5); - rt.refMutRelease(_7181); + r3 = rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2103: rs.u8): rs.f32 => { + const x124: rs.u8 = _2103; + const _7181: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7181.value, x124 ^ 5); + rs.refMutRelease(_7181); if (!(x124 === 255)) { return Math.fround(x124); } return NaN; - }), rt.vecIntoIter(b), rt.same, true) ? 1 : 0; + }), rs.vecIntoIter(b), rs.same, true) ? 1 : 0; } else if (_357 === 1) { - r3 = !rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2102: rt.u8): rt.f32 => { - const x123: rt.u8 = _2102; - const _7180: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7180.value, x123 ^ 5); - rt.refMutRelease(_7180); + r3 = !rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2102: rs.u8): rs.f32 => { + const x123: rs.u8 = _2102; + const _7180: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7180.value, x123 ^ 5); + rs.refMutRelease(_7180); if (!(x123 === 255)) { return Math.fround(x123); } return NaN; - }), rt.vecIntoIter(b), rt.same, true) ? 1 : 0; + }), rs.vecIntoIter(b), rs.same, true) ? 1 : 0; } else if (_357 === 2) { - r3 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2101: rt.u8): rt.f32 => { - const x122: rt.u8 = _2101; - const _7179: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7179.value, x122 ^ 5); - rt.refMutRelease(_7179); + r3 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2101: rs.u8): rs.f32 => { + const x122: rs.u8 = _2101; + const _7179: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7179.value, x122 ^ 5); + rs.refMutRelease(_7179); if (!(x122 === 255)) { return Math.fround(x122); } return NaN; - }), rt.vecIntoIter(b), rt.f32PartialCmp) === -1 ? 1 : 0; + }), rs.vecIntoIter(b), rs.f32PartialCmp) === -1 ? 1 : 0; } else if (_357 === 3) { - const order10 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2100: rt.u8): rt.f32 => { - const x121: rt.u8 = _2100; - const _7178: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7178.value, x121 ^ 5); - rt.refMutRelease(_7178); + const order10 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2100: rs.u8): rs.f32 => { + const x121: rs.u8 = _2100; + const _7178: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7178.value, x121 ^ 5); + rs.refMutRelease(_7178); if (!(x121 === 255)) { return Math.fround(x121); } return NaN; - }), rt.vecIntoIter(b), rt.f32PartialCmp); + }), rs.vecIntoIter(b), rs.f32PartialCmp); r3 = order10 !== undefined && order10 <= 0 ? 1 : 0; } else if (_357 === 4) { - r3 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_299: rt.u8): rt.f32 => { - const x120: rt.u8 = _299; - const _7177: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7177.value, x120 ^ 5); - rt.refMutRelease(_7177); + r3 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_299: rs.u8): rs.f32 => { + const x120: rs.u8 = _299; + const _7177: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7177.value, x120 ^ 5); + rs.refMutRelease(_7177); if (!(x120 === 255)) { return Math.fround(x120); } return NaN; - }), rt.vecIntoIter(b), rt.f32PartialCmp) === 1 ? 1 : 0; + }), rs.vecIntoIter(b), rs.f32PartialCmp) === 1 ? 1 : 0; } else if (_357 === 5) { - const order9 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_297: rt.u8): rt.f32 => { - const x119: rt.u8 = _297; - const _7176: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7176.value, x119 ^ 5); - rt.refMutRelease(_7176); + const order9 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_297: rs.u8): rs.f32 => { + const x119: rs.u8 = _297; + const _7176: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7176.value, x119 ^ 5); + rs.refMutRelease(_7176); if (!(x119 === 255)) { return Math.fround(x119); } return NaN; - }), rt.vecIntoIter(b), rt.f32PartialCmp); + }), rs.vecIntoIter(b), rs.f32PartialCmp); r3 = order9 !== undefined && order9 >= 0 ? 1 : 0; } else if (_357 === 6) { - const part10 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_292: rt.u8): rt.f32 => { - const x118: rt.u8 = _292; - const _7175: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7175.value, x118 ^ 5); - rt.refMutRelease(_7175); + const part10 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_292: rs.u8): rs.f32 => { + const x118: rs.u8 = _292; + const _7175: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7175.value, x118 ^ 5); + rs.refMutRelease(_7175); if (!(x118 === 255)) { return Math.fround(x118); } return NaN; - }), rt.vecIntoIter(b), rt.f32PartialCmp); + }), rs.vecIntoIter(b), rs.f32PartialCmp); r3 = _23(part10); } else if (_357 === 7) { - const _397: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_289: rt.u8): rt.f32 => { - const x116: rt.u8 = _289; - const _7174: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7174.value, x116 ^ 5); - rt.refMutRelease(_7174); + const _397: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_289: rs.u8): rs.f32 => { + const x116: rs.u8 = _289; + const _7174: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7174.value, x116 ^ 5); + rs.refMutRelease(_7174); if (!(x116 === 255)) { return Math.fround(x116); } return NaN; }); - const _401: (a0: rt.f32, a1: rt.f32) => boolean = (x117: rt.f32, y18: rt.f32): boolean => { - calls5 = rt.u8Add(calls5, 1); + const _401: (a0: rs.f32, a1: rs.f32) => boolean = (x117: rs.f32, y18: rs.f32): boolean => { + calls5 = rs.u8Add(calls5, 1); return x117 === y18; }; - r3 = rt.iterEq(_397, rt.vecIntoIter(b), _401, true) ? 1 : 0; + r3 = rs.iterEq(_397, rs.vecIntoIter(b), _401, true) ? 1 : 0; } else { - const _406: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_287: rt.u8): rt.f32 => { - const x114: rt.u8 = _287; - const _7173: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_7173.value, x114 ^ 5); - rt.refMutRelease(_7173); + const _406: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_287: rs.u8): rs.f32 => { + const x114: rs.u8 = _287; + const _7173: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_7173.value, x114 ^ 5); + rs.refMutRelease(_7173); if (!(x114 === 255)) { return Math.fround(x114); } return NaN; }); - const _410: (a0: rt.f32, a1: rt.f32) => rt.Ordering | undefined = (x115: rt.f32, y17: rt.f32): rt.Ordering | undefined => { - calls5 = rt.u8Add(calls5, 1); - return rt.f32PartialCmp(x115, y17); + const _410: (a0: rs.f32, a1: rs.f32) => rs.Ordering | undefined = (x115: rs.f32, y17: rs.f32): rs.Ordering | undefined => { + calls5 = rs.u8Add(calls5, 1); + return rs.f32PartialCmp(x115, y17); }; - const part9 = rt.iterCmp(_406, rt.vecIntoIter(b), _410); + const part9 = rs.iterCmp(_406, rs.vecIntoIter(b), _410); r3 = _23(part9); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r3, calls5)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r3, calls5)), undefined, true); } else { - const lo: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _419: rt.u8 = rt.u8Rem(kind >> 4, 4); + const lo: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _419: rs.u8 = rs.u8Rem(kind >> 4, 4); if (_419 === 0) { - let calls6: rt.u8 = 0; - const _426: rt.u8 = rt.u8Rem(kind, 16); + let calls6: rs.u8 = 0; + const _426: rs.u8 = rs.u8Rem(kind, 16); if (_426 === 9) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_279: rt.u8): rt.u8 => { - const x111: rt.u8 = _279; - const _6172: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6172.value, x111 ^ 7); - rt.refMutRelease(_6172); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_279: rs.u8): rs.u8 => { + const x111: rs.u8 = _279; + const _6172: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6172.value, x111 ^ 7); + rs.refMutRelease(_6172); return x111; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x112: rt.u8): rt.u8 => { - const _6173: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6173.value, x112 ^ 8); - rt.refMutRelease(_6173); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x112: rs.u8): rs.u8 => { + const _6173: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6173.value, x112 ^ 8); + rs.refMutRelease(_6173); return x112; - }), rt.cmp) & 0xff); + }), rs.cmp) & 0xff); } else if (_426 === 10) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_277: rt.u8): rt.u8 => { - const x108: rt.u8 = _277; - const _6170: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6170.value, x108 ^ 7); - rt.refMutRelease(_6170); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_277: rs.u8): rs.u8 => { + const x108: rs.u8 = _277; + const _6170: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6170.value, x108 ^ 7); + rs.refMutRelease(_6170); return x108; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x109: rt.u8): rt.u8 => { - const _6171: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6171.value, x109 ^ 8); - rt.refMutRelease(_6171); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x109: rs.u8): rs.u8 => { + const _6171: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6171.value, x109 ^ 8); + rs.refMutRelease(_6171); return x109; - }), (x110: rt.u8, y16: rt.u8): rt.Ordering => { - calls6 = rt.u8Add(calls6, 1); - return rt.cmp(x110, y16); + }), (x110: rs.u8, y16: rs.u8): rs.Ordering => { + calls6 = rs.u8Add(calls6, 1); + return rs.cmp(x110, y16); }) & 0xff); } else if (_426 === 11) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_272: rt.u8): rt.u8 => { - const x105: rt.u8 = _272; - const _6167: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6167.value, x105 ^ 7); - rt.refMutRelease(_6167); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_272: rs.u8): rs.u8 => { + const x105: rs.u8 = _272; + const _6167: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6167.value, x105 ^ 7); + rs.refMutRelease(_6167); return x105; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x106: rt.u8): rt.u8 => { - const _6168: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6168.value, x106 ^ 8); - rt.refMutRelease(_6168); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x106: rs.u8): rs.u8 => { + const _6168: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6168.value, x106 ^ 8); + rs.refMutRelease(_6168); return x106; - }), (x107: rt.u8, y15: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x107, y15), rt.u8Add(y15, x107)); + }), (x107: rs.u8, y15: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x107, y15), rs.u8Add(y15, x107)); }) & 0xff); } else { - let calls7: rt.u8 = 0; - const _465: rt.u8 = rt.u8Rem(kind, 16); + let calls7: rs.u8 = 0; + const _465: rs.u8 = rs.u8Rem(kind, 16); if (_465 === 0) { - r4 = rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_269: rt.u8): rt.u8 => { - const x103: rt.u8 = _269; - const _6165: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6165.value, x103 ^ 7); - rt.refMutRelease(_6165); + r4 = rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_269: rs.u8): rs.u8 => { + const x103: rs.u8 = _269; + const _6165: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6165.value, x103 ^ 7); + rs.refMutRelease(_6165); return x103; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x104: rt.u8): rt.u8 => { - const _6166: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6166.value, x104 ^ 8); - rt.refMutRelease(_6166); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x104: rs.u8): rs.u8 => { + const _6166: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6166.value, x104 ^ 8); + rs.refMutRelease(_6166); return x104; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_465 === 1) { - r4 = !rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_267: rt.u8): rt.u8 => { - const x101: rt.u8 = _267; - const _6163: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6163.value, x101 ^ 7); - rt.refMutRelease(_6163); + r4 = !rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_267: rs.u8): rs.u8 => { + const x101: rs.u8 = _267; + const _6163: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6163.value, x101 ^ 7); + rs.refMutRelease(_6163); return x101; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x102: rt.u8): rt.u8 => { - const _6164: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6164.value, x102 ^ 8); - rt.refMutRelease(_6164); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x102: rs.u8): rs.u8 => { + const _6164: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6164.value, x102 ^ 8); + rs.refMutRelease(_6164); return x102; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_465 === 2) { - r4 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_262: rt.u8): rt.u8 => { - const x99: rt.u8 = _262; - const _6161: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6161.value, x99 ^ 7); - rt.refMutRelease(_6161); + r4 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_262: rs.u8): rs.u8 => { + const x99: rs.u8 = _262; + const _6161: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6161.value, x99 ^ 7); + rs.refMutRelease(_6161); return x99; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x100: rt.u8): rt.u8 => { - const _6162: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6162.value, x100 ^ 8); - rt.refMutRelease(_6162); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x100: rs.u8): rs.u8 => { + const _6162: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6162.value, x100 ^ 8); + rs.refMutRelease(_6162); return x100; - }), rt.cmp) === -1 ? 1 : 0; + }), rs.cmp) === -1 ? 1 : 0; } else if (_465 === 3) { - const order8 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_259: rt.u8): rt.u8 => { - const x97: rt.u8 = _259; - const _6159: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6159.value, x97 ^ 7); - rt.refMutRelease(_6159); + const order8 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_259: rs.u8): rs.u8 => { + const x97: rs.u8 = _259; + const _6159: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6159.value, x97 ^ 7); + rs.refMutRelease(_6159); return x97; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x98: rt.u8): rt.u8 => { - const _6160: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6160.value, x98 ^ 8); - rt.refMutRelease(_6160); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x98: rs.u8): rs.u8 => { + const _6160: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6160.value, x98 ^ 8); + rs.refMutRelease(_6160); return x98; - }), rt.cmp); + }), rs.cmp); r4 = order8 !== undefined && order8 <= 0 ? 1 : 0; } else if (_465 === 4) { - r4 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_257: rt.u8): rt.u8 => { - const x95: rt.u8 = _257; - const _6157: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6157.value, x95 ^ 7); - rt.refMutRelease(_6157); + r4 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_257: rs.u8): rs.u8 => { + const x95: rs.u8 = _257; + const _6157: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6157.value, x95 ^ 7); + rs.refMutRelease(_6157); return x95; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x96: rt.u8): rt.u8 => { - const _6158: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6158.value, x96 ^ 8); - rt.refMutRelease(_6158); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x96: rs.u8): rs.u8 => { + const _6158: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6158.value, x96 ^ 8); + rs.refMutRelease(_6158); return x96; - }), rt.cmp) === 1 ? 1 : 0; + }), rs.cmp) === 1 ? 1 : 0; } else if (_465 === 5) { - const order7 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_252: rt.u8): rt.u8 => { - const x93: rt.u8 = _252; - const _6155: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6155.value, x93 ^ 7); - rt.refMutRelease(_6155); + const order7 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_252: rs.u8): rs.u8 => { + const x93: rs.u8 = _252; + const _6155: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6155.value, x93 ^ 7); + rs.refMutRelease(_6155); return x93; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x94: rt.u8): rt.u8 => { - const _6156: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6156.value, x94 ^ 8); - rt.refMutRelease(_6156); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x94: rs.u8): rs.u8 => { + const _6156: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6156.value, x94 ^ 8); + rs.refMutRelease(_6156); return x94; - }), rt.cmp); + }), rs.cmp); r4 = order7 !== undefined && order7 >= 0 ? 1 : 0; } else if (_465 === 6) { - const part8 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_249: rt.u8): rt.u8 => { - const x91: rt.u8 = _249; - const _6153: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6153.value, x91 ^ 7); - rt.refMutRelease(_6153); + const part8 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_249: rs.u8): rs.u8 => { + const x91: rs.u8 = _249; + const _6153: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6153.value, x91 ^ 7); + rs.refMutRelease(_6153); return x91; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x92: rt.u8): rt.u8 => { - const _6154: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6154.value, x92 ^ 8); - rt.refMutRelease(_6154); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x92: rs.u8): rs.u8 => { + const _6154: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6154.value, x92 ^ 8); + rs.refMutRelease(_6154); return x92; - }), rt.cmp); + }), rs.cmp); r4 = _23(part8); } else if (_465 === 7) { - r4 = rt.iterEq(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_247: rt.u8): rt.u8 => { - const x88: rt.u8 = _247; - const _6151: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6151.value, x88 ^ 7); - rt.refMutRelease(_6151); + r4 = rs.iterEq(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_247: rs.u8): rs.u8 => { + const x88: rs.u8 = _247; + const _6151: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6151.value, x88 ^ 7); + rs.refMutRelease(_6151); return x88; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x89: rt.u8): rt.u8 => { - const _6152: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6152.value, x89 ^ 8); - rt.refMutRelease(_6152); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x89: rs.u8): rs.u8 => { + const _6152: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6152.value, x89 ^ 8); + rs.refMutRelease(_6152); return x89; - }), (x90: rt.u8, y14: rt.u8): boolean => { - calls7 = rt.u8Add(calls7, 1); + }), (x90: rs.u8, y14: rs.u8): boolean => { + calls7 = rs.u8Add(calls7, 1); return x90 === y14; }, true) ? 1 : 0; } else { - const part7 = rt.iterCmp(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_242: rt.u8): rt.u8 => { - const x85: rt.u8 = _242; - const _6149: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6149.value, x85 ^ 7); - rt.refMutRelease(_6149); + const part7 = rs.iterCmp(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_242: rs.u8): rs.u8 => { + const x85: rs.u8 = _242; + const _6149: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6149.value, x85 ^ 7); + rs.refMutRelease(_6149); return x85; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x86: rt.u8): rt.u8 => { - const _6150: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6150.value, x86 ^ 8); - rt.refMutRelease(_6150); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x86: rs.u8): rs.u8 => { + const _6150: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6150.value, x86 ^ 8); + rs.refMutRelease(_6150); return x86; - }), (x87: rt.u8, y13: rt.u8): rt.Ordering | undefined => { - calls7 = rt.u8Add(calls7, 1); - return rt.cmp(x87, y13); + }), (x87: rs.u8, y13: rs.u8): rs.Ordering | undefined => { + calls7 = rs.u8Add(calls7, 1); + return rs.cmp(x87, y13); }); r4 = _23(part7); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r4, calls7)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r4, calls7)), undefined, true); } - rt.byteVecPush(out, calls6); + rs.byteVecPush(out, calls6); } else if (_419 === 1) { - let calls8: rt.u8 = 0; - const _564: rt.u8 = rt.u8Rem(kind, 16); + let calls8: rs.u8 = 0; + const _564: rs.u8 = rs.u8Rem(kind, 16); if (_564 === 9) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x83: rt.u8): rt.u8 => { - const _6147: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6147.value, x83 ^ 9); - rt.refMutRelease(_6147); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x83: rs.u8): rs.u8 => { + const _6147: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6147.value, x83 ^ 9); + rs.refMutRelease(_6147); return x83; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_237: rt.u8): rt.u8 => { - const x84: rt.u8 = _237; - const _6148: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6148.value, x84 ^ 10); - rt.refMutRelease(_6148); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_237: rs.u8): rs.u8 => { + const x84: rs.u8 = _237; + const _6148: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6148.value, x84 ^ 10); + rs.refMutRelease(_6148); return x84; - }), rt.cmp) & 0xff); + }), rs.cmp) & 0xff); } else if (_564 === 10) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x80: rt.u8): rt.u8 => { - const _6145: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6145.value, x80 ^ 9); - rt.refMutRelease(_6145); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x80: rs.u8): rs.u8 => { + const _6145: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6145.value, x80 ^ 9); + rs.refMutRelease(_6145); return x80; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_236: rt.u8): rt.u8 => { - const x81: rt.u8 = _236; - const _6146: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6146.value, x81 ^ 10); - rt.refMutRelease(_6146); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_236: rs.u8): rs.u8 => { + const x81: rs.u8 = _236; + const _6146: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6146.value, x81 ^ 10); + rs.refMutRelease(_6146); return x81; - }), (x82: rt.u8, y12: rt.u8): rt.Ordering => { - calls8 = rt.u8Add(calls8, 1); - return rt.cmp(x82, y12); + }), (x82: rs.u8, y12: rs.u8): rs.Ordering => { + calls8 = rs.u8Add(calls8, 1); + return rs.cmp(x82, y12); }) & 0xff); } else if (_564 === 11) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x77: rt.u8): rt.u8 => { - const _6142: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6142.value, x77 ^ 9); - rt.refMutRelease(_6142); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x77: rs.u8): rs.u8 => { + const _6142: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6142.value, x77 ^ 9); + rs.refMutRelease(_6142); return x77; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_234: rt.u8): rt.u8 => { - const x78: rt.u8 = _234; - const _6143: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6143.value, x78 ^ 10); - rt.refMutRelease(_6143); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_234: rs.u8): rs.u8 => { + const x78: rs.u8 = _234; + const _6143: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6143.value, x78 ^ 10); + rs.refMutRelease(_6143); return x78; - }), (x79: rt.u8, y11: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x79, y11), rt.u8Add(y11, x79)); + }), (x79: rs.u8, y11: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x79, y11), rs.u8Add(y11, x79)); }) & 0xff); } else { - let calls9: rt.u8 = 0; - const _603: rt.u8 = rt.u8Rem(kind, 16); + let calls9: rs.u8 = 0; + const _603: rs.u8 = rs.u8Rem(kind, 16); if (_603 === 0) { - r5 = rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x75: rt.u8): rt.u8 => { - const _6140: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6140.value, x75 ^ 9); - rt.refMutRelease(_6140); + r5 = rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x75: rs.u8): rs.u8 => { + const _6140: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6140.value, x75 ^ 9); + rs.refMutRelease(_6140); return x75; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_232: rt.u8): rt.u8 => { - const x76: rt.u8 = _232; - const _6141: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6141.value, x76 ^ 10); - rt.refMutRelease(_6141); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_232: rs.u8): rs.u8 => { + const x76: rs.u8 = _232; + const _6141: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6141.value, x76 ^ 10); + rs.refMutRelease(_6141); return x76; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_603 === 1) { - r5 = !rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x73: rt.u8): rt.u8 => { - const _6138: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6138.value, x73 ^ 9); - rt.refMutRelease(_6138); + r5 = !rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x73: rs.u8): rs.u8 => { + const _6138: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6138.value, x73 ^ 9); + rs.refMutRelease(_6138); return x73; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_227: rt.u8): rt.u8 => { - const x74: rt.u8 = _227; - const _6139: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6139.value, x74 ^ 10); - rt.refMutRelease(_6139); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_227: rs.u8): rs.u8 => { + const x74: rs.u8 = _227; + const _6139: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6139.value, x74 ^ 10); + rs.refMutRelease(_6139); return x74; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_603 === 2) { - r5 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x71: rt.u8): rt.u8 => { - const _6136: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6136.value, x71 ^ 9); - rt.refMutRelease(_6136); + r5 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x71: rs.u8): rs.u8 => { + const _6136: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6136.value, x71 ^ 9); + rs.refMutRelease(_6136); return x71; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_222: rt.u8): rt.u8 => { - const x72: rt.u8 = _222; - const _6137: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6137.value, x72 ^ 10); - rt.refMutRelease(_6137); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_222: rs.u8): rs.u8 => { + const x72: rs.u8 = _222; + const _6137: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6137.value, x72 ^ 10); + rs.refMutRelease(_6137); return x72; - }), rt.cmp) === -1 ? 1 : 0; + }), rs.cmp) === -1 ? 1 : 0; } else if (_603 === 3) { - const order6 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x69: rt.u8): rt.u8 => { - const _6134: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6134.value, x69 ^ 9); - rt.refMutRelease(_6134); + const order6 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x69: rs.u8): rs.u8 => { + const _6134: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6134.value, x69 ^ 9); + rs.refMutRelease(_6134); return x69; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_220: rt.u8): rt.u8 => { - const x70: rt.u8 = _220; - const _6135: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6135.value, x70 ^ 10); - rt.refMutRelease(_6135); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_220: rs.u8): rs.u8 => { + const x70: rs.u8 = _220; + const _6135: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6135.value, x70 ^ 10); + rs.refMutRelease(_6135); return x70; - }), rt.cmp); + }), rs.cmp); r5 = order6 !== undefined && order6 <= 0 ? 1 : 0; } else if (_603 === 4) { - r5 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x67: rt.u8): rt.u8 => { - const _6132: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6132.value, x67 ^ 9); - rt.refMutRelease(_6132); + r5 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x67: rs.u8): rs.u8 => { + const _6132: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6132.value, x67 ^ 9); + rs.refMutRelease(_6132); return x67; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.u8 => { - const x68: rt.u8 = _218; - const _6133: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6133.value, x68 ^ 10); - rt.refMutRelease(_6133); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.u8 => { + const x68: rs.u8 = _218; + const _6133: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6133.value, x68 ^ 10); + rs.refMutRelease(_6133); return x68; - }), rt.cmp) === 1 ? 1 : 0; + }), rs.cmp) === 1 ? 1 : 0; } else if (_603 === 5) { - const order5 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x65: rt.u8): rt.u8 => { - const _6130: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6130.value, x65 ^ 9); - rt.refMutRelease(_6130); + const order5 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x65: rs.u8): rs.u8 => { + const _6130: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6130.value, x65 ^ 9); + rs.refMutRelease(_6130); return x65; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): rt.u8 => { - const x66: rt.u8 = _213; - const _6131: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6131.value, x66 ^ 10); - rt.refMutRelease(_6131); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): rs.u8 => { + const x66: rs.u8 = _213; + const _6131: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6131.value, x66 ^ 10); + rs.refMutRelease(_6131); return x66; - }), rt.cmp); + }), rs.cmp); r5 = order5 !== undefined && order5 >= 0 ? 1 : 0; } else if (_603 === 6) { - const part6 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x63: rt.u8): rt.u8 => { - const _6128: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6128.value, x63 ^ 9); - rt.refMutRelease(_6128); + const part6 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x63: rs.u8): rs.u8 => { + const _6128: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6128.value, x63 ^ 9); + rs.refMutRelease(_6128); return x63; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.u8 => { - const x64: rt.u8 = _28; - const _6129: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6129.value, x64 ^ 10); - rt.refMutRelease(_6129); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.u8 => { + const x64: rs.u8 = _28; + const _6129: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6129.value, x64 ^ 10); + rs.refMutRelease(_6129); return x64; - }), rt.cmp); + }), rs.cmp); r5 = _23(part6); } else if (_603 === 7) { - r5 = rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x60: rt.u8): rt.u8 => { - const _6126: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6126.value, x60 ^ 9); - rt.refMutRelease(_6126); + r5 = rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x60: rs.u8): rs.u8 => { + const _6126: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6126.value, x60 ^ 9); + rs.refMutRelease(_6126); return x60; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 => { - const x61: rt.u8 = _27; - const _6127: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6127.value, x61 ^ 10); - rt.refMutRelease(_6127); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 => { + const x61: rs.u8 = _27; + const _6127: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6127.value, x61 ^ 10); + rs.refMutRelease(_6127); return x61; - }), (x62: rt.u8, y10: rt.u8): boolean => { - calls9 = rt.u8Add(calls9, 1); + }), (x62: rs.u8, y10: rs.u8): boolean => { + calls9 = rs.u8Add(calls9, 1); return x62 === y10; }, true) ? 1 : 0; } else { - const part5 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x57: rt.u8): rt.u8 => { - const _6124: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6124.value, x57 ^ 9); - rt.refMutRelease(_6124); + const part5 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x57: rs.u8): rs.u8 => { + const _6124: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6124.value, x57 ^ 9); + rs.refMutRelease(_6124); return x57; - }), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { - const x58: rt.u8 = _2; - const _6125: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6125.value, x58 ^ 10); - rt.refMutRelease(_6125); + }), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { + const x58: rs.u8 = _2; + const _6125: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6125.value, x58 ^ 10); + rs.refMutRelease(_6125); return x58; - }), (x59: rt.u8, y9: rt.u8): rt.Ordering | undefined => { - calls9 = rt.u8Add(calls9, 1); - return rt.cmp(x59, y9); + }), (x59: rs.u8, y9: rs.u8): rs.Ordering | undefined => { + calls9 = rs.u8Add(calls9, 1); + return rs.cmp(x59, y9); }); r5 = _23(part5); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r5, calls9)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r5, calls9)), undefined, true); } - rt.byteVecPush(out, calls8); + rs.byteVecPush(out, calls8); } else if (_419 === 2) { - let calls10: rt.u8 = 0; - const _702: rt.u8 = rt.u8Rem(kind, 16); + let calls10: rs.u8 = 0; + const _702: rs.u8 = rs.u8Rem(kind, 16); if (_702 === 9) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x55: rt.u8): rt.u8 => { - const _6122: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6122.value, x55 ^ 11); - rt.refMutRelease(_6122); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x55: rs.u8): rs.u8 => { + const _6122: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6122.value, x55 ^ 11); + rs.refMutRelease(_6122); return x55; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x56: rt.u8): rt.u8 => { - const _6123: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6123.value, x56 ^ 12); - rt.refMutRelease(_6123); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x56: rs.u8): rs.u8 => { + const _6123: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6123.value, x56 ^ 12); + rs.refMutRelease(_6123); return x56; - }), rt.cmp) & 0xff); + }), rs.cmp) & 0xff); } else if (_702 === 10) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x52: rt.u8): rt.u8 => { - const _6120: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6120.value, x52 ^ 11); - rt.refMutRelease(_6120); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x52: rs.u8): rs.u8 => { + const _6120: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6120.value, x52 ^ 11); + rs.refMutRelease(_6120); return x52; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x53: rt.u8): rt.u8 => { - const _6121: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6121.value, x53 ^ 12); - rt.refMutRelease(_6121); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x53: rs.u8): rs.u8 => { + const _6121: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6121.value, x53 ^ 12); + rs.refMutRelease(_6121); return x53; - }), (x54: rt.u8, y8: rt.u8): rt.Ordering => { - calls10 = rt.u8Add(calls10, 1); - return rt.cmp(x54, y8); + }), (x54: rs.u8, y8: rs.u8): rs.Ordering => { + calls10 = rs.u8Add(calls10, 1); + return rs.cmp(x54, y8); }) & 0xff); } else if (_702 === 11) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x49: rt.u8): rt.u8 => { - const _6117: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6117.value, x49 ^ 11); - rt.refMutRelease(_6117); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x49: rs.u8): rs.u8 => { + const _6117: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6117.value, x49 ^ 11); + rs.refMutRelease(_6117); return x49; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x50: rt.u8): rt.u8 => { - const _6118: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6118.value, x50 ^ 12); - rt.refMutRelease(_6118); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x50: rs.u8): rs.u8 => { + const _6118: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6118.value, x50 ^ 12); + rs.refMutRelease(_6118); return x50; - }), (x51: rt.u8, y7: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x51, y7), rt.u8Add(y7, x51)); + }), (x51: rs.u8, y7: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x51, y7), rs.u8Add(y7, x51)); }) & 0xff); } else { - let calls11: rt.u8 = 0; - const _741: rt.u8 = rt.u8Rem(kind, 16); + let calls11: rs.u8 = 0; + const _741: rs.u8 = rs.u8Rem(kind, 16); if (_741 === 0) { - r6 = rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x47: rt.u8): rt.u8 => { - const _6115: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6115.value, x47 ^ 11); - rt.refMutRelease(_6115); + r6 = rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x47: rs.u8): rs.u8 => { + const _6115: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6115.value, x47 ^ 11); + rs.refMutRelease(_6115); return x47; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x48: rt.u8): rt.u8 => { - const _6116: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6116.value, x48 ^ 12); - rt.refMutRelease(_6116); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x48: rs.u8): rs.u8 => { + const _6116: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6116.value, x48 ^ 12); + rs.refMutRelease(_6116); return x48; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_741 === 1) { - r6 = !rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x45: rt.u8): rt.u8 => { - const _6113: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6113.value, x45 ^ 11); - rt.refMutRelease(_6113); + r6 = !rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x45: rs.u8): rs.u8 => { + const _6113: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6113.value, x45 ^ 11); + rs.refMutRelease(_6113); return x45; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x46: rt.u8): rt.u8 => { - const _6114: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6114.value, x46 ^ 12); - rt.refMutRelease(_6114); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x46: rs.u8): rs.u8 => { + const _6114: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6114.value, x46 ^ 12); + rs.refMutRelease(_6114); return x46; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_741 === 2) { - r6 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x43: rt.u8): rt.u8 => { - const _6111: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6111.value, x43 ^ 11); - rt.refMutRelease(_6111); + r6 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x43: rs.u8): rs.u8 => { + const _6111: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6111.value, x43 ^ 11); + rs.refMutRelease(_6111); return x43; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x44: rt.u8): rt.u8 => { - const _6112: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6112.value, x44 ^ 12); - rt.refMutRelease(_6112); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x44: rs.u8): rs.u8 => { + const _6112: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6112.value, x44 ^ 12); + rs.refMutRelease(_6112); return x44; - }), rt.cmp) === -1 ? 1 : 0; + }), rs.cmp) === -1 ? 1 : 0; } else if (_741 === 3) { - const order4 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x41: rt.u8): rt.u8 => { - const _6109: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6109.value, x41 ^ 11); - rt.refMutRelease(_6109); + const order4 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x41: rs.u8): rs.u8 => { + const _6109: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6109.value, x41 ^ 11); + rs.refMutRelease(_6109); return x41; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x42: rt.u8): rt.u8 => { - const _6110: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6110.value, x42 ^ 12); - rt.refMutRelease(_6110); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x42: rs.u8): rs.u8 => { + const _6110: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6110.value, x42 ^ 12); + rs.refMutRelease(_6110); return x42; - }), rt.cmp); + }), rs.cmp); r6 = order4 !== undefined && order4 <= 0 ? 1 : 0; } else if (_741 === 4) { - r6 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x39: rt.u8): rt.u8 => { - const _6107: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6107.value, x39 ^ 11); - rt.refMutRelease(_6107); + r6 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x39: rs.u8): rs.u8 => { + const _6107: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6107.value, x39 ^ 11); + rs.refMutRelease(_6107); return x39; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x40: rt.u8): rt.u8 => { - const _6108: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6108.value, x40 ^ 12); - rt.refMutRelease(_6108); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x40: rs.u8): rs.u8 => { + const _6108: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6108.value, x40 ^ 12); + rs.refMutRelease(_6108); return x40; - }), rt.cmp) === 1 ? 1 : 0; + }), rs.cmp) === 1 ? 1 : 0; } else if (_741 === 5) { - const order3 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x37: rt.u8): rt.u8 => { - const _6105: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6105.value, x37 ^ 11); - rt.refMutRelease(_6105); + const order3 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x37: rs.u8): rs.u8 => { + const _6105: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6105.value, x37 ^ 11); + rs.refMutRelease(_6105); return x37; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x38: rt.u8): rt.u8 => { - const _6106: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6106.value, x38 ^ 12); - rt.refMutRelease(_6106); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x38: rs.u8): rs.u8 => { + const _6106: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6106.value, x38 ^ 12); + rs.refMutRelease(_6106); return x38; - }), rt.cmp); + }), rs.cmp); r6 = order3 !== undefined && order3 >= 0 ? 1 : 0; } else if (_741 === 6) { - const part4 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x35: rt.u8): rt.u8 => { - const _6103: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6103.value, x35 ^ 11); - rt.refMutRelease(_6103); + const part4 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x35: rs.u8): rs.u8 => { + const _6103: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6103.value, x35 ^ 11); + rs.refMutRelease(_6103); return x35; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x36: rt.u8): rt.u8 => { - const _6104: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6104.value, x36 ^ 12); - rt.refMutRelease(_6104); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x36: rs.u8): rs.u8 => { + const _6104: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6104.value, x36 ^ 12); + rs.refMutRelease(_6104); return x36; - }), rt.cmp); + }), rs.cmp); r6 = _23(part4); } else if (_741 === 7) { - r6 = rt.iterEq(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x32: rt.u8): rt.u8 => { - const _6101: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6101.value, x32 ^ 11); - rt.refMutRelease(_6101); + r6 = rs.iterEq(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x32: rs.u8): rs.u8 => { + const _6101: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6101.value, x32 ^ 11); + rs.refMutRelease(_6101); return x32; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x33: rt.u8): rt.u8 => { - const _6102: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6102.value, x33 ^ 12); - rt.refMutRelease(_6102); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x33: rs.u8): rs.u8 => { + const _6102: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6102.value, x33 ^ 12); + rs.refMutRelease(_6102); return x33; - }), (x34: rt.u8, y6: rt.u8): boolean => { - calls11 = rt.u8Add(calls11, 1); + }), (x34: rs.u8, y6: rs.u8): boolean => { + calls11 = rs.u8Add(calls11, 1); return x34 === y6; }, true) ? 1 : 0; } else { - const part3 = rt.iterCmp(rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x29: rt.u8): rt.u8 => { - const _698: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_698.value, x29 ^ 11); - rt.refMutRelease(_698); + const part3 = rs.iterCmp(rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x29: rs.u8): rs.u8 => { + const _698: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_698.value, x29 ^ 11); + rs.refMutRelease(_698); return x29; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x30: rt.u8): rt.u8 => { - const _6100: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6100.value, x30 ^ 12); - rt.refMutRelease(_6100); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x30: rs.u8): rs.u8 => { + const _6100: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6100.value, x30 ^ 12); + rs.refMutRelease(_6100); return x30; - }), (x31: rt.u8, y5: rt.u8): rt.Ordering | undefined => { - calls11 = rt.u8Add(calls11, 1); - return rt.cmp(x31, y5); + }), (x31: rs.u8, y5: rs.u8): rs.Ordering | undefined => { + calls11 = rs.u8Add(calls11, 1); + return rs.cmp(x31, y5); }); r6 = _23(part3); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r6, calls11)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r6, calls11)), undefined, true); } - rt.byteVecPush(out, calls10); + rs.byteVecPush(out, calls10); } else { - let calls12: rt.u8 = 0; - const _840: rt.u8 = rt.u8Rem(kind, 16); + let calls12: rs.u8 = 0; + const _840: rs.u8 = rs.u8Rem(kind, 16); if (_840 === 9) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x27: rt.u8): rt.u8 => { - const _693: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_693.value, x27 ^ 13); - rt.refMutRelease(_693); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x27: rs.u8): rs.u8 => { + const _693: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_693.value, x27 ^ 13); + rs.refMutRelease(_693); return x27; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x28: rt.u8): rt.u8 => { - const _694: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_694.value, x28 ^ 14); - rt.refMutRelease(_694); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x28: rs.u8): rs.u8 => { + const _694: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_694.value, x28 ^ 14); + rs.refMutRelease(_694); return x28; - }), rt.cmp) & 0xff); + }), rs.cmp) & 0xff); } else if (_840 === 10) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x24: rt.u8): rt.u8 => { - const _687: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_687.value, x24 ^ 13); - rt.refMutRelease(_687); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x24: rs.u8): rs.u8 => { + const _687: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_687.value, x24 ^ 13); + rs.refMutRelease(_687); return x24; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x25: rt.u8): rt.u8 => { - const _691: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_691.value, x25 ^ 14); - rt.refMutRelease(_691); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x25: rs.u8): rs.u8 => { + const _691: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_691.value, x25 ^ 14); + rs.refMutRelease(_691); return x25; - }), (x26: rt.u8, y4: rt.u8): rt.Ordering => { - calls12 = rt.u8Add(calls12, 1); - return rt.cmp(x26, y4); + }), (x26: rs.u8, y4: rs.u8): rs.Ordering => { + calls12 = rs.u8Add(calls12, 1); + return rs.cmp(x26, y4); }) & 0xff); } else if (_840 === 11) { - rt.byteVecPush(out, rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x21: rt.u8): rt.u8 => { - const _678: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_678.value, x21 ^ 13); - rt.refMutRelease(_678); + rs.byteVecPush(out, rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x21: rs.u8): rs.u8 => { + const _678: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_678.value, x21 ^ 13); + rs.refMutRelease(_678); return x21; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x22: rt.u8): rt.u8 => { - const _680: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_680.value, x22 ^ 14); - rt.refMutRelease(_680); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x22: rs.u8): rs.u8 => { + const _680: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_680.value, x22 ^ 14); + rs.refMutRelease(_680); return x22; - }), (x23: rt.u8, y3: rt.u8): rt.Ordering => { - return rt.cmp(rt.u8Add(x23, y3), rt.u8Add(y3, x23)); + }), (x23: rs.u8, y3: rs.u8): rs.Ordering => { + return rs.cmp(rs.u8Add(x23, y3), rs.u8Add(y3, x23)); }) & 0xff); } else { - let calls13: rt.u8 = 0; - const _885: rt.u8 = rt.u8Rem(kind, 16); + let calls13: rs.u8 = 0; + const _885: rs.u8 = rs.u8Rem(kind, 16); if (_885 === 0) { - r7 = rt.iterEq(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x19: rt.u8): rt.u8 => { - const _669: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_669.value, x19 ^ 13); - rt.refMutRelease(_669); + r7 = rs.iterEq(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x19: rs.u8): rs.u8 => { + const _669: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_669.value, x19 ^ 13); + rs.refMutRelease(_669); return x19; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x20: rt.u8): rt.u8 => { - const _674: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_674.value, x20 ^ 14); - rt.refMutRelease(_674); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x20: rs.u8): rs.u8 => { + const _674: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_674.value, x20 ^ 14); + rs.refMutRelease(_674); return x20; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_885 === 1) { - r7 = !rt.iterEq(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x17: rt.u8): rt.u8 => { - const _659: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_659.value, x17 ^ 13); - rt.refMutRelease(_659); + r7 = !rs.iterEq(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x17: rs.u8): rs.u8 => { + const _659: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_659.value, x17 ^ 13); + rs.refMutRelease(_659); return x17; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x18: rt.u8): rt.u8 => { - const _665: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_665.value, x18 ^ 14); - rt.refMutRelease(_665); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x18: rs.u8): rs.u8 => { + const _665: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_665.value, x18 ^ 14); + rs.refMutRelease(_665); return x18; - }), rt.same, true) ? 1 : 0; + }), rs.same, true) ? 1 : 0; } else if (_885 === 2) { - r7 = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x15: rt.u8): rt.u8 => { - const _654: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_654.value, x15 ^ 13); - rt.refMutRelease(_654); + r7 = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x15: rs.u8): rs.u8 => { + const _654: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_654.value, x15 ^ 13); + rs.refMutRelease(_654); return x15; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x16: rt.u8): rt.u8 => { - const _658: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_658.value, x16 ^ 14); - rt.refMutRelease(_658); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x16: rs.u8): rs.u8 => { + const _658: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_658.value, x16 ^ 14); + rs.refMutRelease(_658); return x16; - }), rt.cmp) === -1 ? 1 : 0; + }), rs.cmp) === -1 ? 1 : 0; } else if (_885 === 3) { - const order2 = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x13: rt.u8): rt.u8 => { - const _645: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_645.value, x13 ^ 13); - rt.refMutRelease(_645); + const order2 = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x13: rs.u8): rs.u8 => { + const _645: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_645.value, x13 ^ 13); + rs.refMutRelease(_645); return x13; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x14: rt.u8): rt.u8 => { - const _649: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_649.value, x14 ^ 14); - rt.refMutRelease(_649); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x14: rs.u8): rs.u8 => { + const _649: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_649.value, x14 ^ 14); + rs.refMutRelease(_649); return x14; - }), rt.cmp); + }), rs.cmp); r7 = order2 !== undefined && order2 <= 0 ? 1 : 0; } else if (_885 === 4) { - r7 = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x11: rt.u8): rt.u8 => { - const _636: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_636.value, x11 ^ 13); - rt.refMutRelease(_636); + r7 = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x11: rs.u8): rs.u8 => { + const _636: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_636.value, x11 ^ 13); + rs.refMutRelease(_636); return x11; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x12: rt.u8): rt.u8 => { - const _640: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_640.value, x12 ^ 14); - rt.refMutRelease(_640); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x12: rs.u8): rs.u8 => { + const _640: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_640.value, x12 ^ 14); + rs.refMutRelease(_640); return x12; - }), rt.cmp) === 1 ? 1 : 0; + }), rs.cmp) === 1 ? 1 : 0; } else if (_885 === 5) { - const order = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x9: rt.u8): rt.u8 => { - const _627: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_627.value, x9 ^ 13); - rt.refMutRelease(_627); + const order = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x9: rs.u8): rs.u8 => { + const _627: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_627.value, x9 ^ 13); + rs.refMutRelease(_627); return x9; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x10: rt.u8): rt.u8 => { - const _631: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_631.value, x10 ^ 14); - rt.refMutRelease(_631); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x10: rs.u8): rs.u8 => { + const _631: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_631.value, x10 ^ 14); + rs.refMutRelease(_631); return x10; - }), rt.cmp); + }), rs.cmp); r7 = order !== undefined && order >= 0 ? 1 : 0; } else if (_885 === 6) { - const part2 = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x7: rt.u8): rt.u8 => { - const _618: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_618.value, x7 ^ 13); - rt.refMutRelease(_618); + const part2 = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x7: rs.u8): rs.u8 => { + const _618: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_618.value, x7 ^ 13); + rs.refMutRelease(_618); return x7; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x8: rt.u8): rt.u8 => { - const _622: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_622.value, x8 ^ 14); - rt.refMutRelease(_622); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x8: rs.u8): rs.u8 => { + const _622: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_622.value, x8 ^ 14); + rs.refMutRelease(_622); return x8; - }), rt.cmp); + }), rs.cmp); r7 = _23(part2); } else if (_885 === 7) { - r7 = rt.iterEq(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x4: rt.u8): rt.u8 => { - const _68: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_68.value, x4 ^ 13); - rt.refMutRelease(_68); + r7 = rs.iterEq(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x4: rs.u8): rs.u8 => { + const _68: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_68.value, x4 ^ 13); + rs.refMutRelease(_68); return x4; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x5: rt.u8): rt.u8 => { - const _613: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_613.value, x5 ^ 14); - rt.refMutRelease(_613); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x5: rs.u8): rs.u8 => { + const _613: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_613.value, x5 ^ 14); + rs.refMutRelease(_613); return x5; - }), (x6: rt.u8, y2: rt.u8): boolean => { - calls13 = rt.u8Add(calls13, 1); + }), (x6: rs.u8, y2: rs.u8): boolean => { + calls13 = rs.u8Add(calls13, 1); return x6 === y2; }, true) ? 1 : 0; } else { - const part = rt.iterCmp(rt.iterMap(rt.iterTake(new rt.RangeFrom(lo, rt.u8Step), data.length), (x: rt.u8): rt.u8 => { - const _6: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_6.value, x ^ 13); - rt.refMutRelease(_6); + const part = rs.iterCmp(rs.iterMap(rs.iterTake(new rs.RangeFrom(lo, rs.u8Step), data.length), (x: rs.u8): rs.u8 => { + const _6: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_6.value, x ^ 13); + rs.refMutRelease(_6); return x; - }), rt.iterMap(new rt.RangeFrom(lo, rt.u8Step), (x2: rt.u8): rt.u8 => { - const _64: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_64.value, x2 ^ 14); - rt.refMutRelease(_64); + }), rs.iterMap(new rs.RangeFrom(lo, rs.u8Step), (x2: rs.u8): rs.u8 => { + const _64: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_64.value, x2 ^ 14); + rs.refMutRelease(_64); return x2; - }), (x3: rt.u8, y: rt.u8): rt.Ordering | undefined => { - calls13 = rt.u8Add(calls13, 1); - return rt.cmp(x3, y); + }), (x3: rs.u8, y: rs.u8): rs.Ordering | undefined => { + calls13 = rs.u8Add(calls13, 1); + return rs.cmp(x3, y); }); r7 = _23(part); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(r7, calls13)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(r7, calls13)), undefined, true); } - rt.byteVecPush(out, calls12); + rs.byteVecPush(out, calls12); } } - const _1004: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_1004.value)); - rt.refRelease(_1004); + const _1004: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_1004.value)); + rs.refRelease(_1004); } /** @@ -11451,51 +11451,51 @@ export function compares(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `&mut dyn Iterator`: each advances the iterator it points at, which the original reads * on from where the borrow stopped, and writing through what it returns rebinds the local. */ -export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (_2: rt.u8): rt.usize => { - return rt.u8Rem(_2, 4) as rt.usize; +export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (_2: rs.u8): rs.usize => { + return rs.u8Rem(_2, 4) as rs.usize; }); - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const lent: rt.Iter = it; - rt.iterExtendBytes(out, rt.iterTake(rt.iterBorrow(lent), n), undefined, true); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(lent.next()), 170)); - rt.iterExtendBytes(out, rt.iterTake(rt.iterBorrow(it), 1), undefined, true); - let once: rt.Iter = it; - const twice: rt.Place> = rt.place(() => once, (value2) => once = value2); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.iterBorrow(twice.v), n), 187)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(twice.v.next()), 204)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it.next()), 221)); - const own: Countdown.Countdown = { left: rt.u8Mul(n & 0xff, 3), step: 2 }; + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const lent: rs.Iter = it; + rs.iterExtendBytes(out, rs.iterTake(rs.iterBorrow(lent), n), undefined, true); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(lent.next()), 170)); + rs.iterExtendBytes(out, rs.iterTake(rs.iterBorrow(it), 1), undefined, true); + let once: rs.Iter = it; + const twice: rs.Place> = rs.place(() => once, (value2) => once = value2); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterBorrow(twice.v), n), 187)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(twice.v.next()), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it.next()), 221)); + const own: Countdown.Countdown = { left: rs.u8Mul(n & 0xff, 3), step: 2 }; const other: Countdown.Countdown = { left: 9, step: 4 }; let held: Countdown.Countdown = own; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(Countdown.next$iter_Iterator(held)), 170)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(Countdown.next$iter_Iterator(held)), 170)); held = other; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(Countdown.next$iter_Iterator(held)), 187)); - rt.iterExtendBytes(out, rt.iterFrom(own, Countdown.next$iter_Iterator), "next"); - rt.iterExtendBytes(out, rt.iterFrom(other, Countdown.next$iter_Iterator), "next"); - const range: rt.Range = new rt.Range(0, rt.u8Mul(n & 0xff, 3)); - let erased: rt.Iter = rt.iterDyn(rt.iterBorrow(range)); - rt.iterExtendBytes(out, rt.iterTake(rt.iterStepBy(rt.iterBorrow(erased), 2), 2), "next"); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(erased.next()), 238)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(erased.next()), 238)); - rt.iterExtendBytes(out, range, undefined, true); - let boxed: rt.Iter = rt.iterDyn(rt.iterRev(rt.iterSlice(rt.byteSliceView(data)))); - rt.iterExtendBytes(out, rt.iterTake(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed))), n), "next"); - rt.iterExtendBytes(out, rt.iterTake(rt.iterBox(boxed), 1), "next"); - const rest: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - rt.iterExtendBytes(out, rt.byteVecIntoIter(halves$mut_iter_Copied_slice_Iter_u8(rest, n)), undefined, true); - rt.iterExtendBytes(out, rest, undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(halves$iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data)), n)), undefined, true); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(Countdown.next$iter_Iterator(held)), 187)); + rs.iterExtendBytes(out, rs.iterFrom(own, Countdown.next$iter_Iterator), "next"); + rs.iterExtendBytes(out, rs.iterFrom(other, Countdown.next$iter_Iterator), "next"); + const range: rs.Range = new rs.Range(0, rs.u8Mul(n & 0xff, 3)); + let erased: rs.Iter = rs.iterDyn(rs.iterBorrow(range)); + rs.iterExtendBytes(out, rs.iterTake(rs.iterStepBy(rs.iterBorrow(erased), 2), 2), "next"); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(erased.next()), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(erased.next()), 238)); + rs.iterExtendBytes(out, range, undefined, true); + let boxed: rs.Iter = rs.iterDyn(rs.iterRev(rs.iterSlice(rs.byteSliceView(data)))); + rs.iterExtendBytes(out, rs.iterTake(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed))), n), "next"); + rs.iterExtendBytes(out, rs.iterTake(rs.iterBox(boxed), 1), "next"); + const rest: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + rs.iterExtendBytes(out, rs.byteVecIntoIter(halves$mut_iter_Copied_slice_Iter_u8(rest, n)), undefined, true); + rs.iterExtendBytes(out, rest, undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(halves$iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), n)), undefined, true); } /** The first `n` items, then one more. */ -export function halves$iter_Copied_slice_Iter_u8(it: rt.Iter, n: rt.usize): rt.ByteVec { - return rt.byteSlicesJoin([rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it), n), undefined, true), rt.iterToByteVec(rt.iterTake(it, 1), undefined, true)], undefined, rt.byteVecSlice); +export function halves$iter_Copied_slice_Iter_u8(it: rs.Iter, n: rs.usize): rs.ByteVec { + return rs.byteSlicesJoin([rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it), n), undefined, true), rs.iterToByteVec(rs.iterTake(it, 1), undefined, true)], undefined, rs.byteVecSlice); } /** The first `n` items, then one more. */ -export function halves$mut_iter_Copied_slice_Iter_u8(it: rt.Iter, n: rt.usize): rt.ByteVec { - return rt.byteSlicesJoin([rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it), n), undefined, true), rt.iterToByteVec(rt.iterTake(rt.iterBorrow(it), 1), undefined, true)], undefined, rt.byteVecSlice); +export function halves$mut_iter_Copied_slice_Iter_u8(it: rs.Iter, n: rs.usize): rs.ByteVec { + return rs.byteSlicesJoin([rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it), n), undefined, true), rs.iterToByteVec(rs.iterTake(rs.iterBorrow(it), 1), undefined, true)], undefined, rs.byteVecSlice); } /** @@ -11503,164 +11503,164 @@ export function halves$mut_iter_Copied_slice_Iter_u8(it: rt.Iter, n: rt.u * shared as a struct's is, through adaptors, consumers, `for`, and `IntoIterator`, with * what each drops logged where it drops. */ -export function byValue(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let it!: rt.Peekable; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function byValue(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let it!: rs.Peekable; + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const phase: Phase.Phase = Phase.of(at(0)); const ticks: () => Ticks.Ticks = (): Ticks.Ticks => { - return { tag: "Left", _0: rt.u8Rem(at(1), 6), _1: new Noted.Noted(log, 208) } as Ticks.Ticks; + return { tag: "Left", _0: rs.u8Rem(at(1), 6), _1: new Noted.Noted(log, 208) } as Ticks.Ticks; }; const logged: () => Logged.Logged = (): Logged.Logged => { - return new Logged.Logged(rt.u8Rem(at(2), 5), log); + return new Logged.Logged(rs.u8Rem(at(2), 5), log); }; b0: { - const _18: rt.u8 = rt.u8Rem(kind, 13); + const _18: rs.u8 = rs.u8Rem(kind, 13); if (_18 === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n14: rt.u8): rt.u8 => { - return rt.u8Mul(n14, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n14: rs.u8): rs.u8 => { + return rs.u8Mul(n14, 3); }), "next"); } else if (_18 === 1) { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterFilter(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n13: rt.u8): boolean => { - return rt.u8Rem(n13, 2) === 0; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterFilter(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n13: rs.u8): boolean => { + return rs.u8Rem(n13, 2) === 0; }), "next")), undefined, true); } else if (_18 === 2) { const _26: Ticks.Ticks = ticks(); - rt.iterExtendBytes(out, rt.iterMap(rt.iterZip(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterFrom({ v: _26 }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v))), (_215: [rt.u8, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _26 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), (_215: [rs.u8, rs.u8]): rs.u8 => { return _215[0] ^ _215[1]; }), "next"); } else if (_18 === 3) { const _30: Ticks.Ticks = ticks(); const _32: Logged.Logged = logged(); - rt.iterExtendBytes(out, rt.iterMap(rt.iterZip(rt.iterFrom({ v: _30 }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v)), rt.iterFrom(_32, Logged.next$iter_Iterator, rt.drop)), (_214: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8Add(_214[0], _214[1]); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom({ v: _30 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.iterFrom(_32, Logged.next$iter_Iterator, rs.drop)), (_214: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8Add(_214[0], _214[1]); }), "next"); } else if (_18 === 4) { const _36: Ticks.Ticks = ticks(); - rt.iterExtendBytes(out, rt.iterChain(rt.iterChain(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterFrom({ v: _36 }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v))), rt.iterFrom(logged(), Logged.next$iter_Iterator, rt.drop)), "next"); + rs.iterExtendBytes(out, rs.iterChain(rs.iterChain(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _36 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop)), "next"); } else { if (_18 === 5) { let iter: Ticks.Ticks = ticks(); while (true) { - const _44: rt.u8 | rt.Done = Ticks.next$iter_Iterator(rt.place(() => iter, (value11) => iter = value11)); - if (_44 === rt.DONE) { + const _44: rs.u8 | rs.Done = Ticks.next$iter_Iterator(rs.place(() => iter, (value11) => iter = value11)); + if (_44 === rs.DONE) { break; } - const n: rt.u8 = _44; - const _51: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_51.value, n); - rt.refMutRelease(_51); + const n: rs.u8 = _44; + const _51: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_51.value, n); + rs.refMutRelease(_51); } drop$iters_Ticks(iter); let iter2: Phase.Phase = phase; while (true) { - const _55: rt.u8 | rt.Done = Phase.next$iter_Iterator(rt.place(() => iter2, (value12) => iter2 = value12)); - if (_55 === rt.DONE) { + const _55: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => iter2, (value12) => iter2 = value12)); + if (_55 === rs.DONE) { break b0; } - rt.byteVecPush(out, _55); + rs.byteVecPush(out, _55); } } if (_18 === 6) { - rt.byteVecPush(out, Phase.count$iter_Iterator(phase) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.ownedLast(rt.iterFrom({ v: Phase.of(at(1)) }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), 238)); - rt.byteVecPush(out, rt.iterFold(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 1, (acc: rt.u8, n12: rt.u8): rt.u8 => { + rs.byteVecPush(out, Phase.count$iter_Iterator(phase) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: Phase.of(at(1)) }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), 238)); + rs.byteVecPush(out, rs.iterFold(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 1, (acc: rs.u8, n12: rs.u8): rs.u8 => { return acc ^ n12; }, true)); - rt.byteVecPush(out, Phase.sizeHint$iter_Iterator(phase)[0] & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(rt.iterRev(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })).next()), 238)); + rs.byteVecPush(out, Phase.sizeHint$iter_Iterator(phase)[0] & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })).next()), 238)); } else if (_18 === 7) { - rt.byteVecPush(out, rt.ownedCount(rt.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v))) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.ownedLast(rt.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v))), 238)); - rt.byteVecPush(out, rt.iterSum(rt.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v)), rt.u8Add, 0, true)); + rs.byteVecPush(out, rs.ownedCount(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.ownedLast(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 238)); + rs.byteVecPush(out, rs.iterSum(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), rs.u8Add, 0, true)); let _100: Ticks.Ticks = ticks(); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.iterFrom(rt.place(() => _100, (value10) => _100 = value10), Ticks.next$iter_Iterator), 1), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.iterFrom(rs.place(() => _100, (value10) => _100 = value10), Ticks.next$iter_Iterator), 1), 238)); drop$iters_Ticks(_100); - rt.byteVecPush(out, rt.ownedCount(rt.iterTake(rt.iterFrom(logged(), Logged.next$iter_Iterator, rt.drop), 2)) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.iterTake(rs.iterFrom(logged(), Logged.next$iter_Iterator, rs.drop), 2)) & 0xff); } else if (_18 === 8) { - const v2: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(at(3))); + const v2: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(at(3))); const _115: Ticks.Ticks = ticks(); - rt.iterExtendBytes(v2, rt.iterFrom({ v: _115 }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v)), "next"); - rt.iterExtendBytes(v2, rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); + rs.iterExtendBytes(v2, rs.iterFrom({ v: _115 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); + rs.iterExtendBytes(v2, rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); } else if (_18 === 9) { const bag: Bag.Bag = { _0: at(0), _1: at(1) }; - const iter3: rt.Iter = Bag.intoIter$iter_IntoIterator(bag); + const iter3: rs.Iter = Bag.intoIter$iter_IntoIterator(bag); while (true) { - const _130: rt.u8 | rt.Done = iter3.next(); - if (_130 === rt.DONE) { + const _130: rs.u8 | rs.Done = iter3.next(); + if (_130 === rs.DONE) { break; } - rt.byteVecPush(out, _130); + rs.byteVecPush(out, _130); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterEnumerate(rt.iterMap(Bag.intoIter$iter_IntoIterator(bag), (n10: rt.u8): rt.u8 => { - return rt.u8Add(n10, 1); - })), (_210: [rt.usize, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterEnumerate(rs.iterMap(Bag.intoIter$iter_IntoIterator(bag), (n10: rs.u8): rs.u8 => { + return rs.u8Add(n10, 1); + })), (_210: [rs.usize, rs.u8]): rs.u8 => { return (_210[0] & 0xff) ^ _210[1]; }), "next"); } else if (_18 === 10) { - it = rt.iterPeekable(rt.iterMap(rt.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v)), (n9: rt.u8): rt.u8 => { - return rt.u8Mul(n9, 2); + it = rs.iterPeekable(rs.iterMap(rs.iterFrom({ v: ticks() }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), (n9: rs.u8): rs.u8 => { + return rs.u8Mul(n9, 2); })); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it.next())), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.peekablePeek(it)), undefined, true); - rt.drop(it); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it.next())), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.peekablePeek(it)), undefined, true); + rs.drop(it); const _155: Logged.Logged = logged(); const _157: Ticks.Ticks = ticks(); - const it2: rt.Iter = rt.iterSkip(rt.iterChain(rt.iterFrom(_155, Logged.next$iter_Iterator, rt.drop), rt.iterFrom({ v: _157 }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v))), 1); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(it2.next())), undefined, true); - const _165: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_165.value, 170); - rt.refMutRelease(_165); - rt.drop(it2); + const it2: rs.Iter = rs.iterSkip(rs.iterChain(rs.iterFrom(_155, Logged.next$iter_Iterator, rs.drop), rs.iterFrom({ v: _157 }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v))), 1); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(it2.next())), undefined, true); + const _165: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_165.value, 170); + rs.refMutRelease(_165); + rs.drop(it2); } else if (_18 === 11) { - const _169: rt.Iter = rt.iterRev(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); - for (const _172 of rt.iterToVec(rt.iterZip(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), _169), "next", 2).items) { - rt.byteVecPush(out, rt.u8Add(rt.u8Mul(_172[0], 16), _172[1])); + const _169: rs.Iter = rs.iterRev(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })); + for (const _172 of rs.iterToVec(rs.iterZip(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), _169), "next", 2).items) { + rs.byteVecPush(out, rs.u8Add(rs.u8Mul(_172[0], 16), _172[1])); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterMax(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.lt, true), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterMax(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.lt, true), 238)); const _188: Phase.Phase = Phase.of(at(1)); - rt.byteVecPush(out, rt.iterEq(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.iterFrom({ v: _188 }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rt.same, undefined, true, true) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterTake(rt.iterCycle(rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), { v: (it: rt.Place) => ({ v: it.v }) }), rt.u8Rem(at(1), 8) as rt.usize), "next"); + rs.byteVecPush(out, rs.iterEq(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.iterFrom({ v: _188 }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), rs.same, undefined, true, true) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterTake(rs.iterCycle(rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), { v: (it: rs.Place) => ({ v: it.v }) }), rs.u8Rem(at(1), 8) as rs.usize), "next"); } else { let p: Phase.Phase = phase; - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(rt.iterFrom(rt.place(() => p, (value) => p = value), Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); - rt.byteVecPush(out, rt.iterAny(rt.iterFrom(rt.place(() => p, (value2) => p = value2), Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n5: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(rs.place(() => p, (value) => p = value), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); + rs.byteVecPush(out, rs.iterAny(rs.iterFrom(rs.place(() => p, (value2) => p = value2), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n5: rs.u8): boolean => { return n5 === 1; }) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterTake(rt.iterMap(rt.iterFrom(rt.place(() => p, (value3) => p = value3), Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n6: rt.u8): rt.u8 => { - return rt.u8Add(n6, 16); + rs.iterExtendBytes(out, rs.iterTake(rs.iterMap(rs.iterFrom(rs.place(() => p, (value3) => p = value3), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), (n6: rs.u8): rs.u8 => { + return rs.u8Add(n6, 16); }), 1), "next"); - rt.byteVecPush(out, rt.iterFrom(rt.place(() => p, (value4) => p = value4), Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); - const _224: rt.u8 | rt.Done = Phase.next$iter_Iterator(rt.place(() => p, (value5) => p = value5)); - if (_224 !== rt.DONE) { - rt.byteVecPush(out, _224); + rs.byteVecPush(out, rs.iterFrom(rs.place(() => p, (value4) => p = value4), Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); + const _224: rs.u8 | rs.Done = Phase.next$iter_Iterator(rs.place(() => p, (value5) => p = value5)); + if (_224 !== rs.DONE) { + rs.byteVecPush(out, _224); } - const lent: rt.Place = rt.place(() => p, (value6) => p = value6); - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(rt.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); - rt.byteVecPush(out, rt.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); - rt.iterExtendBytes(out, rt.iterFrom({ v: p }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); + const lent: rs.Place = rs.place(() => p, (value6) => p = value6); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), 0)), undefined, true); + rs.byteVecPush(out, rs.iterFrom(lent, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }).sizeHint()[0] & 0xff); + rs.iterExtendBytes(out, rs.iterFrom({ v: p }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) }), "next"); let t: Ticks.Ticks = ticks(); - rt.iterExtendBytes(out, rt.iterOption(rt.iterFind(rt.iterFrom(rt.place(() => t, (value7) => t = value7), Ticks.next$iter_Iterator), (n7: rt.u8): boolean => { - return rt.u8Rem(n7, 2) === 0; + rs.iterExtendBytes(out, rs.iterOption(rs.iterFind(rs.iterFrom(rs.place(() => t, (value7) => t = value7), Ticks.next$iter_Iterator), (n7: rs.u8): boolean => { + return rs.u8Rem(n7, 2) === 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.iterPosition(rt.iterFrom(rt.place(() => t, (value8) => t = value8), Ticks.next$iter_Iterator), (n8: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.iterPosition(rs.iterFrom(rs.place(() => t, (value8) => t = value8), Ticks.next$iter_Iterator), (n8: rs.u8): boolean => { return n8 === 0; - }), (i2: rt.usize): rt.u8 => { + }), (i2: rs.usize): rs.u8 => { return i2 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterZip(rt.iterFrom(rt.place(() => t, (value9) => t = value9), Ticks.next$iter_Iterator), rt.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rt.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rt.Place) => Phase.count$iter_Iterator(it.v), back: (it: rt.Place) => rt.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), (_27: [rt.u8, rt.u8]): rt.u8 => { - return rt.u8Mul(_27[0], _27[1]); + rs.iterExtendBytes(out, rs.iterMap(rs.iterZip(rs.iterFrom(rs.place(() => t, (value9) => t = value9), Ticks.next$iter_Iterator), rs.iterFrom({ v: phase }, Phase.next$iter_Iterator, undefined, { hint: (it: rs.Place) => Phase.sizeHint$iter_Iterator(it.v), count: (it: rs.Place) => Phase.count$iter_Iterator(it.v), back: (it: rs.Place) => rs.iterFromOption(Phase.nextBack$iter_DoubleEndedIterator(it)) })), (_27: [rs.u8, rs.u8]): rs.u8 => { + return rs.u8Mul(_27[0], _27[1]); }), "next"); - rt.iterExtendBytes(out, rt.iterFrom({ v: t }, Ticks.next$iter_Iterator, (it: rt.Place) => drop$iters_Ticks(it.v)), "next"); + rs.iterExtendBytes(out, rs.iterFrom({ v: t }, Ticks.next$iter_Iterator, (it: rs.Place) => drop$iters_Ticks(it.v)), "next"); } } } - const _258: rt.RefCell = rt.refCellBorrow(log); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_258.value)); - rt.refRelease(_258); + const _258: rs.RefCell = rs.refCellBorrow(log); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_258.value)); + rs.refRelease(_258); } //# sourceMappingURL=iters.ts.map diff --git a/ts/fixtures/lang/iters/expected/lib.ts b/ts/fixtures/lang/iters/expected/lib.ts index 9b83c93db..5a582c245 100644 --- a/ts/fixtures/lang/iters/expected/lib.ts +++ b/ts/fixtures/lang/iters/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { adaptors, consumers, reducers, peekedOthers, skips, ranked, ranges, options, optionItems, own, values, returned, zips, zipsBack, rangeFroms, rangeMethods, compares, lent, byValue } from "./iters.ts"; import type * as Ticks from "./iters.Ticks.ts"; @@ -11,9 +11,9 @@ export function drop$iters_Ticks(_1: Ticks.Ticks): void { } export class of$u8 { - v: rt.u8; + v: rs.u8; - constructor(v: rt.u8) { + constructor(v: rs.u8) { this.v = v; } } @@ -22,26 +22,26 @@ export class of$u8 { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["iters::adaptors", adaptors as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::consumers", consumers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranges", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["iters::adaptors", adaptors as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::consumers", consumers as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::ranges", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { ranges(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::options", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::options", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { options(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::own", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::own", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { own(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::values", (_213: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::values", (_213: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { values(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::skips", skips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::ranked", ranked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::returned", (_214: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::skips", skips as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::ranked", ranked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::returned", (_214: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { returned(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::reducers", (_215: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::reducers", (_215: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { reducers(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::peeked_others", (_216: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::peeked_others", (_216: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { peekedOthers(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips", zips as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::range_methods", rangeMethods as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::compares", compares as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::option_items", (_217: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::zips", zips as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::zips_back", zipsBack as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::range_froms", rangeFroms as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::range_methods", rangeMethods as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::compares", compares as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::option_items", (_217: rs.u8, data8: rs.ByteSlice, out8: rs.ByteVec): undefined => { optionItems(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::lent", (_218: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::lent", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { lent(data9, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["iters::by_value", byValue as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/iters/src/iters.rs b/ts/fixtures/lang/iters/src/iters.rs index ced5fc0b9..78086f9e8 100644 --- a/ts/fixtures/lang/iters/src/iters.rs +++ b/ts/fixtures/lang/iters/src/iters.rs @@ -749,7 +749,7 @@ trait Badge {} impl Badge for u8 {} /// Loops over options, each item's own `Option` tested apart from the iterator's end, for -/// each way JS holds `None`: `undefined`, `rt.None` where `Some` can be `undefined`, and +/// each way JS holds `None`: `undefined`, `rs.None` where `Some` can be `undefined`, and /// nested. pub fn option_items(data: &[u8], out: &mut Vec) { let maybe = |b: &u8| if b % 3 == 0 { None } else { Some(*b) }; @@ -827,7 +827,7 @@ pub fn option_items(data: &[u8], out: &mut Vec) { while let Some(found) = first_present(&mut it) { out.push(found); } - // `scan` of items whose `None` is `rt.None`, each ending where its closure's `None` is. + // `scan` of items whose `None` is `rs.None`, each ending where its closure's `None` is. let mut sum = 0u8; let scanned: Vec> = data .iter() @@ -860,7 +860,7 @@ struct Weighed<'a> { impl Iterator for Weighed<'_> { type Item = u8; - // MIR switches on the return place itself, which holds `rt.DONE` for `None`. + // MIR switches on the return place itself, which holds `rs.DONE` for `None`. #[inline(never)] fn next(&mut self) -> Option { let item = self.inner.next().copied().filter(|b| b % 3 != 0); diff --git a/ts/fixtures/lang/joins/expected/core/option.ts b/ts/fixtures/lang/joins/expected/core/option.ts index 8cc14fcd3..e4c08a62d 100644 --- a/ts/fixtures/lang/joins/expected/core/option.ts +++ b/ts/fixtures/lang/joins/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/joins/expected/harness.ts b/ts/fixtures/lang/joins/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/joins/expected/harness.ts +++ b/ts/fixtures/lang/joins/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/joins/expected/joins.Logged.ts b/ts/fixtures/lang/joins/expected/joins.Logged.ts index 26c927ab6..3b3daf668 100644 --- a/ts/fixtures/lang/joins/expected/joins.Logged.ts +++ b/ts/fixtures/lang/joins/expected/joins.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops, and as it is cloned, the id with the high bit set: its clone's * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -22,16 +22,16 @@ export class Logged { } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=joins.Logged.ts.map diff --git a/ts/fixtures/lang/joins/expected/joins.Sentinel.ts b/ts/fixtures/lang/joins/expected/joins.Sentinel.ts index 3b6c85342..2d397f8b7 100644 --- a/ts/fixtures/lang/joins/expected/joins.Sentinel.ts +++ b/ts/fixtures/lang/joins/expected/joins.Sentinel.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Panics as it is cloned, which shows whether std clones one. */ export interface Sentinel { - _0: rt.u8; + _0: rs.u8; } export function clone$Clone(self: Sentinel): Sentinel { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - rt.panicFmt(["clone sentinel ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + rs.panicFmt(["clone sentinel ", args2[0]]); } //# sourceMappingURL=joins.Sentinel.ts.map diff --git a/ts/fixtures/lang/joins/expected/joins.ts b/ts/fixtures/lang/joins/expected/joins.ts index 3a738901d..beefe221c 100644 --- a/ts/fixtures/lang/joins/expected/joins.ts +++ b/ts/fixtures/lang/joins/expected/joins.ts @@ -1,41 +1,41 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$boxed_Box_slice_joins_Logged, drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged } from "./lib.ts"; -import { unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import { put, text } from "./harness.ts"; import * as Logged from "./joins.Logged.ts"; import * as Sentinel from "./joins.Sentinel.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } /** Puts `v`'s length, then its bytes. */ -export function bytes(v: rt.ByteVec, out: rt.ByteVec): void { - rt.byteVecPush(out, v.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); +export function bytes(v: rs.ByteVec, out: rs.ByteVec): void { + rs.byteVecPush(out, v.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); } /** Puts `v`'s length, then each `u16`'s bytes. */ -export function wides(v: rt.Vec, out: rt.ByteVec): void { - rt.byteVecPush(out, v.items.length & 0xff); +export function wides(v: rs.Vec, out: rs.ByteVec): void { + rs.byteVecPush(out, v.items.length & 0xff); for (const _9 of v.items) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_9).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_9).reverse()), undefined, true); } } /** Puts the ids of `v`, then drops it. */ -export function ids(v: rt.Vec, log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, v.items.length & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v.items), (l: Logged.Logged): rt.u8 => { +export function ids(v: rs.Vec, log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, v.items.length & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v.items), (l: Logged.Logged): rs.u8 => { return l.id; }), undefined, true); - rt.dropVec(v); + rs.dropVec(v); flush(log, out); } @@ -43,221 +43,221 @@ export function ids(v: rt.Vec, log: rt.RefCell, out: * `concat` and `join` of what `kind` picks, each over the parts of `data` between its * zeros, as many as `kind`'s high bits pick, none and empty ones included. */ -export function joins(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const all: rt.Vec = rt.iterToVec(rt.byteSliceSplit(data, (_2: rt.u8): boolean => { +export function joins(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const all: rs.Vec = rs.iterToVec(rs.byteSliceSplit(data, (_2: rs.u8): boolean => { return _2 === 0; }), "next", 8); - const parts: rt.ByteSlice[] = rt.sliceRange(all.items, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(all.items.length, 1))); - const sep: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 7); - const seps: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 3)); - const _26: rt.u8 = rt.u8Rem(kind, 7); + const parts: rs.ByteSlice[] = rs.sliceRange(all.items, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(all.items.length, 1))); + const sep: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 7); + const seps: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); + const _26: rs.u8 = rs.u8Rem(kind, 7); if (_26 === 0) { - bytes(rt.byteSlicesJoin(parts), out); - bytes(rt.byteSlicesJoin(parts, rt.byteSliceFrom(Uint8Array.of(sep))), out); - bytes(rt.byteSlicesJoin(parts, seps), out); - bytes(rt.byteSlicesJoin(parts, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)), out); - const owned: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p7: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(p7); + bytes(rs.byteSlicesJoin(parts), out); + bytes(rs.byteSlicesJoin(parts, rs.byteSliceFrom(Uint8Array.of(sep))), out); + bytes(rs.byteSlicesJoin(parts, seps), out); + bytes(rs.byteSlicesJoin(parts, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)), out); + const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p7: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(p7); }), undefined, 12, true); - bytes(rt.byteSlicesJoin(owned.items, undefined, rt.byteVecSlice), out); - bytes(rt.byteSlicesJoin(owned.items, rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteVecSlice), out); - bytes(rt.byteSlicesJoin(owned.items, seps, rt.byteVecSlice), out); - const boxed: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (_229: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(_229)); + bytes(rs.byteSlicesJoin(owned.items, undefined, rs.byteVecSlice), out); + bytes(rs.byteSlicesJoin(owned.items, rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteVecSlice), out); + bytes(rs.byteSlicesJoin(owned.items, seps, rs.byteVecSlice), out); + const boxed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (_229: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(_229)); }), undefined, 8, true); - bytes(rt.byteSlicesJoin(boxed.items), out); - bytes(rt.byteSlicesJoin(boxed.items, rt.byteSliceFrom(Uint8Array.of(sep))), out); - bytes(rt.byteSlicesJoin(boxed.items, seps), out); - const _74: rt.ByteSlice[] = []; - bytes(rt.byteSlicesJoin(_74), out); - const _78: rt.ByteSlice[] = []; - bytes(rt.byteSlicesJoin(_78, rt.byteSliceFrom(Uint8Array.of(sep))), out); - const _83: rt.ByteSlice[] = []; - bytes(rt.byteSlicesJoin(_83, seps), out); + bytes(rs.byteSlicesJoin(boxed.items), out); + bytes(rs.byteSlicesJoin(boxed.items, rs.byteSliceFrom(Uint8Array.of(sep))), out); + bytes(rs.byteSlicesJoin(boxed.items, seps), out); + const _74: rs.ByteSlice[] = []; + bytes(rs.byteSlicesJoin(_74), out); + const _78: rs.ByteSlice[] = []; + bytes(rs.byteSlicesJoin(_78, rs.byteSliceFrom(Uint8Array.of(sep))), out); + const _83: rs.ByteSlice[] = []; + bytes(rs.byteSlicesJoin(_83, seps), out); } else if (_26 === 1) { - const at: (a0: rt.usize) => rt.u8 = (i5: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i5), i5 & 0xff); + const at: (a0: rs.usize) => rs.u8 = (i5: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i5), i5 & 0xff); }; - const hashA: Uint8Array = rt.bytesFromFn(8, at); - const hashB: Uint8Array = rt.bytesFromFn(8, (i6: rt.usize): rt.u8 => { - return at(rt.usizeAdd(i6, 8)); + const hashA: Uint8Array = rs.bytesFromFn(8, at); + const hashB: Uint8Array = rs.bytesFromFn(8, (i6: rs.usize): rs.u8 => { + return at(rs.usizeAdd(i6, 8)); }); - bytes(rt.byteSlicesJoin([hashA, hashB], undefined, rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin([hashA, hashB], rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin([hashA, hashB], seps, rt.byteSliceFrom), out); - const quads: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p6: rt.ByteSlice): Uint8Array => { - const _423: rt.ByteSlice = p6; - return rt.bytesFromFn(4, (i7: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(_423, i7), 0); + bytes(rs.byteSlicesJoin([hashA, hashB], undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin([hashA, hashB], rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin([hashA, hashB], seps, rs.byteSliceFrom), out); + const quads: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p6: rs.ByteSlice): Uint8Array => { + const _423: rs.ByteSlice = p6; + return rs.bytesFromFn(4, (i7: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(_423, i7), 0); }); }), undefined, 4, true); - bytes(rt.byteSlicesJoin(quads.items, undefined, rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin(quads.items, rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin(quads.items, seps, rt.byteSliceFrom), out); - const zeros: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (_228: rt.ByteSlice): Uint8Array => { + bytes(rs.byteSlicesJoin(quads.items, undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(quads.items, rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(quads.items, seps, rs.byteSliceFrom), out); + const zeros: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (_228: rs.ByteSlice): Uint8Array => { return Uint8Array.of(); }), undefined, 0, true); - bytes(rt.byteSlicesJoin(zeros.items, undefined, rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin(zeros.items, rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteSliceFrom), out); - bytes(rt.byteSlicesJoin(zeros.items, seps, rt.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(zeros.items, undefined, rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(zeros.items, rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(zeros.items, seps, rs.byteSliceFrom), out); const _141: Uint8Array[] = []; - bytes(rt.byteSlicesJoin(_141, undefined, rt.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(_141, undefined, rs.byteSliceFrom), out); const _145: Uint8Array[] = []; - bytes(rt.byteSlicesJoin(_145, rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteSliceFrom), out); + bytes(rs.byteSlicesJoin(_145, rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteSliceFrom), out); } else if (_26 === 2) { - const sep2: rt.u16 = (((sep as rt.u16) << 8) & 0xffff) | 1; - const wide: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p5: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(p5)), (_223: rt.u8): rt.u16 => { - return rt.u16Mul(_223 as rt.u16, 257); + const sep2: rs.u16 = (((sep as rs.u16) << 8) & 0xffff) | 1; + const wide: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p5: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(p5)), (_223: rs.u8): rs.u16 => { + return rs.u16Mul(_223 as rs.u16, 257); }), undefined, 2, true); }), undefined, 12, true); - const wideSeps: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(seps)), (_224: rt.u8): rt.u16 => { - return (_224 as rt.u16) | 256; + const wideSeps: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(seps)), (_224: rs.u8): rs.u16 => { + return (_224 as rs.u16) | 256; }), undefined, 2, true); - wides(rt.slicesJoin(wide.items, 2, undefined, rt.asSlice), out); - wides(rt.slicesJoin(wide.items, 2, [sep2], rt.asSlice), out); - wides(rt.slicesJoin(wide.items, 2, rt.sliceRange(wideSeps.items, 0), rt.asSlice), out); - const slices: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(wide.items), (v2: rt.Vec): rt.u16[] => { - return rt.sliceRange(v2.items, 0); + wides(rs.slicesJoin(wide.items, 2, undefined, rs.asSlice), out); + wides(rs.slicesJoin(wide.items, 2, [sep2], rs.asSlice), out); + wides(rs.slicesJoin(wide.items, 2, rs.sliceRange(wideSeps.items, 0), rs.asSlice), out); + const slices: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(wide.items), (v2: rs.Vec): rs.u16[] => { + return rs.sliceRange(v2.items, 0); }), undefined, 8, true); - wides(rt.slicesJoin(slices.items, 2), out); - wides(rt.slicesJoin(slices.items, 2, [sep2]), out); - wides(rt.slicesJoin(slices.items, 2, rt.sliceRange(wideSeps.items, 0)), out); - const boxed2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(wide.items), (a02: rt.Vec): rt.Vec => { - return rt.vecFrom(a02.items.slice()); - }), (a03: rt.Vec): rt.u16[] => { + wides(rs.slicesJoin(slices.items, 2), out); + wides(rs.slicesJoin(slices.items, 2, [sep2]), out); + wides(rs.slicesJoin(slices.items, 2, rs.sliceRange(wideSeps.items, 0)), out); + const boxed2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(wide.items), (a02: rs.Vec): rs.Vec => { + return rs.vecFrom(a02.items.slice()); + }), (a03: rs.Vec): rs.u16[] => { return a03.items; }), undefined, 8, true); - wides(rt.slicesJoin(boxed2.items, 2), out); - wides(rt.slicesJoin(boxed2.items, 2, [sep2]), out); - wides(rt.slicesJoin(boxed2.items, 2, rt.sliceRange(wideSeps.items, 0)), out); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(slices.items), (s2: rt.u16[]): rt.u16[] => { - return [s2.length & 0xffff, option_unwrapOr$1j4op5y(rt.sliceFirst(s2), 0)]; + wides(rs.slicesJoin(boxed2.items, 2), out); + wides(rs.slicesJoin(boxed2.items, 2, [sep2]), out); + wides(rs.slicesJoin(boxed2.items, 2, rs.sliceRange(wideSeps.items, 0)), out); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(slices.items), (s2: rs.u16[]): rs.u16[] => { + return [s2.length & 0xffff, option_unwrapOr$1szdyfq(rs.sliceFirst(s2), 0)]; }), undefined, 4, true); - wides(rt.slicesJoin(pairs.items, 2), out); - wides(rt.slicesJoin(pairs.items, 2, [sep2]), out); - wides(rt.slicesJoin(pairs.items, 2, rt.sliceRange(wideSeps.items, 0)), out); - const zeros2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (_227: rt.ByteSlice): rt.u16[] => { + wides(rs.slicesJoin(pairs.items, 2), out); + wides(rs.slicesJoin(pairs.items, 2, [sep2]), out); + wides(rs.slicesJoin(pairs.items, 2, rs.sliceRange(wideSeps.items, 0)), out); + const zeros2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (_227: rs.ByteSlice): rs.u16[] => { return []; }), undefined, 0, true); - wides(rt.slicesJoin(zeros2.items, 2), out); - wides(rt.slicesJoin(zeros2.items, 2, [sep2]), out); - const none: rt.Vec> = new rt.Vec(); - wides(rt.slicesJoin(none.items, 2, undefined, rt.asSlice), out); - wides(rt.slicesJoin(none.items, 2, [sep2], rt.asSlice), out); - wides(rt.slicesJoin(none.items, 2, rt.sliceRange(wideSeps.items, 0), rt.asSlice), out); + wides(rs.slicesJoin(zeros2.items, 2), out); + wides(rs.slicesJoin(zeros2.items, 2, [sep2]), out); + const none: rs.Vec> = new rs.Vec(); + wides(rs.slicesJoin(none.items, 2, undefined, rs.asSlice), out); + wides(rs.slicesJoin(none.items, 2, [sep2], rs.asSlice), out); + wides(rs.slicesJoin(none.items, 2, rs.sliceRange(wideSeps.items, 0), rs.asSlice), out); } else if (_26 === 3) { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const vecs: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p4: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(p4)), (_215: rt.u8): Logged.Logged => { + const vecs: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p4: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(p4)), (_215: rs.u8): Logged.Logged => { return logged(_215 & 126); }), undefined, 8, true); }), undefined, 12, true); const sep3: Logged.Logged = logged(80); - const seps2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(seps)), (_219: rt.u8): Logged.Logged => { + const seps2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(seps)), (_219: rs.u8): Logged.Logged => { return logged(_219 & 62); }), undefined, 8, true); - ids(rt.slicesJoin(vecs.items, 8, undefined, rt.asSlice, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(vecs.items, 8, [sep3], rt.asSlice, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(vecs.items, 8, rt.sliceRange(seps2.items, 0), rt.asSlice, Logged.clone$Clone), log.value, out); - const slices2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(vecs.items), (v: rt.Vec): Logged.Logged[] => { - return rt.sliceRange(v.items, 0); + ids(rs.slicesJoin(vecs.items, 8, undefined, rs.asSlice, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(vecs.items, 8, [sep3], rs.asSlice, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(vecs.items, 8, rs.sliceRange(seps2.items, 0), rs.asSlice, Logged.clone$Clone), log.value, out); + const slices2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(vecs.items), (v: rs.Vec): Logged.Logged[] => { + return rs.sliceRange(v.items, 0); }), undefined, 8, true); - ids(rt.slicesJoin(slices2.items, 8, undefined, undefined, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(slices2.items, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(slices2.items, 8, rt.sliceRange(seps2.items, 0), undefined, Logged.clone$Clone), log.value, out); - const boxed3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(slices2.items), (_220: Logged.Logged[]): Logged.Logged[] => { + ids(rs.slicesJoin(slices2.items, 8, undefined, undefined, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(slices2.items, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(slices2.items, 8, rs.sliceRange(seps2.items, 0), undefined, Logged.clone$Clone), log.value, out); + const boxed3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(slices2.items), (_220: Logged.Logged[]): Logged.Logged[] => { return _220.map(Logged.clone$Clone); }), undefined, 8, true); flush(log.value, out); - ids(rt.slicesJoin(boxed3.items, 8, undefined, undefined, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(boxed3.items, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); - rt.dropVec(boxed3, drop$boxed_Box_slice_joins_Logged); + ids(rs.slicesJoin(boxed3.items, 8, undefined, undefined, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(boxed3.items, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); + rs.dropVec(boxed3, drop$boxed_Box_slice_joins_Logged); flush(log.value, out); const pairs2: Logged.Logged[][] = [[logged(2), logged(4)], [logged(6), logged(8)]]; - ids(rt.slicesJoin(pairs2, 8, undefined, undefined, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(pairs2, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); - ids(rt.slicesJoin(pairs2, 8, rt.sliceRange(seps2.items, 0), undefined, Logged.clone$Clone), log.value, out); - drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged([vecs, pairs2, sep3, seps2] as [rt.Vec>, Logged.Logged[][], Logged.Logged, rt.Vec]); + ids(rs.slicesJoin(pairs2, 8, undefined, undefined, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(pairs2, 8, [sep3], undefined, Logged.clone$Clone), log.value, out); + ids(rs.slicesJoin(pairs2, 8, rs.sliceRange(seps2.items, 0), undefined, Logged.clone$Clone), log.value, out); + drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged([vecs, pairs2, sep3, seps2] as [rs.Vec>, Logged.Logged[][], Logged.Logged, rs.Vec]); flush(log.value, out); log[Symbol.dispose](); } else if (_26 === 4) { - const owned2: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p3: rt.ByteSlice): string => { + const owned2: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p3: rs.ByteSlice): string => { return text(p3); }), undefined, 12, true); const sep4: string = text(seps); - put(out, rt.strsJoin(owned2.items, "")); - put(out, rt.strsJoin(owned2.items, sep4)); - const borrowed: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(owned2.items), (a0: string): string => { + put(out, rs.strsJoin(owned2.items, "")); + put(out, rs.strsJoin(owned2.items, sep4)); + const borrowed: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(owned2.items), (a0: string): string => { return a0; }), undefined, 8, true); - put(out, rt.strsJoin(borrowed.items, "")); - put(out, rt.strsJoin(borrowed.items, sep4)); + put(out, rs.strsJoin(borrowed.items, "")); + put(out, rs.strsJoin(borrowed.items, sep4)); const _437: string[] = []; - put(out, rt.strsJoin(_437, "")); + put(out, rs.strsJoin(_437, "")); const _443: string[] = []; - put(out, rt.strsJoin(_443, sep4)); + put(out, rs.strsJoin(_443, sep4)); } else if (_26 === 5) { - const cows: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(parts)), (_22: [rt.usize, rt.ByteSlice]): rt.ByteCow => { - const i2: rt.usize = _22[0]; - const p: rt.ByteSlice = _22[1]; - if (rt.usizeRem(i2, 2) === 0) { + const cows: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(parts)), (_22: [rs.usize, rs.ByteSlice]): rs.ByteCow => { + const i2: rs.usize = _22[0]; + const p: rs.ByteSlice = _22[1]; + if (rs.usizeRem(i2, 2) === 0) { return p; } - return rt.byteSliceToByteVec(p); + return rs.byteSliceToByteVec(p); }), undefined, 12, true); - bytes(rt.byteSlicesJoin(cows.items, undefined, rt.byteCowSlice), out); - bytes(rt.byteSlicesJoin(cows.items, rt.byteSliceFrom(Uint8Array.of(sep)), rt.byteCowSlice), out); - bytes(rt.byteSlicesJoin(cows.items, seps, rt.byteCowSlice), out); - const wide3: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(parts), (p2: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(p2)), (_28: rt.u8): rt.u16 => { - return _28 as rt.u16; + bytes(rs.byteSlicesJoin(cows.items, undefined, rs.byteCowSlice), out); + bytes(rs.byteSlicesJoin(cows.items, rs.byteSliceFrom(Uint8Array.of(sep)), rs.byteCowSlice), out); + bytes(rs.byteSlicesJoin(cows.items, seps, rs.byteCowSlice), out); + const wide3: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(parts), (p2: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(p2)), (_28: rs.u8): rs.u16 => { + return _28 as rs.u16; }), undefined, 2, true); - }), undefined, 12, true).items)), (_212: [rt.usize, rt.Vec]): rt.Cow => { - if (rt.usizeRem(_212[0], 2) === 0) { - return new rt.Borrowed(rt.sliceRange(_212[1].items, 0)); + }), undefined, 12, true).items)), (_212: [rs.usize, rs.Vec]): rs.Cow => { + if (rs.usizeRem(_212[0], 2) === 0) { + return new rs.Borrowed(rs.sliceRange(_212[1].items, 0)); } - return rt.vecFrom(_212[1].items.slice()); + return rs.vecFrom(_212[1].items.slice()); }), undefined, 12, true); - wides(rt.slicesJoin(wide3.items, 2, undefined, rt.cowSlice), out); - wides(rt.slicesJoin(wide3.items, 2, [65535], rt.cowSlice), out); - const texts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(parts)), (_214: [rt.usize, rt.ByteSlice]): rt.StrCow => { - if (rt.usizeRem(_214[0], 2) === 0) { - return new rt.Borrowed("ab"); + wides(rs.slicesJoin(wide3.items, 2, undefined, rs.cowSlice), out); + wides(rs.slicesJoin(wide3.items, 2, [65535], rs.cowSlice), out); + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(parts)), (_214: [rs.usize, rs.ByteSlice]): rs.StrCow => { + if (rs.usizeRem(_214[0], 2) === 0) { + return new rs.Borrowed("ab"); } return text(_214[1]); }), undefined, 12, true); - put(out, rt.strsJoin(texts.items.map(rt.strCowStr), "")); - put(out, rt.strsJoin(texts.items.map(rt.strCowStr), "--")); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "")); + put(out, rs.strsJoin(texts.items.map(rs.strCowStr), "--")); } else { - const big: rt.ByteVec = rt.byteVecOf(1, 1 << 16); - const wide4: rt.Vec = rt.vecFromElem(1, 1 << 16, undefined); - const text_: string = text(rt.byteVecSlice(big)); - const refs: (a0: rt.usize) => rt.Vec = (n: rt.usize): rt.Vec => { - return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0), n, undefined); + const big: rs.ByteVec = rs.byteVecOf(1, 1 << 16); + const wide4: rs.Vec = rs.vecFromElem(1, 1 << 16, undefined); + const text_: string = text(rs.byteVecSlice(big)); + const refs: (a0: rs.usize) => rs.Vec = (n: rs.usize): rs.Vec => { + return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0), n, undefined); }; - const _512: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 7); + const _512: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 7); if (_512 === 0) { - bytes(rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 15, 1)).items), out); + bytes(rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 15, 1)).items), out); } else if (_512 === 1) { - bytes(rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 16, 1)).items), out); + bytes(rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 16, 1)).items), out); } else if (_512 === 2) { - bytes(rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 14, 1)).items, rt.byteSliceRange(rt.byteVecSlice(big), 0)), out); + bytes(rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 14, 1)).items, rs.byteSliceRange(rs.byteVecSlice(big), 0)), out); } else if (_512 === 3) { - wides(rt.slicesJoin(rt.vecFromElem(rt.sliceRange(wide4.items, 0), rt.usizeAdd(1 << 14, 1), undefined).items, 2), out); + wides(rs.slicesJoin(rs.vecFromElem(rs.sliceRange(wide4.items, 0), rs.usizeAdd(1 << 14, 1), undefined).items, 2), out); } else if (_512 === 4) { - put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 15, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 15, 1), undefined).items, "")); } else if (_512 === 5) { - put(out, rt.strsJoin(rt.vecFromElem(text_, rt.usizeAdd(1 << 16, 1), undefined).items, "")); + put(out, rs.strsJoin(rs.vecFromElem(text_, rs.usizeAdd(1 << 16, 1), undefined).items, "")); } else { - const sep5: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, 1 << 16), (i: rt.i32): Sentinel.Sentinel => { + const sep5: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, 1 << 16), (i: rs.i32): Sentinel.Sentinel => { return { _0: (i & 0xff) ^ 90 }; }), undefined, 1, true); const _597: Sentinel.Sentinel[] = []; - rt.slicesJoin(rt.vecFromElem(_597, rt.usizeAdd(1 << 16, 1), undefined).items, 1, rt.sliceRange(sep5.items, 0), undefined, Sentinel.clone$Clone); + rs.slicesJoin(rs.vecFromElem(_597, rs.usizeAdd(1 << 16, 1), undefined).items, 1, rs.sliceRange(sep5.items, 0), undefined, Sentinel.clone$Clone); } } } diff --git a/ts/fixtures/lang/joins/expected/lib.ts b/ts/fixtures/lang/joins/expected/lib.ts index 319895f8e..0fd3fff64 100644 --- a/ts/fixtures/lang/joins/expected/lib.ts +++ b/ts/fixtures/lang/joins/expected/lib.ts @@ -1,34 +1,34 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { joins } from "./joins.ts"; import type * as Logged from "./joins.Logged.ts"; -export function drop$Vec_joins_Logged(value: rt.Vec): void { - rt.dropVec(value); +export function drop$Vec_joins_Logged(value: rs.Vec): void { + rs.dropVec(value); } export function drop$array2_joins_Logged(value: Logged.Logged[]): void { - rt.dropAll(value); + rs.dropAll(value); } export function drop$boxed_Box_slice_joins_Logged(value: Logged.Logged[]): void { - rt.dropAll(value); + rs.dropAll(value); } -export function drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged(_1: [rt.Vec>, Logged.Logged[][], Logged.Logged, rt.Vec]): void { - rt.dropVec(_1[0], drop$Vec_joins_Logged); - rt.dropAll(_1[1], drop$array2_joins_Logged); +export function drop$tuple4_Vec_Vec_joins_Logged_array2_array2_joins_Logged_joins_Logged_Vec_joins_Logged(_1: [rs.Vec>, Logged.Logged[][], Logged.Logged, rs.Vec]): void { + rs.dropVec(_1[0], drop$Vec_joins_Logged); + rs.dropAll(_1[1], drop$array2_joins_Logged); _1[2][Symbol.dispose](); - rt.dropVec(_1[3]); + rs.dropVec(_1[3]); } /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["joins::joins", joins as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["joins::joins", joins as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/keys/expected/core/bool.ts b/ts/fixtures/lang/keys/expected/core/bool.ts index dabe97c80..e64853f48 100644 --- a/ts/fixtures/lang/keys/expected/core/bool.ts +++ b/ts/fixtures/lang/keys/expected/core/bool.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Hop from "../keys.Hop.ts"; import type * as Way from "../keys.Way.ts"; @@ -11,14 +11,14 @@ export function thenSome$0rsp0eu(self: boolean, t: Uint8Array): Uint8Array | und return t; } -export function then$0l8o6jo(self: boolean, f: () => rt.u32[]): rt.u32[] | undefined { +export function then$1hbi99k(self: boolean, f: () => rs.u32[]): rs.u32[] | undefined { if (!self) { return undefined; } return f(); } -export function then$0b2eeh4(self: boolean, f: () => Array): Array | undefined { +export function then$0t1jhx5(self: boolean, f: () => Array): Array | undefined { if (!self) { return undefined; } @@ -32,14 +32,14 @@ export function then$1ghn4qd(self: boolean, f: () => boolean[]): boolean[] | und return f(); } -export function then$1dhbcvy(self: boolean, f: () => rt.char[]): rt.char[] | undefined { +export function then$0wesa0o(self: boolean, f: () => rs.char[]): rs.char[] | undefined { if (!self) { return undefined; } return f(); } -export function then$1nf265w(self: boolean, f: () => rt.i32[]): rt.i32[] | undefined { +export function then$05rk6io(self: boolean, f: () => rs.i32[]): rs.i32[] | undefined { if (!self) { return undefined; } @@ -53,23 +53,23 @@ export function then$1c9ust9(self: boolean, f: () => Hop.Hop[]): Hop.Hop[] | und return f(); } -export function then$0l07w38(self: boolean, f: () => rt.u16[]): rt.u16[] | undefined { +export function then$1ko5lpm(self: boolean, f: () => rs.u16[]): rs.u16[] | undefined { if (!self) { return undefined; } return f(); } -export function then$0uovwq9(self: boolean, f: () => rt.u64[]): rt.u64[] | undefined { +export function then$0zrkb72(self: boolean, f: () => rs.u64[]): rs.u64[] | undefined { if (!self) { return undefined; } return f(); } -export function then$18np55d(self: boolean, f: () => Way.Way | undefined): Way.Way | undefined | rt.None { +export function then$05y10ww(self: boolean, f: () => Way.Way | undefined): Way.Way | undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return f(); } diff --git a/ts/fixtures/lang/keys/expected/core/option.ts b/ts/fixtures/lang/keys/expected/core/option.ts index 9bcf59ca2..b28c301ee 100644 --- a/ts/fixtures/lang/keys/expected/core/option.ts +++ b/ts/fixtures/lang/keys/expected/core/option.ts @@ -1,40 +1,40 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { side, order } from "../keys.ts"; import type * as Hop from "../keys.Hop.ts"; import type * as Side from "../keys.Side.ts"; import type * as Way from "../keys.Way.ts"; -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$1tvry1i(self: rt.u64 | undefined, default_: rt.u64): rt.u64 { +export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs.u64 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$146awhd(self: Hop.Hop | undefined, f: (a0: Hop.Hop) => [rt.u64, rt.u64]): [rt.u64, rt.u64] | undefined { +export function map$1n6u2ar(self: Hop.Hop | undefined, f: (a0: Hop.Hop) => [rs.u64, rs.u64]): [rs.u64, rs.u64] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$120lney(self: Hop.Hop | undefined, f: (a0: Hop.Hop) => rt.u64): rt.u64 | undefined { +export function map$174onvc(self: Hop.Hop | undefined, f: (a0: Hop.Hop) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } @@ -48,175 +48,175 @@ export function map$0lcwx9x(self: Way.Way | undefined, f: (a0: Way.Way) => boole return f(self); } -export function map$0gn4nwv(self: rt.u8 | undefined, _: (a0: rt.u8) => Side.Side): Side.Side | undefined { +export function map$0bzc4vz(self: rs.u8 | undefined, _: (a0: rs.u8) => Side.Side): Side.Side | undefined { if (self === undefined) { return undefined; } return side(self); } -export function mapOr$1h1mlmc(self: rt.u32[] | undefined, default_: rt.u8, f: (a0: rt.u32[]) => rt.u8): rt.u8 { +export function mapOr$18799n0(self: rs.u32[] | undefined, default_: rs.u8, f: (a0: rs.u32[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1bumeih(self: Array | undefined, default_: rt.u8, f: (a0: Array) => rt.u8): rt.u8 { +export function mapOr$182mz1d(self: Array | undefined, default_: rs.u8, f: (a0: Array) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0qqhf4e(self: boolean[] | undefined, default_: rt.u8, f: (a0: boolean[]) => rt.u8): rt.u8 { +export function mapOr$0ucpmcy(self: boolean[] | undefined, default_: rs.u8, f: (a0: boolean[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$141aobk(self: rt.char[] | undefined, default_: rt.u8, f: (a0: rt.char[]) => rt.u8): rt.u8 { +export function mapOr$0187me0(self: rs.char[] | undefined, default_: rs.u8, f: (a0: rs.char[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$17y4wkx(self: rt.i32[] | undefined, default_: rt.u8, f: (a0: rt.i32[]) => rt.u8): rt.u8 { +export function mapOr$19cu5pi(self: rs.i32[] | undefined, default_: rs.u8, f: (a0: rs.i32[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0rtxftk(self: Hop.Hop[] | undefined, default_: rt.u8, f: (a0: Hop.Hop[]) => rt.u8): rt.u8 { +export function mapOr$0kbx53k(self: Hop.Hop[] | undefined, default_: rs.u8, f: (a0: Hop.Hop[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1kiffmd(self: rt.u16[] | undefined, default_: rt.u8, f: (a0: rt.u16[]) => rt.u8): rt.u8 { +export function mapOr$13ci3um(self: rs.u16[] | undefined, default_: rs.u8, f: (a0: rs.u16[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0nlcxqx(self: rt.u64[] | undefined, default_: rt.u8, f: (a0: rt.u64[]) => rt.u8): rt.u8 { +export function mapOr$07qfnm1(self: rs.u64[] | undefined, default_: rs.u8, f: (a0: rs.u64[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1dgdmlk(self: rt.Ordering | undefined, default_: rt.u8, _: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$0iqhkrm(self: rs.Ordering | undefined, default_: rs.u8, _: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return order(self); } -export function mapOr$04khdaj(self: Hop.Hop | undefined, default_: rt.u64, f: (a0: Hop.Hop) => rt.u64): rt.u64 { +export function mapOr$1afu7tt(self: Hop.Hop | undefined, default_: rs.u64, f: (a0: Hop.Hop) => rs.u64): rs.u64 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1a3irjf(self: rt.ByteVec | undefined, default_: rt.u8, f: (a0: rt.ByteVec) => rt.u8): rt.u8 { +export function mapOr$0g5x999(self: rs.ByteVec | undefined, default_: rs.u8, f: (a0: rs.ByteVec) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0z7fb2w(self: rt.ByteSlice | undefined, default_: Uint8Array, f: (a0: rt.ByteSlice) => Uint8Array): Uint8Array { +export function mapOr$172961h(self: rs.ByteSlice | undefined, default_: Uint8Array, f: (a0: rs.ByteSlice) => Uint8Array): Uint8Array { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1w1gbwl(self: rt.ByteSlice | undefined, default_: rt.u8, f: (a0: rt.ByteSlice) => rt.u8): rt.u8 { +export function mapOr$1lwzqm5(self: rs.ByteSlice | undefined, default_: rs.u8, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1xwgm12(self: [rt.u32[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u32[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$0ohpdps(self: [rs.u32[], rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u32[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$187k0x1(self: [Array, rt.u8] | undefined, default_: rt.u8, f: (a0: [Array, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1rph82m(self: [Array, rs.u8] | undefined, default_: rs.u8, f: (a0: [Array, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$13q9j26(self: [boolean[], rt.u8] | undefined, default_: rt.u8, f: (a0: [boolean[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1ruj5y1(self: [boolean[], rs.u8] | undefined, default_: rs.u8, f: (a0: [boolean[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1afbbm4(self: [rt.char[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.char[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$03xawqj(self: [rs.char[], rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.char[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$03mkmku(self: [rt.i32[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.i32[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1r07wd5(self: [rs.i32[], rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.i32[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0spovx0(self: [Hop.Hop[], rt.u8] | undefined, default_: rt.u8, f: (a0: [Hop.Hop[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$03hkgbr(self: [Hop.Hop[], rs.u8] | undefined, default_: rs.u8, f: (a0: [Hop.Hop[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0iyypgq(self: [rt.u16[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u16[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$0uf63ye(self: [rs.u16[], rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u16[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0vfd25u(self: [rt.u64[], rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u64[], rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1p2t4pe(self: [rs.u64[], rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u64[], rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1be3nsj(self: [rt.ByteSlice, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.ByteSlice, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$09t7mex(self: [rs.ByteSlice, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.ByteSlice, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/keys/expected/harness.ts b/ts/fixtures/lang/keys/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/keys/expected/harness.ts +++ b/ts/fixtures/lang/keys/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/keys/expected/keys.Dropped.ts b/ts/fixtures/lang/keys/expected/keys.Dropped.ts index 7982a432a..01dd88a37 100644 --- a/ts/fixtures/lang/keys/expected/keys.Dropped.ts +++ b/ts/fixtures/lang/keys/expected/keys.Dropped.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Pushes its byte to the log it shares as it drops, and its clone another. */ export class Dropped { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -23,13 +23,13 @@ export function live(self: Dropped): boolean { } export function clone$Clone(self: Dropped): Dropped { - return new Dropped(rt.u8WrappingAdd(self._0, 16), self._1); + return new Dropped(rs.u8WrappingAdd(self._0, 16), self._1); } export function drop$ops_Drop(self: Dropped): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=keys.Dropped.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.Hop.ts b/ts/fixtures/lang/keys/expected/keys.Hop.ts index 388f52b88..8b2b69bb2 100644 --- a/ts/fixtures/lang/keys/expected/keys.Hop.ts +++ b/ts/fixtures/lang/keys/expected/keys.Hop.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Hop, other: Hop): boolean { - return rt.u64Eq(self._0, other._0); + return rs.u64Eq(self._0, other._0); } -export function hash$Hash_hash_DefaultHasher(self: Hop, state: rt.Hasher): void { - rt.hash64(self._0, state); +export function hash$Hash_hash_DefaultHasher(self: Hop, state: rs.Hasher): void { + rs.hash64(self._0, state); } -export function partialCmp$cmp_PartialOrd(self: Hop, other: Hop): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Hop, other: Hop): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Hop, other: Hop): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Hop, other: Hop): rs.Ordering { + return rs.cmp(self._0, other._0); } /** A 64-bit hop, past 2^53 for some, where it is no longer a JS number. */ export interface Hop { - _0: rt.u64; + _0: rs.u64; } //# sourceMappingURL=keys.Hop.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.Horizon.ts b/ts/fixtures/lang/keys/expected/keys.Horizon.ts index 39da9258c..ed7574db6 100644 --- a/ts/fixtures/lang/keys/expected/keys.Horizon.ts +++ b/ts/fixtures/lang/keys/expected/keys.Horizon.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Hop from "./keys.Hop.ts"; export function eq$cmp_PartialEq(self: Horizon, other: Horizon): boolean { if (!(self.local === other.local)) { return false; } - return rt.eqOption(Hop.eq$cmp_PartialEq)(self.exclude, other.exclude); + return rs.eqOption(Hop.eq$cmp_PartialEq)(self.exclude, other.exclude); } -export function hash$Hash_hash_DefaultHasher(self: Horizon, state: rt.Hasher): void { - rt.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined)(self.exclude, state); - rt.hash8(self.local, state); +export function hash$Hash_hash_DefaultHasher(self: Horizon, state: rs.Hasher): void { + rs.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined)(self.exclude, state); + rs.hash8(self.local, state); } -export function partialCmp$cmp_PartialOrd(self: Horizon, other: Horizon): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Horizon, other: Horizon): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Horizon, other: Horizon): rt.Ordering { - const cmp: rt.Ordering = rt.cmpOption(Hop.cmp$cmp_Ord)(self.exclude, other.exclude); +export function cmp$cmp_Ord(self: Horizon, other: Horizon): rs.Ordering { + const cmp: rs.Ordering = rs.cmpOption(Hop.cmp$cmp_Ord)(self.exclude, other.exclude); if (cmp === 0) { - return rt.cmp(self.local, other.local); + return rs.cmp(self.local, other.local); } return cmp; } diff --git a/ts/fixtures/lang/keys/expected/keys.Lopsided.ts b/ts/fixtures/lang/keys/expected/keys.Lopsided.ts index 7ad5f8074..03cfecc86 100644 --- a/ts/fixtures/lang/keys/expected/keys.Lopsided.ts +++ b/ts/fixtures/lang/keys/expected/keys.Lopsided.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Lopsided, other: Lopsided): boolean { return self._0 === other._0; } -export function cmp$cmp_Ord(self: Lopsided, other: Lopsided): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Lopsided, other: Lopsided): rs.Ordering { + return rs.cmp(self._0, other._0); } /** @@ -17,10 +17,10 @@ export function cmp$cmp_Ord(self: Lopsided, other: Lopsided): rt.Ordering { * order, which sorts need. */ export interface Lopsided { - _0: rt.u8; + _0: rs.u8; } -export function partialCmp$cmp_PartialOrd(self: Lopsided, other: Lopsided): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Lopsided, other: Lopsided): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } @@ -29,7 +29,7 @@ export function lt$cmp_PartialOrd(self: Lopsided, other: Lopsided): boolean { } export function le$cmp_PartialOrd(self: Lopsided, other: Lopsided): boolean { - return rt.u8Div(self._0, 4) >= rt.u8Div(other._0, 4); + return rs.u8Div(self._0, 4) >= rs.u8Div(other._0, 4); } export function gt$cmp_PartialOrd(self: Lopsided, other: Lopsided): boolean { @@ -37,7 +37,7 @@ export function gt$cmp_PartialOrd(self: Lopsided, other: Lopsided): boolean { } export function ge$cmp_PartialOrd(self: Lopsided, other: Lopsided): boolean { - return rt.u8Rem(self._0, 4) >= rt.u8Rem(other._0, 4); + return rs.u8Rem(self._0, 4) >= rs.u8Rem(other._0, 4); } //# sourceMappingURL=keys.Lopsided.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.Name.ts b/ts/fixtures/lang/keys/expected/keys.Name.ts index 8fe83edfb..2bc6d4b82 100644 --- a/ts/fixtures/lang/keys/expected/keys.Name.ts +++ b/ts/fixtures/lang/keys/expected/keys.Name.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Name, other: Name): boolean { - if (!rt.eqArc(rt.same, true)(self.text, other.text)) { + if (!rs.eqArc(rs.same, true)(self.text, other.text)) { return false; } return self.rank === other.rank; } -export function hash$Hash_hash_DefaultHasher(self: Name, state: rt.Hasher): void { - rt.hashArc(rt.hashStr)(self.text, state); - rt.hashOption(rt.hash8)(self.rank, state); +export function hash$Hash_hash_DefaultHasher(self: Name, state: rs.Hasher): void { + rs.hashArc(rs.hashStr)(self.text, state); + rs.hashOption(rs.hash8)(self.rank, state); } -export function partialCmp$cmp_PartialOrd(self: Name, other: Name): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Name, other: Name): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Name, other: Name): rt.Ordering { - const cmp: rt.Ordering = rt.cmpArc(rt.cmpStr)(self.text, other.text); +export function cmp$cmp_Ord(self: Name, other: Name): rs.Ordering { + const cmp: rs.Ordering = rs.cmpArc(rs.cmpStr)(self.text, other.text); if (cmp === 0) { - return rt.cmpOption(rt.cmp)(self.rank, other.rank); + return rs.cmpOption(rs.cmp)(self.rank, other.rank); } return cmp; } /** Text in an `Arc`, whose derived impls compare and hash it as the text. */ export class Name { - text: rt.Arc; - rank: rt.u8 | undefined; + text: rs.Arc; + rank: rs.u8 | undefined; - constructor(text: rt.Arc, rank: rt.u8 | undefined) { + constructor(text: rs.Arc, rank: rs.u8 | undefined) { this.text = text; this.rank = rank; } diff --git a/ts/fixtures/lang/keys/expected/keys.Picky.ts b/ts/fixtures/lang/keys/expected/keys.Picky.ts index 4fb43dcc6..4dfe8afc1 100644 --- a/ts/fixtures/lang/keys/expected/keys.Picky.ts +++ b/ts/fixtures/lang/keys/expected/keys.Picky.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `ne` of its own that disagrees with `eq`, which an `Option`'s `!=` never calls. */ export interface Picky { - _0: rt.u8; + _0: rs.u8; } export function eq$cmp_PartialEq(self: Picky, other: Picky): boolean { diff --git a/ts/fixtures/lang/keys/expected/keys.Rough.ts b/ts/fixtures/lang/keys/expected/keys.Rough.ts index 79c926bec..f8db5a212 100644 --- a/ts/fixtures/lang/keys/expected/keys.Rough.ts +++ b/ts/fixtures/lang/keys/expected/keys.Rough.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * An `eq` by value and a `partial_cmp` by quarter, unordered past 200: `!=` and `<=` * and `>=` all hold between some, and none of `<`, `<=`, `>`, and `>=` past 200. */ export interface Rough { - _0: rt.u8; + _0: rs.u8; } export function eq$cmp_PartialEq(self: Rough, other: Rough): boolean { return self._0 === other._0; } -export function partialCmp$cmp_PartialOrd(self: Rough, other: Rough): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Rough, other: Rough): rs.Ordering | undefined { let _3!: boolean; if (!(self._0 > 200)) { _3 = other._0 > 200; @@ -22,7 +22,7 @@ export function partialCmp$cmp_PartialOrd(self: Rough, other: Rough): rt.Orderin _3 = true; } if (!_3) { - return rt.cmp(rt.u8Div(self._0, 4), rt.u8Div(other._0, 4)); + return rs.cmp(rs.u8Div(self._0, 4), rs.u8Div(other._0, 4)); } return undefined; } diff --git a/ts/fixtures/lang/keys/expected/keys.Seen.ts b/ts/fixtures/lang/keys/expected/keys.Seen.ts index 52eb0bc65..060614091 100644 --- a/ts/fixtures/lang/keys/expected/keys.Seen.ts +++ b/ts/fixtures/lang/keys/expected/keys.Seen.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Hop from "./keys.Hop.ts"; import * as Horizon from "./keys.Horizon.ts"; import * as Name from "./keys.Name.ts"; @@ -10,7 +10,7 @@ export function eq$cmp_PartialEq(self: Seen, other: Seen): boolean { return false; } if (self.tag === "Hop") { - return rt.eqOption(Hop.eq$cmp_PartialEq)(self._0, (other as { tag: "Hop"; _0: Hop.Hop | undefined })._0); + return rs.eqOption(Hop.eq$cmp_PartialEq)(self._0, (other as { tag: "Hop"; _0: Hop.Hop | undefined })._0); } if (self.tag === "Twice") { return Horizon.eq$cmp_PartialEq(self._0, (other as { tag: "Twice"; _0: Horizon.Horizon })._0); @@ -24,14 +24,14 @@ export function eq$cmp_PartialEq(self: Seen, other: Seen): boolean { return Hop.eq$cmp_PartialEq(self._0, (other as { tag: "Mut"; _0: Hop.Hop })._0); } -export function partialCmp$cmp_PartialOrd(self: Seen, other: Seen): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Seen, other: Seen): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Seen, other: Seen): rt.Ordering { +export function cmp$cmp_Ord(self: Seen, other: Seen): rs.Ordering { if (self.tag === "Hop") { if (other.tag === "Hop") { - return rt.cmpOption(Hop.cmp$cmp_Ord)(self._0, other._0); + return rs.cmpOption(Hop.cmp$cmp_Ord)(self._0, other._0); } } else if (self.tag === "Twice") { if (other.tag === "Twice") { @@ -39,7 +39,7 @@ export function cmp$cmp_Ord(self: Seen, other: Seen): rt.Ordering { } } else if (self.tag === "Text") { if (other.tag === "Text") { - return rt.cmpStr(self._0, other._0); + return rs.cmpStr(self._0, other._0); } } else if (self.tag === "Name") { if (other.tag === "Name") { @@ -48,17 +48,17 @@ export function cmp$cmp_Ord(self: Seen, other: Seen): rt.Ordering { } else if (other.tag === "Mut") { return Hop.cmp$cmp_Ord(self._0, other._0); } - return rt.cmp({ Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[self.tag], { Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[other.tag]); + return rs.cmp({ Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[self.tag], { Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[other.tag]); } -export function hash$Hash_hash_DefaultHasher(self: Seen, state: rt.Hasher): void { - rt.hashIsize({ Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[self.tag], state); +export function hash$Hash_hash_DefaultHasher(self: Seen, state: rs.Hasher): void { + rs.hashIsize({ Hop: 0, Twice: 1, Text: 2, Name: 3, Mut: 4 }[self.tag], state); if (self.tag === "Hop") { - rt.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined)(self._0, state); + rs.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined)(self._0, state); } else if (self.tag === "Twice") { Horizon.hash$Hash_hash_DefaultHasher(self._0, state); } else if (self.tag === "Text") { - rt.hashStr(self._0, state); + rs.hashStr(self._0, state); } else if (self.tag === "Name") { Name.hash$Hash_hash_DefaultHasher(self._0, state); } else { diff --git a/ts/fixtures/lang/keys/expected/keys.Skew.ts b/ts/fixtures/lang/keys/expected/keys.Skew.ts index 04cd510ba..933f04823 100644 --- a/ts/fixtures/lang/keys/expected/keys.Skew.ts +++ b/ts/fixtures/lang/keys/expected/keys.Skew.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Skew, other: Skew): boolean { return self._0 === other._0; @@ -11,22 +11,22 @@ export function eq$cmp_PartialEq(self: Skew, other: Skew): boolean { * values, so a `partial_cmp` that calls `cmp` shows. */ export interface Skew { - _0: rt.u8; + _0: rs.u8; } -export function cmp$cmp_Ord(self: Skew, other: Skew): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Skew, other: Skew): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function partialCmp$cmp_PartialOrd(self: Skew, other: Skew): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Skew, other: Skew): rs.Ordering | undefined { let _3!: boolean; - if (!(rt.u8Rem(self._0, 2) === 1)) { + if (!(rs.u8Rem(self._0, 2) === 1)) { _3 = false; } else { - _3 = rt.u8Rem(other._0, 2) === 1; + _3 = rs.u8Rem(other._0, 2) === 1; } if (!_3) { - return rt.cmp(other._0, self._0); + return rs.cmp(other._0, self._0); } return undefined; } diff --git a/ts/fixtures/lang/keys/expected/keys.Skewed.ts b/ts/fixtures/lang/keys/expected/keys.Skewed.ts index bb9b2f691..d895eb4ff 100644 --- a/ts/fixtures/lang/keys/expected/keys.Skewed.ts +++ b/ts/fixtures/lang/keys/expected/keys.Skewed.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Skew from "./keys.Skew.ts"; export function eq$cmp_PartialEq(self: Skewed, other: Skewed): boolean { return Skew.eq$cmp_PartialEq(self._0, other._0); } -export function partialCmp$cmp_PartialOrd(self: Skewed, other: Skewed): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Skewed, other: Skewed): rs.Ordering | undefined { return Skew.partialCmp$cmp_PartialOrd(self._0, other._0); } diff --git a/ts/fixtures/lang/keys/expected/keys.Touchy.ts b/ts/fixtures/lang/keys/expected/keys.Touchy.ts index 08e24fba7..2ac8359d7 100644 --- a/ts/fixtures/lang/keys/expected/keys.Touchy.ts +++ b/ts/fixtures/lang/keys/expected/keys.Touchy.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A key whose `Eq` and `Ord` panic, which a lookup that compares nothing never calls. */ export interface Touchy { - _0: rt.u8; + _0: rs.u8; } -export function hash$Hash_hash_DefaultHasher(self: Touchy, state: rt.Hasher): void { - rt.hash8(self._0, state); +export function hash$Hash_hash_DefaultHasher(self: Touchy, state: rs.Hasher): void { + rs.hash8(self._0, state); } export function eq$cmp_PartialEq(self: Touchy, _2: Touchy): boolean { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - rt.panicFmt(["compared ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + rs.panicFmt(["compared ", args2[0]]); } -export function cmp$cmp_Ord(self: Touchy, _2: Touchy): rt.Ordering { +export function cmp$cmp_Ord(self: Touchy, _2: Touchy): rs.Ordering { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - rt.panicFmt(["ordered ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + rs.panicFmt(["ordered ", args2[0]]); } //# sourceMappingURL=keys.Touchy.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.Way.ts b/ts/fixtures/lang/keys/expected/keys.Way.ts index 76ee3fcab..2de5f3a82 100644 --- a/ts/fixtures/lang/keys/expected/keys.Way.ts +++ b/ts/fixtures/lang/keys/expected/keys.Way.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A fieldless enum whose own `Eq` and `Hash` find `Up` and `Top` equal, which their JS @@ -24,14 +24,14 @@ export function eq$cmp_PartialEq(self: Way, other: Way): boolean { return _3 === _5; } -export function hash$Hash_hash_DefaultHasher(self: Way, state: rt.Hasher): void { +export function hash$Hash_hash_DefaultHasher(self: Way, state: rs.Hasher): void { let _5!: boolean; if (self === "Down") { _5 = true; } else { _5 = false; } - rt.hash8(_5, state); + rs.hash8(_5, state); } //# sourceMappingURL=keys.Way.ts.map diff --git a/ts/fixtures/lang/keys/expected/keys.ts b/ts/fixtures/lang/keys/expected/keys.ts index 7a1105b18..9ada509e5 100644 --- a/ts/fixtures/lang/keys/expected/keys.ts +++ b/ts/fixtures/lang/keys/expected/keys.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_array2_keys_Hop, copy$Option_array2_u8, copy$Option_keys_Hop, copy$array_keys_Hop, copy$array_u8, copy$keys_Hop, copy$keys_Horizon, copy$tuple2_u8_keys_Horizon, drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided } from "./lib.ts"; -import { thenSome$0rsp0eu, then$0l8o6jo, then$0b2eeh4, then$1ghn4qd, then$1dhbcvy, then$1nf265w, then$1c9ust9, then$0l07w38, then$0uovwq9, then$18np55d } from "./core/bool.ts"; -import { unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$146awhd as option_map$146awhd, map$120lney as option_map$120lney, map$0lcwx9x as option_map$0lcwx9x, map$0gn4nwv as option_map$0gn4nwv, mapOr$1h1mlmc as option_mapOr$1h1mlmc, mapOr$1bumeih as option_mapOr$1bumeih, mapOr$0qqhf4e as option_mapOr$0qqhf4e, mapOr$141aobk as option_mapOr$141aobk, mapOr$17y4wkx as option_mapOr$17y4wkx, mapOr$0rtxftk as option_mapOr$0rtxftk, mapOr$1kiffmd as option_mapOr$1kiffmd, mapOr$0nlcxqx as option_mapOr$0nlcxqx, mapOr$1dgdmlk as option_mapOr$1dgdmlk, mapOr$04khdaj as option_mapOr$04khdaj, mapOr$1a3irjf as option_mapOr$1a3irjf, mapOr$0z7fb2w as option_mapOr$0z7fb2w, mapOr$1w1gbwl as option_mapOr$1w1gbwl, mapOr$1surhce as option_mapOr$1surhce, mapOr$02k4ito as option_mapOr$02k4ito, mapOr$1xwgm12 as option_mapOr$1xwgm12, mapOr$187k0x1 as option_mapOr$187k0x1, mapOr$13q9j26 as option_mapOr$13q9j26, mapOr$1afbbm4 as option_mapOr$1afbbm4, mapOr$03mkmku as option_mapOr$03mkmku, mapOr$0spovx0 as option_mapOr$0spovx0, mapOr$0iyypgq as option_mapOr$0iyypgq, mapOr$0vfd25u as option_mapOr$0vfd25u, mapOr$1be3nsj as option_mapOr$1be3nsj } from "./core/option.ts"; +import { thenSome$0rsp0eu, then$1hbi99k, then$0t1jhx5, then$1ghn4qd, then$0wesa0o, then$05rk6io, then$1c9ust9, then$1ko5lpm, then$0zrkb72, then$05y10ww } from "./core/bool.ts"; +import { unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1n6u2ar as option_map$1n6u2ar, map$174onvc as option_map$174onvc, map$0lcwx9x as option_map$0lcwx9x, map$0bzc4vz as option_map$0bzc4vz, mapOr$18799n0 as option_mapOr$18799n0, mapOr$182mz1d as option_mapOr$182mz1d, mapOr$0ucpmcy as option_mapOr$0ucpmcy, mapOr$0187me0 as option_mapOr$0187me0, mapOr$19cu5pi as option_mapOr$19cu5pi, mapOr$0kbx53k as option_mapOr$0kbx53k, mapOr$13ci3um as option_mapOr$13ci3um, mapOr$07qfnm1 as option_mapOr$07qfnm1, mapOr$0iqhkrm as option_mapOr$0iqhkrm, mapOr$1afu7tt as option_mapOr$1afu7tt, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$172961h as option_mapOr$172961h, mapOr$1lwzqm5 as option_mapOr$1lwzqm5, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$188iunt as option_mapOr$188iunt, mapOr$0ohpdps as option_mapOr$0ohpdps, mapOr$1rph82m as option_mapOr$1rph82m, mapOr$1ruj5y1 as option_mapOr$1ruj5y1, mapOr$03xawqj as option_mapOr$03xawqj, mapOr$1r07wd5 as option_mapOr$1r07wd5, mapOr$03hkgbr as option_mapOr$03hkgbr, mapOr$0uf63ye as option_mapOr$0uf63ye, mapOr$1p2t4pe as option_mapOr$1p2t4pe, mapOr$09t7mex as option_mapOr$09t7mex } from "./core/option.ts"; import * as Dropped from "./keys.Dropped.ts"; import * as Hop from "./keys.Hop.ts"; import * as Horizon from "./keys.Horizon.ts"; @@ -20,8 +20,8 @@ import * as Skewed from "./keys.Skewed.ts"; import * as Touchy from "./keys.Touchy.ts"; import * as Way from "./keys.Way.ts"; -export function way(b: rt.u8): Way.Way | undefined { - const _2: rt.u8 = rt.u8Rem(b, 4); +export function way(b: rs.u8): Way.Way | undefined { + const _2: rs.u8 = rs.u8Rem(b, 4); if (_2 === 0) { return undefined; } @@ -34,87 +34,87 @@ export function way(b: rt.u8): Way.Way | undefined { return "Down" as Way.Way; } -export function hop(b: rt.u8): Hop.Hop | undefined { - const _2: rt.u8 = rt.u8Rem(b, 4); +export function hop(b: rs.u8): Hop.Hop | undefined { + const _2: rs.u8 = rs.u8Rem(b, 4); if (_2 === 0) { return undefined; } if (_2 === 1) { - return { _0: rt.u64Shr(b as rt.u64, 2) }; + return { _0: rs.u64Shr(b as rs.u64, 2) }; } if (_2 === 2) { - return { _0: rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b >> 2 as rt.u64) }; + return { _0: rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b >> 2 as rs.u64) }; } - return { _0: rt.u64Shl(b as rt.u64, 50) }; + return { _0: rs.u64Shl(b as rs.u64, 50) }; } -export function small(b: rt.u8): rt.u8 | undefined { - const v: rt.u8 = rt.u8Rem(b, 3); +export function small(b: rs.u8): rs.u8 | undefined { + const v: rs.u8 = rs.u8Rem(b, 3); if (v === 0) { return undefined; } return v; } -export function side(v: rt.u8): Side.Side { +export function side(v: rs.u8): Side.Side { if (v === 1) { return "Left" as Side.Side; } return "Right" as Side.Side; } -export function name(b: rt.u8): Name.Name { - let text!: rt.Arc; - const _4: rt.usize = rt.usizeRem(b as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); +export function name(b: rs.u8): Name.Name { + let text!: rs.Arc; + const _4: rs.usize = rs.usizeRem(b as rs.usize, ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_4 < 6)) { - rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _4); + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _4); } const _3: string[] = ["", "a", "ab", "", "￿", "𐀀"]; - if (rt.u8Rem(b, 2) === 0) { - text = new rt.Arc(_3[_4]); + if (rs.u8Rem(b, 2) === 0) { + text = new rs.Arc(_3[_4]); } else { - text = new rt.Arc(_3[_4]); + text = new rs.Arc(_3[_4]); } - return new Name.Name(text, small(rt.u8Div(b, 64))); + return new Name.Name(text, small(rs.u8Div(b, 64))); } -export function hashOf$Option_keys_Hop(value: Hop.Hop | undefined): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined)(value, h); - return rt.hashFinish(h); +export function hashOf$Option_keys_Hop(value: Hop.Hop | undefined): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined)(value, h); + return rs.hashFinish(h); } -export function hashOf$keys_Hop(value: Hop.Hop): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashOf$keys_Hop(value: Hop.Hop): rs.u64 { + const h: rs.Hasher = rs.hasher(); Hop.hash$Hash_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashOf$keys_Name(value: Name.Name): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashOf$keys_Name(value: Name.Name): rs.u64 { + const h: rs.Hasher = rs.hasher(); Name.hash$Hash_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashOf$keys_Seen(value: Seen.Seen): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashOf$keys_Seen(value: Seen.Seen): rs.u64 { + const h: rs.Hasher = rs.hasher(); Seen.hash$Hash_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashOf$mut_keys_Hop(value: Hop.Hop): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashOf$mut_keys_Hop(value: Hop.Hop): rs.u64 { + const h: rs.Hasher = rs.hasher(); Hop.hash$Hash_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashOf$sync_Arc_str(value: rt.Arc): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashStr)(value, h); - return rt.hashFinish(h); +export function hashOf$sync_Arc_str(value: rs.Arc): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashStr)(value, h); + return rs.hashFinish(h); } -export function order(o: rt.Ordering): rt.u8 { +export function order(o: rs.Ordering): rs.u8 { if (o === -1) { return 1; } @@ -124,19 +124,19 @@ export function order(o: rt.Ordering): rt.u8 { return 3; } -export function partial(o: rt.Ordering | undefined): rt.u8 { - return option_mapOr$1dgdmlk(o, 0, order); +export function partial(o: rs.Ordering | undefined): rs.u8 { + return option_mapOr$0iqhkrm(o, 0, order); } /** The index of the first of `keys` that borrows as `q`. */ -export function find$String_str(keys: string[], q: string): rt.u8 { - const iter: rt.Iter<[rt.usize, string]> = rt.iterEnumerate(rt.iterSlice(keys)); +export function find$String_str(keys: string[], q: string): rs.u8 { + const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(keys)); while (true) { - const _7: [rt.usize, string] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, string] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const i: rt.usize = _7[0]; + const i: rs.usize = _7[0]; if (_7[1] === q) { return i & 0xff; } @@ -145,14 +145,14 @@ export function find$String_str(keys: string[], q: string): rt.u8 { } /** The index of the first of `keys` that borrows as `q`. */ -export function find$sync_Arc_str_str(keys: rt.Arc[], q: string): rt.u8 { - const iter: rt.Iter<[rt.usize, rt.Arc]> = rt.iterEnumerate(rt.iterSlice(keys)); +export function find$sync_Arc_str_str(keys: rs.Arc[], q: string): rs.u8 { + const iter: rs.Iter<[rs.usize, rs.Arc]> = rs.iterEnumerate(rs.iterSlice(keys)); while (true) { - const _7: [rt.usize, rt.Arc] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.Arc] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const i: rt.usize = _7[0]; + const i: rs.usize = _7[0]; if (_7[1].value === q) { return i & 0xff; } @@ -161,14 +161,14 @@ export function find$sync_Arc_str_str(keys: rt.Arc[], q: string): rt.u8 } /** The index of the first of `keys` that borrows as `q`. */ -export function find$u8_u8(keys: rt.ByteSlice, q: rt.u8): rt.u8 { - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(keys))); +export function find$u8_u8(keys: rs.ByteSlice, q: rs.u8): rs.u8 { + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(keys))); while (true) { - const _7: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const i: rt.usize = _7[0]; + const i: rs.usize = _7[0]; if (_7[1] === q) { return i & 0xff; } @@ -177,8 +177,8 @@ export function find$u8_u8(keys: rt.ByteSlice, q: rt.u8): rt.u8 { } /** Run one case. */ -export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 5); +export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 5); if (_4 === 0) { options(data.data, data.start, data.length, out); } else if (_4 === 1) { @@ -193,190 +193,190 @@ export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$Option_keys_Hop(l: Hop.Hop | undefined, r: Hop.Hop | undefined): rt.u8 { - const _5: rt.u8 = (!rt.eqOption(Hop.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rt.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); - const order = rt.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rt.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); - const order2 = rt.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r); +export function compare$Option_keys_Hop(l: Hop.Hop | undefined, r: Hop.Hop | undefined): rs.u8 { + const _5: rs.u8 = (!rs.eqOption(Hop.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rs.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); + const order = rs.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rs.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const order2 = rs.cmpOption(Hop.partialCmp$cmp_PartialOrd)(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$Option_keys_Lopsided(l: Lopsided.Lopsided | undefined, r: Lopsided.Lopsided | undefined): rt.u8 { - const _5: rt.u8 = (!rt.eqOption(Lopsided.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rt.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); - const order = rt.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rt.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); - const order2 = rt.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r); +export function compare$Option_keys_Lopsided(l: Lopsided.Lopsided | undefined, r: Lopsided.Lopsided | undefined): rs.u8 { + const _5: rs.u8 = (!rs.eqOption(Lopsided.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rs.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); + const order = rs.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rs.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const order2 = rs.cmpOption(Lopsided.partialCmp$cmp_PartialOrd)(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$Option_keys_Rough(l: Rough.Rough | undefined, r: Rough.Rough | undefined): rt.u8 { - const _5: rt.u8 = (!rt.eqOption(Rough.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); - const order = rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); - const order2 = rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r); +export function compare$Option_keys_Rough(l: Rough.Rough | undefined, r: Rough.Rough | undefined): rs.u8 { + const _5: rs.u8 = (!rs.eqOption(Rough.eq$cmp_PartialEq)(l, r) ? 1 : 0) | (((rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r) === -1 ? 1 : 0) << 1) & 0xff); + const order = rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const order2 = rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$cmp_Reverse_keys_Lopsided(l: Lopsided.Lopsided, r: Lopsided.Lopsided): rt.u8 { - return (!Lopsided.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((rt.cmpReverse(Lopsided.lt$cmp_PartialOrd)(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.cmpReverse(Lopsided.le$cmp_PartialOrd)(l, r) ? 1 : 0) << 2) & 0xff) | (((rt.cmpReverse(Lopsided.gt$cmp_PartialOrd)(l, r) ? 1 : 0) << 3) & 0xff) | (((rt.cmpReverse(Lopsided.ge$cmp_PartialOrd)(l, r) ? 1 : 0) << 4) & 0xff); +export function compare$cmp_Reverse_keys_Lopsided(l: Lopsided.Lopsided, r: Lopsided.Lopsided): rs.u8 { + return (!Lopsided.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((rs.cmpReverse(Lopsided.lt$cmp_PartialOrd)(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.cmpReverse(Lopsided.le$cmp_PartialOrd)(l, r) ? 1 : 0) << 2) & 0xff) | (((rs.cmpReverse(Lopsided.gt$cmp_PartialOrd)(l, r) ? 1 : 0) << 3) & 0xff) | (((rs.cmpReverse(Lopsided.ge$cmp_PartialOrd)(l, r) ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Horizon(l: Horizon.Horizon, r: Horizon.Horizon): rt.u8 { - const _5: rt.u8 = (!Horizon.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Horizon.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); +export function compare$keys_Horizon(l: Horizon.Horizon, r: Horizon.Horizon): rs.u8 { + const _5: rs.u8 = (!Horizon.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Horizon.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); const order = Horizon.partialCmp$cmp_PartialOrd(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Horizon.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Horizon.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); const order2 = Horizon.partialCmp$cmp_PartialOrd(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Lopsided(l: Lopsided.Lopsided, r: Lopsided.Lopsided): rt.u8 { +export function compare$keys_Lopsided(l: Lopsided.Lopsided, r: Lopsided.Lopsided): rs.u8 { return (!Lopsided.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Lopsided.lt$cmp_PartialOrd(l, r) ? 1 : 0) << 1) & 0xff) | (((Lopsided.le$cmp_PartialOrd(l, r) ? 1 : 0) << 2) & 0xff) | (((Lopsided.gt$cmp_PartialOrd(l, r) ? 1 : 0) << 3) & 0xff) | (((Lopsided.ge$cmp_PartialOrd(l, r) ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Name(l: Name.Name, r: Name.Name): rt.u8 { - const _5: rt.u8 = (!Name.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Name.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); +export function compare$keys_Name(l: Name.Name, r: Name.Name): rs.u8 { + const _5: rs.u8 = (!Name.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Name.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); const order = Name.partialCmp$cmp_PartialOrd(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Name.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Name.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); const order2 = Name.partialCmp$cmp_PartialOrd(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Rough(l: Rough.Rough, r: Rough.Rough): rt.u8 { - const _5: rt.u8 = (!Rough.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Rough.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); +export function compare$keys_Rough(l: Rough.Rough, r: Rough.Rough): rs.u8 { + const _5: rs.u8 = (!Rough.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Rough.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); const order = Rough.partialCmp$cmp_PartialOrd(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Rough.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Rough.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); const order2 = Rough.partialCmp$cmp_PartialOrd(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Skew(l: Skew.Skew, r: Skew.Skew): rt.u8 { - const _5: rt.u8 = (!Skew.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Skew.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); +export function compare$keys_Skew(l: Skew.Skew, r: Skew.Skew): rs.u8 { + const _5: rs.u8 = (!Skew.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Skew.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); const order = Skew.partialCmp$cmp_PartialOrd(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Skew.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Skew.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); const order2 = Skew.partialCmp$cmp_PartialOrd(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$keys_Skewed(l: Skewed.Skewed, r: Skewed.Skewed): rt.u8 { - const _5: rt.u8 = (!Skewed.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Skewed.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); +export function compare$keys_Skewed(l: Skewed.Skewed, r: Skewed.Skewed): rs.u8 { + const _5: rs.u8 = (!Skewed.eq$cmp_PartialEq(l, r) ? 1 : 0) | (((Skewed.partialCmp$cmp_PartialOrd(l, r) === -1 ? 1 : 0) << 1) & 0xff); const order = Skewed.partialCmp$cmp_PartialOrd(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Skewed.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((Skewed.partialCmp$cmp_PartialOrd(l, r) === 1 ? 1 : 0) << 3) & 0xff); const order2 = Skewed.partialCmp$cmp_PartialOrd(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$sync_Arc_keys_Lopsided(l: rt.Arc, r: rt.Arc): rt.u8 { - return (!rt.eqArc(Lopsided.eq$cmp_PartialEq, true)(l, r) ? 1 : 0) | (((rt.cmpArc(Lopsided.lt$cmp_PartialOrd)(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.cmpArc(Lopsided.le$cmp_PartialOrd)(l, r) ? 1 : 0) << 2) & 0xff) | (((rt.cmpArc(Lopsided.gt$cmp_PartialOrd)(l, r) ? 1 : 0) << 3) & 0xff) | (((rt.cmpArc(Lopsided.ge$cmp_PartialOrd)(l, r) ? 1 : 0) << 4) & 0xff); +export function compare$sync_Arc_keys_Lopsided(l: rs.Arc, r: rs.Arc): rs.u8 { + return (!rs.eqArc(Lopsided.eq$cmp_PartialEq, true)(l, r) ? 1 : 0) | (((rs.cmpArc(Lopsided.lt$cmp_PartialOrd)(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.cmpArc(Lopsided.le$cmp_PartialOrd)(l, r) ? 1 : 0) << 2) & 0xff) | (((rs.cmpArc(Lopsided.gt$cmp_PartialOrd)(l, r) ? 1 : 0) << 3) & 0xff) | (((rs.cmpArc(Lopsided.ge$cmp_PartialOrd)(l, r) ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$tuple2_keys_Lopsided_u8(l: [Lopsided.Lopsided, rt.u8], r: [Lopsided.Lopsided, rt.u8]): rt.u8 { - const _5: rt.u8 = (!rt.eqTuple([Lopsided.eq$cmp_PartialEq, rt.same])(l, r) ? 1 : 0) | (((rt.cmpTuple<[Lopsided.Lopsided, rt.u8], rt.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rt.cmp])(l, r) === -1 ? 1 : 0) << 1) & 0xff); - const order = rt.cmpTuple<[Lopsided.Lopsided, rt.u8], rt.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rt.cmp])(l, r); - const _3: rt.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rt.cmpTuple<[Lopsided.Lopsided, rt.u8], rt.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rt.cmp])(l, r) === 1 ? 1 : 0) << 3) & 0xff); - const order2 = rt.cmpTuple<[Lopsided.Lopsided, rt.u8], rt.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rt.cmp])(l, r); +export function compare$tuple2_keys_Lopsided_u8(l: [Lopsided.Lopsided, rs.u8], r: [Lopsided.Lopsided, rs.u8]): rs.u8 { + const _5: rs.u8 = (!rs.eqTuple([Lopsided.eq$cmp_PartialEq, rs.same])(l, r) ? 1 : 0) | (((rs.cmpTuple<[Lopsided.Lopsided, rs.u8], rs.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rs.cmp])(l, r) === -1 ? 1 : 0) << 1) & 0xff); + const order = rs.cmpTuple<[Lopsided.Lopsided, rs.u8], rs.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rs.cmp])(l, r); + const _3: rs.u8 = _5 | (((order !== undefined && order <= 0 ? 1 : 0) << 2) & 0xff) | (((rs.cmpTuple<[Lopsided.Lopsided, rs.u8], rs.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rs.cmp])(l, r) === 1 ? 1 : 0) << 3) & 0xff); + const order2 = rs.cmpTuple<[Lopsided.Lopsided, rs.u8], rs.Ordering | undefined>([Lopsided.partialCmp$cmp_PartialOrd, rs.cmp])(l, r); return _3 | (((order2 !== undefined && order2 >= 0 ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$tuple2_tuple2_u8_u8_keys_Lopsided(l: [[rt.u8, rt.u8], Lopsided.Lopsided], r: [[rt.u8, rt.u8], Lopsided.Lopsided]): rt.u8 { - return (!rt.eqTuple([rt.eqTuple([rt.same, rt.same]), Lopsided.eq$cmp_PartialEq])(l, r) ? 1 : 0) | (((rt.testTuple([rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])], Lopsided.lt$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.testTuple([rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])], Lopsided.le$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rt.testTuple([rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])], Lopsided.gt$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rt.testTuple([rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])], Lopsided.ge$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 4) & 0xff); +export function compare$tuple2_tuple2_u8_u8_keys_Lopsided(l: [[rs.u8, rs.u8], Lopsided.Lopsided], r: [[rs.u8, rs.u8], Lopsided.Lopsided]): rs.u8 { + return (!rs.eqTuple([rs.eqTuple([rs.same, rs.same]), Lopsided.eq$cmp_PartialEq])(l, r) ? 1 : 0) | (((rs.testTuple([rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])], Lopsided.lt$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.testTuple([rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])], Lopsided.le$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rs.testTuple([rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])], Lopsided.gt$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rs.testTuple([rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])], Lopsided.ge$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(l: [rt.u8, rt.Arc], r: [rt.u8, rt.Arc]): rt.u8 { - return (!rt.eqTuple([rt.same, rt.eqArc(Lopsided.eq$cmp_PartialEq, true)])(l, r) ? 1 : 0) | (((rt.testTuple([rt.cmp], rt.cmpReverse(rt.cmpArc(Lopsided.lt$cmp_PartialOrd)), -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.testTuple([rt.cmp], rt.cmpReverse(rt.cmpArc(Lopsided.le$cmp_PartialOrd)), -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rt.testTuple([rt.cmp], rt.cmpReverse(rt.cmpArc(Lopsided.gt$cmp_PartialOrd)), 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rt.testTuple([rt.cmp], rt.cmpReverse(rt.cmpArc(Lopsided.ge$cmp_PartialOrd)), 1)(l, r) ? 1 : 0) << 4) & 0xff); +export function compare$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(l: [rs.u8, rs.Arc], r: [rs.u8, rs.Arc]): rs.u8 { + return (!rs.eqTuple([rs.same, rs.eqArc(Lopsided.eq$cmp_PartialEq, true)])(l, r) ? 1 : 0) | (((rs.testTuple([rs.cmp], rs.cmpReverse(rs.cmpArc(Lopsided.lt$cmp_PartialOrd)), -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.testTuple([rs.cmp], rs.cmpReverse(rs.cmpArc(Lopsided.le$cmp_PartialOrd)), -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rs.testTuple([rs.cmp], rs.cmpReverse(rs.cmpArc(Lopsided.gt$cmp_PartialOrd)), 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rs.testTuple([rs.cmp], rs.cmpReverse(rs.cmpArc(Lopsided.ge$cmp_PartialOrd)), 1)(l, r) ? 1 : 0) << 4) & 0xff); } /** `!=`, `<`, `<=`, `>`, and `>=` of each of `l` and `r` with the other, as bits. */ -export function compare$tuple2_u8_keys_Lopsided(l: [rt.u8, Lopsided.Lopsided], r: [rt.u8, Lopsided.Lopsided]): rt.u8 { - return (!rt.eqTuple([rt.same, Lopsided.eq$cmp_PartialEq])(l, r) ? 1 : 0) | (((rt.testTuple([rt.cmp], Lopsided.lt$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.testTuple([rt.cmp], Lopsided.le$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rt.testTuple([rt.cmp], Lopsided.gt$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rt.testTuple([rt.cmp], Lopsided.ge$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 4) & 0xff); +export function compare$tuple2_u8_keys_Lopsided(l: [rs.u8, Lopsided.Lopsided], r: [rs.u8, Lopsided.Lopsided]): rs.u8 { + return (!rs.eqTuple([rs.same, Lopsided.eq$cmp_PartialEq])(l, r) ? 1 : 0) | (((rs.testTuple([rs.cmp], Lopsided.lt$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.testTuple([rs.cmp], Lopsided.le$cmp_PartialOrd, -1)(l, r) ? 1 : 0) << 2) & 0xff) | (((rs.testTuple([rs.cmp], Lopsided.gt$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 3) & 0xff) | (((rs.testTuple([rs.cmp], Lopsided.ge$cmp_PartialOrd, 1)(l, r) ? 1 : 0) << 4) & 0xff); } /** * The comparisons a type's `PartialEq` and `PartialOrd` inherit: `!=` as `!eq`, and * the orderings from `partial_cmp`, false when it is `None`, whatever `eq` says. */ -export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { - let _7!: rt.usize; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; +export function defaults(data: rs.ByteSlice, out: rs.ByteVec): void { + let _7!: rs.usize; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = data.length; while ((_7 = iterStart++) < iterEnd) { - const i: rt.usize = _7; - const _15: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _15); - const _14: rt.u8 = data.data[data.start + _15]; - rt.idx(data, i); - const _13: [rt.u8, rt.u8] = [_14, data.data[data.start + i]]; - const c: rt.u8 = _14; - const d: rt.u8 = _13[1]; + const i: rs.usize = _7; + const _15: rs.usize = rs.usizeSub(i, 1); + rs.idx(data, _15); + const _14: rs.u8 = data.data[data.start + _15]; + rs.idx(data, i); + const _13: [rs.u8, rs.u8] = [_14, data.data[data.start + i]]; + const c: rs.u8 = _14; + const d: rs.u8 = _13[1]; const _24: [Rough.Rough, Rough.Rough] = [{ _0: c }, { _0: d }]; const a: Rough.Rough = _24[0]; const b: Rough.Rough = _24[1]; - const _29: rt.u8 = compare$keys_Rough(a, b) | (((!Rough.eq$cmp_PartialEq(a, b) ? 1 : 0) << 5) & 0xff) | (((Rough.partialCmp$cmp_PartialOrd(a, b) === -1 ? 1 : 0) << 6) & 0xff); + const _29: rs.u8 = compare$keys_Rough(a, b) | (((!Rough.eq$cmp_PartialEq(a, b) ? 1 : 0) << 5) & 0xff) | (((Rough.partialCmp$cmp_PartialOrd(a, b) === -1 ? 1 : 0) << 6) & 0xff); const order = Rough.partialCmp$cmp_PartialOrd(a, b); - rt.byteVecPush(out, _29 | (((order !== undefined && order >= 0 ? 1 : 0) << 7) & 0xff)); - const _58: rt.u8 = compare$Option_keys_Rough(a, b); + rs.byteVecPush(out, _29 | (((order !== undefined && order >= 0 ? 1 : 0) << 7) & 0xff)); + const _58: rs.u8 = compare$Option_keys_Rough(a, b); const _67: Rough.Rough | undefined = a; - const order2 = rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(_67, undefined); - const _57: rt.u8 = _58 | (((order2 !== undefined && order2 <= 0 ? 1 : 0) << 5) & 0xff); + const order2 = rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(_67, undefined); + const _57: rs.u8 = _58 | (((order2 !== undefined && order2 <= 0 ? 1 : 0) << 5) & 0xff); const _74: Rough.Rough | undefined = undefined; const _76: Rough.Rough | undefined = b; - rt.byteVecPush(out, _57 | (((rt.cmpOption(Rough.partialCmp$cmp_PartialOrd)(_74, _76) === -1 ? 1 : 0) << 6) & 0xff)); - const _81: [Skew.Skew, Skew.Skew] = [{ _0: rt.u8Rem(c, 4) }, { _0: rt.u8Rem(d, 4) }]; + rs.byteVecPush(out, _57 | (((rs.cmpOption(Rough.partialCmp$cmp_PartialOrd)(_74, _76) === -1 ? 1 : 0) << 6) & 0xff)); + const _81: [Skew.Skew, Skew.Skew] = [{ _0: rs.u8Rem(c, 4) }, { _0: rs.u8Rem(d, 4) }]; const s: Skew.Skew = _81[0]; const t: Skew.Skew = _81[1]; - const _91: rt.u8 = compare$keys_Skew(s, t); + const _91: rs.u8 = compare$keys_Skew(s, t); const order3 = Skew.partialCmp$cmp_PartialOrd(s, t); - rt.byteVecPush(out, _91 | (((order3 !== undefined && order3 <= 0 ? 1 : 0) << 5) & 0xff) | (((Skew.partialCmp$cmp_PartialOrd(s, t) === 1 ? 1 : 0) << 6) & 0xff)); - rt.byteVecPush(out, compare$keys_Skewed({ _0: s }, { _0: t })); + rs.byteVecPush(out, _91 | (((order3 !== undefined && order3 <= 0 ? 1 : 0) << 5) & 0xff) | (((Skew.partialCmp$cmp_PartialOrd(s, t) === 1 ? 1 : 0) << 6) & 0xff)); + rs.byteVecPush(out, compare$keys_Skewed({ _0: s }, { _0: t })); const _118: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; const g: Hop.Hop | undefined = _118[0]; const h: Hop.Hop | undefined = _118[1]; - const _123: rt.u8 = compare$Option_keys_Hop(g, h); - const _130: rt.u64 | undefined = option_map$120lney(g, (h2: Hop.Hop): rt.u64 => { + const _123: rs.u8 = compare$Option_keys_Hop(g, h); + const _130: rs.u64 | undefined = option_map$174onvc(g, (h2: Hop.Hop): rs.u64 => { return h2._0; }); - const _132: rt.u64 | undefined = option_map$120lney(h, (h3: Hop.Hop): rt.u64 => { + const _132: rs.u64 | undefined = option_map$174onvc(h, (h3: Hop.Hop): rs.u64 => { return h3._0; }); - rt.byteVecPush(out, _123 | (((rt.cmpOption(rt.cmp)(_130, _132) === 1 ? 1 : 0) << 5) & 0xff)); - const _138: Horizon.Horizon = { exclude: g, local: rt.u8Rem(c, 2) === 0 }; - const _137: [Horizon.Horizon, Horizon.Horizon] = [_138, { exclude: h, local: rt.u8Rem(d, 2) === 0 }]; + rs.byteVecPush(out, _123 | (((rs.cmpOption(rs.cmp)(_130, _132) === 1 ? 1 : 0) << 5) & 0xff)); + const _138: Horizon.Horizon = { exclude: g, local: rs.u8Rem(c, 2) === 0 }; + const _137: [Horizon.Horizon, Horizon.Horizon] = [_138, { exclude: h, local: rs.u8Rem(d, 2) === 0 }]; const x: Horizon.Horizon = _138; const y: Horizon.Horizon = _137[1]; - const _148: rt.u8 = compare$keys_Horizon(x, y) | (((Horizon.partialCmp$cmp_PartialOrd(x, y) === -1 ? 1 : 0) << 5) & 0xff); + const _148: rs.u8 = compare$keys_Horizon(x, y) | (((Horizon.partialCmp$cmp_PartialOrd(x, y) === -1 ? 1 : 0) << 5) & 0xff); const order4 = Horizon.partialCmp$cmp_PartialOrd(x, y); - rt.byteVecPush(out, _148 | (((order4 !== undefined && order4 >= 0 ? 1 : 0) << 6) & 0xff)); + rs.byteVecPush(out, _148 | (((order4 !== undefined && order4 >= 0 ? 1 : 0) << 6) & 0xff)); const _176: [Name.Name, Name.Name] = [name(c), name(d)]; const m: Name.Name = _176[0]; const n: Name.Name = _176[1]; - rt.byteVecPush(out, compare$keys_Name(m, n) | (((!rt.eqArc(rt.same, true)(m.text, n.text) ? 1 : 0) << 5) & 0xff)); - const _194: rt.u8 = !Side.eq$cmp_PartialEq(side(rt.u8Rem(c, 2)), side(rt.u8Rem(d, 2))) ? 1 : 0; + rs.byteVecPush(out, compare$keys_Name(m, n) | (((!rs.eqArc(rs.same, true)(m.text, n.text) ? 1 : 0) << 5) & 0xff)); + const _194: rs.u8 = !Side.eq$cmp_PartialEq(side(rs.u8Rem(c, 2)), side(rs.u8Rem(d, 2))) ? 1 : 0; const _208: Way.Way | undefined = way(c); const _210: Way.Way | undefined = way(d); - rt.byteVecPush(out, _194 | (((!rt.eqOption(Way.eq$cmp_PartialEq)(_208, _210) ? 1 : 0) << 1) & 0xff) | (((option_map$0lcwx9x(way(c), (w: Way.Way): boolean => { + rs.byteVecPush(out, _194 | (((!rs.eqOption(Way.eq$cmp_PartialEq)(_208, _210) ? 1 : 0) << 1) & 0xff) | (((option_map$0lcwx9x(way(c), (w: Way.Way): boolean => { return !Way.eq$cmp_PartialEq(w, "Top" as Way.Way); }) === true ? 1 : 0) << 2) & 0xff)); - const _225: rt.ByteSlice = rt.byteSliceRange(data, 0, i); - const _227: rt.ByteSlice = rt.byteSliceRange(data, i); - const l: rt.ByteSlice = _225; - const r: rt.ByteSlice = _227; - const _232: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeSub(i, 1), i); - const _236: rt.ByteSlice = rt.byteSliceRange(data, rt.usizeRem(c as rt.usize, i), rt.usizeAdd(rt.usizeRem(c as rt.usize, i), 1)); - const p: rt.ByteSlice = _232; - const q: rt.ByteSlice = _236; - rt.byteVecPush(out, (rt.byteSliceEq(l, r) ? 1 : 0) | (((!rt.byteSliceEq(l, r) ? 1 : 0) << 1) & 0xff) | (((rt.byteSliceEq(p, q) ? 1 : 0) << 2) & 0xff) | (((!rt.byteSliceEq(p, q) ? 1 : 0) << 3) & 0xff) | (((rt.byteSliceEq(rt.byteSliceRange(l, 0, 0), rt.byteSliceRange(r, 0, 0)) ? 1 : 0) << 4) & 0xff) | (((rt.byteSliceEq(rt.byteSliceRange(data, 0, i), rt.byteSliceRange(data, rt.usizeSub(data.length, i))) ? 1 : 0) << 5) & 0xff)); + const _225: rs.ByteSlice = rs.byteSliceRange(data, 0, i); + const _227: rs.ByteSlice = rs.byteSliceRange(data, i); + const l: rs.ByteSlice = _225; + const r: rs.ByteSlice = _227; + const _232: rs.ByteSlice = rs.byteSliceRange(data, rs.usizeSub(i, 1), i); + const _236: rs.ByteSlice = rs.byteSliceRange(data, rs.usizeRem(c as rs.usize, i), rs.usizeAdd(rs.usizeRem(c as rs.usize, i), 1)); + const p: rs.ByteSlice = _232; + const q: rs.ByteSlice = _236; + rs.byteVecPush(out, (rs.byteSliceEq(l, r) ? 1 : 0) | (((!rs.byteSliceEq(l, r) ? 1 : 0) << 1) & 0xff) | (((rs.byteSliceEq(p, q) ? 1 : 0) << 2) & 0xff) | (((!rs.byteSliceEq(p, q) ? 1 : 0) << 3) & 0xff) | (((rs.byteSliceEq(rs.byteSliceRange(l, 0, 0), rs.byteSliceRange(r, 0, 0)) ? 1 : 0) << 4) & 0xff) | (((rs.byteSliceEq(rs.byteSliceRange(data, 0, i), rs.byteSliceRange(data, rs.usizeSub(data.length, i))) ? 1 : 0) << 5) & 0xff)); n[Symbol.dispose](); m[Symbol.dispose](); } @@ -388,83 +388,83 @@ export function defaults(data: rt.ByteSlice, out: rt.ByteVec): void { * `clamp`, and sorts. A field before a tuple's last, and an `Option`, compare by * `partial_cmp`. The first three bytes clamp last, which panics unless `min <= max`. */ -export function overrides(_1: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _8!: rt.usize; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; +export function overrides(_1: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _8!: rs.usize; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = data.length; while ((_8 = iterStart++) < iterEnd) { - const i: rt.usize = _8; - const _16: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _16); - const _15: rt.u8 = data.data[data.start + _16]; - rt.idx(data, i); - const _14: [rt.u8, rt.u8] = [_15, data.data[data.start + i]]; - const c: rt.u8 = _15; - const d: rt.u8 = _14[1]; + const i: rs.usize = _8; + const _16: rs.usize = rs.usizeSub(i, 1); + rs.idx(data, _16); + const _15: rs.u8 = data.data[data.start + _16]; + rs.idx(data, i); + const _14: [rs.u8, rs.u8] = [_15, data.data[data.start + i]]; + const c: rs.u8 = _15; + const d: rs.u8 = _14[1]; const _25: [Lopsided.Lopsided, Lopsided.Lopsided] = [{ _0: c }, { _0: d }]; const a: Lopsided.Lopsided = _25[0]; const b: Lopsided.Lopsided = _25[1]; - rt.byteVecPush(out, compare$keys_Lopsided(a, b)); - const _34: rt.u8 = compare$tuple2_u8_keys_Lopsided([rt.u8Rem(c, 2), a] as [rt.u8, Lopsided.Lopsided], [rt.u8Rem(d, 2), b] as [rt.u8, Lopsided.Lopsided]); - const _48: [rt.u8, Lopsided.Lopsided] = [rt.u8Rem(c, 2), a]; - const _55: [rt.u8, Lopsided.Lopsided] = [rt.u8Rem(d, 2), b]; - rt.byteVecPush(out, _34 | (((rt.testTuple([rt.cmp], Lopsided.lt$cmp_PartialOrd, -1)(_48, _55) ? 1 : 0) << 5) & 0xff)); - rt.byteVecPush(out, compare$tuple2_tuple2_u8_u8_keys_Lopsided([[rt.u8Rem(c, 2), rt.u8Rem(c, 3)] as [rt.u8, rt.u8], a] as [[rt.u8, rt.u8], Lopsided.Lopsided], [[rt.u8Rem(d, 2), rt.u8Rem(d, 3)] as [rt.u8, rt.u8], b] as [[rt.u8, rt.u8], Lopsided.Lopsided])); - const _80: [Lopsided.Lopsided, rt.u8] = [a, rt.u8Rem(c, 2)]; - rt.byteVecPush(out, compare$tuple2_keys_Lopsided_u8(_80, [b, rt.u8Rem(d, 2)] as [Lopsided.Lopsided, rt.u8])); - const _90: rt.Arc = new rt.Arc(a); - const _92: rt.Arc = new rt.Arc(b); - rt.byteVecPush(out, compare$sync_Arc_keys_Lopsided(_90, _92)); + rs.byteVecPush(out, compare$keys_Lopsided(a, b)); + const _34: rs.u8 = compare$tuple2_u8_keys_Lopsided([rs.u8Rem(c, 2), a] as [rs.u8, Lopsided.Lopsided], [rs.u8Rem(d, 2), b] as [rs.u8, Lopsided.Lopsided]); + const _48: [rs.u8, Lopsided.Lopsided] = [rs.u8Rem(c, 2), a]; + const _55: [rs.u8, Lopsided.Lopsided] = [rs.u8Rem(d, 2), b]; + rs.byteVecPush(out, _34 | (((rs.testTuple([rs.cmp], Lopsided.lt$cmp_PartialOrd, -1)(_48, _55) ? 1 : 0) << 5) & 0xff)); + rs.byteVecPush(out, compare$tuple2_tuple2_u8_u8_keys_Lopsided([[rs.u8Rem(c, 2), rs.u8Rem(c, 3)] as [rs.u8, rs.u8], a] as [[rs.u8, rs.u8], Lopsided.Lopsided], [[rs.u8Rem(d, 2), rs.u8Rem(d, 3)] as [rs.u8, rs.u8], b] as [[rs.u8, rs.u8], Lopsided.Lopsided])); + const _80: [Lopsided.Lopsided, rs.u8] = [a, rs.u8Rem(c, 2)]; + rs.byteVecPush(out, compare$tuple2_keys_Lopsided_u8(_80, [b, rs.u8Rem(d, 2)] as [Lopsided.Lopsided, rs.u8])); + const _90: rs.Arc = new rs.Arc(a); + const _92: rs.Arc = new rs.Arc(b); + rs.byteVecPush(out, compare$sync_Arc_keys_Lopsided(_90, _92)); _92[Symbol.dispose](); _90[Symbol.dispose](); - rt.byteVecPush(out, compare$cmp_Reverse_keys_Lopsided(a, b)); - rt.byteVecPush(out, compare$Option_keys_Lopsided(a, b)); - const _108: [rt.u8, rt.Arc] = [rt.u8Rem(c, 2), new rt.Arc(a)]; - const _114: [rt.u8, rt.Arc] = [rt.u8Rem(d, 2), new rt.Arc(b)]; - rt.byteVecPush(out, compare$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_108, _114)); + rs.byteVecPush(out, compare$cmp_Reverse_keys_Lopsided(a, b)); + rs.byteVecPush(out, compare$Option_keys_Lopsided(a, b)); + const _108: [rs.u8, rs.Arc] = [rs.u8Rem(c, 2), new rs.Arc(a)]; + const _114: [rs.u8, rs.Arc] = [rs.u8Rem(d, 2), new rs.Arc(b)]; + rs.byteVecPush(out, compare$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_108, _114)); drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_114); drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_108); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.ordMax(a, b, Lopsided.lt$cmp_PartialOrd)._0, rt.ordMin(a, b, Lopsided.lt$cmp_PartialOrd)._0, rt.ordMax(a, b, Lopsided.lt$cmp_PartialOrd)._0)), undefined, true); - const _131: [[rt.u8, Lopsided.Lopsided], rt.Arc] = [rt.ordMax([rt.u8Rem(c, 2), a] as [rt.u8, Lopsided.Lopsided], [rt.u8Rem(d, 2), b] as [rt.u8, Lopsided.Lopsided], rt.testTuple([rt.cmp], rt.cmpReverse(Lopsided.lt$cmp_PartialOrd), -1)), rt.ordMin(new rt.Arc(a), new rt.Arc(b), rt.cmpArc(Lopsided.lt$cmp_PartialOrd), rt.drop)]; - const m: [rt.u8, Lopsided.Lopsided] = _131[0]; - const n: rt.Arc = _131[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(m[0], m[1]._0, n.value._0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.ordMax(a, b, Lopsided.lt$cmp_PartialOrd)._0, rs.ordMin(a, b, Lopsided.lt$cmp_PartialOrd)._0, rs.ordMax(a, b, Lopsided.lt$cmp_PartialOrd)._0)), undefined, true); + const _131: [[rs.u8, Lopsided.Lopsided], rs.Arc] = [rs.ordMax([rs.u8Rem(c, 2), a] as [rs.u8, Lopsided.Lopsided], [rs.u8Rem(d, 2), b] as [rs.u8, Lopsided.Lopsided], rs.testTuple([rs.cmp], rs.cmpReverse(Lopsided.lt$cmp_PartialOrd), -1)), rs.ordMin(new rs.Arc(a), new rs.Arc(b), rs.cmpArc(Lopsided.lt$cmp_PartialOrd), rs.drop)]; + const m: [rs.u8, Lopsided.Lopsided] = _131[0]; + const n: rs.Arc = _131[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(m[0], m[1]._0, n.value._0)), undefined, true); const x: Lopsided.Lopsided = { _0: c ^ d }; if (Lopsided.le$cmp_PartialOrd(a, b)) { - rt.byteVecPush(out, rt.ordClamp(x, a, b, Lopsided.le$cmp_PartialOrd, Lopsided.lt$cmp_PartialOrd, Lopsided.gt$cmp_PartialOrd)._0); + rs.byteVecPush(out, rs.ordClamp(x, a, b, Lopsided.le$cmp_PartialOrd, Lopsided.lt$cmp_PartialOrd, Lopsided.gt$cmp_PartialOrd)._0); } n[Symbol.dispose](); } - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Lopsided.Lopsided => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Lopsided.Lopsided => { return { _0: _2 }; }), undefined, 1, true); - rt.sliceSort(v.items, Lopsided.lt$cmp_PartialOrd, 1, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v.items), (x2: Lopsided.Lopsided): rt.u8 => { + rs.sliceSort(v.items, Lopsided.lt$cmp_PartialOrd, 1, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v.items), (x2: Lopsided.Lopsided): rs.u8 => { return x2._0; }), undefined, true); - rt.sliceSortUnstable(v.items, rt.keyLt((_23: Lopsided.Lopsided): [rt.u8, Lopsided.Lopsided] => { + rs.sliceSortUnstable(v.items, rs.keyLt((_23: Lopsided.Lopsided): [rs.u8, Lopsided.Lopsided] => { const x3: Lopsided.Lopsided = _23; - return [rt.u8Rem(x3._0, 3), x3] as [rt.u8, Lopsided.Lopsided]; - }, rt.testTuple([rt.cmp], rt.cmpReverse(Lopsided.lt$cmp_PartialOrd), -1)), 1, true, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v.items), (x4: Lopsided.Lopsided): rt.u8 => { + return [rs.u8Rem(x3._0, 3), x3] as [rs.u8, Lopsided.Lopsided]; + }, rs.testTuple([rs.cmp], rs.cmpReverse(Lopsided.lt$cmp_PartialOrd), -1)), 1, true, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v.items), (x4: Lopsided.Lopsided): rs.u8 => { return x4._0; }), undefined, true); - const pairs: rt.Vec<[rt.u8, Lopsided.Lopsided]> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.u8, Lopsided.Lopsided] => { - const c4: rt.u8 = _24; - return [rt.u8Rem(c4, 4), { _0: c4 }] as [rt.u8, Lopsided.Lopsided]; + const pairs: rs.Vec<[rs.u8, Lopsided.Lopsided]> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, Lopsided.Lopsided] => { + const c4: rs.u8 = _24; + return [rs.u8Rem(c4, 4), { _0: c4 }] as [rs.u8, Lopsided.Lopsided]; }), undefined, 2, true); - rt.sliceSortUnstable(pairs.items, rt.testTuple([rt.cmp], Lopsided.lt$cmp_PartialOrd, -1), 2, true, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(pairs.items), (p: [rt.u8, Lopsided.Lopsided]): rt.u8 => { + rs.sliceSortUnstable(pairs.items, rs.testTuple([rs.cmp], Lopsided.lt$cmp_PartialOrd, -1), 2, true, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(pairs.items), (p: [rs.u8, Lopsided.Lopsided]): rs.u8 => { return p[1]._0; }), undefined, true); if (data.length >= 3) { - rt.byteVecPush(out, rt.ordClamp({ _0: data.data[data.start] }, { _0: data.data[data.start + 1] }, { _0: data.data[data.start + 2] }, Lopsided.le$cmp_PartialOrd, Lopsided.lt$cmp_PartialOrd, Lopsided.gt$cmp_PartialOrd)._0); + rs.byteVecPush(out, rs.ordClamp({ _0: data.data[data.start] }, { _0: data.data[data.start + 1] }, { _0: data.data[data.start + 2] }, Lopsided.le$cmp_PartialOrd, Lopsided.lt$cmp_PartialOrd, Lopsided.gt$cmp_PartialOrd)._0); } } /** One of `Seen`'s variants, by `k`. */ -export function seen(k: rt.u8, hop: Hop.Hop | undefined, horizon: Horizon.Horizon, name: Name.Name, mine: Hop.Hop): Seen.Seen { - const _6: rt.u8 = rt.u8Rem(k, 5); +export function seen(k: rs.u8, hop: Hop.Hop | undefined, horizon: Horizon.Horizon, name: Name.Name, mine: Hop.Hop): Seen.Seen { + const _6: rs.u8 = rs.u8Rem(k, 5); if (_6 === 0) { return { tag: "Hop", _0: hop } as Seen.Seen; } @@ -472,9 +472,9 @@ export function seen(k: rt.u8, hop: Hop.Hop | undefined, horizon: Horizon.Horizo return { tag: "Twice", _0: horizon } as Seen.Seen; } if (_6 === 2) { - const _9: rt.usize = rt.usizeRem(rt.usizeDiv(k as rt.usize, 5), ["", "a", "ab", "", "￿", "𐀀"].length); + const _9: rs.usize = rs.usizeRem(rs.usizeDiv(k as rs.usize, 5), ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_9 < 6)) { - rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _9); + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _9); } return { tag: "Text", _0: ["", "a", "ab", "", "￿", "𐀀"][_9] } as Seen.Seen; } @@ -488,211 +488,211 @@ export function seen(k: rt.u8, hop: Hop.Hop | undefined, horizon: Horizon.Horizo * Borrows compared, ordered, and hashed as what they point at, through one reference * or two, shared or mutable. */ -export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _7!: rt.usize; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = dataLen; +export function borrows(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _7!: rs.usize; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { - const i: rt.usize = _7; - const _15: rt.usize = rt.usizeSub(i, 1); + const i: rs.usize = _7; + const _15: rs.usize = rs.usizeSub(i, 1); if (_15 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); } - const _14: rt.u8 = dataData[dataStart + _15]; + const _14: rs.u8 = dataData[dataStart + _15]; if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _13: [rt.u8, rt.u8] = [_14, dataData[dataStart + i]]; - const c: rt.u8 = _14; - const d: rt.u8 = _13[1]; + const _13: [rs.u8, rs.u8] = [_14, dataData[dataStart + i]]; + const c: rs.u8 = _14; + const d: rs.u8 = _13[1]; const _24: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; const a: Hop.Hop | undefined = _24[0]; const b: Hop.Hop | undefined = _24[1]; - const g: Horizon.Horizon = { exclude: a, local: rt.u8Rem(c, 2) === 0 }; - const h: Horizon.Horizon = { exclude: b, local: rt.u8Rem(d, 2) === 0 }; + const g: Horizon.Horizon = { exclude: a, local: rs.u8Rem(c, 2) === 0 }; + const h: Horizon.Horizon = { exclude: b, local: rs.u8Rem(d, 2) === 0 }; const gr: Horizon.Horizon = g; const hr: Horizon.Horizon = h; const _42: [Name.Name, Name.Name] = [name(c), name(d)]; const m: Name.Name = _42[0]; const n: Name.Name = _42[1]; - const _47: [Hop.Hop, Hop.Hop] = [{ _0: rt.u64Rem(c as rt.u64, 3) }, { _0: rt.u64Rem(d as rt.u64, 3) }]; + const _47: [Hop.Hop, Hop.Hop] = [{ _0: rs.u64Rem(c as rs.u64, 3) }, { _0: rs.u64Rem(d as rs.u64, 3) }]; const x: Hop.Hop = copy$keys_Hop(_47[0]); const y: Hop.Hop = copy$keys_Hop(_47[1]); const _58: [Seen.Seen, Seen.Seen] = [seen(c, a, gr, m, x), seen(d, b, hr, n, y)]; const l: Seen.Seen = _58[0]; const r: Seen.Seen = _58[1]; - rt.byteVecPush(out, (Seen.eq$cmp_PartialEq(l, r) ? 1 : 0) | ((order(Seen.cmp$cmp_Ord(l, r)) << 1) & 0xff) | ((partial(Seen.partialCmp$cmp_PartialOrd(l, r)) << 3) & 0xff) | (((rt.u64Eq(hashOf$keys_Seen(l), hashOf$keys_Seen(r)) ? 1 : 0) << 5) & 0xff)); - const _102: [Skew.Skew, Skew.Skew] = [{ _0: rt.u8Rem(c, 4) }, { _0: rt.u8Rem(d, 4) }]; + rs.byteVecPush(out, (Seen.eq$cmp_PartialEq(l, r) ? 1 : 0) | ((order(Seen.cmp$cmp_Ord(l, r)) << 1) & 0xff) | ((partial(Seen.partialCmp$cmp_PartialOrd(l, r)) << 3) & 0xff) | (((rs.u64Eq(hashOf$keys_Seen(l), hashOf$keys_Seen(r)) ? 1 : 0) << 5) & 0xff)); + const _102: [Skew.Skew, Skew.Skew] = [{ _0: rs.u8Rem(c, 4) }, { _0: rs.u8Rem(d, 4) }]; const _111: [Skewed.Skewed, Skewed.Skewed] = [{ _0: _102[0] }, { _0: _102[1] }]; const s2: Skewed.Skewed = _111[0]; const t2: Skewed.Skewed = _111[1]; - rt.byteVecPush(out, (Skewed.eq$cmp_PartialEq(s2, t2) ? 1 : 0) | ((partial(Skewed.partialCmp$cmp_PartialOrd(s2, t2)) << 1) & 0xff)); - rt.byteVecPush(out, (rt.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) | (((Horizon.eq$cmp_PartialEq(gr, hr) ? 1 : 0) << 1) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 2) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 3) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 4) & 0xff) | (((rt.u64Eq(hashOf$mut_keys_Hop(x), hashOf$keys_Hop(y)) ? 1 : 0) << 5) & 0xff)); + rs.byteVecPush(out, (Skewed.eq$cmp_PartialEq(s2, t2) ? 1 : 0) | ((partial(Skewed.partialCmp$cmp_PartialOrd(s2, t2)) << 1) & 0xff)); + rs.byteVecPush(out, (rs.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) | (((Horizon.eq$cmp_PartialEq(gr, hr) ? 1 : 0) << 1) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 2) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 3) & 0xff) | (((Hop.eq$cmp_PartialEq(x, y) ? 1 : 0) << 4) & 0xff) | (((rs.u64Eq(hashOf$mut_keys_Hop(x), hashOf$keys_Hop(y)) ? 1 : 0) << 5) & 0xff)); n[Symbol.dispose](); m[Symbol.dispose](); } } /** `Option`s compared, ordered, and hashed, alone and in keys. */ -export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _12!: rt.usize; - const _313: (a0: rt.u8) => Way.Way | undefined | rt.None = (b2: rt.u8): Way.Way | undefined | rt.None => { - return then$18np55d(rt.u8Rem(b2, 5) !== 0, (): Way.Way | undefined => { +export function options(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _12!: rs.usize; + const _313: (a0: rs.u8) => Way.Way | undefined | rs.None = (b2: rs.u8): Way.Way | undefined | rs.None => { + return then$05y10ww(rs.u8Rem(b2, 5) !== 0, (): Way.Way | undefined => { return way(b2); }); }; - const hashed: rt.HashMap<[rt.u8, Horizon.Horizon], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, Horizon.hash$Hash_hash_DefaultHasher as (a0: Horizon.Horizon, a1: rt.Hasher) => undefined]), rt.eqTuple([rt.same, Horizon.eq$cmp_PartialEq]))) as rt.HashMap<[rt.u8, Horizon.Horizon], rt.u8>; - const sorted: rt.BTreeMap<[rt.u8, Horizon.Horizon], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, Horizon.Horizon], rt.Ordering>([rt.cmp, Horizon.cmp$cmp_Ord])) as rt.BTreeMap<[rt.u8, Horizon.Horizon], rt.u8>; - const ways: rt.HashMap<[Way.Way | undefined, boolean], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rt.Hasher) => undefined), rt.hash8]), rt.eqTuple([rt.eqOption(Way.eq$cmp_PartialEq), rt.same]))) as rt.HashMap<[Way.Way | undefined, boolean], rt.u8>; - const bare: rt.HashMap = rt.hashNew(rt.hashing(rt.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rt.Hasher) => undefined), rt.eqOption(Way.eq$cmp_PartialEq), true)) as rt.HashMap; - const deep: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rt.Hasher) => undefined), rt.None), rt.eqOption(rt.eqOption(Way.eq$cmp_PartialEq), rt.None), true)) as rt.HashSet; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = dataLen; + const hashed: rs.HashMap<[rs.u8, Horizon.Horizon], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, Horizon.hash$Hash_hash_DefaultHasher as (a0: Horizon.Horizon, a1: rs.Hasher) => undefined]), rs.eqTuple([rs.same, Horizon.eq$cmp_PartialEq]))) as rs.HashMap<[rs.u8, Horizon.Horizon], rs.u8>; + const sorted: rs.BTreeMap<[rs.u8, Horizon.Horizon], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Horizon.Horizon], rs.Ordering>([rs.cmp, Horizon.cmp$cmp_Ord])) as rs.BTreeMap<[rs.u8, Horizon.Horizon], rs.u8>; + const ways: rs.HashMap<[Way.Way | undefined, boolean], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rs.Hasher) => undefined), rs.hash8]), rs.eqTuple([rs.eqOption(Way.eq$cmp_PartialEq), rs.same]))) as rs.HashMap<[Way.Way | undefined, boolean], rs.u8>; + const bare: rs.HashMap = rs.hashNew(rs.hashing(rs.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rs.Hasher) => undefined), rs.eqOption(Way.eq$cmp_PartialEq), true)) as rs.HashMap; + const deep: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashOption(Way.hash$Hash_hash_DefaultHasher as (a0: Way.Way, a1: rs.Hasher) => undefined), rs.None), rs.eqOption(rs.eqOption(Way.eq$cmp_PartialEq), rs.None), true)) as rs.HashSet; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = dataLen; while ((_12 = iterStart++) < iterEnd) { - const i: rt.usize = _12; - const _20: rt.usize = rt.usizeSub(i, 1); + const i: rs.usize = _12; + const _20: rs.usize = rs.usizeSub(i, 1); if (_20 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _20); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _20); } - const _19: rt.u8 = dataData[dataStart + _20]; + const _19: rs.u8 = dataData[dataStart + _20]; if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _18: [rt.u8, rt.u8] = [_19, dataData[dataStart + i]]; - const c: rt.u8 = _19; - const d: rt.u8 = _18[1]; + const _18: [rs.u8, rs.u8] = [_19, dataData[dataStart + i]]; + const c: rs.u8 = _19; + const d: rs.u8 = _18[1]; const _29: [Hop.Hop | undefined, Hop.Hop | undefined] = [hop(c), hop(d)]; const a: Hop.Hop | undefined = _29[0]; const b: Hop.Hop | undefined = _29[1]; - rt.byteVecPush(out, (rt.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) | (((!rt.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) << 1) & 0xff) | ((order(rt.cmpOption(Hop.cmp$cmp_Ord)(a, b)) << 2) & 0xff)); - const _58: Hop.Hop | undefined = rt.ordMax(a, b, rt.cmpLt(rt.cmpOption(Hop.partialCmp$cmp_PartialOrd))); - const _55: rt.u8 = rt.eqOption(Hop.eq$cmp_PartialEq)(_58, b) ? 1 : 0; - const _64: Hop.Hop | undefined = rt.ordMin(a, b, rt.cmpLt(rt.cmpOption(Hop.partialCmp$cmp_PartialOrd))); - rt.byteVecPush(out, _55 | (((rt.eqOption(Hop.eq$cmp_PartialEq)(_64, a) ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, rt.u64Eq(hashOf$Option_keys_Hop(a), hashOf$Option_keys_Hop(b)) ? 1 : 0); - const _77: [rt.u8 | undefined, rt.u8 | undefined] = [small(c), small(d)]; - const x: rt.u8 | undefined = _77[0]; - const y: rt.u8 | undefined = _77[1]; - const _82: [Side.Side | undefined, Side.Side | undefined] = [option_map$0gn4nwv(x, side), option_map$0gn4nwv(y, side)]; + rs.byteVecPush(out, (rs.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) | (((!rs.eqOption(Hop.eq$cmp_PartialEq)(a, b) ? 1 : 0) << 1) & 0xff) | ((order(rs.cmpOption(Hop.cmp$cmp_Ord)(a, b)) << 2) & 0xff)); + const _58: Hop.Hop | undefined = rs.ordMax(a, b, rs.cmpLt(rs.cmpOption(Hop.partialCmp$cmp_PartialOrd))); + const _55: rs.u8 = rs.eqOption(Hop.eq$cmp_PartialEq)(_58, b) ? 1 : 0; + const _64: Hop.Hop | undefined = rs.ordMin(a, b, rs.cmpLt(rs.cmpOption(Hop.partialCmp$cmp_PartialOrd))); + rs.byteVecPush(out, _55 | (((rs.eqOption(Hop.eq$cmp_PartialEq)(_64, a) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, rs.u64Eq(hashOf$Option_keys_Hop(a), hashOf$Option_keys_Hop(b)) ? 1 : 0); + const _77: [rs.u8 | undefined, rs.u8 | undefined] = [small(c), small(d)]; + const x: rs.u8 | undefined = _77[0]; + const y: rs.u8 | undefined = _77[1]; + const _82: [Side.Side | undefined, Side.Side | undefined] = [option_map$0bzc4vz(x, side), option_map$0bzc4vz(y, side)]; const s: Side.Side | undefined = _82[0]; const t: Side.Side | undefined = _82[1]; - const _87: rt.u8 = (x === y ? 1 : 0) | (((rt.eqOption(Side.eq$cmp_PartialEq)(s, t) ? 1 : 0) << 1) & 0xff); + const _87: rs.u8 = (x === y ? 1 : 0) | (((rs.eqOption(Side.eq$cmp_PartialEq)(s, t) ? 1 : 0) << 1) & 0xff); const _103: Side.Side | undefined = s; const _106: Side.Side | undefined = t; - rt.byteVecPush(out, _87 | (((!rt.eqOption(Side.eq$cmp_PartialEq)(_103, _106) ? 1 : 0) << 2) & 0xff)); - const pairs: [[rt.u64, rt.u64] | undefined, [rt.u64, rt.u64] | undefined] = [option_map$146awhd(a, (h2: Hop.Hop): [rt.u64, rt.u64] => { - return [h2._0, d as rt.u64] as [rt.u64, rt.u64]; - }), option_map$146awhd(b, (h3: Hop.Hop): [rt.u64, rt.u64] => { - return [h3._0, c as rt.u64] as [rt.u64, rt.u64]; + rs.byteVecPush(out, _87 | (((!rs.eqOption(Side.eq$cmp_PartialEq)(_103, _106) ? 1 : 0) << 2) & 0xff)); + const pairs: [[rs.u64, rs.u64] | undefined, [rs.u64, rs.u64] | undefined] = [option_map$1n6u2ar(a, (h2: Hop.Hop): [rs.u64, rs.u64] => { + return [h2._0, d as rs.u64] as [rs.u64, rs.u64]; + }), option_map$1n6u2ar(b, (h3: Hop.Hop): [rs.u64, rs.u64] => { + return [h3._0, c as rs.u64] as [rs.u64, rs.u64]; })]; - const _121: [rt.u64, rt.u64] | undefined = rt.ordMax(pairs[0], pairs[1], rt.cmpLt(rt.cmpOption(rt.cmpTuple<[rt.u64, rt.u64], rt.Ordering | undefined>([rt.cmp, rt.cmp])))); - rt.byteVecPush(out, rt.eqOption(rt.eqTuple([rt.u64Eq, rt.u64Eq]))(_121, pairs[1]) ? 1 : 0); - const _127: [Skew.Skew | undefined, Skew.Skew | undefined] = [{ _0: rt.u8Rem(c, 4) }, { _0: rt.u8Rem(d, 4) }]; + const _121: [rs.u64, rs.u64] | undefined = rs.ordMax(pairs[0], pairs[1], rs.cmpLt(rs.cmpOption(rs.cmpTuple<[rs.u64, rs.u64], rs.Ordering | undefined>([rs.cmp, rs.cmp])))); + rs.byteVecPush(out, rs.eqOption(rs.eqTuple([rs.u64Eq, rs.u64Eq]))(_121, pairs[1]) ? 1 : 0); + const _127: [Skew.Skew | undefined, Skew.Skew | undefined] = [{ _0: rs.u8Rem(c, 4) }, { _0: rs.u8Rem(d, 4) }]; const p: Skew.Skew | undefined = _127[0]; const q: Skew.Skew | undefined = _127[1]; - const _138: [[Skew.Skew, rt.u8], [Skew.Skew, rt.u8]] = [[{ _0: rt.u8Rem(c, 4) }, c] as [Skew.Skew, rt.u8], [{ _0: rt.u8Rem(d, 4) }, d] as [Skew.Skew, rt.u8]]; - const u: [Skew.Skew, rt.u8] = _138[0]; - const v: [Skew.Skew, rt.u8] = _138[1]; - const _149: [rt.Arc, rt.Arc] = [new rt.Arc({ _0: rt.u8Rem(c, 4) }), new rt.Arc({ _0: rt.u8Rem(d, 4) })]; - const m: rt.Arc = _149[0]; - const n: rt.Arc = _149[1]; - rt.byteVecPush(out, partial(rt.cmpOption(Skew.partialCmp$cmp_PartialOrd)(p, q)) | ((partial(rt.cmpTuple<[Skew.Skew, rt.u8], rt.Ordering | undefined>([Skew.partialCmp$cmp_PartialOrd, rt.cmp])(u, v)) << 2) & 0xff) | ((partial(rt.cmpArc(Skew.partialCmp$cmp_PartialOrd)(m, n)) << 4) & 0xff)); - rt.byteVecPush(out, order(rt.cmpOption(Skew.cmp$cmp_Ord)(p, q)) | ((order(rt.cmpTuple<[Skew.Skew, rt.u8], rt.Ordering>([Skew.cmp$cmp_Ord, rt.cmp])(u, v)) << 2) & 0xff) | ((order(rt.cmpArc(Skew.cmp$cmp_Ord)(m, n)) << 4) & 0xff)); - const _202: [Picky.Picky | undefined, Picky.Picky | undefined] = [{ _0: rt.u8Rem(c, 3) }, { _0: rt.u8Rem(d, 3) }]; + const _138: [[Skew.Skew, rs.u8], [Skew.Skew, rs.u8]] = [[{ _0: rs.u8Rem(c, 4) }, c] as [Skew.Skew, rs.u8], [{ _0: rs.u8Rem(d, 4) }, d] as [Skew.Skew, rs.u8]]; + const u: [Skew.Skew, rs.u8] = _138[0]; + const v: [Skew.Skew, rs.u8] = _138[1]; + const _149: [rs.Arc, rs.Arc] = [new rs.Arc({ _0: rs.u8Rem(c, 4) }), new rs.Arc({ _0: rs.u8Rem(d, 4) })]; + const m: rs.Arc = _149[0]; + const n: rs.Arc = _149[1]; + rs.byteVecPush(out, partial(rs.cmpOption(Skew.partialCmp$cmp_PartialOrd)(p, q)) | ((partial(rs.cmpTuple<[Skew.Skew, rs.u8], rs.Ordering | undefined>([Skew.partialCmp$cmp_PartialOrd, rs.cmp])(u, v)) << 2) & 0xff) | ((partial(rs.cmpArc(Skew.partialCmp$cmp_PartialOrd)(m, n)) << 4) & 0xff)); + rs.byteVecPush(out, order(rs.cmpOption(Skew.cmp$cmp_Ord)(p, q)) | ((order(rs.cmpTuple<[Skew.Skew, rs.u8], rs.Ordering>([Skew.cmp$cmp_Ord, rs.cmp])(u, v)) << 2) & 0xff) | ((order(rs.cmpArc(Skew.cmp$cmp_Ord)(m, n)) << 4) & 0xff)); + const _202: [Picky.Picky | undefined, Picky.Picky | undefined] = [{ _0: rs.u8Rem(c, 3) }, { _0: rs.u8Rem(d, 3) }]; const g: Picky.Picky | undefined = _202[0]; const h: Picky.Picky | undefined = _202[1]; - const _213: [[Picky.Picky | undefined, rt.u8], [Picky.Picky | undefined, rt.u8]] = [[{ _0: rt.u8Rem(c, 3) }, rt.u8Rem(c, 2)] as [Picky.Picky | undefined, rt.u8], [{ _0: rt.u8Rem(d, 3) }, rt.u8Rem(d, 2)] as [Picky.Picky | undefined, rt.u8]]; - const j: [Picky.Picky | undefined, rt.u8] = _213[0]; - const k: [Picky.Picky | undefined, rt.u8] = _213[1]; - const _230: [rt.Arc, rt.Arc] = [new rt.Arc({ _0: rt.u8Rem(c, 3) }), new rt.Arc({ _0: rt.u8Rem(d, 3) })]; - const r: rt.Arc = _230[0]; - const s2: rt.Arc = _230[1]; - rt.byteVecPush(out, (!rt.eqOption(Picky.eq$cmp_PartialEq)(g, h) ? 1 : 0) | (((!rt.eqTuple([rt.eqOption(Picky.eq$cmp_PartialEq), rt.same])(j, k) ? 1 : 0) << 1) & 0xff) | (((!rt.eqArc(rt.eqOption(Picky.eq$cmp_PartialEq))(r, s2) ? 1 : 0) << 2) & 0xff)); - const key: [rt.u8, Horizon.Horizon] = [rt.u8Rem(c, 3), { exclude: a, local: rt.u8Rem(d, 2) === 0 }]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(hashed, copy$tuple2_u8_keys_Horizon(key), i & 0xff), 204)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(sorted, copy$tuple2_u8_keys_Horizon(key), i & 0xff), 204)); + const _213: [[Picky.Picky | undefined, rs.u8], [Picky.Picky | undefined, rs.u8]] = [[{ _0: rs.u8Rem(c, 3) }, rs.u8Rem(c, 2)] as [Picky.Picky | undefined, rs.u8], [{ _0: rs.u8Rem(d, 3) }, rs.u8Rem(d, 2)] as [Picky.Picky | undefined, rs.u8]]; + const j: [Picky.Picky | undefined, rs.u8] = _213[0]; + const k: [Picky.Picky | undefined, rs.u8] = _213[1]; + const _230: [rs.Arc, rs.Arc] = [new rs.Arc({ _0: rs.u8Rem(c, 3) }), new rs.Arc({ _0: rs.u8Rem(d, 3) })]; + const r: rs.Arc = _230[0]; + const s2: rs.Arc = _230[1]; + rs.byteVecPush(out, (!rs.eqOption(Picky.eq$cmp_PartialEq)(g, h) ? 1 : 0) | (((!rs.eqTuple([rs.eqOption(Picky.eq$cmp_PartialEq), rs.same])(j, k) ? 1 : 0) << 1) & 0xff) | (((!rs.eqArc(rs.eqOption(Picky.eq$cmp_PartialEq))(r, s2) ? 1 : 0) << 2) & 0xff)); + const key: [rs.u8, Horizon.Horizon] = [rs.u8Rem(c, 3), { exclude: a, local: rs.u8Rem(d, 2) === 0 }]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(hashed, copy$tuple2_u8_keys_Horizon(key), i & 0xff), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(sorted, copy$tuple2_u8_keys_Horizon(key), i & 0xff), 204)); const _283: [Way.Way | undefined, boolean] = [way(c), c < 128]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(ways, _283, i & 0xff), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(ways, _283, i & 0xff), 204)); const _293: [Way.Way | undefined, boolean] = [way(d), d < 128]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(ways, _293), 221)); - rt.byteVecPush(out, rt.hashLen(ways) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(ways, _293), 221)); + rs.byteVecPush(out, rs.hashLen(ways) & 0xff); const _304: Way.Way | undefined = way(c); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(bare, _304, i & 0xff), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(bare, _304, i & 0xff), 204)); const _312: Way.Way | undefined = way(d); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(bare, _312), 221)); - const _319: Way.Way | undefined | rt.None = _313(c); - const _316: rt.u8 = rt.hashAdd(deep, _319) ? 1 : 0; - const _327: Way.Way | undefined | rt.None = _313(d); - rt.byteVecPush(out, _316 | (((rt.hashContains(deep, _327) ? 1 : 0) << 1) & 0xff)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(bare) & 0xff, rt.hashLen(deep) & 0xff)), undefined, true); - const _345: [rt.u8, Horizon.Horizon] = [rt.u8Rem(d, 3), { exclude: b, local: false }]; - rt.byteVecPush(out, rt.hashContains(hashed, _345) ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(bare, _312), 221)); + const _319: Way.Way | undefined | rs.None = _313(c); + const _316: rs.u8 = rs.hashAdd(deep, _319) ? 1 : 0; + const _327: Way.Way | undefined | rs.None = _313(d); + rs.byteVecPush(out, _316 | (((rs.hashContains(deep, _327) ? 1 : 0) << 1) & 0xff)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(bare) & 0xff, rs.hashLen(deep) & 0xff)), undefined, true); + const _345: [rs.u8, Horizon.Horizon] = [rs.u8Rem(d, 3), { exclude: b, local: false }]; + rs.byteVecPush(out, rs.hashContains(hashed, _345) ? 1 : 0); s2[Symbol.dispose](); r[Symbol.dispose](); n[Symbol.dispose](); m[Symbol.dispose](); } - const iter2: rt.Iter<[[rt.u8, Horizon.Horizon], rt.u8]> = rt.btreeIter(sorted); + const iter2: rs.Iter<[[rs.u8, Horizon.Horizon], rs.u8]> = rs.btreeIter(sorted); while (true) { - const _352: [[rt.u8, Horizon.Horizon], rt.u8] | rt.Done = iter2.next(); - if (_352 === rt.DONE) { + const _352: [[rs.u8, Horizon.Horizon], rs.u8] | rs.Done = iter2.next(); + if (_352 === rs.DONE) { break; } - rt.byteVecPush(out, _352[0][0]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_mapOr$04khdaj(_352[0][1].exclude, 0, (h4: Hop.Hop): rt.u64 => { + rs.byteVecPush(out, _352[0][0]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_mapOr$1afu7tt(_352[0][1].exclude, 0, (h4: Hop.Hop): rs.u64 => { return h4._0; })))); - rt.byteVecPush(out, (_352[0][1].exclude !== undefined ? 1 : 0) | (((_352[0][1].local ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, _352[1]); - rt.byteVecPush(out, rt.hashIndex(hashed, [_352[0][0], copy$keys_Horizon(_352[0][1])] as [rt.u8, Horizon.Horizon])); + rs.byteVecPush(out, (_352[0][1].exclude !== undefined ? 1 : 0) | (((_352[0][1].local ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, _352[1]); + rs.byteVecPush(out, rs.hashIndex(hashed, [_352[0][0], copy$keys_Horizon(_352[0][1])] as [rs.u8, Horizon.Horizon])); } } /** `Arc`s compared, ordered, and hashed as what they hold, and borrowed as it. */ -export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { - let _7!: rt.usize; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = data.length; +export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { + let _7!: rs.usize; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = data.length; while ((_7 = iterStart++) < iterEnd) { - const i: rt.usize = _7; - const _16: rt.usize = rt.usizeSub(i, 1); - rt.idx(data, _16); + const i: rs.usize = _7; + const _16: rs.usize = rs.usizeSub(i, 1); + rs.idx(data, _16); const _14: Name.Name = name(data.data[data.start + _16]); - rt.idx(data, i); + rs.idx(data, i); const _13: [Name.Name, Name.Name] = [_14, name(data.data[data.start + i])]; const a: Name.Name = _14; const b: Name.Name = _13[1]; - rt.byteVecPush(out, order(rt.cmpArc(rt.cmpStr)(a.text, b.text)) | ((order(Name.cmp$cmp_Ord(a, b)) << 2) & 0xff)); - const _40: rt.Arc = rt.ordMax(a.text, b.text, rt.cmpLt(rt.cmpArc(rt.cmpStr))); - const _43: rt.Arc = rt.ordMin(a.text, b.text, rt.cmpLt(rt.cmpArc(rt.cmpStr))); - rt.byteVecPush(out, (_40 === b.text ? 1 : 0) | (((_43 === a.text ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, (rt.eqArc(rt.same, true)(a.text, b.text) ? 1 : 0) | (((Name.eq$cmp_PartialEq(a, b) ? 1 : 0) << 1) & 0xff) | (((rt.eqArc(rt.same, true)(_40, b.text) ? 1 : 0) << 2) & 0xff)); - rt.byteVecPush(out, (rt.u64Eq(hashOf$sync_Arc_str(a.text), hashOf$sync_Arc_str(b.text)) ? 1 : 0) | (((rt.u64Eq(hashOf$keys_Name(a), hashOf$keys_Name(b)) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, order(rs.cmpArc(rs.cmpStr)(a.text, b.text)) | ((order(Name.cmp$cmp_Ord(a, b)) << 2) & 0xff)); + const _40: rs.Arc = rs.ordMax(a.text, b.text, rs.cmpLt(rs.cmpArc(rs.cmpStr))); + const _43: rs.Arc = rs.ordMin(a.text, b.text, rs.cmpLt(rs.cmpArc(rs.cmpStr))); + rs.byteVecPush(out, (_40 === b.text ? 1 : 0) | (((_43 === a.text ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.eqArc(rs.same, true)(a.text, b.text) ? 1 : 0) | (((Name.eq$cmp_PartialEq(a, b) ? 1 : 0) << 1) & 0xff) | (((rs.eqArc(rs.same, true)(_40, b.text) ? 1 : 0) << 2) & 0xff)); + rs.byteVecPush(out, (rs.u64Eq(hashOf$sync_Arc_str(a.text), hashOf$sync_Arc_str(b.text)) ? 1 : 0) | (((rs.u64Eq(hashOf$keys_Name(a), hashOf$keys_Name(b)) ? 1 : 0) << 1) & 0xff)); const text: string = a.text.value; - rt.byteVecPush(out, text === b.text.value ? 1 : 0); - rt.idx(data, i); - const _106: rt.usize = rt.usizeRem(data.data[data.start + i] as rt.usize, ["", "a", "ab", "", "￿", "𐀀"].length); + rs.byteVecPush(out, text === b.text.value ? 1 : 0); + rs.idx(data, i); + const _106: rs.usize = rs.usizeRem(data.data[data.start + i] as rs.usize, ["", "a", "ab", "", "￿", "𐀀"].length); if (!(_106 < 6)) { - rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _106); } const _105: string[] = ["", "a", "ab", "", "￿", "𐀀"]; - rt.byteVecPush(out, find$String_str([text, _105[_106]], _105[_106])); - const _127: rt.Arc[] = [a.text, b.text]; - rt.byteVecPush(out, find$sync_Arc_str_str(_127, _105[_106])); - rt.dropAll(_127); + rs.byteVecPush(out, find$String_str([text, _105[_106]], _105[_106])); + const _127: rs.Arc[] = [a.text, b.text]; + rs.byteVecPush(out, find$sync_Arc_str_str(_127, _105[_106])); + rs.dropAll(_127); } - const _130: rt.u8 | undefined = rt.byteSliceFirst(data); + const _130: rs.u8 | undefined = rs.byteSliceFirst(data); if (_130 !== undefined) { - rt.byteVecPush(out, find$u8_u8(data, _130)); - } - const liar: rt.Arc = new rt.Arc({}); - const never: rt.Arc = new rt.Arc({}); - const _145: rt.Arc = rt.arcClone(liar); - const _141: rt.u8 = rt.eqArc(Liar.eq$cmp_PartialEq, true)(liar, _145) ? 1 : 0; - const _152: rt.Arc = rt.arcClone(never); - const _140: rt.u8 = _141 | (((rt.eqArc(Never.eq$cmp_PartialEq)(never, _152) ? 1 : 0) << 1) & 0xff); - const _161: rt.Arc = new rt.Arc({}); - rt.byteVecPush(out, _140 | (((rt.eqArc(Liar.eq$cmp_PartialEq, true)(liar, _161) ? 1 : 0) << 2) & 0xff)); + rs.byteVecPush(out, find$u8_u8(data, _130)); + } + const liar: rs.Arc = new rs.Arc({}); + const never: rs.Arc = new rs.Arc({}); + const _145: rs.Arc = rs.arcClone(liar); + const _141: rs.u8 = rs.eqArc(Liar.eq$cmp_PartialEq, true)(liar, _145) ? 1 : 0; + const _152: rs.Arc = rs.arcClone(never); + const _140: rs.u8 = _141 | (((rs.eqArc(Never.eq$cmp_PartialEq)(never, _152) ? 1 : 0) << 1) & 0xff); + const _161: rs.Arc = new rs.Arc({}); + rs.byteVecPush(out, _140 | (((rs.eqArc(Liar.eq$cmp_PartialEq, true)(liar, _161) ? 1 : 0) << 2) & 0xff)); _161[Symbol.dispose](); _152[Symbol.dispose](); _145[Symbol.dispose](); @@ -705,175 +705,175 @@ export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { * give: numbers, a wide number, and a tuple, by keys JS compares and by keys found * through their hash. */ -export function places(data: rt.ByteSlice, out: rt.ByteVec): void { - let _154!: rt.usize; - let _257!: rt.u8; - const counts: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const wide: rt.HashMap = rt.hashNew() as rt.HashMap; - const hops: rt.HashMap = rt.hashNew(rt.hashing(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined, Hop.eq$cmp_PartialEq)) as rt.HashMap; - const pairs: rt.BTreeMap = rt.btreeNew(Hop.cmp$cmp_Ord) as rt.BTreeMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function places(data: rs.ByteSlice, out: rs.ByteVec): void { + let _154!: rs.usize; + let _257!: rs.u8; + const counts: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const wide: rs.HashMap = rs.hashNew() as rs.HashMap; + const hops: rs.HashMap = rs.hashNew(rs.hashing(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined, Hop.eq$cmp_PartialEq)) as rs.HashMap; + const pairs: rs.BTreeMap = rs.btreeNew(Hop.cmp$cmp_Ord) as rs.BTreeMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _11: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - const i: rt.usize = _11[0]; - const b: rt.u8 = _11[1]; - const k: rt.u8 = rt.u8Rem(b, 97); - const _18: rt.u8 = rt.u8Rem(b, 6); + const i: rs.usize = _11[0]; + const b: rs.u8 = _11[1]; + const k: rs.u8 = rs.u8Rem(b, 97); + const _18: rs.u8 = rs.u8Rem(b, 6); if (_18 === 0) { - const _20: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, k), (): rt.usize => { + const _20: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, k), (): rs.usize => { return 0; }); - _20.v = rt.usizeAdd(_20.v, 1); + _20.v = rs.usizeAdd(_20.v, 1); } else if (_18 === 1) { - const _24: rt.Place | undefined = rt.btreeGetMut(counts, k); + const _24: rs.Place | undefined = rs.btreeGetMut(counts, k); if (_24 !== undefined) { - _24.v = rt.usizeSub(_24.v, 1); + _24.v = rs.usizeSub(_24.v, 1); if (_24.v === 0) { - rt.btreeRemove(counts, k); + rs.btreeRemove(counts, k); } } } else if (_18 === 2) { - const _35: rt.Entry = rt.entry(counts, k); - if (!rt.entryOccupied(_35)) { - const _50: rt.Place = rt.entryOrInsertMut(_35, i); - _50.v = rt.usizeAdd(_50.v, 2); - } else if (!(rt.entryGet(_35) > 1)) { - const _47: rt.Place = rt.entryGetMut(_35); - _47.v = rt.usizeAdd(_47.v, 7); + const _35: rs.Entry = rs.entry(counts, k); + if (!rs.entryOccupied(_35)) { + const _50: rs.Place = rs.entryOrInsertMut(_35, i); + _50.v = rs.usizeAdd(_50.v, 2); + } else if (!(rs.entryGet(_35) > 1)) { + const _47: rs.Place = rs.entryGetMut(_35); + _47.v = rs.usizeAdd(_47.v, 7); } else { - const _43: rt.Place = rt.entryGetMut(_35); - _43.v = rt.usizeMul(_43.v, 3); + const _43: rs.Place = rs.entryGetMut(_35); + _43.v = rs.usizeMul(_43.v, 3); } } else if (_18 === 3) { - const c: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, k), (): rt.usize => { - return rt.usizeMul(i, 2); + const c: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, k), (): rs.usize => { + return rs.usizeMul(i, 2); }); c.v = (c.v ^ 5) >>> 0; - rt.byteVecPush(out, c.v & 0xff); + rs.byteVecPush(out, c.v & 0xff); } else if (_18 === 4) { - if (!rt.btreeContains(counts, k)) { - const _69: rt.Place = rt.entryOrInsertMut(rt.entry(counts, k), 9); + if (!rs.btreeContains(counts, k)) { + const _69: rs.Place = rs.entryOrInsertMut(rs.entry(counts, k), 9); _69.v = (_69.v << 1) >>> 0; } else { - const _63: rt.Place = rt.optionExpect(rt.btreeGetMut(counts, k), "a counted key"); - _63.v = rt.usizeAdd(_63.v, 4); + const _63: rs.Place = rs.optionExpect(rs.btreeGetMut(counts, k), "a counted key"); + _63.v = rs.usizeAdd(_63.v, 4); } } else { - const _74: rt.Place = rt.optionUnwrap(rt.btreeGetMut(counts, k)); - _74.v = rt.usizeAdd(_74.v, 1); + const _74: rs.Place = rs.optionUnwrap(rs.btreeGetMut(counts, k)); + _74.v = rs.usizeAdd(_74.v, 1); } - const w: rt.Place = rt.entryOrInsertMut(rt.entry(wide, rt.u8Rem(b, 7)), 4503599627370496); - w.v = rt.u64WrappingAdd(rt.u64WrappingAdd(w.v, rt.u64Shr(w.v, 1)), b as rt.u64); - const _98: Hop.Hop = { _0: rt.u64Rem(b as rt.u64, 6) }; - const h: rt.Place = rt.entryOrInsertWithMut(rt.entry(hops, _98), (): rt.u16 => { + const w: rs.Place = rs.entryOrInsertMut(rs.entry(wide, rs.u8Rem(b, 7)), 4503599627370496); + w.v = rs.u64WrappingAdd(rs.u64WrappingAdd(w.v, rs.u64Shr(w.v, 1)), b as rs.u64); + const _98: Hop.Hop = { _0: rs.u64Rem(b as rs.u64, 6) }; + const h: rs.Place = rs.entryOrInsertWithMut(rs.entry(hops, _98), (): rs.u16 => { return 0; }); - h.v = rt.u16WrappingAdd(h.v, b as rt.u16); - const _108: Hop.Hop = { _0: rt.u64Rem(b as rt.u64, 4) }; - const _105: rt.Place | undefined = rt.hashGetMut(hops, _108); + h.v = rs.u16WrappingAdd(h.v, b as rs.u16); + const _108: Hop.Hop = { _0: rs.u64Rem(b as rs.u64, 4) }; + const _105: rs.Place | undefined = rs.hashGetMut(hops, _108); if (_105 !== undefined) { _105.v = _105.v ^ 23130; } - const _116: Hop.Hop = { _0: rt.u64Rem(b as rt.u64, 5) }; - const _114: rt.Entry = rt.entry(hops, _116); - if (rt.entryOccupied(_114)) { - if (!(rt.entryGet(_114) > 4096)) { - const _130: rt.Place = rt.entryGetMut(_114); + const _116: Hop.Hop = { _0: rs.u64Rem(b as rs.u64, 5) }; + const _114: rs.Entry = rs.entry(hops, _116); + if (rs.entryOccupied(_114)) { + if (!(rs.entryGet(_114) > 4096)) { + const _130: rs.Place = rs.entryGetMut(_114); _130.v = _130.v | 1; } else { - const _126: rt.Place = rt.entryGetMut(_114); - _126.v = rt.u16Sub(_126.v, 4096); + const _126: rs.Place = rs.entryGetMut(_114); + _126.v = rs.u16Sub(_126.v, 4096); } } else { - const _132: rt.Place = rt.entryOrInsertMut(_114, b as rt.u16); + const _132: rs.Place = rs.entryOrInsertMut(_114, b as rs.u16); _132.v = (_132.v << 4) & 0xffff; } - const _139: Hop.Hop = { _0: rt.u64Rem(b as rt.u64, 3) }; - const p: [rt.u8, rt.u8] = rt.entryOrInsert(rt.entry(pairs, _139), [0, 0] as [rt.u8, rt.u8]); - p[0] = rt.u8WrappingAdd(p[0], b); + const _139: Hop.Hop = { _0: rs.u64Rem(b as rs.u64, 3) }; + const p: [rs.u8, rs.u8] = rs.entryOrInsert(rs.entry(pairs, _139), [0, 0] as [rs.u8, rs.u8]); + p[0] = rs.u8WrappingAdd(p[0], b); p[1] = p[1] ^ p[0]; } - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _150: rt.usize = rt.usizeMul(data.length, 4); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _150; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _150: rs.usize = rs.usizeMul(data.length, 4); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _150; while ((_154 = iterStart++) < iterEnd) { - const j: rt.usize = _154; - const _159: rt.usize = rt.usizeRem(j, data.length); - rt.idx(data, _159); - const b2: rt.u8 = data.data[data.start + _159]; - const v: rt.Place = rt.entryOrInsertMut(rt.entry(tree, rt.u16Mul(j & 0xffff, 37) ^ b2 as rt.u16), j & 0xffff); - v.v = rt.u16WrappingAdd(v.v, b2 as rt.u16); - } - const iter3: rt.Iter<[rt.u16, rt.u16]> = rt.btreeIter(tree); + const j: rs.usize = _154; + const _159: rs.usize = rs.usizeRem(j, data.length); + rs.idx(data, _159); + const b2: rs.u8 = data.data[data.start + _159]; + const v: rs.Place = rs.entryOrInsertMut(rs.entry(tree, rs.u16Mul(j & 0xffff, 37) ^ b2 as rs.u16), j & 0xffff); + v.v = rs.u16WrappingAdd(v.v, b2 as rs.u16); + } + const iter3: rs.Iter<[rs.u16, rs.u16]> = rs.btreeIter(tree); while (true) { - const _179: [rt.u16, rt.u16] | rt.Done = iter3.next(); - if (_179 === rt.DONE) { + const _179: [rs.u16, rs.u16] | rs.Done = iter3.next(); + if (_179 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[0]))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_179[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_179[0]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_179[1]))); } - const touchy: rt.BTreeMap = rt.btreeNew(Touchy.cmp$cmp_Ord) as rt.BTreeMap; - const _195: rt.Place = rt.entryOrInsertWithMut(rt.entry(touchy, { _0: data.length & 0xff }), (): rt.u8 => { + const touchy: rs.BTreeMap = rs.btreeNew(Touchy.cmp$cmp_Ord) as rs.BTreeMap; + const _195: rs.Place = rs.entryOrInsertWithMut(rs.entry(touchy, { _0: data.length & 0xff }), (): rs.u8 => { return 7; }); - _195.v = rt.u8Add(_195.v, 1); - const hashy: rt.HashMap = rt.hashNew(rt.hashing(Touchy.hash$Hash_hash_DefaultHasher as (a0: Touchy.Touchy, a1: rt.Hasher) => undefined, Touchy.eq$cmp_PartialEq)) as rt.HashMap; - const _203: rt.Place = rt.entryOrInsertWithMut(rt.entry(hashy, { _0: data.length & 0xff }), (): rt.u8 => { + _195.v = rs.u8Add(_195.v, 1); + const hashy: rs.HashMap = rs.hashNew(rs.hashing(Touchy.hash$Hash_hash_DefaultHasher as (a0: Touchy.Touchy, a1: rs.Hasher) => undefined, Touchy.eq$cmp_PartialEq)) as rs.HashMap; + const _203: rs.Place = rs.entryOrInsertWithMut(rs.entry(hashy, { _0: data.length & 0xff }), (): rs.u8 => { return 0; }); - _203.v = rt.u8Add(_203.v, 2); - rt.iterExtendBytes(out, rt.iterChain(rt.btreeValues(touchy), rt.hashValues(hashy)), "next"); - const c2: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, 0), (): rt.usize => { + _203.v = rs.u8Add(_203.v, 2); + rs.iterExtendBytes(out, rs.iterChain(rs.btreeValues(touchy), rs.hashValues(hashy)), "next"); + const c2: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, 0), (): rs.usize => { return 0; }); ((): undefined => { - c2.v = rt.usizeAdd(c2.v, 1); + c2.v = rs.usizeAdd(c2.v, 1); })(); - const spare: rt.usize[] = [data.length, 8]; - const c3: rt.Place = rt.entryOrInsertMut(rt.entry(counts, 1), 3); + const spare: rs.usize[] = [data.length, 8]; + const c3: rs.Place = rs.entryOrInsertMut(rs.entry(counts, 1), 3); const swapped = c3.v; c3.v = spare[0]; spare[0] = swapped; - const d: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, 2), (): rt.usize => { + const d: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, 2), (): rs.usize => { return 0; }); - d.v = rt.usizeAdd(d.v, spare[0]); - const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(counts); + d.v = rs.usizeAdd(d.v, spare[0]); + const iter4: rs.Iter<[rs.u8, rs.usize]> = rs.btreeIter(counts); while (true) { - const _241: [rt.u8, rt.usize] | rt.Done = iter4.next(); - if (_241 === rt.DONE) { + const _241: [rs.u8, rs.usize] | rs.Done = iter4.next(); + if (_241 === rs.DONE) { break; } - rt.byteVecPush(out, _241[0]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_241[1] as rt.u32))); + rs.byteVecPush(out, _241[0]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_241[1] as rs.u32))); } - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 7; + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 7; while ((_257 = iterStart2++) < iterEnd2) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_unwrapOr$1tvry1i(rt.hashGet(wide, _257), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_unwrapOr$15hbiwd(rs.hashGet(wide, _257), 0)))); } - const iter6: rt.Range = new rt.Range(0, 6, rt.u64Step); + const iter6: rs.Range = new rs.Range(0, 6, rs.u64Step); while (true) { - const _273: rt.u64 | rt.Done = iter6.next(); - if (_273 === rt.DONE) { + const _273: rs.u64 | rs.Done = iter6.next(); + if (_273 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(rt.hashGet(hops, { _0: _273 }), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(rs.hashGet(hops, { _0: _273 }), 0)))); } - const iter7: rt.Iter<[Hop.Hop, [rt.u8, rt.u8]]> = rt.btreeIter(pairs); + const iter7: rs.Iter<[Hop.Hop, [rs.u8, rs.u8]]> = rs.btreeIter(pairs); while (true) { - const _290: [Hop.Hop, [rt.u8, rt.u8]] | rt.Done = iter7.next(); - if (_290 === rt.DONE) { + const _290: [Hop.Hop, [rs.u8, rs.u8]] | rs.Done = iter7.next(); + if (_290 === rs.DONE) { break; } - rt.byteVecPush(out, rt.u64Low(_290[0]._0) & 0xff); - rt.byteVecPush(out, _290[1][0]); - rt.byteVecPush(out, _290[1][1]); + rs.byteVecPush(out, rs.u64Low(_290[0]._0) & 0xff); + rs.byteVecPush(out, _290[1][0]); + rs.byteVecPush(out, _290[1][1]); } } @@ -882,191 +882,191 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { * another form holding the same bytes, alone or in a tuple, an `Option`, or an `Arc`, * and a key found by a `&[u8]` it borrows as, in hash and B-tree collections alike. */ -export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const cut: rt.usize = rt.min(data.length, 6); - const iter: rt.Iter = rt.byteSliceWindows(data, 2); +export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const cut: rs.usize = rs.min(data.length, 6); + const iter: rs.Iter = rs.byteSliceWindows(data, 2); while (true) { - const _9: rt.ByteSlice | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.ByteSlice | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - rt.idx(_9, 0); - const _17: rt.u8 = rt.u8Rem(_9.data[_9.start], 3); - rt.idx(_9, 1); - const _16: Uint8Array = Uint8Array.of(_17, rt.u8Rem(_9.data[_9.start + 1], 3)); - rt.idx(_9, 1); - const _30: rt.u8 = rt.u8Rem(_9.data[_9.start + 1], 3); - rt.idx(_9, 0); - const _15: [Uint8Array, Uint8Array] = [_16, Uint8Array.of(_30, rt.u8Rem(_9.data[_9.start], 3))]; + rs.idx(_9, 0); + const _17: rs.u8 = rs.u8Rem(_9.data[_9.start], 3); + rs.idx(_9, 1); + const _16: Uint8Array = Uint8Array.of(_17, rs.u8Rem(_9.data[_9.start + 1], 3)); + rs.idx(_9, 1); + const _30: rs.u8 = rs.u8Rem(_9.data[_9.start + 1], 3); + rs.idx(_9, 0); + const _15: [Uint8Array, Uint8Array] = [_16, Uint8Array.of(_30, rs.u8Rem(_9.data[_9.start], 3))]; const a: Uint8Array = _16; const b: Uint8Array = _15[1]; - const _44: rt.u8 = rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; - const _48: rt.u8 = !rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; - const _52: rt.u8 = rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0; + const _44: rs.u8 = rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) ? 1 : 0; + const _48: rs.u8 = !rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) ? 1 : 0; + const _52: rs.u8 = rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) ? 1 : 0; const _61: Uint8Array | undefined = a; const _63: Uint8Array | undefined = b; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_44, _48, _52, rt.eqOption(rt.eqBytes)(_61, _63) ? 1 : 0)), undefined, true); - rt.idx(_9, 0); - const _69: [Uint8Array, rt.u8] = [a, _9.data[_9.start]]; - rt.idx(_9, 1); - const _75: [Uint8Array, rt.u8] = [b, _9.data[_9.start + 1]]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.eqTuple([rt.eqBytes, rt.same])(_69, _75) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceEq(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0, rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceFrom(a)) ? 1 : 0, rt.eqBytes(rt.byteSliceRange(rt.byteSliceFrom(a), 0), rt.byteSliceToByteVec(rt.byteSliceFrom(b))) ? 1 : 0)), undefined, true); - const _117: rt.u8 = rt.eqBytes(rt.byteSliceToByteVec(rt.byteSliceFrom(a)), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0; - const _127: rt.u8 = rt.eqBytes(rt.byteSliceFrom(a), rt.byteSliceRange(rt.byteSliceFrom(b), 0)) ? 1 : 0; - const _135: rt.Arc = new rt.Arc(copy$array_u8(a)); - const _137: rt.Arc = new rt.Arc(copy$array_u8(b)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_117, _127, rt.eqArc(rt.eqBytes, true)(_135, _137) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_44, _48, _52, rs.eqOption(rs.eqBytes)(_61, _63) ? 1 : 0)), undefined, true); + rs.idx(_9, 0); + const _69: [Uint8Array, rs.u8] = [a, _9.data[_9.start]]; + rs.idx(_9, 1); + const _75: [Uint8Array, rs.u8] = [b, _9.data[_9.start + 1]]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.eqTuple([rs.eqBytes, rs.same])(_69, _75) ? 1 : 0, rs.eqBytes(rs.byteSliceToByteVec(rs.byteSliceFrom(a)), rs.byteSliceToByteVec(rs.byteSliceFrom(b))) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.byteSliceEq(rs.byteSliceRange(rs.byteSliceFrom(a), 0), rs.byteSliceRange(rs.byteSliceFrom(b), 0)) ? 1 : 0, rs.eqBytes(rs.byteSliceToByteVec(rs.byteSliceFrom(a)), rs.byteSliceFrom(a)) ? 1 : 0, rs.eqBytes(rs.byteSliceRange(rs.byteSliceFrom(a), 0), rs.byteSliceToByteVec(rs.byteSliceFrom(b))) ? 1 : 0)), undefined, true); + const _117: rs.u8 = rs.eqBytes(rs.byteSliceToByteVec(rs.byteSliceFrom(a)), rs.byteSliceRange(rs.byteSliceFrom(b), 0)) ? 1 : 0; + const _127: rs.u8 = rs.eqBytes(rs.byteSliceFrom(a), rs.byteSliceRange(rs.byteSliceFrom(b), 0)) ? 1 : 0; + const _135: rs.Arc = new rs.Arc(copy$array_u8(a)); + const _137: rs.Arc = new rs.Arc(copy$array_u8(b)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_117, _127, rs.eqArc(rs.eqBytes, true)(_135, _137) ? 1 : 0)), undefined, true); _137[Symbol.dispose](); _135[Symbol.dispose](); } - const arrays: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const vecs: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const slices: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const nested: rt.HashMap<[Uint8Array | undefined, rt.ByteVec], rt.usize> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hashOption(rt.hashBytes), rt.hashBytes]), rt.eqTuple([rt.eqOption(rt.eqBytes), rt.eqBytes]))) as rt.HashMap<[Uint8Array | undefined, rt.ByteVec], rt.usize>; - const shared: rt.HashMap, rt.usize> = rt.hashNew(rt.hashing(rt.hashArc(rt.hashBytes), rt.eqArc(rt.eqBytes, true))) as rt.HashMap, rt.usize>; - const arcs: rt.HashMap, rt.usize> = rt.hashNew(rt.hashing(rt.hashArc(rt.hashBytes), rt.eqArc(rt.eqBytes, true))) as rt.HashMap, rt.usize>; - const boxed: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const _151: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.byteSliceWindows(data, 2), (w: rt.ByteSlice): Uint8Array => { - rt.idx(w, 0); - const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); - rt.idx(w, 1); - return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); - }), undefined, 2, true).items), rt.byteSliceFrom); - const borrowed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _151, undefined, undefined, 234881024); - const iter2: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); + const arrays: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const vecs: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const slices: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const nested: rs.HashMap<[Uint8Array | undefined, rs.ByteVec], rs.usize> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hashOption(rs.hashBytes), rs.hashBytes]), rs.eqTuple([rs.eqOption(rs.eqBytes), rs.eqBytes]))) as rs.HashMap<[Uint8Array | undefined, rs.ByteVec], rs.usize>; + const shared: rs.HashMap, rs.usize> = rs.hashNew(rs.hashing(rs.hashArc(rs.hashBytes), rs.eqArc(rs.eqBytes, true))) as rs.HashMap, rs.usize>; + const arcs: rs.HashMap, rs.usize> = rs.hashNew(rs.hashing(rs.hashArc(rs.hashBytes), rs.eqArc(rs.eqBytes, true))) as rs.HashMap, rs.usize>; + const boxed: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; + const _151: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), (w: rs.ByteSlice): Uint8Array => { + rs.idx(w, 0); + const _3: rs.u8 = rs.u8Rem(w.data[w.start], 4); + rs.idx(w, 1); + return Uint8Array.of(_3, rs.u8Rem(w.data[w.start + 1], 4)); + }), undefined, 2, true).items), rs.byteSliceFrom); + const borrowed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _151, undefined, undefined, 234881024); + const iter2: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceWindows(data, 2)); while (true) { - const _158: [rt.usize, rt.ByteSlice] | rt.Done = iter2.next(); - if (_158 === rt.DONE) { + const _158: [rs.usize, rs.ByteSlice] | rs.Done = iter2.next(); + if (_158 === rs.DONE) { break; } - const i: rt.usize = _158[0]; - rt.idx(_158[1], 0); - const _164: rt.u8 = rt.u8Rem(_158[1].data[_158[1].start], 4); - rt.idx(_158[1], 1); - const key: Uint8Array = Uint8Array.of(_164, rt.u8Rem(_158[1].data[_158[1].start + 1], 4)); - const s: rt.ByteSlice = rt.byteSliceRange(data, i, rt.min(rt.usizeAdd(i, rt.usizeRem(kind as rt.usize, 3)), data.length)); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(arrays, copy$array_u8(key), i), 204, (old: rt.usize): rt.u8 => { + const i: rs.usize = _158[0]; + rs.idx(_158[1], 0); + const _164: rs.u8 = rs.u8Rem(_158[1].data[_158[1].start], 4); + rs.idx(_158[1], 1); + const key: Uint8Array = Uint8Array.of(_164, rs.u8Rem(_158[1].data[_158[1].start + 1], 4)); + const s: rs.ByteSlice = rs.byteSliceRange(data, i, rs.min(rs.usizeAdd(i, rs.usizeRem(kind as rs.usize, 3)), data.length)); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(arrays, copy$array_u8(key), i), 204, (old: rs.usize): rs.u8 => { return old & 0xff; })); - const _193: rt.ByteVec = rt.byteSliceToByteVec(s); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(vecs, _193, i), 204, (old2: rt.usize): rt.u8 => { + const _193: rs.ByteVec = rs.byteSliceToByteVec(s); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(vecs, _193, i), 204, (old2: rs.usize): rs.u8 => { return old2 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(slices, s, i), 204, (old3: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(slices, s, i), 204, (old3: rs.usize): rs.u8 => { return old3 & 0xff; })); - rt.idx(_158[1], 0); - const opt: Uint8Array | undefined = thenSome$0rsp0eu(rt.u8Rem(_158[1].data[_158[1].start], 3) !== 0, key); - const _211: rt.ByteVec = rt.byteSliceToByteVec(s); - const _210: [Uint8Array | undefined, rt.ByteVec] = [copy$Option_array2_u8(opt), _211]; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(nested, _210, i), 204, (old4: rt.usize): rt.u8 => { + rs.idx(_158[1], 0); + const opt: Uint8Array | undefined = thenSome$0rsp0eu(rs.u8Rem(_158[1].data[_158[1].start], 3) !== 0, key); + const _211: rs.ByteVec = rs.byteSliceToByteVec(s); + const _210: [Uint8Array | undefined, rs.ByteVec] = [copy$Option_array2_u8(opt), _211]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(nested, _210, i), 204, (old4: rs.usize): rs.u8 => { return old4 & 0xff; })); - const _216: rt.Arc = new rt.Arc(rt.byteSliceToByteVec(s)); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(shared, _216, i, rt.drop), 204, (old5: rt.usize): rt.u8 => { + const _216: rs.Arc = new rs.Arc(rs.byteSliceToByteVec(s)); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(shared, _216, i, rs.drop), 204, (old5: rs.usize): rs.u8 => { return old5 & 0xff; })); - const _222: rt.Arc = new rt.Arc(copy$array_u8(key)); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(arcs, _222, i, rt.drop), 204, (old6: rt.usize): rt.u8 => { + const _222: rs.Arc = new rs.Arc(copy$array_u8(key)); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(arcs, _222, i, rs.drop), 204, (old6: rs.usize): rs.u8 => { return old6 & 0xff; })); const _227: Uint8Array = copy$array_u8(key); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashInsert(boxed, _227, i), 204, (old7: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashInsert(boxed, _227, i), 204, (old7: rs.usize): rs.u8 => { return old7 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.btreeInsert(tree, copy$array_u8(key), i), 204, (old8: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.btreeInsert(tree, copy$array_u8(key), i), 204, (old8: rs.usize): rs.u8 => { return old8 & 0xff; })); - const _236: rt.ByteVec = rt.byteSliceToByteVec(s); - rt.byteVecPush(out, rt.btreeAdd(ordered, _236) ? 1 : 0); + const _236: rs.ByteVec = rs.byteSliceToByteVec(s); + rs.byteVecPush(out, rs.btreeAdd(ordered, _236) ? 1 : 0); } - const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, cut, rt.usizeStep); + const iter3: rs.RangeInclusive = new rs.RangeInclusive(0, cut, rs.usizeStep); l5: while (true) { - const _240: rt.usize | rt.Done = iter3.next(); - if (_240 === rt.DONE) { + const _240: rs.usize | rs.Done = iter3.next(); + if (_240 === rs.DONE) { break; } - const i2: rt.usize = _240; - const iter4: rt.RangeInclusive = new rt.RangeInclusive(i2, cut, rt.usizeStep); + const i2: rs.usize = _240; + const iter4: rs.RangeInclusive = new rs.RangeInclusive(i2, cut, rs.usizeStep); while (true) { - const _247: rt.usize | rt.Done = iter4.next(); - if (_247 === rt.DONE) { + const _247: rs.usize | rs.Done = iter4.next(); + if (_247 === rs.DONE) { continue l5; } - const j: rt.usize = _247; - const s2: rt.ByteSlice = rt.byteSliceRange(data, i2, j); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(vecs, s2), 221, (v: rt.usize): rt.u8 => { + const j: rs.usize = _247; + const s2: rs.ByteSlice = rs.byteSliceRange(data, i2, j); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(vecs, s2), 221, (v: rs.usize): rs.u8 => { return v & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(slices, s2), 221, (v2: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(slices, s2), 221, (v2: rs.usize): rs.u8 => { return v2 & 0xff; })); - const _266: rt.ByteVec = rt.byteSliceToByteVec(s2); - rt.byteVecPush(out, rt.hashContains(vecs, _266) ? 1 : 0); - const _272: rt.Arc = new rt.Arc(rt.byteSliceToByteVec(s2)); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(shared, _272), 221, (v3: rt.usize): rt.u8 => { + const _266: rs.ByteVec = rs.byteSliceToByteVec(s2); + rs.byteVecPush(out, rs.hashContains(vecs, _266) ? 1 : 0); + const _272: rs.Arc = new rs.Arc(rs.byteSliceToByteVec(s2)); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(shared, _272), 221, (v3: rs.usize): rs.u8 => { return v3 & 0xff; })); _272[Symbol.dispose](); - const key2: Uint8Array = Uint8Array.of(option_mapOr$1surhce(rt.byteSliceGet(data, i2), 0, (b2: rt.u8): rt.u8 => { - return rt.u8Rem(b2, 4); - }), option_mapOr$1surhce(rt.byteSliceGet(data, j), 0, (b3: rt.u8): rt.u8 => { - return rt.u8Rem(b3, 4); + const key2: Uint8Array = Uint8Array.of(option_mapOr$0vxw5sq(rs.byteSliceGet(data, i2), 0, (b2: rs.u8): rs.u8 => { + return rs.u8Rem(b2, 4); + }), option_mapOr$0vxw5sq(rs.byteSliceGet(data, j), 0, (b3: rs.u8): rs.u8 => { + return rs.u8Rem(b3, 4); })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(arrays, rt.byteSliceView(rt.byteSliceFrom(key2))), 221, (v4: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(arrays, rs.byteSliceView(rs.byteSliceFrom(key2))), 221, (v4: rs.usize): rs.u8 => { return v4 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(arcs, new rt.Arc(rt.byteSliceView(rt.byteSliceFrom(key2)))), 221, (v5: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(arcs, new rs.Arc(rs.byteSliceView(rs.byteSliceFrom(key2)))), 221, (v5: rs.usize): rs.u8 => { return v5 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(boxed, rt.byteSliceView(rt.byteSliceFrom(key2))), 221, (v6: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(boxed, rs.byteSliceView(rs.byteSliceFrom(key2))), 221, (v6: rs.usize): rs.u8 => { return v6 & 0xff; })); const _299: Uint8Array = copy$array_u8(key2); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(boxed, _299), 221, (v7: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(boxed, _299), 221, (v7: rs.usize): rs.u8 => { return v7 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.btreeGet(tree, rt.byteSliceView(rt.byteSliceFrom(key2))), 221, (v8: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.btreeGet(tree, rs.byteSliceView(rs.byteSliceFrom(key2))), 221, (v8: rs.usize): rs.u8 => { return v8 & 0xff; })); - rt.byteVecPush(out, rt.hashContains(borrowed, rt.byteSliceFrom(key2)) ? 1 : 0); - rt.byteVecPush(out, rt.btreeContains(ordered, s2) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(borrowed, rs.byteSliceFrom(key2)) ? 1 : 0); + rs.byteVecPush(out, rs.btreeContains(ordered, s2) ? 1 : 0); if (s2.length >= 2) { - const two: rt.ByteSlice = rt.byteSliceRange(s2, 0, 2); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(arrays, rt.byteSliceView(two)), 221, (v9: rt.usize): rt.u8 => { + const two: rs.ByteSlice = rs.byteSliceRange(s2, 0, 2); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(arrays, rs.byteSliceView(two)), 221, (v9: rs.usize): rs.u8 => { return v9 & 0xff; })); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.btreeGet(tree, rt.byteSliceView(two)), 221, (v10: rt.usize): rt.u8 => { + rs.byteVecPush(out, option_mapOr$188iunt(rs.btreeGet(tree, rs.byteSliceView(two)), 221, (v10: rs.usize): rs.u8 => { return v10 & 0xff; })); } - const _332: [Uint8Array | undefined, rt.ByteVec] = [key2, rt.byteSliceToByteVec(s2)]; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(nested, _332), 221, (v11: rt.usize): rt.u8 => { + const _332: [Uint8Array | undefined, rs.ByteVec] = [key2, rs.byteSliceToByteVec(s2)]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(nested, _332), 221, (v11: rs.usize): rs.u8 => { return v11 & 0xff; })); - const _340: [Uint8Array | undefined, rt.ByteVec] = [undefined, rt.byteSliceToByteVec(s2)]; - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashGet(nested, _340), 221, (v12: rt.usize): rt.u8 => { + const _340: [Uint8Array | undefined, rs.ByteVec] = [undefined, rs.byteSliceToByteVec(s2)]; + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashGet(nested, _340), 221, (v12: rs.usize): rs.u8 => { return v12 & 0xff; })); } } - const _347: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.hashRemove(vecs, _347), 238, (v13: rt.usize): rt.u8 => { + const _347: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0); + rs.byteVecPush(out, option_mapOr$188iunt(rs.hashRemove(vecs, _347), 238, (v13: rs.usize): rs.u8 => { return v13 & 0xff; })); - rt.byteVecPush(out, rt.hashLen(vecs) & 0xff); - const _354: rt.Iter = rt.iterMap(rt.byteSliceChunks(data, 2), (a0: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(a0); + rs.byteVecPush(out, rs.hashLen(vecs) & 0xff); + const _354: rs.Iter = rs.iterMap(rs.byteSliceChunks(data, 2), (a0: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a0); }); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _354, undefined, undefined, 117440512); - rt.byteVecPush(out, rt.hashLen(set) & 0xff); - const _364: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); - rt.byteVecPush(out, rt.hashContains(set, _364) ? 1 : 0); - rt.hashDrop(arcs, rt.drop); - rt.hashDrop(shared, rt.drop); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _354, undefined, undefined, 117440512); + rs.byteVecPush(out, rs.hashLen(set) & 0xff); + const _364: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); + rs.byteVecPush(out, rs.hashContains(set, _364) ? 1 : 0); + rs.hashDrop(arcs, rs.drop); + rs.hashDrop(shared, rs.drop); } /** @@ -1075,523 +1075,523 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * written, which leaves the collection's own as they were. A hash collection's order is * the runtime's, so what it yields is sorted first. */ -export function lentKeys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceWindows(data, 2), (w: rt.ByteSlice): Uint8Array => { - rt.idx(w, 0); - const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); - rt.idx(w, 1); - return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); +export function lentKeys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), (w: rs.ByteSlice): Uint8Array => { + rs.idx(w, 0); + const _3: rs.u8 = rs.u8Rem(w.data[w.start], 4); + rs.idx(w, 1); + return Uint8Array.of(_3, rs.u8Rem(w.data[w.start + 1], 4)); }), undefined, 2, true); - const probe: Uint8Array = Uint8Array.of(rt.u8Rem(kind, 4), rt.u8Rem(rt.u8Div(kind, 4), 4)); - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom)); + const probe: Uint8Array = Uint8Array.of(rs.u8Rem(kind, 4), rs.u8Rem(rs.u8Div(kind, 4), 4)); + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom)); while (true) { - const _24: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const i: rt.usize = _24[0]; - const key: Uint8Array = copy$array_u8(rt.byteSliceToArray(_24[1])); - rt.hashInsert(map, copy$array_u8(key), i & 0xff); - rt.btreeInsert(tree, copy$array_u8(key), i & 0xff); - rt.hashAdd(set, copy$array_u8(key)); - rt.btreeAdd(ordered, copy$array_u8(key)); + const i: rs.usize = _24[0]; + const key: Uint8Array = copy$array_u8(rs.byteSliceToArray(_24[1])); + rs.hashInsert(map, copy$array_u8(key), i & 0xff); + rs.btreeInsert(tree, copy$array_u8(key), i & 0xff); + rs.hashAdd(set, copy$array_u8(key)); + rs.btreeAdd(ordered, copy$array_u8(key)); key[0] = key[0] ^ 16; - rt.byteVecPush(out, rt.hashContains(map, rt.byteSliceView(rt.byteSliceFrom(key))) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(map, rs.byteSliceView(rs.byteSliceFrom(key))) ? 1 : 0); } - const lent: rt.Vec = rt.iterToVec(rt.iterLend(rt.hashKeys(map), rt.byteSliceFrom), "next", 4); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpBytes), 4, true); + const lent: rs.Vec = rs.iterToVec(rs.iterLend(rs.hashKeys(map), rs.byteSliceFrom), "next", 4); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpBytes), 4, true); for (const k of lent.items) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rt.hashIndex(map, rt.byteSliceView(k)), rt.hashContains(map, rt.byteSliceView(k)) ? 1 : 0, rt.eqBytes(k, rt.byteSliceFrom(probe)) ? 1 : 0, rt.cmpBytes(k, rt.byteSliceFrom(probe)) === -1 ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeGet(tree, rt.byteSliceView(k)), 221)); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.optionMap(rt.hashKey(set, rt.byteSliceView(k)), rt.byteSliceFrom), 221, (s: rt.ByteSlice): rt.u8 => { - return rt.eqBytes(s, k) ? 1 : 0; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(k.data[k.start], k.data[k.start + 1], rs.hashIndex(map, rs.byteSliceView(k)), rs.hashContains(map, rs.byteSliceView(k)) ? 1 : 0, rs.eqBytes(k, rs.byteSliceFrom(probe)) ? 1 : 0, rs.cmpBytes(k, rs.byteSliceFrom(probe)) === -1 ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeGet(tree, rs.byteSliceView(k)), 221)); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.optionMap(rs.hashKey(set, rs.byteSliceView(k)), rs.byteSliceFrom), 221, (s: rs.ByteSlice): rs.u8 => { + return rs.eqBytes(s, k) ? 1 : 0; })); - const copy: Uint8Array = rt.byteSliceToArray(k); + const copy: Uint8Array = rs.byteSliceToArray(k); copy[1] = copy[1] ^ 32; - rt.byteVecPush(out, rt.hashContains(map, rt.byteSliceView(rt.byteSliceFrom(copy))) ? 1 : 0); + rs.byteVecPush(out, rs.hashContains(map, rs.byteSliceView(rs.byteSliceFrom(copy))) ? 1 : 0); } - rt.byteVecPush(out, rt.iterAll(rt.iterSlice(lent.items), (k3: rt.ByteSlice): boolean => { - return rt.hashContains(map, rt.byteSliceView(k3)); + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(lent.items), (k3: rs.ByteSlice): boolean => { + return rs.hashContains(map, rs.byteSliceView(k3)); }) ? 1 : 0); - const entries: rt.Vec<[Uint8Array, rt.u8]> = new rt.Vec(); - const iter3: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.hashIter(map), (held): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held[0]), held[1]]; + const entries: rs.Vec<[Uint8Array, rs.u8]> = new rs.Vec(); + const iter3: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterLend(rs.hashIter(map), (held): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }); while (true) { - const _120: [rt.ByteSlice, rt.u8] | rt.Done = iter3.next(); - if (_120 === rt.DONE) { + const _120: [rs.ByteSlice, rs.u8] | rs.Done = iter3.next(); + if (_120 === rs.DONE) { break; } - entries.items.push([rt.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rt.u8]); + entries.items.push([rs.byteSliceToArray(_120[0]), _120[1]] as [Uint8Array, rs.u8]); } - rt.sliceSort(entries.items, rt.cmpLt(rt.cmpTuple<[Uint8Array, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp])), 3, true); + rs.sliceSort(entries.items, rs.cmpLt(rs.cmpTuple<[Uint8Array, rs.u8], rs.Ordering | undefined>([rs.cmpBytes, rs.cmp])), 3, true); for (const _136 of entries.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_136[0])); - rt.byteVecPush(out, _136[1]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(_136[0])); + rs.byteVecPush(out, _136[1]); } - let sum: rt.u8 = 0; - const iter5: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.hashIterMut(map), (held2): [rt.ByteSlice, rt.Place] => { - return [rt.byteSliceFrom(held2[0]), held2[1]]; + let sum: rs.u8 = 0; + const iter5: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterLend(rs.hashIterMut(map), (held2): [rs.ByteSlice, rs.Place] => { + return [rs.byteSliceFrom(held2[0]), held2[1]]; }); while (true) { - const _149: [rt.ByteSlice, rt.Place] | rt.Done = iter5.next(); - if (_149 === rt.DONE) { + const _149: [rs.ByteSlice, rs.Place] | rs.Done = iter5.next(); + if (_149 === rs.DONE) { break; } - _149[1].v = rt.u8WrappingAdd(_149[1].v, _149[0].data[_149[0].start]); - sum = rt.u8WrappingAdd(rt.u8WrappingAdd(sum, _149[0].data[_149[0].start + 1]), _149[1].v); + _149[1].v = rs.u8WrappingAdd(_149[1].v, _149[0].data[_149[0].start]); + sum = rs.u8WrappingAdd(rs.u8WrappingAdd(sum, _149[0].data[_149[0].start + 1]), _149[1].v); } - const iter6: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.hashIterMut(map), (held3): [rt.ByteSlice, rt.Place] => { - return [rt.byteSliceFrom(held3[0]), held3[1]]; + const iter6: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterLend(rs.hashIterMut(map), (held3): [rs.ByteSlice, rs.Place] => { + return [rs.byteSliceFrom(held3[0]), held3[1]]; }); while (true) { - const _170: [rt.ByteSlice, rt.Place] | rt.Done = iter6.next(); - if (_170 === rt.DONE) { + const _170: [rs.ByteSlice, rs.Place] | rs.Done = iter6.next(); + if (_170 === rs.DONE) { break; } _170[1].v = _170[1].v ^ _170[0].data[_170[0].start + 1]; } - const iter7: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.hashIter(map), (held4): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held4[0]), held4[1]]; + const iter7: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterLend(rs.hashIter(map), (held4): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held4[0]), held4[1]]; }); while (true) { - const _181: [rt.ByteSlice, rt.u8] | rt.Done = iter7.next(); - if (_181 === rt.DONE) { + const _181: [rs.ByteSlice, rs.u8] | rs.Done = iter7.next(); + if (_181 === rs.DONE) { break; } - sum = rt.u8WrappingAdd(sum, _181[0].data[_181[0].start] ^ _181[1]); + sum = rs.u8WrappingAdd(sum, _181[0].data[_181[0].start] ^ _181[1]); } - rt.byteVecPush(out, sum); - rt.byteVecPush(out, option_mapOr$1be3nsj(rt.optionMap(rt.hashGetKeyValue(map, rt.byteSliceView(rt.byteSliceFrom(probe))), (held5): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held5[0]), held5[1]]; - }), 221, (_2: [rt.ByteSlice, rt.u8]): rt.u8 => { + rs.byteVecPush(out, sum); + rs.byteVecPush(out, option_mapOr$09t7mex(rs.optionMap(rs.hashGetKeyValue(map, rs.byteSliceView(rs.byteSliceFrom(probe))), (held5): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held5[0]), held5[1]]; + }), 221, (_2: [rs.ByteSlice, rs.u8]): rs.u8 => { return _2[0].data[_2[0].start] ^ _2[0].data[_2[0].start + 1] ^ _2[1]; })); - rt.byteVecPush(out, option_mapOr$1be3nsj(rt.optionMap(rt.btreeGetKeyValue(tree, rt.byteSliceView(rt.byteSliceFrom(probe))), (held6): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held6[0]), held6[1]]; - }), 221, (_22: [rt.ByteSlice, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$09t7mex(rs.optionMap(rs.btreeGetKeyValue(tree, rs.byteSliceView(rs.byteSliceFrom(probe))), (held6): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held6[0]), held6[1]]; + }), 221, (_22: [rs.ByteSlice, rs.u8]): rs.u8 => { return _22[0].data[_22[0].start] ^ _22[0].data[_22[0].start + 1] ^ _22[1]; })); - const _206: rt.Entry = rt.entry(map, copy$array_u8(probe)); - if (rt.entryOccupied(_206)) { - const o: rt.Entry = _206; - const _212: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o)); - const _211: rt.u8 = _212.data[_212.start]; - const _217: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _211, _217.data[_217.start + 1], rt.entryGet(o))), undefined, true); + const _206: rs.Entry = rs.entry(map, copy$array_u8(probe)); + if (rs.entryOccupied(_206)) { + const o: rs.Entry = _206; + const _212: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(o)); + const _211: rs.u8 = _212.data[_212.start]; + const _217: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(o)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(1, _211, _217.data[_217.start + 1], rs.entryGet(o))), undefined, true); } else { - const v: rt.Entry = _206; - const _227: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v)); - const _226: rt.u8 = _227.data[_227.start]; - const _232: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _226, _232.data[_232.start + 1])), undefined, true); - } - const _239: rt.Entry = rt.entry(map, copy$array_u8(probe)); - const f = (k4: rt.ByteSlice): rt.u8 => { - return rt.u8WrappingMul(k4.data[k4.start], 3) ^ k4.data[k4.start + 1]; + const v: rs.Entry = _206; + const _227: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(v)); + const _226: rs.u8 = _227.data[_227.start]; + const _232: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(v)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(0, _226, _232.data[_232.start + 1])), undefined, true); + } + const _239: rs.Entry = rs.entry(map, copy$array_u8(probe)); + const f = (k4: rs.ByteSlice): rs.u8 => { + return rs.u8WrappingMul(k4.data[k4.start], 3) ^ k4.data[k4.start + 1]; }; - rt.byteVecPush(out, rt.entryOrInsertWithMut(_239, (held7) => f(rt.byteSliceFrom(held7))).v); - const _243: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(rt.entry(map, Uint8Array.of(3, 3)))); - rt.byteVecPush(out, _243.data[_243.start + 1]); - const _251: rt.Entry = rt.entry(tree, copy$array_u8(probe)); - if (!rt.entryOccupied(_251)) { - const v2: rt.Entry = _251; - const _272: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v2)); - const _271: rt.u8 = _272.data[_272.start]; - const _277: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(v2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(0, _271, _277.data[_277.start + 1])), undefined, true); + rs.byteVecPush(out, rs.entryOrInsertWithMut(_239, (held7) => f(rs.byteSliceFrom(held7))).v); + const _243: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(rs.entry(map, Uint8Array.of(3, 3)))); + rs.byteVecPush(out, _243.data[_243.start + 1]); + const _251: rs.Entry = rs.entry(tree, copy$array_u8(probe)); + if (!rs.entryOccupied(_251)) { + const v2: rs.Entry = _251; + const _272: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(v2)); + const _271: rs.u8 = _272.data[_272.start]; + const _277: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(v2)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(0, _271, _277.data[_277.start + 1])), undefined, true); } else { - const o2: rt.Entry = _251; - const _257: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o2)); - const _256: rt.u8 = _257.data[_257.start]; - const _262: rt.ByteSlice = rt.byteSliceFrom(rt.entryKey(o2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(1, _256, _262.data[_262.start + 1], rt.entryGet(o2))), undefined, true); - } - const _284: rt.Entry = rt.entry(tree, copy$array_u8(probe)); - const f2 = (k5: rt.ByteSlice): rt.u8 => { - return rt.u8WrappingMul(k5.data[k5.start + 1], 5) ^ k5.data[k5.start]; + const o2: rs.Entry = _251; + const _257: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(o2)); + const _256: rs.u8 = _257.data[_257.start]; + const _262: rs.ByteSlice = rs.byteSliceFrom(rs.entryKey(o2)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(1, _256, _262.data[_262.start + 1], rs.entryGet(o2))), undefined, true); + } + const _284: rs.Entry = rs.entry(tree, copy$array_u8(probe)); + const f2 = (k5: rs.ByteSlice): rs.u8 => { + return rs.u8WrappingMul(k5.data[k5.start + 1], 5) ^ k5.data[k5.start]; }; - rt.byteVecPush(out, rt.entryOrInsertWithMut(_284, (held8) => f2(rt.byteSliceFrom(held8))).v); - const _286: rt.Entry | undefined = rt.btreeFirstEntry(tree); + rs.byteVecPush(out, rs.entryOrInsertWithMut(_284, (held8) => f2(rs.byteSliceFrom(held8))).v); + const _286: rs.Entry | undefined = rs.btreeFirstEntry(tree); if (_286 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.entryKey(_286))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.entryKey(_286))); } - const _294: rt.Entry | undefined = rt.btreeFirstEntry(tree, true); + const _294: rs.Entry | undefined = rs.btreeFirstEntry(tree, true); if (_294 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.entryKey(_294))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.entryKey(_294))); } - const members: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); - rt.sliceSort(members.items, rt.cmpLt(rt.cmpBytes), 2, true); - const iter8: rt.Iter = rt.iterLend(rt.iterSlice(members.items), rt.byteSliceFrom); + const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); + rs.sliceSort(members.items, rs.cmpLt(rs.cmpBytes), 2, true); + const iter8: rs.Iter = rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom); while (true) { - const _312: rt.ByteSlice | rt.Done = iter8.next(); - if (_312 === rt.DONE) { + const _312: rs.ByteSlice | rs.Done = iter8.next(); + if (_312 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _312); + rs.byteVecExtendFromSlice(out, _312); } - const iter9: rt.Iter = rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom); + const iter9: rs.Iter = rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom); while (true) { - const _321: rt.ByteSlice | rt.Done = iter9.next(); - if (_321 === rt.DONE) { + const _321: rs.ByteSlice | rs.Done = iter9.next(); + if (_321 === rs.DONE) { break; } - const _329: rt.ByteSlice | undefined = rt.optionMap(rt.btreeKey(ordered, rt.byteSliceView(_321)), rt.byteSliceFrom); - rt.byteVecPush(out, rt.eqOption(rt.eqBytes)(_329, _321) ? 1 : 0); + const _329: rs.ByteSlice | undefined = rs.optionMap(rs.btreeKey(ordered, rs.byteSliceView(_321)), rs.byteSliceFrom); + rs.byteVecPush(out, rs.eqOption(rs.eqBytes)(_329, _321) ? 1 : 0); } - const window: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.optionMap(rt.hashKey(set, rt.byteSliceView(window)), rt.byteSliceFrom), 221, (k6: rt.ByteSlice): rt.u8 => { + const window: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.optionMap(rs.hashKey(set, rs.byteSliceView(window)), rs.byteSliceFrom), 221, (k6: rs.ByteSlice): rs.u8 => { return k6.data[k6.start] ^ ((k6.data[k6.start + 1] << 2) & 0xff); })); - const _345: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(probe), 0); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.optionMap(rt.hashKey(set, rt.byteSliceView(_345)), rt.byteSliceFrom), 221, (k7: rt.ByteSlice): rt.u8 => { + const _345: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(probe), 0); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.optionMap(rs.hashKey(set, rs.byteSliceView(_345)), rs.byteSliceFrom), 221, (k7: rs.ByteSlice): rs.u8 => { return k7.data[k7.start] ^ ((k7.data[k7.start + 1] << 2) & 0xff); })); - const _353: rt.ByteSlice = rt.byteSliceFrom(probe); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.optionMap(rt.hashKey(set, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom), 221, (k8: rt.ByteSlice): rt.u8 => { - return rt.eqBytes(k8, _353) ? 1 : 0; + const _353: rs.ByteSlice = rs.byteSliceFrom(probe); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.optionMap(rs.hashKey(set, rs.byteSliceView(rs.byteSliceFrom(probe))), rs.byteSliceFrom), 221, (k8: rs.ByteSlice): rs.u8 => { + return rs.eqBytes(k8, _353) ? 1 : 0; })); - const _358: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(probe), 0); - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.optionMap(rt.btreeKey(ordered, rt.byteSliceView(_358)), rt.byteSliceFrom), 221, (k9: rt.ByteSlice): rt.u8 => { + const _358: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(probe), 0); + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.optionMap(rs.btreeKey(ordered, rs.byteSliceView(_358)), rs.byteSliceFrom), 221, (k9: rs.ByteSlice): rs.u8 => { return k9.data[k9.start] ^ ((k9.data[k9.start + 1] << 2) & 0xff); })); - const iter10: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterRev(rt.iterLend(rt.btreeIter(tree), (held9): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held9[0]), held9[1]]; + const iter10: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterRev(rs.iterLend(rs.btreeIter(tree), (held9): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held9[0]), held9[1]]; })); while (true) { - const _365: [rt.ByteSlice, rt.u8] | rt.Done = iter10.next(); - if (_365 === rt.DONE) { + const _365: [rs.ByteSlice, rs.u8] | rs.Done = iter10.next(); + if (_365 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_365[0].data[_365[0].start], _365[0].data[_365[0].start + 1], _365[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_365[0].data[_365[0].start], _365[0].data[_365[0].start + 1], _365[1])), undefined, true); } - const iter11: rt.Iter = rt.iterLend(rt.btreeKeys(tree), rt.byteSliceFrom); + const iter11: rs.Iter = rs.iterLend(rs.btreeKeys(tree), rs.byteSliceFrom); while (true) { - const _383: rt.ByteSlice | rt.Done = iter11.next(); - if (_383 === rt.DONE) { + const _383: rs.ByteSlice | rs.Done = iter11.next(); + if (_383 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _383); + rs.byteVecExtendFromSlice(out, _383); } - const iter12: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.btreeRange(tree, new rt.Range(Uint8Array.of(1, 0), Uint8Array.of(3, 0))), (held10): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held10[0]), held10[1]]; + const iter12: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterLend(rs.btreeRange(tree, new rs.Range(Uint8Array.of(1, 0), Uint8Array.of(3, 0))), (held10): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held10[0]), held10[1]]; }); while (true) { - const _396: [rt.ByteSlice, rt.u8] | rt.Done = iter12.next(); - if (_396 === rt.DONE) { + const _396: [rs.ByteSlice, rs.u8] | rs.Done = iter12.next(); + if (_396 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_396[0].data[_396[0].start], _396[0].data[_396[0].start + 1], _396[1])), undefined, true); } - const iter13: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeRangeMut(tree, new rt.RangeFrom(copy$array_u8(probe))), (held11): [rt.ByteSlice, rt.Place] => { - return [rt.byteSliceFrom(held11[0]), held11[1]]; + const iter13: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterLend(rs.btreeRangeMut(tree, new rs.RangeFrom(copy$array_u8(probe))), (held11): [rs.ByteSlice, rs.Place] => { + return [rs.byteSliceFrom(held11[0]), held11[1]]; }); while (true) { - const _415: [rt.ByteSlice, rt.Place] | rt.Done = iter13.next(); - if (_415 === rt.DONE) { + const _415: [rs.ByteSlice, rs.Place] | rs.Done = iter13.next(); + if (_415 === rs.DONE) { break; } - _415[1].v = rt.u8WrappingAdd(_415[1].v, _415[0].data[_415[0].start]); + _415[1].v = rs.u8WrappingAdd(_415[1].v, _415[0].data[_415[0].start]); } - const iter14: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterLend(rt.btreeIter(tree), (held12): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held12[0]), held12[1]]; + const iter14: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterLend(rs.btreeIter(tree), (held12): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held12[0]), held12[1]]; }); while (true) { - const _428: [rt.ByteSlice, rt.u8] | rt.Done = iter14.next(); - if (_428 === rt.DONE) { + const _428: [rs.ByteSlice, rs.u8] | rs.Done = iter14.next(); + if (_428 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_428[0].data[_428[0].start + 1], _428[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_428[0].data[_428[0].start + 1], _428[1])), undefined, true); } - const iter15: rt.Iter<[rt.ByteSlice, rt.Place]> = rt.iterLend(rt.btreeIterMut(tree), (held13): [rt.ByteSlice, rt.Place] => { - return [rt.byteSliceFrom(held13[0]), held13[1]]; + const iter15: rs.Iter<[rs.ByteSlice, rs.Place]> = rs.iterLend(rs.btreeIterMut(tree), (held13): [rs.ByteSlice, rs.Place] => { + return [rs.byteSliceFrom(held13[0]), held13[1]]; }); while (true) { - const _442: [rt.ByteSlice, rt.Place] | rt.Done = iter15.next(); - if (_442 === rt.DONE) { + const _442: [rs.ByteSlice, rs.Place] | rs.Done = iter15.next(); + if (_442 === rs.DONE) { break; } _442[1].v = _442[1].v ^ _442[0].data[_442[0].start]; } - rt.byteVecPush(out, option_mapOr$1be3nsj(rt.optionMap(rt.btreeFirst(tree), (held14): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held14[0]), held14[1]]; - }), 221, (_23: [rt.ByteSlice, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$09t7mex(rs.optionMap(rs.btreeFirst(tree), (held14): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held14[0]), held14[1]]; + }), 221, (_23: [rs.ByteSlice, rs.u8]): rs.u8 => { return _23[0].data[_23[0].start] ^ _23[1]; })); - rt.byteVecPush(out, option_mapOr$1be3nsj(rt.optionMap(rt.btreeFirst(tree, true), (held15): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held15[0]), held15[1]]; - }), 221, (_25: [rt.ByteSlice, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$09t7mex(rs.optionMap(rs.btreeFirst(tree, true), (held15): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held15[0]), held15[1]]; + }), 221, (_25: [rs.ByteSlice, rs.u8]): rs.u8 => { return _25[0].data[_25[0].start + 1] ^ _25[1]; })); - const iter16: rt.Iter = rt.iterRev(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom)); + const iter16: rs.Iter = rs.iterRev(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom)); while (true) { - const _463: rt.ByteSlice | rt.Done = iter16.next(); - if (_463 === rt.DONE) { + const _463: rs.ByteSlice | rs.Done = iter16.next(); + if (_463 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _463); + rs.byteVecExtendFromSlice(out, _463); } - const iter17: rt.Iter = rt.iterLend(rt.btreeRangeKeys(ordered, { end: copy$array_u8(probe), inclusive: true }), rt.byteSliceFrom); + const iter17: rs.Iter = rs.iterLend(rs.btreeRangeKeys(ordered, { end: copy$array_u8(probe), inclusive: true }), rs.byteSliceFrom); while (true) { - const _474: rt.ByteSlice | rt.Done = iter17.next(); - if (_474 === rt.DONE) { + const _474: rs.ByteSlice | rs.Done = iter17.next(); + if (_474 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _474); + rs.byteVecExtendFromSlice(out, _474); } - const iter18: rt.Iter = rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom); + const iter18: rs.Iter = rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom); while (true) { - const _483: rt.ByteSlice | rt.Done = iter18.next(); - if (_483 === rt.DONE) { + const _483: rs.ByteSlice | rs.Done = iter18.next(); + if (_483 === rs.DONE) { break; } - rt.byteVecPush(out, _483.data[_483.start] ^ _483.data[_483.start + 1]); + rs.byteVecPush(out, _483.data[_483.start] ^ _483.data[_483.start + 1]); } - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.btreeFirstKey(ordered), rt.byteSliceFrom), rt.bytes(2).fill(221), (k10: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(k10); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.btreeFirstKey(ordered), rs.byteSliceFrom), rs.bytes(2).fill(221), (k10: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(k10); })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.btreeFirstKey(ordered, true), rt.byteSliceFrom), rt.bytes(2).fill(221), (k11: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(k11); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.btreeFirstKey(ordered, true), rs.byteSliceFrom), rs.bytes(2).fill(221), (k11: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(k11); })), undefined, true); - const f3 = (k12: rt.ByteSlice, v3: rt.Place): boolean => { + const f3 = (k12: rs.ByteSlice, v3: rs.Place): boolean => { if (!(k12.data[k12.start] <= k12.data[k12.start + 1])) { - return rt.u8Rem(v3.v, 2) === 0; + return rs.u8Rem(v3.v, 2) === 0; } return true; }; - rt.hashRetainMut(map, (held16, held17) => f3(rt.byteSliceFrom(held16), held17)); - const f4 = (k13: rt.ByteSlice, _316: rt.Place): boolean => { + rs.hashRetainMut(map, (held16, held17) => f3(rs.byteSliceFrom(held16), held17)); + const f4 = (k13: rs.ByteSlice, _316: rs.Place): boolean => { return k13.data[k13.start] !== k13.data[k13.start + 1]; }; - rt.btreeRetainMut(tree, (held18, held19) => f4(rt.byteSliceFrom(held18), held19)); - const _512: rt.ByteSlice = rt.byteSliceFrom(probe); - const _511: (a0: rt.ByteSlice) => boolean = (k14: rt.ByteSlice): boolean => { + rs.btreeRetainMut(tree, (held18, held19) => f4(rs.byteSliceFrom(held18), held19)); + const _512: rs.ByteSlice = rs.byteSliceFrom(probe); + const _511: (a0: rs.ByteSlice) => boolean = (k14: rs.ByteSlice): boolean => { return k14.data[k14.start + 1] !== _512.data[_512.start + 1]; }; - rt.hashRetain(set, (held20) => _511(rt.byteSliceFrom(held20))); - const f5 = (k15: rt.ByteSlice): boolean => { + rs.hashRetain(set, (held20) => _511(rs.byteSliceFrom(held20))); + const f5 = (k15: rs.ByteSlice): boolean => { return k15.data[k15.start] < 2; }; - rt.btreeRetain(ordered, (held21) => f5(rt.byteSliceFrom(held21))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(map) & 0xff, rt.btreeLen(tree) & 0xff, rt.hashLen(set) & 0xff, rt.btreeLen(ordered) & 0xff)), undefined, true); - const _529: rt.ByteSlice | undefined = rt.optionMap(rt.btreeFirstKey(ordered), rt.byteSliceFrom); + rs.btreeRetain(ordered, (held21) => f5(rs.byteSliceFrom(held21))); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(map) & 0xff, rs.btreeLen(tree) & 0xff, rs.hashLen(set) & 0xff, rs.btreeLen(ordered) & 0xff)), undefined, true); + const _529: rs.ByteSlice | undefined = rs.optionMap(rs.btreeFirstKey(ordered), rs.byteSliceFrom); if (_529 !== undefined) { - const copy2: Uint8Array = rt.byteSliceToArray(_529); + const copy2: Uint8Array = rs.byteSliceToArray(_529); copy2[0] = 255; - rt.byteVecPush(out, rt.btreeContains(ordered, rt.byteSliceView(rt.byteSliceFrom(copy2))) ? 1 : 0); + rs.byteVecPush(out, rs.btreeContains(ordered, rs.byteSliceView(rs.byteSliceFrom(copy2))) ? 1 : 0); } - rt.byteVecPush(out, rt.iterAll(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (k16: rt.ByteSlice): boolean => { + rs.byteVecPush(out, rs.iterAll(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom), (k16: rs.ByteSlice): boolean => { return k16.data[k16.start] < 2; }) ? 1 : 0); - const _548: rt.Iter<[rt.ByteVec, rt.u8]> = rt.iterMap(rt.byteSliceChunks(data, 3), (c: rt.ByteSlice): [rt.ByteVec, rt.u8] => { - return [rt.byteSliceToByteVec(c), c.length & 0xff] as [rt.ByteVec, rt.u8]; + const _548: rs.Iter<[rs.ByteVec, rs.u8]> = rs.iterMap(rs.byteSliceChunks(data, 3), (c: rs.ByteSlice): [rs.ByteVec, rs.u8] => { + return [rs.byteSliceToByteVec(c), c.length & 0xff] as [rs.ByteVec, rs.u8]; }); - const lens: rt.Vec = rt.iterToVec(rt.hashKeys(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _548, undefined, undefined, undefined, 58720256)), "next", 4); - rt.sliceSort(lens.items, rt.cmpLt(rt.cmpBytes), 4, true); + const lens: rs.Vec = rs.iterToVec(rs.hashKeys(rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _548, undefined, undefined, undefined, 58720256)), "next", 4); + rs.sliceSort(lens.items, rs.cmpLt(rs.cmpBytes), 4, true); for (const _559 of lens.items) { - rt.byteVecPush(out, _559.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_559)); + rs.byteVecPush(out, _559.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_559)); } - const _569: rt.Iter = rt.iterMap(rt.byteSliceChunks(data, 2), (a0: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(a0); + const _569: rs.Iter = rs.iterMap(rs.byteSliceChunks(data, 2), (a0: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a0); }); - rt.byteVecPush(out, option_mapOr$1a3irjf(rt.hashKey(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet, _569, undefined, undefined, 117440512), window), 221, (k17: rt.ByteVec): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0g5x999(rs.hashKey(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet, _569, undefined, undefined, 117440512), window), 221, (k17: rs.ByteVec): rs.u8 => { return k17.length & 0xff; })); - const _576: rt.Iter = rt.byteSliceChunks(data, 2); - const borrowed: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpBytes) as rt.BTreeSet, _576, true, undefined, undefined, 8, true); - const iter20: rt.Iter = rt.btreeKeys(borrowed); + const _576: rs.Iter = rs.byteSliceChunks(data, 2); + const borrowed: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpBytes) as rs.BTreeSet, _576, true, undefined, undefined, 8, true); + const iter20: rs.Iter = rs.btreeKeys(borrowed); while (true) { - const _580: rt.ByteSlice | rt.Done = iter20.next(); - if (_580 === rt.DONE) { + const _580: rs.ByteSlice | rs.Done = iter20.next(); + if (_580 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _580); + rs.byteVecExtendFromSlice(out, _580); } - rt.byteVecPush(out, option_mapOr$1w1gbwl(rt.btreeKey(borrowed, window), 221, (k18: rt.ByteSlice): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1lwzqm5(rs.btreeKey(borrowed, window), 221, (k18: rs.ByteSlice): rs.u8 => { return k18.length & 0xff; })); - const empty: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; - const none: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterLend(rt.btreeKeys(empty), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.btreeFirst(empty), (held22): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held22[0]), held22[1]]; - }) === undefined ? 1 : 0, rt.iterCount(rt.iterLend(rt.btreeRange(empty, new rt.RangeFrom(copy$array_u8(probe))), (held23): [rt.ByteSlice, rt.u8] => { - return [rt.byteSliceFrom(held23[0]), held23[1]]; - })) & 0xff, rt.iterCount(rt.iterLend(rt.hashKeys(none), rt.byteSliceFrom)) & 0xff, rt.optionMap(rt.hashKey(none, rt.byteSliceView(rt.byteSliceFrom(probe))), rt.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); + const empty: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; + const none: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.iterCount(rs.iterLend(rs.btreeKeys(empty), rs.byteSliceFrom)) & 0xff, rs.optionMap(rs.btreeFirst(empty), (held22): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held22[0]), held22[1]]; + }) === undefined ? 1 : 0, rs.iterCount(rs.iterLend(rs.btreeRange(empty, new rs.RangeFrom(copy$array_u8(probe))), (held23): [rs.ByteSlice, rs.u8] => { + return [rs.byteSliceFrom(held23[0]), held23[1]]; + })) & 0xff, rs.iterCount(rs.iterLend(rs.hashKeys(none), rs.byteSliceFrom)) & 0xff, rs.optionMap(rs.hashKey(none, rs.byteSliceView(rs.byteSliceFrom(probe))), rs.byteSliceFrom) === undefined ? 1 : 0)), undefined, true); } /** * Values that are `[u8; 2]`, and the items of a deque and a heap, lent as keys are: a * `&` reads them and a `&mut` writes where the collection holds them. */ -export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const iter: rt.Iter = rt.byteSliceWindows(data, 2); +export function lentValues(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const deque: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const iter: rs.Iter = rs.byteSliceWindows(data, 2); while (true) { - const _11: rt.ByteSlice | rt.Done = iter.next(); - if (_11 === rt.DONE) { + const _11: rs.ByteSlice | rs.Done = iter.next(); + if (_11 === rs.DONE) { break; } - rt.idx(_11, 0); - const _16: rt.u8 = _11.data[_11.start]; - rt.idx(_11, 1); - const value: Uint8Array = Uint8Array.of(_16, rt.u8Rem(_11.data[_11.start + 1], 8)); - rt.idx(_11, 0); - rt.hashInsert(map, rt.u8Rem(_11.data[_11.start], 8), copy$array_u8(value)); - rt.idx(_11, 1); - rt.btreeInsert(tree, rt.u8Rem(_11.data[_11.start + 1], 8), copy$array_u8(value)); - rt.dequePushBack(deque, copy$array_u8(value)); - rt.heapPush(heap, copy$array_u8(value), rt.cmpLe(rt.cmpBytes)); - } - const at: rt.u8 = rt.u8Rem(kind, 8); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v2: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(v2); + rs.idx(_11, 0); + const _16: rs.u8 = _11.data[_11.start]; + rs.idx(_11, 1); + const value: Uint8Array = Uint8Array.of(_16, rs.u8Rem(_11.data[_11.start + 1], 8)); + rs.idx(_11, 0); + rs.hashInsert(map, rs.u8Rem(_11.data[_11.start], 8), copy$array_u8(value)); + rs.idx(_11, 1); + rs.btreeInsert(tree, rs.u8Rem(_11.data[_11.start + 1], 8), copy$array_u8(value)); + rs.dequePushBack(deque, copy$array_u8(value)); + rs.heapPush(heap, copy$array_u8(value), rs.cmpLe(rs.cmpBytes)); + } + const at: rs.u8 = rs.u8Rem(kind, 8); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.hashGet(map, at), rs.byteSliceFrom), rs.bytes(2).fill(221), (v2: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(v2); })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.btreeGet(tree, at), rt.byteSliceFrom), rt.bytes(2).fill(221), (v3: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(v3); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.btreeGet(tree, at), rs.byteSliceFrom), rs.bytes(2).fill(221), (v3: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(v3); })), undefined, true); - const _60: rt.ByteSlice | undefined = rt.optionMap(rt.hashGet(map, at), rt.byteSliceFrom); + const _60: rs.ByteSlice | undefined = rs.optionMap(rs.hashGet(map, at), rs.byteSliceFrom); if (_60 !== undefined) { _60.data[_60.start] = _60.data[_60.start] ^ 64; } - const _67: rt.ByteSlice | undefined = rt.optionMap(rt.btreeGet(tree, at), rt.byteSliceFrom); + const _67: rs.ByteSlice | undefined = rs.optionMap(rs.btreeGet(tree, at), rs.byteSliceFrom); if (_67 !== undefined) { _67.data[_67.start + 1] = _67.data[_67.start + 1] ^ 64; } - if (rt.hashContains(map, at)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.hashIndex(map, at)))), undefined, true); + if (rs.hashContains(map, at)) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceToArray(rs.byteSliceFrom(rs.hashIndex(map, at)))), undefined, true); } - if (rt.btreeContains(tree, at)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.btreeIndex(tree, at)))), undefined, true); + if (rs.btreeContains(tree, at)) { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceToArray(rs.byteSliceFrom(rs.btreeIndex(tree, at)))), undefined, true); } - const _90: rt.ByteSlice = rt.byteSliceFrom(rt.entryOrInsert(rt.entry(map, at), Uint8Array.of(at, at))); + const _90: rs.ByteSlice = rs.byteSliceFrom(rs.entryOrInsert(rs.entry(map, at), Uint8Array.of(at, at))); _90.data[_90.start + 1] = _90.data[_90.start + 1] ^ 1; - const _97: rt.Entry = rt.entry(map, at); - const f = (v4: rt.ByteSlice): undefined => { - const _3: rt.u8 = rt.u8WrappingAdd(v4.data[v4.start], 1); + const _97: rs.Entry = rs.entry(map, at); + const f = (v4: rs.ByteSlice): undefined => { + const _3: rs.u8 = rs.u8WrappingAdd(v4.data[v4.start], 1); v4.data[v4.start] = _3; }; - rt.entryAndModify(_97, (held) => f(rt.byteSliceFrom(held))); - const _99: rt.ByteSlice = rt.byteSliceFrom(rt.entryOrInsertWith(rt.entry(tree, at), (): Uint8Array => { + rs.entryAndModify(_97, (held) => f(rs.byteSliceFrom(held))); + const _99: rs.ByteSlice = rs.byteSliceFrom(rs.entryOrInsertWith(rs.entry(tree, at), (): Uint8Array => { return Uint8Array.of(at, 0); })); _99.data[_99.start] = _99.data[_99.start] ^ 2; - const iter2: rt.Iter = rt.iterLend(rt.hashValues(map), rt.byteSliceFrom); + const iter2: rs.Iter = rs.iterLend(rs.hashValues(map), rs.byteSliceFrom); while (true) { - const _110: rt.ByteSlice | rt.Done = iter2.next(); - if (_110 === rt.DONE) { + const _110: rs.ByteSlice | rs.Done = iter2.next(); + if (_110 === rs.DONE) { break; } - const _114: rt.u8 = rt.u8WrappingMul(_110.data[_110.start + 1], 3); + const _114: rs.u8 = rs.u8WrappingMul(_110.data[_110.start + 1], 3); _110.data[_110.start + 1] = _114; } - const iter3: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held2): [rt.u8, rt.ByteSlice] => { - return [held2[0], rt.byteSliceFrom(held2[1])]; + const iter3: rs.Iter<[rs.u8, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held2): [rs.u8, rs.ByteSlice] => { + return [held2[0], rs.byteSliceFrom(held2[1])]; }); while (true) { - const _124: [rt.u8, rt.ByteSlice] | rt.Done = iter3.next(); - if (_124 === rt.DONE) { + const _124: [rs.u8, rs.ByteSlice] | rs.Done = iter3.next(); + if (_124 === rs.DONE) { break; } - const _128: rt.u8 = rt.u8WrappingAdd(_124[1].data[_124[1].start], _124[1].data[_124[1].start + 1]); + const _128: rs.u8 = rs.u8WrappingAdd(_124[1].data[_124[1].start], _124[1].data[_124[1].start + 1]); _124[1].data[_124[1].start] = _128; } - const values: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashValues(map), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); - rt.sliceSort(values.items, rt.cmpLt(rt.cmpBytes), 2, true); - const iter4: rt.Iter = rt.iterLend(rt.iterSlice(values.items), rt.byteSliceFrom); + const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(map), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); + rs.sliceSort(values.items, rs.cmpLt(rs.cmpBytes), 2, true); + const iter4: rs.Iter = rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom); while (true) { - const _147: rt.ByteSlice | rt.Done = iter4.next(); - if (_147 === rt.DONE) { + const _147: rs.ByteSlice | rs.Done = iter4.next(); + if (_147 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _147); + rs.byteVecExtendFromSlice(out, _147); } - const iter5: rt.Iter<[rt.u8, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held3): [rt.u8, rt.ByteSlice] => { - return [held3[0], rt.byteSliceFrom(held3[1])]; + const iter5: rs.Iter<[rs.u8, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held3): [rs.u8, rs.ByteSlice] => { + return [held3[0], rs.byteSliceFrom(held3[1])]; }); while (true) { - const _156: [rt.u8, rt.ByteSlice] | rt.Done = iter5.next(); - if (_156 === rt.DONE) { + const _156: [rs.u8, rs.ByteSlice] | rs.Done = iter5.next(); + if (_156 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_156[0], _156[1].data[_156[1].start], _156[1].data[_156[1].start + 1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_156[0], _156[1].data[_156[1].start], _156[1].data[_156[1].start + 1])), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.dequeEnd(deque), rt.byteSliceFrom), rt.bytes(2).fill(221), (v5: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(v5); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.dequeEnd(deque), rs.byteSliceFrom), rs.bytes(2).fill(221), (v5: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(v5); })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(rt.dequeEnd(deque, true), rt.byteSliceFrom), rt.bytes(2).fill(221), (v6: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(v6); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(rs.dequeEnd(deque, true), rs.byteSliceFrom), rs.bytes(2).fill(221), (v6: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(v6); })), undefined, true); - const _180: rt.ByteSlice | undefined = rt.optionMap(rt.dequeEnd(deque), rt.byteSliceFrom); + const _180: rs.ByteSlice | undefined = rs.optionMap(rs.dequeEnd(deque), rs.byteSliceFrom); if (_180 !== undefined) { _180.data[_180.start] = _180.data[_180.start] ^ 128; } - const _186: rt.ByteSlice | undefined = rt.optionMap(rt.dequeGet(deque, rt.usizeRem(kind as rt.usize, 4)), rt.byteSliceFrom); + const _186: rs.ByteSlice | undefined = rs.optionMap(rs.dequeGet(deque, rs.usizeRem(kind as rs.usize, 4)), rs.byteSliceFrom); if (_186 !== undefined) { _186.data[_186.start + 1] = _186.data[_186.start + 1] ^ 128; } if (!(deque.n === 0)) { - const _201: rt.ByteSlice = rt.byteSliceFrom(rt.dequeIndex(deque, rt.usizeSub(deque.n, 1))); + const _201: rs.ByteSlice = rs.byteSliceFrom(rs.dequeIndex(deque, rs.usizeSub(deque.n, 1))); _201.data[_201.start] = _201.data[_201.start] ^ 1; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceToArray(rt.byteSliceFrom(rt.dequeIndex(deque, 0)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceToArray(rs.byteSliceFrom(rs.dequeIndex(deque, 0)))), undefined, true); } - const iter6: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); + const iter6: rs.Iter = rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom); while (true) { - const _213: rt.ByteSlice | rt.Done = iter6.next(); - if (_213 === rt.DONE) { + const _213: rs.ByteSlice | rs.Done = iter6.next(); + if (_213 === rs.DONE) { break; } - const _217: rt.u8 = rt.u8WrappingAdd(_213.data[_213.start + 1], 1); + const _217: rs.u8 = rs.u8WrappingAdd(_213.data[_213.start + 1], 1); _213.data[_213.start + 1] = _217; } - const f2 = (v7: rt.ByteSlice): boolean => { - return rt.u8Rem(v7.data[v7.start], 3) !== 0; + const f2 = (v7: rs.ByteSlice): boolean => { + return rs.u8Rem(v7.data[v7.start], 3) !== 0; }; - rt.dequeRetain(deque, (held4) => f2(rt.byteSliceFrom(held4))); - const iter7: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); + rs.dequeRetain(deque, (held4) => f2(rs.byteSliceFrom(held4))); + const iter7: rs.Iter = rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom); while (true) { - const _228: rt.ByteSlice | rt.Done = iter7.next(); - if (_228 === rt.DONE) { + const _228: rs.ByteSlice | rs.Done = iter7.next(); + if (_228 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _228); + rs.byteVecExtendFromSlice(out, _228); } - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (v8: rt.ByteSlice): boolean => { - const _63: rt.ByteSlice = v8; + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (v8: rs.ByteSlice): boolean => { + const _63: rs.ByteSlice = v8; return _63.data[_63.start + 1] > 4; })) & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.optionMap(heap.items[0], rt.byteSliceFrom), rt.bytes(2).fill(221), (v9: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(v9); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.optionMap(heap.items[0], rs.byteSliceFrom), rs.bytes(2).fill(221), (v9: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(v9); })), undefined, true); - const _247: (a0: rt.ByteSlice) => boolean = (v10: rt.ByteSlice): boolean => { - return v10.data[v10.start + 1] !== rt.u8Rem(kind, 8); + const _247: (a0: rs.ByteSlice) => boolean = (v10: rs.ByteSlice): boolean => { + return v10.data[v10.start + 1] !== rs.u8Rem(kind, 8); }; - rt.heapRetain(heap, (held5) => _247(rt.byteSliceFrom(held5)), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); - const iter8: rt.Iter = rt.iterLend(rt.heapIter(heap), rt.byteSliceFrom); + rs.heapRetain(heap, (held5) => _247(rs.byteSliceFrom(held5)), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)); + const iter8: rs.Iter = rs.iterLend(rs.heapIter(heap), rs.byteSliceFrom); while (true) { - const _253: rt.ByteSlice | rt.Done = iter8.next(); - if (_253 === rt.DONE) { + const _253: rs.ByteSlice | rs.Done = iter8.next(); + if (_253 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _253); + rs.byteVecExtendFromSlice(out, _253); } - const iter9: rt.Iter = rt.iterLend(rt.heapIter(heap), rt.byteSliceFrom); + const iter9: rs.Iter = rs.iterLend(rs.heapIter(heap), rs.byteSliceFrom); while (true) { - const _262: rt.ByteSlice | rt.Done = iter9.next(); - if (_262 === rt.DONE) { + const _262: rs.ByteSlice | rs.Done = iter9.next(); + if (_262 === rs.DONE) { break; } - rt.byteVecPush(out, _262.data[_262.start] ^ _262.data[_262.start + 1]); + rs.byteVecPush(out, _262.data[_262.start] ^ _262.data[_262.start + 1]); } - for (const _278 of rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)).items) { - rt.iterExtendBytes(out, rt.iterSlice(_278), undefined, true); + for (const _278 of rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items) { + rs.iterExtendBytes(out, rs.iterSlice(_278), undefined, true); } } @@ -1601,44 +1601,44 @@ export function lentValues(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): vo * by their elements in turn, and ranged, walked, and edited through entries. A hash * collection's order is the runtime's, so what it yields is sorted first. */ -export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 9); +export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 9); if (_4 === 0) { - keyed$u16_2_keys_arrays_closure0(data, (b8: rt.u8): rt.u16[] => { - return [((rt.u8Rem(b8, 4) as rt.u16) << 8) & 0xffff, rt.u8Rem(b8, 3) as rt.u16]; + keyed$u16_2_keys_arrays_closure0(data, (b8: rs.u8): rs.u16[] => { + return [((rs.u8Rem(b8, 4) as rs.u16) << 8) & 0xffff, rs.u8Rem(b8, 3) as rs.u16]; }, out); } else if (_4 === 1) { - keyed$u64_2_keys_arrays_closure1(data, (b7: rt.u8): rt.u64[] => { - return [rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u8Rem(b7, 4) as rt.u64), rt.u64Shl(1, rt.u8Mul(rt.u8Rem(b7, 3), 30))]; + keyed$u64_2_keys_arrays_closure1(data, (b7: rs.u8): rs.u64[] => { + return [rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(b7, 4) as rs.u64), rs.u64Shl(1, rs.u8Mul(rs.u8Rem(b7, 3), 30))]; }, out); } else if (_4 === 2) { - keyed$i32_2_keys_arrays_closure2(data, (b6: rt.u8): rt.i32[] => { - return [rt.i8Rem((b6 << 24) >> 24, 3) as rt.i32, rt.i32Neg(rt.u8Rem(b6, 2) as rt.i32)]; + keyed$i32_2_keys_arrays_closure2(data, (b6: rs.u8): rs.i32[] => { + return [rs.i8Rem((b6 << 24) >> 24, 3) as rs.i32, rs.i32Neg(rs.u8Rem(b6, 2) as rs.i32)]; }, out); } else if (_4 === 3) { - keyed$char_2_keys_arrays_closure3(data, (b5: rt.u8): rt.char[] => { - return [57344, rt.u8Add(rt.u8Rem(b5, 4), 97) as rt.char]; + keyed$char_2_keys_arrays_closure3(data, (b5: rs.u8): rs.char[] => { + return [57344, rs.u8Add(rs.u8Rem(b5, 4), 97) as rs.char]; }, out); } else if (_4 === 4) { - keyed$bool_2_keys_arrays_closure4(data, (b4: rt.u8): boolean[] => { - return [rt.u8Rem(b4, 2) === 0, rt.u8Rem(b4, 3) === 0]; + keyed$bool_2_keys_arrays_closure4(data, (b4: rs.u8): boolean[] => { + return [rs.u8Rem(b4, 2) === 0, rs.u8Rem(b4, 3) === 0]; }, out); } else if (_4 === 5) { - keyed$Option_u8_2_keys_arrays_closure5(data, (b3: rt.u8): Array => { - return [small(b3), small(rt.u8Div(b3, 4))]; + keyed$Option_u8_2_keys_arrays_closure5(data, (b3: rs.u8): Array => { + return [small(b3), small(rs.u8Div(b3, 4))]; }, out); } else if (_4 === 6) { - keyed$keys_Hop_2_keys_arrays_closure6(data, (b2: rt.u8): Hop.Hop[] => { - return [{ _0: rt.u64Shl(rt.u8Rem(b2, 3) as rt.u64, 53) }, { _0: rt.u8Rem(b2, 2) as rt.u64 }]; + keyed$keys_Hop_2_keys_arrays_closure6(data, (b2: rs.u8): Hop.Hop[] => { + return [{ _0: rs.u64Shl(rs.u8Rem(b2, 3) as rs.u64, 53) }, { _0: rs.u8Rem(b2, 2) as rs.u64 }]; }, out); } else if (_4 === 7) { - keyed$u32_0_keys_arrays_closure7(data, (_2: rt.u8): rt.u32[] => { + keyed$u32_0_keys_arrays_closure7(data, (_2: rs.u8): rs.u32[] => { return []; }, out); } else { - keyed$u32_275_keys_arrays_closure8(data, (b: rt.u8): rt.u32[] => { - const _3: rt.u32 = rt.u8Rem(b, 4) as rt.u32; - return Array.from({ length: 275 }, (): rt.u32 => { + keyed$u32_275_keys_arrays_closure8(data, (b: rs.u8): rs.u32[] => { + const _3: rs.u32 = rs.u8Rem(b, 4) as rs.u32; + return Array.from({ length: 275 }, (): rs.u32 => { return _3; }); }, out); @@ -1646,2297 +1646,2297 @@ export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$Option_u8_2_keys_arrays_closure5(data: rt.ByteSlice, make: (a0: rt.u8) => Array, out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeMap, rt.u8>; - const set: rt.HashSet> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashSet>; - const ordered: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>; - const values: rt.HashMap> = rt.hashNew() as rt.HashMap>; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$Option_u8_2_keys_arrays_closure5(data: rs.ByteSlice, make: (a0: rs.u8) => Array, out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashSlice(rs.hashOption(rs.hash8)), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const tree: rs.BTreeMap, rs.u8> = rs.btreeNew(rs.cmpSlice(rs.cmpOption(rs.cmp))) as rs.BTreeMap, rs.u8>; + const set: rs.HashSet> = rs.hashNew(rs.hashing(rs.hashSlice(rs.hashOption(rs.hash8)), rs.eqSlice(rs.same))) as rs.HashSet>; + const ordered: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmpOption(rs.cmp))) as rs.BTreeSet>; + const values: rs.HashMap> = rs.hashNew() as rs.HashMap>; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: Array = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: Array = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: Array = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: Array = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: Array = make(b); - rt.byteVecPush(out, option_mapOr$1bumeih(rt.hashInsert(values, _51, _53), 204, (old: Array): rt.u8 => { - const _6: Array = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: Array = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: Array = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: Array = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: Array = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: Array = make(b); + rs.byteVecPush(out, option_mapOr$182mz1d(rs.hashInsert(values, _51, _53), 204, (old: Array): rs.u8 => { + const _6: Array = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: Array = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: Array = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: Array = make(rt.u8Div(b, 2)); - const _67: rt.Entry, rt.u8> = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry, rt.u8> = _67; - const _82: Array = rt.entryKey(v); - const _85: Array = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: Array = make(rs.u8Div(b, 2)); + const _67: rs.Entry, rs.u8> = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry, rs.u8> = _67; + const _82: Array = rs.entryKey(v); + const _85: Array = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: Array = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: Array = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: Array = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: Array = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: Array = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: Array = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$187k0x1(rt.hashGetKeyValue(map, _134), 221, (_2: [Array, rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: Array = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: Array = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: Array = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: Array = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: Array = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: Array = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$1rph82m(rs.hashGetKeyValue(map, _134), 221, (_2: [Array, rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$187k0x1(rt.btreeGetKeyValue(tree, key), 221, (_22: [Array, rt.u8]): rt.u8 => { - const _5: Array = rt.sliceRange(_22[0], 0); - const _63: Array = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1rph82m(rs.btreeGetKeyValue(tree, key), 221, (_22: [Array, rs.u8]): rs.u8 => { + const _5: Array = rs.sliceRange(_22[0], 0); + const _63: Array = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: Array = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$1bumeih(rt.hashKey(set, _147), 221, (k: Array): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$1bumeih(rt.hashGet(values, b2), 221, (v2: Array): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: Array = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$182mz1d(rs.hashKey(set, _147), 221, (k: Array): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$182mz1d(rs.hashGet(values, b2), 221, (v2: Array): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: Array } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: Array): rt.u8 => { - const order = rt.cmpSlice(rt.cmpOption(rt.cmp))(k2, key); + const _162: { end: Array } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: Array): rs.u8 => { + const order = rs.cmpSlice(rs.cmpOption(rs.cmp))(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Unbounded" } as rt.RangeBound>, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound>]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Unbounded" } as rs.RangeBound>, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound>]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec> = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter[]> = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec> = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter[]> = rs.sliceWindows(keys.items, 2); while (true) { - const _206: Array[] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: Array[] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: Array = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: Array = _206[0]; - rt.idx(_206, 1); - const _596: Array = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmpOption(rt.cmp))(_595, _596); - rt.idx(_206, 0); - const _236: Array = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: Array = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmpOption(rt.cmp))(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$187k0x1(rt.btreeFirst(tree), 221, (_24: [Array, rt.u8]): rt.u8 => { - const _83: Array | undefined = _24[0]; - const _102: Array | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: Array = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: Array = _206[0]; + rs.idx(_206, 1); + const _596: Array = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmpOption(rs.cmp))(_595, _596); + rs.idx(_206, 0); + const _236: Array = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: Array = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmpOption(rs.cmp))(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$1rph82m(rs.btreeFirst(tree), 221, (_24: [Array, rs.u8]): rs.u8 => { + const _83: Array | undefined = _24[0]; + const _102: Array | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$1bumeih(rt.btreeFirstKey(ordered, true), 221, (k3: Array): rt.u8 => { - const _57: Array | undefined = k3; - const _84: Array | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$182mz1d(rs.btreeFirstKey(ordered, true), 221, (k3: Array): rs.u8 => { + const _57: Array | undefined = k3; + const _84: Array | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: Array = make(part10); - const _268: Array = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$187k0x1(rt.hashRemoveEntry(map, probe), 238, (_26: [Array, rt.u8]): rt.u8 => { - const k4: Array = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: Array = make(part10); + const _268: Array = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$1rph82m(rs.hashRemoveEntry(map, probe), 238, (_26: [Array, rs.u8]): rs.u8 => { + const k4: Array = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: Array = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: Array = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: Array = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$1bumeih(rt.btreePopKey(ordered), 221, (k5: Array): rt.u8 => { - return rt.cmpSlice(rt.cmpOption(rt.cmp))(k5, probe) === -1 ? 1 : 0; + const _281: Array = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: Array = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: Array = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$182mz1d(rs.btreePopKey(ordered), 221, (k5: Array): rs.u8 => { + return rs.cmpSlice(rs.cmpOption(rs.cmp))(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: Array, v4: rt.Place): boolean => { - const _512: Array = rt.sliceRange(k6, 0); - const _611: Array = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_512, _611); + rs.btreeRetainMut(tree, (k6: Array, v4: rs.Place): boolean => { + const _512: Array = rs.sliceRange(k6, 0); + const _611: Array = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Array => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Array => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet> = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>, _330, true, undefined, undefined, 4, true); - const _335: [Array, rt.u8][] = [[make(0), 1] as [Array, rt.u8], [make(1), 2] as [Array, rt.u8]]; - const counts: rt.HashMap, rt.u8> = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); - for (const b3 of rt.byteSliceView(data)) { - const _354: Array = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: Array = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmpOption(rs.cmp))) as rs.BTreeSet>, _330, true, undefined, undefined, 4, true); + const _335: [Array, rs.u8][] = [[make(0), 1] as [Array, rs.u8], [make(1), 2] as [Array, rs.u8]]; + const counts: rs.HashMap, rs.u8> = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashSlice(rs.hashOption(rs.hash8)), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>, rs.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rs.byteSliceView(data)) { + const _354: Array = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: Array = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: Array = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: Array = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[Array, rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[Array, rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmpOption(rt.cmp)), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [Array, rt.u8]): rt.u8 => { - const k7: Array = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[Array, rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[Array, rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmpOption(rs.cmp)), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [Array, rs.u8]): rs.u8 => { + const k7: Array = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet> = rt.btreeClone(made, undefined, undefined); - const _405: Array = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet> = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: Array): boolean => { - const _315: Array = rt.sliceRange(k8, 0); - const _411: Array = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmpOption(rt.cmp))(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet> = rs.btreeClone(made, undefined, undefined); + const _405: Array = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet> = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: Array): boolean => { + const _315: Array = rs.sliceRange(k8, 0); + const _411: Array = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmpOption(rs.cmp))(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, Array], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, Array], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])) as rt.BTreeMap<[rt.u8, Array], rt.u8>; - const options: rt.HashSet | undefined> = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hashOption(rt.hash8))), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet | undefined>; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hashOption(rt.hash8)), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmpOption(rt.cmp))) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, Array], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Array], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmpOption(rs.cmp))])) as rs.BTreeMap<[rs.u8, Array], rs.u8>; + const options: rs.HashSet | undefined> = rs.hashNew(rs.hashing(rs.hashOption(rs.hashSlice(rs.hashOption(rs.hash8))), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet | undefined>; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashSlice(rs.hashOption(rs.hash8)), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmpOption(rs.cmp))) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, Array] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, Array] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, Array], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, Array] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, Array], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmpOption(rt.cmp))])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: Array | undefined = then$0b2eeh4(rt.u8Rem(b4, 3) !== 0, (): Array => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, Array] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, Array] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, Array], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmpOption(rs.cmp))])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, Array] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, Array], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmpOption(rs.cmp))])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: Array | undefined = then$0t1jhx5(rs.u8Rem(b4, 3) !== 0, (): Array => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: Array = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: Array = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: Array = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound>, rt.RangeBound>] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound>, { tag: "Unbounded" } as rt.RangeBound>]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u8 | undefined | rt.None => { - return rt.sliceFirst(make(_215), rt.None); - }, rt.None), "next", 2); - const _560: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const key2: Array = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: Array = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: Array = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound>, rs.RangeBound>] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound>, { tag: "Unbounded" } as rs.RangeBound>]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u8 | undefined | rs.None => { + return rs.sliceFirst(make(_215), rs.None); + }, rs.None), "next", 2); + const _560: rs.Iter<[rs.u8 | undefined, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.u8 | undefined | rt.None = rt.sliceFirst(make(_572), rt.None); - if (_576 !== rt.None) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + const _576: rs.u8 | undefined | rs.None = rs.sliceFirst(make(_572), rs.None); + if (_576 !== rs.None) { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$bool_2_keys_arrays_closure4(data: rt.ByteSlice, make: (a0: rt.u8) => boolean[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$bool_2_keys_arrays_closure4(data: rs.ByteSlice, make: (a0: rs.u8) => boolean[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash8), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash8), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; const _23: boolean[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); const _30: boolean[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); const _38: boolean[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; const _44: boolean[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); const _53: boolean[] = make(b); - rt.byteVecPush(out, option_mapOr$0qqhf4e(rt.hashInsert(values, _51, _53), 204, (old: boolean[]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.hashInsert(values, _51, _53), 204, (old: boolean[]): rs.u8 => { const _6: boolean[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: boolean[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: boolean[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: boolean[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: boolean[] = rt.entryKey(v); - const _85: boolean[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: boolean[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: boolean[] = rs.entryKey(v); + const _85: boolean[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; + const b2: rs.u8 = _95; const key: boolean[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: boolean[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: boolean[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: boolean[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: boolean[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: boolean[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$13q9j26(rt.hashGetKeyValue(map, _134), 221, (_2: [boolean[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: boolean[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: boolean[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: boolean[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: boolean[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: boolean[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$1ruj5y1(rs.hashGetKeyValue(map, _134), 221, (_2: [boolean[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$13q9j26(rt.btreeGetKeyValue(tree, key), 221, (_22: [boolean[], rt.u8]): rt.u8 => { - const _5: boolean[] = rt.sliceRange(_22[0], 0); - const _63: boolean[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1ruj5y1(rs.btreeGetKeyValue(tree, key), 221, (_22: [boolean[], rs.u8]): rs.u8 => { + const _5: boolean[] = rs.sliceRange(_22[0], 0); + const _63: boolean[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: boolean[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0qqhf4e(rt.hashKey(set, _147), 221, (k: boolean[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$0qqhf4e(rt.hashGet(values, b2), 221, (v2: boolean[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: boolean[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0ucpmcy(rs.hashKey(set, _147), 221, (k: boolean[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$0ucpmcy(rs.hashGet(values, b2), 221, (v2: boolean[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); const _162: { end: boolean[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: boolean[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: boolean[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: boolean[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: boolean[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); + rs.idx(_206, 0); + rs.idx(_206, 1); const _594: boolean[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); const _595: boolean[] = _206[0]; - rt.idx(_206, 1); + rs.idx(_206, 1); const _596: boolean[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: boolean[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: boolean[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$13q9j26(rt.btreeFirst(tree), 221, (_24: [boolean[], rt.u8]): rt.u8 => { + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: boolean[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: boolean[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$1ruj5y1(rs.btreeFirst(tree), 221, (_24: [boolean[], rs.u8]): rs.u8 => { const _83: boolean[] | undefined = _24[0]; - const _102: boolean[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + const _102: boolean[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$0qqhf4e(rt.btreeFirstKey(ordered, true), 221, (k3: boolean[]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.btreeFirstKey(ordered, true), 221, (k3: boolean[]): rs.u8 => { const _57: boolean[] | undefined = k3; - const _84: boolean[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + const _84: boolean[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: boolean[] = make(part10); - const _268: boolean[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$13q9j26(rt.hashRemoveEntry(map, probe), 238, (_26: [boolean[], rt.u8]): rt.u8 => { + const _268: boolean[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$1ruj5y1(rs.hashRemoveEntry(map, probe), 238, (_26: [boolean[], rs.u8]): rs.u8 => { const k4: boolean[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: boolean[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: boolean[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: boolean[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$0qqhf4e(rt.btreePopKey(ordered), 221, (k5: boolean[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: boolean[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: boolean[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: boolean[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$0ucpmcy(rs.btreePopKey(ordered), 221, (k5: boolean[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: boolean[], v4: rt.Place): boolean => { - const _512: boolean[] = rt.sliceRange(k6, 0); - const _611: boolean[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: boolean[], v4: rs.Place): boolean => { + const _512: boolean[] = rs.sliceRange(k6, 0); + const _611: boolean[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): boolean[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): boolean[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 2, true); - const _335: [boolean[], rt.u8][] = [[make(0), 1] as [boolean[], rt.u8], [make(1), 2] as [boolean[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); - for (const b3 of rt.byteSliceView(data)) { - const _354: boolean[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: boolean[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 2, true); + const _335: [boolean[], rs.u8][] = [[make(0), 1] as [boolean[], rs.u8], [make(1), 2] as [boolean[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashSlice(rs.hash8), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rs.byteSliceView(data)) { + const _354: boolean[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: boolean[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { const _373: boolean[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[boolean[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[boolean[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [boolean[], rt.u8]): rt.u8 => { + const lent: rs.Vec<[boolean[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[boolean[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [boolean[], rs.u8]): rs.u8 => { const k7: boolean[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: boolean[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: boolean[]): boolean => { - const _315: boolean[] = rt.sliceRange(k8, 0); - const _411: boolean[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: boolean[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: boolean[]): boolean => { + const _315: boolean[] = rs.sliceRange(k8, 0); + const _411: boolean[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, boolean[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, boolean[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, boolean[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash8)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash8), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, boolean[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, boolean[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, boolean[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashSlice(rs.hash8)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash8), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, boolean[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, boolean[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, boolean[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, boolean[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, boolean[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: boolean[] | undefined = then$1ghn4qd(rt.u8Rem(b4, 3) !== 0, (): boolean[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, boolean[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, boolean[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, boolean[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, boolean[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, boolean[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: boolean[] | undefined = then$1ghn4qd(rs.u8Rem(b4, 3) !== 0, (): boolean[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: boolean[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: boolean[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: boolean[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): boolean | undefined => { - return rt.sliceFirst(make(_215)); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: boolean[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: boolean[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): boolean | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 1); - const _560: rt.Iter<[boolean, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[boolean, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: boolean | undefined = rt.sliceFirst(make(_572)); + const _576: boolean | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$char_2_keys_arrays_closure3(data: rt.ByteSlice, make: (a0: rt.u8) => rt.char[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$char_2_keys_arrays_closure3(data: rs.ByteSlice, make: (a0: rs.u8) => rs.char[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash32), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash32), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.char[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.char[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.char[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.char[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.char[] = make(b); - rt.byteVecPush(out, option_mapOr$141aobk(rt.hashInsert(values, _51, _53), 204, (old: rt.char[]): rt.u8 => { - const _6: rt.char[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.char[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.char[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.char[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.char[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.char[] = make(b); + rs.byteVecPush(out, option_mapOr$0187me0(rs.hashInsert(values, _51, _53), 204, (old: rs.char[]): rs.u8 => { + const _6: rs.char[] = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: rt.char[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.char[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.char[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.char[] = rt.entryKey(v); - const _85: rt.char[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.char[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.char[] = rs.entryKey(v); + const _85: rs.char[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.char[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.char[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.char[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.char[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.char[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.char[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$1afbbm4(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.char[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.char[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.char[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.char[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.char[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.char[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.char[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$03xawqj(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.char[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$1afbbm4(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.char[], rt.u8]): rt.u8 => { - const _5: rt.char[] = rt.sliceRange(_22[0], 0); - const _63: rt.char[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$03xawqj(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.char[], rs.u8]): rs.u8 => { + const _5: rs.char[] = rs.sliceRange(_22[0], 0); + const _63: rs.char[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: rt.char[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$141aobk(rt.hashKey(set, _147), 221, (k: rt.char[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$141aobk(rt.hashGet(values, b2), 221, (v2: rt.char[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: rs.char[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0187me0(rs.hashKey(set, _147), 221, (k: rs.char[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$0187me0(rs.hashGet(values, b2), 221, (v2: rs.char[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.char[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.char[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.char[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.char[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.char[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.char[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.char[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.char[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.char[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.char[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.char[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$1afbbm4(rt.btreeFirst(tree), 221, (_24: [rt.char[], rt.u8]): rt.u8 => { - const _83: rt.char[] | undefined = _24[0]; - const _102: rt.char[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.char[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.char[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.char[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.char[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.char[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$03xawqj(rs.btreeFirst(tree), 221, (_24: [rs.char[], rs.u8]): rs.u8 => { + const _83: rs.char[] | undefined = _24[0]; + const _102: rs.char[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$141aobk(rt.btreeFirstKey(ordered, true), 221, (k3: rt.char[]): rt.u8 => { - const _57: rt.char[] | undefined = k3; - const _84: rt.char[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$0187me0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.char[]): rs.u8 => { + const _57: rs.char[] | undefined = k3; + const _84: rs.char[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.char[] = make(part10); - const _268: rt.char[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$1afbbm4(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.char[], rt.u8]): rt.u8 => { - const k4: rt.char[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.char[] = make(part10); + const _268: rs.char[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$03xawqj(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.char[], rs.u8]): rs.u8 => { + const k4: rs.char[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.char[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.char[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.char[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$141aobk(rt.btreePopKey(ordered), 221, (k5: rt.char[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.char[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.char[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.char[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$0187me0(rs.btreePopKey(ordered), 221, (k5: rs.char[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.char[], v4: rt.Place): boolean => { - const _512: rt.char[] = rt.sliceRange(k6, 0); - const _611: rt.char[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.char[], v4: rs.Place): boolean => { + const _512: rs.char[] = rs.sliceRange(k6, 0); + const _611: rs.char[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.char[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.char[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 8, true); - const _335: [rt.char[], rt.u8][] = [[make(0), 1] as [rt.char[], rt.u8], [make(1), 2] as [rt.char[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 117440512); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.char[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.char[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 8, true); + const _335: [rs.char[], rs.u8][] = [[make(0), 1] as [rs.char[], rs.u8], [make(1), 2] as [rs.char[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashSlice(rs.hash32), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 117440512); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.char[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.char[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.char[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.char[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.char[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.char[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.char[], rt.u8]): rt.u8 => { - const k7: rt.char[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.char[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.char[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.char[], rs.u8]): rs.u8 => { + const k7: rs.char[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.char[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.char[]): boolean => { - const _315: rt.char[] = rt.sliceRange(k8, 0); - const _411: rt.char[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.char[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.char[]): boolean => { + const _315: rs.char[] = rs.sliceRange(k8, 0); + const _411: rs.char[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.char[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.char[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.char[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(rt.hash32)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(rt.hash32), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.char[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.char[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashSlice(rs.hash32)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashSlice(rs.hash32), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.char[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.char[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.char[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.char[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.char[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.char[] | undefined = then$1dhbcvy(rt.u8Rem(b4, 3) !== 0, (): rt.char[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.char[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.char[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.char[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.char[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.char[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.char[] | undefined = then$0wesa0o(rs.u8Rem(b4, 3) !== 0, (): rs.char[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.char[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.char[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.char[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.char | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.char[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.char[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.char[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.char | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.char, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.char, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.char | undefined = rt.sliceFirst(make(_572)); + const _576: rs.char | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$i32_2_keys_arrays_closure2(data: rt.ByteSlice, make: (a0: rt.u8) => rt.i32[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$i32_2_keys_arrays_closure2(data: rs.ByteSlice, make: (a0: rs.u8) => rs.i32[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.i32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.i32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.i32[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.i32[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.i32[] = make(b); - rt.byteVecPush(out, option_mapOr$17y4wkx(rt.hashInsert(values, _51, _53), 204, (old: rt.i32[]): rt.u8 => { - const _6: rt.i32[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.i32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.i32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.i32[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.i32[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.i32[] = make(b); + rs.byteVecPush(out, option_mapOr$19cu5pi(rs.hashInsert(values, _51, _53), 204, (old: rs.i32[]): rs.u8 => { + const _6: rs.i32[] = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: rt.i32[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.i32[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.i32[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.i32[] = rt.entryKey(v); - const _85: rt.i32[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.i32[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.i32[] = rs.entryKey(v); + const _85: rs.i32[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.i32[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.i32[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.i32[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.i32[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.i32[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.i32[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$03mkmku(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.i32[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.i32[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.i32[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.i32[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.i32[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.i32[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.i32[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$1r07wd5(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.i32[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$03mkmku(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.i32[], rt.u8]): rt.u8 => { - const _5: rt.i32[] = rt.sliceRange(_22[0], 0); - const _63: rt.i32[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1r07wd5(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.i32[], rs.u8]): rs.u8 => { + const _5: rs.i32[] = rs.sliceRange(_22[0], 0); + const _63: rs.i32[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: rt.i32[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$17y4wkx(rt.hashKey(set, _147), 221, (k: rt.i32[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$17y4wkx(rt.hashGet(values, b2), 221, (v2: rt.i32[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: rs.i32[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$19cu5pi(rs.hashKey(set, _147), 221, (k: rs.i32[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$19cu5pi(rs.hashGet(values, b2), 221, (v2: rs.i32[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.i32[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.i32[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.i32[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.i32[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.i32[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.i32[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.i32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.i32[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.i32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.i32[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.i32[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$03mkmku(rt.btreeFirst(tree), 221, (_24: [rt.i32[], rt.u8]): rt.u8 => { - const _83: rt.i32[] | undefined = _24[0]; - const _102: rt.i32[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.i32[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.i32[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.i32[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.i32[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.i32[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$1r07wd5(rs.btreeFirst(tree), 221, (_24: [rs.i32[], rs.u8]): rs.u8 => { + const _83: rs.i32[] | undefined = _24[0]; + const _102: rs.i32[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$17y4wkx(rt.btreeFirstKey(ordered, true), 221, (k3: rt.i32[]): rt.u8 => { - const _57: rt.i32[] | undefined = k3; - const _84: rt.i32[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$19cu5pi(rs.btreeFirstKey(ordered, true), 221, (k3: rs.i32[]): rs.u8 => { + const _57: rs.i32[] | undefined = k3; + const _84: rs.i32[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.i32[] = make(part10); - const _268: rt.i32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$03mkmku(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.i32[], rt.u8]): rt.u8 => { - const k4: rt.i32[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.i32[] = make(part10); + const _268: rs.i32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$1r07wd5(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.i32[], rs.u8]): rs.u8 => { + const k4: rs.i32[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.i32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.i32[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.i32[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$17y4wkx(rt.btreePopKey(ordered), 221, (k5: rt.i32[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.i32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.i32[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.i32[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$19cu5pi(rs.btreePopKey(ordered), 221, (k5: rs.i32[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.i32[], v4: rt.Place): boolean => { - const _512: rt.i32[] = rt.sliceRange(k6, 0); - const _611: rt.i32[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.i32[], v4: rs.Place): boolean => { + const _512: rs.i32[] = rs.sliceRange(k6, 0); + const _611: rs.i32[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.i32[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.i32[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 8, true); - const _335: [rt.i32[], rt.u8][] = [[make(0), 1] as [rt.i32[], rt.u8], [make(1), 2] as [rt.i32[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 117440512); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.i32[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.i32[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 8, true); + const _335: [rs.i32[], rs.u8][] = [[make(0), 1] as [rs.i32[], rs.u8], [make(1), 2] as [rs.i32[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 117440512); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.i32[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.i32[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.i32[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.i32[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.i32[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.i32[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.i32[], rt.u8]): rt.u8 => { - const k7: rt.i32[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.i32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.i32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.i32[], rs.u8]): rs.u8 => { + const k7: rs.i32[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.i32[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.i32[]): boolean => { - const _315: rt.i32[] = rt.sliceRange(k8, 0); - const _411: rt.i32[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.i32[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.i32[]): boolean => { + const _315: rs.i32[] = rs.sliceRange(k8, 0); + const _411: rs.i32[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.i32[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.i32[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.i32[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashInts(4)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.i32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.i32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.i32[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashInts(4)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.i32[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.i32[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.i32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.i32[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.i32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.i32[] | undefined = then$1nf265w(rt.u8Rem(b4, 3) !== 0, (): rt.i32[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.i32[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.i32[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.i32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.i32[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.i32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.i32[] | undefined = then$05rk6io(rs.u8Rem(b4, 3) !== 0, (): rs.i32[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.i32[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.i32[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.i32[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.i32 | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.i32[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.i32[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.i32[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.i32 | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.i32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.i32, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.i32 | undefined = rt.sliceFirst(make(_572)); + const _576: rs.i32 | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$keys_Hop_2_keys_arrays_closure6(data: rt.ByteSlice, make: (a0: rt.u8) => Hop.Hop[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(Hop.cmp$cmp_Ord)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(Hop.cmp$cmp_Ord)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$keys_Hop_2_keys_arrays_closure6(data: rs.ByteSlice, make: (a0: rs.u8) => Hop.Hop[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined), rs.eqSlice(Hop.eq$cmp_PartialEq))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(Hop.cmp$cmp_Ord)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined), rs.eqSlice(Hop.eq$cmp_PartialEq))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(Hop.cmp$cmp_Ord)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; const _23: Hop.Hop[] = copy$array_keys_Hop(make(b)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); const _30: Hop.Hop[] = copy$array_keys_Hop(make(b)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); const _38: Hop.Hop[] = copy$array_keys_Hop(make(b)); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; const _44: Hop.Hop[] = copy$array_keys_Hop(make(b)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); const _53: Hop.Hop[] = copy$array_keys_Hop(make(b)); - rt.byteVecPush(out, option_mapOr$0rtxftk(rt.hashInsert(values, _51, _53), 204, (old: Hop.Hop[]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0kbx53k(rs.hashInsert(values, _51, _53), 204, (old: Hop.Hop[]): rs.u8 => { const _6: Hop.Hop[] = make(b); - return rt.eqSlice(Hop.eq$cmp_PartialEq)(old, _6) ? 1 : 0; + return rs.eqSlice(Hop.eq$cmp_PartialEq)(old, _6) ? 1 : 0; })); - const _62: Hop.Hop[] = copy$array_keys_Hop(make(rt.u8Div(b, 2))); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: Hop.Hop[] = copy$array_keys_Hop(make(rs.u8Div(b, 2))); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: Hop.Hop[] = copy$array_keys_Hop(make(rt.u8Div(b, 2))); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: Hop.Hop[] = rt.entryKey(v); - const _85: Hop.Hop[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(Hop.eq$cmp_PartialEq)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: Hop.Hop[] = copy$array_keys_Hop(make(rs.u8Div(b, 2))); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: Hop.Hop[] = rs.entryKey(v); + const _85: Hop.Hop[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(Hop.eq$cmp_PartialEq)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; + const b2: rs.u8 = _95; const key: Hop.Hop[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: Hop.Hop[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: Hop.Hop[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: Hop.Hop[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: Hop.Hop[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: Hop.Hop[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$0spovx0(rt.hashGetKeyValue(map, _134), 221, (_2: [Hop.Hop[], rt.u8]): rt.u8 => { - return rt.eqSlice(Hop.eq$cmp_PartialEq)(_2[0], key) ? 1 : 0; + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: Hop.Hop[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: Hop.Hop[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: Hop.Hop[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: Hop.Hop[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: Hop.Hop[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$03hkgbr(rs.hashGetKeyValue(map, _134), 221, (_2: [Hop.Hop[], rs.u8]): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$0spovx0(rt.btreeGetKeyValue(tree, key), 221, (_22: [Hop.Hop[], rt.u8]): rt.u8 => { - const _5: Hop.Hop[] = rt.sliceRange(_22[0], 0); - const _63: Hop.Hop[] = rt.sliceRange(key, 0); - return rt.eqSlice(Hop.eq$cmp_PartialEq)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$03hkgbr(rs.btreeGetKeyValue(tree, key), 221, (_22: [Hop.Hop[], rs.u8]): rs.u8 => { + const _5: Hop.Hop[] = rs.sliceRange(_22[0], 0); + const _63: Hop.Hop[] = rs.sliceRange(key, 0); + return rs.eqSlice(Hop.eq$cmp_PartialEq)(_5, _63) ? 1 : 0; }); - const _147: Hop.Hop[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0rtxftk(rt.hashKey(set, _147), 221, (k: Hop.Hop[]): rt.u8 => { - return rt.eqSlice(Hop.eq$cmp_PartialEq)(k, key) ? 1 : 0; - }), option_mapOr$0rtxftk(rt.hashGet(values, b2), 221, (v2: Hop.Hop[]): rt.u8 => { - return rt.eqSlice(Hop.eq$cmp_PartialEq)(v2, key) ? 1 : 0; + const _147: Hop.Hop[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0kbx53k(rs.hashKey(set, _147), 221, (k: Hop.Hop[]): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(k, key) ? 1 : 0; + }), option_mapOr$0kbx53k(rs.hashGet(values, b2), 221, (v2: Hop.Hop[]): rs.u8 => { + return rs.eqSlice(Hop.eq$cmp_PartialEq)(v2, key) ? 1 : 0; }))), undefined, true); const _162: { end: Hop.Hop[] } = { end: copy$array_keys_Hop(copy$array_keys_Hop(key)) }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162, rt.eqSlice(Hop.eq$cmp_PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170, rt.eqSlice(Hop.eq$cmp_PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key), rt.eqSlice(Hop.eq$cmp_PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), (k2: Hop.Hop[]): rt.u8 => { - const order = rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k2, key); + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key), rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd))), (k2: Hop.Hop[]): rs.u8 => { + const order = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189, rt.eqSlice(Hop.eq$cmp_PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: Hop.Hop[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: Hop.Hop[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); + rs.idx(_206, 0); + rs.idx(_206, 1); const _594: Hop.Hop[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); + const _212: rs.u8 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); const _595: Hop.Hop[] = _206[0]; - rt.idx(_206, 1); + rs.idx(_206, 1); const _596: Hop.Hop[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(Hop.cmp$cmp_Ord)(_595, _596); - rt.idx(_206, 0); - const _236: Hop.Hop[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: Hop.Hop[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(Hop.cmp$cmp_Ord)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$0spovx0(rt.btreeFirst(tree), 221, (_24: [Hop.Hop[], rt.u8]): rt.u8 => { + const _227: rs.Ordering = rs.cmpSlice(Hop.cmp$cmp_Ord)(_595, _596); + rs.idx(_206, 0); + const _236: Hop.Hop[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: Hop.Hop[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(Hop.cmp$cmp_Ord)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$03hkgbr(rs.btreeFirst(tree), 221, (_24: [Hop.Hop[], rs.u8]): rs.u8 => { const _83: Hop.Hop[] | undefined = _24[0]; - const _102: Hop.Hop[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(Hop.eq$cmp_PartialEq))(_83, _102) ? 1 : 0) ^ _24[1]; + const _102: Hop.Hop[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$0rtxftk(rt.btreeFirstKey(ordered, true), 221, (k3: Hop.Hop[]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0kbx53k(rs.btreeFirstKey(ordered, true), 221, (k3: Hop.Hop[]): rs.u8 => { const _57: Hop.Hop[] | undefined = k3; - const _84: Hop.Hop[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(Hop.eq$cmp_PartialEq))(_57, _84) ? 1 : 0; + const _84: Hop.Hop[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const probe: Hop.Hop[] = make(part10); - const _268: Hop.Hop[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$0spovx0(rt.hashRemoveEntry(map, probe), 238, (_26: [Hop.Hop[], rt.u8]): rt.u8 => { + const _268: Hop.Hop[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$03hkgbr(rs.hashRemoveEntry(map, probe), 238, (_26: [Hop.Hop[], rs.u8]): rs.u8 => { const k4: Hop.Hop[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(Hop.eq$cmp_PartialEq)(k4, probe) ? 1 : 0) ^ v3; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(Hop.eq$cmp_PartialEq)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: Hop.Hop[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: Hop.Hop[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: Hop.Hop[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$0rtxftk(rt.btreePopKey(ordered), 221, (k5: Hop.Hop[]): rt.u8 => { - return rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k5, probe) === -1 ? 1 : 0; + const _281: Hop.Hop[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: Hop.Hop[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: Hop.Hop[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$0kbx53k(rs.btreePopKey(ordered), 221, (k5: Hop.Hop[]): rs.u8 => { + return rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: Hop.Hop[], v4: rt.Place): boolean => { - const _512: Hop.Hop[] = rt.sliceRange(k6, 0); - const _611: Hop.Hop[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_512, _611); + rs.btreeRetainMut(tree, (k6: Hop.Hop[], v4: rs.Place): boolean => { + const _512: Hop.Hop[] = rs.sliceRange(k6, 0); + const _611: Hop.Hop[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): Hop.Hop[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): Hop.Hop[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(Hop.cmp$cmp_Ord)) as rt.BTreeSet, _330, true, undefined, undefined, 16, true); - const _335: [Hop.Hop[], rt.u8][] = [[copy$array_keys_Hop(make(0)), 1] as [Hop.Hop[], rt.u8], [copy$array_keys_Hop(make(1)), 2] as [Hop.Hop[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 58720256); - for (const b3 of rt.byteSliceView(data)) { - const _354: Hop.Hop[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: Hop.Hop[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(Hop.cmp$cmp_Ord)) as rs.BTreeSet, _330, true, undefined, undefined, 16, true); + const _335: [Hop.Hop[], rs.u8][] = [[copy$array_keys_Hop(make(0)), 1] as [Hop.Hop[], rs.u8], [copy$array_keys_Hop(make(1)), 2] as [Hop.Hop[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined), rs.eqSlice(Hop.eq$cmp_PartialEq))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 58720256); + for (const b3 of rs.byteSliceView(data)) { + const _354: Hop.Hop[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: Hop.Hop[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { const _373: Hop.Hop[] = copy$array_keys_Hop(make(b3)); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[Hop.Hop[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[Hop.Hop[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [Hop.Hop[], rt.u8]): rt.u8 => { + const lent: rs.Vec<[Hop.Hop[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[Hop.Hop[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [Hop.Hop[], rs.u8]): rs.u8 => { const k7: Hop.Hop[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, copy$array_keys_Hop, undefined); - const _405: Hop.Hop[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: Hop.Hop[]): boolean => { - const _315: Hop.Hop[] = rt.sliceRange(k8, 0); - const _411: Hop.Hop[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, copy$array_keys_Hop, undefined); + const _405: Hop.Hop[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: Hop.Hop[]): boolean => { + const _315: Hop.Hop[] = rs.sliceRange(k8, 0); + const _411: Hop.Hop[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, Hop.Hop[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, Hop.Hop[]], rt.Ordering>([rt.cmp, rt.cmpSlice(Hop.cmp$cmp_Ord)])) as rt.BTreeMap<[rt.u8, Hop.Hop[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined)), rt.eqOption(rt.eqSlice(Hop.eq$cmp_PartialEq)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined), rt.eqSlice(Hop.eq$cmp_PartialEq))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(Hop.cmp$cmp_Ord)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, Hop.Hop[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, Hop.Hop[]], rs.Ordering>([rs.cmp, rs.cmpSlice(Hop.cmp$cmp_Ord)])) as rs.BTreeMap<[rs.u8, Hop.Hop[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined)), rs.eqOption(rs.eqSlice(Hop.eq$cmp_PartialEq)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashSlice(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined), rs.eqSlice(Hop.eq$cmp_PartialEq))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(Hop.cmp$cmp_Ord)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, Hop.Hop[]] = [rt.u8Rem(b4, 2), copy$array_keys_Hop(make(b4))]; - const _452: [rt.u8, Hop.Hop[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, Hop.Hop[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, Hop.Hop[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, Hop.Hop[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: Hop.Hop[] | undefined = copy$Option_array2_keys_Hop(then$1c9ust9(rt.u8Rem(b4, 3) !== 0, (): Hop.Hop[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, Hop.Hop[]] = [rs.u8Rem(b4, 2), copy$array_keys_Hop(make(b4))]; + const _452: [rs.u8, Hop.Hop[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, Hop.Hop[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, Hop.Hop[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, Hop.Hop[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: Hop.Hop[] | undefined = copy$Option_array2_keys_Hop(then$1c9ust9(rs.u8Rem(b4, 3) !== 0, (): Hop.Hop[] => { return make(b4); })); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).map(copy$keys_Hop)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).map(copy$keys_Hop)); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).map(copy$keys_Hop)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).map(copy$keys_Hop)); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { const key2: Hop.Hop[] = make(_513); const _526: Hop.Hop[] | undefined = copy$array_keys_Hop(key2); - const _522: rt.u8 = rt.hashContains(options, _526) ? 1 : 0; - const _533: Hop.Hop[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: Hop.Hop[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>, rt.eqSlice(Hop.eq$cmp_PartialEq), rt.cmpGt(rt.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): Hop.Hop | undefined => { - return copy$Option_keys_Hop(rt.sliceFirst(make(_215))); + const _522: rs.u8 = rs.hashContains(options, _526) ? 1 : 0; + const _533: Hop.Hop[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: Hop.Hop[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>, rs.eqSlice(Hop.eq$cmp_PartialEq), rs.cmpGt(rs.cmpSlice(Hop.partialCmp$cmp_PartialOrd)))) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): Hop.Hop | undefined => { + return copy$Option_keys_Hop(rs.sliceFirst(make(_215))); }), "next", 8); - const _560: rt.Iter<[Hop.Hop, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(Hop.cmp$cmp_Ord) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rt.Hasher) => undefined, Hop.eq$cmp_PartialEq)) as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[Hop.Hop, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(Hop.cmp$cmp_Ord) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Hop.hash$Hash_hash_DefaultHasher as (a0: Hop.Hop, a1: rs.Hasher) => undefined, Hop.eq$cmp_PartialEq)) as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: Hop.Hop | undefined = rt.sliceFirst(make(_572)); + const _576: Hop.Hop | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u16_2_keys_arrays_closure0(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u16[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInts(2), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashInts(2), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$u16_2_keys_arrays_closure0(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u16[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashInts(2), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashInts(2), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.u16[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.u16[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.u16[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.u16[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.u16[] = make(b); - rt.byteVecPush(out, option_mapOr$1kiffmd(rt.hashInsert(values, _51, _53), 204, (old: rt.u16[]): rt.u8 => { - const _6: rt.u16[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.u16[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.u16[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.u16[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.u16[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.u16[] = make(b); + rs.byteVecPush(out, option_mapOr$13ci3um(rs.hashInsert(values, _51, _53), 204, (old: rs.u16[]): rs.u8 => { + const _6: rs.u16[] = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: rt.u16[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.u16[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.u16[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.u16[] = rt.entryKey(v); - const _85: rt.u16[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.u16[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.u16[] = rs.entryKey(v); + const _85: rs.u16[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.u16[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.u16[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.u16[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.u16[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.u16[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.u16[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$0iyypgq(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u16[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.u16[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.u16[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.u16[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.u16[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.u16[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.u16[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$0uf63ye(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.u16[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$0iyypgq(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u16[], rt.u8]): rt.u8 => { - const _5: rt.u16[] = rt.sliceRange(_22[0], 0); - const _63: rt.u16[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0uf63ye(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u16[], rs.u8]): rs.u8 => { + const _5: rs.u16[] = rs.sliceRange(_22[0], 0); + const _63: rs.u16[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: rt.u16[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$1kiffmd(rt.hashKey(set, _147), 221, (k: rt.u16[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$1kiffmd(rt.hashGet(values, b2), 221, (v2: rt.u16[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: rs.u16[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$13ci3um(rs.hashKey(set, _147), 221, (k: rs.u16[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$13ci3um(rs.hashGet(values, b2), 221, (v2: rs.u16[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.u16[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u16[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.u16[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u16[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.u16[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.u16[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.u16[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.u16[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.u16[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.u16[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.u16[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$0iyypgq(rt.btreeFirst(tree), 221, (_24: [rt.u16[], rt.u8]): rt.u8 => { - const _83: rt.u16[] | undefined = _24[0]; - const _102: rt.u16[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.u16[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.u16[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.u16[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.u16[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.u16[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$0uf63ye(rs.btreeFirst(tree), 221, (_24: [rs.u16[], rs.u8]): rs.u8 => { + const _83: rs.u16[] | undefined = _24[0]; + const _102: rs.u16[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$1kiffmd(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u16[]): rt.u8 => { - const _57: rt.u16[] | undefined = k3; - const _84: rt.u16[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$13ci3um(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u16[]): rs.u8 => { + const _57: rs.u16[] | undefined = k3; + const _84: rs.u16[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.u16[] = make(part10); - const _268: rt.u16[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$0iyypgq(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u16[], rt.u8]): rt.u8 => { - const k4: rt.u16[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.u16[] = make(part10); + const _268: rs.u16[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$0uf63ye(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u16[], rs.u8]): rs.u8 => { + const k4: rs.u16[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.u16[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.u16[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.u16[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$1kiffmd(rt.btreePopKey(ordered), 221, (k5: rt.u16[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.u16[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.u16[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.u16[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$13ci3um(rs.btreePopKey(ordered), 221, (k5: rs.u16[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.u16[], v4: rt.Place): boolean => { - const _512: rt.u16[] = rt.sliceRange(k6, 0); - const _611: rt.u16[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.u16[], v4: rs.Place): boolean => { + const _512: rs.u16[] = rs.sliceRange(k6, 0); + const _611: rs.u16[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u16[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.u16[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 4, true); - const _335: [rt.u16[], rt.u8][] = [[make(0), 1] as [rt.u16[], rt.u8], [make(1), 2] as [rt.u16[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(2), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.u16[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.u16[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 4, true); + const _335: [rs.u16[], rs.u8][] = [[make(0), 1] as [rs.u16[], rs.u8], [make(1), 2] as [rs.u16[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(2), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.u16[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.u16[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.u16[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.u16[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.u16[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.u16[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.u16[], rt.u8]): rt.u8 => { - const k7: rt.u16[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.u16[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.u16[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u16[], rs.u8]): rs.u8 => { + const k7: rs.u16[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.u16[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u16[]): boolean => { - const _315: rt.u16[] = rt.sliceRange(k8, 0); - const _411: rt.u16[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.u16[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u16[]): boolean => { + const _315: rs.u16[] = rs.sliceRange(k8, 0); + const _411: rs.u16[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.u16[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u16[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u16[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashInts(2)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashInts(2), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.u16[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u16[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u16[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashInts(2)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashInts(2), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.u16[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.u16[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.u16[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.u16[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.u16[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.u16[] | undefined = then$0l07w38(rt.u8Rem(b4, 3) !== 0, (): rt.u16[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.u16[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.u16[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.u16[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.u16[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.u16[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.u16[] | undefined = then$1ko5lpm(rs.u8Rem(b4, 3) !== 0, (): rs.u16[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.u16[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.u16[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.u16[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u16 | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.u16[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.u16[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.u16[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u16 | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 2); - const _560: rt.Iter<[rt.u16, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.u16, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.u16 | undefined = rt.sliceFirst(make(_572)); + const _576: rs.u16 | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u32_0_keys_arrays_closure7(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$u32_0_keys_arrays_closure7(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u32[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.u32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.u32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.u32[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.u32[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.u32[] = make(b); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.hashInsert(values, _51, _53), 204, (old: rt.u32[]): rt.u8 => { - const _6: rt.u32[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.u32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.u32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.u32[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.u32[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.u32[] = make(b); + rs.byteVecPush(out, option_mapOr$18799n0(rs.hashInsert(values, _51, _53), 204, (old: rs.u32[]): rs.u8 => { + const _6: rs.u32[] = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: rt.u32[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.u32[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.u32[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.u32[] = rt.entryKey(v); - const _85: rt.u32[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.u32[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.u32[] = rs.entryKey(v); + const _85: rs.u32[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.u32[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.u32[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.u32[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.u32[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.u32[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.u32[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$1xwgm12(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u32[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.u32[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.u32[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.u32[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.u32[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.u32[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.u32[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$0ohpdps(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.u32[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$1xwgm12(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u32[], rt.u8]): rt.u8 => { - const _5: rt.u32[] = rt.sliceRange(_22[0], 0); - const _63: rt.u32[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0ohpdps(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u32[], rs.u8]): rs.u8 => { + const _5: rs.u32[] = rs.sliceRange(_22[0], 0); + const _63: rs.u32[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: rt.u32[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$1h1mlmc(rt.hashKey(set, _147), 221, (k: rt.u32[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$1h1mlmc(rt.hashGet(values, b2), 221, (v2: rt.u32[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: rs.u32[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$18799n0(rs.hashKey(set, _147), 221, (k: rs.u32[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$18799n0(rs.hashGet(values, b2), 221, (v2: rs.u32[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.u32[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u32[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.u32[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u32[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.u32[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.u32[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.u32[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.u32[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.u32[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$1xwgm12(rt.btreeFirst(tree), 221, (_24: [rt.u32[], rt.u8]): rt.u8 => { - const _83: rt.u32[] | undefined = _24[0]; - const _102: rt.u32[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.u32[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.u32[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.u32[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.u32[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.u32[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$0ohpdps(rs.btreeFirst(tree), 221, (_24: [rs.u32[], rs.u8]): rs.u8 => { + const _83: rs.u32[] | undefined = _24[0]; + const _102: rs.u32[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u32[]): rt.u8 => { - const _57: rt.u32[] | undefined = k3; - const _84: rt.u32[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$18799n0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u32[]): rs.u8 => { + const _57: rs.u32[] | undefined = k3; + const _84: rs.u32[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.u32[] = make(part10); - const _268: rt.u32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$1xwgm12(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u32[], rt.u8]): rt.u8 => { - const k4: rt.u32[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.u32[] = make(part10); + const _268: rs.u32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$0ohpdps(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u32[], rs.u8]): rs.u8 => { + const k4: rs.u32[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.u32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.u32[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.u32[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.btreePopKey(ordered), 221, (k5: rt.u32[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.u32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.u32[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.u32[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$18799n0(rs.btreePopKey(ordered), 221, (k5: rs.u32[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.u32[], v4: rt.Place): boolean => { - const _512: rt.u32[] = rt.sliceRange(k6, 0); - const _611: rt.u32[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.u32[], v4: rs.Place): boolean => { + const _512: rs.u32[] = rs.sliceRange(k6, 0); + const _611: rs.u32[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u32[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.u32[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 0, true); - const _335: [rt.u32[], rt.u8][] = [[make(0), 1] as [rt.u32[], rt.u8], [make(1), 2] as [rt.u32[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 234881024); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.u32[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.u32[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 0, true); + const _335: [rs.u32[], rs.u8][] = [[make(0), 1] as [rs.u32[], rs.u8], [make(1), 2] as [rs.u32[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 234881024); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.u32[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.u32[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.u32[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.u32[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.u32[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.u32[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.u32[], rt.u8]): rt.u8 => { - const k7: rt.u32[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.u32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u32[], rs.u8]): rs.u8 => { + const k7: rs.u32[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.u32[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u32[]): boolean => { - const _315: rt.u32[] = rt.sliceRange(k8, 0); - const _411: rt.u32[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.u32[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u32[]): boolean => { + const _315: rs.u32[] = rs.sliceRange(k8, 0); + const _411: rs.u32[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashInts(4)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashInts(4)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.u32[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.u32[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.u32[] | undefined = then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.u32[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.u32[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.u32[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.u32[] | undefined = then$1hbi99k(rs.u8Rem(b4, 3) !== 0, (): rs.u32[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.u32[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.u32[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.u32[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.u32[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.u32[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.u32[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u32 | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.u32, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.u32 | undefined = rt.sliceFirst(make(_572)); + const _576: rs.u32 | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u32_275_keys_arrays_closure8(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u32[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$u32_275_keys_arrays_closure8(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u32[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.u32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.u32[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.u32[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.u32[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.u32[] = make(b); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.hashInsert(values, _51, _53), 204, (old: rt.u32[]): rt.u8 => { - const _6: rt.u32[] = make(b); - return rt.eqSlice(rt.same)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.u32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.u32[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.u32[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.u32[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.u32[] = make(b); + rs.byteVecPush(out, option_mapOr$18799n0(rs.hashInsert(values, _51, _53), 204, (old: rs.u32[]): rs.u8 => { + const _6: rs.u32[] = make(b); + return rs.eqSlice(rs.same)(old, _6) ? 1 : 0; })); - const _62: rt.u32[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.u32[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.u32[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.u32[] = rt.entryKey(v); - const _85: rt.u32[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.same)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.u32[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.u32[] = rs.entryKey(v); + const _85: rs.u32[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.same)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.u32[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.u32[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.u32[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.u32[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.u32[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.u32[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$1xwgm12(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u32[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.same)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.u32[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.u32[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.u32[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.u32[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.u32[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.u32[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$0ohpdps(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.u32[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.same)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$1xwgm12(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u32[], rt.u8]): rt.u8 => { - const _5: rt.u32[] = rt.sliceRange(_22[0], 0); - const _63: rt.u32[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.same)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$0ohpdps(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u32[], rs.u8]): rs.u8 => { + const _5: rs.u32[] = rs.sliceRange(_22[0], 0); + const _63: rs.u32[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.same)(_5, _63) ? 1 : 0; }); - const _147: rt.u32[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$1h1mlmc(rt.hashKey(set, _147), 221, (k: rt.u32[]): rt.u8 => { - return rt.eqSlice(rt.same)(k, key) ? 1 : 0; - }), option_mapOr$1h1mlmc(rt.hashGet(values, b2), 221, (v2: rt.u32[]): rt.u8 => { - return rt.eqSlice(rt.same)(v2, key) ? 1 : 0; + const _147: rs.u32[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$18799n0(rs.hashKey(set, _147), 221, (k: rs.u32[]): rs.u8 => { + return rs.eqSlice(rs.same)(k, key) ? 1 : 0; + }), option_mapOr$18799n0(rs.hashGet(values, b2), 221, (v2: rs.u32[]): rs.u8 => { + return rs.eqSlice(rs.same)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.u32[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u32[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.u32[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u32[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.u32[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.u32[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.u32[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.u32[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.u32[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.u32[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.u32[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$1xwgm12(rt.btreeFirst(tree), 221, (_24: [rt.u32[], rt.u8]): rt.u8 => { - const _83: rt.u32[] | undefined = _24[0]; - const _102: rt.u32[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.same))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.u32[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.u32[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.u32[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.u32[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.u32[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$0ohpdps(rs.btreeFirst(tree), 221, (_24: [rs.u32[], rs.u8]): rs.u8 => { + const _83: rs.u32[] | undefined = _24[0]; + const _102: rs.u32[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.same))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u32[]): rt.u8 => { - const _57: rt.u32[] | undefined = k3; - const _84: rt.u32[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.same))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$18799n0(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u32[]): rs.u8 => { + const _57: rs.u32[] | undefined = k3; + const _84: rs.u32[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.same))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.u32[] = make(part10); - const _268: rt.u32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$1xwgm12(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u32[], rt.u8]): rt.u8 => { - const k4: rt.u32[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.same)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.u32[] = make(part10); + const _268: rs.u32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$0ohpdps(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u32[], rs.u8]): rs.u8 => { + const k4: rs.u32[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.same)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.u32[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.u32[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.u32[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$1h1mlmc(rt.btreePopKey(ordered), 221, (k5: rt.u32[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.u32[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.u32[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.u32[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$18799n0(rs.btreePopKey(ordered), 221, (k5: rs.u32[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.u32[], v4: rt.Place): boolean => { - const _512: rt.u32[] = rt.sliceRange(k6, 0); - const _611: rt.u32[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.u32[], v4: rs.Place): boolean => { + const _512: rs.u32[] = rs.sliceRange(k6, 0); + const _611: rs.u32[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u32[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.u32[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 1100, true); - const _335: [rt.u32[], rt.u8][] = [[make(0), 1] as [rt.u32[], rt.u8], [make(1), 2] as [rt.u32[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 917504); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.u32[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.u32[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 1100, true); + const _335: [rs.u32[], rs.u8][] = [[make(0), 1] as [rs.u32[], rs.u8], [make(1), 2] as [rs.u32[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 917504); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.u32[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.u32[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.u32[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.u32[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.u32[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.u32[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.u32[], rt.u8]): rt.u8 => { - const k7: rt.u32[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.u32[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.u32[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u32[], rs.u8]): rs.u8 => { + const k7: rs.u32[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.u32[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u32[]): boolean => { - const _315: rt.u32[] = rt.sliceRange(k8, 0); - const _411: rt.u32[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.u32[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u32[]): boolean => { + const _315: rs.u32[] = rs.sliceRange(k8, 0); + const _411: rs.u32[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u32[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashInts(4)), rt.eqOption(rt.eqSlice(rt.same)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashInts(4), rt.eqSlice(rt.same))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u32[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashInts(4)), rs.eqOption(rs.eqSlice(rs.same)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashInts(4), rs.eqSlice(rs.same))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.u32[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.u32[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.u32[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.u32[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.u32[] | undefined = then$0l8o6jo(rt.u8Rem(b4, 3) !== 0, (): rt.u32[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.u32[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.u32[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.u32[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.u32[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.u32[] | undefined = then$1hbi99k(rs.u8Rem(b4, 3) !== 0, (): rs.u32[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.u32[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.u32[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.u32[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u32 | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.u32[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.u32[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.u32[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u32 | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 4); - const _560: rt.Iter<[rt.u32, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.u32, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.u32 | undefined = rt.sliceFirst(make(_572)); + const _576: rs.u32 | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } /** `arrays` of keys `make` makes of each byte. */ -export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: rt.u8) => rt.u64[], out: rt.ByteVec): void { - let _95!: rt.u8; - let _513!: rt.u8; - let _572!: rt.u8; - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashInts(8), rt.eqSlice(rt.u64Eq))) as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeMap; - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashInts(8), rt.eqSlice(rt.u64Eq))) as rt.HashSet; - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet; - const values: rt.HashMap = rt.hashNew() as rt.HashMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); +export function keyed$u64_2_keys_arrays_closure1(data: rs.ByteSlice, make: (a0: rs.u8) => rs.u64[], out: rs.ByteVec): void { + let _95!: rs.u8; + let _513!: rs.u8; + let _572!: rs.u8; + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashInts(8), rs.eqSlice(rs.u64Eq))) as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeMap; + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashInts(8), rs.eqSlice(rs.u64Eq))) as rs.HashSet; + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet; + const values: rs.HashMap = rs.hashNew() as rs.HashMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _13: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const i: rt.usize = _13[0]; - const b: rt.u8 = _13[1]; - const i2: rt.u8 = i & 0xff; - const _23: rt.u64[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(map, _23, i2), 204)); - const _30: rt.u64[] = make(b); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(tree, _30, i2), 204)); - const _38: rt.u64[] = make(b); - const _35: rt.u8 = rt.hashAdd(set, _38) ? 1 : 0; - const _44: rt.u64[] = make(b); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_35, rt.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); - const _51: rt.u8 = rt.u8Rem(b, 4); - const _53: rt.u64[] = make(b); - rt.byteVecPush(out, option_mapOr$0nlcxqx(rt.hashInsert(values, _51, _53), 204, (old: rt.u64[]): rt.u8 => { - const _6: rt.u64[] = make(b); - return rt.eqSlice(rt.u64Eq)(old, _6) ? 1 : 0; + const i: rs.usize = _13[0]; + const b: rs.u8 = _13[1]; + const i2: rs.u8 = i & 0xff; + const _23: rs.u64[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(map, _23, i2), 204)); + const _30: rs.u64[] = make(b); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(tree, _30, i2), 204)); + const _38: rs.u64[] = make(b); + const _35: rs.u8 = rs.hashAdd(set, _38) ? 1 : 0; + const _44: rs.u64[] = make(b); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_35, rs.btreeAdd(ordered, _44) ? 1 : 0)), undefined, true); + const _51: rs.u8 = rs.u8Rem(b, 4); + const _53: rs.u64[] = make(b); + rs.byteVecPush(out, option_mapOr$07qfnm1(rs.hashInsert(values, _51, _53), 204, (old: rs.u64[]): rs.u8 => { + const _6: rs.u64[] = make(b); + return rs.eqSlice(rs.u64Eq)(old, _6) ? 1 : 0; })); - const _62: rt.u64[] = make(rt.u8Div(b, 2)); - const _59: rt.Place = rt.entryOrInsertMut(rt.entry(map, _62), i2); + const _62: rs.u64[] = make(rs.u8Div(b, 2)); + const _59: rs.Place = rs.entryOrInsertMut(rs.entry(map, _62), i2); _59.v = _59.v ^ 64; - const _69: rt.u64[] = make(rt.u8Div(b, 2)); - const _67: rt.Entry = rt.entry(tree, _69); - if (!rt.entryOccupied(_67)) { - const v: rt.Entry = _67; - const _82: rt.u64[] = rt.entryKey(v); - const _85: rt.u64[] = make(rt.u8Div(b, 2)); - rt.byteVecPush(out, rt.eqSlice(rt.u64Eq)(_82, _85) ? 1 : 0); - rt.entryOrInsertMut(v, i2); + const _69: rs.u64[] = make(rs.u8Div(b, 2)); + const _67: rs.Entry = rs.entry(tree, _69); + if (!rs.entryOccupied(_67)) { + const v: rs.Entry = _67; + const _82: rs.u64[] = rs.entryKey(v); + const _85: rs.u64[] = make(rs.u8Div(b, 2)); + rs.byteVecPush(out, rs.eqSlice(rs.u64Eq)(_82, _85) ? 1 : 0); + rs.entryOrInsertMut(v, i2); } else { - const _76: rt.Place = rt.entryGetMut(_67); + const _76: rs.Place = rs.entryGetMut(_67); _76.v = _76.v ^ 64; } } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 8; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 8; while ((_95 = iterStart++) < iterEnd) { - const b2: rt.u8 = _95; - const key: rt.u64[] = make(b2); - const _104: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, key), 221); - const _113: rt.u64[] = rt.sliceRange(key, 0); - const _109: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(map, _113), 221); - const _119: rt.u64[] = rt.sliceRange(key, 0); - const _115: rt.u8 = option_unwrapOr$0r2bmpr(rt.btreeGet(tree, _119), 221); - const _124: rt.u64[] = rt.sliceRange(key, 0); - const _121: rt.u8 = rt.hashContains(set, _124) ? 1 : 0; - const _129: rt.u64[] = rt.sliceRange(key, 0); - const _126: rt.u8 = rt.btreeContains(ordered, _129) ? 1 : 0; - const _134: rt.u64[] = rt.sliceRange(key, 0); - const _131: rt.u8 = option_mapOr$0vfd25u(rt.hashGetKeyValue(map, _134), 221, (_2: [rt.u64[], rt.u8]): rt.u8 => { - return rt.eqSlice(rt.u64Eq)(_2[0], key) ? 1 : 0; + const b2: rs.u8 = _95; + const key: rs.u64[] = make(b2); + const _104: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, key), 221); + const _113: rs.u64[] = rs.sliceRange(key, 0); + const _109: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(map, _113), 221); + const _119: rs.u64[] = rs.sliceRange(key, 0); + const _115: rs.u8 = option_unwrapOr$1fr498u(rs.btreeGet(tree, _119), 221); + const _124: rs.u64[] = rs.sliceRange(key, 0); + const _121: rs.u8 = rs.hashContains(set, _124) ? 1 : 0; + const _129: rs.u64[] = rs.sliceRange(key, 0); + const _126: rs.u8 = rs.btreeContains(ordered, _129) ? 1 : 0; + const _134: rs.u64[] = rs.sliceRange(key, 0); + const _131: rs.u8 = option_mapOr$1p2t4pe(rs.hashGetKeyValue(map, _134), 221, (_2: [rs.u64[], rs.u8]): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(_2[0], key) ? 1 : 0; }); - const _138: rt.u8 = option_mapOr$0vfd25u(rt.btreeGetKeyValue(tree, key), 221, (_22: [rt.u64[], rt.u8]): rt.u8 => { - const _5: rt.u64[] = rt.sliceRange(_22[0], 0); - const _63: rt.u64[] = rt.sliceRange(key, 0); - return rt.eqSlice(rt.u64Eq)(_5, _63) ? 1 : 0; + const _138: rs.u8 = option_mapOr$1p2t4pe(rs.btreeGetKeyValue(tree, key), 221, (_22: [rs.u64[], rs.u8]): rs.u8 => { + const _5: rs.u64[] = rs.sliceRange(_22[0], 0); + const _63: rs.u64[] = rs.sliceRange(key, 0); + return rs.eqSlice(rs.u64Eq)(_5, _63) ? 1 : 0; }); - const _147: rt.u64[] = rt.sliceRange(key, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$0nlcxqx(rt.hashKey(set, _147), 221, (k: rt.u64[]): rt.u8 => { - return rt.eqSlice(rt.u64Eq)(k, key) ? 1 : 0; - }), option_mapOr$0nlcxqx(rt.hashGet(values, b2), 221, (v2: rt.u64[]): rt.u8 => { - return rt.eqSlice(rt.u64Eq)(v2, key) ? 1 : 0; + const _147: rs.u64[] = rs.sliceRange(key, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_104, _109, _115, _121, _126, _131, _138, option_mapOr$07qfnm1(rs.hashKey(set, _147), 221, (k: rs.u64[]): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(k, key) ? 1 : 0; + }), option_mapOr$07qfnm1(rs.hashGet(values, b2), 221, (v2: rs.u64[]): rs.u8 => { + return rs.eqSlice(rs.u64Eq)(v2, key) ? 1 : 0; }))), undefined, true); - const _162: { end: rt.u64[] } = { end: key }; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _162)) & 0xff); - const _170: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: rt.sliceRange(key, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(tree, _170)) & 0xff); - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.btreeRangeKeys(ordered, new rt.RangeFrom(key)), (k2: rt.u64[]): rt.u8 => { - const order = rt.cmpSlice(rt.cmp)(k2, key); + const _162: { end: rs.u64[] } = { end: key }; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _162)) & 0xff); + const _170: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: rs.sliceRange(key, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(tree, _170)) & 0xff); + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.btreeRangeKeys(ordered, new rs.RangeFrom(key)), (k2: rs.u64[]): rs.u8 => { + const order = rs.cmpSlice(rs.cmp)(k2, key); return order !== undefined && order >= 0 ? 1 : 0; - }), rt.u8Add, 0)); - const _189: [rt.RangeBound, rt.RangeBound] = [{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: rt.sliceRange(key, 0) } as rt.RangeBound]; - rt.byteVecPush(out, rt.iterCount(rt.btreeRangeKeys(ordered, _189)) & 0xff); + }), rs.u8Add, 0)); + const _189: [rs.RangeBound, rs.RangeBound] = [{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: rs.sliceRange(key, 0) } as rs.RangeBound]; + rs.byteVecPush(out, rs.iterCount(rs.btreeRangeKeys(ordered, _189)) & 0xff); } - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(ordered), undefined, 4, true); - const iter3: rt.Iter = rt.sliceWindows(keys.items, 2); + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(ordered), undefined, 4, true); + const iter3: rs.Iter = rs.sliceWindows(keys.items, 2); while (true) { - const _206: rt.u64[][] | rt.Done = iter3.next(); - if (_206 === rt.DONE) { + const _206: rs.u64[][] | rs.Done = iter3.next(); + if (_206 === rs.DONE) { break; } - rt.idx(_206, 0); - rt.idx(_206, 1); - const _594: rt.u64[] = _206[1]; - const _212: rt.u8 = rt.cmpSlice(rt.cmp)(_206[0], _594) === -1 ? 1 : 0; - rt.idx(_206, 0); - const _595: rt.u64[] = _206[0]; - rt.idx(_206, 1); - const _596: rt.u64[] = _206[1]; - const _227: rt.Ordering = rt.cmpSlice(rt.cmp)(_595, _596); - rt.idx(_206, 0); - const _236: rt.u64[] = rt.sliceRange(_206[0], 0); - rt.idx(_206, 1); - const _240: rt.u64[] = rt.sliceRange(_206[1], 0); - rt.byteVecPush(out, _212 | (((_227 === rt.cmpSlice(rt.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); - } - rt.byteVecPush(out, option_mapOr$0vfd25u(rt.btreeFirst(tree), 221, (_24: [rt.u64[], rt.u8]): rt.u8 => { - const _83: rt.u64[] | undefined = _24[0]; - const _102: rt.u64[] | undefined = rt.sliceFirst(keys.items); - return (rt.eqOption(rt.eqSlice(rt.u64Eq))(_83, _102) ? 1 : 0) ^ _24[1]; + rs.idx(_206, 0); + rs.idx(_206, 1); + const _594: rs.u64[] = _206[1]; + const _212: rs.u8 = rs.cmpSlice(rs.cmp)(_206[0], _594) === -1 ? 1 : 0; + rs.idx(_206, 0); + const _595: rs.u64[] = _206[0]; + rs.idx(_206, 1); + const _596: rs.u64[] = _206[1]; + const _227: rs.Ordering = rs.cmpSlice(rs.cmp)(_595, _596); + rs.idx(_206, 0); + const _236: rs.u64[] = rs.sliceRange(_206[0], 0); + rs.idx(_206, 1); + const _240: rs.u64[] = rs.sliceRange(_206[1], 0); + rs.byteVecPush(out, _212 | (((_227 === rs.cmpSlice(rs.cmp)(_236, _240) ? 1 : 0) << 1) & 0xff)); + } + rs.byteVecPush(out, option_mapOr$1p2t4pe(rs.btreeFirst(tree), 221, (_24: [rs.u64[], rs.u8]): rs.u8 => { + const _83: rs.u64[] | undefined = _24[0]; + const _102: rs.u64[] | undefined = rs.sliceFirst(keys.items); + return (rs.eqOption(rs.eqSlice(rs.u64Eq))(_83, _102) ? 1 : 0) ^ _24[1]; })); - rt.byteVecPush(out, option_mapOr$0nlcxqx(rt.btreeFirstKey(ordered, true), 221, (k3: rt.u64[]): rt.u8 => { - const _57: rt.u64[] | undefined = k3; - const _84: rt.u64[] | undefined = rt.sliceLast(keys.items); - return rt.eqOption(rt.eqSlice(rt.u64Eq))(_57, _84) ? 1 : 0; + rs.byteVecPush(out, option_mapOr$07qfnm1(rs.btreeFirstKey(ordered, true), 221, (k3: rs.u64[]): rs.u8 => { + const _57: rs.u64[] | undefined = k3; + const _84: rs.u64[] | undefined = rs.sliceLast(keys.items); + return rs.eqOption(rs.eqSlice(rs.u64Eq))(_57, _84) ? 1 : 0; })); - const part10 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const probe: rt.u64[] = make(part10); - const _268: rt.u64[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(map, _268), 238)); - rt.byteVecPush(out, option_mapOr$0vfd25u(rt.hashRemoveEntry(map, probe), 238, (_26: [rt.u64[], rt.u8]): rt.u8 => { - const k4: rt.u64[] = _26[0]; - const v3: rt.u8 = _26[1]; - return (rt.eqSlice(rt.u64Eq)(k4, probe) ? 1 : 0) ^ v3; + const part10 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const probe: rs.u64[] = make(part10); + const _268: rs.u64[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(map, _268), 238)); + rs.byteVecPush(out, option_mapOr$1p2t4pe(rs.hashRemoveEntry(map, probe), 238, (_26: [rs.u64[], rs.u8]): rs.u8 => { + const k4: rs.u64[] = _26[0]; + const v3: rs.u8 = _26[1]; + return (rs.eqSlice(rs.u64Eq)(k4, probe) ? 1 : 0) ^ v3; })); - const _281: rt.u64[] = rt.sliceRange(probe, 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeRemove(tree, _281), 238)); - const _288: rt.u64[] = rt.sliceRange(probe, 0); - const _285: rt.u8 = rt.hashDelete(set, _288) ? 1 : 0; - const _293: rt.u64[] = rt.sliceRange(probe, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_285, rt.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); - rt.byteVecPush(out, option_mapOr$0nlcxqx(rt.btreePopKey(ordered), 221, (k5: rt.u64[]): rt.u8 => { - return rt.cmpSlice(rt.cmp)(k5, probe) === -1 ? 1 : 0; + const _281: rs.u64[] = rs.sliceRange(probe, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeRemove(tree, _281), 238)); + const _288: rs.u64[] = rs.sliceRange(probe, 0); + const _285: rs.u8 = rs.hashDelete(set, _288) ? 1 : 0; + const _293: rs.u64[] = rs.sliceRange(probe, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_285, rs.btreeDelete(ordered, _293) ? 1 : 0)), undefined, true); + rs.byteVecPush(out, option_mapOr$07qfnm1(rs.btreePopKey(ordered), 221, (k5: rs.u64[]): rs.u8 => { + return rs.cmpSlice(rs.cmp)(k5, probe) === -1 ? 1 : 0; })); - rt.btreeRetainMut(tree, (k6: rt.u64[], v4: rt.Place): boolean => { - const _512: rt.u64[] = rt.sliceRange(k6, 0); - const _611: rt.u64[] = rt.sliceRange(probe, 0); - const order2 = rt.cmpSlice(rt.cmp)(_512, _611); + rs.btreeRetainMut(tree, (k6: rs.u64[], v4: rs.Place): boolean => { + const _512: rs.u64[] = rs.sliceRange(k6, 0); + const _611: rs.u64[] = rs.sliceRange(probe, 0); + const order2 = rs.cmpSlice(rs.cmp)(_512, _611); if (!(order2 !== undefined && order2 >= 0)) { - return rt.u8Rem(v4.v, 2) === 0; + return rs.u8Rem(v4.v, 2) === 0; } return true; }); - rt.iterExtendBytes(out, rt.btreeValues(tree), undefined, true); - const held: rt.ByteVec = rt.iterToByteVec(rt.hashValues(map), "next"); - rt.byteSliceView(rt.byteVecSlice(held)).sort(); - rt.iterExtendBytes(out, rt.byteVecIntoIter(held), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.hashLen(map), rt.btreeLen(tree), rt.hashLen(set), rt.btreeLen(ordered)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.btreeValues(tree), undefined, true); + const held: rs.ByteVec = rs.iterToByteVec(rs.hashValues(map), "next"); + rs.byteSliceView(rs.byteVecSlice(held)).sort(); + rs.iterExtendBytes(out, rs.byteVecIntoIter(held), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.hashLen(map), rs.btreeLen(tree), rs.hashLen(set), rs.btreeLen(ordered)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - const _330: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): rt.u64[] => { - return make(rt.u8Div(_29, 3)); + const _330: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): rs.u64[] => { + return make(rs.u8Div(_29, 3)); }); - const made: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet, _330, true, undefined, undefined, 16, true); - const _335: [rt.u64[], rt.u8][] = [[make(0), 1] as [rt.u64[], rt.u8], [make(1), 2] as [rt.u64[], rt.u8]]; - const counts: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashInts(8), rt.eqSlice(rt.u64Eq))) as rt.HashMap, rt.iterSlice(_335), undefined, undefined, undefined, 58720256); - for (const b3 of rt.byteSliceView(data)) { - const _354: rt.u64[] = rt.sliceRange(make(b3), 0); - rt.byteVecPush(out, rt.hashContains(counts, _354) ? 1 : 0); - const _361: rt.u64[] = rt.sliceRange(make(b3), 0); - const _359: rt.Place | undefined = rt.hashGetMut(counts, _361); + const made: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet, _330, true, undefined, undefined, 16, true); + const _335: [rs.u64[], rs.u8][] = [[make(0), 1] as [rs.u64[], rs.u8], [make(1), 2] as [rs.u64[], rs.u8]]; + const counts: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashInts(8), rs.eqSlice(rs.u64Eq))) as rs.HashMap, rs.iterSlice(_335), undefined, undefined, undefined, 58720256); + for (const b3 of rs.byteSliceView(data)) { + const _354: rs.u64[] = rs.sliceRange(make(b3), 0); + rs.byteVecPush(out, rs.hashContains(counts, _354) ? 1 : 0); + const _361: rs.u64[] = rs.sliceRange(make(b3), 0); + const _359: rs.Place | undefined = rs.hashGetMut(counts, _361); if (_359 === undefined) { - const _373: rt.u64[] = make(b3); - const _370: rt.Place = rt.entryOrInsertWithMut(rt.entry(counts, _373), (): rt.u8 => { + const _373: rs.u64[] = make(b3); + const _370: rs.Place = rs.entryOrInsertWithMut(rs.entry(counts, _373), (): rs.u8 => { return 0; }); - _370.v = rt.u8Add(_370.v, 1); + _370.v = rs.u8Add(_370.v, 1); } else { - _359.v = rt.u8WrappingMul(_359.v, 3); + _359.v = rs.u8WrappingMul(_359.v, 3); } } - const lent: rt.Vec<[rt.u64[], rt.u8]> = rt.iterToVec(rt.hashIter(counts), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.u64[], rt.u8], rt.Ordering | undefined>([rt.cmpSlice(rt.cmp), rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(lent.items), (_210: [rt.u64[], rt.u8]): rt.u8 => { - const k7: rt.u64[] = _210[0]; - const v5: rt.u8 = _210[1]; - return (((rt.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; + const lent: rs.Vec<[rs.u64[], rs.u8]> = rs.iterToVec(rs.hashIter(counts), "next", 8); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.u64[], rs.u8], rs.Ordering | undefined>([rs.cmpSlice(rs.cmp), rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(lent.items), (_210: [rs.u64[], rs.u8]): rs.u8 => { + const k7: rs.u64[] = _210[0]; + const v5: rs.u8 = _210[1]; + return (((rs.btreeContains(made, k7) ? 1 : 0) << 7) & 0xff) | v5; }), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.btreeIntersection(made, ordered)) & 0xff); - rt.byteVecPush(out, rt.btreeIsSubset(made, ordered) ? 1 : 0); - const upper: rt.BTreeSet = rt.btreeClone(made, undefined, undefined); - const _405: rt.u64[] = rt.sliceRange(probe, 0); - const lower: rt.BTreeSet = rt.btreeSplitOff(upper, _405); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(upper) & 0xff, rt.btreeLen(lower) & 0xff)), undefined, true); - rt.byteVecPush(out, rt.iterAll(rt.btreeKeys(lower), (k8: rt.u64[]): boolean => { - const _315: rt.u64[] = rt.sliceRange(k8, 0); - const _411: rt.u64[] = rt.sliceRange(probe, 0); - const order3 = rt.cmpSlice(rt.cmp)(_315, _411); + rs.byteVecPush(out, rs.iterCount(rs.btreeIntersection(made, ordered)) & 0xff); + rs.byteVecPush(out, rs.btreeIsSubset(made, ordered) ? 1 : 0); + const upper: rs.BTreeSet = rs.btreeClone(made, undefined, undefined); + const _405: rs.u64[] = rs.sliceRange(probe, 0); + const lower: rs.BTreeSet = rs.btreeSplitOff(upper, _405); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(upper) & 0xff, rs.btreeLen(lower) & 0xff)), undefined, true); + rs.byteVecPush(out, rs.iterAll(rs.btreeKeys(lower), (k8: rs.u64[]): boolean => { + const _315: rs.u64[] = rs.sliceRange(k8, 0); + const _411: rs.u64[] = rs.sliceRange(probe, 0); + const order3 = rs.cmpSlice(rs.cmp)(_315, _411); return order3 !== undefined && order3 >= 0; }) ? 1 : 0); - const pairs: rt.BTreeMap<[rt.u8, rt.u64[]], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u64[]], rt.Ordering>([rt.cmp, rt.cmpSlice(rt.cmp)])) as rt.BTreeMap<[rt.u8, rt.u64[]], rt.u8>; - const options: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hashInts(8)), rt.eqOption(rt.eqSlice(rt.u64Eq)))) as rt.HashSet; - const vecs: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashInts(8), rt.eqSlice(rt.u64Eq))) as rt.HashMap, rt.u8>; - const lists: rt.BTreeSet> = rt.btreeNew(rt.cmpSlice(rt.cmp)) as rt.BTreeSet>; - const iter5: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const pairs: rs.BTreeMap<[rs.u8, rs.u64[]], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u64[]], rs.Ordering>([rs.cmp, rs.cmpSlice(rs.cmp)])) as rs.BTreeMap<[rs.u8, rs.u64[]], rs.u8>; + const options: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hashInts(8)), rs.eqOption(rs.eqSlice(rs.u64Eq)))) as rs.HashSet; + const vecs: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashInts(8), rs.eqSlice(rs.u64Eq))) as rs.HashMap, rs.u8>; + const lists: rs.BTreeSet> = rs.btreeNew(rs.cmpSlice(rs.cmp)) as rs.BTreeSet>; + const iter5: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _431: [rt.usize, rt.u8] | rt.Done = iter5.next(); - if (_431 === rt.DONE) { + const _431: [rs.usize, rs.u8] | rs.Done = iter5.next(); + if (_431 === rs.DONE) { break; } - const i3: rt.usize = _431[0]; - const b4: rt.u8 = _431[1]; - const pair: [rt.u8, rt.u64[]] = [rt.u8Rem(b4, 2), make(b4)]; - const _452: [rt.u8, rt.u64[]] = [1, make(2)]; - const _444: rt.u8 = ((rt.cmpTuple<[rt.u8, rt.u64[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; - const _462: [rt.u8, rt.u64[]] = [0, make(3)]; - const order4 = rt.cmpTuple<[rt.u8, rt.u64[]], rt.Ordering | undefined>([rt.cmp, rt.cmpSlice(rt.cmp)])(pair, _462); - rt.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(pairs, pair, i3 & 0xff), 204)); - const _476: rt.u64[] | undefined = then$0uovwq9(rt.u8Rem(b4, 3) !== 0, (): rt.u64[] => { + const i3: rs.usize = _431[0]; + const b4: rs.u8 = _431[1]; + const pair: [rs.u8, rs.u64[]] = [rs.u8Rem(b4, 2), make(b4)]; + const _452: [rs.u8, rs.u64[]] = [1, make(2)]; + const _444: rs.u8 = ((rs.cmpTuple<[rs.u8, rs.u64[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _452) === -1 ? 1 : 0) << 1) & 0xff; + const _462: [rs.u8, rs.u64[]] = [0, make(3)]; + const order4 = rs.cmpTuple<[rs.u8, rs.u64[]], rs.Ordering | undefined>([rs.cmp, rs.cmpSlice(rs.cmp)])(pair, _462); + rs.byteVecPush(out, _444 | (order4 !== undefined && order4 <= 0 ? 1 : 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(pairs, pair, i3 & 0xff), 204)); + const _476: rs.u64[] | undefined = then$0zrkb72(rs.u8Rem(b4, 3) !== 0, (): rs.u64[] => { return make(b4); }); - rt.byteVecPush(out, rt.hashAdd(options, _476) ? 1 : 0); - const _487: rt.Vec = rt.vecFrom(make(b4).slice()); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(vecs, _487, i3 & 0xff), 204)); - const _498: rt.Vec = rt.vecFrom(make(rt.u8Div(b4, 2)).slice()); - rt.byteVecPush(out, rt.btreeAdd(lists, _498) ? 1 : 0); - } - rt.iterExtendBytes(out, rt.btreeValues(pairs), undefined, true); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 8; + rs.byteVecPush(out, rs.hashAdd(options, _476) ? 1 : 0); + const _487: rs.Vec = rs.vecFrom(make(b4).slice()); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(vecs, _487, i3 & 0xff), 204)); + const _498: rs.Vec = rs.vecFrom(make(rs.u8Div(b4, 2)).slice()); + rs.byteVecPush(out, rs.btreeAdd(lists, _498) ? 1 : 0); + } + rs.iterExtendBytes(out, rs.btreeValues(pairs), undefined, true); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 8; while ((_513 = iterStart2++) < iterEnd2) { - const key2: rt.u64[] = make(_513); - const _522: rt.u8 = rt.hashContains(options, key2) ? 1 : 0; - const _533: rt.u64[] = rt.sliceRange(key2, 0); - const _529: rt.u8 = option_unwrapOr$0r2bmpr(rt.hashGet(vecs, (_533 as unknown) as rt.Vec), 221); - const _538: rt.u64[] = rt.sliceRange(key2, 0); - const _535: rt.u8 = rt.btreeContains(lists, (_538 as unknown) as rt.Vec) ? 1 : 0; - const _544: [rt.RangeBound, rt.RangeBound] = [{ tag: "Included", _0: rt.sliceRange(key2, 0) } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_522, _529, _535, rt.iterCount(rt.btreeRangeKeys(lists, (_544 as unknown) as rt.Bounds>)) & 0xff)), undefined, true); - } - rt.byteVecPush(out, rt.hashContains(options, undefined) ? 1 : 0); - const firsts: rt.Vec = rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): rt.u64 | undefined => { - return rt.sliceFirst(make(_215)); + const key2: rs.u64[] = make(_513); + const _522: rs.u8 = rs.hashContains(options, key2) ? 1 : 0; + const _533: rs.u64[] = rs.sliceRange(key2, 0); + const _529: rs.u8 = option_unwrapOr$1fr498u(rs.hashGet(vecs, (_533 as unknown) as rs.Vec), 221); + const _538: rs.u64[] = rs.sliceRange(key2, 0); + const _535: rs.u8 = rs.btreeContains(lists, (_538 as unknown) as rs.Vec) ? 1 : 0; + const _544: [rs.RangeBound, rs.RangeBound] = [{ tag: "Included", _0: rs.sliceRange(key2, 0) } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_522, _529, _535, rs.iterCount(rs.btreeRangeKeys(lists, (_544 as unknown) as rs.Bounds>)) & 0xff)), undefined, true); + } + rs.byteVecPush(out, rs.hashContains(options, undefined) ? 1 : 0); + const firsts: rs.Vec = rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): rs.u64 | undefined => { + return rs.sliceFirst(make(_215)); }), "next", 8); - const _560: rt.Iter<[rt.u64, rt.u8]> = rt.iterZip(rt.iterSlice(firsts.items), new rt.RangeFrom(0, rt.u8Step), "len"); - const refs: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); - const _566: rt.Iter = rt.iterSlice(firsts.items); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, _566, undefined, undefined, 234881024); - let iterStart3: rt.u8 = 0; - const iterEnd3: rt.u8 = 8; + const _560: rs.Iter<[rs.u64, rs.u8]> = rs.iterZip(rs.iterSlice(firsts.items), new rs.RangeFrom(0, rs.u8Step), "len"); + const refs: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, undefined, 8, true); + const _566: rs.Iter = rs.iterSlice(firsts.items); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet, _566, undefined, undefined, 234881024); + let iterStart3: rs.u8 = 0; + const iterEnd3: rs.u8 = 8; while ((_572 = iterStart3++) < iterEnd3) { - const _576: rt.u64 | undefined = rt.sliceFirst(make(_572)); + const _576: rs.u64 | undefined = rs.sliceFirst(make(_572)); if (_576 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.btreeGet(refs, _576), 221), rt.hashContains(hashed, _576) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_unwrapOr$1fr498u(rs.btreeGet(refs, _576), 221), rs.hashContains(hashed, _576) ? 1 : 0)), undefined, true); } } } @@ -3946,620 +3946,620 @@ export function keyed$u64_2_keys_arrays_closure1(data: rt.ByteSlice, make: (a0: * references to them, lent to an adaptor's closure as std lends the items it holds, and * held as `&[u8; N]` keys beside `[u8; N]` values. Of two bytes, and of none. */ -export function byteRefs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - if (rt.u8Rem(kind, 2) === 0) { - taken$2_keys_byte_refs_closure0(data, (w: rt.ByteSlice): Uint8Array => { - rt.idx(w, 0); - const _3: rt.u8 = rt.u8Rem(w.data[w.start], 4); - rt.idx(w, 1); - return Uint8Array.of(_3, rt.u8Rem(w.data[w.start + 1], 4)); +export function byteRefs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + if (rs.u8Rem(kind, 2) === 0) { + taken$2_keys_byte_refs_closure0(data, (w: rs.ByteSlice): Uint8Array => { + rs.idx(w, 0); + const _3: rs.u8 = rs.u8Rem(w.data[w.start], 4); + rs.idx(w, 1); + return Uint8Array.of(_3, rs.u8Rem(w.data[w.start + 1], 4)); }, out); } else { - taken$0_keys_byte_refs_closure1(data, (_2: rt.ByteSlice): Uint8Array => { + taken$0_keys_byte_refs_closure1(data, (_2: rs.ByteSlice): Uint8Array => { return Uint8Array.of(); }, out); } } /** `byte_refs` of the arrays `make` makes of each window of two bytes. */ -export function taken$0_keys_byte_refs_closure1(data: rt.ByteSlice, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 0, true); - const vec: rt.Vec = new rt.Vec(); - rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 0, true); - const deque: rt.VecDeque = rt.dequeNew(0) as rt.VecDeque; - const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); - const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 0, true); - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; - rt.hashExtendKeys(set, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, undefined, 536870911); - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const _28: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); - rt.btreeExtendKeys(ordered, rt.iterMap(_28, rt.byteSliceToArray)); - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const _34: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p: rt.ByteSlice): [rt.ByteSlice, rt.ByteSlice] => { - return [p, p] as [rt.ByteSlice, rt.ByteSlice]; +export function taken$0_keys_byte_refs_closure1(data: rs.ByteSlice, make: (a0: rs.ByteSlice) => Uint8Array, out: rs.ByteVec): void { + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), make), undefined, 0, true); + const vec: rs.Vec = new rs.Vec(); + rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 0, true); + const deque: rs.VecDeque = rs.dequeNew(0) as rs.VecDeque; + const _14: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); + rs.dequeExtend(deque, rs.iterMap(_14, rs.byteSliceToArray), undefined, true); + const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 0, true); + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; + rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, undefined, 536870911); + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; + const _28: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); + rs.btreeExtendKeys(ordered, rs.iterMap(_28, rs.byteSliceToArray)); + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): [rs.ByteSlice, rs.ByteSlice] => { + return [p, p] as [rs.ByteSlice, rs.ByteSlice]; }); - rt.hashExtend(map, rt.iterMap(_34, (held): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(held[0]), rt.byteSliceToArray(held[1])]; + rs.hashExtend(map, rs.iterMap(_34, (held): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(held[0]), rs.byteSliceToArray(held[1])]; }), undefined, undefined, undefined, 536870911); - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; - const _41: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), [false, false]); - rt.btreeExtend(tree, rt.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(held2[0]), rt.byteSliceToArray(held2[1])]; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; + const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); + rs.btreeExtend(tree, rs.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(held2[0]), rs.byteSliceToArray(held2[1])]; })); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { - const _51: rt.ByteSlice | rt.Done = iter.next(); - if (_51 === rt.DONE) { + const _51: rs.ByteSlice | rs.Done = iter.next(); + if (_51 === rs.DONE) { break; } - const _55: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_51)); + const _55: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_51)); if (_55 !== undefined) { _55.v = _55.v ^ 16; } } - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom); while (true) { - const _64: rt.ByteSlice | rt.Done = iter2.next(); - if (_64 === rt.DONE) { + const _64: rs.ByteSlice | rs.Done = iter2.next(); + if (_64 === rs.DONE) { break; } - const _68: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_64)); + const _68: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_64)); if (_68 !== undefined) { _68.v = _68.v ^ 32; } } - const iter3: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); + const iter3: rs.Iter = rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom); while (true) { - const _76: rt.ByteSlice | rt.Done = iter3.next(); - if (_76 === rt.DONE) { + const _76: rs.ByteSlice | rs.Done = iter3.next(); + if (_76 === rs.DONE) { break; } - const _80: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_76)); + const _80: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_76)); if (_80 !== undefined) { _80.v = _80.v ^ 64; } } - const iter4: rt.Iter = rt.iterLend(rt.hashValues(map), rt.byteSliceFrom); + const iter4: rs.Iter = rs.iterLend(rs.hashValues(map), rs.byteSliceFrom); while (true) { - const _88: rt.ByteSlice | rt.Done = iter4.next(); - if (_88 === rt.DONE) { + const _88: rs.ByteSlice | rs.Done = iter4.next(); + if (_88 === rs.DONE) { break; } - const _92: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_88)); + const _92: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_88)); if (_92 !== undefined) { _92.v = _92.v ^ 128; } } - const iter5: rt.Iter = rt.iterLend(rt.btreeValues(tree), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterLend(rs.btreeValues(tree), rs.byteSliceFrom); while (true) { - const _100: rt.ByteSlice | rt.Done = iter5.next(); - if (_100 === rt.DONE) { + const _100: rs.ByteSlice | rs.Done = iter5.next(); + if (_100 === rs.DONE) { break; } - const _104: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_100)); + const _104: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_100)); if (_104 !== undefined) { _104.v = _104.v ^ 8; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)).items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const members: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 0); - rt.sliceSort(members.items, rt.cmpLt(rt.cmpBytes), 0, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const entries: rt.Vec<[Uint8Array, Uint8Array]> = rt.iterToVec(rt.iterMap(rt.iterLend(rt.hashIter(map), (held3): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held3[0]), rt.byteSliceFrom(held3[1])]; - }), (_2: [rt.ByteSlice, rt.ByteSlice]): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(_2[0]), rt.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 0); + rs.sliceSort(members.items, rs.cmpLt(rs.cmpBytes), 0, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held3): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held3[0]), rs.byteSliceFrom(held3[1])]; + }), (_2: [rs.ByteSlice, rs.ByteSlice]): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(_2[0]), rs.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; }), "next", 0); - rt.sliceSort(entries.items, rt.cmpLt(rt.cmpTuple<[Uint8Array, Uint8Array], rt.Ordering | undefined>([rt.cmpBytes, rt.cmpBytes])), 0, true); + rs.sliceSort(entries.items, rs.cmpLt(rs.cmpTuple<[Uint8Array, Uint8Array], rs.Ordering | undefined>([rs.cmpBytes, rs.cmpBytes])), 0, true); for (const _155 of entries.items) { - const k: rt.ByteSlice = rt.byteSliceFrom(_155[0]); - const v: rt.ByteSlice = rt.byteSliceFrom(_155[1]); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(k)), rt.iterSlice(rt.byteSliceView(v))), undefined, true); + const k: rs.ByteSlice = rs.byteSliceFrom(_155[0]); + const v: rs.ByteSlice = rs.byteSliceFrom(_155[1]); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(k)), rs.iterSlice(rs.byteSliceView(v))), undefined, true); } - const iter7: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held4): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held4[0]), rt.byteSliceFrom(held4[1])]; + const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held4): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held4[0]), rs.byteSliceFrom(held4[1])]; }); while (true) { - const _167: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter7.next(); - if (_167 === rt.DONE) { + const _167: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter7.next(); + if (_167 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_167[0])), rt.iterSlice(rt.byteSliceView(_167[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_167[0])), rs.iterSlice(rs.byteSliceView(_167[1]))), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([vec.items.length, deque.n, rt.hashLen(set), rt.btreeLen(ordered), rt.hashLen(map), rt.btreeLen(tree)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([vec.items.length, deque.n, rs.hashLen(set), rs.btreeLen(ordered), rs.hashLen(map), rs.btreeLen(tree)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.vecIntoIter(rt.vecFrom(vec.items.map(copy$array_u8))), rt.lending((p2: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(p2) !== rt.byteSliceLast(p2); - }, (f2) => (held5) => f2(rt.byteSliceFrom(held5))))) & 0xff); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterFilter(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p3: rt.ByteSlice): boolean => { - return rt.iterAny(rt.iterSlice(rt.byteSliceView(p3)), (_22: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))), rs.lending((p2: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(p2) !== rs.byteSliceLast(p2); + }, (f2) => (held5) => f2(rs.byteSliceFrom(held5))))) & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p3: rs.ByteSlice): boolean => { + return rs.iterAny(rs.iterSlice(rs.byteSliceView(p3)), (_22: rs.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 0).items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(p4) === 64; - }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); - const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); + }, (f4) => (held6) => f4(rs.byteSliceFrom(held6)))), "next", 0).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const rest: rs.Peekable = rs.iterPeekable(rs.iterSkipWhile(rs.dequeIntoIter(rs.dequeClone(deque, copy$array_u8)), rs.lending((p4: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(p4) === 64; + }, (f6) => (held7) => f6(rs.byteSliceFrom(held7))))); + const _214: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeek(rest), rs.byteSliceFrom); if (_214 !== undefined) { - rt.byteVecExtendFromSlice(out, _214); + rs.byteVecExtendFromSlice(out, _214); } - const _220: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeekMut(rest, false), rt.byteSliceFrom); + const _220: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeekMut(rest, false), rs.byteSliceFrom); if (_220 !== undefined) { - const _224: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_220)); + const _224: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_220)); if (_224 !== undefined) { _224.v = 170; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - let seen: rt.u8 = 0; - const taken: rt.Vec = rt.iterToVec(rt.iterTakeWhile(rt.iterInspect(rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p5: rt.ByteSlice): undefined => { - seen = rt.u8WrappingAdd(seen, p5.length & 0xff); - }, (f7) => (held8) => f7(rt.byteSliceFrom(held8)))), rt.lending((p6: rt.ByteSlice): boolean => { - return rt.byteSliceLast(p6) !== 35; - }, (f9) => (held9) => f9(rt.byteSliceFrom(held9)))), "next", 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); - const _255: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f10 = (a: rt.ByteSlice, b2: rt.ByteSlice): rt.Ordering => { - return rt.cmpBytes(a, b2); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterToOption(rest.next())), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + let seen: rs.u8 = 0; + const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { + seen = rs.u8WrappingAdd(seen, p5.length & 0xff); + }, (f7) => (held8) => f7(rs.byteSliceFrom(held8)))), rs.lending((p6: rs.ByteSlice): boolean => { + return rs.byteSliceLast(p6) !== 35; + }, (f9) => (held9) => f9(rs.byteSliceFrom(held9)))), "next", 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); + const _255: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f10 = (a: rs.ByteSlice, b2: rs.ByteSlice): rs.Ordering => { + return rs.cmpBytes(a, b2); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const _264: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f11 = (p7: rt.ByteSlice): rt.u8 => { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(p7)), 0, (a2: rt.u8, b3: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held10, held11) => f10(rs.byteSliceFrom(held10), rs.byteSliceFrom(held11)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const _264: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f11 = (p7: rs.ByteSlice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(p7)), 0, (a2: rs.u8, b3: rs.u8): rs.u8 => { return a2 ^ b3; }); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const _274: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f12 = (p8: rt.ByteSlice): boolean => { - return rt.iterSum(rt.iterSlice(rt.byteSliceView(p8)), rt.u8Add, 0) > 18; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held12) => f11(rs.byteSliceFrom(held12)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const _274: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f12 = (p8: rs.ByteSlice): boolean => { + return rs.iterSum(rs.iterSlice(rs.byteSliceView(p8)), rs.u8Add, 0) > 18; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const _281: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f13 = (a3: rt.ByteSlice, b4: rt.ByteSlice): boolean => { - const order = rt.cmpBytes(a3, b4); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held13) => f12(rs.byteSliceFrom(held13)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const _281: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f13 = (a3: rs.ByteSlice, b4: rs.ByteSlice): boolean => { + const order = rs.cmpBytes(a3, b4); return order !== undefined && order <= 0; }; - rt.byteVecPush(out, rt.iterIsSortedBy(_281, (held14, held15) => f13(rt.byteSliceFrom(held14), rt.byteSliceFrom(held15))) ? 1 : 0); - const _291: rt.Iter = rt.iterCopied(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), rt.byteSliceToArray); - const f14 = (p9: rt.ByteSlice): boolean => { - return rt.cmpBytes(p9, rt.byteSliceFrom(Uint8Array.of())) === -1; + rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held14, held15) => f13(rs.byteSliceFrom(held14), rs.byteSliceFrom(held15))) ? 1 : 0); + const _291: rs.Iter = rs.iterCopied(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), rs.byteSliceToArray); + const f14 = (p9: rs.ByteSlice): boolean => { + return rs.cmpBytes(p9, rs.byteSliceFrom(Uint8Array.of())) === -1; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held16) => f14(rs.byteSliceFrom(held16)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); - const _299: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); + const _299: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const captured = first; - const sorted: boolean = rt.iterIsSortedBy(_299, rt.lending(rt.closure((a4: rt.ByteSlice, b5: rt.ByteSlice): boolean => { + const sorted: boolean = rs.iterIsSortedBy(_299, rs.lending(rs.closure((a4: rs.ByteSlice, b5: rs.ByteSlice): boolean => { if (!Dropped.live(captured)) { return false; } - const order2 = rt.cmpBytes(a4, b5); + const order2 = rs.cmpBytes(a4, b5); return order2 !== undefined && order2 <= 0; }, (): void => { captured[Symbol.dispose](); - }), (f15) => (held17, held18) => f15(rt.byteSliceFrom(held17), rt.byteSliceFrom(held18))), undefined, undefined, rt.drop); - const _307: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); - rt.refMutRelease(_307); + }), (f15) => (held17, held18) => f15(rs.byteSliceFrom(held17), rs.byteSliceFrom(held18))), undefined, undefined, rs.drop); + const _307: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); + rs.refMutRelease(_307); const second: Dropped.Dropped = new Dropped.Dropped(2, log); - const _314: rt.Iter = rt.vecIntoIter(rt.vecFrom(vec.items.map(copy$array_u8))); - const make2 = (captured2: Dropped.Dropped): (a0: rt.ByteSlice) => boolean => { - return rt.closure(rt.cloning((p10: rt.ByteSlice): boolean => { + const _314: rs.Iter = rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))); + const make2 = (captured2: Dropped.Dropped): (a0: rs.ByteSlice) => boolean => { + return rs.closure(rs.cloning((p10: rs.ByteSlice): boolean => { if (!Dropped.live(captured2)) { return false; } - return rt.byteSliceLast(p10) !== 33; + return rs.byteSliceLast(p10) !== 33; }, () => make2(Dropped.clone$Clone(captured2))), (): void => { captured2[Symbol.dispose](); }); }; - const filtered: rt.Iter = rt.iterFilter(_314, rt.lending(make2(second), (f16) => (held19) => f16(rt.byteSliceFrom(held19)))); - const counted: rt.u8 = rt.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rt.closureClone })) & 0xff; - const _325: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_325.value, counted); - rt.refMutRelease(_325); - const counted2: rt.u8 = rt.ownedCount(filtered) & 0xff; - const _332: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_332.value, counted2); - rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); - const lent: rt.Vec<[rt.ByteSlice, rt.ByteSlice]> = rt.iterToVec(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; - }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { - return [_23[0], _23[1]] as [rt.ByteSlice, rt.ByteSlice]; + const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held19) => f16(rs.byteSliceFrom(held19)))); + const counted: rs.u8 = rs.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rs.closureClone })) & 0xff; + const _325: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_325.value, counted); + rs.refMutRelease(_325); + const counted2: rs.u8 = rs.ownedCount(filtered) & 0xff; + const _332: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_332.value, counted2); + rs.refMutRelease(_332); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(log, new rs.ByteVec())), undefined, true); + const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held20): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held20[0]), rs.byteSliceFrom(held20[1])]; + }), (_23: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.ByteSlice] => { + return [_23[0], _23[1]] as [rs.ByteSlice, rs.ByteSlice]; }), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.ByteSlice], rt.Ordering | undefined>([rt.cmpBytes, rt.cmpBytes])), 8, true); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.ByteSlice, rs.ByteSlice], rs.Ordering | undefined>([rs.cmpBytes, rs.cmpBytes])), 8, true); for (const _347 of lent.items) { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_347[0])), rt.iterSlice(rt.byteSliceView(_347[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_347[0])), rs.iterSlice(rs.byteSliceView(_347[1]))), undefined, true); } - const _357: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.iterLend(rt.btreeIter(tree), (held21): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held21[0]), rt.byteSliceFrom(held21[1])]; - }), (_24: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.u8] => { - return [_24[0], _24[1].length & 0xff] as [rt.ByteSlice, rt.u8]; + const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held21): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held21[0]), rs.byteSliceFrom(held21[1])]; + }), (_24: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.u8] => { + return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); - rt.byteVecPush(out, rt.hashLen(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); - const _365: rt.Iter<[rt.ByteSlice, Uint8Array]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p11: rt.ByteSlice): [rt.ByteSlice, Uint8Array] => { - return [p11, rt.byteSliceToArray(p11)] as [rt.ByteSlice, Uint8Array]; + rs.byteVecPush(out, rs.hashLen(rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); + const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + return [p11, rs.byteSliceToArray(p11)] as [rs.ByteSlice, Uint8Array]; }); - const refs: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _365, undefined, undefined, undefined, 234881024); - const _370: rt.Iter<[rt.ByteSlice, Uint8Array]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p12: rt.ByteSlice): [rt.ByteSlice, Uint8Array] => { - return [p12, rt.byteSliceToArray(p12)] as [rt.ByteSlice, Uint8Array]; + const refs: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _365, undefined, undefined, undefined, 234881024); + const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + return [p12, rs.byteSliceToArray(p12)] as [rs.ByteSlice, Uint8Array]; }); - const sorted2: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _370, true, undefined, undefined, undefined, 4, true); - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.hashIter(refs), (held22): [rt.ByteSlice, rt.ByteSlice] => { - return [held22[0], rt.byteSliceFrom(held22[1])]; + const sorted2: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _370, true, undefined, undefined, undefined, 4, true); + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held22): [rs.ByteSlice, rs.ByteSlice] => { + return [held22[0], rs.byteSliceFrom(held22[1])]; }); while (true) { - const _378: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); - if (_378 === rt.DONE) { + const _378: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); + if (_378 === rs.DONE) { break; } - const _383: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_378[1])); + const _383: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_378[1])); if (_383 !== undefined) { - _383.v = _383.v ^ option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_378[0]), 1); + _383.v = _383.v ^ option_unwrapOr$1fr498u(rs.byteSliceFirst(_378[0]), 1); } } - const iter10: rt.Iter = rt.iterLend(rt.btreeValues(sorted2), rt.byteSliceFrom); + const iter10: rs.Iter = rs.iterLend(rs.btreeValues(sorted2), rs.byteSliceFrom); while (true) { - const _395: rt.ByteSlice | rt.Done = iter10.next(); - if (_395 === rt.DONE) { + const _395: rs.ByteSlice | rs.Done = iter10.next(); + if (_395 === rs.DONE) { break; } - const _399: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_395)); + const _399: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_395)); if (_399 !== undefined) { - _399.v = rt.u8WrappingAdd(_399.v, 1); + _399.v = rs.u8WrappingAdd(_399.v, 1); } } - const probe: Uint8Array = option_mapOr$0z7fb2w(rt.optionMap(rt.sliceFirst(pairs.items), rt.byteSliceFrom), rt.bytes(0), (p13: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(p13); + const probe: Uint8Array = option_mapOr$172961h(rs.optionMap(rs.sliceFirst(pairs.items), rs.byteSliceFrom), rs.bytes(0), (p13: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(p13); }); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const _429: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.optionMap(rt.hashGetKeyValue(refs, rt.byteSliceFrom(probe)), (held23): [rt.ByteSlice, rt.ByteSlice] => { - return [held23[0], rt.byteSliceFrom(held23[1])]; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.btreeGet(sorted2, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held23): [rs.ByteSlice, rs.ByteSlice] => { + return [held23[0], rs.byteSliceFrom(held23[1])]; }); if (_429 !== undefined) { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_429[0])), rt.iterSlice(rt.byteSliceView(_429[1]))), undefined, true); - } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(rt.entryOrInsert(rt.entry(refs, rt.byteSliceFrom(probe)), rt.bytes(0).fill(238))))), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.hashKeys(refs), "next", 4); - rt.sliceSort(keys.items, rt.cmpLt(rt.cmpBytes), 4, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys.items), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const values: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashValues(refs), rt.byteSliceFrom), rt.byteSliceToArray), "next", 0); - rt.sliceSort(values.items, rt.cmpLt(rt.cmpBytes), 0, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(sorted2), (held24): [rt.ByteSlice, rt.ByteSlice] => { - return [held24[0], rt.byteSliceFrom(held24[1])]; + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_429[0])), rs.iterSlice(rs.byteSliceView(_429[1]))), undefined, true); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(rs.entryOrInsert(rs.entry(refs, rs.byteSliceFrom(probe)), rs.bytes(0).fill(238))))), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.hashKeys(refs), "next", 4); + rs.sliceSort(keys.items, rs.cmpLt(rs.cmpBytes), 4, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(keys.items), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(refs), rs.byteSliceFrom), rs.byteSliceToArray), "next", 0); + rs.sliceSort(values.items, rs.cmpLt(rs.cmpBytes), 0, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held24): [rs.ByteSlice, rs.ByteSlice] => { + return [held24[0], rs.byteSliceFrom(held24[1])]; }); while (true) { - const _476: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); - if (_476 === rt.DONE) { + const _476: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); + if (_476 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_476[0])), rt.iterSlice(rt.byteSliceView(_476[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_476[0])), rs.iterSlice(rs.byteSliceView(_476[1]))), undefined, true); } - const f17 = (k2: rt.ByteSlice, v2: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(k2) === rt.byteSliceFirst(v2); + const f17 = (k2: rs.ByteSlice, v2: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(k2) === rs.byteSliceFirst(v2); }; - rt.hashRetain(refs, (held25, held26) => f17(held25, rt.byteSliceFrom(held26))); - const f18 = (k3: rt.ByteSlice, v3: rt.ByteSlice): boolean => { - return rt.byteSliceLast(k3) !== rt.byteSliceLast(v3); + rs.hashRetain(refs, (held25, held26) => f17(held25, rs.byteSliceFrom(held26))); + const f18 = (k3: rs.ByteSlice, v3: rs.ByteSlice): boolean => { + return rs.byteSliceLast(k3) !== rs.byteSliceLast(v3); }; - rt.btreeRetain(sorted2, (held27, held28) => f18(held27, rt.byteSliceFrom(held28))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(refs) & 0xff, rt.btreeLen(sorted2) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.hashValues(refs), (v4: Uint8Array): rt.u8 => { - return rt.byteSliceFrom(v4).length & 0xff; + rs.btreeRetain(sorted2, (held27, held28) => f18(held27, rs.byteSliceFrom(held28))); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(refs) & 0xff, rs.btreeLen(sorted2) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.iterToOption(rs.btreeKeys(sorted2).next())), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.hashValues(refs), (v4: Uint8Array): rs.u8 => { + return rs.byteSliceFrom(v4).length & 0xff; }), "next"); } /** `byte_refs` of the arrays `make` makes of each window of two bytes. */ -export function taken$2_keys_byte_refs_closure0(data: rt.ByteSlice, make: (a0: rt.ByteSlice) => Uint8Array, out: rt.ByteVec): void { - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceWindows(data, 2), make), undefined, 2, true); - const vec: rt.Vec = new rt.Vec(); - rt.iterExtend(vec, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - const _14: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); - rt.dequeExtend(deque, rt.iterMap(_14, rt.byteSliceToArray), undefined, true); - const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - rt.heapExtend(heap, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), undefined, 2, true); - const set: rt.HashSet = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet; - rt.hashExtendKeys(set, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, undefined, 469762048); - const ordered: rt.BTreeSet = rt.btreeNew(rt.cmpBytes) as rt.BTreeSet; - const _28: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); - rt.btreeExtendKeys(ordered, rt.iterMap(_28, rt.byteSliceToArray)); - const map: rt.HashMap = rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap; - const _34: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p: rt.ByteSlice): [rt.ByteSlice, rt.ByteSlice] => { - return [p, p] as [rt.ByteSlice, rt.ByteSlice]; +export function taken$2_keys_byte_refs_closure0(data: rs.ByteSlice, make: (a0: rs.ByteSlice) => Uint8Array, out: rs.ByteVec): void { + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(data, 2), make), undefined, 2, true); + const vec: rs.Vec = new rs.Vec(); + rs.iterExtend(vec, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true); + const deque: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + const _14: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); + rs.dequeExtend(deque, rs.iterMap(_14, rs.byteSliceToArray), undefined, true); + const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + rs.heapExtend(heap, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), undefined, 2, true); + const set: rs.HashSet = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet; + rs.hashExtendKeys(set, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, undefined, 469762048); + const ordered: rs.BTreeSet = rs.btreeNew(rs.cmpBytes) as rs.BTreeSet; + const _28: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); + rs.btreeExtendKeys(ordered, rs.iterMap(_28, rs.byteSliceToArray)); + const map: rs.HashMap = rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap; + const _34: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p: rs.ByteSlice): [rs.ByteSlice, rs.ByteSlice] => { + return [p, p] as [rs.ByteSlice, rs.ByteSlice]; }); - rt.hashExtend(map, rt.iterMap(_34, (held): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(held[0]), rt.byteSliceToArray(held[1])]; + rs.hashExtend(map, rs.iterMap(_34, (held): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(held[0]), rs.byteSliceToArray(held[1])]; }), undefined, undefined, undefined, 234881024); - const tree: rt.BTreeMap = rt.btreeNew(rt.cmpBytes) as rt.BTreeMap; - const _41: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterZip(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), [false, false]); - rt.btreeExtend(tree, rt.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(held2[0]), rt.byteSliceToArray(held2[1])]; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmpBytes) as rs.BTreeMap; + const _41: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterZip(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), [false, false]); + rs.btreeExtend(tree, rs.iterMap(_41, (held2): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(held2[0]), rs.byteSliceToArray(held2[1])]; })); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom); while (true) { - const _51: rt.ByteSlice | rt.Done = iter.next(); - if (_51 === rt.DONE) { + const _51: rs.ByteSlice | rs.Done = iter.next(); + if (_51 === rs.DONE) { break; } - const _55: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_51)); + const _55: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_51)); if (_55 !== undefined) { _55.v = _55.v ^ 16; } } - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom); while (true) { - const _64: rt.ByteSlice | rt.Done = iter2.next(); - if (_64 === rt.DONE) { + const _64: rs.ByteSlice | rs.Done = iter2.next(); + if (_64 === rs.DONE) { break; } - const _68: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_64)); + const _68: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_64)); if (_68 !== undefined) { _68.v = _68.v ^ 32; } } - const iter3: rt.Iter = rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom); + const iter3: rs.Iter = rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom); while (true) { - const _76: rt.ByteSlice | rt.Done = iter3.next(); - if (_76 === rt.DONE) { + const _76: rs.ByteSlice | rs.Done = iter3.next(); + if (_76 === rs.DONE) { break; } - const _80: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_76)); + const _80: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_76)); if (_80 !== undefined) { _80.v = _80.v ^ 64; } } - const iter4: rt.Iter = rt.iterLend(rt.hashValues(map), rt.byteSliceFrom); + const iter4: rs.Iter = rs.iterLend(rs.hashValues(map), rs.byteSliceFrom); while (true) { - const _88: rt.ByteSlice | rt.Done = iter4.next(); - if (_88 === rt.DONE) { + const _88: rs.ByteSlice | rs.Done = iter4.next(); + if (_88 === rs.DONE) { break; } - const _92: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_88)); + const _92: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_88)); if (_92 !== undefined) { _92.v = _92.v ^ 128; } } - const iter5: rt.Iter = rt.iterLend(rt.btreeValues(tree), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterLend(rs.btreeValues(tree), rs.byteSliceFrom); while (true) { - const _100: rt.ByteSlice | rt.Done = iter5.next(); - if (_100 === rt.DONE) { + const _100: rs.ByteSlice | rs.Done = iter5.next(); + if (_100 === rs.DONE) { break; } - const _104: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_100)); + const _104: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_100)); if (_104 !== undefined) { _104.v = _104.v ^ 8; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.heapIntoSortedVec(heap, rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)).items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const members: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashKeys(set), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); - rt.sliceSort(members.items, rt.cmpLt(rt.cmpBytes), 2, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(members.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.btreeKeys(ordered), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const entries: rt.Vec<[Uint8Array, Uint8Array]> = rt.iterToVec(rt.iterMap(rt.iterLend(rt.hashIter(map), (held3): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held3[0]), rt.byteSliceFrom(held3[1])]; - }), (_2: [rt.ByteSlice, rt.ByteSlice]): [Uint8Array, Uint8Array] => { - return [rt.byteSliceToArray(_2[0]), rt.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.heapIntoSortedVec(heap, rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const members: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashKeys(set), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); + rs.sliceSort(members.items, rs.cmpLt(rs.cmpBytes), 2, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(members.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.btreeKeys(ordered), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const entries: rs.Vec<[Uint8Array, Uint8Array]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held3): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held3[0]), rs.byteSliceFrom(held3[1])]; + }), (_2: [rs.ByteSlice, rs.ByteSlice]): [Uint8Array, Uint8Array] => { + return [rs.byteSliceToArray(_2[0]), rs.byteSliceToArray(_2[1])] as [Uint8Array, Uint8Array]; }), "next", 4); - rt.sliceSort(entries.items, rt.cmpLt(rt.cmpTuple<[Uint8Array, Uint8Array], rt.Ordering | undefined>([rt.cmpBytes, rt.cmpBytes])), 4, true); + rs.sliceSort(entries.items, rs.cmpLt(rs.cmpTuple<[Uint8Array, Uint8Array], rs.Ordering | undefined>([rs.cmpBytes, rs.cmpBytes])), 4, true); for (const _155 of entries.items) { - const k: rt.ByteSlice = rt.byteSliceFrom(_155[0]); - const v: rt.ByteSlice = rt.byteSliceFrom(_155[1]); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(k)), rt.iterSlice(rt.byteSliceView(v))), undefined, true); + const k: rs.ByteSlice = rs.byteSliceFrom(_155[0]); + const v: rs.ByteSlice = rs.byteSliceFrom(_155[1]); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(k)), rs.iterSlice(rs.byteSliceView(v))), undefined, true); } - const iter7: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(tree), (held4): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held4[0]), rt.byteSliceFrom(held4[1])]; + const iter7: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(tree), (held4): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held4[0]), rs.byteSliceFrom(held4[1])]; }); while (true) { - const _167: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter7.next(); - if (_167 === rt.DONE) { + const _167: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter7.next(); + if (_167 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_167[0])), rt.iterSlice(rt.byteSliceView(_167[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_167[0])), rs.iterSlice(rs.byteSliceView(_167[1]))), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([vec.items.length, deque.n, rt.hashLen(set), rt.btreeLen(ordered), rt.hashLen(map), rt.btreeLen(tree)], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([vec.items.length, deque.n, rs.hashLen(set), rs.btreeLen(ordered), rs.hashLen(map), rs.btreeLen(tree)], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.vecIntoIter(rt.vecFrom(vec.items.map(copy$array_u8))), rt.lending((p2: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(p2) !== rt.byteSliceLast(p2); - }, (f2) => (held5) => f2(rt.byteSliceFrom(held5))))) & 0xff); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterFilter(rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p3: rt.ByteSlice): boolean => { - return rt.iterAny(rt.iterSlice(rt.byteSliceView(p3)), (_22: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))), rs.lending((p2: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(p2) !== rs.byteSliceLast(p2); + }, (f2) => (held5) => f2(rs.byteSliceFrom(held5))))) & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterFilter(rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p3: rs.ByteSlice): boolean => { + return rs.iterAny(rs.iterSlice(rs.byteSliceView(p3)), (_22: rs.u8): boolean => { return _22 < 2; }); - }, (f4) => (held6) => f4(rt.byteSliceFrom(held6)))), "next", 2).items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const rest: rt.Peekable = rt.iterPeekable(rt.iterSkipWhile(rt.dequeIntoIter(rt.dequeClone(deque, copy$array_u8)), rt.lending((p4: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(p4) === 64; - }, (f6) => (held7) => f6(rt.byteSliceFrom(held7))))); - const _214: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeek(rest), rt.byteSliceFrom); + }, (f4) => (held6) => f4(rs.byteSliceFrom(held6)))), "next", 2).items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const rest: rs.Peekable = rs.iterPeekable(rs.iterSkipWhile(rs.dequeIntoIter(rs.dequeClone(deque, copy$array_u8)), rs.lending((p4: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(p4) === 64; + }, (f6) => (held7) => f6(rs.byteSliceFrom(held7))))); + const _214: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeek(rest), rs.byteSliceFrom); if (_214 !== undefined) { - rt.byteVecExtendFromSlice(out, _214); + rs.byteVecExtendFromSlice(out, _214); } - const _220: rt.ByteSlice | undefined = rt.optionMap(rt.peekablePeekMut(rest, false), rt.byteSliceFrom); + const _220: rs.ByteSlice | undefined = rs.optionMap(rs.peekablePeekMut(rest, false), rs.byteSliceFrom); if (_220 !== undefined) { - const _224: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_220)); + const _224: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_220)); if (_224 !== undefined) { _224.v = 170; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterToOption(rest.next())), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - let seen: rt.u8 = 0; - const taken: rt.Vec = rt.iterToVec(rt.iterTakeWhile(rt.iterInspect(rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray), rt.lending((p5: rt.ByteSlice): undefined => { - seen = rt.u8WrappingAdd(seen, p5.length & 0xff); - }, (f7) => (held8) => f7(rt.byteSliceFrom(held8)))), rt.lending((p6: rt.ByteSlice): boolean => { - return rt.byteSliceLast(p6) !== 35; - }, (f9) => (held9) => f9(rt.byteSliceFrom(held9)))), "next", 2); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); - const _255: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f10 = (a: rt.ByteSlice, b2: rt.ByteSlice): rt.Ordering => { - return rt.cmpBytes(a, b2); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterToOption(rest.next())), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + let seen: rs.u8 = 0; + const taken: rs.Vec = rs.iterToVec(rs.iterTakeWhile(rs.iterInspect(rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray), rs.lending((p5: rs.ByteSlice): undefined => { + seen = rs.u8WrappingAdd(seen, p5.length & 0xff); + }, (f7) => (held8) => f7(rs.byteSliceFrom(held8)))), rs.lending((p6: rs.ByteSlice): boolean => { + return rs.byteSliceLast(p6) !== 35; + }, (f9) => (held9) => f9(rs.byteSliceFrom(held9)))), "next", 2); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(seen, taken.items.length & 0xff)), undefined, true); + const _255: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f10 = (a: rs.ByteSlice, b2: rs.ByteSlice): rs.Ordering => { + return rs.cmpBytes(a, b2); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMaxBy(_255, (held10, held11) => f10(rt.byteSliceFrom(held10), rt.byteSliceFrom(held11)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const _264: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f11 = (p7: rt.ByteSlice): rt.u8 => { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(p7)), 0, (a2: rt.u8, b3: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMaxBy(_255, (held10, held11) => f10(rs.byteSliceFrom(held10), rs.byteSliceFrom(held11)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _264: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f11 = (p7: rs.ByteSlice): rs.u8 => { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(p7)), 0, (a2: rs.u8, b3: rs.u8): rs.u8 => { return a2 ^ b3; }); }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterMinByKey(_264, (held12) => f11(rt.byteSliceFrom(held12)), rt.lt)), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const _274: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f12 = (p8: rt.ByteSlice): boolean => { - return rt.iterSum(rt.iterSlice(rt.byteSliceView(p8)), rt.u8Add, 0) > 18; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterMinByKey(_264, (held12) => f11(rs.byteSliceFrom(held12)), rs.lt)), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _274: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f12 = (p8: rs.ByteSlice): boolean => { + return rs.iterSum(rs.iterSlice(rs.byteSliceView(p8)), rs.u8Add, 0) > 18; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterFind(_274, (held13) => f12(rt.byteSliceFrom(held13)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const _281: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); - const f13 = (a3: rt.ByteSlice, b4: rt.ByteSlice): boolean => { - const order = rt.cmpBytes(a3, b4); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterFind(_274, (held13) => f12(rs.byteSliceFrom(held13)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _281: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); + const f13 = (a3: rs.ByteSlice, b4: rs.ByteSlice): boolean => { + const order = rs.cmpBytes(a3, b4); return order !== undefined && order <= 0; }; - rt.byteVecPush(out, rt.iterIsSortedBy(_281, (held14, held15) => f13(rt.byteSliceFrom(held14), rt.byteSliceFrom(held15))) ? 1 : 0); - const _291: rt.Iter = rt.iterCopied(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), rt.byteSliceToArray); - const f14 = (p9: rt.ByteSlice): boolean => { - return rt.cmpBytes(p9, rt.byteSliceFrom(Uint8Array.of(80, 80))) === -1; + rs.byteVecPush(out, rs.iterIsSortedBy(_281, (held14, held15) => f13(rs.byteSliceFrom(held14), rs.byteSliceFrom(held15))) ? 1 : 0); + const _291: rs.Iter = rs.iterCopied(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), rs.byteSliceToArray); + const f14 = (p9: rs.ByteSlice): boolean => { + return rs.cmpBytes(p9, rs.byteSliceFrom(Uint8Array.of(80, 80))) === -1; }; - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterOption(rt.iterRfind(_291, (held16) => f14(rt.byteSliceFrom(held16)))), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterOption(rs.iterRfind(_291, (held16) => f14(rs.byteSliceFrom(held16)))), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const first: Dropped.Dropped = new Dropped.Dropped(1, log); - const _299: rt.Iter = rt.iterCopied(rt.iterLend(rt.iterSlice(vec.items), rt.byteSliceFrom), rt.byteSliceToArray); + const _299: rs.Iter = rs.iterCopied(rs.iterLend(rs.iterSlice(vec.items), rs.byteSliceFrom), rs.byteSliceToArray); const captured = first; - const sorted: boolean = rt.iterIsSortedBy(_299, rt.lending(rt.closure((a4: rt.ByteSlice, b5: rt.ByteSlice): boolean => { + const sorted: boolean = rs.iterIsSortedBy(_299, rs.lending(rs.closure((a4: rs.ByteSlice, b5: rs.ByteSlice): boolean => { if (!Dropped.live(captured)) { return false; } - const order2 = rt.cmpBytes(a4, b5); + const order2 = rs.cmpBytes(a4, b5); return order2 !== undefined && order2 <= 0; }, (): void => { captured[Symbol.dispose](); - }), (f15) => (held17, held18) => f15(rt.byteSliceFrom(held17), rt.byteSliceFrom(held18))), undefined, undefined, rt.drop); - const _307: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); - rt.refMutRelease(_307); + }), (f15) => (held17, held18) => f15(rs.byteSliceFrom(held17), rs.byteSliceFrom(held18))), undefined, undefined, rs.drop); + const _307: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_307.value, (sorted ? 1 : 0) | 128); + rs.refMutRelease(_307); const second: Dropped.Dropped = new Dropped.Dropped(2, log); - const _314: rt.Iter = rt.vecIntoIter(rt.vecFrom(vec.items.map(copy$array_u8))); - const make2 = (captured2: Dropped.Dropped): (a0: rt.ByteSlice) => boolean => { - return rt.closure(rt.cloning((p10: rt.ByteSlice): boolean => { + const _314: rs.Iter = rs.vecIntoIter(rs.vecFrom(vec.items.map(copy$array_u8))); + const make2 = (captured2: Dropped.Dropped): (a0: rs.ByteSlice) => boolean => { + return rs.closure(rs.cloning((p10: rs.ByteSlice): boolean => { if (!Dropped.live(captured2)) { return false; } - return rt.byteSliceLast(p10) !== 33; + return rs.byteSliceLast(p10) !== 33; }, () => make2(Dropped.clone$Clone(captured2))), (): void => { captured2[Symbol.dispose](); }); }; - const filtered: rt.Iter = rt.iterFilter(_314, rt.lending(make2(second), (f16) => (held19) => f16(rt.byteSliceFrom(held19)))); - const counted: rt.u8 = rt.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rt.closureClone })) & 0xff; - const _325: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_325.value, counted); - rt.refMutRelease(_325); - const counted2: rt.u8 = rt.ownedCount(filtered) & 0xff; - const _332: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_332.value, counted2); - rt.refMutRelease(_332); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(log, new rt.ByteVec())), undefined, true); - const lent: rt.Vec<[rt.ByteSlice, rt.ByteSlice]> = rt.iterToVec(rt.iterMap(rt.iterLend(rt.hashIter(map), (held20): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held20[0]), rt.byteSliceFrom(held20[1])]; - }), (_23: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.ByteSlice] => { - return [_23[0], _23[1]] as [rt.ByteSlice, rt.ByteSlice]; + const filtered: rs.Iter = rs.iterFilter(_314, rs.lending(make2(second), (f16) => (held19) => f16(rs.byteSliceFrom(held19)))); + const counted: rs.u8 = rs.ownedCount(filtered.clone({ i: { v: copy$array_u8 }, f: rs.closureClone })) & 0xff; + const _325: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_325.value, counted); + rs.refMutRelease(_325); + const counted2: rs.u8 = rs.ownedCount(filtered) & 0xff; + const _332: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_332.value, counted2); + rs.refMutRelease(_332); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(log, new rs.ByteVec())), undefined, true); + const lent: rs.Vec<[rs.ByteSlice, rs.ByteSlice]> = rs.iterToVec(rs.iterMap(rs.iterLend(rs.hashIter(map), (held20): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held20[0]), rs.byteSliceFrom(held20[1])]; + }), (_23: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.ByteSlice] => { + return [_23[0], _23[1]] as [rs.ByteSlice, rs.ByteSlice]; }), "next", 8); - rt.sliceSort(lent.items, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.ByteSlice], rt.Ordering | undefined>([rt.cmpBytes, rt.cmpBytes])), 8, true); + rs.sliceSort(lent.items, rs.cmpLt(rs.cmpTuple<[rs.ByteSlice, rs.ByteSlice], rs.Ordering | undefined>([rs.cmpBytes, rs.cmpBytes])), 8, true); for (const _347 of lent.items) { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_347[0])), rt.iterSlice(rt.byteSliceView(_347[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_347[0])), rs.iterSlice(rs.byteSliceView(_347[1]))), undefined, true); } - const _357: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterMap(rt.iterLend(rt.btreeIter(tree), (held21): [rt.ByteSlice, rt.ByteSlice] => { - return [rt.byteSliceFrom(held21[0]), rt.byteSliceFrom(held21[1])]; - }), (_24: [rt.ByteSlice, rt.ByteSlice]): [rt.ByteSlice, rt.u8] => { - return [_24[0], _24[1].length & 0xff] as [rt.ByteSlice, rt.u8]; + const _357: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterMap(rs.iterLend(rs.btreeIter(tree), (held21): [rs.ByteSlice, rs.ByteSlice] => { + return [rs.byteSliceFrom(held21[0]), rs.byteSliceFrom(held21[1])]; + }), (_24: [rs.ByteSlice, rs.ByteSlice]): [rs.ByteSlice, rs.u8] => { + return [_24[0], _24[1].length & 0xff] as [rs.ByteSlice, rs.u8]; }); - rt.byteVecPush(out, rt.hashLen(rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); - const _365: rt.Iter<[rt.ByteSlice, Uint8Array]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p11: rt.ByteSlice): [rt.ByteSlice, Uint8Array] => { - return [p11, rt.byteSliceToArray(p11)] as [rt.ByteSlice, Uint8Array]; + rs.byteVecPush(out, rs.hashLen(rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _357, undefined, undefined, undefined, 117440512)) & 0xff); + const _365: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p11: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + return [p11, rs.byteSliceToArray(p11)] as [rs.ByteSlice, Uint8Array]; }); - const refs: rt.HashMap = rt.hashExtend(rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashMap, _365, undefined, undefined, undefined, 117440512); - const _370: rt.Iter<[rt.ByteSlice, Uint8Array]> = rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), (p12: rt.ByteSlice): [rt.ByteSlice, Uint8Array] => { - return [p12, rt.byteSliceToArray(p12)] as [rt.ByteSlice, Uint8Array]; + const refs: rs.HashMap = rs.hashExtend(rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashMap, _365, undefined, undefined, undefined, 117440512); + const _370: rs.Iter<[rs.ByteSlice, Uint8Array]> = rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), (p12: rs.ByteSlice): [rs.ByteSlice, Uint8Array] => { + return [p12, rs.byteSliceToArray(p12)] as [rs.ByteSlice, Uint8Array]; }); - const sorted2: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _370, true, undefined, undefined, undefined, 8, true); - const iter9: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.hashIter(refs), (held22): [rt.ByteSlice, rt.ByteSlice] => { - return [held22[0], rt.byteSliceFrom(held22[1])]; + const sorted2: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _370, true, undefined, undefined, undefined, 8, true); + const iter9: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.hashIter(refs), (held22): [rs.ByteSlice, rs.ByteSlice] => { + return [held22[0], rs.byteSliceFrom(held22[1])]; }); while (true) { - const _378: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter9.next(); - if (_378 === rt.DONE) { + const _378: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter9.next(); + if (_378 === rs.DONE) { break; } - const _383: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_378[1])); + const _383: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_378[1])); if (_383 !== undefined) { - _383.v = _383.v ^ option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_378[0]), 1); + _383.v = _383.v ^ option_unwrapOr$1fr498u(rs.byteSliceFirst(_378[0]), 1); } } - const iter10: rt.Iter = rt.iterLend(rt.btreeValues(sorted2), rt.byteSliceFrom); + const iter10: rs.Iter = rs.iterLend(rs.btreeValues(sorted2), rs.byteSliceFrom); while (true) { - const _395: rt.ByteSlice | rt.Done = iter10.next(); - if (_395 === rt.DONE) { + const _395: rs.ByteSlice | rs.Done = iter10.next(); + if (_395 === rs.DONE) { break; } - const _399: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_395)); + const _399: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_395)); if (_399 !== undefined) { - _399.v = rt.u8WrappingAdd(_399.v, 1); + _399.v = rs.u8WrappingAdd(_399.v, 1); } } - const probe: Uint8Array = option_mapOr$0z7fb2w(rt.optionMap(rt.sliceFirst(pairs.items), rt.byteSliceFrom), rt.bytes(2), (p13: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(p13); + const probe: Uint8Array = option_mapOr$172961h(rs.optionMap(rs.sliceFirst(pairs.items), rs.byteSliceFrom), rs.bytes(2), (p13: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(p13); }); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.hashGet(refs, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.optionMap(rt.btreeGet(sorted2, rt.byteSliceFrom(probe)), rt.byteSliceFrom)), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const _429: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.optionMap(rt.hashGetKeyValue(refs, rt.byteSliceFrom(probe)), (held23): [rt.ByteSlice, rt.ByteSlice] => { - return [held23[0], rt.byteSliceFrom(held23[1])]; + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.hashGet(refs, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.optionMap(rs.btreeGet(sorted2, rs.byteSliceFrom(probe)), rs.byteSliceFrom)), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const _429: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.optionMap(rs.hashGetKeyValue(refs, rs.byteSliceFrom(probe)), (held23): [rs.ByteSlice, rs.ByteSlice] => { + return [held23[0], rs.byteSliceFrom(held23[1])]; }); if (_429 !== undefined) { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_429[0])), rt.iterSlice(rt.byteSliceView(_429[1]))), undefined, true); - } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(rt.entryOrInsert(rt.entry(refs, rt.byteSliceFrom(probe)), rt.bytes(2).fill(238))))), undefined, true); - const keys: rt.Vec = rt.iterToVec(rt.hashKeys(refs), "next", 4); - rt.sliceSort(keys.items, rt.cmpLt(rt.cmpBytes), 4, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(keys.items), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const values: rt.Vec = rt.iterToVec(rt.iterCopied(rt.iterLend(rt.hashValues(refs), rt.byteSliceFrom), rt.byteSliceToArray), "next", 2); - rt.sliceSort(values.items, rt.cmpLt(rt.cmpBytes), 2, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(values.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const iter11: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterLend(rt.btreeIter(sorted2), (held24): [rt.ByteSlice, rt.ByteSlice] => { - return [held24[0], rt.byteSliceFrom(held24[1])]; + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_429[0])), rs.iterSlice(rs.byteSliceView(_429[1]))), undefined, true); + } + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(rs.entryOrInsert(rs.entry(refs, rs.byteSliceFrom(probe)), rs.bytes(2).fill(238))))), undefined, true); + const keys: rs.Vec = rs.iterToVec(rs.hashKeys(refs), "next", 4); + rs.sliceSort(keys.items, rs.cmpLt(rs.cmpBytes), 4, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(keys.items), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const values: rs.Vec = rs.iterToVec(rs.iterCopied(rs.iterLend(rs.hashValues(refs), rs.byteSliceFrom), rs.byteSliceToArray), "next", 2); + rs.sliceSort(values.items, rs.cmpLt(rs.cmpBytes), 2, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(values.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const iter11: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterLend(rs.btreeIter(sorted2), (held24): [rs.ByteSlice, rs.ByteSlice] => { + return [held24[0], rs.byteSliceFrom(held24[1])]; }); while (true) { - const _476: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter11.next(); - if (_476 === rt.DONE) { + const _476: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter11.next(); + if (_476 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(_476[0])), rt.iterSlice(rt.byteSliceView(_476[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(_476[0])), rs.iterSlice(rs.byteSliceView(_476[1]))), undefined, true); } - const f17 = (k2: rt.ByteSlice, v2: rt.ByteSlice): boolean => { - return rt.byteSliceFirst(k2) === rt.byteSliceFirst(v2); + const f17 = (k2: rs.ByteSlice, v2: rs.ByteSlice): boolean => { + return rs.byteSliceFirst(k2) === rs.byteSliceFirst(v2); }; - rt.hashRetain(refs, (held25, held26) => f17(held25, rt.byteSliceFrom(held26))); - const f18 = (k3: rt.ByteSlice, v3: rt.ByteSlice): boolean => { - return rt.byteSliceLast(k3) !== rt.byteSliceLast(v3); + rs.hashRetain(refs, (held25, held26) => f17(held25, rs.byteSliceFrom(held26))); + const f18 = (k3: rs.ByteSlice, v3: rs.ByteSlice): boolean => { + return rs.byteSliceLast(k3) !== rs.byteSliceLast(v3); }; - rt.btreeRetain(sorted2, (held27, held28) => f18(held27, rt.byteSliceFrom(held28))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(refs) & 0xff, rt.btreeLen(sorted2) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(rt.iterToOption(rt.btreeKeys(sorted2).next())), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.hashValues(refs), (v4: Uint8Array): rt.u8 => { - return rt.byteSliceFrom(v4).length & 0xff; + rs.btreeRetain(sorted2, (held27, held28) => f18(held27, rs.byteSliceFrom(held28))); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(refs) & 0xff, rs.btreeLen(sorted2) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(rs.iterToOption(rs.btreeKeys(sorted2).next())), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.hashValues(refs), (v4: Uint8Array): rs.u8 => { + return rs.byteSliceFrom(v4).length & 0xff; }), "next"); } diff --git a/ts/fixtures/lang/keys/expected/lib.ts b/ts/fixtures/lang/keys/expected/lib.ts index 0516b7b68..6797daccf 100644 --- a/ts/fixtures/lang/keys/expected/lib.ts +++ b/ts/fixtures/lang/keys/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { keys, overrides, bytes, lentKeys, lentValues, arrays, byteRefs } from "./keys.ts"; import type * as Hop from "./keys.Hop.ts"; import type * as Horizon from "./keys.Horizon.ts"; @@ -34,11 +34,11 @@ export function copy$keys_Horizon(v: Horizon.Horizon): Horizon.Horizon { return { exclude: copy$Option_keys_Hop(v.exclude), local: v.local }; } -export function copy$tuple2_u8_keys_Horizon(v: [rt.u8, Horizon.Horizon]): [rt.u8, Horizon.Horizon] { +export function copy$tuple2_u8_keys_Horizon(v: [rs.u8, Horizon.Horizon]): [rs.u8, Horizon.Horizon] { return [v[0], copy$keys_Horizon(v[1])]; } -export function drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_1: [rt.u8, rt.Arc]): void { +export function drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_1: [rs.u8, rs.Arc]): void { _1[1][Symbol.dispose](); } @@ -46,8 +46,8 @@ export function drop$tuple2_u8_cmp_Reverse_sync_Arc_keys_Lopsided(_1: [rt.u8, rt * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["keys::keys", keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::bytes", bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_keys", lentKeys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["keys::byte_refs", byteRefs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["keys::keys", keys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::overrides", overrides as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::lent_keys", lentKeys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::lent_values", lentValues as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::arrays", arrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["keys::byte_refs", byteRefs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/lengths/expected/core/option.ts b/ts/fixtures/lang/lengths/expected/core/option.ts index 0fb1b6278..020e119ff 100644 --- a/ts/fixtures/lang/lengths/expected/core/option.ts +++ b/ts/fixtures/lang/lengths/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/lengths/expected/harness.ts b/ts/fixtures/lang/lengths/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/lengths/expected/harness.ts +++ b/ts/fixtures/lang/lengths/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/lengths/expected/lengths.Loud.ts b/ts/fixtures/lang/lengths/expected/lengths.Loud.ts index 7e8fbbd1d..134581b77 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.Loud.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.Loud.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { CLONES } from "./lengths.ts"; /** @@ -9,21 +9,21 @@ import { CLONES } from "./lengths.ts"; * it `n - 1` times. */ export interface Loud { - _0: rt.u16; + _0: rs.u16; } export function clone$Clone(self: Loud): Loud { - rt.localKeyWithBorrowMut(CLONES, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(rt.u16ToBeBytes(self._0).reverse()), undefined, true); + rs.localKeyWithBorrowMut(CLONES, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(rs.u16ToBeBytes(self._0).reverse()), undefined, true); }); if (!(self._0 === 255)) { - return { _0: rt.u16WrappingAdd(self._0, 1) }; + return { _0: rs.u16WrappingAdd(self._0, 1) }; } - rt.assertFailed("!=", (f: rt.Formatter) => rt.u16Debug(self._0, f), (f: rt.Formatter) => rt.u16Debug(255, f), ["a clone of 0xff"]); + rs.assertFailed("!=", (f: rs.Formatter) => rs.u16Debug(self._0, f), (f: rs.Formatter) => rs.u16Debug(255, f), ["a clone of 0xff"]); } -export function put$lengths_Put(self: Loud, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(self._0).reverse()), undefined, true); +export function put$lengths_Put(self: Loud, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(self._0).reverse()), undefined, true); } //# sourceMappingURL=lengths.Loud.ts.map diff --git a/ts/fixtures/lang/lengths/expected/lengths.Row.ts b/ts/fixtures/lang/lengths/expected/lengths.Row.ts index 49d600f5a..fc8ca27e6 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.Row.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.Row.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$tuple2_u8_u8 } from "./lib.ts"; import * as Loud from "./lengths.Loud.ts"; @@ -11,9 +11,9 @@ export function clone$Clone_lengths_Loud(self: Row): Row { /** A value and a pair of tags kept as an object. */ export class Row { _0: T; - _1: [rt.u8, rt.u8]; + _1: [rs.u8, rs.u8]; - constructor(_0: T, _1: [rt.u8, rt.u8]) { + constructor(_0: T, _1: [rs.u8, rs.u8]) { this._0 = _0; this._1 = _1; } diff --git a/ts/fixtures/lang/lengths/expected/lengths.Tagged.ts b/ts/fixtures/lang/lengths/expected/lengths.Tagged.ts index 4e5e2c82d..9f6845b13 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.Tagged.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.Tagged.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { put$lengths_Put_u32 as lengths_put$lengths_Put_u32 } from "./lengths.ts"; export class Tagged { _0: T; - _1: rt.u8; + _1: rs.u8; - constructor(_0: T, _1: rt.u8) { + constructor(_0: T, _1: rs.u8) { this._0 = _0; this._1 = _1; } } -export function put$lengths_Put_u32(self: Tagged, out: rt.ByteVec): void { +export function put$lengths_Put_u32(self: Tagged, out: rs.ByteVec): void { lengths_put$lengths_Put_u32(self._0, out); - rt.byteVecPush(out, self._1); + rs.byteVecPush(out, self._1); } //# sourceMappingURL=lengths.Tagged.ts.map diff --git a/ts/fixtures/lang/lengths/expected/lengths.ts b/ts/fixtures/lang/lengths/expected/lengths.ts index 37bebadc4..40a7ada2e 100644 --- a/ts/fixtures/lang/lengths/expected/lengths.ts +++ b/ts/fixtures/lang/lengths/expected/lengths.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_lengths_Tagged_array0_u32, copy$Option_lengths_Tagged_array0_u8, copy$Option_lengths_Tagged_array17_u32, copy$Option_lengths_Tagged_array17_u8, copy$Option_lengths_Tagged_array1_u32, copy$Option_lengths_Tagged_array1_u8, copy$Option_lengths_Tagged_array3_u32, copy$Option_lengths_Tagged_array3_u8, copy$array_array0_u8, copy$array_array17_u8, copy$array_array1_u8, copy$array_array3_u8, copy$array_lengths_Row_lengths_Loud, copy$array_lengths_Row_u8, copy$array_lengths_Tagged_u32, copy$array_u32, copy$array_u8, copy$lengths_Row_lengths_Loud, copy$lengths_Row_u8, copy$mem_MaybeUninit_tuple2_array0_array0_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array0_lengths_Tagged_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array17_array17_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array17_lengths_Tagged_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array1_array1_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array1_lengths_Tagged_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array3_array3_u8_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array3_lengths_Tagged_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8, copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8 } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Loud from "./lengths.Loud.ts"; import * as Row from "./lengths.Row.ts"; import * as Tagged from "./lengths.Tagged.ts"; /** Each case at the length `kind` picks. */ -export function lengths(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - rt.localKeyWithBorrowMut(CLONES, (a0: rt.ByteVec): undefined => { - rt.byteVecClear(a0); +export function lengths(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + rs.localKeyWithBorrowMut(CLONES, (a0: rs.ByteVec): undefined => { + rs.byteVecClear(a0); }); - const _7: rt.u8 = rt.u8Rem(kind, 4); + const _7: rs.u8 = rs.u8Rem(kind, 4); if (_7 === 0) { each$0(data, out); } else if (_7 === 1) { @@ -22,203 +22,203 @@ export function lengths(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { each$17(data, out); } - const byte: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at), 0) as rt.u16; + const byte: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, at), 0) as rs.u16; }; repeated$u8(data.data, data.start, data.length, 65, 66, out); repeated$lengths_Loud(data.data, data.start, data.length, { _0: byte(1) }, { _0: byte(0) }, out); loud(data, out); zipped(data, out); - rt.localKeyWithBorrowMut(CLONES, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(out, rt.byteVecDrain(log, undefined), "fold", true); + rs.localKeyWithBorrowMut(CLONES, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(out, rs.byteVecDrain(log, undefined), "fold", true); }); } -export function each$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, rt.max(0, 1)), (c: rt.ByteSlice): Uint8Array => { - return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); +export function each$0(data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, rs.max(0, 1)), (c: rs.ByteSlice): Uint8Array => { + return rs.bytesFromFn(0, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 0, true); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (r: rt.ByteSlice): rt.u32[] => { - return rt.arrayMap(rt.byteSliceToArray(r), (b: rt.u8): rt.u32 => { - return ((((b as rt.u32) << 8) >>> 0) | 1) >>> 0; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { + return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 0, true); - joined$0(data, rt.vecFrom(rows.items.map(copy$array_u8)), out); - joined$0(data, rt.vecFrom(copy$array_array0_u8([rt.bytes(0).fill(165), rt.bytesFromFn(0, (i2: rt.usize): rt.u8 => { + joined$0(data, rs.vecFrom(rows.items.map(copy$array_u8)), out); + joined$0(data, rs.vecFrom(copy$array_array0_u8([rs.bytes(0).fill(165), rs.bytesFromFn(0, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); retagged$0(rows.items, out); recloned$u32_0(wide.items, out); - filled$u8_0(data, rt.bytesFromFn(0, (i3: rt.usize): rt.u8 => { + filled$u8_0(data, rs.bytesFromFn(0, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); - filled$u32_0(data, rt.arrayFromFn(0, (i4: rt.usize): rt.u32 => { - return rt.u32Mul(16909060, i4 as rt.u32); + filled$u32_0(data, rs.arrayFromFn(0, (i4: rs.usize): rs.u32 => { + return rs.u32Mul(16909060, i4 as rs.u32); }), out); - filled$array0_u8_0(data, rt.arrayFromFn(0, (i5: rt.usize): Uint8Array => { - return rt.bytesFromFn(0, (j: rt.usize): rt.u8 => { - return rt.usizeAdd(rt.usizeMul(i5, 0), j) & 0xff; + filled$array0_u8_0(data, rs.arrayFromFn(0, (i5: rs.usize): Uint8Array => { + return rs.bytesFromFn(0, (j: rs.usize): rs.u8 => { + return rs.usizeAdd(rs.usizeMul(i5, 0), j) & 0xff; }); }), out); - filled$lengths_Tagged_u32_0(data, rt.arrayFromFn(0, (i6: rt.usize): Tagged.Tagged => { - return new Tagged.Tagged(rt.u32Mul(i6 as rt.u32, 257), ~(i6 & 0xff) & 0xff); + filled$lengths_Tagged_u32_0(data, rs.arrayFromFn(0, (i6: rs.usize): Tagged.Tagged => { + return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); swapped$u8_0(data, rows.items, out); swapped$u32_0(data, wide.items, out); } -export function each$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, rt.max(1, 1)), (c: rt.ByteSlice): Uint8Array => { - return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); +export function each$1(data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, rs.max(1, 1)), (c: rs.ByteSlice): Uint8Array => { + return rs.bytesFromFn(1, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 1, true); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (r: rt.ByteSlice): rt.u32[] => { - return rt.arrayMap(rt.byteSliceToArray(r), (b: rt.u8): rt.u32 => { - return ((((b as rt.u32) << 8) >>> 0) | 1) >>> 0; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { + return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 4, true); - joined$1(data, rt.vecFrom(rows.items.map(copy$array_u8)), out); - joined$1(data, rt.vecFrom(copy$array_array1_u8([rt.bytes(1).fill(165), rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { + joined$1(data, rs.vecFrom(rows.items.map(copy$array_u8)), out); + joined$1(data, rs.vecFrom(copy$array_array1_u8([rs.bytes(1).fill(165), rs.bytesFromFn(1, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); retagged$1(rows.items, out); recloned$u32_1(wide.items, out); - filled$u8_1(data, rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { + filled$u8_1(data, rs.bytesFromFn(1, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); - filled$u32_1(data, rt.arrayFromFn(1, (i4: rt.usize): rt.u32 => { - return rt.u32Mul(16909060, i4 as rt.u32); + filled$u32_1(data, rs.arrayFromFn(1, (i4: rs.usize): rs.u32 => { + return rs.u32Mul(16909060, i4 as rs.u32); }), out); - filled$array1_u8_1(data, rt.arrayFromFn(1, (i5: rt.usize): Uint8Array => { - return rt.bytesFromFn(1, (j: rt.usize): rt.u8 => { - return rt.usizeAdd(rt.usizeMul(i5, 1), j) & 0xff; + filled$array1_u8_1(data, rs.arrayFromFn(1, (i5: rs.usize): Uint8Array => { + return rs.bytesFromFn(1, (j: rs.usize): rs.u8 => { + return rs.usizeAdd(rs.usizeMul(i5, 1), j) & 0xff; }); }), out); - filled$lengths_Tagged_u32_1(data, rt.arrayFromFn(1, (i6: rt.usize): Tagged.Tagged => { - return new Tagged.Tagged(rt.u32Mul(i6 as rt.u32, 257), ~(i6 & 0xff) & 0xff); + filled$lengths_Tagged_u32_1(data, rs.arrayFromFn(1, (i6: rs.usize): Tagged.Tagged => { + return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); swapped$u8_1(data, rows.items, out); swapped$u32_1(data, wide.items, out); } -export function each$17(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, rt.max(17, 1)), (c: rt.ByteSlice): Uint8Array => { - return rt.bytesFromFn(17, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); +export function each$17(data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, rs.max(17, 1)), (c: rs.ByteSlice): Uint8Array => { + return rs.bytesFromFn(17, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 17, true); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (r: rt.ByteSlice): rt.u32[] => { - return rt.arrayMap(rt.byteSliceToArray(r), (b: rt.u8): rt.u32 => { - return ((((b as rt.u32) << 8) >>> 0) | 1) >>> 0; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { + return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 68, true); - joined$17(data, rt.vecFrom(rows.items.map(copy$array_u8)), out); - joined$17(data, rt.vecFrom(copy$array_array17_u8([rt.bytes(17).fill(165), rt.bytesFromFn(17, (i2: rt.usize): rt.u8 => { + joined$17(data, rs.vecFrom(rows.items.map(copy$array_u8)), out); + joined$17(data, rs.vecFrom(copy$array_array17_u8([rs.bytes(17).fill(165), rs.bytesFromFn(17, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); retagged$17(rows.items, out); recloned$u32_17(wide.items, out); - filled$u8_17(data, rt.bytesFromFn(17, (i3: rt.usize): rt.u8 => { + filled$u8_17(data, rs.bytesFromFn(17, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); - filled$u32_17(data, rt.arrayFromFn(17, (i4: rt.usize): rt.u32 => { - return rt.u32Mul(16909060, i4 as rt.u32); + filled$u32_17(data, rs.arrayFromFn(17, (i4: rs.usize): rs.u32 => { + return rs.u32Mul(16909060, i4 as rs.u32); }), out); - filled$array17_u8_17(data, rt.arrayFromFn(17, (i5: rt.usize): Uint8Array => { - return rt.bytesFromFn(17, (j: rt.usize): rt.u8 => { - return rt.usizeAdd(rt.usizeMul(i5, 17), j) & 0xff; + filled$array17_u8_17(data, rs.arrayFromFn(17, (i5: rs.usize): Uint8Array => { + return rs.bytesFromFn(17, (j: rs.usize): rs.u8 => { + return rs.usizeAdd(rs.usizeMul(i5, 17), j) & 0xff; }); }), out); - filled$lengths_Tagged_u32_17(data, rt.arrayFromFn(17, (i6: rt.usize): Tagged.Tagged => { - return new Tagged.Tagged(rt.u32Mul(i6 as rt.u32, 257), ~(i6 & 0xff) & 0xff); + filled$lengths_Tagged_u32_17(data, rs.arrayFromFn(17, (i6: rs.usize): Tagged.Tagged => { + return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); swapped$u8_17(data, rows.items, out); swapped$u32_17(data, wide.items, out); } -export function each$3(data: rt.ByteSlice, out: rt.ByteVec): void { - const rows: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, rt.max(3, 1)), (c: rt.ByteSlice): Uint8Array => { - return rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(c, i), i & 0xff); +export function each$3(data: rs.ByteSlice, out: rs.ByteVec): void { + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, rs.max(3, 1)), (c: rs.ByteSlice): Uint8Array => { + return rs.bytesFromFn(3, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(c, i), i & 0xff); }); }), undefined, 3, true); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (r: rt.ByteSlice): rt.u32[] => { - return rt.arrayMap(rt.byteSliceToArray(r), (b: rt.u8): rt.u32 => { - return ((((b as rt.u32) << 8) >>> 0) | 1) >>> 0; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (r: rs.ByteSlice): rs.u32[] => { + return rs.arrayMap(rs.byteSliceToArray(r), (b: rs.u8): rs.u32 => { + return ((((b as rs.u32) << 8) >>> 0) | 1) >>> 0; }); }), undefined, 12, true); - joined$3(data, rt.vecFrom(rows.items.map(copy$array_u8)), out); - joined$3(data, rt.vecFrom(copy$array_array3_u8([rt.bytes(3).fill(165), rt.bytesFromFn(3, (i2: rt.usize): rt.u8 => { + joined$3(data, rs.vecFrom(rows.items.map(copy$array_u8)), out); + joined$3(data, rs.vecFrom(copy$array_array3_u8([rs.bytes(3).fill(165), rs.bytesFromFn(3, (i2: rs.usize): rs.u8 => { return i2 & 0xff; })]).map(copy$array_u8)), out); retagged$3(rows.items, out); recloned$u32_3(wide.items, out); - filled$u8_3(data, rt.bytesFromFn(3, (i3: rt.usize): rt.u8 => { + filled$u8_3(data, rs.bytesFromFn(3, (i3: rs.usize): rs.u8 => { return i3 & 0xff; }), out); - filled$u32_3(data, rt.arrayFromFn(3, (i4: rt.usize): rt.u32 => { - return rt.u32Mul(16909060, i4 as rt.u32); + filled$u32_3(data, rs.arrayFromFn(3, (i4: rs.usize): rs.u32 => { + return rs.u32Mul(16909060, i4 as rs.u32); }), out); - filled$array3_u8_3(data, rt.arrayFromFn(3, (i5: rt.usize): Uint8Array => { - return rt.bytesFromFn(3, (j: rt.usize): rt.u8 => { - return rt.usizeAdd(rt.usizeMul(i5, 3), j) & 0xff; + filled$array3_u8_3(data, rs.arrayFromFn(3, (i5: rs.usize): Uint8Array => { + return rs.bytesFromFn(3, (j: rs.usize): rs.u8 => { + return rs.usizeAdd(rs.usizeMul(i5, 3), j) & 0xff; }); }), out); - filled$lengths_Tagged_u32_3(data, rt.arrayFromFn(3, (i6: rt.usize): Tagged.Tagged => { - return new Tagged.Tagged(rt.u32Mul(i6 as rt.u32, 257), ~(i6 & 0xff) & 0xff); + filled$lengths_Tagged_u32_3(data, rs.arrayFromFn(3, (i6: rs.usize): Tagged.Tagged => { + return new Tagged.Tagged(rs.u32Mul(i6 as rs.u32, 257), ~(i6 & 0xff) & 0xff); }), out); swapped$u8_3(data, rows.items, out); swapped$u32_3(data, wide.items, out); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$0(data: rt.ByteSlice, rows: rt.Vec, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0)), undefined, true); +export function joined$0(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$1(data: rt.ByteSlice, rows: rt.Vec, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 1)), undefined, true); +export function joined$1(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$17(data: rt.ByteSlice, rows: rt.Vec, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 17)), undefined, true); +export function joined$17(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), undefined, true); } /** The bytes of `data` and then of each row, as one run. */ -export function joined$3(data: rt.ByteSlice, rows: rt.Vec, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterFlatten(rt.iterLend(rt.iterSlice(rows.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 3)), undefined, true); +export function joined$3(data: rs.ByteSlice, rows: rs.Vec, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterFlatten(rs.iterLend(rs.iterSlice(rows.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), undefined, true); } /** * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$0(rows: Uint8Array[], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom)); +export function retagged$0(rows: Uint8Array[], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rows), rs.byteSliceFrom)); while (true) { - const _7: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u8(rt.byteSliceToArray(_7[1])), at & 0xff), 0]; + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u8(rs.byteSliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array0_u8(copy$Option_lengths_Tagged_array0_u8(pair[0])); pair[0] = copy$Option_lengths_Tagged_array0_u8(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - const a: rt.ByteSlice = rt.byteSliceFrom(part.v._0); - const b: rt.ByteSlice = rt.byteSliceFrom(part2.v._0); - rt.byteSliceView(a).reverse(); + const a: rs.ByteSlice = rs.byteSliceFrom(part.v._0); + const b: rs.ByteSlice = rs.byteSliceFrom(part2.v._0); + rs.byteSliceView(a).reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(a)), rt.iterSlice(rt.byteSliceView(b))), undefined, true); + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(a)), rs.iterSlice(rs.byteSliceView(b))), undefined, true); } } } @@ -228,27 +228,27 @@ export function retagged$0(rows: Uint8Array[], out: rt.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$1(rows: Uint8Array[], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom)); +export function retagged$1(rows: Uint8Array[], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rows), rs.byteSliceFrom)); while (true) { - const _7: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u8(rt.byteSliceToArray(_7[1])), at & 0xff), 0]; + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u8(rs.byteSliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array1_u8(copy$Option_lengths_Tagged_array1_u8(pair[0])); pair[0] = copy$Option_lengths_Tagged_array1_u8(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - const a: rt.ByteSlice = rt.byteSliceFrom(part.v._0); - const b: rt.ByteSlice = rt.byteSliceFrom(part2.v._0); - rt.byteSliceView(a).reverse(); + const a: rs.ByteSlice = rs.byteSliceFrom(part.v._0); + const b: rs.ByteSlice = rs.byteSliceFrom(part2.v._0); + rs.byteSliceView(a).reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(a)), rt.iterSlice(rt.byteSliceView(b))), undefined, true); + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(a)), rs.iterSlice(rs.byteSliceView(b))), undefined, true); } } } @@ -258,27 +258,27 @@ export function retagged$1(rows: Uint8Array[], out: rt.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$17(rows: Uint8Array[], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom)); +export function retagged$17(rows: Uint8Array[], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rows), rs.byteSliceFrom)); while (true) { - const _7: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u8(rt.byteSliceToArray(_7[1])), at & 0xff), 0]; + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u8(rs.byteSliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array17_u8(copy$Option_lengths_Tagged_array17_u8(pair[0])); pair[0] = copy$Option_lengths_Tagged_array17_u8(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - const a: rt.ByteSlice = rt.byteSliceFrom(part.v._0); - const b: rt.ByteSlice = rt.byteSliceFrom(part2.v._0); - rt.byteSliceView(a).reverse(); + const a: rs.ByteSlice = rs.byteSliceFrom(part.v._0); + const b: rs.ByteSlice = rs.byteSliceFrom(part2.v._0); + rs.byteSliceView(a).reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(a)), rt.iterSlice(rt.byteSliceView(b))), undefined, true); + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(a)), rs.iterSlice(rs.byteSliceView(b))), undefined, true); } } } @@ -288,52 +288,52 @@ export function retagged$17(rows: Uint8Array[], out: rt.ByteVec): void { * Each row cloned out of an `Option` kept in a pair and written back whole, after which * the pair and the copy each change apart. */ -export function retagged$3(rows: Uint8Array[], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(rows), rt.byteSliceFrom)); +export function retagged$3(rows: Uint8Array[], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(rows), rs.byteSliceFrom)); while (true) { - const _7: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u8(rt.byteSliceToArray(_7[1])), at & 0xff), 0]; + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u8(rs.byteSliceToArray(_7[1])), at & 0xff), 0]; let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array3_u8(copy$Option_lengths_Tagged_array3_u8(pair[0])); pair[0] = copy$Option_lengths_Tagged_array3_u8(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { - const a: rt.ByteSlice = rt.byteSliceFrom(part.v._0); - const b: rt.ByteSlice = rt.byteSliceFrom(part2.v._0); - rt.byteSliceView(a).reverse(); + const a: rs.ByteSlice = rs.byteSliceFrom(part.v._0); + const b: rs.ByteSlice = rs.byteSliceFrom(part2.v._0); + rs.byteSliceView(a).reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(a)), rt.iterSlice(rt.byteSliceView(b))), undefined, true); + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(a)), rs.iterSlice(rs.byteSliceView(b))), undefined, true); } } } } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_0(rows: rt.u32[][], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.u32[]]> = rt.iterEnumerate(rt.iterSlice(rows)); +export function recloned$u32_0(rows: rs.u32[][], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rows)); while (true) { - const _7: [rt.usize, rt.u32[]] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; - let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array0_u32(copy$Option_lengths_Tagged_array0_u32(pair[0])); + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array0_u32(copy$Option_lengths_Tagged_array0_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array0_u32(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { part.v._0.reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(part.v._0), rt.iterSlice(part2.v._0)), (_2: rt.u32): rt.u8 => { + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -342,25 +342,25 @@ export function recloned$u32_0(rows: rt.u32[][], out: rt.ByteVec): void { } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_1(rows: rt.u32[][], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.u32[]]> = rt.iterEnumerate(rt.iterSlice(rows)); +export function recloned$u32_1(rows: rs.u32[][], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rows)); while (true) { - const _7: [rt.usize, rt.u32[]] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; - let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array1_u32(copy$Option_lengths_Tagged_array1_u32(pair[0])); + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array1_u32(copy$Option_lengths_Tagged_array1_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array1_u32(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { part.v._0.reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(part.v._0), rt.iterSlice(part2.v._0)), (_2: rt.u32): rt.u8 => { + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -369,25 +369,25 @@ export function recloned$u32_1(rows: rt.u32[][], out: rt.ByteVec): void { } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_17(rows: rt.u32[][], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.u32[]]> = rt.iterEnumerate(rt.iterSlice(rows)); +export function recloned$u32_17(rows: rs.u32[][], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rows)); while (true) { - const _7: [rt.usize, rt.u32[]] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; - let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array17_u32(copy$Option_lengths_Tagged_array17_u32(pair[0])); + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array17_u32(copy$Option_lengths_Tagged_array17_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array17_u32(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { part.v._0.reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(part.v._0), rt.iterSlice(part2.v._0)), (_2: rt.u32): rt.u8 => { + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -396,25 +396,25 @@ export function recloned$u32_17(rows: rt.u32[][], out: rt.ByteVec): void { } /** [`retagged`] of a type parameter's values. */ -export function recloned$u32_3(rows: rt.u32[][], out: rt.ByteVec): void { - const iter: rt.Iter<[rt.usize, rt.u32[]]> = rt.iterEnumerate(rt.iterSlice(rows)); +export function recloned$u32_3(rows: rs.u32[][], out: rs.ByteVec): void { + const iter: rs.Iter<[rs.usize, rs.u32[]]> = rs.iterEnumerate(rs.iterSlice(rows)); while (true) { - const _7: [rt.usize, rt.u32[]] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, rs.u32[]] | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } - const at: rt.usize = _7[0]; - const pair: [Tagged.Tagged | undefined, rt.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; - let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array3_u32(copy$Option_lengths_Tagged_array3_u32(pair[0])); + const at: rs.usize = _7[0]; + const pair: [Tagged.Tagged | undefined, rs.u8] = [new Tagged.Tagged(copy$array_u32(copy$array_u32(_7[1])), at & 0xff), 0]; + let copy: Tagged.Tagged | undefined = copy$Option_lengths_Tagged_array3_u32(copy$Option_lengths_Tagged_array3_u32(pair[0])); pair[0] = copy$Option_lengths_Tagged_array3_u32(copy); - const part = rt.place(() => pair[0], (value) => pair[0] = value); - const part2 = rt.place(() => copy, (value2) => copy = value2); + const part = rs.place(() => pair[0], (value) => pair[0] = value); + const part2 = rs.place(() => copy, (value2) => copy = value2); if (part.v !== undefined) { if (part2.v !== undefined) { part.v._0.reverse(); part2.v._1 = part2.v._1 ^ 255; - rt.byteVecPush(out, part2.v._1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(part.v._0), rt.iterSlice(part2.v._0)), (_2: rt.u32): rt.u8 => { + rs.byteVecPush(out, part2.v._1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(part.v._0), rs.iterSlice(part2.v._0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -429,38 +429,38 @@ export function recloned$u32_3(rows: rt.u32[][], out: rt.ByteVec): void { * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$array0_u8_0(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filled$array0_u8_0(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ByteVec): void { let row!: Uint8Array[]; const item = ([Array.from({ length: 0 }, (): Uint8Array => { return (new Uint8Array(0) as unknown) as Uint8Array; - }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; - const slots: [Uint8Array[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rt.u8, rt.u8]] => { + }), [undefined, undefined]] as unknown) as [Uint8Array[], [rs.u8, rs.u8]]; + const slots: [Uint8Array[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_array0_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_array0_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_array0_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom); + const picks: rs.Vec = new rs.Vec(); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - picks.items.push(copy$array_u8(rt.byteSliceToArray(_26))); + picks.items.push(copy$array_u8(rs.byteSliceToArray(_26))); } - const iter3: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } const pick: Uint8Array | undefined = _41[1]; @@ -473,51 +473,51 @@ export function filled$array0_u8_0(data: rt.ByteSlice, fill: Uint8Array[], out: }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_array0_u8(row), [0, 90] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_array0_u8(row), [0, 90] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_array0_u8(fill), rt.usizeRem(data.length, 4), copy$array_array0_u8); - const iter4: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_array0_u8(fill), rs.usizeRem(data.length, 4), copy$array_array0_u8); + const iter4: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_array0_u8(_65[1]), [17, 0] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_array0_u8(_65[1]), [17, 0] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterCopied(rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom), rt.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); while (true) { - const _85: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } const item2 = copy$array_u8(_85[1]); const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 0 }, (): Uint8Array => { + rs.ptrWrite(uninit4, [Array.from({ length: 0 }, (): Uint8Array => { return copy$array_u8(item2); - }), [34, 0] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + }), [34, 0] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(0, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(0, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterLend(rt.iterSlice(_131[0]), rt.byteSliceFrom), (v4: rt.ByteSlice): undefined => { + const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array0_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -528,38 +528,38 @@ export function filled$array0_u8_0(data: rt.ByteSlice, fill: Uint8Array[], out: * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$array17_u8_17(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filled$array17_u8_17(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ByteVec): void { let row!: Uint8Array[]; const item = ([Array.from({ length: 17 }, (): Uint8Array => { return (new Uint8Array(17) as unknown) as Uint8Array; - }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; - const slots: [Uint8Array[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rt.u8, rt.u8]] => { + }), [undefined, undefined]] as unknown) as [Uint8Array[], [rs.u8, rs.u8]]; + const slots: [Uint8Array[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_array17_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_array17_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_array17_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom); + const picks: rs.Vec = new rs.Vec(); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - picks.items.push(copy$array_u8(rt.byteSliceToArray(_26))); + picks.items.push(copy$array_u8(rs.byteSliceToArray(_26))); } - const iter3: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } const pick: Uint8Array | undefined = _41[1]; @@ -572,51 +572,51 @@ export function filled$array17_u8_17(data: rt.ByteSlice, fill: Uint8Array[], out }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_array17_u8(row), [17, 90] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_array17_u8(row), [17, 90] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_array17_u8(fill), rt.usizeRem(data.length, 4), copy$array_array17_u8); - const iter4: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_array17_u8(fill), rs.usizeRem(data.length, 4), copy$array_array17_u8); + const iter4: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_array17_u8(_65[1]), [17, 17] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_array17_u8(_65[1]), [17, 17] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterCopied(rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom), rt.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); while (true) { - const _85: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } const item2 = copy$array_u8(_85[1]); const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 17 }, (): Uint8Array => { + rs.ptrWrite(uninit4, [Array.from({ length: 17 }, (): Uint8Array => { return copy$array_u8(item2); - }), [34, 17] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + }), [34, 17] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(17, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(17, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterLend(rt.iterSlice(_131[0]), rt.byteSliceFrom), (v4: rt.ByteSlice): undefined => { + const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array17_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -627,38 +627,38 @@ export function filled$array17_u8_17(data: rt.ByteSlice, fill: Uint8Array[], out * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$array1_u8_1(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filled$array1_u8_1(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ByteVec): void { let row!: Uint8Array[]; const item = ([Array.from({ length: 1 }, (): Uint8Array => { return (new Uint8Array(1) as unknown) as Uint8Array; - }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; - const slots: [Uint8Array[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rt.u8, rt.u8]] => { + }), [undefined, undefined]] as unknown) as [Uint8Array[], [rs.u8, rs.u8]]; + const slots: [Uint8Array[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_array1_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_array1_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_array1_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom); + const picks: rs.Vec = new rs.Vec(); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - picks.items.push(copy$array_u8(rt.byteSliceToArray(_26))); + picks.items.push(copy$array_u8(rs.byteSliceToArray(_26))); } - const iter3: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } const pick: Uint8Array | undefined = _41[1]; @@ -671,51 +671,51 @@ export function filled$array1_u8_1(data: rt.ByteSlice, fill: Uint8Array[], out: }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_array1_u8(row), [1, 90] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_array1_u8(row), [1, 90] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_array1_u8(fill), rt.usizeRem(data.length, 4), copy$array_array1_u8); - const iter4: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_array1_u8(fill), rs.usizeRem(data.length, 4), copy$array_array1_u8); + const iter4: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_array1_u8(_65[1]), [17, 1] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_array1_u8(_65[1]), [17, 1] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterCopied(rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom), rt.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); while (true) { - const _85: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } const item2 = copy$array_u8(_85[1]); const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 1 }, (): Uint8Array => { + rs.ptrWrite(uninit4, [Array.from({ length: 1 }, (): Uint8Array => { return copy$array_u8(item2); - }), [34, 1] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + }), [34, 1] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(1, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(1, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterLend(rt.iterSlice(_131[0]), rt.byteSliceFrom), (v4: rt.ByteSlice): undefined => { + const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array1_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -726,38 +726,38 @@ export function filled$array1_u8_1(data: rt.ByteSlice, fill: Uint8Array[], out: * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$array3_u8_3(data: rt.ByteSlice, fill: Uint8Array[], out: rt.ByteVec): void { +export function filled$array3_u8_3(data: rs.ByteSlice, fill: Uint8Array[], out: rs.ByteVec): void { let row!: Uint8Array[]; const item = ([Array.from({ length: 3 }, (): Uint8Array => { return (new Uint8Array(3) as unknown) as Uint8Array; - }), [undefined, undefined]] as unknown) as [Uint8Array[], [rt.u8, rt.u8]]; - const slots: [Uint8Array[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rt.u8, rt.u8]] => { + }), [undefined, undefined]] as unknown) as [Uint8Array[], [rs.u8, rs.u8]]; + const slots: [Uint8Array[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_array3_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_array3_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_array3_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - const iter2: rt.Iter = rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom); + const picks: rs.Vec = new rs.Vec(); + const iter2: rs.Iter = rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - picks.items.push(copy$array_u8(rt.byteSliceToArray(_26))); + picks.items.push(copy$array_u8(rs.byteSliceToArray(_26))); } - const iter3: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } const pick: Uint8Array | undefined = _41[1]; @@ -770,51 +770,51 @@ export function filled$array3_u8_3(data: rt.ByteSlice, fill: Uint8Array[], out: }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_array3_u8(row), [3, 90] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_array3_u8(row), [3, 90] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_array3_u8(fill), rt.usizeRem(data.length, 4), copy$array_array3_u8); - const iter4: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_array3_u8(fill), rs.usizeRem(data.length, 4), copy$array_array3_u8); + const iter4: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_array3_u8(_65[1]), [17, 3] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_array3_u8(_65[1]), [17, 3] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array[], [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterCopied(rt.iterLend(rt.iterSlice(fill), rt.byteSliceFrom), rt.byteSliceToArray), [false, false]); + const iter5: rs.Iter<[[Uint8Array[], [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterCopied(rs.iterLend(rs.iterSlice(fill), rs.byteSliceFrom), rs.byteSliceToArray), [false, false]); while (true) { - const _85: [[Uint8Array[], [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array[], [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } const item2 = copy$array_u8(_85[1]); const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 3 }, (): Uint8Array => { + rs.ptrWrite(uninit4, [Array.from({ length: 3 }, (): Uint8Array => { return copy$array_u8(item2); - }), [34, 3] as [rt.u8, rt.u8]] as [Uint8Array[], [rt.u8, rt.u8]]); + }), [34, 3] as [rs.u8, rs.u8]] as [Uint8Array[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(3, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(3, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterLend(rt.iterSlice(_131[0]), rt.byteSliceFrom), (v4: rt.ByteSlice): undefined => { + const _131: [Uint8Array[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterLend(rs.iterSlice(_131[0]), rs.byteSliceFrom), (v4: rs.ByteSlice): undefined => { put$lengths_Put_array3_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -825,90 +825,90 @@ export function filled$array3_u8_3(data: rt.ByteSlice, fill: Uint8Array[], out: * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$lengths_Tagged_u32_0(data: rt.ByteSlice, fill: Tagged.Tagged[], out: rt.ByteVec): void { - let row!: Tagged.Tagged[]; - const item = ([Array.from({ length: 0 }, (): Tagged.Tagged => { - return (new Tagged.Tagged((undefined as unknown) as rt.u32, (undefined as unknown) as rt.u8) as unknown) as Tagged.Tagged; - }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rt.u8, rt.u8]]; - const slots: [Tagged.Tagged[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rt.u8, rt.u8]] => { +export function filled$lengths_Tagged_u32_0(data: rs.ByteSlice, fill: Tagged.Tagged[], out: rs.ByteVec): void { + let row!: Tagged.Tagged[]; + const item = ([Array.from({ length: 0 }, (): Tagged.Tagged => { + return (new Tagged.Tagged((undefined as unknown) as rs.u32, (undefined as unknown) as rs.u8) as unknown) as Tagged.Tagged; + }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rs.u8, rs.u8]]; + const slots: [Tagged.Tagged[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_lengths_Tagged_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec | undefined> = new rt.Vec(); + const picks: rs.Vec | undefined> = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: Tagged.Tagged | undefined = _41[1]; + const pick: Tagged.Tagged | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: Tagged.Tagged = pick; - row = Array.from({ length: 0 }, (): Tagged.Tagged => { + const v2: Tagged.Tagged = pick; + row = Array.from({ length: 0 }, (): Tagged.Tagged => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [0, 90] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [0, 90] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec[]> = rt.vecFromElem(copy$array_lengths_Tagged_u32(fill), rt.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); - const iter4: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec[]> = rs.vecFromElem(copy$array_lengths_Tagged_u32(fill), rs.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); + const iter4: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 0] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 0] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: Tagged.Tagged = _85[1]; + const v3: Tagged.Tagged = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 0 }, (): Tagged.Tagged => { + rs.ptrWrite(uninit4, [Array.from({ length: 0 }, (): Tagged.Tagged => { return v3; - }), [34, 0] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + }), [34, 0] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Tagged.Tagged[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(0, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Tagged.Tagged[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(0, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Tagged.Tagged[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { + const _131: [Tagged.Tagged[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { Tagged.put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -919,90 +919,90 @@ export function filled$lengths_Tagged_u32_0(data: rt.ByteSlice, fill: Tagged.Tag * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$lengths_Tagged_u32_1(data: rt.ByteSlice, fill: Tagged.Tagged[], out: rt.ByteVec): void { - let row!: Tagged.Tagged[]; - const item = ([Array.from({ length: 1 }, (): Tagged.Tagged => { - return (new Tagged.Tagged((undefined as unknown) as rt.u32, (undefined as unknown) as rt.u8) as unknown) as Tagged.Tagged; - }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rt.u8, rt.u8]]; - const slots: [Tagged.Tagged[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rt.u8, rt.u8]] => { +export function filled$lengths_Tagged_u32_1(data: rs.ByteSlice, fill: Tagged.Tagged[], out: rs.ByteVec): void { + let row!: Tagged.Tagged[]; + const item = ([Array.from({ length: 1 }, (): Tagged.Tagged => { + return (new Tagged.Tagged((undefined as unknown) as rs.u32, (undefined as unknown) as rs.u8) as unknown) as Tagged.Tagged; + }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rs.u8, rs.u8]]; + const slots: [Tagged.Tagged[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_lengths_Tagged_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec | undefined> = new rt.Vec(); + const picks: rs.Vec | undefined> = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: Tagged.Tagged | undefined = _41[1]; + const pick: Tagged.Tagged | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: Tagged.Tagged = pick; - row = Array.from({ length: 1 }, (): Tagged.Tagged => { + const v2: Tagged.Tagged = pick; + row = Array.from({ length: 1 }, (): Tagged.Tagged => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [1, 90] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [1, 90] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec[]> = rt.vecFromElem(copy$array_lengths_Tagged_u32(fill), rt.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); - const iter4: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec[]> = rs.vecFromElem(copy$array_lengths_Tagged_u32(fill), rs.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); + const iter4: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 1] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 1] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: Tagged.Tagged = _85[1]; + const v3: Tagged.Tagged = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 1 }, (): Tagged.Tagged => { + rs.ptrWrite(uninit4, [Array.from({ length: 1 }, (): Tagged.Tagged => { return v3; - }), [34, 1] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + }), [34, 1] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Tagged.Tagged[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(1, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Tagged.Tagged[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(1, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Tagged.Tagged[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { + const _131: [Tagged.Tagged[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { Tagged.put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1013,90 +1013,90 @@ export function filled$lengths_Tagged_u32_1(data: rt.ByteSlice, fill: Tagged.Tag * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$lengths_Tagged_u32_17(data: rt.ByteSlice, fill: Tagged.Tagged[], out: rt.ByteVec): void { - let row!: Tagged.Tagged[]; - const item = ([Array.from({ length: 17 }, (): Tagged.Tagged => { - return (new Tagged.Tagged((undefined as unknown) as rt.u32, (undefined as unknown) as rt.u8) as unknown) as Tagged.Tagged; - }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rt.u8, rt.u8]]; - const slots: [Tagged.Tagged[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rt.u8, rt.u8]] => { +export function filled$lengths_Tagged_u32_17(data: rs.ByteSlice, fill: Tagged.Tagged[], out: rs.ByteVec): void { + let row!: Tagged.Tagged[]; + const item = ([Array.from({ length: 17 }, (): Tagged.Tagged => { + return (new Tagged.Tagged((undefined as unknown) as rs.u32, (undefined as unknown) as rs.u8) as unknown) as Tagged.Tagged; + }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rs.u8, rs.u8]]; + const slots: [Tagged.Tagged[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_lengths_Tagged_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec | undefined> = new rt.Vec(); + const picks: rs.Vec | undefined> = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: Tagged.Tagged | undefined = _41[1]; + const pick: Tagged.Tagged | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: Tagged.Tagged = pick; - row = Array.from({ length: 17 }, (): Tagged.Tagged => { + const v2: Tagged.Tagged = pick; + row = Array.from({ length: 17 }, (): Tagged.Tagged => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [17, 90] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [17, 90] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec[]> = rt.vecFromElem(copy$array_lengths_Tagged_u32(fill), rt.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); - const iter4: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec[]> = rs.vecFromElem(copy$array_lengths_Tagged_u32(fill), rs.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); + const iter4: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 17] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 17] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: Tagged.Tagged = _85[1]; + const v3: Tagged.Tagged = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 17 }, (): Tagged.Tagged => { + rs.ptrWrite(uninit4, [Array.from({ length: 17 }, (): Tagged.Tagged => { return v3; - }), [34, 17] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + }), [34, 17] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Tagged.Tagged[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(17, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Tagged.Tagged[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(17, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Tagged.Tagged[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { + const _131: [Tagged.Tagged[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { Tagged.put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1107,90 +1107,90 @@ export function filled$lengths_Tagged_u32_17(data: rt.ByteSlice, fill: Tagged.Ta * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$lengths_Tagged_u32_3(data: rt.ByteSlice, fill: Tagged.Tagged[], out: rt.ByteVec): void { - let row!: Tagged.Tagged[]; - const item = ([Array.from({ length: 3 }, (): Tagged.Tagged => { - return (new Tagged.Tagged((undefined as unknown) as rt.u32, (undefined as unknown) as rt.u8) as unknown) as Tagged.Tagged; - }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rt.u8, rt.u8]]; - const slots: [Tagged.Tagged[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rt.u8, rt.u8]] => { +export function filled$lengths_Tagged_u32_3(data: rs.ByteSlice, fill: Tagged.Tagged[], out: rs.ByteVec): void { + let row!: Tagged.Tagged[]; + const item = ([Array.from({ length: 3 }, (): Tagged.Tagged => { + return (new Tagged.Tagged((undefined as unknown) as rs.u32, (undefined as unknown) as rs.u8) as unknown) as Tagged.Tagged; + }), [undefined, undefined]] as unknown) as [Tagged.Tagged[], [rs.u8, rs.u8]]; + const slots: [Tagged.Tagged[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Tagged.Tagged[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_lengths_Tagged_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Tagged.Tagged[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Tagged.Tagged[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_lengths_Tagged_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec | undefined> = new rt.Vec(); + const picks: rs.Vec | undefined> = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: Tagged.Tagged | undefined = _41[1]; + const pick: Tagged.Tagged | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: Tagged.Tagged = pick; - row = Array.from({ length: 3 }, (): Tagged.Tagged => { + const v2: Tagged.Tagged = pick; + row = Array.from({ length: 3 }, (): Tagged.Tagged => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [3, 90] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_lengths_Tagged_u32(row), [3, 90] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec[]> = rt.vecFromElem(copy$array_lengths_Tagged_u32(fill), rt.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); - const iter4: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec[]> = rs.vecFromElem(copy$array_lengths_Tagged_u32(fill), rs.usizeRem(data.length, 4), copy$array_lengths_Tagged_u32); + const iter4: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 3] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_lengths_Tagged_u32(_65[1]), [17, 3] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[Tagged.Tagged[], [rt.u8, rt.u8]], Tagged.Tagged] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Tagged.Tagged[], [rs.u8, rs.u8]], Tagged.Tagged] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: Tagged.Tagged = _85[1]; + const v3: Tagged.Tagged = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 3 }, (): Tagged.Tagged => { + rs.ptrWrite(uninit4, [Array.from({ length: 3 }, (): Tagged.Tagged => { return v3; - }), [34, 3] as [rt.u8, rt.u8]] as [Tagged.Tagged[], [rt.u8, rt.u8]]); + }), [34, 3] as [rs.u8, rs.u8]] as [Tagged.Tagged[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Tagged.Tagged[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(3, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Tagged.Tagged[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(3, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Tagged.Tagged[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { + const _131: [Tagged.Tagged[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: Tagged.Tagged): undefined => { Tagged.put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1201,88 +1201,88 @@ export function filled$lengths_Tagged_u32_3(data: rt.ByteSlice, fill: Tagged.Tag * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u32_0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { - let row!: rt.u32[]; - const item = ([new Array(0), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; - const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { +export function filled$u32_0(data: rs.ByteSlice, fill: rs.u32[], out: rs.ByteVec): void { + let row!: rs.u32[]; + const item = ([new Array(0), [undefined, undefined]] as unknown) as [rs.u32[], [rs.u8, rs.u8]]; + const slots: [rs.u32[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [rs.u32[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[rt.u32[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[rs.u32[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); + const picks: rs.Vec = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u32 | undefined = _41[1]; + const pick: rs.u32 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: rt.u32 = pick; - row = Array.from({ length: 0 }, (): rt.u32 => { + const v2: rs.u32 = pick; + row = Array.from({ length: 0 }, (): rs.u32 => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u32(row), [0, 90] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u32(row), [0, 90] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u32(fill), rt.usizeRem(data.length, 4), copy$array_u32); - const iter4: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u32(fill), rs.usizeRem(data.length, 4), copy$array_u32); + const iter4: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[rt.u32[], [rt.u8, rt.u8]], rt.u32[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[rs.u32[], [rs.u8, rs.u8]], rs.u32[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 0] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 0] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[rt.u32[], [rt.u8, rt.u8]], rt.u32] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[rs.u32[], [rs.u8, rs.u8]], rs.u32] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u32 = _85[1]; + const v3: rs.u32 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 0 }, (): rt.u32 => { + rs.ptrWrite(uninit4, [Array.from({ length: 0 }, (): rs.u32 => { return v3; - }), [34, 0] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + }), [34, 0] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [rt.u32[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(0, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [rs.u32[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(0, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [rt.u32[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: rt.u32): undefined => { + const _131: [rs.u32[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: rs.u32): undefined => { put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1293,88 +1293,88 @@ export function filled$u32_0(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u32_1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { - let row!: rt.u32[]; - const item = ([new Array(1), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; - const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { +export function filled$u32_1(data: rs.ByteSlice, fill: rs.u32[], out: rs.ByteVec): void { + let row!: rs.u32[]; + const item = ([new Array(1), [undefined, undefined]] as unknown) as [rs.u32[], [rs.u8, rs.u8]]; + const slots: [rs.u32[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [rs.u32[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[rt.u32[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[rs.u32[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); + const picks: rs.Vec = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u32 | undefined = _41[1]; + const pick: rs.u32 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: rt.u32 = pick; - row = Array.from({ length: 1 }, (): rt.u32 => { + const v2: rs.u32 = pick; + row = Array.from({ length: 1 }, (): rs.u32 => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u32(row), [1, 90] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u32(row), [1, 90] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u32(fill), rt.usizeRem(data.length, 4), copy$array_u32); - const iter4: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u32(fill), rs.usizeRem(data.length, 4), copy$array_u32); + const iter4: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[rt.u32[], [rt.u8, rt.u8]], rt.u32[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[rs.u32[], [rs.u8, rs.u8]], rs.u32[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 1] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 1] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[rt.u32[], [rt.u8, rt.u8]], rt.u32] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[rs.u32[], [rs.u8, rs.u8]], rs.u32] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u32 = _85[1]; + const v3: rs.u32 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 1 }, (): rt.u32 => { + rs.ptrWrite(uninit4, [Array.from({ length: 1 }, (): rs.u32 => { return v3; - }), [34, 1] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + }), [34, 1] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [rt.u32[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(1, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [rs.u32[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(1, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [rt.u32[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: rt.u32): undefined => { + const _131: [rs.u32[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: rs.u32): undefined => { put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1385,88 +1385,88 @@ export function filled$u32_1(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u32_17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { - let row!: rt.u32[]; - const item = ([new Array(17), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; - const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { +export function filled$u32_17(data: rs.ByteSlice, fill: rs.u32[], out: rs.ByteVec): void { + let row!: rs.u32[]; + const item = ([new Array(17), [undefined, undefined]] as unknown) as [rs.u32[], [rs.u8, rs.u8]]; + const slots: [rs.u32[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [rs.u32[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[rt.u32[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[rs.u32[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); + const picks: rs.Vec = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u32 | undefined = _41[1]; + const pick: rs.u32 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: rt.u32 = pick; - row = Array.from({ length: 17 }, (): rt.u32 => { + const v2: rs.u32 = pick; + row = Array.from({ length: 17 }, (): rs.u32 => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u32(row), [17, 90] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u32(row), [17, 90] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u32(fill), rt.usizeRem(data.length, 4), copy$array_u32); - const iter4: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u32(fill), rs.usizeRem(data.length, 4), copy$array_u32); + const iter4: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[rt.u32[], [rt.u8, rt.u8]], rt.u32[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[rs.u32[], [rs.u8, rs.u8]], rs.u32[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 17] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 17] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[rt.u32[], [rt.u8, rt.u8]], rt.u32] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[rs.u32[], [rs.u8, rs.u8]], rs.u32] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u32 = _85[1]; + const v3: rs.u32 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 17 }, (): rt.u32 => { + rs.ptrWrite(uninit4, [Array.from({ length: 17 }, (): rs.u32 => { return v3; - }), [34, 17] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + }), [34, 17] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [rt.u32[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(17, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [rs.u32[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(17, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [rt.u32[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: rt.u32): undefined => { + const _131: [rs.u32[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: rs.u32): undefined => { put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1477,88 +1477,88 @@ export function filled$u32_17(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVe * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u32_3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec): void { - let row!: rt.u32[]; - const item = ([new Array(3), [undefined, undefined]] as unknown) as [rt.u32[], [rt.u8, rt.u8]]; - const slots: [rt.u32[], [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [rt.u32[], [rt.u8, rt.u8]] => { +export function filled$u32_3(data: rs.ByteSlice, fill: rs.u32[], out: rs.ByteVec): void { + let row!: rs.u32[]; + const item = ([new Array(3), [undefined, undefined]] as unknown) as [rs.u32[], [rs.u8, rs.u8]]; + const slots: [rs.u32[], [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [rs.u32[], [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[rt.u32[], [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[rs.u32[], [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u32(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); + const picks: rs.Vec = new rs.Vec(); for (const _26 of fill) { picks.items.push(_26); } - const iter3: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[rt.u32[], [rt.u8, rt.u8]], rt.u32 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[rs.u32[], [rs.u8, rs.u8]], rs.u32 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u32 | undefined = _41[1]; + const pick: rs.u32 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - const v2: rt.u32 = pick; - row = Array.from({ length: 3 }, (): rt.u32 => { + const v2: rs.u32 = pick; + row = Array.from({ length: 3 }, (): rs.u32 => { return v2; }); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u32(row), [3, 90] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u32(row), [3, 90] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u32(fill), rt.usizeRem(data.length, 4), copy$array_u32); - const iter4: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32[]]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u32(fill), rs.usizeRem(data.length, 4), copy$array_u32); + const iter4: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32[]]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[rt.u32[], [rt.u8, rt.u8]], rt.u32[]] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[rs.u32[], [rs.u8, rs.u8]], rs.u32[]] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 3] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u32(_65[1]), [17, 3] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[rt.u32[], [rt.u8, rt.u8]], rt.u32]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(fill), [false, false]); + const iter5: rs.Iter<[[rs.u32[], [rs.u8, rs.u8]], rs.u32]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(fill), [false, false]); while (true) { - const _85: [[rt.u32[], [rt.u8, rt.u8]], rt.u32] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[rs.u32[], [rs.u8, rs.u8]], rs.u32] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u32 = _85[1]; + const v3: rs.u32 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [Array.from({ length: 3 }, (): rt.u32 => { + rs.ptrWrite(uninit4, [Array.from({ length: 3 }, (): rs.u32 => { return v3; - }), [34, 3] as [rt.u8, rt.u8]] as [rt.u32[], [rt.u8, rt.u8]]); + }), [34, 3] as [rs.u8, rs.u8]] as [rs.u32[], [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [rt.u32[], [rt.u8, rt.u8]] = slots[_103]; - rt.sliceRotateLeft(slot[0], rt.usizeRem(byte as rt.usize, rt.max(3, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [rs.u32[], [rs.u8, rs.u8]] = slots[_103]; + rs.sliceRotateLeft(slot[0], rs.usizeRem(byte as rs.usize, rs.max(3, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [rt.u32[], [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(_131[0]), (v4: rt.u32): undefined => { + const _131: [rs.u32[], [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(_131[0]), (v4: rs.u32): undefined => { put$lengths_Put_u32(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1569,83 +1569,83 @@ export function filled$u32_3(data: rt.ByteSlice, fill: rt.u32[], out: rt.ByteVec * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u8_0(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filled$u8_0(data: rs.ByteSlice, fill: Uint8Array, out: rs.ByteVec): void { let row!: Uint8Array; - const item = ([new Uint8Array(0), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; - const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { + const item = ([new Uint8Array(0), [undefined, undefined]] as unknown) as [Uint8Array, [rs.u8, rs.u8]]; + const slots: [Uint8Array, [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - for (const _26 of rt.byteSliceView(rt.byteSliceFrom(fill))) { + const picks: rs.Vec = new rs.Vec(); + for (const _26 of rs.byteSliceView(rs.byteSliceFrom(fill))) { picks.items.push(_26); } - const iter3: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u8 | undefined = _41[1]; + const pick: rs.u8 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - row = rt.bytes(0).fill(pick); + row = rs.bytes(0).fill(pick); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u8(row), [0, 90] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u8(row), [0, 90] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u8(fill), rt.usizeRem(data.length, 4), copy$array_u8); - const iter4: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u8(fill), rs.usizeRem(data.length, 4), copy$array_u8); + const iter4: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 0] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 0] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(fill))), [false, false]); + const iter5: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(fill))), [false, false]); while (true) { - const _85: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u8 = _85[1]; + const v3: rs.u8 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [rt.bytes(0).fill(v3), [34, 0] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit4, [rs.bytes(0).fill(v3), [34, 0] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array, [rt.u8, rt.u8]] = slots[_103]; - rt.byteSliceRotateLeft(rt.byteSliceFrom(slot[0]), rt.usizeRem(byte as rt.usize, rt.max(0, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array, [rs.u8, rs.u8]] = slots[_103]; + rs.byteSliceRotateLeft(rs.byteSliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(0, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array, [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(_131[0]))), (v4: rt.u8): undefined => { + const _131: [Uint8Array, [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_131[0]))), (v4: rs.u8): undefined => { put$lengths_Put_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1656,83 +1656,83 @@ export function filled$u8_0(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVe * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u8_1(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filled$u8_1(data: rs.ByteSlice, fill: Uint8Array, out: rs.ByteVec): void { let row!: Uint8Array; - const item = ([new Uint8Array(1), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; - const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { + const item = ([new Uint8Array(1), [undefined, undefined]] as unknown) as [Uint8Array, [rs.u8, rs.u8]]; + const slots: [Uint8Array, [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - for (const _26 of rt.byteSliceView(rt.byteSliceFrom(fill))) { + const picks: rs.Vec = new rs.Vec(); + for (const _26 of rs.byteSliceView(rs.byteSliceFrom(fill))) { picks.items.push(_26); } - const iter3: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u8 | undefined = _41[1]; + const pick: rs.u8 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - row = rt.bytes(1).fill(pick); + row = rs.bytes(1).fill(pick); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u8(row), [1, 90] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u8(row), [1, 90] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u8(fill), rt.usizeRem(data.length, 4), copy$array_u8); - const iter4: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u8(fill), rs.usizeRem(data.length, 4), copy$array_u8); + const iter4: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 1] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 1] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(fill))), [false, false]); + const iter5: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(fill))), [false, false]); while (true) { - const _85: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u8 = _85[1]; + const v3: rs.u8 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [rt.bytes(1).fill(v3), [34, 1] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit4, [rs.bytes(1).fill(v3), [34, 1] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array, [rt.u8, rt.u8]] = slots[_103]; - rt.byteSliceRotateLeft(rt.byteSliceFrom(slot[0]), rt.usizeRem(byte as rt.usize, rt.max(1, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array, [rs.u8, rs.u8]] = slots[_103]; + rs.byteSliceRotateLeft(rs.byteSliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(1, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array, [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(_131[0]))), (v4: rt.u8): undefined => { + const _131: [Uint8Array, [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_131[0]))), (v4: rs.u8): undefined => { put$lengths_Put_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1743,83 +1743,83 @@ export function filled$u8_1(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVe * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u8_17(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filled$u8_17(data: rs.ByteSlice, fill: Uint8Array, out: rs.ByteVec): void { let row!: Uint8Array; - const item = ([new Uint8Array(17), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; - const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { + const item = ([new Uint8Array(17), [undefined, undefined]] as unknown) as [Uint8Array, [rs.u8, rs.u8]]; + const slots: [Uint8Array, [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - for (const _26 of rt.byteSliceView(rt.byteSliceFrom(fill))) { + const picks: rs.Vec = new rs.Vec(); + for (const _26 of rs.byteSliceView(rs.byteSliceFrom(fill))) { picks.items.push(_26); } - const iter3: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u8 | undefined = _41[1]; + const pick: rs.u8 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - row = rt.bytes(17).fill(pick); + row = rs.bytes(17).fill(pick); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u8(row), [17, 90] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u8(row), [17, 90] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u8(fill), rt.usizeRem(data.length, 4), copy$array_u8); - const iter4: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u8(fill), rs.usizeRem(data.length, 4), copy$array_u8); + const iter4: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 17] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 17] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(fill))), [false, false]); + const iter5: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(fill))), [false, false]); while (true) { - const _85: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u8 = _85[1]; + const v3: rs.u8 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [rt.bytes(17).fill(v3), [34, 17] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit4, [rs.bytes(17).fill(v3), [34, 17] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array, [rt.u8, rt.u8]] = slots[_103]; - rt.byteSliceRotateLeft(rt.byteSliceFrom(slot[0]), rt.usizeRem(byte as rt.usize, rt.max(17, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array, [rs.u8, rs.u8]] = slots[_103]; + rs.byteSliceRotateLeft(rs.byteSliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(17, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array, [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(_131[0]))), (v4: rt.u8): undefined => { + const _131: [Uint8Array, [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_131[0]))), (v4: rs.u8): undefined => { put$lengths_Put_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } @@ -1830,154 +1830,154 @@ export function filled$u8_17(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteV * last beside `fill`'s values copied, whose iterators point at what a slot holds, then * changed in place, a pair of tags through a pointer to it, and read back. */ -export function filled$u8_3(data: rt.ByteSlice, fill: Uint8Array, out: rt.ByteVec): void { +export function filled$u8_3(data: rs.ByteSlice, fill: Uint8Array, out: rs.ByteVec): void { let row!: Uint8Array; - const item = ([new Uint8Array(3), [undefined, undefined]] as unknown) as [Uint8Array, [rt.u8, rt.u8]]; - const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { + const item = ([new Uint8Array(3), [undefined, undefined]] as unknown) as [Uint8Array, [rs.u8, rs.u8]]; + const slots: [Uint8Array, [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSlice(slots), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSlice(slots), new rs.RangeFrom(0, rs.u8Step), "len"); while (true) { - const _12: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const at: rt.u8 = _12[1]; + const at: rs.u8 = _12[1]; const uninit = _12[0]; - rt.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u8(fill), [at, ~at & 0xff] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit; } - const picks: rt.Vec = new rt.Vec(); - for (const _26 of rt.byteSliceView(rt.byteSliceFrom(fill))) { + const picks: rs.Vec = new rs.Vec(); + for (const _26 of rs.byteSliceView(rs.byteSliceFrom(fill))) { picks.items.push(_26); } - const iter3: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 1), rt.vecIntoIter(picks), "index"); + const iter3: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 1), rs.vecIntoIter(picks), "index"); while (true) { - const _41: [[Uint8Array, [rt.u8, rt.u8]], rt.u8 | undefined] | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: [[Uint8Array, [rs.u8, rs.u8]], rs.u8 | undefined] | rs.Done = iter3.next(); + if (_41 === rs.DONE) { break; } - const pick: rt.u8 | undefined = _41[1]; + const pick: rs.u8 | undefined = _41[1]; if (pick === undefined) { row = fill; } else { - row = rt.bytes(3).fill(pick); + row = rs.bytes(3).fill(pick); } const uninit2 = _41[0]; - rt.ptrWrite(uninit2, [copy$array_u8(row), [3, 90] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u8(row), [3, 90] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit2; } - const rows: rt.Vec = rt.vecFromElem(copy$array_u8(fill), rt.usizeRem(data.length, 4), copy$array_u8); - const iter4: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const rows: rs.Vec = rs.vecFromElem(copy$array_u8(fill), rs.usizeRem(data.length, 4), copy$array_u8); + const iter4: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _65: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter4.next(); - if (_65 === rt.DONE) { + const _65: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter4.next(); + if (_65 === rs.DONE) { break; } const uninit3 = _65[0]; - rt.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 3] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [copy$array_u8(_65[1]), [17, 3] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit3; } - const iter5: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(fill))), [false, false]); + const iter5: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(fill))), [false, false]); while (true) { - const _85: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter5.next(); - if (_85 === rt.DONE) { + const _85: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter5.next(); + if (_85 === rs.DONE) { break; } - const v3: rt.u8 = _85[1]; + const v3: rs.u8 = _85[1]; const uninit4 = _85[0]; - rt.ptrWrite(uninit4, [rt.bytes(3).fill(v3), [34, 3] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit4, [rs.bytes(3).fill(v3), [34, 3] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit4; } - for (const byte of rt.byteSliceView(data)) { - const _103: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _103: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_103 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _103); } - const slot: [Uint8Array, [rt.u8, rt.u8]] = slots[_103]; - rt.byteSliceRotateLeft(rt.byteSliceFrom(slot[0]), rt.usizeRem(byte as rt.usize, rt.max(3, 1))); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array, [rs.u8, rs.u8]] = slots[_103]; + rs.byteSliceRotateLeft(rs.byteSliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, rs.max(3, 1))); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - tags[1] = rt.u8WrappingAdd(tags[1], byte); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + tags[1] = rs.u8WrappingAdd(tags[1], byte); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _124 of slots) { - const _131: [Uint8Array, [rt.u8, rt.u8]] = _124; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(_131[0]))), (v4: rt.u8): undefined => { + const _131: [Uint8Array, [rs.u8, rs.u8]] = _124; + rs.iterForEach(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_131[0]))), (v4: rs.u8): undefined => { put$lengths_Put_u8(v4, out); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_131[1][0], _131[1][1])), undefined, true); } } -export function put$lengths_Put_u8(self: rt.u8, out: rt.ByteVec): void { - rt.byteVecPush(out, self); +export function put$lengths_Put_u8(self: rs.u8, out: rs.ByteVec): void { + rs.byteVecPush(out, self); } -export function put$lengths_Put_u32(self: rt.u32, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(self).reverse()), undefined, true); +export function put$lengths_Put_u32(self: rs.u32, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(self).reverse()), undefined, true); } -export function put$lengths_Put_array0_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array0_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array17_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array17_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array1_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array1_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } -export function put$lengths_Put_array3_u8(self: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, self); +export function put$lengths_Put_array3_u8(self: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, self); } /** * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); +export function swapped$u32_0(data: rs.ByteSlice, rows: rs.u32[][], out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[][]] | undefined = rs.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u32(copy$array_u32(_6[0])); - const grid: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rt.u32[] | undefined = rt.sliceFirst(_6[1]); + const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); if (_9 !== undefined) { - const next: rt.u32[] = copy$array_u32(_9); + const next: rs.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; - const row: rt.u32[] = copy$array_u32(grid[0]); - const _23: rt.u32[] = copy$array_u32(grid[1]); + const byte: rs.u8 = _16; + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); grid[0] = _23; - const _28: rt.u32[] = copy$array_u32(row); + const _28: rs.u32[] = copy$array_u32(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(grid[_35]); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u32 | undefined] = [_32, rt.sliceLast(rows[_42])]; + const _32: rs.Place | undefined = rs.sliceFirstMut(grid[_35]); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rows[_42])]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 0)), (_2: rt.u32): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 0)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -1989,46 +1989,46 @@ export function swapped$u32_0(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); +export function swapped$u32_1(data: rs.ByteSlice, rows: rs.u32[][], out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[][]] | undefined = rs.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u32(copy$array_u32(_6[0])); - const grid: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rt.u32[] | undefined = rt.sliceFirst(_6[1]); + const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); if (_9 !== undefined) { - const next: rt.u32[] = copy$array_u32(_9); + const next: rs.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; - const row: rt.u32[] = copy$array_u32(grid[0]); - const _23: rt.u32[] = copy$array_u32(grid[1]); + const byte: rs.u8 = _16; + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); grid[0] = _23; - const _28: rt.u32[] = copy$array_u32(row); + const _28: rs.u32[] = copy$array_u32(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(grid[_35]); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u32 | undefined] = [_32, rt.sliceLast(rows[_42])]; + const _32: rs.Place | undefined = rs.sliceFirstMut(grid[_35]); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rows[_42])]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 1)), (_2: rt.u32): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 1)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2040,46 +2040,46 @@ export function swapped$u32_1(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); +export function swapped$u32_17(data: rs.ByteSlice, rows: rs.u32[][], out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[][]] | undefined = rs.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u32(copy$array_u32(_6[0])); - const grid: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rt.u32[] | undefined = rt.sliceFirst(_6[1]); + const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); if (_9 !== undefined) { - const next: rt.u32[] = copy$array_u32(_9); + const next: rs.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; - const row: rt.u32[] = copy$array_u32(grid[0]); - const _23: rt.u32[] = copy$array_u32(grid[1]); + const byte: rs.u8 = _16; + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); grid[0] = _23; - const _28: rt.u32[] = copy$array_u32(row); + const _28: rs.u32[] = copy$array_u32(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(grid[_35]); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u32 | undefined] = [_32, rt.sliceLast(rows[_42])]; + const _32: rs.Place | undefined = rs.sliceFirstMut(grid[_35]); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rows[_42])]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 17)), (_2: rt.u32): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 17)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2091,46 +2091,46 @@ export function swapped$u32_17(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[][]] | undefined = rt.sliceSplitFirst(rows); +export function swapped$u32_3(data: rs.ByteSlice, rows: rs.u32[][], out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[][]] | undefined = rs.sliceSplitFirst(rows); b0: { if (_6 !== undefined) { const item = copy$array_u32(copy$array_u32(_6[0])); - const grid: rt.u32[][] = Array.from({ length: 2 }, (): rt.u32[] => { + const grid: rs.u32[][] = Array.from({ length: 2 }, (): rs.u32[] => { return copy$array_u32(item); }); - const _9: rt.u32[] | undefined = rt.sliceFirst(_6[1]); + const _9: rs.u32[] | undefined = rs.sliceFirst(_6[1]); if (_9 !== undefined) { - const next: rt.u32[] = copy$array_u32(_9); + const next: rs.u32[] = copy$array_u32(_9); grid[1] = copy$array_u32(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; - const row: rt.u32[] = copy$array_u32(grid[0]); - const _23: rt.u32[] = copy$array_u32(grid[1]); + const byte: rs.u8 = _16; + const row: rs.u32[] = copy$array_u32(grid[0]); + const _23: rs.u32[] = copy$array_u32(grid[1]); grid[0] = _23; - const _28: rt.u32[] = copy$array_u32(row); + const _28: rs.u32[] = copy$array_u32(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(grid[_35]); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u32 | undefined] = [_32, rt.sliceLast(rows[_42])]; + const _32: rs.Place | undefined = rs.sliceFirstMut(grid[_35]); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u32 | undefined] = [_32, rs.sliceLast(rows[_42])]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(row), rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 3)), (_2: rt.u32): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(row), rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 3)), (_2: rs.u32): rs.u8 => { return _2 & 0xff; }), undefined, true); } @@ -2142,49 +2142,49 @@ export function swapped$u32_3(data: rt.ByteSlice, rows: rt.u32[][], out: rt.Byte * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { - return [rt.byteSliceFrom(held[0]), held[1]]; +export function swapped$u8_0(data: rs.ByteSlice, rows: Uint8Array[], out: rs.ByteVec): void { + const _6: [rs.ByteSlice, Uint8Array[]] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, Uint8Array[]] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }); b0: { if (_6 !== undefined) { - const item = copy$array_u8(rt.byteSliceToArray(_6[0])); + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(_6[1]), rt.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); if (_9 !== undefined) { - const next: Uint8Array = rt.byteSliceToArray(_9); + const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; + const byte: rs.u8 = _16; const row: Uint8Array = copy$array_u8(grid[0]); const _23: Uint8Array = copy$array_u8(grid[1]); grid[0] = _23; const _28: Uint8Array = copy$array_u8(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(grid[_35]))); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u8 | undefined] = [_32, rt.byteSliceLast(rt.byteSliceFrom(rows[_42]))]; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(grid[_35]))); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows[_42]))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 0)), (_2: rt.u8): rt.u8 => { - return (_2 as rt.u32) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 0)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; }), undefined, true); } } @@ -2195,49 +2195,49 @@ export function swapped$u8_0(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { - return [rt.byteSliceFrom(held[0]), held[1]]; +export function swapped$u8_1(data: rs.ByteSlice, rows: Uint8Array[], out: rs.ByteVec): void { + const _6: [rs.ByteSlice, Uint8Array[]] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, Uint8Array[]] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }); b0: { if (_6 !== undefined) { - const item = copy$array_u8(rt.byteSliceToArray(_6[0])); + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(_6[1]), rt.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); if (_9 !== undefined) { - const next: Uint8Array = rt.byteSliceToArray(_9); + const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; + const byte: rs.u8 = _16; const row: Uint8Array = copy$array_u8(grid[0]); const _23: Uint8Array = copy$array_u8(grid[1]); grid[0] = _23; const _28: Uint8Array = copy$array_u8(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(grid[_35]))); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u8 | undefined] = [_32, rt.byteSliceLast(rt.byteSliceFrom(rows[_42]))]; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(grid[_35]))); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows[_42]))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 1)), (_2: rt.u8): rt.u8 => { - return (_2 as rt.u32) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 1)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; }), undefined, true); } } @@ -2248,49 +2248,49 @@ export function swapped$u8_1(data: rt.ByteSlice, rows: Uint8Array[], out: rt.Byt * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { - return [rt.byteSliceFrom(held[0]), held[1]]; +export function swapped$u8_17(data: rs.ByteSlice, rows: Uint8Array[], out: rs.ByteVec): void { + const _6: [rs.ByteSlice, Uint8Array[]] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, Uint8Array[]] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }); b0: { if (_6 !== undefined) { - const item = copy$array_u8(rt.byteSliceToArray(_6[0])); + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(_6[1]), rt.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); if (_9 !== undefined) { - const next: Uint8Array = rt.byteSliceToArray(_9); + const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; + const byte: rs.u8 = _16; const row: Uint8Array = copy$array_u8(grid[0]); const _23: Uint8Array = copy$array_u8(grid[1]); grid[0] = _23; const _28: Uint8Array = copy$array_u8(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(grid[_35]))); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u8 | undefined] = [_32, rt.byteSliceLast(rt.byteSliceFrom(rows[_42]))]; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(grid[_35]))); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows[_42]))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 17)), (_2: rt.u8): rt.u8 => { - return (_2 as rt.u32) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 17)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; }), undefined, true); } } @@ -2301,59 +2301,59 @@ export function swapped$u8_17(data: rt.ByteSlice, rows: Uint8Array[], out: rt.By * Rows of a grid swapped whole, each copy kept apart from the row it was read from as * either changes. */ -export function swapped$u8_3(data: rt.ByteSlice, rows: Uint8Array[], out: rt.ByteVec): void { - const _6: [rt.ByteSlice, Uint8Array[]] | undefined = rt.optionMap(rt.sliceSplitFirst(rows), (held): [rt.ByteSlice, Uint8Array[]] => { - return [rt.byteSliceFrom(held[0]), held[1]]; +export function swapped$u8_3(data: rs.ByteSlice, rows: Uint8Array[], out: rs.ByteVec): void { + const _6: [rs.ByteSlice, Uint8Array[]] | undefined = rs.optionMap(rs.sliceSplitFirst(rows), (held): [rs.ByteSlice, Uint8Array[]] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }); b0: { if (_6 !== undefined) { - const item = copy$array_u8(rt.byteSliceToArray(_6[0])); + const item = copy$array_u8(rs.byteSliceToArray(_6[0])); const grid: Uint8Array[] = Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(item); }); - const _9: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(_6[1]), rt.byteSliceFrom); + const _9: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(_6[1]), rs.byteSliceFrom); if (_9 !== undefined) { - const next: Uint8Array = rt.byteSliceToArray(_9); + const next: Uint8Array = rs.byteSliceToArray(_9); grid[1] = copy$array_u8(next); } - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _16: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_16 === rt.DONE) { + const _16: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_16 === rs.DONE) { break b0; } - const byte: rt.u8 = _16; + const byte: rs.u8 = _16; const row: Uint8Array = copy$array_u8(grid[0]); const _23: Uint8Array = copy$array_u8(grid[1]); grid[0] = _23; const _28: Uint8Array = copy$array_u8(row); grid[1] = _28; - const _35: rt.usize = rt.usizeRem(byte as rt.usize, 2); + const _35: rs.usize = rs.usizeRem(byte as rs.usize, 2); if (!(_35 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _35); } - const _32: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteSliceFrom(grid[_35]))); - const _42: rt.usize = rt.usizeRem(byte as rt.usize, rows.length); - rt.idx(rows, _42); - const _31: [rt.Place | undefined, rt.u8 | undefined] = [_32, rt.byteSliceLast(rt.byteSliceFrom(rows[_42]))]; + const _32: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteSliceFrom(grid[_35]))); + const _42: rs.usize = rs.usizeRem(byte as rs.usize, rows.length); + rs.idx(rows, _42); + const _31: [rs.Place | undefined, rs.u8 | undefined] = [_32, rs.byteSliceLast(rs.byteSliceFrom(rows[_42]))]; if (_32 !== undefined) { if (_31[1] !== undefined) { _32.v = _31[1]; } } - rt.iterExtendBytes(out, rt.iterMap(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(row))), rt.iterFlatten(rt.iterLend(rt.iterSlice(grid), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 3)), (_2: rt.u8): rt.u8 => { - return (_2 as rt.u32) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(row))), rs.iterFlatten(rs.iterLend(rs.iterSlice(grid), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 3)), (_2: rs.u8): rs.u8 => { + return (_2 as rs.u32) & 0xff; }), undefined, true); } } } } -export const CLONES: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(CLONES$init, false); +export const CLONES: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(CLONES$init, false); -export function CLONES$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function CLONES$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } /** @@ -2361,57 +2361,57 @@ export function CLONES$init(): rt.RefCell { * `Clone`, each vector then [`rewritten`], every row kept apart from the others and from * the array's. */ -export function repeated$lengths_Loud(_dataData: Uint8Array, _dataStart: number, dataLen: number, x: Loud.Loud, y: Loud.Loud, out: rt.ByteVec): void { - const rows: Row.Row[] = [new Row.Row(y, [1, 2] as [rt.u8, rt.u8]), new Row.Row(x, [3, 4] as [rt.u8, rt.u8])]; - const copies: rt.Vec> = rt.iterToVec(rt.iterCopied(rt.iterSlice(rows), copy$lengths_Row_lengths_Loud), undefined, 4, true); - rt.byteVecPush(out, copies.items.length & 0xff); - const _19: Row.Row | undefined = rt.sliceFirst(copies.items); +export function repeated$lengths_Loud(_dataData: Uint8Array, _dataStart: number, dataLen: number, x: Loud.Loud, y: Loud.Loud, out: rs.ByteVec): void { + const rows: Row.Row[] = [new Row.Row(y, [1, 2] as [rs.u8, rs.u8]), new Row.Row(x, [3, 4] as [rs.u8, rs.u8])]; + const copies: rs.Vec> = rs.iterToVec(rs.iterCopied(rs.iterSlice(rows), copy$lengths_Row_lengths_Loud), undefined, 4, true); + rs.byteVecPush(out, copies.items.length & 0xff); + const _19: Row.Row | undefined = rs.sliceFirst(copies.items); if (_19 !== undefined) { - Object.assign(_19, new Row.Row(x, [48, 49] as [rt.u8, rt.u8])); - const tags: [rt.u8, rt.u8] = _19._1; + Object.assign(_19, new Row.Row(x, [48, 49] as [rs.u8, rs.u8])); + const tags: [rs.u8, rs.u8] = _19._1; tags[0] = tags[0] ^ 16; } - const _27: Row.Row | undefined = rt.sliceGet(copies.items, 1); + const _27: Row.Row | undefined = rs.sliceGet(copies.items, 1); if (_27 !== undefined) { _27._1[1] = _27._1[1] ^ 32; } for (const _35 of copies.items) { const value: Loud.Loud = _35._0; - const a: rt.u8 = _35._1[0]; - const b: rt.u8 = _35._1[1]; + const a: rs.u8 = _35._1[0]; + const b: rs.u8 = _35._1[1]; Loud.put$lengths_Put(value, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a, b)), undefined, true); } - const repeats: rt.Vec> = rt.vecFromElem(new Row.Row(x, [5, 6] as [rt.u8, rt.u8]), rt.usizeAdd(1, rt.usizeRem(dataLen, 3)), Row.clone$Clone_lengths_Loud); - rt.byteVecPush(out, repeats.items.length & 0xff); - const _57: Row.Row | undefined = rt.sliceFirst(repeats.items); + const repeats: rs.Vec> = rs.vecFromElem(new Row.Row(x, [5, 6] as [rs.u8, rs.u8]), rs.usizeAdd(1, rs.usizeRem(dataLen, 3)), Row.clone$Clone_lengths_Loud); + rs.byteVecPush(out, repeats.items.length & 0xff); + const _57: Row.Row | undefined = rs.sliceFirst(repeats.items); if (_57 !== undefined) { - Object.assign(_57, new Row.Row(x, [48, 49] as [rt.u8, rt.u8])); - const tags2: [rt.u8, rt.u8] = _57._1; + Object.assign(_57, new Row.Row(x, [48, 49] as [rs.u8, rs.u8])); + const tags2: [rs.u8, rs.u8] = _57._1; tags2[0] = tags2[0] ^ 16; } - const _65: Row.Row | undefined = rt.sliceGet(repeats.items, 1); + const _65: Row.Row | undefined = rs.sliceGet(repeats.items, 1); if (_65 !== undefined) { _65._1[1] = _65._1[1] ^ 32; } for (const _73 of repeats.items) { const value2: Loud.Loud = _73._0; - const a2: rt.u8 = _73._1[0]; - const b2: rt.u8 = _73._1[1]; + const a2: rs.u8 = _73._1[0]; + const b2: rs.u8 = _73._1[1]; Loud.put$lengths_Put(value2, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a2, b2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a2, b2)), undefined, true); } - const iter3: rt.Iter> = rt.iterSlice(copy$array_lengths_Row_lengths_Loud(rows)); + const iter3: rs.Iter> = rs.iterSlice(copy$array_lengths_Row_lengths_Loud(rows)); while (true) { - const _86: Row.Row | rt.Done = iter3.next(); - if (_86 === rt.DONE) { + const _86: Row.Row | rs.Done = iter3.next(); + if (_86 === rs.DONE) { break; } const value3: Loud.Loud = _86._0; - const a3: rt.u8 = _86._1[0]; - const b3: rt.u8 = _86._1[1]; + const a3: rs.u8 = _86._1[0]; + const b3: rs.u8 = _86._1[1]; Loud.put$lengths_Put(value3, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a3, b3)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a3, b3)), undefined, true); } } @@ -2420,115 +2420,115 @@ export function repeated$lengths_Loud(_dataData: Uint8Array, _dataStart: number, * `Clone`, each vector then [`rewritten`], every row kept apart from the others and from * the array's. */ -export function repeated$u8(_dataData: Uint8Array, _dataStart: number, dataLen: number, x: rt.u8, y: rt.u8, out: rt.ByteVec): void { - const rows: Row.Row[] = [new Row.Row(y, [1, 2] as [rt.u8, rt.u8]), new Row.Row(x, [3, 4] as [rt.u8, rt.u8])]; - const copies: rt.Vec> = rt.iterToVec(rt.iterCopied(rt.iterSlice(rows), copy$lengths_Row_u8), undefined, 3, true); - rt.byteVecPush(out, copies.items.length & 0xff); - const _19: Row.Row | undefined = rt.sliceFirst(copies.items); +export function repeated$u8(_dataData: Uint8Array, _dataStart: number, dataLen: number, x: rs.u8, y: rs.u8, out: rs.ByteVec): void { + const rows: Row.Row[] = [new Row.Row(y, [1, 2] as [rs.u8, rs.u8]), new Row.Row(x, [3, 4] as [rs.u8, rs.u8])]; + const copies: rs.Vec> = rs.iterToVec(rs.iterCopied(rs.iterSlice(rows), copy$lengths_Row_u8), undefined, 3, true); + rs.byteVecPush(out, copies.items.length & 0xff); + const _19: Row.Row | undefined = rs.sliceFirst(copies.items); if (_19 !== undefined) { - Object.assign(_19, new Row.Row(x, [48, 49] as [rt.u8, rt.u8])); - const tags: [rt.u8, rt.u8] = _19._1; + Object.assign(_19, new Row.Row(x, [48, 49] as [rs.u8, rs.u8])); + const tags: [rs.u8, rs.u8] = _19._1; tags[0] = tags[0] ^ 16; } - const _27: Row.Row | undefined = rt.sliceGet(copies.items, 1); + const _27: Row.Row | undefined = rs.sliceGet(copies.items, 1); if (_27 !== undefined) { _27._1[1] = _27._1[1] ^ 32; } for (const _35 of copies.items) { - const value: rt.u8 = _35._0; - const a: rt.u8 = _35._1[0]; - const b: rt.u8 = _35._1[1]; + const value: rs.u8 = _35._0; + const a: rs.u8 = _35._1[0]; + const b: rs.u8 = _35._1[1]; put$lengths_Put_u8(value, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a, b)), undefined, true); } - const repeats: rt.Vec> = rt.vecFromElem(new Row.Row(x, [5, 6] as [rt.u8, rt.u8]), rt.usizeAdd(1, rt.usizeRem(dataLen, 3)), copy$lengths_Row_u8); - rt.byteVecPush(out, repeats.items.length & 0xff); - const _57: Row.Row | undefined = rt.sliceFirst(repeats.items); + const repeats: rs.Vec> = rs.vecFromElem(new Row.Row(x, [5, 6] as [rs.u8, rs.u8]), rs.usizeAdd(1, rs.usizeRem(dataLen, 3)), copy$lengths_Row_u8); + rs.byteVecPush(out, repeats.items.length & 0xff); + const _57: Row.Row | undefined = rs.sliceFirst(repeats.items); if (_57 !== undefined) { - Object.assign(_57, new Row.Row(x, [48, 49] as [rt.u8, rt.u8])); - const tags2: [rt.u8, rt.u8] = _57._1; + Object.assign(_57, new Row.Row(x, [48, 49] as [rs.u8, rs.u8])); + const tags2: [rs.u8, rs.u8] = _57._1; tags2[0] = tags2[0] ^ 16; } - const _65: Row.Row | undefined = rt.sliceGet(repeats.items, 1); + const _65: Row.Row | undefined = rs.sliceGet(repeats.items, 1); if (_65 !== undefined) { _65._1[1] = _65._1[1] ^ 32; } for (const _73 of repeats.items) { - const value2: rt.u8 = _73._0; - const a2: rt.u8 = _73._1[0]; - const b2: rt.u8 = _73._1[1]; + const value2: rs.u8 = _73._0; + const a2: rs.u8 = _73._1[0]; + const b2: rs.u8 = _73._1[1]; put$lengths_Put_u8(value2, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a2, b2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a2, b2)), undefined, true); } - const iter3: rt.Iter> = rt.iterSlice(copy$array_lengths_Row_u8(rows)); + const iter3: rs.Iter> = rs.iterSlice(copy$array_lengths_Row_u8(rows)); while (true) { - const _86: Row.Row | rt.Done = iter3.next(); - if (_86 === rt.DONE) { + const _86: Row.Row | rs.Done = iter3.next(); + if (_86 === rs.DONE) { break; } - const value3: rt.u8 = _86._0; - const a3: rt.u8 = _86._1[0]; - const b3: rt.u8 = _86._1[1]; + const value3: rs.u8 = _86._0; + const a3: rs.u8 = _86._1[0]; + const b3: rs.u8 = _86._1[1]; put$lengths_Put_u8(value3, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a3, b3)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a3, b3)), undefined, true); } } /** [`repeated`] of the crate's own type, in a body generic over none. */ -export function loud(data: rt.ByteSlice, out: rt.ByteVec): void { - const byte: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at), 0) as rt.u16; +export function loud(data: rs.ByteSlice, out: rs.ByteVec): void { + const byte: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, at), 0) as rs.u16; }; - const rows: Row.Row[] = [new Row.Row({ _0: byte(0) }, [1, 2] as [rt.u8, rt.u8]), new Row.Row({ _0: byte(2) }, [3, 4] as [rt.u8, rt.u8])]; - const copies: rt.Vec> = rt.iterToVec(rt.iterCopied(rt.iterSlice(rows), copy$lengths_Row_lengths_Loud), undefined, 4, true); - rt.byteVecPush(out, copies.items.length & 0xff); - const _26: Row.Row | undefined = rt.sliceFirst(copies.items); + const rows: Row.Row[] = [new Row.Row({ _0: byte(0) }, [1, 2] as [rs.u8, rs.u8]), new Row.Row({ _0: byte(2) }, [3, 4] as [rs.u8, rs.u8])]; + const copies: rs.Vec> = rs.iterToVec(rs.iterCopied(rs.iterSlice(rows), copy$lengths_Row_lengths_Loud), undefined, 4, true); + rs.byteVecPush(out, copies.items.length & 0xff); + const _26: Row.Row | undefined = rs.sliceFirst(copies.items); if (_26 !== undefined) { - Object.assign(_26, new Row.Row({ _0: byte(2) }, [48, 49] as [rt.u8, rt.u8])); - const tags: [rt.u8, rt.u8] = _26._1; + Object.assign(_26, new Row.Row({ _0: byte(2) }, [48, 49] as [rs.u8, rs.u8])); + const tags: [rs.u8, rs.u8] = _26._1; tags[0] = tags[0] ^ 16; } - const _38: Row.Row | undefined = rt.sliceGet(copies.items, 1); + const _38: Row.Row | undefined = rs.sliceGet(copies.items, 1); if (_38 !== undefined) { _38._1[1] = _38._1[1] ^ 32; } for (const _46 of copies.items) { const value: Loud.Loud = _46._0; - const a: rt.u8 = _46._1[0]; - const b: rt.u8 = _46._1[1]; + const a: rs.u8 = _46._1[0]; + const b: rs.u8 = _46._1[1]; Loud.put$lengths_Put(value, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a, b)), undefined, true); } - const repeats: rt.Vec> = rt.vecFromElem(new Row.Row({ _0: byte(2) }, [5, 6] as [rt.u8, rt.u8]), rt.usizeAdd(1, rt.usizeRem(data.length, 3)), Row.clone$Clone_lengths_Loud); - rt.byteVecPush(out, repeats.items.length & 0xff); - const _72: Row.Row | undefined = rt.sliceFirst(repeats.items); + const repeats: rs.Vec> = rs.vecFromElem(new Row.Row({ _0: byte(2) }, [5, 6] as [rs.u8, rs.u8]), rs.usizeAdd(1, rs.usizeRem(data.length, 3)), Row.clone$Clone_lengths_Loud); + rs.byteVecPush(out, repeats.items.length & 0xff); + const _72: Row.Row | undefined = rs.sliceFirst(repeats.items); if (_72 !== undefined) { - Object.assign(_72, new Row.Row({ _0: byte(2) }, [48, 49] as [rt.u8, rt.u8])); - const tags2: [rt.u8, rt.u8] = _72._1; + Object.assign(_72, new Row.Row({ _0: byte(2) }, [48, 49] as [rs.u8, rs.u8])); + const tags2: [rs.u8, rs.u8] = _72._1; tags2[0] = tags2[0] ^ 16; } - const _84: Row.Row | undefined = rt.sliceGet(repeats.items, 1); + const _84: Row.Row | undefined = rs.sliceGet(repeats.items, 1); if (_84 !== undefined) { _84._1[1] = _84._1[1] ^ 32; } for (const _92 of repeats.items) { const value2: Loud.Loud = _92._0; - const a2: rt.u8 = _92._1[0]; - const b2: rt.u8 = _92._1[1]; + const a2: rs.u8 = _92._1[0]; + const b2: rs.u8 = _92._1[1]; Loud.put$lengths_Put(value2, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a2, b2)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a2, b2)), undefined, true); } - const iter3: rt.Iter> = rt.iterSlice(copy$array_lengths_Row_lengths_Loud(rows)); + const iter3: rs.Iter> = rs.iterSlice(copy$array_lengths_Row_lengths_Loud(rows)); while (true) { - const _104: Row.Row | rt.Done = iter3.next(); - if (_104 === rt.DONE) { + const _104: Row.Row | rs.Done = iter3.next(); + if (_104 === rs.DONE) { break; } const value3: Loud.Loud = _104._0; - const a3: rt.u8 = _104._1[0]; - const b3: rt.u8 = _104._1[1]; + const a3: rs.u8 = _104._1[0]; + const b3: rs.u8 = _104._1[1]; Loud.put$lengths_Put(value3, out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a3, b3)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a3, b3)), undefined, true); } } @@ -2537,67 +2537,67 @@ export function loud(data: rt.ByteSlice, out: rt.ByteVec): void { * beside rows collected from `data`, beside a row repeated by `vec!`, and beside a row's * bytes copied, then their tags changed through a pointer and each slot read back. */ -export function zipped(data: rt.ByteSlice, out: rt.ByteVec): void { - const fill: Uint8Array = rt.bytesFromFn(3, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), i & 0xff); +export function zipped(data: rs.ByteSlice, out: rs.ByteVec): void { + const fill: Uint8Array = rs.bytesFromFn(3, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), i & 0xff); }); - const rows: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _36: rt.u8 = c.data[c.start]; - rt.idx(c, 0); + const rows: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _36: rs.u8 = c.data[c.start]; + rs.idx(c, 0); return Uint8Array.of(_36, ~c.data[c.start] & 0xff, c.length & 0xff); }), undefined, 3, true); - const item = copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8([copy$array_u8(fill), [1, 2] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); - const slots: [Uint8Array, [rt.u8, rt.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rt.u8, rt.u8]] => { + const item = copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8([copy$array_u8(fill), [1, 2] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); + const slots: [Uint8Array, [rs.u8, rs.u8]][] = Array.from({ length: 3 }, (): [Uint8Array, [rs.u8, rs.u8]] => { return copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(item); }); - const iter: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(rt.iterSlice(slots), rt.vecIntoIter(rows), "index"); + const iter: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(rs.iterSlice(slots), rs.vecIntoIter(rows), "index"); while (true) { - const _18: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } const uninit = _18[0]; - rt.ptrWrite(uninit, [copy$array_u8(_18[1]), [51, 3] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit, [copy$array_u8(_18[1]), [51, 3] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit; } - const _28: rt.Iter<[Uint8Array, [rt.u8, rt.u8]]> = rt.iterSkip(rt.iterSlice(slots), 1); - const _33: rt.usize = rt.usizeRem(data.length, 3); - const iter2: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], Uint8Array]> = rt.iterZip(_28, rt.vecIntoIter(rt.vecFromElem(copy$array_u8(fill), _33, copy$array_u8)), "index"); + const _28: rs.Iter<[Uint8Array, [rs.u8, rs.u8]]> = rs.iterSkip(rs.iterSlice(slots), 1); + const _33: rs.usize = rs.usizeRem(data.length, 3); + const iter2: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], Uint8Array]> = rs.iterZip(_28, rs.vecIntoIter(rs.vecFromElem(copy$array_u8(fill), _33, copy$array_u8)), "index"); while (true) { - const _37: [[Uint8Array, [rt.u8, rt.u8]], Uint8Array] | rt.Done = iter2.next(); - if (_37 === rt.DONE) { + const _37: [[Uint8Array, [rs.u8, rs.u8]], Uint8Array] | rs.Done = iter2.next(); + if (_37 === rs.DONE) { break; } const uninit2 = _37[0]; - rt.ptrWrite(uninit2, [copy$array_u8(_37[1]), [68, 3] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit2, [copy$array_u8(_37[1]), [68, 3] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit2; } - const iter3: rt.Iter<[[Uint8Array, [rt.u8, rt.u8]], rt.u8]> = rt.iterZip(rt.iterSkip(rt.iterSlice(slots), 2), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(fill))), [false, false]); + const iter3: rs.Iter<[[Uint8Array, [rs.u8, rs.u8]], rs.u8]> = rs.iterZip(rs.iterSkip(rs.iterSlice(slots), 2), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(fill))), [false, false]); while (true) { - const _56: [[Uint8Array, [rt.u8, rt.u8]], rt.u8] | rt.Done = iter3.next(); - if (_56 === rt.DONE) { + const _56: [[Uint8Array, [rs.u8, rs.u8]], rs.u8] | rs.Done = iter3.next(); + if (_56 === rs.DONE) { break; } - const v: rt.u8 = _56[1]; + const v: rs.u8 = _56[1]; const uninit3 = _56[0]; - rt.ptrWrite(uninit3, [rt.bytes(3).fill(v), [85, v] as [rt.u8, rt.u8]] as [Uint8Array, [rt.u8, rt.u8]]); + rs.ptrWrite(uninit3, [rs.bytes(3).fill(v), [85, v] as [rs.u8, rs.u8]] as [Uint8Array, [rs.u8, rs.u8]]); uninit3; } - for (const byte of rt.byteSliceView(data)) { - const _73: rt.usize = rt.usizeRem(byte as rt.usize, 3); + for (const byte of rs.byteSliceView(data)) { + const _73: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_73 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _73); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _73); } - const slot: [Uint8Array, [rt.u8, rt.u8]] = slots[_73]; - rt.byteSliceRotateLeft(rt.byteSliceFrom(slot[0]), rt.usizeRem(byte as rt.usize, 3)); - const tags: [rt.u8, rt.u8] = slot[1]; + const slot: [Uint8Array, [rs.u8, rs.u8]] = slots[_73]; + rs.byteSliceRotateLeft(rs.byteSliceFrom(slot[0]), rs.usizeRem(byte as rs.usize, 3)); + const tags: [rs.u8, rs.u8] = slot[1]; tags[0] = tags[0] ^ byte; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tags[0], tags[1])), undefined, true); } for (const _91 of slots) { - const _98: [Uint8Array, [rt.u8, rt.u8]] = _91; - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(_98[0]))), rt.iterSlice([_98[1][0], _98[1][1]])), undefined, true); + const _98: [Uint8Array, [rs.u8, rs.u8]] = _91; + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(_98[0]))), rs.iterSlice([_98[1][0], _98[1][1]])), undefined, true); } } diff --git a/ts/fixtures/lang/lengths/expected/lib.ts b/ts/fixtures/lang/lengths/expected/lib.ts index 539798bc8..961866485 100644 --- a/ts/fixtures/lang/lengths/expected/lib.ts +++ b/ts/fixtures/lang/lengths/expected/lib.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { lengths } from "./lengths.ts"; import type * as Loud from "./lengths.Loud.ts"; import * as Row from "./lengths.Row.ts"; import * as Tagged from "./lengths.Tagged.ts"; -export function copy$Option_lengths_Tagged_array0_u32(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { +export function copy$Option_lengths_Tagged_array0_u32(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { return v === undefined ? v : copy$lengths_Tagged_array0_u32(v); } @@ -14,7 +14,7 @@ export function copy$Option_lengths_Tagged_array0_u8(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { +export function copy$Option_lengths_Tagged_array17_u32(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { return v === undefined ? v : copy$lengths_Tagged_array17_u32(v); } @@ -22,7 +22,7 @@ export function copy$Option_lengths_Tagged_array17_u8(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { +export function copy$Option_lengths_Tagged_array1_u32(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { return v === undefined ? v : copy$lengths_Tagged_array1_u32(v); } @@ -30,7 +30,7 @@ export function copy$Option_lengths_Tagged_array1_u8(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { +export function copy$Option_lengths_Tagged_array3_u32(v: Tagged.Tagged | undefined): Tagged.Tagged | undefined { return v === undefined ? v : copy$lengths_Tagged_array3_u32(v); } @@ -58,15 +58,15 @@ export function copy$array_lengths_Row_lengths_Loud(v: Row.Row[]): Ro return v.map(copy$lengths_Row_lengths_Loud); } -export function copy$array_lengths_Row_u8(v: Row.Row[]): Row.Row[] { +export function copy$array_lengths_Row_u8(v: Row.Row[]): Row.Row[] { return v.map(copy$lengths_Row_u8); } -export function copy$array_lengths_Tagged_u32(v: Tagged.Tagged[]): Tagged.Tagged[] { +export function copy$array_lengths_Tagged_u32(v: Tagged.Tagged[]): Tagged.Tagged[] { return v.slice(); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } @@ -78,11 +78,11 @@ export function copy$lengths_Row_lengths_Loud(v: Row.Row): Row.Row): Row.Row { +export function copy$lengths_Row_u8(v: Row.Row): Row.Row { return new Row.Row(v._0, copy$tuple2_u8_u8(v._1)); } -export function copy$lengths_Tagged_array0_u32(v: Tagged.Tagged): Tagged.Tagged { +export function copy$lengths_Tagged_array0_u32(v: Tagged.Tagged): Tagged.Tagged { return new Tagged.Tagged(copy$array_u32(v._0), v._1); } @@ -90,7 +90,7 @@ export function copy$lengths_Tagged_array0_u8(v: Tagged.Tagged): Tag return new Tagged.Tagged(copy$array_u8(v._0), v._1); } -export function copy$lengths_Tagged_array17_u32(v: Tagged.Tagged): Tagged.Tagged { +export function copy$lengths_Tagged_array17_u32(v: Tagged.Tagged): Tagged.Tagged { return new Tagged.Tagged(copy$array_u32(v._0), v._1); } @@ -98,7 +98,7 @@ export function copy$lengths_Tagged_array17_u8(v: Tagged.Tagged): Ta return new Tagged.Tagged(copy$array_u8(v._0), v._1); } -export function copy$lengths_Tagged_array1_u32(v: Tagged.Tagged): Tagged.Tagged { +export function copy$lengths_Tagged_array1_u32(v: Tagged.Tagged): Tagged.Tagged { return new Tagged.Tagged(copy$array_u32(v._0), v._1); } @@ -106,7 +106,7 @@ export function copy$lengths_Tagged_array1_u8(v: Tagged.Tagged): Tag return new Tagged.Tagged(copy$array_u8(v._0), v._1); } -export function copy$lengths_Tagged_array3_u32(v: Tagged.Tagged): Tagged.Tagged { +export function copy$lengths_Tagged_array3_u32(v: Tagged.Tagged): Tagged.Tagged { return new Tagged.Tagged(copy$array_u32(v._0), v._1); } @@ -142,14 +142,14 @@ export function copy$mem_MaybeUninit_array_array3_u8(v: Uint8Array[]): Uint8Arra return v.map(copy$mem_MaybeUninit_array_u8); } -export function copy$mem_MaybeUninit_array_lengths_Tagged_u32(v: Tagged.Tagged[]): Tagged.Tagged[] { +export function copy$mem_MaybeUninit_array_lengths_Tagged_u32(v: Tagged.Tagged[]): Tagged.Tagged[] { if (v === undefined) { return v; } return v.slice(); } -export function copy$mem_MaybeUninit_array_u32(v: rt.u32[]): rt.u32[] { +export function copy$mem_MaybeUninit_array_u32(v: rs.u32[]): rs.u32[] { if (v === undefined) { return v; } @@ -163,126 +163,126 @@ export function copy$mem_MaybeUninit_array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$mem_MaybeUninit_tuple2_array0_array0_u8_tuple2_u8_u8(v: [Uint8Array[], [rt.u8, rt.u8]]): [Uint8Array[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array0_array0_u8_tuple2_u8_u8(v: [Uint8Array[], [rs.u8, rs.u8]]): [Uint8Array[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_array0_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array0_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rt.u8, rt.u8]]): [Tagged.Tagged[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array0_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rs.u8, rs.u8]]): [Tagged.Tagged[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_lengths_Tagged_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8(v: [rt.u32[], [rt.u8, rt.u8]]): [rt.u32[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array0_u32_tuple2_u8_u8(v: [rs.u32[], [rs.u8, rs.u8]]): [rs.u32[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8(v: [Uint8Array, [rt.u8, rt.u8]]): [Uint8Array, [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array0_u8_tuple2_u8_u8(v: [Uint8Array, [rs.u8, rs.u8]]): [Uint8Array, [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array17_array17_u8_tuple2_u8_u8(v: [Uint8Array[], [rt.u8, rt.u8]]): [Uint8Array[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array17_array17_u8_tuple2_u8_u8(v: [Uint8Array[], [rs.u8, rs.u8]]): [Uint8Array[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_array17_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array17_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rt.u8, rt.u8]]): [Tagged.Tagged[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array17_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rs.u8, rs.u8]]): [Tagged.Tagged[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_lengths_Tagged_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8(v: [rt.u32[], [rt.u8, rt.u8]]): [rt.u32[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array17_u32_tuple2_u8_u8(v: [rs.u32[], [rs.u8, rs.u8]]): [rs.u32[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8(v: [Uint8Array, [rt.u8, rt.u8]]): [Uint8Array, [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array17_u8_tuple2_u8_u8(v: [Uint8Array, [rs.u8, rs.u8]]): [Uint8Array, [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array1_array1_u8_tuple2_u8_u8(v: [Uint8Array[], [rt.u8, rt.u8]]): [Uint8Array[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array1_array1_u8_tuple2_u8_u8(v: [Uint8Array[], [rs.u8, rs.u8]]): [Uint8Array[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_array1_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array1_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rt.u8, rt.u8]]): [Tagged.Tagged[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array1_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rs.u8, rs.u8]]): [Tagged.Tagged[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_lengths_Tagged_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8(v: [rt.u32[], [rt.u8, rt.u8]]): [rt.u32[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array1_u32_tuple2_u8_u8(v: [rs.u32[], [rs.u8, rs.u8]]): [rs.u32[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8(v: [Uint8Array, [rt.u8, rt.u8]]): [Uint8Array, [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array1_u8_tuple2_u8_u8(v: [Uint8Array, [rs.u8, rs.u8]]): [Uint8Array, [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array3_array3_u8_tuple2_u8_u8(v: [Uint8Array[], [rt.u8, rt.u8]]): [Uint8Array[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array3_array3_u8_tuple2_u8_u8(v: [Uint8Array[], [rs.u8, rs.u8]]): [Uint8Array[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_array3_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array3_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rt.u8, rt.u8]]): [Tagged.Tagged[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array3_lengths_Tagged_u32_tuple2_u8_u8(v: [Tagged.Tagged[], [rs.u8, rs.u8]]): [Tagged.Tagged[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_lengths_Tagged_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8(v: [rt.u32[], [rt.u8, rt.u8]]): [rt.u32[], [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array3_u32_tuple2_u8_u8(v: [rs.u32[], [rs.u8, rs.u8]]): [rs.u32[], [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u32(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(v: [Uint8Array, [rt.u8, rt.u8]]): [Uint8Array, [rt.u8, rt.u8]] { +export function copy$mem_MaybeUninit_tuple2_array3_u8_tuple2_u8_u8(v: [Uint8Array, [rs.u8, rs.u8]]): [Uint8Array, [rs.u8, rs.u8]] { if (v === undefined) { return v; } return [copy$mem_MaybeUninit_array_u8(v[0]), copy$mem_MaybeUninit_tuple2_u8_u8(v[1])]; } -export function copy$mem_MaybeUninit_tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$mem_MaybeUninit_tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { if (v === undefined) { return v; } return [v[0], v[1]]; } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } @@ -290,8 +290,8 @@ export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["lengths::lengths", lengths as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["lengths::lengths", lengths as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/lists/expected/core/option.ts b/ts/fixtures/lang/lists/expected/core/option.ts index a43f18933..56a6ef645 100644 --- a/ts/fixtures/lang/lists/expected/core/option.ts +++ b/ts/fixtures/lang/lists/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/lists/expected/harness.ts b/ts/fixtures/lang/lists/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/lists/expected/harness.ts +++ b/ts/fixtures/lang/lists/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/lists/expected/lib.ts b/ts/fixtures/lang/lists/expected/lib.ts index 32a8534ba..b77bf76e4 100644 --- a/ts/fixtures/lang/lists/expected/lib.ts +++ b/ts/fixtures/lang/lists/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { lists } from "./lists.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["lists::lists", lists as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["lists::lists", lists as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/lists/expected/lists.Tally.ts b/ts/fixtures/lang/lists/expected/lists.Tally.ts index ad561dadf..43371170f 100644 --- a/ts/fixtures/lang/lists/expected/lists.Tally.ts +++ b/ts/fixtures/lang/lists/expected/lists.Tally.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Tally): Tally { return { n: self.n }; } -export function fmt$fmt_Debug(self: Tally, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Tally, f: rs.Formatter): rs.Result { const _3: string = "Tally"; const _4: string = "n"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self.n, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5)); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.n, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5)); } export function default$Default(): Tally { @@ -21,17 +21,17 @@ export function eq$cmp_PartialEq(self: Tally, other: Tally): boolean { return self.n === other.n; } -export function hash$Hash_hash_DefaultHasher(self: Tally, state: rt.Hasher): void { - rt.hash16(self.n, state); +export function hash$Hash_hash_DefaultHasher(self: Tally, state: rs.Hasher): void { + rs.hash16(self.n, state); } -export function cmp$cmp_Ord(self: Tally, other: Tally): rt.Ordering { - return rt.cmp(self.n, other.n); +export function cmp$cmp_Ord(self: Tally, other: Tally): rs.Ordering { + return rs.cmp(self.n, other.n); } /** A value changed in place through `front_mut`, `iter_mut`, and `extract_if`. */ export interface Tally { - n: rt.u16; + n: rs.u16; } //# sourceMappingURL=lists.Tally.ts.map diff --git a/ts/fixtures/lang/lists/expected/lists.ts b/ts/fixtures/lang/lists/expected/lists.ts index 4b0d346bd..57172ba0c 100644 --- a/ts/fixtures/lang/lists/expected/lists.ts +++ b/ts/fixtures/lang/lists/expected/lists.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0 } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi } from "./core/option.ts"; import * as Tally from "./lists.Tally.ts"; -export function hashOf$collections_LinkedList_lists_Tally(value: rt.LinkedList): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashList(Tally.hash$Hash_hash_DefaultHasher as (a0: Tally.Tally, a1: rt.Hasher) => undefined)(value, h); - return rt.hashFinish(h); +export function hashOf$collections_LinkedList_lists_Tally(value: rs.LinkedList): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashList(Tally.hash$Hash_hash_DefaultHasher as (a0: Tally.Tally, a1: rs.Hasher) => undefined)(value, h); + return rs.hashFinish(h); } -export function hashOf$collections_LinkedList_u8(value: rt.LinkedList): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashList(rt.hash8)(value, h); - return rt.hashFinish(h); +export function hashOf$collections_LinkedList_u8(value: rs.LinkedList): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashList(rs.hash8)(value, h); + return rs.hashFinish(h); } /** A list's length, then its items front to back. */ -export function items(l: rt.LinkedList, out: rt.ByteVec): void { - rt.byteVecPush(out, l.n & 0xff); - rt.iterExtendBytes(out, rt.listIter(l), undefined, true); +export function items(l: rs.LinkedList, out: rs.ByteVec): void { + rs.byteVecPush(out, l.n & 0xff); + rs.iterExtendBytes(out, rs.listIter(l), undefined, true); } /** @@ -27,134 +27,134 @@ export function items(l: rt.LinkedList, out: rt.ByteVec): void { * bytes, then how they compare, hash, iterate, and print. `kind` picks whether a split * past the end ends it, which panics. */ -export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _93!: rt.i32; - let x2!: rt.u8 | undefined; - let x3!: rt.Place | undefined; - let l: rt.LinkedList = rt.listNew() as rt.LinkedList; - let m: rt.LinkedList = rt.listNew() as rt.LinkedList; - l1: for (const b of rt.byteSliceView(data)) { - const _13: rt.u8 = rt.u8Rem(b, 13); +export function lists(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _93!: rs.i32; + let x2!: rs.u8 | undefined; + let x3!: rs.Place | undefined; + let l: rs.LinkedList = rs.listNew() as rs.LinkedList; + let m: rs.LinkedList = rs.listNew() as rs.LinkedList; + l1: for (const b of rs.byteSliceView(data)) { + const _13: rs.u8 = rs.u8Rem(b, 13); if (_13 === 0) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listPopFront(l), 238)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.listPopFront(l), 238)); } else if (_13 === 1) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listPopBack(l), 237)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.listPopBack(l), 237)); } else if (_13 === 2) { - rt.listPushFront(l, b); + rs.listPushFront(l, b); } else if (_13 === 3) { - rt.listPushBack(l, b); + rs.listPushBack(l, b); } else if (_13 === 4) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listEnd(l), 236)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.listEnd(l, true), 235)); - rt.byteVecPush(out, l.n === 0 ? 1 : 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.listEnd(l), 236)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.listEnd(l, true), 235)); + rs.byteVecPush(out, l.n === 0 ? 1 : 0); } else if (_13 === 5) { - const _37: rt.Place | undefined = rt.listEndMut(l); + const _37: rs.Place | undefined = rs.listEndMut(l); if (_37 !== undefined) { - _37.v = rt.u8WrappingAdd(_37.v, b); + _37.v = rs.u8WrappingAdd(_37.v, b); } - const _43: rt.Place | undefined = rt.listEndMut(l, true); + const _43: rs.Place | undefined = rs.listEndMut(l, true); if (_43 !== undefined) { _43.v = _43.v ^ 85; } - const _47: rt.Place = rt.listPushBack(l, b); + const _47: rs.Place = rs.listPushBack(l, b); _47.v = _47.v ^ 15; - const x: rt.Place = rt.listPushFront(l, b); - x.v = rt.u8WrappingMul(x.v, 3); + const x: rs.Place = rs.listPushFront(l, b); + x.v = rs.u8WrappingMul(x.v, 3); } else if (_13 === 6) { - const tail: rt.LinkedList = rt.listSplitOff(l, rt.usizeRem(rt.u8Div(b, 13) as rt.usize, rt.usizeAdd(l.n, 1))); + const tail: rs.LinkedList = rs.listSplitOff(l, rs.usizeRem(rs.u8Div(b, 13) as rs.usize, rs.usizeAdd(l.n, 1))); items(tail, out); - rt.listAppend(tail, m); + rs.listAppend(tail, m); m = tail; } else if (_13 === 7) { - rt.listAppend(l, m); - rt.byteVecPush(out, m.n & 0xff); + rs.listAppend(l, m); + rs.byteVecPush(out, m.n & 0xff); } else if (_13 === 8) { - rt.byteVecPush(out, rt.listContains(l, b, rt.same) ? 1 : 0); - rt.byteVecPush(out, rt.listContains(m, b ^ 1, rt.same) ? 1 : 0); + rs.byteVecPush(out, rs.listContains(l, b, rs.same) ? 1 : 0); + rs.byteVecPush(out, rs.listContains(m, b ^ 1, rs.same) ? 1 : 0); } else if (_13 === 9) { - const it: rt.Iter = rt.listIter(l); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 8; + const it: rs.Iter = rs.listIter(l); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 8; while ((_93 = iterStart++) < iterEnd) { - if (!((rt.u8Shr(b, _93) & 1) === 0)) { - x2 = rt.iterToOption(it.nextBack()); + if (!((rs.u8Shr(b, _93) & 1) === 0)) { + x2 = rs.iterToOption(it.nextBack()); } else { - x2 = rt.iterToOption(it.next()); + x2 = rs.iterToOption(it.next()); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(x2, 234)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(x2, 234)); } - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterRev(it.clone()), undefined, true); - rt.byteVecPush(out, it.sizeHint()[0] & 0xff); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterRev(it.clone()), undefined, true); + rs.byteVecPush(out, it.sizeHint()[0] & 0xff); } else { if (_13 === 10) { - const it2: rt.Iter> = rt.listIterMut(l); - let i: rt.u8 = 0; + const it2: rs.Iter> = rs.listIterMut(l); + let i: rs.u8 = 0; while (true) { - if (!((rt.u8Shr(b, rt.u8Rem(i, 8)) & 1) === 0)) { - x3 = rt.iterToOption(it2.nextBack()); + if (!((rs.u8Shr(b, rs.u8Rem(i, 8)) & 1) === 0)) { + x3 = rs.iterToOption(it2.nextBack()); } else { - x3 = rt.iterToOption(it2.next()); + x3 = rs.iterToOption(it2.next()); } if (x3 !== undefined) { - const x4: rt.Place = x3; - x4.v = rt.u8WrappingAdd(x4.v, i); - i = rt.u8Add(i, 1); + const x4: rs.Place = x3; + x4.v = rs.u8WrappingAdd(x4.v, i); + i = rs.u8Add(i, 1); } else { - const iter3: rt.Iter> = rt.listIterMut(m); + const iter3: rs.Iter> = rs.listIterMut(m); while (true) { - const _144: rt.Place | rt.Done = iter3.next(); - if (_144 === rt.DONE) { + const _144: rs.Place | rs.Done = iter3.next(); + if (_144 === rs.DONE) { continue l1; } - _144.v = rt.intRotateLeft(_144.v, 1, 8, false); + _144.v = rs.intRotateLeft(_144.v, 1, 8, false); } } } } if (_13 === 11) { - l = rt.replaceIn(m, l); + l = rs.replaceIn(m, l); } else { - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.listExtractIfMut(l, (x5: rt.Place): boolean => { - x5.v = rt.u8WrappingAdd(x5.v, 1); - return rt.u8Rem(x5.v, 3) === 0; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.listExtractIfMut(l, (x5: rs.Place): boolean => { + x5.v = rs.u8WrappingAdd(x5.v, 1); + return rs.u8Rem(x5.v, 3) === 0; }), "next")), undefined, true); } } } items(l, out); items(m, out); - const _164: rt.LinkedList = m; - rt.byteVecPush(out, rt.eqList(rt.same)(l, _164) ? 1 : 0); - const _169: rt.LinkedList = m; - rt.byteVecPush(out, !rt.eqList(rt.same)(l, _169) ? 1 : 0); - const _174: rt.LinkedList = m; - rt.byteVecPush(out, rt.cmpList(rt.cmp)(l, _174) & 0xff); - const _180: rt.LinkedList = m; - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.cmpList(rt.cmp)(l, _180), 9, (o: rt.Ordering): rt.u8 => { + const _164: rs.LinkedList = m; + rs.byteVecPush(out, rs.eqList(rs.same)(l, _164) ? 1 : 0); + const _169: rs.LinkedList = m; + rs.byteVecPush(out, !rs.eqList(rs.same)(l, _169) ? 1 : 0); + const _174: rs.LinkedList = m; + rs.byteVecPush(out, rs.cmpList(rs.cmp)(l, _174) & 0xff); + const _180: rs.LinkedList = m; + rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpList(rs.cmp)(l, _180), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - const _185: rt.LinkedList = m; - rt.byteVecPush(out, rt.cmpList(rt.cmp)(l, _185) === -1 ? 1 : 0); - const _190: rt.LinkedList = m; - const order = rt.cmpList(rt.cmp)(l, _190); - rt.byteVecPush(out, order !== undefined && order >= 0 ? 1 : 0); - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(hashOf$collections_LinkedList_u8(l)).reverse()), undefined, true); - const _196: rt.Iter> = rt.iterSlice([rt.listClone(l, undefined), rt.listClone(m, undefined), rt.listClone(l, undefined)]); - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashList(rt.hash8), rt.eqList(rt.same))) as rt.HashSet>, _196, undefined, undefined, 117440512)) & 0xff); - const it3: rt.Iter = rt.listIter(rt.listClone(l, undefined)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it3.nextBack()), 233)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it3.next()), 232)); - rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, it3.clone(), undefined, true); - rt.iterExtendBytes(out, rt.iterRev(it3), undefined, true); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterLast(rt.listIter(l)), 231)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterNth(rt.listIter(l), rt.usizeRem(kind as rt.usize, 4)), 230)); + const _185: rs.LinkedList = m; + rs.byteVecPush(out, rs.cmpList(rs.cmp)(l, _185) === -1 ? 1 : 0); + const _190: rs.LinkedList = m; + const order = rs.cmpList(rs.cmp)(l, _190); + rs.byteVecPush(out, order !== undefined && order >= 0 ? 1 : 0); + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(hashOf$collections_LinkedList_u8(l)).reverse()), undefined, true); + const _196: rs.Iter> = rs.iterSlice([rs.listClone(l, undefined), rs.listClone(m, undefined), rs.listClone(l, undefined)]); + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashList(rs.hash8), rs.eqList(rs.same))) as rs.HashSet>, _196, undefined, undefined, 117440512)) & 0xff); + const it3: rs.Iter = rs.listIter(rs.listClone(l, undefined)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it3.nextBack()), 233)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it3.next()), 232)); + rs.byteVecPush(out, it3.len() & 0xff); + rs.iterExtendBytes(out, it3.clone(), undefined, true); + rs.iterExtendBytes(out, rs.iterRev(it3), undefined, true); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterLast(rs.listIter(l)), 231)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterNth(rs.listIter(l), rs.usizeRem(kind as rs.usize, 4)), 230)); edges(data, out); printed(l, m, out); tallies(data, out); - if (rt.u8Rem(kind, 4) === 0) { - rt.iterExtendBytes(out, rt.listIter(rt.listSplitOff(m, rt.usizeAdd(rt.usizeAdd(m.n, 1), rt.u8Rem(rt.u8Div(kind, 4), 2) as rt.usize))), undefined, true); + if (rs.u8Rem(kind, 4) === 0) { + rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(m, rs.usizeAdd(rs.usizeAdd(m.n, 1), rs.u8Rem(rs.u8Div(kind, 4), 2) as rs.usize))), undefined, true); } } @@ -162,145 +162,145 @@ export function lists(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `split_off` and `append` at 0, either side of the middle, and the end, and the list * `collect`, `From`, and `extend` make, empty ones included. */ -export function edges(data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const whole: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); - const len: rt.usize = whole.n; - const iter: rt.Iter = rt.iterSlice([0, rt.min(1, len), rt.usizeDiv(len, 2), rt.usizeSaturatingSub(len, 1), len]); +export function edges(data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const whole: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _4); + const len: rs.usize = whole.n; + const iter: rs.Iter = rs.iterSlice([0, rs.min(1, len), rs.usizeDiv(len, 2), rs.usizeSaturatingSub(len, 1), len]); while (true) { - const _15: rt.usize | rt.Done = iter.next(); - if (_15 === rt.DONE) { + const _15: rs.usize | rs.Done = iter.next(); + if (_15 === rs.DONE) { break; } - const at: rt.usize = _15; - const front: rt.LinkedList = rt.listClone(whole, undefined); - const back: rt.LinkedList = rt.listSplitOff(front, at); + const at: rs.usize = _15; + const front: rs.LinkedList = rs.listClone(whole, undefined); + const back: rs.LinkedList = rs.listSplitOff(front, at); items(front, out); items(back, out); - rt.listAppend(front, back); - rt.byteVecPush(out, back.n === 0 ? 1 : 0); - rt.byteVecPush(out, rt.eqList(rt.same)(front, whole) ? 1 : 0); - const empty: rt.LinkedList = rt.listNew() as rt.LinkedList; - rt.listAppend(empty, front); - const _46: rt.LinkedList = rt.listNew() as rt.LinkedList; - rt.listAppend(empty, _46); - rt.byteVecPush(out, front.n & 0xff); - rt.byteVecPush(out, rt.eqList(rt.same)(empty, whole) ? 1 : 0); + rs.listAppend(front, back); + rs.byteVecPush(out, back.n === 0 ? 1 : 0); + rs.byteVecPush(out, rs.eqList(rs.same)(front, whole) ? 1 : 0); + const empty: rs.LinkedList = rs.listNew() as rs.LinkedList; + rs.listAppend(empty, front); + const _46: rs.LinkedList = rs.listNew() as rs.LinkedList; + rs.listAppend(empty, _46); + rs.byteVecPush(out, front.n & 0xff); + rs.byteVecPush(out, rs.eqList(rs.same)(empty, whole) ? 1 : 0); } - const from: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(Uint8Array.of(1, 2, 3))); - const _60: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3); - rt.listExtend(from, _60); - const _64: rt.LinkedList = rt.listClone(whole, undefined); - rt.listAppend(from, _64); - const _68: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(7, 8)); - rt.listExtend(from, rt.byteVecIntoIter(_68)); + const from: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(Uint8Array.of(1, 2, 3))); + const _60: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3); + rs.listExtend(from, _60); + const _64: rs.LinkedList = rs.listClone(whole, undefined); + rs.listAppend(from, _64); + const _68: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(7, 8)); + rs.listExtend(from, rs.byteVecIntoIter(_68)); items(from, out); - const _75: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u8] => { - const b: rt.u8 = _2; - return [b & (~1 & 0xff), b | 1] as [rt.u8, rt.u8]; + const _75: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.u8] => { + const b: rs.u8 = _2; + return [b & (~1 & 0xff), b | 1] as [rs.u8, rs.u8]; }); - const _74: [rt.LinkedList, rt.LinkedList] = rt.tupleExtend([rt.listNew() as rt.LinkedList, rt.listNew() as rt.LinkedList] as [rt.LinkedList, rt.LinkedList], _75, [rt.listPart(), rt.listPart()]); - const evens: rt.LinkedList = _74[0]; - const odds: rt.LinkedList = _74[1]; + const _74: [rs.LinkedList, rs.LinkedList] = rs.tupleExtend([rs.listNew() as rs.LinkedList, rs.listNew() as rs.LinkedList] as [rs.LinkedList, rs.LinkedList], _75, [rs.listPart(), rs.listPart()]); + const evens: rs.LinkedList = _74[0]; + const odds: rs.LinkedList = _74[1]; items(evens, out); items(odds, out); - const copy: rt.LinkedList = rt.listClone(from, undefined); - rt.listCloneFrom(copy, whole); + const copy: rs.LinkedList = rs.listClone(from, undefined); + rs.listCloneFrom(copy, whole); items(copy, out); - rt.listCloneFrom(copy, from); + rs.listCloneFrom(copy, from); items(copy, out); - rt.listClear(copy); + rs.listClear(copy); items(copy, out); - rt.byteVecPush(out, rt.listIter(rt.listNew()).len() & 0xff); - rt.byteVecPush(out, rt.iterToOption(rt.listIter(rt.listNew()).next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterToOption(rt.listIter(rt.listNew()).next()) === undefined ? 1 : 0); - const _117: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.f64 => { - const b2: rt.u8 = _22; + rs.byteVecPush(out, rs.listIter(rs.listNew()).len() & 0xff); + rs.byteVecPush(out, rs.iterToOption(rs.listIter(rs.listNew()).next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterToOption(rs.listIter(rs.listNew()).next()) === undefined ? 1 : 0); + const _117: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.f64 => { + const b2: rs.u8 = _22; if (!(b2 === 255)) { - return b2 as rt.f64; + return b2 as rs.f64; } return NaN; }); - const floats: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _117); - const _120: rt.Iter = rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_23: rt.u8): rt.f64 => { - return _23 as rt.f64; + const floats: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _117); + const _120: rs.Iter = rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_23: rs.u8): rs.f64 => { + return _23 as rs.f64; }); - const other: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _120); - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.cmpList(rt.f64PartialCmp)(floats, other), 9, (o: rt.Ordering): rt.u8 => { + const other: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _120); + rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpList(rs.f64PartialCmp)(floats, other), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - rt.byteVecPush(out, rt.eqList(rt.same)(floats, other) ? 1 : 0); + rs.byteVecPush(out, rs.eqList(rs.same)(floats, other) ? 1 : 0); } /** `Debug` of the lists and of their iterators part read, plain, pretty, and in hex. */ -export function printed(l: rt.LinkedList, m: rt.LinkedList, out: rt.ByteVec): void { +export function printed(l: rs.LinkedList, m: rs.LinkedList, out: rs.ByteVec): void { let text: string = ""; - const it: rt.Iter = rt.listIter(l); + const it: rs.Iter = rs.listIter(l); it.next(); - const owned: rt.Iter = rt.listIter(rt.listClone(m, undefined)); - rt.iterToOption(owned.nextBack()); - const lent: rt.Iter> = rt.listIterMut(rt.listClone(m, undefined)); + const owned: rs.Iter = rs.listIter(rs.listClone(m, undefined)); + rs.iterToOption(owned.nextBack()); + const lent: rs.Iter> = rs.listIterMut(rs.listClone(m, undefined)); lent.next(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.listIter(l), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.listIter(m), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtListIter(it, f, rt.u8Debug, rt.usizeDebug, "Iter"), (f: rt.Formatter) => rt.fmtIter(owned, f, rt.u8Debug, ["IntoIter"]), (f: rt.Formatter) => rt.fmtListIter(lent, f, rt.u8Debug, rt.usizeDebug, "IterMut")]; - text = rt.fmtWriteString(text, [args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ debugHex: "x" }, args2[2]), "|", rt.fmtSpec({ alternate: true }, args2[2]), "|", args2[3], "|", args2[4]]).s; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text))), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(l), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.listIter(m), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtListIter(it, f, rs.u8Debug, rs.usizeDebug, "Iter"), (f: rs.Formatter) => rs.fmtIter(owned, f, rs.u8Debug, ["IntoIter"]), (f: rs.Formatter) => rs.fmtListIter(lent, f, rs.u8Debug, rs.usizeDebug, "IterMut")]; + text = rs.fmtWriteString(text, [args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ debugHex: "x" }, args2[2]), "|", rs.fmtSpec({ alternate: true }, args2[2]), "|", args2[3], "|", args2[4]]).s; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); } /** A list of `Tally`s, which JS changes in place rather than through places. */ -export function tallies(data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tally.Tally => { - return { n: _2 as rt.u16 }; +export function tallies(data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tally.Tally => { + return { n: _2 as rs.u16 }; }); - const l: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _4); - const copy: rt.LinkedList = rt.listClone(l, Tally.clone$Clone); - const _8: Tally.Tally | undefined = rt.listEnd(l); + const l: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _4); + const copy: rs.LinkedList = rs.listClone(l, Tally.clone$Clone); + const _8: Tally.Tally | undefined = rs.listEnd(l); if (_8 !== undefined) { _8.n = _8.n ^ 255; } - const _12: Tally.Tally | undefined = rt.listEnd(l, true); + const _12: Tally.Tally | undefined = rs.listEnd(l, true); if (_12 !== undefined) { - _12.n = rt.u16Add(_12.n, 1); + _12.n = rs.u16Add(_12.n, 1); } const _19: Tally.Tally = Tally.default$Default(); - rt.listPushBack(l, _19).v.n = 119; - const _20: Tally.Tally = rt.listPushFront(l, { n: 3 }).v; - _20.n = rt.u16Mul(_20.n, 5); - const iter: rt.Iter<[rt.usize, Tally.Tally]> = rt.iterEnumerate(rt.listIter(l)); + rs.listPushBack(l, _19).v.n = 119; + const _20: Tally.Tally = rs.listPushFront(l, { n: 3 }).v; + _20.n = rs.u16Mul(_20.n, 5); + const iter: rs.Iter<[rs.usize, Tally.Tally]> = rs.iterEnumerate(rs.listIter(l)); while (true) { - const _29: [rt.usize, Tally.Tally] | rt.Done = iter.next(); - if (_29 === rt.DONE) { + const _29: [rs.usize, Tally.Tally] | rs.Done = iter.next(); + if (_29 === rs.DONE) { break; } - _29[1].n = rt.u16WrappingAdd(_29[1].n, _29[0] & 0xffff); + _29[1].n = rs.u16WrappingAdd(_29[1].n, _29[0] & 0xffff); } - const _38: rt.Iter = rt.listExtractIf(l, (t: Tally.Tally): boolean => { - t.n = rt.u16Add(t.n, 1); - return rt.u16Rem(t.n, 4) === 0; + const _38: rs.Iter = rs.listExtractIf(l, (t: Tally.Tally): boolean => { + t.n = rs.u16Add(t.n, 1); + return rs.u16Rem(t.n, 4) === 0; }); - const taken: rt.LinkedList = rt.listExtend(rt.listNew() as rt.LinkedList, _38); - const rest: rt.LinkedList = rt.listClone(l, Tally.clone$Clone); - rt.listCloneFrom(rest, taken, Tally.clone$Clone); - const iter2: rt.Iter> = rt.iterSlice([l, copy, taken, rest]); + const taken: rs.LinkedList = rs.listExtend(rs.listNew() as rs.LinkedList, _38); + const rest: rs.LinkedList = rs.listClone(l, Tally.clone$Clone); + rs.listCloneFrom(rest, taken, Tally.clone$Clone); + const iter2: rs.Iter> = rs.iterSlice([l, copy, taken, rest]); while (true) { - const _52: rt.LinkedList | rt.Done = iter2.next(); - if (_52 === rt.DONE) { + const _52: rs.LinkedList | rs.Done = iter2.next(); + if (_52 === rs.DONE) { break; } - rt.byteVecPush(out, _52.n & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.listIter(_52), (t2: Tally.Tally): rt.u8 => { + rs.byteVecPush(out, _52.n & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.listIter(_52), (t2: Tally.Tally): rs.u8 => { return t2.n & 0xff; }), undefined, true); } - rt.byteVecPush(out, rt.listContains(l, { n: 120 }, Tally.eq$cmp_PartialEq) ? 1 : 0); - rt.byteVecPush(out, rt.cmpList(Tally.cmp$cmp_Ord)(l, copy) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashOf$collections_LinkedList_lists_Tally(taken), hashOf$collections_LinkedList_lists_Tally(rest)) ? 1 : 0); + rs.byteVecPush(out, rs.listContains(l, { n: 120 }, Tally.eq$cmp_PartialEq) ? 1 : 0); + rs.byteVecPush(out, rs.cmpList(Tally.cmp$cmp_Ord)(l, copy) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashOf$collections_LinkedList_lists_Tally(taken), hashOf$collections_LinkedList_lists_Tally(rest)) ? 1 : 0); let text: string = ""; - const part = rt.iterToVec(rt.iterTake(rt.iterRev(rt.listIter(rest)), 2), undefined, 4, true); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part.items, f, (value: Tally.Tally, f: rt.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rt.fmtWriteString(text, [args2[0]]).s; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.listIter(taken), f, (value: Tally.Tally, f: rt.Formatter) => Tally.fmt$fmt_Debug(value, f))]; - text = rt.fmtWriteString(text, [rt.fmtSpec({ alternate: true }, args4[0])]).s; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text))), undefined, true); + const part = rs.iterToVec(rs.iterTake(rs.iterRev(rs.listIter(rest)), 2), undefined, 4, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; + text = rs.fmtWriteString(text, [args2[0]]).s; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.listIter(taken), f, (value: Tally.Tally, f: rs.Formatter) => Tally.fmt$fmt_Debug(value, f))]; + text = rs.fmtWriteString(text, [rs.fmtSpec({ alternate: true }, args4[0])]).s; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text))), undefined, true); } //# sourceMappingURL=lists.ts.map diff --git a/ts/fixtures/lang/locals/expected/core/bool.ts b/ts/fixtures/lang/locals/expected/core/bool.ts index ffe6ebaab..a2e40a4f7 100644 --- a/ts/fixtures/lang/locals/expected/core/bool.ts +++ b/ts/fixtures/lang/locals/expected/core/bool.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1d6toqn(self: boolean, t: undefined): undefined | rt.None { +export function thenSome$1qfl7tz(self: boolean, t: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return t; } diff --git a/ts/fixtures/lang/locals/expected/core/option.ts b/ts/fixtures/lang/locals/expected/core/option.ts index a52512ee5..52bb6a053 100644 --- a/ts/fixtures/lang/locals/expected/core/option.ts +++ b/ts/fixtures/lang/locals/expected/core/option.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Noisy from "../locals.Noisy.ts"; -export function mapOr$0cqaybi(self: Noisy.Noisy | undefined, default_: rt.u8, f: (a0: Noisy.Noisy) => rt.u8): rt.u8 { +export function mapOr$14nyq77(self: Noisy.Noisy | undefined, default_: rs.u8, f: (a0: Noisy.Noisy) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1w5qtj7(self: undefined | rt.None, default_: rt.u8, f: (a0: undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$0543jy8(self: undefined | rs.None, default_: rs.u8, f: (a0: undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(self); } -export function mapOr$0ucbp7g(self: [rt.u64, rt.u64] | undefined, default_: rt.u8, f: (a0: [rt.u64, rt.u64]) => rt.u8): rt.u8 { +export function mapOr$1idpb1d(self: [rs.u64, rs.u64] | undefined, default_: rs.u8, f: (a0: [rs.u64, rs.u64]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/locals/expected/core/result.ts b/ts/fixtures/lang/locals/expected/core/result.ts index d3a181cf1..8f3bb8312 100644 --- a/ts/fixtures/lang/locals/expected/core/result.ts +++ b/ts/fixtures/lang/locals/expected/core/result.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function mapOr$18ipla0(self: rt.Result, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$12d9lqr(self: rs.Result, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self.ok) { return f(self.value); } diff --git a/ts/fixtures/lang/locals/expected/harness.ts b/ts/fixtures/lang/locals/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/locals/expected/harness.ts +++ b/ts/fixtures/lang/locals/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/locals/expected/lib.ts b/ts/fixtures/lang/locals/expected/lib.ts index 6a417cc81..4d402e1fd 100644 --- a/ts/fixtures/lang/locals/expected/lib.ts +++ b/ts/fixtures/lang/locals/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { locals, keys } from "./locals.ts"; import type * as Twin from "./locals.Twin.ts"; @@ -16,12 +16,12 @@ export function copy$tuple2_locals_Twin_locals_Twin(v: [Twin.Twin, Twin.Twin]): * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["locals::locals", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["locals::locals", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { locals(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locals::keys", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locals::keys", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { keys(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/locals/expected/locals.Noisy.ts b/ts/fixtures/lang/locals/expected/locals.Noisy.ts index 9501f2b42..93cdfa401 100644 --- a/ts/fixtures/lang/locals/expected/locals.Noisy.ts +++ b/ts/fixtures/lang/locals/expected/locals.Noisy.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id when it drops. */ export class Noisy { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -19,9 +19,9 @@ export class Noisy { } export function drop$ops_Drop(self: Noisy): void { - const _5: rt.Mutex = rt.mutexLock(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.mutexUnlock(_5); + const _5: rs.Mutex = rs.mutexLock(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.mutexUnlock(_5); } //# sourceMappingURL=locals.Noisy.ts.map diff --git a/ts/fixtures/lang/locals/expected/locals.Polling.ts b/ts/fixtures/lang/locals/expected/locals.Polling.ts index ea18a14ad..b1f45e03e 100644 --- a/ts/fixtures/lang/locals/expected/locals.Polling.ts +++ b/ts/fixtures/lang/locals/expected/locals.Polling.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What a batch holds, as kio's `Polling` does. */ export interface Polling { - current: rt.Cell<[rt.u64, rt.u64] | undefined>; - held: rt.RefCell; + current: rs.Cell<[rs.u64, rs.u64] | undefined>; + held: rs.RefCell; } //# sourceMappingURL=locals.Polling.ts.map diff --git a/ts/fixtures/lang/locals/expected/locals.Twin.ts b/ts/fixtures/lang/locals/expected/locals.Twin.ts index 3b49d1d16..8b186295a 100644 --- a/ts/fixtures/lang/locals/expected/locals.Twin.ts +++ b/ts/fixtures/lang/locals/expected/locals.Twin.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Only `PAIRS`'s `const` writes one in place. */ export interface Twin { - _0: rt.u16; - _1: rt.u16; + _0: rs.u16; + _1: rs.u16; } //# sourceMappingURL=locals.Twin.ts.map diff --git a/ts/fixtures/lang/locals/expected/locals.ts b/ts/fixtures/lang/locals/expected/locals.ts index 0afb042af..0e82c8bd5 100644 --- a/ts/fixtures/lang/locals/expected/locals.ts +++ b/ts/fixtures/lang/locals/expected/locals.ts @@ -1,282 +1,282 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$locals_Twin } from "./lib.ts"; -import { thenSome$1d6toqn } from "./core/bool.ts"; -import { mapOr$0cqaybi as option_mapOr$0cqaybi, mapOr$1w5qtj7 as option_mapOr$1w5qtj7, mapOr$0ucbp7g as option_mapOr$0ucbp7g } from "./core/option.ts"; -import { mapOr$18ipla0 as result_mapOr$18ipla0 } from "./core/result.ts"; +import { thenSome$1qfl7tz } from "./core/bool.ts"; +import { mapOr$14nyq77 as option_mapOr$14nyq77, mapOr$0543jy8 as option_mapOr$0543jy8, mapOr$1idpb1d as option_mapOr$1idpb1d } from "./core/option.ts"; +import { mapOr$12d9lqr as result_mapOr$12d9lqr } from "./core/result.ts"; import * as Noisy from "./locals.Noisy.ts"; import type * as Polling from "./locals.Polling.ts"; import type * as Twin from "./locals.Twin.ts"; -import { set$0st49po, set$0xuu1fw, get$0x8wyln, get$1ei2eoj, get$18ignl5, take$09yi5f2, replace$0kxb7te, withBorrow$1qygtee, withBorrow$1k8k9m1, withBorrow$0r4ucls, withBorrow$1t1sbub, withBorrow$15ql9sa, take$1x34chv, take$122f15k, replace$0bb3zeq, replace$1xk72wn } from "./std/thread/local.ts"; +import { set$1ljkjlf, set$0e2h2hd, get$1waoxfw, get$0q7640n, get$09fnt4b, take$1ptr2t1, replace$143ou38, withBorrow$0ff0ub1, withBorrow$04rfir6, withBorrow$008xek1, withBorrow$1p7azig, withBorrow$00rpnrn, take$0hcjffg, take$1snv7rd, replace$06e3fyj, replace$0orw47h } from "./std/thread/local.ts"; -export const COUNT: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(COUNT$init, false); +export const COUNT: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(COUNT$init, false); -export function COUNT$init(): rt.Cell { - return new rt.Cell(7); +export function COUNT$init(): rs.Cell { + return new rs.Cell(7); } -export const HELD: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(HELD$init, false); +export const HELD: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(HELD$init, false); -export function HELD$init(): rt.RefCell { - return new rt.RefCell(undefined as Noisy.Noisy | undefined); +export function HELD$init(): rs.RefCell { + return new rs.RefCell(undefined as Noisy.Noisy | undefined); } -export const LEFT: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LEFT$init, false); +export const LEFT: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LEFT$init, false); -export function LEFT$init(): rt.Cell { - return new rt.Cell(1); +export function LEFT$init(): rs.Cell { + return new rs.Cell(1); } -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey((): rt.RefCell => { +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey((): rs.RefCell => { return LOG$init(undefined); }, true); -export function LOG$init(_1: undefined): rt.RefCell { - return new rt.RefCell(rt.byteVecFrom(Uint8Array.of(1, 2, 3))); +export function LOG$init(_1: undefined): rs.RefCell { + return new rs.RefCell(rs.byteVecFrom(Uint8Array.of(1, 2, 3))); } -export const PAIRS: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(PAIRS$init, false); +export const PAIRS: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(PAIRS$init, false); -export function PAIRS$init(): rt.Cell<[Twin.Twin, Twin.Twin]> { +export function PAIRS$init(): rs.Cell<[Twin.Twin, Twin.Twin]> { const x: Twin.Twin = { _0: 1, _1: 2 }; const y: Twin.Twin = copy$locals_Twin(x); x._0 = 3; - return new rt.Cell([copy$locals_Twin(x), copy$locals_Twin(y)] as [Twin.Twin, Twin.Twin]); + return new rs.Cell([copy$locals_Twin(x), copy$locals_Twin(y)] as [Twin.Twin, Twin.Twin]); } -export const POLLING: rt.LocalKey = /* @__PURE__ */ new rt.LocalKey(POLLING$init, false); +export const POLLING: rs.LocalKey = /* @__PURE__ */ new rs.LocalKey(POLLING$init, false); export function POLLING$init(): Polling.Polling { - return { current: new rt.Cell(undefined as [rt.u64, rt.u64] | undefined), held: new rt.RefCell(new rt.ByteVec()) }; + return { current: new rs.Cell(undefined as [rs.u64, rs.u64] | undefined), held: new rs.RefCell(new rs.ByteVec()) }; } -export const RIGHT: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey((): rt.Cell => { +export const RIGHT: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey((): rs.Cell => { return RIGHT$init(undefined); }, true); -export function RIGHT$init(_1: undefined): rt.Cell { - return new rt.Cell(2); +export function RIGHT$init(_1: undefined): rs.Cell { + return new rs.Cell(2); } -export const TALLY: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey((): rt.RefCell => { +export const TALLY: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey((): rs.RefCell => { return TALLY$init(undefined); }, true); -export function TALLY$init(_1: undefined): rt.RefCell { - return new rt.RefCell(0); +export function TALLY$init(_1: undefined): rs.RefCell { + return new rs.RefCell(0); } /** * Each byte an operation on the thread-locals; each puts what it read and what dropped. * First, what each holds, which only the value it starts with can be. */ -export function locals(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecPush(out, ((a0: rt.Cell): rt.u32 => { +export function locals(data: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecPush(out, ((a0: rs.Cell): rs.u32 => { return a0.v; })(COUNT.get()) & 0xff); - rt.iterExtendBytes(out, rt.byteVecIntoIter(withBorrow$1k8k9m1(LOG, (log2: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(log2)); + rs.iterExtendBytes(out, rs.byteVecIntoIter(withBorrow$04rfir6(LOG, (log2: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(log2)); })), undefined, true); - rt.byteVecPush(out, ((p: Polling.Polling): rt.u8 => { - return option_mapOr$0ucbp7g(p.current.v, 253, (_2: [rt.u64, rt.u64]): rt.u8 => { - return rt.u64Low(_2[0]) & 0xff; + rs.byteVecPush(out, ((p: Polling.Polling): rs.u8 => { + return option_mapOr$1idpb1d(p.current.v, 253, (_2: [rs.u64, rs.u64]): rs.u8 => { + return rs.u64Low(_2[0]) & 0xff; }); })(POLLING.get())); - rt.byteVecPush(out, ((p2: Polling.Polling): rt.u8 => { - const _64: rt.RefCell = rt.refCellBorrow(p2.held); - const _06: rt.u8 = _64.value.length & 0xff; - rt.refRelease(_64); + rs.byteVecPush(out, ((p2: Polling.Polling): rs.u8 => { + const _64: rs.RefCell = rs.refCellBorrow(p2.held); + const _06: rs.u8 = _64.value.length & 0xff; + rs.refRelease(_64); return _06; })(POLLING.get())); - rt.byteVecPush(out, withBorrow$1qygtee(HELD, (held: Noisy.Noisy | undefined): rt.u8 => { - return option_mapOr$0cqaybi(held, 253, (n: Noisy.Noisy): rt.u8 => { + rs.byteVecPush(out, withBorrow$0ff0ub1(HELD, (held: Noisy.Noisy | undefined): rs.u8 => { + return option_mapOr$14nyq77(held, 253, (n: Noisy.Noisy): rs.u8 => { return n.id; }); })); - rt.byteVecPush(out, withBorrow$1t1sbub(TALLY, (tally: rt.u32): rt.u8 => { + rs.byteVecPush(out, withBorrow$1p7azig(TALLY, (tally: rs.u32): rs.u8 => { return tally & 0xff; })); - const _26: [Twin.Twin, Twin.Twin] = get$0x8wyln(PAIRS); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26[0]._0 & 0xff, _26[0]._1 & 0xff, _26[1]._0 & 0xff, _26[1]._1 & 0xff)), undefined, true); - rt.byteVecPush(out, serial(false)); - const log: rt.Arc> = new rt.Arc(new rt.Mutex(new rt.ByteVec())); - for (const op of rt.byteSliceView(data)) { - const _46: rt.u8 = rt.u8Rem(op, 9); + const _26: [Twin.Twin, Twin.Twin] = get$1waoxfw(PAIRS); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_26[0]._0 & 0xff, _26[0]._1 & 0xff, _26[1]._0 & 0xff, _26[1]._1 & 0xff)), undefined, true); + rs.byteVecPush(out, serial(false)); + const log: rs.Arc> = new rs.Arc(new rs.Mutex(new rs.ByteVec())); + for (const op of rs.byteSliceView(data)) { + const _46: rs.u8 = rs.u8Rem(op, 9); if (_46 === 0) { - ((c4: rt.Cell): undefined => { - rt.cellSet(c4, rt.u32WrappingAdd(c4.v, op as rt.u32)); + ((c4: rs.Cell): undefined => { + rs.cellSet(c4, rs.u32WrappingAdd(c4.v, op as rs.u32)); })(COUNT.get()); - rt.byteVecPush(out, ((a02: rt.Cell): rt.u32 => { + rs.byteVecPush(out, ((a02: rs.Cell): rs.u32 => { return a02.v; })(COUNT.get()) & 0xff); } else if (_46 === 1) { - ((log7: rt.RefCell): undefined => { - const _513: rt.RefCell = rt.refCellBorrowMut(log7); - rt.byteVecPush(_513.value, op); - rt.refMutRelease(_513); + ((log7: rs.RefCell): undefined => { + const _513: rs.RefCell = rs.refCellBorrowMut(log7); + rs.byteVecPush(_513.value, op); + rs.refMutRelease(_513); })(LOG.get()); } else if (_46 === 2) { - rt.byteVecPush(out, result_mapOr$18ipla0(rt.Ok(((log6: rt.RefCell): rt.usize => { - const _512: rt.RefCell = rt.refCellBorrow(log6); - const _021: rt.usize = _512.value.length; - rt.refRelease(_512); + rs.byteVecPush(out, result_mapOr$12d9lqr(rs.Ok(((log6: rs.RefCell): rs.usize => { + const _512: rs.RefCell = rs.refCellBorrow(log6); + const _021: rs.usize = _512.value.length; + rs.refRelease(_512); return _021; - })(LOG.get())), 253, (n4: rt.usize): rt.u8 => { + })(LOG.get())), 253, (n4: rs.usize): rs.u8 => { return n4 & 0xff; })); } else if (_46 === 3) { - rt.byteVecPush(out, ((c3: rt.Cell): rt.u8 => { - return ((log5: rt.RefCell): rt.u8 => { - const _318: rt.u8 = c3.v & 0xff; - const _910: rt.RefCell = rt.refCellBorrow(log5); - const _78: rt.ByteVec = _910.value; - const _020: rt.u8 = _318 ^ _78.data[rt.idx(_78, 0)]; - rt.refRelease(_910); + rs.byteVecPush(out, ((c3: rs.Cell): rs.u8 => { + return ((log5: rs.RefCell): rs.u8 => { + const _318: rs.u8 = c3.v & 0xff; + const _910: rs.RefCell = rs.refCellBorrow(log5); + const _78: rs.ByteVec = _910.value; + const _020: rs.u8 = _318 ^ _78.data[rs.idx(_78, 0)]; + rs.refRelease(_910); return _020; })(LOG.get()); })(COUNT.get())); } else if (_46 === 4) { - const outer: [rt.u64, rt.u64] | undefined = ((p3: Polling.Polling): [rt.u64, rt.u64] | undefined => { - const _45: [rt.u64, rt.u64] | undefined = [op as rt.u64, 1]; - return rt.cellReplace(p3.current, _45); + const outer: [rs.u64, rs.u64] | undefined = ((p3: Polling.Polling): [rs.u64, rs.u64] | undefined => { + const _45: [rs.u64, rs.u64] | undefined = [op as rs.u64, 1]; + return rs.cellReplace(p3.current, _45); })(POLLING.get()); - const len: rt.usize = ((p4: Polling.Polling): rt.usize => { - const _611: rt.RefCell = rt.refCellBorrowMut(p4.held); - rt.byteVecPush(_611.value, op); - rt.refMutRelease(_611); - const _1110: rt.RefCell = rt.refCellBorrow(p4.held); - const _017: rt.usize = _1110.value.length; - rt.refRelease(_1110); + const len: rs.usize = ((p4: Polling.Polling): rs.usize => { + const _611: rs.RefCell = rs.refCellBorrowMut(p4.held); + rs.byteVecPush(_611.value, op); + rs.refMutRelease(_611); + const _1110: rs.RefCell = rs.refCellBorrow(p4.held); + const _017: rs.usize = _1110.value.length; + rs.refRelease(_1110); return _017; })(POLLING.get()); - rt.byteVecPush(out, option_mapOr$0ucbp7g(outer, 253, (_23: [rt.u64, rt.u64]): rt.u8 => { - return rt.u64Low(_23[0]) & 0xff; + rs.byteVecPush(out, option_mapOr$1idpb1d(outer, 253, (_23: [rs.u64, rs.u64]): rs.u8 => { + return rs.u64Low(_23[0]) & 0xff; })); - rt.byteVecPush(out, len & 0xff); + rs.byteVecPush(out, len & 0xff); } else if (_46 === 5) { - ((held3: rt.RefCell): undefined => { - const _316: Noisy.Noisy | undefined = new Noisy.Noisy(op, rt.arcClone(log)); - const _94: rt.RefCell = rt.refCellBorrowMut(held3); - rt.drop(_94.value); + ((held3: rs.RefCell): undefined => { + const _316: Noisy.Noisy | undefined = new Noisy.Noisy(op, rs.arcClone(log)); + const _94: rs.RefCell = rs.refCellBorrowMut(held3); + rs.drop(_94.value); _94.value = _316; - rt.refMutRelease(_94); + rs.refMutRelease(_94); })(HELD.get()); } else if (_46 === 6) { - set$0st49po(COUNT, rt.u32WrappingMul(get$1ei2eoj(COUNT), 3)); - rt.byteVecPush(out, replace$0kxb7te(COUNT, op as rt.u32) & 0xff); - rt.byteVecPush(out, take$09yi5f2(COUNT) & 0xff); - set$0st49po(COUNT, rt.u32Add(op as rt.u32, 1)); - const _103: [Twin.Twin, Twin.Twin] = get$0x8wyln(PAIRS); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_103[0]._0 & 0xff, _103[0]._1 & 0xff, _103[1]._0 & 0xff, _103[1]._1 & 0xff)), undefined, true); - rt.byteVecPush(out, option_mapOr$1w5qtj7(thenSome$1d6toqn(rt.u8Rem(op, 2) === 0, undefined), 253, (_22: undefined): rt.u8 => { + set$1ljkjlf(COUNT, rs.u32WrappingMul(get$0q7640n(COUNT), 3)); + rs.byteVecPush(out, replace$143ou38(COUNT, op as rs.u32) & 0xff); + rs.byteVecPush(out, take$1ptr2t1(COUNT) & 0xff); + set$1ljkjlf(COUNT, rs.u32Add(op as rs.u32, 1)); + const _103: [Twin.Twin, Twin.Twin] = get$1waoxfw(PAIRS); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_103[0]._0 & 0xff, _103[0]._1 & 0xff, _103[1]._0 & 0xff, _103[1]._1 & 0xff)), undefined, true); + rs.byteVecPush(out, option_mapOr$0543jy8(thenSome$1qfl7tz(rs.u8Rem(op, 2) === 0, undefined), 253, (_22: undefined): rs.u8 => { return 1; })); } else if (_46 === 7) { - rt.localKeyWithBorrowMut(LOG, (log3: rt.ByteVec): undefined => { - rt.byteVecPush(log3, op); + rs.localKeyWithBorrowMut(LOG, (log3: rs.ByteVec): undefined => { + rs.byteVecPush(log3, op); }); - rt.byteVecPush(out, withBorrow$0r4ucls(LOG, (log4: rt.ByteVec): rt.u8 => { + rs.byteVecPush(out, withBorrow$008xek1(LOG, (log4: rs.ByteVec): rs.u8 => { return log4.length & 0xff; })); - rt.iterExtendBytes(out, rt.byteVecIntoIter(replace$1xk72wn(LOG, rt.byteVecFrom(Uint8Array.of(op)))), undefined, true); - rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(op, op))); - rt.iterExtendBytes(out, rt.byteVecIntoIter(take$122f15k(LOG)), undefined, true); - rt.localKeyRefCellSet(LOG, rt.byteVecFrom(Uint8Array.of(1, 2, 3))); - const _141: rt.LocalKey> = HELD; - const _144: rt.Arc> = rt.arcClone(log); - rt.localKeyRefCellSet(_141, new Noisy.Noisy(op, _144), rt.drop); - rt.localKeyWithBorrowMutPlace(HELD, (held2: rt.Place): undefined => { - rt.drop(held2.v); + rs.iterExtendBytes(out, rs.byteVecIntoIter(replace$0orw47h(LOG, rs.byteVecFrom(Uint8Array.of(op)))), undefined, true); + rs.localKeyRefCellSet(LOG, rs.byteVecFrom(Uint8Array.of(op, op))); + rs.iterExtendBytes(out, rs.byteVecIntoIter(take$1snv7rd(LOG)), undefined, true); + rs.localKeyRefCellSet(LOG, rs.byteVecFrom(Uint8Array.of(1, 2, 3))); + const _141: rs.LocalKey> = HELD; + const _144: rs.Arc> = rs.arcClone(log); + rs.localKeyRefCellSet(_141, new Noisy.Noisy(op, _144), rs.drop); + rs.localKeyWithBorrowMutPlace(HELD, (held2: rs.Place): undefined => { + rs.drop(held2.v); held2.v = undefined; }); - const old: Noisy.Noisy | undefined = replace$0bb3zeq(HELD, new Noisy.Noisy(rt.u8WrappingAdd(op, 1), rt.arcClone(log))); - rt.byteVecPush(out, option_mapOr$0cqaybi(old, 253, (n2: Noisy.Noisy): rt.u8 => { + const old: Noisy.Noisy | undefined = replace$06e3fyj(HELD, new Noisy.Noisy(rs.u8WrappingAdd(op, 1), rs.arcClone(log))); + rs.byteVecPush(out, option_mapOr$14nyq77(old, 253, (n2: Noisy.Noisy): rs.u8 => { return n2.id; })); - rt.drop(old); - rt.byteVecPush(out, option_mapOr$0cqaybi(take$1x34chv(HELD), 253, (n3: Noisy.Noisy): rt.u8 => { - const _013: rt.u8 = n3.id; + rs.drop(old); + rs.byteVecPush(out, option_mapOr$14nyq77(take$0hcjffg(HELD), 253, (n3: Noisy.Noisy): rs.u8 => { + const _013: rs.u8 = n3.id; n3[Symbol.dispose](); return _013; })); - rt.localKeyWithBorrowMutPlace(TALLY, (tally2: rt.Place): undefined => { - tally2.v = rt.u32WrappingAdd(rt.u32WrappingMul(tally2.v, 3), op as rt.u32); + rs.localKeyWithBorrowMutPlace(TALLY, (tally2: rs.Place): undefined => { + tally2.v = rs.u32WrappingAdd(rs.u32WrappingMul(tally2.v, 3), op as rs.u32); }); - rt.byteVecPush(out, withBorrow$1t1sbub(TALLY, (tally3: rt.u32): rt.u8 => { + rs.byteVecPush(out, withBorrow$1p7azig(TALLY, (tally3: rs.u32): rs.u8 => { return tally3 & 0xff; })); - rt.localKeyRefCellSet(TALLY, withBorrow$15ql9sa(TALLY, (tally4: rt.u32): rt.u32 => { - return rt.u32Div(tally4, 2); + rs.localKeyRefCellSet(TALLY, withBorrow$00rpnrn(TALLY, (tally4: rs.u32): rs.u32 => { + return rs.u32Div(tally4, 2); })); } else { - rt.byteVecPush(out, serial(false)); + rs.byteVecPush(out, serial(false)); } - const _181: rt.Mutex = rt.mutexLock(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_181.value))), undefined, true); - rt.mutexUnlock(_181); - const _188: rt.Mutex = rt.mutexLock(log.value); - rt.byteVecClear(_188.value); - rt.mutexUnlock(_188); + const _181: rs.Mutex = rs.mutexLock(log.value); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_181.value))), undefined, true); + rs.mutexUnlock(_181); + const _188: rs.Mutex = rs.mutexLock(log.value); + rs.byteVecClear(_188.value); + rs.mutexUnlock(_188); } - ((c5: rt.Cell): undefined => { - rt.cellSet(c5, 7); + ((c5: rs.Cell): undefined => { + rs.cellSet(c5, 7); })(COUNT.get()); - ((tally5: rt.RefCell): undefined => { - const _515: rt.RefCell = rt.refCellBorrowMut(tally5); + ((tally5: rs.RefCell): undefined => { + const _515: rs.RefCell = rs.refCellBorrowMut(tally5); _515.value = 0; - rt.refMutRelease(_515); + rs.refMutRelease(_515); })(TALLY.get()); - ((log8: rt.RefCell): undefined => { - const _516: rt.RefCell = rt.refCellBorrowMut(log8); - rt.byteVecTruncate(_516.value, 3); - rt.refMutRelease(_516); + ((log8: rs.RefCell): undefined => { + const _516: rs.RefCell = rs.refCellBorrowMut(log8); + rs.byteVecTruncate(_516.value, 3); + rs.refMutRelease(_516); })(LOG.get()); ((p5: Polling.Polling): undefined => { - rt.cellSet(p5.current, undefined as [rt.u64, rt.u64] | undefined); - const _911: rt.RefCell = rt.refCellBorrowMut(p5.held); - rt.byteVecClear(_911.value); - rt.refMutRelease(_911); + rs.cellSet(p5.current, undefined as [rs.u64, rs.u64] | undefined); + const _911: rs.RefCell = rs.refCellBorrowMut(p5.held); + rs.byteVecClear(_911.value); + rs.refMutRelease(_911); })(POLLING.get()); - rt.drop(((held4: rt.RefCell): Noisy.Noisy | undefined => { - const _518: rt.RefCell = rt.refCellBorrowMut(held4); + rs.drop(((held4: rs.RefCell): Noisy.Noisy | undefined => { + const _518: rs.RefCell = rs.refCellBorrowMut(held4); const taken = _518.value; _518.value = undefined; const _024: Noisy.Noisy | undefined = taken; - rt.refMutRelease(_518); + rs.refMutRelease(_518); return _024; })(HELD.get())); serial(true); - const _208: rt.Mutex = rt.mutexLock(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_208.value))), undefined, true); - rt.mutexUnlock(_208); + const _208: rs.Mutex = rs.mutexLock(log.value); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_208.value))), undefined, true); + rs.mutexUnlock(_208); log[Symbol.dispose](); } /** A serial from a thread-local in a function, as kio's `serial` is; starts over if `reset`. */ -export function serial(reset: boolean): rt.u8 { - return ((next: rt.Cell<[rt.u8, rt.u8]>): rt.u8 => { - let _4!: [rt.u8, rt.u8]; +export function serial(reset: boolean): rs.u8 { + return ((next: rs.Cell<[rs.u8, rs.u8]>): rs.u8 => { + let _4!: [rs.u8, rs.u8]; if (!reset) { _4 = next.v; } else { - _4 = [0, 4] as [rt.u8, rt.u8]; + _4 = [0, 4] as [rs.u8, rs.u8]; } - const n: rt.u8 = _4[0]; - const end: rt.u8 = _4[1]; - rt.cellSet(next, [rt.u8WrappingAdd(n, !reset ? 1 : 0), end] as [rt.u8, rt.u8]); + const n: rs.u8 = _4[0]; + const end: rs.u8 = _4[1]; + rs.cellSet(next, [rs.u8WrappingAdd(n, !reset ? 1 : 0), end] as [rs.u8, rs.u8]); return n; })(NEXT$serial.get()); } -export const NEXT$serial: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(NEXT$init$serial, false); +export const NEXT$serial: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NEXT$init$serial, false); -export function NEXT$init$serial(): rt.Cell<[rt.u8, rt.u8]> { - return new rt.Cell([0, 4] as [rt.u8, rt.u8]); +export function NEXT$init$serial(): rs.Cell<[rs.u8, rs.u8]> { + return new rs.Cell([0, 4] as [rs.u8, rs.u8]); } /** `*r = v`, through the reference. */ -export function assign$thread_LocalKey_Cell_u8(r: rt.Place>>, v: rt.LocalKey>): void { +export function assign$thread_LocalKey_Cell_u8(r: rs.Place>>, v: rs.LocalKey>): void { r.v = v; } @@ -286,31 +286,31 @@ export function assign$thread_LocalKey_Cell_u8(r: rt.Place>> = { v: LEFT }; - const _12: rt.u8 = rt.u8Rem(op, 5); +export function keys(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const op of rs.byteSliceView(data)) { + const key: rs.Place>> = { v: LEFT }; + const _12: rs.u8 = rs.u8Rem(op, 5); if (_12 === 0) { assign$thread_LocalKey_Cell_u8(key, RIGHT); } else if (_12 === 1) { const old = key.v; key.v = RIGHT; - rt.byteVecPush(out, get$18ignl5({ v: old }.v)); + rs.byteVecPush(out, get$09fnt4b({ v: old }.v)); } else if (_12 === 2) { - const other: rt.Place>> = { v: RIGHT }; + const other: rs.Place>> = { v: RIGHT }; const swapped = key.v; key.v = other.v; other.v = swapped; - rt.byteVecPush(out, get$18ignl5(other.v)); + rs.byteVecPush(out, get$09fnt4b(other.v)); } else if (_12 === 3) { - rt.cellSet(rt.cellOfPlace(key), RIGHT); + rs.cellSet(rs.cellOfPlace(key), RIGHT); } - const _28: rt.u8 = rt.u8WrappingAdd(get$18ignl5(key.v), op); - set$0xuu1fw(key.v, _28); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$18ignl5(LEFT), get$18ignl5(RIGHT))), undefined, true); + const _28: rs.u8 = rs.u8WrappingAdd(get$09fnt4b(key.v), op); + set$0e2h2hd(key.v, _28); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$09fnt4b(LEFT), get$09fnt4b(RIGHT))), undefined, true); } - set$0xuu1fw(LEFT, 1); - set$0xuu1fw(RIGHT, 2); + set$0e2h2hd(LEFT, 1); + set$0e2h2hd(RIGHT, 2); } //# sourceMappingURL=locals.ts.map diff --git a/ts/fixtures/lang/locals/expected/std/thread/local.ts b/ts/fixtures/lang/locals/expected/std/thread/local.ts index 4fbe683cb..b54751da9 100644 --- a/ts/fixtures/lang/locals/expected/std/thread/local.ts +++ b/ts/fixtures/lang/locals/expected/std/thread/local.ts @@ -1,137 +1,137 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import { copy$tuple2_locals_Twin_locals_Twin } from "../../lib.ts"; import type * as Noisy from "../../locals.Noisy.ts"; import type * as Twin from "../../locals.Twin.ts"; -export function set$0st49po(self: rt.LocalKey>, value: rt.u32): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell | undefined, cell: rt.Cell): undefined => { +export function set$1ljkjlf(self: rs.LocalKey>, value: rs.u32): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell | undefined, cell: rs.Cell): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function set$0xuu1fw(self: rt.LocalKey>, value: rt.u8): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell | undefined, cell: rt.Cell): undefined => { +export function set$0e2h2hd(self: rs.LocalKey>, value: rs.u8): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell | undefined, cell: rs.Cell): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function get$0x8wyln(self: rt.LocalKey>): [Twin.Twin, Twin.Twin] { - return ((a0: rt.Cell<[Twin.Twin, Twin.Twin]>): [Twin.Twin, Twin.Twin] => { +export function get$1waoxfw(self: rs.LocalKey>): [Twin.Twin, Twin.Twin] { + return ((a0: rs.Cell<[Twin.Twin, Twin.Twin]>): [Twin.Twin, Twin.Twin] => { return copy$tuple2_locals_Twin_locals_Twin(a0.v); })(self.get()); } -export function get$1ei2eoj(self: rt.LocalKey>): rt.u32 { - return ((a0: rt.Cell): rt.u32 => { +export function get$0q7640n(self: rs.LocalKey>): rs.u32 { + return ((a0: rs.Cell): rs.u32 => { return a0.v; })(self.get()); } -export function get$18ignl5(self: rt.LocalKey>): rt.u8 { - return ((a0: rt.Cell): rt.u8 => { +export function get$09fnt4b(self: rs.LocalKey>): rs.u8 { + return ((a0: rs.Cell): rs.u8 => { return a0.v; })(self.get()); } -export function take$09yi5f2(self: rt.LocalKey>): rt.u32 { - return ((a0: rt.Cell): rt.u32 => { - return rt.cellReplace(a0, 0); +export function take$1ptr2t1(self: rs.LocalKey>): rs.u32 { + return ((a0: rs.Cell): rs.u32 => { + return rs.cellReplace(a0, 0); })(self.get()); } -export function replace$0kxb7te(self: rt.LocalKey>, value: rt.u32): rt.u32 { +export function replace$143ou38(self: rs.LocalKey>, value: rs.u32): rs.u32 { const captured = value; - return ((cell: rt.Cell): rt.u32 => { - return rt.cellReplace(cell, captured); + return ((cell: rs.Cell): rs.u32 => { + return rs.cellReplace(cell, captured); })(self.get()); } -export function withBorrow$1qygtee(self: rt.LocalKey>, f: (a0: Noisy.Noisy | undefined) => rt.u8): rt.u8 { +export function withBorrow$0ff0ub1(self: rs.LocalKey>, f: (a0: Noisy.Noisy | undefined) => rs.u8): rs.u8 { const captured = f; - return ((cell: rt.RefCell): rt.u8 => { - const _32: (a0: Noisy.Noisy | undefined) => rt.u8 = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell); - const _02: rt.u8 = _32(_7.value); - rt.refRelease(_7); + return ((cell: rs.RefCell): rs.u8 => { + const _32: (a0: Noisy.Noisy | undefined) => rs.u8 = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell); + const _02: rs.u8 = _32(_7.value); + rs.refRelease(_7); return _02; })(self.get()); } -export function withBorrow$1k8k9m1(self: rt.LocalKey>, f: (a0: rt.ByteVec) => rt.ByteVec): rt.ByteVec { +export function withBorrow$04rfir6(self: rs.LocalKey>, f: (a0: rs.ByteVec) => rs.ByteVec): rs.ByteVec { const captured = f; - return ((cell: rt.RefCell): rt.ByteVec => { - const _32: (a0: rt.ByteVec) => rt.ByteVec = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell); - const _02: rt.ByteVec = _32(_7.value); - rt.refRelease(_7); + return ((cell: rs.RefCell): rs.ByteVec => { + const _32: (a0: rs.ByteVec) => rs.ByteVec = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell); + const _02: rs.ByteVec = _32(_7.value); + rs.refRelease(_7); return _02; })(self.get()); } -export function withBorrow$0r4ucls(self: rt.LocalKey>, f: (a0: rt.ByteVec) => rt.u8): rt.u8 { +export function withBorrow$008xek1(self: rs.LocalKey>, f: (a0: rs.ByteVec) => rs.u8): rs.u8 { const captured = f; - return ((cell: rt.RefCell): rt.u8 => { - const _32: (a0: rt.ByteVec) => rt.u8 = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell); - const _02: rt.u8 = _32(_7.value); - rt.refRelease(_7); + return ((cell: rs.RefCell): rs.u8 => { + const _32: (a0: rs.ByteVec) => rs.u8 = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell); + const _02: rs.u8 = _32(_7.value); + rs.refRelease(_7); return _02; })(self.get()); } -export function withBorrow$1t1sbub(self: rt.LocalKey>, f: (a0: rt.u32) => rt.u8): rt.u8 { +export function withBorrow$1p7azig(self: rs.LocalKey>, f: (a0: rs.u32) => rs.u8): rs.u8 { const captured = f; - return ((cell: rt.RefCell): rt.u8 => { - const _32: (a0: rt.u32) => rt.u8 = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell); - const _02: rt.u8 = _32(_7.value); - rt.refRelease(_7); + return ((cell: rs.RefCell): rs.u8 => { + const _32: (a0: rs.u32) => rs.u8 = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell); + const _02: rs.u8 = _32(_7.value); + rs.refRelease(_7); return _02; })(self.get()); } -export function withBorrow$15ql9sa(self: rt.LocalKey>, f: (a0: rt.u32) => rt.u32): rt.u32 { +export function withBorrow$00rpnrn(self: rs.LocalKey>, f: (a0: rs.u32) => rs.u32): rs.u32 { const captured = f; - return ((cell: rt.RefCell): rt.u32 => { - const _32: (a0: rt.u32) => rt.u32 = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell); - const _02: rt.u32 = _32(_7.value); - rt.refRelease(_7); + return ((cell: rs.RefCell): rs.u32 => { + const _32: (a0: rs.u32) => rs.u32 = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell); + const _02: rs.u32 = _32(_7.value); + rs.refRelease(_7); return _02; })(self.get()); } -export function take$1x34chv(self: rt.LocalKey>): Noisy.Noisy | undefined { - return ((a0: rt.RefCell): Noisy.Noisy | undefined => { - return rt.refCellReplace(a0, undefined); +export function take$0hcjffg(self: rs.LocalKey>): Noisy.Noisy | undefined { + return ((a0: rs.RefCell): Noisy.Noisy | undefined => { + return rs.refCellReplace(a0, undefined); })(self.get()); } -export function take$122f15k(self: rt.LocalKey>): rt.ByteVec { - return ((a0: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(a0, new rt.ByteVec()); +export function take$1snv7rd(self: rs.LocalKey>): rs.ByteVec { + return ((a0: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(a0, new rs.ByteVec()); })(self.get()); } -export function replace$0bb3zeq(self: rt.LocalKey>, value: Noisy.Noisy | undefined): Noisy.Noisy | undefined { +export function replace$06e3fyj(self: rs.LocalKey>, value: Noisy.Noisy | undefined): Noisy.Noisy | undefined { const captured = value; - return rt.closure((cell: rt.RefCell): Noisy.Noisy | undefined => { - return rt.refCellReplace(cell, captured); + return rs.closure((cell: rs.RefCell): Noisy.Noisy | undefined => { + return rs.refCellReplace(cell, captured); }, (): void => { - rt.drop(captured); + rs.drop(captured); })(self.get()); } -export function replace$1xk72wn(self: rt.LocalKey>, value: rt.ByteVec): rt.ByteVec { +export function replace$0orw47h(self: rs.LocalKey>, value: rs.ByteVec): rs.ByteVec { const captured = value; - return ((cell: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(cell, captured); + return ((cell: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(cell, captured); })(self.get()); } diff --git a/ts/fixtures/lang/locks/expected/core/bool.ts b/ts/fixtures/lang/locks/expected/core/bool.ts index 586643586..5b2311fa5 100644 --- a/ts/fixtures/lang/locks/expected/core/bool.ts +++ b/ts/fixtures/lang/locks/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0sf2w1i(self: boolean, t: rt.Place): rt.Place | undefined { +export function thenSome$1ueb688(self: boolean, t: rs.Place): rs.Place | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/locks/expected/core/option.ts b/ts/fixtures/lang/locks/expected/core/option.ts index 4c49bd1c8..79770f723 100644 --- a/ts/fixtures/lang/locks/expected/core/option.ts +++ b/ts/fixtures/lang/locks/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Probe from "../locks.Probe.ts"; export function unwrapOr$1iemzn8(self: string | undefined, default_: string): string { @@ -10,21 +10,21 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$16br6l4(self: rt.Arc> | undefined, f: (a0: rt.Arc>) => boolean): boolean | undefined { +export function map$1410a8j(self: rs.Arc> | undefined, f: (a0: rs.Arc>) => boolean): boolean | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1uijrx3(self: rt.Arc>> | undefined, f: (a0: rt.Arc>>) => boolean): boolean | undefined { +export function map$0cdr4co(self: rs.Arc>> | undefined, f: (a0: rs.Arc>>) => boolean): boolean | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/locks/expected/core/result.ts b/ts/fixtures/lang/locks/expected/core/result.ts index dcc16c732..22d4b9c03 100644 --- a/ts/fixtures/lang/locks/expected/core/result.ts +++ b/ts/fixtures/lang/locks/expected/core/result.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally, drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally } from "../lib.ts"; import type * as Tally from "../locks.Tally.ts"; -export function map$02txiwz(self: rt.Result, rt.Mutex>, op: (a0: rt.Mutex) => rt.Result, rt.Mutex>): rt.Result, rt.Mutex>, rt.Mutex> { +export function map$1t3pwfi(self: rs.Result, rs.Mutex>, op: (a0: rs.Mutex) => rs.Result, rs.Mutex>): rs.Result, rs.Mutex>, rs.Mutex> { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result, rt.Mutex>, rt.Mutex>; + return self as rs.Result, rs.Mutex>, rs.Mutex>; } -export function map$1g6jln5(self: rt.Result, rt.RefCell>, op: (a0: rt.RefCell) => rt.Result, rt.RefCell>): rt.Result, rt.RefCell>, rt.RefCell> { +export function map$14a22s8(self: rs.Result, rs.RefCell>, op: (a0: rs.RefCell) => rs.Result, rs.RefCell>): rs.Result, rs.RefCell>, rs.RefCell> { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result, rt.RefCell>, rt.RefCell>; + return self as rs.Result, rs.RefCell>, rs.RefCell>; } -export function mapOr$0666x4n(self: rt.Result, rt.TryLockError>>, default_: rt.u8, f: (a0: rt.Mutex) => rt.u8): rt.u8 { - let _0!: rt.u8; +export function mapOr$162krng(self: rs.Result, rs.TryLockError>>, default_: rs.u8, f: (a0: rs.Mutex) => rs.u8): rs.u8 { + let _0!: rs.u8; if (self.ok) { _0 = f(self.value); } else { @@ -32,8 +32,8 @@ export function mapOr$0666x4n(self: rt.Result, rt.TryLockE return _0; } -export function mapOr$1qkf3ab(self: rt.Result, rt.TryLockError>>, default_: rt.u8, f: (a0: rt.RefCell) => rt.u8): rt.u8 { - let _0!: rt.u8; +export function mapOr$0diztpf(self: rs.Result, rs.TryLockError>>, default_: rs.u8, f: (a0: rs.RefCell) => rs.u8): rs.u8 { + let _0!: rs.u8; if (self.ok) { _0 = f(self.value); } else { diff --git a/ts/fixtures/lang/locks/expected/harness.ts b/ts/fixtures/lang/locks/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/locks/expected/harness.ts +++ b/ts/fixtures/lang/locks/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/locks/expected/lib.ts b/ts/fixtures/lang/locks/expected/lib.ts index 8317b9337..920a7be9d 100644 --- a/ts/fixtures/lang/locks/expected/lib.ts +++ b/ts/fixtures/lang/locks/expected/lib.ts @@ -1,229 +1,229 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { locks, relock, rwlocks, mapped, mutexMapped, printed, downgraded, shown } from "./locks.ts"; import type * as Probe from "./locks.Probe.ts"; import type * as Tally from "./locks.Tally.ts"; -export function drop$Result_Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64_sync_MutexGuard_locks_Tally(_1: rt.Result, rt.Mutex>, rt.Mutex>): void { +export function drop$Result_Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64_sync_MutexGuard_locks_Tally(_1: rs.Result, rs.Mutex>, rs.Mutex>): void { if (_1.ok) { drop$Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64(_1.value); } else { - rt.mutexUnlock(_1.error); + rs.mutexUnlock(_1.error); } } -export function drop$Result_Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64_sync_RwLockWriteGuard_locks_Tally(_1: rt.Result, rt.RefCell>, rt.RefCell>): void { +export function drop$Result_Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64_sync_RwLockWriteGuard_locks_Tally(_1: rs.Result, rs.RefCell>, rs.RefCell>): void { if (_1.ok) { drop$Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64(_1.value); } else { - rt.refMutRelease(_1.error); + rs.refMutRelease(_1.error); } } -export function drop$Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64(_1: rt.Result, rt.Mutex>): void { +export function drop$Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64(_1: rs.Result, rs.Mutex>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { - rt.mutexUnlock(_1.error); + rs.mutexUnlock(_1.error); } } -export function drop$Result_sync_MappedRwLockReadGuard_u8_sync_RwLockReadGuard_locks_Tally(_1: rt.Result, rt.RefCell>): void { +export function drop$Result_sync_MappedRwLockReadGuard_u8_sync_RwLockReadGuard_locks_Tally(_1: rs.Result, rs.RefCell>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { - rt.refRelease(_1.error); + rs.refRelease(_1.error); } } -export function drop$Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64(_1: rt.Result, rt.RefCell>): void { +export function drop$Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64(_1: rs.Result, rs.RefCell>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { - rt.refMutRelease(_1.error); + rs.refMutRelease(_1.error); } } -export function drop$Result_sync_MutexGuard_array4_u8_sync_TryLockError_sync_MutexGuard_array4_u8(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_array4_u8_sync_TryLockError_sync_MutexGuard_array4_u8(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_array4_u8(_1.error); } } -export function drop$Result_sync_MutexGuard_locks_Probe_sync_TryLockError_sync_MutexGuard_locks_Probe(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_locks_Probe_sync_TryLockError_sync_MutexGuard_locks_Probe(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_locks_Probe(_1.error); } } -export function drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_locks_Tally(_1.error); } } -export function drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_u32(_1.error); } } -export function drop$Result_sync_MutexGuard_u8_sync_TryLockError_sync_MutexGuard_u8(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_MutexGuard_u8_sync_TryLockError_sync_MutexGuard_u8(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { drop$sync_TryLockError_sync_MutexGuard_u8(_1.error); } } -export function drop$Result_sync_RwLockReadGuard_array4_u8_sync_TryLockError_sync_RwLockReadGuard_array4_u8(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockReadGuard_array4_u8_sync_TryLockError_sync_RwLockReadGuard_array4_u8(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockReadGuard_array4_u8(_1.error); } } -export function drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_1.error); } } -export function drop$Result_sync_RwLockReadGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_1: rt.Result>, rt.TryLockError>>>): void { +export function drop$Result_sync_RwLockReadGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_1: rs.Result>, rs.TryLockError>>>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_1.error); } } -export function drop$Result_sync_RwLockReadGuard_u32_sync_TryLockError_sync_RwLockReadGuard_u32(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockReadGuard_u32_sync_TryLockError_sync_RwLockReadGuard_u32(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockReadGuard_u32(_1.error); } } -export function drop$Result_sync_RwLockWriteGuard_array4_u8_sync_TryLockError_sync_RwLockWriteGuard_array4_u8(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockWriteGuard_array4_u8_sync_TryLockError_sync_RwLockWriteGuard_array4_u8(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockWriteGuard_array4_u8(_1.error); } } -export function drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_1.error); } } -export function drop$Result_sync_RwLockWriteGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_1: rt.Result>, rt.TryLockError>>>): void { +export function drop$Result_sync_RwLockWriteGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_1: rs.Result>, rs.TryLockError>>>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_1.error); } } -export function drop$Result_sync_RwLockWriteGuard_u32_sync_TryLockError_sync_RwLockWriteGuard_u32(_1: rt.Result, rt.TryLockError>>): void { +export function drop$Result_sync_RwLockWriteGuard_u32_sync_TryLockError_sync_RwLockWriteGuard_u32(_1: rs.Result, rs.TryLockError>>): void { if (_1.ok) { - rt.refMutRelease(_1.value); + rs.refMutRelease(_1.value); } else { drop$sync_TryLockError_sync_RwLockWriteGuard_u32(_1.error); } } -export function drop$sync_TryLockError_sync_MutexGuard_array4_u8(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_array4_u8(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_MutexGuard_locks_Probe(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_locks_Probe(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_MutexGuard_locks_Tally(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_locks_Tally(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_MutexGuard_u32(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_u32(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_MutexGuard_u8(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_MutexGuard_u8(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.mutexUnlock((_1 as { tag: "Poisoned"; _0: rt.Mutex })._0); + rs.mutexUnlock((_1 as { tag: "Poisoned"; _0: rs.Mutex })._0); } } -export function drop$sync_TryLockError_sync_RwLockReadGuard_array4_u8(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockReadGuard_array4_u8(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } -export function drop$sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } -export function drop$sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_1: rt.TryLockError>>): void { +export function drop$sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_1: rs.TryLockError>>): void { if (_1.tag === "Poisoned") { - rt.refRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell> })._0); + rs.refRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell> })._0); } } -export function drop$sync_TryLockError_sync_RwLockReadGuard_u32(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockReadGuard_u32(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } -export function drop$sync_TryLockError_sync_RwLockWriteGuard_array4_u8(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockWriteGuard_array4_u8(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refMutRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refMutRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } -export function drop$sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refMutRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refMutRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } -export function drop$sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_1: rt.TryLockError>>): void { +export function drop$sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_1: rs.TryLockError>>): void { if (_1.tag === "Poisoned") { - rt.refMutRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell> })._0); + rs.refMutRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell> })._0); } } -export function drop$sync_TryLockError_sync_RwLockWriteGuard_u32(_1: rt.TryLockError>): void { +export function drop$sync_TryLockError_sync_RwLockWriteGuard_u32(_1: rs.TryLockError>): void { if (_1.tag === "Poisoned") { - rt.refMutRelease((_1 as { tag: "Poisoned"; _0: rt.RefCell })._0); + rs.refMutRelease((_1 as { tag: "Poisoned"; _0: rs.RefCell })._0); } } @@ -231,24 +231,24 @@ export function drop$sync_TryLockError_sync_RwLockWriteGuard_u32(_1: rt.TryLockE * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["locks::locks", (_27: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["locks::locks", (_27: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { locks(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::relock", (_28: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::relock", (_28: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { relock(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::rwlocks", (_29: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::rwlocks", (_29: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { rwlocks(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::mapped", (_210: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::mapped", (_210: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { mapped(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::mutex_mapped", (_211: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::mutex_mapped", (_211: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { mutexMapped(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::printed", (_212: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::printed", (_212: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { printed(data6, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::downgraded", (_213: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::downgraded", (_213: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { downgraded(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["locks::shown", (_214: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["locks::shown", (_214: rs.u8, data8: rs.ByteSlice, out8: rs.ByteVec): undefined => { shown(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.Lock.ts b/ts/fixtures/lang/locks/expected/locks.Lock.ts index dc0c20afa..c1043fecd 100644 --- a/ts/fixtures/lang/locks/expected/locks.Lock.ts +++ b/ts/fixtures/lang/locks/expected/locks.Lock.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32 } from "./lib.ts"; /** A mutex that debugs through `try_lock`, as kio's `Lock` does. */ export interface Lock { - _0: rt.Mutex; + _0: rs.Mutex; } -export function fmt$fmt_Debug(self: Lock, f: rt.Formatter): rt.Result { - let _0!: rt.Result; - const _3: rt.Result, rt.TryLockError>> = rt.mutexTryLock(self._0); +export function fmt$fmt_Debug(self: Lock, f: rs.Formatter): rs.Result { + let _0!: rs.Result; + const _3: rs.Result, rs.TryLockError>> = rs.mutexTryLock(self._0); if (_3.ok) { - const guard: rt.Mutex = _3.value; - const _9: rt.DebugTuple = rt.fmtDebugTuple(f, "Lock"); - const _12: rt.u32 = guard.value; - _0 = rt.debugTupleFinish(rt.debugTupleField(_9, (f: rt.Formatter) => rt.u32Debug(_12, f))); - rt.mutexUnlock(guard); + const guard: rs.Mutex = _3.value; + const _9: rs.DebugTuple = rs.fmtDebugTuple(f, "Lock"); + const _12: rs.u32 = guard.value; + _0 = rs.debugTupleFinish(rs.debugTupleField(_9, (f: rs.Formatter) => rs.u32Debug(_12, f))); + rs.mutexUnlock(guard); } else { - const _16: rt.DebugTuple = rt.fmtDebugTuple(f, "Lock"); + const _16: rs.DebugTuple = rs.fmtDebugTuple(f, "Lock"); const _19: string = ""; - _0 = rt.debugTupleFinish(rt.debugTupleField(_16, (f: rt.Formatter) => rt.fmtStr(_19, f))); + _0 = rs.debugTupleFinish(rs.debugTupleField(_16, (f: rs.Formatter) => rs.fmtStr(_19, f))); } if (!_3.ok) { drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(_3); diff --git a/ts/fixtures/lang/locks/expected/locks.Probe.ts b/ts/fixtures/lang/locks/expected/locks.Probe.ts index c61403ce9..e45fc208b 100644 --- a/ts/fixtures/lang/locks/expected/locks.Probe.ts +++ b/ts/fixtures/lang/locks/expected/locks.Probe.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_sync_MutexGuard_locks_Probe_sync_TryLockError_sync_MutexGuard_locks_Probe, drop$Result_sync_RwLockReadGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe, drop$Result_sync_RwLockWriteGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe } from "./lib.ts"; -import { map$16br6l4 as option_map$16br6l4, map$1uijrx3 as option_map$1uijrx3 } from "./core/option.ts"; +import { map$1410a8j as option_map$1410a8j, map$0cdr4co as option_map$0cdr4co } from "./core/option.ts"; /** Writes whether the locks it is in can be locked, and how it writes, while they write it. */ export class Probe { - mutex: rt.Weak>; - lock: rt.Weak>>; + mutex: rs.Weak>; + lock: rs.Weak>>; - constructor(mutex: rt.Weak>, lock: rt.Weak>>) { + constructor(mutex: rs.Weak>, lock: rs.Weak>>) { this.mutex = mutex; this.lock = lock; } @@ -20,31 +20,31 @@ export class Probe { } } -export function fmt$fmt_Debug(self: Probe, f: rt.Formatter): rt.Result { - const mutex: boolean | undefined = option_map$16br6l4(rt.weakUpgrade(self.mutex), (m: rt.Arc>): boolean => { - const _42: rt.Result, rt.TryLockError>> = rt.mutexTryLock(m.value); +export function fmt$fmt_Debug(self: Probe, f: rs.Formatter): rs.Result { + const mutex: boolean | undefined = option_map$1410a8j(rs.weakUpgrade(self.mutex), (m: rs.Arc>): boolean => { + const _42: rs.Result, rs.TryLockError>> = rs.mutexTryLock(m.value); const _02: boolean = _42.ok; drop$Result_sync_MutexGuard_locks_Probe_sync_TryLockError_sync_MutexGuard_locks_Probe(_42); m[Symbol.dispose](); return _02; }); - const read: boolean | undefined = option_map$1uijrx3(rt.weakUpgrade(self.lock), (l: rt.Arc>>): boolean => { - const _43: rt.Result>, rt.TryLockError>>> = rt.rwLockTryRead(l.value); + const read: boolean | undefined = option_map$0cdr4co(rs.weakUpgrade(self.lock), (l: rs.Arc>>): boolean => { + const _43: rs.Result>, rs.TryLockError>>> = rs.rwLockTryRead(l.value); const _03: boolean = _43.ok; drop$Result_sync_RwLockReadGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockReadGuard_sync_Mutex_locks_Probe(_43); l[Symbol.dispose](); return _03; }); - const written: boolean | undefined = option_map$1uijrx3(rt.weakUpgrade(self.lock), (l2: rt.Arc>>): boolean => { - const _44: rt.Result>, rt.TryLockError>>> = rt.rwLockTryWrite(l2.value); + const written: boolean | undefined = option_map$0cdr4co(rs.weakUpgrade(self.lock), (l2: rs.Arc>>): boolean => { + const _44: rs.Result>, rs.TryLockError>>> = rs.rwLockTryWrite(l2.value); const _04: boolean = _44.ok; drop$Result_sync_RwLockWriteGuard_sync_Mutex_locks_Probe_sync_TryLockError_sync_RwLockWriteGuard_sync_Mutex_locks_Probe(_44); l2[Symbol.dispose](); return _04; }); - const _15: boolean = rt.fmtAlternate(f); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(mutex, f, rt.fmtBool), (f: rt.Formatter) => rt.fmtOption(read, f, rt.fmtBool), (f: rt.Formatter) => rt.fmtOption(written, f, rt.fmtBool), (f: rt.Formatter) => rt.fmtBool(_15, f)]; - return rt.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + const _15: boolean = rs.fmtAlternate(f); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(mutex, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(read, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtOption(written, f, rs.fmtBool), (f: rs.Formatter) => rs.fmtBool(_15, f)]; + return rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); } //# sourceMappingURL=locks.Probe.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.Tally.ts b/ts/fixtures/lang/locks/expected/locks.Tally.ts index 8fd8ad060..cfadb0991 100644 --- a/ts/fixtures/lang/locks/expected/locks.Tally.ts +++ b/ts/fixtures/lang/locks/expected/locks.Tally.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Tally { - return { n: 0, seen: new rt.ByteVec() }; + return { n: 0, seen: new rs.ByteVec() }; } /** A value a mutex holds, which `Default` makes. */ export interface Tally { - n: rt.u64; - seen: rt.ByteVec; + n: rs.u64; + seen: rs.ByteVec; } //# sourceMappingURL=locks.Tally.ts.map diff --git a/ts/fixtures/lang/locks/expected/locks.ts b/ts/fixtures/lang/locks/expected/locks.ts index 1ffb0db39..5a79f3bce 100644 --- a/ts/fixtures/lang/locks/expected/locks.ts +++ b/ts/fixtures/lang/locks/expected/locks.ts @@ -1,98 +1,98 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64_sync_MutexGuard_locks_Tally, drop$Result_Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64_sync_RwLockWriteGuard_locks_Tally, drop$Result_sync_MappedRwLockReadGuard_u8_sync_RwLockReadGuard_locks_Tally, drop$Result_sync_MutexGuard_array4_u8_sync_TryLockError_sync_MutexGuard_array4_u8, drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally, drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32, drop$Result_sync_MutexGuard_u8_sync_TryLockError_sync_MutexGuard_u8, drop$Result_sync_RwLockReadGuard_array4_u8_sync_TryLockError_sync_RwLockReadGuard_array4_u8, drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally, drop$Result_sync_RwLockReadGuard_u32_sync_TryLockError_sync_RwLockReadGuard_u32, drop$Result_sync_RwLockWriteGuard_array4_u8_sync_TryLockError_sync_RwLockWriteGuard_array4_u8, drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally, drop$Result_sync_RwLockWriteGuard_u32_sync_TryLockError_sync_RwLockWriteGuard_u32 } from "./lib.ts"; -import { thenSome$0sf2w1i, thenSome$0d5am30 } from "./core/bool.ts"; -import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { map$02txiwz as result_map$02txiwz, map$1g6jln5 as result_map$1g6jln5, mapOr$0666x4n as result_mapOr$0666x4n, mapOr$1qkf3ab as result_mapOr$1qkf3ab } from "./core/result.ts"; +import { thenSome$1ueb688, thenSome$0quywni } from "./core/bool.ts"; +import { unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { map$1t3pwfi as result_map$1t3pwfi, map$14a22s8 as result_map$14a22s8, mapOr$162krng as result_mapOr$162krng, mapOr$0diztpf as result_mapOr$0diztpf } from "./core/result.ts"; import * as Lock from "./locks.Lock.ts"; import * as Probe from "./locks.Probe.ts"; import * as Tally from "./locks.Tally.ts"; /** Each byte an operation on the mutexes, its value the operand; each puts what it read. */ -export function locks(data: rt.ByteSlice, out: rt.ByteVec): void { +export function locks(data: rs.ByteSlice, out: rs.ByteVec): void { let _85!: boolean; - const shared: rt.Arc> = new rt.Arc(new rt.Mutex(Tally.default$Default())); - const other: rt.Arc> = rt.arcClone(shared); - const own: rt.Mutex = new rt.Mutex(new rt.ByteVec()); - const number: rt.Mutex = new rt.Mutex(0); - const slot: rt.Mutex = new rt.Mutex(undefined); - const lock: Lock.Lock = { _0: new rt.Mutex(7) }; - for (const op of rt.byteSliceView(data)) { - const _18: rt.u8 = rt.u8Rem(op, 8); + const shared: rs.Arc> = new rs.Arc(new rs.Mutex(Tally.default$Default())); + const other: rs.Arc> = rs.arcClone(shared); + const own: rs.Mutex = new rs.Mutex(new rs.ByteVec()); + const number: rs.Mutex = new rs.Mutex(0); + const slot: rs.Mutex = new rs.Mutex(undefined); + const lock: Lock.Lock = { _0: new rs.Mutex(7) }; + for (const op of rs.byteSliceView(data)) { + const _18: rs.u8 = rs.u8Rem(op, 8); if (_18 === 0) { - const tally: rt.Mutex = rt.mutexLock(shared.value); - tally.value.n = rt.u64Add(tally.value.n, op as rt.u64); - rt.byteVecPush(tally.value.seen, op); - rt.mutexUnlock(tally); + const tally: rs.Mutex = rs.mutexLock(shared.value); + tally.value.n = rs.u64Add(tally.value.n, op as rs.u64); + rs.byteVecPush(tally.value.seen, op); + rs.mutexUnlock(tally); } else if (_18 === 1) { - const tally2: rt.Mutex = rt.mutexLock(other.value); - rt.byteVecPush(out, rt.u64Low(tally2.value.n) & 0xff); - rt.byteVecPush(out, tally2.value.seen.length & 0xff); - rt.mutexUnlock(tally2); + const tally2: rs.Mutex = rs.mutexLock(other.value); + rs.byteVecPush(out, rs.u64Low(tally2.value.n) & 0xff); + rs.byteVecPush(out, tally2.value.seen.length & 0xff); + rs.mutexUnlock(tally2); } else if (_18 === 2) { - rt.byteVecPush(own.value, op); - const _52: rt.u32 = op as rt.u32; - const _53: rt.Place = rt.valuePlace(number); - _53.v = rt.u32Add(_53.v, _52); - const held: rt.Place = rt.valuePlace(slot); + rs.byteVecPush(own.value, op); + const _52: rs.u32 = op as rs.u32; + const _53: rs.Place = rs.valuePlace(number); + _53.v = rs.u32Add(_53.v, _52); + const held: rs.Place = rs.valuePlace(slot); const taken = held.v; held.v = undefined; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(taken, 253)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(taken, 253)); held.v = op; } else if (_18 === 3) { - const _64: rt.u32 = op as rt.u32; - const _67: rt.Mutex = rt.mutexLock(number); - _67.value = rt.u32Add(_67.value, _64); - rt.mutexUnlock(_67); - const _76: rt.Mutex = rt.mutexLock(number); - rt.byteVecPush(out, _76.value & 0xff); - rt.mutexUnlock(_76); + const _64: rs.u32 = op as rs.u32; + const _67: rs.Mutex = rs.mutexLock(number); + _67.value = rs.u32Add(_67.value, _64); + rs.mutexUnlock(_67); + const _76: rs.Mutex = rs.mutexLock(number); + rs.byteVecPush(out, _76.value & 0xff); + rs.mutexUnlock(_76); } else if (_18 === 4) { - const held2: rt.Mutex = rt.mutexLock(shared.value); - const _86: rt.Result, rt.TryLockError>> = rt.mutexTryLock(other.value); + const held2: rs.Mutex = rs.mutexLock(shared.value); + const _86: rs.Result, rs.TryLockError>> = rs.mutexTryLock(other.value); if (!_86.ok) { _85 = true; } else { _85 = false; } - rt.byteVecPush(out, _85 ? 1 : 0); + rs.byteVecPush(out, _85 ? 1 : 0); drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally(_86); - rt.mutexUnlock(held2); - const _92: rt.Result, rt.TryLockError>> = rt.mutexTryLock(other.value); + rs.mutexUnlock(held2); + const _92: rs.Result, rs.TryLockError>> = rs.mutexTryLock(other.value); if (_92.ok) { - const tally3: rt.Mutex = _92.value; - rt.byteVecPush(out, tally3.value.seen.length & 0xff); - rt.mutexUnlock(tally3); + const tally3: rs.Mutex = _92.value; + rs.byteVecPush(out, tally3.value.seen.length & 0xff); + rs.mutexUnlock(tally3); } else { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } } else if (_18 === 5) { - const _104: rt.u32 = op as rt.u32; - const _107: rt.Mutex = rt.mutexLock(lock._0); - _107.value = rt.u32Add(_107.value, _104); - rt.mutexUnlock(_107); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const free: string = rt.fmtFormat([args2[0]]); - const guard: rt.Result, rt.TryLockError>> = rt.mutexTryLock(lock._0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; - const held3: string = rt.fmtFormat([args4[0]]); + const _104: rs.u32 = op as rs.u32; + const _107: rs.Mutex = rs.mutexLock(lock._0); + _107.value = rs.u32Add(_107.value, _104); + rs.mutexUnlock(_107); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; + const free: string = rs.fmtFormat([args2[0]]); + const guard: rs.Result, rs.TryLockError>> = rs.mutexTryLock(lock._0); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Lock.fmt$fmt_Debug(lock, f)]; + const held3: string = rs.fmtFormat([args4[0]]); const _139: boolean = guard.ok; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free), (f: rt.Formatter) => rt.fmtPad(f, held3), (f: rt.Formatter) => rt.fmtBool(_139, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.fmtPad(f, held3), (f: rs.Formatter) => rs.fmtBool(_139, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], " ", args6[2]]))); drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(guard); } else if (_18 === 6) { - rt.byteVecPush(out, false ? 1 : 0); + rs.byteVecPush(out, false ? 1 : 0); } else { - const tally4: rt.Mutex = rt.mutexLock(shared.value); - rt.byteVecPush(out, tally4.value.seen.length & 0xff); - rt.mutexUnlock(tally4); + const tally4: rs.Mutex = rs.mutexLock(shared.value); + rs.byteVecPush(out, tally4.value.seen.length & 0xff); + rs.mutexUnlock(tally4); } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(own.value)); - rt.byteVecPush(out, shared.strong & 0xff); - rt.byteVecPush(out, number.value & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(slot.value, 253)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(own.value)); + rs.byteVecPush(out, shared.strong & 0xff); + rs.byteVecPush(out, number.value & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(slot.value, 253)); other[Symbol.dispose](); shared[Symbol.dispose](); } @@ -103,102 +103,102 @@ export function locks(data: rt.ByteSlice, out: rt.ByteVec): void { * read-write lock read or written through a guard, mapped or not, then read if the low * bit is clear and otherwise written, which aborts as wasm32's does unless both read. */ -export function relock(data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 | undefined = rt.byteSliceFirst(data); +export function relock(data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 | undefined = rs.byteSliceFirst(data); if (_4 !== undefined) { - const pick: rt.u8 = _4; - const mutex: rt.Mutex = new rt.Mutex(pick); - const lock: rt.RefCell = new rt.RefCell({ n: pick as rt.u64, seen: rt.byteVecFrom(Uint8Array.of(pick)) }); - const again: (a0: rt.ByteVec) => undefined = (out2: rt.ByteVec): undefined => { + const pick: rs.u8 = _4; + const mutex: rs.Mutex = new rs.Mutex(pick); + const lock: rs.RefCell = new rs.RefCell({ n: pick as rs.u64, seen: rs.byteVecFrom(Uint8Array.of(pick)) }); + const again: (a0: rs.ByteVec) => undefined = (out2: rs.ByteVec): undefined => { if ((pick & 1) === 0) { - const _93: rt.RefCell = rt.rwLockRead(lock); - rt.byteVecPush(out2, rt.u64Low(_93.value.n) & 0xff); - rt.refRelease(_93); + const _93: rs.RefCell = rs.rwLockRead(lock); + rs.byteVecPush(out2, rs.u64Low(_93.value.n) & 0xff); + rs.refRelease(_93); } else { - const _162: rt.RefCell = rt.rwLockWrite(lock); - rt.byteVecPush(out2, _162.value.seen.length & 0xff); - rt.refMutRelease(_162); + const _162: rs.RefCell = rs.rwLockWrite(lock); + rs.byteVecPush(out2, _162.value.seen.length & 0xff); + rs.refMutRelease(_162); } }; - const _15: rt.u8 = rt.u8Rem(pick >> 1, 8); + const _15: rs.u8 = rs.u8Rem(pick >> 1, 8); if (_15 === 0) { - const guard: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, guard.value); - const _31: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, _31.value); - rt.mutexUnlock(_31); - rt.mutexUnlock(guard); + const guard: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, guard.value); + const _31: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, _31.value); + rs.mutexUnlock(_31); + rs.mutexUnlock(guard); } else if (_15 === 1) { - const _37: rt.Result, rt.TryLockError>> = rt.mutexTryLock(mutex); + const _37: rs.Result, rs.TryLockError>> = rs.mutexTryLock(mutex); if (_37.ok) { - const guard2: rt.Mutex = _37.value; - rt.byteVecPush(out, guard2.value); - const _48: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, _48.value); - rt.mutexUnlock(_48); - rt.mutexUnlock(guard2); + const guard2: rs.Mutex = _37.value; + rs.byteVecPush(out, guard2.value); + const _48: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, _48.value); + rs.mutexUnlock(_48); + rs.mutexUnlock(guard2); } else { drop$Result_sync_MutexGuard_u8_sync_TryLockError_sync_MutexGuard_u8(_37); - rt.panicFmt(["internal error: entered unreachable code: nothing holds the mutex"]); + rs.panicFmt(["internal error: entered unreachable code: nothing holds the mutex"]); } } else if (_15 === 2) { - const read: rt.RefCell = rt.rwLockRead(lock); - rt.byteVecPush(out, rt.u64Low(read.value.n) & 0xff); + const read: rs.RefCell = rs.rwLockRead(lock); + rs.byteVecPush(out, rs.u64Low(read.value.n) & 0xff); again(out); - rt.refRelease(read); + rs.refRelease(read); } else if (_15 === 3) { - const write: rt.RefCell = rt.rwLockWrite(lock); - rt.byteVecPush(out, rt.u64Low(write.value.n) & 0xff); + const write: rs.RefCell = rs.rwLockWrite(lock); + rs.byteVecPush(out, rs.u64Low(write.value.n) & 0xff); again(out); - rt.refMutRelease(write); + rs.refMutRelease(write); } else if (_15 === 4) { - const _74: rt.RefCell = rt.rwLockRead(lock); - const seen: rt.RefCell = rt.refMap(_74, ((t4: Tally.Tally): rt.ByteVec => { + const _74: rs.RefCell = rs.rwLockRead(lock); + const seen: rs.RefCell = rs.refMap(_74, ((t4: Tally.Tally): rs.ByteVec => { return t4.seen; })(_74.value)); - rt.byteVecPush(out, seen.value.length & 0xff); + rs.byteVecPush(out, seen.value.length & 0xff); again(out); - rt.refRelease(seen); + rs.refRelease(seen); } else if (_15 === 5) { - const _86: rt.RefCell = rt.rwLockWrite(lock); - const n: rt.RefCell = rt.refMutMap(_86, ((t3: Tally.Tally): rt.Place => { - return rt.place(() => t3.n, (value2) => t3.n = value2); + const _86: rs.RefCell = rs.rwLockWrite(lock); + const n: rs.RefCell = rs.refMutMap(_86, ((t3: Tally.Tally): rs.Place => { + return rs.place(() => t3.n, (value2) => t3.n = value2); })(_86.value)); - rt.byteVecPush(out, rt.u64Low(n.value) & 0xff); + rs.byteVecPush(out, rs.u64Low(n.value) & 0xff); again(out); - rt.refMutRelease(n); + rs.refMutRelease(n); } else if (_15 === 6) { - const _101: rt.RefCell = rt.rwLockRead(lock); - const _100: rt.Result, rt.RefCell> = rt.refFilterMap(_101, ((t2: Tally.Tally): rt.u8 | undefined => { - return rt.byteSliceFirst(rt.byteVecSlice(t2.seen)); + const _101: rs.RefCell = rs.rwLockRead(lock); + const _100: rs.Result, rs.RefCell> = rs.refFilterMap(_101, ((t2: Tally.Tally): rs.u8 | undefined => { + return rs.byteSliceFirst(rs.byteVecSlice(t2.seen)); })(_101.value)); if (_100.ok) { - const first: rt.RefCell = _100.value; - const first2: rt.RefCell = rt.refMap(first, ((b: rt.u8): rt.u8 => { + const first: rs.RefCell = _100.value; + const first2: rs.RefCell = rs.refMap(first, ((b: rs.u8): rs.u8 => { return b; })(first.value)); - rt.byteVecPush(out, first2.value); + rs.byteVecPush(out, first2.value); again(out); - rt.refRelease(first2); + rs.refRelease(first2); } else { drop$Result_sync_MappedRwLockReadGuard_u8_sync_RwLockReadGuard_locks_Tally(_100); - rt.panicFmt(["internal error: entered unreachable code: seen holds the pick"]); + rs.panicFmt(["internal error: entered unreachable code: seen holds the pick"]); } } else { - const _114: rt.RefCell = rt.rwLockWrite(lock); - const n2: rt.RefCell = rt.refMutMap(_114, ((t: Tally.Tally): rt.Place => { - return rt.place(() => t.n, (value) => t.n = value); + const _114: rs.RefCell = rs.rwLockWrite(lock); + const n2: rs.RefCell = rs.refMutMap(_114, ((t: Tally.Tally): rs.Place => { + return rs.place(() => t.n, (value) => t.n = value); })(_114.value)); - const n3: rt.RefCell = rt.refMutMap(n2, ((n4: rt.Place): rt.Place => { + const n3: rs.RefCell = rs.refMutMap(n2, ((n4: rs.Place): rs.Place => { return n4; - })(rt.valuePlace(n2))); - rt.byteVecPush(out, rt.u64Low(n3.value) & 0xff); + })(rs.valuePlace(n2))); + rs.byteVecPush(out, rs.u64Low(n3.value) & 0xff); again(out); - rt.refMutRelease(n3); + rs.refMutRelease(n3); } - const _130: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, _130.value); - rt.mutexUnlock(_130); + const _130: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, _130.value); + rs.mutexUnlock(_130); again(out); } } @@ -207,95 +207,95 @@ export function relock(data: rt.ByteSlice, out: rt.ByteVec): void { * Each byte an operation on read-write locks, its value the operand; each puts what it * read. */ -export function rwlocks(data: rt.ByteSlice, out: rt.ByteVec): void { +export function rwlocks(data: rs.ByteSlice, out: rs.ByteVec): void { let _75!: boolean; let _91!: boolean; - const lock: rt.Arc> = new rt.Arc(new rt.RefCell(Tally.default$Default())); - const number: rt.RefCell = new rt.RefCell(0); - const owned: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - for (const op of rt.byteSliceView(data)) { - const _13: rt.u8 = rt.u8Rem(op, 8); + const lock: rs.Arc> = new rs.Arc(new rs.RefCell(Tally.default$Default())); + const number: rs.RefCell = new rs.RefCell(0); + const owned: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + for (const op of rs.byteSliceView(data)) { + const _13: rs.u8 = rs.u8Rem(op, 8); if (_13 === 0) { - const tally: rt.RefCell = rt.rwLockWrite(lock.value); - tally.value.n = rt.u64Add(tally.value.n, op as rt.u64); - rt.byteVecPush(tally.value.seen, op); - rt.refMutRelease(tally); + const tally: rs.RefCell = rs.rwLockWrite(lock.value); + tally.value.n = rs.u64Add(tally.value.n, op as rs.u64); + rs.byteVecPush(tally.value.seen, op); + rs.refMutRelease(tally); } else if (_13 === 1) { - const a: rt.RefCell = rt.rwLockRead(lock.value); - const b: rt.RefCell = rt.rwLockRead(lock.value); - rt.byteVecPush(out, a.value.seen.length & 0xff); - rt.byteVecPush(out, rt.u64Low(b.value.n) & 0xff); - rt.refRelease(b); - rt.refRelease(a); + const a: rs.RefCell = rs.rwLockRead(lock.value); + const b: rs.RefCell = rs.rwLockRead(lock.value); + rs.byteVecPush(out, a.value.seen.length & 0xff); + rs.byteVecPush(out, rs.u64Low(b.value.n) & 0xff); + rs.refRelease(b); + rs.refRelease(a); } else if (_13 === 2) { - const _47: rt.u32 = op as rt.u32; - const _50: rt.RefCell = rt.rwLockWrite(number); - _50.value = rt.u32Add(_50.value, _47); - rt.refMutRelease(_50); - const _59: rt.RefCell = rt.rwLockRead(number); - rt.byteVecPush(out, _59.value & 0xff); - rt.refRelease(_59); + const _47: rs.u32 = op as rs.u32; + const _50: rs.RefCell = rs.rwLockWrite(number); + _50.value = rs.u32Add(_50.value, _47); + rs.refMutRelease(_50); + const _59: rs.RefCell = rs.rwLockRead(number); + rs.byteVecPush(out, _59.value & 0xff); + rs.refRelease(_59); } else if (_13 === 3) { - const read: rt.RefCell = rt.rwLockRead(lock.value); - const _70: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock.value); - rt.byteVecPush(out, _70.ok ? 1 : 0); + const read: rs.RefCell = rs.rwLockRead(lock.value); + const _70: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock.value); + rs.byteVecPush(out, _70.ok ? 1 : 0); drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_70); - const _76: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock.value); + const _76: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock.value); if (!_76.ok) { _75 = true; } else { _75 = false; } - rt.byteVecPush(out, _75 ? 1 : 0); + rs.byteVecPush(out, _75 ? 1 : 0); drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_76); - rt.refRelease(read); - const write: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock.value); - rt.byteVecPush(out, write.ok ? 1 : 0); - const _92: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock.value); + rs.refRelease(read); + const write: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock.value); + rs.byteVecPush(out, write.ok ? 1 : 0); + const _92: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock.value); if (!_92.ok) { _91 = true; } else { _91 = false; } - rt.byteVecPush(out, _91 ? 1 : 0); + rs.byteVecPush(out, _91 ? 1 : 0); drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_92); drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(write); } else if (_13 === 4) { - const _97: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock.value); + const _97: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock.value); if (_97.ok) { - const tally2: rt.RefCell = _97.value; - rt.byteVecPush(out, tally2.value.seen.length & 0xff); - rt.refMutRelease(tally2); + const tally2: rs.RefCell = _97.value; + rs.byteVecPush(out, tally2.value.seen.length & 0xff); + rs.refMutRelease(tally2); } else { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } } else if (_13 === 5) { - const made: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _113: rt.RefCell = rt.rwLockWrite(made); - rt.byteVecPush(_113.value, op); - rt.refMutRelease(_113); - const _120: rt.RefCell = rt.rwLockRead(made); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_120.value)); - rt.refRelease(_120); + const made: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _113: rs.RefCell = rs.rwLockWrite(made); + rs.byteVecPush(_113.value, op); + rs.refMutRelease(_113); + const _120: rs.RefCell = rs.rwLockRead(made); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_120.value)); + rs.refRelease(_120); } else if (_13 === 6) { - const _123: rt.u32 = op as rt.u32; - const _124: rt.Place = rt.valuePlace(number); - _124.v = rt.u32Add(_124.v, _123); - rt.byteVecPush(owned.value, op); - const _137: rt.RefCell = rt.rwLockRead(number); - rt.byteVecPush(out, _137.value & 0xff); - rt.refRelease(_137); + const _123: rs.u32 = op as rs.u32; + const _124: rs.Place = rs.valuePlace(number); + _124.v = rs.u32Add(_124.v, _123); + rs.byteVecPush(owned.value, op); + const _137: rs.RefCell = rs.rwLockRead(number); + rs.byteVecPush(out, _137.value & 0xff); + rs.refRelease(_137); } else { - const tally3: Tally.Tally = new rt.RefCell({ n: op as rt.u64, seen: rt.byteVecFrom(Uint8Array.of(op)) }).value; - rt.byteVecPush(out, rt.u64Low(tally3.n) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(tally3.seen)); + const tally3: Tally.Tally = new rs.RefCell({ n: op as rs.u64, seen: rs.byteVecFrom(Uint8Array.of(op)) }).value; + rs.byteVecPush(out, rs.u64Low(tally3.n) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tally3.seen)); } } - const _158: rt.RefCell = rt.rwLockRead(lock.value); - rt.byteVecPush(out, rt.u64Low(_158.value.n) & 0xff); - rt.refRelease(_158); - rt.byteVecPush(out, number.value & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(owned.value)); + const _158: rs.RefCell = rs.rwLockRead(lock.value); + rs.byteVecPush(out, rs.u64Low(_158.value.n) & 0xff); + rs.refRelease(_158); + rs.byteVecPush(out, number.value & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(owned.value)); lock[Symbol.dispose](); } @@ -304,149 +304,149 @@ export function rwlocks(data: rt.ByteSlice, out: rt.ByteVec): void { * parts, its value the operand; each puts what it read through them, what the lock holds * after they drop, and whether it is still locked. */ -export function mapped(data: rt.ByteSlice, out: rt.ByteVec): void { - const lock: rt.RefCell = new rt.RefCell(Tally.default$Default()); - const locked: (a0: rt.ByteVec) => undefined = (out2: rt.ByteVec): undefined => { +export function mapped(data: rs.ByteSlice, out: rs.ByteVec): void { + const lock: rs.RefCell = new rs.RefCell(Tally.default$Default()); + const locked: (a0: rs.ByteVec) => undefined = (out2: rs.ByteVec): undefined => { let read!: boolean; let write!: boolean; - const _43: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock); + const _43: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock); if (!_43.ok) { read = true; } else { read = false; } drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_43); - const _8: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock); + const _8: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock); if (!_8.ok) { write = true; } else { write = false; } drop$Result_sync_RwLockWriteGuard_locks_Tally_sync_TryLockError_sync_RwLockWriteGuard_locks_Tally(_8); - rt.byteVecPush(out2, (((read ? 1 : 0) << 1) & 0xff) | (write ? 1 : 0)); + rs.byteVecPush(out2, (((read ? 1 : 0) << 1) & 0xff) | (write ? 1 : 0)); }; - for (const op of rt.byteSliceView(data)) { - const _13: rt.u8 = rt.u8Rem(op, 4); + for (const op of rs.byteSliceView(data)) { + const _13: rs.u8 = rs.u8Rem(op, 4); if (_13 === 0) { - const _16: rt.RefCell = rt.rwLockWrite(lock); - const n: rt.RefCell = rt.refMutMap(_16, ((t7: Tally.Tally): rt.Place => { - return rt.place(() => t7.n, (value3) => t7.n = value3); + const _16: rs.RefCell = rs.rwLockWrite(lock); + const n: rs.RefCell = rs.refMutMap(_16, ((t7: Tally.Tally): rs.Place => { + return rs.place(() => t7.n, (value3) => t7.n = value3); })(_16.value)); - n.value = rt.u64Add(n.value, op as rt.u64); + n.value = rs.u64Add(n.value, op as rs.u64); locked(out); - const _27: rt.RefCell = n; - const again: rt.RefCell = rt.refMutMap(_27, ((n9: rt.Place): rt.Place => { + const _27: rs.RefCell = n; + const again: rs.RefCell = rs.refMutMap(_27, ((n9: rs.Place): rs.Place => { return n9; - })(rt.valuePlace(_27))); - const _28: rt.u64 = rt.u64WrappingMul(again.value, 3); + })(rs.valuePlace(_27))); + const _28: rs.u64 = rs.u64WrappingMul(again.value, 3); again.value = _28; - rt.refMutRelease(again); + rs.refMutRelease(again); locked(out); - const _44: rt.RefCell = rt.rwLockRead(lock); - rt.byteVecPush(out, rt.u64Low(_44.value.n) & 0xff); - rt.refRelease(_44); + const _44: rs.RefCell = rs.rwLockRead(lock); + rs.byteVecPush(out, rs.u64Low(_44.value.n) & 0xff); + rs.refRelease(_44); } else if (_13 === 1) { - const _48: rt.RefCell = rt.rwLockRead(lock); - const seen: rt.RefCell = rt.refMap(_48, ((t6: Tally.Tally): rt.ByteVec => { + const _48: rs.RefCell = rs.rwLockRead(lock); + const seen: rs.RefCell = rs.refMap(_48, ((t6: Tally.Tally): rs.ByteVec => { return t6.seen; })(_48.value)); - rt.byteVecPush(out, seen.value.length & 0xff); - const last: rt.RefCell = rt.refMap(seen, ((s: rt.ByteVec): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceLast(rt.byteVecSlice(s)), 253); + rs.byteVecPush(out, seen.value.length & 0xff); + const last: rs.RefCell = rs.refMap(seen, ((s: rs.ByteVec): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceLast(rs.byteVecSlice(s)), 253); })(seen.value)); - rt.byteVecPush(out, last.value); + rs.byteVecPush(out, last.value); locked(out); - rt.refRelease(last); + rs.refRelease(last); locked(out); } else if (_13 === 2) { - const _70: rt.RefCell = rt.rwLockWrite(lock); - const _69: rt.Result, rt.RefCell> = rt.refMutFilterMap(_70, ((t3: Tally.Tally): rt.Place | undefined => { - return rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(t3.seen))); + const _70: rs.RefCell = rs.rwLockWrite(lock); + const _69: rs.Result, rs.RefCell> = rs.refMutFilterMap(_70, ((t3: Tally.Tally): rs.Place | undefined => { + return rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(t3.seen))); })(_70.value)); if (_69.ok) { - const last2: rt.RefCell = _69.value; - const _75: rt.u8 = rt.u8WrappingAdd(last2.value, op); + const last2: rs.RefCell = _69.value; + const _75: rs.u8 = rs.u8WrappingAdd(last2.value, op); last2.value = _75; - rt.refMutRelease(last2); + rs.refMutRelease(last2); } else { - const whole: rt.RefCell = _69.error; - rt.byteVecPush(whole.value.seen, op); - rt.refMutRelease(whole); + const whole: rs.RefCell = _69.error; + rs.byteVecPush(whole.value.seen, op); + rs.refMutRelease(whole); } locked(out); - const _90: rt.RefCell = rt.rwLockRead(lock); - const _89: rt.Result, rt.RefCell> = rt.refFilterMap(_90, ((t4: Tally.Tally): rt.u8 | undefined => { - return rt.byteSliceFirst(rt.byteVecSlice(t4.seen)); + const _90: rs.RefCell = rs.rwLockRead(lock); + const _89: rs.Result, rs.RefCell> = rs.refFilterMap(_90, ((t4: Tally.Tally): rs.u8 | undefined => { + return rs.byteSliceFirst(rs.byteVecSlice(t4.seen)); })(_90.value)); if (_89.ok) { - const first: rt.RefCell = _89.value; - const _95: rt.Result, rt.RefCell> = rt.refFilterMap(first, ((b2: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(b2 > 128, b2); + const first: rs.RefCell = _89.value; + const _95: rs.Result, rs.RefCell> = rs.refFilterMap(first, ((b2: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(b2 > 128, b2); })(first.value)); if (_95.ok) { - const b: rt.RefCell = _95.value; - rt.byteVecPush(out, b.value); - rt.refRelease(b); + const b: rs.RefCell = _95.value; + rs.byteVecPush(out, b.value); + rs.refRelease(b); } else { - const first2: rt.RefCell = _95.error; - rt.byteVecPush(out, ~first2.value & 0xff); - rt.refRelease(first2); + const first2: rs.RefCell = _95.error; + rs.byteVecPush(out, ~first2.value & 0xff); + rs.refRelease(first2); } } else { - const whole2: rt.RefCell = _89.error; - rt.byteVecPush(out, 240 | (whole2.value.seen.length & 0xff)); - rt.refRelease(whole2); + const whole2: rs.RefCell = _89.error; + rs.byteVecPush(out, 240 | (whole2.value.seen.length & 0xff)); + rs.refRelease(whole2); } locked(out); - const _117: rt.RefCell = rt.rwLockWrite(lock); - const _121: rt.Result, rt.RefCell>, rt.RefCell> = result_map$1g6jln5(rt.refMutFilterMap(_117, ((t5: Tally.Tally): rt.Place | undefined => { - return rt.place(() => t5.n, (value2) => t5.n = value2); - })(_117.value)), (n7: rt.RefCell): rt.Result, rt.RefCell> => { - return rt.refMutFilterMap(n7, ((n8: rt.Place): rt.Place | undefined => { - return thenSome$0sf2w1i(rt.u64And(n8.v, 1) === 0, n8); - })(rt.valuePlace(n7))); + const _117: rs.RefCell = rs.rwLockWrite(lock); + const _121: rs.Result, rs.RefCell>, rs.RefCell> = result_map$14a22s8(rs.refMutFilterMap(_117, ((t5: Tally.Tally): rs.Place | undefined => { + return rs.place(() => t5.n, (value2) => t5.n = value2); + })(_117.value)), (n7: rs.RefCell): rs.Result, rs.RefCell> => { + return rs.refMutFilterMap(n7, ((n8: rs.Place): rs.Place | undefined => { + return thenSome$1ueb688(rs.u64And(n8.v, 1) === 0, n8); + })(rs.valuePlace(n7))); }); if (_121.ok) { if (_121.value.ok) { - const n3: rt.RefCell = _121.value.value; - n3.value = rt.u64Add(n3.value, 1); - rt.refMutRelease(n3); + const n3: rs.RefCell = _121.value.value; + n3.value = rs.u64Add(n3.value, 1); + rs.refMutRelease(n3); } else { - const n4: rt.RefCell = _121.value.error; - n4.value = rt.u64Add(n4.value, 2); - rt.refMutRelease(n4); + const n4: rs.RefCell = _121.value.error; + n4.value = rs.u64Add(n4.value, 2); + rs.refMutRelease(n4); } } else { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } if (!_121.ok) { drop$Result_Result_sync_MappedRwLockWriteGuard_u64_sync_MappedRwLockWriteGuard_u64_sync_RwLockWriteGuard_locks_Tally(_121); } - const _137: rt.RefCell = rt.rwLockRead(lock); - rt.byteVecPush(out, rt.u64Low(_137.value.n) & 0xff); - rt.refRelease(_137); - const _145: rt.RefCell = rt.rwLockRead(lock); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_145.value.seen)); - rt.refRelease(_145); + const _137: rs.RefCell = rs.rwLockRead(lock); + rs.byteVecPush(out, rs.u64Low(_137.value.n) & 0xff); + rs.refRelease(_137); + const _145: rs.RefCell = rs.rwLockRead(lock); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_145.value.seen)); + rs.refRelease(_145); } else { - const _149: rt.RefCell = rt.rwLockWrite(lock); - const n5: rt.RefCell = rt.refMutMap(_149, ((t: Tally.Tally): rt.Place => { - return rt.place(() => t.n, (value) => t.n = value); + const _149: rs.RefCell = rs.rwLockWrite(lock); + const n5: rs.RefCell = rs.refMutMap(_149, ((t: Tally.Tally): rs.Place => { + return rs.place(() => t.n, (value) => t.n = value); })(_149.value)); locked(out); - rt.refMutRelease(n5); - const _157: rt.RefCell = rt.rwLockRead(lock); - const n6: rt.RefCell = rt.refMap(_157, ((t2: Tally.Tally): rt.u64 => { + rs.refMutRelease(n5); + const _157: rs.RefCell = rs.rwLockRead(lock); + const n6: rs.RefCell = rs.refMap(_157, ((t2: Tally.Tally): rs.u64 => { return t2.n; })(_157.value)); locked(out); - rt.byteVecPush(out, rt.u64Low(n6.value) & 0xff); - rt.refRelease(n6); + rs.byteVecPush(out, rs.u64Low(n6.value) & 0xff); + rs.refRelease(n6); } } const last3: Tally.Tally = lock.value; - rt.byteVecPush(out, rt.u64Low(last3.n) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last3.seen)); + rs.byteVecPush(out, rs.u64Low(last3.n) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last3.seen)); } /** @@ -454,224 +454,224 @@ export function mapped(data: rt.ByteSlice, out: rt.ByteVec): void { * values, its value the operand; each puts what it read through them, what the mutex * holds after they drop, and whether it is still locked. */ -export function mutexMapped(data: rt.ByteSlice, out: rt.ByteVec): void { - const mutex: rt.Mutex = new rt.Mutex(Tally.default$Default()); - const number: rt.Mutex = new rt.Mutex(0); - const locked: (a0: rt.ByteVec) => undefined = (out2: rt.ByteVec): undefined => { +export function mutexMapped(data: rs.ByteSlice, out: rs.ByteVec): void { + const mutex: rs.Mutex = new rs.Mutex(Tally.default$Default()); + const number: rs.Mutex = new rs.Mutex(0); + const locked: (a0: rs.ByteVec) => undefined = (out2: rs.ByteVec): undefined => { let tally!: boolean; let number2!: boolean; - const _45: rt.Result, rt.TryLockError>> = rt.mutexTryLock(mutex); + const _45: rs.Result, rs.TryLockError>> = rs.mutexTryLock(mutex); if (!_45.ok) { tally = true; } else { tally = false; } drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally(_45); - const _8: rt.Result, rt.TryLockError>> = rt.mutexTryLock(number); + const _8: rs.Result, rs.TryLockError>> = rs.mutexTryLock(number); if (!_8.ok) { number2 = true; } else { number2 = false; } drop$Result_sync_MutexGuard_u32_sync_TryLockError_sync_MutexGuard_u32(_8); - rt.byteVecPush(out2, (((tally ? 1 : 0) << 1) & 0xff) | (number2 ? 1 : 0)); + rs.byteVecPush(out2, (((tally ? 1 : 0) << 1) & 0xff) | (number2 ? 1 : 0)); }; - for (const op of rt.byteSliceView(data)) { - const _15: rt.u8 = rt.u8Rem(op, 4); + for (const op of rs.byteSliceView(data)) { + const _15: rs.u8 = rs.u8Rem(op, 4); if (_15 === 0) { - const _18: rt.Mutex = rt.mutexLock(mutex); - const n: rt.Mutex = rt.mutexMap(_18, ((t7: Tally.Tally): rt.Place => { - return rt.place(() => t7.n, (value3) => t7.n = value3); + const _18: rs.Mutex = rs.mutexLock(mutex); + const n: rs.Mutex = rs.mutexMap(_18, ((t7: Tally.Tally): rs.Place => { + return rs.place(() => t7.n, (value3) => t7.n = value3); })(_18.value)); - n.value = rt.u64Add(n.value, op as rt.u64); + n.value = rs.u64Add(n.value, op as rs.u64); locked(out); - const _29: rt.Mutex = n; - const again: rt.Mutex = rt.mutexMap(_29, ((n8: rt.Place): rt.Place => { + const _29: rs.Mutex = n; + const again: rs.Mutex = rs.mutexMap(_29, ((n8: rs.Place): rs.Place => { return n8; - })(rt.valuePlace(_29))); - const _30: rt.u64 = rt.u64WrappingMul(again.value, 3); + })(rs.valuePlace(_29))); + const _30: rs.u64 = rs.u64WrappingMul(again.value, 3); again.value = _30; - rt.mutexUnlock(again); + rs.mutexUnlock(again); locked(out); - const _46: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, rt.u64Low(_46.value.n) & 0xff); - rt.mutexUnlock(_46); - const _50: rt.Mutex = rt.mutexLock(number); - const whole: rt.Mutex = rt.mutexMap(_50, ((n9: rt.Place): rt.Place => { + const _46: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, rs.u64Low(_46.value.n) & 0xff); + rs.mutexUnlock(_46); + const _50: rs.Mutex = rs.mutexLock(number); + const whole: rs.Mutex = rs.mutexMap(_50, ((n9: rs.Place): rs.Place => { return n9; - })(rt.valuePlace(_50))); - const _58: rt.u32 = rt.u32Add(rt.u32WrappingMul(whole.value, 5), op as rt.u32); + })(rs.valuePlace(_50))); + const _58: rs.u32 = rs.u32Add(rs.u32WrappingMul(whole.value, 5), op as rs.u32); whole.value = _58; locked(out); - rt.mutexUnlock(whole); - const _71: rt.Mutex = rt.mutexLock(number); - rt.byteVecPush(out, _71.value & 0xff); - rt.mutexUnlock(_71); + rs.mutexUnlock(whole); + const _71: rs.Mutex = rs.mutexLock(number); + rs.byteVecPush(out, _71.value & 0xff); + rs.mutexUnlock(_71); } else if (_15 === 1) { - const _75: rt.Mutex = rt.mutexLock(mutex); - const seen: rt.Mutex = rt.mutexMap(_75, rt.partPlace(((t5: Tally.Tally): rt.ByteVec => { + const _75: rs.Mutex = rs.mutexLock(mutex); + const seen: rs.Mutex = rs.mutexMap(_75, rs.partPlace(((t5: Tally.Tally): rs.ByteVec => { return t5.seen; })(_75.value))); - rt.byteVecPush(seen.value, op); + rs.byteVecPush(seen.value, op); if ((op >> 4) === 15) { - const _85: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(op, op)); + const _85: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(op, op)); seen.value = _85; } locked(out); - rt.mutexUnlock(seen); - const _99: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_99.value.seen)); - rt.mutexUnlock(_99); + rs.mutexUnlock(seen); + const _99: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_99.value.seen)); + rs.mutexUnlock(_99); if ((op >> 4) === 14) { - const _107: rt.Mutex = rt.mutexLock(mutex); - const whole2: rt.Mutex = rt.mutexMap(_107, rt.partPlace(((t6: Tally.Tally): Tally.Tally => { + const _107: rs.Mutex = rs.mutexLock(mutex); + const whole2: rs.Mutex = rs.mutexMap(_107, rs.partPlace(((t6: Tally.Tally): Tally.Tally => { return t6; })(_107.value))); - const _110: Tally.Tally = { n: op as rt.u64, seen: rt.byteVecFrom(Uint8Array.of(op)) }; + const _110: Tally.Tally = { n: op as rs.u64, seen: rs.byteVecFrom(Uint8Array.of(op)) }; whole2.value = _110; - rt.mutexUnlock(whole2); - const _123: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, rt.u64Low(_123.value.n) & 0xff); - rt.mutexUnlock(_123); + rs.mutexUnlock(whole2); + const _123: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, rs.u64Low(_123.value.n) & 0xff); + rs.mutexUnlock(_123); } } else if (_15 === 2) { - const _128: rt.Mutex = rt.mutexLock(mutex); - const _127: rt.Result, rt.Mutex> = rt.mutexFilterMap(_128, ((t3: Tally.Tally): rt.Place | undefined => { - return rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(t3.seen))); + const _128: rs.Mutex = rs.mutexLock(mutex); + const _127: rs.Result, rs.Mutex> = rs.mutexFilterMap(_128, ((t3: Tally.Tally): rs.Place | undefined => { + return rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(t3.seen))); })(_128.value)); if (_127.ok) { - const last: rt.Mutex = _127.value; - const _133: rt.u8 = rt.u8WrappingAdd(last.value, op); + const last: rs.Mutex = _127.value; + const _133: rs.u8 = rs.u8WrappingAdd(last.value, op); last.value = _133; - rt.mutexUnlock(last); + rs.mutexUnlock(last); } else { - const whole3: rt.Mutex = _127.error; - rt.byteVecPush(whole3.value.seen, op); - rt.mutexUnlock(whole3); + const whole3: rs.Mutex = _127.error; + rs.byteVecPush(whole3.value.seen, op); + rs.mutexUnlock(whole3); } locked(out); - const _147: rt.Mutex = rt.mutexLock(mutex); - const _151: rt.Result, rt.Mutex>, rt.Mutex> = result_map$02txiwz(rt.mutexFilterMap(_147, ((t4: Tally.Tally): rt.Place | undefined => { - return rt.place(() => t4.n, (value2) => t4.n = value2); - })(_147.value)), (n6: rt.Mutex): rt.Result, rt.Mutex> => { - return rt.mutexFilterMap(n6, ((n7: rt.Place): rt.Place | undefined => { - return thenSome$0sf2w1i(rt.u64And(n7.v, 1) === 0, n7); - })(rt.valuePlace(n6))); + const _147: rs.Mutex = rs.mutexLock(mutex); + const _151: rs.Result, rs.Mutex>, rs.Mutex> = result_map$1t3pwfi(rs.mutexFilterMap(_147, ((t4: Tally.Tally): rs.Place | undefined => { + return rs.place(() => t4.n, (value2) => t4.n = value2); + })(_147.value)), (n6: rs.Mutex): rs.Result, rs.Mutex> => { + return rs.mutexFilterMap(n6, ((n7: rs.Place): rs.Place | undefined => { + return thenSome$1ueb688(rs.u64And(n7.v, 1) === 0, n7); + })(rs.valuePlace(n6))); }); if (_151.ok) { if (_151.value.ok) { - const n3: rt.Mutex = _151.value.value; - n3.value = rt.u64Add(n3.value, 1); - rt.mutexUnlock(n3); + const n3: rs.Mutex = _151.value.value; + n3.value = rs.u64Add(n3.value, 1); + rs.mutexUnlock(n3); } else { - const n4: rt.Mutex = _151.value.error; + const n4: rs.Mutex = _151.value.error; locked(out); - n4.value = rt.u64Add(n4.value, 2); - rt.mutexUnlock(n4); + n4.value = rs.u64Add(n4.value, 2); + rs.mutexUnlock(n4); } } else { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } if (!_151.ok) { drop$Result_Result_sync_MappedMutexGuard_u64_sync_MappedMutexGuard_u64_sync_MutexGuard_locks_Tally(_151); } locked(out); - const _173: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecPush(out, rt.u64Low(_173.value.n) & 0xff); - rt.mutexUnlock(_173); - const _181: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(_181.value.seen)); - rt.mutexUnlock(_181); + const _173: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecPush(out, rs.u64Low(_173.value.n) & 0xff); + rs.mutexUnlock(_173); + const _181: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(_181.value.seen)); + rs.mutexUnlock(_181); } else { - const _185: rt.Mutex = rt.mutexLock(mutex); - const n5: rt.Mutex = rt.mutexMap(_185, ((t: Tally.Tally): rt.Place => { - return rt.place(() => t.n, (value) => t.n = value); + const _185: rs.Mutex = rs.mutexLock(mutex); + const n5: rs.Mutex = rs.mutexMap(_185, ((t: Tally.Tally): rs.Place => { + return rs.place(() => t.n, (value) => t.n = value); })(_185.value)); locked(out); - const _195: rt.Result, rt.TryLockError>> = rt.mutexTryLock(mutex); - rt.byteVecPush(out, !_195.ok ? 1 : 0); + const _195: rs.Result, rs.TryLockError>> = rs.mutexTryLock(mutex); + rs.byteVecPush(out, !_195.ok ? 1 : 0); drop$Result_sync_MutexGuard_locks_Tally_sync_TryLockError_sync_MutexGuard_locks_Tally(_195); - rt.mutexUnlock(n5); - rt.byteVecPush(out, result_mapOr$0666x4n(rt.mutexTryLock(mutex), 254, (t2: rt.Mutex): rt.u8 => { - const _0: rt.u8 = t2.value.seen.length & 0xff; - rt.mutexUnlock(t2); + rs.mutexUnlock(n5); + rs.byteVecPush(out, result_mapOr$162krng(rs.mutexTryLock(mutex), 254, (t2: rs.Mutex): rs.u8 => { + const _0: rs.u8 = t2.value.seen.length & 0xff; + rs.mutexUnlock(t2); return _0; })); locked(out); } } const last2: Tally.Tally = mutex.value; - rt.byteVecPush(out, rt.u64Low(last2.n) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last2.seen)); - rt.byteVecPush(out, number.value & 0xff); + rs.byteVecPush(out, rs.u64Low(last2.n) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last2.seen)); + rs.byteVecPush(out, number.value & 0xff); } /** * Each lock's guards printed, plain and mapped, by `Debug` and `Display` and with options, * as std writes what each lends. */ -export function printed(data: rt.ByteSlice, out: rt.ByteVec): void { - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b: rt.u8): rt.char => { - return rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char; +export function printed(data: rs.ByteSlice, out: rs.ByteVec): void { + const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b: rs.u8): rs.char => { + return rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; })); - const mutex: rt.Mutex<[rt.u8, string]> = new rt.Mutex([data.length & 0xff, text] as [rt.u8, string]); - const lock: rt.RefCell<[rt.ByteVec, string]> = new rt.RefCell([rt.byteSliceToByteVec(data), text] as [rt.ByteVec, string]); - const guard: rt.Mutex<[rt.u8, string]> = rt.mutexLock(mutex); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(guard.value[0], f), (f: rt.Formatter) => rt.fmtStr(guard.value[1], f)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0])]))); - const n: rt.Mutex = rt.mutexMap(guard, ((t: [rt.u8, string]): rt.Place => { - return rt.place(() => t[0], (value) => t[0] = value); + const mutex: rs.Mutex<[rs.u8, string]> = new rs.Mutex([data.length & 0xff, text] as [rs.u8, string]); + const lock: rs.RefCell<[rs.ByteVec, string]> = new rs.RefCell([rs.byteSliceToByteVec(data), text] as [rs.ByteVec, string]); + const guard: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(guard.value[0], f), (f: rs.Formatter) => rs.fmtStr(guard.value[1], f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0])]))); + const n: rs.Mutex = rs.mutexMap(guard, ((t: [rs.u8, string]): rs.Place => { + return rs.place(() => t[0], (value) => t[0] = value); })(guard.value)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n.value, f), (f: rt.Formatter) => rt.u8Debug(n.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1], " ", rt.fmtSpec({ align: ">", width: 4 }, args4[0]), " ", rt.fmtSpec({ zero: true, width: 4 }, args4[0])]))); - const n2: rt.Mutex = rt.mutexMap(n, ((n3: rt.Place): rt.Place => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n.value, f), (f: rs.Formatter) => rs.u8Debug(n.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ align: ">", width: 4 }, args4[0]), " ", rs.fmtSpec({ zero: true, width: 4 }, args4[0])]))); + const n2: rs.Mutex = rs.mutexMap(n, ((n3: rs.Place): rs.Place => { return n3; - })(rt.valuePlace(n))); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n2.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat(["[", rt.fmtSpec({ align: "<", width: 3 }, args6[0]), "]"]))); - rt.mutexUnlock(n2); - const _58: rt.Mutex<[rt.u8, string]> = rt.mutexLock(mutex); - const text2: rt.Mutex = rt.mutexMap(_58, ((t2: [rt.u8, string]): rt.Place => { - return rt.place(() => t2[1], (value2) => t2[1] = value2); + })(rs.valuePlace(n))); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat(["[", rs.fmtSpec({ align: "<", width: 3 }, args6[0]), "]"]))); + rs.mutexUnlock(n2); + const _58: rs.Mutex<[rs.u8, string]> = rs.mutexLock(mutex); + const text2: rs.Mutex = rs.mutexMap(_58, ((t2: [rs.u8, string]): rs.Place => { + return rs.place(() => t2[1], (value2) => t2[1] = value2); })(_58.value)); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, text2.value), (f: rt.Formatter) => rt.fmtStr(text2.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args8[0], " ", args8[1], " [", rt.fmtSpec({ align: "^", width: 9 }, args8[0]), "]"]))); - rt.mutexUnlock(text2); - const read: rt.RefCell<[rt.ByteVec, string]> = rt.rwLockRead(lock); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteVecView(read.value[0]), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtStr(read.value[1], f)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args10[0]]))); - const bytes: rt.RefCell = rt.refMap(read, ((t3: [rt.ByteVec, string]): rt.ByteVec => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text2.value), (f: rs.Formatter) => rs.fmtStr(text2.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args8[0], " ", args8[1], " [", rs.fmtSpec({ align: "^", width: 9 }, args8[0]), "]"]))); + rs.mutexUnlock(text2); + const read: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(read.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(read.value[1], f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args10[0]]))); + const bytes: rs.RefCell = rs.refMap(read, ((t3: [rs.ByteVec, string]): rs.ByteVec => { return t3[0]; })(read.value)); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(bytes.value), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args12[0], " ", rt.fmtSpec({ alternate: true }, args12[0])]))); - const _104: rt.RefCell<[rt.ByteVec, string]> = rt.rwLockRead(lock); - const text3: rt.RefCell = rt.refMap(_104, ((t4: [rt.ByteVec, string]): string => { + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(bytes.value), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])]))); + const _104: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockRead(lock); + const text3: rs.RefCell = rs.refMap(_104, ((t4: [rs.ByteVec, string]): string => { return t4[1]; })(_104.value)); - const first: rt.RefCell = rt.refMap(text3, ((t5: string): string => { - return option_unwrapOr$1iemzn8(rt.strGet(t5, 0, 1), "-"); + const first: rs.RefCell = rs.refMap(text3, ((t5: string): string => { + return option_unwrapOr$1iemzn8(rs.strGet(t5, 0, 1), "-"); })(text3.value)); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, first.value), (f: rt.Formatter) => rt.fmtStr(first.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ align: ">", width: 3 }, args14[0])]))); - rt.refRelease(first); - rt.refRelease(bytes); - const write: rt.RefCell<[rt.ByteVec, string]> = rt.rwLockWrite(lock); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteVecView(write.value[0]), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtStr(write.value[1], f)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args16[0]]))); - const text4: rt.RefCell = rt.refMutMap(write, ((t6: [rt.ByteVec, string]): rt.Place => { - return rt.place(() => t6[1], (value3) => t6[1] = value3); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, first.value), (f: rs.Formatter) => rs.fmtStr(first.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ align: ">", width: 3 }, args14[0])]))); + rs.refRelease(first); + rs.refRelease(bytes); + const write: rs.RefCell<[rs.ByteVec, string]> = rs.rwLockWrite(lock); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(write.value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtStr(write.value[1], f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args16[0]]))); + const text4: rs.RefCell = rs.refMutMap(write, ((t6: [rs.ByteVec, string]): rs.Place => { + return rs.place(() => t6[1], (value3) => t6[1] = value3); })(write.value)); text4.value = text4.value + "!"; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, text4.value), (f: rt.Formatter) => rt.fmtStr(text4.value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args18[0], " ", args18[1]]))); - const _154: rt.RefCell = text4; - const text5: rt.RefCell = rt.refMutMap(_154, ((t7: rt.Place): rt.Place => { + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text4.value), (f: rs.Formatter) => rs.fmtStr(text4.value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args18[0], " ", args18[1]]))); + const _154: rs.RefCell = text4; + const text5: rs.RefCell = rs.refMutMap(_154, ((t7: rs.Place): rs.Place => { return t7; - })(rt.valuePlace(_154))); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, text5.value)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([rt.fmtSpec({ align: ">", width: 12 }, args20[0])]))); - rt.refMutRelease(text5); + })(rs.valuePlace(_154))); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, text5.value)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([rs.fmtSpec({ align: ">", width: 12 }, args20[0])]))); + rs.refMutRelease(text5); } /** @@ -679,133 +679,133 @@ export function printed(data: rt.ByteSlice, out: rt.ByteVec): void { * the lock read, and guards mapped to the whole of the bytes a lock holds, its value the * operand; each puts what it read through them and whether each lock is still held. */ -export function downgraded(data: rt.ByteSlice, out: rt.ByteVec): void { - const lock: rt.RefCell = new rt.RefCell(Tally.default$Default()); - const number: rt.RefCell = new rt.RefCell(0); - const quad: rt.RefCell = new rt.RefCell(Uint8Array.of(1, 2, 3, 4)); - const mutex: rt.Mutex = new rt.Mutex(Uint8Array.of(5, 6, 7, 8)); - for (const op of rt.byteSliceView(data)) { - const _16: rt.u8 = rt.u8Rem(op, 4); +export function downgraded(data: rs.ByteSlice, out: rs.ByteVec): void { + const lock: rs.RefCell = new rs.RefCell(Tally.default$Default()); + const number: rs.RefCell = new rs.RefCell(0); + const quad: rs.RefCell = new rs.RefCell(Uint8Array.of(1, 2, 3, 4)); + const mutex: rs.Mutex = new rs.Mutex(Uint8Array.of(5, 6, 7, 8)); + for (const op of rs.byteSliceView(data)) { + const _16: rs.u8 = rs.u8Rem(op, 4); if (_16 === 0) { - const write: rt.RefCell = rt.rwLockWrite(lock); - write.value.n = rt.u64Add(write.value.n, op as rt.u64); - rt.byteVecPush(write.value.seen, op); - const read: rt.RefCell = rt.rwLockDowngrade(write); - rt.byteVecPush(out, held$locks_Tally(lock)); - rt.byteVecPush(out, result_mapOr$1qkf3ab(rt.rwLockTryRead(lock), 254, (t2: rt.RefCell): rt.u8 => { - const _0: rt.u8 = t2.value.seen.length & 0xff; - rt.refRelease(t2); + const write: rs.RefCell = rs.rwLockWrite(lock); + write.value.n = rs.u64Add(write.value.n, op as rs.u64); + rs.byteVecPush(write.value.seen, op); + const read: rs.RefCell = rs.rwLockDowngrade(write); + rs.byteVecPush(out, held$locks_Tally(lock)); + rs.byteVecPush(out, result_mapOr$0diztpf(rs.rwLockTryRead(lock), 254, (t2: rs.RefCell): rs.u8 => { + const _0: rs.u8 = t2.value.seen.length & 0xff; + rs.refRelease(t2); return _0; })); - rt.byteVecPush(out, rt.u64Low(read.value.n) & 0xff); - rt.refRelease(read); - rt.byteVecPush(out, held$locks_Tally(lock)); + rs.byteVecPush(out, rs.u64Low(read.value.n) & 0xff); + rs.refRelease(read); + rs.byteVecPush(out, held$locks_Tally(lock)); } else if (_16 === 1) { - const write2: rt.RefCell = rt.rwLockWrite(number); - write2.value = rt.u32Add(write2.value, op as rt.u32); - const read2: rt.RefCell = rt.rwLockDowngrade(write2); - const other: rt.RefCell = rt.rwLockRead(number); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((read2.value & 0xff) ^ (other.value & 0xff), held$u32(number)))); + const write2: rs.RefCell = rs.rwLockWrite(number); + write2.value = rs.u32Add(write2.value, op as rs.u32); + const read2: rs.RefCell = rs.rwLockDowngrade(write2); + const other: rs.RefCell = rs.rwLockRead(number); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((read2.value & 0xff) ^ (other.value & 0xff), held$u32(number)))); if (!((op & 16) === 0)) { - rt.refRelease(other); - rt.byteVecPush(out, held$u32(number)); - rt.refRelease(read2); + rs.refRelease(other); + rs.byteVecPush(out, held$u32(number)); + rs.refRelease(read2); } else { - rt.refRelease(read2); - rt.byteVecPush(out, held$u32(number)); - rt.refRelease(other); + rs.refRelease(read2); + rs.byteVecPush(out, held$u32(number)); + rs.refRelease(other); } - rt.byteVecPush(out, held$u32(number)); + rs.byteVecPush(out, held$u32(number)); } else if (_16 === 2) { - const _90: rt.RefCell = rt.rwLockWrite(quad); - const f = (q: rt.ByteSlice): rt.ByteSlice => { + const _90: rs.RefCell = rs.rwLockWrite(quad); + const f = (q: rs.ByteSlice): rs.ByteSlice => { return q; }; - const bytes: rt.RefCell = rt.refMutMap(_90, rt.partPlace(rt.byteSliceView(((held) => f(rt.byteSliceFrom(held)))(_90.value)))); - const _93: rt.ByteSlice = rt.byteSliceFrom(bytes.value); - const _95: rt.usize = (op & 3) as rt.usize; + const bytes: rs.RefCell = rs.refMutMap(_90, rs.partPlace(rs.byteSliceView(((held) => f(rs.byteSliceFrom(held)))(_90.value)))); + const _93: rs.ByteSlice = rs.byteSliceFrom(bytes.value); + const _95: rs.usize = (op & 3) as rs.usize; if (!(_95 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _95); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _95); } _93.data[_93.start + _95] = _93.data[_93.start + _95] ^ op; - rt.byteVecPush(out, held$array4_u8(quad)); - const _102: rt.RefCell = bytes; - const f2 = (q2: rt.ByteSlice): rt.ByteSlice => { + rs.byteVecPush(out, held$array4_u8(quad)); + const _102: rs.RefCell = bytes; + const f2 = (q2: rs.ByteSlice): rs.ByteSlice => { return q2; }; - const again: rt.RefCell = rt.refMutMap(_102, rt.partPlace(rt.byteSliceView(((held2) => f2(rt.byteSliceFrom(held2)))(_102.value)))); + const again: rs.RefCell = rs.refMutMap(_102, rs.partPlace(rs.byteSliceView(((held2) => f2(rs.byteSliceFrom(held2)))(_102.value)))); if ((op >> 4) === 15) { - const _107: rt.ByteSlice = rt.byteSliceFrom(again.value); - _107.data.set(rt.bytes(4).fill(op), _107.start); + const _107: rs.ByteSlice = rs.byteSliceFrom(again.value); + _107.data.set(rs.bytes(4).fill(op), _107.start); } - rt.refMutRelease(again); - rt.byteVecPush(out, held$array4_u8(quad)); - const _115: rt.RefCell = rt.rwLockRead(quad); - const f3 = (q3: rt.ByteSlice): rt.ByteSlice => { + rs.refMutRelease(again); + rs.byteVecPush(out, held$array4_u8(quad)); + const _115: rs.RefCell = rs.rwLockRead(quad); + const f3 = (q3: rs.ByteSlice): rs.ByteSlice => { return q3; }; - const read3: rt.RefCell = rt.refMap(_115, rt.byteSliceView(((held3) => f3(rt.byteSliceFrom(held3)))(_115.value))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(read3.value)); - rt.byteVecPush(out, held$array4_u8(quad)); - rt.refRelease(read3); - const _127: rt.Mutex = rt.mutexLock(mutex); - const f4 = (q4: rt.ByteSlice): rt.ByteSlice => { + const read3: rs.RefCell = rs.refMap(_115, rs.byteSliceView(((held3) => f3(rs.byteSliceFrom(held3)))(_115.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(read3.value)); + rs.byteVecPush(out, held$array4_u8(quad)); + rs.refRelease(read3); + const _127: rs.Mutex = rs.mutexLock(mutex); + const f4 = (q4: rs.ByteSlice): rs.ByteSlice => { return q4; }; - const bytes2: rt.Mutex = rt.mutexMap(_127, rt.partPlace(rt.byteSliceView(((held4) => f4(rt.byteSliceFrom(held4)))(_127.value)))); - rt.byteSliceRotateLeft(rt.byteSliceFrom(bytes2.value), 1); + const bytes2: rs.Mutex = rs.mutexMap(_127, rs.partPlace(rs.byteSliceView(((held4) => f4(rs.byteSliceFrom(held4)))(_127.value)))); + rs.byteSliceRotateLeft(rs.byteSliceFrom(bytes2.value), 1); if ((op >> 4) === 14) { - const _138: rt.ByteSlice = rt.byteSliceFrom(bytes2.value); - _138.data.set(rt.bytes(4).fill(op), _138.start); + const _138: rs.ByteSlice = rs.byteSliceFrom(bytes2.value); + _138.data.set(rs.bytes(4).fill(op), _138.start); } - const _144: rt.Result, rt.TryLockError>> = rt.mutexTryLock(mutex); - rt.byteVecPush(out, !_144.ok ? 1 : 0); + const _144: rs.Result, rs.TryLockError>> = rs.mutexTryLock(mutex); + rs.byteVecPush(out, !_144.ok ? 1 : 0); drop$Result_sync_MutexGuard_array4_u8_sync_TryLockError_sync_MutexGuard_array4_u8(_144); - rt.mutexUnlock(bytes2); - const _152: rt.Mutex = rt.mutexLock(mutex); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_152.value)); - rt.mutexUnlock(_152); + rs.mutexUnlock(bytes2); + const _152: rs.Mutex = rs.mutexLock(mutex); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(_152.value)); + rs.mutexUnlock(_152); } else { - const _159: rt.RefCell = rt.rwLockDowngrade(rt.rwLockWrite(lock)); - const seen: rt.RefCell = rt.refMap(_159, ((t: Tally.Tally): rt.ByteVec => { + const _159: rs.RefCell = rs.rwLockDowngrade(rs.rwLockWrite(lock)); + const seen: rs.RefCell = rs.refMap(_159, ((t: Tally.Tally): rs.ByteVec => { return t.seen; })(_159.value)); - rt.byteVecPush(out, held$locks_Tally(lock)); - rt.byteVecPush(out, seen.value.length & 0xff); - rt.refRelease(seen); - rt.byteVecPush(out, held$locks_Tally(lock)); - const write4: rt.RefCell = rt.rwLockWrite(quad); - const _177: rt.ByteSlice = rt.byteSliceFrom(write4.value); - const _175: rt.u8 = rt.u8WrappingAdd(_177.data[_177.start], op); - const _181: rt.ByteSlice = rt.byteSliceFrom(write4.value); + rs.byteVecPush(out, held$locks_Tally(lock)); + rs.byteVecPush(out, seen.value.length & 0xff); + rs.refRelease(seen); + rs.byteVecPush(out, held$locks_Tally(lock)); + const write4: rs.RefCell = rs.rwLockWrite(quad); + const _177: rs.ByteSlice = rs.byteSliceFrom(write4.value); + const _175: rs.u8 = rs.u8WrappingAdd(_177.data[_177.start], op); + const _181: rs.ByteSlice = rs.byteSliceFrom(write4.value); _181.data[_181.start] = _175; - const read4: rt.RefCell = rt.rwLockDowngrade(write4); - const _192: rt.ByteSlice = rt.byteSliceFrom(read4.value); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_192.data[_192.start], held$array4_u8(quad)))); - rt.refRelease(read4); + const read4: rs.RefCell = rs.rwLockDowngrade(write4); + const _192: rs.ByteSlice = rs.byteSliceFrom(read4.value); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_192.data[_192.start], held$array4_u8(quad)))); + rs.refRelease(read4); } } - rt.byteVecPush(out, held$locks_Tally(lock)); + rs.byteVecPush(out, held$locks_Tally(lock)); const last: Tally.Tally = lock.value; - rt.byteVecPush(out, rt.u64Low(last.n) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(last.seen)); - rt.byteVecPush(out, number.value & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(quad.value)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(mutex.value)); + rs.byteVecPush(out, rs.u64Low(last.n) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(last.seen)); + rs.byteVecPush(out, number.value & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(quad.value)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(mutex.value)); } /** Whether a read of `lock` would block, as 2, and whether a write would, as 1. */ -export function held$array4_u8(lock: rt.RefCell): rt.u8 { +export function held$array4_u8(lock: rs.RefCell): rs.u8 { let read!: boolean; let write!: boolean; - const _3: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock); + const _3: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock); if (!_3.ok) { read = true; } else { read = false; } drop$Result_sync_RwLockReadGuard_array4_u8_sync_TryLockError_sync_RwLockReadGuard_array4_u8(_3); - const _7: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock); + const _7: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock); if (!_7.ok) { write = true; } else { @@ -816,17 +816,17 @@ export function held$array4_u8(lock: rt.RefCell): rt.u8 { } /** Whether a read of `lock` would block, as 2, and whether a write would, as 1. */ -export function held$locks_Tally(lock: rt.RefCell): rt.u8 { +export function held$locks_Tally(lock: rs.RefCell): rs.u8 { let read!: boolean; let write!: boolean; - const _3: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock); + const _3: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock); if (!_3.ok) { read = true; } else { read = false; } drop$Result_sync_RwLockReadGuard_locks_Tally_sync_TryLockError_sync_RwLockReadGuard_locks_Tally(_3); - const _7: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock); + const _7: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock); if (!_7.ok) { write = true; } else { @@ -837,17 +837,17 @@ export function held$locks_Tally(lock: rt.RefCell): rt.u8 { } /** Whether a read of `lock` would block, as 2, and whether a write would, as 1. */ -export function held$u32(lock: rt.RefCell): rt.u8 { +export function held$u32(lock: rs.RefCell): rs.u8 { let read!: boolean; let write!: boolean; - const _3: rt.Result, rt.TryLockError>> = rt.rwLockTryRead(lock); + const _3: rs.Result, rs.TryLockError>> = rs.rwLockTryRead(lock); if (!_3.ok) { read = true; } else { read = false; } drop$Result_sync_RwLockReadGuard_u32_sync_TryLockError_sync_RwLockReadGuard_u32(_3); - const _7: rt.Result, rt.TryLockError>> = rt.rwLockTryWrite(lock); + const _7: rs.Result, rs.TryLockError>> = rs.rwLockTryWrite(lock); if (!_7.ok) { write = true; } else { @@ -863,66 +863,66 @@ export function held$u32(lock: rt.RefCell): rt.u8 { * padded, its value the operand: free, held, read, and nested in an `Arc` and each other, * and locked while each writes what it holds. */ -export function shown(data: rt.ByteSlice, out: rt.ByteVec): void { +export function shown(data: rs.ByteSlice, out: rs.ByteVec): void { let text!: string; - const mutex: rt.Arc> = new rt.Arc(new rt.Mutex(0)); - const lock: rt.RefCell>> = new rt.RefCell(rt.vecFrom([new rt.Mutex(97)])); - for (const op of rt.byteSliceView(data)) { - const v: rt.u8 = rt.u8Div(op, 5); - const _18: rt.u8 = rt.u8Rem(op, 5); + const mutex: rs.Arc> = new rs.Arc(new rs.Mutex(0)); + const lock: rs.RefCell>> = new rs.RefCell(rs.vecFrom([new rs.Mutex(97)])); + for (const op of rs.byteSliceView(data)) { + const v: rs.u8 = rs.u8Div(op, 5); + const _18: rs.u8 = rs.u8Rem(op, 5); if (_18 === 0) { - const _22: rt.Mutex = rt.mutexLock(mutex.value); + const _22: rs.Mutex = rs.mutexLock(mutex.value); _22.value = v; - rt.mutexUnlock(_22); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.mutexDebug(mutex.value, f, rt.u8Debug)]; - const free: string = rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0]), " ", rt.fmtSpec({ align: ">", width: 4 }, args2[0])]); - const _held: rt.Mutex = rt.mutexLock(mutex.value); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free), (f: rt.Formatter) => rt.mutexDebug(mutex.value, f, rt.u8Debug)]; - text = rt.fmtFormat([args4[0], " ", args4[1], " ", rt.fmtSpec({ alternate: true }, args4[1]), " ", rt.fmtSpec({ align: ">", width: 12 }, args4[1])]); - rt.mutexUnlock(_held); + rs.mutexUnlock(_22); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + const free: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 4 }, args2[0])]); + const _held: rs.Mutex = rs.mutexLock(mutex.value); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free), (f: rs.Formatter) => rs.mutexDebug(mutex.value, f, rs.u8Debug)]; + text = rs.fmtFormat([args4[0], " ", args4[1], " ", rs.fmtSpec({ alternate: true }, args4[1]), " ", rs.fmtSpec({ align: ">", width: 12 }, args4[1])]); + rs.mutexUnlock(_held); } else if (_18 === 1) { - const _52: rt.RefCell>> = rt.rwLockWrite(lock); - const _55: rt.Mutex = new rt.Mutex(rt.u8Add(97, rt.u8Rem(v, 26)) as rt.char); + const _52: rs.RefCell>> = rs.rwLockWrite(lock); + const _55: rs.Mutex = new rs.Mutex(rs.u8Add(97, rs.u8Rem(v, 26)) as rs.char); _52.value.items.push(_55); - rt.refMutRelease(_52); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.rwLockDebug(lock, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, rt.fmtCharDebug)))]; - const free2: string = rt.fmtFormat([args6[0], " ", rt.fmtSpec({ alternate: true }, args6[0])]); - const read: rt.RefCell>> = rt.rwLockRead(lock); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.rwLockDebug(lock, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, rt.fmtCharDebug)))]; - const shared: string = rt.fmtFormat([args8[0]]); - const _85: rt.Vec> = read.value; - const _held2: rt.Mutex = rt.mutexLock(_85.items[rt.idx(_85.items, 0)]); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, free2), (f: rt.Formatter) => rt.fmtPad(f, shared), (f: rt.Formatter) => rt.rwLockDebug(lock, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, rt.fmtCharDebug)))]; - text = rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", rt.fmtSpec({ alternate: true }, args10[2])]); - rt.mutexUnlock(_held2); - rt.refRelease(read); + rs.refMutRelease(_52); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + const free2: string = rs.fmtFormat([args6[0], " ", rs.fmtSpec({ alternate: true }, args6[0])]); + const read: rs.RefCell>> = rs.rwLockRead(lock); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + const shared: string = rs.fmtFormat([args8[0]]); + const _85: rs.Vec> = read.value; + const _held2: rs.Mutex = rs.mutexLock(_85.items[rs.idx(_85.items, 0)]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, free2), (f: rs.Formatter) => rs.fmtPad(f, shared), (f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + text = rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2])]); + rs.mutexUnlock(_held2); + rs.refRelease(read); } else if (_18 === 2) { - const _held3: rt.RefCell>> = rt.rwLockWrite(lock); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.rwLockDebug(lock, f, (value: rt.Vec>, f: rt.Formatter) => rt.fmtList(value.items, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, rt.fmtCharDebug)))]; - text = rt.fmtFormat([args12[0], " ", rt.fmtSpec({ alternate: true }, args12[0]), " ", rt.fmtSpec({ align: ">", width: 12 }, args12[0])]); - rt.refMutRelease(_held3); + const _held3: rs.RefCell>> = rs.rwLockWrite(lock); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock, f, (value: rs.Vec>, f: rs.Formatter) => rs.fmtList(value.items, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtCharDebug)))]; + text = rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args12[0])]); + rs.refMutRelease(_held3); } else if (_18 === 3) { - if (!(rt.u8Rem(v, 2) === 0)) { - const lock2: rt.Arc>> = rt.arcNewCyclic((me2: rt.Weak>>): rt.RefCell> => { - return new rt.RefCell(new rt.Mutex(new Probe.Probe(new rt.Weak(), rt.weakClone(me2)))); + if (!(rs.u8Rem(v, 2) === 0)) { + const lock2: rs.Arc>> = rs.arcNewCyclic((me2: rs.Weak>>): rs.RefCell> => { + return new rs.RefCell(new rs.Mutex(new Probe.Probe(new rs.Weak(), rs.weakClone(me2)))); }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.rwLockDebug(lock2.value, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, (value: Probe.Probe, f: rt.Formatter) => Probe.fmt$fmt_Debug(value, f)))]; - text = rt.fmtFormat([args16[0], " ", rt.fmtSpec({ alternate: true }, args16[0])]); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(lock2.value, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f)))]; + text = rs.fmtFormat([args16[0], " ", rs.fmtSpec({ alternate: true }, args16[0])]); lock2[Symbol.dispose](); } else { - const mutex2: rt.Arc> = rt.arcNewCyclic((me: rt.Weak>): rt.Mutex => { - return new rt.Mutex(new Probe.Probe(rt.weakClone(me), new rt.Weak())); + const mutex2: rs.Arc> = rs.arcNewCyclic((me: rs.Weak>): rs.Mutex => { + return new rs.Mutex(new Probe.Probe(rs.weakClone(me), new rs.Weak())); }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.mutexDebug(mutex2.value, f, (value: Probe.Probe, f: rt.Formatter) => Probe.fmt$fmt_Debug(value, f))]; - text = rt.fmtFormat([args14[0], " ", rt.fmtSpec({ alternate: true }, args14[0])]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.mutexDebug(mutex2.value, f, (value: Probe.Probe, f: rs.Formatter) => Probe.fmt$fmt_Debug(value, f))]; + text = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0])]); mutex2[Symbol.dispose](); } } else { - const part = new rt.RefCell(new rt.Mutex("s")); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.rwLockDebug(part, f, (value: rt.Mutex, f: rt.Formatter) => rt.mutexDebug(value, f, rt.fmtStr))]; - text = rt.fmtFormat([args18[0]]); + const part = new rs.RefCell(new rs.Mutex("s")); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.rwLockDebug(part, f, (value: rs.Mutex, f: rs.Formatter) => rs.mutexDebug(value, f, rs.fmtStr))]; + text = rs.fmtFormat([args18[0]]); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } mutex[Symbol.dispose](); } diff --git a/ts/fixtures/lang/manual/expected/core/option.ts b/ts/fixtures/lang/manual/expected/core/option.ts index 01795acc5..3674329fe 100644 --- a/ts/fixtures/lang/manual/expected/core/option.ts +++ b/ts/fixtures/lang/manual/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/manual/expected/harness.ts b/ts/fixtures/lang/manual/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/manual/expected/harness.ts +++ b/ts/fixtures/lang/manual/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/manual/expected/lib.ts b/ts/fixtures/lang/manual/expected/lib.ts index c6afa785b..d1f3c6847 100644 --- a/ts/fixtures/lang/manual/expected/lib.ts +++ b/ts/fixtures/lang/manual/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { arcs, needsDrops } from "./manual.ts"; import { uninits } from "./uninit.ts"; @@ -8,14 +8,14 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { if (v === undefined) { return v; } return [v[0], v[1]]; } -export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } @@ -23,14 +23,14 @@ export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["manual::arcs", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["manual::arcs", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { arcs(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["manual::needs_drops", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["manual::needs_drops", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { needsDrops(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["uninit::uninits", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["uninit::uninits", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { uninits(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/manual/expected/manual.ByHand.ts b/ts/fixtures/lang/manual/expected/manual.ByHand.ts index 6f6af3dda..a3fe8988e 100644 --- a/ts/fixtures/lang/manual/expected/manual.ByHand.ts +++ b/ts/fixtures/lang/manual/expected/manual.ByHand.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The crate's struct holding values by hand, which its `Drop` drops one of. */ export class ByHand { - shared: rt.Arc; - count: rt.u32; - pair: [rt.u8, rt.u16]; + shared: rs.Arc; + count: rs.u32; + pair: [rs.u8, rs.u16]; - constructor(shared: rt.Arc, count: rt.u32, pair: [rt.u8, rt.u16]) { + constructor(shared: rs.Arc, count: rs.u32, pair: [rs.u8, rs.u16]) { this.shared = shared; this.count = count; this.pair = pair; @@ -20,7 +20,7 @@ export class ByHand { } export function drop$ops_Drop(self: ByHand): void { - rt.place(() => self.shared, (value) => self.shared = value).v[Symbol.dispose](); + rs.place(() => self.shared, (value) => self.shared = value).v[Symbol.dispose](); } //# sourceMappingURL=manual.ByHand.ts.map diff --git a/ts/fixtures/lang/manual/expected/manual.ts b/ts/fixtures/lang/manual/expected/manual.ts index eeac0d92d..25daf5502 100644 --- a/ts/fixtures/lang/manual/expected/manual.ts +++ b/ts/fixtures/lang/manual/expected/manual.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8, copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16, copy$tuple2_u8_u16 } from "./lib.ts"; import { put } from "./harness.ts"; import * as ByHand from "./manual.ByHand.ts"; /** A value's `ManuallyDrop`, as a generic one makes it, which only an instance lays out. */ -export function held$sync_Arc_u8(value: rt.Arc): rt.Arc { - return rt.arcClone(value); +export function held$sync_Arc_u8(value: rs.Arc): rs.Arc { + return rs.arcClone(value); } /** @@ -15,66 +15,66 @@ export function held$sync_Arc_u8(value: rt.Arc): rt.Arc { * cloned through, dropped, taken, in a struct whose `Drop` drops it, and in an `Arc` that * drops, beside values JS copies written through it and copied while it may hold none. */ -export function arcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const shared: rt.Arc = new rt.Arc(7); - const kept: rt.Vec> = new rt.Vec(); - for (const b of rt.byteSliceView(data)) { - const _12: rt.u8 = rt.u8Rem(b, 9); +export function arcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const shared: rs.Arc = new rs.Arc(7); + const kept: rs.Vec> = new rs.Vec(); + for (const b of rs.byteSliceView(data)) { + const _12: rs.u8 = rs.u8Rem(b, 9); if (_12 === 0) { - rt.arcClone(shared); + rs.arcClone(shared); } else if (_12 === 1) { held$sync_Arc_u8(shared)[Symbol.dispose](); } else if (_12 === 2) { - const m: rt.Arc = held$sync_Arc_u8(shared); - const _24: rt.Arc = ((a0: rt.Arc): rt.Arc => { - return rt.arcClone(a0); + const m: rs.Arc = held$sync_Arc_u8(shared); + const _24: rs.Arc = ((a0: rs.Arc): rs.Arc => { + return rs.arcClone(a0); })(m); kept.items.push(_24); - rt.byteVecPush(out, m.value); + rs.byteVecPush(out, m.value); kept.items.push(m); } else if (_12 === 3) { - let m2: rt.Arc = held$sync_Arc_u8(shared); - rt.place(() => m2, (value2) => m2 = value2).v[Symbol.dispose](); + let m2: rs.Arc = held$sync_Arc_u8(shared); + rs.place(() => m2, (value2) => m2 = value2).v[Symbol.dispose](); } else if (_12 === 4) { - let m3: rt.Arc = held$sync_Arc_u8(shared); - const taken: rt.Arc = rt.place(() => m3, (value) => m3 = value).v; - rt.byteVecPush(out, rt.u8Add(taken.value, taken.strong & 0xff)); + let m3: rs.Arc = held$sync_Arc_u8(shared); + const taken: rs.Arc = rs.place(() => m3, (value) => m3 = value).v; + rs.byteVecPush(out, rs.u8Add(taken.value, taken.strong & 0xff)); taken[Symbol.dispose](); } else if (_12 === 5) { - const h: ByHand.ByHand = new ByHand.ByHand(held$sync_Arc_u8(shared), b as rt.u32, copy$tuple2_u8_u16([b, ((b as rt.u16) << 4) & 0xffff] as [rt.u8, rt.u16])); - h.count = rt.u32Add(h.count, 3); - const _64: [rt.u8, rt.u16] = h.pair; + const h: ByHand.ByHand = new ByHand.ByHand(held$sync_Arc_u8(shared), b as rs.u32, copy$tuple2_u8_u16([b, ((b as rs.u16) << 4) & 0xffff] as [rs.u8, rs.u16])); + h.count = rs.u32Add(h.count, 3); + const _64: [rs.u8, rs.u16] = h.pair; _64[0] = _64[0] ^ 90; - const pair: [rt.u8, rt.u16] = h.pair; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(h.count).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair[0], pair[1] & 0xff, h.shared.value)), undefined, true); + const pair: [rs.u8, rs.u16] = h.pair; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(h.count).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(pair[0], pair[1] & 0xff, h.shared.value)), undefined, true); h[Symbol.dispose](); } else if (_12 === 6) { - rt.arcDrop(new rt.Arc(held$sync_Arc_u8(shared))); + rs.arcDrop(new rs.Arc(held$sync_Arc_u8(shared))); } else if (_12 === 7) { - const slot: [rt.u8, rt.u16] = copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(copy$tuple2_u8_u16([b, ((b as rt.u16) << 3) & 0xffff] as [rt.u8, rt.u16])); - const copy: [rt.u8, rt.u16] = copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(slot); - const _93: [rt.u8, rt.u16] = slot; + const slot: [rs.u8, rs.u16] = copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(copy$tuple2_u8_u16([b, ((b as rs.u16) << 3) & 0xffff] as [rs.u8, rs.u16])); + const copy: [rs.u8, rs.u16] = copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(slot); + const _93: [rs.u8, rs.u16] = slot; _93[0] = _93[0] ^ 51; - const _98: [[rt.u8, rt.u16], [rt.u8, rt.u16]] = [copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(copy), copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(slot)]; - const a: [rt.u8, rt.u16] = _98[0]; - const c: [rt.u8, rt.u16] = _98[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a[0], a[1] & 0xff, c[0], c[1] & 0xff)), undefined, true); + const _98: [[rs.u8, rs.u16], [rs.u8, rs.u16]] = [copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(copy), copy$mem_MaybeUninit_mem_ManuallyDrop_tuple2_u8_u16(slot)]; + const a: [rs.u8, rs.u16] = _98[0]; + const c: [rs.u8, rs.u16] = _98[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a[0], a[1] & 0xff, c[0], c[1] & 0xff)), undefined, true); } else { const m4: Uint8Array = copy$array_u8(Uint8Array.of(b, b ^ 1)); - const _123: rt.ByteSlice = rt.byteSliceFrom(m4); - const _121: rt.u8 = rt.u8WrappingAdd(_123.data[_123.start], 9); - const _127: rt.ByteSlice = rt.byteSliceFrom(m4); + const _123: rs.ByteSlice = rs.byteSliceFrom(m4); + const _121: rs.u8 = rs.u8WrappingAdd(_123.data[_123.start], 9); + const _127: rs.ByteSlice = rs.byteSliceFrom(m4); _127.data[_127.start + 1] = _121; - const copy2: Uint8Array = copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(m4))); - const _134: rt.ByteSlice = rt.byteSliceFrom(m4); + const copy2: Uint8Array = copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(m4))); + const _134: rs.ByteSlice = rs.byteSliceFrom(m4); _134.data[_134.start] = 0; - rt.iterExtendBytes(out, rt.iterSlice(copy2), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(m4), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(copy2), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(m4), undefined, true); } - rt.byteVecPush(out, shared.strong & 0xff); + rs.byteVecPush(out, shared.strong & 0xff); } - rt.byteVecPush(out, shared.strong & 0xff); + rs.byteVecPush(out, shared.strong & 0xff); shared[Symbol.dispose](); } @@ -103,28 +103,28 @@ export function needs$unit(): boolean { * `String`, held by hand, in an empty array, and of a closure by what it captures; what a * generic body that branches on it does, as std's collections do; and types' names. */ -export function needsDrops(data: rt.ByteSlice, out: rt.ByteVec): void { - const captured = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.char => { - return _2 as rt.char; +export function needsDrops(data: rs.ByteSlice, out: rs.ByteVec): void { + const captured = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + return _2 as rs.char; })); - const named: () => rt.usize = (): rt.usize => { - return rt.stringLen(captured); + const named: () => rs.usize = (): rs.usize => { + return rs.stringLen(captured); }; - const copied: () => rt.usize = (): rt.usize => { + const copied: () => rs.usize = (): rs.usize => { return data.length; }; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([false, false, true, false, false, false, true, true, true, true, true, true, false, true, true, false, true, false, false, true, false, false, false, true, true, false, needs$String(), needs$u8(), needs$manual_ByHand(), needs$unit(), needsDropOf$manual_needs_drops_closure1(named), needsDropOf$manual_needs_drops_closure2(copied)], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([false, false, true, false, false, false, true, true, true, true, true, true, false, true, true, false, true, false, false, true, false, false, false, true, true, false, needs$String(), needs$u8(), needs$manual_ByHand(), needs$unit(), needsDropOf$manual_needs_drops_closure1(named), needsDropOf$manual_needs_drops_closure2(copied)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, (named() & 0xff) ^ (copied() & 0xff)); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(droppedByHand$String(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b2: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b2, f)); + rs.byteVecPush(out, (named() & 0xff) ^ (copied() & 0xff)); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$String(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b2: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b2, f)); }), undefined, 12, true))).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(droppedByHand$u8(rt.byteSliceToByteVec(data))).reverse()), undefined, true); - const iter: rt.Iter = rt.iterSlice(["lang_manual_fixture::manual::ByHand", "core::option::Option<&[alloc::string::String]>", "lang_manual_fixture::manual::needs_drops::{{closure}}", "[u8]", nameOf$u8(), nameOf$String()]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(droppedByHand$u8(rs.byteSliceToByteVec(data))).reverse()), undefined, true); + const iter: rs.Iter = rs.iterSlice(["lang_manual_fixture::manual::ByHand", "core::option::Option<&[alloc::string::String]>", "lang_manual_fixture::manual::needs_drops::{{closure}}", "[u8]", nameOf$u8(), nameOf$String()]); while (true) { - const _73: string | rt.Done = iter.next(); - if (_73 === rt.DONE) { + const _73: string | rs.Done = iter.next(); + if (_73 === rs.DONE) { break; } put(out, _73); @@ -132,12 +132,12 @@ export function needsDrops(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Whether the value's type needs dropping. */ -export function needsDropOf$manual_needs_drops_closure1(_1: () => rt.usize): boolean { +export function needsDropOf$manual_needs_drops_closure1(_1: () => rs.usize): boolean { return true; } /** Whether the value's type needs dropping. */ -export function needsDropOf$manual_needs_drops_closure2(_1: () => rt.usize): boolean { +export function needsDropOf$manual_needs_drops_closure2(_1: () => rs.usize): boolean { return false; } @@ -155,13 +155,13 @@ export function nameOf$u8(): string { * How many items a generic body drops one by one, as std's collections do only of a type * that needs dropping, and forgets the rest. */ -export function droppedByHand$String(items: rt.Vec): rt.u32 { +export function droppedByHand$String(items: rs.Vec): rs.u32 { if (false) { return 0; } - let n: rt.u32 = 0; + let n: rs.u32 = 0; for (const _7 of items.items) { - n = rt.u32Add(n, 1); + n = rs.u32Add(n, 1); } return n; } @@ -170,13 +170,13 @@ export function droppedByHand$String(items: rt.Vec): rt.u32 { * How many items a generic body drops one by one, as std's collections do only of a type * that needs dropping, and forgets the rest. */ -export function droppedByHand$u8(items: rt.ByteVec): rt.u32 { +export function droppedByHand$u8(items: rs.ByteVec): rs.u32 { if (true) { return 0; } - let n: rt.u32 = 0; - for (const _7 of rt.byteVecView(items)) { - n = rt.u32Add(n, 1); + let n: rs.u32 = 0; + for (const _7 of rs.byteVecView(items)) { + n = rs.u32Add(n, 1); } return n; } diff --git a/ts/fixtures/lang/manual/expected/uninit.ts b/ts/fixtures/lang/manual/expected/uninit.ts index 1ac8f5e20..1aba7f0ae 100644 --- a/ts/fixtures/lang/manual/expected/uninit.ts +++ b/ts/fixtures/lang/manual/expected/uninit.ts @@ -1,95 +1,95 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { map$0cs071d as option_map$0cs071d } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { map$1yjmt5m as option_map$1yjmt5m } from "./core/option.ts"; /** * An array of bytes not yet written, a `Vec` of them, and an array of `u16`s, each * written from the input and read back. */ -export function uninits(data: rt.ByteSlice, out: rt.ByteVec): void { - const array: Uint8Array = rt.bytes(8).fill((0 as unknown) as rt.u8); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(array).length); - const dst = rt.byteSliceRange(rt.byteSliceFrom(array), 0, n); - rt.byteSliceCopyFromSlice(dst, rt.byteSliceRange(data, 0, n)); - rt.byteSliceView(dst).sort(); - const _17: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceRange(rt.byteSliceFrom(array), 0, n))); +export function uninits(data: rs.ByteSlice, out: rs.ByteVec): void { + const array: Uint8Array = rs.bytes(8).fill((0 as unknown) as rs.u8); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(array).length); + const dst = rs.byteSliceRange(rs.byteSliceFrom(array), 0, n); + rs.byteSliceCopyFromSlice(dst, rs.byteSliceRange(data, 0, n)); + rs.byteSliceView(dst).sort(); + const _17: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceRange(rs.byteSliceFrom(array), 0, n))); if (_17 !== undefined) { const uninit = _17; uninit.v = 238; uninit; } - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(rt.byteSliceFrom(array), 0, n)); - rt.byteSliceView(rt.byteSliceRange(rt.byteSliceFrom(array), 0, n)).reverse(); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(rt.byteSliceFrom(array), 0, n))), (b: rt.u8): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteSliceFrom(array), 0, n)); + rs.byteSliceView(rs.byteSliceRange(rs.byteSliceFrom(array), 0, n)).reverse(); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(rs.byteSliceFrom(array), 0, n))), (b: rs.u8): rs.u8 => { return b; }), undefined, true); - const vec: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { + const vec: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; }), undefined, true); - rt.byteVecPush(vec, 7); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(vec)))); + rs.byteVecPush(vec, 7); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(vec)))); while (true) { - const _52: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_52 === rt.DONE) { + const _52: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_52 === rs.DONE) { break; } - const i: rt.usize = _52[0]; - const _59: rt.u8 = _52[1].v; + const i: rs.usize = _52[0]; + const _59: rs.u8 = _52[1].v; const uninit2 = _52[1]; uninit2.v = _59 ^ (i & 0xff); uninit2; } - rt.byteVecTruncate(vec, rt.usizeAdd(rt.usizeDiv(vec.length, 2), 1)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(vec))), (b3: rt.u8): rt.u8 => { + rs.byteVecTruncate(vec, rs.usizeAdd(rs.usizeDiv(vec.length, 2), 1)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(vec))), (b3: rs.u8): rs.u8 => { return b3; }), undefined, true); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): rt.u16 => { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(c)), 0, (w: rt.u16, _311: rt.u8): rt.u16 => { - return ((w << 8) & 0xffff) | _311 as rt.u16; + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (c: rs.ByteSlice): rs.u16 => { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(c)), 0, (w: rs.u16, _311: rs.u8): rs.u16 => { + return ((w << 8) & 0xffff) | _311 as rs.u16; }); }), undefined, 2, true); - const _79: rt.u16 = (undefined as unknown) as rt.u16; - const words: rt.u16[] = Array.from({ length: 4 }, (): rt.u16 => { + const _79: rs.u16 = (undefined as unknown) as rs.u16; + const words: rs.u16[] = Array.from({ length: 4 }, (): rs.u16 => { return _79; }); - const k: rt.usize = rt.min(wide.items.length, words.length); - const dst2 = rt.sliceRangeMut(words, 0, k); - rt.sliceCopyFromSlice(dst2, rt.sliceRange(wide.items, 0, k)); - const _86: rt.Place | undefined = rt.sliceFirstMut(dst2); + const k: rs.usize = rs.min(wide.items.length, words.length); + const dst2 = rs.sliceRangeMut(words, 0, k); + rs.sliceCopyFromSlice(dst2, rs.sliceRange(wide.items, 0, k)); + const _86: rs.Place | undefined = rs.sliceFirstMut(dst2); if (_86 !== undefined) { _86.v = _86.v ^ 257; } - for (const _102 of rt.sliceRange(words, 0, k)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(_102).reverse())); + for (const _102 of rs.sliceRange(words, 0, k)) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(_102).reverse())); } - const fresh: Uint8Array = rt.bytes(2).fill((0 as unknown) as rt.u8); - const lone: rt.u8 | undefined = option_map$0cs071d(rt.byteSliceFirst(data), (_22: rt.u8): rt.u8 => { - return (0 as unknown) as rt.u8; + const fresh: Uint8Array = rs.bytes(2).fill((0 as unknown) as rs.u8); + const lone: rs.u8 | undefined = option_map$1yjmt5m(rs.byteSliceFirst(data), (_22: rs.u8): rs.u8 => { + return (0 as unknown) as rs.u8; }); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.byteSliceFirst(rt.byteSliceFrom(fresh)) !== undefined, rt.byteSliceGet(rt.byteSliceFrom(fresh), 2) === undefined, lone !== undefined], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.byteSliceFirst(rs.byteSliceFrom(fresh)) !== undefined, rs.byteSliceGet(rs.byteSliceFrom(fresh), 2) === undefined, lone !== undefined], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const nested: Uint8Array = rt.bytes(3).fill((0 as unknown) as rt.u8); - const k2: rt.usize = rt.min(data.length, rt.byteSliceFrom(nested).length); - const src: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, k2))), (_24: rt.u8): rt.u8 => { + const nested: Uint8Array = rs.bytes(3).fill((0 as unknown) as rs.u8); + const k2: rs.usize = rs.min(data.length, rs.byteSliceFrom(nested).length); + const src: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, k2))), (_24: rs.u8): rs.u8 => { return ~_24 & 0xff; }), undefined, true); - const dst3 = rt.byteSliceRange(rt.byteSliceFrom(nested), 0, k2); - rt.byteSliceCopyFromSlice(dst3, rt.byteVecSlice(src)); + const dst3 = rs.byteSliceRange(rs.byteSliceFrom(nested), 0, k2); + rs.byteSliceCopyFromSlice(dst3, rs.byteVecSlice(src)); dst3; - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(rt.byteSliceFrom(nested), 0, k2))), (b6: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(rs.byteSliceFrom(nested), 0, k2))), (b6: rs.u8): rs.u8 => { return b6; }), undefined, true); - const _155: rt.u8 | undefined = rt.byteSliceFirst(data); + const _155: rs.u8 | undefined = rs.byteSliceFirst(data); if (_155 !== undefined) { if (_155 === 254) { - const dst5 = rt.byteSliceRange(rt.byteSliceFrom(array), 0, 1); - rt.byteSliceCopyFromSlice(dst5, rt.byteSliceRange(data, 0, 0)); + const dst5 = rs.byteSliceRange(rs.byteSliceFrom(array), 0, 1); + rs.byteSliceCopyFromSlice(dst5, rs.byteSliceRange(data, 0, 0)); dst5; } else if (_155 === 255) { - const dst4 = rt.sliceRangeMut(words, 0, 1); - rt.sliceCopyFromSlice(dst4, rt.sliceRange(wide.items, 0, 0)); + const dst4 = rs.sliceRangeMut(words, 0, 1); + rs.sliceCopyFromSlice(dst4, rs.sliceRange(wide.items, 0, 0)); dst4; } } diff --git a/ts/fixtures/lang/methods/expected/core/option.ts b/ts/fixtures/lang/methods/expected/core/option.ts index f2d7fef3c..91ad6681d 100644 --- a/ts/fixtures/lang/methods/expected/core/option.ts +++ b/ts/fixtures/lang/methods/expected/core/option.ts @@ -1,92 +1,92 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$18pd8cy(self: rt.i128 | undefined, _: (a0: rt.i128) => rt.i128): rt.i128 | undefined { +export function map$1ocvprc(self: rs.i128 | undefined, _: (a0: rs.i128) => rs.i128): rs.i128 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$0b7sac9(self: rt.i16 | undefined, _: (a0: rt.i16) => rt.i16): rt.i16 | undefined { +export function map$0ip7buw(self: rs.i16 | undefined, _: (a0: rs.i16) => rs.i16): rs.i16 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$0x0f126(self: rt.i32 | undefined, _: (a0: rt.i32) => rt.i32): rt.i32 | undefined { +export function map$0a35how(self: rs.i32 | undefined, _: (a0: rs.i32) => rs.i32): rs.i32 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$02fxff7(self: rt.i64 | undefined, _: (a0: rt.i64) => rt.i64): rt.i64 | undefined { +export function map$05k3lfb(self: rs.i64 | undefined, _: (a0: rs.i64) => rs.i64): rs.i64 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$1u19ipa(self: rt.i8 | undefined, _: (a0: rt.i8) => rt.i8): rt.i8 | undefined { +export function map$1hwn965(self: rs.i8 | undefined, _: (a0: rs.i8) => rs.i8): rs.i8 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$1rlqf9d(self: rt.isize | undefined, _: (a0: rt.isize) => rt.isize): rt.isize | undefined { +export function map$1vj7z9f(self: rs.isize | undefined, _: (a0: rs.isize) => rs.isize): rs.isize | undefined { if (self === undefined) { return undefined; } return self; } -export function map$1fszu7p(self: rt.u128 | undefined, _: (a0: rt.u128) => rt.u128): rt.u128 | undefined { +export function map$1x2mrlk(self: rs.u128 | undefined, _: (a0: rs.u128) => rs.u128): rs.u128 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$12xrbxt(self: rt.u16 | undefined, _: (a0: rt.u16) => rt.u16): rt.u16 | undefined { +export function map$0frntt5(self: rs.u16 | undefined, _: (a0: rs.u16) => rs.u16): rs.u16 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$0xz4pvf(self: rt.u32 | undefined, _: (a0: rt.u32) => rt.u32): rt.u32 | undefined { +export function map$03qwbb9(self: rs.u32 | undefined, _: (a0: rs.u32) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$1rxjg4m(self: rt.u64 | undefined, _: (a0: rt.u64) => rt.u64): rt.u64 | undefined { +export function map$0fest7b(self: rs.u64 | undefined, _: (a0: rs.u64) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$03bv7br(self: rt.u8 | undefined, _: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1far4bd(self: rs.u8 | undefined, _: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return self; } -export function map$08v2q5m(self: rt.usize | undefined, _: (a0: rt.usize) => rt.usize): rt.usize | undefined { +export function map$07b2cw7(self: rs.usize | undefined, _: (a0: rs.usize) => rs.usize): rs.usize | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/methods/expected/harness.ts b/ts/fixtures/lang/methods/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/methods/expected/harness.ts +++ b/ts/fixtures/lang/methods/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/methods/expected/lib.ts b/ts/fixtures/lang/methods/expected/lib.ts index fb259d965..aad314ee3 100644 --- a/ts/fixtures/lang/methods/expected/lib.ts +++ b/ts/fixtures/lang/methods/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { u8s, u16s, u32s, u64s, u128s, usizes, i8s, i16s, i32s, i64s, i128s, isizes } from "./methods.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["methods::u8s", u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u16s", u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u32s", u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u64s", u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::u128s", u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::usizes", usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i8s", i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i16s", i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i32s", i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i64s", i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::i128s", i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["methods::isizes", isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["methods::u8s", u8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::u16s", u16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::u32s", u32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::u64s", u64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::u128s", u128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::usizes", usizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::i8s", i8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::i16s", i16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::i32s", i32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::i64s", i64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::i128s", i128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["methods::isizes", isizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/methods/expected/methods.ts b/ts/fixtures/lang/methods/expected/methods.ts index cc0b67850..2bcf50acc 100644 --- a/ts/fixtures/lang/methods/expected/methods.ts +++ b/ts/fixtures/lang/methods/expected/methods.ts @@ -1,5133 +1,5133 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$18pd8cy as option_map$18pd8cy, map$0b7sac9 as option_map$0b7sac9, map$0x0f126 as option_map$0x0f126, map$02fxff7 as option_map$02fxff7, map$1u19ipa as option_map$1u19ipa, map$1rlqf9d as option_map$1rlqf9d, map$1fszu7p as option_map$1fszu7p, map$12xrbxt as option_map$12xrbxt, map$0xz4pvf as option_map$0xz4pvf, map$1rxjg4m as option_map$1rxjg4m, map$03bv7br as option_map$03bv7br, map$08v2q5m as option_map$08v2q5m } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1ocvprc as option_map$1ocvprc, map$0ip7buw as option_map$0ip7buw, map$0a35how as option_map$0a35how, map$05k3lfb as option_map$05k3lfb, map$1hwn965 as option_map$1hwn965, map$1vj7z9f as option_map$1vj7z9f, map$1x2mrlk as option_map$1x2mrlk, map$0frntt5 as option_map$0frntt5, map$03qwbb9 as option_map$03qwbb9, map$0fest7b as option_map$0fest7b, map$1far4bd as option_map$1far4bd, map$07b2cw7 as option_map$07b2cw7 } from "./core/option.ts"; /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v4: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v4))); - rt.byteVecPush(out2, rt.u8FromBeBytes(rt.u8ToBeBytes(v4)) === v4 ? 1 : 0); +export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v4: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u8FromBeBytes(rs.u8ToBeBytes(v4)) === v4 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.u8 = rt.u8FromBeBytes(rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { + const a: rs.u8 = rs.u8FromBeBytes(rs.bytesFromFn(1, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.u8 = rt.u8FromBeBytes(rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(1, i3)); + const b: rs.u8 = rs.u8FromBeBytes(rs.bytesFromFn(1, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(1, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 1, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 1, i4)); })); - const o: rt.i8 = (b << 24) >> 24; - const k: rt.u32 = rt.u32Rem(n, 3 * 8); - const putOpt: (a0: rt.ByteVec, a1: rt.u8 | undefined) => undefined = (out4: rt.ByteVec, v6: rt.u8 | undefined): undefined => { + const o: rs.i8 = (b << 24) >> 24; + const k: rs.u32 = rs.u32Rem(n, 3 * 8); + const putOpt: (a0: rs.ByteVec, a1: rs.u8 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u8 | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.u8 = v6; - rt.byteVecPush(out4, 1); + const v7: rs.u8 = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.u8, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.u8, boolean]): undefined => { - const v8: rt.u8 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u8, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u8, boolean]): undefined => { + const v8: rs.u8 = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.u8CheckedAdd(a, b); + const part82 = rs.u8CheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.u8CheckedSub(a, b); + const part83 = rs.u8CheckedSub(a, b); putOpt(out, part83); - const part84 = rt.u8CheckedMul(a, b); + const part84 = rs.u8CheckedMul(a, b); putOpt(out, part84); - const part85 = rt.u8SaturatingAdd(a, b); + const part85 = rs.u8SaturatingAdd(a, b); _22(out, part85); - const part86 = rt.u8SaturatingSub(a, b); + const part86 = rs.u8SaturatingSub(a, b); _22(out, part86); - const part87 = rt.u8SaturatingMul(a, b); + const part87 = rs.u8SaturatingMul(a, b); _22(out, part87); - const part88 = rt.u8WrappingAdd(a, b); + const part88 = rs.u8WrappingAdd(a, b); _22(out, part88); - const part89 = rt.u8WrappingSub(a, b); + const part89 = rs.u8WrappingSub(a, b); _22(out, part89); - const part90 = rt.u8WrappingMul(a, b); + const part90 = rs.u8WrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 8, false); + const part91 = rs.intOverflowingAdd(a, b, 8, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 8, false); + const part92 = rs.intOverflowingSub(a, b, 8, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 8, false); + const part93 = rs.intOverflowingMul(a, b, 8, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 8, false); + const part94 = rs.intMidpoint(a, b, 8, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 8, false); + const part95 = rs.intCheckedAdd(a, o, 8, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 8, false); + const part96 = rs.intCheckedSub(a, o, 8, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 8, false); + const part97 = rs.intSaturatingAdd(a, o, 8, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 8, false); + const part98 = rs.intSaturatingSub(a, o, 8, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 8, false); + const part99 = rs.intWrappingAdd(a, o, 8, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 8, false); + const part100 = rs.intWrappingSub(a, o, 8, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 8, false); + const part101 = rs.intOverflowingAdd(a, o, 8, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 8, false); + const part102 = rs.intOverflowingSub(a, o, 8, false); putPair(out, part102); - const b2: rt.u8 = o & 0xff; - const _118: rt.i8 | undefined = rt.intCheckedSignedDiff(a, b2, 8, false) as rt.i8 | undefined; + const b2: rs.u8 = o & 0xff; + const _118: rs.i8 | undefined = rs.intCheckedSignedDiff(a, b2, 8, false) as rs.i8 | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 8, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 8, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 8, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 8, false); putPair(out, part104); } - const _141: [rt.u8, rt.u8] = rt.intCarryingMul(a, b2, a, 8, false); - const lo: rt.u8 = _141[0]; - const hi: rt.u8 = _141[1]; + const _141: [rs.u8, rs.u8] = rs.intCarryingMul(a, b2, a, 8, false); + const lo: rs.u8 = _141[0]; + const hi: rs.u8 = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.u8, rt.u8] = rt.intCarryingMulAdd(a, b2, b2, a, 8, false); - const lo2: rt.u8 = _150[0]; - const hi2: rt.u8 = _150[1]; + const _150: [rs.u8, rs.u8] = rs.intCarryingMulAdd(a, b2, b2, a, 8, false); + const lo2: rs.u8 = _150[0]; + const hi2: rs.u8 = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 8, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 8, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 8, false); + const part77 = rs.intCheckedDiv(a, b, 8, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 8, false); + const part78 = rs.intCheckedRem(a, b, 8, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 8, false); + const part79 = rs.intCheckedDivEuclid(a, b, 8, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 8, false); + const part80 = rs.intCheckedRemEuclid(a, b, 8, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.u8DivCeil(a, b); + const part81 = rs.u8DivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.u8IsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u8IsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 8, false); + const part72 = rs.intCheckedNeg(a, 8, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 8, false); + const part73 = rs.intWrappingNeg(a, 8, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 8, false); + const part74 = rs.intOverflowingNeg(a, 8, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 8, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 8, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 8, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 8, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 8, false); + const part76 = rs.intBitWidth(a, 8, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((a << 24) >> 24))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes((a << 24) >> 24))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 8, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 8, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 8, false); + const part69 = rs.intWrappingPow(a, e, 8, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 8, false); + const part70 = rs.intSaturatingPow(a, e, 8, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 8, false); + const part71 = rs.intOverflowingPow(a, e, 8, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 8, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 8, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 8, false); + const part59 = rs.intCheckedShr(a, s, 8, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 8, false); + const part60 = rs.intWrappingShl(a, s, 8, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 8, false); + const part61 = rs.intWrappingShr(a, s, 8, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 8, false); + const part62 = rs.intOverflowingShl(a, s, 8, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 8, false); + const part63 = rs.intOverflowingShr(a, s, 8, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 8, false); + const part64 = rs.intUnboundedShl(a, s, 8, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 8, false); + const part65 = rs.intUnboundedShr(a, s, 8, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 8, false); + const part66 = rs.intRotateLeft(a, s, 8, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 8, false); + const part67 = rs.intRotateRight(a, s, 8, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 8, false), rt.intCountZeros(a, 8, false), rt.u8LeadingZeros(a), rt.u8TrailingZeros(a), rt.u8LeadingOnes(a), rt.intTrailingOnes(a, 8, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 8, false), rs.intCountZeros(a, 8, false), rs.u8LeadingZeros(a), rs.u8TrailingZeros(a), rs.u8LeadingOnes(a), rs.intTrailingOnes(a, 8, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice(Uint8Array.of(rt.intSwapBytes(a, 8, false), rt.intReverseBits(a, 8, false), rt.intSwapBytes(a, 8, false), a, rt.intSwapBytes(a, 8, false), a)); + const iter5: rs.Iter = rs.iterSlice(Uint8Array.of(rs.intSwapBytes(a, 8, false), rs.intReverseBits(a, 8, false), rs.intSwapBytes(a, 8, false), a, rs.intSwapBytes(a, 8, false), a)); while (true) { - const _308: rt.u8 | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.u8 | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 8, false); + const part54 = rs.intHighestOne(a, 8, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 8, false); + const part55 = rs.intLowestOne(a, 8, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 8, false); + const part56 = rs.intIsolateHighestOne(a, 8, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 8, false); + const part57 = rs.intIsolateLowestOne(a, 8, false); _22(out, part57); _22(out, 255); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 8, false); + const part51 = rs.intCheckedIlog(a, b, 8, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 8, false); + const part52 = rs.intCheckedIlog2(a, 8, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 8, false); + const part53 = rs.intCheckedIlog10(a, 8, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.intAbsDiff(a, b, 8, false) as rt.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.intAbsDiff(a, b, 8, false) as rs.u8))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 8, false); + const part50 = rs.intPow(a, k, 8, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 8, false); + const part49 = rs.intPow(a, n, 8, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 8, false); + const part48 = rs.intDivEuclid(a, b, 8, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 8, false); + const part47 = rs.intRemEuclid(a, b, 8, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 8, false); + const part46 = rs.intIsqrt(a, 8, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 8, false); + const part45 = rs.intIlog(a, b, 8, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 8, false); + const part44 = rs.intIlog2(a, 8, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 8, false); + const part43 = rs.intIlog10(a, 8, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.u8Add(a, b)); + _22(out, rs.u8Add(a, b)); } else if (_30 === 16) { - _22(out, rt.u8Sub(a, b)); + _22(out, rs.u8Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.u8Mul(a, b)); + _22(out, rs.u8Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.u8Div(a, b)); + _22(out, rs.u8Div(a, b)); } else if (_30 === 19) { - _22(out, rt.u8Rem(a, b)); + _22(out, rs.u8Rem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 8, false); + const part37 = rs.intStrictNeg(a, 8, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.u8Shl(a, k)); + _22(out, rs.u8Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.u8Shr(a, k)); + _22(out, rs.u8Shr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 8, false); + const part34 = rs.intPow(a, k, 8, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 8, false); + const part33 = rs.intDivEuclid(a, b, 8, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 8, false); + const part32 = rs.intRemEuclid(a, b, 8, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 8, false); + const part31 = rs.intStrictAdd(a, o, 8, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 8, false); + const part30 = rs.intStrictSub(a, o, 8, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.u8Div(a, b)); + _22(out, rs.u8Div(a, b)); } else if (_30 === 29) { - _22(out, rt.u8Rem(a, b)); + _22(out, rs.u8Rem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 8, false); + const part27 = rs.intWrappingDivEuclid(a, b, 8, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 8, false); + const part26 = rs.intWrappingRemEuclid(a, b, 8, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 8, false); + const part25 = rs.intOverflowingDiv(a, b, 8, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 8, false); + const part24 = rs.intOverflowingRem(a, b, 8, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 8, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 8, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 8, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 8, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.u8Div(a, b)); + _22(out, rs.u8Div(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 8, false); + const part20 = rs.intNextPowerOfTwo(a, 8, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 8, false); + const part19 = rs.intNextMultipleOf(a, b, 8, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 8, false); + const part18 = rs.intFunnelShl(a, b, k, 8, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 8, false); + const part17 = rs.intFunnelShr(a, b, k, 8, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.u8 = a; - const w: rt.u8 = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 8, false), rt.intCountZeros(s2, 8, false), rt.u8LeadingZeros(s2), rt.u8TrailingZeros(s2)]); + const s2: rs.u8 = a; + const w: rs.u8 = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 8, false), rs.intCountZeros(s2, 8, false), rs.u8LeadingZeros(s2), rs.u8TrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 8, false), rt.intCountZeros(w, 8, false), rt.u8LeadingZeros(w), rt.u8TrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 8, false), rs.intCountZeros(w, 8, false), rs.u8LeadingZeros(w), rs.u8TrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 8, false), rt.intRotateRight(s2, n, 8, false), rt.intSwapBytes(s2, 8, false), rt.intReverseBits(s2, 8, false), rt.intSwapBytes(s2, 8, false), s2, rt.intSwapBytes(s2, 8, false), s2, rt.intSaturatingPow(s2, k, 8, false), rt.intSaturatingPow(s2, n, 8, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 8, false), rs.intRotateRight(s2, n, 8, false), rs.intSwapBytes(s2, 8, false), rs.intReverseBits(s2, 8, false), rs.intSwapBytes(s2, 8, false), s2, rs.intSwapBytes(s2, 8, false), s2, rs.intSaturatingPow(s2, k, 8, false), rs.intSaturatingPow(s2, n, 8, false)]); while (true) { - const _506: rt.u8 | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.u8 | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 8, false), rt.intRotateRight(w, n, 8, false), rt.intSwapBytes(w, 8, false), rt.intReverseBits(w, 8, false), rt.intSwapBytes(w, 8, false), w, rt.intSwapBytes(w, 8, false), w, rt.intWrappingPow(w, k, 8, false), rt.intWrappingPow(w, n, 8, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 8, false), rs.intRotateRight(w, n, 8, false), rs.intSwapBytes(w, 8, false), rs.intReverseBits(w, 8, false), rs.intSwapBytes(w, 8, false), w, rs.intSwapBytes(w, 8, false), w, rs.intWrappingPow(w, k, 8, false), rs.intWrappingPow(w, n, 8, false)]); while (true) { - const _527: rt.u8 | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.u8 | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 8, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 8, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 8, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 8, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 8, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 8, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.u8 | undefined, rt.u8 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.u8 | undefined, rs.u8 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.u8 = _548[0]; - const y: rt.u8 = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.u8LeadingZeros(x), rt.u8TrailingZeros(x), rt.intCountOnes(x, 8, false), 7 - rt.u8LeadingZeros(x), rt.u8TrailingZeros(x)]); + const x: rs.u8 = _548[0]; + const y: rs.u8 = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.u8LeadingZeros(x), rs.u8TrailingZeros(x), rs.intCountOnes(x, 8, false), 7 - rs.u8LeadingZeros(x), rs.u8TrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$03bv7br(rt.u8CheckedMul(x, y), (a0: rt.u8): rt.u8 => { + const part3 = option_map$1far4bd(rs.u8CheckedMul(x, y), (a0: rs.u8): rs.u8 => { return a0; }); putOpt(out, part3); - const part4 = rt.u8SaturatingMul(x, y); + const part4 = rs.u8SaturatingMul(x, y); _22(out, part4); - const part5 = option_map$03bv7br(rt.intCheckedPow(x, k, 8, false), (a02: rt.u8): rt.u8 => { + const part5 = option_map$1far4bd(rs.intCheckedPow(x, k, 8, false), (a02: rs.u8): rs.u8 => { return a02; }); putOpt(out, part5); - const part6 = option_map$03bv7br(rt.intCheckedPow(x, n, 8, false), (a03: rt.u8): rt.u8 => { + const part6 = option_map$1far4bd(rs.intCheckedPow(x, n, 8, false), (a03: rs.u8): rs.u8 => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 8, false); + const part7 = rs.intSaturatingPow(x, k, 8, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 8, false); + const part8 = rs.intIsolateHighestOne(x, 8, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 8, false); + const part9 = rs.intIsolateLowestOne(x, 8, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 8, false) ? 1 : 0); - const part10 = option_map$03bv7br(rt.u8CheckedAdd(x, b), (a04: rt.u8): rt.u8 => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 8, false) ? 1 : 0); + const part10 = option_map$1far4bd(rs.u8CheckedAdd(x, b), (a04: rs.u8): rs.u8 => { return a04; }); putOpt(out, part10); - const part11 = rt.u8SaturatingAdd(x, b); + const part11 = rs.u8SaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$03bv7br(rt.intCheckedNextPowerOfTwo(x, 8, false), (a05: rt.u8): rt.u8 => { + const part12 = option_map$1far4bd(rs.intCheckedNextPowerOfTwo(x, 8, false), (a05: rs.u8): rs.u8 => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 8, false), rt.intIlog10(x, 8, false), rt.intBitWidth(x, 8, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 8, false), rs.intIlog10(x, 8, false), rs.intBitWidth(x, 8, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 8, false); + const part13 = rs.intMidpoint(x, y, 8, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 8, false); + const part14 = rs.intIsqrt(x, 8, false); _22(out, part14); - const part15 = rt.u8DivCeil(x, y); + const part15 = rs.u8DivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes((x << 24) >> 24))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes((x << 24) >> 24))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v4: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v4))); - rt.byteVecPush(out2, rt.u16FromBeBytes(rt.u16ToBeBytes(v4)) === v4 ? 1 : 0); +export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v4: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u16FromBeBytes(rs.u16ToBeBytes(v4)) === v4 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.u16 = rt.u16FromBeBytes(rt.bytesFromFn(2, (i2: rt.usize): rt.u8 => { + const a: rs.u16 = rs.u16FromBeBytes(rs.bytesFromFn(2, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.u16 = rt.u16FromBeBytes(rt.bytesFromFn(2, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2, i3)); + const b: rs.u16 = rs.u16FromBeBytes(rs.bytesFromFn(2, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 2, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 2, i4)); })); - const o: rt.i16 = (b << 16) >> 16; - const k: rt.u32 = rt.u32Rem(n, 3 * 16); - const putOpt: (a0: rt.ByteVec, a1: rt.u16 | undefined) => undefined = (out4: rt.ByteVec, v6: rt.u16 | undefined): undefined => { + const o: rs.i16 = (b << 16) >> 16; + const k: rs.u32 = rs.u32Rem(n, 3 * 16); + const putOpt: (a0: rs.ByteVec, a1: rs.u16 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u16 | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.u16 = v6; - rt.byteVecPush(out4, 1); + const v7: rs.u16 = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.u16, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.u16, boolean]): undefined => { - const v8: rt.u16 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u16, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u16, boolean]): undefined => { + const v8: rs.u16 = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.u16CheckedAdd(a, b); + const part82 = rs.u16CheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.u16CheckedSub(a, b); + const part83 = rs.u16CheckedSub(a, b); putOpt(out, part83); - const part84 = rt.u16CheckedMul(a, b); + const part84 = rs.u16CheckedMul(a, b); putOpt(out, part84); - const part85 = rt.u16SaturatingAdd(a, b); + const part85 = rs.u16SaturatingAdd(a, b); _22(out, part85); - const part86 = rt.u16SaturatingSub(a, b); + const part86 = rs.u16SaturatingSub(a, b); _22(out, part86); - const part87 = rt.u16SaturatingMul(a, b); + const part87 = rs.u16SaturatingMul(a, b); _22(out, part87); - const part88 = rt.u16WrappingAdd(a, b); + const part88 = rs.u16WrappingAdd(a, b); _22(out, part88); - const part89 = rt.u16WrappingSub(a, b); + const part89 = rs.u16WrappingSub(a, b); _22(out, part89); - const part90 = rt.u16WrappingMul(a, b); + const part90 = rs.u16WrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 16, false); + const part91 = rs.intOverflowingAdd(a, b, 16, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 16, false); + const part92 = rs.intOverflowingSub(a, b, 16, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 16, false); + const part93 = rs.intOverflowingMul(a, b, 16, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 16, false); + const part94 = rs.intMidpoint(a, b, 16, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 16, false); + const part95 = rs.intCheckedAdd(a, o, 16, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 16, false); + const part96 = rs.intCheckedSub(a, o, 16, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 16, false); + const part97 = rs.intSaturatingAdd(a, o, 16, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 16, false); + const part98 = rs.intSaturatingSub(a, o, 16, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 16, false); + const part99 = rs.intWrappingAdd(a, o, 16, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 16, false); + const part100 = rs.intWrappingSub(a, o, 16, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 16, false); + const part101 = rs.intOverflowingAdd(a, o, 16, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 16, false); + const part102 = rs.intOverflowingSub(a, o, 16, false); putPair(out, part102); - const b2: rt.u16 = o & 0xffff; - const _118: rt.i16 | undefined = rt.intCheckedSignedDiff(a, b2, 16, false) as rt.i16 | undefined; + const b2: rs.u16 = o & 0xffff; + const _118: rs.i16 | undefined = rs.intCheckedSignedDiff(a, b2, 16, false) as rs.i16 | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 16, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 16, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 16, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 16, false); putPair(out, part104); } - const _141: [rt.u16, rt.u16] = rt.intCarryingMul(a, b2, a, 16, false); - const lo: rt.u16 = _141[0]; - const hi: rt.u16 = _141[1]; + const _141: [rs.u16, rs.u16] = rs.intCarryingMul(a, b2, a, 16, false); + const lo: rs.u16 = _141[0]; + const hi: rs.u16 = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.u16, rt.u16] = rt.intCarryingMulAdd(a, b2, b2, a, 16, false); - const lo2: rt.u16 = _150[0]; - const hi2: rt.u16 = _150[1]; + const _150: [rs.u16, rs.u16] = rs.intCarryingMulAdd(a, b2, b2, a, 16, false); + const lo2: rs.u16 = _150[0]; + const hi2: rs.u16 = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 16, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 16, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 16, false); + const part77 = rs.intCheckedDiv(a, b, 16, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 16, false); + const part78 = rs.intCheckedRem(a, b, 16, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 16, false); + const part79 = rs.intCheckedDivEuclid(a, b, 16, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 16, false); + const part80 = rs.intCheckedRemEuclid(a, b, 16, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.u16DivCeil(a, b); + const part81 = rs.u16DivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.u16IsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u16IsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 16, false); + const part72 = rs.intCheckedNeg(a, 16, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 16, false); + const part73 = rs.intWrappingNeg(a, 16, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 16, false); + const part74 = rs.intOverflowingNeg(a, 16, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 16, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 16, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 16, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 16, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 16, false); + const part76 = rs.intBitWidth(a, 16, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((a << 16) >> 16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((a << 16) >> 16))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 16, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 16, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 16, false); + const part69 = rs.intWrappingPow(a, e, 16, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 16, false); + const part70 = rs.intSaturatingPow(a, e, 16, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 16, false); + const part71 = rs.intOverflowingPow(a, e, 16, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 16, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 16, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 16, false); + const part59 = rs.intCheckedShr(a, s, 16, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 16, false); + const part60 = rs.intWrappingShl(a, s, 16, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 16, false); + const part61 = rs.intWrappingShr(a, s, 16, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 16, false); + const part62 = rs.intOverflowingShl(a, s, 16, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 16, false); + const part63 = rs.intOverflowingShr(a, s, 16, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 16, false); + const part64 = rs.intUnboundedShl(a, s, 16, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 16, false); + const part65 = rs.intUnboundedShr(a, s, 16, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 16, false); + const part66 = rs.intRotateLeft(a, s, 16, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 16, false); + const part67 = rs.intRotateRight(a, s, 16, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 16, false), rt.intCountZeros(a, 16, false), rt.u16LeadingZeros(a), rt.u16TrailingZeros(a), rt.u16LeadingOnes(a), rt.intTrailingOnes(a, 16, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 16, false), rs.intCountZeros(a, 16, false), rs.u16LeadingZeros(a), rs.u16TrailingZeros(a), rs.u16LeadingOnes(a), rs.intTrailingOnes(a, 16, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 16, false), rt.intReverseBits(a, 16, false), rt.intSwapBytes(a, 16, false), a, rt.intSwapBytes(a, 16, false), a]); + const iter5: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 16, false), rs.intReverseBits(a, 16, false), rs.intSwapBytes(a, 16, false), a, rs.intSwapBytes(a, 16, false), a]); while (true) { - const _308: rt.u16 | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.u16 | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 16, false); + const part54 = rs.intHighestOne(a, 16, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 16, false); + const part55 = rs.intLowestOne(a, 16, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 16, false); + const part56 = rs.intIsolateHighestOne(a, 16, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 16, false); + const part57 = rs.intIsolateLowestOne(a, 16, false); _22(out, part57); _22(out, 65535); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 16, false); + const part51 = rs.intCheckedIlog(a, b, 16, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 16, false); + const part52 = rs.intCheckedIlog2(a, 16, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 16, false); + const part53 = rs.intCheckedIlog10(a, 16, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.intAbsDiff(a, b, 16, false) as rt.u16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.intAbsDiff(a, b, 16, false) as rs.u16))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 16, false); + const part50 = rs.intPow(a, k, 16, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 16, false); + const part49 = rs.intPow(a, n, 16, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 16, false); + const part48 = rs.intDivEuclid(a, b, 16, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 16, false); + const part47 = rs.intRemEuclid(a, b, 16, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 16, false); + const part46 = rs.intIsqrt(a, 16, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 16, false); + const part45 = rs.intIlog(a, b, 16, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 16, false); + const part44 = rs.intIlog2(a, 16, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 16, false); + const part43 = rs.intIlog10(a, 16, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.u16Add(a, b)); + _22(out, rs.u16Add(a, b)); } else if (_30 === 16) { - _22(out, rt.u16Sub(a, b)); + _22(out, rs.u16Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.u16Mul(a, b)); + _22(out, rs.u16Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.u16Div(a, b)); + _22(out, rs.u16Div(a, b)); } else if (_30 === 19) { - _22(out, rt.u16Rem(a, b)); + _22(out, rs.u16Rem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 16, false); + const part37 = rs.intStrictNeg(a, 16, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.u16Shl(a, k)); + _22(out, rs.u16Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.u16Shr(a, k)); + _22(out, rs.u16Shr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 16, false); + const part34 = rs.intPow(a, k, 16, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 16, false); + const part33 = rs.intDivEuclid(a, b, 16, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 16, false); + const part32 = rs.intRemEuclid(a, b, 16, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 16, false); + const part31 = rs.intStrictAdd(a, o, 16, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 16, false); + const part30 = rs.intStrictSub(a, o, 16, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.u16Div(a, b)); + _22(out, rs.u16Div(a, b)); } else if (_30 === 29) { - _22(out, rt.u16Rem(a, b)); + _22(out, rs.u16Rem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 16, false); + const part27 = rs.intWrappingDivEuclid(a, b, 16, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 16, false); + const part26 = rs.intWrappingRemEuclid(a, b, 16, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 16, false); + const part25 = rs.intOverflowingDiv(a, b, 16, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 16, false); + const part24 = rs.intOverflowingRem(a, b, 16, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 16, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 16, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 16, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 16, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.u16Div(a, b)); + _22(out, rs.u16Div(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 16, false); + const part20 = rs.intNextPowerOfTwo(a, 16, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 16, false); + const part19 = rs.intNextMultipleOf(a, b, 16, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 16, false); + const part18 = rs.intFunnelShl(a, b, k, 16, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 16, false); + const part17 = rs.intFunnelShr(a, b, k, 16, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.u16 = a; - const w: rt.u16 = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 16, false), rt.intCountZeros(s2, 16, false), rt.u16LeadingZeros(s2), rt.u16TrailingZeros(s2)]); + const s2: rs.u16 = a; + const w: rs.u16 = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 16, false), rs.intCountZeros(s2, 16, false), rs.u16LeadingZeros(s2), rs.u16TrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 16, false), rt.intCountZeros(w, 16, false), rt.u16LeadingZeros(w), rt.u16TrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 16, false), rs.intCountZeros(w, 16, false), rs.u16LeadingZeros(w), rs.u16TrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 16, false), rt.intRotateRight(s2, n, 16, false), rt.intSwapBytes(s2, 16, false), rt.intReverseBits(s2, 16, false), rt.intSwapBytes(s2, 16, false), s2, rt.intSwapBytes(s2, 16, false), s2, rt.intSaturatingPow(s2, k, 16, false), rt.intSaturatingPow(s2, n, 16, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 16, false), rs.intRotateRight(s2, n, 16, false), rs.intSwapBytes(s2, 16, false), rs.intReverseBits(s2, 16, false), rs.intSwapBytes(s2, 16, false), s2, rs.intSwapBytes(s2, 16, false), s2, rs.intSaturatingPow(s2, k, 16, false), rs.intSaturatingPow(s2, n, 16, false)]); while (true) { - const _506: rt.u16 | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.u16 | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 16, false), rt.intRotateRight(w, n, 16, false), rt.intSwapBytes(w, 16, false), rt.intReverseBits(w, 16, false), rt.intSwapBytes(w, 16, false), w, rt.intSwapBytes(w, 16, false), w, rt.intWrappingPow(w, k, 16, false), rt.intWrappingPow(w, n, 16, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 16, false), rs.intRotateRight(w, n, 16, false), rs.intSwapBytes(w, 16, false), rs.intReverseBits(w, 16, false), rs.intSwapBytes(w, 16, false), w, rs.intSwapBytes(w, 16, false), w, rs.intWrappingPow(w, k, 16, false), rs.intWrappingPow(w, n, 16, false)]); while (true) { - const _527: rt.u16 | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.u16 | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 16, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 16, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 16, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 16, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 16, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 16, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.u16 | undefined, rt.u16 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.u16 | undefined, rs.u16 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.u16 = _548[0]; - const y: rt.u16 = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.u16LeadingZeros(x), rt.u16TrailingZeros(x), rt.intCountOnes(x, 16, false), 15 - rt.u16LeadingZeros(x), rt.u16TrailingZeros(x)]); + const x: rs.u16 = _548[0]; + const y: rs.u16 = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.u16LeadingZeros(x), rs.u16TrailingZeros(x), rs.intCountOnes(x, 16, false), 15 - rs.u16LeadingZeros(x), rs.u16TrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$12xrbxt(rt.u16CheckedMul(x, y), (a0: rt.u16): rt.u16 => { + const part3 = option_map$0frntt5(rs.u16CheckedMul(x, y), (a0: rs.u16): rs.u16 => { return a0; }); putOpt(out, part3); - const part4 = rt.u16SaturatingMul(x, y); + const part4 = rs.u16SaturatingMul(x, y); _22(out, part4); - const part5 = option_map$12xrbxt(rt.intCheckedPow(x, k, 16, false), (a02: rt.u16): rt.u16 => { + const part5 = option_map$0frntt5(rs.intCheckedPow(x, k, 16, false), (a02: rs.u16): rs.u16 => { return a02; }); putOpt(out, part5); - const part6 = option_map$12xrbxt(rt.intCheckedPow(x, n, 16, false), (a03: rt.u16): rt.u16 => { + const part6 = option_map$0frntt5(rs.intCheckedPow(x, n, 16, false), (a03: rs.u16): rs.u16 => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 16, false); + const part7 = rs.intSaturatingPow(x, k, 16, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 16, false); + const part8 = rs.intIsolateHighestOne(x, 16, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 16, false); + const part9 = rs.intIsolateLowestOne(x, 16, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 16, false) ? 1 : 0); - const part10 = option_map$12xrbxt(rt.u16CheckedAdd(x, b), (a04: rt.u16): rt.u16 => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 16, false) ? 1 : 0); + const part10 = option_map$0frntt5(rs.u16CheckedAdd(x, b), (a04: rs.u16): rs.u16 => { return a04; }); putOpt(out, part10); - const part11 = rt.u16SaturatingAdd(x, b); + const part11 = rs.u16SaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$12xrbxt(rt.intCheckedNextPowerOfTwo(x, 16, false), (a05: rt.u16): rt.u16 => { + const part12 = option_map$0frntt5(rs.intCheckedNextPowerOfTwo(x, 16, false), (a05: rs.u16): rs.u16 => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 16, false), rt.intIlog10(x, 16, false), rt.intBitWidth(x, 16, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 16, false), rs.intIlog10(x, 16, false), rs.intBitWidth(x, 16, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 16, false); + const part13 = rs.intMidpoint(x, y, 16, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 16, false); + const part14 = rs.intIsqrt(x, 16, false); _22(out, part14); - const part15 = rt.u16DivCeil(x, y); + const part15 = rs.u16DivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes((x << 16) >> 16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes((x << 16) >> 16))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v4: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v4))); - rt.byteVecPush(out2, rt.u32FromBeBytes(rt.u32ToBeBytes(v4)) === v4 ? 1 : 0); +export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v4: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u32FromBeBytes(rs.u32ToBeBytes(v4)) === v4 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { + const a: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(4, i3)); + const b: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(4, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 4, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 4, i4)); })); - const o: rt.i32 = b | 0; - const k: rt.u32 = rt.u32Rem(n, 3 * 32); - const putOpt: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out4: rt.ByteVec, v6: rt.u32 | undefined): undefined => { + const o: rs.i32 = b | 0; + const k: rs.u32 = rs.u32Rem(n, 3 * 32); + const putOpt: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u32 | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.u32 = v6; - rt.byteVecPush(out4, 1); + const v7: rs.u32 = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.u32, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.u32, boolean]): undefined => { - const v8: rt.u32 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u32, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u32, boolean]): undefined => { + const v8: rs.u32 = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.u32CheckedAdd(a, b); + const part82 = rs.u32CheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.u32CheckedSub(a, b); + const part83 = rs.u32CheckedSub(a, b); putOpt(out, part83); - const part84 = rt.u32CheckedMul(a, b); + const part84 = rs.u32CheckedMul(a, b); putOpt(out, part84); - const part85 = rt.u32SaturatingAdd(a, b); + const part85 = rs.u32SaturatingAdd(a, b); _22(out, part85); - const part86 = rt.u32SaturatingSub(a, b); + const part86 = rs.u32SaturatingSub(a, b); _22(out, part86); - const part87 = rt.u32SaturatingMul(a, b); + const part87 = rs.u32SaturatingMul(a, b); _22(out, part87); - const part88 = rt.u32WrappingAdd(a, b); + const part88 = rs.u32WrappingAdd(a, b); _22(out, part88); - const part89 = rt.u32WrappingSub(a, b); + const part89 = rs.u32WrappingSub(a, b); _22(out, part89); - const part90 = rt.u32WrappingMul(a, b); + const part90 = rs.u32WrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 32, false); + const part91 = rs.intOverflowingAdd(a, b, 32, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 32, false); + const part92 = rs.intOverflowingSub(a, b, 32, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 32, false); + const part93 = rs.intOverflowingMul(a, b, 32, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 32, false); + const part94 = rs.intMidpoint(a, b, 32, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 32, false); + const part95 = rs.intCheckedAdd(a, o, 32, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 32, false); + const part96 = rs.intCheckedSub(a, o, 32, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 32, false); + const part97 = rs.intSaturatingAdd(a, o, 32, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 32, false); + const part98 = rs.intSaturatingSub(a, o, 32, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 32, false); + const part99 = rs.intWrappingAdd(a, o, 32, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 32, false); + const part100 = rs.intWrappingSub(a, o, 32, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 32, false); + const part101 = rs.intOverflowingAdd(a, o, 32, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 32, false); + const part102 = rs.intOverflowingSub(a, o, 32, false); putPair(out, part102); - const b2: rt.u32 = o >>> 0; - const _118: rt.i32 | undefined = rt.intCheckedSignedDiff(a, b2, 32, false) as rt.i32 | undefined; + const b2: rs.u32 = o >>> 0; + const _118: rs.i32 | undefined = rs.intCheckedSignedDiff(a, b2, 32, false) as rs.i32 | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 32, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 32, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 32, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 32, false); putPair(out, part104); } - const _141: [rt.u32, rt.u32] = rt.intCarryingMul(a, b2, a, 32, false); - const lo: rt.u32 = _141[0]; - const hi: rt.u32 = _141[1]; + const _141: [rs.u32, rs.u32] = rs.intCarryingMul(a, b2, a, 32, false); + const lo: rs.u32 = _141[0]; + const hi: rs.u32 = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.u32, rt.u32] = rt.intCarryingMulAdd(a, b2, b2, a, 32, false); - const lo2: rt.u32 = _150[0]; - const hi2: rt.u32 = _150[1]; + const _150: [rs.u32, rs.u32] = rs.intCarryingMulAdd(a, b2, b2, a, 32, false); + const lo2: rs.u32 = _150[0]; + const hi2: rs.u32 = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 32, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 32, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 32, false); + const part77 = rs.intCheckedDiv(a, b, 32, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 32, false); + const part78 = rs.intCheckedRem(a, b, 32, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 32, false); + const part79 = rs.intCheckedDivEuclid(a, b, 32, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 32, false); + const part80 = rs.intCheckedRemEuclid(a, b, 32, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.u32DivCeil(a, b); + const part81 = rs.u32DivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.u32IsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u32IsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 32, false); + const part72 = rs.intCheckedNeg(a, 32, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 32, false); + const part73 = rs.intWrappingNeg(a, 32, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 32, false); + const part74 = rs.intOverflowingNeg(a, 32, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 32, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 32, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 32, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 32, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 32, false); + const part76 = rs.intBitWidth(a, 32, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(a | 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(a | 0))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 32, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 32, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 32, false); + const part69 = rs.intWrappingPow(a, e, 32, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 32, false); + const part70 = rs.intSaturatingPow(a, e, 32, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 32, false); + const part71 = rs.intOverflowingPow(a, e, 32, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 32, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 32, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 32, false); + const part59 = rs.intCheckedShr(a, s, 32, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 32, false); + const part60 = rs.intWrappingShl(a, s, 32, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 32, false); + const part61 = rs.intWrappingShr(a, s, 32, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 32, false); + const part62 = rs.intOverflowingShl(a, s, 32, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 32, false); + const part63 = rs.intOverflowingShr(a, s, 32, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 32, false); + const part64 = rs.intUnboundedShl(a, s, 32, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 32, false); + const part65 = rs.intUnboundedShr(a, s, 32, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 32, false); + const part66 = rs.intRotateLeft(a, s, 32, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 32, false); + const part67 = rs.intRotateRight(a, s, 32, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 32, false), rt.intCountZeros(a, 32, false), rt.u32LeadingZeros(a), rt.u32TrailingZeros(a), rt.u32LeadingOnes(a), rt.intTrailingOnes(a, 32, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 32, false), rs.intCountZeros(a, 32, false), rs.u32LeadingZeros(a), rs.u32TrailingZeros(a), rs.u32LeadingOnes(a), rs.intTrailingOnes(a, 32, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 32, false), rt.intReverseBits(a, 32, false), rt.intSwapBytes(a, 32, false), a, rt.intSwapBytes(a, 32, false), a]); + const iter5: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 32, false), rs.intReverseBits(a, 32, false), rs.intSwapBytes(a, 32, false), a, rs.intSwapBytes(a, 32, false), a]); while (true) { - const _308: rt.u32 | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.u32 | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 32, false); + const part54 = rs.intHighestOne(a, 32, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 32, false); + const part55 = rs.intLowestOne(a, 32, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 32, false); + const part56 = rs.intIsolateHighestOne(a, 32, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 32, false); + const part57 = rs.intIsolateLowestOne(a, 32, false); _22(out, part57); _22(out, 4294967295); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 32, false); + const part51 = rs.intCheckedIlog(a, b, 32, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 32, false); + const part52 = rs.intCheckedIlog2(a, 32, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 32, false); + const part53 = rs.intCheckedIlog10(a, 32, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.intAbsDiff(a, b, 32, false) as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.intAbsDiff(a, b, 32, false) as rs.u32))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 32, false); + const part50 = rs.intPow(a, k, 32, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 32, false); + const part49 = rs.intPow(a, n, 32, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 32, false); + const part48 = rs.intDivEuclid(a, b, 32, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 32, false); + const part47 = rs.intRemEuclid(a, b, 32, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 32, false); + const part46 = rs.intIsqrt(a, 32, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 32, false); + const part45 = rs.intIlog(a, b, 32, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 32, false); + const part44 = rs.intIlog2(a, 32, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 32, false); + const part43 = rs.intIlog10(a, 32, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.u32Add(a, b)); + _22(out, rs.u32Add(a, b)); } else if (_30 === 16) { - _22(out, rt.u32Sub(a, b)); + _22(out, rs.u32Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.u32Mul(a, b)); + _22(out, rs.u32Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.u32Div(a, b)); + _22(out, rs.u32Div(a, b)); } else if (_30 === 19) { - _22(out, rt.u32Rem(a, b)); + _22(out, rs.u32Rem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 32, false); + const part37 = rs.intStrictNeg(a, 32, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.u32Shl(a, k)); + _22(out, rs.u32Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.u32Shr(a, k)); + _22(out, rs.u32Shr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 32, false); + const part34 = rs.intPow(a, k, 32, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 32, false); + const part33 = rs.intDivEuclid(a, b, 32, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 32, false); + const part32 = rs.intRemEuclid(a, b, 32, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 32, false); + const part31 = rs.intStrictAdd(a, o, 32, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 32, false); + const part30 = rs.intStrictSub(a, o, 32, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.u32Div(a, b)); + _22(out, rs.u32Div(a, b)); } else if (_30 === 29) { - _22(out, rt.u32Rem(a, b)); + _22(out, rs.u32Rem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 32, false); + const part27 = rs.intWrappingDivEuclid(a, b, 32, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 32, false); + const part26 = rs.intWrappingRemEuclid(a, b, 32, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 32, false); + const part25 = rs.intOverflowingDiv(a, b, 32, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 32, false); + const part24 = rs.intOverflowingRem(a, b, 32, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 32, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 32, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 32, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 32, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.u32Div(a, b)); + _22(out, rs.u32Div(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 32, false); + const part20 = rs.intNextPowerOfTwo(a, 32, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 32, false); + const part19 = rs.intNextMultipleOf(a, b, 32, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 32, false); + const part18 = rs.intFunnelShl(a, b, k, 32, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 32, false); + const part17 = rs.intFunnelShr(a, b, k, 32, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.u32 = a; - const w: rt.u32 = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 32, false), rt.intCountZeros(s2, 32, false), rt.u32LeadingZeros(s2), rt.u32TrailingZeros(s2)]); + const s2: rs.u32 = a; + const w: rs.u32 = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 32, false), rs.intCountZeros(s2, 32, false), rs.u32LeadingZeros(s2), rs.u32TrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 32, false), rt.intCountZeros(w, 32, false), rt.u32LeadingZeros(w), rt.u32TrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 32, false), rs.intCountZeros(w, 32, false), rs.u32LeadingZeros(w), rs.u32TrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 32, false), rt.intRotateRight(s2, n, 32, false), rt.intSwapBytes(s2, 32, false), rt.intReverseBits(s2, 32, false), rt.intSwapBytes(s2, 32, false), s2, rt.intSwapBytes(s2, 32, false), s2, rt.intSaturatingPow(s2, k, 32, false), rt.intSaturatingPow(s2, n, 32, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 32, false), rs.intRotateRight(s2, n, 32, false), rs.intSwapBytes(s2, 32, false), rs.intReverseBits(s2, 32, false), rs.intSwapBytes(s2, 32, false), s2, rs.intSwapBytes(s2, 32, false), s2, rs.intSaturatingPow(s2, k, 32, false), rs.intSaturatingPow(s2, n, 32, false)]); while (true) { - const _506: rt.u32 | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.u32 | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 32, false), rt.intRotateRight(w, n, 32, false), rt.intSwapBytes(w, 32, false), rt.intReverseBits(w, 32, false), rt.intSwapBytes(w, 32, false), w, rt.intSwapBytes(w, 32, false), w, rt.intWrappingPow(w, k, 32, false), rt.intWrappingPow(w, n, 32, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 32, false), rs.intRotateRight(w, n, 32, false), rs.intSwapBytes(w, 32, false), rs.intReverseBits(w, 32, false), rs.intSwapBytes(w, 32, false), w, rs.intSwapBytes(w, 32, false), w, rs.intWrappingPow(w, k, 32, false), rs.intWrappingPow(w, n, 32, false)]); while (true) { - const _527: rt.u32 | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.u32 | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 32, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 32, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 32, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 32, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 32, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 32, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.u32 | undefined, rt.u32 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.u32 | undefined, rs.u32 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.u32 = _548[0]; - const y: rt.u32 = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.u32LeadingZeros(x), rt.u32TrailingZeros(x), rt.intCountOnes(x, 32, false), 31 - rt.u32LeadingZeros(x), rt.u32TrailingZeros(x)]); + const x: rs.u32 = _548[0]; + const y: rs.u32 = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.u32LeadingZeros(x), rs.u32TrailingZeros(x), rs.intCountOnes(x, 32, false), 31 - rs.u32LeadingZeros(x), rs.u32TrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$0xz4pvf(rt.u32CheckedMul(x, y), (a0: rt.u32): rt.u32 => { + const part3 = option_map$03qwbb9(rs.u32CheckedMul(x, y), (a0: rs.u32): rs.u32 => { return a0; }); putOpt(out, part3); - const part4 = rt.u32SaturatingMul(x, y); + const part4 = rs.u32SaturatingMul(x, y); _22(out, part4); - const part5 = option_map$0xz4pvf(rt.intCheckedPow(x, k, 32, false), (a02: rt.u32): rt.u32 => { + const part5 = option_map$03qwbb9(rs.intCheckedPow(x, k, 32, false), (a02: rs.u32): rs.u32 => { return a02; }); putOpt(out, part5); - const part6 = option_map$0xz4pvf(rt.intCheckedPow(x, n, 32, false), (a03: rt.u32): rt.u32 => { + const part6 = option_map$03qwbb9(rs.intCheckedPow(x, n, 32, false), (a03: rs.u32): rs.u32 => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 32, false); + const part7 = rs.intSaturatingPow(x, k, 32, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 32, false); + const part8 = rs.intIsolateHighestOne(x, 32, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 32, false); + const part9 = rs.intIsolateLowestOne(x, 32, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 32, false) ? 1 : 0); - const part10 = option_map$0xz4pvf(rt.u32CheckedAdd(x, b), (a04: rt.u32): rt.u32 => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 32, false) ? 1 : 0); + const part10 = option_map$03qwbb9(rs.u32CheckedAdd(x, b), (a04: rs.u32): rs.u32 => { return a04; }); putOpt(out, part10); - const part11 = rt.u32SaturatingAdd(x, b); + const part11 = rs.u32SaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$0xz4pvf(rt.intCheckedNextPowerOfTwo(x, 32, false), (a05: rt.u32): rt.u32 => { + const part12 = option_map$03qwbb9(rs.intCheckedNextPowerOfTwo(x, 32, false), (a05: rs.u32): rs.u32 => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 32, false), rt.intIlog10(x, 32, false), rt.intBitWidth(x, 32, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 32, false), rs.intIlog10(x, 32, false), rs.intBitWidth(x, 32, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 32, false); + const part13 = rs.intMidpoint(x, y, 32, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 32, false); + const part14 = rs.intIsqrt(x, 32, false); _22(out, part14); - const part15 = rt.u32DivCeil(x, y); + const part15 = rs.u32DivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(x | 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(x | 0))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v4: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v4))); - rt.byteVecPush(out2, rt.u64Eq(rt.u64FromBeBytes(rt.u64ToBeBytes(v4)), v4) ? 1 : 0); +export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v4: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u64Eq(rs.u64FromBeBytes(rs.u64ToBeBytes(v4)), v4) ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.u64 = rt.u64FromBeBytes(rt.bytesFromFn(8, (i2: rt.usize): rt.u8 => { + const a: rs.u64 = rs.u64FromBeBytes(rs.bytesFromFn(8, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.u64 = rt.u64FromBeBytes(rt.bytesFromFn(8, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(8, i3)); + const b: rs.u64 = rs.u64FromBeBytes(rs.bytesFromFn(8, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(8, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 8, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 8, i4)); })); - const o: rt.i64 = rt.i64Cast(b); - const k: rt.u32 = rt.u32Rem(n, 3 * 64); - const putOpt: (a0: rt.ByteVec, a1: rt.u64 | undefined) => undefined = (out4: rt.ByteVec, v6: rt.u64 | undefined): undefined => { + const o: rs.i64 = rs.i64Cast(b); + const k: rs.u32 = rs.u32Rem(n, 3 * 64); + const putOpt: (a0: rs.ByteVec, a1: rs.u64 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u64 | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.u64 = v6; - rt.byteVecPush(out4, 1); + const v7: rs.u64 = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.u64, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.u64, boolean]): undefined => { - const v8: rt.u64 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u64, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u64, boolean]): undefined => { + const v8: rs.u64 = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.u64CheckedAdd(a, b); + const part82 = rs.u64CheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.u64CheckedSub(a, b); + const part83 = rs.u64CheckedSub(a, b); putOpt(out, part83); - const part84 = rt.u64CheckedMul(a, b); + const part84 = rs.u64CheckedMul(a, b); putOpt(out, part84); - const part85 = rt.u64SaturatingAdd(a, b); + const part85 = rs.u64SaturatingAdd(a, b); _22(out, part85); - const part86 = rt.u64SaturatingSub(a, b); + const part86 = rs.u64SaturatingSub(a, b); _22(out, part86); - const part87 = rt.u64SaturatingMul(a, b); + const part87 = rs.u64SaturatingMul(a, b); _22(out, part87); - const part88 = rt.u64WrappingAdd(a, b); + const part88 = rs.u64WrappingAdd(a, b); _22(out, part88); - const part89 = rt.u64WrappingSub(a, b); + const part89 = rs.u64WrappingSub(a, b); _22(out, part89); - const part90 = rt.u64WrappingMul(a, b); + const part90 = rs.u64WrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 64, false); + const part91 = rs.intOverflowingAdd(a, b, 64, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 64, false); + const part92 = rs.intOverflowingSub(a, b, 64, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 64, false); + const part93 = rs.intOverflowingMul(a, b, 64, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 64, false); + const part94 = rs.intMidpoint(a, b, 64, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 64, false); + const part95 = rs.intCheckedAdd(a, o, 64, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 64, false); + const part96 = rs.intCheckedSub(a, o, 64, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 64, false); + const part97 = rs.intSaturatingAdd(a, o, 64, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 64, false); + const part98 = rs.intSaturatingSub(a, o, 64, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 64, false); + const part99 = rs.intWrappingAdd(a, o, 64, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 64, false); + const part100 = rs.intWrappingSub(a, o, 64, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 64, false); + const part101 = rs.intOverflowingAdd(a, o, 64, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 64, false); + const part102 = rs.intOverflowingSub(a, o, 64, false); putPair(out, part102); - const b2: rt.u64 = rt.u64Cast(o); - const _118: rt.i64 | undefined = rt.intCheckedSignedDiff(a, b2, 64, false) as rt.i64 | undefined; + const b2: rs.u64 = rs.u64Cast(o); + const _118: rs.i64 | undefined = rs.intCheckedSignedDiff(a, b2, 64, false) as rs.i64 | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 64, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 64, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 64, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 64, false); putPair(out, part104); } - const _141: [rt.u64, rt.u64] = rt.intCarryingMul(a, b2, a, 64, false); - const lo: rt.u64 = _141[0]; - const hi: rt.u64 = _141[1]; + const _141: [rs.u64, rs.u64] = rs.intCarryingMul(a, b2, a, 64, false); + const lo: rs.u64 = _141[0]; + const hi: rs.u64 = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.u64, rt.u64] = rt.intCarryingMulAdd(a, b2, b2, a, 64, false); - const lo2: rt.u64 = _150[0]; - const hi2: rt.u64 = _150[1]; + const _150: [rs.u64, rs.u64] = rs.intCarryingMulAdd(a, b2, b2, a, 64, false); + const lo2: rs.u64 = _150[0]; + const hi2: rs.u64 = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 64, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 64, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 64, false); + const part77 = rs.intCheckedDiv(a, b, 64, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 64, false); + const part78 = rs.intCheckedRem(a, b, 64, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 64, false); + const part79 = rs.intCheckedDivEuclid(a, b, 64, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 64, false); + const part80 = rs.intCheckedRemEuclid(a, b, 64, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.u64DivCeil(a, b); + const part81 = rs.u64DivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.u64IsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u64IsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 64, false); + const part72 = rs.intCheckedNeg(a, 64, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 64, false); + const part73 = rs.intWrappingNeg(a, 64, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 64, false); + const part74 = rs.intOverflowingNeg(a, 64, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 64, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 64, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 64, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 64, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 64, false); + const part76 = rs.intBitWidth(a, 64, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64Cast(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64Cast(a)))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 64, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 64, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 64, false); + const part69 = rs.intWrappingPow(a, e, 64, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 64, false); + const part70 = rs.intSaturatingPow(a, e, 64, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 64, false); + const part71 = rs.intOverflowingPow(a, e, 64, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 64, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 64, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 64, false); + const part59 = rs.intCheckedShr(a, s, 64, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 64, false); + const part60 = rs.intWrappingShl(a, s, 64, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 64, false); + const part61 = rs.intWrappingShr(a, s, 64, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 64, false); + const part62 = rs.intOverflowingShl(a, s, 64, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 64, false); + const part63 = rs.intOverflowingShr(a, s, 64, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 64, false); + const part64 = rs.intUnboundedShl(a, s, 64, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 64, false); + const part65 = rs.intUnboundedShr(a, s, 64, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 64, false); + const part66 = rs.intRotateLeft(a, s, 64, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 64, false); + const part67 = rs.intRotateRight(a, s, 64, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 64, false), rt.intCountZeros(a, 64, false), rt.u64LeadingZeros(a), rt.u64TrailingZeros(a), rt.u64LeadingOnes(a), rt.intTrailingOnes(a, 64, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 64, false), rs.intCountZeros(a, 64, false), rs.u64LeadingZeros(a), rs.u64TrailingZeros(a), rs.u64LeadingOnes(a), rs.intTrailingOnes(a, 64, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 64, false), rt.intReverseBits(a, 64, false), rt.intSwapBytes(a, 64, false), a, rt.intSwapBytes(a, 64, false), a]); + const iter5: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 64, false), rs.intReverseBits(a, 64, false), rs.intSwapBytes(a, 64, false), a, rs.intSwapBytes(a, 64, false), a]); while (true) { - const _308: rt.u64 | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.u64 | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 64, false); + const part54 = rs.intHighestOne(a, 64, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 64, false); + const part55 = rs.intLowestOne(a, 64, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 64, false); + const part56 = rs.intIsolateHighestOne(a, 64, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 64, false); + const part57 = rs.intIsolateLowestOne(a, 64, false); _22(out, part57); - _22(out, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64); + _22(out, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 64, false); + const part51 = rs.intCheckedIlog(a, b, 64, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 64, false); + const part52 = rs.intCheckedIlog2(a, 64, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 64, false); + const part53 = rs.intCheckedIlog10(a, 64, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.intAbsDiff(a, b, 64, false) as rt.u64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.intAbsDiff(a, b, 64, false) as rs.u64))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 64, false); + const part50 = rs.intPow(a, k, 64, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 64, false); + const part49 = rs.intPow(a, n, 64, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 64, false); + const part48 = rs.intDivEuclid(a, b, 64, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 64, false); + const part47 = rs.intRemEuclid(a, b, 64, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 64, false); + const part46 = rs.intIsqrt(a, 64, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 64, false); + const part45 = rs.intIlog(a, b, 64, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 64, false); + const part44 = rs.intIlog2(a, 64, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 64, false); + const part43 = rs.intIlog10(a, 64, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.u64Add(a, b)); + _22(out, rs.u64Add(a, b)); } else if (_30 === 16) { - _22(out, rt.u64Sub(a, b)); + _22(out, rs.u64Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.u64Mul(a, b)); + _22(out, rs.u64Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.u64Div(a, b)); + _22(out, rs.u64Div(a, b)); } else if (_30 === 19) { - _22(out, rt.u64Rem(a, b)); + _22(out, rs.u64Rem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 64, false); + const part37 = rs.intStrictNeg(a, 64, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.u64Shl(a, k)); + _22(out, rs.u64Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.u64Shr(a, k)); + _22(out, rs.u64Shr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 64, false); + const part34 = rs.intPow(a, k, 64, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 64, false); + const part33 = rs.intDivEuclid(a, b, 64, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 64, false); + const part32 = rs.intRemEuclid(a, b, 64, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 64, false); + const part31 = rs.intStrictAdd(a, o, 64, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 64, false); + const part30 = rs.intStrictSub(a, o, 64, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.u64Div(a, b)); + _22(out, rs.u64Div(a, b)); } else if (_30 === 29) { - _22(out, rt.u64Rem(a, b)); + _22(out, rs.u64Rem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 64, false); + const part27 = rs.intWrappingDivEuclid(a, b, 64, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 64, false); + const part26 = rs.intWrappingRemEuclid(a, b, 64, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 64, false); + const part25 = rs.intOverflowingDiv(a, b, 64, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 64, false); + const part24 = rs.intOverflowingRem(a, b, 64, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 64, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 64, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 64, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 64, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.u64Div(a, b)); + _22(out, rs.u64Div(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 64, false); + const part20 = rs.intNextPowerOfTwo(a, 64, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 64, false); + const part19 = rs.intNextMultipleOf(a, b, 64, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 64, false); + const part18 = rs.intFunnelShl(a, b, k, 64, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 64, false); + const part17 = rs.intFunnelShr(a, b, k, 64, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.u64 = a; - const w: rt.u64 = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 64, false), rt.intCountZeros(s2, 64, false), rt.u64LeadingZeros(s2), rt.u64TrailingZeros(s2)]); + const s2: rs.u64 = a; + const w: rs.u64 = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 64, false), rs.intCountZeros(s2, 64, false), rs.u64LeadingZeros(s2), rs.u64TrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 64, false), rt.intCountZeros(w, 64, false), rt.u64LeadingZeros(w), rt.u64TrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 64, false), rs.intCountZeros(w, 64, false), rs.u64LeadingZeros(w), rs.u64TrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 64, false), rt.intRotateRight(s2, n, 64, false), rt.intSwapBytes(s2, 64, false), rt.intReverseBits(s2, 64, false), rt.intSwapBytes(s2, 64, false), s2, rt.intSwapBytes(s2, 64, false), s2, rt.intSaturatingPow(s2, k, 64, false), rt.intSaturatingPow(s2, n, 64, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 64, false), rs.intRotateRight(s2, n, 64, false), rs.intSwapBytes(s2, 64, false), rs.intReverseBits(s2, 64, false), rs.intSwapBytes(s2, 64, false), s2, rs.intSwapBytes(s2, 64, false), s2, rs.intSaturatingPow(s2, k, 64, false), rs.intSaturatingPow(s2, n, 64, false)]); while (true) { - const _506: rt.u64 | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.u64 | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 64, false), rt.intRotateRight(w, n, 64, false), rt.intSwapBytes(w, 64, false), rt.intReverseBits(w, 64, false), rt.intSwapBytes(w, 64, false), w, rt.intSwapBytes(w, 64, false), w, rt.intWrappingPow(w, k, 64, false), rt.intWrappingPow(w, n, 64, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 64, false), rs.intRotateRight(w, n, 64, false), rs.intSwapBytes(w, 64, false), rs.intReverseBits(w, 64, false), rs.intSwapBytes(w, 64, false), w, rs.intSwapBytes(w, 64, false), w, rs.intWrappingPow(w, k, 64, false), rs.intWrappingPow(w, n, 64, false)]); while (true) { - const _527: rt.u64 | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.u64 | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 64, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 64, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 64, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 64, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 64, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 64, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.u64 | undefined, rt.u64 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.u64 | undefined, rs.u64 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.u64 = _548[0]; - const y: rt.u64 = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.u64LeadingZeros(x), rt.u64TrailingZeros(x), rt.intCountOnes(x, 64, false), 63 - rt.u64LeadingZeros(x), rt.u64TrailingZeros(x)]); + const x: rs.u64 = _548[0]; + const y: rs.u64 = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.u64LeadingZeros(x), rs.u64TrailingZeros(x), rs.intCountOnes(x, 64, false), 63 - rs.u64LeadingZeros(x), rs.u64TrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$1rxjg4m(rt.u64CheckedMul(x, y), (a0: rt.u64): rt.u64 => { + const part3 = option_map$0fest7b(rs.u64CheckedMul(x, y), (a0: rs.u64): rs.u64 => { return a0; }); putOpt(out, part3); - const part4 = rt.u64SaturatingMul(x, y); + const part4 = rs.u64SaturatingMul(x, y); _22(out, part4); - const part5 = option_map$1rxjg4m(rt.intCheckedPow(x, k, 64, false), (a02: rt.u64): rt.u64 => { + const part5 = option_map$0fest7b(rs.intCheckedPow(x, k, 64, false), (a02: rs.u64): rs.u64 => { return a02; }); putOpt(out, part5); - const part6 = option_map$1rxjg4m(rt.intCheckedPow(x, n, 64, false), (a03: rt.u64): rt.u64 => { + const part6 = option_map$0fest7b(rs.intCheckedPow(x, n, 64, false), (a03: rs.u64): rs.u64 => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 64, false); + const part7 = rs.intSaturatingPow(x, k, 64, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 64, false); + const part8 = rs.intIsolateHighestOne(x, 64, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 64, false); + const part9 = rs.intIsolateLowestOne(x, 64, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 64, false) ? 1 : 0); - const part10 = option_map$1rxjg4m(rt.u64CheckedAdd(x, b), (a04: rt.u64): rt.u64 => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 64, false) ? 1 : 0); + const part10 = option_map$0fest7b(rs.u64CheckedAdd(x, b), (a04: rs.u64): rs.u64 => { return a04; }); putOpt(out, part10); - const part11 = rt.u64SaturatingAdd(x, b); + const part11 = rs.u64SaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$1rxjg4m(rt.intCheckedNextPowerOfTwo(x, 64, false), (a05: rt.u64): rt.u64 => { + const part12 = option_map$0fest7b(rs.intCheckedNextPowerOfTwo(x, 64, false), (a05: rs.u64): rs.u64 => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 64, false), rt.intIlog10(x, 64, false), rt.intBitWidth(x, 64, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 64, false), rs.intIlog10(x, 64, false), rs.intBitWidth(x, 64, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 64, false); + const part13 = rs.intMidpoint(x, y, 64, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 64, false); + const part14 = rs.intIsqrt(x, 64, false); _22(out, part14); - const part15 = rt.u64DivCeil(x, y); + const part15 = rs.u64DivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64Cast(x)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64Cast(x)))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v4: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v4))); - rt.byteVecPush(out2, rt.u128Eq(rt.u128FromBeBytes(rt.u128ToBeBytes(v4)), v4) ? 1 : 0); +export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v4: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v4))); + rs.byteVecPush(out2, rs.u128Eq(rs.u128FromBeBytes(rs.u128ToBeBytes(v4)), v4) ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.u128 = rt.u128FromBeBytes(rt.bytesFromFn(16, (i2: rt.usize): rt.u8 => { + const a: rs.u128 = rs.u128FromBeBytes(rs.bytesFromFn(16, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.u128 = rt.u128FromBeBytes(rt.bytesFromFn(16, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(16, i3)); + const b: rs.u128 = rs.u128FromBeBytes(rs.bytesFromFn(16, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(16, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 16, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 16, i4)); })); - const o: rt.i128 = rt.i128Cast(b); - const k: rt.u32 = rt.u32Rem(n, 3 * 128); - const putOpt: (a0: rt.ByteVec, a1: rt.u128 | undefined) => undefined = (out4: rt.ByteVec, v6: rt.u128 | undefined): undefined => { + const o: rs.i128 = rs.i128Cast(b); + const k: rs.u32 = rs.u32Rem(n, 3 * 128); + const putOpt: (a0: rs.ByteVec, a1: rs.u128 | undefined) => undefined = (out4: rs.ByteVec, v6: rs.u128 | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.u128 = v6; - rt.byteVecPush(out4, 1); + const v7: rs.u128 = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.u128, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.u128, boolean]): undefined => { - const v8: rt.u128 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.u128, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.u128, boolean]): undefined => { + const v8: rs.u128 = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.u128CheckedAdd(a, b); + const part82 = rs.u128CheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.u128CheckedSub(a, b); + const part83 = rs.u128CheckedSub(a, b); putOpt(out, part83); - const part84 = rt.u128CheckedMul(a, b); + const part84 = rs.u128CheckedMul(a, b); putOpt(out, part84); - const part85 = rt.u128SaturatingAdd(a, b); + const part85 = rs.u128SaturatingAdd(a, b); _22(out, part85); - const part86 = rt.u128SaturatingSub(a, b); + const part86 = rs.u128SaturatingSub(a, b); _22(out, part86); - const part87 = rt.u128SaturatingMul(a, b); + const part87 = rs.u128SaturatingMul(a, b); _22(out, part87); - const part88 = rt.u128WrappingAdd(a, b); + const part88 = rs.u128WrappingAdd(a, b); _22(out, part88); - const part89 = rt.u128WrappingSub(a, b); + const part89 = rs.u128WrappingSub(a, b); _22(out, part89); - const part90 = rt.u128WrappingMul(a, b); + const part90 = rs.u128WrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 128, false); + const part91 = rs.intOverflowingAdd(a, b, 128, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 128, false); + const part92 = rs.intOverflowingSub(a, b, 128, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 128, false); + const part93 = rs.intOverflowingMul(a, b, 128, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 128, false); + const part94 = rs.intMidpoint(a, b, 128, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 128, false); + const part95 = rs.intCheckedAdd(a, o, 128, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 128, false); + const part96 = rs.intCheckedSub(a, o, 128, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 128, false); + const part97 = rs.intSaturatingAdd(a, o, 128, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 128, false); + const part98 = rs.intSaturatingSub(a, o, 128, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 128, false); + const part99 = rs.intWrappingAdd(a, o, 128, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 128, false); + const part100 = rs.intWrappingSub(a, o, 128, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 128, false); + const part101 = rs.intOverflowingAdd(a, o, 128, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 128, false); + const part102 = rs.intOverflowingSub(a, o, 128, false); putPair(out, part102); - const b2: rt.u128 = rt.u128Cast(o); - const _118: rt.i128 | undefined = rt.intCheckedSignedDiff(a, b2, 128, false) as rt.i128 | undefined; + const b2: rs.u128 = rs.u128Cast(o); + const _118: rs.i128 | undefined = rs.intCheckedSignedDiff(a, b2, 128, false) as rs.i128 | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 128, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 128, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 128, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 128, false); putPair(out, part104); } - const _141: [rt.u128, rt.u128] = rt.intCarryingMul(a, b2, a, 128, false); - const lo: rt.u128 = _141[0]; - const hi: rt.u128 = _141[1]; + const _141: [rs.u128, rs.u128] = rs.intCarryingMul(a, b2, a, 128, false); + const lo: rs.u128 = _141[0]; + const hi: rs.u128 = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.u128, rt.u128] = rt.intCarryingMulAdd(a, b2, b2, a, 128, false); - const lo2: rt.u128 = _150[0]; - const hi2: rt.u128 = _150[1]; + const _150: [rs.u128, rs.u128] = rs.intCarryingMulAdd(a, b2, b2, a, 128, false); + const lo2: rs.u128 = _150[0]; + const hi2: rs.u128 = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 128, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 128, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 128, false); + const part77 = rs.intCheckedDiv(a, b, 128, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 128, false); + const part78 = rs.intCheckedRem(a, b, 128, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 128, false); + const part79 = rs.intCheckedDivEuclid(a, b, 128, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 128, false); + const part80 = rs.intCheckedRemEuclid(a, b, 128, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.u128DivCeil(a, b); + const part81 = rs.u128DivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.u128IsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.u128IsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 128, false); + const part72 = rs.intCheckedNeg(a, 128, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 128, false); + const part73 = rs.intWrappingNeg(a, 128, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 128, false); + const part74 = rs.intOverflowingNeg(a, 128, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 128, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 128, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 128, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 128, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 128, false); + const part76 = rs.intBitWidth(a, 128, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(a)))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 128, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 128, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 128, false); + const part69 = rs.intWrappingPow(a, e, 128, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 128, false); + const part70 = rs.intSaturatingPow(a, e, 128, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 128, false); + const part71 = rs.intOverflowingPow(a, e, 128, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 128, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 128, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 128, false); + const part59 = rs.intCheckedShr(a, s, 128, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 128, false); + const part60 = rs.intWrappingShl(a, s, 128, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 128, false); + const part61 = rs.intWrappingShr(a, s, 128, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 128, false); + const part62 = rs.intOverflowingShl(a, s, 128, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 128, false); + const part63 = rs.intOverflowingShr(a, s, 128, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 128, false); + const part64 = rs.intUnboundedShl(a, s, 128, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 128, false); + const part65 = rs.intUnboundedShr(a, s, 128, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 128, false); + const part66 = rs.intRotateLeft(a, s, 128, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 128, false); + const part67 = rs.intRotateRight(a, s, 128, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 128, false), rt.intCountZeros(a, 128, false), rt.u128LeadingZeros(a), rt.u128TrailingZeros(a), rt.u128LeadingOnes(a), rt.intTrailingOnes(a, 128, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 128, false), rs.intCountZeros(a, 128, false), rs.u128LeadingZeros(a), rs.u128TrailingZeros(a), rs.u128LeadingOnes(a), rs.intTrailingOnes(a, 128, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 128, false), rt.intReverseBits(a, 128, false), rt.intSwapBytes(a, 128, false), a, rt.intSwapBytes(a, 128, false), a]); + const iter5: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 128, false), rs.intReverseBits(a, 128, false), rs.intSwapBytes(a, 128, false), a, rs.intSwapBytes(a, 128, false), a]); while (true) { - const _308: rt.u128 | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.u128 | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 128, false); + const part54 = rs.intHighestOne(a, 128, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 128, false); + const part55 = rs.intLowestOne(a, 128, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 128, false); + const part56 = rs.intIsolateHighestOne(a, 128, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 128, false); + const part57 = rs.intIsolateLowestOne(a, 128, false); _22(out, part57); - _22(out, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128); + _22(out, { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 128, false); + const part51 = rs.intCheckedIlog(a, b, 128, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 128, false); + const part52 = rs.intCheckedIlog2(a, 128, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 128, false); + const part53 = rs.intCheckedIlog10(a, 128, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.intAbsDiff(a, b, 128, false) as rt.u128))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.intAbsDiff(a, b, 128, false) as rs.u128))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 128, false); + const part50 = rs.intPow(a, k, 128, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 128, false); + const part49 = rs.intPow(a, n, 128, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 128, false); + const part48 = rs.intDivEuclid(a, b, 128, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 128, false); + const part47 = rs.intRemEuclid(a, b, 128, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 128, false); + const part46 = rs.intIsqrt(a, 128, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 128, false); + const part45 = rs.intIlog(a, b, 128, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 128, false); + const part44 = rs.intIlog2(a, 128, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 128, false); + const part43 = rs.intIlog10(a, 128, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.u128Add(a, b)); + _22(out, rs.u128Add(a, b)); } else if (_30 === 16) { - _22(out, rt.u128Sub(a, b)); + _22(out, rs.u128Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.u128Mul(a, b)); + _22(out, rs.u128Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.u128Div(a, b)); + _22(out, rs.u128Div(a, b)); } else if (_30 === 19) { - _22(out, rt.u128Rem(a, b)); + _22(out, rs.u128Rem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 128, false); + const part37 = rs.intStrictNeg(a, 128, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.u128Shl(a, k)); + _22(out, rs.u128Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.u128Shr(a, k)); + _22(out, rs.u128Shr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 128, false); + const part34 = rs.intPow(a, k, 128, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 128, false); + const part33 = rs.intDivEuclid(a, b, 128, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 128, false); + const part32 = rs.intRemEuclid(a, b, 128, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 128, false); + const part31 = rs.intStrictAdd(a, o, 128, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 128, false); + const part30 = rs.intStrictSub(a, o, 128, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.u128Div(a, b)); + _22(out, rs.u128Div(a, b)); } else if (_30 === 29) { - _22(out, rt.u128Rem(a, b)); + _22(out, rs.u128Rem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 128, false); + const part27 = rs.intWrappingDivEuclid(a, b, 128, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 128, false); + const part26 = rs.intWrappingRemEuclid(a, b, 128, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 128, false); + const part25 = rs.intOverflowingDiv(a, b, 128, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 128, false); + const part24 = rs.intOverflowingRem(a, b, 128, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 128, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 128, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 128, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 128, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.u128Div(a, b)); + _22(out, rs.u128Div(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 128, false); + const part20 = rs.intNextPowerOfTwo(a, 128, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 128, false); + const part19 = rs.intNextMultipleOf(a, b, 128, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 128, false); + const part18 = rs.intFunnelShl(a, b, k, 128, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 128, false); + const part17 = rs.intFunnelShr(a, b, k, 128, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.u128 = a; - const w: rt.u128 = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 128, false), rt.intCountZeros(s2, 128, false), rt.u128LeadingZeros(s2), rt.u128TrailingZeros(s2)]); + const s2: rs.u128 = a; + const w: rs.u128 = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 128, false), rs.intCountZeros(s2, 128, false), rs.u128LeadingZeros(s2), rs.u128TrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 128, false), rt.intCountZeros(w, 128, false), rt.u128LeadingZeros(w), rt.u128TrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 128, false), rs.intCountZeros(w, 128, false), rs.u128LeadingZeros(w), rs.u128TrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 128, false), rt.intRotateRight(s2, n, 128, false), rt.intSwapBytes(s2, 128, false), rt.intReverseBits(s2, 128, false), rt.intSwapBytes(s2, 128, false), s2, rt.intSwapBytes(s2, 128, false), s2, rt.intSaturatingPow(s2, k, 128, false), rt.intSaturatingPow(s2, n, 128, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 128, false), rs.intRotateRight(s2, n, 128, false), rs.intSwapBytes(s2, 128, false), rs.intReverseBits(s2, 128, false), rs.intSwapBytes(s2, 128, false), s2, rs.intSwapBytes(s2, 128, false), s2, rs.intSaturatingPow(s2, k, 128, false), rs.intSaturatingPow(s2, n, 128, false)]); while (true) { - const _506: rt.u128 | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.u128 | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 128, false), rt.intRotateRight(w, n, 128, false), rt.intSwapBytes(w, 128, false), rt.intReverseBits(w, 128, false), rt.intSwapBytes(w, 128, false), w, rt.intSwapBytes(w, 128, false), w, rt.intWrappingPow(w, k, 128, false), rt.intWrappingPow(w, n, 128, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 128, false), rs.intRotateRight(w, n, 128, false), rs.intSwapBytes(w, 128, false), rs.intReverseBits(w, 128, false), rs.intSwapBytes(w, 128, false), w, rs.intSwapBytes(w, 128, false), w, rs.intWrappingPow(w, k, 128, false), rs.intWrappingPow(w, n, 128, false)]); while (true) { - const _527: rt.u128 | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.u128 | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 128, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 128, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 128, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 128, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 128, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 128, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.u128 | undefined, rt.u128 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.u128 | undefined, rs.u128 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.u128 = _548[0]; - const y: rt.u128 = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.u128LeadingZeros(x), rt.u128TrailingZeros(x), rt.intCountOnes(x, 128, false), 127 - rt.u128LeadingZeros(x), rt.u128TrailingZeros(x)]); + const x: rs.u128 = _548[0]; + const y: rs.u128 = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.u128LeadingZeros(x), rs.u128TrailingZeros(x), rs.intCountOnes(x, 128, false), 127 - rs.u128LeadingZeros(x), rs.u128TrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$1fszu7p(rt.u128CheckedMul(x, y), (a0: rt.u128): rt.u128 => { + const part3 = option_map$1x2mrlk(rs.u128CheckedMul(x, y), (a0: rs.u128): rs.u128 => { return a0; }); putOpt(out, part3); - const part4 = rt.u128SaturatingMul(x, y); + const part4 = rs.u128SaturatingMul(x, y); _22(out, part4); - const part5 = option_map$1fszu7p(rt.intCheckedPow(x, k, 128, false), (a02: rt.u128): rt.u128 => { + const part5 = option_map$1x2mrlk(rs.intCheckedPow(x, k, 128, false), (a02: rs.u128): rs.u128 => { return a02; }); putOpt(out, part5); - const part6 = option_map$1fszu7p(rt.intCheckedPow(x, n, 128, false), (a03: rt.u128): rt.u128 => { + const part6 = option_map$1x2mrlk(rs.intCheckedPow(x, n, 128, false), (a03: rs.u128): rs.u128 => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 128, false); + const part7 = rs.intSaturatingPow(x, k, 128, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 128, false); + const part8 = rs.intIsolateHighestOne(x, 128, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 128, false); + const part9 = rs.intIsolateLowestOne(x, 128, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 128, false) ? 1 : 0); - const part10 = option_map$1fszu7p(rt.u128CheckedAdd(x, b), (a04: rt.u128): rt.u128 => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 128, false) ? 1 : 0); + const part10 = option_map$1x2mrlk(rs.u128CheckedAdd(x, b), (a04: rs.u128): rs.u128 => { return a04; }); putOpt(out, part10); - const part11 = rt.u128SaturatingAdd(x, b); + const part11 = rs.u128SaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$1fszu7p(rt.intCheckedNextPowerOfTwo(x, 128, false), (a05: rt.u128): rt.u128 => { + const part12 = option_map$1x2mrlk(rs.intCheckedNextPowerOfTwo(x, 128, false), (a05: rs.u128): rs.u128 => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 128, false), rt.intIlog10(x, 128, false), rt.intBitWidth(x, 128, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 128, false), rs.intIlog10(x, 128, false), rs.intBitWidth(x, 128, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 128, false); + const part13 = rs.intMidpoint(x, y, 128, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 128, false); + const part14 = rs.intIsqrt(x, 128, false); _22(out, part14); - const part15 = rt.u128DivCeil(x, y); + const part15 = rs.u128DivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(x)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(x)))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v4: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v4))); - rt.byteVecPush(out2, rt.usizeFromBeBytes(rt.usizeToBeBytes(v4)) === v4 ? 1 : 0); +export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v4: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v4))); + rs.byteVecPush(out2, rs.usizeFromBeBytes(rs.usizeToBeBytes(v4)) === v4 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v5: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v5))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v5: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v5))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.usize = rt.usizeFromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { + const a: rs.usize = rs.usizeFromBeBytes(rs.bytesFromFn(4, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.usize = rt.usizeFromBeBytes(rt.bytesFromFn(4, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(4, i3)); + const b: rs.usize = rs.usizeFromBeBytes(rs.bytesFromFn(4, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(4, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 4, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 4, i4)); })); - const o: rt.isize = b | 0; - const k: rt.u32 = rt.u32Rem(n, 3 * 32); - const putOpt: (a0: rt.ByteVec, a1: rt.usize | undefined) => undefined = (out4: rt.ByteVec, v6: rt.usize | undefined): undefined => { + const o: rs.isize = b | 0; + const k: rs.u32 = rs.u32Rem(n, 3 * 32); + const putOpt: (a0: rs.ByteVec, a1: rs.usize | undefined) => undefined = (out4: rs.ByteVec, v6: rs.usize | undefined): undefined => { if (v6 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v7: rt.usize = v6; - rt.byteVecPush(out4, 1); + const v7: rs.usize = v6; + rs.byteVecPush(out4, 1); _22(out4, v7); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.usize, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.usize, boolean]): undefined => { - const v8: rt.usize = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.usize, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.usize, boolean]): undefined => { + const v8: rs.usize = _37[0]; const over: boolean = _37[1]; _22(out5, v8); - rt.byteVecPush(out5, over ? 1 : 0); + rs.byteVecPush(out5, over ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v9: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v9: rs.u32 | undefined): undefined => { if (v9 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v10: rt.u32 = v9; - rt.byteVecPush(out6, 1); + const v10: rs.u32 = v9; + rs.byteVecPush(out6, 1); _27(out6, v10); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part82 = rt.usizeCheckedAdd(a, b); + const part82 = rs.usizeCheckedAdd(a, b); putOpt(out, part82); - const part83 = rt.usizeCheckedSub(a, b); + const part83 = rs.usizeCheckedSub(a, b); putOpt(out, part83); - const part84 = rt.usizeCheckedMul(a, b); + const part84 = rs.usizeCheckedMul(a, b); putOpt(out, part84); - const part85 = rt.usizeSaturatingAdd(a, b); + const part85 = rs.usizeSaturatingAdd(a, b); _22(out, part85); - const part86 = rt.usizeSaturatingSub(a, b); + const part86 = rs.usizeSaturatingSub(a, b); _22(out, part86); - const part87 = rt.usizeSaturatingMul(a, b); + const part87 = rs.usizeSaturatingMul(a, b); _22(out, part87); - const part88 = rt.usizeWrappingAdd(a, b); + const part88 = rs.usizeWrappingAdd(a, b); _22(out, part88); - const part89 = rt.usizeWrappingSub(a, b); + const part89 = rs.usizeWrappingSub(a, b); _22(out, part89); - const part90 = rt.usizeWrappingMul(a, b); + const part90 = rs.usizeWrappingMul(a, b); _22(out, part90); - const part91 = rt.intOverflowingAdd(a, b, 32, false); + const part91 = rs.intOverflowingAdd(a, b, 32, false); putPair(out, part91); - const part92 = rt.intOverflowingSub(a, b, 32, false); + const part92 = rs.intOverflowingSub(a, b, 32, false); putPair(out, part92); - const part93 = rt.intOverflowingMul(a, b, 32, false); + const part93 = rs.intOverflowingMul(a, b, 32, false); putPair(out, part93); - const part94 = rt.intMidpoint(a, b, 32, false); + const part94 = rs.intMidpoint(a, b, 32, false); _22(out, part94); - const part95 = rt.intCheckedAdd(a, o, 32, false); + const part95 = rs.intCheckedAdd(a, o, 32, false); putOpt(out, part95); - const part96 = rt.intCheckedSub(a, o, 32, false); + const part96 = rs.intCheckedSub(a, o, 32, false); putOpt(out, part96); - const part97 = rt.intSaturatingAdd(a, o, 32, false); + const part97 = rs.intSaturatingAdd(a, o, 32, false); _22(out, part97); - const part98 = rt.intSaturatingSub(a, o, 32, false); + const part98 = rs.intSaturatingSub(a, o, 32, false); _22(out, part98); - const part99 = rt.intWrappingAdd(a, o, 32, false); + const part99 = rs.intWrappingAdd(a, o, 32, false); _22(out, part99); - const part100 = rt.intWrappingSub(a, o, 32, false); + const part100 = rs.intWrappingSub(a, o, 32, false); _22(out, part100); - const part101 = rt.intOverflowingAdd(a, o, 32, false); + const part101 = rs.intOverflowingAdd(a, o, 32, false); putPair(out, part101); - const part102 = rt.intOverflowingSub(a, o, 32, false); + const part102 = rs.intOverflowingSub(a, o, 32, false); putPair(out, part102); - const b2: rt.usize = o >>> 0; - const _118: rt.isize | undefined = rt.intCheckedSignedDiff(a, b2, 32, false) as rt.isize | undefined; + const b2: rs.usize = o >>> 0; + const _118: rs.isize | undefined = rs.intCheckedSignedDiff(a, b2, 32, false) as rs.isize | undefined; if (_118 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(_118))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(_118))); } - const iter: rt.Iter = rt.iterSlice([false, true]); + const iter: rs.Iter = rs.iterSlice([false, true]); while (true) { - const _127: boolean | rt.Done = iter.next(); - if (_127 === rt.DONE) { + const _127: boolean | rs.Done = iter.next(); + if (_127 === rs.DONE) { break; } const carry: boolean = _127; - const part103 = rt.intCarryingAdd(a, b2, carry, 32, false); + const part103 = rs.intCarryingAdd(a, b2, carry, 32, false); putPair(out, part103); - const part104 = rt.intBorrowingSub(a, b2, carry, 32, false); + const part104 = rs.intBorrowingSub(a, b2, carry, 32, false); putPair(out, part104); } - const _141: [rt.usize, rt.usize] = rt.intCarryingMul(a, b2, a, 32, false); - const lo: rt.usize = _141[0]; - const hi: rt.usize = _141[1]; + const _141: [rs.usize, rs.usize] = rs.intCarryingMul(a, b2, a, 32, false); + const lo: rs.usize = _141[0]; + const hi: rs.usize = _141[1]; _22(out, lo); _22(out, hi); - const _150: [rt.usize, rt.usize] = rt.intCarryingMulAdd(a, b2, b2, a, 32, false); - const lo2: rt.usize = _150[0]; - const hi2: rt.usize = _150[1]; + const _150: [rs.usize, rs.usize] = rs.intCarryingMulAdd(a, b2, b2, a, 32, false); + const lo2: rs.usize = _150[0]; + const hi2: rs.usize = _150[1]; _22(out, lo2); _22(out, hi2); - const part105 = rt.intCheckedNextMultipleOf(a, b2, 32, false); + const part105 = rs.intCheckedNextMultipleOf(a, b2, 32, false); putOpt(out, part105); } else if (_30 === 1) { - const part77 = rt.intCheckedDiv(a, b, 32, false); + const part77 = rs.intCheckedDiv(a, b, 32, false); putOpt(out, part77); - const part78 = rt.intCheckedRem(a, b, 32, false); + const part78 = rs.intCheckedRem(a, b, 32, false); putOpt(out, part78); - const part79 = rt.intCheckedDivEuclid(a, b, 32, false); + const part79 = rs.intCheckedDivEuclid(a, b, 32, false); putOpt(out, part79); - const part80 = rt.intCheckedRemEuclid(a, b, 32, false); + const part80 = rs.intCheckedRemEuclid(a, b, 32, false); putOpt(out, part80); if (b !== 0) { - const part81 = rt.usizeDivCeil(a, b); + const part81 = rs.usizeDivCeil(a, b); _22(out, part81); - rt.byteVecPush(out, rt.usizeIsMultipleOf(a, b) ? 1 : 0); + rs.byteVecPush(out, rs.usizeIsMultipleOf(a, b) ? 1 : 0); } } else if (_30 === 2) { - const part72 = rt.intCheckedNeg(a, 32, false); + const part72 = rs.intCheckedNeg(a, 32, false); putOpt(out, part72); - const part73 = rt.intWrappingNeg(a, 32, false); + const part73 = rs.intWrappingNeg(a, 32, false); _22(out, part73); - const part74 = rt.intOverflowingNeg(a, 32, false); + const part74 = rs.intOverflowingNeg(a, 32, false); putPair(out, part74); - rt.byteVecPush(out, rt.intIsPowerOfTwo(a, 32, false) ? 1 : 0); - const part75 = rt.intCheckedNextPowerOfTwo(a, 32, false); + rs.byteVecPush(out, rs.intIsPowerOfTwo(a, 32, false) ? 1 : 0); + const part75 = rs.intCheckedNextPowerOfTwo(a, 32, false); putOpt(out, part75); - const part76 = rt.intBitWidth(a, 32, false); + const part76 = rs.intBitWidth(a, 32, false); _27(out, part76); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(a | 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(a | 0))); } else if (_30 === 3) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _216: rt.u32 | rt.Done = iter2.next(); - if (_216 === rt.DONE) { + const _216: rs.u32 | rs.Done = iter2.next(); + if (_216 === rs.DONE) { break; } - const e: rt.u32 = _216; - const part68 = rt.intCheckedPow(a, e, 32, false); + const e: rs.u32 = _216; + const part68 = rs.intCheckedPow(a, e, 32, false); putOpt(out, part68); - const part69 = rt.intWrappingPow(a, e, 32, false); + const part69 = rs.intWrappingPow(a, e, 32, false); _22(out, part69); - const part70 = rt.intSaturatingPow(a, e, 32, false); + const part70 = rs.intSaturatingPow(a, e, 32, false); _22(out, part70); - const part71 = rt.intOverflowingPow(a, e, 32, false); + const part71 = rs.intOverflowingPow(a, e, 32, false); putPair(out, part71); } } else if (_30 === 4) { - const iter3: rt.Iter = rt.iterSlice([n, k]); + const iter3: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _239: rt.u32 | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: rs.u32 | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - const s: rt.u32 = _239; - const part58 = rt.intCheckedShl(a, s, 32, false); + const s: rs.u32 = _239; + const part58 = rs.intCheckedShl(a, s, 32, false); putOpt(out, part58); - const part59 = rt.intCheckedShr(a, s, 32, false); + const part59 = rs.intCheckedShr(a, s, 32, false); putOpt(out, part59); - const part60 = rt.intWrappingShl(a, s, 32, false); + const part60 = rs.intWrappingShl(a, s, 32, false); _22(out, part60); - const part61 = rt.intWrappingShr(a, s, 32, false); + const part61 = rs.intWrappingShr(a, s, 32, false); _22(out, part61); - const part62 = rt.intOverflowingShl(a, s, 32, false); + const part62 = rs.intOverflowingShl(a, s, 32, false); putPair(out, part62); - const part63 = rt.intOverflowingShr(a, s, 32, false); + const part63 = rs.intOverflowingShr(a, s, 32, false); putPair(out, part63); - const part64 = rt.intUnboundedShl(a, s, 32, false); + const part64 = rs.intUnboundedShl(a, s, 32, false); _22(out, part64); - const part65 = rt.intUnboundedShr(a, s, 32, false); + const part65 = rs.intUnboundedShr(a, s, 32, false); _22(out, part65); - const part66 = rt.intRotateLeft(a, s, 32, false); + const part66 = rs.intRotateLeft(a, s, 32, false); _22(out, part66); - const part67 = rt.intRotateRight(a, s, 32, false); + const part67 = rs.intRotateRight(a, s, 32, false); _22(out, part67); } } else if (_30 === 5) { - const iter4: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 32, false), rt.intCountZeros(a, 32, false), rt.usizeLeadingZeros(a), rt.usizeTrailingZeros(a), rt.usizeLeadingOnes(a), rt.intTrailingOnes(a, 32, false)]); + const iter4: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 32, false), rs.intCountZeros(a, 32, false), rs.usizeLeadingZeros(a), rs.usizeTrailingZeros(a), rs.usizeLeadingOnes(a), rs.intTrailingOnes(a, 32, false)]); while (true) { - const _292: rt.u32 | rt.Done = iter4.next(); - if (_292 === rt.DONE) { + const _292: rs.u32 | rs.Done = iter4.next(); + if (_292 === rs.DONE) { break; } _27(out, _292); } - const iter5: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 32, false), rt.intReverseBits(a, 32, false), rt.intSwapBytes(a, 32, false), a, rt.intSwapBytes(a, 32, false), a]); + const iter5: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 32, false), rs.intReverseBits(a, 32, false), rs.intSwapBytes(a, 32, false), a, rs.intSwapBytes(a, 32, false), a]); while (true) { - const _308: rt.usize | rt.Done = iter5.next(); - if (_308 === rt.DONE) { + const _308: rs.usize | rs.Done = iter5.next(); + if (_308 === rs.DONE) { break; } _22(out, _308); } - const part54 = rt.intHighestOne(a, 32, false); + const part54 = rs.intHighestOne(a, 32, false); putOptU32(out, part54); - const part55 = rt.intLowestOne(a, 32, false); + const part55 = rs.intLowestOne(a, 32, false); putOptU32(out, part55); - const part56 = rt.intIsolateHighestOne(a, 32, false); + const part56 = rs.intIsolateHighestOne(a, 32, false); _22(out, part56); - const part57 = rt.intIsolateLowestOne(a, 32, false); + const part57 = rs.intIsolateLowestOne(a, 32, false); _22(out, part57); _22(out, 4294967295); _22(out, 0); } else if (_30 === 6) { - const part51 = rt.intCheckedIlog(a, b, 32, false); + const part51 = rs.intCheckedIlog(a, b, 32, false); putOptU32(out, part51); - const part52 = rt.intCheckedIlog2(a, 32, false); + const part52 = rs.intCheckedIlog2(a, 32, false); putOptU32(out, part52); - const part53 = rt.intCheckedIlog10(a, 32, false); + const part53 = rs.intCheckedIlog10(a, 32, false); putOptU32(out, part53); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.intAbsDiff(a, b, 32, false) as rt.usize))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.intAbsDiff(a, b, 32, false) as rs.usize))); } else if (_30 === 7) { - const part50 = rt.intPow(a, k, 32, false); + const part50 = rs.intPow(a, k, 32, false); _22(out, part50); } else if (_30 === 8) { - const part49 = rt.intPow(a, n, 32, false); + const part49 = rs.intPow(a, n, 32, false); _22(out, part49); } else if (_30 === 9) { - const part48 = rt.intDivEuclid(a, b, 32, false); + const part48 = rs.intDivEuclid(a, b, 32, false); _22(out, part48); } else if (_30 === 10) { - const part47 = rt.intRemEuclid(a, b, 32, false); + const part47 = rs.intRemEuclid(a, b, 32, false); _22(out, part47); } else if (_30 === 11) { - const part46 = rt.intIsqrt(a, 32, false); + const part46 = rs.intIsqrt(a, 32, false); _22(out, part46); } else if (_30 === 12) { - const part45 = rt.intIlog(a, b, 32, false); + const part45 = rs.intIlog(a, b, 32, false); _27(out, part45); } else if (_30 === 13) { - const part44 = rt.intIlog2(a, 32, false); + const part44 = rs.intIlog2(a, 32, false); _27(out, part44); } else if (_30 === 14) { - const part43 = rt.intIlog10(a, 32, false); + const part43 = rs.intIlog10(a, 32, false); _27(out, part43); } else if (_30 === 15) { - _22(out, rt.usizeAdd(a, b)); + _22(out, rs.usizeAdd(a, b)); } else if (_30 === 16) { - _22(out, rt.usizeSub(a, b)); + _22(out, rs.usizeSub(a, b)); } else if (_30 === 17) { - _22(out, rt.usizeMul(a, b)); + _22(out, rs.usizeMul(a, b)); } else if (_30 === 18) { - _22(out, rt.usizeDiv(a, b)); + _22(out, rs.usizeDiv(a, b)); } else if (_30 === 19) { - _22(out, rt.usizeRem(a, b)); + _22(out, rs.usizeRem(a, b)); } else if (_30 === 20) { - const part37 = rt.intStrictNeg(a, 32, false); + const part37 = rs.intStrictNeg(a, 32, false); _22(out, part37); } else if (_30 === 21) { - _22(out, rt.usizeShl(a, k)); + _22(out, rs.usizeShl(a, k)); } else if (_30 === 22) { - _22(out, rt.usizeShr(a, k)); + _22(out, rs.usizeShr(a, k)); } else if (_30 === 23) { - const part34 = rt.intPow(a, k, 32, false); + const part34 = rs.intPow(a, k, 32, false); _22(out, part34); } else if (_30 === 24) { - const part33 = rt.intDivEuclid(a, b, 32, false); + const part33 = rs.intDivEuclid(a, b, 32, false); _22(out, part33); } else if (_30 === 25) { - const part32 = rt.intRemEuclid(a, b, 32, false); + const part32 = rs.intRemEuclid(a, b, 32, false); _22(out, part32); } else if (_30 === 26) { - const part31 = rt.intStrictAdd(a, o, 32, false); + const part31 = rs.intStrictAdd(a, o, 32, false); _22(out, part31); } else if (_30 === 27) { - const part30 = rt.intStrictSub(a, o, 32, false); + const part30 = rs.intStrictSub(a, o, 32, false); _22(out, part30); } else if (_30 === 28) { - _22(out, rt.usizeDiv(a, b)); + _22(out, rs.usizeDiv(a, b)); } else if (_30 === 29) { - _22(out, rt.usizeRem(a, b)); + _22(out, rs.usizeRem(a, b)); } else if (_30 === 30) { - const part27 = rt.intWrappingDivEuclid(a, b, 32, false); + const part27 = rs.intWrappingDivEuclid(a, b, 32, false); _22(out, part27); } else if (_30 === 31) { - const part26 = rt.intWrappingRemEuclid(a, b, 32, false); + const part26 = rs.intWrappingRemEuclid(a, b, 32, false); _22(out, part26); } else if (_30 === 32) { - const part25 = rt.intOverflowingDiv(a, b, 32, false); + const part25 = rs.intOverflowingDiv(a, b, 32, false); putPair(out, part25); } else if (_30 === 33) { - const part24 = rt.intOverflowingRem(a, b, 32, false); + const part24 = rs.intOverflowingRem(a, b, 32, false); putPair(out, part24); } else if (_30 === 34) { - const part23 = rt.intOverflowingDivEuclid(a, b, 32, false); + const part23 = rs.intOverflowingDivEuclid(a, b, 32, false); putPair(out, part23); } else if (_30 === 35) { - const part22 = rt.intOverflowingRemEuclid(a, b, 32, false); + const part22 = rs.intOverflowingRemEuclid(a, b, 32, false); putPair(out, part22); } else if (_30 === 36) { - _22(out, rt.usizeDiv(a, b)); + _22(out, rs.usizeDiv(a, b)); } else if (_30 === 37) { - const part20 = rt.intNextPowerOfTwo(a, 32, false); + const part20 = rs.intNextPowerOfTwo(a, 32, false); _22(out, part20); } else if (_30 === 38) { - const _449: rt.u32 = rt.u32Rem(k, 3); + const _449: rs.u32 = rs.u32Rem(k, 3); if (_449 === 0) { - const part19 = rt.intNextMultipleOf(a, b, 32, false); + const part19 = rs.intNextMultipleOf(a, b, 32, false); _22(out, part19); } else if (_449 === 1) { - const part18 = rt.intFunnelShl(a, b, k, 32, false); + const part18 = rs.intFunnelShl(a, b, k, 32, false); _22(out, part18); } else { - const part17 = rt.intFunnelShr(a, b, k, 32, false); + const part17 = rs.intFunnelShr(a, b, k, 32, false); _22(out, part17); } } else if (_30 === 39) { - const s2: rt.usize = a; - const w: rt.usize = a; - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 32, false), rt.intCountZeros(s2, 32, false), rt.usizeLeadingZeros(s2), rt.usizeTrailingZeros(s2)]); + const s2: rs.usize = a; + const w: rs.usize = a; + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 32, false), rs.intCountZeros(s2, 32, false), rs.usizeLeadingZeros(s2), rs.usizeTrailingZeros(s2)]); while (true) { - const _472: rt.u32 | rt.Done = iter6.next(); - if (_472 === rt.DONE) { + const _472: rs.u32 | rs.Done = iter6.next(); + if (_472 === rs.DONE) { break; } _27(out, _472); } - const iter7: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 32, false), rt.intCountZeros(w, 32, false), rt.usizeLeadingZeros(w), rt.usizeTrailingZeros(w)]); + const iter7: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 32, false), rs.intCountZeros(w, 32, false), rs.usizeLeadingZeros(w), rs.usizeTrailingZeros(w)]); while (true) { - const _486: rt.u32 | rt.Done = iter7.next(); - if (_486 === rt.DONE) { + const _486: rs.u32 | rs.Done = iter7.next(); + if (_486 === rs.DONE) { break; } _27(out, _486); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 32, false), rt.intRotateRight(s2, n, 32, false), rt.intSwapBytes(s2, 32, false), rt.intReverseBits(s2, 32, false), rt.intSwapBytes(s2, 32, false), s2, rt.intSwapBytes(s2, 32, false), s2, rt.intSaturatingPow(s2, k, 32, false), rt.intSaturatingPow(s2, n, 32, false)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 32, false), rs.intRotateRight(s2, n, 32, false), rs.intSwapBytes(s2, 32, false), rs.intReverseBits(s2, 32, false), rs.intSwapBytes(s2, 32, false), s2, rs.intSwapBytes(s2, 32, false), s2, rs.intSaturatingPow(s2, k, 32, false), rs.intSaturatingPow(s2, n, 32, false)]); while (true) { - const _506: rt.usize | rt.Done = iter8.next(); - if (_506 === rt.DONE) { + const _506: rs.usize | rs.Done = iter8.next(); + if (_506 === rs.DONE) { break; } _22(out, _506); } - const iter9: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 32, false), rt.intRotateRight(w, n, 32, false), rt.intSwapBytes(w, 32, false), rt.intReverseBits(w, 32, false), rt.intSwapBytes(w, 32, false), w, rt.intSwapBytes(w, 32, false), w, rt.intWrappingPow(w, k, 32, false), rt.intWrappingPow(w, n, 32, false)]); + const iter9: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 32, false), rs.intRotateRight(w, n, 32, false), rs.intSwapBytes(w, 32, false), rs.intReverseBits(w, 32, false), rs.intSwapBytes(w, 32, false), w, rs.intSwapBytes(w, 32, false), w, rs.intWrappingPow(w, k, 32, false), rs.intWrappingPow(w, n, 32, false)]); while (true) { - const _527: rt.usize | rt.Done = iter9.next(); - if (_527 === rt.DONE) { + const _527: rs.usize | rs.Done = iter9.next(); + if (_527 === rs.DONE) { break; } _22(out, _527); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.intIsPowerOfTwo(s2, 32, false) ? 1 : 0, rt.intIsPowerOfTwo(w, 32, false) ? 1 : 0))); - const part16 = rt.intWrappingNextPowerOfTwo(w, 32, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.intIsPowerOfTwo(s2, 32, false) ? 1 : 0, rs.intIsPowerOfTwo(w, 32, false) ? 1 : 0))); + const part16 = rs.intWrappingNextPowerOfTwo(w, 32, false); _22(out, part16); } else if (_30 === 40) { - const _548: [rt.usize | undefined, rt.usize | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _548: [rs.usize | undefined, rs.usize | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_548[0] !== undefined) { if (_548[1] !== undefined) { - const x: rt.usize = _548[0]; - const y: rt.usize = _548[1]; - const iter10: rt.Iter = rt.iterSlice([rt.usizeLeadingZeros(x), rt.usizeTrailingZeros(x), rt.intCountOnes(x, 32, false), 31 - rt.usizeLeadingZeros(x), rt.usizeTrailingZeros(x)]); + const x: rs.usize = _548[0]; + const y: rs.usize = _548[1]; + const iter10: rs.Iter = rs.iterSlice([rs.usizeLeadingZeros(x), rs.usizeTrailingZeros(x), rs.intCountOnes(x, 32, false), 31 - rs.usizeLeadingZeros(x), rs.usizeTrailingZeros(x)]); while (true) { - const _564: rt.u32 | rt.Done = iter10.next(); - if (_564 === rt.DONE) { + const _564: rs.u32 | rs.Done = iter10.next(); + if (_564 === rs.DONE) { break; } _27(out, _564); } - const part3 = option_map$08v2q5m(rt.usizeCheckedMul(x, y), (a0: rt.usize): rt.usize => { + const part3 = option_map$07b2cw7(rs.usizeCheckedMul(x, y), (a0: rs.usize): rs.usize => { return a0; }); putOpt(out, part3); - const part4 = rt.usizeSaturatingMul(x, y); + const part4 = rs.usizeSaturatingMul(x, y); _22(out, part4); - const part5 = option_map$08v2q5m(rt.intCheckedPow(x, k, 32, false), (a02: rt.usize): rt.usize => { + const part5 = option_map$07b2cw7(rs.intCheckedPow(x, k, 32, false), (a02: rs.usize): rs.usize => { return a02; }); putOpt(out, part5); - const part6 = option_map$08v2q5m(rt.intCheckedPow(x, n, 32, false), (a03: rt.usize): rt.usize => { + const part6 = option_map$07b2cw7(rs.intCheckedPow(x, n, 32, false), (a03: rs.usize): rs.usize => { return a03; }); putOpt(out, part6); - const part7 = rt.intSaturatingPow(x, k, 32, false); + const part7 = rs.intSaturatingPow(x, k, 32, false); _22(out, part7); - const part8 = rt.intIsolateHighestOne(x, 32, false); + const part8 = rs.intIsolateHighestOne(x, 32, false); _22(out, part8); - const part9 = rt.intIsolateLowestOne(x, 32, false); + const part9 = rs.intIsolateLowestOne(x, 32, false); _22(out, part9); - rt.byteVecPush(out, rt.intIsPowerOfTwo(x, 32, false) ? 1 : 0); - const part10 = option_map$08v2q5m(rt.usizeCheckedAdd(x, b), (a04: rt.usize): rt.usize => { + rs.byteVecPush(out, rs.intIsPowerOfTwo(x, 32, false) ? 1 : 0); + const part10 = option_map$07b2cw7(rs.usizeCheckedAdd(x, b), (a04: rs.usize): rs.usize => { return a04; }); putOpt(out, part10); - const part11 = rt.usizeSaturatingAdd(x, b); + const part11 = rs.usizeSaturatingAdd(x, b); _22(out, part11); - const part12 = option_map$08v2q5m(rt.intCheckedNextPowerOfTwo(x, 32, false), (a05: rt.usize): rt.usize => { + const part12 = option_map$07b2cw7(rs.intCheckedNextPowerOfTwo(x, 32, false), (a05: rs.usize): rs.usize => { return a05; }); putOpt(out, part12); - const iter11: rt.Iter = rt.iterSlice([rt.intIlog2(x, 32, false), rt.intIlog10(x, 32, false), rt.intBitWidth(x, 32, false)]); + const iter11: rs.Iter = rs.iterSlice([rs.intIlog2(x, 32, false), rs.intIlog10(x, 32, false), rs.intBitWidth(x, 32, false)]); while (true) { - const _631: rt.u32 | rt.Done = iter11.next(); - if (_631 === rt.DONE) { + const _631: rs.u32 | rs.Done = iter11.next(); + if (_631 === rs.DONE) { break; } _27(out, _631); } - const part13 = rt.intMidpoint(x, y, 32, false); + const part13 = rs.intMidpoint(x, y, 32, false); _22(out, part13); - const part14 = rt.intIsqrt(x, 32, false); + const part14 = rs.intIsqrt(x, 32, false); _22(out, part14); - const part15 = rt.usizeDivCeil(x, y); + const part15 = rs.usizeDivCeil(x, y); _22(out, part15); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(x | 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(x | 0))); } } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v8: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v8))); - rt.byteVecPush(out2, rt.i8FromBeBytes(rt.i8ToBeBytes(v8)) === v8 ? 1 : 0); +export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v8: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i8FromBeBytes(rs.i8ToBeBytes(v8)) === v8 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.i8 = rt.i8FromBeBytes(rt.bytesFromFn(1, (i2: rt.usize): rt.u8 => { + const a: rs.i8 = rs.i8FromBeBytes(rs.bytesFromFn(1, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.i8 = rt.i8FromBeBytes(rt.bytesFromFn(1, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(1, i3)); + const b: rs.i8 = rs.i8FromBeBytes(rs.bytesFromFn(1, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(1, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 1, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 1, i4)); })); - const o: rt.u8 = b & 0xff; - const k: rt.u32 = rt.u32Rem(n, 3 * 8); - const putOpt: (a0: rt.ByteVec, a1: rt.i8 | undefined) => undefined = (out4: rt.ByteVec, v10: rt.i8 | undefined): undefined => { + const o: rs.u8 = b & 0xff; + const k: rs.u32 = rs.u32Rem(n, 3 * 8); + const putOpt: (a0: rs.ByteVec, a1: rs.i8 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i8 | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.i8 = v10; - rt.byteVecPush(out4, 1); + const v11: rs.i8 = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.i8, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.i8, boolean]): undefined => { - const v12: rt.i8 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i8, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i8, boolean]): undefined => { + const v12: rs.i8 = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.i8CheckedAdd(a, b); + const part88 = rs.i8CheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.i8CheckedSub(a, b); + const part89 = rs.i8CheckedSub(a, b); putOpt(out, part89); - const part90 = rt.i8CheckedMul(a, b); + const part90 = rs.i8CheckedMul(a, b); putOpt(out, part90); - const part91 = rt.i8SaturatingAdd(a, b); + const part91 = rs.i8SaturatingAdd(a, b); _22(out, part91); - const part92 = rt.i8SaturatingSub(a, b); + const part92 = rs.i8SaturatingSub(a, b); _22(out, part92); - const part93 = rt.i8SaturatingMul(a, b); + const part93 = rs.i8SaturatingMul(a, b); _22(out, part93); - const part94 = rt.i8WrappingAdd(a, b); + const part94 = rs.i8WrappingAdd(a, b); _22(out, part94); - const part95 = rt.i8WrappingSub(a, b); + const part95 = rs.i8WrappingSub(a, b); _22(out, part95); - const part96 = rt.i8WrappingMul(a, b); + const part96 = rs.i8WrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 8, true); + const part97 = rs.intOverflowingAdd(a, b, 8, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 8, true); + const part98 = rs.intOverflowingSub(a, b, 8, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 8, true); + const part99 = rs.intOverflowingMul(a, b, 8, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 8, true); + const part100 = rs.intMidpoint(a, b, 8, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 8, true); + const part101 = rs.intCheckedAdd(a, o, 8, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 8, true); + const part102 = rs.intCheckedSub(a, o, 8, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 8, true); + const part103 = rs.intSaturatingAdd(a, o, 8, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 8, true); + const part104 = rs.intSaturatingSub(a, o, 8, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 8, true); + const part105 = rs.intWrappingAdd(a, o, 8, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 8, true); + const part106 = rs.intWrappingSub(a, o, 8, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 8, true); + const part107 = rs.intOverflowingAdd(a, o, 8, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 8, true); + const part108 = rs.intOverflowingSub(a, o, 8, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 8, true); + const part80 = rs.intCheckedDiv(a, b, 8, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 8, true); + const part81 = rs.intCheckedRem(a, b, 8, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 8, true); + const part82 = rs.intCheckedDivEuclid(a, b, 8, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 8, true); + const part83 = rs.intCheckedRemEuclid(a, b, 8, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.i8WrappingDiv(a, b); + const part84 = rs.i8WrappingDiv(a, b); _22(out, part84); - const part85 = rt.i8WrappingRem(a, b); + const part85 = rs.i8WrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 8, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 8, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 8, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 8, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 8, true); + const part70 = rs.intCheckedNeg(a, 8, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 8, true); + const part71 = rs.intWrappingNeg(a, 8, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 8, true); + const part72 = rs.intOverflowingNeg(a, 8, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 8, true); + const part73 = rs.intCheckedAbs(a, 8, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 8, true); + const part74 = rs.intWrappingAbs(a, 8, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 8, true); + const part75 = rs.intSaturatingAbs(a, 8, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 8, true); + const part76 = rs.intOverflowingAbs(a, 8, true); putPair(out, part76); - const part77 = rt.i8SaturatingSub(0, a); + const part77 = rs.i8SaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 8, true); + const part78 = rs.intSignum(a, 8, true); _22(out, part78); - rt.byteVecPush(out, a > 0 ? 1 : 0); - rt.byteVecPush(out, a < 0 ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 8, true); + rs.byteVecPush(out, a > 0 ? 1 : 0); + rs.byteVecPush(out, a < 0 ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 8, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.intUnsignedAbs(a, 8, true) as rt.u8))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(a & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.intUnsignedAbs(a, 8, true) as rs.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(a & 0xff))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 8, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 8, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 8, true); + const part67 = rs.intWrappingPow(a, e, 8, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 8, true); + const part68 = rs.intSaturatingPow(a, e, 8, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 8, true); + const part69 = rs.intOverflowingPow(a, e, 8, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 8, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 8, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 8, true); + const part57 = rs.intCheckedShr(a, s, 8, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 8, true); + const part58 = rs.intWrappingShl(a, s, 8, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 8, true); + const part59 = rs.intWrappingShr(a, s, 8, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 8, true); + const part60 = rs.intOverflowingShl(a, s, 8, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 8, true); + const part61 = rs.intOverflowingShr(a, s, 8, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 8, true); + const part62 = rs.intUnboundedShl(a, s, 8, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 8, true); + const part63 = rs.intUnboundedShr(a, s, 8, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 8, true); + const part64 = rs.intRotateLeft(a, s, 8, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 8, true); + const part65 = rs.intRotateRight(a, s, 8, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 8, true), rt.intCountZeros(a, 8, true), rt.i8LeadingZeros(a), rt.i8TrailingZeros(a), rt.i8LeadingOnes(a), rt.intTrailingOnes(a, 8, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 8, true), rs.intCountZeros(a, 8, true), rs.i8LeadingZeros(a), rs.i8TrailingZeros(a), rs.i8LeadingOnes(a), rs.intTrailingOnes(a, 8, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 8, true), rt.intReverseBits(a, 8, true), rt.intSwapBytes(a, 8, true), a, rt.intSwapBytes(a, 8, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 8, true), rs.intReverseBits(a, 8, true), rs.intSwapBytes(a, 8, true), a, rs.intSwapBytes(a, 8, true), a]); while (true) { - const _300: rt.i8 | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.i8 | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 8, true); + const part52 = rs.intHighestOne(a, 8, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 8, true); + const part53 = rs.intLowestOne(a, 8, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 8, true); + const part54 = rs.intIsolateHighestOne(a, 8, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 8, true); + const part55 = rs.intIsolateLowestOne(a, 8, true); _22(out, part55); _22(out, 127); _22(out, -128); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 8, true); + const part49 = rs.intCheckedIlog(a, b, 8, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 8, true); + const part50 = rs.intCheckedIlog2(a, 8, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 8, true); + const part51 = rs.intCheckedIlog10(a, 8, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.intAbsDiff(a, b, 8, true) as rt.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.intAbsDiff(a, b, 8, true) as rs.u8))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 8, true); + const part48 = rs.intPow(a, k, 8, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 8, true); + const part47 = rs.intPow(a, n, 8, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 8, true); + const part46 = rs.intDivEuclid(a, b, 8, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 8, true); + const part45 = rs.intRemEuclid(a, b, 8, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 8, true); + const part44 = rs.intIsqrt(a, 8, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 8, true); + const part43 = rs.intIlog(a, b, 8, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 8, true); + const part42 = rs.intIlog2(a, 8, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 8, true); + const part41 = rs.intIlog10(a, 8, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.i8Add(a, b)); + _22(out, rs.i8Add(a, b)); } else if (_30 === 16) { - _22(out, rt.i8Sub(a, b)); + _22(out, rs.i8Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.i8Mul(a, b)); + _22(out, rs.i8Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.i8Div(a, b)); + _22(out, rs.i8Div(a, b)); } else if (_30 === 19) { - _22(out, rt.i8Rem(a, b)); + _22(out, rs.i8Rem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 8, true); + const part35 = rs.intStrictNeg(a, 8, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.i8Shl(a, k)); + _22(out, rs.i8Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.i8Shr(a, k)); + _22(out, rs.i8Shr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 8, true); + const part32 = rs.intPow(a, k, 8, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 8, true); + const part31 = rs.intDivEuclid(a, b, 8, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 8, true); + const part30 = rs.intRemEuclid(a, b, 8, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 8, true); + const part29 = rs.intStrictAdd(a, o, 8, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 8, true); + const part28 = rs.intStrictSub(a, o, 8, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.i8WrappingDiv(a, b); + const part27 = rs.i8WrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.i8WrappingRem(a, b); + const part26 = rs.i8WrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 8, true); + const part25 = rs.intWrappingDivEuclid(a, b, 8, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 8, true); + const part24 = rs.intWrappingRemEuclid(a, b, 8, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 8, true); + const part23 = rs.intOverflowingDiv(a, b, 8, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 8, true); + const part22 = rs.intOverflowingRem(a, b, 8, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 8, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 8, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 8, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 8, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.i8SaturatingDiv(a, b); + const part19 = rs.i8SaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 8, true); + const part18 = rs.intAbs(a, 8, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 8, true); + const part17 = rs.intAbs(a, 8, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.i8 = a; - const w: rt.i8 = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 8, true), rt.intCountZeros(s2, 8, true), rt.i8LeadingZeros(s2), rt.i8TrailingZeros(s2)]); + const s2: rs.i8 = a; + const w: rs.i8 = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 8, true), rs.intCountZeros(s2, 8, true), rs.i8LeadingZeros(s2), rs.i8TrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 8, true), rt.intCountZeros(w, 8, true), rt.i8LeadingZeros(w), rt.i8TrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 8, true), rs.intCountZeros(w, 8, true), rs.i8LeadingZeros(w), rs.i8TrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 8, true), rt.intRotateRight(s2, n, 8, true), rt.intSwapBytes(s2, 8, true), rt.intReverseBits(s2, 8, true), rt.intSwapBytes(s2, 8, true), s2, rt.intSwapBytes(s2, 8, true), s2, rt.intSaturatingPow(s2, k, 8, true), rt.intSaturatingPow(s2, n, 8, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 8, true), rs.intRotateRight(s2, n, 8, true), rs.intSwapBytes(s2, 8, true), rs.intReverseBits(s2, 8, true), rs.intSwapBytes(s2, 8, true), s2, rs.intSwapBytes(s2, 8, true), s2, rs.intSaturatingPow(s2, k, 8, true), rs.intSaturatingPow(s2, n, 8, true)]); while (true) { - const _490: rt.i8 | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.i8 | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 8, true), rt.intRotateRight(w, n, 8, true), rt.intSwapBytes(w, 8, true), rt.intReverseBits(w, 8, true), rt.intSwapBytes(w, 8, true), w, rt.intSwapBytes(w, 8, true), w, rt.intWrappingPow(w, k, 8, true), rt.intWrappingPow(w, n, 8, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 8, true), rs.intRotateRight(w, n, 8, true), rs.intSwapBytes(w, 8, true), rs.intReverseBits(w, 8, true), rs.intSwapBytes(w, 8, true), w, rs.intSwapBytes(w, 8, true), w, rs.intWrappingPow(w, k, 8, true), rs.intWrappingPow(w, n, 8, true)]); while (true) { - const _511: rt.i8 | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.i8 | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 8, true), rt.intSignum(s2, 8, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 8, true), rs.intSignum(s2, 8, true)]); while (true) { - const _524: rt.i8 | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.i8 | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 8, true), rt.intSignum(w, 8, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 8, true), rs.intSignum(w, 8, true)]); while (true) { - const _537: rt.i8 | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.i8 | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.i8 | undefined, rt.i8 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.i8 | undefined, rs.i8 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.i8 = _557[0]; - const y: rt.i8 = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.i8LeadingZeros(x), rt.i8TrailingZeros(x), rt.intCountOnes(x, 8, true), 7 - rt.i8LeadingZeros(x), rt.i8TrailingZeros(x)]); + const x: rs.i8 = _557[0]; + const y: rs.i8 = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.i8LeadingZeros(x), rs.i8TrailingZeros(x), rs.intCountOnes(x, 8, true), 7 - rs.i8LeadingZeros(x), rs.i8TrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$1u19ipa(rt.i8CheckedMul(x, y), (a0: rt.i8): rt.i8 => { + const part4 = option_map$1hwn965(rs.i8CheckedMul(x, y), (a0: rs.i8): rs.i8 => { return a0; }); putOpt(out, part4); - const part5 = rt.i8SaturatingMul(x, y); + const part5 = rs.i8SaturatingMul(x, y); _22(out, part5); - const part6 = option_map$1u19ipa(rt.intCheckedPow(x, k, 8, true), (a02: rt.i8): rt.i8 => { + const part6 = option_map$1hwn965(rs.intCheckedPow(x, k, 8, true), (a02: rs.i8): rs.i8 => { return a02; }); putOpt(out, part6); - const part7 = option_map$1u19ipa(rt.intCheckedPow(x, n, 8, true), (a03: rt.i8): rt.i8 => { + const part7 = option_map$1hwn965(rs.intCheckedPow(x, n, 8, true), (a03: rs.i8): rs.i8 => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 8, true); + const part8 = rs.intSaturatingPow(x, k, 8, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 8, true); + const part9 = rs.intIsolateHighestOne(x, 8, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 8, true); + const part10 = rs.intIsolateLowestOne(x, 8, true); _22(out, part10); - const part11 = option_map$1u19ipa(rt.intCheckedAbs(x, 8, true), (a04: rt.i8): rt.i8 => { + const part11 = option_map$1hwn965(rs.intCheckedAbs(x, 8, true), (a04: rs.i8): rs.i8 => { return a04; }); putOpt(out, part11); - const _622: [rt.i8, boolean] = rt.intOverflowingAbs(x, 8, true); - putPair(out, [_622[0], _622[1]] as [rt.i8, boolean]); - const part12 = rt.intSaturatingAbs(x, 8, true); + const _622: [rs.i8, boolean] = rs.intOverflowingAbs(x, 8, true); + putPair(out, [_622[0], _622[1]] as [rs.i8, boolean]); + const part12 = rs.intSaturatingAbs(x, 8, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 8, true); + const part13 = rs.intWrappingAbs(x, 8, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.intUnsignedAbs(x, 8, true) as rt.u8))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); - const part14 = option_map$1u19ipa(rt.intCheckedNeg(x, 8, true), (a05: rt.i8): rt.i8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.intUnsignedAbs(x, 8, true) as rs.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); + const part14 = option_map$1hwn965(rs.intCheckedNeg(x, 8, true), (a05: rs.i8): rs.i8 => { return a05; }); putOpt(out, part14); - const _659: [rt.i8, boolean] = rt.intOverflowingNeg(x, 8, true); - putPair(out, [_659[0], _659[1]] as [rt.i8, boolean]); - const part15 = rt.i8SaturatingSub(0, x); + const _659: [rs.i8, boolean] = rs.intOverflowingNeg(x, 8, true); + putPair(out, [_659[0], _659[1]] as [rs.i8, boolean]); + const part15 = rs.i8SaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 8, true); + const part16 = rs.intWrappingNeg(x, 8, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(x & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(x & 0xff))); } } } else { - const _681: rt.i8 | undefined = rt.nonZero(a); + const _681: rs.i8 | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 8, true); + const part3 = rs.intAbs(_681, 8, true); _22(out, part3); } } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v8: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v8))); - rt.byteVecPush(out2, rt.i16FromBeBytes(rt.i16ToBeBytes(v8)) === v8 ? 1 : 0); +export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v8: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i16FromBeBytes(rs.i16ToBeBytes(v8)) === v8 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.i16 = rt.i16FromBeBytes(rt.bytesFromFn(2, (i2: rt.usize): rt.u8 => { + const a: rs.i16 = rs.i16FromBeBytes(rs.bytesFromFn(2, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.i16 = rt.i16FromBeBytes(rt.bytesFromFn(2, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2, i3)); + const b: rs.i16 = rs.i16FromBeBytes(rs.bytesFromFn(2, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 2, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 2, i4)); })); - const o: rt.u16 = b & 0xffff; - const k: rt.u32 = rt.u32Rem(n, 3 * 16); - const putOpt: (a0: rt.ByteVec, a1: rt.i16 | undefined) => undefined = (out4: rt.ByteVec, v10: rt.i16 | undefined): undefined => { + const o: rs.u16 = b & 0xffff; + const k: rs.u32 = rs.u32Rem(n, 3 * 16); + const putOpt: (a0: rs.ByteVec, a1: rs.i16 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i16 | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.i16 = v10; - rt.byteVecPush(out4, 1); + const v11: rs.i16 = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.i16, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.i16, boolean]): undefined => { - const v12: rt.i16 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i16, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i16, boolean]): undefined => { + const v12: rs.i16 = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.i16CheckedAdd(a, b); + const part88 = rs.i16CheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.i16CheckedSub(a, b); + const part89 = rs.i16CheckedSub(a, b); putOpt(out, part89); - const part90 = rt.i16CheckedMul(a, b); + const part90 = rs.i16CheckedMul(a, b); putOpt(out, part90); - const part91 = rt.i16SaturatingAdd(a, b); + const part91 = rs.i16SaturatingAdd(a, b); _22(out, part91); - const part92 = rt.i16SaturatingSub(a, b); + const part92 = rs.i16SaturatingSub(a, b); _22(out, part92); - const part93 = rt.i16SaturatingMul(a, b); + const part93 = rs.i16SaturatingMul(a, b); _22(out, part93); - const part94 = rt.i16WrappingAdd(a, b); + const part94 = rs.i16WrappingAdd(a, b); _22(out, part94); - const part95 = rt.i16WrappingSub(a, b); + const part95 = rs.i16WrappingSub(a, b); _22(out, part95); - const part96 = rt.i16WrappingMul(a, b); + const part96 = rs.i16WrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 16, true); + const part97 = rs.intOverflowingAdd(a, b, 16, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 16, true); + const part98 = rs.intOverflowingSub(a, b, 16, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 16, true); + const part99 = rs.intOverflowingMul(a, b, 16, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 16, true); + const part100 = rs.intMidpoint(a, b, 16, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 16, true); + const part101 = rs.intCheckedAdd(a, o, 16, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 16, true); + const part102 = rs.intCheckedSub(a, o, 16, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 16, true); + const part103 = rs.intSaturatingAdd(a, o, 16, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 16, true); + const part104 = rs.intSaturatingSub(a, o, 16, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 16, true); + const part105 = rs.intWrappingAdd(a, o, 16, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 16, true); + const part106 = rs.intWrappingSub(a, o, 16, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 16, true); + const part107 = rs.intOverflowingAdd(a, o, 16, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 16, true); + const part108 = rs.intOverflowingSub(a, o, 16, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 16, true); + const part80 = rs.intCheckedDiv(a, b, 16, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 16, true); + const part81 = rs.intCheckedRem(a, b, 16, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 16, true); + const part82 = rs.intCheckedDivEuclid(a, b, 16, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 16, true); + const part83 = rs.intCheckedRemEuclid(a, b, 16, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.i16WrappingDiv(a, b); + const part84 = rs.i16WrappingDiv(a, b); _22(out, part84); - const part85 = rt.i16WrappingRem(a, b); + const part85 = rs.i16WrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 16, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 16, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 16, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 16, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 16, true); + const part70 = rs.intCheckedNeg(a, 16, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 16, true); + const part71 = rs.intWrappingNeg(a, 16, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 16, true); + const part72 = rs.intOverflowingNeg(a, 16, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 16, true); + const part73 = rs.intCheckedAbs(a, 16, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 16, true); + const part74 = rs.intWrappingAbs(a, 16, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 16, true); + const part75 = rs.intSaturatingAbs(a, 16, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 16, true); + const part76 = rs.intOverflowingAbs(a, 16, true); putPair(out, part76); - const part77 = rt.i16SaturatingSub(0, a); + const part77 = rs.i16SaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 16, true); + const part78 = rs.intSignum(a, 16, true); _22(out, part78); - rt.byteVecPush(out, a > 0 ? 1 : 0); - rt.byteVecPush(out, a < 0 ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 16, true); + rs.byteVecPush(out, a > 0 ? 1 : 0); + rs.byteVecPush(out, a < 0 ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 16, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.intUnsignedAbs(a, 16, true) as rt.u16))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a & 0xffff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.intUnsignedAbs(a, 16, true) as rs.u16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(a & 0xffff))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 16, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 16, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 16, true); + const part67 = rs.intWrappingPow(a, e, 16, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 16, true); + const part68 = rs.intSaturatingPow(a, e, 16, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 16, true); + const part69 = rs.intOverflowingPow(a, e, 16, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 16, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 16, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 16, true); + const part57 = rs.intCheckedShr(a, s, 16, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 16, true); + const part58 = rs.intWrappingShl(a, s, 16, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 16, true); + const part59 = rs.intWrappingShr(a, s, 16, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 16, true); + const part60 = rs.intOverflowingShl(a, s, 16, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 16, true); + const part61 = rs.intOverflowingShr(a, s, 16, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 16, true); + const part62 = rs.intUnboundedShl(a, s, 16, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 16, true); + const part63 = rs.intUnboundedShr(a, s, 16, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 16, true); + const part64 = rs.intRotateLeft(a, s, 16, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 16, true); + const part65 = rs.intRotateRight(a, s, 16, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 16, true), rt.intCountZeros(a, 16, true), rt.i16LeadingZeros(a), rt.i16TrailingZeros(a), rt.i16LeadingOnes(a), rt.intTrailingOnes(a, 16, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 16, true), rs.intCountZeros(a, 16, true), rs.i16LeadingZeros(a), rs.i16TrailingZeros(a), rs.i16LeadingOnes(a), rs.intTrailingOnes(a, 16, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 16, true), rt.intReverseBits(a, 16, true), rt.intSwapBytes(a, 16, true), a, rt.intSwapBytes(a, 16, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 16, true), rs.intReverseBits(a, 16, true), rs.intSwapBytes(a, 16, true), a, rs.intSwapBytes(a, 16, true), a]); while (true) { - const _300: rt.i16 | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.i16 | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 16, true); + const part52 = rs.intHighestOne(a, 16, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 16, true); + const part53 = rs.intLowestOne(a, 16, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 16, true); + const part54 = rs.intIsolateHighestOne(a, 16, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 16, true); + const part55 = rs.intIsolateLowestOne(a, 16, true); _22(out, part55); _22(out, 32767); _22(out, -32768); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 16, true); + const part49 = rs.intCheckedIlog(a, b, 16, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 16, true); + const part50 = rs.intCheckedIlog2(a, 16, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 16, true); + const part51 = rs.intCheckedIlog10(a, 16, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.intAbsDiff(a, b, 16, true) as rt.u16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.intAbsDiff(a, b, 16, true) as rs.u16))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 16, true); + const part48 = rs.intPow(a, k, 16, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 16, true); + const part47 = rs.intPow(a, n, 16, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 16, true); + const part46 = rs.intDivEuclid(a, b, 16, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 16, true); + const part45 = rs.intRemEuclid(a, b, 16, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 16, true); + const part44 = rs.intIsqrt(a, 16, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 16, true); + const part43 = rs.intIlog(a, b, 16, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 16, true); + const part42 = rs.intIlog2(a, 16, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 16, true); + const part41 = rs.intIlog10(a, 16, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.i16Add(a, b)); + _22(out, rs.i16Add(a, b)); } else if (_30 === 16) { - _22(out, rt.i16Sub(a, b)); + _22(out, rs.i16Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.i16Mul(a, b)); + _22(out, rs.i16Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.i16Div(a, b)); + _22(out, rs.i16Div(a, b)); } else if (_30 === 19) { - _22(out, rt.i16Rem(a, b)); + _22(out, rs.i16Rem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 16, true); + const part35 = rs.intStrictNeg(a, 16, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.i16Shl(a, k)); + _22(out, rs.i16Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.i16Shr(a, k)); + _22(out, rs.i16Shr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 16, true); + const part32 = rs.intPow(a, k, 16, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 16, true); + const part31 = rs.intDivEuclid(a, b, 16, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 16, true); + const part30 = rs.intRemEuclid(a, b, 16, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 16, true); + const part29 = rs.intStrictAdd(a, o, 16, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 16, true); + const part28 = rs.intStrictSub(a, o, 16, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.i16WrappingDiv(a, b); + const part27 = rs.i16WrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.i16WrappingRem(a, b); + const part26 = rs.i16WrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 16, true); + const part25 = rs.intWrappingDivEuclid(a, b, 16, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 16, true); + const part24 = rs.intWrappingRemEuclid(a, b, 16, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 16, true); + const part23 = rs.intOverflowingDiv(a, b, 16, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 16, true); + const part22 = rs.intOverflowingRem(a, b, 16, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 16, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 16, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 16, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 16, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.i16SaturatingDiv(a, b); + const part19 = rs.i16SaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 16, true); + const part18 = rs.intAbs(a, 16, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 16, true); + const part17 = rs.intAbs(a, 16, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.i16 = a; - const w: rt.i16 = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 16, true), rt.intCountZeros(s2, 16, true), rt.i16LeadingZeros(s2), rt.i16TrailingZeros(s2)]); + const s2: rs.i16 = a; + const w: rs.i16 = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 16, true), rs.intCountZeros(s2, 16, true), rs.i16LeadingZeros(s2), rs.i16TrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 16, true), rt.intCountZeros(w, 16, true), rt.i16LeadingZeros(w), rt.i16TrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 16, true), rs.intCountZeros(w, 16, true), rs.i16LeadingZeros(w), rs.i16TrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 16, true), rt.intRotateRight(s2, n, 16, true), rt.intSwapBytes(s2, 16, true), rt.intReverseBits(s2, 16, true), rt.intSwapBytes(s2, 16, true), s2, rt.intSwapBytes(s2, 16, true), s2, rt.intSaturatingPow(s2, k, 16, true), rt.intSaturatingPow(s2, n, 16, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 16, true), rs.intRotateRight(s2, n, 16, true), rs.intSwapBytes(s2, 16, true), rs.intReverseBits(s2, 16, true), rs.intSwapBytes(s2, 16, true), s2, rs.intSwapBytes(s2, 16, true), s2, rs.intSaturatingPow(s2, k, 16, true), rs.intSaturatingPow(s2, n, 16, true)]); while (true) { - const _490: rt.i16 | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.i16 | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 16, true), rt.intRotateRight(w, n, 16, true), rt.intSwapBytes(w, 16, true), rt.intReverseBits(w, 16, true), rt.intSwapBytes(w, 16, true), w, rt.intSwapBytes(w, 16, true), w, rt.intWrappingPow(w, k, 16, true), rt.intWrappingPow(w, n, 16, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 16, true), rs.intRotateRight(w, n, 16, true), rs.intSwapBytes(w, 16, true), rs.intReverseBits(w, 16, true), rs.intSwapBytes(w, 16, true), w, rs.intSwapBytes(w, 16, true), w, rs.intWrappingPow(w, k, 16, true), rs.intWrappingPow(w, n, 16, true)]); while (true) { - const _511: rt.i16 | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.i16 | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 16, true), rt.intSignum(s2, 16, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 16, true), rs.intSignum(s2, 16, true)]); while (true) { - const _524: rt.i16 | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.i16 | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 16, true), rt.intSignum(w, 16, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 16, true), rs.intSignum(w, 16, true)]); while (true) { - const _537: rt.i16 | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.i16 | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.i16 | undefined, rt.i16 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.i16 | undefined, rs.i16 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.i16 = _557[0]; - const y: rt.i16 = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.i16LeadingZeros(x), rt.i16TrailingZeros(x), rt.intCountOnes(x, 16, true), 15 - rt.i16LeadingZeros(x), rt.i16TrailingZeros(x)]); + const x: rs.i16 = _557[0]; + const y: rs.i16 = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.i16LeadingZeros(x), rs.i16TrailingZeros(x), rs.intCountOnes(x, 16, true), 15 - rs.i16LeadingZeros(x), rs.i16TrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$0b7sac9(rt.i16CheckedMul(x, y), (a0: rt.i16): rt.i16 => { + const part4 = option_map$0ip7buw(rs.i16CheckedMul(x, y), (a0: rs.i16): rs.i16 => { return a0; }); putOpt(out, part4); - const part5 = rt.i16SaturatingMul(x, y); + const part5 = rs.i16SaturatingMul(x, y); _22(out, part5); - const part6 = option_map$0b7sac9(rt.intCheckedPow(x, k, 16, true), (a02: rt.i16): rt.i16 => { + const part6 = option_map$0ip7buw(rs.intCheckedPow(x, k, 16, true), (a02: rs.i16): rs.i16 => { return a02; }); putOpt(out, part6); - const part7 = option_map$0b7sac9(rt.intCheckedPow(x, n, 16, true), (a03: rt.i16): rt.i16 => { + const part7 = option_map$0ip7buw(rs.intCheckedPow(x, n, 16, true), (a03: rs.i16): rs.i16 => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 16, true); + const part8 = rs.intSaturatingPow(x, k, 16, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 16, true); + const part9 = rs.intIsolateHighestOne(x, 16, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 16, true); + const part10 = rs.intIsolateLowestOne(x, 16, true); _22(out, part10); - const part11 = option_map$0b7sac9(rt.intCheckedAbs(x, 16, true), (a04: rt.i16): rt.i16 => { + const part11 = option_map$0ip7buw(rs.intCheckedAbs(x, 16, true), (a04: rs.i16): rs.i16 => { return a04; }); putOpt(out, part11); - const _622: [rt.i16, boolean] = rt.intOverflowingAbs(x, 16, true); - putPair(out, [_622[0], _622[1]] as [rt.i16, boolean]); - const part12 = rt.intSaturatingAbs(x, 16, true); + const _622: [rs.i16, boolean] = rs.intOverflowingAbs(x, 16, true); + putPair(out, [_622[0], _622[1]] as [rs.i16, boolean]); + const part12 = rs.intSaturatingAbs(x, 16, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 16, true); + const part13 = rs.intWrappingAbs(x, 16, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.intUnsignedAbs(x, 16, true) as rt.u16))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); - const part14 = option_map$0b7sac9(rt.intCheckedNeg(x, 16, true), (a05: rt.i16): rt.i16 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.intUnsignedAbs(x, 16, true) as rs.u16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); + const part14 = option_map$0ip7buw(rs.intCheckedNeg(x, 16, true), (a05: rs.i16): rs.i16 => { return a05; }); putOpt(out, part14); - const _659: [rt.i16, boolean] = rt.intOverflowingNeg(x, 16, true); - putPair(out, [_659[0], _659[1]] as [rt.i16, boolean]); - const part15 = rt.i16SaturatingSub(0, x); + const _659: [rs.i16, boolean] = rs.intOverflowingNeg(x, 16, true); + putPair(out, [_659[0], _659[1]] as [rs.i16, boolean]); + const part15 = rs.i16SaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 16, true); + const part16 = rs.intWrappingNeg(x, 16, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(x & 0xffff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(x & 0xffff))); } } } else { - const _681: rt.i16 | undefined = rt.nonZero(a); + const _681: rs.i16 | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 16, true); + const part3 = rs.intAbs(_681, 16, true); _22(out, part3); } } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v8: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v8))); - rt.byteVecPush(out2, rt.i32FromBeBytes(rt.i32ToBeBytes(v8)) === v8 ? 1 : 0); +export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v8: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i32FromBeBytes(rs.i32ToBeBytes(v8)) === v8 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.i32 = rt.i32FromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { + const a: rs.i32 = rs.i32FromBeBytes(rs.bytesFromFn(4, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.i32 = rt.i32FromBeBytes(rt.bytesFromFn(4, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(4, i3)); + const b: rs.i32 = rs.i32FromBeBytes(rs.bytesFromFn(4, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(4, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 4, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 4, i4)); })); - const o: rt.u32 = b >>> 0; - const k: rt.u32 = rt.u32Rem(n, 3 * 32); - const putOpt: (a0: rt.ByteVec, a1: rt.i32 | undefined) => undefined = (out4: rt.ByteVec, v10: rt.i32 | undefined): undefined => { + const o: rs.u32 = b >>> 0; + const k: rs.u32 = rs.u32Rem(n, 3 * 32); + const putOpt: (a0: rs.ByteVec, a1: rs.i32 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i32 | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.i32 = v10; - rt.byteVecPush(out4, 1); + const v11: rs.i32 = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.i32, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.i32, boolean]): undefined => { - const v12: rt.i32 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i32, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i32, boolean]): undefined => { + const v12: rs.i32 = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.i32CheckedAdd(a, b); + const part88 = rs.i32CheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.i32CheckedSub(a, b); + const part89 = rs.i32CheckedSub(a, b); putOpt(out, part89); - const part90 = rt.i32CheckedMul(a, b); + const part90 = rs.i32CheckedMul(a, b); putOpt(out, part90); - const part91 = rt.i32SaturatingAdd(a, b); + const part91 = rs.i32SaturatingAdd(a, b); _22(out, part91); - const part92 = rt.i32SaturatingSub(a, b); + const part92 = rs.i32SaturatingSub(a, b); _22(out, part92); - const part93 = rt.i32SaturatingMul(a, b); + const part93 = rs.i32SaturatingMul(a, b); _22(out, part93); - const part94 = rt.i32WrappingAdd(a, b); + const part94 = rs.i32WrappingAdd(a, b); _22(out, part94); - const part95 = rt.i32WrappingSub(a, b); + const part95 = rs.i32WrappingSub(a, b); _22(out, part95); - const part96 = rt.i32WrappingMul(a, b); + const part96 = rs.i32WrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 32, true); + const part97 = rs.intOverflowingAdd(a, b, 32, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 32, true); + const part98 = rs.intOverflowingSub(a, b, 32, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 32, true); + const part99 = rs.intOverflowingMul(a, b, 32, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 32, true); + const part100 = rs.intMidpoint(a, b, 32, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 32, true); + const part101 = rs.intCheckedAdd(a, o, 32, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 32, true); + const part102 = rs.intCheckedSub(a, o, 32, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 32, true); + const part103 = rs.intSaturatingAdd(a, o, 32, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 32, true); + const part104 = rs.intSaturatingSub(a, o, 32, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 32, true); + const part105 = rs.intWrappingAdd(a, o, 32, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 32, true); + const part106 = rs.intWrappingSub(a, o, 32, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 32, true); + const part107 = rs.intOverflowingAdd(a, o, 32, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 32, true); + const part108 = rs.intOverflowingSub(a, o, 32, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 32, true); + const part80 = rs.intCheckedDiv(a, b, 32, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 32, true); + const part81 = rs.intCheckedRem(a, b, 32, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 32, true); + const part82 = rs.intCheckedDivEuclid(a, b, 32, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 32, true); + const part83 = rs.intCheckedRemEuclid(a, b, 32, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.i32WrappingDiv(a, b); + const part84 = rs.i32WrappingDiv(a, b); _22(out, part84); - const part85 = rt.i32WrappingRem(a, b); + const part85 = rs.i32WrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 32, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 32, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 32, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 32, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 32, true); + const part70 = rs.intCheckedNeg(a, 32, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 32, true); + const part71 = rs.intWrappingNeg(a, 32, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 32, true); + const part72 = rs.intOverflowingNeg(a, 32, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 32, true); + const part73 = rs.intCheckedAbs(a, 32, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 32, true); + const part74 = rs.intWrappingAbs(a, 32, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 32, true); + const part75 = rs.intSaturatingAbs(a, 32, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 32, true); + const part76 = rs.intOverflowingAbs(a, 32, true); putPair(out, part76); - const part77 = rt.i32SaturatingSub(0, a); + const part77 = rs.i32SaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 32, true); + const part78 = rs.intSignum(a, 32, true); _22(out, part78); - rt.byteVecPush(out, a > 0 ? 1 : 0); - rt.byteVecPush(out, a < 0 ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 32, true); + rs.byteVecPush(out, a > 0 ? 1 : 0); + rs.byteVecPush(out, a < 0 ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 32, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.intUnsignedAbs(a, 32, true) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(a >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.intUnsignedAbs(a, 32, true) as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(a >>> 0))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 32, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 32, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 32, true); + const part67 = rs.intWrappingPow(a, e, 32, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 32, true); + const part68 = rs.intSaturatingPow(a, e, 32, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 32, true); + const part69 = rs.intOverflowingPow(a, e, 32, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 32, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 32, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 32, true); + const part57 = rs.intCheckedShr(a, s, 32, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 32, true); + const part58 = rs.intWrappingShl(a, s, 32, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 32, true); + const part59 = rs.intWrappingShr(a, s, 32, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 32, true); + const part60 = rs.intOverflowingShl(a, s, 32, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 32, true); + const part61 = rs.intOverflowingShr(a, s, 32, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 32, true); + const part62 = rs.intUnboundedShl(a, s, 32, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 32, true); + const part63 = rs.intUnboundedShr(a, s, 32, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 32, true); + const part64 = rs.intRotateLeft(a, s, 32, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 32, true); + const part65 = rs.intRotateRight(a, s, 32, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 32, true), rt.intCountZeros(a, 32, true), rt.i32LeadingZeros(a), rt.i32TrailingZeros(a), rt.i32LeadingOnes(a), rt.intTrailingOnes(a, 32, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 32, true), rs.intCountZeros(a, 32, true), rs.i32LeadingZeros(a), rs.i32TrailingZeros(a), rs.i32LeadingOnes(a), rs.intTrailingOnes(a, 32, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 32, true), rt.intReverseBits(a, 32, true), rt.intSwapBytes(a, 32, true), a, rt.intSwapBytes(a, 32, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 32, true), rs.intReverseBits(a, 32, true), rs.intSwapBytes(a, 32, true), a, rs.intSwapBytes(a, 32, true), a]); while (true) { - const _300: rt.i32 | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.i32 | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 32, true); + const part52 = rs.intHighestOne(a, 32, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 32, true); + const part53 = rs.intLowestOne(a, 32, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 32, true); + const part54 = rs.intIsolateHighestOne(a, 32, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 32, true); + const part55 = rs.intIsolateLowestOne(a, 32, true); _22(out, part55); _22(out, 2147483647); _22(out, -2147483648); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 32, true); + const part49 = rs.intCheckedIlog(a, b, 32, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 32, true); + const part50 = rs.intCheckedIlog2(a, 32, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 32, true); + const part51 = rs.intCheckedIlog10(a, 32, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.intAbsDiff(a, b, 32, true) as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.intAbsDiff(a, b, 32, true) as rs.u32))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 32, true); + const part48 = rs.intPow(a, k, 32, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 32, true); + const part47 = rs.intPow(a, n, 32, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 32, true); + const part46 = rs.intDivEuclid(a, b, 32, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 32, true); + const part45 = rs.intRemEuclid(a, b, 32, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 32, true); + const part44 = rs.intIsqrt(a, 32, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 32, true); + const part43 = rs.intIlog(a, b, 32, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 32, true); + const part42 = rs.intIlog2(a, 32, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 32, true); + const part41 = rs.intIlog10(a, 32, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.i32Add(a, b)); + _22(out, rs.i32Add(a, b)); } else if (_30 === 16) { - _22(out, rt.i32Sub(a, b)); + _22(out, rs.i32Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.i32Mul(a, b)); + _22(out, rs.i32Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.i32Div(a, b)); + _22(out, rs.i32Div(a, b)); } else if (_30 === 19) { - _22(out, rt.i32Rem(a, b)); + _22(out, rs.i32Rem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 32, true); + const part35 = rs.intStrictNeg(a, 32, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.i32Shl(a, k)); + _22(out, rs.i32Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.i32Shr(a, k)); + _22(out, rs.i32Shr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 32, true); + const part32 = rs.intPow(a, k, 32, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 32, true); + const part31 = rs.intDivEuclid(a, b, 32, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 32, true); + const part30 = rs.intRemEuclid(a, b, 32, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 32, true); + const part29 = rs.intStrictAdd(a, o, 32, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 32, true); + const part28 = rs.intStrictSub(a, o, 32, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.i32WrappingDiv(a, b); + const part27 = rs.i32WrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.i32WrappingRem(a, b); + const part26 = rs.i32WrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 32, true); + const part25 = rs.intWrappingDivEuclid(a, b, 32, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 32, true); + const part24 = rs.intWrappingRemEuclid(a, b, 32, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 32, true); + const part23 = rs.intOverflowingDiv(a, b, 32, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 32, true); + const part22 = rs.intOverflowingRem(a, b, 32, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 32, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 32, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 32, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 32, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.i32SaturatingDiv(a, b); + const part19 = rs.i32SaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 32, true); + const part18 = rs.intAbs(a, 32, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 32, true); + const part17 = rs.intAbs(a, 32, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.i32 = a; - const w: rt.i32 = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 32, true), rt.intCountZeros(s2, 32, true), rt.i32LeadingZeros(s2), rt.i32TrailingZeros(s2)]); + const s2: rs.i32 = a; + const w: rs.i32 = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 32, true), rs.intCountZeros(s2, 32, true), rs.i32LeadingZeros(s2), rs.i32TrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 32, true), rt.intCountZeros(w, 32, true), rt.i32LeadingZeros(w), rt.i32TrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 32, true), rs.intCountZeros(w, 32, true), rs.i32LeadingZeros(w), rs.i32TrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 32, true), rt.intRotateRight(s2, n, 32, true), rt.intSwapBytes(s2, 32, true), rt.intReverseBits(s2, 32, true), rt.intSwapBytes(s2, 32, true), s2, rt.intSwapBytes(s2, 32, true), s2, rt.intSaturatingPow(s2, k, 32, true), rt.intSaturatingPow(s2, n, 32, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 32, true), rs.intRotateRight(s2, n, 32, true), rs.intSwapBytes(s2, 32, true), rs.intReverseBits(s2, 32, true), rs.intSwapBytes(s2, 32, true), s2, rs.intSwapBytes(s2, 32, true), s2, rs.intSaturatingPow(s2, k, 32, true), rs.intSaturatingPow(s2, n, 32, true)]); while (true) { - const _490: rt.i32 | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.i32 | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 32, true), rt.intRotateRight(w, n, 32, true), rt.intSwapBytes(w, 32, true), rt.intReverseBits(w, 32, true), rt.intSwapBytes(w, 32, true), w, rt.intSwapBytes(w, 32, true), w, rt.intWrappingPow(w, k, 32, true), rt.intWrappingPow(w, n, 32, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 32, true), rs.intRotateRight(w, n, 32, true), rs.intSwapBytes(w, 32, true), rs.intReverseBits(w, 32, true), rs.intSwapBytes(w, 32, true), w, rs.intSwapBytes(w, 32, true), w, rs.intWrappingPow(w, k, 32, true), rs.intWrappingPow(w, n, 32, true)]); while (true) { - const _511: rt.i32 | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.i32 | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 32, true), rt.intSignum(s2, 32, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 32, true), rs.intSignum(s2, 32, true)]); while (true) { - const _524: rt.i32 | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.i32 | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 32, true), rt.intSignum(w, 32, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 32, true), rs.intSignum(w, 32, true)]); while (true) { - const _537: rt.i32 | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.i32 | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.i32 | undefined, rt.i32 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.i32 | undefined, rs.i32 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.i32 = _557[0]; - const y: rt.i32 = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.i32LeadingZeros(x), rt.i32TrailingZeros(x), rt.intCountOnes(x, 32, true), 31 - rt.i32LeadingZeros(x), rt.i32TrailingZeros(x)]); + const x: rs.i32 = _557[0]; + const y: rs.i32 = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.i32LeadingZeros(x), rs.i32TrailingZeros(x), rs.intCountOnes(x, 32, true), 31 - rs.i32LeadingZeros(x), rs.i32TrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$0x0f126(rt.i32CheckedMul(x, y), (a0: rt.i32): rt.i32 => { + const part4 = option_map$0a35how(rs.i32CheckedMul(x, y), (a0: rs.i32): rs.i32 => { return a0; }); putOpt(out, part4); - const part5 = rt.i32SaturatingMul(x, y); + const part5 = rs.i32SaturatingMul(x, y); _22(out, part5); - const part6 = option_map$0x0f126(rt.intCheckedPow(x, k, 32, true), (a02: rt.i32): rt.i32 => { + const part6 = option_map$0a35how(rs.intCheckedPow(x, k, 32, true), (a02: rs.i32): rs.i32 => { return a02; }); putOpt(out, part6); - const part7 = option_map$0x0f126(rt.intCheckedPow(x, n, 32, true), (a03: rt.i32): rt.i32 => { + const part7 = option_map$0a35how(rs.intCheckedPow(x, n, 32, true), (a03: rs.i32): rs.i32 => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 32, true); + const part8 = rs.intSaturatingPow(x, k, 32, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 32, true); + const part9 = rs.intIsolateHighestOne(x, 32, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 32, true); + const part10 = rs.intIsolateLowestOne(x, 32, true); _22(out, part10); - const part11 = option_map$0x0f126(rt.intCheckedAbs(x, 32, true), (a04: rt.i32): rt.i32 => { + const part11 = option_map$0a35how(rs.intCheckedAbs(x, 32, true), (a04: rs.i32): rs.i32 => { return a04; }); putOpt(out, part11); - const _622: [rt.i32, boolean] = rt.intOverflowingAbs(x, 32, true); - putPair(out, [_622[0], _622[1]] as [rt.i32, boolean]); - const part12 = rt.intSaturatingAbs(x, 32, true); + const _622: [rs.i32, boolean] = rs.intOverflowingAbs(x, 32, true); + putPair(out, [_622[0], _622[1]] as [rs.i32, boolean]); + const part12 = rs.intSaturatingAbs(x, 32, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 32, true); + const part13 = rs.intWrappingAbs(x, 32, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.intUnsignedAbs(x, 32, true) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); - const part14 = option_map$0x0f126(rt.intCheckedNeg(x, 32, true), (a05: rt.i32): rt.i32 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.intUnsignedAbs(x, 32, true) as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); + const part14 = option_map$0a35how(rs.intCheckedNeg(x, 32, true), (a05: rs.i32): rs.i32 => { return a05; }); putOpt(out, part14); - const _659: [rt.i32, boolean] = rt.intOverflowingNeg(x, 32, true); - putPair(out, [_659[0], _659[1]] as [rt.i32, boolean]); - const part15 = rt.i32SaturatingSub(0, x); + const _659: [rs.i32, boolean] = rs.intOverflowingNeg(x, 32, true); + putPair(out, [_659[0], _659[1]] as [rs.i32, boolean]); + const part15 = rs.i32SaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 32, true); + const part16 = rs.intWrappingNeg(x, 32, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x >>> 0))); } } } else { - const _681: rt.i32 | undefined = rt.nonZero(a); + const _681: rs.i32 | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 32, true); + const part3 = rs.intAbs(_681, 32, true); _22(out, part3); } } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v8: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v8))); - rt.byteVecPush(out2, rt.i64Eq(rt.i64FromBeBytes(rt.i64ToBeBytes(v8)), v8) ? 1 : 0); +export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v8: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i64Eq(rs.i64FromBeBytes(rs.i64ToBeBytes(v8)), v8) ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.i64 = rt.i64FromBeBytes(rt.bytesFromFn(8, (i2: rt.usize): rt.u8 => { + const a: rs.i64 = rs.i64FromBeBytes(rs.bytesFromFn(8, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.i64 = rt.i64FromBeBytes(rt.bytesFromFn(8, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(8, i3)); + const b: rs.i64 = rs.i64FromBeBytes(rs.bytesFromFn(8, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(8, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 8, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 8, i4)); })); - const o: rt.u64 = rt.u64Cast(b); - const k: rt.u32 = rt.u32Rem(n, 3 * 64); - const putOpt: (a0: rt.ByteVec, a1: rt.i64 | undefined) => undefined = (out4: rt.ByteVec, v10: rt.i64 | undefined): undefined => { + const o: rs.u64 = rs.u64Cast(b); + const k: rs.u32 = rs.u32Rem(n, 3 * 64); + const putOpt: (a0: rs.ByteVec, a1: rs.i64 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i64 | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.i64 = v10; - rt.byteVecPush(out4, 1); + const v11: rs.i64 = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.i64, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.i64, boolean]): undefined => { - const v12: rt.i64 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i64, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i64, boolean]): undefined => { + const v12: rs.i64 = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.i64CheckedAdd(a, b); + const part88 = rs.i64CheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.i64CheckedSub(a, b); + const part89 = rs.i64CheckedSub(a, b); putOpt(out, part89); - const part90 = rt.i64CheckedMul(a, b); + const part90 = rs.i64CheckedMul(a, b); putOpt(out, part90); - const part91 = rt.i64SaturatingAdd(a, b); + const part91 = rs.i64SaturatingAdd(a, b); _22(out, part91); - const part92 = rt.i64SaturatingSub(a, b); + const part92 = rs.i64SaturatingSub(a, b); _22(out, part92); - const part93 = rt.i64SaturatingMul(a, b); + const part93 = rs.i64SaturatingMul(a, b); _22(out, part93); - const part94 = rt.i64WrappingAdd(a, b); + const part94 = rs.i64WrappingAdd(a, b); _22(out, part94); - const part95 = rt.i64WrappingSub(a, b); + const part95 = rs.i64WrappingSub(a, b); _22(out, part95); - const part96 = rt.i64WrappingMul(a, b); + const part96 = rs.i64WrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 64, true); + const part97 = rs.intOverflowingAdd(a, b, 64, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 64, true); + const part98 = rs.intOverflowingSub(a, b, 64, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 64, true); + const part99 = rs.intOverflowingMul(a, b, 64, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 64, true); + const part100 = rs.intMidpoint(a, b, 64, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 64, true); + const part101 = rs.intCheckedAdd(a, o, 64, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 64, true); + const part102 = rs.intCheckedSub(a, o, 64, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 64, true); + const part103 = rs.intSaturatingAdd(a, o, 64, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 64, true); + const part104 = rs.intSaturatingSub(a, o, 64, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 64, true); + const part105 = rs.intWrappingAdd(a, o, 64, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 64, true); + const part106 = rs.intWrappingSub(a, o, 64, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 64, true); + const part107 = rs.intOverflowingAdd(a, o, 64, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 64, true); + const part108 = rs.intOverflowingSub(a, o, 64, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 64, true); + const part80 = rs.intCheckedDiv(a, b, 64, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 64, true); + const part81 = rs.intCheckedRem(a, b, 64, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 64, true); + const part82 = rs.intCheckedDivEuclid(a, b, 64, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 64, true); + const part83 = rs.intCheckedRemEuclid(a, b, 64, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.i64WrappingDiv(a, b); + const part84 = rs.i64WrappingDiv(a, b); _22(out, part84); - const part85 = rt.i64WrappingRem(a, b); + const part85 = rs.i64WrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 64, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 64, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 64, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 64, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 64, true); + const part70 = rs.intCheckedNeg(a, 64, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 64, true); + const part71 = rs.intWrappingNeg(a, 64, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 64, true); + const part72 = rs.intOverflowingNeg(a, 64, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 64, true); + const part73 = rs.intCheckedAbs(a, 64, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 64, true); + const part74 = rs.intWrappingAbs(a, 64, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 64, true); + const part75 = rs.intSaturatingAbs(a, 64, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 64, true); + const part76 = rs.intOverflowingAbs(a, 64, true); putPair(out, part76); - const part77 = rt.i64SaturatingSub(0, a); + const part77 = rs.i64SaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 64, true); + const part78 = rs.intSignum(a, 64, true); _22(out, part78); - rt.byteVecPush(out, rt.i64Gt(a, 0) ? 1 : 0); - rt.byteVecPush(out, rt.i64Lt(a, 0) ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 64, true); + rs.byteVecPush(out, rs.i64Gt(a, 0) ? 1 : 0); + rs.byteVecPush(out, rs.i64Lt(a, 0) ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 64, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.intUnsignedAbs(a, 64, true) as rt.u64))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Cast(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.intUnsignedAbs(a, 64, true) as rs.u64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64Cast(a)))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 64, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 64, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 64, true); + const part67 = rs.intWrappingPow(a, e, 64, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 64, true); + const part68 = rs.intSaturatingPow(a, e, 64, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 64, true); + const part69 = rs.intOverflowingPow(a, e, 64, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 64, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 64, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 64, true); + const part57 = rs.intCheckedShr(a, s, 64, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 64, true); + const part58 = rs.intWrappingShl(a, s, 64, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 64, true); + const part59 = rs.intWrappingShr(a, s, 64, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 64, true); + const part60 = rs.intOverflowingShl(a, s, 64, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 64, true); + const part61 = rs.intOverflowingShr(a, s, 64, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 64, true); + const part62 = rs.intUnboundedShl(a, s, 64, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 64, true); + const part63 = rs.intUnboundedShr(a, s, 64, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 64, true); + const part64 = rs.intRotateLeft(a, s, 64, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 64, true); + const part65 = rs.intRotateRight(a, s, 64, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 64, true), rt.intCountZeros(a, 64, true), rt.i64LeadingZeros(a), rt.i64TrailingZeros(a), rt.i64LeadingOnes(a), rt.intTrailingOnes(a, 64, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 64, true), rs.intCountZeros(a, 64, true), rs.i64LeadingZeros(a), rs.i64TrailingZeros(a), rs.i64LeadingOnes(a), rs.intTrailingOnes(a, 64, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 64, true), rt.intReverseBits(a, 64, true), rt.intSwapBytes(a, 64, true), a, rt.intSwapBytes(a, 64, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 64, true), rs.intReverseBits(a, 64, true), rs.intSwapBytes(a, 64, true), a, rs.intSwapBytes(a, 64, true), a]); while (true) { - const _300: rt.i64 | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.i64 | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 64, true); + const part52 = rs.intHighestOne(a, 64, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 64, true); + const part53 = rs.intLowestOne(a, 64, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 64, true); + const part54 = rs.intIsolateHighestOne(a, 64, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 64, true); + const part55 = rs.intIsolateLowestOne(a, 64, true); _22(out, part55); - _22(out, { hi: 0x7fffffff, lo: 0xffffffff } as rt.i64); - _22(out, { hi: -0x80000000, lo: 0 } as rt.i64); + _22(out, { hi: 0x7fffffff, lo: 0xffffffff } as rs.i64); + _22(out, { hi: -0x80000000, lo: 0 } as rs.i64); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 64, true); + const part49 = rs.intCheckedIlog(a, b, 64, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 64, true); + const part50 = rs.intCheckedIlog2(a, 64, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 64, true); + const part51 = rs.intCheckedIlog10(a, 64, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.intAbsDiff(a, b, 64, true) as rt.u64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.intAbsDiff(a, b, 64, true) as rs.u64))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 64, true); + const part48 = rs.intPow(a, k, 64, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 64, true); + const part47 = rs.intPow(a, n, 64, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 64, true); + const part46 = rs.intDivEuclid(a, b, 64, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 64, true); + const part45 = rs.intRemEuclid(a, b, 64, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 64, true); + const part44 = rs.intIsqrt(a, 64, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 64, true); + const part43 = rs.intIlog(a, b, 64, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 64, true); + const part42 = rs.intIlog2(a, 64, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 64, true); + const part41 = rs.intIlog10(a, 64, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.i64Add(a, b)); + _22(out, rs.i64Add(a, b)); } else if (_30 === 16) { - _22(out, rt.i64Sub(a, b)); + _22(out, rs.i64Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.i64Mul(a, b)); + _22(out, rs.i64Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.i64Div(a, b)); + _22(out, rs.i64Div(a, b)); } else if (_30 === 19) { - _22(out, rt.i64Rem(a, b)); + _22(out, rs.i64Rem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 64, true); + const part35 = rs.intStrictNeg(a, 64, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.i64Shl(a, k)); + _22(out, rs.i64Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.i64Shr(a, k)); + _22(out, rs.i64Shr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 64, true); + const part32 = rs.intPow(a, k, 64, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 64, true); + const part31 = rs.intDivEuclid(a, b, 64, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 64, true); + const part30 = rs.intRemEuclid(a, b, 64, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 64, true); + const part29 = rs.intStrictAdd(a, o, 64, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 64, true); + const part28 = rs.intStrictSub(a, o, 64, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.i64WrappingDiv(a, b); + const part27 = rs.i64WrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.i64WrappingRem(a, b); + const part26 = rs.i64WrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 64, true); + const part25 = rs.intWrappingDivEuclid(a, b, 64, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 64, true); + const part24 = rs.intWrappingRemEuclid(a, b, 64, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 64, true); + const part23 = rs.intOverflowingDiv(a, b, 64, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 64, true); + const part22 = rs.intOverflowingRem(a, b, 64, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 64, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 64, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 64, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 64, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.i64SaturatingDiv(a, b); + const part19 = rs.i64SaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 64, true); + const part18 = rs.intAbs(a, 64, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 64, true); + const part17 = rs.intAbs(a, 64, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.i64 = a; - const w: rt.i64 = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 64, true), rt.intCountZeros(s2, 64, true), rt.i64LeadingZeros(s2), rt.i64TrailingZeros(s2)]); + const s2: rs.i64 = a; + const w: rs.i64 = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 64, true), rs.intCountZeros(s2, 64, true), rs.i64LeadingZeros(s2), rs.i64TrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 64, true), rt.intCountZeros(w, 64, true), rt.i64LeadingZeros(w), rt.i64TrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 64, true), rs.intCountZeros(w, 64, true), rs.i64LeadingZeros(w), rs.i64TrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 64, true), rt.intRotateRight(s2, n, 64, true), rt.intSwapBytes(s2, 64, true), rt.intReverseBits(s2, 64, true), rt.intSwapBytes(s2, 64, true), s2, rt.intSwapBytes(s2, 64, true), s2, rt.intSaturatingPow(s2, k, 64, true), rt.intSaturatingPow(s2, n, 64, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 64, true), rs.intRotateRight(s2, n, 64, true), rs.intSwapBytes(s2, 64, true), rs.intReverseBits(s2, 64, true), rs.intSwapBytes(s2, 64, true), s2, rs.intSwapBytes(s2, 64, true), s2, rs.intSaturatingPow(s2, k, 64, true), rs.intSaturatingPow(s2, n, 64, true)]); while (true) { - const _490: rt.i64 | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.i64 | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 64, true), rt.intRotateRight(w, n, 64, true), rt.intSwapBytes(w, 64, true), rt.intReverseBits(w, 64, true), rt.intSwapBytes(w, 64, true), w, rt.intSwapBytes(w, 64, true), w, rt.intWrappingPow(w, k, 64, true), rt.intWrappingPow(w, n, 64, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 64, true), rs.intRotateRight(w, n, 64, true), rs.intSwapBytes(w, 64, true), rs.intReverseBits(w, 64, true), rs.intSwapBytes(w, 64, true), w, rs.intSwapBytes(w, 64, true), w, rs.intWrappingPow(w, k, 64, true), rs.intWrappingPow(w, n, 64, true)]); while (true) { - const _511: rt.i64 | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.i64 | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 64, true), rt.intSignum(s2, 64, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 64, true), rs.intSignum(s2, 64, true)]); while (true) { - const _524: rt.i64 | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.i64 | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 64, true), rt.intSignum(w, 64, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 64, true), rs.intSignum(w, 64, true)]); while (true) { - const _537: rt.i64 | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.i64 | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.i64Gt(s2, 0) ? 1 : 0, rt.i64Lt(s2, 0) ? 1 : 0, rt.i64Gt(w, 0) ? 1 : 0, rt.i64Lt(w, 0) ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.i64Gt(s2, 0) ? 1 : 0, rs.i64Lt(s2, 0) ? 1 : 0, rs.i64Gt(w, 0) ? 1 : 0, rs.i64Lt(w, 0) ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.i64 | undefined, rt.i64 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.i64 | undefined, rs.i64 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.i64 = _557[0]; - const y: rt.i64 = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.i64LeadingZeros(x), rt.i64TrailingZeros(x), rt.intCountOnes(x, 64, true), 63 - rt.i64LeadingZeros(x), rt.i64TrailingZeros(x)]); + const x: rs.i64 = _557[0]; + const y: rs.i64 = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.i64LeadingZeros(x), rs.i64TrailingZeros(x), rs.intCountOnes(x, 64, true), 63 - rs.i64LeadingZeros(x), rs.i64TrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$02fxff7(rt.i64CheckedMul(x, y), (a0: rt.i64): rt.i64 => { + const part4 = option_map$05k3lfb(rs.i64CheckedMul(x, y), (a0: rs.i64): rs.i64 => { return a0; }); putOpt(out, part4); - const part5 = rt.i64SaturatingMul(x, y); + const part5 = rs.i64SaturatingMul(x, y); _22(out, part5); - const part6 = option_map$02fxff7(rt.intCheckedPow(x, k, 64, true), (a02: rt.i64): rt.i64 => { + const part6 = option_map$05k3lfb(rs.intCheckedPow(x, k, 64, true), (a02: rs.i64): rs.i64 => { return a02; }); putOpt(out, part6); - const part7 = option_map$02fxff7(rt.intCheckedPow(x, n, 64, true), (a03: rt.i64): rt.i64 => { + const part7 = option_map$05k3lfb(rs.intCheckedPow(x, n, 64, true), (a03: rs.i64): rs.i64 => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 64, true); + const part8 = rs.intSaturatingPow(x, k, 64, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 64, true); + const part9 = rs.intIsolateHighestOne(x, 64, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 64, true); + const part10 = rs.intIsolateLowestOne(x, 64, true); _22(out, part10); - const part11 = option_map$02fxff7(rt.intCheckedAbs(x, 64, true), (a04: rt.i64): rt.i64 => { + const part11 = option_map$05k3lfb(rs.intCheckedAbs(x, 64, true), (a04: rs.i64): rs.i64 => { return a04; }); putOpt(out, part11); - const _622: [rt.i64, boolean] = rt.intOverflowingAbs(x, 64, true); - putPair(out, [_622[0], _622[1]] as [rt.i64, boolean]); - const part12 = rt.intSaturatingAbs(x, 64, true); + const _622: [rs.i64, boolean] = rs.intOverflowingAbs(x, 64, true); + putPair(out, [_622[0], _622[1]] as [rs.i64, boolean]); + const part12 = rs.intSaturatingAbs(x, 64, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 64, true); + const part13 = rs.intWrappingAbs(x, 64, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.intUnsignedAbs(x, 64, true) as rt.u64))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.i64Gt(x, 0) ? 1 : 0, rt.i64Lt(x, 0) ? 1 : 0))); - const part14 = option_map$02fxff7(rt.intCheckedNeg(x, 64, true), (a05: rt.i64): rt.i64 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.intUnsignedAbs(x, 64, true) as rs.u64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.i64Gt(x, 0) ? 1 : 0, rs.i64Lt(x, 0) ? 1 : 0))); + const part14 = option_map$05k3lfb(rs.intCheckedNeg(x, 64, true), (a05: rs.i64): rs.i64 => { return a05; }); putOpt(out, part14); - const _659: [rt.i64, boolean] = rt.intOverflowingNeg(x, 64, true); - putPair(out, [_659[0], _659[1]] as [rt.i64, boolean]); - const part15 = rt.i64SaturatingSub(0, x); + const _659: [rs.i64, boolean] = rs.intOverflowingNeg(x, 64, true); + putPair(out, [_659[0], _659[1]] as [rs.i64, boolean]); + const part15 = rs.i64SaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 64, true); + const part16 = rs.intWrappingNeg(x, 64, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Cast(x)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64Cast(x)))); } } } else { - const _681: rt.i64 | undefined = rt.nonZero(a); + const _681: rs.i64 | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 64, true); + const part3 = rs.intAbs(_681, 64, true); _22(out, part3); } } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v8: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v8))); - rt.byteVecPush(out2, rt.i128Eq(rt.i128FromBeBytes(rt.i128ToBeBytes(v8)), v8) ? 1 : 0); +export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v8: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v8))); + rs.byteVecPush(out2, rs.i128Eq(rs.i128FromBeBytes(rs.i128ToBeBytes(v8)), v8) ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.i128 = rt.i128FromBeBytes(rt.bytesFromFn(16, (i2: rt.usize): rt.u8 => { + const a: rs.i128 = rs.i128FromBeBytes(rs.bytesFromFn(16, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.i128 = rt.i128FromBeBytes(rt.bytesFromFn(16, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(16, i3)); + const b: rs.i128 = rs.i128FromBeBytes(rs.bytesFromFn(16, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(16, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 16, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 16, i4)); })); - const o: rt.u128 = rt.u128Cast(b); - const k: rt.u32 = rt.u32Rem(n, 3 * 128); - const putOpt: (a0: rt.ByteVec, a1: rt.i128 | undefined) => undefined = (out4: rt.ByteVec, v10: rt.i128 | undefined): undefined => { + const o: rs.u128 = rs.u128Cast(b); + const k: rs.u32 = rs.u32Rem(n, 3 * 128); + const putOpt: (a0: rs.ByteVec, a1: rs.i128 | undefined) => undefined = (out4: rs.ByteVec, v10: rs.i128 | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.i128 = v10; - rt.byteVecPush(out4, 1); + const v11: rs.i128 = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.i128, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.i128, boolean]): undefined => { - const v12: rt.i128 = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.i128, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.i128, boolean]): undefined => { + const v12: rs.i128 = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.i128CheckedAdd(a, b); + const part88 = rs.i128CheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.i128CheckedSub(a, b); + const part89 = rs.i128CheckedSub(a, b); putOpt(out, part89); - const part90 = rt.i128CheckedMul(a, b); + const part90 = rs.i128CheckedMul(a, b); putOpt(out, part90); - const part91 = rt.i128SaturatingAdd(a, b); + const part91 = rs.i128SaturatingAdd(a, b); _22(out, part91); - const part92 = rt.i128SaturatingSub(a, b); + const part92 = rs.i128SaturatingSub(a, b); _22(out, part92); - const part93 = rt.i128SaturatingMul(a, b); + const part93 = rs.i128SaturatingMul(a, b); _22(out, part93); - const part94 = rt.i128WrappingAdd(a, b); + const part94 = rs.i128WrappingAdd(a, b); _22(out, part94); - const part95 = rt.i128WrappingSub(a, b); + const part95 = rs.i128WrappingSub(a, b); _22(out, part95); - const part96 = rt.i128WrappingMul(a, b); + const part96 = rs.i128WrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 128, true); + const part97 = rs.intOverflowingAdd(a, b, 128, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 128, true); + const part98 = rs.intOverflowingSub(a, b, 128, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 128, true); + const part99 = rs.intOverflowingMul(a, b, 128, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 128, true); + const part100 = rs.intMidpoint(a, b, 128, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 128, true); + const part101 = rs.intCheckedAdd(a, o, 128, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 128, true); + const part102 = rs.intCheckedSub(a, o, 128, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 128, true); + const part103 = rs.intSaturatingAdd(a, o, 128, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 128, true); + const part104 = rs.intSaturatingSub(a, o, 128, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 128, true); + const part105 = rs.intWrappingAdd(a, o, 128, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 128, true); + const part106 = rs.intWrappingSub(a, o, 128, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 128, true); + const part107 = rs.intOverflowingAdd(a, o, 128, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 128, true); + const part108 = rs.intOverflowingSub(a, o, 128, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 128, true); + const part80 = rs.intCheckedDiv(a, b, 128, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 128, true); + const part81 = rs.intCheckedRem(a, b, 128, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 128, true); + const part82 = rs.intCheckedDivEuclid(a, b, 128, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 128, true); + const part83 = rs.intCheckedRemEuclid(a, b, 128, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.i128WrappingDiv(a, b); + const part84 = rs.i128WrappingDiv(a, b); _22(out, part84); - const part85 = rt.i128WrappingRem(a, b); + const part85 = rs.i128WrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 128, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 128, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 128, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 128, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 128, true); + const part70 = rs.intCheckedNeg(a, 128, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 128, true); + const part71 = rs.intWrappingNeg(a, 128, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 128, true); + const part72 = rs.intOverflowingNeg(a, 128, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 128, true); + const part73 = rs.intCheckedAbs(a, 128, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 128, true); + const part74 = rs.intWrappingAbs(a, 128, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 128, true); + const part75 = rs.intSaturatingAbs(a, 128, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 128, true); + const part76 = rs.intOverflowingAbs(a, 128, true); putPair(out, part76); - const part77 = rt.i128SaturatingSub(0, a); + const part77 = rs.i128SaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 128, true); + const part78 = rs.intSignum(a, 128, true); _22(out, part78); - rt.byteVecPush(out, rt.i128Gt(a, 0) ? 1 : 0); - rt.byteVecPush(out, rt.i128Lt(a, 0) ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 128, true); + rs.byteVecPush(out, rs.i128Gt(a, 0) ? 1 : 0); + rs.byteVecPush(out, rs.i128Lt(a, 0) ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 128, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.intUnsignedAbs(a, 128, true) as rt.u128))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.intUnsignedAbs(a, 128, true) as rs.u128))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(a)))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 128, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 128, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 128, true); + const part67 = rs.intWrappingPow(a, e, 128, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 128, true); + const part68 = rs.intSaturatingPow(a, e, 128, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 128, true); + const part69 = rs.intOverflowingPow(a, e, 128, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 128, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 128, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 128, true); + const part57 = rs.intCheckedShr(a, s, 128, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 128, true); + const part58 = rs.intWrappingShl(a, s, 128, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 128, true); + const part59 = rs.intWrappingShr(a, s, 128, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 128, true); + const part60 = rs.intOverflowingShl(a, s, 128, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 128, true); + const part61 = rs.intOverflowingShr(a, s, 128, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 128, true); + const part62 = rs.intUnboundedShl(a, s, 128, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 128, true); + const part63 = rs.intUnboundedShr(a, s, 128, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 128, true); + const part64 = rs.intRotateLeft(a, s, 128, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 128, true); + const part65 = rs.intRotateRight(a, s, 128, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 128, true), rt.intCountZeros(a, 128, true), rt.i128LeadingZeros(a), rt.i128TrailingZeros(a), rt.i128LeadingOnes(a), rt.intTrailingOnes(a, 128, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 128, true), rs.intCountZeros(a, 128, true), rs.i128LeadingZeros(a), rs.i128TrailingZeros(a), rs.i128LeadingOnes(a), rs.intTrailingOnes(a, 128, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 128, true), rt.intReverseBits(a, 128, true), rt.intSwapBytes(a, 128, true), a, rt.intSwapBytes(a, 128, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 128, true), rs.intReverseBits(a, 128, true), rs.intSwapBytes(a, 128, true), a, rs.intSwapBytes(a, 128, true), a]); while (true) { - const _300: rt.i128 | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.i128 | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 128, true); + const part52 = rs.intHighestOne(a, 128, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 128, true); + const part53 = rs.intLowestOne(a, 128, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 128, true); + const part54 = rs.intIsolateHighestOne(a, 128, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 128, true); + const part55 = rs.intIsolateLowestOne(a, 128, true); _22(out, part55); - _22(out, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.i128); - _22(out, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128); + _22(out, { hi: 0x7fffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.i128); + _22(out, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 128, true); + const part49 = rs.intCheckedIlog(a, b, 128, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 128, true); + const part50 = rs.intCheckedIlog2(a, 128, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 128, true); + const part51 = rs.intCheckedIlog10(a, 128, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.intAbsDiff(a, b, 128, true) as rt.u128))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.intAbsDiff(a, b, 128, true) as rs.u128))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 128, true); + const part48 = rs.intPow(a, k, 128, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 128, true); + const part47 = rs.intPow(a, n, 128, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 128, true); + const part46 = rs.intDivEuclid(a, b, 128, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 128, true); + const part45 = rs.intRemEuclid(a, b, 128, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 128, true); + const part44 = rs.intIsqrt(a, 128, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 128, true); + const part43 = rs.intIlog(a, b, 128, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 128, true); + const part42 = rs.intIlog2(a, 128, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 128, true); + const part41 = rs.intIlog10(a, 128, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.i128Add(a, b)); + _22(out, rs.i128Add(a, b)); } else if (_30 === 16) { - _22(out, rt.i128Sub(a, b)); + _22(out, rs.i128Sub(a, b)); } else if (_30 === 17) { - _22(out, rt.i128Mul(a, b)); + _22(out, rs.i128Mul(a, b)); } else if (_30 === 18) { - _22(out, rt.i128Div(a, b)); + _22(out, rs.i128Div(a, b)); } else if (_30 === 19) { - _22(out, rt.i128Rem(a, b)); + _22(out, rs.i128Rem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 128, true); + const part35 = rs.intStrictNeg(a, 128, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.i128Shl(a, k)); + _22(out, rs.i128Shl(a, k)); } else if (_30 === 22) { - _22(out, rt.i128Shr(a, k)); + _22(out, rs.i128Shr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 128, true); + const part32 = rs.intPow(a, k, 128, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 128, true); + const part31 = rs.intDivEuclid(a, b, 128, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 128, true); + const part30 = rs.intRemEuclid(a, b, 128, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 128, true); + const part29 = rs.intStrictAdd(a, o, 128, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 128, true); + const part28 = rs.intStrictSub(a, o, 128, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.i128WrappingDiv(a, b); + const part27 = rs.i128WrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.i128WrappingRem(a, b); + const part26 = rs.i128WrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 128, true); + const part25 = rs.intWrappingDivEuclid(a, b, 128, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 128, true); + const part24 = rs.intWrappingRemEuclid(a, b, 128, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 128, true); + const part23 = rs.intOverflowingDiv(a, b, 128, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 128, true); + const part22 = rs.intOverflowingRem(a, b, 128, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 128, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 128, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 128, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 128, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.i128SaturatingDiv(a, b); + const part19 = rs.i128SaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 128, true); + const part18 = rs.intAbs(a, 128, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 128, true); + const part17 = rs.intAbs(a, 128, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.i128 = a; - const w: rt.i128 = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 128, true), rt.intCountZeros(s2, 128, true), rt.i128LeadingZeros(s2), rt.i128TrailingZeros(s2)]); + const s2: rs.i128 = a; + const w: rs.i128 = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 128, true), rs.intCountZeros(s2, 128, true), rs.i128LeadingZeros(s2), rs.i128TrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 128, true), rt.intCountZeros(w, 128, true), rt.i128LeadingZeros(w), rt.i128TrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 128, true), rs.intCountZeros(w, 128, true), rs.i128LeadingZeros(w), rs.i128TrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 128, true), rt.intRotateRight(s2, n, 128, true), rt.intSwapBytes(s2, 128, true), rt.intReverseBits(s2, 128, true), rt.intSwapBytes(s2, 128, true), s2, rt.intSwapBytes(s2, 128, true), s2, rt.intSaturatingPow(s2, k, 128, true), rt.intSaturatingPow(s2, n, 128, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 128, true), rs.intRotateRight(s2, n, 128, true), rs.intSwapBytes(s2, 128, true), rs.intReverseBits(s2, 128, true), rs.intSwapBytes(s2, 128, true), s2, rs.intSwapBytes(s2, 128, true), s2, rs.intSaturatingPow(s2, k, 128, true), rs.intSaturatingPow(s2, n, 128, true)]); while (true) { - const _490: rt.i128 | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.i128 | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 128, true), rt.intRotateRight(w, n, 128, true), rt.intSwapBytes(w, 128, true), rt.intReverseBits(w, 128, true), rt.intSwapBytes(w, 128, true), w, rt.intSwapBytes(w, 128, true), w, rt.intWrappingPow(w, k, 128, true), rt.intWrappingPow(w, n, 128, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 128, true), rs.intRotateRight(w, n, 128, true), rs.intSwapBytes(w, 128, true), rs.intReverseBits(w, 128, true), rs.intSwapBytes(w, 128, true), w, rs.intSwapBytes(w, 128, true), w, rs.intWrappingPow(w, k, 128, true), rs.intWrappingPow(w, n, 128, true)]); while (true) { - const _511: rt.i128 | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.i128 | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 128, true), rt.intSignum(s2, 128, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 128, true), rs.intSignum(s2, 128, true)]); while (true) { - const _524: rt.i128 | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.i128 | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 128, true), rt.intSignum(w, 128, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 128, true), rs.intSignum(w, 128, true)]); while (true) { - const _537: rt.i128 | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.i128 | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.i128Gt(s2, 0) ? 1 : 0, rt.i128Lt(s2, 0) ? 1 : 0, rt.i128Gt(w, 0) ? 1 : 0, rt.i128Lt(w, 0) ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.i128Gt(s2, 0) ? 1 : 0, rs.i128Lt(s2, 0) ? 1 : 0, rs.i128Gt(w, 0) ? 1 : 0, rs.i128Lt(w, 0) ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.i128 | undefined, rt.i128 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.i128 | undefined, rs.i128 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.i128 = _557[0]; - const y: rt.i128 = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.i128LeadingZeros(x), rt.i128TrailingZeros(x), rt.intCountOnes(x, 128, true), 127 - rt.i128LeadingZeros(x), rt.i128TrailingZeros(x)]); + const x: rs.i128 = _557[0]; + const y: rs.i128 = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.i128LeadingZeros(x), rs.i128TrailingZeros(x), rs.intCountOnes(x, 128, true), 127 - rs.i128LeadingZeros(x), rs.i128TrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$18pd8cy(rt.i128CheckedMul(x, y), (a0: rt.i128): rt.i128 => { + const part4 = option_map$1ocvprc(rs.i128CheckedMul(x, y), (a0: rs.i128): rs.i128 => { return a0; }); putOpt(out, part4); - const part5 = rt.i128SaturatingMul(x, y); + const part5 = rs.i128SaturatingMul(x, y); _22(out, part5); - const part6 = option_map$18pd8cy(rt.intCheckedPow(x, k, 128, true), (a02: rt.i128): rt.i128 => { + const part6 = option_map$1ocvprc(rs.intCheckedPow(x, k, 128, true), (a02: rs.i128): rs.i128 => { return a02; }); putOpt(out, part6); - const part7 = option_map$18pd8cy(rt.intCheckedPow(x, n, 128, true), (a03: rt.i128): rt.i128 => { + const part7 = option_map$1ocvprc(rs.intCheckedPow(x, n, 128, true), (a03: rs.i128): rs.i128 => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 128, true); + const part8 = rs.intSaturatingPow(x, k, 128, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 128, true); + const part9 = rs.intIsolateHighestOne(x, 128, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 128, true); + const part10 = rs.intIsolateLowestOne(x, 128, true); _22(out, part10); - const part11 = option_map$18pd8cy(rt.intCheckedAbs(x, 128, true), (a04: rt.i128): rt.i128 => { + const part11 = option_map$1ocvprc(rs.intCheckedAbs(x, 128, true), (a04: rs.i128): rs.i128 => { return a04; }); putOpt(out, part11); - const _622: [rt.i128, boolean] = rt.intOverflowingAbs(x, 128, true); - putPair(out, [_622[0], _622[1]] as [rt.i128, boolean]); - const part12 = rt.intSaturatingAbs(x, 128, true); + const _622: [rs.i128, boolean] = rs.intOverflowingAbs(x, 128, true); + putPair(out, [_622[0], _622[1]] as [rs.i128, boolean]); + const part12 = rs.intSaturatingAbs(x, 128, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 128, true); + const part13 = rs.intWrappingAbs(x, 128, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.intUnsignedAbs(x, 128, true) as rt.u128))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(rt.i128Gt(x, 0) ? 1 : 0, rt.i128Lt(x, 0) ? 1 : 0))); - const part14 = option_map$18pd8cy(rt.intCheckedNeg(x, 128, true), (a05: rt.i128): rt.i128 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.intUnsignedAbs(x, 128, true) as rs.u128))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(rs.i128Gt(x, 0) ? 1 : 0, rs.i128Lt(x, 0) ? 1 : 0))); + const part14 = option_map$1ocvprc(rs.intCheckedNeg(x, 128, true), (a05: rs.i128): rs.i128 => { return a05; }); putOpt(out, part14); - const _659: [rt.i128, boolean] = rt.intOverflowingNeg(x, 128, true); - putPair(out, [_659[0], _659[1]] as [rt.i128, boolean]); - const part15 = rt.i128SaturatingSub(0, x); + const _659: [rs.i128, boolean] = rs.intOverflowingNeg(x, 128, true); + putPair(out, [_659[0], _659[1]] as [rs.i128, boolean]); + const part15 = rs.i128SaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 128, true); + const part16 = rs.intWrappingNeg(x, 128, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(x)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(x)))); } } } else { - const _681: rt.i128 | undefined = rt.nonZero(a); + const _681: rs.i128 | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 128, true); + const part3 = rs.intAbs(_681, 128, true); _22(out, part3); } } } /** Apply method `kind` to operands taken from `data`: two of the type, and a `u32`. */ -export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v8: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v8))); - rt.byteVecPush(out2, rt.isizeFromBeBytes(rt.isizeToBeBytes(v8)) === v8 ? 1 : 0); +export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v8: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v8))); + rs.byteVecPush(out2, rs.isizeFromBeBytes(rs.isizeToBeBytes(v8)) === v8 ? 1 : 0); }; - const _27: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out3: rt.ByteVec, v9: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out3, rt.byteSliceFrom(rt.u32ToBeBytes(v9))); + const _27: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out3: rs.ByteVec, v9: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out3, rs.byteSliceFrom(rs.u32ToBeBytes(v9))); }; - const byte: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const byte: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const a: rt.isize = rt.isizeFromBeBytes(rt.bytesFromFn(4, (i2: rt.usize): rt.u8 => { + const a: rs.isize = rs.isizeFromBeBytes(rs.bytesFromFn(4, (i2: rs.usize): rs.u8 => { return byte(i2); })); - const b: rt.isize = rt.isizeFromBeBytes(rt.bytesFromFn(4, (i3: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(4, i3)); + const b: rs.isize = rs.isizeFromBeBytes(rs.bytesFromFn(4, (i3: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(4, i3)); })); - const n: rt.u32 = rt.u32FromBeBytes(rt.bytesFromFn(4, (i4: rt.usize): rt.u8 => { - return byte(rt.usizeAdd(2 * 4, i4)); + const n: rs.u32 = rs.u32FromBeBytes(rs.bytesFromFn(4, (i4: rs.usize): rs.u8 => { + return byte(rs.usizeAdd(2 * 4, i4)); })); - const o: rt.usize = b >>> 0; - const k: rt.u32 = rt.u32Rem(n, 3 * 32); - const putOpt: (a0: rt.ByteVec, a1: rt.isize | undefined) => undefined = (out4: rt.ByteVec, v10: rt.isize | undefined): undefined => { + const o: rs.usize = b >>> 0; + const k: rs.u32 = rs.u32Rem(n, 3 * 32); + const putOpt: (a0: rs.ByteVec, a1: rs.isize | undefined) => undefined = (out4: rs.ByteVec, v10: rs.isize | undefined): undefined => { if (v10 === undefined) { - rt.byteVecPush(out4, 0); + rs.byteVecPush(out4, 0); } else { - const v11: rt.isize = v10; - rt.byteVecPush(out4, 1); + const v11: rs.isize = v10; + rs.byteVecPush(out4, 1); _22(out4, v11); } }; - const putPair: (a0: rt.ByteVec, a1: [rt.isize, boolean]) => undefined = (out5: rt.ByteVec, _37: [rt.isize, boolean]): undefined => { - const v12: rt.isize = _37[0]; + const putPair: (a0: rs.ByteVec, a1: [rs.isize, boolean]) => undefined = (out5: rs.ByteVec, _37: [rs.isize, boolean]): undefined => { + const v12: rs.isize = _37[0]; const over3: boolean = _37[1]; _22(out5, v12); - rt.byteVecPush(out5, over3 ? 1 : 0); + rs.byteVecPush(out5, over3 ? 1 : 0); }; - const putOptU32: (a0: rt.ByteVec, a1: rt.u32 | undefined) => undefined = (out6: rt.ByteVec, v13: rt.u32 | undefined): undefined => { + const putOptU32: (a0: rs.ByteVec, a1: rs.u32 | undefined) => undefined = (out6: rs.ByteVec, v13: rs.u32 | undefined): undefined => { if (v13 === undefined) { - rt.byteVecPush(out6, 0); + rs.byteVecPush(out6, 0); } else { - const v14: rt.u32 = v13; - rt.byteVecPush(out6, 1); + const v14: rs.u32 = v13; + rs.byteVecPush(out6, 1); _27(out6, v14); } }; - const _30: rt.u8 = rt.u8Rem(kind, 42); + const _30: rs.u8 = rs.u8Rem(kind, 42); if (_30 === 0) { - const part88 = rt.isizeCheckedAdd(a, b); + const part88 = rs.isizeCheckedAdd(a, b); putOpt(out, part88); - const part89 = rt.isizeCheckedSub(a, b); + const part89 = rs.isizeCheckedSub(a, b); putOpt(out, part89); - const part90 = rt.isizeCheckedMul(a, b); + const part90 = rs.isizeCheckedMul(a, b); putOpt(out, part90); - const part91 = rt.isizeSaturatingAdd(a, b); + const part91 = rs.isizeSaturatingAdd(a, b); _22(out, part91); - const part92 = rt.isizeSaturatingSub(a, b); + const part92 = rs.isizeSaturatingSub(a, b); _22(out, part92); - const part93 = rt.isizeSaturatingMul(a, b); + const part93 = rs.isizeSaturatingMul(a, b); _22(out, part93); - const part94 = rt.isizeWrappingAdd(a, b); + const part94 = rs.isizeWrappingAdd(a, b); _22(out, part94); - const part95 = rt.isizeWrappingSub(a, b); + const part95 = rs.isizeWrappingSub(a, b); _22(out, part95); - const part96 = rt.isizeWrappingMul(a, b); + const part96 = rs.isizeWrappingMul(a, b); _22(out, part96); - const part97 = rt.intOverflowingAdd(a, b, 32, true); + const part97 = rs.intOverflowingAdd(a, b, 32, true); putPair(out, part97); - const part98 = rt.intOverflowingSub(a, b, 32, true); + const part98 = rs.intOverflowingSub(a, b, 32, true); putPair(out, part98); - const part99 = rt.intOverflowingMul(a, b, 32, true); + const part99 = rs.intOverflowingMul(a, b, 32, true); putPair(out, part99); - const part100 = rt.intMidpoint(a, b, 32, true); + const part100 = rs.intMidpoint(a, b, 32, true); _22(out, part100); - const part101 = rt.intCheckedAdd(a, o, 32, true); + const part101 = rs.intCheckedAdd(a, o, 32, true); putOpt(out, part101); - const part102 = rt.intCheckedSub(a, o, 32, true); + const part102 = rs.intCheckedSub(a, o, 32, true); putOpt(out, part102); - const part103 = rt.intSaturatingAdd(a, o, 32, true); + const part103 = rs.intSaturatingAdd(a, o, 32, true); _22(out, part103); - const part104 = rt.intSaturatingSub(a, o, 32, true); + const part104 = rs.intSaturatingSub(a, o, 32, true); _22(out, part104); - const part105 = rt.intWrappingAdd(a, o, 32, true); + const part105 = rs.intWrappingAdd(a, o, 32, true); _22(out, part105); - const part106 = rt.intWrappingSub(a, o, 32, true); + const part106 = rs.intWrappingSub(a, o, 32, true); _22(out, part106); - const part107 = rt.intOverflowingAdd(a, o, 32, true); + const part107 = rs.intOverflowingAdd(a, o, 32, true); putPair(out, part107); - const part108 = rt.intOverflowingSub(a, o, 32, true); + const part108 = rs.intOverflowingSub(a, o, 32, true); putPair(out, part108); } else if (_30 === 1) { - const part80 = rt.intCheckedDiv(a, b, 32, true); + const part80 = rs.intCheckedDiv(a, b, 32, true); putOpt(out, part80); - const part81 = rt.intCheckedRem(a, b, 32, true); + const part81 = rs.intCheckedRem(a, b, 32, true); putOpt(out, part81); - const part82 = rt.intCheckedDivEuclid(a, b, 32, true); + const part82 = rs.intCheckedDivEuclid(a, b, 32, true); putOpt(out, part82); - const part83 = rt.intCheckedRemEuclid(a, b, 32, true); + const part83 = rs.intCheckedRemEuclid(a, b, 32, true); putOpt(out, part83); if (b !== 0) { - const part84 = rt.isizeWrappingDiv(a, b); + const part84 = rs.isizeWrappingDiv(a, b); _22(out, part84); - const part85 = rt.isizeWrappingRem(a, b); + const part85 = rs.isizeWrappingRem(a, b); _22(out, part85); - const part86 = rt.intOverflowingDivEuclid(a, b, 32, true); + const part86 = rs.intOverflowingDivEuclid(a, b, 32, true); putPair(out, part86); - const part87 = rt.intOverflowingRemEuclid(a, b, 32, true); + const part87 = rs.intOverflowingRemEuclid(a, b, 32, true); putPair(out, part87); } } else if (_30 === 2) { - const part70 = rt.intCheckedNeg(a, 32, true); + const part70 = rs.intCheckedNeg(a, 32, true); putOpt(out, part70); - const part71 = rt.intWrappingNeg(a, 32, true); + const part71 = rs.intWrappingNeg(a, 32, true); _22(out, part71); - const part72 = rt.intOverflowingNeg(a, 32, true); + const part72 = rs.intOverflowingNeg(a, 32, true); putPair(out, part72); - const part73 = rt.intCheckedAbs(a, 32, true); + const part73 = rs.intCheckedAbs(a, 32, true); putOpt(out, part73); - const part74 = rt.intWrappingAbs(a, 32, true); + const part74 = rs.intWrappingAbs(a, 32, true); _22(out, part74); - const part75 = rt.intSaturatingAbs(a, 32, true); + const part75 = rs.intSaturatingAbs(a, 32, true); _22(out, part75); - const part76 = rt.intOverflowingAbs(a, 32, true); + const part76 = rs.intOverflowingAbs(a, 32, true); putPair(out, part76); - const part77 = rt.isizeSaturatingSub(0, a); + const part77 = rs.isizeSaturatingSub(0, a); _22(out, part77); - const part78 = rt.intSignum(a, 32, true); + const part78 = rs.intSignum(a, 32, true); _22(out, part78); - rt.byteVecPush(out, a > 0 ? 1 : 0); - rt.byteVecPush(out, a < 0 ? 1 : 0); - const part79 = rt.intCheckedIsqrt(a, 32, true); + rs.byteVecPush(out, a > 0 ? 1 : 0); + rs.byteVecPush(out, a < 0 ? 1 : 0); + const part79 = rs.intCheckedIsqrt(a, 32, true); putOpt(out, part79); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.intUnsignedAbs(a, 32, true) as rt.usize))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(a >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.intUnsignedAbs(a, 32, true) as rs.usize))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(a >>> 0))); } else if (_30 === 3) { - const iter: rt.Iter = rt.iterSlice([n, k]); + const iter: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _208: rt.u32 | rt.Done = iter.next(); - if (_208 === rt.DONE) { + const _208: rs.u32 | rs.Done = iter.next(); + if (_208 === rs.DONE) { break; } - const e: rt.u32 = _208; - const part66 = rt.intCheckedPow(a, e, 32, true); + const e: rs.u32 = _208; + const part66 = rs.intCheckedPow(a, e, 32, true); putOpt(out, part66); - const part67 = rt.intWrappingPow(a, e, 32, true); + const part67 = rs.intWrappingPow(a, e, 32, true); _22(out, part67); - const part68 = rt.intSaturatingPow(a, e, 32, true); + const part68 = rs.intSaturatingPow(a, e, 32, true); _22(out, part68); - const part69 = rt.intOverflowingPow(a, e, 32, true); + const part69 = rs.intOverflowingPow(a, e, 32, true); putPair(out, part69); } } else if (_30 === 4) { - const iter2: rt.Iter = rt.iterSlice([n, k]); + const iter2: rs.Iter = rs.iterSlice([n, k]); while (true) { - const _231: rt.u32 | rt.Done = iter2.next(); - if (_231 === rt.DONE) { + const _231: rs.u32 | rs.Done = iter2.next(); + if (_231 === rs.DONE) { break; } - const s: rt.u32 = _231; - const part56 = rt.intCheckedShl(a, s, 32, true); + const s: rs.u32 = _231; + const part56 = rs.intCheckedShl(a, s, 32, true); putOpt(out, part56); - const part57 = rt.intCheckedShr(a, s, 32, true); + const part57 = rs.intCheckedShr(a, s, 32, true); putOpt(out, part57); - const part58 = rt.intWrappingShl(a, s, 32, true); + const part58 = rs.intWrappingShl(a, s, 32, true); _22(out, part58); - const part59 = rt.intWrappingShr(a, s, 32, true); + const part59 = rs.intWrappingShr(a, s, 32, true); _22(out, part59); - const part60 = rt.intOverflowingShl(a, s, 32, true); + const part60 = rs.intOverflowingShl(a, s, 32, true); putPair(out, part60); - const part61 = rt.intOverflowingShr(a, s, 32, true); + const part61 = rs.intOverflowingShr(a, s, 32, true); putPair(out, part61); - const part62 = rt.intUnboundedShl(a, s, 32, true); + const part62 = rs.intUnboundedShl(a, s, 32, true); _22(out, part62); - const part63 = rt.intUnboundedShr(a, s, 32, true); + const part63 = rs.intUnboundedShr(a, s, 32, true); _22(out, part63); - const part64 = rt.intRotateLeft(a, s, 32, true); + const part64 = rs.intRotateLeft(a, s, 32, true); _22(out, part64); - const part65 = rt.intRotateRight(a, s, 32, true); + const part65 = rs.intRotateRight(a, s, 32, true); _22(out, part65); } } else if (_30 === 5) { - const iter3: rt.Iter = rt.iterSlice([rt.intCountOnes(a, 32, true), rt.intCountZeros(a, 32, true), rt.isizeLeadingZeros(a), rt.isizeTrailingZeros(a), rt.isizeLeadingOnes(a), rt.intTrailingOnes(a, 32, true)]); + const iter3: rs.Iter = rs.iterSlice([rs.intCountOnes(a, 32, true), rs.intCountZeros(a, 32, true), rs.isizeLeadingZeros(a), rs.isizeTrailingZeros(a), rs.isizeLeadingOnes(a), rs.intTrailingOnes(a, 32, true)]); while (true) { - const _284: rt.u32 | rt.Done = iter3.next(); - if (_284 === rt.DONE) { + const _284: rs.u32 | rs.Done = iter3.next(); + if (_284 === rs.DONE) { break; } _27(out, _284); } - const iter4: rt.Iter = rt.iterSlice([rt.intSwapBytes(a, 32, true), rt.intReverseBits(a, 32, true), rt.intSwapBytes(a, 32, true), a, rt.intSwapBytes(a, 32, true), a]); + const iter4: rs.Iter = rs.iterSlice([rs.intSwapBytes(a, 32, true), rs.intReverseBits(a, 32, true), rs.intSwapBytes(a, 32, true), a, rs.intSwapBytes(a, 32, true), a]); while (true) { - const _300: rt.isize | rt.Done = iter4.next(); - if (_300 === rt.DONE) { + const _300: rs.isize | rs.Done = iter4.next(); + if (_300 === rs.DONE) { break; } _22(out, _300); } - const part52 = rt.intHighestOne(a, 32, true); + const part52 = rs.intHighestOne(a, 32, true); putOptU32(out, part52); - const part53 = rt.intLowestOne(a, 32, true); + const part53 = rs.intLowestOne(a, 32, true); putOptU32(out, part53); - const part54 = rt.intIsolateHighestOne(a, 32, true); + const part54 = rs.intIsolateHighestOne(a, 32, true); _22(out, part54); - const part55 = rt.intIsolateLowestOne(a, 32, true); + const part55 = rs.intIsolateLowestOne(a, 32, true); _22(out, part55); _22(out, 2147483647); _22(out, -2147483648); } else if (_30 === 6) { - const part49 = rt.intCheckedIlog(a, b, 32, true); + const part49 = rs.intCheckedIlog(a, b, 32, true); putOptU32(out, part49); - const part50 = rt.intCheckedIlog2(a, 32, true); + const part50 = rs.intCheckedIlog2(a, 32, true); putOptU32(out, part50); - const part51 = rt.intCheckedIlog10(a, 32, true); + const part51 = rs.intCheckedIlog10(a, 32, true); putOptU32(out, part51); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.intAbsDiff(a, b, 32, true) as rt.usize))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.intAbsDiff(a, b, 32, true) as rs.usize))); } else if (_30 === 7) { - const part48 = rt.intPow(a, k, 32, true); + const part48 = rs.intPow(a, k, 32, true); _22(out, part48); } else if (_30 === 8) { - const part47 = rt.intPow(a, n, 32, true); + const part47 = rs.intPow(a, n, 32, true); _22(out, part47); } else if (_30 === 9) { - const part46 = rt.intDivEuclid(a, b, 32, true); + const part46 = rs.intDivEuclid(a, b, 32, true); _22(out, part46); } else if (_30 === 10) { - const part45 = rt.intRemEuclid(a, b, 32, true); + const part45 = rs.intRemEuclid(a, b, 32, true); _22(out, part45); } else if (_30 === 11) { - const part44 = rt.intIsqrt(a, 32, true); + const part44 = rs.intIsqrt(a, 32, true); _22(out, part44); } else if (_30 === 12) { - const part43 = rt.intIlog(a, b, 32, true); + const part43 = rs.intIlog(a, b, 32, true); _27(out, part43); } else if (_30 === 13) { - const part42 = rt.intIlog2(a, 32, true); + const part42 = rs.intIlog2(a, 32, true); _27(out, part42); } else if (_30 === 14) { - const part41 = rt.intIlog10(a, 32, true); + const part41 = rs.intIlog10(a, 32, true); _27(out, part41); } else if (_30 === 15) { - _22(out, rt.isizeAdd(a, b)); + _22(out, rs.isizeAdd(a, b)); } else if (_30 === 16) { - _22(out, rt.isizeSub(a, b)); + _22(out, rs.isizeSub(a, b)); } else if (_30 === 17) { - _22(out, rt.isizeMul(a, b)); + _22(out, rs.isizeMul(a, b)); } else if (_30 === 18) { - _22(out, rt.isizeDiv(a, b)); + _22(out, rs.isizeDiv(a, b)); } else if (_30 === 19) { - _22(out, rt.isizeRem(a, b)); + _22(out, rs.isizeRem(a, b)); } else if (_30 === 20) { - const part35 = rt.intStrictNeg(a, 32, true); + const part35 = rs.intStrictNeg(a, 32, true); _22(out, part35); } else if (_30 === 21) { - _22(out, rt.isizeShl(a, k)); + _22(out, rs.isizeShl(a, k)); } else if (_30 === 22) { - _22(out, rt.isizeShr(a, k)); + _22(out, rs.isizeShr(a, k)); } else if (_30 === 23) { - const part32 = rt.intPow(a, k, 32, true); + const part32 = rs.intPow(a, k, 32, true); _22(out, part32); } else if (_30 === 24) { - const part31 = rt.intDivEuclid(a, b, 32, true); + const part31 = rs.intDivEuclid(a, b, 32, true); _22(out, part31); } else if (_30 === 25) { - const part30 = rt.intRemEuclid(a, b, 32, true); + const part30 = rs.intRemEuclid(a, b, 32, true); _22(out, part30); } else if (_30 === 26) { - const part29 = rt.intStrictAdd(a, o, 32, true); + const part29 = rs.intStrictAdd(a, o, 32, true); _22(out, part29); } else if (_30 === 27) { - const part28 = rt.intStrictSub(a, o, 32, true); + const part28 = rs.intStrictSub(a, o, 32, true); _22(out, part28); } else if (_30 === 28) { - const part27 = rt.isizeWrappingDiv(a, b); + const part27 = rs.isizeWrappingDiv(a, b); _22(out, part27); } else if (_30 === 29) { - const part26 = rt.isizeWrappingRem(a, b); + const part26 = rs.isizeWrappingRem(a, b); _22(out, part26); } else if (_30 === 30) { - const part25 = rt.intWrappingDivEuclid(a, b, 32, true); + const part25 = rs.intWrappingDivEuclid(a, b, 32, true); _22(out, part25); } else if (_30 === 31) { - const part24 = rt.intWrappingRemEuclid(a, b, 32, true); + const part24 = rs.intWrappingRemEuclid(a, b, 32, true); _22(out, part24); } else if (_30 === 32) { - const part23 = rt.intOverflowingDiv(a, b, 32, true); + const part23 = rs.intOverflowingDiv(a, b, 32, true); putPair(out, part23); } else if (_30 === 33) { - const part22 = rt.intOverflowingRem(a, b, 32, true); + const part22 = rs.intOverflowingRem(a, b, 32, true); putPair(out, part22); } else if (_30 === 34) { - const part21 = rt.intOverflowingDivEuclid(a, b, 32, true); + const part21 = rs.intOverflowingDivEuclid(a, b, 32, true); putPair(out, part21); } else if (_30 === 35) { - const part20 = rt.intOverflowingRemEuclid(a, b, 32, true); + const part20 = rs.intOverflowingRemEuclid(a, b, 32, true); putPair(out, part20); } else if (_30 === 36) { - const part19 = rt.isizeSaturatingDiv(a, b); + const part19 = rs.isizeSaturatingDiv(a, b); _22(out, part19); } else if (_30 === 37) { - const part18 = rt.intAbs(a, 32, true); + const part18 = rs.intAbs(a, 32, true); _22(out, part18); } else if (_30 === 38) { - const part17 = rt.intAbs(a, 32, true); + const part17 = rs.intAbs(a, 32, true); _22(out, part17); } else if (_30 === 39) { - const s2: rt.isize = a; - const w: rt.isize = a; - const iter5: rt.Iter = rt.iterSlice([rt.intCountOnes(s2, 32, true), rt.intCountZeros(s2, 32, true), rt.isizeLeadingZeros(s2), rt.isizeTrailingZeros(s2)]); + const s2: rs.isize = a; + const w: rs.isize = a; + const iter5: rs.Iter = rs.iterSlice([rs.intCountOnes(s2, 32, true), rs.intCountZeros(s2, 32, true), rs.isizeLeadingZeros(s2), rs.isizeTrailingZeros(s2)]); while (true) { - const _456: rt.u32 | rt.Done = iter5.next(); - if (_456 === rt.DONE) { + const _456: rs.u32 | rs.Done = iter5.next(); + if (_456 === rs.DONE) { break; } _27(out, _456); } - const iter6: rt.Iter = rt.iterSlice([rt.intCountOnes(w, 32, true), rt.intCountZeros(w, 32, true), rt.isizeLeadingZeros(w), rt.isizeTrailingZeros(w)]); + const iter6: rs.Iter = rs.iterSlice([rs.intCountOnes(w, 32, true), rs.intCountZeros(w, 32, true), rs.isizeLeadingZeros(w), rs.isizeTrailingZeros(w)]); while (true) { - const _470: rt.u32 | rt.Done = iter6.next(); - if (_470 === rt.DONE) { + const _470: rs.u32 | rs.Done = iter6.next(); + if (_470 === rs.DONE) { break; } _27(out, _470); } - const iter7: rt.Iter = rt.iterSlice([rt.intRotateLeft(s2, k, 32, true), rt.intRotateRight(s2, n, 32, true), rt.intSwapBytes(s2, 32, true), rt.intReverseBits(s2, 32, true), rt.intSwapBytes(s2, 32, true), s2, rt.intSwapBytes(s2, 32, true), s2, rt.intSaturatingPow(s2, k, 32, true), rt.intSaturatingPow(s2, n, 32, true)]); + const iter7: rs.Iter = rs.iterSlice([rs.intRotateLeft(s2, k, 32, true), rs.intRotateRight(s2, n, 32, true), rs.intSwapBytes(s2, 32, true), rs.intReverseBits(s2, 32, true), rs.intSwapBytes(s2, 32, true), s2, rs.intSwapBytes(s2, 32, true), s2, rs.intSaturatingPow(s2, k, 32, true), rs.intSaturatingPow(s2, n, 32, true)]); while (true) { - const _490: rt.isize | rt.Done = iter7.next(); - if (_490 === rt.DONE) { + const _490: rs.isize | rs.Done = iter7.next(); + if (_490 === rs.DONE) { break; } _22(out, _490); } - const iter8: rt.Iter = rt.iterSlice([rt.intRotateLeft(w, k, 32, true), rt.intRotateRight(w, n, 32, true), rt.intSwapBytes(w, 32, true), rt.intReverseBits(w, 32, true), rt.intSwapBytes(w, 32, true), w, rt.intSwapBytes(w, 32, true), w, rt.intWrappingPow(w, k, 32, true), rt.intWrappingPow(w, n, 32, true)]); + const iter8: rs.Iter = rs.iterSlice([rs.intRotateLeft(w, k, 32, true), rs.intRotateRight(w, n, 32, true), rs.intSwapBytes(w, 32, true), rs.intReverseBits(w, 32, true), rs.intSwapBytes(w, 32, true), w, rs.intSwapBytes(w, 32, true), w, rs.intWrappingPow(w, k, 32, true), rs.intWrappingPow(w, n, 32, true)]); while (true) { - const _511: rt.isize | rt.Done = iter8.next(); - if (_511 === rt.DONE) { + const _511: rs.isize | rs.Done = iter8.next(); + if (_511 === rs.DONE) { break; } _22(out, _511); } - const iter9: rt.Iter = rt.iterSlice([rt.intSaturatingAbs(s2, 32, true), rt.intSignum(s2, 32, true)]); + const iter9: rs.Iter = rs.iterSlice([rs.intSaturatingAbs(s2, 32, true), rs.intSignum(s2, 32, true)]); while (true) { - const _524: rt.isize | rt.Done = iter9.next(); - if (_524 === rt.DONE) { + const _524: rs.isize | rs.Done = iter9.next(); + if (_524 === rs.DONE) { break; } _22(out, _524); } - const iter10: rt.Iter = rt.iterSlice([rt.intWrappingAbs(w, 32, true), rt.intSignum(w, 32, true)]); + const iter10: rs.Iter = rs.iterSlice([rs.intWrappingAbs(w, 32, true), rs.intSignum(w, 32, true)]); while (true) { - const _537: rt.isize | rt.Done = iter10.next(); - if (_537 === rt.DONE) { + const _537: rs.isize | rs.Done = iter10.next(); + if (_537 === rs.DONE) { break; } _22(out, _537); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(s2 > 0 ? 1 : 0, s2 < 0 ? 1 : 0, w > 0 ? 1 : 0, w < 0 ? 1 : 0))); } else if (_30 === 40) { - const _557: [rt.isize | undefined, rt.isize | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _557: [rs.isize | undefined, rs.isize | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_557[0] !== undefined) { if (_557[1] !== undefined) { - const x: rt.isize = _557[0]; - const y: rt.isize = _557[1]; - const iter11: rt.Iter = rt.iterSlice([rt.isizeLeadingZeros(x), rt.isizeTrailingZeros(x), rt.intCountOnes(x, 32, true), 31 - rt.isizeLeadingZeros(x), rt.isizeTrailingZeros(x)]); + const x: rs.isize = _557[0]; + const y: rs.isize = _557[1]; + const iter11: rs.Iter = rs.iterSlice([rs.isizeLeadingZeros(x), rs.isizeTrailingZeros(x), rs.intCountOnes(x, 32, true), 31 - rs.isizeLeadingZeros(x), rs.isizeTrailingZeros(x)]); while (true) { - const _573: rt.u32 | rt.Done = iter11.next(); - if (_573 === rt.DONE) { + const _573: rs.u32 | rs.Done = iter11.next(); + if (_573 === rs.DONE) { break; } _27(out, _573); } - const part4 = option_map$1rlqf9d(rt.isizeCheckedMul(x, y), (a0: rt.isize): rt.isize => { + const part4 = option_map$1vj7z9f(rs.isizeCheckedMul(x, y), (a0: rs.isize): rs.isize => { return a0; }); putOpt(out, part4); - const part5 = rt.isizeSaturatingMul(x, y); + const part5 = rs.isizeSaturatingMul(x, y); _22(out, part5); - const part6 = option_map$1rlqf9d(rt.intCheckedPow(x, k, 32, true), (a02: rt.isize): rt.isize => { + const part6 = option_map$1vj7z9f(rs.intCheckedPow(x, k, 32, true), (a02: rs.isize): rs.isize => { return a02; }); putOpt(out, part6); - const part7 = option_map$1rlqf9d(rt.intCheckedPow(x, n, 32, true), (a03: rt.isize): rt.isize => { + const part7 = option_map$1vj7z9f(rs.intCheckedPow(x, n, 32, true), (a03: rs.isize): rs.isize => { return a03; }); putOpt(out, part7); - const part8 = rt.intSaturatingPow(x, k, 32, true); + const part8 = rs.intSaturatingPow(x, k, 32, true); _22(out, part8); - const part9 = rt.intIsolateHighestOne(x, 32, true); + const part9 = rs.intIsolateHighestOne(x, 32, true); _22(out, part9); - const part10 = rt.intIsolateLowestOne(x, 32, true); + const part10 = rs.intIsolateLowestOne(x, 32, true); _22(out, part10); - const part11 = option_map$1rlqf9d(rt.intCheckedAbs(x, 32, true), (a04: rt.isize): rt.isize => { + const part11 = option_map$1vj7z9f(rs.intCheckedAbs(x, 32, true), (a04: rs.isize): rs.isize => { return a04; }); putOpt(out, part11); - const _622: [rt.isize, boolean] = rt.intOverflowingAbs(x, 32, true); - putPair(out, [_622[0], _622[1]] as [rt.isize, boolean]); - const part12 = rt.intSaturatingAbs(x, 32, true); + const _622: [rs.isize, boolean] = rs.intOverflowingAbs(x, 32, true); + putPair(out, [_622[0], _622[1]] as [rs.isize, boolean]); + const part12 = rs.intSaturatingAbs(x, 32, true); _22(out, part12); - const part13 = rt.intWrappingAbs(x, 32, true); + const part13 = rs.intWrappingAbs(x, 32, true); _22(out, part13); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.intUnsignedAbs(x, 32, true) as rt.usize))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); - const part14 = option_map$1rlqf9d(rt.intCheckedNeg(x, 32, true), (a05: rt.isize): rt.isize => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.intUnsignedAbs(x, 32, true) as rs.usize))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x > 0 ? 1 : 0, x < 0 ? 1 : 0))); + const part14 = option_map$1vj7z9f(rs.intCheckedNeg(x, 32, true), (a05: rs.isize): rs.isize => { return a05; }); putOpt(out, part14); - const _659: [rt.isize, boolean] = rt.intOverflowingNeg(x, 32, true); - putPair(out, [_659[0], _659[1]] as [rt.isize, boolean]); - const part15 = rt.isizeSaturatingSub(0, x); + const _659: [rs.isize, boolean] = rs.intOverflowingNeg(x, 32, true); + putPair(out, [_659[0], _659[1]] as [rs.isize, boolean]); + const part15 = rs.isizeSaturatingSub(0, x); _22(out, part15); - const part16 = rt.intWrappingNeg(x, 32, true); + const part16 = rs.intWrappingNeg(x, 32, true); _22(out, part16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(x >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(x >>> 0))); } } } else { - const _681: rt.isize | undefined = rt.nonZero(a); + const _681: rs.isize | undefined = rs.nonZero(a); if (_681 !== undefined) { - const part3 = rt.intAbs(_681, 32, true); + const part3 = rs.intAbs(_681, 32, true); _22(out, part3); } } diff --git a/ts/fixtures/lang/nested/expected/core/bool.ts b/ts/fixtures/lang/nested/expected/core/bool.ts index 6f6d7192c..a2b7a1354 100644 --- a/ts/fixtures/lang/nested/expected/core/bool.ts +++ b/ts/fixtures/lang/nested/expected/core/bool.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { +export function thenSome$1n1oy1h(self: boolean, _: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return undefined; } -export function then$16ew6vr(self: boolean, f: () => rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function then$1uky7mt(self: boolean, f: () => rs.u8 | undefined): rs.u8 | undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return f(); } diff --git a/ts/fixtures/lang/nested/expected/core/option.ts b/ts/fixtures/lang/nested/expected/core/option.ts index fe5056a1f..0b4d32561 100644 --- a/ts/fixtures/lang/nested/expected/core/option.ts +++ b/ts/fixtures/lang/nested/expected/core/option.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isNoneOr$1s1o3ss(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isNoneOr$0xn3i4j(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return true; } return f(self); } -export function unwrapOr$1kxjsqb(self: rt.u8 | undefined | rt.None, default_: rt.u8 | undefined): rt.u8 | undefined { - if (self === rt.None) { +export function unwrapOr$1hs5os9(self: rs.u8 | undefined | rs.None, default_: rs.u8 | undefined): rs.u8 | undefined { + if (self === rs.None) { return default_; } return self; @@ -23,140 +23,140 @@ export function unwrapOr$1la41a6(self: Uint8Array | undefined, default_: Uint8Ar return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0pkankm(self: rt.u8 | undefined | rt.None, f: (a0: rt.u8 | undefined) => rt.u8 | undefined): rt.u8 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$008v810(self: rs.u8 | undefined | rs.None, f: (a0: rs.u8 | undefined) => rs.u8 | undefined): rs.u8 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return f(self); } -export function map$1diqi3e(self: rt.Place | undefined, f: (a0: rt.Place) => undefined): undefined | rt.None { +export function map$16kn1k2(self: rs.Place | undefined, f: (a0: rs.Place) => undefined): undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } f(self); return undefined; } -export function map$0rbsrz6(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function map$1yv0md6(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function map$0p22lts(self: rt.u8 | undefined, f: (a0: rt.u8) => undefined): undefined | rt.None { +export function map$057a36e(self: rs.u8 | undefined, f: (a0: rs.u8) => undefined): undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } f(self); return undefined; } -export function map$0jcaaxx(self: [rt.u8 | undefined, rt.u8] | undefined, f: (a0: [rt.u8 | undefined, rt.u8]) => Uint8Array): Uint8Array | undefined { +export function map$0f5oamy(self: [rs.u8 | undefined, rs.u8] | undefined, f: (a0: [rs.u8 | undefined, rs.u8]) => Uint8Array): Uint8Array | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0at3a41(self: undefined | rt.None, f: (a0: undefined) => rt.u8 | undefined): rt.u8 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$1eqzs00(self: undefined | rs.None, f: (a0: undefined) => rs.u8 | undefined): rs.u8 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return f(undefined); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$06rr3sb(self: rt.u8 | undefined, default_: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined { +export function mapOr$19a4gco(self: rs.u8 | undefined, default_: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$18ph0j9(self: undefined | rt.None, default_: rt.u8, f: (a0: undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$0mkqwg8(self: undefined | rs.None, default_: rs.u8, f: (a0: undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(undefined); } -export function okOr$1vxk0yk(self: rt.u8 | undefined, err: rt.u8): rt.Result { +export function okOr$1j8owgb(self: rs.u8 | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$0g9lvh7(self: rt.u8 | undefined, _: undefined): rt.Result { +export function okOr$06f2ml7(self: rs.u8 | undefined, _: undefined): rs.Result { if (self === undefined) { - return rt.ERR; + return rs.ERR; } - return rt.Ok(self); + return rs.Ok(self); } -export function andThen$0qni7te(self: rt.u8 | undefined | rt.None, f: (a0: rt.u8 | undefined) => rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function andThen$0xvwl6s(self: rs.u8 | undefined | rs.None, f: (a0: rs.u8 | undefined) => rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return f(self); } -export function andThen$0ocv8av(self: Array | undefined, f: (a0: Array) => rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { +export function andThen$1l1aa1i(self: Array | undefined, f: (a0: Array) => rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function andThen$1bd14ex(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { +export function andThen$0jc4o0i(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function filter$19gtvc4(self: rt.u8 | undefined | rt.None, predicate: (a0: rt.u8 | undefined) => boolean): rt.u8 | undefined | rt.None { - if (self !== rt.None) { - const x: rt.u8 | undefined = self; +export function filter$1iofxfx(self: rs.u8 | undefined | rs.None, predicate: (a0: rs.u8 | undefined) => boolean): rs.u8 | undefined | rs.None { + if (self !== rs.None) { + const x: rs.u8 | undefined = self; if (predicate(x)) { return x; } } - return rt.None; + return rs.None; } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } @@ -164,32 +164,32 @@ export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) = return undefined; } -export function or$0j02yk0(self: rt.u8 | undefined | rt.None, optb: rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { - if (self === rt.None) { +export function or$0farkzq(self: rs.u8 | undefined | rs.None, optb: rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { + if (self === rs.None) { return optb; } return self; } -export function xor$0pemq84(self: rt.u8 | undefined | rt.None, optb: rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { - let _0!: rt.u8 | undefined | rt.None; +export function xor$0ucxb2n(self: rs.u8 | undefined | rs.None, optb: rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { + let _0!: rs.u8 | undefined | rs.None; b0: { - if (self === rt.None) { - if (optb !== rt.None) { + if (self === rs.None) { + if (optb !== rs.None) { _0 = optb; break b0; } - } else if (optb === rt.None) { + } else if (optb === rs.None) { _0 = self; break b0; } - _0 = rt.None; + _0 = rs.None; } return _0; } -export function xor$0kctyix(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { - let _0!: rt.u8 | undefined; +export function xor$0x5qjg4(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { + let _0!: rs.u8 | undefined; b0: { if (self === undefined) { if (optb !== undefined) { @@ -205,8 +205,8 @@ export function xor$0kctyix(self: rt.u8 | undefined, optb: rt.u8 | undefined): r return _0; } -export function flatten$1nwzx42(self: rt.u8 | undefined | rt.None): rt.u8 | undefined { - if (self === rt.None) { +export function flatten$0ux6gqw(self: rs.u8 | undefined | rs.None): rs.u8 | undefined { + if (self === rs.None) { return undefined; } return self; diff --git a/ts/fixtures/lang/nested/expected/core/result.ts b/ts/fixtures/lang/nested/expected/core/result.ts index 3cbe333d9..38db98c73 100644 --- a/ts/fixtures/lang/nested/expected/core/result.ts +++ b/ts/fixtures/lang/nested/expected/core/result.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$03hz3l7(self: rt.Result, op: (a0: rt.u8) => undefined): rt.Result { +export function map$1gelxzx(self: rs.Result, op: (a0: rs.u8) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function mapErr$1whfgss(self: rt.Result, op: (a0: undefined) => undefined): rt.Result { +export function mapErr$136pgpq(self: rs.Result, op: (a0: undefined) => undefined): rs.Result { if (self.ok) { return self; } op(undefined); - return rt.ERR; + return rs.ERR; } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/nested/expected/harness.ts b/ts/fixtures/lang/nested/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/nested/expected/harness.ts +++ b/ts/fixtures/lang/nested/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/nested/expected/lib.ts b/ts/fixtures/lang/nested/expected/lib.ts index 11661a6b3..2ba26f87e 100644 --- a/ts/fixtures/lang/nested/expected/lib.ts +++ b/ts/fixtures/lang/nested/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { nested } from "./nested.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["nested::nested", nested as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["nested::nested", nested as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/nested/expected/nested.Halves.ts b/ts/fixtures/lang/nested/expected/nested.Halves.ts index ace8bd939..acffcd982 100644 --- a/ts/fixtures/lang/nested/expected/nested.Halves.ts +++ b/ts/fixtures/lang/nested/expected/nested.Halves.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { halve } from "./nested.ts"; /** Counts down to 0, yielding each count as an `Option`: `None` for each odd one. */ export interface Halves { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(self: Halves): rt.u8 | undefined | rt.Done { - const _2: rt.u8 | undefined = rt.u8CheckedSub(self._0, 1); +export function next$iter_Iterator(self: Halves): rs.u8 | undefined | rs.Done { + const _2: rs.u8 | undefined = rs.u8CheckedSub(self._0, 1); if (_2 !== undefined) { - const n: rt.u8 = _2; + const n: rs.u8 = _2; self._0 = n; - return rt.iterFromOption(halve(n), rt.None); + return rs.iterFromOption(halve(n), rs.None); } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=nested.Halves.ts.map diff --git a/ts/fixtures/lang/nested/expected/nested.Slot.ts b/ts/fixtures/lang/nested/expected/nested.Slot.ts index faddb020a..91845d806 100644 --- a/ts/fixtures/lang/nested/expected/nested.Slot.ts +++ b/ts/fixtures/lang/nested/expected/nested.Slot.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Slot { - held: rt.u8 | undefined | rt.None; - flag: undefined | rt.None; + held: rs.u8 | undefined | rs.None; + flag: undefined | rs.None; } //# sourceMappingURL=nested.Slot.ts.map diff --git a/ts/fixtures/lang/nested/expected/nested.Tagged.ts b/ts/fixtures/lang/nested/expected/nested.Tagged.ts index 2ba244cb7..fa8783b46 100644 --- a/ts/fixtures/lang/nested/expected/nested.Tagged.ts +++ b/ts/fixtures/lang/nested/expected/nested.Tagged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A generic type over a `T` that can be `undefined`, beside a field of no type parameter. */ export class Tagged { value: T; - order: rt.Ordering; + order: rs.Ordering; - constructor(value: T, order: rt.Ordering) { + constructor(value: T, order: rs.Ordering) { this.value = value; this.order = order; } diff --git a/ts/fixtures/lang/nested/expected/nested.Unit.ts b/ts/fixtures/lang/nested/expected/nested.Unit.ts index 2de6d217c..d9e484702 100644 --- a/ts/fixtures/lang/nested/expected/nested.Unit.ts +++ b/ts/fixtures/lang/nested/expected/nested.Unit.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Unit { } -export function made$nested_Made(_self: Unit, _2: rt.u8): void { +export function made$nested_Made(_self: Unit, _2: rs.u8): void { } //# sourceMappingURL=nested.Unit.ts.map diff --git a/ts/fixtures/lang/nested/expected/nested.ts b/ts/fixtures/lang/nested/expected/nested.ts index 5bd4caf06..814734dcc 100644 --- a/ts/fixtures/lang/nested/expected/nested.ts +++ b/ts/fixtures/lang/nested/expected/nested.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { thenSome$0d5am30, thenSome$1j8foe9, then$16ew6vr } from "./core/bool.ts"; -import { isNoneOr$1s1o3ss, unwrapOr$1kxjsqb as option_unwrapOr$1kxjsqb, unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0pkankm as option_map$0pkankm, map$1diqi3e as option_map$1diqi3e, map$0rbsrz6 as option_map$0rbsrz6, map$0p22lts as option_map$0p22lts, map$0jcaaxx as option_map$0jcaaxx, map$0cs071d as option_map$0cs071d, map$0at3a41 as option_map$0at3a41, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$06rr3sb as option_mapOr$06rr3sb, mapOr$1surhce as option_mapOr$1surhce, mapOr$18ph0j9 as option_mapOr$18ph0j9, okOr$1vxk0yk as option_okOr$1vxk0yk, okOr$0g9lvh7 as option_okOr$0g9lvh7, andThen$0qni7te as option_andThen$0qni7te, andThen$0ocv8av as option_andThen$0ocv8av, andThen$1bd14ex as option_andThen$1bd14ex, filter$19gtvc4, filter$0v80fk8, or$0j02yk0 as option_or$0j02yk0, xor$0pemq84, xor$0kctyix, flatten$1nwzx42 as option_flatten$1nwzx42 } from "./core/option.ts"; -import { map$03hz3l7 as result_map$03hz3l7, mapErr$1whfgss as result_mapErr$1whfgss } from "./core/result.ts"; +import * as rs from "./rs.ts"; +import { thenSome$0quywni, thenSome$1n1oy1h, then$1uky7mt } from "./core/bool.ts"; +import { isNoneOr$0xn3i4j, unwrapOr$1hs5os9 as option_unwrapOr$1hs5os9, unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$008v810 as option_map$008v810, map$16kn1k2 as option_map$16kn1k2, map$1yv0md6 as option_map$1yv0md6, map$057a36e as option_map$057a36e, map$0f5oamy as option_map$0f5oamy, map$1yjmt5m as option_map$1yjmt5m, map$1eqzs00 as option_map$1eqzs00, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$19a4gco as option_mapOr$19a4gco, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0mkqwg8 as option_mapOr$0mkqwg8, okOr$1j8owgb as option_okOr$1j8owgb, okOr$06f2ml7 as option_okOr$06f2ml7, andThen$0xvwl6s as option_andThen$0xvwl6s, andThen$1l1aa1i as option_andThen$1l1aa1i, andThen$0jc4o0i as option_andThen$0jc4o0i, filter$1iofxfx, filter$0hq86nl, or$0farkzq as option_or$0farkzq, xor$0ucxb2n, xor$0x5qjg4, flatten$0ux6gqw as option_flatten$0ux6gqw } from "./core/option.ts"; +import { map$1gelxzx as result_map$1gelxzx, mapErr$136pgpq as result_mapErr$136pgpq } from "./core/result.ts"; import * as Halves from "./nested.Halves.ts"; import type * as Slot from "./nested.Slot.ts"; import * as Tagged from "./nested.Tagged.ts"; @@ -13,8 +13,8 @@ import * as Unit from "./nested.Unit.ts"; * Run case `kind % 8` over `data`, whose bytes pick each `None`, `Some(None)`, or * `Some(Some(_))`. */ -export function nested(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 8); +export function nested(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 8); if (_4 === 0) { made(data, out); } else if (_4 === 1) { @@ -35,10 +35,10 @@ export function nested(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `None` for a byte that is 0 mod 3, `Some(None)` for 1, and else `Some(Some(byte))`. */ -export function pick(b: rt.u8): rt.u8 | undefined | rt.None { - const _2: rt.u8 = rt.u8Rem(b, 3); +export function pick(b: rs.u8): rs.u8 | undefined | rs.None { + const _2: rs.u8 = rs.u8Rem(b, 3); if (_2 === 0) { - return rt.None; + return rs.None; } if (_2 === 1) { return undefined; @@ -47,13 +47,13 @@ export function pick(b: rt.u8): rt.u8 | undefined | rt.None { } /** `Some(())` for an even byte. */ -export function unit(b: rt.u8): undefined | rt.None { - return thenSome$1j8foe9(rt.u8Rem(b, 2) === 0, undefined); +export function unit(b: rs.u8): undefined | rs.None { + return thenSome$1n1oy1h(rs.u8Rem(b, 2) === 0, undefined); } /** Which of the three `o` is, and its byte. */ -export function code(o: rt.u8 | undefined | rt.None): rt.u8 { - if (o === rt.None) { +export function code(o: rs.u8 | undefined | rs.None): rs.u8 { + if (o === rs.None) { return 224; } if (o === undefined) { @@ -63,77 +63,77 @@ export function code(o: rt.u8 | undefined | rt.None): rt.u8 { } /** `?` on an `Option<()>` and on an `Option>`, which return their `None`. */ -export function tried(a: undefined | rt.None, b: rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { - if (a !== rt.None) { - const _5: rt.u8 | undefined | rt.None = b; - if (_5 !== rt.None) { - return option_map$0cs071d(_5, (x: rt.u8): rt.u8 => { - return rt.u8Div(x, 2); +export function tried(a: undefined | rs.None, b: rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { + if (a !== rs.None) { + const _5: rs.u8 | undefined | rs.None = b; + if (_5 !== rs.None) { + return option_map$1yjmt5m(_5, (x: rs.u8): rs.u8 => { + return rs.u8Div(x, 2); }); } - return rt.None; + return rs.None; } - return rt.None; + return rs.None; } -export function made(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const b of rt.byteSliceView(data)) { - const o: rt.u8 | undefined | rt.None = pick(b); - const u: undefined | rt.None = unit(b); - rt.byteVecPush(out, code(o)); - rt.byteVecPush(out, (o !== rt.None ? 1 : 0) | (((o === rt.None ? 1 : 0) << 1) & 0xff) | (((u !== rt.None ? 1 : 0) << 2) & 0xff) | (((u === rt.None ? 1 : 0) << 3) & 0xff)); - rt.byteVecPush(out, code(option_map$0pkankm(o, (x: rt.u8 | undefined): rt.u8 | undefined => { - return option_map$0cs071d(x, (y: rt.u8): rt.u8 => { +export function made(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const b of rs.byteSliceView(data)) { + const o: rs.u8 | undefined | rs.None = pick(b); + const u: undefined | rs.None = unit(b); + rs.byteVecPush(out, code(o)); + rs.byteVecPush(out, (o !== rs.None ? 1 : 0) | (((o === rs.None ? 1 : 0) << 1) & 0xff) | (((u !== rs.None ? 1 : 0) << 2) & 0xff) | (((u === rs.None ? 1 : 0) << 3) & 0xff)); + rs.byteVecPush(out, code(option_map$008v810(o, (x: rs.u8 | undefined): rs.u8 | undefined => { + return option_map$1yjmt5m(x, (y: rs.u8): rs.u8 => { return y ^ 85; }); }))); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(option_flatten$1nwzx42(o), 240)); - rt.byteVecPush(out, code(option_andThen$0qni7te(o, (x2: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return option_map$0rbsrz6(x2, (y2: rt.u8): rt.u8 | undefined => { - return rt.u8WrappingAdd(y2, 1); + rs.byteVecPush(out, option_unwrapOr$1fr498u(option_flatten$0ux6gqw(o), 240)); + rs.byteVecPush(out, code(option_andThen$0xvwl6s(o, (x2: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return option_map$1yv0md6(x2, (y2: rs.u8): rs.u8 | undefined => { + return rs.u8WrappingAdd(y2, 1); }); }))); - rt.byteVecPush(out, code(filter$19gtvc4(o, (x3: rt.u8 | undefined): boolean => { + rs.byteVecPush(out, code(filter$1iofxfx(o, (x3: rs.u8 | undefined): boolean => { return x3 !== undefined; }))); - rt.byteVecPush(out, code(option_or$0j02yk0(o, undefined as rt.u8 | undefined | rt.None))); - const _58: rt.u8 | undefined | rt.None = option_map$0at3a41(u, (_: undefined): rt.u8 | undefined => { + rs.byteVecPush(out, code(option_or$0farkzq(o, undefined as rs.u8 | undefined | rs.None))); + const _58: rs.u8 | undefined | rs.None = option_map$1eqzs00(u, (_: undefined): rs.u8 | undefined => { return undefined; }); - rt.byteVecPush(out, code(xor$0pemq84(o, _58))); - rt.byteVecPush(out, option_mapOr$18ph0j9(u, 208, (_2: undefined): rt.u8 => { + rs.byteVecPush(out, code(xor$0ucxb2n(o, _58))); + rs.byteVecPush(out, option_mapOr$0mkqwg8(u, 208, (_2: undefined): rs.u8 => { return 209; })); - rt.byteVecPush(out, code(tried(u, o))); - rt.byteVecPush(out, o === o ? 1 : 0); + rs.byteVecPush(out, code(tried(u, o))); + rs.byteVecPush(out, o === o ? 1 : 0); const slot: Slot.Slot = { held: o, flag: u }; - const taken2: rt.u8 | undefined | rt.None = slot.held; - slot.held = rt.None; - const taken: rt.u8 | undefined | rt.None = taken2; - const taken3: undefined | rt.None = slot.flag; - slot.flag = rt.None; - const flag: undefined | rt.None = taken3; - rt.byteVecPush(out, code(taken) ^ code(slot.held)); - rt.byteVecPush(out, (flag !== rt.None ? 1 : 0) | (((slot.flag !== rt.None ? 1 : 0) << 1) & 0xff)); - const old: rt.u8 | undefined | rt.None = slot.held; - slot.held = b as rt.u8 | undefined | rt.None; - rt.byteVecPush(out, code(old) ^ code(slot.held)); - rt.byteVecPush(out, code(rt.None)); - const _106: rt.Ordering = rt.cmp(b, 128); - const tagged: Tagged.Tagged = new Tagged.Tagged(u, _106); - rt.byteVecPush(out, (tagged.value !== rt.None ? 1 : 0) | ((order(tagged.order) << 1) & 0xff)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(o, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(u, f, rt.fmtUnit, rt.None)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1]]))); + const taken2: rs.u8 | undefined | rs.None = slot.held; + slot.held = rs.None; + const taken: rs.u8 | undefined | rs.None = taken2; + const taken3: undefined | rs.None = slot.flag; + slot.flag = rs.None; + const flag: undefined | rs.None = taken3; + rs.byteVecPush(out, code(taken) ^ code(slot.held)); + rs.byteVecPush(out, (flag !== rs.None ? 1 : 0) | (((slot.flag !== rs.None ? 1 : 0) << 1) & 0xff)); + const old: rs.u8 | undefined | rs.None = slot.held; + slot.held = b as rs.u8 | undefined | rs.None; + rs.byteVecPush(out, code(old) ^ code(slot.held)); + rs.byteVecPush(out, code(rs.None)); + const _106: rs.Ordering = rs.cmp(b, 128); + const tagged: Tagged.Tagged = new Tagged.Tagged(u, _106); + rs.byteVecPush(out, (tagged.value !== rs.None ? 1 : 0) | ((order(tagged.order) << 1) & 0xff)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(o, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(u, f, rs.fmtUnit, rs.None)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1]]))); } } -export function hashOf$Option_Option_u8(value: rt.u8 | undefined | rt.None): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashOption(rt.hashOption(rt.hash8), rt.None)(value, h); - return rt.hashFinish(h); +export function hashOf$Option_Option_u8(value: rs.u8 | undefined | rs.None): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashOption(rs.hashOption(rs.hash8), rs.None)(value, h); + return rs.hashFinish(h); } -export function order(o: rt.Ordering): rt.u8 { +export function order(o: rs.Ordering): rs.u8 { if (o === -1) { return 1; } @@ -147,105 +147,105 @@ export function order(o: rt.Ordering): rt.u8 { * Compared, ordered, and hashed: `None` orders before `Some(None)`, which orders before * each `Some(Some(_))`. */ -export function keys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _9!: rt.usize; - const hashed: rt.HashMap<[rt.u8, rt.u8 | undefined | rt.None], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hashOption(rt.hashOption(rt.hash8), rt.None)]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8 | undefined | rt.None], rt.u8>; - const sorted: rt.BTreeMap<[rt.u8 | undefined | rt.None, rt.u8], rt.u8> = rt.btreeNew(rt.cmpTuple<[rt.u8 | undefined | rt.None, rt.u8], rt.Ordering>([rt.cmpOption(rt.cmpOption(rt.cmp), rt.None), rt.cmp])) as rt.BTreeMap<[rt.u8 | undefined | rt.None, rt.u8], rt.u8>; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = dataLen; +export function keys(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _9!: rs.usize; + const hashed: rs.HashMap<[rs.u8, rs.u8 | undefined | rs.None], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hashOption(rs.hashOption(rs.hash8), rs.None)]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8 | undefined | rs.None], rs.u8>; + const sorted: rs.BTreeMap<[rs.u8 | undefined | rs.None, rs.u8], rs.u8> = rs.btreeNew(rs.cmpTuple<[rs.u8 | undefined | rs.None, rs.u8], rs.Ordering>([rs.cmpOption(rs.cmpOption(rs.cmp), rs.None), rs.cmp])) as rs.BTreeMap<[rs.u8 | undefined | rs.None, rs.u8], rs.u8>; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = dataLen; while ((_9 = iterStart++) < iterEnd) { - const i: rt.usize = _9; - const _18: rt.usize = rt.usizeSub(i, 1); + const i: rs.usize = _9; + const _18: rs.usize = rs.usizeSub(i, 1); if (_18 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _18); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _18); } - const _16: rt.u8 | undefined | rt.None = pick(dataData[dataStart + _18]); + const _16: rs.u8 | undefined | rs.None = pick(dataData[dataStart + _18]); if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _15: [rt.u8 | undefined | rt.None, rt.u8 | undefined | rt.None] = [_16, pick(dataData[dataStart + i])]; - const a: rt.u8 | undefined | rt.None = _16; - const b: rt.u8 | undefined | rt.None = _15[1]; - rt.byteVecPush(out, (a === b ? 1 : 0) | (((a !== b ? 1 : 0) << 1) & 0xff) | (((rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)(a, b) === -1 ? 1 : 0) << 2) & 0xff) | ((order(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)(a, b)) << 3) & 0xff)); - rt.byteVecPush(out, (rt.ordMax(a, b, rt.cmpLt(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None))) === b ? 1 : 0) | (((rt.u64Eq(hashOf$Option_Option_u8(a), hashOf$Option_Option_u8(b)) ? 1 : 0) << 1) & 0xff)); + const _15: [rs.u8 | undefined | rs.None, rs.u8 | undefined | rs.None] = [_16, pick(dataData[dataStart + i])]; + const a: rs.u8 | undefined | rs.None = _16; + const b: rs.u8 | undefined | rs.None = _15[1]; + rs.byteVecPush(out, (a === b ? 1 : 0) | (((a !== b ? 1 : 0) << 1) & 0xff) | (((rs.cmpOption(rs.cmpOption(rs.cmp), rs.None)(a, b) === -1 ? 1 : 0) << 2) & 0xff) | ((order(rs.cmpOption(rs.cmpOption(rs.cmp), rs.None)(a, b)) << 3) & 0xff)); + rs.byteVecPush(out, (rs.ordMax(a, b, rs.cmpLt(rs.cmpOption(rs.cmpOption(rs.cmp), rs.None))) === b ? 1 : 0) | (((rs.u64Eq(hashOf$Option_Option_u8(a), hashOf$Option_Option_u8(b)) ? 1 : 0) << 1) & 0xff)); if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _75: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(dataData[dataStart + i], 2), a]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashInsert(hashed, _75, i & 0xff), 204)); + const _75: [rs.u8, rs.u8 | undefined | rs.None] = [rs.u8Rem(dataData[dataStart + i], 2), a]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashInsert(hashed, _75, i & 0xff), 204)); if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _86: [rt.u8 | undefined | rt.None, rt.u8] = [a, rt.u8Rem(dataData[dataStart + i], 2)]; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.btreeInsert(sorted, _86, i & 0xff), 204)); - const _101: rt.usize = rt.usizeSub(i, 1); + const _86: [rs.u8 | undefined | rs.None, rs.u8] = [a, rs.u8Rem(dataData[dataStart + i], 2)]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.btreeInsert(sorted, _86, i & 0xff), 204)); + const _101: rs.usize = rs.usizeSub(i, 1); if (_101 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _101); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _101); } - const _98: [rt.u8, rt.u8 | undefined | rt.None] = [rt.u8Rem(dataData[dataStart + _101], 2), b]; - rt.byteVecPush(out, rt.hashContains(hashed, _98) ? 1 : 0); + const _98: [rs.u8, rs.u8 | undefined | rs.None] = [rs.u8Rem(dataData[dataStart + _101], 2), b]; + rs.byteVecPush(out, rs.hashContains(hashed, _98) ? 1 : 0); } - const iter2: rt.Iter<[[rt.u8 | undefined | rt.None, rt.u8], rt.u8]> = rt.btreeIter(sorted); + const iter2: rs.Iter<[[rs.u8 | undefined | rs.None, rs.u8], rs.u8]> = rs.btreeIter(sorted); while (true) { - const _109: [[rt.u8 | undefined | rt.None, rt.u8], rt.u8] | rt.Done = iter2.next(); - if (_109 === rt.DONE) { + const _109: [[rs.u8 | undefined | rs.None, rs.u8], rs.u8] | rs.Done = iter2.next(); + if (_109 === rs.DONE) { break; } - rt.byteVecPush(out, code(_109[0][0])); - rt.byteVecPush(out, _109[0][1]); - rt.byteVecPush(out, _109[1]); + rs.byteVecPush(out, code(_109[0][0])); + rs.byteVecPush(out, _109[0][1]); + rs.byteVecPush(out, _109[1]); } } -export function halve(n: rt.u8): rt.u8 | undefined | rt.None { - return thenSome$0d5am30(rt.u8Rem(n, 2) === 0, rt.u8Div(n, 2)); +export function halve(n: rs.u8): rs.u8 | undefined | rs.None { + return thenSome$0quywni(rs.u8Rem(n, 2) === 0, rs.u8Div(n, 2)); } -export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { - const b: rt.u8 = _2; - return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); +export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 | undefined => { + const b: rs.u8 = _2; + return thenSome$0quywni(rs.u8Rem(b, 2) === 0, b); }), undefined, 2, true); - const at: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { - return rt.usizeRem(b2 as rt.usize, 4); + const at: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (b2: rs.u8): rs.usize => { + return rs.usizeRem(b2 as rs.usize, 4); }); - rt.byteVecPush(out, code(rt.sliceGet(items.items, at, rt.None))); - rt.byteVecPush(out, code(rt.sliceFirst(items.items, rt.None))); - rt.byteVecPush(out, code(then$16ew6vr(at > 1, (): rt.u8 | undefined => { - return option_flatten$1nwzx42(rt.sliceGet(items.items, at, rt.None)); + rs.byteVecPush(out, code(rs.sliceGet(items.items, at, rs.None))); + rs.byteVecPush(out, code(rs.sliceFirst(items.items, rs.None))); + rs.byteVecPush(out, code(then$1uky7mt(at > 1, (): rs.u8 | undefined => { + return option_flatten$0ux6gqw(rs.sliceGet(items.items, at, rs.None)); }))); - const it: rt.Iter = rt.iterSlice(items.items); - rt.byteVecPush(out, code(rt.iterToOption(it.next(), rt.None))); - rt.byteVecPush(out, code(rt.iterToOption(it.nextBack(), rt.None))); - rt.byteVecPush(out, code(rt.iterNthBack(it, 1, undefined, rt.None))); - const iter: rt.Iter = it; + const it: rs.Iter = rs.iterSlice(items.items); + rs.byteVecPush(out, code(rs.iterToOption(it.next(), rs.None))); + rs.byteVecPush(out, code(rs.iterToOption(it.nextBack(), rs.None))); + rs.byteVecPush(out, code(rs.iterNthBack(it, 1, undefined, rs.None))); + const iter: rs.Iter = it; while (true) { - const _46: rt.u8 | undefined | rt.Done = iter.next(); - if (_46 === rt.DONE) { + const _46: rs.u8 | undefined | rs.Done = iter.next(); + if (_46 === rs.DONE) { break; } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_46, 225)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(_46, 225)); } - const own: Halves.Halves = { _0: rt.u8Rem(data.length & 0xff, 8) }; - rt.byteVecPush(out, code(rt.iterToOption(Halves.next$iter_Iterator(own), rt.None))); + const own: Halves.Halves = { _0: rs.u8Rem(data.length & 0xff, 8) }; + rs.byteVecPush(out, code(rs.iterToOption(Halves.next$iter_Iterator(own), rs.None))); const iter2: Halves.Halves = own; while (true) { - const _64: rt.u8 | undefined | rt.Done = Halves.next$iter_Iterator(iter2); - if (_64 === rt.DONE) { + const _64: rs.u8 | undefined | rs.Done = Halves.next$iter_Iterator(iter2); + if (_64 === rs.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1surhce(_64, 225, (x: rt.u8): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0vxw5sq(_64, 225, (x: rs.u8): rs.u8 => { return x; })); } - for (const _72 of rt.byteSliceView(data)) { - const o: rt.u8 | undefined | rt.None = pick(_72); - rt.byteVecPush(out, rt.iterCount(rt.iterOption(o, undefined, rt.None)) & 0xff); - rt.iterForEach(rt.iterOption(o, undefined, rt.None), (x2: rt.u8 | undefined): undefined => { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(x2, 225)); + for (const _72 of rs.byteSliceView(data)) { + const o: rs.u8 | undefined | rs.None = pick(_72); + rs.byteVecPush(out, rs.iterCount(rs.iterOption(o, undefined, rs.None)) & 0xff); + rs.iterForEach(rs.iterOption(o, undefined, rs.None), (x2: rs.u8 | undefined): undefined => { + rs.byteVecPush(out, option_unwrapOr$1fr498u(x2, 225)); }); - rt.iterForEach(rt.iterOption(unit(_72), undefined, rt.None), (_: undefined): undefined => { - rt.byteVecPush(out, 209); + rs.iterForEach(rs.iterOption(unit(_72), undefined, rs.None), (_: undefined): undefined => { + rs.byteVecPush(out, 209); }); } } @@ -254,95 +254,95 @@ export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { * Each consumer that returns an `Option` of the item, over items that are each `None` * for an odd byte: its `None` apart from its `Some(None)`. */ -export function consumers(data: rt.ByteSlice, out: rt.ByteVec): void { - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 | undefined => { - const b: rt.u8 = _2; - return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); +export function consumers(data: rs.ByteSlice, out: rs.ByteVec): void { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 | undefined => { + const b: rs.u8 = _2; + return thenSome$0quywni(rs.u8Rem(b, 2) === 0, b); }), undefined, 2, true); - const n: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { - return rt.usizeRem(b2 as rt.usize, 8); + const n: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (b2: rs.u8): rs.usize => { + return rs.usizeRem(b2 as rs.usize, 8); }); - const it: () => rt.Iter = (): rt.Iter => { - return rt.iterSlice(items.items); + const it: () => rs.Iter = (): rs.Iter => { + return rs.iterSlice(items.items); }; - rt.byteVecPush(out, code(rt.iterNth(it(), n, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterLast(it(), rt.None))); - rt.byteVecPush(out, code(rt.iterNth(rt.iterRev(it()), n, undefined, rt.None))); - let tested: rt.u8 = 0; - rt.byteVecPush(out, code(rt.iterFind(it(), (o: rt.u8 | undefined): boolean => { - tested = rt.u8Add(tested, 1); - return isNoneOr$1s1o3ss(o, (b3: rt.u8): boolean => { + rs.byteVecPush(out, code(rs.iterNth(it(), n, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterLast(it(), rs.None))); + rs.byteVecPush(out, code(rs.iterNth(rs.iterRev(it()), n, undefined, rs.None))); + let tested: rs.u8 = 0; + rs.byteVecPush(out, code(rs.iterFind(it(), (o: rs.u8 | undefined): boolean => { + tested = rs.u8Add(tested, 1); + return isNoneOr$0xn3i4j(o, (b3: rs.u8): boolean => { return b3 > 128; }); - }, undefined, rt.None))); - rt.byteVecPush(out, tested); - rt.byteVecPush(out, code(rt.iterRfind(it(), (a0: rt.u8 | undefined): boolean => { + }, undefined, rs.None))); + rs.byteVecPush(out, tested); + rs.byteVecPush(out, code(rs.iterRfind(it(), (a0: rs.u8 | undefined): boolean => { return a0 === undefined; - }, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMax(it(), rt.cmpLt(rt.cmpOption(rt.cmp)), undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMin(it(), rt.cmpLt(rt.cmpOption(rt.cmp)), undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMaxByKey(it(), (o2: rt.u8 | undefined): rt.u8 | undefined => { - return option_map$0cs071d(o2, (b4: rt.u8): rt.u8 => { - return rt.u8Rem(b4, 4); + }, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMax(it(), rs.cmpLt(rs.cmpOption(rs.cmp)), undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMin(it(), rs.cmpLt(rs.cmpOption(rs.cmp)), undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMaxByKey(it(), (o2: rs.u8 | undefined): rs.u8 | undefined => { + return option_map$1yjmt5m(o2, (b4: rs.u8): rs.u8 => { + return rs.u8Rem(b4, 4); }); - }, rt.cmpLt(rt.cmpOption(rt.cmp)), undefined, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMinByKey(it(), (o3: rt.u8 | undefined): rt.u8 | undefined => { - return option_map$0cs071d(o3, (b5: rt.u8): rt.u8 => { - return rt.u8Rem(b5, 4); + }, rs.cmpLt(rs.cmpOption(rs.cmp)), undefined, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMinByKey(it(), (o3: rs.u8 | undefined): rs.u8 | undefined => { + return option_map$1yjmt5m(o3, (b5: rs.u8): rs.u8 => { + return rs.u8Rem(b5, 4); }); - }, rt.cmpLt(rt.cmpOption(rt.cmp)), undefined, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMaxByKey(it(), (o4: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return option_map$0rbsrz6(o4, (b6: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b6, 4) !== 0, rt.u8Rem(b6, 3)); + }, rs.cmpLt(rs.cmpOption(rs.cmp)), undefined, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMaxByKey(it(), (o4: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return option_map$1yv0md6(o4, (b6: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b6, 4) !== 0, rs.u8Rem(b6, 3)); }); - }, rt.cmpLt(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)), undefined, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMinByKey(it(), (o5: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return option_map$0rbsrz6(o5, (b7: rt.u8): rt.u8 | undefined => { - return thenSome$0d5am30(rt.u8Rem(b7, 4) !== 0, rt.u8Rem(b7, 3)); + }, rs.cmpLt(rs.cmpOption(rs.cmpOption(rs.cmp), rs.None)), undefined, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMinByKey(it(), (o5: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return option_map$1yv0md6(o5, (b7: rs.u8): rs.u8 | undefined => { + return thenSome$0quywni(rs.u8Rem(b7, 4) !== 0, rs.u8Rem(b7, 3)); }); - }, rt.cmpLt(rt.cmpOption(rt.cmpOption(rt.cmp), rt.None)), undefined, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterFind(rt.iterSlice(items.items), (o6: rt.u8 | undefined): boolean => { + }, rs.cmpLt(rs.cmpOption(rs.cmpOption(rs.cmp), rs.None)), undefined, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterFind(rs.iterSlice(items.items), (o6: rs.u8 | undefined): boolean => { return o6 === undefined; - }, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMax(rt.iterSlice(items.items), rt.cmpLt(rt.cmpOption(rt.cmp)), undefined, undefined, rt.None))); - const rest: rt.Iter = it(); - rt.byteVecPush(out, code(rt.iterNth(rest, n, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterToOption(rest.next(), rt.None))); - const peeked: rt.Peekable = rt.iterPeekable(it()); - rt.byteVecPush(out, code(rt.peekablePeek(peeked, rt.None))); - rt.byteVecPush(out, code(rt.peekableNextIf(peeked, (a02: rt.u8 | undefined): boolean => { + }, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMax(rs.iterSlice(items.items), rs.cmpLt(rs.cmpOption(rs.cmp)), undefined, undefined, rs.None))); + const rest: rs.Iter = it(); + rs.byteVecPush(out, code(rs.iterNth(rest, n, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterToOption(rest.next(), rs.None))); + const peeked: rs.Peekable = rs.iterPeekable(it()); + rs.byteVecPush(out, code(rs.peekablePeek(peeked, rs.None))); + rs.byteVecPush(out, code(rs.peekableNextIf(peeked, (a02: rs.u8 | undefined): boolean => { return a02 === undefined; - }, rt.None))); - rt.byteVecPush(out, code(rt.iterToOption(peeked.next(), rt.None))); - rt.byteVecPush(out, code(rt.iterMaxBy(it(), (a: rt.u8 | undefined, b8: rt.u8 | undefined): rt.Ordering => { - const _511: rt.u8 | undefined = option_map$0cs071d(a, (b9: rt.u8): rt.u8 => { - return rt.u8Rem(b9, 4); + }, rs.None))); + rs.byteVecPush(out, code(rs.iterToOption(peeked.next(), rs.None))); + rs.byteVecPush(out, code(rs.iterMaxBy(it(), (a: rs.u8 | undefined, b8: rs.u8 | undefined): rs.Ordering => { + const _511: rs.u8 | undefined = option_map$1yjmt5m(a, (b9: rs.u8): rs.u8 => { + return rs.u8Rem(b9, 4); }); - const _8: rt.u8 | undefined = option_map$0cs071d(b8, (b10: rt.u8): rt.u8 => { - return rt.u8Rem(b10, 4); + const _8: rs.u8 | undefined = option_map$1yjmt5m(b8, (b10: rs.u8): rs.u8 => { + return rs.u8Rem(b10, 4); }); - return rt.cmpOption(rt.cmp)(_511, _8); - }, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMinBy(it(), (a03: rt.u8 | undefined, a1: rt.u8 | undefined): rt.Ordering => { - return rt.cmpOption(rt.cmp)(a03, a1); - }, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterMaxBy(it(), (_27: rt.u8 | undefined, _318: rt.u8 | undefined): rt.Ordering => { + return rs.cmpOption(rs.cmp)(_511, _8); + }, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMinBy(it(), (a03: rs.u8 | undefined, a1: rs.u8 | undefined): rs.Ordering => { + return rs.cmpOption(rs.cmp)(a03, a1); + }, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterMaxBy(it(), (_27: rs.u8 | undefined, _318: rs.u8 | undefined): rs.Ordering => { return 0; - }, undefined, undefined, undefined, rt.None))); - rt.byteVecPush(out, code(rt.iterReduce(it(), (a2: rt.u8 | undefined, b11: rt.u8 | undefined): rt.u8 | undefined => { - return xor$0kctyix(a2, b11); - }, undefined, undefined, rt.None))); - const written: rt.Peekable = rt.iterPeekable(it()); - const _139: rt.Place | undefined = rt.peekablePeekMut(written, true); + }, undefined, undefined, undefined, rs.None))); + rs.byteVecPush(out, code(rs.iterReduce(it(), (a2: rs.u8 | undefined, b11: rs.u8 | undefined): rs.u8 | undefined => { + return xor$0x5qjg4(a2, b11); + }, undefined, undefined, rs.None))); + const written: rs.Peekable = rs.iterPeekable(it()); + const _139: rs.Place | undefined = rs.peekablePeekMut(written, true); if (_139 !== undefined) { - _139.v = option_mapOr$06rr3sb(_139.v, 66, (_28: rt.u8): rt.u8 | undefined => { + _139.v = option_mapOr$19a4gco(_139.v, 66, (_28: rs.u8): rs.u8 | undefined => { return undefined; }); } - rt.byteVecPush(out, code(rt.iterToOption(written.next(), rt.None))); - rt.byteVecPush(out, code(rt.peekableNextIfEq(written, undefined, rt.same, rt.None))); - rt.byteVecPush(out, code(rt.peekableNextIfEq(written, n & 0xff, rt.same, rt.None))); - rt.byteVecPush(out, code(rt.iterToOption(written.next(), rt.None))); + rs.byteVecPush(out, code(rs.iterToOption(written.next(), rs.None))); + rs.byteVecPush(out, code(rs.peekableNextIfEq(written, undefined, rs.same, rs.None))); + rs.byteVecPush(out, code(rs.peekableNextIfEq(written, n & 0xff, rs.same, rs.None))); + rs.byteVecPush(out, code(rs.iterToOption(written.next(), rs.None))); } /** @@ -350,125 +350,125 @@ export function consumers(data: rt.ByteSlice, out: rt.ByteVec): void { * `Option<()>`: its `None` ends or skips, where its `Some(None)` is an item. Each count is * of the closure's calls. */ -export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { - let called: rt.u8 = 0; - const _6: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const _8: rt.Place = rt.place(() => called, (value) => called = value); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.iterFindMap(_6, (_2: rt.u8): rt.u8 | undefined | rt.None => { - const b2: rt.u8 = _2; - _8.v = rt.u8Add(_8.v, 1); +export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { + let called: rs.u8 = 0; + const _6: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const _8: rs.Place = rs.place(() => called, (value) => called = value); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.iterFindMap(_6, (_2: rs.u8): rs.u8 | undefined | rs.None => { + const b2: rs.u8 = _2; + _8.v = rs.u8Add(_8.v, 1); return pick(b2); - }, rt.None)), called)), undefined, true); - rt.byteVecPush(out, option_mapOr$18ph0j9(rt.iterFindMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): undefined | rt.None => { + }, rs.None)), called)), undefined, true); + rs.byteVecPush(out, option_mapOr$0mkqwg8(rs.iterFindMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): undefined | rs.None => { return unit(_23 ^ 1); - }, rt.None), 208, (_: undefined): rt.u8 => { + }, rs.None), 208, (_: undefined): rs.u8 => { return 209; })); called = 0; - const _22: rt.Place = rt.place(() => called, (value2) => called = value2); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined | rt.None => { - const b4: rt.u8 = _27; - _22.v = rt.u8Add(_22.v, 1); + const _22: rs.Place = rs.place(() => called, (value2) => called = value2); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 | undefined | rs.None => { + const b4: rs.u8 = _27; + _22.v = rs.u8Add(_22.v, 1); return pick(b4); - }, rt.None), "next", 2).items), (_28: rt.u8 | undefined): rt.u8 => { + }, rs.None), "next", 2).items), (_28: rs.u8 | undefined): rs.u8 => { return code(_28); }), undefined, true); - rt.byteVecPush(out, called); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterRev(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): rt.u8 | undefined | rt.None => { + rs.byteVecPush(out, called); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterRev(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): rs.u8 | undefined | rs.None => { return pick(_210); - }, rt.None)), "next", 2).items), (_211: rt.u8 | undefined): rt.u8 => { + }, rs.None)), "next", 2).items), (_211: rs.u8 | undefined): rs.u8 => { return code(_211); }), undefined, true); - rt.byteVecPush(out, rt.iterFold(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 | undefined | rt.None => { + rs.byteVecPush(out, rs.iterFold(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 | undefined | rs.None => { return pick(_212); - }, rt.None), 0, (n: rt.u8, o3: rt.u8 | undefined): rt.u8 => { - return rt.u8WrappingAdd(rt.u8WrappingMul(n, 3), code(o3)); + }, rs.None), 0, (n: rs.u8, o3: rs.u8 | undefined): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(n, 3), code(o3)); })); - rt.byteVecPush(out, rt.iterCount(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): undefined | rt.None => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): undefined | rs.None => { return unit(_213); - }, rt.None)) & 0xff); + }, rs.None)) & 0xff); called = 0; - const _52: rt.Place = rt.place(() => called, (value3) => called = value3); - const whiles: rt.Vec = rt.iterToVec(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): rt.u8 | undefined | rt.None => { - const b8: rt.u8 = _214; - _52.v = rt.u8Add(_52.v, 1); + const _52: rs.Place = rs.place(() => called, (value3) => called = value3); + const whiles: rs.Vec = rs.iterToVec(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): rs.u8 | undefined | rs.None => { + const b8: rs.u8 = _214; + _52.v = rs.u8Add(_52.v, 1); return pick(b8); - }, rt.None), "next", 2); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(whiles.items), (_215: rt.u8 | undefined): rt.u8 => { + }, rs.None), "next", 2); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(whiles.items), (_215: rs.u8 | undefined): rs.u8 => { return code(_215); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(whiles.items.length & 0xff, called)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): undefined | rt.None => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(whiles.items.length & 0xff, called)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): undefined | rs.None => { return unit(_216); - }, rt.None)) & 0xff); - const rest: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + }, rs.None)) & 0xff); + const rest: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); called = 0; - const _72: rt.Place = rt.place(() => called, (value4) => called = value4); - const made: rt.Iter = rt.iterFromFn((): rt.u8 | undefined | rt.None => { - _72.v = rt.u8Add(_72.v, 1); - const _414: rt.u8 | rt.Done = rest.next(); - if (_414 !== rt.DONE) { + const _72: rs.Place = rs.place(() => called, (value4) => called = value4); + const made: rs.Iter = rs.iterFromFn((): rs.u8 | undefined | rs.None => { + _72.v = rs.u8Add(_72.v, 1); + const _414: rs.u8 | rs.Done = rest.next(); + if (_414 !== rs.DONE) { return pick(_414); } - return rt.None; - }, rt.None); - const first: rt.Vec = rt.iterToVec(rt.iterBorrow(made), "next", 2); - const after: rt.u8 | undefined | rt.None = rt.iterToOption(made.next(), rt.None); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(first.items), (_218: rt.u8 | undefined): rt.u8 => { + return rs.None; + }, rs.None); + const first: rs.Vec = rs.iterToVec(rs.iterBorrow(made), "next", 2); + const after: rs.u8 | undefined | rs.None = rs.iterToOption(made.next(), rs.None); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(first.items), (_218: rs.u8 | undefined): rs.u8 => { return code(_218); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(first.items.length & 0xff, code(after), called)), undefined, true); - let left: rt.usize = data.length; - rt.byteVecPush(out, rt.iterCount(rt.iterFromFn((): undefined | rt.None => { - const _219: rt.usize | undefined = rt.usizeCheckedSub(left, 1); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(first.items.length & 0xff, code(after), called)), undefined, true); + let left: rs.usize = data.length; + rs.byteVecPush(out, rs.iterCount(rs.iterFromFn((): undefined | rs.None => { + const _219: rs.usize | undefined = rs.usizeCheckedSub(left, 1); if (_219 !== undefined) { left = _219; return unit(left & 0xff); } - return rt.None; - }, rt.None)) & 0xff); - const seen: rt.ByteVec = new rt.ByteVec(); - const rest2: rt.Iter = rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterSuccessors(option_andThen$1bd14ex(rt.byteSliceFirst(data), (_220: rt.u8): rt.u8 | undefined | rt.None => { + return rs.None; + }, rs.None)) & 0xff); + const seen: rs.ByteVec = new rs.ByteVec(); + const rest2: rs.Iter = rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), 1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterSuccessors(option_andThen$0jc4o0i(rs.byteSliceFirst(data), (_220: rs.u8): rs.u8 | undefined | rs.None => { return pick(_220); - }), (_221: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - rt.byteVecPush(seen, code(_221)); - const _84: rt.u8 | rt.Done = rest2.next(); - if (_84 !== rt.DONE) { + }), (_221: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + rs.byteVecPush(seen, code(_221)); + const _84: rs.u8 | rs.Done = rest2.next(); + if (_84 !== rs.DONE) { return pick(_84); } - return rt.None; - }, undefined, rt.None), "next", 2).items), (_222: rt.u8 | undefined): rt.u8 => { + return rs.None; + }, undefined, rs.None), "next", 2).items), (_222: rs.u8 | undefined): rs.u8 => { return code(_222); }), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(seen), undefined, true); - let steps: rt.u8 = 0; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCount(rt.iterSuccessors(undefined, (_223: undefined): undefined | rt.None => { - steps = rt.u8Add(steps, 1); - return thenSome$1j8foe9(steps < 3, undefined); - }, undefined, rt.None)) & 0xff, steps)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(seen), undefined, true); + let steps: rs.u8 = 0; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.iterCount(rs.iterSuccessors(undefined, (_223: undefined): undefined | rs.None => { + steps = rs.u8Add(steps, 1); + return thenSome$1n1oy1h(steps < 3, undefined); + }, undefined, rs.None)) & 0xff, steps)), undefined, true); if (data.length === 1) { if (240 <= data.data[data.start]) { if (data.data[data.start] <= 255) { - const b: rt.u8 = data.data[data.start]; + const b: rs.u8 = data.data[data.start]; let s: string = ""; - const rest3: rt.Iter = rt.iterMap(new rt.Range(0, 2147483647), (_224: rt.usize): rt.char => { - rt.panicFmt(["read"]); + const rest3: rs.Iter = rs.iterMap(new rs.Range(0, 2147483647), (_224: rs.usize): rs.char => { + rs.panicFmt(["read"]); }); - if (rt.u8Rem(b, 2) === 0) { - const _137: rt.Iter = rt.iterChain(rt.iterMap(rt.iterSuccessors(undefined, (_227: undefined): undefined | rt.None => { - return rt.None; - }, undefined, rt.None), (_30: undefined): rt.char => { + if (rs.u8Rem(b, 2) === 0) { + const _137: rs.Iter = rs.iterChain(rs.iterMap(rs.iterSuccessors(undefined, (_227: undefined): undefined | rs.None => { + return rs.None; + }, undefined, rs.None), (_30: undefined): rs.char => { return 97; }), rest3); - s = rt.stringExtendChars(s, _137); + s = rs.stringExtendChars(s, _137); } else { - const _142: rt.Iter = rt.iterChain(rt.iterMap(rt.iterSuccessors(undefined as rt.u8 | undefined | rt.None, (_225: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return rt.None; - }, undefined, rt.None), (_226: rt.u8 | undefined): rt.char => { + const _142: rs.Iter = rs.iterChain(rs.iterMap(rs.iterSuccessors(undefined as rs.u8 | undefined | rs.None, (_225: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return rs.None; + }, undefined, rs.None), (_226: rs.u8 | undefined): rs.char => { return 97; }), rest3); - s = rt.stringExtendChars(s, _142); + s = rs.stringExtendChars(s, _142); } } } @@ -481,259 +481,259 @@ export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { * then a map keyed by them: an empty collection's and an out-of-range `None` apart from a * `Some(None)`. The first byte is also the index. */ -export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { - const _8: (a0: rt.Place) => undefined = (o8: rt.Place): undefined => { - o8.v = option_mapOr$06rr3sb(o8.v, 66, (_2: rt.u8): rt.u8 | undefined => { +export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { + const _8: (a0: rs.Place) => undefined = (o8: rs.Place): undefined => { + o8.v = option_mapOr$19a4gco(o8.v, 66, (_2: rs.u8): rs.u8 | undefined => { return undefined; }); }; - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.u8 | undefined => { - const b: rt.u8 = _22; - return thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u8 | undefined => { + const b: rs.u8 = _22; + return thenSome$0quywni(rs.u8Rem(b, 2) === 0, b); }), undefined, 2, true); - const at: rt.usize = option_mapOr$1t0muvr(rt.byteSliceFirst(data), 0, (b2: rt.u8): rt.usize => { - return rt.usizeRem(b2 as rt.usize, 8); + const at: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceFirst(data), 0, (b2: rs.u8): rs.usize => { + return rs.usizeRem(b2 as rs.usize, 8); }); - const v: rt.Vec = rt.vecFrom(items.items.slice()); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v.items, rt.None)), code(rt.sliceLast(v.items, rt.None)), code(rt.sliceGet(v.items, at, rt.None)))), undefined, true); - rt.byteVecPush(out, code(option_andThen$0ocv8av(rt.sliceGetRange(rt.sliceRange(v.items, 0), at), (s: Array): rt.u8 | undefined | rt.None => { - return rt.sliceFirst(s, rt.None); + const v: rs.Vec = rs.vecFrom(items.items.slice()); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.sliceFirst(v.items, rs.None)), code(rs.sliceLast(v.items, rs.None)), code(rs.sliceGet(v.items, at, rs.None)))), undefined, true); + rs.byteVecPush(out, code(option_andThen$1l1aa1i(rs.sliceGetRange(rs.sliceRange(v.items, 0), at), (s: Array): rs.u8 | undefined | rs.None => { + return rs.sliceFirst(s, rs.None); }))); - option_map$1diqi3e(rt.sliceFirstMut(v.items), (o9: rt.Place): undefined => { - o9.v = option_mapOr$06rr3sb(o9.v, 66, (_27: rt.u8): rt.u8 | undefined => { + option_map$16kn1k2(rs.sliceFirstMut(v.items), (o9: rs.Place): undefined => { + o9.v = option_mapOr$19a4gco(o9.v, 66, (_27: rs.u8): rs.u8 | undefined => { return undefined; }); }); - option_map$1diqi3e(rt.sliceLastMut(v.items), (o10: rt.Place): undefined => { - o10.v = option_mapOr$06rr3sb(o10.v, 66, (_28: rt.u8): rt.u8 | undefined => { + option_map$16kn1k2(rs.sliceLastMut(v.items), (o10: rs.Place): undefined => { + o10.v = option_mapOr$19a4gco(o10.v, 66, (_28: rs.u8): rs.u8 | undefined => { return undefined; }); }); - option_map$1diqi3e(rt.sliceGetMut(v.items, at), (o11: rt.Place): undefined => { - o11.v = option_mapOr$06rr3sb(o11.v, 66, (_212: rt.u8): rt.u8 | undefined => { + option_map$16kn1k2(rs.sliceGetMut(v.items, at), (o11: rs.Place): undefined => { + o11.v = option_mapOr$19a4gco(o11.v, 66, (_212: rs.u8): rs.u8 | undefined => { return undefined; }); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.sliceFirst(v.items, rt.None)), code(rt.sliceLast(v.items, rt.None)), code(rt.sliceGet(v.items, at, rt.None)))), undefined, true); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 2; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.sliceFirst(v.items, rs.None)), code(rs.sliceLast(v.items, rs.None)), code(rs.sliceGet(v.items, at, rs.None)))), undefined, true); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 2; while (iterStart++ < iterEnd) { - rt.byteVecPush(out, code(rt.vecPopIfMut(v, (o12: rt.Place): boolean => { + rs.byteVecPush(out, code(rs.vecPopIfMut(v, (o12: rs.Place): boolean => { _8(o12); return o12.v === undefined; - }, undefined, rt.None))); - rt.byteVecPush(out, code(rt.sliceLast(v.items, rt.None))); + }, undefined, rs.None))); + rs.byteVecPush(out, code(rs.sliceLast(v.items, rs.None))); } while (true) { - const _83: rt.u8 | undefined | rt.None = rt.vecPop(v, rt.None); - if (_83 !== rt.None) { - rt.byteVecPush(out, code(_83)); + const _83: rs.u8 | undefined | rs.None = rs.vecPop(v, rs.None); + if (_83 !== rs.None) { + rs.byteVecPush(out, code(_83)); } else { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.vecPop(v, rt.None)), code(rt.vecPopIfMut(v, (_213: rt.Place): boolean => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.vecPop(v, rs.None)), code(rs.vecPopIfMut(v, (_213: rs.Place): boolean => { return true; - }, undefined, rt.None)))), undefined, true); - const units: rt.Vec = rt.vecFromElem(undefined, data.length, undefined); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirst(units.items, rt.None) !== rt.None ? 1 : 0, rt.sliceLast(units.items, rt.None) !== rt.None ? 1 : 0, rt.sliceGet(units.items, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceFirstMut(units.items) !== undefined ? 1 : 0, rt.sliceLastMut(units.items) !== undefined ? 1 : 0, rt.sliceGetMut(units.items, at) !== undefined ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.vecPopIfMut(units, (_217: rt.Place): boolean => { - return rt.usizeRem(at, 2) === 0; - }, undefined, rt.None) !== rt.None ? 1 : 0, units.items.length & 0xff)), undefined, true); - let popped: rt.u8 = 0; - while (rt.vecPop(units, rt.None) !== rt.None) { - popped = rt.u8Add(popped, 1); + }, undefined, rs.None)))), undefined, true); + const units: rs.Vec = rs.vecFromElem(undefined, data.length, undefined); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceFirst(units.items, rs.None) !== rs.None ? 1 : 0, rs.sliceLast(units.items, rs.None) !== rs.None ? 1 : 0, rs.sliceGet(units.items, at, rs.None) !== rs.None ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceFirstMut(units.items) !== undefined ? 1 : 0, rs.sliceLastMut(units.items) !== undefined ? 1 : 0, rs.sliceGetMut(units.items, at) !== undefined ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.vecPopIfMut(units, (_217: rs.Place): boolean => { + return rs.usizeRem(at, 2) === 0; + }, undefined, rs.None) !== rs.None ? 1 : 0, units.items.length & 0xff)), undefined, true); + let popped: rs.u8 = 0; + while (rs.vecPop(units, rs.None) !== rs.None) { + popped = rs.u8Add(popped, 1); } - rt.byteVecPush(out, popped); - const q: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - const iter2: rt.Iter<[rt.usize, rt.u8 | undefined]> = rt.iterEnumerate(rt.iterSlice(items.items)); + rs.byteVecPush(out, popped); + const q: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + const iter2: rs.Iter<[rs.usize, rs.u8 | undefined]> = rs.iterEnumerate(rs.iterSlice(items.items)); while (true) { - const _167: [rt.usize, rt.u8 | undefined] | rt.Done = iter2.next(); - if (_167 === rt.DONE) { + const _167: [rs.usize, rs.u8 | undefined] | rs.Done = iter2.next(); + if (_167 === rs.DONE) { break; } - const i: rt.usize = _167[0]; - const o2: rt.u8 | undefined = _167[1]; - if (rt.usizeRem(i, 2) === 0) { - rt.dequePushBack(q, o2); + const i: rs.usize = _167[0]; + const o2: rs.u8 | undefined = _167[1]; + if (rs.usizeRem(i, 2) === 0) { + rs.dequePushBack(q, o2); } else { - rt.dequePushFront(q, o2); + rs.dequePushFront(q, o2); } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); - option_map$1diqi3e(rt.dequeEndMut(q), (o13: rt.Place): undefined => { - o13.v = option_mapOr$06rr3sb(o13.v, 66, (_220: rt.u8): rt.u8 | undefined => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.dequeEnd(q, false, rs.None)), code(rs.dequeEnd(q, true, rs.None)), code(rs.dequeGet(q, at, rs.None)))), undefined, true); + option_map$16kn1k2(rs.dequeEndMut(q), (o13: rs.Place): undefined => { + o13.v = option_mapOr$19a4gco(o13.v, 66, (_220: rs.u8): rs.u8 | undefined => { return undefined; }); }); - option_map$1diqi3e(rt.dequeEndMut(q, true), (o14: rt.Place): undefined => { - o14.v = option_mapOr$06rr3sb(o14.v, 66, (_223: rt.u8): rt.u8 | undefined => { + option_map$16kn1k2(rs.dequeEndMut(q, true), (o14: rs.Place): undefined => { + o14.v = option_mapOr$19a4gco(o14.v, 66, (_223: rs.u8): rs.u8 | undefined => { return undefined; }); }); - option_map$1diqi3e(rt.dequeGetMut(q, at), (o15: rt.Place): undefined => { - o15.v = option_mapOr$06rr3sb(o15.v, 66, (_225: rt.u8): rt.u8 | undefined => { + option_map$16kn1k2(rs.dequeGetMut(q, at), (o15: rs.Place): undefined => { + o15.v = option_mapOr$19a4gco(o15.v, 66, (_225: rs.u8): rs.u8 | undefined => { return undefined; }); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeEnd(q, true, rt.None)), code(rt.dequeGet(q, at, rt.None)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequeRemove(q, at, rt.None)), code(rt.dequeSwapRemove(q, at, true, rt.None)), code(rt.dequeSwapRemove(q, at, false, rt.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.dequeEnd(q, false, rs.None)), code(rs.dequeEnd(q, true, rs.None)), code(rs.dequeGet(q, at, rs.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.dequeRemove(q, at, rs.None)), code(rs.dequeSwapRemove(q, at, true, rs.None)), code(rs.dequeSwapRemove(q, at, false, rs.None)))), undefined, true); while (true) { - const _224: rt.u8 | undefined | rt.None = rt.dequePopFront(q, rt.None); - if (_224 !== rt.None) { - rt.byteVecPush(out, code(_224)); - const _231: rt.u8 | undefined | rt.None = rt.dequePopBack(q, rt.None); - if (_231 !== rt.None) { - rt.byteVecPush(out, code(_231)); + const _224: rs.u8 | undefined | rs.None = rs.dequePopFront(q, rs.None); + if (_224 !== rs.None) { + rs.byteVecPush(out, code(_224)); + const _231: rs.u8 | undefined | rs.None = rs.dequePopBack(q, rs.None); + if (_231 !== rs.None) { + rs.byteVecPush(out, code(_231)); } } else { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.dequePopFront(q, rt.None)), code(rt.dequePopBack(q, rt.None)), code(rt.dequeEnd(q, false, rt.None)), code(rt.dequeRemove(q, 0, rt.None)), code(rt.dequeSwapRemove(q, 0, true, rt.None)), code(rt.dequeSwapRemove(q, 0, false, rt.None)))), undefined, true); - const unitQ: rt.VecDeque = rt.dequeFromVec(rt.vecFromElem(undefined, rt.usizeMul(data.length, 2), undefined), 0) as rt.VecDeque; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequeEnd(unitQ, false, rt.None) !== rt.None ? 1 : 0, rt.dequeEnd(unitQ, true, rt.None) !== rt.None ? 1 : 0, rt.dequeGet(unitQ, at, rt.None) !== rt.None ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.dequePopBack(unitQ, rt.None) !== rt.None ? 1 : 0, rt.dequeRemove(unitQ, at, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, true, rt.None) !== rt.None ? 1 : 0, rt.dequeSwapRemove(unitQ, at, false, rt.None) !== rt.None ? 1 : 0, rt.dequePopFront(unitQ, rt.None) !== rt.None ? 1 : 0, unitQ.n & 0xff)), undefined, true); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterSlice(items.items), undefined, 2, true), rt.cmpLe(rt.cmpOption(rt.cmp)), rt.cmpGe(rt.cmpOption(rt.cmp)), rt.cmpLt(rt.cmpOption(rt.cmp))); - rt.byteVecPush(out, code(rt.heapPeek(heap, rt.None))); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.dequePopFront(q, rs.None)), code(rs.dequePopBack(q, rs.None)), code(rs.dequeEnd(q, false, rs.None)), code(rs.dequeRemove(q, 0, rs.None)), code(rs.dequeSwapRemove(q, 0, true, rs.None)), code(rs.dequeSwapRemove(q, 0, false, rs.None)))), undefined, true); + const unitQ: rs.VecDeque = rs.dequeFromVec(rs.vecFromElem(undefined, rs.usizeMul(data.length, 2), undefined), 0) as rs.VecDeque; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.dequeEnd(unitQ, false, rs.None) !== rs.None ? 1 : 0, rs.dequeEnd(unitQ, true, rs.None) !== rs.None ? 1 : 0, rs.dequeGet(unitQ, at, rs.None) !== rs.None ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.dequePopBack(unitQ, rs.None) !== rs.None ? 1 : 0, rs.dequeRemove(unitQ, at, rs.None) !== rs.None ? 1 : 0, rs.dequeSwapRemove(unitQ, at, true, rs.None) !== rs.None ? 1 : 0, rs.dequeSwapRemove(unitQ, at, false, rs.None) !== rs.None ? 1 : 0, rs.dequePopFront(unitQ, rs.None) !== rs.None ? 1 : 0, unitQ.n & 0xff)), undefined, true); + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(items.items), undefined, 2, true), rs.cmpLe(rs.cmpOption(rs.cmp)), rs.cmpGe(rs.cmpOption(rs.cmp)), rs.cmpLt(rs.cmpOption(rs.cmp))); + rs.byteVecPush(out, code(rs.heapPeek(heap, rs.None))); while (true) { - const _321: rt.u8 | undefined | rt.None = rt.heapPop(heap, rt.cmpLe(rt.cmpOption(rt.cmp)), rt.None); - if (_321 !== rt.None) { - rt.byteVecPush(out, code(_321)); + const _321: rs.u8 | undefined | rs.None = rs.heapPop(heap, rs.cmpLe(rs.cmpOption(rs.cmp)), rs.None); + if (_321 !== rs.None) { + rs.byteVecPush(out, code(_321)); } else { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.heapPeek(heap, rt.None)), code(rt.heapPop(heap, rt.cmpLe(rt.cmpOption(rt.cmp)), rt.None)))), undefined, true); - const hashed: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashSet; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, false, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashReplace(hashed, undefined as rt.u8 | undefined, rt.None)), code(rt.hashReplace(hashed, undefined as rt.u8 | undefined, rt.None)))), undefined, true); - const _361: rt.Iter = rt.iterSlice(items.items); - rt.hashExtendKeys(hashed, _361, undefined, undefined, 469762048); - const probe: rt.u8 | undefined | rt.None = option_map$0rbsrz6(rt.byteSliceLast(data), (_226: rt.u8): rt.u8 | undefined => { - const b3: rt.u8 = _226; - return thenSome$0d5am30(rt.u8Rem(b3, 2) === 0, b3); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.heapPeek(heap, rs.None)), code(rs.heapPop(heap, rs.cmpLe(rs.cmpOption(rs.cmp)), rs.None)))), undefined, true); + const hashed: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashSet; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.hashKey(hashed, undefined, false, rs.None)), code(rs.hashKey(hashed, undefined, true, rs.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.hashReplace(hashed, undefined as rs.u8 | undefined, rs.None)), code(rs.hashReplace(hashed, undefined as rs.u8 | undefined, rs.None)))), undefined, true); + const _361: rs.Iter = rs.iterSlice(items.items); + rs.hashExtendKeys(hashed, _361, undefined, undefined, 469762048); + const probe: rs.u8 | undefined | rs.None = option_map$1yv0md6(rs.byteSliceLast(data), (_226: rs.u8): rs.u8 | undefined => { + const b3: rs.u8 = _226; + return thenSome$0quywni(rs.u8Rem(b3, 2) === 0, b3); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, false, rt.None)), code(option_andThen$0qni7te(probe, (p: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return rt.hashKey(hashed, p, false, rt.None); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.hashKey(hashed, undefined, false, rs.None)), code(option_andThen$0xvwl6s(probe, (p: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return rs.hashKey(hashed, p, false, rs.None); })))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, undefined, true, rt.None)), code(rt.hashKey(hashed, 1, false, rt.None)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.hashReplace(hashed, undefined as rt.u8 | undefined, rt.None)), code(option_andThen$0qni7te(probe, (p2: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return rt.hashReplace(hashed, p2, rt.None); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.hashKey(hashed, undefined, true, rs.None)), code(rs.hashKey(hashed, undefined, true, rs.None)), code(rs.hashKey(hashed, 1, false, rs.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.hashReplace(hashed, undefined as rs.u8 | undefined, rs.None)), code(option_andThen$0xvwl6s(probe, (p2: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return rs.hashReplace(hashed, p2, rs.None); })))), undefined, true); - rt.byteVecPush(out, rt.hashLen(hashed) & 0xff); - const _409: rt.Iter = rt.iterSlice(items.items); - const sorted: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _409, true, undefined, undefined, 2, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeKey(sorted, undefined, false, rt.None)), code(option_andThen$0qni7te(probe, (p3: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return rt.btreeKey(sorted, p3, false, rt.None); - })), code(rt.btreeReplace(sorted, undefined as rt.u8 | undefined, rt.None)), code(rt.btreeKey(sorted, undefined, true, rt.None)), code(rt.btreeKey(sorted, undefined, true, rt.None)), code(rt.btreeReplace(sorted, undefined as rt.u8 | undefined, rt.None)))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreePopKey(sorted, false, rt.None)), code(rt.btreePopKey(sorted, true, rt.None)))), undefined, true); + rs.byteVecPush(out, rs.hashLen(hashed) & 0xff); + const _409: rs.Iter = rs.iterSlice(items.items); + const sorted: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _409, true, undefined, undefined, 2, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.btreeFirstKey(sorted, false, rs.None)), code(rs.btreeFirstKey(sorted, true, rs.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.btreeKey(sorted, undefined, false, rs.None)), code(option_andThen$0xvwl6s(probe, (p3: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return rs.btreeKey(sorted, p3, false, rs.None); + })), code(rs.btreeReplace(sorted, undefined as rs.u8 | undefined, rs.None)), code(rs.btreeKey(sorted, undefined, true, rs.None)), code(rs.btreeKey(sorted, undefined, true, rs.None)), code(rs.btreeReplace(sorted, undefined as rs.u8 | undefined, rs.None)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.btreePopKey(sorted, false, rs.None)), code(rs.btreePopKey(sorted, true, rs.None)))), undefined, true); while (true) { - const _459: rt.u8 | undefined | rt.None = rt.btreePopKey(sorted, true, rt.None); - if (_459 !== rt.None) { - rt.byteVecPush(out, code(_459)); + const _459: rs.u8 | undefined | rs.None = rs.btreePopKey(sorted, true, rs.None); + if (_459 !== rs.None) { + rs.byteVecPush(out, code(_459)); } else { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.btreeFirstKey(sorted, false, rt.None)), code(rt.btreeFirstKey(sorted, true, rt.None)), code(rt.btreePopKey(sorted, false, rt.None)), code(rt.btreeKey(sorted, undefined, false, rt.None)), code(rt.btreeKey(sorted, undefined, true, rt.None)))), undefined, true); - const shared: rt.Arc = new rt.Arc(option_unwrapOr$1kxjsqb(rt.sliceFirst(items.items, rt.None), 51)); - const other: rt.Arc = rt.arcClone(shared); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(rt.arcIntoInner(shared, rt.None)), code(rt.arcIntoInner(other, rt.None)))), undefined, true); - const unit: rt.Arc = new rt.Arc(undefined); - const weak: rt.Weak = new rt.Weak(unit); - const again: rt.Arc = rt.arcClone(unit); - const _510: rt.u8 = rt.arcIntoInner(unit, rt.None) !== rt.None ? 1 : 0; - const _517: rt.Arc | undefined = rt.weakUpgrade(weak); - const _514: rt.u8 = _517 !== undefined ? 1 : 0; - const _519: rt.u8 = rt.arcIntoInner(again, rt.None) !== rt.None ? 1 : 0; - const _526: rt.Arc | undefined = rt.weakUpgrade(weak); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_510, _514, _519, _526 !== undefined ? 1 : 0)), undefined, true); - rt.drop(_526); - rt.drop(_517); - const by: rt.BTreeMap = rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeMap; - const hashBy: rt.HashMap = rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashMap; - const iter3: rt.Iter<[rt.usize, rt.u8 | undefined]> = rt.iterEnumerate(rt.iterSlice(items.items)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.btreeFirstKey(sorted, false, rs.None)), code(rs.btreeFirstKey(sorted, true, rs.None)), code(rs.btreePopKey(sorted, false, rs.None)), code(rs.btreeKey(sorted, undefined, false, rs.None)), code(rs.btreeKey(sorted, undefined, true, rs.None)))), undefined, true); + const shared: rs.Arc = new rs.Arc(option_unwrapOr$1hs5os9(rs.sliceFirst(items.items, rs.None), 51)); + const other: rs.Arc = rs.arcClone(shared); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(rs.arcIntoInner(shared, rs.None)), code(rs.arcIntoInner(other, rs.None)))), undefined, true); + const unit: rs.Arc = new rs.Arc(undefined); + const weak: rs.Weak = new rs.Weak(unit); + const again: rs.Arc = rs.arcClone(unit); + const _510: rs.u8 = rs.arcIntoInner(unit, rs.None) !== rs.None ? 1 : 0; + const _517: rs.Arc | undefined = rs.weakUpgrade(weak); + const _514: rs.u8 = _517 !== undefined ? 1 : 0; + const _519: rs.u8 = rs.arcIntoInner(again, rs.None) !== rs.None ? 1 : 0; + const _526: rs.Arc | undefined = rs.weakUpgrade(weak); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_510, _514, _519, _526 !== undefined ? 1 : 0)), undefined, true); + rs.drop(_526); + rs.drop(_517); + const by: rs.BTreeMap = rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeMap; + const hashBy: rs.HashMap = rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap; + const iter3: rs.Iter<[rs.usize, rs.u8 | undefined]> = rs.iterEnumerate(rs.iterSlice(items.items)); while (true) { - const _536: [rt.usize, rt.u8 | undefined] | rt.Done = iter3.next(); - if (_536 === rt.DONE) { + const _536: [rs.usize, rs.u8 | undefined] | rs.Done = iter3.next(); + if (_536 === rs.DONE) { break; } - const i2: rt.usize = _536[0]; - const o7: rt.u8 | undefined = _536[1]; - const _542: rt.Place = rt.entryOrInsertWithMut(rt.entry(by, o7), (): rt.u8 => { + const i2: rs.usize = _536[0]; + const o7: rs.u8 | undefined = _536[1]; + const _542: rs.Place = rs.entryOrInsertWithMut(rs.entry(by, o7), (): rs.u8 => { return 0; }); - _542.v = rt.u8Add(_542.v, i2 & 0xff); - rt.hashInsert(hashBy, o7, i2 & 0xff); + _542.v = rs.u8Add(_542.v, i2 & 0xff); + rs.hashInsert(hashBy, o7, i2 & 0xff); } - const iter4: rt.Iter = rt.iterSlice([rt.btreeGet(by, undefined), rt.hashGet(hashBy, undefined), rt.btreeGet(by, at & 0xff)]); + const iter4: rs.Iter = rs.iterSlice([rs.btreeGet(by, undefined), rs.hashGet(hashBy, undefined), rs.btreeGet(by, at & 0xff)]); while (true) { - const _563: rt.u8 | undefined | rt.Done = iter4.next(); - if (_563 === rt.DONE) { + const _563: rs.u8 | undefined | rs.Done = iter4.next(); + if (_563 === rs.DONE) { break; } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_563, 204)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(_563, 204)); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashRemove(hashBy, undefined), 204)); - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$0jcaaxx(rt.btreeFirst(by), (_227: [rt.u8 | undefined, rt.u8]): Uint8Array => { - const k2: rt.u8 | undefined = _227[0]; - const n3: rt.u8 = _227[1]; + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashRemove(hashBy, undefined), 204)); + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$0f5oamy(rs.btreeFirst(by), (_227: [rs.u8 | undefined, rs.u8]): Uint8Array => { + const k2: rs.u8 | undefined = _227[0]; + const n3: rs.u8 = _227[1]; return Uint8Array.of(code(k2), n3); - }), rt.bytes(2).fill(204))), undefined, true); - const iter5: rt.Iter<[rt.u8 | undefined, rt.u8]> = rt.btreeIter(by); + }), rs.bytes(2).fill(204))), undefined, true); + const iter5: rs.Iter<[rs.u8 | undefined, rs.u8]> = rs.btreeIter(by); while (true) { - const _584: [rt.u8 | undefined, rt.u8] | rt.Done = iter5.next(); - if (_584 === rt.DONE) { + const _584: [rs.u8 | undefined, rs.u8] | rs.Done = iter5.next(); + if (_584 === rs.DONE) { break; } - const k: rt.u8 | undefined = _584[0]; - const n2: rt.u8 = _584[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(code(k), n2)), undefined, true); + const k: rs.u8 | undefined = _584[0]; + const n2: rs.u8 = _584[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(code(k), n2)), undefined, true); } - rt.byteVecPush(out, rt.hashLen(hashBy) & 0xff); + rs.byteVecPush(out, rs.hashLen(hashBy) & 0xff); weak[Symbol.dispose](); } -export function panics(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const b of rt.byteSliceView(data)) { - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.optionExpect(pick(b), "picked none", rt.None), 225)); - rt.byteVecPush(out, code(rt.optionUnwrap(pick(b), rt.None))); - rt.optionUnwrap(unit(b ^ 1), rt.None); +export function panics(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const b of rs.byteSliceView(data)) { + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.optionExpect(pick(b), "picked none", rs.None), 225)); + rs.byteVecPush(out, code(rs.optionUnwrap(pick(b), rs.None))); + rs.optionUnwrap(unit(b ^ 1), rs.None); } } -export function ignore(_1: rt.u8): void { +export function ignore(_1: rs.u8): void { } -export function half(b: rt.u8): rt.u8 { - return rt.u8Div(b, 2); +export function half(b: rs.u8): rs.u8 { + return rs.u8Div(b, 2); } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$u8_nested_half(data: rt.ByteSlice, _: (a0: rt.u8) => rt.u8): rt.ByteVec { - return rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), half), undefined, true); +export function each$u8_nested_half(data: rs.ByteSlice, _: (a0: rs.u8) => rs.u8): rs.ByteVec { + return rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), half), undefined, true); } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$unit_nested_ignore(data: rt.ByteSlice, _: (a0: rt.u8) => undefined): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); +export function each$unit_nested_ignore(data: rs.ByteSlice, _: (a0: rs.u8) => undefined): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), ignore as (a0: rs.u8) => undefined), undefined, 0, true); } /** Each of `data` through `f`, read from its parameter: a function item too. */ -export function each$unit_nested_units_closure3(data: rt.ByteSlice, f: (a0: rt.u8) => undefined): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), f), undefined, 0, true); +export function each$unit_nested_units_closure3(data: rs.ByteSlice, f: (a0: rs.u8) => undefined): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), f), undefined, 0, true); } /** Each of `data` through a pointer. */ -export function pointed(data: rt.ByteSlice, f: (a0: rt.u8) => undefined): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), f), undefined, 0, true); +export function pointed(data: rs.ByteSlice, f: (a0: rs.u8) => undefined): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), f), undefined, 0, true); } -export function madeAll$nested_Unit(m: Unit.Unit, data: rt.ByteSlice): rt.Vec { - return rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => { +export function madeAll$nested_Unit(m: Unit.Unit, data: rs.ByteSlice): rs.Vec { + return rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): undefined => { Unit.made$nested_Made(m, _2); }), undefined, 0, true); } @@ -742,45 +742,45 @@ export function madeAll$nested_Unit(m: Unit.Unit, data: rt.ByteSlice): rt.Vec undefined; - const units: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined => {}), undefined, 0, true); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_22: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; - const named: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), ignore as (a0: rt.u8) => undefined), undefined, 0, true); - const _15: rt.u8 | undefined = rt.byteSliceFirst(data); +export function units(data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: (a0: rs.u8) => undefined; + const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): undefined => {}), undefined, 0, true); + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_22: rs.u8): undefined => {}), undefined, 0, true), 0) as rs.VecDeque; + const named: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), ignore as (a0: rs.u8) => undefined), undefined, 0, true); + const _15: rs.u8 | undefined = rs.byteSliceFirst(data); b0: { if (_15 !== undefined) { - if (rt.u8Rem(_15, 2) === 0) { - f = ignore as (a0: rt.u8) => undefined; + if (rs.u8Rem(_15, 2) === 0) { + f = ignore as (a0: rs.u8) => undefined; break b0; } } - f = (_24: rt.u8): undefined => {}; + f = (_24: rs.u8): undefined => {}; } - const byPointer: rt.Vec = pointed(data, f); - const generic: rt.Vec = each$unit_nested_units_closure3(data, (_25: rt.u8): undefined => {}); - const byName: rt.Vec = each$unit_nested_ignore(data, ignore as (a0: rt.u8) => undefined); - rt.iterExtendBytes(out, rt.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); - const methods: rt.Vec = madeAll$nested_Unit({}, data); - const dynamic: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), rt.lent(ignore as (a0: rt.u8) => undefined)), undefined, 0, true); - const iter: rt.Iter> = rt.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); + const byPointer: rs.Vec = pointed(data, f); + const generic: rs.Vec = each$unit_nested_units_closure3(data, (_25: rs.u8): undefined => {}); + const byName: rs.Vec = each$unit_nested_ignore(data, ignore as (a0: rs.u8) => undefined); + rs.iterExtendBytes(out, rs.byteVecIntoIter(each$u8_nested_half(data, half)), undefined, true); + const methods: rs.Vec = madeAll$nested_Unit({}, data); + const dynamic: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), rs.lent(ignore as (a0: rs.u8) => undefined)), undefined, 0, true); + const iter: rs.Iter> = rs.iterSlice([units, named, byPointer, generic, byName, methods, dynamic]); while (true) { - const _46: rt.Vec | rt.Done = iter.next(); - if (_46 === rt.DONE) { + const _46: rs.Vec | rs.Done = iter.next(); + if (_46 === rs.DONE) { break; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_46.items.length & 0xff, rt.sliceFirst(_46.items, rt.None) !== rt.None ? 1 : 0, rt.iterCount(rt.iterSlice(_46.items)) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_46.items.length & 0xff, rs.sliceFirst(_46.items, rs.None) !== rs.None ? 1 : 0, rs.iterCount(rs.iterSlice(_46.items)) & 0xff)), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(q.n & 0xff, rt.dequeEnd(q, true, rt.None) !== rt.None ? 1 : 0)), undefined, true); - const o: undefined | rt.None = option_map$0p22lts(rt.byteSliceFirst(data), (_26: rt.u8): undefined => {}); - const none: undefined | rt.None = option_map$0p22lts(filter$0v80fk8(rt.byteSliceGet(data, 1), (b: rt.u8): boolean => { - return rt.u8Rem(b, 2) === 0; - }), (_28: rt.u8): undefined => {}); - const r: rt.Result = result_map$03hz3l7(option_okOr$1vxk0yk(rt.byteSliceFirst(data), 238), (_210: rt.u8): undefined => {}); - const e: rt.Result = result_mapErr$1whfgss(option_okOr$0g9lvh7(rt.byteSliceFirst(data), undefined), (_: undefined): undefined => {}); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(o !== rt.None ? 1 : 0, none !== rt.None ? 1 : 0, r.ok ? 1 : 0, !e.ok ? 1 : 0)), undefined, true); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(units.items, f, rt.fmtUnit), (f: rt.Formatter) => rt.fmtOption(o, f, rt.fmtUnit, rt.None), (f: rt.Formatter) => rt.fmtOption(none, f, rt.fmtUnit, rt.None), (f: rt.Formatter) => rt.fmtResult(r, f, rt.fmtUnit, rt.u8Debug), (f: rt.Formatter) => rt.fmtResult(e, f, rt.u8Debug, rt.fmtUnit)]; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(q.n & 0xff, rs.dequeEnd(q, true, rs.None) !== rs.None ? 1 : 0)), undefined, true); + const o: undefined | rs.None = option_map$057a36e(rs.byteSliceFirst(data), (_26: rs.u8): undefined => {}); + const none: undefined | rs.None = option_map$057a36e(filter$0hq86nl(rs.byteSliceGet(data, 1), (b: rs.u8): boolean => { + return rs.u8Rem(b, 2) === 0; + }), (_28: rs.u8): undefined => {}); + const r: rs.Result = result_map$1gelxzx(option_okOr$1j8owgb(rs.byteSliceFirst(data), 238), (_210: rs.u8): undefined => {}); + const e: rs.Result = result_mapErr$136pgpq(option_okOr$06f2ml7(rs.byteSliceFirst(data), undefined), (_: undefined): undefined => {}); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(o !== rs.None ? 1 : 0, none !== rs.None ? 1 : 0, r.ok ? 1 : 0, !e.ok ? 1 : 0)), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtOption(o, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, rs.fmtUnit, rs.None), (f: rs.Formatter) => rs.fmtResult(r, f, rs.fmtUnit, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(e, f, rs.u8Debug, rs.fmtUnit)]; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4]])))), undefined, true); } //# sourceMappingURL=nested.ts.map diff --git a/ts/fixtures/lang/nested/src/nested.rs b/ts/fixtures/lang/nested/src/nested.rs index 941101d3b..2b815a805 100644 --- a/ts/fixtures/lang/nested/src/nested.rs +++ b/ts/fixtures/lang/nested/src/nested.rs @@ -1,5 +1,5 @@ //! Options of values that can already be `undefined`, `Option>` and -//! `Option<()>`, whose `None` is `rt.None` apart from each `Some`. +//! `Option<()>`, whose `None` is `rs.None` apart from each `Some`. use std::cmp::Ordering; use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque}; @@ -197,7 +197,7 @@ fn consumers(data: &[u8], out: &mut Vec) { let key = |o: &Option| o.map(|b| b % 4); out.push(code(it().max_by_key(key))); out.push(code(it().min_by_key(key))); - // By a key whose `None` is `rt.None` too. + // By a key whose `None` is `rs.None` too. let nested = |o: &Option| o.map(|b| (b % 4 != 0).then_some(b % 3)); out.push(code(it().max_by_key(nested))); out.push(code(it().min_by_key(nested))); diff --git a/ts/fixtures/lang/objects/expected/core/option.ts b/ts/fixtures/lang/objects/expected/core/option.ts index 6e8907ca4..c909b0306 100644 --- a/ts/fixtures/lang/objects/expected/core/option.ts +++ b/ts/fixtures/lang/objects/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1q3ff8g(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$1gfk3jk(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/objects/expected/harness.ts b/ts/fixtures/lang/objects/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/objects/expected/harness.ts +++ b/ts/fixtures/lang/objects/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/objects/expected/lib.ts b/ts/fixtures/lang/objects/expected/lib.ts index 156fc3eef..b196968a0 100644 --- a/ts/fixtures/lang/objects/expected/lib.ts +++ b/ts/fixtures/lang/objects/expected/lib.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { objects } from "./objects.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["objects::objects", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["objects::objects", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { objects(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/objects/expected/objects.Wakes.ts b/ts/fixtures/lang/objects/expected/objects.Wakes.ts index 3ee691636..d24507c34 100644 --- a/ts/fixtures/lang/objects/expected/objects.Wakes.ts +++ b/ts/fixtures/lang/objects/expected/objects.Wakes.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Wakes { - _0: rt.Atomic; + _0: rs.Atomic; } -export function wake$task_Wake(self: rt.Arc): void { - rt.atomicFetch(self.value._0, rt.u8WrappingAdd, 1, 0); +export function wake$task_Wake(self: rs.Arc): void { + rs.atomicFetch(self.value._0, rs.u8WrappingAdd, 1, 0); self[Symbol.dispose](); } diff --git a/ts/fixtures/lang/objects/expected/objects.Window.ts b/ts/fixtures/lang/objects/expected/objects.Window.ts index 502fe4b3c..ad7ad2257 100644 --- a/ts/fixtures/lang/objects/expected/objects.Window.ts +++ b/ts/fixtures/lang/objects/expected/objects.Window.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Window { - return new Window(0, new rt.Vec()); + return new Window(0, new rs.Vec()); } /** The crate's own struct, taken apart and put back, as moq-net's `apply` does. */ export class Window { - start: rt.u8; - held: rt.Vec>; + start: rs.u8; + held: rs.Vec>; - constructor(start: rt.u8, held: rt.Vec>) { + constructor(start: rs.u8, held: rs.Vec>) { this.start = start; this.held = held; } [Symbol.dispose](): void { - rt.dropVec(this.held); + rs.dropVec(this.held); } } -export function withStart(self: Window, start: rt.u8): Window { +export function withStart(self: Window, start: rs.u8): Window { self.start = start; return self; } diff --git a/ts/fixtures/lang/objects/expected/objects.ts b/ts/fixtures/lang/objects/expected/objects.ts index a7ee4d312..3ddcecb04 100644 --- a/ts/fixtures/lang/objects/expected/objects.ts +++ b/ts/fixtures/lang/objects/expected/objects.ts @@ -1,413 +1,413 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1q3ff8g as option_mapOr$1q3ff8g } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$1gfk3jk as option_mapOr$1gfk3jk } from "./core/option.ts"; import * as Wakes from "./objects.Wakes.ts"; import * as Window from "./objects.Window.ts"; /** moq-net's growing buffer: the `Arc` behind a parameter, replaced by a bigger one. */ -export function reserve(current: rt.Place>, needed: rt.usize): void { +export function reserve(current: rs.Place>, needed: rs.usize): void { if (!(current.v.value.length >= needed)) { - const next: rt.ByteVec = rt.byteVecOf(0, rt.max(needed, rt.usizeMul(current.v.value.length, 2))); + const next: rs.ByteVec = rs.byteVecOf(0, rs.max(needed, rs.usizeMul(current.v.value.length, 2))); const part = current.v.value.length; - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteVecSlice(next), 0, part), rt.byteVecSlice(current.v.value)); - const _24: rt.Arc = new rt.Arc(next); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteVecSlice(next), 0, part), rs.byteVecSlice(current.v.value)); + const _24: rs.Arc = new rs.Arc(next); current.v[Symbol.dispose](); current.v = _24; } } -export function repin(p: rt.Place>, to: rt.u8): void { - const _3: rt.Arc = new rt.Arc(to); +export function repin(p: rs.Place>, to: rs.u8): void { + const _3: rs.Arc = new rs.Arc(to); p.v[Symbol.dispose](); p.v = _3; } /** What a pointer to a pinned `Arc` reads, through its own `Deref` and then the pin's. */ -export function through$mut_Pin_sync_Arc_u8(p: rt.Place>): rt.u8 { +export function through$mut_Pin_sync_Arc_u8(p: rs.Place>): rs.u8 { return p.v.value; } /** What a pointer to a pinned `Arc` reads, through its own `Deref` and then the pin's. */ -export function through$ref_Pin_sync_Arc_u8(p: rt.Arc): rt.u8 { +export function through$ref_Pin_sync_Arc_u8(p: rs.Arc): rs.u8 { return p.value; } /** What a pointer to an `Arc` reads, through its own `Deref` and then the `Arc`'s. */ -export function throughArc$mut_sync_Arc_u8(p: rt.Place>): rt.u8 { +export function throughArc$mut_sync_Arc_u8(p: rs.Place>): rs.u8 { return p.v.value; } /** What a pointer to an `Arc` reads, through its own `Deref` and then the `Arc`'s. */ -export function throughArc$ref_sync_Arc_u8(p: rt.Arc): rt.u8 { +export function throughArc$ref_sync_Arc_u8(p: rs.Arc): rs.u8 { return p.value; } /** What a pointer to a guard reads, through its own `Deref` and then the guard's. */ -export function throughMutex$mut_sync_Mutex_u8(p: rt.Mutex): rt.u8 { - const _4: rt.Mutex = rt.mutexLock(p); - const _0: rt.u8 = _4.value; - rt.mutexUnlock(_4); +export function throughMutex$mut_sync_Mutex_u8(p: rs.Mutex): rs.u8 { + const _4: rs.Mutex = rs.mutexLock(p); + const _0: rs.u8 = _4.value; + rs.mutexUnlock(_4); return _0; } /** What a pointer to a guard reads, through its own `Deref` and then the guard's. */ -export function throughMutex$ref_sync_Mutex_u8(p: rt.Mutex): rt.u8 { - const _4: rt.Mutex = rt.mutexLock(p); - const _0: rt.u8 = _4.value; - rt.mutexUnlock(_4); +export function throughMutex$ref_sync_Mutex_u8(p: rs.Mutex): rs.u8 { + const _4: rs.Mutex = rs.mutexLock(p); + const _0: rs.u8 = _4.value; + rs.mutexUnlock(_4); return _0; } /** Writes a byte through a pointer's `DerefMut`. */ -export function writeThrough$Pin_mut_u8(p: rt.Place, by: rt.u8): void { +export function writeThrough$Pin_mut_u8(p: rs.Place, by: rs.u8): void { p.v = p.v ^ by; } /** Writes a byte through a pointer's `DerefMut`. */ -export function writeThrough$mut_u8(p: rt.Place, by: rt.u8): void { +export function writeThrough$mut_u8(p: rs.Place, by: rs.u8): void { p.v = p.v ^ by; } /** Replaces an `Arc` through a pointer's `DerefMut`. */ -export function replaceThrough$Pin_mut_sync_Arc_u8(p: rt.Place>, by: rt.u8): void { - const _3: rt.Arc = new rt.Arc(by); - const _4: rt.Place> = p; +export function replaceThrough$Pin_mut_sync_Arc_u8(p: rs.Place>, by: rs.u8): void { + const _3: rs.Arc = new rs.Arc(by); + const _4: rs.Place> = p; _4.v[Symbol.dispose](); _4.v = _3; } /** Replaces an `Arc` through a pointer's `DerefMut`. */ -export function replaceThrough$mut_sync_Arc_u8(p: rt.Place>, by: rt.u8): void { - const _3: rt.Arc = new rt.Arc(by); +export function replaceThrough$mut_sync_Arc_u8(p: rs.Place>, by: rs.u8): void { + const _3: rs.Arc = new rs.Arc(by); p.v[Symbol.dispose](); p.v = _3; } /** Replaces an `Arc` through a pointer's `DerefMut`. */ -export function replaceThrough$sync_MutexGuard_sync_Arc_u8(p: rt.Mutex>, by: rt.u8): void { - const _3: rt.Arc = new rt.Arc(by); +export function replaceThrough$sync_MutexGuard_sync_Arc_u8(p: rs.Mutex>, by: rs.u8): void { + const _3: rs.Arc = new rs.Arc(by); p.value[Symbol.dispose](); p.value = _3; - rt.mutexUnlock(p); + rs.mutexUnlock(p); } /** A pin of a byte, made through a function pointer, that writes the byte. */ -export function pinVia(p: rt.Place): rt.Place { - return ((a0: rt.Place): rt.Place => { +export function pinVia(p: rs.Place): rs.Place { + return ((a0: rs.Place): rs.Place => { return a0; })(p); } -export function lockedBy(n: rt.u8): rt.Mutex { - return new rt.Mutex(rt.u8WrappingAdd(n, 3)); +export function lockedBy(n: rs.u8): rs.Mutex { + return new rs.Mutex(rs.u8WrappingAdd(n, 3)); } /** The `Arc` a pinned box holds, replaced through `Pin`'s `DerefMut`. */ -export function rebox(p: rt.Place>, to: rt.u8): void { - const _3: rt.Arc = new rt.Arc(to); +export function rebox(p: rs.Place>, to: rs.u8): void { + const _3: rs.Arc = new rs.Arc(to); p.v[Symbol.dispose](); p.v = _3; } -export function apply(w: Window.Window, start: rt.u8): void { - const _3: Window.Window = Window.withStart(rt.replaceIn(w, Window.default$Default()), start); +export function apply(w: Window.Window, start: rs.u8): void { + const _3: Window.Window = Window.withStart(rs.replaceIn(w, Window.default$Default()), start); w[Symbol.dispose](); Object.assign(w, _3); } /** What moq-net's tracks do: a new value made of the old one's parts, swapped in. */ -export function park(w: Window.Window, start: rt.u8): rt.u8 { +export function park(w: Window.Window, start: rs.u8): rs.u8 { const taken = w.held; - w.held = new rt.Vec(); - const _6: Window.Window = rt.replaceIn(w, new Window.Window(start, taken)); - const _0: rt.u8 = _6.start; + w.held = new rs.Vec(); + const _6: Window.Window = rs.replaceIn(w, new Window.Window(start, taken)); + const _0: rs.u8 = _6.start; _6[Symbol.dispose](); return _0; } export function swapWindows(a: Window.Window, b: Window.Window): void { - Object.assign(a, rt.replaceIn(b, a)); + Object.assign(a, rs.replaceIn(b, a)); } /** A local's own `Vec` swapped with the one a parameter points at, each kept apart. */ -export function swapIn(v: rt.Vec>, with_: rt.Arc): rt.Vec> { - const swapped = rt.replaceIn(v, rt.vecFrom([rt.arcClone(with_)])); - const _9: rt.Arc = rt.arcClone(with_); +export function swapIn(v: rs.Vec>, with_: rs.Arc): rs.Vec> { + const swapped = rs.replaceIn(v, rs.vecFrom([rs.arcClone(with_)])); + const _9: rs.Arc = rs.arcClone(with_); v.items.push(_9); return swapped; } /** A reference a closure copied, which holds the array it points at. */ -export function replaceCaptured(a: rt.u16[], to: rt.u16): rt.u16[] { +export function replaceCaptured(a: rs.u16[], to: rs.u16): rs.u16[] { const captured = to; - return ((): rt.u16[] => { - return rt.replaceIn(a, [captured, rt.u16WrappingAdd(captured, 1)]); + return ((): rs.u16[] => { + return rs.replaceIn(a, [captured, rs.u16WrappingAdd(captured, 1)]); })(); } /** A pinned box is what it holds in JS: here a `Vec`, whose length changes. */ -export function repinAll(v: rt.Vec>, with_: rt.Arc, n: rt.u8): rt.usize { - const old: rt.Vec> = rt.replaceIn(v, rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 3)), (_2: rt.u8): rt.Arc => { - return rt.arcClone(with_); +export function repinAll(v: rs.Vec>, with_: rs.Arc, n: rs.u8): rs.usize { + const old: rs.Vec> = rs.replaceIn(v, rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(n, 3)), (_2: rs.u8): rs.Arc => { + return rs.arcClone(with_); }), undefined, 4, true)); - const _12: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 4)), (_22: rt.u8): rt.Arc => { - return rt.arcClone(with_); + const _12: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(n, 4)), (_22: rs.u8): rs.Arc => { + return rs.arcClone(with_); }), undefined, 4, true); - rt.dropVec(v); + rs.dropVec(v); Object.assign(v, _12); - const _0: rt.usize = old.items.length; - rt.dropVec(old); + const _0: rs.usize = old.items.length; + rs.dropVec(old); return _0; } /** An array of objects, assigned whole through a parameter. */ -export function reset(a: rt.Arc[], with_: rt.Arc): void { - const _3: rt.Arc = rt.arcClone(with_); - const _4: rt.Arc = new rt.Arc(with_.value); - rt.dropAll(a); +export function reset(a: rs.Arc[], with_: rs.Arc): void { + const _3: rs.Arc = rs.arcClone(with_); + const _4: rs.Arc = new rs.Arc(with_.value); + rs.dropAll(a); Object.assign(a, [_3, _4]); } -export function takeAll(v: rt.Vec>): rt.Vec> { - return rt.replaceIn(v, new rt.Vec()); +export function takeAll(v: rs.Vec>): rs.Vec> { + return rs.replaceIn(v, new rs.Vec()); } -export function swapAll(a: rt.Vec>, b: rt.Vec>): void { - Object.assign(a, rt.replaceIn(b, a)); +export function swapAll(a: rs.Vec>, b: rs.Vec>): void { + Object.assign(a, rs.replaceIn(b, a)); } -export function refill(v: rt.Vec>, bytes: rt.ByteVec, with_: rt.Arc, n: rt.u8): void { - const _5: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(n, 4)), (_2: rt.u8): rt.Arc => { - return rt.arcClone(with_); +export function refill(v: rs.Vec>, bytes: rs.ByteVec, with_: rs.Arc, n: rs.u8): void { + const _5: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(n, 4)), (_2: rs.u8): rs.Arc => { + return rs.arcClone(with_); }), undefined, 4, true); - rt.dropVec(v); + rs.dropVec(v); Object.assign(v, _5); - Object.assign(bytes, rt.byteVecOf(n, rt.u8Rem(n, 3) as rt.usize)); + Object.assign(bytes, rs.byteVecOf(n, rs.u8Rem(n, 3) as rs.usize)); } -export function requeue(q: rt.VecDeque, map: rt.HashMap, n: rt.u8): rt.usize { - const old: rt.VecDeque = rt.replaceIn(q, rt.dequeFromVec(rt.iterToVec(new rt.Range(0, rt.u8Rem(n, 5)), undefined, 1, true), 1, true) as rt.VecDeque); - Object.assign(map, rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[n, n] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)); +export function requeue(q: rs.VecDeque, map: rs.HashMap, n: rs.u8): rs.usize { + const old: rs.VecDeque = rs.replaceIn(q, rs.dequeFromVec(rs.iterToVec(new rs.Range(0, rs.u8Rem(n, 5)), undefined, 1, true), 1, true) as rs.VecDeque); + Object.assign(map, rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice([[n, n] as [rs.u8, rs.u8]]), undefined, undefined, undefined, 469762048)); return old.n; } -export function relink(w: rt.Weak, to: rt.Arc): void { - const _3: rt.Weak = new rt.Weak(to); +export function relink(w: rs.Weak, to: rs.Arc): void { + const _3: rs.Weak = new rs.Weak(to); w[Symbol.dispose](); Object.assign(w, _3); } /** A `Waker`, whose clones may be one object, as `noop`'s are. */ -export function rewake(w: rt.Place, to: rt.Waker): rt.Waker { - const _3: rt.Waker = to.clone(); +export function rewake(w: rs.Place, to: rs.Waker): rs.Waker { + const _3: rs.Waker = to.clone(); const old = w.v; w.v = _3; return old; } /** What `count` says of each `Arc`, and the values `items` hold. */ -export function counts(out: rt.ByteVec, arcs: rt.Arc[], items: rt.Arc[]): void { +export function counts(out: rs.ByteVec, arcs: rs.Arc[], items: rs.Arc[]): void { for (const _6 of arcs) { - rt.byteVecPush(out, _6.strong & 0xff); + rs.byteVecPush(out, _6.strong & 0xff); } - rt.byteVecPush(out, items.length & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items), (a: rt.Arc): rt.u8 => { + rs.byteVecPush(out, items.length & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(items), (a: rs.Arc): rs.u8 => { return a.value; }), undefined, true); } -export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { - let _625!: rt.Waker; - const by: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 5); - const one: rt.Arc = new rt.Arc(by); - const two: rt.Arc = new rt.Arc(rt.u8WrappingAdd(by, 1)); - const v: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Arc => { - return rt.arcClone(one); +export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { + let _625!: rs.Waker; + const by: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 5); + const one: rs.Arc = new rs.Arc(by); + const two: rs.Arc = new rs.Arc(rs.u8WrappingAdd(by, 1)); + const v: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Arc => { + return rs.arcClone(one); }), undefined, 4, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _18: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } - const i: rt.usize = _18[0]; - const b: rt.u8 = _18[1]; - const _23: rt.Place> | undefined = rt.sliceGetMut(v.items, rt.usizeRem(b as rt.usize, rt.usizeAdd(data.length, 1))); + const i: rs.usize = _18[0]; + const b: rs.u8 = _18[1]; + const _23: rs.Place> | undefined = rs.sliceGetMut(v.items, rs.usizeRem(b as rs.usize, rs.usizeAdd(data.length, 1))); if (_23 !== undefined) { - const _34: rt.Arc = rt.arcClone(two); + const _34: rs.Arc = rs.arcClone(two); _23.v[Symbol.dispose](); _23.v = _34; } - if (rt.u8Rem(b, 3) === 0) { - const _39: rt.Place> | undefined = rt.sliceGetMut(v.items, i); + if (rs.u8Rem(b, 3) === 0) { + const _39: rs.Place> | undefined = rs.sliceGetMut(v.items, i); if (_39 !== undefined) { - const _44: rt.Arc = new rt.Arc(b); + const _44: rs.Arc = new rs.Arc(b); _39.v[Symbol.dispose](); _39.v = _44; } } } counts(out, [one, two], v.items); - let maybe: rt.Arc | undefined = rt.arcClone(one); - const _56: rt.Place> | undefined = maybe === undefined ? undefined : rt.place(() => maybe as rt.Arc, (value) => maybe = value); + let maybe: rs.Arc | undefined = rs.arcClone(one); + const _56: rs.Place> | undefined = maybe === undefined ? undefined : rs.place(() => maybe as rs.Arc, (value) => maybe = value); if (_56 !== undefined) { - const _60: rt.Arc = rt.arcClone(two); + const _60: rs.Arc = rs.arcClone(two); _56.v[Symbol.dispose](); _56.v = _60; } - rt.byteVecPush(out, option_mapOr$1q3ff8g(maybe, 238, (a2: rt.Arc): rt.u8 => { - const _02: rt.u8 = a2.value; + rs.byteVecPush(out, option_mapOr$1gfk3jk(maybe, 238, (a2: rs.Arc): rs.u8 => { + const _02: rs.u8 = a2.value; a2[Symbol.dispose](); return _02; })); - const iter2: rt.Iter<[rt.Place>, rt.u8]> = rt.iterZip(rt.iterSliceMut(v.items), rt.iterSlice(rt.byteSliceView(data)), [false, false]); + const iter2: rs.Iter<[rs.Place>, rs.u8]> = rs.iterZip(rs.iterSliceMut(v.items), rs.iterSlice(rs.byteSliceView(data)), [false, false]); while (true) { - const _71: [rt.Place>, rt.u8] | rt.Done = iter2.next(); - if (_71 === rt.DONE) { + const _71: [rs.Place>, rs.u8] | rs.Done = iter2.next(); + if (_71 === rs.DONE) { break; } - if (rt.u8Rem(_71[1], 2) === 0) { - const _79: rt.Arc = rt.arcClone(one); + if (rs.u8Rem(_71[1], 2) === 0) { + const _79: rs.Arc = rs.arcClone(one); _71[0].v[Symbol.dispose](); _71[0].v = _79; } } - const _81: rt.Place> | undefined = rt.sliceLastMut(v.items); + const _81: rs.Place> | undefined = rs.sliceLastMut(v.items); if (_81 !== undefined) { - const _86: rt.Arc = new rt.Arc(rt.u8WrappingMul(by, 3)); + const _86: rs.Arc = new rs.Arc(rs.u8WrappingMul(by, 3)); _81.v[Symbol.dispose](); _81.v = _86; } - let kept: rt.Arc = rt.arcClone(one); - ((to: rt.Arc): undefined => { - const _32: rt.Arc = rt.arcClone(to); + let kept: rs.Arc = rs.arcClone(one); + ((to: rs.Arc): undefined => { + const _32: rs.Arc = rs.arcClone(to); kept[Symbol.dispose](); kept = _32; })(two); - rt.byteVecPush(out, kept.value); + rs.byteVecPush(out, kept.value); kept[Symbol.dispose](); counts(out, [one, two], v.items); - let buffer: rt.Arc = new rt.Arc(rt.byteSliceToByteVec(data)); - const reader: rt.Arc = rt.arcClone(buffer); - for (const _116 of rt.byteSliceView(data)) { - const _122: rt.usize = rt.u8Rem(_116, 16) as rt.usize; - reserve(rt.place(() => buffer, (value2) => buffer = value2), _122); + let buffer: rs.Arc = new rs.Arc(rs.byteSliceToByteVec(data)); + const reader: rs.Arc = rs.arcClone(buffer); + for (const _116 of rs.byteSliceView(data)) { + const _122: rs.usize = rs.u8Rem(_116, 16) as rs.usize; + reserve(rs.place(() => buffer, (value2) => buffer = value2), _122); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(buffer.value.length & 0xff, reader.value.length & 0xff))); - rt.byteVecPush(out, reader.strong & 0xff); - let pinned: rt.Arc = new rt.Arc(by); - const _145: rt.u8 = rt.u8WrappingAdd(by, 7); - repin(rt.place(() => pinned, (value3) => pinned = value3), _145); - rt.byteVecPush(out, pinned.value); - const held: rt.Arc = new rt.Arc(by); - let boxed: rt.Arc = rt.arcClone(held); - const _156: rt.u8 = rt.u8WrappingAdd(by, 9); - rebox(rt.place(() => boxed, (value4) => boxed = value4), _156); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed.value, held.strong & 0xff))); - const lent: rt.Arc = held; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(lent.strong & 0xff, lent.value, through$ref_Pin_sync_Arc_u8(pinned)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(throughArc$ref_sync_Arc_u8(held), throughMutex$ref_sync_Mutex_u8(lockedBy(by))))); - let _199: rt.Arc = rt.arcClone(held); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(throughArc$mut_sync_Arc_u8(rt.place(() => _199, (value5) => _199 = value5)), through$mut_Pin_sync_Arc_u8(rt.place(() => pinned, (value6) => pinned = value6))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(buffer.value.length & 0xff, reader.value.length & 0xff))); + rs.byteVecPush(out, reader.strong & 0xff); + let pinned: rs.Arc = new rs.Arc(by); + const _145: rs.u8 = rs.u8WrappingAdd(by, 7); + repin(rs.place(() => pinned, (value3) => pinned = value3), _145); + rs.byteVecPush(out, pinned.value); + const held: rs.Arc = new rs.Arc(by); + let boxed: rs.Arc = rs.arcClone(held); + const _156: rs.u8 = rs.u8WrappingAdd(by, 9); + rebox(rs.place(() => boxed, (value4) => boxed = value4), _156); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed.value, held.strong & 0xff))); + const lent: rs.Arc = held; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(lent.strong & 0xff, lent.value, through$ref_Pin_sync_Arc_u8(pinned)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(throughArc$ref_sync_Arc_u8(held), throughMutex$ref_sync_Mutex_u8(lockedBy(by))))); + let _199: rs.Arc = rs.arcClone(held); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(throughArc$mut_sync_Arc_u8(rs.place(() => _199, (value5) => _199 = value5)), through$mut_Pin_sync_Arc_u8(rs.place(() => pinned, (value6) => pinned = value6))))); _199[Symbol.dispose](); - rt.byteVecPush(out, throughMutex$mut_sync_Mutex_u8(lockedBy(by))); - let byte: rt.u8 = by; - const _210: rt.Place = rt.place(() => byte, (value7) => byte = value7); + rs.byteVecPush(out, throughMutex$mut_sync_Mutex_u8(lockedBy(by))); + let byte: rs.u8 = by; + const _210: rs.Place = rs.place(() => byte, (value7) => byte = value7); _210.v = _210.v ^ 90; - writeThrough$Pin_mut_u8(rt.place(() => byte, (value8) => byte = value8), 33); - writeThrough$mut_u8(rt.place(() => byte, (value9) => byte = value9), 12); - rt.byteVecPush(out, byte); - let replaced: rt.Arc = new rt.Arc(by); - const _220: rt.Arc = new rt.Arc(rt.u8WrappingAdd(by, 1)); - const _222: rt.Place> = rt.place(() => replaced, (value10) => replaced = value10); + writeThrough$Pin_mut_u8(rs.place(() => byte, (value8) => byte = value8), 33); + writeThrough$mut_u8(rs.place(() => byte, (value9) => byte = value9), 12); + rs.byteVecPush(out, byte); + let replaced: rs.Arc = new rs.Arc(by); + const _220: rs.Arc = new rs.Arc(rs.u8WrappingAdd(by, 1)); + const _222: rs.Place> = rs.place(() => replaced, (value10) => replaced = value10); _222.v[Symbol.dispose](); _222.v = _220; - rt.byteVecPush(out, replaced.value); - replaceThrough$Pin_mut_sync_Arc_u8(rt.place(() => replaced, (value11) => replaced = value11), rt.u8WrappingAdd(by, 2)); - rt.byteVecPush(out, replaced.value); - const _240: rt.u8 = rt.u8WrappingAdd(by, 3); - replaceThrough$mut_sync_Arc_u8(rt.place(() => replaced, (value12) => replaced = value12), _240); - rt.byteVecPush(out, replaced.value); - const guarded: rt.Mutex> = new rt.Mutex(new rt.Arc(by)); - replaceThrough$sync_MutexGuard_sync_Arc_u8(rt.mutexLock(guarded), rt.u8WrappingAdd(by, 4)); - const _257: rt.Mutex> = rt.mutexLock(guarded); - rt.byteVecPush(out, _257.value.value); - rt.mutexUnlock(_257); - let pinnedByte: rt.u8 = by; - const _261: rt.Place = pinVia(rt.place(() => pinnedByte, (value13) => pinnedByte = value13)); + rs.byteVecPush(out, replaced.value); + replaceThrough$Pin_mut_sync_Arc_u8(rs.place(() => replaced, (value11) => replaced = value11), rs.u8WrappingAdd(by, 2)); + rs.byteVecPush(out, replaced.value); + const _240: rs.u8 = rs.u8WrappingAdd(by, 3); + replaceThrough$mut_sync_Arc_u8(rs.place(() => replaced, (value12) => replaced = value12), _240); + rs.byteVecPush(out, replaced.value); + const guarded: rs.Mutex> = new rs.Mutex(new rs.Arc(by)); + replaceThrough$sync_MutexGuard_sync_Arc_u8(rs.mutexLock(guarded), rs.u8WrappingAdd(by, 4)); + const _257: rs.Mutex> = rs.mutexLock(guarded); + rs.byteVecPush(out, _257.value.value); + rs.mutexUnlock(_257); + let pinnedByte: rs.u8 = by; + const _261: rs.Place = pinVia(rs.place(() => pinnedByte, (value13) => pinnedByte = value13)); _261.v = _261.v ^ 90; - rt.byteVecPush(out, pinnedByte); - let owned: rt.Arc = rt.arcClone(held); - const lent2: rt.Place> = rt.place(() => owned, (value14) => owned = value14); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(lent2.v.strong & 0xff, lent2.v.value))); - const locked: rt.Mutex>> = new rt.Mutex(v); - const _287: rt.Mutex>> = rt.mutexLock(locked); + rs.byteVecPush(out, pinnedByte); + let owned: rs.Arc = rs.arcClone(held); + const lent2: rs.Place> = rs.place(() => owned, (value14) => owned = value14); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(lent2.v.strong & 0xff, lent2.v.value))); + const locked: rs.Mutex>> = new rs.Mutex(v); + const _287: rs.Mutex>> = rs.mutexLock(locked); const taken3 = _287.value; - _287.value = new rt.Vec(); - const taken: rt.Vec> = taken3; - rt.mutexUnlock(_287); + _287.value = new rs.Vec(); + const taken: rs.Vec> = taken3; + rs.mutexUnlock(_287); counts(out, [one, two], taken.items); - const _298: rt.Vec> = rt.vecFrom([rt.arcClone(two)]); - const _304: rt.Mutex>> = rt.mutexLock(locked); - rt.dropVec(_304.value); + const _298: rs.Vec> = rs.vecFrom([rs.arcClone(two)]); + const _304: rs.Mutex>> = rs.mutexLock(locked); + rs.dropVec(_304.value); _304.value = _298; - rt.mutexUnlock(_304); - rt.dropVec(taken); - const _309: rt.Arc[] = [one, two]; - const _317: rt.Mutex>> = rt.mutexLock(locked); + rs.mutexUnlock(_304); + rs.dropVec(taken); + const _309: rs.Arc[] = [one, two]; + const _317: rs.Mutex>> = rs.mutexLock(locked); counts(out, _309, _317.value.items); - rt.mutexUnlock(_317); - const cell: rt.RefCell>> = new rt.RefCell(rt.vecFrom([rt.arcClone(one)])); - const _328: rt.RefCell>> = rt.refCellBorrowMut(cell); + rs.mutexUnlock(_317); + const cell: rs.RefCell>> = new rs.RefCell(rs.vecFrom([rs.arcClone(one)])); + const _328: rs.RefCell>> = rs.refCellBorrowMut(cell); const taken4 = _328.value; - _328.value = new rt.Vec(); - const taken2: rt.Vec> = taken4; - rt.refMutRelease(_328); - const _330: rt.Vec> = rt.vecFrom([rt.arcClone(two), rt.arcClone(two)]); - const _338: rt.RefCell>> = rt.refCellBorrowMut(cell); - rt.dropVec(_338.value); + _328.value = new rs.Vec(); + const taken2: rs.Vec> = taken4; + rs.refMutRelease(_328); + const _330: rs.Vec> = rs.vecFrom([rs.arcClone(two), rs.arcClone(two)]); + const _338: rs.RefCell>> = rs.refCellBorrowMut(cell); + rs.dropVec(_338.value); _338.value = _330; - rt.refMutRelease(_338); + rs.refMutRelease(_338); counts(out, [one, two], taken2.items); - const _349: rt.Arc[] = [one, two]; - const _357: rt.RefCell>> = rt.refCellBorrow(cell); + const _349: rs.Arc[] = [one, two]; + const _357: rs.RefCell>> = rs.refCellBorrow(cell); counts(out, _349, _357.value.items); - rt.refRelease(_357); - const sets: rt.HashMap> = rt.hashNew() as rt.HashMap>; - const _363: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const _362: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _363, true, undefined, undefined, 1, true); - rt.hashInsert(sets, by, _362); - const _365: rt.BTreeSet | undefined = rt.hashGet(sets, by); + rs.refRelease(_357); + const sets: rs.HashMap> = rs.hashNew() as rs.HashMap>; + const _363: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const _362: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _363, true, undefined, undefined, 1, true); + rs.hashInsert(sets, by, _362); + const _365: rs.BTreeSet | undefined = rs.hashGet(sets, by); if (_365 !== undefined) { - const _372: Uint8Array = Uint8Array.of(rt.u8WrappingAdd(by, 1)); - rt.byteVecPush(out, rt.btreeLen(rt.replaceIn(_365, rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_372), true, undefined, undefined, 1, true))) & 0xff); + const _372: Uint8Array = Uint8Array.of(rs.u8WrappingAdd(by, 1)); + rs.byteVecPush(out, rs.btreeLen(rs.replaceIn(_365, rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_372), true, undefined, undefined, 1, true))) & 0xff); } const _379: Uint8Array = Uint8Array.of(by); - const _378: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_379), true, undefined, undefined, 1, true); - const _383: rt.u8 = rt.u8WrappingAdd(by, 1); - Object.assign(rt.entryOrInsertWith(rt.entry(sets, _383), (): rt.BTreeSet => { - return rt.btreeNew(rt.cmp) as rt.BTreeSet; + const _378: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_379), true, undefined, undefined, 1, true); + const _383: rs.u8 = rs.u8WrappingAdd(by, 1); + Object.assign(rs.entryOrInsertWith(rs.entry(sets, _383), (): rs.BTreeSet => { + return rs.btreeNew(rs.cmp) as rs.BTreeSet; }), _378); - const keys: rt.Vec<[rt.u8, rt.u8]> = rt.iterToVec(rt.iterMap(rt.hashIter(sets), (_22: [rt.u8, rt.BTreeSet]): [rt.u8, rt.u8] => { - return [_22[0], rt.btreeLen(_22[1]) & 0xff] as [rt.u8, rt.u8]; + const keys: rs.Vec<[rs.u8, rs.u8]> = rs.iterToVec(rs.iterMap(rs.hashIter(sets), (_22: [rs.u8, rs.BTreeSet]): [rs.u8, rs.u8] => { + return [_22[0], rs.btreeLen(_22[1]) & 0xff] as [rs.u8, rs.u8]; }), "next", 2); - rt.sliceSort(keys.items, rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 2, true); + rs.sliceSort(keys.items, rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 2, true); for (const _394 of keys.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_394[0], _394[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_394[0], _394[1]))); } - const _404: rt.Vec> = rt.vecFrom([rt.arcClone(one)]); + const _404: rs.Vec> = rs.vecFrom([rs.arcClone(one)]); const w: Window.Window = new Window.Window(by, _404); - const other: rt.Vec> = rt.vecFrom([rt.arcClone(two), rt.arcClone(two)]); - const bytes: rt.ByteVec = new rt.ByteVec(); - for (const b4 of rt.byteSliceView(data)) { - const _422: rt.u8 = rt.u8Rem(b4, 5); + const other: rs.Vec> = rs.vecFrom([rs.arcClone(two), rs.arcClone(two)]); + const bytes: rs.ByteVec = new rs.ByteVec(); + for (const b4 of rs.byteSliceView(data)) { + const _422: rs.u8 = rs.u8Rem(b4, 5); if (_422 === 0) { apply(w, b4); continue; } if (_422 === 1) { - rt.byteVecPush(out, park(w, b4)); + rs.byteVecPush(out, park(w, b4)); continue; } if (_422 === 2) { @@ -419,88 +419,88 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { continue; } if (_422 === 4) { - if (rt.u8Rem(b4, 2) === 0) { - const mine: rt.Vec> = swapIn(other, two); + if (rs.u8Rem(b4, 2) === 0) { + const mine: rs.Vec> = swapIn(other, two); counts(out, [one, two], mine.items); - rt.dropVec(mine); + rs.dropVec(mine); continue; } } - rt.dropVec(takeAll(w.held)); + rs.dropVec(takeAll(w.held)); } - const pinnedAll: rt.Vec> = rt.vecFrom([rt.arcClone(two)]); - for (const _455 of rt.byteSliceView(data)) { - rt.byteVecPush(out, repinAll(pinnedAll, one, _455) & 0xff); + const pinnedAll: rs.Vec> = rs.vecFrom([rs.arcClone(two)]); + for (const _455 of rs.byteSliceView(data)) { + rs.byteVecPush(out, repinAll(pinnedAll, one, _455) & 0xff); } counts(out, [one, two], pinnedAll.items); - rt.dropVec(pinnedAll); - const pair: rt.Arc[] = [rt.arcClone(one), rt.arcClone(two)]; + rs.dropVec(pinnedAll); + const pair: rs.Arc[] = [rs.arcClone(one), rs.arcClone(two)]; reset(pair, two); counts(out, [one, two], pair); - rt.dropAll(pair); - rt.byteVecPush(out, w.start); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); + rs.dropAll(pair); + rs.byteVecPush(out, w.start); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); counts(out, [one, two], w.held.items); counts(out, [one, two], other.items); - const q: rt.VecDeque = rt.dequeFromArray(Uint8Array.of(by), 1, true) as rt.VecDeque; - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - for (const _519 of rt.byteSliceView(data)) { - rt.byteVecPush(out, requeue(q, map, _519) & 0xff); + const q: rs.VecDeque = rs.dequeFromArray(Uint8Array.of(by), 1, true) as rs.VecDeque; + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + for (const _519 of rs.byteSliceView(data)) { + rs.byteVecPush(out, requeue(q, map, _519) & 0xff); } - rt.iterExtendBytes(out, rt.dequeIter(q), undefined, true); - rt.iterExtendBytes(out, rt.hashValues(map), "next"); - const weak: rt.Weak = new rt.Weak(); + rs.iterExtendBytes(out, rs.dequeIter(q), undefined, true); + rs.iterExtendBytes(out, rs.hashValues(map), "next"); + const weak: rs.Weak = new rs.Weak(); relink(weak, two); - rt.byteVecPush(out, option_mapOr$1q3ff8g(rt.weakUpgrade(weak), 238, (a3: rt.Arc): rt.u8 => { - const _05: rt.u8 = a3.value; + rs.byteVecPush(out, option_mapOr$1gfk3jk(rs.weakUpgrade(weak), 238, (a3: rs.Arc): rs.u8 => { + const _05: rs.u8 = a3.value; a3[Symbol.dispose](); return _05; })); - rt.byteVecPush(out, two.weak & 0xff); + rs.byteVecPush(out, two.weak & 0xff); const a: Window.Window = Window.withStart(Window.default$Default(), by); - const b7: Window.Window = new Window.Window(rt.u8WrappingAdd(by, 2), rt.vecFrom([rt.arcClone(one)])); - const _555: rt.u16 = by as rt.u16; - const array: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { + const b7: Window.Window = new Window.Window(rs.u8WrappingAdd(by, 2), rs.vecFrom([rs.arcClone(one)])); + const _555: rs.u16 = by as rs.u16; + const array: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return _555; }); - for (const x of rt.byteSliceView(data)) { - if (rt.u8Rem(x, 2) === 0) { + for (const x of rs.byteSliceView(data)) { + if (rs.u8Rem(x, 2) === 0) { swapWindows(a, b7); } - const old2: rt.u16[] = replaceCaptured(array, x as rt.u16); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(old2[0] & 0xff, old2[1] & 0xff))); + const old2: rs.u16[] = replaceCaptured(array, x as rs.u16); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(old2[0] & 0xff, old2[1] & 0xff))); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.start, a.held.items.length & 0xff, b7.start, b7.held.items.length & 0xff))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(array[0] & 0xff, array[1] & 0xff))); - const wakes: rt.Arc = new rt.Arc({ _0: new rt.Atomic(0) }); - const counting: rt.Waker = rt.arcWaker(rt.arcClone(wakes), Wakes.wake$task_Wake as (a0: rt.Arc) => undefined, (arc: rt.Arc) => arc[Symbol.dispose]()); - const noop: rt.Waker = rt.NOOP_WAKER.clone(); - let w2: rt.Waker = noop.clone(); - for (const _619 of rt.byteSliceView(data)) { - if (!(rt.u8Rem(_619, 2) === 0)) { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.start, a.held.items.length & 0xff, b7.start, b7.held.items.length & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(array[0] & 0xff, array[1] & 0xff))); + const wakes: rs.Arc = new rs.Arc({ _0: new rs.Atomic(0) }); + const counting: rs.Waker = rs.arcWaker(rs.arcClone(wakes), Wakes.wake$task_Wake as (a0: rs.Arc) => undefined, (arc: rs.Arc) => arc[Symbol.dispose]()); + const noop: rs.Waker = rs.NOOP_WAKER.clone(); + let w2: rs.Waker = noop.clone(); + for (const _619 of rs.byteSliceView(data)) { + if (!(rs.u8Rem(_619, 2) === 0)) { _625 = noop; } else { _625 = counting; } - const old3: rt.Waker = rewake(rt.place(() => w2, (value15) => w2 = value15), _625); + const old3: rs.Waker = rewake(rs.place(() => w2, (value15) => w2 = value15), _625); old3.wakeByRef(); w2.wakeByRef(); old3[Symbol.dispose](); } w2[Symbol.dispose](); - rt.byteVecPush(out, rt.atomicLoad(wakes.value._0, 0)); - rt.byteVecPush(out, wakes.strong & 0xff); + rs.byteVecPush(out, rs.atomicLoad(wakes.value._0, 0)); + rs.byteVecPush(out, wakes.strong & 0xff); noop[Symbol.dispose](); counting[Symbol.dispose](); wakes[Symbol.dispose](); b7[Symbol.dispose](); a[Symbol.dispose](); weak[Symbol.dispose](); - rt.dropVec(other); + rs.dropVec(other); w[Symbol.dispose](); - rt.dropVec(taken2); - rt.dropVec(cell.value); - rt.dropVec(locked.value); + rs.dropVec(taken2); + rs.dropVec(cell.value); + rs.dropVec(locked.value); owned[Symbol.dispose](); guarded[Symbol.dispose](); replaced[Symbol.dispose](); diff --git a/ts/fixtures/lang/operators/expected/core/option.ts b/ts/fixtures/lang/operators/expected/core/option.ts index 0fb1b6278..020e119ff 100644 --- a/ts/fixtures/lang/operators/expected/core/option.ts +++ b/ts/fixtures/lang/operators/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/operators/expected/harness.ts b/ts/fixtures/lang/operators/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/operators/expected/harness.ts +++ b/ts/fixtures/lang/operators/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/operators/expected/lib.ts b/ts/fixtures/lang/operators/expected/lib.ts index a6fb39945..39ff2be17 100644 --- a/ts/fixtures/lang/operators/expected/lib.ts +++ b/ts/fixtures/lang/operators/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { u8s, u16s, u32s, u64s, u128s, usizes, i8s, i16s, i32s, i64s, i128s, isizes, f64s, f32s, bools } from "./operators.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["operators::u8s", u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u16s", u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u32s", u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u64s", u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::u128s", u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::usizes", usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i8s", i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i16s", i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i32s", i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i64s", i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::i128s", i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::isizes", isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::f64s", f64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::f32s", f32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["operators::bools", bools as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["operators::u8s", u8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::u16s", u16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::u32s", u32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::u64s", u64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::u128s", u128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::usizes", usizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::i8s", i8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::i16s", i16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::i32s", i32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::i64s", i64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::i128s", i128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::isizes", isizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::f64s", f64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::f32s", f32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["operators::bools", bools as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/operators/expected/operators.ts b/ts/fixtures/lang/operators/expected/operators.ts index 480f3bcd5..cd620c72b 100644 --- a/ts/fixtures/lang/operators/expected/operators.ts +++ b/ts/fixtures/lang/operators/expected/operators.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** `f(a)`, as a generic body calls a function value. */ export function one$bool_bool_ops_Not_not_bool(_: (a0: boolean) => boolean, a: boolean): boolean { @@ -9,72 +9,72 @@ export function one$bool_bool_ops_Not_not_bool(_: (a0: boolean) => boolean, a: b } /** `f(a)`, as a generic body calls a function value. */ -export function one$f32_f32_ops_Neg_neg_f32(_: (a0: rt.f32) => rt.f32, a: rt.f32): rt.f32 { +export function one$f32_f32_ops_Neg_neg_f32(_: (a0: rs.f32) => rs.f32, a: rs.f32): rs.f32 { return -a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$f64_f64_ops_Neg_neg_f64(_: (a0: rt.f64) => rt.f64, a: rt.f64): rt.f64 { +export function one$f64_f64_ops_Neg_neg_f64(_: (a0: rs.f64) => rs.f64, a: rs.f64): rs.f64 { return -a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$i128_i128_ops_Neg_neg_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { - return rt.i128Neg(a); +export function one$i128_i128_ops_Neg_neg_i128(_: (a0: rs.i128) => rs.i128, a: rs.i128): rs.i128 { + return rs.i128Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i128_i128_ops_Not_not_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { - return rt.i128Not(a); +export function one$i128_i128_ops_Not_not_i128(_: (a0: rs.i128) => rs.i128, a: rs.i128): rs.i128 { + return rs.i128Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i16_i16_ops_Neg_neg_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { - return rt.i16Neg(a); +export function one$i16_i16_ops_Neg_neg_i16(_: (a0: rs.i16) => rs.i16, a: rs.i16): rs.i16 { + return rs.i16Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i16_i16_ops_Not_not_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { +export function one$i16_i16_ops_Not_not_i16(_: (a0: rs.i16) => rs.i16, a: rs.i16): rs.i16 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$i32_i32_ops_Neg_neg_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { - return rt.i32Neg(a); +export function one$i32_i32_ops_Neg_neg_i32(_: (a0: rs.i32) => rs.i32, a: rs.i32): rs.i32 { + return rs.i32Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i32_i32_ops_Not_not_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { +export function one$i32_i32_ops_Not_not_i32(_: (a0: rs.i32) => rs.i32, a: rs.i32): rs.i32 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$i64_i64_ops_Neg_neg_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { - return rt.i64Neg(a); +export function one$i64_i64_ops_Neg_neg_i64(_: (a0: rs.i64) => rs.i64, a: rs.i64): rs.i64 { + return rs.i64Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i64_i64_ops_Not_not_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { - return rt.i64Not(a); +export function one$i64_i64_ops_Not_not_i64(_: (a0: rs.i64) => rs.i64, a: rs.i64): rs.i64 { + return rs.i64Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i8_i8_ops_Neg_neg_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { - return rt.i8Neg(a); +export function one$i8_i8_ops_Neg_neg_i8(_: (a0: rs.i8) => rs.i8, a: rs.i8): rs.i8 { + return rs.i8Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$i8_i8_ops_Not_not_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { +export function one$i8_i8_ops_Not_not_i8(_: (a0: rs.i8) => rs.i8, a: rs.i8): rs.i8 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$isize_isize_ops_Neg_neg_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { - return rt.isizeNeg(a); +export function one$isize_isize_ops_Neg_neg_isize(_: (a0: rs.isize) => rs.isize, a: rs.isize): rs.isize { + return rs.isizeNeg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$isize_isize_ops_Not_not_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { +export function one$isize_isize_ops_Not_not_isize(_: (a0: rs.isize) => rs.isize, a: rs.isize): rs.isize { return ~a; } @@ -84,132 +84,132 @@ export function one$ref_bool_bool_ops_Not_not_ref_bool(_: (a0: boolean) => boole } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_f32_f32_ops_Neg_neg_ref_f32(_: (a0: rt.f32) => rt.f32, a: rt.f32): rt.f32 { +export function one$ref_f32_f32_ops_Neg_neg_ref_f32(_: (a0: rs.f32) => rs.f32, a: rs.f32): rs.f32 { return -a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_f64_f64_ops_Neg_neg_ref_f64(_: (a0: rt.f64) => rt.f64, a: rt.f64): rt.f64 { +export function one$ref_f64_f64_ops_Neg_neg_ref_f64(_: (a0: rs.f64) => rs.f64, a: rs.f64): rs.f64 { return -a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i128_i128_ops_Neg_neg_ref_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { - return rt.i128Neg(a); +export function one$ref_i128_i128_ops_Neg_neg_ref_i128(_: (a0: rs.i128) => rs.i128, a: rs.i128): rs.i128 { + return rs.i128Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i128_i128_ops_Not_not_ref_i128(_: (a0: rt.i128) => rt.i128, a: rt.i128): rt.i128 { - return rt.i128Not(a); +export function one$ref_i128_i128_ops_Not_not_ref_i128(_: (a0: rs.i128) => rs.i128, a: rs.i128): rs.i128 { + return rs.i128Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i16_i16_ops_Neg_neg_ref_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { - return rt.i16Neg(a); +export function one$ref_i16_i16_ops_Neg_neg_ref_i16(_: (a0: rs.i16) => rs.i16, a: rs.i16): rs.i16 { + return rs.i16Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i16_i16_ops_Not_not_ref_i16(_: (a0: rt.i16) => rt.i16, a: rt.i16): rt.i16 { +export function one$ref_i16_i16_ops_Not_not_ref_i16(_: (a0: rs.i16) => rs.i16, a: rs.i16): rs.i16 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i32_i32_ops_Neg_neg_ref_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { - return rt.i32Neg(a); +export function one$ref_i32_i32_ops_Neg_neg_ref_i32(_: (a0: rs.i32) => rs.i32, a: rs.i32): rs.i32 { + return rs.i32Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i32_i32_ops_Not_not_ref_i32(_: (a0: rt.i32) => rt.i32, a: rt.i32): rt.i32 { +export function one$ref_i32_i32_ops_Not_not_ref_i32(_: (a0: rs.i32) => rs.i32, a: rs.i32): rs.i32 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i64_i64_ops_Neg_neg_ref_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { - return rt.i64Neg(a); +export function one$ref_i64_i64_ops_Neg_neg_ref_i64(_: (a0: rs.i64) => rs.i64, a: rs.i64): rs.i64 { + return rs.i64Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i64_i64_ops_Not_not_ref_i64(_: (a0: rt.i64) => rt.i64, a: rt.i64): rt.i64 { - return rt.i64Not(a); +export function one$ref_i64_i64_ops_Not_not_ref_i64(_: (a0: rs.i64) => rs.i64, a: rs.i64): rs.i64 { + return rs.i64Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i8_i8_ops_Neg_neg_ref_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { - return rt.i8Neg(a); +export function one$ref_i8_i8_ops_Neg_neg_ref_i8(_: (a0: rs.i8) => rs.i8, a: rs.i8): rs.i8 { + return rs.i8Neg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_i8_i8_ops_Not_not_ref_i8(_: (a0: rt.i8) => rt.i8, a: rt.i8): rt.i8 { +export function one$ref_i8_i8_ops_Not_not_ref_i8(_: (a0: rs.i8) => rs.i8, a: rs.i8): rs.i8 { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_isize_isize_ops_Neg_neg_ref_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { - return rt.isizeNeg(a); +export function one$ref_isize_isize_ops_Neg_neg_ref_isize(_: (a0: rs.isize) => rs.isize, a: rs.isize): rs.isize { + return rs.isizeNeg(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_isize_isize_ops_Not_not_ref_isize(_: (a0: rt.isize) => rt.isize, a: rt.isize): rt.isize { +export function one$ref_isize_isize_ops_Not_not_ref_isize(_: (a0: rs.isize) => rs.isize, a: rs.isize): rs.isize { return ~a; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_u128_u128_ops_Not_not_ref_u128(_: (a0: rt.u128) => rt.u128, a: rt.u128): rt.u128 { - return rt.u128Not(a); +export function one$ref_u128_u128_ops_Not_not_ref_u128(_: (a0: rs.u128) => rs.u128, a: rs.u128): rs.u128 { + return rs.u128Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_u16_u16_ops_Not_not_ref_u16(_: (a0: rt.u16) => rt.u16, a: rt.u16): rt.u16 { +export function one$ref_u16_u16_ops_Not_not_ref_u16(_: (a0: rs.u16) => rs.u16, a: rs.u16): rs.u16 { return ~a & 0xffff; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_u32_u32_ops_Not_not_ref_u32(_: (a0: rt.u32) => rt.u32, a: rt.u32): rt.u32 { +export function one$ref_u32_u32_ops_Not_not_ref_u32(_: (a0: rs.u32) => rs.u32, a: rs.u32): rs.u32 { return ~a >>> 0; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_u64_u64_ops_Not_not_ref_u64(_: (a0: rt.u64) => rt.u64, a: rt.u64): rt.u64 { - return rt.u64Not(a); +export function one$ref_u64_u64_ops_Not_not_ref_u64(_: (a0: rs.u64) => rs.u64, a: rs.u64): rs.u64 { + return rs.u64Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_u8_u8_ops_Not_not_ref_u8(_: (a0: rt.u8) => rt.u8, a: rt.u8): rt.u8 { +export function one$ref_u8_u8_ops_Not_not_ref_u8(_: (a0: rs.u8) => rs.u8, a: rs.u8): rs.u8 { return ~a & 0xff; } /** `f(a)`, as a generic body calls a function value. */ -export function one$ref_usize_usize_ops_Not_not_ref_usize(_: (a0: rt.usize) => rt.usize, a: rt.usize): rt.usize { +export function one$ref_usize_usize_ops_Not_not_ref_usize(_: (a0: rs.usize) => rs.usize, a: rs.usize): rs.usize { return ~a >>> 0; } /** `f(a)`, as a generic body calls a function value. */ -export function one$u128_u128_ops_Not_not_u128(_: (a0: rt.u128) => rt.u128, a: rt.u128): rt.u128 { - return rt.u128Not(a); +export function one$u128_u128_ops_Not_not_u128(_: (a0: rs.u128) => rs.u128, a: rs.u128): rs.u128 { + return rs.u128Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$u16_u16_ops_Not_not_u16(_: (a0: rt.u16) => rt.u16, a: rt.u16): rt.u16 { +export function one$u16_u16_ops_Not_not_u16(_: (a0: rs.u16) => rs.u16, a: rs.u16): rs.u16 { return ~a & 0xffff; } /** `f(a)`, as a generic body calls a function value. */ -export function one$u32_u32_ops_Not_not_u32(_: (a0: rt.u32) => rt.u32, a: rt.u32): rt.u32 { +export function one$u32_u32_ops_Not_not_u32(_: (a0: rs.u32) => rs.u32, a: rs.u32): rs.u32 { return ~a >>> 0; } /** `f(a)`, as a generic body calls a function value. */ -export function one$u64_u64_ops_Not_not_u64(_: (a0: rt.u64) => rt.u64, a: rt.u64): rt.u64 { - return rt.u64Not(a); +export function one$u64_u64_ops_Not_not_u64(_: (a0: rs.u64) => rs.u64, a: rs.u64): rs.u64 { + return rs.u64Not(a); } /** `f(a)`, as a generic body calls a function value. */ -export function one$u8_u8_ops_Not_not_u8(_: (a0: rt.u8) => rt.u8, a: rt.u8): rt.u8 { +export function one$u8_u8_ops_Not_not_u8(_: (a0: rs.u8) => rs.u8, a: rs.u8): rs.u8 { return ~a & 0xff; } /** `f(a)`, as a generic body calls a function value. */ -export function one$usize_usize_ops_Not_not_usize(_: (a0: rt.usize) => rt.usize, a: rt.usize): rt.usize { +export function one$usize_usize_ops_Not_not_usize(_: (a0: rs.usize) => rs.usize, a: rs.usize): rs.usize { return ~a >>> 0; } @@ -229,1670 +229,1670 @@ export function two$bool_bool_bool_ops_BitXor_bitxor_bool_bool(_: (a0: boolean, } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_f32_f32_ops_Add_add_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_f32_f32_ops_Add_add_f32_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return Math.fround(a + b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_f32_f32_ops_Div_div_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_f32_f32_ops_Div_div_f32_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return Math.fround(a / b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_f32_f32_ops_Mul_mul_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_f32_f32_ops_Mul_mul_f32_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return Math.fround(a * b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_f32_f32_ops_Rem_rem_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_f32_f32_ops_Rem_rem_f32_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return a % b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_f32_f32_ops_Sub_sub_f32_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_f32_f32_ops_Sub_sub_f32_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return Math.fround(a - b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return a % b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_f64_f64_ops_Add_add_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_f64_f64_ops_Add_add_f64_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a + b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_f64_f64_ops_Div_div_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_f64_f64_ops_Div_div_f64_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a / b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_f64_f64_ops_Mul_mul_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_f64_f64_ops_Mul_mul_f64_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a * b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_f64_f64_ops_Rem_rem_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_f64_f64_ops_Rem_rem_f64_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a % b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_f64_f64_ops_Sub_sub_f64_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_f64_f64_ops_Sub_sub_f64_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a - b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a % b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_Add_add_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Add(a, b); +export function two$i128_i128_i128_ops_Add_add_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_BitAnd_bitand_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128And(a, b); +export function two$i128_i128_i128_ops_BitAnd_bitand_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128And(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_BitOr_bitor_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Or(a, b); +export function two$i128_i128_i128_ops_BitOr_bitor_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Or(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_BitXor_bitxor_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Xor(a, b); +export function two$i128_i128_i128_ops_BitXor_bitxor_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Xor(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_Div_div_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Div(a, b); +export function two$i128_i128_i128_ops_Div_div_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_Mul_mul_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Mul(a, b); +export function two$i128_i128_i128_ops_Mul_mul_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_Rem_rem_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Rem(a, b); +export function two$i128_i128_i128_ops_Rem_rem_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i128_i128_ops_Sub_sub_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Sub(a, b); +export function two$i128_i128_i128_ops_Sub_sub_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_i16_i128_ops_Shl_shl_i128_i16(_: (a0: rt.i128, a1: rt.i16) => rt.i128, a: rt.i128, b: rt.i16): rt.i128 { - return rt.i128Shl(a, b); +export function two$i128_i16_i128_ops_Shl_shl_i128_i16(_: (a0: rs.i128, a1: rs.i16) => rs.i128, a: rs.i128, b: rs.i16): rs.i128 { + return rs.i128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Add(a, b); +export function two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_u128_i128_ops_Shr_shr_i128_u128(_: (a0: rt.i128, a1: rt.u128) => rt.i128, a: rt.i128, b: rt.u128): rt.i128 { - return rt.i128Shr(a, b); +export function two$i128_u128_i128_ops_Shr_shr_i128_u128(_: (a0: rs.i128, a1: rs.u128) => rs.i128, a: rs.i128, b: rs.u128): rs.i128 { + return rs.i128Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_u32_i128_ops_Shl_shl_i128_u32(_: (a0: rt.i128, a1: rt.u32) => rt.i128, a: rt.i128, b: rt.u32): rt.i128 { - return rt.i128Shl(a, b); +export function two$i128_u32_i128_ops_Shl_shl_i128_u32(_: (a0: rs.i128, a1: rs.u32) => rs.i128, a: rs.i128, b: rs.u32): rs.i128 { + return rs.i128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i128_u32_i128_ops_Shr_shr_i128_u32(_: (a0: rt.i128, a1: rt.u32) => rt.i128, a: rt.i128, b: rt.u32): rt.i128 { - return rt.i128Shr(a, b); +export function two$i128_u32_i128_ops_Shr_shr_i128_u32(_: (a0: rs.i128, a1: rs.u32) => rs.i128, a: rs.i128, b: rs.u32): rs.i128 { + return rs.i128Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Add_add_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Add(a, b); +export function two$i16_i16_i16_ops_Add_add_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_BitAnd_bitand_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { +export function two$i16_i16_i16_ops_BitAnd_bitand_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_BitOr_bitor_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { +export function two$i16_i16_i16_ops_BitOr_bitor_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_BitXor_bitxor_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { +export function two$i16_i16_i16_ops_BitXor_bitxor_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Div_div_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Div(a, b); +export function two$i16_i16_i16_ops_Div_div_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Mul_mul_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Mul(a, b); +export function two$i16_i16_i16_ops_Mul_mul_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Rem_rem_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Rem(a, b); +export function two$i16_i16_i16_ops_Rem_rem_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Shl_shl_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Shl(a, b); +export function two$i16_i16_i16_ops_Shl_shl_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_i16_i16_ops_Sub_sub_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Sub(a, b); +export function two$i16_i16_i16_ops_Sub_sub_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Add(a, b); +export function two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_u128_i16_ops_Shr_shr_i16_u128(_: (a0: rt.i16, a1: rt.u128) => rt.i16, a: rt.i16, b: rt.u128): rt.i16 { - return rt.i16Shr(a, b); +export function two$i16_u128_i16_ops_Shr_shr_i16_u128(_: (a0: rs.i16, a1: rs.u128) => rs.i16, a: rs.i16, b: rs.u128): rs.i16 { + return rs.i16Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_u32_i16_ops_Shl_shl_i16_u32(_: (a0: rt.i16, a1: rt.u32) => rt.i16, a: rt.i16, b: rt.u32): rt.i16 { - return rt.i16Shl(a, b); +export function two$i16_u32_i16_ops_Shl_shl_i16_u32(_: (a0: rs.i16, a1: rs.u32) => rs.i16, a: rs.i16, b: rs.u32): rs.i16 { + return rs.i16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i16_u32_i16_ops_Shr_shr_i16_u32(_: (a0: rt.i16, a1: rt.u32) => rt.i16, a: rt.i16, b: rt.u32): rt.i16 { - return rt.i16Shr(a, b); +export function two$i16_u32_i16_ops_Shr_shr_i16_u32(_: (a0: rs.i16, a1: rs.u32) => rs.i16, a: rs.i16, b: rs.u32): rs.i16 { + return rs.i16Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i16_i32_ops_Shl_shl_i32_i16(_: (a0: rt.i32, a1: rt.i16) => rt.i32, a: rt.i32, b: rt.i16): rt.i32 { - return rt.i32Shl(a, b); +export function two$i32_i16_i32_ops_Shl_shl_i32_i16(_: (a0: rs.i32, a1: rs.i16) => rs.i32, a: rs.i32, b: rs.i16): rs.i32 { + return rs.i32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_Add_add_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Add(a, b); +export function two$i32_i32_i32_ops_Add_add_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_BitAnd_bitand_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { +export function two$i32_i32_i32_ops_BitAnd_bitand_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_BitOr_bitor_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { +export function two$i32_i32_i32_ops_BitOr_bitor_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_BitXor_bitxor_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { +export function two$i32_i32_i32_ops_BitXor_bitxor_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_Div_div_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Div(a, b); +export function two$i32_i32_i32_ops_Div_div_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_Mul_mul_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Mul(a, b); +export function two$i32_i32_i32_ops_Mul_mul_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_Rem_rem_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Rem(a, b); +export function two$i32_i32_i32_ops_Rem_rem_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_i32_i32_ops_Sub_sub_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Sub(a, b); +export function two$i32_i32_i32_ops_Sub_sub_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Add(a, b); +export function two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_u128_i32_ops_Shr_shr_i32_u128(_: (a0: rt.i32, a1: rt.u128) => rt.i32, a: rt.i32, b: rt.u128): rt.i32 { - return rt.i32Shr(a, b); +export function two$i32_u128_i32_ops_Shr_shr_i32_u128(_: (a0: rs.i32, a1: rs.u128) => rs.i32, a: rs.i32, b: rs.u128): rs.i32 { + return rs.i32Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_u32_i32_ops_Shl_shl_i32_u32(_: (a0: rt.i32, a1: rt.u32) => rt.i32, a: rt.i32, b: rt.u32): rt.i32 { - return rt.i32Shl(a, b); +export function two$i32_u32_i32_ops_Shl_shl_i32_u32(_: (a0: rs.i32, a1: rs.u32) => rs.i32, a: rs.i32, b: rs.u32): rs.i32 { + return rs.i32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i32_u32_i32_ops_Shr_shr_i32_u32(_: (a0: rt.i32, a1: rt.u32) => rt.i32, a: rt.i32, b: rt.u32): rt.i32 { - return rt.i32Shr(a, b); +export function two$i32_u32_i32_ops_Shr_shr_i32_u32(_: (a0: rs.i32, a1: rs.u32) => rs.i32, a: rs.i32, b: rs.u32): rs.i32 { + return rs.i32Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i16_i64_ops_Shl_shl_i64_i16(_: (a0: rt.i64, a1: rt.i16) => rt.i64, a: rt.i64, b: rt.i16): rt.i64 { - return rt.i64Shl(a, b); +export function two$i64_i16_i64_ops_Shl_shl_i64_i16(_: (a0: rs.i64, a1: rs.i16) => rs.i64, a: rs.i64, b: rs.i16): rs.i64 { + return rs.i64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_Add_add_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Add(a, b); +export function two$i64_i64_i64_ops_Add_add_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_BitAnd_bitand_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64And(a, b); +export function two$i64_i64_i64_ops_BitAnd_bitand_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64And(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_BitOr_bitor_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Or(a, b); +export function two$i64_i64_i64_ops_BitOr_bitor_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Or(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_BitXor_bitxor_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Xor(a, b); +export function two$i64_i64_i64_ops_BitXor_bitxor_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Xor(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_Div_div_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Div(a, b); +export function two$i64_i64_i64_ops_Div_div_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_Mul_mul_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Mul(a, b); +export function two$i64_i64_i64_ops_Mul_mul_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_Rem_rem_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Rem(a, b); +export function two$i64_i64_i64_ops_Rem_rem_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_i64_i64_ops_Sub_sub_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Sub(a, b); +export function two$i64_i64_i64_ops_Sub_sub_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Add(a, b); +export function two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_u128_i64_ops_Shr_shr_i64_u128(_: (a0: rt.i64, a1: rt.u128) => rt.i64, a: rt.i64, b: rt.u128): rt.i64 { - return rt.i64Shr(a, b); +export function two$i64_u128_i64_ops_Shr_shr_i64_u128(_: (a0: rs.i64, a1: rs.u128) => rs.i64, a: rs.i64, b: rs.u128): rs.i64 { + return rs.i64Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_u32_i64_ops_Shl_shl_i64_u32(_: (a0: rt.i64, a1: rt.u32) => rt.i64, a: rt.i64, b: rt.u32): rt.i64 { - return rt.i64Shl(a, b); +export function two$i64_u32_i64_ops_Shl_shl_i64_u32(_: (a0: rs.i64, a1: rs.u32) => rs.i64, a: rs.i64, b: rs.u32): rs.i64 { + return rs.i64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i64_u32_i64_ops_Shr_shr_i64_u32(_: (a0: rt.i64, a1: rt.u32) => rt.i64, a: rt.i64, b: rt.u32): rt.i64 { - return rt.i64Shr(a, b); +export function two$i64_u32_i64_ops_Shr_shr_i64_u32(_: (a0: rs.i64, a1: rs.u32) => rs.i64, a: rs.i64, b: rs.u32): rs.i64 { + return rs.i64Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i16_i8_ops_Shl_shl_i8_i16(_: (a0: rt.i8, a1: rt.i16) => rt.i8, a: rt.i8, b: rt.i16): rt.i8 { - return rt.i8Shl(a, b); +export function two$i8_i16_i8_ops_Shl_shl_i8_i16(_: (a0: rs.i8, a1: rs.i16) => rs.i8, a: rs.i8, b: rs.i16): rs.i8 { + return rs.i8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_Add_add_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Add(a, b); +export function two$i8_i8_i8_ops_Add_add_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_BitAnd_bitand_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { +export function two$i8_i8_i8_ops_BitAnd_bitand_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_BitOr_bitor_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { +export function two$i8_i8_i8_ops_BitOr_bitor_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_BitXor_bitxor_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { +export function two$i8_i8_i8_ops_BitXor_bitxor_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_Div_div_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Div(a, b); +export function two$i8_i8_i8_ops_Div_div_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_Mul_mul_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Mul(a, b); +export function two$i8_i8_i8_ops_Mul_mul_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_Rem_rem_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Rem(a, b); +export function two$i8_i8_i8_ops_Rem_rem_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_i8_i8_ops_Sub_sub_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Sub(a, b); +export function two$i8_i8_i8_ops_Sub_sub_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Add(a, b); +export function two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_u128_i8_ops_Shr_shr_i8_u128(_: (a0: rt.i8, a1: rt.u128) => rt.i8, a: rt.i8, b: rt.u128): rt.i8 { - return rt.i8Shr(a, b); +export function two$i8_u128_i8_ops_Shr_shr_i8_u128(_: (a0: rs.i8, a1: rs.u128) => rs.i8, a: rs.i8, b: rs.u128): rs.i8 { + return rs.i8Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_u32_i8_ops_Shl_shl_i8_u32(_: (a0: rt.i8, a1: rt.u32) => rt.i8, a: rt.i8, b: rt.u32): rt.i8 { - return rt.i8Shl(a, b); +export function two$i8_u32_i8_ops_Shl_shl_i8_u32(_: (a0: rs.i8, a1: rs.u32) => rs.i8, a: rs.i8, b: rs.u32): rs.i8 { + return rs.i8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$i8_u32_i8_ops_Shr_shr_i8_u32(_: (a0: rt.i8, a1: rt.u32) => rt.i8, a: rt.i8, b: rt.u32): rt.i8 { - return rt.i8Shr(a, b); +export function two$i8_u32_i8_ops_Shr_shr_i8_u32(_: (a0: rs.i8, a1: rs.u32) => rs.i8, a: rs.i8, b: rs.u32): rs.i8 { + return rs.i8Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_i16_isize_ops_Shl_shl_isize_i16(_: (a0: rt.isize, a1: rt.i16) => rt.isize, a: rt.isize, b: rt.i16): rt.isize { - return rt.isizeShl(a, b); +export function two$isize_i16_isize_ops_Shl_shl_isize_i16(_: (a0: rs.isize, a1: rs.i16) => rs.isize, a: rs.isize, b: rs.i16): rs.isize { + return rs.isizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_Add_add_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeAdd(a, b); +export function two$isize_isize_isize_ops_Add_add_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeAdd(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_BitAnd_bitand_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { +export function two$isize_isize_isize_ops_BitAnd_bitand_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_BitOr_bitor_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { +export function two$isize_isize_isize_ops_BitOr_bitor_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_BitXor_bitxor_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { +export function two$isize_isize_isize_ops_BitXor_bitxor_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_Div_div_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeDiv(a, b); +export function two$isize_isize_isize_ops_Div_div_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeDiv(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_Mul_mul_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeMul(a, b); +export function two$isize_isize_isize_ops_Mul_mul_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeMul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_Rem_rem_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeRem(a, b); +export function two$isize_isize_isize_ops_Rem_rem_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeRem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_isize_isize_ops_Sub_sub_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeSub(a, b); +export function two$isize_isize_isize_ops_Sub_sub_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeSub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeAdd(a, b); +export function two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeAdd(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_u128_isize_ops_Shr_shr_isize_u128(_: (a0: rt.isize, a1: rt.u128) => rt.isize, a: rt.isize, b: rt.u128): rt.isize { - return rt.isizeShr(a, b); +export function two$isize_u128_isize_ops_Shr_shr_isize_u128(_: (a0: rs.isize, a1: rs.u128) => rs.isize, a: rs.isize, b: rs.u128): rs.isize { + return rs.isizeShr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_u32_isize_ops_Shl_shl_isize_u32(_: (a0: rt.isize, a1: rt.u32) => rt.isize, a: rt.isize, b: rt.u32): rt.isize { - return rt.isizeShl(a, b); +export function two$isize_u32_isize_ops_Shl_shl_isize_u32(_: (a0: rs.isize, a1: rs.u32) => rs.isize, a: rs.isize, b: rs.u32): rs.isize { + return rs.isizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$isize_u32_isize_ops_Shr_shr_isize_u32(_: (a0: rt.isize, a1: rt.u32) => rt.isize, a: rt.isize, b: rt.u32): rt.isize { - return rt.isizeShr(a, b); +export function two$isize_u32_isize_ops_Shr_shr_isize_u32(_: (a0: rs.isize, a1: rs.u32) => rs.isize, a: rs.isize, b: rs.u32): rs.isize { + return rs.isizeShr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { - ((a0: rt.Place, a1: boolean): undefined => { +export function two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool(_: (a0: rs.Place, a1: boolean) => undefined, a: rs.Place, b: boolean): void { + ((a0: rs.Place, a1: boolean): undefined => { a0.v = a0.v && a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { - ((a0: rt.Place, a1: boolean): undefined => { +export function two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool(_: (a0: rs.Place, a1: boolean) => undefined, a: rs.Place, b: boolean): void { + ((a0: rs.Place, a1: boolean): undefined => { a0.v = a0.v || a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { - ((a0: rt.Place, a1: boolean): undefined => { +export function two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool(_: (a0: rs.Place, a1: boolean) => undefined, a: rs.Place, b: boolean): void { + ((a0: rs.Place, a1: boolean): undefined => { a0.v = a0.v !== a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool(_: (a0: rt.Place, a1: boolean) => undefined, a: rt.Place, b: boolean): void { - ((a0: rt.Place, a1: boolean): undefined => { +export function two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool(_: (a0: rs.Place, a1: boolean) => undefined, a: rs.Place, b: boolean): void { + ((a0: rs.Place, a1: boolean): undefined => { a0.v = a0.v || a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = Math.fround(a0.v + a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = Math.fround(a0.v / a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = Math.fround(a0.v * a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = a0.v % a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = Math.fround(a0.v - a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = Math.fround(a0.v * a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32(_: (a0: rt.Place, a1: rt.f32) => undefined, a: rt.Place, b: rt.f32): void { - ((a0: rt.Place, a1: rt.f32): undefined => { +export function two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32(_: (a0: rs.Place, a1: rs.f32) => undefined, a: rs.Place, b: rs.f32): void { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = a0.v % a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v + a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v / a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v * a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v % a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v - a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v * a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64(_: (a0: rt.Place, a1: rt.f64) => undefined, a: rt.Place, b: rt.f64): void { - ((a0: rt.Place, a1: rt.f64): undefined => { +export function two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64(_: (a0: rs.Place, a1: rs.f64) => undefined, a: rs.Place, b: rs.f64): void { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v % a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Add(a0.v, a1); +export function two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128And(a0.v, a1); +export function two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128And(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Or(a0.v, a1); +export function two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Or(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Xor(a0.v, a1); +export function two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Xor(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Div(a0.v, a1); +export function two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Mul(a0.v, a1); +export function two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Rem(a0.v, a1); +export function two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Sub(a0.v, a1); +export function two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i128Shr(a0.v, a1); +export function two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i128Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Add(a0.v, a1); +export function two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128(_: (a0: rt.Place, a1: rt.i128) => undefined, a: rt.Place, b: rt.i128): void { - ((a0: rt.Place, a1: rt.i128): undefined => { - a0.v = rt.i128Div(a0.v, a1); +export function two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128(_: (a0: rs.Place, a1: rs.i128) => undefined, a: rs.Place, b: rs.i128): void { + ((a0: rs.Place, a1: rs.i128): undefined => { + a0.v = rs.i128Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i128Shr(a0.v, a1); +export function two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i128Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.i128Shl(a0.v, a1); +export function two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.i128Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Add(a0.v, a1); +export function two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { +export function two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { +export function two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { +export function two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Div(a0.v, a1); +export function two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Mul(a0.v, a1); +export function two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Rem(a0.v, a1); +export function two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Sub(a0.v, a1); +export function two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i16Shr(a0.v, a1); +export function two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i16Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Add(a0.v, a1); +export function two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16(_: (a0: rt.Place, a1: rt.i16) => undefined, a: rt.Place, b: rt.i16): void { - ((a0: rt.Place, a1: rt.i16): undefined => { - a0.v = rt.i16Div(a0.v, a1); +export function two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16(_: (a0: rs.Place, a1: rs.i16) => undefined, a: rs.Place, b: rs.i16): void { + ((a0: rs.Place, a1: rs.i16): undefined => { + a0.v = rs.i16Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i16Shr(a0.v, a1); +export function two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i16Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.i16Shl(a0.v, a1); +export function two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.i16Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Add(a0.v, a1); +export function two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { +export function two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { +export function two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { +export function two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Div(a0.v, a1); +export function two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Mul(a0.v, a1); +export function two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Rem(a0.v, a1); +export function two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Sub(a0.v, a1); +export function two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i32Shr(a0.v, a1); +export function two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i32Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Add(a0.v, a1); +export function two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32(_: (a0: rt.Place, a1: rt.i32) => undefined, a: rt.Place, b: rt.i32): void { - ((a0: rt.Place, a1: rt.i32): undefined => { - a0.v = rt.i32Div(a0.v, a1); +export function two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32(_: (a0: rs.Place, a1: rs.i32) => undefined, a: rs.Place, b: rs.i32): void { + ((a0: rs.Place, a1: rs.i32): undefined => { + a0.v = rs.i32Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i32Shr(a0.v, a1); +export function two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i32Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.i32Shl(a0.v, a1); +export function two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.i32Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Add(a0.v, a1); +export function two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64And(a0.v, a1); +export function two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64And(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Or(a0.v, a1); +export function two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Or(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Xor(a0.v, a1); +export function two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Xor(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Div(a0.v, a1); +export function two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Mul(a0.v, a1); +export function two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Rem(a0.v, a1); +export function two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Shr(a0.v, a1); +export function two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Sub(a0.v, a1); +export function two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Add(a0.v, a1); +export function two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i64Div(a0.v, a1); +export function two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i64Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i64Shr(a0.v, a1); +export function two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i64Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.i64Shl(a0.v, a1); +export function two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.i64Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.i8Shr(a0.v, a1); +export function two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.i8Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Add(a0.v, a1); +export function two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { +export function two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { +export function two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { +export function two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Div(a0.v, a1); +export function two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Mul(a0.v, a1); +export function two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Rem(a0.v, a1); +export function two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Sub(a0.v, a1); +export function two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Add(a0.v, a1); +export function two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8(_: (a0: rt.Place, a1: rt.i8) => undefined, a: rt.Place, b: rt.i8): void { - ((a0: rt.Place, a1: rt.i8): undefined => { - a0.v = rt.i8Div(a0.v, a1); +export function two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8(_: (a0: rs.Place, a1: rs.i8) => undefined, a: rs.Place, b: rs.i8): void { + ((a0: rs.Place, a1: rs.i8): undefined => { + a0.v = rs.i8Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i8Shr(a0.v, a1); +export function two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i8Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.i8Shl(a0.v, a1); +export function two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.i8Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.isizeShr(a0.v, a1); +export function two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.isizeShr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeAdd(a0.v, a1); +export function two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeAdd(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { +export function two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { +export function two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { +export function two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeDiv(a0.v, a1); +export function two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeDiv(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeMul(a0.v, a1); +export function two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeMul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeRem(a0.v, a1); +export function two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeRem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeSub(a0.v, a1); +export function two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeSub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeAdd(a0.v, a1); +export function two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeAdd(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize(_: (a0: rt.Place, a1: rt.isize) => undefined, a: rt.Place, b: rt.isize): void { - ((a0: rt.Place, a1: rt.isize): undefined => { - a0.v = rt.isizeDiv(a0.v, a1); +export function two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize(_: (a0: rs.Place, a1: rs.isize) => undefined, a: rs.Place, b: rs.isize): void { + ((a0: rs.Place, a1: rs.isize): undefined => { + a0.v = rs.isizeDiv(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.isizeShr(a0.v, a1); +export function two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.isizeShr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.isizeShl(a0.v, a1); +export function two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.isizeShl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.u128Shr(a0.v, a1); +export function two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.u128Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Add(a0.v, a1); +export function two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Div(a0.v, a1); +export function two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u128Shr(a0.v, a1); +export function two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u128Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Add(a0.v, a1); +export function two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128And(a0.v, a1); +export function two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128And(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Or(a0.v, a1); +export function two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Or(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Xor(a0.v, a1); +export function two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Xor(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Div(a0.v, a1); +export function two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Mul(a0.v, a1); +export function two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Rem(a0.v, a1); +export function two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128(_: (a0: rt.Place, a1: rt.u128) => undefined, a: rt.Place, b: rt.u128): void { - ((a0: rt.Place, a1: rt.u128): undefined => { - a0.v = rt.u128Sub(a0.v, a1); +export function two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128(_: (a0: rs.Place, a1: rs.u128) => undefined, a: rs.Place, b: rs.u128): void { + ((a0: rs.Place, a1: rs.u128): undefined => { + a0.v = rs.u128Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u128Shl(a0.v, a1); +export function two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u128Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.u16Shr(a0.v, a1); +export function two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.u16Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Add(a0.v, a1); +export function two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Div(a0.v, a1); +export function two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Shr(a0.v, a1); +export function two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Add(a0.v, a1); +export function two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { +export function two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { +export function two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { +export function two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Div(a0.v, a1); +export function two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Mul(a0.v, a1); +export function two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Rem(a0.v, a1); +export function two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Sub(a0.v, a1); +export function two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u16Shl(a0.v, a1); +export function two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u16Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.u32Shr(a0.v, a1); +export function two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.u32Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u32Shr(a0.v, a1); +export function two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u32Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Add(a0.v, a1); +export function two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Div(a0.v, a1); +export function two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Add(a0.v, a1); +export function two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { +export function two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { a0.v = (a0.v & a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { +export function two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { a0.v = (a0.v | a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { +export function two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { a0.v = (a0.v ^ a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Div(a0.v, a1); +export function two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Mul(a0.v, a1); +export function two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Rem(a0.v, a1); +export function two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Shl(a0.v, a1); +export function two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u32Sub(a0.v, a1); +export function two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u32Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.u64Shr(a0.v, a1); +export function two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.u64Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u64Shr(a0.v, a1); +export function two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u64Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Add(a0.v, a1); +export function two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Div(a0.v, a1); +export function two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u64Shl(a0.v, a1); +export function two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u64Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Add(a0.v, a1); +export function two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64And(a0.v, a1); +export function two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64And(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Or(a0.v, a1); +export function two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Or(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Xor(a0.v, a1); +export function two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Xor(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Div(a0.v, a1); +export function two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Mul(a0.v, a1); +export function two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Rem(a0.v, a1); +export function two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64(_: (a0: rt.Place, a1: rt.u64) => undefined, a: rt.Place, b: rt.u64): void { - ((a0: rt.Place, a1: rt.u64): undefined => { - a0.v = rt.u64Sub(a0.v, a1); +export function two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64(_: (a0: rs.Place, a1: rs.u64) => undefined, a: rs.Place, b: rs.u64): void { + ((a0: rs.Place, a1: rs.u64): undefined => { + a0.v = rs.u64Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.u8Shr(a0.v, a1); +export function two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.u8Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u8Shr(a0.v, a1); +export function two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u8Shr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Add(a0.v, a1); +export function two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Div(a0.v, a1); +export function two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.u8Shl(a0.v, a1); +export function two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.u8Shl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Add(a0.v, a1); +export function two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Add(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { +export function two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { a0.v = a0.v & a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { +export function two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { a0.v = a0.v | a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { +export function two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { a0.v = a0.v ^ a1; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Div(a0.v, a1); +export function two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Div(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Mul(a0.v, a1); +export function two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Mul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Rem(a0.v, a1); +export function two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Rem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8(_: (a0: rt.Place, a1: rt.u8) => undefined, a: rt.Place, b: rt.u8): void { - ((a0: rt.Place, a1: rt.u8): undefined => { - a0.v = rt.u8Sub(a0.v, a1); +export function two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8(_: (a0: rs.Place, a1: rs.u8) => undefined, a: rs.Place, b: rs.u8): void { + ((a0: rs.Place, a1: rs.u8): undefined => { + a0.v = rs.u8Sub(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64(_: (a0: rt.Place, a1: rt.i64) => undefined, a: rt.Place, b: rt.i64): void { - ((a0: rt.Place, a1: rt.i64): undefined => { - a0.v = rt.usizeShr(a0.v, a1); +export function two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64(_: (a0: rs.Place, a1: rs.i64) => undefined, a: rs.Place, b: rs.i64): void { + ((a0: rs.Place, a1: rs.i64): undefined => { + a0.v = rs.usizeShr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16(_: (a0: rt.Place, a1: rt.u16) => undefined, a: rt.Place, b: rt.u16): void { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.usizeShr(a0.v, a1); +export function two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16(_: (a0: rs.Place, a1: rs.u16) => undefined, a: rs.Place, b: rs.u16): void { + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.usizeShr(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeAdd(a0.v, a1); +export function two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeAdd(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeDiv(a0.v, a1); +export function two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeDiv(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32(_: (a0: rt.Place, a1: rt.u32) => undefined, a: rt.Place, b: rt.u32): void { - ((a0: rt.Place, a1: rt.u32): undefined => { - a0.v = rt.usizeShl(a0.v, a1); +export function two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32(_: (a0: rs.Place, a1: rs.u32) => undefined, a: rs.Place, b: rs.u32): void { + ((a0: rs.Place, a1: rs.u32): undefined => { + a0.v = rs.usizeShl(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeAdd(a0.v, a1); +export function two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeAdd(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { +export function two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { a0.v = (a0.v & a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { +export function two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { a0.v = (a0.v | a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { +export function two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { a0.v = (a0.v ^ a1) >>> 0; })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeDiv(a0.v, a1); +export function two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeDiv(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeMul(a0.v, a1); +export function two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeMul(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeRem(a0.v, a1); +export function two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeRem(a0.v, a1); })(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize(_: (a0: rt.Place, a1: rt.usize) => undefined, a: rt.Place, b: rt.usize): void { - ((a0: rt.Place, a1: rt.usize): undefined => { - a0.v = rt.usizeSub(a0.v, a1); +export function two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize(_: (a0: rs.Place, a1: rs.usize) => undefined, a: rs.Place, b: rs.usize): void { + ((a0: rs.Place, a1: rs.usize): undefined => { + a0.v = rs.usizeSub(a0.v, a1); })(a, b); } @@ -1902,1050 +1902,1050 @@ export function two$ref_bool_ref_bool_bool_ops_BitAnd_bitand_ref_bool_ref_bool(_ } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32(_: (a0: rt.f32, a1: rt.f32) => rt.f32, a: rt.f32, b: rt.f32): rt.f32 { +export function two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32(_: (a0: rs.f32, a1: rs.f32) => rs.f32, a: rs.f32, b: rs.f32): rs.f32 { return Math.fround(a + b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64(_: (a0: rt.f64, a1: rt.f64) => rt.f64, a: rt.f64, b: rt.f64): rt.f64 { +export function two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64(_: (a0: rs.f64, a1: rs.f64) => rs.f64, a: rs.f64, b: rs.f64): rs.f64 { return a + b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Sub(a, b); +export function two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128(_: (a0: rt.i128, a1: rt.i128) => rt.i128, a: rt.i128, b: rt.i128): rt.i128 { - return rt.i128Mul(a, b); +export function two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128(_: (a0: rs.i128, a1: rs.i128) => rs.i128, a: rs.i128, b: rs.i128): rs.i128 { + return rs.i128Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8(_: (a0: rt.i128, a1: rt.u8) => rt.i128, a: rt.i128, b: rt.u8): rt.i128 { - return rt.i128Shl(a, b); +export function two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8(_: (a0: rs.i128, a1: rs.u8) => rs.i128, a: rs.i128, b: rs.u8): rs.i128 { + return rs.i128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Sub(a, b); +export function two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16(_: (a0: rt.i16, a1: rt.i16) => rt.i16, a: rt.i16, b: rt.i16): rt.i16 { - return rt.i16Mul(a, b); +export function two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16(_: (a0: rs.i16, a1: rs.i16) => rs.i16, a: rs.i16, b: rs.i16): rs.i16 { + return rs.i16Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8(_: (a0: rt.i16, a1: rt.u8) => rt.i16, a: rt.i16, b: rt.u8): rt.i16 { - return rt.i16Shl(a, b); +export function two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8(_: (a0: rs.i16, a1: rs.u8) => rs.i16, a: rs.i16, b: rs.u8): rs.i16 { + return rs.i16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Sub(a, b); +export function two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32(_: (a0: rt.i32, a1: rt.i32) => rt.i32, a: rt.i32, b: rt.i32): rt.i32 { - return rt.i32Mul(a, b); +export function two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32(_: (a0: rs.i32, a1: rs.i32) => rs.i32, a: rs.i32, b: rs.i32): rs.i32 { + return rs.i32Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8(_: (a0: rt.i32, a1: rt.u8) => rt.i32, a: rt.i32, b: rt.u8): rt.i32 { - return rt.i32Shl(a, b); +export function two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8(_: (a0: rs.i32, a1: rs.u8) => rs.i32, a: rs.i32, b: rs.u8): rs.i32 { + return rs.i32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Sub(a, b); +export function two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64(_: (a0: rt.i64, a1: rt.i64) => rt.i64, a: rt.i64, b: rt.i64): rt.i64 { - return rt.i64Mul(a, b); +export function two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64(_: (a0: rs.i64, a1: rs.i64) => rs.i64, a: rs.i64, b: rs.i64): rs.i64 { + return rs.i64Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8(_: (a0: rt.i64, a1: rt.u8) => rt.i64, a: rt.i64, b: rt.u8): rt.i64 { - return rt.i64Shl(a, b); +export function two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8(_: (a0: rs.i64, a1: rs.u8) => rs.i64, a: rs.i64, b: rs.u8): rs.i64 { + return rs.i64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Sub(a, b); +export function two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8(_: (a0: rt.i8, a1: rt.i8) => rt.i8, a: rt.i8, b: rt.i8): rt.i8 { - return rt.i8Mul(a, b); +export function two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8(_: (a0: rs.i8, a1: rs.i8) => rs.i8, a: rs.i8, b: rs.i8): rs.i8 { + return rs.i8Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8(_: (a0: rt.i8, a1: rt.u8) => rt.i8, a: rt.i8, b: rt.u8): rt.i8 { - return rt.i8Shl(a, b); +export function two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8(_: (a0: rs.i8, a1: rs.u8) => rs.i8, a: rs.i8, b: rs.u8): rs.i8 { + return rs.i8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeSub(a, b); +export function two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeSub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize(_: (a0: rt.isize, a1: rt.isize) => rt.isize, a: rt.isize, b: rt.isize): rt.isize { - return rt.isizeMul(a, b); +export function two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize(_: (a0: rs.isize, a1: rs.isize) => rs.isize, a: rs.isize, b: rs.isize): rs.isize { + return rs.isizeMul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8(_: (a0: rt.isize, a1: rt.u8) => rt.isize, a: rt.isize, b: rt.u8): rt.isize { - return rt.isizeShl(a, b); +export function two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8(_: (a0: rs.isize, a1: rs.u8) => rs.isize, a: rs.isize, b: rs.u8): rs.isize { + return rs.isizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Mul(a, b); +export function two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8(_: (a0: rt.u128, a1: rt.u8) => rt.u128, a: rt.u128, b: rt.u8): rt.u128 { - return rt.u128Shl(a, b); +export function two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8(_: (a0: rs.u128, a1: rs.u8) => rs.u128, a: rs.u128, b: rs.u8): rs.u128 { + return rs.u128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Sub(a, b); +export function two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Mul(a, b); +export function two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8(_: (a0: rt.u16, a1: rt.u8) => rt.u16, a: rt.u16, b: rt.u8): rt.u16 { - return rt.u16Shl(a, b); +export function two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8(_: (a0: rs.u16, a1: rs.u8) => rs.u16, a: rs.u16, b: rs.u8): rs.u16 { + return rs.u16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Sub(a, b); +export function two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Mul(a, b); +export function two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8(_: (a0: rt.u32, a1: rt.u8) => rt.u32, a: rt.u32, b: rt.u8): rt.u32 { - return rt.u32Shl(a, b); +export function two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8(_: (a0: rs.u32, a1: rs.u8) => rs.u32, a: rs.u32, b: rs.u8): rs.u32 { + return rs.u32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Sub(a, b); +export function two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Mul(a, b); +export function two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8(_: (a0: rt.u64, a1: rt.u8) => rt.u64, a: rt.u64, b: rt.u8): rt.u64 { - return rt.u64Shl(a, b); +export function two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8(_: (a0: rs.u64, a1: rs.u8) => rs.u64, a: rs.u64, b: rs.u8): rs.u64 { + return rs.u64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Sub(a, b); +export function two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Mul(a, b); +export function two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Shl(a, b); +export function two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Sub(a, b); +export function two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8(_: (a0: rt.usize, a1: rt.u8) => rt.usize, a: rt.usize, b: rt.u8): rt.usize { - return rt.usizeShl(a, b); +export function two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8(_: (a0: rs.usize, a1: rs.u8) => rs.usize, a: rs.usize, b: rs.u8): rs.usize { + return rs.usizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeMul(a, b); +export function two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeMul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeSub(a, b); +export function two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeSub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_i16_u128_ops_Shl_shl_u128_i16(_: (a0: rt.u128, a1: rt.i16) => rt.u128, a: rt.u128, b: rt.i16): rt.u128 { - return rt.u128Shl(a, b); +export function two$u128_i16_u128_ops_Shl_shl_u128_i16(_: (a0: rs.u128, a1: rs.i16) => rs.u128, a: rs.u128, b: rs.i16): rs.u128 { + return rs.u128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Add(a, b); +export function two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Add_add_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Add(a, b); +export function two$u128_u128_u128_ops_Add_add_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_BitAnd_bitand_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128And(a, b); +export function two$u128_u128_u128_ops_BitAnd_bitand_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128And(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_BitOr_bitor_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Or(a, b); +export function two$u128_u128_u128_ops_BitOr_bitor_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Or(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_BitXor_bitxor_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Xor(a, b); +export function two$u128_u128_u128_ops_BitXor_bitxor_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Xor(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Div_div_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Div(a, b); +export function two$u128_u128_u128_ops_Div_div_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Mul_mul_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Mul(a, b); +export function two$u128_u128_u128_ops_Mul_mul_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Rem_rem_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Rem(a, b); +export function two$u128_u128_u128_ops_Rem_rem_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Shr_shr_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Shr(a, b); +export function two$u128_u128_u128_ops_Shr_shr_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u128_u128_ops_Sub_sub_u128_u128(_: (a0: rt.u128, a1: rt.u128) => rt.u128, a: rt.u128, b: rt.u128): rt.u128 { - return rt.u128Sub(a, b); +export function two$u128_u128_u128_ops_Sub_sub_u128_u128(_: (a0: rs.u128, a1: rs.u128) => rs.u128, a: rs.u128, b: rs.u128): rs.u128 { + return rs.u128Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u32_u128_ops_Shl_shl_u128_u32(_: (a0: rt.u128, a1: rt.u32) => rt.u128, a: rt.u128, b: rt.u32): rt.u128 { - return rt.u128Shl(a, b); +export function two$u128_u32_u128_ops_Shl_shl_u128_u32(_: (a0: rs.u128, a1: rs.u32) => rs.u128, a: rs.u128, b: rs.u32): rs.u128 { + return rs.u128Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u128_u32_u128_ops_Shr_shr_u128_u32(_: (a0: rt.u128, a1: rt.u32) => rt.u128, a: rt.u128, b: rt.u32): rt.u128 { - return rt.u128Shr(a, b); +export function two$u128_u32_u128_ops_Shr_shr_u128_u32(_: (a0: rs.u128, a1: rs.u32) => rs.u128, a: rs.u128, b: rs.u32): rs.u128 { + return rs.u128Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_i16_u16_ops_Shl_shl_u16_i16(_: (a0: rt.u16, a1: rt.i16) => rt.u16, a: rt.u16, b: rt.i16): rt.u16 { - return rt.u16Shl(a, b); +export function two$u16_i16_u16_ops_Shl_shl_u16_i16(_: (a0: rs.u16, a1: rs.i16) => rs.u16, a: rs.u16, b: rs.i16): rs.u16 { + return rs.u16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Add(a, b); +export function two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u128_u16_ops_Shr_shr_u16_u128(_: (a0: rt.u16, a1: rt.u128) => rt.u16, a: rt.u16, b: rt.u128): rt.u16 { - return rt.u16Shr(a, b); +export function two$u16_u128_u16_ops_Shr_shr_u16_u128(_: (a0: rs.u16, a1: rs.u128) => rs.u16, a: rs.u16, b: rs.u128): rs.u16 { + return rs.u16Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_Add_add_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Add(a, b); +export function two$u16_u16_u16_ops_Add_add_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_BitAnd_bitand_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { +export function two$u16_u16_u16_ops_BitAnd_bitand_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_BitOr_bitor_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { +export function two$u16_u16_u16_ops_BitOr_bitor_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_BitXor_bitxor_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { +export function two$u16_u16_u16_ops_BitXor_bitxor_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_Div_div_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Div(a, b); +export function two$u16_u16_u16_ops_Div_div_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_Mul_mul_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Mul(a, b); +export function two$u16_u16_u16_ops_Mul_mul_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_Rem_rem_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Rem(a, b); +export function two$u16_u16_u16_ops_Rem_rem_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u16_u16_ops_Sub_sub_u16_u16(_: (a0: rt.u16, a1: rt.u16) => rt.u16, a: rt.u16, b: rt.u16): rt.u16 { - return rt.u16Sub(a, b); +export function two$u16_u16_u16_ops_Sub_sub_u16_u16(_: (a0: rs.u16, a1: rs.u16) => rs.u16, a: rs.u16, b: rs.u16): rs.u16 { + return rs.u16Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u32_u16_ops_Shl_shl_u16_u32(_: (a0: rt.u16, a1: rt.u32) => rt.u16, a: rt.u16, b: rt.u32): rt.u16 { - return rt.u16Shl(a, b); +export function two$u16_u32_u16_ops_Shl_shl_u16_u32(_: (a0: rs.u16, a1: rs.u32) => rs.u16, a: rs.u16, b: rs.u32): rs.u16 { + return rs.u16Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u16_u32_u16_ops_Shr_shr_u16_u32(_: (a0: rt.u16, a1: rt.u32) => rt.u16, a: rt.u16, b: rt.u32): rt.u16 { - return rt.u16Shr(a, b); +export function two$u16_u32_u16_ops_Shr_shr_u16_u32(_: (a0: rs.u16, a1: rs.u32) => rs.u16, a: rs.u16, b: rs.u32): rs.u16 { + return rs.u16Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_i16_u32_ops_Shl_shl_u32_i16(_: (a0: rt.u32, a1: rt.i16) => rt.u32, a: rt.u32, b: rt.i16): rt.u32 { - return rt.u32Shl(a, b); +export function two$u32_i16_u32_ops_Shl_shl_u32_i16(_: (a0: rs.u32, a1: rs.i16) => rs.u32, a: rs.u32, b: rs.i16): rs.u32 { + return rs.u32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Add(a, b); +export function two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u128_u32_ops_Shr_shr_u32_u128(_: (a0: rt.u32, a1: rt.u128) => rt.u32, a: rt.u32, b: rt.u128): rt.u32 { - return rt.u32Shr(a, b); +export function two$u32_u128_u32_ops_Shr_shr_u32_u128(_: (a0: rs.u32, a1: rs.u128) => rs.u32, a: rs.u32, b: rs.u128): rs.u32 { + return rs.u32Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Add_add_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Add(a, b); +export function two$u32_u32_u32_ops_Add_add_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_BitAnd_bitand_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { +export function two$u32_u32_u32_ops_BitAnd_bitand_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { return (a & b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_BitOr_bitor_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { +export function two$u32_u32_u32_ops_BitOr_bitor_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { return (a | b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_BitXor_bitxor_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { +export function two$u32_u32_u32_ops_BitXor_bitxor_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { return (a ^ b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Div_div_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Div(a, b); +export function two$u32_u32_u32_ops_Div_div_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Mul_mul_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Mul(a, b); +export function two$u32_u32_u32_ops_Mul_mul_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Rem_rem_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Rem(a, b); +export function two$u32_u32_u32_ops_Rem_rem_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Shl_shl_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Shl(a, b); +export function two$u32_u32_u32_ops_Shl_shl_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Shr_shr_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Shr(a, b); +export function two$u32_u32_u32_ops_Shr_shr_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u32_u32_u32_ops_Sub_sub_u32_u32(_: (a0: rt.u32, a1: rt.u32) => rt.u32, a: rt.u32, b: rt.u32): rt.u32 { - return rt.u32Sub(a, b); +export function two$u32_u32_u32_ops_Sub_sub_u32_u32(_: (a0: rs.u32, a1: rs.u32) => rs.u32, a: rs.u32, b: rs.u32): rs.u32 { + return rs.u32Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_i16_u64_ops_Shl_shl_u64_i16(_: (a0: rt.u64, a1: rt.i16) => rt.u64, a: rt.u64, b: rt.i16): rt.u64 { - return rt.u64Shl(a, b); +export function two$u64_i16_u64_ops_Shl_shl_u64_i16(_: (a0: rs.u64, a1: rs.i16) => rs.u64, a: rs.u64, b: rs.i16): rs.u64 { + return rs.u64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Add(a, b); +export function two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u128_u64_ops_Shr_shr_u64_u128(_: (a0: rt.u64, a1: rt.u128) => rt.u64, a: rt.u64, b: rt.u128): rt.u64 { - return rt.u64Shr(a, b); +export function two$u64_u128_u64_ops_Shr_shr_u64_u128(_: (a0: rs.u64, a1: rs.u128) => rs.u64, a: rs.u64, b: rs.u128): rs.u64 { + return rs.u64Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u32_u64_ops_Shl_shl_u64_u32(_: (a0: rt.u64, a1: rt.u32) => rt.u64, a: rt.u64, b: rt.u32): rt.u64 { - return rt.u64Shl(a, b); +export function two$u64_u32_u64_ops_Shl_shl_u64_u32(_: (a0: rs.u64, a1: rs.u32) => rs.u64, a: rs.u64, b: rs.u32): rs.u64 { + return rs.u64Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u32_u64_ops_Shr_shr_u64_u32(_: (a0: rt.u64, a1: rt.u32) => rt.u64, a: rt.u64, b: rt.u32): rt.u64 { - return rt.u64Shr(a, b); +export function two$u64_u32_u64_ops_Shr_shr_u64_u32(_: (a0: rs.u64, a1: rs.u32) => rs.u64, a: rs.u64, b: rs.u32): rs.u64 { + return rs.u64Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_Add_add_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Add(a, b); +export function two$u64_u64_u64_ops_Add_add_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_BitAnd_bitand_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64And(a, b); +export function two$u64_u64_u64_ops_BitAnd_bitand_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64And(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_BitOr_bitor_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Or(a, b); +export function two$u64_u64_u64_ops_BitOr_bitor_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Or(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_BitXor_bitxor_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Xor(a, b); +export function two$u64_u64_u64_ops_BitXor_bitxor_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Xor(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_Div_div_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Div(a, b); +export function two$u64_u64_u64_ops_Div_div_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_Mul_mul_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Mul(a, b); +export function two$u64_u64_u64_ops_Mul_mul_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_Rem_rem_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Rem(a, b); +export function two$u64_u64_u64_ops_Rem_rem_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u64_u64_u64_ops_Sub_sub_u64_u64(_: (a0: rt.u64, a1: rt.u64) => rt.u64, a: rt.u64, b: rt.u64): rt.u64 { - return rt.u64Sub(a, b); +export function two$u64_u64_u64_ops_Sub_sub_u64_u64(_: (a0: rs.u64, a1: rs.u64) => rs.u64, a: rs.u64, b: rs.u64): rs.u64 { + return rs.u64Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_i16_u8_ops_Shl_shl_u8_i16(_: (a0: rt.u8, a1: rt.i16) => rt.u8, a: rt.u8, b: rt.i16): rt.u8 { - return rt.u8Shl(a, b); +export function two$u8_i16_u8_ops_Shl_shl_u8_i16(_: (a0: rs.u8, a1: rs.i16) => rs.u8, a: rs.u8, b: rs.i16): rs.u8 { + return rs.u8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Add(a, b); +export function two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u128_u8_ops_Shr_shr_u8_u128(_: (a0: rt.u8, a1: rt.u128) => rt.u8, a: rt.u8, b: rt.u128): rt.u8 { - return rt.u8Shr(a, b); +export function two$u8_u128_u8_ops_Shr_shr_u8_u128(_: (a0: rs.u8, a1: rs.u128) => rs.u8, a: rs.u8, b: rs.u128): rs.u8 { + return rs.u8Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u32_u8_ops_Shl_shl_u8_u32(_: (a0: rt.u8, a1: rt.u32) => rt.u8, a: rt.u8, b: rt.u32): rt.u8 { - return rt.u8Shl(a, b); +export function two$u8_u32_u8_ops_Shl_shl_u8_u32(_: (a0: rs.u8, a1: rs.u32) => rs.u8, a: rs.u8, b: rs.u32): rs.u8 { + return rs.u8Shl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u32_u8_ops_Shr_shr_u8_u32(_: (a0: rt.u8, a1: rt.u32) => rt.u8, a: rt.u8, b: rt.u32): rt.u8 { - return rt.u8Shr(a, b); +export function two$u8_u32_u8_ops_Shr_shr_u8_u32(_: (a0: rs.u8, a1: rs.u32) => rs.u8, a: rs.u8, b: rs.u32): rs.u8 { + return rs.u8Shr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_Add_add_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Add(a, b); +export function two$u8_u8_u8_ops_Add_add_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Add(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_BitAnd_bitand_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { +export function two$u8_u8_u8_ops_BitAnd_bitand_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { return a & b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_BitOr_bitor_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { +export function two$u8_u8_u8_ops_BitOr_bitor_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { return a | b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_BitXor_bitxor_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { +export function two$u8_u8_u8_ops_BitXor_bitxor_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { return a ^ b; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_Div_div_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Div(a, b); +export function two$u8_u8_u8_ops_Div_div_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Div(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_Mul_mul_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Mul(a, b); +export function two$u8_u8_u8_ops_Mul_mul_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Mul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_Rem_rem_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Rem(a, b); +export function two$u8_u8_u8_ops_Rem_rem_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Rem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$u8_u8_u8_ops_Sub_sub_u8_u8(_: (a0: rt.u8, a1: rt.u8) => rt.u8, a: rt.u8, b: rt.u8): rt.u8 { - return rt.u8Sub(a, b); +export function two$u8_u8_u8_ops_Sub_sub_u8_u8(_: (a0: rs.u8, a1: rs.u8) => rs.u8, a: rs.u8, b: rs.u8): rs.u8 { + return rs.u8Sub(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_i16_usize_ops_Shl_shl_usize_i16(_: (a0: rt.usize, a1: rt.i16) => rt.usize, a: rt.usize, b: rt.i16): rt.usize { - return rt.usizeShl(a, b); +export function two$usize_i16_usize_ops_Shl_shl_usize_i16(_: (a0: rs.usize, a1: rs.i16) => rs.usize, a: rs.usize, b: rs.i16): rs.usize { + return rs.usizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeAdd(a, b); +export function two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeAdd(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_u128_usize_ops_Shr_shr_usize_u128(_: (a0: rt.usize, a1: rt.u128) => rt.usize, a: rt.usize, b: rt.u128): rt.usize { - return rt.usizeShr(a, b); +export function two$usize_u128_usize_ops_Shr_shr_usize_u128(_: (a0: rs.usize, a1: rs.u128) => rs.usize, a: rs.usize, b: rs.u128): rs.usize { + return rs.usizeShr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_u32_usize_ops_Shl_shl_usize_u32(_: (a0: rt.usize, a1: rt.u32) => rt.usize, a: rt.usize, b: rt.u32): rt.usize { - return rt.usizeShl(a, b); +export function two$usize_u32_usize_ops_Shl_shl_usize_u32(_: (a0: rs.usize, a1: rs.u32) => rs.usize, a: rs.usize, b: rs.u32): rs.usize { + return rs.usizeShl(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_u32_usize_ops_Shr_shr_usize_u32(_: (a0: rt.usize, a1: rt.u32) => rt.usize, a: rt.usize, b: rt.u32): rt.usize { - return rt.usizeShr(a, b); +export function two$usize_u32_usize_ops_Shr_shr_usize_u32(_: (a0: rs.usize, a1: rs.u32) => rs.usize, a: rs.usize, b: rs.u32): rs.usize { + return rs.usizeShr(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_Add_add_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeAdd(a, b); +export function two$usize_usize_usize_ops_Add_add_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeAdd(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_BitAnd_bitand_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { +export function two$usize_usize_usize_ops_BitAnd_bitand_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { return (a & b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_BitOr_bitor_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { +export function two$usize_usize_usize_ops_BitOr_bitor_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { return (a | b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_BitXor_bitxor_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { +export function two$usize_usize_usize_ops_BitXor_bitxor_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { return (a ^ b) >>> 0; } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_Div_div_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeDiv(a, b); +export function two$usize_usize_usize_ops_Div_div_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeDiv(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_Mul_mul_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeMul(a, b); +export function two$usize_usize_usize_ops_Mul_mul_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeMul(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_Rem_rem_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeRem(a, b); +export function two$usize_usize_usize_ops_Rem_rem_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeRem(a, b); } /** `f(a, b)`, as a generic body calls a function value. */ -export function two$usize_usize_usize_ops_Sub_sub_usize_usize(_: (a0: rt.usize, a1: rt.usize) => rt.usize, a: rt.usize, b: rt.usize): rt.usize { - return rt.usizeSub(a, b); +export function two$usize_usize_usize_ops_Sub_sub_usize_usize(_: (a0: rs.usize, a1: rs.usize) => rs.usize, a: rs.usize, b: rs.usize): rs.usize { + return rs.usizeSub(a, b); } /** * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.u8; - const _28: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v3: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); +export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.u8; + const _28: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v3: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); }; - const take: (a0: rt.usize) => rt.u8 = (at: rt.usize): rt.u8 => { + const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.u8FromBeBytes(buf); + return rs.u8FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.u8, rt.u8] = [take(1), take(1 + 1)]; - const a: rt.u8 = _10[0]; - const b: rt.u8 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 1), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.u8, rs.u8] = [take(1), take(1 + 1)]; + const a: rs.u8 = _10[0]; + const b: rs.u8 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 1), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.u8Add(a, b); + v = rs.u8Add(a, b); } else if (_32 === 1) { - v = two$u8_u8_u8_ops_Add_add_u8_u8((a062: rt.u8, a158: rt.u8): rt.u8 => { - return rt.u8Add(a062, a158); + v = two$u8_u8_u8_ops_Add_add_u8_u8((a062: rs.u8, a158: rs.u8): rs.u8 => { + return rs.u8Add(a062, a158); }, a, b); } else { - v = ((a061: rt.u8, a157: rt.u8): rt.u8 => { - return rt.u8Add(a061, a157); + v = ((a061: rs.u8, a157: rs.u8): rs.u8 => { + return rs.u8Add(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.u8Sub(a, b); + v = rs.u8Sub(a, b); } else if (_35 === 1) { - v = two$u8_u8_u8_ops_Sub_sub_u8_u8((a060: rt.u8, a156: rt.u8): rt.u8 => { - return rt.u8Sub(a060, a156); + v = two$u8_u8_u8_ops_Sub_sub_u8_u8((a060: rs.u8, a156: rs.u8): rs.u8 => { + return rs.u8Sub(a060, a156); }, a, b); } else { - v = ((a059: rt.u8, a155: rt.u8): rt.u8 => { - return rt.u8Sub(a059, a155); + v = ((a059: rs.u8, a155: rs.u8): rs.u8 => { + return rs.u8Sub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.u8Mul(a, b); + v = rs.u8Mul(a, b); } else if (_38 === 1) { - v = two$u8_u8_u8_ops_Mul_mul_u8_u8((a058: rt.u8, a154: rt.u8): rt.u8 => { - return rt.u8Mul(a058, a154); + v = two$u8_u8_u8_ops_Mul_mul_u8_u8((a058: rs.u8, a154: rs.u8): rs.u8 => { + return rs.u8Mul(a058, a154); }, a, b); } else { - v = ((a057: rt.u8, a153: rt.u8): rt.u8 => { - return rt.u8Mul(a057, a153); + v = ((a057: rs.u8, a153: rs.u8): rs.u8 => { + return rs.u8Mul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.u8Div(a, b); + v = rs.u8Div(a, b); } else if (_41 === 1) { - v = two$u8_u8_u8_ops_Div_div_u8_u8((a056: rt.u8, a152: rt.u8): rt.u8 => { - return rt.u8Div(a056, a152); + v = two$u8_u8_u8_ops_Div_div_u8_u8((a056: rs.u8, a152: rs.u8): rs.u8 => { + return rs.u8Div(a056, a152); }, a, b); } else { - v = ((a055: rt.u8, a151: rt.u8): rt.u8 => { - return rt.u8Div(a055, a151); + v = ((a055: rs.u8, a151: rs.u8): rs.u8 => { + return rs.u8Div(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.u8Rem(a, b); + v = rs.u8Rem(a, b); } else if (_44 === 1) { - v = two$u8_u8_u8_ops_Rem_rem_u8_u8((a054: rt.u8, a150: rt.u8): rt.u8 => { - return rt.u8Rem(a054, a150); + v = two$u8_u8_u8_ops_Rem_rem_u8_u8((a054: rs.u8, a150: rs.u8): rs.u8 => { + return rs.u8Rem(a054, a150); }, a, b); } else { - v = ((a053: rt.u8, a149: rt.u8): rt.u8 => { - return rt.u8Rem(a053, a149); + v = ((a053: rs.u8, a149: rs.u8): rs.u8 => { + return rs.u8Rem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$u8_u8_u8_ops_BitAnd_bitand_u8_u8((a052: rt.u8, a148: rt.u8): rt.u8 => { + v = two$u8_u8_u8_ops_BitAnd_bitand_u8_u8((a052: rs.u8, a148: rs.u8): rs.u8 => { return a052 & a148; }, a, b); } else { - v = ((a051: rt.u8, a147: rt.u8): rt.u8 => { + v = ((a051: rs.u8, a147: rs.u8): rs.u8 => { return a051 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$u8_u8_u8_ops_BitOr_bitor_u8_u8((a050: rt.u8, a146: rt.u8): rt.u8 => { + v = two$u8_u8_u8_ops_BitOr_bitor_u8_u8((a050: rs.u8, a146: rs.u8): rs.u8 => { return a050 | a146; }, a, b); } else { - v = ((a049: rt.u8, a145: rt.u8): rt.u8 => { + v = ((a049: rs.u8, a145: rs.u8): rs.u8 => { return a049 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$u8_u8_u8_ops_BitXor_bitxor_u8_u8((a048: rt.u8, a144: rt.u8): rt.u8 => { + v = two$u8_u8_u8_ops_BitXor_bitxor_u8_u8((a048: rs.u8, a144: rs.u8): rs.u8 => { return a048 ^ a144; }, a, b); } else { - v = ((a047: rt.u8, a143: rt.u8): rt.u8 => { + v = ((a047: rs.u8, a143: rs.u8): rs.u8 => { return a047 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.u8Shl(a, n); + v = rs.u8Shl(a, n); } else if (_56 === 1) { - v = two$u8_u32_u8_ops_Shl_shl_u8_u32((a046: rt.u8, a142: rt.u32): rt.u8 => { - return rt.u8Shl(a046, a142); + v = two$u8_u32_u8_ops_Shl_shl_u8_u32((a046: rs.u8, a142: rs.u32): rs.u8 => { + return rs.u8Shl(a046, a142); }, a, n); } else { - v = ((a045: rt.u8, a141: rt.u32): rt.u8 => { - return rt.u8Shl(a045, a141); + v = ((a045: rs.u8, a141: rs.u32): rs.u8 => { + return rs.u8Shl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.u8Shr(a, n); + v = rs.u8Shr(a, n); } else if (_59 === 1) { - v = two$u8_u32_u8_ops_Shr_shr_u8_u32((a044: rt.u8, a140: rt.u32): rt.u8 => { - return rt.u8Shr(a044, a140); + v = two$u8_u32_u8_ops_Shr_shr_u8_u32((a044: rs.u8, a140: rs.u32): rs.u8 => { + return rs.u8Shr(a044, a140); }, a, n); } else { - v = ((a043: rt.u8, a139: rt.u32): rt.u8 => { - return rt.u8Shr(a043, a139); + v = ((a043: rs.u8, a139: rs.u32): rs.u8 => { + return rs.u8Shr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.u8Shl(a, (n << 16) >> 16); + v = rs.u8Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$u8_i16_u8_ops_Shl_shl_u8_i16((a042: rt.u8, a138: rt.i16): rt.u8 => { - return rt.u8Shl(a042, a138); + v = two$u8_i16_u8_ops_Shl_shl_u8_i16((a042: rs.u8, a138: rs.i16): rs.u8 => { + return rs.u8Shl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.u8, a137: rt.i16): rt.u8 => { - return rt.u8Shl(a041, a137); + v = ((a041: rs.u8, a137: rs.i16): rs.u8 => { + return rs.u8Shl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.u8Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.u8Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$u8_u128_u8_ops_Shr_shr_u8_u128((a040: rt.u8, a136: rt.u128): rt.u8 => { - return rt.u8Shr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$u8_u128_u8_ops_Shr_shr_u8_u128((a040: rs.u8, a136: rs.u128): rs.u8 => { + return rs.u8Shr(a040, a136); }, a, _74); } else { - v = ((a039: rt.u8, a135: rt.u128): rt.u8 => { - return rt.u8Shr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.u8, a135: rs.u128): rs.u8 => { + return rs.u8Shr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a & 0xff; } else if (_83 === 1) { - v = one$u8_u8_ops_Not_not_u8((a038: rt.u8): rt.u8 => { + v = one$u8_u8_ops_Not_not_u8((a038: rs.u8): rs.u8 => { return ~a038 & 0xff; }, a); } else { - v = ((a037: rt.u8): rt.u8 => { + v = ((a037: rs.u8): rs.u8 => { return ~a037 & 0xff; })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.u8 | undefined; + const _86 = undefined as rs.u8 | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.u8 = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.u8 = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.u8Add(x, b); + x = rs.u8Add(x, b); } else if (_91 === 1) { - two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8((a036: rt.Place, a134: rt.u8): undefined => { - a036.v = rt.u8Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_u8_u8_unit_ops_AddAssign_add_assign_u8_u8((a036: rs.Place, a134: rs.u8): undefined => { + a036.v = rs.u8Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.u8): undefined => { - a035.v = rt.u8Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.u8): undefined => { + a035.v = rs.u8Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.u8 = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.u8 = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.u8Sub(x2, b); + x2 = rs.u8Sub(x2, b); } else if (_99 === 1) { - two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8((a034: rt.Place, a132: rt.u8): undefined => { - a034.v = rt.u8Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_u8_u8_unit_ops_SubAssign_sub_assign_u8_u8((a034: rs.Place, a132: rs.u8): undefined => { + a034.v = rs.u8Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.u8): undefined => { - a033.v = rt.u8Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.u8): undefined => { + a033.v = rs.u8Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.u8 = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.u8 = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.u8Mul(x3, b); + x3 = rs.u8Mul(x3, b); } else if (_107 === 1) { - two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8((a032: rt.Place, a130: rt.u8): undefined => { - a032.v = rt.u8Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_u8_u8_unit_ops_MulAssign_mul_assign_u8_u8((a032: rs.Place, a130: rs.u8): undefined => { + a032.v = rs.u8Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.u8): undefined => { - a031.v = rt.u8Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.u8): undefined => { + a031.v = rs.u8Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.u8 = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.u8 = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.u8Div(x4, b); + x4 = rs.u8Div(x4, b); } else if (_115 === 1) { - two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8((a030: rt.Place, a128: rt.u8): undefined => { - a030.v = rt.u8Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_u8_u8_unit_ops_DivAssign_div_assign_u8_u8((a030: rs.Place, a128: rs.u8): undefined => { + a030.v = rs.u8Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.u8): undefined => { - a029.v = rt.u8Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.u8): undefined => { + a029.v = rs.u8Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.u8 = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.u8 = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.u8Rem(x5, b); + x5 = rs.u8Rem(x5, b); } else if (_123 === 1) { - two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8((a028: rt.Place, a126: rt.u8): undefined => { - a028.v = rt.u8Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_u8_u8_unit_ops_RemAssign_rem_assign_u8_u8((a028: rs.Place, a126: rs.u8): undefined => { + a028.v = rs.u8Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.u8): undefined => { - a027.v = rt.u8Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.u8): undefined => { + a027.v = rs.u8Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.u8 = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.u8 = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { x6 = x6 & b; } else if (_131 === 1) { - two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8((a026: rt.Place, a124: rt.u8): undefined => { + two$mut_u8_u8_unit_ops_BitAndAssign_bitand_assign_u8_u8((a026: rs.Place, a124: rs.u8): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.u8): undefined => { + ((a025: rs.Place, a123: rs.u8): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.u8 = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.u8 = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { x7 = x7 | b; } else if (_139 === 1) { - two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8((a024: rt.Place, a122: rt.u8): undefined => { + two$mut_u8_u8_unit_ops_BitOrAssign_bitor_assign_u8_u8((a024: rs.Place, a122: rs.u8): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.u8): undefined => { + ((a023: rs.Place, a121: rs.u8): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.u8 = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.u8 = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { x8 = x8 ^ b; } else if (_147 === 1) { - two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8((a022: rt.Place, a120: rt.u8): undefined => { + two$mut_u8_u8_unit_ops_BitXorAssign_bitxor_assign_u8_u8((a022: rs.Place, a120: rs.u8): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.u8): undefined => { + ((a021: rs.Place, a119: rs.u8): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.u8 = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.u8 = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.u8Shl(x9, n); + x9 = rs.u8Shl(x9, n); } else if (_155 === 1) { - two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.u8Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_u8_u32_unit_ops_ShlAssign_shl_assign_u8_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.u8Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.u8Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.u8Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.u8 = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.u8 = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.u8Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.u8Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.u8Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_u8_i64_unit_ops_ShrAssign_shr_assign_u8_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.u8Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.u8Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.u8Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.u8Add(a, b); + v = rs.u8Add(a, b); } else if (_175 === 1) { - v = two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8((a016: rt.u8, a114: rt.u8): rt.u8 => { - return rt.u8Add(a016, a114); + v = two$u8_ref_u8_u8_ops_Add_add_u8_ref_u8((a016: rs.u8, a114: rs.u8): rs.u8 => { + return rs.u8Add(a016, a114); }, a, b); } else { - v = ((a015: rt.u8, a113: rt.u8): rt.u8 => { - return rt.u8Add(a015, a113); + v = ((a015: rs.u8, a113: rs.u8): rs.u8 => { + return rs.u8Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.u8Sub(a, b); + v = rs.u8Sub(a, b); } else if (_181 === 1) { - v = two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8((a014: rt.u8, a112: rt.u8): rt.u8 => { - return rt.u8Sub(a014, a112); + v = two$ref_u8_u8_u8_ops_Sub_sub_ref_u8_u8((a014: rs.u8, a112: rs.u8): rs.u8 => { + return rs.u8Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.u8, a111: rt.u8): rt.u8 => { - return rt.u8Sub(a013, a111); + v = ((a013: rs.u8, a111: rs.u8): rs.u8 => { + return rs.u8Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.u8Mul(a, b); + v = rs.u8Mul(a, b); } else if (_187 === 1) { - v = two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8((a012: rt.u8, a110: rt.u8): rt.u8 => { - return rt.u8Mul(a012, a110); + v = two$ref_u8_ref_u8_u8_ops_Mul_mul_ref_u8_ref_u8((a012: rs.u8, a110: rs.u8): rs.u8 => { + return rs.u8Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.u8, a19: rt.u8): rt.u8 => { - return rt.u8Mul(a011, a19); + v = ((a011: rs.u8, a19: rs.u8): rs.u8 => { + return rs.u8Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.u8Shl(a, n & 0xff); + v = rs.u8Shl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8((a010: rt.u8, a18: rt.u8): rt.u8 => { - return rt.u8Shl(a010, a18); + v = two$ref_u8_ref_u8_u8_ops_Shl_shl_ref_u8_ref_u8((a010: rs.u8, a18: rs.u8): rs.u8 => { + return rs.u8Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.u8, a17: rt.u8): rt.u8 => { - return rt.u8Shl(a09, a17); + v = ((a09: rs.u8, a17: rs.u8): rs.u8 => { + return rs.u8Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { v = ~a & 0xff; } else if (_208 === 1) { - v = one$ref_u8_u8_ops_Not_not_ref_u8((a08: rt.u8): rt.u8 => { + v = one$ref_u8_u8_ops_Not_not_ref_u8((a08: rs.u8): rs.u8 => { return ~a08 & 0xff; }, a); } else { - v = ((a07: rt.u8): rt.u8 => { + v = ((a07: rs.u8): rs.u8 => { return ~a07 & 0xff; })(a); } } else if (_30 === 29) { - let x11: rt.u8 = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.u8 = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.u8Add(x11, b); + x11 = rs.u8Add(x11, b); } else if (_216 === 1) { - two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8((a06: rt.Place, a16: rt.u8): undefined => { - a06.v = rt.u8Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_u8_ref_u8_unit_ops_AddAssign_add_assign_u8_ref_u8((a06: rs.Place, a16: rs.u8): undefined => { + a06.v = rs.u8Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.u8): undefined => { - a05.v = rt.u8Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.u8): undefined => { + a05.v = rs.u8Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.u8 = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.u8 = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.u8Div(x12, b); + x12 = rs.u8Div(x12, b); } else if (_227 === 1) { - two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8((a04: rt.Place, a14: rt.u8): undefined => { - a04.v = rt.u8Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_u8_ref_u8_unit_ops_DivAssign_div_assign_u8_ref_u8((a04: rs.Place, a14: rs.u8): undefined => { + a04.v = rs.u8Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.u8): undefined => { - a03.v = rt.u8Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.u8): undefined => { + a03.v = rs.u8Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.u8 = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.u8 = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.u8Shr(x13, n & 0xffff); + x13 = rs.u8Shr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.u8Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_u8_ref_u16_unit_ops_ShrAssign_shr_assign_u8_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.u8Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u8Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u8Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -2957,467 +2957,467 @@ export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.u16; - const _28: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v3: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); +export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.u16; + const _28: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v3: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); }; - const take: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { - const buf: Uint8Array = rt.bytes(2); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { + const buf: Uint8Array = rs.bytes(2); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.u16FromBeBytes(buf); + return rs.u16FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.u16, rt.u16] = [take(1), take(1 + 2)]; - const a: rt.u16 = _10[0]; - const b: rt.u16 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 2), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.u16, rs.u16] = [take(1), take(1 + 2)]; + const a: rs.u16 = _10[0]; + const b: rs.u16 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 2), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.u16Add(a, b); + v = rs.u16Add(a, b); } else if (_32 === 1) { - v = two$u16_u16_u16_ops_Add_add_u16_u16((a062: rt.u16, a158: rt.u16): rt.u16 => { - return rt.u16Add(a062, a158); + v = two$u16_u16_u16_ops_Add_add_u16_u16((a062: rs.u16, a158: rs.u16): rs.u16 => { + return rs.u16Add(a062, a158); }, a, b); } else { - v = ((a061: rt.u16, a157: rt.u16): rt.u16 => { - return rt.u16Add(a061, a157); + v = ((a061: rs.u16, a157: rs.u16): rs.u16 => { + return rs.u16Add(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.u16Sub(a, b); + v = rs.u16Sub(a, b); } else if (_35 === 1) { - v = two$u16_u16_u16_ops_Sub_sub_u16_u16((a060: rt.u16, a156: rt.u16): rt.u16 => { - return rt.u16Sub(a060, a156); + v = two$u16_u16_u16_ops_Sub_sub_u16_u16((a060: rs.u16, a156: rs.u16): rs.u16 => { + return rs.u16Sub(a060, a156); }, a, b); } else { - v = ((a059: rt.u16, a155: rt.u16): rt.u16 => { - return rt.u16Sub(a059, a155); + v = ((a059: rs.u16, a155: rs.u16): rs.u16 => { + return rs.u16Sub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.u16Mul(a, b); + v = rs.u16Mul(a, b); } else if (_38 === 1) { - v = two$u16_u16_u16_ops_Mul_mul_u16_u16((a058: rt.u16, a154: rt.u16): rt.u16 => { - return rt.u16Mul(a058, a154); + v = two$u16_u16_u16_ops_Mul_mul_u16_u16((a058: rs.u16, a154: rs.u16): rs.u16 => { + return rs.u16Mul(a058, a154); }, a, b); } else { - v = ((a057: rt.u16, a153: rt.u16): rt.u16 => { - return rt.u16Mul(a057, a153); + v = ((a057: rs.u16, a153: rs.u16): rs.u16 => { + return rs.u16Mul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.u16Div(a, b); + v = rs.u16Div(a, b); } else if (_41 === 1) { - v = two$u16_u16_u16_ops_Div_div_u16_u16((a056: rt.u16, a152: rt.u16): rt.u16 => { - return rt.u16Div(a056, a152); + v = two$u16_u16_u16_ops_Div_div_u16_u16((a056: rs.u16, a152: rs.u16): rs.u16 => { + return rs.u16Div(a056, a152); }, a, b); } else { - v = ((a055: rt.u16, a151: rt.u16): rt.u16 => { - return rt.u16Div(a055, a151); + v = ((a055: rs.u16, a151: rs.u16): rs.u16 => { + return rs.u16Div(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.u16Rem(a, b); + v = rs.u16Rem(a, b); } else if (_44 === 1) { - v = two$u16_u16_u16_ops_Rem_rem_u16_u16((a054: rt.u16, a150: rt.u16): rt.u16 => { - return rt.u16Rem(a054, a150); + v = two$u16_u16_u16_ops_Rem_rem_u16_u16((a054: rs.u16, a150: rs.u16): rs.u16 => { + return rs.u16Rem(a054, a150); }, a, b); } else { - v = ((a053: rt.u16, a149: rt.u16): rt.u16 => { - return rt.u16Rem(a053, a149); + v = ((a053: rs.u16, a149: rs.u16): rs.u16 => { + return rs.u16Rem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$u16_u16_u16_ops_BitAnd_bitand_u16_u16((a052: rt.u16, a148: rt.u16): rt.u16 => { + v = two$u16_u16_u16_ops_BitAnd_bitand_u16_u16((a052: rs.u16, a148: rs.u16): rs.u16 => { return a052 & a148; }, a, b); } else { - v = ((a051: rt.u16, a147: rt.u16): rt.u16 => { + v = ((a051: rs.u16, a147: rs.u16): rs.u16 => { return a051 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$u16_u16_u16_ops_BitOr_bitor_u16_u16((a050: rt.u16, a146: rt.u16): rt.u16 => { + v = two$u16_u16_u16_ops_BitOr_bitor_u16_u16((a050: rs.u16, a146: rs.u16): rs.u16 => { return a050 | a146; }, a, b); } else { - v = ((a049: rt.u16, a145: rt.u16): rt.u16 => { + v = ((a049: rs.u16, a145: rs.u16): rs.u16 => { return a049 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$u16_u16_u16_ops_BitXor_bitxor_u16_u16((a048: rt.u16, a144: rt.u16): rt.u16 => { + v = two$u16_u16_u16_ops_BitXor_bitxor_u16_u16((a048: rs.u16, a144: rs.u16): rs.u16 => { return a048 ^ a144; }, a, b); } else { - v = ((a047: rt.u16, a143: rt.u16): rt.u16 => { + v = ((a047: rs.u16, a143: rs.u16): rs.u16 => { return a047 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.u16Shl(a, n); + v = rs.u16Shl(a, n); } else if (_56 === 1) { - v = two$u16_u32_u16_ops_Shl_shl_u16_u32((a046: rt.u16, a142: rt.u32): rt.u16 => { - return rt.u16Shl(a046, a142); + v = two$u16_u32_u16_ops_Shl_shl_u16_u32((a046: rs.u16, a142: rs.u32): rs.u16 => { + return rs.u16Shl(a046, a142); }, a, n); } else { - v = ((a045: rt.u16, a141: rt.u32): rt.u16 => { - return rt.u16Shl(a045, a141); + v = ((a045: rs.u16, a141: rs.u32): rs.u16 => { + return rs.u16Shl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.u16Shr(a, n); + v = rs.u16Shr(a, n); } else if (_59 === 1) { - v = two$u16_u32_u16_ops_Shr_shr_u16_u32((a044: rt.u16, a140: rt.u32): rt.u16 => { - return rt.u16Shr(a044, a140); + v = two$u16_u32_u16_ops_Shr_shr_u16_u32((a044: rs.u16, a140: rs.u32): rs.u16 => { + return rs.u16Shr(a044, a140); }, a, n); } else { - v = ((a043: rt.u16, a139: rt.u32): rt.u16 => { - return rt.u16Shr(a043, a139); + v = ((a043: rs.u16, a139: rs.u32): rs.u16 => { + return rs.u16Shr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.u16Shl(a, (n << 16) >> 16); + v = rs.u16Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$u16_i16_u16_ops_Shl_shl_u16_i16((a042: rt.u16, a138: rt.i16): rt.u16 => { - return rt.u16Shl(a042, a138); + v = two$u16_i16_u16_ops_Shl_shl_u16_i16((a042: rs.u16, a138: rs.i16): rs.u16 => { + return rs.u16Shl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.u16, a137: rt.i16): rt.u16 => { - return rt.u16Shl(a041, a137); + v = ((a041: rs.u16, a137: rs.i16): rs.u16 => { + return rs.u16Shl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.u16Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.u16Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$u16_u128_u16_ops_Shr_shr_u16_u128((a040: rt.u16, a136: rt.u128): rt.u16 => { - return rt.u16Shr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$u16_u128_u16_ops_Shr_shr_u16_u128((a040: rs.u16, a136: rs.u128): rs.u16 => { + return rs.u16Shr(a040, a136); }, a, _74); } else { - v = ((a039: rt.u16, a135: rt.u128): rt.u16 => { - return rt.u16Shr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.u16, a135: rs.u128): rs.u16 => { + return rs.u16Shr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a & 0xffff; } else if (_83 === 1) { - v = one$u16_u16_ops_Not_not_u16((a038: rt.u16): rt.u16 => { + v = one$u16_u16_ops_Not_not_u16((a038: rs.u16): rs.u16 => { return ~a038 & 0xffff; }, a); } else { - v = ((a037: rt.u16): rt.u16 => { + v = ((a037: rs.u16): rs.u16 => { return ~a037 & 0xffff; })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.u16 | undefined; + const _86 = undefined as rs.u16 | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.u16 = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.u16 = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.u16Add(x, b); + x = rs.u16Add(x, b); } else if (_91 === 1) { - two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16((a036: rt.Place, a134: rt.u16): undefined => { - a036.v = rt.u16Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_u16_u16_unit_ops_AddAssign_add_assign_u16_u16((a036: rs.Place, a134: rs.u16): undefined => { + a036.v = rs.u16Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.u16): undefined => { - a035.v = rt.u16Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.u16): undefined => { + a035.v = rs.u16Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.u16 = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.u16 = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.u16Sub(x2, b); + x2 = rs.u16Sub(x2, b); } else if (_99 === 1) { - two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16((a034: rt.Place, a132: rt.u16): undefined => { - a034.v = rt.u16Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_u16_u16_unit_ops_SubAssign_sub_assign_u16_u16((a034: rs.Place, a132: rs.u16): undefined => { + a034.v = rs.u16Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.u16): undefined => { - a033.v = rt.u16Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.u16): undefined => { + a033.v = rs.u16Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.u16 = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.u16 = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.u16Mul(x3, b); + x3 = rs.u16Mul(x3, b); } else if (_107 === 1) { - two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16((a032: rt.Place, a130: rt.u16): undefined => { - a032.v = rt.u16Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_u16_u16_unit_ops_MulAssign_mul_assign_u16_u16((a032: rs.Place, a130: rs.u16): undefined => { + a032.v = rs.u16Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.u16): undefined => { - a031.v = rt.u16Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.u16): undefined => { + a031.v = rs.u16Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.u16 = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.u16 = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.u16Div(x4, b); + x4 = rs.u16Div(x4, b); } else if (_115 === 1) { - two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16((a030: rt.Place, a128: rt.u16): undefined => { - a030.v = rt.u16Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_u16_u16_unit_ops_DivAssign_div_assign_u16_u16((a030: rs.Place, a128: rs.u16): undefined => { + a030.v = rs.u16Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.u16): undefined => { - a029.v = rt.u16Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.u16): undefined => { + a029.v = rs.u16Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.u16 = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.u16 = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.u16Rem(x5, b); + x5 = rs.u16Rem(x5, b); } else if (_123 === 1) { - two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16((a028: rt.Place, a126: rt.u16): undefined => { - a028.v = rt.u16Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_u16_u16_unit_ops_RemAssign_rem_assign_u16_u16((a028: rs.Place, a126: rs.u16): undefined => { + a028.v = rs.u16Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.u16): undefined => { - a027.v = rt.u16Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.u16): undefined => { + a027.v = rs.u16Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.u16 = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.u16 = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { x6 = x6 & b; } else if (_131 === 1) { - two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16((a026: rt.Place, a124: rt.u16): undefined => { + two$mut_u16_u16_unit_ops_BitAndAssign_bitand_assign_u16_u16((a026: rs.Place, a124: rs.u16): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.u16): undefined => { + ((a025: rs.Place, a123: rs.u16): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.u16 = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.u16 = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { x7 = x7 | b; } else if (_139 === 1) { - two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16((a024: rt.Place, a122: rt.u16): undefined => { + two$mut_u16_u16_unit_ops_BitOrAssign_bitor_assign_u16_u16((a024: rs.Place, a122: rs.u16): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.u16): undefined => { + ((a023: rs.Place, a121: rs.u16): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.u16 = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.u16 = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { x8 = x8 ^ b; } else if (_147 === 1) { - two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16((a022: rt.Place, a120: rt.u16): undefined => { + two$mut_u16_u16_unit_ops_BitXorAssign_bitxor_assign_u16_u16((a022: rs.Place, a120: rs.u16): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.u16): undefined => { + ((a021: rs.Place, a119: rs.u16): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.u16 = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.u16 = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.u16Shl(x9, n); + x9 = rs.u16Shl(x9, n); } else if (_155 === 1) { - two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.u16Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_u16_u32_unit_ops_ShlAssign_shl_assign_u16_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.u16Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.u16Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.u16Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.u16 = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.u16 = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.u16Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.u16Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.u16Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_u16_i64_unit_ops_ShrAssign_shr_assign_u16_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.u16Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.u16Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.u16Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.u16Add(a, b); + v = rs.u16Add(a, b); } else if (_175 === 1) { - v = two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16((a016: rt.u16, a114: rt.u16): rt.u16 => { - return rt.u16Add(a016, a114); + v = two$u16_ref_u16_u16_ops_Add_add_u16_ref_u16((a016: rs.u16, a114: rs.u16): rs.u16 => { + return rs.u16Add(a016, a114); }, a, b); } else { - v = ((a015: rt.u16, a113: rt.u16): rt.u16 => { - return rt.u16Add(a015, a113); + v = ((a015: rs.u16, a113: rs.u16): rs.u16 => { + return rs.u16Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.u16Sub(a, b); + v = rs.u16Sub(a, b); } else if (_181 === 1) { - v = two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16((a014: rt.u16, a112: rt.u16): rt.u16 => { - return rt.u16Sub(a014, a112); + v = two$ref_u16_u16_u16_ops_Sub_sub_ref_u16_u16((a014: rs.u16, a112: rs.u16): rs.u16 => { + return rs.u16Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.u16, a111: rt.u16): rt.u16 => { - return rt.u16Sub(a013, a111); + v = ((a013: rs.u16, a111: rs.u16): rs.u16 => { + return rs.u16Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.u16Mul(a, b); + v = rs.u16Mul(a, b); } else if (_187 === 1) { - v = two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16((a012: rt.u16, a110: rt.u16): rt.u16 => { - return rt.u16Mul(a012, a110); + v = two$ref_u16_ref_u16_u16_ops_Mul_mul_ref_u16_ref_u16((a012: rs.u16, a110: rs.u16): rs.u16 => { + return rs.u16Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.u16, a19: rt.u16): rt.u16 => { - return rt.u16Mul(a011, a19); + v = ((a011: rs.u16, a19: rs.u16): rs.u16 => { + return rs.u16Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.u16Shl(a, n & 0xff); + v = rs.u16Shl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8((a010: rt.u16, a18: rt.u8): rt.u16 => { - return rt.u16Shl(a010, a18); + v = two$ref_u16_ref_u8_u16_ops_Shl_shl_ref_u16_ref_u8((a010: rs.u16, a18: rs.u8): rs.u16 => { + return rs.u16Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.u16, a17: rt.u8): rt.u16 => { - return rt.u16Shl(a09, a17); + v = ((a09: rs.u16, a17: rs.u8): rs.u16 => { + return rs.u16Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { v = ~a & 0xffff; } else if (_208 === 1) { - v = one$ref_u16_u16_ops_Not_not_ref_u16((a08: rt.u16): rt.u16 => { + v = one$ref_u16_u16_ops_Not_not_ref_u16((a08: rs.u16): rs.u16 => { return ~a08 & 0xffff; }, a); } else { - v = ((a07: rt.u16): rt.u16 => { + v = ((a07: rs.u16): rs.u16 => { return ~a07 & 0xffff; })(a); } } else if (_30 === 29) { - let x11: rt.u16 = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.u16 = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.u16Add(x11, b); + x11 = rs.u16Add(x11, b); } else if (_216 === 1) { - two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16((a06: rt.Place, a16: rt.u16): undefined => { - a06.v = rt.u16Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_u16_ref_u16_unit_ops_AddAssign_add_assign_u16_ref_u16((a06: rs.Place, a16: rs.u16): undefined => { + a06.v = rs.u16Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.u16): undefined => { - a05.v = rt.u16Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.u16): undefined => { + a05.v = rs.u16Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.u16 = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.u16 = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.u16Div(x12, b); + x12 = rs.u16Div(x12, b); } else if (_227 === 1) { - two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16((a04: rt.Place, a14: rt.u16): undefined => { - a04.v = rt.u16Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_u16_ref_u16_unit_ops_DivAssign_div_assign_u16_ref_u16((a04: rs.Place, a14: rs.u16): undefined => { + a04.v = rs.u16Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.u16): undefined => { - a03.v = rt.u16Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.u16): undefined => { + a03.v = rs.u16Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.u16 = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.u16 = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.u16Shr(x13, n & 0xffff); + x13 = rs.u16Shr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.u16Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_u16_ref_u16_unit_ops_ShrAssign_shr_assign_u16_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.u16Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u16Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u16Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -3429,467 +3429,467 @@ export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.u32; - const _28: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v3: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); +export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.u32; + const _28: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v3: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); }; - const take: (a0: rt.usize) => rt.u32 = (at: rt.usize): rt.u32 => { - const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { + const buf: Uint8Array = rs.bytes(4); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.u32FromBeBytes(buf); + return rs.u32FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.u32, rt.u32] = [take(1), take(1 + 4)]; - const a: rt.u32 = _10[0]; - const b: rt.u32 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.u32, rs.u32] = [take(1), take(1 + 4)]; + const a: rs.u32 = _10[0]; + const b: rs.u32 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 4), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.u32Add(a, b); + v = rs.u32Add(a, b); } else if (_32 === 1) { - v = two$u32_u32_u32_ops_Add_add_u32_u32((a062: rt.u32, a158: rt.u32): rt.u32 => { - return rt.u32Add(a062, a158); + v = two$u32_u32_u32_ops_Add_add_u32_u32((a062: rs.u32, a158: rs.u32): rs.u32 => { + return rs.u32Add(a062, a158); }, a, b); } else { - v = ((a061: rt.u32, a157: rt.u32): rt.u32 => { - return rt.u32Add(a061, a157); + v = ((a061: rs.u32, a157: rs.u32): rs.u32 => { + return rs.u32Add(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.u32Sub(a, b); + v = rs.u32Sub(a, b); } else if (_35 === 1) { - v = two$u32_u32_u32_ops_Sub_sub_u32_u32((a060: rt.u32, a156: rt.u32): rt.u32 => { - return rt.u32Sub(a060, a156); + v = two$u32_u32_u32_ops_Sub_sub_u32_u32((a060: rs.u32, a156: rs.u32): rs.u32 => { + return rs.u32Sub(a060, a156); }, a, b); } else { - v = ((a059: rt.u32, a155: rt.u32): rt.u32 => { - return rt.u32Sub(a059, a155); + v = ((a059: rs.u32, a155: rs.u32): rs.u32 => { + return rs.u32Sub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.u32Mul(a, b); + v = rs.u32Mul(a, b); } else if (_38 === 1) { - v = two$u32_u32_u32_ops_Mul_mul_u32_u32((a058: rt.u32, a154: rt.u32): rt.u32 => { - return rt.u32Mul(a058, a154); + v = two$u32_u32_u32_ops_Mul_mul_u32_u32((a058: rs.u32, a154: rs.u32): rs.u32 => { + return rs.u32Mul(a058, a154); }, a, b); } else { - v = ((a057: rt.u32, a153: rt.u32): rt.u32 => { - return rt.u32Mul(a057, a153); + v = ((a057: rs.u32, a153: rs.u32): rs.u32 => { + return rs.u32Mul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.u32Div(a, b); + v = rs.u32Div(a, b); } else if (_41 === 1) { - v = two$u32_u32_u32_ops_Div_div_u32_u32((a056: rt.u32, a152: rt.u32): rt.u32 => { - return rt.u32Div(a056, a152); + v = two$u32_u32_u32_ops_Div_div_u32_u32((a056: rs.u32, a152: rs.u32): rs.u32 => { + return rs.u32Div(a056, a152); }, a, b); } else { - v = ((a055: rt.u32, a151: rt.u32): rt.u32 => { - return rt.u32Div(a055, a151); + v = ((a055: rs.u32, a151: rs.u32): rs.u32 => { + return rs.u32Div(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.u32Rem(a, b); + v = rs.u32Rem(a, b); } else if (_44 === 1) { - v = two$u32_u32_u32_ops_Rem_rem_u32_u32((a054: rt.u32, a150: rt.u32): rt.u32 => { - return rt.u32Rem(a054, a150); + v = two$u32_u32_u32_ops_Rem_rem_u32_u32((a054: rs.u32, a150: rs.u32): rs.u32 => { + return rs.u32Rem(a054, a150); }, a, b); } else { - v = ((a053: rt.u32, a149: rt.u32): rt.u32 => { - return rt.u32Rem(a053, a149); + v = ((a053: rs.u32, a149: rs.u32): rs.u32 => { + return rs.u32Rem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = (a & b) >>> 0; } else if (_47 === 1) { - v = two$u32_u32_u32_ops_BitAnd_bitand_u32_u32((a052: rt.u32, a148: rt.u32): rt.u32 => { + v = two$u32_u32_u32_ops_BitAnd_bitand_u32_u32((a052: rs.u32, a148: rs.u32): rs.u32 => { return (a052 & a148) >>> 0; }, a, b); } else { - v = ((a051: rt.u32, a147: rt.u32): rt.u32 => { + v = ((a051: rs.u32, a147: rs.u32): rs.u32 => { return (a051 & a147) >>> 0; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = (a | b) >>> 0; } else if (_50 === 1) { - v = two$u32_u32_u32_ops_BitOr_bitor_u32_u32((a050: rt.u32, a146: rt.u32): rt.u32 => { + v = two$u32_u32_u32_ops_BitOr_bitor_u32_u32((a050: rs.u32, a146: rs.u32): rs.u32 => { return (a050 | a146) >>> 0; }, a, b); } else { - v = ((a049: rt.u32, a145: rt.u32): rt.u32 => { + v = ((a049: rs.u32, a145: rs.u32): rs.u32 => { return (a049 | a145) >>> 0; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = (a ^ b) >>> 0; } else if (_53 === 1) { - v = two$u32_u32_u32_ops_BitXor_bitxor_u32_u32((a048: rt.u32, a144: rt.u32): rt.u32 => { + v = two$u32_u32_u32_ops_BitXor_bitxor_u32_u32((a048: rs.u32, a144: rs.u32): rs.u32 => { return (a048 ^ a144) >>> 0; }, a, b); } else { - v = ((a047: rt.u32, a143: rt.u32): rt.u32 => { + v = ((a047: rs.u32, a143: rs.u32): rs.u32 => { return (a047 ^ a143) >>> 0; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.u32Shl(a, n); + v = rs.u32Shl(a, n); } else if (_56 === 1) { - v = two$u32_u32_u32_ops_Shl_shl_u32_u32((a046: rt.u32, a142: rt.u32): rt.u32 => { - return rt.u32Shl(a046, a142); + v = two$u32_u32_u32_ops_Shl_shl_u32_u32((a046: rs.u32, a142: rs.u32): rs.u32 => { + return rs.u32Shl(a046, a142); }, a, n); } else { - v = ((a045: rt.u32, a141: rt.u32): rt.u32 => { - return rt.u32Shl(a045, a141); + v = ((a045: rs.u32, a141: rs.u32): rs.u32 => { + return rs.u32Shl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.u32Shr(a, n); + v = rs.u32Shr(a, n); } else if (_59 === 1) { - v = two$u32_u32_u32_ops_Shr_shr_u32_u32((a044: rt.u32, a140: rt.u32): rt.u32 => { - return rt.u32Shr(a044, a140); + v = two$u32_u32_u32_ops_Shr_shr_u32_u32((a044: rs.u32, a140: rs.u32): rs.u32 => { + return rs.u32Shr(a044, a140); }, a, n); } else { - v = ((a043: rt.u32, a139: rt.u32): rt.u32 => { - return rt.u32Shr(a043, a139); + v = ((a043: rs.u32, a139: rs.u32): rs.u32 => { + return rs.u32Shr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.u32Shl(a, (n << 16) >> 16); + v = rs.u32Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$u32_i16_u32_ops_Shl_shl_u32_i16((a042: rt.u32, a138: rt.i16): rt.u32 => { - return rt.u32Shl(a042, a138); + v = two$u32_i16_u32_ops_Shl_shl_u32_i16((a042: rs.u32, a138: rs.i16): rs.u32 => { + return rs.u32Shl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.u32, a137: rt.i16): rt.u32 => { - return rt.u32Shl(a041, a137); + v = ((a041: rs.u32, a137: rs.i16): rs.u32 => { + return rs.u32Shl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.u32Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.u32Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$u32_u128_u32_ops_Shr_shr_u32_u128((a040: rt.u32, a136: rt.u128): rt.u32 => { - return rt.u32Shr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$u32_u128_u32_ops_Shr_shr_u32_u128((a040: rs.u32, a136: rs.u128): rs.u32 => { + return rs.u32Shr(a040, a136); }, a, _74); } else { - v = ((a039: rt.u32, a135: rt.u128): rt.u32 => { - return rt.u32Shr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.u32, a135: rs.u128): rs.u32 => { + return rs.u32Shr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a >>> 0; } else if (_83 === 1) { - v = one$u32_u32_ops_Not_not_u32((a038: rt.u32): rt.u32 => { + v = one$u32_u32_ops_Not_not_u32((a038: rs.u32): rs.u32 => { return ~a038 >>> 0; }, a); } else { - v = ((a037: rt.u32): rt.u32 => { + v = ((a037: rs.u32): rs.u32 => { return ~a037 >>> 0; })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.u32 | undefined; + const _86 = undefined as rs.u32 | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.u32 = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.u32 = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.u32Add(x, b); + x = rs.u32Add(x, b); } else if (_91 === 1) { - two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32((a036: rt.Place, a134: rt.u32): undefined => { - a036.v = rt.u32Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_u32_u32_unit_ops_AddAssign_add_assign_u32_u32((a036: rs.Place, a134: rs.u32): undefined => { + a036.v = rs.u32Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.u32): undefined => { - a035.v = rt.u32Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.u32): undefined => { + a035.v = rs.u32Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.u32 = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.u32 = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.u32Sub(x2, b); + x2 = rs.u32Sub(x2, b); } else if (_99 === 1) { - two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32((a034: rt.Place, a132: rt.u32): undefined => { - a034.v = rt.u32Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_u32_u32_unit_ops_SubAssign_sub_assign_u32_u32((a034: rs.Place, a132: rs.u32): undefined => { + a034.v = rs.u32Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.u32): undefined => { - a033.v = rt.u32Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.u32): undefined => { + a033.v = rs.u32Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.u32 = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.u32 = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.u32Mul(x3, b); + x3 = rs.u32Mul(x3, b); } else if (_107 === 1) { - two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32((a032: rt.Place, a130: rt.u32): undefined => { - a032.v = rt.u32Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_u32_u32_unit_ops_MulAssign_mul_assign_u32_u32((a032: rs.Place, a130: rs.u32): undefined => { + a032.v = rs.u32Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.u32): undefined => { - a031.v = rt.u32Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.u32): undefined => { + a031.v = rs.u32Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.u32 = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.u32 = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.u32Div(x4, b); + x4 = rs.u32Div(x4, b); } else if (_115 === 1) { - two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32((a030: rt.Place, a128: rt.u32): undefined => { - a030.v = rt.u32Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_u32_u32_unit_ops_DivAssign_div_assign_u32_u32((a030: rs.Place, a128: rs.u32): undefined => { + a030.v = rs.u32Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.u32): undefined => { - a029.v = rt.u32Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.u32): undefined => { + a029.v = rs.u32Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.u32 = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.u32 = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.u32Rem(x5, b); + x5 = rs.u32Rem(x5, b); } else if (_123 === 1) { - two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32((a028: rt.Place, a126: rt.u32): undefined => { - a028.v = rt.u32Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_u32_u32_unit_ops_RemAssign_rem_assign_u32_u32((a028: rs.Place, a126: rs.u32): undefined => { + a028.v = rs.u32Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.u32): undefined => { - a027.v = rt.u32Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.u32): undefined => { + a027.v = rs.u32Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.u32 = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.u32 = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { x6 = (x6 & b) >>> 0; } else if (_131 === 1) { - two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32((a026: rt.Place, a124: rt.u32): undefined => { + two$mut_u32_u32_unit_ops_BitAndAssign_bitand_assign_u32_u32((a026: rs.Place, a124: rs.u32): undefined => { a026.v = (a026.v & a124) >>> 0; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.u32): undefined => { + ((a025: rs.Place, a123: rs.u32): undefined => { a025.v = (a025.v & a123) >>> 0; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.u32 = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.u32 = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { x7 = (x7 | b) >>> 0; } else if (_139 === 1) { - two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32((a024: rt.Place, a122: rt.u32): undefined => { + two$mut_u32_u32_unit_ops_BitOrAssign_bitor_assign_u32_u32((a024: rs.Place, a122: rs.u32): undefined => { a024.v = (a024.v | a122) >>> 0; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.u32): undefined => { + ((a023: rs.Place, a121: rs.u32): undefined => { a023.v = (a023.v | a121) >>> 0; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.u32 = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.u32 = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { x8 = (x8 ^ b) >>> 0; } else if (_147 === 1) { - two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32((a022: rt.Place, a120: rt.u32): undefined => { + two$mut_u32_u32_unit_ops_BitXorAssign_bitxor_assign_u32_u32((a022: rs.Place, a120: rs.u32): undefined => { a022.v = (a022.v ^ a120) >>> 0; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.u32): undefined => { + ((a021: rs.Place, a119: rs.u32): undefined => { a021.v = (a021.v ^ a119) >>> 0; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.u32 = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.u32 = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.u32Shl(x9, n); + x9 = rs.u32Shl(x9, n); } else if (_155 === 1) { - two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.u32Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_u32_u32_unit_ops_ShlAssign_shl_assign_u32_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.u32Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.u32Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.u32Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.u32 = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.u32 = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.u32Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.u32Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.u32Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_u32_i64_unit_ops_ShrAssign_shr_assign_u32_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.u32Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.u32Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.u32Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.u32Add(a, b); + v = rs.u32Add(a, b); } else if (_175 === 1) { - v = two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32((a016: rt.u32, a114: rt.u32): rt.u32 => { - return rt.u32Add(a016, a114); + v = two$u32_ref_u32_u32_ops_Add_add_u32_ref_u32((a016: rs.u32, a114: rs.u32): rs.u32 => { + return rs.u32Add(a016, a114); }, a, b); } else { - v = ((a015: rt.u32, a113: rt.u32): rt.u32 => { - return rt.u32Add(a015, a113); + v = ((a015: rs.u32, a113: rs.u32): rs.u32 => { + return rs.u32Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.u32Sub(a, b); + v = rs.u32Sub(a, b); } else if (_181 === 1) { - v = two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32((a014: rt.u32, a112: rt.u32): rt.u32 => { - return rt.u32Sub(a014, a112); + v = two$ref_u32_u32_u32_ops_Sub_sub_ref_u32_u32((a014: rs.u32, a112: rs.u32): rs.u32 => { + return rs.u32Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.u32, a111: rt.u32): rt.u32 => { - return rt.u32Sub(a013, a111); + v = ((a013: rs.u32, a111: rs.u32): rs.u32 => { + return rs.u32Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.u32Mul(a, b); + v = rs.u32Mul(a, b); } else if (_187 === 1) { - v = two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32((a012: rt.u32, a110: rt.u32): rt.u32 => { - return rt.u32Mul(a012, a110); + v = two$ref_u32_ref_u32_u32_ops_Mul_mul_ref_u32_ref_u32((a012: rs.u32, a110: rs.u32): rs.u32 => { + return rs.u32Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.u32, a19: rt.u32): rt.u32 => { - return rt.u32Mul(a011, a19); + v = ((a011: rs.u32, a19: rs.u32): rs.u32 => { + return rs.u32Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.u32Shl(a, n & 0xff); + v = rs.u32Shl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8((a010: rt.u32, a18: rt.u8): rt.u32 => { - return rt.u32Shl(a010, a18); + v = two$ref_u32_ref_u8_u32_ops_Shl_shl_ref_u32_ref_u8((a010: rs.u32, a18: rs.u8): rs.u32 => { + return rs.u32Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.u32, a17: rt.u8): rt.u32 => { - return rt.u32Shl(a09, a17); + v = ((a09: rs.u32, a17: rs.u8): rs.u32 => { + return rs.u32Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { v = ~a >>> 0; } else if (_208 === 1) { - v = one$ref_u32_u32_ops_Not_not_ref_u32((a08: rt.u32): rt.u32 => { + v = one$ref_u32_u32_ops_Not_not_ref_u32((a08: rs.u32): rs.u32 => { return ~a08 >>> 0; }, a); } else { - v = ((a07: rt.u32): rt.u32 => { + v = ((a07: rs.u32): rs.u32 => { return ~a07 >>> 0; })(a); } } else if (_30 === 29) { - let x11: rt.u32 = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.u32 = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.u32Add(x11, b); + x11 = rs.u32Add(x11, b); } else if (_216 === 1) { - two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32((a06: rt.Place, a16: rt.u32): undefined => { - a06.v = rt.u32Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_u32_ref_u32_unit_ops_AddAssign_add_assign_u32_ref_u32((a06: rs.Place, a16: rs.u32): undefined => { + a06.v = rs.u32Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.u32): undefined => { - a05.v = rt.u32Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.u32): undefined => { + a05.v = rs.u32Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.u32 = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.u32 = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.u32Div(x12, b); + x12 = rs.u32Div(x12, b); } else if (_227 === 1) { - two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32((a04: rt.Place, a14: rt.u32): undefined => { - a04.v = rt.u32Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_u32_ref_u32_unit_ops_DivAssign_div_assign_u32_ref_u32((a04: rs.Place, a14: rs.u32): undefined => { + a04.v = rs.u32Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.u32): undefined => { - a03.v = rt.u32Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.u32): undefined => { + a03.v = rs.u32Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.u32 = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.u32 = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.u32Shr(x13, n & 0xffff); + x13 = rs.u32Shr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.u32Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_u32_ref_u16_unit_ops_ShrAssign_shr_assign_u32_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.u32Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u32Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u32Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -3901,467 +3901,467 @@ export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.u64; - const _28: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v3: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast(v3)))); +export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.u64; + const _28: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v3: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast(v3)))); }; - const take: (a0: rt.usize) => rt.u64 = (at: rt.usize): rt.u64 => { - const buf: Uint8Array = rt.bytes(8); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { + const buf: Uint8Array = rs.bytes(8); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.u64FromBeBytes(buf); + return rs.u64FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.u64, rt.u64] = [take(1), take(1 + 8)]; - const a: rt.u64 = _10[0]; - const b: rt.u64 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 8), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.u64, rs.u64] = [take(1), take(1 + 8)]; + const a: rs.u64 = _10[0]; + const b: rs.u64 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 8), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.u64Add(a, b); + v = rs.u64Add(a, b); } else if (_32 === 1) { - v = two$u64_u64_u64_ops_Add_add_u64_u64((a062: rt.u64, a158: rt.u64): rt.u64 => { - return rt.u64Add(a062, a158); + v = two$u64_u64_u64_ops_Add_add_u64_u64((a062: rs.u64, a158: rs.u64): rs.u64 => { + return rs.u64Add(a062, a158); }, a, b); } else { - v = ((a061: rt.u64, a157: rt.u64): rt.u64 => { - return rt.u64Add(a061, a157); + v = ((a061: rs.u64, a157: rs.u64): rs.u64 => { + return rs.u64Add(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.u64Sub(a, b); + v = rs.u64Sub(a, b); } else if (_35 === 1) { - v = two$u64_u64_u64_ops_Sub_sub_u64_u64((a060: rt.u64, a156: rt.u64): rt.u64 => { - return rt.u64Sub(a060, a156); + v = two$u64_u64_u64_ops_Sub_sub_u64_u64((a060: rs.u64, a156: rs.u64): rs.u64 => { + return rs.u64Sub(a060, a156); }, a, b); } else { - v = ((a059: rt.u64, a155: rt.u64): rt.u64 => { - return rt.u64Sub(a059, a155); + v = ((a059: rs.u64, a155: rs.u64): rs.u64 => { + return rs.u64Sub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.u64Mul(a, b); + v = rs.u64Mul(a, b); } else if (_38 === 1) { - v = two$u64_u64_u64_ops_Mul_mul_u64_u64((a058: rt.u64, a154: rt.u64): rt.u64 => { - return rt.u64Mul(a058, a154); + v = two$u64_u64_u64_ops_Mul_mul_u64_u64((a058: rs.u64, a154: rs.u64): rs.u64 => { + return rs.u64Mul(a058, a154); }, a, b); } else { - v = ((a057: rt.u64, a153: rt.u64): rt.u64 => { - return rt.u64Mul(a057, a153); + v = ((a057: rs.u64, a153: rs.u64): rs.u64 => { + return rs.u64Mul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.u64Div(a, b); + v = rs.u64Div(a, b); } else if (_41 === 1) { - v = two$u64_u64_u64_ops_Div_div_u64_u64((a056: rt.u64, a152: rt.u64): rt.u64 => { - return rt.u64Div(a056, a152); + v = two$u64_u64_u64_ops_Div_div_u64_u64((a056: rs.u64, a152: rs.u64): rs.u64 => { + return rs.u64Div(a056, a152); }, a, b); } else { - v = ((a055: rt.u64, a151: rt.u64): rt.u64 => { - return rt.u64Div(a055, a151); + v = ((a055: rs.u64, a151: rs.u64): rs.u64 => { + return rs.u64Div(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.u64Rem(a, b); + v = rs.u64Rem(a, b); } else if (_44 === 1) { - v = two$u64_u64_u64_ops_Rem_rem_u64_u64((a054: rt.u64, a150: rt.u64): rt.u64 => { - return rt.u64Rem(a054, a150); + v = two$u64_u64_u64_ops_Rem_rem_u64_u64((a054: rs.u64, a150: rs.u64): rs.u64 => { + return rs.u64Rem(a054, a150); }, a, b); } else { - v = ((a053: rt.u64, a149: rt.u64): rt.u64 => { - return rt.u64Rem(a053, a149); + v = ((a053: rs.u64, a149: rs.u64): rs.u64 => { + return rs.u64Rem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { - v = rt.u64And(a, b); + v = rs.u64And(a, b); } else if (_47 === 1) { - v = two$u64_u64_u64_ops_BitAnd_bitand_u64_u64((a052: rt.u64, a148: rt.u64): rt.u64 => { - return rt.u64And(a052, a148); + v = two$u64_u64_u64_ops_BitAnd_bitand_u64_u64((a052: rs.u64, a148: rs.u64): rs.u64 => { + return rs.u64And(a052, a148); }, a, b); } else { - v = ((a051: rt.u64, a147: rt.u64): rt.u64 => { - return rt.u64And(a051, a147); + v = ((a051: rs.u64, a147: rs.u64): rs.u64 => { + return rs.u64And(a051, a147); })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { - v = rt.u64Or(a, b); + v = rs.u64Or(a, b); } else if (_50 === 1) { - v = two$u64_u64_u64_ops_BitOr_bitor_u64_u64((a050: rt.u64, a146: rt.u64): rt.u64 => { - return rt.u64Or(a050, a146); + v = two$u64_u64_u64_ops_BitOr_bitor_u64_u64((a050: rs.u64, a146: rs.u64): rs.u64 => { + return rs.u64Or(a050, a146); }, a, b); } else { - v = ((a049: rt.u64, a145: rt.u64): rt.u64 => { - return rt.u64Or(a049, a145); + v = ((a049: rs.u64, a145: rs.u64): rs.u64 => { + return rs.u64Or(a049, a145); })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { - v = rt.u64Xor(a, b); + v = rs.u64Xor(a, b); } else if (_53 === 1) { - v = two$u64_u64_u64_ops_BitXor_bitxor_u64_u64((a048: rt.u64, a144: rt.u64): rt.u64 => { - return rt.u64Xor(a048, a144); + v = two$u64_u64_u64_ops_BitXor_bitxor_u64_u64((a048: rs.u64, a144: rs.u64): rs.u64 => { + return rs.u64Xor(a048, a144); }, a, b); } else { - v = ((a047: rt.u64, a143: rt.u64): rt.u64 => { - return rt.u64Xor(a047, a143); + v = ((a047: rs.u64, a143: rs.u64): rs.u64 => { + return rs.u64Xor(a047, a143); })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.u64Shl(a, n); + v = rs.u64Shl(a, n); } else if (_56 === 1) { - v = two$u64_u32_u64_ops_Shl_shl_u64_u32((a046: rt.u64, a142: rt.u32): rt.u64 => { - return rt.u64Shl(a046, a142); + v = two$u64_u32_u64_ops_Shl_shl_u64_u32((a046: rs.u64, a142: rs.u32): rs.u64 => { + return rs.u64Shl(a046, a142); }, a, n); } else { - v = ((a045: rt.u64, a141: rt.u32): rt.u64 => { - return rt.u64Shl(a045, a141); + v = ((a045: rs.u64, a141: rs.u32): rs.u64 => { + return rs.u64Shl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.u64Shr(a, n); + v = rs.u64Shr(a, n); } else if (_59 === 1) { - v = two$u64_u32_u64_ops_Shr_shr_u64_u32((a044: rt.u64, a140: rt.u32): rt.u64 => { - return rt.u64Shr(a044, a140); + v = two$u64_u32_u64_ops_Shr_shr_u64_u32((a044: rs.u64, a140: rs.u32): rs.u64 => { + return rs.u64Shr(a044, a140); }, a, n); } else { - v = ((a043: rt.u64, a139: rt.u32): rt.u64 => { - return rt.u64Shr(a043, a139); + v = ((a043: rs.u64, a139: rs.u32): rs.u64 => { + return rs.u64Shr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.u64Shl(a, (n << 16) >> 16); + v = rs.u64Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$u64_i16_u64_ops_Shl_shl_u64_i16((a042: rt.u64, a138: rt.i16): rt.u64 => { - return rt.u64Shl(a042, a138); + v = two$u64_i16_u64_ops_Shl_shl_u64_i16((a042: rs.u64, a138: rs.i16): rs.u64 => { + return rs.u64Shl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.u64, a137: rt.i16): rt.u64 => { - return rt.u64Shl(a041, a137); + v = ((a041: rs.u64, a137: rs.i16): rs.u64 => { + return rs.u64Shl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.u64Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.u64Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$u64_u128_u64_ops_Shr_shr_u64_u128((a040: rt.u64, a136: rt.u128): rt.u64 => { - return rt.u64Shr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$u64_u128_u64_ops_Shr_shr_u64_u128((a040: rs.u64, a136: rs.u128): rs.u64 => { + return rs.u64Shr(a040, a136); }, a, _74); } else { - v = ((a039: rt.u64, a135: rt.u128): rt.u64 => { - return rt.u64Shr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.u64, a135: rs.u128): rs.u64 => { + return rs.u64Shr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { - v = rt.u64Not(a); + v = rs.u64Not(a); } else if (_83 === 1) { - v = one$u64_u64_ops_Not_not_u64((a038: rt.u64): rt.u64 => { - return rt.u64Not(a038); + v = one$u64_u64_ops_Not_not_u64((a038: rs.u64): rs.u64 => { + return rs.u64Not(a038); }, a); } else { - v = ((a037: rt.u64): rt.u64 => { - return rt.u64Not(a037); + v = ((a037: rs.u64): rs.u64 => { + return rs.u64Not(a037); })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.u64 | undefined; + const _86 = undefined as rs.u64 | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.u64 = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.u64 = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.u64Add(x, b); + x = rs.u64Add(x, b); } else if (_91 === 1) { - two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64((a036: rt.Place, a134: rt.u64): undefined => { - a036.v = rt.u64Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_u64_u64_unit_ops_AddAssign_add_assign_u64_u64((a036: rs.Place, a134: rs.u64): undefined => { + a036.v = rs.u64Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.u64): undefined => { - a035.v = rt.u64Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.u64): undefined => { + a035.v = rs.u64Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.u64 = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.u64 = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.u64Sub(x2, b); + x2 = rs.u64Sub(x2, b); } else if (_99 === 1) { - two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64((a034: rt.Place, a132: rt.u64): undefined => { - a034.v = rt.u64Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_u64_u64_unit_ops_SubAssign_sub_assign_u64_u64((a034: rs.Place, a132: rs.u64): undefined => { + a034.v = rs.u64Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.u64): undefined => { - a033.v = rt.u64Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.u64): undefined => { + a033.v = rs.u64Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.u64 = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.u64 = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.u64Mul(x3, b); + x3 = rs.u64Mul(x3, b); } else if (_107 === 1) { - two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64((a032: rt.Place, a130: rt.u64): undefined => { - a032.v = rt.u64Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_u64_u64_unit_ops_MulAssign_mul_assign_u64_u64((a032: rs.Place, a130: rs.u64): undefined => { + a032.v = rs.u64Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.u64): undefined => { - a031.v = rt.u64Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.u64): undefined => { + a031.v = rs.u64Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.u64 = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.u64 = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.u64Div(x4, b); + x4 = rs.u64Div(x4, b); } else if (_115 === 1) { - two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64((a030: rt.Place, a128: rt.u64): undefined => { - a030.v = rt.u64Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_u64_u64_unit_ops_DivAssign_div_assign_u64_u64((a030: rs.Place, a128: rs.u64): undefined => { + a030.v = rs.u64Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.u64): undefined => { - a029.v = rt.u64Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.u64): undefined => { + a029.v = rs.u64Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.u64 = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.u64 = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.u64Rem(x5, b); + x5 = rs.u64Rem(x5, b); } else if (_123 === 1) { - two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64((a028: rt.Place, a126: rt.u64): undefined => { - a028.v = rt.u64Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_u64_u64_unit_ops_RemAssign_rem_assign_u64_u64((a028: rs.Place, a126: rs.u64): undefined => { + a028.v = rs.u64Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.u64): undefined => { - a027.v = rt.u64Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.u64): undefined => { + a027.v = rs.u64Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.u64 = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.u64 = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { - x6 = rt.u64And(x6, b); + x6 = rs.u64And(x6, b); } else if (_131 === 1) { - two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64((a026: rt.Place, a124: rt.u64): undefined => { - a026.v = rt.u64And(a026.v, a124); - }, rt.place(() => x6, (value16) => x6 = value16), b); + two$mut_u64_u64_unit_ops_BitAndAssign_bitand_assign_u64_u64((a026: rs.Place, a124: rs.u64): undefined => { + a026.v = rs.u64And(a026.v, a124); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.u64): undefined => { - a025.v = rt.u64And(a025.v, a123); - })(rt.place(() => x6, (value15) => x6 = value15), b); + ((a025: rs.Place, a123: rs.u64): undefined => { + a025.v = rs.u64And(a025.v, a123); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.u64 = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.u64 = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { - x7 = rt.u64Or(x7, b); + x7 = rs.u64Or(x7, b); } else if (_139 === 1) { - two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64((a024: rt.Place, a122: rt.u64): undefined => { - a024.v = rt.u64Or(a024.v, a122); - }, rt.place(() => x7, (value14) => x7 = value14), b); + two$mut_u64_u64_unit_ops_BitOrAssign_bitor_assign_u64_u64((a024: rs.Place, a122: rs.u64): undefined => { + a024.v = rs.u64Or(a024.v, a122); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.u64): undefined => { - a023.v = rt.u64Or(a023.v, a121); - })(rt.place(() => x7, (value13) => x7 = value13), b); + ((a023: rs.Place, a121: rs.u64): undefined => { + a023.v = rs.u64Or(a023.v, a121); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.u64 = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.u64 = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { - x8 = rt.u64Xor(x8, b); + x8 = rs.u64Xor(x8, b); } else if (_147 === 1) { - two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64((a022: rt.Place, a120: rt.u64): undefined => { - a022.v = rt.u64Xor(a022.v, a120); - }, rt.place(() => x8, (value12) => x8 = value12), b); + two$mut_u64_u64_unit_ops_BitXorAssign_bitxor_assign_u64_u64((a022: rs.Place, a120: rs.u64): undefined => { + a022.v = rs.u64Xor(a022.v, a120); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.u64): undefined => { - a021.v = rt.u64Xor(a021.v, a119); - })(rt.place(() => x8, (value11) => x8 = value11), b); + ((a021: rs.Place, a119: rs.u64): undefined => { + a021.v = rs.u64Xor(a021.v, a119); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.u64 = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.u64 = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.u64Shl(x9, n); + x9 = rs.u64Shl(x9, n); } else if (_155 === 1) { - two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.u64Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_u64_u32_unit_ops_ShlAssign_shl_assign_u64_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.u64Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.u64Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.u64Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.u64 = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.u64 = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.u64Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.u64Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.u64Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_u64_i64_unit_ops_ShrAssign_shr_assign_u64_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.u64Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.u64Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.u64Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.u64Add(a, b); + v = rs.u64Add(a, b); } else if (_175 === 1) { - v = two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64((a016: rt.u64, a114: rt.u64): rt.u64 => { - return rt.u64Add(a016, a114); + v = two$u64_ref_u64_u64_ops_Add_add_u64_ref_u64((a016: rs.u64, a114: rs.u64): rs.u64 => { + return rs.u64Add(a016, a114); }, a, b); } else { - v = ((a015: rt.u64, a113: rt.u64): rt.u64 => { - return rt.u64Add(a015, a113); + v = ((a015: rs.u64, a113: rs.u64): rs.u64 => { + return rs.u64Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.u64Sub(a, b); + v = rs.u64Sub(a, b); } else if (_181 === 1) { - v = two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64((a014: rt.u64, a112: rt.u64): rt.u64 => { - return rt.u64Sub(a014, a112); + v = two$ref_u64_u64_u64_ops_Sub_sub_ref_u64_u64((a014: rs.u64, a112: rs.u64): rs.u64 => { + return rs.u64Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.u64, a111: rt.u64): rt.u64 => { - return rt.u64Sub(a013, a111); + v = ((a013: rs.u64, a111: rs.u64): rs.u64 => { + return rs.u64Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.u64Mul(a, b); + v = rs.u64Mul(a, b); } else if (_187 === 1) { - v = two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64((a012: rt.u64, a110: rt.u64): rt.u64 => { - return rt.u64Mul(a012, a110); + v = two$ref_u64_ref_u64_u64_ops_Mul_mul_ref_u64_ref_u64((a012: rs.u64, a110: rs.u64): rs.u64 => { + return rs.u64Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.u64, a19: rt.u64): rt.u64 => { - return rt.u64Mul(a011, a19); + v = ((a011: rs.u64, a19: rs.u64): rs.u64 => { + return rs.u64Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.u64Shl(a, n & 0xff); + v = rs.u64Shl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8((a010: rt.u64, a18: rt.u8): rt.u64 => { - return rt.u64Shl(a010, a18); + v = two$ref_u64_ref_u8_u64_ops_Shl_shl_ref_u64_ref_u8((a010: rs.u64, a18: rs.u8): rs.u64 => { + return rs.u64Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.u64, a17: rt.u8): rt.u64 => { - return rt.u64Shl(a09, a17); + v = ((a09: rs.u64, a17: rs.u8): rs.u64 => { + return rs.u64Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { - v = rt.u64Not(a); + v = rs.u64Not(a); } else if (_208 === 1) { - v = one$ref_u64_u64_ops_Not_not_ref_u64((a08: rt.u64): rt.u64 => { - return rt.u64Not(a08); + v = one$ref_u64_u64_ops_Not_not_ref_u64((a08: rs.u64): rs.u64 => { + return rs.u64Not(a08); }, a); } else { - v = ((a07: rt.u64): rt.u64 => { - return rt.u64Not(a07); + v = ((a07: rs.u64): rs.u64 => { + return rs.u64Not(a07); })(a); } } else if (_30 === 29) { - let x11: rt.u64 = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.u64 = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.u64Add(x11, b); + x11 = rs.u64Add(x11, b); } else if (_216 === 1) { - two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64((a06: rt.Place, a16: rt.u64): undefined => { - a06.v = rt.u64Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_u64_ref_u64_unit_ops_AddAssign_add_assign_u64_ref_u64((a06: rs.Place, a16: rs.u64): undefined => { + a06.v = rs.u64Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.u64): undefined => { - a05.v = rt.u64Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.u64): undefined => { + a05.v = rs.u64Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.u64 = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.u64 = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.u64Div(x12, b); + x12 = rs.u64Div(x12, b); } else if (_227 === 1) { - two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64((a04: rt.Place, a14: rt.u64): undefined => { - a04.v = rt.u64Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_u64_ref_u64_unit_ops_DivAssign_div_assign_u64_ref_u64((a04: rs.Place, a14: rs.u64): undefined => { + a04.v = rs.u64Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.u64): undefined => { - a03.v = rt.u64Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.u64): undefined => { + a03.v = rs.u64Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.u64 = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.u64 = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.u64Shr(x13, n & 0xffff); + x13 = rs.u64Shr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.u64Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_u64_ref_u16_unit_ops_ShrAssign_shr_assign_u64_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.u64Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u64Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u64Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -4373,467 +4373,467 @@ export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.u128; - const _28: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v3: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3))); +export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.u128; + const _28: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v3: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3))); }; - const take: (a0: rt.usize) => rt.u128 = (at: rt.usize): rt.u128 => { - const buf: Uint8Array = rt.bytes(16); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { + const buf: Uint8Array = rs.bytes(16); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.u128FromBeBytes(buf); + return rs.u128FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.u128, rt.u128] = [take(1), take(1 + 16)]; - const a: rt.u128 = _10[0]; - const b: rt.u128 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 16), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.u128, rs.u128] = [take(1), take(1 + 16)]; + const a: rs.u128 = _10[0]; + const b: rs.u128 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 16), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.u128Add(a, b); + v = rs.u128Add(a, b); } else if (_32 === 1) { - v = two$u128_u128_u128_ops_Add_add_u128_u128((a062: rt.u128, a158: rt.u128): rt.u128 => { - return rt.u128Add(a062, a158); + v = two$u128_u128_u128_ops_Add_add_u128_u128((a062: rs.u128, a158: rs.u128): rs.u128 => { + return rs.u128Add(a062, a158); }, a, b); } else { - v = ((a061: rt.u128, a157: rt.u128): rt.u128 => { - return rt.u128Add(a061, a157); + v = ((a061: rs.u128, a157: rs.u128): rs.u128 => { + return rs.u128Add(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.u128Sub(a, b); + v = rs.u128Sub(a, b); } else if (_35 === 1) { - v = two$u128_u128_u128_ops_Sub_sub_u128_u128((a060: rt.u128, a156: rt.u128): rt.u128 => { - return rt.u128Sub(a060, a156); + v = two$u128_u128_u128_ops_Sub_sub_u128_u128((a060: rs.u128, a156: rs.u128): rs.u128 => { + return rs.u128Sub(a060, a156); }, a, b); } else { - v = ((a059: rt.u128, a155: rt.u128): rt.u128 => { - return rt.u128Sub(a059, a155); + v = ((a059: rs.u128, a155: rs.u128): rs.u128 => { + return rs.u128Sub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.u128Mul(a, b); + v = rs.u128Mul(a, b); } else if (_38 === 1) { - v = two$u128_u128_u128_ops_Mul_mul_u128_u128((a058: rt.u128, a154: rt.u128): rt.u128 => { - return rt.u128Mul(a058, a154); + v = two$u128_u128_u128_ops_Mul_mul_u128_u128((a058: rs.u128, a154: rs.u128): rs.u128 => { + return rs.u128Mul(a058, a154); }, a, b); } else { - v = ((a057: rt.u128, a153: rt.u128): rt.u128 => { - return rt.u128Mul(a057, a153); + v = ((a057: rs.u128, a153: rs.u128): rs.u128 => { + return rs.u128Mul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.u128Div(a, b); + v = rs.u128Div(a, b); } else if (_41 === 1) { - v = two$u128_u128_u128_ops_Div_div_u128_u128((a056: rt.u128, a152: rt.u128): rt.u128 => { - return rt.u128Div(a056, a152); + v = two$u128_u128_u128_ops_Div_div_u128_u128((a056: rs.u128, a152: rs.u128): rs.u128 => { + return rs.u128Div(a056, a152); }, a, b); } else { - v = ((a055: rt.u128, a151: rt.u128): rt.u128 => { - return rt.u128Div(a055, a151); + v = ((a055: rs.u128, a151: rs.u128): rs.u128 => { + return rs.u128Div(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.u128Rem(a, b); + v = rs.u128Rem(a, b); } else if (_44 === 1) { - v = two$u128_u128_u128_ops_Rem_rem_u128_u128((a054: rt.u128, a150: rt.u128): rt.u128 => { - return rt.u128Rem(a054, a150); + v = two$u128_u128_u128_ops_Rem_rem_u128_u128((a054: rs.u128, a150: rs.u128): rs.u128 => { + return rs.u128Rem(a054, a150); }, a, b); } else { - v = ((a053: rt.u128, a149: rt.u128): rt.u128 => { - return rt.u128Rem(a053, a149); + v = ((a053: rs.u128, a149: rs.u128): rs.u128 => { + return rs.u128Rem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { - v = rt.u128And(a, b); + v = rs.u128And(a, b); } else if (_47 === 1) { - v = two$u128_u128_u128_ops_BitAnd_bitand_u128_u128((a052: rt.u128, a148: rt.u128): rt.u128 => { - return rt.u128And(a052, a148); + v = two$u128_u128_u128_ops_BitAnd_bitand_u128_u128((a052: rs.u128, a148: rs.u128): rs.u128 => { + return rs.u128And(a052, a148); }, a, b); } else { - v = ((a051: rt.u128, a147: rt.u128): rt.u128 => { - return rt.u128And(a051, a147); + v = ((a051: rs.u128, a147: rs.u128): rs.u128 => { + return rs.u128And(a051, a147); })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { - v = rt.u128Or(a, b); + v = rs.u128Or(a, b); } else if (_50 === 1) { - v = two$u128_u128_u128_ops_BitOr_bitor_u128_u128((a050: rt.u128, a146: rt.u128): rt.u128 => { - return rt.u128Or(a050, a146); + v = two$u128_u128_u128_ops_BitOr_bitor_u128_u128((a050: rs.u128, a146: rs.u128): rs.u128 => { + return rs.u128Or(a050, a146); }, a, b); } else { - v = ((a049: rt.u128, a145: rt.u128): rt.u128 => { - return rt.u128Or(a049, a145); + v = ((a049: rs.u128, a145: rs.u128): rs.u128 => { + return rs.u128Or(a049, a145); })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { - v = rt.u128Xor(a, b); + v = rs.u128Xor(a, b); } else if (_53 === 1) { - v = two$u128_u128_u128_ops_BitXor_bitxor_u128_u128((a048: rt.u128, a144: rt.u128): rt.u128 => { - return rt.u128Xor(a048, a144); + v = two$u128_u128_u128_ops_BitXor_bitxor_u128_u128((a048: rs.u128, a144: rs.u128): rs.u128 => { + return rs.u128Xor(a048, a144); }, a, b); } else { - v = ((a047: rt.u128, a143: rt.u128): rt.u128 => { - return rt.u128Xor(a047, a143); + v = ((a047: rs.u128, a143: rs.u128): rs.u128 => { + return rs.u128Xor(a047, a143); })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.u128Shl(a, n); + v = rs.u128Shl(a, n); } else if (_56 === 1) { - v = two$u128_u32_u128_ops_Shl_shl_u128_u32((a046: rt.u128, a142: rt.u32): rt.u128 => { - return rt.u128Shl(a046, a142); + v = two$u128_u32_u128_ops_Shl_shl_u128_u32((a046: rs.u128, a142: rs.u32): rs.u128 => { + return rs.u128Shl(a046, a142); }, a, n); } else { - v = ((a045: rt.u128, a141: rt.u32): rt.u128 => { - return rt.u128Shl(a045, a141); + v = ((a045: rs.u128, a141: rs.u32): rs.u128 => { + return rs.u128Shl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.u128Shr(a, n); + v = rs.u128Shr(a, n); } else if (_59 === 1) { - v = two$u128_u32_u128_ops_Shr_shr_u128_u32((a044: rt.u128, a140: rt.u32): rt.u128 => { - return rt.u128Shr(a044, a140); + v = two$u128_u32_u128_ops_Shr_shr_u128_u32((a044: rs.u128, a140: rs.u32): rs.u128 => { + return rs.u128Shr(a044, a140); }, a, n); } else { - v = ((a043: rt.u128, a139: rt.u32): rt.u128 => { - return rt.u128Shr(a043, a139); + v = ((a043: rs.u128, a139: rs.u32): rs.u128 => { + return rs.u128Shr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.u128Shl(a, (n << 16) >> 16); + v = rs.u128Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$u128_i16_u128_ops_Shl_shl_u128_i16((a042: rt.u128, a138: rt.i16): rt.u128 => { - return rt.u128Shl(a042, a138); + v = two$u128_i16_u128_ops_Shl_shl_u128_i16((a042: rs.u128, a138: rs.i16): rs.u128 => { + return rs.u128Shl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.u128, a137: rt.i16): rt.u128 => { - return rt.u128Shl(a041, a137); + v = ((a041: rs.u128, a137: rs.i16): rs.u128 => { + return rs.u128Shl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.u128Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.u128Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$u128_u128_u128_ops_Shr_shr_u128_u128((a040: rt.u128, a136: rt.u128): rt.u128 => { - return rt.u128Shr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$u128_u128_u128_ops_Shr_shr_u128_u128((a040: rs.u128, a136: rs.u128): rs.u128 => { + return rs.u128Shr(a040, a136); }, a, _74); } else { - v = ((a039: rt.u128, a135: rt.u128): rt.u128 => { - return rt.u128Shr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.u128, a135: rs.u128): rs.u128 => { + return rs.u128Shr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { - v = rt.u128Not(a); + v = rs.u128Not(a); } else if (_83 === 1) { - v = one$u128_u128_ops_Not_not_u128((a038: rt.u128): rt.u128 => { - return rt.u128Not(a038); + v = one$u128_u128_ops_Not_not_u128((a038: rs.u128): rs.u128 => { + return rs.u128Not(a038); }, a); } else { - v = ((a037: rt.u128): rt.u128 => { - return rt.u128Not(a037); + v = ((a037: rs.u128): rs.u128 => { + return rs.u128Not(a037); })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.u128 | undefined; + const _86 = undefined as rs.u128 | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.u128 = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.u128 = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.u128Add(x, b); + x = rs.u128Add(x, b); } else if (_91 === 1) { - two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128((a036: rt.Place, a134: rt.u128): undefined => { - a036.v = rt.u128Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_u128_u128_unit_ops_AddAssign_add_assign_u128_u128((a036: rs.Place, a134: rs.u128): undefined => { + a036.v = rs.u128Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.u128): undefined => { - a035.v = rt.u128Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.u128): undefined => { + a035.v = rs.u128Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.u128 = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.u128 = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.u128Sub(x2, b); + x2 = rs.u128Sub(x2, b); } else if (_99 === 1) { - two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128((a034: rt.Place, a132: rt.u128): undefined => { - a034.v = rt.u128Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_u128_u128_unit_ops_SubAssign_sub_assign_u128_u128((a034: rs.Place, a132: rs.u128): undefined => { + a034.v = rs.u128Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.u128): undefined => { - a033.v = rt.u128Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.u128): undefined => { + a033.v = rs.u128Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.u128 = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.u128 = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.u128Mul(x3, b); + x3 = rs.u128Mul(x3, b); } else if (_107 === 1) { - two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128((a032: rt.Place, a130: rt.u128): undefined => { - a032.v = rt.u128Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_u128_u128_unit_ops_MulAssign_mul_assign_u128_u128((a032: rs.Place, a130: rs.u128): undefined => { + a032.v = rs.u128Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.u128): undefined => { - a031.v = rt.u128Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.u128): undefined => { + a031.v = rs.u128Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.u128 = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.u128 = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.u128Div(x4, b); + x4 = rs.u128Div(x4, b); } else if (_115 === 1) { - two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128((a030: rt.Place, a128: rt.u128): undefined => { - a030.v = rt.u128Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_u128_u128_unit_ops_DivAssign_div_assign_u128_u128((a030: rs.Place, a128: rs.u128): undefined => { + a030.v = rs.u128Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.u128): undefined => { - a029.v = rt.u128Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.u128): undefined => { + a029.v = rs.u128Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.u128 = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.u128 = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.u128Rem(x5, b); + x5 = rs.u128Rem(x5, b); } else if (_123 === 1) { - two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128((a028: rt.Place, a126: rt.u128): undefined => { - a028.v = rt.u128Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_u128_u128_unit_ops_RemAssign_rem_assign_u128_u128((a028: rs.Place, a126: rs.u128): undefined => { + a028.v = rs.u128Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.u128): undefined => { - a027.v = rt.u128Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.u128): undefined => { + a027.v = rs.u128Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.u128 = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.u128 = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { - x6 = rt.u128And(x6, b); + x6 = rs.u128And(x6, b); } else if (_131 === 1) { - two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128((a026: rt.Place, a124: rt.u128): undefined => { - a026.v = rt.u128And(a026.v, a124); - }, rt.place(() => x6, (value16) => x6 = value16), b); + two$mut_u128_u128_unit_ops_BitAndAssign_bitand_assign_u128_u128((a026: rs.Place, a124: rs.u128): undefined => { + a026.v = rs.u128And(a026.v, a124); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.u128): undefined => { - a025.v = rt.u128And(a025.v, a123); - })(rt.place(() => x6, (value15) => x6 = value15), b); + ((a025: rs.Place, a123: rs.u128): undefined => { + a025.v = rs.u128And(a025.v, a123); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.u128 = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.u128 = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { - x7 = rt.u128Or(x7, b); + x7 = rs.u128Or(x7, b); } else if (_139 === 1) { - two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128((a024: rt.Place, a122: rt.u128): undefined => { - a024.v = rt.u128Or(a024.v, a122); - }, rt.place(() => x7, (value14) => x7 = value14), b); + two$mut_u128_u128_unit_ops_BitOrAssign_bitor_assign_u128_u128((a024: rs.Place, a122: rs.u128): undefined => { + a024.v = rs.u128Or(a024.v, a122); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.u128): undefined => { - a023.v = rt.u128Or(a023.v, a121); - })(rt.place(() => x7, (value13) => x7 = value13), b); + ((a023: rs.Place, a121: rs.u128): undefined => { + a023.v = rs.u128Or(a023.v, a121); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.u128 = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.u128 = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { - x8 = rt.u128Xor(x8, b); + x8 = rs.u128Xor(x8, b); } else if (_147 === 1) { - two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128((a022: rt.Place, a120: rt.u128): undefined => { - a022.v = rt.u128Xor(a022.v, a120); - }, rt.place(() => x8, (value12) => x8 = value12), b); + two$mut_u128_u128_unit_ops_BitXorAssign_bitxor_assign_u128_u128((a022: rs.Place, a120: rs.u128): undefined => { + a022.v = rs.u128Xor(a022.v, a120); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.u128): undefined => { - a021.v = rt.u128Xor(a021.v, a119); - })(rt.place(() => x8, (value11) => x8 = value11), b); + ((a021: rs.Place, a119: rs.u128): undefined => { + a021.v = rs.u128Xor(a021.v, a119); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.u128 = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.u128 = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.u128Shl(x9, n); + x9 = rs.u128Shl(x9, n); } else if (_155 === 1) { - two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.u128Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_u128_u32_unit_ops_ShlAssign_shl_assign_u128_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.u128Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.u128Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.u128Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.u128 = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.u128 = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.u128Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.u128Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.u128Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_u128_i64_unit_ops_ShrAssign_shr_assign_u128_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.u128Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.u128Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.u128Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.u128Add(a, b); + v = rs.u128Add(a, b); } else if (_175 === 1) { - v = two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128((a016: rt.u128, a114: rt.u128): rt.u128 => { - return rt.u128Add(a016, a114); + v = two$u128_ref_u128_u128_ops_Add_add_u128_ref_u128((a016: rs.u128, a114: rs.u128): rs.u128 => { + return rs.u128Add(a016, a114); }, a, b); } else { - v = ((a015: rt.u128, a113: rt.u128): rt.u128 => { - return rt.u128Add(a015, a113); + v = ((a015: rs.u128, a113: rs.u128): rs.u128 => { + return rs.u128Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.u128Sub(a, b); + v = rs.u128Sub(a, b); } else if (_181 === 1) { - v = two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128((a014: rt.u128, a112: rt.u128): rt.u128 => { - return rt.u128Sub(a014, a112); + v = two$ref_u128_u128_u128_ops_Sub_sub_ref_u128_u128((a014: rs.u128, a112: rs.u128): rs.u128 => { + return rs.u128Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.u128, a111: rt.u128): rt.u128 => { - return rt.u128Sub(a013, a111); + v = ((a013: rs.u128, a111: rs.u128): rs.u128 => { + return rs.u128Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.u128Mul(a, b); + v = rs.u128Mul(a, b); } else if (_187 === 1) { - v = two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128((a012: rt.u128, a110: rt.u128): rt.u128 => { - return rt.u128Mul(a012, a110); + v = two$ref_u128_ref_u128_u128_ops_Mul_mul_ref_u128_ref_u128((a012: rs.u128, a110: rs.u128): rs.u128 => { + return rs.u128Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.u128, a19: rt.u128): rt.u128 => { - return rt.u128Mul(a011, a19); + v = ((a011: rs.u128, a19: rs.u128): rs.u128 => { + return rs.u128Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.u128Shl(a, n & 0xff); + v = rs.u128Shl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8((a010: rt.u128, a18: rt.u8): rt.u128 => { - return rt.u128Shl(a010, a18); + v = two$ref_u128_ref_u8_u128_ops_Shl_shl_ref_u128_ref_u8((a010: rs.u128, a18: rs.u8): rs.u128 => { + return rs.u128Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.u128, a17: rt.u8): rt.u128 => { - return rt.u128Shl(a09, a17); + v = ((a09: rs.u128, a17: rs.u8): rs.u128 => { + return rs.u128Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { - v = rt.u128Not(a); + v = rs.u128Not(a); } else if (_208 === 1) { - v = one$ref_u128_u128_ops_Not_not_ref_u128((a08: rt.u128): rt.u128 => { - return rt.u128Not(a08); + v = one$ref_u128_u128_ops_Not_not_ref_u128((a08: rs.u128): rs.u128 => { + return rs.u128Not(a08); }, a); } else { - v = ((a07: rt.u128): rt.u128 => { - return rt.u128Not(a07); + v = ((a07: rs.u128): rs.u128 => { + return rs.u128Not(a07); })(a); } } else if (_30 === 29) { - let x11: rt.u128 = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.u128 = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.u128Add(x11, b); + x11 = rs.u128Add(x11, b); } else if (_216 === 1) { - two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128((a06: rt.Place, a16: rt.u128): undefined => { - a06.v = rt.u128Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_u128_ref_u128_unit_ops_AddAssign_add_assign_u128_ref_u128((a06: rs.Place, a16: rs.u128): undefined => { + a06.v = rs.u128Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.u128): undefined => { - a05.v = rt.u128Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.u128): undefined => { + a05.v = rs.u128Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.u128 = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.u128 = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.u128Div(x12, b); + x12 = rs.u128Div(x12, b); } else if (_227 === 1) { - two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128((a04: rt.Place, a14: rt.u128): undefined => { - a04.v = rt.u128Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_u128_ref_u128_unit_ops_DivAssign_div_assign_u128_ref_u128((a04: rs.Place, a14: rs.u128): undefined => { + a04.v = rs.u128Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.u128): undefined => { - a03.v = rt.u128Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.u128): undefined => { + a03.v = rs.u128Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.u128 = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.u128 = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.u128Shr(x13, n & 0xffff); + x13 = rs.u128Shr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.u128Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_u128_ref_u16_unit_ops_ShrAssign_shr_assign_u128_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.u128Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.u128Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.u128Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -4845,467 +4845,467 @@ export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.usize; - const _28: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v3: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v3 as rt.u128))); +export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.usize; + const _28: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v3: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v3 as rs.u128))); }; - const take: (a0: rt.usize) => rt.usize = (at: rt.usize): rt.usize => { - const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { + const buf: Uint8Array = rs.bytes(4); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.usizeFromBeBytes(buf); + return rs.usizeFromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.usize, rt.usize] = [take(1), take(1 + 4)]; - const a: rt.usize = _10[0]; - const b: rt.usize = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.usize, rs.usize] = [take(1), take(1 + 4)]; + const a: rs.usize = _10[0]; + const b: rs.usize = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 4), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.usizeAdd(a, b); + v = rs.usizeAdd(a, b); } else if (_32 === 1) { - v = two$usize_usize_usize_ops_Add_add_usize_usize((a062: rt.usize, a158: rt.usize): rt.usize => { - return rt.usizeAdd(a062, a158); + v = two$usize_usize_usize_ops_Add_add_usize_usize((a062: rs.usize, a158: rs.usize): rs.usize => { + return rs.usizeAdd(a062, a158); }, a, b); } else { - v = ((a061: rt.usize, a157: rt.usize): rt.usize => { - return rt.usizeAdd(a061, a157); + v = ((a061: rs.usize, a157: rs.usize): rs.usize => { + return rs.usizeAdd(a061, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.usizeSub(a, b); + v = rs.usizeSub(a, b); } else if (_35 === 1) { - v = two$usize_usize_usize_ops_Sub_sub_usize_usize((a060: rt.usize, a156: rt.usize): rt.usize => { - return rt.usizeSub(a060, a156); + v = two$usize_usize_usize_ops_Sub_sub_usize_usize((a060: rs.usize, a156: rs.usize): rs.usize => { + return rs.usizeSub(a060, a156); }, a, b); } else { - v = ((a059: rt.usize, a155: rt.usize): rt.usize => { - return rt.usizeSub(a059, a155); + v = ((a059: rs.usize, a155: rs.usize): rs.usize => { + return rs.usizeSub(a059, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.usizeMul(a, b); + v = rs.usizeMul(a, b); } else if (_38 === 1) { - v = two$usize_usize_usize_ops_Mul_mul_usize_usize((a058: rt.usize, a154: rt.usize): rt.usize => { - return rt.usizeMul(a058, a154); + v = two$usize_usize_usize_ops_Mul_mul_usize_usize((a058: rs.usize, a154: rs.usize): rs.usize => { + return rs.usizeMul(a058, a154); }, a, b); } else { - v = ((a057: rt.usize, a153: rt.usize): rt.usize => { - return rt.usizeMul(a057, a153); + v = ((a057: rs.usize, a153: rs.usize): rs.usize => { + return rs.usizeMul(a057, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.usizeDiv(a, b); + v = rs.usizeDiv(a, b); } else if (_41 === 1) { - v = two$usize_usize_usize_ops_Div_div_usize_usize((a056: rt.usize, a152: rt.usize): rt.usize => { - return rt.usizeDiv(a056, a152); + v = two$usize_usize_usize_ops_Div_div_usize_usize((a056: rs.usize, a152: rs.usize): rs.usize => { + return rs.usizeDiv(a056, a152); }, a, b); } else { - v = ((a055: rt.usize, a151: rt.usize): rt.usize => { - return rt.usizeDiv(a055, a151); + v = ((a055: rs.usize, a151: rs.usize): rs.usize => { + return rs.usizeDiv(a055, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.usizeRem(a, b); + v = rs.usizeRem(a, b); } else if (_44 === 1) { - v = two$usize_usize_usize_ops_Rem_rem_usize_usize((a054: rt.usize, a150: rt.usize): rt.usize => { - return rt.usizeRem(a054, a150); + v = two$usize_usize_usize_ops_Rem_rem_usize_usize((a054: rs.usize, a150: rs.usize): rs.usize => { + return rs.usizeRem(a054, a150); }, a, b); } else { - v = ((a053: rt.usize, a149: rt.usize): rt.usize => { - return rt.usizeRem(a053, a149); + v = ((a053: rs.usize, a149: rs.usize): rs.usize => { + return rs.usizeRem(a053, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = (a & b) >>> 0; } else if (_47 === 1) { - v = two$usize_usize_usize_ops_BitAnd_bitand_usize_usize((a052: rt.usize, a148: rt.usize): rt.usize => { + v = two$usize_usize_usize_ops_BitAnd_bitand_usize_usize((a052: rs.usize, a148: rs.usize): rs.usize => { return (a052 & a148) >>> 0; }, a, b); } else { - v = ((a051: rt.usize, a147: rt.usize): rt.usize => { + v = ((a051: rs.usize, a147: rs.usize): rs.usize => { return (a051 & a147) >>> 0; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = (a | b) >>> 0; } else if (_50 === 1) { - v = two$usize_usize_usize_ops_BitOr_bitor_usize_usize((a050: rt.usize, a146: rt.usize): rt.usize => { + v = two$usize_usize_usize_ops_BitOr_bitor_usize_usize((a050: rs.usize, a146: rs.usize): rs.usize => { return (a050 | a146) >>> 0; }, a, b); } else { - v = ((a049: rt.usize, a145: rt.usize): rt.usize => { + v = ((a049: rs.usize, a145: rs.usize): rs.usize => { return (a049 | a145) >>> 0; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = (a ^ b) >>> 0; } else if (_53 === 1) { - v = two$usize_usize_usize_ops_BitXor_bitxor_usize_usize((a048: rt.usize, a144: rt.usize): rt.usize => { + v = two$usize_usize_usize_ops_BitXor_bitxor_usize_usize((a048: rs.usize, a144: rs.usize): rs.usize => { return (a048 ^ a144) >>> 0; }, a, b); } else { - v = ((a047: rt.usize, a143: rt.usize): rt.usize => { + v = ((a047: rs.usize, a143: rs.usize): rs.usize => { return (a047 ^ a143) >>> 0; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.usizeShl(a, n); + v = rs.usizeShl(a, n); } else if (_56 === 1) { - v = two$usize_u32_usize_ops_Shl_shl_usize_u32((a046: rt.usize, a142: rt.u32): rt.usize => { - return rt.usizeShl(a046, a142); + v = two$usize_u32_usize_ops_Shl_shl_usize_u32((a046: rs.usize, a142: rs.u32): rs.usize => { + return rs.usizeShl(a046, a142); }, a, n); } else { - v = ((a045: rt.usize, a141: rt.u32): rt.usize => { - return rt.usizeShl(a045, a141); + v = ((a045: rs.usize, a141: rs.u32): rs.usize => { + return rs.usizeShl(a045, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.usizeShr(a, n); + v = rs.usizeShr(a, n); } else if (_59 === 1) { - v = two$usize_u32_usize_ops_Shr_shr_usize_u32((a044: rt.usize, a140: rt.u32): rt.usize => { - return rt.usizeShr(a044, a140); + v = two$usize_u32_usize_ops_Shr_shr_usize_u32((a044: rs.usize, a140: rs.u32): rs.usize => { + return rs.usizeShr(a044, a140); }, a, n); } else { - v = ((a043: rt.usize, a139: rt.u32): rt.usize => { - return rt.usizeShr(a043, a139); + v = ((a043: rs.usize, a139: rs.u32): rs.usize => { + return rs.usizeShr(a043, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.usizeShl(a, (n << 16) >> 16); + v = rs.usizeShl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$usize_i16_usize_ops_Shl_shl_usize_i16((a042: rt.usize, a138: rt.i16): rt.usize => { - return rt.usizeShl(a042, a138); + v = two$usize_i16_usize_ops_Shl_shl_usize_i16((a042: rs.usize, a138: rs.i16): rs.usize => { + return rs.usizeShl(a042, a138); }, a, (n << 16) >> 16); } else { - v = ((a041: rt.usize, a137: rt.i16): rt.usize => { - return rt.usizeShl(a041, a137); + v = ((a041: rs.usize, a137: rs.i16): rs.usize => { + return rs.usizeShl(a041, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.usizeShr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.usizeShr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$usize_u128_usize_ops_Shr_shr_usize_u128((a040: rt.usize, a136: rt.u128): rt.usize => { - return rt.usizeShr(a040, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$usize_u128_usize_ops_Shr_shr_usize_u128((a040: rs.usize, a136: rs.u128): rs.usize => { + return rs.usizeShr(a040, a136); }, a, _74); } else { - v = ((a039: rt.usize, a135: rt.u128): rt.usize => { - return rt.usizeShr(a039, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a039: rs.usize, a135: rs.u128): rs.usize => { + return rs.usizeShr(a039, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a >>> 0; } else if (_83 === 1) { - v = one$usize_usize_ops_Not_not_usize((a038: rt.usize): rt.usize => { + v = one$usize_usize_ops_Not_not_usize((a038: rs.usize): rs.usize => { return ~a038 >>> 0; }, a); } else { - v = ((a037: rt.usize): rt.usize => { + v = ((a037: rs.usize): rs.usize => { return ~a037 >>> 0; })(a); } } else if (_30 === 13) { - const _86 = undefined as rt.usize | undefined; + const _86 = undefined as rs.usize | undefined; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.usize = a; - const _91: rt.u8 = rt.u8Rem(form, 3); + let x: rs.usize = a; + const _91: rs.u8 = rs.u8Rem(form, 3); if (_91 === 0) { - x = rt.usizeAdd(x, b); + x = rs.usizeAdd(x, b); } else if (_91 === 1) { - two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize((a036: rt.Place, a134: rt.usize): undefined => { - a036.v = rt.usizeAdd(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_usize_usize_unit_ops_AddAssign_add_assign_usize_usize((a036: rs.Place, a134: rs.usize): undefined => { + a036.v = rs.usizeAdd(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.usize): undefined => { - a035.v = rt.usizeAdd(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.usize): undefined => { + a035.v = rs.usizeAdd(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.usize = a; - const _99: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.usize = a; + const _99: rs.u8 = rs.u8Rem(form, 3); if (_99 === 0) { - x2 = rt.usizeSub(x2, b); + x2 = rs.usizeSub(x2, b); } else if (_99 === 1) { - two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize((a034: rt.Place, a132: rt.usize): undefined => { - a034.v = rt.usizeSub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_usize_usize_unit_ops_SubAssign_sub_assign_usize_usize((a034: rs.Place, a132: rs.usize): undefined => { + a034.v = rs.usizeSub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.usize): undefined => { - a033.v = rt.usizeSub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.usize): undefined => { + a033.v = rs.usizeSub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.usize = a; - const _107: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.usize = a; + const _107: rs.u8 = rs.u8Rem(form, 3); if (_107 === 0) { - x3 = rt.usizeMul(x3, b); + x3 = rs.usizeMul(x3, b); } else if (_107 === 1) { - two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize((a032: rt.Place, a130: rt.usize): undefined => { - a032.v = rt.usizeMul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_usize_usize_unit_ops_MulAssign_mul_assign_usize_usize((a032: rs.Place, a130: rs.usize): undefined => { + a032.v = rs.usizeMul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.usize): undefined => { - a031.v = rt.usizeMul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.usize): undefined => { + a031.v = rs.usizeMul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.usize = a; - const _115: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.usize = a; + const _115: rs.u8 = rs.u8Rem(form, 3); if (_115 === 0) { - x4 = rt.usizeDiv(x4, b); + x4 = rs.usizeDiv(x4, b); } else if (_115 === 1) { - two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize((a030: rt.Place, a128: rt.usize): undefined => { - a030.v = rt.usizeDiv(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_usize_usize_unit_ops_DivAssign_div_assign_usize_usize((a030: rs.Place, a128: rs.usize): undefined => { + a030.v = rs.usizeDiv(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.usize): undefined => { - a029.v = rt.usizeDiv(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.usize): undefined => { + a029.v = rs.usizeDiv(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.usize = a; - const _123: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.usize = a; + const _123: rs.u8 = rs.u8Rem(form, 3); if (_123 === 0) { - x5 = rt.usizeRem(x5, b); + x5 = rs.usizeRem(x5, b); } else if (_123 === 1) { - two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize((a028: rt.Place, a126: rt.usize): undefined => { - a028.v = rt.usizeRem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_usize_usize_unit_ops_RemAssign_rem_assign_usize_usize((a028: rs.Place, a126: rs.usize): undefined => { + a028.v = rs.usizeRem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.usize): undefined => { - a027.v = rt.usizeRem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.usize): undefined => { + a027.v = rs.usizeRem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.usize = a; - const _131: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.usize = a; + const _131: rs.u8 = rs.u8Rem(form, 3); if (_131 === 0) { x6 = (x6 & b) >>> 0; } else if (_131 === 1) { - two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize((a026: rt.Place, a124: rt.usize): undefined => { + two$mut_usize_usize_unit_ops_BitAndAssign_bitand_assign_usize_usize((a026: rs.Place, a124: rs.usize): undefined => { a026.v = (a026.v & a124) >>> 0; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.usize): undefined => { + ((a025: rs.Place, a123: rs.usize): undefined => { a025.v = (a025.v & a123) >>> 0; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.usize = a; - const _139: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.usize = a; + const _139: rs.u8 = rs.u8Rem(form, 3); if (_139 === 0) { x7 = (x7 | b) >>> 0; } else if (_139 === 1) { - two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize((a024: rt.Place, a122: rt.usize): undefined => { + two$mut_usize_usize_unit_ops_BitOrAssign_bitor_assign_usize_usize((a024: rs.Place, a122: rs.usize): undefined => { a024.v = (a024.v | a122) >>> 0; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.usize): undefined => { + ((a023: rs.Place, a121: rs.usize): undefined => { a023.v = (a023.v | a121) >>> 0; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.usize = a; - const _147: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.usize = a; + const _147: rs.u8 = rs.u8Rem(form, 3); if (_147 === 0) { x8 = (x8 ^ b) >>> 0; } else if (_147 === 1) { - two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize((a022: rt.Place, a120: rt.usize): undefined => { + two$mut_usize_usize_unit_ops_BitXorAssign_bitxor_assign_usize_usize((a022: rs.Place, a120: rs.usize): undefined => { a022.v = (a022.v ^ a120) >>> 0; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.usize): undefined => { + ((a021: rs.Place, a119: rs.usize): undefined => { a021.v = (a021.v ^ a119) >>> 0; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.usize = a; - const _155: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.usize = a; + const _155: rs.u8 = rs.u8Rem(form, 3); if (_155 === 0) { - x9 = rt.usizeShl(x9, n); + x9 = rs.usizeShl(x9, n); } else if (_155 === 1) { - two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.usizeShl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_usize_u32_unit_ops_ShlAssign_shl_assign_usize_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.usizeShl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.usizeShl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.usizeShl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.usize = a; - const _163: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.usize = a; + const _163: rs.u8 = rs.u8Rem(form, 3); if (_163 === 0) { - x10 = rt.usizeShr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.usizeShr(x10, (n << 16) >> 16 as rs.i64); } else if (_163 === 1) { - two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.usizeShr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_usize_i64_unit_ops_ShrAssign_shr_assign_usize_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.usizeShr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.usizeShr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.usizeShr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _175: rt.u8 = rt.u8Rem(form, 3); + const _175: rs.u8 = rs.u8Rem(form, 3); if (_175 === 0) { - v = rt.usizeAdd(a, b); + v = rs.usizeAdd(a, b); } else if (_175 === 1) { - v = two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize((a016: rt.usize, a114: rt.usize): rt.usize => { - return rt.usizeAdd(a016, a114); + v = two$usize_ref_usize_usize_ops_Add_add_usize_ref_usize((a016: rs.usize, a114: rs.usize): rs.usize => { + return rs.usizeAdd(a016, a114); }, a, b); } else { - v = ((a015: rt.usize, a113: rt.usize): rt.usize => { - return rt.usizeAdd(a015, a113); + v = ((a015: rs.usize, a113: rs.usize): rs.usize => { + return rs.usizeAdd(a015, a113); })(a, b); } } else if (_30 === 25) { - const _181: rt.u8 = rt.u8Rem(form, 3); + const _181: rs.u8 = rs.u8Rem(form, 3); if (_181 === 0) { - v = rt.usizeSub(a, b); + v = rs.usizeSub(a, b); } else if (_181 === 1) { - v = two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize((a014: rt.usize, a112: rt.usize): rt.usize => { - return rt.usizeSub(a014, a112); + v = two$ref_usize_usize_usize_ops_Sub_sub_ref_usize_usize((a014: rs.usize, a112: rs.usize): rs.usize => { + return rs.usizeSub(a014, a112); }, a, b); } else { - v = ((a013: rt.usize, a111: rt.usize): rt.usize => { - return rt.usizeSub(a013, a111); + v = ((a013: rs.usize, a111: rs.usize): rs.usize => { + return rs.usizeSub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _187: rt.u8 = rt.u8Rem(form, 3); + const _187: rs.u8 = rs.u8Rem(form, 3); if (_187 === 0) { - v = rt.usizeMul(a, b); + v = rs.usizeMul(a, b); } else if (_187 === 1) { - v = two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize((a012: rt.usize, a110: rt.usize): rt.usize => { - return rt.usizeMul(a012, a110); + v = two$ref_usize_ref_usize_usize_ops_Mul_mul_ref_usize_ref_usize((a012: rs.usize, a110: rs.usize): rs.usize => { + return rs.usizeMul(a012, a110); }, a, b); } else { - v = ((a011: rt.usize, a19: rt.usize): rt.usize => { - return rt.usizeMul(a011, a19); + v = ((a011: rs.usize, a19: rs.usize): rs.usize => { + return rs.usizeMul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _196: rt.u8 = rt.u8Rem(form, 3); + const _196: rs.u8 = rs.u8Rem(form, 3); if (_196 === 0) { - v = rt.usizeShl(a, n & 0xff); + v = rs.usizeShl(a, n & 0xff); } else if (_196 === 1) { - v = two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8((a010: rt.usize, a18: rt.u8): rt.usize => { - return rt.usizeShl(a010, a18); + v = two$ref_usize_ref_u8_usize_ops_Shl_shl_ref_usize_ref_u8((a010: rs.usize, a18: rs.u8): rs.usize => { + return rs.usizeShl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.usize, a17: rt.u8): rt.usize => { - return rt.usizeShl(a09, a17); + v = ((a09: rs.usize, a17: rs.u8): rs.usize => { + return rs.usizeShl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _208: rt.u8 = rt.u8Rem(form, 3); + const _208: rs.u8 = rs.u8Rem(form, 3); if (_208 === 0) { v = ~a >>> 0; } else if (_208 === 1) { - v = one$ref_usize_usize_ops_Not_not_ref_usize((a08: rt.usize): rt.usize => { + v = one$ref_usize_usize_ops_Not_not_ref_usize((a08: rs.usize): rs.usize => { return ~a08 >>> 0; }, a); } else { - v = ((a07: rt.usize): rt.usize => { + v = ((a07: rs.usize): rs.usize => { return ~a07 >>> 0; })(a); } } else if (_30 === 29) { - let x11: rt.usize = a; - const _216: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.usize = a; + const _216: rs.u8 = rs.u8Rem(form, 3); if (_216 === 0) { - x11 = rt.usizeAdd(x11, b); + x11 = rs.usizeAdd(x11, b); } else if (_216 === 1) { - two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize((a06: rt.Place, a16: rt.usize): undefined => { - a06.v = rt.usizeAdd(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_usize_ref_usize_unit_ops_AddAssign_add_assign_usize_ref_usize((a06: rs.Place, a16: rs.usize): undefined => { + a06.v = rs.usizeAdd(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.usize): undefined => { - a05.v = rt.usizeAdd(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.usize): undefined => { + a05.v = rs.usizeAdd(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.usize = a; - const _227: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.usize = a; + const _227: rs.u8 = rs.u8Rem(form, 3); if (_227 === 0) { - x12 = rt.usizeDiv(x12, b); + x12 = rs.usizeDiv(x12, b); } else if (_227 === 1) { - two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize((a04: rt.Place, a14: rt.usize): undefined => { - a04.v = rt.usizeDiv(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_usize_ref_usize_unit_ops_DivAssign_div_assign_usize_ref_usize((a04: rs.Place, a14: rs.usize): undefined => { + a04.v = rs.usizeDiv(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.usize): undefined => { - a03.v = rt.usizeDiv(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.usize): undefined => { + a03.v = rs.usizeDiv(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.usize = a; - const _238: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.usize = a; + const _238: rs.u8 = rs.u8Rem(form, 3); if (_238 === 0) { - x13 = rt.usizeShr(x13, n & 0xffff); + x13 = rs.usizeShr(x13, n & 0xffff); } else if (_238 === 1) { - two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.usizeShr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_usize_ref_u16_unit_ops_ShrAssign_shr_assign_usize_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.usizeShr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.usizeShr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.usizeShr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -5317,495 +5317,495 @@ export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.i8; - let _87!: rt.i8; - const _28: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v3: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); +export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.i8; + let _87!: rs.i8; + const _28: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v3: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); }; - const take: (a0: rt.usize) => rt.i8 = (at: rt.usize): rt.i8 => { + const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.i8FromBeBytes(buf); + return rs.i8FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.i8, rt.i8] = [take(1), take(1 + 1)]; - const a: rt.i8 = _10[0]; - const b: rt.i8 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 1), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.i8, rs.i8] = [take(1), take(1 + 1)]; + const a: rs.i8 = _10[0]; + const b: rs.i8 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 1), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.i8Add(a, b); + v = rs.i8Add(a, b); } else if (_32 === 1) { - v = two$i8_i8_i8_ops_Add_add_i8_i8((a066: rt.i8, a158: rt.i8): rt.i8 => { - return rt.i8Add(a066, a158); + v = two$i8_i8_i8_ops_Add_add_i8_i8((a066: rs.i8, a158: rs.i8): rs.i8 => { + return rs.i8Add(a066, a158); }, a, b); } else { - v = ((a065: rt.i8, a157: rt.i8): rt.i8 => { - return rt.i8Add(a065, a157); + v = ((a065: rs.i8, a157: rs.i8): rs.i8 => { + return rs.i8Add(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.i8Sub(a, b); + v = rs.i8Sub(a, b); } else if (_35 === 1) { - v = two$i8_i8_i8_ops_Sub_sub_i8_i8((a064: rt.i8, a156: rt.i8): rt.i8 => { - return rt.i8Sub(a064, a156); + v = two$i8_i8_i8_ops_Sub_sub_i8_i8((a064: rs.i8, a156: rs.i8): rs.i8 => { + return rs.i8Sub(a064, a156); }, a, b); } else { - v = ((a063: rt.i8, a155: rt.i8): rt.i8 => { - return rt.i8Sub(a063, a155); + v = ((a063: rs.i8, a155: rs.i8): rs.i8 => { + return rs.i8Sub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.i8Mul(a, b); + v = rs.i8Mul(a, b); } else if (_38 === 1) { - v = two$i8_i8_i8_ops_Mul_mul_i8_i8((a062: rt.i8, a154: rt.i8): rt.i8 => { - return rt.i8Mul(a062, a154); + v = two$i8_i8_i8_ops_Mul_mul_i8_i8((a062: rs.i8, a154: rs.i8): rs.i8 => { + return rs.i8Mul(a062, a154); }, a, b); } else { - v = ((a061: rt.i8, a153: rt.i8): rt.i8 => { - return rt.i8Mul(a061, a153); + v = ((a061: rs.i8, a153: rs.i8): rs.i8 => { + return rs.i8Mul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.i8Div(a, b); + v = rs.i8Div(a, b); } else if (_41 === 1) { - v = two$i8_i8_i8_ops_Div_div_i8_i8((a060: rt.i8, a152: rt.i8): rt.i8 => { - return rt.i8Div(a060, a152); + v = two$i8_i8_i8_ops_Div_div_i8_i8((a060: rs.i8, a152: rs.i8): rs.i8 => { + return rs.i8Div(a060, a152); }, a, b); } else { - v = ((a059: rt.i8, a151: rt.i8): rt.i8 => { - return rt.i8Div(a059, a151); + v = ((a059: rs.i8, a151: rs.i8): rs.i8 => { + return rs.i8Div(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.i8Rem(a, b); + v = rs.i8Rem(a, b); } else if (_44 === 1) { - v = two$i8_i8_i8_ops_Rem_rem_i8_i8((a058: rt.i8, a150: rt.i8): rt.i8 => { - return rt.i8Rem(a058, a150); + v = two$i8_i8_i8_ops_Rem_rem_i8_i8((a058: rs.i8, a150: rs.i8): rs.i8 => { + return rs.i8Rem(a058, a150); }, a, b); } else { - v = ((a057: rt.i8, a149: rt.i8): rt.i8 => { - return rt.i8Rem(a057, a149); + v = ((a057: rs.i8, a149: rs.i8): rs.i8 => { + return rs.i8Rem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$i8_i8_i8_ops_BitAnd_bitand_i8_i8((a056: rt.i8, a148: rt.i8): rt.i8 => { + v = two$i8_i8_i8_ops_BitAnd_bitand_i8_i8((a056: rs.i8, a148: rs.i8): rs.i8 => { return a056 & a148; }, a, b); } else { - v = ((a055: rt.i8, a147: rt.i8): rt.i8 => { + v = ((a055: rs.i8, a147: rs.i8): rs.i8 => { return a055 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$i8_i8_i8_ops_BitOr_bitor_i8_i8((a054: rt.i8, a146: rt.i8): rt.i8 => { + v = two$i8_i8_i8_ops_BitOr_bitor_i8_i8((a054: rs.i8, a146: rs.i8): rs.i8 => { return a054 | a146; }, a, b); } else { - v = ((a053: rt.i8, a145: rt.i8): rt.i8 => { + v = ((a053: rs.i8, a145: rs.i8): rs.i8 => { return a053 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$i8_i8_i8_ops_BitXor_bitxor_i8_i8((a052: rt.i8, a144: rt.i8): rt.i8 => { + v = two$i8_i8_i8_ops_BitXor_bitxor_i8_i8((a052: rs.i8, a144: rs.i8): rs.i8 => { return a052 ^ a144; }, a, b); } else { - v = ((a051: rt.i8, a143: rt.i8): rt.i8 => { + v = ((a051: rs.i8, a143: rs.i8): rs.i8 => { return a051 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.i8Shl(a, n); + v = rs.i8Shl(a, n); } else if (_56 === 1) { - v = two$i8_u32_i8_ops_Shl_shl_i8_u32((a050: rt.i8, a142: rt.u32): rt.i8 => { - return rt.i8Shl(a050, a142); + v = two$i8_u32_i8_ops_Shl_shl_i8_u32((a050: rs.i8, a142: rs.u32): rs.i8 => { + return rs.i8Shl(a050, a142); }, a, n); } else { - v = ((a049: rt.i8, a141: rt.u32): rt.i8 => { - return rt.i8Shl(a049, a141); + v = ((a049: rs.i8, a141: rs.u32): rs.i8 => { + return rs.i8Shl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.i8Shr(a, n); + v = rs.i8Shr(a, n); } else if (_59 === 1) { - v = two$i8_u32_i8_ops_Shr_shr_i8_u32((a048: rt.i8, a140: rt.u32): rt.i8 => { - return rt.i8Shr(a048, a140); + v = two$i8_u32_i8_ops_Shr_shr_i8_u32((a048: rs.i8, a140: rs.u32): rs.i8 => { + return rs.i8Shr(a048, a140); }, a, n); } else { - v = ((a047: rt.i8, a139: rt.u32): rt.i8 => { - return rt.i8Shr(a047, a139); + v = ((a047: rs.i8, a139: rs.u32): rs.i8 => { + return rs.i8Shr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.i8Shl(a, (n << 16) >> 16); + v = rs.i8Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$i8_i16_i8_ops_Shl_shl_i8_i16((a046: rt.i8, a138: rt.i16): rt.i8 => { - return rt.i8Shl(a046, a138); + v = two$i8_i16_i8_ops_Shl_shl_i8_i16((a046: rs.i8, a138: rs.i16): rs.i8 => { + return rs.i8Shl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.i8, a137: rt.i16): rt.i8 => { - return rt.i8Shl(a045, a137); + v = ((a045: rs.i8, a137: rs.i16): rs.i8 => { + return rs.i8Shl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.i8Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.i8Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$i8_u128_i8_ops_Shr_shr_i8_u128((a044: rt.i8, a136: rt.u128): rt.i8 => { - return rt.i8Shr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$i8_u128_i8_ops_Shr_shr_i8_u128((a044: rs.i8, a136: rs.u128): rs.i8 => { + return rs.i8Shr(a044, a136); }, a, _74); } else { - v = ((a043: rt.i8, a135: rt.u128): rt.i8 => { - return rt.i8Shr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.i8, a135: rs.u128): rs.i8 => { + return rs.i8Shr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a; } else if (_83 === 1) { - v = one$i8_i8_ops_Not_not_i8((a042: rt.i8): rt.i8 => { + v = one$i8_i8_ops_Not_not_i8((a042: rs.i8): rs.i8 => { return ~a042; }, a); } else { - v = ((a041: rt.i8): rt.i8 => { + v = ((a041: rs.i8): rs.i8 => { return ~a041; })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.i8Neg(a); + _87 = rs.i8Neg(a); } else if (_92 === 1) { - _87 = one$i8_i8_ops_Neg_neg_i8((a040: rt.i8): rt.i8 => { - return rt.i8Neg(a040); + _87 = one$i8_i8_ops_Neg_neg_i8((a040: rs.i8): rs.i8 => { + return rs.i8Neg(a040); }, a); } else { - _87 = ((a039: rt.i8): rt.i8 => { - return rt.i8Neg(a039); + _87 = ((a039: rs.i8): rs.i8 => { + return rs.i8Neg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.i8Neg(a); + _87 = rs.i8Neg(a); } else if (_95 === 1) { - _87 = one$ref_i8_i8_ops_Neg_neg_ref_i8((a038: rt.i8): rt.i8 => { - return rt.i8Neg(a038); + _87 = one$ref_i8_i8_ops_Neg_neg_ref_i8((a038: rs.i8): rs.i8 => { + return rs.i8Neg(a038); }, a); } else { - _87 = ((a037: rt.i8): rt.i8 => { - return rt.i8Neg(a037); + _87 = ((a037: rs.i8): rs.i8 => { + return rs.i8Neg(a037); })(a); } } - const _86: rt.i8 | undefined = _87; + const _86: rs.i8 | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.i8 = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.i8 = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.i8Add(x, b); + x = rs.i8Add(x, b); } else if (_105 === 1) { - two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8((a036: rt.Place, a134: rt.i8): undefined => { - a036.v = rt.i8Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_i8_i8_unit_ops_AddAssign_add_assign_i8_i8((a036: rs.Place, a134: rs.i8): undefined => { + a036.v = rs.i8Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.i8): undefined => { - a035.v = rt.i8Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.i8): undefined => { + a035.v = rs.i8Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.i8 = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.i8 = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.i8Sub(x2, b); + x2 = rs.i8Sub(x2, b); } else if (_113 === 1) { - two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8((a034: rt.Place, a132: rt.i8): undefined => { - a034.v = rt.i8Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_i8_i8_unit_ops_SubAssign_sub_assign_i8_i8((a034: rs.Place, a132: rs.i8): undefined => { + a034.v = rs.i8Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.i8): undefined => { - a033.v = rt.i8Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.i8): undefined => { + a033.v = rs.i8Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.i8 = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.i8 = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.i8Mul(x3, b); + x3 = rs.i8Mul(x3, b); } else if (_121 === 1) { - two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8((a032: rt.Place, a130: rt.i8): undefined => { - a032.v = rt.i8Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_i8_i8_unit_ops_MulAssign_mul_assign_i8_i8((a032: rs.Place, a130: rs.i8): undefined => { + a032.v = rs.i8Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.i8): undefined => { - a031.v = rt.i8Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.i8): undefined => { + a031.v = rs.i8Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.i8 = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.i8 = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.i8Div(x4, b); + x4 = rs.i8Div(x4, b); } else if (_129 === 1) { - two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8((a030: rt.Place, a128: rt.i8): undefined => { - a030.v = rt.i8Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_i8_i8_unit_ops_DivAssign_div_assign_i8_i8((a030: rs.Place, a128: rs.i8): undefined => { + a030.v = rs.i8Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.i8): undefined => { - a029.v = rt.i8Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.i8): undefined => { + a029.v = rs.i8Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.i8 = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.i8 = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.i8Rem(x5, b); + x5 = rs.i8Rem(x5, b); } else if (_137 === 1) { - two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8((a028: rt.Place, a126: rt.i8): undefined => { - a028.v = rt.i8Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_i8_i8_unit_ops_RemAssign_rem_assign_i8_i8((a028: rs.Place, a126: rs.i8): undefined => { + a028.v = rs.i8Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.i8): undefined => { - a027.v = rt.i8Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.i8): undefined => { + a027.v = rs.i8Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.i8 = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.i8 = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { x6 = x6 & b; } else if (_145 === 1) { - two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8((a026: rt.Place, a124: rt.i8): undefined => { + two$mut_i8_i8_unit_ops_BitAndAssign_bitand_assign_i8_i8((a026: rs.Place, a124: rs.i8): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.i8): undefined => { + ((a025: rs.Place, a123: rs.i8): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.i8 = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.i8 = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { x7 = x7 | b; } else if (_153 === 1) { - two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8((a024: rt.Place, a122: rt.i8): undefined => { + two$mut_i8_i8_unit_ops_BitOrAssign_bitor_assign_i8_i8((a024: rs.Place, a122: rs.i8): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.i8): undefined => { + ((a023: rs.Place, a121: rs.i8): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.i8 = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.i8 = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { x8 = x8 ^ b; } else if (_161 === 1) { - two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8((a022: rt.Place, a120: rt.i8): undefined => { + two$mut_i8_i8_unit_ops_BitXorAssign_bitxor_assign_i8_i8((a022: rs.Place, a120: rs.i8): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.i8): undefined => { + ((a021: rs.Place, a119: rs.i8): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.i8 = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.i8 = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.i8Shl(x9, n); + x9 = rs.i8Shl(x9, n); } else if (_169 === 1) { - two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.i8Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_i8_u32_unit_ops_ShlAssign_shl_assign_i8_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.i8Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.i8Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.i8Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.i8 = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.i8 = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.i8Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.i8Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.i8Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_i8_i64_unit_ops_ShrAssign_shr_assign_i8_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.i8Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.i8Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.i8Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.i8Add(a, b); + v = rs.i8Add(a, b); } else if (_189 === 1) { - v = two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8((a016: rt.i8, a114: rt.i8): rt.i8 => { - return rt.i8Add(a016, a114); + v = two$i8_ref_i8_i8_ops_Add_add_i8_ref_i8((a016: rs.i8, a114: rs.i8): rs.i8 => { + return rs.i8Add(a016, a114); }, a, b); } else { - v = ((a015: rt.i8, a113: rt.i8): rt.i8 => { - return rt.i8Add(a015, a113); + v = ((a015: rs.i8, a113: rs.i8): rs.i8 => { + return rs.i8Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.i8Sub(a, b); + v = rs.i8Sub(a, b); } else if (_195 === 1) { - v = two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8((a014: rt.i8, a112: rt.i8): rt.i8 => { - return rt.i8Sub(a014, a112); + v = two$ref_i8_i8_i8_ops_Sub_sub_ref_i8_i8((a014: rs.i8, a112: rs.i8): rs.i8 => { + return rs.i8Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.i8, a111: rt.i8): rt.i8 => { - return rt.i8Sub(a013, a111); + v = ((a013: rs.i8, a111: rs.i8): rs.i8 => { + return rs.i8Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.i8Mul(a, b); + v = rs.i8Mul(a, b); } else if (_201 === 1) { - v = two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8((a012: rt.i8, a110: rt.i8): rt.i8 => { - return rt.i8Mul(a012, a110); + v = two$ref_i8_ref_i8_i8_ops_Mul_mul_ref_i8_ref_i8((a012: rs.i8, a110: rs.i8): rs.i8 => { + return rs.i8Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.i8, a19: rt.i8): rt.i8 => { - return rt.i8Mul(a011, a19); + v = ((a011: rs.i8, a19: rs.i8): rs.i8 => { + return rs.i8Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.i8Shl(a, n & 0xff); + v = rs.i8Shl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8((a010: rt.i8, a18: rt.u8): rt.i8 => { - return rt.i8Shl(a010, a18); + v = two$ref_i8_ref_u8_i8_ops_Shl_shl_ref_i8_ref_u8((a010: rs.i8, a18: rs.u8): rs.i8 => { + return rs.i8Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.i8, a17: rt.u8): rt.i8 => { - return rt.i8Shl(a09, a17); + v = ((a09: rs.i8, a17: rs.u8): rs.i8 => { + return rs.i8Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { v = ~a; } else if (_222 === 1) { - v = one$ref_i8_i8_ops_Not_not_ref_i8((a08: rt.i8): rt.i8 => { + v = one$ref_i8_i8_ops_Not_not_ref_i8((a08: rs.i8): rs.i8 => { return ~a08; }, a); } else { - v = ((a07: rt.i8): rt.i8 => { + v = ((a07: rs.i8): rs.i8 => { return ~a07; })(a); } } else if (_30 === 29) { - let x11: rt.i8 = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.i8 = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.i8Add(x11, b); + x11 = rs.i8Add(x11, b); } else if (_230 === 1) { - two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8((a06: rt.Place, a16: rt.i8): undefined => { - a06.v = rt.i8Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_i8_ref_i8_unit_ops_AddAssign_add_assign_i8_ref_i8((a06: rs.Place, a16: rs.i8): undefined => { + a06.v = rs.i8Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.i8): undefined => { - a05.v = rt.i8Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.i8): undefined => { + a05.v = rs.i8Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.i8 = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.i8 = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.i8Div(x12, b); + x12 = rs.i8Div(x12, b); } else if (_241 === 1) { - two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8((a04: rt.Place, a14: rt.i8): undefined => { - a04.v = rt.i8Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_i8_ref_i8_unit_ops_DivAssign_div_assign_i8_ref_i8((a04: rs.Place, a14: rs.i8): undefined => { + a04.v = rs.i8Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.i8): undefined => { - a03.v = rt.i8Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.i8): undefined => { + a03.v = rs.i8Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.i8 = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.i8 = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.i8Shr(x13, n & 0xffff); + x13 = rs.i8Shr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.i8Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_i8_ref_u16_unit_ops_ShrAssign_shr_assign_i8_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.i8Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i8Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i8Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -5817,495 +5817,495 @@ export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.i16; - let _87!: rt.i16; - const _28: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v3: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); +export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.i16; + let _87!: rs.i16; + const _28: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v3: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); }; - const take: (a0: rt.usize) => rt.i16 = (at: rt.usize): rt.i16 => { - const buf: Uint8Array = rt.bytes(2); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { + const buf: Uint8Array = rs.bytes(2); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.i16FromBeBytes(buf); + return rs.i16FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.i16, rt.i16] = [take(1), take(1 + 2)]; - const a: rt.i16 = _10[0]; - const b: rt.i16 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 2), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.i16, rs.i16] = [take(1), take(1 + 2)]; + const a: rs.i16 = _10[0]; + const b: rs.i16 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 2), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.i16Add(a, b); + v = rs.i16Add(a, b); } else if (_32 === 1) { - v = two$i16_i16_i16_ops_Add_add_i16_i16((a066: rt.i16, a158: rt.i16): rt.i16 => { - return rt.i16Add(a066, a158); + v = two$i16_i16_i16_ops_Add_add_i16_i16((a066: rs.i16, a158: rs.i16): rs.i16 => { + return rs.i16Add(a066, a158); }, a, b); } else { - v = ((a065: rt.i16, a157: rt.i16): rt.i16 => { - return rt.i16Add(a065, a157); + v = ((a065: rs.i16, a157: rs.i16): rs.i16 => { + return rs.i16Add(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.i16Sub(a, b); + v = rs.i16Sub(a, b); } else if (_35 === 1) { - v = two$i16_i16_i16_ops_Sub_sub_i16_i16((a064: rt.i16, a156: rt.i16): rt.i16 => { - return rt.i16Sub(a064, a156); + v = two$i16_i16_i16_ops_Sub_sub_i16_i16((a064: rs.i16, a156: rs.i16): rs.i16 => { + return rs.i16Sub(a064, a156); }, a, b); } else { - v = ((a063: rt.i16, a155: rt.i16): rt.i16 => { - return rt.i16Sub(a063, a155); + v = ((a063: rs.i16, a155: rs.i16): rs.i16 => { + return rs.i16Sub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.i16Mul(a, b); + v = rs.i16Mul(a, b); } else if (_38 === 1) { - v = two$i16_i16_i16_ops_Mul_mul_i16_i16((a062: rt.i16, a154: rt.i16): rt.i16 => { - return rt.i16Mul(a062, a154); + v = two$i16_i16_i16_ops_Mul_mul_i16_i16((a062: rs.i16, a154: rs.i16): rs.i16 => { + return rs.i16Mul(a062, a154); }, a, b); } else { - v = ((a061: rt.i16, a153: rt.i16): rt.i16 => { - return rt.i16Mul(a061, a153); + v = ((a061: rs.i16, a153: rs.i16): rs.i16 => { + return rs.i16Mul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.i16Div(a, b); + v = rs.i16Div(a, b); } else if (_41 === 1) { - v = two$i16_i16_i16_ops_Div_div_i16_i16((a060: rt.i16, a152: rt.i16): rt.i16 => { - return rt.i16Div(a060, a152); + v = two$i16_i16_i16_ops_Div_div_i16_i16((a060: rs.i16, a152: rs.i16): rs.i16 => { + return rs.i16Div(a060, a152); }, a, b); } else { - v = ((a059: rt.i16, a151: rt.i16): rt.i16 => { - return rt.i16Div(a059, a151); + v = ((a059: rs.i16, a151: rs.i16): rs.i16 => { + return rs.i16Div(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.i16Rem(a, b); + v = rs.i16Rem(a, b); } else if (_44 === 1) { - v = two$i16_i16_i16_ops_Rem_rem_i16_i16((a058: rt.i16, a150: rt.i16): rt.i16 => { - return rt.i16Rem(a058, a150); + v = two$i16_i16_i16_ops_Rem_rem_i16_i16((a058: rs.i16, a150: rs.i16): rs.i16 => { + return rs.i16Rem(a058, a150); }, a, b); } else { - v = ((a057: rt.i16, a149: rt.i16): rt.i16 => { - return rt.i16Rem(a057, a149); + v = ((a057: rs.i16, a149: rs.i16): rs.i16 => { + return rs.i16Rem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$i16_i16_i16_ops_BitAnd_bitand_i16_i16((a056: rt.i16, a148: rt.i16): rt.i16 => { + v = two$i16_i16_i16_ops_BitAnd_bitand_i16_i16((a056: rs.i16, a148: rs.i16): rs.i16 => { return a056 & a148; }, a, b); } else { - v = ((a055: rt.i16, a147: rt.i16): rt.i16 => { + v = ((a055: rs.i16, a147: rs.i16): rs.i16 => { return a055 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$i16_i16_i16_ops_BitOr_bitor_i16_i16((a054: rt.i16, a146: rt.i16): rt.i16 => { + v = two$i16_i16_i16_ops_BitOr_bitor_i16_i16((a054: rs.i16, a146: rs.i16): rs.i16 => { return a054 | a146; }, a, b); } else { - v = ((a053: rt.i16, a145: rt.i16): rt.i16 => { + v = ((a053: rs.i16, a145: rs.i16): rs.i16 => { return a053 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$i16_i16_i16_ops_BitXor_bitxor_i16_i16((a052: rt.i16, a144: rt.i16): rt.i16 => { + v = two$i16_i16_i16_ops_BitXor_bitxor_i16_i16((a052: rs.i16, a144: rs.i16): rs.i16 => { return a052 ^ a144; }, a, b); } else { - v = ((a051: rt.i16, a143: rt.i16): rt.i16 => { + v = ((a051: rs.i16, a143: rs.i16): rs.i16 => { return a051 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.i16Shl(a, n); + v = rs.i16Shl(a, n); } else if (_56 === 1) { - v = two$i16_u32_i16_ops_Shl_shl_i16_u32((a050: rt.i16, a142: rt.u32): rt.i16 => { - return rt.i16Shl(a050, a142); + v = two$i16_u32_i16_ops_Shl_shl_i16_u32((a050: rs.i16, a142: rs.u32): rs.i16 => { + return rs.i16Shl(a050, a142); }, a, n); } else { - v = ((a049: rt.i16, a141: rt.u32): rt.i16 => { - return rt.i16Shl(a049, a141); + v = ((a049: rs.i16, a141: rs.u32): rs.i16 => { + return rs.i16Shl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.i16Shr(a, n); + v = rs.i16Shr(a, n); } else if (_59 === 1) { - v = two$i16_u32_i16_ops_Shr_shr_i16_u32((a048: rt.i16, a140: rt.u32): rt.i16 => { - return rt.i16Shr(a048, a140); + v = two$i16_u32_i16_ops_Shr_shr_i16_u32((a048: rs.i16, a140: rs.u32): rs.i16 => { + return rs.i16Shr(a048, a140); }, a, n); } else { - v = ((a047: rt.i16, a139: rt.u32): rt.i16 => { - return rt.i16Shr(a047, a139); + v = ((a047: rs.i16, a139: rs.u32): rs.i16 => { + return rs.i16Shr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.i16Shl(a, (n << 16) >> 16); + v = rs.i16Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$i16_i16_i16_ops_Shl_shl_i16_i16((a046: rt.i16, a138: rt.i16): rt.i16 => { - return rt.i16Shl(a046, a138); + v = two$i16_i16_i16_ops_Shl_shl_i16_i16((a046: rs.i16, a138: rs.i16): rs.i16 => { + return rs.i16Shl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.i16, a137: rt.i16): rt.i16 => { - return rt.i16Shl(a045, a137); + v = ((a045: rs.i16, a137: rs.i16): rs.i16 => { + return rs.i16Shl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.i16Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.i16Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$i16_u128_i16_ops_Shr_shr_i16_u128((a044: rt.i16, a136: rt.u128): rt.i16 => { - return rt.i16Shr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$i16_u128_i16_ops_Shr_shr_i16_u128((a044: rs.i16, a136: rs.u128): rs.i16 => { + return rs.i16Shr(a044, a136); }, a, _74); } else { - v = ((a043: rt.i16, a135: rt.u128): rt.i16 => { - return rt.i16Shr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.i16, a135: rs.u128): rs.i16 => { + return rs.i16Shr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a; } else if (_83 === 1) { - v = one$i16_i16_ops_Not_not_i16((a042: rt.i16): rt.i16 => { + v = one$i16_i16_ops_Not_not_i16((a042: rs.i16): rs.i16 => { return ~a042; }, a); } else { - v = ((a041: rt.i16): rt.i16 => { + v = ((a041: rs.i16): rs.i16 => { return ~a041; })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.i16Neg(a); + _87 = rs.i16Neg(a); } else if (_92 === 1) { - _87 = one$i16_i16_ops_Neg_neg_i16((a040: rt.i16): rt.i16 => { - return rt.i16Neg(a040); + _87 = one$i16_i16_ops_Neg_neg_i16((a040: rs.i16): rs.i16 => { + return rs.i16Neg(a040); }, a); } else { - _87 = ((a039: rt.i16): rt.i16 => { - return rt.i16Neg(a039); + _87 = ((a039: rs.i16): rs.i16 => { + return rs.i16Neg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.i16Neg(a); + _87 = rs.i16Neg(a); } else if (_95 === 1) { - _87 = one$ref_i16_i16_ops_Neg_neg_ref_i16((a038: rt.i16): rt.i16 => { - return rt.i16Neg(a038); + _87 = one$ref_i16_i16_ops_Neg_neg_ref_i16((a038: rs.i16): rs.i16 => { + return rs.i16Neg(a038); }, a); } else { - _87 = ((a037: rt.i16): rt.i16 => { - return rt.i16Neg(a037); + _87 = ((a037: rs.i16): rs.i16 => { + return rs.i16Neg(a037); })(a); } } - const _86: rt.i16 | undefined = _87; + const _86: rs.i16 | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.i16 = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.i16 = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.i16Add(x, b); + x = rs.i16Add(x, b); } else if (_105 === 1) { - two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16((a036: rt.Place, a134: rt.i16): undefined => { - a036.v = rt.i16Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_i16_i16_unit_ops_AddAssign_add_assign_i16_i16((a036: rs.Place, a134: rs.i16): undefined => { + a036.v = rs.i16Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.i16): undefined => { - a035.v = rt.i16Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.i16): undefined => { + a035.v = rs.i16Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.i16 = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.i16 = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.i16Sub(x2, b); + x2 = rs.i16Sub(x2, b); } else if (_113 === 1) { - two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16((a034: rt.Place, a132: rt.i16): undefined => { - a034.v = rt.i16Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_i16_i16_unit_ops_SubAssign_sub_assign_i16_i16((a034: rs.Place, a132: rs.i16): undefined => { + a034.v = rs.i16Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.i16): undefined => { - a033.v = rt.i16Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.i16): undefined => { + a033.v = rs.i16Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.i16 = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.i16 = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.i16Mul(x3, b); + x3 = rs.i16Mul(x3, b); } else if (_121 === 1) { - two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16((a032: rt.Place, a130: rt.i16): undefined => { - a032.v = rt.i16Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_i16_i16_unit_ops_MulAssign_mul_assign_i16_i16((a032: rs.Place, a130: rs.i16): undefined => { + a032.v = rs.i16Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.i16): undefined => { - a031.v = rt.i16Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.i16): undefined => { + a031.v = rs.i16Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.i16 = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.i16 = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.i16Div(x4, b); + x4 = rs.i16Div(x4, b); } else if (_129 === 1) { - two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16((a030: rt.Place, a128: rt.i16): undefined => { - a030.v = rt.i16Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_i16_i16_unit_ops_DivAssign_div_assign_i16_i16((a030: rs.Place, a128: rs.i16): undefined => { + a030.v = rs.i16Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.i16): undefined => { - a029.v = rt.i16Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.i16): undefined => { + a029.v = rs.i16Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.i16 = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.i16 = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.i16Rem(x5, b); + x5 = rs.i16Rem(x5, b); } else if (_137 === 1) { - two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16((a028: rt.Place, a126: rt.i16): undefined => { - a028.v = rt.i16Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_i16_i16_unit_ops_RemAssign_rem_assign_i16_i16((a028: rs.Place, a126: rs.i16): undefined => { + a028.v = rs.i16Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.i16): undefined => { - a027.v = rt.i16Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.i16): undefined => { + a027.v = rs.i16Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.i16 = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.i16 = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { x6 = x6 & b; } else if (_145 === 1) { - two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16((a026: rt.Place, a124: rt.i16): undefined => { + two$mut_i16_i16_unit_ops_BitAndAssign_bitand_assign_i16_i16((a026: rs.Place, a124: rs.i16): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.i16): undefined => { + ((a025: rs.Place, a123: rs.i16): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.i16 = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.i16 = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { x7 = x7 | b; } else if (_153 === 1) { - two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16((a024: rt.Place, a122: rt.i16): undefined => { + two$mut_i16_i16_unit_ops_BitOrAssign_bitor_assign_i16_i16((a024: rs.Place, a122: rs.i16): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.i16): undefined => { + ((a023: rs.Place, a121: rs.i16): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.i16 = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.i16 = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { x8 = x8 ^ b; } else if (_161 === 1) { - two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16((a022: rt.Place, a120: rt.i16): undefined => { + two$mut_i16_i16_unit_ops_BitXorAssign_bitxor_assign_i16_i16((a022: rs.Place, a120: rs.i16): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.i16): undefined => { + ((a021: rs.Place, a119: rs.i16): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.i16 = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.i16 = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.i16Shl(x9, n); + x9 = rs.i16Shl(x9, n); } else if (_169 === 1) { - two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.i16Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_i16_u32_unit_ops_ShlAssign_shl_assign_i16_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.i16Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.i16Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.i16Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.i16 = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.i16 = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.i16Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.i16Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.i16Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_i16_i64_unit_ops_ShrAssign_shr_assign_i16_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.i16Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.i16Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.i16Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.i16Add(a, b); + v = rs.i16Add(a, b); } else if (_189 === 1) { - v = two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16((a016: rt.i16, a114: rt.i16): rt.i16 => { - return rt.i16Add(a016, a114); + v = two$i16_ref_i16_i16_ops_Add_add_i16_ref_i16((a016: rs.i16, a114: rs.i16): rs.i16 => { + return rs.i16Add(a016, a114); }, a, b); } else { - v = ((a015: rt.i16, a113: rt.i16): rt.i16 => { - return rt.i16Add(a015, a113); + v = ((a015: rs.i16, a113: rs.i16): rs.i16 => { + return rs.i16Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.i16Sub(a, b); + v = rs.i16Sub(a, b); } else if (_195 === 1) { - v = two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16((a014: rt.i16, a112: rt.i16): rt.i16 => { - return rt.i16Sub(a014, a112); + v = two$ref_i16_i16_i16_ops_Sub_sub_ref_i16_i16((a014: rs.i16, a112: rs.i16): rs.i16 => { + return rs.i16Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.i16, a111: rt.i16): rt.i16 => { - return rt.i16Sub(a013, a111); + v = ((a013: rs.i16, a111: rs.i16): rs.i16 => { + return rs.i16Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.i16Mul(a, b); + v = rs.i16Mul(a, b); } else if (_201 === 1) { - v = two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16((a012: rt.i16, a110: rt.i16): rt.i16 => { - return rt.i16Mul(a012, a110); + v = two$ref_i16_ref_i16_i16_ops_Mul_mul_ref_i16_ref_i16((a012: rs.i16, a110: rs.i16): rs.i16 => { + return rs.i16Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.i16, a19: rt.i16): rt.i16 => { - return rt.i16Mul(a011, a19); + v = ((a011: rs.i16, a19: rs.i16): rs.i16 => { + return rs.i16Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.i16Shl(a, n & 0xff); + v = rs.i16Shl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8((a010: rt.i16, a18: rt.u8): rt.i16 => { - return rt.i16Shl(a010, a18); + v = two$ref_i16_ref_u8_i16_ops_Shl_shl_ref_i16_ref_u8((a010: rs.i16, a18: rs.u8): rs.i16 => { + return rs.i16Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.i16, a17: rt.u8): rt.i16 => { - return rt.i16Shl(a09, a17); + v = ((a09: rs.i16, a17: rs.u8): rs.i16 => { + return rs.i16Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { v = ~a; } else if (_222 === 1) { - v = one$ref_i16_i16_ops_Not_not_ref_i16((a08: rt.i16): rt.i16 => { + v = one$ref_i16_i16_ops_Not_not_ref_i16((a08: rs.i16): rs.i16 => { return ~a08; }, a); } else { - v = ((a07: rt.i16): rt.i16 => { + v = ((a07: rs.i16): rs.i16 => { return ~a07; })(a); } } else if (_30 === 29) { - let x11: rt.i16 = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.i16 = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.i16Add(x11, b); + x11 = rs.i16Add(x11, b); } else if (_230 === 1) { - two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16((a06: rt.Place, a16: rt.i16): undefined => { - a06.v = rt.i16Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_i16_ref_i16_unit_ops_AddAssign_add_assign_i16_ref_i16((a06: rs.Place, a16: rs.i16): undefined => { + a06.v = rs.i16Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.i16): undefined => { - a05.v = rt.i16Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.i16): undefined => { + a05.v = rs.i16Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.i16 = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.i16 = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.i16Div(x12, b); + x12 = rs.i16Div(x12, b); } else if (_241 === 1) { - two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16((a04: rt.Place, a14: rt.i16): undefined => { - a04.v = rt.i16Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_i16_ref_i16_unit_ops_DivAssign_div_assign_i16_ref_i16((a04: rs.Place, a14: rs.i16): undefined => { + a04.v = rs.i16Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.i16): undefined => { - a03.v = rt.i16Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.i16): undefined => { + a03.v = rs.i16Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.i16 = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.i16 = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.i16Shr(x13, n & 0xffff); + x13 = rs.i16Shr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.i16Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_i16_ref_u16_unit_ops_ShrAssign_shr_assign_i16_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.i16Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i16Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i16Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -6317,495 +6317,495 @@ export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.i32; - let _87!: rt.i32; - const _28: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v3: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); +export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.i32; + let _87!: rs.i32; + const _28: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v3: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); }; - const take: (a0: rt.usize) => rt.i32 = (at: rt.usize): rt.i32 => { - const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { + const buf: Uint8Array = rs.bytes(4); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.i32FromBeBytes(buf); + return rs.i32FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.i32, rt.i32] = [take(1), take(1 + 4)]; - const a: rt.i32 = _10[0]; - const b: rt.i32 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.i32, rs.i32] = [take(1), take(1 + 4)]; + const a: rs.i32 = _10[0]; + const b: rs.i32 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 4), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.i32Add(a, b); + v = rs.i32Add(a, b); } else if (_32 === 1) { - v = two$i32_i32_i32_ops_Add_add_i32_i32((a066: rt.i32, a158: rt.i32): rt.i32 => { - return rt.i32Add(a066, a158); + v = two$i32_i32_i32_ops_Add_add_i32_i32((a066: rs.i32, a158: rs.i32): rs.i32 => { + return rs.i32Add(a066, a158); }, a, b); } else { - v = ((a065: rt.i32, a157: rt.i32): rt.i32 => { - return rt.i32Add(a065, a157); + v = ((a065: rs.i32, a157: rs.i32): rs.i32 => { + return rs.i32Add(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.i32Sub(a, b); + v = rs.i32Sub(a, b); } else if (_35 === 1) { - v = two$i32_i32_i32_ops_Sub_sub_i32_i32((a064: rt.i32, a156: rt.i32): rt.i32 => { - return rt.i32Sub(a064, a156); + v = two$i32_i32_i32_ops_Sub_sub_i32_i32((a064: rs.i32, a156: rs.i32): rs.i32 => { + return rs.i32Sub(a064, a156); }, a, b); } else { - v = ((a063: rt.i32, a155: rt.i32): rt.i32 => { - return rt.i32Sub(a063, a155); + v = ((a063: rs.i32, a155: rs.i32): rs.i32 => { + return rs.i32Sub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.i32Mul(a, b); + v = rs.i32Mul(a, b); } else if (_38 === 1) { - v = two$i32_i32_i32_ops_Mul_mul_i32_i32((a062: rt.i32, a154: rt.i32): rt.i32 => { - return rt.i32Mul(a062, a154); + v = two$i32_i32_i32_ops_Mul_mul_i32_i32((a062: rs.i32, a154: rs.i32): rs.i32 => { + return rs.i32Mul(a062, a154); }, a, b); } else { - v = ((a061: rt.i32, a153: rt.i32): rt.i32 => { - return rt.i32Mul(a061, a153); + v = ((a061: rs.i32, a153: rs.i32): rs.i32 => { + return rs.i32Mul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.i32Div(a, b); + v = rs.i32Div(a, b); } else if (_41 === 1) { - v = two$i32_i32_i32_ops_Div_div_i32_i32((a060: rt.i32, a152: rt.i32): rt.i32 => { - return rt.i32Div(a060, a152); + v = two$i32_i32_i32_ops_Div_div_i32_i32((a060: rs.i32, a152: rs.i32): rs.i32 => { + return rs.i32Div(a060, a152); }, a, b); } else { - v = ((a059: rt.i32, a151: rt.i32): rt.i32 => { - return rt.i32Div(a059, a151); + v = ((a059: rs.i32, a151: rs.i32): rs.i32 => { + return rs.i32Div(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.i32Rem(a, b); + v = rs.i32Rem(a, b); } else if (_44 === 1) { - v = two$i32_i32_i32_ops_Rem_rem_i32_i32((a058: rt.i32, a150: rt.i32): rt.i32 => { - return rt.i32Rem(a058, a150); + v = two$i32_i32_i32_ops_Rem_rem_i32_i32((a058: rs.i32, a150: rs.i32): rs.i32 => { + return rs.i32Rem(a058, a150); }, a, b); } else { - v = ((a057: rt.i32, a149: rt.i32): rt.i32 => { - return rt.i32Rem(a057, a149); + v = ((a057: rs.i32, a149: rs.i32): rs.i32 => { + return rs.i32Rem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$i32_i32_i32_ops_BitAnd_bitand_i32_i32((a056: rt.i32, a148: rt.i32): rt.i32 => { + v = two$i32_i32_i32_ops_BitAnd_bitand_i32_i32((a056: rs.i32, a148: rs.i32): rs.i32 => { return a056 & a148; }, a, b); } else { - v = ((a055: rt.i32, a147: rt.i32): rt.i32 => { + v = ((a055: rs.i32, a147: rs.i32): rs.i32 => { return a055 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$i32_i32_i32_ops_BitOr_bitor_i32_i32((a054: rt.i32, a146: rt.i32): rt.i32 => { + v = two$i32_i32_i32_ops_BitOr_bitor_i32_i32((a054: rs.i32, a146: rs.i32): rs.i32 => { return a054 | a146; }, a, b); } else { - v = ((a053: rt.i32, a145: rt.i32): rt.i32 => { + v = ((a053: rs.i32, a145: rs.i32): rs.i32 => { return a053 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$i32_i32_i32_ops_BitXor_bitxor_i32_i32((a052: rt.i32, a144: rt.i32): rt.i32 => { + v = two$i32_i32_i32_ops_BitXor_bitxor_i32_i32((a052: rs.i32, a144: rs.i32): rs.i32 => { return a052 ^ a144; }, a, b); } else { - v = ((a051: rt.i32, a143: rt.i32): rt.i32 => { + v = ((a051: rs.i32, a143: rs.i32): rs.i32 => { return a051 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.i32Shl(a, n); + v = rs.i32Shl(a, n); } else if (_56 === 1) { - v = two$i32_u32_i32_ops_Shl_shl_i32_u32((a050: rt.i32, a142: rt.u32): rt.i32 => { - return rt.i32Shl(a050, a142); + v = two$i32_u32_i32_ops_Shl_shl_i32_u32((a050: rs.i32, a142: rs.u32): rs.i32 => { + return rs.i32Shl(a050, a142); }, a, n); } else { - v = ((a049: rt.i32, a141: rt.u32): rt.i32 => { - return rt.i32Shl(a049, a141); + v = ((a049: rs.i32, a141: rs.u32): rs.i32 => { + return rs.i32Shl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.i32Shr(a, n); + v = rs.i32Shr(a, n); } else if (_59 === 1) { - v = two$i32_u32_i32_ops_Shr_shr_i32_u32((a048: rt.i32, a140: rt.u32): rt.i32 => { - return rt.i32Shr(a048, a140); + v = two$i32_u32_i32_ops_Shr_shr_i32_u32((a048: rs.i32, a140: rs.u32): rs.i32 => { + return rs.i32Shr(a048, a140); }, a, n); } else { - v = ((a047: rt.i32, a139: rt.u32): rt.i32 => { - return rt.i32Shr(a047, a139); + v = ((a047: rs.i32, a139: rs.u32): rs.i32 => { + return rs.i32Shr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.i32Shl(a, (n << 16) >> 16); + v = rs.i32Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$i32_i16_i32_ops_Shl_shl_i32_i16((a046: rt.i32, a138: rt.i16): rt.i32 => { - return rt.i32Shl(a046, a138); + v = two$i32_i16_i32_ops_Shl_shl_i32_i16((a046: rs.i32, a138: rs.i16): rs.i32 => { + return rs.i32Shl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.i32, a137: rt.i16): rt.i32 => { - return rt.i32Shl(a045, a137); + v = ((a045: rs.i32, a137: rs.i16): rs.i32 => { + return rs.i32Shl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.i32Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.i32Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$i32_u128_i32_ops_Shr_shr_i32_u128((a044: rt.i32, a136: rt.u128): rt.i32 => { - return rt.i32Shr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$i32_u128_i32_ops_Shr_shr_i32_u128((a044: rs.i32, a136: rs.u128): rs.i32 => { + return rs.i32Shr(a044, a136); }, a, _74); } else { - v = ((a043: rt.i32, a135: rt.u128): rt.i32 => { - return rt.i32Shr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.i32, a135: rs.u128): rs.i32 => { + return rs.i32Shr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a; } else if (_83 === 1) { - v = one$i32_i32_ops_Not_not_i32((a042: rt.i32): rt.i32 => { + v = one$i32_i32_ops_Not_not_i32((a042: rs.i32): rs.i32 => { return ~a042; }, a); } else { - v = ((a041: rt.i32): rt.i32 => { + v = ((a041: rs.i32): rs.i32 => { return ~a041; })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.i32Neg(a); + _87 = rs.i32Neg(a); } else if (_92 === 1) { - _87 = one$i32_i32_ops_Neg_neg_i32((a040: rt.i32): rt.i32 => { - return rt.i32Neg(a040); + _87 = one$i32_i32_ops_Neg_neg_i32((a040: rs.i32): rs.i32 => { + return rs.i32Neg(a040); }, a); } else { - _87 = ((a039: rt.i32): rt.i32 => { - return rt.i32Neg(a039); + _87 = ((a039: rs.i32): rs.i32 => { + return rs.i32Neg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.i32Neg(a); + _87 = rs.i32Neg(a); } else if (_95 === 1) { - _87 = one$ref_i32_i32_ops_Neg_neg_ref_i32((a038: rt.i32): rt.i32 => { - return rt.i32Neg(a038); + _87 = one$ref_i32_i32_ops_Neg_neg_ref_i32((a038: rs.i32): rs.i32 => { + return rs.i32Neg(a038); }, a); } else { - _87 = ((a037: rt.i32): rt.i32 => { - return rt.i32Neg(a037); + _87 = ((a037: rs.i32): rs.i32 => { + return rs.i32Neg(a037); })(a); } } - const _86: rt.i32 | undefined = _87; + const _86: rs.i32 | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.i32 = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.i32 = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.i32Add(x, b); + x = rs.i32Add(x, b); } else if (_105 === 1) { - two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32((a036: rt.Place, a134: rt.i32): undefined => { - a036.v = rt.i32Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_i32_i32_unit_ops_AddAssign_add_assign_i32_i32((a036: rs.Place, a134: rs.i32): undefined => { + a036.v = rs.i32Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.i32): undefined => { - a035.v = rt.i32Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.i32): undefined => { + a035.v = rs.i32Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.i32 = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.i32 = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.i32Sub(x2, b); + x2 = rs.i32Sub(x2, b); } else if (_113 === 1) { - two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32((a034: rt.Place, a132: rt.i32): undefined => { - a034.v = rt.i32Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_i32_i32_unit_ops_SubAssign_sub_assign_i32_i32((a034: rs.Place, a132: rs.i32): undefined => { + a034.v = rs.i32Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.i32): undefined => { - a033.v = rt.i32Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.i32): undefined => { + a033.v = rs.i32Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.i32 = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.i32 = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.i32Mul(x3, b); + x3 = rs.i32Mul(x3, b); } else if (_121 === 1) { - two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32((a032: rt.Place, a130: rt.i32): undefined => { - a032.v = rt.i32Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_i32_i32_unit_ops_MulAssign_mul_assign_i32_i32((a032: rs.Place, a130: rs.i32): undefined => { + a032.v = rs.i32Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.i32): undefined => { - a031.v = rt.i32Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.i32): undefined => { + a031.v = rs.i32Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.i32 = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.i32 = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.i32Div(x4, b); + x4 = rs.i32Div(x4, b); } else if (_129 === 1) { - two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32((a030: rt.Place, a128: rt.i32): undefined => { - a030.v = rt.i32Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_i32_i32_unit_ops_DivAssign_div_assign_i32_i32((a030: rs.Place, a128: rs.i32): undefined => { + a030.v = rs.i32Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.i32): undefined => { - a029.v = rt.i32Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.i32): undefined => { + a029.v = rs.i32Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.i32 = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.i32 = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.i32Rem(x5, b); + x5 = rs.i32Rem(x5, b); } else if (_137 === 1) { - two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32((a028: rt.Place, a126: rt.i32): undefined => { - a028.v = rt.i32Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_i32_i32_unit_ops_RemAssign_rem_assign_i32_i32((a028: rs.Place, a126: rs.i32): undefined => { + a028.v = rs.i32Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.i32): undefined => { - a027.v = rt.i32Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.i32): undefined => { + a027.v = rs.i32Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.i32 = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.i32 = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { x6 = x6 & b; } else if (_145 === 1) { - two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32((a026: rt.Place, a124: rt.i32): undefined => { + two$mut_i32_i32_unit_ops_BitAndAssign_bitand_assign_i32_i32((a026: rs.Place, a124: rs.i32): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.i32): undefined => { + ((a025: rs.Place, a123: rs.i32): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.i32 = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.i32 = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { x7 = x7 | b; } else if (_153 === 1) { - two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32((a024: rt.Place, a122: rt.i32): undefined => { + two$mut_i32_i32_unit_ops_BitOrAssign_bitor_assign_i32_i32((a024: rs.Place, a122: rs.i32): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.i32): undefined => { + ((a023: rs.Place, a121: rs.i32): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.i32 = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.i32 = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { x8 = x8 ^ b; } else if (_161 === 1) { - two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32((a022: rt.Place, a120: rt.i32): undefined => { + two$mut_i32_i32_unit_ops_BitXorAssign_bitxor_assign_i32_i32((a022: rs.Place, a120: rs.i32): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.i32): undefined => { + ((a021: rs.Place, a119: rs.i32): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.i32 = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.i32 = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.i32Shl(x9, n); + x9 = rs.i32Shl(x9, n); } else if (_169 === 1) { - two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.i32Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_i32_u32_unit_ops_ShlAssign_shl_assign_i32_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.i32Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.i32Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.i32Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.i32 = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.i32 = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.i32Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.i32Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.i32Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_i32_i64_unit_ops_ShrAssign_shr_assign_i32_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.i32Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.i32Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.i32Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.i32Add(a, b); + v = rs.i32Add(a, b); } else if (_189 === 1) { - v = two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32((a016: rt.i32, a114: rt.i32): rt.i32 => { - return rt.i32Add(a016, a114); + v = two$i32_ref_i32_i32_ops_Add_add_i32_ref_i32((a016: rs.i32, a114: rs.i32): rs.i32 => { + return rs.i32Add(a016, a114); }, a, b); } else { - v = ((a015: rt.i32, a113: rt.i32): rt.i32 => { - return rt.i32Add(a015, a113); + v = ((a015: rs.i32, a113: rs.i32): rs.i32 => { + return rs.i32Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.i32Sub(a, b); + v = rs.i32Sub(a, b); } else if (_195 === 1) { - v = two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32((a014: rt.i32, a112: rt.i32): rt.i32 => { - return rt.i32Sub(a014, a112); + v = two$ref_i32_i32_i32_ops_Sub_sub_ref_i32_i32((a014: rs.i32, a112: rs.i32): rs.i32 => { + return rs.i32Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.i32, a111: rt.i32): rt.i32 => { - return rt.i32Sub(a013, a111); + v = ((a013: rs.i32, a111: rs.i32): rs.i32 => { + return rs.i32Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.i32Mul(a, b); + v = rs.i32Mul(a, b); } else if (_201 === 1) { - v = two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32((a012: rt.i32, a110: rt.i32): rt.i32 => { - return rt.i32Mul(a012, a110); + v = two$ref_i32_ref_i32_i32_ops_Mul_mul_ref_i32_ref_i32((a012: rs.i32, a110: rs.i32): rs.i32 => { + return rs.i32Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.i32, a19: rt.i32): rt.i32 => { - return rt.i32Mul(a011, a19); + v = ((a011: rs.i32, a19: rs.i32): rs.i32 => { + return rs.i32Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.i32Shl(a, n & 0xff); + v = rs.i32Shl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8((a010: rt.i32, a18: rt.u8): rt.i32 => { - return rt.i32Shl(a010, a18); + v = two$ref_i32_ref_u8_i32_ops_Shl_shl_ref_i32_ref_u8((a010: rs.i32, a18: rs.u8): rs.i32 => { + return rs.i32Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.i32, a17: rt.u8): rt.i32 => { - return rt.i32Shl(a09, a17); + v = ((a09: rs.i32, a17: rs.u8): rs.i32 => { + return rs.i32Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { v = ~a; } else if (_222 === 1) { - v = one$ref_i32_i32_ops_Not_not_ref_i32((a08: rt.i32): rt.i32 => { + v = one$ref_i32_i32_ops_Not_not_ref_i32((a08: rs.i32): rs.i32 => { return ~a08; }, a); } else { - v = ((a07: rt.i32): rt.i32 => { + v = ((a07: rs.i32): rs.i32 => { return ~a07; })(a); } } else if (_30 === 29) { - let x11: rt.i32 = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.i32 = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.i32Add(x11, b); + x11 = rs.i32Add(x11, b); } else if (_230 === 1) { - two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32((a06: rt.Place, a16: rt.i32): undefined => { - a06.v = rt.i32Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_i32_ref_i32_unit_ops_AddAssign_add_assign_i32_ref_i32((a06: rs.Place, a16: rs.i32): undefined => { + a06.v = rs.i32Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.i32): undefined => { - a05.v = rt.i32Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.i32): undefined => { + a05.v = rs.i32Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.i32 = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.i32 = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.i32Div(x12, b); + x12 = rs.i32Div(x12, b); } else if (_241 === 1) { - two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32((a04: rt.Place, a14: rt.i32): undefined => { - a04.v = rt.i32Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_i32_ref_i32_unit_ops_DivAssign_div_assign_i32_ref_i32((a04: rs.Place, a14: rs.i32): undefined => { + a04.v = rs.i32Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.i32): undefined => { - a03.v = rt.i32Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.i32): undefined => { + a03.v = rs.i32Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.i32 = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.i32 = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.i32Shr(x13, n & 0xffff); + x13 = rs.i32Shr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.i32Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_i32_ref_u16_unit_ops_ShrAssign_shr_assign_i32_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.i32Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i32Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i32Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -6817,495 +6817,495 @@ export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.i64; - let _87!: rt.i64; - const _28: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v3: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128Cast(v3)))); +export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.i64; + let _87!: rs.i64; + const _28: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v3: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128Cast(v3)))); }; - const take: (a0: rt.usize) => rt.i64 = (at: rt.usize): rt.i64 => { - const buf: Uint8Array = rt.bytes(8); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { + const buf: Uint8Array = rs.bytes(8); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.i64FromBeBytes(buf); + return rs.i64FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.i64, rt.i64] = [take(1), take(1 + 8)]; - const a: rt.i64 = _10[0]; - const b: rt.i64 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 8), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.i64, rs.i64] = [take(1), take(1 + 8)]; + const a: rs.i64 = _10[0]; + const b: rs.i64 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 8), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.i64Add(a, b); + v = rs.i64Add(a, b); } else if (_32 === 1) { - v = two$i64_i64_i64_ops_Add_add_i64_i64((a066: rt.i64, a158: rt.i64): rt.i64 => { - return rt.i64Add(a066, a158); + v = two$i64_i64_i64_ops_Add_add_i64_i64((a066: rs.i64, a158: rs.i64): rs.i64 => { + return rs.i64Add(a066, a158); }, a, b); } else { - v = ((a065: rt.i64, a157: rt.i64): rt.i64 => { - return rt.i64Add(a065, a157); + v = ((a065: rs.i64, a157: rs.i64): rs.i64 => { + return rs.i64Add(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.i64Sub(a, b); + v = rs.i64Sub(a, b); } else if (_35 === 1) { - v = two$i64_i64_i64_ops_Sub_sub_i64_i64((a064: rt.i64, a156: rt.i64): rt.i64 => { - return rt.i64Sub(a064, a156); + v = two$i64_i64_i64_ops_Sub_sub_i64_i64((a064: rs.i64, a156: rs.i64): rs.i64 => { + return rs.i64Sub(a064, a156); }, a, b); } else { - v = ((a063: rt.i64, a155: rt.i64): rt.i64 => { - return rt.i64Sub(a063, a155); + v = ((a063: rs.i64, a155: rs.i64): rs.i64 => { + return rs.i64Sub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.i64Mul(a, b); + v = rs.i64Mul(a, b); } else if (_38 === 1) { - v = two$i64_i64_i64_ops_Mul_mul_i64_i64((a062: rt.i64, a154: rt.i64): rt.i64 => { - return rt.i64Mul(a062, a154); + v = two$i64_i64_i64_ops_Mul_mul_i64_i64((a062: rs.i64, a154: rs.i64): rs.i64 => { + return rs.i64Mul(a062, a154); }, a, b); } else { - v = ((a061: rt.i64, a153: rt.i64): rt.i64 => { - return rt.i64Mul(a061, a153); + v = ((a061: rs.i64, a153: rs.i64): rs.i64 => { + return rs.i64Mul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.i64Div(a, b); + v = rs.i64Div(a, b); } else if (_41 === 1) { - v = two$i64_i64_i64_ops_Div_div_i64_i64((a060: rt.i64, a152: rt.i64): rt.i64 => { - return rt.i64Div(a060, a152); + v = two$i64_i64_i64_ops_Div_div_i64_i64((a060: rs.i64, a152: rs.i64): rs.i64 => { + return rs.i64Div(a060, a152); }, a, b); } else { - v = ((a059: rt.i64, a151: rt.i64): rt.i64 => { - return rt.i64Div(a059, a151); + v = ((a059: rs.i64, a151: rs.i64): rs.i64 => { + return rs.i64Div(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.i64Rem(a, b); + v = rs.i64Rem(a, b); } else if (_44 === 1) { - v = two$i64_i64_i64_ops_Rem_rem_i64_i64((a058: rt.i64, a150: rt.i64): rt.i64 => { - return rt.i64Rem(a058, a150); + v = two$i64_i64_i64_ops_Rem_rem_i64_i64((a058: rs.i64, a150: rs.i64): rs.i64 => { + return rs.i64Rem(a058, a150); }, a, b); } else { - v = ((a057: rt.i64, a149: rt.i64): rt.i64 => { - return rt.i64Rem(a057, a149); + v = ((a057: rs.i64, a149: rs.i64): rs.i64 => { + return rs.i64Rem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { - v = rt.i64And(a, b); + v = rs.i64And(a, b); } else if (_47 === 1) { - v = two$i64_i64_i64_ops_BitAnd_bitand_i64_i64((a056: rt.i64, a148: rt.i64): rt.i64 => { - return rt.i64And(a056, a148); + v = two$i64_i64_i64_ops_BitAnd_bitand_i64_i64((a056: rs.i64, a148: rs.i64): rs.i64 => { + return rs.i64And(a056, a148); }, a, b); } else { - v = ((a055: rt.i64, a147: rt.i64): rt.i64 => { - return rt.i64And(a055, a147); + v = ((a055: rs.i64, a147: rs.i64): rs.i64 => { + return rs.i64And(a055, a147); })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { - v = rt.i64Or(a, b); + v = rs.i64Or(a, b); } else if (_50 === 1) { - v = two$i64_i64_i64_ops_BitOr_bitor_i64_i64((a054: rt.i64, a146: rt.i64): rt.i64 => { - return rt.i64Or(a054, a146); + v = two$i64_i64_i64_ops_BitOr_bitor_i64_i64((a054: rs.i64, a146: rs.i64): rs.i64 => { + return rs.i64Or(a054, a146); }, a, b); } else { - v = ((a053: rt.i64, a145: rt.i64): rt.i64 => { - return rt.i64Or(a053, a145); + v = ((a053: rs.i64, a145: rs.i64): rs.i64 => { + return rs.i64Or(a053, a145); })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { - v = rt.i64Xor(a, b); + v = rs.i64Xor(a, b); } else if (_53 === 1) { - v = two$i64_i64_i64_ops_BitXor_bitxor_i64_i64((a052: rt.i64, a144: rt.i64): rt.i64 => { - return rt.i64Xor(a052, a144); + v = two$i64_i64_i64_ops_BitXor_bitxor_i64_i64((a052: rs.i64, a144: rs.i64): rs.i64 => { + return rs.i64Xor(a052, a144); }, a, b); } else { - v = ((a051: rt.i64, a143: rt.i64): rt.i64 => { - return rt.i64Xor(a051, a143); + v = ((a051: rs.i64, a143: rs.i64): rs.i64 => { + return rs.i64Xor(a051, a143); })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.i64Shl(a, n); + v = rs.i64Shl(a, n); } else if (_56 === 1) { - v = two$i64_u32_i64_ops_Shl_shl_i64_u32((a050: rt.i64, a142: rt.u32): rt.i64 => { - return rt.i64Shl(a050, a142); + v = two$i64_u32_i64_ops_Shl_shl_i64_u32((a050: rs.i64, a142: rs.u32): rs.i64 => { + return rs.i64Shl(a050, a142); }, a, n); } else { - v = ((a049: rt.i64, a141: rt.u32): rt.i64 => { - return rt.i64Shl(a049, a141); + v = ((a049: rs.i64, a141: rs.u32): rs.i64 => { + return rs.i64Shl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.i64Shr(a, n); + v = rs.i64Shr(a, n); } else if (_59 === 1) { - v = two$i64_u32_i64_ops_Shr_shr_i64_u32((a048: rt.i64, a140: rt.u32): rt.i64 => { - return rt.i64Shr(a048, a140); + v = two$i64_u32_i64_ops_Shr_shr_i64_u32((a048: rs.i64, a140: rs.u32): rs.i64 => { + return rs.i64Shr(a048, a140); }, a, n); } else { - v = ((a047: rt.i64, a139: rt.u32): rt.i64 => { - return rt.i64Shr(a047, a139); + v = ((a047: rs.i64, a139: rs.u32): rs.i64 => { + return rs.i64Shr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.i64Shl(a, (n << 16) >> 16); + v = rs.i64Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$i64_i16_i64_ops_Shl_shl_i64_i16((a046: rt.i64, a138: rt.i16): rt.i64 => { - return rt.i64Shl(a046, a138); + v = two$i64_i16_i64_ops_Shl_shl_i64_i16((a046: rs.i64, a138: rs.i16): rs.i64 => { + return rs.i64Shl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.i64, a137: rt.i16): rt.i64 => { - return rt.i64Shl(a045, a137); + v = ((a045: rs.i64, a137: rs.i16): rs.i64 => { + return rs.i64Shl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.i64Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.i64Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$i64_u128_i64_ops_Shr_shr_i64_u128((a044: rt.i64, a136: rt.u128): rt.i64 => { - return rt.i64Shr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$i64_u128_i64_ops_Shr_shr_i64_u128((a044: rs.i64, a136: rs.u128): rs.i64 => { + return rs.i64Shr(a044, a136); }, a, _74); } else { - v = ((a043: rt.i64, a135: rt.u128): rt.i64 => { - return rt.i64Shr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.i64, a135: rs.u128): rs.i64 => { + return rs.i64Shr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { - v = rt.i64Not(a); + v = rs.i64Not(a); } else if (_83 === 1) { - v = one$i64_i64_ops_Not_not_i64((a042: rt.i64): rt.i64 => { - return rt.i64Not(a042); + v = one$i64_i64_ops_Not_not_i64((a042: rs.i64): rs.i64 => { + return rs.i64Not(a042); }, a); } else { - v = ((a041: rt.i64): rt.i64 => { - return rt.i64Not(a041); + v = ((a041: rs.i64): rs.i64 => { + return rs.i64Not(a041); })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.i64Neg(a); + _87 = rs.i64Neg(a); } else if (_92 === 1) { - _87 = one$i64_i64_ops_Neg_neg_i64((a040: rt.i64): rt.i64 => { - return rt.i64Neg(a040); + _87 = one$i64_i64_ops_Neg_neg_i64((a040: rs.i64): rs.i64 => { + return rs.i64Neg(a040); }, a); } else { - _87 = ((a039: rt.i64): rt.i64 => { - return rt.i64Neg(a039); + _87 = ((a039: rs.i64): rs.i64 => { + return rs.i64Neg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.i64Neg(a); + _87 = rs.i64Neg(a); } else if (_95 === 1) { - _87 = one$ref_i64_i64_ops_Neg_neg_ref_i64((a038: rt.i64): rt.i64 => { - return rt.i64Neg(a038); + _87 = one$ref_i64_i64_ops_Neg_neg_ref_i64((a038: rs.i64): rs.i64 => { + return rs.i64Neg(a038); }, a); } else { - _87 = ((a037: rt.i64): rt.i64 => { - return rt.i64Neg(a037); + _87 = ((a037: rs.i64): rs.i64 => { + return rs.i64Neg(a037); })(a); } } - const _86: rt.i64 | undefined = _87; + const _86: rs.i64 | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.i64 = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.i64 = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.i64Add(x, b); + x = rs.i64Add(x, b); } else if (_105 === 1) { - two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64((a036: rt.Place, a134: rt.i64): undefined => { - a036.v = rt.i64Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_i64_i64_unit_ops_AddAssign_add_assign_i64_i64((a036: rs.Place, a134: rs.i64): undefined => { + a036.v = rs.i64Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.i64): undefined => { - a035.v = rt.i64Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.i64): undefined => { + a035.v = rs.i64Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.i64 = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.i64 = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.i64Sub(x2, b); + x2 = rs.i64Sub(x2, b); } else if (_113 === 1) { - two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64((a034: rt.Place, a132: rt.i64): undefined => { - a034.v = rt.i64Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_i64_i64_unit_ops_SubAssign_sub_assign_i64_i64((a034: rs.Place, a132: rs.i64): undefined => { + a034.v = rs.i64Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.i64): undefined => { - a033.v = rt.i64Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.i64): undefined => { + a033.v = rs.i64Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.i64 = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.i64 = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.i64Mul(x3, b); + x3 = rs.i64Mul(x3, b); } else if (_121 === 1) { - two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64((a032: rt.Place, a130: rt.i64): undefined => { - a032.v = rt.i64Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_i64_i64_unit_ops_MulAssign_mul_assign_i64_i64((a032: rs.Place, a130: rs.i64): undefined => { + a032.v = rs.i64Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.i64): undefined => { - a031.v = rt.i64Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.i64): undefined => { + a031.v = rs.i64Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.i64 = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.i64 = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.i64Div(x4, b); + x4 = rs.i64Div(x4, b); } else if (_129 === 1) { - two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64((a030: rt.Place, a128: rt.i64): undefined => { - a030.v = rt.i64Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_i64_i64_unit_ops_DivAssign_div_assign_i64_i64((a030: rs.Place, a128: rs.i64): undefined => { + a030.v = rs.i64Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.i64): undefined => { - a029.v = rt.i64Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.i64): undefined => { + a029.v = rs.i64Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.i64 = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.i64 = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.i64Rem(x5, b); + x5 = rs.i64Rem(x5, b); } else if (_137 === 1) { - two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64((a028: rt.Place, a126: rt.i64): undefined => { - a028.v = rt.i64Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_i64_i64_unit_ops_RemAssign_rem_assign_i64_i64((a028: rs.Place, a126: rs.i64): undefined => { + a028.v = rs.i64Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.i64): undefined => { - a027.v = rt.i64Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.i64): undefined => { + a027.v = rs.i64Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.i64 = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.i64 = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { - x6 = rt.i64And(x6, b); + x6 = rs.i64And(x6, b); } else if (_145 === 1) { - two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64((a026: rt.Place, a124: rt.i64): undefined => { - a026.v = rt.i64And(a026.v, a124); - }, rt.place(() => x6, (value16) => x6 = value16), b); + two$mut_i64_i64_unit_ops_BitAndAssign_bitand_assign_i64_i64((a026: rs.Place, a124: rs.i64): undefined => { + a026.v = rs.i64And(a026.v, a124); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.i64): undefined => { - a025.v = rt.i64And(a025.v, a123); - })(rt.place(() => x6, (value15) => x6 = value15), b); + ((a025: rs.Place, a123: rs.i64): undefined => { + a025.v = rs.i64And(a025.v, a123); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.i64 = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.i64 = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { - x7 = rt.i64Or(x7, b); + x7 = rs.i64Or(x7, b); } else if (_153 === 1) { - two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64((a024: rt.Place, a122: rt.i64): undefined => { - a024.v = rt.i64Or(a024.v, a122); - }, rt.place(() => x7, (value14) => x7 = value14), b); + two$mut_i64_i64_unit_ops_BitOrAssign_bitor_assign_i64_i64((a024: rs.Place, a122: rs.i64): undefined => { + a024.v = rs.i64Or(a024.v, a122); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.i64): undefined => { - a023.v = rt.i64Or(a023.v, a121); - })(rt.place(() => x7, (value13) => x7 = value13), b); + ((a023: rs.Place, a121: rs.i64): undefined => { + a023.v = rs.i64Or(a023.v, a121); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.i64 = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.i64 = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { - x8 = rt.i64Xor(x8, b); + x8 = rs.i64Xor(x8, b); } else if (_161 === 1) { - two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64((a022: rt.Place, a120: rt.i64): undefined => { - a022.v = rt.i64Xor(a022.v, a120); - }, rt.place(() => x8, (value12) => x8 = value12), b); + two$mut_i64_i64_unit_ops_BitXorAssign_bitxor_assign_i64_i64((a022: rs.Place, a120: rs.i64): undefined => { + a022.v = rs.i64Xor(a022.v, a120); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.i64): undefined => { - a021.v = rt.i64Xor(a021.v, a119); - })(rt.place(() => x8, (value11) => x8 = value11), b); + ((a021: rs.Place, a119: rs.i64): undefined => { + a021.v = rs.i64Xor(a021.v, a119); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.i64 = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.i64 = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.i64Shl(x9, n); + x9 = rs.i64Shl(x9, n); } else if (_169 === 1) { - two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.i64Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_i64_u32_unit_ops_ShlAssign_shl_assign_i64_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.i64Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.i64Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.i64Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.i64 = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.i64 = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.i64Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.i64Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.i64Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_i64_i64_unit_ops_ShrAssign_shr_assign_i64_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.i64Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.i64Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.i64Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.i64Add(a, b); + v = rs.i64Add(a, b); } else if (_189 === 1) { - v = two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64((a016: rt.i64, a114: rt.i64): rt.i64 => { - return rt.i64Add(a016, a114); + v = two$i64_ref_i64_i64_ops_Add_add_i64_ref_i64((a016: rs.i64, a114: rs.i64): rs.i64 => { + return rs.i64Add(a016, a114); }, a, b); } else { - v = ((a015: rt.i64, a113: rt.i64): rt.i64 => { - return rt.i64Add(a015, a113); + v = ((a015: rs.i64, a113: rs.i64): rs.i64 => { + return rs.i64Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.i64Sub(a, b); + v = rs.i64Sub(a, b); } else if (_195 === 1) { - v = two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64((a014: rt.i64, a112: rt.i64): rt.i64 => { - return rt.i64Sub(a014, a112); + v = two$ref_i64_i64_i64_ops_Sub_sub_ref_i64_i64((a014: rs.i64, a112: rs.i64): rs.i64 => { + return rs.i64Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.i64, a111: rt.i64): rt.i64 => { - return rt.i64Sub(a013, a111); + v = ((a013: rs.i64, a111: rs.i64): rs.i64 => { + return rs.i64Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.i64Mul(a, b); + v = rs.i64Mul(a, b); } else if (_201 === 1) { - v = two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64((a012: rt.i64, a110: rt.i64): rt.i64 => { - return rt.i64Mul(a012, a110); + v = two$ref_i64_ref_i64_i64_ops_Mul_mul_ref_i64_ref_i64((a012: rs.i64, a110: rs.i64): rs.i64 => { + return rs.i64Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.i64, a19: rt.i64): rt.i64 => { - return rt.i64Mul(a011, a19); + v = ((a011: rs.i64, a19: rs.i64): rs.i64 => { + return rs.i64Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.i64Shl(a, n & 0xff); + v = rs.i64Shl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8((a010: rt.i64, a18: rt.u8): rt.i64 => { - return rt.i64Shl(a010, a18); + v = two$ref_i64_ref_u8_i64_ops_Shl_shl_ref_i64_ref_u8((a010: rs.i64, a18: rs.u8): rs.i64 => { + return rs.i64Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.i64, a17: rt.u8): rt.i64 => { - return rt.i64Shl(a09, a17); + v = ((a09: rs.i64, a17: rs.u8): rs.i64 => { + return rs.i64Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { - v = rt.i64Not(a); + v = rs.i64Not(a); } else if (_222 === 1) { - v = one$ref_i64_i64_ops_Not_not_ref_i64((a08: rt.i64): rt.i64 => { - return rt.i64Not(a08); + v = one$ref_i64_i64_ops_Not_not_ref_i64((a08: rs.i64): rs.i64 => { + return rs.i64Not(a08); }, a); } else { - v = ((a07: rt.i64): rt.i64 => { - return rt.i64Not(a07); + v = ((a07: rs.i64): rs.i64 => { + return rs.i64Not(a07); })(a); } } else if (_30 === 29) { - let x11: rt.i64 = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.i64 = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.i64Add(x11, b); + x11 = rs.i64Add(x11, b); } else if (_230 === 1) { - two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64((a06: rt.Place, a16: rt.i64): undefined => { - a06.v = rt.i64Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_i64_ref_i64_unit_ops_AddAssign_add_assign_i64_ref_i64((a06: rs.Place, a16: rs.i64): undefined => { + a06.v = rs.i64Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.i64): undefined => { - a05.v = rt.i64Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.i64): undefined => { + a05.v = rs.i64Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.i64 = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.i64 = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.i64Div(x12, b); + x12 = rs.i64Div(x12, b); } else if (_241 === 1) { - two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64((a04: rt.Place, a14: rt.i64): undefined => { - a04.v = rt.i64Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_i64_ref_i64_unit_ops_DivAssign_div_assign_i64_ref_i64((a04: rs.Place, a14: rs.i64): undefined => { + a04.v = rs.i64Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.i64): undefined => { - a03.v = rt.i64Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.i64): undefined => { + a03.v = rs.i64Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.i64 = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.i64 = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.i64Shr(x13, n & 0xffff); + x13 = rs.i64Shr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.i64Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_i64_ref_u16_unit_ops_ShrAssign_shr_assign_i64_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.i64Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i64Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i64Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -7317,495 +7317,495 @@ export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.i128; - let _87!: rt.i128; - const _28: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v3: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3))); +export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.i128; + let _87!: rs.i128; + const _28: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v3: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3))); }; - const take: (a0: rt.usize) => rt.i128 = (at: rt.usize): rt.i128 => { - const buf: Uint8Array = rt.bytes(16); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { + const buf: Uint8Array = rs.bytes(16); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.i128FromBeBytes(buf); + return rs.i128FromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.i128, rt.i128] = [take(1), take(1 + 16)]; - const a: rt.i128 = _10[0]; - const b: rt.i128 = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 16), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.i128, rs.i128] = [take(1), take(1 + 16)]; + const a: rs.i128 = _10[0]; + const b: rs.i128 = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 16), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.i128Add(a, b); + v = rs.i128Add(a, b); } else if (_32 === 1) { - v = two$i128_i128_i128_ops_Add_add_i128_i128((a066: rt.i128, a158: rt.i128): rt.i128 => { - return rt.i128Add(a066, a158); + v = two$i128_i128_i128_ops_Add_add_i128_i128((a066: rs.i128, a158: rs.i128): rs.i128 => { + return rs.i128Add(a066, a158); }, a, b); } else { - v = ((a065: rt.i128, a157: rt.i128): rt.i128 => { - return rt.i128Add(a065, a157); + v = ((a065: rs.i128, a157: rs.i128): rs.i128 => { + return rs.i128Add(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.i128Sub(a, b); + v = rs.i128Sub(a, b); } else if (_35 === 1) { - v = two$i128_i128_i128_ops_Sub_sub_i128_i128((a064: rt.i128, a156: rt.i128): rt.i128 => { - return rt.i128Sub(a064, a156); + v = two$i128_i128_i128_ops_Sub_sub_i128_i128((a064: rs.i128, a156: rs.i128): rs.i128 => { + return rs.i128Sub(a064, a156); }, a, b); } else { - v = ((a063: rt.i128, a155: rt.i128): rt.i128 => { - return rt.i128Sub(a063, a155); + v = ((a063: rs.i128, a155: rs.i128): rs.i128 => { + return rs.i128Sub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.i128Mul(a, b); + v = rs.i128Mul(a, b); } else if (_38 === 1) { - v = two$i128_i128_i128_ops_Mul_mul_i128_i128((a062: rt.i128, a154: rt.i128): rt.i128 => { - return rt.i128Mul(a062, a154); + v = two$i128_i128_i128_ops_Mul_mul_i128_i128((a062: rs.i128, a154: rs.i128): rs.i128 => { + return rs.i128Mul(a062, a154); }, a, b); } else { - v = ((a061: rt.i128, a153: rt.i128): rt.i128 => { - return rt.i128Mul(a061, a153); + v = ((a061: rs.i128, a153: rs.i128): rs.i128 => { + return rs.i128Mul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.i128Div(a, b); + v = rs.i128Div(a, b); } else if (_41 === 1) { - v = two$i128_i128_i128_ops_Div_div_i128_i128((a060: rt.i128, a152: rt.i128): rt.i128 => { - return rt.i128Div(a060, a152); + v = two$i128_i128_i128_ops_Div_div_i128_i128((a060: rs.i128, a152: rs.i128): rs.i128 => { + return rs.i128Div(a060, a152); }, a, b); } else { - v = ((a059: rt.i128, a151: rt.i128): rt.i128 => { - return rt.i128Div(a059, a151); + v = ((a059: rs.i128, a151: rs.i128): rs.i128 => { + return rs.i128Div(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.i128Rem(a, b); + v = rs.i128Rem(a, b); } else if (_44 === 1) { - v = two$i128_i128_i128_ops_Rem_rem_i128_i128((a058: rt.i128, a150: rt.i128): rt.i128 => { - return rt.i128Rem(a058, a150); + v = two$i128_i128_i128_ops_Rem_rem_i128_i128((a058: rs.i128, a150: rs.i128): rs.i128 => { + return rs.i128Rem(a058, a150); }, a, b); } else { - v = ((a057: rt.i128, a149: rt.i128): rt.i128 => { - return rt.i128Rem(a057, a149); + v = ((a057: rs.i128, a149: rs.i128): rs.i128 => { + return rs.i128Rem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { - v = rt.i128And(a, b); + v = rs.i128And(a, b); } else if (_47 === 1) { - v = two$i128_i128_i128_ops_BitAnd_bitand_i128_i128((a056: rt.i128, a148: rt.i128): rt.i128 => { - return rt.i128And(a056, a148); + v = two$i128_i128_i128_ops_BitAnd_bitand_i128_i128((a056: rs.i128, a148: rs.i128): rs.i128 => { + return rs.i128And(a056, a148); }, a, b); } else { - v = ((a055: rt.i128, a147: rt.i128): rt.i128 => { - return rt.i128And(a055, a147); + v = ((a055: rs.i128, a147: rs.i128): rs.i128 => { + return rs.i128And(a055, a147); })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { - v = rt.i128Or(a, b); + v = rs.i128Or(a, b); } else if (_50 === 1) { - v = two$i128_i128_i128_ops_BitOr_bitor_i128_i128((a054: rt.i128, a146: rt.i128): rt.i128 => { - return rt.i128Or(a054, a146); + v = two$i128_i128_i128_ops_BitOr_bitor_i128_i128((a054: rs.i128, a146: rs.i128): rs.i128 => { + return rs.i128Or(a054, a146); }, a, b); } else { - v = ((a053: rt.i128, a145: rt.i128): rt.i128 => { - return rt.i128Or(a053, a145); + v = ((a053: rs.i128, a145: rs.i128): rs.i128 => { + return rs.i128Or(a053, a145); })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { - v = rt.i128Xor(a, b); + v = rs.i128Xor(a, b); } else if (_53 === 1) { - v = two$i128_i128_i128_ops_BitXor_bitxor_i128_i128((a052: rt.i128, a144: rt.i128): rt.i128 => { - return rt.i128Xor(a052, a144); + v = two$i128_i128_i128_ops_BitXor_bitxor_i128_i128((a052: rs.i128, a144: rs.i128): rs.i128 => { + return rs.i128Xor(a052, a144); }, a, b); } else { - v = ((a051: rt.i128, a143: rt.i128): rt.i128 => { - return rt.i128Xor(a051, a143); + v = ((a051: rs.i128, a143: rs.i128): rs.i128 => { + return rs.i128Xor(a051, a143); })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.i128Shl(a, n); + v = rs.i128Shl(a, n); } else if (_56 === 1) { - v = two$i128_u32_i128_ops_Shl_shl_i128_u32((a050: rt.i128, a142: rt.u32): rt.i128 => { - return rt.i128Shl(a050, a142); + v = two$i128_u32_i128_ops_Shl_shl_i128_u32((a050: rs.i128, a142: rs.u32): rs.i128 => { + return rs.i128Shl(a050, a142); }, a, n); } else { - v = ((a049: rt.i128, a141: rt.u32): rt.i128 => { - return rt.i128Shl(a049, a141); + v = ((a049: rs.i128, a141: rs.u32): rs.i128 => { + return rs.i128Shl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.i128Shr(a, n); + v = rs.i128Shr(a, n); } else if (_59 === 1) { - v = two$i128_u32_i128_ops_Shr_shr_i128_u32((a048: rt.i128, a140: rt.u32): rt.i128 => { - return rt.i128Shr(a048, a140); + v = two$i128_u32_i128_ops_Shr_shr_i128_u32((a048: rs.i128, a140: rs.u32): rs.i128 => { + return rs.i128Shr(a048, a140); }, a, n); } else { - v = ((a047: rt.i128, a139: rt.u32): rt.i128 => { - return rt.i128Shr(a047, a139); + v = ((a047: rs.i128, a139: rs.u32): rs.i128 => { + return rs.i128Shr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.i128Shl(a, (n << 16) >> 16); + v = rs.i128Shl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$i128_i16_i128_ops_Shl_shl_i128_i16((a046: rt.i128, a138: rt.i16): rt.i128 => { - return rt.i128Shl(a046, a138); + v = two$i128_i16_i128_ops_Shl_shl_i128_i16((a046: rs.i128, a138: rs.i16): rs.i128 => { + return rs.i128Shl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.i128, a137: rt.i16): rt.i128 => { - return rt.i128Shl(a045, a137); + v = ((a045: rs.i128, a137: rs.i16): rs.i128 => { + return rs.i128Shl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.i128Shr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.i128Shr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$i128_u128_i128_ops_Shr_shr_i128_u128((a044: rt.i128, a136: rt.u128): rt.i128 => { - return rt.i128Shr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$i128_u128_i128_ops_Shr_shr_i128_u128((a044: rs.i128, a136: rs.u128): rs.i128 => { + return rs.i128Shr(a044, a136); }, a, _74); } else { - v = ((a043: rt.i128, a135: rt.u128): rt.i128 => { - return rt.i128Shr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.i128, a135: rs.u128): rs.i128 => { + return rs.i128Shr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { - v = rt.i128Not(a); + v = rs.i128Not(a); } else if (_83 === 1) { - v = one$i128_i128_ops_Not_not_i128((a042: rt.i128): rt.i128 => { - return rt.i128Not(a042); + v = one$i128_i128_ops_Not_not_i128((a042: rs.i128): rs.i128 => { + return rs.i128Not(a042); }, a); } else { - v = ((a041: rt.i128): rt.i128 => { - return rt.i128Not(a041); + v = ((a041: rs.i128): rs.i128 => { + return rs.i128Not(a041); })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.i128Neg(a); + _87 = rs.i128Neg(a); } else if (_92 === 1) { - _87 = one$i128_i128_ops_Neg_neg_i128((a040: rt.i128): rt.i128 => { - return rt.i128Neg(a040); + _87 = one$i128_i128_ops_Neg_neg_i128((a040: rs.i128): rs.i128 => { + return rs.i128Neg(a040); }, a); } else { - _87 = ((a039: rt.i128): rt.i128 => { - return rt.i128Neg(a039); + _87 = ((a039: rs.i128): rs.i128 => { + return rs.i128Neg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.i128Neg(a); + _87 = rs.i128Neg(a); } else if (_95 === 1) { - _87 = one$ref_i128_i128_ops_Neg_neg_ref_i128((a038: rt.i128): rt.i128 => { - return rt.i128Neg(a038); + _87 = one$ref_i128_i128_ops_Neg_neg_ref_i128((a038: rs.i128): rs.i128 => { + return rs.i128Neg(a038); }, a); } else { - _87 = ((a037: rt.i128): rt.i128 => { - return rt.i128Neg(a037); + _87 = ((a037: rs.i128): rs.i128 => { + return rs.i128Neg(a037); })(a); } } - const _86: rt.i128 | undefined = _87; + const _86: rs.i128 | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.i128 = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.i128 = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.i128Add(x, b); + x = rs.i128Add(x, b); } else if (_105 === 1) { - two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128((a036: rt.Place, a134: rt.i128): undefined => { - a036.v = rt.i128Add(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_i128_i128_unit_ops_AddAssign_add_assign_i128_i128((a036: rs.Place, a134: rs.i128): undefined => { + a036.v = rs.i128Add(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.i128): undefined => { - a035.v = rt.i128Add(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.i128): undefined => { + a035.v = rs.i128Add(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.i128 = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.i128 = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.i128Sub(x2, b); + x2 = rs.i128Sub(x2, b); } else if (_113 === 1) { - two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128((a034: rt.Place, a132: rt.i128): undefined => { - a034.v = rt.i128Sub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_i128_i128_unit_ops_SubAssign_sub_assign_i128_i128((a034: rs.Place, a132: rs.i128): undefined => { + a034.v = rs.i128Sub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.i128): undefined => { - a033.v = rt.i128Sub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.i128): undefined => { + a033.v = rs.i128Sub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.i128 = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.i128 = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.i128Mul(x3, b); + x3 = rs.i128Mul(x3, b); } else if (_121 === 1) { - two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128((a032: rt.Place, a130: rt.i128): undefined => { - a032.v = rt.i128Mul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_i128_i128_unit_ops_MulAssign_mul_assign_i128_i128((a032: rs.Place, a130: rs.i128): undefined => { + a032.v = rs.i128Mul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.i128): undefined => { - a031.v = rt.i128Mul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.i128): undefined => { + a031.v = rs.i128Mul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.i128 = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.i128 = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.i128Div(x4, b); + x4 = rs.i128Div(x4, b); } else if (_129 === 1) { - two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128((a030: rt.Place, a128: rt.i128): undefined => { - a030.v = rt.i128Div(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_i128_i128_unit_ops_DivAssign_div_assign_i128_i128((a030: rs.Place, a128: rs.i128): undefined => { + a030.v = rs.i128Div(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.i128): undefined => { - a029.v = rt.i128Div(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.i128): undefined => { + a029.v = rs.i128Div(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.i128 = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.i128 = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.i128Rem(x5, b); + x5 = rs.i128Rem(x5, b); } else if (_137 === 1) { - two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128((a028: rt.Place, a126: rt.i128): undefined => { - a028.v = rt.i128Rem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_i128_i128_unit_ops_RemAssign_rem_assign_i128_i128((a028: rs.Place, a126: rs.i128): undefined => { + a028.v = rs.i128Rem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.i128): undefined => { - a027.v = rt.i128Rem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.i128): undefined => { + a027.v = rs.i128Rem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.i128 = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.i128 = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { - x6 = rt.i128And(x6, b); + x6 = rs.i128And(x6, b); } else if (_145 === 1) { - two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128((a026: rt.Place, a124: rt.i128): undefined => { - a026.v = rt.i128And(a026.v, a124); - }, rt.place(() => x6, (value16) => x6 = value16), b); + two$mut_i128_i128_unit_ops_BitAndAssign_bitand_assign_i128_i128((a026: rs.Place, a124: rs.i128): undefined => { + a026.v = rs.i128And(a026.v, a124); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.i128): undefined => { - a025.v = rt.i128And(a025.v, a123); - })(rt.place(() => x6, (value15) => x6 = value15), b); + ((a025: rs.Place, a123: rs.i128): undefined => { + a025.v = rs.i128And(a025.v, a123); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.i128 = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.i128 = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { - x7 = rt.i128Or(x7, b); + x7 = rs.i128Or(x7, b); } else if (_153 === 1) { - two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128((a024: rt.Place, a122: rt.i128): undefined => { - a024.v = rt.i128Or(a024.v, a122); - }, rt.place(() => x7, (value14) => x7 = value14), b); + two$mut_i128_i128_unit_ops_BitOrAssign_bitor_assign_i128_i128((a024: rs.Place, a122: rs.i128): undefined => { + a024.v = rs.i128Or(a024.v, a122); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.i128): undefined => { - a023.v = rt.i128Or(a023.v, a121); - })(rt.place(() => x7, (value13) => x7 = value13), b); + ((a023: rs.Place, a121: rs.i128): undefined => { + a023.v = rs.i128Or(a023.v, a121); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.i128 = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.i128 = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { - x8 = rt.i128Xor(x8, b); + x8 = rs.i128Xor(x8, b); } else if (_161 === 1) { - two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128((a022: rt.Place, a120: rt.i128): undefined => { - a022.v = rt.i128Xor(a022.v, a120); - }, rt.place(() => x8, (value12) => x8 = value12), b); + two$mut_i128_i128_unit_ops_BitXorAssign_bitxor_assign_i128_i128((a022: rs.Place, a120: rs.i128): undefined => { + a022.v = rs.i128Xor(a022.v, a120); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.i128): undefined => { - a021.v = rt.i128Xor(a021.v, a119); - })(rt.place(() => x8, (value11) => x8 = value11), b); + ((a021: rs.Place, a119: rs.i128): undefined => { + a021.v = rs.i128Xor(a021.v, a119); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.i128 = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.i128 = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.i128Shl(x9, n); + x9 = rs.i128Shl(x9, n); } else if (_169 === 1) { - two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.i128Shl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_i128_u32_unit_ops_ShlAssign_shl_assign_i128_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.i128Shl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.i128Shl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.i128Shl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.i128 = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.i128 = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.i128Shr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.i128Shr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.i128Shr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_i128_i64_unit_ops_ShrAssign_shr_assign_i128_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.i128Shr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.i128Shr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.i128Shr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.i128Add(a, b); + v = rs.i128Add(a, b); } else if (_189 === 1) { - v = two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128((a016: rt.i128, a114: rt.i128): rt.i128 => { - return rt.i128Add(a016, a114); + v = two$i128_ref_i128_i128_ops_Add_add_i128_ref_i128((a016: rs.i128, a114: rs.i128): rs.i128 => { + return rs.i128Add(a016, a114); }, a, b); } else { - v = ((a015: rt.i128, a113: rt.i128): rt.i128 => { - return rt.i128Add(a015, a113); + v = ((a015: rs.i128, a113: rs.i128): rs.i128 => { + return rs.i128Add(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.i128Sub(a, b); + v = rs.i128Sub(a, b); } else if (_195 === 1) { - v = two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128((a014: rt.i128, a112: rt.i128): rt.i128 => { - return rt.i128Sub(a014, a112); + v = two$ref_i128_i128_i128_ops_Sub_sub_ref_i128_i128((a014: rs.i128, a112: rs.i128): rs.i128 => { + return rs.i128Sub(a014, a112); }, a, b); } else { - v = ((a013: rt.i128, a111: rt.i128): rt.i128 => { - return rt.i128Sub(a013, a111); + v = ((a013: rs.i128, a111: rs.i128): rs.i128 => { + return rs.i128Sub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.i128Mul(a, b); + v = rs.i128Mul(a, b); } else if (_201 === 1) { - v = two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128((a012: rt.i128, a110: rt.i128): rt.i128 => { - return rt.i128Mul(a012, a110); + v = two$ref_i128_ref_i128_i128_ops_Mul_mul_ref_i128_ref_i128((a012: rs.i128, a110: rs.i128): rs.i128 => { + return rs.i128Mul(a012, a110); }, a, b); } else { - v = ((a011: rt.i128, a19: rt.i128): rt.i128 => { - return rt.i128Mul(a011, a19); + v = ((a011: rs.i128, a19: rs.i128): rs.i128 => { + return rs.i128Mul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.i128Shl(a, n & 0xff); + v = rs.i128Shl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8((a010: rt.i128, a18: rt.u8): rt.i128 => { - return rt.i128Shl(a010, a18); + v = two$ref_i128_ref_u8_i128_ops_Shl_shl_ref_i128_ref_u8((a010: rs.i128, a18: rs.u8): rs.i128 => { + return rs.i128Shl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.i128, a17: rt.u8): rt.i128 => { - return rt.i128Shl(a09, a17); + v = ((a09: rs.i128, a17: rs.u8): rs.i128 => { + return rs.i128Shl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { - v = rt.i128Not(a); + v = rs.i128Not(a); } else if (_222 === 1) { - v = one$ref_i128_i128_ops_Not_not_ref_i128((a08: rt.i128): rt.i128 => { - return rt.i128Not(a08); + v = one$ref_i128_i128_ops_Not_not_ref_i128((a08: rs.i128): rs.i128 => { + return rs.i128Not(a08); }, a); } else { - v = ((a07: rt.i128): rt.i128 => { - return rt.i128Not(a07); + v = ((a07: rs.i128): rs.i128 => { + return rs.i128Not(a07); })(a); } } else if (_30 === 29) { - let x11: rt.i128 = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.i128 = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.i128Add(x11, b); + x11 = rs.i128Add(x11, b); } else if (_230 === 1) { - two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128((a06: rt.Place, a16: rt.i128): undefined => { - a06.v = rt.i128Add(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_i128_ref_i128_unit_ops_AddAssign_add_assign_i128_ref_i128((a06: rs.Place, a16: rs.i128): undefined => { + a06.v = rs.i128Add(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.i128): undefined => { - a05.v = rt.i128Add(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.i128): undefined => { + a05.v = rs.i128Add(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.i128 = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.i128 = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.i128Div(x12, b); + x12 = rs.i128Div(x12, b); } else if (_241 === 1) { - two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128((a04: rt.Place, a14: rt.i128): undefined => { - a04.v = rt.i128Div(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_i128_ref_i128_unit_ops_DivAssign_div_assign_i128_ref_i128((a04: rs.Place, a14: rs.i128): undefined => { + a04.v = rs.i128Div(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.i128): undefined => { - a03.v = rt.i128Div(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.i128): undefined => { + a03.v = rs.i128Div(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.i128 = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.i128 = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.i128Shr(x13, n & 0xffff); + x13 = rs.i128Shr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.i128Shr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_i128_ref_u16_unit_ops_ShrAssign_shr_assign_i128_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.i128Shr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.i128Shr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.i128Shr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -7817,495 +7817,495 @@ export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to operands taken from `data`, in the form its first byte * picks: two operands, then a shift amount, which may pass the width many times over. */ -export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.isize; - let _87!: rt.isize; - const _28: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v3: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v3 as rt.i128))); +export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.isize; + let _87!: rs.isize; + const _28: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v3: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v3 as rs.i128))); }; - const take: (a0: rt.usize) => rt.isize = (at: rt.usize): rt.isize => { - const buf: Uint8Array = rt.bytes(4); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { + const buf: Uint8Array = rs.bytes(4); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _102: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_102 === rt.DONE) { + const _102: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_102 === rs.DONE) { break; } - _102[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _102[0])), 0); + _102[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _102[0])), 0); } - return rt.isizeFromBeBytes(buf); + return rs.isizeFromBeBytes(buf); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.isize, rt.isize] = [take(1), take(1 + 4)]; - const a: rt.isize = _10[0]; - const b: rt.isize = _10[1]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(rt.usizeAdd(1, 2 * 4), i2)), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.isize, rs.isize] = [take(1), take(1 + 4)]; + const a: rs.isize = _10[0]; + const b: rs.isize = _10[1]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(rs.usizeAdd(1, 2 * 4), i2)), 0); }; - const n: rt.u32 = ((byte(1) << 24) | byte(0)) >>> 0; + const n: rs.u32 = ((byte(1) << 24) | byte(0)) >>> 0; b0: { - const _30: rt.u8 = rt.u8Rem(kind, 32); + const _30: rs.u8 = rs.u8Rem(kind, 32); if (_30 === 0) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { - v = rt.isizeAdd(a, b); + v = rs.isizeAdd(a, b); } else if (_32 === 1) { - v = two$isize_isize_isize_ops_Add_add_isize_isize((a066: rt.isize, a158: rt.isize): rt.isize => { - return rt.isizeAdd(a066, a158); + v = two$isize_isize_isize_ops_Add_add_isize_isize((a066: rs.isize, a158: rs.isize): rs.isize => { + return rs.isizeAdd(a066, a158); }, a, b); } else { - v = ((a065: rt.isize, a157: rt.isize): rt.isize => { - return rt.isizeAdd(a065, a157); + v = ((a065: rs.isize, a157: rs.isize): rs.isize => { + return rs.isizeAdd(a065, a157); })(a, b); } } else if (_30 === 1) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { - v = rt.isizeSub(a, b); + v = rs.isizeSub(a, b); } else if (_35 === 1) { - v = two$isize_isize_isize_ops_Sub_sub_isize_isize((a064: rt.isize, a156: rt.isize): rt.isize => { - return rt.isizeSub(a064, a156); + v = two$isize_isize_isize_ops_Sub_sub_isize_isize((a064: rs.isize, a156: rs.isize): rs.isize => { + return rs.isizeSub(a064, a156); }, a, b); } else { - v = ((a063: rt.isize, a155: rt.isize): rt.isize => { - return rt.isizeSub(a063, a155); + v = ((a063: rs.isize, a155: rs.isize): rs.isize => { + return rs.isizeSub(a063, a155); })(a, b); } } else if (_30 === 2) { - const _38: rt.u8 = rt.u8Rem(form, 3); + const _38: rs.u8 = rs.u8Rem(form, 3); if (_38 === 0) { - v = rt.isizeMul(a, b); + v = rs.isizeMul(a, b); } else if (_38 === 1) { - v = two$isize_isize_isize_ops_Mul_mul_isize_isize((a062: rt.isize, a154: rt.isize): rt.isize => { - return rt.isizeMul(a062, a154); + v = two$isize_isize_isize_ops_Mul_mul_isize_isize((a062: rs.isize, a154: rs.isize): rs.isize => { + return rs.isizeMul(a062, a154); }, a, b); } else { - v = ((a061: rt.isize, a153: rt.isize): rt.isize => { - return rt.isizeMul(a061, a153); + v = ((a061: rs.isize, a153: rs.isize): rs.isize => { + return rs.isizeMul(a061, a153); })(a, b); } } else if (_30 === 3) { - const _41: rt.u8 = rt.u8Rem(form, 3); + const _41: rs.u8 = rs.u8Rem(form, 3); if (_41 === 0) { - v = rt.isizeDiv(a, b); + v = rs.isizeDiv(a, b); } else if (_41 === 1) { - v = two$isize_isize_isize_ops_Div_div_isize_isize((a060: rt.isize, a152: rt.isize): rt.isize => { - return rt.isizeDiv(a060, a152); + v = two$isize_isize_isize_ops_Div_div_isize_isize((a060: rs.isize, a152: rs.isize): rs.isize => { + return rs.isizeDiv(a060, a152); }, a, b); } else { - v = ((a059: rt.isize, a151: rt.isize): rt.isize => { - return rt.isizeDiv(a059, a151); + v = ((a059: rs.isize, a151: rs.isize): rs.isize => { + return rs.isizeDiv(a059, a151); })(a, b); } } else if (_30 === 4) { - const _44: rt.u8 = rt.u8Rem(form, 3); + const _44: rs.u8 = rs.u8Rem(form, 3); if (_44 === 0) { - v = rt.isizeRem(a, b); + v = rs.isizeRem(a, b); } else if (_44 === 1) { - v = two$isize_isize_isize_ops_Rem_rem_isize_isize((a058: rt.isize, a150: rt.isize): rt.isize => { - return rt.isizeRem(a058, a150); + v = two$isize_isize_isize_ops_Rem_rem_isize_isize((a058: rs.isize, a150: rs.isize): rs.isize => { + return rs.isizeRem(a058, a150); }, a, b); } else { - v = ((a057: rt.isize, a149: rt.isize): rt.isize => { - return rt.isizeRem(a057, a149); + v = ((a057: rs.isize, a149: rs.isize): rs.isize => { + return rs.isizeRem(a057, a149); })(a, b); } } else if (_30 === 5) { - const _47: rt.u8 = rt.u8Rem(form, 3); + const _47: rs.u8 = rs.u8Rem(form, 3); if (_47 === 0) { v = a & b; } else if (_47 === 1) { - v = two$isize_isize_isize_ops_BitAnd_bitand_isize_isize((a056: rt.isize, a148: rt.isize): rt.isize => { + v = two$isize_isize_isize_ops_BitAnd_bitand_isize_isize((a056: rs.isize, a148: rs.isize): rs.isize => { return a056 & a148; }, a, b); } else { - v = ((a055: rt.isize, a147: rt.isize): rt.isize => { + v = ((a055: rs.isize, a147: rs.isize): rs.isize => { return a055 & a147; })(a, b); } } else if (_30 === 6) { - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { v = a | b; } else if (_50 === 1) { - v = two$isize_isize_isize_ops_BitOr_bitor_isize_isize((a054: rt.isize, a146: rt.isize): rt.isize => { + v = two$isize_isize_isize_ops_BitOr_bitor_isize_isize((a054: rs.isize, a146: rs.isize): rs.isize => { return a054 | a146; }, a, b); } else { - v = ((a053: rt.isize, a145: rt.isize): rt.isize => { + v = ((a053: rs.isize, a145: rs.isize): rs.isize => { return a053 | a145; })(a, b); } } else if (_30 === 7) { - const _53: rt.u8 = rt.u8Rem(form, 3); + const _53: rs.u8 = rs.u8Rem(form, 3); if (_53 === 0) { v = a ^ b; } else if (_53 === 1) { - v = two$isize_isize_isize_ops_BitXor_bitxor_isize_isize((a052: rt.isize, a144: rt.isize): rt.isize => { + v = two$isize_isize_isize_ops_BitXor_bitxor_isize_isize((a052: rs.isize, a144: rs.isize): rs.isize => { return a052 ^ a144; }, a, b); } else { - v = ((a051: rt.isize, a143: rt.isize): rt.isize => { + v = ((a051: rs.isize, a143: rs.isize): rs.isize => { return a051 ^ a143; })(a, b); } } else if (_30 === 8) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { - v = rt.isizeShl(a, n); + v = rs.isizeShl(a, n); } else if (_56 === 1) { - v = two$isize_u32_isize_ops_Shl_shl_isize_u32((a050: rt.isize, a142: rt.u32): rt.isize => { - return rt.isizeShl(a050, a142); + v = two$isize_u32_isize_ops_Shl_shl_isize_u32((a050: rs.isize, a142: rs.u32): rs.isize => { + return rs.isizeShl(a050, a142); }, a, n); } else { - v = ((a049: rt.isize, a141: rt.u32): rt.isize => { - return rt.isizeShl(a049, a141); + v = ((a049: rs.isize, a141: rs.u32): rs.isize => { + return rs.isizeShl(a049, a141); })(a, n); } } else if (_30 === 9) { - const _59: rt.u8 = rt.u8Rem(form, 3); + const _59: rs.u8 = rs.u8Rem(form, 3); if (_59 === 0) { - v = rt.isizeShr(a, n); + v = rs.isizeShr(a, n); } else if (_59 === 1) { - v = two$isize_u32_isize_ops_Shr_shr_isize_u32((a048: rt.isize, a140: rt.u32): rt.isize => { - return rt.isizeShr(a048, a140); + v = two$isize_u32_isize_ops_Shr_shr_isize_u32((a048: rs.isize, a140: rs.u32): rs.isize => { + return rs.isizeShr(a048, a140); }, a, n); } else { - v = ((a047: rt.isize, a139: rt.u32): rt.isize => { - return rt.isizeShr(a047, a139); + v = ((a047: rs.isize, a139: rs.u32): rs.isize => { + return rs.isizeShr(a047, a139); })(a, n); } } else if (_30 === 10) { - const _62: rt.u8 = rt.u8Rem(form, 3); + const _62: rs.u8 = rs.u8Rem(form, 3); if (_62 === 0) { - v = rt.isizeShl(a, (n << 16) >> 16); + v = rs.isizeShl(a, (n << 16) >> 16); } else if (_62 === 1) { - v = two$isize_i16_isize_ops_Shl_shl_isize_i16((a046: rt.isize, a138: rt.i16): rt.isize => { - return rt.isizeShl(a046, a138); + v = two$isize_i16_isize_ops_Shl_shl_isize_i16((a046: rs.isize, a138: rs.i16): rs.isize => { + return rs.isizeShl(a046, a138); }, a, (n << 16) >> 16); } else { - v = ((a045: rt.isize, a137: rt.i16): rt.isize => { - return rt.isizeShl(a045, a137); + v = ((a045: rs.isize, a137: rs.i16): rs.isize => { + return rs.isizeShl(a045, a137); })(a, (n << 16) >> 16); } } else if (_30 === 11) { - const _68: rt.u8 = rt.u8Rem(form, 3); + const _68: rs.u8 = rs.u8Rem(form, 3); if (_68 === 0) { - v = rt.isizeShr(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = rs.isizeShr(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } else if (_68 === 1) { - const _74: rt.u128 = rt.u128Shl(n as rt.u128, (n & 64) >>> 0); - v = two$isize_u128_isize_ops_Shr_shr_isize_u128((a044: rt.isize, a136: rt.u128): rt.isize => { - return rt.isizeShr(a044, a136); + const _74: rs.u128 = rs.u128Shl(n as rs.u128, (n & 64) >>> 0); + v = two$isize_u128_isize_ops_Shr_shr_isize_u128((a044: rs.isize, a136: rs.u128): rs.isize => { + return rs.isizeShr(a044, a136); }, a, _74); } else { - v = ((a043: rt.isize, a135: rt.u128): rt.isize => { - return rt.isizeShr(a043, a135); - })(a, rt.u128Shl(n as rt.u128, (n & 64) >>> 0)); + v = ((a043: rs.isize, a135: rs.u128): rs.isize => { + return rs.isizeShr(a043, a135); + })(a, rs.u128Shl(n as rs.u128, (n & 64) >>> 0)); } } else if (_30 === 12) { - const _83: rt.u8 = rt.u8Rem(form, 3); + const _83: rs.u8 = rs.u8Rem(form, 3); if (_83 === 0) { v = ~a; } else if (_83 === 1) { - v = one$isize_isize_ops_Not_not_isize((a042: rt.isize): rt.isize => { + v = one$isize_isize_ops_Not_not_isize((a042: rs.isize): rs.isize => { return ~a042; }, a); } else { - v = ((a041: rt.isize): rt.isize => { + v = ((a041: rs.isize): rs.isize => { return ~a041; })(a); } } else if (_30 === 13) { - if (rt.u8Rem(rt.u8Div(form, 3), 2) === 0) { - const _92: rt.u8 = rt.u8Rem(form, 3); + if (rs.u8Rem(rs.u8Div(form, 3), 2) === 0) { + const _92: rs.u8 = rs.u8Rem(form, 3); if (_92 === 0) { - _87 = rt.isizeNeg(a); + _87 = rs.isizeNeg(a); } else if (_92 === 1) { - _87 = one$isize_isize_ops_Neg_neg_isize((a040: rt.isize): rt.isize => { - return rt.isizeNeg(a040); + _87 = one$isize_isize_ops_Neg_neg_isize((a040: rs.isize): rs.isize => { + return rs.isizeNeg(a040); }, a); } else { - _87 = ((a039: rt.isize): rt.isize => { - return rt.isizeNeg(a039); + _87 = ((a039: rs.isize): rs.isize => { + return rs.isizeNeg(a039); })(a); } } else { - const _95: rt.u8 = rt.u8Rem(form, 3); + const _95: rs.u8 = rs.u8Rem(form, 3); if (_95 === 0) { - _87 = rt.isizeNeg(a); + _87 = rs.isizeNeg(a); } else if (_95 === 1) { - _87 = one$ref_isize_isize_ops_Neg_neg_ref_isize((a038: rt.isize): rt.isize => { - return rt.isizeNeg(a038); + _87 = one$ref_isize_isize_ops_Neg_neg_ref_isize((a038: rs.isize): rs.isize => { + return rs.isizeNeg(a038); }, a); } else { - _87 = ((a037: rt.isize): rt.isize => { - return rt.isizeNeg(a037); + _87 = ((a037: rs.isize): rs.isize => { + return rs.isizeNeg(a037); })(a); } } - const _86: rt.isize | undefined = _87; + const _86: rs.isize | undefined = _87; if (_86 === undefined) { break b0; } v = _86; } else if (_30 === 14) { - let x: rt.isize = a; - const _105: rt.u8 = rt.u8Rem(form, 3); + let x: rs.isize = a; + const _105: rs.u8 = rs.u8Rem(form, 3); if (_105 === 0) { - x = rt.isizeAdd(x, b); + x = rs.isizeAdd(x, b); } else if (_105 === 1) { - two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize((a036: rt.Place, a134: rt.isize): undefined => { - a036.v = rt.isizeAdd(a036.v, a134); - }, rt.place(() => x, (value26) => x = value26), b); + two$mut_isize_isize_unit_ops_AddAssign_add_assign_isize_isize((a036: rs.Place, a134: rs.isize): undefined => { + a036.v = rs.isizeAdd(a036.v, a134); + }, rs.place(() => x, (value26) => x = value26), b); } else { - ((a035: rt.Place, a133: rt.isize): undefined => { - a035.v = rt.isizeAdd(a035.v, a133); - })(rt.place(() => x, (value25) => x = value25), b); + ((a035: rs.Place, a133: rs.isize): undefined => { + a035.v = rs.isizeAdd(a035.v, a133); + })(rs.place(() => x, (value25) => x = value25), b); } v = x; } else if (_30 === 15) { - let x2: rt.isize = a; - const _113: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.isize = a; + const _113: rs.u8 = rs.u8Rem(form, 3); if (_113 === 0) { - x2 = rt.isizeSub(x2, b); + x2 = rs.isizeSub(x2, b); } else if (_113 === 1) { - two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize((a034: rt.Place, a132: rt.isize): undefined => { - a034.v = rt.isizeSub(a034.v, a132); - }, rt.place(() => x2, (value24) => x2 = value24), b); + two$mut_isize_isize_unit_ops_SubAssign_sub_assign_isize_isize((a034: rs.Place, a132: rs.isize): undefined => { + a034.v = rs.isizeSub(a034.v, a132); + }, rs.place(() => x2, (value24) => x2 = value24), b); } else { - ((a033: rt.Place, a131: rt.isize): undefined => { - a033.v = rt.isizeSub(a033.v, a131); - })(rt.place(() => x2, (value23) => x2 = value23), b); + ((a033: rs.Place, a131: rs.isize): undefined => { + a033.v = rs.isizeSub(a033.v, a131); + })(rs.place(() => x2, (value23) => x2 = value23), b); } v = x2; } else if (_30 === 16) { - let x3: rt.isize = a; - const _121: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.isize = a; + const _121: rs.u8 = rs.u8Rem(form, 3); if (_121 === 0) { - x3 = rt.isizeMul(x3, b); + x3 = rs.isizeMul(x3, b); } else if (_121 === 1) { - two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize((a032: rt.Place, a130: rt.isize): undefined => { - a032.v = rt.isizeMul(a032.v, a130); - }, rt.place(() => x3, (value22) => x3 = value22), b); + two$mut_isize_isize_unit_ops_MulAssign_mul_assign_isize_isize((a032: rs.Place, a130: rs.isize): undefined => { + a032.v = rs.isizeMul(a032.v, a130); + }, rs.place(() => x3, (value22) => x3 = value22), b); } else { - ((a031: rt.Place, a129: rt.isize): undefined => { - a031.v = rt.isizeMul(a031.v, a129); - })(rt.place(() => x3, (value21) => x3 = value21), b); + ((a031: rs.Place, a129: rs.isize): undefined => { + a031.v = rs.isizeMul(a031.v, a129); + })(rs.place(() => x3, (value21) => x3 = value21), b); } v = x3; } else if (_30 === 17) { - let x4: rt.isize = a; - const _129: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.isize = a; + const _129: rs.u8 = rs.u8Rem(form, 3); if (_129 === 0) { - x4 = rt.isizeDiv(x4, b); + x4 = rs.isizeDiv(x4, b); } else if (_129 === 1) { - two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize((a030: rt.Place, a128: rt.isize): undefined => { - a030.v = rt.isizeDiv(a030.v, a128); - }, rt.place(() => x4, (value20) => x4 = value20), b); + two$mut_isize_isize_unit_ops_DivAssign_div_assign_isize_isize((a030: rs.Place, a128: rs.isize): undefined => { + a030.v = rs.isizeDiv(a030.v, a128); + }, rs.place(() => x4, (value20) => x4 = value20), b); } else { - ((a029: rt.Place, a127: rt.isize): undefined => { - a029.v = rt.isizeDiv(a029.v, a127); - })(rt.place(() => x4, (value19) => x4 = value19), b); + ((a029: rs.Place, a127: rs.isize): undefined => { + a029.v = rs.isizeDiv(a029.v, a127); + })(rs.place(() => x4, (value19) => x4 = value19), b); } v = x4; } else if (_30 === 18) { - let x5: rt.isize = a; - const _137: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.isize = a; + const _137: rs.u8 = rs.u8Rem(form, 3); if (_137 === 0) { - x5 = rt.isizeRem(x5, b); + x5 = rs.isizeRem(x5, b); } else if (_137 === 1) { - two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize((a028: rt.Place, a126: rt.isize): undefined => { - a028.v = rt.isizeRem(a028.v, a126); - }, rt.place(() => x5, (value18) => x5 = value18), b); + two$mut_isize_isize_unit_ops_RemAssign_rem_assign_isize_isize((a028: rs.Place, a126: rs.isize): undefined => { + a028.v = rs.isizeRem(a028.v, a126); + }, rs.place(() => x5, (value18) => x5 = value18), b); } else { - ((a027: rt.Place, a125: rt.isize): undefined => { - a027.v = rt.isizeRem(a027.v, a125); - })(rt.place(() => x5, (value17) => x5 = value17), b); + ((a027: rs.Place, a125: rs.isize): undefined => { + a027.v = rs.isizeRem(a027.v, a125); + })(rs.place(() => x5, (value17) => x5 = value17), b); } v = x5; } else if (_30 === 19) { - let x6: rt.isize = a; - const _145: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.isize = a; + const _145: rs.u8 = rs.u8Rem(form, 3); if (_145 === 0) { x6 = x6 & b; } else if (_145 === 1) { - two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize((a026: rt.Place, a124: rt.isize): undefined => { + two$mut_isize_isize_unit_ops_BitAndAssign_bitand_assign_isize_isize((a026: rs.Place, a124: rs.isize): undefined => { a026.v = a026.v & a124; - }, rt.place(() => x6, (value16) => x6 = value16), b); + }, rs.place(() => x6, (value16) => x6 = value16), b); } else { - ((a025: rt.Place, a123: rt.isize): undefined => { + ((a025: rs.Place, a123: rs.isize): undefined => { a025.v = a025.v & a123; - })(rt.place(() => x6, (value15) => x6 = value15), b); + })(rs.place(() => x6, (value15) => x6 = value15), b); } v = x6; } else if (_30 === 20) { - let x7: rt.isize = a; - const _153: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.isize = a; + const _153: rs.u8 = rs.u8Rem(form, 3); if (_153 === 0) { x7 = x7 | b; } else if (_153 === 1) { - two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize((a024: rt.Place, a122: rt.isize): undefined => { + two$mut_isize_isize_unit_ops_BitOrAssign_bitor_assign_isize_isize((a024: rs.Place, a122: rs.isize): undefined => { a024.v = a024.v | a122; - }, rt.place(() => x7, (value14) => x7 = value14), b); + }, rs.place(() => x7, (value14) => x7 = value14), b); } else { - ((a023: rt.Place, a121: rt.isize): undefined => { + ((a023: rs.Place, a121: rs.isize): undefined => { a023.v = a023.v | a121; - })(rt.place(() => x7, (value13) => x7 = value13), b); + })(rs.place(() => x7, (value13) => x7 = value13), b); } v = x7; } else if (_30 === 21) { - let x8: rt.isize = a; - const _161: rt.u8 = rt.u8Rem(form, 3); + let x8: rs.isize = a; + const _161: rs.u8 = rs.u8Rem(form, 3); if (_161 === 0) { x8 = x8 ^ b; } else if (_161 === 1) { - two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize((a022: rt.Place, a120: rt.isize): undefined => { + two$mut_isize_isize_unit_ops_BitXorAssign_bitxor_assign_isize_isize((a022: rs.Place, a120: rs.isize): undefined => { a022.v = a022.v ^ a120; - }, rt.place(() => x8, (value12) => x8 = value12), b); + }, rs.place(() => x8, (value12) => x8 = value12), b); } else { - ((a021: rt.Place, a119: rt.isize): undefined => { + ((a021: rs.Place, a119: rs.isize): undefined => { a021.v = a021.v ^ a119; - })(rt.place(() => x8, (value11) => x8 = value11), b); + })(rs.place(() => x8, (value11) => x8 = value11), b); } v = x8; } else if (_30 === 22) { - let x9: rt.isize = a; - const _169: rt.u8 = rt.u8Rem(form, 3); + let x9: rs.isize = a; + const _169: rs.u8 = rs.u8Rem(form, 3); if (_169 === 0) { - x9 = rt.isizeShl(x9, n); + x9 = rs.isizeShl(x9, n); } else if (_169 === 1) { - two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32((a020: rt.Place, a118: rt.u32): undefined => { - a020.v = rt.isizeShl(a020.v, a118); - }, rt.place(() => x9, (value10) => x9 = value10), n); + two$mut_isize_u32_unit_ops_ShlAssign_shl_assign_isize_u32((a020: rs.Place, a118: rs.u32): undefined => { + a020.v = rs.isizeShl(a020.v, a118); + }, rs.place(() => x9, (value10) => x9 = value10), n); } else { - ((a019: rt.Place, a117: rt.u32): undefined => { - a019.v = rt.isizeShl(a019.v, a117); - })(rt.place(() => x9, (value9) => x9 = value9), n); + ((a019: rs.Place, a117: rs.u32): undefined => { + a019.v = rs.isizeShl(a019.v, a117); + })(rs.place(() => x9, (value9) => x9 = value9), n); } v = x9; } else if (_30 === 23) { - let x10: rt.isize = a; - const _177: rt.u8 = rt.u8Rem(form, 3); + let x10: rs.isize = a; + const _177: rs.u8 = rs.u8Rem(form, 3); if (_177 === 0) { - x10 = rt.isizeShr(x10, (n << 16) >> 16 as rt.i64); + x10 = rs.isizeShr(x10, (n << 16) >> 16 as rs.i64); } else if (_177 === 1) { - two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64((a018: rt.Place, a116: rt.i64): undefined => { - a018.v = rt.isizeShr(a018.v, a116); - }, rt.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rt.i64); + two$mut_isize_i64_unit_ops_ShrAssign_shr_assign_isize_i64((a018: rs.Place, a116: rs.i64): undefined => { + a018.v = rs.isizeShr(a018.v, a116); + }, rs.place(() => x10, (value8) => x10 = value8), (n << 16) >> 16 as rs.i64); } else { - ((a017: rt.Place, a115: rt.i64): undefined => { - a017.v = rt.isizeShr(a017.v, a115); - })(rt.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rt.i64); + ((a017: rs.Place, a115: rs.i64): undefined => { + a017.v = rs.isizeShr(a017.v, a115); + })(rs.place(() => x10, (value7) => x10 = value7), (n << 16) >> 16 as rs.i64); } v = x10; } else if (_30 === 24) { - const _189: rt.u8 = rt.u8Rem(form, 3); + const _189: rs.u8 = rs.u8Rem(form, 3); if (_189 === 0) { - v = rt.isizeAdd(a, b); + v = rs.isizeAdd(a, b); } else if (_189 === 1) { - v = two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize((a016: rt.isize, a114: rt.isize): rt.isize => { - return rt.isizeAdd(a016, a114); + v = two$isize_ref_isize_isize_ops_Add_add_isize_ref_isize((a016: rs.isize, a114: rs.isize): rs.isize => { + return rs.isizeAdd(a016, a114); }, a, b); } else { - v = ((a015: rt.isize, a113: rt.isize): rt.isize => { - return rt.isizeAdd(a015, a113); + v = ((a015: rs.isize, a113: rs.isize): rs.isize => { + return rs.isizeAdd(a015, a113); })(a, b); } } else if (_30 === 25) { - const _195: rt.u8 = rt.u8Rem(form, 3); + const _195: rs.u8 = rs.u8Rem(form, 3); if (_195 === 0) { - v = rt.isizeSub(a, b); + v = rs.isizeSub(a, b); } else if (_195 === 1) { - v = two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize((a014: rt.isize, a112: rt.isize): rt.isize => { - return rt.isizeSub(a014, a112); + v = two$ref_isize_isize_isize_ops_Sub_sub_ref_isize_isize((a014: rs.isize, a112: rs.isize): rs.isize => { + return rs.isizeSub(a014, a112); }, a, b); } else { - v = ((a013: rt.isize, a111: rt.isize): rt.isize => { - return rt.isizeSub(a013, a111); + v = ((a013: rs.isize, a111: rs.isize): rs.isize => { + return rs.isizeSub(a013, a111); })(a, b); } } else if (_30 === 26) { - const _201: rt.u8 = rt.u8Rem(form, 3); + const _201: rs.u8 = rs.u8Rem(form, 3); if (_201 === 0) { - v = rt.isizeMul(a, b); + v = rs.isizeMul(a, b); } else if (_201 === 1) { - v = two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize((a012: rt.isize, a110: rt.isize): rt.isize => { - return rt.isizeMul(a012, a110); + v = two$ref_isize_ref_isize_isize_ops_Mul_mul_ref_isize_ref_isize((a012: rs.isize, a110: rs.isize): rs.isize => { + return rs.isizeMul(a012, a110); }, a, b); } else { - v = ((a011: rt.isize, a19: rt.isize): rt.isize => { - return rt.isizeMul(a011, a19); + v = ((a011: rs.isize, a19: rs.isize): rs.isize => { + return rs.isizeMul(a011, a19); })(a, b); } } else if (_30 === 27) { - const _210: rt.u8 = rt.u8Rem(form, 3); + const _210: rs.u8 = rs.u8Rem(form, 3); if (_210 === 0) { - v = rt.isizeShl(a, n & 0xff); + v = rs.isizeShl(a, n & 0xff); } else if (_210 === 1) { - v = two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8((a010: rt.isize, a18: rt.u8): rt.isize => { - return rt.isizeShl(a010, a18); + v = two$ref_isize_ref_u8_isize_ops_Shl_shl_ref_isize_ref_u8((a010: rs.isize, a18: rs.u8): rs.isize => { + return rs.isizeShl(a010, a18); }, a, n & 0xff); } else { - v = ((a09: rt.isize, a17: rt.u8): rt.isize => { - return rt.isizeShl(a09, a17); + v = ((a09: rs.isize, a17: rs.u8): rs.isize => { + return rs.isizeShl(a09, a17); })(a, n & 0xff); } } else if (_30 === 28) { - const _222: rt.u8 = rt.u8Rem(form, 3); + const _222: rs.u8 = rs.u8Rem(form, 3); if (_222 === 0) { v = ~a; } else if (_222 === 1) { - v = one$ref_isize_isize_ops_Not_not_ref_isize((a08: rt.isize): rt.isize => { + v = one$ref_isize_isize_ops_Not_not_ref_isize((a08: rs.isize): rs.isize => { return ~a08; }, a); } else { - v = ((a07: rt.isize): rt.isize => { + v = ((a07: rs.isize): rs.isize => { return ~a07; })(a); } } else if (_30 === 29) { - let x11: rt.isize = a; - const _230: rt.u8 = rt.u8Rem(form, 3); + let x11: rs.isize = a; + const _230: rs.u8 = rs.u8Rem(form, 3); if (_230 === 0) { - x11 = rt.isizeAdd(x11, b); + x11 = rs.isizeAdd(x11, b); } else if (_230 === 1) { - two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize((a06: rt.Place, a16: rt.isize): undefined => { - a06.v = rt.isizeAdd(a06.v, a16); - }, rt.place(() => x11, (value6) => x11 = value6), b); + two$mut_isize_ref_isize_unit_ops_AddAssign_add_assign_isize_ref_isize((a06: rs.Place, a16: rs.isize): undefined => { + a06.v = rs.isizeAdd(a06.v, a16); + }, rs.place(() => x11, (value6) => x11 = value6), b); } else { - ((a05: rt.Place, a15: rt.isize): undefined => { - a05.v = rt.isizeAdd(a05.v, a15); - })(rt.place(() => x11, (value5) => x11 = value5), b); + ((a05: rs.Place, a15: rs.isize): undefined => { + a05.v = rs.isizeAdd(a05.v, a15); + })(rs.place(() => x11, (value5) => x11 = value5), b); } v = x11; } else if (_30 === 30) { - let x12: rt.isize = a; - const _241: rt.u8 = rt.u8Rem(form, 3); + let x12: rs.isize = a; + const _241: rs.u8 = rs.u8Rem(form, 3); if (_241 === 0) { - x12 = rt.isizeDiv(x12, b); + x12 = rs.isizeDiv(x12, b); } else if (_241 === 1) { - two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize((a04: rt.Place, a14: rt.isize): undefined => { - a04.v = rt.isizeDiv(a04.v, a14); - }, rt.place(() => x12, (value4) => x12 = value4), b); + two$mut_isize_ref_isize_unit_ops_DivAssign_div_assign_isize_ref_isize((a04: rs.Place, a14: rs.isize): undefined => { + a04.v = rs.isizeDiv(a04.v, a14); + }, rs.place(() => x12, (value4) => x12 = value4), b); } else { - ((a03: rt.Place, a13: rt.isize): undefined => { - a03.v = rt.isizeDiv(a03.v, a13); - })(rt.place(() => x12, (value3) => x12 = value3), b); + ((a03: rs.Place, a13: rs.isize): undefined => { + a03.v = rs.isizeDiv(a03.v, a13); + })(rs.place(() => x12, (value3) => x12 = value3), b); } v = x12; } else { - let x13: rt.isize = a; - const _252: rt.u8 = rt.u8Rem(form, 3); + let x13: rs.isize = a; + const _252: rs.u8 = rs.u8Rem(form, 3); if (_252 === 0) { - x13 = rt.isizeShr(x13, n & 0xffff); + x13 = rs.isizeShr(x13, n & 0xffff); } else if (_252 === 1) { - two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16((a02: rt.Place, a12: rt.u16): undefined => { - a02.v = rt.isizeShr(a02.v, a12); - }, rt.place(() => x13, (value2) => x13 = value2), n & 0xffff); + two$mut_isize_ref_u16_unit_ops_ShrAssign_shr_assign_isize_ref_u16((a02: rs.Place, a12: rs.u16): undefined => { + a02.v = rs.isizeShr(a02.v, a12); + }, rs.place(() => x13, (value2) => x13 = value2), n & 0xffff); } else { - ((a0: rt.Place, a1: rt.u16): undefined => { - a0.v = rt.isizeShr(a0.v, a1); - })(rt.place(() => x13, (value) => x13 = value), n & 0xffff); + ((a0: rs.Place, a1: rs.u16): undefined => { + a0.v = rs.isizeShr(a0.v, a1); + })(rs.place(() => x13, (value) => x13 = value), n & 0xffff); } v = x13; } @@ -8317,246 +8317,246 @@ export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operator `kind` to two doubles' bits taken from `data`, rounded to the type, * in the form its first byte picks. */ -export function f64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.f64; - let v2!: rt.f64; - const take: (a0: rt.usize) => rt.f64 = (at: rt.usize): rt.f64 => { - const buf: Uint8Array = rt.bytes(8); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); +export function f64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.f64; + let v2!: rs.f64; + const take: (a0: rs.usize) => rs.f64 = (at: rs.usize): rs.f64 => { + const buf: Uint8Array = rs.bytes(8); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _103: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_103 === rt.DONE) { + const _103: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_103 === rs.DONE) { break; } - _103[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _103[0])), 0); + _103[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _103[0])), 0); } - return rt.f64FromBits(rt.u64FromBeBytes(buf)); + return rs.f64FromBits(rs.u64FromBeBytes(buf)); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.f64, rt.f64] = [take(1), take(9)]; - const a: rt.f64 = _10[0]; - const b: rt.f64 = _10[1]; - const _18: rt.u8 = rt.u8Rem(kind, 16); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.f64, rs.f64] = [take(1), take(9)]; + const a: rs.f64 = _10[0]; + const b: rs.f64 = _10[1]; + const _18: rs.u8 = rs.u8Rem(kind, 16); if (_18 === 0) { - const _20: rt.u8 = rt.u8Rem(form, 3); + const _20: rs.u8 = rs.u8Rem(form, 3); if (_20 === 0) { v = a + b; } else if (_20 === 1) { - v = two$f64_f64_f64_ops_Add_add_f64_f64((a032: rt.f64, a128: rt.f64): rt.f64 => { + v = two$f64_f64_f64_ops_Add_add_f64_f64((a032: rs.f64, a128: rs.f64): rs.f64 => { return a032 + a128; }, a, b); } else { - v = ((a031: rt.f64, a127: rt.f64): rt.f64 => { + v = ((a031: rs.f64, a127: rs.f64): rs.f64 => { return a031 + a127; })(a, b); } } else if (_18 === 1) { - const _23: rt.u8 = rt.u8Rem(form, 3); + const _23: rs.u8 = rs.u8Rem(form, 3); if (_23 === 0) { v = a - b; } else if (_23 === 1) { - v = two$f64_f64_f64_ops_Sub_sub_f64_f64((a030: rt.f64, a126: rt.f64): rt.f64 => { + v = two$f64_f64_f64_ops_Sub_sub_f64_f64((a030: rs.f64, a126: rs.f64): rs.f64 => { return a030 - a126; }, a, b); } else { - v = ((a029: rt.f64, a125: rt.f64): rt.f64 => { + v = ((a029: rs.f64, a125: rs.f64): rs.f64 => { return a029 - a125; })(a, b); } } else if (_18 === 2) { - const _26: rt.u8 = rt.u8Rem(form, 3); + const _26: rs.u8 = rs.u8Rem(form, 3); if (_26 === 0) { v = a * b; } else if (_26 === 1) { - v = two$f64_f64_f64_ops_Mul_mul_f64_f64((a028: rt.f64, a124: rt.f64): rt.f64 => { + v = two$f64_f64_f64_ops_Mul_mul_f64_f64((a028: rs.f64, a124: rs.f64): rs.f64 => { return a028 * a124; }, a, b); } else { - v = ((a027: rt.f64, a123: rt.f64): rt.f64 => { + v = ((a027: rs.f64, a123: rs.f64): rs.f64 => { return a027 * a123; })(a, b); } } else if (_18 === 3) { - const _29: rt.u8 = rt.u8Rem(form, 3); + const _29: rs.u8 = rs.u8Rem(form, 3); if (_29 === 0) { v = a / b; } else if (_29 === 1) { - v = two$f64_f64_f64_ops_Div_div_f64_f64((a026: rt.f64, a122: rt.f64): rt.f64 => { + v = two$f64_f64_f64_ops_Div_div_f64_f64((a026: rs.f64, a122: rs.f64): rs.f64 => { return a026 / a122; }, a, b); } else { - v = ((a025: rt.f64, a121: rt.f64): rt.f64 => { + v = ((a025: rs.f64, a121: rs.f64): rs.f64 => { return a025 / a121; })(a, b); } } else if (_18 === 4) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { v = a % b; } else if (_32 === 1) { - v = two$f64_f64_f64_ops_Rem_rem_f64_f64((a024: rt.f64, a120: rt.f64): rt.f64 => { + v = two$f64_f64_f64_ops_Rem_rem_f64_f64((a024: rs.f64, a120: rs.f64): rs.f64 => { return a024 % a120; }, a, b); } else { - v = ((a023: rt.f64, a119: rt.f64): rt.f64 => { + v = ((a023: rs.f64, a119: rs.f64): rs.f64 => { return a023 % a119; })(a, b); } } else if (_18 === 5) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { v = -a; } else if (_35 === 1) { - v = one$f64_f64_ops_Neg_neg_f64((a022: rt.f64): rt.f64 => { + v = one$f64_f64_ops_Neg_neg_f64((a022: rs.f64): rs.f64 => { return -a022; }, a); } else { - v = ((a021: rt.f64): rt.f64 => { + v = ((a021: rs.f64): rs.f64 => { return -a021; })(a); } } else if (_18 === 6) { - let x: rt.f64 = a; - const _40: rt.u8 = rt.u8Rem(form, 3); + let x: rs.f64 = a; + const _40: rs.u8 = rs.u8Rem(form, 3); if (_40 === 0) { x = x + b; } else if (_40 === 1) { - two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64((a020: rt.Place, a118: rt.f64): undefined => { + two$mut_f64_f64_unit_ops_AddAssign_add_assign_f64_f64((a020: rs.Place, a118: rs.f64): undefined => { a020.v = a020.v + a118; - }, rt.place(() => x, (value14) => x = value14), b); + }, rs.place(() => x, (value14) => x = value14), b); } else { - ((a019: rt.Place, a117: rt.f64): undefined => { + ((a019: rs.Place, a117: rs.f64): undefined => { a019.v = a019.v + a117; - })(rt.place(() => x, (value13) => x = value13), b); + })(rs.place(() => x, (value13) => x = value13), b); } v = x; } else if (_18 === 7) { - let x2: rt.f64 = a; - const _48: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.f64 = a; + const _48: rs.u8 = rs.u8Rem(form, 3); if (_48 === 0) { x2 = x2 - b; } else if (_48 === 1) { - two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64((a018: rt.Place, a116: rt.f64): undefined => { + two$mut_f64_f64_unit_ops_SubAssign_sub_assign_f64_f64((a018: rs.Place, a116: rs.f64): undefined => { a018.v = a018.v - a116; - }, rt.place(() => x2, (value12) => x2 = value12), b); + }, rs.place(() => x2, (value12) => x2 = value12), b); } else { - ((a017: rt.Place, a115: rt.f64): undefined => { + ((a017: rs.Place, a115: rs.f64): undefined => { a017.v = a017.v - a115; - })(rt.place(() => x2, (value11) => x2 = value11), b); + })(rs.place(() => x2, (value11) => x2 = value11), b); } v = x2; } else if (_18 === 8) { - let x3: rt.f64 = a; - const _56: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.f64 = a; + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { x3 = x3 * b; } else if (_56 === 1) { - two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64((a016: rt.Place, a114: rt.f64): undefined => { + two$mut_f64_f64_unit_ops_MulAssign_mul_assign_f64_f64((a016: rs.Place, a114: rs.f64): undefined => { a016.v = a016.v * a114; - }, rt.place(() => x3, (value10) => x3 = value10), b); + }, rs.place(() => x3, (value10) => x3 = value10), b); } else { - ((a015: rt.Place, a113: rt.f64): undefined => { + ((a015: rs.Place, a113: rs.f64): undefined => { a015.v = a015.v * a113; - })(rt.place(() => x3, (value9) => x3 = value9), b); + })(rs.place(() => x3, (value9) => x3 = value9), b); } v = x3; } else if (_18 === 9) { - let x4: rt.f64 = a; - const _64: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.f64 = a; + const _64: rs.u8 = rs.u8Rem(form, 3); if (_64 === 0) { x4 = x4 / b; } else if (_64 === 1) { - two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64((a014: rt.Place, a112: rt.f64): undefined => { + two$mut_f64_f64_unit_ops_DivAssign_div_assign_f64_f64((a014: rs.Place, a112: rs.f64): undefined => { a014.v = a014.v / a112; - }, rt.place(() => x4, (value8) => x4 = value8), b); + }, rs.place(() => x4, (value8) => x4 = value8), b); } else { - ((a013: rt.Place, a111: rt.f64): undefined => { + ((a013: rs.Place, a111: rs.f64): undefined => { a013.v = a013.v / a111; - })(rt.place(() => x4, (value7) => x4 = value7), b); + })(rs.place(() => x4, (value7) => x4 = value7), b); } v = x4; } else if (_18 === 10) { - let x5: rt.f64 = a; - const _72: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.f64 = a; + const _72: rs.u8 = rs.u8Rem(form, 3); if (_72 === 0) { x5 = x5 % b; } else if (_72 === 1) { - two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64((a012: rt.Place, a110: rt.f64): undefined => { + two$mut_f64_f64_unit_ops_RemAssign_rem_assign_f64_f64((a012: rs.Place, a110: rs.f64): undefined => { a012.v = a012.v % a110; - }, rt.place(() => x5, (value6) => x5 = value6), b); + }, rs.place(() => x5, (value6) => x5 = value6), b); } else { - ((a011: rt.Place, a19: rt.f64): undefined => { + ((a011: rs.Place, a19: rs.f64): undefined => { a011.v = a011.v % a19; - })(rt.place(() => x5, (value5) => x5 = value5), b); + })(rs.place(() => x5, (value5) => x5 = value5), b); } v = x5; } else if (_18 === 11) { - const _78: rt.u8 = rt.u8Rem(form, 3); + const _78: rs.u8 = rs.u8Rem(form, 3); if (_78 === 0) { v = a + b; } else if (_78 === 1) { - v = two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64((a010: rt.f64, a18: rt.f64): rt.f64 => { + v = two$ref_f64_ref_f64_f64_ops_Add_add_ref_f64_ref_f64((a010: rs.f64, a18: rs.f64): rs.f64 => { return a010 + a18; }, a, b); } else { - v = ((a09: rt.f64, a17: rt.f64): rt.f64 => { + v = ((a09: rs.f64, a17: rs.f64): rs.f64 => { return a09 + a17; })(a, b); } } else if (_18 === 12) { - const _87: rt.u8 = rt.u8Rem(form, 3); + const _87: rs.u8 = rs.u8Rem(form, 3); if (_87 === 0) { v = a % b; } else if (_87 === 1) { - v = two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64((a08: rt.f64, a16: rt.f64): rt.f64 => { + v = two$f64_ref_f64_f64_ops_Rem_rem_f64_ref_f64((a08: rs.f64, a16: rs.f64): rs.f64 => { return a08 % a16; }, a, b); } else { - v = ((a07: rt.f64, a15: rt.f64): rt.f64 => { + v = ((a07: rs.f64, a15: rs.f64): rs.f64 => { return a07 % a15; })(a, b); } } else if (_18 === 13) { - const _93: rt.u8 = rt.u8Rem(form, 3); + const _93: rs.u8 = rs.u8Rem(form, 3); if (_93 === 0) { v = -a; } else if (_93 === 1) { - v = one$ref_f64_f64_ops_Neg_neg_ref_f64((a06: rt.f64): rt.f64 => { + v = one$ref_f64_f64_ops_Neg_neg_ref_f64((a06: rs.f64): rs.f64 => { return -a06; }, a); } else { - v = ((a05: rt.f64): rt.f64 => { + v = ((a05: rs.f64): rs.f64 => { return -a05; })(a); } } else if (_18 === 14) { - let x6: rt.f64 = a; - const _101: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.f64 = a; + const _101: rs.u8 = rs.u8Rem(form, 3); if (_101 === 0) { x6 = x6 * b; } else if (_101 === 1) { - two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64((a04: rt.Place, a14: rt.f64): undefined => { + two$mut_f64_ref_f64_unit_ops_MulAssign_mul_assign_f64_ref_f64((a04: rs.Place, a14: rs.f64): undefined => { a04.v = a04.v * a14; - }, rt.place(() => x6, (value4) => x6 = value4), b); + }, rs.place(() => x6, (value4) => x6 = value4), b); } else { - ((a03: rt.Place, a13: rt.f64): undefined => { + ((a03: rs.Place, a13: rs.f64): undefined => { a03.v = a03.v * a13; - })(rt.place(() => x6, (value3) => x6 = value3), b); + })(rs.place(() => x6, (value3) => x6 = value3), b); } v = x6; } else { - let x7: rt.f64 = a; - const _112: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.f64 = a; + const _112: rs.u8 = rs.u8Rem(form, 3); if (_112 === 0) { x7 = x7 % b; } else if (_112 === 1) { - two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64((a02: rt.Place, a12: rt.f64): undefined => { + two$mut_f64_ref_f64_unit_ops_RemAssign_rem_assign_f64_ref_f64((a02: rs.Place, a12: rs.f64): undefined => { a02.v = a02.v % a12; - }, rt.place(() => x7, (value2) => x7 = value2), b); + }, rs.place(() => x7, (value2) => x7 = value2), b); } else { - ((a0: rt.Place, a1: rt.f64): undefined => { + ((a0: rs.Place, a1: rs.f64): undefined => { a0.v = a0.v % a1; - })(rt.place(() => x7, (value) => x7 = value), b); + })(rs.place(() => x7, (value) => x7 = value), b); } v = x7; } @@ -8565,253 +8565,253 @@ export function f64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { v2 = NaN; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(v2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(v2)))); } /** * Apply operator `kind` to two doubles' bits taken from `data`, rounded to the type, * in the form its first byte picks. */ -export function f32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let v!: rt.f32; - let v2!: rt.f32; - const take: (a0: rt.usize) => rt.f32 = (at: rt.usize): rt.f32 => { - const buf: Uint8Array = rt.bytes(8); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); +export function f32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let v!: rs.f32; + let v2!: rs.f32; + const take: (a0: rs.usize) => rs.f32 = (at: rs.usize): rs.f32 => { + const buf: Uint8Array = rs.bytes(8); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _103: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_103 === rt.DONE) { + const _103: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_103 === rs.DONE) { break; } - _103[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _103[0])), 0); + _103[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _103[0])), 0); } - return Math.fround(rt.f64FromBits(rt.u64FromBeBytes(buf))); + return Math.fround(rs.f64FromBits(rs.u64FromBeBytes(buf))); }; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _10: [rt.f32, rt.f32] = [take(1), take(9)]; - const a: rt.f32 = _10[0]; - const b: rt.f32 = _10[1]; - const _18: rt.u8 = rt.u8Rem(kind, 16); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _10: [rs.f32, rs.f32] = [take(1), take(9)]; + const a: rs.f32 = _10[0]; + const b: rs.f32 = _10[1]; + const _18: rs.u8 = rs.u8Rem(kind, 16); if (_18 === 0) { - const _20: rt.u8 = rt.u8Rem(form, 3); + const _20: rs.u8 = rs.u8Rem(form, 3); if (_20 === 0) { v = Math.fround(a + b); } else if (_20 === 1) { - v = two$f32_f32_f32_ops_Add_add_f32_f32((a032: rt.f32, a128: rt.f32): rt.f32 => { + v = two$f32_f32_f32_ops_Add_add_f32_f32((a032: rs.f32, a128: rs.f32): rs.f32 => { return Math.fround(a032 + a128); }, a, b); } else { - v = ((a031: rt.f32, a127: rt.f32): rt.f32 => { + v = ((a031: rs.f32, a127: rs.f32): rs.f32 => { return Math.fround(a031 + a127); })(a, b); } } else if (_18 === 1) { - const _23: rt.u8 = rt.u8Rem(form, 3); + const _23: rs.u8 = rs.u8Rem(form, 3); if (_23 === 0) { v = Math.fround(a - b); } else if (_23 === 1) { - v = two$f32_f32_f32_ops_Sub_sub_f32_f32((a030: rt.f32, a126: rt.f32): rt.f32 => { + v = two$f32_f32_f32_ops_Sub_sub_f32_f32((a030: rs.f32, a126: rs.f32): rs.f32 => { return Math.fround(a030 - a126); }, a, b); } else { - v = ((a029: rt.f32, a125: rt.f32): rt.f32 => { + v = ((a029: rs.f32, a125: rs.f32): rs.f32 => { return Math.fround(a029 - a125); })(a, b); } } else if (_18 === 2) { - const _26: rt.u8 = rt.u8Rem(form, 3); + const _26: rs.u8 = rs.u8Rem(form, 3); if (_26 === 0) { v = Math.fround(a * b); } else if (_26 === 1) { - v = two$f32_f32_f32_ops_Mul_mul_f32_f32((a028: rt.f32, a124: rt.f32): rt.f32 => { + v = two$f32_f32_f32_ops_Mul_mul_f32_f32((a028: rs.f32, a124: rs.f32): rs.f32 => { return Math.fround(a028 * a124); }, a, b); } else { - v = ((a027: rt.f32, a123: rt.f32): rt.f32 => { + v = ((a027: rs.f32, a123: rs.f32): rs.f32 => { return Math.fround(a027 * a123); })(a, b); } } else if (_18 === 3) { - const _29: rt.u8 = rt.u8Rem(form, 3); + const _29: rs.u8 = rs.u8Rem(form, 3); if (_29 === 0) { v = Math.fround(a / b); } else if (_29 === 1) { - v = two$f32_f32_f32_ops_Div_div_f32_f32((a026: rt.f32, a122: rt.f32): rt.f32 => { + v = two$f32_f32_f32_ops_Div_div_f32_f32((a026: rs.f32, a122: rs.f32): rs.f32 => { return Math.fround(a026 / a122); }, a, b); } else { - v = ((a025: rt.f32, a121: rt.f32): rt.f32 => { + v = ((a025: rs.f32, a121: rs.f32): rs.f32 => { return Math.fround(a025 / a121); })(a, b); } } else if (_18 === 4) { - const _32: rt.u8 = rt.u8Rem(form, 3); + const _32: rs.u8 = rs.u8Rem(form, 3); if (_32 === 0) { v = a % b; } else if (_32 === 1) { - v = two$f32_f32_f32_ops_Rem_rem_f32_f32((a024: rt.f32, a120: rt.f32): rt.f32 => { + v = two$f32_f32_f32_ops_Rem_rem_f32_f32((a024: rs.f32, a120: rs.f32): rs.f32 => { return a024 % a120; }, a, b); } else { - v = ((a023: rt.f32, a119: rt.f32): rt.f32 => { + v = ((a023: rs.f32, a119: rs.f32): rs.f32 => { return a023 % a119; })(a, b); } } else if (_18 === 5) { - const _35: rt.u8 = rt.u8Rem(form, 3); + const _35: rs.u8 = rs.u8Rem(form, 3); if (_35 === 0) { v = -a; } else if (_35 === 1) { - v = one$f32_f32_ops_Neg_neg_f32((a022: rt.f32): rt.f32 => { + v = one$f32_f32_ops_Neg_neg_f32((a022: rs.f32): rs.f32 => { return -a022; }, a); } else { - v = ((a021: rt.f32): rt.f32 => { + v = ((a021: rs.f32): rs.f32 => { return -a021; })(a); } } else if (_18 === 6) { - let x: rt.f32 = a; - const _40: rt.u8 = rt.u8Rem(form, 3); + let x: rs.f32 = a; + const _40: rs.u8 = rs.u8Rem(form, 3); if (_40 === 0) { x = Math.fround(x + b); } else if (_40 === 1) { - two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32((a020: rt.Place, a118: rt.f32): undefined => { + two$mut_f32_f32_unit_ops_AddAssign_add_assign_f32_f32((a020: rs.Place, a118: rs.f32): undefined => { a020.v = Math.fround(a020.v + a118); - }, rt.place(() => x, (value14) => x = value14), b); + }, rs.place(() => x, (value14) => x = value14), b); } else { - ((a019: rt.Place, a117: rt.f32): undefined => { + ((a019: rs.Place, a117: rs.f32): undefined => { a019.v = Math.fround(a019.v + a117); - })(rt.place(() => x, (value13) => x = value13), b); + })(rs.place(() => x, (value13) => x = value13), b); } v = x; } else if (_18 === 7) { - let x2: rt.f32 = a; - const _48: rt.u8 = rt.u8Rem(form, 3); + let x2: rs.f32 = a; + const _48: rs.u8 = rs.u8Rem(form, 3); if (_48 === 0) { x2 = Math.fround(x2 - b); } else if (_48 === 1) { - two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32((a018: rt.Place, a116: rt.f32): undefined => { + two$mut_f32_f32_unit_ops_SubAssign_sub_assign_f32_f32((a018: rs.Place, a116: rs.f32): undefined => { a018.v = Math.fround(a018.v - a116); - }, rt.place(() => x2, (value12) => x2 = value12), b); + }, rs.place(() => x2, (value12) => x2 = value12), b); } else { - ((a017: rt.Place, a115: rt.f32): undefined => { + ((a017: rs.Place, a115: rs.f32): undefined => { a017.v = Math.fround(a017.v - a115); - })(rt.place(() => x2, (value11) => x2 = value11), b); + })(rs.place(() => x2, (value11) => x2 = value11), b); } v = x2; } else if (_18 === 8) { - let x3: rt.f32 = a; - const _56: rt.u8 = rt.u8Rem(form, 3); + let x3: rs.f32 = a; + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { x3 = Math.fround(x3 * b); } else if (_56 === 1) { - two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32((a016: rt.Place, a114: rt.f32): undefined => { + two$mut_f32_f32_unit_ops_MulAssign_mul_assign_f32_f32((a016: rs.Place, a114: rs.f32): undefined => { a016.v = Math.fround(a016.v * a114); - }, rt.place(() => x3, (value10) => x3 = value10), b); + }, rs.place(() => x3, (value10) => x3 = value10), b); } else { - ((a015: rt.Place, a113: rt.f32): undefined => { + ((a015: rs.Place, a113: rs.f32): undefined => { a015.v = Math.fround(a015.v * a113); - })(rt.place(() => x3, (value9) => x3 = value9), b); + })(rs.place(() => x3, (value9) => x3 = value9), b); } v = x3; } else if (_18 === 9) { - let x4: rt.f32 = a; - const _64: rt.u8 = rt.u8Rem(form, 3); + let x4: rs.f32 = a; + const _64: rs.u8 = rs.u8Rem(form, 3); if (_64 === 0) { x4 = Math.fround(x4 / b); } else if (_64 === 1) { - two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32((a014: rt.Place, a112: rt.f32): undefined => { + two$mut_f32_f32_unit_ops_DivAssign_div_assign_f32_f32((a014: rs.Place, a112: rs.f32): undefined => { a014.v = Math.fround(a014.v / a112); - }, rt.place(() => x4, (value8) => x4 = value8), b); + }, rs.place(() => x4, (value8) => x4 = value8), b); } else { - ((a013: rt.Place, a111: rt.f32): undefined => { + ((a013: rs.Place, a111: rs.f32): undefined => { a013.v = Math.fround(a013.v / a111); - })(rt.place(() => x4, (value7) => x4 = value7), b); + })(rs.place(() => x4, (value7) => x4 = value7), b); } v = x4; } else if (_18 === 10) { - let x5: rt.f32 = a; - const _72: rt.u8 = rt.u8Rem(form, 3); + let x5: rs.f32 = a; + const _72: rs.u8 = rs.u8Rem(form, 3); if (_72 === 0) { x5 = x5 % b; } else if (_72 === 1) { - two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32((a012: rt.Place, a110: rt.f32): undefined => { + two$mut_f32_f32_unit_ops_RemAssign_rem_assign_f32_f32((a012: rs.Place, a110: rs.f32): undefined => { a012.v = a012.v % a110; - }, rt.place(() => x5, (value6) => x5 = value6), b); + }, rs.place(() => x5, (value6) => x5 = value6), b); } else { - ((a011: rt.Place, a19: rt.f32): undefined => { + ((a011: rs.Place, a19: rs.f32): undefined => { a011.v = a011.v % a19; - })(rt.place(() => x5, (value5) => x5 = value5), b); + })(rs.place(() => x5, (value5) => x5 = value5), b); } v = x5; } else if (_18 === 11) { - const _78: rt.u8 = rt.u8Rem(form, 3); + const _78: rs.u8 = rs.u8Rem(form, 3); if (_78 === 0) { v = Math.fround(a + b); } else if (_78 === 1) { - v = two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32((a010: rt.f32, a18: rt.f32): rt.f32 => { + v = two$ref_f32_ref_f32_f32_ops_Add_add_ref_f32_ref_f32((a010: rs.f32, a18: rs.f32): rs.f32 => { return Math.fround(a010 + a18); }, a, b); } else { - v = ((a09: rt.f32, a17: rt.f32): rt.f32 => { + v = ((a09: rs.f32, a17: rs.f32): rs.f32 => { return Math.fround(a09 + a17); })(a, b); } } else if (_18 === 12) { - const _87: rt.u8 = rt.u8Rem(form, 3); + const _87: rs.u8 = rs.u8Rem(form, 3); if (_87 === 0) { v = a % b; } else if (_87 === 1) { - v = two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32((a08: rt.f32, a16: rt.f32): rt.f32 => { + v = two$f32_ref_f32_f32_ops_Rem_rem_f32_ref_f32((a08: rs.f32, a16: rs.f32): rs.f32 => { return a08 % a16; }, a, b); } else { - v = ((a07: rt.f32, a15: rt.f32): rt.f32 => { + v = ((a07: rs.f32, a15: rs.f32): rs.f32 => { return a07 % a15; })(a, b); } } else if (_18 === 13) { - const _93: rt.u8 = rt.u8Rem(form, 3); + const _93: rs.u8 = rs.u8Rem(form, 3); if (_93 === 0) { v = -a; } else if (_93 === 1) { - v = one$ref_f32_f32_ops_Neg_neg_ref_f32((a06: rt.f32): rt.f32 => { + v = one$ref_f32_f32_ops_Neg_neg_ref_f32((a06: rs.f32): rs.f32 => { return -a06; }, a); } else { - v = ((a05: rt.f32): rt.f32 => { + v = ((a05: rs.f32): rs.f32 => { return -a05; })(a); } } else if (_18 === 14) { - let x6: rt.f32 = a; - const _101: rt.u8 = rt.u8Rem(form, 3); + let x6: rs.f32 = a; + const _101: rs.u8 = rs.u8Rem(form, 3); if (_101 === 0) { x6 = Math.fround(x6 * b); } else if (_101 === 1) { - two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32((a04: rt.Place, a14: rt.f32): undefined => { + two$mut_f32_ref_f32_unit_ops_MulAssign_mul_assign_f32_ref_f32((a04: rs.Place, a14: rs.f32): undefined => { a04.v = Math.fround(a04.v * a14); - }, rt.place(() => x6, (value4) => x6 = value4), b); + }, rs.place(() => x6, (value4) => x6 = value4), b); } else { - ((a03: rt.Place, a13: rt.f32): undefined => { + ((a03: rs.Place, a13: rs.f32): undefined => { a03.v = Math.fround(a03.v * a13); - })(rt.place(() => x6, (value3) => x6 = value3), b); + })(rs.place(() => x6, (value3) => x6 = value3), b); } v = x6; } else { - let x7: rt.f32 = a; - const _112: rt.u8 = rt.u8Rem(form, 3); + let x7: rs.f32 = a; + const _112: rs.u8 = rs.u8Rem(form, 3); if (_112 === 0) { x7 = x7 % b; } else if (_112 === 1) { - two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32((a02: rt.Place, a12: rt.f32): undefined => { + two$mut_f32_ref_f32_unit_ops_RemAssign_rem_assign_f32_ref_f32((a02: rs.Place, a12: rs.f32): undefined => { a02.v = a02.v % a12; - }, rt.place(() => x7, (value2) => x7 = value2), b); + }, rs.place(() => x7, (value2) => x7 = value2), b); } else { - ((a0: rt.Place, a1: rt.f32): undefined => { + ((a0: rs.Place, a1: rs.f32): undefined => { a0.v = a0.v % a1; - })(rt.place(() => x7, (value) => x7 = value), b); + })(rs.place(() => x7, (value) => x7 = value), b); } v = x7; } @@ -8820,23 +8820,23 @@ export function f32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { v2 = NaN; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(v2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(v2)))); } /** * Apply operator `kind` to the two bools the low bits of `data`'s second byte pick, in the * form its first byte picks. */ -export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function bools(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let v!: boolean; - const form: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); + const form: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const bits: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); const _12: [boolean, boolean] = [(bits & 1) === 1, (bits & 2) === 2]; const a: boolean = _12[0]; const b: boolean = _12[1]; - const _18: rt.u8 = rt.u8Rem(kind, 10); + const _18: rs.u8 = rs.u8Rem(kind, 10); if (_18 === 0) { - const _20: rt.u8 = rt.u8Rem(form, 3); + const _20: rs.u8 = rs.u8Rem(form, 3); if (_20 === 0) { v = a && b; } else if (_20 === 1) { @@ -8849,7 +8849,7 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })(a, b); } } else if (_18 === 1) { - const _23: rt.u8 = rt.u8Rem(form, 3); + const _23: rs.u8 = rs.u8Rem(form, 3); if (_23 === 0) { v = a || b; } else if (_23 === 1) { @@ -8862,7 +8862,7 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })(a, b); } } else if (_18 === 2) { - const _26: rt.u8 = rt.u8Rem(form, 3); + const _26: rs.u8 = rs.u8Rem(form, 3); if (_26 === 0) { v = a !== b; } else if (_26 === 1) { @@ -8875,7 +8875,7 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })(a, b); } } else if (_18 === 3) { - const _29: rt.u8 = rt.u8Rem(form, 3); + const _29: rs.u8 = rs.u8Rem(form, 3); if (_29 === 0) { v = !a; } else if (_29 === 1) { @@ -8889,51 +8889,51 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else if (_18 === 4) { let x: boolean = a; - const _34: rt.u8 = rt.u8Rem(form, 3); + const _34: rs.u8 = rs.u8Rem(form, 3); if (_34 === 0) { x = x && b; } else if (_34 === 1) { - two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool((a012: rt.Place, a110: boolean): undefined => { + two$mut_bool_bool_unit_ops_BitAndAssign_bitand_assign_bool_bool((a012: rs.Place, a110: boolean): undefined => { a012.v = a012.v && a110; - }, rt.place(() => x, (value8) => x = value8), b); + }, rs.place(() => x, (value8) => x = value8), b); } else { - ((a011: rt.Place, a19: boolean): undefined => { + ((a011: rs.Place, a19: boolean): undefined => { a011.v = a011.v && a19; - })(rt.place(() => x, (value7) => x = value7), b); + })(rs.place(() => x, (value7) => x = value7), b); } v = x; } else if (_18 === 5) { let x2: boolean = a; - const _42: rt.u8 = rt.u8Rem(form, 3); + const _42: rs.u8 = rs.u8Rem(form, 3); if (_42 === 0) { x2 = x2 || b; } else if (_42 === 1) { - two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool((a010: rt.Place, a18: boolean): undefined => { + two$mut_bool_bool_unit_ops_BitOrAssign_bitor_assign_bool_bool((a010: rs.Place, a18: boolean): undefined => { a010.v = a010.v || a18; - }, rt.place(() => x2, (value6) => x2 = value6), b); + }, rs.place(() => x2, (value6) => x2 = value6), b); } else { - ((a09: rt.Place, a17: boolean): undefined => { + ((a09: rs.Place, a17: boolean): undefined => { a09.v = a09.v || a17; - })(rt.place(() => x2, (value5) => x2 = value5), b); + })(rs.place(() => x2, (value5) => x2 = value5), b); } v = x2; } else if (_18 === 6) { let x3: boolean = a; - const _50: rt.u8 = rt.u8Rem(form, 3); + const _50: rs.u8 = rs.u8Rem(form, 3); if (_50 === 0) { x3 = x3 !== b; } else if (_50 === 1) { - two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool((a08: rt.Place, a16: boolean): undefined => { + two$mut_bool_bool_unit_ops_BitXorAssign_bitxor_assign_bool_bool((a08: rs.Place, a16: boolean): undefined => { a08.v = a08.v !== a16; - }, rt.place(() => x3, (value4) => x3 = value4), b); + }, rs.place(() => x3, (value4) => x3 = value4), b); } else { - ((a07: rt.Place, a15: boolean): undefined => { + ((a07: rs.Place, a15: boolean): undefined => { a07.v = a07.v !== a15; - })(rt.place(() => x3, (value3) => x3 = value3), b); + })(rs.place(() => x3, (value3) => x3 = value3), b); } v = x3; } else if (_18 === 7) { - const _56: rt.u8 = rt.u8Rem(form, 3); + const _56: rs.u8 = rs.u8Rem(form, 3); if (_56 === 0) { v = a && b; } else if (_56 === 1) { @@ -8946,7 +8946,7 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { })(a, b); } } else if (_18 === 8) { - const _65: rt.u8 = rt.u8Rem(form, 3); + const _65: rs.u8 = rs.u8Rem(form, 3); if (_65 === 0) { v = !a; } else if (_65 === 1) { @@ -8960,21 +8960,21 @@ export function bools(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } else { let x4: boolean = a; - const _73: rt.u8 = rt.u8Rem(form, 3); + const _73: rs.u8 = rs.u8Rem(form, 3); if (_73 === 0) { x4 = x4 || b; } else if (_73 === 1) { - two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool((a02: rt.Place, a12: boolean): undefined => { + two$mut_bool_ref_bool_unit_ops_BitOrAssign_bitor_assign_bool_ref_bool((a02: rs.Place, a12: boolean): undefined => { a02.v = a02.v || a12; - }, rt.place(() => x4, (value2) => x4 = value2), b); + }, rs.place(() => x4, (value2) => x4 = value2), b); } else { - ((a0: rt.Place, a1: boolean): undefined => { + ((a0: rs.Place, a1: boolean): undefined => { a0.v = a0.v || a1; - })(rt.place(() => x4, (value) => x4 = value), b); + })(rs.place(() => x4, (value) => x4 = value), b); } v = x4; } - rt.byteVecPush(out, v ? 1 : 0); + rs.byteVecPush(out, v ? 1 : 0); } //# sourceMappingURL=operators.ts.map diff --git a/ts/fixtures/lang/orders/expected/core/bool.ts b/ts/fixtures/lang/orders/expected/core/bool.ts index ffe6ebaab..a2e40a4f7 100644 --- a/ts/fixtures/lang/orders/expected/core/bool.ts +++ b/ts/fixtures/lang/orders/expected/core/bool.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1d6toqn(self: boolean, t: undefined): undefined | rt.None { +export function thenSome$1qfl7tz(self: boolean, t: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return t; } diff --git a/ts/fixtures/lang/orders/expected/core/cmp.ts b/ts/fixtures/lang/orders/expected/core/cmp.ts index e9d2d0980..67e100148 100644 --- a/ts/fixtures/lang/orders/expected/core/cmp.ts +++ b/ts/fixtures/lang/orders/expected/core/cmp.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Item from "../orders.Item.ts"; -export function min$1ljcpv9(v1: string, v2: string): string { - return rt.ordMin(v1, v2, rt.cmpLt(rt.cmpStr)); +export function min$0tf7r1u(v1: string, v2: string): string { + return rs.ordMin(v1, v2, rs.cmpLt(rs.cmpStr)); } -export function min$1f8m2y1(v1: Item.Item, v2: Item.Item): Item.Item { - return rt.ordMin(v1, v2, Item.lt$cmp_PartialOrd, rt.drop); +export function min$0hz2v7s(v1: Item.Item, v2: Item.Item): Item.Item { + return rs.ordMin(v1, v2, Item.lt$cmp_PartialOrd, rs.drop); } -export function min$0tn2vhs(v1: Item.Item, v2: Item.Item): Item.Item { - return rt.ordMin(v1, v2, Item.lt$cmp_PartialOrd); +export function min$1akgklh(v1: Item.Item, v2: Item.Item): Item.Item { + return rs.ordMin(v1, v2, Item.lt$cmp_PartialOrd); } -export function min$1mtc1eg(v1: rt.u8, v2: rt.u8): rt.u8 { - return rt.min(v1, v2); +export function min$094dtzd(v1: rs.u8, v2: rs.u8): rs.u8 { + return rs.min(v1, v2); } -export function minBy$0f4msyz(v1: Item.Item, v2: Item.Item, compare: (a0: Item.Item, a1: Item.Item) => rt.Ordering): Item.Item { +export function minBy$18ytev0(v1: Item.Item, v2: Item.Item, compare: (a0: Item.Item, a1: Item.Item) => rs.Ordering): Item.Item { let _0!: Item.Item; let _10: boolean = false; let _9: boolean = false; @@ -42,22 +42,22 @@ export function minBy$0f4msyz(v1: Item.Item, v2: Item.Item, compare: (a0: Item.I return _0; } -export function minBy$0wmhcb1(v1: [rt.f64, rt.u8], v2: [rt.f64, rt.u8], compare: (a0: [rt.f64, rt.u8], a1: [rt.f64, rt.u8]) => rt.Ordering): [rt.f64, rt.u8] { +export function minBy$0p6yz91(v1: [rs.f64, rs.u8], v2: [rs.f64, rs.u8], compare: (a0: [rs.f64, rs.u8], a1: [rs.f64, rs.u8]) => rs.Ordering): [rs.f64, rs.u8] { if (!(compare(v1, v2) <= 0)) { return v2; } return v1; } -export function minByKey$04nvnd5(v1: Item.Item, v2: Item.Item, f: (a0: Item.Item) => rt.u8): Item.Item { +export function minByKey$1qsvvgc(v1: Item.Item, v2: Item.Item, f: (a0: Item.Item) => rs.u8): Item.Item { let _0!: Item.Item; let _16: boolean = false; let _15: boolean = false; _16 = true; _15 = true; - const _6: rt.u8 = f(v2); - const _11: rt.u8 = f(v1); - if (!(rt.cmpReverse(rt.cmp)(_6, _11) === -1)) { + const _6: rs.u8 = f(v2); + const _11: rs.u8 = f(v1); + if (!(rs.cmpReverse(rs.cmp)(_6, _11) === -1)) { _16 = false; _0 = v1; } else { @@ -74,31 +74,31 @@ export function minByKey$04nvnd5(v1: Item.Item, v2: Item.Item, f: (a0: Item.Item return _0; } -export function max$17dwnpn(v1: string, v2: string): string { - return rt.ordMax(v1, v2, rt.cmpLt(rt.cmpStr)); +export function max$0mrbrbr(v1: string, v2: string): string { + return rs.ordMax(v1, v2, rs.cmpLt(rs.cmpStr)); } -export function max$1s8mlx0(v1: Uint8Array, v2: Uint8Array): Uint8Array { - return rt.ordMax(v1, v2, rt.cmpLt(rt.cmpBytes)); +export function max$0vq2d0c(v1: Uint8Array, v2: Uint8Array): Uint8Array { + return rs.ordMax(v1, v2, rs.cmpLt(rs.cmpBytes)); } -export function max$0i3ups8(v1: rt.i8, v2: rt.i8): rt.i8 { - return rt.max(v1, v2); +export function max$0n458i1(v1: rs.i8, v2: rs.i8): rs.i8 { + return rs.max(v1, v2); } -export function max$1tkcqvz(v1: Item.Item, v2: Item.Item): Item.Item { - return rt.ordMax(v1, v2, Item.lt$cmp_PartialOrd, rt.drop); +export function max$1nu2xoq(v1: Item.Item, v2: Item.Item): Item.Item { + return rs.ordMax(v1, v2, Item.lt$cmp_PartialOrd, rs.drop); } -export function max$0bn3iky(v1: Item.Item, v2: Item.Item): Item.Item { - return rt.ordMax(v1, v2, Item.lt$cmp_PartialOrd); +export function max$12ifqlw(v1: Item.Item, v2: Item.Item): Item.Item { + return rs.ordMax(v1, v2, Item.lt$cmp_PartialOrd); } -export function max$0g5g0ks(v1: rt.u8, v2: rt.u8): rt.u8 { - return rt.max(v1, v2); +export function max$0we2ghu(v1: rs.u8, v2: rs.u8): rs.u8 { + return rs.max(v1, v2); } -export function maxBy$04pyy5s(v1: Item.Item, v2: Item.Item, compare: (a0: Item.Item, a1: Item.Item) => rt.Ordering): Item.Item { +export function maxBy$1ghjx71(v1: Item.Item, v2: Item.Item, compare: (a0: Item.Item, a1: Item.Item) => rs.Ordering): Item.Item { let _0!: Item.Item; let _10: boolean = false; let _9: boolean = false; @@ -121,7 +121,7 @@ export function maxBy$04pyy5s(v1: Item.Item, v2: Item.Item, compare: (a0: Item.I return _0; } -export function maxBy$0yuzdd4(v1: [rt.f64, rt.u8], v2: [rt.f64, rt.u8], compare: (a0: [rt.f64, rt.u8], a1: [rt.f64, rt.u8]) => rt.Ordering): [rt.f64, rt.u8] { +export function maxBy$1gr65n2(v1: [rs.f64, rs.u8], v2: [rs.f64, rs.u8], compare: (a0: [rs.f64, rs.u8], a1: [rs.f64, rs.u8]) => rs.Ordering): [rs.f64, rs.u8] { if (!(compare(v1, v2) > 0)) { return v2; } diff --git a/ts/fixtures/lang/orders/expected/core/option.ts b/ts/fixtures/lang/orders/expected/core/option.ts index 68fac34ed..182cd5ae2 100644 --- a/ts/fixtures/lang/orders/expected/core/option.ts +++ b/ts/fixtures/lang/orders/expected/core/option.ts @@ -1,58 +1,58 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Item from "../orders.Item.ts"; -export function unwrapOr$0l1fs14(self: rt.Ordering | undefined, default_: rt.Ordering): rt.Ordering { +export function unwrapOr$18rai12(self: rs.Ordering | undefined, default_: rs.Ordering): rs.Ordering { if (self === undefined) { return default_; } return self; } -export function map$0isl2bb(self: rt.Result | undefined, f: (a0: rt.Result) => rt.u8): rt.u8 | undefined { +export function map$0adj75b(self: rs.Result | undefined, f: (a0: rs.Result) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$05nbzug(self: rt.usize | undefined, f: (a0: rt.usize) => rt.u8): rt.u8 | undefined { +export function map$14ju55r(self: rs.usize | undefined, f: (a0: rs.usize) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$14aggam(self: Item.Item | undefined, default_: rt.u8, f: (a0: Item.Item) => rt.u8): rt.u8 { +export function mapOr$13h3wxw(self: Item.Item | undefined, default_: rs.u8, f: (a0: Item.Item) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0z7fb2w(self: rt.ByteSlice | undefined, default_: Uint8Array, f: (a0: rt.ByteSlice) => Uint8Array): Uint8Array { +export function mapOr$172961h(self: rs.ByteSlice | undefined, default_: Uint8Array, f: (a0: rs.ByteSlice) => Uint8Array): Uint8Array { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$06gg5x7(self: [rt.usize, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.usize, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$0i0fno7(self: [rs.usize, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.usize, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/orders/expected/core/result.ts b/ts/fixtures/lang/orders/expected/core/result.ts index 756da4648..ce495579a 100644 --- a/ts/fixtures/lang/orders/expected/core/result.ts +++ b/ts/fixtures/lang/orders/expected/core/result.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { cmp$175ka5q as poll_cmp$175ka5q } from "../core/task/poll.ts"; +import * as rs from "../rs.ts"; +import { cmp$17et0iz as poll_cmp$17et0iz } from "../core/task/poll.ts"; import * as Part from "../orders.Part.ts"; -export function eq$15zrpyn(self: rt.Result, other: rt.Result): boolean { +export function eq$1wvyxyw(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return self.value === (other as { ok: true; value: rt.f64 }).value; + return self.value === (other as { ok: true; value: rs.f64 }).value; } - return self.error === (other as { ok: false; error: rt.f64 }).error; + return self.error === (other as { ok: false; error: rs.f64 }).error; } -export function eq$1faqxpo(self: rt.Result, other: rt.Result): boolean { +export function eq$0p2ygx3(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } @@ -24,29 +24,29 @@ export function eq$1faqxpo(self: rt.Result, other: rt.Resu return Part.eq$cmp_PartialEq(self.error, (other as { ok: false; error: Part.Part }).error); } -export function partialCmp$08on5x6(self: rt.Result, rt.u8>, other: rt.Result, rt.u8>): rt.Ordering | undefined { +export function partialCmp$1frpo9k(self: rs.Result, rs.u8>, other: rs.Result, rs.u8>): rs.Ordering | undefined { if (self.ok) { if (other.ok) { - return rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(self.value, other.value); + return rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(self.value, other.value); } } else if (!other.ok) { - return rt.cmp(self.error, other.error); + return rs.cmp(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function partialCmp$0v2kxbo(self: rt.Result, other: rt.Result): rt.Ordering | undefined { +export function partialCmp$1ks7sga(self: rs.Result, other: rs.Result): rs.Ordering | undefined { if (self.ok) { if (other.ok) { - return rt.f64PartialCmp(self.value, other.value); + return rs.f64PartialCmp(self.value, other.value); } } else if (!other.ok) { - return rt.f64PartialCmp(self.error, other.error); + return rs.f64PartialCmp(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function partialCmp$0spmpix(self: rt.Result, other: rt.Result): rt.Ordering | undefined { +export function partialCmp$0rzsy3r(self: rs.Result, other: rs.Result): rs.Ordering | undefined { if (self.ok) { if (other.ok) { return Part.partialCmp$cmp_PartialOrd(self.value, other.value); @@ -54,32 +54,32 @@ export function partialCmp$0spmpix(self: rt.Result, other: } else if (!other.ok) { return Part.partialCmp$cmp_PartialOrd(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function partialCmp$0hea5es(self: rt.Result, other: rt.Result): rt.Ordering | undefined { +export function partialCmp$0wss1z6(self: rs.Result, other: rs.Result): rs.Ordering | undefined { if (self.ok) { if (other.ok) { - return rt.cmp(self.value, other.value); + return rs.cmp(self.value, other.value); } } else if (!other.ok) { - return rt.cmp(self.error, other.error); + return rs.cmp(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function cmp$0nb553d(self: rt.Result, rt.Poll>, other: rt.Result, rt.Poll>): rt.Ordering { +export function cmp$0lhhufb(self: rs.Result, rs.Poll>, other: rs.Result, rs.Poll>): rs.Ordering { if (self.ok) { if (other.ok) { - return rt.cmpDeque(rt.cmp)(self.value, other.value); + return rs.cmpDeque(rs.cmp)(self.value, other.value); } } else if (!other.ok) { - return poll_cmp$175ka5q(self.error, other.error); + return poll_cmp$17et0iz(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function cmp$0h5rzdg(self: rt.Result, other: rt.Result): rt.Ordering { +export function cmp$13u97s2(self: rs.Result, other: rs.Result): rs.Ordering { if (self.ok) { if (other.ok) { return Part.cmp$cmp_Ord(self.value, other.value); @@ -87,29 +87,29 @@ export function cmp$0h5rzdg(self: rt.Result, other: rt.Res } else if (!other.ok) { return Part.cmp$cmp_Ord(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function cmp$0qsbu3y(self: rt.Result<[Part.Part], rt.u8>, other: rt.Result<[Part.Part], rt.u8>): rt.Ordering { +export function cmp$0h35u3j(self: rs.Result<[Part.Part], rs.u8>, other: rs.Result<[Part.Part], rs.u8>): rs.Ordering { if (self.ok) { if (other.ok) { - return rt.cmpTuple<[Part.Part], rt.Ordering>([Part.cmp$cmp_Ord])(self.value, other.value); + return rs.cmpTuple<[Part.Part], rs.Ordering>([Part.cmp$cmp_Ord])(self.value, other.value); } } else if (!other.ok) { - return rt.cmp(self.error, other.error); + return rs.cmp(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } -export function cmp$06akmd5(self: rt.Result, other: rt.Result): rt.Ordering { +export function cmp$18cbpvu(self: rs.Result, other: rs.Result): rs.Ordering { if (self.ok) { if (other.ok) { - return rt.cmp(self.value, other.value); + return rs.cmp(self.value, other.value); } } else if (!other.ok) { - return rt.cmp(self.error, other.error); + return rs.cmp(self.error, other.error); } - return rt.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); + return rs.cmp(self.ok ? 0 : 1, other.ok ? 0 : 1); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/orders/expected/core/task/poll.ts b/ts/fixtures/lang/orders/expected/core/task/poll.ts index 8cf94e617..cd67115f6 100644 --- a/ts/fixtures/lang/orders/expected/core/task/poll.ts +++ b/ts/fixtures/lang/orders/expected/core/task/poll.ts @@ -1,45 +1,45 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; -import { partialCmp$0v2kxbo as result_partialCmp$0v2kxbo } from "../../core/result.ts"; +import * as rs from "../../rs.ts"; +import { partialCmp$1ks7sga as result_partialCmp$1ks7sga } from "../../core/result.ts"; -export function eq$1h9nnoh(self: rt.Poll, other: rt.Poll): boolean { - if (!((self !== rt.Pending ? 0 : 1) === (other !== rt.Pending ? 0 : 1))) { +export function eq$1qrb1lw(self: rs.Poll, other: rs.Poll): boolean { + if (!((self !== rs.Pending ? 0 : 1) === (other !== rs.Pending ? 0 : 1))) { return false; } - if (self !== rt.Pending) { - if (other !== rt.Pending) { + if (self !== rs.Pending) { + if (other !== rs.Pending) { return self === other; } } return true; } -export function cmp$175ka5q(self: rt.Poll, other: rt.Poll): rt.Ordering { - if (self !== rt.Pending) { - if (other !== rt.Pending) { - return rt.cmp(self, other); +export function cmp$17et0iz(self: rs.Poll, other: rs.Poll): rs.Ordering { + if (self !== rs.Pending) { + if (other !== rs.Pending) { + return rs.cmp(self, other); } } - return rt.cmp(self !== rt.Pending ? 0 : 1, other !== rt.Pending ? 0 : 1); + return rs.cmp(self !== rs.Pending ? 0 : 1, other !== rs.Pending ? 0 : 1); } -export function partialCmp$1fsj76o(self: rt.Poll>, other: rt.Poll>): rt.Ordering | undefined { - if (self !== rt.Pending) { - if (other !== rt.Pending) { - return result_partialCmp$0v2kxbo(self, other); +export function partialCmp$1gaal0x(self: rs.Poll>, other: rs.Poll>): rs.Ordering | undefined { + if (self !== rs.Pending) { + if (other !== rs.Pending) { + return result_partialCmp$1ks7sga(self, other); } } - return rt.cmp(self !== rt.Pending ? 0 : 1, other !== rt.Pending ? 0 : 1); + return rs.cmp(self !== rs.Pending ? 0 : 1, other !== rs.Pending ? 0 : 1); } -export function partialCmp$1r9dhkr(self: rt.Poll, other: rt.Poll): rt.Ordering | undefined { - if (self !== rt.Pending) { - if (other !== rt.Pending) { - return rt.cmp(self, other); +export function partialCmp$12m7vp8(self: rs.Poll, other: rs.Poll): rs.Ordering | undefined { + if (self !== rs.Pending) { + if (other !== rs.Pending) { + return rs.cmp(self, other); } } - return rt.cmp(self !== rt.Pending ? 0 : 1, other !== rt.Pending ? 0 : 1); + return rs.cmp(self !== rs.Pending ? 0 : 1, other !== rs.Pending ? 0 : 1); } //# sourceMappingURL=poll.ts.map diff --git a/ts/fixtures/lang/orders/expected/harness.ts b/ts/fixtures/lang/orders/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/orders/expected/harness.ts +++ b/ts/fixtures/lang/orders/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/orders/expected/lib.ts b/ts/fixtures/lang/orders/expected/lib.ts index 98c684bdb..cc0e496ab 100644 --- a/ts/fixtures/lang/orders/expected/lib.ts +++ b/ts/fixtures/lang/orders/expected/lib.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { orders, bytes, tuples, held, btrees } from "./orders.ts"; -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } @@ -11,14 +11,14 @@ export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["orders::orders", orders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::bytes", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["orders::orders", orders as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["orders::bytes", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { bytes(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::held", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["orders::held", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { held(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::tuples", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["orders::tuples", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { tuples(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["orders::btrees", btrees as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["orders::btrees", btrees as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/orders/expected/orders.Apart.ts b/ts/fixtures/lang/orders/expected/orders.Apart.ts index 2d16e8e7a..4edb00860 100644 --- a/ts/fixtures/lang/orders/expected/orders.Apart.ts +++ b/ts/fixtures/lang/orders/expected/orders.Apart.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./orders.ts"; /** Zero-sized, equal by `cmp` and never by `==`. */ @@ -12,7 +12,7 @@ export function eq$cmp_PartialEq(_self: Apart, _2: Apart): boolean { return false; } -export function cmp$cmp_Ord(_self: Apart, _2: Apart): rt.Ordering { +export function cmp$cmp_Ord(_self: Apart, _2: Apart): rs.Ordering { log(Uint8Array.of(99, 0, 0)); return 0; } diff --git a/ts/fixtures/lang/orders/expected/orders.Item.ts b/ts/fixtures/lang/orders/expected/orders.Item.ts index 861234d12..8fc011761 100644 --- a/ts/fixtures/lang/orders/expected/orders.Item.ts +++ b/ts/fixtures/lang/orders/expected/orders.Item.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./orders.ts"; /** @@ -8,10 +8,10 @@ import { log } from "./orders.ts"; * is and the two tags, and a drop logs the tag. */ export class Item { - key: rt.u8; - tag: rt.u8; + key: rs.u8; + tag: rs.u8; - constructor(key: rt.u8, tag: rt.u8) { + constructor(key: rs.u8, tag: rs.u8) { this.key = key; this.tag = tag; } diff --git a/ts/fixtures/lang/orders/expected/orders.Part.ts b/ts/fixtures/lang/orders/expected/orders.Part.ts index 870fa0802..55fcee0fb 100644 --- a/ts/fixtures/lang/orders/expected/orders.Part.ts +++ b/ts/fixtures/lang/orders/expected/orders.Part.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./orders.ts"; /** @@ -9,8 +9,8 @@ import { log } from "./orders.ts"; * the two tags. */ export interface Part { - key: rt.u8; - tag: rt.u8; + key: rs.u8; + tag: rs.u8; } export function eq$cmp_PartialEq(self: Part, other: Part): boolean { @@ -18,7 +18,7 @@ export function eq$cmp_PartialEq(self: Part, other: Part): boolean { return self.key === other.key; } -export function partialCmp$cmp_PartialOrd(self: Part, other: Part): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Part, other: Part): rs.Ordering | undefined { let _7!: boolean; log(Uint8Array.of(112, self.tag, other.tag)); if (!(self.key === 7)) { @@ -27,14 +27,14 @@ export function partialCmp$cmp_PartialOrd(self: Part, other: Part): rt.Ordering _7 = true; } if (!_7) { - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } return undefined; } -export function cmp$cmp_Ord(self: Part, other: Part): rt.Ordering { +export function cmp$cmp_Ord(self: Part, other: Part): rs.Ordering { log(Uint8Array.of(99, self.tag, other.tag)); - return rt.cmp(other.key, self.key); + return rs.cmp(other.key, self.key); } //# sourceMappingURL=orders.Part.ts.map diff --git a/ts/fixtures/lang/orders/expected/orders.Torn.ts b/ts/fixtures/lang/orders/expected/orders.Torn.ts index 551d0c77d..853d1af5f 100644 --- a/ts/fixtures/lang/orders/expected/orders.Torn.ts +++ b/ts/fixtures/lang/orders/expected/orders.Torn.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { log } from "./orders.ts"; /** @@ -10,34 +10,34 @@ import { log } from "./orders.ts"; * Each call logs which it is and the two tags. */ export interface Torn { - key: rt.u8; - tag: rt.u8; - mode: rt.u8; + key: rs.u8; + tag: rs.u8; + mode: rs.u8; } /** What `PartialOrd` orders by. */ -export function rank(self: Torn): rt.i16 { +export function rank(self: Torn): rs.i16 { if (self.mode === 1) { - return rt.i16Neg(self.key as rt.i16); + return rs.i16Neg(self.key as rs.i16); } if (self.mode === 3 || self.mode === 4) { - return rt.u8Div(self.key, 2) as rt.i16; + return rs.u8Div(self.key, 2) as rs.i16; } - return self.key as rt.i16; + return self.key as rs.i16; } /** What `PartialEq` compares. */ -function class_(self: Torn): rt.u16 { +function class_(self: Torn): rs.u16 { if (self.mode === 2) { - return (((self.key as rt.u16) << 8) & 0xffff) | self.tag as rt.u16; + return (((self.key as rs.u16) << 8) & 0xffff) | self.tag as rs.u16; } if (self.mode === 3) { - return rt.u8Div(self.key, 2) as rt.u16; + return rs.u8Div(self.key, 2) as rs.u16; } if (self.mode === 4) { - return rt.u8Rem(self.tag, 2) as rt.u16; + return rs.u8Rem(self.tag, 2) as rs.u16; } - return self.key as rt.u16; + return self.key as rs.u16; } export function ne$cmp_PartialEq(self: Torn, other: Torn): boolean { @@ -45,9 +45,9 @@ export function ne$cmp_PartialEq(self: Torn, other: Torn): boolean { return class_(self) !== class_(other); } -export function partialCmp$cmp_PartialOrd(self: Torn, other: Torn): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Torn, other: Torn): rs.Ordering | undefined { log(Uint8Array.of(112, self.tag, other.tag)); - return rt.cmp(rank(self), rank(other)); + return rs.cmp(rank(self), rank(other)); } export function lt$cmp_PartialOrd(self: Torn, other: Torn): boolean { @@ -55,9 +55,9 @@ export function lt$cmp_PartialOrd(self: Torn, other: Torn): boolean { return rank(self) < rank(other); } -export function cmp$cmp_Ord(self: Torn, other: Torn): rt.Ordering { +export function cmp$cmp_Ord(self: Torn, other: Torn): rs.Ordering { log(Uint8Array.of(99, self.tag, other.tag)); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } export { class_ as class }; diff --git a/ts/fixtures/lang/orders/expected/orders.ts b/ts/fixtures/lang/orders/expected/orders.ts index 26ca4777d..cc887e8ad 100644 --- a/ts/fixtures/lang/orders/expected/orders.ts +++ b/ts/fixtures/lang/orders/expected/orders.ts @@ -1,45 +1,45 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$tuple2_u8_u8 } from "./lib.ts"; -import { thenSome$1d6toqn } from "./core/bool.ts"; -import { min$1ljcpv9, min$1f8m2y1, min$0tn2vhs, min$1mtc1eg, minBy$0f4msyz, minBy$0wmhcb1, minByKey$04nvnd5, max$17dwnpn, max$1s8mlx0, max$0i3ups8, max$1tkcqvz, max$0bn3iky, max$0g5g0ks, maxBy$04pyy5s, maxBy$0yuzdd4, maxByKey$1a9sf4b } from "./core/cmp.ts"; -import { unwrapOr$0l1fs14 as option_unwrapOr$0l1fs14, map$0isl2bb as option_map$0isl2bb, map$05nbzug as option_map$05nbzug, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$14aggam as option_mapOr$14aggam, mapOr$0z7fb2w as option_mapOr$0z7fb2w, mapOr$1surhce as option_mapOr$1surhce, mapOr$06gg5x7 as option_mapOr$06gg5x7 } from "./core/option.ts"; -import { eq$15zrpyn as result_eq$15zrpyn, eq$1faqxpo as result_eq$1faqxpo, partialCmp$08on5x6 as result_partialCmp$08on5x6, partialCmp$0v2kxbo as result_partialCmp$0v2kxbo, partialCmp$0spmpix as result_partialCmp$0spmpix, partialCmp$0hea5es as result_partialCmp$0hea5es, cmp$0nb553d as result_cmp$0nb553d, cmp$0h5rzdg as result_cmp$0h5rzdg, cmp$0qsbu3y as result_cmp$0qsbu3y, cmp$06akmd5 as result_cmp$06akmd5 } from "./core/result.ts"; -import { eq$1h9nnoh as poll_eq$1h9nnoh, cmp$175ka5q as poll_cmp$175ka5q, partialCmp$1fsj76o as poll_partialCmp$1fsj76o, partialCmp$1r9dhkr as poll_partialCmp$1r9dhkr } from "./core/task/poll.ts"; +import { thenSome$1qfl7tz } from "./core/bool.ts"; +import { min$0tf7r1u, min$0hz2v7s, min$1akgklh, min$094dtzd, minBy$18ytev0, minBy$0p6yz91, minByKey$1qsvvgc, max$0mrbrbr, max$0vq2d0c, max$0n458i1, max$1nu2xoq, max$12ifqlw, max$0we2ghu, maxBy$1ghjx71, maxBy$1gr65n2, maxByKey$1a9sf4b } from "./core/cmp.ts"; +import { unwrapOr$18rai12 as option_unwrapOr$18rai12, map$0adj75b as option_map$0adj75b, map$14ju55r as option_map$14ju55r, mapOr$14runhi as option_mapOr$14runhi, mapOr$13h3wxw as option_mapOr$13h3wxw, mapOr$172961h as option_mapOr$172961h, mapOr$0vxw5sq as option_mapOr$0vxw5sq, mapOr$0i0fno7 as option_mapOr$0i0fno7 } from "./core/option.ts"; +import { eq$1wvyxyw as result_eq$1wvyxyw, eq$0p2ygx3 as result_eq$0p2ygx3, partialCmp$1frpo9k as result_partialCmp$1frpo9k, partialCmp$1ks7sga as result_partialCmp$1ks7sga, partialCmp$0rzsy3r as result_partialCmp$0rzsy3r, partialCmp$0wss1z6 as result_partialCmp$0wss1z6, cmp$0lhhufb as result_cmp$0lhhufb, cmp$13u97s2 as result_cmp$13u97s2, cmp$0h35u3j as result_cmp$0h35u3j, cmp$18cbpvu as result_cmp$18cbpvu } from "./core/result.ts"; +import { eq$1qrb1lw as poll_eq$1qrb1lw, cmp$17et0iz as poll_cmp$17et0iz, partialCmp$1gaal0x as poll_partialCmp$1gaal0x, partialCmp$12m7vp8 as poll_partialCmp$12m7vp8 } from "./core/task/poll.ts"; import * as Apart from "./orders.Apart.ts"; import * as Item from "./orders.Item.ts"; import * as Part from "./orders.Part.ts"; import * as Torn from "./orders.Torn.ts"; -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LOG$init, false); +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); -export function LOG$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function LOG$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } export function log(entry: Uint8Array): void { - const _5: rt.ByteSlice = rt.byteSliceFrom(entry); - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.iterExtendBytes(log, rt.iterSlice(rt.byteSliceToArray(_5)), undefined, true); + const _5: rs.ByteSlice = rs.byteSliceFrom(entry); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.iterExtendBytes(log, rs.iterSlice(rs.byteSliceToArray(_5)), undefined, true); }); } /** Puts what was logged since the last flush. */ -export function flush(out: rt.ByteVec): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); - rt.byteVecClear(log); +export function flush(out: rs.ByteVec): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); + rs.byteVecClear(log); }); } -export function item(tag: rt.usize, key: rt.u8): Item.Item { - return new Item.Item(rt.u8Rem(key, 8), tag & 0xff); +export function item(tag: rs.usize, key: rs.u8): Item.Item { + return new Item.Item(rs.u8Rem(key, 8), tag & 0xff); } /** Run one case. */ -export function orders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.u8 = rt.u8Rem(kind, 4); +export function orders(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.u8 = rs.u8Rem(kind, 4); if (_5 === 0) { cmps(data.data, data.start, data.length, out); } else if (_5 === 1) { @@ -56,67 +56,67 @@ export function orders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `cmp::max` and `min` and their forms of each byte and the next, as integers, strings, * and items, which the one not returned drops, and of references to items. */ -export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _7!: rt.usize; - let iterStart: rt.usize = 1; - const iterEnd: rt.usize = dataLen; +export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _7!: rs.usize; + let iterStart: rs.usize = 1; + const iterEnd: rs.usize = dataLen; while ((_7 = iterStart++) < iterEnd) { - const i: rt.usize = _7; - const _15: rt.usize = rt.usizeSub(i, 1); + const i: rs.usize = _7; + const _15: rs.usize = rs.usizeSub(i, 1); if (_15 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _15); } - const _14: rt.u8 = dataData[dataStart + _15]; + const _14: rs.u8 = dataData[dataStart + _15]; if (i >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + i); } - const _13: [rt.u8, rt.u8] = [_14, dataData[dataStart + i]]; - const a: rt.u8 = _14; - const b: rt.u8 = _13[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$0g5g0ks(a, b), min$1mtc1eg(a, b), max$0i3ups8((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); - const _37: rt.u8 = rt.u8Div(b, 2); - const _32: [string, string] = [rt.fmtToString((f: rt.Formatter) => rt.u8Display(a, f)), rt.fmtToString((f: rt.Formatter) => rt.u8Display(_37, f))]; + const _13: [rs.u8, rs.u8] = [_14, dataData[dataStart + i]]; + const a: rs.u8 = _14; + const b: rs.u8 = _13[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$0we2ghu(a, b), min$094dtzd(a, b), max$0n458i1((a << 24) >> 24, (b << 24) >> 24) & 0xff)), undefined, true); + const _37: rs.u8 = rs.u8Div(b, 2); + const _32: [string, string] = [rs.fmtToString((f: rs.Formatter) => rs.u8Display(a, f)), rs.fmtToString((f: rs.Formatter) => rs.u8Display(_37, f))]; const s: string = _32[0]; const t: string = _32[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.stringLen(max$17dwnpn(s, t)) & 0xff, rt.stringLen(min$1ljcpv9(s, t)) & 0xff)), undefined, true); - const _55: [Item.Item, Item.Item] = [item(rt.usizeMul(2, i), a), item(rt.usizeAdd(rt.usizeMul(2, i), 1), b)]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.stringLen(max$0mrbrbr(s, t)) & 0xff, rs.stringLen(min$0tf7r1u(s, t)) & 0xff)), undefined, true); + const _55: [Item.Item, Item.Item] = [item(rs.usizeMul(2, i), a), item(rs.usizeAdd(rs.usizeMul(2, i), 1), b)]; const x: Item.Item = _55[0]; const y: Item.Item = _55[1]; - rt.byteVecPush(out, max$0bn3iky(x, y).tag); - rt.byteVecPush(out, min$0tn2vhs(x, y).tag); - const _76: Item.Item = max$1tkcqvz(x, y); - rt.byteVecPush(out, _76.tag); + rs.byteVecPush(out, max$12ifqlw(x, y).tag); + rs.byteVecPush(out, min$1akgklh(x, y).tag); + const _76: Item.Item = max$1nu2xoq(x, y); + rs.byteVecPush(out, _76.tag); _76[Symbol.dispose](); const pair: () => [Item.Item, Item.Item] = (): [Item.Item, Item.Item] => { - return [item(rt.usizeMul(2, i), a), item(rt.usizeAdd(rt.usizeMul(2, i), 1), b)] as [Item.Item, Item.Item]; + return [item(rs.usizeMul(2, i), a), item(rs.usizeAdd(rs.usizeMul(2, i), 1), b)] as [Item.Item, Item.Item]; }; const _83: [Item.Item, Item.Item] = pair(); - const _87: Item.Item = min$1f8m2y1(_83[0], _83[1]); - rt.byteVecPush(out, _87.tag); + const _87: Item.Item = min$0hz2v7s(_83[0], _83[1]); + rs.byteVecPush(out, _87.tag); _87[Symbol.dispose](); const _90: [Item.Item, Item.Item] = pair(); - const _94: Item.Item = maxBy$04pyy5s(_90[0], _90[1], (l: Item.Item, r: Item.Item): rt.Ordering => { - return rt.orderingReverse(rt.cmp(l.key, r.key)); + const _94: Item.Item = maxBy$1ghjx71(_90[0], _90[1], (l: Item.Item, r: Item.Item): rs.Ordering => { + return rs.orderingReverse(rs.cmp(l.key, r.key)); }); - rt.byteVecPush(out, _94.tag); + rs.byteVecPush(out, _94.tag); _94[Symbol.dispose](); const _97: [Item.Item, Item.Item] = pair(); - const _101: Item.Item = minBy$0f4msyz(_97[0], _97[1], (l2: Item.Item, r2: Item.Item): rt.Ordering => { - return rt.cmp(rt.u8Div(l2.key, 2), rt.u8Div(r2.key, 2)); + const _101: Item.Item = minBy$18ytev0(_97[0], _97[1], (l2: Item.Item, r2: Item.Item): rs.Ordering => { + return rs.cmp(rs.u8Div(l2.key, 2), rs.u8Div(r2.key, 2)); }); - rt.byteVecPush(out, _101.tag); + rs.byteVecPush(out, _101.tag); _101[Symbol.dispose](); const _104: [Item.Item, Item.Item] = pair(); const _108: Item.Item = maxByKey$1a9sf4b(_104[0], _104[1], (v: Item.Item): Item.Item => { - return item(rt.usizeAdd(v.tag as rt.usize, 100), rt.u8Div(v.key, 2)); + return item(rs.usizeAdd(v.tag as rs.usize, 100), rs.u8Div(v.key, 2)); }); - rt.byteVecPush(out, _108.tag); + rs.byteVecPush(out, _108.tag); _108[Symbol.dispose](); const _111: [Item.Item, Item.Item] = pair(); - const _115: Item.Item = minByKey$04nvnd5(_111[0], _111[1], (v2: Item.Item): rt.u8 => { + const _115: Item.Item = minByKey$1qsvvgc(_111[0], _111[1], (v2: Item.Item): rs.u8 => { return v2.key; }); - rt.byteVecPush(out, _115.tag); + rs.byteVecPush(out, _115.tag); _115[Symbol.dispose](); flush(out); } @@ -126,109 +126,109 @@ export function cmps(dataData: Uint8Array, dataStart: number, dataLen: number, o * The `is_sorted` family of slices and iterators of items, bytes, and strings, as given * and sorted: each test std makes, and each item or key it drops. */ -export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { +export function sorted(data: rs.ByteSlice, out: rs.ByteVec): void { const _77: () => Item.Item = (): Item.Item => { return item(200, 0); }; - const ascending: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.sliceSort(rt.byteSliceView(rt.byteVecSlice(ascending)), rt.keyLt((b: rt.u8): rt.u8 => { - return rt.u8Rem(b, 8); - }, rt.lt), 1, true); - const iter: rt.Iter = rt.iterSlice([data, rt.byteVecSlice(ascending)]); + const ascending: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.sliceSort(rs.byteSliceView(rs.byteVecSlice(ascending)), rs.keyLt((b: rs.u8): rs.u8 => { + return rs.u8Rem(b, 8); + }, rs.lt), 1, true); + const iter: rs.Iter = rs.iterSlice([data, rs.byteVecSlice(ascending)]); while (true) { - const _12: rt.ByteSlice | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: rs.ByteSlice | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const items: () => rt.Iter = (): rt.Iter => { - return rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(_12))), (_24: [rt.usize, rt.u8]): Item.Item => { + const items: () => rs.Iter = (): rs.Iter => { + return rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(_12))), (_24: [rs.usize, rs.u8]): Item.Item => { return item(_24[0], _24[1]); }); }; - const v: rt.Vec = rt.iterToVec(items(), undefined, 2, true); - rt.byteVecPush(out, rt.sliceIsSorted(v.items, Item.le$cmp_PartialOrd) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterSlice(v.items), (a: Item.Item, b3: Item.Item): boolean => { + const v: rs.Vec = rs.iterToVec(items(), undefined, 2, true); + rs.byteVecPush(out, rs.sliceIsSorted(v.items, Item.le$cmp_PartialOrd) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterSlice(v.items), (a: Item.Item, b3: Item.Item): boolean => { return a.key >= b3.key; }) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(v.items), (x: Item.Item): Item.Item => { - return item(rt.usizeAdd(x.tag as rt.usize, 100), rt.u8Div(x.key, 2)); - }), Item.le$cmp_PartialOrd, undefined, rt.drop) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterSlice(v.items), Item.le$cmp_PartialOrd) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.sliceRange(v.items, 0, rt.usizeDiv(v.items.length, 2))), (x2: Item.Item): rt.u8 => { + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(v.items), (x: Item.Item): Item.Item => { + return item(rs.usizeAdd(x.tag as rs.usize, 100), rs.u8Div(x.key, 2)); + }), Item.le$cmp_PartialOrd, undefined, rs.drop) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterSlice(v.items), Item.le$cmp_PartialOrd) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.sliceRange(v.items, 0, rs.usizeDiv(v.items.length, 2))), (x2: Item.Item): rs.u8 => { return x2.key; - }), rt.le) ? 1 : 0); - rt.dropVec(v); + }), rs.le) ? 1 : 0); + rs.dropVec(v); flush(out); - rt.byteVecPush(out, rt.iterIsSortedBy(items(), Item.le$cmp_PartialOrd, undefined, rt.drop) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(items(), (a2: Item.Item, b4: Item.Item): boolean => { + rs.byteVecPush(out, rs.iterIsSortedBy(items(), Item.le$cmp_PartialOrd, undefined, rs.drop) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(items(), (a2: Item.Item, b4: Item.Item): boolean => { if (!(a2.tag > b4.tag)) { return a2.key <= b4.key; } return true; - }, undefined, rt.drop) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(items(), (x3: Item.Item): rt.u8 => { - const _09: rt.u8 = x3.key; + }, undefined, rs.drop) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(items(), (x3: Item.Item): rs.u8 => { + const _09: rs.u8 = x3.key; x3[Symbol.dispose](); return _09; - }), rt.cmpLe(rt.cmpReverse(rt.cmp))) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.vecIntoIter(rt.iterToVec(items(), undefined, 2, true), rt.drop), Item.le$cmp_PartialOrd, true, rt.drop) ? 1 : 0); + }), rs.cmpLe(rs.cmpReverse(rs.cmp))) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), Item.le$cmp_PartialOrd, true, rs.drop) ? 1 : 0); flush(out); const _82: [Item.Item, Item.Item, Item.Item, Item.Item] = [_77(), _77(), _77(), _77()]; const g: Item.Item = _82[0]; const h: Item.Item = _82[1]; const k: Item.Item = _82[2]; const l: Item.Item = _82[3]; - const _94: rt.Iter = items(); + const _94: rs.Iter = items(); const captured = g; - rt.byteVecPush(out, rt.iterIsSortedBy(_94, rt.closure((a3: Item.Item, b5: Item.Item): boolean => { + rs.byteVecPush(out, rs.iterIsSortedBy(_94, rs.closure((a3: Item.Item, b5: Item.Item): boolean => { if (!(captured.key <= a3.key)) { return false; } return a3.key <= b5.key; }, (): void => { captured[Symbol.dispose](); - }), undefined, rt.drop, rt.drop) ? 1 : 0); - const _103: rt.Iter = rt.vecIntoIter(rt.iterToVec(items(), undefined, 2, true), rt.drop); + }), undefined, rs.drop, rs.drop) ? 1 : 0); + const _103: rs.Iter = rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop); const captured2 = h; - rt.byteVecPush(out, rt.iterIsSortedBy(_103, rt.closure((a4: Item.Item, b6: Item.Item): boolean => { - return a4.key <= rt.u8Add(b6.key, captured2.key); + rs.byteVecPush(out, rs.iterIsSortedBy(_103, rs.closure((a4: Item.Item, b6: Item.Item): boolean => { + return a4.key <= rs.u8Add(b6.key, captured2.key); }, (): void => { captured2[Symbol.dispose](); - }), true, rt.drop, rt.drop) ? 1 : 0); - const _108: rt.Iter = items(); + }), true, rs.drop, rs.drop) ? 1 : 0); + const _108: rs.Iter = items(); const captured3 = k; - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(_108, rt.closure((x4: Item.Item): rt.u8 => { - const _012: rt.u8 = rt.u8Add(x4.key, captured3.key); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(_108, rs.closure((x4: Item.Item): rs.u8 => { + const _012: rs.u8 = rs.u8Add(x4.key, captured3.key); x4[Symbol.dispose](); return _012; }, (): void => { captured3[Symbol.dispose](); - })), rt.le, true) ? 1 : 0); + })), rs.le, true) ? 1 : 0); const captured4 = l; - const key: (a0: Item.Item) => rt.u8 = rt.closure((x5: Item.Item): rt.u8 => { - const _013: rt.u8 = rt.u8Add(x5.key, captured4.key); + const key: (a0: Item.Item) => rs.u8 = rs.closure((x5: Item.Item): rs.u8 => { + const _013: rs.u8 = rs.u8Add(x5.key, captured4.key); x5[Symbol.dispose](); return _013; }, (): void => { captured4[Symbol.dispose](); }); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.vecIntoIter(rt.iterToVec(items(), undefined, 2, true), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); - rt.byteVecPush(out, rt.iterIsSortedBy(rt.iterMap(rt.vecIntoIter(rt.iterToVec(items(), undefined, 2, true), rt.drop), rt.lent(key)), rt.le, true) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); + rs.byteVecPush(out, rs.iterIsSortedBy(rs.iterMap(rs.vecIntoIter(rs.iterToVec(items(), undefined, 2, true), rs.drop), rs.lent(key)), rs.le, true) ? 1 : 0); flush(out); - const strings: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (b7: rt.u8): string => { - const _415: rt.u8 = rt.u8Rem(b7, 16); - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(_415, f)); + const strings: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (b7: rs.u8): string => { + const _415: rs.u8 = rs.u8Rem(b7, 16); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_415, f)); }), undefined, 12, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.sliceIsSorted(rt.byteSliceView(_12), rt.le) ? 1 : 0, rt.iterIsSortedBy(rt.iterSlice(rt.byteSliceView(_12)), (a5: rt.u8, b8: rt.u8): boolean => { - return rt.u8Div(a5, 4) <= rt.u8Div(b8, 4); - }) ? 1 : 0, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (_25: rt.u8): rt.u8 => { - return rt.u8Rem(_25, 8); - }), rt.le) ? 1 : 0, rt.iterIsSortedBy(rt.iterSlice(rt.byteSliceView(_12)), rt.le) ? 1 : 0, rt.sliceIsSorted(strings.items, rt.cmpLe(rt.cmpStr)) ? 1 : 0, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(strings.items), (a0: string): rt.usize => { - return rt.stringLen(a0); - }), rt.le) ? 1 : 0, rt.iterIsSortedBy(rt.iterMap(rt.iterSlice(rt.byteSliceView(_12)), (_29: rt.u8): rt.f64 => { - return (_29 as rt.f64) / 3.0; - }), rt.cmpLe(rt.f64PartialCmp)) ? 1 : 0)), undefined, true); - rt.drop(key); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.sliceIsSorted(rs.byteSliceView(_12), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), (a5: rs.u8, b8: rs.u8): boolean => { + return rs.u8Div(a5, 4) <= rs.u8Div(b8, 4); + }) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_25: rs.u8): rs.u8 => { + return rs.u8Rem(_25, 8); + }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterSlice(rs.byteSliceView(_12)), rs.le) ? 1 : 0, rs.sliceIsSorted(strings.items, rs.cmpLe(rs.cmpStr)) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(strings.items), (a0: string): rs.usize => { + return rs.stringLen(a0); + }), rs.le) ? 1 : 0, rs.iterIsSortedBy(rs.iterMap(rs.iterSlice(rs.byteSliceView(_12)), (_29: rs.u8): rs.f64 => { + return (_29 as rs.f64) / 3.0; + }), rs.cmpLe(rs.f64PartialCmp)) ? 1 : 0)), undefined, true); + rs.drop(key); } } @@ -236,104 +236,104 @@ export function sorted(data: rt.ByteSlice, out: rt.ByteVec): void { * A heap of items changed by each pair of bytes, an operation and its operand: each * comparison its sifts make, which of equal items it gives back, and when each drops. */ -export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { +export function heaps(data: rs.ByteSlice, out: rs.ByteVec): void { let _127: boolean = false; let _128: boolean = false; - let heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; - const other: rt.BinaryHeap = rt.heapWithCapacity(4, 2) as rt.BinaryHeap; - const ops: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + let heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; + const other: rs.BinaryHeap = rs.heapWithCapacity(4, 2) as rs.BinaryHeap; + const ops: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _8: [rt.usize, rt.u8] | rt.Done = ops.next(); - if (_8 !== rt.DONE) { - const i: rt.usize = _8[0]; - const op: rt.u8 = _8[1]; - const v: rt.u8 = option_mapOr$06gg5x7(rt.iterToOption(ops.next()), 0, (_2: [rt.usize, rt.u8]): rt.u8 => { + const _8: [rs.usize, rs.u8] | rs.Done = ops.next(); + if (_8 !== rs.DONE) { + const i: rs.usize = _8[0]; + const op: rs.u8 = _8[1]; + const v: rs.u8 = option_mapOr$0i0fno7(rs.iterToOption(ops.next()), 0, (_2: [rs.usize, rs.u8]): rs.u8 => { return _2[1]; }); b2: { - const _17: rt.u8 = rt.u8Rem(op, 12); + const _17: rs.u8 = rs.u8Rem(op, 12); if (0 <= _17) { if (_17 <= 2) { - rt.heapPush(heap, item(i, v), Item.le$cmp_PartialOrd); + rs.heapPush(heap, item(i, v), Item.le$cmp_PartialOrd); break b2; } } if (_17 === 3) { - rt.byteVecPush(out, option_mapOr$14aggam(rt.heapPop(heap, Item.le$cmp_PartialOrd), 255, (x5: Item.Item): rt.u8 => { - const _06: rt.u8 = x5.tag; + rs.byteVecPush(out, option_mapOr$13h3wxw(rs.heapPop(heap, Item.le$cmp_PartialOrd), 255, (x5: Item.Item): rs.u8 => { + const _06: rs.u8 = x5.tag; x5[Symbol.dispose](); return _06; })); } else if (_17 === 4) { - const _26: rt.PeekMut | undefined = rt.heapPeekMut(heap, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); + const _26: rs.PeekMut | undefined = rs.heapPeekMut(heap, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); if (_26 !== undefined) { _127 = true; - const top: rt.PeekMut = _26; - rt.peekMutDerefMut(top); - top.v.key = rt.u8Rem(v, 8); + const top: rs.PeekMut = _26; + rs.peekMutDerefMut(top); + top.v.key = rs.u8Rem(v, 8); if ((v & 16) !== 0) { _127 = false; } if (_127) { - rt.peekMutDrop(top); + rs.peekMutDrop(top); } _127 = false; } } else if (_17 === 5) { - const _37: rt.PeekMut | undefined = rt.heapPeekMut(heap, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); + const _37: rs.PeekMut | undefined = rs.heapPeekMut(heap, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); if (_37 !== undefined) { _128 = true; - const top2: rt.PeekMut = _37; - const _41: rt.u8 = rt.u8Rem(v, 3); + const top2: rs.PeekMut = _37; + const _41: rs.u8 = rs.u8Rem(v, 3); if (_41 === 0) { _128 = false; - const _44: Item.Item = rt.peekMutPop(top2); - rt.byteVecPush(out, _44.tag); + const _44: Item.Item = rs.peekMutPop(top2); + rs.byteVecPush(out, _44.tag); _44[Symbol.dispose](); } else if (_41 === 1) { - rt.byteVecPush(out, top2.v.tag); + rs.byteVecPush(out, top2.v.tag); } else { _128 = false; - const top3: rt.PeekMut = top2; - rt.peekMutDerefMut(top3); + const top3: rs.PeekMut = top2; + rs.peekMutDerefMut(top3); const _50: Item.Item = top3.v; _50.tag = _50.tag ^ 64; - const _54: Item.Item = rt.peekMutPop(top3); - rt.byteVecPush(out, _54.tag); + const _54: Item.Item = rs.peekMutPop(top3); + rs.byteVecPush(out, _54.tag); _54[Symbol.dispose](); } if (_128) { - rt.peekMutDrop(top2); + rs.peekMutDrop(top2); } _128 = false; } } else if (_17 === 6) { const _57: Item.Item = item(i, v); - rt.heapPush(other, _57, Item.le$cmp_PartialOrd); + rs.heapPush(other, _57, Item.le$cmp_PartialOrd); } else if (_17 === 7) { - rt.heapAppend(heap, other, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd, 2); + rs.heapAppend(heap, other, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd, 2); } else if (_17 === 8) { - rt.heapRetain(heap, (x4: Item.Item): boolean => { - return x4.key !== rt.u8Rem(v, 8); - }, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd, rt.drop); + rs.heapRetain(heap, (x4: Item.Item): boolean => { + return x4.key !== rs.u8Rem(v, 8); + }, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd, rs.drop); } else if (_17 === 9) { - rt.heapExtend(heap, rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), rt.usizeRem(v as rt.usize, 6)), (_28: rt.u8): Item.Item => { - return item(rt.usizeAdd(i, 50), _28); + rs.heapExtend(heap, rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), rs.usizeRem(v as rs.usize, 6)), (_28: rs.u8): Item.Item => { + return item(rs.usizeAdd(i, 50), _28); }), Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd, undefined, 2, true); } else if (_17 === 10) { - const sorted: rt.Vec = rt.heapIntoSortedVec(rt.replaceIn(heap, rt.heapNew() as rt.BinaryHeap), Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted.items), (x3: Item.Item): rt.u8 => { + const sorted: rs.Vec = rs.heapIntoSortedVec(rs.replaceIn(heap, rs.heapNew() as rs.BinaryHeap), Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (x3: Item.Item): rs.u8 => { return x3.tag; }), undefined, true); flush(out); - const _81: rt.BinaryHeap = rt.heapFrom(sorted, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); - rt.heapDrop(heap, rt.drop); + const _81: rs.BinaryHeap = rs.heapFrom(sorted, Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); + rs.heapDrop(heap, rs.drop); heap = _81; } else { - rt.iterExtendBytes(out, rt.iterMap(rt.heapIter(heap), (x: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(heap), (x: Item.Item): rs.u8 => { return x.tag; }), "next"); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(option_mapOr$14aggam(heap.items[0], 255, (x2: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(option_mapOr$13h3wxw(heap.items[0], 255, (x2: Item.Item): rs.u8 => { return x2.tag; }), heap.items.length & 0xff, heap.items.length === 0 ? 1 : 0)), undefined, true); } @@ -343,109 +343,109 @@ export function heaps(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - const drain: rt.Iter = rt.heapDrain(heap, rt.drop); - rt.byteVecPush(out, option_mapOr$14aggam(rt.iterToOption(drain.next()), 255, (x6: Item.Item): rt.u8 => { - const _07: rt.u8 = x6.tag; + const drain: rs.Iter = rs.heapDrain(heap, rs.drop); + rs.byteVecPush(out, option_mapOr$13h3wxw(rs.iterToOption(drain.next()), 255, (x6: Item.Item): rs.u8 => { + const _07: rs.u8 = x6.tag; x6[Symbol.dispose](); return _07; })); - rt.drop(drain); + rs.drop(drain); flush(out); - const collected: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_29: [rt.usize, rt.u8]): Item.Item => { + const collected: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_29: [rs.usize, rs.u8]): Item.Item => { return item(_29[0], _29[1]); }), undefined, 2, true), Item.le$cmp_PartialOrd, Item.ge$cmp_PartialOrd, Item.lt$cmp_PartialOrd); - rt.byteVecPush(out, option_mapOr$14aggam(rt.heapPop(collected, Item.le$cmp_PartialOrd), 255, (x7: Item.Item): rt.u8 => { - const _09: rt.u8 = x7.tag; + rs.byteVecPush(out, option_mapOr$13h3wxw(rs.heapPop(collected, Item.le$cmp_PartialOrd), 255, (x7: Item.Item): rs.u8 => { + const _09: rs.u8 = x7.tag; x7[Symbol.dispose](); return _09; })); - const rest: rt.Iter = rt.heapIter(collected, rt.drop); - rt.byteVecPush(out, option_mapOr$14aggam(rt.iterToOption(rest.next()), 255, (x8: Item.Item): rt.u8 => { - const _010: rt.u8 = x8.tag; + const rest: rs.Iter = rs.heapIter(collected, rs.drop); + rs.byteVecPush(out, option_mapOr$13h3wxw(rs.iterToOption(rest.next()), 255, (x8: Item.Item): rs.u8 => { + const _010: rs.u8 = x8.tag; x8[Symbol.dispose](); return _010; })); - rt.drop(rest); + rs.drop(rest); flush(out); - rt.heapClear(other, rt.drop); + rs.heapClear(other, rs.drop); flush(out); - rt.heapDrop(other, rt.drop); - rt.heapDrop(heap, rt.drop); + rs.heapDrop(other, rs.drop); + rs.heapDrop(heap, rs.drop); } /** * Heaps of values with no comparison of their own: bytes, a min-heap of them, strings, * and tuples, built every way, and their vectors, slices, clones, and debug form. */ -export function values(data: rt.ByteSlice, out: rt.ByteVec): void { - const bytes: rt.BinaryHeap = rt.heapFrom(rt.byteVecToVec(rt.byteSliceToByteVec(data)), rt.le, rt.ge, rt.lt); - rt.heapPush(bytes, data.length & 0xff, rt.le); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.from(bytes.items)))), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.heapIntoSortedVec(rt.heapClone(bytes, undefined), rt.le, rt.ge, rt.lt))), undefined, true); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(bytes.items, f, rt.u8Debug)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0]])), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(bytes)), undefined, true); - const least: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { +export function values(data: rs.ByteSlice, out: rs.ByteVec): void { + const bytes: rs.BinaryHeap = rs.heapFrom(rs.byteVecToVec(rs.byteSliceToByteVec(data)), rs.le, rs.ge, rs.lt); + rs.heapPush(bytes, data.length & 0xff, rs.le); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.from(bytes.items)))), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.heapIntoSortedVec(rs.heapClone(bytes, undefined), rs.le, rs.ge, rs.lt))), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(bytes.items, f, rs.u8Debug)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0]])), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(bytes)), undefined, true); + const least: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; - }), undefined, 1, true), rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp))); - const _37: rt.Iter = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_23: rt.u8): rt.u8 => { - return rt.u8Div(_23, 2); + }), undefined, 1, true), rs.cmpLe(rs.cmpReverse(rs.cmp)), rs.cmpGe(rs.cmpReverse(rs.cmp)), rs.cmpLt(rs.cmpReverse(rs.cmp))); + const _37: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_23: rs.u8): rs.u8 => { + return rs.u8Div(_23, 2); }); - rt.heapExtend(least, _37, rt.cmpLe(rt.cmpReverse(rt.cmp)), rt.cmpGe(rt.cmpReverse(rt.cmp)), rt.cmpLt(rt.cmpReverse(rt.cmp)), undefined, 1, true); + rs.heapExtend(least, _37, rs.cmpLe(rs.cmpReverse(rs.cmp)), rs.cmpGe(rs.cmpReverse(rs.cmp)), rs.cmpLt(rs.cmpReverse(rs.cmp)), undefined, 1, true); while (true) { - const _40: rt.u8 | undefined = rt.heapPop(least, rt.cmpLe(rt.cmpReverse(rt.cmp))); + const _40: rs.u8 | undefined = rs.heapPop(least, rs.cmpLe(rs.cmpReverse(rs.cmp))); if (_40 !== undefined) { - rt.byteVecPush(out, _40); + rs.byteVecPush(out, _40); } else { break; } } - const _51: rt.usize = data.length; - const strings: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterSlice(["pear", "apple", rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(_51, f))]), undefined, 12, true), rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); - const copy: rt.BinaryHeap = rt.heapClone(strings, undefined); - const _56: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b4: rt.u8): string => { - const _43: rt.u8 = rt.u8Rem(b4, 10); - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(_43, f)); + const _51: rs.usize = data.length; + const strings: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(["pear", "apple", rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(_51, f))]), undefined, 12, true), rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); + const copy: rs.BinaryHeap = rs.heapClone(strings, undefined); + const _56: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b4: rs.u8): string => { + const _43: rs.u8 = rs.u8Rem(b4, 10); + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(_43, f)); }); - rt.heapExtend(copy, _56, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr), undefined, 12, true); - rt.heapRetain(copy, (s: string): boolean => { - if (!(rt.stringLen(s) > 1)) { - return rt.cmpStr(s, "5") === -1; + rs.heapExtend(copy, _56, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr), undefined, 12, true); + rs.heapRetain(copy, (s: string): boolean => { + if (!(rs.stringLen(s) > 1)) { + return rs.cmpStr(s, "5") === -1; } return true; - }, rt.cmpLe(rt.cmpStr), rt.cmpGe(rt.cmpStr), rt.cmpLt(rt.cmpStr)); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(copy.items), (s2: string): rt.Iter => { - return rt.strBytes(s2); + }, rs.cmpLe(rs.cmpStr), rs.cmpGe(rs.cmpStr), rs.cmpLt(rs.cmpStr)); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(copy.items), (s2: string): rs.Iter => { + return rs.strBytes(s2); }, undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterMap(rt.heapIter(strings), (s3: string): rt.u8 => { - return rt.stringLen(s3) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.heapIter(strings), (s3: string): rs.u8 => { + return rs.stringLen(s3) & 0xff; }), "next"); - const pairs: rt.BinaryHeap<[rt.u8, rt.u8]> = rt.heapNew() as rt.BinaryHeap<[rt.u8, rt.u8]>; - const _73: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.u8, rt.u8] => { - const b5: rt.u8 = _24; - return [rt.u8Rem(b5, 4), rt.u8Div(b5, 64)] as [rt.u8, rt.u8]; + const pairs: rs.BinaryHeap<[rs.u8, rs.u8]> = rs.heapNew() as rs.BinaryHeap<[rs.u8, rs.u8]>; + const _73: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.u8, rs.u8] => { + const b5: rs.u8 = _24; + return [rs.u8Rem(b5, 4), rs.u8Div(b5, 64)] as [rs.u8, rs.u8]; }); - rt.heapExtend(pairs, _73, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), undefined, 2, true); - const _78: [rt.u8, rt.u8][] = [[rt.u8Rem(data.length & 0xff, 4), 9] as [rt.u8, rt.u8]]; - rt.heapExtend(pairs, rt.iterMap(rt.iterSlice(_78), copy$tuple2_u8_u8), rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), undefined, 2, true); - const _84: rt.PeekMut<[rt.u8, rt.u8]> | undefined = rt.heapPeekMut(pairs, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + rs.heapExtend(pairs, _73, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 2, true); + const _78: [rs.u8, rs.u8][] = [[rs.u8Rem(data.length & 0xff, 4), 9] as [rs.u8, rs.u8]]; + rs.heapExtend(pairs, rs.iterMap(rs.iterSlice(_78), copy$tuple2_u8_u8), rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), undefined, 2, true); + const _84: rs.PeekMut<[rs.u8, rs.u8]> | undefined = rs.heapPeekMut(pairs, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); if (_84 !== undefined) { - const top: rt.PeekMut<[rt.u8, rt.u8]> = _84; - const _88: rt.u8 = rt.u8WrappingAdd(top.v[1], 1); - rt.peekMutDerefMut(top); + const top: rs.PeekMut<[rs.u8, rs.u8]> = _84; + const _88: rs.u8 = rs.u8WrappingAdd(top.v[1], 1); + rs.peekMutDerefMut(top); top.v[1] = _88; - rt.peekMutDrop(top); + rs.peekMutDrop(top); } - const _94: rt.PeekMut<[rt.u8, rt.u8]> | undefined = rt.heapPeekMut(pairs, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]))); + const _94: rs.PeekMut<[rs.u8, rs.u8]> | undefined = rs.heapPeekMut(pairs, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]))); if (_94 !== undefined) { - const top2: rt.PeekMut<[rt.u8, rt.u8]> = _94; - rt.peekMutDerefMut(top2); - Object.assign(top2.v, [0, 0] as [rt.u8, rt.u8]); - rt.peekMutDrop(top2); + const top2: rs.PeekMut<[rs.u8, rs.u8]> = _94; + rs.peekMutDerefMut(top2); + Object.assign(top2.v, [0, 0] as [rs.u8, rs.u8]); + rs.peekMutDrop(top2); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.vecIntoIter(rt.heapIntoSortedVec(pairs, rt.cmpLe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpGe(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp])))), (_25: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.vecIntoIter(rs.heapIntoSortedVec(pairs, rs.cmpLe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpGe(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp])))), (_25: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_25[0], _25[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } /** @@ -453,132 +453,132 @@ export function values(data: rt.ByteSlice, out: rt.ByteVec): void { * orders them, by their bytes and then by length: directly, through `Ord`'s defaults, as * keys and items, and in tuples, owned and borrowed. */ -export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = rt.byteSliceWindows(data, 2); +export function bytes(data: rs.ByteSlice, out: rs.ByteVec): void { + const iter: rs.Iter = rs.byteSliceWindows(data, 2); while (true) { - const _6: rt.ByteSlice | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.ByteSlice | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } - rt.idx(_6, 0); - const _14: rt.u8 = rt.u8Rem(_6.data[_6.start], 4); - rt.idx(_6, 1); - const _13: Uint8Array = Uint8Array.of(_14, rt.u8Rem(_6.data[_6.start + 1], 4)); - rt.idx(_6, 1); - const _27: rt.u8 = rt.u8Rem(_6.data[_6.start + 1], 4); - rt.idx(_6, 0); - const _12: [Uint8Array, Uint8Array] = [_13, Uint8Array.of(_27, rt.u8Rem(_6.data[_6.start], 2))]; + rs.idx(_6, 0); + const _14: rs.u8 = rs.u8Rem(_6.data[_6.start], 4); + rs.idx(_6, 1); + const _13: Uint8Array = Uint8Array.of(_14, rs.u8Rem(_6.data[_6.start + 1], 4)); + rs.idx(_6, 1); + const _27: rs.u8 = rs.u8Rem(_6.data[_6.start + 1], 4); + rs.idx(_6, 0); + const _12: [Uint8Array, Uint8Array] = [_13, Uint8Array.of(_27, rs.u8Rem(_6.data[_6.start], 2))]; const a: Uint8Array = _13; const b: Uint8Array = _12[1]; - const _41: rt.u8 = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) === -1 ? 1 : 0; - const order = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)); - const _45: rt.u8 = order !== undefined && order <= 0 ? 1 : 0; - const _49: rt.u8 = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) === 1 ? 1 : 0; - const order2 = rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_41, _45, _49, order2 !== undefined && order2 >= 0 ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) & 0xff, rt.optionUnwrap(rt.cmpBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b))) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max$1s8mlx0(a, b)[0], rt.ordMin(a, b, rt.cmpLt(rt.cmpBytes))[1], rt.ordClamp(a, Uint8Array.of(1, 1), Uint8Array.of(2, 2), rt.cmpLe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes), rt.cmpGt(rt.cmpBytes))[1])), undefined, true); - const pair: [Uint8Array, rt.u8] = [a, b[0]]; - const _95: [Uint8Array, rt.u8] = [b, a[1]]; - rt.byteVecPush(out, rt.cmpTuple<[Uint8Array, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp])(pair, _95) === -1 ? 1 : 0); + const _41: rs.u8 = rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) === -1 ? 1 : 0; + const order = rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)); + const _45: rs.u8 = order !== undefined && order <= 0 ? 1 : 0; + const _49: rs.u8 = rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) === 1 ? 1 : 0; + const order2 = rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_41, _45, _49, order2 !== undefined && order2 >= 0 ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) & 0xff, rs.optionUnwrap(rs.cmpBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b))) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max$0vq2d0c(a, b)[0], rs.ordMin(a, b, rs.cmpLt(rs.cmpBytes))[1], rs.ordClamp(a, Uint8Array.of(1, 1), Uint8Array.of(2, 2), rs.cmpLe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes), rs.cmpGt(rs.cmpBytes))[1])), undefined, true); + const pair: [Uint8Array, rs.u8] = [a, b[0]]; + const _95: [Uint8Array, rs.u8] = [b, a[1]]; + rs.byteVecPush(out, rs.cmpTuple<[Uint8Array, rs.u8], rs.Ordering | undefined>([rs.cmpBytes, rs.cmp])(pair, _95) === -1 ? 1 : 0); } - const cut: rt.usize = rt.min(data.length, 6); - const iter2: rt.RangeInclusive = new rt.RangeInclusive(0, cut, rt.usizeStep); + const cut: rs.usize = rs.min(data.length, 6); + const iter2: rs.RangeInclusive = new rs.RangeInclusive(0, cut, rs.usizeStep); l3: while (true) { - const _104: rt.usize | rt.Done = iter2.next(); - if (_104 === rt.DONE) { + const _104: rs.usize | rs.Done = iter2.next(); + if (_104 === rs.DONE) { break; } - const i: rt.usize = _104; - const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, cut, rt.usizeStep); + const i: rs.usize = _104; + const iter3: rs.RangeInclusive = new rs.RangeInclusive(0, cut, rs.usizeStep); while (true) { - const _111: rt.usize | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: rs.usize | rs.Done = iter3.next(); + if (_111 === rs.DONE) { continue l3; } - const j: rt.usize = _111; - const _118: rt.ByteSlice = rt.byteSliceRange(data, 0, i); - const _120: rt.ByteSlice = rt.byteSliceRange(data, j, cut); - const s: rt.ByteSlice = _118; - const _124: rt.u8 = rt.cmpBytes(s, _120) & 0xff; - const _127: rt.u8 = rt.cmpBytes(s, _120) === -1 ? 1 : 0; - const order3 = rt.cmpBytes(s, _120); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_124, _127, order3 !== undefined && order3 >= 0 ? 1 : 0)), undefined, true); - const _139: [rt.ByteVec, rt.ByteVec] = [rt.byteSliceToByteVec(s), rt.byteSliceToByteVec(_120)]; - const v: rt.ByteVec = _139[0]; - const u: rt.ByteVec = _139[1]; - const _144: rt.u8 = rt.cmpBytes(v, u) & 0xff; - const _149: rt.u8 = rt.cmpBytes(v, u) === 1 ? 1 : 0; - const order4 = rt.cmpBytes(v, u); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_144, _149, order4 !== undefined && order4 <= 0 ? 1 : 0)), undefined, true); + const j: rs.usize = _111; + const _118: rs.ByteSlice = rs.byteSliceRange(data, 0, i); + const _120: rs.ByteSlice = rs.byteSliceRange(data, j, cut); + const s: rs.ByteSlice = _118; + const _124: rs.u8 = rs.cmpBytes(s, _120) & 0xff; + const _127: rs.u8 = rs.cmpBytes(s, _120) === -1 ? 1 : 0; + const order3 = rs.cmpBytes(s, _120); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_124, _127, order3 !== undefined && order3 >= 0 ? 1 : 0)), undefined, true); + const _139: [rs.ByteVec, rs.ByteVec] = [rs.byteSliceToByteVec(s), rs.byteSliceToByteVec(_120)]; + const v: rs.ByteVec = _139[0]; + const u: rs.ByteVec = _139[1]; + const _144: rs.u8 = rs.cmpBytes(v, u) & 0xff; + const _149: rs.u8 = rs.cmpBytes(v, u) === 1 ? 1 : 0; + const order4 = rs.cmpBytes(v, u); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_144, _149, order4 !== undefined && order4 <= 0 ? 1 : 0)), undefined, true); } } - const arrays: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - return Uint8Array.of(rt.u8Rem(c.data[c.start], 4), option_mapOr$1surhce(rt.byteSliceGet(c, 1), 0, (b2: rt.u8): rt.u8 => { - return rt.u8Rem(b2, 4); + const arrays: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + return Uint8Array.of(rs.u8Rem(c.data[c.start], 4), option_mapOr$0vxw5sq(rs.byteSliceGet(c, 1), 0, (b2: rs.u8): rs.u8 => { + return rs.u8Rem(b2, 4); })); }), undefined, 2, true); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.iterMax(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a4: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(a4); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMax(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a4: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(a4); })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_mapOr$0z7fb2w(rt.iterMin(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), rt.cmpLt(rt.cmpBytes)), Uint8Array.of(9, 9), (a5: rt.ByteSlice): Uint8Array => { - return rt.byteSliceToArray(a5); + rs.iterExtendBytes(out, rs.iterSlice(option_mapOr$172961h(rs.iterMin(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.cmpLt(rs.cmpBytes)), Uint8Array.of(9, 9), (a5: rs.ByteSlice): Uint8Array => { + return rs.byteSliceToArray(a5); })), undefined, true); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterCopied(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, 2, true), rt.cmpLe(rt.cmpBytes), rt.cmpGe(rt.cmpBytes), rt.cmpLt(rt.cmpBytes)); + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterCopied(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, 2, true), rs.cmpLe(rs.cmpBytes), rs.cmpGe(rs.cmpBytes), rs.cmpLt(rs.cmpBytes)); while (true) { - const _179: Uint8Array | undefined = rt.heapPop(heap, rt.cmpLe(rt.cmpBytes)); + const _179: Uint8Array | undefined = rs.heapPop(heap, rs.cmpLe(rs.cmpBytes)); if (_179 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(_179), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_179), undefined, true); } else { break; } } - const _185: rt.Iter<[Uint8Array, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterCopied(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), rt.byteSliceToArray)), (_2: [rt.usize, Uint8Array]): [Uint8Array, rt.usize] => { - return [_2[1], _2[0]] as [Uint8Array, rt.usize]; + const _185: rs.Iter<[Uint8Array, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterCopied(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), rs.byteSliceToArray)), (_2: [rs.usize, Uint8Array]): [Uint8Array, rs.usize] => { + return [_2[1], _2[0]] as [Uint8Array, rs.usize]; }); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _185, true, undefined, undefined, undefined, 8, true)), (_22: [Uint8Array, rt.usize]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _185, true, undefined, undefined, undefined, 8, true)), (_22: [Uint8Array, rs.usize]): Uint8Array => { const k: Uint8Array = _22[0]; return Uint8Array.of(k[0], k[1], _22[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), true, 3), undefined, true); - rt.sliceSort(arrays.items, rt.cmpLt(rt.cmpBytes), 2, true); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true, 2), undefined, true); - const slices: rt.Vec = rt.iterToVec(rt.byteSliceChunks(data, 3), undefined, 8, true); - rt.sliceSort(slices.items, rt.cmpLt((a7: rt.ByteSlice, b3: rt.ByteSlice): rt.Ordering => { - return rt.cmpBytes(b3, a7); + }, (value: Uint8Array) => rs.iterSlice(value), true, 3), undefined, true); + rs.sliceSort(arrays.items, rs.cmpLt(rs.cmpBytes), 2, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true, 2), undefined, true); + const slices: rs.Vec = rs.iterToVec(rs.byteSliceChunks(data, 3), undefined, 8, true); + rs.sliceSort(slices.items, rs.cmpLt((a7: rs.ByteSlice, b3: rs.ByteSlice): rs.Ordering => { + return rs.cmpBytes(b3, a7); }), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(slices.items), (s2: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(slices.items), (s2: rs.ByteSlice): rs.u8 => { return s2.length & 0xff; }), undefined, true); - const vecs: rt.Vec<[rt.ByteVec, rt.usize]> = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.byteSliceChunks(data, 3)), (_29: [rt.usize, rt.ByteSlice]): [rt.ByteVec, rt.usize] => { - const i4: rt.usize = _29[0]; - return [rt.byteSliceToByteVec(_29[1]), i4] as [rt.ByteVec, rt.usize]; + const vecs: rs.Vec<[rs.ByteVec, rs.usize]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.byteSliceChunks(data, 3)), (_29: [rs.usize, rs.ByteSlice]): [rs.ByteVec, rs.usize] => { + const i4: rs.usize = _29[0]; + return [rs.byteSliceToByteVec(_29[1]), i4] as [rs.ByteVec, rs.usize]; }), undefined, 16, true); - rt.sliceSort(vecs.items, rt.cmpLt(rt.cmpTuple<[rt.ByteVec, rt.usize], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp])), 16, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(vecs.items), (_211: [rt.ByteVec, rt.usize]): rt.u8 => { + rs.sliceSort(vecs.items, rs.cmpLt(rs.cmpTuple<[rs.ByteVec, rs.usize], rs.Ordering | undefined>([rs.cmpBytes, rs.cmp])), 16, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(vecs.items), (_211: [rs.ByteVec, rs.usize]): rs.u8 => { return _211[1] & 0xff; }), undefined, true); - const refs: rt.Vec<[rt.ByteSlice, rt.u8]> = new rt.Vec(); - const iter4: rt.Iter = rt.byteSliceWindows(data, 2); + const refs: rs.Vec<[rs.ByteSlice, rs.u8]> = new rs.Vec(); + const iter4: rs.Iter = rs.byteSliceWindows(data, 2); while (true) { - const _228: rt.ByteSlice | rt.Done = iter4.next(); - if (_228 === rt.DONE) { + const _228: rs.ByteSlice | rs.Done = iter4.next(); + if (_228 === rs.DONE) { break; } if (_228.length >= 2) { - rt.idx(_228, 0); - refs.items.push([new rt.ByteSlice(_228.data, _228.start, 2), rt.u8Div(_228.data[_228.start], 64)] as [rt.ByteSlice, rt.u8]); + rs.idx(_228, 0); + refs.items.push([new rs.ByteSlice(_228.data, _228.start, 2), rs.u8Div(_228.data[_228.start], 64)] as [rs.ByteSlice, rs.u8]); } } - rt.sliceSort(refs.items, rt.cmpLt(rt.cmpTuple<[rt.ByteSlice, rt.u8], rt.Ordering | undefined>([rt.cmpBytes, rt.cmp])), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(refs.items), (_212: [rt.ByteSlice, rt.u8]): rt.u8 => { - const _86: rt.ByteSlice = _212[0]; + rs.sliceSort(refs.items, rs.cmpLt(rs.cmpTuple<[rs.ByteSlice, rs.u8], rs.Ordering | undefined>([rs.cmpBytes, rs.cmp])), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(refs.items), (_212: [rs.ByteSlice, rs.u8]): rs.u8 => { + const _86: rs.ByteSlice = _212[0]; return _86.data[_86.start] ^ _212[1]; }), undefined, true); } -export function part(tag: rt.usize, key: rt.u8): Part.Part { - return { key: rt.u8Rem(key, 8), tag: tag & 0xff }; +export function part(tag: rs.usize, key: rs.u8): Part.Part { + return { key: rs.u8Rem(key, 8), tag: tag & 0xff }; } /** @@ -588,146 +588,146 @@ export function part(tag: rt.usize, key: rt.u8): Part.Part { * `min`, `clamp`, and their `_by` forms, and as `sort_by` orders them, whose comparisons * are the runtime's own. */ -export function tuples(data: rt.ByteSlice, out: rt.ByteVec): void { - const _3: (a0: rt.u8) => rt.f64 = (b: rt.u8): rt.f64 => { - if (!(rt.u8Rem(b, 5) === 0)) { - return rt.u8Rem(b, 4) as rt.f64; +export function tuples(data: rs.ByteSlice, out: rs.ByteVec): void { + const _3: (a0: rs.u8) => rs.f64 = (b: rs.u8): rs.f64 => { + if (!(rs.u8Rem(b, 5) === 0)) { + return rs.u8Rem(b, 4) as rs.f64; } return NaN; }; - const parts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): Part.Part => { + const parts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): Part.Part => { return part(_2[0], _2[1]); }), undefined, 2, true); - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceWindows(data, 2)); while (true) { - const _12: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - const i: rt.usize = _12[0]; - const at = rt.idx(parts.items, i); - const at2 = rt.idx(parts.items, rt.usizeAdd(i, 1)); + const i: rs.usize = _12[0]; + const at = rs.idx(parts.items, i); + const at2 = rs.idx(parts.items, rs.usizeAdd(i, 1)); const part_ = parts.items[at]; const part2 = parts.items[at2]; - rt.idx(_12[1], 0); - const _29: rt.u8 = rt.u8Rem(_12[1].data[_12[1].start], 3); - rt.idx(_12[1], 1); - const _28: [rt.u8, rt.u8] = [_29, rt.u8Rem(_12[1].data[_12[1].start + 1], 3)]; - const x: rt.u8 = _29; - const y: rt.u8 = _28[1]; + rs.idx(_12[1], 0); + const _29: rs.u8 = rs.u8Rem(_12[1].data[_12[1].start], 3); + rs.idx(_12[1], 1); + const _28: [rs.u8, rs.u8] = [_29, rs.u8Rem(_12[1].data[_12[1].start + 1], 3)]; + const x: rs.u8 = _29; + const y: rs.u8 = _28[1]; const _44: [Part.Part] = [part_]; const _46: [Part.Part] = [part2]; - const _42: rt.Ordering = rt.cmpTuple<[Part.Part], rt.Ordering>([Part.cmp$cmp_Ord])(_44, _46); - const _49: [Part.Part, rt.u8] = [part_, x]; - const _51: [Part.Part, rt.u8] = [part2, y]; - const _47: rt.Ordering = rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmp])(_49, _51); - const _54: [rt.u8, Part.Part] = [x, part_]; - const _56: [rt.u8, Part.Part] = [y, part2]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_42, _47, rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering>([rt.cmp, Part.cmp$cmp_Ord])(_54, _56), ranked$tuples_u8([part_, x] as [Part.Part, rt.u8], [part2, y] as [Part.Part, rt.u8]), ranked$tuples_Vec_u8([part_, rt.byteVecFrom(Uint8Array.of(x))] as [Part.Part, rt.ByteVec], [part2, rt.byteVecFrom(Uint8Array.of(y))] as [Part.Part, rt.ByteVec])], (o: rt.Ordering): rt.u8 => { + const _42: rs.Ordering = rs.cmpTuple<[Part.Part], rs.Ordering>([Part.cmp$cmp_Ord])(_44, _46); + const _49: [Part.Part, rs.u8] = [part_, x]; + const _51: [Part.Part, rs.u8] = [part2, y]; + const _47: rs.Ordering = rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp])(_49, _51); + const _54: [rs.u8, Part.Part] = [x, part_]; + const _56: [rs.u8, Part.Part] = [y, part2]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_42, _47, rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering>([rs.cmp, Part.cmp$cmp_Ord])(_54, _56), ranked$tuples_u8([part_, x] as [Part.Part, rs.u8], [part2, y] as [Part.Part, rs.u8]), ranked$tuples_Vec_u8([part_, rs.byteVecFrom(Uint8Array.of(x))] as [Part.Part, rs.ByteVec], [part2, rs.byteVecFrom(Uint8Array.of(y))] as [Part.Part, rs.ByteVec])], (o: rs.Ordering): rs.u8 => { return o & 0xff; })), undefined, true); flush(out); - const s: [rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, Part.Part] = [x, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, part_]; - const t: [rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, Part.Part] = [y, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, part2]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.cmpTuple<[rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, Part.Part], rt.Ordering>([rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, Part.cmp$cmp_Ord])(s, t) & 0xff, order(rt.cmpTuple<[rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, Part.partialCmp$cmp_PartialOrd])(s, t)), rt.cmpTuple<[rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, rt.cmp, Part.partialCmp$cmp_PartialOrd])(s, t) === -1 ? 1 : 0)), undefined, true); + const s: [rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, Part.Part] = [x, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, part_]; + const t: [rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, Part.Part] = [y, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, part2]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.cmpTuple<[rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, Part.Part], rs.Ordering>([rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, Part.cmp$cmp_Ord])(s, t) & 0xff, order(rs.cmpTuple<[rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, Part.partialCmp$cmp_PartialOrd])(s, t)), rs.cmpTuple<[rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, rs.cmp, Part.partialCmp$cmp_PartialOrd])(s, t) === -1 ? 1 : 0)), undefined, true); flush(out); - rt.idx(_12[1], 0); - const _95: rt.f64 = _3(_12[1].data[_12[1].start]); - rt.idx(_12[1], 1); - const _94: [rt.f64, rt.f64] = [_95, _3(_12[1].data[_12[1].start + 1])]; - const fx: rt.f64 = _95; - const fy: rt.f64 = _94[1]; - const _114: [Part.Part, rt.f64] = [part_, fx]; - const _116: [Part.Part, rt.f64] = [part2, fy]; - const _111: rt.u8 = order(rt.cmpTuple<[Part.Part, rt.f64], rt.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rt.f64PartialCmp])(_114, _116)); - const _120: [rt.f64, Part.Part] = [fx, part_]; - const _122: [rt.f64, Part.Part] = [fy, part2]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_111, order(rt.cmpTuple<[rt.f64, Part.Part], rt.Ordering | undefined>([rt.f64PartialCmp, Part.partialCmp$cmp_PartialOrd])(_120, _122)), order(rt.cmpTuple<[rt.u8, rt.f64], rt.Ordering | undefined>([rt.cmp, rt.f64PartialCmp])([x, fx] as [rt.u8, rt.f64], [y, fy] as [rt.u8, rt.f64])))), undefined, true); - const _134: [Part.Part, rt.f64] = [part_, fx]; - const _136: [Part.Part, rt.f64] = [part2, fy]; - const _132: boolean = rt.cmpTuple<[Part.Part, rt.f64], rt.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rt.f64PartialCmp])(_134, _136) === -1; - const order_ = rt.cmpTuple<[rt.f64, rt.u8], rt.Ordering | undefined>([rt.f64PartialCmp, rt.cmp])([fx, x] as [rt.f64, rt.u8], [fy, y] as [rt.f64, rt.u8]); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_132, order_ !== undefined && order_ >= 0], (a0: boolean): rt.u8 => { + rs.idx(_12[1], 0); + const _95: rs.f64 = _3(_12[1].data[_12[1].start]); + rs.idx(_12[1], 1); + const _94: [rs.f64, rs.f64] = [_95, _3(_12[1].data[_12[1].start + 1])]; + const fx: rs.f64 = _95; + const fy: rs.f64 = _94[1]; + const _114: [Part.Part, rs.f64] = [part_, fx]; + const _116: [Part.Part, rs.f64] = [part2, fy]; + const _111: rs.u8 = order(rs.cmpTuple<[Part.Part, rs.f64], rs.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rs.f64PartialCmp])(_114, _116)); + const _120: [rs.f64, Part.Part] = [fx, part_]; + const _122: [rs.f64, Part.Part] = [fy, part2]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_111, order(rs.cmpTuple<[rs.f64, Part.Part], rs.Ordering | undefined>([rs.f64PartialCmp, Part.partialCmp$cmp_PartialOrd])(_120, _122)), order(rs.cmpTuple<[rs.u8, rs.f64], rs.Ordering | undefined>([rs.cmp, rs.f64PartialCmp])([x, fx] as [rs.u8, rs.f64], [y, fy] as [rs.u8, rs.f64])))), undefined, true); + const _134: [Part.Part, rs.f64] = [part_, fx]; + const _136: [Part.Part, rs.f64] = [part2, fy]; + const _132: boolean = rs.cmpTuple<[Part.Part, rs.f64], rs.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rs.f64PartialCmp])(_134, _136) === -1; + const order_ = rs.cmpTuple<[rs.f64, rs.u8], rs.Ordering | undefined>([rs.f64PartialCmp, rs.cmp])([fx, x] as [rs.f64, rs.u8], [fy, y] as [rs.f64, rs.u8]); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_132, order_ !== undefined && order_ >= 0], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); flush(out); - const _146: [Part.Part, rt.u8][] = [[part_, x] as [Part.Part, rt.u8]]; - const _149: [Part.Part, rt.u8][] = [[part2, y] as [Part.Part, rt.u8]]; - const _144: rt.Ordering = rt.cmpSlice(rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmp]))(_146, _149); - const _153: rt.Vec<[rt.u8, Part.Part]> = rt.vecFrom([[x, part_] as [rt.u8, Part.Part]]); - const _157: rt.Vec<[rt.u8, Part.Part]> = rt.vecFrom([[y, part2] as [rt.u8, Part.Part]]); - const _151: rt.Ordering = rt.cmpSlice(rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering>([rt.cmp, Part.cmp$cmp_Ord]))(_153, _157); - const _162: [Part.Part, rt.u8] | undefined = [part_, x]; - const _165: [Part.Part, rt.u8] | undefined = [part2, y]; - const _160: rt.Ordering = rt.cmpOption(rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmp]))(_162, _165); - const _167: rt.Ordering = result_cmp$0qsbu3y(rt.Ok([part_] as [Part.Part]), rt.Ok([part2] as [Part.Part])); - const _176: [Part.Part, rt.u8] = [part_, x]; - const _179: [Part.Part, rt.u8] = [part2, y]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_144, _151, _160, _167, rt.cmpReverse(rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmp]))(_176, _179)], (o2: rt.Ordering): rt.u8 => { + const _146: [Part.Part, rs.u8][] = [[part_, x] as [Part.Part, rs.u8]]; + const _149: [Part.Part, rs.u8][] = [[part2, y] as [Part.Part, rs.u8]]; + const _144: rs.Ordering = rs.cmpSlice(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp]))(_146, _149); + const _153: rs.Vec<[rs.u8, Part.Part]> = rs.vecFrom([[x, part_] as [rs.u8, Part.Part]]); + const _157: rs.Vec<[rs.u8, Part.Part]> = rs.vecFrom([[y, part2] as [rs.u8, Part.Part]]); + const _151: rs.Ordering = rs.cmpSlice(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering>([rs.cmp, Part.cmp$cmp_Ord]))(_153, _157); + const _162: [Part.Part, rs.u8] | undefined = [part_, x]; + const _165: [Part.Part, rs.u8] | undefined = [part2, y]; + const _160: rs.Ordering = rs.cmpOption(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp]))(_162, _165); + const _167: rs.Ordering = result_cmp$0h35u3j(rs.Ok([part_] as [Part.Part]), rs.Ok([part2] as [Part.Part])); + const _176: [Part.Part, rs.u8] = [part_, x]; + const _179: [Part.Part, rs.u8] = [part2, y]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_144, _151, _160, _167, rs.cmpReverse(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp]))(_176, _179)], (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; })), undefined, true); flush(out); - const _186: [[Part.Part, rt.u8], [rt.u8, Part.Part]] = [rt.ordMax([part_, x] as [Part.Part, rt.u8], [part2, y] as [Part.Part, rt.u8], rt.cmpLt(rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rt.cmp]))), rt.ordMin([x, part_] as [rt.u8, Part.Part], [y, part2] as [rt.u8, Part.Part], rt.cmpLt(rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, Part.partialCmp$cmp_PartialOrd])))]; - const max: [Part.Part, rt.u8] = _186[0]; - const min: [rt.u8, Part.Part] = _186[1]; - const clamped: [rt.u8, Part.Part] = rt.ordClamp([x, part_] as [rt.u8, Part.Part], [0, part2] as [rt.u8, Part.Part], [2, part2] as [rt.u8, Part.Part], rt.cmpLe(rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, Part.partialCmp$cmp_PartialOrd])), rt.cmpLt(rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, Part.partialCmp$cmp_PartialOrd])), rt.cmpGt(rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering | undefined>([rt.cmp, Part.partialCmp$cmp_PartialOrd]))); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(max[0].tag, max[1], min[0], min[1].tag, clamped[0], clamped[1].tag)), undefined, true); + const _186: [[Part.Part, rs.u8], [rs.u8, Part.Part]] = [rs.ordMax([part_, x] as [Part.Part, rs.u8], [part2, y] as [Part.Part, rs.u8], rs.cmpLt(rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering | undefined>([Part.partialCmp$cmp_PartialOrd, rs.cmp]))), rs.ordMin([x, part_] as [rs.u8, Part.Part], [y, part2] as [rs.u8, Part.Part], rs.cmpLt(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, Part.partialCmp$cmp_PartialOrd])))]; + const max: [Part.Part, rs.u8] = _186[0]; + const min: [rs.u8, Part.Part] = _186[1]; + const clamped: [rs.u8, Part.Part] = rs.ordClamp([x, part_] as [rs.u8, Part.Part], [0, part2] as [rs.u8, Part.Part], [2, part2] as [rs.u8, Part.Part], rs.cmpLe(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, Part.partialCmp$cmp_PartialOrd])), rs.cmpLt(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, Part.partialCmp$cmp_PartialOrd])), rs.cmpGt(rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering | undefined>([rs.cmp, Part.partialCmp$cmp_PartialOrd]))); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(max[0].tag, max[1], min[0], min[1].tag, clamped[0], clamped[1].tag)), undefined, true); flush(out); - const _208: [[rt.f64, rt.u8], [rt.f64, rt.u8]] = [[fx, x] as [rt.f64, rt.u8], [fy, y] as [rt.f64, rt.u8]]; - const p: [rt.f64, rt.u8] = _208[0]; - const q: [rt.f64, rt.u8] = _208[1]; - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice([maxBy$0yuzdd4(p, q, (p2: [rt.f64, rt.u8], q2: [rt.f64, rt.u8]): rt.Ordering => { - return option_unwrapOr$0l1fs14(rt.cmpTuple<[rt.f64, rt.u8], rt.Ordering | undefined>([rt.f64PartialCmp, rt.cmp])(p2, q2), -1 as rt.Ordering); - }), minBy$0wmhcb1(p, q, (p3: [rt.f64, rt.u8], q3: [rt.f64, rt.u8]): rt.Ordering => { - return option_unwrapOr$0l1fs14(rt.cmpTuple<[rt.f64, rt.u8], rt.Ordering | undefined>([rt.f64PartialCmp, rt.cmp])(p3, q3), -1 as rt.Ordering); - })]), (_23: [rt.f64, rt.u8]): Uint8Array => { - let _510!: rt.u8; - const f: rt.f64 = _23[0]; - const n: rt.u8 = _23[1]; + const _208: [[rs.f64, rs.u8], [rs.f64, rs.u8]] = [[fx, x] as [rs.f64, rs.u8], [fy, y] as [rs.f64, rs.u8]]; + const p: [rs.f64, rs.u8] = _208[0]; + const q: [rs.f64, rs.u8] = _208[1]; + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice([maxBy$1gr65n2(p, q, (p2: [rs.f64, rs.u8], q2: [rs.f64, rs.u8]): rs.Ordering => { + return option_unwrapOr$18rai12(rs.cmpTuple<[rs.f64, rs.u8], rs.Ordering | undefined>([rs.f64PartialCmp, rs.cmp])(p2, q2), -1 as rs.Ordering); + }), minBy$0p6yz91(p, q, (p3: [rs.f64, rs.u8], q3: [rs.f64, rs.u8]): rs.Ordering => { + return option_unwrapOr$18rai12(rs.cmpTuple<[rs.f64, rs.u8], rs.Ordering | undefined>([rs.f64PartialCmp, rs.cmp])(p3, q3), -1 as rs.Ordering); + })]), (_23: [rs.f64, rs.u8]): Uint8Array => { + let _510!: rs.u8; + const f: rs.f64 = _23[0]; + const n: rs.u8 = _23[1]; if (!Number.isNaN(f)) { - _510 = rt.u8FromF64(f); + _510 = rs.u8FromF64(f); } else { _510 = 9; } return Uint8Array.of(_510, n); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } - const pairs: rt.Vec<[rt.u8, Part.Part]> = rt.iterToVec(rt.iterMap(rt.iterSlice(parts.items), (p4: Part.Part): [rt.u8, Part.Part] => { - return [rt.u8Rem(p4.tag, 3), p4] as [rt.u8, Part.Part]; + const pairs: rs.Vec<[rs.u8, Part.Part]> = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p4: Part.Part): [rs.u8, Part.Part] => { + return [rs.u8Rem(p4.tag, 3), p4] as [rs.u8, Part.Part]; }), undefined, 8, true); - rt.sliceSort(pairs.items, rt.cmpLt((p5: [rt.u8, Part.Part], q4: [rt.u8, Part.Part]): rt.Ordering => { - const _512: [rt.u8, Part.Part] = [p5[0], p5[1]]; - const _92: [rt.u8, Part.Part] = [q4[0], q4[1]]; - return rt.cmpTuple<[rt.u8, Part.Part], rt.Ordering>([rt.cmp, Part.cmp$cmp_Ord])(_512, _92); + rs.sliceSort(pairs.items, rs.cmpLt((p5: [rs.u8, Part.Part], q4: [rs.u8, Part.Part]): rs.Ordering => { + const _512: [rs.u8, Part.Part] = [p5[0], p5[1]]; + const _92: [rs.u8, Part.Part] = [q4[0], q4[1]]; + return rs.cmpTuple<[rs.u8, Part.Part], rs.Ordering>([rs.cmp, Part.cmp$cmp_Ord])(_512, _92); }), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(pairs.items), (p6: [rt.u8, Part.Part]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(pairs.items), (p6: [rs.u8, Part.Part]): rs.u8 => { return p6[1].tag; }), undefined, true); - rt.localKeyWithBorrowMut(LOG, (a02: rt.ByteVec): undefined => { - rt.byteVecClear(a02); + rs.localKeyWithBorrowMut(LOG, (a02: rs.ByteVec): undefined => { + rs.byteVecClear(a02); }); - const floats: rt.Vec<[rt.f64, rt.u8]> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.f64, rt.u8] => { - const b3: rt.u8 = _26; - return [rt.u8Rem(b3, 4) as rt.f64, b3] as [rt.f64, rt.u8]; + const floats: rs.Vec<[rs.f64, rs.u8]> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): [rs.f64, rs.u8] => { + const b3: rs.u8 = _26; + return [rs.u8Rem(b3, 4) as rs.f64, b3] as [rs.f64, rs.u8]; }), undefined, 16, true); - rt.sliceSort(floats.items, rt.cmpLt((p7: [rt.f64, rt.u8], q5: [rt.f64, rt.u8]): rt.Ordering => { - return rt.optionExpect(rt.cmpTuple<[rt.f64, rt.u8], rt.Ordering | undefined>([rt.f64PartialCmp, rt.cmp])(p7, q5), "no NaN"); + rs.sliceSort(floats.items, rs.cmpLt((p7: [rs.f64, rs.u8], q5: [rs.f64, rs.u8]): rs.Ordering => { + return rs.optionExpect(rs.cmpTuple<[rs.f64, rs.u8], rs.Ordering | undefined>([rs.f64PartialCmp, rs.cmp])(p7, q5), "no NaN"); }), 16, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(floats.items), (p8: [rt.f64, rt.u8]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(floats.items), (p8: [rs.f64, rs.u8]): rs.u8 => { return p8[1]; }), undefined, true); } -export function ranked$tuples_Vec_u8(a: [Part.Part, rt.ByteVec], b: [Part.Part, rt.ByteVec]): rt.Ordering { - return rt.cmpTuple<[Part.Part, rt.ByteVec], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmpBytes])(a, b); +export function ranked$tuples_Vec_u8(a: [Part.Part, rs.ByteVec], b: [Part.Part, rs.ByteVec]): rs.Ordering { + return rs.cmpTuple<[Part.Part, rs.ByteVec], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmpBytes])(a, b); } -export function ranked$tuples_u8(a: [Part.Part, rt.u8], b: [Part.Part, rt.u8]): rt.Ordering { - return rt.cmpTuple<[Part.Part, rt.u8], rt.Ordering>([Part.cmp$cmp_Ord, rt.cmp])(a, b); +export function ranked$tuples_u8(a: [Part.Part, rs.u8], b: [Part.Part, rs.u8]): rs.Ordering { + return rs.cmpTuple<[Part.Part, rs.u8], rs.Ordering>([Part.cmp$cmp_Ord, rs.cmp])(a, b); } -export function order(o: rt.Ordering | undefined): rt.u8 { - return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function order(o: rs.Ordering | undefined): rs.u8 { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); } @@ -736,29 +736,29 @@ export function order(o: rt.Ordering | undefined): rt.u8 { * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { - let at!: rt.usize; +export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rs.usize, a1: rs.u8) => Part.Part): rs.VecDeque { + let at!: rs.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(sLen, 2); + at = rs.usizeDiv(sLen, 2); } const mid: number = at; if (mid > sLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const _17: rt.usize = at; - const d: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { - return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true), 2) as rt.VecDeque; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); + const _17: rs.usize = at; + const d: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rs.usize, rs.u8]): Part.Part => { + return f(rs.usizeAdd(_2[0], _17), _2[1]); + }), undefined, 2, true), 2) as rs.VecDeque; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart, mid))))); while (true) { - const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_23 === rs.DONE) { return d; } const _30: Part.Part = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rs.dequePushFront(d, _30); } } @@ -766,29 +766,29 @@ export function deque$orders_Part_orders_held_closure3(sData: Uint8Array, sStart * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, _: (a0: rt.usize, a1: rt.u8) => Part.Part): rt.VecDeque { - let at!: rt.usize; +export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, _: (a0: rs.usize, a1: rs.u8) => Part.Part): rs.VecDeque { + let at!: rs.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(sLen, 2); + at = rs.usizeDiv(sLen, 2); } const mid: number = at; if (mid > sLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const _17: rt.usize = at; - const d: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): Part.Part => { - return part(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 2, true), 2) as rt.VecDeque; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); + const _17: rs.usize = at; + const d: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rs.usize, rs.u8]): Part.Part => { + return part(rs.usizeAdd(_2[0], _17), _2[1]); + }), undefined, 2, true), 2) as rs.VecDeque; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart, mid))))); while (true) { - const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_23 === rs.DONE) { return d; } const _30: Part.Part = part(_23[0], _23[1]); - rt.dequePushFront(d, _30); + rs.dequePushFront(d, _30); } } @@ -796,29 +796,29 @@ export function deque$orders_Part_orders_part(sData: Uint8Array, sStart: number, * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { - let at!: rt.usize; +export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rs.usize, a1: rs.u8) => rs.u8): rs.VecDeque { + let at!: rs.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(sLen, 2); + at = rs.usizeDiv(sLen, 2); } const mid: number = at; if (mid > sLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const _17: rt.usize = at; - const d: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { - return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true), 1, true) as rt.VecDeque; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); + const _17: rs.usize = at; + const d: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rs.usize, rs.u8]): rs.u8 => { + return f(rs.usizeAdd(_2[0], _17), _2[1]); + }), undefined, 1, true), 1, true) as rs.VecDeque; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart, mid))))); while (true) { - const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_23 === rs.DONE) { return d; } - const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + const _30: rs.u8 = f(_23[0], _23[1]); + rs.dequePushFront(d, _30); } } @@ -826,29 +826,29 @@ export function deque$u8_orders_held_closure11(sData: Uint8Array, sStart: number * A deque of `f` of each byte and its index: straight, or with its first half pushed to the * front in reverse, so it wraps around its buffer. */ -export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rt.usize, a1: rt.u8) => rt.u8): rt.VecDeque { - let at!: rt.usize; +export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, sLen: number, wraps: boolean, f: (a0: rs.usize, a1: rs.u8) => rs.u8): rs.VecDeque { + let at!: rs.usize; if (!wraps) { at = 0; } else { - at = rt.usizeDiv(sLen, 2); + at = rs.usizeDiv(sLen, 2); } const mid: number = at; if (mid > sLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const _17: rt.usize = at; - const d: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rt.usize, rt.u8]): rt.u8 => { - return f(rt.usizeAdd(_2[0], _17), _2[1]); - }), undefined, 1, true), 1, true) as rt.VecDeque; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterRev(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(new rt.ByteSlice(sData, sStart, mid))))); + const _17: rs.usize = at; + const d: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart + mid, sLen - mid)))), (_2: [rs.usize, rs.u8]): rs.u8 => { + return f(rs.usizeAdd(_2[0], _17), _2[1]); + }), undefined, 1, true), 1, true) as rs.VecDeque; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterRev(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(new rs.ByteSlice(sData, sStart, mid))))); while (true) { - const _23: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_23 === rs.DONE) { return d; } - const _30: rt.u8 = f(_23[0], _23[1]); - rt.dequePushFront(d, _30); + const _30: rs.u8 = f(_23[0], _23[1]); + rs.dequePushFront(d, _30); } } @@ -858,248 +858,248 @@ export function deque$u8_orders_held_closure8(sData: Uint8Array, sStart: number, * ring buffer wraps: of parts, which log where std stops, and of floats, whose NaN orders * as nothing. Then each as a B-tree key. */ -export function held(data: rt.ByteSlice, out: rt.ByteVec): void { +export function held(data: rs.ByteSlice, out: rs.ByteVec): void { let _342!: Uint8Array; - let key!: rt.Result, rt.Poll>; - const _3: (a0: rt.usize, a1: rt.u8) => rt.Result = (i5: rt.usize, b2: rt.u8): rt.Result => { + let key!: rs.Result, rs.Poll>; + const _3: (a0: rs.usize, a1: rs.u8) => rs.Result = (i5: rs.usize, b2: rs.u8): rs.Result => { if ((b2 & 128) === 0) { - return rt.Ok(part(i5, b2)); + return rs.Ok(part(i5, b2)); } - return rt.Err(part(i5, b2 >> 3)); + return rs.Err(part(i5, b2 >> 3)); }; - const _4: (a0: rt.u8) => rt.Result = (b3: rt.u8): rt.Result => { - let x2!: rt.f64; - if (!(rt.u8Rem(b3, 5) === 0)) { - x2 = rt.u8Rem(b3, 4) as rt.f64; + const _4: (a0: rs.u8) => rs.Result = (b3: rs.u8): rs.Result => { + let x2!: rs.f64; + if (!(rs.u8Rem(b3, 5) === 0)) { + x2 = rs.u8Rem(b3, 4) as rs.f64; } else { x2 = NaN; } if (!((b3 & 1) === 0)) { - return rt.Err(x2); + return rs.Err(x2); } - return rt.Ok(x2); + return rs.Ok(x2); }; - const _5: (a0: rt.u8) => rt.Poll = (b4: rt.u8): rt.Poll => { - if (!(rt.u8Rem(b4, 3) === 0)) { - return rt.u8Rem(b4, 4); + const _5: (a0: rs.u8) => rs.Poll = (b4: rs.u8): rs.Poll => { + if (!(rs.u8Rem(b4, 3) === 0)) { + return rs.u8Rem(b4, 4); } - return rt.Pending; + return rs.Pending; }; - const _296: (a0: rt.VecDeque) => rt.VecDeque = (d3: rt.VecDeque): rt.VecDeque => { - return rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.dequeIter(d3), (p2: Part.Part): rt.f64 => { + const _296: (a0: rs.VecDeque) => rs.VecDeque = (d3: rs.VecDeque): rs.VecDeque => { + return rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.dequeIter(d3), (p2: Part.Part): rs.f64 => { if (!(p2.key === 7)) { - return p2.key as rt.f64; + return p2.key as rs.f64; } return NaN; - }), undefined, 8, true), 8) as rt.VecDeque; + }), undefined, 8, true), 8) as rs.VecDeque; }; - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceWindows(data, 2)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceWindows(data, 2)); while (true) { - const _10: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const i: rt.usize = _10[0]; - const _21: rt.usize = rt.usizeMul(2, i); - rt.idx(_10[1], 0); - const _18: rt.Result = _3(_21, _10[1].data[_10[1].start]); - const _30: rt.usize = rt.usizeAdd(rt.usizeMul(2, i), 1); - rt.idx(_10[1], 1); - const _17: [rt.Result, rt.Result] = [_18, _3(_30, _10[1].data[_10[1].start + 1])]; - const a: rt.Result = _18; - const b: rt.Result = _17[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(order(result_partialCmp$0spmpix(a, b)), result_cmp$0h5rzdg(a, b) & 0xff)), undefined, true); - const _52: boolean = result_partialCmp$0spmpix(a, b) === -1; - const order_ = result_partialCmp$0spmpix(a, b); + const i: rs.usize = _10[0]; + const _21: rs.usize = rs.usizeMul(2, i); + rs.idx(_10[1], 0); + const _18: rs.Result = _3(_21, _10[1].data[_10[1].start]); + const _30: rs.usize = rs.usizeAdd(rs.usizeMul(2, i), 1); + rs.idx(_10[1], 1); + const _17: [rs.Result, rs.Result] = [_18, _3(_30, _10[1].data[_10[1].start + 1])]; + const a: rs.Result = _18; + const b: rs.Result = _17[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(order(result_partialCmp$0rzsy3r(a, b)), result_cmp$13u97s2(a, b) & 0xff)), undefined, true); + const _52: boolean = result_partialCmp$0rzsy3r(a, b) === -1; + const order_ = result_partialCmp$0rzsy3r(a, b); const _55: boolean = order_ !== undefined && order_ <= 0; - const _58: boolean = result_partialCmp$0spmpix(a, b) === 1; - const order2 = result_partialCmp$0spmpix(a, b); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_52, _55, _58, order2 !== undefined && order2 >= 0, result_eq$1faqxpo(a, b)], (a0: boolean): rt.u8 => { + const _58: boolean = result_partialCmp$0rzsy3r(a, b) === 1; + const order2 = result_partialCmp$0rzsy3r(a, b); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_52, _55, _58, order2 !== undefined && order2 >= 0, result_eq$0p2ygx3(a, b)], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const _72: rt.Result | undefined = a; - const _75: rt.Result | undefined = b; - const _69: rt.u8 = order(rt.cmpOption(result_partialCmp$0spmpix)(_72, _75)); - const _80: [rt.Result] = [a]; - const _83: [rt.Result] = [b]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_69, rt.cmpTuple<[rt.Result], rt.Ordering>([result_cmp$0h5rzdg])(_80, _83) & 0xff)), undefined, true); - const _91: rt.Result[] = [a, b]; - const _95: rt.Result[] = [b, a]; - const _89: boolean = rt.cmpSlice(result_partialCmp$0spmpix)(_91, _95) === -1; - const _100: rt.Vec> = rt.vecFrom([a]); - const _104: rt.Vec> = rt.vecFrom([b]); - const order3 = rt.cmpSlice(result_partialCmp$0spmpix)(_100, _104); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_89, order3 !== undefined && order3 >= 0], (a02: boolean): rt.u8 => { + const _72: rs.Result | undefined = a; + const _75: rs.Result | undefined = b; + const _69: rs.u8 = order(rs.cmpOption(result_partialCmp$0rzsy3r)(_72, _75)); + const _80: [rs.Result] = [a]; + const _83: [rs.Result] = [b]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_69, rs.cmpTuple<[rs.Result], rs.Ordering>([result_cmp$13u97s2])(_80, _83) & 0xff)), undefined, true); + const _91: rs.Result[] = [a, b]; + const _95: rs.Result[] = [b, a]; + const _89: boolean = rs.cmpSlice(result_partialCmp$0rzsy3r)(_91, _95) === -1; + const _100: rs.Vec> = rs.vecFrom([a]); + const _104: rs.Vec> = rs.vecFrom([b]); + const order3 = rs.cmpSlice(result_partialCmp$0rzsy3r)(_100, _104); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_89, order3 !== undefined && order3 >= 0], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); flush(out); - rt.idx(_10[1], 0); - const _111: rt.Result = _4(_10[1].data[_10[1].start]); - rt.idx(_10[1], 1); - const _110: [rt.Result, rt.Result] = [_111, _4(_10[1].data[_10[1].start + 1])]; - const x: rt.Result = _111; - const y: rt.Result = _110[1]; - const _127: rt.u8 = order(result_partialCmp$0v2kxbo(x, y)); - const _134 = x as rt.Result | undefined; - const _136 = y as rt.Result | undefined; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_127, order(rt.cmpOption(result_partialCmp$0v2kxbo)(_134, _136)))), undefined, true); - const _140: boolean = result_partialCmp$0v2kxbo(x, y) === -1; - const order4 = result_partialCmp$0v2kxbo(x, y); + rs.idx(_10[1], 0); + const _111: rs.Result = _4(_10[1].data[_10[1].start]); + rs.idx(_10[1], 1); + const _110: [rs.Result, rs.Result] = [_111, _4(_10[1].data[_10[1].start + 1])]; + const x: rs.Result = _111; + const y: rs.Result = _110[1]; + const _127: rs.u8 = order(result_partialCmp$1ks7sga(x, y)); + const _134 = x as rs.Result | undefined; + const _136 = y as rs.Result | undefined; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_127, order(rs.cmpOption(result_partialCmp$1ks7sga)(_134, _136)))), undefined, true); + const _140: boolean = result_partialCmp$1ks7sga(x, y) === -1; + const order4 = result_partialCmp$1ks7sga(x, y); const _143: boolean = order4 !== undefined && order4 <= 0; - const _146: boolean = result_partialCmp$0v2kxbo(x, y) === 1; - const order5 = result_partialCmp$0v2kxbo(x, y); + const _146: boolean = result_partialCmp$1ks7sga(x, y) === 1; + const order5 = result_partialCmp$1ks7sga(x, y); const _149: boolean = order5 !== undefined && order5 >= 0; - const _152: boolean = result_eq$15zrpyn(x, y); - const _157: [rt.Result, rt.i32] = [x, 1]; - const _159: [rt.Result, rt.i32] = [y, 0]; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_140, _143, _146, _149, _152, rt.cmpTuple<[rt.Result, rt.i32], rt.Ordering | undefined>([result_partialCmp$0v2kxbo, rt.cmp])(_157, _159) === -1], (a03: boolean): rt.u8 => { + const _152: boolean = result_eq$1wvyxyw(x, y); + const _157: [rs.Result, rs.i32] = [x, 1]; + const _159: [rs.Result, rs.i32] = [y, 0]; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_140, _143, _146, _149, _152, rs.cmpTuple<[rs.Result, rs.i32], rs.Ordering | undefined>([result_partialCmp$1ks7sga, rs.cmp])(_157, _159) === -1], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.idx(_10[1], 0); - const _163: rt.Poll = _5(_10[1].data[_10[1].start]); - rt.idx(_10[1], 1); - const _162: [rt.Poll, rt.Poll] = [_163, _5(_10[1].data[_10[1].start + 1])]; - const p: rt.Poll = _163; - const q: rt.Poll = _162[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(poll_cmp$175ka5q(p, q) & 0xff, order(poll_partialCmp$1r9dhkr(p, q)), poll_cmp$175ka5q(p, rt.Pending) & 0xff)), undefined, true); - const _196: boolean = poll_partialCmp$1r9dhkr(p, q) === -1; - const order6 = poll_partialCmp$1r9dhkr(p, q); + rs.idx(_10[1], 0); + const _163: rs.Poll = _5(_10[1].data[_10[1].start]); + rs.idx(_10[1], 1); + const _162: [rs.Poll, rs.Poll] = [_163, _5(_10[1].data[_10[1].start + 1])]; + const p: rs.Poll = _163; + const q: rs.Poll = _162[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(poll_cmp$17et0iz(p, q) & 0xff, order(poll_partialCmp$12m7vp8(p, q)), poll_cmp$17et0iz(p, rs.Pending) & 0xff)), undefined, true); + const _196: boolean = poll_partialCmp$12m7vp8(p, q) === -1; + const order6 = poll_partialCmp$12m7vp8(p, q); const _199: boolean = order6 !== undefined && order6 >= 0; - const _202: boolean = poll_eq$1h9nnoh(p, q); - const _205: boolean = poll_partialCmp$1r9dhkr(q, 2) === 1; - const _210 = p as rt.Poll | undefined; - const _212 = q as rt.Poll | undefined; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_196, _199, _202, _205, !rt.eqOption(poll_eq$1h9nnoh)(_210, _212)], (a04: boolean): rt.u8 => { + const _202: boolean = poll_eq$1qrb1lw(p, q); + const _205: boolean = poll_partialCmp$12m7vp8(q, 2) === 1; + const _210 = p as rs.Poll | undefined; + const _212 = q as rs.Poll | undefined; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_196, _199, _202, _205, !rs.eqOption(poll_eq$1qrb1lw)(_210, _212)], (a04: boolean): rs.u8 => { return a04 ? 1 : 0; })), undefined, true); - rt.byteVecPush(out, order(poll_partialCmp$1fsj76o(x as rt.Poll>, y as rt.Poll>))); + rs.byteVecPush(out, order(poll_partialCmp$1gaal0x(x as rs.Poll>, y as rs.Poll>))); } - const cut: rt.usize = rt.min(data.length, 6); - const iter2: rt.RangeInclusive = new rt.RangeInclusive(0, cut, rt.usizeStep); + const cut: rs.usize = rs.min(data.length, 6); + const iter2: rs.RangeInclusive = new rs.RangeInclusive(0, cut, rs.usizeStep); l3: while (true) { - const _225: rt.usize | rt.Done = iter2.next(); - if (_225 === rt.DONE) { + const _225: rs.usize | rs.Done = iter2.next(); + if (_225 === rs.DONE) { break; } - const i2: rt.usize = _225; - const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, cut, rt.usizeStep); + const i2: rs.usize = _225; + const iter3: rs.RangeInclusive = new rs.RangeInclusive(0, cut, rs.usizeStep); while (true) { - const _232: rt.usize | rt.Done = iter3.next(); - if (_232 === rt.DONE) { + const _232: rs.usize | rs.Done = iter3.next(); + if (_232 === rs.DONE) { continue l3; } - const _240: rt.ByteSlice = rt.byteSliceRange(data, 0, i2); - const j: rt.usize = _232; - const _239: rt.VecDeque = deque$orders_Part_orders_part(_240.data, _240.start, _240.length, false, part); - const _243: rt.ByteSlice = rt.byteSliceRange(data, j, cut); - const _238: [rt.VecDeque, rt.VecDeque] = [_239, deque$orders_Part_orders_held_closure3(_243.data, _243.start, _243.length, true, (i6: rt.usize, b5: rt.u8): Part.Part => { - return part(rt.usizeAdd(i6, 50), b5); + const _240: rs.ByteSlice = rs.byteSliceRange(data, 0, i2); + const j: rs.usize = _232; + const _239: rs.VecDeque = deque$orders_Part_orders_part(_240.data, _240.start, _240.length, false, part); + const _243: rs.ByteSlice = rs.byteSliceRange(data, j, cut); + const _238: [rs.VecDeque, rs.VecDeque] = [_239, deque$orders_Part_orders_held_closure3(_243.data, _243.start, _243.length, true, (i6: rs.usize, b5: rs.u8): Part.Part => { + return part(rs.usizeAdd(i6, 50), b5); })]; - const d: rt.VecDeque = _239; - const e: rt.VecDeque = _238[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(order(rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e)), rt.cmpDeque(Part.cmp$cmp_Ord)(d, e) & 0xff, order(rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(e, d)))), undefined, true); - const _263: boolean = rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e) === -1; - const order7 = rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_263, order7 !== undefined && order7 >= 0, rt.cmpDeque(Part.partialCmp$cmp_PartialOrd)(e, d) === 1, rt.eqSeq(Part.eq$cmp_PartialEq)(d, e)], (a05: boolean): rt.u8 => { + const d: rs.VecDeque = _239; + const e: rs.VecDeque = _238[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(order(rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e)), rs.cmpDeque(Part.cmp$cmp_Ord)(d, e) & 0xff, order(rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(e, d)))), undefined, true); + const _263: boolean = rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e) === -1; + const order7 = rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(d, e); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_263, order7 !== undefined && order7 >= 0, rs.cmpDeque(Part.partialCmp$cmp_PartialOrd)(e, d) === 1, rs.eqSeq(Part.eq$cmp_PartialEq)(d, e)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - const _280: rt.VecDeque | undefined = d; - const _283: rt.VecDeque | undefined = e; - const _277: rt.u8 = order(rt.cmpOption(rt.cmpDeque(Part.partialCmp$cmp_PartialOrd))(_280, _283)); - const _288: rt.Vec> = rt.vecFrom([e]); - const _292: rt.Vec> = rt.vecFrom([d]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_277, rt.cmpSlice(rt.cmpDeque(Part.cmp$cmp_Ord))(_288, _292) & 0xff)), undefined, true); - const _301: rt.VecDeque = _296(d); - const _306: rt.VecDeque = _296(e); - rt.byteVecPush(out, order(rt.cmpDeque(rt.f64PartialCmp)(_301, _306))); - const _312: [rt.Result, rt.u8>, rt.Result, rt.u8>] = [rt.Ok(d), rt.Err(e.n & 0xff)]; - const r: rt.Result, rt.u8> = _312[0]; - const s: rt.Result, rt.u8> = _312[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(order(result_partialCmp$08on5x6(r, s)), result_partialCmp$08on5x6(r, s) === -1 ? 1 : 0)), undefined, true); + const _280: rs.VecDeque | undefined = d; + const _283: rs.VecDeque | undefined = e; + const _277: rs.u8 = order(rs.cmpOption(rs.cmpDeque(Part.partialCmp$cmp_PartialOrd))(_280, _283)); + const _288: rs.Vec> = rs.vecFrom([e]); + const _292: rs.Vec> = rs.vecFrom([d]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_277, rs.cmpSlice(rs.cmpDeque(Part.cmp$cmp_Ord))(_288, _292) & 0xff)), undefined, true); + const _301: rs.VecDeque = _296(d); + const _306: rs.VecDeque = _296(e); + rs.byteVecPush(out, order(rs.cmpDeque(rs.f64PartialCmp)(_301, _306))); + const _312: [rs.Result, rs.u8>, rs.Result, rs.u8>] = [rs.Ok(d), rs.Err(e.n & 0xff)]; + const r: rs.Result, rs.u8> = _312[0]; + const s: rs.Result, rs.u8> = _312[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(order(result_partialCmp$1frpo9k(r, s)), result_partialCmp$1frpo9k(r, s) === -1 ? 1 : 0)), undefined, true); flush(out); } } - const _330: rt.Iter<[rt.Result, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [rt.Result, rt.usize] => { - let _510!: rt.Result; - const i7: rt.usize = _2[0]; - const b6: rt.u8 = _2[1]; + const _330: rs.Iter<[rs.Result, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): [rs.Result, rs.usize] => { + let _510!: rs.Result; + const i7: rs.usize = _2[0]; + const b6: rs.u8 = _2[1]; if (!((b6 & 1) === 0)) { - _510 = rt.Err((b6 << 24) >> 24 >> 4); + _510 = rs.Err((b6 << 24) >> 24 >> 4); } else { - _510 = rt.Ok(rt.u8Rem(rt.u8Div(b6, 2), 8)); + _510 = rs.Ok(rs.u8Rem(rs.u8Div(b6, 2), 8)); } - return [_510, i7] as [rt.Result, rt.usize]; + return [_510, i7] as [rs.Result, rs.usize]; }); - const results: rt.BTreeMap, rt.usize> = rt.btreeExtend(rt.btreeNew(result_cmp$06akmd5) as rt.BTreeMap, rt.usize>, _330, true, undefined, undefined, undefined, 8, true); - const iter4: rt.Iter<[rt.Result, rt.usize]> = rt.btreeIter(results); + const results: rs.BTreeMap, rs.usize> = rs.btreeExtend(rs.btreeNew(result_cmp$18cbpvu) as rs.BTreeMap, rs.usize>, _330, true, undefined, undefined, undefined, 8, true); + const iter4: rs.Iter<[rs.Result, rs.usize]> = rs.btreeIter(results); while (true) { - const _336: [rt.Result, rt.usize] | rt.Done = iter4.next(); - if (_336 === rt.DONE) { + const _336: [rs.Result, rs.usize] | rs.Done = iter4.next(); + if (_336 === rs.DONE) { break; } - const i3: rt.usize = _336[1]; + const i3: rs.usize = _336[1]; if (_336[0].ok) { - _342 = Uint8Array.of(0, (_336[0] as { ok: true; value: rt.u8 }).value, i3 & 0xff); + _342 = Uint8Array.of(0, (_336[0] as { ok: true; value: rs.u8 }).value, i3 & 0xff); } else { - _342 = Uint8Array.of(1, (_336[0] as { ok: false; error: rt.i8 }).error & 0xff, i3 & 0xff); + _342 = Uint8Array.of(1, (_336[0] as { ok: false; error: rs.i8 }).error & 0xff, i3 & 0xff); } - rt.iterExtendBytes(out, rt.iterSlice(_342), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_342), undefined, true); } - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeGet(results, rt.Ok(3)), (_24: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeGet(results, rs.Ok(3)), (_24: rs.usize): rs.u8 => { return _24 & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeGet(results, rt.Err(-1)), (_28: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeGet(results, rs.Err(-1)), (_28: rs.usize): rs.u8 => { return _28 & 0xff; })), undefined, true); - const deques: rt.BTreeMap, rt.Poll>, rt.usize> = rt.btreeNew(result_cmp$0nb553d) as rt.BTreeMap, rt.Poll>, rt.usize>; - const iter5: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunks(data, 3)); + const deques: rs.BTreeMap, rs.Poll>, rs.usize> = rs.btreeNew(result_cmp$0lhhufb) as rs.BTreeMap, rs.Poll>, rs.usize>; + const iter5: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceChunks(data, 3)); while (true) { - const _366: [rt.usize, rt.ByteSlice] | rt.Done = iter5.next(); - if (_366 === rt.DONE) { + const _366: [rs.usize, rs.ByteSlice] | rs.Done = iter5.next(); + if (_366 === rs.DONE) { break; } - const i4: rt.usize = _366[0]; - const d2: rt.VecDeque = deque$u8_orders_held_closure8(_366[1].data, _366[1].start, _366[1].length, rt.usizeRem(i4, 2) === 1, (_211: rt.usize, b7: rt.u8): rt.u8 => { - return rt.u8Rem(b7, 4); + const i4: rs.usize = _366[0]; + const d2: rs.VecDeque = deque$u8_orders_held_closure8(_366[1].data, _366[1].start, _366[1].length, rs.usizeRem(i4, 2) === 1, (_211: rs.usize, b7: rs.u8): rs.u8 => { + return rs.u8Rem(b7, 4); }); - rt.idx(_366[1], 0); + rs.idx(_366[1], 0); if (!((_366[1].data[_366[1].start] & 1) === 0)) { - rt.idx(_366[1], 0); - key = rt.Err(_5(_366[1].data[_366[1].start])); + rs.idx(_366[1], 0); + key = rs.Err(_5(_366[1].data[_366[1].start])); } else { - key = rt.Ok(d2); + key = rs.Ok(d2); } - rt.iterExtendBytes(out, rt.iterOption(option_map$05nbzug(rt.btreeInsert(deques, key, i4), (i10: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$14ju55r(rs.btreeInsert(deques, key, i4), (i10: rs.usize): rs.u8 => { return i10 & 0xff; })), undefined, true); } - rt.iterExtendBytes(out, rt.iterMap(rt.btreeValues(deques), (_213: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeValues(deques), (_213: rs.usize): rs.u8 => { return _213 & 0xff; }), undefined, true); - const _400: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 3)); - const _409: rt.Result, rt.Poll> = rt.Ok(deque$u8_orders_held_closure11(_400.data, _400.start, _400.length, true, (_216: rt.usize, b8: rt.u8): rt.u8 => { - return rt.u8Rem(b8, 4); + const _400: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 3)); + const _409: rs.Result, rs.Poll> = rs.Ok(deque$u8_orders_held_closure11(_400.data, _400.start, _400.length, true, (_216: rs.usize, b8: rs.u8): rs.u8 => { + return rs.u8Rem(b8, 4); })); - rt.byteVecPush(out, rt.btreeContains(deques, _409) ? 1 : 0); - const _411: rt.Iter> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_218: rt.u8): rt.Poll => { + rs.byteVecPush(out, rs.btreeContains(deques, _409) ? 1 : 0); + const _411: rs.Iter> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_218: rs.u8): rs.Poll => { return _5(_218); }); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(poll_cmp$175ka5q) as rt.BTreeSet>, _411, true, undefined, undefined, 2, true)), (p3: rt.Poll): rt.u8 => { - if (p3 !== rt.Pending) { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(poll_cmp$17et0iz) as rs.BTreeSet>, _411, true, undefined, undefined, 2, true)), (p3: rs.Poll): rs.u8 => { + if (p3 !== rs.Pending) { return p3; } return 9; }), undefined, true); - const sorted: rt.Vec> = rt.iterToVec(rt.iterRev(rt.btreeKeys(results)), undefined, 2, true); - rt.sliceSort(sorted.items, rt.cmpLt(result_partialCmp$0hea5es), 2, true); - rt.byteVecPush(out, rt.sliceIsSorted(sorted.items, rt.cmpLe(result_partialCmp$0hea5es)) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterOption(option_map$0isl2bb(rt.iterMax(rt.iterSlice(sorted.items), rt.cmpLt(result_partialCmp$0hea5es)), (r2: rt.Result): rt.u8 => { + const sorted: rs.Vec> = rs.iterToVec(rs.iterRev(rs.btreeKeys(results)), undefined, 2, true); + rs.sliceSort(sorted.items, rs.cmpLt(result_partialCmp$0wss1z6), 2, true); + rs.byteVecPush(out, rs.sliceIsSorted(sorted.items, rs.cmpLe(result_partialCmp$0wss1z6)) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterOption(option_map$0adj75b(rs.iterMax(rs.iterSlice(sorted.items), rs.cmpLt(result_partialCmp$0wss1z6)), (r2: rs.Result): rs.u8 => { return r2.ok ? 1 : 0; })), undefined, true); } -export function torn(tag: rt.usize, key: rt.u8, mode: rt.u8): Torn.Torn { - return { key: rt.u8Rem(key, 8), tag: tag & 0xff, mode }; +export function torn(tag: rs.usize, key: rs.u8, mode: rs.u8): Torn.Torn { + return { key: rs.u8Rem(key, 8), tag: tag & 0xff, mode }; } /** @@ -1110,150 +1110,150 @@ export function torn(tag: rt.usize, key: rt.u8, mode: rt.u8): Torn.Torn { * each, and the set operators, which build as `collect` does from what they yield, of * sets that `insert` built. Then zero-sized keys, which std's sort leaves as they are. */ -export function btrees(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const mode: rt.u8 = rt.u8Rem(kind, 5); - const keys: (a0: rt.ByteSlice) => rt.Vec = (bytes: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(bytes))), (_2: [rt.usize, rt.u8]): Torn.Torn => { +export function btrees(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const mode: rs.u8 = rs.u8Rem(kind, 5); + const keys: (a0: rs.ByteSlice) => rs.Vec = (bytes: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), (_2: [rs.usize, rs.u8]): Torn.Torn => { return torn(_2[0], _2[1], mode); }), undefined, 3, true); }; - const short: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 16)); - const iter: rt.Iter> = rt.iterSlice([keys(short), keys(data), rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(short))), (_24: [rt.usize, rt.u8]): Torn.Torn => { + const short: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 16)); + const iter: rs.Iter> = rs.iterSlice([keys(short), keys(data), rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(short))), (_24: [rs.usize, rs.u8]): Torn.Torn => { return torn(_24[0], 5, mode); }), undefined, 3, true)]); while (true) { - const _27: rt.Vec | rt.Done = iter.next(); - if (_27 === rt.DONE) { + const _27: rs.Vec | rs.Done = iter.next(); + if (_27 === rs.DONE) { break; } - const keys2: rt.Vec = _27; - const _32: rt.Iter = rt.iterSlice(keys2.items); - const set: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_32, undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a2: Torn.Torn, b3: Torn.Torn): boolean => { + const keys2: rs.Vec = _27; + const _32: rs.Iter = rs.iterSlice(keys2.items); + const set: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_32, undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a2: Torn.Torn, b3: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a2, b3); }); - rt.byteVecPush(out, rt.btreeLen(set) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set), (k: Torn.Torn): rt.u8 => { + rs.byteVecPush(out, rs.btreeLen(set) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set), (k: Torn.Torn): rs.u8 => { return k.tag; }), undefined, true); - const _45: rt.Iter<[Torn.Torn, rt.u8]> = rt.iterMap(rt.iterSlice(keys2.items), (k2: Torn.Torn): [Torn.Torn, rt.u8] => { - return [k2, k2.tag ^ 128] as [Torn.Torn, rt.u8]; + const _45: rs.Iter<[Torn.Torn, rs.u8]> = rs.iterMap(rs.iterSlice(keys2.items), (k2: Torn.Torn): [Torn.Torn, rs.u8] => { + return [k2, k2.tag ^ 128] as [Torn.Torn, rs.u8]; }); - const map: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_45, undefined, 4, true).items, 4, true, (a3: Torn.Torn, b4: Torn.Torn): boolean => { + const map: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_45, undefined, 4, true).items, 4, true, (a3: Torn.Torn, b4: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a3, b4); }); - rt.byteVecPush(out, rt.btreeLen(map) & 0xff); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(map), (_26: [Torn.Torn, rt.u8]): Uint8Array => { + rs.byteVecPush(out, rs.btreeLen(map) & 0xff); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(map), (_26: [Torn.Torn, rs.u8]): Uint8Array => { return Uint8Array.of(_26[0].tag, _26[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); const _57: Torn.Torn[] = keys2.items; if (_57.length >= 3) { const a: Torn.Torn = _57[0]; const b: Torn.Torn = _57[1]; const c: Torn.Torn = _57[2]; - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(rt.iterSlice([a, b, c]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a4: Torn.Torn, b5: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeCollectKeys(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice([a, b, c]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a4: Torn.Torn, b5: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a4, b5); - })), (k3: Torn.Torn): rt.u8 => { + })), (k3: Torn.Torn): rs.u8 => { return k3.tag; }), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeCollect(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(rt.iterSlice([[a, 1] as [Torn.Torn, rt.u8], [b, 2] as [Torn.Torn, rt.u8], [c, 3] as [Torn.Torn, rt.u8]]), undefined, 4, true).items, 4, true, (a5: Torn.Torn, b6: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(rs.btreeCollect(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(rs.iterSlice([[a, 1] as [Torn.Torn, rs.u8], [b, 2] as [Torn.Torn, rs.u8], [c, 3] as [Torn.Torn, rs.u8]]), undefined, 4, true).items, 4, true, (a5: Torn.Torn, b6: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a5, b6); - })), (_28: [Torn.Torn, rt.u8]): Uint8Array => { + })), (_28: [Torn.Torn, rs.u8]): Uint8Array => { return Uint8Array.of(_28[0].tag, _28[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(rt.iterSlice([a]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a6: Torn.Torn, b7: Torn.Torn): boolean => { + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeCollectKeys(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice([a]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a6: Torn.Torn, b7: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a6, b7); - })), (k4: Torn.Torn): rt.u8 => { + })), (k4: Torn.Torn): rs.u8 => { return k4.tag; }), undefined, true); } - rt.byteVecPush(out, rt.btreeLen(rt.btreeCollectKeys(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(rt.iterSlice([]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a7: Torn.Torn, b8: Torn.Torn): boolean => { + rs.byteVecPush(out, rs.btreeLen(rs.btreeCollectKeys(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice([]), undefined, 3, true).items, 3, true, Torn.lt$cmp_PartialOrd, (a7: Torn.Torn, b8: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a7, b8); })) & 0xff); - const _91: rt.Iter> = rt.iterMap(rt.sliceChunks(keys2.items, 2), (a0: Torn.Torn[]): rt.Vec => { - return rt.vecFrom(a0.slice()); + const _91: rs.Iter> = rs.iterMap(rs.sliceChunks(keys2.items, 2), (a0: Torn.Torn[]): rs.Vec => { + return rs.vecFrom(a0.slice()); }); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(rt.cmpSlice(Torn.cmp$cmp_Ord)) as rt.BTreeSet>, rt.iterToVec(_91, undefined, 12, true).items, 12, true, rt.cmpLt(rt.cmpSlice(Torn.partialCmp$cmp_PartialOrd)), rt.eqSlice((a8: Torn.Torn, b9: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeKeys(rs.btreeCollectKeys(rs.btreeNew(rs.cmpSlice(Torn.cmp$cmp_Ord)) as rs.BTreeSet>, rs.iterToVec(_91, undefined, 12, true).items, 12, true, rs.cmpLt(rs.cmpSlice(Torn.partialCmp$cmp_PartialOrd)), rs.eqSlice((a8: Torn.Torn, b9: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a8, b9); - }))), (c2: rt.Vec): rt.Iter => { - return rt.iterMap(rt.iterSlice(c2.items), (k5: Torn.Torn): rt.u8 => { + }))), (c2: rs.Vec): rs.Iter => { + return rs.iterMap(rs.iterSlice(c2.items), (k5: Torn.Torn): rs.u8 => { return k5.tag; }); }, undefined, true), "next"); flush(out); - const extended: rt.BTreeSet = rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet; - const _103: rt.Iter = rt.iterSlice(keys2.items); - rt.btreeExtendKeys(extended, _103); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(extended), (k6: Torn.Torn): rt.u8 => { + const extended: rs.BTreeSet = rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet; + const _103: rs.Iter = rs.iterSlice(keys2.items); + rs.btreeExtendKeys(extended, _103); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(extended), (k6: Torn.Torn): rs.u8 => { return k6.tag; }), undefined, true); - const entries: rt.BTreeMap = rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeMap; - const _114: rt.Iter<[Torn.Torn, rt.u8]> = rt.iterMap(rt.iterSlice(keys2.items), (k7: Torn.Torn): [Torn.Torn, rt.u8] => { - return [k7, k7.tag] as [Torn.Torn, rt.u8]; + const entries: rs.BTreeMap = rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeMap; + const _114: rs.Iter<[Torn.Torn, rs.u8]> = rs.iterMap(rs.iterSlice(keys2.items), (k7: Torn.Torn): [Torn.Torn, rs.u8] => { + return [k7, k7.tag] as [Torn.Torn, rs.u8]; }); - rt.btreeExtend(entries, _114); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(entries), (_29: [Torn.Torn, rt.u8]): Uint8Array => { + rs.btreeExtend(entries, _114); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(entries), (_29: [Torn.Torn, rs.u8]): Uint8Array => { return Uint8Array.of(_29[0].tag, _29[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const _124: [rt.BTreeSet, rt.BTreeSet] = [rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet]; - const left: rt.BTreeSet = _124[0]; - const right: rt.BTreeSet = _124[1]; - const _129: [Torn.Torn[], Torn.Torn[]] = rt.sliceSplitAt(keys2.items, rt.usizeDiv(keys2.items.length, 2)); - const _138: rt.Iter = rt.iterSlice(_129[0]); - rt.btreeExtendKeys(left, _138); - const _142: rt.Iter = rt.iterSlice(_129[1]); - rt.btreeExtendKeys(right, _142); - rt.localKeyWithBorrowMut(LOG, (a02: rt.ByteVec): undefined => { - rt.byteVecClear(a02); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const _124: [rs.BTreeSet, rs.BTreeSet] = [rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet]; + const left: rs.BTreeSet = _124[0]; + const right: rs.BTreeSet = _124[1]; + const _129: [Torn.Torn[], Torn.Torn[]] = rs.sliceSplitAt(keys2.items, rs.usizeDiv(keys2.items.length, 2)); + const _138: rs.Iter = rs.iterSlice(_129[0]); + rs.btreeExtendKeys(left, _138); + const _142: rs.Iter = rs.iterSlice(_129[1]); + rs.btreeExtendKeys(right, _142); + rs.localKeyWithBorrowMut(LOG, (a02: rs.ByteVec): undefined => { + rs.byteVecClear(a02); }); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeFromSorted(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeUnion(left, right), (a9: Torn.Torn, b10: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeFromSorted(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeUnion(left, right), (a9: Torn.Torn, b10: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a9, b10); - })), (k8: Torn.Torn): rt.u8 => { + })), (k8: Torn.Torn): rs.u8 => { return k8.tag; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeFromSorted(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeSymmetricDifference(left, right), (a10: Torn.Torn, b11: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeFromSorted(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeSymmetricDifference(left, right), (a10: Torn.Torn, b11: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a10, b11); - })), (k9: Torn.Torn): rt.u8 => { + })), (k9: Torn.Torn): rs.u8 => { return k9.tag; }), undefined, true); flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeFromSorted(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeIntersection(left, right), (a11: Torn.Torn, b12: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeFromSorted(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeIntersection(left, right), (a11: Torn.Torn, b12: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a11, b12); - })), (k10: Torn.Torn): rt.u8 => { + })), (k10: Torn.Torn): rs.u8 => { return k10.tag; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(rt.btreeFromSorted(rt.btreeNew(Torn.cmp$cmp_Ord) as rt.BTreeSet, rt.btreeDifference(left, right), (a12: Torn.Torn, b13: Torn.Torn): boolean => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(rs.btreeFromSorted(rs.btreeNew(Torn.cmp$cmp_Ord) as rs.BTreeSet, rs.btreeDifference(left, right), (a12: Torn.Torn, b13: Torn.Torn): boolean => { return !Torn.ne$cmp_PartialEq(a12, b13); - })), (k11: Torn.Torn): rt.u8 => { + })), (k11: Torn.Torn): rs.u8 => { return k11.tag; }), undefined, true); - rt.localKeyWithBorrowMut(LOG, (a03: rt.ByteVec): undefined => { - rt.byteVecClear(a03); + rs.localKeyWithBorrowMut(LOG, (a03: rs.ByteVec): undefined => { + rs.byteVecClear(a03); }); } - const apart: rt.Vec = rt.vecFromElem({}, short.length, undefined); - const _180: rt.Iter = rt.iterSlice(apart.items); - const set2: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_180, undefined, 0, true).items, 0, true, undefined, Apart.eq$cmp_PartialEq); - const _185: rt.Iter<[Apart.Apart, undefined]> = rt.iterMap(rt.iterSlice(apart.items), (_210: Apart.Apart): [Apart.Apart, undefined] => { + const apart: rs.Vec = rs.vecFromElem({}, short.length, undefined); + const _180: rs.Iter = rs.iterSlice(apart.items); + const set2: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Apart.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_180, undefined, 0, true).items, 0, true, undefined, Apart.eq$cmp_PartialEq); + const _185: rs.Iter<[Apart.Apart, undefined]> = rs.iterMap(rs.iterSlice(apart.items), (_210: Apart.Apart): [Apart.Apart, undefined] => { return [{}, undefined] as [Apart.Apart, undefined]; }); - const units: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_185, undefined, 0, true).items, 0, true, Apart.eq$cmp_PartialEq); - const _190: rt.Iter<[Apart.Apart, rt.u8]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(apart.items)), (_214: [rt.usize, Apart.Apart]): [Apart.Apart, rt.u8] => { - return [{}, _214[0] & 0xff] as [Apart.Apart, rt.u8]; + const units: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Apart.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_185, undefined, 0, true).items, 0, true, Apart.eq$cmp_PartialEq); + const _190: rs.Iter<[Apart.Apart, rs.u8]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(apart.items)), (_214: [rs.usize, Apart.Apart]): [Apart.Apart, rs.u8] => { + return [{}, _214[0] & 0xff] as [Apart.Apart, rs.u8]; }); - const map2: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Apart.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_190, undefined, 1, true).items, 1, true, Apart.eq$cmp_PartialEq); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(set2) & 0xff, rt.btreeLen(units) & 0xff, rt.btreeLen(map2) & 0xff)), undefined, true); - rt.iterExtendBytes(out, rt.btreeValues(map2), undefined, true); + const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Apart.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_190, undefined, 1, true).items, 1, true, Apart.eq$cmp_PartialEq); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(set2) & 0xff, rs.btreeLen(units) & 0xff, rs.btreeLen(map2) & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.btreeValues(map2), undefined, true); flush(out); - const _211: rt.Iter<[undefined | rt.None, Item.Item]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_217: [rt.usize, rt.u8]): [undefined | rt.None, Item.Item] => { - const i4: rt.usize = _217[0]; - const b14: rt.u8 = _217[1]; - return [thenSome$1d6toqn(rt.u8Rem(b14, 2) === 0, undefined), item(i4, b14)] as [undefined | rt.None, Item.Item]; + const _211: rs.Iter<[undefined | rs.None, Item.Item]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_217: [rs.usize, rs.u8]): [undefined | rs.None, Item.Item] => { + const i4: rs.usize = _217[0]; + const b14: rs.u8 = _217[1]; + return [thenSome$1qfl7tz(rs.u8Rem(b14, 2) === 0, undefined), item(i4, b14)] as [undefined | rs.None, Item.Item]; }); - const phantoms: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmpOption(rt.cmpNothing, rt.None)) as rt.BTreeMap, rt.iterToVec(_211, undefined, 3, true).items, 3, true, undefined, undefined, rt.drop); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeValues(phantoms), (x: Item.Item): rt.u8 => { + const phantoms: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(rs.cmpOption(rs.cmpNothing, rs.None)) as rs.BTreeMap, rs.iterToVec(_211, undefined, 3, true).items, 3, true, undefined, undefined, rs.drop); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeValues(phantoms), (x: Item.Item): rs.u8 => { return x.tag; }), undefined, true); - rt.btreeDrop(phantoms, undefined, rt.drop); + rs.btreeDrop(phantoms, undefined, rs.drop); flush(out); } diff --git a/ts/fixtures/lang/panics/expected/core/bool.ts b/ts/fixtures/lang/panics/expected/core/bool.ts index 026013bde..1f7100ce4 100644 --- a/ts/fixtures/lang/panics/expected/core/bool.ts +++ b/ts/fixtures/lang/panics/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$142atvy(self: boolean, f: () => rt.Location): rt.Location | undefined { +export function then$1yydrio(self: boolean, f: () => rs.Location): rs.Location | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/panics/expected/core/cmp.ts b/ts/fixtures/lang/panics/expected/core/cmp.ts index e94e93d02..a148b7c33 100644 --- a/ts/fixtures/lang/panics/expected/core/cmp.ts +++ b/ts/fixtures/lang/panics/expected/core/cmp.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function min$1rvi5e9(v1: rt.Location, v2: rt.Location): rt.Location { - return rt.ordMin(v1, v2, rt.cmpLt(rt.locationCmp)); +export function min$1k8d4j6(v1: rs.Location, v2: rs.Location): rs.Location { + return rs.ordMin(v1, v2, rs.cmpLt(rs.locationCmp)); } -export function max$02i836o(v1: rt.Location, v2: rt.Location): rt.Location { - return rt.ordMax(v1, v2, rt.cmpLt(rt.locationCmp)); +export function max$0rht4yb(v1: rs.Location, v2: rs.Location): rs.Location { + return rs.ordMax(v1, v2, rs.cmpLt(rs.locationCmp)); } //# sourceMappingURL=cmp.ts.map diff --git a/ts/fixtures/lang/panics/expected/core/option.ts b/ts/fixtures/lang/panics/expected/core/option.ts index a43f18933..56a6ef645 100644 --- a/ts/fixtures/lang/panics/expected/core/option.ts +++ b/ts/fixtures/lang/panics/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/panics/expected/core/result.ts b/ts/fixtures/lang/panics/expected/core/result.ts index 4955b47a9..548e69eb1 100644 --- a/ts/fixtures/lang/panics/expected/core/result.ts +++ b/ts/fixtures/lang/panics/expected/core/result.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Any from "../core/any.Any.ts"; -export function asRef$16amweg(self: rt.Result): rt.Result { +export function asRef$11fb4n1(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function mapOr$059pexg(self: rt.Result, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$171qvtg(self: rs.Result, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self.ok) { return f(self.value); } diff --git a/ts/fixtures/lang/panics/expected/core/task/poll.ts b/ts/fixtures/lang/panics/expected/core/task/poll.ts index d2153f840..93eaf4349 100644 --- a/ts/fixtures/lang/panics/expected/core/task/poll.ts +++ b/ts/fixtures/lang/panics/expected/core/task/poll.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function isReady$1ntq2i8(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$1olyx0w(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isPending$0vrdvv1(self: rt.Poll): boolean { - return !isReady$1ntq2i8(self); +export function isPending$189w6zf(self: rs.Poll): boolean { + return !isReady$1olyx0w(self); } //# sourceMappingURL=poll.ts.map diff --git a/ts/fixtures/lang/panics/expected/harness.ts b/ts/fixtures/lang/panics/expected/harness.ts index 091f6dc3f..adfa38b8e 100644 --- a/ts/fixtures/lang/panics/expected/harness.ts +++ b/ts/fixtures/lang/panics/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,38 +18,38 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/panics/expected/lib.ts b/ts/fixtures/lang/panics/expected/lib.ts index b2ed95759..303963f04 100644 --- a/ts/fixtures/lang/panics/expected/lib.ts +++ b/ts/fixtures/lang/panics/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Any from "./core/any.Any.ts"; import { via$located_Tracked_u8, at$located_Tracked_u8, called as located_called, read, panicked } from "./located.ts"; import * as Inherits from "./located.Inherits.ts"; @@ -12,9 +12,9 @@ export function copy$panics_Point(v: Point.Point): Point.Point { return { x: v.x, y: v.y }; } -export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rt.Result): void { +export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rs.Result): void { if (!_1.ok) { - rt.drop(_1.error); + rs.drop(_1.error); } } @@ -33,11 +33,11 @@ export class of$located_Inherits { this.v = v; } - at$Tracked(caller: rt.Location): rt.Location { + at$Tracked(caller: rs.Location): rs.Location { return Inherits.at$located_Tracked(this.v, caller); } - via$Tracked(): rt.Location { + via$Tracked(): rs.Location { return Inherits.via$located_Tracked(this.v); } } @@ -49,7 +49,7 @@ export class of$located_Own { this.v = v; } - at$Untracked(): rt.Location { + at$Untracked(): rs.Location { return Own.at$located_Untracked(this.v, { file: "fixtures/lang/panics/src/located.rs", line: 86, col: 5 }); } } @@ -63,17 +63,17 @@ export class of$ref_str { } export class of$u8 { - v: rt.u8; + v: rs.u8; - constructor(v: rt.u8) { + constructor(v: rs.u8) { this.v = v; } - at$Tracked(caller: rt.Location): rt.Location { + at$Tracked(caller: rs.Location): rs.Location { return at$located_Tracked_u8(this.v, caller); } - via$Tracked(): rt.Location { + via$Tracked(): rs.Location { return via$located_Tracked_u8(this.v); } } @@ -82,19 +82,19 @@ export class of$u8 { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["panics::wrapped", wrapped as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::called", panics_called as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::raised", raised as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::called", located_called as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::read", read as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::panicked", panicked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["panics::wrapped", wrapped as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } -export const NOTE: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rt.RefCell { - return new rt.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(""); } /** Take what the hooks wrote since the last call. */ export function note(): string { - return rt.localKeyWithBorrowMutPlace(NOTE, (a0: rt.Place): string => { + return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { const taken = a0.v; a0.v = ""; return taken; diff --git a/ts/fixtures/lang/panics/expected/located.Held$read.ts b/ts/fixtures/lang/panics/expected/located.Held$read.ts index 96cfe6953..cc96f2732 100644 --- a/ts/fixtures/lang/panics/expected/located.Held$read.ts +++ b/ts/fixtures/lang/panics/expected/located.Held$read.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$read_fmt_Debug(self: Held, f: rt.Formatter): rt.Result { +export function fmt$read_fmt_Debug(self: Held, f: rs.Formatter): rs.Result { const _3: string = "Held"; const _4: string = "at"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtLocationDebug(self.at, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtLocationDebug(self.at, f); const _7: string = "maybe"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.maybe, f, rt.fmtLocationDebug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$read_cmp_PartialEq(self: Held, other: Held): boolean { - if (!rt.locationEq(self.at, other.at)) { + if (!rs.locationEq(self.at, other.at)) { return false; } - return rt.eqOption(rt.locationEq)(self.maybe, other.maybe); + return rs.eqOption(rs.locationEq)(self.maybe, other.maybe); } export interface Held { - at: rt.Location; - maybe: rt.Location | undefined; + at: rs.Location; + maybe: rs.Location | undefined; } //# sourceMappingURL=located.Held$read.ts.map diff --git a/ts/fixtures/lang/panics/expected/located.Inherits.ts b/ts/fixtures/lang/panics/expected/located.Inherits.ts index 8628ba0e9..eced42e8e 100644 --- a/ts/fixtures/lang/panics/expected/located.Inherits.ts +++ b/ts/fixtures/lang/panics/expected/located.Inherits.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { here } from "./located.ts"; /** A default, untracked, of the tracked method. */ -export function via$located_Tracked(self: Inherits): rt.Location { +export function via$located_Tracked(self: Inherits): rs.Location { return at$located_Tracked(self, { file: "fixtures/lang/panics/src/located.rs", line: 58, col: 14 }); } @@ -12,7 +12,7 @@ export function via$located_Tracked(self: Inherits): rt.Location { export interface Inherits { } -export function at$located_Tracked(_self: Inherits, caller: rt.Location): rt.Location { +export function at$located_Tracked(_self: Inherits, caller: rs.Location): rs.Location { return here(caller); } diff --git a/ts/fixtures/lang/panics/expected/located.Own.ts b/ts/fixtures/lang/panics/expected/located.Own.ts index 6238ff25b..8acfd7e15 100644 --- a/ts/fixtures/lang/panics/expected/located.Own.ts +++ b/ts/fixtures/lang/panics/expected/located.Own.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Only the impl tracks: a call through a trait object passes the impl's own location. */ export interface Own { } -export function at$located_Untracked(_self: Own, caller: rt.Location): rt.Location { +export function at$located_Untracked(_self: Own, caller: rs.Location): rs.Location { return caller; } diff --git a/ts/fixtures/lang/panics/expected/located.Places.ts b/ts/fixtures/lang/panics/expected/located.Places.ts index b36e16e6a..b8cd2d91b 100644 --- a/ts/fixtures/lang/panics/expected/located.Places.ts +++ b/ts/fixtures/lang/panics/expected/located.Places.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Indexing that gives where it was indexed. */ export interface Places { } -export function index$ops_Index_u8(_self: Places, _2: rt.u8, caller: rt.Location): rt.Location { +export function index$ops_Index_u8(_self: Places, _2: rs.u8, caller: rs.Location): rs.Location { return caller; } diff --git a/ts/fixtures/lang/panics/expected/located.Tracked.ts b/ts/fixtures/lang/panics/expected/located.Tracked.ts index 0f7f027d0..ad34eeb54 100644 --- a/ts/fixtures/lang/panics/expected/located.Tracked.ts +++ b/ts/fixtures/lang/panics/expected/located.Tracked.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export type Tracked = - | { at$Tracked: (a0: rt.Location) => rt.Location; via$Tracked: () => rt.Location }; + | { at$Tracked: (a0: rs.Location) => rs.Location; via$Tracked: () => rs.Location }; //# sourceMappingURL=located.Tracked.ts.map diff --git a/ts/fixtures/lang/panics/expected/located.Untracked.ts b/ts/fixtures/lang/panics/expected/located.Untracked.ts index e50dbc556..89decdf8e 100644 --- a/ts/fixtures/lang/panics/expected/located.Untracked.ts +++ b/ts/fixtures/lang/panics/expected/located.Untracked.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export type Untracked = { at$Untracked: () => rt.Location }; +export type Untracked = { at$Untracked: () => rs.Location }; //# sourceMappingURL=located.Untracked.ts.map diff --git a/ts/fixtures/lang/panics/expected/located.ts b/ts/fixtures/lang/panics/expected/located.ts index a7efb913b..d870e4d8c 100644 --- a/ts/fixtures/lang/panics/expected/located.ts +++ b/ts/fixtures/lang/panics/expected/located.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$located_Inherits, of$located_Own, of$u8 } from "./lib.ts"; -import { then$142atvy } from "./core/bool.ts"; -import { min$1rvi5e9, max$02i836o } from "./core/cmp.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0 } from "./core/option.ts"; +import { then$1yydrio } from "./core/bool.ts"; +import { min$1k8d4j6, max$0rht4yb } from "./core/cmp.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi } from "./core/option.ts"; import * as Held$read from "./located.Held$read.ts"; import * as Inherits from "./located.Inherits.ts"; import * as Own from "./located.Own.ts"; @@ -12,26 +12,26 @@ import * as Places from "./located.Places.ts"; import type * as Tracked from "./located.Tracked.ts"; import type * as Untracked from "./located.Untracked.ts"; -export function here(caller: rt.Location): rt.Location { +export function here(caller: rs.Location): rs.Location { return caller; } /** A chain, which passes on its own caller's location. */ -export function outer(caller: rt.Location): rt.Location { +export function outer(caller: rs.Location): rs.Location { return here(caller); } -export function twice(caller: rt.Location): [rt.Location, rt.Location] { - return [outer(caller), caller] as [rt.Location, rt.Location]; +export function twice(caller: rs.Location): [rs.Location, rs.Location] { + return [outer(caller), caller] as [rs.Location, rs.Location]; } /** Not tracked: its own call of `here`. */ -export function plain(): rt.Location { +export function plain(): rs.Location { return here({ file: "fixtures/lang/panics/src/located.rs", line: 32, col: 5 }); } -export function picked(first: rt.u8, caller: rt.Location): rt.Location { - const _2: rt.u8 = rt.u8Rem(first, 3); +export function picked(first: rs.u8, caller: rs.Location): rs.Location { + const _2: rs.u8 = rs.u8Rem(first, 3); if (_2 === 0) { return here(caller); } @@ -42,57 +42,57 @@ export function picked(first: rt.u8, caller: rt.Location): rt.Location { } /** A closure is no `#[track_caller]` function, so it gives its own calls'. */ -export function inClosure(_caller: rt.Location): [rt.Location, rt.Location] { - const _1: () => rt.Location = (): rt.Location => { +export function inClosure(_caller: rs.Location): [rs.Location, rs.Location] { + const _1: () => rs.Location = (): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; }; - const _2: () => rt.Location = (): rt.Location => { + const _2: () => rs.Location = (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 48, col: 21 }); }; - return [_1(), _2()] as [rt.Location, rt.Location]; + return [_1(), _2()] as [rs.Location, rs.Location]; } /** A default, untracked, of the tracked method. */ -export function via$located_Tracked_u8(self: rt.u8): rt.Location { +export function via$located_Tracked_u8(self: rs.u8): rs.Location { return at$located_Tracked_u8(self, { file: "fixtures/lang/panics/src/located.rs", line: 58, col: 14 }); } -export function at$located_Tracked_u8(_self: rt.u8, caller: rt.Location): rt.Location { +export function at$located_Tracked_u8(_self: rs.u8, caller: rs.Location): rs.Location { return caller; } -export function generic$located_Inherits(t: Inherits.Inherits): rt.Location { +export function generic$located_Inherits(t: Inherits.Inherits): rs.Location { return Inherits.at$located_Tracked(t, { file: "fixtures/lang/panics/src/located.rs", line: 92, col: 7 }); } -export function generic$u8(t: rt.u8): rt.Location { +export function generic$u8(t: rs.u8): rs.Location { return at$located_Tracked_u8(t, { file: "fixtures/lang/panics/src/located.rs", line: 92, col: 7 }); } /** Each location's `Display`, a line each. */ -export function lines(out: rt.ByteVec, at: rt.Location[]): void { +export function lines(out: rs.ByteVec, at: rs.Location[]): void { for (const _5 of at) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(_5, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "\n"]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); } } /** Calls of `#[track_caller]` functions, and `Location::caller` itself. */ -export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _24: (a0: rt.u8) => rt.Location = (n: rt.u8): rt.Location => { - if (!(rt.u8Rem(n, 2) === 0)) { +export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _24: (a0: rs.u8) => rs.Location = (n: rs.u8): rs.Location => { + if (!(rs.u8Rem(n, 2) === 0)) { return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); } return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); }; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _7: rt.u8 = rt.u8Rem(kind, 6); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _7: rs.u8 = rs.u8Rem(kind, 6); if (_7 === 0) { - const _11: [rt.Location, rt.Location] = twice({ file: "fixtures/lang/panics/src/located.rs", line: 131, col: 26 }); + const _11: [rs.Location, rs.Location] = twice({ file: "fixtures/lang/panics/src/located.rs", line: 131, col: 26 }); lines(out, [{ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 19 }, here({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 39 }), outer({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 47 }), _11[0], _11[1], plain(), picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 134, col: 71 })]); } else if (_7 === 1) { - const _23: [rt.Location, rt.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); - lines(out, [_23[0], _23[1], _24(first), ((): rt.Location => { + const _23: [rs.Location, rs.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); + lines(out, [_23[0], _23[1], _24(first), ((): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 140, col: 53 }; })()]); } else if (_7 === 2) { @@ -101,26 +101,26 @@ export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const own: Untracked.Untracked = new of$located_Own({}); lines(out, [at$located_Tracked_u8(first, { file: "fixtures/lang/panics/src/located.rs", line: 149, col: 27 }), via$located_Tracked_u8(first), Inherits.at$located_Tracked({}, { file: "fixtures/lang/panics/src/located.rs", line: 151, col: 30 }), generic$u8(first), generic$located_Inherits({}), tracked.at$Tracked({ file: "fixtures/lang/panics/src/located.rs", line: 154, col: 29 }), tracked.via$Tracked(), inherits.at$Tracked({ file: "fixtures/lang/panics/src/located.rs", line: 156, col: 30 }), own.at$Untracked(), Own.at$located_Untracked({}, { file: "fixtures/lang/panics/src/located.rs", line: 158, col: 25 }), Places.index$ops_Index_u8({}, first, { file: "fixtures/lang/panics/src/located.rs", line: 159, col: 28 })]); } else if (_7 === 3) { - const g: () => rt.Location = (): rt.Location => { + const g: () => rs.Location = (): rs.Location => { return outer({ file: "fixtures/lang/panics/src/located.rs", line: 21, col: 1 }); }; - const h: (a0: rt.u8) => rt.Location = (a: rt.u8): rt.Location => { + const h: (a0: rs.u8) => rs.Location = (a: rs.u8): rs.Location => { return picked(a, { file: "fixtures/lang/panics/src/located.rs", line: 36, col: 1 }); }; - const fs: Array<() => rt.Location> = [(): rt.Location => { + const fs: Array<() => rs.Location> = [(): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 15, col: 1 }); }, plain]; - const own2: (a0: Own.Own) => rt.Location = (a2: Own.Own): rt.Location => { + const own2: (a0: Own.Own) => rs.Location = (a2: Own.Own): rs.Location => { return Own.at$located_Untracked(a2, { file: "fixtures/lang/panics/src/located.rs", line: 86, col: 5 }); }; - const _73: rt.Location = ((): rt.Location => { + const _73: rs.Location = ((): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 15, col: 1 }); })(); - const _74: rt.Location = g(); - const _75: rt.Location = h(first); - const _78: rt.usize = rt.u8Rem(first, 2) as rt.usize; + const _74: rs.Location = g(); + const _75: rs.Location = h(first); + const _78: rs.usize = rs.u8Rem(first, 2) as rs.usize; if (!(_78 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _78); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _78); } lines(out, [_73, _74, _75, fs[_78](), own2({})]); } else if (_7 === 4) { @@ -128,78 +128,78 @@ export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { lines(out, [here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 23 }), here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 34 }), here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 45 })]); const wide: string = "é😀　"; - const _105: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); - const _107: rt.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, wide), (f: rt.Formatter) => rt.fmtLocationDisplay(_105, f), (f: rt.Formatter) => rt.fmtLocationDisplay(_107, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); + const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); } } -export const THERE$called: rt.Location = { file: "fixtures/lang/panics/src/located.rs", line: 177, col: 34 }; +export const THERE$called: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 177, col: 34 }; /** What a `Location` says of itself, and how locations compare. */ -export function read(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const a: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 197, col: 13 }); - const b: rt.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); - const _9: rt.u8 = rt.u8Rem(kind, 4); +export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const a: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 197, col: 13 }); + const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); + const _9: rs.u8 = rs.u8Rem(kind, 4); if (_9 === 0) { let s: string = ""; const _18: string = a.file; - const _20: rt.u32 = a.line; - const _22: rt.u32 = a.col; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _18), (f: rt.Formatter) => rt.u32Display(_20, f), (f: rt.Formatter) => rt.u32Display(_22, f)]; - const written = rt.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); + const _20: rs.u32 = a.line; + const _22: rs.u32 = a.col; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; + const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); s = written.s; - rt.resultUnwrap(written.result, rt.fmtErrorDebug); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(a, f), (f: rt.Formatter) => rt.fmtLocationDebug(a, f), (f: rt.Formatter) => rt.fmtLocationDebug(b, f)]; - const written2 = rt.fmtWriteString(s, [rt.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rt.fmtSpec({ alternate: true }, args4[2]), "|", rt.fmtSpec({ debugHex: "x" }, args4[2])]); + rs.resultUnwrap(written.result, rs.fmtErrorDebug); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; + const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); s = written2.s; - rt.resultUnwrap(written2.result, rt.fmtErrorDebug); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + rs.resultUnwrap(written2.result, rs.fmtErrorDebug); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); } else if (_9 === 1) { - const copy: rt.Location = a; - const same: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); - const _49: rt.u8 = rt.locationEq(a, b) ? 1 : 0; - const _53: rt.u8 = rt.locationEq(a, copy) ? 1 : 0; - const _56: rt.u8 = !rt.locationEq(a, same) ? 1 : 0; - const _60: rt.u8 = rt.locationCmp(a, b) === -1 ? 1 : 0; - const order = rt.locationCmp(a, same); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_49, _53, _56, _60, order !== undefined && order >= 0 ? 1 : 0, rt.locationCmp(a, b) & 0xff, option_mapOr$1e4a1e0(rt.locationCmp(a, same), 9, (o: rt.Ordering): rt.u8 => { + const copy: rs.Location = a; + const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); + const _49: rs.u8 = rs.locationEq(a, b) ? 1 : 0; + const _53: rs.u8 = rs.locationEq(a, copy) ? 1 : 0; + const _56: rs.u8 = !rs.locationEq(a, same) ? 1 : 0; + const _60: rs.u8 = rs.locationCmp(a, b) === -1 ? 1 : 0; + const order = rs.locationCmp(a, same); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_49, _53, _56, _60, order !== undefined && order >= 0 ? 1 : 0, rs.locationCmp(a, b) & 0xff, option_mapOr$14runhi(rs.locationCmp(a, same), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; }))), undefined, true); - lines(out, [max$02i836o(a, b), min$1rvi5e9(a, b)]); + lines(out, [max$0rht4yb(a, b), min$1k8d4j6(a, b)]); } else if (_9 === 2) { - const _83: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 35 }); - const _84: rt.Location = outer({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 46 }); - const _85: rt.Location = picked(rt.u8WrappingAdd(first, 1), { file: "fixtures/lang/panics/src/located.rs", line: 221, col: 55 }); - const all: rt.Vec = rt.vecFrom([b, _83, a, _84, _85]); - rt.sliceSort(all.items, rt.cmpLt(rt.locationCmp), 4, true); - rt.vecDedupBy(all, rt.locationEq); + const _83: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 35 }); + const _84: rs.Location = outer({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 46 }); + const _85: rs.Location = picked(rs.u8WrappingAdd(first, 1), { file: "fixtures/lang/panics/src/located.rs", line: 221, col: 55 }); + const all: rs.Vec = rs.vecFrom([b, _83, a, _84, _85]); + rs.sliceSort(all.items, rs.cmpLt(rs.locationCmp), 4, true); + rs.vecDedupBy(all, rs.locationEq); lines(out, all.items); - const _96: rt.Iter = rt.iterSlice(all.items); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.locationCmp) as rt.BTreeSet, _96, true, undefined, undefined, 4, true); - const _101: rt.Iter = rt.iterMap(rt.iterSlice(all.items), (l: rt.Location): rt.Location => { + const _96: rs.Iter = rs.iterSlice(all.items); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.locationCmp) as rs.BTreeSet, _96, true, undefined, undefined, 4, true); + const _101: rs.Iter = rs.iterMap(rs.iterSlice(all.items), (l: rs.Location): rs.Location => { return l; }); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.locationHash, rt.locationEq)) as rt.HashSet, _101, undefined, undefined, 58720256); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(set) & 0xff, rt.hashLen(hashed) & 0xff, rt.hashContains(hashed, a) ? 1 : 0)), undefined, true); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.locationHash, rs.locationEq)) as rs.HashSet, _101, undefined, undefined, 58720256); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(set) & 0xff, rs.hashLen(hashed) & 0xff, rs.hashContains(hashed, a) ? 1 : 0)), undefined, true); } else { - const _117: rt.Location | undefined = then$142atvy(rt.u8Rem(first, 2) === 0, (): rt.Location => { + const _117: rs.Location | undefined = then$1yydrio(rs.u8Rem(first, 2) === 0, (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 238, col: 49 }); }); const held: Held$read.Held = { at: a, maybe: _117 }; - const _127: rt.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rt.Formatter) => rt.u8Display(_127, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args6[0], "|", args6[1]]))); + const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; + const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); } } /** Panics whose message carries where a `#[track_caller]` function was called. */ -export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - if (rt.u8Rem(kind, 2) === 0) { - check$panicked(rt.u8Rem(first, 3) !== 0, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 14 }); +export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + if (rs.u8Rem(kind, 2) === 0) { + check$panicked(rs.u8Rem(first, 3) !== 0, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 14 }); } else { const f: (a0: boolean) => undefined = ((a: boolean): void => { return check$panicked(a, { file: "fixtures/lang/panics/src/located.rs", line: 250, col: 5 }); @@ -207,19 +207,19 @@ export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _15: (a0: boolean) => undefined = ((a2: boolean): void => { return check$panicked(a2, { file: "fixtures/lang/panics/src/located.rs", line: 250, col: 5 }); }) as (a0: boolean) => undefined; - const _18: rt.usize = rt.u8Rem(first, 2) as rt.usize; + const _18: rs.usize = rs.u8Rem(first, 2) as rs.usize; if (!(_18 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _18); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _18); } - [_15, f][_18](rt.u8Rem(first, 3) !== 1); + [_15, f][_18](rs.u8Rem(first, 3) !== 1); } - rt.byteVecPush(out, first); + rs.byteVecPush(out, first); } -export function check$panicked(ok: boolean, caller: rt.Location): void { +export function check$panicked(ok: boolean, caller: rs.Location): void { if (!ok) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(caller, f)]; - rt.panicFmt(["failed at ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)]; + rs.panicFmt(["failed at ", args2[0]]); } } diff --git a/ts/fixtures/lang/panics/expected/panics.Countdown.ts b/ts/fixtures/lang/panics/expected/panics.Countdown.ts index 506b89705..0ca05e8fd 100644 --- a/ts/fixtures/lang/panics/expected/panics.Countdown.ts +++ b/ts/fixtures/lang/panics/expected/panics.Countdown.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A future to poll: ready after `n` polls, waking itself on each that is pending. */ export interface Countdown { - _0: rt.u8; + _0: rs.u8; } -export function poll$Future(self: Countdown, cx: rt.Context): rt.Poll { +export function poll$Future(self: Countdown, cx: rs.Context): rs.Poll { if (!(self._0 === 0)) { const _7: Countdown = self; - _7._0 = rt.u8Sub(_7._0, 1); + _7._0 = rs.u8Sub(_7._0, 1); cx.wakeByRef(); - return rt.Pending; + return rs.Pending; } return 7; } diff --git a/ts/fixtures/lang/panics/expected/panics.Logged.ts b/ts/fixtures/lang/panics/expected/panics.Logged.ts index a098971bd..f767bc323 100644 --- a/ts/fixtures/lang/panics/expected/panics.Logged.ts +++ b/ts/fixtures/lang/panics/expected/panics.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its byte as it drops. */ export class Logged { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -18,9 +18,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=panics.Logged.ts.map diff --git a/ts/fixtures/lang/panics/expected/panics.Point.ts b/ts/fixtures/lang/panics/expected/panics.Point.ts index affb31107..c5f7e0f38 100644 --- a/ts/fixtures/lang/panics/expected/panics.Point.ts +++ b/ts/fixtures/lang/panics/expected/panics.Point.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Point, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { const _3: string = "Point"; const _4: string = "x"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.x, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.x, f); const _7: string = "y"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.y, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.y, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function default$Default(): Point { @@ -17,8 +17,8 @@ export function default$Default(): Point { /** A point, which JS copies. */ export interface Point { - x: rt.u8; - y: rt.u8; + x: rs.u8; + y: rs.u8; } //# sourceMappingURL=panics.Point.ts.map diff --git a/ts/fixtures/lang/panics/expected/panics.ts b/ts/fixtures/lang/panics/expected/panics.ts index 229649be0..4cfc59f49 100644 --- a/ts/fixtures/lang/panics/expected/panics.ts +++ b/ts/fixtures/lang/panics/expected/panics.ts @@ -1,152 +1,152 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$panics_Point, drop$Result_u8_boxed_Box_dyn_Any_marker_Send, of$String, of$ref_str, of$u8 } from "./lib.ts"; import type * as Any from "./core/any.Any.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { asRef$16amweg, mapOr$059pexg as result_mapOr$059pexg } from "./core/result.ts"; -import { isPending$0vrdvv1 } from "./core/task/poll.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { asRef$11fb4n1, mapOr$171qvtg as result_mapOr$171qvtg } from "./core/result.ts"; +import { isPending$189w6zf } from "./core/task/poll.ts"; import { text } from "./harness.ts"; import * as Countdown from "./panics.Countdown.ts"; import * as Logged from "./panics.Logged.ts"; import * as Point from "./panics.Point.ts"; -export function seven(): rt.u8 { +export function seven(): rs.u8 { return 7; } /** What `f` returns, through `catch_unwind`. */ export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rt.Result = rt.Ok(f()); + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** What `f` returns, through `catch_unwind`. */ -export function caught$Vec_u8_panics_called_closure5(f: () => rt.ByteVec): rt.ByteVec { - const _2: rt.Result = rt.Ok(f()); +export function caught$Vec_u8_panics_called_closure5(f: () => rs.ByteVec): rs.ByteVec { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_panics_called_closure4(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_panics_called_closure4(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_panics_seven(_: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(seven()); +export function caught$u8_panics_seven(_: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(seven()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_ref_panics_called_closure7(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_ref_panics_called_closure7(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"]); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"]); } /** Write `to` over what `at` points at. */ -export function replace$panic_AssertUnwindSafe_Vec_u8(at: rt.ByteVec, to: rt.ByteVec): void { +export function replace$panic_AssertUnwindSafe_Vec_u8(at: rs.ByteVec, to: rs.ByteVec): void { Object.assign(at, to); } /** Write `to` over what `at` points at. */ -export function replace$panic_AssertUnwindSafe_sync_Arc_u8(at: rt.Place>, to: rt.Arc): void { +export function replace$panic_AssertUnwindSafe_sync_Arc_u8(at: rs.Place>, to: rs.Arc): void { at.v[Symbol.dispose](); at.v = to; } /** `AssertUnwindSafe` of values, read and written as what it holds. */ -export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: rt.ByteVec; +export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: rs.ByteVec; let _234: boolean = false; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _7: rt.u8 = rt.u8Rem(kind, 7); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _7: rs.u8 = rs.u8Rem(kind, 7); if (_7 === 6) { - let a: rt.Arc = new rt.Arc(first); - const shared: rt.Arc = rt.arcClone(a); - const _16: rt.Arc = new rt.Arc(9); - replace$panic_AssertUnwindSafe_sync_Arc_u8(rt.place(() => a, (value) => a = value), _16); - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - const before: rt.usize = v.length; - const _25: rt.ByteVec = rt.byteVecOf(first, 3); + let a: rs.Arc = new rs.Arc(first); + const shared: rs.Arc = rs.arcClone(a); + const _16: rs.Arc = new rs.Arc(9); + replace$panic_AssertUnwindSafe_sync_Arc_u8(rs.place(() => a, (value) => a = value), _16); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + const before: rs.usize = v.length; + const _25: rs.ByteVec = rs.byteVecOf(first, 3); replace$panic_AssertUnwindSafe_Vec_u8(v, _25); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(shared.value, a.value, shared.strong & 0xff, before & 0xff)), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(shared.value, a.value, shared.strong & 0xff, before & 0xff)), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); shared[Symbol.dispose](); a[Symbol.dispose](); } else if (_7 === 0) { - let w: rt.usize = data.length; - w = rt.usizeAdd(w, 1); - rt.byteVecPush(out, w & 0xff); - w = rt.usizeWrappingMul(w, 3); - rt.byteVecPush(out, w & 0xff); - w = rt.usizeAdd(w, first as rt.usize); - rt.byteVecPush(out, w & 0xff); + let w: rs.usize = data.length; + w = rs.usizeAdd(w, 1); + rs.byteVecPush(out, w & 0xff); + w = rs.usizeWrappingMul(w, 3); + rs.byteVecPush(out, w & 0xff); + w = rs.usizeAdd(w, first as rs.usize); + rs.byteVecPush(out, w & 0xff); } else if (_7 === 1) { - const v2: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteVecPush(v2, first); - rt.byteVecPush(v2, 9); - rt.byteVecRetain(v2, (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2) === 0; + const v2: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteVecPush(v2, first); + rs.byteVecPush(v2, 9); + rs.byteVecRetain(v2, (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2) === 0; }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); - rt.byteVecPush(out, v2.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v2)); + rs.byteVecPush(out, v2.length & 0xff); } else if (_7 === 2) { const p: Point.Point = { x: first, y: 2 }; - const _89: rt.u8 = rt.u8WrappingAdd(p.x, 1); + const _89: rs.u8 = rs.u8WrappingAdd(p.x, 1); p.x = _89; - const _95: rt.u8 = rt.u8WrappingMul(p.y, first); + const _95: rs.u8 = rs.u8WrappingMul(p.y, first); p.y = _95; const copy: Point.Point = copy$panics_Point(p); p.x = 0; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(copy.x, copy.y, p.x, p.y)), undefined, true); - let nested: rt.u8 = first; - nested = rt.u8WrappingAdd(nested, 5); - rt.byteVecPush(out, nested); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(copy.x, copy.y, p.x, p.y)), undefined, true); + let nested: rs.u8 = first; + nested = rs.u8WrappingAdd(nested, 5); + rs.byteVecPush(out, nested); } else if (_7 === 3) { - const _132: rt.u8 = first; - const _134: rt.u8 = first; + const _132: rs.u8 = first; + const _134: rs.u8 = first; const _136: string = text(data); - const _138: rt.i8 = -1; + const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; - const _144: [rt.u8, string] = [first, "a"]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.u8Debug(_132, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.u8Debug(_134, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtStr(_136, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.i8Debug(_138, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_144[0], f), (f: rt.Formatter) => rt.fmtStr(_144[1], f)], f)])]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rt.fmtSpec({ alternate: true }, args2[5])]))); + const _144: [rs.u8, string] = [first, "a"]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); } else if (_7 === 4) { - const d: rt.u8 = 0; + const d: rs.u8 = 0; const s2: string = ""; const p2: Point.Point = Point.default$Default(); - const v3: rt.ByteVec = new rt.ByteVec(); - const e: rt.u8 = first; - f = rt.byteSliceToByteVec(data); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(d, rt.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + const v3: rs.ByteVec = new rs.ByteVec(); + const e: rs.u8 = first; + f = rs.byteSliceToByteVec(data); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); let b: Logged.Logged = new Logged.Logged(2, log); const _198: Logged.Logged = new Logged.Logged(3, log); @@ -160,17 +160,17 @@ export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _206: Logged.Logged = new Logged.Logged(5, log); b[Symbol.dispose](); b = _206; - if (rt.u8Rem(first, 2) === 0) { + if (rs.u8Rem(first, 2) === 0) { _234 = false; c[Symbol.dispose](); } - const _216: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_216.value, b._0); - rt.refMutRelease(_216); + const _216: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_216.value, b._0); + rs.refMutRelease(_216); b[Symbol.dispose](); - const _226: rt.RefCell = rt.refCellBorrow(log); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_226.value))), undefined, true); - rt.refRelease(_226); + const _226: rs.RefCell = rs.refCellBorrow(log); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_226.value))), undefined, true); + rs.refRelease(_226); if (_234) { c[Symbol.dispose](); } @@ -179,186 +179,186 @@ export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** `AssertUnwindSafe` of functions called, and `catch_unwind` of each kind of function. */ -export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _8: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _10: rt.u8 = rt.u8Rem(kind, 7); +export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _8: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _10: rs.u8 = rs.u8Rem(kind, 7); if (_10 === 0) { - const n: rt.usize = ((): rt.usize => { + const n: rs.usize = ((): rs.usize => { return data.length; })(); - const s: rt.u8 = seven(); - let count: rt.u8 = first; + const s: rs.u8 = seven(); + let count: rs.u8 = first; ((): undefined => { - count = rt.u8WrappingAdd(count, 3); + count = rs.u8WrappingAdd(count, 3); })(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(n & 0xff, s, count)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(n & 0xff, s, count)), undefined, true); } else if (_10 === 1) { const owned: Logged.Logged = new Logged.Logged(1, _8); const kept: Logged.Logged = new Logged.Logged(2, _8); const captured3 = owned._0; const captured4 = first; - const r: rt.u8 = ((): rt.u8 => { - const _510: rt.RefCell = rt.refCellBorrowMut(_8); - rt.byteVecPush(_510.value, rt.u8Add(10, captured3)); - rt.refMutRelease(_510); + const r: rs.u8 = ((): rs.u8 => { + const _510: rs.RefCell = rs.refCellBorrowMut(_8); + rs.byteVecPush(_510.value, rs.u8Add(10, captured3)); + rs.refMutRelease(_510); return captured4; })(); - const _33: rt.RefCell = rt.refCellBorrowMut(_8); - rt.byteVecPush(_33.value, r); - rt.refMutRelease(_33); + const _33: rs.RefCell = rs.refCellBorrowMut(_8); + rs.byteVecPush(_33.value, r); + rs.refMutRelease(_33); const captured5 = kept; - const back: Logged.Logged = rt.closure((): Logged.Logged => { + const back: Logged.Logged = rs.closure((): Logged.Logged => { return captured5; }, (): void => { captured5[Symbol.dispose](); })(); - const _40: rt.RefCell = rt.refCellBorrowMut(_8); - rt.byteVecPush(_40.value, rt.u8Add(20, back._0)); - rt.refMutRelease(_40); + const _40: rs.RefCell = rs.refCellBorrowMut(_8); + rs.byteVecPush(_40.value, rs.u8Add(20, back._0)); + rs.refMutRelease(_40); back[Symbol.dispose](); - const _50: rt.RefCell = rt.refCellBorrow(_8); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_50.value))), undefined, true); - rt.refRelease(_50); + const _50: rs.RefCell = rs.refCellBorrow(_8); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_50.value))), undefined, true); + rs.refRelease(_50); owned[Symbol.dispose](); } else if (_10 === 2) { - rt.byteVecPush(out, caught$u8_panics_called_closure4((): rt.u8 => { + rs.byteVecPush(out, caught$u8_panics_called_closure4((): rs.u8 => { return data.length & 0xff; })); - rt.byteVecPush(out, caught$u8_panics_seven(seven)); - rt.byteVecPush(out, seven()); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rt.ByteVec => { - return rt.iterToByteVec(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), undefined, true); + rs.byteVecPush(out, caught$u8_panics_seven(seven)); + rs.byteVecPush(out, seven()); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { + return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(caught$String_panics_called_closure6((): string => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(first, f)]; - return rt.fmtFormat([args6[0]]); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; + return rs.fmtFormat([args6[0]]); }))); } else if (_10 === 3) { - rt.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rt.u8 => { - return rt.u8WrappingMul(first, 2); + rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { + return rs.u8WrappingMul(first, 2); })); - let sum: rt.u8 = 0; - rt.byteVecPush(out, ((): rt.u8 => { - const iterS: Uint8Array = rt.byteSliceView(data); + let sum: rs.u8 = 0; + rs.byteVecPush(out, ((): rs.u8 => { + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _59: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_59 === rt.DONE) { + const _59: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_59 === rs.DONE) { return sum; } - sum = rt.u8WrappingAdd(sum, _59); + sum = rs.u8WrappingAdd(sum, _59); } })()); - rt.byteVecPush(out, sum); + rs.byteVecPush(out, sum); } else if (_10 === 4) { const owned2: Logged.Logged = new Logged.Logged(1, _8); const captured = owned2._0; - const r3: rt.Result = rt.Ok(((): rt.u8 => { - const _56: rt.RefCell = rt.refCellBorrowMut(_8); - rt.byteVecPush(_56.value, rt.u8Add(10, captured)); - rt.refMutRelease(_56); + const r3: rs.Result = rs.Ok(((): rs.u8 => { + const _56: rs.RefCell = rs.refCellBorrowMut(_8); + rs.byteVecPush(_56.value, rs.u8Add(10, captured)); + rs.refMutRelease(_56); return captured; })()); - const _92: rt.RefCell = rt.refCellBorrowMut(_8); - const _93: rt.u8 = rt.u8Add(30, rt.resultUnwrap(r3, (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")))); - rt.byteVecPush(_92.value, _93); - rt.refMutRelease(_92); + const _92: rs.RefCell = rs.refCellBorrowMut(_8); + const _93: rs.u8 = rs.u8Add(30, rs.resultUnwrap(r3, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")))); + rs.byteVecPush(_92.value, _93); + rs.refMutRelease(_92); const captured2 = first; - const boxed: () => rt.u8 = (): rt.u8 => { - return rt.u8WrappingAdd(captured2, 1); + const boxed: () => rs.u8 = (): rs.u8 => { + return rs.u8WrappingAdd(captured2, 1); }; - const _102: rt.RefCell = rt.refCellBorrowMut(_8); - const _103: rt.u8 = caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(boxed); - rt.byteVecPush(_102.value, _103); - rt.refMutRelease(_102); - const _109: rt.RefCell = rt.refCellBorrow(_8); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_109.value))), undefined, true); - rt.refRelease(_109); + const _102: rs.RefCell = rs.refCellBorrowMut(_8); + const _103: rs.u8 = caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(boxed); + rs.byteVecPush(_102.value, _103); + rs.refMutRelease(_102); + const _109: rs.RefCell = rs.refCellBorrow(_8); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_109.value))), undefined, true); + rs.refRelease(_109); owned2[Symbol.dispose](); } else if (_10 === 5) { - const r4: rt.Result = rt.Ok(((): rt.u8 => { + const r4: rs.Result = rs.Ok(((): rs.u8 => { return data.length & 0xff; })()); const _117: boolean = r4.ok; - const _120: rt.u8 = result_mapOr$059pexg(asRef$16amweg(r4), 0, (n2: rt.u8): rt.u8 => { + const _120: rs.u8 = result_mapOr$171qvtg(asRef$11fb4n1(r4), 0, (n2: rs.u8): rs.u8 => { return n2; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r4, f, rt.u8Debug, (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any"))), (f: rt.Formatter) => rt.fmtBool(_117, f), (f: rt.Formatter) => rt.u8Display(_120, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); - rt.byteVecPush(out, ((): rt.u8 => { - if (!(rt.u8Rem(first, 3) === 0)) { + rs.byteVecPush(out, ((): rs.u8 => { + if (!(rs.u8Rem(first, 3) === 0)) { return first; } const part = owned3._0; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; - rt.panicFmt(["caught ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; + rs.panicFmt(["caught ", args4[0]]); })()); owned3[Symbol.dispose](); - const _147: rt.RefCell = rt.refCellBorrow(_8); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_147.value))), undefined, true); - rt.refRelease(_147); + const _147: rs.RefCell = rs.refCellBorrow(_8); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_147.value))), undefined, true); + rs.refRelease(_147); } } /** `AssertUnwindSafe` of futures, polled by hand and awaited. */ -export function awaited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _22!: rt.Poll; +export function awaited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _22!: rs.Poll; let _86: boolean = false; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const cx: rt.Context = rt.NOOP_WAKER; - const _11: rt.u8 = rt.u8Rem(kind, 3); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const cx: rs.Context = rs.NOOP_WAKER; + const _11: rs.u8 = rs.u8Rem(kind, 3); if (_11 === 0) { - const pinned: Countdown.Countdown = { _0: rt.u8Rem(first, 4) }; + const pinned: Countdown.Countdown = { _0: rs.u8Rem(first, 4) }; const f: Countdown.Countdown = pinned; - let polls: rt.u8 = 0; + let polls: rs.u8 = 0; while (true) { - polls = rt.u8Add(polls, 1); + polls = rs.u8Add(polls, 1); _22 = Countdown.poll$Future(f, cx); - if (_22 !== rt.Pending) { + if (_22 !== rs.Pending) { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_22, polls)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_22, polls)), undefined, true); } else if (_11 === 1) { - const pinned2: rt.Future = new awaitedFuture$closure0(rt.u8Rem(first, 3)); - const f2: rt.Future = pinned2; - let polls2: rt.u8 = 0; - while (isPending$0vrdvv1(f2.poll(cx))) { - polls2 = rt.u8Add(polls2, 1); + const pinned2: rs.Future = new awaitedFuture$closure0(rs.u8Rem(first, 3)); + const f2: rs.Future = pinned2; + let polls2: rs.u8 = 0; + while (isPending$189w6zf(f2.poll(cx))) { + polls2 = rs.u8Add(polls2, 1); } - rt.byteVecPush(out, polls2); - rt.drop(pinned2); + rs.byteVecPush(out, polls2); + rs.drop(pinned2); } else { const a: Logged.Logged = new Logged.Logged(1, log); const b: Logged.Logged = new Logged.Logged(2, log); - const _53: rt.Future = new awaitedFuture$closure1(a._0); + const _53: rs.Future = new awaitedFuture$closure1(a._0); _86 = true; - const unpolled: rt.Future = _53; - const pinned3: rt.Future = new awaitedFuture$closure2(b._0); - const done: rt.Future = pinned3; - while (done.poll(cx) === rt.Pending) { - const _67: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_67.value, 9); - rt.refMutRelease(_67); + const unpolled: rs.Future = _53; + const pinned3: rs.Future = new awaitedFuture$closure2(b._0); + const done: rs.Future = pinned3; + while (done.poll(cx) === rs.Pending) { + const _67: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_67.value, 9); + rs.refMutRelease(_67); } - if (rt.u8Rem(first, 2) === 0) { + if (rs.u8Rem(first, 2) === 0) { _86 = false; - rt.drop(unpolled); + rs.drop(unpolled); } - const _77: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_77.value, 0); - rt.refMutRelease(_77); - const _84: rt.RefCell = rt.refCellBorrow(log); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_84.value))), undefined, true); - rt.refRelease(_84); - rt.drop(pinned3); + const _77: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_77.value, 0); + rs.refMutRelease(_77); + const _84: rs.RefCell = rs.refCellBorrow(log); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_84.value))), undefined, true); + rs.refRelease(_84); + rs.drop(pinned3); if (_86) { - rt.drop(unpolled); + rs.drop(unpolled); } _86 = false; b[Symbol.dispose](); @@ -368,170 +368,170 @@ export function awaited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void export class awaitedFuture$closure0 { #state: number = 0; - #n: rt.u8; - #inner!: rt.u8; - #awaitee!: rt.Future; + #n: rs.u8; + #inner!: rs.u8; + #awaitee!: rs.Future; #awaitee$2!: Countdown.Countdown; - constructor(n: rt.u8) { + constructor(n: rs.u8) { this.#n = n; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { if (this.#state === 0) { this.#awaitee = new awaitedFuture$closure0_closure0(this.#n); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { break b0; } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { this.#inner = _7; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#awaitee$2 = { _0: 0 }; } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _18: rt.Poll = Countdown.poll$Future(this.#awaitee$2, _2); - if (_18 !== rt.Pending) { - const _0: rt.Poll = rt.u8Add(_18, this.#inner); + const _18: rs.Poll = Countdown.poll$Future(this.#awaitee$2, _2); + if (_18 !== rs.Pending) { + const _0: rs.Poll = rs.u8Add(_18, this.#inner); this.#state = 1; return _0; } this.#state = 4; - return rt.Pending; + return rs.Pending; } } export class awaitedFuture$closure0_closure0 { #state: number = 0; - #n: rt.u8; + #n: rs.u8; #awaitee!: Countdown.Countdown; - constructor(n: rt.u8) { + constructor(n: rs.u8) { this.#n = n; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = { _0: this.#n }; } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = Countdown.poll$Future(this.#awaitee, _2); - if (_6 !== rt.Pending) { - const _0: rt.Poll = rt.u8Add(_6, 1); + const _6: rs.Poll = Countdown.poll$Future(this.#awaitee, _2); + if (_6 !== rs.Pending) { + const _0: rs.Poll = rs.u8Add(_6, 1); this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class awaitedFuture$closure1 { #state: number = 0; - #a0: rt.u8; + #a0: rs.u8; - constructor(a0: rt.u8) { + constructor(a0: rs.u8) { this.#a0 = a0; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = this.#a0; + const _0: rs.Poll = this.#a0; this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class awaitedFuture$closure2 { #state: number = 0; - #b0: rt.u8; + #b0: rs.u8; #awaitee!: Countdown.Countdown; - constructor(b0: rt.u8) { + constructor(b0: rs.u8) { this.#b0 = b0; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = { _0: 1 }; } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - if (Countdown.poll$Future(this.#awaitee, _2) !== rt.Pending) { - const _0: rt.Poll = this.#b0; + if (Countdown.poll$Future(this.#awaitee, _2) !== rs.Pending) { + const _0: rs.Poll = this.#b0; this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** Panics with a payload, and `Debug` of a `dyn Any`. */ -export function raised(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _9: rt.u8 = rt.u8Rem(kind, 8); +export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _9: rs.u8 = rs.u8Rem(kind, 8); if (_9 === 0) { - rt.panic("a payload of text"); + rs.panic("a payload of text"); } else if (_9 === 1) { - rt.panic(text(data)); + rs.panic(text(data)); } else if (_9 === 2) { - rt.panic("Box"); + rs.panic("Box"); } else if (_9 === 3) { - const _19: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + const _19: rs.RefCell = new rs.RefCell(new rs.ByteVec()); new Logged.Logged(first, _19)._0; - rt.panic("Box"); + rs.panic("Box"); } else if (_9 === 4) { new of$u8(first); - rt.resumeUnwind(); + rs.resumeUnwind(); } else if (_9 === 5) { new of$ref_str("text"); - rt.resumeUnwind(); + rs.resumeUnwind(); } else if (_9 === 6) { const _held: Logged.Logged = new Logged.Logged(1, log); - if (!(rt.u8Rem(first, 2) === 0)) { - rt.byteVecPush(out, first); + if (!(rs.u8Rem(first, 2) === 0)) { + rs.byteVecPush(out, first); _held[Symbol.dispose](); } else { - rt.panic("Box"); + rs.panic("Box"); } } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); const synced: Any.Any = new of$String(""); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any"))])]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", rt.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); - rt.drop(synced); - rt.drop(boxed); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + rs.drop(synced); + rs.drop(boxed); } - const _67: rt.RefCell = rt.refCellBorrow(log); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_67.value))), undefined, true); - rt.refRelease(_67); + const _67: rs.RefCell = rs.refCellBorrow(log); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_67.value))), undefined, true); + rs.refRelease(_67); } //# sourceMappingURL=panics.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/bytes.TryGetError.ts b/ts/fixtures/lang/panics/hook/expected/bytes.TryGetError.ts index 4b6b5f3b8..f049245dc 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes.TryGetError.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes.TryGetError.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Error type for the `try_get_` methods of [`Buf`]. @@ -11,9 +11,9 @@ import * as rt from "./rt.ts"; */ export interface TryGetError { /** The number of bytes necessary to get the value */ - requested: rt.usize; + requested: rs.usize; /** The number of bytes available in the buffer */ - available: rt.usize; + available: rs.usize; } //# sourceMappingURL=bytes.TryGetError.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/bytes.ts b/ts/fixtures/lang/panics/hook/expected/bytes.ts index 0847c4f10..b34d1bcd2 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; export function panicAdvance(errorInfo: TryGetError.TryGetError): never { const arg = errorInfo.available; - const _8: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(arg, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = errorInfo.requested; - const args2: rt.Fmt[] = [_8, (f: rt.Formatter) => rt.usizeDisplay(arg2, f)]; - rt.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }); + const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }); } //# sourceMappingURL=bytes.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/bytes/buf/buf_impl.ts b/ts/fixtures/lang/panics/hook/expected/bytes/buf/buf_impl.ts index 9e4c12b30..da085b42d 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes/buf/buf_impl.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes/buf/buf_impl.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import { new_$bytes_Bytes as take_new_$bytes_Bytes } from "../../bytes/buf/take.ts"; import type * as Take from "../../bytes/buf/take.Take.ts"; @@ -27,7 +27,7 @@ import type * as Take from "../../bytes/buf/take.Take.ts"; * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_bytes_Bytes(self: rt.ByteSlice, limit: rt.usize): Take.Take { +export function take$bytes_Buf_bytes_Bytes(self: rs.ByteSlice, limit: rs.usize): Take.Take { return take_new_$bytes_Bytes(self, limit); } diff --git a/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.Take.ts b/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.Take.ts index e7ab7cc2c..df0c613a5 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.Take.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.Take.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import { panicAdvance } from "../../bytes.ts"; import type * as TryGetError from "../../bytes.TryGetError.ts"; -import { min$0wa4xqw } from "../../core/cmp.ts"; -import { unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "../../core/result.ts"; +import { min$00xoube } from "../../core/cmp.ts"; +import { unwrapOrElse$1fg63zn as result_unwrapOrElse$1fg63zn } from "../../core/result.ts"; /** * Copies bytes from `self` into `dst`. @@ -29,8 +29,8 @@ import { unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "../../core/ * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -67,18 +67,18 @@ export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_Bytes_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 16 }), rt.byteSliceRange(src, 0, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 44 }), { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 24 }); - dst = rt.byteSliceRange(dst, cnt, undefined, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1179, col: 27 }); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 16 }), rs.byteSliceRange(src, 0, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 44 }), { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1178, col: 24 }); + dst = rs.byteSliceRange(dst, cnt, undefined, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/buf_impl.rs", line: 1179, col: 27 }); advance$bytes_Buf_bytes_Bytes(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_mut(self) }); } /** @@ -111,7 +111,7 @@ export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, d * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_Bytes_mut(self: Take): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_mut(self: Take): rs.ByteSlice { return chunk$bytes_Buf_bytes_Bytes(self); } @@ -142,7 +142,7 @@ export function chunk$bytes_Buf_bytes_Bytes_mut(self: Take): rt.By * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): rs.usize { return remaining$bytes_Buf_bytes_Bytes(self); } @@ -154,9 +154,9 @@ export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): r */ export class Take { inner: T; - limit: rt.usize; + limit: rs.usize; - constructor(inner: T, limit: rt.usize) { + constructor(inner: T, limit: rs.usize) { this.inner = inner; this.limit = limit; } @@ -189,8 +189,8 @@ export class Take { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes(self: Take): rt.usize { - return min$0wa4xqw(self.inner.length, self.limit); +export function remaining$bytes_Buf_bytes_Bytes(self: Take): rs.usize { + return min$00xoube(self.inner.length, self.limit); } /** @@ -223,9 +223,9 @@ export function remaining$bytes_Buf_bytes_Bytes(self: Take): rt.us * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_Bytes(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = self.inner; - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit), { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 142, col: 15 }); +export function chunk$bytes_Buf_bytes_Bytes(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = self.inner; + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit), { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 142, col: 15 }); } /** @@ -260,12 +260,12 @@ export function chunk$bytes_Buf_bytes_Bytes(self: Take): rt.ByteSl * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit", { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 146, col: 9 }); + rs.panic("assertion failed: cnt <= self.limit", { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 146, col: 9 }); } else { - rt.bytesAdvance(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 148, col: 9 }); + rs.bytesAdvance(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 148, col: 9 }); } } @@ -290,12 +290,12 @@ export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rt. * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_Bytes(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_bytes_Bytes(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_bytes_Bytes_mut(self))) { - rt.panicFmt(["`len` greater than remaining"], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 152, col: 9 }); + rs.panicFmt(["`len` greater than remaining"], { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 152, col: 9 }); } else { - const r: rt.ByteSlice = rt.bytesSplitTo(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 155, col: 9 }); + const r: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len, { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/buf/take.rs", line: 155, col: 9 }); return r; } } diff --git a/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.ts b/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.ts index e27213498..a2dc4a195 100644 --- a/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.ts +++ b/ts/fixtures/lang/panics/hook/expected/bytes/buf/take.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import * as Take from "../../bytes/buf/take.Take.ts"; -export function new_$bytes_Bytes(inner: rt.ByteSlice, limit: rt.usize): Take.Take { +export function new_$bytes_Bytes(inner: rs.ByteSlice, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } diff --git a/ts/fixtures/lang/panics/hook/expected/core/bool.ts b/ts/fixtures/lang/panics/hook/expected/core/bool.ts index 026013bde..1f7100ce4 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/bool.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/bool.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$142atvy(self: boolean, f: () => rt.Location): rt.Location | undefined { +export function then$1yydrio(self: boolean, f: () => rs.Location): rs.Location | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/panics/hook/expected/core/cmp.ts b/ts/fixtures/lang/panics/hook/expected/core/cmp.ts index 1051aea71..977d5e966 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/cmp.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/cmp.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function min$1rvi5e9(v1: rt.Location, v2: rt.Location): rt.Location { - return rt.ordMin(v1, v2, rt.cmpLt(rt.locationCmp)); +export function min$1k8d4j6(v1: rs.Location, v2: rs.Location): rs.Location { + return rs.ordMin(v1, v2, rs.cmpLt(rs.locationCmp)); } -export function min$0wa4xqw(v1: rt.usize, v2: rt.usize): rt.usize { - return rt.min(v1, v2); +export function min$00xoube(v1: rs.usize, v2: rs.usize): rs.usize { + return rs.min(v1, v2); } -export function max$02i836o(v1: rt.Location, v2: rt.Location): rt.Location { - return rt.ordMax(v1, v2, rt.cmpLt(rt.locationCmp)); +export function max$0rht4yb(v1: rs.Location, v2: rs.Location): rs.Location { + return rs.ordMax(v1, v2, rs.cmpLt(rs.locationCmp)); } //# sourceMappingURL=cmp.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/core/option.ts b/ts/fixtures/lang/panics/hook/expected/core/option.ts index 8ab879d94..6f168ecb0 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/option.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/option.ts @@ -1,38 +1,38 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1vkt7xs(self: rt.char | undefined, _: (a0: rt.char) => rt.u32): rt.u32 | undefined { +export function map$18ftgyp(self: rs.char | undefined, _: (a0: rs.char) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } - return self as rt.u32; + return self as rs.u32; } -export function map$0a57co2(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u8): rt.u8 | undefined { +export function map$04ry0e1(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } diff --git a/ts/fixtures/lang/panics/hook/expected/core/result.ts b/ts/fixtures/lang/panics/hook/expected/core/result.ts index add7717f6..50bace238 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/result.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/result.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as TryGetError from "../bytes.TryGetError.ts"; import type * as Any from "../core/any.Any.ts"; -export function asRef$16amweg(self: rt.Result): rt.Result { +export function asRef$11fb4n1(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function map$170q7dc(self: rt.Result, rt.BorrowMutError>, _: (a0: rt.RefCell) => undefined): rt.Result { +export function map$1hfd4x1(self: rs.Result, rs.BorrowMutError>, _: (a0: rs.RefCell) => undefined): rs.Result { if (self.ok) { - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } -export function mapOr$059pexg(self: rt.Result, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$171qvtg(self: rs.Result, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self.ok) { return f(self.value); } return default_; } -export function unwrapOrDefault$0ry0sbh(self: rt.Result): void { +export function unwrapOrDefault$0t7trfe(self: rs.Result): void { if (!self.ok) { undefined; } } -export function unwrapOr$02rbyvl(self: rt.Result, default_: rt.u8): rt.u8 { +export function unwrapOr$1tftpn5(self: rs.Result, default_: rs.u8): rs.u8 { if (self.ok) { return self.value; } return default_; } -export function unwrapOrElse$0s2lrc9(self: rt.Result, op: (a0: TryGetError.TryGetError) => undefined): void { +export function unwrapOrElse$1fg63zn(self: rs.Result, op: (a0: TryGetError.TryGetError) => undefined): void { if (!self.ok) { op(self.error); } diff --git a/ts/fixtures/lang/panics/hook/expected/core/task/poll.ts b/ts/fixtures/lang/panics/hook/expected/core/task/poll.ts index d2153f840..93eaf4349 100644 --- a/ts/fixtures/lang/panics/hook/expected/core/task/poll.ts +++ b/ts/fixtures/lang/panics/hook/expected/core/task/poll.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function isReady$1ntq2i8(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$1olyx0w(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isPending$0vrdvv1(self: rt.Poll): boolean { - return !isReady$1ntq2i8(self); +export function isPending$189w6zf(self: rs.Poll): boolean { + return !isReady$1olyx0w(self); } //# sourceMappingURL=poll.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/harness.ts b/ts/fixtures/lang/panics/hook/expected/harness.ts index c758394ee..ba815243a 100644 --- a/ts/fixtures/lang/panics/hook/expected/harness.ts +++ b/ts/fixtures/lang/panics/hook/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length, { file: "fixtures/lang/panics/src/../../harness.rs", line: 14, col: 27 }), { file: "fixtures/lang/panics/src/../../harness.rs", line: 14, col: 26 })][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length, { file: "fixtures/lang/panics/src/../../harness.rs", line: 14, col: 27 }), { file: "fixtures/lang/panics/src/../../harness.rs", line: 14, col: 26 })][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,38 +18,38 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"], { file: "fixtures/lang/panics/src/../../harness.rs", line: 28, col: 14 }); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"], { file: "fixtures/lang/panics/src/../../harness.rs", line: 28, col: 14 }); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]], { file: "fixtures/lang/panics/src/../../harness.rs", line: 23, col: 9 }); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]], { file: "fixtures/lang/panics/src/../../harness.rs", line: 23, col: 9 }); } } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 25 }) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 25 }) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 16 }, true); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13, { file: "fixtures/lang/panics/src/../../harness.rs", line: 62, col: 16 }, true); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Lying.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Lying.ts index 357d2c8e1..6bb9f27e2 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Lying.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Lying.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An iterator whose size hint has no upper bound, though it says its length is exact. */ export interface Lying { - _0: rt.u8; + _0: rs.u8; } -export function next$iter_Iterator(_self: Lying): rt.u8 | rt.Done { - return rt.DONE; +export function next$iter_Iterator(_self: Lying): rs.u8 | rs.Done { + return rs.DONE; } -export function sizeHint$iter_Iterator(self: Lying): [rt.usize, rt.usize | undefined] { - return [self._0 as rt.usize, undefined] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator(self: Lying): [rs.usize, rs.usize | undefined] { + return [self._0 as rs.usize, undefined] as [rs.usize, rs.usize | undefined]; } //# sourceMappingURL=hooked.Lying.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts index d7e53ad4d..2bc072f77 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.Shown.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { NOTE } from "./lib.ts"; /** @@ -11,17 +11,17 @@ export interface Shown { again: boolean; } -export function fmt$fmt_Display(self: Shown, f: rt.Formatter): rt.Result { - const part = rt.panicking(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - const line: string = rt.fmtFormat(["shown ", args2[0], "\n"]); - rt.localKeyWithBorrowMutPlace(NOTE, (note: rt.Place): undefined => { +export function fmt$fmt_Display(self: Shown, f: rs.Formatter): rs.Result { + const part = rs.panicking(); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + const line: string = rs.fmtFormat(["shown ", args2[0], "\n"]); + rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); if (!self.again) { - return rt.fmtWriteStr(f, "shown"); + return rs.fmtWriteStr(f, "shown"); } - rt.panicFmt(["shown"], { file: "fixtures/lang/panics/src/hooked.rs", line: 139, col: 13 }); + rs.panicFmt(["shown"], { file: "fixtures/lang/panics/src/hooked.rs", line: 139, col: 13 }); } //# sourceMappingURL=hooked.Shown.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/hooked.ts b/ts/fixtures/lang/panics/hook/expected/hooked.ts index 15d672fb1..762d78d2c 100644 --- a/ts/fixtures/lang/panics/hook/expected/hooked.ts +++ b/ts/fixtures/lang/panics/hook/expected/hooked.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8, drop$bytes_buf_Take_bytes_Bytes, of$String, of$ref_str, of$u32, ofPlace$String, ofPlace$ref_str, ofPlace$u32, NOTE } from "./lib.ts"; import { take$bytes_Buf_bytes_Bytes as buf_impl_take$bytes_Buf_bytes_Bytes } from "./bytes/buf/buf_impl.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import type * as Any from "./core/any.Any.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1vkt7xs as option_map$1vkt7xs, map$0a57co2 as option_map$0a57co2, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, filter$0v80fk8 } from "./core/option.ts"; -import { map$170q7dc as result_map$170q7dc, unwrapOrDefault$0ry0sbh as result_unwrapOrDefault$0ry0sbh, unwrapOr$02rbyvl as result_unwrapOr$02rbyvl } from "./core/result.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$18ftgyp as option_map$18ftgyp, map$04ry0e1 as option_map$04ry0e1, mapOr$14runhi as option_mapOr$14runhi, filter$0hq86nl } from "./core/option.ts"; +import { map$1hfd4x1 as result_map$1hfd4x1, unwrapOrDefault$0t7trfe as result_unwrapOrDefault$0t7trfe, unwrapOr$1tftpn5 as result_unwrapOr$1tftpn5 } from "./core/result.ts"; import * as Lying from "./hooked.Lying.ts"; import * as Shown from "./hooked.Shown.ts"; -import { withBorrow$1s4hgxf } from "./std/thread/local.ts"; +import { withBorrow$097wfl1 } from "./std/thread/local.ts"; /** * Write what `info` says: its `Display`, its payload's type and text, and its location's * parts, and whether the thread is panicking. */ -export function record(info: rt.PanicHookInfo): void { +export function record(info: rs.PanicHookInfo): void { let kind!: string; - const payload: Any.Any = rt.hookPayload(info, of$ref_str, of$String); + const payload: Any.Any = rs.hookPayload(info, of$ref_str, of$String); if (!(payload instanceof of$ref_str || payload instanceof ofPlace$ref_str)) { if (!(payload instanceof of$String || payload instanceof ofPlace$String)) { - const _8: rt.u32 | undefined = payload instanceof of$u32 ? payload.v : payload instanceof ofPlace$u32 ? payload.v.v : undefined; + const _8: rs.u32 | undefined = payload instanceof of$u32 ? payload.v : payload instanceof ofPlace$u32 ? payload.v.v : undefined; if (_8 !== undefined) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_8, f)]; - kind = rt.fmtFormat(["u32 ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_8, f)]; + kind = rs.fmtFormat(["u32 ", args2[0]]); } else { kind = "other"; } @@ -33,16 +33,16 @@ export function record(info: rt.PanicHookInfo): void { } else { kind = "&str"; } - const at: rt.Location = rt.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 39, col: 30 }); - const _27: string = rt.strReplace(rt.fmtToString((f: rt.Formatter) => rt.fmtPanicHookInfoDisplay(info, f)), at.file, stdNamed(at.file)); + const at: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 39, col: 30 }); + const _27: string = rs.strReplace(rs.fmtToString((f: rs.Formatter) => rs.fmtPanicHookInfoDisplay(info, f)), at.file, stdNamed(at.file)); const _37: string | undefined = info.text; const _39: string = stdNamed(at.file); - const _42: rt.u32 = at.line; - const _44: rt.u32 = at.col; - const _46: boolean = rt.panicking(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _27), (f: rt.Formatter) => rt.fmtPad(f, kind), (f: rt.Formatter) => rt.fmtOption(_37, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtPad(f, _39), (f: rt.Formatter) => rt.u32Display(_42, f), (f: rt.Formatter) => rt.u32Display(_44, f), (f: rt.Formatter) => rt.fmtBool(_46, f)]; - const line: string = rt.fmtFormat([args4[0], "\n", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], "\n"]); - rt.localKeyWithBorrowMutPlace(NOTE, (note: rt.Place): undefined => { + const _42: rs.u32 = at.line; + const _44: rs.u32 = at.col; + const _46: boolean = rs.panicking(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _27), (f: rs.Formatter) => rs.fmtPad(f, kind), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtPad(f, _39), (f: rs.Formatter) => rs.u32Display(_42, f), (f: rs.Formatter) => rs.u32Display(_44, f), (f: rs.Formatter) => rs.fmtBool(_46, f)]; + const line: string = rs.fmtFormat([args4[0], "\n", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], "\n"]); + rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); } @@ -54,17 +54,17 @@ export function record(info: rt.PanicHookInfo): void { * did, as the translation always does. */ export function stdNamed(file: string): string { - const _2: [string, string] | undefined = rt.strSplitOnce(file, "/library/"); + const _2: [string, string] | undefined = rs.strSplitOnce(file, "/library/"); b1: { if (_2 !== undefined) { - if (!rt.strStartsWith(_2[0], "/rustc/")) { - if (!rt.strEndsWith(_2[0], "/lib/rustlib/src/rust")) { + if (!rs.strStartsWith(_2[0], "/rustc/")) { + if (!rs.strEndsWith(_2[0], "/lib/rustlib/src/rust")) { break b1; } } const part = _2[1]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - return rt.fmtFormat(["/library/", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + return rs.fmtFormat(["/library/", args2[0]]); } } return file; @@ -72,115 +72,115 @@ export function stdNamed(file: string): string { /** Replace the hook with one that records each panic, then passes it on. */ export function hook(): void { - const captured = rt.takeHook(); - rt.setHook(rt.closure((info: rt.PanicHookInfo): undefined => { + const captured = rs.takeHook(); + rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { record(info); captured(info); }, (): void => { - rt.drop(captured); + rs.drop(captured); }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); } -export function tracked(n: rt.u8, caller: rt.Location): rt.u8 { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tracked ", args2[0]], caller); +export function tracked(n: rs.u8, caller: rs.Location): rs.u8 { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tracked ", args2[0]], caller); } /** One panic, by `kind`, with a hook set. `data`'s first byte varies its operands. */ -export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); +export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); hook(); - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(n, n)); - const _10: rt.u8 = rt.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 84, col: 11 }); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(n, n)); + const _10: rs.u8 = rs.u8Rem(kind, 32, { file: "fixtures/lang/panics/src/hooked.rs", line: 84, col: 11 }); if (_10 === 0) { - rt.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 85, col: 14 }); + rs.panicFmt(["literal"], { file: "fixtures/lang/panics/src/hooked.rs", line: 85, col: 14 }); } else if (_10 === 1) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["formatted ", args2[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["formatted ", args2[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 86, col: 14 }); } else if (_10 === 2) { - rt.byteVecPush(out, v.data[rt.idx(v, rt.usizeAdd(n as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 24 })]); + rs.byteVecPush(out, v.data[rs.idx(v, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 25 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 87, col: 24 })]); } else if (_10 === 3) { - rt.byteVecPush(out, rt.u8Add(rt.max(n, 200), rt.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 88, col: 23 })); + rs.byteVecPush(out, rs.u8Add(rs.max(n, 200), rs.max(n, 100), { file: "fixtures/lang/panics/src/hooked.rs", line: 88, col: 23 })); } else if (_10 === 4) { - rt.byteVecPush(out, rt.optionUnwrap(filter$0v80fk8(n, (_24: rt.u8): boolean => { + rs.byteVecPush(out, rs.optionUnwrap(filter$0hq86nl(n, (_24: rs.u8): boolean => { return false; }), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 89, col: 49 })); } else if (_10 === 5) { - rt.byteVecPush(out, rt.resultUnwrap(rt.Err(n), rt.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 90, col: 40 })); + rs.byteVecPush(out, rs.resultUnwrap(rs.Err(n), rs.u8Debug, { file: "fixtures/lang/panics/src/hooked.rs", line: 90, col: 40 })); } else if (_10 === 6) { - rt.byteVecPush(out, rt.optionExpect(filter$0v80fk8(n, (_2: rt.u8): boolean => { + rs.byteVecPush(out, rs.optionExpect(filter$0hq86nl(n, (_2: rs.u8): boolean => { return false; }), "expected", undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 91, col: 49 })); } else if (_10 === 7) { - const part2 = rt.usizeAdd(rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 51 }) as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 39 }); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(rt.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 38 })); + const part2 = rs.usizeAdd(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 51 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 39 }); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(rs.byteVecSlice(v), part2, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 92, col: 38 })); } else if (_10 === 8) { - const cell: rt.RefCell = new rt.RefCell(n); - const _held: rt.RefCell = rt.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 30 }); - const _56: rt.RefCell = rt.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 28 }); - rt.byteVecPush(out, _56.value); - rt.refMutRelease(_56); - rt.refMutRelease(_held); + const cell: rs.RefCell = new rs.RefCell(n); + const _held: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 95, col: 30 }); + const _56: rs.RefCell = rs.refCellBorrowMut(cell, { file: "fixtures/lang/panics/src/hooked.rs", line: 96, col: 28 }); + rs.byteVecPush(out, _56.value); + rs.refMutRelease(_56); + rs.refMutRelease(_held); } else if (_10 === 9) { - rt.byteVecPush(out, rt.intPow(rt.max(n, 2), 9, 8, false, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/mod.rs", line: 590, col: 5 })); + rs.byteVecPush(out, rs.intPow(rs.max(n, 2), 9, 8, false, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/mod.rs", line: 590, col: 5 })); } else if (_10 === 10) { - rt.byteVecPush(out, rt.u8Div(100, rt.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 24 })); + rs.byteVecPush(out, rs.u8Div(100, rs.u8WrappingMul(n, 0), { file: "fixtures/lang/panics/src/hooked.rs", line: 99, col: 24 })); } else if (_10 === 11) { - rt.byteVecPush(out, rt.byteVecRemove(rt.byteVecFrom(rt.byteVecView(v)), rt.usizeAdd(n as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 34 })); + rs.byteVecPush(out, rs.byteVecRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 100, col: 34 })); } else if (_10 === 12) { - rt.byteVecPush(out, rt.byteVecSwapRemove(rt.byteVecFrom(rt.byteVecView(v)), rt.usizeAdd(n as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 46 }))); + rs.byteVecPush(out, rs.byteVecSwapRemove(rs.byteVecFrom(rs.byteVecView(v)), rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 101, col: 46 }))); } else if (_10 === 13) { - rt.byteSliceRotateLeft(rt.byteVecSlice(rt.byteVecFrom(rt.byteVecView(v))), rt.usizeAdd(n as rt.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 37 })); + rs.byteSliceRotateLeft(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 102, col: 37 })); } else if (_10 === 14) { - rt.byteVecPush(out, rt.hashIndex(rt.hashNew() as rt.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 48 })); + rs.byteVecPush(out, rs.hashIndex(rs.hashNew() as rs.HashMap, n, { file: "fixtures/lang/panics/src/hooked.rs", line: 103, col: 48 })); } else if (_10 === 15) { - rt.panicAny(new of$u32(n as rt.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); + rs.panicAny(new of$u32(n as rs.u32), { file: "fixtures/lang/panics/src/hooked.rs", line: 104, col: 15 }); } else if (_10 === 16) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panic(rt.fmtFormat(["any ", args4[0]]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panic(rs.fmtFormat(["any ", args4[0]]), { file: "fixtures/lang/panics/src/hooked.rs", line: 105, col: 15 }, true); } else if (_10 === 17) { - const _104: rt.u8 = rt.u8WrappingAdd(n, 1); + const _104: rs.u8 = rs.u8WrappingAdd(n, 1); if (!(n === _104)) { - rt.assertFailed("==", (f: rt.Formatter) => rt.u8Debug(n, f), (f: rt.Formatter) => rt.u8Debug(_104, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 15 }); + rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(_104, f), ["differ"], { file: "fixtures/lang/panics/src/hooked.rs", line: 106, col: 15 }); } } else if (_10 === 18) { - rt.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 107, col: 24 })); + rs.byteVecPush(out, tracked(n, { file: "fixtures/lang/panics/src/hooked.rs", line: 107, col: 24 })); } else if (_10 === 19) { - rt.byteVecPush(out, rt.dequeIndex(rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(v))), 1, true) as rt.VecDeque, rt.usizeAdd(n as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 49 })); + rs.byteVecPush(out, rs.dequeIndex(rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque, rs.usizeAdd(n as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 108, col: 49 })); } else if (_10 === 20) { - rt.byteVecPush(out, result_unwrapOr$02rbyvl(rt.u8TryFrom(rt.durationAsSecs(rt.durationAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, rt.durationFromSecs(rt.max(n, 1) as rt.u64)))), 0)); + rs.byteVecPush(out, result_unwrapOr$1tftpn5(rs.u8TryFrom(rs.durationAsSecs(rs.durationAdd({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)))), 0)); } else if (_10 === 21) { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.strSlice("éé", 0, rt.usizeAdd(rt.usizeMul(rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 56 }) as rt.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 41 }))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strSlice("éé", 0, rs.usizeAdd(rs.usizeMul(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 56 }) as rs.usize, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 44 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 110, col: 41 }))); } else if (_10 === 22) { - rt.iterExtendBytes(out, rt.iterStepBy(new rt.Range(0, n), rt.usizeMul(n as rt.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 111, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(new rs.Range(0, n), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 111, col: 41 }), undefined, 255, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 23) { - const _150: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(v)); - const _152: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(n as rt.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 112, col: 42 }), rt.usizeStep); - rt.iterExtendBytes(out, rt.byteVecDrain(_150, _152, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); + const _150: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _152: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(n as rs.usize, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 112, col: 42 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.byteVecDrain(_150, _152, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), "fold", true); } else if (_10 === 24) { - rt.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 15 }, false); + rs.panic("any", { file: "fixtures/lang/panics/src/hooked.rs", line: 113, col: 15 }, false); } else if (_10 === 25) { - rt.iterExtendBytes(out, rt.iterStepBy(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))), rt.usizeMul(n as rt.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); + rs.iterExtendBytes(out, rs.iterStepBy(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.usizeMul(n as rs.usize, 0, { file: "fixtures/lang/panics/src/hooked.rs", line: 114, col: 43 }), undefined, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/adapters/step_by.rs", line: 36, col: 9 }), undefined, true); } else if (_10 === 26) { - const _165: rt.u8 = rt.u8WrappingAdd(n, 1); + const _165: rs.u8 = rs.u8WrappingAdd(n, 1); if (!(n === _165)) { - rt.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 15 }); + rs.panic("assertion failed: n == n.wrapping_add(1)", { file: "fixtures/lang/panics/src/hooked.rs", line: 115, col: 15 }); } } else if (_10 === 27) { - rt.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 15 }); + rs.panic("explicit panic", { file: "fixtures/lang/panics/src/hooked.rs", line: 116, col: 15 }); } else if (_10 === 28) { - rt.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 15 }); + rs.panic("internal error: entered unreachable code", { file: "fixtures/lang/panics/src/hooked.rs", line: 117, col: 15 }); } else if (_10 === 29) { - rt.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); + rs.panic("not yet implemented", { file: "fixtures/lang/panics/src/hooked.rs", line: 118, col: 15 }); } else if (_10 === 30) { if (n === n) { - rt.assertFailed("!=", (f: rt.Formatter) => rt.u8Debug(n, f), (f: rt.Formatter) => rt.u8Debug(n, f), undefined as rt.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 119, col: 15 }); + rs.assertFailed("!=", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(n, f), undefined as rs.Arguments | undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 119, col: 15 }); } } else if (_10 === 31) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["not implemented: not ", args6[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["not implemented: not ", args6[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 120, col: 15 }); } else { - rt.byteVecPush(out, rt.hashLen(rt.hashWithCapacity(4294967295, 469762048) as rt.HashMap) & 0xff); + rs.byteVecPush(out, rs.hashLen(rs.hashWithCapacity(4294967295, 469762048) as rs.HashMap) & 0xff); } } @@ -188,288 +188,288 @@ export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * A hook that panics, or that sets the hook, or a message that panics as it formats, which * aborts as a panic in a hook does, without running the hook again. */ -export function aborted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const prev: (a0: rt.PanicHookInfo) => undefined = rt.takeHook(); +export function aborted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const prev: (a0: rs.PanicHookInfo) => undefined = rs.takeHook(); const captured = kind; const captured2 = prev; - rt.setHook(rt.closure((info: rt.PanicHookInfo): undefined => { + rs.setHook(rs.closure((info: rs.PanicHookInfo): undefined => { record(info); - const _4: rt.u8 = rt.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 152, col: 15 }); + const _4: rs.u8 = rs.u8Rem(captured, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 152, col: 15 }); if (_4 === 0) { - rt.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 153, col: 18 }); + rs.panicFmt(["again"], { file: "fixtures/lang/panics/src/hooked.rs", line: 153, col: 18 }); } else if (_4 === 1) { - rt.drop(rt.takeHook()); + rs.drop(rs.takeHook()); } else { captured2(info); } }, (): void => { - rt.drop(captured2); + rs.drop(captured2); }), { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); - rt.byteVecPush(out, n); - const _13: rt.u8 = rt.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 159, col: 11 }); + rs.byteVecPush(out, n); + const _13: rs.u8 = rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 159, col: 11 }); if (_13 === 3 || _13 === 4) { - const _19: Shown.Shown = { again: rt.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 56 }) === 4 }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => Shown.fmt$fmt_Display(_19, f)]; - rt.panicFmt(["first ", args2[0], " ", args2[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); + const _19: Shown.Shown = { again: rs.u8Rem(kind, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 56 }) === 4 }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Shown.fmt$fmt_Display(_19, f)]; + rs.panicFmt(["first ", args2[0], " ", args2[1]], { file: "fixtures/lang/panics/src/hooked.rs", line: 160, col: 18 }); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["first ", args4[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["first ", args4[0]], { file: "fixtures/lang/panics/src/hooked.rs", line: 161, col: 14 }); } } -export const EXCLUSIVE: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(EXCLUSIVE$init, false); +export const EXCLUSIVE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(EXCLUSIVE$init, false); -export function EXCLUSIVE$init(): rt.RefCell { - return new rt.RefCell(0); +export function EXCLUSIVE$init(): rs.RefCell { + return new rs.RefCell(0); } -export const SHARED: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(SHARED$init, false); +export const SHARED: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(SHARED$init, false); -export function SHARED$init(): rt.RefCell { - return new rt.RefCell(0); +export function SHARED$init(): rs.RefCell { + return new rs.RefCell(0); } /** * One panic of std's own code, by `kind`, with a hook set: each where the native build * names it, in the toolchain's source. */ -export function sited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const at: rt.usize = n as rt.usize; +export function sited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const at: rs.usize = n as rs.usize; hook(); - const v: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(n, n)); - const deque: rt.VecDeque = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecFrom(rt.byteVecView(v))), 1, true) as rt.VecDeque; - const _15: [rt.u16, rt.u8][] = [[n as rt.u16, n] as [rt.u16, rt.u8]]; - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice(_15), true, undefined, undefined, undefined, 4, true); - const _19: rt.u16[] = [n as rt.u16]; - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_19), true, undefined, undefined, 2, true); + const v: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(n, n)); + const deque: rs.VecDeque = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecFrom(rs.byteVecView(v))), 1, true) as rs.VecDeque; + const _15: [rs.u16, rs.u8][] = [[n as rs.u16, n] as [rs.u16, rs.u8]]; + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice(_15), true, undefined, undefined, undefined, 4, true); + const _19: rs.u16[] = [n as rs.u16]; + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_19), true, undefined, undefined, 2, true); b0: { - const k: rt.u8 = rt.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 183, col: 11 }); + const k: rs.u8 = rs.u8Rem(kind, 70, { file: "fixtures/lang/panics/src/hooked.rs", line: 183, col: 11 }); if (k === 0) { - rt.byteVecPush(out, rt.byteVecWithCapacity(rt.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 184, col: 48 })).length & 0xff); + rs.byteVecPush(out, rs.byteVecWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 184, col: 48 })).length & 0xff); } else if (k === 1) { - rt.byteSliceRotateRight(rt.byteVecSlice(rt.byteVecFrom(rt.byteVecView(v))), rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 185, col: 37 })); + rs.byteSliceRotateRight(rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(v))), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 185, col: 37 })); } else if (k === 2) { - rt.byteVecPush(out, rt.clamp(n, rt.max(n, 1), rt.u8Sub(rt.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 25 })); + rs.byteVecPush(out, rs.clamp(n, rs.max(n, 1), rs.u8Sub(rs.max(n, 1), 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 186, col: 25 })); } else if (k === 3) { - rt.byteVecPush(out, rt.u8FromF64(rt.f64Clamp(n as rt.f64, 1.0, 0.0))); + rs.byteVecPush(out, rs.u8FromF64(rs.f64Clamp(n as rs.f64, 1.0, 0.0))); } else if (k === 4) { - rt.byteVecPush(out, rt.u8FromF64(rt.f32Clamp(Math.fround(n), 1.0, 0.0) as rt.f64)); + rs.byteVecPush(out, rs.u8FromF64(rs.f32Clamp(Math.fround(n), 1.0, 0.0) as rs.f64)); } else if (k === 5) { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.charEncodeUtf8(rt.max(n, 128) as rt.char, rt.byteSliceFrom(Uint8Array.of(0))).v)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.charEncodeUtf8(rs.max(n, 128) as rs.char, rs.byteSliceFrom(Uint8Array.of(0))).v)); } else if (k === 6) { - const _62: rt.char = rt.optionUnwrap(rt.charFromU32(rt.u32Add(128512, n as rt.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 191, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 192, col: 18 }); - const _69: rt.u16[] = [0]; - rt.byteVecPush(out, rt.charEncodeUtf16(_62, _69).length & 0xff); + const _62: rs.char = rs.optionUnwrap(rs.charFromU32(rs.u32Add(128512, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 191, col: 28 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 192, col: 18 }); + const _69: rs.u16[] = [0]; + rs.byteVecPush(out, rs.charEncodeUtf16(_62, _69).length & 0xff); } else if (k === 7) { - const _73: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: n as rt.u16 } as rt.RangeBound, { tag: "Excluded", _0: n as rt.u16 } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRange(map, _73), (_239: [rt.u16, rt.u8]): rt.u8 => { + const _73: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: n as rs.u16 } as rs.RangeBound, { tag: "Excluded", _0: n as rs.u16 } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRange(map, _73), (_239: [rs.u16, rs.u8]): rs.u8 => { return _239[1]; }), "next"); } else if (k === 8) { - const _81: rt.Range = new rt.Range(rt.u16Add(n as rt.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 35 }), n as rt.u16); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRange(map, _81), (_237: [rt.u16, rt.u8]): rt.u8 => { + const _81: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 200, col: 35 }), n as rs.u16); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRange(map, _81), (_237: [rs.u16, rs.u8]): rs.u8 => { return _237[1]; }), "next"); } else if (k === 9) { - const _89: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: n as rt.u16 } as rt.RangeBound, { tag: "Excluded", _0: n as rt.u16 } as rt.RangeBound]; - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(set, _89), (_232: rt.u16): rt.u8 => { + const _89: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: n as rs.u16 } as rs.RangeBound, { tag: "Excluded", _0: n as rs.u16 } as rs.RangeBound]; + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set, _89), (_232: rs.u16): rs.u8 => { return _232 & 0xff; }), "next"); } else if (k === 10) { - const _97: rt.Range = new rt.Range(rt.u16Add(n as rt.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 205, col: 36 }), n as rt.u16); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeRangeKeys(set, _97), (_230: rt.u16): rt.u8 => { + const _97: rs.Range = new rs.Range(rs.u16Add(n as rs.u16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 205, col: 36 }), n as rs.u16); + rs.iterExtendBytes(out, rs.iterMap(rs.btreeRangeKeys(set, _97), (_230: rs.u16): rs.u8 => { return _230 & 0xff; }), "next"); } else if (k === 11) { - rt.dequeInsert(rt.dequeClone(deque), rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 206, col: 36 }), n); + rs.dequeInsert(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 206, col: 36 }), n); } else if (k === 12) { - rt.dequeSwap(rt.dequeClone(deque), rt.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 34 }), 0); + rs.dequeSwap(rs.dequeClone(deque), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 207, col: 34 }), 0); } else if (k === 13) { - rt.dequeSwap(rt.dequeClone(deque), 0, rt.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 37 })); + rs.dequeSwap(rs.dequeClone(deque), 0, rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 208, col: 37 })); } else if (k === 14) { - rt.dequeRotate(rt.dequeClone(deque), rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 41 })); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 209, col: 41 })); } else if (k === 15) { - rt.dequeRotate(rt.dequeClone(deque), rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 210, col: 42 }), true); + rs.dequeRotate(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 210, col: 42 }), true); } else if (k === 16) { - rt.iterExtendBytes(out, rt.dequeIntoIter(rt.dequeSplitOff(rt.dequeClone(deque), rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 211, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(rs.dequeSplitOff(rs.dequeClone(deque), rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 211, col: 50 }))), undefined, true); } else if (k === 17) { const _136: Uint8Array = Uint8Array.of(n); - rt.iterExtendBytes(out, rt.listIter(rt.listSplitOff(rt.listExtend(rt.listNew() as rt.LinkedList, rt.iterSlice(_136)), rt.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 212, col: 58 }))), undefined, true); + rs.iterExtendBytes(out, rs.listIter(rs.listSplitOff(rs.listExtend(rs.listNew() as rs.LinkedList, rs.iterSlice(_136)), rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 212, col: 58 }))), undefined, true); } else if (k === 18) { - const mutex: rt.Mutex = new rt.Mutex(n); - const _held: rt.Result, rt.Mutex> = rt.Ok(rt.mutexLock(mutex)); - const _146: rt.Mutex = rt.resultUnwrap(rt.Ok(rt.mutexLock(mutex)), rt.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 216, col: 36 }); - rt.byteVecPush(out, _146.value); - rt.mutexUnlock(_146); + const mutex: rs.Mutex = new rs.Mutex(n); + const _held: rs.Result, rs.Mutex> = rs.Ok(rs.mutexLock(mutex)); + const _146: rs.Mutex = rs.resultUnwrap(rs.Ok(rs.mutexLock(mutex)), rs.fmtPoisonErrorDebug, { file: "fixtures/lang/panics/src/hooked.rs", line: 216, col: 36 }); + rs.byteVecPush(out, _146.value); + rs.mutexUnlock(_146); drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_held); } else if (k === 19) { - const cell: rt.OnceCell = new rt.OnceCell(undefined); - rt.byteVecPush(out, rt.onceGetOrInit(cell, (): rt.u8 => { - return rt.onceGetOrInit(cell, (): rt.u8 => { + const cell: rs.OnceCell = new rs.OnceCell(undefined); + rs.byteVecPush(out, rs.onceGetOrInit(cell, (): rs.u8 => { + return rs.onceGetOrInit(cell, (): rs.u8 => { return n; }); })); } else if (k === 20) { - const lock: rt.OnceLock = new rt.OnceLock(undefined); - rt.byteVecPush(out, rt.onceGetOrInit(lock, (): rt.u8 => { - return rt.onceGetOrInit(lock, (): rt.u8 => { + const lock: rs.OnceLock = new rs.OnceLock(undefined); + rs.byteVecPush(out, rs.onceGetOrInit(lock, (): rs.u8 => { + return rs.onceGetOrInit(lock, (): rs.u8 => { return n; }); })); } else { if (k === 21) { - const ready: rt.Ready = new rt.Ready(n); - const cx: rt.Context = rt.NOOP_WAKER; - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 2; + const ready: rs.Ready = new rs.Ready(n); + const cx: rs.Context = rs.NOOP_WAKER; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 2; while (true) { if (!(iterStart++ < iterEnd)) { break b0; } - const _174: rt.Poll = ready.poll(cx); - if (_174 !== rt.Pending) { - rt.byteVecPush(out, _174); + const _174: rs.Poll = ready.poll(cx); + if (_174 !== rs.Pending) { + rs.byteVecPush(out, _174); } } } if (k === 22) { - const ready2: rt.Ready = new rt.Ready(n); - const _184: rt.Poll = ready2.poll(rt.NOOP_WAKER); - if (_184 !== rt.Pending) { - rt.byteVecPush(out, _184); + const ready2: rs.Ready = new rs.Ready(n); + const _184: rs.Poll = ready2.poll(rs.NOOP_WAKER); + if (_184 !== rs.Pending) { + rs.byteVecPush(out, _184); } - rt.byteVecPush(out, ready2.intoInner()); + rs.byteVecPush(out, ready2.intoInner()); } else if (k === 23) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u32Add(1000000000, n as rt.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 243, col: 48 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationNew({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u32Add(1000000000, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 243, col: 48 }))) & 0xff); } else if (k === 24) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationFromMins(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, n as rt.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 244, col: 44 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromMins(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 244, col: 44 }))) & 0xff); } else if (k === 25) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationFromHours(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, n as rt.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 245, col: 45 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromHours(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, n as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 245, col: 45 }))) & 0xff); } else if (k === 26) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationSub({ secs: 0, nanos: 0 }, rt.durationFromSecs(rt.u64Add(n as rt.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 246, col: 62 })))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationSub({ secs: 0, nanos: 0 }, rs.durationFromSecs(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 246, col: 62 })))) & 0xff); } else if (k === 27) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, rt.u32Add(n as rt.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 247, col: 41 }))) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMul({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.u32Add(n as rs.u32, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 247, col: 41 }))) & 0xff); } else if (k === 28) { - const _231: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(v)); - const _233: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 248, col: 44 }), rt.usizeStep); - rt.byteVecExtendFromWithin(_231, _233, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3614, col: 21 }); + const _231: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _233: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 248, col: 44 }), rs.usizeStep); + rs.byteVecExtendFromWithin(_231, _233, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3614, col: 21 }); } else if (k === 29) { - const _238: rt.VecDeque = rt.dequeClone(deque); - const _240: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 249, col: 46 }), rt.usizeStep); - rt.iterExtendBytes(out, rt.dequeDrain(_238, _240, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1998, col: 36 }), "next"); + const _238: rs.VecDeque = rs.dequeClone(deque); + const _240: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 249, col: 46 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.dequeDrain(_238, _240, undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1998, col: 36 }), "next"); } else if (k === 30) { - const _245: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 250, col: 38 }), rt.usizeStep); - rt.iterExtendBytes(out, rt.dequeRange(deque, _245, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), undefined, true); + const _245: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 250, col: 38 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.dequeRange(deque, _245, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), undefined, true); } else if (k === 31) { - const _251: rt.VecDeque = rt.dequeClone(deque); - const _253: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 251, col: 50 }), rt.usizeStep); - rt.iterExtendBytes(out, rt.iterMap(rt.dequeRangeMut(_251, _253, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), (v5: rt.Place): rt.u8 => { + const _251: rs.VecDeque = rs.dequeClone(deque); + const _253: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 251, col: 50 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.iterMap(rs.dequeRangeMut(_251, _253, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1845, col: 36 }), (v5: rs.Place): rs.u8 => { return v5.v; }), undefined, true); } else if (k === 32) { - const cell2: rt.RefCell = new rt.RefCell(rt.byteVecFrom(Uint8Array.of(n))); - const _held2: rt.RefCell = rt.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 254, col: 30 }); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.refCellReplace(cell2, new rt.ByteVec(), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1434, col: 14 })), undefined, true); - rt.refRelease(_held2); + const cell2: rs.RefCell = new rs.RefCell(rs.byteVecFrom(Uint8Array.of(n))); + const _held2: rs.RefCell = rs.refCellBorrow(cell2, { file: "fixtures/lang/panics/src/hooked.rs", line: 254, col: 30 }); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.refCellReplace(cell2, new rs.ByteVec(), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1434, col: 14 })), undefined, true); + rs.refRelease(_held2); } else if (k === 33) { - ((cell4: rt.RefCell): undefined => { - rt.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 54 }); + ((cell4: rs.RefCell): undefined => { + rs.refCellBorrow(cell4, { file: "fixtures/lang/panics/src/hooked.rs", line: 258, col: 54 }); })(SHARED.get()); - rt.localKeyWithBorrowMutPlace(SHARED, (v4: rt.Place): undefined => { + rs.localKeyWithBorrowMutPlace(SHARED, (v4: rs.Place): undefined => { v4.v = n; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); } else if (k === 34) { - ((cell3: rt.RefCell): undefined => { - result_unwrapOrDefault$0ry0sbh(result_map$170q7dc(rt.refCellTryBorrowMut(cell3), (_a02: rt.RefCell): undefined => { + ((cell3: rs.RefCell): undefined => { + result_unwrapOrDefault$0t7trfe(result_map$1hfd4x1(rs.refCellTryBorrowMut(cell3), (_a02: rs.RefCell): undefined => { undefined; })); })(EXCLUSIVE.get()); - withBorrow$1s4hgxf(EXCLUSIVE, (_210: rt.u8): undefined => { - rt.byteVecPush(out, _210); + withBorrow$097wfl1(EXCLUSIVE, (_210: rs.u8): undefined => { + rs.byteVecPush(out, _210); }); } else if (k === 35) { - const _277: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(v)); - const _279: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 43 }), rt.usizeStep); + const _277: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _279: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 265, col: 43 }), rs.usizeStep); const _282: Uint8Array = Uint8Array.of(n); - rt.iterExtendBytes(out, rt.spliceFrom(rt.byteVecSplice(_277, _279, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), rt.iterSlice(_282), true), "next"); + rs.iterExtendBytes(out, rs.spliceFrom(rs.byteVecSplice(_277, _279, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3007, col: 36 }), rs.iterSlice(_282), true), "next"); } else if (k === 36) { - rt.iterExtendBytes(out, rt.iterOption(option_map$0a57co2(option_map$1vkt7xs(rt.charFromDigit(n as rt.u32, rt.u32Add(37, n as rt.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rt.char): rt.u32 => { - return a0 as rt.u32; - }), (c2: rt.u32): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(option_map$18ftgyp(rs.charFromDigit(n as rs.u32, rs.u32Add(37, n as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 267, col: 44 }), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/convert.rs", line: 332, col: 9 }), (a0: rs.char): rs.u32 => { + return a0 as rs.u32; + }), (c2: rs.u32): rs.u8 => { return c2 & 0xff; })), undefined, true); } else if (k === 37) { - const _294: rt.usize = rt.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 59 }); + const _294: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 59 }); if (!(_294 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 21 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _294, { file: "fixtures/lang/panics/src/hooked.rs", line: 271, col: 21 }, true); } - rt.fence([0, 4][_294], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); + rs.fence([0, 4][_294], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4822, col: 24 }); } else if (k === 38) { - const _301: rt.usize = rt.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 68 }); + const _301: rs.usize = rs.usizeDiv(at, 256, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 68 }); if (!(_301 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 30 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _301, { file: "fixtures/lang/panics/src/hooked.rs", line: 272, col: 30 }, true); } - rt.fence([0, 4][_301], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); + rs.fence([0, 4][_301], { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/sync/atomic.rs", line: 4907, col: 24 }); } else if (k === 39) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationFromSecsF64(-1.0 - (n as rt.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF64(-1.0 - (n as rs.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); } else if (k === 40) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationFromSecsF32(Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1087, col: 23 })) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationFromSecsF32(Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1087, col: 23 })) & 0xff); } else if (k === 41) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationMulF64(rt.durationFromSecs(1), -1.0 - (n as rt.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationMulF64(rs.durationFromSecs(1), -1.0 - (n as rs.f64), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); } else if (k === 42) { - rt.byteVecPush(out, rt.durationSubsecNanos(rt.durationDivF32(rt.durationFromSecs(1), Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); + rs.byteVecPush(out, rs.durationSubsecNanos(rs.durationDivF32(rs.durationFromSecs(1), Math.fround(-1.0 - Math.fround(n)), { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1050, col: 23 })) & 0xff); } else if (k === 43) { - rt.byteVecPush(out, rt.iterSum(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(rt.max(n, 1), 255)))), (a: rt.u8, b: rt.u8) => rt.u8Add(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 0)); + rs.byteVecPush(out, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(rs.max(n, 1), 255)))), (a: rs.u8, b: rs.u8) => rs.u8Add(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 0)); } else if (k === 44) { - rt.byteVecPush(out, rt.iterProduct(rt.iterSlice([rt.max(n, 2) as rt.u16, 65535]), (a: rt.u16, b: rt.u16) => rt.u16Mul(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 1) & 0xff); + rs.byteVecPush(out, rs.iterProduct(rs.iterSlice([rs.max(n, 2) as rs.u16, 65535]), (a: rs.u16, b: rs.u16) => rs.u16Mul(a, b, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }), 1) & 0xff); } else if (k === 45) { - rt.byteVecPush(out, rt.u64Low(rt.durationAsSecs(rt.durationSum(rt.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, rt.durationFromSecs(rt.max(n, 1) as rt.u64)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1461, col: 9 }))) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationFromSecs(rs.max(n, 1) as rs.u64)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1461, col: 9 }))) & 0xff); } else if (k === 46) { - rt.byteVecPush(out, rt.u64Low(rt.durationAsSecs(rt.durationSum(rt.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, rt.durationNew(rt.u64Add(n as rt.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); + rs.byteVecPush(out, rs.u64Low(rs.durationAsSecs(rs.durationSum(rs.iterSlice([{ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, rs.durationNew(rs.u64Add(n as rs.u64, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 286, col: 43 }), 0)]), undefined, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1468, col: 9 }))) & 0xff); } else if (k === 47) { - const _365: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(v)); - const _367: rt.RangeFrom = new rt.RangeFrom(rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 291, col: 47 }), rt.usizeStep); - rt.iterExtendBytes(out, rt.byteVecExtractIf(_365, _367, (_29: rt.Place): boolean => { + const _365: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + const _367: rs.RangeFrom = new rs.RangeFrom(rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 291, col: 47 }), rs.usizeStep); + rs.iterExtendBytes(out, rs.byteVecExtractIf(_365, _367, (_29: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), "next"); } else if (k === 48) { - const _374: rt.Vec = rt.vecFrom([n as rt.u16]); - const _377: { end: rt.usize } = { end: rt.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 292, col: 56 }) }; - rt.byteVecPush(out, rt.ownedCount(rt.vecExtractIfMut(_374, _377, (_2: rt.Place): boolean => { + const _374: rs.Vec = rs.vecFrom([n as rs.u16]); + const _377: { end: rs.usize } = { end: rs.usizeAdd(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 292, col: 56 }) }; + rs.byteVecPush(out, rs.ownedCount(rs.vecExtractIfMut(_374, _377, (_2: rs.Place): boolean => { return true; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/extract_if.rs", line: 43, col: 36 }), undefined, undefined) & 0xff); } else if (k === 49) { - rt.iterExtendBytes(out, rt.iterTake(new rt.RangeFrom(rt.u8Sub(255, rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 27 }), rt.u8Step), 3), undefined, true); + rs.iterExtendBytes(out, rs.iterTake(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 293, col: 27 }), rs.u8Step), 3), undefined, true); } else if (k === 50) { - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(new rt.RangeFrom(rt.u8Sub(255, rt.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 27 }), rt.u8Step), rt.usizeAdd(rt.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 62 }) as rt.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 50 }))), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(new rs.RangeFrom(rs.u8Sub(255, rs.u8Rem(n, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 37 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 27 }), rs.u8Step), rs.usizeAdd(rs.u8Rem(n, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 62 }) as rs.usize, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 294, col: 50 }))), undefined, true); } else if (k === 51) { - rt.iterExtendBytes(out, rt.iterMap(rt.iterTake(new rt.RangeFrom(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 48 }) as rt.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 27 }), rt.u64Step), 3), (x: rt.u64): rt.u8 => { - return rt.u64Low(x) & 0xff; + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 48 }) as rs.u64, { file: "fixtures/lang/panics/src/hooked.rs", line: 295, col: 27 }), rs.u64Step), 3), (x: rs.u64): rs.u8 => { + return rs.u64Low(x) & 0xff; }), undefined, true); } else if (k === 52) { - rt.iterExtendBytes(out, rt.iterMap(rt.iterTake(new rt.RangeFrom(rt.optionUnwrap(rt.charFromU32(rt.u32Sub(1114111, rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 51 }) as rt.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 59 }), rt.charStep), 3), (c: rt.char): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterTake(new rs.RangeFrom(rs.optionUnwrap(rs.charFromU32(rs.u32Sub(1114111, rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 51 }) as rs.u32, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 29 })), undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 297, col: 59 }), rs.charStep), 3), (c: rs.char): rs.u8 => { return c & 0xff; }), undefined, true); } else if (k === 68) { - const v2: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 304, col: 50 })); - rt.byteVecSetLen(v2, rt.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 32 })); - rt.byteVecPush(out, v2.length & 0xff); + const v2: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 304, col: 50 })); + rs.byteVecSetLen(v2, rs.usizeAdd(v2.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 306, col: 32 })); + rs.byteVecPush(out, v2.length & 0xff); } else { if (53 <= k) { if (k <= 56) { - joined(rt.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 31 }), n, out); + joined(rs.u8Sub(k, 53, { file: "fixtures/lang/panics/src/hooked.rs", line: 301, col: 31 }), n, out); break b0; } } if (57 <= k) { if (k <= 67) { - rt.byteVecPush(out, compared(rt.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 302, col: 42 }), n)); + rs.byteVecPush(out, compared(rs.u8Sub(k, 57, { file: "fixtures/lang/panics/src/hooked.rs", line: 302, col: 42 }), n)); break b0; } } - rt.byteVecPush(out, rt.iterFrom({ _0: n }, Lying.next$iter_Iterator, undefined, { hint: Lying.sizeHint$iter_Iterator }).len() & 0xff); + rs.byteVecPush(out, rs.iterFrom({ _0: n }, Lying.next$iter_Iterator, undefined, { hint: Lying.sizeHint$iter_Iterator }).len() & 0xff); } } } @@ -479,26 +479,26 @@ export function sited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * A `concat` or `join` whose length overflows, by `kind`: its sum of the parts' lengths, * or the capacity the sum reserves. */ -export function joined(kind: rt.u8, n: rt.u8, out: rt.ByteVec): void { - let joined!: rt.ByteVec; - const big: rt.ByteVec = rt.byteVecOf(n, 1 << 16); - const refs: (a0: rt.usize) => rt.Vec = (count: rt.usize): rt.Vec => { - return rt.vecFromElem(rt.byteSliceRange(rt.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 40 }), count, undefined); +export function joined(kind: rs.u8, n: rs.u8, out: rs.ByteVec): void { + let joined!: rs.ByteVec; + const big: rs.ByteVec = rs.byteVecOf(n, 1 << 16); + const refs: (a0: rs.usize) => rs.Vec = (count: rs.usize): rs.Vec => { + return rs.vecFromElem(rs.byteSliceRange(rs.byteVecSlice(big), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 317, col: 40 }), count, undefined); }; if (kind === 0) { - joined = rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 19 })).items); + joined = rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 319, col: 19 })).items); } else if (kind === 1) { - joined = rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 320, col: 19 })).items, rt.byteSliceFrom(Uint8Array.of(n))); + joined = rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 16, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 320, col: 19 })).items, rs.byteSliceFrom(Uint8Array.of(n))); } else if (kind === 2) { - joined = rt.byteSlicesJoin(refs(rt.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 19 })).items); + joined = rs.byteSlicesJoin(refs(rs.usizeAdd(1 << 15, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 321, col: 19 })).items); } else { - const _48: rt.u16[][] = rt.vecFromElem(rt.sliceRange(rt.vecFromElem(n as rt.u16, 1 << 16, undefined).items, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 36 }), rt.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 42 }), undefined).items; - const _59: rt.u16[] = [1]; - joined = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.slicesJoin(_48, 2, rt.sliceRange(_59, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 69 })).items), (_2: rt.u16): rt.u8 => { + const _48: rs.u16[][] = rs.vecFromElem(rs.sliceRange(rs.vecFromElem(n as rs.u16, 1 << 16, undefined).items, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 36 }), rs.usizeAdd(1 << 14, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 42 }), undefined).items; + const _59: rs.u16[] = [1]; + joined = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.slicesJoin(_48, 2, rs.sliceRange(_59, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 324, col: 69 })).items), (_2: rs.u16): rs.u8 => { return _2 & 0xff; }), undefined, true); } - rt.byteVecPush(out, joined.length & 0xff); + rs.byteVecPush(out, joined.length & 0xff); } /** @@ -506,54 +506,54 @@ export function joined(kind: rt.u8, n: rt.u8, out: rt.ByteVec): void { * each of their own comparisons, and those that reach them through a tuple's last element, * a `Reverse`, and a vector. */ -export function compared(kind: rt.u8, n: rt.u8): rt.u8 { - let _0!: rt.u8; - let _held!: rt.RefCell; - const _15: (a0: rt.Ordering | undefined) => rt.u8 = (o: rt.Ordering | undefined): rt.u8 => { - return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function compared(kind: rs.u8, n: rs.u8): rs.u8 { + let _0!: rs.u8; + let _held!: rs.RefCell; + const _15: (a0: rs.Ordering | undefined) => rs.u8 = (o: rs.Ordering | undefined): rs.u8 => { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); }; - const _5: [rt.RefCell, rt.RefCell] = [new rt.RefCell(n), new rt.RefCell(rt.u8WrappingAdd(n, 1))]; - const a: rt.RefCell = _5[0]; - const b: rt.RefCell = _5[1]; - if (!(rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 20 }) === 0)) { - _held = rt.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 59 }); + const _5: [rs.RefCell, rs.RefCell] = [new rs.RefCell(n), new rs.RefCell(rs.u8WrappingAdd(n, 1))]; + const a: rs.RefCell = _5[0]; + const b: rs.RefCell = _5[1]; + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 20 }) === 0)) { + _held = rs.refCellBorrowMut(b, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 59 }); } else { - _held = rt.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 35 }); + _held = rs.refCellBorrowMut(a, { file: "fixtures/lang/panics/src/hooked.rs", line: 336, col: 35 }); } if (kind === 0) { - _0 = rt.refCellBy(rt.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; } else if (kind === 1) { - _0 = !rt.refCellBy(rt.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; + _0 = !rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 })(a, b) ? 1 : 0; } else if (kind === 2) { - const part2 = rt.refCellBy(rt.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 43 })(a, b); + const part2 = rs.refCellBy(rs.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1496, col: 43 })(a, b); _0 = _15(part2); } else if (kind === 3) { - _0 = rt.refCellBy(rt.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 })(a, b) ? 1 : 0; } else if (kind === 4) { - _0 = rt.refCellBy(rt.le, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.le, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1512, col: 34 })(a, b) ? 1 : 0; } else if (kind === 5) { - _0 = rt.refCellBy(rt.gt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 33 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.gt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1520, col: 33 })(a, b) ? 1 : 0; } else if (kind === 6) { - _0 = rt.refCellBy(rt.ge, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 34 })(a, b) ? 1 : 0; + _0 = rs.refCellBy(rs.ge, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1528, col: 34 })(a, b) ? 1 : 0; } else if (kind === 7) { - const part = rt.refCellBy(rt.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 35 })(a, b); + const part = rs.refCellBy(rs.cmp, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 14 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1539, col: 35 })(a, b); _0 = _15(part); } else if (kind === 8) { - const _47: [rt.u8, rt.RefCell] = [n, a]; - const _50: [rt.u8, rt.RefCell] = [n, b]; - _0 = rt.testTuple([rt.cmp], rt.refCellBy(rt.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }), -1)(_47, _50) ? 1 : 0; + const _47: [rs.u8, rs.RefCell] = [n, a]; + const _50: [rs.u8, rs.RefCell] = [n, b]; + _0 = rs.testTuple([rs.cmp], rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }), -1)(_47, _50) ? 1 : 0; } else if (kind === 9) { - const _54: rt.RefCell = a; - const _57: rt.RefCell = b; - _0 = rt.cmpReverse(rt.refCellBy(rt.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }))(_54, _57) ? 1 : 0; + const _54: rs.RefCell = a; + const _57: rs.RefCell = b; + _0 = rs.cmpReverse(rs.refCellBy(rs.lt, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1504, col: 33 }))(_54, _57) ? 1 : 0; } else { - const _61: rt.RefCell[] = [a]; - const _64: rt.RefCell[] = [b]; - _0 = rt.eqSlice(rt.refCellBy(rt.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 }))(_61, _64) ? 1 : 0; + const _61: rs.RefCell[] = [a]; + const _64: rs.RefCell[] = [b]; + _0 = rs.eqSlice(rs.refCellBy(rs.same, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 15 }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell.rs", line: 1482, col: 34 }))(_61, _64) ? 1 : 0; } - rt.refMutRelease(_held); + rs.refMutRelease(_held); return _0; } @@ -561,184 +561,184 @@ export function compared(kind: rt.u8, n: rt.u8): rt.u8 { * One panic of `bytes`' own code, by `kind`, with a hook set: each where the native build * names it, in the source of the `bytes` it builds. */ -export function stock(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let held!: rt.ByteSlice; - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const at: rt.usize = n as rt.usize; - const whole: rt.ByteSlice = rt.bytesFromVec(rt.byteVecOf(n, 4)); +export function stock(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let held!: rs.ByteSlice; + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const at: rs.usize = n as rs.usize; + const whole: rs.ByteSlice = rs.bytesFromVec(rs.byteVecOf(n, 4)); b0: { - const k: rt.u8 = rt.u8Rem(kind, 30, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 24 }); + const k: rs.u8 = rs.u8Rem(kind, 30, { file: "fixtures/lang/panics/src/hooked.rs", line: 378, col: 24 }); if (0 <= k) { if (k <= 1) { - rt.setHook((info: rt.PanicHookInfo): undefined => { - const at2: rt.Location = rt.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 380, col: 38 }); + rs.setHook((info: rs.PanicHookInfo): undefined => { + const at2: rs.Location = rs.optionUnwrap(info.location, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 380, col: 38 }); const _10: string = at2.file; - const _126: rt.u32 = at2.line; - const _14: rt.u32 = at2.col; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _10), (f: rt.Formatter) => rt.u32Display(_126, f), (f: rt.Formatter) => rt.u32Display(_14, f)]; - const line: string = rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]); - rt.localKeyWithBorrowMutPlace(NOTE, (note: rt.Place): undefined => { + const _126: rs.u32 = at2.line; + const _14: rs.u32 = at2.col; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _10), (f: rs.Formatter) => rs.u32Display(_126, f), (f: rs.Formatter) => rs.u32Display(_14, f)]; + const line: string = rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]); + rs.localKeyWithBorrowMutPlace(NOTE, (note: rs.Place): undefined => { note.v = note.v + line; }, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 721, col: 38 }); - rt.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 383, col: 13 }); + rs.panicFmt(["unread"], { file: "fixtures/lang/panics/src/hooked.rs", line: 383, col: 13 }); }, { capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/raw_vec/mod.rs", line: 29, col: 5 }, trusted_capacity: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/spec_from_iter_nested.rs", line: 57, col: 18 }, swap_remove: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2178, col: 13 }, vec_set_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 2138, col: 9 }, into_flattened: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/vec/mod.rs", line: 3667, col: 36 }, rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3902, col: 9 }, rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/mod.rs", line: 3948, col: 9 }, ord_violation: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/slice/sort/shared/smallsort.rs", line: 854, col: 5 }, ord_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cmp.rs", line: 1166, col: 9 }, f32_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f32.rs", line: 1665, col: 9 }, f64_clamp: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/num/f64.rs", line: 1643, col: 9 }, encode_utf8: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2507, col: 9 }, encode_utf16: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/char/methods.rs", line: 2601, col: 13 }, format: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/fmt.rs", line: 657, col: 14 }, to_string: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/string.rs", line: 2997, col: 14 }, debug_struct_fields: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/fmt/mod.rs", line: 2572, col: 9 }, exact_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/exact_size.rs", line: 122, col: 9 }, join_len: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/str.rs", line: 177, col: 10 }, int_sum: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/traits/accum.rs", line: 206, col: 1 }, int_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 554, col: 1 }, char_forward: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/iter/range.rs", line: 119, col: 45 }, hash_capacity: { file: "/cargo/registry/25cdd57fae9f0462/hashbrown-0.17.1/src/raw.rs", line: 36, col: 40 }, btree_range_equal_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 110, col: 21 }, btree_range_equal_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 112, col: 21 }, btree_range_order_BTreeSet: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 119, col: 21 }, btree_range_order_BTreeMap: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/btree/search.rs", line: 121, col: 21 }, deque_insert: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2612, col: 9 }, deque_swap_i: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1062, col: 9 }, deque_swap_j: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 1063, col: 9 }, deque_rotate_left: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3198, col: 9 }, deque_rotate_right: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 3243, col: 9 }, deque_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/vec_deque/mod.rs", line: 2724, col: 9 }, list_split_off: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/alloc/src/collections/linked_list.rs", line: 1015, col: 9 }, mutex_lock: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sys/sync/mutex/no_threads.rs", line: 28, col: 9 }, once_force: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/sync/once.rs", line: 227, col: 20 }, reentrant_init: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/once.rs", line: 325, col: 66 }, lazy_poisoned: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/cell/lazy.rs", line: 386, col: 5 }, ready_poll: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 23, col: 35 }, ready_into_inner: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/future/ready.rs", line: 46, col: 16 }, duration_new: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 281, col: 18 }, duration_from_mins: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 540, col: 13 }, duration_from_hours: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 510, col: 13 }, duration_add: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1345, col: 31 }, duration_sub: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1365, col: 31 }, duration_mul: { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/core/src/time.rs", line: 1385, col: 31 }, bytes_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 207, col: 5 }, bytes_does_not_fit: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/lib.rs", line: 215, col: 5 }, bytes_slice: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 374, col: 28 }, bytes_slice_ref_start: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 426, col: 9 }, bytes_slice_ref_end: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 432, col: 9 }, bytes_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 481, col: 9 }, bytes_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 533, col: 9 }, bytes_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes.rs", line: 694, col: 9 }, bytes_mut_split_off: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 329, col: 9 }, bytes_mut_split_to: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 408, col: 9 }, bytes_mut_set_len: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 545, col: 9 }, bytes_mut_overflow: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 700, col: 21 }, bytes_mut_overflow_offset: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 720, col: 29 }, bytes_mut_buf_advance: { file: "/cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.12.1/src/bytes_mut.rs", line: 1246, col: 9 } }); - const subset: rt.ByteSlice = rt.bytesSlice(whole, 0, 1); + const subset: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); if (k === 0) { - const _22: rt.ByteSlice = rt.bytesSlice(whole, rt.usizeAdd(1, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 30 })); - held = rt.bytesSliceRef(_22, subset); - rt.bytesDrop(_22); + const _22: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(1, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 34 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 387, col: 30 })); + held = rs.bytesSliceRef(_22, subset); + rs.bytesDrop(_22); } else { - const _32: rt.ByteSlice = rt.bytesSlice(whole, 0, 1); - const _35: rt.ByteSlice = rt.byteSliceRange(whole, 0, rt.usizeAdd(2, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 51 }); - held = rt.bytesSliceRef(_32, _35); - rt.bytesDrop(_32); + const _32: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); + const _35: rs.ByteSlice = rs.byteSliceRange(whole, 0, rs.usizeAdd(2, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 58 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 54 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 388, col: 51 }); + held = rs.bytesSliceRef(_32, _35); + rs.bytesDrop(_32); } - rt.byteVecExtendFromSlice(out, held); - rt.bytesDrop(held); - rt.bytesDrop(subset); - rt.bytesDrop(whole); + rs.byteVecExtendFromSlice(out, held); + rs.bytesDrop(held); + rs.bytesDrop(subset); + rs.bytesDrop(whole); break b0; } } hook(); - const shared: rt.BytesMut = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 44 })); - const _52: rt.u8 = rt.u8Rem(kind, 30, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 11 }); + const shared: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(8).fill(n)), 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 394, col: 44 })); + const _52: rs.u8 = rs.u8Rem(kind, 30, { file: "fixtures/lang/panics/src/hooked.rs", line: 395, col: 11 }); if (_52 === 2) { - const _56: rt.ByteSlice = rt.bytesSlice(whole, rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 396, col: 49 }), 2); - rt.byteVecExtendFromSlice(out, _56); - rt.bytesDrop(_56); + const _56: rs.ByteSlice = rs.bytesSlice(whole, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 396, col: 49 }), 2); + rs.byteVecExtendFromSlice(out, _56); + rs.bytesDrop(_56); } else if (_52 === 3) { - const _63: rt.ByteSlice = rt.bytesSlice(whole, 0, rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 51 })); - rt.byteVecExtendFromSlice(out, _63); - rt.bytesDrop(_63); + const _63: rs.ByteSlice = rs.bytesSlice(whole, 0, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 397, col: 51 })); + rs.byteVecExtendFromSlice(out, _63); + rs.bytesDrop(_63); } else if (_52 === 4) { - const _72: rt.RangeInclusive = new rt.RangeInclusive(rt.usizeSub(4294967295, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 49 }), 4294967295, rt.usizeStep); - const _70: rt.ByteSlice = rt.bytesSliceInclusive(whole, _72); - rt.byteVecExtendFromSlice(out, _70); - rt.bytesDrop(_70); + const _72: rs.RangeInclusive = new rs.RangeInclusive(rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 62 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 398, col: 49 }), 4294967295, rs.usizeStep); + const _70: rs.ByteSlice = rs.bytesSliceInclusive(whole, _72); + rs.byteVecExtendFromSlice(out, _70); + rs.bytesDrop(_70); } else if (_52 === 5) { - let _81: rt.ByteSlice = rt.bytesClone(whole); - const _83: rt.usize = rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 399, col: 60 }); - const _79: rt.ByteSlice = rt.bytesSplitTo(rt.place(() => _81, (value9) => _81 = value9), _83); - rt.byteVecExtendFromSlice(out, _79); - rt.bytesDrop(_79); - rt.bytesDrop(_81); + let _81: rs.ByteSlice = rs.bytesClone(whole); + const _83: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 399, col: 60 }); + const _79: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _81, (value9) => _81 = value9), _83); + rs.byteVecExtendFromSlice(out, _79); + rs.bytesDrop(_79); + rs.bytesDrop(_81); } else if (_52 === 6) { - let _89: rt.ByteSlice = rt.bytesClone(whole); - const _91: rt.usize = rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 61 }); - const _87: rt.ByteSlice = rt.bytesSplitOff(rt.place(() => _89, (value8) => _89 = value8), _91); - rt.byteVecExtendFromSlice(out, _87); - rt.bytesDrop(_87); - rt.bytesDrop(_89); + let _89: rs.ByteSlice = rs.bytesClone(whole); + const _91: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 400, col: 61 }); + const _87: rs.ByteSlice = rs.bytesSplitOff(rs.place(() => _89, (value8) => _89 = value8), _91); + rs.byteVecExtendFromSlice(out, _87); + rs.bytesDrop(_87); + rs.bytesDrop(_89); } else if (_52 === 7) { - let _94: rt.ByteSlice = rt.bytesClone(whole); - const _96: rt.usize = rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 401, col: 36 }); - rt.bytesAdvance(rt.place(() => _94, (value7) => _94 = value7), _96); - rt.bytesDrop(_94); + let _94: rs.ByteSlice = rs.bytesClone(whole); + const _96: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 401, col: 36 }); + rs.bytesAdvance(rs.place(() => _94, (value7) => _94 = value7), _96); + rs.bytesDrop(_94); } else if (_52 === 8) { - let _101: rt.ByteSlice = rt.bytesSlice(whole, 0, 1); - rt.byteVecPush(out, (rt.bytesReadWord(rt.place(() => _101, (value6) => _101 = value6), 2, false) as rt.u16) & 0xff); - rt.bytesDrop(_101); + let _101: rs.ByteSlice = rs.bytesSlice(whole, 0, 1); + rs.byteVecPush(out, (rs.bytesReadWord(rs.place(() => _101, (value6) => _101 = value6), 2, false) as rs.u16) & 0xff); + rs.bytesDrop(_101); } else if (_52 === 9) { - let _107: rt.ByteSlice = rt.bytesClone(whole); - const _109: rt.usize = rt.usizeAdd(9, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 46 }); - rt.byteVecPush(out, rt.u64Low(rt.u64FromBeBytes(rt.bytesReadInt(rt.place(() => _107, (value5) => _107 = value5), 8, _109, false, false))) & 0xff); - rt.bytesDrop(_107); + let _107: rs.ByteSlice = rs.bytesClone(whole); + const _109: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 50 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 403, col: 46 }); + rs.byteVecPush(out, rs.u64Low(rs.u64FromBeBytes(rs.bytesReadInt(rs.place(() => _107, (value5) => _107 = value5), 8, _109, false, false))) & 0xff); + rs.bytesDrop(_107); } else if (_52 === 10) { - let _114: rt.ByteSlice = rt.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 21 }); - const _116: rt.usize = rt.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 35 }); - rt.byteSliceAdvance(rt.place(() => _114, (value4) => _114 = value4), _116); + let _114: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 21 }); + const _116: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 404, col: 35 }); + rs.byteSliceAdvance(rs.place(() => _114, (value4) => _114 = value4), _116); } else if (_52 === 11) { - let _120: rt.ByteSlice = rt.bytesClone(whole); - const _122: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5)); - rt.bytesCopyToSlice(rt.place(() => _120, (value3) => _120 = value3), _122); - rt.bytesDrop(_120); + let _120: rs.ByteSlice = rs.bytesClone(whole); + const _122: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5)); + rs.bytesCopyToSlice(rs.place(() => _120, (value3) => _120 = value3), _122); + rs.bytesDrop(_120); } else if (_52 === 12) { - let _129: rt.ByteSlice = rt.bytesClone(whole); - const _131: rt.usize = rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 406, col: 66 }); - const _127: rt.ByteSlice = rt.bytesSplitTo(rt.place(() => _129, (value2) => _129 = value2), _131); - rt.byteVecExtendFromSlice(out, _127); - rt.bytesDrop(_127); - rt.bytesDrop(_129); + let _129: rs.ByteSlice = rs.bytesClone(whole); + const _131: rs.usize = rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 406, col: 66 }); + const _127: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => _129, (value2) => _129 = value2), _131); + rs.byteVecExtendFromSlice(out, _127); + rs.bytesDrop(_127); + rs.bytesDrop(_129); } else if (_52 === 13) { - let _137: rt.ByteSlice = rt.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 44 }); - const _139: rt.usize = rt.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 64 }); - const _135: rt.ByteSlice = rt.byteSliceCopyToBytes(rt.place(() => _137, (value) => _137 = value), _139); - rt.byteVecExtendFromSlice(out, _135); - rt.bytesDrop(_135); + let _137: rs.ByteSlice = rs.byteSliceRange(data, 0, undefined, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 44 }); + const _139: rs.usize = rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 407, col: 64 }); + const _135: rs.ByteSlice = rs.byteSliceCopyToBytes(rs.place(() => _137, (value) => _137 = value), _139); + rs.byteVecExtendFromSlice(out, _135); + rs.bytesDrop(_135); } else if (_52 === 14) { - const _146: rt.BytesMut = rt.bytesMutFrom(data); - const _144: rt.BytesMut = rt.bytesMutSplitTo(_146, rt.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 408, col: 68 })); - rt.byteVecExtendFromSlice(out, rt.bytesMutView(_144)); + const _146: rs.BytesMut = rs.bytesMutFrom(data); + const _144: rs.BytesMut = rs.bytesMutSplitTo(_146, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 408, col: 68 })); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(_144)); _144[Symbol.dispose](); _146[Symbol.dispose](); } else if (_52 === 15) { - const _154: rt.BytesMut = rt.bytesMutWithCapacity(4); - const _152: rt.BytesMut = rt.bytesMutSplitOff(_154, rt.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 409, col: 75 })); - rt.byteVecExtendFromSlice(out, rt.bytesMutView(_152)); + const _154: rs.BytesMut = rs.bytesMutWithCapacity(4); + const _152: rs.BytesMut = rs.bytesMutSplitOff(_154, rs.usizeAdd(at, 5, { file: "fixtures/lang/panics/src/hooked.rs", line: 409, col: 75 })); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(_152)); _152[Symbol.dispose](); _154[Symbol.dispose](); } else if (_52 === 16) { - const b: rt.BytesMut = rt.bytesMutWithCapacity(rt.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 49 })); - rt.bytesMutSetLen(b, rt.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 32 })); - rt.byteVecPush(out, b.length & 0xff); + const b: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 411, col: 49 })); + rs.bytesMutSetLen(b, rs.usizeAdd(b.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 413, col: 32 })); + rs.byteVecPush(out, b.length & 0xff); b[Symbol.dispose](); } else if (_52 === 17) { - const b2: rt.BytesMut = rt.bytesMutWithCapacity(rt.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 49 })); - rt.bytesMutAdvanceMut(b2, rt.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 419, col: 36 })); - rt.byteVecPush(out, b2.length & 0xff); + const b2: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 417, col: 49 })); + rs.bytesMutAdvanceMut(b2, rs.usizeAdd(b2.cap, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 419, col: 36 })); + rs.byteVecPush(out, b2.length & 0xff); b2[Symbol.dispose](); } else if (_52 === 18) { - const v: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 50 })); - rt.byteVecAdvanceMut(v, rt.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 36 })); - rt.byteVecPush(out, v.length & 0xff); + const v: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(at, 4, { file: "fixtures/lang/panics/src/hooked.rs", line: 423, col: 50 })); + rs.byteVecAdvanceMut(v, rs.usizeAdd(v.data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 425, col: 36 })); + rs.byteVecPush(out, v.length & 0xff); } else if (_52 === 19) { - const _197: rt.BytesMut = rt.bytesMutFrom(data); - rt.bytesMutAdvance(_197, rt.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 44 })); + const _197: rs.BytesMut = rs.bytesMutFrom(data); + rs.bytesMutAdvance(_197, rs.usizeAdd(data.length, 1, { file: "fixtures/lang/panics/src/hooked.rs", line: 428, col: 44 })); _197[Symbol.dispose](); } else if (_52 === 20) { - const _204: rt.BytesMut = rt.bytesMutFrom(rt.byteSliceRange(data, 0, rt.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 429, col: 44 })); - rt.byteVecPush(out, (rt.bytesMutReadWord(_204, 4, false) as rt.u32) & 0xff); + const _204: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(data, 0, rs.min(data.length, 3), { file: "fixtures/lang/panics/src/hooked.rs", line: 429, col: 44 })); + rs.byteVecPush(out, (rs.bytesMutReadWord(_204, 4, false) as rs.u32) & 0xff); _204[Symbol.dispose](); } else if (_52 === 21) { - const _212: rt.BytesMut = rt.bytesMutWithCapacity(rt.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 48 })); - rt.byteVecPush(out, _212.cap & 0xff); + const _212: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 430, col: 48 })); + rs.byteVecPush(out, _212.cap & 0xff); _212[Symbol.dispose](); } else if (_52 === 22) { - const _tail: rt.BytesMut = rt.bytesMutSplitOff(shared, 4); - rt.bytesMutReserve(shared, rt.usizeSub(4294967295, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 28 })); + const _tail: rs.BytesMut = rs.bytesMutSplitOff(shared, 4); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 41 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 434, col: 28 })); _tail[Symbol.dispose](); } else if (_52 === 23) { - rt.bytesMutSplitTo(shared, 4)[Symbol.dispose](); - rt.bytesMutReserve(shared, rt.usizeSub(4294967295 - 4, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 28 })); + rs.bytesMutSplitTo(shared, 4)[Symbol.dispose](); + rs.bytesMutReserve(shared, rs.usizeSub(4294967295 - 4, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 439, col: 28 })); } else if (_52 === 24) { - const _235: rt.u64 = n as rt.u64; - const _236: rt.usize = rt.usizeAdd(9, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 45 }); - rt.bytesMutPutInt(shared, rt.u64ToBeBytes(_235), _236, false); + const _235: rs.u64 = n as rs.u64; + const _236: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 49 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 441, col: 45 }); + rs.bytesMutPutInt(shared, rs.u64ToBeBytes(_235), _236, false); } else if (_52 === 25) { - const _240: rt.i64 = n as rt.i64; - const _241: rt.usize = rt.usizeAdd(9, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 41 }); - rt.byteVecPutInt(out, rt.i64ToBeBytes(_240), _241, false); + const _240: rs.i64 = n as rs.i64; + const _241: rs.usize = rs.usizeAdd(9, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 45 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 442, col: 41 }); + rs.byteVecPutInt(out, rs.i64ToBeBytes(_240), _241, false); } else if (_52 === 26) { - rt.byteVecPutFill(out, n, rt.usizeSub(4294967295, rt.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 40 })); + rs.byteVecPutFill(out, n, rs.usizeSub(4294967295, rs.usizeRem(at, 2, { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 53 }), { file: "fixtures/lang/panics/src/hooked.rs", line: 443, col: 40 })); } else if (_52 === 27) { - const _253: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rt.bytesClone(whole), 2); - const _251: rt.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rt.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 444, col: 74 })); - rt.byteVecExtendFromSlice(out, _251); - rt.bytesDrop(_251); + const _253: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesClone(whole), 2); + const _251: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(_253, rs.usizeAdd(at, 3, { file: "fixtures/lang/panics/src/hooked.rs", line: 444, col: 74 })); + rs.byteVecExtendFromSlice(out, _251); + rs.bytesDrop(_251); drop$bytes_buf_Take_bytes_Bytes(_253); } else if (_52 === 28) { - const _261: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rt.bytesClone(whole), 1); - rt.byteVecPush(out, rt.bufGet(_261, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined) & 0xff); + const _261: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesClone(whole), 1); + rs.byteVecPush(out, rs.bufGet(_261, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined) & 0xff); drop$bytes_buf_Take_bytes_Bytes(_261); } else { - const _267: rt.BytesMut = rt.bytesMutZeroed(rt.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 446, col: 40 })); - rt.byteVecPush(out, _267.length & 0xff); + const _267: rs.BytesMut = rs.bytesMutZeroed(rs.usizeSub(4294967295, at, { file: "fixtures/lang/panics/src/hooked.rs", line: 446, col: 40 })); + rs.byteVecPush(out, _267.length & 0xff); _267[Symbol.dispose](); } - rt.byteVecExtendFromSlice(out, rt.bytesMutView(shared)); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(shared)); shared[Symbol.dispose](); - rt.bytesDrop(whole); + rs.bytesDrop(whole); } } diff --git a/ts/fixtures/lang/panics/hook/expected/lib.ts b/ts/fixtures/lang/panics/hook/expected/lib.ts index b25d5ab79..59068410d 100644 --- a/ts/fixtures/lang/panics/hook/expected/lib.ts +++ b/ts/fixtures/lang/panics/hook/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Take from "./bytes/buf/take.Take.ts"; import type * as Any from "./core/any.Any.ts"; import { panicked as hooked_panicked, aborted, sited, stock } from "./hooked.ts"; @@ -14,22 +14,22 @@ export function copy$panics_Point(v: Point.Point): Point.Point { return { x: v.x, y: v.y }; } -export function drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_1: rt.Result, rt.Mutex>): void { +export function drop$Result_sync_MutexGuard_u8_sync_PoisonError_sync_MutexGuard_u8(_1: rs.Result, rs.Mutex>): void { if (_1.ok) { - rt.mutexUnlock(_1.value); + rs.mutexUnlock(_1.value); } else { - rt.mutexUnlock(_1.error); + rs.mutexUnlock(_1.error); } } -export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rt.Result): void { +export function drop$Result_u8_boxed_Box_dyn_Any_marker_Send(_1: rs.Result): void { if (!_1.ok) { - rt.drop(_1.error); + rs.drop(_1.error); } } -export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): void { - rt.bytesDrop(_1.inner); +export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): void { + rs.bytesDrop(_1.inner); } export class of$String { @@ -47,11 +47,11 @@ export class of$located_Inherits { this.v = v; } - at$Tracked(caller: rt.Location): rt.Location { + at$Tracked(caller: rs.Location): rs.Location { return Inherits.at$located_Tracked(this.v, caller); } - via$Tracked(): rt.Location { + via$Tracked(): rs.Location { return Inherits.via$located_Tracked(this.v); } } @@ -63,7 +63,7 @@ export class of$located_Own { this.v = v; } - at$Untracked(): rt.Location { + at$Untracked(): rs.Location { return Own.at$located_Untracked(this.v, { file: "fixtures/lang/panics/src/located.rs", line: 86, col: 5 }); } } @@ -85,49 +85,49 @@ export class of$ref_str { } export class of$u32 { - v: rt.u32; + v: rs.u32; - constructor(v: rt.u32) { + constructor(v: rs.u32) { this.v = v; } } export class of$u8 { - v: rt.u8; + v: rs.u8; - constructor(v: rt.u8) { + constructor(v: rs.u8) { this.v = v; } - at$Tracked(caller: rt.Location): rt.Location { + at$Tracked(caller: rs.Location): rs.Location { return at$located_Tracked_u8(this.v, caller); } - via$Tracked(): rt.Location { + via$Tracked(): rs.Location { return via$located_Tracked_u8(this.v); } } export class ofPlace$String { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } export class ofPlace$ref_str { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } export class ofPlace$u32 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } } @@ -136,19 +136,19 @@ export class ofPlace$u32 { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.iterToVec(rt.iterChain(rt.vecIntoIter(rt.vecFrom([["panics::wrapped", wrapped as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::called", panics_called as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["panics::raised", raised as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::called", located_called as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::read", read as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["located::panicked", located_panicked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]])), rt.iterSlice([["hooked::panicked", hooked_panicked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hooked::aborted", aborted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hooked::sited", sited as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hooked::stock", stock as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]])), undefined, 12, true); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.iterToVec(rs.iterChain(rs.vecIntoIter(rs.vecFrom([["panics::wrapped", wrapped as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::called", panics_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::awaited", awaited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["panics::raised", raised as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::called", located_called as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::read", read as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["located::panicked", located_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), rs.iterSlice([["hooked::panicked", hooked_panicked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::aborted", aborted as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::sited", sited as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["hooked::stock", stock as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]])), undefined, 12, true); } -export const NOTE: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(NOTE$init, false); +export const NOTE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NOTE$init, false); -export function NOTE$init(): rt.RefCell { - return new rt.RefCell(""); +export function NOTE$init(): rs.RefCell { + return new rs.RefCell(""); } /** Take what the hooks wrote since the last call. */ export function note(): string { - return rt.localKeyWithBorrowMutPlace(NOTE, (a0: rt.Place): string => { + return rs.localKeyWithBorrowMutPlace(NOTE, (a0: rs.Place): string => { const taken = a0.v; a0.v = ""; return taken; diff --git a/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts b/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts index 96cfe6953..cc96f2732 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Held$read.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$read_fmt_Debug(self: Held, f: rt.Formatter): rt.Result { +export function fmt$read_fmt_Debug(self: Held, f: rs.Formatter): rs.Result { const _3: string = "Held"; const _4: string = "at"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtLocationDebug(self.at, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtLocationDebug(self.at, f); const _7: string = "maybe"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.maybe, f, rt.fmtLocationDebug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.maybe, f, rs.fmtLocationDebug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$read_cmp_PartialEq(self: Held, other: Held): boolean { - if (!rt.locationEq(self.at, other.at)) { + if (!rs.locationEq(self.at, other.at)) { return false; } - return rt.eqOption(rt.locationEq)(self.maybe, other.maybe); + return rs.eqOption(rs.locationEq)(self.maybe, other.maybe); } export interface Held { - at: rt.Location; - maybe: rt.Location | undefined; + at: rs.Location; + maybe: rs.Location | undefined; } //# sourceMappingURL=located.Held$read.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/located.Inherits.ts b/ts/fixtures/lang/panics/hook/expected/located.Inherits.ts index 8628ba0e9..eced42e8e 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Inherits.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Inherits.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { here } from "./located.ts"; /** A default, untracked, of the tracked method. */ -export function via$located_Tracked(self: Inherits): rt.Location { +export function via$located_Tracked(self: Inherits): rs.Location { return at$located_Tracked(self, { file: "fixtures/lang/panics/src/located.rs", line: 58, col: 14 }); } @@ -12,7 +12,7 @@ export function via$located_Tracked(self: Inherits): rt.Location { export interface Inherits { } -export function at$located_Tracked(_self: Inherits, caller: rt.Location): rt.Location { +export function at$located_Tracked(_self: Inherits, caller: rs.Location): rs.Location { return here(caller); } diff --git a/ts/fixtures/lang/panics/hook/expected/located.Own.ts b/ts/fixtures/lang/panics/hook/expected/located.Own.ts index 6238ff25b..8acfd7e15 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Own.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Own.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Only the impl tracks: a call through a trait object passes the impl's own location. */ export interface Own { } -export function at$located_Untracked(_self: Own, caller: rt.Location): rt.Location { +export function at$located_Untracked(_self: Own, caller: rs.Location): rs.Location { return caller; } diff --git a/ts/fixtures/lang/panics/hook/expected/located.Places.ts b/ts/fixtures/lang/panics/hook/expected/located.Places.ts index b36e16e6a..b8cd2d91b 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Places.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Places.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Indexing that gives where it was indexed. */ export interface Places { } -export function index$ops_Index_u8(_self: Places, _2: rt.u8, caller: rt.Location): rt.Location { +export function index$ops_Index_u8(_self: Places, _2: rs.u8, caller: rs.Location): rs.Location { return caller; } diff --git a/ts/fixtures/lang/panics/hook/expected/located.Tracked.ts b/ts/fixtures/lang/panics/hook/expected/located.Tracked.ts index 0f7f027d0..ad34eeb54 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Tracked.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Tracked.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export type Tracked = - | { at$Tracked: (a0: rt.Location) => rt.Location; via$Tracked: () => rt.Location }; + | { at$Tracked: (a0: rs.Location) => rs.Location; via$Tracked: () => rs.Location }; //# sourceMappingURL=located.Tracked.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/located.Untracked.ts b/ts/fixtures/lang/panics/hook/expected/located.Untracked.ts index e50dbc556..89decdf8e 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.Untracked.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.Untracked.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export type Untracked = { at$Untracked: () => rt.Location }; +export type Untracked = { at$Untracked: () => rs.Location }; //# sourceMappingURL=located.Untracked.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/located.ts b/ts/fixtures/lang/panics/hook/expected/located.ts index 15ec4bda4..06c97e5a0 100644 --- a/ts/fixtures/lang/panics/hook/expected/located.ts +++ b/ts/fixtures/lang/panics/hook/expected/located.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$located_Inherits, of$located_Own, of$u8 } from "./lib.ts"; -import { then$142atvy } from "./core/bool.ts"; -import { min$1rvi5e9, max$02i836o } from "./core/cmp.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0 } from "./core/option.ts"; +import { then$1yydrio } from "./core/bool.ts"; +import { min$1k8d4j6, max$0rht4yb } from "./core/cmp.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi } from "./core/option.ts"; import * as Held$read from "./located.Held$read.ts"; import * as Inherits from "./located.Inherits.ts"; import * as Own from "./located.Own.ts"; @@ -12,26 +12,26 @@ import * as Places from "./located.Places.ts"; import type * as Tracked from "./located.Tracked.ts"; import type * as Untracked from "./located.Untracked.ts"; -export function here(caller: rt.Location): rt.Location { +export function here(caller: rs.Location): rs.Location { return caller; } /** A chain, which passes on its own caller's location. */ -export function outer(caller: rt.Location): rt.Location { +export function outer(caller: rs.Location): rs.Location { return here(caller); } -export function twice(caller: rt.Location): [rt.Location, rt.Location] { - return [outer(caller), caller] as [rt.Location, rt.Location]; +export function twice(caller: rs.Location): [rs.Location, rs.Location] { + return [outer(caller), caller] as [rs.Location, rs.Location]; } /** Not tracked: its own call of `here`. */ -export function plain(): rt.Location { +export function plain(): rs.Location { return here({ file: "fixtures/lang/panics/src/located.rs", line: 32, col: 5 }); } -export function picked(first: rt.u8, caller: rt.Location): rt.Location { - const _2: rt.u8 = rt.u8Rem(first, 3, caller); +export function picked(first: rs.u8, caller: rs.Location): rs.Location { + const _2: rs.u8 = rs.u8Rem(first, 3, caller); if (_2 === 0) { return here(caller); } @@ -42,57 +42,57 @@ export function picked(first: rt.u8, caller: rt.Location): rt.Location { } /** A closure is no `#[track_caller]` function, so it gives its own calls'. */ -export function inClosure(_caller: rt.Location): [rt.Location, rt.Location] { - const _1: () => rt.Location = (): rt.Location => { +export function inClosure(_caller: rs.Location): [rs.Location, rs.Location] { + const _1: () => rs.Location = (): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 47, col: 18 }; }; - const _2: () => rt.Location = (): rt.Location => { + const _2: () => rs.Location = (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 48, col: 21 }); }; - return [_1(), _2()] as [rt.Location, rt.Location]; + return [_1(), _2()] as [rs.Location, rs.Location]; } /** A default, untracked, of the tracked method. */ -export function via$located_Tracked_u8(self: rt.u8): rt.Location { +export function via$located_Tracked_u8(self: rs.u8): rs.Location { return at$located_Tracked_u8(self, { file: "fixtures/lang/panics/src/located.rs", line: 58, col: 14 }); } -export function at$located_Tracked_u8(_self: rt.u8, caller: rt.Location): rt.Location { +export function at$located_Tracked_u8(_self: rs.u8, caller: rs.Location): rs.Location { return caller; } -export function generic$located_Inherits(t: Inherits.Inherits): rt.Location { +export function generic$located_Inherits(t: Inherits.Inherits): rs.Location { return Inherits.at$located_Tracked(t, { file: "fixtures/lang/panics/src/located.rs", line: 92, col: 7 }); } -export function generic$u8(t: rt.u8): rt.Location { +export function generic$u8(t: rs.u8): rs.Location { return at$located_Tracked_u8(t, { file: "fixtures/lang/panics/src/located.rs", line: 92, col: 7 }); } /** Each location's `Display`, a line each. */ -export function lines(out: rt.ByteVec, at: rt.Location[]): void { +export function lines(out: rs.ByteVec, at: rs.Location[]): void { for (const _5 of at) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(_5, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "\n"]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(_5, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "\n"]))); } } /** Calls of `#[track_caller]` functions, and `Location::caller` itself. */ -export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _24: (a0: rt.u8) => rt.Location = (n: rt.u8): rt.Location => { - if (!(rt.u8Rem(n, 2, { file: "fixtures/lang/panics/src/located.rs", line: 139, col: 32 }) === 0)) { +export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _24: (a0: rs.u8) => rs.Location = (n: rs.u8): rs.Location => { + if (!(rs.u8Rem(n, 2, { file: "fixtures/lang/panics/src/located.rs", line: 139, col: 32 }) === 0)) { return outer({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 61 }); } return here({ file: "fixtures/lang/panics/src/located.rs", line: 139, col: 45 }); }; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _7: rt.u8 = rt.u8Rem(kind, 6, { file: "fixtures/lang/panics/src/located.rs", line: 129, col: 11 }); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _7: rs.u8 = rs.u8Rem(kind, 6, { file: "fixtures/lang/panics/src/located.rs", line: 129, col: 11 }); if (_7 === 0) { - const _11: [rt.Location, rt.Location] = twice({ file: "fixtures/lang/panics/src/located.rs", line: 131, col: 26 }); + const _11: [rs.Location, rs.Location] = twice({ file: "fixtures/lang/panics/src/located.rs", line: 131, col: 26 }); lines(out, [{ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 19 }, here({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 39 }), outer({ file: "fixtures/lang/panics/src/located.rs", line: 134, col: 47 }), _11[0], _11[1], plain(), picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 134, col: 71 })]); } else if (_7 === 1) { - const _23: [rt.Location, rt.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); - lines(out, [_23[0], _23[1], _24(first), ((): rt.Location => { + const _23: [rs.Location, rs.Location] = inClosure({ file: "fixtures/lang/panics/src/located.rs", line: 138, col: 33 }); + lines(out, [_23[0], _23[1], _24(first), ((): rs.Location => { return { file: "fixtures/lang/panics/src/located.rs", line: 140, col: 53 }; })()]); } else if (_7 === 2) { @@ -101,26 +101,26 @@ export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const own: Untracked.Untracked = new of$located_Own({}); lines(out, [at$located_Tracked_u8(first, { file: "fixtures/lang/panics/src/located.rs", line: 149, col: 27 }), via$located_Tracked_u8(first), Inherits.at$located_Tracked({}, { file: "fixtures/lang/panics/src/located.rs", line: 151, col: 30 }), generic$u8(first), generic$located_Inherits({}), tracked.at$Tracked({ file: "fixtures/lang/panics/src/located.rs", line: 154, col: 29 }), tracked.via$Tracked(), inherits.at$Tracked({ file: "fixtures/lang/panics/src/located.rs", line: 156, col: 30 }), own.at$Untracked(), Own.at$located_Untracked({}, { file: "fixtures/lang/panics/src/located.rs", line: 158, col: 25 }), Places.index$ops_Index_u8({}, first, { file: "fixtures/lang/panics/src/located.rs", line: 159, col: 28 })]); } else if (_7 === 3) { - const g: () => rt.Location = (): rt.Location => { + const g: () => rs.Location = (): rs.Location => { return outer({ file: "fixtures/lang/panics/src/located.rs", line: 21, col: 1 }); }; - const h: (a0: rt.u8) => rt.Location = (a: rt.u8): rt.Location => { + const h: (a0: rs.u8) => rs.Location = (a: rs.u8): rs.Location => { return picked(a, { file: "fixtures/lang/panics/src/located.rs", line: 36, col: 1 }); }; - const fs: Array<() => rt.Location> = [(): rt.Location => { + const fs: Array<() => rs.Location> = [(): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 15, col: 1 }); }, plain]; - const own2: (a0: Own.Own) => rt.Location = (a2: Own.Own): rt.Location => { + const own2: (a0: Own.Own) => rs.Location = (a2: Own.Own): rs.Location => { return Own.at$located_Untracked(a2, { file: "fixtures/lang/panics/src/located.rs", line: 86, col: 5 }); }; - const _73: rt.Location = ((): rt.Location => { + const _73: rs.Location = ((): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 15, col: 1 }); })(); - const _74: rt.Location = g(); - const _75: rt.Location = h(first); - const _78: rt.usize = rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 170, col: 61 }) as rt.usize; + const _74: rs.Location = g(); + const _75: rs.Location = h(first); + const _78: rs.usize = rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 170, col: 61 }) as rs.usize; if (!(_78 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _78, { file: "fixtures/lang/panics/src/located.rs", line: 170, col: 46 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _78, { file: "fixtures/lang/panics/src/located.rs", line: 170, col: 46 }, true); } lines(out, [_73, _74, _75, fs[_78](), own2({})]); } else if (_7 === 4) { @@ -128,78 +128,78 @@ export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { lines(out, [here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 23 }), here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 34 }), here({ file: "fixtures/lang/panics/src/located.rs", line: 186, col: 45 })]); const wide: string = "é😀　"; - const _105: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); - const _107: rt.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, wide), (f: rt.Formatter) => rt.fmtLocationDisplay(_105, f), (f: rt.Formatter) => rt.fmtLocationDisplay(_107, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); + const _105: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 188, col: 49 }); + const _107: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 188, col: 57 }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, wide), (f: rs.Formatter) => rs.fmtLocationDisplay(_105, f), (f: rs.Formatter) => rs.fmtLocationDisplay(_107, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], args2[1], args2[0], args2[2]]))); } } -export const THERE$called: rt.Location = { file: "fixtures/lang/panics/src/located.rs", line: 177, col: 34 }; +export const THERE$called: rs.Location = { file: "fixtures/lang/panics/src/located.rs", line: 177, col: 34 }; /** What a `Location` says of itself, and how locations compare. */ -export function read(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const a: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 197, col: 13 }); - const b: rt.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); - const _9: rt.u8 = rt.u8Rem(kind, 4, { file: "fixtures/lang/panics/src/located.rs", line: 199, col: 11 }); +export function read(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const a: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 197, col: 13 }); + const b: rs.Location = picked(first, { file: "fixtures/lang/panics/src/located.rs", line: 198, col: 13 }); + const _9: rs.u8 = rs.u8Rem(kind, 4, { file: "fixtures/lang/panics/src/located.rs", line: 199, col: 11 }); if (_9 === 0) { let s: string = ""; const _18: string = a.file; - const _20: rt.u32 = a.line; - const _22: rt.u32 = a.col; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _18), (f: rt.Formatter) => rt.u32Display(_20, f), (f: rt.Formatter) => rt.u32Display(_22, f)]; - const written = rt.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); + const _20: rs.u32 = a.line; + const _22: rs.u32 = a.col; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _18), (f: rs.Formatter) => rs.u32Display(_20, f), (f: rs.Formatter) => rs.u32Display(_22, f)]; + const written = rs.fmtWriteString(s, [args2[0], "|", args2[1], "|", args2[2], "|"]); s = written.s; - rt.resultUnwrap(written.result, rt.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(a, f), (f: rt.Formatter) => rt.fmtLocationDebug(a, f), (f: rt.Formatter) => rt.fmtLocationDebug(b, f)]; - const written2 = rt.fmtWriteString(s, [rt.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rt.fmtSpec({ alternate: true }, args4[2]), "|", rt.fmtSpec({ debugHex: "x" }, args4[2])]); + rs.resultUnwrap(written.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 202, col: 68 }); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(a, f), (f: rs.Formatter) => rs.fmtLocationDebug(b, f)]; + const written2 = rs.fmtWriteString(s, [rs.fmtSpec({ align: ">", width: 60 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ debugHex: "x" }, args4[2])]); s = written2.s; - rt.resultUnwrap(written2.result, rt.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + rs.resultUnwrap(written2.result, rs.fmtErrorDebug, { file: "fixtures/lang/panics/src/located.rs", line: 203, col: 54 }); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); } else if (_9 === 1) { - const copy: rt.Location = a; - const same: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); - const _49: rt.u8 = rt.locationEq(a, b) ? 1 : 0; - const _53: rt.u8 = rt.locationEq(a, copy) ? 1 : 0; - const _56: rt.u8 = !rt.locationEq(a, same) ? 1 : 0; - const _60: rt.u8 = rt.locationCmp(a, b) === -1 ? 1 : 0; - const order = rt.locationCmp(a, same); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_49, _53, _56, _60, order !== undefined && order >= 0 ? 1 : 0, rt.locationCmp(a, b) & 0xff, option_mapOr$1e4a1e0(rt.locationCmp(a, same), 9, (o: rt.Ordering): rt.u8 => { + const copy: rs.Location = a; + const same: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 208, col: 24 }); + const _49: rs.u8 = rs.locationEq(a, b) ? 1 : 0; + const _53: rs.u8 = rs.locationEq(a, copy) ? 1 : 0; + const _56: rs.u8 = !rs.locationEq(a, same) ? 1 : 0; + const _60: rs.u8 = rs.locationCmp(a, b) === -1 ? 1 : 0; + const order = rs.locationCmp(a, same); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_49, _53, _56, _60, order !== undefined && order >= 0 ? 1 : 0, rs.locationCmp(a, b) & 0xff, option_mapOr$14runhi(rs.locationCmp(a, same), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; }))), undefined, true); - lines(out, [max$02i836o(a, b), min$1rvi5e9(a, b)]); + lines(out, [max$0rht4yb(a, b), min$1k8d4j6(a, b)]); } else if (_9 === 2) { - const _83: rt.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 35 }); - const _84: rt.Location = outer({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 46 }); - const _85: rt.Location = picked(rt.u8WrappingAdd(first, 1), { file: "fixtures/lang/panics/src/located.rs", line: 221, col: 55 }); - const all: rt.Vec = rt.vecFrom([b, _83, a, _84, _85]); - rt.sliceSort(all.items, rt.cmpLt(rt.locationCmp), 4, true); - rt.vecDedupBy(all, rt.locationEq); + const _83: rs.Location = here({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 35 }); + const _84: rs.Location = outer({ file: "fixtures/lang/panics/src/located.rs", line: 221, col: 46 }); + const _85: rs.Location = picked(rs.u8WrappingAdd(first, 1), { file: "fixtures/lang/panics/src/located.rs", line: 221, col: 55 }); + const all: rs.Vec = rs.vecFrom([b, _83, a, _84, _85]); + rs.sliceSort(all.items, rs.cmpLt(rs.locationCmp), 4, true); + rs.vecDedupBy(all, rs.locationEq); lines(out, all.items); - const _96: rt.Iter = rt.iterSlice(all.items); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.locationCmp) as rt.BTreeSet, _96, true, undefined, undefined, 4, true); - const _101: rt.Iter = rt.iterMap(rt.iterSlice(all.items), (l: rt.Location): rt.Location => { + const _96: rs.Iter = rs.iterSlice(all.items); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.locationCmp) as rs.BTreeSet, _96, true, undefined, undefined, 4, true); + const _101: rs.Iter = rs.iterMap(rs.iterSlice(all.items), (l: rs.Location): rs.Location => { return l; }); - const hashed: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.locationHash, rt.locationEq)) as rt.HashSet, _101, undefined, undefined, 58720256); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(set) & 0xff, rt.hashLen(hashed) & 0xff, rt.hashContains(hashed, a) ? 1 : 0)), undefined, true); + const hashed: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.locationHash, rs.locationEq)) as rs.HashSet, _101, undefined, undefined, 58720256); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(set) & 0xff, rs.hashLen(hashed) & 0xff, rs.hashContains(hashed, a) ? 1 : 0)), undefined, true); } else { - const _117: rt.Location | undefined = then$142atvy(rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 238, col: 25 }) === 0, (): rt.Location => { + const _117: rs.Location | undefined = then$1yydrio(rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 238, col: 25 }) === 0, (): rs.Location => { return here({ file: "fixtures/lang/panics/src/located.rs", line: 238, col: 49 }); }); const held: Held$read.Held = { at: a, maybe: _117 }; - const _127: rt.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rt.Formatter) => rt.u8Display(_127, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args6[0], "|", args6[1]]))); + const _127: rs.u8 = Held$read.eq$read_cmp_PartialEq(held, held) ? 1 : 0; + const args6: rs.Fmt[] = [(f: rs.Formatter) => Held$read.fmt$read_fmt_Debug(held, f), (f: rs.Formatter) => rs.u8Display(_127, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], "|", args6[1]]))); } } /** Panics whose message carries where a `#[track_caller]` function was called. */ -export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - if (rt.u8Rem(kind, 2, { file: "fixtures/lang/panics/src/located.rs", line: 256, col: 11 }) === 0) { - check$panicked(rt.u8Rem(first, 3, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 20 }) !== 0, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 14 }); +export function panicked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + if (rs.u8Rem(kind, 2, { file: "fixtures/lang/panics/src/located.rs", line: 256, col: 11 }) === 0) { + check$panicked(rs.u8Rem(first, 3, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 20 }) !== 0, { file: "fixtures/lang/panics/src/located.rs", line: 257, col: 14 }); } else { const f: (a0: boolean) => undefined = ((a: boolean): void => { return check$panicked(a, { file: "fixtures/lang/panics/src/located.rs", line: 250, col: 5 }); @@ -207,19 +207,19 @@ export function panicked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _15: (a0: boolean) => undefined = ((a2: boolean): void => { return check$panicked(a2, { file: "fixtures/lang/panics/src/located.rs", line: 250, col: 5 }); }) as (a0: boolean) => undefined; - const _18: rt.usize = rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 28 }) as rt.usize; + const _18: rs.usize = rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 28 }) as rs.usize; if (!(_18 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _18, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 13 }, true); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _18, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 13 }, true); } - [_15, f][_18](rt.u8Rem(first, 3, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 40 }) !== 1); + [_15, f][_18](rs.u8Rem(first, 3, { file: "fixtures/lang/panics/src/located.rs", line: 261, col: 40 }) !== 1); } - rt.byteVecPush(out, first); + rs.byteVecPush(out, first); } -export function check$panicked(ok: boolean, caller: rt.Location): void { +export function check$panicked(ok: boolean, caller: rs.Location): void { if (!ok) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLocationDisplay(caller, f)]; - rt.panicFmt(["failed at ", args2[0]], caller); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLocationDisplay(caller, f)]; + rs.panicFmt(["failed at ", args2[0]], caller); } } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.Countdown.ts b/ts/fixtures/lang/panics/hook/expected/panics.Countdown.ts index b87c5ea5f..d13e6e5b1 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.Countdown.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.Countdown.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A future to poll: ready after `n` polls, waking itself on each that is pending. */ export interface Countdown { - _0: rt.u8; + _0: rs.u8; } -export function poll$Future(self: Countdown, cx: rt.Context): rt.Poll { +export function poll$Future(self: Countdown, cx: rs.Context): rs.Poll { if (!(self._0 === 0)) { const _7: Countdown = self; - _7._0 = rt.u8Sub(_7._0, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 227, col: 9 }); + _7._0 = rs.u8Sub(_7._0, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 227, col: 9 }); cx.wakeByRef(); - return rt.Pending; + return rs.Pending; } return 7; } diff --git a/ts/fixtures/lang/panics/hook/expected/panics.Logged.ts b/ts/fixtures/lang/panics/hook/expected/panics.Logged.ts index 298d98d9e..fed3e4b70 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.Logged.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its byte as it drops. */ export class Logged { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -18,9 +18,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1, { file: "fixtures/lang/panics/src/panics.rs", line: 21, col: 16 }); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1, { file: "fixtures/lang/panics/src/panics.rs", line: 21, col: 16 }); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } //# sourceMappingURL=panics.Logged.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/panics.Point.ts b/ts/fixtures/lang/panics/hook/expected/panics.Point.ts index affb31107..c5f7e0f38 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.Point.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.Point.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Point, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { const _3: string = "Point"; const _4: string = "x"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.x, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.x, f); const _7: string = "y"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.y, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.y, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function default$Default(): Point { @@ -17,8 +17,8 @@ export function default$Default(): Point { /** A point, which JS copies. */ export interface Point { - x: rt.u8; - y: rt.u8; + x: rs.u8; + y: rs.u8; } //# sourceMappingURL=panics.Point.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/panics.ts b/ts/fixtures/lang/panics/hook/expected/panics.ts index be8d8f23b..0086a8cf1 100644 --- a/ts/fixtures/lang/panics/hook/expected/panics.ts +++ b/ts/fixtures/lang/panics/hook/expected/panics.ts @@ -1,152 +1,152 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$panics_Point, drop$Result_u8_boxed_Box_dyn_Any_marker_Send, of$String, of$panics_Point, of$ref_str, of$u8 } from "./lib.ts"; import type * as Any from "./core/any.Any.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; -import { asRef$16amweg, mapOr$059pexg as result_mapOr$059pexg } from "./core/result.ts"; -import { isPending$0vrdvv1 } from "./core/task/poll.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; +import { asRef$11fb4n1, mapOr$171qvtg as result_mapOr$171qvtg } from "./core/result.ts"; +import { isPending$189w6zf } from "./core/task/poll.ts"; import { text } from "./harness.ts"; import * as Countdown from "./panics.Countdown.ts"; import * as Logged from "./panics.Logged.ts"; import * as Point from "./panics.Point.ts"; -export function seven(): rt.u8 { +export function seven(): rs.u8 { return 7; } /** What `f` returns, through `catch_unwind`. */ export function caught$String_panics_called_closure6(f: () => string): string { - const _2: rt.Result = rt.Ok(f()); + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** What `f` returns, through `catch_unwind`. */ -export function caught$Vec_u8_panics_called_closure5(f: () => rt.ByteVec): rt.ByteVec { - const _2: rt.Result = rt.Ok(f()); +export function caught$Vec_u8_panics_called_closure5(f: () => rs.ByteVec): rs.ByteVec { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_panics_called_closure4(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_panics_called_closure4(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_panics_seven(_: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(seven()); +export function caught$u8_panics_seven(_: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(seven()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** What `f` returns, through `catch_unwind`. */ -export function caught$u8_ref_panics_called_closure7(f: () => rt.u8): rt.u8 { - const _2: rt.Result = rt.Ok(f()); +export function caught$u8_ref_panics_called_closure7(f: () => rs.u8): rs.u8 { + const _2: rs.Result = rs.Ok(f()); if (_2.ok) { return _2.value; } - rt.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); + rs.panicFmt(["internal error: entered unreachable code: a panic aborts"], { file: "fixtures/lang/panics/src/panics.rs", line: 40, col: 19 }); } /** Write `to` over what `at` points at. */ -export function replace$panic_AssertUnwindSafe_Vec_u8(at: rt.ByteVec, to: rt.ByteVec): void { +export function replace$panic_AssertUnwindSafe_Vec_u8(at: rs.ByteVec, to: rs.ByteVec): void { Object.assign(at, to); } /** Write `to` over what `at` points at. */ -export function replace$panic_AssertUnwindSafe_sync_Arc_u8(at: rt.Place>, to: rt.Arc): void { +export function replace$panic_AssertUnwindSafe_sync_Arc_u8(at: rs.Place>, to: rs.Arc): void { at.v[Symbol.dispose](); at.v = to; } /** `AssertUnwindSafe` of values, read and written as what it holds. */ -export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: rt.ByteVec; +export function wrapped(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: rs.ByteVec; let _234: boolean = false; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _7: rt.u8 = rt.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/panics.rs", line: 52, col: 11 }); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _7: rs.u8 = rs.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/panics.rs", line: 52, col: 11 }); if (_7 === 6) { - let a: rt.Arc = new rt.Arc(first); - const shared: rt.Arc = rt.arcClone(a); - const _16: rt.Arc = new rt.Arc(9); - replace$panic_AssertUnwindSafe_sync_Arc_u8(rt.place(() => a, (value) => a = value), _16); - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - const before: rt.usize = v.length; - const _25: rt.ByteVec = rt.byteVecOf(first, 3); + let a: rs.Arc = new rs.Arc(first); + const shared: rs.Arc = rs.arcClone(a); + const _16: rs.Arc = new rs.Arc(9); + replace$panic_AssertUnwindSafe_sync_Arc_u8(rs.place(() => a, (value) => a = value), _16); + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + const before: rs.usize = v.length; + const _25: rs.ByteVec = rs.byteVecOf(first, 3); replace$panic_AssertUnwindSafe_Vec_u8(v, _25); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(shared.value, a.value, shared.strong & 0xff, before & 0xff)), undefined, true); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(shared.value, a.value, shared.strong & 0xff, before & 0xff)), undefined, true); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v)); shared[Symbol.dispose](); a[Symbol.dispose](); } else if (_7 === 0) { - let w: rt.usize = data.length; - w = rt.usizeAdd(w, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 66, col: 13 }); - rt.byteVecPush(out, w & 0xff); - w = rt.usizeWrappingMul(w, 3); - rt.byteVecPush(out, w & 0xff); - w = rt.usizeAdd(w, first as rt.usize, { file: "fixtures/lang/panics/src/panics.rs", line: 71, col: 13 }); - rt.byteVecPush(out, w & 0xff); + let w: rs.usize = data.length; + w = rs.usizeAdd(w, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 66, col: 13 }); + rs.byteVecPush(out, w & 0xff); + w = rs.usizeWrappingMul(w, 3); + rs.byteVecPush(out, w & 0xff); + w = rs.usizeAdd(w, first as rs.usize, { file: "fixtures/lang/panics/src/panics.rs", line: 71, col: 13 }); + rs.byteVecPush(out, w & 0xff); } else if (_7 === 1) { - const v2: rt.ByteVec = rt.byteSliceToByteVec(data); - rt.byteVecPush(v2, first); - rt.byteVecPush(v2, 9); - rt.byteVecRetain(v2, (b2: rt.u8): boolean => { - return rt.u8Rem(b2, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 78, col: 26 }) === 0; + const v2: rs.ByteVec = rs.byteSliceToByteVec(data); + rs.byteVecPush(v2, first); + rs.byteVecPush(v2, 9); + rs.byteVecRetain(v2, (b2: rs.u8): boolean => { + return rs.u8Rem(b2, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 78, col: 26 }) === 0; }); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(v2)); - rt.byteVecPush(out, v2.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(v2)); + rs.byteVecPush(out, v2.length & 0xff); } else if (_7 === 2) { const p: Point.Point = { x: first, y: 2 }; - const _89: rt.u8 = rt.u8WrappingAdd(p.x, 1); + const _89: rs.u8 = rs.u8WrappingAdd(p.x, 1); p.x = _89; - const _95: rt.u8 = rt.u8WrappingMul(p.y, first); + const _95: rs.u8 = rs.u8WrappingMul(p.y, first); p.y = _95; const copy: Point.Point = copy$panics_Point(p); p.x = 0; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(copy.x, copy.y, p.x, p.y)), undefined, true); - let nested: rt.u8 = first; - nested = rt.u8WrappingAdd(nested, 5); - rt.byteVecPush(out, nested); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(copy.x, copy.y, p.x, p.y)), undefined, true); + let nested: rs.u8 = first; + nested = rs.u8WrappingAdd(nested, 5); + rs.byteVecPush(out, nested); } else if (_7 === 3) { - const _132: rt.u8 = first; - const _134: rt.u8 = first; + const _132: rs.u8 = first; + const _134: rs.u8 = first; const _136: string = text(data); - const _138: rt.i8 = -1; + const _138: rs.i8 = -1; const _140: Point.Point = { x: first, y: 0 }; - const _144: [rt.u8, string] = [first, "a"]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.u8Debug(_132, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.u8Debug(_134, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtStr(_136, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.i8Debug(_138, f)]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_144[0], f), (f: rt.Formatter) => rt.fmtStr(_144[1], f)], f)])]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rt.fmtSpec({ alternate: true }, args2[5])]))); + const _144: [rs.u8, string] = [first, "a"]; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_132, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.u8Debug(_134, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtStr(_136, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.i8Debug(_138, f)]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => Point.fmt$fmt_Debug(_140, f)])]), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_144[0], f), (f: rs.Formatter) => rs.fmtStr(_144[1], f)], f)])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ width: 5 }, args2[3]), "|", args2[4], "|", rs.fmtSpec({ alternate: true }, args2[5])]))); } else if (_7 === 4) { - const d: rt.u8 = 0; + const d: rs.u8 = 0; const s2: string = ""; const p2: Point.Point = Point.default$Default(); - const v3: rt.ByteVec = new rt.ByteVec(); - const e: rt.u8 = first; - f = rt.byteSliceToByteVec(data); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(d, rt.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); + const v3: rs.ByteVec = new rs.ByteVec(); + const e: rs.u8 = first; + f = rs.byteSliceToByteVec(data); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d, rs.stringLen(s2) & 0xff, p2.x, p2.y, v3.length & 0xff, e, f.length & 0xff)), undefined, true); } else { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(1, log); let b: Logged.Logged = new Logged.Logged(2, log); const _198: Logged.Logged = new Logged.Logged(3, log); @@ -160,17 +160,17 @@ export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _206: Logged.Logged = new Logged.Logged(5, log); b[Symbol.dispose](); b = _206; - if (rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 124, col: 16 }) === 0) { + if (rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 124, col: 16 }) === 0) { _234 = false; c[Symbol.dispose](); } - const _216: rt.RefCell = rt.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 127, col: 17 }); - rt.byteVecPush(_216.value, b._0); - rt.refMutRelease(_216); + const _216: rs.RefCell = rs.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 127, col: 17 }); + rs.byteVecPush(_216.value, b._0); + rs.refMutRelease(_216); b[Symbol.dispose](); - const _226: rt.RefCell = rt.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 129, col: 28 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_226.value))), undefined, true); - rt.refRelease(_226); + const _226: rs.RefCell = rs.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 129, col: 28 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_226.value))), undefined, true); + rs.refRelease(_226); if (_234) { c[Symbol.dispose](); } @@ -179,186 +179,186 @@ export function wrapped(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** `AssertUnwindSafe` of functions called, and `catch_unwind` of each kind of function. */ -export function called(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const _8: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _10: rt.u8 = rt.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/panics.rs", line: 138, col: 11 }); +export function called(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const _8: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _10: rs.u8 = rs.u8Rem(kind, 7, { file: "fixtures/lang/panics/src/panics.rs", line: 138, col: 11 }); if (_10 === 0) { - const n: rt.usize = ((): rt.usize => { + const n: rs.usize = ((): rs.usize => { return data.length; })(); - const s: rt.u8 = seven(); - let count: rt.u8 = first; + const s: rs.u8 = seven(); + let count: rs.u8 = first; ((): undefined => { - count = rt.u8WrappingAdd(count, 3); + count = rs.u8WrappingAdd(count, 3); })(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(n & 0xff, s, count)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(n & 0xff, s, count)), undefined, true); } else if (_10 === 1) { const owned: Logged.Logged = new Logged.Logged(1, _8); const kept: Logged.Logged = new Logged.Logged(2, _8); const captured3 = owned._0; const captured4 = first; - const r: rt.u8 = ((): rt.u8 => { - const _510: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 153, col: 21 }); - rt.byteVecPush(_510.value, rt.u8Add(10, captured3, { file: "fixtures/lang/panics/src/panics.rs", line: 153, col: 39 })); - rt.refMutRelease(_510); + const r: rs.u8 = ((): rs.u8 => { + const _510: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 153, col: 21 }); + rs.byteVecPush(_510.value, rs.u8Add(10, captured3, { file: "fixtures/lang/panics/src/panics.rs", line: 153, col: 39 })); + rs.refMutRelease(_510); return captured4; })(); - const _33: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 156, col: 17 }); - rt.byteVecPush(_33.value, r); - rt.refMutRelease(_33); + const _33: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 156, col: 17 }); + rs.byteVecPush(_33.value, r); + rs.refMutRelease(_33); const captured5 = kept; - const back: Logged.Logged = rt.closure((): Logged.Logged => { + const back: Logged.Logged = rs.closure((): Logged.Logged => { return captured5; }, (): void => { captured5[Symbol.dispose](); })(); - const _40: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 158, col: 17 }); - rt.byteVecPush(_40.value, rt.u8Add(20, back._0, { file: "fixtures/lang/panics/src/panics.rs", line: 158, col: 35 })); - rt.refMutRelease(_40); + const _40: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 158, col: 17 }); + rs.byteVecPush(_40.value, rs.u8Add(20, back._0, { file: "fixtures/lang/panics/src/panics.rs", line: 158, col: 35 })); + rs.refMutRelease(_40); back[Symbol.dispose](); - const _50: rt.RefCell = rt.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 160, col: 28 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_50.value))), undefined, true); - rt.refRelease(_50); + const _50: rs.RefCell = rs.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 160, col: 28 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_50.value))), undefined, true); + rs.refRelease(_50); owned[Symbol.dispose](); } else if (_10 === 2) { - rt.byteVecPush(out, caught$u8_panics_called_closure4((): rt.u8 => { + rs.byteVecPush(out, caught$u8_panics_called_closure4((): rs.u8 => { return data.length & 0xff; })); - rt.byteVecPush(out, caught$u8_panics_seven(seven)); - rt.byteVecPush(out, rt.resultUnwrap(rt.Ok(seven()), (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 165, col: 49 })); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rt.ByteVec => { - return rt.iterToByteVec(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), undefined, true); + rs.byteVecPush(out, caught$u8_panics_seven(seven)); + rs.byteVecPush(out, rs.resultUnwrap(rs.Ok(seven()), (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 165, col: 49 })); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(caught$Vec_u8_panics_called_closure5((): rs.ByteVec => { + return rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); }))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(caught$String_panics_called_closure6((): string => { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(first, f)]; - return rt.fmtFormat([args6[0]]); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(caught$String_panics_called_closure6((): string => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f)]; + return rs.fmtFormat([args6[0]]); }))); } else if (_10 === 3) { - rt.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rt.u8 => { - return rt.u8WrappingMul(first, 2); + rs.byteVecPush(out, caught$u8_ref_panics_called_closure7((): rs.u8 => { + return rs.u8WrappingMul(first, 2); })); - let sum: rt.u8 = 0; - rt.byteVecPush(out, rt.resultUnwrap(rt.Ok(((): rt.u8 => { - const iterS: Uint8Array = rt.byteSliceView(data); + let sum: rs.u8 = 0; + rs.byteVecPush(out, rs.resultUnwrap(rs.Ok(((): rs.u8 => { + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _59: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_59 === rt.DONE) { + const _59: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_59 === rs.DONE) { return sum; } - sum = rt.u8WrappingAdd(sum, _59); + sum = rs.u8WrappingAdd(sum, _59); } - })()), (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 182, col: 24 })); - rt.byteVecPush(out, sum); + })()), (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 182, col: 24 })); + rs.byteVecPush(out, sum); } else if (_10 === 4) { const owned2: Logged.Logged = new Logged.Logged(1, _8); const captured = owned2._0; - const r3: rt.Result = rt.Ok(((): rt.u8 => { - const _56: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 188, col: 21 }); - rt.byteVecPush(_56.value, rt.u8Add(10, captured, { file: "fixtures/lang/panics/src/panics.rs", line: 188, col: 39 })); - rt.refMutRelease(_56); + const r3: rs.Result = rs.Ok(((): rs.u8 => { + const _56: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 188, col: 21 }); + rs.byteVecPush(_56.value, rs.u8Add(10, captured, { file: "fixtures/lang/panics/src/panics.rs", line: 188, col: 39 })); + rs.refMutRelease(_56); return captured; })()); - const _92: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 17 }); - const _93: rt.u8 = rt.u8Add(30, rt.resultUnwrap(r3, (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 42 }), { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 35 }); - rt.byteVecPush(_92.value, _93); - rt.refMutRelease(_92); + const _92: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 17 }); + const _93: rs.u8 = rs.u8Add(30, rs.resultUnwrap(r3, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 42 }), { file: "fixtures/lang/panics/src/panics.rs", line: 191, col: 35 }); + rs.byteVecPush(_92.value, _93); + rs.refMutRelease(_92); const captured2 = first; - const boxed: () => rt.u8 = (): rt.u8 => { - return rt.u8WrappingAdd(captured2, 1); + const boxed: () => rs.u8 = (): rs.u8 => { + return rs.u8WrappingAdd(captured2, 1); }; - const _102: rt.RefCell = rt.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 193, col: 17 }); - const _103: rt.u8 = caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(boxed); - rt.byteVecPush(_102.value, _103); - rt.refMutRelease(_102); - const _109: rt.RefCell = rt.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 194, col: 28 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_109.value))), undefined, true); - rt.refRelease(_109); + const _102: rs.RefCell = rs.refCellBorrowMut(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 193, col: 17 }); + const _103: rs.u8 = caught$u8_boxed_Box_dyn_ops_FnOnce_unit_u8_panic_UnwindSafe(boxed); + rs.byteVecPush(_102.value, _103); + rs.refMutRelease(_102); + const _109: rs.RefCell = rs.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 194, col: 28 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_109.value))), undefined, true); + rs.refRelease(_109); owned2[Symbol.dispose](); } else if (_10 === 5) { - const r4: rt.Result = rt.Ok(((): rt.u8 => { + const r4: rs.Result = rs.Ok(((): rs.u8 => { return data.length & 0xff; })()); const _117: boolean = r4.ok; - const _120: rt.u8 = result_mapOr$059pexg(asRef$16amweg(r4), 0, (n2: rt.u8): rt.u8 => { + const _120: rs.u8 = result_mapOr$171qvtg(asRef$11fb4n1(r4), 0, (n2: rs.u8): rs.u8 => { return n2; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r4, f, rt.u8Debug, (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any"))), (f: rt.Formatter) => rt.fmtBool(_117, f), (f: rt.Formatter) => rt.u8Display(_120, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r4, f, rs.u8Debug, (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))), (f: rs.Formatter) => rs.fmtBool(_117, f), (f: rs.Formatter) => rs.u8Display(_120, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]]))); drop$Result_u8_boxed_Box_dyn_Any_marker_Send(r4); } else { const owned3: Logged.Logged = new Logged.Logged(1, _8); - rt.byteVecPush(out, rt.resultUnwrap(rt.Ok(((): rt.u8 => { - if (!(rt.u8Rem(first, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 205, col: 20 }) === 0)) { + rs.byteVecPush(out, rs.resultUnwrap(rs.Ok(((): rs.u8 => { + if (!(rs.u8Rem(first, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 205, col: 20 }) === 0)) { return first; } const part = owned3._0; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; - rt.panicFmt(["caught ", args4[0]], { file: "fixtures/lang/panics/src/panics.rs", line: 206, col: 21 }); - })()), (_value: Any.Any, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 210, col: 24 })); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; + rs.panicFmt(["caught ", args4[0]], { file: "fixtures/lang/panics/src/panics.rs", line: 206, col: 21 }); + })()), (_value: Any.Any, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), { file: "fixtures/lang/panics/src/panics.rs", line: 210, col: 24 })); owned3[Symbol.dispose](); - const _147: rt.RefCell = rt.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 212, col: 28 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_147.value))), undefined, true); - rt.refRelease(_147); + const _147: rs.RefCell = rs.refCellBorrow(_8, { file: "fixtures/lang/panics/src/panics.rs", line: 212, col: 28 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_147.value))), undefined, true); + rs.refRelease(_147); } } /** `AssertUnwindSafe` of futures, polled by hand and awaited. */ -export function awaited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _22!: rt.Poll; +export function awaited(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _22!: rs.Poll; let _86: boolean = false; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const cx: rt.Context = rt.NOOP_WAKER; - const _11: rt.u8 = rt.u8Rem(kind, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 238, col: 11 }); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const cx: rs.Context = rs.NOOP_WAKER; + const _11: rs.u8 = rs.u8Rem(kind, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 238, col: 11 }); if (_11 === 0) { - const pinned: Countdown.Countdown = { _0: rt.u8Rem(first, 4, { file: "fixtures/lang/panics/src/panics.rs", line: 240, col: 57 }) }; + const pinned: Countdown.Countdown = { _0: rs.u8Rem(first, 4, { file: "fixtures/lang/panics/src/panics.rs", line: 240, col: 57 }) }; const f: Countdown.Countdown = pinned; - let polls: rt.u8 = 0; + let polls: rs.u8 = 0; while (true) { - polls = rt.u8Add(polls, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 243, col: 17 }); + polls = rs.u8Add(polls, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 243, col: 17 }); _22 = Countdown.poll$Future(f, cx); - if (_22 !== rt.Pending) { + if (_22 !== rs.Pending) { break; } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_22, polls)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_22, polls)), undefined, true); } else if (_11 === 1) { - const pinned2: rt.Future = new awaitedFuture$closure0(rt.u8Rem(first, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 251, col: 21 })); - const f2: rt.Future = pinned2; - let polls2: rt.u8 = 0; - while (isPending$0vrdvv1(f2.poll(cx))) { - polls2 = rt.u8Add(polls2, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 259, col: 17 }); + const pinned2: rs.Future = new awaitedFuture$closure0(rs.u8Rem(first, 3, { file: "fixtures/lang/panics/src/panics.rs", line: 251, col: 21 })); + const f2: rs.Future = pinned2; + let polls2: rs.u8 = 0; + while (isPending$189w6zf(f2.poll(cx))) { + polls2 = rs.u8Add(polls2, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 259, col: 17 }); } - rt.byteVecPush(out, polls2); - rt.drop(pinned2); + rs.byteVecPush(out, polls2); + rs.drop(pinned2); } else { const a: Logged.Logged = new Logged.Logged(1, log); const b: Logged.Logged = new Logged.Logged(2, log); - const _53: rt.Future = new awaitedFuture$closure1(a._0); + const _53: rs.Future = new awaitedFuture$closure1(a._0); _86 = true; - const unpolled: rt.Future = _53; - const pinned3: rt.Future = new awaitedFuture$closure2(b._0); - const done: rt.Future = pinned3; - while (done.poll(cx) === rt.Pending) { - const _67: rt.RefCell = rt.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 273, col: 21 }); - rt.byteVecPush(_67.value, 9); - rt.refMutRelease(_67); + const unpolled: rs.Future = _53; + const pinned3: rs.Future = new awaitedFuture$closure2(b._0); + const done: rs.Future = pinned3; + while (done.poll(cx) === rs.Pending) { + const _67: rs.RefCell = rs.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 273, col: 21 }); + rs.byteVecPush(_67.value, 9); + rs.refMutRelease(_67); } - if (rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 275, col: 16 }) === 0) { + if (rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 275, col: 16 }) === 0) { _86 = false; - rt.drop(unpolled); + rs.drop(unpolled); } - const _77: rt.RefCell = rt.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 278, col: 17 }); - rt.byteVecPush(_77.value, 0); - rt.refMutRelease(_77); - const _84: rt.RefCell = rt.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 279, col: 28 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_84.value))), undefined, true); - rt.refRelease(_84); - rt.drop(pinned3); + const _77: rs.RefCell = rs.refCellBorrowMut(log, { file: "fixtures/lang/panics/src/panics.rs", line: 278, col: 17 }); + rs.byteVecPush(_77.value, 0); + rs.refMutRelease(_77); + const _84: rs.RefCell = rs.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 279, col: 28 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_84.value))), undefined, true); + rs.refRelease(_84); + rs.drop(pinned3); if (_86) { - rt.drop(unpolled); + rs.drop(unpolled); } _86 = false; b[Symbol.dispose](); @@ -368,169 +368,169 @@ export function awaited(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void export class awaitedFuture$closure0 { #state: number = 0; - #n: rt.u8; - #inner!: rt.u8; - #awaitee!: rt.Future; + #n: rs.u8; + #inner!: rs.u8; + #awaitee!: rs.Future; #awaitee$2!: Countdown.Countdown; - constructor(n: rt.u8) { + constructor(n: rs.u8) { this.#n = n; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { if (this.#state === 0) { this.#awaitee = new awaitedFuture$closure0_closure0(this.#n); } else if (this.#state === 1) { - rt.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 252, col: 23 }); + rs.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 252, col: 23 }); } else if (this.#state !== 3) { break b0; } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { this.#inner = _7; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#awaitee$2 = { _0: 0 }; } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _18: rt.Poll = Countdown.poll$Future(this.#awaitee$2, _2); - if (_18 !== rt.Pending) { - const _0: rt.Poll = rt.u8Add(_18, this.#inner, { file: "fixtures/lang/panics/src/panics.rs", line: 254, col: 17 }); + const _18: rs.Poll = Countdown.poll$Future(this.#awaitee$2, _2); + if (_18 !== rs.Pending) { + const _0: rs.Poll = rs.u8Add(_18, this.#inner, { file: "fixtures/lang/panics/src/panics.rs", line: 254, col: 17 }); this.#state = 1; return _0; } this.#state = 4; - return rt.Pending; + return rs.Pending; } } export class awaitedFuture$closure0_closure0 { #state: number = 0; - #n: rt.u8; + #n: rs.u8; #awaitee!: Countdown.Countdown; - constructor(n: rt.u8) { + constructor(n: rs.u8) { this.#n = n; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = { _0: this.#n }; } else if (this.#state === 1) { - rt.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 253, col: 46 }); + rs.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 253, col: 46 }); } - const _6: rt.Poll = Countdown.poll$Future(this.#awaitee, _2); - if (_6 !== rt.Pending) { - const _0: rt.Poll = rt.u8Add(_6, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 253, col: 54 }); + const _6: rs.Poll = Countdown.poll$Future(this.#awaitee, _2); + if (_6 !== rs.Pending) { + const _0: rs.Poll = rs.u8Add(_6, 1, { file: "fixtures/lang/panics/src/panics.rs", line: 253, col: 54 }); this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class awaitedFuture$closure1 { #state: number = 0; - #a0: rt.u8; + #a0: rs.u8; - constructor(a0: rt.u8) { + constructor(a0: rs.u8) { this.#a0 = a0; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = this.#a0; + const _0: rs.Poll = this.#a0; this.#state = 1; return _0; } - rt.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 267, col: 45 }); + rs.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 267, col: 45 }); } } export class awaitedFuture$closure2 { #state: number = 0; - #b0: rt.u8; + #b0: rs.u8; #awaitee!: Countdown.Countdown; - constructor(b0: rt.u8) { + constructor(b0: rs.u8) { this.#b0 = b0; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = { _0: 1 }; } else if (this.#state === 1) { - rt.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 268, col: 50 }); + rs.asyncFnResumed({ file: "fixtures/lang/panics/src/panics.rs", line: 268, col: 50 }); } - if (Countdown.poll$Future(this.#awaitee, _2) !== rt.Pending) { - const _0: rt.Poll = this.#b0; + if (Countdown.poll$Future(this.#awaitee, _2) !== rs.Pending) { + const _0: rs.Poll = this.#b0; this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** Panics with a payload, and `Debug` of a `dyn Any`. */ -export function raised(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const _9: rt.u8 = rt.u8Rem(kind, 8, { file: "fixtures/lang/panics/src/panics.rs", line: 288, col: 11 }); +export function raised(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const _9: rs.u8 = rs.u8Rem(kind, 8, { file: "fixtures/lang/panics/src/panics.rs", line: 288, col: 11 }); if (_9 === 0) { - rt.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }, false); + rs.panic("a payload of text", { file: "fixtures/lang/panics/src/panics.rs", line: 289, col: 14 }, false); } else if (_9 === 1) { - rt.panic(text(data), { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); + rs.panic(text(data), { file: "fixtures/lang/panics/src/panics.rs", line: 290, col: 14 }, true); } else if (_9 === 2) { - rt.panicAny(new of$u8(first), { file: "fixtures/lang/panics/src/panics.rs", line: 291, col: 14 }); + rs.panicAny(new of$u8(first), { file: "fixtures/lang/panics/src/panics.rs", line: 291, col: 14 }); } else if (_9 === 3) { - const _19: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - rt.panicAny(new of$u8(new Logged.Logged(first, _19)._0), { file: "fixtures/lang/panics/src/panics.rs", line: 292, col: 14 }); + const _19: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + rs.panicAny(new of$u8(new Logged.Logged(first, _19)._0), { file: "fixtures/lang/panics/src/panics.rs", line: 292, col: 14 }); } else if (_9 === 4) { new of$u8(first); - rt.resumeUnwind(); + rs.resumeUnwind(); } else if (_9 === 5) { new of$ref_str("text"); - rt.resumeUnwind(); + rs.resumeUnwind(); } else if (_9 === 6) { const _held: Logged.Logged = new Logged.Logged(1, log); - if (!(rt.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 298, col: 16 }) === 0)) { - rt.byteVecPush(out, first); + if (!(rs.u8Rem(first, 2, { file: "fixtures/lang/panics/src/panics.rs", line: 298, col: 16 }) === 0)) { + rs.byteVecPush(out, first); _held[Symbol.dispose](); } else { - rt.panicAny(new of$panics_Point({ x: first, y: 0 }), { file: "fixtures/lang/panics/src/panics.rs", line: 299, col: 17 }); + rs.panicAny(new of$panics_Point({ x: first, y: 0 }), { file: "fixtures/lang/panics/src/panics.rs", line: 299, col: 17 }); } } else { const boxed: Any.Any = new of$u8(first); new of$u8(first); const synced: Any.Any = new of$String(""); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any"))])]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[1]), "|", rt.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); - rt.drop(synced); - rt.drop(boxed); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "AssertUnwindSafe", [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any"))])]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[1]), "|", rs.fmtSpec({ align: ">", width: 20 }, args2[2]), "|", args2[3]]))); + rs.drop(synced); + rs.drop(boxed); } - const _67: rt.RefCell = rt.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 311, col: 20 }); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_67.value))), undefined, true); - rt.refRelease(_67); + const _67: rs.RefCell = rs.refCellBorrow(log, { file: "fixtures/lang/panics/src/panics.rs", line: 311, col: 20 }); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_67.value))), undefined, true); + rs.refRelease(_67); } //# sourceMappingURL=panics.ts.map diff --git a/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts b/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts index dafe331e1..4606da7f5 100644 --- a/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts +++ b/ts/fixtures/lang/panics/hook/expected/std/thread/local.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function withBorrow$1s4hgxf(self: rt.LocalKey>, f: (a0: rt.u8) => undefined): void { +export function withBorrow$097wfl1(self: rs.LocalKey>, f: (a0: rs.u8) => undefined): void { const captured = f; - ((cell: rt.RefCell): undefined => { - const _32: (a0: rt.u8) => undefined = captured; - const _7: rt.RefCell = rt.refCellBorrow(cell, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 688, col: 34 }); + ((cell: rs.RefCell): undefined => { + const _32: (a0: rs.u8) => undefined = captured; + const _7: rs.RefCell = rs.refCellBorrow(cell, { file: "/rustc/7df81381d027710708209f36b98d11b1c88f8d2e/library/std/src/thread/local.rs", line: 688, col: 34 }); _32(_7.value); - rt.refRelease(_7); + rs.refRelease(_7); })(self.get()); } diff --git a/ts/fixtures/lang/pointers/expected/core/bool.ts b/ts/fixtures/lang/pointers/expected/core/bool.ts index 36b66624a..e694d25bc 100644 --- a/ts/fixtures/lang/pointers/expected/core/bool.ts +++ b/ts/fixtures/lang/pointers/expected/core/bool.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Spot from "../pointers.Spot.ts"; -export function then$1vx3p6m(self: boolean, f: () => rt.Weak): rt.Weak | undefined { +export function then$0bgt67i(self: boolean, f: () => rs.Weak): rs.Weak | undefined { if (!self) { return undefined; } return f(); } -export function then$04p7jmh(self: boolean, f: () => [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc]): [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc] | undefined { +export function then$1a5xgoh(self: boolean, f: () => [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc]): [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc] | undefined { if (!self) { return undefined; } return f(); } -export function then$1d2br9m(self: boolean, f: () => [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak]): [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak] | undefined { +export function then$0jw3xip(self: boolean, f: () => [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak]): [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak] | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/pointers/expected/core/option.ts b/ts/fixtures/lang/pointers/expected/core/option.ts index 97414afbd..8f6edbacb 100644 --- a/ts/fixtures/lang/pointers/expected/core/option.ts +++ b/ts/fixtures/lang/pointers/expected/core/option.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$pointers_Pair, copy$pointers_Spot } from "../lib.ts"; import type * as Loaded from "../pointers.Loaded.ts"; import type * as Pair from "../pointers.Pair.ts"; import type * as Spot from "../pointers.Spot.ts"; -export function isSomeAnd$09tpccf(self: rt.u8 | undefined, f: (a0: rt.u8) => boolean): boolean { +export function isSomeAnd$1s2u5lz(self: rs.u8 | undefined, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function isSomeAnd$0h2dqit(self: [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc] | undefined, f: (a0: [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc]) => boolean): boolean { +export function isSomeAnd$1nosv3e(self: [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc] | undefined, f: (a0: [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc]) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function isSomeAnd$10niqnm(self: [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak] | undefined, f: (a0: [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak]) => boolean): boolean { +export function isSomeAnd$07atiew(self: [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak] | undefined, f: (a0: [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak]) => boolean): boolean { if (self === undefined) { return false; } @@ -34,14 +34,14 @@ export function unwrapOr$0mkoact(self: Loaded.Loaded | undefined, default_: Load return self; } -export function unwrapOr$1l4p6jc(self: [rt.u16, rt.u8] | undefined, default_: [rt.u16, rt.u8]): [rt.u16, rt.u8] { +export function unwrapOr$179xo1w(self: [rs.u16, rs.u8] | undefined, default_: [rs.u16, rs.u8]): [rs.u16, rs.u8] { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -55,7 +55,7 @@ export function map$1cfrse5(self: Loaded.Loaded | undefined, f: (a0: Loaded.Load return f(self); } -export function mapOr$1j1wsle(self: Pair.Pair | undefined, default_: rt.u8, f: (a0: Pair.Pair) => rt.u8): rt.u8 { +export function mapOr$078vnqn(self: Pair.Pair | undefined, default_: rs.u8, f: (a0: Pair.Pair) => rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -69,16 +69,16 @@ export function mapOr$00zno7m(self: Spot.Spot | undefined, default_: Spot.Spot, return f(copy$pointers_Spot(self)); } -export function mapOr$1wxcg5q(self: [rt.u8, rt.Arc] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.Arc]) => rt.u8): rt.u8 { +export function mapOr$173j2gr(self: [rs.u8, rs.Arc] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.Arc]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function filter$0tnmmii(self: rt.u32 | undefined, predicate: (a0: rt.u32) => boolean): rt.u32 | undefined { +export function filter$0wvwd70(self: rs.u32 | undefined, predicate: (a0: rs.u32) => boolean): rs.u32 | undefined { if (self !== undefined) { - const x: rt.u32 = self; + const x: rs.u32 = self; if (predicate(x)) { return x; } diff --git a/ts/fixtures/lang/pointers/expected/harness.ts b/ts/fixtures/lang/pointers/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/pointers/expected/harness.ts +++ b/ts/fixtures/lang/pointers/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/pointers/expected/lib.ts b/ts/fixtures/lang/pointers/expected/lib.ts index 61c5d30d0..7c169c6d1 100644 --- a/ts/fixtures/lang/pointers/expected/lib.ts +++ b/ts/fixtures/lang/pointers/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { lists, shared, places, unchecked, nested, copies, sentinels, cells, rebound, lapsed, writers, made, segments, uninitRuns, iteratedRuns, besideWritten, waiters, taken, bytes, loaded, reattached, partWritten, aimed, distinct, rawArcs, rawPlaces } from "./pointers.ts"; import type * as Aimed from "./pointers.Aimed.ts"; import * as Bin from "./pointers.Bin.ts"; @@ -23,19 +23,19 @@ export function copy$Option_pointers_Pair(v: Pair.Pair | undefined): Pair.Pair | return v === undefined ? v : copy$pointers_Pair(v); } -export function copy$Option_tuple2_u16_u8(v: [rt.u16, rt.u8] | undefined): [rt.u16, rt.u8] | undefined { +export function copy$Option_tuple2_u16_u8(v: [rs.u16, rs.u8] | undefined): [rs.u16, rs.u8] | undefined { return v === undefined ? v : copy$tuple2_u16_u8(v); } -export function copy$array_ptr_array4_u8(v: rt.ByteSlice[]): rt.ByteSlice[] { +export function copy$array_ptr_array4_u8(v: rs.ByteSlice[]): rs.ByteSlice[] { return v.slice(); } -export function copy$array_u16(v: rt.u16[]): rt.u16[] { +export function copy$array_u16(v: rs.u16[]): rs.u16[] { return v.slice(); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } @@ -47,7 +47,7 @@ export function copy$array_unit(v: undefined[]): undefined[] { return v.slice(); } -export function copy$mem_MaybeUninit_array_u32(v: rt.u32[]): rt.u32[] { +export function copy$mem_MaybeUninit_array_u32(v: rs.u32[]): rs.u32[] { if (v === undefined) { return v; } @@ -61,39 +61,39 @@ export function copy$mem_MaybeUninit_array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$mem_MaybeUninit_tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$mem_MaybeUninit_tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { if (v === undefined) { return v; } return [v[0], v[1]]; } -export function copy$pointers_Aimed_Cell_u8(v: Aimed.Aimed>): Aimed.Aimed> { - return { at: v.at as rt.Place>, seen: v.seen as rt.Place>, held: v.held as rt.Place>, maybe: v.maybe as rt.Place> | undefined, tagged: copy$tuple2_mutPtr_Cell_u8_u8(v.tagged as [rt.Place>, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place>) => rt.u8) as (a0: rt.Ptr>) => rt.u8 }; +export function copy$pointers_Aimed_Cell_u8(v: Aimed.Aimed>): Aimed.Aimed> { + return { at: v.at as rs.Place>, seen: v.seen as rs.Place>, held: v.held as rs.Place>, maybe: v.maybe as rs.Place> | undefined, tagged: copy$tuple2_mutPtr_Cell_u8_u8(v.tagged as [rs.Place>, rs.u8]), to: v.to, read: (v.read as (a0: rs.Place>) => rs.u8) as (a0: rs.Ptr>) => rs.u8 }; } -export function copy$pointers_Aimed_array2_u16(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.u16[], seen: v.seen as rt.u16[], held: v.held as rt.u16[], maybe: v.maybe as rt.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rt.u16[], rt.u8]), to: v.to, read: (v.read as (a0: rt.u16[]) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; +export function copy$pointers_Aimed_array2_u16(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rs.u16[], seen: v.seen as rs.u16[], held: v.held as rs.u16[], maybe: v.maybe as rs.u16[] | undefined, tagged: copy$tuple2_mutPtr_array2_u16_u8(v.tagged as [rs.u16[], rs.u8]), to: v.to, read: (v.read as (a0: rs.u16[]) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } export function copy$pointers_Aimed_array4_u8(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.ByteSlice, seen: v.seen as rt.ByteSlice, held: v.held as rt.ByteSlice, maybe: v.maybe as rt.ByteSlice | undefined, tagged: copy$tuple2_mutPtr_array4_u8_u8(v.tagged as [rt.ByteSlice, rt.u8]), to: v.to, read: (v.read as (a0: rt.ByteSlice) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; + return { at: v.at as rs.ByteSlice, seen: v.seen as rs.ByteSlice, held: v.held as rs.ByteSlice, maybe: v.maybe as rs.ByteSlice | undefined, tagged: copy$tuple2_mutPtr_array4_u8_u8(v.tagged as [rs.ByteSlice, rs.u8]), to: v.to, read: (v.read as (a0: rs.ByteSlice) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } -export function copy$pointers_Aimed_pointers_Housed_u8(v: Aimed.Aimed>): Aimed.Aimed> { - return { at: v.at as Housed.Housed, seen: v.seen as Housed.Housed, held: v.held as Housed.Housed, maybe: v.maybe as Housed.Housed | undefined, tagged: copy$tuple2_mutPtr_pointers_Housed_u8_u8(v.tagged as [Housed.Housed, rt.u8]), to: v.to, read: (v.read as (a0: Housed.Housed) => rt.u8) as (a0: rt.Ptr>) => rt.u8 }; +export function copy$pointers_Aimed_pointers_Housed_u8(v: Aimed.Aimed>): Aimed.Aimed> { + return { at: v.at as Housed.Housed, seen: v.seen as Housed.Housed, held: v.held as Housed.Housed, maybe: v.maybe as Housed.Housed | undefined, tagged: copy$tuple2_mutPtr_pointers_Housed_u8_u8(v.tagged as [Housed.Housed, rs.u8]), to: v.to, read: (v.read as (a0: Housed.Housed) => rs.u8) as (a0: rs.Ptr>) => rs.u8 }; } export function copy$pointers_Aimed_pointers_Leaning(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_pointers_Leaning_u8(v.tagged as [rt.Place, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; + return { at: v.at as rs.Place, seen: v.seen as rs.Place, held: v.held as rs.Place, maybe: v.maybe as rs.Place | undefined, tagged: copy$tuple2_mutPtr_pointers_Leaning_u8(v.tagged as [rs.Place, rs.u8]), to: v.to, read: (v.read as (a0: rs.Place) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } export function copy$pointers_Aimed_pointers_Paired(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as Paired.Paired, seen: v.seen as Paired.Paired, held: v.held as Paired.Paired, maybe: v.maybe as Paired.Paired | undefined, tagged: copy$tuple2_mutPtr_pointers_Paired_u8(v.tagged as [Paired.Paired, rt.u8]), to: v.to, read: (v.read as (a0: Paired.Paired) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; + return { at: v.at as Paired.Paired, seen: v.seen as Paired.Paired, held: v.held as Paired.Paired, maybe: v.maybe as Paired.Paired | undefined, tagged: copy$tuple2_mutPtr_pointers_Paired_u8(v.tagged as [Paired.Paired, rs.u8]), to: v.to, read: (v.read as (a0: Paired.Paired) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } -export function copy$pointers_Aimed_u8(v: Aimed.Aimed): Aimed.Aimed { - return { at: v.at as rt.Place, seen: v.seen as rt.Place, held: v.held as rt.Place, maybe: v.maybe as rt.Place | undefined, tagged: copy$tuple2_mutPtr_u8_u8(v.tagged as [rt.Place, rt.u8]), to: v.to, read: (v.read as (a0: rt.Place) => rt.u8) as (a0: rt.Ptr) => rt.u8 }; +export function copy$pointers_Aimed_u8(v: Aimed.Aimed): Aimed.Aimed { + return { at: v.at as rs.Place, seen: v.seen as rs.Place, held: v.held as rs.Place, maybe: v.maybe as rs.Place | undefined, tagged: copy$tuple2_mutPtr_u8_u8(v.tagged as [rs.Place, rs.u8]), to: v.to, read: (v.read as (a0: rs.Place) => rs.u8) as (a0: rs.Ptr) => rs.u8 }; } export function copy$pointers_ByCall(v: ByCall.ByCall): ByCall.ByCall { @@ -136,55 +136,55 @@ export function copy$pointers_Twin(v: Twin.Twin): Twin.Twin { return { _0: v._0, _1: v._1 }; } -export function copy$tuple2_array2_u32_u8(v: [rt.u32[], rt.u8]): [rt.u32[], rt.u8] { +export function copy$tuple2_array2_u32_u8(v: [rs.u32[], rs.u8]): [rs.u32[], rs.u8] { return [copy$array_u32(v[0]), v[1]]; } -export function copy$tuple2_mutPtr_Cell_u8_u8(v: [rt.Place>, rt.u8]): [rt.Place>, rt.u8] { +export function copy$tuple2_mutPtr_Cell_u8_u8(v: [rs.Place>, rs.u8]): [rs.Place>, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_array2_u16_u8(v: [rt.u16[], rt.u8]): [rt.u16[], rt.u8] { +export function copy$tuple2_mutPtr_array2_u16_u8(v: [rs.u16[], rs.u8]): [rs.u16[], rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_array4_u8_u8(v: [rt.ByteSlice, rt.u8]): [rt.ByteSlice, rt.u8] { +export function copy$tuple2_mutPtr_array4_u8_u8(v: [rs.ByteSlice, rs.u8]): [rs.ByteSlice, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_pointers_Housed_u8_u8(v: [Housed.Housed, rt.u8]): [Housed.Housed, rt.u8] { +export function copy$tuple2_mutPtr_pointers_Housed_u8_u8(v: [Housed.Housed, rs.u8]): [Housed.Housed, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_pointers_Leaning_u8(v: [rt.Place, rt.u8]): [rt.Place, rt.u8] { +export function copy$tuple2_mutPtr_pointers_Leaning_u8(v: [rs.Place, rs.u8]): [rs.Place, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_pointers_Paired_u8(v: [Paired.Paired, rt.u8]): [Paired.Paired, rt.u8] { +export function copy$tuple2_mutPtr_pointers_Paired_u8(v: [Paired.Paired, rs.u8]): [Paired.Paired, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_mutPtr_u8_u8(v: [rt.Place, rt.u8]): [rt.Place, rt.u8] { +export function copy$tuple2_mutPtr_u8_u8(v: [rs.Place, rs.u8]): [rs.Place, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_u16_u8(v: [rt.u16, rt.u8]): [rt.u16, rt.u8] { +export function copy$tuple2_u16_u8(v: [rs.u16, rs.u8]): [rs.u16, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_u32_u32(v: [rt.u32, rt.u32]): [rt.u32, rt.u32] { +export function copy$tuple2_u32_u32(v: [rs.u32, rs.u32]): [rs.u32, rs.u32] { return [v[0], v[1]]; } -export function copy$tuple2_u8_String(v: [rt.u8, string]): [rt.u8, string] { +export function copy$tuple2_u8_String(v: [rs.u8, string]): [rs.u8, string] { return [v[0], v[1]]; } -export function copy$tuple2_u8_sync_Arc_u8(v: [rt.u8, rt.Arc]): [rt.u8, rt.Arc] { +export function copy$tuple2_u8_sync_Arc_u8(v: [rs.u8, rs.Arc]): [rs.u8, rs.Arc] { return [v[0], v[1]]; } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } @@ -192,26 +192,26 @@ export function drop$pointers_List_String(_1: List.List): void { List.drop$ops_Drop_String(_1); } -export function drop$pointers_List_sync_Arc_u8(_1: List.List>): void { +export function drop$pointers_List_sync_Arc_u8(_1: List.List>): void { List.drop$ops_Drop_sync_Arc_u8(_1); } -export function drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin(_1: [rt.Arc, rt.Arc]): void { +export function drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin(_1: [rs.Arc, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } -export function drop$tuple2_u8_sync_Arc_u8(_1: [rt.u8, rt.Arc]): void { +export function drop$tuple2_u8_sync_Arc_u8(_1: [rs.u8, rs.Arc]): void { _1[1][Symbol.dispose](); } -export function drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit(_1: [rt.Arc, rt.Arc, rt.Arc]): void { +export function drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit(_1: [rs.Arc, rs.Arc, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); _1[2][Symbol.dispose](); } -export function drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin(_1: [rt.Arc, rt.Arc, rt.Arc, rt.Arc]): void { +export function drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin(_1: [rs.Arc, rs.Arc, rs.Arc, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); _1[2][Symbol.dispose](); @@ -234,60 +234,60 @@ export class of$pointers_Bin_pointers_ByObject { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["pointers::copies", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["pointers::copies", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { copies(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lists", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::lists", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { lists(data2.data, data2.start, data2.length, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::nested", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::nested", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { nested(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::places", (_213: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::places", (_213: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { places(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::sentinels", (_214: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::sentinels", (_214: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { sentinels(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::shared", (_215: rt.u8, data6: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::shared", (_215: rs.u8, data6: rs.ByteSlice, out6: rs.ByteVec): undefined => { shared(data6.data, data6.start, data6.length, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::unchecked", (_216: rt.u8, data7: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::unchecked", (_216: rs.u8, data7: rs.ByteSlice, out7: rs.ByteVec): undefined => { unchecked(data7, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::cells", (_217: rt.u8, data8: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::cells", (_217: rs.u8, data8: rs.ByteSlice, out8: rs.ByteVec): undefined => { cells(data8, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::rebound", (_218: rt.u8, data9: rt.ByteSlice, out9: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::rebound", (_218: rs.u8, data9: rs.ByteSlice, out9: rs.ByteVec): undefined => { rebound(data9, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::writers", (_219: rt.u8, data10: rt.ByteSlice, out10: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::writers", (_219: rs.u8, data10: rs.ByteSlice, out10: rs.ByteVec): undefined => { writers(data10, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::made", (_220: rt.u8, data11: rt.ByteSlice, out11: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::made", (_220: rs.u8, data11: rs.ByteSlice, out11: rs.ByteVec): undefined => { made(data11, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::lapsed", (_221: rt.u8, data12: rt.ByteSlice, out12: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::lapsed", (_221: rs.u8, data12: rs.ByteSlice, out12: rs.ByteVec): undefined => { lapsed(data12, out12); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::segments", (_222: rt.u8, data13: rt.ByteSlice, out13: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::segments", (_222: rs.u8, data13: rs.ByteSlice, out13: rs.ByteVec): undefined => { segments(data13, out13); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::uninit_runs", (_223: rt.u8, data14: rt.ByteSlice, out14: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::uninit_runs", (_223: rs.u8, data14: rs.ByteSlice, out14: rs.ByteVec): undefined => { uninitRuns(data14, out14); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::beside_written", (_224: rt.u8, data15: rt.ByteSlice, out15: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::beside_written", (_224: rs.u8, data15: rs.ByteSlice, out15: rs.ByteVec): undefined => { besideWritten(data15, out15); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::iterated_runs", (_225: rt.u8, data16: rt.ByteSlice, out16: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::iterated_runs", (_225: rs.u8, data16: rs.ByteSlice, out16: rs.ByteVec): undefined => { iteratedRuns(data16, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::waiters", (_226: rt.u8, data17: rt.ByteSlice, out17: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::waiters", (_226: rs.u8, data17: rs.ByteSlice, out17: rs.ByteVec): undefined => { waiters(data17, out17); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::taken", (_227: rt.u8, data18: rt.ByteSlice, out18: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::taken", (_227: rs.u8, data18: rs.ByteSlice, out18: rs.ByteVec): undefined => { taken(data18, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::bytes", (_228: rt.u8, data19: rt.ByteSlice, out19: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::bytes", (_228: rs.u8, data19: rs.ByteSlice, out19: rs.ByteVec): undefined => { bytes(data19, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::loaded", (_229: rt.u8, data20: rt.ByteSlice, out20: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::loaded", (_229: rs.u8, data20: rs.ByteSlice, out20: rs.ByteVec): undefined => { loaded(data20, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::reattached", (_230: rt.u8, data21: rt.ByteSlice, out21: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::reattached", (_230: rs.u8, data21: rs.ByteSlice, out21: rs.ByteVec): undefined => { reattached(data21, out21); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::part_written", (_231: rt.u8, data22: rt.ByteSlice, out22: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::part_written", (_231: rs.u8, data22: rs.ByteSlice, out22: rs.ByteVec): undefined => { partWritten(data22, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::aimed", (_232: rt.u8, data23: rt.ByteSlice, out23: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::aimed", (_232: rs.u8, data23: rs.ByteSlice, out23: rs.ByteVec): undefined => { aimed(data23, out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::distinct", (_233: rt.u8, data24: rt.ByteSlice, out24: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::distinct", (_233: rs.u8, data24: rs.ByteSlice, out24: rs.ByteVec): undefined => { distinct(data24, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::raw_arcs", (_234: rt.u8, data25: rt.ByteSlice, out25: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::raw_arcs", (_234: rs.u8, data25: rs.ByteSlice, out25: rs.ByteVec): undefined => { rawArcs(data25, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["pointers::raw_places", (_235: rt.u8, data26: rt.ByteSlice, out26: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["pointers::raw_places", (_235: rs.u8, data26: rs.ByteSlice, out26: rs.ByteVec): undefined => { rawPlaces(data26, out26); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Aimed.ts b/ts/fixtures/lang/pointers/expected/pointers.Aimed.ts index 776833442..f08f1d8c7 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Aimed.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Aimed.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as To from "./pointers.To.ts"; /** Pointers to `T` in each shape a field holds one, copied as Rust copies them. */ export interface Aimed { - at: rt.Ptr; - seen: rt.Ptr; - held: rt.Ptr; - maybe: rt.Ptr | undefined; - tagged: [rt.Ptr, rt.u8]; + at: rs.Ptr; + seen: rs.Ptr; + held: rs.Ptr; + maybe: rs.Ptr | undefined; + tagged: [rs.Ptr, rs.u8]; to: To.To; /** A function taking one, which JS takes as the instance's own pointer. */ - read: (a0: rt.Ptr) => rt.u8; + read: (a0: rs.Ptr) => rs.u8; } //# sourceMappingURL=pointers.Aimed.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Bin.ts b/ts/fixtures/lang/pointers/expected/pointers.Bin.ts index 414340c04..e063f2574 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Bin.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Bin.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$pointers_ByObject } from "./lib.ts"; import * as ByObject from "./pointers.ByObject.ts"; /** A value of a `T` in a cell, which `reset` gives `T`'s default. */ export class Bin { - _0: rt.Cell; + _0: rs.Cell; - constructor(_0: rt.Cell) { + constructor(_0: rs.Cell) { this._0 = _0; } } export function reset$pointers_Reset_pointers_ByObject(self: Bin): void { const _2: ByObject.ByObject = copy$pointers_ByObject(ByObject.default$Default()); - rt.ptrWrite(self._0.v, _2); + rs.ptrWrite(self._0.v, _2); } //# sourceMappingURL=pointers.Bin.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Borrows.ts b/ts/fixtures/lang/pointers/expected/pointers.Borrows.ts index a3e034b44..1e59bd0cf 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Borrows.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Borrows.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** References to `T`. */ export interface Borrows { - to: rt.Ptr; - seen: rt.Ptr; + to: rs.Ptr; + seen: rs.Ptr; } //# sourceMappingURL=pointers.Borrows.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.ByCall.ts b/ts/fixtures/lang/pointers/expected/pointers.ByCall.ts index bef39aacb..6305a698b 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ByCall.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ByCall.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Structs JS keeps as objects, which Rust copies, and which only the generic bodies below @@ -9,8 +9,8 @@ import * as rt from "./rt.ts"; * reached at, such as `nested`'s, whose pointers translate. */ export interface ByCall { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.ByCall.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.ByClosure.ts b/ts/fixtures/lang/pointers/expected/pointers.ByClosure.ts index 43f9665db..a6c7e1f22 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ByClosure.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ByClosure.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): ByClosure { return { _0: 0, _1: 0 }; } export interface ByClosure { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.ByClosure.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.ByObject.ts b/ts/fixtures/lang/pointers/expected/pointers.ByObject.ts index 2d6729e54..ed638f7e3 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ByObject.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ByObject.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): ByObject { return { _0: 0, _1: 0 }; } export interface ByObject { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.ByObject.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Counted.ts b/ts/fixtures/lang/pointers/expected/pointers.Counted.ts index fcf3e9823..dabe2da99 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Counted.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Counted.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * What an `Arc` or `Rc` holds through its raw pointer, which notes its drop in the * `Cell` beside it. */ export class Counted { - id: rt.u8; - dropped: rt.Cell; + id: rs.u8; + dropped: rs.Cell; - constructor(id: rt.u8, dropped: rt.Cell) { + constructor(id: rs.u8, dropped: rs.Cell) { this.id = id; this.dropped = dropped; } @@ -21,7 +21,7 @@ export class Counted { } export function drop$ops_Drop(self: Counted): void { - rt.cellSet(self.dropped, rt.u8WrappingAdd(self.dropped.v, self.id)); + rs.cellSet(self.dropped, rs.u8WrappingAdd(self.dropped.v, self.id)); } //# sourceMappingURL=pointers.Counted.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Duo.ts b/ts/fixtures/lang/pointers/expected/pointers.Duo.ts index c96bd3eea..74856c84e 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Duo.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Duo.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A struct JS keeps as an object, which Rust copies. It has no `Default`, which * `generics::reset` would count as replaced whole. */ export interface Duo { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.Duo.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Gauge.ts b/ts/fixtures/lang/pointers/expected/pointers.Gauge.ts index bbd5f933f..6a50c862c 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Gauge.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Gauge.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Gauge { - range: [rt.u8, rt.u8]; - slot: [rt.u8, rt.u8]; + range: [rs.u8, rs.u8]; + slot: [rs.u8, rs.u8]; } //# sourceMappingURL=pointers.Gauge.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Halves.ts b/ts/fixtures/lang/pointers/expected/pointers.Halves.ts index 8d64cfc3f..ded07ff1f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Halves.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Halves.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export type Halves = { at0: rt.u32[] }; +export type Halves = { at0: rs.u32[] }; //# sourceMappingURL=pointers.Halves.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Held.ts b/ts/fixtures/lang/pointers/expected/pointers.Held.ts index 6ff4123fd..308802577 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Held.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Held.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object, owning a count. */ export class Held { - n: rt.u8; - count: rt.Arc; + n: rs.u8; + count: rs.Arc; - constructor(n: rt.u8, count: rt.Arc) { + constructor(n: rs.u8, count: rs.Arc) { this.n = n; this.count = count; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Housed.ts b/ts/fixtures/lang/pointers/expected/pointers.Housed.ts index f457ad1f8..2c006f871 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Housed.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Housed.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An instance of another generic type. */ export class Housed { @@ -11,16 +11,16 @@ export class Housed { } } -export function made$pointers_Aim_u8(n: rt.u8): Housed { +export function made$pointers_Aim_u8(n: rs.u8): Housed { return new Housed(n ^ 153); } -export function get$pointers_Aim_u8(self: Housed): rt.u8 { +export function get$pointers_Aim_u8(self: Housed): rs.u8 { return self._0; } -export function put$pointers_Aim_u8(self: Housed, n: rt.u8): void { - self._0 = rt.u8WrappingAdd(self._0, n) ^ 16; +export function put$pointers_Aim_u8(self: Housed, n: rs.u8): void { + self._0 = rs.u8WrappingAdd(self._0, n) ^ 16; } //# sourceMappingURL=pointers.Housed.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Inner.ts b/ts/fixtures/lang/pointers/expected/pointers.Inner.ts index 210a5f5f2..82592faf8 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Inner.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Inner.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Inner { - a: rt.u32; - b: rt.u32; + a: rs.u32; + b: rs.u32; } //# sourceMappingURL=pointers.Inner.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Leaning.ts b/ts/fixtures/lang/pointers/expected/pointers.Leaning.ts index 7e30c6939..9ae2fdf22 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Leaning.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Leaning.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An enum, an object JS copies, so pointers to it are places, as pointers to a number are. */ -export type Leaning = { tag: "Pos"; _0: rt.u8 } | { tag: "Neg"; _0: rt.u8 }; +export type Leaning = { tag: "Pos"; _0: rs.u8 } | { tag: "Neg"; _0: rs.u8 }; -export function made$pointers_Aim(n: rt.u8): Leaning { +export function made$pointers_Aim(n: rs.u8): Leaning { return { tag: "Neg", _0: n ^ 85 } as Leaning; } -export function get$pointers_Aim(self: Leaning): rt.u8 { +export function get$pointers_Aim(self: Leaning): rs.u8 { if (self.tag === "Pos") { return self._0; } return ~self._0 & 0xff; } -export function put$pointers_Aim(self: rt.Place, n: rt.u8): void { +export function put$pointers_Aim(self: rs.Place, n: rs.u8): void { let _3!: Leaning; if (self.v.tag === "Pos") { - _3 = { tag: "Neg", _0: rt.u8WrappingAdd(self.v._0, n) } as Leaning; + _3 = { tag: "Neg", _0: rs.u8WrappingAdd(self.v._0, n) } as Leaning; } else { - _3 = { tag: "Pos", _0: rt.u8WrappingSub(self.v._0, n) } as Leaning; + _3 = { tag: "Pos", _0: rs.u8WrappingSub(self.v._0, n) } as Leaning; } self.v = _3; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Lent.ts b/ts/fixtures/lang/pointers/expected/pointers.Lent.ts index 7a60db773..4ec63fec8 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Lent.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Lent.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$mem_MaybeUninit_tuple2_u8_u8 } from "./lib.ts"; /** @@ -8,26 +8,26 @@ import { copy$mem_MaybeUninit_tuple2_u8_u8 } from "./lib.ts"; * `sync::UnsafeCell` is. */ export class Lent { - _0: rt.Cell; + _0: rs.Cell; - constructor(_0: rt.Cell) { + constructor(_0: rs.Cell) { this._0 = _0; } } -export function new$mem_MaybeUninit_tuple2_u8_u8(value: [rt.u8, rt.u8]): Lent<[rt.u8, rt.u8]> { - return new Lent(new rt.Cell(copy$mem_MaybeUninit_tuple2_u8_u8(value))); +export function new$mem_MaybeUninit_tuple2_u8_u8(value: [rs.u8, rs.u8]): Lent<[rs.u8, rs.u8]> { + return new Lent(new rs.Cell(copy$mem_MaybeUninit_tuple2_u8_u8(value))); } -export function with$mem_MaybeUninit_tuple2_u8_u8_tuple2_u8_u8_pointers_segments_closure1(self: Lent<[rt.u8, rt.u8]>, f: (a0: [rt.u8, rt.u8]) => [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function with$mem_MaybeUninit_tuple2_u8_u8_tuple2_u8_u8_pointers_segments_closure1(self: Lent<[rs.u8, rs.u8]>, f: (a0: [rs.u8, rs.u8]) => [rs.u8, rs.u8]): [rs.u8, rs.u8] { return f(self._0.v); } -export function withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(self: Lent<[rt.u8, rt.u8]>, f: (a0: [rt.u8, rt.u8]) => [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(self: Lent<[rs.u8, rs.u8]>, f: (a0: [rs.u8, rs.u8]) => [rs.u8, rs.u8]): [rs.u8, rs.u8] { return f(self._0.v); } -export function withMut$mem_MaybeUninit_tuple2_u8_u8_unit_pointers_segments_closure2(self: Lent<[rt.u8, rt.u8]>, f: (a0: [rt.u8, rt.u8]) => undefined): void { +export function withMut$mem_MaybeUninit_tuple2_u8_u8_unit_pointers_segments_closure2(self: Lent<[rs.u8, rs.u8]>, f: (a0: [rs.u8, rs.u8]) => undefined): void { f(self._0.v); } diff --git a/ts/fixtures/lang/pointers/expected/pointers.List.ts b/ts/fixtures/lang/pointers/expected/pointers.List.ts index 0cddedd3a..50e9b6466 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.List.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.List.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$tuple2_u8_String, copy$tuple2_u8_sync_Arc_u8, drop$tuple2_u8_sync_Arc_u8 } from "./lib.ts"; import { attachBefore$String, attachBefore$sync_Arc_u8, detach$String, detach$sync_Arc_u8 } from "./pointers.ts"; import type * as Free from "./pointers.Free.ts"; @@ -12,9 +12,9 @@ export class List { /** The guard: `next` is the first entry and `prev` the last, or itself if none. */ guard: Node.Node | undefined; free: Node.Node | undefined; - len: rt.usize; + len: rs.usize; - constructor(guard: Node.Node | undefined, free: Node.Node | undefined, len: rt.usize) { + constructor(guard: Node.Node | undefined, free: Node.Node | undefined, len: rs.usize) { this.guard = guard; this.free = free; this.len = len; @@ -25,7 +25,7 @@ export function new$String(): List { return new List(undefined, undefined, 0); } -export function new$sync_Arc_u8(): List> { +export function new$sync_Arc_u8(): List> { return new List(undefined, undefined, 0); } @@ -42,13 +42,13 @@ export function guard$String(self: List): Node.Node { return guard2; } -export function guard$sync_Arc_u8(self: List>): Node.Node> { +export function guard$sync_Arc_u8(self: List>): Node.Node> { if (self.guard !== undefined) { return self.guard; } - const guard2: Node.Node> = Node.new$sync_Arc_u8(); - const _8: Links.Links> = { next: guard2, prev: guard2 }; - const _11: Node.Node> = guard2; + const guard2: Node.Node> = Node.new$sync_Arc_u8(); + const _8: Links.Links> = { next: guard2, prev: guard2 }; + const _11: Node.Node> = guard2; _11.link.at0 = _8.next; _11.link.at4 = _8.prev; self.guard = guard2; @@ -64,32 +64,32 @@ export function alloc$String(self: List): Node.Node { return free; } -export function alloc$sync_Arc_u8(self: List>): Node.Node> { +export function alloc$sync_Arc_u8(self: List>): Node.Node> { if (self.free === undefined) { return Node.new$sync_Arc_u8(); } - const free: Node.Node> = self.free; + const free: Node.Node> = self.free; self.free = free.link.at0; return free; } -export function pushBack$String(self: List, key: rt.u8, value: string): void { +export function pushBack$String(self: List, key: rs.u8, value: string): void { const guard: Node.Node = guard$String(self); const node: Node.Node = alloc$String(self); - rt.ptrWrite(node.entry, [key, value] as [rt.u8, string]); + rs.ptrWrite(node.entry, [key, value] as [rs.u8, string]); attachBefore$String(node, guard); - self.len = rt.usizeAdd(self.len, 1); + self.len = rs.usizeAdd(self.len, 1); } -export function pushBack$sync_Arc_u8(self: List>, key: rt.u8, value: rt.Arc): void { - const guard: Node.Node> = guard$sync_Arc_u8(self); - const node: Node.Node> = alloc$sync_Arc_u8(self); - rt.ptrWrite(node.entry, [key, value] as [rt.u8, rt.Arc]); +export function pushBack$sync_Arc_u8(self: List>, key: rs.u8, value: rs.Arc): void { + const guard: Node.Node> = guard$sync_Arc_u8(self); + const node: Node.Node> = alloc$sync_Arc_u8(self); + rs.ptrWrite(node.entry, [key, value] as [rs.u8, rs.Arc]); attachBefore$sync_Arc_u8(node, guard); - self.len = rt.usizeAdd(self.len, 1); + self.len = rs.usizeAdd(self.len, 1); } -export function find$String(self: List, key: rt.u8): Node.Node | undefined { +export function find$String(self: List, key: rs.u8): Node.Node | undefined { const _4: Node.Node | undefined = self.guard; if (_4 !== undefined) { const guard: Node.Node = _4; @@ -106,14 +106,14 @@ export function find$String(self: List, key: rt.u8): Node.Node | return undefined; } -export function find$sync_Arc_u8(self: List>, key: rt.u8): Node.Node> | undefined { - const _4: Node.Node> | undefined = self.guard; +export function find$sync_Arc_u8(self: List>, key: rs.u8): Node.Node> | undefined { + const _4: Node.Node> | undefined = self.guard; if (_4 !== undefined) { - const guard: Node.Node> = _4; - let at: Node.Node> = guard.link.at0 as Node.Node>; + const guard: Node.Node> = _4; + let at: Node.Node> = guard.link.at0 as Node.Node>; while (at !== guard) { if (!(at.entry[0] === key)) { - at = at.link.at0 as Node.Node>; + at = at.link.at0 as Node.Node>; } else { return at; } @@ -123,37 +123,37 @@ export function find$sync_Arc_u8(self: List>, key: rt.u8): Node.No return undefined; } -export function remove$String(self: List, key: rt.u8): [rt.u8, string] | undefined { +export function remove$String(self: List, key: rs.u8): [rs.u8, string] | undefined { const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { const node: Node.Node = _4; detach$String(node); - const entry: [rt.u8, string] = copy$tuple2_u8_String(node.entry); + const entry: [rs.u8, string] = copy$tuple2_u8_String(node.entry); const _16: Free.Free = { next: self.free }; node.link.at0 = _16.next; self.free = node; - self.len = rt.usizeSub(self.len, 1); + self.len = rs.usizeSub(self.len, 1); return entry; } return undefined; } -export function remove$sync_Arc_u8(self: List>, key: rt.u8): [rt.u8, rt.Arc] | undefined { - const _4: Node.Node> | undefined = find$sync_Arc_u8(self, key); +export function remove$sync_Arc_u8(self: List>, key: rs.u8): [rs.u8, rs.Arc] | undefined { + const _4: Node.Node> | undefined = find$sync_Arc_u8(self, key); if (_4 !== undefined) { - const node: Node.Node> = _4; + const node: Node.Node> = _4; detach$sync_Arc_u8(node); - const entry: [rt.u8, rt.Arc] = copy$tuple2_u8_sync_Arc_u8(node.entry); - const _16: Free.Free> = { next: self.free }; + const entry: [rs.u8, rs.Arc] = copy$tuple2_u8_sync_Arc_u8(node.entry); + const _16: Free.Free> = { next: self.free }; node.link.at0 = _16.next; self.free = node; - self.len = rt.usizeSub(self.len, 1); + self.len = rs.usizeSub(self.len, 1); return entry; } return undefined; } -export function toFront$String(self: List, key: rt.u8): boolean { +export function toFront$String(self: List, key: rs.u8): boolean { const _4: Node.Node | undefined = find$String(self, key); if (_4 !== undefined) { const node: Node.Node = _4; @@ -168,14 +168,14 @@ export function toFront$String(self: List, key: rt.u8): boolean { return false; } -export function toFront$sync_Arc_u8(self: List>, key: rt.u8): boolean { - const _4: Node.Node> | undefined = find$sync_Arc_u8(self, key); +export function toFront$sync_Arc_u8(self: List>, key: rs.u8): boolean { + const _4: Node.Node> | undefined = find$sync_Arc_u8(self, key); if (_4 !== undefined) { - const node: Node.Node> = _4; + const node: Node.Node> = _4; if (self.guard !== undefined) { - const guard: Node.Node> = self.guard; + const guard: Node.Node> = self.guard; detach$sync_Arc_u8(node); - attachBefore$sync_Arc_u8(node, guard.link.at0 as Node.Node>); + attachBefore$sync_Arc_u8(node, guard.link.at0 as Node.Node>); return true; } return false; @@ -183,16 +183,16 @@ export function toFront$sync_Arc_u8(self: List>, key: rt.u8): bool return false; } -export function getMut$String(self: List, key: rt.u8): rt.Place | undefined { +export function getMut$String(self: List, key: rs.u8): rs.Place | undefined { const _3: Node.Node | undefined = find$String(self, key); if (_3 !== undefined) { - const _9: [rt.u8, string] = _3.entry; - return rt.place(() => _9[1], (value) => _9[1] = value); + const _9: [rs.u8, string] = _3.entry; + return rs.place(() => _9[1], (value) => _9[1] = value); } return undefined; } -export function each$String(self: List, out: rt.ByteVec): void { +export function each$String(self: List, out: rs.ByteVec): void { b0: { if (self.guard !== undefined) { const guard: Node.Node = self.guard; @@ -201,9 +201,9 @@ export function each$String(self: List, out: rt.ByteVec): void { if (!(at !== guard)) { break b0; } - const _13: [rt.u8, string] = at.entry; - rt.byteVecPush(out, _13[0]); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_13[1])); + const _13: [rs.u8, string] = at.entry; + rs.byteVecPush(out, _13[0]); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_13[1])); at = at.link.at0 as Node.Node; } } @@ -223,12 +223,12 @@ export function drop$ops_Drop_String(self: List): void { } } -export function drop$ops_Drop_sync_Arc_u8(self: List>): void { +export function drop$ops_Drop_sync_Arc_u8(self: List>): void { if (self.guard !== undefined) { - const guard: Node.Node> = self.guard; - let at: Node.Node> = guard.link.at0 as Node.Node>; + const guard: Node.Node> = self.guard; + let at: Node.Node> = guard.link.at0 as Node.Node>; while (at !== guard) { - const next: Node.Node> = at.link.at0 as Node.Node>; + const next: Node.Node> = at.link.at0 as Node.Node>; drop$tuple2_u8_sync_Arc_u8(at.entry); at = next; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Loaded.ts b/ts/fixtures/lang/pointers/expected/pointers.Loaded.ts index 7f7c68a63..a4381cd7d 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Loaded.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Loaded.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object that only [`loaded`] reads out. */ export interface Loaded { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.Loaded.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Log.ts b/ts/fixtures/lang/pointers/expected/pointers.Log.ts index 8936af84e..79fcb58d2 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Log.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Log.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object, holding bytes. */ export interface Log { - bytes: rt.ByteVec; + bytes: rs.ByteVec; } //# sourceMappingURL=pointers.Log.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Node.ts b/ts/fixtures/lang/pointers/expected/pointers.Node.ts index 3401bf3ad..7a3d3504f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Node.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Node.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Link from "./pointers.Link.ts"; import type * as Links from "./pointers.Links.ts"; export interface Node { - entry: [rt.u8, V]; + entry: [rs.u8, V]; link: Link.Link; } export function new$String(): Node { - const _1: [rt.u8, string] = ([undefined, undefined] as unknown) as [rt.u8, string]; - const _3: Links.Links = { next: rt.DANGLING, prev: rt.DANGLING }; + const _1: [rs.u8, string] = ([undefined, undefined] as unknown) as [rs.u8, string]; + const _3: Links.Links = { next: rs.DANGLING, prev: rs.DANGLING }; return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link }; } -export function new$sync_Arc_u8(): Node> { - const _1: [rt.u8, rt.Arc] = ([undefined, undefined] as unknown) as [rt.u8, rt.Arc]; - const _3: Links.Links> = { next: rt.DANGLING, prev: rt.DANGLING }; - return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link> }; +export function new$sync_Arc_u8(): Node> { + const _1: [rs.u8, rs.Arc] = ([undefined, undefined] as unknown) as [rs.u8, rs.Arc]; + const _3: Links.Links> = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _1, link: ({ at0: _3.next, at4: _3.prev } as unknown) as Link.Link> }; } //# sourceMappingURL=pointers.Node.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Outer.ts b/ts/fixtures/lang/pointers/expected/pointers.Outer.ts index 73bb035ad..e40755a43 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Outer.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Outer.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Inner from "./pointers.Inner.ts"; export interface Outer { inner: Inner.Inner; - pair: [rt.u32, rt.u32]; - n: rt.u32; + pair: [rs.u32, rs.u32]; + n: rs.u32; } //# sourceMappingURL=pointers.Outer.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Pair.ts b/ts/fixtures/lang/pointers/expected/pointers.Pair.ts index 4889c478e..11924af69 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Pair.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Pair.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Pair { - a: rt.u32; - b: rt.u32; + a: rs.u32; + b: rs.u32; } //# sourceMappingURL=pointers.Pair.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Paired.ts b/ts/fixtures/lang/pointers/expected/pointers.Paired.ts index 3abda2896..458f4a1e2 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Paired.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Paired.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object, which pointers to are. */ export interface Paired { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } -export function made$pointers_Aim(n: rt.u8): Paired { +export function made$pointers_Aim(n: rs.u8): Paired { return { _0: n, _1: n ^ 15 }; } -export function get$pointers_Aim(self: Paired): rt.u8 { +export function get$pointers_Aim(self: Paired): rs.u8 { return self._0 ^ self._1; } -export function put$pointers_Aim(self: Paired, n: rt.u8): void { - self._1 = rt.u8WrappingAdd(self._0, n); +export function put$pointers_Aim(self: Paired, n: rs.u8): void { + self._1 = rs.u8WrappingAdd(self._0, n); } //# sourceMappingURL=pointers.Paired.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Pointing.ts b/ts/fixtures/lang/pointers/expected/pointers.Pointing.ts index 3699ba8c7..d78f34b0b 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Pointing.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Pointing.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Pointing, other: Pointing): boolean { - return rt.byteSliceSame(self._0, other._0); + return rs.byteSliceSame(self._0, other._0); } export interface Pointing { - _0: rt.ByteSlice; + _0: rs.ByteSlice; } //# sourceMappingURL=pointers.Pointing.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Reattached.ts b/ts/fixtures/lang/pointers/expected/pointers.Reattached.ts index 254d0321c..b94e140ac 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Reattached.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Reattached.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object that only [`reattached`] points into. */ export interface Reattached { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.Reattached.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Refilled.ts b/ts/fixtures/lang/pointers/expected/pointers.Refilled.ts index 9eb8a31fd..80d3046cc 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Refilled.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Refilled.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object, whose cell only [`refill`] replaces. */ export interface Refilled { - cell: rt.Cell; + cell: rs.Cell; } //# sourceMappingURL=pointers.Refilled.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Run.ts b/ts/fixtures/lang/pointers/expected/pointers.Run.ts index ce068a080..1e54524e1 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Run.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Run.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object, with a part it keeps as one too. */ export interface Run { - span: [rt.u8, rt.u8]; - n: rt.u8; + span: [rs.u8, rs.u8]; + n: rs.u8; } //# sourceMappingURL=pointers.Run.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Segment.ts b/ts/fixtures/lang/pointers/expected/pointers.Segment.ts index a9310d35b..1d0029b17 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Segment.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Segment.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Lent from "./pointers.Lent.ts"; /** @@ -9,50 +9,50 @@ import * as Lent from "./pointers.Lent.ts"; * pointer its cell lends. */ export interface Segment { - filled: rt.usize; - slots: Lent.Lent<[rt.u8, rt.u8]>[]; + filled: rs.usize; + slots: Lent.Lent<[rs.u8, rs.u8]>[]; } function new_(): Segment { - let _6!: rt.usize; - const slots: Lent.Lent<[rt.u8, rt.u8]>[] = Array.from({ length: 4 }, (): Lent.Lent<[rt.u8, rt.u8]> => { - return (new Lent.Lent((undefined as unknown) as rt.Cell<[rt.u8, rt.u8]>) as unknown) as Lent.Lent<[rt.u8, rt.u8]>; + let _6!: rs.usize; + const slots: Lent.Lent<[rs.u8, rs.u8]>[] = Array.from({ length: 4 }, (): Lent.Lent<[rs.u8, rs.u8]> => { + return (new Lent.Lent((undefined as unknown) as rs.Cell<[rs.u8, rs.u8]>) as unknown) as Lent.Lent<[rs.u8, rs.u8]>; }); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 4; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 4; while ((_6 = iterStart++) < iterEnd) { - const at: rt.usize = _6; + const at: rs.usize = _6; if (!(at < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + at); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + at); } - const _15: Lent.Lent<[rt.u8, rt.u8]>[] = slots; - const _13: Lent.Lent<[rt.u8, rt.u8]> = Lent.new$mem_MaybeUninit_tuple2_u8_u8(([undefined, undefined] as unknown) as [rt.u8, rt.u8]); - rt.ptrWrite(_15[at], _13); + const _15: Lent.Lent<[rs.u8, rs.u8]>[] = slots; + const _13: Lent.Lent<[rs.u8, rs.u8]> = Lent.new$mem_MaybeUninit_tuple2_u8_u8(([undefined, undefined] as unknown) as [rs.u8, rs.u8]); + rs.ptrWrite(_15[at], _13); } return { filled: 0, slots }; } /** As [`Self::new`], with kio's loop written with an iterator. */ export function iterated(): Segment { - const slots: Lent.Lent<[rt.u8, rt.u8]>[] = Array.from({ length: 4 }, (): Lent.Lent<[rt.u8, rt.u8]> => { - return (new Lent.Lent((undefined as unknown) as rt.Cell<[rt.u8, rt.u8]>) as unknown) as Lent.Lent<[rt.u8, rt.u8]>; + const slots: Lent.Lent<[rs.u8, rs.u8]>[] = Array.from({ length: 4 }, (): Lent.Lent<[rs.u8, rs.u8]> => { + return (new Lent.Lent((undefined as unknown) as rs.Cell<[rs.u8, rs.u8]>) as unknown) as Lent.Lent<[rs.u8, rs.u8]>; }); - const iter: rt.Iter> = rt.iterSlice(slots); + const iter: rs.Iter> = rs.iterSlice(slots); while (true) { - const _8: Lent.Lent<[rt.u8, rt.u8]> | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: Lent.Lent<[rs.u8, rs.u8]> | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } const uninit = _8; - rt.ptrWrite(uninit, Lent.new$mem_MaybeUninit_tuple2_u8_u8(([undefined, undefined] as unknown) as [rt.u8, rt.u8])); + rs.ptrWrite(uninit, Lent.new$mem_MaybeUninit_tuple2_u8_u8(([undefined, undefined] as unknown) as [rs.u8, rs.u8])); uninit; } return { filled: 0, slots }; } -export function slot(self: Segment, at: rt.usize): Lent.Lent<[rt.u8, rt.u8]> { +export function slot(self: Segment, at: rs.usize): Lent.Lent<[rs.u8, rs.u8]> { if (!(at < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + at); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + at); } return self.slots[at]; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Shelf.ts b/ts/fixtures/lang/pointers/expected/pointers.Shelf.ts index 400018237..b17b87384 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Shelf.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Shelf.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What holds an `Arc` a reference to it borrows through. */ export class Shelf { - _0: rt.Arc; + _0: rs.Arc; - constructor(_0: rt.Arc) { + constructor(_0: rs.Arc) { this._0 = _0; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Span.ts b/ts/fixtures/lang/pointers/expected/pointers.Span.ts index 8f1f6d246..270a6584f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Span.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Span.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Span { - range: [rt.u8, rt.u8]; + range: [rs.u8, rs.u8]; } //# sourceMappingURL=pointers.Span.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Spot.ts b/ts/fixtures/lang/pointers/expected/pointers.Spot.ts index d989450c1..62cb983d9 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Spot.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Spot.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$pointers_Spot } from "./lib.ts"; export function clone$Clone(self: Spot): Spot { @@ -9,8 +9,8 @@ export function clone$Clone(self: Spot): Spot { /** A struct nothing writes into, holding a pair nothing writes into either. */ export interface Spot { - at: [rt.u16, rt.u8]; - tag: rt.u8; + at: [rs.u16, rs.u8]; + tag: rs.u8; } //# sourceMappingURL=pointers.Spot.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Stable.ts b/ts/fixtures/lang/pointers/expected/pointers.Stable.ts index dc7dcef0b..61b648401 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Stable.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Stable.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -/** A struct JS keeps as an object, holding an `rt.Cell`. */ +/** A struct JS keeps as an object, holding an `rs.Cell`. */ export interface Stable { - _0: rt.Cell; + _0: rs.Cell; } //# sourceMappingURL=pointers.Stable.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Swapped.ts b/ts/fixtures/lang/pointers/expected/pointers.Swapped.ts index 3a2c6cee6..c2a79e999 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Swapped.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Swapped.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An `AtomicPtr` to `T`. */ export interface Swapped { - at: rt.Atomic>; + at: rs.Atomic>; } //# sourceMappingURL=pointers.Swapped.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.To.ts b/ts/fixtures/lang/pointers/expected/pointers.To.ts index 67270de10..ed676cdf9 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.To.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.To.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export type To = { tag: "At"; _0: rt.Ptr } | { tag: "Nowhere" }; +export type To = { tag: "At"; _0: rs.Ptr } | { tag: "Nowhere" }; //# sourceMappingURL=pointers.To.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Twin.ts b/ts/fixtures/lang/pointers/expected/pointers.Twin.ts index a567f134c..66034a954 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Twin.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Twin.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What two `Arc`s hold copies of, which nothing compares pointers to. */ export interface Twin { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.Twin.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Viewed.ts b/ts/fixtures/lang/pointers/expected/pointers.Viewed.ts index 46d8e217b..d00dd40ce 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Viewed.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Viewed.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Viewed { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } //# sourceMappingURL=pointers.Viewed.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Waiter.ts b/ts/fixtures/lang/pointers/expected/pointers.Waiter.ts index 4d3dcfb87..33393dd19 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Waiter.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Waiter.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A node a list links through an `AtomicPtr`, holding a cell it lends a pointer into, as * wasmtimer's timer nodes hold futures' `AtomicWaker`. */ export interface Waiter { - next: rt.Atomic; - enqueued: rt.Atomic; - slot: rt.Cell<[rt.u8, rt.u8]>; + next: rs.Atomic; + enqueued: rs.Atomic; + slot: rs.Cell<[rs.u8, rs.u8]>; } //# sourceMappingURL=pointers.Waiter.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts b/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts index 6a4ee0a68..4af08be45 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Waiters.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Waiter from "./pointers.Waiter.ts"; /** @@ -8,17 +8,17 @@ import type * as Waiter from "./pointers.Waiter.ts"; * `ArcList` keeps them, with the one popped last kept in memory too. */ export interface Waiters { - head: rt.Atomic; + head: rs.Atomic; last: Waiter.Waiter; } export function push(self: Waiters, waiter: Waiter.Waiter): void { b0: { - if (!rt.atomicSwap(waiter.enqueued, true, 4)) { - let head: Waiter.Waiter = rt.atomicLoad(self.head, 4); + if (!rs.atomicSwap(waiter.enqueued, true, 4)) { + let head: Waiter.Waiter = rs.atomicLoad(self.head, 4); while (true) { - rt.atomicStore(waiter.next, head, 4); - const _14: rt.Result = rt.atomicCompareExchange(self.head, head, waiter, 4, 4); + rs.atomicStore(waiter.next, head, 4); + const _14: rs.Result = rs.atomicCompareExchange(self.head, head, waiter, 4, 4); if (_14.ok) { break b0; } @@ -30,10 +30,10 @@ export function push(self: Waiters, waiter: Waiter.Waiter): void { export function pop(self: Waiters): boolean { const head: Waiter.Waiter = self.head.v; - if (!(head === rt.NULL)) { - const _6: Waiter.Waiter = rt.atomicLoad(head.next, 4); + if (!(head === rs.NULL)) { + const _6: Waiter.Waiter = rs.atomicLoad(head.next, 4); self.head.v = _6; - rt.atomicStore(head.enqueued, false, 4); + rs.atomicStore(head.enqueued, false, 4); self.last = head; return true; } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Window.ts b/ts/fixtures/lang/pointers/expected/pointers.Window.ts index d23668be4..f56f5440f 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Window.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Window.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Window { - at: rt.Ptr; + at: rs.Ptr; } //# sourceMappingURL=pointers.Window.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.Wrapped.ts b/ts/fixtures/lang/pointers/expected/pointers.Wrapped.ts index 7e89b7c28..393c31a63 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Wrapped.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Wrapped.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Held from "./pointers.Held.ts"; /** crossbeam-epoch's own wrapper over `UnsafeCell`, which lends its pointer to a closure. */ export class Wrapped { - _0: rt.Cell; + _0: rs.Cell; - constructor(_0: rt.Cell) { + constructor(_0: rs.Cell) { this._0 = _0; } @@ -17,14 +17,14 @@ export class Wrapped { } export function new$pointers_Held(value: Held.Held): Wrapped { - return new Wrapped(new rt.Cell(value)); + return new Wrapped(new rs.Cell(value)); } -export function with$pointers_Held_u8_pointers_cells_closure2(self: Wrapped, f: (a0: Held.Held) => rt.u8): rt.u8 { +export function with$pointers_Held_u8_pointers_cells_closure2(self: Wrapped, f: (a0: Held.Held) => rs.u8): rs.u8 { return f(self._0.v); } -export function with$pointers_Held_u8_pointers_cells_closure4(self: Wrapped, f: (a0: Held.Held) => rt.u8): rt.u8 { +export function with$pointers_Held_u8_pointers_cells_closure4(self: Wrapped, f: (a0: Held.Held) => rs.u8): rs.u8 { return f(self._0.v); } diff --git a/ts/fixtures/lang/pointers/expected/pointers.Written.ts b/ts/fixtures/lang/pointers/expected/pointers.Written.ts index 7f0c670b7..331c7f01c 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.Written.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.Written.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct JS keeps as an object that only [`part_written`] points into. */ export interface Written { - cell: rt.Cell; - tag: rt.u8; + cell: rs.Cell; + tag: rs.u8; } //# sourceMappingURL=pointers.Written.ts.map diff --git a/ts/fixtures/lang/pointers/expected/pointers.ts b/ts/fixtures/lang/pointers/expected/pointers.ts index 72ce89c42..328a111e0 100644 --- a/ts/fixtures/lang/pointers/expected/pointers.ts +++ b/ts/fixtures/lang/pointers/expected/pointers.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_pointers_Pair, copy$Option_tuple2_u16_u8, copy$array_ptr_array4_u8, copy$array_u16, copy$array_u8, copy$array_unit, copy$mem_MaybeUninit_array_u32, copy$mem_MaybeUninit_array_u8, copy$mem_MaybeUninit_tuple2_u8_u8, copy$pointers_Aimed_Cell_u8, copy$pointers_Aimed_array2_u16, copy$pointers_Aimed_array4_u8, copy$pointers_Aimed_pointers_Housed_u8, copy$pointers_Aimed_pointers_Leaning, copy$pointers_Aimed_pointers_Paired, copy$pointers_Aimed_u8, copy$pointers_ByCall, copy$pointers_ByClosure, copy$pointers_ByObject, copy$pointers_Duo, copy$pointers_Halves, copy$pointers_Outer, copy$pointers_Pair, copy$pointers_Spot, copy$pointers_Twin, copy$tuple2_array2_u32_u8, copy$tuple2_u16_u8, copy$tuple2_u32_u32, copy$tuple2_u8_u8, drop$pointers_List_String, drop$pointers_List_sync_Arc_u8, drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin, drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit, drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin, of$pointers_Bin_pointers_ByObject } from "./lib.ts"; -import { then$1vx3p6m, then$04p7jmh, then$1d2br9m } from "./core/bool.ts"; -import { isSomeAnd$09tpccf, isSomeAnd$0h2dqit, isSomeAnd$10niqnm, unwrapOr$0mkoact as option_unwrapOr$0mkoact, unwrapOr$1l4p6jc as option_unwrapOr$1l4p6jc, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1cfrse5 as option_map$1cfrse5, mapOr$1j1wsle as option_mapOr$1j1wsle, mapOr$00zno7m as option_mapOr$00zno7m, mapOr$1wxcg5q as option_mapOr$1wxcg5q, filter$0tnmmii } from "./core/option.ts"; +import { then$0bgt67i, then$1a5xgoh, then$0jw3xip } from "./core/bool.ts"; +import { isSomeAnd$1s2u5lz, isSomeAnd$1nosv3e, isSomeAnd$07atiew, unwrapOr$0mkoact as option_unwrapOr$0mkoact, unwrapOr$179xo1w as option_unwrapOr$179xo1w, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1cfrse5 as option_map$1cfrse5, mapOr$078vnqn as option_mapOr$078vnqn, mapOr$00zno7m as option_mapOr$00zno7m, mapOr$173j2gr as option_mapOr$173j2gr, filter$0wvwd70 } from "./core/option.ts"; import type * as Aimed from "./pointers.Aimed.ts"; import * as Bin from "./pointers.Bin.ts"; import type * as ByCall from "./pointers.ByCall.ts"; @@ -58,13 +58,13 @@ export function attachBefore$String(node: Node.Node, at: Node.Node>, at: Node.Node>): void { - const _3: Links.Links> = { next: at, prev: at.link.at4 }; - const _8: Node.Node> = node; +export function attachBefore$sync_Arc_u8(node: Node.Node>, at: Node.Node>): void { + const _3: Links.Links> = { next: at, prev: at.link.at4 }; + const _8: Node.Node> = node; _8.link.at0 = _3.next; _8.link.at4 = _3.prev; at.link.at4 = node; - (node.link.at4.link.at0 as Node.Node>) = node; + (node.link.at4.link.at0 as Node.Node>) = node; } export function detach$String(node: Node.Node): void { @@ -72,61 +72,61 @@ export function detach$String(node: Node.Node): void { (node.link.at0 as Node.Node).link.at4 = node.link.at4; } -export function detach$sync_Arc_u8(node: Node.Node>): void { - (node.link.at4.link.at0 as Node.Node>) = node.link.at0 as Node.Node>; - (node.link.at0 as Node.Node>).link.at4 = node.link.at4; +export function detach$sync_Arc_u8(node: Node.Node>): void { + (node.link.at4.link.at0 as Node.Node>) = node.link.at0 as Node.Node>; + (node.link.at0 as Node.Node>).link.at4 = node.link.at4; } /** * Steps on a list of the operation and key each pair of bytes picks, putting what each * finds and then the list in order. */ -export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { const list: List.List = List.new$String(); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const key: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const key: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const _13: [rt.u8, rt.u8] = [op, rt.u8Rem(key, 8)]; - const op2: rt.u8 = op; - const key2: rt.u8 = _13[1]; - const _18: rt.u8 = rt.u8Rem(op2, 4); + const _13: [rs.u8, rs.u8] = [op, rs.u8Rem(key, 8)]; + const op2: rs.u8 = op; + const key2: rs.u8 = _13[1]; + const _18: rs.u8 = rs.u8Rem(op2, 4); if (_18 === 0) { - const _26: rt.usize = rt.u8Rem(op2, 3) as rt.usize; + const _26: rs.usize = rs.u8Rem(op2, 3) as rs.usize; if (!(_26 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _26); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _26); } List.pushBack$String(list, key2, ["", "v", "vv"][_26]); } else if (_18 === 1) { - const _30: [rt.u8, string] | undefined = List.remove$String(list, key2); + const _30: [rs.u8, string] | undefined = List.remove$String(list, key2); if (_30 === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - const k: rt.u8 = _30[0]; + const k: rs.u8 = _30[0]; const v: string = _30[1]; - rt.byteVecPush(out, k); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(v)); + rs.byteVecPush(out, k); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(v)); } } else if (_18 === 2) { - rt.byteVecPush(out, List.toFront$String(list, key2) ? 1 : 0); + rs.byteVecPush(out, List.toFront$String(list, key2) ? 1 : 0); } else { - const _42: rt.Place | undefined = List.getMut$String(list, key2); + const _42: rs.Place | undefined = List.getMut$String(list, key2); if (_42 === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { _42.v = _42.v + "w"; } } } - rt.byteVecPush(out, list.len & 0xff); + rs.byteVecPush(out, list.len & 0xff); List.each$String(list, out); drop$pointers_List_String(list); } @@ -135,42 +135,42 @@ export function lists(dataData: Uint8Array, dataStart: number, dataLen: number, * Steps on a list of shared counts, putting how many hold the one each push clones * while the list lives, and after it drops. */ -export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const held: rt.Arc = new rt.Arc(0); - const list: List.List> = List.new$sync_Arc_u8(); +export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const held: rs.Arc = new rs.Arc(0); + const list: List.List> = List.new$sync_Arc_u8(); let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const key: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const key: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const _13: [rt.u8, rt.u8] = [op, rt.u8Rem(key, 4)]; - const op2: rt.u8 = op; - const key2: rt.u8 = _13[1]; - const _19: rt.u8 = rt.u8Rem(op2, 3); + const _13: [rs.u8, rs.u8] = [op, rs.u8Rem(key, 4)]; + const op2: rs.u8 = op; + const key2: rs.u8 = _13[1]; + const _19: rs.u8 = rs.u8Rem(op2, 3); if (_19 === 0) { - const _22: rt.Arc = rt.arcClone(held); + const _22: rs.Arc = rs.arcClone(held); List.pushBack$sync_Arc_u8(list, key2, _22); } else if (_19 === 1) { - rt.byteVecPush(out, option_mapOr$1wxcg5q(List.remove$sync_Arc_u8(list, key2), 255, (_2: [rt.u8, rt.Arc]): rt.u8 => { - const v: rt.Arc = _2[1]; - const _0: rt.u8 = v.value; + rs.byteVecPush(out, option_mapOr$173j2gr(List.remove$sync_Arc_u8(list, key2), 255, (_2: [rs.u8, rs.Arc]): rs.u8 => { + const v: rs.Arc = _2[1]; + const _0: rs.u8 = v.value; v[Symbol.dispose](); return _0; })); } else { - rt.byteVecPush(out, List.toFront$sync_Arc_u8(list, key2) ? 1 : 0); + rs.byteVecPush(out, List.toFront$sync_Arc_u8(list, key2) ? 1 : 0); } - rt.byteVecPush(out, held.strong & 0xff); + rs.byteVecPush(out, held.strong & 0xff); } drop$pointers_List_sync_Arc_u8(list); - rt.byteVecPush(out, held.strong & 0xff); + rs.byteVecPush(out, held.strong & 0xff); held[Symbol.dispose](); } @@ -178,24 +178,24 @@ export function shared(dataData: Uint8Array, dataStart: number, dataLen: number, * Pointers to numbers, to a field, to a whole struct, and to bytes: read, written, * swapped, replaced with the old value read or not, compared, and null. */ -export function places(data: rt.ByteSlice, out: rt.ByteVec): void { - let _31!: rt.Place; - let _52!: rt.u8; - let x: rt.u32 = 0; - let y: rt.u32 = 1; +export function places(data: rs.ByteSlice, out: rs.ByteVec): void { + let _31!: rs.Place; + let _52!: rs.u8; + let x: rs.u32 = 0; + let y: rs.u32 = 1; const pair: Pair.Pair = { a: 2, b: 3 }; - const px: rt.Place = rt.place(() => x, (value) => x = value); - const py: rt.Place = rt.place(() => y, (value2) => y = value2); - const pa: rt.Place = rt.place(() => pair.a, (value3) => pair.a = value3); + const px: rs.Place = rs.place(() => x, (value) => x = value); + const py: rs.Place = rs.place(() => y, (value2) => y = value2); + const pa: rs.Place = rs.place(() => pair.a, (value3) => pair.a = value3); const pp: Pair.Pair = pair; - let held: rt.Place = rt.NULL; - const bytes: Uint8Array = rt.bytes(2); - const pb: rt.ByteSlice = rt.byteSliceFrom(bytes); - for (const byte of rt.byteSliceView(data)) { - const v: rt.u32 = byte as rt.u32; - const _21: rt.u8 = rt.u8Rem(byte, 12); + let held: rs.Place = rs.NULL; + const bytes: Uint8Array = rs.bytes(2); + const pb: rs.ByteSlice = rs.byteSliceFrom(bytes); + for (const byte of rs.byteSliceView(data)) { + const v: rs.u32 = byte as rs.u32; + const _21: rs.u8 = rs.u8Rem(byte, 12); if (_21 === 0) { - px.v = rt.u32Add(px.v, v); + px.v = rs.u32Add(px.v, v); } else if (_21 === 1) { py.v = v; } else if (_21 === 2) { @@ -208,12 +208,12 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { const pointer4 = pa; const old5 = pointer4.v; pointer4.v = v; - rt.byteVecPush(out, old5 & 0xff); + rs.byteVecPush(out, old5 & 0xff); } else if (_21 === 4) { pp.b = v; } else if (_21 === 5) { const old: Pair.Pair = copy$pointers_Pair(pp); - rt.ptrWrite(pp, { a: old.b, b: old.a }); + rs.ptrWrite(pp, { a: old.b, b: old.a }); } else if (_21 === 6) { if (!((byte & 1) === 0)) { _31 = pa; @@ -222,67 +222,67 @@ export function places(data: rt.ByteSlice, out: rt.ByteVec): void { } held = _31; } else if (_21 === 7) { - rt.byteVecPush(out, (held === rt.NULL ? 1 : 0) | (((pp === pair ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (held === rs.NULL ? 1 : 0) | (((pp === pair ? 1 : 0) << 1) & 0xff)); } else if (_21 === 9) { const pointer3 = pa; const old4 = pointer3.v; pointer3.v = v; old4; } else if (_21 === 10) { - const _46: Pair.Pair = { a: v, b: rt.u32Add(v, 1) }; + const _46: Pair.Pair = { a: v, b: rs.u32Add(v, 1) }; const pointer2 = pp; const old3 = copy$pointers_Pair(pointer2); - rt.ptrWrite(pointer2, _46); + rs.ptrWrite(pointer2, _46); old3; } else if (_21 === 11) { const pointer = pb; - const old2 = rt.byteSliceToArray(pointer); - rt.byteSliceSet(pointer, Uint8Array.of(byte, ~byte & 0xff)); + const old2 = rs.byteSliceToArray(pointer); + rs.byteSliceSet(pointer, Uint8Array.of(byte, ~byte & 0xff)); old2; } else { - if (!(held === rt.NULL)) { + if (!(held === rs.NULL)) { _52 = held.v & 0xff; } else { _52 = 255; } - rt.byteVecPush(out, _52); + rs.byteVecPush(out, _52); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x & 0xff, y & 0xff, pair.a & 0xff, pair.b & 0xff, bytes[0], bytes[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x & 0xff, y & 0xff, pair.a & 0xff, pair.b & 0xff, bytes[0], bytes[1]))); } /** * Unchecked indexing, a boxed number behind a pointer, a `MaybeUninit` number, and a * value dropped in place. */ -export function unchecked(data: rt.ByteSlice, out: rt.ByteVec): void { - const counts: rt.u32[] = Array.from({ length: 4 }, (): rt.u32 => { +export function unchecked(data: rs.ByteSlice, out: rs.ByteVec): void { + const counts: rs.u32[] = Array.from({ length: 4 }, (): rs.u32 => { return 0; }); - const boxed: rt.Place = { v: 0 }; - let slot: rt.u32 = (undefined as unknown) as rt.u32; - const uninit = rt.place(() => slot, (value) => slot = value); + const boxed: rs.Place = { v: 0 }; + let slot: rs.u32 = (undefined as unknown) as rs.u32; + const uninit = rs.place(() => slot, (value) => slot = value); uninit.v = 7; uninit; - const held: rt.Arc = new rt.Arc(0); - const dropped: rt.Arc = rt.arcClone(held); - for (const byte of rt.byteSliceView(data)) { - const at: rt.usize = rt.u8Rem(byte, 4) as rt.usize; - const _23: rt.u32[] = counts; - const at2 = rt.idx(_23, at); - _23[at2] = rt.u32Add(_23[at2], 1); - boxed.v = rt.u32Add(boxed.v, byte as rt.u32); - const _28: rt.u32 = byte as rt.u32; - const _29: rt.Place = rt.place(() => slot, (value2) => slot = value2); + const held: rs.Arc = new rs.Arc(0); + const dropped: rs.Arc = rs.arcClone(held); + for (const byte of rs.byteSliceView(data)) { + const at: rs.usize = rs.u8Rem(byte, 4) as rs.usize; + const _23: rs.u32[] = counts; + const at2 = rs.idx(_23, at); + _23[at2] = rs.u32Add(_23[at2], 1); + boxed.v = rs.u32Add(boxed.v, byte as rs.u32); + const _28: rs.u32 = byte as rs.u32; + const _29: rs.Place = rs.place(() => slot, (value2) => slot = value2); _29.v = (_29.v ^ _28) >>> 0; - const _35: rt.u32[] = counts; - rt.byteVecPush(out, _35[rt.idx(_35, at)] & 0xff); + const _35: rs.u32[] = counts; + rs.byteVecPush(out, _35[rs.idx(_35, at)] & 0xff); } - rt.byteVecPush(out, boxed.v & 0xff); - rt.byteVecPush(out, slot & 0xff); - rt.byteVecPush(out, held.strong & 0xff); + rs.byteVecPush(out, boxed.v & 0xff); + rs.byteVecPush(out, slot & 0xff); + rs.byteVecPush(out, held.strong & 0xff); dropped[Symbol.dispose](); - rt.byteVecPush(out, held.strong & 0xff); + rs.byteVecPush(out, held.strong & 0xff); held[Symbol.dispose](); } @@ -290,85 +290,85 @@ export function unchecked(data: rt.ByteSlice, out: rt.ByteVec): void { * Pointers to the parts of a struct kept as objects: initialized one by one from nothing, * written through the struct's pointer and their own, and read out before a write. */ -export function nested(data: rt.ByteSlice, out: rt.ByteVec): void { +export function nested(data: rs.ByteSlice, out: rs.ByteVec): void { const slot: Outer.Outer = ({ inner: { a: undefined, b: undefined }, pair: [undefined, undefined], n: undefined } as unknown) as Outer.Outer; const p: Outer.Outer = slot; - const _8: [Inner.Inner, [rt.u32, rt.u32]] = [p.inner, p.pair]; + const _8: [Inner.Inner, [rs.u32, rs.u32]] = [p.inner, p.pair]; const inner: Inner.Inner = _8[0]; - const pair: [rt.u32, rt.u32] = _8[1]; - rt.ptrWrite(inner, { a: 1, b: 2 }); - rt.ptrWrite(pair, [3, 4] as [rt.u32, rt.u32]); + const pair: [rs.u32, rs.u32] = _8[1]; + rs.ptrWrite(inner, { a: 1, b: 2 }); + rs.ptrWrite(pair, [3, 4] as [rs.u32, rs.u32]); p.n = 5; - for (const byte of rt.byteSliceView(data)) { - const v: rt.u32 = byte as rt.u32; - const _25: rt.u8 = rt.u8Rem(byte, 6); + for (const byte of rs.byteSliceView(data)) { + const v: rs.u32 = byte as rs.u32; + const _25: rs.u8 = rs.u8Rem(byte, 6); if (_25 === 0) { p.inner.a = v; } else if (_25 === 1) { - rt.ptrWrite(inner, { a: v, b: inner.a }); + rs.ptrWrite(inner, { a: v, b: inner.a }); } else if (_25 === 2) { - pair[1] = rt.u32Add(pair[1], v); + pair[1] = rs.u32Add(pair[1], v); } else if (_25 === 3) { const old: Outer.Outer = copy$pointers_Outer(p); inner.b = v; - rt.byteVecPush(out, old.inner.b & 0xff); + rs.byteVecPush(out, old.inner.b & 0xff); } else if (_25 === 4) { - const old2: [rt.u32, rt.u32] = copy$tuple2_u32_u32(pair); + const old2: [rs.u32, rs.u32] = copy$tuple2_u32_u32(pair); p.pair[0] = v; - rt.byteVecPush(out, old2[0] & 0xff); + rs.byteVecPush(out, old2[0] & 0xff); } else { - rt.byteVecPush(out, (inner.a & 0xff) ^ (pair[0] & 0xff)); + rs.byteVecPush(out, (inner.a & 0xff) ^ (pair[0] & 0xff)); } } const outer: Outer.Outer = slot; const inner2: Inner.Inner = outer.inner; - const pair2: [rt.u32, rt.u32] = outer.pair; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(inner2.a & 0xff, inner2.b & 0xff, pair2[0] & 0xff, pair2[1] & 0xff, outer.n & 0xff))); + const pair2: [rs.u32, rs.u32] = outer.pair; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(inner2.a & 0xff, inner2.b & 0xff, pair2[0] & 0xff, pair2[1] & 0xff, outer.n & 0xff))); } /** * Copies of a `MaybeUninit` and of a union holding arrays, each changed after, and values * read out through pointers before what they point at changes. */ -export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const _5 of rt.byteSliceView(data)) { - const v: rt.u32 = _5 as rt.u32; - const x: rt.u32[] = copy$mem_MaybeUninit_array_u32(Array.from({ length: 4 }, (): rt.u32 => { +export function copies(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const _5 of rs.byteSliceView(data)) { + const v: rs.u32 = _5 as rs.u32; + const x: rs.u32[] = copy$mem_MaybeUninit_array_u32(Array.from({ length: 4 }, (): rs.u32 => { return v; })); - const y: rt.u32[] = copy$mem_MaybeUninit_array_u32(x); - const _16: rt.u32 = (v ^ 1) >>> 0; + const y: rs.u32[] = copy$mem_MaybeUninit_array_u32(x); + const _16: rs.u32 = (v ^ 1) >>> 0; const uninit = x; - rt.ptrWrite(uninit, Array.from({ length: 4 }, (): rt.u32 => { + rs.ptrWrite(uninit, Array.from({ length: 4 }, (): rs.u32 => { return _16; })); uninit; - const h: Halves.Halves = ({ at0: [v, rt.u32Add(v, 1)] } as unknown) as Halves.Halves; + const h: Halves.Halves = ({ at0: [v, rs.u32Add(v, 1)] } as unknown) as Halves.Halves; const g: Halves.Halves = copy$pointers_Halves(h); - g.at0[0] = rt.u32Add(v, 2); + g.at0[0] = rs.u32Add(v, 2); let held: Pair.Pair | undefined = { a: v, b: 0 }; - const p: rt.Place = rt.place(() => held, (value) => held = value); + const p: rs.Place = rs.place(() => held, (value) => held = value); const old: Pair.Pair | undefined = copy$Option_pointers_Pair(p.v); if (p.v !== undefined) { - p.v.a = rt.u32Add(v, 3); + p.v.a = rs.u32Add(v, 3); } - const _35: [rt.u8, rt.u8] = snapshot(v); - const before: rt.u8 = _35[0]; - const after: rt.u8 = _35[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(y[0] & 0xff, x[0] & 0xff, h.at0[0] & 0xff, g.at0[0] & 0xff, option_mapOr$1j1wsle(old, 0, (o: Pair.Pair): rt.u8 => { + const _35: [rs.u8, rs.u8] = snapshot(v); + const before: rs.u8 = _35[0]; + const after: rs.u8 = _35[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(y[0] & 0xff, x[0] & 0xff, h.at0[0] & 0xff, g.at0[0] & 0xff, option_mapOr$078vnqn(old, 0, (o: Pair.Pair): rs.u8 => { return o.a & 0xff; - }), option_mapOr$1j1wsle(copy$Option_pointers_Pair(held), 0, (o2: Pair.Pair): rt.u8 => { + }), option_mapOr$078vnqn(copy$Option_pointers_Pair(held), 0, (o2: Pair.Pair): rs.u8 => { return o2.a & 0xff; }), before, after))); } } /** What a pointer to a tuple holding an array reads, and what the tuple holds after. */ -export function snapshot(v: rt.u32): [rt.u8, rt.u8] { - const nest: [rt.u32[], rt.u8] = [[v, 1], 0]; - const before: [rt.u32[], rt.u8] = copy$tuple2_array2_u32_u8(nest); - nest[0][0] = rt.u32Add(v, 4); - return [before[0][0] & 0xff, nest[0][0] & 0xff] as [rt.u8, rt.u8]; +export function snapshot(v: rs.u32): [rs.u8, rs.u8] { + const nest: [rs.u32[], rs.u8] = [[v, 1], 0]; + const before: [rs.u32[], rs.u8] = copy$tuple2_array2_u32_u8(nest); + nest[0][0] = rs.u32Add(v, 4); + return [before[0][0] & 0xff, nest[0][0] & 0xff] as [rs.u8, rs.u8]; } /** @@ -376,34 +376,34 @@ export function snapshot(v: rt.u32): [rt.u8, rt.u8] { * `as_ref`, and `()` written through a dangling pointer; and values of no bytes read * through dangling pointers. */ -export function sentinels(data: rt.ByteSlice, out: rt.ByteVec): void { - let p!: rt.Place; - let _19!: rt.u8; - for (const byte of rt.byteSliceView(data)) { - let some: rt.u32 | undefined = filter$0tnmmii(byte as rt.u32, (v: rt.u32): boolean => { - return rt.u32Rem(v, 2) === 0; +export function sentinels(data: rs.ByteSlice, out: rs.ByteVec): void { + let p!: rs.Place; + let _19!: rs.u8; + for (const byte of rs.byteSliceView(data)) { + let some: rs.u32 | undefined = filter$0wvwd70(byte as rs.u32, (v: rs.u32): boolean => { + return rs.u32Rem(v, 2) === 0; }); - if (rt.u8Rem(byte, 3) === 0) { - p = rt.NULL; + if (rs.u8Rem(byte, 3) === 0) { + p = rs.NULL; } else { - p = rt.place(() => some, (value) => some = value); + p = rs.place(() => some, (value) => some = value); } const pointer = p; - const _20: rt.u32 | undefined | rt.None = pointer === rt.NULL ? rt.None : pointer.v; - if (_20 === rt.None) { + const _20: rs.u32 | undefined | rs.None = pointer === rs.NULL ? rs.None : pointer.v; + if (_20 === rs.None) { _19 = 0; } else if (_20 === undefined) { _19 = 1; } else { - _19 = rt.u8Add(2, rt.u32Rem(_20, 100) & 0xff); + _19 = rs.u8Add(2, rs.u32Rem(_20, 100) & 0xff); } - rt.byteVecPush(out, _19); + rs.byteVecPush(out, _19); const pointer2 = p; - rt.byteVecPush(out, (pointer2 === rt.NULL ? rt.None : pointer2.v) === rt.None ? 1 : 0); + rs.byteVecPush(out, (pointer2 === rs.NULL ? rs.None : pointer2.v) === rs.None ? 1 : 0); const units: undefined[] = (new Array(2) as unknown) as undefined[]; copy$array_unit(units); - rt.byteVecPush(out, rt.iterCount(rt.iterSlice([undefined, undefined])) & 0xff); - rt.byteVecPush(out, units.length & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterSlice([undefined, undefined])) & 0xff); + rs.byteVecPush(out, units.length & 0xff); } } @@ -412,108 +412,108 @@ export function sentinels(data: rt.ByteSlice, out: rt.ByteVec): void { * through `get` and `get_mut`, read through another `get` and before a write, assigned * through `get`, which drops what each held, replaced whole, and their values taken out. */ -export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { - const count: rt.Arc = new rt.Arc(undefined); - let num: rt.Cell = new rt.Cell(4294967295 - 1); - const pair: rt.Cell = new rt.Cell({ _0: 0, _1: 255 }); - let text: rt.Cell = new rt.Cell(""); - const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new Held.Held(0, rt.arcClone(count))); - for (const op of rt.byteSliceView(data)) { - const n: rt.u8 = rt.u8Div(op, 8); - const _23: rt.u8 = rt.u8Rem(op, 8); +export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { + const count: rs.Arc = new rs.Arc(undefined); + let num: rs.Cell = new rs.Cell(4294967295 - 1); + const pair: rs.Cell = new rs.Cell({ _0: 0, _1: 255 }); + let text: rs.Cell = new rs.Cell(""); + const held: Wrapped.Wrapped = Wrapped.new$pointers_Held(new Held.Held(0, rs.arcClone(count))); + for (const op of rs.byteSliceView(data)) { + const n: rs.u8 = rs.u8Div(op, 8); + const _23: rs.u8 = rs.u8Rem(op, 8); if (_23 === 0) { - const before: rt.u32 = num.v; - const _32: rt.u32 = rt.u32WrappingAdd(num.v, ((n as rt.u32) << 26) >>> 0); + const before: rs.u32 = num.v; + const _32: rs.u32 = rs.u32WrappingAdd(num.v, ((n as rs.u32) << 26) >>> 0); num.v = _32; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(before).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(before).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(num.v).reverse()), undefined, true); } else if (_23 === 1) { - const _46: rt.u32 = n as rt.u32; - const _47: rt.Place = num; + const _46: rs.u32 = n as rs.u32; + const _47: rs.Place = num; _47.v = (_47.v ^ _46) >>> 0; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(num.v).reverse()), undefined, true); } else if (_23 === 2) { const before2: Duo.Duo = copy$pointers_Duo(pair.v); pair.v._0 = n; const between: Duo.Duo = copy$pointers_Duo(pair.v); const p: Duo.Duo = pair.v; - rt.ptrWrite(p, { _0: p._1, _1: p._0 }); + rs.ptrWrite(p, { _0: p._1, _1: p._0 }); const _67: Duo.Duo = pair.v; _67._1 = _67._1 ^ 128; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(before2._0, before2._1, between._0, between._1, pair.v._0, pair.v._1)), undefined, true); } else if (_23 === 3) { - const _83: rt.Place = text; - _83.v = _83.v + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(n, 26)) as rt.char); - const _91: rt.Place = text; + const _83: rs.Place = text; + _83.v = _83.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(n, 26)) as rs.char); + const _91: rs.Place = text; _91.v = _91.v + "!"; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); } else if (_23 === 4) { - const _99: rt.Arc = rt.arcClone(count); + const _99: rs.Arc = rs.arcClone(count); const fresh: Held.Held = new Held.Held(n, _99); - if (rt.u8Rem(n, 2) === 0) { + if (rs.u8Rem(n, 2) === 0) { const captured2 = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rt.closure((p6: Held.Held): undefined => { + Wrapped.withMut$pointers_Held_unit_pointers_cells_closure0(held, rs.closure((p6: Held.Held): undefined => { const _311: Held.Held = captured2; p6[Symbol.dispose](); - rt.ptrWrite(p6, _311); + rs.ptrWrite(p6, _311); }, (): void => { captured2[Symbol.dispose](); })); } else { const captured = fresh; - Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rt.closure((p5: Held.Held): undefined => { - rt.ptrWrite(p5, captured); + Wrapped.withMut$pointers_Held_unit_pointers_cells_closure1(held, rs.closure((p5: Held.Held): undefined => { + rs.ptrWrite(p5, captured); }, (): void => { captured[Symbol.dispose](); })); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: Held.Held): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(Wrapped.with$pointers_Held_u8_pointers_cells_closure2(held, (p7: Held.Held): rs.u8 => { return p7.n; }), count.strong & 0xff)), undefined, true); } else if (_23 === 5) { Wrapped.withMut$pointers_Held_unit_pointers_cells_closure3(held, (p3: Held.Held): undefined => { - p3.n = rt.u8WrappingAdd(p3.n, n); + p3.n = rs.u8WrappingAdd(p3.n, n); }); const _119: Held.Held = held._0.v; _119.n = _119.n ^ 1; - rt.byteVecPush(out, Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: Held.Held): rt.u8 => { + rs.byteVecPush(out, Wrapped.with$pointers_Held_u8_pointers_cells_closure4(held, (p4: Held.Held): rs.u8 => { return p4.n; })); } else if (_23 === 6) { - const _126: rt.Cell = new rt.Cell(n as rt.u32); + const _126: rs.Cell = new rs.Cell(n as rs.u32); const old3 = num; num = _126; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(old3.v).reverse()), undefined, true); - const _133: rt.Cell = new rt.Cell(rt.fmtToString((f: rt.Formatter) => rt.u8Display(n, f))); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(old3.v).reverse()), undefined, true); + const _133: rs.Cell = new rs.Cell(rs.fmtToString((f: rs.Formatter) => rs.u8Display(n, f))); const old4 = text; text = _133; - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(old4.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(old4.v))), undefined, true); const _140: Duo.Duo = { _0: n, _1: ~n & 0xff }; Object.assign(pair.v, _140); } else { - const _146: rt.Arc = rt.arcClone(count); + const _146: rs.Arc = rs.arcClone(count); const made: Wrapped.Wrapped = Wrapped.new$pointers_Held(new Held.Held(n, _146)); Wrapped.withMut$pointers_Held_unit_pointers_cells_closure5(made, (p2: Held.Held): undefined => { p2.n = p2.n ^ 85; }); - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); const made2: Held.Held = made._0.v; - rt.byteVecPush(out, made2.n); + rs.byteVecPush(out, made2.n); made2[Symbol.dispose](); - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(num.v).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(num.v).reverse()), undefined, true); const _169: Duo.Duo = pair.v; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_169._0, _169._1)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(text.v))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_169._0, _169._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(text.v))), undefined, true); held[Symbol.dispose](); - rt.byteVecPush(out, count.strong & 0xff); + rs.byteVecPush(out, count.strong & 0xff); count[Symbol.dispose](); } -export function renewNum(cell: rt.Cell, value: rt.u32): rt.u32 { - return rt.replaceIn(cell, new rt.Cell(value)).v; +export function renewNum(cell: rs.Cell, value: rs.u32): rs.u32 { + return rs.replaceIn(cell, new rs.Cell(value)).v; } /** @@ -524,42 +524,42 @@ export function renewNum(cell: rt.Cell, value: rt.u32): rt.u32 { * one to a part a `&mut` given as `mem::replace`'s value borrows, which it leaves be; * and one through a reference `mem::replace` pointed elsewhere first. */ -export function rebound(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(n, 7); +export function rebound(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(n, 7); if (_10 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(replacedBefore(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(replacedBefore(n)), undefined, true); } else if (_10 === 6) { - rt.iterExtendBytes(out, rt.iterSlice(retargeted(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(retargeted(n)), undefined, true); } else if (_10 === 5) { - rt.iterExtendBytes(out, rt.iterSlice(lentAsValue(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(lentAsValue(n)), undefined, true); } else if (_10 === 1) { - rt.iterExtendBytes(out, rt.iterSlice(partsReplaced(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(partsReplaced(n)), undefined, true); } else if (_10 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(writtenInPlace(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(writtenInPlace(n)), undefined, true); } else if (_10 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(cellWrittenInPlace(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(cellWrittenInPlace(n)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(borrowedThrough(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(borrowedThrough(n)), undefined, true); } } } -export function replacedBefore(n: rt.u8): Uint8Array { - let pair: [rt.u8, rt.u8] = [n, ~n & 0xff]; +export function replacedBefore(n: rs.u8): Uint8Array { + let pair: [rs.u8, rs.u8] = [n, ~n & 0xff]; const old2 = pair; - pair = [n ^ 1, n] as [rt.u8, rt.u8]; - const old: [rt.u8, rt.u8] = old2; - const p: [rt.u8, rt.u8] = pair; + pair = [n ^ 1, n] as [rs.u8, rs.u8]; + const old: [rs.u8, rs.u8] = old2; + const p: [rs.u8, rs.u8] = pair; p[1] = p[1] ^ old[0]; return Uint8Array.of(pair[0], pair[1]); } -export function lentAsValue(n: rt.u8): Uint8Array { - const span: Span.Span = { range: [n, ~n & 0xff] as [rt.u8, rt.u8] }; - const other: [rt.u8, rt.u8] = [0, 0]; - let r: [rt.u8, rt.u8] = other; - const p: [rt.u8, rt.u8] = span.range; +export function lentAsValue(n: rs.u8): Uint8Array { + const span: Span.Span = { range: [n, ~n & 0xff] as [rs.u8, rs.u8] }; + const other: [rs.u8, rs.u8] = [0, 0]; + let r: [rs.u8, rs.u8] = other; + const p: [rs.u8, rs.u8] = span.range; const old2 = r; r = span.range; old2[0] = n ^ 1; @@ -567,23 +567,23 @@ export function lentAsValue(n: rt.u8): Uint8Array { return Uint8Array.of(p[0], p[1], other[0], span.range[0]); } -export function retargeted(n: rt.u8): Uint8Array { - let a: [rt.u8, rt.u8] = [n, ~n & 0xff]; - const b: [rt.u8, rt.u8] = [n ^ 5, n]; - let r: [rt.u8, rt.u8] = a; +export function retargeted(n: rs.u8): Uint8Array { + let a: [rs.u8, rs.u8] = [n, ~n & 0xff]; + const b: [rs.u8, rs.u8] = [n ^ 5, n]; + let r: [rs.u8, rs.u8] = a; r = b; - const p: [rt.u8, rt.u8] = r; - a = [0, 0] as [rt.u8, rt.u8]; + const p: [rs.u8, rs.u8] = r; + a = [0, 0] as [rs.u8, rs.u8]; return Uint8Array.of(p[0] ^ a[0], p[1]); } -export function partsReplaced(n: rt.u8): Uint8Array { - const pair: [rt.u8, rt.u8] = [n, ~n & 0xff]; - const p: [rt.u8, rt.u8] = pair; - const _7: rt.u8 = rt.u8WrappingAdd(n, 1); +export function partsReplaced(n: rs.u8): Uint8Array { + const pair: [rs.u8, rs.u8] = [n, ~n & 0xff]; + const p: [rs.u8, rs.u8] = pair; + const _7: rs.u8 = rs.u8WrappingAdd(n, 1); const old2 = pair[0]; pair[0] = _7; - const old: rt.u8 = old2; + const old: rs.u8 = old2; const swapped = pair[0]; pair[0] = pair[1]; pair[1] = swapped; @@ -592,7 +592,7 @@ export function partsReplaced(n: rt.u8): Uint8Array { return Uint8Array.of(p[0], p[1], old, taken2); } -export function writtenInPlace(n: rt.u8): Uint8Array { +export function writtenInPlace(n: rs.u8): Uint8Array { const a: Duo.Duo = { _0: n, _1: 1 }; const b: Duo.Duo = { _0: 2, _1: n }; const p: Duo.Duo = a; @@ -604,38 +604,38 @@ export function writtenInPlace(n: rt.u8): Uint8Array { return Uint8Array.of(between._0, between._1, swapped._0, swapped._1, p._0, p._1); } -export function cellWrittenInPlace(n: rt.u8): Uint8Array { - const cell: rt.Cell = new rt.Cell(((n as rt.u32) << 9) >>> 0); - const p: rt.Place = cell; - const old: rt.u32 = renewNum(cell, rt.u32Add(n as rt.u32, 7)); +export function cellWrittenInPlace(n: rs.u8): Uint8Array { + const cell: rs.Cell = new rs.Cell(((n as rs.u32) << 9) >>> 0); + const p: rs.Place = cell; + const old: rs.u32 = renewNum(cell, rs.u32Add(n as rs.u32, 7)); return Uint8Array.of(old & 0xff, (old >>> 9) & 0xff, p.v & 0xff, (clear(cell) & 0xff) ^ (p.v & 0xff)); } -export function borrowedThrough(n: rt.u8): Uint8Array { +export function borrowedThrough(n: rs.u8): Uint8Array { let d: Duo.Duo = { _0: n, _1: ~n & 0xff }; - const first: rt.u8 = flipped(d); + const first: rs.u8 = flipped(d); d = { _0: d._1, _1: d._0 }; return Uint8Array.of(first, d._0, d._1); } export function renew(at: Duo.Duo, value: Duo.Duo): Duo.Duo { - return rt.replaceIn(at, copy$pointers_Duo(value)); + return rs.replaceIn(at, copy$pointers_Duo(value)); } export function exchange(a: Duo.Duo, b: Duo.Duo): void { - Object.assign(a, rt.replaceIn(b, a)); + Object.assign(a, rs.replaceIn(b, a)); } export function assign(at: Duo.Duo, value: Duo.Duo): void { Object.assign(at, copy$pointers_Duo(value)); } -export function clear(cell: rt.Cell): rt.u32 { - return rt.replaceIn(cell, new rt.Cell(0)).v; +export function clear(cell: rs.Cell): rs.u32 { + return rs.replaceIn(cell, new rs.Cell(0)).v; } /** The first of `d`, flipped through the pointer `pointer_of` gives. */ -export function flipped(d: Duo.Duo): rt.u8 { +export function flipped(d: Duo.Duo): rs.u8 { const p: Duo.Duo = pointerOf(d); p._0 = p._0 ^ 90; return p._0; @@ -651,57 +651,57 @@ export function pointerOf(d: Duo.Duo): Duo.Duo { * iteration of a loop that assigns the variable after, one an arm makes where another * arm replaces its variable, and ones nested loops make. */ -export function lapsed(data: rt.ByteSlice, out: rt.ByteVec): void { - let _54!: rt.u8; +export function lapsed(data: rs.ByteSlice, out: rs.ByteVec): void { + let _54!: rs.u8; let pair: Duo.Duo = { _0: 0, _1: 255 }; - let log: Log.Log = { bytes: new rt.ByteVec() }; - let window: Uint8Array = rt.bytes(3); - for (const n of rt.byteSliceView(data)) { + let log: Log.Log = { bytes: new rs.ByteVec() }; + let window: Uint8Array = rs.bytes(3); + for (const n of rs.byteSliceView(data)) { const p: Duo.Duo = pair; - p._0 = rt.u8WrappingAdd(p._0, n); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(p._0, p._1)), undefined, true); + p._0 = rs.u8WrappingAdd(p._0, n); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(p._0, p._1)), undefined, true); pair = { _0: pair._1 ^ n, _1: pair._0 }; - const _24: rt.u8 = rt.u8Rem(n, 4); + const _24: rs.u8 = rs.u8Rem(n, 4); if (_24 === 0) { const q: Log.Log = log; - rt.byteVecPush(q.bytes, n); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(q.bytes)), undefined, true); + rs.byteVecPush(q.bytes, n); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(q.bytes)), undefined, true); } else if (_24 === 1) { - const _33: Log.Log = { bytes: rt.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; + const _33: Log.Log = { bytes: rs.byteVecFrom(Uint8Array.of(n, ~n & 0xff)) }; const old3 = log; log = _33; - rt.iterExtendBytes(out, rt.byteVecIntoIter(old3.bytes), undefined, true); - const old2: Duo.Duo = rt.replaceIn(pair, { _0: n, _1: n ^ 15 }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(old3.bytes), undefined, true); + const old2: Duo.Duo = rs.replaceIn(pair, { _0: n, _1: n ^ 15 }); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(old2._0, old2._1)), undefined, true); } else if (_24 === 2) { let duo: Duo.Duo = { _0: n, _1: 0 }; const outer: Duo.Duo = duo; - const _51: rt.u8 = rt.u8Rem(n, 5); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _51; + const _51: rs.u8 = rs.u8Rem(n, 5); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _51; while ((_54 = iterStart++) < iterEnd) { - const i: rt.u8 = _54; - const inner: rt.ByteSlice = rt.byteSliceFrom(window); - const _59: rt.usize = rt.u8Rem(i, 3) as rt.usize; + const i: rs.u8 = _54; + const inner: rs.ByteSlice = rs.byteSliceFrom(window); + const _59: rs.usize = rs.u8Rem(i, 3) as rs.usize; if (!(_59 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _59); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _59); } inner.data[inner.start + _59] = inner.data[inner.start + _59] ^ n; - outer._1 = rt.u8WrappingAdd(outer._1, inner.data[inner.start]); - window = Uint8Array.of(window[2], window[0], rt.u8WrappingAdd(window[1], i)); + outer._1 = rs.u8WrappingAdd(outer._1, inner.data[inner.start]); + window = Uint8Array.of(window[2], window[0], rs.u8WrappingAdd(window[1], i)); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(outer._0, outer._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(outer._0, outer._1)), undefined, true); duo = { _0: duo._1, _1: duo._0 }; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(duo._0, duo._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(duo._0, duo._1)), undefined, true); } else { - const p2: rt.ByteSlice = rt.byteSliceFrom(window); - rt.byteVecPush(out, p2.data[p2.start]); - window = rt.bytes(3).fill(n); + const p2: rs.ByteSlice = rs.byteSliceFrom(window); + rs.byteVecPush(out, p2.data[p2.start]); + window = rs.bytes(3).fill(n); } } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log.bytes), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(copy$array_u8(window)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(log.bytes), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(copy$array_u8(window)), undefined, true); } export function put$pointers_ByCall(slot: ByCall.ByCall, value: ByCall.ByCall): void { @@ -711,7 +711,7 @@ export function put$pointers_ByCall(slot: ByCall.ByCall, value: ByCall.ByCall): export function resetter$pointers_ByClosure(slot: ByClosure.ByClosure): () => undefined { const captured = slot; return (): undefined => { - rt.ptrWrite(captured, copy$pointers_ByClosure(ByClosure.default$Default())); + rs.ptrWrite(captured, copy$pointers_ByClosure(ByClosure.default$Default())); }; } @@ -719,11 +719,11 @@ export function resetter$pointers_ByClosure(slot: ByClosure.ByClosure): () => un * Each byte a copy of one of them, the original written whole after by its generic body, * and both put. Each is a function of its own, as a loop assigns its variables again. */ -export function writers(data: rt.ByteSlice, out: rt.ByteVec): void { +export function writers(data: rs.ByteSlice, out: rs.ByteVec): void { let _12!: Uint8Array; - for (const byte of rt.byteSliceView(data)) { - const n: rt.u8 = rt.u8Div(byte, 3); - const _13: rt.u8 = rt.u8Rem(byte, 3); + for (const byte of rs.byteSliceView(data)) { + const n: rs.u8 = rs.u8Div(byte, 3); + const _13: rs.u8 = rs.u8Rem(byte, 3); if (_13 === 0) { _12 = byCall(n); } else if (_13 === 1) { @@ -731,26 +731,26 @@ export function writers(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _12 = byClosure(n); } - rt.iterExtendBytes(out, rt.iterSlice(_12), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(_12), undefined, true); } } -export function byCall(n: rt.u8): Uint8Array { +export function byCall(n: rs.u8): Uint8Array { const a: ByCall.ByCall = { _0: n, _1: 1 }; const b: ByCall.ByCall = copy$pointers_ByCall(a); put$pointers_ByCall(a, { _0: 2, _1: ~n & 0xff }); return Uint8Array.of(a._0, a._1, b._0, b._1); } -export function byObject(n: rt.u8): Uint8Array { - const bin: Bin.Bin = new Bin.Bin(new rt.Cell({ _0: n, _1: 1 })); +export function byObject(n: rs.u8): Uint8Array { + const bin: Bin.Bin = new Bin.Bin(new rs.Cell({ _0: n, _1: 1 })); const before: ByObject.ByObject = copy$pointers_ByObject(bin._0.v); new of$pointers_Bin_pointers_ByObject(bin).reset$Reset(); const after: ByObject.ByObject = bin._0.v; return Uint8Array.of(after._0, after._1, before._0, before._1); } -export function byClosure(n: rt.u8): Uint8Array { +export function byClosure(n: rs.u8): Uint8Array { const a: ByClosure.ByClosure = { _0: n, _1: 1 }; const b: ByClosure.ByClosure = copy$pointers_ByClosure(a); resetter$pointers_ByClosure(a)(); @@ -758,9 +758,9 @@ export function byClosure(n: rt.u8): Uint8Array { } /** Each part of a `Gauge` written into, never given another object. */ -export function nudge(g: Gauge.Gauge, n: rt.u8): void { +export function nudge(g: Gauge.Gauge, n: rs.u8): void { g.range[0] = g.range[0] ^ n; - const _3: [rt.u8, rt.u8] = g.slot; + const _3: [rs.u8, rs.u8] = g.slot; _3[1] = _3[1] ^ n; } @@ -770,21 +770,21 @@ export function nudge(g: Gauge.Gauge, n: rt.u8): void { * `MaybeUninit::as_mut_ptr` and `as_ptr`. Each is a function of its own, as a loop assigns * its variables again. */ -export function made(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const _5 of rt.byteSliceView(data)) { - rt.iterExtendBytes(out, rt.iterSlice(madeParts(_5)), undefined, true); +export function made(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const _5 of rs.byteSliceView(data)) { + rs.iterExtendBytes(out, rs.iterSlice(madeParts(_5)), undefined, true); } } -export function madeParts(n: rt.u8): Uint8Array { - const g: Gauge.Gauge = { range: [n, ~n & 0xff] as [rt.u8, rt.u8], slot: copy$mem_MaybeUninit_tuple2_u8_u8([~n & 0xff, n] as [rt.u8, rt.u8]) }; - const p: [rt.u8, rt.u8] = g.range; - const q: [rt.u8, rt.u8] = g.slot; +export function madeParts(n: rs.u8): Uint8Array { + const g: Gauge.Gauge = { range: [n, ~n & 0xff] as [rs.u8, rs.u8], slot: copy$mem_MaybeUninit_tuple2_u8_u8([~n & 0xff, n] as [rs.u8, rs.u8]) }; + const p: [rs.u8, rs.u8] = g.range; + const q: [rs.u8, rs.u8] = g.slot; nudge(g, n ^ 90); q[0] = p[1]; - const r: [rt.u8, rt.u8] = g.range; - const s: [rt.u8, rt.u8] = g.slot; - const t: [rt.u8, rt.u8] = g.range; + const r: [rs.u8, rs.u8] = g.range; + const s: [rs.u8, rs.u8] = g.slot; + const t: [rs.u8, rs.u8] = g.range; nudge(g, n); return Uint8Array.of(p[0], p[1], r[0], t[1], s[0], s[1], g.slot[0]); } @@ -793,14 +793,14 @@ export function madeParts(n: rt.u8): Uint8Array { * Entries pushed into segments of slots that each fill whole first, read back, and * changed in place through the pointer each slot's cell lends. */ -export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Vec = new rt.Vec(); - let len: rt.usize = 0; - for (const byte of rt.byteSliceView(data)) { - const _12: rt.u8 = rt.u8Rem(byte, 4); +export function segments(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Vec = new rs.Vec(); + let len: rs.usize = 0; + for (const byte of rs.byteSliceView(data)) { + const _12: rs.u8 = rs.u8Rem(byte, 4); if (_12 === 0) { - if (!(rt.usizeRem(len, 8) === 0)) { - if (rt.usizeRem(len, 4) === 0) { + if (!(rs.usizeRem(len, 8) === 0)) { + if (rs.usizeRem(len, 4) === 0) { const _27: Segment.Segment = Segment.iterated(); log.items.push(_27); } @@ -808,39 +808,39 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { const _20: Segment.Segment = Segment.new(); log.items.push(_20); } - const at5 = rt.idx(log.items, rt.usizeDiv(len, 4)); - Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(Segment.slot(log.items[at5], log.items[at5].filled), (p3: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { + const at5 = rs.idx(log.items, rs.usizeDiv(len, 4)); + Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_mut_tuple2_u8_u8_pointers_segments_closure0(Segment.slot(log.items[at5], log.items[at5].filled), (p3: [rs.u8, rs.u8]): [rs.u8, rs.u8] => { const uninit = p3; - rt.ptrWrite(uninit, [byte, ~byte & 0xff] as [rt.u8, rt.u8]); + rs.ptrWrite(uninit, [byte, ~byte & 0xff] as [rs.u8, rs.u8]); return uninit; }); - log.items[at5].filled = rt.usizeAdd(log.items[at5].filled, 1); - len = rt.usizeAdd(len, 1); + log.items[at5].filled = rs.usizeAdd(log.items[at5].filled, 1); + len = rs.usizeAdd(len, 1); continue; } if (_12 === 1) { if (len > 0) { - const at: rt.usize = rt.usizeRem(byte as rt.usize, len); - const _49: [rt.u8, rt.u8] = Lent.with$mem_MaybeUninit_tuple2_u8_u8_tuple2_u8_u8_pointers_segments_closure1(Segment.slot(log.items[rt.idx(log.items, rt.usizeDiv(at, 4))], rt.usizeRem(at, 4)), (p2: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { + const at: rs.usize = rs.usizeRem(byte as rs.usize, len); + const _49: [rs.u8, rs.u8] = Lent.with$mem_MaybeUninit_tuple2_u8_u8_tuple2_u8_u8_pointers_segments_closure1(Segment.slot(log.items[rs.idx(log.items, rs.usizeDiv(at, 4))], rs.usizeRem(at, 4)), (p2: [rs.u8, rs.u8]): [rs.u8, rs.u8] => { return copy$tuple2_u8_u8(p2); }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_49[0], _49[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_49[0], _49[1])), undefined, true); continue; } } else if (_12 === 2) { if (len > 0) { - const at2: rt.usize = rt.usizeRem(byte as rt.usize, len); - Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_unit_pointers_segments_closure2(Segment.slot(log.items[rt.idx(log.items, rt.usizeDiv(at2, 4))], rt.usizeRem(at2, 4)), (p: [rt.u8, rt.u8]): undefined => { - const _3: rt.u8 = byte; - const _4: [rt.u8, rt.u8] = p; + const at2: rs.usize = rs.usizeRem(byte as rs.usize, len); + Lent.withMut$mem_MaybeUninit_tuple2_u8_u8_unit_pointers_segments_closure2(Segment.slot(log.items[rs.idx(log.items, rs.usizeDiv(at2, 4))], rs.usizeRem(at2, 4)), (p: [rs.u8, rs.u8]): undefined => { + const _3: rs.u8 = byte; + const _4: [rs.u8, rs.u8] = p; _4[1] = _4[1] ^ _3; }); continue; } } - rt.byteVecPush(out, rt.iterSum(rt.iterMap(rt.iterSlice(log.items), (s: Segment.Segment): rt.u8 => { + rs.byteVecPush(out, rs.iterSum(rs.iterMap(rs.iterSlice(log.items), (s: Segment.Segment): rs.u8 => { return s.filled & 0xff; - }), rt.u8Add, 0)); + }), rs.u8Add, 0)); } } @@ -848,42 +848,42 @@ export function segments(data: rt.ByteSlice, out: rt.ByteVec): void { * A `MaybeUninit` array and a `MaybeUninit` variable, each slot written whole before any * pointer into it is taken, then changed through pointers to a part of each and read back. */ -export function uninitRuns(data: rt.ByteSlice, out: rt.ByteVec): void { - let _7!: rt.usize; +export function uninitRuns(data: rs.ByteSlice, out: rs.ByteVec): void { + let _7!: rs.usize; const runs: Run.Run[] = Array.from({ length: 3 }, (): Run.Run => { return ({ span: [undefined, undefined], n: undefined } as unknown) as Run.Run; }); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 3; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 3; while ((_7 = iterStart++) < iterEnd) { - const at: rt.usize = _7; - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at), 0); + const at: rs.usize = _7; + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, at), 0); if (!(at < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + at); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + at); } - rt.ptrWrite(runs[at], { span: [n, ~n & 0xff] as [rt.u8, rt.u8], n: at & 0xff }); + rs.ptrWrite(runs[at], { span: [n, ~n & 0xff] as [rs.u8, rs.u8], n: at & 0xff }); } const last: Run.Run = ({ span: [undefined, undefined], n: undefined } as unknown) as Run.Run; - rt.ptrWrite(last, { span: [data.length & 0xff, 0] as [rt.u8, rt.u8], n: 3 }); - const tail: [rt.u8, rt.u8] = last.span; - for (const byte of rt.byteSliceView(data)) { - const _40: rt.usize = rt.usizeRem(byte as rt.usize, 3); + rs.ptrWrite(last, { span: [data.length & 0xff, 0] as [rs.u8, rs.u8], n: 3 }); + const tail: [rs.u8, rs.u8] = last.span; + for (const byte of rs.byteSliceView(data)) { + const _40: rs.usize = rs.usizeRem(byte as rs.usize, 3); if (!(_40 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _40); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _40); } const run: Run.Run = runs[_40]; - const span: [rt.u8, rt.u8] = run.span; + const span: [rs.u8, rs.u8] = run.span; span[0] = span[0] ^ byte; - span[1] = rt.u8WrappingAdd(span[1], run.n); - tail[1] = rt.u8WrappingAdd(tail[1], span[0]); - rt.byteVecPush(out, span[0]); + span[1] = rs.u8WrappingAdd(span[1], run.n); + tail[1] = rs.u8WrappingAdd(tail[1], span[0]); + rs.byteVecPush(out, span[0]); } for (const _56 of runs) { const run2: Run.Run = _56; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(run2.span[0], run2.span[1], run2.n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(run2.span[0], run2.span[1], run2.n)), undefined, true); } const last2: Run.Run = last; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(last2.span[0], last2.span[1], last2.n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(last2.span[0], last2.span[1], last2.n)), undefined, true); } /** @@ -892,98 +892,98 @@ export function uninitRuns(data: rt.ByteSlice, out: rt.ByteVec): void { * `chunks_exact_mut`, and a `zip` with an index range; then changed through pointers to * a part of each and read back. */ -export function iteratedRuns(data: rt.ByteSlice, out: rt.ByteVec): void { - const byte: (a0: rt.usize) => rt.u8 = (at3: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, at3), 0); +export function iteratedRuns(data: rs.ByteSlice, out: rs.ByteVec): void { + const byte: (a0: rs.usize) => rs.u8 = (at3: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, at3), 0); }; const runs: Run.Run[] = Array.from({ length: 3 }, (): Run.Run => { return ({ span: [undefined, undefined], n: undefined } as unknown) as Run.Run; }); - const iter: rt.Iter = rt.iterSlice(runs); + const iter: rs.Iter = rs.iterSlice(runs); while (true) { - const _10: Run.Run | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: Run.Run | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } const uninit = _10; - rt.ptrWrite(uninit, { span: [byte(0), ~byte(0) & 0xff] as [rt.u8, rt.u8], n: 0 }); + rs.ptrWrite(uninit, { span: [byte(0), ~byte(0) & 0xff] as [rs.u8, rs.u8], n: 0 }); uninit; } const boxed: Run.Run[] = Array.from({ length: 4 }, (): Run.Run => { return ({ span: [undefined, undefined], n: undefined } as unknown) as Run.Run; }); - const iter2: rt.Iter = rt.iterSlice(boxed); + const iter2: rs.Iter = rs.iterSlice(boxed); while (true) { - const _30: Run.Run | rt.Done = iter2.next(); - if (_30 === rt.DONE) { + const _30: Run.Run | rs.Done = iter2.next(); + if (_30 === rs.DONE) { break; } const uninit2 = _30; - rt.ptrWrite(uninit2, { span: [byte(1), 1] as [rt.u8, rt.u8], n: 1 }); + rs.ptrWrite(uninit2, { span: [byte(1), 1] as [rs.u8, rs.u8], n: 1 }); uninit2; } - const iter3: rt.Iter<[Run.Run[], rt.u8]> = rt.iterZip(rt.sliceChunksExactMut(boxed, 2), new rt.RangeFrom(0, rt.u8Step), "len"); + const iter3: rs.Iter<[Run.Run[], rs.u8]> = rs.iterZip(rs.sliceChunksExactMut(boxed, 2), new rs.RangeFrom(0, rs.u8Step), "len"); l5: while (true) { - const _46: [Run.Run[], rt.u8] | rt.Done = iter3.next(); - if (_46 === rt.DONE) { + const _46: [Run.Run[], rs.u8] | rs.Done = iter3.next(); + if (_46 === rs.DONE) { break; } - const at: rt.u8 = _46[1]; + const at: rs.u8 = _46[1]; const iterS: Run.Run[] = _46[0]; let iterI: number = 0; while (true) { - const _53: Run.Run | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_53 === rt.DONE) { + const _53: Run.Run | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_53 === rs.DONE) { continue l5; } const uninit3 = _53; - rt.ptrWrite(uninit3, { span: [byte(2), at] as [rt.u8, rt.u8], n: rt.u8WrappingAdd(at, byte(3)) }); + rs.ptrWrite(uninit3, { span: [byte(2), at] as [rs.u8, rs.u8], n: rs.u8WrappingAdd(at, byte(3)) }); uninit3; } } - const iter5: rt.Iter<[Run.Run, rt.usize]> = rt.iterZip(rt.iterSlice(runs), new rt.RangeFrom(0, rt.usizeStep), "len"); + const iter5: rs.Iter<[Run.Run, rs.usize]> = rs.iterZip(rs.iterSlice(runs), new rs.RangeFrom(0, rs.usizeStep), "len"); while (true) { - const _74: [Run.Run, rt.usize] | rt.Done = iter5.next(); - if (_74 === rt.DONE) { + const _74: [Run.Run, rs.usize] | rs.Done = iter5.next(); + if (_74 === rs.DONE) { break; } - const at2: rt.usize = _74[1]; + const at2: rs.usize = _74[1]; const uninit4 = _74[0]; - rt.ptrWrite(uninit4, { span: [byte(at2), at2 & 0xff] as [rt.u8, rt.u8], n: at2 & 0xff }); + rs.ptrWrite(uninit4, { span: [byte(at2), at2 & 0xff] as [rs.u8, rs.u8], n: at2 & 0xff }); uninit4; } - for (const byte2 of rt.byteSliceView(data)) { - const _95: rt.usize = rt.usizeRem(byte2 as rt.usize, 3); + for (const byte2 of rs.byteSliceView(data)) { + const _95: rs.usize = rs.usizeRem(byte2 as rs.usize, 3); if (!(_95 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _95); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _95); } const run: Run.Run = runs[_95]; - const span: [rt.u8, rt.u8] = run.span; + const span: [rs.u8, rs.u8] = run.span; span[0] = span[0] ^ byte2; - span[1] = rt.u8WrappingAdd(span[1], run.n); - rt.byteVecPush(out, span[0]); - const _107: rt.usize = rt.usizeRem(byte2 as rt.usize, 4); - rt.idx(boxed, _107); - const span2: [rt.u8, rt.u8] = boxed[_107].span; + span[1] = rs.u8WrappingAdd(span[1], run.n); + rs.byteVecPush(out, span[0]); + const _107: rs.usize = rs.usizeRem(byte2 as rs.usize, 4); + rs.idx(boxed, _107); + const span2: [rs.u8, rs.u8] = boxed[_107].span; span2[1] = span2[1] ^ byte2; - rt.byteVecPush(out, span2[1]); + rs.byteVecPush(out, span2[1]); } - const iter7: rt.Iter = rt.iterChain(rt.iterSlice(runs), rt.iterSlice(boxed)); + const iter7: rs.Iter = rs.iterChain(rs.iterSlice(runs), rs.iterSlice(boxed)); while (true) { - const _123: Run.Run | rt.Done = iter7.next(); - if (_123 === rt.DONE) { + const _123: Run.Run | rs.Done = iter7.next(); + if (_123 === rs.DONE) { break; } const run3: Run.Run = _123; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(run3.span[0], run3.span[1], run3.n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(run3.span[0], run3.span[1], run3.n)), undefined, true); } } -export function firstSet$u16(pair: [rt.u16, Stable.Stable], value: rt.u16): void { +export function firstSet$u16(pair: [rs.u16, Stable.Stable], value: rs.u16): void { pair[0] = value; } -export function stableCell(stable: Stable.Stable): rt.Place { +export function stableCell(stable: Stable.Stable): rs.Place { return stable._0; } @@ -991,21 +991,21 @@ export function stableCell(stable: Stable.Stable): rt.Place { * A pointer to a cell beside a field a generic body writes whole, which leaves the cell's * struct be. */ -export function besideWritten(data: rt.ByteSlice, out: rt.ByteVec): void { - const pair: [rt.u16, Stable.Stable] = [0, { _0: new rt.Cell(0) }]; - const cell: rt.Place = stableCell(pair[1]); - for (const byte of rt.byteSliceView(data)) { - firstSet$u16(pair, byte as rt.u16); - cell.v = rt.u8WrappingAdd(cell.v, byte); - rt.byteVecPush(out, cell.v ^ (pair[0] & 0xff)); +export function besideWritten(data: rs.ByteSlice, out: rs.ByteVec): void { + const pair: [rs.u16, Stable.Stable] = [0, { _0: new rs.Cell(0) }]; + const cell: rs.Place = stableCell(pair[1]); + for (const byte of rs.byteSliceView(data)) { + firstSet$u16(pair, byte as rs.u16); + cell.v = rs.u8WrappingAdd(cell.v, byte); + rs.byteVecPush(out, cell.v ^ (pair[0] & 0xff)); } } -export function waiter(n: rt.u8): Waiter.Waiter { - return { next: new rt.Atomic(rt.NULL), enqueued: new rt.Atomic(false), slot: new rt.Cell([n, 0] as [rt.u8, rt.u8]) }; +export function waiter(n: rs.u8): Waiter.Waiter { + return { next: new rs.Atomic(rs.NULL), enqueued: new rs.Atomic(false), slot: new rs.Cell([n, 0] as [rs.u8, rs.u8]) }; } -export function slotOf(waiter: Waiter.Waiter): [rt.u8, rt.u8] { +export function slotOf(waiter: Waiter.Waiter): [rs.u8, rs.u8] { return waiter.slot.v; } @@ -1013,50 +1013,50 @@ export function slotOf(waiter: Waiter.Waiter): [rt.u8, rt.u8] { * Waiters linked and unlinked, each changed and read through the pointer into its cell * taken when it was made, which nothing writing a waiter whole leaves stale. */ -export function waiters(data: rt.ByteSlice, out: rt.ByteVec): void { - let _80!: rt.usize; +export function waiters(data: rs.ByteSlice, out: rs.ByteVec): void { + let _80!: rs.usize; const nodes: Waiter.Waiter[] = [waiter(0), waiter(1), waiter(2), waiter(3)]; - const slots: [rt.u8, rt.u8][] = [slotOf(nodes[0]), slotOf(nodes[1]), slotOf(nodes[2]), slotOf(nodes[3])]; - const list: Waiters.Waiters = { head: new rt.Atomic(rt.NULL), last: rt.NULL }; - for (const byte of rt.byteSliceView(data)) { - const at: rt.usize = rt.usizeRem(byte >> 2 as rt.usize, 4); - const _42: rt.u8 = rt.u8Rem(byte, 4); + const slots: [rs.u8, rs.u8][] = [slotOf(nodes[0]), slotOf(nodes[1]), slotOf(nodes[2]), slotOf(nodes[3])]; + const list: Waiters.Waiters = { head: new rs.Atomic(rs.NULL), last: rs.NULL }; + for (const byte of rs.byteSliceView(data)) { + const at: rs.usize = rs.usizeRem(byte >> 2 as rs.usize, 4); + const _42: rs.u8 = rs.u8Rem(byte, 4); if (_42 === 0) { if (!(at < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + at); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + at); } Waiters.push(list, nodes[at]); continue; } if (_42 === 1) { - rt.byteVecPush(out, Waiters.pop(list) ? 1 : 0); + rs.byteVecPush(out, Waiters.pop(list) ? 1 : 0); continue; } if (_42 === 2) { - if (!(list.last === rt.NULL)) { - const slot: [rt.u8, rt.u8] = slotOf(list.last); - slot[1] = rt.u8WrappingAdd(slot[1], byte); + if (!(list.last === rs.NULL)) { + const slot: [rs.u8, rs.u8] = slotOf(list.last); + slot[1] = rs.u8WrappingAdd(slot[1], byte); continue; } } if (!(at < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + at); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + at); } - const _58: [rt.u8, rt.u8] = copy$tuple2_u8_u8(slots[at]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_58[0], _58[1])), undefined, true); + const _58: [rs.u8, rs.u8] = copy$tuple2_u8_u8(slots[at]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_58[0], _58[1])), undefined, true); } - let at2: Waiter.Waiter = rt.atomicLoad(list.head, 4); - while (!(at2 === rt.NULL)) { - const _69: [rt.u8, rt.u8] = copy$tuple2_u8_u8(slotOf(at2)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_69[0], _69[1])), undefined, true); - at2 = rt.atomicLoad(at2.next, 4); + let at2: Waiter.Waiter = rs.atomicLoad(list.head, 4); + while (!(at2 === rs.NULL)) { + const _69: [rs.u8, rs.u8] = copy$tuple2_u8_u8(slotOf(at2)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_69[0], _69[1])), undefined, true); + at2 = rs.atomicLoad(at2.next, 4); } - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 4; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 4; while ((_80 = iterStart++) < iterEnd) { - const node: rt.usize = _80; + const node: rs.usize = _80; if (!(node < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + node); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + node); } nodes[node]; } @@ -1069,75 +1069,75 @@ export function waiters(data: rt.ByteSlice, out: rt.ByteVec): void { * points at another variable, whose first is assigned after, and ones a callee gives back * only as a reference, through a borrow a closure keeps. */ -export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(n, 4); +export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(n, 4); if (_10 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(readBefore(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(readBefore(n)), undefined, true); } else if (_10 === 1) { perIteration(n, out); } else if (_10 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(swappedAway(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(swappedAway(n)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(viewed(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(viewed(n)), undefined, true); } } } -export function readBefore(n: rt.u8): Uint8Array { +export function readBefore(n: rs.u8): Uint8Array { let d: Duo.Duo = { _0: n, _1: ~n & 0xff }; const q: Duo.Duo = pointerOf(d); q._0 = q._0 ^ 51; - const seen: rt.u8 = q._0; + const seen: rs.u8 = q._0; d = { _0: d._1, _1: d._0 }; return Uint8Array.of(seen, d._0, d._1); } -export function keep(d: Duo.Duo, kept: rt.Vec): void { +export function keep(d: Duo.Duo, kept: rs.Vec): void { kept.items.push(d); } -export function perIteration(n: rt.u8, out: rt.ByteVec): void { - let _9!: rt.u8; - const kept: rt.Vec = new rt.Vec(); - const _6: rt.u8 = rt.u8Rem(n, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _6; +export function perIteration(n: rs.u8, out: rs.ByteVec): void { + let _9!: rs.u8; + const kept: rs.Vec = new rs.Vec(); + const _6: rs.u8 = rs.u8Rem(n, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _6; while ((_9 = iterStart++) < iterEnd) { - const i: rt.u8 = _9; + const i: rs.u8 = _9; const d: Duo.Duo = { _0: n ^ i, _1: i }; keep(d, kept); - const at = rt.idx(kept.items, 0); + const at = rs.idx(kept.items, 0); kept.items[at]._1 = kept.items[at]._1 ^ n; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(d._0, d._1)), undefined, true); - rt.vecTruncate(kept, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(d._0, d._1)), undefined, true); + rs.vecTruncate(kept, 0); } } -export function swappedAway(n: rt.u8): Uint8Array { - let a: [rt.u8, rt.u8] = [n, 1]; - const b: [rt.u8, rt.u8] = [2, n]; - let r: [rt.u8, rt.u8] = a; - let s: [rt.u8, rt.u8] = b; +export function swappedAway(n: rs.u8): Uint8Array { + let a: [rs.u8, rs.u8] = [n, 1]; + const b: [rs.u8, rs.u8] = [2, n]; + let r: [rs.u8, rs.u8] = a; + let s: [rs.u8, rs.u8] = b; const swapped = r; r = s; s = swapped; - const p: [rt.u8, rt.u8] = r; - a = [a[1], a[0]] as [rt.u8, rt.u8]; + const p: [rs.u8, rs.u8] = r; + a = [a[1], a[0]] as [rs.u8, rs.u8]; p[0] = p[0] ^ 7; return Uint8Array.of(a[0], a[1], b[0], b[1]); } -export function firstOf(v: Viewed.Viewed): rt.Place { +export function firstOf(v: Viewed.Viewed): rs.Place { const _2: Viewed.Viewed = v; - return rt.place(() => _2._0, (value) => _2._0 = value); + return rs.place(() => _2._0, (value) => _2._0 = value); } -export function viewed(n: rt.u8): Uint8Array { +export function viewed(n: rs.u8): Uint8Array { let v: Viewed.Viewed = { _0: n, _1: 3 }; const _4: Viewed.Viewed = v; - const bump: (a0: rt.u8) => undefined = (k: rt.u8): undefined => { - const _3: rt.Place = firstOf(_4); + const bump: (a0: rs.u8) => undefined = (k: rs.u8): undefined => { + const _3: rs.Place = firstOf(_4); _3.v = _3.v ^ k; }; bump(5); @@ -1153,95 +1153,95 @@ export function viewed(n: rt.u8): Uint8Array { * `UnsafeCell`, and `AtomicPtr` make and take them. Pointers to one array are equal however they were made, and to arrays of equal * bytes, or to parts at other offsets, are not. */ -export function bytes(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { +export function bytes(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { const a: Uint8Array = Uint8Array.of(n, n ^ 1, n ^ 2, n ^ 3); const b: Uint8Array = copy$array_u8(a); - const fromRef: rt.ByteSlice = rt.byteSliceFrom(a); - const fromRaw: rt.ByteSlice = rt.byteSliceFrom(a); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.byteSliceSame(fromRef, rt.byteSliceFrom(a)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, rt.byteSliceSame(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, fromRaw) ? 1 : 0, !rt.byteSliceSame(fromRef, rt.byteSliceFrom(b)) ? 1 : 0, rt.byteSliceSame(fromRef, rt.NULL) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(a)) ? 1 : 0, sameBytes(rt.byteSliceFrom(a), rt.byteSliceFrom(b)) ? 1 : 0)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(held(n)), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(parts(rt.byteSliceFrom(a))), undefined, true); - const _55: rt.u8 = rt.u8Rem(n, 4); + const fromRef: rs.ByteSlice = rs.byteSliceFrom(a); + const fromRaw: rs.ByteSlice = rs.byteSliceFrom(a); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.byteSliceSame(fromRef, rs.byteSliceFrom(a)) ? 1 : 0, rs.byteSliceSame(fromRef, fromRaw) ? 1 : 0, rs.byteSliceSame(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) ? 1 : 0, rs.byteSliceSame(fromRef, fromRaw) ? 1 : 0, !rs.byteSliceSame(fromRef, rs.byteSliceFrom(b)) ? 1 : 0, rs.byteSliceSame(fromRef, rs.NULL) ? 1 : 0, sameBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(a)) ? 1 : 0, sameBytes(rs.byteSliceFrom(a), rs.byteSliceFrom(b)) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(held(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(parts(rs.byteSliceFrom(a))), undefined, true); + const _55: rs.u8 = rs.u8Rem(n, 4); if (_55 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(moved(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(moved(n)), undefined, true); } else if (_55 === 1) { - rt.iterExtendBytes(out, rt.iterSlice(wrapped(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(wrapped(n)), undefined, true); } else if (_55 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(inVec(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(inVec(n)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(exchanged(n)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(exchanged(n)), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(copy$array_u8(a)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(copy$array_u8(a)), undefined, true); } } -export function sameBytes(p: rt.ByteSlice, q: rt.ByteSlice): boolean { - return rt.byteSliceSame(p, q); +export function sameBytes(p: rs.ByteSlice, q: rs.ByteSlice): boolean { + return rs.byteSliceSame(p, q); } /** * Pointers compared in a tuple, an array, a vector, an `Option`, and a derived * `PartialEq`. */ -export function held(n: rt.u8): Uint8Array { - const _4: [Uint8Array, Uint8Array] = [rt.bytes(4).fill(n), rt.bytes(4).fill(n)]; +export function held(n: rs.u8): Uint8Array { + const _4: [Uint8Array, Uint8Array] = [rs.bytes(4).fill(n), rs.bytes(4).fill(n)]; const a: Uint8Array = copy$array_u8(_4[0]); const b: Uint8Array = copy$array_u8(_4[1]); - const _11: rt.ByteSlice = rt.byteSliceFrom(a); - const _13: rt.ByteSlice = rt.byteSliceFrom(a); - const _10: [rt.ByteSlice, rt.ByteSlice, rt.ByteSlice] = [_11, _13, rt.byteSliceFrom(b)]; - const p: rt.ByteSlice = _11; - const q: rt.ByteSlice = _13; - const r: rt.ByteSlice = _10[2]; - const _20: [rt.ByteSlice, rt.i32] = [p, 1]; - const _22: [rt.ByteSlice, rt.i32] = [q, 1]; - const _17: rt.u8 = rt.eqTuple([rt.byteSliceSame, rt.same])(_20, _22) ? 1 : 0; - const _23: rt.u8 = rt.eqSlice(rt.byteSliceSame)([p], [r]) ? 1 : 0; - const _29: rt.u8 = rt.sliceContains(rt.vecFrom(copy$array_ptr_array4_u8([r, p])).items, q, rt.byteSliceSame) ? 1 : 0; - const _39: rt.ByteSlice | undefined = p; - const _41: rt.ByteSlice | undefined = q; - return Uint8Array.of(_17, _23, _29, rt.eqOption(rt.byteSliceSame)(_39, _41) ? 1 : 0, rt.eqOption(rt.byteSliceSame)(p, r) ? 1 : 0, Pointing.eq$cmp_PartialEq({ _0: p }, { _0: q }) ? 1 : 0); + const _11: rs.ByteSlice = rs.byteSliceFrom(a); + const _13: rs.ByteSlice = rs.byteSliceFrom(a); + const _10: [rs.ByteSlice, rs.ByteSlice, rs.ByteSlice] = [_11, _13, rs.byteSliceFrom(b)]; + const p: rs.ByteSlice = _11; + const q: rs.ByteSlice = _13; + const r: rs.ByteSlice = _10[2]; + const _20: [rs.ByteSlice, rs.i32] = [p, 1]; + const _22: [rs.ByteSlice, rs.i32] = [q, 1]; + const _17: rs.u8 = rs.eqTuple([rs.byteSliceSame, rs.same])(_20, _22) ? 1 : 0; + const _23: rs.u8 = rs.eqSlice(rs.byteSliceSame)([p], [r]) ? 1 : 0; + const _29: rs.u8 = rs.sliceContains(rs.vecFrom(copy$array_ptr_array4_u8([r, p])).items, q, rs.byteSliceSame) ? 1 : 0; + const _39: rs.ByteSlice | undefined = p; + const _41: rs.ByteSlice | undefined = q; + return Uint8Array.of(_17, _23, _29, rs.eqOption(rs.byteSliceSame)(_39, _41) ? 1 : 0, rs.eqOption(rs.byteSliceSame)(p, r) ? 1 : 0, Pointing.eq$cmp_PartialEq({ _0: p }, { _0: q }) ? 1 : 0); } /** Pointers to parts of an array at each offset, compared, and one written through. */ -export function parts(a: rt.ByteSlice): Uint8Array { - const first: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceGetRange(a, 0, 2)); - const last: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceLastChunk(a, 2)); - const again: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceGetRange(rt.byteSliceRange(a, 0, 3), 0, 2)); - const slice: rt.ByteSlice = a; - const middle: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceGetRange(rt.optionUnwrap((slice.length >= 1 ? [new rt.ByteSlice(slice.data, slice.start, 1), new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1)] as [rt.ByteSlice, rt.ByteSlice] : undefined) as [rt.ByteSlice, rt.ByteSlice] | undefined)[1], 0, 2)); - const written: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceLastChunk(a, 2)); +export function parts(a: rs.ByteSlice): Uint8Array { + const first: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceGetRange(a, 0, 2)); + const last: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(a, 2)); + const again: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceGetRange(rs.byteSliceRange(a, 0, 3), 0, 2)); + const slice: rs.ByteSlice = a; + const middle: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceGetRange(rs.optionUnwrap((slice.length >= 1 ? [new rs.ByteSlice(slice.data, slice.start, 1), new rs.ByteSlice(slice.data, slice.start + 1, slice.length - 1)] as [rs.ByteSlice, rs.ByteSlice] : undefined) as [rs.ByteSlice, rs.ByteSlice] | undefined)[1], 0, 2)); + const written: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(a, 2)); written.data[written.start] = written.data[written.start] ^ 128; - return Uint8Array.of(rt.byteSliceSame(first, last) ? 1 : 0, rt.byteSliceSame(first, again) ? 1 : 0, rt.byteSliceSame(first, middle) ? 1 : 0, rt.byteSliceSame(last, written) ? 1 : 0, last.data[last.start]); + return Uint8Array.of(rs.byteSliceSame(first, last) ? 1 : 0, rs.byteSliceSame(first, again) ? 1 : 0, rs.byteSliceSame(first, middle) ? 1 : 0, rs.byteSliceSame(last, written) ? 1 : 0, last.data[last.start]); } /** * `ptr::read`, `write`, `swap`, and `replace`, a whole write and a write by index * through a pointer, and a reference made again of one. */ -export function moved(n: rt.u8): Uint8Array { - const a: Uint8Array = rt.bytes(4).fill(n); +export function moved(n: rs.u8): Uint8Array { + const a: Uint8Array = rs.bytes(4).fill(n); const b: Uint8Array = Uint8Array.of(1, 2, 3, n); - const p: rt.ByteSlice = rt.byteSliceFrom(a); - const q: rt.ByteSlice = rt.byteSliceFrom(b); - const read2: Uint8Array = rt.byteSliceToArray(p); + const p: rs.ByteSlice = rs.byteSliceFrom(a); + const q: rs.ByteSlice = rs.byteSliceFrom(b); + const read2: Uint8Array = rs.byteSliceToArray(p); const x = p; const y = q; - const old3 = rt.byteSliceToArray(x); - rt.byteSliceSet(x, rt.byteSliceToArray(y)); - rt.byteSliceSet(y, old3); + const old3 = rs.byteSliceToArray(x); + rs.byteSliceSet(x, rs.byteSliceToArray(y)); + rs.byteSliceSet(y, old3); const x2 = p; const y2 = p; - const old4 = rt.byteSliceToArray(x2); - rt.byteSliceSet(x2, rt.byteSliceToArray(y2)); - rt.byteSliceSet(y2, old4); + const old4 = rs.byteSliceToArray(x2); + rs.byteSliceSet(x2, rs.byteSliceToArray(y2)); + rs.byteSliceSet(y2, old4); const pointer = q; - const old5 = rt.byteSliceToArray(pointer); - rt.byteSliceSet(pointer, rt.bytes(4).fill(n ^ 15)); + const old5 = rs.byteSliceToArray(pointer); + rs.byteSliceSet(pointer, rs.bytes(4).fill(n ^ 15)); const old2: Uint8Array = old5; p.data[p.start] = old2[1]; - rt.byteSliceSet(q, Uint8Array.of(read2[0], 7, 8, 9)); + rs.byteSliceSet(q, Uint8Array.of(read2[0], 7, 8, 9)); p.data.set(Uint8Array.of(p.data[p.start], p.data[p.start + 1], q.data[q.start + 1], n), p.start); q.data[q.start + 3] = q.data[q.start + 3] ^ 64; const _39: Uint8Array = Uint8Array.of(q.data[q.start], q.data[q.start + 1], p.data[p.start + 3]); @@ -1256,56 +1256,56 @@ export function moved(n: rt.u8): Uint8Array { * Pointers `NonNull`, `Box`, `MaybeUninit`, and `UnsafeCell` make, and the references * made again of them. */ -export function wrapped(n: rt.u8): Uint8Array { +export function wrapped(n: rs.u8): Uint8Array { const a: Uint8Array = Uint8Array.of(n, 1, 2, 3); - const nonNull: rt.ByteSlice = rt.byteSliceFrom(a); - const shared: rt.ByteSlice = rt.byteSliceFrom(a); - const same: boolean = rt.byteSliceSame(nonNull, shared); - const _10: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceView(nonNull)); + const nonNull: rs.ByteSlice = rs.byteSliceFrom(a); + const shared: rs.ByteSlice = rs.byteSliceFrom(a); + const same: boolean = rs.byteSliceSame(nonNull, shared); + const _10: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceView(nonNull)); _10.data[_10.start + 1] = n ^ 85; - const _15: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceView(shared)); - const viewed: rt.u8 = _15.data[_15.start + 1]; + const _15: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceView(shared)); + const viewed: rs.u8 = _15.data[_15.start + 1]; const pointer = nonNull; - const _20: rt.ByteSlice = rt.optionUnwrap(rt.optionMap(pointer === rt.NULL ? undefined : rt.byteSliceView(pointer), rt.byteSliceFrom)); - const asRef: rt.u8 = _20.data[_20.start]; - const boxed: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(3).fill(n)); + const _20: rs.ByteSlice = rs.optionUnwrap(rs.optionMap(pointer === rs.NULL ? undefined : rs.byteSliceView(pointer), rs.byteSliceFrom)); + const asRef: rs.u8 = _20.data[_20.start]; + const boxed: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(3).fill(n)); boxed.data[boxed.start + 2] = 9; - const boxed2: Uint8Array = copy$array_u8(rt.byteSliceView(boxed)); + const boxed2: Uint8Array = copy$array_u8(rs.byteSliceView(boxed)); const uninit: Uint8Array = copy$mem_MaybeUninit_array_u8((new Uint8Array(2) as unknown) as Uint8Array); - const whole: rt.ByteSlice = rt.byteSliceFrom(uninit); - const slot: rt.ByteSlice = rt.byteSliceFrom(rt.byteSliceView(whole)); - const uninit3 = rt.byteSliceView(whole); - rt.ptrWrite(uninit3, Uint8Array.of(n, n)); - rt.byteSliceFrom(uninit3); + const whole: rs.ByteSlice = rs.byteSliceFrom(uninit); + const slot: rs.ByteSlice = rs.byteSliceFrom(rs.byteSliceView(whole)); + const uninit3 = rs.byteSliceView(whole); + rs.ptrWrite(uninit3, Uint8Array.of(n, n)); + rs.byteSliceFrom(uninit3); slot.data[slot.start + 1] = slot.data[slot.start + 1] ^ 34; - const aliased: boolean = rt.byteSliceSame(whole, slot); + const aliased: boolean = rs.byteSliceSame(whole, slot); const uninit2: Uint8Array = copy$mem_MaybeUninit_array_u8(uninit); - const cell: rt.Cell = new rt.Cell(rt.bytes(2).fill(n)); - const _51: rt.ByteSlice = rt.byteSliceFrom(cell.v); + const cell: rs.Cell = new rs.Cell(rs.bytes(2).fill(n)); + const _51: rs.ByteSlice = rs.byteSliceFrom(cell.v); _51.data[_51.start] = 4; const cell2: Uint8Array = cell.v; return Uint8Array.of(same ? 1 : 0, aliased ? 1 : 0, viewed, asRef, boxed2[0], boxed2[2], uninit2[0], uninit2[1], cell2[0], cell2[1], a[0], a[1], a[2], a[3]); } /** Pointers to parts of a vector's bytes, compared and written through. */ -export function inVec(n: rt.u8): Uint8Array { - const v: rt.ByteVec = rt.byteVecOf(n, 6); - const p: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceGetRange(rt.byteVecSlice(v), 0, 2)); - const q: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceGetRange(rt.byteVecSlice(v), 0, 2)); - const r: rt.ByteSlice = rt.optionUnwrap(rt.byteSliceLastChunk(rt.byteVecSlice(v), 2)); +export function inVec(n: rs.u8): Uint8Array { + const v: rs.ByteVec = rs.byteVecOf(n, 6); + const p: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceGetRange(rs.byteVecSlice(v), 0, 2)); + const q: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceGetRange(rs.byteVecSlice(v), 0, 2)); + const r: rs.ByteSlice = rs.optionUnwrap(rs.byteSliceLastChunk(rs.byteVecSlice(v), 2)); p.data[p.start + 1] = 9; - rt.byteSliceSet(p, Uint8Array.of(r.data[r.start] ^ 1, q.data[q.start + 1])); - return Uint8Array.of(rt.byteSliceSame(p, q) ? 1 : 0, rt.byteSliceSame(q, r) ? 1 : 0, v.data[rt.idx(v, 0)], v.data[rt.idx(v, 1)], v.data[rt.idx(v, 5)]); + rs.byteSliceSet(p, Uint8Array.of(r.data[r.start] ^ 1, q.data[q.start + 1])); + return Uint8Array.of(rs.byteSliceSame(p, q) ? 1 : 0, rs.byteSliceSame(q, r) ? 1 : 0, v.data[rs.idx(v, 0)], v.data[rs.idx(v, 1)], v.data[rs.idx(v, 5)]); } /** An `AtomicPtr` to an array, exchanged only for a pointer to it. */ -export function exchanged(n: rt.u8): Uint8Array { - const a: Uint8Array = rt.bytes(2).fill(n); - const b: Uint8Array = rt.bytes(2).fill(n ^ 1); - const at: rt.Atomic = new rt.Atomic(rt.byteSliceFrom(a)); - const missed: boolean = !rt.atomicCompareExchange(at, rt.byteSliceFrom(b), rt.byteSliceFrom(b), 4, 4, rt.byteSliceSame).ok; - const hit: boolean = rt.atomicCompareExchange(at, rt.byteSliceFrom(a), rt.byteSliceFrom(b), 4, 4, rt.byteSliceSame).ok; - const _25: rt.ByteSlice = rt.atomicLoad(at, 4); +export function exchanged(n: rs.u8): Uint8Array { + const a: Uint8Array = rs.bytes(2).fill(n); + const b: Uint8Array = rs.bytes(2).fill(n ^ 1); + const at: rs.Atomic = new rs.Atomic(rs.byteSliceFrom(a)); + const missed: boolean = !rs.atomicCompareExchange(at, rs.byteSliceFrom(b), rs.byteSliceFrom(b), 4, 4, rs.byteSliceSame).ok; + const hit: boolean = rs.atomicCompareExchange(at, rs.byteSliceFrom(a), rs.byteSliceFrom(b), 4, 4, rs.byteSliceSame).ok; + const _25: rs.ByteSlice = rs.atomicLoad(at, 4); _25.data[_25.start] = 3; return Uint8Array.of(missed ? 1 : 0, hit ? 1 : 0, b[0]); } @@ -1315,17 +1315,17 @@ export function exchanged(n: rt.u8): Uint8Array { * none of those pointers: each read out over a type parameter, as smallvec's `Drain` * reads its items, and kept past its array's next value. */ -export function loaded(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const n of rt.byteSliceView(data)) { +export function loaded(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const n of rs.byteSliceView(data)) { let pair: Loaded.Loaded[] = [{ _0: n, _1: 1 }, { _0: 2, _1: ~n & 0xff }]; - const first: Loaded.Loaded = option_unwrapOr$0mkoact(nextRead$pointers_Loaded(rt.iterSlice(pair)), { _0: 0, _1: 0 }); + const first: Loaded.Loaded = option_unwrapOr$0mkoact(nextRead$pointers_Loaded(rs.iterSlice(pair)), { _0: 0, _1: 0 }); pair = [{ _0: first._1, _1: n ^ 90 }, { _0: first._0, _1: n }]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(first._0, first._1, pair[0]._0, pair[0]._1, pair[1]._0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(first._0, first._1, pair[0]._0, pair[0]._1, pair[1]._0)), undefined, true); } } -export function nextRead$pointers_Loaded(items: rt.Iter): Loaded.Loaded | undefined { - return option_map$1cfrse5(rt.iterToOption(items.next()), (r: Loaded.Loaded): Loaded.Loaded => { +export function nextRead$pointers_Loaded(items: rs.Iter): Loaded.Loaded | undefined { + return option_map$1cfrse5(rs.iterToOption(items.next()), (r: Loaded.Loaded): Loaded.Loaded => { return r; }); } @@ -1336,46 +1336,46 @@ export function nextRead$pointers_Loaded(items: rt.Iter): Loaded. * read, as zlib's stream takes its window each round, by a callee over a type parameter, * into fields of one generic type: one into an array and one into a struct. */ -export function reattached(data: rt.ByteSlice, out: rt.ByteVec): void { - const window: Window.Window = { at: rt.NULL }; - let buf: rt.u16[] = Array.from({ length: 4 }, (): rt.u16 => { +export function reattached(data: rs.ByteSlice, out: rs.ByteVec): void { + const window: Window.Window = { at: rs.NULL }; + let buf: rs.u16[] = Array.from({ length: 4 }, (): rs.u16 => { return 0; }); - const slot: Window.Window = { at: rt.NULL }; + const slot: Window.Window = { at: rs.NULL }; let pair: Reattached.Reattached = { _0: 0, _1: 0 }; - for (const n of rt.byteSliceView(data)) { - const _17: rt.u16[] = buf; - attach$array4_u16(rt.place(() => window.at as rt.u16[], (value) => (window.at as rt.u16[]) = value), _17); - const _18: rt.u16 = ((n as rt.u16) << 7) & 0xffff; - const _22: rt.usize = rt.u8Rem(n, 4) as rt.usize; + for (const n of rs.byteSliceView(data)) { + const _17: rs.u16[] = buf; + attach$array4_u16(rs.place(() => window.at as rs.u16[], (value) => (window.at as rs.u16[]) = value), _17); + const _18: rs.u16 = ((n as rs.u16) << 7) & 0xffff; + const _22: rs.usize = rs.u8Rem(n, 4) as rs.usize; if (!(_22 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _22); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _22); } - (window.at as rt.u16[])[_22] = (window.at as rt.u16[])[_22] ^ _18; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap(buf, (b: rt.u16): rt.u8 => { + (window.at as rs.u16[])[_22] = (window.at as rs.u16[])[_22] ^ _18; + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(buf, (b: rs.u16): rs.u8 => { return (b >> 4) & 0xff; })), undefined, true); - const _29: rt.u16 = n as rt.u16; - buf = Array.from({ length: 4 }, (): rt.u16 => { + const _29: rs.u16 = n as rs.u16; + buf = Array.from({ length: 4 }, (): rs.u16 => { return _29; }); const _32: Reattached.Reattached = pair; - attach$pointers_Reattached(rt.place(() => slot.at as Reattached.Reattached, (value2) => (slot.at as Reattached.Reattached) = value2), _32); - const _33: rt.u8 = rt.u8WrappingAdd((slot.at as Reattached.Reattached)._0, n); + attach$pointers_Reattached(rs.place(() => slot.at as Reattached.Reattached, (value2) => (slot.at as Reattached.Reattached) = value2), _32); + const _33: rs.u8 = rs.u8WrappingAdd((slot.at as Reattached.Reattached)._0, n); (slot.at as Reattached.Reattached)._1 = _33; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(pair._0, pair._1)), undefined, true); pair = { _0: pair._1, _1: n }; } - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap(buf, (b2: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap(buf, (b2: rs.u16): rs.u8 => { return b2 & 0xff; })), undefined, true); } -export function attach$array4_u16(at: rt.Place, to: rt.u16[]): void { +export function attach$array4_u16(at: rs.Place, to: rs.u16[]): void { at.v = to; } -export function attach$pointers_Reattached(at: rt.Place, to: Reattached.Reattached): void { +export function attach$pointers_Reattached(at: rs.Place, to: Reattached.Reattached): void { at.v = to; } @@ -1386,44 +1386,44 @@ export function attach$pointers_Reattached(at: rt.Place, * pointer sees. Another struct's cell, which no pointer is taken into, is given another * cell by `mem::replace` through a `&mut` to the struct. */ -export function partWritten(data: rt.ByteSlice, out: rt.ByteVec): void { - const refilled: Refilled.Refilled = { cell: new rt.Cell(0) }; - for (const n of rt.byteSliceView(data)) { - rt.byteVecPush(out, refill(refilled, n)); - const w: Written.Written = { cell: new rt.Cell(n), tag: ~n & 0xff }; - const p: rt.Place = writtenCell(w.cell); - const seen: rt.u8 = p.v; +export function partWritten(data: rs.ByteSlice, out: rs.ByteVec): void { + const refilled: Refilled.Refilled = { cell: new rs.Cell(0) }; + for (const n of rs.byteSliceView(data)) { + rs.byteVecPush(out, refill(refilled, n)); + const w: Written.Written = { cell: new rs.Cell(n), tag: ~n & 0xff }; + const p: rs.Place = writtenCell(w.cell); + const seen: rs.u8 = p.v; overwrite(w.cell, n ^ 17); - const afterWrite: rt.u8 = p.v; - const old: rt.u8 = replaceCell(w.cell, n ^ 34); - const afterReplace: rt.u8 = p.v; + const afterWrite: rs.u8 = p.v; + const old: rs.u8 = replaceCell(w.cell, n ^ 34); + const afterReplace: rs.u8 = p.v; swapCell(w.cell, n ^ 51); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(seen, afterWrite, old, afterReplace, p.v, w.cell.v, w.tag)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(seen, afterWrite, old, afterReplace, p.v, w.cell.v, w.tag)), undefined, true); } } -export function writtenCell(c: rt.Cell): rt.Place { +export function writtenCell(c: rs.Cell): rs.Place { return c; } -export function overwrite(c: rt.Cell, n: rt.u8): void { - Object.assign(c, new rt.Cell(n)); +export function overwrite(c: rs.Cell, n: rs.u8): void { + Object.assign(c, new rs.Cell(n)); } -export function replaceCell(c: rt.Cell, n: rt.u8): rt.u8 { - return rt.replaceIn(c, new rt.Cell(n)).v; +export function replaceCell(c: rs.Cell, n: rs.u8): rs.u8 { + return rs.replaceIn(c, new rs.Cell(n)).v; } -export function refill(r: Refilled.Refilled, n: rt.u8): rt.u8 { - const _5: rt.Cell = new rt.Cell(n); +export function refill(r: Refilled.Refilled, n: rs.u8): rs.u8 { + const _5: rs.Cell = new rs.Cell(n); const old = r.cell; r.cell = _5; return old.v; } -export function swapCell(c: rt.Cell, n: rt.u8): void { - let _5: rt.Cell = new rt.Cell(n); - _5 = rt.replaceIn(c, _5); +export function swapCell(c: rs.Cell, n: rs.u8): void { + let _5: rs.Cell = new rs.Cell(n); + _5 = rs.replaceIn(c, _5); } /** @@ -1433,22 +1433,22 @@ export function swapCell(c: rt.Cell, n: rt.u8): void { * type's instance: read and written through, and compared where JS can compare them. * An `AtomicPtr` to the parameter and references to it are held beside them. */ -export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { +export function aimed(data: rs.ByteSlice, out: rs.ByteVec): void { let _17!: Paired.Paired | undefined; let _22!: To.To; - let _43!: rt.Place | undefined; - let _48!: To.To; + let _43!: rs.Place | undefined; + let _48!: To.To; let signed!: Leaning.Leaning; - let _72!: rt.Place | undefined; + let _72!: rs.Place | undefined; let _77!: To.To; - let _98!: rt.ByteSlice | undefined; + let _98!: rs.ByteSlice | undefined; let _103!: To.To; - let _124!: rt.Place> | undefined; - let _129!: To.To>; - let _154!: rt.u16[] | undefined; - let _159!: To.To; - let _180!: Housed.Housed | undefined; - let _185!: To.To>; + let _124!: rs.Place> | undefined; + let _129!: To.To>; + let _154!: rs.u16[] | undefined; + let _159!: To.To; + let _180!: Housed.Housed | undefined; + let _185!: To.To>; let _214!: Paired.Paired | undefined; let _219!: To.To; let _232!: Paired.Paired | undefined; @@ -1460,9 +1460,9 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { let _262!: boolean; let _270!: boolean; let _272!: boolean; - let _347!: rt.ByteSlice | undefined; + let _347!: rs.ByteSlice | undefined; let _352!: To.To; - let _365!: rt.ByteSlice | undefined; + let _365!: rs.ByteSlice | undefined; let _370!: To.To; let same2!: boolean[]; let _380!: boolean; @@ -1471,10 +1471,10 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { let _395!: boolean; let _403!: boolean; let _405!: boolean; - let _480!: Housed.Housed | undefined; - let _485!: To.To>; - let _498!: Housed.Housed | undefined; - let _503!: To.To>; + let _480!: Housed.Housed | undefined; + let _485!: To.To>; + let _498!: Housed.Housed | undefined; + let _503!: To.To>; let same3!: boolean[]; let _513!: boolean; let _519!: boolean; @@ -1482,209 +1482,209 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { let _528!: boolean; let _536!: boolean; let _538!: boolean; - const _322: (a0: boolean[]) => rt.u8 = (b: boolean[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(b), 0, (acc: rt.u8, _33: boolean): rt.u8 => { + const _322: (a0: boolean[]) => rs.u8 = (b: boolean[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(b), 0, (acc: rs.u8, _33: boolean): rs.u8 => { return ((acc << 1) & 0xff) | (_33 ? 1 : 0); }); }; - const _455: (a0: boolean[]) => rt.u8 = (b3: boolean[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(b3), 0, (acc2: rt.u8, _36: boolean): rt.u8 => { + const _455: (a0: boolean[]) => rs.u8 = (b3: boolean[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(b3), 0, (acc2: rs.u8, _36: boolean): rs.u8 => { return ((acc2 << 1) & 0xff) | (_36 ? 1 : 0); }); }; - const _588: (a0: boolean[]) => rt.u8 = (b5: boolean[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(b5), 0, (acc3: rt.u8, _38: boolean): rt.u8 => { + const _588: (a0: boolean[]) => rs.u8 = (b5: boolean[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(b5), 0, (acc3: rs.u8, _38: boolean): rs.u8 => { return ((acc3 << 1) & 0xff) | (_38 ? 1 : 0); }); }; - for (const n of rt.byteSliceView(data)) { + for (const n of rs.byteSliceView(data)) { const pair: Paired.Paired = { _0: n, _1: ~n & 0xff }; const at: Paired.Paired = pair; const pointer = at; - const held: Paired.Paired = rt.optionUnwrap(pointer === rt.NULL ? undefined : pointer); + const held: Paired.Paired = rs.optionUnwrap(pointer === rs.NULL ? undefined : pointer); const _16: Paired.Paired = at; - if (!(rt.u8Rem(n, 2) === 0)) { + if (!(rs.u8Rem(n, 2) === 0)) { _17 = undefined; } else { _17 = held; } - const _21: [Paired.Paired, rt.u8] = [at, n]; - if (!(rt.u8Rem(n, 3) === 0)) { + const _21: [Paired.Paired, rs.u8] = [at, n]; + if (!(rs.u8Rem(n, 3) === 0)) { _22 = { tag: "Nowhere" } as To.To; } else { _22 = { tag: "At", _0: at } as To.To; } - through$pointers_Paired({ inner: { at, seen: _16, held, maybe: _17, tagged: _21, to: _22, read: readThrough$pointers_Paired as (a0: rt.Ptr) => rt.u8 } }, n, out); + through$pointers_Paired({ inner: { at, seen: _16, held, maybe: _17, tagged: _21, to: _22, read: readThrough$pointers_Paired as (a0: rs.Ptr) => rs.u8 } }, n, out); swappedIn$pointers_Paired(pair, n, out); lend$pointers_Paired(pair, n, out); - rt.byteVecPush(out, Paired.get$pointers_Aim(pair)); - let num: rt.u8 = n; - const at2: rt.Place = rt.place(() => num, (value) => num = value); + rs.byteVecPush(out, Paired.get$pointers_Aim(pair)); + let num: rs.u8 = n; + const at2: rs.Place = rs.place(() => num, (value) => num = value); const pointer2 = at2; - const held2: rt.Place = rt.optionUnwrap(pointer2 === rt.NULL ? undefined : pointer2); - const _42: rt.Place = at2; - if (!(rt.u8Rem(n, 2) === 0)) { + const held2: rs.Place = rs.optionUnwrap(pointer2 === rs.NULL ? undefined : pointer2); + const _42: rs.Place = at2; + if (!(rs.u8Rem(n, 2) === 0)) { _43 = undefined; } else { _43 = held2; } - const _47: [rt.Place, rt.u8] = [at2, n]; - if (!(rt.u8Rem(n, 3) === 0)) { - _48 = { tag: "Nowhere" } as To.To; + const _47: [rs.Place, rs.u8] = [at2, n]; + if (!(rs.u8Rem(n, 3) === 0)) { + _48 = { tag: "Nowhere" } as To.To; } else { - _48 = { tag: "At", _0: at2 } as To.To; + _48 = { tag: "At", _0: at2 } as To.To; } - through$u8({ inner: { at: at2, seen: _42, held: held2, maybe: _43, tagged: _47, to: _48, read: readThrough$u8 as (a0: rt.Ptr) => rt.u8 } }, n, out); - swappedIn$u8(rt.place(() => num, (value2) => num = value2), n, out); - lend$u8(rt.place(() => num, (value3) => num = value3), n, out); - rt.byteVecPush(out, get$pointers_Aim_u8(num)); - if (!(rt.u8Rem(n, 2) === 0)) { + through$u8({ inner: { at: at2, seen: _42, held: held2, maybe: _43, tagged: _47, to: _48, read: readThrough$u8 as (a0: rs.Ptr) => rs.u8 } }, n, out); + swappedIn$u8(rs.place(() => num, (value2) => num = value2), n, out); + lend$u8(rs.place(() => num, (value3) => num = value3), n, out); + rs.byteVecPush(out, get$pointers_Aim_u8(num)); + if (!(rs.u8Rem(n, 2) === 0)) { signed = { tag: "Neg", _0: n } as Leaning.Leaning; } else { signed = { tag: "Pos", _0: n } as Leaning.Leaning; } - const at3: rt.Place = rt.place(() => signed, (value4) => signed = value4); + const at3: rs.Place = rs.place(() => signed, (value4) => signed = value4); const pointer3 = at3; - const held3: rt.Place = rt.optionUnwrap(pointer3 === rt.NULL ? undefined : pointer3); - const _71: rt.Place = at3; - if (!(rt.u8Rem(n, 2) === 0)) { + const held3: rs.Place = rs.optionUnwrap(pointer3 === rs.NULL ? undefined : pointer3); + const _71: rs.Place = at3; + if (!(rs.u8Rem(n, 2) === 0)) { _72 = undefined; } else { _72 = held3; } - const _76: [rt.Place, rt.u8] = [at3, n]; - if (!(rt.u8Rem(n, 3) === 0)) { + const _76: [rs.Place, rs.u8] = [at3, n]; + if (!(rs.u8Rem(n, 3) === 0)) { _77 = { tag: "Nowhere" } as To.To; } else { _77 = { tag: "At", _0: at3 } as To.To; } - through$pointers_Leaning({ inner: { at: at3, seen: _71, held: held3, maybe: _72, tagged: _76, to: _77, read: readThrough$pointers_Leaning as (a0: rt.Ptr) => rt.u8 } }, n, out); - swappedIn$pointers_Leaning(rt.place(() => signed, (value5) => signed = value5), n, out); - lend$pointers_Leaning(rt.place(() => signed, (value6) => signed = value6), n, out); - rt.byteVecPush(out, Leaning.get$pointers_Aim(signed)); - const bytes: Uint8Array = rt.bytes(4).fill(n); - const at4: rt.ByteSlice = rt.byteSliceFrom(bytes); + through$pointers_Leaning({ inner: { at: at3, seen: _71, held: held3, maybe: _72, tagged: _76, to: _77, read: readThrough$pointers_Leaning as (a0: rs.Ptr) => rs.u8 } }, n, out); + swappedIn$pointers_Leaning(rs.place(() => signed, (value5) => signed = value5), n, out); + lend$pointers_Leaning(rs.place(() => signed, (value6) => signed = value6), n, out); + rs.byteVecPush(out, Leaning.get$pointers_Aim(signed)); + const bytes: Uint8Array = rs.bytes(4).fill(n); + const at4: rs.ByteSlice = rs.byteSliceFrom(bytes); const pointer4 = at4; - const held4: rt.ByteSlice = rt.optionUnwrap(pointer4 === rt.NULL ? undefined : pointer4); - const _97: rt.ByteSlice = at4; - if (!(rt.u8Rem(n, 2) === 0)) { + const held4: rs.ByteSlice = rs.optionUnwrap(pointer4 === rs.NULL ? undefined : pointer4); + const _97: rs.ByteSlice = at4; + if (!(rs.u8Rem(n, 2) === 0)) { _98 = undefined; } else { _98 = held4; } - const _102: [rt.ByteSlice, rt.u8] = [at4, n]; - if (!(rt.u8Rem(n, 3) === 0)) { + const _102: [rs.ByteSlice, rs.u8] = [at4, n]; + if (!(rs.u8Rem(n, 3) === 0)) { _103 = { tag: "Nowhere" } as To.To; } else { _103 = { tag: "At", _0: at4 } as To.To; } - through$array4_u8({ inner: { at: at4, seen: _97, held: held4, maybe: _98, tagged: _102, to: _103, read: readThrough$array4_u8 as (a0: rt.Ptr) => rt.u8 } }, n, out); - swappedIn$array4_u8(rt.byteSliceFrom(bytes), n, out); - lend$array4_u8(rt.byteSliceFrom(bytes), n, out); - const _116: rt.ByteSlice = rt.byteSliceFrom(bytes); - rt.byteVecPush(out, get$pointers_Aim_array4_u8(_116.data, _116.start, _116.length)); - let cell: rt.Cell = new rt.Cell(n); - const at5: rt.Place> = rt.place(() => cell, (value7) => cell = value7); + through$array4_u8({ inner: { at: at4, seen: _97, held: held4, maybe: _98, tagged: _102, to: _103, read: readThrough$array4_u8 as (a0: rs.Ptr) => rs.u8 } }, n, out); + swappedIn$array4_u8(rs.byteSliceFrom(bytes), n, out); + lend$array4_u8(rs.byteSliceFrom(bytes), n, out); + const _116: rs.ByteSlice = rs.byteSliceFrom(bytes); + rs.byteVecPush(out, get$pointers_Aim_array4_u8(_116.data, _116.start, _116.length)); + let cell: rs.Cell = new rs.Cell(n); + const at5: rs.Place> = rs.place(() => cell, (value7) => cell = value7); const pointer5 = at5; - const held5: rt.Place> = rt.optionUnwrap(pointer5 === rt.NULL ? undefined : pointer5); - const _123: rt.Place> = at5; - if (!(rt.u8Rem(n, 2) === 0)) { + const held5: rs.Place> = rs.optionUnwrap(pointer5 === rs.NULL ? undefined : pointer5); + const _123: rs.Place> = at5; + if (!(rs.u8Rem(n, 2) === 0)) { _124 = undefined; } else { _124 = held5; } - const _128: [rt.Place>, rt.u8] = [at5, n]; - if (!(rt.u8Rem(n, 3) === 0)) { - _129 = { tag: "Nowhere" } as To.To>; + const _128: [rs.Place>, rs.u8] = [at5, n]; + if (!(rs.u8Rem(n, 3) === 0)) { + _129 = { tag: "Nowhere" } as To.To>; } else { - _129 = { tag: "At", _0: at5 } as To.To>; + _129 = { tag: "At", _0: at5 } as To.To>; } - through$Cell_u8({ inner: { at: at5, seen: _123, held: held5, maybe: _124, tagged: _128, to: _129, read: readThrough$Cell_u8 as (a0: rt.Ptr>) => rt.u8 } }, n, out); - swappedIn$Cell_u8(rt.place(() => cell, (value8) => cell = value8), n, out); + through$Cell_u8({ inner: { at: at5, seen: _123, held: held5, maybe: _124, tagged: _128, to: _129, read: readThrough$Cell_u8 as (a0: rs.Ptr>) => rs.u8 } }, n, out); + swappedIn$Cell_u8(rs.place(() => cell, (value8) => cell = value8), n, out); lend$Cell_u8(cell, n, out); - rt.byteVecPush(out, cell.v); - const _144: rt.u16 = ((n as rt.u16) << 4) & 0xffff; - const wide: rt.u16[] = Array.from({ length: 2 }, (): rt.u16 => { + rs.byteVecPush(out, cell.v); + const _144: rs.u16 = ((n as rs.u16) << 4) & 0xffff; + const wide: rs.u16[] = Array.from({ length: 2 }, (): rs.u16 => { return _144; }); - const at6: rt.u16[] = wide; + const at6: rs.u16[] = wide; const pointer6 = at6; - const held6: rt.u16[] = rt.optionUnwrap(pointer6 === rt.NULL ? undefined : pointer6); - const _153: rt.u16[] = at6; - if (!(rt.u8Rem(n, 2) === 0)) { + const held6: rs.u16[] = rs.optionUnwrap(pointer6 === rs.NULL ? undefined : pointer6); + const _153: rs.u16[] = at6; + if (!(rs.u8Rem(n, 2) === 0)) { _154 = undefined; } else { _154 = held6; } - const _158: [rt.u16[], rt.u8] = [at6, n]; - if (!(rt.u8Rem(n, 3) === 0)) { - _159 = { tag: "Nowhere" } as To.To; + const _158: [rs.u16[], rs.u8] = [at6, n]; + if (!(rs.u8Rem(n, 3) === 0)) { + _159 = { tag: "Nowhere" } as To.To; } else { - _159 = { tag: "At", _0: at6 } as To.To; + _159 = { tag: "At", _0: at6 } as To.To; } - through$array2_u16({ inner: { at: at6, seen: _153, held: held6, maybe: _154, tagged: _158, to: _159, read: readThrough$array2_u16 as (a0: rt.Ptr) => rt.u8 } }, n, out); + through$array2_u16({ inner: { at: at6, seen: _153, held: held6, maybe: _154, tagged: _158, to: _159, read: readThrough$array2_u16 as (a0: rs.Ptr) => rs.u8 } }, n, out); swappedIn$array2_u16(wide, n, out); lend$array2_u16(wide, n, out); - rt.byteVecPush(out, get$pointers_Aim_array2_u16(wide)); - const wrap: Housed.Housed = new Housed.Housed(n); - const at7: Housed.Housed = wrap; + rs.byteVecPush(out, get$pointers_Aim_array2_u16(wide)); + const wrap: Housed.Housed = new Housed.Housed(n); + const at7: Housed.Housed = wrap; const pointer7 = at7; - const held7: Housed.Housed = rt.optionUnwrap(pointer7 === rt.NULL ? undefined : pointer7); - const _179: Housed.Housed = at7; - if (!(rt.u8Rem(n, 2) === 0)) { + const held7: Housed.Housed = rs.optionUnwrap(pointer7 === rs.NULL ? undefined : pointer7); + const _179: Housed.Housed = at7; + if (!(rs.u8Rem(n, 2) === 0)) { _180 = undefined; } else { _180 = held7; } - const _184: [Housed.Housed, rt.u8] = [at7, n]; - if (!(rt.u8Rem(n, 3) === 0)) { - _185 = { tag: "Nowhere" } as To.To>; + const _184: [Housed.Housed, rs.u8] = [at7, n]; + if (!(rs.u8Rem(n, 3) === 0)) { + _185 = { tag: "Nowhere" } as To.To>; } else { - _185 = { tag: "At", _0: at7 } as To.To>; + _185 = { tag: "At", _0: at7 } as To.To>; } - through$pointers_Housed_u8({ inner: { at: at7, seen: _179, held: held7, maybe: _180, tagged: _184, to: _185, read: readThrough$pointers_Housed_u8 as (a0: rt.Ptr>) => rt.u8 } }, n, out); + through$pointers_Housed_u8({ inner: { at: at7, seen: _179, held: held7, maybe: _180, tagged: _184, to: _185, read: readThrough$pointers_Housed_u8 as (a0: rs.Ptr>) => rs.u8 } }, n, out); swappedIn$pointers_Housed_u8(wrap, n, out); lend$pointers_Housed_u8(wrap, n, out); - rt.byteVecPush(out, Housed.get$pointers_Aim_u8(wrap)); + rs.byteVecPush(out, Housed.get$pointers_Aim_u8(wrap)); const other: Paired.Paired = { _0: ~n & 0xff, _1: n }; - const otherBytes: Uint8Array = rt.bytes(4).fill(~n & 0xff); - const otherWrap: Housed.Housed = new Housed.Housed(~n & 0xff); + const otherBytes: Uint8Array = rs.bytes(4).fill(~n & 0xff); + const otherWrap: Housed.Housed = new Housed.Housed(~n & 0xff); const other2: Paired.Paired = other; const at8: Paired.Paired = pair; const pointer8 = at8; - const held8: Paired.Paired = rt.optionUnwrap(pointer8 === rt.NULL ? undefined : pointer8); + const held8: Paired.Paired = rs.optionUnwrap(pointer8 === rs.NULL ? undefined : pointer8); const _213: Paired.Paired = at8; if (false) { _214 = undefined; } else { _214 = held8; } - const _218: [Paired.Paired, rt.u8] = [at8, 0]; + const _218: [Paired.Paired, rs.u8] = [at8, 0]; if (false) { _219 = { tag: "Nowhere" } as To.To; } else { _219 = { tag: "At", _0: at8 } as To.To; } - const nest8: Enclosed.Enclosed = { inner: { at: at8, seen: _213, held: held8, maybe: _214, tagged: _218, to: _219, read: readThrough$pointers_Paired as (a0: rt.Ptr) => rt.u8 } }; + const nest8: Enclosed.Enclosed = { inner: { at: at8, seen: _213, held: held8, maybe: _214, tagged: _218, to: _219, read: readThrough$pointers_Paired as (a0: rs.Ptr) => rs.u8 } }; const at9: Paired.Paired = pair; const pointer9 = at9; - const held9: Paired.Paired = rt.optionUnwrap(pointer9 === rt.NULL ? undefined : pointer9); + const held9: Paired.Paired = rs.optionUnwrap(pointer9 === rs.NULL ? undefined : pointer9); const _231: Paired.Paired = at9; if (true) { _232 = undefined; } else { _232 = held9; } - const _236: [Paired.Paired, rt.u8] = [at9, 1]; + const _236: [Paired.Paired, rs.u8] = [at9, 1]; if (true) { _237 = { tag: "Nowhere" } as To.To; } else { _237 = { tag: "At", _0: at9 } as To.To; } - const none: Paired.Paired | undefined = { at: at9, seen: _231, held: held9, maybe: _232, tagged: _236, to: _237, read: readThrough$pointers_Paired as (a0: rt.Ptr) => rt.u8 }.maybe as Paired.Paired | undefined; + const none: Paired.Paired | undefined = { at: at9, seen: _231, held: held9, maybe: _232, tagged: _236, to: _237, read: readThrough$pointers_Paired as (a0: rs.Ptr) => rs.u8 }.maybe as Paired.Paired | undefined; const _243: boolean = (nest8.inner.at as Paired.Paired) === nest8.inner.seen as Paired.Paired; const pointer10 = nest8.inner.at as Paired.Paired; - const _250: Paired.Paired = rt.optionUnwrap(pointer10 === rt.NULL ? undefined : pointer10); + const _250: Paired.Paired = rs.optionUnwrap(pointer10 === rs.NULL ? undefined : pointer10); b21: { _247 = (nest8.inner.held as Paired.Paired) === _250; if ((nest8.inner.maybe as Paired.Paired | undefined) !== undefined) { @@ -1696,7 +1696,7 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _253 = false; } b23: { - _259 = (nest8.inner.tagged as [Paired.Paired, rt.u8])[0] === nest8.inner.at as Paired.Paired; + _259 = (nest8.inner.tagged as [Paired.Paired, rs.u8])[0] === nest8.inner.at as Paired.Paired; if (nest8.inner.to.tag === "At") { if ((nest8.inner.to._0 as Paired.Paired) === nest8.inner.at as Paired.Paired) { _262 = true; @@ -1718,52 +1718,52 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _272 = false; } const apart: boolean[] = [_270, _272, (nest8.inner.seen as Paired.Paired) === other2]; - const null_: Paired.Paired = rt.NULL; + const null_: Paired.Paired = rs.NULL; const _284: boolean = (nest8.inner.maybe as Paired.Paired | undefined) === nest8.inner.held as Paired.Paired; const _289: boolean = (nest8.inner.maybe as Paired.Paired | undefined) !== nest8.inner.held as Paired.Paired; const pointer11 = other2; - const optional: boolean[] = [_284, _289, (nest8.inner.maybe as Paired.Paired | undefined) === (pointer11 === rt.NULL ? undefined : pointer11), (nest8.inner.maybe as Paired.Paired | undefined) === none, none === undefined, (nest8.inner.seen as Paired.Paired) === nest8.inner.at as Paired.Paired, (nest8.inner.seen as Paired.Paired) !== null_, null_ === rt.NULL]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_322(same), _322(apart), _322(optional))), undefined, true); - const other3: rt.ByteSlice = rt.byteSliceFrom(otherBytes); - const at10: rt.ByteSlice = rt.byteSliceFrom(bytes); + const optional: boolean[] = [_284, _289, (nest8.inner.maybe as Paired.Paired | undefined) === (pointer11 === rs.NULL ? undefined : pointer11), (nest8.inner.maybe as Paired.Paired | undefined) === none, none === undefined, (nest8.inner.seen as Paired.Paired) === nest8.inner.at as Paired.Paired, (nest8.inner.seen as Paired.Paired) !== null_, null_ === rs.NULL]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_322(same), _322(apart), _322(optional))), undefined, true); + const other3: rs.ByteSlice = rs.byteSliceFrom(otherBytes); + const at10: rs.ByteSlice = rs.byteSliceFrom(bytes); const pointer12 = at10; - const held10: rt.ByteSlice = rt.optionUnwrap(pointer12 === rt.NULL ? undefined : pointer12); - const _346: rt.ByteSlice = at10; + const held10: rs.ByteSlice = rs.optionUnwrap(pointer12 === rs.NULL ? undefined : pointer12); + const _346: rs.ByteSlice = at10; if (false) { _347 = undefined; } else { _347 = held10; } - const _351: [rt.ByteSlice, rt.u8] = [at10, 0]; + const _351: [rs.ByteSlice, rs.u8] = [at10, 0]; if (false) { _352 = { tag: "Nowhere" } as To.To; } else { _352 = { tag: "At", _0: at10 } as To.To; } - const nest9: Enclosed.Enclosed = { inner: { at: at10, seen: _346, held: held10, maybe: _347, tagged: _351, to: _352, read: readThrough$array4_u8 as (a0: rt.Ptr) => rt.u8 } }; - const at11: rt.ByteSlice = rt.byteSliceFrom(bytes); + const nest9: Enclosed.Enclosed = { inner: { at: at10, seen: _346, held: held10, maybe: _347, tagged: _351, to: _352, read: readThrough$array4_u8 as (a0: rs.Ptr) => rs.u8 } }; + const at11: rs.ByteSlice = rs.byteSliceFrom(bytes); const pointer13 = at11; - const held11: rt.ByteSlice = rt.optionUnwrap(pointer13 === rt.NULL ? undefined : pointer13); - const _364: rt.ByteSlice = at11; + const held11: rs.ByteSlice = rs.optionUnwrap(pointer13 === rs.NULL ? undefined : pointer13); + const _364: rs.ByteSlice = at11; if (true) { _365 = undefined; } else { _365 = held11; } - const _369: [rt.ByteSlice, rt.u8] = [at11, 1]; + const _369: [rs.ByteSlice, rs.u8] = [at11, 1]; if (true) { _370 = { tag: "Nowhere" } as To.To; } else { _370 = { tag: "At", _0: at11 } as To.To; } - const none2: rt.ByteSlice | undefined = { at: at11, seen: _364, held: held11, maybe: _365, tagged: _369, to: _370, read: readThrough$array4_u8 as (a0: rt.Ptr) => rt.u8 }.maybe as rt.ByteSlice | undefined; - const _376: boolean = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, nest9.inner.seen as rt.ByteSlice); - const pointer14 = nest9.inner.at as rt.ByteSlice; - const _383: rt.ByteSlice = rt.optionUnwrap(pointer14 === rt.NULL ? undefined : pointer14); + const none2: rs.ByteSlice | undefined = { at: at11, seen: _364, held: held11, maybe: _365, tagged: _369, to: _370, read: readThrough$array4_u8 as (a0: rs.Ptr) => rs.u8 }.maybe as rs.ByteSlice | undefined; + const _376: boolean = rs.byteSliceSame(nest9.inner.at as rs.ByteSlice, nest9.inner.seen as rs.ByteSlice); + const pointer14 = nest9.inner.at as rs.ByteSlice; + const _383: rs.ByteSlice = rs.optionUnwrap(pointer14 === rs.NULL ? undefined : pointer14); b31: { - _380 = rt.byteSliceSame(nest9.inner.held as rt.ByteSlice, _383); - if ((nest9.inner.maybe as rt.ByteSlice | undefined) !== undefined) { - if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, nest9.inner.held as rt.ByteSlice)) { + _380 = rs.byteSliceSame(nest9.inner.held as rs.ByteSlice, _383); + if ((nest9.inner.maybe as rs.ByteSlice | undefined) !== undefined) { + if (rs.byteSliceSame((nest9.inner.maybe as rs.ByteSlice | undefined) as rs.ByteSlice, nest9.inner.held as rs.ByteSlice)) { _386 = true; break b31; } @@ -1771,9 +1771,9 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _386 = false; } b33: { - _392 = rt.byteSliceSame((nest9.inner.tagged as [rt.ByteSlice, rt.u8])[0], nest9.inner.at as rt.ByteSlice); + _392 = rs.byteSliceSame((nest9.inner.tagged as [rs.ByteSlice, rs.u8])[0], nest9.inner.at as rs.ByteSlice); if (nest9.inner.to.tag === "At") { - if (rt.byteSliceSame(nest9.inner.to._0 as rt.ByteSlice, nest9.inner.at as rt.ByteSlice)) { + if (rs.byteSliceSame(nest9.inner.to._0 as rs.ByteSlice, nest9.inner.at as rs.ByteSlice)) { _395 = true; break b33; } @@ -1781,73 +1781,73 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _395 = false; } b35: { - _403 = rt.byteSliceSame(nest9.inner.at as rt.ByteSlice, other3); - const scrutinee4 = nest9.inner.maybe as rt.ByteSlice | undefined; + _403 = rs.byteSliceSame(nest9.inner.at as rs.ByteSlice, other3); + const scrutinee4 = nest9.inner.maybe as rs.ByteSlice | undefined; same2 = [_376, _380, _386, _392, _395]; if (scrutinee4 !== undefined) { - if (rt.byteSliceSame((nest9.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, other3)) { + if (rs.byteSliceSame((nest9.inner.maybe as rs.ByteSlice | undefined) as rs.ByteSlice, other3)) { _405 = true; break b35; } } _405 = false; } - const apart2: boolean[] = [_403, _405, rt.byteSliceSame(nest9.inner.seen as rt.ByteSlice, other3)]; - const null_2: rt.ByteSlice = rt.NULL; - const _420: rt.ByteSlice | undefined = nest9.inner.held as rt.ByteSlice; - const _417: boolean = rt.eqOption(rt.byteSliceSame)(nest9.inner.maybe as rt.ByteSlice | undefined, _420); - const _425: rt.ByteSlice | undefined = nest9.inner.held as rt.ByteSlice; - const _422: boolean = !rt.eqOption(rt.byteSliceSame)(nest9.inner.maybe as rt.ByteSlice | undefined, _425); + const apart2: boolean[] = [_403, _405, rs.byteSliceSame(nest9.inner.seen as rs.ByteSlice, other3)]; + const null_2: rs.ByteSlice = rs.NULL; + const _420: rs.ByteSlice | undefined = nest9.inner.held as rs.ByteSlice; + const _417: boolean = rs.eqOption(rs.byteSliceSame)(nest9.inner.maybe as rs.ByteSlice | undefined, _420); + const _425: rs.ByteSlice | undefined = nest9.inner.held as rs.ByteSlice; + const _422: boolean = !rs.eqOption(rs.byteSliceSame)(nest9.inner.maybe as rs.ByteSlice | undefined, _425); const pointer15 = other3; - const _427: boolean = rt.eqOption(rt.byteSliceSame)(nest9.inner.maybe as rt.ByteSlice | undefined, pointer15 === rt.NULL ? undefined : pointer15); - const _431: boolean = rt.eqOption(rt.byteSliceSame)(nest9.inner.maybe as rt.ByteSlice | undefined, none2); - const _434: boolean = rt.eqOption(rt.byteSliceSame)(none2, undefined); - const _439: rt.ByteSlice | undefined = nest9.inner.seen as rt.ByteSlice; - const _442: rt.ByteSlice | undefined = nest9.inner.at as rt.ByteSlice; - const _437: boolean = rt.eqOption(rt.byteSliceSame)(_439, _442); - const _447: rt.ByteSlice | undefined = nest9.inner.seen as rt.ByteSlice; - const optional2: boolean[] = [_417, _422, _427, _431, _434, _437, !rt.eqOption(rt.byteSliceSame)(_447, null_2), rt.eqOption(rt.byteSliceSame)(null_2, rt.NULL)]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_455(same2), _455(apart2), _455(optional2))), undefined, true); - const other4: Housed.Housed = otherWrap; - const at12: Housed.Housed = wrap; + const _427: boolean = rs.eqOption(rs.byteSliceSame)(nest9.inner.maybe as rs.ByteSlice | undefined, pointer15 === rs.NULL ? undefined : pointer15); + const _431: boolean = rs.eqOption(rs.byteSliceSame)(nest9.inner.maybe as rs.ByteSlice | undefined, none2); + const _434: boolean = rs.eqOption(rs.byteSliceSame)(none2, undefined); + const _439: rs.ByteSlice | undefined = nest9.inner.seen as rs.ByteSlice; + const _442: rs.ByteSlice | undefined = nest9.inner.at as rs.ByteSlice; + const _437: boolean = rs.eqOption(rs.byteSliceSame)(_439, _442); + const _447: rs.ByteSlice | undefined = nest9.inner.seen as rs.ByteSlice; + const optional2: boolean[] = [_417, _422, _427, _431, _434, _437, !rs.eqOption(rs.byteSliceSame)(_447, null_2), rs.eqOption(rs.byteSliceSame)(null_2, rs.NULL)]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_455(same2), _455(apart2), _455(optional2))), undefined, true); + const other4: Housed.Housed = otherWrap; + const at12: Housed.Housed = wrap; const pointer16 = at12; - const held12: Housed.Housed = rt.optionUnwrap(pointer16 === rt.NULL ? undefined : pointer16); - const _479: Housed.Housed = at12; + const held12: Housed.Housed = rs.optionUnwrap(pointer16 === rs.NULL ? undefined : pointer16); + const _479: Housed.Housed = at12; if (false) { _480 = undefined; } else { _480 = held12; } - const _484: [Housed.Housed, rt.u8] = [at12, 0]; + const _484: [Housed.Housed, rs.u8] = [at12, 0]; if (false) { - _485 = { tag: "Nowhere" } as To.To>; + _485 = { tag: "Nowhere" } as To.To>; } else { - _485 = { tag: "At", _0: at12 } as To.To>; + _485 = { tag: "At", _0: at12 } as To.To>; } - const nest10: Enclosed.Enclosed> = { inner: { at: at12, seen: _479, held: held12, maybe: _480, tagged: _484, to: _485, read: readThrough$pointers_Housed_u8 as (a0: rt.Ptr>) => rt.u8 } }; - const at13: Housed.Housed = wrap; + const nest10: Enclosed.Enclosed> = { inner: { at: at12, seen: _479, held: held12, maybe: _480, tagged: _484, to: _485, read: readThrough$pointers_Housed_u8 as (a0: rs.Ptr>) => rs.u8 } }; + const at13: Housed.Housed = wrap; const pointer17 = at13; - const held13: Housed.Housed = rt.optionUnwrap(pointer17 === rt.NULL ? undefined : pointer17); - const _497: Housed.Housed = at13; + const held13: Housed.Housed = rs.optionUnwrap(pointer17 === rs.NULL ? undefined : pointer17); + const _497: Housed.Housed = at13; if (true) { _498 = undefined; } else { _498 = held13; } - const _502: [Housed.Housed, rt.u8] = [at13, 1]; + const _502: [Housed.Housed, rs.u8] = [at13, 1]; if (true) { - _503 = { tag: "Nowhere" } as To.To>; + _503 = { tag: "Nowhere" } as To.To>; } else { - _503 = { tag: "At", _0: at13 } as To.To>; + _503 = { tag: "At", _0: at13 } as To.To>; } - const none3: Housed.Housed | undefined = { at: at13, seen: _497, held: held13, maybe: _498, tagged: _502, to: _503, read: readThrough$pointers_Housed_u8 as (a0: rt.Ptr>) => rt.u8 }.maybe as Housed.Housed | undefined; - const _509: boolean = (nest10.inner.at as Housed.Housed) === nest10.inner.seen as Housed.Housed; - const pointer18 = nest10.inner.at as Housed.Housed; - const _516: Housed.Housed = rt.optionUnwrap(pointer18 === rt.NULL ? undefined : pointer18); + const none3: Housed.Housed | undefined = { at: at13, seen: _497, held: held13, maybe: _498, tagged: _502, to: _503, read: readThrough$pointers_Housed_u8 as (a0: rs.Ptr>) => rs.u8 }.maybe as Housed.Housed | undefined; + const _509: boolean = (nest10.inner.at as Housed.Housed) === nest10.inner.seen as Housed.Housed; + const pointer18 = nest10.inner.at as Housed.Housed; + const _516: Housed.Housed = rs.optionUnwrap(pointer18 === rs.NULL ? undefined : pointer18); b41: { - _513 = (nest10.inner.held as Housed.Housed) === _516; - if ((nest10.inner.maybe as Housed.Housed | undefined) !== undefined) { - if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === nest10.inner.held as Housed.Housed) { + _513 = (nest10.inner.held as Housed.Housed) === _516; + if ((nest10.inner.maybe as Housed.Housed | undefined) !== undefined) { + if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === nest10.inner.held as Housed.Housed) { _519 = true; break b41; } @@ -1855,9 +1855,9 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _519 = false; } b43: { - _525 = (nest10.inner.tagged as [Housed.Housed, rt.u8])[0] === nest10.inner.at as Housed.Housed; + _525 = (nest10.inner.tagged as [Housed.Housed, rs.u8])[0] === nest10.inner.at as Housed.Housed; if (nest10.inner.to.tag === "At") { - if ((nest10.inner.to._0 as Housed.Housed) === nest10.inner.at as Housed.Housed) { + if ((nest10.inner.to._0 as Housed.Housed) === nest10.inner.at as Housed.Housed) { _528 = true; break b43; } @@ -1865,81 +1865,81 @@ export function aimed(data: rt.ByteSlice, out: rt.ByteVec): void { _528 = false; } b45: { - _536 = (nest10.inner.at as Housed.Housed) === other4; - const scrutinee6 = nest10.inner.maybe as Housed.Housed | undefined; + _536 = (nest10.inner.at as Housed.Housed) === other4; + const scrutinee6 = nest10.inner.maybe as Housed.Housed | undefined; same3 = [_509, _513, _519, _525, _528]; if (scrutinee6 !== undefined) { - if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === other4) { + if (((nest10.inner.maybe as Housed.Housed | undefined) as Housed.Housed) === other4) { _538 = true; break b45; } } _538 = false; } - const apart3: boolean[] = [_536, _538, (nest10.inner.seen as Housed.Housed) === other4]; - const null_3: Housed.Housed = rt.NULL; - const _550: boolean = (nest10.inner.maybe as Housed.Housed | undefined) === nest10.inner.held as Housed.Housed; - const _555: boolean = (nest10.inner.maybe as Housed.Housed | undefined) !== nest10.inner.held as Housed.Housed; + const apart3: boolean[] = [_536, _538, (nest10.inner.seen as Housed.Housed) === other4]; + const null_3: Housed.Housed = rs.NULL; + const _550: boolean = (nest10.inner.maybe as Housed.Housed | undefined) === nest10.inner.held as Housed.Housed; + const _555: boolean = (nest10.inner.maybe as Housed.Housed | undefined) !== nest10.inner.held as Housed.Housed; const pointer19 = other4; - const optional3: boolean[] = [_550, _555, (nest10.inner.maybe as Housed.Housed | undefined) === (pointer19 === rt.NULL ? undefined : pointer19), (nest10.inner.maybe as Housed.Housed | undefined) === none3, none3 === undefined, (nest10.inner.seen as Housed.Housed) === nest10.inner.at as Housed.Housed, (nest10.inner.seen as Housed.Housed) !== null_3, null_3 === rt.NULL]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_588(same3), _588(apart3), _588(optional3))), undefined, true); + const optional3: boolean[] = [_550, _555, (nest10.inner.maybe as Housed.Housed | undefined) === (pointer19 === rs.NULL ? undefined : pointer19), (nest10.inner.maybe as Housed.Housed | undefined) === none3, none3 === undefined, (nest10.inner.seen as Housed.Housed) === nest10.inner.at as Housed.Housed, (nest10.inner.seen as Housed.Housed) !== null_3, null_3 === rs.NULL]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_588(same3), _588(apart3), _588(optional3))), undefined, true); } } -export function made$pointers_Aim_u8(n: rt.u8): rt.u8 { +export function made$pointers_Aim_u8(n: rs.u8): rs.u8 { return n ^ 60; } -export function get$pointers_Aim_u8(self: rt.u8): rt.u8 { +export function get$pointers_Aim_u8(self: rs.u8): rs.u8 { return self; } -export function put$pointers_Aim_u8(self: rt.Place, n: rt.u8): void { - self.v = rt.u8WrappingAdd(rt.u8WrappingMul(self.v, 3), n); +export function put$pointers_Aim_u8(self: rs.Place, n: rs.u8): void { + self.v = rs.u8WrappingAdd(rs.u8WrappingMul(self.v, 3), n); } -export function made$pointers_Aim_array4_u8(n: rt.u8): Uint8Array { +export function made$pointers_Aim_array4_u8(n: rs.u8): Uint8Array { return Uint8Array.of(n, ~n & 0xff, n ^ 1, n ^ 2); } -export function get$pointers_Aim_array4_u8(selfData: Uint8Array, selfStart: number, _selfLen: number): rt.u8 { +export function get$pointers_Aim_array4_u8(selfData: Uint8Array, selfStart: number, _selfLen: number): rs.u8 { return selfData[selfStart] ^ selfData[selfStart + 3]; } -export function put$pointers_Aim_array4_u8(self: rt.ByteSlice, n: rt.u8): void { - const _3: rt.u8 = rt.u8WrappingAdd(self.data[self.start], n); - const _7: rt.usize = rt.u8Rem(n, 4) as rt.usize; +export function put$pointers_Aim_array4_u8(self: rs.ByteSlice, n: rs.u8): void { + const _3: rs.u8 = rs.u8WrappingAdd(self.data[self.start], n); + const _7: rs.usize = rs.u8Rem(n, 4) as rs.usize; if (!(_7 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _7); } self.data[self.start + _7] = _3; } -export function made$pointers_Aim_Cell_u8(n: rt.u8): rt.Cell { - return new rt.Cell(n ^ 119); +export function made$pointers_Aim_Cell_u8(n: rs.u8): rs.Cell { + return new rs.Cell(n ^ 119); } -export function get$pointers_Aim_Cell_u8(self: rt.Cell): rt.u8 { +export function get$pointers_Aim_Cell_u8(self: rs.Cell): rs.u8 { return self.v; } -export function put$pointers_Aim_Cell_u8(self: rt.Cell, n: rt.u8): void { - rt.cellSet(self, rt.intRotateLeft(self.v, 1, 8, false) ^ n); +export function put$pointers_Aim_Cell_u8(self: rs.Cell, n: rs.u8): void { + rs.cellSet(self, rs.intRotateLeft(self.v, 1, 8, false) ^ n); } -export function made$pointers_Aim_array2_u16(n: rt.u8): rt.u16[] { - return [((n as rt.u16) << 4) & 0xffff, (((~n & 0xff) as rt.u16) << 4) & 0xffff]; +export function made$pointers_Aim_array2_u16(n: rs.u8): rs.u16[] { + return [((n as rs.u16) << 4) & 0xffff, (((~n & 0xff) as rs.u16) << 4) & 0xffff]; } -export function get$pointers_Aim_array2_u16(self: rt.u16[]): rt.u8 { +export function get$pointers_Aim_array2_u16(self: rs.u16[]): rs.u8 { return ((self[0] ^ self[1]) >> 4) & 0xff; } -export function put$pointers_Aim_array2_u16(self: rt.u16[], n: rt.u8): void { - const _3: rt.u16 = ((n as rt.u16) << 4) & 0xffff; - const _7: rt.usize = rt.u8Rem(n, 2) as rt.usize; +export function put$pointers_Aim_array2_u16(self: rs.u16[], n: rs.u8): void { + const _3: rs.u16 = ((n as rs.u16) << 4) & 0xffff; + const _7: rs.usize = rs.u8Rem(n, 2) as rs.usize; if (!(_7 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _7); } self[_7] = self[_7] ^ _3; } @@ -1948,452 +1948,452 @@ export function put$pointers_Aim_array2_u16(self: rt.u16[], n: rt.u8): void { * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { +export function through$Cell_u8(nest: Enclosed.Enclosed>, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; - const copy: Aimed.Aimed> = copy$pointers_Aimed_Cell_u8(nest.inner); - (copy.tagged as [rt.Place>, rt.u8])[1] = (copy.tagged as [rt.Place>, rt.u8])[1] ^ 64; - const _8: [rt.Place>, rt.u8] = tagged$Cell_u8(copy); - const at: rt.Place> = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place>, rt.u8])[1], tag)), undefined, true); + const copy: Aimed.Aimed> = copy$pointers_Aimed_Cell_u8(nest.inner); + (copy.tagged as [rs.Place>, rs.u8])[1] = (copy.tagged as [rs.Place>, rs.u8])[1] ^ 64; + const _8: [rs.Place>, rs.u8] = tagged$Cell_u8(copy); + const at: rs.Place> = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.Place>, rs.u8])[1], tag)), undefined, true); put$pointers_Aim_Cell_u8(at.v, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place>) => rt.u8)(nest.inner.seen as rt.Place>)); - put$pointers_Aim_Cell_u8((nest.inner.at as rt.Place>).v, n); - rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.held as rt.Place>).v)); - if ((nest.inner.maybe as rt.Place> | undefined) !== undefined) { - put$pointers_Aim_Cell_u8(((nest.inner.maybe as rt.Place> | undefined) as rt.Place>).v, n ^ 3); - } - const _62: rt.Place> = (nest.inner.tagged as [rt.Place>, rt.u8])[0]; - const _34: rt.u8 = rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place>, rt.u8])[1]); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.Place>) => rs.u8)(nest.inner.seen as rs.Place>)); + put$pointers_Aim_Cell_u8((nest.inner.at as rs.Place>).v, n); + rs.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.held as rs.Place>).v)); + if ((nest.inner.maybe as rs.Place> | undefined) !== undefined) { + put$pointers_Aim_Cell_u8(((nest.inner.maybe as rs.Place> | undefined) as rs.Place>).v, n ^ 3); + } + const _62: rs.Place> = (nest.inner.tagged as [rs.Place>, rs.u8])[0]; + const _34: rs.u8 = rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.Place>, rs.u8])[1]); put$pointers_Aim_Cell_u8(_62.v, _34); if (nest.inner.to.tag === "At") { - put$pointers_Aim_Cell_u8((nest.inner.to._0 as rt.Place>).v, ~n & 0xff); + put$pointers_Aim_Cell_u8((nest.inner.to._0 as rs.Place>).v, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as rt.Place> | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.Place> | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - (nest.inner.at as rt.Place>).v = made$pointers_Aim_Cell_u8(n); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + (nest.inner.at as rs.Place>).v = made$pointers_Aim_Cell_u8(n); } - rt.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rt.Place>).v)); + rs.byteVecPush(out, get$pointers_Aim_Cell_u8((nest.inner.seen as rs.Place>).v)); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$array2_u16(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { +export function through$array2_u16(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; - const copy: Aimed.Aimed = copy$pointers_Aimed_array2_u16(nest.inner); - (copy.tagged as [rt.u16[], rt.u8])[1] = (copy.tagged as [rt.u16[], rt.u8])[1] ^ 64; - const _8: [rt.u16[], rt.u8] = tagged$array2_u16(copy); - const at: rt.u16[] = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.u16[], rt.u8])[1], tag)), undefined, true); + const copy: Aimed.Aimed = copy$pointers_Aimed_array2_u16(nest.inner); + (copy.tagged as [rs.u16[], rs.u8])[1] = (copy.tagged as [rs.u16[], rs.u8])[1] ^ 64; + const _8: [rs.u16[], rs.u8] = tagged$array2_u16(copy); + const at: rs.u16[] = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.u16[], rs.u8])[1], tag)), undefined, true); put$pointers_Aim_array2_u16(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: rt.u16[]) => rt.u8)(nest.inner.seen as rt.u16[])); - put$pointers_Aim_array2_u16(nest.inner.at as rt.u16[], n); - rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rt.u16[])); - if ((nest.inner.maybe as rt.u16[] | undefined) !== undefined) { - put$pointers_Aim_array2_u16((nest.inner.maybe as rt.u16[] | undefined) as rt.u16[], n ^ 3); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.u16[]) => rs.u8)(nest.inner.seen as rs.u16[])); + put$pointers_Aim_array2_u16(nest.inner.at as rs.u16[], n); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.held as rs.u16[])); + if ((nest.inner.maybe as rs.u16[] | undefined) !== undefined) { + put$pointers_Aim_array2_u16((nest.inner.maybe as rs.u16[] | undefined) as rs.u16[], n ^ 3); } - put$pointers_Aim_array2_u16((nest.inner.tagged as [rt.u16[], rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.u16[], rt.u8])[1])); + put$pointers_Aim_array2_u16((nest.inner.tagged as [rs.u16[], rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.u16[], rs.u8])[1])); if (nest.inner.to.tag === "At") { - put$pointers_Aim_array2_u16(nest.inner.to._0 as rt.u16[], ~n & 0xff); + put$pointers_Aim_array2_u16(nest.inner.to._0 as rs.u16[], ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as rt.u16[] | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.u16[] | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - rt.ptrWrite(nest.inner.at as rt.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + rs.ptrWrite(nest.inner.at as rs.u16[], copy$array_u16(made$pointers_Aim_array2_u16(n))); } - rt.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rt.u16[])); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(nest.inner.seen as rs.u16[])); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$array4_u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { +export function through$array4_u8(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_array4_u8(nest.inner); - (copy.tagged as [rt.ByteSlice, rt.u8])[1] = (copy.tagged as [rt.ByteSlice, rt.u8])[1] ^ 64; - const _8: [rt.ByteSlice, rt.u8] = tagged$array4_u8(copy); - const at: rt.ByteSlice = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.ByteSlice, rt.u8])[1], tag)), undefined, true); + (copy.tagged as [rs.ByteSlice, rs.u8])[1] = (copy.tagged as [rs.ByteSlice, rs.u8])[1] ^ 64; + const _8: [rs.ByteSlice, rs.u8] = tagged$array4_u8(copy); + const at: rs.ByteSlice = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.ByteSlice, rs.u8])[1], tag)), undefined, true); put$pointers_Aim_array4_u8(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: rt.ByteSlice) => rt.u8)(nest.inner.seen as rt.ByteSlice)); - put$pointers_Aim_array4_u8(nest.inner.at as rt.ByteSlice, n); - const _24: rt.ByteSlice = nest.inner.held as rt.ByteSlice; - rt.byteVecPush(out, get$pointers_Aim_array4_u8(_24.data, _24.start, _24.length)); - if ((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined) { - put$pointers_Aim_array4_u8((nest.inner.maybe as rt.ByteSlice | undefined) as rt.ByteSlice, n ^ 3); - } - put$pointers_Aim_array4_u8((nest.inner.tagged as [rt.ByteSlice, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.ByteSlice, rt.u8])[1])); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.ByteSlice) => rs.u8)(nest.inner.seen as rs.ByteSlice)); + put$pointers_Aim_array4_u8(nest.inner.at as rs.ByteSlice, n); + const _24: rs.ByteSlice = nest.inner.held as rs.ByteSlice; + rs.byteVecPush(out, get$pointers_Aim_array4_u8(_24.data, _24.start, _24.length)); + if ((nest.inner.maybe as rs.ByteSlice | undefined) !== undefined) { + put$pointers_Aim_array4_u8((nest.inner.maybe as rs.ByteSlice | undefined) as rs.ByteSlice, n ^ 3); + } + put$pointers_Aim_array4_u8((nest.inner.tagged as [rs.ByteSlice, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.ByteSlice, rs.u8])[1])); if (nest.inner.to.tag === "At") { - put$pointers_Aim_array4_u8(nest.inner.to._0 as rt.ByteSlice, ~n & 0xff); + put$pointers_Aim_array4_u8(nest.inner.to._0 as rs.ByteSlice, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as rt.ByteSlice | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.ByteSlice | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - rt.byteSliceSet(nest.inner.at as rt.ByteSlice, copy$array_u8(made$pointers_Aim_array4_u8(n))); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + rs.byteSliceSet(nest.inner.at as rs.ByteSlice, copy$array_u8(made$pointers_Aim_array4_u8(n))); } - const _63: rt.ByteSlice = nest.inner.seen as rt.ByteSlice; - rt.byteVecPush(out, get$pointers_Aim_array4_u8(_63.data, _63.start, _63.length)); + const _63: rs.ByteSlice = nest.inner.seen as rs.ByteSlice; + rs.byteVecPush(out, get$pointers_Aim_array4_u8(_63.data, _63.start, _63.length)); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$pointers_Housed_u8(nest: Enclosed.Enclosed>, n: rt.u8, out: rt.ByteVec): void { +export function through$pointers_Housed_u8(nest: Enclosed.Enclosed>, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; - const copy: Aimed.Aimed> = copy$pointers_Aimed_pointers_Housed_u8(nest.inner); - (copy.tagged as [Housed.Housed, rt.u8])[1] = (copy.tagged as [Housed.Housed, rt.u8])[1] ^ 64; - const _8: [Housed.Housed, rt.u8] = tagged$pointers_Housed_u8(copy); - const at: Housed.Housed = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [Housed.Housed, rt.u8])[1], tag)), undefined, true); + const copy: Aimed.Aimed> = copy$pointers_Aimed_pointers_Housed_u8(nest.inner); + (copy.tagged as [Housed.Housed, rs.u8])[1] = (copy.tagged as [Housed.Housed, rs.u8])[1] ^ 64; + const _8: [Housed.Housed, rs.u8] = tagged$pointers_Housed_u8(copy); + const at: Housed.Housed = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [Housed.Housed, rs.u8])[1], tag)), undefined, true); Housed.put$pointers_Aim_u8(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: Housed.Housed) => rt.u8)(nest.inner.seen as Housed.Housed)); - Housed.put$pointers_Aim_u8(nest.inner.at as Housed.Housed, n); - rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.held as Housed.Housed)); - if ((nest.inner.maybe as Housed.Housed | undefined) !== undefined) { - Housed.put$pointers_Aim_u8((nest.inner.maybe as Housed.Housed | undefined) as Housed.Housed, n ^ 3); + rs.byteVecPush(out, (nest.inner.read as (a0: Housed.Housed) => rs.u8)(nest.inner.seen as Housed.Housed)); + Housed.put$pointers_Aim_u8(nest.inner.at as Housed.Housed, n); + rs.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.held as Housed.Housed)); + if ((nest.inner.maybe as Housed.Housed | undefined) !== undefined) { + Housed.put$pointers_Aim_u8((nest.inner.maybe as Housed.Housed | undefined) as Housed.Housed, n ^ 3); } - Housed.put$pointers_Aim_u8((nest.inner.tagged as [Housed.Housed, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [Housed.Housed, rt.u8])[1])); + Housed.put$pointers_Aim_u8((nest.inner.tagged as [Housed.Housed, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [Housed.Housed, rs.u8])[1])); if (nest.inner.to.tag === "At") { - Housed.put$pointers_Aim_u8(nest.inner.to._0 as Housed.Housed, ~n & 0xff); + Housed.put$pointers_Aim_u8(nest.inner.to._0 as Housed.Housed, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as Housed.Housed | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - rt.ptrWrite(nest.inner.at as Housed.Housed, Housed.made$pointers_Aim_u8(n)); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + rs.ptrWrite(nest.inner.at as Housed.Housed, Housed.made$pointers_Aim_u8(n)); } - rt.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); + rs.byteVecPush(out, Housed.get$pointers_Aim_u8(nest.inner.seen as Housed.Housed)); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$pointers_Leaning(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { +export function through$pointers_Leaning(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Leaning(nest.inner); - (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; - const _8: [rt.Place, rt.u8] = tagged$pointers_Leaning(copy); - const at: rt.Place = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place, rt.u8])[1], tag)), undefined, true); + (copy.tagged as [rs.Place, rs.u8])[1] = (copy.tagged as [rs.Place, rs.u8])[1] ^ 64; + const _8: [rs.Place, rs.u8] = tagged$pointers_Leaning(copy); + const at: rs.Place = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.Place, rs.u8])[1], tag)), undefined, true); Leaning.put$pointers_Aim(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place) => rt.u8)(nest.inner.seen as rt.Place)); - Leaning.put$pointers_Aim(nest.inner.at as rt.Place, n); - rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.held as rt.Place).v)); - if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { - Leaning.put$pointers_Aim((nest.inner.maybe as rt.Place | undefined) as rt.Place, n ^ 3); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.Place) => rs.u8)(nest.inner.seen as rs.Place)); + Leaning.put$pointers_Aim(nest.inner.at as rs.Place, n); + rs.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.held as rs.Place).v)); + if ((nest.inner.maybe as rs.Place | undefined) !== undefined) { + Leaning.put$pointers_Aim((nest.inner.maybe as rs.Place | undefined) as rs.Place, n ^ 3); } - Leaning.put$pointers_Aim((nest.inner.tagged as [rt.Place, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place, rt.u8])[1])); + Leaning.put$pointers_Aim((nest.inner.tagged as [rs.Place, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.Place, rs.u8])[1])); if (nest.inner.to.tag === "At") { - Leaning.put$pointers_Aim(nest.inner.to._0 as rt.Place, ~n & 0xff); + Leaning.put$pointers_Aim(nest.inner.to._0 as rs.Place, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.Place | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - (nest.inner.at as rt.Place).v = Leaning.made$pointers_Aim(n); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + (nest.inner.at as rs.Place).v = Leaning.made$pointers_Aim(n); } - rt.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rt.Place).v)); + rs.byteVecPush(out, Leaning.get$pointers_Aim((nest.inner.seen as rs.Place).v)); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$pointers_Paired(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { +export function through$pointers_Paired(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; const copy: Aimed.Aimed = copy$pointers_Aimed_pointers_Paired(nest.inner); - (copy.tagged as [Paired.Paired, rt.u8])[1] = (copy.tagged as [Paired.Paired, rt.u8])[1] ^ 64; - const _8: [Paired.Paired, rt.u8] = tagged$pointers_Paired(copy); + (copy.tagged as [Paired.Paired, rs.u8])[1] = (copy.tagged as [Paired.Paired, rs.u8])[1] ^ 64; + const _8: [Paired.Paired, rs.u8] = tagged$pointers_Paired(copy); const at: Paired.Paired = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [Paired.Paired, rt.u8])[1], tag)), undefined, true); + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [Paired.Paired, rs.u8])[1], tag)), undefined, true); Paired.put$pointers_Aim(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: Paired.Paired) => rt.u8)(nest.inner.seen as Paired.Paired)); + rs.byteVecPush(out, (nest.inner.read as (a0: Paired.Paired) => rs.u8)(nest.inner.seen as Paired.Paired)); Paired.put$pointers_Aim(nest.inner.at as Paired.Paired, n); - rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.held as Paired.Paired)); + rs.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.held as Paired.Paired)); if ((nest.inner.maybe as Paired.Paired | undefined) !== undefined) { Paired.put$pointers_Aim((nest.inner.maybe as Paired.Paired | undefined) as Paired.Paired, n ^ 3); } - Paired.put$pointers_Aim((nest.inner.tagged as [Paired.Paired, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [Paired.Paired, rt.u8])[1])); + Paired.put$pointers_Aim((nest.inner.tagged as [Paired.Paired, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [Paired.Paired, rs.u8])[1])); if (nest.inner.to.tag === "At") { Paired.put$pointers_Aim(nest.inner.to._0 as Paired.Paired, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as Paired.Paired | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - rt.ptrWrite(nest.inner.at as Paired.Paired, Paired.made$pointers_Aim(n)); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + rs.ptrWrite(nest.inner.at as Paired.Paired, Paired.made$pointers_Aim(n)); } - rt.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); + rs.byteVecPush(out, Paired.get$pointers_Aim(nest.inner.seen as Paired.Paired)); } /** * Reads and writes through each of `nest`'s pointers, and through those of a copy of * them, whose own tag changes apart from theirs. */ -export function through$u8(nest: Enclosed.Enclosed, n: rt.u8, out: rt.ByteVec): void { +export function through$u8(nest: Enclosed.Enclosed, n: rs.u8, out: rs.ByteVec): void { let _50!: boolean; - const copy: Aimed.Aimed = copy$pointers_Aimed_u8(nest.inner); - (copy.tagged as [rt.Place, rt.u8])[1] = (copy.tagged as [rt.Place, rt.u8])[1] ^ 64; - const _8: [rt.Place, rt.u8] = tagged$u8(copy); - const at: rt.Place = _8[0]; - const tag: rt.u8 = _8[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of((nest.inner.tagged as [rt.Place, rt.u8])[1], tag)), undefined, true); + const copy: Aimed.Aimed = copy$pointers_Aimed_u8(nest.inner); + (copy.tagged as [rs.Place, rs.u8])[1] = (copy.tagged as [rs.Place, rs.u8])[1] ^ 64; + const _8: [rs.Place, rs.u8] = tagged$u8(copy); + const at: rs.Place = _8[0]; + const tag: rs.u8 = _8[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of((nest.inner.tagged as [rs.Place, rs.u8])[1], tag)), undefined, true); put$pointers_Aim_u8(at, tag); - rt.byteVecPush(out, (nest.inner.read as (a0: rt.Place) => rt.u8)(nest.inner.seen as rt.Place)); - put$pointers_Aim_u8(nest.inner.at as rt.Place, n); - rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.held as rt.Place).v)); - if ((nest.inner.maybe as rt.Place | undefined) !== undefined) { - put$pointers_Aim_u8((nest.inner.maybe as rt.Place | undefined) as rt.Place, n ^ 3); + rs.byteVecPush(out, (nest.inner.read as (a0: rs.Place) => rs.u8)(nest.inner.seen as rs.Place)); + put$pointers_Aim_u8(nest.inner.at as rs.Place, n); + rs.byteVecPush(out, get$pointers_Aim_u8((nest.inner.held as rs.Place).v)); + if ((nest.inner.maybe as rs.Place | undefined) !== undefined) { + put$pointers_Aim_u8((nest.inner.maybe as rs.Place | undefined) as rs.Place, n ^ 3); } - put$pointers_Aim_u8((nest.inner.tagged as [rt.Place, rt.u8])[0], rt.u8WrappingAdd(n, (nest.inner.tagged as [rt.Place, rt.u8])[1])); + put$pointers_Aim_u8((nest.inner.tagged as [rs.Place, rs.u8])[0], rs.u8WrappingAdd(n, (nest.inner.tagged as [rs.Place, rs.u8])[1])); if (nest.inner.to.tag === "At") { - put$pointers_Aim_u8(nest.inner.to._0 as rt.Place, ~n & 0xff); + put$pointers_Aim_u8(nest.inner.to._0 as rs.Place, ~n & 0xff); } - const _43: rt.u8 = (((nest.inner.maybe as rt.Place | undefined) !== undefined ? 1 : 0) << 1) & 0xff; + const _43: rs.u8 = (((nest.inner.maybe as rs.Place | undefined) !== undefined ? 1 : 0) << 1) & 0xff; if (nest.inner.to.tag === "At") { _50 = true; } else { _50 = false; } - rt.byteVecPush(out, _43 | (_50 ? 1 : 0)); - if (rt.u8Rem(n, 5) === 0) { - (nest.inner.at as rt.Place).v = made$pointers_Aim_u8(n); + rs.byteVecPush(out, _43 | (_50 ? 1 : 0)); + if (rs.u8Rem(n, 5) === 0) { + (nest.inner.at as rs.Place).v = made$pointers_Aim_u8(n); } - rt.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rt.Place).v)); + rs.byteVecPush(out, get$pointers_Aim_u8((nest.inner.seen as rs.Place).v)); } /** What `at` points at, read as a byte. */ -export function readThrough$Cell_u8(at: rt.Place>): rt.u8 { +export function readThrough$Cell_u8(at: rs.Place>): rs.u8 { return get$pointers_Aim_Cell_u8(at.v); } /** What `at` points at, read as a byte. */ -export function readThrough$array2_u16(at: rt.u16[]): rt.u8 { +export function readThrough$array2_u16(at: rs.u16[]): rs.u8 { return get$pointers_Aim_array2_u16(at); } /** What `at` points at, read as a byte. */ -export function readThrough$array4_u8(at: rt.ByteSlice): rt.u8 { +export function readThrough$array4_u8(at: rs.ByteSlice): rs.u8 { return get$pointers_Aim_array4_u8(at.data, at.start, at.length); } /** What `at` points at, read as a byte. */ -export function readThrough$pointers_Housed_u8(at: Housed.Housed): rt.u8 { +export function readThrough$pointers_Housed_u8(at: Housed.Housed): rs.u8 { return Housed.get$pointers_Aim_u8(at); } /** What `at` points at, read as a byte. */ -export function readThrough$pointers_Leaning(at: rt.Place): rt.u8 { +export function readThrough$pointers_Leaning(at: rs.Place): rs.u8 { return Leaning.get$pointers_Aim(at.v); } /** What `at` points at, read as a byte. */ -export function readThrough$pointers_Paired(at: Paired.Paired): rt.u8 { +export function readThrough$pointers_Paired(at: Paired.Paired): rs.u8 { return Paired.get$pointers_Aim(at); } /** What `at` points at, read as a byte. */ -export function readThrough$u8(at: rt.Place): rt.u8 { +export function readThrough$u8(at: rs.Place): rs.u8 { return get$pointers_Aim_u8(at.v); } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$Cell_u8(a: Aimed.Aimed>): [rt.Place>, rt.u8] { - return [(a.tagged as [rt.Place>, rt.u8])[0], (a.tagged as [rt.Place>, rt.u8])[1]] as [rt.Place>, rt.u8]; +export function tagged$Cell_u8(a: Aimed.Aimed>): [rs.Place>, rs.u8] { + return [(a.tagged as [rs.Place>, rs.u8])[0], (a.tagged as [rs.Place>, rs.u8])[1]] as [rs.Place>, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$array2_u16(a: Aimed.Aimed): [rt.u16[], rt.u8] { - return [(a.tagged as [rt.u16[], rt.u8])[0], (a.tagged as [rt.u16[], rt.u8])[1]] as [rt.u16[], rt.u8]; +export function tagged$array2_u16(a: Aimed.Aimed): [rs.u16[], rs.u8] { + return [(a.tagged as [rs.u16[], rs.u8])[0], (a.tagged as [rs.u16[], rs.u8])[1]] as [rs.u16[], rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$array4_u8(a: Aimed.Aimed): [rt.ByteSlice, rt.u8] { - return [(a.tagged as [rt.ByteSlice, rt.u8])[0], (a.tagged as [rt.ByteSlice, rt.u8])[1]] as [rt.ByteSlice, rt.u8]; +export function tagged$array4_u8(a: Aimed.Aimed): [rs.ByteSlice, rs.u8] { + return [(a.tagged as [rs.ByteSlice, rs.u8])[0], (a.tagged as [rs.ByteSlice, rs.u8])[1]] as [rs.ByteSlice, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$pointers_Housed_u8(a: Aimed.Aimed>): [Housed.Housed, rt.u8] { - return [(a.tagged as [Housed.Housed, rt.u8])[0], (a.tagged as [Housed.Housed, rt.u8])[1]] as [Housed.Housed, rt.u8]; +export function tagged$pointers_Housed_u8(a: Aimed.Aimed>): [Housed.Housed, rs.u8] { + return [(a.tagged as [Housed.Housed, rs.u8])[0], (a.tagged as [Housed.Housed, rs.u8])[1]] as [Housed.Housed, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$pointers_Leaning(a: Aimed.Aimed): [rt.Place, rt.u8] { - return [(a.tagged as [rt.Place, rt.u8])[0], (a.tagged as [rt.Place, rt.u8])[1]] as [rt.Place, rt.u8]; +export function tagged$pointers_Leaning(a: Aimed.Aimed): [rs.Place, rs.u8] { + return [(a.tagged as [rs.Place, rs.u8])[0], (a.tagged as [rs.Place, rs.u8])[1]] as [rs.Place, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$pointers_Paired(a: Aimed.Aimed): [Paired.Paired, rt.u8] { - return [(a.tagged as [Paired.Paired, rt.u8])[0], (a.tagged as [Paired.Paired, rt.u8])[1]] as [Paired.Paired, rt.u8]; +export function tagged$pointers_Paired(a: Aimed.Aimed): [Paired.Paired, rs.u8] { + return [(a.tagged as [Paired.Paired, rs.u8])[0], (a.tagged as [Paired.Paired, rs.u8])[1]] as [Paired.Paired, rs.u8]; } /** `a`'s tagged pointer and tag, taken apart. */ -export function tagged$u8(a: Aimed.Aimed): [rt.Place, rt.u8] { - return [(a.tagged as [rt.Place, rt.u8])[0], (a.tagged as [rt.Place, rt.u8])[1]] as [rt.Place, rt.u8]; +export function tagged$u8(a: Aimed.Aimed): [rs.Place, rs.u8] { + return [(a.tagged as [rs.Place, rs.u8])[0], (a.tagged as [rs.Place, rs.u8])[1]] as [rs.Place, rs.u8]; } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$Cell_u8(to: rt.Place>, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped> = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>>, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic>>, to, 4); - const at: rt.Place> = rt.atomicLoad(shared.at as rt.Atomic>>, 4); +export function swappedIn$Cell_u8(to: rs.Place>, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>>, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic>>, to, 4); + const at: rs.Place> = rs.atomicLoad(shared.at as rs.Atomic>>, 4); put$pointers_Aim_Cell_u8(at.v, n); - rt.byteVecPush(out, get$pointers_Aim_Cell_u8(at.v)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>>, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, get$pointers_Aim_Cell_u8(at.v)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic>>, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$array2_u16(to: rt.u16[], n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic, to, 4); - const at: rt.u16[] = rt.atomicLoad(shared.at as rt.Atomic, 4); +export function swappedIn$array2_u16(to: rs.u16[], n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic, to, 4); + const at: rs.u16[] = rs.atomicLoad(shared.at as rs.Atomic, 4); put$pointers_Aim_array2_u16(at, n); - rt.byteVecPush(out, get$pointers_Aim_array2_u16(at)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, get$pointers_Aim_array2_u16(at)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$array4_u8(to: rt.ByteSlice, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic, to, 4); - const at: rt.ByteSlice = rt.atomicLoad(shared.at as rt.Atomic, 4); +export function swappedIn$array4_u8(to: rs.ByteSlice, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic, to, 4); + const at: rs.ByteSlice = rs.atomicLoad(shared.at as rs.Atomic, 4); put$pointers_Aim_array4_u8(at, n); - rt.byteVecPush(out, get$pointers_Aim_array4_u8(at.data, at.start, at.length)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, get$pointers_Aim_array4_u8(at.data, at.start, at.length)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$pointers_Housed_u8(to: Housed.Housed, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped> = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic>, to, 4); - const at: Housed.Housed = rt.atomicLoad(shared.at as rt.Atomic>, 4); +export function swappedIn$pointers_Housed_u8(to: Housed.Housed, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped> = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic>, to, 4); + const at: Housed.Housed = rs.atomicLoad(shared.at as rs.Atomic>, 4); Housed.put$pointers_Aim_u8(at, n); - rt.byteVecPush(out, Housed.get$pointers_Aim_u8(at)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, Housed.get$pointers_Aim_u8(at)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic>, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$pointers_Leaning(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic>, to, 4); - const at: rt.Place = rt.atomicLoad(shared.at as rt.Atomic>, 4); +export function swappedIn$pointers_Leaning(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic>, to, 4); + const at: rs.Place = rs.atomicLoad(shared.at as rs.Atomic>, 4); Leaning.put$pointers_Aim(at, n); - rt.byteVecPush(out, Leaning.get$pointers_Aim(at.v)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, Leaning.get$pointers_Aim(at.v)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic>, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$pointers_Paired(to: Paired.Paired, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic, to, 4); - const at: Paired.Paired = rt.atomicLoad(shared.at as rt.Atomic, 4); +export function swappedIn$pointers_Paired(to: Paired.Paired, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic, to, 4); + const at: Paired.Paired = rs.atomicLoad(shared.at as rs.Atomic, 4); Paired.put$pointers_Aim(at, n); - rt.byteVecPush(out, Paired.get$pointers_Aim(at)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, Paired.get$pointers_Aim(at)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes through an `AtomicPtr` to what `to` points at, swapped in for null. */ -export function swappedIn$u8(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { - const shared: Swapped.Swapped = { at: new rt.Atomic(rt.NULL) }; - rt.byteVecPush(out, rt.atomicLoad(shared.at as rt.Atomic>, 4) === rt.NULL ? 1 : 0); - rt.atomicStore(shared.at as rt.Atomic>, to, 4); - const at: rt.Place = rt.atomicLoad(shared.at as rt.Atomic>, 4); +export function swappedIn$u8(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { + const shared: Swapped.Swapped = { at: new rs.Atomic(rs.NULL) }; + rs.byteVecPush(out, rs.atomicLoad(shared.at as rs.Atomic>, 4) === rs.NULL ? 1 : 0); + rs.atomicStore(shared.at as rs.Atomic>, to, 4); + const at: rs.Place = rs.atomicLoad(shared.at as rs.Atomic>, 4); put$pointers_Aim_u8(at, n); - rt.byteVecPush(out, get$pointers_Aim_u8(at.v)); - rt.byteVecPush(out, rt.atomicSwap(shared.at as rt.Atomic>, rt.NULL, 4) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, get$pointers_Aim_u8(at.v)); + rs.byteVecPush(out, rs.atomicSwap(shared.at as rs.Atomic>, rs.NULL, 4) === rs.NULL ? 1 : 0); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$Cell_u8(to: rt.Cell, n: rt.u8, out: rt.ByteVec): void { - const made: rt.Cell = made$pointers_Aim_Cell_u8(n); +export function lend$Cell_u8(to: rs.Cell, n: rs.u8, out: rs.ByteVec): void { + const made: rs.Cell = made$pointers_Aim_Cell_u8(n); put$pointers_Aim_Cell_u8(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_Cell_u8(to), get$pointers_Aim_Cell_u8(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_Cell_u8(to), get$pointers_Aim_Cell_u8(made))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$array2_u16(to: rt.u16[], n: rt.u8, out: rt.ByteVec): void { - const made: rt.u16[] = made$pointers_Aim_array2_u16(n); +export function lend$array2_u16(to: rs.u16[], n: rs.u8, out: rs.ByteVec): void { + const made: rs.u16[] = made$pointers_Aim_array2_u16(n); put$pointers_Aim_array2_u16(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_array2_u16(to), get$pointers_Aim_array2_u16(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_array2_u16(to), get$pointers_Aim_array2_u16(made))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$array4_u8(to: rt.ByteSlice, n: rt.u8, out: rt.ByteVec): void { - const _6: rt.ByteSlice = rt.byteSliceFrom(made$pointers_Aim_array4_u8(n)); +export function lend$array4_u8(to: rs.ByteSlice, n: rs.u8, out: rs.ByteVec): void { + const _6: rs.ByteSlice = rs.byteSliceFrom(made$pointers_Aim_array4_u8(n)); put$pointers_Aim_array4_u8(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_array4_u8(to.data, to.start, to.length), get$pointers_Aim_array4_u8(_6.data, _6.start, _6.length))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_array4_u8(to.data, to.start, to.length), get$pointers_Aim_array4_u8(_6.data, _6.start, _6.length))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$pointers_Housed_u8(to: Housed.Housed, n: rt.u8, out: rt.ByteVec): void { - const made: Housed.Housed = Housed.made$pointers_Aim_u8(n); +export function lend$pointers_Housed_u8(to: Housed.Housed, n: rs.u8, out: rs.ByteVec): void { + const made: Housed.Housed = Housed.made$pointers_Aim_u8(n); Housed.put$pointers_Aim_u8(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Housed.get$pointers_Aim_u8(to), Housed.get$pointers_Aim_u8(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(Housed.get$pointers_Aim_u8(to), Housed.get$pointers_Aim_u8(made))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$pointers_Leaning(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { +export function lend$pointers_Leaning(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { const made: Leaning.Leaning = Leaning.made$pointers_Aim(n); Leaning.put$pointers_Aim(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Leaning.get$pointers_Aim(to.v), Leaning.get$pointers_Aim(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(Leaning.get$pointers_Aim(to.v), Leaning.get$pointers_Aim(made))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$pointers_Paired(to: Paired.Paired, n: rt.u8, out: rt.ByteVec): void { +export function lend$pointers_Paired(to: Paired.Paired, n: rs.u8, out: rs.ByteVec): void { const made: Paired.Paired = Paired.made$pointers_Aim(n); Paired.put$pointers_Aim(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(Paired.get$pointers_Aim(to), Paired.get$pointers_Aim(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(Paired.get$pointers_Aim(to), Paired.get$pointers_Aim(made))), undefined, true); } /** Reads and writes `to` through references to it and to another `T`. */ -export function lend$u8(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { - const made: rt.u8 = made$pointers_Aim_u8(n); +export function lend$u8(to: rs.Place, n: rs.u8, out: rs.ByteVec): void { + const made: rs.u8 = made$pointers_Aim_u8(n); put$pointers_Aim_u8(to, n >> 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(get$pointers_Aim_u8(to.v), get$pointers_Aim_u8(made))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(get$pointers_Aim_u8(to.v), get$pointers_Aim_u8(made))), undefined, true); } /** @@ -2404,147 +2404,147 @@ export function lend$u8(to: rt.Place, n: rt.u8, out: rt.ByteVec): void { * by `make_mut`, of a slice of bytes too, as `ptr::eq`, `addr_eq`, and `as_ptr` compare * them; a clone of an `Arc` or `Rc` shares its value. */ -export function distinct(data: rt.ByteSlice, out: rt.ByteVec): void { - const iter: rt.Iter = rt.byteSliceChunks(data, 3); +export function distinct(data: rs.ByteSlice, out: rs.ByteVec): void { + const iter: rs.Iter = rs.byteSliceChunks(data, 3); while (true) { - const _6: rt.ByteSlice | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.ByteSlice | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } if (_6.length === 3) { - const a: rt.u8 = _6.data[_6.start]; - const b: rt.u8 = _6.data[_6.start + 1]; - const c: rt.u8 = _6.data[_6.start + 2]; - const pair: [rt.u16, rt.u8] = [(((a as rt.u16) << 8) & 0xffff) | b as rt.u16, c]; + const a: rs.u8 = _6.data[_6.start]; + const b: rs.u8 = _6.data[_6.start + 1]; + const c: rs.u8 = _6.data[_6.start + 2]; + const pair: [rs.u16, rs.u8] = [(((a as rs.u16) << 8) & 0xffff) | b as rs.u16, c]; const spot: Spot.Spot = { at: copy$tuple2_u16_u8(pair), tag: a ^ c }; const bytes: Uint8Array = Uint8Array.of(a, b, c); - const _27: [rt.Arc<[rt.u16, rt.u8]>, rt.Arc<[rt.u16, rt.u8]>] = [new rt.Arc(copy$tuple2_u16_u8(pair)), new rt.Arc(copy$tuple2_u16_u8(pair))]; - const x: rt.Arc<[rt.u16, rt.u8]> = _27[0]; - const y: rt.Arc<[rt.u16, rt.u8]> = _27[1]; - const same: rt.Arc<[rt.u16, rt.u8]> = rt.arcClone(x); - const _34: [rt.Arc, rt.Arc] = [new rt.Arc(copy$pointers_Spot(spot)), new rt.Arc(copy$pointers_Spot(spot))]; - const p: rt.Arc = _34[0]; - const q: rt.Arc = _34[1]; - const shared: rt.Arc = rt.arcClone(p); - const _41: [[rt.u16, rt.u8], [rt.u16, rt.u8]] = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(pair)]; - const m: [rt.u16, rt.u8] = _41[0]; - const n: [rt.u16, rt.u8] = _41[1]; - const _46: [rt.Arc, rt.Arc] = [new rt.Arc(copy$array_u8(bytes)), new rt.Arc(copy$array_u8(bytes))]; - const k: rt.Arc = _46[0]; - const l: rt.Arc = _46[1]; - const list: rt.Vec<[rt.u16, rt.u8]> = rt.vecFromElem(copy$tuple2_u16_u8(pair), 2, copy$tuple2_u16_u8); - const pushed: rt.Vec = new rt.Vec(); + const _27: [rs.Arc<[rs.u16, rs.u8]>, rs.Arc<[rs.u16, rs.u8]>] = [new rs.Arc(copy$tuple2_u16_u8(pair)), new rs.Arc(copy$tuple2_u16_u8(pair))]; + const x: rs.Arc<[rs.u16, rs.u8]> = _27[0]; + const y: rs.Arc<[rs.u16, rs.u8]> = _27[1]; + const same: rs.Arc<[rs.u16, rs.u8]> = rs.arcClone(x); + const _34: [rs.Arc, rs.Arc] = [new rs.Arc(copy$pointers_Spot(spot)), new rs.Arc(copy$pointers_Spot(spot))]; + const p: rs.Arc = _34[0]; + const q: rs.Arc = _34[1]; + const shared: rs.Arc = rs.arcClone(p); + const _41: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(pair)]; + const m: [rs.u16, rs.u8] = _41[0]; + const n: [rs.u16, rs.u8] = _41[1]; + const _46: [rs.Arc, rs.Arc] = [new rs.Arc(copy$array_u8(bytes)), new rs.Arc(copy$array_u8(bytes))]; + const k: rs.Arc = _46[0]; + const l: rs.Arc = _46[1]; + const list: rs.Vec<[rs.u16, rs.u8]> = rs.vecFromElem(copy$tuple2_u16_u8(pair), 2, copy$tuple2_u16_u8); + const pushed: rs.Vec = new rs.Vec(); pushed.items.push(copy$pointers_Spot(spot)); pushed.items.push(copy$pointers_Spot(spot)); - const held: Array<[rt.u16, rt.u8] | undefined> = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(pair)]; - const _60: [[rt.u16, rt.u8], [rt.u16, rt.u8]] = [[0, 1], [0, 1]]; - const origin: [rt.u16, rt.u8] = _60[0]; - const other: [rt.u16, rt.u8] = _60[1]; + const held: Array<[rs.u16, rs.u8] | undefined> = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(pair)]; + const _60: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [[0, 1], [0, 1]]; + const origin: [rs.u16, rs.u8] = _60[0]; + const other: [rs.u16, rs.u8] = _60[1]; const _64: string = "a"; const named: Named.Named = { spot: copy$pointers_Spot(spot), name: _64 }; const renamed: Named.Named = Named.clone$Clone(named); - const _69: rt.u8 = x.value === y.value ? 1 : 0; - const _77: rt.u8 = x.value === same.value ? 1 : 0; + const _69: rs.u8 = x.value === y.value ? 1 : 0; + const _77: rs.u8 = x.value === same.value ? 1 : 0; const arc = x; - const _87: [rt.u16, rt.u8] = rt.arcRaw(arc, arc.value, "Arc"); + const _87: [rs.u16, rs.u8] = rs.arcRaw(arc, arc.value, "Arc"); const arc2 = y; - const _85: rt.u8 = _87 === rt.arcRaw(arc2, arc2.value, "Arc") ? 1 : 0; + const _85: rs.u8 = _87 === rs.arcRaw(arc2, arc2.value, "Arc") ? 1 : 0; const arc3 = x; - const _93: [rt.u16, rt.u8] = rt.arcRaw(arc3, arc3.value, "Arc"); + const _93: [rs.u16, rs.u8] = rs.arcRaw(arc3, arc3.value, "Arc"); const arc4 = same; - const _91: rt.u8 = _93 === rt.arcRaw(arc4, arc4.value, "Arc") ? 1 : 0; - const _97: rt.u8 = x.value === pair ? 1 : 0; - const _104: rt.u8 = p.value === q.value ? 1 : 0; - const _112: rt.u8 = p.value === shared.value ? 1 : 0; - const _120: rt.u8 = p.value.at === q.value.at ? 1 : 0; - const _130: rt.u8 = p.value.at === spot.at ? 1 : 0; + const _91: rs.u8 = _93 === rs.arcRaw(arc4, arc4.value, "Arc") ? 1 : 0; + const _97: rs.u8 = x.value === pair ? 1 : 0; + const _104: rs.u8 = p.value === q.value ? 1 : 0; + const _112: rs.u8 = p.value === shared.value ? 1 : 0; + const _120: rs.u8 = p.value.at === q.value.at ? 1 : 0; + const _130: rs.u8 = p.value.at === spot.at ? 1 : 0; const arc5 = p; - const _140: Spot.Spot = rt.arcRaw(arc5, arc5.value, "Rc"); + const _140: Spot.Spot = rs.arcRaw(arc5, arc5.value, "Rc"); const arc6 = shared; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_69, _77, _85, _91, _97, _104, _112, _120, _130, _140 === rt.arcRaw(arc6, arc6.value, "Rc") ? 1 : 0, m === n ? 1 : 0, m === x.value ? 1 : 0, rt.byteSliceSame(rt.byteSliceFrom(k.value), rt.byteSliceFrom(l.value)) ? 1 : 0, rt.byteSliceSame(rt.byteSliceFrom(k.value), rt.byteSliceFrom(bytes)) ? 1 : 0, list.items[rt.idx(list.items, 0)] === list.items[rt.idx(list.items, 1)] ? 1 : 0, pushed.items[rt.idx(pushed.items, 0)] === pushed.items[rt.idx(pushed.items, 1)] ? 1 : 0, pushed.items[rt.idx(pushed.items, 0)].at === spot.at ? 1 : 0, rt.optionUnwrap(held[0]) === rt.optionUnwrap(held[1]) ? 1 : 0, origin === other ? 1 : 0, named.spot === renamed.spot ? 1 : 0, named.spot.at === renamed.spot.at ? 1 : 0)), undefined, true); - const moved: [rt.u16, rt.u8] = copy$tuple2_u16_u8(m); - const again: [rt.u16, rt.u8] = copy$tuple2_u16_u8(moved); - const swapped: [rt.u16, rt.u8] = copy$tuple2_u16_u8(n); - const unwrapped: rt.Arc<[rt.u16, rt.u8]> = new rt.Arc(copy$tuple2_u16_u8(option_unwrapOr$1l4p6jc(rt.arcIntoInner(x), [0, 1]))); - const rewrapped: rt.Arc = new rt.Arc(copy$pointers_Spot(option_mapOr$00zno7m(rt.arcIntoInner(q), spot, (s: Spot.Spot): Spot.Spot => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_69, _77, _85, _91, _97, _104, _112, _120, _130, _140 === rs.arcRaw(arc6, arc6.value, "Rc") ? 1 : 0, m === n ? 1 : 0, m === x.value ? 1 : 0, rs.byteSliceSame(rs.byteSliceFrom(k.value), rs.byteSliceFrom(l.value)) ? 1 : 0, rs.byteSliceSame(rs.byteSliceFrom(k.value), rs.byteSliceFrom(bytes)) ? 1 : 0, list.items[rs.idx(list.items, 0)] === list.items[rs.idx(list.items, 1)] ? 1 : 0, pushed.items[rs.idx(pushed.items, 0)] === pushed.items[rs.idx(pushed.items, 1)] ? 1 : 0, pushed.items[rs.idx(pushed.items, 0)].at === spot.at ? 1 : 0, rs.optionUnwrap(held[0]) === rs.optionUnwrap(held[1]) ? 1 : 0, origin === other ? 1 : 0, named.spot === renamed.spot ? 1 : 0, named.spot.at === renamed.spot.at ? 1 : 0)), undefined, true); + const moved: [rs.u16, rs.u8] = copy$tuple2_u16_u8(m); + const again: [rs.u16, rs.u8] = copy$tuple2_u16_u8(moved); + const swapped: [rs.u16, rs.u8] = copy$tuple2_u16_u8(n); + const unwrapped: rs.Arc<[rs.u16, rs.u8]> = new rs.Arc(copy$tuple2_u16_u8(option_unwrapOr$179xo1w(rs.arcIntoInner(x), [0, 1]))); + const rewrapped: rs.Arc = new rs.Arc(copy$pointers_Spot(option_mapOr$00zno7m(rs.arcIntoInner(q), spot, (s: Spot.Spot): Spot.Spot => { return copy$pointers_Spot(s); }))); - const _238: rt.u8 = again === m ? 1 : 0; - const _244: rt.u8 = again === moved ? 1 : 0; - const _250: rt.u8 = n === again ? 1 : 0; - const _256: rt.u8 = swapped === n ? 1 : 0; - const _262: rt.u8 = unwrapped.value === y.value ? 1 : 0; - const _270: rt.u8 = unwrapped.value === same.value ? 1 : 0; + const _238: rs.u8 = again === m ? 1 : 0; + const _244: rs.u8 = again === moved ? 1 : 0; + const _250: rs.u8 = n === again ? 1 : 0; + const _256: rs.u8 = swapped === n ? 1 : 0; + const _262: rs.u8 = unwrapped.value === y.value ? 1 : 0; + const _270: rs.u8 = unwrapped.value === same.value ? 1 : 0; const arc7 = unwrapped; - const _280: [rt.u16, rt.u8] = rt.arcRaw(arc7, arc7.value, "Arc"); + const _280: [rs.u16, rs.u8] = rs.arcRaw(arc7, arc7.value, "Arc"); const arc8 = y; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rt.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (rt.stringLen(_64) & 0xff))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_238, _244, _250, _256, _262, _270, _280 === rs.arcRaw(arc8, arc8.value, "Arc") ? 1 : 0, rewrapped.value === p.value ? 1 : 0, rewrapped.value.at === p.value.at ? 1 : 0, p.strong & 0xff, swapped[1] ^ unwrapped.value[1] ^ rewrapped.value.tag ^ (rs.stringLen(_64) & 0xff))), undefined, true); const item = copy$tuple2_u16_u8(pair); - const repeated: rt.Vec<[rt.u16, rt.u8]> = rt.vecFrom(Array.from({ length: 2 }, (): [rt.u16, rt.u8] => { + const repeated: rs.Vec<[rs.u16, rs.u8]> = rs.vecFrom(Array.from({ length: 2 }, (): [rs.u16, rs.u8] => { return copy$tuple2_u16_u8(item); }).map(copy$tuple2_u16_u8)); - const copied: rt.Vec<[rt.u16, rt.u8]> = rt.iterToVec(rt.iterCopied(rt.iterSlice(list.items), copy$tuple2_u16_u8), undefined, 4, true); - const cloned: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(pushed.items), copy$pointers_Spot), undefined, 6, true); - const extended: rt.Vec<[rt.u16, rt.u8]> = rt.vecFrom(list.items.map(copy$tuple2_u16_u8)); - rt.vecExtendFromSlice(extended, list.items, 4, copy$tuple2_u16_u8); + const copied: rs.Vec<[rs.u16, rs.u8]> = rs.iterToVec(rs.iterCopied(rs.iterSlice(list.items), copy$tuple2_u16_u8), undefined, 4, true); + const cloned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(pushed.items), copy$pointers_Spot), undefined, 6, true); + const extended: rs.Vec<[rs.u16, rs.u8]> = rs.vecFrom(list.items.map(copy$tuple2_u16_u8)); + rs.vecExtendFromSlice(extended, list.items, 4, copy$tuple2_u16_u8); extended.items.push(copy$tuple2_u16_u8(pair)); extended.items.push(copy$tuple2_u16_u8(pair)); - const _346: rt.Iter<[rt.u16, rt.u8]> = rt.iterSlice(list.items); - rt.iterExtend(extended, rt.iterMap(_346, copy$tuple2_u16_u8), undefined, 4, true); - const opted: [rt.u16, rt.u8] | undefined = copy$Option_tuple2_u16_u8(held[0]); - const cell: rt.Cell<[rt.u16, rt.u8]> = new rt.Cell(copy$tuple2_u16_u8(pair)); - const _357: [[rt.u16, rt.u8], [rt.u16, rt.u8]] = [copy$tuple2_u16_u8(cell.v), copy$tuple2_u16_u8(cell.v)]; - const got: [rt.u16, rt.u8] = copy$tuple2_u16_u8(_357[0]); - const againGot: [rt.u16, rt.u8] = copy$tuple2_u16_u8(_357[1]); - const _364: [[rt.u16, rt.u8], [rt.u16, rt.u8]] = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(m)]; - const read: [rt.u16, rt.u8] = copy$tuple2_u16_u8(_364[0]); - const reread: [rt.u16, rt.u8] = copy$tuple2_u16_u8(_364[1]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(repeated.items[rt.idx(repeated.items, 0)] === repeated.items[rt.idx(repeated.items, 1)] ? 1 : 0, copied.items[rt.idx(copied.items, 0)] === list.items[rt.idx(list.items, 0)] ? 1 : 0, cloned.items[rt.idx(cloned.items, 1)].at === pushed.items[rt.idx(pushed.items, 1)].at ? 1 : 0, extended.items[rt.idx(extended.items, 0)] === list.items[rt.idx(list.items, 0)] ? 1 : 0, extended.items[rt.idx(extended.items, 2)] === list.items[rt.idx(list.items, 0)] ? 1 : 0, extended.items[rt.idx(extended.items, 4)] === extended.items[rt.idx(extended.items, 5)] ? 1 : 0, extended.items[rt.idx(extended.items, 6)] === list.items[rt.idx(list.items, 0)] ? 1 : 0, rt.optionUnwrap(opted) === rt.optionUnwrap(held[0]) ? 1 : 0, got === againGot ? 1 : 0, read === pair ? 1 : 0, reread === m ? 1 : 0)), undefined, true); - let maybe: rt.Arc<[rt.u16, rt.u8] | undefined> = new rt.Arc(copy$tuple2_u16_u8(pair)); - let spotted: rt.Arc = new rt.Arc(copy$pointers_Spot(spot)); - const weak: [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak] | undefined = then$1d2br9m((c & 1) !== 0, (): [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak] => { - return [new rt.Weak(maybe), new rt.Weak(spotted)] as [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak]; + const _346: rs.Iter<[rs.u16, rs.u8]> = rs.iterSlice(list.items); + rs.iterExtend(extended, rs.iterMap(_346, copy$tuple2_u16_u8), undefined, 4, true); + const opted: [rs.u16, rs.u8] | undefined = copy$Option_tuple2_u16_u8(held[0]); + const cell: rs.Cell<[rs.u16, rs.u8]> = new rs.Cell(copy$tuple2_u16_u8(pair)); + const _357: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [copy$tuple2_u16_u8(cell.v), copy$tuple2_u16_u8(cell.v)]; + const got: [rs.u16, rs.u8] = copy$tuple2_u16_u8(_357[0]); + const againGot: [rs.u16, rs.u8] = copy$tuple2_u16_u8(_357[1]); + const _364: [[rs.u16, rs.u8], [rs.u16, rs.u8]] = [copy$tuple2_u16_u8(pair), copy$tuple2_u16_u8(m)]; + const read: [rs.u16, rs.u8] = copy$tuple2_u16_u8(_364[0]); + const reread: [rs.u16, rs.u8] = copy$tuple2_u16_u8(_364[1]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(repeated.items[rs.idx(repeated.items, 0)] === repeated.items[rs.idx(repeated.items, 1)] ? 1 : 0, copied.items[rs.idx(copied.items, 0)] === list.items[rs.idx(list.items, 0)] ? 1 : 0, cloned.items[rs.idx(cloned.items, 1)].at === pushed.items[rs.idx(pushed.items, 1)].at ? 1 : 0, extended.items[rs.idx(extended.items, 0)] === list.items[rs.idx(list.items, 0)] ? 1 : 0, extended.items[rs.idx(extended.items, 2)] === list.items[rs.idx(list.items, 0)] ? 1 : 0, extended.items[rs.idx(extended.items, 4)] === extended.items[rs.idx(extended.items, 5)] ? 1 : 0, extended.items[rs.idx(extended.items, 6)] === list.items[rs.idx(list.items, 0)] ? 1 : 0, rs.optionUnwrap(opted) === rs.optionUnwrap(held[0]) ? 1 : 0, got === againGot ? 1 : 0, read === pair ? 1 : 0, reread === m ? 1 : 0)), undefined, true); + let maybe: rs.Arc<[rs.u16, rs.u8] | undefined> = new rs.Arc(copy$tuple2_u16_u8(pair)); + let spotted: rs.Arc = new rs.Arc(copy$pointers_Spot(spot)); + const weak: [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak] | undefined = then$0jw3xip((c & 1) !== 0, (): [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak] => { + return [new rs.Weak(maybe), new rs.Weak(spotted)] as [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak]; }); - const strong: [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc] | undefined = then$04p7jmh((c & 2) !== 0, (): [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc] => { - return [rt.arcClone(maybe), rt.arcClone(spotted)] as [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc]; + const strong: [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc] | undefined = then$1a5xgoh((c & 2) !== 0, (): [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc] => { + return [rs.arcClone(maybe), rs.arcClone(spotted)] as [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc]; }); - let run: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.byteVecFrom(Uint8Array.of(a, b, c)))); - const runWeak: rt.Weak | undefined = then$1vx3p6m((c & 4) !== 0, (): rt.Weak => { - return new rt.Weak(run); + let run: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteVecFrom(Uint8Array.of(a, b, c)))); + const runWeak: rs.Weak | undefined = then$0bgt67i((c & 4) !== 0, (): rs.Weak => { + return new rs.Weak(run); }); - const _484: rt.ByteSlice = rt.arcMakeMut(rt.place(() => run, (value) => run = value), (a0: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a0)); - }, rt.drop); - rt.idx(_484, 0); + const _484: rs.ByteSlice = rs.arcMakeMut(rs.place(() => run, (value) => run = value), (a0: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a0)); + }, rs.drop); + rs.idx(_484, 0); _484.data[_484.start] = _484.data[_484.start] ^ c; - rt.byteVecExtendFromSlice(out, run.value); - rt.drop(runWeak); - const was: [rt.u16, rt.u8] = rt.optionUnwrap(maybe.value); - const wasAt: [rt.u16, rt.u8] = spotted.value.at; + rs.byteVecExtendFromSlice(out, run.value); + rs.drop(runWeak); + const was: [rs.u16, rs.u8] = rs.optionUnwrap(maybe.value); + const wasAt: [rs.u16, rs.u8] = spotted.value.at; const arc9 = spotted; - const wasSpot: Spot.Spot = rt.arcRaw(arc9, arc9.value, "Arc"); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(was === rt.optionUnwrap(rt.arcMakeMutPlace(rt.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u16_u8, rt.drop, copy$Option_tuple2_u16_u8).v) ? 1 : 0, wasAt === rt.arcMakeMut(rt.place(() => spotted, (value3) => spotted = value3), copy$pointers_Spot, rt.drop, copy$pointers_Spot).at ? 1 : 0, wasSpot === spotted.value ? 1 : 0, isSomeAnd$10niqnm(weak, (_24: [rt.Weak<[rt.u16, rt.u8] | undefined>, rt.Weak]): boolean => { + const wasSpot: Spot.Spot = rs.arcRaw(arc9, arc9.value, "Arc"); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(was === rs.optionUnwrap(rs.arcMakeMutPlace(rs.place(() => maybe, (value2) => maybe = value2), copy$Option_tuple2_u16_u8, rs.drop, copy$Option_tuple2_u16_u8).v) ? 1 : 0, wasAt === rs.arcMakeMut(rs.place(() => spotted, (value3) => spotted = value3), copy$pointers_Spot, rs.drop, copy$pointers_Spot).at ? 1 : 0, wasSpot === spotted.value ? 1 : 0, isSomeAnd$07atiew(weak, (_24: [rs.Weak<[rs.u16, rs.u8] | undefined>, rs.Weak]): boolean => { let _06!: boolean; - const r: rt.Weak<[rt.u16, rt.u8] | undefined> = _24[0]; - const a2: rt.Weak = _24[1]; - const _7: rt.Arc<[rt.u16, rt.u8] | undefined> | undefined = rt.weakUpgrade(r); + const r: rs.Weak<[rs.u16, rs.u8] | undefined> = _24[0]; + const a2: rs.Weak = _24[1]; + const _7: rs.Arc<[rs.u16, rs.u8] | undefined> | undefined = rs.weakUpgrade(r); if (!(_7 !== undefined)) { - rt.drop(_7); - const _10: rt.Arc | undefined = rt.weakUpgrade(a2); + rs.drop(_7); + const _10: rs.Arc | undefined = rs.weakUpgrade(a2); _06 = _10 !== undefined; - rt.drop(_10); + rs.drop(_10); } else { - rt.drop(_7); + rs.drop(_7); _06 = true; } a2[Symbol.dispose](); r[Symbol.dispose](); return _06; - }) ? 1 : 0, isSomeAnd$0h2dqit(strong, (_25: [rt.Arc<[rt.u16, rt.u8] | undefined>, rt.Arc]): boolean => { + }) ? 1 : 0, isSomeAnd$1nosv3e(strong, (_25: [rs.Arc<[rs.u16, rs.u8] | undefined>, rs.Arc]): boolean => { let _07!: boolean; - const r2: rt.Arc<[rt.u16, rt.u8] | undefined> = _25[0]; - const a3: rt.Arc = _25[1]; - if (!(rt.optionUnwrap(r2.value) === rt.optionUnwrap(maybe.value))) { + const r2: rs.Arc<[rs.u16, rs.u8] | undefined> = _25[0]; + const a3: rs.Arc = _25[1]; + if (!(rs.optionUnwrap(r2.value) === rs.optionUnwrap(maybe.value))) { _07 = a3.value.at === spotted.value.at; } else { _07 = true; @@ -2574,117 +2574,117 @@ export function distinct(data: rt.ByteSlice, out: rt.ByteVec): void { * and `decrement_strong_count`, the value dropping with the last, taken back by * `from_raw`, cast to `*const ()` and back first, and compared, as `strong_count` reads. */ -export function rawArcs(data: rt.ByteSlice, out: rt.ByteVec): void { - const dropped: rt.Cell = new rt.Cell(0); - const num: rt.Arc = new rt.Arc(7); - const duo: rt.Arc = new rt.Arc({ _0: 1, _1: 2 }); - const unit: rt.Arc = new rt.Arc(undefined); - const other: rt.Arc = new rt.Arc(undefined); - const held: rt.Arc = new rt.Arc(new Counted.Counted(3, dropped)); +export function rawArcs(data: rs.ByteSlice, out: rs.ByteVec): void { + const dropped: rs.Cell = new rs.Cell(0); + const num: rs.Arc = new rs.Arc(7); + const duo: rs.Arc = new rs.Arc({ _0: 1, _1: 2 }); + const unit: rs.Arc = new rs.Arc(undefined); + const other: rs.Arc = new rs.Arc(undefined); + const held: rs.Arc = new rs.Arc(new Counted.Counted(3, dropped)); const arc = num; - const numAt: rt.Place = rt.arcRaw(arc, rt.arcPlace(arc), "Arc"); - const arc2 = rt.arcClone(num); - const _17: rt.Place = rt.arcRaw(arc2, rt.arcPlace(arc2), "Arc"); - const arc3 = rt.arcClone(duo); - const _16: [rt.Place, Duo.Duo] = [_17, rt.arcRaw(arc3, arc3.value, "Rc")]; - const numRaw: rt.Place = _17; + const numAt: rs.Place = rs.arcRaw(arc, rs.arcPlace(arc), "Arc"); + const arc2 = rs.arcClone(num); + const _17: rs.Place = rs.arcRaw(arc2, rs.arcPlace(arc2), "Arc"); + const arc3 = rs.arcClone(duo); + const _16: [rs.Place, Duo.Duo] = [_17, rs.arcRaw(arc3, arc3.value, "Rc")]; + const numRaw: rs.Place = _17; const duoRaw: Duo.Duo = _16[1]; - const arc4 = rt.arcClone(unit); - const _26: rt.Place = rt.arcRaw(arc4, rt.arcPlace(arc4), "Arc"); + const arc4 = rs.arcClone(unit); + const _26: rs.Place = rs.arcRaw(arc4, rs.arcPlace(arc4), "Arc"); const arc5 = other; - const _25: [rt.Place, rt.Place] = [_26, rt.arcRaw(arc5, rt.arcPlace(arc5), "Arc")]; - const unitRaw: rt.Place = _26; - const otherRaw: rt.Place = _25[1]; + const _25: [rs.Place, rs.Place] = [_26, rs.arcRaw(arc5, rs.arcPlace(arc5), "Arc")]; + const unitRaw: rs.Place = _26; + const otherRaw: rs.Place = _25[1]; const arc6 = held; - const heldRaw: Counted.Counted = rt.arcRaw(arc6, arc6.value, "Rc"); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([duoRaw === duo.value, unitRaw === otherRaw], (a0: boolean): rt.u8 => { + const heldRaw: Counted.Counted = rs.arcRaw(arc6, arc6.value, "Rc"); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([duoRaw === duo.value, unitRaw === otherRaw], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); const arc7 = unit; - const _42: boolean = unitRaw === rt.arcRaw(arc7, rt.arcPlace(arc7), "Arc"); - const _46: rt.Place = rt.ptrErase(duoRaw, "pointers::Duo", 1); + const _42: boolean = unitRaw === rs.arcRaw(arc7, rs.arcPlace(arc7), "Arc"); + const _46: rs.Place = rs.ptrErase(duoRaw, "pointers::Duo", 1); const arc8 = duo; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_42, _46 === rt.ptrErase(rt.arcRaw(arc8, arc8.value, "Rc"), "pointers::Duo", 1)], (a02: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_42, _46 === rs.ptrErase(rs.arcRaw(arc8, arc8.value, "Rc"), "pointers::Duo", 1)], (a02: boolean): rs.u8 => { return a02 ? 1 : 0; })), undefined, true); - for (const byte of rt.byteSliceView(data)) { - const _57: rt.u8 = rt.u8Rem(byte, 6); + for (const byte of rs.byteSliceView(data)) { + const _57: rs.u8 = rs.u8Rem(byte, 6); if (_57 === 0) { - rt.arcClone(rt.arcFromRaw(rt.ptrAdd(rt.ptrAdd(numRaw, 1), -1), "Arc")); + rs.arcClone(rs.arcFromRaw(rs.ptrAdd(rs.ptrAdd(numRaw, 1), -1), "Arc")); undefined; } else if (_57 === 1) { if (num.strong > 2) { - const back: rt.usize = byte >> 3 as rt.usize; - rt.arcFromRaw(rt.ptrWrappingAdd(rt.ptrWrappingAdd(numAt, back, 4, 4), -back, 4, 4), "Arc")[Symbol.dispose](); + const back: rs.usize = byte >> 3 as rs.usize; + rs.arcFromRaw(rs.ptrWrappingAdd(rs.ptrWrappingAdd(numAt, back, 4, 4), -back, 4, 4), "Arc")[Symbol.dispose](); } } else if (_57 === 2) { - rt.arcClone(rt.arcFromRaw(duoRaw, "Rc")); + rs.arcClone(rs.arcFromRaw(duoRaw, "Rc")); undefined; } else if (_57 === 3) { if (dropped.v === 0) { - rt.arcClone(rt.arcFromRaw(rt.ptrUnerase(rt.ptrErase(heldRaw, "pointers::Counted<'_>", 4), "pointers::Counted<'_>", 4) as Counted.Counted, "Rc")); + rs.arcClone(rs.arcFromRaw(rs.ptrUnerase(rs.ptrErase(heldRaw, "pointers::Counted<'_>", 4), "pointers::Counted<'_>", 4) as Counted.Counted, "Rc")); undefined; } } else if (_57 === 4) { if (dropped.v === 0) { - rt.arcFromRaw(rt.ptrUnerase(rt.ptrErase(heldRaw, "pointers::Counted<'_>", 4), "pointers::Counted<'_>", 4) as Counted.Counted, "Rc")[Symbol.dispose](); + rs.arcFromRaw(rs.ptrUnerase(rs.ptrErase(heldRaw, "pointers::Counted<'_>", 4), "pointers::Counted<'_>", 4) as Counted.Counted, "Rc")[Symbol.dispose](); } } else { - rt.byteVecPush(out, rt.arcFromRaw(duoRaw, "Rc").strong & 0xff); + rs.byteVecPush(out, rs.arcFromRaw(duoRaw, "Rc").strong & 0xff); undefined; } if (dropped.v === 0) { - const held2: rt.Arc = rt.arcFromRaw(heldRaw, "Rc"); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(held2.strong & 0xff, held2.value.id)), undefined, true); + const held2: rs.Arc = rs.arcFromRaw(heldRaw, "Rc"); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(held2.strong & 0xff, held2.value.id)), undefined, true); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(num.strong & 0xff, duo.strong & 0xff, dropped.v)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(num.strong & 0xff, duo.strong & 0xff, dropped.v)), undefined, true); } - const numBack: rt.Arc = rt.arcFromRaw(numRaw, "Arc"); - const duoBack: rt.Arc = rt.arcFromRaw(duoRaw, "Rc"); - const unitBack: rt.Arc = rt.arcFromRaw(unitRaw, "Arc"); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([numBack === num, duoBack === duo, unitBack === unit], (a03: boolean): rt.u8 => { + const numBack: rs.Arc = rs.arcFromRaw(numRaw, "Arc"); + const duoBack: rs.Arc = rs.arcFromRaw(duoRaw, "Rc"); + const unitBack: rs.Arc = rs.arcFromRaw(unitRaw, "Arc"); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([numBack === num, duoBack === duo, unitBack === unit], (a03: boolean): rs.u8 => { return a03 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(numBack.value & 0xff, duoBack.value._1, unit.strong & 0xff)), undefined, true); - drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit([numBack, duoBack, unitBack] as [rt.Arc, rt.Arc, rt.Arc]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(num.strong & 0xff, duo.strong & 0xff, unit.strong & 0xff)), undefined, true); - rt.arcFromRaw(otherRaw, "Arc")[Symbol.dispose](); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(numBack.value & 0xff, duoBack.value._1, unit.strong & 0xff)), undefined, true); + drop$tuple3_sync_Arc_u32_Rc_pointers_Duo_sync_Arc_unit([numBack, duoBack, unitBack] as [rs.Arc, rs.Arc, rs.Arc]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(num.strong & 0xff, duo.strong & 0xff, unit.strong & 0xff)), undefined, true); + rs.arcFromRaw(otherRaw, "Arc")[Symbol.dispose](); const twin: Twin.Twin = { _0: data.length & 0xff, _1: 1 }; - const _159: [rt.Arc, rt.Arc] = [new rt.Arc(copy$pointers_Twin(twin)), new rt.Arc(copy$pointers_Twin(twin))]; - const a: rt.Arc = _159[0]; - const b: rt.Arc = _159[1]; - const _164: [rt.Arc, rt.Arc] = [new rt.Arc(copy$pointers_Twin(twin)), new rt.Arc(copy$pointers_Twin(twin))]; - const c: rt.Arc = _164[0]; - const d: rt.Arc = _164[1]; - const arc9 = rt.arcClone(a); - const _170: Twin.Twin = rt.arcRaw(arc9, arc9.value, "Arc"); - const arc10 = rt.arcClone(b); - const _169: [Twin.Twin, Twin.Twin] = [_170, rt.arcRaw(arc10, arc10.value, "Rc")]; + const _159: [rs.Arc, rs.Arc] = [new rs.Arc(copy$pointers_Twin(twin)), new rs.Arc(copy$pointers_Twin(twin))]; + const a: rs.Arc = _159[0]; + const b: rs.Arc = _159[1]; + const _164: [rs.Arc, rs.Arc] = [new rs.Arc(copy$pointers_Twin(twin)), new rs.Arc(copy$pointers_Twin(twin))]; + const c: rs.Arc = _164[0]; + const d: rs.Arc = _164[1]; + const arc9 = rs.arcClone(a); + const _170: Twin.Twin = rs.arcRaw(arc9, arc9.value, "Arc"); + const arc10 = rs.arcClone(b); + const _169: [Twin.Twin, Twin.Twin] = [_170, rs.arcRaw(arc10, arc10.value, "Rc")]; const p: Twin.Twin = _170; const q: Twin.Twin = _169[1]; - const arc11 = rt.arcClone(c); - const _179: Twin.Twin = rt.arcRaw(arc11, arc11.value, "Arc"); - const arc12 = rt.arcClone(d); - const _178: [Twin.Twin, Twin.Twin] = [_179, rt.arcRaw(arc12, arc12.value, "Rc")]; + const arc11 = rs.arcClone(c); + const _179: Twin.Twin = rs.arcRaw(arc11, arc11.value, "Arc"); + const arc12 = rs.arcClone(d); + const _178: [Twin.Twin, Twin.Twin] = [_179, rs.arcRaw(arc12, arc12.value, "Rc")]; const r: Twin.Twin = _179; const s: Twin.Twin = _178[1]; - rt.arcClone(rt.arcFromRaw(p, "Arc")); + rs.arcClone(rs.arcFromRaw(p, "Arc")); undefined; - rt.arcClone(rt.arcFromRaw(q, "Rc")); + rs.arcClone(rs.arcFromRaw(q, "Rc")); undefined; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([a.value, b.value, c.value, d.value], (t: Twin.Twin): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([a.value, b.value, c.value, d.value], (t: Twin.Twin): rs.u8 => { return t._0 ^ t._1; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([a.strong, b.strong, c.strong, d.strong], (n: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([a.strong, b.strong, c.strong, d.strong], (n: rs.usize): rs.u8 => { return n & 0xff; })), undefined, true); - drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin([rt.arcFromRaw(p, "Arc"), rt.arcFromRaw(p, "Arc"), rt.arcFromRaw(q, "Rc"), rt.arcFromRaw(q, "Rc")] as [rt.Arc, rt.Arc, rt.Arc, rt.Arc]); - drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin([rt.arcFromRaw(r, "Arc"), rt.arcFromRaw(s, "Rc")] as [rt.Arc, rt.Arc]); + drop$tuple4_sync_Arc_pointers_Twin_sync_Arc_pointers_Twin_Rc_pointers_Twin_Rc_pointers_Twin([rs.arcFromRaw(p, "Arc"), rs.arcFromRaw(p, "Arc"), rs.arcFromRaw(q, "Rc"), rs.arcFromRaw(q, "Rc")] as [rs.Arc, rs.Arc, rs.Arc, rs.Arc]); + drop$tuple2_sync_Arc_pointers_Twin_Rc_pointers_Twin([rs.arcFromRaw(r, "Arc"), rs.arcFromRaw(s, "Rc")] as [rs.Arc, rs.Arc]); while (dropped.v === 0) { - rt.arcFromRaw(heldRaw, "Rc")[Symbol.dispose](); - rt.byteVecPush(out, dropped.v); + rs.arcFromRaw(heldRaw, "Rc")[Symbol.dispose](); + rs.byteVecPush(out, dropped.v); } - rt.byteVecPush(out, dropped.v); + rs.byteVecPush(out, dropped.v); d[Symbol.dispose](); c[Symbol.dispose](); b[Symbol.dispose](); @@ -2695,37 +2695,37 @@ export function rawArcs(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A waker's data, an `Arc`'s raw pointer, which waking sets. */ -export function flagClone(data: rt.Place): rt.RawWaker { - rt.arcClone(rt.arcFromRaw(rt.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rt.Place>, "Arc")); +export function flagClone(data: rs.Place): rs.RawWaker { + rs.arcClone(rs.arcFromRaw(rs.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rs.Place>, "Arc")); undefined; return { data, vtable: FLAG }; } -export function flagWake(data: rt.Place): void { - const _5: rt.Arc> = rt.arcFromRaw(rt.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rt.Place>, "Arc"); - rt.atomicStore(_5.value, true, 4); +export function flagWake(data: rs.Place): void { + const _5: rs.Arc> = rs.arcFromRaw(rs.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rs.Place>, "Arc"); + rs.atomicStore(_5.value, true, 4); _5[Symbol.dispose](); } -export function flagWakeByRef(data: rt.Place): void { - rt.atomicStore((rt.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rt.Place>).v, true, 4); +export function flagWakeByRef(data: rs.Place): void { + rs.atomicStore((rs.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rs.Place>).v, true, 4); } -export function flagDrop(data: rt.Place): void { - rt.arcFromRaw(rt.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rt.Place>, "Arc")[Symbol.dispose](); +export function flagDrop(data: rs.Place): void { + rs.arcFromRaw(rs.ptrUnerase(data, "std::sync::atomic::Atomic", 1) as rs.Place>, "Arc")[Symbol.dispose](); } -export const FLAG: rt.WakerVTable = /* @__PURE__ */ rt.wakerVTable(flagClone, flagWake as (a0: rt.Place) => undefined, flagWakeByRef as (a0: rt.Place) => undefined, flagDrop as (a0: rt.Place) => undefined); +export const FLAG: rs.WakerVTable = /* @__PURE__ */ rs.wakerVTable(flagClone, flagWake as (a0: rs.Place) => undefined, flagWakeByRef as (a0: rs.Place) => undefined, flagDrop as (a0: rs.Place) => undefined); /** A waker that sets `flag`, holding a count of it. */ -export function flagWaker(flag: rt.Arc>): rt.Waker { - const arc = rt.arcClone(flag); - return rt.wakerFromRaw({ data: rt.arcErase(rt.arcRaw(arc, rt.arcPlace(arc), "Arc"), "std::sync::atomic::Atomic", 1), vtable: FLAG }); +export function flagWaker(flag: rs.Arc>): rs.Waker { + const arc = rs.arcClone(flag); + return rs.wakerFromRaw({ data: rs.arcErase(rs.arcRaw(arc, rs.arcPlace(arc), "Arc"), "std::sync::atomic::Atomic", 1), vtable: FLAG }); } /** `p`, a pointer this body doesn't show the source of, erased. */ -export function eraseFlag(p: rt.Place>): rt.Place { - return rt.arcErase(p, "std::sync::atomic::Atomic", 1); +export function eraseFlag(p: rs.Place>): rs.Place { + return rs.arcErase(p, "std::sync::atomic::Atomic", 1); } /** @@ -2734,103 +2734,103 @@ export function eraseFlag(p: rt.Place>): rt.Place * and an `Arc`'s cast to `*const ()` and back, as a waker's data, which its * vtable counts, wakes, and drops. Each compares as the pointer `as_ptr` gives. */ -export function rawPlaces(data: rt.ByteSlice, out: rt.ByteVec): void { - const num: rt.Arc = new rt.Arc(data.length as rt.u32); - const rc: rt.Arc = new rt.Arc(9); - const flag: rt.Arc> = new rt.Arc(new rt.Atomic(false)); - const wakers: rt.Vec = rt.vecFrom([flagWaker(flag)]); - for (const byte of rt.byteSliceView(data)) { - const numAt: rt.Place = rt.arcRaw(num, rt.arcPlace(num), "Arc"); - const rcAt: rt.Place = rt.arcRaw(rc, rt.arcPlace(rc), "Rc"); +export function rawPlaces(data: rs.ByteSlice, out: rs.ByteVec): void { + const num: rs.Arc = new rs.Arc(data.length as rs.u32); + const rc: rs.Arc = new rs.Arc(9); + const flag: rs.Arc> = new rs.Arc(new rs.Atomic(false)); + const wakers: rs.Vec = rs.vecFrom([flagWaker(flag)]); + for (const byte of rs.byteSliceView(data)) { + const numAt: rs.Place = rs.arcRaw(num, rs.arcPlace(num), "Arc"); + const rcAt: rs.Place = rs.arcRaw(rc, rs.arcPlace(rc), "Rc"); b2: { - const _26: rt.u8 = rt.u8Rem(byte, 8); + const _26: rs.u8 = rs.u8Rem(byte, 8); if (_26 === 0) { - rt.arcClone(rt.arcFromRaw(numAt, "Arc")); + rs.arcClone(rs.arcFromRaw(numAt, "Arc")); break b2; } if (_26 === 1) { if (num.strong > 1) { - rt.arcFromRaw(numAt, "Arc")[Symbol.dispose](); + rs.arcFromRaw(numAt, "Arc")[Symbol.dispose](); break b2; } } else { if (_26 === 2) { - rt.arcClone(rt.arcFromRaw(rcAt, "Rc")); + rs.arcClone(rs.arcFromRaw(rcAt, "Rc")); break b2; } if (_26 === 3) { if (rc.strong > 1) { - rt.arcFromRaw(rcAt, "Rc")[Symbol.dispose](); + rs.arcFromRaw(rcAt, "Rc")[Symbol.dispose](); break b2; } } else { if (_26 === 4) { - rt.arcClone(rt.arcFromRaw(rt.arcRaw(num, rt.arcPlace(num), "Arc"), "Arc")); + rs.arcClone(rs.arcFromRaw(rs.arcRaw(num, rs.arcPlace(num), "Arc"), "Arc")); break b2; } if (_26 === 5) { - const _47: rt.Waker = wakers.items[rt.idx(wakers.items, rt.usizeRem(byte as rt.usize, wakers.items.length))].clone(); + const _47: rs.Waker = wakers.items[rs.idx(wakers.items, rs.usizeRem(byte as rs.usize, wakers.items.length))].clone(); wakers.items.push(_47); break b2; } if (_26 === 6) { if (wakers.items.length > 1) { - rt.vecSwapRemove(wakers, rt.usizeRem(byte as rt.usize, wakers.items.length))[Symbol.dispose](); + rs.vecSwapRemove(wakers, rs.usizeRem(byte as rs.usize, wakers.items.length))[Symbol.dispose](); break b2; } } } } - rt.atomicStore(flag.value, false, 4); + rs.atomicStore(flag.value, false, 4); if ((byte & 8) === 0) { - wakers.items[rt.idx(wakers.items, 0)].wakeByRef(); + wakers.items[rs.idx(wakers.items, 0)].wakeByRef(); } else { - rt.optionUnwrap(rt.vecPop(wakers)).wake(); + rs.optionUnwrap(rs.vecPop(wakers)).wake(); } if (wakers.items.length === 0) { - const _80: rt.Waker = flagWaker(flag); + const _80: rs.Waker = flagWaker(flag); wakers.items.push(_80); } } - const taken2: rt.Arc = rt.arcFromRaw(rt.arcRaw(num, rt.arcPlace(num), "Arc"), "Arc"); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(num.strong & 0xff, taken2 === num ? 1 : 0, rc.strong & 0xff, flag.strong & 0xff, rt.atomicLoad(flag.value, 4) ? 1 : 0)), undefined, true); + const taken2: rs.Arc = rs.arcFromRaw(rs.arcRaw(num, rs.arcPlace(num), "Arc"), "Arc"); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(num.strong & 0xff, taken2 === num ? 1 : 0, rc.strong & 0xff, flag.strong & 0xff, rs.atomicLoad(flag.value, 4) ? 1 : 0)), undefined, true); const arc = num; - const _111: boolean = rt.arcErase(numAt, "u32", 4) === rt.arcErase(rt.arcRaw(arc, rt.arcPlace(arc), "Arc"), "u32", 4); - const _117: rt.Place = rt.arcErase(rcAt, "u16", 2); + const _111: boolean = rs.arcErase(numAt, "u32", 4) === rs.arcErase(rs.arcRaw(arc, rs.arcPlace(arc), "Arc"), "u32", 4); + const _117: rs.Place = rs.arcErase(rcAt, "u16", 2); const arc2 = rc; - const _116: boolean = _117 === rt.arcErase(rt.arcRaw(arc2, rt.arcPlace(arc2), "Rc"), "u16", 2); + const _116: boolean = _117 === rs.arcErase(rs.arcRaw(arc2, rs.arcPlace(arc2), "Rc"), "u16", 2); const arc3 = flag; - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_111, _116, eraseFlag(rt.arcRaw(arc3, rt.arcPlace(arc3), "Arc")) === wakers.items[rt.idx(wakers.items, 0)].data as rt.Place, rt.arcErase(rt.arcRaw(flag, rt.arcPlace(flag), "Arc"), "std::sync::atomic::Atomic", 1) === wakers.items[rt.idx(wakers.items, 0)].data as rt.Place], (a0: boolean): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_111, _116, eraseFlag(rs.arcRaw(arc3, rs.arcPlace(arc3), "Arc")) === wakers.items[rs.idx(wakers.items, 0)].data as rs.Place, rs.arcErase(rs.arcRaw(flag, rs.arcPlace(flag), "Arc"), "std::sync::atomic::Atomic", 1) === wakers.items[rs.idx(wakers.items, 0)].data as rs.Place], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); } - rt.dropVec(wakers); - rt.byteVecPush(out, flag.strong & 0xff); + rs.dropVec(wakers); + rs.byteVecPush(out, flag.strong & 0xff); while (num.strong > 1) { const arc4 = num; - rt.arcFromRaw(rt.arcRaw(arc4, rt.arcPlace(arc4), "Arc"), "Arc")[Symbol.dispose](); + rs.arcFromRaw(rs.arcRaw(arc4, rs.arcPlace(arc4), "Arc"), "Arc")[Symbol.dispose](); } while (rc.strong > 1) { - rt.arcFromRaw(rt.arcRaw(rc, rt.arcPlace(rc), "Rc"), "Rc")[Symbol.dispose](); + rs.arcFromRaw(rs.arcRaw(rc, rs.arcPlace(rc), "Rc"), "Rc")[Symbol.dispose](); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(num.strong & 0xff, rc.strong & 0xff, rc.value & 0xff)), undefined, true); - const _169: [Shelf.Shelf, Shelf.Shelf] = [new Shelf.Shelf(new rt.Arc(1)), new Shelf.Shelf(new rt.Arc(2))]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(num.strong & 0xff, rc.strong & 0xff, rc.value & 0xff)), undefined, true); + const _169: [Shelf.Shelf, Shelf.Shelf] = [new Shelf.Shelf(new rs.Arc(1)), new Shelf.Shelf(new rs.Arc(2))]; const first: Shelf.Shelf = _169[0]; const second: Shelf.Shelf = _169[1]; let shelf: Shelf.Shelf = first; - const value: rt.u32 = shelf._0.value; - if (isSomeAnd$09tpccf(rt.byteSliceFirst(data), (b: rt.u8): boolean => { - return rt.u8Rem(b, 2) === 0; + const value: rs.u32 = shelf._0.value; + if (isSomeAnd$1s2u5lz(rs.byteSliceFirst(data), (b: rs.u8): boolean => { + return rs.u8Rem(b, 2) === 0; })) { shelf = second; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of({ v: value }.v & 0xff, shelf._0.value & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of({ v: value }.v & 0xff, shelf._0.value & 0xff)), undefined, true); let shelf2: Shelf.Shelf = first; - const value2: rt.u32 = shelf2._0.value; - if (rt.usizeRem(data.length, 3) === 0) { + const value2: rs.u32 = shelf2._0.value; + if (rs.usizeRem(data.length, 3) === 0) { shelf2 = second; } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of({ v: value2 }.v & 0xff, shelf2._0.value & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of({ v: value2 }.v & 0xff, shelf2._0.value & 0xff)), undefined, true); second[Symbol.dispose](); first[Symbol.dispose](); flag[Symbol.dispose](); diff --git a/ts/fixtures/lang/pointers/src/pointers.rs b/ts/fixtures/lang/pointers/src/pointers.rs index 1e8dfb8d2..2065c8438 100644 --- a/ts/fixtures/lang/pointers/src/pointers.rs +++ b/ts/fixtures/lang/pointers/src/pointers.rs @@ -1089,7 +1089,7 @@ pub fn iterated_runs(data: &[u8], out: &mut Vec) { } } -/// A struct JS keeps as an object, holding an `rt.Cell`. +/// A struct JS keeps as an object, holding an `rs.Cell`. struct Stable(UnsafeCell); fn first_set(pair: &mut (T, Stable), value: T) { diff --git a/ts/fixtures/lang/refs/expected/core/bool.ts b/ts/fixtures/lang/refs/expected/core/bool.ts index a829bc88b..8e93227c5 100644 --- a/ts/fixtures/lang/refs/expected/core/bool.ts +++ b/ts/fixtures/lang/refs/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0xksuo2(self: boolean, t: rt.Place): rt.Place | undefined { +export function thenSome$1c6ozzd(self: boolean, t: rs.Place): rs.Place | undefined { if (!self) { return undefined; } return t; } -export function then$0ozmvid(self: boolean, f: () => rt.ByteVec): rt.ByteVec | undefined { +export function then$17csa2h(self: boolean, f: () => rs.ByteVec): rs.ByteVec | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/refs/expected/core/option.ts b/ts/fixtures/lang/refs/expected/core/option.ts index 9fbe75b1e..ec78ea0d7 100644 --- a/ts/fixtures/lang/refs/expected/core/option.ts +++ b/ts/fixtures/lang/refs/expected/core/option.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0x6fy3l(self: [rt.u8, rt.u8] | undefined, default_: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function unwrapOr$0w1py1w(self: [rs.u8, rs.u8] | undefined, default_: [rs.u8, rs.u8]): [rs.u8, rs.u8] { if (self === undefined) { return default_; } return self; } -export function unwrapOr$11c0we2(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { +export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -30,93 +30,93 @@ export function unwrapOrDefault$165pyh5(self: string | undefined): string { return self; } -export function unwrapOrDefault$0wx44sw(self: rt.ByteVec | undefined): rt.ByteVec { +export function unwrapOrDefault$0w012ed(self: rs.ByteVec | undefined): rs.ByteVec { if (self === undefined) { - return new rt.ByteVec(); + return new rs.ByteVec(); } return self; } -export function map$1k7m6zz(self: [rt.u8, rt.u8] | undefined, f: (a0: [rt.u8, rt.u8]) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$0cwxh6b(self: [rs.u8, rs.u8] | undefined, f: (a0: [rs.u8, rs.u8]) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1fmzefe(self: rt.u8 | undefined, f: (a0: rt.u8) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$1pv2dfs(self: rs.u8 | undefined, f: (a0: rs.u8) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0cs071d(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8): rt.u8 | undefined { +export function map$1yjmt5m(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1xztl8h(self: rt.u8 | undefined | rt.None, default_: rt.u8, f: (a0: rt.u8 | undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$1rg5gkk(self: rs.u8 | undefined | rs.None, default_: rs.u8, f: (a0: rs.u8 | undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(self); } -export function mapOr$0lcrgk1(self: string | undefined, default_: rt.u8, f: (a0: string) => rt.u8): rt.u8 { +export function mapOr$1nyk1yj(self: string | undefined, default_: rs.u8, f: (a0: string) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1giiemz(self: rt.Place | undefined, default_: rt.u32, f: (a0: rt.Place) => rt.u32): rt.u32 { +export function mapOr$1ldmp8y(self: rs.Place | undefined, default_: rs.u32, f: (a0: rs.Place) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0mmpeqx(self: [rt.u8, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1h9hu6n(self: [rs.u8, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.u8, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1m2xzon(self: rt.u8 | undefined, default_: boolean, f: (a0: rt.u8) => boolean): boolean { +export function mapOr$0rvzdvd(self: rs.u8 | undefined, default_: boolean, f: (a0: rs.u8) => boolean): boolean { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function andThen$101gy6h(self: rt.Place | undefined, f: (a0: rt.Place) => rt.Place | undefined): rt.Place | undefined { +export function andThen$1x5wmg5(self: rs.Place | undefined, f: (a0: rs.Place) => rs.Place | undefined): rs.Place | undefined { if (self === undefined) { return undefined; } return f(self); } -export function filter$033ccod(self: [rt.u8, rt.u8] | undefined, predicate: (a0: [rt.u8, rt.u8]) => boolean): [rt.u8, rt.u8] | undefined { +export function filter$00vpwuf(self: [rs.u8, rs.u8] | undefined, predicate: (a0: [rs.u8, rs.u8]) => boolean): [rs.u8, rs.u8] | undefined { if (self !== undefined) { - const x: [rt.u8, rt.u8] = self; + const x: [rs.u8, rs.u8] = self; if (predicate(x)) { return x; } @@ -124,7 +124,7 @@ export function filter$033ccod(self: [rt.u8, rt.u8] | undefined, predicate: (a0: return undefined; } -export function or$1loyskh(self: rt.u8 | undefined, optb: rt.u8 | undefined): rt.u8 | undefined { +export function or$0ar58vy(self: rs.u8 | undefined, optb: rs.u8 | undefined): rs.u8 | undefined { if (self === undefined) { return optb; } diff --git a/ts/fixtures/lang/refs/expected/core/result.ts b/ts/fixtures/lang/refs/expected/core/result.ts index 4708e9536..86a1240af 100644 --- a/ts/fixtures/lang/refs/expected/core/result.ts +++ b/ts/fixtures/lang/refs/expected/core/result.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function err$1nqzzwu(self: rt.Result): rt.u8 | undefined { +export function err$1igyjfc(self: rs.Result): rs.u8 | undefined { if (self.ok) { return undefined; } return self.error; } -export function asRef$0ssaoss(self: rt.Result): rt.Result { +export function asRef$1pwjn59(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/refs/expected/harness.ts b/ts/fixtures/lang/refs/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/refs/expected/harness.ts +++ b/ts/fixtures/lang/refs/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/refs/expected/lib.ts b/ts/fixtures/lang/refs/expected/lib.ts index 869c996b2..2375952c4 100644 --- a/ts/fixtures/lang/refs/expected/lib.ts +++ b/ts/fixtures/lang/refs/expected/lib.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { refs, toRefs, adapted, compared } from "./refs.ts"; -export function copy$Option_tuple2_u8_u8(v: [rt.u8, rt.u8] | undefined): [rt.u8, rt.u8] | undefined { +export function copy$Option_tuple2_u8_u8(v: [rs.u8, rs.u8] | undefined): [rs.u8, rs.u8] | undefined { return v === undefined ? v : copy$tuple2_u8_u8(v); } -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } @@ -21,16 +21,16 @@ export const out$u8: { err: unknown } = { err: undefined }; * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["refs::refs", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["refs::refs", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { refs(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::to_refs", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["refs::to_refs", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { toRefs(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::adapted", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["refs::adapted", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { adapted(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["refs::compared", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { compared(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/refs/expected/refs.Counts.ts b/ts/fixtures/lang/refs/expected/refs.Counts.ts index ac3e8ae5a..0efd46248 100644 --- a/ts/fixtures/lang/refs/expected/refs.Counts.ts +++ b/ts/fixtures/lang/refs/expected/refs.Counts.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Counts { - hits: rt.usize; - misses: rt.usize; + hits: rs.usize; + misses: rs.usize; } /** A `&mut` returned to one of two fields, as moq-net's `count` returns one. */ -export function count(self: Counts, hit: boolean): rt.Place { +export function count(self: Counts, hit: boolean): rs.Place { if (!hit) { - return rt.place(() => self.misses, (value2) => self.misses = value2); + return rs.place(() => self.misses, (value2) => self.misses = value2); } - return rt.place(() => self.hits, (value) => self.hits = value); + return rs.place(() => self.hits, (value) => self.hits = value); } //# sourceMappingURL=refs.Counts.ts.map diff --git a/ts/fixtures/lang/refs/expected/refs.Cursor.ts b/ts/fixtures/lang/refs/expected/refs.Cursor.ts index b5fc4892d..c46275617 100644 --- a/ts/fixtures/lang/refs/expected/refs.Cursor.ts +++ b/ts/fixtures/lang/refs/expected/refs.Cursor.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct that keeps a `&mut` to its position. */ export interface Cursor { - at: rt.Place; + at: rs.Place; dataData: Uint8Array; dataStart: number; dataLen: number; } -export function next(self: Cursor): rt.u8 | undefined { - const _3: rt.u8 | undefined = rt.byteSliceGet(new rt.ByteSlice(self.dataData, self.dataStart, self.dataLen), self.at.v); +export function next(self: Cursor): rs.u8 | undefined { + const _3: rs.u8 | undefined = rs.byteSliceGet(new rs.ByteSlice(self.dataData, self.dataStart, self.dataLen), self.at.v); if (_3 !== undefined) { - self.at.v = rt.usizeAdd(self.at.v, 1); + self.at.v = rs.usizeAdd(self.at.v, 1); return _3; } return undefined; diff --git a/ts/fixtures/lang/refs/expected/refs.Fetch.ts b/ts/fixtures/lang/refs/expected/refs.Fetch.ts index 7f6ff2c99..e2c745afc 100644 --- a/ts/fixtures/lang/refs/expected/refs.Fetch.ts +++ b/ts/fixtures/lang/refs/expected/refs.Fetch.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export type Fetch = { tag: "Idle" } | { tag: "Pending"; _0: rt.u8 } | { tag: "Refused" }; +export type Fetch = { tag: "Idle" } | { tag: "Pending"; _0: rs.u8 } | { tag: "Refused" }; //# sourceMappingURL=refs.Fetch.ts.map diff --git a/ts/fixtures/lang/refs/expected/refs.Listing.ts b/ts/fixtures/lang/refs/expected/refs.Listing.ts index 180045df0..5454dfe64 100644 --- a/ts/fixtures/lang/refs/expected/refs.Listing.ts +++ b/ts/fixtures/lang/refs/expected/refs.Listing.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Listing { - return { source: undefined, listed: new rt.ByteVec(), stale: new rt.ByteVec() }; + return { source: undefined, listed: new rs.ByteVec(), stale: new rs.ByteVec() }; } -export function fmt$fmt_Debug(self: Listing, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Listing, f: rs.Formatter): rs.Result { const _3: string = "Listing"; const _4: string = "source"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.source, f, rt.u8Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.source, f, rs.u8Debug); const _7: string = "listed"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.listed), f, rt.u8Debug); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.listed), f, rs.u8Debug); const _10: string = "stale"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.stale), f, rt.u8Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.stale), f, rs.u8Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } /** moq-net's listing: a crate type's default, made in place only while there is none. */ export interface Listing { - source: rt.u8 | undefined; - listed: rt.ByteVec; - stale: rt.ByteVec; + source: rs.u8 | undefined; + listed: rs.ByteVec; + stale: rs.ByteVec; } //# sourceMappingURL=refs.Listing.ts.map diff --git a/ts/fixtures/lang/refs/expected/refs.Pair.ts b/ts/fixtures/lang/refs/expected/refs.Pair.ts index 646860a31..d3a9e7a48 100644 --- a/ts/fixtures/lang/refs/expected/refs.Pair.ts +++ b/ts/fixtures/lang/refs/expected/refs.Pair.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Pair { - n: rt.u8; + n: rs.u8; } -export function tally$refs_Tally(self: Pair, n: rt.u8): void { - self.n = rt.u8WrappingAdd(self.n, n); +export function tally$refs_Tally(self: Pair, n: rs.u8): void { + self.n = rs.u8WrappingAdd(self.n, n); } -export function total$refs_Tally(self: Pair): rt.u32 { - return self.n as rt.u32; +export function total$refs_Tally(self: Pair): rs.u32 { + return self.n as rs.u32; } -export function tally$refs_Tally_mut(self: rt.Place, n: rt.u8): void { +export function tally$refs_Tally_mut(self: rs.Place, n: rs.u8): void { tally$refs_Tally(self.v, n); } -export function total$refs_Tally_mut(self: Pair): rt.u32 { +export function total$refs_Tally_mut(self: Pair): rs.u32 { return total$refs_Tally(self); } -export function total$refs_Tally_mut_mut(self: rt.Place): rt.u32 { +export function total$refs_Tally_mut_mut(self: rs.Place): rs.u32 { return total$refs_Tally_mut(self.v); } diff --git a/ts/fixtures/lang/refs/expected/refs.Pair2.ts b/ts/fixtures/lang/refs/expected/refs.Pair2.ts index 7f88821b4..25dca5e66 100644 --- a/ts/fixtures/lang/refs/expected/refs.Pair2.ts +++ b/ts/fixtures/lang/refs/expected/refs.Pair2.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Pair2 { - a: rt.u32 | undefined; - b: rt.u32 | undefined; + a: rs.u32 | undefined; + b: rs.u32 | undefined; } //# sourceMappingURL=refs.Pair2.ts.map diff --git a/ts/fixtures/lang/refs/expected/refs.Reader.ts b/ts/fixtures/lang/refs/expected/refs.Reader.ts index bc458ed43..e5f713a71 100644 --- a/ts/fixtures/lang/refs/expected/refs.Reader.ts +++ b/ts/fixtures/lang/refs/expected/refs.Reader.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A reader keeping a `&mut` to the slice it reads, which it lends on. */ export interface Reader { - rest: rt.Place; + rest: rs.Place; } -export function rest(self: Reader): rt.Place { +export function rest(self: Reader): rs.Place { return self.rest; } diff --git a/ts/fixtures/lang/refs/expected/refs.ts b/ts/fixtures/lang/refs/expected/refs.ts index 2d90bba76..a88411c1e 100644 --- a/ts/fixtures/lang/refs/expected/refs.ts +++ b/ts/fixtures/lang/refs/expected/refs.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_tuple2_u8_u8, copy$array_u32, out$u8 } from "./lib.ts"; -import { thenSome$0xksuo2, then$0ozmvid } from "./core/bool.ts"; -import { unwrapOr$0x6fy3l as option_unwrapOr$0x6fy3l, unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0wx44sw as option_unwrapOrDefault$0wx44sw, map$1k7m6zz as option_map$1k7m6zz, map$1fmzefe as option_map$1fmzefe, map$0cs071d as option_map$0cs071d, mapOr$1xztl8h as option_mapOr$1xztl8h, mapOr$0lcrgk1 as option_mapOr$0lcrgk1, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$1giiemz as option_mapOr$1giiemz, mapOr$0mmpeqx as option_mapOr$0mmpeqx, mapOr$1m2xzon as option_mapOr$1m2xzon, mapOr$1surhce as option_mapOr$1surhce, andThen$101gy6h as option_andThen$101gy6h, filter$033ccod, or$1loyskh as option_or$1loyskh } from "./core/option.ts"; -import { err$1nqzzwu, asRef$0ssaoss } from "./core/result.ts"; +import { thenSome$1c6ozzd, then$17csa2h } from "./core/bool.ts"; +import { unwrapOr$0w1py1w as option_unwrapOr$0w1py1w, unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$165pyh5 as option_unwrapOrDefault$165pyh5, unwrapOrDefault$0w012ed as option_unwrapOrDefault$0w012ed, map$0cwxh6b as option_map$0cwxh6b, map$1pv2dfs as option_map$1pv2dfs, map$1yjmt5m as option_map$1yjmt5m, mapOr$1rg5gkk as option_mapOr$1rg5gkk, mapOr$1nyk1yj as option_mapOr$1nyk1yj, mapOr$14runhi as option_mapOr$14runhi, mapOr$1ldmp8y as option_mapOr$1ldmp8y, mapOr$1h9hu6n as option_mapOr$1h9hu6n, mapOr$0rvzdvd as option_mapOr$0rvzdvd, mapOr$0vxw5sq as option_mapOr$0vxw5sq, andThen$1x5wmg5 as option_andThen$1x5wmg5, filter$00vpwuf, or$0ar58vy as option_or$0ar58vy } from "./core/option.ts"; +import { err$1igyjfc, asRef$1pwjn59 } from "./core/result.ts"; import * as Counts from "./refs.Counts.ts"; import * as Cursor from "./refs.Cursor.ts"; import type * as Fetch from "./refs.Fetch.ts"; @@ -15,31 +15,31 @@ import * as Pair from "./refs.Pair.ts"; import type * as Pair2 from "./refs.Pair2.ts"; import * as Reader from "./refs.Reader.ts"; -export function bump(x: rt.Place, by: rt.u8): void { - x.v = rt.u32Add(x.v, by as rt.u32); +export function bump(x: rs.Place, by: rs.u8): void { + x.v = rs.u32Add(x.v, by as rs.u32); } /** A parameter passed on twice, and once from a closure that captures it. */ -export function bumpThrice(x: rt.Place, by: rt.u8): void { +export function bumpThrice(x: rs.Place, by: rs.u8): void { bump(x, by); bump(x, 1); - ((n: rt.u8): undefined => { + ((n: rs.u8): undefined => { bump(x, n); })(by); } /** Over 2^53, where the runtime switches a `u64` to limbs. */ -export function shiftWide(x: rt.Place, by: rt.u8): void { - x.v = rt.u64WrappingAdd(rt.u64WrappingAdd(x.v, { hi: 0x200000, lo: 0 } as rt.u64), by as rt.u64); +export function shiftWide(x: rs.Place, by: rs.u8): void { + x.v = rs.u64WrappingAdd(rs.u64WrappingAdd(x.v, { hi: 0x200000, lo: 0 } as rs.u64), by as rs.u64); } /** moq-net's cache shape: the largest seen so far, read, replaced, and taken. */ -export function takeLargest(seen: rt.Place, next: rt.u8): rt.u8 | undefined { - if (!option_mapOr$1m2xzon(seen.v, true, (s: rt.u8): boolean => { +export function takeLargest(seen: rs.Place, next: rs.u8): rs.u8 | undefined { + if (!option_mapOr$0rvzdvd(seen.v, true, (s: rs.u8): boolean => { return next > s; })) { if (seen.v !== undefined) { - seen.v = rt.u8WrappingAdd(seen.v, 1); + seen.v = rs.u8WrappingAdd(seen.v, 1); } if (!(next === 0)) { return undefined; @@ -54,51 +54,51 @@ export function takeLargest(seen: rt.Place, next: rt.u8): rt. } /** A name replaced through a parameter, its old one returned. */ -export function rename(name: rt.Place, b: rt.u8): string | undefined { - const _5: rt.char = rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char; - const _3: string = rt.fmtToString((f: rt.Formatter) => rt.fmtCharDisplay(_5, f)); +export function rename(name: rs.Place, b: rs.u8): string | undefined { + const _5: rs.char = rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char; + const _3: string = rs.fmtToString((f: rs.Formatter) => rs.fmtCharDisplay(_5, f)); const old = name.v; name.v = _3; return old; } /** A `&mut Option` passed on from inside a closure std calls. */ -export function largestOf(seen: rt.Place, items: rt.ByteSlice): rt.u8 { - let taken: rt.u8 = 0; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(items)), (_2: rt.u8): undefined => { +export function largestOf(seen: rs.Place, items: rs.ByteSlice): rs.u8 { + let taken: rs.u8 = 0; + rs.iterForEach(rs.iterSlice(rs.byteSliceView(items)), (_2: rs.u8): undefined => { if (takeLargest(seen, _2) !== undefined) { - taken = rt.u8WrappingAdd(taken, 1); + taken = rs.u8WrappingAdd(taken, 1); } }); return taken; } /** moq-net's `&mut Box`: changed through, and replaced whole. */ -export function rebox(b: rt.Place, by: rt.u8): void { - const _3: rt.u8 = rt.u8WrappingAdd(b.v.n, by); +export function rebox(b: rs.Place, by: rs.u8): void { + const _3: rs.u8 = rs.u8WrappingAdd(b.v.n, by); b.v.n = _3; - if (rt.u8Rem(by, 2) === 0) { - b.v = { n: rt.u8WrappingAdd(b.v.n, b.v.n) }; + if (rs.u8Rem(by, 2) === 0) { + b.v = { n: rs.u8WrappingAdd(b.v.n, b.v.n) }; } } -export function swapPair(p: [rt.u8, rt.u8]): void { +export function swapPair(p: [rs.u8, rs.u8]): void { const swapped = p[0]; p[0] = p[1]; p[1] = swapped; - p[1] = rt.u8WrappingAdd(p[1], 1); - if (rt.u8Rem(p[0], 3) === 0) { - Object.assign(p, [p[1], p[0]] as [rt.u8, rt.u8]); + p[1] = rs.u8WrappingAdd(p[1], 1); + if (rs.u8Rem(p[0], 3) === 0) { + Object.assign(p, [p[1], p[0]] as [rs.u8, rs.u8]); } } -export function refuse(f: rt.Place): void { +export function refuse(f: rs.Place): void { let _2!: Fetch.Fetch; if (f.v.tag === "Idle") { _2 = { tag: "Pending", _0: 1 } as Fetch.Fetch; } else if (f.v.tag === "Pending") { if (!(f.v._0 > 2)) { - _2 = { tag: "Pending", _0: rt.u8Add(f.v._0, 1) } as Fetch.Fetch; + _2 = { tag: "Pending", _0: rs.u8Add(f.v._0, 1) } as Fetch.Fetch; } else { _2 = { tag: "Refused" } as Fetch.Fetch; } @@ -108,15 +108,15 @@ export function refuse(f: rt.Place): void { f.v = _2; } -export function pushTo(s: rt.Place, c: rt.char): void { +export function pushTo(s: rs.Place, c: rs.char): void { s.v = s.v + String.fromCodePoint(c); if (c === 122) { const taken = s.v; s.v = ""; - const iter: rt.Iter = rt.iterTake(rt.strChars(taken), 2); + const iter: rs.Iter = rs.iterTake(rs.strChars(taken), 2); while (true) { - const _12: rt.char | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: rs.char | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } s.v = s.v + String.fromCodePoint(_12); @@ -124,19 +124,19 @@ export function pushTo(s: rt.Place, c: rt.char): void { } } -export function skip(remaining: rt.Place, data: rt.ByteSlice): rt.usize { - let skipped: rt.usize = 0; - const iterS: Uint8Array = rt.byteSliceView(data); +export function skip(remaining: rs.Place, data: rs.ByteSlice): rs.usize { + let skipped: rs.usize = 0; + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _6: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_6 === rt.DONE) { + const _6: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_6 === rs.DONE) { return skipped; } - const b: rt.u8 = _6; + const b: rs.u8 = _6; if (!(remaining.v === 0)) { - remaining.v = rt.usizeSub(remaining.v, 1); - skipped = rt.usizeAdd(skipped, rt.u8Rem(b, 2) as rt.usize); + remaining.v = rs.usizeSub(remaining.v, 1); + skipped = rs.usizeAdd(skipped, rs.u8Rem(b, 2) as rs.usize); } else { return skipped; } @@ -147,118 +147,118 @@ export function skip(remaining: rt.Place, data: rt.ByteSlice): rt.usiz * Places std reads through: its impls for references compare, order, and format what * they point at. */ -export function readThrough(a: rt.Place, b: rt.Place, out: rt.ByteVec): void { - rt.byteVecPush(out, a.v === b.v ? 1 : 0); - rt.byteVecPush(out, a.v < b.v ? 1 : 0); - rt.byteVecPush(out, rt.cmp(a.v, b.v) & 0xff); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(a.v, f), (f: rt.Formatter) => rt.u32Debug(b.v, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], "|", args2[1]]))); +export function readThrough(a: rs.Place, b: rs.Place, out: rs.ByteVec): void { + rs.byteVecPush(out, a.v === b.v ? 1 : 0); + rs.byteVecPush(out, a.v < b.v ? 1 : 0); + rs.byteVecPush(out, rs.cmp(a.v, b.v) & 0xff); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a.v, f), (f: rs.Formatter) => rs.u32Debug(b.v, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], "|", args2[1]]))); } /** A `&mut Box` dereferenced through `DerefMut`, as generic code over it would. */ -export function derefBox(b: rt.Place, to: rt.u8): void { +export function derefBox(b: rs.Place, to: rs.u8): void { b.v = to; } /** Methods that take `&self`, called through a `&mut`. */ -export function fill(seen: rt.Place, s: rt.Place, next: rt.u8): rt.u8 { +export function fill(seen: rs.Place, s: rs.Place, next: rs.u8): rs.u8 { if (seen.v === undefined) { seen.v = next; } - return rt.u8WrappingAdd(option_unwrapOr$0r2bmpr(seen.v, 238), rt.stringLen(s.v) & 0xff); + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(seen.v, 238), rs.stringLen(s.v) & 0xff); } -export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { - let _170!: rt.u8; - const _117: (a0: rt.u8 | undefined | rt.None) => rt.u8 = (o: rt.u8 | undefined | rt.None): rt.u8 => { - return option_mapOr$1xztl8h(o, 221, (o2: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(o2, 238); +export function refs(data: rs.ByteSlice, out: rs.ByteVec): void { + let _170!: rs.u8; + const _117: (a0: rs.u8 | undefined | rs.None) => rs.u8 = (o: rs.u8 | undefined | rs.None): rs.u8 => { + return option_mapOr$1rg5gkk(o, 221, (o2: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(o2, 238); }); }; - const _275: (a0: rt.Place, a1: rt.u8) => undefined = (x3: rt.Place, b8: rt.u8): undefined => { + const _275: (a0: rs.Place, a1: rs.u8) => undefined = (x3: rs.Place, b8: rs.u8): undefined => { bump(x3, b8); }; - const by: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 3); - let local: rt.u32 = 7; - bumpThrice(rt.place(() => local, (value) => local = value), by); + const by: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 3); + let local: rs.u32 = 7; + bumpThrice(rs.place(() => local, (value) => local = value), by); const counts: Counts.Counts = { hits: 0, misses: 0 }; - const held: rt.u32[] = [1, 2, 3]; - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; + const held: rs.u32[] = [1, 2, 3]; + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; }), undefined, 4, true); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _18: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } - const i: rt.usize = _18[0]; - const b: rt.u8 = _18[1]; - const _23: rt.Place = Counts.count(counts, rt.u8Rem(b, 3) === 0); - _23.v = rt.usizeAdd(_23.v, 1); - bumpSlot(Counts.count(counts, rt.u8Rem(b, 2) === 0), b); - const _37: rt.usize = rt.usizeRem(i, 3); + const i: rs.usize = _18[0]; + const b: rs.u8 = _18[1]; + const _23: rs.Place = Counts.count(counts, rs.u8Rem(b, 3) === 0); + _23.v = rs.usizeAdd(_23.v, 1); + bumpSlot(Counts.count(counts, rs.u8Rem(b, 2) === 0), b); + const _37: rs.usize = rs.usizeRem(i, 3); if (!(_37 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _37); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _37); } - bump(rt.place(() => held[_37], (value2) => held[_37] = value2), b); - const at2 = rt.idx(v.items, i); - bump(rt.place(() => v.items[at2], (value3) => v.items[at2] = value3), 1); + bump(rs.place(() => held[_37], (value2) => held[_37] = value2), b); + const at2 = rs.idx(v.items, i); + bump(rs.place(() => v.items[at2], (value3) => v.items[at2] = value3), 1); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(local))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(counts.hits as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(counts.misses as rt.u32))); - const iter2: rt.Iter = rt.iterChain(rt.iterSlice(held), rt.iterSlice(v.items)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(local))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(counts.hits as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(counts.misses as rs.u32))); + const iter2: rs.Iter = rs.iterChain(rs.iterSlice(held), rs.iterSlice(v.items)); while (true) { - const _67: rt.u32 | rt.Done = iter2.next(); - if (_67 === rt.DONE) { + const _67: rs.u32 | rs.Done = iter2.next(); + if (_67 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_67))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_67))); } - let wide: rt.u64 = { hi: 0xffffffff, lo: 0xfffffffc } as rt.u64; - shiftWide(rt.place(() => wide, (value4) => wide = value4), by); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(wide))); - let seen: rt.u8 | undefined = undefined; - rt.byteVecPush(out, largestOf(rt.place(() => seen, (value5) => seen = value5), data)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(seen, 238)); - let slot: rt.u8 | undefined = by; + let wide: rs.u64 = { hi: 0xffffffff, lo: 0xfffffffc } as rs.u64; + shiftWide(rs.place(() => wide, (value4) => wide = value4), by); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(wide))); + let seen: rs.u8 | undefined = undefined; + rs.byteVecPush(out, largestOf(rs.place(() => seen, (value5) => seen = value5), data)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(seen, 238)); + let slot: rs.u8 | undefined = by; if (slot !== undefined) { - bumpByte(rt.place(() => slot as rt.u8, (value6) => slot = value6)); + bumpByte(rs.place(() => slot as rs.u8, (value6) => slot = value6)); } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(slot, 238)); - let last = undefined as rt.u8 | undefined; + rs.byteVecPush(out, option_unwrapOr$1fr498u(slot, 238)); + let last = undefined as rs.u8 | undefined; let name: string | undefined = undefined; - for (const b2 of rt.byteSliceView(data)) { + for (const b2 of rs.byteSliceView(data)) { const old = last; last = b2; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(old, 238)); - rt.byteVecPush(out, option_mapOr$0lcrgk1(rename(rt.place(() => name, (value7) => name = value7), b2), 238, (n2: string): rt.u8 => { - const _3: rt.ByteSlice = rt.stringAsBytes(n2); - rt.idx(_3, 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(old, 238)); + rs.byteVecPush(out, option_mapOr$1nyk1yj(rename(rs.place(() => name, (value7) => name = value7), b2), 238, (n2: string): rs.u8 => { + const _3: rs.ByteSlice = rs.stringAsBytes(n2); + rs.idx(_3, 0); return _3.data[_3.start]; })); } - let nested = rt.None as rt.u8 | undefined | rt.None; - const old2: rt.u8 | undefined | rt.None = nested; + let nested = rs.None as rs.u8 | undefined | rs.None; + const old2: rs.u8 | undefined | rs.None = nested; nested = by; - rt.byteVecPush(out, _117(old2)); - const old3: rt.u8 | undefined | rt.None = nested; - nested = undefined as rt.u8 | undefined; - rt.byteVecPush(out, _117(old3)); - rt.byteVecPush(out, _117(nested)); + rs.byteVecPush(out, _117(old2)); + const old3: rs.u8 | undefined | rs.None = nested; + nested = undefined as rs.u8 | undefined; + rs.byteVecPush(out, _117(old3)); + rs.byteVecPush(out, _117(nested)); let boxed: Pair.Pair = { n: by }; - const pair: [rt.u8, rt.u8] = [by, rt.u8WrappingAdd(by, 1)]; + const pair: [rs.u8, rs.u8] = [by, rs.u8WrappingAdd(by, 1)]; let fetch = { tag: "Idle" } as Fetch.Fetch; let text: string = ""; - for (const b3 of rt.byteSliceView(data)) { - rebox(rt.place(() => boxed, (value8) => boxed = value8), b3); + for (const b3 of rs.byteSliceView(data)) { + rebox(rs.place(() => boxed, (value8) => boxed = value8), b3); swapPair(pair); - refuse(rt.place(() => fetch, (value9) => fetch = value9)); - const _157: rt.char = rt.u8Add(97, rt.u8Rem(b3, 26)) as rt.char; - pushTo(rt.place(() => text, (value10) => text = value10), _157); + refuse(rs.place(() => fetch, (value9) => fetch = value9)); + const _157: rs.char = rs.u8Add(97, rs.u8Rem(b3, 26)) as rs.char; + pushTo(rs.place(() => text, (value10) => text = value10), _157); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed.n, pair[0], pair[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed.n, pair[0], pair[1]))); if (fetch.tag === "Idle") { _170 = 0; } else if (fetch.tag === "Pending") { @@ -266,20 +266,20 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _170 = 255; } - rt.byteVecPush(out, _170); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); - let empty: rt.u8 | undefined = undefined; - rt.byteVecPush(out, fill(rt.place(() => empty, (value11) => empty = value11), rt.place(() => text, (value12) => text = value12), by)); - const _185: rt.u8 = rt.u8WrappingAdd(by, 1); - rt.byteVecPush(out, fill(rt.place(() => empty, (value13) => empty = value13), rt.place(() => text, (value14) => text = value14), _185)); - let at: rt.usize = 0; - const cursor: Cursor.Cursor = { at: rt.place(() => at, (value15) => at = value15), dataData: data.data, dataStart: data.start, dataLen: data.length }; - let sum: rt.u8 = 0; + rs.byteVecPush(out, _170); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); + let empty: rs.u8 | undefined = undefined; + rs.byteVecPush(out, fill(rs.place(() => empty, (value11) => empty = value11), rs.place(() => text, (value12) => text = value12), by)); + const _185: rs.u8 = rs.u8WrappingAdd(by, 1); + rs.byteVecPush(out, fill(rs.place(() => empty, (value13) => empty = value13), rs.place(() => text, (value14) => text = value14), _185)); + let at: rs.usize = 0; + const cursor: Cursor.Cursor = { at: rs.place(() => at, (value15) => at = value15), dataData: data.data, dataStart: data.start, dataLen: data.length }; + let sum: rs.u8 = 0; while (true) { - const _190: rt.u8 | undefined = Cursor.next(cursor); + const _190: rs.u8 | undefined = Cursor.next(cursor); if (_190 !== undefined) { - const b4: rt.u8 = _190; - sum = rt.u8WrappingAdd(sum, b4); + const b4: rs.u8 = _190; + sum = rs.u8WrappingAdd(sum, b4); if (b4 > 200) { break; } @@ -287,59 +287,59 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecPush(out, sum); - rt.byteVecPush(out, at & 0xff); - let remaining: rt.usize = rt.u8Rem(by, 5) as rt.usize; - rt.byteVecPush(out, skip(rt.place(() => remaining, (value16) => remaining = value16), data) & 0xff); - rt.byteVecPush(out, remaining & 0xff); + rs.byteVecPush(out, sum); + rs.byteVecPush(out, at & 0xff); + let remaining: rs.usize = rs.u8Rem(by, 5) as rs.usize; + rs.byteVecPush(out, skip(rs.place(() => remaining, (value16) => remaining = value16), data) & 0xff); + rs.byteVecPush(out, remaining & 0xff); const _214: [Pair.Pair, Pair.Pair] = [{ n: 1 }, { n: 2 }]; const a: Pair.Pair = _214[0]; const b5: Pair.Pair = _214[1]; let p: Pair.Pair = a; const borrowed = p; - const r: rt.Place = rt.place(() => borrowed.n, (value17) => borrowed.n = value17); + const r: rs.Place = rs.place(() => borrowed.n, (value17) => borrowed.n = value17); p = b5; bumpByte(r); - p.n = rt.u8Add(p.n, 10); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.n, b5.n))); - const hash: rt.HashMap = rt.hashNew() as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - for (const b6 of rt.byteSliceView(data)) { - bump(rt.entryOrInsertMut(rt.entry(hash, rt.u8Rem(b6, 4)), 0), b6); - bump(rt.entryOrInsertWithMut(rt.entry(tree, rt.u8Rem(b6, 3)), (): rt.u32 => { + p.n = rs.u8Add(p.n, 10); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.n, b5.n))); + const hash: rs.HashMap = rs.hashNew() as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + for (const b6 of rs.byteSliceView(data)) { + bump(rs.entryOrInsertMut(rs.entry(hash, rs.u8Rem(b6, 4)), 0), b6); + bump(rs.entryOrInsertWithMut(rs.entry(tree, rs.u8Rem(b6, 3)), (): rs.u32 => { return 0; }), 1); - const _248: rt.Place | undefined = rt.hashGetMut(hash, rt.u8Rem(b6, 2)); + const _248: rs.Place | undefined = rs.hashGetMut(hash, rs.u8Rem(b6, 2)); if (_248 !== undefined) { bump(_248, 2); } } - const _257: rt.Iter<[rt.u8, rt.u32]> = rt.hashIter(hash); - const iter6: rt.Iter<[rt.u8, rt.u32]> = rt.iterChain(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _257, true, undefined, undefined, "next", 8)), rt.btreeIter(tree)); + const _257: rs.Iter<[rs.u8, rs.u32]> = rs.hashIter(hash); + const iter6: rs.Iter<[rs.u8, rs.u32]> = rs.iterChain(rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _257, true, undefined, undefined, "next", 8)), rs.btreeIter(tree)); while (true) { - const _264: [rt.u8, rt.u32] | rt.Done = iter6.next(); - if (_264 === rt.DONE) { + const _264: [rs.u8, rs.u32] | rs.Done = iter6.next(); + if (_264 === rs.DONE) { break; } - const k: rt.u8 = _264[0]; - const x: rt.u32 = _264[1]; - rt.byteVecPush(out, k); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x))); - } - let total: rt.u32 = 0; - for (const b7 of rt.byteSliceView(data)) { - _275(rt.place(() => total, (value18) => total = value18), b7); - } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(total))); - const _293: [rt.u32, rt.u32] = [by as rt.u32, option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 5) as rt.u32]; - let x2: rt.u32 = _293[0]; - let y: rt.u32 = _293[1]; - readThrough(rt.place(() => x2, (value19) => x2 = value19), rt.place(() => y, (value20) => y = value20), out); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x2 & 0xff, y & 0xff))); - let boxed2: rt.u8 | undefined = undefined as rt.u8 | undefined; - const _314: rt.u8 = total & 0xff; - derefBox(rt.place(() => boxed2, (value21) => boxed2 = value21), _314); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(boxed2, 238)); + const k: rs.u8 = _264[0]; + const x: rs.u32 = _264[1]; + rs.byteVecPush(out, k); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x))); + } + let total: rs.u32 = 0; + for (const b7 of rs.byteSliceView(data)) { + _275(rs.place(() => total, (value18) => total = value18), b7); + } + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(total))); + const _293: [rs.u32, rs.u32] = [by as rs.u32, option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 5) as rs.u32]; + let x2: rs.u32 = _293[0]; + let y: rs.u32 = _293[1]; + readThrough(rs.place(() => x2, (value19) => x2 = value19), rs.place(() => y, (value20) => y = value20), out); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x2 & 0xff, y & 0xff))); + let boxed2: rs.u8 | undefined = undefined as rs.u8 | undefined; + const _314: rs.u8 = total & 0xff; + derefBox(rs.place(() => boxed2, (value21) => boxed2 = value21), _314); + rs.byteVecPush(out, option_unwrapOr$1fr498u(boxed2, 238)); lent(data, out); } @@ -347,143 +347,143 @@ export function refs(data: rt.ByteSlice, out: rt.ByteVec): void { * What std lends of an `Option` a `&mut` borrows: its payload, written through in place, * passed on, and kept. */ -export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { - let at!: rt.Place; - let seen: rt.u32 | undefined = undefined; - let last = undefined as [rt.u8, rt.u8] | undefined; +export function lent(data: rs.ByteSlice, out: rs.ByteVec): void { + let at!: rs.Place; + let seen: rs.u32 | undefined = undefined; + let last = undefined as [rs.u8, rs.u8] | undefined; let text = undefined as string | undefined; - const held: rt.Vec> = new rt.Vec(); - const spare: Array = [undefined, 9]; - for (const b of rt.byteSliceView(data)) { - const _17: rt.u8 = rt.u8Rem(b, 6); + const held: rs.Vec> = new rs.Vec(); + const spare: Array = [undefined, 9]; + for (const b of rs.byteSliceView(data)) { + const _17: rs.u8 = rs.u8Rem(b, 6); if (_17 === 0) { - const _20: rt.Place = rt.place(() => seen, (value7) => seen = value7); - const _21: rt.u32 = b as rt.u32; + const _20: rs.Place = rs.place(() => seen, (value7) => seen = value7); + const _21: rs.u32 = b as rs.u32; if (_20.v === undefined) { _20.v = _21; } - _20.v = rt.u32Add(_20.v as rt.u32, 1); + _20.v = rs.u32Add(_20.v as rs.u32, 1); } else if (_17 === 1) { - const _24: rt.Place = rt.place(() => seen, (value5) => seen = value5); - const _25: () => rt.u32 = (): rt.u32 => { - return rt.u32Mul(b as rt.u32, 2); + const _24: rs.Place = rs.place(() => seen, (value5) => seen = value5); + const _25: () => rs.u32 = (): rs.u32 => { + return rs.u32Mul(b as rs.u32, 2); }; if (_24.v === undefined) { _24.v = _25(); } - bump(rt.place(() => _24.v as rt.u32, (value6) => (_24.v as rt.u32) = value6), b); + bump(rs.place(() => _24.v as rs.u32, (value6) => (_24.v as rs.u32) = value6), b); } else if (_17 === 2) { - const _27: rt.u32 = b as rt.u32; - const _29: rt.Place = rt.place(() => seen, (value4) => seen = value4); + const _27: rs.u32 = b as rs.u32; + const _29: rs.Place = rs.place(() => seen, (value4) => seen = value4); if (_29.v === undefined) { _29.v = 0; } - _29.v = rt.u32Add(_29.v as rt.u32, _27); + _29.v = rs.u32Add(_29.v as rs.u32, _27); } else if (_17 === 3) { - const _32: rt.Place = rt.place(() => seen, (value3) => seen = value3); - _32.v = b as rt.u32; - _32.v = rt.u32WrappingAdd(_32.v as rt.u32, _32.v as rt.u32); + const _32: rs.Place = rs.place(() => seen, (value3) => seen = value3); + _32.v = b as rs.u32; + _32.v = rs.u32WrappingAdd(_32.v as rs.u32, _32.v as rs.u32); } else if (_17 === 4) { - const _38: rt.Place = rt.place(() => seen, (value) => seen = value); - const _37: rt.Place | undefined = _38.v === undefined ? undefined : rt.place(() => _38.v as rt.u32, (value2) => _38.v = value2); + const _38: rs.Place = rs.place(() => seen, (value) => seen = value); + const _37: rs.Place | undefined = _38.v === undefined ? undefined : rs.place(() => _38.v as rs.u32, (value2) => _38.v = value2); if (_37 !== undefined) { bump(_37, b); } } else { seen = undefined; } - const _45: [rt.u8, rt.u8] = [b, 0]; + const _45: [rs.u8, rs.u8] = [b, 0]; if (last === undefined) { last = _45; } - (last as [rt.u8, rt.u8])[1] = (last as [rt.u8, rt.u8])[1] ^ b; - const _46: [rt.u8, rt.u8] | undefined = last; + (last as [rs.u8, rs.u8])[1] = (last as [rs.u8, rs.u8])[1] ^ b; + const _46: [rs.u8, rs.u8] | undefined = last; if (_46 !== undefined) { - _46[0] = rt.u8WrappingAdd(_46[0], 1); + _46[0] = rs.u8WrappingAdd(_46[0], 1); } - const _52: [rt.u8, rt.u8] | undefined = option_map$1k7m6zz(filter$033ccod(last, (p: [rt.u8, rt.u8]): boolean => { - return rt.u8Rem(p[0], 2) === 0; - }), (p2: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { - p2[1] = rt.u8WrappingAdd(p2[1], 2); + const _52: [rs.u8, rs.u8] | undefined = option_map$0cwxh6b(filter$00vpwuf(last, (p: [rs.u8, rs.u8]): boolean => { + return rs.u8Rem(p[0], 2) === 0; + }), (p2: [rs.u8, rs.u8]): [rs.u8, rs.u8] => { + p2[1] = rs.u8WrappingAdd(p2[1], 2); return p2; }); if (_52 !== undefined) { _52[0] = _52[0] ^ 1; } - const _61: rt.Place = rt.place(() => seen, (value8) => seen = value8); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_mapOr$1giiemz(option_andThen$101gy6h(_61.v === undefined ? undefined : rt.place(() => _61.v as rt.u32, (value9) => _61.v = value9), (x4: rt.Place): rt.Place | undefined => { - return thenSome$0xksuo2(rt.u32Rem(x4.v, 3) === 0, x4); - }), 0, (x5: rt.Place): rt.u32 => { - x5.v = rt.u32Mul(x5.v, 2); + const _61: rs.Place = rs.place(() => seen, (value8) => seen = value8); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_mapOr$1ldmp8y(option_andThen$1x5wmg5(_61.v === undefined ? undefined : rs.place(() => _61.v as rs.u32, (value9) => _61.v = value9), (x4: rs.Place): rs.Place | undefined => { + return thenSome$1c6ozzd(rs.u32Rem(x4.v, 3) === 0, x4); + }), 0, (x5: rs.Place): rs.u32 => { + x5.v = rs.u32Mul(x5.v, 2); return x5.v; })))); if (text === undefined) { text = ""; } - text = (text as string) + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(seen, 61166)))); + text = (text as string) + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(seen, 61166)))); } - const _82: [rt.u8, rt.u8] = option_unwrapOr$0x6fy3l(last, [238, 238] as [rt.u8, rt.u8]); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_82[0], _82[1]))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(option_unwrapOrDefault$165pyh5(text))); + const _82: [rs.u8, rs.u8] = option_unwrapOr$0w1py1w(last, [238, 238] as [rs.u8, rs.u8]); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_82[0], _82[1]))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(option_unwrapOrDefault$165pyh5(text))); const counts: Pair2.Pair2 = { a: undefined, b: undefined }; - const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const iter2: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _101: [rt.usize, rt.u8] | rt.Done = iter2.next(); - if (_101 === rt.DONE) { + const _101: [rs.usize, rs.u8] | rs.Done = iter2.next(); + if (_101 === rs.DONE) { break; } - const i: rt.usize = _101[0]; - const b2: rt.u8 = _101[1]; - if (rt.usizeRem(i, 2) === 0) { + const i: rs.usize = _101[0]; + const b2: rs.u8 = _101[1]; + if (rs.usizeRem(i, 2) === 0) { if (counts.a === undefined) { counts.a = 0; } const borrowed = counts; - at = rt.place(() => borrowed.a as rt.u32, (value11) => borrowed.a = value11); + at = rs.place(() => borrowed.a as rs.u32, (value11) => borrowed.a = value11); } else { - const f = (): rt.u32 => { + const f = (): rs.u32 => { return 100; }; if (counts.b === undefined) { counts.b = f(); } - at = rt.place(() => counts.b as rt.u32, (value10) => (counts.b as rt.u32) = value10); + at = rs.place(() => counts.b as rs.u32, (value10) => (counts.b as rs.u32) = value10); } - at.v = rt.u32Add(at.v, b2 as rt.u32); - const _117: rt.usize = rt.usizeRem(i, 2); + at.v = rs.u32Add(at.v, b2 as rs.u32); + const _117: rs.usize = rs.usizeRem(i, 2); if (!(_117 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _117); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _117); } if (spare[_117] === undefined) { spare[_117] = 1; } - bump(rt.place(() => spare[_117] as rt.u32, (value12) => (spare[_117] as rt.u32) = value12), b2); + bump(rs.place(() => spare[_117] as rs.u32, (value12) => (spare[_117] as rs.u32) = value12), b2); } - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(spare)); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(spare)); while (true) { - const _126: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_126 === rt.DONE) { + const _126: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_126 === rs.DONE) { break; } - _126[1].v = _126[0] as rt.u32; - held.items.push(rt.place(() => _126[1].v as rt.u32, (value13) => (_126[1].v as rt.u32) = value13)); + _126[1].v = _126[0] as rs.u32; + held.items.push(rs.place(() => _126[1].v as rs.u32, (value13) => (_126[1].v as rs.u32) = value13)); } - const iter4: rt.Iter> = rt.vecIntoIter(held); + const iter4: rs.Iter> = rs.vecIntoIter(held); while (true) { - const _138: rt.Place | rt.Done = iter4.next(); - if (_138 === rt.DONE) { + const _138: rs.Place | rs.Done = iter4.next(); + if (_138 === rs.DONE) { break; } - _138.v = rt.u32Add(_138.v, 7); + _138.v = rs.u32Add(_138.v, 7); } - const iter5: rt.Iter = rt.iterSlice([counts.a, counts.b, spare[0], spare[1]]); + const iter5: rs.Iter = rs.iterSlice([counts.a, counts.b, spare[0], spare[1]]); while (true) { - const _154: rt.u32 | undefined | rt.Done = iter5.next(); - if (_154 === rt.DONE) { + const _154: rs.u32 | undefined | rs.Done = iter5.next(); + if (_154 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(option_unwrapOr$11c0we2(_154, 61166)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(option_unwrapOr$1b5hww3(_154, 61166)))); } defaulted(data, out); taken(data, out); @@ -492,58 +492,58 @@ export function lent(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Filled in place by its default, through a `&mut` and from a closure, then reset. */ -export function defaulted(data: rt.ByteSlice, out: rt.ByteVec): void { +export function defaulted(data: rs.ByteSlice, out: rs.ByteVec): void { let listing: Listing.Listing | undefined = undefined; - for (const b of rt.byteSliceView(data)) { - const _11: rt.u8 = rt.u8Rem(b, 5); + for (const b of rs.byteSliceView(data)) { + const _11: rs.u8 = rs.u8Rem(b, 5); if (_11 === 0) { listing = undefined; } else if (_11 === 1) { - list$defaulted(rt.place(() => listing, (value4) => listing = value4), b); + list$defaulted(rs.place(() => listing, (value4) => listing = value4), b); } else if (_11 === 2) { - const _16: rt.Place = rt.place(() => listing, (value3) => listing = value3); + const _16: rs.Place = rs.place(() => listing, (value3) => listing = value3); if (_16.v === undefined) { _16.v = Listing.default$Default(); } - const _17: rt.u8 | undefined = option_unwrapOr$0r2bmpr((_16.v as Listing.Listing).source, b) ^ b; + const _17: rs.u8 | undefined = option_unwrapOr$1fr498u((_16.v as Listing.Listing).source, b) ^ b; (_16.v as Listing.Listing).source = _17; } else if (_11 === 3) { - const _22: rt.Place = rt.place(() => listing, (value2) => listing = value2); - const relist: (a0: rt.u8) => undefined = (b2: rt.u8): undefined => { + const _22: rs.Place = rs.place(() => listing, (value2) => listing = value2); + const relist: (a0: rs.u8) => undefined = (b2: rs.u8): undefined => { if (_22.v === undefined) { _22.v = Listing.default$Default(); } - rt.byteVecPush((_22.v as Listing.Listing).listed, b2); + rs.byteVecPush((_22.v as Listing.Listing).listed, b2); }; relist(b); relist(b ^ 1); } else { - const _31: rt.Place = rt.place(() => listing, (value) => listing = value); + const _31: rs.Place = rs.place(() => listing, (value) => listing = value); if (_31.v === undefined) { _31.v = Listing.default$Default(); } (_31.v as Listing.Listing).source = undefined; - rt.byteVecPop((_31.v as Listing.Listing).listed); + rs.byteVecPop((_31.v as Listing.Listing).listed); } } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(listing, f, (value: Listing.Listing, f: rt.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(listing, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } -export function list$defaulted(listing: rt.Place, b: rt.u8): void { +export function list$defaulted(listing: rs.Place, b: rs.u8): void { if (listing.v === undefined) { listing.v = Listing.default$Default(); } (listing.v as Listing.Listing).source = b; - const _5: rt.ByteVec = rt.byteVecFrom(rt.byteVecView((listing.v as Listing.Listing).listed)); + const _5: rs.ByteVec = rs.byteVecFrom(rs.byteVecView((listing.v as Listing.Listing).listed)); (listing.v as Listing.Listing).stale = _5; - rt.byteVecPush((listing.v as Listing.Listing).listed, b); + rs.byteVecPush((listing.v as Listing.Listing).listed, b); } /** moq-net's ingest: a field of what a `&mut` parameter points at, taken by a closure. */ -export function restock(listing: Listing.Listing, b: rt.u8): rt.ByteVec | undefined { - return then$0ozmvid(rt.u8Rem(b, 2) === 0, (): rt.ByteVec => { - const _2: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(b)); +export function restock(listing: Listing.Listing, b: rs.u8): rs.ByteVec | undefined { + return then$17csa2h(rs.u8Rem(b, 2) === 0, (): rs.ByteVec => { + const _2: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(b)); const old = listing.listed; listing.listed = _2; return old; @@ -554,68 +554,68 @@ export function restock(listing: Listing.Listing, b: rt.u8): rt.ByteVec | undefi * moq-net's front: a `Vec` a closure captured by reference, taken, replaced, and * refilled on each call, read after by the caller. */ -export function taken(data: rt.ByteSlice, out: rt.ByteVec): void { - let held: rt.ByteVec = rt.byteSliceToByteVec(data); - let wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { - return rt.u32Mul(_2 as rt.u32, 1000); +export function taken(data: rs.ByteSlice, out: rs.ByteVec): void { + let held: rs.ByteVec = rs.byteSliceToByteVec(data); + let wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { + return rs.u32Mul(_2 as rs.u32, 1000); }), undefined, 4, true); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(poll$taken_refs_taken_closure1(data, (b4: rt.u8): boolean => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(poll$taken_refs_taken_closure1(data, (b4: rs.u8): boolean => { const taken = held; - held = new rt.ByteVec(); - for (const x of rt.byteVecView(taken)) { - if (rt.u8Rem(x, 3) !== rt.u8Rem(b4, 3)) { - rt.byteVecPush(held, rt.u8Div(x, 2)); + held = new rs.ByteVec(); + for (const x of rs.byteVecView(taken)) { + if (rs.u8Rem(x, 3) !== rs.u8Rem(b4, 3)) { + rs.byteVecPush(held, rs.u8Div(x, 2)); } } ((): undefined => { const old2 = wide; - wide = new rt.Vec(); - wide = rt.iterToVec(rt.iterMap(rt.iterFilter(rt.vecIntoIter(old2), (_25: rt.u32): boolean => { - return _25 > (b4 as rt.u32); - }), (x3: rt.u32): rt.u32 => { - return rt.u32Div(x3, 2); + wide = new rs.Vec(); + wide = rs.iterToVec(rs.iterMap(rs.iterFilter(rs.vecIntoIter(old2), (_25: rs.u32): boolean => { + return _25 > (b4 as rs.u32); + }), (x3: rs.u32): rs.u32 => { + return rs.u32Div(x3, 2); }), "next", 4, false, 4); })(); return held.length === 0; - }) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(held)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(wide.items, f, rt.u32Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - const pair: [rt.ByteVec, Listing.Listing] = [rt.byteSliceToByteVec(data), Listing.default$Default()]; - const swap: (a0: rt.u8) => rt.ByteVec = (b5: rt.u8): rt.ByteVec => { - const _36: rt.ByteVec = rt.byteVecOf(b5, rt.u8Rem(b5, 4) as rt.usize); + }) as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(held)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(wide.items, f, rs.u32Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + const pair: [rs.ByteVec, Listing.Listing] = [rs.byteSliceToByteVec(data), Listing.default$Default()]; + const swap: (a0: rs.u8) => rs.ByteVec = (b5: rs.u8): rs.ByteVec => { + const _36: rs.ByteVec = rs.byteVecOf(b5, rs.u8Rem(b5, 4) as rs.usize); const old3 = pair[0]; pair[0] = _36; return old3; }; - const swapped: rt.ByteVec = new rt.ByteVec(); - for (const _39 of rt.byteSliceView(data)) { - const _45: rt.ByteVec = swap(_39); - rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_45), undefined, true); + const swapped: rs.ByteVec = new rs.ByteVec(); + for (const _39 of rs.byteSliceView(data)) { + const _45: rs.ByteVec = swap(_39); + rs.iterExtendBytes(swapped, rs.byteVecIntoIter(_45), undefined, true); } - const list: (a0: rt.u8) => undefined = (b6: rt.u8): undefined => { + const list: (a0: rs.u8) => undefined = (b6: rs.u8): undefined => { const taken2 = pair[1].listed; - pair[1].listed = new rt.ByteVec(); + pair[1].listed = new rs.ByteVec(); pair[1].stale = taken2; - rt.byteVecPush(pair[1].listed, b6); + rs.byteVecPush(pair[1].listed, b6); }; - rt.iterForEach(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): undefined => { + rs.iterForEach(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): undefined => { list(_26); }); - for (const _57 of rt.byteSliceView(data)) { - const _63: rt.ByteVec = option_unwrapOrDefault$0wx44sw(restock(pair[1], _57)); - rt.iterExtendBytes(swapped, rt.byteVecIntoIter(_63), undefined, true); + for (const _57 of rs.byteSliceView(data)) { + const _63: rs.ByteVec = option_unwrapOrDefault$0w012ed(restock(pair[1], _57)); + rs.iterExtendBytes(swapped, rs.byteVecIntoIter(_63), undefined, true); } const taken3 = pair[1].stale; - pair[1].stale = new rt.ByteVec(); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(taken3)); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(swapped)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteVecView(pair[0]), f, rt.u8Debug), (f: rt.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0]]))); + pair[1].stale = new rs.ByteVec(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(taken3)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(swapped)); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteVecView(pair[0]), f, rs.u8Debug), (f: rs.Formatter) => Listing.fmt$fmt_Debug(pair[1], f)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0]]))); } -export function poll$taken_refs_taken_closure1(data: rt.ByteSlice, f: (a0: rt.u8) => boolean): rt.usize { - return rt.iterCount(rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): boolean => { +export function poll$taken_refs_taken_closure1(data: rs.ByteSlice, f: (a0: rs.u8) => boolean): rs.usize { + return rs.iterCount(rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): boolean => { return !f(_2); })); } @@ -624,428 +624,428 @@ export function poll$taken_refs_taken_closure1(data: rt.ByteSlice, f: (a0: rt.u8 * What std lends of the elements and values of slices and collections, which JS copies: * one, each in turn, or each to a closure. */ -export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { - let _326!: rt.u8; - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; +export function elements(data: rs.ByteSlice, out: rs.ByteVec): void { + let _326!: rs.u8; + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; }), undefined, 4, true); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const pairs: rt.Vec<[rt.u8, rt.u8 | undefined]> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): [rt.u8, rt.u8 | undefined] => { - const b8: rt.u8 = _22; - return [b8, rt.u8CheckedSub(b8, 100)] as [rt.u8, rt.u8 | undefined]; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const pairs: rs.Vec<[rs.u8, rs.u8 | undefined]> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): [rs.u8, rs.u8 | undefined] => { + const b8: rs.u8 = _22; + return [b8, rs.u8CheckedSub(b8, 100)] as [rs.u8, rs.u8 | undefined]; }), undefined, 3, true); - const by: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 1); - const _13: rt.Place | undefined = rt.sliceFirstMut(v.items); + const by: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 1); + const _13: rs.Place | undefined = rs.sliceFirstMut(v.items); if (_13 !== undefined) { - _13.v = rt.u32Add(_13.v, 1); + _13.v = rs.u32Add(_13.v, 1); } - const _19: rt.Place | undefined = rt.sliceLastMut(v.items); + const _19: rs.Place | undefined = rs.sliceLastMut(v.items); if (_19 !== undefined) { bump(_19, by); } - const _25: rt.Place | undefined = rt.sliceGetMut(v.items, rt.usizeRem(by as rt.usize, 4)); + const _25: rs.Place | undefined = rs.sliceGetMut(v.items, rs.usizeRem(by as rs.usize, 4)); if (_25 !== undefined) { - _25.v = rt.u32Mul(_25.v, 2); + _25.v = rs.u32Mul(_25.v, 2); } - const _34: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteVecSlice(bytes))); + const _34: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteVecSlice(bytes))); if (_34 !== undefined) { - _34.v = rt.u8WrappingAdd(_34.v, 1); + _34.v = rs.u8WrappingAdd(_34.v, 1); } - const _41: rt.Place | undefined = rt.sliceGetMut(rt.byteSliceView(rt.byteVecSlice(bytes)), 1); + const _41: rs.Place | undefined = rs.sliceGetMut(rs.byteSliceView(rs.byteVecSlice(bytes)), 1); if (_41 !== undefined) { bumpByte(_41); } - const iter: rt.Iter> = rt.iterStepBy(rt.iterRev(rt.iterSliceMut(v.items)), 2); + const iter: rs.Iter> = rs.iterStepBy(rs.iterRev(rs.iterSliceMut(v.items)), 2); while (true) { - const _54: rt.Place | rt.Done = iter.next(); - if (_54 === rt.DONE) { + const _54: rs.Place | rs.Done = iter.next(); + if (_54 === rs.DONE) { break; } - _54.v = rt.u32Add(_54.v, 3); + _54.v = rs.u32Add(_54.v, 3); } - const iter2: rt.Iter> = rt.iterSliceMut(v.items); + const iter2: rs.Iter> = rs.iterSliceMut(v.items); while (true) { - const _62: rt.Place | rt.Done = iter2.next(); - if (_62 === rt.DONE) { + const _62: rs.Place | rs.Done = iter2.next(); + if (_62 === rs.DONE) { break; } bump(_62, 1); } - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes)))); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes)))); while (true) { - const _73: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_73 === rt.DONE) { + const _73: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_73 === rs.DONE) { break; } _73[1].v = _73[1].v ^ (_73[0] & 0xff); } - const iter4: rt.Iter<[rt.Place, rt.Place]> = rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(bytes))), rt.iterSliceMut(v.items), [false, false]); + const iter4: rs.Iter<[rs.Place, rs.Place]> = rs.iterZip(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(bytes))), rs.iterSliceMut(v.items), [false, false]); while (true) { - const _86: [rt.Place, rt.Place] | rt.Done = iter4.next(); - if (_86 === rt.DONE) { + const _86: [rs.Place, rs.Place] | rs.Done = iter4.next(); + if (_86 === rs.DONE) { break; } - _86[1].v = rt.u32Add(_86[1].v, _86[0].v as rt.u32); - _86[0].v = rt.u8WrappingAdd(_86[0].v, _86[0].v); + _86[1].v = rs.u32Add(_86[1].v, _86[0].v as rs.u32); + _86[0].v = rs.u8WrappingAdd(_86[0].v, _86[0].v); } - const _97: [rt.u8, rt.u8 | undefined] | undefined = rt.iterFind(rt.iterSlice(pairs.items), (_23: [rt.u8, rt.u8 | undefined]): boolean => { - return rt.u8Rem(_23[0], 3) === 0; + const _97: [rs.u8, rs.u8 | undefined] | undefined = rs.iterFind(rs.iterSlice(pairs.items), (_23: [rs.u8, rs.u8 | undefined]): boolean => { + return rs.u8Rem(_23[0], 3) === 0; }); if (_97 !== undefined) { - _97[1] = option_mapOr$1surhce(_97[1], 0, (s: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(s, 1); + _97[1] = option_mapOr$0vxw5sq(_97[1], 0, (s: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(s, 1); }); } - const most: rt.Place | undefined = rt.iterMaxByKey(rt.iterSliceMut(v.items), (x7: rt.Place): rt.u32 => { + const most: rs.Place | undefined = rs.iterMaxByKey(rs.iterSliceMut(v.items), (x7: rs.Place): rs.u32 => { return x7.v; - }, rt.lt); + }, rs.lt); if (most !== undefined) { most.v = 0; } - const iter5: rt.Iter> = rt.vecIntoIter(rt.iterToVec(rt.iterFilter(rt.iterSliceMut(v.items), (x8: rt.Place): boolean => { - return rt.u32Rem(x8.v, 2) === 0; + const iter5: rs.Iter> = rs.vecIntoIter(rs.iterToVec(rs.iterFilter(rs.iterSliceMut(v.items), (x8: rs.Place): boolean => { + return rs.u32Rem(x8.v, 2) === 0; }), "next", 4)); while (true) { - const _120: rt.Place | rt.Done = iter5.next(); - if (_120 === rt.DONE) { + const _120: rs.Place | rs.Done = iter5.next(); + if (_120 === rs.DONE) { break; } - _120.v = rt.u32Add(_120.v, 1); + _120.v = rs.u32Add(_120.v, 1); } - const item = copy$array_u32(Array.from({ length: 2 }, (): rt.u32 => { + const item = copy$array_u32(Array.from({ length: 2 }, (): rs.u32 => { return 0; })); - const grid: rt.u32[][] = Array.from({ length: 3 }, (): rt.u32[] => { + const grid: rs.u32[][] = Array.from({ length: 3 }, (): rs.u32[] => { return copy$array_u32(item); }); - const iter6: rt.Iter<[rt.u32[], rt.u8]> = rt.iterZip(rt.iterSlice(grid), rt.iterSlice(rt.byteSliceView(data)), [false, false]); + const iter6: rs.Iter<[rs.u32[], rs.u8]> = rs.iterZip(rs.iterSlice(grid), rs.iterSlice(rs.byteSliceView(data)), [false, false]); l18: while (true) { - const _133: [rt.u32[], rt.u8] | rt.Done = iter6.next(); - if (_133 === rt.DONE) { + const _133: [rs.u32[], rs.u8] | rs.Done = iter6.next(); + if (_133 === rs.DONE) { break; } - const b: rt.u8 = _133[1]; - const iter7: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(_133[0])); + const b: rs.u8 = _133[1]; + const iter7: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(_133[0])); while (true) { - const _143: [rt.usize, rt.Place] | rt.Done = iter7.next(); - if (_143 === rt.DONE) { + const _143: [rs.usize, rs.Place] | rs.Done = iter7.next(); + if (_143 === rs.DONE) { continue l18; } - _143[1].v = rt.u32Shl(b as rt.u32, _143[0]); + _143[1].v = rs.u32Shl(b as rs.u32, _143[0]); } } for (const _153 of v.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_153))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_153))); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(bytes)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(bytes)); for (const _168 of pairs.items) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$0r2bmpr(_168[1], 238)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_168[0], option_unwrapOr$1fr498u(_168[1], 238)))); } - const iter10: rt.Iter = rt.iterFlatten(rt.iterSlice(grid), (value: rt.u32[]) => rt.iterSlice(value), true, 2); + const iter10: rs.Iter = rs.iterFlatten(rs.iterSlice(grid), (value: rs.u32[]) => rs.iterSlice(value), true, 2); while (true) { - const _186: rt.u32 | rt.Done = iter10.next(); - if (_186 === rt.DONE) { + const _186: rs.u32 | rs.Done = iter10.next(); + if (_186 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_186))); - } - const hash: rt.HashMap = rt.hashNew() as rt.HashMap; - const tree: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const queue: rt.VecDeque = rt.dequeNew(4) as rt.VecDeque; - for (const b2 of rt.byteSliceView(data)) { - rt.entryOrInsert(rt.entryAndModify(rt.entry(hash, rt.u8Rem(b2, 5)), (x9: [rt.u8, rt.u8]): undefined => { - x9[1] = rt.u8WrappingAdd(x9[1], b2); - }), [b2, 0] as [rt.u8, rt.u8]); - const _213: rt.u32 = b2 as rt.u32; - const _214: rt.Place = rt.entryOrInsertWithMut(rt.entryAndModifyMut(rt.entry(tree, rt.u8Rem(b2, 4)), (x10: rt.Place): undefined => { - x10.v = rt.u32Add(x10.v, 1); - }), (): rt.u32 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_186))); + } + const hash: rs.HashMap = rs.hashNew() as rs.HashMap; + const tree: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const queue: rs.VecDeque = rs.dequeNew(4) as rs.VecDeque; + for (const b2 of rs.byteSliceView(data)) { + rs.entryOrInsert(rs.entryAndModify(rs.entry(hash, rs.u8Rem(b2, 5)), (x9: [rs.u8, rs.u8]): undefined => { + x9[1] = rs.u8WrappingAdd(x9[1], b2); + }), [b2, 0] as [rs.u8, rs.u8]); + const _213: rs.u32 = b2 as rs.u32; + const _214: rs.Place = rs.entryOrInsertWithMut(rs.entryAndModifyMut(rs.entry(tree, rs.u8Rem(b2, 4)), (x10: rs.Place): undefined => { + x10.v = rs.u32Add(x10.v, 1); + }), (): rs.u32 => { return 0; }); - _214.v = rt.u32Add(_214.v, _213); - rt.dequePushBack(queue, b2 as rt.u32); - if (rt.u8Rem(b2, 3) === 0) { - rt.dequePushFront(queue, rt.u32Add(b2 as rt.u32, 1)); + _214.v = rs.u32Add(_214.v, _213); + rs.dequePushBack(queue, b2 as rs.u32); + if (rs.u8Rem(b2, 3) === 0) { + rs.dequePushFront(queue, rs.u32Add(b2 as rs.u32, 1)); } } - const iter12: rt.Iter<[rt.u8, rt.u8]> = rt.hashValues(hash); + const iter12: rs.Iter<[rs.u8, rs.u8]> = rs.hashValues(hash); while (true) { - const _236: [rt.u8, rt.u8] | rt.Done = iter12.next(); - if (_236 === rt.DONE) { + const _236: [rs.u8, rs.u8] | rs.Done = iter12.next(); + if (_236 === rs.DONE) { break; } - _236[0] = rt.u8WrappingAdd(_236[0], 1); + _236[0] = rs.u8WrappingAdd(_236[0], 1); } - const iter13: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.hashIter(hash); + const iter13: rs.Iter<[rs.u8, [rs.u8, rs.u8]]> = rs.hashIter(hash); while (true) { - const _246: [rt.u8, [rt.u8, rt.u8]] | rt.Done = iter13.next(); - if (_246 === rt.DONE) { + const _246: [rs.u8, [rs.u8, rs.u8]] | rs.Done = iter13.next(); + if (_246 === rs.DONE) { break; } - if (rt.u8Rem(_246[0], 2) === 0) { - Object.assign(_246[1], [_246[1][1], _246[1][0]] as [rt.u8, rt.u8]); + if (rs.u8Rem(_246[0], 2) === 0) { + Object.assign(_246[1], [_246[1][1], _246[1][0]] as [rs.u8, rs.u8]); } } - const iter14: rt.Iter<[rt.u8, rt.Place]> = rt.btreeIterMut(tree); + const iter14: rs.Iter<[rs.u8, rs.Place]> = rs.btreeIterMut(tree); while (true) { - const _258: [rt.u8, rt.Place] | rt.Done = iter14.next(); - if (_258 === rt.DONE) { + const _258: [rs.u8, rs.Place] | rs.Done = iter14.next(); + if (_258 === rs.DONE) { break; } - _258[1].v = rt.u32Add(_258[1].v, _258[0] as rt.u32); + _258[1].v = rs.u32Add(_258[1].v, _258[0] as rs.u32); } - const iter15: rt.Iter> = rt.iterRev(rt.btreeValuesMut(tree)); + const iter15: rs.Iter> = rs.iterRev(rs.btreeValuesMut(tree)); while (true) { - const _271: rt.Place | rt.Done = iter15.next(); - if (_271 === rt.DONE) { + const _271: rs.Place | rs.Done = iter15.next(); + if (_271 === rs.DONE) { break; } - _271.v = rt.u32Mul(_271.v, 2); + _271.v = rs.u32Mul(_271.v, 2); } - const iter16: rt.Iter<[rt.u8, rt.Place]> = rt.btreeRangeMut(tree, new rt.Range(1, 3)); + const iter16: rs.Iter<[rs.u8, rs.Place]> = rs.btreeRangeMut(tree, new rs.Range(1, 3)); while (true) { - const _281: [rt.u8, rt.Place] | rt.Done = iter16.next(); - if (_281 === rt.DONE) { + const _281: [rs.u8, rs.Place] | rs.Done = iter16.next(); + if (_281 === rs.DONE) { break; } - _281[1].v = rt.u32Add(_281[1].v, ((_281[0] as rt.u32) << 8) >>> 0); + _281[1].v = rs.u32Add(_281[1].v, ((_281[0] as rs.u32) << 8) >>> 0); } - let nested = rt.None as rt.u8 | undefined | rt.None; - l39: for (const b3 of rt.byteSliceView(data)) { - const _300: rt.u8 = rt.u8Rem(b3, 3); + let nested = rs.None as rs.u8 | undefined | rs.None; + l39: for (const b3 of rs.byteSliceView(data)) { + const _300: rs.u8 = rs.u8Rem(b3, 3); if (_300 === 0) { - const _302: rt.u8 | undefined = rt.u8CheckedSub(b3, 50); - const _305 = undefined as rt.u8 | undefined; - if (nested === rt.None) { + const _302: rs.u8 | undefined = rs.u8CheckedSub(b3, 50); + const _305 = undefined as rs.u8 | undefined; + if (nested === rs.None) { nested = _305; } nested = _302; } else if (_300 === 1) { - const _306: rt.Place | undefined = nested === rt.None ? undefined : rt.place(() => nested as rt.u8 | undefined, (value2) => nested = value2); + const _306: rs.Place | undefined = nested === rs.None ? undefined : rs.place(() => nested as rs.u8 | undefined, (value2) => nested = value2); if (_306 !== undefined) { - _306.v = option_map$0cs071d(_306.v, (x11: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(x11, 1); + _306.v = option_map$1yjmt5m(_306.v, (x11: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(x11, 1); }); } } else { nested = b3; - rt.place(() => nested as rt.u8 | undefined, (value) => (nested as rt.u8 | undefined) = value); + rs.place(() => nested as rs.u8 | undefined, (value) => (nested as rs.u8 | undefined) = value); } - const iter18: rt.Iter> = rt.iterOption(rt.optionAsMut(rt.place(() => nested, (value3) => nested = value3), rt.None)); + const iter18: rs.Iter> = rs.iterOption(rs.optionAsMut(rs.place(() => nested, (value3) => nested = value3), rs.None)); while (true) { - const _318: rt.Place | rt.Done = iter18.next(); - if (_318 === rt.DONE) { + const _318: rs.Place | rs.Done = iter18.next(); + if (_318 === rs.DONE) { continue l39; } - _318.v = option_or$1loyskh(_318.v, 1); + _318.v = option_or$0ar58vy(_318.v, 1); } } - if (nested === rt.None) { + if (nested === rs.None) { _326 = 238; } else if (nested === undefined) { _326 = 221; } else { _326 = nested; } - rt.byteVecPush(out, _326); - const iter19: rt.Iter = rt.iterSlice([seenOf(data), undefined]); + rs.byteVecPush(out, _326); + const iter19: rs.Iter = rs.iterSlice([seenOf(data), undefined]); while (true) { - const _335: rt.u8 | undefined | rt.Done = iter19.next(); - if (_335 === rt.DONE) { + const _335: rs.u8 | undefined | rs.Done = iter19.next(); + if (_335 === rs.DONE) { break; } - let o2: rt.u8 | undefined = _335; - const iter20: rt.Iter> = rt.iterOption(rt.optionAsMut(rt.place(() => o2, (value4) => o2 = value4))); + let o2: rs.u8 | undefined = _335; + const iter20: rs.Iter> = rs.iterOption(rs.optionAsMut(rs.place(() => o2, (value4) => o2 = value4))); while (true) { - const _343: rt.Place | rt.Done = iter20.next(); - if (_343 === rt.DONE) { + const _343: rs.Place | rs.Done = iter20.next(); + if (_343 === rs.DONE) { break; } - _343.v = rt.u8WrappingAdd(_343.v, 7); + _343.v = rs.u8WrappingAdd(_343.v, 7); } - rt.byteVecPush(out, rt.iterCount(rt.iterOption(rt.optionAsMut(rt.place(() => o2, (value5) => o2 = value5)))) & 0xff); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(o2, 238)); + rs.byteVecPush(out, rs.iterCount(rs.iterOption(rs.optionAsMut(rs.place(() => o2, (value5) => o2 = value5)))) & 0xff); + rs.byteVecPush(out, option_unwrapOr$1fr498u(o2, 238)); } - const iter21: rt.Iter<[rt.u8, rt.u8] | undefined> = rt.iterSlice([copy$Option_tuple2_u8_u8(option_map$1fmzefe(seenOf(data), (b9: rt.u8): [rt.u8, rt.u8] => { - return [b9, 1] as [rt.u8, rt.u8]; + const iter21: rs.Iter<[rs.u8, rs.u8] | undefined> = rs.iterSlice([copy$Option_tuple2_u8_u8(option_map$1pv2dfs(seenOf(data), (b9: rs.u8): [rs.u8, rs.u8] => { + return [b9, 1] as [rs.u8, rs.u8]; })), undefined]); while (true) { - const _363: [rt.u8, rt.u8] | undefined | rt.Done = iter21.next(); - if (_363 === rt.DONE) { + const _363: [rs.u8, rs.u8] | undefined | rs.Done = iter21.next(); + if (_363 === rs.DONE) { break; } - const o4: [rt.u8, rt.u8] | undefined = copy$Option_tuple2_u8_u8(_363); - const iter22: rt.Iter<[rt.u8, rt.u8]> = rt.iterOption(o4); + const o4: [rs.u8, rs.u8] | undefined = copy$Option_tuple2_u8_u8(_363); + const iter22: rs.Iter<[rs.u8, rs.u8]> = rs.iterOption(o4); while (true) { - const _371: [rt.u8, rt.u8] | rt.Done = iter22.next(); - if (_371 === rt.DONE) { + const _371: [rs.u8, rs.u8] | rs.Done = iter22.next(); + if (_371 === rs.DONE) { break; } _371[0] = _371[0] ^ 90; } - rt.byteVecPush(out, rt.iterCount(rt.iterOption(o4)) & 0xff); - rt.byteVecPush(out, option_mapOr$0mmpeqx(o4, 238, (p: [rt.u8, rt.u8]): rt.u8 => { + rs.byteVecPush(out, rs.iterCount(rs.iterOption(o4)) & 0xff); + rs.byteVecPush(out, option_mapOr$1h9hu6n(o4, 238, (p: [rs.u8, rs.u8]): rs.u8 => { return p[0]; })); } - let n: rt.u8 = option_unwrapOr$0r2bmpr(seenOf(data), 0); - const iter23: rt.Iter | undefined> = rt.iterSlice([rt.place(() => n, (value8) => n = value8), undefined]); + let n: rs.u8 = option_unwrapOr$1fr498u(seenOf(data), 0); + const iter23: rs.Iter | undefined> = rs.iterSlice([rs.place(() => n, (value8) => n = value8), undefined]); while (true) { - const _391: rt.Place | undefined | rt.Done = iter23.next(); - if (_391 === rt.DONE) { + const _391: rs.Place | undefined | rs.Done = iter23.next(); + if (_391 === rs.DONE) { break; } - let o6: rt.Place | undefined = _391; - rt.byteVecPush(out, rt.iterCount(rt.iterOption(rt.optionAsMut(rt.place(() => o6, (value9) => o6 = value9)))) & 0xff); + let o6: rs.Place | undefined = _391; + rs.byteVecPush(out, rs.iterCount(rs.iterOption(rs.optionAsMut(rs.place(() => o6, (value9) => o6 = value9)))) & 0xff); } - rt.byteVecPush(out, n); - let _406: rt.u8 | undefined = seenOf(data); - const iter24: rt.Iter> = rt.iterOption(_406 === undefined ? undefined : rt.place(() => _406 as rt.u8, (value10) => _406 = value10)); + rs.byteVecPush(out, n); + let _406: rs.u8 | undefined = seenOf(data); + const iter24: rs.Iter> = rs.iterOption(_406 === undefined ? undefined : rs.place(() => _406 as rs.u8, (value10) => _406 = value10)); while (true) { - const _408: rt.Place | rt.Done = iter24.next(); - if (_408 === rt.DONE) { + const _408: rs.Place | rs.Done = iter24.next(); + if (_408 === rs.DONE) { break; } _408.v = _408.v ^ 255; - rt.btreeInsert(tree, 9, _408.v as rt.u32); + rs.btreeInsert(tree, 9, _408.v as rs.u32); } - rt.hashRetain(hash, (k4: rt.u8, x12: [rt.u8, rt.u8]): boolean => { + rs.hashRetain(hash, (k4: rs.u8, x12: [rs.u8, rs.u8]): boolean => { x12[1] = x12[1] ^ k4; - return k4 !== rt.u8Rem(by, 5); + return k4 !== rs.u8Rem(by, 5); }); - rt.btreeRetainMut(tree, (k5: rt.u8, x13: rt.Place): boolean => { - x13.v = rt.u32Add(x13.v, 1); - return k5 !== rt.u8Rem(by, 4); + rs.btreeRetainMut(tree, (k5: rs.u8, x13: rs.Place): boolean => { + x13.v = rs.u32Add(x13.v, 1); + return k5 !== rs.u8Rem(by, 4); }); - const iter25: rt.Iter> = rt.dequeIterMut(queue); + const iter25: rs.Iter> = rs.dequeIterMut(queue); while (true) { - const _428: rt.Place | rt.Done = iter25.next(); - if (_428 === rt.DONE) { + const _428: rs.Place | rs.Done = iter25.next(); + if (_428 === rs.DONE) { break; } - _428.v = rt.u32Add(_428.v, 1); + _428.v = rs.u32Add(_428.v, 1); } - const _433: rt.Place | undefined = rt.dequeEndMut(queue); + const _433: rs.Place | undefined = rs.dequeEndMut(queue); if (_433 !== undefined) { - _433.v = rt.u32Add(_433.v, 100); + _433.v = rs.u32Add(_433.v, 100); } - const _438: rt.Place | undefined = rt.dequeEndMut(queue, true); + const _438: rs.Place | undefined = rs.dequeEndMut(queue, true); if (_438 !== undefined) { - _438.v = rt.u32Add(_438.v, 200); + _438.v = rs.u32Add(_438.v, 200); } - const _443: rt.Place | undefined = rt.dequeGetMut(queue, 1); + const _443: rs.Place | undefined = rs.dequeGetMut(queue, 1); if (_443 !== undefined) { - _443.v = rt.u32Add(_443.v, 300); + _443.v = rs.u32Add(_443.v, 300); } - rt.dequeRetainMut(queue, (x14: rt.Place): boolean => { - x14.v = rt.u32Add(x14.v, 1); - return rt.u32Rem(x14.v, 3) !== 0; + rs.dequeRetainMut(queue, (x14: rs.Place): boolean => { + x14.v = rs.u32Add(x14.v, 1); + return rs.u32Rem(x14.v, 3) !== 0; }); - const scalars: rt.HashMap = rt.hashNew() as rt.HashMap; - for (const b4 of rt.byteSliceView(data)) { - const _457: rt.u32 = b4 as rt.u32; - const _458: rt.Place = rt.entryOrInsertWithMut(rt.entry(scalars, rt.u8Rem(b4, 5)), (): rt.u32 => { + const scalars: rs.HashMap = rs.hashNew() as rs.HashMap; + for (const b4 of rs.byteSliceView(data)) { + const _457: rs.u32 = b4 as rs.u32; + const _458: rs.Place = rs.entryOrInsertWithMut(rs.entry(scalars, rs.u8Rem(b4, 5)), (): rs.u32 => { return 0; }); - _458.v = rt.u32Add(_458.v, _457); + _458.v = rs.u32Add(_458.v, _457); } - const iter27: rt.Iter<[rt.u8, rt.Place]> = rt.hashIterMut(scalars); + const iter27: rs.Iter<[rs.u8, rs.Place]> = rs.hashIterMut(scalars); while (true) { - const _468: [rt.u8, rt.Place] | rt.Done = iter27.next(); - if (_468 === rt.DONE) { + const _468: [rs.u8, rs.Place] | rs.Done = iter27.next(); + if (_468 === rs.DONE) { break; } - _468[1].v = rt.u32Add(_468[1].v, _468[0] as rt.u32); + _468[1].v = rs.u32Add(_468[1].v, _468[0] as rs.u32); } - const iter28: rt.Iter> = rt.hashValuesMut(scalars); + const iter28: rs.Iter> = rs.hashValuesMut(scalars); while (true) { - const _480: rt.Place | rt.Done = iter28.next(); - if (_480 === rt.DONE) { + const _480: rs.Place | rs.Done = iter28.next(); + if (_480 === rs.DONE) { break; } - _480.v = rt.u32Mul(_480.v, 3); + _480.v = rs.u32Mul(_480.v, 3); } - const _486: rt.Iter<[rt.u8, rt.u32]> = rt.hashIter(scalars); - const iter29: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _486, true, undefined, undefined, "next", 8)); + const _486: rs.Iter<[rs.u8, rs.u32]> = rs.hashIter(scalars); + const iter29: rs.Iter<[rs.u8, rs.u32]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _486, true, undefined, undefined, "next", 8)); while (true) { - const _490: [rt.u8, rt.u32] | rt.Done = iter29.next(); - if (_490 === rt.DONE) { + const _490: [rs.u8, rs.u32] | rs.Done = iter29.next(); + if (_490 === rs.DONE) { break; } - const k: rt.u8 = _490[0]; - const x2: rt.u32 = _490[1]; - rt.byteVecPush(out, k); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x2))); + const k: rs.u8 = _490[0]; + const x2: rs.u32 = _490[1]; + rs.byteVecPush(out, k); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x2))); } - const paired: rt.HashMap<[rt.u8, rt.u8], rt.u32> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8], rt.u32>; - for (const b5 of rt.byteSliceView(data)) { - const _507: rt.u32 = b5 as rt.u32; - const _511: [rt.u8, rt.u8] = [rt.u8Rem(b5, 3), rt.u8Rem(b5, 2)]; - const _508: rt.Place = rt.entryOrInsertWithMut(rt.entry(paired, _511), (): rt.u32 => { + const paired: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; + for (const b5 of rs.byteSliceView(data)) { + const _507: rs.u32 = b5 as rs.u32; + const _511: [rs.u8, rs.u8] = [rs.u8Rem(b5, 3), rs.u8Rem(b5, 2)]; + const _508: rs.Place = rs.entryOrInsertWithMut(rs.entry(paired, _511), (): rs.u32 => { return 0; }); - _508.v = rt.u32Add(_508.v, _507); + _508.v = rs.u32Add(_508.v, _507); } - const iter31: rt.Iter<[[rt.u8, rt.u8], rt.Place]> = rt.hashIterMut(paired); + const iter31: rs.Iter<[[rs.u8, rs.u8], rs.Place]> = rs.hashIterMut(paired); while (true) { - const _521: [[rt.u8, rt.u8], rt.Place] | rt.Done = iter31.next(); - if (_521 === rt.DONE) { + const _521: [[rs.u8, rs.u8], rs.Place] | rs.Done = iter31.next(); + if (_521 === rs.DONE) { break; } - _521[1].v = rt.u32Add(_521[1].v, _521[0][0] as rt.u32); + _521[1].v = rs.u32Add(_521[1].v, _521[0][0] as rs.u32); } - const iter32: rt.Iter> = rt.hashValuesMut(paired); + const iter32: rs.Iter> = rs.hashValuesMut(paired); while (true) { - const _533: rt.Place | rt.Done = iter32.next(); - if (_533 === rt.DONE) { + const _533: rs.Place | rs.Done = iter32.next(); + if (_533 === rs.DONE) { break; } - _533.v = rt.u32Mul(_533.v, 2); + _533.v = rs.u32Mul(_533.v, 2); } - rt.hashRetainMut(paired, (k6: [rt.u8, rt.u8], x15: rt.Place): boolean => { - x15.v = rt.u32Add(x15.v, 1); + rs.hashRetainMut(paired, (k6: [rs.u8, rs.u8], x15: rs.Place): boolean => { + x15.v = rs.u32Add(x15.v, 1); return k6[1] === 0; }); - const _541: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.hashIter(paired); - const iter33: rt.Iter<[[rt.u8, rt.u8], rt.u32]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeMap<[rt.u8, rt.u8], rt.u32>, _541, true, undefined, undefined, "next", 8)); + const _541: rs.Iter<[[rs.u8, rs.u8], rs.u32]> = rs.hashIter(paired); + const iter33: rs.Iter<[[rs.u8, rs.u8], rs.u32]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeMap<[rs.u8, rs.u8], rs.u32>, _541, true, undefined, undefined, "next", 8)); while (true) { - const _545: [[rt.u8, rt.u8], rt.u32] | rt.Done = iter33.next(); - if (_545 === rt.DONE) { + const _545: [[rs.u8, rs.u8], rs.u32] | rs.Done = iter33.next(); + if (_545 === rs.DONE) { break; } - const a: rt.u8 = _545[0][0]; - const b6: rt.u8 = _545[0][1]; - const x3: rt.u32 = _545[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, b6))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x3))); + const a: rs.u8 = _545[0][0]; + const b6: rs.u8 = _545[0][1]; + const x3: rs.u32 = _545[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b6))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x3))); } - const _560: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.hashIter(hash); - const iter34: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _560, true, undefined, undefined, "next", 3)); + const _560: rs.Iter<[rs.u8, [rs.u8, rs.u8]]> = rs.hashIter(hash); + const iter34: rs.Iter<[rs.u8, [rs.u8, rs.u8]]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _560, true, undefined, undefined, "next", 3)); while (true) { - const _564: [rt.u8, [rt.u8, rt.u8]] | rt.Done = iter34.next(); - if (_564 === rt.DONE) { + const _564: [rs.u8, [rs.u8, rs.u8]] | rs.Done = iter34.next(); + if (_564 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_564[0], _564[1][0], _564[1][1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_564[0], _564[1][0], _564[1][1]))); } - const iter35: rt.Iter<[rt.u8, rt.u32]> = rt.btreeIter(tree); + const iter35: rs.Iter<[rs.u8, rs.u32]> = rs.btreeIter(tree); while (true) { - const _577: [rt.u8, rt.u32] | rt.Done = iter35.next(); - if (_577 === rt.DONE) { + const _577: [rs.u8, rs.u32] | rs.Done = iter35.next(); + if (_577 === rs.DONE) { break; } - const k3: rt.u8 = _577[0]; - const x5: rt.u32 = _577[1]; - rt.byteVecPush(out, k3); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x5))); + const k3: rs.u8 = _577[0]; + const x5: rs.u32 = _577[1]; + rs.byteVecPush(out, k3); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x5))); } - const iter36: rt.Iter = rt.dequeIntoIter(queue); + const iter36: rs.Iter = rs.dequeIntoIter(queue); while (true) { - const _590: rt.u32 | rt.Done = iter36.next(); - if (_590 === rt.DONE) { + const _590: rs.u32 | rs.Done = iter36.next(); + if (_590 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_590))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_590))); } } @@ -1053,13 +1053,13 @@ export function elements(data: rt.ByteSlice, out: rt.ByteVec): void { * References kept in a tuple, read after the index or reference they were borrowed * through changes: each part reads what it borrowed when the tuple was made. */ -export function kept(data: rt.ByteSlice, out: rt.ByteVec): void { - const by: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 4); +export function kept(data: rs.ByteSlice, out: rs.ByteVec): void { + const by: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 4); const v: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(v))), rt.iterSlice(rt.byteSliceView(data)), [false, false]); + const iter: rs.Iter<[rs.Place, rs.u8]> = rs.iterZip(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(v))), rs.iterSlice(rs.byteSliceView(data)), [false, false]); while (true) { - const _13: [rt.Place, rt.u8] | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: [rs.Place, rs.u8] | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } _13[0].v = _13[0].v ^ _13[1]; @@ -1067,168 +1067,168 @@ export function kept(data: rt.ByteSlice, out: rt.ByteVec): void { const _20: [Nest.Nest, Nest.Nest] = [{ pair: { n: by } }, { pair: { n: by ^ 255 } }]; const x: Nest.Nest = _20[0]; const y: Nest.Nest = _20[1]; - let i: rt.usize = rt.usizeRem(by as rt.usize, rt.byteSliceFrom(v).length); + let i: rs.usize = rs.usizeRem(by as rs.usize, rs.byteSliceFrom(v).length); let r: Nest.Nest = x; const held: Held.Held = { at: x }; const copied: Nest.Nest = r; - const _42: rt.usize = i; + const _42: rs.usize = i; if (!(_42 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _42); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _42); } const _44: Pair.Pair = r.pair; const _82: Nest.Nest = held.at; const _48: Nest.Nest = held.at; const part = v[_42]; - i = rt.usizeRem(rt.usizeAdd(i, 1), rt.byteSliceFrom(v).length); + i = rs.usizeRem(rs.usizeAdd(i, 1), rs.byteSliceFrom(v).length); r = y; held.at = y; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part, _44.n, y.pair.n, _82.pair.n, copied.pair.n, _48.pair.n, copied.pair.n))); - const _73: rt.u8 = part ^ _44.n; - const _77: rt.usize = i; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(part, _44.n, y.pair.n, _82.pair.n, copied.pair.n, _48.pair.n, copied.pair.n))); + const _73: rs.u8 = part ^ _44.n; + const _77: rs.usize = i; if (!(_77 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _77); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _77); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_73, v[_77], r.pair.n, held.at.pair.n))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_73, v[_77], r.pair.n, held.at.pair.n))); } -export function seenOf(data: rt.ByteSlice): rt.u8 | undefined { - return rt.byteSliceGet(data, 2); +export function seenOf(data: rs.ByteSlice): rs.u8 | undefined { + return rs.byteSliceGet(data, 2); } -export function bumpSlot(c: rt.Place, b: rt.u8): void { - c.v = rt.usizeAdd(c.v, rt.u8Rem(b, 4) as rt.usize); +export function bumpSlot(c: rs.Place, b: rs.u8): void { + c.v = rs.usizeAdd(c.v, rs.u8Rem(b, 4) as rs.usize); } -export function bumpByte(x: rt.Place): void { - x.v = rt.u8WrappingAdd(x.v, 1); +export function bumpByte(x: rs.Place): void { + x.v = rs.u8WrappingAdd(x.v, 1); } /** * The front of a slice taken through a `&mut` to it, which it moves past: out of bounds * past the end, it panics. */ -export function takeFront(s: rt.Place, n: rt.usize): rt.ByteSlice { - const slice: rt.ByteSlice = s.v; +export function takeFront(s: rs.Place, n: rs.usize): rs.ByteSlice { + const slice: rs.ByteSlice = s.v; if (n > slice.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const front: rt.ByteSlice = new rt.ByteSlice(slice.data, slice.start, n); - s.v = new rt.ByteSlice(slice.data, slice.start + n, slice.length - n); + const front: rs.ByteSlice = new rs.ByteSlice(slice.data, slice.start, n); + s.v = new rs.ByteSlice(slice.data, slice.start + n, slice.length - n); return front; } -export function tally$refs_Tally_u32(self: rt.Place, n: rt.u8): void { - self.v = rt.u32Add(self.v, n as rt.u32); +export function tally$refs_Tally_u32(self: rs.Place, n: rs.u8): void { + self.v = rs.u32Add(self.v, n as rs.u32); } -export function total$refs_Tally_u32(self: rt.u32): rt.u32 { +export function total$refs_Tally_u32(self: rs.u32): rs.u32 { return self; } -export function tally$refs_Tally_mut_mut_u32(self: rt.Place>>, n: rt.u8): void { +export function tally$refs_Tally_mut_mut_u32(self: rs.Place>>, n: rs.u8): void { tally$refs_Tally_mut_u32(self.v, n); } -export function tally$refs_Tally_mut_u32(self: rt.Place>, n: rt.u8): void { +export function tally$refs_Tally_mut_u32(self: rs.Place>, n: rs.u8): void { tally$refs_Tally_u32(self.v, n); } -export function total$refs_Tally_mut_mut_mut_u32(self: rt.Place>>): rt.u32 { +export function total$refs_Tally_mut_mut_mut_u32(self: rs.Place>>): rs.u32 { return total$refs_Tally_mut_mut_u32(self.v); } -export function total$refs_Tally_mut_mut_u32(self: rt.Place>): rt.u32 { +export function total$refs_Tally_mut_mut_u32(self: rs.Place>): rs.u32 { return total$refs_Tally_mut_u32(self.v); } -export function total$refs_Tally_mut_u32(self: rt.Place): rt.u32 { +export function total$refs_Tally_mut_u32(self: rs.Place): rs.u32 { return total$refs_Tally_u32(self.v); } -export function tallyAll$mut_mut_u32(t: rt.Place>>, data: rt.ByteSlice): rt.u32 { - for (const _5 of rt.byteSliceView(data)) { +export function tallyAll$mut_mut_u32(t: rs.Place>>, data: rs.ByteSlice): rs.u32 { + for (const _5 of rs.byteSliceView(data)) { tally$refs_Tally_mut_mut_u32(t, _5); } return total$refs_Tally_mut_mut_mut_u32(t); } -export function tallyAll$mut_refs_Pair(t: rt.Place, data: rt.ByteSlice): rt.u32 { - for (const _5 of rt.byteSliceView(data)) { +export function tallyAll$mut_refs_Pair(t: rs.Place, data: rs.ByteSlice): rs.u32 { + for (const _5 of rs.byteSliceView(data)) { Pair.tally$refs_Tally_mut(t, _5); } return Pair.total$refs_Tally_mut_mut(t); } -export function tallyAll$mut_u32(t: rt.Place>, data: rt.ByteSlice): rt.u32 { - for (const _5 of rt.byteSliceView(data)) { +export function tallyAll$mut_u32(t: rs.Place>, data: rs.ByteSlice): rs.u32 { + for (const _5 of rs.byteSliceView(data)) { tally$refs_Tally_mut_u32(t, _5); } return total$refs_Tally_mut_mut_u32(t); } /** The larger of two references, replacing the one a `&mut` points at. */ -export function keepLarger(r: rt.Place, other: Pair.Pair): void { +export function keepLarger(r: rs.Place, other: Pair.Pair): void { if (other.n > r.v.n) { r.v = other; } } /** A `&mut` to a `&mut`, written through twice over, then pointed elsewhere. */ -export function retarget(r: rt.Place>, other: rt.Place, by: rt.u8): void { - r.v.v = rt.u32Add(r.v.v, by as rt.u32); - if (rt.u8Rem(by, 2) === 0) { +export function retarget(r: rs.Place>, other: rs.Place, by: rs.u8): void { + r.v.v = rs.u32Add(r.v.v, by as rs.u32); + if (rs.u8Rem(by, 2) === 0) { r.v = other; } - r.v.v = rt.u32Add(r.v.v, 1); + r.v.v = rs.u32Add(r.v.v, 1); } /** The next two items, through std's `Iterator` for `&mut I` when `it` is one. */ -export function nextTwo$boxed_Box_mut_mut_iter_Copied_slice_Iter_u8(it: rt.Place>): rt.u8 { - return rt.u8WrappingAdd(option_unwrapOr$0r2bmpr(rt.iterToOption(it.v.next()), 238), option_unwrapOr$0r2bmpr(rt.iterToOption(it.v.next()), 221)); +export function nextTwo$boxed_Box_mut_mut_iter_Copied_slice_Iter_u8(it: rs.Place>): rs.u8 { + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(rs.iterToOption(it.v.next()), 238), option_unwrapOr$1fr498u(rs.iterToOption(it.v.next()), 221)); } /** The next two items, through std's `Iterator` for `&mut I` when `it` is one. */ -export function nextTwo$mut_iter_Copied_slice_Iter_u8(it: rt.Iter): rt.u8 { - return rt.u8WrappingAdd(option_unwrapOr$0r2bmpr(rt.iterToOption(it.next()), 238), option_unwrapOr$0r2bmpr(rt.iterToOption(it.next()), 221)); +export function nextTwo$mut_iter_Copied_slice_Iter_u8(it: rs.Iter): rs.u8 { + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(rs.iterToOption(it.next()), 238), option_unwrapOr$1fr498u(rs.iterToOption(it.next()), 221)); } /** The next two items, through std's `Iterator` for `&mut I` when `it` is one. */ -export function nextTwo$mut_mut_iter_Copied_slice_Iter_u8(it: rt.Place>): rt.u8 { - return rt.u8WrappingAdd(option_unwrapOr$0r2bmpr(rt.iterToOption(it.v.next()), 238), option_unwrapOr$0r2bmpr(rt.iterToOption(it.v.next()), 221)); +export function nextTwo$mut_mut_iter_Copied_slice_Iter_u8(it: rs.Place>): rs.u8 { + return rs.u8WrappingAdd(option_unwrapOr$1fr498u(rs.iterToOption(it.v.next()), 238), option_unwrapOr$1fr498u(rs.iterToOption(it.v.next()), 221)); } /** Called twice, through std's `FnMut` for `&mut F` when `f` is one. */ -export function callTwice$boxed_Box_mut_mut_refs_to_refs_closure3(f: rt.Place<(a0: rt.u8) => rt.u8>): rt.u8 { - return rt.u8WrappingAdd(f.v(1), f.v(2)); +export function callTwice$boxed_Box_mut_mut_refs_to_refs_closure3(f: rs.Place<(a0: rs.u8) => rs.u8>): rs.u8 { + return rs.u8WrappingAdd(f.v(1), f.v(2)); } /** Called twice, through std's `FnMut` for `&mut F` when `f` is one. */ -export function callTwice$boxed_Box_mut_refs_to_refs_closure3(f: (a0: rt.u8) => rt.u8): rt.u8 { - return rt.u8WrappingAdd(f(1), f(2)); +export function callTwice$boxed_Box_mut_refs_to_refs_closure3(f: (a0: rs.u8) => rs.u8): rs.u8 { + return rs.u8WrappingAdd(f(1), f(2)); } /** Called twice, through std's `FnMut` for `&mut F` when `f` is one. */ -export function callTwice$mut_mut_refs_to_refs_closure3(f: rt.Place<(a0: rt.u8) => rt.u8>): rt.u8 { - return rt.u8WrappingAdd(f.v(1), f.v(2)); +export function callTwice$mut_mut_refs_to_refs_closure3(f: rs.Place<(a0: rs.u8) => rs.u8>): rs.u8 { + return rs.u8WrappingAdd(f.v(1), f.v(2)); } /** Called twice, through std's `FnMut` for `&mut F` when `f` is one. */ -export function callTwice$mut_refs_to_refs_closure3(f: (a0: rt.u8) => rt.u8): rt.u8 { - return rt.u8WrappingAdd(f(1), f(2)); +export function callTwice$mut_refs_to_refs_closure3(f: (a0: rs.u8) => rs.u8): rs.u8 { + return rs.u8WrappingAdd(f(1), f(2)); } /** Called once, through std's `FnOnce` for `&mut F` when `f` is one. */ -export function callOnce$mut_mut_mut_refs_to_refs_closure3(f: rt.Place rt.u8>>): rt.u8 { +export function callOnce$mut_mut_mut_refs_to_refs_closure3(f: rs.Place rs.u8>>): rs.u8 { return f.v.v(3); } /** Called once, through std's `FnOnce` for `&mut F` when `f` is one. */ -export function callOnce$mut_mut_refs_to_refs_closure3(f: rt.Place<(a0: rt.u8) => rt.u8>): rt.u8 { +export function callOnce$mut_mut_refs_to_refs_closure3(f: rs.Place<(a0: rs.u8) => rs.u8>): rs.u8 { return f.v(3); } /** Called once, through std's `FnOnce` for `&mut F` when `f` is one. */ -export function callOnce$mut_refs_to_refs_closure3(f: (a0: rt.u8) => rt.u8): rt.u8 { +export function callOnce$mut_refs_to_refs_closure3(f: (a0: rs.u8) => rs.u8): rs.u8 { return f(3); } @@ -1236,21 +1236,21 @@ export function callOnce$mut_refs_to_refs_closure3(f: (a0: rt.u8) => rt.u8): rt. * A `&mut` to a reference: replaced, read, and written through, held, passed on, swapped, * and through an impl that forwards a trait through `&mut T`. */ -export function toRefs(data: rt.ByteSlice, out: rt.ByteVec): void { +export function toRefs(data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length >= 1) { - const n: rt.usize = data.data[data.start] as rt.usize; - let bytes: rt.ByteSlice = rt.byteSliceRange(data, 1); - const _12: rt.usize = rt.usizeRem(n, rt.usizeAdd(rt.byteSliceRange(data, 1).length, 2)); - rt.byteVecExtendFromSlice(out, takeFront(rt.place(() => bytes, (value) => bytes = value), _12)); - rt.byteVecPush(out, bytes.length & 0xff); - const reader: Reader.Reader = { rest: rt.place(() => bytes, (value2) => bytes = value2) }; + const n: rs.usize = data.data[data.start] as rs.usize; + let bytes: rs.ByteSlice = rs.byteSliceRange(data, 1); + const _12: rs.usize = rs.usizeRem(n, rs.usizeAdd(rs.byteSliceRange(data, 1).length, 2)); + rs.byteVecExtendFromSlice(out, takeFront(rs.place(() => bytes, (value) => bytes = value), _12)); + rs.byteVecPush(out, bytes.length & 0xff); + const reader: Reader.Reader = { rest: rs.place(() => bytes, (value2) => bytes = value2) }; while (true) { - const slice: rt.ByteSlice = Reader.rest(reader).v; + const slice: rs.ByteSlice = Reader.rest(reader).v; if (slice.length !== 0) { - const b: rt.u8 = slice.data[slice.start]; - Reader.rest(reader).v = new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1); - if (!(rt.u8Rem(b, 5) === 0)) { - rt.byteVecPush(out, b); + const b: rs.u8 = slice.data[slice.start]; + Reader.rest(reader).v = new rs.ByteSlice(slice.data, slice.start + 1, slice.length - 1); + if (!(rs.u8Rem(b, 5) === 0)) { + rs.byteVecPush(out, b); } else { break; } @@ -1258,127 +1258,127 @@ export function toRefs(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecPush(out, bytes.length & 0xff); - let tail2: rt.u32[] = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_2: rt.u8): rt.u32 => { - return ((_2 as rt.u32) << 8) >>> 0; + rs.byteVecPush(out, bytes.length & 0xff); + let tail2: rs.u32[] = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 1))), (_2: rs.u8): rs.u32 => { + return ((_2 as rs.u32) << 8) >>> 0; }), undefined, 4, true).items; while (tail2.length >= 1) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tail2[0]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tail2[0]))); tail2 = tail2.slice(1, tail2.length - 0); } let text: string = ""; - for (const _59 of rt.byteSliceView(rt.byteSliceRange(data, 1))) { - text = text + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(_59, 26)) as rt.char); + for (const _59 of rs.byteSliceView(rs.byteSliceRange(data, 1))) { + text = text + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(_59, 26)) as rs.char); } let s: string = text; - s = rt.strSlice(s, rt.min(rt.usizeRem(n, 3), rt.stringLen(s))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - const part2 = rt.usizeDiv(rt.byteSliceRange(data, 1).length, 2); - const _85: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceRange(data, 1), part2); - let a: rt.ByteSlice = rt.byteSliceRange(data, 1); - let b3: rt.ByteSlice = _85; + s = rs.strSlice(s, rs.min(rs.usizeRem(n, 3), rs.stringLen(s))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + const part2 = rs.usizeDiv(rs.byteSliceRange(data, 1).length, 2); + const _85: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceRange(data, 1), part2); + let a: rs.ByteSlice = rs.byteSliceRange(data, 1); + let b3: rs.ByteSlice = _85; const swapped = a; a = b3; b3 = swapped; const old2 = b3; - b3 = rt.byteSliceFrom(Uint8Array.of()); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.length & 0xff, b3.length & 0xff, old2.length & 0xff))); + b3 = rs.byteSliceFrom(Uint8Array.of()); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.length & 0xff, b3.length & 0xff, old2.length & 0xff))); const taken2 = a; - a = rt.byteSliceFrom(new Uint8Array(0)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.length & 0xff, taken2.length & 0xff))); - let left: rt.ByteSlice = rt.byteSliceRange(data, 1); - const skip: (a0: rt.usize) => rt.usize = (n2: rt.usize): rt.usize => { - const at: rt.usize = rt.min(n2, left.length); - left = rt.byteSliceRange(left, at); + a = rs.byteSliceFrom(new Uint8Array(0)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.length & 0xff, taken2.length & 0xff))); + let left: rs.ByteSlice = rs.byteSliceRange(data, 1); + const skip: (a0: rs.usize) => rs.usize = (n2: rs.usize): rs.usize => { + const at: rs.usize = rs.min(n2, left.length); + left = rs.byteSliceRange(left, at); return at; }; - rt.byteVecPush(out, skip(rt.usizeRem(n, 3)) & 0xff); - rt.byteVecPush(out, skip(1) & 0xff); - rt.byteVecPush(out, left.length & 0xff); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))), (_22: rt.u8): Pair.Pair => { + rs.byteVecPush(out, skip(rs.usizeRem(n, 3)) & 0xff); + rs.byteVecPush(out, skip(1) & 0xff); + rs.byteVecPush(out, left.length & 0xff); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 1))), (_22: rs.u8): Pair.Pair => { return { n: _22 }; }), undefined, 1, true); const first: Pair.Pair = { n: 0 }; let largest: Pair.Pair = first; for (const _147 of pairs.items) { - keepLarger(rt.place(() => largest, (value3) => largest = value3), _147); - } - rt.byteVecPush(out, largest.n); - let x: rt.u32 = 0; - let y: rt.u32 = 100; - let r: rt.Place = rt.place(() => x, (value4) => x = value4); - retarget(rt.place(() => r, (value5) => r = value5), rt.place(() => y, (value6) => y = value6), n & 0xff); - r.v = rt.u32Add(r.v, 1000); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(x))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(y))); - let count: rt.u32 = 0; + keepLarger(rs.place(() => largest, (value3) => largest = value3), _147); + } + rs.byteVecPush(out, largest.n); + let x: rs.u32 = 0; + let y: rs.u32 = 100; + let r: rs.Place = rs.place(() => x, (value4) => x = value4); + retarget(rs.place(() => r, (value5) => r = value5), rs.place(() => y, (value6) => y = value6), n & 0xff); + r.v = rs.u32Add(r.v, 1000); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(x))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(y))); + let count: rs.u32 = 0; const pair: Pair.Pair = { n: 1 }; - let _182: rt.Place = rt.place(() => count, (value7) => count = value7); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_u32(rt.place(() => _182, (value8) => _182 = value8), rt.byteSliceRange(data, 1))))); + let _182: rs.Place = rs.place(() => count, (value7) => count = value7); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tallyAll$mut_u32(rs.place(() => _182, (value8) => _182 = value8), rs.byteSliceRange(data, 1))))); let _189: Pair.Pair = pair; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_refs_Pair(rt.place(() => _189, (value9) => _189 = value9), rt.byteSliceRange(data, 1))))); - let _197: rt.Place = rt.place(() => count, (value10) => count = value10); - let _196: rt.Place> = rt.place(() => _197, (value11) => _197 = value11); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(tallyAll$mut_mut_u32(rt.place(() => _196, (value12) => _196 = value12), rt.byteSliceRange(data, 1))))); - rt.byteVecPush(out, pair.n); - const it: rt.Iter = rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 1))); - rt.byteVecPush(out, nextTwo$mut_iter_Copied_slice_Iter_u8(it)); - let _208: rt.Iter = it; - rt.byteVecPush(out, nextTwo$mut_mut_iter_Copied_slice_Iter_u8(rt.place(() => _208, (value13) => _208 = value13))); - let _213: rt.Iter = it; - rt.byteVecPush(out, nextTwo$boxed_Box_mut_mut_iter_Copied_slice_Iter_u8(rt.place(() => _213, (value14) => _213 = value14))); - let r2: rt.Iter = it; - const iter3: rt.Place> = rt.place(() => r2, (value15) => r2 = value15); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tallyAll$mut_refs_Pair(rs.place(() => _189, (value9) => _189 = value9), rs.byteSliceRange(data, 1))))); + let _197: rs.Place = rs.place(() => count, (value10) => count = value10); + let _196: rs.Place> = rs.place(() => _197, (value11) => _197 = value11); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(tallyAll$mut_mut_u32(rs.place(() => _196, (value12) => _196 = value12), rs.byteSliceRange(data, 1))))); + rs.byteVecPush(out, pair.n); + const it: rs.Iter = rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 1))); + rs.byteVecPush(out, nextTwo$mut_iter_Copied_slice_Iter_u8(it)); + let _208: rs.Iter = it; + rs.byteVecPush(out, nextTwo$mut_mut_iter_Copied_slice_Iter_u8(rs.place(() => _208, (value13) => _208 = value13))); + let _213: rs.Iter = it; + rs.byteVecPush(out, nextTwo$boxed_Box_mut_mut_iter_Copied_slice_Iter_u8(rs.place(() => _213, (value14) => _213 = value14))); + let r2: rs.Iter = it; + const iter3: rs.Place> = rs.place(() => r2, (value15) => r2 = value15); while (true) { - const _218: rt.u8 | rt.Done = iter3.v.next(); - if (_218 === rt.DONE) { + const _218: rs.u8 | rs.Done = iter3.v.next(); + if (_218 === rs.DONE) { break; } - const b4: rt.u8 = _218; - if (!(rt.u8Rem(b4, 3) === 0)) { - rt.byteVecPush(out, b4); + const b4: rs.u8 = _218; + if (!(rs.u8Rem(b4, 3) === 0)) { + rs.byteVecPush(out, b4); } else { break; } } - let _229: rt.Iter = it; - const iter4: rt.Place> = rt.place(() => _229, (value16) => _229 = value16); + let _229: rs.Iter = it; + const iter4: rs.Place> = rs.place(() => _229, (value16) => _229 = value16); while (true) { - const _231: rt.u8 | rt.Done = iter4.v.next(); - if (_231 === rt.DONE) { + const _231: rs.u8 | rs.Done = iter4.v.next(); + if (_231 === rs.DONE) { break; } - const b5: rt.u8 = _231; - if (!(rt.u8Rem(b5, 4) === 0)) { - rt.byteVecPush(out, b5); + const b5: rs.u8 = _231; + if (!(rs.u8Rem(b5, 4) === 0)) { + rs.byteVecPush(out, b5); } else { break; } } - rt.byteVecPush(out, rt.iterCount(it) & 0xff); - let calls: rt.u8 = 0; - const counted: (a0: rt.u8) => rt.u8 = (b7: rt.u8): rt.u8 => { - calls = rt.u8WrappingAdd(calls, b7); + rs.byteVecPush(out, rs.iterCount(it) & 0xff); + let calls: rs.u8 = 0; + const counted: (a0: rs.u8) => rs.u8 = (b7: rs.u8): rs.u8 => { + calls = rs.u8WrappingAdd(calls, b7); return calls; }; - rt.byteVecPush(out, callTwice$mut_refs_to_refs_closure3(counted)); - let _252: (a0: rt.u8) => rt.u8 = counted; - rt.byteVecPush(out, callTwice$mut_mut_refs_to_refs_closure3(rt.place(() => _252, (value17) => _252 = value17))); - rt.byteVecPush(out, callOnce$mut_refs_to_refs_closure3(counted)); - let _259: (a0: rt.u8) => rt.u8 = counted; - rt.byteVecPush(out, callOnce$mut_mut_refs_to_refs_closure3(rt.place(() => _259, (value18) => _259 = value18))); - let _264: (a0: rt.u8) => rt.u8 = counted; - let _263: rt.Place<(a0: rt.u8) => rt.u8> = rt.place(() => _264, (value19) => _264 = value19); - rt.byteVecPush(out, callOnce$mut_mut_mut_refs_to_refs_closure3(rt.place(() => _263, (value20) => _263 = value20))); - rt.byteVecPush(out, callTwice$boxed_Box_mut_refs_to_refs_closure3(counted)); - let _273: (a0: rt.u8) => rt.u8 = counted; - rt.byteVecPush(out, callTwice$boxed_Box_mut_mut_refs_to_refs_closure3(rt.place(() => _273, (value21) => _273 = value21))); + rs.byteVecPush(out, callTwice$mut_refs_to_refs_closure3(counted)); + let _252: (a0: rs.u8) => rs.u8 = counted; + rs.byteVecPush(out, callTwice$mut_mut_refs_to_refs_closure3(rs.place(() => _252, (value17) => _252 = value17))); + rs.byteVecPush(out, callOnce$mut_refs_to_refs_closure3(counted)); + let _259: (a0: rs.u8) => rs.u8 = counted; + rs.byteVecPush(out, callOnce$mut_mut_refs_to_refs_closure3(rs.place(() => _259, (value18) => _259 = value18))); + let _264: (a0: rs.u8) => rs.u8 = counted; + let _263: rs.Place<(a0: rs.u8) => rs.u8> = rs.place(() => _264, (value19) => _264 = value19); + rs.byteVecPush(out, callOnce$mut_mut_mut_refs_to_refs_closure3(rs.place(() => _263, (value20) => _263 = value20))); + rs.byteVecPush(out, callTwice$boxed_Box_mut_refs_to_refs_closure3(counted)); + let _273: (a0: rs.u8) => rs.u8 = counted; + rs.byteVecPush(out, callTwice$boxed_Box_mut_mut_refs_to_refs_closure3(rs.place(() => _273, (value21) => _273 = value21))); } } /** `Ok` for an even byte, else `Err`. */ -export function parity(b: rt.u8): rt.u8 | undefined { - if (!(rt.u8Rem(b, 2) === 0)) { +export function parity(b: rs.u8): rs.u8 | undefined { + if (!(rs.u8Rem(b, 2) === 0)) { out$u8.err = b; return undefined; } @@ -1390,39 +1390,39 @@ export function parity(b: rt.u8): rt.u8 | undefined { * beside items of no places or an empty iterator, lends each element as its place to write * through. One a consumer is given compares as values. */ -export function adapted(data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.ByteVec = rt.byteSliceToByteVec(data); - let opt: rt.u8 | undefined = rt.byteSliceFirst(data); - const part = parity(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 4)); - let res: rt.Result = part === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part); - const iter: rt.Iter<[rt.u8, rt.Place]> = rt.iterZip(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), rt.iterSliceMut(rt.byteVecView(v)), "len"); +export function adapted(data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.ByteVec = rs.byteSliceToByteVec(data); + let opt: rs.u8 | undefined = rs.byteSliceFirst(data); + const part = parity(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 4)); + let res: rs.Result = part === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part); + const iter: rs.Iter<[rs.u8, rs.Place]> = rs.iterZip(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), rs.iterSliceMut(rs.byteVecView(v)), "len"); while (true) { - const _16: [rt.u8, rt.Place] | rt.Done = iter.next(); - if (_16 === rt.DONE) { + const _16: [rs.u8, rs.Place] | rs.Done = iter.next(); + if (_16 === rs.DONE) { break; } - _16[1].v = rt.intRotateLeft(rt.u8WrappingAdd(_16[1].v, _16[0]), 1, 8, false); + _16[1].v = rs.intRotateLeft(rs.u8WrappingAdd(_16[1].v, _16[0]), 1, 8, false); } - const iter2: rt.Iter<[rt.u8, rt.Place]> = rt.iterZip(new rt.RangeFrom(1, rt.u8Step), rt.iterOption(rt.optionAsMut(rt.place(() => opt, (value) => opt = value))), "len"); + const iter2: rs.Iter<[rs.u8, rs.Place]> = rs.iterZip(new rs.RangeFrom(1, rs.u8Step), rs.iterOption(rs.optionAsMut(rs.place(() => opt, (value) => opt = value))), "len"); while (true) { - const _29: [rt.u8, rt.Place] | rt.Done = iter2.next(); - if (_29 === rt.DONE) { + const _29: [rs.u8, rs.Place] | rs.Done = iter2.next(); + if (_29 === rs.DONE) { break; } _29[1].v = _29[1].v ^ ((_29[0] << 6) & 0xff); } - const iter3: rt.Iter<[rt.u8, rt.Place]> = rt.iterZip(new rt.RangeFrom(3, rt.u8Step), rt.iterOption(rt.resultAsMut(rt.place(() => res, (value2) => res = value2))), "len"); + const iter3: rs.Iter<[rs.u8, rs.Place]> = rs.iterZip(new rs.RangeFrom(3, rs.u8Step), rs.iterOption(rs.resultAsMut(rs.place(() => res, (value2) => res = value2))), "len"); while (true) { - const _42: [rt.u8, rt.Place] | rt.Done = iter3.next(); - if (_42 === rt.DONE) { + const _42: [rs.u8, rs.Place] | rs.Done = iter3.next(); + if (_42 === rs.DONE) { break; } - _42[1].v = rt.u8WrappingMul(_42[1].v, _42[0]); + _42[1].v = rs.u8WrappingMul(_42[1].v, _42[0]); } - const iter4: rt.Iter<[[rt.u8, rt.Place], rt.Place]> = rt.iterZip(rt.iterZip(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))), rt.iterOption(rt.optionAsMut(rt.place(() => opt, (value3) => opt = value3))), "len"), rt.iterOption(rt.resultAsMut(rt.place(() => res, (value4) => res = value4))), "len"); + const iter4: rs.Iter<[[rs.u8, rs.Place], rs.Place]> = rs.iterZip(rs.iterZip(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))), rs.iterOption(rs.optionAsMut(rs.place(() => opt, (value3) => opt = value3))), "len"), rs.iterOption(rs.resultAsMut(rs.place(() => res, (value4) => res = value4))), "len"); while (true) { - const _58: [[rt.u8, rt.Place], rt.Place] | rt.Done = iter4.next(); - if (_58 === rt.DONE) { + const _58: [[rs.u8, rs.Place], rs.Place] | rs.Done = iter4.next(); + if (_58 === rs.DONE) { break; } const swapped = _58[0][1].v; @@ -1430,80 +1430,80 @@ export function adapted(data: rt.ByteSlice, out: rt.ByteVec): void { _58[1].v = swapped; _58[1].v = _58[1].v ^ _58[0][0]; } - const iter5: rt.Iter> = rt.iterChain(rt.iterChain(rt.iterChain(rt.iterOption(undefined as rt.Place | undefined), rt.iterSliceMut(rt.byteVecView(v))), rt.iterOption(rt.optionAsMut(rt.place(() => opt, (value5) => opt = value5)))), rt.iterOption(rt.resultAsMut(rt.place(() => res, (value6) => res = value6)))); + const iter5: rs.Iter> = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterOption(undefined as rs.Place | undefined), rs.iterSliceMut(rs.byteVecView(v))), rs.iterOption(rs.optionAsMut(rs.place(() => opt, (value5) => opt = value5)))), rs.iterOption(rs.resultAsMut(rs.place(() => res, (value6) => res = value6)))); while (true) { - const _76: rt.Place | rt.Done = iter5.next(); - if (_76 === rt.DONE) { + const _76: rs.Place | rs.Done = iter5.next(); + if (_76 === rs.DONE) { break; } - _76.v = rt.u8WrappingAdd(_76.v, 5); + _76.v = rs.u8WrappingAdd(_76.v, 5); } - rt.iterEmpty(); - const _84: rt.Iter> = rt.iterChain(rt.iterEmpty() as rt.Iter>, rt.iterSliceMut(rt.byteVecView(v))); - rt.iterEmpty(); - const iter6: rt.Iter> = rt.iterChain(_84, rt.iterEmpty() as rt.Iter>); + rs.iterEmpty(); + const _84: rs.Iter> = rs.iterChain(rs.iterEmpty() as rs.Iter>, rs.iterSliceMut(rs.byteVecView(v))); + rs.iterEmpty(); + const iter6: rs.Iter> = rs.iterChain(_84, rs.iterEmpty() as rs.Iter>); while (true) { - const _89: rt.Place | rt.Done = iter6.next(); - if (_89 === rt.DONE) { + const _89: rs.Place | rs.Done = iter6.next(); + if (_89 === rs.DONE) { break; } - _89.v = rt.intRotateLeft(_89.v, 3, 8, false); + _89.v = rs.intRotateLeft(_89.v, 3, 8, false); } - const _97: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(v))); - rt.iterEmpty(); - const iter7: rt.Iter<[rt.Place, rt.Place]> = rt.iterZip(_97, rt.iterEmpty() as rt.Iter>, "len"); + const _97: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(v))); + rs.iterEmpty(); + const iter7: rs.Iter<[rs.Place, rs.Place]> = rs.iterZip(_97, rs.iterEmpty() as rs.Iter>, "len"); while (true) { - const _102: [rt.Place, rt.Place] | rt.Done = iter7.next(); - if (_102 === rt.DONE) { + const _102: [rs.Place, rs.Place] | rs.Done = iter7.next(); + if (_102 === rs.DONE) { break; } const swapped2 = _102[0].v; _102[0].v = _102[1].v; _102[1].v = swapped2; } - rt.iterEmpty(); - const iter8: rt.Iter<[rt.Place, rt.Place]> = rt.iterZip(rt.iterEmpty() as rt.Iter>, rt.iterOption(rt.optionAsMut(rt.place(() => opt, (value7) => opt = value7))), "len"); + rs.iterEmpty(); + const iter8: rs.Iter<[rs.Place, rs.Place]> = rs.iterZip(rs.iterEmpty() as rs.Iter>, rs.iterOption(rs.optionAsMut(rs.place(() => opt, (value7) => opt = value7))), "len"); while (true) { - const _113: [rt.Place, rt.Place] | rt.Done = iter8.next(); - if (_113 === rt.DONE) { + const _113: [rs.Place, rs.Place] | rs.Done = iter8.next(); + if (_113 === rs.DONE) { break; } _113[0].v = _113[0].v ^ _113[1].v; _113[1].v = 0; } - const lists: rt.Iter> = rt.listIter(rt.listNew()); - const owned: rt.Iter> = rt.listIter(rt.listNew()); - rt.iterEmpty() as rt.Iter>; - const iter9: rt.Iter> = rt.iterChain(rt.iterChain(rt.iterChain(rt.iterEmpty() as rt.Iter>, rt.iterSliceMut(rt.byteVecView(v))), lists), owned); + const lists: rs.Iter> = rs.listIter(rs.listNew()); + const owned: rs.Iter> = rs.listIter(rs.listNew()); + rs.iterEmpty() as rs.Iter>; + const iter9: rs.Iter> = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterEmpty() as rs.Iter>, rs.iterSliceMut(rs.byteVecView(v))), lists), owned); while (true) { - const _128: rt.Place | rt.Done = iter9.next(); - if (_128 === rt.DONE) { + const _128: rs.Place | rs.Done = iter9.next(); + if (_128 === rs.DONE) { break; } - _128.v = rt.u8WrappingSub(_128.v, 1); + _128.v = rs.u8WrappingSub(_128.v, 1); } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(v)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(opt), undefined, true); - rt.iterExtendBytes(out, rt.iterChain(rt.iterResult(res), rt.iterOption(err$1nqzzwu(asRef$0ssaoss(res)))), undefined, true); - const copy: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(v)); - let other: rt.u8 | undefined = option_map$0cs071d(opt, (x: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(v)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(opt), undefined, true); + rs.iterExtendBytes(out, rs.iterChain(rs.iterResult(res), rs.iterOption(err$1igyjfc(asRef$1pwjn59(res)))), undefined, true); + const copy: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(v)); + let other: rs.u8 | undefined = option_map$1yjmt5m(opt, (x: rs.u8): rs.u8 => { return x ^ 1; }); - const _166: boolean = rt.iterEq(rt.iterOption(opt), rt.iterOption(rt.optionAsMut(rt.place(() => other, (value8) => other = value8))), (a04: rt.u8, a14: rt.Place): boolean => { + const _166: boolean = rs.iterEq(rs.iterOption(opt), rs.iterOption(rs.optionAsMut(rs.place(() => other, (value8) => other = value8))), (a04: rs.u8, a14: rs.Place): boolean => { return a04 === a14.v; }, true); - const _170: boolean = rt.iterEq(rt.iterResult(res), rt.iterOption(rt.optionAsMut(rt.place(() => opt, (value9) => opt = value9))), (a05: rt.u8, a15: rt.Place): boolean => { + const _170: boolean = rs.iterEq(rs.iterResult(res), rs.iterOption(rs.optionAsMut(rs.place(() => opt, (value9) => opt = value9))), (a05: rs.u8, a15: rs.Place): boolean => { return a05 === a15.v; }, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.iterEq(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(copy))), rt.iterSliceMut(rt.byteVecView(v)), (a0: rt.u8, a1: rt.Place): boolean => { + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterEq(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(copy))), rs.iterSliceMut(rs.byteVecView(v)), (a0: rs.u8, a1: rs.Place): boolean => { return a0 === a1.v; - }, true), !rt.iterEq(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(copy))), rt.iterSliceMut(rt.byteVecView(v)), (a02: rt.u8, a12: rt.Place): boolean => { + }, true), !rs.iterEq(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(copy))), rs.iterSliceMut(rs.byteVecView(v)), (a02: rs.u8, a12: rs.Place): boolean => { return a02 === a12.v; - }, true), rt.iterEq(rt.iterSkip(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(copy))), 1), rt.iterSliceMut(rt.byteVecView(v)), (a03: rt.u8, a13: rt.Place): boolean => { + }, true), rs.iterEq(rs.iterSkip(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(copy))), 1), rs.iterSliceMut(rs.byteVecView(v)), (a03: rs.u8, a13: rs.Place): boolean => { return a03 === a13.v; - }, true), _166, _170, !rt.iterEq(rt.iterSlice(rt.byteSliceView(data)), rt.iterOption(rt.resultAsMut(rt.place(() => res, (value10) => res = value10))), (a06: rt.u8, a16: rt.Place): boolean => { + }, true), _166, _170, !rs.iterEq(rs.iterSlice(rs.byteSliceView(data)), rs.iterOption(rs.resultAsMut(rs.place(() => res, (value10) => res = value10))), (a06: rs.u8, a16: rs.Place): boolean => { return a06 === a16.v; - }, true)], (a07: boolean): rt.u8 => { + }, true)], (a07: boolean): rs.u8 => { return a07 ? 1 : 0; })), undefined, true); } @@ -1512,8 +1512,8 @@ export function adapted(data: rt.ByteSlice, out: rt.ByteVec): void { * A float of few values, so that prefixes agree often: a NaN, which orders as nothing, and * a `-0.0`, equal to `0.0`. */ -export function few(b: rt.u8): rt.f32 { - const n: rt.u8 = rt.u8Rem(b, 5); +export function few(b: rs.u8): rs.f32 { + const n: rs.u8 = rs.u8Rem(b, 5); if (n === 3) { return NaN; } @@ -1524,8 +1524,8 @@ export function few(b: rt.u8): rt.f32 { } /** What `partial_cmp` answered, as its `Ordering`'s byte, or 9 for `None`. */ -export function order(o: rt.Ordering | undefined): rt.u8 { - return option_mapOr$1e4a1e0(o, 9, (o2: rt.Ordering): rt.u8 => { +export function order(o: rs.Ordering | undefined): rs.u8 { + return option_mapOr$14runhi(o, 9, (o2: rs.Ordering): rs.u8 => { return o2 & 0xff; }); } @@ -1535,57 +1535,57 @@ export function order(o: rt.Ordering | undefined): rt.u8 { * or values and in tuples beside values, over sides split at `split`: of lengths that * differ and prefixes that agree. */ -export function compared(split: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const mid: number = rt.usizeRem(split as rt.usize, rt.usizeAdd(dataLen, 1)); +export function compared(split: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const mid: number = rs.usizeRem(split as rs.usize, rs.usizeAdd(dataLen, 1)); if (mid > dataLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const left: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); - const right: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid); - const a: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), (b2: rt.u8): rt.u8 => { - return rt.u8Rem(b2, 3); + const left: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); + const right: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid); + const a: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), (b2: rs.u8): rs.u8 => { + return rs.u8Rem(b2, 3); }), undefined, true); - const b: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), (b3: rt.u8): rt.u8 => { - return rt.u8Rem(b3, 3); + const b: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), (b3: rs.u8): rs.u8 => { + return rs.u8Rem(b3, 3); }), undefined, true); - const x: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(left)), few), undefined, 4, true); - const y: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(right)), few), undefined, 4, true); - let one: rt.u8 | undefined = rt.byteSliceFirst(rt.byteVecSlice(b)); - const _32: boolean = rt.iterEq(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.same), true); - const _37: boolean = !rt.iterEq(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.same), true); - const _42: boolean = rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp)) === -1; - const order_ = rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp)); + const x: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(left)), few), undefined, 4, true); + const y: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(right)), few), undefined, 4, true); + let one: rs.u8 | undefined = rs.byteSliceFirst(rs.byteVecSlice(b)); + const _32: boolean = rs.iterEq(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.same), true); + const _37: boolean = !rs.iterEq(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.same), true); + const _42: boolean = rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp)) === -1; + const order_ = rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp)); const _47: boolean = order_ !== undefined && order_ <= 0; - const _52: boolean = rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp)) === 1; - const order2 = rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp)); - const _74: boolean = rt.iterEq(rt.iterChain(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterOption(rt.optionAsMut(rt.place(() => one, (value) => one = value)))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.same), true); + const _52: boolean = rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp)) === 1; + const order2 = rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp)); + const _74: boolean = rs.iterEq(rs.iterChain(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterOption(rs.optionAsMut(rs.place(() => one, (value) => one = value)))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.same), true); const _57: boolean = order2 !== undefined && order2 >= 0; - const _62: boolean = rt.iterEq(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(b))), (a0: rt.Place, a1: rt.u8): boolean => { + const _62: boolean = rs.iterEq(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(b))), (a0: rs.Place, a1: rs.u8): boolean => { return a0.v === a1; }, true); - const _69: boolean = !rt.iterEq(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), (a02: rt.u8, a12: rt.Place): boolean => { + const _69: boolean = !rs.iterEq(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), (a02: rs.u8, a12: rs.Place): boolean => { return a02 === a12.v; }, true); - const _81: boolean = rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(b))), rt.iterChain(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterOption(rt.optionAsMut(rt.place(() => one, (value2) => one = value2)))), rt.cellBy(rt.cmp)) === -1; - const _90: boolean = rt.iterEq(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.same), true); - const _95: boolean = !rt.iterEq(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.same), true); - const _100: boolean = rt.iterCmp(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.f32PartialCmp)) === -1; - const order3 = rt.iterCmp(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.f32PartialCmp)); + const _81: boolean = rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(b))), rs.iterChain(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterOption(rs.optionAsMut(rs.place(() => one, (value2) => one = value2)))), rs.cellBy(rs.cmp)) === -1; + const _90: boolean = rs.iterEq(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.same), true); + const _95: boolean = !rs.iterEq(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.same), true); + const _100: boolean = rs.iterCmp(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.f32PartialCmp)) === -1; + const order3 = rs.iterCmp(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.f32PartialCmp)); const _105: boolean = order3 !== undefined && order3 <= 0; - const _110: boolean = rt.iterCmp(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.f32PartialCmp)) === 1; - const order4 = rt.iterCmp(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.f32PartialCmp)); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([_32, _37, _42, _47, _52, _57, _62, _69, _74, _81, _90, _95, _100, _105, _110, order4 !== undefined && order4 >= 0, rt.iterEq(rt.iterSlice(x.items), rt.iterSliceMut(y.items), (a03: rt.f32, a13: rt.Place): boolean => { + const _110: boolean = rs.iterCmp(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.f32PartialCmp)) === 1; + const order4 = rs.iterCmp(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.f32PartialCmp)); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([_32, _37, _42, _47, _52, _57, _62, _69, _74, _81, _90, _95, _100, _105, _110, order4 !== undefined && order4 >= 0, rs.iterEq(rs.iterSlice(x.items), rs.iterSliceMut(y.items), (a03: rs.f32, a13: rs.Place): boolean => { return a03 === a13.v; - }, true), !rt.iterEq(rt.iterSliceMut(x.items), rt.iterSlice(y.items), (a04: rt.Place, a14: rt.f32): boolean => { + }, true), !rs.iterEq(rs.iterSliceMut(x.items), rs.iterSlice(y.items), (a04: rs.Place, a14: rs.f32): boolean => { return a04.v === a14; - }, true)], (a05: boolean): rt.u8 => { + }, true)], (a05: boolean): rs.u8 => { return a05 ? 1 : 0; })), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp)) & 0xff, rt.iterCmp(rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSlice(rt.byteSliceView(left)), [false, false]), rt.iterZip(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(b))), rt.iterSlice(rt.byteSliceView(right)), [false, false]), rt.cmpTuple<[rt.Place, rt.u8], rt.Ordering>([rt.cellBy(rt.cmp), rt.cmp])) & 0xff, rt.iterCmp(rt.iterMap(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), (a06: rt.Place): rt.Place | undefined => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp)) & 0xff, rs.iterCmp(rs.iterZip(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSlice(rs.byteSliceView(left)), [false, false]), rs.iterZip(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(b))), rs.iterSlice(rs.byteSliceView(right)), [false, false]), rs.cmpTuple<[rs.Place, rs.u8], rs.Ordering>([rs.cellBy(rs.cmp), rs.cmp])) & 0xff, rs.iterCmp(rs.iterMap(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), (a06: rs.Place): rs.Place | undefined => { return a06; - }), rt.iterMap(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(b))), (a07: rt.Place): rt.Place | undefined => { + }), rs.iterMap(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(b))), (a07: rs.Place): rs.Place | undefined => { return a07; - }), rt.cmpOption(rt.cellBy(rt.cmp))) & 0xff, order(rt.iterCmp(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(a))), rt.iterSliceMut(rt.byteVecView(b)), rt.cellBy(rt.cmp))), order(rt.iterCmp(rt.iterSliceMut(x.items), rt.iterSliceMut(y.items), rt.cellBy(rt.f32PartialCmp))), order(rt.iterCmp(rt.iterZip(rt.iterSliceMut(x.items), rt.iterSlice(rt.byteVecView(a)), [false, false]), rt.iterZip(rt.iterSliceMut(y.items), rt.iterSlice(rt.byteVecView(b)), [false, false]), rt.cmpTuple<[rt.Place, rt.u8], rt.Ordering | undefined>([rt.cellBy(rt.f32PartialCmp), rt.cmp]))))), undefined, true); + }), rs.cmpOption(rs.cellBy(rs.cmp))) & 0xff, order(rs.iterCmp(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(a))), rs.iterSliceMut(rs.byteVecView(b)), rs.cellBy(rs.cmp))), order(rs.iterCmp(rs.iterSliceMut(x.items), rs.iterSliceMut(y.items), rs.cellBy(rs.f32PartialCmp))), order(rs.iterCmp(rs.iterZip(rs.iterSliceMut(x.items), rs.iterSlice(rs.byteVecView(a)), [false, false]), rs.iterZip(rs.iterSliceMut(y.items), rs.iterSlice(rs.byteVecView(b)), [false, false]), rs.cmpTuple<[rs.Place, rs.u8], rs.Ordering | undefined>([rs.cellBy(rs.f32PartialCmp), rs.cmp]))))), undefined, true); } //# sourceMappingURL=refs.ts.map diff --git a/ts/fixtures/lang/refs/src/refs.rs b/ts/fixtures/lang/refs/src/refs.rs index c6cc0a013..a65350289 100644 --- a/ts/fixtures/lang/refs/src/refs.rs +++ b/ts/fixtures/lang/refs/src/refs.rs @@ -196,7 +196,7 @@ pub fn refs(data: &[u8], out: &mut Vec) { bump_byte(s); } out.push(slot.unwrap_or(0xee)); - // Replaced, in a local, through a parameter, and where `None` is `rt.None`. + // Replaced, in a local, through a parameter, and where `None` is `rs.None`. let mut last = None; let mut name = None; for &b in data { diff --git a/ts/fixtures/lang/results/expected/core/option.ts b/ts/fixtures/lang/results/expected/core/option.ts index c63661bab..5d8981cb6 100644 --- a/ts/fixtures/lang/results/expected/core/option.ts +++ b/ts/fixtures/lang/results/expected/core/option.ts @@ -1,74 +1,74 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$17ntxfo(self: rt.Result | undefined, default_: rt.Result): rt.Result { +export function unwrapOr$0xy2nem(self: rs.Result | undefined, default_: rs.Result): rs.Result { if (self === undefined) { return default_; } return self; } -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0ejznqm(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.ByteVec): rt.ByteVec | undefined { +export function map$1px2rk4(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.ByteVec): rs.ByteVec | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0w2t0i1(self: rt.u8 | undefined, _: (a0: rt.u8) => rt.u16): rt.u16 | undefined { +export function map$0zvojrv(self: rs.u8 | undefined, _: (a0: rs.u8) => rs.u16): rs.u16 | undefined { if (self === undefined) { return undefined; } - return self as rt.u16; + return self as rs.u16; } -export function map$1mcfwnw(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u16): rt.u16 | undefined { +export function map$0ydco3f(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u16): rs.u16 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0p22lts(self: rt.u8 | undefined, f: (a0: rt.u8) => undefined): undefined | rt.None { +export function map$057a36e(self: rs.u8 | undefined, f: (a0: rs.u8) => undefined): undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } f(self); return undefined; } -export function mapOr$18ph0j9(self: undefined | rt.None, default_: rt.u8, f: (a0: undefined) => rt.u8): rt.u8 { - if (self === rt.None) { +export function mapOr$0mkqwg8(self: undefined | rs.None, default_: rs.u8, f: (a0: undefined) => rs.u8): rs.u8 { + if (self === rs.None) { return default_; } return f(undefined); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) => boolean): rt.u8 | undefined { +export function filter$0hq86nl(self: rs.u8 | undefined, predicate: (a0: rs.u8) => boolean): rs.u8 | undefined { if (self !== undefined) { - const x: rt.u8 = self; + const x: rs.u8 = self; if (predicate(x)) { return x; } @@ -76,11 +76,11 @@ export function filter$0v80fk8(self: rt.u8 | undefined, predicate: (a0: rt.u8) = return undefined; } -export function clone$1grnave(self: rt.ByteVec | undefined): rt.ByteVec | undefined { +export function clone$0e53k5z(self: rs.ByteVec | undefined): rs.ByteVec | undefined { if (self === undefined) { return undefined; } - return rt.byteVecFrom(rt.byteVecView(self)); + return rs.byteVecFrom(rs.byteVecView(self)); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/results/expected/core/result.ts b/ts/fixtures/lang/results/expected/core/result.ts index 4dc0f1e99..10791dfd5 100644 --- a/ts/fixtures/lang/results/expected/core/result.ts +++ b/ts/fixtures/lang/results/expected/core/result.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$03hz3l7(self: rt.Result, op: (a0: rt.u8) => undefined): rt.Result { +export function map$1gelxzx(self: rs.Result, op: (a0: rs.u8) => undefined): rs.Result { if (self.ok) { op(self.value); - return rt.OK; + return rs.OK; } - return self as rt.Result; + return self as rs.Result; } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/results/expected/harness.ts b/ts/fixtures/lang/results/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/results/expected/harness.ts +++ b/ts/fixtures/lang/results/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/results/expected/lib.ts b/ts/fixtures/lang/results/expected/lib.ts index cc4f26967..a96fb4520 100644 --- a/ts/fixtures/lang/results/expected/lib.ts +++ b/ts/fixtures/lang/results/expected/lib.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { results, optionSlices } from "./results.ts"; import type * as Logged from "./results.Logged.ts"; -export function copy$Result_array0_u8_u8(v: rt.Result): rt.Result { - return v.ok ? rt.Ok(copy$array_u8(v.value)) : rt.Err(v.error); +export function copy$Result_array0_u8_u8(v: rs.Result): rs.Result { + return v.ok ? rs.Ok(copy$array_u8(v.value)) : rs.Err(v.error); } -export function copy$Result_array1_u8_u8(v: rt.Result): rt.Result { - return v.ok ? rt.Ok(copy$array_u8(v.value)) : rt.Err(v.error); +export function copy$Result_array1_u8_u8(v: rs.Result): rs.Result { + return v.ok ? rs.Ok(copy$array_u8(v.value)) : rs.Err(v.error); } -export function copy$Result_array5_u8_u8(v: rt.Result): rt.Result { - return v.ok ? rt.Ok(copy$array_u8(v.value)) : rt.Err(v.error); +export function copy$Result_array5_u8_u8(v: rs.Result): rs.Result { + return v.ok ? rs.Ok(copy$array_u8(v.value)) : rs.Err(v.error); } export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function drop$Result_results_Logged_results_Logged(_1: rt.Result): void { +export function drop$Result_results_Logged_results_Logged(_1: rs.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -34,8 +34,8 @@ export const out$u8: { err: unknown } = { err: undefined }; * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["results::results", results as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["results::option_slices", optionSlices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["results::results", results as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["results::option_slices", optionSlices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/results/expected/results.Logged.ts b/ts/fixtures/lang/results/expected/results.Logged.ts index 54b0528c3..b3c0ffaba 100644 --- a/ts/fixtures/lang/results/expected/results.Logged.ts +++ b/ts/fixtures/lang/results/expected/results.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id as it drops. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -19,9 +19,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=results.Logged.ts.map diff --git a/ts/fixtures/lang/results/expected/results.ts b/ts/fixtures/lang/results/expected/results.ts index 3f7b4411b..e01947eda 100644 --- a/ts/fixtures/lang/results/expected/results.ts +++ b/ts/fixtures/lang/results/expected/results.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Result_array0_u8_u8, copy$Result_array1_u8_u8, copy$Result_array5_u8_u8, drop$Result_results_Logged_results_Logged, out$u8 } from "./lib.ts"; -import { unwrapOr$17ntxfo as option_unwrapOr$17ntxfo, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0ejznqm as option_map$0ejznqm, map$0w2t0i1 as option_map$0w2t0i1, map$1mcfwnw as option_map$1mcfwnw, map$0p22lts as option_map$0p22lts, mapOr$18ph0j9 as option_mapOr$18ph0j9, mapOr$02k4ito as option_mapOr$02k4ito, filter$0v80fk8, clone$1grnave as option_clone$1grnave } from "./core/option.ts"; -import { map$03hz3l7 as result_map$03hz3l7 } from "./core/result.ts"; +import { unwrapOr$0xy2nem as option_unwrapOr$0xy2nem, unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1px2rk4 as option_map$1px2rk4, map$0zvojrv as option_map$0zvojrv, map$0ydco3f as option_map$0ydco3f, map$057a36e as option_map$057a36e, mapOr$0mkqwg8 as option_mapOr$0mkqwg8, mapOr$188iunt as option_mapOr$188iunt, filter$0hq86nl, clone$0e53k5z as option_clone$0e53k5z } from "./core/option.ts"; +import { map$1gelxzx as result_map$1gelxzx } from "./core/result.ts"; import * as Logged from "./results.Logged.ts"; /** The iterators of `Result`s of each payload `kind` picks. */ -export function results(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 7); +export function results(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 7); if (_4 === 0) { copied(data, out); } else if (_4 === 1) { @@ -27,8 +27,8 @@ export function results(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } /** `Ok` for a byte not divisible by 3, else `Err`. */ -export function split(b: rt.u8): rt.u8 | undefined { - if (!(rt.u8Rem(b, 3) === 0)) { +export function split(b: rs.u8): rs.u8 | undefined { + if (!(rs.u8Rem(b, 3) === 0)) { return b; } out$u8.err = b; @@ -36,611 +36,611 @@ export function split(b: rt.u8): rt.u8 | undefined { } /** Of bytes, which JS copies, so a `&mut` lends each as its place. */ -export function copied(data: rt.ByteSlice, out: rt.ByteVec): void { - const results: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { +export function copied(data: rs.ByteSlice, out: rs.ByteVec): void { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { const part = split(_2); - return part === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part); + return part === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part); }), undefined, 2, true); for (const _9 of results.items) { - rt.iterExtendBytes(out, rt.iterResult(_9), undefined, true); - rt.byteVecPush(out, rt.iterResult(_9).len() & 0xff); - const _22: [rt.usize, rt.usize | undefined] = rt.iterResult(_9).sizeHint(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_22[0] & 0xff, option_mapOr$02k4ito(_22[1], 238, (h: rt.usize): rt.u8 => { + rs.iterExtendBytes(out, rs.iterResult(_9), undefined, true); + rs.byteVecPush(out, rs.iterResult(_9).len() & 0xff); + const _22: [rs.usize, rs.usize | undefined] = rs.iterResult(_9).sizeHint(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_22[0] & 0xff, option_mapOr$188iunt(_22[1], 238, (h: rs.usize): rs.u8 => { return h & 0xff; }))), undefined, true); } - const iter2: rt.Iter>> = rt.iterSliceMut(results.items); + const iter2: rs.Iter>> = rs.iterSliceMut(results.items); l3: while (true) { - const _34: rt.Place> | rt.Done = iter2.next(); - if (_34 === rt.DONE) { + const _34: rs.Place> | rs.Done = iter2.next(); + if (_34 === rs.DONE) { break; } - const iter3: rt.Iter> = rt.iterOption(rt.resultAsMut(_34)); + const iter3: rs.Iter> = rs.iterOption(rs.resultAsMut(_34)); while (true) { - const _41: rt.Place | rt.Done = iter3.next(); - if (_41 === rt.DONE) { + const _41: rs.Place | rs.Done = iter3.next(); + if (_41 === rs.DONE) { continue l3; } - _41.v = rt.u8WrappingAdd(_41.v, 1); + _41.v = rs.u8WrappingAdd(_41.v, 1); } } - const iter4: rt.Iter>> = rt.iterSliceMut(results.items); + const iter4: rs.Iter>> = rs.iterSliceMut(results.items); l6: while (true) { - const _50: rt.Place> | rt.Done = iter4.next(); - if (_50 === rt.DONE) { + const _50: rs.Place> | rs.Done = iter4.next(); + if (_50 === rs.DONE) { break; } - const iter5: rt.Iter> = rt.iterOption(rt.resultAsMut(_50)); + const iter5: rs.Iter> = rs.iterOption(rs.resultAsMut(_50)); while (true) { - const _56: rt.Place | rt.Done = iter5.next(); - if (_56 === rt.DONE) { + const _56: rs.Place | rs.Done = iter5.next(); + if (_56 === rs.DONE) { continue l6; } _56.v = _56.v ^ 16; } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true), "next"); - const iter6: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), true, undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true), "next"); + const iter6: rs.Iter> = rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterOption(rs.resultAsMut(value)), true, undefined, true); while (true) { - const _71: rt.Place | rt.Done = iter6.next(); - if (_71 === rt.DONE) { + const _71: rs.Place | rs.Done = iter6.next(); + if (_71 === rs.DONE) { break; } - _71.v = rt.u8WrappingMul(_71.v, 3); + _71.v = rs.u8WrappingMul(_71.v, 3); } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true)), "next"); - const it: rt.Iter = rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true)), "next"); + const it: rs.Iter = rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true); while (true) { - const _93: [rt.u8 | undefined, rt.u8 | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.nextBack())]; + const _93: [rs.u8 | undefined, rs.u8 | undefined] = [rs.iterToOption(it.next()), rs.iterToOption(it.nextBack())]; if (_93[0] !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_93[0], option_unwrapOr$0r2bmpr(_93[1], 170))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_93[0], option_unwrapOr$1fr498u(_93[1], 170))), undefined, true); } else { break; } } - let first: rt.Result = option_unwrapOr$17ntxfo(rt.sliceFirst(results.items), rt.Err(0)); - rt.iterExtendBytes(out, rt.iterChain(rt.iterChain(rt.iterSlice(rt.byteSliceView(data)), rt.iterResult(first)), rt.iterRev(rt.iterResult(first))), undefined, true); - const iter7: rt.Iter<[rt.u8, rt.u8]> = rt.iterZip(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 1), rt.iterResult(first), "len"); + let first: rs.Result = option_unwrapOr$0xy2nem(rs.sliceFirst(results.items), rs.Err(0)); + rs.iterExtendBytes(out, rs.iterChain(rs.iterChain(rs.iterSlice(rs.byteSliceView(data)), rs.iterResult(first)), rs.iterRev(rs.iterResult(first))), undefined, true); + const iter7: rs.Iter<[rs.u8, rs.u8]> = rs.iterZip(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 1), rs.iterResult(first), "len"); while (true) { - const _126: [rt.u8, rt.u8] | rt.Done = iter7.next(); - if (_126 === rt.DONE) { + const _126: [rs.u8, rs.u8] | rs.Done = iter7.next(); + if (_126 === rs.DONE) { break; } - rt.byteVecPush(out, rt.u8WrappingSub(_126[0], _126[1])); + rs.byteVecPush(out, rs.u8WrappingSub(_126[0], _126[1])); } - const iter8: rt.Iter> = rt.iterOption(rt.resultAsMut(rt.place(() => first, (value) => first = value))); + const iter8: rs.Iter> = rs.iterOption(rs.resultAsMut(rs.place(() => first, (value) => first = value))); while (true) { - const _138: rt.Place | rt.Done = iter8.next(); - if (_138 === rt.DONE) { + const _138: rs.Place | rs.Done = iter8.next(); + if (_138 === rs.DONE) { break; } - _138.v = rt.u8WrappingSub(_138.v, 1); + _138.v = rs.u8WrappingSub(_138.v, 1); } - rt.iterExtendBytes(out, rt.iterChain(rt.iterResult(first), rt.iterResult(first)), undefined, true); - const it2: rt.Iter = rt.iterResult(first); - const cloned: rt.Iter = it2.clone(); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.iterToOption(it2.next()), 238)); - rt.byteVecPush(out, rt.iterToOption(it2.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(cloned) & 0xff); - const into: rt.Iter = rt.iterResult(first); - const back: rt.Iter = into.clone(); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([rt.iterToOption(into.next()), rt.iterToOption(back.nextBack()), rt.iterToOption(back.next())], (x: rt.u8 | undefined): rt.u8 => { - return option_unwrapOr$0r2bmpr(x, 221); + rs.iterExtendBytes(out, rs.iterChain(rs.iterResult(first), rs.iterResult(first)), undefined, true); + const it2: rs.Iter = rs.iterResult(first); + const cloned: rs.Iter = it2.clone(); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.iterToOption(it2.next()), 238)); + rs.byteVecPush(out, rs.iterToOption(it2.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(cloned) & 0xff); + const into: rs.Iter = rs.iterResult(first); + const back: rs.Iter = into.clone(); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([rs.iterToOption(into.next()), rs.iterToOption(back.nextBack()), rs.iterToOption(back.next())], (x: rs.u8 | undefined): rs.u8 => { + return option_unwrapOr$1fr498u(x, 221); })), undefined, true); - rt.iterExtendBytes(out, rt.vecIntoIter(rt.iterToVec(rt.iterResult(first), undefined, 4, true)), undefined, true); + rs.iterExtendBytes(out, rs.vecIntoIter(rs.iterToVec(rs.iterResult(first), undefined, 4, true)), undefined, true); } /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } /** * Of objects that drop, each `Ok` and `Err` alike: `into_iter` drops an `Err` as it makes * the iterator, and the iterator the `Ok` it never yielded. */ -export function owned(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const made: (a0: rt.u8) => rt.Result = (b2: rt.u8): rt.Result => { - const logged: Logged.Logged = new Logged.Logged(b2, rt.arcClone(log)); - if (!(rt.u8Rem(b2, 3) === 0)) { - return rt.Ok(logged); - } - return rt.Err(logged); +export function owned(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const made: (a0: rs.u8) => rs.Result = (b2: rs.u8): rs.Result => { + const logged: Logged.Logged = new Logged.Logged(b2, rs.arcClone(log)); + if (!(rs.u8Rem(b2, 3) === 0)) { + return rs.Ok(logged); + } + return rs.Err(logged); }; - for (const b of rt.byteSliceView(data)) { - const it: rt.Iter = rt.iterResult(made(b), rt.drop, rt.drop); - const _21: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecPush(_21.value, 254); - rt.refMutRelease(_21); - rt.drop(it); - const iter2: rt.Iter = rt.iterResult(made(b), rt.drop, rt.drop); + for (const b of rs.byteSliceView(data)) { + const it: rs.Iter = rs.iterResult(made(b), rs.drop, rs.drop); + const _21: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecPush(_21.value, 254); + rs.refMutRelease(_21); + rs.drop(it); + const iter2: rs.Iter = rs.iterResult(made(b), rs.drop, rs.drop); while (true) { - const _30: Logged.Logged | rt.Done = iter2.next(); - if (_30 === rt.DONE) { + const _30: Logged.Logged | rs.Done = iter2.next(); + if (_30 === rs.DONE) { break; } const l: Logged.Logged = _30; - rt.byteVecPush(out, l.id); + rs.byteVecPush(out, l.id); l[Symbol.dispose](); } - rt.drop(iter2); + rs.drop(iter2); flush(log.value, out); } - const results: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { return made(_2); }), undefined, 12, true); for (const _47 of results.items) { - rt.iterExtendBytes(out, rt.iterMap(rt.iterResult(_47), (l3: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterResult(_47), (l3: Logged.Logged): rs.u8 => { return l3.id; }), undefined, true); } - const iter4: rt.Iter>> = rt.iterSliceMut(results.items); + const iter4: rs.Iter>> = rs.iterSliceMut(results.items); l7: while (true) { - const _59: rt.Place> | rt.Done = iter4.next(); - if (_59 === rt.DONE) { + const _59: rs.Place> | rs.Done = iter4.next(); + if (_59 === rs.DONE) { break; } - const iter5: rt.Iter = rt.iterResult(_59.v); + const iter5: rs.Iter = rs.iterResult(_59.v); while (true) { - const _65: Logged.Logged | rt.Done = iter5.next(); - if (_65 === rt.DONE) { + const _65: Logged.Logged | rs.Done = iter5.next(); + if (_65 === rs.DONE) { continue l7; } _65.id = _65.id ^ 64; } } - const iter6: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterResult(value.v), true, undefined, true)); + const iter6: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterResult(value.v), true, undefined, true)); while (true) { - const _76: Logged.Logged | rt.Done = iter6.next(); - if (_76 === rt.DONE) { + const _76: Logged.Logged | rs.Done = iter6.next(); + if (_76 === rs.DONE) { break; } - _76.id = rt.u8WrappingAdd(_76.id, 1); + _76.id = rs.u8WrappingAdd(_76.id, 1); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (l4: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true), (l4: Logged.Logged): rs.u8 => { return l4.id; }), "next"); flush(log.value, out); - const iter7: rt.Iter = rt.iterTake(rt.iterFlatten(rt.vecIntoIter(results, drop$Result_results_Logged_results_Logged), (value: rt.Result) => rt.iterResult(value, rt.drop, rt.drop), true, undefined, true), 2, rt.drop); + const iter7: rs.Iter = rs.iterTake(rs.iterFlatten(rs.vecIntoIter(results, drop$Result_results_Logged_results_Logged), (value: rs.Result) => rs.iterResult(value, rs.drop, rs.drop), true, undefined, true), 2, rs.drop); while (true) { - const _97: Logged.Logged | rt.Done = iter7.next(); - if (_97 === rt.DONE) { + const _97: Logged.Logged | rs.Done = iter7.next(); + if (_97 === rs.DONE) { break; } const l2: Logged.Logged = _97; - rt.byteVecPush(out, l2.id); + rs.byteVecPush(out, l2.id); flush(log.value, out); l2[Symbol.dispose](); } - rt.drop(iter7); + rs.drop(iter7); flush(log.value, out); - const rest: rt.Vec = rt.iterToVec(rt.iterFlatten(rt.iterMap(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), (_23: rt.u8): rt.Result => { + const rest: rs.Vec = rs.iterToVec(rs.iterFlatten(rs.iterMap(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), (_23: rs.u8): rs.Result => { return made(_23); - }), (value: rt.Result) => rt.iterResult(value, rt.drop, rt.drop), true, undefined, true), "next", 8); + }), (value: rs.Result) => rs.iterResult(value, rs.drop, rs.drop), true, undefined, true), "next", 8); flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rest.items), (l5: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rest.items), (l5: Logged.Logged): rs.u8 => { return l5.id; }), undefined, true); - rt.dropVec(rest); + rs.dropVec(rest); flush(log.value, out); log[Symbol.dispose](); } -/** Of `()`, which JS holds as `undefined`, so an `Option` of one is `rt.None`. */ -export function units(data: rt.ByteSlice, out: rt.ByteVec): void { - const results: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { - const part: rt.u8 | undefined = split(_2); - const err: rt.u8 | undefined = part === undefined ? out$u8.err as rt.u8 : undefined; - return result_map$03hz3l7((err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(part as rt.u8)) as rt.Result, (_24: rt.u8): undefined => {}); +/** Of `()`, which JS holds as `undefined`, so an `Option` of one is `rs.None`. */ +export function units(data: rs.ByteSlice, out: rs.ByteVec): void { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { + const part: rs.u8 | undefined = split(_2); + const err: rs.u8 | undefined = part === undefined ? out$u8.err as rs.u8 : undefined; + return result_map$1gelxzx((err !== undefined ? rs.Err(err as rs.u8) : rs.Ok(part as rs.u8)) as rs.Result, (_24: rs.u8): undefined => {}); }), undefined, 2, true); - rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true)) & 0xff); - const iter: rt.Iter>> = rt.iterSliceMut(results.items); + rs.byteVecPush(out, rs.iterCount(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true)) & 0xff); + const iter: rs.Iter>> = rs.iterSliceMut(results.items); while (true) { - const _16: rt.Place> | rt.Done = iter.next(); - if (_16 === rt.DONE) { + const _16: rs.Place> | rs.Done = iter.next(); + if (_16 === rs.DONE) { break; } - const it: rt.Iter> = rt.iterOption(rt.resultAsMut(_16)); - rt.byteVecPush(out, rt.iterToOption(it.next()) !== undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterToOption(it.next()) !== undefined ? 1 : 0); + const it: rs.Iter> = rs.iterOption(rs.resultAsMut(_16)); + rs.byteVecPush(out, rs.iterToOption(it.next()) !== undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterToOption(it.next()) !== undefined ? 1 : 0); } for (const _36 of results.items) { - rt.byteVecPush(out, option_mapOr$18ph0j9(rt.iterToOption(rt.iterResult(_36).next(), rt.None), 160, (_26: undefined): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0mkqwg8(rs.iterToOption(rs.iterResult(_36).next(), rs.None), 160, (_26: undefined): rs.u8 => { return 161; })); - rt.byteVecPush(out, rt.iterToOption(rt.iterResult(_36).nextBack(), rt.None) !== rt.None ? 1 : 0); + rs.byteVecPush(out, rs.iterToOption(rs.iterResult(_36).nextBack(), rs.None) !== rs.None ? 1 : 0); } - rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.vecIntoIter(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFlatten(rs.vecIntoIter(results), (value: rs.Result) => rs.iterResult(value), true, undefined, true)) & 0xff); } /** Of an `Option`, which `flatten` reads into in turn. */ -export function nested(data: rt.ByteSlice, out: rt.ByteVec): void { - let _14!: rt.u8; - const results: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result => { - const b: rt.u8 = _2; - const _42: rt.u8 = rt.u8Rem(b, 4); +export function nested(data: rs.ByteSlice, out: rs.ByteVec): void { + let _14!: rs.u8; + const results: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result => { + const b: rs.u8 = _2; + const _42: rs.u8 = rs.u8Rem(b, 4); if (_42 === 0) { - return rt.Err(b); + return rs.Err(b); } if (_42 === 1) { - return rt.OK; + return rs.OK; } - return rt.Ok(b); + return rs.Ok(b); }), undefined, 2, true); for (const _9 of results.items) { - const _15: rt.u8 | undefined | rt.Done = rt.iterResult(_9).next(); - if (_15 === rt.DONE) { + const _15: rs.u8 | undefined | rs.Done = rs.iterResult(_9).next(); + if (_15 === rs.DONE) { _14 = 164; } else if (_15 === undefined) { _14 = 163; } else { _14 = _15; } - rt.byteVecPush(out, _14); + rs.byteVecPush(out, _14); } - const iter2: rt.Iter> = rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterOption(rt.resultAsMut(value)), true, undefined, true); + const iter2: rs.Iter> = rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterOption(rs.resultAsMut(value)), true, undefined, true); while (true) { - const _27: rt.Place | rt.Done = iter2.next(); - if (_27 === rt.DONE) { + const _27: rs.Place | rs.Done = iter2.next(); + if (_27 === rs.DONE) { break; } if (_27.v === undefined) { _27.v = 165; } else { - _27.v = rt.u8WrappingAdd(_27.v, 1); + _27.v = rs.u8WrappingAdd(_27.v, 1); } } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true), "next"); - rt.iterExtendBytes(out, rt.iterRev(rt.iterFlatten(rt.iterFlatten(rt.vecIntoIter(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), (value: rt.u8 | undefined) => rt.iterOption(value), true, undefined, true)), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterResult(value), true, undefined, true), (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true), "next"); + rs.iterExtendBytes(out, rs.iterRev(rs.iterFlatten(rs.iterFlatten(rs.vecIntoIter(results), (value: rs.Result) => rs.iterResult(value), true, undefined, true), (value: rs.u8 | undefined) => rs.iterOption(value), true, undefined, true)), "next"); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$0(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(0, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$0(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(0, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$1(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(1, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$1(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(1, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** `N` bytes of `data` from `at`, past its end each its index. */ -export function bytesAt$5(data: rt.ByteSlice, at: rt.usize): Uint8Array { - return rt.bytesFromFn(5, (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, i)), rt.usizeAdd(at, i) & 0xff); +export function bytesAt$5(data: rs.ByteSlice, at: rs.usize): Uint8Array { + return rs.bytesFromFn(5, (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, i)), rs.usizeAdd(at, i) & 0xff); }); } /** Of arrays of bytes, each lent as a slice of it: of no bytes, one, and many. */ -export function arrays$0(data: rt.ByteSlice, out: rt.ByteVec): void { - const results: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): rt.Result => { +export function arrays$0(data: rs.ByteSlice, out: rs.ByteVec): void { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): rs.Result => { if (k === 2 || k === 4) { - return rt.Err(k & 0xff); + return rs.Err(k & 0xff); } - return rt.Ok(bytesAt$0(data, rt.usizeMul(k, 0))); + return rs.Ok(bytesAt$0(data, rs.usizeMul(k, 0))); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterLend(rs.iterResult(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _38: rt.ByteSlice | rt.Done = iter3.next(); - if (_38 === rt.DONE) { + const _38: rs.ByteSlice | rs.Done = iter3.next(); + if (_38 === rs.DONE) { break; } - rt.byteSliceView(_38).reverse(); - const _44: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_38)); + rs.byteSliceView(_38).reverse(); + const _44: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_38)); if (_44 !== undefined) { _44.v = _44.v ^ 17; } } - const iter4: rt.Iter>> = rt.iterSliceMut(results.items); + const iter4: rs.Iter>> = rs.iterSliceMut(results.items); l7: while (true) { - const _51: rt.Place> | rt.Done = iter4.next(); - if (_51 === rt.DONE) { + const _51: rs.Place> | rs.Done = iter4.next(); + if (_51 === rs.DONE) { break; } - const iter5: rt.Iter = rt.iterLend(rt.iterResult(_51.v), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterLend(rs.iterResult(_51.v), rs.byteSliceFrom); while (true) { - const _58: rt.ByteSlice | rt.Done = iter5.next(); - if (_58 === rt.DONE) { + const _58: rs.ByteSlice | rs.Done = iter5.next(); + if (_58 === rs.DONE) { continue l7; } - const _62: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_58)); + const _62: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_58)); if (_62 !== undefined) { - _62.v = rt.u8WrappingAdd(_62.v, 3); + _62.v = rs.u8WrappingAdd(_62.v, 3); } } } - const first: rt.Result = copy$Result_array0_u8_u8(results.items[rt.idx(results.items, 0)]); - const other: rt.Result = copy$Result_array0_u8_u8(results.items[rt.idx(results.items, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const first: rs.Result = copy$Result_array0_u8_u8(results.items[rs.idx(results.items, 0)]); + const other: rs.Result = copy$Result_array0_u8_u8(results.items[rs.idx(results.items, 1)]); + const iter6: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _85: rt.ByteSlice | rt.Done = iter6.next(); - if (_85 === rt.DONE) { + const _85: rs.ByteSlice | rs.Done = iter6.next(); + if (_85 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _85); + rs.byteVecExtendFromSlice(out, _85); } - const iter7: rt.Iter = rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(results.items[rt.idx(results.items, 3)]), rt.byteSliceFrom)); + const iter7: rs.Iter = rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(results.items[rs.idx(results.items, 3)]), rs.byteSliceFrom)); while (true) { - const _98: rt.ByteSlice | rt.Done = iter7.next(); - if (_98 === rt.DONE) { + const _98: rs.ByteSlice | rs.Done = iter7.next(); + if (_98 === rs.DONE) { break; } - rt.byteSliceFill(_98, 90); + rs.byteSliceFill(_98, 90); } - const iter8: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter8: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _107: rt.ByteSlice | rt.Done = iter8.next(); - if (_107 === rt.DONE) { + const _107: rs.ByteSlice | rs.Done = iter8.next(); + if (_107 === rs.DONE) { break; } - rt.byteSliceView(_107).reverse(); + rs.byteSliceView(_107).reverse(); } - const iter9: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter9: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _116: rt.ByteSlice | rt.Done = iter9.next(); - if (_116 === rt.DONE) { + const _116: rs.ByteSlice | rs.Done = iter9.next(); + if (_116 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _116); + rs.byteVecExtendFromSlice(out, _116); } l18: for (const _125 of results.items) { - const iter11: rt.Iter = rt.iterLend(rt.iterResult(_125), rt.byteSliceFrom); + const iter11: rs.Iter = rs.iterLend(rs.iterResult(_125), rs.byteSliceFrom); while (true) { - const _131: rt.ByteSlice | rt.Done = iter11.next(); - if (_131 === rt.DONE) { + const _131: rs.ByteSlice | rs.Done = iter11.next(); + if (_131 === rs.DONE) { continue l18; } - rt.byteVecExtendFromSlice(out, _131); + rs.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterChain(rt.iterFlatten(rt.vecIntoIter(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array0_u8_u8(first))), "next", 0).items), rt.byteSliceFrom); + const iter12: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterChain(rs.iterFlatten(rs.vecIntoIter(results), (value: rs.Result) => rs.iterResult(value), true, undefined, true), rs.iterResult(copy$Result_array0_u8_u8(first))), "next", 0).items), rs.byteSliceFrom); while (true) { - const _146: rt.ByteSlice | rt.Done = iter12.next(); - if (_146 === rt.DONE) { + const _146: rs.ByteSlice | rs.Done = iter12.next(); + if (_146 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _146); + rs.byteVecExtendFromSlice(out, _146); } } /** Of arrays of bytes, each lent as a slice of it: of no bytes, one, and many. */ -export function arrays$1(data: rt.ByteSlice, out: rt.ByteVec): void { - const results: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): rt.Result => { +export function arrays$1(data: rs.ByteSlice, out: rs.ByteVec): void { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): rs.Result => { if (k === 2 || k === 4) { - return rt.Err(k & 0xff); + return rs.Err(k & 0xff); } - return rt.Ok(bytesAt$1(data, rt.usizeMul(k, 1))); + return rs.Ok(bytesAt$1(data, rs.usizeMul(k, 1))); }), undefined, 2, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterLend(rs.iterResult(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _38: rt.ByteSlice | rt.Done = iter3.next(); - if (_38 === rt.DONE) { + const _38: rs.ByteSlice | rs.Done = iter3.next(); + if (_38 === rs.DONE) { break; } - rt.byteSliceView(_38).reverse(); - const _44: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_38)); + rs.byteSliceView(_38).reverse(); + const _44: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_38)); if (_44 !== undefined) { _44.v = _44.v ^ 17; } } - const iter4: rt.Iter>> = rt.iterSliceMut(results.items); + const iter4: rs.Iter>> = rs.iterSliceMut(results.items); l7: while (true) { - const _51: rt.Place> | rt.Done = iter4.next(); - if (_51 === rt.DONE) { + const _51: rs.Place> | rs.Done = iter4.next(); + if (_51 === rs.DONE) { break; } - const iter5: rt.Iter = rt.iterLend(rt.iterResult(_51.v), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterLend(rs.iterResult(_51.v), rs.byteSliceFrom); while (true) { - const _58: rt.ByteSlice | rt.Done = iter5.next(); - if (_58 === rt.DONE) { + const _58: rs.ByteSlice | rs.Done = iter5.next(); + if (_58 === rs.DONE) { continue l7; } - const _62: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_58)); + const _62: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_58)); if (_62 !== undefined) { - _62.v = rt.u8WrappingAdd(_62.v, 3); + _62.v = rs.u8WrappingAdd(_62.v, 3); } } } - const first: rt.Result = copy$Result_array1_u8_u8(results.items[rt.idx(results.items, 0)]); - const other: rt.Result = copy$Result_array1_u8_u8(results.items[rt.idx(results.items, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const first: rs.Result = copy$Result_array1_u8_u8(results.items[rs.idx(results.items, 0)]); + const other: rs.Result = copy$Result_array1_u8_u8(results.items[rs.idx(results.items, 1)]); + const iter6: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _85: rt.ByteSlice | rt.Done = iter6.next(); - if (_85 === rt.DONE) { + const _85: rs.ByteSlice | rs.Done = iter6.next(); + if (_85 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _85); + rs.byteVecExtendFromSlice(out, _85); } - const iter7: rt.Iter = rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(results.items[rt.idx(results.items, 3)]), rt.byteSliceFrom)); + const iter7: rs.Iter = rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(results.items[rs.idx(results.items, 3)]), rs.byteSliceFrom)); while (true) { - const _98: rt.ByteSlice | rt.Done = iter7.next(); - if (_98 === rt.DONE) { + const _98: rs.ByteSlice | rs.Done = iter7.next(); + if (_98 === rs.DONE) { break; } - rt.byteSliceFill(_98, 90); + rs.byteSliceFill(_98, 90); } - const iter8: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter8: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _107: rt.ByteSlice | rt.Done = iter8.next(); - if (_107 === rt.DONE) { + const _107: rs.ByteSlice | rs.Done = iter8.next(); + if (_107 === rs.DONE) { break; } - rt.byteSliceView(_107).reverse(); + rs.byteSliceView(_107).reverse(); } - const iter9: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter9: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _116: rt.ByteSlice | rt.Done = iter9.next(); - if (_116 === rt.DONE) { + const _116: rs.ByteSlice | rs.Done = iter9.next(); + if (_116 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _116); + rs.byteVecExtendFromSlice(out, _116); } l18: for (const _125 of results.items) { - const iter11: rt.Iter = rt.iterLend(rt.iterResult(_125), rt.byteSliceFrom); + const iter11: rs.Iter = rs.iterLend(rs.iterResult(_125), rs.byteSliceFrom); while (true) { - const _131: rt.ByteSlice | rt.Done = iter11.next(); - if (_131 === rt.DONE) { + const _131: rs.ByteSlice | rs.Done = iter11.next(); + if (_131 === rs.DONE) { continue l18; } - rt.byteVecExtendFromSlice(out, _131); + rs.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterChain(rt.iterFlatten(rt.vecIntoIter(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array1_u8_u8(first))), "next", 1).items), rt.byteSliceFrom); + const iter12: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterChain(rs.iterFlatten(rs.vecIntoIter(results), (value: rs.Result) => rs.iterResult(value), true, undefined, true), rs.iterResult(copy$Result_array1_u8_u8(first))), "next", 1).items), rs.byteSliceFrom); while (true) { - const _146: rt.ByteSlice | rt.Done = iter12.next(); - if (_146 === rt.DONE) { + const _146: rs.ByteSlice | rs.Done = iter12.next(); + if (_146 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _146); + rs.byteVecExtendFromSlice(out, _146); } } /** Of arrays of bytes, each lent as a slice of it: of no bytes, one, and many. */ -export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { - const results: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 5), (k: rt.usize): rt.Result => { +export function arrays$5(data: rs.ByteSlice, out: rs.ByteVec): void { + const results: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 5), (k: rs.usize): rs.Result => { if (k === 2 || k === 4) { - return rt.Err(k & 0xff); + return rs.Err(k & 0xff); } - return rt.Ok(bytesAt$5(data, rt.usizeMul(k, 5))); + return rs.Ok(bytesAt$5(data, rs.usizeMul(k, 5))); }), undefined, 6, true); - const iter: rt.Iter = rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true); + const iter: rs.Iter = rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true); while (true) { - const _13: rt.ByteSlice | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.ByteSlice | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _13); + rs.byteVecExtendFromSlice(out, _13); } - const iter2: rt.Iter = rt.iterRev(rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const iter2: rs.Iter = rs.iterRev(rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _26: rt.ByteSlice | rt.Done = iter2.next(); - if (_26 === rt.DONE) { + const _26: rs.ByteSlice | rs.Done = iter2.next(); + if (_26 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _26); + rs.byteVecExtendFromSlice(out, _26); } - const iter3: rt.Iter = rt.iterFlatten(rt.iterSliceMut(results.items), (value: rt.Place>) => rt.iterLend(rt.iterResult(value.v), rt.byteSliceFrom), true, undefined, true); + const iter3: rs.Iter = rs.iterFlatten(rs.iterSliceMut(results.items), (value: rs.Place>) => rs.iterLend(rs.iterResult(value.v), rs.byteSliceFrom), true, undefined, true); while (true) { - const _38: rt.ByteSlice | rt.Done = iter3.next(); - if (_38 === rt.DONE) { + const _38: rs.ByteSlice | rs.Done = iter3.next(); + if (_38 === rs.DONE) { break; } - rt.byteSliceView(_38).reverse(); - const _44: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_38)); + rs.byteSliceView(_38).reverse(); + const _44: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_38)); if (_44 !== undefined) { _44.v = _44.v ^ 17; } } - const iter4: rt.Iter>> = rt.iterSliceMut(results.items); + const iter4: rs.Iter>> = rs.iterSliceMut(results.items); l7: while (true) { - const _51: rt.Place> | rt.Done = iter4.next(); - if (_51 === rt.DONE) { + const _51: rs.Place> | rs.Done = iter4.next(); + if (_51 === rs.DONE) { break; } - const iter5: rt.Iter = rt.iterLend(rt.iterResult(_51.v), rt.byteSliceFrom); + const iter5: rs.Iter = rs.iterLend(rs.iterResult(_51.v), rs.byteSliceFrom); while (true) { - const _58: rt.ByteSlice | rt.Done = iter5.next(); - if (_58 === rt.DONE) { + const _58: rs.ByteSlice | rs.Done = iter5.next(); + if (_58 === rs.DONE) { continue l7; } - const _62: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_58)); + const _62: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_58)); if (_62 !== undefined) { - _62.v = rt.u8WrappingAdd(_62.v, 3); + _62.v = rs.u8WrappingAdd(_62.v, 3); } } } - const first: rt.Result = copy$Result_array5_u8_u8(results.items[rt.idx(results.items, 0)]); - const other: rt.Result = copy$Result_array5_u8_u8(results.items[rt.idx(results.items, 1)]); - const iter6: rt.Iter = rt.iterChain(rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(other), rt.byteSliceFrom)), rt.iterFlatten(rt.iterSlice(results.items), (value: rt.Result) => rt.iterLend(rt.iterResult(value), rt.byteSliceFrom), true, undefined, true)); + const first: rs.Result = copy$Result_array5_u8_u8(results.items[rs.idx(results.items, 0)]); + const other: rs.Result = copy$Result_array5_u8_u8(results.items[rs.idx(results.items, 1)]); + const iter6: rs.Iter = rs.iterChain(rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(other), rs.byteSliceFrom)), rs.iterFlatten(rs.iterSlice(results.items), (value: rs.Result) => rs.iterLend(rs.iterResult(value), rs.byteSliceFrom), true, undefined, true)); while (true) { - const _85: rt.ByteSlice | rt.Done = iter6.next(); - if (_85 === rt.DONE) { + const _85: rs.ByteSlice | rs.Done = iter6.next(); + if (_85 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _85); + rs.byteVecExtendFromSlice(out, _85); } - const iter7: rt.Iter = rt.iterChain(rt.iterLend(rt.iterResult(first), rt.byteSliceFrom), rt.iterLend(rt.iterResult(results.items[rt.idx(results.items, 3)]), rt.byteSliceFrom)); + const iter7: rs.Iter = rs.iterChain(rs.iterLend(rs.iterResult(first), rs.byteSliceFrom), rs.iterLend(rs.iterResult(results.items[rs.idx(results.items, 3)]), rs.byteSliceFrom)); while (true) { - const _98: rt.ByteSlice | rt.Done = iter7.next(); - if (_98 === rt.DONE) { + const _98: rs.ByteSlice | rs.Done = iter7.next(); + if (_98 === rs.DONE) { break; } - rt.byteSliceFill(_98, 90); + rs.byteSliceFill(_98, 90); } - const iter8: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter8: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _107: rt.ByteSlice | rt.Done = iter8.next(); - if (_107 === rt.DONE) { + const _107: rs.ByteSlice | rs.Done = iter8.next(); + if (_107 === rs.DONE) { break; } - rt.byteSliceView(_107).reverse(); + rs.byteSliceView(_107).reverse(); } - const iter9: rt.Iter = rt.iterLend(rt.iterResult(first), rt.byteSliceFrom); + const iter9: rs.Iter = rs.iterLend(rs.iterResult(first), rs.byteSliceFrom); while (true) { - const _116: rt.ByteSlice | rt.Done = iter9.next(); - if (_116 === rt.DONE) { + const _116: rs.ByteSlice | rs.Done = iter9.next(); + if (_116 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _116); + rs.byteVecExtendFromSlice(out, _116); } l18: for (const _125 of results.items) { - const iter11: rt.Iter = rt.iterLend(rt.iterResult(_125), rt.byteSliceFrom); + const iter11: rs.Iter = rs.iterLend(rs.iterResult(_125), rs.byteSliceFrom); while (true) { - const _131: rt.ByteSlice | rt.Done = iter11.next(); - if (_131 === rt.DONE) { + const _131: rs.ByteSlice | rs.Done = iter11.next(); + if (_131 === rs.DONE) { continue l18; } - rt.byteVecExtendFromSlice(out, _131); + rs.byteVecExtendFromSlice(out, _131); } } - const iter12: rt.Iter = rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterChain(rt.iterFlatten(rt.vecIntoIter(results), (value: rt.Result) => rt.iterResult(value), true, undefined, true), rt.iterResult(copy$Result_array5_u8_u8(first))), "next", 5).items), rt.byteSliceFrom); + const iter12: rs.Iter = rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterChain(rs.iterFlatten(rs.vecIntoIter(results), (value: rs.Result) => rs.iterResult(value), true, undefined, true), rs.iterResult(copy$Result_array5_u8_u8(first))), "next", 5).items), rs.byteSliceFrom); while (true) { - const _146: rt.ByteSlice | rt.Done = iter12.next(); - if (_146 === rt.DONE) { + const _146: rs.ByteSlice | rs.Done = iter12.next(); + if (_146 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _146); + rs.byteVecExtendFromSlice(out, _146); } } @@ -649,105 +649,105 @@ export function arrays$5(data: rt.ByteSlice, out: rt.ByteVec): void { * of the one value, read and written where the `Option` holds it, and of a `None`, an * empty one. A byte's is only read, as a byte slice views only an array of bytes. */ -export function optionSlices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const some: (a0: rt.usize) => rt.u8 | undefined = (i: rt.usize): rt.u8 | undefined => { - return filter$0v80fk8(rt.byteSliceGet(data, i), (b: rt.u8): boolean => { - return rt.u8Rem(b, 3) !== 0; +export function optionSlices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const some: (a0: rs.usize) => rs.u8 | undefined = (i: rs.usize): rs.u8 | undefined => { + return filter$0hq86nl(rs.byteSliceGet(data, i), (b: rs.u8): boolean => { + return rs.u8Rem(b, 3) !== 0; }); }; b0: { - const _5: rt.u8 = rt.u8Rem(kind, 4); + const _5: rs.u8 = rs.u8Rem(kind, 4); if (_5 === 0) { - const bytes: Array = [some(0), some(1)]; + const bytes: Array = [some(0), some(1)]; for (const _17 of bytes) { - rt.byteVecPush(out, rt.byteOptionAsSlice(_17).length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteOptionAsSlice(_17)); + rs.byteVecPush(out, rs.byteOptionAsSlice(_17).length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteOptionAsSlice(_17)); } - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(bytes), (a02: rt.u8 | undefined): rt.ByteSlice => { - return rt.byteOptionAsSlice(a02); - }, (value: rt.ByteSlice) => rt.iterSlice(rt.byteSliceView(value)), true), "next"); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(bytes), (a02: rs.u8 | undefined): rs.ByteSlice => { + return rs.byteOptionAsSlice(a02); + }, (value: rs.ByteSlice) => rs.iterSlice(rs.byteSliceView(value)), true), "next"); } else { if (_5 === 1) { - let wide: rt.u16 | undefined = option_map$1mcfwnw(some(0), (b3: rt.u8): rt.u16 => { - return ((b3 as rt.u16) << 4) & 0xffff; + let wide: rs.u16 | undefined = option_map$0ydco3f(some(0), (b3: rs.u8): rs.u16 => { + return ((b3 as rs.u16) << 4) & 0xffff; }); - (wide === undefined ? [] : rt.sliceOfPlace(rt.place(() => wide as rt.u16, (value3) => wide = value3))).fill(4660); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.iterFold(rt.iterSlice(rt.optionAsSlice(wide)), 0, (a: rt.u16, w: rt.u16): rt.u16 => { + (wide === undefined ? [] : rs.sliceOfPlace(rs.place(() => wide as rs.u16, (value3) => wide = value3))).fill(4660); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.iterFold(rs.iterSlice(rs.optionAsSlice(wide)), 0, (a: rs.u16, w: rs.u16): rs.u16 => { return a ^ w; })))); - const wides: Array = [wide, option_map$0w2t0i1(some(1), (a0: rt.u8): rt.u16 => { - return a0 as rt.u16; - }), option_map$1mcfwnw(some(2), (b4: rt.u8): rt.u16 => { - return rt.u16Mul(b4 as rt.u16, 257); + const wides: Array = [wide, option_map$0zvojrv(some(1), (a0: rs.u8): rs.u16 => { + return a0 as rs.u16; + }), option_map$0ydco3f(some(2), (b4: rs.u8): rs.u16 => { + return rs.u16Mul(b4 as rs.u16, 257); })]; - const iter2: rt.Iter> = rt.iterSliceMut(wides); + const iter2: rs.Iter> = rs.iterSliceMut(wides); while (true) { - const _60: rt.Place | rt.Done = iter2.next(); - if (_60 === rt.DONE) { + const _60: rs.Place | rs.Done = iter2.next(); + if (_60 === rs.DONE) { break; } - const iter3: rt.Iter> = rt.iterSliceMut(_60.v === undefined ? [] : rt.sliceOfPlace(rt.place(() => _60.v as rt.u16, (value4) => _60.v = value4))); + const iter3: rs.Iter> = rs.iterSliceMut(_60.v === undefined ? [] : rs.sliceOfPlace(rs.place(() => _60.v as rs.u16, (value4) => _60.v = value4))); while (true) { - const _67: rt.Place | rt.Done = iter3.next(); - if (_67 === rt.DONE) { + const _67: rs.Place | rs.Done = iter3.next(); + if (_67 === rs.DONE) { break; } _67.v = _67.v ^ 3855; } - const _71: rt.u16[] = _60.v === undefined ? [] : rt.sliceOfPlace(rt.place(() => _60.v as rt.u16, (value5) => _60.v = value5)); + const _71: rs.u16[] = _60.v === undefined ? [] : rs.sliceOfPlace(rs.place(() => _60.v as rs.u16, (value5) => _60.v = value5)); if (_71.length === 1) { - _71[0] = rt.intRotateLeft(_71[0], 3, 16, false); + _71[0] = rs.intRotateLeft(_71[0], 3, 16, false); } - rt.byteVecPush(out, rt.optionAsSlice(_60.v).length & 0xff); + rs.byteVecPush(out, rs.optionAsSlice(_60.v).length & 0xff); } - swapHalves(rt.place(() => wides[1], (value6) => wides[1] = value6)); - const iterS2: Array = wides; + swapHalves(rs.place(() => wides[1], (value6) => wides[1] = value6)); + const iterS2: Array = wides; let iterI2: number = 0; while (true) { - const _90: rt.u16 | undefined | rt.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rt.DONE; - if (_90 === rt.DONE) { + const _90: rs.u16 | undefined | rs.Done = iterI2 < iterS2.length ? iterS2[iterI2++] : rs.DONE; + if (_90 === rs.DONE) { break b0; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(option_unwrapOr$1j4op5y(_90, 61166)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(option_unwrapOr$1szdyfq(_90, 61166)))); } } if (_5 === 2) { - const words: rt.ByteVec | undefined = option_map$0ejznqm(some(0), (b2: rt.u8): rt.ByteVec => { - return rt.byteVecOf(b2, rt.u8Rem(b2, 4) as rt.usize); + const words: rs.ByteVec | undefined = option_map$1px2rk4(some(0), (b2: rs.u8): rs.ByteVec => { + return rs.byteVecOf(b2, rs.u8Rem(b2, 4) as rs.usize); }); - const other: rt.ByteVec | undefined = option_clone$1grnave(words); - for (const _110 of words === undefined ? [] : rt.sliceIn(words)) { - rt.byteVecPush(_110, 119); + const other: rs.ByteVec | undefined = option_clone$0e53k5z(words); + for (const _110 of words === undefined ? [] : rs.sliceIn(words)) { + rs.byteVecPush(_110, 119); } - const _115: rt.ByteVec | undefined = rt.sliceFirst(words === undefined ? [] : rt.sliceIn(words)); + const _115: rs.ByteVec | undefined = rs.sliceFirst(words === undefined ? [] : rs.sliceIn(words)); if (_115 !== undefined) { - Object.assign(_115, rt.byteVecFrom(Uint8Array.of(102))); + Object.assign(_115, rs.byteVecFrom(Uint8Array.of(102))); } - const s: rt.ByteVec[] = rt.optionAsSlice(words); - rt.byteVecPush(out, s.length & 0xff); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(s), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), "next"); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterSlice(rt.optionAsSlice(other)), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), "next"); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(words), (value: rt.ByteVec) => rt.byteVecIntoIter(value), true), "next"); + const s: rs.ByteVec[] = rs.optionAsSlice(words); + rs.byteVecPush(out, s.length & 0xff); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(s), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterSlice(rs.optionAsSlice(other)), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), "next"); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(words), (value: rs.ByteVec) => rs.byteVecIntoIter(value), true), "next"); } else { - let units: undefined | rt.None = option_map$0p22lts(some(0), (_2: rt.u8): undefined => {}); - rt.byteVecPush(out, rt.optionAsSlice(units, rt.None).length & 0xff); - rt.byteVecPush(out, (units === rt.None ? [] : rt.sliceOfPlace(rt.place(() => units as undefined, (value) => units = value))).length & 0xff); - (units === rt.None ? [] : rt.sliceOfPlace(rt.place(() => units as undefined, (value2) => units = value2))).fill(undefined); - rt.byteVecPush(out, units !== rt.None ? 1 : 0); + let units: undefined | rs.None = option_map$057a36e(some(0), (_2: rs.u8): undefined => {}); + rs.byteVecPush(out, rs.optionAsSlice(units, rs.None).length & 0xff); + rs.byteVecPush(out, (units === rs.None ? [] : rs.sliceOfPlace(rs.place(() => units as undefined, (value) => units = value))).length & 0xff); + (units === rs.None ? [] : rs.sliceOfPlace(rs.place(() => units as undefined, (value2) => units = value2))).fill(undefined); + rs.byteVecPush(out, units !== rs.None ? 1 : 0); } } } } /** Swaps the bytes of `o`'s payload, if any, through the slice of it. */ -export function swapHalves(o: rt.Place): void { - const iter: rt.Iter> = rt.iterSliceMut(o.v === undefined ? [] : rt.sliceOfPlace(rt.place(() => o.v as rt.u16, (value) => o.v = value))); +export function swapHalves(o: rs.Place): void { + const iter: rs.Iter> = rs.iterSliceMut(o.v === undefined ? [] : rs.sliceOfPlace(rs.place(() => o.v as rs.u16, (value) => o.v = value))); while (true) { - const _5: rt.Place | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.Place | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - _5.v = rt.intSwapBytes(_5.v, 16, false); + _5.v = rs.intSwapBytes(_5.v, 16, false); } } diff --git a/ts/fixtures/lang/results/src/results.rs b/ts/fixtures/lang/results/src/results.rs index 45414dcb1..5466ac505 100644 --- a/ts/fixtures/lang/results/src/results.rs +++ b/ts/fixtures/lang/results/src/results.rs @@ -143,7 +143,7 @@ fn owned(data: &[u8], out: &mut Vec) { flush(&log, out); } -/// Of `()`, which JS holds as `undefined`, so an `Option` of one is `rt.None`. +/// Of `()`, which JS holds as `undefined`, so an `Option` of one is `rs.None`. fn units(data: &[u8], out: &mut Vec) { let mut results: Vec> = data.iter().map(|&b| split(b).map(|_| ())).collect(); out.push(results.iter().flatten().count() as u8); @@ -296,7 +296,7 @@ pub fn option_slices(kind: u8, data: &[u8], out: &mut Vec) { out.extend(words.into_iter().flatten()); } _ => { - // Of `()`, whose `Option`'s `None` is `rt.None`. + // Of `()`, whose `Option`'s `None` is `rs.None`. let mut units: Option<()> = some(0).map(|_| ()); out.push(units.as_slice().len() as u8); out.push(units.as_mut_slice().len() as u8); diff --git a/ts/fixtures/lang/returns/expected/core/bool.ts b/ts/fixtures/lang/returns/expected/core/bool.ts index 1a9e3a0ff..2ee115912 100644 --- a/ts/fixtures/lang/returns/expected/core/bool.ts +++ b/ts/fixtures/lang/returns/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$0b23a33(self: boolean, t: rt.u16): rt.u16 | undefined { +export function thenSome$1gvhopg(self: boolean, t: rs.u16): rs.u16 | undefined { if (!self) { return undefined; } return t; } -export function then$0w2ymju(self: boolean, f: () => rt.ByteSlice): rt.ByteSlice | undefined { +export function then$0abhnvu(self: boolean, f: () => rs.ByteSlice): rs.ByteSlice | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/returns/expected/core/option.ts b/ts/fixtures/lang/returns/expected/core/option.ts index 639f43d91..d9ae0f18c 100644 --- a/ts/fixtures/lang/returns/expected/core/option.ts +++ b/ts/fixtures/lang/returns/expected/core/option.ts @@ -1,83 +1,83 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as returns_Error from "../returns.Error.ts"; -export function unwrapOr$06r8g1t(self: rt.i128 | undefined, default_: rt.i128): rt.i128 { +export function unwrapOr$12qj13x(self: rs.i128 | undefined, default_: rs.i128): rs.i128 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$1j4op5y(self: rt.u16 | undefined, default_: rt.u16): rt.u16 { +export function unwrapOr$1szdyfq(self: rs.u16 | undefined, default_: rs.u16): rs.u16 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0c2keyb(self: rt.ByteSlice | undefined, f: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { +export function map$0q6fk7x(self: rs.ByteSlice | undefined, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1yogfym(self: [rt.u8, rt.ByteSlice] | undefined, f: (a0: [rt.u8, rt.ByteSlice]) => rt.ByteSlice): rt.ByteSlice | undefined { +export function map$05uajnx(self: [rs.u8, rs.ByteSlice] | undefined, f: (a0: [rs.u8, rs.ByteSlice]) => rs.ByteSlice): rs.ByteSlice | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1cf8u0y(self: rt.u64 | undefined, f: (a0: rt.u64) => rt.u64): rt.u64 | undefined { +export function map$1haiqd3(self: rs.u64 | undefined, f: (a0: rs.u64) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$1surhce(self: rt.u8 | undefined, default_: rt.u8, f: (a0: rt.u8) => rt.u8): rt.u8 { +export function mapOr$0vxw5sq(self: rs.u8 | undefined, default_: rs.u8, f: (a0: rs.u8) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function okOr$1b6nkwr(self: rt.char | undefined, err: rt.u8): rt.Result { +export function okOr$19yb1mu(self: rs.char | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$12p77jh(self: rt.ByteSlice | undefined, err: returns_Error.Error): rt.Result { +export function okOr$0rfpk7i(self: rs.ByteSlice | undefined, err: returns_Error.Error): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$0gtm15y(self: rt.ByteSlice | undefined, err: rt.u8 | undefined): rt.Result { +export function okOr$0j0xd63(self: rs.ByteSlice | undefined, err: rs.u8 | undefined): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function okOr$0tezn0w(self: rt.ByteSlice | undefined, _: undefined): rt.Result { +export function okOr$1ylsdit(self: rs.ByteSlice | undefined, _: undefined): rs.Result { if (self === undefined) { - return rt.ERR; + return rs.ERR; } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/returns/expected/core/result.ts b/ts/fixtures/lang/returns/expected/core/result.ts index 4544fbf0b..41c681e4c 100644 --- a/ts/fixtures/lang/returns/expected/core/result.ts +++ b/ts/fixtures/lang/returns/expected/core/result.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as returns_Error from "../returns.Error.ts"; -export function eq$11dy112(self: rt.Result, other: rt.Result): boolean { +export function eq$14w6i0g(self: rs.Result, other: rs.Result): boolean { if (!((self.ok ? 0 : 1) === (other.ok ? 0 : 1))) { return false; } if (self.ok) { - return rt.eqOption(rt.u64Eq)(self.value, (other as { ok: true; value: rt.u64 | undefined }).value); + return rs.eqOption(rs.u64Eq)(self.value, (other as { ok: true; value: rs.u64 | undefined }).value); } return returns_Error.eq$cmp_PartialEq(self.error, (other as { ok: false; error: returns_Error.Error }).error); } -export function map$1rffkv6(self: rt.Result, _: (a0: rt.u32) => rt.u64): rt.Result { +export function map$1gzrj7d(self: rs.Result, _: (a0: rs.u32) => rs.u64): rs.Result { if (self.ok) { - return rt.Ok(self.value as rt.u64); + return rs.Ok(self.value as rs.u64); } - return self as rt.Result; + return self as rs.Result; } -export function mapOr$0fbyajt(self: rt.Result, default_: rt.usize, _: (a0: rt.ByteSlice) => rt.usize): rt.usize { +export function mapOr$1df1cdv(self: rs.Result, default_: rs.usize, _: (a0: rs.ByteSlice) => rs.usize): rs.usize { if (self.ok) { return self.value.length; } return default_; } -export function andThen$1yropo4(self: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, op: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.Result): rt.Result { +export function andThen$0ud0j7o(self: rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error>, op: (a0: [rs.ByteSlice, rs.ByteSlice]) => rs.Result): rs.Result { if (self.ok) { return op(self.value); } - return self as rt.Result; + return self as rs.Result; } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/returns/expected/harness.ts b/ts/fixtures/lang/returns/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/returns/expected/harness.ts +++ b/ts/fixtures/lang/returns/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/returns/expected/lib.ts b/ts/fixtures/lang/returns/expected/lib.ts index 68d138a7c..3b278490f 100644 --- a/ts/fixtures/lang/returns/expected/lib.ts +++ b/ts/fixtures/lang/returns/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { returns, options } from "./returns.ts"; import * as At from "./returns.At.ts"; import type * as returns_Error from "./returns.Error.ts"; @@ -12,54 +12,54 @@ export class of$returns_At { this.v = v; } - split$Split(a: rt.ByteSlice): rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> { + split$Split(a: rs.ByteSlice): rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error> { const err = At.split$returns_Split(this.v, a.data, a.start, a.length); - const result: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = err !== undefined ? rt.Err(err as returns_Error.Error) : rt.Ok([new rt.ByteSlice(out$tuple2_ref_slice_u8_ref_slice_u8.p_0Data, out$tuple2_ref_slice_u8_ref_slice_u8.p_0Start, out$tuple2_ref_slice_u8_ref_slice_u8.p_0Len), new rt.ByteSlice(out$tuple2_ref_slice_u8_ref_slice_u8.p_1Data, out$tuple2_ref_slice_u8_ref_slice_u8.p_1Start, out$tuple2_ref_slice_u8_ref_slice_u8.p_1Len)] as [rt.ByteSlice, rt.ByteSlice]); + const result: rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error> = err !== undefined ? rs.Err(err as returns_Error.Error) : rs.Ok([new rs.ByteSlice(out$tuple2_ref_slice_u8_ref_slice_u8.p_0Data, out$tuple2_ref_slice_u8_ref_slice_u8.p_0Start, out$tuple2_ref_slice_u8_ref_slice_u8.p_0Len), new rs.ByteSlice(out$tuple2_ref_slice_u8_ref_slice_u8.p_1Data, out$tuple2_ref_slice_u8_ref_slice_u8.p_1Start, out$tuple2_ref_slice_u8_ref_slice_u8.p_1Len)] as [rs.ByteSlice, rs.ByteSlice]); return result; } } export const out$Option_bool: { p: boolean | undefined } = { p: undefined as never }; -export const out$Option_char: { p: rt.char | undefined } = { p: undefined as never }; +export const out$Option_char: { p: rs.char | undefined } = { p: undefined as never }; -export const out$Option_f32: { p: rt.f32 | undefined } = { p: undefined as never }; +export const out$Option_f32: { p: rs.f32 | undefined } = { p: undefined as never }; -export const out$Option_f64: { p: rt.f64 | undefined } = { p: undefined as never }; +export const out$Option_f64: { p: rs.f64 | undefined } = { p: undefined as never }; -export const out$Option_i128: { p: rt.i128 | undefined } = { p: undefined as never }; +export const out$Option_i128: { p: rs.i128 | undefined } = { p: undefined as never }; -export const out$Option_i16: { p: rt.i16 | undefined } = { p: undefined as never }; +export const out$Option_i16: { p: rs.i16 | undefined } = { p: undefined as never }; -export const out$Option_i32: { p: rt.i32 | undefined } = { p: undefined as never }; +export const out$Option_i32: { p: rs.i32 | undefined } = { p: undefined as never }; -export const out$Option_i64: { p: rt.i64 | undefined } = { p: undefined as never }; +export const out$Option_i64: { p: rs.i64 | undefined } = { p: undefined as never }; -export const out$Option_i8: { p: rt.i8 | undefined } = { p: undefined as never }; +export const out$Option_i8: { p: rs.i8 | undefined } = { p: undefined as never }; -export const out$Option_u128: { p: rt.u128 | undefined } = { p: undefined as never }; +export const out$Option_u128: { p: rs.u128 | undefined } = { p: undefined as never }; -export const out$Option_u16: { p: rt.u16 | undefined } = { p: undefined as never }; +export const out$Option_u16: { p: rs.u16 | undefined } = { p: undefined as never }; -export const out$Option_u32: { p: rt.u32 | undefined } = { p: undefined as never }; +export const out$Option_u32: { p: rs.u32 | undefined } = { p: undefined as never }; -export const out$Option_u64: { p: rt.u64 | undefined } = { p: undefined as never }; +export const out$Option_u64: { p: rs.u64 | undefined } = { p: undefined as never }; -export const out$Option_u8: { p: rt.u8 | undefined } = { p: undefined as never }; +export const out$Option_u8: { p: rs.u8 | undefined } = { p: undefined as never }; -export const out$Option_usize: { p: rt.usize | undefined } = { p: undefined as never }; +export const out$Option_usize: { p: rs.usize | undefined } = { p: undefined as never }; export const out$bool: { p: boolean } = { p: undefined as never }; export const out$ref_slice_u8: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; -export const out$tuple2_Option_u16_ref_slice_u8: { p_0: rt.u16 | undefined; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; +export const out$tuple2_Option_u16_ref_slice_u8: { p_0: rs.u16 | undefined; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export const out$tuple2_Option_u8_u64: { p_0: rt.u8 | undefined; p_1: rt.u64 } = { p_0: undefined as never, p_1: undefined as never }; +export const out$tuple2_Option_u8_u64: { p_0: rs.u8 | undefined; p_1: rs.u64 } = { p_0: undefined as never, p_1: undefined as never }; -export const out$tuple2_f64_char: { err: unknown; p_1: rt.char } = { err: undefined, p_1: undefined as never }; +export const out$tuple2_f64_char: { err: unknown; p_1: rs.char } = { err: undefined, p_1: undefined as never }; -export const out$tuple2_i64_u64: { err: unknown; p_1: rt.u64 } = { err: undefined, p_1: undefined as never }; +export const out$tuple2_i64_u64: { err: unknown; p_1: rs.u64 } = { err: undefined, p_1: undefined as never }; export const out$tuple2_ref_slice_u8_ref_slice_u8: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; @@ -67,7 +67,7 @@ export const out$tuple2_u16_ref_slice_u8: { err: unknown; p_1Data: Uint8Array; p export const out$tuple2_u32_ref_slice_u8: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export const out$tuple2_u64_Option_i128: { err: unknown; p_1: rt.i128 | undefined } = { err: undefined, p_1: undefined as never }; +export const out$tuple2_u64_Option_i128: { err: unknown; p_1: rs.i128 | undefined } = { err: undefined, p_1: undefined as never }; export const out$tuple2_u64_ref_slice_u8: { err: unknown; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { err: undefined, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; @@ -75,7 +75,7 @@ export const out$tuple2_u8_ref_slice_u8: { err: unknown; p_1Data: Uint8Array; p_ export const out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; -export const out$tuple3_u64_u64_ref_slice_u8: { err: unknown; p_1: rt.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const out$tuple3_u64_u64_ref_slice_u8: { err: unknown; p_1: rs.u64; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; export const out$u32: { err: unknown } = { err: undefined }; @@ -87,8 +87,8 @@ export const out$u8: { err: unknown } = { err: undefined }; * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["returns::returns", returns as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["returns::options", options as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["returns::returns", returns as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["returns::options", options as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/returns/expected/returns.At.ts b/ts/fixtures/lang/returns/expected/returns.At.ts index 87011c46c..c3e0982f9 100644 --- a/ts/fixtures/lang/returns/expected/returns.At.ts +++ b/ts/fixtures/lang/returns/expected/returns.At.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$tuple2_ref_slice_u8_ref_slice_u8 } from "./lib.ts"; import type * as returns_Error from "./returns.Error.ts"; export interface At { - _0: rt.usize; + _0: rs.usize; } export function split$returns_Split(self: At, dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { diff --git a/ts/fixtures/lang/returns/expected/returns.Error.ts b/ts/fixtures/lang/returns/expected/returns.Error.ts index 2143f2c97..8d49411b3 100644 --- a/ts/fixtures/lang/returns/expected/returns.Error.ts +++ b/ts/fixtures/lang/returns/expected/returns.Error.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Error, other: Error): boolean { if (!({ Short: 0, Bad: 1 }[self.tag] === { Short: 0, Bad: 1 }[other.tag])) { @@ -14,9 +14,9 @@ export function eq$cmp_PartialEq(self: Error, other: Error): boolean { return true; } -export type Error = { tag: "Short"; _0: rt.usize } | { tag: "Bad" }; +export type Error = { tag: "Short"; _0: rs.usize } | { tag: "Bad" }; -export function code(self: Error): rt.u8 { +export function code(self: Error): rs.u8 { if (self.tag === "Short") { return self._0 & 0xff; } diff --git a/ts/fixtures/lang/returns/expected/returns.Guard.ts b/ts/fixtures/lang/returns/expected/returns.Guard.ts index 89527dc41..6b86e5db5 100644 --- a/ts/fixtures/lang/returns/expected/returns.Guard.ts +++ b/ts/fixtures/lang/returns/expected/returns.Guard.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$tuple2_u64_ref_slice_u8 } from "./lib.ts"; import { narrow } from "./returns.ts"; import type * as returns_Error from "./returns.Error.ts"; @@ -10,9 +10,9 @@ export class Guard { _0Data: Uint8Array; _0Start: number; _0Len: number; - _1: rt.u8; + _1: rs.u8; - constructor(_0Data: Uint8Array, _0Start: number, _0Len: number, _1: rt.u8) { + constructor(_0Data: Uint8Array, _0Start: number, _0Len: number, _1: rs.u8) { this._0Data = _0Data; this._0Start = _0Start; this._0Len = _0Len; @@ -25,7 +25,7 @@ export class Guard { } export function drop$ops_Drop(self: Guard): void { - const _3: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(self._0Data, self._0Start, self._0Len), rt.usizeRem(self._1 as rt.usize, 2)); + const _3: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(self._0Data, self._0Start, self._0Len), rs.usizeRem(self._1 as rs.usize, 2)); narrow(_3.data, _3.start, _3.length) === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; } diff --git a/ts/fixtures/lang/returns/expected/returns.Late.ts b/ts/fixtures/lang/returns/expected/returns.Late.ts index a93debba9..e86ed2189 100644 --- a/ts/fixtures/lang/returns/expected/returns.Late.ts +++ b/ts/fixtures/lang/returns/expected/returns.Late.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$u64 } from "./lib.ts"; import { big } from "./returns.ts"; import type * as returns_Error from "./returns.Error.ts"; @@ -23,7 +23,7 @@ export class Late { } export function drop$ops_Drop(self: Late): void { - big(new rt.ByteSlice(self._0Data, self._0Start, self._0Len)) === undefined ? out$u64.err as returns_Error.Error : undefined; + big(new rs.ByteSlice(self._0Data, self._0Start, self._0Len)) === undefined ? out$u64.err as returns_Error.Error : undefined; } //# sourceMappingURL=returns.Late.ts.map diff --git a/ts/fixtures/lang/returns/expected/returns.Split.ts b/ts/fixtures/lang/returns/expected/returns.Split.ts index 6c692959b..c4bad1371 100644 --- a/ts/fixtures/lang/returns/expected/returns.Split.ts +++ b/ts/fixtures/lang/returns/expected/returns.Split.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as returns_Error from "./returns.Error.ts"; export type Split = - | { split$Split: (a0: rt.ByteSlice) => rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> }; + | { split$Split: (a0: rs.ByteSlice) => rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error> }; //# sourceMappingURL=returns.Split.ts.map diff --git a/ts/fixtures/lang/returns/expected/returns.Wrapped.ts b/ts/fixtures/lang/returns/expected/returns.Wrapped.ts index 44694a899..7c56f80dd 100644 --- a/ts/fixtures/lang/returns/expected/returns.Wrapped.ts +++ b/ts/fixtures/lang/returns/expected/returns.Wrapped.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** An error converted from a residual of a slice and a byte. */ export interface Wrapped { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } -export function from$convert_From_tuple2_ref_slice_u8_u8(_1: [rt.ByteSlice, rt.u8]): Wrapped { - const n: rt.u8 = _1[1]; - return { _0: (_1[0].length & 0xff) ^ option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_1[0]), 90), _1: n }; +export function from$convert_From_tuple2_ref_slice_u8_u8(_1: [rs.ByteSlice, rs.u8]): Wrapped { + const n: rs.u8 = _1[1]; + return { _0: (_1[0].length & 0xff) ^ option_unwrapOr$1fr498u(rs.byteSliceFirst(_1[0]), 90), _1: n }; } //# sourceMappingURL=returns.Wrapped.ts.map diff --git a/ts/fixtures/lang/returns/expected/returns.ts b/ts/fixtures/lang/returns/expected/returns.ts index 8318f899d..c03b48118 100644 --- a/ts/fixtures/lang/returns/expected/returns.ts +++ b/ts/fixtures/lang/returns/expected/returns.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { of$returns_At, out$Option_bool, out$Option_char, out$Option_f32, out$Option_f64, out$Option_i128, out$Option_i16, out$Option_i32, out$Option_i64, out$Option_i8, out$Option_u128, out$Option_u16, out$Option_u32, out$Option_u64, out$Option_u8, out$Option_usize, out$bool, out$ref_slice_u8, out$tuple2_Option_u16_ref_slice_u8, out$tuple2_Option_u8_u64, out$tuple2_f64_char, out$tuple2_i64_u64, out$tuple2_ref_slice_u8_ref_slice_u8, out$tuple2_u16_ref_slice_u8, out$tuple2_u32_ref_slice_u8, out$tuple2_u64_Option_i128, out$tuple2_u64_ref_slice_u8, out$tuple2_u8_ref_slice_u8, out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8, out$tuple3_u64_u64_ref_slice_u8, out$u32, out$u64, out$u8 } from "./lib.ts"; -import { thenSome$0b23a33, then$0w2ymju } from "./core/bool.ts"; -import { unwrapOr$06r8g1t as option_unwrapOr$06r8g1t, unwrapOr$1j4op5y as option_unwrapOr$1j4op5y, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0c2keyb as option_map$0c2keyb, map$1yogfym as option_map$1yogfym, map$1cf8u0y as option_map$1cf8u0y, mapOr$1surhce as option_mapOr$1surhce, okOr$1b6nkwr as option_okOr$1b6nkwr, okOr$12p77jh as option_okOr$12p77jh, okOr$0gtm15y as option_okOr$0gtm15y, okOr$0tezn0w as option_okOr$0tezn0w } from "./core/option.ts"; -import { eq$11dy112 as result_eq$11dy112, map$1rffkv6 as result_map$1rffkv6, mapOr$0fbyajt as result_mapOr$0fbyajt, andThen$1yropo4 as result_andThen$1yropo4 } from "./core/result.ts"; +import { thenSome$1gvhopg, then$0abhnvu } from "./core/bool.ts"; +import { unwrapOr$12qj13x as option_unwrapOr$12qj13x, unwrapOr$1szdyfq as option_unwrapOr$1szdyfq, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0q6fk7x as option_map$0q6fk7x, map$05uajnx as option_map$05uajnx, map$1haiqd3 as option_map$1haiqd3, mapOr$0vxw5sq as option_mapOr$0vxw5sq, okOr$19yb1mu as option_okOr$19yb1mu, okOr$0rfpk7i as option_okOr$0rfpk7i, okOr$0j0xd63 as option_okOr$0j0xd63, okOr$1ylsdit as option_okOr$1ylsdit } from "./core/option.ts"; +import { eq$14w6i0g as result_eq$14w6i0g, map$1gzrj7d as result_map$1gzrj7d, mapOr$1df1cdv as result_mapOr$1df1cdv, andThen$0ud0j7o as result_andThen$0ud0j7o } from "./core/result.ts"; import * as At from "./returns.At.ts"; import * as returns_Error from "./returns.Error.ts"; import * as Guard from "./returns.Guard.ts"; @@ -13,10 +13,10 @@ import * as Opted from "./returns.Opted.ts"; import * as Wrapped from "./returns.Wrapped.ts"; /** A slice alone, with returns from several places. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): returns_Error.Error | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rs.usize): returns_Error.Error | undefined { if (!(n > 200)) { if (!(n <= dataLen)) { - return { tag: "Short", _0: rt.usizeSub(n, dataLen) } as returns_Error.Error; + return { tag: "Short", _0: rs.usizeSub(n, dataLen) } as returns_Error.Error; } out$ref_slice_u8.pData = dataData; out$ref_slice_u8.pStart = dataStart; @@ -27,14 +27,14 @@ export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n } /** The same slice type through another function, which shares its slot. */ -export function tail(data: rt.ByteSlice, n: rt.usize): returns_Error.Error | undefined { - const _0: rt.Result = option_okOr$12p77jh(then$0w2ymju(n <= data.length, (): rt.ByteSlice => { - return rt.byteSliceRange(data, n); +export function tail(data: rs.ByteSlice, n: rs.usize): returns_Error.Error | undefined { + const _0: rs.Result = option_okOr$0rfpk7i(then$0abhnvu(n <= data.length, (): rs.ByteSlice => { + return rs.byteSliceRange(data, n); }), { tag: "Short", _0: n } as returns_Error.Error); if (!_0.ok) { return _0.error; } - const slice: rt.ByteSlice = _0.value; + const slice: rs.ByteSlice = _0.value; out$ref_slice_u8.pData = slice.data; out$ref_slice_u8.pStart = slice.start; out$ref_slice_u8.pLen = slice.length; @@ -42,9 +42,9 @@ export function tail(data: rt.ByteSlice, n: rt.usize): returns_Error.Error | und } /** A number past 2^31 and the rest. */ -export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { +export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { if (dataLen >= 8) { - const _11_0: rt.u64 = rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(dataData, dataStart, 8))); + const _11_0: rs.u64 = rs.u64FromBeBytes(rs.byteSliceToArray(new rs.ByteSlice(dataData, dataStart, 8))); out$tuple2_u64_ref_slice_u8.p_1Data = dataData; out$tuple2_u64_ref_slice_u8.p_1Start = dataStart + 8; out$tuple2_u64_ref_slice_u8.p_1Len = dataLen - 8; @@ -54,9 +54,9 @@ export function wide(dataData: Uint8Array, dataStart: number, dataLen: number): return undefined; } -export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { +export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { if (dataLen !== 0) { - const b: rt.u8 = dataData[dataStart]; + const b: rs.u8 = dataData[dataStart]; if (b === 255) { out$tuple2_u64_ref_slice_u8.err = { tag: "Bad" } as returns_Error.Error; return undefined; @@ -64,14 +64,14 @@ export function narrow(dataData: Uint8Array, dataStart: number, dataLen: number) out$tuple2_u64_ref_slice_u8.p_1Data = dataData; out$tuple2_u64_ref_slice_u8.p_1Start = dataStart + 1; out$tuple2_u64_ref_slice_u8.p_1Len = dataLen - 1; - return b as rt.u64; + return b as rs.u64; } out$tuple2_u64_ref_slice_u8.err = { tag: "Short", _0: 1 } as returns_Error.Error; return undefined; } /** What either returns, returned as is. */ -export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): rt.u64 | undefined { +export function number(dataData: Uint8Array, dataStart: number, dataLen: number, wide_: boolean): rs.u64 | undefined { if (!wide_) { return narrow(dataData, dataStart, dataLen); } @@ -79,7 +79,7 @@ export function number(dataData: Uint8Array, dataStart: number, dataLen: number, } /** Each byte before a zero counted, recursively. */ -export function count(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { +export function count(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { if (dataLen === 0) { out$tuple2_u64_ref_slice_u8.err = { tag: "Short", _0: 1 } as returns_Error.Error; return undefined; @@ -90,13 +90,13 @@ export function count(dataData: Uint8Array, dataStart: number, dataLen: number): out$tuple2_u64_ref_slice_u8.p_1Len = dataLen - 1; return 0; } - const part: rt.u64 | undefined = count(dataData, dataStart + 1, dataLen - 1); + const part: rs.u64 | undefined = count(dataData, dataStart + 1, dataLen - 1); const err: returns_Error.Error | undefined = part === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part2: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part3: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part4: number = out$tuple2_u64_ref_slice_u8.p_1Len; if (err === undefined) { - const _14_0: rt.u64 = rt.u64Add(part as rt.u64, 1); + const _14_0: rs.u64 = rs.u64Add(part as rs.u64, 1); out$tuple2_u64_ref_slice_u8.p_1Data = part2; out$tuple2_u64_ref_slice_u8.p_1Start = part3; out$tuple2_u64_ref_slice_u8.p_1Len = part4; @@ -107,11 +107,11 @@ export function count(dataData: Uint8Array, dataStart: number, dataLen: number): } /** Two slices, and a reference to an array. */ -export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function halves(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 | undefined { if (dataLen >= 2) { - const mid: number = rt.usizeDiv(dataLen - 2, 2); + const mid: number = rs.usizeDiv(dataLen - 2, 2); if (mid > dataLen - 2) { - rt.panic("mid > len"); + rs.panic("mid > len"); } out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_0Data = dataData; out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_0Start = dataStart + 2; @@ -128,30 +128,30 @@ export function halves(dataData: Uint8Array, dataStart: number, dataLen: number) } /** Calls whose results are both held while the slot is written again between them. */ -export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { - const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); +export function both(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { + const part: rs.u64 | undefined = narrow(dataData, dataStart, dataLen); const err: returns_Error.Error | undefined = part === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part2: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part3: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part4: number = out$tuple2_u64_ref_slice_u8.p_1Len; if (err === undefined) { - const a: rt.u64 = part as rt.u64; - const part5: rt.u64 | undefined = number(part2, part3, part4, rt.u64Rem(a, 2) === 1); + const a: rs.u64 = part as rs.u64; + const part5: rs.u64 | undefined = number(part2, part3, part4, rs.u64Rem(a, 2) === 1); const err2: returns_Error.Error | undefined = part5 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part6: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part7: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part8: number = out$tuple2_u64_ref_slice_u8.p_1Len; if (err2 === undefined) { - const b: rt.u64 = part5 as rt.u64; - const err3: returns_Error.Error | undefined = tail(new rt.ByteSlice(part6, part7, part8), rt.u64Low(rt.u64Rem(a, 3))); + const b: rs.u64 = part5 as rs.u64; + const err3: returns_Error.Error | undefined = tail(new rs.ByteSlice(part6, part7, part8), rs.u64Low(rs.u64Rem(a, 3))); const part9: Uint8Array = out$ref_slice_u8.pData; const part10: number = out$ref_slice_u8.pStart; const part11: number = out$ref_slice_u8.pLen; if (err3 === undefined) { - const err4: returns_Error.Error | undefined = take(part9, part10, part11, rt.u64Low(rt.u64Rem(b, 4))); + const err4: returns_Error.Error | undefined = take(part9, part10, part11, rs.u64Low(rs.u64Rem(b, 4))); const part14: number = out$ref_slice_u8.pLen; if (err4 === undefined) { - out$tuple3_u64_u64_ref_slice_u8.p_1 = rt.u64Xor(b, part14 as rt.u64); + out$tuple3_u64_u64_ref_slice_u8.p_1 = rs.u64Xor(b, part14 as rs.u64); out$tuple3_u64_u64_ref_slice_u8.p_2Data = part9; out$tuple3_u64_u64_ref_slice_u8.p_2Start = part10; out$tuple3_u64_u64_ref_slice_u8.p_2Len = part11; @@ -170,8 +170,8 @@ export function both(dataData: Uint8Array, dataStart: number, dataLen: number): return undefined; } -export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, other: rt.ByteSlice): rt.u64 | undefined { - const part: rt.u64 | undefined = narrow(dataData, dataStart, dataLen); +export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number, other: rs.ByteSlice): rs.u64 | undefined { + const part: rs.u64 | undefined = narrow(dataData, dataStart, dataLen); const err: returns_Error.Error | undefined = part === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part2: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part3: number = out$tuple2_u64_ref_slice_u8.p_1Start; @@ -184,34 +184,34 @@ export function guarded(dataData: Uint8Array, dataStart: number, dataLen: number out$tuple2_u64_ref_slice_u8.p_1Data = part2; out$tuple2_u64_ref_slice_u8.p_1Start = part3; out$tuple2_u64_ref_slice_u8.p_1Len = part4; - return part as rt.u64; + return part as rs.u64; } /** Errors that are no single value: `()`, and an `Option`. */ -export function unitErr(dataData: Uint8Array, dataStart: number, dataLen: number): rt.Result { - return option_okOr$0tezn0w(option_map$1yogfym((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { +export function unitErr(dataData: Uint8Array, dataStart: number, dataLen: number): rs.Result { + return option_okOr$1ylsdit(option_map$05uajnx((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, (_22: [rs.u8, rs.ByteSlice]): rs.ByteSlice => { return _22[1]; }), undefined); } -export function noneErr(data: rt.ByteSlice): rt.Result { - const _2: rt.u8 | undefined = rt.byteSliceFirst(data); +export function noneErr(data: rs.ByteSlice): rs.Result { + const _2: rs.u8 | undefined = rs.byteSliceFirst(data); if (_2 !== undefined) { if (_2 === 0) { - return rt.ERR; + return rs.ERR; } if (_2 > 240) { - return rt.Err(_2); + return rs.Err(_2); } } - return option_okOr$0gtm15y(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_22: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + return option_okOr$0j0xd63(option_map$05uajnx((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, (_22: [rs.u8, rs.ByteSlice]): rs.ByteSlice => { return _22[1]; - }), undefined as rt.u8 | undefined); + }), undefined as rs.u8 | undefined); } -export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u16 | undefined { +export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u16 | undefined { if (dataLen !== 0) { - const _11_0: rt.u16 = dataData[dataStart] as rt.u16; + const _11_0: rs.u16 = dataData[dataStart] as rs.u16; out$tuple2_u16_ref_slice_u8.p_1Data = dataData; out$tuple2_u16_ref_slice_u8.p_1Start = dataStart + 1; out$tuple2_u16_ref_slice_u8.p_1Len = dataLen - 1; @@ -221,9 +221,9 @@ export function lead$u16(dataData: Uint8Array, dataStart: number, dataLen: numbe return undefined; } -export function lead$u32(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 | undefined { +export function lead$u32(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u32 | undefined { if (dataLen !== 0) { - const _11_0: rt.u32 = dataData[dataStart] as rt.u32; + const _11_0: rs.u32 = dataData[dataStart] as rs.u32; out$tuple2_u32_ref_slice_u8.p_1Data = dataData; out$tuple2_u32_ref_slice_u8.p_1Start = dataStart + 1; out$tuple2_u32_ref_slice_u8.p_1Len = dataLen - 1; @@ -237,27 +237,27 @@ export function splitWith$returns_At(s: At.At, dataData: Uint8Array, dataStart: return At.split$returns_Split(s, dataData, dataStart, dataLen); } -export function push(out: rt.ByteVec, r: rt.Result): void { +export function push(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { - rt.byteVecPush(out, r.value.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceRange(r.value, 0, rt.min(r.value.length, 4))); + rs.byteVecPush(out, r.value.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceRange(r.value, 0, rs.min(r.value.length, 4))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); } } -export function pushNumber(out: rt.ByteVec, r: rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>): void { +export function pushNumber(out: rs.ByteVec, r: rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>): void { if (r.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(r.value[0]))); - rt.byteVecPush(out, r.value[1].length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(r.value[0]))); + rs.byteVecPush(out, r.value[1].length & 0xff); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); } } /** A slice that takes no argument. */ export function fixed(): returns_Error.Error | undefined { - const slice: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(97, 98, 99)); + const slice: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(97, 98, 99)); out$ref_slice_u8.pData = slice.data; out$ref_slice_u8.pStart = slice.start; out$ref_slice_u8.pLen = slice.length; @@ -271,7 +271,7 @@ export function afterFixed(_dataData: Uint8Array, _dataStart: number, dataLen: n const part2: number = out$ref_slice_u8.pStart; const part3: number = out$ref_slice_u8.pLen; if (err === undefined) { - const slice2: rt.ByteSlice = rt.byteSliceRange(new rt.ByteSlice(part, part2, part3), 0, rt.min(dataLen, part3)); + const slice2: rs.ByteSlice = rs.byteSliceRange(new rs.ByteSlice(part, part2, part3), 0, rs.min(dataLen, part3)); out$ref_slice_u8.pData = slice2.data; out$ref_slice_u8.pStart = slice2.start; out$ref_slice_u8.pLen = slice2.length; @@ -281,73 +281,73 @@ export function afterFixed(_dataData: Uint8Array, _dataStart: number, dataLen: n } /** `?` on a residual whose error is a slice and a byte, converted. */ -export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function wrapped(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 | undefined { let rErr!: boolean; - let r2!: rt.u8; + let r2!: rs.u8; let r_0Data!: Uint8Array; let r_0Start!: number; let r_0Len!: number; - let r_1!: rt.u8; + let r_1!: rs.u8; if (dataLen === 0) { rErr = true; r_0Data = dataData; r_0Start = dataStart; r_0Len = dataLen; r_1 = 0; - } else if (!(rt.u8Rem(dataData[dataStart], 2) === 0)) { - const _12_1: rt.u8 = dataData[dataStart]; + } else if (!(rs.u8Rem(dataData[dataStart], 2) === 0)) { + const _12_1: rs.u8 = dataData[dataStart]; rErr = true; r_0Data = dataData; r_0Start = dataStart + 1; r_0Len = dataLen - 1; r_1 = _12_1; } else { - const b: rt.u8 = dataData[dataStart]; + const b: rs.u8 = dataData[dataStart]; rErr = false; r2 = b; } const _15Err: boolean = rErr; - const _152: rt.u8 = r2; + const _152: rs.u8 = r2; const _15_0Data: Uint8Array = r_0Data; const _15_0Start: number = r_0Start; const _15_0Len: number = r_0Len; - const _15_1: rt.u8 = r_1; + const _15_1: rs.u8 = r_1; if (!_15Err) { - const _19_0: rt.u8 = _152; + const _19_0: rs.u8 = _152; out$tuple2_u8_ref_slice_u8.p_1Data = dataData; out$tuple2_u8_ref_slice_u8.p_1Start = dataStart; out$tuple2_u8_ref_slice_u8.p_1Len = dataLen; return _19_0; } - out$tuple2_u8_ref_slice_u8.err = Wrapped.from$convert_From_tuple2_ref_slice_u8_u8([new rt.ByteSlice(_15_0Data, _15_0Start, _15_0Len), _15_1]); + out$tuple2_u8_ref_slice_u8.err = Wrapped.from$convert_From_tuple2_ref_slice_u8_u8([new rs.ByteSlice(_15_0Data, _15_0Start, _15_0Len), _15_1]); return undefined; } /** A number alone, past 2^53 from eight bytes. */ -export function big(data: rt.ByteSlice): rt.u64 | undefined { +export function big(data: rs.ByteSlice): rs.u64 | undefined { if (!(data.length >= 8)) { - if (!(rt.byteSliceFirst(data) === 255)) { - out$u64.err = { tag: "Short", _0: rt.usizeSub(8, data.length) } as returns_Error.Error; + if (!(rs.byteSliceFirst(data) === 255)) { + out$u64.err = { tag: "Short", _0: rs.usizeSub(8, data.length) } as returns_Error.Error; return undefined; } out$u64.err = { tag: "Bad" } as returns_Error.Error; return undefined; } - return rt.u64FromBeBytes(rt.byteSliceToArray(new rt.ByteSlice(data.data, data.start, 8))); + return rs.u64FromBeBytes(rs.byteSliceToArray(new rs.ByteSlice(data.data, data.start, 8))); } /** A signed number and an unsigned one, each through `?`, at an offset. */ -export function pair(data: rt.ByteSlice, at: rt.usize): rt.i64 | undefined { - const _3: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(data, at), { tag: "Short", _0: at } as returns_Error.Error); +export function pair(data: rs.ByteSlice, at: rs.usize): rs.i64 | undefined { + const _3: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(data, at), { tag: "Short", _0: at } as returns_Error.Error); if (_3.ok) { - const part: rt.u64 | undefined = big(_3.value); + const part: rs.u64 | undefined = big(_3.value); const err: returns_Error.Error | undefined = part === undefined ? out$u64.err as returns_Error.Error : undefined; if (err === undefined) { - const _18: rt.i64 = rt.intWrappingNeg(rt.i64Cast(part as rt.u64), 64, true); - const part3: rt.u64 | undefined = big(rt.byteSliceRange(_3.value, rt.min(_3.value.length, 3))); + const _18: rs.i64 = rs.intWrappingNeg(rs.i64Cast(part as rs.u64), 64, true); + const part3: rs.u64 | undefined = big(rs.byteSliceRange(_3.value, rs.min(_3.value.length, 3))); const err2: returns_Error.Error | undefined = part3 === undefined ? out$u64.err as returns_Error.Error : undefined; if (err2 === undefined) { - const tuple: [rt.i64, rt.u64] = [_18, rt.u64Shr(part3 as rt.u64, 3)]; + const tuple: [rs.i64, rs.u64] = [_18, rs.u64Shr(part3 as rs.u64, 3)]; out$tuple2_i64_u64.p_1 = tuple[1]; return tuple[0]; } @@ -363,12 +363,12 @@ export function pair(data: rt.ByteSlice, at: rt.usize): rt.i64 | undefined { /** A flag, which is no number to return, so it goes in the slot. */ export function odd(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { - const part: rt.u64 | undefined = big(new rt.ByteSlice(dataData, dataStart, dataLen)); + const part: rs.u64 | undefined = big(new rs.ByteSlice(dataData, dataStart, dataLen)); const err: returns_Error.Error | undefined = part === undefined ? out$u64.err as returns_Error.Error : undefined; if (err === undefined) { - const n: rt.u64 = part as rt.u64; + const n: rs.u64 = part as rs.u64; if (!(n === 7)) { - out$bool.p = rt.u64Rem(n, 2) === 1; + out$bool.p = rs.u64Rem(n, 2) === 1; return undefined; } return { tag: "Short", _0: 7 } as returns_Error.Error; @@ -377,8 +377,8 @@ export function odd(dataData: Uint8Array, dataStart: number, dataLen: number): r } /** A number whose error is a number too. */ -export function byte(data: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { - const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); +export function byte(data: rs.ByteSlice, i: rs.usize): rs.u8 | undefined { + const _3: rs.u8 | undefined = rs.byteSliceGet(data, i); if (_3 === undefined) { out$u8.err = i & 0xff; return undefined; @@ -391,32 +391,32 @@ export function byte(data: rt.ByteSlice, i: rt.usize): rt.u8 | undefined { } /** A float and a char. */ -export function mixed(dataData: Uint8Array, dataStart: number, dataLen: number): rt.f64 | undefined { - const part: rt.u8 | undefined = byte(new rt.ByteSlice(dataData, dataStart, dataLen), 0); - const err: rt.u8 | undefined = part === undefined ? out$u8.err as rt.u8 : undefined; +export function mixed(dataData: Uint8Array, dataStart: number, dataLen: number): rs.f64 | undefined { + const part: rs.u8 | undefined = byte(new rs.ByteSlice(dataData, dataStart, dataLen), 0); + const err: rs.u8 | undefined = part === undefined ? out$u8.err as rs.u8 : undefined; if (err === undefined) { - const b: rt.u8 = part as rt.u8; - const part2: rt.u8 | undefined = byte(new rt.ByteSlice(dataData, dataStart, dataLen), 1); - const err2: rt.u8 | undefined = part2 === undefined ? out$u8.err as rt.u8 : undefined; + const b: rs.u8 = part as rs.u8; + const part2: rs.u8 | undefined = byte(new rs.ByteSlice(dataData, dataStart, dataLen), 1); + const err2: rs.u8 | undefined = part2 === undefined ? out$u8.err as rs.u8 : undefined; if (err2 === undefined) { - const _7: rt.Result = option_okOr$1b6nkwr(rt.charFromU32(rt.u32Add(rt.u32Mul((part2 as rt.u8) as rt.u32, 37), 55280)), b); + const _7: rs.Result = option_okOr$19yb1mu(rs.charFromU32(rs.u32Add(rs.u32Mul((part2 as rs.u8) as rs.u32, 37), 55280)), b); if (_7.ok) { - const tuple: [rt.f64, rt.char] = [-(b as rt.f64) / 3.0, _7.value]; + const tuple: [rs.f64, rs.char] = [-(b as rs.f64) / 3.0, _7.value]; out$tuple2_f64_char.p_1 = tuple[1]; return tuple[0]; } - out$tuple2_f64_char.err = (_7 as { ok: false; error: rt.u8 }).error; + out$tuple2_f64_char.err = (_7 as { ok: false; error: rs.u8 }).error; return undefined; } - out$tuple2_f64_char.err = err2 as rt.u8; + out$tuple2_f64_char.err = err2 as rs.u8; return undefined; } - out$tuple2_f64_char.err = err as rt.u8; + out$tuple2_f64_char.err = err as rs.u8; return undefined; } /** Each byte before a zero counted, recursively, without the rest. */ -export function depth(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u32 | undefined { +export function depth(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u32 | undefined { if (dataLen === 0) { out$u32.err = { tag: "Short", _0: 1 } as returns_Error.Error; return undefined; @@ -424,28 +424,28 @@ export function depth(dataData: Uint8Array, dataStart: number, dataLen: number): if (dataData[dataStart] === 0) { return 0; } - const part: rt.u32 | undefined = depth(dataData, dataStart + 1, dataLen - 1); + const part: rs.u32 | undefined = depth(dataData, dataStart + 1, dataLen - 1); const err: returns_Error.Error | undefined = part === undefined ? out$u32.err as returns_Error.Error : undefined; if (err === undefined) { - return rt.u32Add(part as rt.u32, 1); + return rs.u32Add(part as rs.u32, 1); } out$u32.err = err as returns_Error.Error; return undefined; } /** What either returns, returned as is. */ -export function either(data: rt.ByteSlice, first: boolean): rt.u64 | undefined { - let _0!: rt.Result; +export function either(data: rs.ByteSlice, first: boolean): rs.u64 | undefined { + let _0!: rs.Result; if (!first) { - const part: rt.u32 | undefined = depth(data.data, data.start, data.length); + const part: rs.u32 | undefined = depth(data.data, data.start, data.length); const err: returns_Error.Error | undefined = part === undefined ? out$u32.err as returns_Error.Error : undefined; - _0 = result_map$1rffkv6((err !== undefined ? rt.Err(err as returns_Error.Error) : rt.Ok(part as rt.u32)) as rt.Result, (a0: rt.u32): rt.u64 => { - return a0 as rt.u64; + _0 = result_map$1gzrj7d((err !== undefined ? rs.Err(err as returns_Error.Error) : rs.Ok(part as rs.u32)) as rs.Result, (a0: rs.u32): rs.u64 => { + return a0 as rs.u64; }); } else { return big(data); } - const result: rt.Result = _0; + const result: rs.Result = _0; if (!result.ok) { out$u64.err = result.error; return undefined; @@ -453,26 +453,26 @@ export function either(data: rt.ByteSlice, first: boolean): rt.u64 | undefined { return result.value; } -export function late(dataData: Uint8Array, dataStart: number, dataLen: number, other: rt.ByteSlice): rt.u64 | undefined { - const part: rt.u64 | undefined = big(new rt.ByteSlice(dataData, dataStart, dataLen)); +export function late(dataData: Uint8Array, dataStart: number, dataLen: number, other: rs.ByteSlice): rs.u64 | undefined { + const part: rs.u64 | undefined = big(new rs.ByteSlice(dataData, dataStart, dataLen)); const err: returns_Error.Error | undefined = part === undefined ? out$u64.err as returns_Error.Error : undefined; new Late.Late(other.data, other.start, other.length)[Symbol.dispose](); if (err !== undefined) { out$u64.err = err as returns_Error.Error; return undefined; } - return part as rt.u64; + return part as rs.u64; } -export function lateSelf(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { - return late(dataData, dataStart, dataLen, new rt.ByteSlice(dataData, dataStart, dataLen)); +export function lateSelf(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { + return late(dataData, dataStart, dataLen, new rs.ByteSlice(dataData, dataStart, dataLen)); } -export function pushBig(out: rt.ByteVec, r: rt.Result): void { +export function pushBig(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(r.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(r.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); } } @@ -480,87 +480,87 @@ export function pushBig(out: rt.ByteVec, r: rt.Result rt.Result; - const part: rt.u64 | undefined = big(data); +export function numbers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: (a0: rs.ByteSlice) => rs.Result; + const part: rs.u64 | undefined = big(data); const err: returns_Error.Error | undefined = part === undefined ? out$u64.err as returns_Error.Error : undefined; - pushBig(out, (err !== undefined ? rt.Err(err as returns_Error.Error) : rt.Ok(part as rt.u64)) as rt.Result); - const part2: rt.i64 | undefined = pair(data, rt.usizeRem(kind as rt.usize, 4)); + pushBig(out, (err !== undefined ? rs.Err(err as returns_Error.Error) : rs.Ok(part as rs.u64)) as rs.Result); + const part2: rs.i64 | undefined = pair(data, rs.usizeRem(kind as rs.usize, 4)); const err2: returns_Error.Error | undefined = part2 === undefined ? out$tuple2_i64_u64.err as returns_Error.Error : undefined; - const part3: rt.u64 = out$tuple2_i64_u64.p_1; + const part3: rs.u64 = out$tuple2_i64_u64.p_1; if (err2 === undefined) { - const a: rt.i64 = part2 as rt.i64; - const b: rt.u64 = part3; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(a))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); + const a: rs.i64 = part2 as rs.i64; + const b: rs.u64 = part3; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(a))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(b))); } else { - rt.byteVecPush(out, returns_Error.code(err2 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err2 as returns_Error.Error)); } const err3: returns_Error.Error | undefined = odd(data.data, data.start, data.length); const part4: boolean = out$bool.p; if (err3 === undefined) { - rt.byteVecPush(out, part4 ? 1 : 0); + rs.byteVecPush(out, part4 ? 1 : 0); } else { - rt.byteVecPush(out, returns_Error.code(err3 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err3 as returns_Error.Error)); } - const part5: rt.u64 | undefined = big(data); + const part5: rs.u64 | undefined = big(data); const err4: returns_Error.Error | undefined = part5 === undefined ? out$u64.err as returns_Error.Error : undefined; - const part7: rt.u64 | undefined = big(rt.byteSliceRange(data, rt.min(data.length, 1))); + const part7: rs.u64 | undefined = big(rs.byteSliceRange(data, rs.min(data.length, 1))); const err5: returns_Error.Error | undefined = part7 === undefined ? out$u64.err as returns_Error.Error : undefined; b2: { if (err4 === undefined) { if (err5 === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Xor(part5 as rt.u64, part7 as rt.u64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64Xor(part5 as rs.u64, part7 as rs.u64)))); break b2; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err4 !== undefined ? rt.Err(err4 as returns_Error.Error) : rt.Ok(part5 as rt.u64)) as rt.Result).ok ? 1 : 0, ((err5 !== undefined ? rt.Err(err5 as returns_Error.Error) : rt.Ok(part7 as rt.u64)) as rt.Result).ok ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(((err4 !== undefined ? rs.Err(err4 as returns_Error.Error) : rs.Ok(part5 as rs.u64)) as rs.Result).ok ? 1 : 0, ((err5 !== undefined ? rs.Err(err5 as returns_Error.Error) : rs.Ok(part7 as rs.u64)) as rs.Result).ok ? 1 : 0))); } - for (const _67 of rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (i: rt.usize): rt.Result => { - const part9 = big(rt.byteSliceRange(data, rt.min(data.length, i))); - return part9 === undefined ? rt.Err(out$u64.err as returns_Error.Error) : rt.Ok(part9); + for (const _67 of rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (i: rs.usize): rs.Result => { + const part9 = big(rs.byteSliceRange(data, rs.min(data.length, i))); + return part9 === undefined ? rs.Err(out$u64.err as returns_Error.Error) : rs.Ok(part9); }), undefined, 16, true).items) { pushBig(out, _67); } - if (!(rt.u8Rem(kind, 2) === 0)) { - f = (a02: rt.ByteSlice): rt.Result => { + if (!(rs.u8Rem(kind, 2) === 0)) { + f = (a02: rs.ByteSlice): rs.Result => { const part11 = lateSelf(a02.data, a02.start, a02.length); - return part11 === undefined ? rt.Err(out$u64.err as returns_Error.Error) : rt.Ok(part11); + return part11 === undefined ? rs.Err(out$u64.err as returns_Error.Error) : rs.Ok(part11); }; } else { - f = (a0: rt.ByteSlice): rt.Result => { + f = (a0: rs.ByteSlice): rs.Result => { const part10 = big(a0); - return part10 === undefined ? rt.Err(out$u64.err as returns_Error.Error) : rt.Ok(part10); + return part10 === undefined ? rs.Err(out$u64.err as returns_Error.Error) : rs.Ok(part10); }; } pushBig(out, f(data)); - const part12: rt.u64 | undefined = either(data, rt.u8Rem(kind, 3) === 0); + const part12: rs.u64 | undefined = either(data, rs.u8Rem(kind, 3) === 0); const err6: returns_Error.Error | undefined = part12 === undefined ? out$u64.err as returns_Error.Error : undefined; - pushBig(out, (err6 !== undefined ? rt.Err(err6 as returns_Error.Error) : rt.Ok(part12 as rt.u64)) as rt.Result); - const _86: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 2)); - const part14: rt.u64 | undefined = late(data.data, data.start, data.length, _86); + pushBig(out, (err6 !== undefined ? rs.Err(err6 as returns_Error.Error) : rs.Ok(part12 as rs.u64)) as rs.Result); + const _86: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 2)); + const part14: rs.u64 | undefined = late(data.data, data.start, data.length, _86); const err7: returns_Error.Error | undefined = part14 === undefined ? out$u64.err as returns_Error.Error : undefined; - pushBig(out, (err7 !== undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok(part14 as rt.u64)) as rt.Result); - const part15: rt.f64 | undefined = mixed(data.data, data.start, data.length); - const err8: rt.u8 | undefined = part15 === undefined ? out$tuple2_f64_char.err as rt.u8 : undefined; - const part16: rt.char = out$tuple2_f64_char.p_1; + pushBig(out, (err7 !== undefined ? rs.Err(err7 as returns_Error.Error) : rs.Ok(part14 as rs.u64)) as rs.Result); + const part15: rs.f64 | undefined = mixed(data.data, data.start, data.length); + const err8: rs.u8 | undefined = part15 === undefined ? out$tuple2_f64_char.err as rs.u8 : undefined; + const part16: rs.char = out$tuple2_f64_char.p_1; if (err8 === undefined) { - const f2: rt.f64 = part15 as rt.f64; - const c: rt.char = part16; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(f2)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(c as rt.u32))); + const f2: rs.f64 = part15 as rs.f64; + const c: rs.char = part16; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(f2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(c as rs.u32))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, err8 as rt.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, err8 as rs.u8))); } - let rest: rt.ByteSlice = data; - let sum: rt.u64 = 0; + let rest: rs.ByteSlice = data; + let sum: rs.u64 = 0; while (true) { - const _112: rt.ByteSlice = rest; - const part17: rt.u32 | undefined = depth(_112.data, _112.start, _112.length); + const _112: rs.ByteSlice = rest; + const part17: rs.u32 | undefined = depth(_112.data, _112.start, _112.length); if ((part17 === undefined ? out$u32.err as returns_Error.Error : undefined) === undefined) { - const n: rt.u32 = part17 as rt.u32; - sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), n as rt.u64); - rest = rt.byteSliceRange(rest, rt.usizeAdd(n as rt.usize, 1)); + const n: rs.u32 = part17 as rs.u32; + sum = rs.u64WrappingAdd(rs.u64WrappingMul(sum, 31), n as rs.u64); + rest = rs.byteSliceRange(rest, rs.usizeAdd(n as rs.usize, 1)); } else { break; } @@ -568,43 +568,43 @@ export function numbers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void put$returns_Put_u64(sum, out); } -export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: (a0: rt.ByteSlice) => rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>; +export function returns(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: (a0: rs.ByteSlice) => rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>; b0: { - if (!(rt.u8Rem(kind, 8) === 7)) { - const _7: rt.u8 = rt.u8Rem(kind, 7); + if (!(rs.u8Rem(kind, 8) === 7)) { + const _7: rs.u8 = rs.u8Rem(kind, 7); if (_7 === 0) { - const err16: returns_Error.Error | undefined = take(data.data, data.start, data.length, rt.usizeRem(kind as rt.usize, 7)); + const err16: returns_Error.Error | undefined = take(data.data, data.start, data.length, rs.usizeRem(kind as rs.usize, 7)); const part65: Uint8Array = out$ref_slice_u8.pData; const part66: number = out$ref_slice_u8.pStart; const part67: number = out$ref_slice_u8.pLen; - push(out, (err16 !== undefined ? rt.Err(err16 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part65, part66, part67))) as rt.Result); + push(out, (err16 !== undefined ? rs.Err(err16 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(part65, part66, part67))) as rs.Result); const err17: returns_Error.Error | undefined = take(data.data, data.start, data.length, 201); const part68: Uint8Array = out$ref_slice_u8.pData; const part69: number = out$ref_slice_u8.pStart; const part70: number = out$ref_slice_u8.pLen; - push(out, (err17 !== undefined ? rt.Err(err17 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part68, part69, part70))) as rt.Result); + push(out, (err17 !== undefined ? rs.Err(err17 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(part68, part69, part70))) as rs.Result); const err18: returns_Error.Error | undefined = tail(data, 3); const part71: Uint8Array = out$ref_slice_u8.pData; const part72: number = out$ref_slice_u8.pStart; const part73: number = out$ref_slice_u8.pLen; - push(out, (err18 !== undefined ? rt.Err(err18 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part71, part72, part73))) as rt.Result); - const part74: rt.u64 | undefined = number(data.data, data.start, data.length, rt.u8Rem(kind, 2) === 0); + push(out, (err18 !== undefined ? rs.Err(err18 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(part71, part72, part73))) as rs.Result); + const part74: rs.u64 | undefined = number(data.data, data.start, data.length, rs.u8Rem(kind, 2) === 0); const err19: returns_Error.Error | undefined = part74 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part75: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part76: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part77: number = out$tuple2_u64_ref_slice_u8.p_1Len; - pushNumber(out, (err19 !== undefined ? rt.Err(err19 as returns_Error.Error) : rt.Ok([part74 as rt.u64, new rt.ByteSlice(part75, part76, part77)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); - const part78: rt.u64 | undefined = count(data.data, data.start, data.length); + pushNumber(out, (err19 !== undefined ? rs.Err(err19 as returns_Error.Error) : rs.Ok([part74 as rs.u64, new rs.ByteSlice(part75, part76, part77)] as [rs.u64, rs.ByteSlice])) as rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>); + const part78: rs.u64 | undefined = count(data.data, data.start, data.length); const err20: returns_Error.Error | undefined = part78 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part79: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part80: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part81: number = out$tuple2_u64_ref_slice_u8.p_1Len; - pushNumber(out, (err20 !== undefined ? rt.Err(err20 as returns_Error.Error) : rt.Ok([part78 as rt.u64, new rt.ByteSlice(part79, part80, part81)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err20 !== undefined ? rs.Err(err20 as returns_Error.Error) : rs.Ok([part78 as rs.u64, new rs.ByteSlice(part79, part80, part81)] as [rs.u64, rs.ByteSlice])) as rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>); } else if (_7 === 1) { - const kept: rt.Vec> = rt.iterToVec(rt.iterMap(new rt.Range(0, 4), (n3: rt.usize): rt.Result => { - const err13 = take(data.data, data.start, data.length, rt.usizeMul(n3, 3)); - return err13 !== undefined ? rt.Err(err13 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(out$ref_slice_u8.pData, out$ref_slice_u8.pStart, out$ref_slice_u8.pLen)); + const kept: rs.Vec> = rs.iterToVec(rs.iterMap(new rs.Range(0, 4), (n3: rs.usize): rs.Result => { + const err13 = take(data.data, data.start, data.length, rs.usizeMul(n3, 3)); + return err13 !== undefined ? rs.Err(err13 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(out$ref_slice_u8.pData, out$ref_slice_u8.pStart, out$ref_slice_u8.pLen)); }), undefined, 12, true); const err14: returns_Error.Error | undefined = tail(data, 1); const part57: Uint8Array = out$ref_slice_u8.pData; @@ -613,52 +613,52 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void for (const _32 of kept.items) { push(out, _32); } - push(out, (err14 !== undefined ? rt.Err(err14 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part57, part58, part59))) as rt.Result); - const part60: rt.u64 | undefined = both(data.data, data.start, data.length); + push(out, (err14 !== undefined ? rs.Err(err14 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(part57, part58, part59))) as rs.Result); + const part60: rs.u64 | undefined = both(data.data, data.start, data.length); const err15: returns_Error.Error | undefined = part60 === undefined ? out$tuple3_u64_u64_ref_slice_u8.err as returns_Error.Error : undefined; - const part61: rt.u64 = out$tuple3_u64_u64_ref_slice_u8.p_1; + const part61: rs.u64 = out$tuple3_u64_u64_ref_slice_u8.p_1; const part64: number = out$tuple3_u64_u64_ref_slice_u8.p_2Len; if (err15 === undefined) { - const a: rt.u64 = part60 as rt.u64; - const b: rt.u64 = part61; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(a))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(b))); - rt.byteVecPush(out, part64 & 0xff); + const a: rs.u64 = part60 as rs.u64; + const b: rs.u64 = part61; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(a))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(b))); + rs.byteVecPush(out, part64 & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(err15 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err15 as returns_Error.Error)); } } else if (_7 === 2) { - if (!(rt.usizeRem(data.length, 2) === 0)) { - f = (a02: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + if (!(rs.usizeRem(data.length, 2) === 0)) { + f = (a02: rs.ByteSlice): rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error> => { const part51 = narrow(a02.data, a02.start, a02.length); - return part51 === undefined ? rt.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rt.Ok([part51, new rt.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rt.u64, rt.ByteSlice]); + return part51 === undefined ? rs.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rs.Ok([part51, new rs.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rs.u64, rs.ByteSlice]); }; } else { - f = (a0: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + f = (a0: rs.ByteSlice): rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error> => { const part50 = wide(a0.data, a0.start, a0.length); - return part50 === undefined ? rt.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rt.Ok([part50, new rt.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rt.u64, rt.ByteSlice]); + return part50 === undefined ? rs.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rs.Ok([part50, new rs.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rs.u64, rs.ByteSlice]); }; } pushNumber(out, f(data)); - for (const _74 of rt.iterToVec(rt.iterMap(rt.iterSlice([data, rt.byteSliceRange(data, rt.min(data.length, 3))]), (a03: rt.ByteSlice): rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error> => { + for (const _74 of rs.iterToVec(rs.iterMap(rs.iterSlice([data, rs.byteSliceRange(data, rs.min(data.length, 3))]), (a03: rs.ByteSlice): rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error> => { const part53 = count(a03.data, a03.start, a03.length); - return part53 === undefined ? rt.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rt.Ok([part53, new rt.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rt.u64, rt.ByteSlice]); + return part53 === undefined ? rs.Err(out$tuple2_u64_ref_slice_u8.err as returns_Error.Error) : rs.Ok([part53, new rs.ByteSlice(out$tuple2_u64_ref_slice_u8.p_1Data, out$tuple2_u64_ref_slice_u8.p_1Start, out$tuple2_u64_ref_slice_u8.p_1Len)] as [rs.u64, rs.ByteSlice]); }), undefined, 16, true).items) { pushNumber(out, _74); } - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(option_map$1yogfym((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, (_23: [rt.u8, rt.ByteSlice]): rt.ByteSlice => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(option_map$05uajnx((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, (_23: [rs.u8, rs.ByteSlice]): rs.ByteSlice => { return _23[1]; - }), (s2: rt.ByteSlice): rt.u8 => { + }), (s2: rs.ByteSlice): rs.u8 => { const err12: returns_Error.Error | undefined = tail(s2, 2); const part54: Uint8Array = out$ref_slice_u8.pData; const part55: number = out$ref_slice_u8.pStart; const part56: number = out$ref_slice_u8.pLen; - return result_mapOr$0fbyajt((err12 !== undefined ? rt.Err(err12 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(part54, part55, part56))) as rt.Result, 0, (a04: rt.ByteSlice): rt.usize => { + return result_mapOr$1df1cdv((err12 !== undefined ? rs.Err(err12 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(part54, part55, part56))) as rs.Result, 0, (a04: rs.ByteSlice): rs.usize => { return a04.length; }) & 0xff; })), undefined, true); } else if (_7 === 3) { - const err9: rt.u8 | undefined = halves(data.data, data.start, data.length); + const err9: rs.u8 | undefined = halves(data.data, data.start, data.length); const part35: number = out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_0Len; const part36: Uint8Array = out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_1Data; const part37: number = out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_1Start; @@ -667,95 +667,95 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const part40: number = out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_2Start; const part41: number = out$tuple3_ref_slice_u8_ref_array2_u8_ref_slice_u8.p_2Len; if (err9 === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part36, part37, part38)); - rt.byteVecPush(out, part35 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part39, part40, part41)); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part36, part37, part38)); + rs.byteVecPush(out, part35 & 0xff); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part39, part40, part41)); } else { - rt.byteVecPush(out, err9 as rt.u8); + rs.byteVecPush(out, err9 as rs.u8); } const other: Uint8Array = Uint8Array.of(255, 1, 2); - const _99: rt.ByteSlice = rt.byteSliceFrom(other); - const part42: rt.u64 | undefined = guarded(data.data, data.start, data.length, _99); + const _99: rs.ByteSlice = rs.byteSliceFrom(other); + const part42: rs.u64 | undefined = guarded(data.data, data.start, data.length, _99); const err10: returns_Error.Error | undefined = part42 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part43: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part44: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part45: number = out$tuple2_u64_ref_slice_u8.p_1Len; - pushNumber(out, (err10 !== undefined ? rt.Err(err10 as returns_Error.Error) : rt.Ok([part42 as rt.u64, new rt.ByteSlice(part43, part44, part45)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); - const _103: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(other), 1); - const part46: rt.u64 | undefined = guarded(data.data, data.start, data.length, _103); + pushNumber(out, (err10 !== undefined ? rs.Err(err10 as returns_Error.Error) : rs.Ok([part42 as rs.u64, new rs.ByteSlice(part43, part44, part45)] as [rs.u64, rs.ByteSlice])) as rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>); + const _103: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(other), 1); + const part46: rs.u64 | undefined = guarded(data.data, data.start, data.length, _103); const err11: returns_Error.Error | undefined = part46 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part47: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part48: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part49: number = out$tuple2_u64_ref_slice_u8.p_1Len; - pushNumber(out, (err11 !== undefined ? rt.Err(err11 as returns_Error.Error) : rt.Ok([part46 as rt.u64, new rt.ByteSlice(part47, part48, part49)] as [rt.u64, rt.ByteSlice])) as rt.Result<[rt.u64, rt.ByteSlice], returns_Error.Error>); + pushNumber(out, (err11 !== undefined ? rs.Err(err11 as returns_Error.Error) : rs.Ok([part46 as rs.u64, new rs.ByteSlice(part47, part48, part49)] as [rs.u64, rs.ByteSlice])) as rs.Result<[rs.u64, rs.ByteSlice], returns_Error.Error>); } else if (_7 === 4) { - const _107: rt.Result = unitErr(data.data, data.start, data.length); + const _107: rs.Result = unitErr(data.data, data.start, data.length); if (_107.ok) { - rt.byteVecPush(out, _107.value.length & 0xff); + rs.byteVecPush(out, _107.value.length & 0xff); } else { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } - const _113: rt.Result = noneErr(data); + const _113: rs.Result = noneErr(data); if (_113.ok) { - rt.byteVecPush(out, _113.value.length & 0xff); + rs.byteVecPush(out, _113.value.length & 0xff); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$0r2bmpr(_113.error, 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, option_unwrapOr$1fr498u(_113.error, 0)))); } - const part24: rt.u16 | undefined = lead$u16(data.data, data.start, data.length); + const part24: rs.u16 | undefined = lead$u16(data.data, data.start, data.length); const err7: returns_Error.Error | undefined = part24 === undefined ? out$tuple2_u16_ref_slice_u8.err as returns_Error.Error : undefined; const part25: Uint8Array = out$tuple2_u16_ref_slice_u8.p_1Data; const part26: number = out$tuple2_u16_ref_slice_u8.p_1Start; const part27: number = out$tuple2_u16_ref_slice_u8.p_1Len; - const _126: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); - const part29: rt.u32 | undefined = lead$u32(_126.data, _126.start, _126.length); + const _126: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 1)); + const part29: rs.u32 | undefined = lead$u32(_126.data, _126.start, _126.length); const err8: returns_Error.Error | undefined = part29 === undefined ? out$tuple2_u32_ref_slice_u8.err as returns_Error.Error : undefined; const part30: Uint8Array = out$tuple2_u32_ref_slice_u8.p_1Data; const part31: number = out$tuple2_u32_ref_slice_u8.p_1Start; const part32: number = out$tuple2_u32_ref_slice_u8.p_1Len; if (err7 === undefined) { if (err8 === undefined) { - const a3: rt.u16 = part24 as rt.u16; - const b3: rt.u32 = part29 as rt.u32; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(a3))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(b3))); - rt.byteVecPush(out, part32 & 0xff); + const a3: rs.u16 = part24 as rs.u16; + const b3: rs.u32 = part29 as rs.u32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(a3))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(b3))); + rs.byteVecPush(out, part32 & 0xff); break b0; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(((err7 !== undefined ? rt.Err(err7 as returns_Error.Error) : rt.Ok([part24 as rt.u16, new rt.ByteSlice(part25, part26, part27)] as [rt.u16, rt.ByteSlice])) as rt.Result<[rt.u16, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err8 !== undefined ? rt.Err(err8 as returns_Error.Error) : rt.Ok([part29 as rt.u32, new rt.ByteSlice(part30, part31, part32)] as [rt.u32, rt.ByteSlice])) as rt.Result<[rt.u32, rt.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(((err7 !== undefined ? rs.Err(err7 as returns_Error.Error) : rs.Ok([part24 as rs.u16, new rs.ByteSlice(part25, part26, part27)] as [rs.u16, rs.ByteSlice])) as rs.Result<[rs.u16, rs.ByteSlice], returns_Error.Error>).ok ? 1 : 0, ((err8 !== undefined ? rs.Err(err8 as returns_Error.Error) : rs.Ok([part29 as rs.u32, new rs.ByteSlice(part30, part31, part32)] as [rs.u32, rs.ByteSlice])) as rs.Result<[rs.u32, rs.ByteSlice], returns_Error.Error>).ok ? 1 : 0))); } else if (_7 === 5) { const err5: returns_Error.Error | undefined = afterFixed(data.data, data.start, data.length); const part17: Uint8Array = out$ref_slice_u8.pData; const part18: number = out$ref_slice_u8.pStart; const part19: number = out$ref_slice_u8.pLen; if (err5 === undefined) { - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(part17, part18, part19)); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(part17, part18, part19)); } else { - rt.byteVecPush(out, returns_Error.code(err5 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err5 as returns_Error.Error)); } - const part20: rt.u8 | undefined = wrapped(data.data, data.start, data.length); + const part20: rs.u8 | undefined = wrapped(data.data, data.start, data.length); const err6: Wrapped.Wrapped | undefined = part20 === undefined ? out$tuple2_u8_ref_slice_u8.err as Wrapped.Wrapped : undefined; const part23: number = out$tuple2_u8_ref_slice_u8.p_1Len; if (err6 === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part20 as rt.u8, part23 & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(part20 as rs.u8, part23 & 0xff))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, (err6 as Wrapped.Wrapped)._0, (err6 as Wrapped.Wrapped)._1))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, (err6 as Wrapped.Wrapped)._0, (err6 as Wrapped.Wrapped)._1))); } } else { - const at: At.At = { _0: rt.usizeRem(kind as rt.usize, 5) }; + const at: At.At = { _0: rs.usizeRem(kind as rs.usize, 5) }; const err: returns_Error.Error | undefined = splitWith$returns_At(at, data.data, data.start, data.length); const part3: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_0Len; const part6: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_1Len; if (err === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(part3 & 0xff, part6 & 0xff))); } else { - rt.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err as returns_Error.Error)); } - const _199: rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error> = new of$returns_At(at).split$Split(data); + const _199: rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error> = new of$returns_At(at).split$Split(data); if (_199.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_199.value[1].length & 0xff, _199.value[0].length & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_199.value[1].length & 0xff, _199.value[0].length & 0xff))); } else { - rt.byteVecPush(out, returns_Error.code(_199.error)); + rs.byteVecPush(out, returns_Error.code(_199.error)); } const err2: returns_Error.Error | undefined = At.split$returns_Split(at, data.data, data.start, data.length); const part7: Uint8Array = out$tuple2_ref_slice_u8_ref_slice_u8.p_0Data; @@ -764,27 +764,27 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const part10: Uint8Array = out$tuple2_ref_slice_u8_ref_slice_u8.p_1Data; const part11: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_1Start; const part12: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_1Len; - const _213: rt.Result = result_andThen$1yropo4((err2 !== undefined ? rt.Err(err2 as returns_Error.Error) : rt.Ok([new rt.ByteSlice(part7, part8, part9), new rt.ByteSlice(part10, part11, part12)] as [rt.ByteSlice, rt.ByteSlice])) as rt.Result<[rt.ByteSlice, rt.ByteSlice], returns_Error.Error>, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.Result => { + const _213: rs.Result = result_andThen$0ud0j7o((err2 !== undefined ? rs.Err(err2 as returns_Error.Error) : rs.Ok([new rs.ByteSlice(part7, part8, part9), new rs.ByteSlice(part10, part11, part12)] as [rs.ByteSlice, rs.ByteSlice])) as rs.Result<[rs.ByteSlice, rs.ByteSlice], returns_Error.Error>, (_2: [rs.ByteSlice, rs.ByteSlice]): rs.Result => { const err3 = take(_2[1].data, _2[1].start, _2[1].length, _2[0].length); - return err3 !== undefined ? rt.Err(err3 as returns_Error.Error) : rt.Ok(new rt.ByteSlice(out$ref_slice_u8.pData, out$ref_slice_u8.pStart, out$ref_slice_u8.pLen)); + return err3 !== undefined ? rs.Err(err3 as returns_Error.Error) : rs.Ok(new rs.ByteSlice(out$ref_slice_u8.pData, out$ref_slice_u8.pStart, out$ref_slice_u8.pLen)); }); if (_213.ok) { - rt.byteVecPush(out, _213.value.length & 0xff); + rs.byteVecPush(out, _213.value.length & 0xff); } else { - rt.byteVecPush(out, returns_Error.code(_213.error)); + rs.byteVecPush(out, returns_Error.code(_213.error)); } let restData4: Uint8Array = data.data; let restStart4: number = data.start; let restLen4: number = data.length; - let sum: rt.u64 = 0; + let sum: rs.u64 = 0; while (true) { - const part13: rt.u64 | undefined = narrow(restData4, restStart4, restLen4); + const part13: rs.u64 | undefined = narrow(restData4, restStart4, restLen4); const err4: returns_Error.Error | undefined = part13 === undefined ? out$tuple2_u64_ref_slice_u8.err as returns_Error.Error : undefined; const part14: Uint8Array = out$tuple2_u64_ref_slice_u8.p_1Data; const part15: number = out$tuple2_u64_ref_slice_u8.p_1Start; const part16: number = out$tuple2_u64_ref_slice_u8.p_1Len; if (err4 === undefined) { - sum = rt.u64WrappingAdd(rt.u64WrappingMul(sum, 31), part13 as rt.u64); + sum = rs.u64WrappingAdd(rs.u64WrappingMul(sum, 31), part13 as rs.u64); restData4 = part14; restStart4 = part15; restLen4 = part16; @@ -792,7 +792,7 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void break; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(sum))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(sum))); } } else { numbers(kind, data, out); @@ -802,7 +802,7 @@ export function returns(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void export function optF32(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_f32.p = undefined; return undefined; @@ -818,9 +818,9 @@ export function optF32(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_f32.p = NaN; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); if (_17.ok) { - out$Option_f32.p = rt.f32FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_f32.p = rs.f32FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -830,7 +830,7 @@ export function optF32(dataData: Uint8Array, dataStart: number, dataLen: number) export function optF64(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_f64.p = undefined; return undefined; @@ -846,9 +846,9 @@ export function optF64(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_f64.p = NaN; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); if (_17.ok) { - out$Option_f64.p = rt.f64FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_f64.p = rs.f64FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -858,7 +858,7 @@ export function optF64(dataData: Uint8Array, dataStart: number, dataLen: number) export function optI128(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_i128.p = undefined; return undefined; @@ -871,12 +871,12 @@ export function optI128(dataData: Uint8Array, dataStart: number, dataLen: number return { tag: "Bad" } as returns_Error.Error; } if (_11 === 3) { - out$Option_i128.p = { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128; + out$Option_i128.p = { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 16), { tag: "Short", _0: 16 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 16), { tag: "Short", _0: 16 } as returns_Error.Error); if (_17.ok) { - out$Option_i128.p = rt.i128FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_i128.p = rs.i128FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -886,7 +886,7 @@ export function optI128(dataData: Uint8Array, dataStart: number, dataLen: number export function optI16(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_i16.p = undefined; return undefined; @@ -902,7 +902,7 @@ export function optI16(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_i16.p = -32768; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 2), { tag: "Short", _0: 2 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 2), { tag: "Short", _0: 2 } as returns_Error.Error); if (_17.ok) { out$Option_i16.p = (((_17.value.data[_17.value.start] << 8) | _17.value.data[_17.value.start + 1]) << 16) >> 16; return undefined; @@ -914,7 +914,7 @@ export function optI16(dataData: Uint8Array, dataStart: number, dataLen: number) export function optI32(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_i32.p = undefined; return undefined; @@ -930,7 +930,7 @@ export function optI32(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_i32.p = -2147483648; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); if (_17.ok) { out$Option_i32.p = (_17.value.data[_17.value.start] << 24) | (_17.value.data[_17.value.start + 1] << 16) | (_17.value.data[_17.value.start + 2] << 8) | _17.value.data[_17.value.start + 3]; return undefined; @@ -942,7 +942,7 @@ export function optI32(dataData: Uint8Array, dataStart: number, dataLen: number) export function optI64(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_i64.p = undefined; return undefined; @@ -955,12 +955,12 @@ export function optI64(dataData: Uint8Array, dataStart: number, dataLen: number) return { tag: "Bad" } as returns_Error.Error; } if (_11 === 3) { - out$Option_i64.p = { hi: -0x80000000, lo: 0 } as rt.i64; + out$Option_i64.p = { hi: -0x80000000, lo: 0 } as rs.i64; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); if (_17.ok) { - out$Option_i64.p = rt.i64FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_i64.p = rs.i64FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -970,7 +970,7 @@ export function optI64(dataData: Uint8Array, dataStart: number, dataLen: number) export function optI8(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_i8.p = undefined; return undefined; @@ -986,7 +986,7 @@ export function optI8(dataData: Uint8Array, dataStart: number, dataLen: number): out$Option_i8.p = -128; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 1), { tag: "Short", _0: 1 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 1), { tag: "Short", _0: 1 } as returns_Error.Error); if (_17.ok) { out$Option_i8.p = (_17.value.data[_17.value.start] << 24) >> 24; return undefined; @@ -998,7 +998,7 @@ export function optI8(dataData: Uint8Array, dataStart: number, dataLen: number): export function optU128(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_u128.p = undefined; return undefined; @@ -1011,12 +1011,12 @@ export function optU128(dataData: Uint8Array, dataStart: number, dataLen: number return { tag: "Bad" } as returns_Error.Error; } if (_11 === 3) { - out$Option_u128.p = { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128; + out$Option_u128.p = { hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 16), { tag: "Short", _0: 16 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 16), { tag: "Short", _0: 16 } as returns_Error.Error); if (_17.ok) { - out$Option_u128.p = rt.u128FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_u128.p = rs.u128FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -1026,7 +1026,7 @@ export function optU128(dataData: Uint8Array, dataStart: number, dataLen: number export function optU16(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_u16.p = undefined; return undefined; @@ -1042,7 +1042,7 @@ export function optU16(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_u16.p = 65535; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 2), { tag: "Short", _0: 2 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 2), { tag: "Short", _0: 2 } as returns_Error.Error); if (_17.ok) { out$Option_u16.p = (_17.value.data[_17.value.start] << 8) | _17.value.data[_17.value.start + 1]; return undefined; @@ -1054,7 +1054,7 @@ export function optU16(dataData: Uint8Array, dataStart: number, dataLen: number) export function optU32(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_u32.p = undefined; return undefined; @@ -1070,7 +1070,7 @@ export function optU32(dataData: Uint8Array, dataStart: number, dataLen: number) out$Option_u32.p = 4294967295; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); if (_17.ok) { out$Option_u32.p = ((_17.value.data[_17.value.start] << 24) | (_17.value.data[_17.value.start + 1] << 16) | (_17.value.data[_17.value.start + 2] << 8) | _17.value.data[_17.value.start + 3]) >>> 0; return undefined; @@ -1082,7 +1082,7 @@ export function optU32(dataData: Uint8Array, dataStart: number, dataLen: number) export function optU64(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_u64.p = undefined; return undefined; @@ -1095,12 +1095,12 @@ export function optU64(dataData: Uint8Array, dataStart: number, dataLen: number) return { tag: "Bad" } as returns_Error.Error; } if (_11 === 3) { - out$Option_u64.p = { hi: 0xffffffff, lo: 0xffffffff } as rt.u64; + out$Option_u64.p = { hi: 0xffffffff, lo: 0xffffffff } as rs.u64; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 8), { tag: "Short", _0: 8 } as returns_Error.Error); if (_17.ok) { - out$Option_u64.p = rt.u64FromBeBytes(rt.byteSliceToArray(_17.value)); + out$Option_u64.p = rs.u64FromBeBytes(rs.byteSliceToArray(_17.value)); return undefined; } return (_17 as { ok: false; error: returns_Error.Error }).error; @@ -1110,7 +1110,7 @@ export function optU64(dataData: Uint8Array, dataStart: number, dataLen: number) export function optU8(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_u8.p = undefined; return undefined; @@ -1126,7 +1126,7 @@ export function optU8(dataData: Uint8Array, dataStart: number, dataLen: number): out$Option_u8.p = 255; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 1), { tag: "Short", _0: 1 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 1), { tag: "Short", _0: 1 } as returns_Error.Error); if (_17.ok) { out$Option_u8.p = _17.value.data[_17.value.start]; return undefined; @@ -1138,7 +1138,7 @@ export function optU8(dataData: Uint8Array, dataStart: number, dataLen: number): export function optUsize(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const _11: rt.u8 = rt.u8Rem(dataData[dataStart], 5); + const _11: rs.u8 = rs.u8Rem(dataData[dataStart], 5); if (_11 === 0) { out$Option_usize.p = undefined; return undefined; @@ -1154,7 +1154,7 @@ export function optUsize(dataData: Uint8Array, dataStart: number, dataLen: numbe out$Option_usize.p = 4294967295; return undefined; } - const _17: rt.Result = option_okOr$12p77jh(rt.byteSliceGetRange(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); + const _17: rs.Result = option_okOr$0rfpk7i(rs.byteSliceGetRange(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 0, 4), { tag: "Short", _0: 4 } as returns_Error.Error); if (_17.ok) { out$Option_usize.p = ((_17.value.data[_17.value.start] << 24) | (_17.value.data[_17.value.start + 1] << 16) | (_17.value.data[_17.value.start + 2] << 8) | _17.value.data[_17.value.start + 3]) >>> 0; return undefined; @@ -1164,38 +1164,38 @@ export function optUsize(dataData: Uint8Array, dataStart: number, dataLen: numbe return { tag: "Short", _0: 1 } as returns_Error.Error; } -export function optBool(data: rt.ByteSlice): returns_Error.Error | undefined { - const _2: rt.u8 | undefined = rt.byteSliceFirst(data); +export function optBool(data: rs.ByteSlice): returns_Error.Error | undefined { + const _2: rs.u8 | undefined = rs.byteSliceFirst(data); if (_2 === undefined) { return { tag: "Short", _0: 1 } as returns_Error.Error; } - if (!(rt.u8Rem(_2, 3) === 0)) { - out$Option_bool.p = rt.u8Rem(_2, 3) === 1; + if (!(rs.u8Rem(_2, 3) === 0)) { + out$Option_bool.p = rs.u8Rem(_2, 3) === 1; return undefined; } out$Option_bool.p = undefined; return undefined; } -export function optChar(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { - const part: rt.u8 | undefined = byte(new rt.ByteSlice(dataData, dataStart, dataLen), 0); - const err: rt.u8 | undefined = part === undefined ? out$u8.err as rt.u8 : undefined; +export function optChar(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 | undefined { + const part: rs.u8 | undefined = byte(new rs.ByteSlice(dataData, dataStart, dataLen), 0); + const err: rs.u8 | undefined = part === undefined ? out$u8.err as rs.u8 : undefined; if (err === undefined) { - out$Option_char.p = rt.charFromU32(rt.u32Add(rt.u32Mul((part as rt.u8) as rt.u32, 435), 55040)); + out$Option_char.p = rs.charFromU32(rs.u32Add(rs.u32Mul((part as rs.u8) as rs.u32, 435), 55040)); return undefined; } - return err as rt.u8; + return err as rs.u8; } /** `opt_u64`'s result returned as is, and taken apart by `?` and made again. */ -export function optAgain(data: rt.ByteSlice, first: boolean): returns_Error.Error | undefined { +export function optAgain(data: rs.ByteSlice, first: boolean): returns_Error.Error | undefined { if (!first) { - const _6: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + const _6: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 1)); const err: returns_Error.Error | undefined = optU64(_6.data, _6.start, _6.length); - const part2: rt.u64 | undefined = out$Option_u64.p; + const part2: rs.u64 | undefined = out$Option_u64.p; if (err === undefined) { - out$Option_u64.p = option_map$1cf8u0y(part2, (v: rt.u64): rt.u64 => { - return rt.u64Shr(v, 1); + out$Option_u64.p = option_map$1haiqd3(part2, (v: rs.u64): rs.u64 => { + return rs.u64Shr(v, 1); }); return undefined; } @@ -1207,19 +1207,19 @@ export function optAgain(data: rt.ByteSlice, first: boolean): returns_Error.Erro /** An `Option` beside a number, first and last, and beside a slice. */ export function optFirst(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { const err: returns_Error.Error | undefined = optU8(dataData, dataStart, dataLen); - const part: rt.u8 | undefined = out$Option_u8.p; + const part: rs.u8 | undefined = out$Option_u8.p; if (err === undefined) { out$tuple2_Option_u8_u64.p_0 = part; - out$tuple2_Option_u8_u64.p_1 = dataLen as rt.u64; + out$tuple2_Option_u8_u64.p_1 = dataLen as rs.u64; return undefined; } return err as returns_Error.Error; } -export function optLast(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u64 | undefined { +export function optLast(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u64 | undefined { const err: returns_Error.Error | undefined = optI128(dataData, dataStart, dataLen); - const part: rt.i128 | undefined = out$Option_i128.p; - const _3: rt.u64 = dataLen as rt.u64; + const part: rs.i128 | undefined = out$Option_i128.p; + const _3: rs.u64 = dataLen as rs.u64; if (err === undefined) { out$tuple2_u64_Option_i128.p_1 = part; return _3; @@ -1230,8 +1230,8 @@ export function optLast(dataData: Uint8Array, dataStart: number, dataLen: number export function optRest(dataData: Uint8Array, dataStart: number, dataLen: number): returns_Error.Error | undefined { if (dataLen !== 0) { - const b: rt.u8 = dataData[dataStart]; - out$tuple2_Option_u16_ref_slice_u8.p_0 = thenSome$0b23a33(rt.u8Rem(b, 2) === 0, ((b as rt.u16) << 8) & 0xffff); + const b: rs.u8 = dataData[dataStart]; + out$tuple2_Option_u16_ref_slice_u8.p_0 = thenSome$1gvhopg(rs.u8Rem(b, 2) === 0, ((b as rs.u16) << 8) & 0xffff); out$tuple2_Option_u16_ref_slice_u8.p_1Data = dataData; out$tuple2_Option_u16_ref_slice_u8.p_1Start = dataStart + 1; out$tuple2_Option_u16_ref_slice_u8.p_1Len = dataLen - 1; @@ -1240,9 +1240,9 @@ export function optRest(dataData: Uint8Array, dataStart: number, dataLen: number return { tag: "Short", _0: 1 } as returns_Error.Error; } -export function optLate(dataData: Uint8Array, dataStart: number, dataLen: number, other: rt.ByteSlice): returns_Error.Error | undefined { +export function optLate(dataData: Uint8Array, dataStart: number, dataLen: number, other: rs.ByteSlice): returns_Error.Error | undefined { const err: returns_Error.Error | undefined = optU64(dataData, dataStart, dataLen); - const part: rt.u64 | undefined = out$Option_u64.p; + const part: rs.u64 | undefined = out$Option_u64.p; new Opted.Opted(other.data, other.start, other.length)[Symbol.dispose](); if (err !== undefined) { return err as returns_Error.Error; @@ -1251,71 +1251,71 @@ export function optLate(dataData: Uint8Array, dataStart: number, dataLen: number return undefined; } -export function put$returns_Put_i128(self: rt.i128, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(self))); +export function put$returns_Put_i128(self: rs.i128, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(self))); } -export function put$returns_Put_i16(self: rt.i16, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(self))); +export function put$returns_Put_i16(self: rs.i16, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(self))); } -export function put$returns_Put_i32(self: rt.i32, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(self))); +export function put$returns_Put_i32(self: rs.i32, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(self))); } -export function put$returns_Put_i64(self: rt.i64, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(self))); +export function put$returns_Put_i64(self: rs.i64, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(self))); } -export function put$returns_Put_i8(self: rt.i8, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(self))); +export function put$returns_Put_i8(self: rs.i8, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(self))); } -export function put$returns_Put_u128(self: rt.u128, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(self))); +export function put$returns_Put_u128(self: rs.u128, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(self))); } -export function put$returns_Put_u16(self: rt.u16, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(self))); +export function put$returns_Put_u16(self: rs.u16, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(self))); } -export function put$returns_Put_u32(self: rt.u32, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(self))); +export function put$returns_Put_u32(self: rs.u32, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(self))); } -export function put$returns_Put_u64(self: rt.u64, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(self))); +export function put$returns_Put_u64(self: rs.u64, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(self))); } -export function put$returns_Put_u8(self: rt.u8, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(self))); +export function put$returns_Put_u8(self: rs.u8, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(self))); } -export function put$returns_Put_usize(self: rt.usize, out: rt.ByteVec): void { - put$returns_Put_u64(self as rt.u64, out); +export function put$returns_Put_usize(self: rs.usize, out: rs.ByteVec): void { + put$returns_Put_u64(self as rs.u64, out); } -export function put$returns_Put_bool(self: boolean, out: rt.ByteVec): void { - rt.byteVecPush(out, self ? 1 : 0); +export function put$returns_Put_bool(self: boolean, out: rs.ByteVec): void { + rs.byteVecPush(out, self ? 1 : 0); } -export function put$returns_Put_char(self: rt.char, out: rt.ByteVec): void { - put$returns_Put_u32(self as rt.u32, out); +export function put$returns_Put_char(self: rs.char, out: rs.ByteVec): void { + put$returns_Put_u32(self as rs.u32, out); } -export function put$returns_Put_f32(self: rt.f32, out: rt.ByteVec): void { +export function put$returns_Put_f32(self: rs.f32, out: rs.ByteVec): void { if (!Number.isNaN(self)) { - put$returns_Put_u32(rt.f32ToBits(self), out); + put$returns_Put_u32(rs.f32ToBits(self), out); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(127, rt.f32IsSignNegative(self) ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(127, rs.f32IsSignNegative(self) ? 1 : 0))); } } -export function put$returns_Put_f64(self: rt.f64, out: rt.ByteVec): void { +export function put$returns_Put_f64(self: rs.f64, out: rs.ByteVec): void { if (!Number.isNaN(self)) { - put$returns_Put_u64(rt.f64ToBits(self), out); + put$returns_Put_u64(rs.f64ToBits(self), out); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(127, rt.f64IsSignNegative(self) ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(127, rs.f64IsSignNegative(self) ? 1 : 0))); } } @@ -1323,329 +1323,329 @@ export function put$returns_Put_f64(self: rt.f64, out: rt.ByteVec): void { * Results of `Option`s of numbers: held as parts, kept whole, and read after the slot was * written again. */ -export function options(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let f!: (a0: rt.ByteSlice) => rt.Result; +export function options(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let f!: (a0: rs.ByteSlice) => rs.Result; const err: returns_Error.Error | undefined = optU8(data.data, data.start, data.length); - const part: rt.u8 | undefined = out$Option_u8.p; + const part: rs.u8 | undefined = out$Option_u8.p; if (err === undefined) { if (part === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v: rt.u8 = part; - rt.byteVecPush(out, 1); + const v: rs.u8 = part; + rs.byteVecPush(out, 1); put$returns_Put_u8(v, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err as returns_Error.Error)))); } const err2: returns_Error.Error | undefined = optU16(data.data, data.start, data.length); - const part2: rt.u16 | undefined = out$Option_u16.p; + const part2: rs.u16 | undefined = out$Option_u16.p; if (err2 === undefined) { if (part2 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v2: rt.u16 = part2; - rt.byteVecPush(out, 1); + const v2: rs.u16 = part2; + rs.byteVecPush(out, 1); put$returns_Put_u16(v2, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err2 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err2 as returns_Error.Error)))); } const err3: returns_Error.Error | undefined = optU32(data.data, data.start, data.length); - const part3: rt.u32 | undefined = out$Option_u32.p; + const part3: rs.u32 | undefined = out$Option_u32.p; if (err3 === undefined) { if (part3 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v3: rt.u32 = part3; - rt.byteVecPush(out, 1); + const v3: rs.u32 = part3; + rs.byteVecPush(out, 1); put$returns_Put_u32(v3, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err3 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err3 as returns_Error.Error)))); } const err4: returns_Error.Error | undefined = optU64(data.data, data.start, data.length); - const part4: rt.u64 | undefined = out$Option_u64.p; + const part4: rs.u64 | undefined = out$Option_u64.p; if (err4 === undefined) { if (part4 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v4: rt.u64 = part4; - rt.byteVecPush(out, 1); + const v4: rs.u64 = part4; + rs.byteVecPush(out, 1); put$returns_Put_u64(v4, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err4 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err4 as returns_Error.Error)))); } const err5: returns_Error.Error | undefined = optU128(data.data, data.start, data.length); - const part5: rt.u128 | undefined = out$Option_u128.p; + const part5: rs.u128 | undefined = out$Option_u128.p; if (err5 === undefined) { if (part5 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v5: rt.u128 = part5; - rt.byteVecPush(out, 1); + const v5: rs.u128 = part5; + rs.byteVecPush(out, 1); put$returns_Put_u128(v5, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err5 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err5 as returns_Error.Error)))); } const err6: returns_Error.Error | undefined = optUsize(data.data, data.start, data.length); - const part6: rt.usize | undefined = out$Option_usize.p; + const part6: rs.usize | undefined = out$Option_usize.p; if (err6 === undefined) { if (part6 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v6: rt.usize = part6; - rt.byteVecPush(out, 1); + const v6: rs.usize = part6; + rs.byteVecPush(out, 1); put$returns_Put_usize(v6, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err6 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err6 as returns_Error.Error)))); } const err7: returns_Error.Error | undefined = optI8(data.data, data.start, data.length); - const part7: rt.i8 | undefined = out$Option_i8.p; + const part7: rs.i8 | undefined = out$Option_i8.p; if (err7 === undefined) { if (part7 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v7: rt.i8 = part7; - rt.byteVecPush(out, 1); + const v7: rs.i8 = part7; + rs.byteVecPush(out, 1); put$returns_Put_i8(v7, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err7 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err7 as returns_Error.Error)))); } const err8: returns_Error.Error | undefined = optI16(data.data, data.start, data.length); - const part8: rt.i16 | undefined = out$Option_i16.p; + const part8: rs.i16 | undefined = out$Option_i16.p; if (err8 === undefined) { if (part8 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v8: rt.i16 = part8; - rt.byteVecPush(out, 1); + const v8: rs.i16 = part8; + rs.byteVecPush(out, 1); put$returns_Put_i16(v8, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err8 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err8 as returns_Error.Error)))); } const err9: returns_Error.Error | undefined = optI32(data.data, data.start, data.length); - const part9: rt.i32 | undefined = out$Option_i32.p; + const part9: rs.i32 | undefined = out$Option_i32.p; if (err9 === undefined) { if (part9 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v9: rt.i32 = part9; - rt.byteVecPush(out, 1); + const v9: rs.i32 = part9; + rs.byteVecPush(out, 1); put$returns_Put_i32(v9, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err9 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err9 as returns_Error.Error)))); } const err10: returns_Error.Error | undefined = optI64(data.data, data.start, data.length); - const part10: rt.i64 | undefined = out$Option_i64.p; + const part10: rs.i64 | undefined = out$Option_i64.p; if (err10 === undefined) { if (part10 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v10: rt.i64 = part10; - rt.byteVecPush(out, 1); + const v10: rs.i64 = part10; + rs.byteVecPush(out, 1); put$returns_Put_i64(v10, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err10 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err10 as returns_Error.Error)))); } const err11: returns_Error.Error | undefined = optI128(data.data, data.start, data.length); - const part11: rt.i128 | undefined = out$Option_i128.p; + const part11: rs.i128 | undefined = out$Option_i128.p; if (err11 === undefined) { if (part11 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v11: rt.i128 = part11; - rt.byteVecPush(out, 1); + const v11: rs.i128 = part11; + rs.byteVecPush(out, 1); put$returns_Put_i128(v11, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err11 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err11 as returns_Error.Error)))); } const err12: returns_Error.Error | undefined = optF32(data.data, data.start, data.length); - const part12: rt.f32 | undefined = out$Option_f32.p; + const part12: rs.f32 | undefined = out$Option_f32.p; if (err12 === undefined) { if (part12 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v12: rt.f32 = part12; - rt.byteVecPush(out, 1); + const v12: rs.f32 = part12; + rs.byteVecPush(out, 1); put$returns_Put_f32(v12, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err12 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err12 as returns_Error.Error)))); } const err13: returns_Error.Error | undefined = optF64(data.data, data.start, data.length); - const part13: rt.f64 | undefined = out$Option_f64.p; + const part13: rs.f64 | undefined = out$Option_f64.p; if (err13 === undefined) { if (part13 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v13: rt.f64 = part13; - rt.byteVecPush(out, 1); + const v13: rs.f64 = part13; + rs.byteVecPush(out, 1); put$returns_Put_f64(v13, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err13 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err13 as returns_Error.Error)))); } const err14: returns_Error.Error | undefined = optBool(data); const part14: boolean | undefined = out$Option_bool.p; if (err14 === undefined) { if (part14 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { const v14: boolean = part14; - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); put$returns_Put_bool(v14, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err14 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err14 as returns_Error.Error)))); } - const err15: rt.u8 | undefined = optChar(data.data, data.start, data.length); - const part15: rt.char | undefined = out$Option_char.p; + const err15: rs.u8 | undefined = optChar(data.data, data.start, data.length); + const part15: rs.char | undefined = out$Option_char.p; if (err15 === undefined) { if (part15 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { put$returns_Put_char(part15, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, err15 as rt.u8))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, err15 as rs.u8))); } - const tail: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); - const err16: returns_Error.Error | undefined = optAgain(data, rt.u8Rem(kind, 2) === 0); - const part17: rt.u64 | undefined = out$Option_u64.p; + const tail: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 1)); + const err16: returns_Error.Error | undefined = optAgain(data, rs.u8Rem(kind, 2) === 0); + const part17: rs.u64 | undefined = out$Option_u64.p; if (err16 === undefined) { if (part17 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v15: rt.u64 = part17; - rt.byteVecPush(out, 1); + const v15: rs.u64 = part17; + rs.byteVecPush(out, 1); put$returns_Put_u64(v15, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err16 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err16 as returns_Error.Error)))); } const err17: returns_Error.Error | undefined = optLate(data.data, data.start, data.length, tail); - const part18: rt.u64 | undefined = out$Option_u64.p; + const part18: rs.u64 | undefined = out$Option_u64.p; if (err17 === undefined) { if (part18 === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v16: rt.u64 = part18; - rt.byteVecPush(out, 1); + const v16: rs.u64 = part18; + rs.byteVecPush(out, 1); put$returns_Put_u64(v16, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err17 as returns_Error.Error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(err17 as returns_Error.Error)))); } const err18: returns_Error.Error | undefined = optFirst(data.data, data.start, data.length); - const part19: rt.u8 | undefined = out$tuple2_Option_u8_u64.p_0; - const part20: rt.u64 = out$tuple2_Option_u8_u64.p_1; + const part19: rs.u8 | undefined = out$tuple2_Option_u8_u64.p_0; + const part20: rs.u64 = out$tuple2_Option_u8_u64.p_1; if (err18 === undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(option_mapOr$1surhce(part19, 170, (n5: rt.u8): rt.u8 => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(option_mapOr$0vxw5sq(part19, 170, (n5: rs.u8): rs.u8 => { return n5; - }), rt.u64Low(part20) & 0xff))); + }), rs.u64Low(part20) & 0xff))); } else { - rt.byteVecPush(out, returns_Error.code(err18 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err18 as returns_Error.Error)); } - const part21: rt.u64 | undefined = optLast(data.data, data.start, data.length); + const part21: rs.u64 | undefined = optLast(data.data, data.start, data.length); const err19: returns_Error.Error | undefined = part21 === undefined ? out$tuple2_u64_Option_i128.err as returns_Error.Error : undefined; - const part22: rt.i128 | undefined = out$tuple2_u64_Option_i128.p_1; + const part22: rs.i128 | undefined = out$tuple2_u64_Option_i128.p_1; if (err19 === undefined) { - const len2: rt.u64 = part21 as rt.u64; - const n2: rt.i128 | undefined = part22; - rt.byteVecPush(out, rt.u64Low(len2) & 0xff); - put$returns_Put_i128(option_unwrapOr$06r8g1t(n2, -1), out); + const len2: rs.u64 = part21 as rs.u64; + const n2: rs.i128 | undefined = part22; + rs.byteVecPush(out, rs.u64Low(len2) & 0xff); + put$returns_Put_i128(option_unwrapOr$12qj13x(n2, -1), out); } else { - rt.byteVecPush(out, returns_Error.code(err19 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err19 as returns_Error.Error)); } const err20: returns_Error.Error | undefined = optRest(data.data, data.start, data.length); - const part23: rt.u16 | undefined = out$tuple2_Option_u16_ref_slice_u8.p_0; + const part23: rs.u16 | undefined = out$tuple2_Option_u16_ref_slice_u8.p_0; const part26: number = out$tuple2_Option_u16_ref_slice_u8.p_1Len; if (err20 === undefined) { - const n3: rt.u16 | undefined = part23; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(n3 !== undefined ? 1 : 0, (option_unwrapOr$1j4op5y(n3, 0) >> 8) & 0xff, part26 & 0xff))); + const n3: rs.u16 | undefined = part23; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(n3 !== undefined ? 1 : 0, (option_unwrapOr$1szdyfq(n3, 0) >> 8) & 0xff, part26 & 0xff))); } else { - rt.byteVecPush(out, returns_Error.code(err20 as returns_Error.Error)); + rs.byteVecPush(out, returns_Error.code(err20 as returns_Error.Error)); } const err21: returns_Error.Error | undefined = optU64(data.data, data.start, data.length); - const part27: rt.u64 | undefined = out$Option_u64.p; + const part27: rs.u64 | undefined = out$Option_u64.p; const err22: returns_Error.Error | undefined = optU64(tail.data, tail.start, tail.length); - const part28: rt.u64 | undefined = out$Option_u64.p; + const part28: rs.u64 | undefined = out$Option_u64.p; b20: { if (err21 === undefined) { if (err22 === undefined) { if (part27 !== undefined) { if (part28 !== undefined) { - put$returns_Put_u64(rt.u64Xor(part27, part28), out); + put$returns_Put_u64(rs.u64Xor(part27, part28), out); break b20; } } } } - const x5: rt.Result = (err21 !== undefined ? rt.Err(err21 as returns_Error.Error) : rt.Ok(part27)) as rt.Result; - const y5: rt.Result = (err22 !== undefined ? rt.Err(err22 as returns_Error.Error) : rt.Ok(part28)) as rt.Result; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(x5.ok ? 1 : 0, y5.ok ? 1 : 0, result_eq$11dy112(x5, y5) ? 1 : 0))); + const x5: rs.Result = (err21 !== undefined ? rs.Err(err21 as returns_Error.Error) : rs.Ok(part27)) as rs.Result; + const y5: rs.Result = (err22 !== undefined ? rs.Err(err22 as returns_Error.Error) : rs.Ok(part28)) as rs.Result; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(x5.ok ? 1 : 0, y5.ok ? 1 : 0, result_eq$14w6i0g(x5, y5) ? 1 : 0))); } - for (const r of rt.iterToVec(rt.iterMap(new rt.Range(0, 3), (i: rt.usize): rt.Result => { - const _3: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, i)); + for (const r of rs.iterToVec(rs.iterMap(new rs.Range(0, 3), (i: rs.usize): rs.Result => { + const _3: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, i)); const err23 = optU64(_3.data, _3.start, _3.length); - return err23 !== undefined ? rt.Err(err23 as returns_Error.Error) : rt.Ok(out$Option_u64.p); + return err23 !== undefined ? rs.Err(err23 as returns_Error.Error) : rs.Ok(out$Option_u64.p); }), undefined, 16, true).items) { if (r.ok) { if (r.value === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v17: rt.u64 = r.value; - rt.byteVecPush(out, 1); + const v17: rs.u64 = r.value; + rs.byteVecPush(out, 1); put$returns_Put_u64(v17, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(r.error)))); } } - if (!(rt.u8Rem(kind, 2) === 0)) { - f = (d: rt.ByteSlice): rt.Result => { - const _32: rt.ByteSlice = rt.byteSliceRange(d, rt.min(d.length, 1)); + if (!(rs.u8Rem(kind, 2) === 0)) { + f = (d: rs.ByteSlice): rs.Result => { + const _32: rs.ByteSlice = rs.byteSliceRange(d, rs.min(d.length, 1)); const err25 = optI64(_32.data, _32.start, _32.length); - return err25 !== undefined ? rt.Err(err25 as returns_Error.Error) : rt.Ok(out$Option_i64.p); + return err25 !== undefined ? rs.Err(err25 as returns_Error.Error) : rs.Ok(out$Option_i64.p); }; } else { - f = (a0: rt.ByteSlice): rt.Result => { + f = (a0: rs.ByteSlice): rs.Result => { const err24 = optI64(a0.data, a0.start, a0.length); - return err24 !== undefined ? rt.Err(err24 as returns_Error.Error) : rt.Ok(out$Option_i64.p); + return err24 !== undefined ? rs.Err(err24 as returns_Error.Error) : rs.Ok(out$Option_i64.p); }; } - const _310: rt.Result = f(data); + const _310: rs.Result = f(data); if (_310.ok) { if (_310.value === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const v18: rt.i64 = _310.value; - rt.byteVecPush(out, 1); + const v18: rs.i64 = _310.value; + rs.byteVecPush(out, 1); put$returns_Put_i64(v18, out); } } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(238, returns_Error.code(_310.error)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(238, returns_Error.code(_310.error)))); } - let rest2: rt.ByteSlice = data; - let sum: rt.u32 = 0; + let rest2: rs.ByteSlice = data; + let sum: rs.u32 = 0; while (true) { - const _325: rt.ByteSlice = rest2; + const _325: rs.ByteSlice = rest2; const err26: returns_Error.Error | undefined = optU32(_325.data, _325.start, _325.length); - const part31: rt.u32 | undefined = out$Option_u32.p; + const part31: rs.u32 | undefined = out$Option_u32.p; if (err26 === undefined) { if (part31 !== undefined) { - const n4: rt.u32 = part31; - sum = rt.u32WrappingAdd(rt.u32WrappingMul(sum, 31), n4); - rest2 = rt.byteSliceRange(rest2, rt.max(rt.min(rt.usizeRem(n4 as rt.usize, 5), rest2.length), 1)); + const n4: rs.u32 = part31; + sum = rs.u32WrappingAdd(rs.u32WrappingMul(sum, 31), n4); + rest2 = rs.byteSliceRange(rest2, rs.max(rs.min(rs.usizeRem(n4 as rs.usize, 5), rest2.length), 1)); } else { break; } diff --git a/ts/fixtures/lang/rings/expected/core/option.ts b/ts/fixtures/lang/rings/expected/core/option.ts index 07f3e7865..5263a7208 100644 --- a/ts/fixtures/lang/rings/expected/core/option.ts +++ b/ts/fixtures/lang/rings/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { +export function mapOr$0z4nmg2(self: [rs.u8, rs.ByteSlice] | undefined, default_: [rs.u8, rs.ByteSlice], f: (a0: [rs.u8, rs.ByteSlice]) => [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/rings/expected/harness.ts b/ts/fixtures/lang/rings/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/rings/expected/harness.ts +++ b/ts/fixtures/lang/rings/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/rings/expected/lib.ts b/ts/fixtures/lang/rings/expected/lib.ts index ce85175f8..11e55499a 100644 --- a/ts/fixtures/lang/rings/expected/lib.ts +++ b/ts/fixtures/lang/rings/expected/lib.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { slices } from "./rings.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["rings::slices", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["rings::slices", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { slices(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/rings/expected/rings.Big.ts b/ts/fixtures/lang/rings/expected/rings.Big.ts index 85f357d3e..9ca0be749 100644 --- a/ts/fixtures/lang/rings/expected/rings.Big.ts +++ b/ts/fixtures/lang/rings/expected/rings.Big.ts @@ -1,42 +1,42 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Big): Big { - return { id: self.id, pad: rt.byteSliceToArray(rt.byteSliceFrom(self.pad)) }; + return { id: self.id, pad: rs.byteSliceToArray(rs.byteSliceFrom(self.pad)) }; } -export function partialCmp$cmp_PartialOrd(self: Big, other: Big): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Big, other: Big): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Big, other: Big): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.id, other.id); +export function cmp$cmp_Ord(self: Big, other: Big): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.id, other.id); if (cmp === 0) { - return rt.cmpBytes(rt.byteSliceFrom(self.pad), rt.byteSliceFrom(other.pad)); + return rs.cmpBytes(rs.byteSliceFrom(self.pad), rs.byteSliceFrom(other.pad)); } return cmp; } /** Past 1 KiB, which std's grows from one slot rather than four. */ export interface Big { - id: rt.u8; + id: rs.u8; pad: Uint8Array; } -export function fmt$fmt_Debug(self: Big, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Big, f: rs.Formatter): rs.Result { const part = self.pad[1099]; const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(part, f)]; - return rt.fmtWriteFmt(f, ["B", args2[0], ".", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(part, f)]; + return rs.fmtWriteFmt(f, ["B", args2[0], ".", args2[1]]); } -export function make$rings_Item(b: rt.u8): Big { - return { id: b, pad: rt.bytes(1100).fill(b) }; +export function make$rings_Item(b: rs.u8): Big { + return { id: b, pad: rs.bytes(1100).fill(b) }; } export function bump$rings_Item(self: Big): void { - self.id = rt.u8WrappingAdd(self.id, 1); + self.id = rs.u8WrappingAdd(self.id, 1); } //# sourceMappingURL=rings.Big.ts.map diff --git a/ts/fixtures/lang/rings/expected/rings.ts b/ts/fixtures/lang/rings/expected/rings.ts index 5f102491c..b712edece 100644 --- a/ts/fixtures/lang/rings/expected/rings.ts +++ b/ts/fixtures/lang/rings/expected/rings.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; import * as Big from "./rings.Big.ts"; -export function make$rings_Item_u8(b: rt.u8): rt.u8 { +export function make$rings_Item_u8(b: rs.u8): rs.u8 { return b; } -export function bump$rings_Item_u8(self: rt.Place): void { - self.v = rt.u8WrappingAdd(self.v, 1); +export function bump$rings_Item_u8(self: rs.Place): void { + self.v = rs.u8WrappingAdd(self.v, 1); } -export function make$rings_Item_u32(b: rt.u8): rt.u32 { - return ((b as rt.u32) << 12) >>> 0; +export function make$rings_Item_u32(b: rs.u8): rs.u32 { + return ((b as rs.u32) << 12) >>> 0; } -export function bump$rings_Item_u32(self: rt.Place): void { - self.v = rt.u32Add(self.v, 1); +export function bump$rings_Item_u32(self: rs.Place): void { + self.v = rs.u32Add(self.v, 1); } -export function make$rings_Item_String(b: rt.u8): string { - const part = rt.u8Rem(b, 16); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; - return rt.fmtFormat(["s", args2[0]]); +export function make$rings_Item_String(b: rs.u8): string { + const part = rs.u8Rem(b, 16); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; + return rs.fmtFormat(["s", args2[0]]); } -export function bump$rings_Item_String(self: rt.Place): void { +export function bump$rings_Item_String(self: rs.Place): void { self.v = self.v + "!"; } -export function make$rings_Item_unit(_1: rt.u8): void { +export function make$rings_Item_unit(_1: rs.u8): void { } -export function bump$rings_Item_unit(_self: rt.Place): void { +export function bump$rings_Item_unit(_self: rs.Place): void { } /** Steps a deque of the item type `kind` picks through `data`. */ -export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 5); +export function slices(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 5); if (_4 === 0) { steps$u8(dataData, dataStart, dataLen, out); } else if (_4 === 1) { @@ -53,305 +53,305 @@ export function slices(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat } /** A length or capacity, as four bytes. */ -export function put(out: rt.ByteVec, n: rt.usize): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(n as rt.u32).reverse())); +export function put(out: rs.ByteVec, n: rs.usize): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(n as rs.u32).reverse())); } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_String(out: rt.ByteVec, value: string | undefined): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtStr)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Option_ref_String(out: rs.ByteVec, value: string | undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtStr)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_rings_Big(out: rt.ByteVec, value: Big.Big | undefined): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Option_ref_rings_Big(out: rs.ByteVec, value: Big.Big | undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_u32(out: rt.ByteVec, value: rt.u32 | undefined): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Option_ref_u32(out: rs.ByteVec, value: rs.u32 | undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_u8(out: rt.ByteVec, value: rt.u8 | undefined): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Option_ref_u8(out: rs.ByteVec, value: rs.u8 | undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$Option_ref_unit(out: rt.ByteVec, value: undefined | rt.None): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.fmtUnit, rt.None)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Option_ref_unit(out: rs.ByteVec, value: undefined | rs.None): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.fmtUnit, rs.None)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$Result_usize_usize(out: rt.ByteVec, value: rt.Result): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(value, f, rt.usizeDebug, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$Result_usize_usize(out: rs.ByteVec, value: rs.Result): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(value, f, rs.usizeDebug, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$String(out: rt.ByteVec, value: string): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$String(out: rs.ByteVec, value: string): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_String(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Drain_String(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_rings_Big(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Drain_rings_Big(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_u32(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Drain_u32(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_u8(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Drain_u8(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Drain_unit(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeDrain(value, f, rt.usizeDebug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Drain_unit(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeDrain(value, f, rs.usizeDebug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_String(out: rt.ByteVec, value: rt.Iter>): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "IterMut")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_String(out: rs.ByteVec, value: rs.Iter>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_rings_Big(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_rings_Big(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_u32(out: rt.ByteVec, value: rt.Iter>): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "IterMut")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_u32(out: rs.ByteVec, value: rs.Iter>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_u8(out: rt.ByteVec, value: rt.Iter>): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "IterMut")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_u8(out: rs.ByteVec, value: rs.Iter>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_IterMut_unit(out: rt.ByteVec, value: rt.Iter>): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "IterMut")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_IterMut_unit(out: rs.ByteVec, value: rs.Iter>): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "IterMut")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_String(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtStr, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_String(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtStr, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_rings_Big(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_rings_Big(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f), "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_u32(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u32Debug, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_u32(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u32Debug, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_u8(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.u8Debug, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_u8(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.u8Debug, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$collections_vec_deque_Iter_unit(out: rt.ByteVec, value: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDequeIter(value, f, rt.fmtUnit, "Iter")]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$collections_vec_deque_Iter_unit(out: rs.ByteVec, value: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDequeIter(value, f, rs.fmtUnit, "Iter")]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_String(out: rt.ByteVec, value: string[]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(value, f, rt.fmtStr)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$mut_slice_String(out: rs.ByteVec, value: string[]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(value, f, rs.fmtStr)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_rings_Big(out: rt.ByteVec, value: Big.Big[]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(value, f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$mut_slice_rings_Big(out: rs.ByteVec, value: Big.Big[]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(value, f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_u32(out: rt.ByteVec, value: rt.u32[]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(value, f, rt.u32Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$mut_slice_u32(out: rs.ByteVec, value: rs.u32[]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(value, f, rs.u32Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_u8(out: rt.ByteVec, value: rt.ByteSlice): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$mut_slice_u8(out: rs.ByteVec, value: rs.ByteSlice): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$mut_slice_unit(out: rt.ByteVec, value: undefined[]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(value, f, rt.fmtUnit)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$mut_slice_unit(out: rs.ByteVec, value: undefined[]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(value, f, rs.fmtUnit)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$rings_Big(out: rt.ByteVec, value: Big.Big): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => Big.fmt$fmt_Debug(value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$rings_Big(out: rs.ByteVec, value: Big.Big): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_String_ref_slice_String(out: rt.ByteVec, value: [string[], string[]]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtStr)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_String_ref_slice_String(out: rs.ByteVec, value: [string[], string[]]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(value[1], f, rs.fmtStr)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rt.ByteVec, value: [Big.Big[], Big.Big[]]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtList(value[1], f, (value: Big.Big, f: rt.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out: rs.ByteVec, value: [Big.Big[], Big.Big[]]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtList(value[1], f, (value: Big.Big, f: rs.Formatter) => Big.fmt$fmt_Debug(value, f))], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rt.ByteVec, value: [rt.u32[], rt.u32[]]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.u32Debug)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_u32_ref_slice_u32(out: rs.ByteVec, value: [rs.u32[], rs.u32[]]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(value[1], f, rs.u32Debug)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rt.ByteVec, value: [rt.ByteSlice, rt.ByteSlice]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[0]), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value[1]), f, rt.u8Debug)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_u8_ref_slice_u8(out: rs.ByteVec, value: [rs.ByteSlice, rs.ByteSlice]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[0]), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value[1]), f, rs.u8Debug)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rt.ByteVec, value: [undefined[], undefined[]]): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.fmtUnit), (f: rt.Formatter) => rt.fmtList(value[1], f, rt.fmtUnit)], f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$tuple2_ref_slice_unit_ref_slice_unit(out: rs.ByteVec, value: [undefined[], undefined[]]): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.fmtUnit), (f: rs.Formatter) => rs.fmtList(value[1], f, rs.fmtUnit)], f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$u32(out: rt.ByteVec, value: rt.u32): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Debug(value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$u32(out: rs.ByteVec, value: rs.u32): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$u8(out: rt.ByteVec, value: rt.u8): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(value, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$u8(out: rs.ByteVec, value: rs.u8): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(value, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** What `{:?}` writes of `value`. */ -export function text$unit(out: rt.ByteVec, _value: undefined): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); +export function text$unit(out: rs.ByteVec, _value: undefined): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); } /** * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and * each pair after it steps: after each, its length, capacity, and two slices. */ -export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let q!: rt.VecDeque; - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let q!: rs.VecDeque; + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _5[0]; - const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); - const _17: rt.u8 = rt.u8Rem(first, 3); + const first: rs.u8 = _5[0]; + const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); + const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rt.dequeNew(12) as rt.VecDeque; + q = rs.dequeNew(12) as rs.VecDeque; } else if (_17 === 1) { - q = rt.dequeWithCapacity(n, 12) as rt.VecDeque; + q = rs.dequeWithCapacity(n, 12) as rs.VecDeque; } else { - q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rt.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_String(first), n, undefined), 12) as rs.VecDeque; } - const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const at: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); b3: { - const _46: rt.u8 = rt.u8Rem(op, 35); + const _46: rs.u8 = rs.u8Rem(op, 35); if (0 <= _46) { if (_46 <= 3) { - rt.dequePushBack(q, make$rings_Item_String(arg)); + rs.dequePushBack(q, make$rings_Item_String(arg)); break b3; } } if (_46 === 4 || _46 === 5) { - rt.dequePushFront(q, make$rings_Item_String(arg)); + rs.dequePushFront(q, make$rings_Item_String(arg)); } else if (_46 === 6) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_46 === 7) { - rt.dequePopBack(q); + rs.dequePopBack(q); } else if (_46 === 8) { - rt.dequeInsert(q, at, make$rings_Item_String(arg)); + rs.dequeInsert(q, at, make$rings_Item_String(arg)); } else if (_46 === 9) { - rt.dequeRemove(q, at); + rs.dequeRemove(q, at); } else if (_46 === 10) { - rt.dequeSwapRemove(q, at); + rs.dequeSwapRemove(q, at); } else if (_46 === 11) { - rt.dequeSwapRemove(q, at, true); + rs.dequeSwapRemove(q, at, true); } else if (_46 === 12) { - rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { - let kept: rt.u8 = arg; - rt.dequeRetain(q, (_25: string): boolean => { - kept = rt.intRotateLeft(kept, 1, 8, false); + let kept: rs.u8 = arg; + rs.dequeRetain(q, (_25: string): boolean => { + kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); } else if (_46 === 14) { drained$String(q, arg, out); } else if (_46 === 15) { - rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserve(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 16) { - rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserveExact(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 17) { - rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeShrinkTo(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 18) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_46 === 19) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 8)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make$rings_Item_String), "next"); } else if (_46 === 20) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_String), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 8)), make$rings_Item_String), undefined, true); } else if (_46 === 21) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_46 === 22) { q = remade$String(q, arg); } else if (_46 === 23) { @@ -359,46 +359,46 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n } else if (_46 === 24) { appended$String(q, arg, out); } else if (_46 === 25) { - rt.dequeResize(q, rt.usizeRem(arg as rt.usize, 16), make$rings_Item_String(arg), undefined); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_String(arg), undefined); } else if (_46 === 26) { - rt.dequeResizeWith(q, rt.usizeRem(arg as rt.usize, 16), (): string => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): string => { return make$rings_Item_String(arg); }); } else if (_46 === 27) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, at); - put(out, rt.dequeCapacity(tail)); - text$tuple2_ref_slice_String_ref_slice_String(out, rt.dequeAsSlices(tail)); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + put(out, rs.dequeCapacity(tail)); + text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(q.n, 1)); - const it: rt.Iter> = rt.dequeRangeMut(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(q.n, start), 1))))); - const _151: rt.Place | rt.Done = it.next(); - if (_151 !== rt.DONE) { + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); + const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.Place | rs.Done = it.next(); + if (_151 !== rs.DONE) { bump$rings_Item_String(_151); } - const _156: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_String(_156); } text$collections_vec_deque_IterMut_String(out, it); } else if (_46 === 29) { - const v: rt.Vec = rt.dequeToVec(q); - put(out, rt.vecCapacity(v, 12)); - q = rt.dequeFromVec(v, 12) as rt.VecDeque; + const v: rs.Vec = rs.dequeToVec(q); + put(out, rs.vecCapacity(v, 12)); + q = rs.dequeFromVec(v, 12) as rs.VecDeque; } else if (_46 === 30) { - rt.dequeRotate(q, at); + rs.dequeRotate(q, at); } else if (_46 === 31) { - rt.dequeRotate(q, at, true); + rs.dequeRotate(q, at, true); } else if (_46 === 32) { if (!(q.n === 0)) { - rt.dequeSwap(q, rt.usizeRem(arg as rt.usize, q.n), rt.usizeRem(arg >> 4 as rt.usize, q.n)); + rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: string[] = rt.dequeMakeContiguous(q); - const _190: rt.Place | undefined = rt.sliceFirstMut(s); + const s: string[] = rs.dequeMakeContiguous(q); + const _190: rs.Place | undefined = rs.sliceFirstMut(s); if (_190 !== undefined) { bump$rings_Item_String(_190); } - const _194: rt.Place | undefined = rt.sliceLastMut(s); + const _194: rs.Place | undefined = rs.sliceLastMut(s); if (_194 !== undefined) { bump$rings_Item_String(_194); } @@ -408,8 +408,8 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n } } put(out, q.n); - put(out, rt.dequeCapacity(q)); - text$tuple2_ref_slice_String_ref_slice_String(out, rt.dequeAsSlices(q)); + put(out, rs.dequeCapacity(q)); + text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(q)); iterated$String(q, arg, out); } } @@ -418,81 +418,81 @@ export function steps$String(dataData: Uint8Array, dataStart: number, dataLen: n * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and * each pair after it steps: after each, its length, capacity, and two slices. */ -export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let q!: rt.VecDeque; - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let q!: rs.VecDeque; + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _5[0]; - const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); - const _17: rt.u8 = rt.u8Rem(first, 3); + const first: rs.u8 = _5[0]; + const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); + const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rt.dequeNew(1101) as rt.VecDeque; + q = rs.dequeNew(1101) as rs.VecDeque; } else if (_17 === 1) { - q = rt.dequeWithCapacity(n, 1101) as rt.VecDeque; + q = rs.dequeWithCapacity(n, 1101) as rs.VecDeque; } else { - q = rt.dequeFromVec(rt.vecFromElem(Big.make$rings_Item(first), n, Big.clone$Clone), 1101) as rt.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(Big.make$rings_Item(first), n, Big.clone$Clone), 1101) as rs.VecDeque; } - const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const at: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); b3: { - const _46: rt.u8 = rt.u8Rem(op, 35); + const _46: rs.u8 = rs.u8Rem(op, 35); if (0 <= _46) { if (_46 <= 3) { - rt.dequePushBack(q, Big.make$rings_Item(arg)); + rs.dequePushBack(q, Big.make$rings_Item(arg)); break b3; } } if (_46 === 4 || _46 === 5) { - rt.dequePushFront(q, Big.make$rings_Item(arg)); + rs.dequePushFront(q, Big.make$rings_Item(arg)); } else if (_46 === 6) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_46 === 7) { - rt.dequePopBack(q); + rs.dequePopBack(q); } else if (_46 === 8) { - rt.dequeInsert(q, at, Big.make$rings_Item(arg)); + rs.dequeInsert(q, at, Big.make$rings_Item(arg)); } else if (_46 === 9) { - rt.dequeRemove(q, at); + rs.dequeRemove(q, at); } else if (_46 === 10) { - rt.dequeSwapRemove(q, at); + rs.dequeSwapRemove(q, at); } else if (_46 === 11) { - rt.dequeSwapRemove(q, at, true); + rs.dequeSwapRemove(q, at, true); } else if (_46 === 12) { - rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { - let kept: rt.u8 = arg; - rt.dequeRetain(q, (_25: Big.Big): boolean => { - kept = rt.intRotateLeft(kept, 1, 8, false); + let kept: rs.u8 = arg; + rs.dequeRetain(q, (_25: Big.Big): boolean => { + kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); } else if (_46 === 14) { drained$rings_Big(q, arg, out); } else if (_46 === 15) { - rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserve(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 16) { - rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserveExact(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 17) { - rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeShrinkTo(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 18) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_46 === 19) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 8)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), Big.make$rings_Item), "next"); } else if (_46 === 20) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), Big.make$rings_Item), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 8)), Big.make$rings_Item), undefined, true); } else if (_46 === 21) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_46 === 22) { q = remade$rings_Big(q, arg); } else if (_46 === 23) { @@ -500,46 +500,46 @@ export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen } else if (_46 === 24) { appended$rings_Big(q, arg, out); } else if (_46 === 25) { - rt.dequeResize(q, rt.usizeRem(arg as rt.usize, 16), Big.make$rings_Item(arg), Big.clone$Clone); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), Big.make$rings_Item(arg), Big.clone$Clone); } else if (_46 === 26) { - rt.dequeResizeWith(q, rt.usizeRem(arg as rt.usize, 16), (): Big.Big => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): Big.Big => { return Big.make$rings_Item(arg); }); } else if (_46 === 27) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, at); - put(out, rt.dequeCapacity(tail)); - text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rt.dequeAsSlices(tail)); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + put(out, rs.dequeCapacity(tail)); + text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(q.n, 1)); - const it: rt.Iter = rt.dequeRange(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(q.n, start), 1))))); - const _151: Big.Big | rt.Done = it.next(); - if (_151 !== rt.DONE) { + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); + const it: rs.Iter = rs.dequeRange(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: Big.Big | rs.Done = it.next(); + if (_151 !== rs.DONE) { Big.bump$rings_Item(_151); } - const _156: Big.Big | undefined = rt.iterToOption(it.nextBack()); + const _156: Big.Big | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { Big.bump$rings_Item(_156); } text$collections_vec_deque_IterMut_rings_Big(out, it); } else if (_46 === 29) { - const v: rt.Vec = rt.dequeToVec(q); - put(out, rt.vecCapacity(v, 1101)); - q = rt.dequeFromVec(v, 1101) as rt.VecDeque; + const v: rs.Vec = rs.dequeToVec(q); + put(out, rs.vecCapacity(v, 1101)); + q = rs.dequeFromVec(v, 1101) as rs.VecDeque; } else if (_46 === 30) { - rt.dequeRotate(q, at); + rs.dequeRotate(q, at); } else if (_46 === 31) { - rt.dequeRotate(q, at, true); + rs.dequeRotate(q, at, true); } else if (_46 === 32) { if (!(q.n === 0)) { - rt.dequeSwap(q, rt.usizeRem(arg as rt.usize, q.n), rt.usizeRem(arg >> 4 as rt.usize, q.n)); + rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: Big.Big[] = rt.dequeMakeContiguous(q); - const _190: Big.Big | undefined = rt.sliceFirst(s); + const s: Big.Big[] = rs.dequeMakeContiguous(q); + const _190: Big.Big | undefined = rs.sliceFirst(s); if (_190 !== undefined) { Big.bump$rings_Item(_190); } - const _194: Big.Big | undefined = rt.sliceLast(s); + const _194: Big.Big | undefined = rs.sliceLast(s); if (_194 !== undefined) { Big.bump$rings_Item(_194); } @@ -549,8 +549,8 @@ export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen } } put(out, q.n); - put(out, rt.dequeCapacity(q)); - text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rt.dequeAsSlices(q)); + put(out, rs.dequeCapacity(q)); + text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rs.dequeAsSlices(q)); iterated$rings_Big(q, arg, out); } } @@ -559,81 +559,81 @@ export function steps$rings_Big(dataData: Uint8Array, dataStart: number, dataLen * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and * each pair after it steps: after each, its length, capacity, and two slices. */ -export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let q!: rt.VecDeque; - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let q!: rs.VecDeque; + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _5[0]; - const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); - const _17: rt.u8 = rt.u8Rem(first, 3); + const first: rs.u8 = _5[0]; + const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); + const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rt.dequeNew(4) as rt.VecDeque; + q = rs.dequeNew(4) as rs.VecDeque; } else if (_17 === 1) { - q = rt.dequeWithCapacity(n, 4) as rt.VecDeque; + q = rs.dequeWithCapacity(n, 4) as rs.VecDeque; } else { - q = rt.dequeFromVec(rt.vecFromElem(make$rings_Item_u32(first), n, undefined), 4) as rt.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(make$rings_Item_u32(first), n, undefined), 4) as rs.VecDeque; } - const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const at: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); b3: { - const _46: rt.u8 = rt.u8Rem(op, 35); + const _46: rs.u8 = rs.u8Rem(op, 35); if (0 <= _46) { if (_46 <= 3) { - rt.dequePushBack(q, make$rings_Item_u32(arg)); + rs.dequePushBack(q, make$rings_Item_u32(arg)); break b3; } } if (_46 === 4 || _46 === 5) { - rt.dequePushFront(q, make$rings_Item_u32(arg)); + rs.dequePushFront(q, make$rings_Item_u32(arg)); } else if (_46 === 6) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_46 === 7) { - rt.dequePopBack(q); + rs.dequePopBack(q); } else if (_46 === 8) { - rt.dequeInsert(q, at, make$rings_Item_u32(arg)); + rs.dequeInsert(q, at, make$rings_Item_u32(arg)); } else if (_46 === 9) { - rt.dequeRemove(q, at); + rs.dequeRemove(q, at); } else if (_46 === 10) { - rt.dequeSwapRemove(q, at); + rs.dequeSwapRemove(q, at); } else if (_46 === 11) { - rt.dequeSwapRemove(q, at, true); + rs.dequeSwapRemove(q, at, true); } else if (_46 === 12) { - rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { - let kept: rt.u8 = arg; - rt.dequeRetain(q, (_25: rt.u32): boolean => { - kept = rt.intRotateLeft(kept, 1, 8, false); + let kept: rs.u8 = arg; + rs.dequeRetain(q, (_25: rs.u32): boolean => { + kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); } else if (_46 === 14) { drained$u32(q, arg, out); } else if (_46 === 15) { - rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserve(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 16) { - rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserveExact(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 17) { - rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeShrinkTo(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 18) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_46 === 19) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 8)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make$rings_Item_u32), "next"); } else if (_46 === 20) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u32), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 8)), make$rings_Item_u32), undefined, true); } else if (_46 === 21) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_46 === 22) { q = remade$u32(q, arg); } else if (_46 === 23) { @@ -641,46 +641,46 @@ export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: numb } else if (_46 === 24) { appended$u32(q, arg, out); } else if (_46 === 25) { - rt.dequeResize(q, rt.usizeRem(arg as rt.usize, 16), make$rings_Item_u32(arg), undefined); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_u32(arg), undefined); } else if (_46 === 26) { - rt.dequeResizeWith(q, rt.usizeRem(arg as rt.usize, 16), (): rt.u32 => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): rs.u32 => { return make$rings_Item_u32(arg); }); } else if (_46 === 27) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, at); - put(out, rt.dequeCapacity(tail)); - text$tuple2_ref_slice_u32_ref_slice_u32(out, rt.dequeAsSlices(tail)); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + put(out, rs.dequeCapacity(tail)); + text$tuple2_ref_slice_u32_ref_slice_u32(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(q.n, 1)); - const it: rt.Iter> = rt.dequeRangeMut(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(q.n, start), 1))))); - const _151: rt.Place | rt.Done = it.next(); - if (_151 !== rt.DONE) { + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); + const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.Place | rs.Done = it.next(); + if (_151 !== rs.DONE) { bump$rings_Item_u32(_151); } - const _156: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_u32(_156); } text$collections_vec_deque_IterMut_u32(out, it); } else if (_46 === 29) { - const v: rt.Vec = rt.dequeToVec(q); - put(out, rt.vecCapacity(v, 4)); - q = rt.dequeFromVec(v, 4) as rt.VecDeque; + const v: rs.Vec = rs.dequeToVec(q); + put(out, rs.vecCapacity(v, 4)); + q = rs.dequeFromVec(v, 4) as rs.VecDeque; } else if (_46 === 30) { - rt.dequeRotate(q, at); + rs.dequeRotate(q, at); } else if (_46 === 31) { - rt.dequeRotate(q, at, true); + rs.dequeRotate(q, at, true); } else if (_46 === 32) { if (!(q.n === 0)) { - rt.dequeSwap(q, rt.usizeRem(arg as rt.usize, q.n), rt.usizeRem(arg >> 4 as rt.usize, q.n)); + rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: rt.u32[] = rt.dequeMakeContiguous(q); - const _190: rt.Place | undefined = rt.sliceFirstMut(s); + const s: rs.u32[] = rs.dequeMakeContiguous(q); + const _190: rs.Place | undefined = rs.sliceFirstMut(s); if (_190 !== undefined) { bump$rings_Item_u32(_190); } - const _194: rt.Place | undefined = rt.sliceLastMut(s); + const _194: rs.Place | undefined = rs.sliceLastMut(s); if (_194 !== undefined) { bump$rings_Item_u32(_194); } @@ -690,8 +690,8 @@ export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: numb } } put(out, q.n); - put(out, rt.dequeCapacity(q)); - text$tuple2_ref_slice_u32_ref_slice_u32(out, rt.dequeAsSlices(q)); + put(out, rs.dequeCapacity(q)); + text$tuple2_ref_slice_u32_ref_slice_u32(out, rs.dequeAsSlices(q)); iterated$u32(q, arg, out); } } @@ -700,81 +700,81 @@ export function steps$u32(dataData: Uint8Array, dataStart: number, dataLen: numb * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and * each pair after it steps: after each, its length, capacity, and two slices. */ -export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let q!: rt.VecDeque; - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let q!: rs.VecDeque; + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _5[0]; - const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); - const _17: rt.u8 = rt.u8Rem(first, 3); + const first: rs.u8 = _5[0]; + const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); + const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rt.dequeNew(1, true) as rt.VecDeque; + q = rs.dequeNew(1, true) as rs.VecDeque; } else if (_17 === 1) { - q = rt.dequeWithCapacity(n, 1, true) as rt.VecDeque; + q = rs.dequeWithCapacity(n, 1, true) as rs.VecDeque; } else { - q = rt.dequeFromVec(rt.byteVecToVec(rt.byteVecOf(make$rings_Item_u8(first), n)), 1, true) as rt.VecDeque; + q = rs.dequeFromVec(rs.byteVecToVec(rs.byteVecOf(make$rings_Item_u8(first), n)), 1, true) as rs.VecDeque; } - const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const at: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); b3: { - const _46: rt.u8 = rt.u8Rem(op, 35); + const _46: rs.u8 = rs.u8Rem(op, 35); if (0 <= _46) { if (_46 <= 3) { - rt.dequePushBack(q, make$rings_Item_u8(arg)); + rs.dequePushBack(q, make$rings_Item_u8(arg)); break b3; } } if (_46 === 4 || _46 === 5) { - rt.dequePushFront(q, make$rings_Item_u8(arg)); + rs.dequePushFront(q, make$rings_Item_u8(arg)); } else if (_46 === 6) { - rt.dequePopFront(q); + rs.dequePopFront(q); } else if (_46 === 7) { - rt.dequePopBack(q); + rs.dequePopBack(q); } else if (_46 === 8) { - rt.dequeInsert(q, at, make$rings_Item_u8(arg)); + rs.dequeInsert(q, at, make$rings_Item_u8(arg)); } else if (_46 === 9) { - rt.dequeRemove(q, at); + rs.dequeRemove(q, at); } else if (_46 === 10) { - rt.dequeSwapRemove(q, at); + rs.dequeSwapRemove(q, at); } else if (_46 === 11) { - rt.dequeSwapRemove(q, at, true); + rs.dequeSwapRemove(q, at, true); } else if (_46 === 12) { - rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { - let kept: rt.u8 = arg; - rt.dequeRetain(q, (_25: rt.u8): boolean => { - kept = rt.intRotateLeft(kept, 1, 8, false); + let kept: rs.u8 = arg; + rs.dequeRetain(q, (_25: rs.u8): boolean => { + kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); } else if (_46 === 14) { drained$u8(q, arg, out); } else if (_46 === 15) { - rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserve(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 16) { - rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserveExact(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 17) { - rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeShrinkTo(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 18) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_46 === 19) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 8)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; }), make$rings_Item_u8), "next"); } else if (_46 === 20) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_u8), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 8)), make$rings_Item_u8), undefined, true); } else if (_46 === 21) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_46 === 22) { q = remade$u8(q, arg); } else if (_46 === 23) { @@ -782,46 +782,46 @@ export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: numbe } else if (_46 === 24) { appended$u8(q, arg, out); } else if (_46 === 25) { - rt.dequeResize(q, rt.usizeRem(arg as rt.usize, 16), make$rings_Item_u8(arg), undefined); + rs.dequeResize(q, rs.usizeRem(arg as rs.usize, 16), make$rings_Item_u8(arg), undefined); } else if (_46 === 26) { - rt.dequeResizeWith(q, rt.usizeRem(arg as rt.usize, 16), (): rt.u8 => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): rs.u8 => { return make$rings_Item_u8(arg); }); } else if (_46 === 27) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, at); - put(out, rt.dequeCapacity(tail)); - text$tuple2_ref_slice_u8_ref_slice_u8(out, rt.dequeByteSlices(tail)); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + put(out, rs.dequeCapacity(tail)); + text$tuple2_ref_slice_u8_ref_slice_u8(out, rs.dequeByteSlices(tail)); } else if (_46 === 28) { - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(q.n, 1)); - const it: rt.Iter> = rt.dequeRangeMut(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(q.n, start), 1))))); - const _151: rt.Place | rt.Done = it.next(); - if (_151 !== rt.DONE) { + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); + const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.Place | rs.Done = it.next(); + if (_151 !== rs.DONE) { bump$rings_Item_u8(_151); } - const _156: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_u8(_156); } text$collections_vec_deque_IterMut_u8(out, it); } else if (_46 === 29) { - const v: rt.ByteVec = rt.byteVecFromVec(rt.dequeToVec(q)); + const v: rs.ByteVec = rs.byteVecFromVec(rs.dequeToVec(q)); put(out, v.data.length); - q = rt.dequeFromVec(rt.byteVecToVec(v), 1, true) as rt.VecDeque; + q = rs.dequeFromVec(rs.byteVecToVec(v), 1, true) as rs.VecDeque; } else if (_46 === 30) { - rt.dequeRotate(q, at); + rs.dequeRotate(q, at); } else if (_46 === 31) { - rt.dequeRotate(q, at, true); + rs.dequeRotate(q, at, true); } else if (_46 === 32) { if (!(q.n === 0)) { - rt.dequeSwap(q, rt.usizeRem(arg as rt.usize, q.n), rt.usizeRem(arg >> 4 as rt.usize, q.n)); + rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: rt.ByteSlice = rt.dequeByteMakeContiguous(q); - const _190: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(s)); + const s: rs.ByteSlice = rs.dequeByteMakeContiguous(q); + const _190: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(s)); if (_190 !== undefined) { bump$rings_Item_u8(_190); } - const _194: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(s)); + const _194: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(s)); if (_194 !== undefined) { bump$rings_Item_u8(_194); } @@ -831,8 +831,8 @@ export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: numbe } } put(out, q.n); - put(out, rt.dequeCapacity(q)); - text$tuple2_ref_slice_u8_ref_slice_u8(out, rt.dequeByteSlices(q)); + put(out, rs.dequeCapacity(q)); + text$tuple2_ref_slice_u8_ref_slice_u8(out, rs.dequeByteSlices(q)); iterated$u8(q, arg, out); } } @@ -841,88 +841,88 @@ export function steps$u8(dataData: Uint8Array, dataStart: number, dataLen: numbe * A deque the first byte makes, new, with room for a few, or from a `Vec` of a few, and * each pair after it steps: after each, its length, capacity, and two slices. */ -export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let q!: rt.VecDeque; - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let q!: rs.VecDeque; + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const first: rt.u8 = _5[0]; - const n: rt.usize = rt.usizeRem(first >> 2 as rt.usize, 12); - const _17: rt.u8 = rt.u8Rem(first, 3); + const first: rs.u8 = _5[0]; + const n: rs.usize = rs.usizeRem(first >> 2 as rs.usize, 12); + const _17: rs.u8 = rs.u8Rem(first, 3); if (_17 === 0) { - q = rt.dequeNew(0) as rt.VecDeque; + q = rs.dequeNew(0) as rs.VecDeque; } else if (_17 === 1) { - q = rt.dequeWithCapacity(n, 0) as rt.VecDeque; + q = rs.dequeWithCapacity(n, 0) as rs.VecDeque; } else { make$rings_Item_unit(first); - q = rt.dequeFromVec(rt.vecFromElem(undefined, n, undefined), 0) as rt.VecDeque; + q = rs.dequeFromVec(rs.vecFromElem(undefined, n, undefined), 0) as rs.VecDeque; } - const iter: rt.Iter = rt.byteSliceChunks(_5[1], 2); + const iter: rs.Iter = rs.byteSliceChunks(_5[1], 2); while (true) { - const _24: rt.ByteSlice | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.ByteSlice | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - rt.idx(_24, 0); - const _30: [rt.u8, rt.u8] = [_24.data[_24.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_24, 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const at: rt.usize = rt.usizeRem(arg as rt.usize, rt.usizeAdd(q.n, 1)); + rs.idx(_24, 0); + const _30: [rs.u8, rs.u8] = [_24.data[_24.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_24, 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const at: rs.usize = rs.usizeRem(arg as rs.usize, rs.usizeAdd(q.n, 1)); b3: { - const _46: rt.u8 = rt.u8Rem(op, 35); + const _46: rs.u8 = rs.u8Rem(op, 35); if (0 <= _46) { if (_46 <= 3) { - const _50: rt.VecDeque = q; + const _50: rs.VecDeque = q; make$rings_Item_unit(arg); - rt.dequePushBack(_50, undefined); + rs.dequePushBack(_50, undefined); break b3; } } if (_46 === 4 || _46 === 5) { - const _52: rt.VecDeque = q; + const _52: rs.VecDeque = q; make$rings_Item_unit(arg); - rt.dequePushFront(_52, undefined); + rs.dequePushFront(_52, undefined); } else if (_46 === 6) { - rt.dequePopFront(q, rt.None); + rs.dequePopFront(q, rs.None); } else if (_46 === 7) { - rt.dequePopBack(q, rt.None); + rs.dequePopBack(q, rs.None); } else if (_46 === 8) { - const _58: rt.VecDeque = q; + const _58: rs.VecDeque = q; make$rings_Item_unit(arg); - rt.dequeInsert(_58, at, undefined); + rs.dequeInsert(_58, at, undefined); } else if (_46 === 9) { - rt.dequeRemove(q, at, rt.None); + rs.dequeRemove(q, at, rs.None); } else if (_46 === 10) { - rt.dequeSwapRemove(q, at, false, rt.None); + rs.dequeSwapRemove(q, at, false, rs.None); } else if (_46 === 11) { - rt.dequeSwapRemove(q, at, true, rt.None); + rs.dequeSwapRemove(q, at, true, rs.None); } else if (_46 === 12) { - rt.dequeTruncate(q, rt.usizeRem(arg as rt.usize, 8)); + rs.dequeTruncate(q, rs.usizeRem(arg as rs.usize, 8)); } else if (_46 === 13) { - let kept: rt.u8 = arg; - rt.dequeRetain(q, (_25: undefined): boolean => { - kept = rt.intRotateLeft(kept, 1, 8, false); + let kept: rs.u8 = arg; + rs.dequeRetain(q, (_25: undefined): boolean => { + kept = rs.intRotateLeft(kept, 1, 8, false); return (kept & 1) === 1; }); } else if (_46 === 14) { drained$unit(q, arg, out); } else if (_46 === 15) { - rt.dequeReserve(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserve(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 16) { - rt.dequeReserveExact(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeReserveExact(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 17) { - rt.dequeShrinkTo(q, rt.usizeRem(arg as rt.usize, 12)); + rs.dequeShrinkTo(q, rs.usizeRem(arg as rs.usize, 12)); } else if (_46 === 18) { - rt.dequeShrinkTo(q, 0); + rs.dequeShrinkTo(q, 0); } else if (_46 === 19) { - rt.dequeExtend(q, rt.iterMap(rt.iterFilter(new rt.Range(0, rt.u8Rem(arg, 8)), (i: rt.u8): boolean => { - return rt.u8Rem(i, 3) !== 0; - }), make$rings_Item_unit as (a0: rt.u8) => undefined), "next"); + rs.dequeExtend(q, rs.iterMap(rs.iterFilter(new rs.Range(0, rs.u8Rem(arg, 8)), (i: rs.u8): boolean => { + return rs.u8Rem(i, 3) !== 0; + }), make$rings_Item_unit as (a0: rs.u8) => undefined), "next"); } else if (_46 === 20) { - rt.dequeExtend(q, rt.iterMap(new rt.Range(0, rt.u8Rem(arg, 8)), make$rings_Item_unit as (a0: rt.u8) => undefined), undefined, true); + rs.dequeExtend(q, rs.iterMap(new rs.Range(0, rs.u8Rem(arg, 8)), make$rings_Item_unit as (a0: rs.u8) => undefined), undefined, true); } else if (_46 === 21) { - rt.dequeClear(q); + rs.dequeClear(q); } else if (_46 === 22) { q = remade$unit(q, arg); } else if (_46 === 23) { @@ -930,49 +930,49 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num } else if (_46 === 24) { appended$unit(q, arg, out); } else if (_46 === 25) { - const _105: rt.VecDeque = q; - const _106: rt.usize = rt.usizeRem(arg as rt.usize, 16); + const _105: rs.VecDeque = q; + const _106: rs.usize = rs.usizeRem(arg as rs.usize, 16); make$rings_Item_unit(arg); - rt.dequeResize(_105, _106, undefined, undefined); + rs.dequeResize(_105, _106, undefined, undefined); } else if (_46 === 26) { - rt.dequeResizeWith(q, rt.usizeRem(arg as rt.usize, 16), (): undefined => { + rs.dequeResizeWith(q, rs.usizeRem(arg as rs.usize, 16), (): undefined => { make$rings_Item_unit(arg); }); } else if (_46 === 27) { - const tail: rt.VecDeque = rt.dequeSplitOff(q, at); - put(out, rt.dequeCapacity(tail)); - text$tuple2_ref_slice_unit_ref_slice_unit(out, rt.dequeAsSlices(tail)); + const tail: rs.VecDeque = rs.dequeSplitOff(q, at); + put(out, rs.dequeCapacity(tail)); + text$tuple2_ref_slice_unit_ref_slice_unit(out, rs.dequeAsSlices(tail)); } else if (_46 === 28) { - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(q.n, 1)); - const it: rt.Iter> = rt.dequeRangeMut(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(q.n, start), 1))))); - const _151: rt.Place | rt.Done = it.next(); - if (_151 !== rt.DONE) { + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(q.n, 1)); + const it: rs.Iter> = rs.dequeRangeMut(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(q.n, start), 1))))); + const _151: rs.Place | rs.Done = it.next(); + if (_151 !== rs.DONE) { bump$rings_Item_unit(_151); } - const _156: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _156: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_156 !== undefined) { bump$rings_Item_unit(_156); } text$collections_vec_deque_IterMut_unit(out, it); } else if (_46 === 29) { - const v: rt.Vec = rt.dequeToVec(q); - put(out, rt.vecCapacity(v, 0)); - q = rt.dequeFromVec(v, 0) as rt.VecDeque; + const v: rs.Vec = rs.dequeToVec(q); + put(out, rs.vecCapacity(v, 0)); + q = rs.dequeFromVec(v, 0) as rs.VecDeque; } else if (_46 === 30) { - rt.dequeRotate(q, at); + rs.dequeRotate(q, at); } else if (_46 === 31) { - rt.dequeRotate(q, at, true); + rs.dequeRotate(q, at, true); } else if (_46 === 32) { if (!(q.n === 0)) { - rt.dequeSwap(q, rt.usizeRem(arg as rt.usize, q.n), rt.usizeRem(arg >> 4 as rt.usize, q.n)); + rs.dequeSwap(q, rs.usizeRem(arg as rs.usize, q.n), rs.usizeRem(arg >> 4 as rs.usize, q.n)); } } else if (_46 === 33) { - const s: undefined[] = rt.dequeMakeContiguous(q); - const _190: rt.Place | undefined = rt.sliceFirstMut(s); + const s: undefined[] = rs.dequeMakeContiguous(q); + const _190: rs.Place | undefined = rs.sliceFirstMut(s); if (_190 !== undefined) { bump$rings_Item_unit(_190); } - const _194: rt.Place | undefined = rt.sliceLastMut(s); + const _194: rs.Place | undefined = rs.sliceLastMut(s); if (_194 !== undefined) { bump$rings_Item_unit(_194); } @@ -982,8 +982,8 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num } } put(out, q.n); - put(out, rt.dequeCapacity(q)); - text$tuple2_ref_slice_unit_ref_slice_unit(out, rt.dequeAsSlices(q)); + put(out, rs.dequeCapacity(q)); + text$tuple2_ref_slice_unit_ref_slice_unit(out, rs.dequeAsSlices(q)); iterated$unit(q, arg, out); } } @@ -994,62 +994,62 @@ export function steps$unit(dataData: Uint8Array, dataStart: number, dataLen: num * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through * adaptors in place of another. */ -export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { - let _0!: rt.VecDeque; - const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); - const _8: rt.u8 = rt.u8Rem(arg, 5); +export function remade$String(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; + const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); + const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 12) as rt.VecDeque; + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 12) as rs.VecDeque; const _18: string = make$rings_Item_String(arg); - rt.dequePushFront(own, _18); + rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } else { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } return own; } - return rt.dequeClone(q); + return rs.dequeClone(q); } if (_8 === 1) { - const it: rt.Iter = rt.dequeIntoIter(q); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = skip; + const it: rs.Iter = rs.dequeIntoIter(q); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - rt.iterToOption(it.nextBack()); - return rt.dequeFromIntoIter(it, 12) as rt.VecDeque; + rs.iterToOption(it.nextBack()); + return rs.dequeFromIntoIter(it, 12) as rs.VecDeque; } if (_8 === 2) { - const it2: rt.Iter = rt.dequeIntoIter(q); - rt.iterNth(it2, skip); - return rt.dequeFromIntoIter(it2, 12) as rt.VecDeque; + const it2: rs.Iter = rs.dequeIntoIter(q); + rs.iterNth(it2, skip); + return rs.dequeFromIntoIter(it2, 12) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 12, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); let kept: boolean = false; - return rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_2: string): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: string): boolean => { kept = !kept; return kept; - }), "next", 12, false, 12), 12) as rt.VecDeque; + }), "next", 12, false, 12), 12) as rs.VecDeque; } - return rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 12, true), 12) as rt.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true), 12) as rs.VecDeque; } - const v2: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 12, true); - rt.vecReserve(v2, skip, 12); - const it3: rt.Iter = rt.vecIntoIter(v2); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 12, true); + rs.vecReserve(v2, skip, 12); + const it3: rs.Iter = rs.vecIntoIter(v2); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); + rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rt.dequeFromIntoIter(it3, 12) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 12) as rs.VecDeque; } else { - _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 12) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 12) as rs.VecDeque; } return _0; } @@ -1060,62 +1060,62 @@ export function remade$String(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeque { - let _0!: rt.VecDeque; - const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); - const _8: rt.u8 = rt.u8Rem(arg, 5); +export function remade$rings_Big(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; + const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); + const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1101) as rt.VecDeque; + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 1101) as rs.VecDeque; const _18: Big.Big = Big.make$rings_Item(arg); - rt.dequePushFront(own, _18); + rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rt.dequeCloneFrom(own, q, Big.clone$Clone); + rs.dequeCloneFrom(own, q, Big.clone$Clone); } else { - rt.dequeCloneFrom(own, q, Big.clone$Clone); + rs.dequeCloneFrom(own, q, Big.clone$Clone); } return own; } - return rt.dequeClone(q, Big.clone$Clone); + return rs.dequeClone(q, Big.clone$Clone); } if (_8 === 1) { - const it: rt.Iter = rt.dequeIntoIter(q); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = skip; + const it: rs.Iter = rs.dequeIntoIter(q); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - rt.iterToOption(it.nextBack()); - return rt.dequeFromIntoIter(it, 1101) as rt.VecDeque; + rs.iterToOption(it.nextBack()); + return rs.dequeFromIntoIter(it, 1101) as rs.VecDeque; } if (_8 === 2) { - const it2: rt.Iter = rt.dequeIntoIter(q); - rt.iterNth(it2, skip); - return rt.dequeFromIntoIter(it2, 1101) as rt.VecDeque; + const it2: rs.Iter = rs.dequeIntoIter(q); + rs.iterNth(it2, skip); + return rs.dequeFromIntoIter(it2, 1101) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 1101, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 1101, true); let kept: boolean = false; - return rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_2: Big.Big): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: Big.Big): boolean => { kept = !kept; return kept; - }), "next", 1101, false, 1101), 1101) as rt.VecDeque; + }), "next", 1101, false, 1101), 1101) as rs.VecDeque; } - return rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 1101, true), 1101) as rt.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 1101, true), 1101) as rs.VecDeque; } - const v2: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 1101, true); - rt.vecReserve(v2, skip, 1101); - const it3: rt.Iter = rt.vecIntoIter(v2); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 1101, true); + rs.vecReserve(v2, skip, 1101); + const it3: rs.Iter = rs.vecIntoIter(v2); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); + rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rt.dequeFromIntoIter(it3, 1101) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 1101) as rs.VecDeque; } else { - _0 = rt.dequeFromIntoIter(it3.clone({ v: Big.clone$Clone }), 1101) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: Big.clone$Clone }), 1101) as rs.VecDeque; } return _0; } @@ -1126,62 +1126,62 @@ export function remade$rings_Big(q: rt.VecDeque, arg: rt.u8): rt.VecDeq * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through * adaptors in place of another. */ -export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { - let _0!: rt.VecDeque; - const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); - const _8: rt.u8 = rt.u8Rem(arg, 5); +export function remade$u32(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; + const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); + const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 4) as rt.VecDeque; - const _18: rt.u32 = make$rings_Item_u32(arg); - rt.dequePushFront(own, _18); + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 4) as rs.VecDeque; + const _18: rs.u32 = make$rings_Item_u32(arg); + rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } else { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } return own; } - return rt.dequeClone(q); + return rs.dequeClone(q); } if (_8 === 1) { - const it: rt.Iter = rt.dequeIntoIter(q); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = skip; + const it: rs.Iter = rs.dequeIntoIter(q); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - rt.iterToOption(it.nextBack()); - return rt.dequeFromIntoIter(it, 4) as rt.VecDeque; + rs.iterToOption(it.nextBack()); + return rs.dequeFromIntoIter(it, 4) as rs.VecDeque; } if (_8 === 2) { - const it2: rt.Iter = rt.dequeIntoIter(q); - rt.iterNth(it2, skip); - return rt.dequeFromIntoIter(it2, 4) as rt.VecDeque; + const it2: rs.Iter = rs.dequeIntoIter(q); + rs.iterNth(it2, skip); + return rs.dequeFromIntoIter(it2, 4) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 4, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 4, true); let kept: boolean = false; - return rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_2: rt.u32): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: rs.u32): boolean => { kept = !kept; return kept; - }), "next", 4, false, 4), 4) as rt.VecDeque; + }), "next", 4, false, 4), 4) as rs.VecDeque; } - return rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 4, true), 4) as rt.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 4, true), 4) as rs.VecDeque; } - const v2: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 4, true); - rt.vecReserve(v2, skip, 4); - const it3: rt.Iter = rt.vecIntoIter(v2); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 4, true); + rs.vecReserve(v2, skip, 4); + const it3: rs.Iter = rs.vecIntoIter(v2); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); + rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rt.dequeFromIntoIter(it3, 4) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 4) as rs.VecDeque; } else { - _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 4) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 4) as rs.VecDeque; } return _0; } @@ -1192,62 +1192,62 @@ export function remade$u32(q: rt.VecDeque, arg: rt.u8): rt.VecDeque, arg: rt.u8): rt.VecDeque { - let _0!: rt.VecDeque; - const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); - const _8: rt.u8 = rt.u8Rem(arg, 5); +export function remade$u8(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; + const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); + const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 1, true) as rt.VecDeque; - const _18: rt.u8 = make$rings_Item_u8(arg); - rt.dequePushFront(own, _18); + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 1, true) as rs.VecDeque; + const _18: rs.u8 = make$rings_Item_u8(arg); + rs.dequePushFront(own, _18); if ((arg & 64) === 0) { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } else { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } return own; } - return rt.dequeClone(q); + return rs.dequeClone(q); } if (_8 === 1) { - const it: rt.Iter = rt.dequeIntoIter(q); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = skip; + const it: rs.Iter = rs.dequeIntoIter(q); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - rt.iterToOption(it.nextBack()); - return rt.dequeFromIntoIter(it, 1, true) as rt.VecDeque; + rs.iterToOption(it.nextBack()); + return rs.dequeFromIntoIter(it, 1, true) as rs.VecDeque; } if (_8 === 2) { - const it2: rt.Iter = rt.dequeIntoIter(q); - rt.iterNth(it2, skip); - return rt.dequeFromIntoIter(it2, 1, true) as rt.VecDeque; + const it2: rs.Iter = rs.dequeIntoIter(q); + rs.iterNth(it2, skip); + return rs.dequeFromIntoIter(it2, 1, true) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); + const v: rs.ByteVec = rs.iterToByteVec(rs.dequeIntoIter(q), undefined, true); let kept: boolean = false; - return rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.byteVecIntoIter(v), (_2: rt.u8): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.byteVecIntoIter(v), (_2: rs.u8): boolean => { kept = !kept; return kept; - }), "next", 1, false, 1), 1, true) as rt.VecDeque; + }), "next", 1, false, 1), 1, true) as rs.VecDeque; } - return rt.dequeFromVec(rt.byteVecToVec(rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true)), 1, true) as rt.VecDeque; + return rs.dequeFromVec(rs.byteVecToVec(rs.iterToByteVec(rs.dequeIntoIter(q), undefined, true)), 1, true) as rs.VecDeque; } - const v2: rt.ByteVec = rt.iterToByteVec(rt.dequeIntoIter(q), undefined, true); - rt.byteVecReserve(v2, skip); - const it3: rt.Iter = rt.byteVecIntoIter(v2); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; + const v2: rs.ByteVec = rs.iterToByteVec(rs.dequeIntoIter(q), undefined, true); + rs.byteVecReserve(v2, skip); + const it3: rs.Iter = rs.byteVecIntoIter(v2); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next()); + rs.iterToOption(it3.next()); } if ((arg & 64) === 0) { - _0 = rt.dequeFromIntoIter(it3, 1, true) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 1, true) as rs.VecDeque; } else { - _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 1, true) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 1, true) as rs.VecDeque; } return _0; } @@ -1258,62 +1258,62 @@ export function remade$u8(q: rt.VecDeque, arg: rt.u8): rt.VecDeque * whose buffers std's takes as they are, or from a `Vec` it collects, directly or through * adaptors in place of another. */ -export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque { - let _0!: rt.VecDeque; - const skip: rt.usize = rt.usizeRem(rt.u8Div(arg, 5) as rt.usize, 4); - const _8: rt.u8 = rt.u8Rem(arg, 5); +export function remade$unit(q: rs.VecDeque, arg: rs.u8): rs.VecDeque { + let _0!: rs.VecDeque; + const skip: rs.usize = rs.usizeRem(rs.u8Div(arg, 5) as rs.usize, 4); + const _8: rs.u8 = rs.u8Rem(arg, 5); if (_8 === 0) { if (!((arg & 32) === 0)) { - const own: rt.VecDeque = rt.dequeWithCapacity(rt.usizeMul(skip, 3), 0) as rt.VecDeque; + const own: rs.VecDeque = rs.dequeWithCapacity(rs.usizeMul(skip, 3), 0) as rs.VecDeque; make$rings_Item_unit(arg); - rt.dequePushFront(own, undefined); + rs.dequePushFront(own, undefined); if ((arg & 64) === 0) { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } else { - rt.dequeCloneFrom(own, q, undefined); + rs.dequeCloneFrom(own, q, undefined); } return own; } - return rt.dequeClone(q); + return rs.dequeClone(q); } if (_8 === 1) { - const it: rt.Iter = rt.dequeIntoIter(q); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = skip; + const it: rs.Iter = rs.dequeIntoIter(q); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = skip; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next(), rt.None); + rs.iterToOption(it.next(), rs.None); } - rt.iterToOption(it.nextBack(), rt.None); - return rt.dequeFromIntoIter(it, 0) as rt.VecDeque; + rs.iterToOption(it.nextBack(), rs.None); + return rs.dequeFromIntoIter(it, 0) as rs.VecDeque; } if (_8 === 2) { - const it2: rt.Iter = rt.dequeIntoIter(q); - rt.iterNth(it2, skip, undefined, rt.None); - return rt.dequeFromIntoIter(it2, 0) as rt.VecDeque; + const it2: rs.Iter = rs.dequeIntoIter(q); + rs.iterNth(it2, skip, undefined, rs.None); + return rs.dequeFromIntoIter(it2, 0) as rs.VecDeque; } if (_8 === 3) { if (!((arg & 32) === 0)) { - const v: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 0, true); + const v: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 0, true); let kept: boolean = false; - return rt.dequeFromVec(rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v), (_2: undefined): boolean => { + return rs.dequeFromVec(rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v), (_2: undefined): boolean => { kept = !kept; return kept; - }), "next", 0), 0) as rt.VecDeque; + }), "next", 0), 0) as rs.VecDeque; } - return rt.dequeFromVec(rt.iterToVec(rt.dequeIntoIter(q), undefined, 0, true), 0) as rt.VecDeque; + return rs.dequeFromVec(rs.iterToVec(rs.dequeIntoIter(q), undefined, 0, true), 0) as rs.VecDeque; } - const v2: rt.Vec = rt.iterToVec(rt.dequeIntoIter(q), undefined, 0, true); - rt.vecReserve(v2, skip, 0); - const it3: rt.Iter = rt.vecIntoIter(v2); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = skip; + const v2: rs.Vec = rs.iterToVec(rs.dequeIntoIter(q), undefined, 0, true); + rs.vecReserve(v2, skip, 0); + const it3: rs.Iter = rs.vecIntoIter(v2); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = skip; while (iterStart2++ < iterEnd2) { - rt.iterToOption(it3.next(), rt.None); + rs.iterToOption(it3.next(), rs.None); } if ((arg & 64) === 0) { - _0 = rt.dequeFromIntoIter(it3, 0) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3, 0) as rs.VecDeque; } else { - _0 = rt.dequeFromIntoIter(it3.clone({ v: rt.itself }), 0) as rt.VecDeque; + _0 = rs.dequeFromIntoIter(it3.clone({ v: rs.itself }), 0) as rs.VecDeque; } return _0; } @@ -1322,249 +1322,249 @@ export function remade$unit(q: rt.VecDeque, arg: rt.u8): rt.VecDeque< * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _16!: rt.u8; - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 4) as rt.usize, 12) as rt.VecDeque; - const _10: rt.u8 = (arg >> 2) & 7; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _10; +export function appended$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _16!: rs.u8; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 12) as rs.VecDeque; + const _10: rs.u8 = (arg >> 2) & 7; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u8 = _16; - if (rt.u8Rem(i, 3) === 2) { + const i: rs.u8 = _16; + if (rs.u8Rem(i, 3) === 2) { const _23: string = make$rings_Item_String(i); - rt.dequePushFront(other, _23); + rs.dequePushFront(other, _23); } else { const _25: string = make$rings_Item_String(i); - rt.dequePushBack(other, _25); + rs.dequePushBack(other, _25); } } - rt.dequeAppend(q, other); - put(out, rt.dequeCapacity(other)); + rs.dequeAppend(q, other); + put(out, rs.dequeCapacity(other)); const _33: string = make$rings_Item_String(arg); - rt.dequePushFront(other, _33); + rs.dequePushFront(other, _33); const _36: string = make$rings_Item_String(arg); - rt.dequePushBack(other, _36); - text$tuple2_ref_slice_String_ref_slice_String(out, rt.dequeAsSlices(other)); + rs.dequePushBack(other, _36); + text$tuple2_ref_slice_String_ref_slice_String(out, rs.dequeAsSlices(other)); } /** * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _16!: rt.u8; - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 4) as rt.usize, 1101) as rt.VecDeque; - const _10: rt.u8 = (arg >> 2) & 7; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _10; +export function appended$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _16!: rs.u8; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 1101) as rs.VecDeque; + const _10: rs.u8 = (arg >> 2) & 7; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u8 = _16; - if (rt.u8Rem(i, 3) === 2) { + const i: rs.u8 = _16; + if (rs.u8Rem(i, 3) === 2) { const _23: Big.Big = Big.make$rings_Item(i); - rt.dequePushFront(other, _23); + rs.dequePushFront(other, _23); } else { const _25: Big.Big = Big.make$rings_Item(i); - rt.dequePushBack(other, _25); + rs.dequePushBack(other, _25); } } - rt.dequeAppend(q, other); - put(out, rt.dequeCapacity(other)); + rs.dequeAppend(q, other); + put(out, rs.dequeCapacity(other)); const _33: Big.Big = Big.make$rings_Item(arg); - rt.dequePushFront(other, _33); + rs.dequePushFront(other, _33); const _36: Big.Big = Big.make$rings_Item(arg); - rt.dequePushBack(other, _36); - text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rt.dequeAsSlices(other)); + rs.dequePushBack(other, _36); + text$tuple2_ref_slice_rings_Big_ref_slice_rings_Big(out, rs.dequeAsSlices(other)); } /** * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _16!: rt.u8; - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 4) as rt.usize, 4) as rt.VecDeque; - const _10: rt.u8 = (arg >> 2) & 7; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _10; +export function appended$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _16!: rs.u8; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 4) as rs.VecDeque; + const _10: rs.u8 = (arg >> 2) & 7; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u8 = _16; - if (rt.u8Rem(i, 3) === 2) { - const _23: rt.u32 = make$rings_Item_u32(i); - rt.dequePushFront(other, _23); + const i: rs.u8 = _16; + if (rs.u8Rem(i, 3) === 2) { + const _23: rs.u32 = make$rings_Item_u32(i); + rs.dequePushFront(other, _23); } else { - const _25: rt.u32 = make$rings_Item_u32(i); - rt.dequePushBack(other, _25); + const _25: rs.u32 = make$rings_Item_u32(i); + rs.dequePushBack(other, _25); } } - rt.dequeAppend(q, other); - put(out, rt.dequeCapacity(other)); - const _33: rt.u32 = make$rings_Item_u32(arg); - rt.dequePushFront(other, _33); - const _36: rt.u32 = make$rings_Item_u32(arg); - rt.dequePushBack(other, _36); - text$tuple2_ref_slice_u32_ref_slice_u32(out, rt.dequeAsSlices(other)); + rs.dequeAppend(q, other); + put(out, rs.dequeCapacity(other)); + const _33: rs.u32 = make$rings_Item_u32(arg); + rs.dequePushFront(other, _33); + const _36: rs.u32 = make$rings_Item_u32(arg); + rs.dequePushBack(other, _36); + text$tuple2_ref_slice_u32_ref_slice_u32(out, rs.dequeAsSlices(other)); } /** * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _16!: rt.u8; - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 4) as rt.usize, 1, true) as rt.VecDeque; - const _10: rt.u8 = (arg >> 2) & 7; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _10; +export function appended$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _16!: rs.u8; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 1, true) as rs.VecDeque; + const _10: rs.u8 = (arg >> 2) & 7; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u8 = _16; - if (rt.u8Rem(i, 3) === 2) { - const _23: rt.u8 = make$rings_Item_u8(i); - rt.dequePushFront(other, _23); + const i: rs.u8 = _16; + if (rs.u8Rem(i, 3) === 2) { + const _23: rs.u8 = make$rings_Item_u8(i); + rs.dequePushFront(other, _23); } else { - const _25: rt.u8 = make$rings_Item_u8(i); - rt.dequePushBack(other, _25); + const _25: rs.u8 = make$rings_Item_u8(i); + rs.dequePushBack(other, _25); } } - rt.dequeAppend(q, other); - put(out, rt.dequeCapacity(other)); - const _33: rt.u8 = make$rings_Item_u8(arg); - rt.dequePushFront(other, _33); - const _36: rt.u8 = make$rings_Item_u8(arg); - rt.dequePushBack(other, _36); - text$tuple2_ref_slice_u8_ref_slice_u8(out, rt.dequeByteSlices(other)); + rs.dequeAppend(q, other); + put(out, rs.dequeCapacity(other)); + const _33: rs.u8 = make$rings_Item_u8(arg); + rs.dequePushFront(other, _33); + const _36: rs.u8 = make$rings_Item_u8(arg); + rs.dequePushBack(other, _36); + text$tuple2_ref_slice_u8_ref_slice_u8(out, rs.dequeByteSlices(other)); } /** * Another deque's items, wrapped as `arg` picks, moved to `q`'s back, and what that leaves * it, which shows where its head is once pushed at both ends. */ -export function appended$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _16!: rt.u8; - const other: rt.VecDeque = rt.dequeWithCapacity(rt.u8Rem(arg, 4) as rt.usize, 0) as rt.VecDeque; - const _10: rt.u8 = (arg >> 2) & 7; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _10; +export function appended$unit(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _16!: rs.u8; + const other: rs.VecDeque = rs.dequeWithCapacity(rs.u8Rem(arg, 4) as rs.usize, 0) as rs.VecDeque; + const _10: rs.u8 = (arg >> 2) & 7; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _10; while ((_16 = iterStart++) < iterEnd) { - const i: rt.u8 = _16; - if (rt.u8Rem(i, 3) === 2) { + const i: rs.u8 = _16; + if (rs.u8Rem(i, 3) === 2) { make$rings_Item_unit(i); - rt.dequePushFront(other, undefined); + rs.dequePushFront(other, undefined); } else { make$rings_Item_unit(i); - rt.dequePushBack(other, undefined); + rs.dequePushBack(other, undefined); } } - rt.dequeAppend(q, other); - put(out, rt.dequeCapacity(other)); + rs.dequeAppend(q, other); + put(out, rs.dequeCapacity(other)); make$rings_Item_unit(arg); - rt.dequePushFront(other, undefined); + rs.dequePushFront(other, undefined); make$rings_Item_unit(arg); - rt.dequePushBack(other, undefined); - text$tuple2_ref_slice_unit_ref_slice_unit(out, rt.dequeAsSlices(other)); + rs.dequePushBack(other, undefined); + text$tuple2_ref_slice_unit_ref_slice_unit(out, rs.dequeAsSlices(other)); } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const len: rt.usize = q.n; - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); - const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); +export function drained$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const len: rs.usize = q.n; + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_String(out, d); if ((arg & 64) !== 0) { - rt.iterToOption(d.next()); + rs.iterToOption(d.next()); } if ((arg & 128) !== 0) { - rt.iterToOption(d.nextBack()); + rs.iterToOption(d.nextBack()); } text$collections_vec_deque_Drain_String(out, d); - rt.drop(d); + rs.drop(d); } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const len: rt.usize = q.n; - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); - const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); +export function drained$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const len: rs.usize = q.n; + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_rings_Big(out, d); if ((arg & 64) !== 0) { - rt.iterToOption(d.next()); + rs.iterToOption(d.next()); } if ((arg & 128) !== 0) { - rt.iterToOption(d.nextBack()); + rs.iterToOption(d.nextBack()); } text$collections_vec_deque_Drain_rings_Big(out, d); - rt.drop(d); + rs.drop(d); } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const len: rt.usize = q.n; - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); - const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); +export function drained$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const len: rs.usize = q.n; + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_u32(out, d); if ((arg & 64) !== 0) { - rt.iterToOption(d.next()); + rs.iterToOption(d.next()); } if ((arg & 128) !== 0) { - rt.iterToOption(d.nextBack()); + rs.iterToOption(d.nextBack()); } text$collections_vec_deque_Drain_u32(out, d); - rt.drop(d); + rs.drop(d); } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const len: rt.usize = q.n; - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); - const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); +export function drained$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const len: rs.usize = q.n; + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_u8(out, d); if ((arg & 64) !== 0) { - rt.iterToOption(d.next()); + rs.iterToOption(d.next()); } if ((arg & 128) !== 0) { - rt.iterToOption(d.nextBack()); + rs.iterToOption(d.nextBack()); } text$collections_vec_deque_Drain_u8(out, d); - rt.drop(d); + rs.drop(d); } /** A drain of a range `arg` picks, written as it is read from either end and then dropped. */ -export function drained$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const len: rt.usize = q.n; - const start: rt.usize = rt.usizeRem((arg & 7) as rt.usize, rt.usizeAdd(len, 1)); - const d: rt.Iter = rt.dequeDrain(q, new rt.Range(start, rt.usizeAdd(start, rt.usizeRem(((arg >> 3) & 7) as rt.usize, rt.usizeAdd(rt.usizeSub(len, start), 1))))); +export function drained$unit(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const len: rs.usize = q.n; + const start: rs.usize = rs.usizeRem((arg & 7) as rs.usize, rs.usizeAdd(len, 1)); + const d: rs.Iter = rs.dequeDrain(q, new rs.Range(start, rs.usizeAdd(start, rs.usizeRem(((arg >> 3) & 7) as rs.usize, rs.usizeAdd(rs.usizeSub(len, start), 1))))); text$collections_vec_deque_Drain_unit(out, d); if ((arg & 64) !== 0) { - rt.iterToOption(d.next(), rt.None); + rs.iterToOption(d.next(), rs.None); } if ((arg & 128) !== 0) { - rt.iterToOption(d.nextBack(), rt.None); + rs.iterToOption(d.nextBack(), rs.None); } text$collections_vec_deque_Drain_unit(out, d); - rt.drop(d); + rs.drop(d); } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const _6: [string[], string[]] = rt.dequeAsSlices(q, true); - const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); +export function mutated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [string[], string[]] = rs.dequeAsSlices(q, true); + const _7: rs.Place | undefined = rs.sliceFirstMut(_6[0]); if (_7 !== undefined) { bump$rings_Item_String(_7); } - const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + const _11: rs.Place | undefined = rs.sliceLastMut(_6[1]); if (_11 !== undefined) { bump$rings_Item_String(_11); } - const it: rt.Iter> = rt.dequeIterMut(q); - const _18: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _18; + const it: rs.Iter> = rs.dequeIterMut(q); + const _18: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rt.Place | rt.Done = it.next(); - if (_24 !== rt.DONE) { + const _24: rs.Place | rs.Done = it.next(); + if (_24 !== rs.DONE) { bump$rings_Item_String(_24); } } - const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_String(_29); } @@ -1572,27 +1572,27 @@ export function mutated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteV } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const _6: [Big.Big[], Big.Big[]] = rt.dequeAsSlices(q, true); - const _7: Big.Big | undefined = rt.sliceFirst(_6[0]); +export function mutated$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [Big.Big[], Big.Big[]] = rs.dequeAsSlices(q, true); + const _7: Big.Big | undefined = rs.sliceFirst(_6[0]); if (_7 !== undefined) { Big.bump$rings_Item(_7); } - const _11: Big.Big | undefined = rt.sliceLast(_6[1]); + const _11: Big.Big | undefined = rs.sliceLast(_6[1]); if (_11 !== undefined) { Big.bump$rings_Item(_11); } - const it: rt.Iter = rt.dequeIter(q); - const _18: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _18; + const it: rs.Iter = rs.dequeIter(q); + const _18: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: Big.Big | rt.Done = it.next(); - if (_24 !== rt.DONE) { + const _24: Big.Big | rs.Done = it.next(); + if (_24 !== rs.DONE) { Big.bump$rings_Item(_24); } } - const _29: Big.Big | undefined = rt.iterToOption(it.nextBack()); + const _29: Big.Big | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { Big.bump$rings_Item(_29); } @@ -1600,27 +1600,27 @@ export function mutated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.B } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const _6: [rt.u32[], rt.u32[]] = rt.dequeAsSlices(q, true); - const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); +export function mutated$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [rs.u32[], rs.u32[]] = rs.dequeAsSlices(q, true); + const _7: rs.Place | undefined = rs.sliceFirstMut(_6[0]); if (_7 !== undefined) { bump$rings_Item_u32(_7); } - const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + const _11: rs.Place | undefined = rs.sliceLastMut(_6[1]); if (_11 !== undefined) { bump$rings_Item_u32(_11); } - const it: rt.Iter> = rt.dequeIterMut(q); - const _18: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _18; + const it: rs.Iter> = rs.dequeIterMut(q); + const _18: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rt.Place | rt.Done = it.next(); - if (_24 !== rt.DONE) { + const _24: rs.Place | rs.Done = it.next(); + if (_24 !== rs.DONE) { bump$rings_Item_u32(_24); } } - const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_u32(_29); } @@ -1628,27 +1628,27 @@ export function mutated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec) } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const _6: [rt.ByteSlice, rt.ByteSlice] = rt.dequeByteSlices(q); - const _7: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_6[0])); +export function mutated$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [rs.ByteSlice, rs.ByteSlice] = rs.dequeByteSlices(q); + const _7: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_6[0])); if (_7 !== undefined) { bump$rings_Item_u8(_7); } - const _11: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_6[1])); + const _11: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_6[1])); if (_11 !== undefined) { bump$rings_Item_u8(_11); } - const it: rt.Iter> = rt.dequeIterMut(q); - const _18: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _18; + const it: rs.Iter> = rs.dequeIterMut(q); + const _18: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rt.Place | rt.Done = it.next(); - if (_24 !== rt.DONE) { + const _24: rs.Place | rs.Done = it.next(); + if (_24 !== rs.DONE) { bump$rings_Item_u8(_24); } } - const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_u8(_29); } @@ -1656,27 +1656,27 @@ export function mutated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): } /** Items bumped through `as_mut_slices`, then through `iter_mut` read in part, written. */ -export function mutated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const _6: [undefined[], undefined[]] = rt.dequeAsSlices(q, true); - const _7: rt.Place | undefined = rt.sliceFirstMut(_6[0]); +export function mutated$unit(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const _6: [undefined[], undefined[]] = rs.dequeAsSlices(q, true); + const _7: rs.Place | undefined = rs.sliceFirstMut(_6[0]); if (_7 !== undefined) { bump$rings_Item_unit(_7); } - const _11: rt.Place | undefined = rt.sliceLastMut(_6[1]); + const _11: rs.Place | undefined = rs.sliceLastMut(_6[1]); if (_11 !== undefined) { bump$rings_Item_unit(_11); } - const it: rt.Iter> = rt.dequeIterMut(q); - const _18: rt.u8 = rt.u8Rem(arg, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _18; + const it: rs.Iter> = rs.dequeIterMut(q); + const _18: rs.u8 = rs.u8Rem(arg, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _18; while (iterStart++ < iterEnd) { - const _24: rt.Place | rt.Done = it.next(); - if (_24 !== rt.DONE) { + const _24: rs.Place | rs.Done = it.next(); + if (_24 !== rs.DONE) { bump$rings_Item_unit(_24); } } - const _29: rt.Place | undefined = rt.iterToOption(it.nextBack()); + const _29: rs.Place | undefined = rs.iterToOption(it.nextBack()); if (_29 !== undefined) { bump$rings_Item_unit(_29); } @@ -1687,22 +1687,22 @@ export function mutated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.Byte * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { +export function searched$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { const x: string = make$rings_Item_String(arg); - text$Result_usize_usize(out, rt.dequeBinarySearch(q, x, rt.cmpStr)); - text$Result_usize_usize(out, rt.dequeBinarySearchBy(q, (y: string): rt.Ordering => { + text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, rs.cmpStr)); + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: string): rs.Ordering => { text$String(out, y); - return rt.cmpStr(y, x); + return rs.cmpStr(y, x); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(x, f)]; - text$Result_usize_usize(out, rt.dequeBinarySearchByKey(q, rt.fmtFormat([args2[0]]), (y2: string): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(x, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: string): string => { text$String(out, y2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(y2, f)]; - return rt.fmtFormat([args4[0]]); - }, rt.cmpStr)); - put(out, rt.dequePartitionPoint(q, (y3: string): boolean => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(y2, f)]; + return rs.fmtFormat([args4[0]]); + }, rs.cmpStr)); + put(out, rs.dequePartitionPoint(q, (y3: string): boolean => { text$String(out, y3); - return rt.cmpStr(y3, x) === -1; + return rs.cmpStr(y3, x) === -1; })); } @@ -1710,20 +1710,20 @@ export function searched$String(q: rt.VecDeque, arg: rt.u8, out: rt.Byte * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { +export function searched$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { const x: Big.Big = Big.make$rings_Item(arg); - text$Result_usize_usize(out, rt.dequeBinarySearch(q, x, Big.cmp$cmp_Ord)); - text$Result_usize_usize(out, rt.dequeBinarySearchBy(q, (y: Big.Big): rt.Ordering => { + text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, Big.cmp$cmp_Ord)); + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: Big.Big): rs.Ordering => { text$rings_Big(out, y); return Big.cmp$cmp_Ord(y, x); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Big.fmt$fmt_Debug(x, f)]; - text$Result_usize_usize(out, rt.dequeBinarySearchByKey(q, rt.fmtFormat([args2[0]]), (y2: Big.Big): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(x, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: Big.Big): string => { text$rings_Big(out, y2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Big.fmt$fmt_Debug(y2, f)]; - return rt.fmtFormat([args4[0]]); - }, rt.cmpStr)); - put(out, rt.dequePartitionPoint(q, (y3: Big.Big): boolean => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => Big.fmt$fmt_Debug(y2, f)]; + return rs.fmtFormat([args4[0]]); + }, rs.cmpStr)); + put(out, rs.dequePartitionPoint(q, (y3: Big.Big): boolean => { text$rings_Big(out, y3); return Big.partialCmp$cmp_PartialOrd(y3, x) === -1; })); @@ -1733,20 +1733,20 @@ export function searched$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt. * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const x: rt.u32 = make$rings_Item_u32(arg); - text$Result_usize_usize(out, rt.dequeBinarySearch(q, x, rt.cmp)); - text$Result_usize_usize(out, rt.dequeBinarySearchBy(q, (y: rt.u32): rt.Ordering => { +export function searched$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const x: rs.u32 = make$rings_Item_u32(arg); + text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, rs.cmp)); + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: rs.u32): rs.Ordering => { text$u32(out, y); - return rt.cmp(y, x); + return rs.cmp(y, x); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Debug(x, f)]; - text$Result_usize_usize(out, rt.dequeBinarySearchByKey(q, rt.fmtFormat([args2[0]]), (y2: rt.u32): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(x, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u32): string => { text$u32(out, y2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Debug(y2, f)]; - return rt.fmtFormat([args4[0]]); - }, rt.cmpStr)); - put(out, rt.dequePartitionPoint(q, (y3: rt.u32): boolean => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(y2, f)]; + return rs.fmtFormat([args4[0]]); + }, rs.cmpStr)); + put(out, rs.dequePartitionPoint(q, (y3: rs.u32): boolean => { text$u32(out, y3); return y3 < x; })); @@ -1756,20 +1756,20 @@ export function searched$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - const x: rt.u8 = make$rings_Item_u8(arg); - text$Result_usize_usize(out, rt.dequeBinarySearch(q, x, rt.cmp)); - text$Result_usize_usize(out, rt.dequeBinarySearchBy(q, (y: rt.u8): rt.Ordering => { +export function searched$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + const x: rs.u8 = make$rings_Item_u8(arg); + text$Result_usize_usize(out, rs.dequeBinarySearch(q, x, rs.cmp)); + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: rs.u8): rs.Ordering => { text$u8(out, y); - return rt.cmp(y, x); + return rs.cmp(y, x); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(x, f)]; - text$Result_usize_usize(out, rt.dequeBinarySearchByKey(q, rt.fmtFormat([args2[0]]), (y2: rt.u8): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(x, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: rs.u8): string => { text$u8(out, y2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(y2, f)]; - return rt.fmtFormat([args4[0]]); - }, rt.cmpStr)); - put(out, rt.dequePartitionPoint(q, (y3: rt.u8): boolean => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(y2, f)]; + return rs.fmtFormat([args4[0]]); + }, rs.cmpStr)); + put(out, rs.dequePartitionPoint(q, (y3: rs.u8): boolean => { text$u8(out, y3); return y3 < x; })); @@ -1779,57 +1779,57 @@ export function searched$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): * Where each binary search finds an item `arg` makes, of items that need not be sorted, * and each item it probes. */ -export function searched$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { +export function searched$unit(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { make$rings_Item_unit(arg); - text$Result_usize_usize(out, rt.dequeBinarySearch(q, undefined, rt.cmpNothing)); - text$Result_usize_usize(out, rt.dequeBinarySearchBy(q, (y: undefined): rt.Ordering => { + text$Result_usize_usize(out, rs.dequeBinarySearch(q, undefined, rs.cmpNothing)); + text$Result_usize_usize(out, rs.dequeBinarySearchBy(q, (y: undefined): rs.Ordering => { text$unit(out, y); - return rt.cmpNothing(y, undefined); + return rs.cmpNothing(y, undefined); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - text$Result_usize_usize(out, rt.dequeBinarySearchByKey(q, rt.fmtFormat([args2[0]]), (y2: undefined): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + text$Result_usize_usize(out, rs.dequeBinarySearchByKey(q, rs.fmtFormat([args2[0]]), (y2: undefined): string => { text$unit(out, y2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - return rt.fmtFormat([args4[0]]); - }, rt.cmpStr)); - put(out, rt.dequePartitionPoint(q, (y3: undefined): boolean => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + return rs.fmtFormat([args4[0]]); + }, rs.cmpStr)); + put(out, rs.dequePartitionPoint(q, (y3: undefined): boolean => { text$unit(out, y3); - return rt.cmpNothing(y3, undefined) === -1; + return rs.cmpNothing(y3, undefined) === -1; })); } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$String(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _10!: rt.u32; +export function iterated$String(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _10!: rs.u32; let read!: string | undefined; - const it: rt.Iter = rt.dequeIter(q); + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_String(out, it); - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = 3; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = 3; while ((_10 = iterStart++) < iterEnd) { - const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); - let count: rt.u8 = (pick >> 3) & 3; - const _22: rt.u8 = rt.u8Rem(pick, 7); + const pick: rs.u8 = rs.intRotateLeft(arg, rs.u32Mul(3, _10), 8, false); + let count: rs.u8 = (pick >> 3) & 3; + const _22: rs.u8 = rs.u8Rem(pick, 7); if (_22 === 0) { - read = rt.iterToOption(it.next()); + read = rs.iterToOption(it.next()); } else if (_22 === 1) { - read = rt.iterToOption(it.nextBack()); + read = rs.iterToOption(it.nextBack()); } else if (_22 === 2) { - read = rt.iterNth(it, count as rt.usize); + read = rs.iterNth(it, count as rs.usize); } else if (_22 === 3) { - read = rt.iterNthBack(it, count as rt.usize); + read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rt.iterFind(it, (_24: string): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterFind(it, (_24: string): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rt.iterRfind(it, (_2: string): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterRfind(it, (_2: string): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else { - read = rt.iterToOption(it.clone().next()); + read = rs.iterToOption(it.clone().next()); } text$Option_ref_String(out, read); text$collections_vec_deque_Iter_String(out, it); @@ -1837,37 +1837,37 @@ export function iterated$String(q: rt.VecDeque, arg: rt.u8, out: rt.Byte } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _10!: rt.u32; +export function iterated$rings_Big(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _10!: rs.u32; let read!: Big.Big | undefined; - const it: rt.Iter = rt.dequeIter(q); + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_rings_Big(out, it); - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = 3; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = 3; while ((_10 = iterStart++) < iterEnd) { - const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); - let count: rt.u8 = (pick >> 3) & 3; - const _22: rt.u8 = rt.u8Rem(pick, 7); + const pick: rs.u8 = rs.intRotateLeft(arg, rs.u32Mul(3, _10), 8, false); + let count: rs.u8 = (pick >> 3) & 3; + const _22: rs.u8 = rs.u8Rem(pick, 7); if (_22 === 0) { - read = rt.iterToOption(it.next()); + read = rs.iterToOption(it.next()); } else if (_22 === 1) { - read = rt.iterToOption(it.nextBack()); + read = rs.iterToOption(it.nextBack()); } else if (_22 === 2) { - read = rt.iterNth(it, count as rt.usize); + read = rs.iterNth(it, count as rs.usize); } else if (_22 === 3) { - read = rt.iterNthBack(it, count as rt.usize); + read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rt.iterFind(it, (_24: Big.Big): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterFind(it, (_24: Big.Big): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rt.iterRfind(it, (_2: Big.Big): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterRfind(it, (_2: Big.Big): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else { - read = rt.iterToOption(it.clone().next()); + read = rs.iterToOption(it.clone().next()); } text$Option_ref_rings_Big(out, read); text$collections_vec_deque_Iter_rings_Big(out, it); @@ -1875,37 +1875,37 @@ export function iterated$rings_Big(q: rt.VecDeque, arg: rt.u8, out: rt. } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _10!: rt.u32; - let read!: rt.u32 | undefined; - const it: rt.Iter = rt.dequeIter(q); +export function iterated$u32(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _10!: rs.u32; + let read!: rs.u32 | undefined; + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_u32(out, it); - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = 3; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = 3; while ((_10 = iterStart++) < iterEnd) { - const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); - let count: rt.u8 = (pick >> 3) & 3; - const _22: rt.u8 = rt.u8Rem(pick, 7); + const pick: rs.u8 = rs.intRotateLeft(arg, rs.u32Mul(3, _10), 8, false); + let count: rs.u8 = (pick >> 3) & 3; + const _22: rs.u8 = rs.u8Rem(pick, 7); if (_22 === 0) { - read = rt.iterToOption(it.next()); + read = rs.iterToOption(it.next()); } else if (_22 === 1) { - read = rt.iterToOption(it.nextBack()); + read = rs.iterToOption(it.nextBack()); } else if (_22 === 2) { - read = rt.iterNth(it, count as rt.usize); + read = rs.iterNth(it, count as rs.usize); } else if (_22 === 3) { - read = rt.iterNthBack(it, count as rt.usize); + read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rt.iterFind(it, (_24: rt.u32): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterFind(it, (_24: rs.u32): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rt.iterRfind(it, (_2: rt.u32): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterRfind(it, (_2: rs.u32): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else { - read = rt.iterToOption(it.clone().next()); + read = rs.iterToOption(it.clone().next()); } text$Option_ref_u32(out, read); text$collections_vec_deque_Iter_u32(out, it); @@ -1913,37 +1913,37 @@ export function iterated$u32(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _10!: rt.u32; - let read!: rt.u8 | undefined; - const it: rt.Iter = rt.dequeIter(q); +export function iterated$u8(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _10!: rs.u32; + let read!: rs.u8 | undefined; + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_u8(out, it); - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = 3; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = 3; while ((_10 = iterStart++) < iterEnd) { - const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); - let count: rt.u8 = (pick >> 3) & 3; - const _22: rt.u8 = rt.u8Rem(pick, 7); + const pick: rs.u8 = rs.intRotateLeft(arg, rs.u32Mul(3, _10), 8, false); + let count: rs.u8 = (pick >> 3) & 3; + const _22: rs.u8 = rs.u8Rem(pick, 7); if (_22 === 0) { - read = rt.iterToOption(it.next()); + read = rs.iterToOption(it.next()); } else if (_22 === 1) { - read = rt.iterToOption(it.nextBack()); + read = rs.iterToOption(it.nextBack()); } else if (_22 === 2) { - read = rt.iterNth(it, count as rt.usize); + read = rs.iterNth(it, count as rs.usize); } else if (_22 === 3) { - read = rt.iterNthBack(it, count as rt.usize); + read = rs.iterNthBack(it, count as rs.usize); } else if (_22 === 4) { - read = rt.iterFind(it, (_24: rt.u8): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterFind(it, (_24: rs.u8): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else if (_22 === 5) { - read = rt.iterRfind(it, (_2: rt.u8): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterRfind(it, (_2: rs.u8): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; }); } else { - read = rt.iterToOption(it.clone().next()); + read = rs.iterToOption(it.clone().next()); } text$Option_ref_u8(out, read); text$collections_vec_deque_Iter_u8(out, it); @@ -1951,37 +1951,37 @@ export function iterated$u8(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): } /** `q`'s `Iter`, written before and after each of three reads `arg` picks. */ -export function iterated$unit(q: rt.VecDeque, arg: rt.u8, out: rt.ByteVec): void { - let _10!: rt.u32; - let read!: undefined | rt.None; - const it: rt.Iter = rt.dequeIter(q); +export function iterated$unit(q: rs.VecDeque, arg: rs.u8, out: rs.ByteVec): void { + let _10!: rs.u32; + let read!: undefined | rs.None; + const it: rs.Iter = rs.dequeIter(q); text$collections_vec_deque_Iter_unit(out, it); - let iterStart: rt.u32 = 0; - const iterEnd: rt.u32 = 3; + let iterStart: rs.u32 = 0; + const iterEnd: rs.u32 = 3; while ((_10 = iterStart++) < iterEnd) { - const pick: rt.u8 = rt.intRotateLeft(arg, rt.u32Mul(3, _10), 8, false); - let count: rt.u8 = (pick >> 3) & 3; - const _22: rt.u8 = rt.u8Rem(pick, 7); + const pick: rs.u8 = rs.intRotateLeft(arg, rs.u32Mul(3, _10), 8, false); + let count: rs.u8 = (pick >> 3) & 3; + const _22: rs.u8 = rs.u8Rem(pick, 7); if (_22 === 0) { - read = rt.iterToOption(it.next(), rt.None); + read = rs.iterToOption(it.next(), rs.None); } else if (_22 === 1) { - read = rt.iterToOption(it.nextBack(), rt.None); + read = rs.iterToOption(it.nextBack(), rs.None); } else if (_22 === 2) { - read = rt.iterNth(it, count as rt.usize, undefined, rt.None); + read = rs.iterNth(it, count as rs.usize, undefined, rs.None); } else if (_22 === 3) { - read = rt.iterNthBack(it, count as rt.usize, undefined, rt.None); + read = rs.iterNthBack(it, count as rs.usize, undefined, rs.None); } else if (_22 === 4) { - read = rt.iterFind(it, (_24: undefined): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterFind(it, (_24: undefined): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; - }, undefined, rt.None); + }, undefined, rs.None); } else if (_22 === 5) { - read = rt.iterRfind(it, (_2: undefined): boolean => { - count = rt.u8SaturatingSub(count, 1); + read = rs.iterRfind(it, (_2: undefined): boolean => { + count = rs.u8SaturatingSub(count, 1); return count === 0; - }, undefined, rt.None); + }, undefined, rs.None); } else { - read = rt.iterToOption(it.clone().next(), rt.None); + read = rs.iterToOption(it.clone().next(), rs.None); } text$Option_ref_unit(out, read); text$collections_vec_deque_Iter_unit(out, it); diff --git a/ts/fixtures/lang/saturates/expected/core/option.ts b/ts/fixtures/lang/saturates/expected/core/option.ts index 45fcd396d..0856a8d27 100644 --- a/ts/fixtures/lang/saturates/expected/core/option.ts +++ b/ts/fixtures/lang/saturates/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$08u1px1(self: rt.Ordering | undefined, f: (a0: rt.Ordering) => boolean): boolean { +export function isSomeAnd$0dtzjhd(self: rs.Ordering | undefined, f: (a0: rs.Ordering) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/saturates/expected/harness.ts b/ts/fixtures/lang/saturates/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/saturates/expected/harness.ts +++ b/ts/fixtures/lang/saturates/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/saturates/expected/lib.ts b/ts/fixtures/lang/saturates/expected/lib.ts index ef18f154e..8b69c5f34 100644 --- a/ts/fixtures/lang/saturates/expected/lib.ts +++ b/ts/fixtures/lang/saturates/expected/lib.ts @@ -1,54 +1,54 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { u8s, u16s, u32s, u64s, u128s, usizes, i8s, i16s, i32s, i64s, i128s, isizes } from "./saturates.ts"; import * as Gauge from "./saturates.Gauge.ts"; -export function copy$saturates_Gauge_i128(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_i128(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_i16(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_i16(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_i32(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_i32(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_i64(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_i64(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_i8(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_i8(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_isize(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_isize(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_u128(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_u128(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_u16(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_u16(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_u32(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_u32(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_u64(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_u64(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_u8(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_u8(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } -export function copy$saturates_Gauge_usize(v: Gauge.Gauge): Gauge.Gauge { +export function copy$saturates_Gauge_usize(v: Gauge.Gauge): Gauge.Gauge { return new Gauge.Gauge(v._0); } @@ -56,8 +56,8 @@ export function copy$saturates_Gauge_usize(v: Gauge.Gauge): Gauge.Gaug * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["saturates::u8s", u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u16s", u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u32s", u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u64s", u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::u128s", u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::usizes", usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i8s", i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i16s", i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i32s", i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i64s", i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::i128s", i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["saturates::isizes", isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["saturates::u8s", u8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::u16s", u16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::u32s", u32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::u64s", u64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::u128s", u128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::usizes", usizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::i8s", i8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::i16s", i16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::i32s", i32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::i64s", i64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::i128s", i128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["saturates::isizes", isizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts b/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts index 836cfaa6b..8a8eedc3a 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.Gauge.ts @@ -1,269 +1,269 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug_i128(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i128(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i128Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i128Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i16(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i16(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i32(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i32(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i32Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i64(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i64(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i64Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i8(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i8(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_isize(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_isize(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.isizeDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.isizeDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u128(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u128(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u128Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u128Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u16(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u16(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u32(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u32(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u32Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u64(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u64(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u64Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u8(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_usize(self: Gauge, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_usize(self: Gauge, f: rs.Formatter): rs.Result { const _3: string = "Gauge"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function default$Default_i128(): Gauge { +export function default$Default_i128(): Gauge { return new Gauge(0); } -export function default$Default_i16(): Gauge { +export function default$Default_i16(): Gauge { return new Gauge(0); } -export function default$Default_i32(): Gauge { +export function default$Default_i32(): Gauge { return new Gauge(0); } -export function default$Default_i64(): Gauge { +export function default$Default_i64(): Gauge { return new Gauge(0); } -export function default$Default_i8(): Gauge { +export function default$Default_i8(): Gauge { return new Gauge(0); } -export function default$Default_isize(): Gauge { +export function default$Default_isize(): Gauge { return new Gauge(0); } -export function default$Default_u128(): Gauge { +export function default$Default_u128(): Gauge { return new Gauge(0); } -export function default$Default_u16(): Gauge { +export function default$Default_u16(): Gauge { return new Gauge(0); } -export function default$Default_u32(): Gauge { +export function default$Default_u32(): Gauge { return new Gauge(0); } -export function default$Default_u64(): Gauge { +export function default$Default_u64(): Gauge { return new Gauge(0); } -export function default$Default_u8(): Gauge { +export function default$Default_u8(): Gauge { return new Gauge(0); } -export function default$Default_usize(): Gauge { +export function default$Default_usize(): Gauge { return new Gauge(0); } -export function eq$cmp_PartialEq_i128(self: Gauge, other: Gauge): boolean { - return rt.i128Eq(self._0, other._0); +export function eq$cmp_PartialEq_i128(self: Gauge, other: Gauge): boolean { + return rs.i128Eq(self._0, other._0); } -export function eq$cmp_PartialEq_i16(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_i16(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_i32(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_i32(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_i64(self: Gauge, other: Gauge): boolean { - return rt.i64Eq(self._0, other._0); +export function eq$cmp_PartialEq_i64(self: Gauge, other: Gauge): boolean { + return rs.i64Eq(self._0, other._0); } -export function eq$cmp_PartialEq_i8(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_i8(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_isize(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_isize(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u128(self: Gauge, other: Gauge): boolean { - return rt.u128Eq(self._0, other._0); +export function eq$cmp_PartialEq_u128(self: Gauge, other: Gauge): boolean { + return rs.u128Eq(self._0, other._0); } -export function eq$cmp_PartialEq_u16(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_u16(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u32(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_u32(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u64(self: Gauge, other: Gauge): boolean { - return rt.u64Eq(self._0, other._0); +export function eq$cmp_PartialEq_u64(self: Gauge, other: Gauge): boolean { + return rs.u64Eq(self._0, other._0); } -export function eq$cmp_PartialEq_u8(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_u8(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_usize(self: Gauge, other: Gauge): boolean { +export function eq$cmp_PartialEq_usize(self: Gauge, other: Gauge): boolean { return self._0 === other._0; } -export function hash$Hash_i128_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashI128(self._0, state); +export function hash$Hash_i128_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashI128(self._0, state); } -export function hash$Hash_i16_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashI16(self._0, state); +export function hash$Hash_i16_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashI16(self._0, state); } -export function hash$Hash_i32_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashI32(self._0, state); +export function hash$Hash_i32_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashI32(self._0, state); } -export function hash$Hash_i64_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashI64(self._0, state); +export function hash$Hash_i64_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashI64(self._0, state); } -export function hash$Hash_i8_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashI8(self._0, state); +export function hash$Hash_i8_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashI8(self._0, state); } -export function hash$Hash_isize_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashIsize(self._0, state); +export function hash$Hash_isize_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashIsize(self._0, state); } -export function hash$Hash_u128_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hash128(self._0, state); +export function hash$Hash_u128_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hash128(self._0, state); } -export function hash$Hash_u16_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hash16(self._0, state); +export function hash$Hash_u16_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hash16(self._0, state); } -export function hash$Hash_u32_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hash32(self._0, state); +export function hash$Hash_u32_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hash32(self._0, state); } -export function hash$Hash_u64_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hash64(self._0, state); +export function hash$Hash_u64_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hash64(self._0, state); } -export function hash$Hash_u8_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hash8(self._0, state); +export function hash$Hash_u8_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hash8(self._0, state); } -export function hash$Hash_usize_hash_DefaultHasher(self: Gauge, state: rt.Hasher): void { - rt.hashUsize(self._0, state); +export function hash$Hash_usize_hash_DefaultHasher(self: Gauge, state: rs.Hasher): void { + rs.hashUsize(self._0, state); } -export function cmp$cmp_Ord_i128(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i128(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i16(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i16(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i32(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i32(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i64(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i64(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i8(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i8(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_isize(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_isize(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u128(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u128(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u16(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u16(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u32(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u32(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u64(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u64(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u8(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u8(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_usize(self: Gauge, other: Gauge): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_usize(self: Gauge, other: Gauge): rs.Ordering { + return rs.cmp(self._0, other._0); } /** A `Saturating` in a field, with each derived impl reading it. */ diff --git a/ts/fixtures/lang/saturates/expected/saturates.ts b/ts/fixtures/lang/saturates/expected/saturates.ts index 8e7adcc10..90ebaac79 100644 --- a/ts/fixtures/lang/saturates/expected/saturates.ts +++ b/ts/fixtures/lang/saturates/expected/saturates.ts @@ -1,263 +1,263 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$saturates_Gauge_i128, copy$saturates_Gauge_i16, copy$saturates_Gauge_i32, copy$saturates_Gauge_i64, copy$saturates_Gauge_i8, copy$saturates_Gauge_isize, copy$saturates_Gauge_u128, copy$saturates_Gauge_u16, copy$saturates_Gauge_u32, copy$saturates_Gauge_u64, copy$saturates_Gauge_u8, copy$saturates_Gauge_usize } from "./lib.ts"; -import { isSomeAnd$08u1px1, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { isSomeAnd$0dtzjhd, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Gauge from "./saturates.Gauge.ts"; -export function hashed$i128(v: rt.i128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI128(v, h); - return rt.hashFinish(h); +export function hashed$i128(v: rs.i128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI128(v, h); + return rs.hashFinish(h); } -export function hashed$i16(v: rt.i16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI16(v, h); - return rt.hashFinish(h); +export function hashed$i16(v: rs.i16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI16(v, h); + return rs.hashFinish(h); } -export function hashed$i32(v: rt.i32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI32(v, h); - return rt.hashFinish(h); +export function hashed$i32(v: rs.i32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI32(v, h); + return rs.hashFinish(h); } -export function hashed$i64(v: rt.i64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI64(v, h); - return rt.hashFinish(h); +export function hashed$i64(v: rs.i64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI64(v, h); + return rs.hashFinish(h); } -export function hashed$i8(v: rt.i8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(v, h); - return rt.hashFinish(h); +export function hashed$i8(v: rs.i8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(v, h); + return rs.hashFinish(h); } -export function hashed$isize(v: rt.isize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashIsize(v, h); - return rt.hashFinish(h); +export function hashed$isize(v: rs.isize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashIsize(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_i128(v: rt.i128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI128(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_i128(v: rs.i128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI128(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_i16(v: rt.i16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI16(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_i16(v: rs.i16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI16(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_i32(v: rt.i32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI32(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_i32(v: rs.i32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI32(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_i64(v: rt.i64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI64(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_i64(v: rs.i64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI64(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_i8(v: rt.i8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_i8(v: rs.i8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_isize(v: rt.isize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashIsize(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_isize(v: rs.isize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashIsize(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_u128(v: rt.u128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash128(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_u128(v: rs.u128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash128(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_u16(v: rt.u16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash16(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_u16(v: rs.u16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash16(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_u32(v: rt.u32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash32(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_u32(v: rs.u32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash32(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_u64(v: rt.u64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash64(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_u64(v: rs.u64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash64(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_u8(v: rt.u8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash8(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_u8(v: rs.u8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash8(v, h); + return rs.hashFinish(h); } -export function hashed$num_Saturating_usize(v: rt.usize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashUsize(v, h); - return rt.hashFinish(h); +export function hashed$num_Saturating_usize(v: rs.usize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashUsize(v, h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_i128(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_i128(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_i128_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_i16(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_i16(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_i16_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_i32(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_i32(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_i32_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_i64(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_i64(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_i64_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_i8(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_i8(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_i8_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_isize(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_isize(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_isize_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_u128(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_u128(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_u128_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_u16(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_u16(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_u16_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_u32(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_u32(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_u32_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_u64(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_u64(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_u64_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_u8(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_u8(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_u8_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$saturates_Gauge_usize(v: Gauge.Gauge): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$saturates_Gauge_usize(v: Gauge.Gauge): rs.u64 { + const h: rs.Hasher = rs.hasher(); Gauge.hash$Hash_usize_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$u128(v: rt.u128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash128(v, h); - return rt.hashFinish(h); +export function hashed$u128(v: rs.u128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash128(v, h); + return rs.hashFinish(h); } -export function hashed$u16(v: rt.u16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash16(v, h); - return rt.hashFinish(h); +export function hashed$u16(v: rs.u16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash16(v, h); + return rs.hashFinish(h); } -export function hashed$u32(v: rt.u32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash32(v, h); - return rt.hashFinish(h); +export function hashed$u32(v: rs.u32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash32(v, h); + return rs.hashFinish(h); } -export function hashed$u64(v: rt.u64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash64(v, h); - return rt.hashFinish(h); +export function hashed$u64(v: rs.u64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash64(v, h); + return rs.hashFinish(h); } -export function hashed$u8(v: rt.u8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash8(v, h); - return rt.hashFinish(h); +export function hashed$u8(v: rs.u8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash8(v, h); + return rs.hashFinish(h); } -export function hashed$usize(v: rt.usize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashUsize(v, h); - return rt.hashFinish(h); +export function hashed$usize(v: rs.usize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashUsize(v, h); + return rs.hashFinish(h); } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v))); +export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u8 = (at: rt.usize): rt.u8 => { + const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u8FromBeBytes(buf); + return rs.u8FromBeBytes(buf); }; - const _8: [rt.u8, rt.u8, rt.u8] = [take(0), take(1), take(2 * 1)]; - const a: rt.u8 = _8[0]; - const b: rt.u8 = _8[1]; - const c: rt.u8 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.u8, rs.u8, rs.u8] = [take(0), take(1), take(2 * 1)]; + const a: rs.u8 = _8[0]; + const b: rs.u8 = _8[1]; + const c: rs.u8 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.u8SaturatingAdd(a, b); + const part47 = rs.u8SaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.u8SaturatingSub(a, b); + const part46 = rs.u8SaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.u8SaturatingMul(a, b); + const part45 = rs.u8SaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.u8Div(a, b)); + _20(out, rs.u8Div(a, b)); } else if (_21 === 4) { - _20(out, rt.u8Rem(a, b)); + _20(out, rs.u8Rem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { _20(out, ~a & 0xff); } else if (_21 === 7) { @@ -267,195 +267,195 @@ export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.u8 = a; - x = rt.u8SaturatingAdd(x, b); + let x: rs.u8 = a; + x = rs.u8SaturatingAdd(x, b); _20(out, x); - x = rt.u8SaturatingMul(x, c); + x = rs.u8SaturatingMul(x, c); _20(out, x); - x = rt.u8SaturatingSub(x, b); + x = rs.u8SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.u8 = a; - x2 = rt.u8Div(x2, b); + let x2: rs.u8 = a; + x2 = rs.u8Div(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.u8 = a; - x3 = rt.u8Rem(x3, b); + let x3: rs.u8 = a; + x3 = rs.u8Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.u8 = a; + let x4: rs.u8 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.u8 = a; - x5 = rt.u8SaturatingAdd(x5, b); + let x5: rs.u8 = a; + x5 = rs.u8SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.u8SaturatingSub(x5, c); + x5 = rs.u8SaturatingSub(x5, c); _20(out, x5); - x5 = rt.u8SaturatingMul(x5, b); + x5 = rs.u8SaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.u8Div(x5, b); + x5 = rs.u8Div(x5, b); _20(out, x5); - x5 = rt.u8Rem(x5, c); + x5 = rs.u8Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.u8SaturatingAdd(a, b); + const part17 = rs.u8SaturatingAdd(a, b); _20(out, part17); - const part18 = rt.u8SaturatingSub(a, b); + const part18 = rs.u8SaturatingSub(a, b); _20(out, part18); - const part19 = rt.u8SaturatingMul(a, c); + const part19 = rs.u8SaturatingMul(a, c); _20(out, part19); _20(out, ~b & 0xff); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.u8 = a; - x6 = rt.u8SaturatingAdd(x6, b); - x6 = rt.u8SaturatingMul(x6, c); + let x6: rs.u8 = a; + x6 = rs.u8SaturatingAdd(x6, b); + x6 = rs.u8SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.u8Rem(a, b)); - _20(out, rt.u8Div(c, b)); + _20(out, rs.u8Rem(a, b)); + _20(out, rs.u8Div(c, b)); } else if (_21 === 16) { const _204: boolean = a === b; const _207: boolean = a !== b; - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.u8 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.u8 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.u8 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.u8 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_u8(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_u8(a), hashed$u8(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 1, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_u8(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_u8(a), hashed$u8(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 1, true)); while (true) { - const _271: rt.u8 | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.u8 | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash8, rt.same)) as rt.HashSet, _280, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash8, rs.same)) as rs.HashSet, _280, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(a, f), (f: rt.Formatter) => rt.u8Debug(b, f), (f: rt.Formatter) => rt.u8LowerHex(a, f), (f: rt.Formatter) => rt.u8UpperHex(b, f), (f: rt.Formatter) => rt.u8Octal(c, f), (f: rt.Formatter) => rt.u8Binary(a, f), (f: rt.Formatter) => rt.u8Display(b, f), (f: rt.Formatter) => rt.u8LowerHex(c, f), (f: rt.Formatter) => rt.u8Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.u8[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.u8SaturatingAdd, 0); + const all: rs.u8[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.u8SaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.u8SaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.u8SaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.u8SaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.u8SaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.u8SaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.u8SaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u8SaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u8SaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u8SaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u8SaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_u8(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_u8(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_u8(x7), hashed$num_Saturating_u8(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_u8(x7); - z._0 = rt.u8SaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_u8(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u8(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u8(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u8(x7), hashed$num_Saturating_u8(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_u8(x7); + z._0 = rs.u8SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.u8 | undefined, rt.u8 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.u8 | undefined, rs.u8 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.u8SaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.u8SaturatingMul(_414[0], _414[1])))); } } - const part = rt.u8SaturatingMul(a, b); + const part = rs.u8SaturatingMul(a, b); _20(out, part); - const part2 = rt.u8SaturatingAdd(a, b); + const part2 = rs.u8SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.u8SaturatingSub(a, b); + const part3 = rs.u8SaturatingSub(a, b); _20(out, part3); - _20(out, rt.u8Div(a, b)); + _20(out, rs.u8Div(a, b)); } else { - const _457: rt.u8 | undefined = rt.nonZero(a); + const _457: rs.u8 | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.u8SaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.u8SaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v))); +export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { - const buf: Uint8Array = rt.bytes(2); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { + const buf: Uint8Array = rs.bytes(2); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u16FromBeBytes(buf); + return rs.u16FromBeBytes(buf); }; - const _8: [rt.u16, rt.u16, rt.u16] = [take(0), take(2), take(2 * 2)]; - const a: rt.u16 = _8[0]; - const b: rt.u16 = _8[1]; - const c: rt.u16 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.u16, rs.u16, rs.u16] = [take(0), take(2), take(2 * 2)]; + const a: rs.u16 = _8[0]; + const b: rs.u16 = _8[1]; + const c: rs.u16 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.u16SaturatingAdd(a, b); + const part47 = rs.u16SaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.u16SaturatingSub(a, b); + const part46 = rs.u16SaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.u16SaturatingMul(a, b); + const part45 = rs.u16SaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.u16Div(a, b)); + _20(out, rs.u16Div(a, b)); } else if (_21 === 4) { - _20(out, rt.u16Rem(a, b)); + _20(out, rs.u16Rem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { _20(out, ~a & 0xffff); } else if (_21 === 7) { @@ -465,195 +465,195 @@ export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.u16 = a; - x = rt.u16SaturatingAdd(x, b); + let x: rs.u16 = a; + x = rs.u16SaturatingAdd(x, b); _20(out, x); - x = rt.u16SaturatingMul(x, c); + x = rs.u16SaturatingMul(x, c); _20(out, x); - x = rt.u16SaturatingSub(x, b); + x = rs.u16SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.u16 = a; - x2 = rt.u16Div(x2, b); + let x2: rs.u16 = a; + x2 = rs.u16Div(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.u16 = a; - x3 = rt.u16Rem(x3, b); + let x3: rs.u16 = a; + x3 = rs.u16Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.u16 = a; + let x4: rs.u16 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.u16 = a; - x5 = rt.u16SaturatingAdd(x5, b); + let x5: rs.u16 = a; + x5 = rs.u16SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.u16SaturatingSub(x5, c); + x5 = rs.u16SaturatingSub(x5, c); _20(out, x5); - x5 = rt.u16SaturatingMul(x5, b); + x5 = rs.u16SaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.u16Div(x5, b); + x5 = rs.u16Div(x5, b); _20(out, x5); - x5 = rt.u16Rem(x5, c); + x5 = rs.u16Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.u16SaturatingAdd(a, b); + const part17 = rs.u16SaturatingAdd(a, b); _20(out, part17); - const part18 = rt.u16SaturatingSub(a, b); + const part18 = rs.u16SaturatingSub(a, b); _20(out, part18); - const part19 = rt.u16SaturatingMul(a, c); + const part19 = rs.u16SaturatingMul(a, c); _20(out, part19); _20(out, ~b & 0xffff); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.u16 = a; - x6 = rt.u16SaturatingAdd(x6, b); - x6 = rt.u16SaturatingMul(x6, c); + let x6: rs.u16 = a; + x6 = rs.u16SaturatingAdd(x6, b); + x6 = rs.u16SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.u16Rem(a, b)); - _20(out, rt.u16Div(c, b)); + _20(out, rs.u16Rem(a, b)); + _20(out, rs.u16Div(c, b)); } else if (_21 === 16) { const _204: boolean = a === b; const _207: boolean = a !== b; - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.u16 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.u16 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.u16 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.u16 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_u16(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_u16(a), hashed$u16(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 2, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_u16(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_u16(a), hashed$u16(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 2, true)); while (true) { - const _271: rt.u16 | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.u16 | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash16, rt.same)) as rt.HashSet, _280, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash16, rs.same)) as rs.HashSet, _280, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(a, f), (f: rt.Formatter) => rt.u16Debug(b, f), (f: rt.Formatter) => rt.u16LowerHex(a, f), (f: rt.Formatter) => rt.u16UpperHex(b, f), (f: rt.Formatter) => rt.u16Octal(c, f), (f: rt.Formatter) => rt.u16Binary(a, f), (f: rt.Formatter) => rt.u16Display(b, f), (f: rt.Formatter) => rt.u16LowerHex(c, f), (f: rt.Formatter) => rt.u16Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.u16[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.u16SaturatingAdd, 0); + const all: rs.u16[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.u16SaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.u16SaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.u16SaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.u16SaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.u16SaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.u16SaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.u16SaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u16SaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u16SaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u16SaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u16SaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_u16(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_u16(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_u16(x7), hashed$num_Saturating_u16(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_u16(x7); - z._0 = rt.u16SaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_u16(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u16(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u16(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u16(x7), hashed$num_Saturating_u16(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_u16(x7); + z._0 = rs.u16SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.u16 | undefined, rt.u16 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.u16 | undefined, rs.u16 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.u16SaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.u16SaturatingMul(_414[0], _414[1])))); } } - const part = rt.u16SaturatingMul(a, b); + const part = rs.u16SaturatingMul(a, b); _20(out, part); - const part2 = rt.u16SaturatingAdd(a, b); + const part2 = rs.u16SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.u16SaturatingSub(a, b); + const part3 = rs.u16SaturatingSub(a, b); _20(out, part3); - _20(out, rt.u16Div(a, b)); + _20(out, rs.u16Div(a, b)); } else { - const _457: rt.u16 | undefined = rt.nonZero(a); + const _457: rs.u16 | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.u16SaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.u16SaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v))); +export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u32 = (at: rt.usize): rt.u32 => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u32FromBeBytes(buf); + return rs.u32FromBeBytes(buf); }; - const _8: [rt.u32, rt.u32, rt.u32] = [take(0), take(4), take(2 * 4)]; - const a: rt.u32 = _8[0]; - const b: rt.u32 = _8[1]; - const c: rt.u32 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.u32, rs.u32, rs.u32] = [take(0), take(4), take(2 * 4)]; + const a: rs.u32 = _8[0]; + const b: rs.u32 = _8[1]; + const c: rs.u32 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.u32SaturatingAdd(a, b); + const part47 = rs.u32SaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.u32SaturatingSub(a, b); + const part46 = rs.u32SaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.u32SaturatingMul(a, b); + const part45 = rs.u32SaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.u32Div(a, b)); + _20(out, rs.u32Div(a, b)); } else if (_21 === 4) { - _20(out, rt.u32Rem(a, b)); + _20(out, rs.u32Rem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { _20(out, ~a >>> 0); } else if (_21 === 7) { @@ -663,591 +663,591 @@ export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, (a ^ b) >>> 0); } else if (_21 === 10) { - let x: rt.u32 = a; - x = rt.u32SaturatingAdd(x, b); + let x: rs.u32 = a; + x = rs.u32SaturatingAdd(x, b); _20(out, x); - x = rt.u32SaturatingMul(x, c); + x = rs.u32SaturatingMul(x, c); _20(out, x); - x = rt.u32SaturatingSub(x, b); + x = rs.u32SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.u32 = a; - x2 = rt.u32Div(x2, b); + let x2: rs.u32 = a; + x2 = rs.u32Div(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.u32 = a; - x3 = rt.u32Rem(x3, b); + let x3: rs.u32 = a; + x3 = rs.u32Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.u32 = a; + let x4: rs.u32 = a; x4 = (x4 & b) >>> 0; x4 = (x4 | c) >>> 0; x4 = (x4 ^ b) >>> 0; _20(out, x4); } else if (_21 === 14) { - let x5: rt.u32 = a; - x5 = rt.u32SaturatingAdd(x5, b); + let x5: rs.u32 = a; + x5 = rs.u32SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.u32SaturatingSub(x5, c); + x5 = rs.u32SaturatingSub(x5, c); _20(out, x5); - x5 = rt.u32SaturatingMul(x5, b); + x5 = rs.u32SaturatingMul(x5, b); _20(out, x5); x5 = (x5 & c) >>> 0; x5 = (x5 | b) >>> 0; x5 = (x5 ^ c) >>> 0; _20(out, x5); - x5 = rt.u32Div(x5, b); + x5 = rs.u32Div(x5, b); _20(out, x5); - x5 = rt.u32Rem(x5, c); + x5 = rs.u32Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.u32SaturatingAdd(a, b); + const part17 = rs.u32SaturatingAdd(a, b); _20(out, part17); - const part18 = rt.u32SaturatingSub(a, b); + const part18 = rs.u32SaturatingSub(a, b); _20(out, part18); - const part19 = rt.u32SaturatingMul(a, c); + const part19 = rs.u32SaturatingMul(a, c); _20(out, part19); _20(out, ~b >>> 0); _20(out, (a ^ c) >>> 0); _20(out, (a & b) >>> 0); _20(out, (a | c) >>> 0); - let x6: rt.u32 = a; - x6 = rt.u32SaturatingAdd(x6, b); - x6 = rt.u32SaturatingMul(x6, c); + let x6: rs.u32 = a; + x6 = rs.u32SaturatingAdd(x6, b); + x6 = rs.u32SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.u32Rem(a, b)); - _20(out, rt.u32Div(c, b)); + _20(out, rs.u32Rem(a, b)); + _20(out, rs.u32Div(c, b)); } else if (_21 === 16) { const _204: boolean = a === b; const _207: boolean = a !== b; - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.u32 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.u32 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.u32 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.u32 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_u32(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_u32(a), hashed$u32(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_u32(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_u32(a), hashed$u32(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 4, true)); while (true) { - const _271: rt.u32 | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.u32 | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash32, rt.same)) as rt.HashSet, _280, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash32, rs.same)) as rs.HashSet, _280, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(a, f), (f: rt.Formatter) => rt.u32Debug(b, f), (f: rt.Formatter) => rt.u32LowerHex(a, f), (f: rt.Formatter) => rt.u32UpperHex(b, f), (f: rt.Formatter) => rt.u32Octal(c, f), (f: rt.Formatter) => rt.u32Binary(a, f), (f: rt.Formatter) => rt.u32Display(b, f), (f: rt.Formatter) => rt.u32LowerHex(c, f), (f: rt.Formatter) => rt.u32Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.u32[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.u32SaturatingAdd, 0); + const all: rs.u32[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.u32SaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.u32SaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.u32SaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.u32SaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.u32SaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.u32SaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.u32SaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u32SaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u32SaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u32SaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u32SaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_u32(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_u32(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_u32(x7), hashed$num_Saturating_u32(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_u32(x7); - z._0 = rt.u32SaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_u32(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u32(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u32(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u32(x7), hashed$num_Saturating_u32(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_u32(x7); + z._0 = rs.u32SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.u32 | undefined, rt.u32 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.u32 | undefined, rs.u32 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32SaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32SaturatingMul(_414[0], _414[1])))); } } - const part = rt.u32SaturatingMul(a, b); + const part = rs.u32SaturatingMul(a, b); _20(out, part); - const part2 = rt.u32SaturatingAdd(a, b); + const part2 = rs.u32SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.u32SaturatingSub(a, b); + const part3 = rs.u32SaturatingSub(a, b); _20(out, part3); - _20(out, rt.u32Div(a, b)); + _20(out, rs.u32Div(a, b)); } else { - const _457: rt.u32 | undefined = rt.nonZero(a); + const _457: rs.u32 | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32SaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32SaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v))); +export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u64 = (at: rt.usize): rt.u64 => { - const buf: Uint8Array = rt.bytes(8); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { + const buf: Uint8Array = rs.bytes(8); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u64FromBeBytes(buf); + return rs.u64FromBeBytes(buf); }; - const _8: [rt.u64, rt.u64, rt.u64] = [take(0), take(8), take(2 * 8)]; - const a: rt.u64 = _8[0]; - const b: rt.u64 = _8[1]; - const c: rt.u64 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.u64, rs.u64, rs.u64] = [take(0), take(8), take(2 * 8)]; + const a: rs.u64 = _8[0]; + const b: rs.u64 = _8[1]; + const c: rs.u64 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.u64SaturatingAdd(a, b); + const part47 = rs.u64SaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.u64SaturatingSub(a, b); + const part46 = rs.u64SaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.u64SaturatingMul(a, b); + const part45 = rs.u64SaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.u64Div(a, b)); + _20(out, rs.u64Div(a, b)); } else if (_21 === 4) { - _20(out, rt.u64Rem(a, b)); + _20(out, rs.u64Rem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { - _20(out, rt.u64Not(a)); + _20(out, rs.u64Not(a)); } else if (_21 === 7) { - _20(out, rt.u64And(a, b)); + _20(out, rs.u64And(a, b)); } else if (_21 === 8) { - _20(out, rt.u64Or(a, b)); + _20(out, rs.u64Or(a, b)); } else if (_21 === 9) { - _20(out, rt.u64Xor(a, b)); + _20(out, rs.u64Xor(a, b)); } else if (_21 === 10) { - let x: rt.u64 = a; - x = rt.u64SaturatingAdd(x, b); + let x: rs.u64 = a; + x = rs.u64SaturatingAdd(x, b); _20(out, x); - x = rt.u64SaturatingMul(x, c); + x = rs.u64SaturatingMul(x, c); _20(out, x); - x = rt.u64SaturatingSub(x, b); + x = rs.u64SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.u64 = a; - x2 = rt.u64Div(x2, b); + let x2: rs.u64 = a; + x2 = rs.u64Div(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.u64 = a; - x3 = rt.u64Rem(x3, b); + let x3: rs.u64 = a; + x3 = rs.u64Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.u64 = a; - x4 = rt.u64And(x4, b); - x4 = rt.u64Or(x4, c); - x4 = rt.u64Xor(x4, b); + let x4: rs.u64 = a; + x4 = rs.u64And(x4, b); + x4 = rs.u64Or(x4, c); + x4 = rs.u64Xor(x4, b); _20(out, x4); } else if (_21 === 14) { - let x5: rt.u64 = a; - x5 = rt.u64SaturatingAdd(x5, b); + let x5: rs.u64 = a; + x5 = rs.u64SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.u64SaturatingSub(x5, c); + x5 = rs.u64SaturatingSub(x5, c); _20(out, x5); - x5 = rt.u64SaturatingMul(x5, b); + x5 = rs.u64SaturatingMul(x5, b); _20(out, x5); - x5 = rt.u64And(x5, c); - x5 = rt.u64Or(x5, b); - x5 = rt.u64Xor(x5, c); + x5 = rs.u64And(x5, c); + x5 = rs.u64Or(x5, b); + x5 = rs.u64Xor(x5, c); _20(out, x5); - x5 = rt.u64Div(x5, b); + x5 = rs.u64Div(x5, b); _20(out, x5); - x5 = rt.u64Rem(x5, c); + x5 = rs.u64Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.u64SaturatingAdd(a, b); + const part17 = rs.u64SaturatingAdd(a, b); _20(out, part17); - const part18 = rt.u64SaturatingSub(a, b); + const part18 = rs.u64SaturatingSub(a, b); _20(out, part18); - const part19 = rt.u64SaturatingMul(a, c); + const part19 = rs.u64SaturatingMul(a, c); _20(out, part19); - _20(out, rt.u64Not(b)); - _20(out, rt.u64Xor(a, c)); - _20(out, rt.u64And(a, b)); - _20(out, rt.u64Or(a, c)); - let x6: rt.u64 = a; - x6 = rt.u64SaturatingAdd(x6, b); - x6 = rt.u64SaturatingMul(x6, c); + _20(out, rs.u64Not(b)); + _20(out, rs.u64Xor(a, c)); + _20(out, rs.u64And(a, b)); + _20(out, rs.u64Or(a, c)); + let x6: rs.u64 = a; + x6 = rs.u64SaturatingAdd(x6, b); + x6 = rs.u64SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.u64Rem(a, b)); - _20(out, rt.u64Div(c, b)); + _20(out, rs.u64Rem(a, b)); + _20(out, rs.u64Div(c, b)); } else if (_21 === 16) { - const _204: boolean = rt.u64Eq(a, b); - const _207: boolean = !rt.u64Eq(a, b); - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _204: boolean = rs.u64Eq(a, b); + const _207: boolean = !rs.u64Eq(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.u64 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.u64 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.u64 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.u64 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_u64(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_u64(a), hashed$u64(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 8, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_u64(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_u64(a), hashed$u64(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 8, true)); while (true) { - const _271: rt.u64 | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.u64 | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, _280, undefined, undefined, 117440512); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet, _280, undefined, undefined, 117440512); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(a, f), (f: rt.Formatter) => rt.u64Debug(b, f), (f: rt.Formatter) => rt.u64LowerHex(a, f), (f: rt.Formatter) => rt.u64UpperHex(b, f), (f: rt.Formatter) => rt.u64Octal(c, f), (f: rt.Formatter) => rt.u64Binary(a, f), (f: rt.Formatter) => rt.u64Display(b, f), (f: rt.Formatter) => rt.u64LowerHex(c, f), (f: rt.Formatter) => rt.u64Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.u64[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.u64SaturatingAdd, 0); + const all: rs.u64[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.u64SaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.u64SaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.u64SaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.u64SaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.u64SaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.u64SaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.u64SaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u64SaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u64SaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u64SaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u64SaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_u64(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_u64(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_u64(x7), hashed$num_Saturating_u64(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_u64(x7); - z._0 = rt.u64SaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_u64(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u64(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u64(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u64(x7), hashed$num_Saturating_u64(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_u64(x7); + z._0 = rs.u64SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.u64 | undefined, rt.u64 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.u64 | undefined, rs.u64 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64SaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64SaturatingMul(_414[0], _414[1])))); } } - const part = rt.u64SaturatingMul(a, b); + const part = rs.u64SaturatingMul(a, b); _20(out, part); - const part2 = rt.u64SaturatingAdd(a, b); + const part2 = rs.u64SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.u64SaturatingSub(a, b); + const part3 = rs.u64SaturatingSub(a, b); _20(out, part3); - _20(out, rt.u64Div(a, b)); + _20(out, rs.u64Div(a, b)); } else { - const _457: rt.u64 | undefined = rt.nonZero(a); + const _457: rs.u64 | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64SaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64SaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); +export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u128 = (at: rt.usize): rt.u128 => { - const buf: Uint8Array = rt.bytes(16); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { + const buf: Uint8Array = rs.bytes(16); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u128FromBeBytes(buf); + return rs.u128FromBeBytes(buf); }; - const _8: [rt.u128, rt.u128, rt.u128] = [take(0), take(16), take(2 * 16)]; - const a: rt.u128 = _8[0]; - const b: rt.u128 = _8[1]; - const c: rt.u128 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.u128, rs.u128, rs.u128] = [take(0), take(16), take(2 * 16)]; + const a: rs.u128 = _8[0]; + const b: rs.u128 = _8[1]; + const c: rs.u128 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.u128SaturatingAdd(a, b); + const part47 = rs.u128SaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.u128SaturatingSub(a, b); + const part46 = rs.u128SaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.u128SaturatingMul(a, b); + const part45 = rs.u128SaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.u128Div(a, b)); + _20(out, rs.u128Div(a, b)); } else if (_21 === 4) { - _20(out, rt.u128Rem(a, b)); + _20(out, rs.u128Rem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { - _20(out, rt.u128Not(a)); + _20(out, rs.u128Not(a)); } else if (_21 === 7) { - _20(out, rt.u128And(a, b)); + _20(out, rs.u128And(a, b)); } else if (_21 === 8) { - _20(out, rt.u128Or(a, b)); + _20(out, rs.u128Or(a, b)); } else if (_21 === 9) { - _20(out, rt.u128Xor(a, b)); + _20(out, rs.u128Xor(a, b)); } else if (_21 === 10) { - let x: rt.u128 = a; - x = rt.u128SaturatingAdd(x, b); + let x: rs.u128 = a; + x = rs.u128SaturatingAdd(x, b); _20(out, x); - x = rt.u128SaturatingMul(x, c); + x = rs.u128SaturatingMul(x, c); _20(out, x); - x = rt.u128SaturatingSub(x, b); + x = rs.u128SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.u128 = a; - x2 = rt.u128Div(x2, b); + let x2: rs.u128 = a; + x2 = rs.u128Div(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.u128 = a; - x3 = rt.u128Rem(x3, b); + let x3: rs.u128 = a; + x3 = rs.u128Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.u128 = a; - x4 = rt.u128And(x4, b); - x4 = rt.u128Or(x4, c); - x4 = rt.u128Xor(x4, b); + let x4: rs.u128 = a; + x4 = rs.u128And(x4, b); + x4 = rs.u128Or(x4, c); + x4 = rs.u128Xor(x4, b); _20(out, x4); } else if (_21 === 14) { - let x5: rt.u128 = a; - x5 = rt.u128SaturatingAdd(x5, b); + let x5: rs.u128 = a; + x5 = rs.u128SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.u128SaturatingSub(x5, c); + x5 = rs.u128SaturatingSub(x5, c); _20(out, x5); - x5 = rt.u128SaturatingMul(x5, b); + x5 = rs.u128SaturatingMul(x5, b); _20(out, x5); - x5 = rt.u128And(x5, c); - x5 = rt.u128Or(x5, b); - x5 = rt.u128Xor(x5, c); + x5 = rs.u128And(x5, c); + x5 = rs.u128Or(x5, b); + x5 = rs.u128Xor(x5, c); _20(out, x5); - x5 = rt.u128Div(x5, b); + x5 = rs.u128Div(x5, b); _20(out, x5); - x5 = rt.u128Rem(x5, c); + x5 = rs.u128Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.u128SaturatingAdd(a, b); + const part17 = rs.u128SaturatingAdd(a, b); _20(out, part17); - const part18 = rt.u128SaturatingSub(a, b); + const part18 = rs.u128SaturatingSub(a, b); _20(out, part18); - const part19 = rt.u128SaturatingMul(a, c); + const part19 = rs.u128SaturatingMul(a, c); _20(out, part19); - _20(out, rt.u128Not(b)); - _20(out, rt.u128Xor(a, c)); - _20(out, rt.u128And(a, b)); - _20(out, rt.u128Or(a, c)); - let x6: rt.u128 = a; - x6 = rt.u128SaturatingAdd(x6, b); - x6 = rt.u128SaturatingMul(x6, c); + _20(out, rs.u128Not(b)); + _20(out, rs.u128Xor(a, c)); + _20(out, rs.u128And(a, b)); + _20(out, rs.u128Or(a, c)); + let x6: rs.u128 = a; + x6 = rs.u128SaturatingAdd(x6, b); + x6 = rs.u128SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.u128Rem(a, b)); - _20(out, rt.u128Div(c, b)); + _20(out, rs.u128Rem(a, b)); + _20(out, rs.u128Div(c, b)); } else if (_21 === 16) { - const _204: boolean = rt.u128Eq(a, b); - const _207: boolean = !rt.u128Eq(a, b); - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _204: boolean = rs.u128Eq(a, b); + const _207: boolean = !rs.u128Eq(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.u128 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.u128 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.u128 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.u128 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_u128(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_u128(a), hashed$u128(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 16, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_u128(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_u128(a), hashed$u128(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 16, true)); while (true) { - const _271: rt.u128 | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.u128 | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash128, rt.u128Eq)) as rt.HashSet, _280, undefined, undefined, 58720256); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash128, rs.u128Eq)) as rs.HashSet, _280, undefined, undefined, 58720256); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(a, f), (f: rt.Formatter) => rt.u128Debug(b, f), (f: rt.Formatter) => rt.u128LowerHex(a, f), (f: rt.Formatter) => rt.u128UpperHex(b, f), (f: rt.Formatter) => rt.u128Octal(c, f), (f: rt.Formatter) => rt.u128Binary(a, f), (f: rt.Formatter) => rt.u128Display(b, f), (f: rt.Formatter) => rt.u128LowerHex(c, f), (f: rt.Formatter) => rt.u128Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.u128[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.u128SaturatingAdd, 0); + const all: rs.u128[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.u128SaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.u128SaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.u128SaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.u128SaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.u128SaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.u128SaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.u128SaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u128SaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u128SaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u128SaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u128SaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_u128(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_u128(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_u128(x7), hashed$num_Saturating_u128(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_u128(x7); - z._0 = rt.u128SaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_u128(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_u128(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_u128(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_u128(x7), hashed$num_Saturating_u128(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_u128(x7); + z._0 = rs.u128SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.u128 | undefined, rt.u128 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.u128 | undefined, rs.u128 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128SaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128SaturatingMul(_414[0], _414[1])))); } } - const part = rt.u128SaturatingMul(a, b); + const part = rs.u128SaturatingMul(a, b); _20(out, part); - const part2 = rt.u128SaturatingAdd(a, b); + const part2 = rs.u128SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.u128SaturatingSub(a, b); + const part3 = rs.u128SaturatingSub(a, b); _20(out, part3); - _20(out, rt.u128Div(a, b)); + _20(out, rs.u128Div(a, b)); } else { - const _457: rt.u128 | undefined = rt.nonZero(a); + const _457: rs.u128 | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128SaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128SaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v))); +export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.usize = (at: rt.usize): rt.usize => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.usizeFromBeBytes(buf); + return rs.usizeFromBeBytes(buf); }; - const _8: [rt.usize, rt.usize, rt.usize] = [take(0), take(4), take(2 * 4)]; - const a: rt.usize = _8[0]; - const b: rt.usize = _8[1]; - const c: rt.usize = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.usize, rs.usize, rs.usize] = [take(0), take(4), take(2 * 4)]; + const a: rs.usize = _8[0]; + const b: rs.usize = _8[1]; + const c: rs.usize = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part47 = rt.usizeSaturatingAdd(a, b); + const part47 = rs.usizeSaturatingAdd(a, b); _20(out, part47); } else if (_21 === 1) { - const part46 = rt.usizeSaturatingSub(a, b); + const part46 = rs.usizeSaturatingSub(a, b); _20(out, part46); } else if (_21 === 2) { - const part45 = rt.usizeSaturatingMul(a, b); + const part45 = rs.usizeSaturatingMul(a, b); _20(out, part45); } else if (_21 === 3) { - _20(out, rt.usizeDiv(a, b)); + _20(out, rs.usizeDiv(a, b)); } else if (_21 === 4) { - _20(out, rt.usizeRem(a, b)); + _20(out, rs.usizeRem(a, b)); } else if (_21 === 5) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 6) { _20(out, ~a >>> 0); } else if (_21 === 7) { @@ -1257,200 +1257,200 @@ export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, (a ^ b) >>> 0); } else if (_21 === 10) { - let x: rt.usize = a; - x = rt.usizeSaturatingAdd(x, b); + let x: rs.usize = a; + x = rs.usizeSaturatingAdd(x, b); _20(out, x); - x = rt.usizeSaturatingMul(x, c); + x = rs.usizeSaturatingMul(x, c); _20(out, x); - x = rt.usizeSaturatingSub(x, b); + x = rs.usizeSaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.usize = a; - x2 = rt.usizeDiv(x2, b); + let x2: rs.usize = a; + x2 = rs.usizeDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.usize = a; - x3 = rt.usizeRem(x3, b); + let x3: rs.usize = a; + x3 = rs.usizeRem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.usize = a; + let x4: rs.usize = a; x4 = (x4 & b) >>> 0; x4 = (x4 | c) >>> 0; x4 = (x4 ^ b) >>> 0; _20(out, x4); } else if (_21 === 14) { - let x5: rt.usize = a; - x5 = rt.usizeSaturatingAdd(x5, b); + let x5: rs.usize = a; + x5 = rs.usizeSaturatingAdd(x5, b); _20(out, x5); - x5 = rt.usizeSaturatingSub(x5, c); + x5 = rs.usizeSaturatingSub(x5, c); _20(out, x5); - x5 = rt.usizeSaturatingMul(x5, b); + x5 = rs.usizeSaturatingMul(x5, b); _20(out, x5); x5 = (x5 & c) >>> 0; x5 = (x5 | b) >>> 0; x5 = (x5 ^ c) >>> 0; _20(out, x5); - x5 = rt.usizeDiv(x5, b); + x5 = rs.usizeDiv(x5, b); _20(out, x5); - x5 = rt.usizeRem(x5, c); + x5 = rs.usizeRem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part17 = rt.usizeSaturatingAdd(a, b); + const part17 = rs.usizeSaturatingAdd(a, b); _20(out, part17); - const part18 = rt.usizeSaturatingSub(a, b); + const part18 = rs.usizeSaturatingSub(a, b); _20(out, part18); - const part19 = rt.usizeSaturatingMul(a, c); + const part19 = rs.usizeSaturatingMul(a, c); _20(out, part19); _20(out, ~b >>> 0); _20(out, (a ^ c) >>> 0); _20(out, (a & b) >>> 0); _20(out, (a | c) >>> 0); - let x6: rt.usize = a; - x6 = rt.usizeSaturatingAdd(x6, b); - x6 = rt.usizeSaturatingMul(x6, c); + let x6: rs.usize = a; + x6 = rs.usizeSaturatingAdd(x6, b); + x6 = rs.usizeSaturatingMul(x6, c); _20(out, x6); - _20(out, rt.usizeRem(a, b)); - _20(out, rt.usizeDiv(c, b)); + _20(out, rs.usizeRem(a, b)); + _20(out, rs.usizeDiv(c, b)); } else if (_21 === 16) { const _204: boolean = a === b; const _207: boolean = a !== b; - const _210: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _210: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _213: boolean = order !== undefined && order <= 0; - const _216: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _216: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_204, _207, _210, _213, _216, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _232: boolean | rt.Done = iter.next(); - if (_232 === rt.DONE) { + const _232: boolean | rs.Done = iter.next(); + if (_232 === rs.DONE) { break; } - rt.byteVecPush(out, _232 ? 1 : 0); + rs.byteVecPush(out, _232 ? 1 : 0); } - const part14 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part14 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part14); - const part15 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part15 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part15); - const _250: rt.usize = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _251: rt.usize = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part16 = rt.ordClamp(a, _250, _251, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _250: rs.usize = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _251: rs.usize = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part16 = rs.ordClamp(a, _250, _251, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part16); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_usize(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_usize(a), hashed$usize(a)) ? 1 : 0); - const _266: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _266, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_usize(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_usize(a), hashed$usize(a)) ? 1 : 0); + const _266: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _266, true, undefined, undefined, 4, true)); while (true) { - const _271: rt.usize | rt.Done = iter2.next(); - if (_271 === rt.DONE) { + const _271: rs.usize | rs.Done = iter2.next(); + if (_271 === rs.DONE) { break; } _20(out, _271); } - const _280: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashUsize, rt.same)) as rt.HashSet, _280, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _280: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashUsize, rs.same)) as rs.HashSet, _280, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(a, f), (f: rt.Formatter) => rt.usizeDebug(b, f), (f: rt.Formatter) => rt.usizeLowerHex(a, f), (f: rt.Formatter) => rt.usizeUpperHex(b, f), (f: rt.Formatter) => rt.usizeOctal(c, f), (f: rt.Formatter) => rt.usizeBinary(a, f), (f: rt.Formatter) => rt.usizeDisplay(b, f), (f: rt.Formatter) => rt.usizeLowerHex(c, f), (f: rt.Formatter) => rt.usizeDebug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - const all: rt.usize[] = [a, b, c]; - const part8 = rt.iterSum(rt.iterSlice(all), rt.usizeSaturatingAdd, 0); + const all: rs.usize[] = [a, b, c]; + const part8 = rs.iterSum(rs.iterSlice(all), rs.usizeSaturatingAdd, 0); _20(out, part8); - const part9 = rt.iterSum(rt.iterSlice(all), rt.usizeSaturatingAdd, 0); + const part9 = rs.iterSum(rs.iterSlice(all), rs.usizeSaturatingAdd, 0); _20(out, part9); - const part10 = rt.iterProduct(rt.iterSlice(all), rt.usizeSaturatingMul, 1); + const part10 = rs.iterProduct(rs.iterSlice(all), rs.usizeSaturatingMul, 1); _20(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(all), rt.usizeSaturatingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(all), rs.usizeSaturatingMul, 1); _20(out, part11); - const part12 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.usizeSaturatingAdd, 0); + const part12 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.usizeSaturatingAdd, 0); _20(out, part12); - const part13 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.usizeSaturatingMul, 1); + const part13 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.usizeSaturatingMul, 1); _20(out, part13); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _370[0]; - const y: Gauge.Gauge = _370[1]; - const _378: Gauge.Gauge = Gauge.default$Default_usize(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_usize(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_usize(x7), hashed$num_Saturating_usize(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_usize(x7); - z._0 = rt.usizeSaturatingSub(z._0, y._0); + const _370: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _370[0]; + const y: Gauge.Gauge = _370[1]; + const _378: Gauge.Gauge = Gauge.default$Default_usize(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_usize(_378, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_usize(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_usize(x7), hashed$num_Saturating_usize(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_usize(x7); + z._0 = rs.usizeSaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _414: [rt.usize | undefined, rt.usize | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _414: [rs.usize | undefined, rs.usize | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_414[0] !== undefined) { if (_414[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.usizeSaturatingMul(_414[0], _414[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.usizeSaturatingMul(_414[0], _414[1])))); } } - const part = rt.usizeSaturatingMul(a, b); + const part = rs.usizeSaturatingMul(a, b); _20(out, part); - const part2 = rt.usizeSaturatingAdd(a, b); + const part2 = rs.usizeSaturatingAdd(a, b); _20(out, part2); - const part3 = rt.usizeSaturatingSub(a, b); + const part3 = rs.usizeSaturatingSub(a, b); _20(out, part3); - _20(out, rt.usizeDiv(a, b)); + _20(out, rs.usizeDiv(a, b)); } else { - const _457: rt.usize | undefined = rt.nonZero(a); + const _457: rs.usize | undefined = rs.nonZero(a); if (_457 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.usizeSaturatingAdd(_457, b)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.usizeSaturatingAdd(_457, b)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v))); +export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i8 = (at: rt.usize): rt.i8 => { + const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i8FromBeBytes(buf); + return rs.i8FromBeBytes(buf); }; - const _8: [rt.i8, rt.i8, rt.i8] = [take(0), take(1), take(2 * 1)]; - const a: rt.i8 = _8[0]; - const b: rt.i8 = _8[1]; - const c: rt.i8 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.i8, rs.i8, rs.i8] = [take(0), take(1), take(2 * 1)]; + const a: rs.i8 = _8[0]; + const b: rs.i8 = _8[1]; + const c: rs.i8 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.i8SaturatingAdd(a, b); + const part44 = rs.i8SaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.i8SaturatingSub(a, b); + const part43 = rs.i8SaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.i8SaturatingMul(a, b); + const part42 = rs.i8SaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.i8SaturatingDiv(a, b); + const part41 = rs.i8SaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.i8Rem(a, b)); + _20(out, rs.i8Rem(a, b)); } else if (_21 === 5) { - const part37 = rt.i8SaturatingSub(0, a); + const part37 = rs.i8SaturatingSub(0, a); _20(out, part37); - const part38 = rt.i8SaturatingSub(0, b); + const part38 = rs.i8SaturatingSub(0, b); _20(out, part38); - const part39 = rt.i8SaturatingSub(0, a); + const part39 = rs.i8SaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { _20(out, ~a); @@ -1461,190 +1461,190 @@ export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.i8 = a; - x = rt.i8SaturatingAdd(x, b); + let x: rs.i8 = a; + x = rs.i8SaturatingAdd(x, b); _20(out, x); - x = rt.i8SaturatingMul(x, c); + x = rs.i8SaturatingMul(x, c); _20(out, x); - x = rt.i8SaturatingSub(x, b); + x = rs.i8SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.i8 = a; - x2 = rt.i8SaturatingDiv(x2, b); + let x2: rs.i8 = a; + x2 = rs.i8SaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.i8 = a; - x3 = rt.i8Rem(x3, b); + let x3: rs.i8 = a; + x3 = rs.i8Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.i8 = a; + let x4: rs.i8 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.i8 = a; - x5 = rt.i8SaturatingAdd(x5, b); + let x5: rs.i8 = a; + x5 = rs.i8SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.i8SaturatingSub(x5, c); + x5 = rs.i8SaturatingSub(x5, c); _20(out, x5); - x5 = rt.i8SaturatingMul(x5, b); + x5 = rs.i8SaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.i8SaturatingDiv(x5, b); + x5 = rs.i8SaturatingDiv(x5, b); _20(out, x5); - x5 = rt.i8Rem(x5, c); + x5 = rs.i8Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.i8SaturatingAdd(a, b); + const part11 = rs.i8SaturatingAdd(a, b); _20(out, part11); - const part12 = rt.i8SaturatingSub(a, b); + const part12 = rs.i8SaturatingSub(a, b); _20(out, part12); - const part13 = rt.i8SaturatingMul(a, c); + const part13 = rs.i8SaturatingMul(a, c); _20(out, part13); _20(out, ~b); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.i8 = a; - x6 = rt.i8SaturatingAdd(x6, b); - x6 = rt.i8SaturatingMul(x6, c); + let x6: rs.i8 = a; + x6 = rs.i8SaturatingAdd(x6, b); + x6 = rs.i8SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.i8Rem(a, b)); - const part20 = rt.i8SaturatingDiv(c, b); + _20(out, rs.i8Rem(a, b)); + const part20 = rs.i8SaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { const _219: boolean = a === b; const _222: boolean = a !== b; - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.i8 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.i8 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.i8 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.i8 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_i8(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_i8(a), hashed$i8(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 1, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_i8(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_i8(a), hashed$i8(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 1, true)); while (true) { - const _286: rt.i8 | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.i8 | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI8, rt.same)) as rt.HashSet, _295, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI8, rs.same)) as rs.HashSet, _295, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(a, f), (f: rt.Formatter) => rt.i8Debug(b, f), (f: rt.Formatter) => rt.i8LowerHex(a, f), (f: rt.Formatter) => rt.i8UpperHex(b, f), (f: rt.Formatter) => rt.i8Octal(c, f), (f: rt.Formatter) => rt.i8Binary(a, f), (f: rt.Formatter) => rt.i8Display(b, f), (f: rt.Formatter) => rt.i8LowerHex(c, f), (f: rt.Formatter) => rt.i8Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_i8(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_i8(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_i8(x7), hashed$num_Saturating_i8(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_i8(x7); - z._0 = rt.i8SaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_i8(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i8(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i8(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i8(x7), hashed$num_Saturating_i8(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_i8(x7); + z._0 = rs.i8SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.i8 | undefined, rt.i8 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.i8 | undefined, rs.i8 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(rt.i8SaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(rs.i8SaturatingMul(_388[0], _388[1])))); } } - const part = rt.i8SaturatingMul(a, b); + const part = rs.i8SaturatingMul(a, b); _20(out, part); - const part2 = rt.i8SaturatingAdd(a, b); + const part2 = rs.i8SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.i8SaturatingSub(a, b); + const part3 = rs.i8SaturatingSub(a, b); _20(out, part3); - const part4 = rt.i8SaturatingDiv(a, b); + const part4 = rs.i8SaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.i8 | undefined = rt.nonZero(a); + const _431: rs.i8 | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(rt.i8SaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(rs.i8SaturatingSub(0, _431)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v))); +export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i16 = (at: rt.usize): rt.i16 => { - const buf: Uint8Array = rt.bytes(2); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { + const buf: Uint8Array = rs.bytes(2); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i16FromBeBytes(buf); + return rs.i16FromBeBytes(buf); }; - const _8: [rt.i16, rt.i16, rt.i16] = [take(0), take(2), take(2 * 2)]; - const a: rt.i16 = _8[0]; - const b: rt.i16 = _8[1]; - const c: rt.i16 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.i16, rs.i16, rs.i16] = [take(0), take(2), take(2 * 2)]; + const a: rs.i16 = _8[0]; + const b: rs.i16 = _8[1]; + const c: rs.i16 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.i16SaturatingAdd(a, b); + const part44 = rs.i16SaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.i16SaturatingSub(a, b); + const part43 = rs.i16SaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.i16SaturatingMul(a, b); + const part42 = rs.i16SaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.i16SaturatingDiv(a, b); + const part41 = rs.i16SaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.i16Rem(a, b)); + _20(out, rs.i16Rem(a, b)); } else if (_21 === 5) { - const part37 = rt.i16SaturatingSub(0, a); + const part37 = rs.i16SaturatingSub(0, a); _20(out, part37); - const part38 = rt.i16SaturatingSub(0, b); + const part38 = rs.i16SaturatingSub(0, b); _20(out, part38); - const part39 = rt.i16SaturatingSub(0, a); + const part39 = rs.i16SaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { _20(out, ~a); @@ -1655,190 +1655,190 @@ export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.i16 = a; - x = rt.i16SaturatingAdd(x, b); + let x: rs.i16 = a; + x = rs.i16SaturatingAdd(x, b); _20(out, x); - x = rt.i16SaturatingMul(x, c); + x = rs.i16SaturatingMul(x, c); _20(out, x); - x = rt.i16SaturatingSub(x, b); + x = rs.i16SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.i16 = a; - x2 = rt.i16SaturatingDiv(x2, b); + let x2: rs.i16 = a; + x2 = rs.i16SaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.i16 = a; - x3 = rt.i16Rem(x3, b); + let x3: rs.i16 = a; + x3 = rs.i16Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.i16 = a; + let x4: rs.i16 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.i16 = a; - x5 = rt.i16SaturatingAdd(x5, b); + let x5: rs.i16 = a; + x5 = rs.i16SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.i16SaturatingSub(x5, c); + x5 = rs.i16SaturatingSub(x5, c); _20(out, x5); - x5 = rt.i16SaturatingMul(x5, b); + x5 = rs.i16SaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.i16SaturatingDiv(x5, b); + x5 = rs.i16SaturatingDiv(x5, b); _20(out, x5); - x5 = rt.i16Rem(x5, c); + x5 = rs.i16Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.i16SaturatingAdd(a, b); + const part11 = rs.i16SaturatingAdd(a, b); _20(out, part11); - const part12 = rt.i16SaturatingSub(a, b); + const part12 = rs.i16SaturatingSub(a, b); _20(out, part12); - const part13 = rt.i16SaturatingMul(a, c); + const part13 = rs.i16SaturatingMul(a, c); _20(out, part13); _20(out, ~b); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.i16 = a; - x6 = rt.i16SaturatingAdd(x6, b); - x6 = rt.i16SaturatingMul(x6, c); + let x6: rs.i16 = a; + x6 = rs.i16SaturatingAdd(x6, b); + x6 = rs.i16SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.i16Rem(a, b)); - const part20 = rt.i16SaturatingDiv(c, b); + _20(out, rs.i16Rem(a, b)); + const part20 = rs.i16SaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { const _219: boolean = a === b; const _222: boolean = a !== b; - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.i16 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.i16 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.i16 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.i16 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_i16(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_i16(a), hashed$i16(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 2, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_i16(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_i16(a), hashed$i16(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 2, true)); while (true) { - const _286: rt.i16 | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.i16 | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI16, rt.same)) as rt.HashSet, _295, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI16, rs.same)) as rs.HashSet, _295, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(a, f), (f: rt.Formatter) => rt.i16Debug(b, f), (f: rt.Formatter) => rt.i16LowerHex(a, f), (f: rt.Formatter) => rt.i16UpperHex(b, f), (f: rt.Formatter) => rt.i16Octal(c, f), (f: rt.Formatter) => rt.i16Binary(a, f), (f: rt.Formatter) => rt.i16Display(b, f), (f: rt.Formatter) => rt.i16LowerHex(c, f), (f: rt.Formatter) => rt.i16Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_i16(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_i16(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_i16(x7), hashed$num_Saturating_i16(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_i16(x7); - z._0 = rt.i16SaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_i16(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i16(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i16(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i16(x7), hashed$num_Saturating_i16(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_i16(x7); + z._0 = rs.i16SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.i16 | undefined, rt.i16 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.i16 | undefined, rs.i16 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(rt.i16SaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.i16SaturatingMul(_388[0], _388[1])))); } } - const part = rt.i16SaturatingMul(a, b); + const part = rs.i16SaturatingMul(a, b); _20(out, part); - const part2 = rt.i16SaturatingAdd(a, b); + const part2 = rs.i16SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.i16SaturatingSub(a, b); + const part3 = rs.i16SaturatingSub(a, b); _20(out, part3); - const part4 = rt.i16SaturatingDiv(a, b); + const part4 = rs.i16SaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.i16 | undefined = rt.nonZero(a); + const _431: rs.i16 | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(rt.i16SaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.i16SaturatingSub(0, _431)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v))); +export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i32 = (at: rt.usize): rt.i32 => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i32FromBeBytes(buf); + return rs.i32FromBeBytes(buf); }; - const _8: [rt.i32, rt.i32, rt.i32] = [take(0), take(4), take(2 * 4)]; - const a: rt.i32 = _8[0]; - const b: rt.i32 = _8[1]; - const c: rt.i32 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.i32, rs.i32, rs.i32] = [take(0), take(4), take(2 * 4)]; + const a: rs.i32 = _8[0]; + const b: rs.i32 = _8[1]; + const c: rs.i32 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.i32SaturatingAdd(a, b); + const part44 = rs.i32SaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.i32SaturatingSub(a, b); + const part43 = rs.i32SaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.i32SaturatingMul(a, b); + const part42 = rs.i32SaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.i32SaturatingDiv(a, b); + const part41 = rs.i32SaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.i32Rem(a, b)); + _20(out, rs.i32Rem(a, b)); } else if (_21 === 5) { - const part37 = rt.i32SaturatingSub(0, a); + const part37 = rs.i32SaturatingSub(0, a); _20(out, part37); - const part38 = rt.i32SaturatingSub(0, b); + const part38 = rs.i32SaturatingSub(0, b); _20(out, part38); - const part39 = rt.i32SaturatingSub(0, a); + const part39 = rs.i32SaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { _20(out, ~a); @@ -1849,578 +1849,578 @@ export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.i32 = a; - x = rt.i32SaturatingAdd(x, b); + let x: rs.i32 = a; + x = rs.i32SaturatingAdd(x, b); _20(out, x); - x = rt.i32SaturatingMul(x, c); + x = rs.i32SaturatingMul(x, c); _20(out, x); - x = rt.i32SaturatingSub(x, b); + x = rs.i32SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.i32 = a; - x2 = rt.i32SaturatingDiv(x2, b); + let x2: rs.i32 = a; + x2 = rs.i32SaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.i32 = a; - x3 = rt.i32Rem(x3, b); + let x3: rs.i32 = a; + x3 = rs.i32Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.i32 = a; + let x4: rs.i32 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.i32 = a; - x5 = rt.i32SaturatingAdd(x5, b); + let x5: rs.i32 = a; + x5 = rs.i32SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.i32SaturatingSub(x5, c); + x5 = rs.i32SaturatingSub(x5, c); _20(out, x5); - x5 = rt.i32SaturatingMul(x5, b); + x5 = rs.i32SaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.i32SaturatingDiv(x5, b); + x5 = rs.i32SaturatingDiv(x5, b); _20(out, x5); - x5 = rt.i32Rem(x5, c); + x5 = rs.i32Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.i32SaturatingAdd(a, b); + const part11 = rs.i32SaturatingAdd(a, b); _20(out, part11); - const part12 = rt.i32SaturatingSub(a, b); + const part12 = rs.i32SaturatingSub(a, b); _20(out, part12); - const part13 = rt.i32SaturatingMul(a, c); + const part13 = rs.i32SaturatingMul(a, c); _20(out, part13); _20(out, ~b); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.i32 = a; - x6 = rt.i32SaturatingAdd(x6, b); - x6 = rt.i32SaturatingMul(x6, c); + let x6: rs.i32 = a; + x6 = rs.i32SaturatingAdd(x6, b); + x6 = rs.i32SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.i32Rem(a, b)); - const part20 = rt.i32SaturatingDiv(c, b); + _20(out, rs.i32Rem(a, b)); + const part20 = rs.i32SaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { const _219: boolean = a === b; const _222: boolean = a !== b; - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.i32 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.i32 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.i32 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.i32 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_i32(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_i32(a), hashed$i32(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_i32(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_i32(a), hashed$i32(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 4, true)); while (true) { - const _286: rt.i32 | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.i32 | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI32, rt.same)) as rt.HashSet, _295, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI32, rs.same)) as rs.HashSet, _295, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(a, f), (f: rt.Formatter) => rt.i32Debug(b, f), (f: rt.Formatter) => rt.i32LowerHex(a, f), (f: rt.Formatter) => rt.i32UpperHex(b, f), (f: rt.Formatter) => rt.i32Octal(c, f), (f: rt.Formatter) => rt.i32Binary(a, f), (f: rt.Formatter) => rt.i32Display(b, f), (f: rt.Formatter) => rt.i32LowerHex(c, f), (f: rt.Formatter) => rt.i32Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_i32(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_i32(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_i32(x7), hashed$num_Saturating_i32(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_i32(x7); - z._0 = rt.i32SaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_i32(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i32(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i32(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i32(x7), hashed$num_Saturating_i32(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_i32(x7); + z._0 = rs.i32SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.i32 | undefined, rt.i32 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.i32 | undefined, rs.i32 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(rt.i32SaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(rs.i32SaturatingMul(_388[0], _388[1])))); } } - const part = rt.i32SaturatingMul(a, b); + const part = rs.i32SaturatingMul(a, b); _20(out, part); - const part2 = rt.i32SaturatingAdd(a, b); + const part2 = rs.i32SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.i32SaturatingSub(a, b); + const part3 = rs.i32SaturatingSub(a, b); _20(out, part3); - const part4 = rt.i32SaturatingDiv(a, b); + const part4 = rs.i32SaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.i32 | undefined = rt.nonZero(a); + const _431: rs.i32 | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(rt.i32SaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(rs.i32SaturatingSub(0, _431)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v))); +export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i64 = (at: rt.usize): rt.i64 => { - const buf: Uint8Array = rt.bytes(8); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { + const buf: Uint8Array = rs.bytes(8); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i64FromBeBytes(buf); + return rs.i64FromBeBytes(buf); }; - const _8: [rt.i64, rt.i64, rt.i64] = [take(0), take(8), take(2 * 8)]; - const a: rt.i64 = _8[0]; - const b: rt.i64 = _8[1]; - const c: rt.i64 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.i64, rs.i64, rs.i64] = [take(0), take(8), take(2 * 8)]; + const a: rs.i64 = _8[0]; + const b: rs.i64 = _8[1]; + const c: rs.i64 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.i64SaturatingAdd(a, b); + const part44 = rs.i64SaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.i64SaturatingSub(a, b); + const part43 = rs.i64SaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.i64SaturatingMul(a, b); + const part42 = rs.i64SaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.i64SaturatingDiv(a, b); + const part41 = rs.i64SaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.i64Rem(a, b)); + _20(out, rs.i64Rem(a, b)); } else if (_21 === 5) { - const part37 = rt.i64SaturatingSub(0, a); + const part37 = rs.i64SaturatingSub(0, a); _20(out, part37); - const part38 = rt.i64SaturatingSub(0, b); + const part38 = rs.i64SaturatingSub(0, b); _20(out, part38); - const part39 = rt.i64SaturatingSub(0, a); + const part39 = rs.i64SaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { - _20(out, rt.i64Not(a)); + _20(out, rs.i64Not(a)); } else if (_21 === 7) { - _20(out, rt.i64And(a, b)); + _20(out, rs.i64And(a, b)); } else if (_21 === 8) { - _20(out, rt.i64Or(a, b)); + _20(out, rs.i64Or(a, b)); } else if (_21 === 9) { - _20(out, rt.i64Xor(a, b)); + _20(out, rs.i64Xor(a, b)); } else if (_21 === 10) { - let x: rt.i64 = a; - x = rt.i64SaturatingAdd(x, b); + let x: rs.i64 = a; + x = rs.i64SaturatingAdd(x, b); _20(out, x); - x = rt.i64SaturatingMul(x, c); + x = rs.i64SaturatingMul(x, c); _20(out, x); - x = rt.i64SaturatingSub(x, b); + x = rs.i64SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.i64 = a; - x2 = rt.i64SaturatingDiv(x2, b); + let x2: rs.i64 = a; + x2 = rs.i64SaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.i64 = a; - x3 = rt.i64Rem(x3, b); + let x3: rs.i64 = a; + x3 = rs.i64Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.i64 = a; - x4 = rt.i64And(x4, b); - x4 = rt.i64Or(x4, c); - x4 = rt.i64Xor(x4, b); + let x4: rs.i64 = a; + x4 = rs.i64And(x4, b); + x4 = rs.i64Or(x4, c); + x4 = rs.i64Xor(x4, b); _20(out, x4); } else if (_21 === 14) { - let x5: rt.i64 = a; - x5 = rt.i64SaturatingAdd(x5, b); + let x5: rs.i64 = a; + x5 = rs.i64SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.i64SaturatingSub(x5, c); + x5 = rs.i64SaturatingSub(x5, c); _20(out, x5); - x5 = rt.i64SaturatingMul(x5, b); + x5 = rs.i64SaturatingMul(x5, b); _20(out, x5); - x5 = rt.i64And(x5, c); - x5 = rt.i64Or(x5, b); - x5 = rt.i64Xor(x5, c); + x5 = rs.i64And(x5, c); + x5 = rs.i64Or(x5, b); + x5 = rs.i64Xor(x5, c); _20(out, x5); - x5 = rt.i64SaturatingDiv(x5, b); + x5 = rs.i64SaturatingDiv(x5, b); _20(out, x5); - x5 = rt.i64Rem(x5, c); + x5 = rs.i64Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.i64SaturatingAdd(a, b); + const part11 = rs.i64SaturatingAdd(a, b); _20(out, part11); - const part12 = rt.i64SaturatingSub(a, b); + const part12 = rs.i64SaturatingSub(a, b); _20(out, part12); - const part13 = rt.i64SaturatingMul(a, c); + const part13 = rs.i64SaturatingMul(a, c); _20(out, part13); - _20(out, rt.i64Not(b)); - _20(out, rt.i64Xor(a, c)); - _20(out, rt.i64And(a, b)); - _20(out, rt.i64Or(a, c)); - let x6: rt.i64 = a; - x6 = rt.i64SaturatingAdd(x6, b); - x6 = rt.i64SaturatingMul(x6, c); + _20(out, rs.i64Not(b)); + _20(out, rs.i64Xor(a, c)); + _20(out, rs.i64And(a, b)); + _20(out, rs.i64Or(a, c)); + let x6: rs.i64 = a; + x6 = rs.i64SaturatingAdd(x6, b); + x6 = rs.i64SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.i64Rem(a, b)); - const part20 = rt.i64SaturatingDiv(c, b); + _20(out, rs.i64Rem(a, b)); + const part20 = rs.i64SaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { - const _219: boolean = rt.i64Eq(a, b); - const _222: boolean = !rt.i64Eq(a, b); - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _219: boolean = rs.i64Eq(a, b); + const _222: boolean = !rs.i64Eq(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.i64 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.i64 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.i64 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.i64 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_i64(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_i64(a), hashed$i64(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 8, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_i64(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_i64(a), hashed$i64(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 8, true)); while (true) { - const _286: rt.i64 | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.i64 | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI64, rt.i64Eq)) as rt.HashSet, _295, undefined, undefined, 117440512); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI64, rs.i64Eq)) as rs.HashSet, _295, undefined, undefined, 117440512); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(a, f), (f: rt.Formatter) => rt.i64Debug(b, f), (f: rt.Formatter) => rt.i64LowerHex(a, f), (f: rt.Formatter) => rt.i64UpperHex(b, f), (f: rt.Formatter) => rt.i64Octal(c, f), (f: rt.Formatter) => rt.i64Binary(a, f), (f: rt.Formatter) => rt.i64Display(b, f), (f: rt.Formatter) => rt.i64LowerHex(c, f), (f: rt.Formatter) => rt.i64Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_i64(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_i64(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_i64(x7), hashed$num_Saturating_i64(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_i64(x7); - z._0 = rt.i64SaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_i64(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i64(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i64(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i64(x7), hashed$num_Saturating_i64(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_i64(x7); + z._0 = rs.i64SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.i64 | undefined, rt.i64 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.i64 | undefined, rs.i64 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64SaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64SaturatingMul(_388[0], _388[1])))); } } - const part = rt.i64SaturatingMul(a, b); + const part = rs.i64SaturatingMul(a, b); _20(out, part); - const part2 = rt.i64SaturatingAdd(a, b); + const part2 = rs.i64SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.i64SaturatingSub(a, b); + const part3 = rs.i64SaturatingSub(a, b); _20(out, part3); - const part4 = rt.i64SaturatingDiv(a, b); + const part4 = rs.i64SaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.i64 | undefined = rt.nonZero(a); + const _431: rs.i64 | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64SaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64SaturatingSub(0, _431)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); +export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i128 = (at: rt.usize): rt.i128 => { - const buf: Uint8Array = rt.bytes(16); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { + const buf: Uint8Array = rs.bytes(16); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i128FromBeBytes(buf); + return rs.i128FromBeBytes(buf); }; - const _8: [rt.i128, rt.i128, rt.i128] = [take(0), take(16), take(2 * 16)]; - const a: rt.i128 = _8[0]; - const b: rt.i128 = _8[1]; - const c: rt.i128 = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.i128, rs.i128, rs.i128] = [take(0), take(16), take(2 * 16)]; + const a: rs.i128 = _8[0]; + const b: rs.i128 = _8[1]; + const c: rs.i128 = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.i128SaturatingAdd(a, b); + const part44 = rs.i128SaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.i128SaturatingSub(a, b); + const part43 = rs.i128SaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.i128SaturatingMul(a, b); + const part42 = rs.i128SaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.i128SaturatingDiv(a, b); + const part41 = rs.i128SaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.i128Rem(a, b)); + _20(out, rs.i128Rem(a, b)); } else if (_21 === 5) { - const part37 = rt.i128SaturatingSub(0, a); + const part37 = rs.i128SaturatingSub(0, a); _20(out, part37); - const part38 = rt.i128SaturatingSub(0, b); + const part38 = rs.i128SaturatingSub(0, b); _20(out, part38); - const part39 = rt.i128SaturatingSub(0, a); + const part39 = rs.i128SaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { - _20(out, rt.i128Not(a)); + _20(out, rs.i128Not(a)); } else if (_21 === 7) { - _20(out, rt.i128And(a, b)); + _20(out, rs.i128And(a, b)); } else if (_21 === 8) { - _20(out, rt.i128Or(a, b)); + _20(out, rs.i128Or(a, b)); } else if (_21 === 9) { - _20(out, rt.i128Xor(a, b)); + _20(out, rs.i128Xor(a, b)); } else if (_21 === 10) { - let x: rt.i128 = a; - x = rt.i128SaturatingAdd(x, b); + let x: rs.i128 = a; + x = rs.i128SaturatingAdd(x, b); _20(out, x); - x = rt.i128SaturatingMul(x, c); + x = rs.i128SaturatingMul(x, c); _20(out, x); - x = rt.i128SaturatingSub(x, b); + x = rs.i128SaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.i128 = a; - x2 = rt.i128SaturatingDiv(x2, b); + let x2: rs.i128 = a; + x2 = rs.i128SaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.i128 = a; - x3 = rt.i128Rem(x3, b); + let x3: rs.i128 = a; + x3 = rs.i128Rem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.i128 = a; - x4 = rt.i128And(x4, b); - x4 = rt.i128Or(x4, c); - x4 = rt.i128Xor(x4, b); + let x4: rs.i128 = a; + x4 = rs.i128And(x4, b); + x4 = rs.i128Or(x4, c); + x4 = rs.i128Xor(x4, b); _20(out, x4); } else if (_21 === 14) { - let x5: rt.i128 = a; - x5 = rt.i128SaturatingAdd(x5, b); + let x5: rs.i128 = a; + x5 = rs.i128SaturatingAdd(x5, b); _20(out, x5); - x5 = rt.i128SaturatingSub(x5, c); + x5 = rs.i128SaturatingSub(x5, c); _20(out, x5); - x5 = rt.i128SaturatingMul(x5, b); + x5 = rs.i128SaturatingMul(x5, b); _20(out, x5); - x5 = rt.i128And(x5, c); - x5 = rt.i128Or(x5, b); - x5 = rt.i128Xor(x5, c); + x5 = rs.i128And(x5, c); + x5 = rs.i128Or(x5, b); + x5 = rs.i128Xor(x5, c); _20(out, x5); - x5 = rt.i128SaturatingDiv(x5, b); + x5 = rs.i128SaturatingDiv(x5, b); _20(out, x5); - x5 = rt.i128Rem(x5, c); + x5 = rs.i128Rem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.i128SaturatingAdd(a, b); + const part11 = rs.i128SaturatingAdd(a, b); _20(out, part11); - const part12 = rt.i128SaturatingSub(a, b); + const part12 = rs.i128SaturatingSub(a, b); _20(out, part12); - const part13 = rt.i128SaturatingMul(a, c); + const part13 = rs.i128SaturatingMul(a, c); _20(out, part13); - _20(out, rt.i128Not(b)); - _20(out, rt.i128Xor(a, c)); - _20(out, rt.i128And(a, b)); - _20(out, rt.i128Or(a, c)); - let x6: rt.i128 = a; - x6 = rt.i128SaturatingAdd(x6, b); - x6 = rt.i128SaturatingMul(x6, c); + _20(out, rs.i128Not(b)); + _20(out, rs.i128Xor(a, c)); + _20(out, rs.i128And(a, b)); + _20(out, rs.i128Or(a, c)); + let x6: rs.i128 = a; + x6 = rs.i128SaturatingAdd(x6, b); + x6 = rs.i128SaturatingMul(x6, c); _20(out, x6); - _20(out, rt.i128Rem(a, b)); - const part20 = rt.i128SaturatingDiv(c, b); + _20(out, rs.i128Rem(a, b)); + const part20 = rs.i128SaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { - const _219: boolean = rt.i128Eq(a, b); - const _222: boolean = !rt.i128Eq(a, b); - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _219: boolean = rs.i128Eq(a, b); + const _222: boolean = !rs.i128Eq(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.i128 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.i128 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.i128 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.i128 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_i128(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_i128(a), hashed$i128(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 16, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_i128(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_i128(a), hashed$i128(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 16, true)); while (true) { - const _286: rt.i128 | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.i128 | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI128, rt.i128Eq)) as rt.HashSet, _295, undefined, undefined, 58720256); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI128, rs.i128Eq)) as rs.HashSet, _295, undefined, undefined, 58720256); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(a, f), (f: rt.Formatter) => rt.i128Debug(b, f), (f: rt.Formatter) => rt.i128LowerHex(a, f), (f: rt.Formatter) => rt.i128UpperHex(b, f), (f: rt.Formatter) => rt.i128Octal(c, f), (f: rt.Formatter) => rt.i128Binary(a, f), (f: rt.Formatter) => rt.i128Display(b, f), (f: rt.Formatter) => rt.i128LowerHex(c, f), (f: rt.Formatter) => rt.i128Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_i128(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_i128(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_i128(x7), hashed$num_Saturating_i128(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_i128(x7); - z._0 = rt.i128SaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_i128(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_i128(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_i128(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_i128(x7), hashed$num_Saturating_i128(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_i128(x7); + z._0 = rs.i128SaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.i128 | undefined, rt.i128 | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.i128 | undefined, rs.i128 | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128SaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128SaturatingMul(_388[0], _388[1])))); } } - const part = rt.i128SaturatingMul(a, b); + const part = rs.i128SaturatingMul(a, b); _20(out, part); - const part2 = rt.i128SaturatingAdd(a, b); + const part2 = rs.i128SaturatingAdd(a, b); _20(out, part2); - const part3 = rt.i128SaturatingSub(a, b); + const part3 = rs.i128SaturatingSub(a, b); _20(out, part3); - const part4 = rt.i128SaturatingDiv(a, b); + const part4 = rs.i128SaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.i128 | undefined = rt.nonZero(a); + const _431: rs.i128 | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128SaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128SaturatingSub(0, _431)))); } } } /** Apply operation `kind` to `Saturating`s taken from `data`: three operands. */ -export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _20: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v))); +export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _20: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.isize = (at: rt.usize): rt.isize => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.isizeFromBeBytes(buf); + return rs.isizeFromBeBytes(buf); }; - const _8: [rt.isize, rt.isize, rt.isize] = [take(0), take(4), take(2 * 4)]; - const a: rt.isize = _8[0]; - const b: rt.isize = _8[1]; - const c: rt.isize = _8[2]; - const _21: rt.u8 = rt.u8Rem(kind, 24); + const _8: [rs.isize, rs.isize, rs.isize] = [take(0), take(4), take(2 * 4)]; + const a: rs.isize = _8[0]; + const b: rs.isize = _8[1]; + const c: rs.isize = _8[2]; + const _21: rs.u8 = rs.u8Rem(kind, 24); if (_21 === 0) { - const part44 = rt.isizeSaturatingAdd(a, b); + const part44 = rs.isizeSaturatingAdd(a, b); _20(out, part44); } else if (_21 === 1) { - const part43 = rt.isizeSaturatingSub(a, b); + const part43 = rs.isizeSaturatingSub(a, b); _20(out, part43); } else if (_21 === 2) { - const part42 = rt.isizeSaturatingMul(a, b); + const part42 = rs.isizeSaturatingMul(a, b); _20(out, part42); } else if (_21 === 3) { - const part41 = rt.isizeSaturatingDiv(a, b); + const part41 = rs.isizeSaturatingDiv(a, b); _20(out, part41); } else if (_21 === 4) { - _20(out, rt.isizeRem(a, b)); + _20(out, rs.isizeRem(a, b)); } else if (_21 === 5) { - const part37 = rt.isizeSaturatingSub(0, a); + const part37 = rs.isizeSaturatingSub(0, a); _20(out, part37); - const part38 = rt.isizeSaturatingSub(0, b); + const part38 = rs.isizeSaturatingSub(0, b); _20(out, part38); - const part39 = rt.isizeSaturatingSub(0, a); + const part39 = rs.isizeSaturatingSub(0, a); _20(out, part39); } else if (_21 === 6) { _20(out, ~a); @@ -2431,144 +2431,144 @@ export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_21 === 9) { _20(out, a ^ b); } else if (_21 === 10) { - let x: rt.isize = a; - x = rt.isizeSaturatingAdd(x, b); + let x: rs.isize = a; + x = rs.isizeSaturatingAdd(x, b); _20(out, x); - x = rt.isizeSaturatingMul(x, c); + x = rs.isizeSaturatingMul(x, c); _20(out, x); - x = rt.isizeSaturatingSub(x, b); + x = rs.isizeSaturatingSub(x, b); _20(out, x); } else if (_21 === 11) { - let x2: rt.isize = a; - x2 = rt.isizeSaturatingDiv(x2, b); + let x2: rs.isize = a; + x2 = rs.isizeSaturatingDiv(x2, b); _20(out, x2); } else if (_21 === 12) { - let x3: rt.isize = a; - x3 = rt.isizeRem(x3, b); + let x3: rs.isize = a; + x3 = rs.isizeRem(x3, b); _20(out, x3); } else if (_21 === 13) { - let x4: rt.isize = a; + let x4: rs.isize = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _20(out, x4); } else if (_21 === 14) { - let x5: rt.isize = a; - x5 = rt.isizeSaturatingAdd(x5, b); + let x5: rs.isize = a; + x5 = rs.isizeSaturatingAdd(x5, b); _20(out, x5); - x5 = rt.isizeSaturatingSub(x5, c); + x5 = rs.isizeSaturatingSub(x5, c); _20(out, x5); - x5 = rt.isizeSaturatingMul(x5, b); + x5 = rs.isizeSaturatingMul(x5, b); _20(out, x5); x5 = x5 & c; x5 = x5 | b; x5 = x5 ^ c; _20(out, x5); - x5 = rt.isizeSaturatingDiv(x5, b); + x5 = rs.isizeSaturatingDiv(x5, b); _20(out, x5); - x5 = rt.isizeRem(x5, c); + x5 = rs.isizeRem(x5, c); _20(out, x5); } else if (_21 === 15) { - const part11 = rt.isizeSaturatingAdd(a, b); + const part11 = rs.isizeSaturatingAdd(a, b); _20(out, part11); - const part12 = rt.isizeSaturatingSub(a, b); + const part12 = rs.isizeSaturatingSub(a, b); _20(out, part12); - const part13 = rt.isizeSaturatingMul(a, c); + const part13 = rs.isizeSaturatingMul(a, c); _20(out, part13); _20(out, ~b); _20(out, a ^ c); _20(out, a & b); _20(out, a | c); - let x6: rt.isize = a; - x6 = rt.isizeSaturatingAdd(x6, b); - x6 = rt.isizeSaturatingMul(x6, c); + let x6: rs.isize = a; + x6 = rs.isizeSaturatingAdd(x6, b); + x6 = rs.isizeSaturatingMul(x6, c); _20(out, x6); - _20(out, rt.isizeRem(a, b)); - const part20 = rt.isizeSaturatingDiv(c, b); + _20(out, rs.isizeRem(a, b)); + const part20 = rs.isizeSaturatingDiv(c, b); _20(out, part20); } else if (_21 === 16) { const _219: boolean = a === b; const _222: boolean = a !== b; - const _225: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _225: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _228: boolean = order !== undefined && order <= 0; - const _231: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _231: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_219, _222, _225, _228, _231, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _247: boolean | rt.Done = iter.next(); - if (_247 === rt.DONE) { + const _247: boolean | rs.Done = iter.next(); + if (_247 === rs.DONE) { break; } - rt.byteVecPush(out, _247 ? 1 : 0); + rs.byteVecPush(out, _247 ? 1 : 0); } - const part8 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part8 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _20(out, part8); - const part9 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part9 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _20(out, part9); - const _265: rt.isize = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _266: rt.isize = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part10 = rt.ordClamp(a, _265, _266, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _265: rs.isize = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _266: rs.isize = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part10 = rs.ordClamp(a, _265, _266, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _20(out, part10); } else if (_21 === 17) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Saturating_isize(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Saturating_isize(a), hashed$isize(a)) ? 1 : 0); - const _281: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _281, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Saturating_isize(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Saturating_isize(a), hashed$isize(a)) ? 1 : 0); + const _281: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _281, true, undefined, undefined, 4, true)); while (true) { - const _286: rt.isize | rt.Done = iter2.next(); - if (_286 === rt.DONE) { + const _286: rs.isize | rs.Done = iter2.next(); + if (_286 === rs.DONE) { break; } _20(out, _286); } - const _295: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashIsize, rt.same)) as rt.HashSet, _295, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _295: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashIsize, rs.same)) as rs.HashSet, _295, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_21 === 18) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(a, f), (f: rt.Formatter) => rt.isizeDebug(b, f), (f: rt.Formatter) => rt.isizeLowerHex(a, f), (f: rt.Formatter) => rt.isizeUpperHex(b, f), (f: rt.Formatter) => rt.isizeOctal(c, f), (f: rt.Formatter) => rt.isizeBinary(a, f), (f: rt.Formatter) => rt.isizeDisplay(b, f), (f: rt.Formatter) => rt.isizeLowerHex(c, f), (f: rt.Formatter) => rt.isizeDebug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_21 === 19) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else if (_21 === 20) { _20(out, 0); _20(out, a); _20(out, a); } else if (_21 === 21) { - const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; - const x7: Gauge.Gauge = _344[0]; - const y: Gauge.Gauge = _344[1]; - const _352: Gauge.Gauge = Gauge.default$Default_isize(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rt.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); - rt.byteVecPush(out, Gauge.cmp$cmp_Ord_isize(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$saturates_Gauge_isize(x7), hashed$num_Saturating_isize(a)) ? 1 : 0); - const z: Gauge.Gauge = copy$saturates_Gauge_isize(x7); - z._0 = rt.isizeSaturatingSub(z._0, y._0); + const _344: [Gauge.Gauge, Gauge.Gauge] = [new Gauge.Gauge(a), new Gauge.Gauge(b)]; + const x7: Gauge.Gauge = _344[0]; + const y: Gauge.Gauge = _344[1]; + const _352: Gauge.Gauge = Gauge.default$Default_isize(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Gauge.fmt$fmt_Debug_isize(_352, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); + rs.byteVecPush(out, Gauge.cmp$cmp_Ord_isize(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$saturates_Gauge_isize(x7), hashed$num_Saturating_isize(a)) ? 1 : 0); + const z: Gauge.Gauge = copy$saturates_Gauge_isize(x7); + z._0 = rs.isizeSaturatingSub(z._0, y._0); _20(out, z._0); } else if (_21 === 22) { - const _388: [rt.isize | undefined, rt.isize | undefined] = [rt.nonZero(a), rt.nonZero(b)]; + const _388: [rs.isize | undefined, rs.isize | undefined] = [rs.nonZero(a), rs.nonZero(b)]; if (_388[0] !== undefined) { if (_388[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeSaturatingMul(_388[0], _388[1])))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(rs.isizeSaturatingMul(_388[0], _388[1])))); } } - const part = rt.isizeSaturatingMul(a, b); + const part = rs.isizeSaturatingMul(a, b); _20(out, part); - const part2 = rt.isizeSaturatingAdd(a, b); + const part2 = rs.isizeSaturatingAdd(a, b); _20(out, part2); - const part3 = rt.isizeSaturatingSub(a, b); + const part3 = rs.isizeSaturatingSub(a, b); _20(out, part3); - const part4 = rt.isizeSaturatingDiv(a, b); + const part4 = rs.isizeSaturatingDiv(a, b); _20(out, part4); } else { - const _431: rt.isize | undefined = rt.nonZero(a); + const _431: rs.isize | undefined = rs.nonZero(a); if (_431 !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeSaturatingSub(0, _431)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(rs.isizeSaturatingSub(0, _431)))); } } } diff --git a/ts/fixtures/lang/searches/expected/core/option.ts b/ts/fixtures/lang/searches/expected/core/option.ts index 0596cf60a..2a33ff40b 100644 --- a/ts/fixtures/lang/searches/expected/core/option.ts +++ b/ts/fixtures/lang/searches/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { +export function mapOr$0z4nmg2(self: [rs.u8, rs.ByteSlice] | undefined, default_: [rs.u8, rs.ByteSlice], f: (a0: [rs.u8, rs.ByteSlice]) => [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/searches/expected/harness.ts b/ts/fixtures/lang/searches/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/searches/expected/harness.ts +++ b/ts/fixtures/lang/searches/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/searches/expected/lib.ts b/ts/fixtures/lang/searches/expected/lib.ts index 142cd4541..02dfe9e4d 100644 --- a/ts/fixtures/lang/searches/expected/lib.ts +++ b/ts/fixtures/lang/searches/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { searches, texts } from "./searches.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["searches::searches", searches as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["searches::texts", texts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["searches::searches", searches as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["searches::texts", texts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/searches/expected/searches.ts b/ts/fixtures/lang/searches/expected/searches.ts index bc21675e8..e094cbb06 100644 --- a/ts/fixtures/lang/searches/expected/searches.ts +++ b/ts/fixtures/lang/searches/expected/searches.ts @@ -1,47 +1,47 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; import { put as harness_put, text } from "./harness.ts"; -export function put$searches_Item_ref_str(self: string, out: rt.ByteVec): void { +export function put$searches_Item_ref_str(self: string, out: rs.ByteVec): void { harness_put(out, self); } -export function put$searches_Item_tuple2_usize_ref_str(self: [rt.usize, string], out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(self[0] as rt.u32))); +export function put$searches_Item_tuple2_usize_ref_str(self: [rs.usize, string], out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(self[0] as rs.u32))); harness_put(out, self[1]); } -export function put$searches_Item_tuple2_usize_char(self: [rt.usize, rt.char], out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(self[0] as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(self[1] as rt.u32))); +export function put$searches_Item_tuple2_usize_char(self: [rs.usize, rs.char], out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(self[0] as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(self[1] as rs.u32))); } /** * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Matches_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Matches_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -52,26 +52,26 @@ export function front$ref_str_str_Matches_array2_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Matches_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Matches_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -82,26 +82,26 @@ export function front$ref_str_str_Matches_char(it: rt.Iter, out: rt.Byte * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Matches_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Matches_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -112,26 +112,26 @@ export function front$ref_str_str_Matches_ref_slice_char(it: rt.Iter, ou * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Matches_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Matches_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -142,26 +142,26 @@ export function front$ref_str_str_Matches_ref_str(it: rt.Iter, out: rt.B * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Matches_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -172,26 +172,26 @@ export function front$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RMatches_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RMatches_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -202,26 +202,26 @@ export function front$ref_str_str_RMatches_array2_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RMatches_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RMatches_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -232,26 +232,26 @@ export function front$ref_str_str_RMatches_char(it: rt.Iter, out: rt.Byt * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RMatches_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -262,26 +262,26 @@ export function front$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, o * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RMatches_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RMatches_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -292,26 +292,26 @@ export function front$ref_str_str_RMatches_ref_str(it: rt.Iter, out: rt. * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RMatches_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RMatches_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -322,26 +322,26 @@ export function front$ref_str_str_RMatches_searches_searches_closure1(it: rt.Ite * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitN_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitN_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -352,26 +352,26 @@ export function front$ref_str_str_RSplitN_array2_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitN_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitN_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -382,26 +382,26 @@ export function front$ref_str_str_RSplitN_char(it: rt.Iter, out: rt.Byte * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitN_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitN_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -412,26 +412,26 @@ export function front$ref_str_str_RSplitN_ref_slice_char(it: rt.Iter, ou * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitN_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitN_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -442,26 +442,26 @@ export function front$ref_str_str_RSplitN_ref_str(it: rt.Iter, out: rt.B * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitN_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitN_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -472,26 +472,26 @@ export function front$ref_str_str_RSplitN_searches_searches_closure1(it: rt.Iter * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitTerminator_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -502,26 +502,26 @@ export function front$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitTerminator_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -532,26 +532,26 @@ export function front$ref_str_str_RSplitTerminator_char(it: rt.Iter, out * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitTerminator_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -562,26 +562,26 @@ export function front$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitTerminator_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -592,26 +592,26 @@ export function front$ref_str_str_RSplitTerminator_ref_str(it: rt.Iter, * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplitTerminator_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplitTerminator_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -622,26 +622,26 @@ export function front$ref_str_str_RSplitTerminator_searches_searches_closure1(it * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplit_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplit_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -652,26 +652,26 @@ export function front$ref_str_str_RSplit_array2_char(it: rt.Iter, out: r * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplit_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplit_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -682,26 +682,26 @@ export function front$ref_str_str_RSplit_char(it: rt.Iter, out: rt.ByteV * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplit_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -712,26 +712,26 @@ export function front$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, out * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplit_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplit_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -742,26 +742,26 @@ export function front$ref_str_str_RSplit_ref_str(it: rt.Iter, out: rt.By * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_RSplit_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -772,26 +772,26 @@ export function front$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter< * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitInclusive_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitInclusive_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -802,26 +802,26 @@ export function front$ref_str_str_SplitInclusive_array2_char(it: rt.Iter * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitInclusive_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitInclusive_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -832,26 +832,26 @@ export function front$ref_str_str_SplitInclusive_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitInclusive_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -862,26 +862,26 @@ export function front$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitInclusive_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -892,26 +892,26 @@ export function front$ref_str_str_SplitInclusive_ref_str(it: rt.Iter, ou * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitInclusive_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitInclusive_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -922,26 +922,26 @@ export function front$ref_str_str_SplitInclusive_searches_searches_closure1(it: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitN_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitN_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -952,26 +952,26 @@ export function front$ref_str_str_SplitN_array2_char(it: rt.Iter, out: r * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitN_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitN_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -982,26 +982,26 @@ export function front$ref_str_str_SplitN_char(it: rt.Iter, out: rt.ByteV * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitN_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitN_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1012,26 +1012,26 @@ export function front$ref_str_str_SplitN_ref_slice_char(it: rt.Iter, out * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitN_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitN_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1042,26 +1042,26 @@ export function front$ref_str_str_SplitN_ref_str(it: rt.Iter, out: rt.By * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitN_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitN_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1072,26 +1072,26 @@ export function front$ref_str_str_SplitN_searches_searches_closure1(it: rt.Iter< * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitTerminator_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitTerminator_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1102,26 +1102,26 @@ export function front$ref_str_str_SplitTerminator_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitTerminator_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1132,26 +1132,26 @@ export function front$ref_str_str_SplitTerminator_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitTerminator_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1162,26 +1162,26 @@ export function front$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitTerminator_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1192,26 +1192,26 @@ export function front$ref_str_str_SplitTerminator_ref_str(it: rt.Iter, o * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_SplitTerminator_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_SplitTerminator_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1222,26 +1222,26 @@ export function front$ref_str_str_SplitTerminator_searches_searches_closure1(it: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Split_array2_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Split_array2_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1252,26 +1252,26 @@ export function front$ref_str_str_Split_array2_char(it: rt.Iter, out: rt * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Split_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Split_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1282,26 +1282,26 @@ export function front$ref_str_str_Split_char(it: rt.Iter, out: rt.ByteVe * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Split_ref_slice_char(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Split_ref_slice_char(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1312,26 +1312,26 @@ export function front$ref_str_str_Split_ref_slice_char(it: rt.Iter, out: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Split_ref_str(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Split_ref_str(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1342,26 +1342,26 @@ export function front$ref_str_str_Split_ref_str(it: rt.Iter, out: rt.Byt * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$ref_str_str_Split_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter | undefined = undefined; +export function front$ref_str_str_Split_searches_searches_closure1(it: rs.Iter, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter | undefined = undefined; while (true) { - const _5: string | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: string | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: string | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: string | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_ref_str(_24, out); @@ -1372,26 +1372,26 @@ export function front$ref_str_str_Split_searches_searches_closure1(it: rt.Iter, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1402,26 +1402,26 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rt.I * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_MatchIndices_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1432,26 +1432,26 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1462,26 +1462,26 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: r * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_MatchIndices_ref_str(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_MatchIndices_ref_str(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1492,26 +1492,26 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_ref_str(it: rt.Iter< * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1522,26 +1522,26 @@ export function front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_cl * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1552,26 +1552,26 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt. * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_RMatchIndices_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1582,26 +1582,26 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[r * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1612,26 +1612,26 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1642,26 +1642,26 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(it: rt.Iter * `it` read to its end from the front, then how many it gave, then a clone made after the * first, read to its end. */ -export function front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(it: rt.Iter<[rt.usize, string]>, out: rt.ByteVec): void { - let n: rt.i32 = 0; - let copy: rt.Iter<[rt.usize, string]> | undefined = undefined; +export function front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(it: rs.Iter<[rs.usize, string]>, out: rs.ByteVec): void { + let n: rs.i32 = 0; + let copy: rs.Iter<[rs.usize, string]> | undefined = undefined; while (true) { - const _5: [rt.usize, string] | rt.Done = it.next(); - if (_5 !== rt.DONE) { + const _5: [rs.usize, string] | rs.Done = it.next(); + if (_5 !== rs.DONE) { put$searches_Item_tuple2_usize_ref_str(_5, out); if (n === 0) { copy = it.clone(); } - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } else { break; } } - rt.byteVecPush(out, n & 0xff); - const iter: rt.Iter<[rt.usize, string]> = rt.iterFlatten(rt.iterOption(copy), undefined, true); + rs.byteVecPush(out, n & 0xff); + const iter: rs.Iter<[rs.usize, string]> = rs.iterFlatten(rs.iterOption(copy), undefined, true); while (true) { - const _24: [rt.usize, string] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, string] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_24, out); @@ -1672,13 +1672,13 @@ export function front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_c * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Lines(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Lines(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1689,23 +1689,23 @@ export function both$ref_str_str_Lines(it: rt.Iter, data: rt.ByteSlice, back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1720,13 +1720,13 @@ export function both$ref_str_str_Lines(it: rt.Iter, data: rt.ByteSlice, * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Matches_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Matches_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1737,23 +1737,23 @@ export function both$ref_str_str_Matches_array2_char(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1768,13 +1768,13 @@ export function both$ref_str_str_Matches_array2_char(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Matches_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Matches_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1785,23 +1785,23 @@ export function both$ref_str_str_Matches_char(it: rt.Iter, data: rt.Byte back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1816,13 +1816,13 @@ export function both$ref_str_str_Matches_char(it: rt.Iter, data: rt.Byte * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Matches_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Matches_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1833,23 +1833,23 @@ export function both$ref_str_str_Matches_ref_slice_char(it: rt.Iter, dat back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1864,13 +1864,13 @@ export function both$ref_str_str_Matches_ref_slice_char(it: rt.Iter, dat * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Matches_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1881,23 +1881,23 @@ export function both$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter< back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1912,13 +1912,13 @@ export function both$ref_str_str_Matches_searches_searches_closure1(it: rt.Iter< * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RMatches_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RMatches_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1929,23 +1929,23 @@ export function both$ref_str_str_RMatches_array2_char(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -1960,13 +1960,13 @@ export function both$ref_str_str_RMatches_array2_char(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RMatches_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RMatches_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -1977,23 +1977,23 @@ export function both$ref_str_str_RMatches_char(it: rt.Iter, data: rt.Byt back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2008,13 +2008,13 @@ export function both$ref_str_str_RMatches_char(it: rt.Iter, data: rt.Byt * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RMatches_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2025,23 +2025,23 @@ export function both$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, da back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2056,13 +2056,13 @@ export function both$ref_str_str_RMatches_ref_slice_char(it: rt.Iter, da * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RMatches_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RMatches_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2073,23 +2073,23 @@ export function both$ref_str_str_RMatches_searches_searches_closure1(it: rt.Iter back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2104,13 +2104,13 @@ export function both$ref_str_str_RMatches_searches_searches_closure1(it: rt.Iter * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplitTerminator_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2121,23 +2121,23 @@ export function both$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2152,13 +2152,13 @@ export function both$ref_str_str_RSplitTerminator_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplitTerminator_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2169,23 +2169,23 @@ export function both$ref_str_str_RSplitTerminator_char(it: rt.Iter, data back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2200,13 +2200,13 @@ export function both$ref_str_str_RSplitTerminator_char(it: rt.Iter, data * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplitTerminator_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2217,23 +2217,23 @@ export function both$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2248,13 +2248,13 @@ export function both$ref_str_str_RSplitTerminator_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplitTerminator_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2265,23 +2265,23 @@ export function both$ref_str_str_RSplitTerminator_searches_searches_closure1(it: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2296,13 +2296,13 @@ export function both$ref_str_str_RSplitTerminator_searches_searches_closure1(it: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplit_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplit_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2313,23 +2313,23 @@ export function both$ref_str_str_RSplit_array2_char(it: rt.Iter, data: r back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2344,13 +2344,13 @@ export function both$ref_str_str_RSplit_array2_char(it: rt.Iter, data: r * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplit_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplit_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2361,23 +2361,23 @@ export function both$ref_str_str_RSplit_char(it: rt.Iter, data: rt.ByteS back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2392,13 +2392,13 @@ export function both$ref_str_str_RSplit_char(it: rt.Iter, data: rt.ByteS * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplit_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2409,23 +2409,23 @@ export function both$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, data back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2440,13 +2440,13 @@ export function both$ref_str_str_RSplit_ref_slice_char(it: rt.Iter, data * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_RSplit_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2457,23 +2457,23 @@ export function both$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2488,13 +2488,13 @@ export function both$ref_str_str_RSplit_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitAsciiWhitespace(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2505,23 +2505,23 @@ export function both$ref_str_str_SplitAsciiWhitespace(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2536,13 +2536,13 @@ export function both$ref_str_str_SplitAsciiWhitespace(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitInclusive_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitInclusive_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2553,23 +2553,23 @@ export function both$ref_str_str_SplitInclusive_array2_char(it: rt.Iter, back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2584,13 +2584,13 @@ export function both$ref_str_str_SplitInclusive_array2_char(it: rt.Iter, * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitInclusive_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitInclusive_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2601,23 +2601,23 @@ export function both$ref_str_str_SplitInclusive_char(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2632,13 +2632,13 @@ export function both$ref_str_str_SplitInclusive_char(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitInclusive_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2649,23 +2649,23 @@ export function both$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2680,13 +2680,13 @@ export function both$ref_str_str_SplitInclusive_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitInclusive_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2697,23 +2697,23 @@ export function both$ref_str_str_SplitInclusive_searches_searches_closure1(it: r back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2728,13 +2728,13 @@ export function both$ref_str_str_SplitInclusive_searches_searches_closure1(it: r * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitTerminator_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitTerminator_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2745,23 +2745,23 @@ export function both$ref_str_str_SplitTerminator_array2_char(it: rt.Iter back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2776,13 +2776,13 @@ export function both$ref_str_str_SplitTerminator_array2_char(it: rt.Iter * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitTerminator_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitTerminator_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2793,23 +2793,23 @@ export function both$ref_str_str_SplitTerminator_char(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2824,13 +2824,13 @@ export function both$ref_str_str_SplitTerminator_char(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitTerminator_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2841,23 +2841,23 @@ export function both$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2872,13 +2872,13 @@ export function both$ref_str_str_SplitTerminator_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitTerminator_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2889,23 +2889,23 @@ export function both$ref_str_str_SplitTerminator_searches_searches_closure1(it: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2920,13 +2920,13 @@ export function both$ref_str_str_SplitTerminator_searches_searches_closure1(it: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_SplitWhitespace(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_SplitWhitespace(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2937,23 +2937,23 @@ export function both$ref_str_str_SplitWhitespace(it: rt.Iter, data: rt.B back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -2968,13 +2968,13 @@ export function both$ref_str_str_SplitWhitespace(it: rt.Iter, data: rt.B * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Split_array2_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Split_array2_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -2985,23 +2985,23 @@ export function both$ref_str_str_Split_array2_char(it: rt.Iter, data: rt back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -3016,13 +3016,13 @@ export function both$ref_str_str_Split_array2_char(it: rt.Iter, data: rt * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Split_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Split_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3033,23 +3033,23 @@ export function both$ref_str_str_Split_char(it: rt.Iter, data: rt.ByteSl back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -3064,13 +3064,13 @@ export function both$ref_str_str_Split_char(it: rt.Iter, data: rt.ByteSl * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Split_ref_slice_char(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Split_ref_slice_char(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3081,23 +3081,23 @@ export function both$ref_str_str_Split_ref_slice_char(it: rt.Iter, data: back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -3112,13 +3112,13 @@ export function both$ref_str_str_Split_ref_slice_char(it: rt.Iter, data: * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$ref_str_str_Split_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$ref_str_str_Split_searches_searches_closure1(it: rs.Iter, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; let _15!: string | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3129,23 +3129,23 @@ export function both$ref_str_str_Split_searches_searches_closure1(it: rt.Iter = rt.iterRev(copy); + const iter: rs.Iter = rs.iterRev(copy); while (true) { - const _35: string | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: string | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_ref_str(_35, out); @@ -3160,13 +3160,13 @@ export function both$ref_str_str_Split_searches_searches_closure1(it: rt.Iter, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_char_str_CharIndices(it: rs.Iter<[rs.usize, rs.char]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, rt.char] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, rt.char]> | undefined; + let _15!: [rs.usize, rs.char] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, rs.char]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3177,23 +3177,23 @@ export function both$tuple2_usize_char_str_CharIndices(it: rt.Iter<[rt.usize, rt back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_char(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, rt.char]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, rs.char]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, rt.char] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, rs.char] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_char(_35, out); @@ -3208,13 +3208,13 @@ export function both$tuple2_usize_char_str_CharIndices(it: rt.Iter<[rt.usize, rt * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3225,23 +3225,23 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rt.It back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3256,13 +3256,13 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_array2_char(it: rt.It * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_MatchIndices_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3273,23 +3273,23 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt. back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3304,13 +3304,13 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_char(it: rt.Iter<[rt. * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3321,23 +3321,23 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rt back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3352,13 +3352,13 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(it: rt * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3369,23 +3369,23 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_clo back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3400,13 +3400,13 @@ export function both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_clo * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3417,23 +3417,23 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt.I back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3448,13 +3448,13 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(it: rt.I * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_RMatchIndices_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3465,23 +3465,23 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[rt back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3496,13 +3496,13 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_char(it: rt.Iter<[rt * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3513,23 +3513,23 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: r back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3544,13 +3544,13 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(it: r * `it` read to its end, each step from the end the high bit of `data`'s byte picks, then * how many it gave, then a clone made after the first, read from the back. */ -export function both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(it: rt.Iter<[rt.usize, string]>, data: rt.ByteSlice, out: rt.ByteVec): void { +export function both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(it: rs.Iter<[rs.usize, string]>, data: rs.ByteSlice, out: rs.ByteVec): void { let back!: boolean; - let _15!: [rt.usize, string] | undefined; - let n: rt.usize = 0; - let copy = undefined as rt.Iter<[rt.usize, string]> | undefined; + let _15!: [rs.usize, string] | undefined; + let n: rs.usize = 0; + let copy = undefined as rs.Iter<[rs.usize, string]> | undefined; while (true) { - const _7: rt.u8 | undefined = rt.byteSliceGet(data, n); + const _7: rs.u8 | undefined = rs.byteSliceGet(data, n); b1: { if (_7 !== undefined) { if ((_7 & 128) !== 0) { @@ -3561,23 +3561,23 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_cl back = false; } if (!back) { - _15 = rt.iterToOption(it.next()); + _15 = rs.iterToOption(it.next()); } else { - _15 = rt.iterToOption(it.nextBack()); + _15 = rs.iterToOption(it.nextBack()); } if (_15 !== undefined) { put$searches_Item_tuple2_usize_ref_str(_15, out); if (n === 0) { copy = it.clone(); } - n = rt.usizeAdd(n, 1); + n = rs.usizeAdd(n, 1); } else { - rt.byteVecPush(out, n & 0xff); + rs.byteVecPush(out, n & 0xff); if (copy !== undefined) { - const iter: rt.Iter<[rt.usize, string]> = rt.iterRev(copy); + const iter: rs.Iter<[rs.usize, string]> = rs.iterRev(copy); while (true) { - const _35: [rt.usize, string] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.usize, string] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } put$searches_Item_tuple2_usize_ref_str(_35, out); @@ -3588,19 +3588,19 @@ export function both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_cl } } -export function putOption(out: rt.ByteVec, s: string | undefined): void { +export function putOption(out: rs.ByteVec, s: string | undefined): void { if (s === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { harness_put(out, s); } } -export function putOffset(out: rt.ByteVec, i: rt.usize | undefined): void { +export function putOffset(out: rs.ByteVec, i: rs.usize | undefined): void { if (i === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(i as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(i as rs.u32))); } } @@ -3610,321 +3610,321 @@ export function putOffset(out: rt.ByteVec, i: rt.usize | undefined): void { * pattern of chars matches, a `&str` pattern of up to three chars from the text, empty a * quarter of the time, and `splitn`'s and `replacen`'s count. */ -export function searches(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((data.length !== 0 ? [data.data[data.start], new rt.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, [0, data] as [rt.u8, rt.ByteSlice], (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function searches(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((data.length !== 0 ? [data.data[data.start], new rs.ByteSlice(data.data, data.start + 1, data.length - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, [0, data] as [rs.u8, rs.ByteSlice], (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const pick: rt.u8 = _6[0]; + const pick: rs.u8 = _6[0]; const s: string = text(_6[1]); - const alphabet: rt.Vec = rt.iterToVec(rt.strChars(text(rt.byteSliceFrom(Uint8Array.of(rt.u8Rem(pick, 16), rt.u8Div(pick, 16))))), "next", 4); - const _25: rt.char = alphabet.items[rt.idx(alphabet.items, 0)]; - const _24: [rt.char, rt.char] = [_25, alphabet.items[rt.idx(alphabet.items, 1)]]; - const c: rt.char = _25; - const d: rt.char = _24[1]; - const n: rt.usize = rt.u8Rem(pick, 5) as rt.usize; - const m: rt.u8 = rt.u8Rem(kind, 17); - const seen: rt.RefCell> = new rt.RefCell(new rt.Vec()); - const p: (a0: rt.char) => boolean = (x2: rt.char): boolean => { - const _62: rt.RefCell> = rt.refCellBorrowMut(seen); + const alphabet: rs.Vec = rs.iterToVec(rs.strChars(text(rs.byteSliceFrom(Uint8Array.of(rs.u8Rem(pick, 16), rs.u8Div(pick, 16))))), "next", 4); + const _25: rs.char = alphabet.items[rs.idx(alphabet.items, 0)]; + const _24: [rs.char, rs.char] = [_25, alphabet.items[rs.idx(alphabet.items, 1)]]; + const c: rs.char = _25; + const d: rs.char = _24[1]; + const n: rs.usize = rs.u8Rem(pick, 5) as rs.usize; + const m: rs.u8 = rs.u8Rem(kind, 17); + const seen: rs.RefCell> = new rs.RefCell(new rs.Vec()); + const p: (a0: rs.char) => boolean = (x2: rs.char): boolean => { + const _62: rs.RefCell> = rs.refCellBorrowMut(seen); _62.value.items.push(x2); - rt.refMutRelease(_62); + rs.refMutRelease(_62); if (!(x2 === c)) { - return rt.isAsciiDigit(x2); + return rs.isAsciiDigit(x2); } return true; }; - const _42: rt.u8 = rt.u8Rem(rt.u8Div(kind, 17), 5); + const _42: rs.u8 = rs.u8Rem(rs.u8Div(kind, 17), 5); if (_42 === 0) { const _50: string = s; const part4 = _6[1]; if (m === 9) { - harness_put(out, rt.strTrimMatches(_50, String.fromCodePoint(c))); + harness_put(out, rs.strTrimMatches(_50, String.fromCodePoint(c))); } else if (m === 10) { - both$ref_str_str_Split_char(rt.strSplit(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_Split_char(rs.strSplit(_50, String.fromCodePoint(c)), part4, out); } else if (m === 11) { - both$ref_str_str_RSplit_char(rt.strRsplit(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_RSplit_char(rs.strRsplit(_50, String.fromCodePoint(c)), part4, out); } else if (m === 12) { - both$ref_str_str_SplitTerminator_char(rt.strSplitTerminator(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_SplitTerminator_char(rs.strSplitTerminator(_50, String.fromCodePoint(c)), part4, out); } else if (m === 13) { - both$ref_str_str_RSplitTerminator_char(rt.strRsplitTerminator(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_RSplitTerminator_char(rs.strRsplitTerminator(_50, String.fromCodePoint(c)), part4, out); } else if (m === 14) { - both$ref_str_str_SplitInclusive_char(rt.strSplitInclusive(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_SplitInclusive_char(rs.strSplitInclusive(_50, String.fromCodePoint(c)), part4, out); } else if (m === 15) { - both$ref_str_str_Matches_char(rt.strMatches(_50, String.fromCodePoint(c)), part4, out); - both$ref_str_str_RMatches_char(rt.strRmatches(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_Matches_char(rs.strMatches(_50, String.fromCodePoint(c)), part4, out); + both$ref_str_str_RMatches_char(rs.strRmatches(_50, String.fromCodePoint(c)), part4, out); } else if (m === 16) { - both$tuple2_usize_ref_str_str_MatchIndices_char(rt.strMatchIndices(_50, String.fromCodePoint(c)), part4, out); - both$tuple2_usize_ref_str_str_RMatchIndices_char(rt.strRmatchIndices(_50, String.fromCodePoint(c)), part4, out); + both$tuple2_usize_ref_str_str_MatchIndices_char(rs.strMatchIndices(_50, String.fromCodePoint(c)), part4, out); + both$tuple2_usize_ref_str_str_RMatchIndices_char(rs.strRmatchIndices(_50, String.fromCodePoint(c)), part4, out); } else if (m === 0) { - putOffset(out, rt.strFind(_50, String.fromCodePoint(c))); - putOffset(out, rt.strRfind(_50, String.fromCodePoint(c))); + putOffset(out, rs.strFind(_50, String.fromCodePoint(c))); + putOffset(out, rs.strRfind(_50, String.fromCodePoint(c))); } else if (m === 1) { - putOption(out, rt.strStripPrefix(_50, String.fromCodePoint(c))); - putOption(out, rt.strStripSuffix(_50, String.fromCodePoint(c))); + putOption(out, rs.strStripPrefix(_50, String.fromCodePoint(c))); + putOption(out, rs.strStripSuffix(_50, String.fromCodePoint(c))); } else if (m === 2) { - harness_put(out, rt.strReplace(_50, String.fromCodePoint(c), "<>")); - harness_put(out, rt.strReplace(_50, String.fromCodePoint(c), "é", n)); + harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "<>")); + harness_put(out, rs.strReplace(_50, String.fromCodePoint(c), "é", n)); } else if (m === 3) { - front$ref_str_str_Split_char(rt.strSplit(_50, String.fromCodePoint(c)), out); - front$ref_str_str_RSplit_char(rt.strRsplit(_50, String.fromCodePoint(c)), out); + front$ref_str_str_Split_char(rs.strSplit(_50, String.fromCodePoint(c)), out); + front$ref_str_str_RSplit_char(rs.strRsplit(_50, String.fromCodePoint(c)), out); } else if (m === 4) { - front$ref_str_str_SplitTerminator_char(rt.strSplitTerminator(_50, String.fromCodePoint(c)), out); - front$ref_str_str_RSplitTerminator_char(rt.strRsplitTerminator(_50, String.fromCodePoint(c)), out); + front$ref_str_str_SplitTerminator_char(rs.strSplitTerminator(_50, String.fromCodePoint(c)), out); + front$ref_str_str_RSplitTerminator_char(rs.strRsplitTerminator(_50, String.fromCodePoint(c)), out); } else if (m === 5) { - front$ref_str_str_SplitN_char(rt.strSplitn(_50, n, String.fromCodePoint(c)), out); - front$ref_str_str_RSplitN_char(rt.strRsplitn(_50, n, String.fromCodePoint(c)), out); + front$ref_str_str_SplitN_char(rs.strSplitn(_50, n, String.fromCodePoint(c)), out); + front$ref_str_str_RSplitN_char(rs.strRsplitn(_50, n, String.fromCodePoint(c)), out); } else if (m === 6) { - front$ref_str_str_SplitInclusive_char(rt.strSplitInclusive(_50, String.fromCodePoint(c)), out); + front$ref_str_str_SplitInclusive_char(rs.strSplitInclusive(_50, String.fromCodePoint(c)), out); } else if (m === 7) { - front$ref_str_str_Matches_char(rt.strMatches(_50, String.fromCodePoint(c)), out); - front$ref_str_str_RMatches_char(rt.strRmatches(_50, String.fromCodePoint(c)), out); + front$ref_str_str_Matches_char(rs.strMatches(_50, String.fromCodePoint(c)), out); + front$ref_str_str_RMatches_char(rs.strRmatches(_50, String.fromCodePoint(c)), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_char(rt.strMatchIndices(_50, String.fromCodePoint(c)), out); - front$tuple2_usize_ref_str_str_RMatchIndices_char(rt.strRmatchIndices(_50, String.fromCodePoint(c)), out); + front$tuple2_usize_ref_str_str_MatchIndices_char(rs.strMatchIndices(_50, String.fromCodePoint(c)), out); + front$tuple2_usize_ref_str_str_RMatchIndices_char(rs.strRmatchIndices(_50, String.fromCodePoint(c)), out); } } else if (_42 === 1) { - const needle: string = rt.stringExtendChars("", rt.iterTake(rt.iterSkip(rt.strChars(s), rt.u8Div(pick, 64) as rt.usize), rt.u8Rem(rt.u8Div(pick, 16), 4) as rt.usize)); - const _127: rt.u8 = rt.u8Rem(m, 9); + const needle: string = rs.stringExtendChars("", rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(pick, 64) as rs.usize), rs.u8Rem(rs.u8Div(pick, 16), 4) as rs.usize)); + const _127: rs.u8 = rs.u8Rem(m, 9); if (_127 === 0) { - putOffset(out, rt.strFind(s, needle)); - putOffset(out, rt.strRfind(s, needle)); + putOffset(out, rs.strFind(s, needle)); + putOffset(out, rs.strRfind(s, needle)); } else if (_127 === 1) { - putOption(out, rt.strStripPrefix(s, needle)); - putOption(out, rt.strStripSuffix(s, needle)); + putOption(out, rs.strStripPrefix(s, needle)); + putOption(out, rs.strStripSuffix(s, needle)); } else if (_127 === 2) { - harness_put(out, rt.strReplace(s, needle, "<>")); - harness_put(out, rt.strReplace(s, needle, "é", n)); + harness_put(out, rs.strReplace(s, needle, "<>")); + harness_put(out, rs.strReplace(s, needle, "é", n)); } else if (_127 === 3) { - front$ref_str_str_Split_ref_str(rt.strSplit(s, needle), out); - front$ref_str_str_RSplit_ref_str(rt.strRsplit(s, needle), out); + front$ref_str_str_Split_ref_str(rs.strSplit(s, needle), out); + front$ref_str_str_RSplit_ref_str(rs.strRsplit(s, needle), out); } else if (_127 === 4) { - front$ref_str_str_SplitTerminator_ref_str(rt.strSplitTerminator(s, needle), out); - front$ref_str_str_RSplitTerminator_ref_str(rt.strRsplitTerminator(s, needle), out); + front$ref_str_str_SplitTerminator_ref_str(rs.strSplitTerminator(s, needle), out); + front$ref_str_str_RSplitTerminator_ref_str(rs.strRsplitTerminator(s, needle), out); } else if (_127 === 5) { - front$ref_str_str_SplitN_ref_str(rt.strSplitn(s, n, needle), out); - front$ref_str_str_RSplitN_ref_str(rt.strRsplitn(s, n, needle), out); + front$ref_str_str_SplitN_ref_str(rs.strSplitn(s, n, needle), out); + front$ref_str_str_RSplitN_ref_str(rs.strRsplitn(s, n, needle), out); } else if (_127 === 6) { - front$ref_str_str_SplitInclusive_ref_str(rt.strSplitInclusive(s, needle), out); + front$ref_str_str_SplitInclusive_ref_str(rs.strSplitInclusive(s, needle), out); } else if (_127 === 7) { - front$ref_str_str_Matches_ref_str(rt.strMatches(s, needle), out); - front$ref_str_str_RMatches_ref_str(rt.strRmatches(s, needle), out); + front$ref_str_str_Matches_ref_str(rs.strMatches(s, needle), out); + front$ref_str_str_RMatches_ref_str(rs.strRmatches(s, needle), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rt.strMatchIndices(s, needle), out); - front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rt.strRmatchIndices(s, needle), out); + front$tuple2_usize_ref_str_str_MatchIndices_ref_str(rs.strMatchIndices(s, needle), out); + front$tuple2_usize_ref_str_str_RMatchIndices_ref_str(rs.strRmatchIndices(s, needle), out); } } else if (_42 === 2) { const _206: string = s; const part3 = _6[1]; if (m === 9) { - const _211: rt.char[] = [c, d]; - harness_put(out, rt.strTrimMatches(_206, rt.patternChars(rt.sliceRange(_211, 0)))); + const _211: rs.char[] = [c, d]; + harness_put(out, rs.strTrimMatches(_206, rs.patternChars(rs.sliceRange(_211, 0)))); } else if (m === 10) { - const _215: rt.char[] = [c, d]; - both$ref_str_str_Split_ref_slice_char(rt.strSplit(_206, rt.patternChars(rt.sliceRange(_215, 0))), part3, out); + const _215: rs.char[] = [c, d]; + both$ref_str_str_Split_ref_slice_char(rs.strSplit(_206, rs.patternChars(rs.sliceRange(_215, 0))), part3, out); } else if (m === 11) { - const _219: rt.char[] = [c, d]; - both$ref_str_str_RSplit_ref_slice_char(rt.strRsplit(_206, rt.patternChars(rt.sliceRange(_219, 0))), part3, out); + const _219: rs.char[] = [c, d]; + both$ref_str_str_RSplit_ref_slice_char(rs.strRsplit(_206, rs.patternChars(rs.sliceRange(_219, 0))), part3, out); } else if (m === 12) { - const _223: rt.char[] = [c, d]; - both$ref_str_str_SplitTerminator_ref_slice_char(rt.strSplitTerminator(_206, rt.patternChars(rt.sliceRange(_223, 0))), part3, out); + const _223: rs.char[] = [c, d]; + both$ref_str_str_SplitTerminator_ref_slice_char(rs.strSplitTerminator(_206, rs.patternChars(rs.sliceRange(_223, 0))), part3, out); } else if (m === 13) { - const _227: rt.char[] = [c, d]; - both$ref_str_str_RSplitTerminator_ref_slice_char(rt.strRsplitTerminator(_206, rt.patternChars(rt.sliceRange(_227, 0))), part3, out); + const _227: rs.char[] = [c, d]; + both$ref_str_str_RSplitTerminator_ref_slice_char(rs.strRsplitTerminator(_206, rs.patternChars(rs.sliceRange(_227, 0))), part3, out); } else if (m === 14) { - const _231: rt.char[] = [c, d]; - both$ref_str_str_SplitInclusive_ref_slice_char(rt.strSplitInclusive(_206, rt.patternChars(rt.sliceRange(_231, 0))), part3, out); + const _231: rs.char[] = [c, d]; + both$ref_str_str_SplitInclusive_ref_slice_char(rs.strSplitInclusive(_206, rs.patternChars(rs.sliceRange(_231, 0))), part3, out); } else if (m === 15) { - const _236: rt.char[] = [c, d]; - both$ref_str_str_Matches_ref_slice_char(rt.strMatches(_206, rt.patternChars(rt.sliceRange(_236, 0))), part3, out); - const _241: rt.char[] = [c, d]; - both$ref_str_str_RMatches_ref_slice_char(rt.strRmatches(_206, rt.patternChars(rt.sliceRange(_241, 0))), part3, out); + const _236: rs.char[] = [c, d]; + both$ref_str_str_Matches_ref_slice_char(rs.strMatches(_206, rs.patternChars(rs.sliceRange(_236, 0))), part3, out); + const _241: rs.char[] = [c, d]; + both$ref_str_str_RMatches_ref_slice_char(rs.strRmatches(_206, rs.patternChars(rs.sliceRange(_241, 0))), part3, out); } else if (m === 16) { - const _246: rt.char[] = [c, d]; - both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(rt.strMatchIndices(_206, rt.patternChars(rt.sliceRange(_246, 0))), part3, out); - const _251: rt.char[] = [c, d]; - both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rt.strRmatchIndices(_206, rt.patternChars(rt.sliceRange(_251, 0))), part3, out); + const _246: rs.char[] = [c, d]; + both$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(rs.strMatchIndices(_206, rs.patternChars(rs.sliceRange(_246, 0))), part3, out); + const _251: rs.char[] = [c, d]; + both$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rs.strRmatchIndices(_206, rs.patternChars(rs.sliceRange(_251, 0))), part3, out); } else if (m === 0) { - const _259: rt.char[] = [c, d]; - putOffset(out, rt.strFind(_206, rt.patternChars(rt.sliceRange(_259, 0)))); - const _264: rt.char[] = [c, d]; - putOffset(out, rt.strRfind(_206, rt.patternChars(rt.sliceRange(_264, 0)))); + const _259: rs.char[] = [c, d]; + putOffset(out, rs.strFind(_206, rs.patternChars(rs.sliceRange(_259, 0)))); + const _264: rs.char[] = [c, d]; + putOffset(out, rs.strRfind(_206, rs.patternChars(rs.sliceRange(_264, 0)))); } else if (m === 1) { - const _269: rt.char[] = [c, d]; - putOption(out, rt.strStripPrefix(_206, rt.patternChars(rt.sliceRange(_269, 0)))); - const _274: rt.char[] = [c, d]; - putOption(out, rt.strStripSuffix(_206, rt.patternChars(rt.sliceRange(_274, 0)))); + const _269: rs.char[] = [c, d]; + putOption(out, rs.strStripPrefix(_206, rs.patternChars(rs.sliceRange(_269, 0)))); + const _274: rs.char[] = [c, d]; + putOption(out, rs.strStripSuffix(_206, rs.patternChars(rs.sliceRange(_274, 0)))); } else if (m === 2) { - const _281: rt.char[] = [c, d]; - harness_put(out, rt.strReplace(_206, rt.patternChars(rt.sliceRange(_281, 0)), "<>")); - const _289: rt.char[] = [c, d]; - harness_put(out, rt.strReplace(_206, rt.patternChars(rt.sliceRange(_289, 0)), "é", n)); + const _281: rs.char[] = [c, d]; + harness_put(out, rs.strReplace(_206, rs.patternChars(rs.sliceRange(_281, 0)), "<>")); + const _289: rs.char[] = [c, d]; + harness_put(out, rs.strReplace(_206, rs.patternChars(rs.sliceRange(_289, 0)), "é", n)); } else if (m === 3) { - const _295: rt.char[] = [c, d]; - front$ref_str_str_Split_ref_slice_char(rt.strSplit(_206, rt.patternChars(rt.sliceRange(_295, 0))), out); - const _300: rt.char[] = [c, d]; - front$ref_str_str_RSplit_ref_slice_char(rt.strRsplit(_206, rt.patternChars(rt.sliceRange(_300, 0))), out); + const _295: rs.char[] = [c, d]; + front$ref_str_str_Split_ref_slice_char(rs.strSplit(_206, rs.patternChars(rs.sliceRange(_295, 0))), out); + const _300: rs.char[] = [c, d]; + front$ref_str_str_RSplit_ref_slice_char(rs.strRsplit(_206, rs.patternChars(rs.sliceRange(_300, 0))), out); } else if (m === 4) { - const _305: rt.char[] = [c, d]; - front$ref_str_str_SplitTerminator_ref_slice_char(rt.strSplitTerminator(_206, rt.patternChars(rt.sliceRange(_305, 0))), out); - const _310: rt.char[] = [c, d]; - front$ref_str_str_RSplitTerminator_ref_slice_char(rt.strRsplitTerminator(_206, rt.patternChars(rt.sliceRange(_310, 0))), out); + const _305: rs.char[] = [c, d]; + front$ref_str_str_SplitTerminator_ref_slice_char(rs.strSplitTerminator(_206, rs.patternChars(rs.sliceRange(_305, 0))), out); + const _310: rs.char[] = [c, d]; + front$ref_str_str_RSplitTerminator_ref_slice_char(rs.strRsplitTerminator(_206, rs.patternChars(rs.sliceRange(_310, 0))), out); } else if (m === 5) { - const _315: rt.char[] = [c, d]; - front$ref_str_str_SplitN_ref_slice_char(rt.strSplitn(_206, n, rt.patternChars(rt.sliceRange(_315, 0))), out); - const _320: rt.char[] = [c, d]; - front$ref_str_str_RSplitN_ref_slice_char(rt.strRsplitn(_206, n, rt.patternChars(rt.sliceRange(_320, 0))), out); + const _315: rs.char[] = [c, d]; + front$ref_str_str_SplitN_ref_slice_char(rs.strSplitn(_206, n, rs.patternChars(rs.sliceRange(_315, 0))), out); + const _320: rs.char[] = [c, d]; + front$ref_str_str_RSplitN_ref_slice_char(rs.strRsplitn(_206, n, rs.patternChars(rs.sliceRange(_320, 0))), out); } else if (m === 6) { - const _324: rt.char[] = [c, d]; - front$ref_str_str_SplitInclusive_ref_slice_char(rt.strSplitInclusive(_206, rt.patternChars(rt.sliceRange(_324, 0))), out); + const _324: rs.char[] = [c, d]; + front$ref_str_str_SplitInclusive_ref_slice_char(rs.strSplitInclusive(_206, rs.patternChars(rs.sliceRange(_324, 0))), out); } else if (m === 7) { - const _329: rt.char[] = [c, d]; - front$ref_str_str_Matches_ref_slice_char(rt.strMatches(_206, rt.patternChars(rt.sliceRange(_329, 0))), out); - const _334: rt.char[] = [c, d]; - front$ref_str_str_RMatches_ref_slice_char(rt.strRmatches(_206, rt.patternChars(rt.sliceRange(_334, 0))), out); + const _329: rs.char[] = [c, d]; + front$ref_str_str_Matches_ref_slice_char(rs.strMatches(_206, rs.patternChars(rs.sliceRange(_329, 0))), out); + const _334: rs.char[] = [c, d]; + front$ref_str_str_RMatches_ref_slice_char(rs.strRmatches(_206, rs.patternChars(rs.sliceRange(_334, 0))), out); } else { - const _339: rt.char[] = [c, d]; - front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(rt.strMatchIndices(_206, rt.patternChars(rt.sliceRange(_339, 0))), out); - const _344: rt.char[] = [c, d]; - front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rt.strRmatchIndices(_206, rt.patternChars(rt.sliceRange(_344, 0))), out); + const _339: rs.char[] = [c, d]; + front$tuple2_usize_ref_str_str_MatchIndices_ref_slice_char(rs.strMatchIndices(_206, rs.patternChars(rs.sliceRange(_339, 0))), out); + const _344: rs.char[] = [c, d]; + front$tuple2_usize_ref_str_str_RMatchIndices_ref_slice_char(rs.strRmatchIndices(_206, rs.patternChars(rs.sliceRange(_344, 0))), out); } } else if (_42 === 3) { const _349: string = s; const part2 = _6[1]; if (m === 9) { - harness_put(out, rt.strTrimMatches(_349, rt.patternChars([c, d]))); + harness_put(out, rs.strTrimMatches(_349, rs.patternChars([c, d]))); } else if (m === 10) { - both$ref_str_str_Split_array2_char(rt.strSplit(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_Split_array2_char(rs.strSplit(_349, rs.patternChars([c, d])), part2, out); } else if (m === 11) { - both$ref_str_str_RSplit_array2_char(rt.strRsplit(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_RSplit_array2_char(rs.strRsplit(_349, rs.patternChars([c, d])), part2, out); } else if (m === 12) { - both$ref_str_str_SplitTerminator_array2_char(rt.strSplitTerminator(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_SplitTerminator_array2_char(rs.strSplitTerminator(_349, rs.patternChars([c, d])), part2, out); } else if (m === 13) { - both$ref_str_str_RSplitTerminator_array2_char(rt.strRsplitTerminator(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_RSplitTerminator_array2_char(rs.strRsplitTerminator(_349, rs.patternChars([c, d])), part2, out); } else if (m === 14) { - both$ref_str_str_SplitInclusive_array2_char(rt.strSplitInclusive(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_SplitInclusive_array2_char(rs.strSplitInclusive(_349, rs.patternChars([c, d])), part2, out); } else if (m === 15) { - both$ref_str_str_Matches_array2_char(rt.strMatches(_349, rt.patternChars([c, d])), part2, out); - both$ref_str_str_RMatches_array2_char(rt.strRmatches(_349, rt.patternChars([c, d])), part2, out); + both$ref_str_str_Matches_array2_char(rs.strMatches(_349, rs.patternChars([c, d])), part2, out); + both$ref_str_str_RMatches_array2_char(rs.strRmatches(_349, rs.patternChars([c, d])), part2, out); } else if (m === 16) { - both$tuple2_usize_ref_str_str_MatchIndices_array2_char(rt.strMatchIndices(_349, rt.patternChars([c, d])), part2, out); - both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rt.strRmatchIndices(_349, rt.patternChars([c, d])), part2, out); + both$tuple2_usize_ref_str_str_MatchIndices_array2_char(rs.strMatchIndices(_349, rs.patternChars([c, d])), part2, out); + both$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rs.strRmatchIndices(_349, rs.patternChars([c, d])), part2, out); } else if (m === 0) { - putOffset(out, rt.strFind(_349, rt.patternChars([c, d]))); - putOffset(out, rt.strRfind(_349, rt.patternChars([c, d]))); + putOffset(out, rs.strFind(_349, rs.patternChars([c, d]))); + putOffset(out, rs.strRfind(_349, rs.patternChars([c, d]))); } else if (m === 1) { - putOption(out, rt.strStripPrefix(_349, rt.patternChars([c, d]))); - putOption(out, rt.strStripSuffix(_349, rt.patternChars([c, d]))); + putOption(out, rs.strStripPrefix(_349, rs.patternChars([c, d]))); + putOption(out, rs.strStripSuffix(_349, rs.patternChars([c, d]))); } else if (m === 2) { - harness_put(out, rt.strReplace(_349, rt.patternChars([c, d]), "<>")); - harness_put(out, rt.strReplace(_349, rt.patternChars([c, d]), "é", n)); + harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "<>")); + harness_put(out, rs.strReplace(_349, rs.patternChars([c, d]), "é", n)); } else if (m === 3) { - front$ref_str_str_Split_array2_char(rt.strSplit(_349, rt.patternChars([c, d])), out); - front$ref_str_str_RSplit_array2_char(rt.strRsplit(_349, rt.patternChars([c, d])), out); + front$ref_str_str_Split_array2_char(rs.strSplit(_349, rs.patternChars([c, d])), out); + front$ref_str_str_RSplit_array2_char(rs.strRsplit(_349, rs.patternChars([c, d])), out); } else if (m === 4) { - front$ref_str_str_SplitTerminator_array2_char(rt.strSplitTerminator(_349, rt.patternChars([c, d])), out); - front$ref_str_str_RSplitTerminator_array2_char(rt.strRsplitTerminator(_349, rt.patternChars([c, d])), out); + front$ref_str_str_SplitTerminator_array2_char(rs.strSplitTerminator(_349, rs.patternChars([c, d])), out); + front$ref_str_str_RSplitTerminator_array2_char(rs.strRsplitTerminator(_349, rs.patternChars([c, d])), out); } else if (m === 5) { - front$ref_str_str_SplitN_array2_char(rt.strSplitn(_349, n, rt.patternChars([c, d])), out); - front$ref_str_str_RSplitN_array2_char(rt.strRsplitn(_349, n, rt.patternChars([c, d])), out); + front$ref_str_str_SplitN_array2_char(rs.strSplitn(_349, n, rs.patternChars([c, d])), out); + front$ref_str_str_RSplitN_array2_char(rs.strRsplitn(_349, n, rs.patternChars([c, d])), out); } else if (m === 6) { - front$ref_str_str_SplitInclusive_array2_char(rt.strSplitInclusive(_349, rt.patternChars([c, d])), out); + front$ref_str_str_SplitInclusive_array2_char(rs.strSplitInclusive(_349, rs.patternChars([c, d])), out); } else if (m === 7) { - front$ref_str_str_Matches_array2_char(rt.strMatches(_349, rt.patternChars([c, d])), out); - front$ref_str_str_RMatches_array2_char(rt.strRmatches(_349, rt.patternChars([c, d])), out); + front$ref_str_str_Matches_array2_char(rs.strMatches(_349, rs.patternChars([c, d])), out); + front$ref_str_str_RMatches_array2_char(rs.strRmatches(_349, rs.patternChars([c, d])), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_array2_char(rt.strMatchIndices(_349, rt.patternChars([c, d])), out); - front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rt.strRmatchIndices(_349, rt.patternChars([c, d])), out); + front$tuple2_usize_ref_str_str_MatchIndices_array2_char(rs.strMatchIndices(_349, rs.patternChars([c, d])), out); + front$tuple2_usize_ref_str_str_RMatchIndices_array2_char(rs.strRmatchIndices(_349, rs.patternChars([c, d])), out); } } else { const _438: string = s; const part = _6[1]; if (m === 9) { - harness_put(out, rt.strTrimMatches(_438, p)); + harness_put(out, rs.strTrimMatches(_438, p)); } else if (m === 10) { - both$ref_str_str_Split_searches_searches_closure1(rt.strSplit(_438, p), part, out); + both$ref_str_str_Split_searches_searches_closure1(rs.strSplit(_438, p), part, out); } else if (m === 11) { - both$ref_str_str_RSplit_searches_searches_closure1(rt.strRsplit(_438, p), part, out); + both$ref_str_str_RSplit_searches_searches_closure1(rs.strRsplit(_438, p), part, out); } else if (m === 12) { - both$ref_str_str_SplitTerminator_searches_searches_closure1(rt.strSplitTerminator(_438, p), part, out); + both$ref_str_str_SplitTerminator_searches_searches_closure1(rs.strSplitTerminator(_438, p), part, out); } else if (m === 13) { - both$ref_str_str_RSplitTerminator_searches_searches_closure1(rt.strRsplitTerminator(_438, p), part, out); + both$ref_str_str_RSplitTerminator_searches_searches_closure1(rs.strRsplitTerminator(_438, p), part, out); } else if (m === 14) { - both$ref_str_str_SplitInclusive_searches_searches_closure1(rt.strSplitInclusive(_438, p), part, out); + both$ref_str_str_SplitInclusive_searches_searches_closure1(rs.strSplitInclusive(_438, p), part, out); } else if (m === 15) { - both$ref_str_str_Matches_searches_searches_closure1(rt.strMatches(_438, p), part, out); - both$ref_str_str_RMatches_searches_searches_closure1(rt.strRmatches(_438, p), part, out); + both$ref_str_str_Matches_searches_searches_closure1(rs.strMatches(_438, p), part, out); + both$ref_str_str_RMatches_searches_searches_closure1(rs.strRmatches(_438, p), part, out); } else if (m === 16) { - both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(rt.strMatchIndices(_438, p), part, out); - both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(rt.strRmatchIndices(_438, p), part, out); + both$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(rs.strMatchIndices(_438, p), part, out); + both$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(rs.strRmatchIndices(_438, p), part, out); } else if (m === 0) { - putOffset(out, rt.strFind(_438, p)); - putOffset(out, rt.strRfind(_438, p)); + putOffset(out, rs.strFind(_438, p)); + putOffset(out, rs.strRfind(_438, p)); } else if (m === 1) { - putOption(out, rt.strStripPrefix(_438, p)); - putOption(out, rt.strStripSuffix(_438, p)); + putOption(out, rs.strStripPrefix(_438, p)); + putOption(out, rs.strStripSuffix(_438, p)); } else if (m === 2) { - harness_put(out, rt.strReplace(_438, p, "<>")); - harness_put(out, rt.strReplace(_438, p, "é", n)); + harness_put(out, rs.strReplace(_438, p, "<>")); + harness_put(out, rs.strReplace(_438, p, "é", n)); } else if (m === 3) { - front$ref_str_str_Split_searches_searches_closure1(rt.strSplit(_438, p), out); - front$ref_str_str_RSplit_searches_searches_closure1(rt.strRsplit(_438, p), out); + front$ref_str_str_Split_searches_searches_closure1(rs.strSplit(_438, p), out); + front$ref_str_str_RSplit_searches_searches_closure1(rs.strRsplit(_438, p), out); } else if (m === 4) { - front$ref_str_str_SplitTerminator_searches_searches_closure1(rt.strSplitTerminator(_438, p), out); - front$ref_str_str_RSplitTerminator_searches_searches_closure1(rt.strRsplitTerminator(_438, p), out); + front$ref_str_str_SplitTerminator_searches_searches_closure1(rs.strSplitTerminator(_438, p), out); + front$ref_str_str_RSplitTerminator_searches_searches_closure1(rs.strRsplitTerminator(_438, p), out); } else if (m === 5) { - front$ref_str_str_SplitN_searches_searches_closure1(rt.strSplitn(_438, n, p), out); - front$ref_str_str_RSplitN_searches_searches_closure1(rt.strRsplitn(_438, n, p), out); + front$ref_str_str_SplitN_searches_searches_closure1(rs.strSplitn(_438, n, p), out); + front$ref_str_str_RSplitN_searches_searches_closure1(rs.strRsplitn(_438, n, p), out); } else if (m === 6) { - front$ref_str_str_SplitInclusive_searches_searches_closure1(rt.strSplitInclusive(_438, p), out); + front$ref_str_str_SplitInclusive_searches_searches_closure1(rs.strSplitInclusive(_438, p), out); } else if (m === 7) { - front$ref_str_str_Matches_searches_searches_closure1(rt.strMatches(_438, p), out); - front$ref_str_str_RMatches_searches_searches_closure1(rt.strRmatches(_438, p), out); + front$ref_str_str_Matches_searches_searches_closure1(rs.strMatches(_438, p), out); + front$ref_str_str_RMatches_searches_searches_closure1(rs.strRmatches(_438, p), out); } else { - front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(rt.strMatchIndices(_438, p), out); - front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(rt.strRmatchIndices(_438, p), out); + front$tuple2_usize_ref_str_str_MatchIndices_searches_searches_closure1(rs.strMatchIndices(_438, p), out); + front$tuple2_usize_ref_str_str_RMatchIndices_searches_searches_closure1(rs.strRmatchIndices(_438, p), out); } } - const _501: rt.RefCell> = rt.refCellBorrow(seen); - const iter: rt.Iter = rt.iterSlice(_501.value.items); + const _501: rs.RefCell> = rs.refCellBorrow(seen); + const iter: rs.Iter = rs.iterSlice(_501.value.items); while (true) { - const _504: rt.char | rt.Done = iter.next(); - if (_504 === rt.DONE) { + const _504: rs.char | rs.Done = iter.next(); + if (_504 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_504 as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_504 as rs.u32))); } - rt.refRelease(_501); + rs.refRelease(_501); } /** * `str`'s text iterators and trims, `kind % 5` picking which, of text of `SPACES` by the * low bits of each byte, read from the end each byte's high bit picks. */ -export function texts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.char => { - const _52: rt.usize = rt.u8Rem(_2, 16) as rt.usize; +export function texts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _52: rs.usize = rs.u8Rem(_2, 16) as rs.usize; if (!(_52 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _52); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _52); } return [10, 13, 97, 32, 9, 11, 133, 160, 5760, 8202, 8203, 8232, 12288, 65279, 233, 128512][_52]; })); - const _7: rt.u8 = rt.u8Rem(kind, 5); + const _7: rs.u8 = rs.u8Rem(kind, 5); if (_7 === 0) { - both$tuple2_usize_char_str_CharIndices(rt.strCharIndices(s), data, out); + both$tuple2_usize_char_str_CharIndices(rs.strCharIndices(s), data, out); } else if (_7 === 1) { - both$ref_str_str_Lines(rt.strLines(s), data, out); + both$ref_str_str_Lines(rs.strLines(s), data, out); } else if (_7 === 2) { - both$ref_str_str_SplitWhitespace(rt.strSplitWhitespace(s), data, out); + both$ref_str_str_SplitWhitespace(rs.strSplitWhitespace(s), data, out); } else if (_7 === 3) { - both$ref_str_str_SplitAsciiWhitespace(rt.strSplitAsciiWhitespace(s), data, out); + both$ref_str_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(s), data, out); } else { - harness_put(out, rt.strTrimMatches(s, rt.charIsWhitespace)); - harness_put(out, rt.strTrimStartMatches(s, rt.charIsWhitespace)); - harness_put(out, rt.strTrimEndMatches(s, rt.charIsWhitespace)); - for (const _40 of rt.iterToVec(rt.iterMap(rt.strChars(s), (a0: rt.char): boolean => { - return rt.charIsWhitespace(a0); + harness_put(out, rs.strTrimMatches(s, rs.charIsWhitespace)); + harness_put(out, rs.strTrimStartMatches(s, rs.charIsWhitespace)); + harness_put(out, rs.strTrimEndMatches(s, rs.charIsWhitespace)); + for (const _40 of rs.iterToVec(rs.iterMap(rs.strChars(s), (a0: rs.char): boolean => { + return rs.charIsWhitespace(a0); }), "next", 1).items) { - rt.byteVecPush(out, _40 ? 1 : 0); + rs.byteVecPush(out, _40 ? 1 : 0); } } } diff --git a/ts/fixtures/lang/separated/expected/core/option.ts b/ts/fixtures/lang/separated/expected/core/option.ts index 803d48279..dd2cfd16a 100644 --- a/ts/fixtures/lang/separated/expected/core/option.ts +++ b/ts/fixtures/lang/separated/expected/core/option.ts @@ -1,80 +1,80 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { sum, sumWords, sumPairs, sumTexts, sumTwos } from "../separated.ts"; import type * as Pair from "../separated.Pair.ts"; -export function map$1r7pvtd(self: string[] | undefined, _: (a0: string[]) => rt.u8): rt.u8 | undefined { +export function map$14ugp8v(self: string[] | undefined, _: (a0: string[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return sumTexts(self); } -export function map$14orwce(self: Uint8Array[] | undefined, _: (a0: Uint8Array[]) => rt.u8): rt.u8 | undefined { +export function map$0qvqmiu(self: Uint8Array[] | undefined, _: (a0: Uint8Array[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return sumTwos(self); } -export function map$02o7iu2(self: Pair.Pair[] | undefined, _: (a0: Pair.Pair[]) => rt.u8): rt.u8 | undefined { +export function map$0wpmcoh(self: Pair.Pair[] | undefined, _: (a0: Pair.Pair[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return sumPairs(self); } -export function map$0vryjg8(self: rt.u16[] | undefined, _: (a0: rt.u16[]) => rt.u8): rt.u8 | undefined { +export function map$0un8siq(self: rs.u16[] | undefined, _: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return sumWords(self); } -export function map$1uuzv15(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { +export function map$0x0c7ki(self: rs.ByteSlice | undefined, _: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return sum(self); } -export function mapOr$0j8cgo8(self: string[] | undefined, default_: rt.u8, _: (a0: string[]) => rt.u8): rt.u8 { +export function mapOr$115x2cs(self: string[] | undefined, default_: rs.u8, _: (a0: string[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return sumTexts(self); } -export function mapOr$0wkl4zm(self: Uint8Array[] | undefined, default_: rt.u8, _: (a0: Uint8Array[]) => rt.u8): rt.u8 { +export function mapOr$0fbdkgt(self: Uint8Array[] | undefined, default_: rs.u8, _: (a0: Uint8Array[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return sumTwos(self); } -export function mapOr$15c63lv(self: Pair.Pair[] | undefined, default_: rt.u8, _: (a0: Pair.Pair[]) => rt.u8): rt.u8 { +export function mapOr$119f2zg(self: Pair.Pair[] | undefined, default_: rs.u8, _: (a0: Pair.Pair[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return sumPairs(self); } -export function mapOr$1qu2moz(self: rt.u16[] | undefined, default_: rt.u8, _: (a0: rt.u16[]) => rt.u8): rt.u8 { +export function mapOr$0dwb29p(self: rs.u16[] | undefined, default_: rs.u8, _: (a0: rs.u16[]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return sumWords(self); } -export function mapOr$18m1ie6(self: rt.ByteSlice | undefined, default_: rt.u8, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 { +export function mapOr$0ckb6jj(self: rs.ByteSlice | undefined, default_: rs.u8, _: (a0: rs.ByteSlice) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return sum(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/separated/expected/harness.ts b/ts/fixtures/lang/separated/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/separated/expected/harness.ts +++ b/ts/fixtures/lang/separated/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/separated/expected/lib.ts b/ts/fixtures/lang/separated/expected/lib.ts index d0dd9ba4c..c57ab367d 100644 --- a/ts/fixtures/lang/separated/expected/lib.ts +++ b/ts/fixtures/lang/separated/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { separated } from "./separated.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["separated::separated", separated as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["separated::separated", separated as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/separated/expected/separated.Below.ts b/ts/fixtures/lang/separated/expected/separated.Below.ts index f976bf337..9fc1d0d2a 100644 --- a/ts/fixtures/lang/separated/expected/separated.Below.ts +++ b/ts/fixtures/lang/separated/expected/separated.Below.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A separator test that logs its tag as it drops. */ export class Below { - tag: rt.u8; - bound: rt.u16; - log: rt.RefCell; + tag: rs.u8; + bound: rs.u16; + log: rs.RefCell; - constructor(tag: rt.u8, bound: rt.u16, log: rt.RefCell) { + constructor(tag: rs.u8, bound: rs.u16, log: rs.RefCell) { this.tag = tag; this.bound = bound; this.log = log; @@ -19,17 +19,17 @@ export class Below { } } -export function test(self: Below, b: rt.u8): boolean { - const _6: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_6.value, b); - rt.refMutRelease(_6); - return (b as rt.u16) < self.bound; +export function test(self: Below, b: rs.u8): boolean { + const _6: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_6.value, b); + rs.refMutRelease(_6); + return (b as rs.u16) < self.bound; } export function drop$ops_Drop(self: Below): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, self.tag); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, self.tag); + rs.refMutRelease(_5); } //# sourceMappingURL=separated.Below.ts.map diff --git a/ts/fixtures/lang/separated/expected/separated.Pair.ts b/ts/fixtures/lang/separated/expected/separated.Pair.ts index 84dc85c05..13c04f80e 100644 --- a/ts/fixtures/lang/separated/expected/separated.Pair.ts +++ b/ts/fixtures/lang/separated/expected/separated.Pair.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function partialCmp$cmp_PartialOrd(self: Pair, other: Pair): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Pair, other: Pair): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Pair, other: Pair): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.a, other.a); +export function cmp$cmp_Ord(self: Pair, other: Pair): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.a, other.a); if (cmp === 0) { - return rt.cmp(self.b, other.b); + return rs.cmp(self.b, other.b); } return cmp; } /** An element kept as an object, which a mutable part writes whole and by field. */ export interface Pair { - a: rt.u8; - b: rt.u16; + a: rs.u8; + b: rs.u16; } //# sourceMappingURL=separated.Pair.ts.map diff --git a/ts/fixtures/lang/separated/expected/separated.ts b/ts/fixtures/lang/separated/expected/separated.ts index b959fb2eb..cb5fa7c3a 100644 --- a/ts/fixtures/lang/separated/expected/separated.ts +++ b/ts/fixtures/lang/separated/expected/separated.ts @@ -1,117 +1,117 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { map$1r7pvtd as option_map$1r7pvtd, map$14orwce as option_map$14orwce, map$02o7iu2 as option_map$02o7iu2, map$0vryjg8 as option_map$0vryjg8, map$1uuzv15 as option_map$1uuzv15, mapOr$0j8cgo8 as option_mapOr$0j8cgo8, mapOr$0wkl4zm as option_mapOr$0wkl4zm, mapOr$15c63lv as option_mapOr$15c63lv, mapOr$1qu2moz as option_mapOr$1qu2moz, mapOr$18m1ie6 as option_mapOr$18m1ie6, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { map$14ugp8v as option_map$14ugp8v, map$0qvqmiu as option_map$0qvqmiu, map$0wpmcoh as option_map$0wpmcoh, map$0un8siq as option_map$0un8siq, map$0x0c7ki as option_map$0x0c7ki, mapOr$115x2cs as option_mapOr$115x2cs, mapOr$0fbdkgt as option_mapOr$0fbdkgt, mapOr$119f2zg as option_mapOr$119f2zg, mapOr$0dwb29p as option_mapOr$0dwb29p, mapOr$0ckb6jj as option_mapOr$0ckb6jj, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import * as Below from "./separated.Below.ts"; import * as Pair from "./separated.Pair.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } -export function hint(_1: [rt.usize, rt.usize | undefined], out: rt.ByteVec): void { - const lower: rt.usize = _1[0]; - const upper: rt.usize | undefined = _1[1]; - rt.byteVecPush(out, lower & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(upper, 254, (u: rt.usize): rt.u8 => { +export function hint(_1: [rs.usize, rs.usize | undefined], out: rs.ByteVec): void { + const lower: rs.usize = _1[0]; + const upper: rs.usize | undefined = _1[1]; + rs.byteVecPush(out, lower & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(upper, 254, (u: rs.usize): rs.u8 => { return u & 0xff; })); } /** A sum of a part, which tells parts of different lengths or contents apart. */ -export function sum(part: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(part)), part.length & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), _32); +export function sum(part: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(part)), part.length & 0xff, (acc: rs.u8, _32: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), _32); }); } -export function sumWords(part: rt.u16[]): rt.u8 { - return rt.iterFold(rt.iterSlice(part), part.length & 0xff, (acc: rt.u8, _32: rt.u16): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ ((_32 >> 3) & 0xff); +export function sumWords(part: rs.u16[]): rs.u8 { + return rs.iterFold(rs.iterSlice(part), part.length & 0xff, (acc: rs.u8, _32: rs.u16): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ ((_32 >> 3) & 0xff); }); } -export function sumPairs(part: Pair.Pair[]): rt.u8 { - return rt.iterFold(rt.iterSlice(part), part.length & 0xff, (acc: rt.u8, p: Pair.Pair): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ p.a ^ ((p.b >> 4) & 0xff); +export function sumPairs(part: Pair.Pair[]): rs.u8 { + return rs.iterFold(rs.iterSlice(part), part.length & 0xff, (acc: rs.u8, p: Pair.Pair): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ p.a ^ ((p.b >> 4) & 0xff); }); } -export function sumTexts(part: string[]): rt.u8 { - return rt.iterFold(rt.iterSlice(part), part.length & 0xff, (acc: rt.u8, s: string): rt.u8 => { - return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), rt.stringLen(s) & 0xff); +export function sumTexts(part: string[]): rs.u8 { + return rs.iterFold(rs.iterSlice(part), part.length & 0xff, (acc: rs.u8, s: string): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), rs.stringLen(s) & 0xff); }); } -export function sumTwos(part: Uint8Array[]): rt.u8 { - return rt.iterFold(rt.iterLend(rt.iterSlice(part), rt.byteSliceFrom), part.length & 0xff, (acc: rt.u8, t: rt.ByteSlice): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ rt.u8WrappingAdd(t.data[t.start], t.data[t.start + 1]); +export function sumTwos(part: Uint8Array[]): rs.u8 { + return rs.iterFold(rs.iterLend(rs.iterSlice(part), rs.byteSliceFrom), part.length & 0xff, (acc: rs.u8, t: rs.ByteSlice): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ rs.u8WrappingAdd(t.data[t.start], t.data[t.start + 1]); }); } -export function scribble(i: rt.usize, part: rt.ByteSlice): void { - const _3: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(part)); +export function scribble(i: rs.usize, part: rs.ByteSlice): void { + const _3: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(part)); if (_3 !== undefined) { - _3.v = rt.u8WrappingAdd(_3.v, rt.u8Add(i & 0xff, 1)); + _3.v = rs.u8WrappingAdd(_3.v, rs.u8Add(i & 0xff, 1)); } - rt.byteSliceView(part).reverse(); - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceSplit(part, (_2: rt.u8): boolean => { - return rt.u8Rem(_2, 3) === 0; + rs.byteSliceView(part).reverse(); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceSplit(part, (_2: rs.u8): boolean => { + return rs.u8Rem(_2, 3) === 0; })); while (true) { - const _16: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_16 === rt.DONE) { + const _16: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_16 === rs.DONE) { break; } - const j: rt.usize = _16[0]; - const _21: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_16[1])); + const j: rs.usize = _16[0]; + const _21: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_16[1])); if (_21 !== undefined) { - _21.v = _21.v ^ rt.u8Add(j & 0xff, 1); + _21.v = _21.v ^ rs.u8Add(j & 0xff, 1); } } } -export function scribbleWords(i: rt.usize, part: rt.u16[]): void { - const _3: rt.Place | undefined = rt.sliceFirstMut(part); +export function scribbleWords(i: rs.usize, part: rs.u16[]): void { + const _3: rs.Place | undefined = rs.sliceFirstMut(part); if (_3 !== undefined) { - _3.v = rt.u16WrappingAdd(_3.v, rt.u16Add(rt.u16Mul(i & 0xffff, 3), 1)); + _3.v = rs.u16WrappingAdd(_3.v, rs.u16Add(rs.u16Mul(i & 0xffff, 3), 1)); } part.reverse(); - const iter: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceSplitInclusiveMut(part, (_2: rt.u16): boolean => { - return rt.u16Rem(_2, 3) === 0; + const iter: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceSplitInclusiveMut(part, (_2: rs.u16): boolean => { + return rs.u16Rem(_2, 3) === 0; })); while (true) { - const _18: [rt.usize, rt.u16[]] | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: [rs.usize, rs.u16[]] | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } _18[1].fill((_18[0] & 0xffff) | 256); } } -export function scribblePairs(i: rt.usize, part: Pair.Pair[]): void { - const _3: Pair.Pair | undefined = rt.sliceFirst(part); +export function scribblePairs(i: rs.usize, part: Pair.Pair[]): void { + const _3: Pair.Pair | undefined = rs.sliceFirst(part); if (_3 !== undefined) { - _3.a = rt.u8WrappingAdd(_3.a, rt.u8Add(i & 0xff, 1)); + _3.a = rs.u8WrappingAdd(_3.a, rs.u8Add(i & 0xff, 1)); } - const _11: Pair.Pair | undefined = rt.sliceLast(part); + const _11: Pair.Pair | undefined = rs.sliceLast(part); if (_11 !== undefined) { Object.assign(_11, { a: _11.b & 0xff, b: i & 0xffff }); } - rt.sliceSort(part, rt.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); - const iter: rt.Iter = rt.sliceRsplitMut(part, (p: Pair.Pair): boolean => { - return rt.u8Rem(p.a, 2) === 0; + rs.sliceSort(part, rs.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); + const iter: rs.Iter = rs.sliceRsplitMut(part, (p: Pair.Pair): boolean => { + return rs.u8Rem(p.a, 2) === 0; }); while (true) { - const _22: Pair.Pair[] | rt.Done = iter.next(); - if (_22 === rt.DONE) { + const _22: Pair.Pair[] | rs.Done = iter.next(); + if (_22 === rs.DONE) { break; } - const _26: Pair.Pair | undefined = rt.sliceFirst(_22); + const _26: Pair.Pair | undefined = rs.sliceFirst(_22); if (_26 !== undefined) { _26.b = _26.b ^ 85; } @@ -123,1227 +123,1227 @@ export function scribblePairs(i: rt.usize, part: Pair.Pair[]): void { * predicate that logs each call, with each bound that makes no, some, or every element a * separator. */ -export function separated(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _52!: rt.ByteSlice | undefined; - let _83!: rt.i32; - let p2!: rt.ByteSlice | undefined; - let _151!: rt.u16[] | undefined; - let _184!: rt.i32; - let p4!: rt.u16[] | undefined; +export function separated(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _52!: rs.ByteSlice | undefined; + let _83!: rs.i32; + let p2!: rs.ByteSlice | undefined; + let _151!: rs.u16[] | undefined; + let _184!: rs.i32; + let p4!: rs.u16[] | undefined; let _262!: string[] | undefined; - let _295!: rt.i32; + let _295!: rs.i32; let p6!: string[] | undefined; - let _360!: rt.i32; - let _425!: rt.ByteSlice | undefined; - let _456!: rt.i32; - let p8!: rt.ByteSlice | undefined; + let _360!: rs.i32; + let _425!: rs.ByteSlice | undefined; + let _456!: rs.i32; + let p8!: rs.ByteSlice | undefined; let _524!: Pair.Pair[] | undefined; - let _557!: rt.i32; + let _557!: rs.i32; let p10!: Pair.Pair[] | undefined; let _635!: string[] | undefined; - let _668!: rt.i32; + let _668!: rs.i32; let p12!: string[] | undefined; let _751!: Uint8Array[] | undefined; - let _784!: rt.i32; + let _784!: rs.i32; let p14!: Uint8Array[] | undefined; let _862!: Uint8Array[] | undefined; - let _895!: rt.i32; + let _895!: rs.i32; let p16!: Uint8Array[] | undefined; - let _971!: rt.ByteSlice | undefined; - let _1002!: rt.i32; - let p18!: rt.ByteSlice | undefined; - let _1070!: rt.u16[] | undefined; - let _1103!: rt.i32; - let p20!: rt.u16[] | undefined; + let _971!: rs.ByteSlice | undefined; + let _1002!: rs.i32; + let p18!: rs.ByteSlice | undefined; + let _1070!: rs.u16[] | undefined; + let _1103!: rs.i32; + let p20!: rs.u16[] | undefined; let _1181!: Pair.Pair[] | undefined; - let _1214!: rt.i32; + let _1214!: rs.i32; let p22!: Pair.Pair[] | undefined; - let _1284!: rt.usize; - let _1322!: rt.usize; - let _1361!: rt.usize; - let _1404!: rt.usize; - let _1447!: rt.usize; - let _1636!: rt.usize; - let p23!: rt.ByteSlice | undefined; - let _1665!: rt.usize; - let p25!: rt.u16[] | undefined; - let _1694!: rt.usize; + let _1284!: rs.usize; + let _1322!: rs.usize; + let _1361!: rs.usize; + let _1404!: rs.usize; + let _1447!: rs.usize; + let _1636!: rs.usize; + let p23!: rs.ByteSlice | undefined; + let _1665!: rs.usize; + let p25!: rs.u16[] | undefined; + let _1694!: rs.usize; let p27!: Pair.Pair[] | undefined; - let _1870!: rt.usize; - let p29!: rt.ByteSlice | undefined; - let _1899!: rt.usize; - let p31!: rt.u16[] | undefined; - let _1928!: rt.usize; + let _1870!: rs.usize; + let p29!: rs.ByteSlice | undefined; + let _1899!: rs.usize; + let p31!: rs.u16[] | undefined; + let _1928!: rs.usize; let p33!: Pair.Pair[] | undefined; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const steps: rt.u8 = kind >> 3; - const iter: rt.Iter = rt.iterSlice([0, 1, 128, 256]); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const steps: rs.u8 = kind >> 3; + const iter: rs.Iter = rs.iterSlice([0, 1, 128, 256]); while (true) { - const _13: rt.u16 | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.u16 | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const bound: rt.u16 = _13; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const bound: rs.u16 = _13; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): Pair.Pair => { - const b2: rt.u8 = _24; - return { a: b2, b: rt.u16Mul(b2 as rt.u16, 3) }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): Pair.Pair => { + const b2: rs.u8 = _24; + return { a: b2, b: rs.u16Mul(b2 as rs.u16, 3) }; }), undefined, 4, true); - const texts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): string => { - const _7: rt.usize = rt.usizeRem(_27 as rt.usize, 3); + const texts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): string => { + const _7: rs.usize = rs.usizeRem(_27 as rs.usize, 3); if (!(_7 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _7); } return ["", "a", "ab"][_7]; }), undefined, 12, true); - const test: (a0: rt.u8) => boolean = (_28: rt.u8): boolean => { - const b4: rt.u8 = _28; - const _73: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_73.value, b4); - rt.refMutRelease(_73); - return (b4 as rt.u16) < bound; + const test: (a0: rs.u8) => boolean = (_28: rs.u8): boolean => { + const b4: rs.u8 = _28; + const _73: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_73.value, b4); + rs.refMutRelease(_73); + return (b4 as rs.u16) < bound; }; - const testWords: (a0: rt.u16) => boolean = (_29: rt.u16): boolean => { - const w: rt.u16 = _29; - const _75: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_75.value, (w & 0xff) ^ 90); - rt.refMutRelease(_75); + const testWords: (a0: rs.u16) => boolean = (_29: rs.u16): boolean => { + const w: rs.u16 = _29; + const _75: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_75.value, (w & 0xff) ^ 90); + rs.refMutRelease(_75); return (w >> 8) < bound; }; const testPairs: (a0: Pair.Pair) => boolean = (p35: Pair.Pair): boolean => { - const _63: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_63.value, p35.a ^ 51); - rt.refMutRelease(_63); - return (p35.a as rt.u16) < bound; + const _63: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_63.value, p35.a ^ 51); + rs.refMutRelease(_63); + return (p35.a as rs.u16) < bound; }; const testTexts: (a0: string) => boolean = (s: string): boolean => { - const _67: rt.RefCell = rt.refCellBorrowMut(log); - const _79: rt.u8 = (rt.stringLen(s) & 0xff) | 128; - rt.byteVecPush(_67.value, _79); - rt.refMutRelease(_67); - return rt.stringLen(s) < rt.usizeRem(bound as rt.usize, 3); + const _67: rs.RefCell = rs.refCellBorrowMut(log); + const _79: rs.u8 = (rs.stringLen(s) & 0xff) | 128; + rs.byteVecPush(_67.value, _79); + rs.refMutRelease(_67); + return rs.stringLen(s) < rs.usizeRem(bound as rs.usize, 3); }; b2: { - const _35: rt.u8 = rt.u8Rem(kind, 8); + const _35: rs.u8 = rs.u8Rem(kind, 8); if (_35 === 0) { - const iter2: rt.Iter = rt.iterSlice([false, true]); + const iter2: rs.Iter = rs.iterSlice([false, true]); l147: while (true) { - const _43: boolean | rt.Done = iter2.next(); - if (_43 === rt.DONE) { + const _43: boolean | rs.Done = iter2.next(); + if (_43 === rs.DONE) { break; } const back: boolean = _43; - const it: rt.Iter = rt.byteSliceSplit(data, test); + const it: rs.Iter = rs.byteSliceSplit(data, test); hint(it.sizeHint(), out); flush(log, out); while (true) { if (!back) { - _52 = rt.iterToOption(it.next()); + _52 = rs.iterToOption(it.next()); } else { - _52 = rt.iterToOption(it.nextBack()); + _52 = rs.iterToOption(it.nextBack()); } if (_52 !== undefined) { - rt.byteVecPush(out, sum(_52)); + rs.byteVecPush(out, sum(_52)); hint(it.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l147; } } } - const it2: rt.Iter = rt.byteSliceSplit(data, test); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 12; + const it2: rs.Iter = rs.byteSliceSplit(data, test); + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 12; while ((_83 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.i32Rem(_83, 8)) & 1) === 0) { - p2 = rt.iterToOption(it2.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_83, 8)) & 1) === 0) { + p2 = rs.iterToOption(it2.next()); } else { - p2 = rt.iterToOption(it2.nextBack()); + p2 = rs.iterToOption(it2.nextBack()); } - rt.byteVecPush(out, option_mapOr$18m1ie6(p2, 252, sum)); + rs.byteVecPush(out, option_mapOr$0ckb6jj(p2, 252, sum)); hint(it2.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceSplit(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNth(rs.byteSliceSplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceSplit(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNthBack(rs.byteSliceSplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceSplit(data, test)), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterLast(rs.byteSliceSplit(data, test)), sum)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceSplit(data, test)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceSplit(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplit(data, test)), 1), sum), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.byteSliceSplit(data, test)), 1), sum), "next"); flush(log, out); - const iter4: rt.Iter = rt.iterSlice([false, true]); + const iter4: rs.Iter = rs.iterSlice([false, true]); l154: while (true) { - const _140: boolean | rt.Done = iter4.next(); - if (_140 === rt.DONE) { + const _140: boolean | rs.Done = iter4.next(); + if (_140 === rs.DONE) { break; } const back2: boolean = _140; - const it3: rt.Iter = rt.sliceSplit(words.items, testWords); + const it3: rs.Iter = rs.sliceSplit(words.items, testWords); hint(it3.sizeHint(), out); flush(log, out); while (true) { if (!back2) { - _151 = rt.iterToOption(it3.next()); + _151 = rs.iterToOption(it3.next()); } else { - _151 = rt.iterToOption(it3.nextBack()); + _151 = rs.iterToOption(it3.nextBack()); } if (_151 !== undefined) { - rt.byteVecPush(out, sumWords(_151)); + rs.byteVecPush(out, sumWords(_151)); hint(it3.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it3.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it3.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it3.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it3.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l154; } } } - const it4: rt.Iter = rt.sliceSplit(words.items, testWords); - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 12; + const it4: rs.Iter = rs.sliceSplit(words.items, testWords); + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 12; while ((_184 = iterStart2++) < iterEnd2) { - if ((rt.u8Shr(steps, rt.i32Rem(_184, 8)) & 1) === 0) { - p4 = rt.iterToOption(it4.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_184, 8)) & 1) === 0) { + p4 = rs.iterToOption(it4.next()); } else { - p4 = rt.iterToOption(it4.nextBack()); + p4 = rs.iterToOption(it4.nextBack()); } - rt.byteVecPush(out, option_mapOr$1qu2moz(p4, 252, sumWords)); + rs.byteVecPush(out, option_mapOr$0dwb29p(p4, 252, sumWords)); hint(it4.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterNth(rt.sliceSplit(words.items, testWords), 1), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterNth(rs.sliceSplit(words.items, testWords), 1), sumWords)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterNthBack(rt.sliceSplit(words.items, testWords), 1), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterNthBack(rs.sliceSplit(words.items, testWords), 1), sumWords)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterLast(rt.sliceSplit(words.items, testWords)), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterLast(rs.sliceSplit(words.items, testWords)), sumWords)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplit(words.items, testWords)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(words.items, testWords)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceSplit(words.items, testWords)), 1), sumWords), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplit(words.items, testWords)), 1), sumWords), "next"); flush(log, out); - const iter6: rt.Iter = rt.iterSlice([false, true]); + const iter6: rs.Iter = rs.iterSlice([false, true]); l161: while (true) { - const _251: boolean | rt.Done = iter6.next(); - if (_251 === rt.DONE) { + const _251: boolean | rs.Done = iter6.next(); + if (_251 === rs.DONE) { break; } const back3: boolean = _251; - const it5: rt.Iter = rt.sliceSplit(texts.items, testTexts); + const it5: rs.Iter = rs.sliceSplit(texts.items, testTexts); hint(it5.sizeHint(), out); flush(log, out); while (true) { if (!back3) { - _262 = rt.iterToOption(it5.next()); + _262 = rs.iterToOption(it5.next()); } else { - _262 = rt.iterToOption(it5.nextBack()); + _262 = rs.iterToOption(it5.nextBack()); } if (_262 !== undefined) { - rt.byteVecPush(out, sumTexts(_262)); + rs.byteVecPush(out, sumTexts(_262)); hint(it5.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it5.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it5.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it5.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it5.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l161; } } } - const it6: rt.Iter = rt.sliceSplit(texts.items, testTexts); - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 12; + const it6: rs.Iter = rs.sliceSplit(texts.items, testTexts); + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 12; while ((_295 = iterStart3++) < iterEnd3) { - if ((rt.u8Shr(steps, rt.i32Rem(_295, 8)) & 1) === 0) { - p6 = rt.iterToOption(it6.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_295, 8)) & 1) === 0) { + p6 = rs.iterToOption(it6.next()); } else { - p6 = rt.iterToOption(it6.nextBack()); + p6 = rs.iterToOption(it6.nextBack()); } - rt.byteVecPush(out, option_mapOr$0j8cgo8(p6, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$115x2cs(p6, 252, sumTexts)); hint(it6.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterNth(rt.sliceSplit(texts.items, testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterNth(rs.sliceSplit(texts.items, testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterNthBack(rt.sliceSplit(texts.items, testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterNthBack(rs.sliceSplit(texts.items, testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterLast(rt.sliceSplit(texts.items, testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterLast(rs.sliceSplit(texts.items, testTexts)), sumTexts)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplit(texts.items, testTexts)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(texts.items, testTexts)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceSplit(texts.items, testTexts)), 1), sumTexts), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplit(texts.items, testTexts)), 1), sumTexts), "next"); flush(log, out); - const it7: rt.Iter = rt.byteSliceSplit(data, test); - let iterStart4: rt.i32 = 0; - const iterEnd4: rt.i32 = 4; + const it7: rs.Iter = rs.byteSliceSplit(data, test); + let iterStart4: rs.i32 = 0; + const iterEnd4: rs.i32 = 4; while ((_360 = iterStart4++) < iterEnd4) { - const i4: rt.i32 = _360; - rt.byteVecPush(out, sum(rt.splitAsSlice(it7))); - if (rt.i32Rem(i4, 2) === 0) { - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.next()), sum)), undefined, true); + const i4: rs.i32 = _360; + rs.byteVecPush(out, sum(rs.splitAsSlice(it7))); + if (rs.i32Rem(i4, 2) === 0) { + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterToOption(it7.next()), sum)), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.nextBack()), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterToOption(it7.nextBack()), sum)), undefined, true); } flush(log, out); } - const copy: rt.Iter = it7.clone(); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(copy.nextBack()), sum)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it7.next()), sum)), undefined, true); - rt.byteVecPush(out, sum(rt.splitAsSlice(copy))); - rt.byteVecPush(out, sum(rt.splitAsSlice(it7))); + const copy: rs.Iter = it7.clone(); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterToOption(copy.nextBack()), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterToOption(it7.next()), sum)), undefined, true); + rs.byteVecPush(out, sum(rs.splitAsSlice(copy))); + rs.byteVecPush(out, sum(rs.splitAsSlice(it7))); flush(log, out); - const it8: rt.Iter = rt.sliceSplit(pairs.items, testPairs); - rt.iterToOption(it8.nextBack()); - rt.byteVecPush(out, sumPairs(rt.splitAsSlice(it8))); + const it8: rs.Iter = rs.sliceSplit(pairs.items, testPairs); + rs.iterToOption(it8.nextBack()); + rs.byteVecPush(out, sumPairs(rs.splitAsSlice(it8))); flush(log, out); } else if (_35 === 1) { - const iter9: rt.Iter = rt.iterSlice([false, true]); + const iter9: rs.Iter = rs.iterSlice([false, true]); l112: while (true) { - const _416: boolean | rt.Done = iter9.next(); - if (_416 === rt.DONE) { + const _416: boolean | rs.Done = iter9.next(); + if (_416 === rs.DONE) { break; } const back4: boolean = _416; - const it9: rt.Iter = rt.byteSliceRsplit(data, test); + const it9: rs.Iter = rs.byteSliceRsplit(data, test); hint(it9.sizeHint(), out); flush(log, out); while (true) { if (!back4) { - _425 = rt.iterToOption(it9.next()); + _425 = rs.iterToOption(it9.next()); } else { - _425 = rt.iterToOption(it9.nextBack()); + _425 = rs.iterToOption(it9.nextBack()); } if (_425 !== undefined) { - rt.byteVecPush(out, sum(_425)); + rs.byteVecPush(out, sum(_425)); hint(it9.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it9.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it9.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it9.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it9.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l112; } } } - const it10: rt.Iter = rt.byteSliceRsplit(data, test); - let iterStart5: rt.i32 = 0; - const iterEnd5: rt.i32 = 12; + const it10: rs.Iter = rs.byteSliceRsplit(data, test); + let iterStart5: rs.i32 = 0; + const iterEnd5: rs.i32 = 12; while ((_456 = iterStart5++) < iterEnd5) { - if ((rt.u8Shr(steps, rt.i32Rem(_456, 8)) & 1) === 0) { - p8 = rt.iterToOption(it10.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_456, 8)) & 1) === 0) { + p8 = rs.iterToOption(it10.next()); } else { - p8 = rt.iterToOption(it10.nextBack()); + p8 = rs.iterToOption(it10.nextBack()); } - rt.byteVecPush(out, option_mapOr$18m1ie6(p8, 252, sum)); + rs.byteVecPush(out, option_mapOr$0ckb6jj(p8, 252, sum)); hint(it10.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceRsplit(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNth(rs.byteSliceRsplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceRsplit(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNthBack(rs.byteSliceRsplit(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceRsplit(data, test)), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterLast(rs.byteSliceRsplit(data, test)), sum)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRsplit(data, test)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRsplit(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceRsplit(data, test)), 1), sum), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.byteSliceRsplit(data, test)), 1), sum), "next"); flush(log, out); - const iter11: rt.Iter = rt.iterSlice([false, true]); + const iter11: rs.Iter = rs.iterSlice([false, true]); l119: while (true) { - const _513: boolean | rt.Done = iter11.next(); - if (_513 === rt.DONE) { + const _513: boolean | rs.Done = iter11.next(); + if (_513 === rs.DONE) { break; } const back5: boolean = _513; - const it11: rt.Iter = rt.sliceRsplit(pairs.items, testPairs); + const it11: rs.Iter = rs.sliceRsplit(pairs.items, testPairs); hint(it11.sizeHint(), out); flush(log, out); while (true) { if (!back5) { - _524 = rt.iterToOption(it11.next()); + _524 = rs.iterToOption(it11.next()); } else { - _524 = rt.iterToOption(it11.nextBack()); + _524 = rs.iterToOption(it11.nextBack()); } if (_524 !== undefined) { - rt.byteVecPush(out, sumPairs(_524)); + rs.byteVecPush(out, sumPairs(_524)); hint(it11.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it11.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it11.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it11.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it11.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l119; } } } - const it12: rt.Iter = rt.sliceRsplit(pairs.items, testPairs); - let iterStart6: rt.i32 = 0; - const iterEnd6: rt.i32 = 12; + const it12: rs.Iter = rs.sliceRsplit(pairs.items, testPairs); + let iterStart6: rs.i32 = 0; + const iterEnd6: rs.i32 = 12; while ((_557 = iterStart6++) < iterEnd6) { - if ((rt.u8Shr(steps, rt.i32Rem(_557, 8)) & 1) === 0) { - p10 = rt.iterToOption(it12.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_557, 8)) & 1) === 0) { + p10 = rs.iterToOption(it12.next()); } else { - p10 = rt.iterToOption(it12.nextBack()); + p10 = rs.iterToOption(it12.nextBack()); } - rt.byteVecPush(out, option_mapOr$15c63lv(p10, 252, sumPairs)); + rs.byteVecPush(out, option_mapOr$119f2zg(p10, 252, sumPairs)); hint(it12.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterNth(rt.sliceRsplit(pairs.items, testPairs), 1), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterNth(rs.sliceRsplit(pairs.items, testPairs), 1), sumPairs)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterNthBack(rt.sliceRsplit(pairs.items, testPairs), 1), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterNthBack(rs.sliceRsplit(pairs.items, testPairs), 1), sumPairs)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterLast(rt.sliceRsplit(pairs.items, testPairs)), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterLast(rs.sliceRsplit(pairs.items, testPairs)), sumPairs)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceRsplit(pairs.items, testPairs)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(pairs.items, testPairs)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceRsplit(pairs.items, testPairs)), 1), sumPairs), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceRsplit(pairs.items, testPairs)), 1), sumPairs), "next"); flush(log, out); - const iter13: rt.Iter = rt.iterSlice([false, true]); + const iter13: rs.Iter = rs.iterSlice([false, true]); l126: while (true) { - const _624: boolean | rt.Done = iter13.next(); - if (_624 === rt.DONE) { + const _624: boolean | rs.Done = iter13.next(); + if (_624 === rs.DONE) { break; } const back6: boolean = _624; - const it13: rt.Iter = rt.sliceRsplit(texts.items, testTexts); + const it13: rs.Iter = rs.sliceRsplit(texts.items, testTexts); hint(it13.sizeHint(), out); flush(log, out); while (true) { if (!back6) { - _635 = rt.iterToOption(it13.next()); + _635 = rs.iterToOption(it13.next()); } else { - _635 = rt.iterToOption(it13.nextBack()); + _635 = rs.iterToOption(it13.nextBack()); } if (_635 !== undefined) { - rt.byteVecPush(out, sumTexts(_635)); + rs.byteVecPush(out, sumTexts(_635)); hint(it13.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it13.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it13.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it13.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it13.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l126; } } } - const it14: rt.Iter = rt.sliceRsplit(texts.items, testTexts); - let iterStart7: rt.i32 = 0; - const iterEnd7: rt.i32 = 12; + const it14: rs.Iter = rs.sliceRsplit(texts.items, testTexts); + let iterStart7: rs.i32 = 0; + const iterEnd7: rs.i32 = 12; while ((_668 = iterStart7++) < iterEnd7) { - if ((rt.u8Shr(steps, rt.i32Rem(_668, 8)) & 1) === 0) { - p12 = rt.iterToOption(it14.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_668, 8)) & 1) === 0) { + p12 = rs.iterToOption(it14.next()); } else { - p12 = rt.iterToOption(it14.nextBack()); + p12 = rs.iterToOption(it14.nextBack()); } - rt.byteVecPush(out, option_mapOr$0j8cgo8(p12, 252, sumTexts)); + rs.byteVecPush(out, option_mapOr$115x2cs(p12, 252, sumTexts)); hint(it14.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterNth(rt.sliceRsplit(texts.items, testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterNth(rs.sliceRsplit(texts.items, testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterNthBack(rt.sliceRsplit(texts.items, testTexts), 1), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterNthBack(rs.sliceRsplit(texts.items, testTexts), 1), sumTexts)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1r7pvtd(rt.iterLast(rt.sliceRsplit(texts.items, testTexts)), sumTexts)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$14ugp8v(rs.iterLast(rs.sliceRsplit(texts.items, testTexts)), sumTexts)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceRsplit(texts.items, testTexts)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(texts.items, testTexts)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceRsplit(texts.items, testTexts)), 1), sumTexts), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceRsplit(texts.items, testTexts)), 1), sumTexts), "next"); flush(log, out); - const twos: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _33: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + const twos: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _33: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_33, c.data[c.start + 1]); }), undefined, 2, true); - const testTwos: (a0: rt.ByteSlice) => boolean = (t: rt.ByteSlice): boolean => { - const _610: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_610.value, t.data[t.start + 1]); - rt.refMutRelease(_610); - return (t.data[t.start] as rt.u16) < bound; + const testTwos: (a0: rs.ByteSlice) => boolean = (t: rs.ByteSlice): boolean => { + const _610: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_610.value, t.data[t.start + 1]); + rs.refMutRelease(_610); + return (t.data[t.start] as rs.u16) < bound; }; - const iter15: rt.Iter = rt.iterSlice([false, true]); + const iter15: rs.Iter = rs.iterSlice([false, true]); l133: while (true) { - const _740: boolean | rt.Done = iter15.next(); - if (_740 === rt.DONE) { + const _740: boolean | rs.Done = iter15.next(); + if (_740 === rs.DONE) { break; } const back7: boolean = _740; - const it15: rt.Iter = rt.sliceRsplit(twos.items, rt.lending(testTwos, (f) => (held11) => f(rt.byteSliceFrom(held11)))); + const it15: rs.Iter = rs.sliceRsplit(twos.items, rs.lending(testTwos, (f) => (held11) => f(rs.byteSliceFrom(held11)))); hint(it15.sizeHint(), out); flush(log, out); while (true) { if (!back7) { - _751 = rt.iterToOption(it15.next()); + _751 = rs.iterToOption(it15.next()); } else { - _751 = rt.iterToOption(it15.nextBack()); + _751 = rs.iterToOption(it15.nextBack()); } if (_751 !== undefined) { - rt.byteVecPush(out, sumTwos(_751)); + rs.byteVecPush(out, sumTwos(_751)); hint(it15.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it15.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it15.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it15.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it15.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l133; } } } - const it16: rt.Iter = rt.sliceRsplit(twos.items, rt.lending(testTwos, (f2) => (held12) => f2(rt.byteSliceFrom(held12)))); - let iterStart8: rt.i32 = 0; - const iterEnd8: rt.i32 = 12; + const it16: rs.Iter = rs.sliceRsplit(twos.items, rs.lending(testTwos, (f2) => (held12) => f2(rs.byteSliceFrom(held12)))); + let iterStart8: rs.i32 = 0; + const iterEnd8: rs.i32 = 12; while ((_784 = iterStart8++) < iterEnd8) { - if ((rt.u8Shr(steps, rt.i32Rem(_784, 8)) & 1) === 0) { - p14 = rt.iterToOption(it16.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_784, 8)) & 1) === 0) { + p14 = rs.iterToOption(it16.next()); } else { - p14 = rt.iterToOption(it16.nextBack()); + p14 = rs.iterToOption(it16.nextBack()); } - rt.byteVecPush(out, option_mapOr$0wkl4zm(p14, 252, sumTwos)); + rs.byteVecPush(out, option_mapOr$0fbdkgt(p14, 252, sumTwos)); hint(it16.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterNth(rt.sliceRsplit(twos.items, rt.lending(testTwos, (f3) => (held13) => f3(rt.byteSliceFrom(held13)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterNth(rs.sliceRsplit(twos.items, rs.lending(testTwos, (f3) => (held13) => f3(rs.byteSliceFrom(held13)))), 1), sumTwos)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterNthBack(rt.sliceRsplit(twos.items, rt.lending(testTwos, (f4) => (held14) => f4(rt.byteSliceFrom(held14)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterNthBack(rs.sliceRsplit(twos.items, rs.lending(testTwos, (f4) => (held14) => f4(rs.byteSliceFrom(held14)))), 1), sumTwos)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterLast(rt.sliceRsplit(twos.items, rt.lending(testTwos, (f5) => (held15) => f5(rt.byteSliceFrom(held15))))), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterLast(rs.sliceRsplit(twos.items, rs.lending(testTwos, (f5) => (held15) => f5(rs.byteSliceFrom(held15))))), sumTwos)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceRsplit(twos.items, rt.lending(testTwos, (f6) => (held16) => f6(rt.byteSliceFrom(held16))))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceRsplit(twos.items, rs.lending(testTwos, (f6) => (held16) => f6(rs.byteSliceFrom(held16))))) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceRsplit(twos.items, rt.lending(testTwos, (f7) => (held17) => f7(rt.byteSliceFrom(held17))))), 1), sumTwos), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceRsplit(twos.items, rs.lending(testTwos, (f7) => (held17) => f7(rs.byteSliceFrom(held17))))), 1), sumTwos), "next"); flush(log, out); - const iter17: rt.Iter = rt.iterSlice([false, true]); + const iter17: rs.Iter = rs.iterSlice([false, true]); l140: while (true) { - const _851: boolean | rt.Done = iter17.next(); - if (_851 === rt.DONE) { + const _851: boolean | rs.Done = iter17.next(); + if (_851 === rs.DONE) { break; } const back8: boolean = _851; - const it17: rt.Iter = rt.sliceSplit(twos.items, rt.lending(testTwos, (f8) => (held18) => f8(rt.byteSliceFrom(held18)))); + const it17: rs.Iter = rs.sliceSplit(twos.items, rs.lending(testTwos, (f8) => (held18) => f8(rs.byteSliceFrom(held18)))); hint(it17.sizeHint(), out); flush(log, out); while (true) { if (!back8) { - _862 = rt.iterToOption(it17.next()); + _862 = rs.iterToOption(it17.next()); } else { - _862 = rt.iterToOption(it17.nextBack()); + _862 = rs.iterToOption(it17.nextBack()); } if (_862 !== undefined) { - rt.byteVecPush(out, sumTwos(_862)); + rs.byteVecPush(out, sumTwos(_862)); hint(it17.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it17.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it17.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it17.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it17.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l140; } } } - const it18: rt.Iter = rt.sliceSplit(twos.items, rt.lending(testTwos, (f9) => (held19) => f9(rt.byteSliceFrom(held19)))); - let iterStart9: rt.i32 = 0; - const iterEnd9: rt.i32 = 12; + const it18: rs.Iter = rs.sliceSplit(twos.items, rs.lending(testTwos, (f9) => (held19) => f9(rs.byteSliceFrom(held19)))); + let iterStart9: rs.i32 = 0; + const iterEnd9: rs.i32 = 12; while ((_895 = iterStart9++) < iterEnd9) { - if ((rt.u8Shr(steps, rt.i32Rem(_895, 8)) & 1) === 0) { - p16 = rt.iterToOption(it18.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_895, 8)) & 1) === 0) { + p16 = rs.iterToOption(it18.next()); } else { - p16 = rt.iterToOption(it18.nextBack()); + p16 = rs.iterToOption(it18.nextBack()); } - rt.byteVecPush(out, option_mapOr$0wkl4zm(p16, 252, sumTwos)); + rs.byteVecPush(out, option_mapOr$0fbdkgt(p16, 252, sumTwos)); hint(it18.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterNth(rt.sliceSplit(twos.items, rt.lending(testTwos, (f10) => (held20) => f10(rt.byteSliceFrom(held20)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterNth(rs.sliceSplit(twos.items, rs.lending(testTwos, (f10) => (held20) => f10(rs.byteSliceFrom(held20)))), 1), sumTwos)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterNthBack(rt.sliceSplit(twos.items, rt.lending(testTwos, (f11) => (held21) => f11(rt.byteSliceFrom(held21)))), 1), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterNthBack(rs.sliceSplit(twos.items, rs.lending(testTwos, (f11) => (held21) => f11(rs.byteSliceFrom(held21)))), 1), sumTwos)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$14orwce(rt.iterLast(rt.sliceSplit(twos.items, rt.lending(testTwos, (f12) => (held22) => f12(rt.byteSliceFrom(held22))))), sumTwos)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0qvqmiu(rs.iterLast(rs.sliceSplit(twos.items, rs.lending(testTwos, (f12) => (held22) => f12(rs.byteSliceFrom(held22))))), sumTwos)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplit(twos.items, rt.lending(testTwos, (f13) => (held23) => f13(rt.byteSliceFrom(held23))))) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplit(twos.items, rs.lending(testTwos, (f13) => (held23) => f13(rs.byteSliceFrom(held23))))) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceSplit(twos.items, rt.lending(testTwos, (f14) => (held24) => f14(rt.byteSliceFrom(held24))))), 1), sumTwos), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplit(twos.items, rs.lending(testTwos, (f14) => (held24) => f14(rs.byteSliceFrom(held24))))), 1), sumTwos), "next"); flush(log, out); } else if (_35 === 2) { - const iter19: rt.Iter = rt.iterSlice([false, true]); + const iter19: rs.Iter = rs.iterSlice([false, true]); l91: while (true) { - const _962: boolean | rt.Done = iter19.next(); - if (_962 === rt.DONE) { + const _962: boolean | rs.Done = iter19.next(); + if (_962 === rs.DONE) { break; } const back9: boolean = _962; - const it19: rt.Iter = rt.byteSliceSplitInclusive(data, test); + const it19: rs.Iter = rs.byteSliceSplitInclusive(data, test); hint(it19.sizeHint(), out); flush(log, out); while (true) { if (!back9) { - _971 = rt.iterToOption(it19.next()); + _971 = rs.iterToOption(it19.next()); } else { - _971 = rt.iterToOption(it19.nextBack()); + _971 = rs.iterToOption(it19.nextBack()); } if (_971 !== undefined) { - rt.byteVecPush(out, sum(_971)); + rs.byteVecPush(out, sum(_971)); hint(it19.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it19.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it19.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it19.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it19.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l91; } } } - const it20: rt.Iter = rt.byteSliceSplitInclusive(data, test); - let iterStart10: rt.i32 = 0; - const iterEnd10: rt.i32 = 12; + const it20: rs.Iter = rs.byteSliceSplitInclusive(data, test); + let iterStart10: rs.i32 = 0; + const iterEnd10: rs.i32 = 12; while ((_1002 = iterStart10++) < iterEnd10) { - if ((rt.u8Shr(steps, rt.i32Rem(_1002, 8)) & 1) === 0) { - p18 = rt.iterToOption(it20.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_1002, 8)) & 1) === 0) { + p18 = rs.iterToOption(it20.next()); } else { - p18 = rt.iterToOption(it20.nextBack()); + p18 = rs.iterToOption(it20.nextBack()); } - rt.byteVecPush(out, option_mapOr$18m1ie6(p18, 252, sum)); + rs.byteVecPush(out, option_mapOr$0ckb6jj(p18, 252, sum)); hint(it20.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNth(rt.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNth(rs.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterNthBack(rt.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterNthBack(rs.byteSliceSplitInclusive(data, test), 1), sum)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterLast(rt.byteSliceSplitInclusive(data, test)), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterLast(rs.byteSliceSplitInclusive(data, test)), sum)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceSplitInclusive(data, test)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceSplitInclusive(data, test)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.byteSliceSplitInclusive(data, test)), 1), sum), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.byteSliceSplitInclusive(data, test)), 1), sum), "next"); flush(log, out); - const iter21: rt.Iter = rt.iterSlice([false, true]); + const iter21: rs.Iter = rs.iterSlice([false, true]); l98: while (true) { - const _1059: boolean | rt.Done = iter21.next(); - if (_1059 === rt.DONE) { + const _1059: boolean | rs.Done = iter21.next(); + if (_1059 === rs.DONE) { break; } const back10: boolean = _1059; - const it21: rt.Iter = rt.sliceSplitInclusive(words.items, testWords); + const it21: rs.Iter = rs.sliceSplitInclusive(words.items, testWords); hint(it21.sizeHint(), out); flush(log, out); while (true) { if (!back10) { - _1070 = rt.iterToOption(it21.next()); + _1070 = rs.iterToOption(it21.next()); } else { - _1070 = rt.iterToOption(it21.nextBack()); + _1070 = rs.iterToOption(it21.nextBack()); } if (_1070 !== undefined) { - rt.byteVecPush(out, sumWords(_1070)); + rs.byteVecPush(out, sumWords(_1070)); hint(it21.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it21.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it21.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it21.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it21.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l98; } } } - const it22: rt.Iter = rt.sliceSplitInclusive(words.items, testWords); - let iterStart11: rt.i32 = 0; - const iterEnd11: rt.i32 = 12; + const it22: rs.Iter = rs.sliceSplitInclusive(words.items, testWords); + let iterStart11: rs.i32 = 0; + const iterEnd11: rs.i32 = 12; while ((_1103 = iterStart11++) < iterEnd11) { - if ((rt.u8Shr(steps, rt.i32Rem(_1103, 8)) & 1) === 0) { - p20 = rt.iterToOption(it22.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_1103, 8)) & 1) === 0) { + p20 = rs.iterToOption(it22.next()); } else { - p20 = rt.iterToOption(it22.nextBack()); + p20 = rs.iterToOption(it22.nextBack()); } - rt.byteVecPush(out, option_mapOr$1qu2moz(p20, 252, sumWords)); + rs.byteVecPush(out, option_mapOr$0dwb29p(p20, 252, sumWords)); hint(it22.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterNth(rt.sliceSplitInclusive(words.items, testWords), 1), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterNth(rs.sliceSplitInclusive(words.items, testWords), 1), sumWords)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterNthBack(rt.sliceSplitInclusive(words.items, testWords), 1), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterNthBack(rs.sliceSplitInclusive(words.items, testWords), 1), sumWords)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$0vryjg8(rt.iterLast(rt.sliceSplitInclusive(words.items, testWords)), sumWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0un8siq(rs.iterLast(rs.sliceSplitInclusive(words.items, testWords)), sumWords)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplitInclusive(words.items, testWords)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplitInclusive(words.items, testWords)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceSplitInclusive(words.items, testWords)), 1), sumWords), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplitInclusive(words.items, testWords)), 1), sumWords), "next"); flush(log, out); - const iter23: rt.Iter = rt.iterSlice([false, true]); + const iter23: rs.Iter = rs.iterSlice([false, true]); l105: while (true) { - const _1170: boolean | rt.Done = iter23.next(); - if (_1170 === rt.DONE) { + const _1170: boolean | rs.Done = iter23.next(); + if (_1170 === rs.DONE) { break; } const back11: boolean = _1170; - const it23: rt.Iter = rt.sliceSplitInclusive(pairs.items, testPairs); + const it23: rs.Iter = rs.sliceSplitInclusive(pairs.items, testPairs); hint(it23.sizeHint(), out); flush(log, out); while (true) { if (!back11) { - _1181 = rt.iterToOption(it23.next()); + _1181 = rs.iterToOption(it23.next()); } else { - _1181 = rt.iterToOption(it23.nextBack()); + _1181 = rs.iterToOption(it23.nextBack()); } if (_1181 !== undefined) { - rt.byteVecPush(out, sumPairs(_1181)); + rs.byteVecPush(out, sumPairs(_1181)); hint(it23.sizeHint(), out); flush(log, out); } else { - rt.byteVecPush(out, (rt.iterToOption(it23.next()) === undefined ? 1 : 0) | (((rt.iterToOption(it23.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.iterToOption(it23.next()) === undefined ? 1 : 0) | (((rs.iterToOption(it23.nextBack()) === undefined ? 1 : 0) << 1) & 0xff)); flush(log, out); continue l105; } } } - const it24: rt.Iter = rt.sliceSplitInclusive(pairs.items, testPairs); - let iterStart12: rt.i32 = 0; - const iterEnd12: rt.i32 = 12; + const it24: rs.Iter = rs.sliceSplitInclusive(pairs.items, testPairs); + let iterStart12: rs.i32 = 0; + const iterEnd12: rs.i32 = 12; while ((_1214 = iterStart12++) < iterEnd12) { - if ((rt.u8Shr(steps, rt.i32Rem(_1214, 8)) & 1) === 0) { - p22 = rt.iterToOption(it24.next()); + if ((rs.u8Shr(steps, rs.i32Rem(_1214, 8)) & 1) === 0) { + p22 = rs.iterToOption(it24.next()); } else { - p22 = rt.iterToOption(it24.nextBack()); + p22 = rs.iterToOption(it24.nextBack()); } - rt.byteVecPush(out, option_mapOr$15c63lv(p22, 252, sumPairs)); + rs.byteVecPush(out, option_mapOr$119f2zg(p22, 252, sumPairs)); hint(it24.sizeHint(), out); flush(log, out); } - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterNth(rt.sliceSplitInclusive(pairs.items, testPairs), 1), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterNth(rs.sliceSplitInclusive(pairs.items, testPairs), 1), sumPairs)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterNthBack(rt.sliceSplitInclusive(pairs.items, testPairs), 1), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterNthBack(rs.sliceSplitInclusive(pairs.items, testPairs), 1), sumPairs)), undefined, true); flush(log, out); - rt.iterExtendBytes(out, rt.iterOption(option_map$02o7iu2(rt.iterLast(rt.sliceSplitInclusive(pairs.items, testPairs)), sumPairs)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0wpmcoh(rs.iterLast(rs.sliceSplitInclusive(pairs.items, testPairs)), sumPairs)), undefined, true); flush(log, out); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplitInclusive(pairs.items, testPairs)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplitInclusive(pairs.items, testPairs)) & 0xff); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSkip(rt.iterRev(rt.sliceSplitInclusive(pairs.items, testPairs)), 1), sumPairs), "next"); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSkip(rs.iterRev(rs.sliceSplitInclusive(pairs.items, testPairs)), 1), sumPairs), "next"); flush(log, out); } else { if (_35 === 3) { - const _1280: rt.usize = rt.usizeAdd(data.length, 3); - let iterStart13: rt.usize = 0; - const iterEnd13: rt.usize = _1280; + const _1280: rs.usize = rs.usizeAdd(data.length, 3); + let iterStart13: rs.usize = 0; + const iterEnd13: rs.usize = _1280; while ((_1284 = iterStart13++) < iterEnd13) { - const n: rt.usize = _1284; - const it25: rt.Iter = rt.byteSliceSplitn(data, n, test); + const n: rs.usize = _1284; + const it25: rs.Iter = rs.byteSliceSplitn(data, n, test); hint(it25.sizeHint(), out); while (true) { - const _1292: rt.ByteSlice | rt.Done = it25.next(); - if (_1292 !== rt.DONE) { - rt.byteVecPush(out, sum(_1292)); + const _1292: rs.ByteSlice | rs.Done = it25.next(); + if (_1292 !== rs.DONE) { + rs.byteVecPush(out, sum(_1292)); hint(it25.sizeHint(), out); flush(log, out); } else { break; } } - rt.byteVecPush(out, rt.iterToOption(it25.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceSplitn(data, n, test)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it25.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceSplitn(data, n, test)) & 0xff); flush(log, out); } - const _1318: rt.usize = rt.usizeAdd(data.length, 3); - let iterStart14: rt.usize = 0; - const iterEnd14: rt.usize = _1318; + const _1318: rs.usize = rs.usizeAdd(data.length, 3); + let iterStart14: rs.usize = 0; + const iterEnd14: rs.usize = _1318; while ((_1322 = iterStart14++) < iterEnd14) { - const n2: rt.usize = _1322; - const it26: rt.Iter = rt.byteSliceRsplitn(data, n2, test); + const n2: rs.usize = _1322; + const it26: rs.Iter = rs.byteSliceRsplitn(data, n2, test); hint(it26.sizeHint(), out); while (true) { - const _1330: rt.ByteSlice | rt.Done = it26.next(); - if (_1330 !== rt.DONE) { - rt.byteVecPush(out, sum(_1330)); + const _1330: rs.ByteSlice | rs.Done = it26.next(); + if (_1330 !== rs.DONE) { + rs.byteVecPush(out, sum(_1330)); hint(it26.sizeHint(), out); flush(log, out); } else { break; } } - rt.byteVecPush(out, rt.iterToOption(it26.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRsplitn(data, n2, test)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it26.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRsplitn(data, n2, test)) & 0xff); flush(log, out); } - const _1356: rt.usize = rt.usizeAdd(words.items.length, 3); - let iterStart15: rt.usize = 0; - const iterEnd15: rt.usize = _1356; + const _1356: rs.usize = rs.usizeAdd(words.items.length, 3); + let iterStart15: rs.usize = 0; + const iterEnd15: rs.usize = _1356; while ((_1361 = iterStart15++) < iterEnd15) { - const n3: rt.usize = _1361; - const it27: rt.Iter = rt.sliceSplitn(words.items, n3, testWords); + const n3: rs.usize = _1361; + const it27: rs.Iter = rs.sliceSplitn(words.items, n3, testWords); hint(it27.sizeHint(), out); while (true) { - const _1371: rt.u16[] | rt.Done = it27.next(); - if (_1371 !== rt.DONE) { - rt.byteVecPush(out, sumWords(_1371)); + const _1371: rs.u16[] | rs.Done = it27.next(); + if (_1371 !== rs.DONE) { + rs.byteVecPush(out, sumWords(_1371)); hint(it27.sizeHint(), out); flush(log, out); } else { break; } } - rt.byteVecPush(out, rt.iterToOption(it27.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplitn(words.items, n3, testWords)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it27.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplitn(words.items, n3, testWords)) & 0xff); flush(log, out); } - const _1399: rt.usize = rt.usizeAdd(pairs.items.length, 3); - let iterStart16: rt.usize = 0; - const iterEnd16: rt.usize = _1399; + const _1399: rs.usize = rs.usizeAdd(pairs.items.length, 3); + let iterStart16: rs.usize = 0; + const iterEnd16: rs.usize = _1399; while ((_1404 = iterStart16++) < iterEnd16) { - const n4: rt.usize = _1404; - const it28: rt.Iter = rt.sliceRsplitn(pairs.items, n4, testPairs); + const n4: rs.usize = _1404; + const it28: rs.Iter = rs.sliceRsplitn(pairs.items, n4, testPairs); hint(it28.sizeHint(), out); while (true) { - const _1414: Pair.Pair[] | rt.Done = it28.next(); - if (_1414 !== rt.DONE) { - rt.byteVecPush(out, sumPairs(_1414)); + const _1414: Pair.Pair[] | rs.Done = it28.next(); + if (_1414 !== rs.DONE) { + rs.byteVecPush(out, sumPairs(_1414)); hint(it28.sizeHint(), out); flush(log, out); } else { break; } } - rt.byteVecPush(out, rt.iterToOption(it28.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.sliceRsplitn(pairs.items, n4, testPairs)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it28.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.sliceRsplitn(pairs.items, n4, testPairs)) & 0xff); flush(log, out); } - const _1442: rt.usize = rt.usizeAdd(texts.items.length, 3); - let iterStart17: rt.usize = 0; - const iterEnd17: rt.usize = _1442; + const _1442: rs.usize = rs.usizeAdd(texts.items.length, 3); + let iterStart17: rs.usize = 0; + const iterEnd17: rs.usize = _1442; while (true) { if (!((_1447 = iterStart17++) < iterEnd17)) { break b2; } - const n5: rt.usize = _1447; - const it29: rt.Iter = rt.sliceSplitn(texts.items, n5, testTexts); + const n5: rs.usize = _1447; + const it29: rs.Iter = rs.sliceSplitn(texts.items, n5, testTexts); hint(it29.sizeHint(), out); while (true) { - const _1457: string[] | rt.Done = it29.next(); - if (_1457 !== rt.DONE) { - rt.byteVecPush(out, sumTexts(_1457)); + const _1457: string[] | rs.Done = it29.next(); + if (_1457 !== rs.DONE) { + rs.byteVecPush(out, sumTexts(_1457)); hint(it29.sizeHint(), out); flush(log, out); } else { break; } } - rt.byteVecPush(out, rt.iterToOption(it29.next()) === undefined ? 1 : 0); - rt.byteVecPush(out, rt.iterCount(rt.sliceSplitn(texts.items, n5, testTexts)) & 0xff); + rs.byteVecPush(out, rs.iterToOption(it29.next()) === undefined ? 1 : 0); + rs.byteVecPush(out, rs.iterCount(rs.sliceSplitn(texts.items, n5, testTexts)) & 0xff); flush(log, out); } } if (_35 === 4) { - const iter30: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceSplit(rt.byteVecSlice(bytes), test)); + const iter30: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceSplit(rs.byteVecSlice(bytes), test)); while (true) { - const _1489: [rt.usize, rt.ByteSlice] | rt.Done = iter30.next(); - if (_1489 === rt.DONE) { + const _1489: [rs.usize, rs.ByteSlice] | rs.Done = iter30.next(); + if (_1489 === rs.DONE) { break; } scribble(_1489[0], _1489[1]); } flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const held: rt.Vec = rt.iterToVec(rt.byteSliceSplit(rt.byteVecSlice(bytes), test), "next", 8); - const iter31: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held.items))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const held: rs.Vec = rs.iterToVec(rs.byteSliceSplit(rs.byteVecSlice(bytes), test), "next", 8); + const iter31: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held.items))); while (true) { - const _1511: [rt.usize, rt.Place] | rt.Done = iter31.next(); - if (_1511 === rt.DONE) { + const _1511: [rs.usize, rs.Place] | rs.Done = iter31.next(); + if (_1511 === rs.DONE) { break; } - scribble(rt.usizeAdd(_1511[0], 7), _1511[1].v); + scribble(rs.usizeAdd(_1511[0], 7), _1511[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held.items), (p44: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held.items), (p44: rs.ByteSlice): rs.u8 => { return sum(p44); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const iter32: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRsplitMut(words.items, testWords)); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const iter32: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceRsplitMut(words.items, testWords)); while (true) { - const _1538: [rt.usize, rt.u16[]] | rt.Done = iter32.next(); - if (_1538 === rt.DONE) { + const _1538: [rs.usize, rs.u16[]] | rs.Done = iter32.next(); + if (_1538 === rs.DONE) { break; } scribbleWords(_1538[0], _1538[1]); } flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const held2: rt.Vec = rt.iterToVec(rt.sliceRsplitMut(words.items, testWords), "next", 8); - const iter33: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held2.items))); + rs.byteVecPush(out, sumWords(words.items)); + const held2: rs.Vec = rs.iterToVec(rs.sliceRsplitMut(words.items, testWords), "next", 8); + const iter33: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held2.items))); while (true) { - const _1560: [rt.usize, rt.Place] | rt.Done = iter33.next(); - if (_1560 === rt.DONE) { + const _1560: [rs.usize, rs.Place] | rs.Done = iter33.next(); + if (_1560 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_1560[0], 7), _1560[1].v); + scribbleWords(rs.usizeAdd(_1560[0], 7), _1560[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held2.items), (p45: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held2.items), (p45: rs.u16[]): rs.u8 => { return sumWords(p45); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const iter34: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceSplitMut(pairs.items, testPairs)); + rs.byteVecPush(out, sumWords(words.items)); + const iter34: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceSplitMut(pairs.items, testPairs)); while (true) { - const _1587: [rt.usize, Pair.Pair[]] | rt.Done = iter34.next(); - if (_1587 === rt.DONE) { + const _1587: [rs.usize, Pair.Pair[]] | rs.Done = iter34.next(); + if (_1587 === rs.DONE) { break; } scribblePairs(_1587[0], _1587[1]); } flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const held3: rt.Vec = rt.iterToVec(rt.sliceSplitMut(pairs.items, testPairs), "next", 8); - const iter35: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held3.items))); + rs.byteVecPush(out, sumPairs(pairs.items)); + const held3: rs.Vec = rs.iterToVec(rs.sliceSplitMut(pairs.items, testPairs), "next", 8); + const iter35: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held3.items))); while (true) { - const _1609: [rt.usize, rt.Place] | rt.Done = iter35.next(); - if (_1609 === rt.DONE) { + const _1609: [rs.usize, rs.Place] | rs.Done = iter35.next(); + if (_1609 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_1609[0], 7), _1609[1].v); + scribblePairs(rs.usizeAdd(_1609[0], 7), _1609[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held3.items), (p46: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held3.items), (p46: Pair.Pair[]): rs.u8 => { return sumPairs(p46); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const it30: rt.Iter = rt.byteSliceRsplit(rt.byteVecSlice(bytes), test); - let iterStart18: rt.usize = 0; - const iterEnd18: rt.usize = 12; + rs.byteVecPush(out, sumPairs(pairs.items)); + const it30: rs.Iter = rs.byteSliceRsplit(rs.byteVecSlice(bytes), test); + let iterStart18: rs.usize = 0; + const iterEnd18: rs.usize = 12; while ((_1636 = iterStart18++) < iterEnd18) { - const i19: rt.usize = _1636; - if ((rt.u8Shr(steps, rt.usizeRem(i19, 8)) & 1) === 0) { - p23 = rt.iterToOption(it30.next()); + const i19: rs.usize = _1636; + if ((rs.u8Shr(steps, rs.usizeRem(i19, 8)) & 1) === 0) { + p23 = rs.iterToOption(it30.next()); } else { - p23 = rt.iterToOption(it30.nextBack()); + p23 = rs.iterToOption(it30.nextBack()); } if (p23 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribble(i19, p23); } flush(log, out); } - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const it31: rt.Iter = rt.sliceSplitMut(words.items, testWords); - let iterStart19: rt.usize = 0; - const iterEnd19: rt.usize = 12; + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const it31: rs.Iter = rs.sliceSplitMut(words.items, testWords); + let iterStart19: rs.usize = 0; + const iterEnd19: rs.usize = 12; while ((_1665 = iterStart19++) < iterEnd19) { - const i20: rt.usize = _1665; - if ((rt.u8Shr(steps, rt.usizeRem(i20, 8)) & 1) === 0) { - p25 = rt.iterToOption(it31.next()); + const i20: rs.usize = _1665; + if ((rs.u8Shr(steps, rs.usizeRem(i20, 8)) & 1) === 0) { + p25 = rs.iterToOption(it31.next()); } else { - p25 = rt.iterToOption(it31.nextBack()); + p25 = rs.iterToOption(it31.nextBack()); } if (p25 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribbleWords(i20, p25); } flush(log, out); } - rt.byteVecPush(out, sumWords(words.items)); - const it32: rt.Iter = rt.sliceRsplitMut(pairs.items, testPairs); - let iterStart20: rt.usize = 0; - const iterEnd20: rt.usize = 12; + rs.byteVecPush(out, sumWords(words.items)); + const it32: rs.Iter = rs.sliceRsplitMut(pairs.items, testPairs); + let iterStart20: rs.usize = 0; + const iterEnd20: rs.usize = 12; while ((_1694 = iterStart20++) < iterEnd20) { - const i21: rt.usize = _1694; - if ((rt.u8Shr(steps, rt.usizeRem(i21, 8)) & 1) === 0) { - p27 = rt.iterToOption(it32.next()); + const i21: rs.usize = _1694; + if ((rs.u8Shr(steps, rs.usizeRem(i21, 8)) & 1) === 0) { + p27 = rs.iterToOption(it32.next()); } else { - p27 = rt.iterToOption(it32.nextBack()); + p27 = rs.iterToOption(it32.nextBack()); } if (p27 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribblePairs(i21, p27); } flush(log, out); } - rt.byteVecPush(out, sumPairs(pairs.items)); + rs.byteVecPush(out, sumPairs(pairs.items)); } else if (_35 === 5) { - const iter39: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceSplitInclusive(rt.byteVecSlice(bytes), test)); + const iter39: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceSplitInclusive(rs.byteVecSlice(bytes), test)); while (true) { - const _1723: [rt.usize, rt.ByteSlice] | rt.Done = iter39.next(); - if (_1723 === rt.DONE) { + const _1723: [rs.usize, rs.ByteSlice] | rs.Done = iter39.next(); + if (_1723 === rs.DONE) { break; } scribble(_1723[0], _1723[1]); } flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const held4: rt.Vec = rt.iterToVec(rt.byteSliceSplitInclusive(rt.byteVecSlice(bytes), test), "next", 8); - const iter40: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4.items))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const held4: rs.Vec = rs.iterToVec(rs.byteSliceSplitInclusive(rs.byteVecSlice(bytes), test), "next", 8); + const iter40: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held4.items))); while (true) { - const _1745: [rt.usize, rt.Place] | rt.Done = iter40.next(); - if (_1745 === rt.DONE) { + const _1745: [rs.usize, rs.Place] | rs.Done = iter40.next(); + if (_1745 === rs.DONE) { break; } - scribble(rt.usizeAdd(_1745[0], 7), _1745[1].v); + scribble(rs.usizeAdd(_1745[0], 7), _1745[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4.items), (p41: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held4.items), (p41: rs.ByteSlice): rs.u8 => { return sum(p41); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const iter41: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceSplitInclusiveMut(words.items, testWords)); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const iter41: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceSplitInclusiveMut(words.items, testWords)); while (true) { - const _1772: [rt.usize, rt.u16[]] | rt.Done = iter41.next(); - if (_1772 === rt.DONE) { + const _1772: [rs.usize, rs.u16[]] | rs.Done = iter41.next(); + if (_1772 === rs.DONE) { break; } scribbleWords(_1772[0], _1772[1]); } flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const held5: rt.Vec = rt.iterToVec(rt.sliceSplitInclusiveMut(words.items, testWords), "next", 8); - const iter42: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held5.items))); + rs.byteVecPush(out, sumWords(words.items)); + const held5: rs.Vec = rs.iterToVec(rs.sliceSplitInclusiveMut(words.items, testWords), "next", 8); + const iter42: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held5.items))); while (true) { - const _1794: [rt.usize, rt.Place] | rt.Done = iter42.next(); - if (_1794 === rt.DONE) { + const _1794: [rs.usize, rs.Place] | rs.Done = iter42.next(); + if (_1794 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_1794[0], 7), _1794[1].v); + scribbleWords(rs.usizeAdd(_1794[0], 7), _1794[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held5.items), (p42: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held5.items), (p42: rs.u16[]): rs.u8 => { return sumWords(p42); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const iter43: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceSplitInclusiveMut(pairs.items, testPairs)); + rs.byteVecPush(out, sumWords(words.items)); + const iter43: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceSplitInclusiveMut(pairs.items, testPairs)); while (true) { - const _1821: [rt.usize, Pair.Pair[]] | rt.Done = iter43.next(); - if (_1821 === rt.DONE) { + const _1821: [rs.usize, Pair.Pair[]] | rs.Done = iter43.next(); + if (_1821 === rs.DONE) { break; } scribblePairs(_1821[0], _1821[1]); } flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const held6: rt.Vec = rt.iterToVec(rt.sliceSplitInclusiveMut(pairs.items, testPairs), "next", 8); - const iter44: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held6.items))); + rs.byteVecPush(out, sumPairs(pairs.items)); + const held6: rs.Vec = rs.iterToVec(rs.sliceSplitInclusiveMut(pairs.items, testPairs), "next", 8); + const iter44: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held6.items))); while (true) { - const _1843: [rt.usize, rt.Place] | rt.Done = iter44.next(); - if (_1843 === rt.DONE) { + const _1843: [rs.usize, rs.Place] | rs.Done = iter44.next(); + if (_1843 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_1843[0], 7), _1843[1].v); + scribblePairs(rs.usizeAdd(_1843[0], 7), _1843[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held6.items), (p43: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held6.items), (p43: Pair.Pair[]): rs.u8 => { return sumPairs(p43); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const it33: rt.Iter = rt.byteSliceSplitInclusive(rt.byteVecSlice(bytes), test); - let iterStart21: rt.usize = 0; - const iterEnd21: rt.usize = 12; + rs.byteVecPush(out, sumPairs(pairs.items)); + const it33: rs.Iter = rs.byteSliceSplitInclusive(rs.byteVecSlice(bytes), test); + let iterStart21: rs.usize = 0; + const iterEnd21: rs.usize = 12; while ((_1870 = iterStart21++) < iterEnd21) { - const i28: rt.usize = _1870; - if ((rt.u8Shr(steps, rt.usizeRem(i28, 8)) & 1) === 0) { - p29 = rt.iterToOption(it33.next()); + const i28: rs.usize = _1870; + if ((rs.u8Shr(steps, rs.usizeRem(i28, 8)) & 1) === 0) { + p29 = rs.iterToOption(it33.next()); } else { - p29 = rt.iterToOption(it33.nextBack()); + p29 = rs.iterToOption(it33.nextBack()); } if (p29 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribble(i28, p29); } flush(log, out); } - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const it34: rt.Iter = rt.sliceSplitInclusiveMut(words.items, testWords); - let iterStart22: rt.usize = 0; - const iterEnd22: rt.usize = 12; + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const it34: rs.Iter = rs.sliceSplitInclusiveMut(words.items, testWords); + let iterStart22: rs.usize = 0; + const iterEnd22: rs.usize = 12; while ((_1899 = iterStart22++) < iterEnd22) { - const i29: rt.usize = _1899; - if ((rt.u8Shr(steps, rt.usizeRem(i29, 8)) & 1) === 0) { - p31 = rt.iterToOption(it34.next()); + const i29: rs.usize = _1899; + if ((rs.u8Shr(steps, rs.usizeRem(i29, 8)) & 1) === 0) { + p31 = rs.iterToOption(it34.next()); } else { - p31 = rt.iterToOption(it34.nextBack()); + p31 = rs.iterToOption(it34.nextBack()); } if (p31 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribbleWords(i29, p31); } flush(log, out); } - rt.byteVecPush(out, sumWords(words.items)); - const it35: rt.Iter = rt.sliceSplitInclusiveMut(pairs.items, testPairs); - let iterStart23: rt.usize = 0; - const iterEnd23: rt.usize = 12; + rs.byteVecPush(out, sumWords(words.items)); + const it35: rs.Iter = rs.sliceSplitInclusiveMut(pairs.items, testPairs); + let iterStart23: rs.usize = 0; + const iterEnd23: rs.usize = 12; while ((_1928 = iterStart23++) < iterEnd23) { - const i30: rt.usize = _1928; - if ((rt.u8Shr(steps, rt.usizeRem(i30, 8)) & 1) === 0) { - p33 = rt.iterToOption(it35.next()); + const i30: rs.usize = _1928; + if ((rs.u8Shr(steps, rs.usizeRem(i30, 8)) & 1) === 0) { + p33 = rs.iterToOption(it35.next()); } else { - p33 = rt.iterToOption(it35.nextBack()); + p33 = rs.iterToOption(it35.nextBack()); } if (p33 === undefined) { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } else { scribblePairs(i30, p33); } flush(log, out); } - rt.byteVecPush(out, sumPairs(pairs.items)); + rs.byteVecPush(out, sumPairs(pairs.items)); } else if (_35 === 6) { - const n6: rt.usize = rt.usizeRem(steps as rt.usize, rt.usizeAdd(data.length, 3)); - const iter48: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceSplitn(rt.byteVecSlice(bytes), n6, test)); + const n6: rs.usize = rs.usizeRem(steps as rs.usize, rs.usizeAdd(data.length, 3)); + const iter48: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceSplitn(rs.byteVecSlice(bytes), n6, test)); while (true) { - const _1963: [rt.usize, rt.ByteSlice] | rt.Done = iter48.next(); - if (_1963 === rt.DONE) { + const _1963: [rs.usize, rs.ByteSlice] | rs.Done = iter48.next(); + if (_1963 === rs.DONE) { break; } scribble(_1963[0], _1963[1]); } flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const held7: rt.Vec = rt.iterToVec(rt.byteSliceSplitn(rt.byteVecSlice(bytes), n6, test), "next", 8); - const iter49: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7.items))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const held7: rs.Vec = rs.iterToVec(rs.byteSliceSplitn(rs.byteVecSlice(bytes), n6, test), "next", 8); + const iter49: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held7.items))); while (true) { - const _1985: [rt.usize, rt.Place] | rt.Done = iter49.next(); - if (_1985 === rt.DONE) { + const _1985: [rs.usize, rs.Place] | rs.Done = iter49.next(); + if (_1985 === rs.DONE) { break; } - scribble(rt.usizeAdd(_1985[0], 7), _1985[1].v); + scribble(rs.usizeAdd(_1985[0], 7), _1985[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7.items), (p37: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held7.items), (p37: rs.ByteSlice): rs.u8 => { return sum(p37); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const iter50: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRsplitnMut(words.items, n6, testWords)); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const iter50: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceRsplitnMut(words.items, n6, testWords)); while (true) { - const _2012: [rt.usize, rt.u16[]] | rt.Done = iter50.next(); - if (_2012 === rt.DONE) { + const _2012: [rs.usize, rs.u16[]] | rs.Done = iter50.next(); + if (_2012 === rs.DONE) { break; } scribbleWords(_2012[0], _2012[1]); } flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const held8: rt.Vec = rt.iterToVec(rt.sliceRsplitnMut(words.items, n6, testWords), "next", 8); - const iter51: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held8.items))); + rs.byteVecPush(out, sumWords(words.items)); + const held8: rs.Vec = rs.iterToVec(rs.sliceRsplitnMut(words.items, n6, testWords), "next", 8); + const iter51: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held8.items))); while (true) { - const _2034: [rt.usize, rt.Place] | rt.Done = iter51.next(); - if (_2034 === rt.DONE) { + const _2034: [rs.usize, rs.Place] | rs.Done = iter51.next(); + if (_2034 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_2034[0], 7), _2034[1].v); + scribbleWords(rs.usizeAdd(_2034[0], 7), _2034[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held8.items), (p38: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held8.items), (p38: rs.u16[]): rs.u8 => { return sumWords(p38); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumWords(words.items)); - const iter52: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceSplitnMut(pairs.items, n6, testPairs)); + rs.byteVecPush(out, sumWords(words.items)); + const iter52: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceSplitnMut(pairs.items, n6, testPairs)); while (true) { - const _2061: [rt.usize, Pair.Pair[]] | rt.Done = iter52.next(); - if (_2061 === rt.DONE) { + const _2061: [rs.usize, Pair.Pair[]] | rs.Done = iter52.next(); + if (_2061 === rs.DONE) { break; } scribblePairs(_2061[0], _2061[1]); } flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const held9: rt.Vec = rt.iterToVec(rt.sliceSplitnMut(pairs.items, n6, testPairs), "next", 8); - const iter53: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held9.items))); + rs.byteVecPush(out, sumPairs(pairs.items)); + const held9: rs.Vec = rs.iterToVec(rs.sliceSplitnMut(pairs.items, n6, testPairs), "next", 8); + const iter53: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held9.items))); while (true) { - const _2083: [rt.usize, rt.Place] | rt.Done = iter53.next(); - if (_2083 === rt.DONE) { + const _2083: [rs.usize, rs.Place] | rs.Done = iter53.next(); + if (_2083 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_2083[0], 7), _2083[1].v); + scribblePairs(rs.usizeAdd(_2083[0], 7), _2083[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held9.items), (p39: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held9.items), (p39: Pair.Pair[]): rs.u8 => { return sumPairs(p39); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sumPairs(pairs.items)); - const iter54: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceRsplitn(rt.byteVecSlice(bytes), n6, test)); + rs.byteVecPush(out, sumPairs(pairs.items)); + const iter54: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceRsplitn(rs.byteVecSlice(bytes), n6, test)); while (true) { - const _2110: [rt.usize, rt.ByteSlice] | rt.Done = iter54.next(); - if (_2110 === rt.DONE) { + const _2110: [rs.usize, rs.ByteSlice] | rs.Done = iter54.next(); + if (_2110 === rs.DONE) { break; } scribble(_2110[0], _2110[1]); } flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); - const held10: rt.Vec = rt.iterToVec(rt.byteSliceRsplitn(rt.byteVecSlice(bytes), n6, test), "next", 8); - const iter55: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10.items))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); + const held10: rs.Vec = rs.iterToVec(rs.byteSliceRsplitn(rs.byteVecSlice(bytes), n6, test), "next", 8); + const iter55: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held10.items))); while (true) { - const _2132: [rt.usize, rt.Place] | rt.Done = iter55.next(); - if (_2132 === rt.DONE) { + const _2132: [rs.usize, rs.Place] | rs.Done = iter55.next(); + if (_2132 === rs.DONE) { break; } - scribble(rt.usizeAdd(_2132[0], 7), _2132[1].v); + scribble(rs.usizeAdd(_2132[0], 7), _2132[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10.items), (p40: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held10.items), (p40: rs.ByteSlice): rs.u8 => { return sum(p40); }), undefined, true); flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); } else { - const below: (a0: rt.u8) => Below.Below = (tag: rt.u8): Below.Below => { + const below: (a0: rs.u8) => Below.Below = (tag: rs.u8): Below.Below => { return new Below.Below(tag, bound, log); }; const captured = below(224); - const it36: rt.Iter = rt.byteSliceSplit(data, rt.closure((_210: rt.u8): boolean => { + const it36: rs.Iter = rs.byteSliceSplit(data, rs.closure((_210: rs.u8): boolean => { return Below.test(captured, _210); }, (): void => { captured[Symbol.dispose](); })); - rt.iterExtendBytes(out, rt.iterOption(option_map$1uuzv15(rt.iterToOption(it36.next()), sum)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0x0c7ki(rs.iterToOption(it36.next()), sum)), undefined, true); flush(log, out); - rt.drop(it36); + rs.drop(it36); flush(log, out); const captured2 = below(225); - const iter56: rt.Iter = rt.byteSliceRsplit(data, rt.closure((_213: rt.u8): boolean => { + const iter56: rs.Iter = rs.byteSliceRsplit(data, rs.closure((_213: rs.u8): boolean => { return Below.test(captured2, _213); }, (): void => { captured2[Symbol.dispose](); })); while (true) { - const _2172: rt.ByteSlice | rt.Done = iter56.next(); - if (_2172 === rt.DONE) { + const _2172: rs.ByteSlice | rs.Done = iter56.next(); + if (_2172 === rs.DONE) { break; } - rt.byteVecPush(out, sum(_2172)); + rs.byteVecPush(out, sum(_2172)); flush(log, out); } - rt.drop(iter56); + rs.drop(iter56); flush(log, out); const captured3 = below(226); - const all: rt.Vec = rt.iterToVec(rt.byteSliceSplitInclusive(data, rt.closure((_214: rt.u8): boolean => { + const all: rs.Vec = rs.iterToVec(rs.byteSliceSplitInclusive(data, rs.closure((_214: rs.u8): boolean => { return Below.test(captured3, _214); }, (): void => { captured3[Symbol.dispose](); })), "next", 8); flush(log, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(all.items), (p36: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(all.items), (p36: rs.ByteSlice): rs.u8 => { return sum(p36); }), undefined, true); const captured4 = below(227); - rt.byteVecPush(out, rt.ownedCount(rt.byteSliceSplitn(data, 2, rt.closure((_215: rt.u8): boolean => { + rs.byteVecPush(out, rs.ownedCount(rs.byteSliceSplitn(data, 2, rs.closure((_215: rs.u8): boolean => { return Below.test(captured4, _215); }, (): void => { captured4[Symbol.dispose](); }))) & 0xff); flush(log, out); const sep5: Below.Below = below(228); - const _2206: rt.ByteSlice = rt.byteVecSlice(bytes); + const _2206: rs.ByteSlice = rs.byteVecSlice(bytes); const captured5 = sep5; - const iter57: rt.Iter = rt.byteSliceRsplitn(_2206, 3, rt.closure((_218: rt.u8): boolean => { + const iter57: rs.Iter = rs.byteSliceRsplitn(_2206, 3, rs.closure((_218: rs.u8): boolean => { return Below.test(captured5, _218); }, (): void => { captured5[Symbol.dispose](); })); while (true) { - const _2210: rt.ByteSlice | rt.Done = iter57.next(); - if (_2210 === rt.DONE) { + const _2210: rs.ByteSlice | rs.Done = iter57.next(); + if (_2210 === rs.DONE) { break; } scribble(1, _2210); } - rt.drop(iter57); + rs.drop(iter57); flush(log, out); - rt.byteVecPush(out, sum(rt.byteVecSlice(bytes))); + rs.byteVecPush(out, sum(rs.byteVecSlice(bytes))); } } } diff --git a/ts/fixtures/lang/shapes/brands.ts b/ts/fixtures/lang/shapes/brands.ts index 17f935230..26a41fb13 100644 --- a/ts/fixtures/lang/shapes/brands.ts +++ b/ts/fixtures/lang/shapes/brands.ts @@ -2,22 +2,22 @@ // `@ts-expect-error` fails the type check if it is accepted. A plain number, such as a // literal, passes for any integer type, and a cast picks one. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Meters from "./shapes.Meters.ts"; import * as Point from "./shapes.Point.ts"; import { returnedNever, tailBreak } from "./shapes.ts"; -export function mixed(data: rt.ByteSlice): void { +export function mixed(data: rs.ByteSlice): void { returnedNever(7, 1); - const meters: Meters.Meters = { _0: tailBreak(data) as rt.u64 }; + const meters: Meters.Meters = { _0: tailBreak(data) as rs.u64 }; // @ts-expect-error A `u16` is not a `u8`. returnedNever(tailBreak(data), 1); // @ts-expect-error A `u32` is not a `usize`. - returnedNever(1, 0xffffffff as rt.u32); + returnedNever(1, 0xffffffff as rs.u32); // @ts-expect-error A `u64` is not a `u8`, even as a number. returnedNever(Meters.area(meters), 1); // @ts-expect-error An `i64` is not a `u64`. - Meters.area({ _0: rt.i64Of(9223372036854775807n) }); + Meters.area({ _0: rs.i64Of(9223372036854775807n) }); // @ts-expect-error A `u32` is not an `i32`. - Point.new(0xffffffff as rt.u32, 0); + Point.new(0xffffffff as rs.u32, 0); } diff --git a/ts/fixtures/lang/shapes/caller.ts b/ts/fixtures/lang/shapes/caller.ts index 1854135d6..1ad079026 100644 --- a/ts/fixtures/lang/shapes/caller.ts +++ b/ts/fixtures/lang/shapes/caller.ts @@ -4,26 +4,26 @@ import * as Fault from "./fmt.Fault.ts"; import { be, edges, op, ops as picks, run as harness } from "./lang.ts"; -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The bytes that pick each case, and a `Fault`'s first byte. */ export const ops = new Map([...picks, ["fmt::Fault", Uint8Array.of(0xff)]]); -export function run(input: rt.ByteSlice): rt.ByteVec { - if (rt.byteSliceFirst(input) !== 0xff) return harness(input); - const fault = Fault.new(rt.byteSliceRange(input, 1)); - const display: rt.Fmt = (f) => Fault.fmt$fmt_Display(fault, f); - const debug: rt.Fmt = (f) => Fault.fmt$fmt_Debug(fault, f); - const text = rt.fmtFormat([ +export function run(input: rs.ByteSlice): rs.ByteVec { + if (rs.byteSliceFirst(input) !== 0xff) return harness(input); + const fault = Fault.new(rs.byteSliceRange(input, 1)); + const display: rs.Fmt = (f) => Fault.fmt$fmt_Display(fault, f); + const debug: rs.Fmt = (f) => Fault.fmt$fmt_Debug(fault, f); + const text = rs.fmtFormat([ display, "|", - rt.fmtSpec({ align: ">", width: 16 }, display), + rs.fmtSpec({ align: ">", width: 16 }, display), "|", debug, "|", - rt.fmtSpec({ alternate: true }, debug), + rs.fmtSpec({ alternate: true }, debug), ]); - return rt.byteVecFrom(new TextEncoder().encode(text)); + return rs.byteVecFrom(new TextEncoder().encode(text)); } /** `shapes::loops` with each first byte that one of its cases of `!` takes, with one more byte and without. */ diff --git a/ts/fixtures/lang/shapes/expected/core/bool.ts b/ts/fixtures/lang/shapes/expected/core/bool.ts index 54db173c0..57ba2790b 100644 --- a/ts/fixtures/lang/shapes/expected/core/bool.ts +++ b/ts/fixtures/lang/shapes/expected/core/bool.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Pair from "../fmt.Pair.ts"; import type * as Void from "../shapes.Void.ts"; -export function thenSome$0ztng9q(self: boolean, t: rt.Result): rt.Result | undefined { +export function thenSome$1uv8pdy(self: boolean, t: rs.Result): rs.Result | undefined { if (!self) { return undefined; } @@ -18,42 +18,42 @@ export function thenSome$1ou04rm(self: boolean, t: Pair.Pair): Pair.Pair | undef return t; } -export function thenSome$0n2gkz4(self: boolean, t: rt.i32): rt.i32 | undefined { +export function thenSome$05ku0zn(self: boolean, t: rs.i32): rs.i32 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$0d5am30(self: boolean, t: rt.u8): rt.u8 | undefined { +export function thenSome$0quywni(self: boolean, t: rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return t; } -export function then$1he9dd4(self: boolean, _: () => rt.Vec): rt.Vec | undefined { +export function then$01xsbgy(self: boolean, _: () => rs.Vec): rs.Vec | undefined { if (!self) { return undefined; } - return new rt.Vec(); + return new rs.Vec(); } -export function then$1i9qaz4(self: boolean, _: () => rt.ByteVec): rt.ByteVec | undefined { +export function then$0y7on52(self: boolean, _: () => rs.ByteVec): rs.ByteVec | undefined { if (!self) { return undefined; } - return new rt.ByteVec(); + return new rs.ByteVec(); } -export function then$1btzga3(self: boolean, f: () => rt.u8): rt.u8 | undefined { +export function then$1ldvmdq(self: boolean, f: () => rs.u8): rs.u8 | undefined { if (!self) { return undefined; } return f(); } -export function then$0uwf92a(self: boolean, f: () => rt.usize): rt.usize | undefined { +export function then$1uoo7un(self: boolean, f: () => rs.usize): rs.usize | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/shapes/expected/core/option.ts b/ts/fixtures/lang/shapes/expected/core/option.ts index f452c8f21..a836601c1 100644 --- a/ts/fixtures/lang/shapes/expected/core/option.ts +++ b/ts/fixtures/lang/shapes/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Ticked from "../generics.Ticked.ts"; import { from$convert_From_shapes_Dir_u8 } from "../shapes.ts"; import type * as Dir from "../shapes.Dir.ts"; @@ -8,42 +8,42 @@ import type * as Meters from "../shapes.Meters.ts"; import type * as Point from "../shapes.Point.ts"; import type * as Shape from "../shapes.Shape.ts"; -export function unwrapOr$0k15iai(self: rt.char | undefined, default_: rt.char): rt.char { +export function unwrapOr$04rqm9m(self: rs.char | undefined, default_: rs.char): rs.char { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function unwrapOrDefault$0301ewp(self: rt.ByteSlice | undefined): rt.ByteSlice { +export function unwrapOrDefault$0avqj0t(self: rs.ByteSlice | undefined): rs.ByteSlice { if (self === undefined) { - return rt.byteSliceFrom(new Uint8Array(0)); + return rs.byteSliceFrom(new Uint8Array(0)); } return self; } -export function unwrapOrDefault$001fvl5(self: rt.u16 | undefined): rt.u16 { +export function unwrapOrDefault$0w7995p(self: rs.u16 | undefined): rs.u16 { if (self === undefined) { return 0; } return self; } -export function unwrapOrDefault$1q0ps0j(self: rt.u8 | undefined): rt.u8 { +export function unwrapOrDefault$03apme8(self: rs.u8 | undefined): rs.u8 { if (self === undefined) { return 0; } return self; } -export function map$0zbvahh(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.Vec): rt.Vec | undefined { +export function map$0ggarad(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.Vec): rs.Vec | undefined { if (self === undefined) { return undefined; } @@ -57,88 +57,88 @@ export function map$0600mq0(self: Dir.Dir | undefined, f: (a0: Dir.Dir) => Shape return f(self); } -export function map$18z3v8h(self: Dir.Dir | undefined, _: (a0: Dir.Dir) => rt.u8): rt.u8 | undefined { +export function map$1mgv9ns(self: Dir.Dir | undefined, _: (a0: Dir.Dir) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return from$convert_From_shapes_Dir_u8(self); } -export function map$0phsnvg(self: rt.u8 | undefined, _: (a0: rt.u8) => rt.u8 | undefined): rt.u8 | undefined | rt.None { +export function map$02rrcvu(self: rs.u8 | undefined, _: (a0: rs.u8) => rs.u8 | undefined): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return self; } -export function mapOr$1a3irjf(self: rt.ByteVec | undefined, default_: rt.u8, f: (a0: rt.ByteVec) => rt.u8): rt.u8 { +export function mapOr$0g5x999(self: rs.ByteVec | undefined, default_: rs.u8, f: (a0: rs.ByteVec) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1t0muvr(self: rt.u8 | undefined, default_: rt.usize, f: (a0: rt.u8) => rt.usize): rt.usize { +export function mapOr$1d4bp7c(self: rs.u8 | undefined, default_: rs.usize, f: (a0: rs.u8) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1ybqvup(self: Meters.Meters | undefined, default_: rt.u64, f: (a0: Meters.Meters) => rt.u64): rt.u64 { +export function mapOr$04kaubd(self: Meters.Meters | undefined, default_: rs.u64, f: (a0: Meters.Meters) => rs.u64): rs.u64 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0rtdylj(self: Point.Point | undefined, default_: rt.u8, f: (a0: Point.Point) => rt.u8): rt.u8 { +export function mapOr$092ozr9(self: Point.Point | undefined, default_: rs.u8, f: (a0: Point.Point) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0aserv9(self: Shape.Shape | undefined, default_: rt.u8, f: (a0: Shape.Shape) => rt.u8): rt.u8 { +export function mapOr$04m3h1l(self: Shape.Shape | undefined, default_: rs.u8, f: (a0: Shape.Shape) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1hjjwvv(self: [rt.Mutex, rt.u8] | undefined, default_: rt.u8, f: (a0: [rt.Mutex, rt.u8]) => rt.u8): rt.u8 { +export function mapOr$1c3pipy(self: [rs.Mutex, rs.u8] | undefined, default_: rs.u8, f: (a0: [rs.Mutex, rs.u8]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function okOr$1vxk0yk(self: rt.u8 | undefined, err: rt.u8): rt.Result { +export function okOr$1j8owgb(self: rs.u8 | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } -export function andThen$1bd14ex(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u8 | undefined | rt.None): rt.u8 | undefined | rt.None { +export function andThen$0jc4o0i(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u8 | undefined | rs.None): rs.u8 | undefined | rs.None { if (self === undefined) { - return rt.None; + return rs.None; } return f(self); } -export function clone$11qe8jq(self: rt.Vec | undefined): rt.Vec | undefined { +export function clone$14vwxlf(self: rs.Vec | undefined): rs.Vec | undefined { if (self === undefined) { return undefined; } - return rt.vecFrom(self.items.slice()); + return rs.vecFrom(self.items.slice()); } -export function clone$1grnave(self: rt.ByteVec | undefined): rt.ByteVec | undefined { +export function clone$0e53k5z(self: rs.ByteVec | undefined): rs.ByteVec | undefined { if (self === undefined) { return undefined; } - return rt.byteVecFrom(rt.byteVecView(self)); + return rs.byteVecFrom(rs.byteVecView(self)); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/lang/shapes/expected/core/result.ts b/ts/fixtures/lang/shapes/expected/core/result.ts index 635a98a43..45dd0032f 100644 --- a/ts/fixtures/lang/shapes/expected/core/result.ts +++ b/ts/fixtures/lang/shapes/expected/core/result.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function map$1dbyvzi(self: rt.Result, op: (a0: rt.u8) => rt.u8): rt.Result { +export function map$1yblbjf(self: rs.Result, op: (a0: rs.u8) => rs.u8): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } return self; } -export function mapErr$0dzqwjy(self: rt.Result, op: (a0: string) => rt.u8): rt.Result { +export function mapErr$0hqg57m(self: rs.Result, op: (a0: string) => rs.u8): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } //# sourceMappingURL=result.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Bare.ts b/ts/fixtures/lang/shapes/expected/fmt.Bare.ts index 037f449c0..efb90e10f 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Bare.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Bare.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Bare, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Bare"); +export function fmt$fmt_Debug(_self: Bare, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Bare"); } export function eq$cmp_PartialEq(_self: Bare, _other: Bare): boolean { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Braced.ts b/ts/fixtures/lang/shapes/expected/fmt.Braced.ts index 9bed138d5..1768628e5 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Braced.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Braced.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Braced, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Braced"); +export function fmt$fmt_Debug(_self: Braced, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Braced"); } export function eq$cmp_PartialEq(_self: Braced, _other: Braced): boolean { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts index 0969c634c..738829a72 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Capped.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Capped.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A writer of the crate's own that fails a `write_str` past `cap` bytes, and counts each. */ export interface Capped { text: string; - calls: rt.u8; - cap: rt.usize; + calls: rs.u8; + cap: rs.usize; } -export function writeStr$fmt_Write(self: Capped, s: string): rt.Result { - self.calls = rt.u8Add(self.calls, 1); - if (!(rt.usizeAdd(rt.stringLen(self.text), rt.stringLen(s)) > self.cap)) { - const iter: rt.Iter = rt.strChars(s); +export function writeStr$fmt_Write(self: Capped, s: string): rs.Result { + self.calls = rs.u8Add(self.calls, 1); + if (!(rs.usizeAdd(rs.stringLen(self.text), rs.stringLen(s)) > self.cap)) { + const iter: rs.Iter = rs.strChars(s); while (true) { - const _14: rt.char | rt.Done = iter.next(); - if (_14 === rt.DONE) { + const _14: rs.char | rs.Done = iter.next(); + if (_14 === rs.DONE) { break; } self.text = self.text + String.fromCodePoint(_14); } - return rt.OK; + return rs.OK; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } //# sourceMappingURL=fmt.Capped.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Clip.ts b/ts/fixtures/lang/shapes/expected/fmt.Clip.ts index 760bd76ec..7fbe2cb0c 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Clip.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Clip.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `Debug` that pads its text, so a width and precision passed to it show, and marks `#`. */ export interface Clip { _0: string; } -export function fmt$fmt_Debug(self: Clip, f: rt.Formatter): rt.Result { - if (rt.fmtAlternate(f)) { - if (!rt.fmtWriteStr(f, "#").ok) { - return rt.Err(new rt.FmtError()); +export function fmt$fmt_Debug(self: Clip, f: rs.Formatter): rs.Result { + if (rs.fmtAlternate(f)) { + if (!rs.fmtWriteStr(f, "#").ok) { + return rs.Err(new rs.FmtError()); } } - return rt.fmtPad(f, self._0); + return rs.fmtPad(f, self._0); } //# sourceMappingURL=fmt.Clip.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts index a067730b6..d6891dc28 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Countdown.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Countdown, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Countdown, f: rs.Formatter): rs.Result { const _3: string = "Countdown"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } /** @@ -13,16 +13,16 @@ export function fmt$fmt_Debug(self: Countdown, f: rt.Formatter): rt.Result>; + tag: rs.u8; + log: rs.Arc>; - constructor(tag: rt.u8, log: rt.Arc>) { + constructor(tag: rs.u8, log: rs.Arc>) { this.tag = tag; this.log = log; } @@ -18,20 +18,20 @@ export class Dropper { } } -export function fmt$fmt_Debug(self: Dropper, f: rt.Formatter): rt.Result { - return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.fmtDebugStruct(f, "Dropper"), "tag", (f: rt.Formatter) => rt.u8Debug(self.tag, f))); +export function fmt$fmt_Debug(self: Dropper, f: rs.Formatter): rs.Result { + return rs.debugStructFinishNonExhaustive(rs.debugStructField(rs.fmtDebugStruct(f, "Dropper"), "tag", (f: rs.Formatter) => rs.u8Debug(self.tag, f))); } -export function fmt$fmt_Display(self: Dropper, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Dropper, f: rs.Formatter): rs.Result { const arg = self.tag; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - return rt.fmtPad(f, rt.fmtFormat(["n", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + return rs.fmtPad(f, rs.fmtFormat(["n", args2[0]])); } export function drop$ops_Drop(self: Dropper): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.tag); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.tag); + rs.refMutRelease(_5); } //# sourceMappingURL=fmt.Dropper.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Fails.ts b/ts/fixtures/lang/shapes/expected/fmt.Fails.ts index 41495d26d..607af5968 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Fails.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Fails.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `Display` that fails after writing, for odd values. */ export interface Fails { - _0: rt.u8; + _0: rs.u8; } -export function fmt$fmt_Display(self: Fails, f: rt.Formatter): rt.Result { - if (!(rt.u8Rem(self._0, 2) === 0)) { +export function fmt$fmt_Display(self: Fails, f: rs.Formatter): rs.Result { + if (!(rs.u8Rem(self._0, 2) === 0)) { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - if (rt.fmtWriteFmt(f, ["half ", args2[0]]).ok) { - return rt.Err(new rt.FmtError()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + if (rs.fmtWriteFmt(f, ["half ", args2[0]]).ok) { + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.fmtWriteStr(f, "fine"); + return rs.fmtWriteStr(f, "fine"); } //# sourceMappingURL=fmt.Fails.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts index 94c8558a9..dbc65dd04 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Fault.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Fault.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Pair from "./fmt.Pair.ts"; -export function fmt$fmt_Debug(self: Fault, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Fault, f: rs.Formatter): rs.Result { if (self.tag === "Short") { - return rt.fmtWriteStr(f, "Short"); + return rs.fmtWriteStr(f, "Short"); } if (self.tag === "Code") { const _6: string = "Code"; - const _7: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _6), _7)); + const _7: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _6), _7)); } if (self.tag === "TooLarge") { const _11: string = "TooLarge"; const _12: string = "size"; - const _13: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self.size, f); + const _13: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.size, f); const _14: string = "max"; - const _15: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self.max, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _11), _12, _13), _14, _15)); + const _15: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self.max, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _11), _12, _13), _14, _15)); } const _18: string = "At"; - const _19: rt.Fmt = (f: rt.Formatter) => Pair.fmt$fmt_Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _18), _19)); + const _19: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _18), _19)); } /** @@ -32,37 +32,37 @@ export function fmt$fmt_Debug(self: Fault, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Fault, f: rs.Formatter): rs.Result { if (self.tag === "Short") { - return rt.fmtPad(f, "short buffer"); + return rs.fmtPad(f, "short buffer"); } if (self.tag === "Code") { const arg4 = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16LowerHex(arg4, f)]; - return rt.fmtWriteFmt(f, ["code=", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, args2[0])]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16LowerHex(arg4, f)]; + return rs.fmtWriteFmt(f, ["code=", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, args2[0])]); } if (self.tag === "TooLarge") { const arg2 = self.size; - const _20: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(arg2, f); + const _20: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg2, f); const arg3 = self.max; - const args4: rt.Fmt[] = [_20, (f: rt.Formatter) => rt.usizeDisplay(arg3, f)]; - return rt.fmtWriteFmt(f, [args4[0], " bytes exceeds the ", args4[1], " byte limit"]); + const args4: rs.Fmt[] = [_20, (f: rs.Formatter) => rs.usizeDisplay(arg3, f)]; + return rs.fmtWriteFmt(f, [args4[0], " bytes exceeds the ", args4[1], " byte limit"]); } const arg = self._0; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Pair.fmt$fmt_Debug(arg, f)]; - return rt.fmtWriteFmt(f, ["at ", args6[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Pair.fmt$fmt_Debug(arg, f)]; + return rs.fmtWriteFmt(f, ["at ", args6[0]]); } /** The fault `data` picks. */ -function new_(data: rt.ByteSlice): Fault { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +function new_(data: rs.ByteSlice): Fault { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _3: rt.u8 = rt.u8Rem(at(0), 4); + const _3: rs.u8 = rs.u8Rem(at(0), 4); if (_3 === 0) { return { tag: "Short" } as Fault; } @@ -70,9 +70,9 @@ function new_(data: rt.ByteSlice): Fault { return { tag: "Code", _0: (at(1) << 8) | at(2) } as Fault; } if (_3 === 2) { - return { tag: "TooLarge", size: ((((at(1) as rt.usize) << 24) >>> 0) | at(2) as rt.usize) >>> 0, max: at(3) as rt.usize } as Fault; + return { tag: "TooLarge", size: ((((at(1) as rs.usize) << 24) >>> 0) | at(2) as rs.usize) >>> 0, max: at(3) as rs.usize } as Fault; } - return { tag: "At", _0: { _0: at(1), _1: rt.i64Shl((at(2) << 24) >> 24 as rt.i64, 40) } } as Fault; + return { tag: "At", _0: { _0: at(1), _1: rs.i64Shl((at(2) << 24) >> 24 as rs.i64, 40) } } as Fault; } export { new_ as new }; diff --git a/ts/fixtures/lang/shapes/expected/fmt.Gauge.ts b/ts/fixtures/lang/shapes/expected/fmt.Gauge.ts index 8d22218ab..188c350c7 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Gauge.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Gauge.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Writes what its cell holds as it is written. */ export interface Gauge { - _0: rt.Cell; + _0: rs.Cell; } -export function fmt$fmt_Debug(self: Gauge, f: rt.Formatter): rt.Result { - const _5: rt.DebugTuple = rt.fmtDebugTuple(f, "Gauge"); - const _9: rt.u8 = self._0.v; - return rt.debugTupleFinish(rt.debugTupleField(_5, (f: rt.Formatter) => rt.u8Debug(_9, f))); +export function fmt$fmt_Debug(self: Gauge, f: rs.Formatter): rs.Result { + const _5: rs.DebugTuple = rs.fmtDebugTuple(f, "Gauge"); + const _9: rs.u8 = self._0.v; + return rs.debugTupleFinish(rs.debugTupleField(_5, (f: rs.Formatter) => rs.u8Debug(_9, f))); } //# sourceMappingURL=fmt.Gauge.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Hex.ts b/ts/fixtures/lang/shapes/expected/fmt.Hex.ts index f0fc2273d..74f6d0d2d 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Hex.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Hex.ts @@ -1,43 +1,43 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `Display` written with `write!`, which ignores the outer options, unless `#`. */ export interface Hex { - _0: rt.u32; + _0: rs.u32; } -export function fmt$fmt_Binary(self: Hex, f: rt.Formatter): rt.Result { - return rt.u32Binary(self._0, f); +export function fmt$fmt_Binary(self: Hex, f: rs.Formatter): rs.Result { + return rs.u32Binary(self._0, f); } -export function fmt$fmt_Octal(self: Hex, f: rt.Formatter): rt.Result { +export function fmt$fmt_Octal(self: Hex, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Octal(arg, f)]; - return rt.fmtWriteFmt(f, [args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Octal(arg, f)]; + return rs.fmtWriteFmt(f, [args2[0]]); } -export function fmt$fmt_LowerExp(self: Hex, f: rt.Formatter): rt.Result { - return rt.u32LowerExp(self._0, f); +export function fmt$fmt_LowerExp(self: Hex, f: rs.Formatter): rs.Result { + return rs.u32LowerExp(self._0, f); } -export function fmt$fmt_UpperExp(self: Hex, f: rt.Formatter): rt.Result { - return rt.u32UpperExp(self._0, f); +export function fmt$fmt_UpperExp(self: Hex, f: rs.Formatter): rs.Result { + return rs.u32UpperExp(self._0, f); } -export function fmt$fmt_Display(self: Hex, f: rt.Formatter): rt.Result { - if (!rt.fmtAlternate(f)) { +export function fmt$fmt_Display(self: Hex, f: rs.Formatter): rs.Result { + if (!rs.fmtAlternate(f)) { const arg2 = self._0; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32LowerHex(arg2, f)]; - return rt.fmtWriteFmt(f, [args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerHex(arg2, f)]; + return rs.fmtWriteFmt(f, [args4[0]]); } const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32LowerHex(arg, f)]; - return rt.fmtWriteFmt(f, [rt.fmtSpec({ alternate: true }, args2[0])]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerHex(arg, f)]; + return rs.fmtWriteFmt(f, [rs.fmtSpec({ alternate: true }, args2[0])]); } -export function fmt$fmt_Debug(self: Hex, f: rt.Formatter): rt.Result { - return rt.u32Display(self._0, f); +export function fmt$fmt_Debug(self: Hex, f: rs.Formatter): rs.Result { + return rs.u32Display(self._0, f); } //# sourceMappingURL=fmt.Hex.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Kind.ts b/ts/fixtures/lang/shapes/expected/fmt.Kind.ts index d7f3c6939..c5ee522fa 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Kind.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Kind.ts @@ -1,35 +1,35 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Kind, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Kind, f: rs.Formatter): rs.Result { if (self.tag === "Empty") { - return rt.fmtWriteStr(f, "Empty"); + return rs.fmtWriteStr(f, "Empty"); } if (self.tag === "Braced") { - return rt.fmtWriteStr(f, "Braced"); + return rs.fmtWriteStr(f, "Braced"); } if (self.tag === "Bare") { - return rt.fmtWriteStr(f, "Bare"); + return rs.fmtWriteStr(f, "Bare"); } if (self.tag === "One") { const _8: string = "One"; - const _9: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _8), _9)); + const _9: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _8), _9)); } const _13: string = "Many"; const _14: string = "count"; - const _15: rt.Fmt = (f: rt.Formatter) => rt.u32Debug(self.count, f); + const _15: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self.count, f); const _16: string = "items"; - const _17: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.items), f, rt.u8Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _13), _14, _15), _16, _17)); + const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.items), f, rs.u8Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _13), _14, _15), _16, _17)); } export type Kind = | { tag: "Empty" } | { tag: "Braced" } | { tag: "Bare" } - | { tag: "One"; _0: rt.u8 } - | { tag: "Many"; count: rt.u32; items: rt.ByteVec }; + | { tag: "One"; _0: rs.u8 } + | { tag: "Many"; count: rs.u32; items: rs.ByteVec }; //# sourceMappingURL=fmt.Kind.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts b/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts index 936f0e973..ae37d4ca1 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Lettered.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `Display` through a `Formatter`'s `write_char`, `pad`, and `write!`. */ export interface Lettered { - _0: rt.char; + _0: rs.char; } -export function fmt$fmt_Display(self: Lettered, f: rt.Formatter): rt.Result { - if (rt.fmtWriteChar(f, self._0).ok) { - if (rt.fmtPad(f, "xy").ok) { +export function fmt$fmt_Display(self: Lettered, f: rs.Formatter): rs.Result { + if (rs.fmtWriteChar(f, self._0).ok) { + if (rs.fmtPad(f, "xy").ok) { const arg = self._0; - const _16: rt.Fmt = (f: rt.Formatter) => rt.fmtCharDisplay(arg, f); + const _16: rs.Fmt = (f: rs.Formatter) => rs.fmtCharDisplay(arg, f); const arg2 = self._0; - const args2: rt.Fmt[] = [_16, (f: rt.Formatter) => rt.fmtCharDisplay(arg2, f)]; - return rt.fmtWriteFmt(f, [args2[0], rt.fmtSpec({ align: ">", width: 3 }, args2[1])]); + const args2: rs.Fmt[] = [_16, (f: rs.Formatter) => rs.fmtCharDisplay(arg2, f)]; + return rs.fmtWriteFmt(f, [args2[0], rs.fmtSpec({ align: ">", width: 3 }, args2[1])]); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } //# sourceMappingURL=fmt.Lettered.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Log.ts b/ts/fixtures/lang/shapes/expected/fmt.Log.ts index dc68f2c49..f410c4458 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Log.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Log.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A writer of the crate's own that logs each call std makes to it, a `write_str` by `s` and @@ -8,39 +8,39 @@ import * as rt from "./rt.ts"; */ export interface Log { text: string; - budget: rt.usize; + budget: rs.usize; } -function new_(budget: rt.usize): Log { +function new_(budget: rs.usize): Log { return { text: "", budget }; } -export function open(self: Log, kind: rt.char): rt.Result { +export function open(self: Log, kind: rs.char): rs.Result { if (!(self.budget === 0)) { - self.budget = rt.usizeSub(self.budget, 1); + self.budget = rs.usizeSub(self.budget, 1); self.text = self.text + String.fromCodePoint(kind); - return rt.OK; + return rs.OK; } self.text = self.text + "!"; - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } -export function writeStr$fmt_Write(self: Log, s: string): rt.Result { +export function writeStr$fmt_Write(self: Log, s: string): rs.Result { if (open(self, 115).ok) { self.text = self.text + s; self.text = self.text + "\u0001"; - return rt.OK; + return rs.OK; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } -export function writeChar$fmt_Write(self: Log, c: rt.char): rt.Result { +export function writeChar$fmt_Write(self: Log, c: rs.char): rs.Result { if (open(self, 99).ok) { self.text = self.text + String.fromCodePoint(c); self.text = self.text + "\u0001"; - return rt.OK; + return rs.OK; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } export { new_ as new }; diff --git a/ts/fixtures/lang/shapes/expected/fmt.Manual.ts b/ts/fixtures/lang/shapes/expected/fmt.Manual.ts index 28fd7cf8d..3d2fd5528 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Manual.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Manual.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** The builders, written out. */ export interface Manual { - id: rt.u8; - list: rt.Vec; + id: rs.u8; + list: rs.Vec; } -export function fmt$fmt_Debug(self: Manual, f: rt.Formatter): rt.Result { - return rt.debugStructFinishNonExhaustive(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, "Manual"), "id", (f: rt.Formatter) => rt.u8Debug(self.id, f)), "list", (f: rt.Formatter) => rt.fmtList(self.list.items, f, rt.u16Debug))); +export function fmt$fmt_Debug(self: Manual, f: rs.Formatter): rs.Result { + return rs.debugStructFinishNonExhaustive(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, "Manual"), "id", (f: rs.Formatter) => rs.u8Debug(self.id, f)), "list", (f: rs.Formatter) => rs.fmtList(self.list.items, f, rs.u16Debug))); } //# sourceMappingURL=fmt.Manual.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts index e11490869..012bb94f7 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Nested.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Nested.ts @@ -1,30 +1,30 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Kind from "./fmt.Kind.ts"; import * as Pair from "./fmt.Pair.ts"; import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; -export function fmt$fmt_Debug(self: Nested, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Nested, f: rs.Formatter): rs.Result { const names: string[] = ["name", "point", "shape", "tags", "pairs", "maybe", "none", "result", "list", "tuple", "single", "empty", "unit", "boxed"]; - const values: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(self.name, f), (f: rt.Formatter) => Point.fmt$fmt_Debug(self.point, f), (f: rt.Formatter) => Shape.fmt$fmt_Debug(self.shape, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.tags), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.maybe, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(self.none, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtResult(self.result, f, rt.u8Debug, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(self.list, f, rt.i16Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(self.tuple[0], f), (f: rt.Formatter) => rt.fmtBool(self.tuple[1], f), (f: rt.Formatter) => rt.fmtStr(self.tuple[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(self.single[0], f)], f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(self.empty), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtUnit(self.unit, f), (f: rt.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]; - return rt.fmtDebugStructFields(f, "Nested", names, values); + const values: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(self.name, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(self.point, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.shape, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.tags), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(self.pairs.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.maybe, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(self.none, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtResult(self.result, f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(self.list, f, rs.i16Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.tuple[0], f), (f: rs.Formatter) => rs.fmtBool(self.tuple[1], f), (f: rs.Formatter) => rs.fmtStr(self.tuple[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(self.single[0], f)], f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(self.empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtUnit(self.unit, f), (f: rs.Formatter) => Kind.fmt$fmt_Debug(self.boxed, f)]; + return rs.fmtDebugStructFields(f, "Nested", names, values); } export interface Nested { name: string; point: Point.Point; shape: Shape.Shape; - tags: rt.ByteVec; - pairs: rt.Vec; + tags: rs.ByteVec; + pairs: rs.Vec; maybe: Pair.Pair | undefined; - none: rt.u8 | undefined; - result: rt.Result; - list: rt.i16[]; - tuple: [rt.u8, boolean, string]; - single: [rt.u8]; - empty: rt.ByteVec; + none: rs.u8 | undefined; + result: rs.Result; + list: rs.i16[]; + tuple: [rs.u8, boolean, string]; + single: [rs.u8]; + empty: rs.ByteVec; unit: undefined; boxed: Kind.Kind; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.Noted.ts b/ts/fixtures/lang/shapes/expected/fmt.Noted.ts index b33d44023..0e0c237bf 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Noted.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Noted.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { note } from "./fmt.ts"; /** `Display` through `write!` of arguments with effects. */ export interface Noted { - _0: rt.u8; + _0: rs.u8; } -export function fmt$fmt_Display(self: Noted, f: rt.Formatter): rt.Result { - const log: rt.ByteVec = new rt.ByteVec(); - const _7: rt.u8 = note(log, self._0); +export function fmt$fmt_Display(self: Noted, f: rs.Formatter): rs.Result { + const log: rs.ByteVec = new rs.ByteVec(); + const _7: rs.u8 = note(log, self._0); const _11: boolean = note(log, 1) === self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_7, f), (f: rt.Formatter) => rt.fmtBool(_11, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(log), f, rt.u8Debug)]; - return rt.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_7, f), (f: rs.Formatter) => rs.fmtBool(_11, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(log), f, rs.u8Debug)]; + return rs.fmtWriteFmt(f, [args2[0], " ", args2[1], " ", args2[2]]); } //# sourceMappingURL=fmt.Noted.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Padded.ts b/ts/fixtures/lang/shapes/expected/fmt.Padded.ts index 8996e1c26..3a6405bd8 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Padded.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Padded.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** `Display` through `pad`, which keeps the options. */ export interface Padded { _0: string; } -export function fmt$fmt_Display(self: Padded, f: rt.Formatter): rt.Result { - const _3: rt.usize | undefined = rt.fmtWidth(f); +export function fmt$fmt_Display(self: Padded, f: rs.Formatter): rs.Result { + const _3: rs.usize | undefined = rs.fmtWidth(f); if (_3 !== undefined) { if (_3 > 20) { - return rt.fmtWriteStr(f, "wide"); + return rs.fmtWriteStr(f, "wide"); } } - return rt.fmtPad(f, self._0); + return rs.fmtPad(f, self._0); } //# sourceMappingURL=fmt.Padded.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Pair.ts b/ts/fixtures/lang/shapes/expected/fmt.Pair.ts index 552886046..052303dbb 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Pair.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Pair.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Pair, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Pair, f: rs.Formatter): rs.Result { const _3: string = "Pair"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - const _6: rt.Fmt = (f: rt.Formatter) => rt.i64Debug(self._1, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + const _6: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._1, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); } export function eq$cmp_PartialEq(self: Pair, other: Pair): boolean { if (!(self._0 === other._0)) { return false; } - return rt.i64Eq(self._1, other._1); + return rs.i64Eq(self._1, other._1); } export interface Pair { - _0: rt.u8; - _1: rt.i64; + _0: rs.u8; + _1: rs.i64; } //# sourceMappingURL=fmt.Pair.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Placed.ts b/ts/fixtures/lang/shapes/expected/fmt.Placed.ts index be0116bc9..3e5108ac3 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Placed.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Placed.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { literals$mut_fmt_Formatter, placed$mut_fmt_Formatter } from "./fmt.ts"; /** `Display` through a `Formatter` as a writer, which takes no options from the placeholder. */ export interface Placed { - _0: rt.u8; + _0: rs.u8; } -export function fmt$fmt_Display(self: Placed, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Placed, f: rs.Formatter): rs.Result { if (placed$mut_fmt_Formatter(f, self._0).ok) { return literals$mut_fmt_Formatter(f, 233); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } //# sourceMappingURL=fmt.Placed.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Seq.ts b/ts/fixtures/lang/shapes/expected/fmt.Seq.ts index 9cdbb3251..3202c64d5 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Seq.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Seq.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Pair from "./fmt.Pair.ts"; export interface Seq { - _0: rt.Vec; + _0: rs.Vec; } -export function fmt$fmt_Debug(self: Seq, f: rt.Formatter): rt.Result { - const _5: rt.DebugList = rt.fmtDebugList(f); - const _6: rt.Iter = rt.iterSlice(self._0.items); - return rt.debugListFinish(rt.debugListEntries(_5, _6, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))); +export function fmt$fmt_Debug(self: Seq, f: rs.Formatter): rs.Result { + const _5: rs.DebugList = rs.fmtDebugList(f); + const _6: rs.Iter = rs.iterSlice(self._0.items); + return rs.debugListFinish(rs.debugListEntries(_5, _6, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))); } //# sourceMappingURL=fmt.Seq.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Setter.ts b/ts/fixtures/lang/shapes/expected/fmt.Setter.ts index 285b30fbd..5bcb9d5d0 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Setter.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Setter.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Log from "./fmt.Log.ts"; /** A [`Log`] that sets or forces each of the cells it holds as it is given `trigger`. */ export interface Setter { log: Log.Log; trigger: string; - cell: rt.Cell; - once: rt.OnceCell; - lazy: rt.LazyCell; - lock: rt.OnceLock; - forced: rt.LazyLock; + cell: rs.Cell; + once: rs.OnceCell; + lazy: rs.LazyCell; + lock: rs.OnceLock; + forced: rs.LazyLock; } -export function writeStr$fmt_Write(self: Setter, s: string): rt.Result { +export function writeStr$fmt_Write(self: Setter, s: string): rs.Result { if (s === self.trigger) { - rt.cellSet(self.cell, 9); - rt.onceSet(self.once, 9); + rs.cellSet(self.cell, 9); + rs.onceSet(self.once, 9); self.lazy.force(); - rt.onceSet(self.lock, 9); + rs.onceSet(self.lock, 9); self.forced.force(); } return Log.writeStr$fmt_Write(self.log, s); diff --git a/ts/fixtures/lang/shapes/expected/fmt.Shared.ts b/ts/fixtures/lang/shapes/expected/fmt.Shared.ts index c5dca19e6..189c0aa17 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Shared.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Shared.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Pair from "./fmt.Pair.ts"; -export function fmt$fmt_Debug(self: Shared, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Shared, f: rs.Formatter): rs.Result { const _3: string = "Shared"; const _4: string = "arc"; - const _5: rt.Fmt = (f: rt.Formatter) => Pair.fmt$fmt_Debug(self.arc.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self.arc.value, f); const _7: string = "span"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtRange(self.span, f, rt.u16Debug); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtRange(self.span, f, rs.u16Debug); const _10: string = "upto"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtRangeToInclusive(self.upto, f, rt.u8Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtRangeToInclusive(self.upto, f, rs.u8Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } export class Shared { - arc: rt.Arc; - span: rt.Range; - upto: { end: rt.u8; inclusive: true }; + arc: rs.Arc; + span: rs.Range; + upto: { end: rs.u8; inclusive: true }; - constructor(arc: rt.Arc, span: rt.Range, upto: { end: rt.u8; inclusive: true }) { + constructor(arc: rs.Arc, span: rs.Range, upto: { end: rs.u8; inclusive: true }) { this.arc = arc; this.span = span; this.upto = upto; diff --git a/ts/fixtures/lang/shapes/expected/fmt.Six.ts b/ts/fixtures/lang/shapes/expected/fmt.Six.ts index 140d5b50a..dcf44fcd6 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Six.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Six.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Six, f: rt.Formatter): rt.Result { - const values: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(self._0, f), (f: rt.Formatter) => rt.u8Debug(self._1, f), (f: rt.Formatter) => rt.u8Debug(self._2, f), (f: rt.Formatter) => rt.u8Debug(self._3, f), (f: rt.Formatter) => rt.u8Debug(self._4, f), (f: rt.Formatter) => rt.u8Debug(self._5, f)]; - return rt.fmtDebugTupleFields(f, "Six", values); +export function fmt$fmt_Debug(self: Six, f: rs.Formatter): rs.Result { + const values: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(self._0, f), (f: rs.Formatter) => rs.u8Debug(self._1, f), (f: rs.Formatter) => rs.u8Debug(self._2, f), (f: rs.Formatter) => rs.u8Debug(self._3, f), (f: rs.Formatter) => rs.u8Debug(self._4, f), (f: rs.Formatter) => rs.u8Debug(self._5, f)]; + return rs.fmtDebugTupleFields(f, "Six", values); } export interface Six { - _0: rt.u8; - _1: rt.u8; - _2: rt.u8; - _3: rt.u8; - _4: rt.u8; - _5: rt.u8; + _0: rs.u8; + _1: rs.u8; + _2: rs.u8; + _3: rs.u8; + _4: rs.u8; + _5: rs.u8; } //# sourceMappingURL=fmt.Six.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts b/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts index 56c21a492..5ef7d9fbb 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Toggle.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Toggle, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Toggle, f: rs.Formatter): rs.Result { let _3!: string; if (self === "Ready") { _3 = "Ready"; } else { _3 = "Done"; } - return rt.fmtWriteStr(f, _3); + return rs.fmtWriteStr(f, _3); } /** @@ -18,12 +18,12 @@ export function fmt$fmt_Debug(self: Toggle, f: rt.Formatter): rt.Result): rt.u8 | rt.Done { +export function next$iter_Iterator(self: rs.Place): rs.u8 | rs.Done { if (self.v === "Ready") { self.v = "Done" as Toggle; return 1; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=fmt.Toggle.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Tup.ts b/ts/fixtures/lang/shapes/expected/fmt.Tup.ts index 0300eee76..7a7f6fbcb 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Tup.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Tup.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Tup { - _0: rt.u8; - _1: rt.u8 | undefined; + _0: rs.u8; + _1: rs.u8 | undefined; } -export function fmt$fmt_Debug(self: Tup, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Tup, f: rs.Formatter): rs.Result { if (self._1 === undefined) { - return rt.debugTupleFinishNonExhaustive(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Debug(self._0, f))); + return rs.debugTupleFinishNonExhaustive(rs.debugTupleField(rs.fmtDebugTuple(f, "Tup"), (f: rs.Formatter) => rs.u8Debug(self._0, f))); } - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, "Tup"), (f: rt.Formatter) => rt.u8Debug(self._0, f)), (f: rt.Formatter) => rt.fmtOption(self._1, f, rt.u8Debug))); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, "Tup"), (f: rs.Formatter) => rs.u8Debug(self._0, f)), (f: rs.Formatter) => rs.fmtOption(self._1, f, rs.u8Debug))); } //# sourceMappingURL=fmt.Tup.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts index b7e4397fb..170f4857d 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Twice.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Twice.ts @@ -1,28 +1,28 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A writer of the crate's own that writes each `char` twice through its own `write_char`. */ export interface Twice { _0: string; } -export function writeStr$fmt_Write(self: Twice, s: string): rt.Result { - const iter: rt.Iter = rt.strChars(s); +export function writeStr$fmt_Write(self: Twice, s: string): rs.Result { + const iter: rs.Iter = rs.strChars(s); while (true) { - const _6: rt.char | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.char | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } self._0 = self._0 + String.fromCodePoint(_6); } - return rt.OK; + return rs.OK; } -export function writeChar$fmt_Write(self: Twice, c: rt.char): rt.Result { +export function writeChar$fmt_Write(self: Twice, c: rs.char): rs.Result { self._0 = self._0 + String.fromCodePoint(c); self._0 = self._0 + String.fromCodePoint(c); - return rt.OK; + return rs.OK; } //# sourceMappingURL=fmt.Twice.ts.map diff --git a/ts/fixtures/lang/shapes/expected/fmt.Unit.ts b/ts/fixtures/lang/shapes/expected/fmt.Unit.ts index 1a26cfc5c..974b42389 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Unit.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Unit.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Unit, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Unit"); +export function fmt$fmt_Debug(_self: Unit, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Unit"); } export interface Unit { diff --git a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts index 8371884da..28c681531 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.Wide.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.Wide.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Wide, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Wide, f: rs.Formatter): rs.Result { const names: string[] = ["a", "b", "c", "d", "e", "f"]; - const values: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(self.a, f), (f: rt.Formatter) => rt.u16Debug(self.b, f), (f: rt.Formatter) => rt.u32Debug(self.c, f), (f: rt.Formatter) => rt.u64Debug(self.d, f), (f: rt.Formatter) => rt.i8Debug(self.e, f), (f: rt.Formatter) => rt.fmtBool(self.f, f)]; - return rt.fmtDebugStructFields(f, "Wide", names, values); + const values: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(self.a, f), (f: rs.Formatter) => rs.u16Debug(self.b, f), (f: rs.Formatter) => rs.u32Debug(self.c, f), (f: rs.Formatter) => rs.u64Debug(self.d, f), (f: rs.Formatter) => rs.i8Debug(self.e, f), (f: rs.Formatter) => rs.fmtBool(self.f, f)]; + return rs.fmtDebugStructFields(f, "Wide", names, values); } /** Past five fields, derived `Debug` takes the fields as slices. */ export interface Wide { - a: rt.u8; - b: rt.u16; - c: rt.u32; - d: rt.u64; - e: rt.i8; + a: rs.u8; + b: rs.u16; + c: rs.u32; + d: rs.u64; + e: rs.i8; f: boolean; } diff --git a/ts/fixtures/lang/shapes/expected/fmt.ts b/ts/fixtures/lang/shapes/expected/fmt.ts index d0445370f..5ea2ec22c 100644 --- a/ts/fixtures/lang/shapes/expected/fmt.ts +++ b/ts/fixtures/lang/shapes/expected/fmt.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_tuple2_u8_u8, copy$array_u8, copy$tuple2_u8_u8, of$u8 } from "./lib.ts"; -import { thenSome$1ou04rm, thenSome$0n2gkz4, thenSome$0d5am30, then$0uwf92a } from "./core/bool.ts"; -import { unwrapOr$0k15iai as option_unwrapOr$0k15iai, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrDefault$0301ewp as option_unwrapOrDefault$0301ewp, map$0phsnvg as option_map$0phsnvg, andThen$1bd14ex as option_andThen$1bd14ex } from "./core/option.ts"; +import { thenSome$1ou04rm, thenSome$05ku0zn, thenSome$0quywni, then$1uoo7un } from "./core/bool.ts"; +import { unwrapOr$04rqm9m as option_unwrapOr$04rqm9m, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0avqj0t as option_unwrapOrDefault$0avqj0t, map$02rrcvu as option_map$02rrcvu, andThen$0jc4o0i as option_andThen$0jc4o0i } from "./core/option.ts"; import * as Bare from "./fmt.Bare.ts"; import * as Braced from "./fmt.Braced.ts"; import * as Capped from "./fmt.Capped.ts"; @@ -36,397 +36,397 @@ import * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; /** Integers of every width, with each spec. */ -export function ints(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _4: rt.u8 = rt.u8Rem(kind, 12); +export function ints(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _4: rs.u8 = rs.u8Rem(kind, 12); if (_4 === 0) { const buf: Uint8Array = Uint8Array.of(0); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - const v: rt.u8 = rt.u8FromBeBytes(buf); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8Debug(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8UpperHex(v, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[1]), " ", rt.fmtSpec({ width: 3 }, args2[1])])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(v, f), (f: rt.Formatter) => rt.u8LowerHex(v, f), (f: rt.Formatter) => rt.u8Binary(v, f), (f: rt.Formatter) => rt.u8Octal(v, f), (f: rt.Formatter) => rt.u8Debug(v, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args4[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args4[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args4[1]), " ", args4[0], " ", rt.fmtSpec({ precision: 3 }, args4[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args4[0]), "|", args4[2], " ", rt.fmtSpec({ alternate: true }, args4[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args4[2]), " ", args4[3], " ", rt.fmtSpec({ alternate: true }, args4[3]), " ", rt.fmtSpec({ plus: true }, args4[3]), "|", rt.fmtSpec({ debugHex: "x" }, args4[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args4[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args4[4]), " ", rt.fmtSpec({ plus: true }, args4[4])])); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8LowerExp(v, f), (f: rt.Formatter) => rt.u8UpperExp(v, f)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1], " ", rt.fmtSpec({ precision: 0 }, args6[0]), " ", rt.fmtSpec({ precision: 1 }, args6[0]), " ", rt.fmtSpec({ precision: 3 }, args6[0]), " ", rt.fmtSpec({ precision: 45 }, args6[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args6[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args6[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args6[0]), "| ", rt.fmtSpec({ alternate: true }, args6[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args6[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(v, f))); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + const v: rs.u8 = rs.u8FromBeBytes(buf); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8Debug(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8UpperHex(v, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args2[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args2[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args2[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args2[0]), "|", args2[2], " ", args2[3], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args2[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[1]), " ", rs.fmtSpec({ width: 3 }, args2[1])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(v, f), (f: rs.Formatter) => rs.u8LowerHex(v, f), (f: rs.Formatter) => rs.u8Binary(v, f), (f: rs.Formatter) => rs.u8Octal(v, f), (f: rs.Formatter) => rs.u8Debug(v, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args4[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args4[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args4[1]), " ", args4[0], " ", rs.fmtSpec({ precision: 3 }, args4[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args4[0]), "|", args4[2], " ", rs.fmtSpec({ alternate: true }, args4[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args4[2]), " ", args4[3], " ", rs.fmtSpec({ alternate: true }, args4[3]), " ", rs.fmtSpec({ plus: true }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args4[4]), " ", rs.fmtSpec({ plus: true }, args4[4])])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerExp(v, f), (f: rs.Formatter) => rs.u8UpperExp(v, f)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1], " ", rs.fmtSpec({ precision: 0 }, args6[0]), " ", rs.fmtSpec({ precision: 1 }, args6[0]), " ", rs.fmtSpec({ precision: 3 }, args6[0]), " ", rs.fmtSpec({ precision: 45 }, args6[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args6[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args6[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args6[0]), "| ", rs.fmtSpec({ alternate: true }, args6[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args6[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(v, f))); } else if (_4 === 1) { - const buf2: Uint8Array = rt.bytes(2); - const n2: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf2).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf2), 0, n2), rt.byteSliceRange(data, 0, n2)); - const v2: rt.u16 = rt.u16FromBeBytes(buf2); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16Debug(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16UpperHex(v2, f)]; - put(out, rt.fmtFormat([args8[0], " ", args8[1], " ", rt.fmtSpec({ width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rt.fmtSpec({ alternate: true }, args8[2]), " ", rt.fmtSpec({ alternate: true }, args8[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rt.fmtSpec({ alternate: true }, args8[1]), " ", rt.fmtSpec({ width: 3 }, args8[1])])); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(v2, f), (f: rt.Formatter) => rt.u16LowerHex(v2, f), (f: rt.Formatter) => rt.u16Binary(v2, f), (f: rt.Formatter) => rt.u16Octal(v2, f), (f: rt.Formatter) => rt.u16Debug(v2, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args10[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args10[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args10[1]), " ", args10[0], " ", rt.fmtSpec({ precision: 3 }, args10[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args10[0]), "|", args10[2], " ", rt.fmtSpec({ alternate: true }, args10[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args10[2]), " ", args10[3], " ", rt.fmtSpec({ alternate: true }, args10[3]), " ", rt.fmtSpec({ plus: true }, args10[3]), "|", rt.fmtSpec({ debugHex: "x" }, args10[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args10[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args10[4]), " ", rt.fmtSpec({ plus: true }, args10[4])])); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u16LowerExp(v2, f), (f: rt.Formatter) => rt.u16UpperExp(v2, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ precision: 0 }, args12[0]), " ", rt.fmtSpec({ precision: 1 }, args12[0]), " ", rt.fmtSpec({ precision: 3 }, args12[0]), " ", rt.fmtSpec({ precision: 45 }, args12[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args12[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args12[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args12[0]), "| ", rt.fmtSpec({ alternate: true }, args12[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args12[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u16Display(v2, f))); + const buf2: Uint8Array = rs.bytes(2); + const n2: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf2).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf2), 0, n2), rs.byteSliceRange(data, 0, n2)); + const v2: rs.u16 = rs.u16FromBeBytes(buf2); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16UpperHex(v2, f)]; + put(out, rs.fmtFormat([args8[0], " ", args8[1], " ", rs.fmtSpec({ width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args8[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args8[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args8[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args8[0]), "|", args8[2], " ", args8[3], " ", rs.fmtSpec({ alternate: true }, args8[2]), " ", rs.fmtSpec({ alternate: true }, args8[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args8[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args8[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args8[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args8[3]), "|", rs.fmtSpec({ alternate: true }, args8[1]), " ", rs.fmtSpec({ width: 3 }, args8[1])])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(v2, f), (f: rs.Formatter) => rs.u16LowerHex(v2, f), (f: rs.Formatter) => rs.u16Binary(v2, f), (f: rs.Formatter) => rs.u16Octal(v2, f), (f: rs.Formatter) => rs.u16Debug(v2, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args10[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args10[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args10[1]), " ", args10[0], " ", rs.fmtSpec({ precision: 3 }, args10[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args10[0]), "|", args10[2], " ", rs.fmtSpec({ alternate: true }, args10[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args10[2]), " ", args10[3], " ", rs.fmtSpec({ alternate: true }, args10[3]), " ", rs.fmtSpec({ plus: true }, args10[3]), "|", rs.fmtSpec({ debugHex: "x" }, args10[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args10[4]), " ", rs.fmtSpec({ plus: true }, args10[4])])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u16LowerExp(v2, f), (f: rs.Formatter) => rs.u16UpperExp(v2, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ precision: 0 }, args12[0]), " ", rs.fmtSpec({ precision: 1 }, args12[0]), " ", rs.fmtSpec({ precision: 3 }, args12[0]), " ", rs.fmtSpec({ precision: 45 }, args12[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args12[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args12[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args12[0]), "| ", rs.fmtSpec({ alternate: true }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args12[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u16Display(v2, f))); } else if (_4 === 2) { - const buf3: Uint8Array = rt.bytes(4); - const n3: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf3).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf3), 0, n3), rt.byteSliceRange(data, 0, n3)); - const v3: rt.u32 = rt.u32FromBeBytes(buf3); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32Debug(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32UpperHex(v3, f)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", rt.fmtSpec({ width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rt.fmtSpec({ alternate: true }, args14[2]), " ", rt.fmtSpec({ alternate: true }, args14[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rt.fmtSpec({ alternate: true }, args14[1]), " ", rt.fmtSpec({ width: 3 }, args14[1])])); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(v3, f), (f: rt.Formatter) => rt.u32LowerHex(v3, f), (f: rt.Formatter) => rt.u32Binary(v3, f), (f: rt.Formatter) => rt.u32Octal(v3, f), (f: rt.Formatter) => rt.u32Debug(v3, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args16[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args16[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args16[1]), " ", args16[0], " ", rt.fmtSpec({ precision: 3 }, args16[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args16[0]), "|", args16[2], " ", rt.fmtSpec({ alternate: true }, args16[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args16[2]), " ", args16[3], " ", rt.fmtSpec({ alternate: true }, args16[3]), " ", rt.fmtSpec({ plus: true }, args16[3]), "|", rt.fmtSpec({ debugHex: "x" }, args16[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args16[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args16[4]), " ", rt.fmtSpec({ plus: true }, args16[4])])); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32LowerExp(v3, f), (f: rt.Formatter) => rt.u32UpperExp(v3, f)]; - put(out, rt.fmtFormat([args18[0], " ", args18[1], " ", rt.fmtSpec({ precision: 0 }, args18[0]), " ", rt.fmtSpec({ precision: 1 }, args18[0]), " ", rt.fmtSpec({ precision: 3 }, args18[0]), " ", rt.fmtSpec({ precision: 45 }, args18[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args18[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args18[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args18[0]), "| ", rt.fmtSpec({ alternate: true }, args18[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args18[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u32Display(v3, f))); + const buf3: Uint8Array = rs.bytes(4); + const n3: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf3).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf3), 0, n3), rs.byteSliceRange(data, 0, n3)); + const v3: rs.u32 = rs.u32FromBeBytes(buf3); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32UpperHex(v3, f)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", rs.fmtSpec({ width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args14[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args14[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args14[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args14[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args14[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args14[0]), "|", args14[2], " ", args14[3], " ", rs.fmtSpec({ alternate: true }, args14[2]), " ", rs.fmtSpec({ alternate: true }, args14[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args14[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args14[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args14[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args14[3]), "|", rs.fmtSpec({ alternate: true }, args14[1]), " ", rs.fmtSpec({ width: 3 }, args14[1])])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(v3, f), (f: rs.Formatter) => rs.u32LowerHex(v3, f), (f: rs.Formatter) => rs.u32Binary(v3, f), (f: rs.Formatter) => rs.u32Octal(v3, f), (f: rs.Formatter) => rs.u32Debug(v3, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args16[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args16[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args16[1]), " ", args16[0], " ", rs.fmtSpec({ precision: 3 }, args16[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args16[0]), "|", args16[2], " ", rs.fmtSpec({ alternate: true }, args16[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args16[2]), " ", args16[3], " ", rs.fmtSpec({ alternate: true }, args16[3]), " ", rs.fmtSpec({ plus: true }, args16[3]), "|", rs.fmtSpec({ debugHex: "x" }, args16[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args16[4]), " ", rs.fmtSpec({ plus: true }, args16[4])])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(v3, f), (f: rs.Formatter) => rs.u32UpperExp(v3, f)]; + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", rs.fmtSpec({ precision: 0 }, args18[0]), " ", rs.fmtSpec({ precision: 1 }, args18[0]), " ", rs.fmtSpec({ precision: 3 }, args18[0]), " ", rs.fmtSpec({ precision: 45 }, args18[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args18[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args18[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args18[0]), "| ", rs.fmtSpec({ alternate: true }, args18[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args18[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u32Display(v3, f))); } else if (_4 === 3) { - const buf4: Uint8Array = rt.bytes(8); - const n4: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf4).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf4), 0, n4), rt.byteSliceRange(data, 0, n4)); - const v4: rt.u64 = rt.u64FromBeBytes(buf4); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64Debug(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64UpperHex(v4, f)]; - put(out, rt.fmtFormat([args20[0], " ", args20[1], " ", rt.fmtSpec({ width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rt.fmtSpec({ alternate: true }, args20[2]), " ", rt.fmtSpec({ alternate: true }, args20[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rt.fmtSpec({ alternate: true }, args20[1]), " ", rt.fmtSpec({ width: 3 }, args20[1])])); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(v4, f), (f: rt.Formatter) => rt.u64LowerHex(v4, f), (f: rt.Formatter) => rt.u64Binary(v4, f), (f: rt.Formatter) => rt.u64Octal(v4, f), (f: rt.Formatter) => rt.u64Debug(v4, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args22[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args22[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args22[1]), " ", args22[0], " ", rt.fmtSpec({ precision: 3 }, args22[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args22[0]), "|", args22[2], " ", rt.fmtSpec({ alternate: true }, args22[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args22[2]), " ", args22[3], " ", rt.fmtSpec({ alternate: true }, args22[3]), " ", rt.fmtSpec({ plus: true }, args22[3]), "|", rt.fmtSpec({ debugHex: "x" }, args22[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args22[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args22[4]), " ", rt.fmtSpec({ plus: true }, args22[4])])); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u64LowerExp(v4, f), (f: rt.Formatter) => rt.u64UpperExp(v4, f)]; - put(out, rt.fmtFormat([args24[0], " ", args24[1], " ", rt.fmtSpec({ precision: 0 }, args24[0]), " ", rt.fmtSpec({ precision: 1 }, args24[0]), " ", rt.fmtSpec({ precision: 3 }, args24[0]), " ", rt.fmtSpec({ precision: 45 }, args24[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args24[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args24[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args24[0]), "| ", rt.fmtSpec({ alternate: true }, args24[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args24[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u64Display(v4, f))); + const buf4: Uint8Array = rs.bytes(8); + const n4: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf4).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf4), 0, n4), rs.byteSliceRange(data, 0, n4)); + const v4: rs.u64 = rs.u64FromBeBytes(buf4); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64UpperHex(v4, f)]; + put(out, rs.fmtFormat([args20[0], " ", args20[1], " ", rs.fmtSpec({ width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args20[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args20[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args20[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args20[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args20[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args20[0]), "|", args20[2], " ", args20[3], " ", rs.fmtSpec({ alternate: true }, args20[2]), " ", rs.fmtSpec({ alternate: true }, args20[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args20[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args20[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args20[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args20[3]), "|", rs.fmtSpec({ alternate: true }, args20[1]), " ", rs.fmtSpec({ width: 3 }, args20[1])])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(v4, f), (f: rs.Formatter) => rs.u64LowerHex(v4, f), (f: rs.Formatter) => rs.u64Binary(v4, f), (f: rs.Formatter) => rs.u64Octal(v4, f), (f: rs.Formatter) => rs.u64Debug(v4, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args22[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args22[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args22[1]), " ", args22[0], " ", rs.fmtSpec({ precision: 3 }, args22[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args22[0]), "|", args22[2], " ", rs.fmtSpec({ alternate: true }, args22[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args22[2]), " ", args22[3], " ", rs.fmtSpec({ alternate: true }, args22[3]), " ", rs.fmtSpec({ plus: true }, args22[3]), "|", rs.fmtSpec({ debugHex: "x" }, args22[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args22[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args22[4]), " ", rs.fmtSpec({ plus: true }, args22[4])])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u64LowerExp(v4, f), (f: rs.Formatter) => rs.u64UpperExp(v4, f)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1], " ", rs.fmtSpec({ precision: 0 }, args24[0]), " ", rs.fmtSpec({ precision: 1 }, args24[0]), " ", rs.fmtSpec({ precision: 3 }, args24[0]), " ", rs.fmtSpec({ precision: 45 }, args24[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args24[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args24[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args24[0]), "| ", rs.fmtSpec({ alternate: true }, args24[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args24[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u64Display(v4, f))); } else if (_4 === 4) { - const buf5: Uint8Array = rt.bytes(16); - const n5: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf5).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf5), 0, n5), rt.byteSliceRange(data, 0, n5)); - const v5: rt.u128 = rt.u128FromBeBytes(buf5); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128Debug(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128UpperHex(v5, f)]; - put(out, rt.fmtFormat([args26[0], " ", args26[1], " ", rt.fmtSpec({ width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rt.fmtSpec({ alternate: true }, args26[2]), " ", rt.fmtSpec({ alternate: true }, args26[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rt.fmtSpec({ alternate: true }, args26[1]), " ", rt.fmtSpec({ width: 3 }, args26[1])])); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(v5, f), (f: rt.Formatter) => rt.u128LowerHex(v5, f), (f: rt.Formatter) => rt.u128Binary(v5, f), (f: rt.Formatter) => rt.u128Octal(v5, f), (f: rt.Formatter) => rt.u128Debug(v5, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args28[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args28[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args28[1]), " ", args28[0], " ", rt.fmtSpec({ precision: 3 }, args28[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args28[0]), "|", args28[2], " ", rt.fmtSpec({ alternate: true }, args28[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args28[2]), " ", args28[3], " ", rt.fmtSpec({ alternate: true }, args28[3]), " ", rt.fmtSpec({ plus: true }, args28[3]), "|", rt.fmtSpec({ debugHex: "x" }, args28[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args28[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args28[4]), " ", rt.fmtSpec({ plus: true }, args28[4])])); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u128LowerExp(v5, f), (f: rt.Formatter) => rt.u128UpperExp(v5, f)]; - put(out, rt.fmtFormat([args30[0], " ", args30[1], " ", rt.fmtSpec({ precision: 0 }, args30[0]), " ", rt.fmtSpec({ precision: 1 }, args30[0]), " ", rt.fmtSpec({ precision: 3 }, args30[0]), " ", rt.fmtSpec({ precision: 45 }, args30[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args30[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args30[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args30[0]), "| ", rt.fmtSpec({ alternate: true }, args30[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args30[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u128Display(v5, f))); + const buf5: Uint8Array = rs.bytes(16); + const n5: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf5).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf5), 0, n5), rs.byteSliceRange(data, 0, n5)); + const v5: rs.u128 = rs.u128FromBeBytes(buf5); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128UpperHex(v5, f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args26[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args26[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args26[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args26[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args26[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args26[0]), "|", args26[2], " ", args26[3], " ", rs.fmtSpec({ alternate: true }, args26[2]), " ", rs.fmtSpec({ alternate: true }, args26[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args26[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args26[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args26[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args26[3]), "|", rs.fmtSpec({ alternate: true }, args26[1]), " ", rs.fmtSpec({ width: 3 }, args26[1])])); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(v5, f), (f: rs.Formatter) => rs.u128LowerHex(v5, f), (f: rs.Formatter) => rs.u128Binary(v5, f), (f: rs.Formatter) => rs.u128Octal(v5, f), (f: rs.Formatter) => rs.u128Debug(v5, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args28[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args28[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args28[1]), " ", args28[0], " ", rs.fmtSpec({ precision: 3 }, args28[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args28[0]), "|", args28[2], " ", rs.fmtSpec({ alternate: true }, args28[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args28[2]), " ", args28[3], " ", rs.fmtSpec({ alternate: true }, args28[3]), " ", rs.fmtSpec({ plus: true }, args28[3]), "|", rs.fmtSpec({ debugHex: "x" }, args28[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args28[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args28[4]), " ", rs.fmtSpec({ plus: true }, args28[4])])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp(v5, f), (f: rs.Formatter) => rs.u128UpperExp(v5, f)]; + put(out, rs.fmtFormat([args30[0], " ", args30[1], " ", rs.fmtSpec({ precision: 0 }, args30[0]), " ", rs.fmtSpec({ precision: 1 }, args30[0]), " ", rs.fmtSpec({ precision: 3 }, args30[0]), " ", rs.fmtSpec({ precision: 45 }, args30[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args30[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args30[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args30[0]), "| ", rs.fmtSpec({ alternate: true }, args30[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args30[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u128Display(v5, f))); } else if (_4 === 5) { - const buf6: Uint8Array = rt.bytes(4); - const n6: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf6).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf6), 0, n6), rt.byteSliceRange(data, 0, n6)); - const v6: rt.usize = rt.usizeFromBeBytes(buf6); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeDebug(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeUpperHex(v6, f)]; - put(out, rt.fmtFormat([args32[0], " ", args32[1], " ", rt.fmtSpec({ width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rt.fmtSpec({ alternate: true }, args32[2]), " ", rt.fmtSpec({ alternate: true }, args32[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rt.fmtSpec({ alternate: true }, args32[1]), " ", rt.fmtSpec({ width: 3 }, args32[1])])); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(v6, f), (f: rt.Formatter) => rt.usizeLowerHex(v6, f), (f: rt.Formatter) => rt.usizeBinary(v6, f), (f: rt.Formatter) => rt.usizeOctal(v6, f), (f: rt.Formatter) => rt.usizeDebug(v6, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args34[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args34[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args34[1]), " ", args34[0], " ", rt.fmtSpec({ precision: 3 }, args34[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", args34[2], " ", rt.fmtSpec({ alternate: true }, args34[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args34[2]), " ", args34[3], " ", rt.fmtSpec({ alternate: true }, args34[3]), " ", rt.fmtSpec({ plus: true }, args34[3]), "|", rt.fmtSpec({ debugHex: "x" }, args34[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args34[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args34[4]), " ", rt.fmtSpec({ plus: true }, args34[4])])); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeLowerExp(v6, f), (f: rt.Formatter) => rt.usizeUpperExp(v6, f)]; - put(out, rt.fmtFormat([args36[0], " ", args36[1], " ", rt.fmtSpec({ precision: 0 }, args36[0]), " ", rt.fmtSpec({ precision: 1 }, args36[0]), " ", rt.fmtSpec({ precision: 3 }, args36[0]), " ", rt.fmtSpec({ precision: 45 }, args36[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args36[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args36[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args36[0]), "| ", rt.fmtSpec({ alternate: true }, args36[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args36[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.usizeDisplay(v6, f))); + const buf6: Uint8Array = rs.bytes(4); + const n6: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf6).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf6), 0, n6), rs.byteSliceRange(data, 0, n6)); + const v6: rs.usize = rs.usizeFromBeBytes(buf6); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeUpperHex(v6, f)]; + put(out, rs.fmtFormat([args32[0], " ", args32[1], " ", rs.fmtSpec({ width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args32[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args32[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args32[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args32[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args32[0]), "|", args32[2], " ", args32[3], " ", rs.fmtSpec({ alternate: true }, args32[2]), " ", rs.fmtSpec({ alternate: true }, args32[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args32[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args32[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args32[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args32[3]), "|", rs.fmtSpec({ alternate: true }, args32[1]), " ", rs.fmtSpec({ width: 3 }, args32[1])])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(v6, f), (f: rs.Formatter) => rs.usizeLowerHex(v6, f), (f: rs.Formatter) => rs.usizeBinary(v6, f), (f: rs.Formatter) => rs.usizeOctal(v6, f), (f: rs.Formatter) => rs.usizeDebug(v6, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args34[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args34[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args34[1]), " ", args34[0], " ", rs.fmtSpec({ precision: 3 }, args34[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args34[0]), "|", args34[2], " ", rs.fmtSpec({ alternate: true }, args34[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args34[2]), " ", args34[3], " ", rs.fmtSpec({ alternate: true }, args34[3]), " ", rs.fmtSpec({ plus: true }, args34[3]), "|", rs.fmtSpec({ debugHex: "x" }, args34[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args34[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args34[4]), " ", rs.fmtSpec({ plus: true }, args34[4])])); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeLowerExp(v6, f), (f: rs.Formatter) => rs.usizeUpperExp(v6, f)]; + put(out, rs.fmtFormat([args36[0], " ", args36[1], " ", rs.fmtSpec({ precision: 0 }, args36[0]), " ", rs.fmtSpec({ precision: 1 }, args36[0]), " ", rs.fmtSpec({ precision: 3 }, args36[0]), " ", rs.fmtSpec({ precision: 45 }, args36[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args36[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args36[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args36[0]), "| ", rs.fmtSpec({ alternate: true }, args36[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args36[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.usizeDisplay(v6, f))); } else if (_4 === 6) { const buf7: Uint8Array = Uint8Array.of(0); - const n7: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf7).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf7), 0, n7), rt.byteSliceRange(data, 0, n7)); - const v7: rt.i8 = rt.i8FromBeBytes(buf7); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8Debug(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8UpperHex(v7, f)]; - put(out, rt.fmtFormat([args38[0], " ", args38[1], " ", rt.fmtSpec({ width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rt.fmtSpec({ alternate: true }, args38[2]), " ", rt.fmtSpec({ alternate: true }, args38[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rt.fmtSpec({ alternate: true }, args38[1]), " ", rt.fmtSpec({ width: 3 }, args38[1])])); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(v7, f), (f: rt.Formatter) => rt.i8LowerHex(v7, f), (f: rt.Formatter) => rt.i8Binary(v7, f), (f: rt.Formatter) => rt.i8Octal(v7, f), (f: rt.Formatter) => rt.i8Debug(v7, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args40[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args40[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args40[1]), " ", args40[0], " ", rt.fmtSpec({ precision: 3 }, args40[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args40[0]), "|", args40[2], " ", rt.fmtSpec({ alternate: true }, args40[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args40[2]), " ", args40[3], " ", rt.fmtSpec({ alternate: true }, args40[3]), " ", rt.fmtSpec({ plus: true }, args40[3]), "|", rt.fmtSpec({ debugHex: "x" }, args40[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args40[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args40[4]), " ", rt.fmtSpec({ plus: true }, args40[4])])); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.i8LowerExp(v7, f), (f: rt.Formatter) => rt.i8UpperExp(v7, f)]; - put(out, rt.fmtFormat([args42[0], " ", args42[1], " ", rt.fmtSpec({ precision: 0 }, args42[0]), " ", rt.fmtSpec({ precision: 1 }, args42[0]), " ", rt.fmtSpec({ precision: 3 }, args42[0]), " ", rt.fmtSpec({ precision: 45 }, args42[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args42[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args42[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args42[0]), "| ", rt.fmtSpec({ alternate: true }, args42[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args42[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i8Display(v7, f))); + const n7: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf7).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf7), 0, n7), rs.byteSliceRange(data, 0, n7)); + const v7: rs.i8 = rs.i8FromBeBytes(buf7); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8UpperHex(v7, f)]; + put(out, rs.fmtFormat([args38[0], " ", args38[1], " ", rs.fmtSpec({ width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args38[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args38[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args38[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args38[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args38[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args38[0]), "|", args38[2], " ", args38[3], " ", rs.fmtSpec({ alternate: true }, args38[2]), " ", rs.fmtSpec({ alternate: true }, args38[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args38[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args38[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args38[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args38[3]), "|", rs.fmtSpec({ alternate: true }, args38[1]), " ", rs.fmtSpec({ width: 3 }, args38[1])])); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(v7, f), (f: rs.Formatter) => rs.i8LowerHex(v7, f), (f: rs.Formatter) => rs.i8Binary(v7, f), (f: rs.Formatter) => rs.i8Octal(v7, f), (f: rs.Formatter) => rs.i8Debug(v7, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args40[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args40[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args40[1]), " ", args40[0], " ", rs.fmtSpec({ precision: 3 }, args40[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args40[0]), "|", args40[2], " ", rs.fmtSpec({ alternate: true }, args40[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args40[2]), " ", args40[3], " ", rs.fmtSpec({ alternate: true }, args40[3]), " ", rs.fmtSpec({ plus: true }, args40[3]), "|", rs.fmtSpec({ debugHex: "x" }, args40[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args40[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args40[4]), " ", rs.fmtSpec({ plus: true }, args40[4])])); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.i8LowerExp(v7, f), (f: rs.Formatter) => rs.i8UpperExp(v7, f)]; + put(out, rs.fmtFormat([args42[0], " ", args42[1], " ", rs.fmtSpec({ precision: 0 }, args42[0]), " ", rs.fmtSpec({ precision: 1 }, args42[0]), " ", rs.fmtSpec({ precision: 3 }, args42[0]), " ", rs.fmtSpec({ precision: 45 }, args42[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args42[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args42[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args42[0]), "| ", rs.fmtSpec({ alternate: true }, args42[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args42[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i8Display(v7, f))); } else if (_4 === 7) { - const buf8: Uint8Array = rt.bytes(2); - const n8: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf8).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf8), 0, n8), rt.byteSliceRange(data, 0, n8)); - const v8: rt.i16 = rt.i16FromBeBytes(buf8); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16Debug(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16UpperHex(v8, f)]; - put(out, rt.fmtFormat([args44[0], " ", args44[1], " ", rt.fmtSpec({ width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rt.fmtSpec({ alternate: true }, args44[2]), " ", rt.fmtSpec({ alternate: true }, args44[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rt.fmtSpec({ alternate: true }, args44[1]), " ", rt.fmtSpec({ width: 3 }, args44[1])])); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(v8, f), (f: rt.Formatter) => rt.i16LowerHex(v8, f), (f: rt.Formatter) => rt.i16Binary(v8, f), (f: rt.Formatter) => rt.i16Octal(v8, f), (f: rt.Formatter) => rt.i16Debug(v8, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args46[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args46[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args46[1]), " ", args46[0], " ", rt.fmtSpec({ precision: 3 }, args46[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args46[0]), "|", args46[2], " ", rt.fmtSpec({ alternate: true }, args46[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args46[2]), " ", args46[3], " ", rt.fmtSpec({ alternate: true }, args46[3]), " ", rt.fmtSpec({ plus: true }, args46[3]), "|", rt.fmtSpec({ debugHex: "x" }, args46[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args46[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args46[4]), " ", rt.fmtSpec({ plus: true }, args46[4])])); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.i16LowerExp(v8, f), (f: rt.Formatter) => rt.i16UpperExp(v8, f)]; - put(out, rt.fmtFormat([args48[0], " ", args48[1], " ", rt.fmtSpec({ precision: 0 }, args48[0]), " ", rt.fmtSpec({ precision: 1 }, args48[0]), " ", rt.fmtSpec({ precision: 3 }, args48[0]), " ", rt.fmtSpec({ precision: 45 }, args48[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args48[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args48[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args48[0]), "| ", rt.fmtSpec({ alternate: true }, args48[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args48[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i16Display(v8, f))); + const buf8: Uint8Array = rs.bytes(2); + const n8: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf8).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf8), 0, n8), rs.byteSliceRange(data, 0, n8)); + const v8: rs.i16 = rs.i16FromBeBytes(buf8); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16UpperHex(v8, f)]; + put(out, rs.fmtFormat([args44[0], " ", args44[1], " ", rs.fmtSpec({ width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args44[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args44[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args44[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args44[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args44[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args44[0]), "|", args44[2], " ", args44[3], " ", rs.fmtSpec({ alternate: true }, args44[2]), " ", rs.fmtSpec({ alternate: true }, args44[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args44[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args44[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args44[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args44[3]), "|", rs.fmtSpec({ alternate: true }, args44[1]), " ", rs.fmtSpec({ width: 3 }, args44[1])])); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(v8, f), (f: rs.Formatter) => rs.i16LowerHex(v8, f), (f: rs.Formatter) => rs.i16Binary(v8, f), (f: rs.Formatter) => rs.i16Octal(v8, f), (f: rs.Formatter) => rs.i16Debug(v8, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args46[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args46[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args46[1]), " ", args46[0], " ", rs.fmtSpec({ precision: 3 }, args46[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args46[0]), "|", args46[2], " ", rs.fmtSpec({ alternate: true }, args46[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args46[2]), " ", args46[3], " ", rs.fmtSpec({ alternate: true }, args46[3]), " ", rs.fmtSpec({ plus: true }, args46[3]), "|", rs.fmtSpec({ debugHex: "x" }, args46[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args46[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args46[4]), " ", rs.fmtSpec({ plus: true }, args46[4])])); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.i16LowerExp(v8, f), (f: rs.Formatter) => rs.i16UpperExp(v8, f)]; + put(out, rs.fmtFormat([args48[0], " ", args48[1], " ", rs.fmtSpec({ precision: 0 }, args48[0]), " ", rs.fmtSpec({ precision: 1 }, args48[0]), " ", rs.fmtSpec({ precision: 3 }, args48[0]), " ", rs.fmtSpec({ precision: 45 }, args48[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args48[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args48[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args48[0]), "| ", rs.fmtSpec({ alternate: true }, args48[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args48[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i16Display(v8, f))); } else if (_4 === 8) { - const buf9: Uint8Array = rt.bytes(4); - const n9: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf9).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf9), 0, n9), rt.byteSliceRange(data, 0, n9)); - const v9: rt.i32 = rt.i32FromBeBytes(buf9); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32Debug(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32UpperHex(v9, f)]; - put(out, rt.fmtFormat([args50[0], " ", args50[1], " ", rt.fmtSpec({ width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rt.fmtSpec({ alternate: true }, args50[2]), " ", rt.fmtSpec({ alternate: true }, args50[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rt.fmtSpec({ alternate: true }, args50[1]), " ", rt.fmtSpec({ width: 3 }, args50[1])])); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v9, f), (f: rt.Formatter) => rt.i32LowerHex(v9, f), (f: rt.Formatter) => rt.i32Binary(v9, f), (f: rt.Formatter) => rt.i32Octal(v9, f), (f: rt.Formatter) => rt.i32Debug(v9, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args52[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args52[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args52[1]), " ", args52[0], " ", rt.fmtSpec({ precision: 3 }, args52[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args52[0]), "|", args52[2], " ", rt.fmtSpec({ alternate: true }, args52[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args52[2]), " ", args52[3], " ", rt.fmtSpec({ alternate: true }, args52[3]), " ", rt.fmtSpec({ plus: true }, args52[3]), "|", rt.fmtSpec({ debugHex: "x" }, args52[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args52[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args52[4]), " ", rt.fmtSpec({ plus: true }, args52[4])])); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.i32LowerExp(v9, f), (f: rt.Formatter) => rt.i32UpperExp(v9, f)]; - put(out, rt.fmtFormat([args54[0], " ", args54[1], " ", rt.fmtSpec({ precision: 0 }, args54[0]), " ", rt.fmtSpec({ precision: 1 }, args54[0]), " ", rt.fmtSpec({ precision: 3 }, args54[0]), " ", rt.fmtSpec({ precision: 45 }, args54[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args54[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args54[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args54[0]), "| ", rt.fmtSpec({ alternate: true }, args54[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args54[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i32Display(v9, f))); + const buf9: Uint8Array = rs.bytes(4); + const n9: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf9).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf9), 0, n9), rs.byteSliceRange(data, 0, n9)); + const v9: rs.i32 = rs.i32FromBeBytes(buf9); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32UpperHex(v9, f)]; + put(out, rs.fmtFormat([args50[0], " ", args50[1], " ", rs.fmtSpec({ width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args50[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args50[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args50[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args50[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args50[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args50[0]), "|", args50[2], " ", args50[3], " ", rs.fmtSpec({ alternate: true }, args50[2]), " ", rs.fmtSpec({ alternate: true }, args50[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args50[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args50[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args50[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args50[3]), "|", rs.fmtSpec({ alternate: true }, args50[1]), " ", rs.fmtSpec({ width: 3 }, args50[1])])); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v9, f), (f: rs.Formatter) => rs.i32LowerHex(v9, f), (f: rs.Formatter) => rs.i32Binary(v9, f), (f: rs.Formatter) => rs.i32Octal(v9, f), (f: rs.Formatter) => rs.i32Debug(v9, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args52[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args52[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args52[1]), " ", args52[0], " ", rs.fmtSpec({ precision: 3 }, args52[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args52[0]), "|", args52[2], " ", rs.fmtSpec({ alternate: true }, args52[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args52[2]), " ", args52[3], " ", rs.fmtSpec({ alternate: true }, args52[3]), " ", rs.fmtSpec({ plus: true }, args52[3]), "|", rs.fmtSpec({ debugHex: "x" }, args52[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args52[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args52[4]), " ", rs.fmtSpec({ plus: true }, args52[4])])); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.i32LowerExp(v9, f), (f: rs.Formatter) => rs.i32UpperExp(v9, f)]; + put(out, rs.fmtFormat([args54[0], " ", args54[1], " ", rs.fmtSpec({ precision: 0 }, args54[0]), " ", rs.fmtSpec({ precision: 1 }, args54[0]), " ", rs.fmtSpec({ precision: 3 }, args54[0]), " ", rs.fmtSpec({ precision: 45 }, args54[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args54[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args54[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args54[0]), "| ", rs.fmtSpec({ alternate: true }, args54[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args54[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i32Display(v9, f))); } else if (_4 === 9) { - const buf10: Uint8Array = rt.bytes(8); - const n10: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf10).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf10), 0, n10), rt.byteSliceRange(data, 0, n10)); - const v10: rt.i64 = rt.i64FromBeBytes(buf10); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64Debug(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64UpperHex(v10, f)]; - put(out, rt.fmtFormat([args56[0], " ", args56[1], " ", rt.fmtSpec({ width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rt.fmtSpec({ alternate: true }, args56[2]), " ", rt.fmtSpec({ alternate: true }, args56[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rt.fmtSpec({ alternate: true }, args56[1]), " ", rt.fmtSpec({ width: 3 }, args56[1])])); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v10, f), (f: rt.Formatter) => rt.i64LowerHex(v10, f), (f: rt.Formatter) => rt.i64Binary(v10, f), (f: rt.Formatter) => rt.i64Octal(v10, f), (f: rt.Formatter) => rt.i64Debug(v10, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args58[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args58[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args58[1]), " ", args58[0], " ", rt.fmtSpec({ precision: 3 }, args58[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args58[0]), "|", args58[2], " ", rt.fmtSpec({ alternate: true }, args58[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args58[2]), " ", args58[3], " ", rt.fmtSpec({ alternate: true }, args58[3]), " ", rt.fmtSpec({ plus: true }, args58[3]), "|", rt.fmtSpec({ debugHex: "x" }, args58[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args58[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args58[4]), " ", rt.fmtSpec({ plus: true }, args58[4])])); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.i64LowerExp(v10, f), (f: rt.Formatter) => rt.i64UpperExp(v10, f)]; - put(out, rt.fmtFormat([args60[0], " ", args60[1], " ", rt.fmtSpec({ precision: 0 }, args60[0]), " ", rt.fmtSpec({ precision: 1 }, args60[0]), " ", rt.fmtSpec({ precision: 3 }, args60[0]), " ", rt.fmtSpec({ precision: 45 }, args60[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args60[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args60[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args60[0]), "| ", rt.fmtSpec({ alternate: true }, args60[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args60[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i64Display(v10, f))); + const buf10: Uint8Array = rs.bytes(8); + const n10: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf10).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf10), 0, n10), rs.byteSliceRange(data, 0, n10)); + const v10: rs.i64 = rs.i64FromBeBytes(buf10); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64UpperHex(v10, f)]; + put(out, rs.fmtFormat([args56[0], " ", args56[1], " ", rs.fmtSpec({ width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args56[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args56[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args56[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args56[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args56[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args56[0]), "|", args56[2], " ", args56[3], " ", rs.fmtSpec({ alternate: true }, args56[2]), " ", rs.fmtSpec({ alternate: true }, args56[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args56[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args56[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args56[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args56[3]), "|", rs.fmtSpec({ alternate: true }, args56[1]), " ", rs.fmtSpec({ width: 3 }, args56[1])])); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v10, f), (f: rs.Formatter) => rs.i64LowerHex(v10, f), (f: rs.Formatter) => rs.i64Binary(v10, f), (f: rs.Formatter) => rs.i64Octal(v10, f), (f: rs.Formatter) => rs.i64Debug(v10, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args58[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args58[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args58[1]), " ", args58[0], " ", rs.fmtSpec({ precision: 3 }, args58[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args58[0]), "|", args58[2], " ", rs.fmtSpec({ alternate: true }, args58[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args58[2]), " ", args58[3], " ", rs.fmtSpec({ alternate: true }, args58[3]), " ", rs.fmtSpec({ plus: true }, args58[3]), "|", rs.fmtSpec({ debugHex: "x" }, args58[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args58[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args58[4]), " ", rs.fmtSpec({ plus: true }, args58[4])])); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.i64LowerExp(v10, f), (f: rs.Formatter) => rs.i64UpperExp(v10, f)]; + put(out, rs.fmtFormat([args60[0], " ", args60[1], " ", rs.fmtSpec({ precision: 0 }, args60[0]), " ", rs.fmtSpec({ precision: 1 }, args60[0]), " ", rs.fmtSpec({ precision: 3 }, args60[0]), " ", rs.fmtSpec({ precision: 45 }, args60[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args60[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args60[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args60[0]), "| ", rs.fmtSpec({ alternate: true }, args60[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args60[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i64Display(v10, f))); } else if (_4 === 10) { - const buf11: Uint8Array = rt.bytes(16); - const n11: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf11).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf11), 0, n11), rt.byteSliceRange(data, 0, n11)); - const v11: rt.i128 = rt.i128FromBeBytes(buf11); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128Debug(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128UpperHex(v11, f)]; - put(out, rt.fmtFormat([args62[0], " ", args62[1], " ", rt.fmtSpec({ width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rt.fmtSpec({ alternate: true }, args62[2]), " ", rt.fmtSpec({ alternate: true }, args62[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rt.fmtSpec({ alternate: true }, args62[1]), " ", rt.fmtSpec({ width: 3 }, args62[1])])); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(v11, f), (f: rt.Formatter) => rt.i128LowerHex(v11, f), (f: rt.Formatter) => rt.i128Binary(v11, f), (f: rt.Formatter) => rt.i128Octal(v11, f), (f: rt.Formatter) => rt.i128Debug(v11, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args64[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args64[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args64[1]), " ", args64[0], " ", rt.fmtSpec({ precision: 3 }, args64[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args64[0]), "|", args64[2], " ", rt.fmtSpec({ alternate: true }, args64[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args64[2]), " ", args64[3], " ", rt.fmtSpec({ alternate: true }, args64[3]), " ", rt.fmtSpec({ plus: true }, args64[3]), "|", rt.fmtSpec({ debugHex: "x" }, args64[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args64[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args64[4]), " ", rt.fmtSpec({ plus: true }, args64[4])])); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.i128LowerExp(v11, f), (f: rt.Formatter) => rt.i128UpperExp(v11, f)]; - put(out, rt.fmtFormat([args66[0], " ", args66[1], " ", rt.fmtSpec({ precision: 0 }, args66[0]), " ", rt.fmtSpec({ precision: 1 }, args66[0]), " ", rt.fmtSpec({ precision: 3 }, args66[0]), " ", rt.fmtSpec({ precision: 45 }, args66[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args66[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args66[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args66[0]), "| ", rt.fmtSpec({ alternate: true }, args66[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args66[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.i128Display(v11, f))); + const buf11: Uint8Array = rs.bytes(16); + const n11: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf11).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf11), 0, n11), rs.byteSliceRange(data, 0, n11)); + const v11: rs.i128 = rs.i128FromBeBytes(buf11); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128UpperHex(v11, f)]; + put(out, rs.fmtFormat([args62[0], " ", args62[1], " ", rs.fmtSpec({ width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args62[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args62[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args62[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args62[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args62[0]), "|", args62[2], " ", args62[3], " ", rs.fmtSpec({ alternate: true }, args62[2]), " ", rs.fmtSpec({ alternate: true }, args62[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args62[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args62[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args62[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args62[3]), "|", rs.fmtSpec({ alternate: true }, args62[1]), " ", rs.fmtSpec({ width: 3 }, args62[1])])); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(v11, f), (f: rs.Formatter) => rs.i128LowerHex(v11, f), (f: rs.Formatter) => rs.i128Binary(v11, f), (f: rs.Formatter) => rs.i128Octal(v11, f), (f: rs.Formatter) => rs.i128Debug(v11, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args64[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args64[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args64[1]), " ", args64[0], " ", rs.fmtSpec({ precision: 3 }, args64[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args64[0]), "|", args64[2], " ", rs.fmtSpec({ alternate: true }, args64[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args64[2]), " ", args64[3], " ", rs.fmtSpec({ alternate: true }, args64[3]), " ", rs.fmtSpec({ plus: true }, args64[3]), "|", rs.fmtSpec({ debugHex: "x" }, args64[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args64[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args64[4]), " ", rs.fmtSpec({ plus: true }, args64[4])])); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.i128LowerExp(v11, f), (f: rs.Formatter) => rs.i128UpperExp(v11, f)]; + put(out, rs.fmtFormat([args66[0], " ", args66[1], " ", rs.fmtSpec({ precision: 0 }, args66[0]), " ", rs.fmtSpec({ precision: 1 }, args66[0]), " ", rs.fmtSpec({ precision: 3 }, args66[0]), " ", rs.fmtSpec({ precision: 45 }, args66[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args66[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args66[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args66[0]), "| ", rs.fmtSpec({ alternate: true }, args66[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args66[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.i128Display(v11, f))); } else { - const buf12: Uint8Array = rt.bytes(4); - const n12: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf12).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf12), 0, n12), rt.byteSliceRange(data, 0, n12)); - const v12: rt.isize = rt.isizeFromBeBytes(buf12); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeDebug(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeUpperHex(v12, f)]; - put(out, rt.fmtFormat([args68[0], " ", args68[1], " ", rt.fmtSpec({ width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rt.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rt.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rt.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rt.fmtSpec({ alternate: true }, args68[2]), " ", rt.fmtSpec({ alternate: true }, args68[3]), " ", rt.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rt.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rt.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rt.fmtSpec({ alternate: true }, args68[1]), " ", rt.fmtSpec({ width: 3 }, args68[1])])); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(v12, f), (f: rt.Formatter) => rt.isizeLowerHex(v12, f), (f: rt.Formatter) => rt.isizeBinary(v12, f), (f: rt.Formatter) => rt.isizeOctal(v12, f), (f: rt.Formatter) => rt.isizeDebug(v12, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true }, args70[0]), " ", rt.fmtSpec({ plus: true, zero: true, width: 6 }, args70[0]), " ", rt.fmtSpec({ plus: true, alternate: true }, args70[1]), " ", args70[0], " ", rt.fmtSpec({ precision: 3 }, args70[0]), " ", rt.fmtSpec({ width: 8, precision: 2 }, args70[0]), "|", args70[2], " ", rt.fmtSpec({ alternate: true }, args70[2]), " ", rt.fmtSpec({ alternate: true, zero: true, width: 12 }, args70[2]), " ", args70[3], " ", rt.fmtSpec({ alternate: true }, args70[3]), " ", rt.fmtSpec({ plus: true }, args70[3]), "|", rt.fmtSpec({ debugHex: "x" }, args70[4]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args70[4]), " ", rt.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args70[4]), " ", rt.fmtSpec({ plus: true }, args70[4])])); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeLowerExp(v12, f), (f: rt.Formatter) => rt.isizeUpperExp(v12, f)]; - put(out, rt.fmtFormat([args72[0], " ", args72[1], " ", rt.fmtSpec({ precision: 0 }, args72[0]), " ", rt.fmtSpec({ precision: 1 }, args72[0]), " ", rt.fmtSpec({ precision: 3 }, args72[0]), " ", rt.fmtSpec({ precision: 45 }, args72[1]), " ", rt.fmtSpec({ plus: true, precision: 2 }, args72[0]), " ", rt.fmtSpec({ zero: true, width: 12, precision: 1 }, args72[0]), " ", rt.fmtSpec({ align: "<", plus: true, width: 9 }, args72[0]), "| ", rt.fmtSpec({ alternate: true }, args72[0]), " ", rt.fmtSpec({ align: ">", width: 12, precision: 4 }, args72[1]), "|"])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.isizeDisplay(v12, f))); + const buf12: Uint8Array = rs.bytes(4); + const n12: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf12).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf12), 0, n12), rs.byteSliceRange(data, 0, n12)); + const v12: rs.isize = rs.isizeFromBeBytes(buf12); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeUpperHex(v12, f)]; + put(out, rs.fmtFormat([args68[0], " ", args68[1], " ", rs.fmtSpec({ width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "^", width: 7 }, args68[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args68[0]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 9 }, args68[0]), "|", rs.fmtSpec({ fill: "é", align: ">", width: 6 }, args68[0]), "|", rs.fmtSpec({ zero: true, width: 5 }, args68[0]), "|", rs.fmtSpec({ align: "<", zero: true, width: 5 }, args68[0]), "|", args68[2], " ", args68[3], " ", rs.fmtSpec({ alternate: true }, args68[2]), " ", rs.fmtSpec({ alternate: true }, args68[3]), " ", rs.fmtSpec({ zero: true, width: 8 }, args68[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args68[2]), " ", rs.fmtSpec({ align: ">", width: 8 }, args68[2]), "|", rs.fmtSpec({ align: "<", alternate: true, width: 6 }, args68[3]), "|", rs.fmtSpec({ alternate: true }, args68[1]), " ", rs.fmtSpec({ width: 3 }, args68[1])])); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(v12, f), (f: rs.Formatter) => rs.isizeLowerHex(v12, f), (f: rs.Formatter) => rs.isizeBinary(v12, f), (f: rs.Formatter) => rs.isizeOctal(v12, f), (f: rs.Formatter) => rs.isizeDebug(v12, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true }, args70[0]), " ", rs.fmtSpec({ plus: true, zero: true, width: 6 }, args70[0]), " ", rs.fmtSpec({ plus: true, alternate: true }, args70[1]), " ", args70[0], " ", rs.fmtSpec({ precision: 3 }, args70[0]), " ", rs.fmtSpec({ width: 8, precision: 2 }, args70[0]), "|", args70[2], " ", rs.fmtSpec({ alternate: true }, args70[2]), " ", rs.fmtSpec({ alternate: true, zero: true, width: 12 }, args70[2]), " ", args70[3], " ", rs.fmtSpec({ alternate: true }, args70[3]), " ", rs.fmtSpec({ plus: true }, args70[3]), "|", rs.fmtSpec({ debugHex: "x" }, args70[4]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args70[4]), " ", rs.fmtSpec({ zero: true, debugHex: "x", width: 6 }, args70[4]), " ", rs.fmtSpec({ plus: true }, args70[4])])); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeLowerExp(v12, f), (f: rs.Formatter) => rs.isizeUpperExp(v12, f)]; + put(out, rs.fmtFormat([args72[0], " ", args72[1], " ", rs.fmtSpec({ precision: 0 }, args72[0]), " ", rs.fmtSpec({ precision: 1 }, args72[0]), " ", rs.fmtSpec({ precision: 3 }, args72[0]), " ", rs.fmtSpec({ precision: 45 }, args72[1]), " ", rs.fmtSpec({ plus: true, precision: 2 }, args72[0]), " ", rs.fmtSpec({ zero: true, width: 12, precision: 1 }, args72[0]), " ", rs.fmtSpec({ align: "<", plus: true, width: 9 }, args72[0]), "| ", rs.fmtSpec({ alternate: true }, args72[0]), " ", rs.fmtSpec({ align: ">", width: 12, precision: 4 }, args72[1]), "|"])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.isizeDisplay(v12, f))); } } /** Strings padded and escaped, and bytes that may not be UTF-8. */ -export function strings(data: rt.ByteSlice, out: rt.ByteVec): void { +export function strings(data: rs.ByteSlice, out: rs.ByteVec): void { let flag!: boolean; - for (const _9 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 3)))) { - const _15: rt.usize = rt.usizeRem(_9 as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + for (const _9 of rs.byteSliceView(rs.byteSliceRange(data, 0, rs.min(data.length, 3)))) { + const _15: rs.usize = rs.usizeRem(_9 as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_15 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _15); } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_15]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s), (f: rt.Formatter) => rt.fmtStr(s, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ width: 8 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rt.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ width: 12 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s), (f: rt.Formatter) => rt.fmtStr(s, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 2 }, args4[0]), "|", rt.fmtSpec({ width: 8, precision: 3 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 6, precision: 1 }, args4[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args4[0]), "|", rt.fmtSpec({ precision: 0 }, args4[0]), "|", rt.fmtSpec({ precision: 20 }, args4[0]), "|", rt.fmtSpec({ precision: 2 }, args4[1]), "|", rt.fmtSpec({ width: 10, precision: 2 }, args4[1]), "|", rt.fmtSpec({ plus: true }, args4[0])])); - } - const c: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(rt.u32Mul(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.u32, 257)), 63); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(c, f), (f: rt.Formatter) => rt.fmtCharDebug(c, f)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ precision: 0 }, args6[0]), "|", rt.fmtSpec({ width: 3, precision: 1 }, args6[0]), "|", rt.fmtSpec({ precision: 0 }, args6[1]), "|", rt.fmtSpec({ align: ">", width: 4 }, args6[1])])); - const _70: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ width: 8 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 8 }, args2[0]), "|", rs.fmtSpec({ align: "^", width: 8 }, args2[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ width: 12 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1]), "|{", args2[0], "}"])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 2 }, args4[0]), "|", rs.fmtSpec({ width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 6, precision: 1 }, args4[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7, precision: 2 }, args4[0]), "|", rs.fmtSpec({ precision: 0 }, args4[0]), "|", rs.fmtSpec({ precision: 20 }, args4[0]), "|", rs.fmtSpec({ precision: 2 }, args4[1]), "|", rs.fmtSpec({ width: 10, precision: 2 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[0])])); + } + const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 257)), 63); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ precision: 0 }, args6[0]), "|", rs.fmtSpec({ width: 3, precision: 1 }, args6[0]), "|", rs.fmtSpec({ precision: 0 }, args6[1]), "|", rs.fmtSpec({ align: ">", width: 4 }, args6[1])])); + const _70: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_70.ok) { const s2: string = _70.value; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(s2, f), (f: rt.Formatter) => rt.fmtPad(f, s2)]; - put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ align: ">", width: 4 }, args8[1]), " ", rt.fmtSpec({ precision: 1 }, args8[1])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s2, f), (f: rs.Formatter) => rs.fmtPad(f, s2)]; + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ align: ">", width: 4 }, args8[1]), " ", rs.fmtSpec({ precision: 1 }, args8[1])])); } else { - const e: rt.FromUtf8Error = _70.error; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFromUtf8ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtFromUtf8ErrorDebug(e, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", rt.fmtSpec({ alternate: true }, args10[1]), " ", rt.fmtSpec({ align: ">", width: 80 }, args10[0]), " ", rt.fmtSpec({ precision: 4 }, args10[0]), " ", rt.fmtSpec({ debugHex: "x" }, args10[1]), " ", rt.fmtSpec({ alternate: true, debugHex: "X" }, args10[1])])); + const e: rs.FromUtf8Error = _70.error; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf8ErrorDebug(e, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1]), " ", rs.fmtSpec({ align: ">", width: 80 }, args10[0]), " ", rs.fmtSpec({ precision: 4 }, args10[0]), " ", rs.fmtSpec({ debugHex: "x" }, args10[1]), " ", rs.fmtSpec({ alternate: true, debugHex: "X" }, args10[1])])); } - const _100: rt.u8 | undefined = rt.byteSliceFirst(data); + const _100: rs.u8 | undefined = rs.byteSliceFirst(data); b3: { if (_100 !== undefined) { - if (rt.u8Rem(_100, 2) === 0) { + if (rs.u8Rem(_100, 2) === 0) { flag = true; break b3; } } flag = false; } - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", rt.fmtSpec({ align: ">", width: 6 }, args12[0]), " ", rt.fmtSpec({ precision: 2 }, args12[0]), " ", rt.fmtSpec({ align: ">", width: 4, precision: 1 }, args12[1]), " ", args12[2], " ", rt.fmtSpec({ alternate: true }, args12[3]), " ", rt.fmtSpec({ precision: 1 }, args12[4])])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", rs.fmtSpec({ align: ">", width: 6 }, args12[0]), " ", rs.fmtSpec({ precision: 2 }, args12[0]), " ", rs.fmtSpec({ align: ">", width: 4, precision: 1 }, args12[1]), " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3]), " ", rs.fmtSpec({ precision: 1 }, args12[4])])); const _130: boolean = flag; - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtBool(_130, f))); - const _131: rt.Result = rt.u8TryFrom(rt.i32Sub(data.length | 0, 3)); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtBool(_130, f))); + const _131: rs.Result = rs.u8TryFrom(rs.i32Sub(data.length | 0, 3)); if (_131.ok) { const arg = _131.value; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f)]; - put(out, rt.fmtFormat([args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f)]; + put(out, rs.fmtFormat([args14[0]])); } else { - const e2: rt.TryFromIntError = _131.error; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTryFromIntErrorDisplay(e2, f), (f: rt.Formatter) => rt.fmtTryFromIntErrorDebug(e2, f)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", rt.fmtSpec({ align: ">", width: 40 }, args16[0]), "| ", rt.fmtSpec({ precision: 6 }, args16[0]), "|", rt.fmtSpec({ width: 10, precision: 3 }, args16[0]), "|"])); + const e2: rs.TryFromIntError = _131.error; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtTryFromIntErrorDebug(e2, f)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", rs.fmtSpec({ align: ">", width: 40 }, args16[0]), "| ", rs.fmtSpec({ precision: 6 }, args16[0]), "|", rs.fmtSpec({ width: 10, precision: 3 }, args16[0]), "|"])); } } -export function nested(data: rt.ByteSlice): Nested.Nested { +export function nested(data: rs.ByteSlice): Nested.Nested { let _22!: Shape.Shape; let _49!: Pair.Pair | undefined; - let _61!: rt.Result; + let _61!: rs.Result; let _90!: Kind.Kind; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _5: rt.usize = rt.usizeRem(at(0) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const _5: rs.usize = rs.usizeRem(at(0) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_5 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _5); } const _3: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_5]; - const _15: Point.Point = { x: rt.i32Sub(at(1) as rt.i32, 128), y: -7 }; - const _23: rt.u8 = rt.u8Rem(at(2), 3); + const _15: Point.Point = { x: rs.i32Sub(at(1) as rs.i32, 128), y: -7 }; + const _23: rs.u8 = rs.u8Rem(at(2), 3); if (_23 === 0) { _22 = { tag: "Dot" } as Shape.Shape; } else if (_23 === 1) { _22 = { tag: "Line", _0: { x: 1, y: 2 }, _1: { x: -3, y: 4 } } as Shape.Shape; } else { - _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rt.u16, height: 9 } as Shape.Shape; + _22 = { tag: "Rect", corner: { x: 0, y: 0 }, width: at(3) as rs.u16, height: 9 } as Shape.Shape; } - const _35: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 0, rt.min(data.length, 4))); - const _40: rt.Vec = rt.vecFrom([{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }].slice()); - if (!(rt.u8Rem(at(5), 2) === 0)) { + const _35: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 0, rs.min(data.length, 4))); + const _40: rs.Vec = rs.vecFrom([{ _0: at(4), _1: -1 }, { _0: 2, _1: { hi: -0x80000000, lo: 0 } as rs.i64 }].slice()); + if (!(rs.u8Rem(at(5), 2) === 0)) { _49 = undefined; } else { _49 = { _0: at(5), _1: 5 }; } - const _60: rt.u8 | undefined = undefined; - if (!(rt.u8Rem(at(6), 2) === 0)) { - _61 = rt.Err("no"); + const _60: rs.u8 | undefined = undefined; + if (!(rs.u8Rem(at(6), 2) === 0)) { + _61 = rs.Err("no"); } else { - _61 = rt.Ok(at(6)); + _61 = rs.Ok(at(6)); } - const _73: rt.i16[] = [rt.i16Sub(at(7) as rt.i16, 100), 32767]; - const _80: [rt.u8, boolean, string] = [at(8), true, "t"]; - const _84: [rt.u8] = [at(9)]; - const _88: rt.ByteVec = new rt.ByteVec(); - const _91: rt.u8 = rt.u8Rem(at(10), 3); + const _73: rs.i16[] = [rs.i16Sub(at(7) as rs.i16, 100), 32767]; + const _80: [rs.u8, boolean, string] = [at(8), true, "t"]; + const _84: [rs.u8] = [at(9)]; + const _88: rs.ByteVec = new rs.ByteVec(); + const _91: rs.u8 = rs.u8Rem(at(10), 3); if (_91 === 0) { _90 = { tag: "Empty" } as Kind.Kind; } else if (_91 === 1) { _90 = { tag: "One", _0: at(11) } as Kind.Kind; } else { - _90 = { tag: "Many", count: 2, items: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(at(11), at(12)))) } as Kind.Kind; + _90 = { tag: "Many", count: 2, items: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(at(11), at(12)))) } as Kind.Kind; } return { name: _3, point: _15, shape: _22, tags: _35, pairs: _40, maybe: _49, none: _60, result: _61, list: _73, tuple: _80, single: _84, empty: _88, unit: undefined, boxed: _90 }; } /** Derived `Debug` of every shape, compact and pretty, with options passed to fields. */ -export function derived(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function derived(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; const value: Nested.Nested = nested(data); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rt.fmtFormat([args2[0]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); - const args6: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args6[0])])); - const args8: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true, debugHex: "X" }, args8[0])])); - const args10: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ plus: true, precision: 1 }, args10[0])])); - const wide: fmt_Wide.Wide = { a: at(0), b: 300, c: 70000, d: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, e: -1, f: at(1) > 10 }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + put(out, rs.fmtFormat([args2[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args6[0])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true, debugHex: "X" }, args8[0])])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ plus: true, precision: 1 }, args10[0])])); + const wide: fmt_Wide.Wide = { a: at(0), b: 300, c: 70000, d: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, e: -1, f: at(1) > 10 }; const six: Six.Six = { _0: at(0), _1: 1, _2: 2, _3: 3, _4: 4, _5: at(1) }; const _87: Unit.Unit = {}; const _88: Unit.Unit = {}; - const args12: rt.Fmt[] = [(f: rt.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rt.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rt.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rt.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", rt.fmtSpec({ alternate: true }, args12[3])])); - const args14: rt.Fmt[] = [(f: rt.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rt.Formatter) => Six.fmt$fmt_Debug(six, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args14[0]), " ", rt.fmtSpec({ alternate: true }, args14[1])])); - const point: Point.Point = { x: at(2) as rt.i32, y: -1 }; + const args12: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_88, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", rs.fmtSpec({ alternate: true }, args12[3])])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => fmt_Wide.fmt$fmt_Debug(wide, f), (f: rs.Formatter) => Six.fmt$fmt_Debug(six, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ alternate: true }, args14[1])])); + const point: Point.Point = { x: at(2) as rs.i32, y: -1 }; const _125: Pair.Pair = { _0: at(3), _1: -9 }; - const args16: rt.Fmt[] = [(f: rt.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rt.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ width: 5 }, args16[0]), "|", rt.fmtSpec({ align: "<", width: 4 }, args16[0]), "|", rt.fmtSpec({ alternate: true, width: 4 }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args16[1])])); - const kinds: Kind.Kind[] = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rt.ByteVec() } as Kind.Kind]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => Point.fmt$fmt_Debug(point, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_125, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args16[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args16[0]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[1])])); + const kinds: Kind.Kind[] = [{ tag: "Empty" } as Kind.Kind, { tag: "One", _0: at(4) } as Kind.Kind, { tag: "Braced" } as Kind.Kind, { tag: "Bare" } as Kind.Kind, { tag: "Many", count: 0, items: new rs.ByteVec() } as Kind.Kind]; const _154: Kind.Kind = kinds[1]; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; - put(out, rt.fmtFormat([args18[0], " ", args18[1]])); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(kinds, f, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args20[0])])); - const words: rt.u16[] = [at(5) as rt.u16, 65535]; - const _189: rt.u8 | undefined = rt.byteSliceFirst(data); - const _191: rt.u8 | undefined = rt.byteSliceGet(data, 100); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(data), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(words, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtOption(_189, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_191, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => Kind.fmt$fmt_Debug(_154, f)]; + put(out, rs.fmtFormat([args18[0], " ", args18[1]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(kinds, f, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args20[0])])); + const words: rs.u16[] = [at(5) as rs.u16, 65535]; + const _189: rs.u8 | undefined = rs.byteSliceFirst(data); + const _191: rs.u8 | undefined = rs.byteSliceGet(data, 100); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(data), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(words, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(_189, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_191, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args22[0], " ", args22[1], " ", args22[2], " ", args22[3]])); const _208: Braced.Braced = {}; const _209: Braced.Braced = {}; const _210: Bare.Bare = {}; const _211: Bare.Bare = {}; - const args24: rt.Fmt[] = [(f: rt.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rt.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rt.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rt.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; - put(out, rt.fmtFormat([args24[0], " ", rt.fmtSpec({ alternate: true }, args24[1]), " ", args24[2], " ", rt.fmtSpec({ alternate: true }, args24[3])])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(Braced.eq$cmp_PartialEq({}, {}) ? 1 : 0, Bare.eq$cmp_PartialEq({}, {}) ? 1 : 0))); + const args24: rs.Fmt[] = [(f: rs.Formatter) => Braced.fmt$fmt_Debug(_208, f), (f: rs.Formatter) => Braced.fmt$fmt_Debug(_209, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_210, f), (f: rs.Formatter) => Bare.fmt$fmt_Debug(_211, f)]; + put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[1]), " ", args24[2], " ", rs.fmtSpec({ alternate: true }, args24[3])])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(Braced.eq$cmp_PartialEq({}, {}) ? 1 : 0, Bare.eq$cmp_PartialEq({}, {}) ? 1 : 0))); } /** `v`, logged, so an argument evaluated more than once shows. */ -export function note(log: rt.ByteVec, v: rt.u8): rt.u8 { - rt.byteVecPush(log, v); +export function note(log: rs.ByteVec, v: rs.u8): rs.u8 { + rs.byteVecPush(log, v); return v; } /** Arguments that read `log` before and after one changes it, through a reference. */ -export function logged(log: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { - const _7: rt.usize = log.length; +export function logged(log: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): string { + const _7: rs.usize = log.length; if (0 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + 0); } - const _10: rt.u8 = note(log, dataData[dataStart]); - const _16: rt.usize = rt.usizeRem(log.length, dataLen); + const _10: rs.u8 = note(log, dataData[dataStart]); + const _16: rs.usize = rs.usizeRem(log.length, dataLen); if (_16 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _16); } - const _24: rt.usize = log.length; + const _24: rs.usize = log.length; const part = dataData[dataStart + _16]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_7, f), (f: rt.Formatter) => rt.u8Display(_10, f), (f: rt.Formatter) => rt.u8Display(part, f), (f: rt.Formatter) => rt.usizeDisplay(_24, f)]; - return rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_7, f), (f: rs.Formatter) => rs.u8Display(_10, f), (f: rs.Formatter) => rs.u8Display(part, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; + return rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]); } /** Written `Display` and `Debug`, and a `Display` that fails inside `format!`. */ -export function written(data: rt.ByteSlice, out: rt.ByteVec): void { - let _116!: rt.u8 | undefined; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function written(data: rs.ByteSlice, out: rs.ByteVec): void { + let _116!: rs.u8 | undefined; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const hex: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rt.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rt.fmtSpec({ alternate: true }, args2[1])])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rt.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args4[0]), "|", rt.fmtSpec({ alternate: true }, args4[1]), "|", rt.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rt.fmtSpec({ precision: 2 }, args4[3]), "|", args4[4], "|", rt.fmtSpec({ plus: true, precision: 1 }, args4[0])])); - put(out, rt.fmtToString((f: rt.Formatter) => Hex.fmt$fmt_Display(hex, f))); + const hex: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", args2[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args2[1]), "|", rs.fmtSpec({ alternate: true }, args2[1])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Debug(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Binary(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_Octal(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_LowerExp(hex, f), (f: rs.Formatter) => Hex.fmt$fmt_UpperExp(hex, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", rs.fmtSpec({ align: ">", width: 8 }, args4[2]), "|", rs.fmtSpec({ precision: 2 }, args4[3]), "|", args4[4], "|", rs.fmtSpec({ plus: true, precision: 1 }, args4[0])])); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(hex, f))); const arg = { _0: "pad" }; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Padded.fmt$fmt_Display(arg, f)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rt.fmtSpec({ width: 30 }, args6[0]), "|"])); - const manual: Manual.Manual = { id: at(1), list: rt.vecFrom([1, at(2) as rt.u16].slice()) }; - const empty: Manual.Manual = { id: 0, list: new rt.Vec() }; - const args8: rt.Fmt[] = [(f: rt.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rt.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; - put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); - const seq: Seq.Seq = { _0: rt.vecFrom([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice()) }; - const none: Seq.Seq = { _0: new rt.Vec() }; - const args10: rt.Fmt[] = [(f: rt.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rt.Formatter) => Seq.fmt$fmt_Debug(none, f)]; - put(out, rt.fmtFormat([args10[0], " ", rt.fmtSpec({ alternate: true }, args10[0]), " ", args10[1], " ", rt.fmtSpec({ alternate: true }, args10[1])])); - const _113: rt.u8 = at(4); - if (!(rt.u8Rem(at(5), 2) === 0)) { + const args6: rs.Fmt[] = [(f: rs.Formatter) => Padded.fmt$fmt_Display(arg, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 9 }, args6[0]), "|", rs.fmtSpec({ width: 30 }, args6[0]), "|"])); + const manual: Manual.Manual = { id: at(1), list: rs.vecFrom([1, at(2) as rs.u16].slice()) }; + const empty: Manual.Manual = { id: 0, list: new rs.Vec() }; + const args8: rs.Fmt[] = [(f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(empty, f)]; + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", args8[1]])); + const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(3), _1: 0 }, { _0: 1, _1: -1 }].slice()) }; + const none: Seq.Seq = { _0: new rs.Vec() }; + const args10: rs.Fmt[] = [(f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(none, f)]; + put(out, rs.fmtFormat([args10[0], " ", rs.fmtSpec({ alternate: true }, args10[0]), " ", args10[1], " ", rs.fmtSpec({ alternate: true }, args10[1])])); + const _113: rs.u8 = at(4); + if (!(rs.u8Rem(at(5), 2) === 0)) { _116 = undefined; } else { _116 = at(5); } const arg2 = { _0: _113, _1: _116 }; - const args12: rt.Fmt[] = [(f: rt.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; - put(out, rt.fmtFormat([args12[0], " ", rt.fmtSpec({ alternate: true }, args12[0])])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(arg2, f)]; + put(out, rs.fmtFormat([args12[0], " ", rs.fmtSpec({ alternate: true }, args12[0])])); const part = { _0: at(6) & (~1 & 0xff) }; - const args14: rt.Fmt[] = [(f: rt.Formatter) => Fails.fmt$fmt_Display(part, f)]; - put(out, rt.fmtFormat([args14[0], " ", rt.fmtSpec({ align: ">", width: 9 }, args14[0])])); - const _164: rt.u8 = at(7); - const _168: rt.u8 = at(8); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_168, f), (f: rt.Formatter) => rt.u8Display(_164, f), (f: rt.Formatter) => rt.u8Debug(_164, f), (f: rt.Formatter) => rt.fmtPad(f, "named")]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " named ", rt.fmtSpec({ align: ">", width: 5 }, args16[3])])); - const log: rt.ByteVec = new rt.ByteVec(); - const _187: rt.u8 = at(9); - const _185: rt.u8 = note(log, _187); - const _194: rt.u8 = at(10); + const args14: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part, f)]; + put(out, rs.fmtFormat([args14[0], " ", rs.fmtSpec({ align: ">", width: 9 }, args14[0])])); + const _164: rs.u8 = at(7); + const _168: rs.u8 = at(8); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_168, f), (f: rs.Formatter) => rs.u8Display(_164, f), (f: rs.Formatter) => rs.u8Debug(_164, f), (f: rs.Formatter) => rs.fmtPad(f, "named")]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " ", args16[2], " named ", rs.fmtSpec({ align: ">", width: 5 }, args16[3])])); + const log: rs.ByteVec = new rs.ByteVec(); + const _187: rs.u8 = at(9); + const _185: rs.u8 = note(log, _187); + const _194: rs.u8 = at(10); const _191: boolean = note(log, _194) === 3; - const _198: rt.usize = log.length; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_191, f), (f: rt.Formatter) => rt.u8Display(_185, f), (f: rt.Formatter) => rt.u8Debug(_185, f), (f: rt.Formatter) => rt.usizeDisplay(_198, f)]; - put(out, rt.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " ", args18[3], " ", args18[1]])); + const _198: rs.usize = log.length; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_191, f), (f: rs.Formatter) => rs.u8Display(_185, f), (f: rs.Formatter) => rs.u8Debug(_185, f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; + put(out, rs.fmtFormat([args18[0], " ", args18[1], " ", args18[2], " ", args18[3], " ", args18[1]])); const _218: Noted.Noted = { _0: at(11) }; const _222: Noted.Noted = { _0: 2 }; - const args20: rt.Fmt[] = [(f: rt.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rt.Formatter) => Noted.fmt$fmt_Display(_222, f)]; - put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args20[1])])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => Noted.fmt$fmt_Display(_218, f), (f: rs.Formatter) => Noted.fmt$fmt_Display(_222, f)]; + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args20[1])])); if (!(data.length === 0)) { put(out, logged(log, data.data, data.start, data.length)); } - const _241: rt.u8 = at(13); + const _241: rs.u8 = at(13); const part2 = note(log, _241); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(part2, f)]; - const once: string = rt.fmtFormat([args22[0]]); - const _257: rt.usize = log.length; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, once), (f: rt.Formatter) => rt.usizeDisplay(_257, f)]; - put(out, rt.fmtFormat([args24[0], " ", args24[1]])); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(part2, f)]; + const once: string = rs.fmtFormat([args22[0]]); + const _257: rs.usize = log.length; + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, once), (f: rs.Formatter) => rs.usizeDisplay(_257, f)]; + put(out, rs.fmtFormat([args24[0], " ", args24[1]])); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); if (at(12) > 250) { - const _277: rt.u8 = at(12); - const _275: rt.u8 = note(log, _277); - const _281: rt.usize = log.length; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_275, f), (f: rt.Formatter) => rt.usizeDisplay(_281, f)]; - rt.panicFmt([args26[0], " ", args26[1]]); + const _277: rs.u8 = at(12); + const _275: rs.u8 = note(log, _277); + const _281: rs.usize = log.length; + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_275, f), (f: rs.Formatter) => rs.usizeDisplay(_281, f)]; + rs.panicFmt([args26[0], " ", args26[1]]); } } @@ -434,176 +434,176 @@ export function written(data: rt.ByteSlice, out: rt.ByteVec): void { * Widths and precisions from arguments, by position and by name, and one past * `u16::MAX`, which panics. */ -export function counts(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function counts(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 24) as rt.usize, rt.u8Rem(at(1), 12) as rt.usize]; - const w: rt.usize = _6[0]; - const p: rt.usize = _6[1]; - const data2: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 2)); - const buf: Uint8Array = rt.bytes(8); - const n: rt.usize = rt.min(data2.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data2, 0, n)); - const v: rt.i64 = rt.i64FromBeBytes(buf); - const _39: rt.usize = rt.usizeRem(at(3) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const _6: [rs.usize, rs.usize] = [rs.u8Rem(at(0), 24) as rs.usize, rs.u8Rem(at(1), 12) as rs.usize]; + const w: rs.usize = _6[0]; + const p: rs.usize = _6[1]; + const data2: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 2)); + const buf: Uint8Array = rs.bytes(8); + const n: rs.usize = rs.min(data2.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data2, 0, n)); + const v: rs.i64 = rs.i64FromBeBytes(buf); + const _39: rs.usize = rs.usizeRem(at(3) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_39 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _39); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _39); } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_39]; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(v, f), rt.fmtCount(w), (f: rt.Formatter) => rt.i64LowerExp(v, f), rt.fmtCount(p), (f: rt.Formatter) => rt.fmtPad(f, s), (f: rt.Formatter) => rt.fmtPad(f, s), rt.fmtCount(p), (f: rt.Formatter) => rt.usizeDisplay(w, f), rt.fmtCount(w), (f: rt.Formatter) => rt.fmtStr(s, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ width: rt.fmtCountOf(args2[1]) }, args2[0]), "|", rt.fmtSpec({ align: "<", width: rt.fmtCountOf(args2[1]) }, args2[2]), "|", rt.fmtSpec({ plus: true, zero: true, width: rt.fmtCountOf(args2[1]), precision: rt.fmtCountOf(args2[3]) }, args2[2]), "|", rt.fmtSpec({ precision: rt.fmtCountOf(args2[3]) }, args2[4]), "|", rt.fmtSpec({ align: "^", width: rt.fmtCountOf(args2[1]), precision: rt.fmtCountOf(args2[3]) }, args2[4]), "|", rt.fmtSpec({ precision: rt.fmtCountOf(args2[6]) }, args2[5]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args2[6]) }, args2[7]), "|", rt.fmtSpec({ width: rt.fmtCountOf(args2[8]), precision: rt.fmtCountOf(args2[6]) }, args2[5]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args2[3]) }, args2[9])])); - const log: rt.ByteVec = new rt.ByteVec(); - const _87: rt.u8 = at(4); - const _85: rt.u8 = note(log, _87); - const _91: rt.usize = note(log, 6) as rt.usize; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_85, f), rt.fmtCount(_91), (f: rt.Formatter) => rt.fmtPad(f, s)]; - put(out, rt.fmtFormat([rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args4[1]) }, args4[0]), "|", rt.fmtSpec({ precision: rt.fmtCountOf(args4[1]) }, args4[2])])); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); - const big: rt.usize = rt.usizeAdd(65535 as rt.usize, rt.u8Rem(at(5), 2) as rt.usize); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s), rt.fmtCount(big)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: rt.fmtCountOf(args6[1]) }, args6[0]), "|"])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(v, f), rs.fmtCount(w), (f: rs.Formatter) => rs.i64LowerExp(v, f), rs.fmtCount(p), (f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(p), (f: rs.Formatter) => rs.usizeDisplay(w, f), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ align: "<", width: rs.fmtCountOf(args2[1]) }, args2[2]), "|", rs.fmtSpec({ plus: true, zero: true, width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[2]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args2[1]), precision: rs.fmtCountOf(args2[3]) }, args2[4]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[6]) }, args2[7]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args2[8]), precision: rs.fmtCountOf(args2[6]) }, args2[5]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[3]) }, args2[9])])); + const log: rs.ByteVec = new rs.ByteVec(); + const _87: rs.u8 = at(4); + const _85: rs.u8 = note(log, _87); + const _91: rs.usize = note(log, 6) as rs.usize; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_85, f), rs.fmtCount(_91), (f: rs.Formatter) => rs.fmtPad(f, s)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[1]) }, args4[0]), "|", rs.fmtSpec({ precision: rs.fmtCountOf(args4[1]) }, args4[2])])); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); + const big: rs.usize = rs.usizeAdd(65535 as rs.usize, rs.u8Rem(at(5), 2) as rs.usize); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), rs.fmtCount(big)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args6[1]) }, args6[0]), "|"])); } /** `{:e}` at each rounding: below, above, and ties to even, which may carry a digit. */ -export function rounding(out: rt.ByteVec): void { - const iter: rt.Iter = rt.iterSlice([0, 5, 15, 25, 125, 135, 994, 995, 999, 1000, 1250000, 4294967295]); +export function rounding(out: rs.ByteVec): void { + const iter: rs.Iter = rs.iterSlice([0, 5, 15, 25, 125, 135, 994, 995, 999, 1000, 1250000, 4294967295]); while (true) { - const _5: rt.u32 | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.u32 | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32LowerExp(_5, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 0 }, args2[0]), " ", rt.fmtSpec({ precision: 1 }, args2[0]), " ", rt.fmtSpec({ precision: 2 }, args2[0]), " ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32LowerExp(_5, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args2[0]), " ", rs.fmtSpec({ precision: 1 }, args2[0]), " ", rs.fmtSpec({ precision: 2 }, args2[0]), " ", args2[0]])); } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rt.u128, f), (f: rt.Formatter) => rt.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128, f), (f: rt.Formatter) => rt.i64UpperExp({ hi: -0x80000000, lo: 0 } as rt.i64, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 0 }, args4[0]), " ", args4[1], " ", rt.fmtSpec({ precision: 3 }, args4[2])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u128LowerExp({ hi: 0xffffffff, w2: 0xffffffff, w1: 0xffffffff, lo: 0xffffffff } as rs.u128, f), (f: rs.Formatter) => rs.i128LowerExp({ hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128, f), (f: rs.Formatter) => rs.i64UpperExp({ hi: -0x80000000, lo: 0 } as rs.i64, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 0 }, args4[0]), " ", args4[1], " ", rs.fmtSpec({ precision: 3 }, args4[2])])); } /** Panics, each with the message native Rust formats. */ -export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void { - let r!: rt.Result; - let r2!: rt.Result; - let r4!: rt.Result; - let r5!: rt.Result; - const n: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(rest), 0); - const _7: rt.u8 = rt.u8Rem(kind, 20); +export function panics(kind: rs.u8, rest: rs.ByteSlice, out: rs.ByteVec): void { + let r!: rs.Result; + let r2!: rs.Result; + let r4!: rs.Result; + let r5!: rs.Result; + const n: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(rest), 0); + const _7: rs.u8 = rs.u8Rem(kind, 20); if (_7 === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rest), f, rt.u8Debug)]; - rt.panicFmt(["bad ", args2[0], ": ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rest), f, rs.u8Debug)]; + rs.panicFmt(["bad ", args2[0], ": ", args2[1]]); } else if (_7 === 1) { - const _23: Hex.Hex = { _0: n as rt.u32 }; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8LowerHex(n, f), (f: rt.Formatter) => Hex.fmt$fmt_Display(_23, f)]; - rt.panicFmt(["internal error: entered unreachable code: never ", rt.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); + const _23: Hex.Hex = { _0: n as rs.u32 }; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => Hex.fmt$fmt_Display(_23, f)]; + rs.panicFmt(["internal error: entered unreachable code: never ", rs.fmtSpec({ alternate: true }, args4[0]), " ", args4[1]]); } else if (_7 === 2) { if (!(n > 200)) { const _37: Pair.Pair = { _0: n, _1: 0 }; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => Pair.fmt$fmt_Debug(_37, f)]; - rt.panicFmt(["small ", args6[0], " ", args6[1]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_37, f)]; + rs.panicFmt(["small ", args6[0], " ", args6[1]]); } } else if (_7 === 3) { if (!(n > 200)) { - rt.panic("assertion failed: n > 200"); + rs.panic("assertion failed: n > 200"); } } else if (_7 === 4) { if (!(n === 7)) { - rt.assertFailed("==", (f: rt.Formatter) => rt.u8Debug(n, f), (f: rt.Formatter) => rt.u8Debug(7, f), undefined as rt.Arguments | undefined); + rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(7, f), undefined as rs.Arguments | undefined); } } else if (_7 === 5) { const _58: Pair.Pair = { _0: n, _1: 1 }; const _60: Pair.Pair = { _0: n, _1: 1 }; if (Pair.eq$cmp_PartialEq(_58, _60)) { const kind3: string = "!="; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - const _66: rt.Arguments | undefined = ["same ", args8[0]]; - rt.assertFailed(kind3, (f: rt.Formatter) => Pair.fmt$fmt_Debug(_58, f), (f: rt.Formatter) => Pair.fmt$fmt_Debug(_60, f), _66); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + const _66: rs.Arguments | undefined = ["same ", args8[0]]; + rs.assertFailed(kind3, (f: rs.Formatter) => Pair.fmt$fmt_Debug(_58, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_60, f), _66); } } else if (_7 === 6) { if (!(n === 9)) { - rt.assertFailed("==", (f: rt.Formatter) => rt.u8Debug(n, f), (f: rt.Formatter) => rt.u8Debug(9, f), ["with context"]); + rs.assertFailed("==", (f: rs.Formatter) => rs.u8Debug(n, f), (f: rs.Formatter) => rs.u8Debug(9, f), ["with context"]); } } else if (_7 === 7) { - if (rt.u8Rem(n, 2) === 0) { - r = rt.Err({ tag: "One", _0: n } as Kind.Kind); + if (rs.u8Rem(n, 2) === 0) { + r = rs.Err({ tag: "One", _0: n } as Kind.Kind); } else { - r = rt.Err({ tag: "Many", count: 1, items: rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(n))) } as Kind.Kind); + r = rs.Err({ tag: "Many", count: 1, items: rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(n))) } as Kind.Kind); } - const _100: rt.u8 = rt.resultUnwrap(r, (value: Kind.Kind, f: rt.Formatter) => Kind.fmt$fmt_Debug(value, f)); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_100, f))); + const _100: rs.u8 = rs.resultUnwrap(r, (value: Kind.Kind, f: rs.Formatter) => Kind.fmt$fmt_Debug(value, f)); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_100, f))); } else if (_7 === 8) { if (!(n > 128)) { - r2 = rt.Err({ _0: n, _1: -2 }); + r2 = rs.Err({ _0: n, _1: -2 }); } else { - r2 = rt.Ok(n); + r2 = rs.Ok(n); } - const _110: rt.u8 = rt.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_110, f))); + const _110: rs.u8 = rs.resultExpect(r2, "expected a byte", (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_110, f))); } else if (_7 === 9) { - const _121: rt.u8 = rt.resultUnwrapErr(rt.Ok({ x: n as rt.i32, y: 0 }), (value: Point.Point, f: rt.Formatter) => Point.fmt$fmt_Debug(value, f)); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_121, f))); + const _121: rs.u8 = rs.resultUnwrapErr(rs.Ok({ x: n as rs.i32, y: 0 }), (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f)); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_121, f))); } else if (_7 === 10) { - const missing: rt.u8 | undefined = rt.byteSliceGet(rest, 200); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f)]; - const _129: rt.u8 = rt.optionExpect(missing, rt.fmtFormat(["missing ", args10[0]])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_129, f))); + const missing: rs.u8 | undefined = rs.byteSliceGet(rest, 200); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f)]; + const _129: rs.u8 = rs.optionExpect(missing, rs.fmtFormat(["missing ", args10[0]])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_129, f))); } else if (_7 === 11) { const part3 = { _0: n }; - const args12: rt.Fmt[] = [(f: rt.Formatter) => Fails.fmt$fmt_Display(part3, f)]; - put(out, rt.fmtFormat([args12[0]])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(part3, f)]; + put(out, rs.fmtFormat([args12[0]])); } else if (_7 === 12) { const _157: Fails.Fails = { _0: n }; - put(out, rt.fmtToString((f: rt.Formatter) => Fails.fmt$fmt_Display(_157, f))); + put(out, rs.fmtToString((f: rs.Formatter) => Fails.fmt$fmt_Display(_157, f))); } else if (_7 === 13) { - const _162: Hex.Hex = { _0: n as rt.u32 }; + const _162: Hex.Hex = { _0: n as rs.u32 }; const _165: Fails.Fails = { _0: n }; - const args14: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$fmt_Display(_162, f), (f: rt.Formatter) => Fails.fmt$fmt_Display(_165, f)]; - rt.panicFmt([args14[0], " then ", args14[1]]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(_162, f), (f: rs.Formatter) => Fails.fmt$fmt_Display(_165, f)]; + rs.panicFmt([args14[0], " then ", args14[1]]); } else if (_7 === 14) { - const _173: [rt.usize, rt.usize] = [rt.u8Rem(n, 8) as rt.usize, rt.u8Div(n, 32) as rt.usize]; - const start: rt.usize = _173[0]; - const end: rt.usize = _173[1]; - const _189: rt.ByteSlice = rt.byteSliceRange(rest, start); - const _193: rt.ByteSlice = rt.byteSliceRange(rest, start, end); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_189), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_193), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1]])); + const _173: [rs.usize, rs.usize] = [rs.u8Rem(n, 8) as rs.usize, rs.u8Div(n, 32) as rs.usize]; + const start: rs.usize = _173[0]; + const end: rs.usize = _173[1]; + const _189: rs.ByteSlice = rs.byteSliceRange(rest, start); + const _193: rs.ByteSlice = rs.byteSliceRange(rest, start, end); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_189), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_193), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1]])); } else if (_7 === 15) { - const buf: Uint8Array = rt.bytes(3); - rt.byteSliceCopyFromSlice(rt.byteSliceFrom(buf), rt.byteSliceRange(rest, 0, rt.min(rest.length, 4))); - const arg3 = rt.byteSliceFrom(buf); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg3), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args18[0]])); + const buf: Uint8Array = rs.bytes(3); + rs.byteSliceCopyFromSlice(rs.byteSliceFrom(buf), rs.byteSliceRange(rest, 0, rs.min(rest.length, 4))); + const arg3 = rs.byteSliceFrom(buf); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args18[0]])); } else if (_7 === 16) { - const _221: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(rest)); + const _221: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(rest)); if (_221.ok) { - r4 = rt.Ok(rt.stringLen(_221.value) & 0xff); + r4 = rs.Ok(rs.stringLen(_221.value) & 0xff); } else { - r4 = _221 as rt.Result; + r4 = _221 as rs.Result; } - const _234: rt.u8 = rt.resultUnwrap(r4, rt.fmtFromUtf8ErrorDebug); - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(_234, f))); + const _234: rs.u8 = rs.resultUnwrap(r4, rs.fmtFromUtf8ErrorDebug); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(_234, f))); } else if (_7 === 17) { const buf2: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const dest: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, 1), 0) as rt.usize, 4); - const _244: rt.ByteSlice = rt.byteSliceFrom(buf2); - const _246: rt.Range = new rt.Range(rt.u8Rem(n, 6) as rt.usize, rt.u8Rem(rt.u8Div(n, 6), 6) as rt.usize); - rt.byteSliceCopyWithin(_244, _246.start, _246.end, dest); - const arg2 = rt.byteSliceFrom(buf2); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg2), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args20[0]])); + const dest: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(rest, 1), 0) as rs.usize, 4); + const _244: rs.ByteSlice = rs.byteSliceFrom(buf2); + const _246: rs.Range = new rs.Range(rs.u8Rem(n, 6) as rs.usize, rs.u8Rem(rs.u8Div(n, 6), 6) as rs.usize); + rs.byteSliceCopyWithin(_244, _246.start, _246.end, dest); + const arg2 = rs.byteSliceFrom(buf2); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args20[0]])); } else if (_7 === 18) { - const _271: rt.usize = rt.u8Rem(n, 8) as rt.usize; - rt.idx(rest, _271); + const _271: rs.usize = rs.u8Rem(n, 8) as rs.usize; + rs.idx(rest, _271); const arg = rest.data[rest.start + _271]; - put(out, rt.fmtToString((f: rt.Formatter) => rt.u8Display(arg, f))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.u8Display(arg, f))); } else { - if (!(rt.u8Rem(n, 2) === 0)) { - r5 = rt.Ok(n); + if (!(rs.u8Rem(n, 2) === 0)) { + r5 = rs.Ok(n); } else { - r5 = rt.Err(n); + r5 = rs.Err(n); } - const part = rt.resultUnwrapErr(r5, rt.u8Debug); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(part, f)]; - put(out, rt.fmtFormat([args22[0]])); + const part = rs.resultUnwrapErr(r5, rs.u8Debug); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(part, f)]; + put(out, rs.fmtFormat([args22[0]])); } } @@ -611,111 +611,111 @@ export function panics(kind: rt.u8, rest: rt.ByteSlice, out: rt.ByteVec): void { * std's ranges' `Debug`, which passes its options to each bound, and an `Arc`'s `Debug` * and `Display`, which pass them to what it holds. */ -export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function wrapped(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.i32, rt.i32] = [rt.i32Sub(at(0) as rt.i32, 128), rt.i32Sub(at(1) as rt.i32, 100)]; - const a: rt.i32 = _6[0]; - const b: rt.i32 = _6[1]; - const w: rt.usize = rt.u8Rem(at(2), 10) as rt.usize; - const _33: rt.Range = new rt.Range(a, b); - const _35: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _37: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); - const _39: { end: rt.i32 } = { end: b }; - const _41: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_33, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(_35, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_37, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_39, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_41, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFull(undefined, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]])); - const _60: rt.Range = new rt.Range(a, b); - const _62: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _72: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.i32Step); - const _64: rt.RangeFrom = new rt.RangeFrom(a, rt.i32Step); - const _66: { end: rt.i32 } = { end: b }; - const _68: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - const _70: rt.Range = new rt.Range(a, b); - const _74: { end: rt.i32; inclusive: true } = { end: b, inclusive: true }; - const _77: rt.Range = new rt.Range(a, b); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_60, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(_62, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFrom(_64, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeTo(_66, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeToInclusive(_68, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRange(_70, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(_72, f, rt.i32Debug), rt.fmtCount(w), (f: rt.Formatter) => rt.fmtRangeToInclusive(_74, f, rt.i32Debug), (f: rt.Formatter) => rt.fmtRangeFull(undefined, f), (f: rt.Formatter) => rt.fmtRange(_77, f, rt.i32Debug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ width: 5 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 4 }, args4[1]), "|", rt.fmtSpec({ plus: true }, args4[2]), "|", rt.fmtSpec({ zero: true, width: 5 }, args4[3]), "|", rt.fmtSpec({ debugHex: "x" }, args4[4]), "|", rt.fmtSpec({ alternate: true, debugHex: "X" }, args4[5]), "|", rt.fmtSpec({ width: rt.fmtCountOf(args4[7]) }, args4[6]), "|", rt.fmtSpec({ align: "^", width: rt.fmtCountOf(args4[7]) }, args4[8]), "|", rt.fmtSpec({ align: ">", width: 3 }, args4[9]), "|", rt.fmtSpec({ alternate: true }, args4[10])])); - const _96: rt.usize = rt.usizeRem(at(3) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const _6: [rs.i32, rs.i32] = [rs.i32Sub(at(0) as rs.i32, 128), rs.i32Sub(at(1) as rs.i32, 100)]; + const a: rs.i32 = _6[0]; + const b: rs.i32 = _6[1]; + const w: rs.usize = rs.u8Rem(at(2), 10) as rs.usize; + const _33: rs.Range = new rs.Range(a, b); + const _35: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _37: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); + const _39: { end: rs.i32 } = { end: b }; + const _41: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_33, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_35, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_37, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_39, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_41, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5]])); + const _60: rs.Range = new rs.Range(a, b); + const _62: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _72: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.i32Step); + const _64: rs.RangeFrom = new rs.RangeFrom(a, rs.i32Step); + const _66: { end: rs.i32 } = { end: b }; + const _68: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + const _70: rs.Range = new rs.Range(a, b); + const _74: { end: rs.i32; inclusive: true } = { end: b, inclusive: true }; + const _77: rs.Range = new rs.Range(a, b); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_60, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_62, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFrom(_64, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeTo(_66, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeToInclusive(_68, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRange(_70, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_72, f, rs.i32Debug), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_74, f, rs.i32Debug), (f: rs.Formatter) => rs.fmtRangeFull(undefined, f), (f: rs.Formatter) => rs.fmtRange(_77, f, rs.i32Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 5 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args4[1]), "|", rs.fmtSpec({ plus: true }, args4[2]), "|", rs.fmtSpec({ zero: true, width: 5 }, args4[3]), "|", rs.fmtSpec({ debugHex: "x" }, args4[4]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args4[5]), "|", rs.fmtSpec({ width: rs.fmtCountOf(args4[7]) }, args4[6]), "|", rs.fmtSpec({ align: "^", width: rs.fmtCountOf(args4[7]) }, args4[8]), "|", rs.fmtSpec({ align: ">", width: 3 }, args4[9]), "|", rs.fmtSpec({ alternate: true }, args4[10])])); + const _96: rs.usize = rs.usizeRem(at(3) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_96 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _96); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _96); } const lo: Clip.Clip = { _0: ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_96] }; - const _109: rt.usize = rt.usizeRem(at(4) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const _109: rs.usize = rs.usizeRem(at(4) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_109 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _109); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _109); } const hi: Clip.Clip = { _0: ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_109] }; - const _127: rt.Range = new rt.Range(lo, hi); - const _129: rt.RangeInclusive = new rt.RangeInclusive(lo, hi); + const _127: rs.Range = new rs.Range(lo, hi); + const _129: rs.RangeInclusive = new rs.RangeInclusive(lo, hi); const _131: { end: Clip.Clip } = { end: hi }; - const _133: rt.RangeFrom = new rt.RangeFrom(lo); + const _133: rs.RangeFrom = new rs.RangeFrom(lo); const _135: { end: Clip.Clip; inclusive: true } = { end: lo, inclusive: true }; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_127, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeTo(_131, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f)), rt.fmtCount(w), (f: rt.Formatter) => rt.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rt.fmtSpec({ alternate: true }, args6[2]), "|", rt.fmtSpec({ fill: "_", align: ">", width: rt.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rt.fmtSpec({ alternate: true, width: 4 }, args6[5])])); - const _148: [rt.u32, rt.u32] = [rt.u32Mul(at(5) as rt.u32, 257), at(6) as rt.u32]; - const x: rt.u32 = _148[0]; - const y: rt.u32 = _148[1]; - const _167: rt.Range = new rt.Range({ _0: x }, { _0: y }); - const _171: rt.RangeInclusive = new rt.RangeInclusive({ _0: x }, { _0: y }); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_127, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_129, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_131, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeFrom(_133, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtRangeToInclusive(_135, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ width: 8, precision: 2 }, args6[1]), "|", rs.fmtSpec({ alternate: true }, args6[2]), "|", rs.fmtSpec({ fill: "_", align: ">", width: rs.fmtCountOf(args6[4]), precision: 1 }, args6[3]), "|", rs.fmtSpec({ alternate: true, width: 4 }, args6[5])])); + const _148: [rs.u32, rs.u32] = [rs.u32Mul(at(5) as rs.u32, 257), at(6) as rs.u32]; + const x: rs.u32 = _148[0]; + const y: rs.u32 = _148[1]; + const _167: rs.Range = new rs.Range({ _0: x }, { _0: y }); + const _171: rs.RangeInclusive = new rs.RangeInclusive({ _0: x }, { _0: y }); const _175: { end: Hex.Hex } = { end: { _0: y } }; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(_167, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtRangeTo(_175, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ align: ">", width: 9 }, args8[1]), "|", rt.fmtSpec({ alternate: true }, args8[2])])); - const part3 = new rt.Range({ _0: at(7), _1: -1 }, { _0: 1, _1: { hi: -0x80000000, lo: 0 } as rt.i64 }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(part3, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0]), "|", rt.fmtSpec({ debugHex: "x" }, args10[0]), "|", rt.fmtSpec({ plus: true }, args10[0])])); - const drained: rt.RangeInclusive = new rt.RangeInclusive(rt.u8Rem(at(8), 4), rt.u8Rem(at(9), 4), rt.u8Step); - while (rt.iterToOption(drained.next()) !== undefined) { - } - const top: rt.RangeInclusive = new rt.RangeInclusive(rt.max(at(8), 250), 255, rt.u8Step); - while (rt.iterToOption(top.next()) !== undefined) { - } - const back: rt.RangeInclusive = new rt.RangeInclusive(0, rt.u8Rem(at(9), 3), rt.u8Step); - while (rt.iterToOption(back.nextBack()) !== undefined) { - } - const far: rt.RangeInclusive = new rt.RangeInclusive(at(8), at(9), rt.u8Step); - const _244: rt.usize = rt.u8Rem(at(10), 8) as rt.usize; - rt.iterNth(far, _244); - const _257: rt.RangeInclusive = new rt.RangeInclusive(0, 0, rt.i32Step); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRangeInclusive(drained, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(top, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(back, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(far, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(_257, f, rt.i32Debug)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4]])); - const arc: rt.Arc = new rt.Arc({ _0: x }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rt.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args14[0]), "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rt.fmtSpec({ align: ">", width: 6 }, args14[1]), "|", rt.fmtSpec({ alternate: true }, args14[1])])); - put(out, rt.fmtToString((f: rt.Formatter) => Hex.fmt$fmt_Display(arc.value, f))); - const nested: rt.Arc> = new rt.Arc(new rt.Arc(a)); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(nested.value.value, f), (f: rt.Formatter) => rt.i32Debug(nested.value.value, f), rt.fmtCount(w)]; - put(out, rt.fmtFormat([args16[0], "|", rt.fmtSpec({ plus: true, zero: true, width: 5 }, args16[0]), "|", args16[1], "|", rt.fmtSpec({ debugHex: "x" }, args16[1]), "|", rt.fmtSpec({ alternate: true, debugHex: "X" }, args16[1]), "|", rt.fmtSpec({ align: "<", width: 6 }, args16[1]), "|", rt.fmtSpec({ align: "^", plus: true, width: rt.fmtCountOf(args16[2]) }, args16[0])])); - const _310: rt.usize = rt.usizeRem(at(3) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(_167, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeInclusive(_171, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtRangeTo(_175, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ align: ">", width: 9 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[2])])); + const part3 = new rs.Range({ _0: at(7), _1: -1 }, { _0: 1, _1: { hi: -0x80000000, lo: 0 } as rs.i64 }); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ plus: true }, args10[0])])); + const drained: rs.RangeInclusive = new rs.RangeInclusive(rs.u8Rem(at(8), 4), rs.u8Rem(at(9), 4), rs.u8Step); + while (rs.iterToOption(drained.next()) !== undefined) { + } + const top: rs.RangeInclusive = new rs.RangeInclusive(rs.max(at(8), 250), 255, rs.u8Step); + while (rs.iterToOption(top.next()) !== undefined) { + } + const back: rs.RangeInclusive = new rs.RangeInclusive(0, rs.u8Rem(at(9), 3), rs.u8Step); + while (rs.iterToOption(back.nextBack()) !== undefined) { + } + const far: rs.RangeInclusive = new rs.RangeInclusive(at(8), at(9), rs.u8Step); + const _244: rs.usize = rs.u8Rem(at(10), 8) as rs.usize; + rs.iterNth(far, _244); + const _257: rs.RangeInclusive = new rs.RangeInclusive(0, 0, rs.i32Step); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRangeInclusive(drained, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(top, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(back, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(far, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(_257, f, rs.i32Debug)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1], " ", args12[2], " ", args12[3], " ", args12[4]])); + const arc: rs.Arc = new rs.Arc({ _0: x }); + const args14: rs.Fmt[] = [(f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f), (f: rs.Formatter) => Hex.fmt$fmt_Debug(arc.value, f)]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args14[0]), "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ align: ">", width: 6 }, args14[1]), "|", rs.fmtSpec({ alternate: true }, args14[1])])); + put(out, rs.fmtToString((f: rs.Formatter) => Hex.fmt$fmt_Display(arc.value, f))); + const nested: rs.Arc> = new rs.Arc(new rs.Arc(a)); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(nested.value.value, f), (f: rs.Formatter) => rs.i32Debug(nested.value.value, f), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ plus: true, zero: true, width: 5 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ debugHex: "x" }, args16[1]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args16[1]), "|", rs.fmtSpec({ align: "<", width: 6 }, args16[1]), "|", rs.fmtSpec({ align: "^", plus: true, width: rs.fmtCountOf(args16[2]) }, args16[0])])); + const _310: rs.usize = rs.usizeRem(at(3) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_310 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _310); - } - const rc: rt.Arc = new rt.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rc.value), (f: rt.Formatter) => rt.fmtStr(rc.value, f)]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]])); - const list: rt.Arc> = new rt.Arc(rt.vecFrom([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice())); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(list.value.items, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args20[0], " ", rt.fmtSpec({ alternate: true }, args20[0])])); - const held: rt.Range> = new rt.Range(new rt.Arc(a), new rt.Arc(b)); - const _366: rt.Range> = new rt.Range(new rt.Arc(lo), new rt.Arc(hi)); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRange(held, f, (value: rt.Arc, f: rt.Formatter) => rt.i32Debug(value.value, f)), (f: rt.Formatter) => rt.fmtRange(_366, f, (value: rt.Arc, f: rt.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; - const _362: string = rt.fmtFormat([args22[0], " ", rt.fmtSpec({ plus: true, zero: true, width: 4 }, args22[0]), " ", args22[1]]); - rt.dropAll([_366.start, _366.end]); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _310); + } + const rc: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_310]); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rc.value), (f: rs.Formatter) => rs.fmtStr(rc.value, f)]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ align: ">", width: 8, precision: 2 }, args18[0]), "|", args18[1]])); + const list: rs.Arc> = new rs.Arc(rs.vecFrom([{ _0: at(7), _1: 2 }, { _0: 3, _1: -4 }].slice())); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(list.value.items, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0])])); + const held: rs.Range> = new rs.Range(new rs.Arc(a), new rs.Arc(b)); + const _366: rs.Range> = new rs.Range(new rs.Arc(lo), new rs.Arc(hi)); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRange(held, f, (value: rs.Arc, f: rs.Formatter) => rs.i32Debug(value.value, f)), (f: rs.Formatter) => rs.fmtRange(_366, f, (value: rs.Arc, f: rs.Formatter) => Clip.fmt$fmt_Debug(value.value, f))]; + const _362: string = rs.fmtFormat([args22[0], " ", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args22[0]), " ", args22[1]]); + rs.dropAll([_366.start, _366.end]); put(out, _362); - const shared: Shared.Shared = new Shared.Shared(new rt.Arc({ _0: at(7), _1: 5 }), new rt.Range(at(8) as rt.u16, 300), { end: at(9), inclusive: true }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; - put(out, rt.fmtFormat([args24[0], " ", rt.fmtSpec({ alternate: true }, args24[0])])); - const _405: rt.usize = rt.usizeRem(at(3) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const shared: Shared.Shared = new Shared.Shared(new rs.Arc({ _0: at(7), _1: 5 }), new rs.Range(at(8) as rs.u16, 300), { end: at(9), inclusive: true }); + const args24: rs.Fmt[] = [(f: rs.Formatter) => Shared.fmt$fmt_Debug(shared, f)]; + put(out, rs.fmtFormat([args24[0], " ", rs.fmtSpec({ alternate: true }, args24[0])])); + const _405: rs.usize = rs.usizeRem(at(3) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_405 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _405); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _405); } - const t: rt.Arc = new rt.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_405]); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, t.value), (f: rt.Formatter) => rt.fmtStr(t.value, f)]; - put(out, rt.fmtFormat([args26[0], " ", args26[1], " ", rt.fmtSpec({ align: ">", width: 9, precision: 2 }, args26[0])])); + const t: rs.Arc = new rs.Arc(["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_405]); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, t.value), (f: rs.Formatter) => rs.fmtStr(t.value, f)]; + put(out, rs.fmtFormat([args26[0], " ", args26[1], " ", rs.fmtSpec({ align: ">", width: 9, precision: 2 }, args26[0])])); t[Symbol.dispose](); shared[Symbol.dispose](); - rt.dropAll([held.start, held.end]); + rs.dropAll([held.start, held.end]); list[Symbol.dispose](); rc[Symbol.dispose](); nested[Symbol.dispose](); @@ -727,85 +727,85 @@ export function wrapped(data: rt.ByteSlice, out: rt.ByteVec): void { * head however its buffer wraps, sets and maps in braces, nested, and pretty. A hash * collection holds at most one entry, since std leaves their order unspecified. */ -export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function collections(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const q: rt.VecDeque = rt.dequeWithCapacity(4, 2) as rt.VecDeque; - for (const b of rt.byteSliceView(data)) { - const _12: rt.u8 = rt.u8Rem(b, 4); + const q: rs.VecDeque = rs.dequeWithCapacity(4, 2) as rs.VecDeque; + for (const b of rs.byteSliceView(data)) { + const _12: rs.u8 = rs.u8Rem(b, 4); if (_12 === 0) { - const _15: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushBack(q, _15); + const _15: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); + rs.dequePushBack(q, _15); } else if (_12 === 1) { - const _20: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - rt.dequePushFront(q, _20); + const _20: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); + rs.dequePushFront(q, _20); } else if (_12 === 2) { - rt.dequePopBack(q, rt.None); + rs.dequePopBack(q, rs.None); } else { - rt.dequePopFront(q, rt.None); - } - } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(q), f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[0])])); - const wrapped: rt.VecDeque = rt.dequeWithCapacity(4, 4) as rt.VecDeque; - rt.dequeExtend(wrapped, rt.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); - const _48: Hex.Hex = { _0: rt.u32Mul(at(0) as rt.u32, 4097) }; - rt.dequePushFront(wrapped, _48); - const _57: Hex.Hex = { _0: at(1) as rt.u32 }; - rt.dequePushFront(wrapped, _57); - rt.dequePopBack(wrapped); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - const mid: string = rt.fmtFormat([args4[0]]); - rt.dequePopBack(wrapped); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, mid), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(wrapped), f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args6[0], "|", args6[1], "|", rt.fmtSpec({ alternate: true }, args6[1]), "|", rt.fmtSpec({ width: 6 }, args6[1])])); - const empty: rt.VecDeque = rt.dequeNew(1, true) as rt.VecDeque; - const units: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(new rt.Range(0, rt.u8Rem(at(2), 3)), (_2: rt.u8): undefined => {}), undefined, 0, true), 0) as rt.VecDeque; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(empty), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(units), f, rt.fmtUnit)]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); - const part = rt.dequeFromArray([rt.dequeNew(16) as rt.VecDeque, rt.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rt.VecDeque], 16) as rt.VecDeque>; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.dequeIter(part), f, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0])])); - const _135: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): rt.u8 | undefined => { - const b5: rt.u8 = _25; - return thenSome$0d5am30(rt.u8Rem(b5, 3) !== 0, rt.u8Rem(b5, 8)); + rs.dequePopFront(q, rs.None); + } + } + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(q), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[0])])); + const wrapped: rs.VecDeque = rs.dequeWithCapacity(4, 4) as rs.VecDeque; + rs.dequeExtend(wrapped, rs.iterSlice([{ _0: 1 }, { _0: 2 }]), undefined, true); + const _48: Hex.Hex = { _0: rs.u32Mul(at(0) as rs.u32, 4097) }; + rs.dequePushFront(wrapped, _48); + const _57: Hex.Hex = { _0: at(1) as rs.u32 }; + rs.dequePushFront(wrapped, _57); + rs.dequePopBack(wrapped); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + const mid: string = rs.fmtFormat([args4[0]]); + rs.dequePopBack(wrapped); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, mid), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(wrapped), f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args6[0], "|", args6[1], "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ width: 6 }, args6[1])])); + const empty: rs.VecDeque = rs.dequeNew(1, true) as rs.VecDeque; + const units: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(0, rs.u8Rem(at(2), 3)), (_2: rs.u8): undefined => {}), undefined, 0, true), 0) as rs.VecDeque; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(empty), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(units), f, rs.fmtUnit)]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", args8[1]])); + const part = rs.dequeFromArray([rs.dequeNew(16) as rs.VecDeque, rs.dequeFromArray([{ _0: at(3), _1: -1 }, { _0: 2, _1: 3 }], 16) as rs.VecDeque], 16) as rs.VecDeque>; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.dequeIter(part), f, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0])])); + const _135: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): rs.u8 | undefined => { + const b5: rs.u8 = _25; + return thenSome$0quywni(rs.u8Rem(b5, 3) !== 0, rs.u8Rem(b5, 8)); }); - const part2 = rt.btreeExtendKeys(rt.btreeNew(rt.cmpOption(rt.cmp)) as rt.BTreeSet, _135, true, undefined, undefined, 2, true); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSet(rt.btreeKeys(part2), f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ alternate: true }, args12[0]), "|", rt.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args12[0])])); - const map: rt.BTreeMap> = rt.btreeNew(rt.cmp) as rt.BTreeMap>; - const iter2: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6); - while (true) { - const _154: rt.u8 | rt.Done = iter2.next(); - if (_154 === rt.DONE) { + const part2 = rs.btreeExtendKeys(rs.btreeNew(rs.cmpOption(rs.cmp)) as rs.BTreeSet, _135, true, undefined, undefined, 2, true); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(part2), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args12[0])])); + const map: rs.BTreeMap> = rs.btreeNew(rs.cmp) as rs.BTreeMap>; + const iter2: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); + while (true) { + const _154: rs.u8 | rs.Done = iter2.next(); + if (_154 === rs.DONE) { break; } - const b2: rt.u8 = _154; - rt.dequePushFront(rt.entryOrInsertWith(rt.entry(map, rt.u8Rem(b2, 4)), (): rt.VecDeque => { - return rt.dequeNew(16) as rt.VecDeque; - }), { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }); - } - const _176: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _178: rt.BTreeSet = rt.btreeNew(rt.cmp) as rt.BTreeSet; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtMap(rt.btreeIter(map), f, rt.u8Debug, (value: rt.VecDeque, f: rt.Formatter) => rt.fmtList(rt.dequeIter(value), f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rt.Formatter) => rt.fmtMap(rt.btreeIter(_176), f, rt.u8Debug, rt.u8Debug), (f: rt.Formatter) => rt.fmtSet(rt.btreeKeys(_178), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rt.fmtSpec({ alternate: true }, args14[2])])); - const _188: [rt.HashMap, rt.HashSet] = [rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashMap, rt.hashNew() as rt.HashSet]; - const one: rt.HashMap = _188[0]; - const set: rt.HashSet = _188[1]; - const _191: rt.u8 | undefined = rt.byteSliceFirst(data); + const b2: rs.u8 = _154; + rs.dequePushFront(rs.entryOrInsertWith(rs.entry(map, rs.u8Rem(b2, 4)), (): rs.VecDeque => { + return rs.dequeNew(16) as rs.VecDeque; + }), { _0: b2, _1: rs.i64Neg(b2 as rs.i64) }); + } + const _176: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _178: rs.BTreeSet = rs.btreeNew(rs.cmp) as rs.BTreeSet; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, (value: rs.VecDeque, f: rs.Formatter) => rs.fmtList(rs.dequeIter(value), f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtMap(rs.btreeIter(_176), f, rs.u8Debug, rs.u8Debug), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(_178), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", args14[1], "|", rs.fmtSpec({ alternate: true }, args14[2])])); + const _188: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew() as rs.HashSet]; + const one: rs.HashMap = _188[0]; + const set: rs.HashSet = _188[1]; + const _191: rs.u8 | undefined = rs.byteSliceFirst(data); if (_191 !== undefined) { - const b3: rt.u8 = _191; - const _196: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b3, 2) === 0, b3); - const _200: Hex.Hex = { _0: b3 as rt.u32 }; - rt.hashInsert(one, _196, _200); + const b3: rs.u8 = _191; + const _196: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b3, 2) === 0, b3); + const _200: Hex.Hex = { _0: b3 as rs.u32 }; + rs.hashInsert(one, _196, _200); } - const _202: rt.u8 | undefined = rt.byteSliceGet(data, 1); + const _202: rs.u8 | undefined = rs.byteSliceGet(data, 1); if (_202 !== undefined) { - rt.hashAdd(set, _202); + rs.hashAdd(set, _202); } - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtMap(rt.hashIter(one), f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtSet(rt.hashKeys(set), f, rt.u8Debug)]; - put(out, rt.fmtFormat([args16[0], "|", rt.fmtSpec({ alternate: true }, args16[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rt.fmtSpec({ alternate: true }, args16[1]), "|", rt.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.hashIter(one), f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtSet(rs.hashKeys(set), f, rs.u8Debug)]; + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", rs.fmtSpec({ alternate: true, zero: true, debugHex: "x", width: 4 }, args16[1])])); } /** @@ -813,175 +813,175 @@ export function collections(data: rt.ByteSlice, out: rt.ByteVec): void { * a field passes the options to it, and one without writes its name unpadded. A * `ControlFlow` that `?` would break with holds the `Err` or `None` it was applied to. */ -export function enums(data: rt.ByteSlice, out: rt.ByteVec): void { - let flow!: rt.Result; - let unit!: rt.Result; - let erred!: rt.Result; - let none!: rt.u8 | undefined; - let unitNone!: undefined | rt.None; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function enums(data: rs.ByteSlice, out: rs.ByteVec): void { + let flow!: rs.Result; + let unit!: rs.Result; + let erred!: rs.Result; + let none!: rs.u8 | undefined; + let unitNone!: undefined | rs.None; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const w: rt.usize = rt.u8Rem(at(0), 10) as rt.usize; - const n: rt.RangeBound = pick$enums_u8(at(1), at(2)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(n, f, rt.u8Debug), rt.fmtCount(w)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ alternate: true, debugHex: "X" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args2[1]) }, args2[0]), "|", rt.fmtSpec({ fill: "_", align: "^", width: 7 }, args2[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 4 }, args2[0])])); - const _32: rt.u8 = at(3); - const _37: rt.usize = rt.usizeRem(at(4) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const w: rs.usize = rs.u8Rem(at(0), 10) as rs.usize; + const n: rs.RangeBound = pick$enums_u8(at(1), at(2)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(n, f, rs.u8Debug), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ alternate: true, debugHex: "X" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args2[1]) }, args2[0]), "|", rs.fmtSpec({ fill: "_", align: "^", width: 7 }, args2[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 4 }, args2[0])])); + const _32: rs.u8 = at(3); + const _37: rs.usize = rs.usizeRem(at(4) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_37 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _37); - } - const s: rt.RangeBound = pick$enums_ref_str(_32, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_37]); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(s, f, rt.fmtStr), rt.fmtCount(w)]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 9 }, args4[0]), "|", rt.fmtSpec({ fill: "*", align: "<", width: rt.fmtCountOf(args4[1]), precision: 2 }, args4[0])])); - const part = pick$enums_char(at(5), at(6) as rt.char); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(part, f, rt.fmtCharDebug)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0]), "|", rt.fmtSpec({ align: "^", width: 6 }, args6[0])])); - const part2 = pick$enums_Option_u8(at(7), thenSome$0d5am30(rt.u8Rem(at(8), 2) === 0, at(9))); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(part2, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0]), "|", rt.fmtSpec({ debugHex: "x" }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args8[0])])); - const part4 = pick$enums_ref_slice_u8(at(10), rt.byteSliceRange(data, 0, rt.min(data.length, 3))); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(part4, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug))]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0]), "|", rt.fmtSpec({ debugHex: "x" }, args10[0]), "|", rt.fmtSpec({ width: 3 }, args10[0])])); - const _128: rt.u8 = at(11); - const _134: rt.usize = rt.usizeRem(at(12) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _37); + } + const s: rs.RangeBound = pick$enums_ref_str(_32, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_37]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(s, f, rs.fmtStr), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args4[0]), "|", rs.fmtSpec({ fill: "*", align: "<", width: rs.fmtCountOf(args4[1]), precision: 2 }, args4[0])])); + const part = pick$enums_char(at(5), at(6) as rs.char); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part, f, rs.fmtCharDebug)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0]), "|", rs.fmtSpec({ align: "^", width: 6 }, args6[0])])); + const part2 = pick$enums_Option_u8(at(7), thenSome$0quywni(rs.u8Rem(at(8), 2) === 0, at(9))); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part2, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0]), "|", rs.fmtSpec({ debugHex: "x" }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args8[0])])); + const part4 = pick$enums_ref_slice_u8(at(10), rs.byteSliceRange(data, 0, rs.min(data.length, 3))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(part4, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug))]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ debugHex: "x" }, args10[0]), "|", rs.fmtSpec({ width: 3 }, args10[0])])); + const _128: rs.u8 = at(11); + const _134: rs.usize = rs.usizeRem(at(12) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_134 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _134); - } - const clip: rt.RangeBound = pick$enums_fmt_Clip(_128, { _0: ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_134] }); - const _152: rt.RangeBound = clip; - const _155: rt.RangeBound | undefined = clip; - const _157: [rt.RangeBound, rt.RangeBound] = [n, s]; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_152, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => rt.fmtOption(_155, f, (value: rt.RangeBound, f: rt.Formatter) => rt.fmtBound(value, f, (value: Clip.Clip, f: rt.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBound(_157[0], f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_157[1], f, rt.fmtStr)], f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ width: 8, precision: 2 }, args12[0]), "|", rt.fmtSpec({ alternate: true }, args12[1]), "|", args12[2]])); - const r: rt.RangeInclusive = new rt.RangeInclusive(at(1), at(2), rt.u8Step); - const _179: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; - const _182: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; - new rt.RangeFrom(at(1), rt.u8Step); - const _185: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; - const _192: rt.RangeBound = { tag: "Excluded", _0: { end: at(2) }.end } as rt.RangeBound; - const _199: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBound(_179, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_182, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_185, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_192, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_199, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", rt.fmtSpec({ debugHex: "x" }, args14[3]), " ", rt.fmtSpec({ alternate: true }, args14[4])])); - const ord: rt.Ordering = rt.cmp(at(1), at(2)); - const all: rt.Ordering[] = [-1, 0, 1]; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOrdering(ord, f), (f: rt.Formatter) => rt.fmtList(all, f, rt.fmtOrdering)]; - put(out, rt.fmtFormat([args16[0], "|", rt.fmtSpec({ align: ">", width: 8 }, args16[0]), "|", rt.fmtSpec({ alternate: true }, args16[0]), "|", args16[1], "|", rt.fmtSpec({ alternate: true }, args16[1])])); - const rev: rt.u8 = at(1); - const _244: rt.usize = rt.usizeRem(at(4) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _134); + } + const clip: rs.RangeBound = pick$enums_fmt_Clip(_128, { _0: ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_134] }); + const _152: rs.RangeBound = clip; + const _155: rs.RangeBound | undefined = clip; + const _157: [rs.RangeBound, rs.RangeBound] = [n, s]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_152, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => rs.fmtOption(_155, f, (value: rs.RangeBound, f: rs.Formatter) => rs.fmtBound(value, f, (value: Clip.Clip, f: rs.Formatter) => Clip.fmt$fmt_Debug(value, f))), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBound(_157[0], f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_157[1], f, rs.fmtStr)], f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ width: 8, precision: 2 }, args12[0]), "|", rs.fmtSpec({ alternate: true }, args12[1]), "|", args12[2]])); + const r: rs.RangeInclusive = new rs.RangeInclusive(at(1), at(2), rs.u8Step); + const _179: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; + const _182: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; + new rs.RangeFrom(at(1), rs.u8Step); + const _185: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; + const _192: rs.RangeBound = { tag: "Excluded", _0: { end: at(2) }.end } as rs.RangeBound; + const _199: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBound(_179, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_182, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_185, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_192, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_199, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args14[0], " ", args14[1], " ", args14[2], " ", rs.fmtSpec({ debugHex: "x" }, args14[3]), " ", rs.fmtSpec({ alternate: true }, args14[4])])); + const ord: rs.Ordering = rs.cmp(at(1), at(2)); + const all: rs.Ordering[] = [-1, 0, 1]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOrdering(ord, f), (f: rs.Formatter) => rs.fmtList(all, f, rs.fmtOrdering)]; + put(out, rs.fmtFormat([args16[0], "|", rs.fmtSpec({ align: ">", width: 8 }, args16[0]), "|", rs.fmtSpec({ alternate: true }, args16[0]), "|", args16[1], "|", rs.fmtSpec({ alternate: true }, args16[1])])); + const rev: rs.u8 = at(1); + const _244: rs.usize = rs.usizeRem(at(4) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_244 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _244); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _244); } const nested: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_244]; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "Reverse", [(f: rt.Formatter) => rt.u8Debug(rev, f)]), rt.fmtCount(w), (f: rt.Formatter) => rt.fmtDebugTupleFields(f, "Reverse", [(f: rt.Formatter) => rt.fmtDebugTupleFields(f, "Reverse", [(f: rt.Formatter) => rt.fmtStr(nested, f)])])]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[0]), "|", rt.fmtSpec({ debugHex: "x" }, args18[0]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args18[1]) }, args18[0]), "|", args18[2], "|", rt.fmtSpec({ alternate: true }, args18[2])])); - const _272: rt.usize = rt.usizeRem(at(4) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.u8Debug(rev, f)]), rs.fmtCount(w), (f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtDebugTupleFields(f, "Reverse", [(f: rs.Formatter) => rs.fmtStr(nested, f)])])]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", rs.fmtSpec({ debugHex: "x" }, args18[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args18[1]) }, args18[0]), "|", args18[2], "|", rs.fmtSpec({ alternate: true }, args18[2])])); + const _272: rs.usize = rs.usizeRem(at(4) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_272 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _272); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _272); } const _271: string[] = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"]; - if (rt.u8Rem(at(1), 2) === 0) { - flow = rt.Err(_271[_272]); + if (rs.u8Rem(at(1), 2) === 0) { + flow = rs.Err(_271[_272]); } else { - flow = rt.Ok(rt.u16Mul(at(2) as rt.u16, 300)); + flow = rs.Ok(rs.u16Mul(at(2) as rs.u16, 300)); } - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(flow, f, rt.u16Debug, rt.fmtStr), rt.fmtCount(w)]; - put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ alternate: true }, args20[0]), "|", rt.fmtSpec({ debugHex: "x" }, args20[0]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args20[1]) }, args20[0])])); - if (rt.u8Rem(at(1), 2) === 0) { - unit = rt.Err(at(2)); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(flow, f, rs.u16Debug, rs.fmtStr), rs.fmtCount(w)]; + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0]), "|", rs.fmtSpec({ debugHex: "x" }, args20[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args20[1]) }, args20[0])])); + if (rs.u8Rem(at(1), 2) === 0) { + unit = rs.Err(at(2)); } else { - unit = rt.OK; + unit = rs.OK; } - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(unit, f, rt.fmtUnit, rt.u8Debug)]; - put(out, rt.fmtFormat([args22[0], "|", rt.fmtSpec({ alternate: true }, args22[0]), "|", rt.fmtSpec({ zero: true, width: 3 }, args22[0])])); - if (rt.u8Rem(at(1), 2) === 0) { - erred = rt.Err(at(2)); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(unit, f, rs.fmtUnit, rs.u8Debug)]; + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ zero: true, width: 3 }, args22[0])])); + if (rs.u8Rem(at(1), 2) === 0) { + erred = rs.Err(at(2)); } else { - erred = rt.Ok(at(2) as rt.u16); + erred = rs.Ok(at(2) as rs.u16); } - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(erred, f, rt.u16Debug, (value: rt.Result, f: rt.Formatter) => rt.fmtResult(value, f, (value: never, _f: rt.Formatter) => rt.unreachable(value), rt.u8Debug), true)]; - put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0]), "|", rt.fmtSpec({ align: ">", width: 5 }, args24[0])])); - if (rt.u8Rem(at(1), 2) === 0) { + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(erred, f, rs.u16Debug, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value), rs.u8Debug), true)]; + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ align: ">", width: 5 }, args24[0])])); + if (rs.u8Rem(at(1), 2) === 0) { none = undefined; } else { none = at(2); } - if (rt.u8Rem(at(2), 2) === 0) { - unitNone = rt.None; + if (rs.u8Rem(at(2), 2) === 0) { + unitNone = rs.None; } else { unitNone = undefined; } - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlowOption(none, f, rt.u8Debug, (value: never | undefined, f: rt.Formatter) => rt.fmtOption(value, f, (value: never, _f: rt.Formatter) => rt.unreachable(value))), (f: rt.Formatter) => rt.fmtControlFlowOption(unitNone, f, rt.fmtUnit, (value: never | undefined, f: rt.Formatter) => rt.fmtOption(value, f, (value: never, _f: rt.Formatter) => rt.unreachable(value)), rt.None)]; - put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0]), "|", rt.fmtSpec({ align: "<", width: 4 }, args26[0]), "|", args26[1], "|", rt.fmtSpec({ alternate: true }, args26[1])])); - const part5 = rt.Ok(at(2)); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part5, f, rt.u8Debug, (value: never, _f: rt.Formatter) => rt.unreachable(value))]; - put(out, rt.fmtFormat([args28[0], "|", rt.fmtSpec({ alternate: true }, args28[0])])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlowOption(none, f, rs.u8Debug, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value))), (f: rs.Formatter) => rs.fmtControlFlowOption(unitNone, f, rs.fmtUnit, (value: never | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: never, _f: rs.Formatter) => rs.unreachable(value)), rs.None)]; + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0]), "|", rs.fmtSpec({ align: "<", width: 4 }, args26[0]), "|", args26[1], "|", rs.fmtSpec({ alternate: true }, args26[1])])); + const part5 = rs.Ok(at(2)); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u8Debug, (value: never, _f: rs.Formatter) => rs.unreachable(value))]; + put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0])])); } -export function pick$enums_Option_u8(by: rt.u8, x: rt.u8 | undefined): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_Option_u8(by: rs.u8, x: rs.u8 | undefined): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function pick$enums_char(by: rt.u8, x: rt.char): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_char(by: rs.u8, x: rs.char): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function pick$enums_fmt_Clip(by: rt.u8, x: Clip.Clip): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_fmt_Clip(by: rs.u8, x: Clip.Clip): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function pick$enums_ref_slice_u8(by: rt.u8, x: rt.ByteSlice): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_ref_slice_u8(by: rs.u8, x: rs.ByteSlice): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function pick$enums_ref_str(by: rt.u8, x: string): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_ref_str(by: rs.u8, x: string): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function pick$enums_u8(by: rt.u8, x: rt.u8): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(by, 3); +export function pick$enums_u8(by: rs.u8, x: rs.u8): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(by, 3); if (_3 === 0) { - return { tag: "Included", _0: x } as rt.RangeBound; + return { tag: "Included", _0: x } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: x } as rt.RangeBound; + return { tag: "Excluded", _0: x } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } /** @@ -989,865 +989,865 @@ export function pick$enums_u8(by: rt.u8, x: rt.u8): rt.RangeBound { * element's `Debug` with the formatter's options: consumed from either end, empty, and * pretty. A hash iterator holds at most one entry, since std leaves their order unspecified. */ -export function iters(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function iters(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 3) as rt.usize, rt.u8Rem(at(1), 3) as rt.usize]; - const front: rt.usize = _6[0]; - const back: rt.usize = _6[1]; - const part = ends$iters_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(data)), front, back); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part, f, rt.u8Debug, ["Iter"])]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args2[0])])); - const part2 = ends$iters_slice_IterMut_u8(rt.iterSliceMut(rt.byteSliceView(rt.byteVecSlice(rt.iterToByteVec(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), undefined, true)))), front, back); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part2, f, rt.u8Debug, ["IterMut"])]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); - const part3 = ends$iters_vec_IntoIter_fmt_Pair(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 4), (_2: rt.u8): Pair.Pair => { - const b2: rt.u8 = _2; - return { _0: b2, _1: rt.i64Neg(b2 as rt.i64) }; + const _6: [rs.usize, rs.usize] = [rs.u8Rem(at(0), 3) as rs.usize, rs.u8Rem(at(1), 3) as rs.usize]; + const front: rs.usize = _6[0]; + const back: rs.usize = _6[1]; + const part = ends$iters_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(data)), front, back); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args2[0])])); + const part2 = ends$iters_slice_IterMut_u8(rs.iterSliceMut(rs.byteSliceView(rs.byteVecSlice(rs.iterToByteVec(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), undefined, true)))), front, back); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part2, f, rs.u8Debug, ["IterMut"])]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const part3 = ends$iters_vec_IntoIter_fmt_Pair(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 4), (_2: rs.u8): Pair.Pair => { + const b2: rs.u8 = _2; + return { _0: b2, _1: rs.i64Neg(b2 as rs.i64) }; }), undefined, 16, true)), front, back); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part3, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = ends$iters_vec_IntoIter_u8(rt.byteVecIntoIter(rt.byteSliceToByteVec(data)), front, back); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part4, f, rt.u8Debug, ["IntoIter"])]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args8[0])])); - const it4: rt.Iter = ends$iters_vec_Drain_fmt_Hex(rt.vecDrain(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 5), (_23: rt.u8): Hex.Hex => { - return { _0: rt.u32Mul(_23 as rt.u32, 257) }; - }), undefined, 4, true), new rt.RangeFrom(1, rt.usizeStep)), front, back); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it4, f, (value: Hex.Hex, f: rt.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); - rt.drop(it4); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const _111: { end: rt.usize } = { end: rt.usizeDiv(data.length, 2) }; - const it5: rt.Iter = ends$iters_vec_Drain_u8(rt.byteVecDrain(bytes, _111), front, back); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it5, f, rt.u8Debug, ["Drain"])]; - put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])])); - rt.drop(it5); - const arrays: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _32: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part3, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + const part4 = ends$iters_vec_IntoIter_u8(rs.byteVecIntoIter(rs.byteSliceToByteVec(data)), front, back); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part4, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args8[0])])); + const it4: rs.Iter = ends$iters_vec_Drain_fmt_Hex(rs.vecDrain(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 5), (_23: rs.u8): Hex.Hex => { + return { _0: rs.u32Mul(_23 as rs.u32, 257) }; + }), undefined, 4, true), new rs.RangeFrom(1, rs.usizeStep)), front, back); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it4, f, (value: Hex.Hex, f: rs.Formatter) => Hex.fmt$fmt_Debug(value, f), ["Drain"])]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args10[0])])); + rs.drop(it4); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const _111: { end: rs.usize } = { end: rs.usizeDiv(data.length, 2) }; + const it5: rs.Iter = ends$iters_vec_Drain_u8(rs.byteVecDrain(bytes, _111), front, back); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it5, f, rs.u8Debug, ["Drain"])]; + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ zero: true, debugHex: "X", width: 2 }, args12[0])])); + rs.drop(it5); + const arrays: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _32: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_32, c.data[c.start + 1]); }), undefined, 2, true); - const part5 = ends$iters_slice_Iter_array2_u8(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), front, back); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part5, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["Iter"])]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0])])); - const part6 = ends$iters_slice_IterMut_array2_u8(rt.iterLend(rt.iterSlice(arrays.items), rt.byteSliceFrom), back, front); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part6, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["IterMut"])]; - put(out, rt.fmtFormat([args16[0]])); - const _165: Array = []; - const _174: rt.Iter = rt.iterSlice(_165); - const _176: rt.Iter = rt.byteVecIntoIter(new rt.ByteVec()); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_174, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["Iter"]), (f: rt.Formatter) => rt.fmtIter(_176, f, rt.u8Debug, ["IntoIter"])]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); - const heap: rt.BinaryHeap = rt.heapFrom(rt.iterToVec(rt.iterSlice(rt.byteSliceView(data)), undefined, 1, true), rt.le, rt.ge, rt.lt); - const part7 = ends$iters_collections_binary_heap_Iter_u8(rt.heapIter(heap), front, back); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part7, f, rt.u8Debug, ["Iter"])]; - put(out, rt.fmtFormat([args20[0], "|", rt.fmtSpec({ alternate: true }, args20[0])])); - const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rt.heapIter(rt.heapClone(heap, undefined)), front, back); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part8, f, rt.u8Debug, ["IntoIter"])]; - put(out, rt.fmtFormat([args22[0]])); - const it8: rt.Iter = ends$iters_collections_binary_heap_Drain_u8(rt.heapDrain(rt.heapClone(heap, undefined)), front, back); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it8, f, rt.u8Debug, [["Drain", "iter"], "Drain"])]; - put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); - rt.drop(it8); - const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rt.dequeIntoIter(rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): rt.u8 | undefined => { - const b4: rt.u8 = _27; - return thenSome$0d5am30(rt.u8Rem(b4, 3) !== 0, b4); - }), undefined, 2, true), 2) as rt.VecDeque), front, back); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part9, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), ["IntoIter"])]; - put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): rt.char => { - const _59: rt.usize = rt.u8Rem(_28, 6) as rt.usize; + const part5 = ends$iters_slice_Iter_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), front, back); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part5, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"])]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0])])); + const part6 = ends$iters_slice_IterMut_array2_u8(rs.iterLend(rs.iterSlice(arrays.items), rs.byteSliceFrom), back, front); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part6, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["IterMut"])]; + put(out, rs.fmtFormat([args16[0]])); + const _165: Array = []; + const _174: rs.Iter = rs.iterSlice(_165); + const _176: rs.Iter = rs.byteVecIntoIter(new rs.ByteVec()); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_174, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["Iter"]), (f: rs.Formatter) => rs.fmtIter(_176, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + const heap: rs.BinaryHeap = rs.heapFrom(rs.iterToVec(rs.iterSlice(rs.byteSliceView(data)), undefined, 1, true), rs.le, rs.ge, rs.lt); + const part7 = ends$iters_collections_binary_heap_Iter_u8(rs.heapIter(heap), front, back); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part7, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args20[0], "|", rs.fmtSpec({ alternate: true }, args20[0])])); + const part8 = ends$iters_collections_binary_heap_IntoIter_u8(rs.heapIter(rs.heapClone(heap, undefined)), front, back); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part8, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args22[0]])); + const it8: rs.Iter = ends$iters_collections_binary_heap_Drain_u8(rs.heapDrain(rs.heapClone(heap, undefined)), front, back); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it8, f, rs.u8Debug, [["Drain", "iter"], "Drain"])]; + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + rs.drop(it8); + const part9 = ends$iters_collections_vec_deque_IntoIter_Option_u8(rs.dequeIntoIter(rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): rs.u8 | undefined => { + const b4: rs.u8 = _27; + return thenSome$0quywni(rs.u8Rem(b4, 3) !== 0, b4); + }), undefined, 2, true), 2) as rs.VecDeque), front, back); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part9, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), ["IntoIter"])]; + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); + const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): rs.char => { + const _59: rs.usize = rs.u8Rem(_28, 6) as rs.usize; if (!(_59 < 6)) { - rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _59); + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _59); } return [97, 233, 20013, 129408, 10, 39][_59]; })); - const part10 = ends$iters_str_Chars(rt.strChars(text), front, back); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChars(part10, f)]; - put(out, rt.fmtFormat([args28[0], "|", rt.fmtSpec({ alternate: true }, args28[0]), "|", rt.fmtSpec({ align: ">", width: 3 }, args28[0])])); - const part11 = ends$iters_str_Bytes(rt.strBytes(text), front, back); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part11, f, rt.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rt.fmtFormat([args30[0], "|", rt.fmtSpec({ alternate: true }, args30[0]), "|", rt.fmtSpec({ debugHex: "x" }, args30[0])])); - const _295: rt.Iter = rt.strChars(""); - const _298: rt.Iter = rt.strChars(""); - const _301: rt.Iter = rt.strBytes(""); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChars(_295, f), (f: rt.Formatter) => rt.fmtChars(_298, f), (f: rt.Formatter) => rt.fmtIter(_301, f, rt.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; - put(out, rt.fmtFormat([args32[0], "|", rt.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]])); - const _310: rt.Iter<[rt.u8, rt.u8 | undefined]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): [rt.u8, rt.u8 | undefined] => { - const b6: rt.u8 = _29; - return [rt.u8Rem(b6, 16), thenSome$0d5am30(rt.u8Rem(b6, 3) !== 0, b6)] as [rt.u8, rt.u8 | undefined]; + const part10 = ends$iters_str_Chars(rs.strChars(text), front, back); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(part10, f)]; + put(out, rs.fmtFormat([args28[0], "|", rs.fmtSpec({ alternate: true }, args28[0]), "|", rs.fmtSpec({ align: ">", width: 3 }, args28[0])])); + const part11 = ends$iters_str_Bytes(rs.strBytes(text), front, back); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0]), "|", rs.fmtSpec({ debugHex: "x" }, args30[0])])); + const _295: rs.Iter = rs.strChars(""); + const _298: rs.Iter = rs.strChars(""); + const _301: rs.Iter = rs.strBytes(""); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChars(_295, f), (f: rs.Formatter) => rs.fmtChars(_298, f), (f: rs.Formatter) => rs.fmtIter(_301, f, rs.u8Debug, ["Bytes", ["Copied", "it"], "Iter"])]; + put(out, rs.fmtFormat([args32[0], "|", rs.fmtSpec({ alternate: true }, args32[1]), "|", args32[2]])); + const _310: rs.Iter<[rs.u8, rs.u8 | undefined]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): [rs.u8, rs.u8 | undefined] => { + const b6: rs.u8 = _29; + return [rs.u8Rem(b6, 16), thenSome$0quywni(rs.u8Rem(b6, 3) !== 0, b6)] as [rs.u8, rs.u8 | undefined]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); - const part12 = ends$iters_collections_btree_map_Iter_u8_Option_u8(rt.btreeIter(map), front, back); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part12, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0]), "|", rt.fmtSpec({ debugHex: "x" }, args34[0])])); - const _335: rt.Iter = ends$iters_collections_btree_map_Keys_u8_Option_u8(rt.btreeKeys(map), front, back); - const _339: rt.Iter = ends$iters_collections_btree_map_Values_u8_Option_u8(rt.btreeValues(map), front, back); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_335, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIter(_339, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args36[0], "|", args36[1]])); - const lo: rt.u8 = rt.u8Rem(at(2), 16); - const _360: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rt.btreeRange(map, new rt.RangeFrom(lo, rt.u8Step)), front, back); - const _365: rt.Iter<[rt.u8, rt.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rt.btreeRange(map, { end: lo, inclusive: true }), front, back); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_360, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f)), (f: rt.Formatter) => rt.fmtIter(_365, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - put(out, rt.fmtFormat([args38[0], "|", args38[1]])); - const part13 = ends$iters_collections_btree_map_IterMut_u8_Option_u8(rt.btreeIterMut(map), front, back); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part13, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - put(out, rt.fmtFormat([args40[0]])); - const part14 = ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(rt.btreeValuesMut(map), front, back); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part14, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args42[0]])); - const part15 = ends$iters_collections_btree_map_RangeMut_u8_Option_u8(rt.btreeRangeMut(map, new rt.RangeFrom(lo, rt.u8Step)), front, back); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part15, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - put(out, rt.fmtFormat([args44[0]])); - const part16 = ends$iters_collections_btree_map_IntoIter_u8_Option_u8(rt.btreeIter(rt.btreeClone(map, undefined, undefined)), front, back); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part16, f, (value: [rt.u8, rt.u8 | undefined], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtOption(value[1], f, rt.u8Debug)], f))]; - put(out, rt.fmtFormat([args46[0]])); - const part17 = ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(rt.btreeKeys(rt.btreeClone(map, undefined, undefined)), front, back); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part17, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args48[0]])); - const part18 = ends$iters_collections_btree_map_IntoValues_u8_Option_u8(rt.btreeValues(map), front, back); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part18, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args50[0]])); - const _468: rt.Iter<[Uint8Array, Hex.Hex]> = rt.iterMap(rt.byteSliceChunksExact(data, 2), (c2: rt.ByteSlice): [Uint8Array, Hex.Hex] => { - rt.idx(c2, 0); - const _411: rt.u8 = c2.data[c2.start]; - rt.idx(c2, 1); + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _310, true, undefined, undefined, undefined, 3, true); + const part12 = ends$iters_collections_btree_map_Iter_u8_Option_u8(rs.btreeIter(map), front, back); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + const _335: rs.Iter = ends$iters_collections_btree_map_Keys_u8_Option_u8(rs.btreeKeys(map), front, back); + const _339: rs.Iter = ends$iters_collections_btree_map_Values_u8_Option_u8(rs.btreeValues(map), front, back); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_335, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIter(_339, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args36[0], "|", args36[1]])); + const lo: rs.u8 = rs.u8Rem(at(2), 16); + const _360: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); + const _365: rs.Iter<[rs.u8, rs.u8 | undefined]> = ends$iters_collections_btree_map_Range_u8_Option_u8(rs.btreeRange(map, { end: lo, inclusive: true }), front, back); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_360, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f)), (f: rs.Formatter) => rs.fmtIter(_365, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args38[0], "|", args38[1]])); + const part13 = ends$iters_collections_btree_map_IterMut_u8_Option_u8(rs.btreeIterMut(map), front, back); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part13, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args40[0]])); + const part14 = ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(rs.btreeValuesMut(map), front, back); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part14, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args42[0]])); + const part15 = ends$iters_collections_btree_map_RangeMut_u8_Option_u8(rs.btreeRangeMut(map, new rs.RangeFrom(lo, rs.u8Step)), front, back); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part15, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args44[0]])); + const part16 = ends$iters_collections_btree_map_IntoIter_u8_Option_u8(rs.btreeIter(rs.btreeClone(map, undefined, undefined)), front, back); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part16, f, (value: [rs.u8, rs.u8 | undefined], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtOption(value[1], f, rs.u8Debug)], f))]; + put(out, rs.fmtFormat([args46[0]])); + const part17 = ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(rs.btreeKeys(rs.btreeClone(map, undefined, undefined)), front, back); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part17, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args48[0]])); + const part18 = ends$iters_collections_btree_map_IntoValues_u8_Option_u8(rs.btreeValues(map), front, back); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part18, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args50[0]])); + const _468: rs.Iter<[Uint8Array, Hex.Hex]> = rs.iterMap(rs.byteSliceChunksExact(data, 2), (c2: rs.ByteSlice): [Uint8Array, Hex.Hex] => { + rs.idx(c2, 0); + const _411: rs.u8 = c2.data[c2.start]; + rs.idx(c2, 1); const _33: Uint8Array = Uint8Array.of(_411, c2.data[c2.start + 1]); - rt.idx(c2, 0); - return [_33, { _0: c2.data[c2.start] as rt.u32 }] as [Uint8Array, Hex.Hex]; + rs.idx(c2, 0); + return [_33, { _0: c2.data[c2.start] as rs.u32 }] as [Uint8Array, Hex.Hex]; }); - const keyed: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmpBytes) as rt.BTreeMap, _468, true, undefined, undefined, undefined, 8, true); - const it13: rt.Iter<[rt.ByteSlice, Hex.Hex]> = ends$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(rt.iterLend(rt.btreeIter(keyed), (held): [rt.ByteSlice, Hex.Hex] => { - return [rt.byteSliceFrom(held[0]), held[1]]; + const keyed: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmpBytes) as rs.BTreeMap, _468, true, undefined, undefined, undefined, 8, true); + const it13: rs.Iter<[rs.ByteSlice, Hex.Hex]> = ends$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(rs.iterLend(rs.btreeIter(keyed), (held): [rs.ByteSlice, Hex.Hex] => { + return [rs.byteSliceFrom(held[0]), held[1]]; }), front, back); - const _481: rt.Iter = ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(rt.iterLend(rt.btreeKeys(keyed), rt.byteSliceFrom), back, front); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtList(value[0], f, rt.u8Debug), (f: rt.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_481, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args52[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]])); - const _491: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 => { - return rt.u8Rem(_212, 16); + const _481: rs.Iter = ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(rs.iterLend(rs.btreeKeys(keyed), rs.byteSliceFrom), back, front); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it13, f, (value: [Uint8Array, Hex.Hex], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtList(value[0], f, rs.u8Debug), (f: rs.Formatter) => Hex.fmt$fmt_Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_481, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args52[0]), "|", args52[1]])); + const _491: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { + return rs.u8Rem(_212, 16); }); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _491, true, undefined, undefined, 1, true); - const part19 = ends$iters_collections_btree_set_Iter_u8(rt.btreeKeys(set), front, back); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part19, f, rt.u8Debug, ["Iter"])]; - put(out, rt.fmtFormat([args54[0], "|", rt.fmtSpec({ alternate: true }, args54[0])])); - const part20 = ends$iters_collections_btree_set_Range_u8(rt.btreeRangeKeys(set, new rt.RangeFrom(lo, rt.u8Step)), front, back); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part20, f, rt.fmtSetVal(rt.u8Debug), [["Range", "iter"]])]; - put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0]), "|", rt.fmtSpec({ debugHex: "x" }, args56[0])])); - const part21 = ends$iters_collections_btree_set_IntoIter_u8(rt.btreeKeys(set), front, back); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part21, f, rt.fmtSetVal(rt.u8Debug), [["IntoIter", "iter"]])]; - put(out, rt.fmtFormat([args58[0], "|", rt.fmtSpec({ alternate: true }, args58[0])])); - const empty2: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _547: rt.Iter<[rt.u8, rt.u8]> = rt.btreeIter(empty2); - const _550: rt.Iter = rt.btreeKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_547, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_550, f, rt.u8Debug, ["Iter"])]; - put(out, rt.fmtFormat([args60[0], "|", rt.fmtSpec({ alternate: true }, args60[1])])); - const part22 = rt.btreeKeys(empty2); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part22, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args62[0]])); - const _573: [rt.HashMap, rt.HashSet] = [rt.hashNew(rt.hashing(rt.hashOption(rt.hash8), rt.same)) as rt.HashMap, rt.hashNew(rt.hashing(rt.hashBytes, rt.eqBytes)) as rt.HashSet]; - const one: rt.HashMap = _573[0]; - const keys: rt.HashSet = _573[1]; - const _576: rt.u8 | undefined = rt.byteSliceFirst(data); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _491, true, undefined, undefined, 1, true); + const part19 = ends$iters_collections_btree_set_Iter_u8(rs.btreeKeys(set), front, back); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part19, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0])])); + const part20 = ends$iters_collections_btree_set_Range_u8(rs.btreeRangeKeys(set, new rs.RangeFrom(lo, rs.u8Step)), front, back); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part20, f, rs.fmtSetVal(rs.u8Debug), [["Range", "iter"]])]; + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0]), "|", rs.fmtSpec({ debugHex: "x" }, args56[0])])); + const part21 = ends$iters_collections_btree_set_IntoIter_u8(rs.btreeKeys(set), front, back); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part21, f, rs.fmtSetVal(rs.u8Debug), [["IntoIter", "iter"]])]; + put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0])])); + const empty2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _547: rs.Iter<[rs.u8, rs.u8]> = rs.btreeIter(empty2); + const _550: rs.Iter = rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_547, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_550, f, rs.u8Debug, ["Iter"])]; + put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[1])])); + const part22 = rs.btreeKeys(empty2); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part22, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args62[0]])); + const _573: [rs.HashMap, rs.HashSet] = [rs.hashNew(rs.hashing(rs.hashOption(rs.hash8), rs.same)) as rs.HashMap, rs.hashNew(rs.hashing(rs.hashBytes, rs.eqBytes)) as rs.HashSet]; + const one: rs.HashMap = _573[0]; + const keys: rs.HashSet = _573[1]; + const _576: rs.u8 | undefined = rs.byteSliceFirst(data); if (_576 !== undefined) { - const b: rt.u8 = _576; - const _581: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 2) === 0, b); - rt.hashInsert(one, _581, rt.u16Mul(b as rt.u16, 257)); + const b: rs.u8 = _576; + const _581: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 2) === 0, b); + rs.hashInsert(one, _581, rs.u16Mul(b as rs.u16, 257)); const _590: Uint8Array = Uint8Array.of(b, at(1)); - rt.hashAdd(keys, _590); - } - const n: rt.usize = rt.u8Rem(at(1), 2) as rt.usize; - const _608: rt.Iter<[rt.u8 | undefined, rt.u16]> = rt.hashIter(one); - const _611: rt.Iter<[rt.u8 | undefined, rt.u16]> = skip$iters_collections_hash_map_Iter_Option_u8_u16(rt.hashIter(one), n); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_608, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtIter(_611, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args64[0], "|", rt.fmtSpec({ alternate: true }, args64[1])])); - const _627: rt.Iter = skip$iters_collections_hash_map_Keys_Option_u8_u16(rt.hashKeys(one), n); - const _631: rt.Iter = skip$iters_collections_hash_map_Values_Option_u8_u16(rt.hashValues(one), n); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_627, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_631, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args66[0], "|", args66[1]])); - const part23 = skip$iters_collections_hash_map_IterMut_Option_u8_u16(rt.hashIterMut(one), n); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part23, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args68[0]])); - const part24 = skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(rt.hashValuesMut(one), rt.usizeSub(1, n)); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part24, f, rt.u16Debug)]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args70[0])])); - const part25 = skip$iters_collections_hash_map_IntoIter_Option_u8_u16(rt.hashIter(rt.hashClone(one, undefined, undefined)), n); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part25, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args72[0]])); - const _695: rt.Iter = rt.hashKeys(rt.hashClone(one, undefined, undefined)); - const _699: rt.Iter = skip$iters_collections_hash_map_IntoValues_Option_u8_u16(rt.hashValues(rt.hashClone(one, undefined, undefined)), n); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_695, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_699, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args74[0], "|", args74[1]])); - const it17: rt.Iter<[rt.u8 | undefined, rt.u16]> = skip$iters_collections_hash_map_Drain_Option_u8_u16(rt.hashDrain(one), n); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(it17, f, (value: [rt.u8 | undefined, rt.u16], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(value[0], f, rt.u8Debug), (f: rt.Formatter) => rt.u16Debug(value[1], f)], f))]; - put(out, rt.fmtFormat([args76[0], "|", rt.fmtSpec({ alternate: true }, args76[0])])); - const _732: rt.Iter = skip$iters_collections_hash_set_Iter_array2_u8(rt.iterLend(rt.hashKeys(keys), rt.byteSliceFrom), n); - const _736: rt.Iter = rt.hashKeys(rt.hashClone(keys, copy$array_u8, undefined)); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(_732, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)), (f: rt.Formatter) => rt.fmtIter(_736, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args78[0], "|", rt.fmtSpec({ alternate: true }, args78[1])])); - const part26 = skip$iters_collections_hash_set_Drain_array2_u8(rt.hashDrainKeys(keys), rt.usizeSub(1, n)); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part26, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args80[0]])); -} - -export function skip$iters_collections_binary_heap_Drain_u8(it: rt.Iter, n: rt.usize): rt.Iter { + rs.hashAdd(keys, _590); + } + const n: rs.usize = rs.u8Rem(at(1), 2) as rs.usize; + const _608: rs.Iter<[rs.u8 | undefined, rs.u16]> = rs.hashIter(one); + const _611: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Iter_Option_u8_u16(rs.hashIter(one), n); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_608, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtIter(_611, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[1])])); + const _627: rs.Iter = skip$iters_collections_hash_map_Keys_Option_u8_u16(rs.hashKeys(one), n); + const _631: rs.Iter = skip$iters_collections_hash_map_Values_Option_u8_u16(rs.hashValues(one), n); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_627, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_631, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args66[0], "|", args66[1]])); + const part23 = skip$iters_collections_hash_map_IterMut_Option_u8_u16(rs.hashIterMut(one), n); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part23, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args68[0]])); + const part24 = skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(rs.hashValuesMut(one), rs.usizeSub(1, n)); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part24, f, rs.u16Debug)]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args70[0])])); + const part25 = skip$iters_collections_hash_map_IntoIter_Option_u8_u16(rs.hashIter(rs.hashClone(one, undefined, undefined)), n); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part25, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args72[0]])); + const _695: rs.Iter = rs.hashKeys(rs.hashClone(one, undefined, undefined)); + const _699: rs.Iter = skip$iters_collections_hash_map_IntoValues_Option_u8_u16(rs.hashValues(rs.hashClone(one, undefined, undefined)), n); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_695, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_699, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args74[0], "|", args74[1]])); + const it17: rs.Iter<[rs.u8 | undefined, rs.u16]> = skip$iters_collections_hash_map_Drain_Option_u8_u16(rs.hashDrain(one), n); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(it17, f, (value: [rs.u8 | undefined, rs.u16], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(value[0], f, rs.u8Debug), (f: rs.Formatter) => rs.u16Debug(value[1], f)], f))]; + put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ alternate: true }, args76[0])])); + const _732: rs.Iter = skip$iters_collections_hash_set_Iter_array2_u8(rs.iterLend(rs.hashKeys(keys), rs.byteSliceFrom), n); + const _736: rs.Iter = rs.hashKeys(rs.hashClone(keys, copy$array_u8, undefined)); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(_732, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)), (f: rs.Formatter) => rs.fmtIter(_736, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[1])])); + const part26 = skip$iters_collections_hash_set_Drain_array2_u8(rs.hashDrainKeys(keys), rs.usizeSub(1, n)); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part26, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args80[0]])); +} + +export function skip$iters_collections_binary_heap_Drain_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_binary_heap_IntoIter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_binary_heap_IntoIter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_binary_heap_Iter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_binary_heap_Iter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_IntoIter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { +export function skip$iters_collections_btree_map_IntoIter_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, n: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_IntoKeys_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_map_IntoKeys_u8_Option_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_IntoValues_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_map_IntoValues_u8_Option_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + rs.iterNth(it, rs.usizeSub(n, 1), undefined, rs.None); return it; } return it; } -export function skip$iters_collections_btree_map_IterMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8, rt.Place]> { +export function skip$iters_collections_btree_map_IterMut_u8_Option_u8(it: rs.Iter<[rs.u8, rs.Place]>, n: rs.usize): rs.Iter<[rs.u8, rs.Place]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it: rt.Iter<[rt.ByteSlice, Hex.Hex]>, n: rt.usize): rt.Iter<[rt.ByteSlice, Hex.Hex]> { +export function skip$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it: rs.Iter<[rs.ByteSlice, Hex.Hex]>, n: rs.usize): rs.Iter<[rs.ByteSlice, Hex.Hex]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Iter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { +export function skip$iters_collections_btree_map_Iter_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, n: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Keys_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_map_Keys_u8_Option_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_RangeMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8, rt.Place]> { +export function skip$iters_collections_btree_map_RangeMut_u8_Option_u8(it: rs.Iter<[rs.u8, rs.Place]>, n: rs.usize): rs.Iter<[rs.u8, rs.Place]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Range_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, n: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { +export function skip$iters_collections_btree_map_Range_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, n: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_ValuesMut_u8_Option_u8(it: rt.Iter>, n: rt.usize): rt.Iter> { +export function skip$iters_collections_btree_map_ValuesMut_u8_Option_u8(it: rs.Iter>, n: rs.usize): rs.Iter> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_map_Values_u8_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_map_Values_u8_Option_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + rs.iterNth(it, rs.usizeSub(n, 1), undefined, rs.None); return it; } return it; } -export function skip$iters_collections_btree_set_IntoIter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_set_IntoIter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_set_Iter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_set_Iter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_btree_set_Range_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_btree_set_Range_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_Drain_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { +export function skip$iters_collections_hash_map_Drain_Option_u8_u16(it: rs.Iter<[rs.u8 | undefined, rs.u16]>, n: rs.usize): rs.Iter<[rs.u8 | undefined, rs.u16]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_IntoIter_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { +export function skip$iters_collections_hash_map_IntoIter_Option_u8_u16(it: rs.Iter<[rs.u8 | undefined, rs.u16]>, n: rs.usize): rs.Iter<[rs.u8 | undefined, rs.u16]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_IntoValues_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_hash_map_IntoValues_Option_u8_u16(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_IterMut_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.Place]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.Place]> { +export function skip$iters_collections_hash_map_IterMut_Option_u8_u16(it: rs.Iter<[rs.u8 | undefined, rs.Place]>, n: rs.usize): rs.Iter<[rs.u8 | undefined, rs.Place]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_Iter_Option_u8_u16(it: rt.Iter<[rt.u8 | undefined, rt.u16]>, n: rt.usize): rt.Iter<[rt.u8 | undefined, rt.u16]> { +export function skip$iters_collections_hash_map_Iter_Option_u8_u16(it: rs.Iter<[rs.u8 | undefined, rs.u16]>, n: rs.usize): rs.Iter<[rs.u8 | undefined, rs.u16]> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_Keys_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_hash_map_Keys_Option_u8_u16(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + rs.iterNth(it, rs.usizeSub(n, 1), undefined, rs.None); return it; } return it; } -export function skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(it: rt.Iter>, n: rt.usize): rt.Iter> { +export function skip$iters_collections_hash_map_ValuesMut_Option_u8_u16(it: rs.Iter>, n: rs.usize): rs.Iter> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_map_Values_Option_u8_u16(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_hash_map_Values_Option_u8_u16(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_set_Drain_array2_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_hash_set_Drain_array2_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_hash_set_Iter_array2_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_hash_set_Iter_array2_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_collections_vec_deque_IntoIter_Option_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_collections_vec_deque_IntoIter_Option_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1), undefined, rt.None); + rs.iterNth(it, rs.usizeSub(n, 1), undefined, rs.None); return it; } return it; } -export function skip$iters_slice_IterMut_array2_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_slice_IterMut_array2_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_slice_IterMut_u8(it: rt.Iter>, n: rt.usize): rt.Iter> { +export function skip$iters_slice_IterMut_u8(it: rs.Iter>, n: rs.usize): rs.Iter> { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_slice_Iter_array2_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_slice_Iter_array2_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_slice_Iter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_slice_Iter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_str_Bytes(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_str_Bytes(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_str_Chars(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_str_Chars(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_vec_Drain_fmt_Hex(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_vec_Drain_fmt_Hex(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_vec_Drain_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_vec_Drain_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_vec_IntoIter_fmt_Pair(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_vec_IntoIter_fmt_Pair(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function skip$iters_vec_IntoIter_u8(it: rt.Iter, n: rt.usize): rt.Iter { +export function skip$iters_vec_IntoIter_u8(it: rs.Iter, n: rs.usize): rs.Iter { if (n > 0) { - rt.iterNth(it, rt.usizeSub(n, 1)); + rs.iterNth(it, rs.usizeSub(n, 1)); return it; } return it; } -export function ends$iters_collections_binary_heap_Drain_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_binary_heap_Drain_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_binary_heap_Drain_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_binary_heap_Drain_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_binary_heap_IntoIter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_binary_heap_IntoIter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_binary_heap_IntoIter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_binary_heap_IntoIter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_binary_heap_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_binary_heap_Iter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_binary_heap_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_binary_heap_Iter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_IntoIter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { - const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$iters_collections_btree_map_IntoIter_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_IntoIter_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { + const it2: rs.Iter<[rs.u8, rs.u8 | undefined]> = skip$iters_collections_btree_map_IntoIter_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_map_IntoKeys_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_IntoKeys_u8_Option_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_map_IntoKeys_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_IntoValues_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_map_IntoValues_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_IntoValues_u8_Option_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_map_IntoValues_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack(), rt.None); + rs.iterToOption(it2.nextBack(), rs.None); } } -export function ends$iters_collections_btree_map_IterMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.Place]> { - const it2: rt.Iter<[rt.u8, rt.Place]> = skip$iters_collections_btree_map_IterMut_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_IterMut_u8_Option_u8(it: rs.Iter<[rs.u8, rs.Place]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.Place]> { + const it2: rs.Iter<[rs.u8, rs.Place]> = skip$iters_collections_btree_map_IterMut_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it: rt.Iter<[rt.ByteSlice, Hex.Hex]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.ByteSlice, Hex.Hex]> { - const it2: rt.Iter<[rt.ByteSlice, Hex.Hex]> = skip$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it: rs.Iter<[rs.ByteSlice, Hex.Hex]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.ByteSlice, Hex.Hex]> { + const it2: rs.Iter<[rs.ByteSlice, Hex.Hex]> = skip$iters_collections_btree_map_Iter_array2_u8_fmt_Hex(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Iter_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { - const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$iters_collections_btree_map_Iter_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Iter_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { + const it2: rs.Iter<[rs.u8, rs.u8 | undefined]> = skip$iters_collections_btree_map_Iter_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_map_Keys_array2_u8_fmt_Hex(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Keys_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_map_Keys_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Keys_u8_Option_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_map_Keys_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_RangeMut_u8_Option_u8(it: rt.Iter<[rt.u8, rt.Place]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.Place]> { - const it2: rt.Iter<[rt.u8, rt.Place]> = skip$iters_collections_btree_map_RangeMut_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_RangeMut_u8_Option_u8(it: rs.Iter<[rs.u8, rs.Place]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.Place]> { + const it2: rs.Iter<[rs.u8, rs.Place]> = skip$iters_collections_btree_map_RangeMut_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Range_u8_Option_u8(it: rt.Iter<[rt.u8, rt.u8 | undefined]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8 | undefined]> { - const it2: rt.Iter<[rt.u8, rt.u8 | undefined]> = skip$iters_collections_btree_map_Range_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Range_u8_Option_u8(it: rs.Iter<[rs.u8, rs.u8 | undefined]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.u8 | undefined]> { + const it2: rs.Iter<[rs.u8, rs.u8 | undefined]> = skip$iters_collections_btree_map_Range_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(it: rt.Iter>, front: rt.usize, back: rt.usize): rt.Iter> { - const it2: rt.Iter> = skip$iters_collections_btree_map_ValuesMut_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_ValuesMut_u8_Option_u8(it: rs.Iter>, front: rs.usize, back: rs.usize): rs.Iter> { + const it2: rs.Iter> = skip$iters_collections_btree_map_ValuesMut_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_map_Values_u8_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_map_Values_u8_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_map_Values_u8_Option_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_map_Values_u8_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack(), rt.None); + rs.iterToOption(it2.nextBack(), rs.None); } } -export function ends$iters_collections_btree_set_IntoIter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_set_IntoIter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_set_IntoIter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_set_IntoIter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_set_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_set_Iter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_set_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_set_Iter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_btree_set_Range_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_btree_set_Range_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_btree_set_Range_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_btree_set_Range_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_collections_vec_deque_IntoIter_Option_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_collections_vec_deque_IntoIter_Option_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_collections_vec_deque_IntoIter_Option_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_collections_vec_deque_IntoIter_Option_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack(), rt.None); + rs.iterToOption(it2.nextBack(), rs.None); } } -export function ends$iters_slice_IterMut_array2_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_slice_IterMut_array2_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_slice_IterMut_array2_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_slice_IterMut_array2_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_slice_IterMut_u8(it: rt.Iter>, front: rt.usize, back: rt.usize): rt.Iter> { - const it2: rt.Iter> = skip$iters_slice_IterMut_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_slice_IterMut_u8(it: rs.Iter>, front: rs.usize, back: rs.usize): rs.Iter> { + const it2: rs.Iter> = skip$iters_slice_IterMut_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_slice_Iter_array2_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_slice_Iter_array2_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_slice_Iter_array2_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_slice_Iter_array2_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_slice_Iter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_slice_Iter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_str_Bytes(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_str_Bytes(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_str_Bytes(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_str_Bytes(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_str_Chars(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_str_Chars(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_str_Chars(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_str_Chars(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_vec_Drain_fmt_Hex(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_vec_Drain_fmt_Hex(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_vec_Drain_fmt_Hex(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_vec_Drain_fmt_Hex(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_vec_Drain_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_vec_Drain_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_vec_Drain_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_vec_Drain_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_vec_IntoIter_fmt_Pair(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_vec_IntoIter_fmt_Pair(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_vec_IntoIter_fmt_Pair(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_vec_IntoIter_fmt_Pair(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } -export function ends$iters_vec_IntoIter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - const it2: rt.Iter = skip$iters_vec_IntoIter_u8(it, front); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = back; +export function ends$iters_vec_IntoIter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + const it2: rs.Iter = skip$iters_vec_IntoIter_u8(it, front); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = back; while (true) { if (!(iterStart++ < iterEnd)) { return it2; } - rt.iterToOption(it2.nextBack()); + rs.iterToOption(it2.nextBack()); } } @@ -1856,1019 +1856,1019 @@ export function ends$iters_vec_IntoIter_u8(it: rt.Iter, front: rt.usize, * with no closure: consumed from either end, so each writes the state it keeps, as a * `Peekable` its peeked item and a `Skip` what it has left to skip, plain and pretty. */ -export function adaptors(data: rt.ByteSlice, out: rt.ByteVec): void { +export function adaptors(data: rs.ByteSlice, out: rs.ByteVec): void { let toggle!: Toggle.Toggle; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 4) as rt.usize, rt.u8Rem(at(1), 3) as rt.usize]; - const front: rt.usize = _6[0]; - const back: rt.usize = _6[1]; - const bytes: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 6)); - const part2 = ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (b: rt.u8): rt.u8 => { - return rt.u8Add(b, 1); + const _6: [rs.usize, rs.usize] = [rs.u8Rem(at(0), 4) as rs.usize, rs.u8Rem(at(1), 3) as rs.usize]; + const front: rs.usize = _6[0]; + const back: rs.usize = _6[1]; + const bytes: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 6)); + const part2 = ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b: rs.u8): rs.u8 => { + return rs.u8Add(b, 1); }), front, back); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part2, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0])])); - const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rt.iterFilter(rt.iterSlice(rt.byteSliceView(bytes)), (_2: rt.u8): boolean => { - return rt.u8Rem(_2, 2) === 0; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part2, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const part3 = ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(rs.iterFilter(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): boolean => { + return rs.u8Rem(_2, 2) === 0; }), front, back); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part3, f, "Filter", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); - const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rt.iterFilterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_23: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_23, 9); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part3, f, "Filter", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const part4 = ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(rs.iterFilterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_23: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(_23, 9); }), front, back); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part4, f, "FilterMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args6[0]])); - const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rt.iterInspect(rt.iterSlice(rt.byteSliceView(bytes)), (_26: rt.u8): undefined => {}), front, back); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part5, f, "Inspect", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args8[0]])); - const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_28: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedSub(_28, 3); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part4, f, "FilterMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args6[0]])); + const part5 = ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(rs.iterInspect(rs.iterSlice(rs.byteSliceView(bytes)), (_26: rs.u8): undefined => {}), front, back); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part5, f, "Inspect", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args8[0]])); + const part6 = fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_28: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedSub(_28, 3); }), front); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part6, f, "MapWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args10[0]])); - const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))), front, back); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part7, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args12[0], "|", rt.fmtSpec({ alternate: true }, args12[0])])); - const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rt.iterSlice(rt.byteSliceView(bytes)), front, back); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part8, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", rt.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); - const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rt.iterCloned(rt.iterSlice(rt.byteSliceView(bytes))), front, back); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part9, f, "Cloned", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), "it")]; - put(out, rt.fmtFormat([args16[0]])); - const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rt.iterCloned(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (b5: rt.u8): string => { - return rt.fmtToString((f: rt.Formatter) => rt.u8Display(b5, f)); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part6, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args10[0]])); + const part7 = ends$adaptors_iter_Rev_slice_Iter_u8(rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), front, back); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part7, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args12[0], "|", rs.fmtSpec({ alternate: true }, args12[0])])); + const part8 = ends$adaptors_iter_Copied_slice_Iter_u8(rs.iterSlice(rs.byteSliceView(bytes)), front, back); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part8, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args14[0])])); + const part9 = ends$adaptors_iter_Cloned_slice_Iter_u8(rs.iterCloned(rs.iterSlice(rs.byteSliceView(bytes))), front, back); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part9, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), "it")]; + put(out, rs.fmtFormat([args16[0]])); + const part10 = ends$adaptors_iter_Cloned_slice_Iter_String(rs.iterCloned(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (b5: rs.u8): string => { + return rs.fmtToString((f: rs.Formatter) => rs.u8Display(b5, f)); }), undefined, 12, true).items)), front, back); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part10, f, "Cloned", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.fmtStr, ["Iter"]), "it")]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[0])])); - const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rt.iterCopied(rt.iterLend(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterTake(rt.byteSliceChunksExact(data, 2), 3), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _32: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part10, f, "Cloned", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.fmtStr, ["Iter"]), "it")]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0])])); + const part11 = ends$adaptors_iter_Copied_slice_Iter_array2_u8(rs.iterCopied(rs.iterLend(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterTake(rs.byteSliceChunksExact(data, 2), 3), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _32: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_32, c.data[c.start + 1]); - }), undefined, 2, true).items), rt.byteSliceFrom), rt.byteSliceToArray), front, back); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part11, f, "Copied", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug), ["Iter"]), "it")]; - put(out, rt.fmtFormat([args20[0]])); - const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(bytes))), front, back); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part12, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args22[0], "|", rt.fmtSpec({ alternate: true }, args22[0]), "|", rt.fmtSpec({ debugHex: "x" }, args22[0])])); - const it12: rt.Iter = rt.iterSkip(rt.iterSlice(rt.byteSliceView(bytes)), at(2) as rt.usize); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0])])); - rt.iterToOption(it12.nextBack()); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args26[0]])); + }), undefined, 2, true).items), rs.byteSliceFrom), rs.byteSliceToArray), front, back); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part11, f, "Copied", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug), ["Iter"]), "it")]; + put(out, rs.fmtFormat([args20[0]])); + const part12 = ends$adaptors_iter_Enumerate_slice_Iter_u8(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(bytes))), front, back); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part12, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args22[0], "|", rs.fmtSpec({ alternate: true }, args22[0]), "|", rs.fmtSpec({ debugHex: "x" }, args22[0])])); + const it12: rs.Iter = rs.iterSkip(rs.iterSlice(rs.byteSliceView(bytes)), at(2) as rs.usize); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0])])); + rs.iterToOption(it12.nextBack()); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args26[0]])); it12.next(); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(it12, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args28[0]])); - const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rt.iterTake(rt.iterSlice(rt.byteSliceView(bytes)), rt.u8Rem(at(2), 8) as rt.usize), front, back); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part13, f, "Take", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args30[0], "|", rt.fmtSpec({ alternate: true }, args30[0])])); - const it14: rt.Iter = rt.iterSkipWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_211: rt.u8): boolean => { - return rt.u8Rem(_211, 3) !== 0; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(it12, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args28[0]])); + const part13 = ends$adaptors_iter_Take_slice_Iter_u8(rs.iterTake(rs.iterSlice(rs.byteSliceView(bytes)), rs.u8Rem(at(2), 8) as rs.usize), front, back); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + const it14: rs.Iter = rs.iterSkipWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_211: rs.u8): boolean => { + return rs.u8Rem(_211, 3) !== 0; }); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it14, f, "SkipWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args32[0]])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args32[0]])); it14.next(); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it14, f, "SkipWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0])])); - const it15: rt.Iter = rt.iterTakeWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_212: rt.u8): boolean => { - return rt.u8Rem(_212, 5) !== 0; + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it14, f, "SkipWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + const it15: rs.Iter = rs.iterTakeWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): boolean => { + return rs.u8Rem(_212, 5) !== 0; }); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it15, f, "TakeWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args36[0]])); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args36[0]])); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { it15.next(); } - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlagged(it15, f, "TakeWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args38[0], "|", rt.fmtSpec({ alternate: true }, args38[0])])); - const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rt.iterScan(rt.iterSlice(rt.byteSliceView(bytes)), 0, (sum: rt.Place, _33: rt.u8): rt.u32 | undefined => { - sum.v = rt.u32Add(sum.v, _33 as rt.u32); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlagged(it15, f, "TakeWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0])])); + const part14 = fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), 0, (sum: rs.Place, _33: rs.u8): rs.u32 | undefined => { + sum.v = rs.u32Add(sum.v, _33 as rs.u32); return sum.v; }, true), front); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtScan(part14, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u32Debug)]; - put(out, rt.fmtFormat([args40[0], "|", rt.fmtSpec({ alternate: true }, args40[0]), "|", rt.fmtSpec({ debugHex: "x" }, args40[0])])); - const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rt.iterScan(rt.iterSlice(rt.byteSliceView(bytes)), "", (s: rt.Place, _34: rt.u8): rt.usize | undefined => { - const b9: rt.u8 = _34; - s.v = s.v + String.fromCodePoint(rt.u8Add(97, rt.u8Rem(b9, 26)) as rt.char); - return then$0uwf92a(rt.u8Rem(b9, 7) !== 0, (): rt.usize => { - return rt.stringLen(s.v); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part14, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u32Debug)]; + put(out, rs.fmtFormat([args40[0], "|", rs.fmtSpec({ alternate: true }, args40[0]), "|", rs.fmtSpec({ debugHex: "x" }, args40[0])])); + const part15 = fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(rs.iterScan(rs.iterSlice(rs.byteSliceView(bytes)), "", (s: rs.Place, _34: rs.u8): rs.usize | undefined => { + const b9: rs.u8 = _34; + s.v = s.v + String.fromCodePoint(rs.u8Add(97, rs.u8Rem(b9, 26)) as rs.char); + return then$1uoo7un(rs.u8Rem(b9, 7) !== 0, (): rs.usize => { + return rs.stringLen(s.v); }); }, true), front); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtScan(part15, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.fmtStr)]; - put(out, rt.fmtFormat([args42[0]])); - const it18: rt.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))), front, back); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; - put(out, rt.fmtFormat([args44[0]])); - rt.peekablePeek(it18); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; - put(out, rt.fmtFormat([args46[0], "|", rt.fmtSpec({ alternate: true }, args46[0])])); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtScan(part15, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.fmtStr)]; + put(out, rs.fmtFormat([args42[0]])); + const it18: rs.Peekable = ends$adaptors_iter_Peekable_slice_Iter_u8(rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))), front, back); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args44[0]])); + rs.peekablePeek(it18); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args46[0], "|", rs.fmtSpec({ alternate: true }, args46[0])])); it18.next(); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it18, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; - put(out, rt.fmtFormat([args48[0]])); - const it19: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(bytes.length, 1))))); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it18, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args48[0]])); + const it19: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(bytes.length, 1))))); it19.next(); - rt.peekablePeek(it19); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(it19, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), rt.u8Debug)]; - put(out, rt.fmtFormat([args50[0], "|", rt.fmtSpec({ alternate: true }, args50[0])])); - const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(2, bytes.length)))), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, rt.min(2, bytes.length))))), front, back); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part19, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args52[0], "|", rt.fmtSpec({ alternate: true }, args52[0])])); - const it21: rt.Iter = rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(bytes, 0, rt.min(1, bytes.length)))), rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(7, 8))))); - rt.iterToOption(it21.nextBack()); - rt.iterToOption(it21.nextBack()); - rt.iterToOption(it21.nextBack()); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(it21, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args54[0]])); - const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b10: rt.u8): rt.u8 => { + rs.peekablePeek(it19); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(it19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), rs.u8Debug)]; + put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + const part19 = ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(2, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, rs.min(2, bytes.length))))), front, back); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part19, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0])])); + const it21: rs.Iter = rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(bytes, 0, rs.min(1, bytes.length)))), rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(7, 8))))); + rs.iterToOption(it21.nextBack()); + rs.iterToOption(it21.nextBack()); + rs.iterToOption(it21.nextBack()); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(it21, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args54[0]])); + const part21 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b10: rs.u8): rs.u8 => { return b10 ^ 1; }), [false, true]), front, back); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part21, f)]; - put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0])])); - const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rt.iterZip(rt.iterSlice(rt.byteSliceView(bytes)), rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))), "len"), front, back); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part22, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args58[0]])); - const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rt.iterZip(rt.strChars(rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_213: rt.u8): rt.char => { - const _511: rt.usize = rt.u8Rem(_213, 4) as rt.usize; + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part21, f)]; + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + const part22 = ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(rs.iterZip(rs.iterSlice(rs.byteSliceView(bytes)), rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))), "len"), front, back); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part22, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args58[0]])); + const part23 = fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(rs.iterZip(rs.strChars(rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.char => { + const _511: rs.usize = rs.u8Rem(_213, 4) as rs.usize; if (!(_511 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _511); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _511); } return [97, 233, 20013, 129408][_511]; - }))), rt.iterSlice(rt.byteSliceView(bytes))), front); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part23, f, rt.fmtChars, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args60[0], "|", rt.fmtSpec({ alternate: true }, args60[0])])); - const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rt.iterCycle(rt.iterSlice(rt.byteSliceView(bytes))), rt.usizeAdd(front, rt.u8Rem(at(2), 8) as rt.usize)); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCycle(part24, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args62[0], "|", rt.fmtSpec({ alternate: true }, args62[0])])); - const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rt.iterFuse(rt.iterSlice(rt.byteSliceView(bytes)), true), rt.usizeAdd(front, 6)); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part25, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args64[0], "|", rt.fmtSpec({ alternate: true }, args64[0])])); - const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rt.iterFuse(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), 2), true), rt.usizeAdd(front, 2)); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part26, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtStepBy(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args66[0], "|", rt.fmtSpec({ alternate: true }, args66[0])])); - const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rt.iterFuse(rt.iterMapWhile(rt.iterSlice(rt.byteSliceView(bytes)), (_216: rt.u8): rt.u8 | undefined => { - const b12: rt.u8 = _216; - return thenSome$0d5am30(rt.u8Rem(b12, 4) !== 0, b12); - })), rt.usizeMul(front, 2)); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part27, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "MapWhile", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args68[0]])); - const step: rt.usize = rt.usizeAdd(rt.u8Rem(at(3), 4) as rt.usize, 1); - const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rt.iterStepBy(rt.iterSlice(rt.byteSliceView(bytes)), step), front, back); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part28, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args70[0], "|", rt.fmtSpec({ alternate: true }, args70[0])])); - const _630: [rt.u8, rt.u8] = [rt.u8Rem(at(4), 16), at(5)]; - const lo: rt.u8 = _630[0]; - const hi: rt.u8 = _630[1]; - const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(lo, hi), step, undefined, 255), front, back); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part29, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args72[0], "|", rt.fmtSpec({ alternate: true }, args72[0])])); - const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rt.iterStepBy(new rt.Range(lo as rt.u32, hi as rt.u32), step, undefined, 4294967295), front); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part30, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u32Debug))]; - put(out, rt.fmtFormat([args74[0]])); - const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rt.iterStepBy(new rt.Range(lo as rt.usize, hi as rt.usize), step, undefined, 4294967295), front, back); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part31, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.usizeDebug))]; - put(out, rt.fmtFormat([args76[0], "|", rt.fmtSpec({ debugHex: "x" }, args76[0])])); - const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rt.iterStepBy(new rt.Range(lo as rt.u16, hi as rt.u16), step, undefined, 65535), front, back); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part32, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u16Debug))]; - put(out, rt.fmtFormat([args78[0]])); - const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rt.iterStepBy(new rt.Range(lo as rt.i32, hi as rt.i32), step), front, back); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part33, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.i32Debug))]; - put(out, rt.fmtFormat([args80[0]])); - const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rt.iterStepBy(new rt.Range(lo as rt.u64, hi as rt.u64, rt.u64Step), step), front); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part34, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u64Debug))]; - put(out, rt.fmtFormat([args82[0]])); - const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(250, 255), 300, undefined, 255), front); - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part35, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args84[0]])); - const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(250, 255), rt.usizeAdd(at(3) as rt.usize, 1), undefined, 255), front); - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part36, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args86[0]])); - const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rt.iterStepBy(new rt.Range(hi, 255), rt.usizeAdd(step, 200), undefined, 255), front); - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStepBy(part37, f, (value: rt.Range, f: rt.Formatter) => rt.fmtRange(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args88[0]])); - const lists: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(bytes, 2), (a0: rt.ByteSlice): rt.ByteVec => { - return rt.byteSliceToByteVec(a0); + }))), rs.iterSlice(rs.byteSliceView(bytes))), front); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part23, f, rs.fmtChars, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args60[0], "|", rs.fmtSpec({ alternate: true }, args60[0])])); + const part24 = fronts$adaptors_iter_Cycle_slice_Iter_u8(rs.iterCycle(rs.iterSlice(rs.byteSliceView(bytes))), rs.usizeAdd(front, rs.u8Rem(at(2), 8) as rs.usize)); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCycle(part24, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + const part25 = fronts$adaptors_iter_Fuse_slice_Iter_u8(rs.iterFuse(rs.iterSlice(rs.byteSliceView(bytes)), true), rs.usizeAdd(front, 6)); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part25, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + const part26 = fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(rs.iterFuse(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), 2), true), rs.usizeAdd(front, 2)); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part26, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtStepBy(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0])])); + const part27 = fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(rs.iterFuse(rs.iterMapWhile(rs.iterSlice(rs.byteSliceView(bytes)), (_216: rs.u8): rs.u8 | undefined => { + const b12: rs.u8 = _216; + return thenSome$0quywni(rs.u8Rem(b12, 4) !== 0, b12); + })), rs.usizeMul(front, 2)); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part27, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "MapWhile", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args68[0]])); + const step: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); + const part28 = ends$adaptors_iter_StepBy_slice_Iter_u8(rs.iterStepBy(rs.iterSlice(rs.byteSliceView(bytes)), step), front, back); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part28, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + const _630: [rs.u8, rs.u8] = [rs.u8Rem(at(4), 16), at(5)]; + const lo: rs.u8 = _630[0]; + const hi: rs.u8 = _630[1]; + const part29 = ends$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(lo, hi), step, undefined, 255), front, back); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part29, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + const part30 = fronts$adaptors_iter_StepBy_ops_Range_u32(rs.iterStepBy(new rs.Range(lo as rs.u32, hi as rs.u32), step, undefined, 4294967295), front); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part30, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u32Debug))]; + put(out, rs.fmtFormat([args74[0]])); + const part31 = ends$adaptors_iter_StepBy_ops_Range_usize(rs.iterStepBy(new rs.Range(lo as rs.usize, hi as rs.usize), step, undefined, 4294967295), front, back); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part31, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.usizeDebug))]; + put(out, rs.fmtFormat([args76[0], "|", rs.fmtSpec({ debugHex: "x" }, args76[0])])); + const part32 = ends$adaptors_iter_StepBy_ops_Range_u16(rs.iterStepBy(new rs.Range(lo as rs.u16, hi as rs.u16), step, undefined, 65535), front, back); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part32, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u16Debug))]; + put(out, rs.fmtFormat([args78[0]])); + const part33 = ends$adaptors_iter_StepBy_ops_Range_i32(rs.iterStepBy(new rs.Range(lo as rs.i32, hi as rs.i32), step), front, back); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part33, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.i32Debug))]; + put(out, rs.fmtFormat([args80[0]])); + const part34 = fronts$adaptors_iter_StepBy_ops_Range_u64(rs.iterStepBy(new rs.Range(lo as rs.u64, hi as rs.u64, rs.u64Step), step), front); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part34, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u64Debug))]; + put(out, rs.fmtFormat([args82[0]])); + const part35 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), 300, undefined, 255), front); + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part35, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args84[0]])); + const part36 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(250, 255), rs.usizeAdd(at(3) as rs.usize, 1), undefined, 255), front); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part36, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args86[0]])); + const part37 = fronts$adaptors_iter_StepBy_ops_Range_u8(rs.iterStepBy(new rs.Range(hi, 255), rs.usizeAdd(step, 200), undefined, 255), front); + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStepBy(part37, f, (value: rs.Range, f: rs.Formatter) => rs.fmtRange(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args88[0]])); + const lists: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(bytes, 2), (a0: rs.ByteSlice): rs.ByteVec => { + return rs.byteSliceToByteVec(a0); }), undefined, 12, true); - const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rt.iterFlatten(rt.iterSlice(lists.items), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), front, back); - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlatten(part38, f, "Flatten", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args90[0], "|", rt.fmtSpec({ alternate: true }, args90[0])])); - const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rt.iterFlatMap(rt.iterSlice(lists.items), (v: rt.ByteVec): rt.Iter => { - return rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(v))); + const part38 = ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), front, back); + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part38, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + const part39 = ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(rs.iterFlatMap(rs.iterSlice(lists.items), (v: rs.ByteVec): rs.Iter => { + return rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(v))); }, undefined, true), front, back); - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFlatten(part39, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args92[0], "|", rt.fmtSpec({ alternate: true }, args92[0])])); - const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rt.iterFuse(rt.iterFlatten(rt.iterSlice(lists.items), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true), true), rt.usizeAdd(front, 6)); - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFuse(part40, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "Flatten", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args94[0]])); - const units: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_218: rt.u8): rt.u16 => { - const _517: rt.usize = rt.u8Rem(_218, 5) as rt.usize; + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFlatten(part39, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args92[0], "|", rs.fmtSpec({ alternate: true }, args92[0])])); + const part40 = fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(rs.iterFuse(rs.iterFlatten(rs.iterSlice(lists.items), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true), true), rs.usizeAdd(front, 6)); + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFuse(part40, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "Flatten", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args94[0]])); + const units: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_218: rs.u8): rs.u16 => { + const _517: rs.usize = rs.u8Rem(_218, 5) as rs.usize; if (!(_517 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _517); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _517); } return [97, 55296, 56320, 233, 56319][_517]; }), undefined, 2, true); - const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterSlice(units.items)), front); - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part41, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args96[0], "|", rt.fmtSpec({ alternate: true }, args96[0]), "|", rt.fmtSpec({ debugHex: "x" }, args96[0])])); - const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rt.charDecodeUtf16(rt.vecIntoIter(rt.vecFrom([55296, 97, 98]))), rt.u8Rem(at(2), 3) as rt.usize); - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part42, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["IntoIter"]))]; - put(out, rt.fmtFormat([args98[0]])); - const quoted: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_219: rt.u8): rt.char => { - const _519: rt.usize = rt.u8Rem(_219, 6) as rt.usize; + const part41 = fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterSlice(units.items)), front); + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part41, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args96[0], "|", rs.fmtSpec({ alternate: true }, args96[0]), "|", rs.fmtSpec({ debugHex: "x" }, args96[0])])); + const part42 = fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(rs.charDecodeUtf16(rs.vecIntoIter(rs.vecFrom([55296, 97, 98]))), rs.u8Rem(at(2), 3) as rs.usize); + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part42, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["IntoIter"]))]; + put(out, rs.fmtFormat([args98[0]])); + const quoted: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_219: rs.u8): rs.char => { + const _519: rs.usize = rs.u8Rem(_219, 6) as rs.usize; if (!(_519 < 6)) { - rt.panic("index out of bounds: the len is " + 6 + " but the index is " + _519); + rs.panic("index out of bounds: the len is " + 6 + " but the index is " + _519); } return [97, 34, 10, 769, 233, 39][_519]; })); - const part43 = fronts$adaptors_str_EscapeDebug(rt.strEscapeDebug(quoted), rt.usizeMul(front, 2)); - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part43, f, "EscapeDebug", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeDebug")))]; - put(out, rt.fmtFormat([args100[0], "|", rt.fmtSpec({ alternate: true }, args100[0])])); - const part44 = fronts$adaptors_str_EscapeDefault(rt.strEscapeDefault(quoted), rt.usizeMul(front, 3)); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part44, f, "EscapeDefault", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeDefault")))]; - put(out, rt.fmtFormat([args102[0]])); - const part45 = fronts$adaptors_str_EscapeUnicode(rt.strEscapeUnicode(quoted), rt.usizeMul(front, 5)); - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", rt.fmtChars), (value: rt.Iter, f: rt.Formatter) => rt.fmtCharsDebug(value, f, "EscapeUnicode")))]; - put(out, rt.fmtFormat([args104[0], "|", rt.fmtSpec({ alternate: true }, args104[0])])); - const base: rt.Iter = rt.iterSlice(rt.byteSliceView(bytes)); + const part43 = fronts$adaptors_str_EscapeDebug(rs.strEscapeDebug(quoted), rs.usizeMul(front, 2)); + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part43, f, "EscapeDebug", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDebug")))]; + put(out, rs.fmtFormat([args100[0], "|", rs.fmtSpec({ alternate: true }, args100[0])])); + const part44 = fronts$adaptors_str_EscapeDefault(rs.strEscapeDefault(quoted), rs.usizeMul(front, 3)); + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part44, f, "EscapeDefault", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeDefault")))]; + put(out, rs.fmtFormat([args102[0]])); + const part45 = fronts$adaptors_str_EscapeUnicode(rs.strEscapeUnicode(quoted), rs.usizeMul(front, 5)); + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part45, f, "EscapeUnicode", "inner", (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", rs.fmtChars), (value: rs.Iter, f: rs.Formatter) => rs.fmtCharsDebug(value, f, "EscapeUnicode")))]; + put(out, rs.fmtFormat([args104[0], "|", rs.fmtSpec({ alternate: true }, args104[0])])); + const base: rs.Iter = rs.iterSlice(rs.byteSliceView(bytes)); base.next(); - const part46 = rt.iterSkip(rt.iterMap(rt.iterBorrow(base), (b15: rt.u8): rt.u8 => { - return rt.u8Add(b15, 1); + const part46 = rs.iterSkip(rs.iterMap(rs.iterBorrow(base), (b15: rs.u8): rs.u8 => { + return rs.u8Add(b15, 1); }), 1); - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part46, f, "Skip", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args106[0], "|", rt.fmtSpec({ alternate: true }, args106[0])])); - const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rt.charDecodeUtf16(rt.iterBorrow(rt.iterSlice(units.items))), front); - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtDecodeUtf16(part47, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u16Debug, ["Iter"])))]; - put(out, rt.fmtFormat([args108[0]])); - const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rt.iterBorrow(rt.iterSlice(rt.byteSliceView(bytes))), front); - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAround(part48, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args110[0], "|", rt.fmtSpec({ alternate: true }, args110[0])])); - const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rt.iterMap(rt.iterBox(rt.iterSlice(rt.byteSliceView(bytes))), (b16: rt.u8): rt.u8 => { - return rt.u8Add(b16, 1); + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part46, f, "Skip", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args106[0], "|", rs.fmtSpec({ alternate: true }, args106[0])])); + const part47 = fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(rs.charDecodeUtf16(rs.iterBorrow(rs.iterSlice(units.items))), front); + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtDecodeUtf16(part47, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u16Debug, ["Iter"])))]; + put(out, rs.fmtFormat([args108[0]])); + const part48 = fronts$adaptors_iter_Copied_mut_slice_Iter_u8(rs.iterBorrow(rs.iterSlice(rs.byteSliceView(bytes))), front); + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAround(part48, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[0])])); + const part49 = fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(rs.iterMap(rs.iterBox(rs.iterSlice(rs.byteSliceView(bytes))), (b16: rs.u8): rs.u8 => { + return rs.u8Add(b16, 1); }), front); - const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part49, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))]; - put(out, rt.fmtFormat([args112[0]])); - const boxed: rt.Iter = rt.iterRev(rt.iterSlice(rt.byteSliceView(bytes))); + const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part49, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))]; + put(out, rs.fmtFormat([args112[0]])); + const boxed: rs.Iter = rs.iterRev(rs.iterSlice(rs.byteSliceView(bytes))); const _1027: Countdown.Countdown = { _0: 4 }; - const part50 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rt.iterZip(rt.iterBorrow(rt.iterBox(rt.iterBorrow(boxed))), rt.iterBox(rt.iterFrom(_1027, Countdown.next$iter_Iterator))), front); - const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtZip(part50, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args114[0]])); - const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(rt.iterEnumerate(rt.iterMap(rt.iterFrom({ _0: rt.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rt.u8): rt.u8 => { - return rt.u8Mul(n, 2); + const part50 = fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(rs.iterZip(rs.iterBorrow(rs.iterBox(rs.iterBorrow(boxed))), rs.iterBox(rs.iterFrom(_1027, Countdown.next$iter_Iterator))), front); + const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtZip(part50, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args114[0]])); + const part51 = fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(rs.iterEnumerate(rs.iterMap(rs.iterFrom({ _0: rs.u8Rem(at(2), 5) }, Countdown.next$iter_Iterator), (n: rs.u8): rs.u8 => { + return rs.u8Mul(n, 2); })), front); - const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEnumerate(part51, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; - put(out, rt.fmtFormat([args116[0], "|", rt.fmtSpec({ alternate: true }, args116[0])])); - if (!(rt.u8Rem(at(3), 2) === 0)) { + const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEnumerate(part51, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)))]; + put(out, rs.fmtFormat([args116[0], "|", rs.fmtSpec({ alternate: true }, args116[0])])); + if (!(rs.u8Rem(at(3), 2) === 0)) { toggle = "Done" as Toggle.Toggle; } else { toggle = "Ready" as Toggle.Toggle; } - const part52 = rt.iterMap(rt.iterFrom(rt.place(() => toggle, (value2) => toggle = value2), Toggle.next$iter_Iterator), (x: rt.u8): rt.u8 => { + const part52 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value2) => toggle = value2), Toggle.next$iter_Iterator), (x: rs.u8): rs.u8 => { return x; }); - const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part52, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rt.fmtFormat([args118[0], "|", rt.fmtSpec({ alternate: true }, args118[0])])); - const part53 = rt.iterMap(rt.iterFrom(rt.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rt.u8): rt.u8 => { + const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part52, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args118[0], "|", rs.fmtSpec({ alternate: true }, args118[0])])); + const part53 = rs.iterMap(rs.iterFrom(rs.place(() => toggle, (value3) => toggle = value3), Toggle.next$iter_Iterator), (x2: rs.u8): rs.u8 => { return x2; }); - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part53, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rt.fmtFormat([args120[0]])); + const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part53, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args120[0]])); let boxed2: Toggle.Toggle = toggle; - const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterFrom(rt.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rt.u8): rt.u8 => { + const part54 = fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value5) => boxed2 = value5), Toggle.next$iter_Iterator))), (x3: rs.u8): rs.u8 => { return x3; }), front); - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part54, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rt.fmtFormat([args122[0], "|", rt.fmtSpec({ alternate: true }, args122[0])])); - const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rt.iterMap(rt.iterBox(rt.iterBorrow(rt.iterBox(rt.iterFrom(rt.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rt.u8): rt.u8 => { + const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part54, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args122[0], "|", rs.fmtSpec({ alternate: true }, args122[0])])); + const part55 = fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(rs.iterMap(rs.iterBox(rs.iterBorrow(rs.iterBox(rs.iterFrom(rs.place(() => boxed2, (value6) => boxed2 = value6), Toggle.next$iter_Iterator)))), (x4: rs.u8): rs.u8 => { return x4; }), front); - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part55, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rt.fmtFormat([args124[0]])); - const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rt.iterMap(rt.iterBox(rt.iterFrom(rt.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rt.u8): rt.u8 => { + const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part55, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args124[0]])); + const part56 = fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(rs.iterMap(rs.iterBox(rs.iterFrom(rs.place(() => toggle, (value7) => toggle = value7), Toggle.next$iter_Iterator)), (x5: rs.u8): rs.u8 => { return x5; }), front); - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part56, f, "Map", (value: rt.Place, f: rt.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; - put(out, rt.fmtFormat([args126[0]])); - let nested: Countdown.Countdown = { _0: rt.u8Rem(at(4), 5) }; - const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rt.iterMap(rt.iterBorrow(rt.iterBox(rt.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rt.u8): rt.u8 => { + const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part56, f, "Map", (value: rs.Place, f: rs.Formatter) => Toggle.fmt$fmt_Debug(value.v, f))]; + put(out, rs.fmtFormat([args126[0]])); + let nested: Countdown.Countdown = { _0: rs.u8Rem(at(4), 5) }; + const part57 = fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(rs.iterMap(rs.iterBorrow(rs.iterBox(rs.iterFrom(nested, Countdown.next$iter_Iterator))), (n2: rs.u8): rs.u8 => { return n2; }), front); - const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args128[0]])); - const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rt.iterMap(rt.iterBox(rt.iterFrom({ _0: rt.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rt.u8): rt.u8 => { + const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part57, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args128[0]])); + const part58 = fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(rs.iterMap(rs.iterBox(rs.iterFrom({ _0: rs.u8Rem(at(5), 5) }, Countdown.next$iter_Iterator)), (n3: rs.u8): rs.u8 => { return n3; }), front); - const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args130[0]])); - const own: Countdown.Countdown = { _0: rt.u8Rem(at(3), 5) }; - const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rt.iterPeekable(rt.iterFrom(own, Countdown.next$iter_Iterator)), front); - const args132: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f), rt.u8Debug)]; - put(out, rt.fmtFormat([args132[0]])); - const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rt.iterChain(rt.iterFlatMap(rt.iterSlice(lists.items), (v2: rt.ByteVec): Countdown.Countdown => { - return { _0: rt.u8Rem(v2.data[rt.idx(v2, 0)], 3) }; - }, (value: Countdown.Countdown) => rt.iterFrom(value, Countdown.next$iter_Iterator), true), rt.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); - const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part60, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtFlatten(value, f, "FlatMap", (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rt.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args134[0]])); - const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rt.iterTake(rt.iterRev(rt.iterSkip(rt.iterEnumerate(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_221: rt.u8): Pair.Pair => { + const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part58, f, "Map", (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args130[0]])); + const own: Countdown.Countdown = { _0: rs.u8Rem(at(3), 5) }; + const part59 = fronts$adaptors_iter_Peekable_mut_fmt_Countdown(rs.iterPeekable(rs.iterFrom(own, Countdown.next$iter_Iterator)), front); + const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPeekable(part59, f, (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f), rs.u8Debug)]; + put(out, rs.fmtFormat([args132[0]])); + const part60 = fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(rs.iterChain(rs.iterFlatMap(rs.iterSlice(lists.items), (v2: rs.ByteVec): Countdown.Countdown => { + return { _0: rs.u8Rem(v2.data[rs.idx(v2, 0)], 3) }; + }, (value: Countdown.Countdown) => rs.iterFrom(value, Countdown.next$iter_Iterator), true), rs.iterFrom({ _0: 2 }, Countdown.next$iter_Iterator)), front); + const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part60, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtFlatten(value, f, "FlatMap", (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug), ["Iter"])), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f)), (value: Countdown.Countdown, f: rs.Formatter) => Countdown.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args134[0]])); + const part61 = ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(rs.iterTake(rs.iterRev(rs.iterSkip(rs.iterEnumerate(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_221: rs.u8): Pair.Pair => { return { _0: _221, _1: -1 }; })), 1)), 3), front, back); - const args136: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part61, f, "Take", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Rev", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtCounted(value, f, "Skip", (value: rt.Iter<[rt.usize, Pair.Pair]>, f: rt.Formatter) => rt.fmtEnumerate(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"]))))))]; - put(out, rt.fmtFormat([args136[0], "|", rt.fmtSpec({ alternate: true }, args136[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args136[0])])); - const it63: rt.Peekable = rt.iterPeekable(rt.iterSlice(rt.byteSliceView(bytes))); - rt.peekablePeek(it63); - const part62 = rt.iterChain(rt.iterFilter(rt.iterZip(it63, new rt.RangeFrom(1, rt.u8Step), "len"), (p: [rt.u8, rt.u8]): boolean => { + const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part61, f, "Take", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Rev", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtCounted(value, f, "Skip", (value: rs.Iter<[rs.usize, Pair.Pair]>, f: rs.Formatter) => rs.fmtEnumerate(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"]))))))]; + put(out, rs.fmtFormat([args136[0], "|", rs.fmtSpec({ alternate: true }, args136[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args136[0])])); + const it63: rs.Peekable = rs.iterPeekable(rs.iterSlice(rs.byteSliceView(bytes))); + rs.peekablePeek(it63); + const part62 = rs.iterChain(rs.iterFilter(rs.iterZip(it63, new rs.RangeFrom(1, rs.u8Step), "len"), (p: [rs.u8, rs.u8]): boolean => { return p[0] !== 0; - }), rt.vecIntoIter(rt.vecFrom(copy$array_tuple2_u8_u8([[9, 9] as [rt.u8, rt.u8]]).map(copy$tuple2_u8_u8)))); - const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtChain(part62, f, (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtAdaptor(value, f, "Filter", (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtZip(value, f, (value: rt.Peekable, f: rt.Formatter) => rt.fmtPeekable(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtAround(value, f, "Copied", "it", (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["Iter"])), rt.u8Debug), (value: rt.RangeFrom, f: rt.Formatter) => rt.fmtRangeFrom(value, f, rt.u8Debug))), (value: rt.Iter<[rt.u8, rt.u8]>, f: rt.Formatter) => rt.fmtIter(value, f, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f), ["IntoIter"]))]; - put(out, rt.fmtFormat([args138[0], "|", rt.fmtSpec({ alternate: true }, args138[0])])); + }), rs.vecIntoIter(rs.vecFrom(copy$array_tuple2_u8_u8([[9, 9] as [rs.u8, rs.u8]]).map(copy$tuple2_u8_u8)))); + const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtChain(part62, f, (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtAdaptor(value, f, "Filter", (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtZip(value, f, (value: rs.Peekable, f: rs.Formatter) => rs.fmtPeekable(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtAround(value, f, "Copied", "it", (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["Iter"])), rs.u8Debug), (value: rs.RangeFrom, f: rs.Formatter) => rs.fmtRangeFrom(value, f, rs.u8Debug))), (value: rs.Iter<[rs.u8, rs.u8]>, f: rs.Formatter) => rs.fmtIter(value, f, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f), ["IntoIter"]))]; + put(out, rs.fmtFormat([args138[0], "|", rs.fmtSpec({ alternate: true }, args138[0])])); } -export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Chain_slice_Iter_u8_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Cloned_slice_Iter_String(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Cloned_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Cloned_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Copied_slice_Iter_array2_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Copied_slice_Iter_array2_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Copied_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Copied_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Enumerate_slice_Iter_u8(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Enumerate_slice_Iter_u8(it: rs.Iter<[rs.usize, rs.u8]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_FilterMap_slice_Iter_u8_fmt_adaptors_closure3(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Filter_slice_Iter_u8_fmt_adaptors_closure2(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_FlatMap_slice_Iter_Vec_u8_slice_Iter_u8_fmt_adaptors_closure15(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Flatten_slice_Iter_Vec_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Inspect_slice_Iter_u8_fmt_adaptors_closure4(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Map_slice_Iter_u8_fmt_adaptors_closure1(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Peekable_slice_Iter_u8(it: rt.Peekable, front: rt.usize, back: rt.usize): rt.Peekable { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Peekable_slice_Iter_u8(it: rs.Peekable, front: rs.usize, back: rs.usize): rs.Peekable { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Rev_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Rev_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_StepBy_ops_Range_i32(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_StepBy_ops_Range_i32(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_StepBy_ops_Range_u16(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_StepBy_ops_Range_u16(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_StepBy_ops_Range_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_StepBy_ops_Range_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_StepBy_ops_Range_usize(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_StepBy_ops_Range_usize(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_StepBy_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(it: rt.Iter<[rt.usize, Pair.Pair]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, Pair.Pair]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Take_iter_Rev_iter_Skip_iter_Enumerate_iter_Map_slice_Iter_u8_fmt_adaptors_closure29(it: rs.Iter<[rs.usize, Pair.Pair]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, Pair.Pair]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Take_slice_Iter_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Take_slice_Iter_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Map_slice_Iter_u8_fmt_adaptors_closure12(it: rs.Iter<[rs.u8, rs.u8]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.u8, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$adaptors_iter_Zip_slice_Iter_u8_iter_Rev_slice_Iter_u8(it: rs.Iter<[rs.u8, rs.u8]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.u8, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_char_DecodeUtf16_iter_Copied_slice_Iter_u16(it: rs.Iter>, front: rs.usize): rs.Iter> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_char_DecodeUtf16_mut_iter_Copied_slice_Iter_u16(it: rs.Iter>, front: rs.usize): rs.Iter> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rt.Iter>, front: rt.usize): rt.Iter> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_char_DecodeUtf16_vec_IntoIter_u16(it: rs.Iter>, front: rs.usize): rs.Iter> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Chain_iter_FlatMap_slice_Iter_Vec_u8_fmt_Countdown_fmt_adaptors_closure28_fmt_Countdown(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Copied_mut_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Copied_mut_slice_Iter_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Cycle_slice_Iter_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(it: rt.Iter<[rt.usize, rt.u8]>, front: rt.usize): rt.Iter<[rt.usize, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Enumerate_iter_Map_fmt_Countdown_fmt_adaptors_closure20(it: rs.Iter<[rs.usize, rs.u8]>, front: rs.usize): rs.Iter<[rs.usize, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Fuse_iter_Flatten_slice_Iter_Vec_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Fuse_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure14(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Fuse_iter_StepBy_slice_Iter_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Fuse_slice_Iter_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Fuse_slice_Iter_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_MapWhile_slice_Iter_u8_fmt_adaptors_closure5(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure27(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_boxed_Box_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure24(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_boxed_Box_mut_fmt_Toggle_fmt_adaptors_closure25(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_boxed_Box_slice_Iter_u8_fmt_adaptors_closure19(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_mut_boxed_Box_fmt_Toggle_fmt_adaptors_closure23(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Map_mut_mut_boxed_Box_boxed_Box_fmt_Countdown_fmt_adaptors_closure26(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Peekable_mut_fmt_Countdown(it: rt.Peekable, front: rt.usize): rt.Peekable { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Peekable_mut_fmt_Countdown(it: rs.Peekable, front: rs.usize): rs.Peekable { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Scan_slice_Iter_u8_String_fmt_adaptors_closure11(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Scan_slice_Iter_u8_u32_fmt_adaptors_closure10(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_StepBy_ops_Range_u32(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_StepBy_ops_Range_u32(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_StepBy_ops_Range_u64(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_StepBy_ops_Range_u64(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_StepBy_ops_Range_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_StepBy_ops_Range_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(it: rt.Iter<[rt.u8, rt.u8]>, front: rt.usize): rt.Iter<[rt.u8, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Zip_mut_boxed_Box_iter_Rev_slice_Iter_u8_boxed_Box_fmt_Countdown(it: rs.Iter<[rs.u8, rs.u8]>, front: rs.usize): rs.Iter<[rs.u8, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(it: rt.Iter<[rt.char, rt.u8]>, front: rt.usize): rt.Iter<[rt.char, rt.u8]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_iter_Zip_str_Chars_slice_Iter_u8(it: rs.Iter<[rs.char, rs.u8]>, front: rs.usize): rs.Iter<[rs.char, rs.u8]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_str_EscapeDebug(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_str_EscapeDebug(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_str_EscapeDefault(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_str_EscapeDefault(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$adaptors_str_EscapeUnicode(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$adaptors_str_EscapeUnicode(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } @@ -2876,52 +2876,52 @@ export function fronts$adaptors_str_EscapeUnicode(it: rt.Iter, front: r * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_String(w: rt.Place, c: rt.char): rt.Result { +export function literals$mut_String(w: rs.Place, c: rs.char): rs.Result { w.v = w.v + "ab"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + String.fromCodePoint(c); - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + "cxd"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + "😀"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + "\n"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + "{}"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v = w.v + "end\n"; - return rt.OK; + return rs.OK; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_fmt_Capped(w: Capped.Capped, c: rt.char): rt.Result { +export function literals$mut_fmt_Capped(w: Capped.Capped, c: rs.char): rs.Result { if (Capped.writeStr$fmt_Write(w, "ab").ok) { if (Capped.writeStr$fmt_Write(w, "").ok) { if (Capped.writeStr$fmt_Write(w, "").ok) { @@ -2933,65 +2933,65 @@ export function literals$mut_fmt_Capped(w: Capped.Capped, c: rt.char): rt.Result if (Capped.writeStr$fmt_Write(w, "").ok) { return Capped.writeStr$fmt_Write(w, "end\n"); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_fmt_Formatter(w: rt.Formatter, c: rt.char): rt.Result { - if (rt.fmtWriteStr(w, "ab").ok) { - if (rt.fmtWriteStr(w, "").ok) { - if (rt.fmtWriteStr(w, "").ok) { - if (rt.fmtWriteChar(w, c).ok) { - if (rt.fmtWriteStr(w, "cxd").ok) { - if (rt.fmtWriteChar(w, 128512).ok) { - if (rt.fmtWriteStr(w, "\n").ok) { - if (rt.fmtWriteStr(w, "{}").ok) { - if (rt.fmtWriteStr(w, "").ok) { - return rt.fmtWriteStr(w, "end\n"); +export function literals$mut_fmt_Formatter(w: rs.Formatter, c: rs.char): rs.Result { + if (rs.fmtWriteStr(w, "ab").ok) { + if (rs.fmtWriteStr(w, "").ok) { + if (rs.fmtWriteStr(w, "").ok) { + if (rs.fmtWriteChar(w, c).ok) { + if (rs.fmtWriteStr(w, "cxd").ok) { + if (rs.fmtWriteChar(w, 128512).ok) { + if (rs.fmtWriteStr(w, "\n").ok) { + if (rs.fmtWriteStr(w, "{}").ok) { + if (rs.fmtWriteStr(w, "").ok) { + return rs.fmtWriteStr(w, "end\n"); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_fmt_Twice(w: Twice.Twice, c: rt.char): rt.Result { +export function literals$mut_fmt_Twice(w: Twice.Twice, c: rs.char): rs.Result { if (Twice.writeStr$fmt_Write(w, "ab").ok) { if (Twice.writeStr$fmt_Write(w, "").ok) { if (Twice.writeStr$fmt_Write(w, "").ok) { @@ -3003,75 +3003,75 @@ export function literals$mut_fmt_Twice(w: Twice.Twice, c: rt.char): rt.Result>, c: rt.char): rt.Result { +export function literals$mut_mut_String(w: rs.Place>, c: rs.char): rs.Result { w.v.v = w.v.v + "ab"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + String.fromCodePoint(c); - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + "cxd"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + "😀"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + "\n"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + "{}"; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + ""; - if (rt.OK.ok) { + if (rs.OK.ok) { w.v.v = w.v.v + "end\n"; - return rt.OK; + return rs.OK; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** * Literals, a `char` of each width, and empty pieces, each its own call, stopping at the * first error. */ -export function literals$mut_mut_fmt_Capped(w: rt.Place, c: rt.char): rt.Result { +export function literals$mut_mut_fmt_Capped(w: rs.Place, c: rs.char): rs.Result { if (Capped.writeStr$fmt_Write(w.v, "ab").ok) { if (Capped.writeStr$fmt_Write(w.v, "").ok) { if (Capped.writeStr$fmt_Write(w.v, "").ok) { @@ -3083,141 +3083,141 @@ export function literals$mut_mut_fmt_Capped(w: rt.Place, c: rt.ch if (Capped.writeStr$fmt_Write(w.v, "").ok) { return Capped.writeStr$fmt_Write(w.v, "end\n"); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** Placeholders with options, through a writer std's impl forwards to. */ -export function placed$mut_String(w: rt.Place, n: rt.u8): rt.Result { +export function placed$mut_String(w: rs.Place, n: rs.u8): rs.Result { const _8: string = "q\"é"; - const _9: rt.char = 223; - const _11: rt.i16 = rt.i16Sub(n as rt.i16, 100); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8LowerHex(n, f), (f: rt.Formatter) => rt.fmtStr(_8, f), (f: rt.Formatter) => rt.fmtCharDisplay(_9, f), (f: rt.Formatter) => rt.i16Display(_11, f)]; - const written = rt.fmtWriteString(w.v, ["n=", rt.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rt.fmtSpec({ plus: true }, args2[4])]); + const _9: rs.char = 223; + const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + const written = rs.fmtWriteString(w.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); w.v = written.s; if (written.result.ok) { w.v = w.v + "é"; - if (rt.OK.ok) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Binary(n, f)]; - const written2 = rt.fmtWriteString(w.v, [rt.fmtSpec({ alternate: true }, args4[0]), "\n"]); + if (rs.OK.ok) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + const written2 = rs.fmtWriteString(w.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); w.v = written2.s; return written2.result; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** Placeholders with options, through a writer std's impl forwards to. */ -export function placed$mut_fmt_Formatter(w: rt.Formatter, n: rt.u8): rt.Result { +export function placed$mut_fmt_Formatter(w: rs.Formatter, n: rs.u8): rs.Result { const _8: string = "q\"é"; - const _9: rt.char = 223; - const _11: rt.i16 = rt.i16Sub(n as rt.i16, 100); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8LowerHex(n, f), (f: rt.Formatter) => rt.fmtStr(_8, f), (f: rt.Formatter) => rt.fmtCharDisplay(_9, f), (f: rt.Formatter) => rt.i16Display(_11, f)]; - if (rt.fmtWriteFmt(w, ["n=", rt.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rt.fmtSpec({ plus: true }, args2[4])]).ok) { - if (rt.fmtWriteChar(w, 233).ok) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Binary(n, f)]; - return rt.fmtWriteFmt(w, [rt.fmtSpec({ alternate: true }, args4[0]), "\n"]); + const _9: rs.char = 223; + const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + if (rs.fmtWriteFmt(w, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]).ok) { + if (rs.fmtWriteChar(w, 233).ok) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + return rs.fmtWriteFmt(w, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** Placeholders with options, through a writer std's impl forwards to. */ -export function placed$mut_mut_mut_String(w: rt.Place>>, n: rt.u8): rt.Result { +export function placed$mut_mut_mut_String(w: rs.Place>>, n: rs.u8): rs.Result { const _8: string = "q\"é"; - const _9: rt.char = 223; - const _11: rt.i16 = rt.i16Sub(n as rt.i16, 100); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(n, f), (f: rt.Formatter) => rt.u8LowerHex(n, f), (f: rt.Formatter) => rt.fmtStr(_8, f), (f: rt.Formatter) => rt.fmtCharDisplay(_9, f), (f: rt.Formatter) => rt.i16Display(_11, f)]; - const written = rt.fmtWriteString(w.v.v.v, ["n=", rt.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rt.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rt.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rt.fmtSpec({ plus: true }, args2[4])]); + const _9: rs.char = 223; + const _11: rs.i16 = rs.i16Sub(n as rs.i16, 100); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(n, f), (f: rs.Formatter) => rs.u8LowerHex(n, f), (f: rs.Formatter) => rs.fmtStr(_8, f), (f: rs.Formatter) => rs.fmtCharDisplay(_9, f), (f: rs.Formatter) => rs.i16Display(_11, f)]; + const written = rs.fmtWriteString(w.v.v.v, ["n=", rs.fmtSpec({ zero: true, width: 3 }, args2[0]), "|", rs.fmtSpec({ align: ">", width: 4 }, args2[1]), "|", args2[2], "|", rs.fmtSpec({ align: "<", width: 3 }, args2[3]), "|", rs.fmtSpec({ plus: true }, args2[4])]); w.v.v.v = written.s; if (written.result.ok) { w.v.v.v = w.v.v.v + "é"; - if (rt.OK.ok) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Binary(n, f)]; - const written2 = rt.fmtWriteString(w.v.v.v, [rt.fmtSpec({ alternate: true }, args4[0]), "\n"]); + if (rs.OK.ok) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Binary(n, f)]; + const written2 = rs.fmtWriteString(w.v.v.v, [rs.fmtSpec({ alternate: true }, args4[0]), "\n"]); w.v.v.v = written2.s; return written2.result; } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } - return rt.Err(new rt.FmtError()); + return rs.Err(new rs.FmtError()); } /** Each result as a byte: 1 for `Ok`. */ -export function result(out: rt.ByteVec, r: rt.Result): void { - rt.byteVecPush(out, r.ok ? 1 : 0); +export function result(out: rs.ByteVec, r: rs.Result): void { + rs.byteVecPush(out, r.ok ? 1 : 0); } /** * `fmt::Write` for a `String`, through `&mut W`, and for the crate's own writers, which see * each call std makes. */ -export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const c: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(rt.u32Mul(at(0) as rt.u32, 257)), 63); + const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(at(0) as rs.u32, 257)), 63); let s: string = ""; - const _19: rt.u8 = at(1); - const _25: rt.u8 = at(2); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_19, f), (f: rt.Formatter) => rt.fmtCharDisplay(c, f), (f: rt.Formatter) => rt.fmtStr("q\"é", f), (f: rt.Formatter) => rt.u8LowerHex(_25, f)]; - const written = rt.fmtWriteString(s, ["a", args2[0], "b", rt.fmtSpec({ align: ">", width: 5 }, args2[1]), "|", args2[2], "|", args2[3]]); + const _19: rs.u8 = at(1); + const _25: rs.u8 = at(2); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_19, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"é", f), (f: rs.Formatter) => rs.u8LowerHex(_25, f)]; + const written = rs.fmtWriteString(s, ["a", args2[0], "b", rs.fmtSpec({ align: ">", width: 5 }, args2[1]), "|", args2[2], "|", args2[3]]); s = written.s; result(out, written.result); s = s + "\n"; - result(out, rt.OK); + result(out, rs.OK); s = s + String.fromCodePoint(c); - result(out, rt.OK); + result(out, rs.OK); s = s + "tail"; - result(out, rt.OK); + result(out, rs.OK); const _52: Fails.Fails = { _0: at(3) }; - const _57: rt.u8 = at(4); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rt.Formatter) => rt.u8Display(_57, f)]; - const written2 = rt.fmtWriteString(s, ["x", args4[0], "y", args4[1]]); + const _57: rs.u8 = at(4); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Fails.fmt$fmt_Display(_52, f), (f: rs.Formatter) => rs.u8Display(_57, f)]; + const written2 = rs.fmtWriteString(s, ["x", args4[0], "y", args4[1]]); s = written2.s; result(out, written2.result); - result(out, literals$mut_String(rt.place(() => s, (value) => s = value), c)); - const _71: rt.u8 = at(5); - result(out, placed$mut_String(rt.place(() => s, (value2) => s = value2), _71)); - let inner: rt.Place = rt.place(() => s, (value3) => s = value3); - result(out, literals$mut_mut_String(rt.place(() => inner, (value4) => inner = value4), 223)); - let _81: rt.Place> = rt.place(() => inner, (value5) => inner = value5); - const _82: rt.u8 = at(6); - result(out, placed$mut_mut_mut_String(rt.place(() => _81, (value6) => _81 = value6), _82)); + result(out, literals$mut_String(rs.place(() => s, (value) => s = value), c)); + const _71: rs.u8 = at(5); + result(out, placed$mut_String(rs.place(() => s, (value2) => s = value2), _71)); + let inner: rs.Place = rs.place(() => s, (value3) => s = value3); + result(out, literals$mut_mut_String(rs.place(() => inner, (value4) => inner = value4), 223)); + let _81: rs.Place> = rs.place(() => inner, (value5) => inner = value5); + const _82: rs.u8 = at(6); + result(out, placed$mut_mut_mut_String(rs.place(() => _81, (value6) => _81 = value6), _82)); put(out, s); const _96: Placed.Placed = { _0: at(7) }; const _101: Placed.Placed = { _0: at(8) }; - const args6: rt.Fmt[] = [(f: rt.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rt.Formatter) => Placed.fmt$fmt_Display(_101, f)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ align: ">", width: 30 }, args6[1])])); - const capped: Capped.Capped = { text: "", calls: 0, cap: rt.u8Rem(at(9), 40) as rt.usize }; + const args6: rs.Fmt[] = [(f: rs.Formatter) => Placed.fmt$fmt_Display(_96, f), (f: rs.Formatter) => Placed.fmt$fmt_Display(_101, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ align: ">", width: 30 }, args6[1])])); + const capped: Capped.Capped = { text: "", calls: 0, cap: rs.u8Rem(at(9), 40) as rs.usize }; result(out, literals$mut_fmt_Capped(capped, c)); result(out, Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c))); result(out, Capped.writeStr$fmt_Write(capped, "z")); - const _134: rt.u8 = at(10); - const _138: rt.i16 = rt.i16Neg(at(11) as rt.i16); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(_134, f), (f: rt.Formatter) => rt.i16Display(_138, f), (f: rt.Formatter) => rt.fmtCharDisplay(c, f), (f: rt.Formatter) => rt.fmtStr("q\"b", f)]; - const _131: rt.Arguments = [rt.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", args8[1], "|", rt.fmtSpec({ align: "^", width: 5 }, args8[2]), "|", args8[3]]; - result(out, rt.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), _131)); + const _134: rs.u8 = at(10); + const _138: rs.i16 = rs.i16Neg(at(11) as rs.i16); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(_134, f), (f: rs.Formatter) => rs.i16Display(_138, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtStr("q\"b", f)]; + const _131: rs.Arguments = [rs.fmtSpec({ align: ">", width: 4 }, args8[0]), "|", args8[1], "|", rs.fmtSpec({ align: "^", width: 5 }, args8[2]), "|", args8[3]]; + result(out, rs.fmtWrite((s2) => Capped.writeStr$fmt_Write(capped, s2), (c2) => Capped.writeStr$fmt_Write(capped, String.fromCodePoint(c2)), _131)); let _156: Capped.Capped = capped; - result(out, literals$mut_mut_fmt_Capped(rt.place(() => _156, (value7) => _156 = value7), 233)); - rt.byteVecPush(out, capped.calls); + result(out, literals$mut_mut_fmt_Capped(rs.place(() => _156, (value7) => _156 = value7), 233)); + rs.byteVecPush(out, capped.calls); put(out, capped.text); const twice: Twice.Twice = { _0: "" }; result(out, literals$mut_fmt_Twice(twice, c)); @@ -3227,156 +3227,156 @@ export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** Placeholders into writers named as the translation's own callback parameters might be. */ -export function named(out: rt.ByteVec, first: rt.u8, second: rt.u8): void { +export function named(out: rs.ByteVec, first: rs.u8, second: rs.u8): void { const s: Twice.Twice = { _0: "" }; const c: Capped.Capped = { text: "", calls: 0, cap: 64 }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(first, f), (f: rt.Formatter) => rt.fmtCharDisplay(120, f)]; - const _11: rt.Arguments = [args2[0], rt.fmtSpec({ align: ">", width: 3 }, args2[1])]; - result(out, rt.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), _11)); - const _28: rt.Fmt = (f: rt.Formatter) => rt.u8Display(second, f); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(first, f), (f: rs.Formatter) => rs.fmtCharDisplay(120, f)]; + const _11: rs.Arguments = [args2[0], rs.fmtSpec({ align: ">", width: 3 }, args2[1])]; + result(out, rs.fmtWrite((s2) => Twice.writeStr$fmt_Write(s, s2), (c2) => Twice.writeChar$fmt_Write(s, c2), _11)); + const _28: rs.Fmt = (f: rs.Formatter) => rs.u8Display(second, f); const arg = s._0; - const args4: rt.Fmt[] = [_28, (f: rt.Formatter) => rt.fmtPad(f, arg)]; - const _23: rt.Arguments = [rt.fmtSpec({ align: "<", width: 3 }, args4[0]), args4[1]]; - result(out, rt.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), _23)); + const args4: rs.Fmt[] = [_28, (f: rs.Formatter) => rs.fmtPad(f, arg)]; + const _23: rs.Arguments = [rs.fmtSpec({ align: "<", width: 3 }, args4[0]), args4[1]]; + result(out, rs.fmtWrite((s3) => Capped.writeStr$fmt_Write(c, s3), (c3) => Capped.writeStr$fmt_Write(c, String.fromCodePoint(c3)), _23)); put(out, s._0); put(out, c.text); - rt.byteVecPush(out, c.calls); + rs.byteVecPush(out, c.calls); } -export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { +export function objects(data: rs.ByteSlice, out: rs.ByteVec): void { let _372: boolean = false; - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const dropper: (a0: rt.u8) => Dropper.Dropper = (tag: rt.u8): Dropper.Dropper => { - return new Dropper.Dropper(tag, rt.arcClone(log)); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const dropper: (a0: rs.u8) => Dropper.Dropper = (tag: rs.u8): Dropper.Dropper => { + return new Dropper.Dropper(tag, rs.arcClone(log)); }; - const dropped: (a0: rt.ByteVec) => undefined = (out2: rt.ByteVec): undefined => { - const _6: rt.RefCell = rt.refCellBorrowMut(log.value); + const dropped: (a0: rs.ByteVec) => undefined = (out2: rs.ByteVec): undefined => { + const _6: rs.RefCell = rs.refCellBorrowMut(log.value); const taken = _6.value; - _6.value = new rt.ByteVec(); - const tags: rt.ByteVec = taken; - rt.refMutRelease(_6); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteVecView(tags), f, rt.u8Debug)]; - put(out2, rt.fmtFormat([args32[0], " "])); + _6.value = new rs.ByteVec(); + const tags: rs.ByteVec = taken; + rs.refMutRelease(_6); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteVecView(tags), f, rs.u8Debug)]; + put(out2, rs.fmtFormat([args32[0], " "])); }; - const shown: rt.Vec = new rt.Vec(); - const written: rt.Vec = new rt.Vec(); - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const shown: rs.Vec = new rs.Vec(); + const written: rs.Vec = new rs.Vec(); + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _17: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_17 === rt.DONE) { + const _17: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_17 === rs.DONE) { break; } - const i: rt.usize = _17[0]; - const x: rt.u8 = _17[1]; - const _22: rt.u8 = rt.u8Rem(x, 4); + const i: rs.usize = _17[0]; + const x: rs.u8 = _17[1]; + const _22: rs.u8 = rs.u8Rem(x, 4); if (_22 === 0) { - const _25: rt.Fmt = rt.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rt.Formatter) => Dropper.fmt$fmt_Debug(value, f), rt.drop); + const _25: rs.Fmt = rs.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop); shown.items.push(_25); } else if (_22 === 1) { - const _31: rt.Fmt = rt.fmtOwned([x, i] as [rt.u8, rt.usize], (value: [rt.u8, rt.usize], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.usizeDebug(value[1], f)], f)); + const _31: rs.Fmt = rs.fmtOwned([x, i] as [rs.u8, rs.usize], (value: [rs.u8, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f)); shown.items.push(_31); } else if (_22 === 2) { - const _35: rt.Fmt = rt.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rt.Formatter) => Dropper.fmt$fmt_Display(value, f), rt.drop); + const _35: rs.Fmt = rs.fmtOwned(dropper(x), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop); written.items.push(_35); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(x, f)]; - const _41: rt.Fmt = rt.fmtOwned(rt.fmtFormat(["s", args2[0]]), (value: string, f: rt.Formatter) => rt.fmtPad(f, value)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(x, f)]; + const _41: rs.Fmt = rs.fmtOwned(rs.fmtFormat(["s", args2[0]]), (value: string, f: rs.Formatter) => rs.fmtPad(f, value)); written.items.push(_41); } } for (const _55 of shown.items) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => _55(f)]; - put(out, rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[0]), " "])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => _55(f)]; + put(out, rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " "])); } for (const _74 of written.items) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => _74(f)]; - put(out, rt.fmtFormat([args6[0], " [", rt.fmtSpec({ align: ">", width: 6 }, args6[0]), "] [", rt.fmtSpec({ align: "^", width: 7 }, args6[0]), "] "])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => _74(f)]; + put(out, rs.fmtFormat([args6[0], " [", rs.fmtSpec({ align: ">", width: 6 }, args6[0]), "] [", rs.fmtSpec({ align: "^", width: 7 }, args6[0]), "] "])); } - const up: rt.Fmt = rt.fmtOwned(data.length, rt.usizeDebug); - const args8: rt.Fmt[] = [(f: rt.Formatter) => up(f)]; - put(out, rt.fmtFormat([args8[0], " "])); - rt.dropVec(written); + const up: rs.Fmt = rs.fmtOwned(data.length, rs.usizeDebug); + const args8: rs.Fmt[] = [(f: rs.Formatter) => up(f)]; + put(out, rs.fmtFormat([args8[0], " "])); + rs.dropVec(written); dropped(out); - rt.vecTruncate(shown, 1, rt.drop); + rs.vecTruncate(shown, 1, rs.drop); dropped(out); if (!(data.length >= 2)) { - rt.drop(up); - rt.dropVec(shown); + rs.drop(up); + rs.dropVec(shown); log[Symbol.dispose](); } else { - const b: rt.u8 = data.data[data.start + 1]; - const _121: rt.Arc<[rt.u8, rt.u8]> = new rt.Arc([data.data[data.start], b] as [rt.u8, rt.u8]); - const shared: rt.Arc = new rt.ArcDyn(_121, rt.fmtOwned(_121.value, (value: [rt.u8, rt.u8], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.u8Debug(value[1], f)], f))); - const kept: rt.Arc = rt.arcClone(shared); - const _135: rt.usize = kept.strong; - const args10: rt.Fmt[] = [(f: rt.Formatter) => shared.value(f), (f: rt.Formatter) => rt.usizeDisplay(_135, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " "])); - const counted: rt.Arc = new rt.Arc(dropper(data.data[data.start])); - const _149: rt.Arc = rt.arcClone(counted); - const asDisplay: rt.Arc = new rt.ArcDyn(_149, rt.fmtOwned(_149.value, (value: Dropper.Dropper, f: rt.Formatter) => Dropper.fmt$fmt_Display(value, f), rt.drop)); + const b: rs.u8 = data.data[data.start + 1]; + const _121: rs.Arc<[rs.u8, rs.u8]> = new rs.Arc([data.data[data.start], b] as [rs.u8, rs.u8]); + const shared: rs.Arc = new rs.ArcDyn(_121, rs.fmtOwned(_121.value, (value: [rs.u8, rs.u8], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.u8Debug(value[1], f)], f))); + const kept: rs.Arc = rs.arcClone(shared); + const _135: rs.usize = kept.strong; + const args10: rs.Fmt[] = [(f: rs.Formatter) => shared.value(f), (f: rs.Formatter) => rs.usizeDisplay(_135, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " "])); + const counted: rs.Arc = new rs.Arc(dropper(data.data[data.start])); + const _149: rs.Arc = rs.arcClone(counted); + const asDisplay: rs.Arc = new rs.ArcDyn(_149, rs.fmtOwned(_149.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Display(value, f), rs.drop)); _372 = true; - const asDebug: rt.Arc = new rt.ArcDyn(counted, rt.fmtOwned(counted.value, (value: Dropper.Dropper, f: rt.Formatter) => Dropper.fmt$fmt_Debug(value, f), rt.drop)); - const _160: rt.usize = asDebug.strong; - const args12: rt.Fmt[] = [(f: rt.Formatter) => asDisplay.value(f), (f: rt.Formatter) => rt.usizeDisplay(_160, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ align: "<", width: 5 }, args12[0]), "| ", args12[1], " "])); + const asDebug: rs.Arc = new rs.ArcDyn(counted, rs.fmtOwned(counted.value, (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop)); + const _160: rs.usize = asDebug.strong; + const args12: rs.Fmt[] = [(f: rs.Formatter) => asDisplay.value(f), (f: rs.Formatter) => rs.usizeDisplay(_160, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ align: "<", width: 5 }, args12[0]), "| ", args12[1], " "])); asDisplay[Symbol.dispose](); dropped(out); - if (rt.u8Rem(b, 2) === 0) { + if (rs.u8Rem(b, 2) === 0) { _372 = false; asDebug[Symbol.dispose](); } else { - const args14: rt.Fmt[] = [(f: rt.Formatter) => asDebug.value(f)]; - put(out, rt.fmtFormat([args14[0], " "])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => asDebug.value(f)]; + put(out, rs.fmtFormat([args14[0], " "])); } dropped(out); shared[Symbol.dispose](); - const _198: rt.usize = kept.strong; - const args16: rt.Fmt[] = [(f: rt.Formatter) => kept.value(f), (f: rt.Formatter) => rt.usizeDisplay(_198, f)]; - put(out, rt.fmtFormat([args16[0], " ", args16[1], " "])); - let n: rt.u8 = rt.u8WrappingMul(data.data[data.start], 3); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - let text: string = rt.fmtFormat(["t", args18[0]]); + const _198: rs.usize = kept.strong; + const args16: rs.Fmt[] = [(f: rs.Formatter) => kept.value(f), (f: rs.Formatter) => rs.usizeDisplay(_198, f)]; + put(out, rs.fmtFormat([args16[0], " ", args16[1], " "])); + let n: rs.u8 = rs.u8WrappingMul(data.data[data.start], 3); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + let text: string = rs.fmtFormat(["t", args18[0]]); const owned: Dropper.Dropper = dropper(b); - const part5 = rt.u8WrappingAdd(b, 1); - let boxed: rt.Fmt = rt.fmtOwned(dropper(part5), (value: Dropper.Dropper, f: rt.Formatter) => Dropper.fmt$fmt_Debug(value, f), rt.drop); - const cell: rt.Cell = new rt.Cell(data.data[data.start]); - const pair: [fmt_Gauge.Gauge, rt.u8] = [{ _0: cell }, b]; - const _237: rt.Place = rt.place(() => n, (value) => n = value); - const arg = rt.place(() => text, (value2) => text = value2); - const _238: rt.Fmt = (f: rt.Formatter) => rt.fmtStr(arg.v, f); - const _240: rt.Fmt = (f: rt.Formatter) => Dropper.fmt$fmt_Debug(owned, f); - const arg2 = rt.place(() => boxed, (value3) => boxed = value3); - const objects: rt.Vec = rt.vecFrom([(f: rt.Formatter) => rt.u8Debug(_237.v, f), _238, _240, (f: rt.Formatter) => arg2.v(f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rt.Formatter) => rt.u8Debug(pair[1], f)], f)]); - const iter4: rt.Iter> = rt.iterSliceMut(objects.items); + const part5 = rs.u8WrappingAdd(b, 1); + let boxed: rs.Fmt = rs.fmtOwned(dropper(part5), (value: Dropper.Dropper, f: rs.Formatter) => Dropper.fmt$fmt_Debug(value, f), rs.drop); + const cell: rs.Cell = new rs.Cell(data.data[data.start]); + const pair: [fmt_Gauge.Gauge, rs.u8] = [{ _0: cell }, b]; + const _237: rs.Place = rs.place(() => n, (value) => n = value); + const arg = rs.place(() => text, (value2) => text = value2); + const _238: rs.Fmt = (f: rs.Formatter) => rs.fmtStr(arg.v, f); + const _240: rs.Fmt = (f: rs.Formatter) => Dropper.fmt$fmt_Debug(owned, f); + const arg2 = rs.place(() => boxed, (value3) => boxed = value3); + const objects: rs.Vec = rs.vecFrom([(f: rs.Formatter) => rs.u8Debug(_237.v, f), _238, _240, (f: rs.Formatter) => arg2.v(f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => fmt_Gauge.fmt$fmt_Debug(pair[0], f), (f: rs.Formatter) => rs.u8Debug(pair[1], f)], f)]); + const iter4: rs.Iter> = rs.iterSliceMut(objects.items); while (true) { - const _251: rt.Place | rt.Done = iter4.next(); - if (_251 === rt.DONE) { + const _251: rs.Place | rs.Done = iter4.next(); + if (_251 === rs.DONE) { break; } - const args20: rt.Fmt[] = [(f: rt.Formatter) => _251.v(f)]; - put(out, rt.fmtFormat([args20[0], " ", rt.fmtSpec({ alternate: true }, args20[0]), " "])); - } - const _269: rt.u8 = rt.u8WrappingAdd(cell.v, 1); - rt.cellSet(cell, _269); - const again: rt.Fmt = objects.items[rt.idx(objects.items, 4)]; - const args22: rt.Fmt[] = [(f: rt.Formatter) => again(f)]; - put(out, rt.fmtFormat([args22[0], " "])); - const args24: rt.Fmt[] = [(f: rt.Formatter) => again(f)]; - put(out, rt.fmtFormat([args24[0], " "])); - n = rt.u8WrappingAdd(n, 1); - const _304: rt.Place = rt.place(() => n, (value4) => n = value4); - const part6 = (f: rt.Formatter) => rt.u8Display(_304.v, f); - const args26: rt.Fmt[] = [(f: rt.Formatter) => part6(f)]; - put(out, rt.fmtFormat(["[", rt.fmtSpec({ align: ">", width: 5 }, args26[0]), "] "])); - const part7 = (f: rt.Formatter) => Dropper.fmt$fmt_Display(owned, f); - const args28: rt.Fmt[] = [(f: rt.Formatter) => part7(f)]; - put(out, rt.fmtFormat(["[", rt.fmtSpec({ align: "^", width: 6 }, args28[0]), "] "])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => _251.v(f)]; + put(out, rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " "])); + } + const _269: rs.u8 = rs.u8WrappingAdd(cell.v, 1); + rs.cellSet(cell, _269); + const again: rs.Fmt = objects.items[rs.idx(objects.items, 4)]; + const args22: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; + put(out, rs.fmtFormat([args22[0], " "])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => again(f)]; + put(out, rs.fmtFormat([args24[0], " "])); + n = rs.u8WrappingAdd(n, 1); + const _304: rs.Place = rs.place(() => n, (value4) => n = value4); + const part6 = (f: rs.Formatter) => rs.u8Display(_304.v, f); + const args26: rs.Fmt[] = [(f: rs.Formatter) => part6(f)]; + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: ">", width: 5 }, args26[0]), "] "])); + const part7 = (f: rs.Formatter) => Dropper.fmt$fmt_Display(owned, f); + const args28: rs.Fmt[] = [(f: rs.Formatter) => part7(f)]; + put(out, rs.fmtFormat(["[", rs.fmtSpec({ align: "^", width: 6 }, args28[0]), "] "])); text = text + "!"; - const arg3 = rt.place(() => text, (value5) => text = value5); - const part8 = (f: rt.Formatter) => rt.fmtPad(f, arg3.v); - const args30: rt.Fmt[] = [(f: rt.Formatter) => part8(f)]; - put(out, rt.fmtFormat([args30[0], " "])); - rt.drop(boxed); + const arg3 = rs.place(() => text, (value5) => text = value5); + const part8 = (f: rs.Formatter) => rs.fmtPad(f, arg3.v); + const args30: rs.Fmt[] = [(f: rs.Formatter) => part8(f)]; + put(out, rs.fmtFormat([args30[0], " "])); + rs.drop(boxed); dropped(out); owned[Symbol.dispose](); if (_372) { @@ -3384,8 +3384,8 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { } _372 = false; kept[Symbol.dispose](); - rt.drop(up); - rt.dropVec(shown); + rs.drop(up); + rs.dropVec(shown); log[Symbol.dispose](); } } @@ -3395,796 +3395,796 @@ export function objects(data: rt.ByteSlice, out: rt.ByteVec): void { * slice's parts' `Debug`, each the state std's fields keep: fresh, read from either end, * and past the end, plain and pretty. */ -export function sources(data: rt.ByteSlice, out: rt.ByteVec): void { - let result!: rt.Result; - let held!: rt.Result; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function sources(data: rs.ByteSlice, out: rs.ByteVec): void { + let result!: rs.Result; + let held!: rs.Result; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 4) as rt.usize, rt.u8Rem(at(1), 3) as rt.usize]; - const front: rt.usize = _6[0]; - const back: rt.usize = _6[1]; - const b: rt.u8 = at(2); - const bytes: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 7)); - const part2 = fronts$sources_iter_Once_u8(rt.iterOnce(b), rt.usizeRem(front, 2)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part2, f, rt.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0])])); - const part3 = rt.iterOnce(thenSome$1ou04rm(rt.u8Rem(b, 2) === 0, { _0: b, _1: -1 })); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rt.Formatter) => rt.fmtOption(value, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); - const maybe: rt.u8 | undefined = thenSome$0d5am30(rt.u8Rem(b, 3) !== 0, b); - const _72: rt.Iter = rt.iterOption(maybe); - const _75: rt.Iter = rt.iterOption(maybe); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(_72, f, rt.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rt.Formatter) => rt.fmtIterOption(_75, f, rt.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[1])])); - const pair: Pair.Pair | undefined = thenSome$1ou04rm(rt.u8Rem(b, 2) === 0, { _0: b, _1: 2 }); - const part4 = fronts$sources_option_Iter_fmt_Pair(rt.iterOption(pair), rt.usizeRem(front, 2)); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part4, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args8[0]])); - const part5 = rt.iterOption(pair); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part5, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args10[0]])); - const part6 = rt.iterOption(pair); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part6, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args12[0]])); - const _132: Array = [rt.None, undefined, b]; - const _138: rt.usize = rt.u8Rem(b, 3) as rt.usize; + const _6: [rs.usize, rs.usize] = [rs.u8Rem(at(0), 4) as rs.usize, rs.u8Rem(at(1), 3) as rs.usize]; + const front: rs.usize = _6[0]; + const back: rs.usize = _6[1]; + const b: rs.u8 = at(2); + const bytes: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 7)); + const part2 = fronts$sources_iter_Once_u8(rs.iterOnce(b), rs.usizeRem(front, 2)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part2, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const part3 = rs.iterOnce(thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: -1 })); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part3, f, (value: Pair.Pair | undefined, f: rs.Formatter) => rs.fmtOption(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)), [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const maybe: rs.u8 | undefined = thenSome$0quywni(rs.u8Rem(b, 3) !== 0, b); + const _72: rs.Iter = rs.iterOption(maybe); + const _75: rs.Iter = rs.iterOption(maybe); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_72, f, rs.u8Debug, [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_75, f, rs.u8Debug, [["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[1])])); + const pair: Pair.Pair | undefined = thenSome$1ou04rm(rs.u8Rem(b, 2) === 0, { _0: b, _1: 2 }); + const part4 = fronts$sources_option_Iter_fmt_Pair(rs.iterOption(pair), rs.usizeRem(front, 2)); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part4, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["Iter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args8[0]])); + const part5 = rs.iterOption(pair); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part5, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args10[0]])); + const part6 = rs.iterOption(pair); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part6, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args12[0]])); + const _132: Array = [rs.None, undefined, b]; + const _138: rs.usize = rs.u8Rem(b, 3) as rs.usize; if (!(_138 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _138); - } - const nested: rt.u8 | undefined | rt.None = _132[_138]; - const _150: rt.Iter = rt.iterOption(nested, undefined, rt.None); - const _153: rt.Iter = rt.iterOption(nested, undefined, rt.None); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(_150, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rt.Formatter) => rt.fmtIterOption(_153, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ debugHex: "x" }, args14[1])])); - let mine: rt.u8 | undefined = maybe; - const part7 = fronts$sources_option_IterMut_u8(rt.iterOption(mine === undefined ? undefined : rt.place(() => mine as rt.u8, (value) => mine = value)), rt.usizeRem(front, 2)); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part7, f, (value: rt.Place, f: rt.Formatter) => rt.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])]; - put(out, rt.fmtFormat([args16[0]])); - if (!(rt.u8Rem(b, 2) === 0)) { - result = rt.Err({ _0: b, _1: 3 }); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _138); + } + const nested: rs.u8 | undefined | rs.None = _132[_138]; + const _150: rs.Iter = rs.iterOption(nested, undefined, rs.None); + const _153: rs.Iter = rs.iterOption(nested, undefined, rs.None); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_150, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["Iter", "inner"], ["Item", "opt"]]), (f: rs.Formatter) => rs.fmtIterOption(_153, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug), [["IntoIter", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ debugHex: "x" }, args14[1])])); + let mine: rs.u8 | undefined = maybe; + const part7 = fronts$sources_option_IterMut_u8(rs.iterOption(mine === undefined ? undefined : rs.place(() => mine as rs.u8, (value) => mine = value)), rs.usizeRem(front, 2)); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part7, f, (value: rs.Place, f: rs.Formatter) => rs.u8Debug(value.v, f), [["IterMut", "inner"], ["Item", "opt"]])]; + put(out, rs.fmtFormat([args16[0]])); + if (!(rs.u8Rem(b, 2) === 0)) { + result = rs.Err({ _0: b, _1: 3 }); } else { - result = rt.Ok(b); - } - const _190: rt.Iter = rt.iterResult(result); - const _193: rt.Iter = rt.iterResult(result); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(_190, f, rt.u8Debug, [["Iter", "inner"]]), (f: rt.Formatter) => rt.fmtIterOption(_193, f, rt.u8Debug, [["IntoIter", "inner"]])]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); - if (!(rt.u8Rem(b, 3) === 0)) { - held = rt.Ok({ _0: b, _1: 4 }); + result = rs.Ok(b); + } + const _190: rs.Iter = rs.iterResult(result); + const _193: rs.Iter = rs.iterResult(result); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(_190, f, rs.u8Debug, [["Iter", "inner"]]), (f: rs.Formatter) => rs.fmtIterOption(_193, f, rs.u8Debug, [["IntoIter", "inner"]])]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); + if (!(rs.u8Rem(b, 3) === 0)) { + held = rs.Ok({ _0: b, _1: 4 }); } else { - held = rt.Err(b); - } - const part8 = fronts$sources_result_IterMut_fmt_Pair(rt.iterResult(held), rt.usizeRem(front, 2)); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part8, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])]; - put(out, rt.fmtFormat([args20[0]])); - const part9 = fronts$sources_result_IntoIter_fmt_Pair(rt.iterResult(held), rt.usizeRem(front, 2)); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterOption(part9, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])]; - put(out, rt.fmtFormat([args22[0]])); - const _243: rt.u8 = at(3); - const _246: rt.u8 = at(4); - const _249: rt.u8 = at(5); - const part10 = ends$sources_array_IntoIter_u8_4(rt.iterSlice(Uint8Array.of(b, _243, _246, _249)), front, back); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part10, f, rt.u8Debug, ["IntoIter"])]; - put(out, rt.fmtFormat([args24[0], "|", rt.fmtSpec({ alternate: true }, args24[0]), "|", rt.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args24[0])])); - const part11 = ends$sources_array_IntoIter_fmt_Pair_2(rt.iterSlice([{ _0: b, _1: 5 }, { _0: at(3), _1: 6 }]), rt.usizeRem(front, 3), rt.usizeRem(back, 2)); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part11, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; - put(out, rt.fmtFormat([args26[0], "|", rt.fmtSpec({ alternate: true }, args26[0])])); - const part12 = rt.iterSlice(Uint8Array.of()); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIter(part12, f, rt.u8Debug, ["IntoIter"])]; - put(out, rt.fmtFormat([args28[0]])); - let n: rt.i32 = 0; - const it5: rt.Iter = rt.iterFromFn((): rt.i32 | undefined => { - n = rt.i32Add(n, 1); - return thenSome$0n2gkz4(n < 3, n); + held = rs.Err(b); + } + const part8 = fronts$sources_result_IterMut_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IterMut", "inner"]])]; + put(out, rs.fmtFormat([args20[0]])); + const part9 = fronts$sources_result_IntoIter_fmt_Pair(rs.iterResult(held), rs.usizeRem(front, 2)); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterOption(part9, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), [["IntoIter", "inner"]])]; + put(out, rs.fmtFormat([args22[0]])); + const _243: rs.u8 = at(3); + const _246: rs.u8 = at(4); + const _249: rs.u8 = at(5); + const part10 = ends$sources_array_IntoIter_u8_4(rs.iterSlice(Uint8Array.of(b, _243, _246, _249)), front, back); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part10, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args24[0], "|", rs.fmtSpec({ alternate: true }, args24[0]), "|", rs.fmtSpec({ zero: true, debugHex: "x", width: 2 }, args24[0])])); + const part11 = ends$sources_array_IntoIter_fmt_Pair_2(rs.iterSlice([{ _0: b, _1: 5 }, { _0: at(3), _1: 6 }]), rs.usizeRem(front, 3), rs.usizeRem(back, 2)); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part11, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f), ["IntoIter"])]; + put(out, rs.fmtFormat([args26[0], "|", rs.fmtSpec({ alternate: true }, args26[0])])); + const part12 = rs.iterSlice(Uint8Array.of()); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIter(part12, f, rs.u8Debug, ["IntoIter"])]; + put(out, rs.fmtFormat([args28[0]])); + let n: rs.i32 = 0; + const it5: rs.Iter = rs.iterFromFn((): rs.i32 | undefined => { + n = rs.i32Add(n, 1); + return thenSome$05ku0zn(n < 3, n); }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, "FromFn")]; - put(out, rt.fmtFormat([args30[0], "|", rt.fmtSpec({ alternate: true }, args30[0])])); - const part13 = rt.iterTake(it5, 2); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part13, f, "Take", (_value: rt.Iter, f: rt.Formatter) => rt.fmtWriteStr(f, "FromFn"))]; - put(out, rt.fmtFormat([args32[0]])); - const it6: rt.Iter = rt.iterRepeatWith((): rt.u8 => { + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn")]; + put(out, rs.fmtFormat([args30[0], "|", rs.fmtSpec({ alternate: true }, args30[0])])); + const part13 = rs.iterTake(it5, 2); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part13, f, "Take", (_value: rs.Iter, f: rs.Formatter) => rs.fmtWriteStr(f, "FromFn"))]; + put(out, rs.fmtFormat([args32[0]])); + const it6: rs.Iter = rs.iterRepeatWith((): rs.u8 => { return b; }); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "RepeatWith"))]; - put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0])])); - const part14 = rt.iterSkip(it6, 1); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part14, f, "Skip", (_value: rt.Iter, f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "RepeatWith")))]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args36[0])])); - const part15 = fronts$sources_iter_Successors_u8_fmt_sources_closure3(rt.iterSuccessors(b, (_22: rt.u8): rt.u8 | undefined => { - return rt.u8CheckedAdd(_22, 100); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0])])); + const part14 = rs.iterSkip(it6, 1); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part14, f, "Skip", (_value: rs.Iter, f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith")))]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args36[0])])); + const part15 = fronts$sources_iter_Successors_u8_fmt_sources_closure3(rs.iterSuccessors(b, (_22: rs.u8): rs.u8 | undefined => { + return rs.u8CheckedAdd(_22, 100); }), front); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSuccessors(part15, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args38[0], "|", rt.fmtSpec({ alternate: true }, args38[0]), "|", rt.fmtSpec({ debugHex: "x" }, args38[0])])); - const part16 = fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(rt.iterSuccessors(b as rt.u8 | undefined | rt.None, (_26: rt.u8 | undefined): rt.u8 | undefined | rt.None => { - return option_andThen$1bd14ex(_26, (x3: rt.u8): rt.u8 | undefined | rt.None => { - return option_map$0phsnvg(rt.u8CheckedSub(x3, 100), (a0: rt.u8): rt.u8 | undefined => { + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part15, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args38[0], "|", rs.fmtSpec({ alternate: true }, args38[0]), "|", rs.fmtSpec({ debugHex: "x" }, args38[0])])); + const part16 = fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(rs.iterSuccessors(b as rs.u8 | undefined | rs.None, (_26: rs.u8 | undefined): rs.u8 | undefined | rs.None => { + return option_andThen$0jc4o0i(_26, (x3: rs.u8): rs.u8 | undefined | rs.None => { + return option_map$02rrcvu(rs.u8CheckedSub(x3, 100), (a0: rs.u8): rs.u8 | undefined => { return a0; }); }); - }, undefined, rt.None), front); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSuccessors(part16, f, (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - put(out, rt.fmtFormat([args40[0]])); - const part17 = rt.iterMap(rt.iterChain(rt.iterOnce(b), rt.iterSlice(Uint8Array.of(at(3), at(4)))), (x4: rt.u8): rt.u8 => { - return rt.u8Div(x4, 2); + }, undefined, rs.None), front); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSuccessors(part16, f, (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + put(out, rs.fmtFormat([args40[0]])); + const part17 = rs.iterMap(rs.iterChain(rs.iterOnce(b), rs.iterSlice(Uint8Array.of(at(3), at(4)))), (x4: rs.u8): rs.u8 => { + return rs.u8Div(x4, 2); }); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtAdaptor(part17, f, "Map", (value: rt.Iter, f: rt.Formatter) => rt.fmtChain(value, f, (value: rt.Iter, f: rt.Formatter) => rt.fmtIterOption(value, f, rt.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rt.Iter, f: rt.Formatter) => rt.fmtIter(value, f, rt.u8Debug, ["IntoIter"])))]; - put(out, rt.fmtFormat([args42[0], "|", rt.fmtSpec({ alternate: true }, args42[0])])); - const part18 = rt.iterRepeat(b); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRepeat(part18, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args44[0], "|", rt.fmtSpec({ alternate: true }, args44[0]), "|", rt.fmtSpec({ debugHex: "x" }, args44[0])])); - const part19 = ends$sources_iter_Take_iter_Repeat_fmt_Pair(rt.iterTake(rt.iterRepeat({ _0: b, _1: 7 }), 3), front, back); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCounted(part19, f, "Take", (value: rt.Iter, f: rt.Formatter) => rt.fmtRepeat(value, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; - put(out, rt.fmtFormat([args46[0]])); - const n2: rt.usize = rt.u8Rem(at(3), 4) as rt.usize; - const part20 = ends$sources_iter_RepeatN_u8(rt.iterRepeatN(b, n2), front, back); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRepeatN(part20, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args48[0], "|", rt.fmtSpec({ alternate: true }, args48[0])])); - const it12: rt.Iter = rt.iterRepeatN({ _0: b, _1: 8 }, n2); - const _464: rt.usize = rt.u8Rem(at(4), 4) as rt.usize; - rt.iterNth(it12, _464); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtRepeatN(it12, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args50[0], "|", rt.fmtSpec({ alternate: true }, args50[0])])); - const part21 = ends$sources_iter_OnceWith_fmt_sources_closure6(rt.iterOnceWith((): rt.u8 => { + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtAdaptor(part17, f, "Map", (value: rs.Iter, f: rs.Formatter) => rs.fmtChain(value, f, (value: rs.Iter, f: rs.Formatter) => rs.fmtIterOption(value, f, rs.u8Debug, [["Once", "inner"], ["IntoIter", "inner"], ["Item", "opt"]]), (value: rs.Iter, f: rs.Formatter) => rs.fmtIter(value, f, rs.u8Debug, ["IntoIter"])))]; + put(out, rs.fmtFormat([args42[0], "|", rs.fmtSpec({ alternate: true }, args42[0])])); + const part18 = rs.iterRepeat(b); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeat(part18, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args44[0], "|", rs.fmtSpec({ alternate: true }, args44[0]), "|", rs.fmtSpec({ debugHex: "x" }, args44[0])])); + const part19 = ends$sources_iter_Take_iter_Repeat_fmt_Pair(rs.iterTake(rs.iterRepeat({ _0: b, _1: 7 }), 3), front, back); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCounted(part19, f, "Take", (value: rs.Iter, f: rs.Formatter) => rs.fmtRepeat(value, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f)))]; + put(out, rs.fmtFormat([args46[0]])); + const n2: rs.usize = rs.u8Rem(at(3), 4) as rs.usize; + const part20 = ends$sources_iter_RepeatN_u8(rs.iterRepeatN(b, n2), front, back); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(part20, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args48[0], "|", rs.fmtSpec({ alternate: true }, args48[0])])); + const it12: rs.Iter = rs.iterRepeatN({ _0: b, _1: 8 }, n2); + const _464: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; + rs.iterNth(it12, _464); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtRepeatN(it12, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args50[0], "|", rs.fmtSpec({ alternate: true }, args50[0])])); + const part21 = ends$sources_iter_OnceWith_fmt_sources_closure6(rs.iterOnceWith((): rs.u8 => { return b; - }), rt.usizeRem(front, 2), rt.usizeRem(back, 2)); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOnceWith(part21, f)]; - put(out, rt.fmtFormat([args52[0], "|", rt.fmtSpec({ alternate: true }, args52[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args52[0])])); - const text: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_212: rt.u8): rt.char => { - const _54: rt.usize = rt.u8Rem(_212, 5) as rt.usize; + }), rs.usizeRem(front, 2), rs.usizeRem(back, 2)); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOnceWith(part21, f)]; + put(out, rs.fmtFormat([args52[0], "|", rs.fmtSpec({ alternate: true }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[0])])); + const text: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_212: rs.u8): rs.char => { + const _54: rs.usize = rs.u8Rem(_212, 5) as rs.usize; if (!(_54 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _54); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _54); } return [97, 233, 20013, 129408, 10][_54]; })); - const part22 = ends$sources_str_CharIndices(rt.strCharIndices(text), front, back); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharIndices(part22, f)]; - put(out, rt.fmtFormat([args54[0], "|", rt.fmtSpec({ alternate: true }, args54[0]), "|", rt.fmtSpec({ debugHex: "x" }, args54[0])])); + const part22 = ends$sources_str_CharIndices(rs.strCharIndices(text), front, back); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharIndices(part22, f)]; + put(out, rs.fmtFormat([args54[0], "|", rs.fmtSpec({ alternate: true }, args54[0]), "|", rs.fmtSpec({ debugHex: "x" }, args54[0])])); let drained: string = text; - const it15: rt.Iter = ends$sources_string_Drain(rt.stringDrain(rt.place(() => drained, (value3) => drained = value3), undefined), front, back); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStringDrain(it15, f)]; - put(out, rt.fmtFormat([args56[0], "|", rt.fmtSpec({ alternate: true }, args56[0])])); - rt.drop(it15); - const size: rt.usize = rt.usizeAdd(rt.u8Rem(at(3), 4) as rt.usize, 1); - const part23 = ends$sources_slice_Windows_u8(rt.byteSliceWindows(bytes, size), front, back); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part23, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Windows")]; - put(out, rt.fmtFormat([args58[0], "|", rt.fmtSpec({ alternate: true }, args58[0]), "|", rt.fmtSpec({ debugHex: "x" }, args58[0])])); - const it17: rt.Iter = rt.byteSliceWindows(bytes, size); - const _564: rt.usize = rt.u8Rem(at(4), 8) as rt.usize; - rt.iterNth(it17, _564); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(it17, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Windows")]; - put(out, rt.fmtFormat([args60[0]])); - const it18: rt.Iter = fronts$sources_slice_Windows_u8(rt.byteSliceWindows(bytes, size), 8); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(it18, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Windows")]; - put(out, rt.fmtFormat([args62[0]])); - rt.iterToOption(it18.nextBack()); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(it18, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Windows")]; - put(out, rt.fmtFormat([args64[0]])); - const it19: rt.Iter = rt.byteSliceWindows(bytes, size); - const _613: rt.usize = rt.u8Rem(at(4), 8) as rt.usize; - rt.iterNthBack(it19, _613); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(it19, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Windows")]; - put(out, rt.fmtFormat([args66[0]])); - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_213: rt.u8): rt.u16 => { - return rt.u16Mul(_213 as rt.u16, 257); + const it15: rs.Iter = ends$sources_string_Drain(rs.stringDrain(rs.place(() => drained, (value3) => drained = value3), undefined), front, back); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStringDrain(it15, f)]; + put(out, rs.fmtFormat([args56[0], "|", rs.fmtSpec({ alternate: true }, args56[0])])); + rs.drop(it15); + const size: rs.usize = rs.usizeAdd(rs.u8Rem(at(3), 4) as rs.usize, 1); + const part23 = ends$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), front, back); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part23, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args58[0], "|", rs.fmtSpec({ alternate: true }, args58[0]), "|", rs.fmtSpec({ debugHex: "x" }, args58[0])])); + const it17: rs.Iter = rs.byteSliceWindows(bytes, size); + const _564: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; + rs.iterNth(it17, _564); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it17, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args60[0]])); + const it18: rs.Iter = fronts$sources_slice_Windows_u8(rs.byteSliceWindows(bytes, size), 8); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args62[0]])); + rs.iterToOption(it18.nextBack()); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it18, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args64[0]])); + const it19: rs.Iter = rs.byteSliceWindows(bytes, size); + const _613: rs.usize = rs.u8Rem(at(4), 8) as rs.usize; + rs.iterNthBack(it19, _613); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it19, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Windows")]; + put(out, rs.fmtFormat([args66[0]])); + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_213: rs.u8): rs.u16 => { + return rs.u16Mul(_213 as rs.u16, 257); }), undefined, 2, true); - const part24 = ends$sources_slice_Windows_u16(rt.sliceWindows(wide.items, size), front, back); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part24, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "Windows")]; - put(out, rt.fmtFormat([args68[0], "|", rt.fmtSpec({ alternate: true, debugHex: "x" }, args68[0])])); - const part25 = ends$sources_slice_Chunks_u8(rt.byteSliceChunks(bytes, size), front, back); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part25, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Chunks")]; - put(out, rt.fmtFormat([args70[0], "|", rt.fmtSpec({ alternate: true }, args70[0])])); - const part26 = ends$sources_slice_ChunksExact_u16(rt.sliceChunksExact(wide.items, size), front, back); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part26, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "ChunksExact")]; - put(out, rt.fmtFormat([args72[0], "|", rt.fmtSpec({ alternate: true }, args72[0])])); - const part27 = ends$sources_slice_ChunksExact_u8(rt.byteSliceChunksExact(bytes, size), front, back); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part27, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "ChunksExact")]; - put(out, rt.fmtFormat([args74[0]])); - const part28 = ends$sources_slice_RChunks_u16(rt.sliceRchunks(wide.items, size), front, back); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part28, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "RChunks")]; - put(out, rt.fmtFormat([args76[0]])); - const part29 = ends$sources_slice_RChunks_u8(rt.byteSliceRchunks(bytes, size), front, back); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part29, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RChunks")]; - put(out, rt.fmtFormat([args78[0], "|", rt.fmtSpec({ alternate: true }, args78[0])])); - const part30 = ends$sources_slice_RChunksExact_u8(rt.byteSliceRchunksExact(bytes, size), front, back); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(part30, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RChunksExact")]; - put(out, rt.fmtFormat([args80[0]])); - const it27: rt.Iter = rt.sliceRchunksExact(wide.items, size); - const _743: rt.usize = rt.u8Rem(at(4), 4) as rt.usize; - rt.iterNth(it27, _743); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParts(it27, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "RChunksExact")]; - put(out, rt.fmtFormat([args82[0]])); - const part31 = ends$sources_slice_Split_u8_fmt_sources_closure9(rt.byteSliceSplit(bytes, (x5: rt.u8): boolean => { - return rt.u8Rem(x5, 3) === 0; + const part24 = ends$sources_slice_Windows_u16(rs.sliceWindows(wide.items, size), front, back); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part24, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "Windows")]; + put(out, rs.fmtFormat([args68[0], "|", rs.fmtSpec({ alternate: true, debugHex: "x" }, args68[0])])); + const part25 = ends$sources_slice_Chunks_u8(rs.byteSliceChunks(bytes, size), front, back); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part25, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Chunks")]; + put(out, rs.fmtFormat([args70[0], "|", rs.fmtSpec({ alternate: true }, args70[0])])); + const part26 = ends$sources_slice_ChunksExact_u16(rs.sliceChunksExact(wide.items, size), front, back); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part26, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "ChunksExact")]; + put(out, rs.fmtFormat([args72[0], "|", rs.fmtSpec({ alternate: true }, args72[0])])); + const part27 = ends$sources_slice_ChunksExact_u8(rs.byteSliceChunksExact(bytes, size), front, back); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part27, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "ChunksExact")]; + put(out, rs.fmtFormat([args74[0]])); + const part28 = ends$sources_slice_RChunks_u16(rs.sliceRchunks(wide.items, size), front, back); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part28, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "RChunks")]; + put(out, rs.fmtFormat([args76[0]])); + const part29 = ends$sources_slice_RChunks_u8(rs.byteSliceRchunks(bytes, size), front, back); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part29, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunks")]; + put(out, rs.fmtFormat([args78[0], "|", rs.fmtSpec({ alternate: true }, args78[0])])); + const part30 = ends$sources_slice_RChunksExact_u8(rs.byteSliceRchunksExact(bytes, size), front, back); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(part30, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RChunksExact")]; + put(out, rs.fmtFormat([args80[0]])); + const it27: rs.Iter = rs.sliceRchunksExact(wide.items, size); + const _743: rs.usize = rs.u8Rem(at(4), 4) as rs.usize; + rs.iterNth(it27, _743); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParts(it27, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "RChunksExact")]; + put(out, rs.fmtFormat([args82[0]])); + const part31 = ends$sources_slice_Split_u8_fmt_sources_closure9(rs.byteSliceSplit(bytes, (x5: rs.u8): boolean => { + return rs.u8Rem(x5, 3) === 0; }), front, back); - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part31, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Split", false)]; - put(out, rt.fmtFormat([args84[0], "|", rt.fmtSpec({ alternate: true }, args84[0]), "|", rt.fmtSpec({ debugHex: "x" }, args84[0])])); - const part32 = ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(rt.byteSliceSplitInclusive(bytes, (x6: rt.u8): boolean => { - return rt.u8Rem(x6, 3) === 0; + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part31, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false)]; + put(out, rs.fmtFormat([args84[0], "|", rs.fmtSpec({ alternate: true }, args84[0]), "|", rs.fmtSpec({ debugHex: "x" }, args84[0])])); + const part32 = ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(bytes, (x6: rs.u8): boolean => { + return rs.u8Rem(x6, 3) === 0; }), front, back); - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part32, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "SplitInclusive", false)]; - put(out, rt.fmtFormat([args86[0]])); - const part33 = ends$sources_slice_RSplit_u8_fmt_sources_closure9(rt.byteSliceRsplit(bytes, (x7: rt.u8): boolean => { - return rt.u8Rem(x7, 3) === 0; + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part32, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusive", false)]; + put(out, rs.fmtFormat([args86[0]])); + const part33 = ends$sources_slice_RSplit_u8_fmt_sources_closure9(rs.byteSliceRsplit(bytes, (x7: rs.u8): boolean => { + return rs.u8Rem(x7, 3) === 0; }), front, back); - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part33, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RSplit", false)]; - put(out, rt.fmtFormat([args88[0]])); - const part34 = fronts$sources_slice_SplitN_u8_fmt_sources_closure9(rt.byteSliceSplitn(bytes, rt.u8Rem(at(4), 4) as rt.usize, (x8: rt.u8): boolean => { - return rt.u8Rem(x8, 3) === 0; + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part33, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false)]; + put(out, rs.fmtFormat([args88[0]])); + const part34 = fronts$sources_slice_SplitN_u8_fmt_sources_closure9(rs.byteSliceSplitn(bytes, rs.u8Rem(at(4), 4) as rs.usize, (x8: rs.u8): boolean => { + return rs.u8Rem(x8, 3) === 0; }), front); - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part34, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "Split", false, "SplitN")]; - put(out, rt.fmtFormat([args90[0], "|", rt.fmtSpec({ alternate: true }, args90[0])])); - const part35 = fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(rt.byteSliceRsplitn(bytes, 2, (x9: rt.u8): boolean => { - return rt.u8Rem(x9, 3) === 0; + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part34, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "Split", false, "SplitN")]; + put(out, rs.fmtFormat([args90[0], "|", rs.fmtSpec({ alternate: true }, args90[0])])); + const part35 = fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(rs.byteSliceRsplitn(bytes, 2, (x9: rs.u8): boolean => { + return rs.u8Rem(x9, 3) === 0; }), front); - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part35, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RSplit", false, "RSplitN")]; - put(out, rt.fmtFormat([args92[0]])); - const part36 = ends$sources_slice_Split_u16_fmt_sources_closure10(rt.sliceSplit(wide.items, (x10: rt.u16): boolean => { - return rt.u16Rem(x10, 3) === 0; + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part35, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplit", false, "RSplitN")]; + put(out, rs.fmtFormat([args92[0]])); + const part36 = ends$sources_slice_Split_u16_fmt_sources_closure10(rs.sliceSplit(wide.items, (x10: rs.u16): boolean => { + return rs.u16Rem(x10, 3) === 0; }), front, back); - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part36, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "Split", false)]; - put(out, rt.fmtFormat([args94[0]])); - const part37 = fronts$sources_slice_SplitN_u16_fmt_sources_closure10(rt.sliceSplitn(wide.items, 2, (x11: rt.u16): boolean => { - return rt.u16Rem(x11, 3) === 0; + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part36, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "Split", false)]; + put(out, rs.fmtFormat([args94[0]])); + const part37 = fronts$sources_slice_SplitN_u16_fmt_sources_closure10(rs.sliceSplitn(wide.items, 2, (x11: rs.u16): boolean => { + return rs.u16Rem(x11, 3) === 0; }), front); - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part37, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "Split", false, "SplitN")]; - put(out, rt.fmtFormat([args96[0]])); - const owned: rt.ByteVec = rt.byteSliceToByteVec(bytes); - const part38 = ends$sources_slice_SplitMut_u8_fmt_sources_closure9(rt.byteSliceSplit(rt.byteVecSlice(owned), (x12: rt.u8): boolean => { - return rt.u8Rem(x12, 3) === 0; + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part37, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "Split", false, "SplitN")]; + put(out, rs.fmtFormat([args96[0]])); + const owned: rs.ByteVec = rs.byteSliceToByteVec(bytes); + const part38 = ends$sources_slice_SplitMut_u8_fmt_sources_closure9(rs.byteSliceSplit(rs.byteVecSlice(owned), (x12: rs.u8): boolean => { + return rs.u8Rem(x12, 3) === 0; }), front, back); - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part38, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "SplitMut", true)]; - put(out, rt.fmtFormat([args98[0], "|", rt.fmtSpec({ alternate: true }, args98[0])])); - const part39 = ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(rt.byteSliceSplitInclusive(rt.byteVecSlice(owned), (x13: rt.u8): boolean => { - return rt.u8Rem(x13, 3) === 0; + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part38, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true)]; + put(out, rs.fmtFormat([args98[0], "|", rs.fmtSpec({ alternate: true }, args98[0])])); + const part39 = ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(rs.byteSliceSplitInclusive(rs.byteVecSlice(owned), (x13: rs.u8): boolean => { + return rs.u8Rem(x13, 3) === 0; }), front, back); - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part39, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "SplitInclusiveMut", true)]; - put(out, rt.fmtFormat([args100[0]])); - const part40 = ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(rt.byteSliceRsplit(rt.byteVecSlice(owned), (x14: rt.u8): boolean => { - return rt.u8Rem(x14, 3) === 0; + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part39, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitInclusiveMut", true)]; + put(out, rs.fmtFormat([args100[0]])); + const part40 = ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(rs.byteSliceRsplit(rs.byteVecSlice(owned), (x14: rs.u8): boolean => { + return rs.u8Rem(x14, 3) === 0; }), front, back); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part40, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RSplitMut", true)]; - put(out, rt.fmtFormat([args102[0]])); - const part41 = fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(rt.byteSliceSplitn(rt.byteVecSlice(owned), 2, (x15: rt.u8): boolean => { - return rt.u8Rem(x15, 3) === 0; + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part40, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true)]; + put(out, rs.fmtFormat([args102[0]])); + const part41 = fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(rs.byteSliceSplitn(rs.byteVecSlice(owned), 2, (x15: rs.u8): boolean => { + return rs.u8Rem(x15, 3) === 0; }), front); - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part41, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "SplitMut", true, "SplitNMut")]; - put(out, rt.fmtFormat([args104[0]])); - const part42 = fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(rt.byteSliceRsplitn(rt.byteVecSlice(owned), rt.u8Rem(at(4), 4) as rt.usize, (x16: rt.u8): boolean => { - return rt.u8Rem(x16, 3) === 0; + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part41, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "SplitMut", true, "SplitNMut")]; + put(out, rs.fmtFormat([args104[0]])); + const part42 = fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(rs.byteSliceRsplitn(rs.byteVecSlice(owned), rs.u8Rem(at(4), 4) as rs.usize, (x16: rs.u8): boolean => { + return rs.u8Rem(x16, 3) === 0; }), front); - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part42, f, (value: rt.ByteSlice, f: rt.Formatter) => rt.fmtList(rt.byteSliceView(value), f, rt.u8Debug), "RSplitMut", true, "RSplitNMut")]; - put(out, rt.fmtFormat([args106[0]])); - const part43 = ends$sources_slice_SplitMut_u16_fmt_sources_closure10(rt.sliceSplitMut(rt.vecFrom(wide.items.slice()).items, (x17: rt.u16): boolean => { - return rt.u16Rem(x17, 3) === 0; + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part42, f, (value: rs.ByteSlice, f: rs.Formatter) => rs.fmtList(rs.byteSliceView(value), f, rs.u8Debug), "RSplitMut", true, "RSplitNMut")]; + put(out, rs.fmtFormat([args106[0]])); + const part43 = ends$sources_slice_SplitMut_u16_fmt_sources_closure10(rs.sliceSplitMut(rs.vecFrom(wide.items.slice()).items, (x17: rs.u16): boolean => { + return rs.u16Rem(x17, 3) === 0; }), front, back); - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtSplit(part43, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug), "SplitMut", true)]; - put(out, rt.fmtFormat([args108[0]])); - const _976: [rt.HashSet, rt.HashSet] = [rt.hashNew() as rt.HashSet, rt.hashNew() as rt.HashSet]; - const one: rt.HashSet = _976[0]; - const other: rt.HashSet = _976[1]; - if (rt.u8Rem(b, 2) === 0) { - rt.hashAdd(one, b); - } - if (rt.u8Rem(b, 3) === 0) { - rt.hashAdd(other, b); - } - const _997: rt.Iter = rt.hashDifference(one, other); - const _1001: rt.Iter = rt.hashIntersection(one, other); - const _1005: rt.Iter = rt.hashSymmetricDifference(one, other); - const _1009: rt.Iter = rt.hashUnion(one, other); - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtIterClone(_997, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIterClone(_1001, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIterClone(_1005, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtIterClone(_1009, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args110[0], "|", rt.fmtSpec({ alternate: true }, args110[1]), "|", args110[2], "|", args110[3]])); -} - -export function ends$sources_array_IntoIter_fmt_Pair_2(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtSplit(part43, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug), "SplitMut", true)]; + put(out, rs.fmtFormat([args108[0]])); + const _976: [rs.HashSet, rs.HashSet] = [rs.hashNew() as rs.HashSet, rs.hashNew() as rs.HashSet]; + const one: rs.HashSet = _976[0]; + const other: rs.HashSet = _976[1]; + if (rs.u8Rem(b, 2) === 0) { + rs.hashAdd(one, b); + } + if (rs.u8Rem(b, 3) === 0) { + rs.hashAdd(other, b); + } + const _997: rs.Iter = rs.hashDifference(one, other); + const _1001: rs.Iter = rs.hashIntersection(one, other); + const _1005: rs.Iter = rs.hashSymmetricDifference(one, other); + const _1009: rs.Iter = rs.hashUnion(one, other); + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtIterClone(_997, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1001, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1005, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtIterClone(_1009, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args110[0], "|", rs.fmtSpec({ alternate: true }, args110[1]), "|", args110[2], "|", args110[3]])); +} + +export function ends$sources_array_IntoIter_fmt_Pair_2(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_array_IntoIter_u8_4(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_array_IntoIter_u8_4(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_iter_OnceWith_fmt_sources_closure6(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_iter_OnceWith_fmt_sources_closure6(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_iter_RepeatN_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_iter_RepeatN_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_iter_Take_iter_Repeat_fmt_Pair(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_iter_Take_iter_Repeat_fmt_Pair(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_ChunksExact_u16(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_ChunksExact_u16(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_ChunksExact_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_ChunksExact_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_Chunks_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_Chunks_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_RChunksExact_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_RChunksExact_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_RChunks_u16(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_RChunks_u16(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_RChunks_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_RChunks_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_RSplitMut_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_RSplit_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_RSplit_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_SplitInclusiveMut_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_SplitInclusive_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_SplitMut_u16_fmt_sources_closure10(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_SplitMut_u16_fmt_sources_closure10(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_SplitMut_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_SplitMut_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_Split_u16_fmt_sources_closure10(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_Split_u16_fmt_sources_closure10(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_Split_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_Split_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_Windows_u16(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_Windows_u16(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_slice_Windows_u8(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_slice_Windows_u8(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_str_CharIndices(it: rt.Iter<[rt.usize, rt.char]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, rt.char]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_str_CharIndices(it: rs.Iter<[rs.usize, rs.char]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, rs.char]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$sources_string_Drain(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$sources_string_Drain(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function fronts$sources_iter_Once_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_iter_Once_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_iter_Successors_Option_u8_fmt_sources_closure4(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next(), rt.None); + rs.iterToOption(it.next(), rs.None); } } -export function fronts$sources_iter_Successors_u8_fmt_sources_closure3(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_iter_Successors_u8_fmt_sources_closure3(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_option_IterMut_u8(it: rt.Iter>, front: rt.usize): rt.Iter> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_option_IterMut_u8(it: rs.Iter>, front: rs.usize): rs.Iter> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_option_Iter_fmt_Pair(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_option_Iter_fmt_Pair(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_result_IntoIter_fmt_Pair(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_result_IntoIter_fmt_Pair(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_result_IterMut_fmt_Pair(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_result_IterMut_fmt_Pair(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_RSplitNMut_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_RSplitN_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_SplitNMut_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_SplitN_u16_fmt_sources_closure10(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_SplitN_u16_fmt_sources_closure10(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_SplitN_u8_fmt_sources_closure9(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_SplitN_u8_fmt_sources_closure9(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sources_slice_Windows_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sources_slice_Windows_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } @@ -4194,190 +4194,190 @@ export function fronts$sources_slice_Windows_u8(it: rt.Iter, front * by where the sets meet, fresh and part read, plain and pretty. And each `ExtractIf`'s: a * list's the item it reads next, a hash map's and set's nothing. */ -export function sets(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function sets(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const front: rt.usize = rt.u8Rem(at(0), 4) as rt.usize; - const b: rt.u8 = rt.u8Rem(at(1), 64); - const _16: rt.Iter = rt.iterMap(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 2), rt.u8Rem(at(2), 4) as rt.usize), (_2: rt.u8): rt.u8 => { - return rt.u8Rem(_2, 64); + const front: rs.usize = rs.u8Rem(at(0), 4) as rs.usize; + const b: rs.u8 = rs.u8Rem(at(1), 64); + const _16: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), 2), rs.u8Rem(at(2), 4) as rs.usize), (_2: rs.u8): rs.u8 => { + return rs.u8Rem(_2, 64); }); - const small: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _16, true, undefined, undefined, 1, true); - const _27: rt.Iter = rt.iterMap(new rt.Range(0, rt.usizeMul(rt.u8Rem(at(3), 3) as rt.usize, 24)), (i2: rt.usize): rt.u8 => { - return rt.u8Rem(rt.u8WrappingMul(i2 & 0xff, at(4) | 1), 64); + const small: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _16, true, undefined, undefined, 1, true); + const _27: rs.Iter = rs.iterMap(new rs.Range(0, rs.usizeMul(rs.u8Rem(at(3), 3) as rs.usize, 24)), (i2: rs.usize): rs.u8 => { + return rs.u8Rem(rs.u8WrappingMul(i2 & 0xff, at(4) | 1), 64); }); - const large: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _27, true, undefined, undefined, 1, true); - const _40: Uint8Array = Uint8Array.of(b, rt.u8Add(b, 1), rt.u8Add(b, 2)); - const low: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_40), true, undefined, undefined, 1, true); - const _46: Uint8Array = Uint8Array.of(rt.u8Add(b, 2), rt.u8Add(b, 70)); - const high: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterSlice(_46), true, undefined, undefined, 1, true); - const iter: rt.Iter<[rt.BTreeSet, rt.BTreeSet]> = rt.iterSlice([[small, large] as [rt.BTreeSet, rt.BTreeSet], [large, small] as [rt.BTreeSet, rt.BTreeSet], [small, small] as [rt.BTreeSet, rt.BTreeSet], [low, high] as [rt.BTreeSet, rt.BTreeSet], [high, low] as [rt.BTreeSet, rt.BTreeSet]]); - while (true) { - const _69: [rt.BTreeSet, rt.BTreeSet] | rt.Done = iter.next(); - if (_69 === rt.DONE) { + const large: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _27, true, undefined, undefined, 1, true); + const _40: Uint8Array = Uint8Array.of(b, rs.u8Add(b, 1), rs.u8Add(b, 2)); + const low: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_40), true, undefined, undefined, 1, true); + const _46: Uint8Array = Uint8Array.of(rs.u8Add(b, 2), rs.u8Add(b, 70)); + const high: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterSlice(_46), true, undefined, undefined, 1, true); + const iter: rs.Iter<[rs.BTreeSet, rs.BTreeSet]> = rs.iterSlice([[small, large] as [rs.BTreeSet, rs.BTreeSet], [large, small] as [rs.BTreeSet, rs.BTreeSet], [small, small] as [rs.BTreeSet, rs.BTreeSet], [low, high] as [rs.BTreeSet, rs.BTreeSet], [high, low] as [rs.BTreeSet, rs.BTreeSet]]); + while (true) { + const _69: [rs.BTreeSet, rs.BTreeSet] | rs.Done = iter.next(); + if (_69 === rs.DONE) { break; } - const part = fronts$sets_collections_btree_set_Difference_u8(rt.btreeDifference(_69[0], _69[1]), front); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part, f, rt.u8Debug, "Difference")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0])])); - const part2 = fronts$sets_collections_btree_set_Intersection_u8(rt.btreeIntersection(_69[0], _69[1]), front); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part2, f, rt.u8Debug, "Intersection")]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); - const part3 = fronts$sets_collections_btree_set_Union_u8(rt.btreeUnion(_69[0], _69[1]), front); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part3, f, rt.u8Debug, "Union")]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const part4 = fronts$sets_collections_btree_set_SymmetricDifference_u8(rt.btreeSymmetricDifference(_69[0], _69[1]), front); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part4, f, rt.u8Debug, "SymmetricDifference")]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ alternate: true }, args8[0])])); - } - const _131: rt.Iter<[rt.u8, rt.char]> = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_23: rt.u8): [rt.u8, rt.char] => { - return [rt.u8Rem(_23, 4), 112] as [rt.u8, rt.char]; + const part = fronts$sets_collections_btree_set_Difference_u8(rs.btreeDifference(_69[0], _69[1]), front); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part, f, rs.u8Debug, "Difference")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0])])); + const part2 = fronts$sets_collections_btree_set_Intersection_u8(rs.btreeIntersection(_69[0], _69[1]), front); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part2, f, rs.u8Debug, "Intersection")]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + const part3 = fronts$sets_collections_btree_set_Union_u8(rs.btreeUnion(_69[0], _69[1]), front); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part3, f, rs.u8Debug, "Union")]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + const part4 = fronts$sets_collections_btree_set_SymmetricDifference_u8(rs.btreeSymmetricDifference(_69[0], _69[1]), front); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part4, f, rs.u8Debug, "SymmetricDifference")]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ alternate: true }, args8[0])])); + } + const _131: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_23: rs.u8): [rs.u8, rs.char] => { + return [rs.u8Rem(_23, 4), 112] as [rs.u8, rs.char]; }); - const pairs: rt.BTreeSet<[rt.u8, rt.char]> = rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.char], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.char]>, _131, true, undefined, undefined, 8, true); - const _135: rt.Iter<[rt.u8, rt.char]> = rt.iterMap(rt.iterTake(rt.iterSkip(rt.iterSlice(rt.byteSliceView(data)), 1), 3), (_26: rt.u8): [rt.u8, rt.char] => { - return [rt.u8Rem(_26, 4), 113] as [rt.u8, rt.char]; + const pairs: rs.BTreeSet<[rs.u8, rs.char]> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.char]>, _131, true, undefined, undefined, 8, true); + const _135: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterTake(rs.iterSkip(rs.iterSlice(rs.byteSliceView(data)), 1), 3), (_26: rs.u8): [rs.u8, rs.char] => { + return [rs.u8Rem(_26, 4), 113] as [rs.u8, rs.char]; }); - const more: rt.BTreeSet<[rt.u8, rt.char]> = rt.btreeExtendKeys(rt.btreeNew(rt.cmpTuple<[rt.u8, rt.char], rt.Ordering>([rt.cmp, rt.cmp])) as rt.BTreeSet<[rt.u8, rt.char]>, _135, true, undefined, undefined, 8, true); - const part5 = fronts$sets_collections_btree_set_Union_tuple2_u8_char(rt.btreeUnion(pairs, more), front); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part5, f, (value: [rt.u8, rt.char], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtCharDebug(value[1], f)], f), "Union")]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ debugHex: "x" }, args10[0])])); - const part6 = fronts$sets_collections_btree_set_Difference_tuple2_u8_char(rt.btreeDifference(pairs, more), front); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBTreeSetOp(part6, f, (value: [rt.u8, rt.char], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(value[0], f), (f: rt.Formatter) => rt.fmtCharDebug(value[1], f)], f), "Difference")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args12[0])])); - const _172: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6); - const it7: rt.Iter = fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(rt.listExtractIfMut(rt.listExtend(rt.listNew() as rt.LinkedList, _172), (x4: rt.Place): boolean => { - return rt.u8Rem(x4.v, 2) === 0; + const more: rs.BTreeSet<[rs.u8, rs.char]> = rs.btreeExtendKeys(rs.btreeNew(rs.cmpTuple<[rs.u8, rs.char], rs.Ordering>([rs.cmp, rs.cmp])) as rs.BTreeSet<[rs.u8, rs.char]>, _135, true, undefined, undefined, 8, true); + const part5 = fronts$sets_collections_btree_set_Union_tuple2_u8_char(rs.btreeUnion(pairs, more), front); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part5, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Union")]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ debugHex: "x" }, args10[0])])); + const part6 = fronts$sets_collections_btree_set_Difference_tuple2_u8_char(rs.btreeDifference(pairs, more), front); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBTreeSetOp(part6, f, (value: [rs.u8, rs.char], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(value[0], f), (f: rs.Formatter) => rs.fmtCharDebug(value[1], f)], f), "Difference")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + const _172: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); + const it7: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(rs.listExtractIfMut(rs.listExtend(rs.listNew() as rs.LinkedList, _172), (x4: rs.Place): boolean => { + return rs.u8Rem(x4.v, 2) === 0; }), front); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtListExtractIf(it7, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args14[0], "|", rt.fmtSpec({ alternate: true }, args14[0]), "|", rt.fmtSpec({ debugHex: "x" }, args14[0])])); - const _192: rt.Iter = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_210: rt.u8): Pair.Pair => { + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it7, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args14[0], "|", rs.fmtSpec({ alternate: true }, args14[0]), "|", rs.fmtSpec({ debugHex: "x" }, args14[0])])); + const _192: rs.Iter = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_210: rs.u8): Pair.Pair => { return { _0: _210, _1: 2 }; }); - const it8: rt.Iter = fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(rt.listExtractIf(rt.listExtend(rt.listNew() as rt.LinkedList, _192), (p: Pair.Pair): boolean => { - return rt.u8Rem(p._0, 3) === 0; + const it8: rs.Iter = fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(rs.listExtractIf(rs.listExtend(rs.listNew() as rs.LinkedList, _192), (p: Pair.Pair): boolean => { + return rs.u8Rem(p._0, 3) === 0; }), front); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rt.Formatter) => Pair.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args16[0]])); - const _212: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): [rt.u8, rt.u8] => { - const x6: rt.u8 = _211; - return [x6, x6] as [rt.u8, rt.u8]; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtListExtractIf(it8, f, (value: Pair.Pair, f: rs.Formatter) => Pair.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args16[0]])); + const _212: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): [rs.u8, rs.u8] => { + const x6: rs.u8 = _211; + return [x6, x6] as [rs.u8, rs.u8]; }); - const map: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _212, undefined, undefined, undefined, 469762048); - const _215: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew() as rt.HashSet, _215, undefined, undefined, 469762048); - rt.hashExtractIfMut(map, (k: rt.u8, _310: rt.Place): boolean => { + const map: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _212, undefined, undefined, undefined, 469762048); + const _215: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew() as rs.HashSet, _215, undefined, undefined, 469762048); + rs.hashExtractIfMut(map, (k: rs.u8, _310: rs.Place): boolean => { return k > 9; }); - rt.hashExtractKeysIf(set, (k2: rt.u8): boolean => { + rs.hashExtractKeysIf(set, (k2: rs.u8): boolean => { return k2 > 9; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "ExtractIf")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "ExtractIf"))]; - put(out, rt.fmtFormat([args18[0], "|", rt.fmtSpec({ alternate: true }, args18[1])])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "ExtractIf"))]; + put(out, rs.fmtFormat([args18[0], "|", rs.fmtSpec({ alternate: true }, args18[1])])); } -export function fronts$sets_collections_btree_set_Difference_tuple2_u8_char(it: rt.Iter<[rt.u8, rt.char]>, front: rt.usize): rt.Iter<[rt.u8, rt.char]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_Difference_tuple2_u8_char(it: rs.Iter<[rs.u8, rs.char]>, front: rs.usize): rs.Iter<[rs.u8, rs.char]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_btree_set_Difference_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_Difference_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_btree_set_Intersection_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_Intersection_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_btree_set_SymmetricDifference_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_SymmetricDifference_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_btree_set_Union_tuple2_u8_char(it: rt.Iter<[rt.u8, rt.char]>, front: rt.usize): rt.Iter<[rt.u8, rt.char]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_Union_tuple2_u8_char(it: rs.Iter<[rs.u8, rs.char]>, front: rs.usize): rs.Iter<[rs.u8, rs.char]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_btree_set_Union_u8(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_btree_set_Union_u8(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_linked_list_ExtractIf_fmt_Pair_fmt_sets_closure7(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$sets_collections_linked_list_ExtractIf_u8_fmt_sets_closure5(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } /** `args` written to a [`Log`], made elsewhere than where they are written. */ -export function passed(out: rt.ByteVec, budget: rt.usize, args: rt.Arguments): void { - let _23!: rt.char; - let _34!: rt.char; - const iter: rt.Iter = rt.iterSlice([4294967295, budget]); +export function passed(out: rs.ByteVec, budget: rs.usize, args: rs.Arguments): void { + let _23!: rs.char; + let _34!: rs.char; + const iter: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _7: rt.usize | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: rs.usize | rs.Done = iter.next(); + if (_7 === rs.DONE) { break; } const log: Log.Log = Log.new(_7); - const args3: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtArguments(args, f)]; - const _14: rt.Arguments = [args3[0]]; - if (!rt.fmtWrite((s) => Log.writeStr$fmt_Write(log, s), (c) => Log.writeChar$fmt_Write(log, c), _14).ok) { + const args3: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtArguments(args, f)]; + const _14: rs.Arguments = [args3[0]]; + if (!rs.fmtWrite((s) => Log.writeStr$fmt_Write(log, s), (c) => Log.writeChar$fmt_Write(log, c), _14).ok) { _23 = 45; } else { _23 = 43; @@ -4386,7 +4386,7 @@ export function passed(out: rt.ByteVec, budget: rt.usize, args: rt.Arguments): v put(out, log.text); } const log2: Log.Log = Log.new(budget); - if (!rt.fmtWrite((s2) => Log.writeStr$fmt_Write(log2, s2), (c2) => Log.writeChar$fmt_Write(log2, c2), args).ok) { + if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log2, s2), (c2) => Log.writeChar$fmt_Write(log2, c2), args).ok) { _34 = 45; } else { _34 = 43; @@ -4400,39 +4400,39 @@ export function passed(out: rt.ByteVec, budget: rt.usize, args: rt.Arguments): v * sign, digits, a float's parts, a string's escapes in runs, and the builders' pieces, and * where a call that fails stops the rest. */ -export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { - let _56!: rt.char; - let _132!: rt.char; - let x!: rt.f64; - let _166!: rt.char; - let _198!: rt.char; - let _265!: rt.char; - let _291!: rt.char; - let _316!: rt.char; - let _378!: rt.char; - let _450!: rt.char; - let _524!: rt.char; - let _575!: rt.char; - let _603!: rt.char; - let _633!: rt.char; - let _676!: rt.char; - let _740!: rt.char; - let _775!: rt.char; - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function calls(data: rs.ByteSlice, out: rs.ByteVec): void { + let _56!: rs.char; + let _132!: rs.char; + let x!: rs.f64; + let _166!: rs.char; + let _198!: rs.char; + let _265!: rs.char; + let _291!: rs.char; + let _316!: rs.char; + let _378!: rs.char; + let _450!: rs.char; + let _524!: rs.char; + let _575!: rs.char; + let _603!: rs.char; + let _633!: rs.char; + let _676!: rs.char; + let _740!: rs.char; + let _775!: rs.char; + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const budget: rt.usize = rt.u8Rem(at(0), 64) as rt.usize; - const v: rt.i32 = rt.i32Shr((at(1) << 24) | (at(2) << 16) | (at(3) << 8) | at(4), rt.u8Rem(at(5), 32)); - const iter: rt.Iter = rt.iterSlice([4294967295, budget]); + const budget: rs.usize = rs.u8Rem(at(0), 64) as rs.usize; + const v: rs.i32 = rs.i32Shr((at(1) << 24) | (at(2) << 16) | (at(3) << 8) | at(4), rs.u8Rem(at(5), 32)); + const iter: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _34: rt.usize | rt.Done = iter.next(); - if (_34 === rt.DONE) { + const _34: rs.usize | rs.Done = iter.next(); + if (_34 === rs.DONE) { break; } const log: Log.Log = Log.new(_34); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v, f), (f: rt.Formatter) => rt.i32LowerHex(v, f), (f: rt.Formatter) => rt.i32Binary(v, f), (f: rt.Formatter) => rt.i32Octal(v, f), (f: rt.Formatter) => rt.i32Debug(v, f), (f: rt.Formatter) => rt.i32LowerExp(v, f), (f: rt.Formatter) => rt.i32UpperExp(v, f)]; - const _41: rt.Arguments = ["a", rt.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", args2[0], "|", rt.fmtSpec({ align: "<", plus: true, width: 6 }, args2[0]), "|", rt.fmtSpec({ align: "^", alternate: true, width: 9 }, args2[1]), "|", rt.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", rt.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), "|", rt.fmtSpec({ plus: true, alternate: true }, args2[3]), "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ alternate: true }, args2[4]), "|", rt.fmtSpec({ debugHex: "x" }, args2[4]), "|", args2[5], "|", rt.fmtSpec({ precision: 3 }, args2[5]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12, precision: 2 }, args2[6]), "|", rt.fmtSpec({ fill: "*", align: "^", width: 12 }, args2[5]), "|", rt.fmtSpec({ precision: 0 }, args2[5]), "|", rt.fmtSpec({ precision: 12 }, args2[5]), "|", rt.fmtSpec({ alternate: true }, args2[5])]; - if (!rt.fmtWrite((s2) => Log.writeStr$fmt_Write(log, s2), (c2) => Log.writeChar$fmt_Write(log, c2), _41).ok) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => rs.i32LowerHex(v, f), (f: rs.Formatter) => rs.i32Binary(v, f), (f: rs.Formatter) => rs.i32Octal(v, f), (f: rs.Formatter) => rs.i32Debug(v, f), (f: rs.Formatter) => rs.i32LowerExp(v, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; + const _41: rs.Arguments = ["a", rs.fmtSpec({ align: ">", width: 4 }, args2[0]), "|", args2[0], "|", rs.fmtSpec({ align: "<", plus: true, width: 6 }, args2[0]), "|", rs.fmtSpec({ align: "^", alternate: true, width: 9 }, args2[1]), "|", rs.fmtSpec({ zero: true, width: 8 }, args2[0]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 10 }, args2[2]), "|", rs.fmtSpec({ plus: true, alternate: true }, args2[3]), "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ alternate: true }, args2[4]), "|", rs.fmtSpec({ debugHex: "x" }, args2[4]), "|", args2[5], "|", rs.fmtSpec({ precision: 3 }, args2[5]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12, precision: 2 }, args2[6]), "|", rs.fmtSpec({ fill: "*", align: "^", width: 12 }, args2[5]), "|", rs.fmtSpec({ precision: 0 }, args2[5]), "|", rs.fmtSpec({ precision: 12 }, args2[5]), "|", rs.fmtSpec({ alternate: true }, args2[5])]; + if (!rs.fmtWrite((s2) => Log.writeStr$fmt_Write(log, s2), (c2) => Log.writeChar$fmt_Write(log, c2), _41).ok) { _56 = 45; } else { _56 = 43; @@ -4440,20 +4440,20 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log.text = log.text + String.fromCodePoint(_56); put(out, log.text); } - const w: rt.u64 = rt.u64FromBeBytes(Uint8Array.of(at(6), at(7), at(8), at(9), at(1), at(2), at(3), at(4))); - const n: rt.i128 = rt.i128Mul(v as rt.i128, rt.i128Neg(rt.i128Shl(1, 70))); - const iter2: rt.Iter = rt.iterSlice([4294967295, budget]); + const w: rs.u64 = rs.u64FromBeBytes(Uint8Array.of(at(6), at(7), at(8), at(9), at(1), at(2), at(3), at(4))); + const n: rs.i128 = rs.i128Mul(v as rs.i128, rs.i128Neg(rs.i128Shl(1, 70))); + const iter2: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _99: rt.usize | rt.Done = iter2.next(); - if (_99 === rt.DONE) { + const _99: rs.usize | rs.Done = iter2.next(); + if (_99 === rs.DONE) { break; } const log2: Log.Log = Log.new(_99); - const _109: rt.u8 = at(6); - const _113: rt.i8 = (at(7) << 24) >> 24; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(w, f), (f: rt.Formatter) => rt.u64LowerHex(w, f), (f: rt.Formatter) => rt.i128Display(n, f), (f: rt.Formatter) => rt.i128LowerExp(n, f), (f: rt.Formatter) => rt.u8Display(_109, f), (f: rt.Formatter) => rt.i8LowerHex(_113, f), (f: rt.Formatter) => rt.i32UpperExp(v, f)]; - const _106: rt.Arguments = [rt.fmtSpec({ align: ">", width: 24 }, args4[0]), "|", rt.fmtSpec({ alternate: true }, args4[1]), "|", args4[2], "|", rt.fmtSpec({ plus: true, zero: true, width: 45 }, args4[2]), "|", args4[3], "|", rt.fmtSpec({ align: ">", width: 5 }, args4[4]), "|", rt.fmtSpec({ alternate: true, zero: true, width: 6 }, args4[5]), "|", rt.fmtSpec({ precision: 45 }, args4[6])]; - if (!rt.fmtWrite((s3) => Log.writeStr$fmt_Write(log2, s3), (c3) => Log.writeChar$fmt_Write(log2, c3), _106).ok) { + const _109: rs.u8 = at(6); + const _113: rs.i8 = (at(7) << 24) >> 24; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(w, f), (f: rs.Formatter) => rs.u64LowerHex(w, f), (f: rs.Formatter) => rs.i128Display(n, f), (f: rs.Formatter) => rs.i128LowerExp(n, f), (f: rs.Formatter) => rs.u8Display(_109, f), (f: rs.Formatter) => rs.i8LowerHex(_113, f), (f: rs.Formatter) => rs.i32UpperExp(v, f)]; + const _106: rs.Arguments = [rs.fmtSpec({ align: ">", width: 24 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2], "|", rs.fmtSpec({ plus: true, zero: true, width: 45 }, args4[2]), "|", args4[3], "|", rs.fmtSpec({ align: ">", width: 5 }, args4[4]), "|", rs.fmtSpec({ alternate: true, zero: true, width: 6 }, args4[5]), "|", rs.fmtSpec({ precision: 45 }, args4[6])]; + if (!rs.fmtWrite((s3) => Log.writeStr$fmt_Write(log2, s3), (c3) => Log.writeChar$fmt_Write(log2, c3), _106).ok) { _132 = 45; } else { _132 = 43; @@ -4461,7 +4461,7 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log2.text = log2.text + String.fromCodePoint(_132); put(out, log2.text); } - const _139: rt.u8 = rt.u8Rem(at(10), 9); + const _139: rs.u8 = rs.u8Rem(at(10), 9); if (_139 === 0) { x = NaN; } else if (_139 === 1) { @@ -4479,18 +4479,18 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_139 === 7) { x = 2.0; } else { - x = rt.f64FromBits(w); + x = rs.f64FromBits(w); } - const iter3: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter3: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _147: rt.usize | rt.Done = iter3.next(); - if (_147 === rt.DONE) { + const _147: rs.usize | rs.Done = iter3.next(); + if (_147 === rs.DONE) { break; } const log3: Log.Log = Log.new(_147); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(x, f), (f: rt.Formatter) => rt.f64Debug(x, f), (f: rt.Formatter) => rt.f64LowerExp(x, f), (f: rt.Formatter) => rt.f64UpperExp(x, f)]; - const _154: rt.Arguments = [args6[0], "|", args6[1], "|", rt.fmtSpec({ width: 10, precision: 3 }, args6[0]), "|", rt.fmtSpec({ align: "<", plus: true, width: 12 }, args6[0]), "|", rt.fmtSpec({ align: "^", zero: true, width: 12, precision: 1 }, args6[0]), "|", args6[2], "|", rt.fmtSpec({ precision: 2 }, args6[2]), "|", rt.fmtSpec({ precision: 30 }, args6[0]), "|", rt.fmtSpec({ alternate: true }, args6[1]), "|", rt.fmtSpec({ plus: true, precision: 0 }, args6[0]), "|", rt.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", args6[3], "|", rt.fmtSpec({ zero: true, width: 8 }, args6[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 9, precision: 3 }, args6[2]), "|", rt.fmtSpec({ precision: 0 }, args6[2])]; - if (!rt.fmtWrite((s4) => Log.writeStr$fmt_Write(log3, s4), (c4) => Log.writeChar$fmt_Write(log3, c4), _154).ok) { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64Debug(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f64UpperExp(x, f)]; + const _154: rs.Arguments = [args6[0], "|", args6[1], "|", rs.fmtSpec({ width: 10, precision: 3 }, args6[0]), "|", rs.fmtSpec({ align: "<", plus: true, width: 12 }, args6[0]), "|", rs.fmtSpec({ align: "^", zero: true, width: 12, precision: 1 }, args6[0]), "|", args6[2], "|", rs.fmtSpec({ precision: 2 }, args6[2]), "|", rs.fmtSpec({ precision: 30 }, args6[0]), "|", rs.fmtSpec({ alternate: true }, args6[1]), "|", rs.fmtSpec({ plus: true, precision: 0 }, args6[0]), "|", rs.fmtSpec({ align: ">", width: 9 }, args6[1]), "|", args6[3], "|", rs.fmtSpec({ zero: true, width: 8 }, args6[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 9, precision: 3 }, args6[2]), "|", rs.fmtSpec({ precision: 0 }, args6[2])]; + if (!rs.fmtWrite((s4) => Log.writeStr$fmt_Write(log3, s4), (c4) => Log.writeChar$fmt_Write(log3, c4), _154).ok) { _166 = 45; } else { _166 = 43; @@ -4498,17 +4498,17 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log3.text = log3.text + String.fromCodePoint(_166); put(out, log3.text); } - const y: rt.f32 = Math.fround(x); - const iter4: rt.Iter = rt.iterSlice([4294967295, budget]); + const y: rs.f32 = Math.fround(x); + const iter4: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _177: rt.usize | rt.Done = iter4.next(); - if (_177 === rt.DONE) { + const _177: rs.usize | rs.Done = iter4.next(); + if (_177 === rs.DONE) { break; } const log4: Log.Log = Log.new(_177); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.f64Display(x, f), (f: rt.Formatter) => rt.f64LowerExp(x, f), (f: rt.Formatter) => rt.f32Display(y, f), (f: rt.Formatter) => rt.f32Debug(y, f), (f: rt.Formatter) => rt.f32LowerExp(y, f)]; - const _184: rt.Arguments = [rt.fmtSpec({ precision: 70 }, args8[0]), "|", rt.fmtSpec({ precision: 330 }, args8[0]), "|", rt.fmtSpec({ precision: 20 }, args8[1]), "|", args8[2], "|", args8[3], "|", rt.fmtSpec({ precision: 3 }, args8[2]), "|", args8[4], "|", rt.fmtSpec({ precision: 12 }, args8[4]), "|", rt.fmtSpec({ precision: 50 }, args8[2])]; - if (!rt.fmtWrite((s5) => Log.writeStr$fmt_Write(log4, s5), (c5) => Log.writeChar$fmt_Write(log4, c5), _184).ok) { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.f64Display(x, f), (f: rs.Formatter) => rs.f64LowerExp(x, f), (f: rs.Formatter) => rs.f32Display(y, f), (f: rs.Formatter) => rs.f32Debug(y, f), (f: rs.Formatter) => rs.f32LowerExp(y, f)]; + const _184: rs.Arguments = [rs.fmtSpec({ precision: 70 }, args8[0]), "|", rs.fmtSpec({ precision: 330 }, args8[0]), "|", rs.fmtSpec({ precision: 20 }, args8[1]), "|", args8[2], "|", args8[3], "|", rs.fmtSpec({ precision: 3 }, args8[2]), "|", args8[4], "|", rs.fmtSpec({ precision: 12 }, args8[4]), "|", rs.fmtSpec({ precision: 50 }, args8[2])]; + if (!rs.fmtWrite((s5) => Log.writeStr$fmt_Write(log4, s5), (c5) => Log.writeChar$fmt_Write(log4, c5), _184).ok) { _198 = 45; } else { _198 = 43; @@ -4516,23 +4516,23 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log4.text = log4.text + String.fromCodePoint(_198); put(out, log4.text); } - const _206: rt.usize = rt.usizeRem(at(11) as rt.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); + const _206: rs.usize = rs.usizeRem(at(11) as rs.usize, ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"].length); if (!(_206 < 14)) { - rt.panic("index out of bounds: the len is " + 14 + " but the index is " + _206); + rs.panic("index out of bounds: the len is " + 14 + " but the index is " + _206); } const s: string = ["", "a", "héllo", "日本語", "tab\tnew\nline\r", "quote\"back\\slash'", "\u0000\u0001\u001f", "€Ÿ ­", "é", "‍ᅟ\u2028　", "͸􏿽𽀀𿱀", "😀 🇦", "ﾞﾟﾝ", "{}"][_206]; - const c: rt.char = option_unwrapOr$0k15iai(rt.charFromU32(rt.u32Mul(at(12) as rt.u32, 257)), 63); - const flag: boolean = rt.u8Rem(at(13), 2) === 0; - const iter5: rt.Iter = rt.iterSlice([4294967295, budget]); + const c: rs.char = option_unwrapOr$04rqm9m(rs.charFromU32(rs.u32Mul(at(12) as rs.u32, 257)), 63); + const flag: boolean = rs.u8Rem(at(13), 2) === 0; + const iter5: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _233: rt.usize | rt.Done = iter5.next(); - if (_233 === rt.DONE) { + const _233: rs.usize | rs.Done = iter5.next(); + if (_233 === rs.DONE) { break; } const log5: Log.Log = Log.new(_233); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s), (f: rt.Formatter) => rt.fmtStr(s, f), (f: rt.Formatter) => rt.fmtCharDisplay(c, f), (f: rt.Formatter) => rt.fmtCharDebug(c, f), (f: rt.Formatter) => rt.fmtCharDebug(39, f), (f: rt.Formatter) => rt.fmtCharDebug(34, f), (f: rt.Formatter) => rt.fmtCharDebug(769, f), (f: rt.Formatter) => rt.fmtCharDebug(233, f), (f: rt.Formatter) => rt.fmtBool(flag, f), (f: rt.Formatter) => rt.fmtUnit(undefined, f)]; - const _240: rt.Arguments = [args10[0], "|", args10[1], "|", rt.fmtSpec({ align: ">", width: 8 }, args10[0]), "|", rt.fmtSpec({ align: "^", width: 9, precision: 2 }, args10[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 3 }, args10[0]), "|", rt.fmtSpec({ alternate: true }, args10[1]), "|", args10[2], "|", args10[3], "|", rt.fmtSpec({ align: ">", width: 3 }, args10[2]), "|", rt.fmtSpec({ precision: 0 }, args10[2]), "|", rt.fmtSpec({ align: "^", width: 5 }, args10[3]), "|", args10[4], args10[5], args10[6], args10[7], "|", args10[8], "|", args10[9], "|", rt.fmtSpec({ align: ">", width: 7 }, args10[8])]; - if (!rt.fmtWrite((s6) => Log.writeStr$fmt_Write(log5, s6), (c6) => Log.writeChar$fmt_Write(log5, c6), _240).ok) { + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s), (f: rs.Formatter) => rs.fmtStr(s, f), (f: rs.Formatter) => rs.fmtCharDisplay(c, f), (f: rs.Formatter) => rs.fmtCharDebug(c, f), (f: rs.Formatter) => rs.fmtCharDebug(39, f), (f: rs.Formatter) => rs.fmtCharDebug(34, f), (f: rs.Formatter) => rs.fmtCharDebug(769, f), (f: rs.Formatter) => rs.fmtCharDebug(233, f), (f: rs.Formatter) => rs.fmtBool(flag, f), (f: rs.Formatter) => rs.fmtUnit(undefined, f)]; + const _240: rs.Arguments = [args10[0], "|", args10[1], "|", rs.fmtSpec({ align: ">", width: 8 }, args10[0]), "|", rs.fmtSpec({ align: "^", width: 9, precision: 2 }, args10[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 3 }, args10[0]), "|", rs.fmtSpec({ alternate: true }, args10[1]), "|", args10[2], "|", args10[3], "|", rs.fmtSpec({ align: ">", width: 3 }, args10[2]), "|", rs.fmtSpec({ precision: 0 }, args10[2]), "|", rs.fmtSpec({ align: "^", width: 5 }, args10[3]), "|", args10[4], args10[5], args10[6], args10[7], "|", args10[8], "|", args10[9], "|", rs.fmtSpec({ align: ">", width: 7 }, args10[8])]; + if (!rs.fmtWrite((s6) => Log.writeStr$fmt_Write(log5, s6), (c6) => Log.writeChar$fmt_Write(log5, c6), _240).ok) { _265 = 45; } else { _265 = 43; @@ -4541,16 +4541,16 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, log5.text); } const value: Nested.Nested = nested(data); - const iter6: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter6: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _275: rt.usize | rt.Done = iter6.next(); - if (_275 === rt.DONE) { + const _275: rs.usize | rs.Done = iter6.next(); + if (_275 === rs.DONE) { break; } const log6: Log.Log = Log.new(_275); - const args12: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - const _282: rt.Arguments = [args12[0]]; - if (!rt.fmtWrite((s7) => Log.writeStr$fmt_Write(log6, s7), (c7) => Log.writeChar$fmt_Write(log6, c7), _282).ok) { + const args12: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + const _282: rs.Arguments = [args12[0]]; + if (!rs.fmtWrite((s7) => Log.writeStr$fmt_Write(log6, s7), (c7) => Log.writeChar$fmt_Write(log6, c7), _282).ok) { _291 = 45; } else { _291 = 43; @@ -4558,16 +4558,16 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log6.text = log6.text + String.fromCodePoint(_291); put(out, log6.text); } - const iter7: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter7: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _300: rt.usize | rt.Done = iter7.next(); - if (_300 === rt.DONE) { + const _300: rs.usize | rs.Done = iter7.next(); + if (_300 === rs.DONE) { break; } const log7: Log.Log = Log.new(_300); - const args14: rt.Fmt[] = [(f: rt.Formatter) => Nested.fmt$fmt_Debug(value, f)]; - const _307: rt.Arguments = [rt.fmtSpec({ alternate: true }, args14[0])]; - if (!rt.fmtWrite((s8) => Log.writeStr$fmt_Write(log7, s8), (c8) => Log.writeChar$fmt_Write(log7, c8), _307).ok) { + const args14: rs.Fmt[] = [(f: rs.Formatter) => Nested.fmt$fmt_Debug(value, f)]; + const _307: rs.Arguments = [rs.fmtSpec({ alternate: true }, args14[0])]; + if (!rs.fmtWrite((s8) => Log.writeStr$fmt_Write(log7, s8), (c8) => Log.writeChar$fmt_Write(log7, c8), _307).ok) { _316 = 45; } else { _316 = 43; @@ -4575,23 +4575,23 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log7.text = log7.text + String.fromCodePoint(_316); put(out, log7.text); } - const manual: Manual.Manual = { id: at(14), list: rt.vecFrom([1, 2].slice()) }; - const seq: Seq.Seq = { _0: rt.vecFrom([{ _0: at(15), _1: -2 }].slice()) }; - const iter8: rt.Iter = rt.iterSlice([4294967295, budget]); + const manual: Manual.Manual = { id: at(14), list: rs.vecFrom([1, 2].slice()) }; + const seq: Seq.Seq = { _0: rs.vecFrom([{ _0: at(15), _1: -2 }].slice()) }; + const iter8: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _341: rt.usize | rt.Done = iter8.next(); - if (_341 === rt.DONE) { + const _341: rs.usize | rs.Done = iter8.next(); + if (_341 === rs.DONE) { break; } const log8: Log.Log = Log.new(_341); const _351: Tup.Tup = { _0: at(16), _1: undefined }; - const _358: [rt.u8] = [at(17)]; + const _358: [rs.u8] = [at(17)]; const _356: Tup.Tup = { _0: 1, _1: 2 }; - const _362: [rt.i32, string] = [1, "t"]; + const _362: [rs.i32, string] = [1, "t"]; const _363: Unit.Unit = {}; - const args16: rt.Fmt[] = [(f: rt.Formatter) => Tup.fmt$fmt_Debug(_351, f), (f: rt.Formatter) => Tup.fmt$fmt_Debug(_356, f), (f: rt.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rt.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u8Debug(_358[0], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.i32Debug(_362[0], f), (f: rt.Formatter) => rt.fmtStr(_362[1], f)], f), (f: rt.Formatter) => Unit.fmt$fmt_Debug(_363, f)]; - const _348: rt.Arguments = [args16[0], "|", rt.fmtSpec({ alternate: true }, args16[1]), "|", args16[2], "|", rt.fmtSpec({ alternate: true }, args16[2]), "|", rt.fmtSpec({ alternate: true }, args16[3]), "|", args16[4], "|", rt.fmtSpec({ alternate: true }, args16[5]), "|", args16[6]]; - if (!rt.fmtWrite((s9) => Log.writeStr$fmt_Write(log8, s9), (c9) => Log.writeChar$fmt_Write(log8, c9), _348).ok) { + const args16: rs.Fmt[] = [(f: rs.Formatter) => Tup.fmt$fmt_Debug(_351, f), (f: rs.Formatter) => Tup.fmt$fmt_Debug(_356, f), (f: rs.Formatter) => Manual.fmt$fmt_Debug(manual, f), (f: rs.Formatter) => Seq.fmt$fmt_Debug(seq, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u8Debug(_358[0], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.i32Debug(_362[0], f), (f: rs.Formatter) => rs.fmtStr(_362[1], f)], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_363, f)]; + const _348: rs.Arguments = [args16[0], "|", rs.fmtSpec({ alternate: true }, args16[1]), "|", args16[2], "|", rs.fmtSpec({ alternate: true }, args16[2]), "|", rs.fmtSpec({ alternate: true }, args16[3]), "|", args16[4], "|", rs.fmtSpec({ alternate: true }, args16[5]), "|", args16[6]]; + if (!rs.fmtWrite((s9) => Log.writeStr$fmt_Write(log8, s9), (c9) => Log.writeChar$fmt_Write(log8, c9), _348).ok) { _378 = 45; } else { _378 = 43; @@ -4599,33 +4599,33 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log8.text = log8.text + String.fromCodePoint(_378); put(out, log8.text); } - const _385: rt.Iter<[rt.u8, string]> = rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 3), (_2: rt.u8): [rt.u8, string] => { - return [rt.u8Rem(_2, 8), "v"] as [rt.u8, string]; + const _385: rs.Iter<[rs.u8, string]> = rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 3), (_2: rs.u8): [rs.u8, string] => { + return [rs.u8Rem(_2, 8), "v"] as [rs.u8, string]; }); - const map: rt.BTreeMap = rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _385, true, undefined, undefined, undefined, 12, true); - const _389: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 2); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _389, true, undefined, undefined, 1, true); - const deque: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 2), (_23: rt.u8): rt.i8 => { + const map: rs.BTreeMap = rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _385, true, undefined, undefined, undefined, 12, true); + const _389: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 2); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _389, true, undefined, undefined, 1, true); + const deque: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 2), (_23: rs.u8): rs.i8 => { return (_23 << 24) >> 24; - }), undefined, 1, true), 1) as rt.VecDeque; - const range: rt.RangeInclusive = new rt.RangeInclusive(1, rt.u8Rem(at(18), 3), rt.u8Step); - const iter9: rt.RangeInclusive = range; - while (iter9.next() !== rt.DONE) { + }), undefined, 1, true), 1) as rs.VecDeque; + const range: rs.RangeInclusive = new rs.RangeInclusive(1, rs.u8Rem(at(18), 3), rs.u8Step); + const iter9: rs.RangeInclusive = range; + while (iter9.next() !== rs.DONE) { } - const iter10: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter10: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _411: rt.usize | rt.Done = iter10.next(); - if (_411 === rt.DONE) { + const _411: rs.usize | rs.Done = iter10.next(); + if (_411 === rs.DONE) { break; } const log9: Log.Log = Log.new(_411); - const _421: rt.Result | undefined = rt.Ok(at(19)); - const _428: { end: rt.u8 } = { end: at(20) }; - const _426: rt.u8 | undefined = undefined; - const _432: rt.RangeBound = { tag: "Included", _0: 3 } as rt.RangeBound; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtMap(rt.btreeIter(map), f, rt.u8Debug, rt.fmtStr), (f: rt.Formatter) => rt.fmtSet(rt.btreeKeys(set), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.dequeIter(deque), f, rt.i8Debug), (f: rt.Formatter) => rt.fmtOption(_421, f, (value: rt.Result, f: rt.Formatter) => rt.fmtResult(value, f, rt.u8Debug, rt.fmtUnit)), (f: rt.Formatter) => rt.fmtOption(_426, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeInclusive(range, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtRangeTo(_428, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtBound(_432, f, rt.i32Debug)]; - const _418: rt.Arguments = [args18[0], "|", rt.fmtSpec({ alternate: true }, args18[0]), "|", args18[1], "|", rt.fmtSpec({ alternate: true }, args18[1]), "|", args18[2], "|", args18[3], "|", args18[4], "|", args18[5], "|", args18[6], "|", args18[7]]; - if (!rt.fmtWrite((s10) => Log.writeStr$fmt_Write(log9, s10), (c10) => Log.writeChar$fmt_Write(log9, c10), _418).ok) { + const _421: rs.Result | undefined = rs.Ok(at(19)); + const _428: { end: rs.u8 } = { end: at(20) }; + const _426: rs.u8 | undefined = undefined; + const _432: rs.RangeBound = { tag: "Included", _0: 3 } as rs.RangeBound; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtMap(rs.btreeIter(map), f, rs.u8Debug, rs.fmtStr), (f: rs.Formatter) => rs.fmtSet(rs.btreeKeys(set), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.dequeIter(deque), f, rs.i8Debug), (f: rs.Formatter) => rs.fmtOption(_421, f, (value: rs.Result, f: rs.Formatter) => rs.fmtResult(value, f, rs.u8Debug, rs.fmtUnit)), (f: rs.Formatter) => rs.fmtOption(_426, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeInclusive(range, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtRangeTo(_428, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtBound(_432, f, rs.i32Debug)]; + const _418: rs.Arguments = [args18[0], "|", rs.fmtSpec({ alternate: true }, args18[0]), "|", args18[1], "|", rs.fmtSpec({ alternate: true }, args18[1]), "|", args18[2], "|", args18[3], "|", args18[4], "|", args18[5], "|", args18[6], "|", args18[7]]; + if (!rs.fmtWrite((s10) => Log.writeStr$fmt_Write(log9, s10), (c10) => Log.writeChar$fmt_Write(log9, c10), _418).ok) { _450 = 45; } else { _450 = 43; @@ -4633,33 +4633,33 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log9.text = log9.text + String.fromCodePoint(_450); put(out, log9.text); } - const bytes: rt.Iter = rt.byteSliceEscapeAscii(data); - if (rt.u8Rem(at(21), 2) === 0) { + const bytes: rs.Iter = rs.byteSliceEscapeAscii(data); + if (rs.u8Rem(at(21), 2) === 0) { bytes.next(); } - if (rt.u8Rem(at(22), 2) === 0) { - rt.iterToOption(bytes.nextBack()); + if (rs.u8Rem(at(22), 2) === 0) { + rs.iterToOption(bytes.nextBack()); } - const spent: rt.Iter = rt.charEscapeDebug(c); + const spent: rs.Iter = rs.charEscapeDebug(c); spent.next(); - const iter11: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter11: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _479: rt.usize | rt.Done = iter11.next(); - if (_479 === rt.DONE) { + const _479: rs.usize | rs.Done = iter11.next(); + if (_479 === rs.DONE) { break; } const log10: Log.Log = Log.new(_479); - const _489: rt.Iter = rt.escapeAscii(10); - rt.escapeAscii(113); - const _493: rt.Iter = rt.charEscapeDebug(c); - const _495: rt.Iter = rt.charEscapeDefault(c); - const _497: rt.Iter = rt.charEscapeUnicode(c); - const _499: rt.Iter = rt.charToUppercase(223); - const _501: rt.Iter = rt.strEscapeDebug(s); - const _503: rt.Iter = rt.strEscapeDefault("a\""); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtEscapeAscii(bytes, f), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "EscapeAscii")), (f: rt.Formatter) => rt.fmtEscapeAscii(_489, f), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "EscapeDefault")), (f: rt.Formatter) => rt.fmtCharsDisplay(_493, f), (f: rt.Formatter) => rt.fmtCharsDisplay(_495, f), (f: rt.Formatter) => rt.fmtCharsDisplay(_497, f), (f: rt.Formatter) => rt.fmtCharsDisplay(_499, f), (f: rt.Formatter) => rt.fmtCharsDisplay(spent, f), (f: rt.Formatter) => rt.fmtCharsDebug(spent, f, "EscapeDebug"), (f: rt.Formatter) => rt.fmtStrEscapeDisplay(_501, f), (f: rt.Formatter) => rt.fmtStrEscapeDisplay(_503, f)]; - const _486: rt.Arguments = [args20[0], "|", args20[1], "|", args20[2], "|", args20[3], "|", args20[4], "|", args20[5], "|", args20[6], "|", args20[7], "|", args20[8], "|", args20[9], "|", args20[10], "|", args20[11]]; - if (!rt.fmtWrite((s11) => Log.writeStr$fmt_Write(log10, s11), (c11) => Log.writeChar$fmt_Write(log10, c11), _486).ok) { + const _489: rs.Iter = rs.escapeAscii(10); + rs.escapeAscii(113); + const _493: rs.Iter = rs.charEscapeDebug(c); + const _495: rs.Iter = rs.charEscapeDefault(c); + const _497: rs.Iter = rs.charEscapeUnicode(c); + const _499: rs.Iter = rs.charToUppercase(223); + const _501: rs.Iter = rs.strEscapeDebug(s); + const _503: rs.Iter = rs.strEscapeDefault("a\""); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtEscapeAscii(bytes, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeAscii")), (f: rs.Formatter) => rs.fmtEscapeAscii(_489, f), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EscapeDefault")), (f: rs.Formatter) => rs.fmtCharsDisplay(_493, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_495, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_497, f), (f: rs.Formatter) => rs.fmtCharsDisplay(_499, f), (f: rs.Formatter) => rs.fmtCharsDisplay(spent, f), (f: rs.Formatter) => rs.fmtCharsDebug(spent, f, "EscapeDebug"), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_501, f), (f: rs.Formatter) => rs.fmtStrEscapeDisplay(_503, f)]; + const _486: rs.Arguments = [args20[0], "|", args20[1], "|", args20[2], "|", args20[3], "|", args20[4], "|", args20[5], "|", args20[6], "|", args20[7], "|", args20[8], "|", args20[9], "|", args20[10], "|", args20[11]]; + if (!rs.fmtWrite((s11) => Log.writeStr$fmt_Write(log10, s11), (c11) => Log.writeChar$fmt_Write(log10, c11), _486).ok) { _524 = 45; } else { _524 = 43; @@ -4667,17 +4667,17 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log10.text = log10.text + String.fromCodePoint(_524); put(out, log10.text); } - const d: rt.Duration = rt.durationNew(rt.u64Mul(rt.u8Rem(at(23), 3) as rt.u64, at(24) as rt.u64), rt.u32Rem((at(25) << 16) | (at(26) << 8) | at(27), 1000000000)); - const iter12: rt.Iter = rt.iterSlice([4294967295, budget]); + const d: rs.Duration = rs.durationNew(rs.u64Mul(rs.u8Rem(at(23), 3) as rs.u64, at(24) as rs.u64), rs.u32Rem((at(25) << 16) | (at(26) << 8) | at(27), 1000000000)); + const iter12: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _559: rt.usize | rt.Done = iter12.next(); - if (_559 === rt.DONE) { + const _559: rs.usize | rs.Done = iter12.next(); + if (_559 === rs.DONE) { break; } const log11: Log.Log = Log.new(_559); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.durationDebug(d, f)]; - const _566: rt.Arguments = [args22[0], "|", rt.fmtSpec({ align: ">", width: 12 }, args22[0]), "|", rt.fmtSpec({ precision: 2 }, args22[0]), "|", rt.fmtSpec({ plus: true }, args22[0]), "|", rt.fmtSpec({ align: "^", width: 15, precision: 11 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 4, precision: 0 }, args22[0]), "|", rt.fmtSpec({ fill: "*", align: ">", width: 20, precision: 3 }, args22[0])]; - if (!rt.fmtWrite((s12) => Log.writeStr$fmt_Write(log11, s12), (c12) => Log.writeChar$fmt_Write(log11, c12), _566).ok) { + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.durationDebug(d, f)]; + const _566: rs.Arguments = [args22[0], "|", rs.fmtSpec({ align: ">", width: 12 }, args22[0]), "|", rs.fmtSpec({ precision: 2 }, args22[0]), "|", rs.fmtSpec({ plus: true }, args22[0]), "|", rs.fmtSpec({ align: "^", width: 15, precision: 11 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 4, precision: 0 }, args22[0]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 20, precision: 3 }, args22[0])]; + if (!rs.fmtWrite((s12) => Log.writeStr$fmt_Write(log11, s12), (c12) => Log.writeChar$fmt_Write(log11, c12), _566).ok) { _575 = 45; } else { _575 = 43; @@ -4685,19 +4685,19 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log11.text = log11.text + String.fromCodePoint(_575); put(out, log11.text); } - const _581: rt.Result = rt.strFromUtf8(data); + const _581: rs.Result = rs.strFromUtf8(data); if (_581.ok) { - const iter13: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter13: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _586: rt.usize | rt.Done = iter13.next(); - if (_586 === rt.DONE) { + const _586: rs.usize | rs.Done = iter13.next(); + if (_586 === rs.DONE) { break; } const log12: Log.Log = Log.new(_586); - const part8 = rt.byteSliceUtf8Chunks(data); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8Chunks(part8, f)]; - const _593: rt.Arguments = [args24[0]]; - if (!rt.fmtWrite((s14) => Log.writeStr$fmt_Write(log12, s14), (c14) => Log.writeChar$fmt_Write(log12, c14), _593).ok) { + const part8 = rs.byteSliceUtf8Chunks(data); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(part8, f)]; + const _593: rs.Arguments = [args24[0]]; + if (!rs.fmtWrite((s14) => Log.writeStr$fmt_Write(log12, s14), (c14) => Log.writeChar$fmt_Write(log12, c14), _593).ok) { _603 = 45; } else { _603 = 43; @@ -4706,18 +4706,18 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, log12.text); } } else { - const e: rt.Utf8Error = _581.error; - const iter14: rt.Iter = rt.iterSlice([4294967295, budget]); + const e: rs.Utf8Error = _581.error; + const iter14: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _613: rt.usize | rt.Done = iter14.next(); - if (_613 === rt.DONE) { + const _613: rs.usize | rs.Done = iter14.next(); + if (_613 === rs.DONE) { break; } const log13: Log.Log = Log.new(_613); - const _623: rt.Iter = rt.byteSliceUtf8Chunks(data); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtUtf8ErrorDebug(e, f), (f: rt.Formatter) => rt.fmtUtf8Chunks(_623, f)]; - const _620: rt.Arguments = [args26[0], "|", args26[1], "|", args26[2]]; - if (!rt.fmtWrite((s13) => Log.writeStr$fmt_Write(log13, s13), (c13) => Log.writeChar$fmt_Write(log13, c13), _620).ok) { + const _623: rs.Iter = rs.byteSliceUtf8Chunks(data); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f), (f: rs.Formatter) => rs.fmtUtf8Chunks(_623, f)]; + const _620: rs.Arguments = [args26[0], "|", args26[1], "|", args26[2]]; + if (!rs.fmtWrite((s13) => Log.writeStr$fmt_Write(log13, s13), (c13) => Log.writeChar$fmt_Write(log13, c13), _620).ok) { _633 = 45; } else { _633 = 43; @@ -4726,19 +4726,19 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, log13.text); } } - const _643: rt.Result = rt.strFromUtf8(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(97, 230, 151, at(32))), 0, rt.usizeAdd(3, rt.u8Rem(at(32), 2) as rt.usize))); + const _643: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(97, 230, 151, at(32))), 0, rs.usizeAdd(3, rs.u8Rem(at(32), 2) as rs.usize))); if (!_643.ok) { - const e2: rt.Utf8Error = _643.error; - const iter15: rt.Iter = rt.iterSlice([4294967295, budget]); + const e2: rs.Utf8Error = _643.error; + const iter15: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _660: rt.usize | rt.Done = iter15.next(); - if (_660 === rt.DONE) { + const _660: rs.usize | rs.Done = iter15.next(); + if (_660 === rs.DONE) { break; } const log14: Log.Log = Log.new(_660); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8ErrorDisplay(e2, f)]; - const _667: rt.Arguments = [args28[0]]; - if (!rt.fmtWrite((s15) => Log.writeStr$fmt_Write(log14, s15), (c15) => Log.writeChar$fmt_Write(log14, c15), _667).ok) { + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e2, f)]; + const _667: rs.Arguments = [args28[0]]; + if (!rs.fmtWrite((s15) => Log.writeStr$fmt_Write(log14, s15), (c15) => Log.writeChar$fmt_Write(log14, c15), _667).ok) { _676 = 45; } else { _676 = 43; @@ -4747,24 +4747,24 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, log14.text); } } - const layout: rt.Layout = rt.resultUnwrap(rt.layoutFromSizeAlign(at(28) as rt.usize, rt.usizeShl(1, rt.u8Rem(at(29), 8))), rt.fmtLayoutErrorDebug); - const reserve: rt.TryReserveError = rt.resultUnwrapErr(rt.byteVecTryReserve(new rt.ByteVec(), 4294967295), rt.fmtUnit); + const layout: rs.Layout = rs.resultUnwrap(rs.layoutFromSizeAlign(at(28) as rs.usize, rs.usizeShl(1, rs.u8Rem(at(29), 8))), rs.fmtLayoutErrorDebug); + const reserve: rs.TryReserveError = rs.resultUnwrapErr(rs.byteVecTryReserve(new rs.ByteVec(), 4294967295), rs.fmtUnit); new of$u8(at(33)); - const iter16: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter16: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _707: rt.usize | rt.Done = iter16.next(); - if (_707 === rt.DONE) { + const _707: rs.usize | rs.Done = iter16.next(); + if (_707 === rs.DONE) { break; } const log15: Log.Log = Log.new(_707); - new rt.Cell(1); - rt.strEncodeUtf16("ab"); - rt.iterRepeatWith((): rt.i32 => { + new rs.Cell(1); + rs.strEncodeUtf16("ab"); + rs.iterRepeatWith((): rs.i32 => { return 1; }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtLayoutDebug(layout, f), (f: rt.Formatter) => rt.fmtTryReserveErrorDisplay(reserve, f), (f: rt.Formatter) => rt.fmtTryReserveErrorDebug(reserve, f), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "Any")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "UnsafeCell")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "EncodeUtf16")), (f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "RepeatWith"))]; - const _714: rt.Arguments = [args30[0], "|", args30[1], "|", args30[2], "|", args30[3], "|", args30[4], "|", args30[5], "|", args30[6], "|", args30[7]]; - if (!rt.fmtWrite((s16) => Log.writeStr$fmt_Write(log15, s16), (c16) => Log.writeChar$fmt_Write(log15, c16), _714).ok) { + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtLayoutDebug(layout, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDisplay(reserve, f), (f: rs.Formatter) => rs.fmtTryReserveErrorDebug(reserve, f), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "Any")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "UnsafeCell")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16")), (f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "RepeatWith"))]; + const _714: rs.Arguments = [args30[0], "|", args30[1], "|", args30[2], "|", args30[3], "|", args30[4], "|", args30[5], "|", args30[6], "|", args30[7]]; + if (!rs.fmtWrite((s16) => Log.writeStr$fmt_Write(log15, s16), (c16) => Log.writeChar$fmt_Write(log15, c16), _714).ok) { _740 = 45; } else { _740 = 43; @@ -4772,19 +4772,19 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { log15.text = log15.text + String.fromCodePoint(_740); put(out, log15.text); } - const iter17: rt.Iter = rt.iterSlice([4294967295, budget]); + const iter17: rs.Iter = rs.iterSlice([4294967295, budget]); while (true) { - const _749: rt.usize | rt.Done = iter17.next(); - if (_749 === rt.DONE) { + const _749: rs.usize | rs.Done = iter17.next(); + if (_749 === rs.DONE) { break; } const log16: Log.Log = Log.new(_749); const _759: Lettered.Lettered = { _0: c }; - const _762: rt.u8 = at(30); + const _762: rs.u8 = at(30); const _760: Lettered.Lettered = { _0: 233 }; - const args32: rt.Fmt[] = [(f: rt.Formatter) => Lettered.fmt$fmt_Display(_759, f), (f: rt.Formatter) => Lettered.fmt$fmt_Display(_760, f), (f: rt.Formatter) => rt.u8Display(_762, f), (f: rt.Formatter) => rt.i32Display(v, f)]; - const _756: rt.Arguments = [args32[0], "|", rt.fmtSpec({ align: ">", width: 6 }, args32[1]), "|a", args32[2], "b", rt.fmtSpec({ align: ">", width: 3 }, args32[3])]; - if (!rt.fmtWrite((s17) => Log.writeStr$fmt_Write(log16, s17), (c17) => Log.writeChar$fmt_Write(log16, c17), _756).ok) { + const args32: rs.Fmt[] = [(f: rs.Formatter) => Lettered.fmt$fmt_Display(_759, f), (f: rs.Formatter) => Lettered.fmt$fmt_Display(_760, f), (f: rs.Formatter) => rs.u8Display(_762, f), (f: rs.Formatter) => rs.i32Display(v, f)]; + const _756: rs.Arguments = [args32[0], "|", rs.fmtSpec({ align: ">", width: 6 }, args32[1]), "|a", args32[2], "b", rs.fmtSpec({ align: ">", width: 3 }, args32[3])]; + if (!rs.fmtWrite((s17) => Log.writeStr$fmt_Write(log16, s17), (c17) => Log.writeChar$fmt_Write(log16, c17), _756).ok) { _775 = 45; } else { _775 = 43; @@ -4793,33 +4793,33 @@ export function calls(data: rt.ByteSlice, out: rt.ByteVec): void { put(out, log16.text); } const _785: Pair.Pair = { _0: at(31), _1: 1 }; - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(v, f), (f: rt.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rt.Formatter) => rt.fmtStr(s, f)]; - passed(out, budget, [rt.fmtSpec({ plus: true }, args34[0]), "|", args34[1], "|", args34[2]]); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(v, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(_785, f), (f: rs.Formatter) => rs.fmtStr(s, f)]; + passed(out, budget, [rs.fmtSpec({ plus: true }, args34[0]), "|", args34[1], "|", args34[2]]); passed(out, budget, ["lit"]); passed(out, budget, [""]); } /** `Debug` of cells that the writer sets as it is written, which shows when std reads each. */ -export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { - let _48!: rt.char; - const _5: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.usize, ["Cell", "OnceCell", "LazyCell", "OnceLock", "LazyLock", "(", " { "].length); +export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { + let _48!: rs.char; + const _5: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.usize, ["Cell", "OnceCell", "LazyCell", "OnceLock", "LazyLock", "(", " { "].length); if (!(_5 < 7)) { - rt.panic("index out of bounds: the len is " + 7 + " but the index is " + _5); + rs.panic("index out of bounds: the len is " + 7 + " but the index is " + _5); } - const cell: rt.Cell = new rt.Cell(1); - const once: rt.OnceCell = new rt.OnceCell(undefined); - const lazy: rt.LazyCell = new rt.LazyCell((): rt.u8 => { + const cell: rs.Cell = new rs.Cell(1); + const once: rs.OnceCell = new rs.OnceCell(undefined); + const lazy: rs.LazyCell = new rs.LazyCell((): rs.u8 => { return 5; }); - const lock: rt.OnceLock = new rt.OnceLock(undefined); - const forced: rt.LazyLock = new rt.LazyLock((): rt.u8 => { + const lock: rs.OnceLock = new rs.OnceLock(undefined); + const forced: rs.LazyLock = new rs.LazyLock((): rs.u8 => { return 6; }); const _4: string[] = ["Cell", "OnceCell", "LazyCell", "OnceLock", "LazyLock", "(", " { "]; const setter: Setter.Setter = { log: Log.new(4294967295), trigger: _4[_5], cell, once, lazy, lock, forced }; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.cellDebug(() => cell.v, f, rt.u8Debug), (f: rt.Formatter) => rt.onceDebug(once, f, "OnceCell", rt.u8Debug), (f: rt.Formatter) => lazy.debug(f, "LazyCell", rt.u8Debug), (f: rt.Formatter) => rt.onceDebug(lock, f, "OnceLock", rt.u8Debug), (f: rt.Formatter) => forced.debug(f, "LazyLock", rt.u8Debug)]; - const _31: rt.Arguments = [args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4], "|", args2[0], "|", args2[1]]; - if (!rt.fmtWrite((s) => Setter.writeStr$fmt_Write(setter, s), (c) => Setter.writeStr$fmt_Write(setter, String.fromCodePoint(c)), _31).ok) { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.cellDebug(() => cell.v, f, rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(once, f, "OnceCell", rs.u8Debug), (f: rs.Formatter) => lazy.debug(f, "LazyCell", rs.u8Debug), (f: rs.Formatter) => rs.onceDebug(lock, f, "OnceLock", rs.u8Debug), (f: rs.Formatter) => forced.debug(f, "LazyLock", rs.u8Debug)]; + const _31: rs.Arguments = [args2[0], "|", args2[1], "|", args2[2], "|", args2[3], "|", args2[4], "|", args2[0], "|", args2[1]]; + if (!rs.fmtWrite((s) => Setter.writeStr$fmt_Write(setter, s), (c) => Setter.writeStr$fmt_Write(setter, String.fromCodePoint(c)), _31).ok) { _48 = 45; } else { _48 = 43; @@ -4833,561 +4833,561 @@ export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { * read from either end, and past the end, plain, pretty, and in hex. A `&str`'s two-way * search keeps what it last compared, which a search that finds nothing leaves. */ -export function searches(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function searches(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _6: [rt.usize, rt.usize] = [rt.u8Rem(at(0), 6) as rt.usize, rt.u8Rem(at(1), 4) as rt.usize]; - const front: rt.usize = _6[0]; - const back: rt.usize = _6[1]; - const rest: rt.ByteSlice = option_unwrapOrDefault$0301ewp(rt.byteSliceGetRange(data, 4)); - const text2: string = rt.stringExtendChars("", rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(rest)), 10), (_2: rt.u8): rt.char => { - const _5: rt.usize = rt.u8Rem(_2, 9) as rt.usize; + const _6: [rs.usize, rs.usize] = [rs.u8Rem(at(0), 6) as rs.usize, rs.u8Rem(at(1), 4) as rs.usize]; + const front: rs.usize = _6[0]; + const back: rs.usize = _6[1]; + const rest: rs.ByteSlice = option_unwrapOrDefault$0avqj0t(rs.byteSliceGetRange(data, 4)); + const text2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 10), (_2: rs.u8): rs.char => { + const _5: rs.usize = rs.u8Rem(_2, 9) as rs.usize; if (!(_5 < 9)) { - rt.panic("index out of bounds: the len is " + 9 + " but the index is " + _5); + rs.panic("index out of bounds: the len is " + 9 + " but the index is " + _5); } return [97, 98, 233, 129408, 32, 10, 13, 12288, 9][_5]; })); - const _30: rt.usize = rt.u8Rem(at(2), 4) as rt.usize; + const _30: rs.usize = rs.u8Rem(at(2), 4) as rs.usize; if (!(_30 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); - } - const c: rt.char = [97, 233, 129408, 32][_30]; - const part = ends$searches_str_Split_char(rt.strSplit(text2, String.fromCodePoint(c)), front, back); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part, f, "Split", "CharSearcher")]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ alternate: true }, args2[0]), "|", rt.fmtSpec({ debugHex: "x" }, args2[0])])); - const part2 = ends$searches_str_RSplit_char(rt.strRsplit(text2, String.fromCodePoint(c)), front, back); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part2, f, "RSplit", "CharSearcher")]; - put(out, rt.fmtFormat([args4[0]])); - const part3 = ends$searches_str_SplitTerminator_char(rt.strSplitTerminator(text2, String.fromCodePoint(c)), front, back); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")]; - put(out, rt.fmtFormat([args6[0]])); - const part4 = ends$searches_str_RSplitTerminator_char(rt.strRsplitTerminator(text2, String.fromCodePoint(c)), front, back); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")]; - put(out, rt.fmtFormat([args8[0]])); - const part5 = fronts$searches_str_SplitN_char(rt.strSplitn(text2, rt.u8Rem(at(3), 4) as rt.usize, String.fromCodePoint(c)), front); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part5, f, "SplitN", "CharSearcher")]; - put(out, rt.fmtFormat([args10[0]])); - const part6 = fronts$searches_str_RSplitN_char(rt.strRsplitn(text2, 2, String.fromCodePoint(c)), front); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part6, f, "RSplitN", "CharSearcher")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args12[0])])); - const part7 = ends$searches_str_SplitInclusive_char(rt.strSplitInclusive(text2, String.fromCodePoint(c)), front, back); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")]; - put(out, rt.fmtFormat([args14[0]])); - const part8 = ends$searches_str_Matches_char(rt.strMatches(text2, String.fromCodePoint(c)), front, back); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part8, f, "Matches", "CharSearcher")]; - put(out, rt.fmtFormat([args16[0]])); - const part9 = ends$searches_str_RMatches_char(rt.strRmatches(text2, String.fromCodePoint(c)), front, back); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part9, f, "RMatches", "CharSearcher")]; - put(out, rt.fmtFormat([args18[0]])); - const part10 = ends$searches_str_MatchIndices_char(rt.strMatchIndices(text2, String.fromCodePoint(c)), front, back); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher")]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args20[0])])); - const part11 = ends$searches_str_RMatchIndices_char(rt.strRmatchIndices(text2, String.fromCodePoint(c)), front, back); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")]; - put(out, rt.fmtFormat([args22[0]])); - const set: rt.char[] = [c, 98]; - const part12 = ends$searches_str_Split_array2_char(rt.strSplit(text2, rt.patternChars(set)), front, back); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part12, f, "Split", "CharArraySearcher")]; - put(out, rt.fmtFormat([args24[0]])); - const part13 = ends$searches_str_Matches_ref_array2_char(rt.strMatches(text2, rt.patternChars(set)), front, back); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args26[0])])); - const part14 = ends$searches_str_RSplit_ref_slice_char(rt.strRsplit(text2, rt.patternChars(rt.sliceRange(set, 0, 1))), front, back); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")]; - put(out, rt.fmtFormat([args28[0]])); - const part15 = ends$searches_str_Split_fmt_searches_closure3(rt.strSplit(text2, (x: rt.char): boolean => { + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _30); + } + const c: rs.char = [97, 233, 129408, 32][_30]; + const part = ends$searches_str_Split_char(rs.strSplit(text2, String.fromCodePoint(c)), front, back); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part, f, "Split", "CharSearcher")]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ alternate: true }, args2[0]), "|", rs.fmtSpec({ debugHex: "x" }, args2[0])])); + const part2 = ends$searches_str_RSplit_char(rs.strRsplit(text2, String.fromCodePoint(c)), front, back); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part2, f, "RSplit", "CharSearcher")]; + put(out, rs.fmtFormat([args4[0]])); + const part3 = ends$searches_str_SplitTerminator_char(rs.strSplitTerminator(text2, String.fromCodePoint(c)), front, back); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part3, f, "SplitTerminator", "CharSearcher")]; + put(out, rs.fmtFormat([args6[0]])); + const part4 = ends$searches_str_RSplitTerminator_char(rs.strRsplitTerminator(text2, String.fromCodePoint(c)), front, back); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part4, f, "RSplitTerminator", "CharSearcher")]; + put(out, rs.fmtFormat([args8[0]])); + const part5 = fronts$searches_str_SplitN_char(rs.strSplitn(text2, rs.u8Rem(at(3), 4) as rs.usize, String.fromCodePoint(c)), front); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part5, f, "SplitN", "CharSearcher")]; + put(out, rs.fmtFormat([args10[0]])); + const part6 = fronts$searches_str_RSplitN_char(rs.strRsplitn(text2, 2, String.fromCodePoint(c)), front); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part6, f, "RSplitN", "CharSearcher")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args12[0])])); + const part7 = ends$searches_str_SplitInclusive_char(rs.strSplitInclusive(text2, String.fromCodePoint(c)), front, back); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part7, f, "SplitInclusive", "CharSearcher")]; + put(out, rs.fmtFormat([args14[0]])); + const part8 = ends$searches_str_Matches_char(rs.strMatches(text2, String.fromCodePoint(c)), front, back); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part8, f, "Matches", "CharSearcher")]; + put(out, rs.fmtFormat([args16[0]])); + const part9 = ends$searches_str_RMatches_char(rs.strRmatches(text2, String.fromCodePoint(c)), front, back); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part9, f, "RMatches", "CharSearcher")]; + put(out, rs.fmtFormat([args18[0]])); + const part10 = ends$searches_str_MatchIndices_char(rs.strMatchIndices(text2, String.fromCodePoint(c)), front, back); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part10, f, "MatchIndices", "CharSearcher")]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args20[0])])); + const part11 = ends$searches_str_RMatchIndices_char(rs.strRmatchIndices(text2, String.fromCodePoint(c)), front, back); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part11, f, "RMatchIndices", "CharSearcher")]; + put(out, rs.fmtFormat([args22[0]])); + const set: rs.char[] = [c, 98]; + const part12 = ends$searches_str_Split_array2_char(rs.strSplit(text2, rs.patternChars(set)), front, back); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part12, f, "Split", "CharArraySearcher")]; + put(out, rs.fmtFormat([args24[0]])); + const part13 = ends$searches_str_Matches_ref_array2_char(rs.strMatches(text2, rs.patternChars(set)), front, back); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part13, f, "Matches", "CharArrayRefSearcher")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args26[0])])); + const part14 = ends$searches_str_RSplit_ref_slice_char(rs.strRsplit(text2, rs.patternChars(rs.sliceRange(set, 0, 1))), front, back); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part14, f, "RSplit", "CharSliceSearcher")]; + put(out, rs.fmtFormat([args28[0]])); + const part15 = ends$searches_str_Split_fmt_searches_closure3(rs.strSplit(text2, (x: rs.char): boolean => { return x === c; }), front, back); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")]; - put(out, rt.fmtFormat([args30[0]])); - const part16 = ends$searches_str_MatchIndices_char_is_whitespace(rt.strMatchIndices(text2, (a0: rt.char): boolean => { - return rt.charIsWhitespace(a0); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part15, f, "Split", "CharPredicateSearcher")]; + put(out, rs.fmtFormat([args30[0]])); + const part16 = ends$searches_str_MatchIndices_char_is_whitespace(rs.strMatchIndices(text2, (a0: rs.char): boolean => { + return rs.charIsWhitespace(a0); }), front, back); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher")]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args32[0])])); - const few2: string = rt.stringExtendChars("", rt.iterMap(rt.iterTake(rt.iterSlice(rt.byteSliceView(rest)), 16), (_22: rt.u8): rt.char => { - const _53: rt.usize = rt.u8Rem(_22, 3) as rt.usize; + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part16, f, "MatchIndices", "CharPredicateSearcher")]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args32[0])])); + const few2: string = rs.stringExtendChars("", rs.iterMap(rs.iterTake(rs.iterSlice(rs.byteSliceView(rest)), 16), (_22: rs.u8): rs.char => { + const _53: rs.usize = rs.u8Rem(_22, 3) as rs.usize; if (!(_53 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _53); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _53); } return [97, 98, 233][_53]; })); - const _291: rt.usize = rt.u8Rem(at(2), 10) as rt.usize; + const _291: rs.usize = rs.u8Rem(at(2), 10) as rs.usize; if (!(_291 < 10)) { - rt.panic("index out of bounds: the len is " + 10 + " but the index is " + _291); + rs.panic("index out of bounds: the len is " + 10 + " but the index is " + _291); } const _281: string[] = ["", "a", "aa", "ab", "aab", "aba", "abab", "bé", "aaba", "éaé"]; - const part17 = fronts$searches_str_Split_ref_str(rt.strSplit(few2, _281[_291]), front); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part17, f, "Split", "StrSearcher")]; - put(out, rt.fmtFormat([args34[0], "|", rt.fmtSpec({ alternate: true }, args34[0]), "|", rt.fmtSpec({ debugHex: "x" }, args34[0])])); - const part18 = fronts$searches_str_RSplit_ref_str(rt.strRsplit(few2, _281[_291]), front); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part18, f, "RSplit", "StrSearcher")]; - put(out, rt.fmtFormat([args36[0]])); - const part19 = fronts$searches_str_SplitTerminator_ref_str(rt.strSplitTerminator(few2, _281[_291]), front); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")]; - put(out, rt.fmtFormat([args38[0]])); - const part20 = fronts$searches_str_SplitN_ref_str(rt.strSplitn(few2, rt.u8Rem(at(3), 4) as rt.usize, _281[_291]), front); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part20, f, "SplitN", "StrSearcher")]; - put(out, rt.fmtFormat([args40[0]])); - const part21 = fronts$searches_str_RSplitN_ref_str(rt.strRsplitn(few2, rt.u8Rem(at(3), 4) as rt.usize, _281[_291]), front); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")]; - put(out, rt.fmtFormat([args42[0]])); - const part22 = fronts$searches_str_SplitInclusive_ref_str(rt.strSplitInclusive(few2, _281[_291]), front); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")]; - put(out, rt.fmtFormat([args44[0]])); - const part23 = fronts$searches_str_Matches_ref_str(rt.strMatches(few2, _281[_291]), rt.usizeMul(front, 2)); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part23, f, "Matches", "StrSearcher")]; - put(out, rt.fmtFormat([args46[0]])); - const part24 = fronts$searches_str_RMatches_ref_str(rt.strRmatches(few2, _281[_291]), rt.usizeMul(front, 2)); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part24, f, "RMatches", "StrSearcher")]; - put(out, rt.fmtFormat([args48[0]])); - const part25 = fronts$searches_str_MatchIndices_ref_str(rt.strMatchIndices(few2, _281[_291]), front); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")]; - put(out, rt.fmtFormat([args50[0]])); - const part26 = fronts$searches_str_RMatchIndices_ref_str(rt.strRmatchIndices(few2, _281[_291]), front); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher")]; - put(out, rt.fmtFormat([rt.fmtSpec({ debugHex: "x" }, args52[0])])); - const part27 = fronts$searches_str_Split_ref_String(rt.strSplit(text2, _281[_291]), front); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part27, f, "Split", "StrSearcher")]; - put(out, rt.fmtFormat([args54[0]])); - const it3: rt.Iter = rt.strMatches(few2, _281[_291]); - while (rt.iterToOption(it3.next()) !== undefined) { - } - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rt.fmtFormat([args56[0]])); + const part17 = fronts$searches_str_Split_ref_str(rs.strSplit(few2, _281[_291]), front); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part17, f, "Split", "StrSearcher")]; + put(out, rs.fmtFormat([args34[0], "|", rs.fmtSpec({ alternate: true }, args34[0]), "|", rs.fmtSpec({ debugHex: "x" }, args34[0])])); + const part18 = fronts$searches_str_RSplit_ref_str(rs.strRsplit(few2, _281[_291]), front); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part18, f, "RSplit", "StrSearcher")]; + put(out, rs.fmtFormat([args36[0]])); + const part19 = fronts$searches_str_SplitTerminator_ref_str(rs.strSplitTerminator(few2, _281[_291]), front); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part19, f, "SplitTerminator", "StrSearcher")]; + put(out, rs.fmtFormat([args38[0]])); + const part20 = fronts$searches_str_SplitN_ref_str(rs.strSplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part20, f, "SplitN", "StrSearcher")]; + put(out, rs.fmtFormat([args40[0]])); + const part21 = fronts$searches_str_RSplitN_ref_str(rs.strRsplitn(few2, rs.u8Rem(at(3), 4) as rs.usize, _281[_291]), front); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part21, f, "RSplitN", "StrSearcher")]; + put(out, rs.fmtFormat([args42[0]])); + const part22 = fronts$searches_str_SplitInclusive_ref_str(rs.strSplitInclusive(few2, _281[_291]), front); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part22, f, "SplitInclusive", "StrSearcher")]; + put(out, rs.fmtFormat([args44[0]])); + const part23 = fronts$searches_str_Matches_ref_str(rs.strMatches(few2, _281[_291]), rs.usizeMul(front, 2)); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part23, f, "Matches", "StrSearcher")]; + put(out, rs.fmtFormat([args46[0]])); + const part24 = fronts$searches_str_RMatches_ref_str(rs.strRmatches(few2, _281[_291]), rs.usizeMul(front, 2)); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part24, f, "RMatches", "StrSearcher")]; + put(out, rs.fmtFormat([args48[0]])); + const part25 = fronts$searches_str_MatchIndices_ref_str(rs.strMatchIndices(few2, _281[_291]), front); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part25, f, "MatchIndices", "StrSearcher")]; + put(out, rs.fmtFormat([args50[0]])); + const part26 = fronts$searches_str_RMatchIndices_ref_str(rs.strRmatchIndices(few2, _281[_291]), front); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part26, f, "RMatchIndices", "StrSearcher")]; + put(out, rs.fmtFormat([rs.fmtSpec({ debugHex: "x" }, args52[0])])); + const part27 = fronts$searches_str_Split_ref_String(rs.strSplit(text2, _281[_291]), front); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part27, f, "Split", "StrSearcher")]; + put(out, rs.fmtFormat([args54[0]])); + const it3: rs.Iter = rs.strMatches(few2, _281[_291]); + while (rs.iterToOption(it3.next()) !== undefined) { + } + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; + put(out, rs.fmtFormat([args56[0]])); it3.next(); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; - put(out, rt.fmtFormat([args58[0]])); - const it4: rt.Iter<[rt.usize, string]> = rt.strRmatchIndices(few2, _281[_291]); - while (rt.iterToOption(it4.next()) !== undefined) { - } - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")]; - put(out, rt.fmtFormat([args60[0]])); - const part28 = ends$searches_str_Lines(rt.strLines(text2), front, back); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part28, f, "Lines")]; - put(out, rt.fmtFormat([args62[0], "|", rt.fmtSpec({ alternate: true }, args62[0])])); - const part29 = ends$searches_str_SplitWhitespace(rt.strSplitWhitespace(text2), front, back); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(part29, f, "SplitWhitespace")]; - put(out, rt.fmtFormat([args64[0], "|", rt.fmtSpec({ alternate: true }, args64[0])])); - const it7: rt.Iter = ends$searches_str_SplitAsciiWhitespace(rt.strSplitAsciiWhitespace(text2), front, back); - const _556: [rt.usize, rt.usize | undefined] = it7.sizeHint(); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_556[0], f), (f: rt.Formatter) => rt.fmtOption(_556[1], f, rt.usizeDebug)], f)]; - put(out, rt.fmtFormat([args66[0], "|", rt.fmtSpec({ alternate: true }, args66[0]), "|", rt.fmtSpec({ debugHex: "x" }, args66[0]), "|", args66[1]])); -} - -export function ends$searches_str_Lines(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it3, f, "Matches", "StrSearcher")]; + put(out, rs.fmtFormat([args58[0]])); + const it4: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(few2, _281[_291]); + while (rs.iterToOption(it4.next()) !== undefined) { + } + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it4, f, "RMatchIndices", "StrSearcher")]; + put(out, rs.fmtFormat([args60[0]])); + const part28 = ends$searches_str_Lines(rs.strLines(text2), front, back); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part28, f, "Lines")]; + put(out, rs.fmtFormat([args62[0], "|", rs.fmtSpec({ alternate: true }, args62[0])])); + const part29 = ends$searches_str_SplitWhitespace(rs.strSplitWhitespace(text2), front, back); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(part29, f, "SplitWhitespace")]; + put(out, rs.fmtFormat([args64[0], "|", rs.fmtSpec({ alternate: true }, args64[0])])); + const it7: rs.Iter = ends$searches_str_SplitAsciiWhitespace(rs.strSplitAsciiWhitespace(text2), front, back); + const _556: [rs.usize, rs.usize | undefined] = it7.sizeHint(); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrSearch(it7, f, "SplitAsciiWhitespace"), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_556[0], f), (f: rs.Formatter) => rs.fmtOption(_556[1], f, rs.usizeDebug)], f)]; + put(out, rs.fmtFormat([args66[0], "|", rs.fmtSpec({ alternate: true }, args66[0]), "|", rs.fmtSpec({ debugHex: "x" }, args66[0]), "|", args66[1]])); +} + +export function ends$searches_str_Lines(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_MatchIndices_char(it: rt.Iter<[rt.usize, string]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, string]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_MatchIndices_char(it: rs.Iter<[rs.usize, string]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, string]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_MatchIndices_char_is_whitespace(it: rt.Iter<[rt.usize, string]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, string]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_MatchIndices_char_is_whitespace(it: rs.Iter<[rs.usize, string]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, string]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_Matches_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_Matches_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_Matches_ref_array2_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_Matches_ref_array2_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_RMatchIndices_char(it: rt.Iter<[rt.usize, string]>, front: rt.usize, back: rt.usize): rt.Iter<[rt.usize, string]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_RMatchIndices_char(it: rs.Iter<[rs.usize, string]>, front: rs.usize, back: rs.usize): rs.Iter<[rs.usize, string]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_RMatches_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_RMatches_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_RSplitTerminator_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_RSplitTerminator_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_RSplit_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_RSplit_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_RSplit_ref_slice_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_RSplit_ref_slice_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_SplitAsciiWhitespace(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_SplitAsciiWhitespace(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_SplitInclusive_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_SplitInclusive_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_SplitTerminator_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_SplitTerminator_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_SplitWhitespace(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_SplitWhitespace(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_Split_array2_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_Split_array2_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_Split_char(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_Split_char(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function ends$searches_str_Split_fmt_searches_closure3(it: rt.Iter, front: rt.usize, back: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function ends$searches_str_Split_fmt_searches_closure3(it: rs.Iter, front: rs.usize, back: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (iterStart++ < iterEnd) { - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = back; + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = back; while (true) { if (!(iterStart2++ < iterEnd2)) { return it; } - rt.iterToOption(it.nextBack()); + rs.iterToOption(it.nextBack()); } } -export function fronts$searches_str_MatchIndices_ref_str(it: rt.Iter<[rt.usize, string]>, front: rt.usize): rt.Iter<[rt.usize, string]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_MatchIndices_ref_str(it: rs.Iter<[rs.usize, string]>, front: rs.usize): rs.Iter<[rs.usize, string]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_Matches_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_Matches_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_RMatchIndices_ref_str(it: rt.Iter<[rt.usize, string]>, front: rt.usize): rt.Iter<[rt.usize, string]> { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_RMatchIndices_ref_str(it: rs.Iter<[rs.usize, string]>, front: rs.usize): rs.Iter<[rs.usize, string]> { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_RMatches_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_RMatches_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_RSplitN_char(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_RSplitN_char(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_RSplitN_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_RSplitN_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_RSplit_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_RSplit_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_SplitInclusive_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_SplitInclusive_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_SplitN_char(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_SplitN_char(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_SplitN_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_SplitN_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_SplitTerminator_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_SplitTerminator_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_Split_ref_String(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_Split_ref_String(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } -export function fronts$searches_str_Split_ref_str(it: rt.Iter, front: rt.usize): rt.Iter { - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = front; +export function fronts$searches_str_Split_ref_str(it: rs.Iter, front: rs.usize): rs.Iter { + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = front; while (true) { if (!(iterStart++ < iterEnd)) { return it; } - rt.iterToOption(it.next()); + rs.iterToOption(it.next()); } } diff --git a/ts/fixtures/lang/shapes/expected/generics.Either.ts b/ts/fixtures/lang/shapes/expected/generics.Either.ts index c06698c3b..758d4b29a 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Either.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Either.ts @@ -1,86 +1,86 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$shapes_Point } from "./lib.ts"; import * as Point from "./shapes.Point.ts"; -export function fmt$fmt_Debug_shapes_Point_u8(self: Either, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_shapes_Point_u8(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { const _5: string = "Left"; - const _6: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Right") { const _9: string = "Right"; const _10: string = "value"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.value, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.value, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } - return rt.fmtWriteStr(f, "Neither"); + return rs.fmtWriteStr(f, "Neither"); } -export function fmt$fmt_Debug_u8_shapes_Point(self: Either, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8_shapes_Point(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { const _5: string = "Left"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Right") { const _9: string = "Right"; const _10: string = "value"; - const _11: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self.value, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } - return rt.fmtWriteStr(f, "Neither"); + return rs.fmtWriteStr(f, "Neither"); } -export function fmt$fmt_Debug_u8_u16(self: Either, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8_u16(self: Either, f: rs.Formatter): rs.Result { if (self.tag === "Left") { const _5: string = "Left"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Right") { const _9: string = "Right"; const _10: string = "value"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self.value, f); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.value, f); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } - return rt.fmtWriteStr(f, "Neither"); + return rs.fmtWriteStr(f, "Neither"); } /** A generic enum, with a companion function per instance. */ export type Either = { tag: "Left"; _0: L } | { tag: "Right"; value: R } | { tag: "Neither" }; -export function left$shapes_Point_u8(self: Either): Point.Point | undefined { +export function left$shapes_Point_u8(self: Either): Point.Point | undefined { if (self.tag === "Left") { return copy$shapes_Point(self._0); } return undefined; } -export function left$u8_shapes_Point(self: Either): rt.u8 | undefined { +export function left$u8_shapes_Point(self: Either): rs.u8 | undefined { if (self.tag === "Left") { return self._0; } return undefined; } -export function left$u8_u16(self: Either): rt.u8 | undefined { +export function left$u8_u16(self: Either): rs.u8 | undefined { if (self.tag === "Left") { return self._0; } return undefined; } -export function flip$u8_shapes_Point(self: Either): Either { +export function flip$u8_shapes_Point(self: Either): Either { if (self.tag === "Left") { - return { tag: "Right", value: self._0 } as Either; + return { tag: "Right", value: self._0 } as Either; } if (self.tag === "Right") { - return { tag: "Left", _0: self.value } as Either; + return { tag: "Left", _0: self.value } as Either; } - return { tag: "Neither" } as Either; + return { tag: "Neither" } as Either; } //# sourceMappingURL=generics.Either.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts index 294d05b45..3db54d7a0 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Fixed.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Fixed.ts @@ -1,33 +1,33 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug_u16(self: Fixed, f: rt.Formatter): rt.Result { - const arg = self.pair as rt.u16[]; +export function fmt$fmt_Debug_u16(self: Fixed, f: rs.Formatter): rs.Result { + const arg = self.pair as rs.u16[]; const _3: string = "Fixed"; const _4: string = "pair"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg, f, rt.u16Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); const _7: string = "tag"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.tag, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_u8(self: Fixed, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Fixed, f: rs.Formatter): rs.Result { const _3: string = "Fixed"; const _4: string = "pair"; - const _6: rt.ByteSlice = rt.byteSliceFrom(self.pair as Uint8Array); - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_6), f, rt.u8Debug); + const _6: rs.ByteSlice = rs.byteSliceFrom(self.pair as Uint8Array); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_6), f, rs.u8Debug); const _7: string = "tag"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.tag, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.tag, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A generic type JS copies, holding an array of its parameter. */ export class Fixed { - pair: rt.ArrayOf; - tag: rt.u8; + pair: rs.ArrayOf; + tag: rs.u8; - constructor(pair: rt.ArrayOf, tag: rt.u8) { + constructor(pair: rs.ArrayOf, tag: rs.u8) { this.pair = pair; this.tag = tag; } diff --git a/ts/fixtures/lang/shapes/expected/generics.Lends.ts b/ts/fixtures/lang/shapes/expected/generics.Lends.ts index 1f50478ae..bd9063c36 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Lends.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Lends.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A generic type lending a run of its parameter, which it writes through, and a function * of one. */ export interface Lends { - run: rt.SliceOf; - last: (a0: rt.SliceOf) => rt.Ptr | undefined; + run: rs.SliceOf; + last: (a0: rs.SliceOf) => rs.Ptr | undefined; } //# sourceMappingURL=generics.Lends.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.Run.ts b/ts/fixtures/lang/shapes/expected/generics.Run.ts index f1c61e515..ad87c5156 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Run.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Run.ts @@ -1,63 +1,63 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug_u16(self: Run, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u16(self: Run, f: rs.Formatter): rs.Result { if (self.tag === "Listed") { - const arg2 = self._0 as rt.Vec; + const arg2 = self._0 as rs.Vec; const _5: string = "Listed"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg2.items, f, rt.u16Debug); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u16Debug); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Fixed") { - const arg = self.array as rt.u16[]; + const arg = self.array as rs.u16[]; const _9: string = "Fixed"; const _10: string = "array"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg, f, rt.u16Debug); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } - return rt.fmtWriteStr(f, "Empty"); + return rs.fmtWriteStr(f, "Empty"); } -export function fmt$fmt_Debug_u8(self: Run, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Run, f: rs.Formatter): rs.Result { if (self.tag === "Listed") { - const arg = self._0 as rt.ByteVec; + const arg = self._0 as rs.ByteVec; const _5: string = "Listed"; - const _6: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(arg), f, rt.u8Debug); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _5), _6)); + const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _5), _6)); } if (self.tag === "Fixed") { - const __self0: rt.ByteSlice = rt.byteSliceFrom(self.array as Uint8Array); + const __self0: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); const _9: string = "Fixed"; const _10: string = "array"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(__self0), f, rt.u8Debug); - return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _9), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(__self0), f, rs.u8Debug); + return rs.debugStructFinish(rs.debugStructField(rs.fmtDebugStruct(f, _9), _10, _11)); } - return rt.fmtWriteStr(f, "Empty"); + return rs.fmtWriteStr(f, "Empty"); } /** An enum holding a run of its parameter in a variant. */ export type Run = - | { tag: "Listed"; _0: rt.VecOf } - | { tag: "Fixed"; array: rt.ArrayOf } + | { tag: "Listed"; _0: rs.VecOf } + | { tag: "Fixed"; array: rs.ArrayOf } | { tag: "Empty" }; -export function first$u16(self: Run): rt.u16 | undefined { +export function first$u16(self: Run): rs.u16 | undefined { if (self.tag === "Listed") { - return rt.sliceFirst((self._0 as rt.Vec).items); + return rs.sliceFirst((self._0 as rs.Vec).items); } if (self.tag === "Fixed") { - return (self.array as rt.u16[])[0]; + return (self.array as rs.u16[])[0]; } return undefined; } -export function first$u8(self: Run): rt.u8 | undefined { +export function first$u8(self: Run): rs.u8 | undefined { if (self.tag === "Listed") { - return rt.byteSliceFirst(rt.byteVecSlice(self._0 as rt.ByteVec)); + return rs.byteSliceFirst(rs.byteVecSlice(self._0 as rs.ByteVec)); } if (self.tag === "Fixed") { - const array: rt.ByteSlice = rt.byteSliceFrom(self.array as Uint8Array); + const array: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); return array.data[array.start]; } return undefined; diff --git a/ts/fixtures/lang/shapes/expected/generics.Runs.ts b/ts/fixtures/lang/shapes/expected/generics.Runs.ts index 4b6fe8eec..901982810 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Runs.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Runs.ts @@ -1,63 +1,63 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u16, copy$array_u8 } from "./lib.ts"; -import { clone$11qe8jq as option_clone$11qe8jq, clone$1grnave as option_clone$1grnave } from "./core/option.ts"; +import { clone$14vwxlf as option_clone$14vwxlf, clone$0e53k5z as option_clone$0e53k5z } from "./core/option.ts"; import type * as Run from "./generics.Run.ts"; -export function clone$Clone_u16(self: Runs): Runs { - return new Runs(copy$array_u16(copy$array_u16(self.array as rt.u16[])), rt.vecFrom((self.list as rt.Vec).items.slice()), self.view as rt.u16[], (self.boxed as rt.u16[]).slice(), rt.cowClone(self.cow as rt.Cow), rt.vecFrom((self.pairs as rt.Vec).items.map(copy$array_u16)), option_clone$11qe8jq(self.maybe as rt.Vec | undefined)); +export function clone$Clone_u16(self: Runs): Runs { + return new Runs(copy$array_u16(copy$array_u16(self.array as rs.u16[])), rs.vecFrom((self.list as rs.Vec).items.slice()), self.view as rs.u16[], (self.boxed as rs.u16[]).slice(), rs.cowClone(self.cow as rs.Cow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u16)), option_clone$14vwxlf(self.maybe as rs.Vec | undefined)); } -export function clone$Clone_u8(self: Runs): Runs { - return new Runs(copy$array_u8(rt.byteSliceToArray(rt.byteSliceFrom(self.array as Uint8Array))), rt.byteVecFrom(rt.byteVecView(self.list as rt.ByteVec)), self.view as rt.ByteSlice, rt.byteSliceFrom(rt.byteSliceToArray(self.boxed as rt.ByteSlice)), rt.byteCowClone(self.cow as rt.ByteCow), rt.vecFrom((self.pairs as rt.Vec).items.map(copy$array_u8)), option_clone$1grnave(self.maybe as rt.ByteVec | undefined)); +export function clone$Clone_u8(self: Runs): Runs { + return new Runs(copy$array_u8(rs.byteSliceToArray(rs.byteSliceFrom(self.array as Uint8Array))), rs.byteVecFrom(rs.byteVecView(self.list as rs.ByteVec)), self.view as rs.ByteSlice, rs.byteSliceFrom(rs.byteSliceToArray(self.boxed as rs.ByteSlice)), rs.byteCowClone(self.cow as rs.ByteCow), rs.vecFrom((self.pairs as rs.Vec).items.map(copy$array_u8)), option_clone$0e53k5z(self.maybe as rs.ByteVec | undefined)); } -export function fmt$fmt_Debug_u16(self: Runs, f: rt.Formatter): rt.Result { - const arg = self.array as rt.u16[]; - const _7: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg, f, rt.u16Debug); - const arg2 = self.list as rt.Vec; - const _9: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg2.items, f, rt.u16Debug); - const arg3 = self.view as rt.u16[]; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg3, f, rt.u16Debug); - const arg4 = self.boxed as rt.u16[]; - const _13: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg4, f, rt.u16Debug); - const arg5 = self.cow as rt.Cow; - const _15: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.cowSlice(arg5), f, rt.u16Debug); - const arg6 = self.pairs as rt.Vec; - const _17: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg6.items, f, (value: rt.u16[], f: rt.Formatter) => rt.fmtList(value, f, rt.u16Debug)); - const arg7 = self.maybe as rt.Vec | undefined; +export function fmt$fmt_Debug_u16(self: Runs, f: rs.Formatter): rs.Result { + const arg = self.array as rs.u16[]; + const _7: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg, f, rs.u16Debug); + const arg2 = self.list as rs.Vec; + const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u16Debug); + const arg3 = self.view as rs.u16[]; + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg3, f, rs.u16Debug); + const arg4 = self.boxed as rs.u16[]; + const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg4, f, rs.u16Debug); + const arg5 = self.cow as rs.Cow; + const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.cowSlice(arg5), f, rs.u16Debug); + const arg6 = self.pairs as rs.Vec; + const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg6.items, f, (value: rs.u16[], f: rs.Formatter) => rs.fmtList(value, f, rs.u16Debug)); + const arg7 = self.maybe as rs.Vec | undefined; const names: string[] = ["array", "list", "view", "boxed", "cow", "pairs", "maybe"]; - const values: rt.Fmt[] = [_7, _9, _11, _13, _15, _17, (f: rt.Formatter) => rt.fmtOption(arg7, f, (value: rt.Vec, f: rt.Formatter) => rt.fmtList(value.items, f, rt.u16Debug))]; - return rt.fmtDebugStructFields(f, "Runs", names, values); + const values: rs.Fmt[] = [_7, _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg7, f, (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.u16Debug))]; + return rs.fmtDebugStructFields(f, "Runs", names, values); } -export function fmt$fmt_Debug_u8(self: Runs, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Runs, f: rs.Formatter): rs.Result { const names: string[] = ["array", "list", "view", "boxed", "cow", "pairs", "maybe"]; - const _8: rt.ByteSlice = rt.byteSliceFrom(self.array as Uint8Array); - const arg = self.list as rt.ByteVec; - const _9: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteVecView(arg), f, rt.u8Debug); - const arg2 = self.view as rt.ByteSlice; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg2), f, rt.u8Debug); - const arg3 = self.boxed as rt.ByteSlice; - const _13: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg3), f, rt.u8Debug); - const arg4 = self.cow as rt.ByteCow; - const _15: rt.Fmt = (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(rt.byteCowSlice(arg4)), f, rt.u8Debug); - const arg5 = self.pairs as rt.Vec; - const _17: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg5.items, f, (value: Uint8Array, f: rt.Formatter) => rt.fmtList(value, f, rt.u8Debug)); - const arg6 = self.maybe as rt.ByteVec | undefined; - const values: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_8), f, rt.u8Debug), _9, _11, _13, _15, _17, (f: rt.Formatter) => rt.fmtOption(arg6, f, (value: rt.ByteVec, f: rt.Formatter) => rt.fmtList(rt.byteVecView(value), f, rt.u8Debug))]; - return rt.fmtDebugStructFields(f, "Runs", names, values); + const _8: rs.ByteSlice = rs.byteSliceFrom(self.array as Uint8Array); + const arg = self.list as rs.ByteVec; + const _9: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteVecView(arg), f, rs.u8Debug); + const arg2 = self.view as rs.ByteSlice; + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug); + const arg3 = self.boxed as rs.ByteSlice; + const _13: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg3), f, rs.u8Debug); + const arg4 = self.cow as rs.ByteCow; + const _15: rs.Fmt = (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(rs.byteCowSlice(arg4)), f, rs.u8Debug); + const arg5 = self.pairs as rs.Vec; + const _17: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg5.items, f, (value: Uint8Array, f: rs.Formatter) => rs.fmtList(value, f, rs.u8Debug)); + const arg6 = self.maybe as rs.ByteVec | undefined; + const values: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_8), f, rs.u8Debug), _9, _11, _13, _15, _17, (f: rs.Formatter) => rs.fmtOption(arg6, f, (value: rs.ByteVec, f: rs.Formatter) => rs.fmtList(rs.byteVecView(value), f, rs.u8Debug))]; + return rs.fmtDebugStructFields(f, "Runs", names, values); } -export function eq$cmp_PartialEq_u16(self: Runs, other: Runs): boolean { - if (rt.eqSlice(rt.same)(self.array as rt.u16[], other.array as rt.u16[])) { - if (rt.eqSlice(rt.same)(self.list as rt.Vec, other.list as rt.Vec)) { - if (rt.eqSlice(rt.same)(self.view as rt.u16[], other.view as rt.u16[])) { - if (rt.eqSlice(rt.same)(self.boxed as rt.u16[], other.boxed as rt.u16[])) { - if (rt.eqSlice(rt.same)(rt.cowSlice(self.cow as rt.Cow), rt.cowSlice(other.cow as rt.Cow))) { - if (rt.eqSlice(rt.eqSlice(rt.same))(self.pairs as rt.Vec, other.pairs as rt.Vec)) { - return rt.eqOption(rt.eqSlice(rt.same))(self.maybe as rt.Vec | undefined, other.maybe as rt.Vec | undefined); +export function eq$cmp_PartialEq_u16(self: Runs, other: Runs): boolean { + if (rs.eqSlice(rs.same)(self.array as rs.u16[], other.array as rs.u16[])) { + if (rs.eqSlice(rs.same)(self.list as rs.Vec, other.list as rs.Vec)) { + if (rs.eqSlice(rs.same)(self.view as rs.u16[], other.view as rs.u16[])) { + if (rs.eqSlice(rs.same)(self.boxed as rs.u16[], other.boxed as rs.u16[])) { + if (rs.eqSlice(rs.same)(rs.cowSlice(self.cow as rs.Cow), rs.cowSlice(other.cow as rs.Cow))) { + if (rs.eqSlice(rs.eqSlice(rs.same))(self.pairs as rs.Vec, other.pairs as rs.Vec)) { + return rs.eqOption(rs.eqSlice(rs.same))(self.maybe as rs.Vec | undefined, other.maybe as rs.Vec | undefined); } } } @@ -67,14 +67,14 @@ export function eq$cmp_PartialEq_u16(self: Runs, other: Runs): b return false; } -export function eq$cmp_PartialEq_u8(self: Runs, other: Runs): boolean { - if (rt.eqBytes(rt.byteSliceFrom(self.array as Uint8Array), rt.byteSliceFrom(other.array as Uint8Array))) { - if (rt.eqBytes(self.list as rt.ByteVec, other.list as rt.ByteVec)) { - if (rt.byteSliceEq(self.view as rt.ByteSlice, other.view as rt.ByteSlice)) { - if (rt.eqBytes(self.boxed as rt.ByteSlice, other.boxed as rt.ByteSlice)) { - if (rt.eqBytes(self.cow as rt.ByteCow, other.cow as rt.ByteCow)) { - if (rt.eqSlice(rt.eqBytes)(self.pairs as rt.Vec, other.pairs as rt.Vec)) { - return rt.eqOption(rt.eqBytes)(self.maybe as rt.ByteVec | undefined, other.maybe as rt.ByteVec | undefined); +export function eq$cmp_PartialEq_u8(self: Runs, other: Runs): boolean { + if (rs.eqBytes(rs.byteSliceFrom(self.array as Uint8Array), rs.byteSliceFrom(other.array as Uint8Array))) { + if (rs.eqBytes(self.list as rs.ByteVec, other.list as rs.ByteVec)) { + if (rs.byteSliceEq(self.view as rs.ByteSlice, other.view as rs.ByteSlice)) { + if (rs.eqBytes(self.boxed as rs.ByteSlice, other.boxed as rs.ByteSlice)) { + if (rs.eqBytes(self.cow as rs.ByteCow, other.cow as rs.ByteCow)) { + if (rs.eqSlice(rs.eqBytes)(self.pairs as rs.Vec, other.pairs as rs.Vec)) { + return rs.eqOption(rs.eqBytes)(self.maybe as rs.ByteVec | undefined, other.maybe as rs.ByteVec | undefined); } } } @@ -89,15 +89,15 @@ export function eq$cmp_PartialEq_u8(self: Runs, other: Runs): bool * apart in, which only an instance decides. */ export class Runs { - array: rt.ArrayOf; - list: rt.VecOf; - view: rt.SliceOf; - boxed: rt.SliceOf; - cow: rt.CowOf; - pairs: rt.Vec>; - maybe: rt.VecOf | undefined; - - constructor(array: rt.ArrayOf, list: rt.VecOf, view: rt.SliceOf, boxed: rt.SliceOf, cow: rt.CowOf, pairs: rt.Vec>, maybe: rt.VecOf | undefined) { + array: rs.ArrayOf; + list: rs.VecOf; + view: rs.SliceOf; + boxed: rs.SliceOf; + cow: rs.CowOf; + pairs: rs.Vec>; + maybe: rs.VecOf | undefined; + + constructor(array: rs.ArrayOf, list: rs.VecOf, view: rs.SliceOf, boxed: rs.SliceOf, cow: rs.CowOf, pairs: rs.Vec>, maybe: rs.VecOf | undefined) { this.array = array; this.list = list; this.view = view; @@ -108,76 +108,76 @@ export class Runs { } [Symbol.dispose](): void { - rt.dropAll(this.array as T[]); - rt.dropVec(this.list as rt.Vec); - rt.dropAll(this.boxed as T[]); - rt.cowDrop(this.cow as rt.Cow); - rt.dropVec(this.pairs as rt.Vec, (value: T[]) => rt.dropAll(value)); - rt.dropVec(this.maybe as rt.Vec | undefined); + rs.dropAll(this.array as T[]); + rs.dropVec(this.list as rs.Vec); + rs.dropAll(this.boxed as T[]); + rs.cowDrop(this.cow as rs.Cow); + rs.dropVec(this.pairs as rs.Vec, (value: T[]) => rs.dropAll(value)); + rs.dropVec(this.maybe as rs.Vec | undefined); } } -export function total$u16(self: Runs): rt.usize { - return rt.usizeAdd(rt.usizeAdd(rt.usizeAdd(rt.usizeAdd(rt.usizeAdd((self.array as rt.u16[]).length, (self.list as rt.Vec).items.length), (self.view as rt.u16[]).length), (self.boxed as rt.u16[]).length), rt.cowSlice(self.cow as rt.Cow).length), (self.pairs as rt.Vec).items.length); +export function total$u16(self: Runs): rs.usize { + return rs.usizeAdd(rs.usizeAdd(rs.usizeAdd(rs.usizeAdd(rs.usizeAdd((self.array as rs.u16[]).length, (self.list as rs.Vec).items.length), (self.view as rs.u16[]).length), (self.boxed as rs.u16[]).length), rs.cowSlice(self.cow as rs.Cow).length), (self.pairs as rs.Vec).items.length); } -export function total$u8(self: Runs): rt.usize { - return rt.usizeAdd(rt.usizeAdd(rt.usizeAdd(rt.usizeAdd(rt.usizeAdd(rt.byteSliceFrom(self.array as Uint8Array).length, (self.list as rt.ByteVec).length), (self.view as rt.ByteSlice).length), (self.boxed as rt.ByteSlice).length), rt.byteCowSlice(self.cow as rt.ByteCow).length), (self.pairs as rt.Vec).items.length); +export function total$u8(self: Runs): rs.usize { + return rs.usizeAdd(rs.usizeAdd(rs.usizeAdd(rs.usizeAdd(rs.usizeAdd(rs.byteSliceFrom(self.array as Uint8Array).length, (self.list as rs.ByteVec).length), (self.view as rs.ByteSlice).length), (self.boxed as rs.ByteSlice).length), rs.byteCowSlice(self.cow as rs.ByteCow).length), (self.pairs as rs.Vec).items.length); } -export function push$u16(self: Runs, item: rt.u16): void { - (self.list as rt.Vec).items.push(item); - const owned = rt.cowIntoOwned(self.cow as rt.Cow); - (self.cow as rt.Cow) = owned; +export function push$u16(self: Runs, item: rs.u16): void { + (self.list as rs.Vec).items.push(item); + const owned = rs.cowIntoOwned(self.cow as rs.Cow); + (self.cow as rs.Cow) = owned; owned.items.push(item); - (self.pairs as rt.Vec).items.push(Array.from({ length: 2 }, (): rt.u16 => { + (self.pairs as rs.Vec).items.push(Array.from({ length: 2 }, (): rs.u16 => { return item; })); - rt.sliceRotateLeft(self.array as rt.u16[], 1); - (self.array as rt.u16[])[2] = item; - rt.idx(self.boxed as rt.u16[], 0); - (self.boxed as rt.u16[])[0] = item; - if ((self.maybe as rt.Vec | undefined) !== undefined) { - ((self.maybe as rt.Vec | undefined) as rt.Vec).items.push(item); + rs.sliceRotateLeft(self.array as rs.u16[], 1); + (self.array as rs.u16[])[2] = item; + rs.idx(self.boxed as rs.u16[], 0); + (self.boxed as rs.u16[])[0] = item; + if ((self.maybe as rs.Vec | undefined) !== undefined) { + ((self.maybe as rs.Vec | undefined) as rs.Vec).items.push(item); } } -export function push$u8(self: Runs, item: rt.u8): void { - rt.byteVecPush(self.list as rt.ByteVec, item); - const owned = rt.byteCowIntoOwned(self.cow as rt.ByteCow); - (self.cow as rt.ByteCow) = owned; - rt.byteVecPush(owned, item); - (self.pairs as rt.Vec).items.push(rt.bytes(2).fill(item)); - rt.byteSliceRotateLeft(rt.byteSliceFrom(self.array as Uint8Array), 1); +export function push$u8(self: Runs, item: rs.u8): void { + rs.byteVecPush(self.list as rs.ByteVec, item); + const owned = rs.byteCowIntoOwned(self.cow as rs.ByteCow); + (self.cow as rs.ByteCow) = owned; + rs.byteVecPush(owned, item); + (self.pairs as rs.Vec).items.push(rs.bytes(2).fill(item)); + rs.byteSliceRotateLeft(rs.byteSliceFrom(self.array as Uint8Array), 1); (self.array as Uint8Array)[2] = item; - rt.idx(self.boxed as rt.ByteSlice, 0); - const _24: rt.ByteSlice = self.boxed as rt.ByteSlice; + rs.idx(self.boxed as rs.ByteSlice, 0); + const _24: rs.ByteSlice = self.boxed as rs.ByteSlice; _24.data[_24.start] = item; - if ((self.maybe as rt.ByteVec | undefined) !== undefined) { - rt.byteVecPush((self.maybe as rt.ByteVec | undefined) as rt.ByteVec, item); + if ((self.maybe as rs.ByteVec | undefined) !== undefined) { + rs.byteVecPush((self.maybe as rs.ByteVec | undefined) as rs.ByteVec, item); } } -export function run$u16(self: Runs): Run.Run { - const _2: rt.usize = rt.usizeRem((self.list as rt.Vec).items.length, 3); +export function run$u16(self: Runs): Run.Run { + const _2: rs.usize = rs.usizeRem((self.list as rs.Vec).items.length, 3); if (_2 === 0) { - return { tag: "Listed", _0: rt.vecFrom((self.list as rt.Vec).items.slice()) } as Run.Run; + return { tag: "Listed", _0: rs.vecFrom((self.list as rs.Vec).items.slice()) } as Run.Run; } if (_2 === 1) { - return { tag: "Fixed", array: [(self.array as rt.u16[])[0], (self.array as rt.u16[])[2]] } as Run.Run; + return { tag: "Fixed", array: [(self.array as rs.u16[])[0], (self.array as rs.u16[])[2]] } as Run.Run; } - return { tag: "Empty" } as Run.Run; + return { tag: "Empty" } as Run.Run; } -export function run$u8(self: Runs): Run.Run { - const _2: rt.usize = rt.usizeRem((self.list as rt.ByteVec).length, 3); +export function run$u8(self: Runs): Run.Run { + const _2: rs.usize = rs.usizeRem((self.list as rs.ByteVec).length, 3); if (_2 === 0) { - return { tag: "Listed", _0: rt.byteVecFrom(rt.byteVecView(self.list as rt.ByteVec)) } as Run.Run; + return { tag: "Listed", _0: rs.byteVecFrom(rs.byteVecView(self.list as rs.ByteVec)) } as Run.Run; } if (_2 === 1) { - return { tag: "Fixed", array: Uint8Array.of((self.array as Uint8Array)[0], (self.array as Uint8Array)[2]) } as Run.Run; + return { tag: "Fixed", array: Uint8Array.of((self.array as Uint8Array)[0], (self.array as Uint8Array)[2]) } as Run.Run; } - return { tag: "Empty" } as Run.Run; + return { tag: "Empty" } as Run.Run; } //# sourceMappingURL=generics.Runs.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.Tagged.ts b/ts/fixtures/lang/shapes/expected/generics.Tagged.ts index 0c29f6fe4..1af38296a 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Tagged.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Tagged.ts @@ -1,35 +1,35 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Either from "./generics.Either.ts"; import * as Wrap from "./generics.Wrap.ts"; -export function fmt$fmt_Debug_generics_Either_u8_u16_i16(self: Tagged, rt.i16>, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_generics_Either_u8_u16_i16(self: Tagged, rs.i16>, f: rs.Formatter): rs.Result { const _3: string = "Tagged"; const _4: string = "key"; - const _5: rt.Fmt = (f: rt.Formatter) => Either.fmt$fmt_Debug_u8_u16(self.key, f); + const _5: rs.Fmt = (f: rs.Formatter) => Either.fmt$fmt_Debug_u8_u16(self.key, f); const _7: string = "inner"; - const _8: rt.Fmt = (f: rt.Formatter) => Wrap.fmt$fmt_Debug_i16(self.inner, f); + const _8: rs.Fmt = (f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(self.inner, f); const _10: string = "all"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.all.items, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f)); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.all.items, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f)); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11)); } /** Two parameters, one nested in another generic type. */ export class Tagged { key: K; inner: Wrap.Wrap; - all: rt.Vec>; + all: rs.Vec>; - constructor(key: K, inner: Wrap.Wrap, all: rt.Vec>) { + constructor(key: K, inner: Wrap.Wrap, all: rs.Vec>) { this.key = key; this.inner = inner; this.all = all; } } -export function first$generics_Either_u8_u16_i16(self: Tagged, rt.i16>): Wrap.Wrap | undefined { - return rt.sliceFirst(self.all.items); +export function first$generics_Either_u8_u16_i16(self: Tagged, rs.i16>): Wrap.Wrap | undefined { + return rs.sliceFirst(self.all.items); } //# sourceMappingURL=generics.Tagged.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.Ticked.ts b/ts/fixtures/lang/shapes/expected/generics.Ticked.ts index 1154330fe..c9c5cace6 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Ticked.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Ticked.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id as it drops, and as it is cloned, the id with the high bit set. */ export class Ticked { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -19,16 +19,16 @@ export class Ticked { } export function clone$Clone(self: Ticked): Ticked { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Ticked(self.id, rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Ticked(self.id, rs.arcClone(self.log)); } export function drop$ops_Drop(self: Ticked): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=generics.Ticked.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.Wrap.ts b/ts/fixtures/lang/shapes/expected/generics.Wrap.ts index 04b05d8eb..ef804b195 100644 --- a/ts/fixtures/lang/shapes/expected/generics.Wrap.ts +++ b/ts/fixtures/lang/shapes/expected/generics.Wrap.ts @@ -1,90 +1,90 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Pair from "./fmt.Pair.ts"; import * as Meters from "./shapes.Meters.ts"; import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; -export function fmt$fmt_Debug_Option_u8(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_Option_u8(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.value, f, rt.u8Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.value, f, rs.u8Debug); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_Result_u8_shapes_Shape(self: Wrap>, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_Result_u8_shapes_Shape(self: Wrap>, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtResult(self.value, f, rt.u8Debug, (value: Shape.Shape, f: rt.Formatter) => Shape.fmt$fmt_Debug(value, f)); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtResult(self.value, f, rs.u8Debug, (value: Shape.Shape, f: rs.Formatter) => Shape.fmt$fmt_Debug(value, f)); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_Vec_u16(self: Wrap>, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_Vec_u16(self: Wrap>, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.value.items, f, rt.u16Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.value.items, f, rs.u16Debug); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_fmt_Pair(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => Pair.fmt$fmt_Debug(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => Pair.fmt$fmt_Debug(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_generics_Wrap_fmt_Pair(self: Wrap>, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_generics_Wrap_fmt_Pair(self: Wrap>, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => fmt$fmt_Debug_fmt_Pair(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => fmt$fmt_Debug_fmt_Pair(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_i16(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i16(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.i16Debug(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_shapes_Point(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_shapes_Point(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_shapes_Shape(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_shapes_Shape(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => Shape.fmt$fmt_Debug(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => Shape.fmt$fmt_Debug(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } -export function fmt$fmt_Debug_u8(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Wrap, f: rs.Formatter): rs.Result { const _3: string = "Wrap"; const _4: string = "value"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.value, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.value, f); const _7: string = "count"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.count, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.count, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$cmp_PartialEq_fmt_Pair(self: Wrap, other: Wrap): boolean { @@ -97,15 +97,15 @@ export function eq$cmp_PartialEq_fmt_Pair(self: Wrap, other: Wrap { value: T; - count: rt.u8; + count: rs.u8; - constructor(value: T, count: rt.u8) { + constructor(value: T, count: rs.u8) { this.value = value; this.count = count; } } -export function new$Option_u8(value: rt.u8 | undefined): Wrap { +export function new$Option_u8(value: rs.u8 | undefined): Wrap { return new Wrap(value, 0); } @@ -117,7 +117,7 @@ export function new$generics_Wrap_fmt_Pair(value: Wrap): Wrap { +export function new$i16(value: rs.i16): Wrap { return new Wrap(value, 0); } @@ -129,11 +129,11 @@ export function new$shapes_Shape(value: Shape.Shape): Wrap { return new Wrap(value, 0); } -export function new$u8(value: rt.u8): Wrap { +export function new$u8(value: rs.u8): Wrap { return new Wrap(value, 0); } -export function get$Option_u8(self: Wrap): rt.u8 | undefined { +export function get$Option_u8(self: Wrap): rs.u8 | undefined { return self.value; } @@ -145,22 +145,22 @@ export function get$generics_Wrap_fmt_Pair(self: Wrap>): Wrap): rt.u8 { +export function get$u8(self: Wrap): rs.u8 { return self.value; } -export function bump$Vec_u16(self: Wrap>): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); +export function bump$Vec_u16(self: Wrap>): rs.u8 { + self.count = rs.u8WrappingAdd(self.count, 1); return self.count; } -export function bump$shapes_Point(self: Wrap): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); +export function bump$shapes_Point(self: Wrap): rs.u8 { + self.count = rs.u8WrappingAdd(self.count, 1); return self.count; } -export function bump$u8(self: Wrap): rt.u8 { - self.count = rt.u8WrappingAdd(self.count, 1); +export function bump$u8(self: Wrap): rs.u8 { + self.count = rs.u8WrappingAdd(self.count, 1); return self.count; } @@ -169,40 +169,40 @@ export function intoInner$shapes_Point(self: Wrap): Point.Point { } /** A method with its own type parameter. */ -export function map$u8_fmt_Pair_generics_methods_closure1(self: Wrap, f: (a0: rt.u8) => Pair.Pair): Wrap { +export function map$u8_fmt_Pair_generics_methods_closure1(self: Wrap, f: (a0: rs.u8) => Pair.Pair): Wrap { return new Wrap(f(self.value), self.count); } -export function scaled$shapes_Meters(self: Wrap): rt.u64 { - return rt.u64SaturatingAdd(Meters.area$shapes_Area(self.value), self.count as rt.u64); +export function scaled$shapes_Meters(self: Wrap): rs.u64 { + return rs.u64SaturatingAdd(Meters.area$shapes_Area(self.value), self.count as rs.u64); } -export function scaled$shapes_Shape(self: Wrap): rt.u64 { - return rt.u64SaturatingAdd(Shape.area$shapes_Area(self.value), self.count as rt.u64); +export function scaled$shapes_Shape(self: Wrap): rs.u64 { + return rs.u64SaturatingAdd(Shape.area$shapes_Area(self.value), self.count as rs.u64); } -export function double$u8(self: Wrap): rt.u16 { - return rt.u16Mul(self.value as rt.u16, 2); +export function double$u8(self: Wrap): rs.u16 { + return rs.u16Mul(self.value as rs.u16, 2); } -export function area$shapes_Area_shapes_Meters(self: Wrap): rt.u64 { +export function area$shapes_Area_shapes_Meters(self: Wrap): rs.u64 { return Meters.area$shapes_Area(self.value); } -export function area$shapes_Area_shapes_Shape(self: Wrap): rt.u64 { +export function area$shapes_Area_shapes_Shape(self: Wrap): rs.u64 { return Shape.area$shapes_Area(self.value); } /** A default method, monomorphized for each type. */ -export function describe$shapes_Area_shapes_Meters(self: Wrap, out: rt.ByteVec): void { - rt.byteVecPush(out, 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$shapes_Area_shapes_Meters(self)))); +export function describe$shapes_Area_shapes_Meters(self: Wrap, out: rs.ByteVec): void { + rs.byteVecPush(out, 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(area$shapes_Area_shapes_Meters(self)))); } /** A default method, monomorphized for each type. */ -export function describe$shapes_Area_shapes_Shape(self: Wrap, out: rt.ByteVec): void { - rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$shapes_Area_shapes_Shape(self)))); +export function describe$shapes_Area_shapes_Shape(self: Wrap, out: rs.ByteVec): void { + rs.byteVecPush(out, 4); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(area$shapes_Area_shapes_Shape(self)))); } //# sourceMappingURL=generics.Wrap.ts.map diff --git a/ts/fixtures/lang/shapes/expected/generics.ts b/ts/fixtures/lang/shapes/expected/generics.ts index 217697bb2..ad880e8f3 100644 --- a/ts/fixtures/lang/shapes/expected/generics.ts +++ b/ts/fixtures/lang/shapes/expected/generics.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_generics_Either_u8_shapes_Point, copy$generics_Fixed_u16, copy$generics_Fixed_u8, copy$generics_Wrap_shapes_Point, copy$generics_Wrap_u8, copy$shapes_Gauge, drop$generics_Run_generics_Ticked } from "./lib.ts"; -import { then$1he9dd4, then$1i9qaz4 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrDefault$001fvl5 as option_unwrapOrDefault$001fvl5, unwrapOrDefault$1q0ps0j as option_unwrapOrDefault$1q0ps0j, map$0zbvahh as option_map$0zbvahh } from "./core/option.ts"; +import { then$01xsbgy, then$0y7on52 } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$0w7995p as option_unwrapOrDefault$0w7995p, unwrapOrDefault$03apme8 as option_unwrapOrDefault$03apme8, map$0ggarad as option_map$0ggarad } from "./core/option.ts"; import type * as Pair from "./fmt.Pair.ts"; import * as Either from "./generics.Either.ts"; import * as Fixed from "./generics.Fixed.ts"; @@ -21,65 +21,65 @@ import type * as Shape from "./shapes.Shape.ts"; import type * as Track from "./shapes.Track.ts"; /** Each method once per instance: `Wrap` of a struct, an enum, a number, and itself. */ -export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function methods(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const point: Wrap.Wrap = copy$generics_Wrap_shapes_Point(Wrap.new$shapes_Point({ x: at(0) as rt.i32, y: -2 })); + const point: Wrap.Wrap = copy$generics_Wrap_shapes_Point(Wrap.new$shapes_Point({ x: at(0) as rs.i32, y: -2 })); Wrap.bump$shapes_Point(point); - const byte: Wrap.Wrap = copy$generics_Wrap_u8(Wrap.new$u8(at(1))); + const byte: Wrap.Wrap = copy$generics_Wrap_u8(Wrap.new$u8(at(1))); Wrap.bump$u8(byte); Wrap.bump$u8(byte); const nested: Wrap.Wrap> = Wrap.new$generics_Wrap_fmt_Pair(Wrap.new$fmt_Pair({ _0: at(2), _1: -3 })); - const meters: Wrap.Wrap = new Wrap.Wrap({ _0: at(3) as rt.u64 }, at(4)); - const shape: Wrap.Wrap = Wrap.new$shapes_Shape({ tag: "Rect", corner: Wrap.intoInner$shapes_Point(point), width: at(5) as rt.u16, height: 3 } as Shape.Shape); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ alternate: true }, args4[0])])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(Wrap.double$u8(byte)))); - rt.byteVecPush(out, Wrap.get$u8(byte)); - rt.byteVecPush(out, Wrap.get$fmt_Pair(Wrap.get$generics_Wrap_fmt_Pair(nested))._0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(Wrap.scaled$shapes_Meters(meters)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(Wrap.scaled$shapes_Shape(shape)))); + const meters: Wrap.Wrap = new Wrap.Wrap({ _0: at(3) as rs.u64 }, at(4)); + const shape: Wrap.Wrap = Wrap.new$shapes_Shape({ tag: "Rect", corner: Wrap.intoInner$shapes_Point(point), width: at(5) as rs.u16, height: 3 } as Shape.Shape); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Point(point, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_u8(byte, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_shapes_Shape(shape, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_generics_Wrap_fmt_Pair(nested, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ alternate: true }, args4[0])])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(Wrap.double$u8(byte)))); + rs.byteVecPush(out, Wrap.get$u8(byte)); + rs.byteVecPush(out, Wrap.get$fmt_Pair(Wrap.get$generics_Wrap_fmt_Pair(nested))._0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(Wrap.scaled$shapes_Meters(meters)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(Wrap.scaled$shapes_Shape(shape)))); Wrap.describe$shapes_Area_shapes_Meters(meters, out); Wrap.describe$shapes_Area_shapes_Shape(shape, out); - const mapped: Wrap.Wrap = Wrap.map$u8_fmt_Pair_generics_methods_closure1(byte, (b: rt.u8): Pair.Pair => { - return { _0: b, _1: at(6) as rt.i64 }; + const mapped: Wrap.Wrap = Wrap.map$u8_fmt_Pair_generics_methods_closure1(byte, (b: rs.u8): Pair.Pair => { + return { _0: b, _1: at(6) as rs.i64 }; }); const _119: Wrap.Wrap = Wrap.new$fmt_Pair({ _0: at(1), _1: 0 }); const _116: boolean = Wrap.eq$cmp_PartialEq_fmt_Pair(mapped, _119); - const args6: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rt.Formatter) => rt.fmtBool(_116, f)]; - put(out, rt.fmtFormat([args6[0], " ", args6[1]])); - const iter: rt.Iter> = rt.iterSlice(copy$array_generics_Either_u8_shapes_Point([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_fmt_Pair(mapped, f), (f: rs.Formatter) => rs.fmtBool(_116, f)]; + put(out, rs.fmtFormat([args6[0], " ", args6[1]])); + const iter: rs.Iter> = rs.iterSlice(copy$array_generics_Either_u8_shapes_Point([{ tag: "Left", _0: at(7) } as Either.Either, { tag: "Right", value: Point.new(1, -1) } as Either.Either, { tag: "Neither" } as Either.Either])); while (true) { - const _140: Either.Either | rt.Done = iter.next(); - if (_140 === rt.DONE) { + const _140: Either.Either | rs.Done = iter.next(); + if (_140 === rs.DONE) { break; } - const either: Either.Either = _140; - const flipped: Either.Either = Either.flip$u8_shapes_Point(either); - const _153: rt.u8 | undefined = Either.left$u8_shapes_Point(either); + const either: Either.Either = _140; + const flipped: Either.Either = Either.flip$u8_shapes_Point(either); + const _153: rs.u8 | undefined = Either.left$u8_shapes_Point(either); const _156: Point.Point | undefined = Either.left$shapes_Point_u8(flipped); - const args8: rt.Fmt[] = [(f: rt.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rt.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rt.Formatter) => rt.fmtOption(_153, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(_156, f, (value: Point.Point, f: rt.Formatter) => Point.fmt$fmt_Debug(value, f))]; - put(out, rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Either.fmt$fmt_Debug_u8_shapes_Point(either, f), (f: rs.Formatter) => Either.fmt$fmt_Debug_shapes_Point_u8(flipped, f), (f: rs.Formatter) => rs.fmtOption(_153, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(_156, f, (value: Point.Point, f: rs.Formatter) => Point.fmt$fmt_Debug(value, f))]; + put(out, rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[1]), " ", args8[2], " ", args8[3]])); } - const list: Wrap.Wrap> = new Wrap.Wrap(new rt.Vec(), 1); - const _171: rt.u16 = at(10) as rt.u16; + const list: Wrap.Wrap> = new Wrap.Wrap(new rs.Vec(), 1); + const _171: rs.u16 = at(10) as rs.u16; list.value.items.push(_171); Wrap.bump$Vec_u16(list); - const none: Wrap.Wrap = new Wrap.Wrap(undefined, 0); - const some: Wrap.Wrap = Wrap.new$Option_u8(rt.byteSliceGet(data, 11)); - const err: Wrap.Wrap> = new Wrap.Wrap(rt.Err({ tag: "Dot" } as Shape.Shape), 2); - const _193: rt.u8 = option_unwrapOr$0r2bmpr(Wrap.get$Option_u8(none), some.count); - const args10: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rt.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rt.Formatter) => rt.u8Debug(_193, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); - const tagged: Tagged.Tagged, rt.i16> = new Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rt.i16Sub(at(8) as rt.i16, 100)), rt.vecFrom([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rt.i16)].slice())); - const _237: Wrap.Wrap | undefined = Tagged.first$generics_Either_u8_u16_i16(tagged); - const args12: rt.Fmt[] = [(f: rt.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rt.Formatter) => rt.fmtOption(_237, f, (value: Wrap.Wrap, f: rt.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; - put(out, rt.fmtFormat([args12[0], " ", args12[1]])); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(tagged.inner.value))); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(Either.left$u8_u16(tagged.key), 0)); + const none: Wrap.Wrap = new Wrap.Wrap(undefined, 0); + const some: Wrap.Wrap = Wrap.new$Option_u8(rs.byteSliceGet(data, 11)); + const err: Wrap.Wrap> = new Wrap.Wrap(rs.Err({ tag: "Dot" } as Shape.Shape), 2); + const _193: rs.u8 = option_unwrapOr$1fr498u(Wrap.get$Option_u8(none), some.count); + const args10: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Debug_Vec_u16(list, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(none, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Option_u8(some, f), (f: rs.Formatter) => Wrap.fmt$fmt_Debug_Result_u8_shapes_Shape(err, f), (f: rs.Formatter) => rs.u8Debug(_193, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2], " ", args10[3], " ", args10[4]])); + const tagged: Tagged.Tagged, rs.i16> = new Tagged.Tagged({ tag: "Right", value: 500 } as Either.Either, Wrap.new$i16(rs.i16Sub(at(8) as rs.i16, 100)), rs.vecFrom([Wrap.new$i16(-1), Wrap.new$i16(at(9) as rs.i16)].slice())); + const _237: Wrap.Wrap | undefined = Tagged.first$generics_Either_u8_u16_i16(tagged); + const args12: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_generics_Either_u8_u16_i16(tagged, f), (f: rs.Formatter) => rs.fmtOption(_237, f, (value: Wrap.Wrap, f: rs.Formatter) => Wrap.fmt$fmt_Debug_i16(value, f))]; + put(out, rs.fmtFormat([args12[0], " ", args12[1]])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(tagged.inner.value))); + rs.byteVecPush(out, option_unwrapOr$1fr498u(Either.left$u8_u16(tagged.key), 0)); } /** @@ -87,7 +87,7 @@ export function methods(data: rt.ByteSlice, out: rt.ByteVec): void { * the copy of one that must not see it. */ export function advance(track: Track.Track): void { - const _2: rt.u8 = rt.u8WrappingAdd(track.mark.at, 1); + const _2: rs.u8 = rs.u8WrappingAdd(track.mark.at, 1); track.mark.at = _2; } @@ -96,10 +96,10 @@ export function advance(track: Track.Track): void { * type of. */ export function reset$shapes_Gauge(xs: shapes_Gauge.Gauge[]): void { - const iter: rt.Iter = rt.iterSlice(xs); + const iter: rs.Iter = rs.iterSlice(xs); while (true) { - const _5: shapes_Gauge.Gauge | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: shapes_Gauge.Gauge | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } Object.assign(_5, copy$shapes_Gauge(shapes_Gauge.default$Default())); @@ -107,25 +107,25 @@ export function reset$shapes_Gauge(xs: shapes_Gauge.Gauge[]): void { } /** `fixed` with its pair swapped, in a copy of it. */ -export function swapped$u16(fixed: Fixed.Fixed): Fixed.Fixed { - const copy: Fixed.Fixed = copy$generics_Fixed_u16(fixed); - rt.sliceSwap(copy.pair as rt.u16[], 0, 1); +export function swapped$u16(fixed: Fixed.Fixed): Fixed.Fixed { + const copy: Fixed.Fixed = copy$generics_Fixed_u16(fixed); + rs.sliceSwap(copy.pair as rs.u16[], 0, 1); return copy$generics_Fixed_u16(copy); } /** `fixed` with its pair swapped, in a copy of it. */ -export function swapped$u8(fixed: Fixed.Fixed): Fixed.Fixed { - const copy: Fixed.Fixed = copy$generics_Fixed_u8(fixed); - rt.byteSliceSwap(rt.byteSliceFrom(copy.pair as Uint8Array), 0, 1); +export function swapped$u8(fixed: Fixed.Fixed): Fixed.Fixed { + const copy: Fixed.Fixed = copy$generics_Fixed_u8(fixed); + rs.byteSliceSwap(rs.byteSliceFrom(copy.pair as Uint8Array), 0, 1); return copy$generics_Fixed_u8(copy); } /** Writes `item` over each element of `run`, through a `&mut` to a field. */ -export function fill$u16(run: rt.u16[], item: rt.u16): void { - const iter: rt.Iter> = rt.iterSliceMut(run); +export function fill$u16(run: rs.u16[], item: rs.u16): void { + const iter: rs.Iter> = rs.iterSliceMut(run); while (true) { - const _5: rt.Place | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.Place | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } _5.v = item; @@ -133,11 +133,11 @@ export function fill$u16(run: rt.u16[], item: rt.u16): void { } /** Writes `item` over each element of `run`, through a `&mut` to a field. */ -export function fill$u8(run: rt.ByteSlice, item: rt.u8): void { - const iter: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(run)); +export function fill$u8(run: rs.ByteSlice, item: rs.u8): void { + const iter: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(run)); while (true) { - const _5: rt.Place | rt.Done = iter.next(); - if (_5 === rt.DONE) { + const _5: rs.Place | rs.Done = iter.next(); + if (_5 === rs.DONE) { break; } _5.v = item; @@ -148,131 +148,131 @@ export function fill$u8(run: rt.ByteSlice, item: rt.u8): void { * [`Runs`], [`Run`], and [`Fixed`] at `u8`, whose runs JS keeps as bytes, and at * `u16`, then [`Runs`] and [`Run`] of values that drop, in the order of their fields. */ -export function runs(data: rt.ByteSlice, out: rt.ByteVec): void { - let _266!: rt.Cow; +export function runs(data: rs.ByteSlice, out: rs.ByteVec): void { + let _266!: rs.Cow; let run3!: Run.Run; - const data2: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { + const data2: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { return _2; }), undefined, true); - const n: rt.u8 = option_unwrapOrDefault$1q0ps0j(rt.byteSliceFirst(rt.byteVecSlice(data2))); - const runs: Runs.Runs = new Runs.Runs(rt.bytes(3).fill(n), rt.byteVecFrom(rt.byteVecView(data2)), rt.byteVecSlice(data2), rt.byteVecSlice(rt.byteVecFrom(rt.byteVecView(data2))), rt.byteVecSlice(data2), new rt.Vec(), then$1i9qaz4(rt.usizeRem(data2.length, 2) === 0, (): rt.ByteVec => { - return new rt.ByteVec(); + const n: rs.u8 = option_unwrapOrDefault$03apme8(rs.byteSliceFirst(rs.byteVecSlice(data2))); + const runs: Runs.Runs = new Runs.Runs(rs.bytes(3).fill(n), rs.byteVecFrom(rs.byteVecView(data2)), rs.byteVecSlice(data2), rs.byteVecSlice(rs.byteVecFrom(rs.byteVecView(data2))), rs.byteVecSlice(data2), new rs.Vec(), then$0y7on52(rs.usizeRem(data2.length, 2) === 0, (): rs.ByteVec => { + return new rs.ByteVec(); })); - const before: Runs.Runs = Runs.clone$Clone_u8(runs); - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), 3); + const before: Runs.Runs = Runs.clone$Clone_u8(runs); + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), 3); while (true) { - const _38: rt.u8 | rt.Done = iter.next(); - if (_38 === rt.DONE) { + const _38: rs.u8 | rs.Done = iter.next(); + if (_38 === rs.DONE) { break; } Runs.push$u8(runs, _38); } - const _44: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst((runs.pairs as rt.Vec).items), rt.byteSliceFrom); + const _44: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst((runs.pairs as rs.Vec).items), rs.byteSliceFrom); if (_44 !== undefined) { fill$u8(_44, n); } - fill$u8(rt.byteSliceRange(rt.byteSliceFrom(runs.array as Uint8Array), 1), 7); - const taken3 = runs.list as rt.ByteVec; - (runs.list as rt.ByteVec) = new rt.ByteVec(); - const taken: rt.ByteVec = taken3; - const _59: rt.ByteSlice = rt.byteVecSlice(taken); - const lent: Lends.Lends = { run: _59, last: ((a0: rt.ByteSlice): rt.u8 | undefined => { - return rt.byteSliceLast(a0); - }) as (a0: rt.SliceOf) => rt.Ptr | undefined }; - const last: rt.u8 | undefined = (lent.last as (a0: rt.ByteSlice) => rt.u8 | undefined)(runs.view as rt.ByteSlice); - const _65: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_59)); + fill$u8(rs.byteSliceRange(rs.byteSliceFrom(runs.array as Uint8Array), 1), 7); + const taken3 = runs.list as rs.ByteVec; + (runs.list as rs.ByteVec) = new rs.ByteVec(); + const taken: rs.ByteVec = taken3; + const _59: rs.ByteSlice = rs.byteVecSlice(taken); + const lent: Lends.Lends = { run: _59, last: ((a0: rs.ByteSlice): rs.u8 | undefined => { + return rs.byteSliceLast(a0); + }) as (a0: rs.SliceOf) => rs.Ptr | undefined }; + const last: rs.u8 | undefined = (lent.last as (a0: rs.ByteSlice) => rs.u8 | undefined)(runs.view as rs.ByteSlice); + const _65: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_59)); if (_65 !== undefined) { _65.v = n; } fill$u8(_59, 3); - const run: Run.Run = Runs.run$u8(runs); - const fixed: Fixed.Fixed = new Fixed.Fixed(Uint8Array.of(n, n), 1); - const copy: Fixed.Fixed = copy$generics_Fixed_u8(fixed); + const run: Run.Run = Runs.run$u8(runs); + const fixed: Fixed.Fixed = new Fixed.Fixed(Uint8Array.of(n, n), 1); + const copy: Fixed.Fixed = copy$generics_Fixed_u8(fixed); (copy.pair as Uint8Array)[0] = 9; - const swapped: Fixed.Fixed = swapped$u8(copy$generics_Fixed_u8(copy)); - const _88: rt.usize = Runs.total$u8(runs); + const swapped: Fixed.Fixed = swapped$u8(copy$generics_Fixed_u8(copy)); + const _88: rs.usize = Runs.total$u8(runs); const _91: boolean = Runs.eq$cmp_PartialEq_u8(runs, before); - const _95: rt.u8 | undefined = Run.first$u8(run); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rt.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rt.Formatter) => rt.fmtList(rt.byteVecView(taken), f, rt.u8Debug), (f: rt.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rt.Formatter) => rt.usizeDisplay(_88, f), (f: rt.Formatter) => rt.fmtBool(_91, f), (f: rt.Formatter) => rt.fmtOption(_95, f, rt.u8Debug), (f: rt.Formatter) => rt.fmtOption(last, f, rt.u8Debug)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9], " ", args2[10]])); - const data3: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.u16 => { - return _22 as rt.u16; + const _95: rs.u8 | undefined = Run.first$u8(run); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(runs, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u8(before, f), (f: rs.Formatter) => rs.fmtList(rs.byteVecView(taken), f, rs.u8Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u8(run, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(fixed, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(copy, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u8(swapped, f), (f: rs.Formatter) => rs.usizeDisplay(_88, f), (f: rs.Formatter) => rs.fmtBool(_91, f), (f: rs.Formatter) => rs.fmtOption(_95, f, rs.u8Debug), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u8Debug)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9], " ", args2[10]])); + const data3: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.u16 => { + return _22 as rs.u16; }), undefined, 2, true); - const n2: rt.u16 = option_unwrapOrDefault$001fvl5(rt.sliceFirst(data3.items)); - const runs2: Runs.Runs = new Runs.Runs(Array.from({ length: 3 }, (): rt.u16 => { + const n2: rs.u16 = option_unwrapOrDefault$0w7995p(rs.sliceFirst(data3.items)); + const runs2: Runs.Runs = new Runs.Runs(Array.from({ length: 3 }, (): rs.u16 => { return n2; - }), rt.vecFrom(data3.items.slice()), data3.items, rt.vecFrom(data3.items.slice()).items, new rt.Borrowed(data3.items), new rt.Vec(), then$1he9dd4(rt.usizeRem(data3.items.length, 2) === 0, (): rt.Vec => { - return new rt.Vec(); + }), rs.vecFrom(data3.items.slice()), data3.items, rs.vecFrom(data3.items.slice()).items, new rs.Borrowed(data3.items), new rs.Vec(), then$01xsbgy(rs.usizeRem(data3.items.length, 2) === 0, (): rs.Vec => { + return new rs.Vec(); })); - const before2: Runs.Runs = Runs.clone$Clone_u16(runs2); - const iter2: rt.Iter = rt.iterTake(rt.iterSlice(data3.items), 3); + const before2: Runs.Runs = Runs.clone$Clone_u16(runs2); + const iter2: rs.Iter = rs.iterTake(rs.iterSlice(data3.items), 3); while (true) { - const _154: rt.u16 | rt.Done = iter2.next(); - if (_154 === rt.DONE) { + const _154: rs.u16 | rs.Done = iter2.next(); + if (_154 === rs.DONE) { break; } Runs.push$u16(runs2, _154); } - const _160: rt.u16[] | undefined = rt.sliceFirst((runs2.pairs as rt.Vec).items); + const _160: rs.u16[] | undefined = rs.sliceFirst((runs2.pairs as rs.Vec).items); if (_160 !== undefined) { fill$u16(_160, n2); } - fill$u16(rt.sliceRangeMut(runs2.array as rt.u16[], 1), 7 as rt.u16); - const taken4 = runs2.list as rt.Vec; - (runs2.list as rt.Vec) = new rt.Vec(); - const taken2: rt.Vec = taken4; - const _175: rt.u16[] = taken2.items; - const lent2: Lends.Lends = { run: _175, last: ((a02: rt.u16[]): rt.u16 | undefined => { - return rt.sliceLast(a02); - }) as (a0: rt.SliceOf) => rt.Ptr | undefined }; - const last2: rt.u16 | undefined = (lent2.last as (a0: rt.u16[]) => rt.u16 | undefined)(runs2.view as rt.u16[]); - const _181: rt.Place | undefined = rt.sliceLastMut(_175); + fill$u16(rs.sliceRangeMut(runs2.array as rs.u16[], 1), 7 as rs.u16); + const taken4 = runs2.list as rs.Vec; + (runs2.list as rs.Vec) = new rs.Vec(); + const taken2: rs.Vec = taken4; + const _175: rs.u16[] = taken2.items; + const lent2: Lends.Lends = { run: _175, last: ((a02: rs.u16[]): rs.u16 | undefined => { + return rs.sliceLast(a02); + }) as (a0: rs.SliceOf) => rs.Ptr | undefined }; + const last2: rs.u16 | undefined = (lent2.last as (a0: rs.u16[]) => rs.u16 | undefined)(runs2.view as rs.u16[]); + const _181: rs.Place | undefined = rs.sliceLastMut(_175); if (_181 !== undefined) { _181.v = n2; } - fill$u16(_175, 3 as rt.u16); - const run2: Run.Run = Runs.run$u16(runs2); - const fixed2: Fixed.Fixed = new Fixed.Fixed([n2, n2], 1); - const copy2: Fixed.Fixed = copy$generics_Fixed_u16(fixed2); - (copy2.pair as rt.u16[])[0] = 9 as rt.u16; - const swapped2: Fixed.Fixed = swapped$u16(copy$generics_Fixed_u16(copy2)); - const _204: rt.usize = Runs.total$u16(runs2); + fill$u16(_175, 3 as rs.u16); + const run2: Run.Run = Runs.run$u16(runs2); + const fixed2: Fixed.Fixed = new Fixed.Fixed([n2, n2], 1); + const copy2: Fixed.Fixed = copy$generics_Fixed_u16(fixed2); + (copy2.pair as rs.u16[])[0] = 9 as rs.u16; + const swapped2: Fixed.Fixed = swapped$u16(copy$generics_Fixed_u16(copy2)); + const _204: rs.usize = Runs.total$u16(runs2); const _207: boolean = Runs.eq$cmp_PartialEq_u16(runs2, before2); - const _211: rt.u16 | undefined = Run.first$u16(run2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rt.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rt.Formatter) => rt.fmtList(taken2.items, f, rt.u16Debug), (f: rt.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rt.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rt.Formatter) => rt.usizeDisplay(_204, f), (f: rt.Formatter) => rt.fmtBool(_207, f), (f: rt.Formatter) => rt.fmtOption(_211, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtOption(last2, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], " ", args4[7], " ", args4[8], " ", args4[9], " ", args4[10]])); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const tick: (a0: rt.u8) => Ticked.Ticked = (id: rt.u8): Ticked.Ticked => { - return new Ticked.Ticked(id, rt.arcClone(log)); + const _211: rs.u16 | undefined = Run.first$u16(run2); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(runs2, f), (f: rs.Formatter) => Runs.fmt$fmt_Debug_u16(before2, f), (f: rs.Formatter) => rs.fmtList(taken2.items, f, rs.u16Debug), (f: rs.Formatter) => Run.fmt$fmt_Debug_u16(run2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(fixed2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(copy2, f), (f: rs.Formatter) => Fixed.fmt$fmt_Debug_u16(swapped2, f), (f: rs.Formatter) => rs.usizeDisplay(_204, f), (f: rs.Formatter) => rs.fmtBool(_207, f), (f: rs.Formatter) => rs.fmtOption(_211, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4], " ", args4[5], " ", args4[6], " ", args4[7], " ", args4[8], " ", args4[9], " ", args4[10]])); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const tick: (a0: rs.u8) => Ticked.Ticked = (id: rs.u8): Ticked.Ticked => { + return new Ticked.Ticked(id, rs.arcClone(log)); }; - const ticks: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): Ticked.Ticked => { + const ticks: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): Ticked.Ticked => { return tick(_28); }), undefined, 8, true); const _246: Ticked.Ticked[] = [tick(1), tick(2), tick(3)]; - const _256: rt.Vec = rt.vecFrom(ticks.items.map(Ticked.clone$Clone)); + const _256: rs.Vec = rs.vecFrom(ticks.items.map(Ticked.clone$Clone)); const _258: Ticked.Ticked[] = ticks.items; const _260: Ticked.Ticked[] = [tick(4)]; - if (rt.usizeRem(data.length, 2) === 0) { - _266 = new rt.Borrowed(ticks.items); + if (rs.usizeRem(data.length, 2) === 0) { + _266 = new rs.Borrowed(ticks.items); } else { - _266 = rt.vecFrom([tick(7)]); + _266 = rs.vecFrom([tick(7)]); } - new Runs.Runs(_246, _256, _258, _260, _266, rt.vecFrom([[tick(5), tick(6)]]), option_map$0zbvahh(rt.byteSliceFirst(data), (_210: rt.u8): rt.Vec => { - return rt.vecFrom([tick(~_210 & 0xff)]); + new Runs.Runs(_246, _256, _258, _260, _266, rs.vecFrom([[tick(5), tick(6)]]), option_map$0ggarad(rs.byteSliceFirst(data), (_210: rs.u8): rs.Vec => { + return rs.vecFrom([tick(~_210 & 0xff)]); }))[Symbol.dispose](); - const _292: rt.usize = rt.usizeRem(data.length, 3); + const _292: rs.usize = rs.usizeRem(data.length, 3); if (_292 === 0) { - run3 = { tag: "Listed", _0: rt.vecFrom([tick(8)]) } as Run.Run; + run3 = { tag: "Listed", _0: rs.vecFrom([tick(8)]) } as Run.Run; } else if (_292 === 1) { run3 = { tag: "Fixed", array: [tick(9), tick(10)] } as Run.Run; } else { run3 = { tag: "Empty" } as Run.Run; } drop$generics_Run_generics_Ticked(run3); - rt.dropVec(ticks); - const _315: rt.RefCell = rt.refCellBorrow(log.value); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_315.value))), undefined, true); - rt.refRelease(_315); + rs.dropVec(ticks); + const _315: rs.RefCell = rs.refCellBorrow(log.value); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_315.value))), undefined, true); + rs.refRelease(_315); log[Symbol.dispose](); } diff --git a/ts/fixtures/lang/shapes/expected/harness.ts b/ts/fixtures/lang/shapes/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/shapes/expected/harness.ts +++ b/ts/fixtures/lang/shapes/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/shapes/expected/lib.ts b/ts/fixtures/lang/shapes/expected/lib.ts index 585b482b5..2c990a1aa 100644 --- a/ts/fixtures/lang/shapes/expected/lib.ts +++ b/ts/fixtures/lang/shapes/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { ints, strings, derived, written, counts, rounding, panics, wrapped, collections, enums, iters, adaptors, writes, objects, sources, sets, calls, cells, searches } from "./fmt.ts"; import { methods, runs } from "./generics.ts"; import type * as Either from "./generics.Either.ts"; @@ -21,19 +21,19 @@ export function copy$Option_shapes_Shape(v: Shape.Shape | undefined): Shape.Shap return v === undefined ? v : copy$shapes_Shape(v); } -export function copy$Option_tuple2_ref_sync_Mutex_u8_u8(v: [rt.Mutex, rt.u8] | undefined): [rt.Mutex, rt.u8] | undefined { +export function copy$Option_tuple2_ref_sync_Mutex_u8_u8(v: [rs.Mutex, rs.u8] | undefined): [rs.Mutex, rs.u8] | undefined { return v === undefined ? v : copy$tuple2_ref_sync_Mutex_u8_u8(v); } -export function copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(v: rt.Result<[rt.Mutex, rt.u8], rt.u8>): rt.Result<[rt.Mutex, rt.u8], rt.u8> { - return v.ok ? rt.Ok(copy$tuple2_ref_sync_Mutex_u8_u8(v.value)) : rt.Err(v.error); +export function copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(v: rs.Result<[rs.Mutex, rs.u8], rs.u8>): rs.Result<[rs.Mutex, rs.u8], rs.u8> { + return v.ok ? rs.Ok(copy$tuple2_ref_sync_Mutex_u8_u8(v.value)) : rs.Err(v.error); } -export function copy$array_generics_Either_u8_shapes_Point(v: Either.Either[]): Either.Either[] { +export function copy$array_generics_Either_u8_shapes_Point(v: Either.Either[]): Either.Either[] { return v.map(copy$generics_Either_u8_shapes_Point); } -export function copy$array_ref_sync_Mutex_u8(v: rt.Mutex[]): rt.Mutex[] { +export function copy$array_ref_sync_Mutex_u8(v: rs.Mutex[]): rs.Mutex[] { return v.slice(); } @@ -41,11 +41,11 @@ export function copy$array_shapes_Point(v: Point.Point[]): Point.Point[] { return v.map(copy$shapes_Point); } -export function copy$array_tuple2_u8_u8(v: [rt.u8, rt.u8][]): [rt.u8, rt.u8][] { +export function copy$array_tuple2_u8_u8(v: [rs.u8, rs.u8][]): [rs.u8, rs.u8][] { return v.map(copy$tuple2_u8_u8); } -export function copy$array_u16(v: rt.u16[]): rt.u16[] { +export function copy$array_u16(v: rs.u16[]): rs.u16[] { return v.slice(); } @@ -53,7 +53,7 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$generics_Either_u8_shapes_Point(v: Either.Either): Either.Either { +export function copy$generics_Either_u8_shapes_Point(v: Either.Either): Either.Either { if (v.tag === "Left") { return { tag: "Left", _0: v._0 }; } @@ -63,11 +63,11 @@ export function copy$generics_Either_u8_shapes_Point(v: Either.Either): Fixed.Fixed { - return new Fixed.Fixed(copy$array_u16(v.pair as rt.u16[]), v.tag); +export function copy$generics_Fixed_u16(v: Fixed.Fixed): Fixed.Fixed { + return new Fixed.Fixed(copy$array_u16(v.pair as rs.u16[]), v.tag); } -export function copy$generics_Fixed_u8(v: Fixed.Fixed): Fixed.Fixed { +export function copy$generics_Fixed_u8(v: Fixed.Fixed): Fixed.Fixed { return new Fixed.Fixed(copy$array_u8(v.pair as Uint8Array), v.tag); } @@ -75,16 +75,16 @@ export function copy$generics_Wrap_shapes_Point(v: Wrap.Wrap): Wrap return new Wrap.Wrap(copy$shapes_Point(v.value), v.count); } -export function copy$generics_Wrap_u8(v: Wrap.Wrap): Wrap.Wrap { +export function copy$generics_Wrap_u8(v: Wrap.Wrap): Wrap.Wrap { return new Wrap.Wrap(v.value, v.count); } -export function copy$ops_ControlFlow_ref_sync_Arc_u8_array1_u8(v: rt.Result>): rt.Result> { - return v.ok ? rt.Ok(copy$array_u8(v.value)) : rt.Err(v.error); +export function copy$ops_ControlFlow_ref_sync_Arc_u8_array1_u8(v: rs.Result>): rs.Result> { + return v.ok ? rs.Ok(copy$array_u8(v.value)) : rs.Err(v.error); } -export function copy$ops_ControlFlow_unit_array2_u8(v: rt.Result): rt.Result { - return v.ok ? rt.Ok(copy$array_u8(v.value)) : rt.Err(v.error); +export function copy$ops_ControlFlow_unit_array2_u8(v: rs.Result): rs.Result { + return v.ok ? rs.Ok(copy$array_u8(v.value)) : rs.Err(v.error); } export function copy$shapes_Gauge(v: shapes_Gauge.Gauge): shapes_Gauge.Gauge { @@ -121,39 +121,39 @@ export function copy$shapes_Shape(v: Shape.Shape): Shape.Shape { return v; } -export function copy$task_Poll_array1_u8(v: rt.Poll): rt.Poll { - return v === rt.Pending ? v : copy$array_u8(v); +export function copy$task_Poll_array1_u8(v: rs.Poll): rs.Poll { + return v === rs.Pending ? v : copy$array_u8(v); } -export function copy$tuple2_ref_sync_Mutex_u8_u8(v: [rt.Mutex, rt.u8]): [rt.Mutex, rt.u8] { +export function copy$tuple2_ref_sync_Mutex_u8_u8(v: [rs.Mutex, rs.u8]): [rs.Mutex, rs.u8] { return [v[0], v[1]]; } -export function copy$tuple2_shapes_Point_u8(v: [Point.Point, rt.u8]): [Point.Point, rt.u8] { +export function copy$tuple2_shapes_Point_u8(v: [Point.Point, rs.u8]): [Point.Point, rs.u8] { return [copy$shapes_Point(v[0]), v[1]]; } -export function copy$tuple2_u8_u8(v: [rt.u8, rt.u8]): [rt.u8, rt.u8] { +export function copy$tuple2_u8_u8(v: [rs.u8, rs.u8]): [rs.u8, rs.u8] { return [v[0], v[1]]; } export function drop$generics_Run_generics_Ticked(_1: Run.Run): void { if (_1.tag === "Listed") { - rt.dropVec(_1._0 as rt.Vec); + rs.dropVec(_1._0 as rs.Vec); } else if (_1.tag === "Fixed") { - rt.dropAll(_1.array as Ticked.Ticked[]); + rs.dropAll(_1.array as Ticked.Ticked[]); } } export class of$u8 { - v: rt.u8; + v: rs.u8; - constructor(v: rt.u8) { + constructor(v: rs.u8) { this.v = v; } } -export const out$Option_u8: { p: rt.u8 | undefined } = { p: undefined as never }; +export const out$Option_u8: { p: rs.u8 | undefined } = { p: undefined as never }; export const out$u8: { err: unknown } = { err: undefined }; @@ -161,64 +161,64 @@ export const out$u8: { err: unknown } = { err: undefined }; * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["fmt::ints", ints as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::strings", (_210: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["fmt::ints", ints as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::strings", (_210: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { strings(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::derived", (_211: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::derived", (_211: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { derived(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::written", (_212: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::written", (_212: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { written(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::panics", panics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::counts", (_213: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::panics", panics as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::counts", (_213: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { counts(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::rounding", (_214: rt.u8, _310: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::rounding", (_214: rs.u8, _310: rs.ByteSlice, out5: rs.ByteVec): undefined => { rounding(out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::wrapped", (_215: rt.u8, data5: rt.ByteSlice, out6: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::wrapped", (_215: rs.u8, data5: rs.ByteSlice, out6: rs.ByteVec): undefined => { wrapped(data5, out6); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::writes", (_216: rt.u8, data6: rt.ByteSlice, out7: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::writes", (_216: rs.u8, data6: rs.ByteSlice, out7: rs.ByteVec): undefined => { writes(data6, out7); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::collections", (_217: rt.u8, data7: rt.ByteSlice, out8: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::collections", (_217: rs.u8, data7: rs.ByteSlice, out8: rs.ByteVec): undefined => { collections(data7, out8); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::iters", (_218: rt.u8, data8: rt.ByteSlice, out9: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::iters", (_218: rs.u8, data8: rs.ByteSlice, out9: rs.ByteVec): undefined => { iters(data8, out9); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::enums", (_219: rt.u8, data9: rt.ByteSlice, out10: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::enums", (_219: rs.u8, data9: rs.ByteSlice, out10: rs.ByteVec): undefined => { enums(data9, out10); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_220: rt.u8, data10: rt.ByteSlice, out11: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::objects", (_220: rs.u8, data10: rs.ByteSlice, out11: rs.ByteVec): undefined => { objects(data10, out11); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::methods", (_221: rt.u8, data11: rt.ByteSlice, out12: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["generics::methods", (_221: rs.u8, data11: rs.ByteSlice, out12: rs.ByteVec): undefined => { methods(data11, out12); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["generics::runs", (_222: rt.u8, data12: rt.ByteSlice, out13: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["generics::runs", (_222: rs.u8, data12: rs.ByteSlice, out13: rs.ByteVec): undefined => { runs(data12, out13); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::copies", (_223: rt.u8, data13: rt.ByteSlice, out14: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::copies", (_223: rs.u8, data13: rs.ByteSlice, out14: rs.ByteVec): undefined => { copies(data13, out14); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::loops", (_224: rt.u8, data14: rt.ByteSlice, out15: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::loops", (_224: rs.u8, data14: rs.ByteSlice, out15: rs.ByteVec): undefined => { loops(data14, out15); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::patterns", (_225: rt.u8, data15: rt.ByteSlice, out16: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::patterns", (_225: rs.u8, data15: rs.ByteSlice, out16: rs.ByteVec): undefined => { patterns(data15, out16); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::closures", (_226: rt.u8, data16: rt.ByteSlice, out17: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::closures", (_226: rs.u8, data16: rs.ByteSlice, out17: rs.ByteVec): undefined => { closures(data16, out17); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::discriminants", (_227: rt.u8, data17: rt.ByteSlice, out18: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::discriminants", (_227: rs.u8, data17: rs.ByteSlice, out18: rs.ByteVec): undefined => { discriminants(data17, out18); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::library", (_228: rt.u8, data18: rt.ByteSlice, out19: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::library", (_228: rs.u8, data18: rs.ByteSlice, out19: rs.ByteVec): undefined => { library(data18, out19); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::order", (_229: rt.u8, data19: rt.ByteSlice, out20: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::order", (_229: rs.u8, data19: rs.ByteSlice, out20: rs.ByteVec): undefined => { order(data19, out20); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::flows", (_230: rt.u8, data20: rt.ByteSlice, out21: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::flows", (_230: rs.u8, data20: rs.ByteSlice, out21: rs.ByteVec): undefined => { flows(data20, out21); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shapes::uninhabited", (_231: rt.u8, data21: rt.ByteSlice, out22: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shapes::uninhabited", (_231: rs.u8, data21: rs.ByteSlice, out22: rs.ByteVec): undefined => { uninhabited(data21, out22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::adaptors", (_232: rt.u8, data22: rt.ByteSlice, out23: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::adaptors", (_232: rs.u8, data22: rs.ByteSlice, out23: rs.ByteVec): undefined => { adaptors(data22, out23); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::sources", (_233: rt.u8, data23: rt.ByteSlice, out24: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::sources", (_233: rs.u8, data23: rs.ByteSlice, out24: rs.ByteVec): undefined => { sources(data23, out24); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::sets", (_234: rt.u8, data24: rt.ByteSlice, out25: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::sets", (_234: rs.u8, data24: rs.ByteSlice, out25: rs.ByteVec): undefined => { sets(data24, out25); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::calls", (_235: rt.u8, data25: rt.ByteSlice, out26: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::calls", (_235: rs.u8, data25: rs.ByteSlice, out26: rs.ByteVec): undefined => { calls(data25, out26); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::cells", (_236: rt.u8, data26: rt.ByteSlice, out27: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::cells", (_236: rs.u8, data26: rs.ByteSlice, out27: rs.ByteVec): undefined => { cells(data26, out27); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::searches", (_237: rt.u8, data27: rt.ByteSlice, out28: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["fmt::searches", (_237: rs.u8, data27: rs.ByteSlice, out28: rs.ByteVec): undefined => { searches(data27, out28); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Filled.ts b/ts/fixtures/lang/shapes/expected/shapes.Filled.ts index 411a5e9c4..51ad50a99 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Filled.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Filled.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$shapes_Point } from "./lib.ts"; import * as Point from "./shapes.Point.ts"; import type * as Shape from "./shapes.Shape.ts"; @@ -22,7 +22,7 @@ export function fill(self: Filled): void { self.shape = _2; } -export function run(self: Filled): rt.u8 { +export function run(self: Filled): rs.u8 { if (self.shape === undefined) { fill(self); if ((self.shape as Shape.Shape | undefined) === undefined) { diff --git a/ts/fixtures/lang/shapes/expected/shapes.Gauge.ts b/ts/fixtures/lang/shapes/expected/shapes.Gauge.ts index a5517f656..eb73ea6fd 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Gauge.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Gauge.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Gauge { return { level: 0 }; @@ -8,7 +8,7 @@ export function default$Default(): Gauge { /** A `Copy` struct written into only behind a type parameter, by `generics::reset`. */ export interface Gauge { - level: rt.u8; + level: rs.u8; } //# sourceMappingURL=shapes.Gauge.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Lens.ts b/ts/fixtures/lang/shapes/expected/shapes.Lens.ts index c86f9609a..cd1fe7be9 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Lens.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Lens.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` struct holding a shared reference to a value that changes through it. */ export interface Lens { - slot: rt.Mutex; - n: rt.u8; + slot: rs.Mutex; + n: rs.u8; } //# sourceMappingURL=shapes.Lens.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Level.ts b/ts/fixtures/lang/shapes/expected/shapes.Level.ts index 46839714e..c7455f019 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Level.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Level.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` struct written into only through a box. */ export interface Level { - _0: rt.u8; + _0: rs.u8; } //# sourceMappingURL=shapes.Level.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Machine.ts b/ts/fixtures/lang/shapes/expected/shapes.Machine.ts index e8275e9f3..127936dd0 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Machine.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Machine.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$shapes_Point } from "./lib.ts"; import * as Point from "./shapes.Point.ts"; import * as Shape from "./shapes.Shape.ts"; @@ -8,12 +8,12 @@ import * as Shape from "./shapes.Shape.ts"; /** A state a method matches, changing it between its matches. */ export interface Machine { state: Shape.Shape; - steps: rt.u8; + steps: rs.u8; } export function step(self: Machine): void { let _3!: Shape.Shape; - self.steps = rt.u8Add(self.steps, 1); + self.steps = rs.u8Add(self.steps, 1); if (self.state.tag === "Dot") { _3 = { tag: "Line", _0: copy$shapes_Point(Point.new(1, 2)), _1: copy$shapes_Point(Point.new(3, 4)) } as Shape.Shape; } else if (self.state.tag === "Line") { @@ -25,16 +25,16 @@ export function step(self: Machine): void { } /** Reads the state, which a shared borrow can't change. */ -export function peek(self: Machine): rt.u8 { - return self.steps ^ (rt.u64Low(Shape.area$shapes_Area(self.state)) & 0xff); +export function peek(self: Machine): rs.u8 { + return self.steps ^ (rs.u64Low(Shape.area$shapes_Area(self.state)) & 0xff); } -export function log(self: Machine, v: rt.u8): rt.u8 { - self.steps = rt.u8WrappingAdd(self.steps, v); +export function log(self: Machine, v: rs.u8): rs.u8 { + self.steps = rs.u8WrappingAdd(self.steps, v); return self.steps; } -export function run(self: Machine, n: rt.u8): rt.u8 { +export function run(self: Machine, n: rs.u8): rs.u8 { if (self.state.tag === "Dot") { step(self); if ((self.state as Shape.Shape).tag === "Line") { @@ -43,11 +43,11 @@ export function run(self: Machine, n: rt.u8): rt.u8 { return 27; } if (self.state.tag === "Line") { - const seen: rt.u8 = peek(self); + const seen: rs.u8 = peek(self); return (self.state._1.y & 0xff) ^ seen; } - const width: rt.u16 = self.state.width; - const logged: rt.u8 = log(self, self.state.height & 0xff); + const width: rs.u16 = self.state.width; + const logged: rs.u8 = log(self, self.state.height & 0xff); step(self); if (self.state.tag === "Rect") { return 30; diff --git a/ts/fixtures/lang/shapes/expected/shapes.Mark.ts b/ts/fixtures/lang/shapes/expected/shapes.Mark.ts index 3b0d6eedb..441b753d6 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Mark.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Mark.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` struct this module never writes into: only `generics::advance` does. */ export interface Mark { - at: rt.u8; + at: rs.u8; } //# sourceMappingURL=shapes.Mark.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Meters.ts b/ts/fixtures/lang/shapes/expected/shapes.Meters.ts index 3655ca807..0fe9ec3f6 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Meters.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Meters.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A tuple struct. */ export interface Meters { - _0: rt.u64; + _0: rs.u64; } -export function area$shapes_Area(self: Meters): rt.u64 { +export function area$shapes_Area(self: Meters): rs.u64 { return self._0; } /** A default method, monomorphized for each type. */ -export function describe$shapes_Area(self: Meters, out: rt.ByteVec): void { - rt.byteVecPush(out, 170); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(self._0))); +export function describe$shapes_Area(self: Meters, out: rs.ByteVec): void { + rs.byteVecPush(out, 170); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(self._0))); } //# sourceMappingURL=shapes.Meters.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Moved.ts b/ts/fixtures/lang/shapes/expected/shapes.Moved.ts index 7c486a2ce..5a6009de7 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Moved.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Moved.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Moved, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Moved, f: rs.Formatter): rs.Result { const _3: string = "Moved"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - const _6: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self._1, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + const _6: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._1, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); } /** A tuple struct that is not `Copy`, so struct update syntax reads its base in place. */ export interface Moved { - _0: rt.u8; - _1: rt.u16; + _0: rs.u8; + _1: rs.u16; } //# sourceMappingURL=shapes.Moved.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Partial.ts b/ts/fixtures/lang/shapes/expected/shapes.Partial.ts index f5b65acea..427617aee 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Partial.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Partial.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Void from "./shapes.Void.ts"; /** An enum whose other variant holds a value that can't exist. */ -export type Partial = { tag: "Real"; _0: rt.u8 } | { tag: "Never"; _0: Void.Void }; +export type Partial = { tag: "Real"; _0: rs.u8 } | { tag: "Never"; _0: Void.Void }; //# sourceMappingURL=shapes.Partial.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Parts.ts b/ts/fixtures/lang/shapes/expected/shapes.Parts.ts index 5bcc4fc8d..751236118 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Parts.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Parts.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Void from "./shapes.Void.ts"; /** A struct whose fields' other variants can't exist. */ export interface Parts { - left: rt.Result; - right: rt.Result | undefined; + left: rs.Result; + right: rs.Result | undefined; } //# sourceMappingURL=shapes.Parts.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Point.ts b/ts/fixtures/lang/shapes/expected/shapes.Point.ts index c27010551..e19009318 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Point.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Point.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$shapes_Point } from "./lib.ts"; -export function fmt$fmt_Debug(self: Point, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Point, f: rs.Formatter): rs.Result { const _3: string = "Point"; const _4: string = "x"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.i32Debug(self.x, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self.x, f); const _7: string = "y"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.i32Debug(self.y, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self.y, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } export function eq$cmp_PartialEq(self: Point, other: Point): boolean { @@ -21,23 +21,23 @@ export function eq$cmp_PartialEq(self: Point, other: Point): boolean { /** A `Copy` struct, which Rust copies where JS would share. */ export interface Point { - x: rt.i32; - y: rt.i32; + x: rs.i32; + y: rs.i32; } -function new_(x: rt.i32, y: rt.i32): Point { +function new_(x: rs.i32, y: rs.i32): Point { return { x, y }; } /** Changes `self`, which a caller's copy must not see. */ -export function shift(self: Point, by: rt.i32): Point { +export function shift(self: Point, by: rs.i32): Point { self = copy$shapes_Point(self); - self.x = rt.i32Add(self.x, by); + self.x = rs.i32Add(self.x, by); return copy$shapes_Point(self); } export function bump(self: Point): void { - self.y = rt.i32Add(self.y, 1); + self.y = rs.i32Add(self.y, 1); } export { new_ as new }; diff --git a/ts/fixtures/lang/shapes/expected/shapes.Shape.ts b/ts/fixtures/lang/shapes/expected/shapes.Shape.ts index 9de93d1f8..c4f3dd839 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Shape.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Shape.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Point from "./shapes.Point.ts"; -export function fmt$fmt_Debug(self: Shape, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Shape, f: rs.Formatter): rs.Result { if (self.tag === "Dot") { - return rt.fmtWriteStr(f, "Dot"); + return rs.fmtWriteStr(f, "Dot"); } if (self.tag === "Line") { const _7: string = "Line"; - const _8: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self._0, f); - const _9: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self._1, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _7), _8), _9)); + const _8: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self._0, f); + const _9: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self._1, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _7), _8), _9)); } const _14: string = "Rect"; const _15: string = "corner"; - const _16: rt.Fmt = (f: rt.Formatter) => Point.fmt$fmt_Debug(self.corner, f); + const _16: rs.Fmt = (f: rs.Formatter) => Point.fmt$fmt_Debug(self.corner, f); const _17: string = "width"; - const _18: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self.width, f); + const _18: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.width, f); const _19: string = "height"; - const _20: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self.height, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); + const _20: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self.height, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _14), _15, _16), _17, _18), _19, _20)); } export function eq$cmp_PartialEq(self: Shape, other: Shape): boolean { @@ -51,22 +51,22 @@ export function eq$cmp_PartialEq(self: Shape, other: Shape): boolean { export type Shape = | { tag: "Dot" } | { tag: "Line"; _0: Point.Point; _1: Point.Point } - | { tag: "Rect"; corner: Point.Point; width: rt.u16; height: rt.u16 }; + | { tag: "Rect"; corner: Point.Point; width: rs.u16; height: rs.u16 }; /** A default method, monomorphized for each type. */ -export function describe$shapes_Area(self: Shape, out: rt.ByteVec): void { - rt.byteVecPush(out, 4); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(area$shapes_Area(self)))); +export function describe$shapes_Area(self: Shape, out: rs.ByteVec): void { + rs.byteVecPush(out, 4); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(area$shapes_Area(self)))); } -export function area$shapes_Area(self: Shape): rt.u64 { +export function area$shapes_Area(self: Shape): rs.u64 { if (self.tag === "Dot") { return 0; } if (self.tag === "Line") { return 0; } - return rt.u64Mul(self.width as rt.u64, self.height as rt.u64); + return rs.u64Mul(self.width as rs.u64, self.height as rs.u64); } //# sourceMappingURL=shapes.Shape.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Slot.ts b/ts/fixtures/lang/shapes/expected/shapes.Slot.ts index 8d561e9fa..816a926d9 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Slot.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Slot.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A struct holding an enum, changed through a borrow of its field. */ export interface Slot { - res: rt.Result; + res: rs.Result; } //# sourceMappingURL=shapes.Slot.ts.map diff --git a/ts/fixtures/lang/shapes/expected/shapes.Void.ts b/ts/fixtures/lang/shapes/expected/shapes.Void.ts index 6f6b2e9f2..e3ddfbe90 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.Void.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.Void.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Void, _f: rt.Formatter): rt.Result { - rt.unreachable(undefined); +export function fmt$fmt_Debug(_self: Void, _f: rs.Formatter): rs.Result { + rs.unreachable(undefined); } /** An enum without variants: no value of it exists. */ diff --git a/ts/fixtures/lang/shapes/expected/shapes.ts b/ts/fixtures/lang/shapes/expected/shapes.ts index 9e977761c..cff132211 100644 --- a/ts/fixtures/lang/shapes/expected/shapes.ts +++ b/ts/fixtures/lang/shapes/expected/shapes.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_shapes_Shape, copy$Option_tuple2_ref_sync_Mutex_u8_u8, copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8, copy$array_ref_sync_Mutex_u8, copy$array_shapes_Point, copy$array_u8, copy$ops_ControlFlow_ref_sync_Arc_u8_array1_u8, copy$ops_ControlFlow_unit_array2_u8, copy$shapes_Gauge, copy$shapes_Held, copy$shapes_Lens, copy$shapes_Level, copy$shapes_Point, copy$shapes_Shape, copy$task_Poll_array1_u8, copy$tuple2_ref_sync_Mutex_u8_u8, copy$tuple2_shapes_Point_u8, copy$tuple2_u8_u8, out$Option_u8, out$u8 } from "./lib.ts"; -import { thenSome$0ztng9q, then$1i9qaz4, then$1btzga3 } from "./core/bool.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0600mq0 as option_map$0600mq0, map$18z3v8h as option_map$18z3v8h, mapOr$1a3irjf as option_mapOr$1a3irjf, mapOr$1t0muvr as option_mapOr$1t0muvr, mapOr$1ybqvup as option_mapOr$1ybqvup, mapOr$0rtdylj as option_mapOr$0rtdylj, mapOr$0aserv9 as option_mapOr$0aserv9, mapOr$1hjjwvv as option_mapOr$1hjjwvv, okOr$1vxk0yk as option_okOr$1vxk0yk } from "./core/option.ts"; -import { map$1dbyvzi as result_map$1dbyvzi, mapErr$0dzqwjy as result_mapErr$0dzqwjy } from "./core/result.ts"; +import { thenSome$1uv8pdy, then$0y7on52, then$1ldvmdq } from "./core/bool.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0600mq0 as option_map$0600mq0, map$1mgv9ns as option_map$1mgv9ns, mapOr$0g5x999 as option_mapOr$0g5x999, mapOr$1d4bp7c as option_mapOr$1d4bp7c, mapOr$04kaubd as option_mapOr$04kaubd, mapOr$092ozr9 as option_mapOr$092ozr9, mapOr$04m3h1l as option_mapOr$04m3h1l, mapOr$1c3pipy as option_mapOr$1c3pipy, okOr$1j8owgb as option_okOr$1j8owgb } from "./core/option.ts"; +import { map$1yblbjf as result_map$1yblbjf, mapErr$0hqg57m as result_mapErr$0hqg57m } from "./core/result.ts"; import * as Pair from "./fmt.Pair.ts"; import { advance, reset$shapes_Gauge as generics_reset$shapes_Gauge } from "./generics.ts"; import type * as Dir from "./shapes.Dir.ts"; @@ -28,40 +28,40 @@ import * as Track from "./shapes.Track.ts"; import * as Void from "./shapes.Void.ts"; import type * as shapes_Wide from "./shapes.Wide.ts"; -export function total$shapes_Meters(items: Meters.Meters[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; +export function total$shapes_Meters(items: Meters.Meters[], out: rs.ByteVec): rs.u64 { + let sum: rs.u64 = 0; const iterS: Meters.Meters[] = items; let iterI: number = 0; while (true) { - const _6: Meters.Meters | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_6 === rt.DONE) { + const _6: Meters.Meters | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_6 === rs.DONE) { return sum; } Meters.describe$shapes_Area(_6, out); - sum = rt.u64SaturatingAdd(sum, Meters.area$shapes_Area(_6)); + sum = rs.u64SaturatingAdd(sum, Meters.area$shapes_Area(_6)); } } -export function total$shapes_Shape(items: Shape.Shape[], out: rt.ByteVec): rt.u64 { - let sum: rt.u64 = 0; +export function total$shapes_Shape(items: Shape.Shape[], out: rs.ByteVec): rs.u64 { + let sum: rs.u64 = 0; const iterS: Shape.Shape[] = items; let iterI: number = 0; while (true) { - const _6: Shape.Shape | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_6 === rt.DONE) { + const _6: Shape.Shape | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_6 === rs.DONE) { return sum; } Shape.describe$shapes_Area(_6, out); - sum = rt.u64SaturatingAdd(sum, Shape.area$shapes_Area(_6)); + sum = rs.u64SaturatingAdd(sum, Shape.area$shapes_Area(_6)); } } -export function from$convert_From_shapes_Dir_u8(dir: Dir.Dir): rt.u8 { +export function from$convert_From_shapes_Dir_u8(dir: Dir.Dir): rs.u8 { return { North: 1, East: 2, South: 4, West: 8 }[dir] & 0xff; } -export function dir(byte: rt.u8): Dir.Dir | undefined { - const _2: rt.u8 = rt.u8Rem(byte, 5); +export function dir(byte: rs.u8): Dir.Dir | undefined { + const _2: rs.u8 = rs.u8Rem(byte, 5); if (_2 === 0) { return "North" as Dir.Dir; } @@ -79,37 +79,37 @@ export function dir(byte: rt.u8): Dir.Dir | undefined { export function shape(dataData: Uint8Array, dataStart: number, dataLen: number): Shape.Shape { if (dataLen !== 0) { - const kind: rt.u8 = dataData[dataStart]; - const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const at: (a0: rt.usize) => rt.i32 = (i: rt.usize): rt.i32 => { - return rt.i32Sub(option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, i), 0) as rt.i32, 128); + const kind: rs.u8 = dataData[dataStart]; + const rest: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const at: (a0: rs.usize) => rs.i32 = (i: rs.usize): rs.i32 => { + return rs.i32Sub(option_unwrapOr$1fr498u(rs.byteSliceGet(rest, i), 0) as rs.i32, 128); }; - const _7: rt.u8 = rt.u8Rem(kind, 3); + const _7: rs.u8 = rs.u8Rem(kind, 3); if (_7 === 0) { return { tag: "Dot" } as Shape.Shape; } if (_7 === 1) { return { tag: "Line", _0: Point.new(at(0), at(1)), _1: Point.new(at(2), at(3)) } as Shape.Shape; } - return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rt.u16Mul(option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, 2), 0) as rt.u16, 300), height: option_unwrapOr$0r2bmpr(rt.byteSliceGet(rest, 3), 0) as rt.u16 } as Shape.Shape; + return { tag: "Rect", corner: Point.new(at(0), at(1)), width: rs.u16Mul(option_unwrapOr$1fr498u(rs.byteSliceGet(rest, 2), 0) as rs.u16, 300), height: option_unwrapOr$1fr498u(rs.byteSliceGet(rest, 3), 0) as rs.u16 } as Shape.Shape; } return { tag: "Dot" } as Shape.Shape; } /** `Copy` aggregates: a copy changes apart from its original. */ -export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { +export function copies(data: rs.ByteSlice, out: rs.ByteVec): void { let _265!: Uint8Array; - let poll!: rt.Poll; - let _300!: rt.u8; - const p: Point.Point = Point.new(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.i32, 7); + let poll!: rs.Poll; + let _300!: rs.u8; + const p: Point.Point = Point.new(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.i32, 7); const q: Point.Point = copy$shapes_Point(p); - q.x = rt.i32Add(q.x, 100); + q.x = rs.i32Add(q.x, 100); Point.bump(q); const r: Point.Point = Point.shift(p, 5); - const pair: [Point.Point, rt.u8] = [copy$shapes_Point(p), 3]; - const saved: [Point.Point, rt.u8] = copy$tuple2_shapes_Point_u8(pair); + const pair: [Point.Point, rs.u8] = [copy$shapes_Point(p), 3]; + const saved: [Point.Point, rs.u8] = copy$tuple2_shapes_Point_u8(pair); pair[0].y = -1; - pair[1] = rt.u8Add(pair[1], 1); + pair[1] = rs.u8Add(pair[1], 1); const item = copy$shapes_Point(p); const grid: Point.Point[] = Array.from({ length: 3 }, (): Point.Point => { return copy$shapes_Point(item); @@ -117,17 +117,17 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { grid[1].x = 9; const row: Point.Point[] = copy$array_shapes_Point(grid); grid[2] = copy$shapes_Point(q); - const iter: rt.Iter = rt.iterSlice([p.x, p.y, q.x, q.y, r.x, saved[0].y, pair[0].y, row[1].x, row[2].x, grid[2].x]); + const iter: rs.Iter = rs.iterSlice([p.x, p.y, q.x, q.y, r.x, saved[0].y, pair[0].y, row[1].x, row[2].x, grid[2].x]); while (true) { - const _42: rt.i32 | rt.Done = iter.next(); - if (_42 === rt.DONE) { + const _42: rs.i32 | rs.Done = iter.next(); + if (_42 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(_42))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(_42))); } - rt.byteVecPush(out, saved[1]); - rt.byteVecPush(out, pair[1]); - rt.byteVecPush(out, Point.eq$cmp_PartialEq(p, saved[0]) ? 1 : 0); + rs.byteVecPush(out, saved[1]); + rs.byteVecPush(out, pair[1]); + rs.byteVecPush(out, Point.eq$cmp_PartialEq(p, saved[0]) ? 1 : 0); let a: Point.Point = copy$shapes_Point(Point.new(1, 2)); let b: Point.Point = copy$shapes_Point(Point.new(3, 4)); const swapped = a; @@ -136,26 +136,26 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const _66: Point.Point = copy$shapes_Point(Point.new(5, 6)); const old2 = a; a = _66; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a.x & 0xff, b.x & 0xff, old2.x & 0xff))); const boxed: Moved.Moved = { _0: data.length & 0xff, _1: 0 }; - boxed._1 = rt.u16Add(boxed._1, 1); - boxed._1 = rt.u16Add(boxed._1, 2); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(boxed._0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(boxed._1))); - let n: rt.u32 = data.length as rt.u32; - const both: [rt.u32, rt.u32] = [n, n]; + boxed._1 = rs.u16Add(boxed._1, 1); + boxed._1 = rs.u16Add(boxed._1, 2); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(boxed._0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(boxed._1))); + let n: rs.u32 = data.length as rs.u32; + const both: [rs.u32, rs.u32] = [n, n]; n = 9; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(rt.u32Add(both[0], both[1]), n)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32Add(rs.u32Add(both[0], both[1]), n)))); let s: string = "ab"; let t: string = "cde"; let x: Point.Point = p; let y: Point.Point = q; - const _120: [rt.u8, rt.u8] = [data.length & 0xff, 1]; - let i: rt.u8 = _120[0]; - let j: rt.u8 = 1; - const _125: rt.usize = rt.usizeRem(data.length, 3); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _125; + const _120: [rs.u8, rs.u8] = [data.length & 0xff, 1]; + let i: rs.u8 = _120[0]; + let j: rs.u8 = 1; + const _125: rs.usize = rs.usizeRem(data.length, 3); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _125; while (iterStart++ < iterEnd) { const _135: string = t; const _136: string = s; @@ -165,44 +165,44 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const _141: Point.Point = x; x = _140; y = _141; - const _144: [rt.u8, rt.u8] = [j, i]; - const _142: rt.u8 = _144[0]; - const _143: rt.u8 = _144[1]; + const _144: [rs.u8, rs.u8] = [j, i]; + const _142: rs.u8 = _144[0]; + const _143: rs.u8 = _144[1]; i = _142; j = _143; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, (x.x & 0xff) ^ i); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, (x.x & 0xff) ^ i); } - rt.byteVecPush(out, (rt.stringLen(t) & 0xff) ^ (y.y & 0xff) ^ j); + rs.byteVecPush(out, (rs.stringLen(t) & 0xff) ^ (y.y & 0xff) ^ j); const word: Uint8Array = Uint8Array.of(0, 0, 0, data.length & 0xff); - const converted: rt.u32 = rt.u32FromBeBytes(word); + const converted: rs.u32 = rs.u32FromBeBytes(word); word[0] = 9; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(converted, word[0] as rt.u32)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32Add(converted, word[0] as rs.u32)))); const cell: Uint8Array = Uint8Array.of(data.length & 0xff); - rt.byteVecPush(out, writeThenRead(copy$array_u8(cell), rt.byteSliceFrom(cell))); + rs.byteVecPush(out, writeThenRead(copy$array_u8(cell), rs.byteSliceFrom(cell))); const source: Uint8Array = Uint8Array.of(data.length & 0xff); const returned: Uint8Array = same(copy$array_u8(source)); source[0] = 9; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(returned[0], source[0]))); - rt.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rt.u8, rt.u8])); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(returned[0], source[0]))); + rs.byteVecPush(out, copyThenWrite([data.length & 0xff, 0] as [rs.u8, rs.u8])); const marked: boolean = mark(out, 1) === 0; mark(out, 2); - rt.byteVecPush(out, marked ? 1 : 0); + rs.byteVecPush(out, marked ? 1 : 0); let opt: Meters.Meters | undefined = { _0: 9 }; const taken2 = opt; opt = undefined; const taken: Meters.Meters | undefined = taken2; - rt.byteVecPush(out, opt === undefined ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(option_mapOr$1ybqvup(taken, 0, (m: Meters.Meters): rt.u64 => { + rs.byteVecPush(out, opt === undefined ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(option_mapOr$04kaubd(taken, 0, (m: Meters.Meters): rs.u64 => { return m._0; })))); - const res: rt.Result = rt.Ok(p); - const first: Point.Point = copy$shapes_Point(rt.resultUnwrap(res, rt.u8Debug)); + const res: rs.Result = rs.Ok(p); + const first: Point.Point = copy$shapes_Point(rs.resultUnwrap(res, rs.u8Debug)); first.x = 2; - const fail: rt.Result = rt.Err(copy$shapes_Point(q)); - const err: Point.Point = copy$shapes_Point(rt.resultUnwrapErr(fail, rt.u8Debug)); + const fail: rs.Result = rs.Err(copy$shapes_Point(q)); + const err: Point.Point = copy$shapes_Point(rs.resultUnwrapErr(fail, rs.u8Debug)); err.y = 3; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.x & 0xff, rt.resultUnwrap(res, rt.u8Debug).x & 0xff, err.y & 0xff, rt.resultUnwrapErr(fail, rt.u8Debug).y & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(first.x & 0xff, rs.resultUnwrap(res, rs.u8Debug).x & 0xff, err.y & 0xff, rs.resultUnwrapErr(fail, rs.u8Debug).y & 0xff))); const shape_: Shape.Shape = copy$shapes_Shape(shape(data.data, data.start, data.length)); const before: Shape.Shape = copy$shapes_Shape(shape_); if (shape_.tag !== "Dot") { @@ -214,15 +214,15 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { } } const _256: Shape.Shape = copy$shapes_Shape(shape_); - const iter3: rt.Iter = rt.iterSlice([copy$shapes_Shape(before), _256]); + const iter3: rs.Iter = rs.iterSlice([copy$shapes_Shape(before), _256]); while (true) { - const _258: Shape.Shape | rt.Done = iter3.next(); - if (_258 === rt.DONE) { + const _258: Shape.Shape | rs.Done = iter3.next(); + if (_258 === rs.DONE) { break; } const shape2: Shape.Shape = _258; if (shape2.tag === "Dot") { - _265 = rt.bytes(3); + _265 = rs.bytes(3); } else if (shape2.tag === "Line") { const from: Point.Point = shape2._0; _265 = Uint8Array.of(1, from.x & 0xff, from.y & 0xff); @@ -230,32 +230,32 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { const corner: Point.Point = shape2.corner; _265 = Uint8Array.of(corner.x & 0xff, corner.y & 0xff, shape2.width & 0xff); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_265)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(_265)); } - if (rt.usizeRem(data.length, 2) === 0) { - poll = rt.Pending as rt.Poll; + if (rs.usizeRem(data.length, 2) === 0) { + poll = rs.Pending as rs.Poll; } else { - poll = Uint8Array.of(data.length & 0xff) as rt.Poll; + poll = Uint8Array.of(data.length & 0xff) as rs.Poll; } - const polled: rt.Poll = copy$task_Poll_array1_u8(poll); - if (poll !== rt.Pending) { - const bytes: rt.ByteSlice = rt.byteSliceFrom(poll); + const polled: rs.Poll = copy$task_Poll_array1_u8(poll); + if (poll !== rs.Pending) { + const bytes: rs.ByteSlice = rs.byteSliceFrom(poll); bytes.data[bytes.start] = 9; } - const _293: rt.Poll = copy$task_Poll_array1_u8(poll); - const iter4: rt.Iter> = rt.iterSlice([copy$task_Poll_array1_u8(polled), _293]); + const _293: rs.Poll = copy$task_Poll_array1_u8(poll); + const iter4: rs.Iter> = rs.iterSlice([copy$task_Poll_array1_u8(polled), _293]); while (true) { - const _295: rt.Poll | rt.Done = iter4.next(); - if (_295 === rt.DONE) { + const _295: rs.Poll | rs.Done = iter4.next(); + if (_295 === rs.DONE) { break; } - const poll2: rt.Poll = _295; - if (poll2 !== rt.Pending) { + const poll2: rs.Poll = _295; + if (poll2 !== rs.Pending) { _300 = poll2[0]; } else { _300 = 255; } - rt.byteVecPush(out, _300); + rs.byteVecPush(out, _300); } shares(data, out); unwritten(data.data, data.start, data.length, out); @@ -265,161 +265,161 @@ export function copies(data: rt.ByteSlice, out: rt.ByteVec): void { * `Copy` aggregates written into only in another module, behind a type parameter, or * through a box. Each copy keeps its value. */ -export function unwritten(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - const n: rt.u8 = dataLen & 0xff; +export function unwritten(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + const n: rs.u8 = dataLen & 0xff; const track: Track.Track = { mark: { at: n } }; const seen: Mark.Mark = Track.mark(track); advance(track); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(seen.at, track.mark.at))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(seen.at, track.mark.at))); const first: shapes_Gauge.Gauge = { level: n | 1 }; const item = copy$shapes_Gauge(first); const gauges: shapes_Gauge.Gauge[] = Array.from({ length: 2 }, (): shapes_Gauge.Gauge => { return copy$shapes_Gauge(item); }); generics_reset$shapes_Gauge(gauges); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first.level, gauges[0].level, gauges[1].level))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(first.level, gauges[0].level, gauges[1].level))); const start: Level.Level = { _0: n }; const boxed: Level.Level = copy$shapes_Level(start); Object.assign(boxed, { _0: ~n & 0xff }); const _40: Level.Level = copy$shapes_Level(boxed); - const iter: rt.Iter = rt.iterSlice([copy$shapes_Level(start), _40]); + const iter: rs.Iter = rs.iterSlice([copy$shapes_Level(start), _40]); while (true) { - const _42: Level.Level | rt.Done = iter.next(); - if (_42 === rt.DONE) { + const _42: Level.Level | rs.Done = iter.next(); + if (_42 === rs.DONE) { break; } - rt.byteVecPush(out, _42._0); + rs.byteVecPush(out, _42._0); } } /** Adds one to what `slot` holds. */ -export function bump(slot: rt.Mutex): void { - const held: rt.Mutex = rt.mutexLock(slot); - const _4: rt.u8 = rt.u8WrappingAdd(held.value, 1); +export function bump(slot: rs.Mutex): void { + const held: rs.Mutex = rs.mutexLock(slot); + const _4: rs.u8 = rs.u8WrappingAdd(held.value, 1); held.value = _4; - rt.mutexUnlock(held); + rs.mutexUnlock(held); } /** * `Copy` aggregates holding shared references: a copy has its own values, and shares * what its references point at with the original's. */ -export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { - let res!: rt.Result<[rt.Mutex, rt.u8], rt.u8>; - let n!: rt.u8; - let flow!: rt.Result>; - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const slot: rt.Mutex = new rt.Mutex(a); - const other: rt.Mutex = new rt.Mutex(0); - const pair: [rt.Mutex, rt.u8] = [slot, a]; - const copy: [rt.Mutex, rt.u8] = copy$tuple2_ref_sync_Mutex_u8_u8(pair); - copy[1] = rt.u8WrappingAdd(copy[1], 1); +export function shares(data: rs.ByteSlice, out: rs.ByteVec): void { + let res!: rs.Result<[rs.Mutex, rs.u8], rs.u8>; + let n!: rs.u8; + let flow!: rs.Result>; + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const slot: rs.Mutex = new rs.Mutex(a); + const other: rs.Mutex = new rs.Mutex(0); + const pair: [rs.Mutex, rs.u8] = [slot, a]; + const copy: [rs.Mutex, rs.u8] = copy$tuple2_ref_sync_Mutex_u8_u8(pair); + copy[1] = rs.u8WrappingAdd(copy[1], 1); bump(copy[0]); bump(slot); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, copy[1]))); - const refs: rt.Mutex[] = [slot, other]; - const copy2: rt.Mutex[] = copy$array_ref_sync_Mutex_u8(refs); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, copy[1]))); + const refs: rs.Mutex[] = [slot, other]; + const copy2: rs.Mutex[] = copy$array_ref_sync_Mutex_u8(refs); bump(copy2[0]); copy2[1] = slot; bump(copy2[1]); bump(refs[1]); - const held: [rt.Mutex, rt.u8] | undefined = [slot, a]; - const copy3: [rt.Mutex, rt.u8] | undefined = copy$Option_tuple2_ref_sync_Mutex_u8_u8(held); + const held: [rs.Mutex, rs.u8] | undefined = [slot, a]; + const copy3: [rs.Mutex, rs.u8] | undefined = copy$Option_tuple2_ref_sync_Mutex_u8_u8(held); if (copy3 !== undefined) { bump(copy3[0]); - const _45: rt.u8 = rt.u8WrappingAdd(copy3[1], 2); + const _45: rs.u8 = rs.u8WrappingAdd(copy3[1], 2); copy3[1] = _45; } - const _49: [rt.Mutex, rt.u8] | undefined = copy$Option_tuple2_ref_sync_Mutex_u8_u8(copy3); - const iter: rt.Iter<[rt.Mutex, rt.u8] | undefined> = rt.iterSlice([copy$Option_tuple2_ref_sync_Mutex_u8_u8(held), _49]); + const _49: [rs.Mutex, rs.u8] | undefined = copy$Option_tuple2_ref_sync_Mutex_u8_u8(copy3); + const iter: rs.Iter<[rs.Mutex, rs.u8] | undefined> = rs.iterSlice([copy$Option_tuple2_ref_sync_Mutex_u8_u8(held), _49]); while (true) { - const _51: [rt.Mutex, rt.u8] | undefined | rt.Done = iter.next(); - if (_51 === rt.DONE) { + const _51: [rs.Mutex, rs.u8] | undefined | rs.Done = iter.next(); + if (_51 === rs.DONE) { break; } - rt.byteVecPush(out, option_mapOr$1hjjwvv(_51, 0, (_2: [rt.Mutex, rt.u8]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$1c3pipy(_51, 0, (_2: [rs.Mutex, rs.u8]): rs.u8 => { return _2[1]; })); } - if (!(rt.u8Rem(a, 2) === 0)) { - res = rt.Err(a); + if (!(rs.u8Rem(a, 2) === 0)) { + res = rs.Err(a); } else { - res = rt.Ok([slot, a] as [rt.Mutex, rt.u8]); + res = rs.Ok([slot, a] as [rs.Mutex, rs.u8]); } - const copy4: rt.Result<[rt.Mutex, rt.u8], rt.u8> = copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(res); + const copy4: rs.Result<[rs.Mutex, rs.u8], rs.u8> = copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(res); if (copy4.ok) { bump(copy4.value[0]); - const _69: rt.u8 = rt.u8WrappingAdd(copy4.value[1], 3); + const _69: rs.u8 = rs.u8WrappingAdd(copy4.value[1], 3); copy4.value[1] = _69; } - const iter2: rt.Iter, rt.u8], rt.u8>> = rt.iterSlice([copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(res), copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(copy4)]); + const iter2: rs.Iter, rs.u8], rs.u8>> = rs.iterSlice([copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(res), copy$Result_tuple2_ref_sync_Mutex_u8_u8_u8(copy4)]); while (true) { - const _76: rt.Result<[rt.Mutex, rt.u8], rt.u8> | rt.Done = iter2.next(); - if (_76 === rt.DONE) { + const _76: rs.Result<[rs.Mutex, rs.u8], rs.u8> | rs.Done = iter2.next(); + if (_76 === rs.DONE) { break; } - const r: rt.Result<[rt.Mutex, rt.u8], rt.u8> = _76; + const r: rs.Result<[rs.Mutex, rs.u8], rs.u8> = _76; if (r.ok) { n = r.value[1]; } else { n = r.error; } - rt.byteVecPush(out, n); + rs.byteVecPush(out, n); } const lens: Lens.Lens = { slot, n: a }; const copy5: Lens.Lens = copy$shapes_Lens(lens); - copy5.n = rt.u8WrappingAdd(copy5.n, 4); + copy5.n = rs.u8WrappingAdd(copy5.n, 4); bump(copy5.slot); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, copy5.n))); - rt.byteVecPush(out, lensBumped(lens)); - for (const _104 of rt.vecFrom(Array.from({ length: 2 }, (): Lens.Lens => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, copy5.n))); + rs.byteVecPush(out, lensBumped(lens)); + for (const _104 of rs.vecFrom(Array.from({ length: 2 }, (): Lens.Lens => { return copy$shapes_Lens(lens); }).map(copy$shapes_Lens)).items) { bump(_104.slot); } - const lenses: rt.Vec = new rt.Vec(); + const lenses: rs.Vec = new rs.Vec(); lenses.items.push(copy$shapes_Lens(lens)); - const _114: rt.Iter = rt.iterSlice([lens]); - rt.iterExtend(lenses, rt.iterMap(_114, copy$shapes_Lens), undefined, 8, true); - const iter4: rt.Iter = rt.iterCopied(rt.iterSlice(lenses.items), copy$shapes_Lens); + const _114: rs.Iter = rs.iterSlice([lens]); + rs.iterExtend(lenses, rs.iterMap(_114, copy$shapes_Lens), undefined, 8, true); + const iter4: rs.Iter = rs.iterCopied(rs.iterSlice(lenses.items), copy$shapes_Lens); while (true) { - const _124: Lens.Lens | rt.Done = iter4.next(); - if (_124 === rt.DONE) { + const _124: Lens.Lens | rs.Done = iter4.next(); + if (_124 === rs.DONE) { break; } bump(_124.slot); } - const arc: rt.Arc = new rt.Arc(a); - if (rt.u8Rem(a, 3) === 0) { - flow = rt.Ok(Uint8Array.of(a)); + const arc: rs.Arc = new rs.Arc(a); + if (rs.u8Rem(a, 3) === 0) { + flow = rs.Ok(Uint8Array.of(a)); } else { - flow = rt.Err(arc); - } - rt.byteVecPush(out, sameArc(flow, arc)); - const _143: rt.Mutex = rt.mutexLock(slot); - rt.byteVecPush(out, _143.value); - rt.mutexUnlock(_143); - const _150: rt.Mutex = rt.mutexLock(other); - rt.byteVecPush(out, _150.value); - rt.mutexUnlock(_150); - const source: Held.Held = { at: copy$shapes_Point(Point.new(a as rt.i32, 0)) }; + flow = rs.Err(arc); + } + rs.byteVecPush(out, sameArc(flow, arc)); + const _143: rs.Mutex = rs.mutexLock(slot); + rs.byteVecPush(out, _143.value); + rs.mutexUnlock(_143); + const _150: rs.Mutex = rs.mutexLock(other); + rs.byteVecPush(out, _150.value); + rs.mutexUnlock(_150); + const source: Held.Held = { at: copy$shapes_Point(Point.new(a as rs.i32, 0)) }; const kept: Held.Held = hold(copy$shapes_Point(source.at)); source.at.x = 9; - const read: rt.i32 = movedThenRead(copy$shapes_Point(source.at), source); - const by: rt.i32 = movedBy(copy$shapes_Point(source.at), { held: source }); - const part: rt.i32 = partMovedThenRead(copy$shapes_Held(source), source.at); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(kept.at.x & 0xff, read & 0xff, by & 0xff, part & 0xff, source.at.x & 0xff))); + const read: rs.i32 = movedThenRead(copy$shapes_Point(source.at), source); + const by: rs.i32 = movedBy(copy$shapes_Point(source.at), { held: source }); + const part: rs.i32 = partMovedThenRead(copy$shapes_Held(source), source.at); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(kept.at.x & 0xff, read & 0xff, by & 0xff, part & 0xff, source.at.x & 0xff))); const bytes: Uint8Array = Uint8Array.of(a, 1); - rt.byteVecPush(out, unsizedCopy(rt.byteSliceFrom(bytes))); - rt.byteVecPush(out, bytes[0]); - const at: rt.usize = option_mapOr$1t0muvr(rt.byteSliceGet(data, 1), 0, (_22: rt.u8): rt.usize => { - return rt.usizeRem(_22 as rt.usize, 3); + rs.byteVecPush(out, unsizedCopy(rs.byteSliceFrom(bytes))); + rs.byteVecPush(out, bytes[0]); + const at: rs.usize = option_mapOr$1d4bp7c(rs.byteSliceGet(data, 1), 0, (_22: rs.u8): rs.usize => { + return rs.usizeRem(_22 as rs.usize, 3); }); - rt.byteVecPush(out, writeAt(rt.byteSliceFrom(bytes), at, a)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const points: rt.Vec = rt.vecFromElem(copy$shapes_Point(Point.new(a as rt.i32, 0)), 2, copy$shapes_Point); + rs.byteVecPush(out, writeAt(rs.byteSliceFrom(bytes), at, a)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); + const points: rs.Vec = rs.vecFromElem(copy$shapes_Point(Point.new(a as rs.i32, 0)), 2, copy$shapes_Point); movedAt(points.items, at); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(points.items[rt.idx(points.items, 0)].x & 0xff, points.items[rt.idx(points.items, 1)].x & 0xff, points.items[rt.idx(points.items, 1)].y & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(points.items[rs.idx(points.items, 0)].x & 0xff, points.items[rs.idx(points.items, 1)].x & 0xff, points.items[rs.idx(points.items, 1)].y & 0xff))); arc[Symbol.dispose](); } @@ -427,28 +427,28 @@ export function shares(data: rt.ByteSlice, out: rt.ByteVec): void { * `live[at]`, written with `b`, then changed through its first byte, and through a * reborrow that may move past it: an index past the end panics as native Rust does. */ -export function writeAt(live: rt.ByteSlice, at: rt.usize, b: rt.u8): rt.u8 { - rt.idx(live, at); +export function writeAt(live: rs.ByteSlice, at: rs.usize, b: rs.u8): rs.u8 { + rs.idx(live, at); live.data[live.start + at] = b; - rt.idx(live, at); - const _7: rt.u8 = rt.u8WrappingAdd(live.data[live.start + at], 1); - rt.idx(live, 0); + rs.idx(live, at); + const _7: rs.u8 = rs.u8WrappingAdd(live.data[live.start + at], 1); + rs.idx(live, 0); live.data[live.start] = live.data[live.start] ^ _7; - let rest: rt.ByteSlice = live; - if (rt.u8Rem(b, 2) === 0) { - rest = rt.byteSliceRange(rest, 1); + let rest: rs.ByteSlice = live; + if (rs.u8Rem(b, 2) === 0) { + rest = rs.byteSliceRange(rest, 1); } - const _27: rt.usize = rest.length; + const _27: rs.usize = rest.length; if (!(0 < _27)) { - rt.panic("index out of bounds: the len is " + _27 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + _27 + " but the index is " + 0); } - const _23: rt.u8 = rt.u8WrappingAdd(rest.data[rest.start], 3); - const _31: rt.usize = rest.length; + const _23: rs.u8 = rs.u8WrappingAdd(rest.data[rest.start], 3); + const _31: rs.usize = rest.length; if (!(0 < _31)) { - rt.panic("index out of bounds: the len is " + _31 + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + _31 + " but the index is " + 0); } rest.data[rest.start] = _23; - rt.idx(live, at); + rs.idx(live, at); return live.data[live.start + at]; } @@ -456,12 +456,12 @@ export function writeAt(live: rt.ByteSlice, at: rt.usize, b: rt.u8): rt.u8 { * `live[at]` moved right by one, and its neighbor by its new `x`: an index past the end * panics as native Rust does. */ -export function movedAt(live: Point.Point[], at: rt.usize): void { - rt.idx(live, at); - live[at].x = rt.i32Add(live[at].x, 1); - rt.idx(live, at); - const _7: rt.i32 = live[at].x; - rt.idx(live, 1); +export function movedAt(live: Point.Point[], at: rs.usize): void { + rs.idx(live, at); + live[at].x = rs.i32Add(live[at].x, 1); + rs.idx(live, at); + const _7: rs.i32 = live[at].x; + rs.idx(live, 1); live[1].y = _7; } @@ -471,8 +471,8 @@ export function hold(at: Point.Point): Held.Held { } /** `copy.x`, read after `held` moves right by one, which a copy of its point doesn't see. */ -export function movedThenRead(copy: Point.Point, held: Held.Held): rt.i32 { - held.at.x = rt.i32Add(held.at.x, 1); +export function movedThenRead(copy: Point.Point, held: Held.Held): rs.i32 { + held.at.x = rs.i32Add(held.at.x, 1); return copy.x; } @@ -480,43 +480,43 @@ export function movedThenRead(copy: Point.Point, held: Held.Held): rt.i32 { * `copy.at.x`, read after `at` moves right by one, which a copy of what holds it doesn't * see. */ -export function partMovedThenRead(copy: Held.Held, at: Point.Point): rt.i32 { - at.x = rt.i32Add(at.x, 1); +export function partMovedThenRead(copy: Held.Held, at: Point.Point): rs.i32 { + at.x = rs.i32Add(at.x, 1); return copy.at.x; } /** `copy[0]`, read after `live`, its source unsized, changes. */ -export function sliceChangedThenRead(copy: Uint8Array, live: rt.ByteSlice): rt.u8 { - rt.byteSliceCopyFromSlice(live, rt.byteSliceFrom(Uint8Array.of(9, 9))); +export function sliceChangedThenRead(copy: Uint8Array, live: rs.ByteSlice): rs.u8 { + rs.byteSliceCopyFromSlice(live, rs.byteSliceFrom(Uint8Array.of(9, 9))); return copy[0]; } /** `src[0]` as it was, read after a call changes it through a slice. */ -export function unsizedCopy(src: rt.ByteSlice): rt.u8 { - return sliceChangedThenRead(rt.byteSliceToArray(src), src); +export function unsizedCopy(src: rs.ByteSlice): rs.u8 { + return sliceChangedThenRead(rs.byteSliceToArray(src), src); } /** `copy.x`, read after `by` moves what it holds right by one. */ -export function movedBy(copy: Point.Point, by: Mover.Mover): rt.i32 { - by.held.at.y = rt.i32Add(by.held.at.y, 1); - by.held.at.x = rt.i32Add(by.held.at.x, 1); +export function movedBy(copy: Point.Point, by: Mover.Mover): rs.i32 { + by.held.at.y = rs.i32Add(by.held.at.y, 1); + by.held.at.x = rs.i32Add(by.held.at.x, 1); return copy.x; } /** A `Lens` changed in place, which changes its slot too. */ -export function lensBumped(lens: Lens.Lens): rt.u8 { +export function lensBumped(lens: Lens.Lens): rs.u8 { lens = copy$shapes_Lens(lens); - lens.n = rt.u8WrappingAdd(lens.n, 5); + lens.n = rs.u8WrappingAdd(lens.n, 5); bump(lens.slot); return lens.n; } /** Whether `flow` breaks with `arc` itself, after changing its own bytes in place. */ -export function sameArc(flow: rt.Result>, arc: rt.Arc): rt.u8 { +export function sameArc(flow: rs.Result>, arc: rs.Arc): rs.u8 { flow = copy$ops_ControlFlow_ref_sync_Arc_u8_array1_u8(flow); if (flow.ok) { - const bytes: rt.ByteSlice = rt.byteSliceFrom(flow.value); - const _5: rt.u8 = rt.u8WrappingAdd(bytes.data[bytes.start], 1); + const bytes: rs.ByteSlice = rs.byteSliceFrom(flow.value); + const _5: rs.u8 = rs.u8WrappingAdd(bytes.data[bytes.start], 1); bytes.data[bytes.start] = _5; return bytes.data[bytes.start]; } @@ -524,17 +524,17 @@ export function sameArc(flow: rt.Result>, arc: rt.Arc< } /** `a`'s byte, after writing `b`'s. */ -export function writeThenRead(a: Uint8Array, b: rt.ByteSlice): rt.u8 { +export function writeThenRead(a: Uint8Array, b: rs.ByteSlice): rs.u8 { b.data[b.start] = 9; return a[0]; } /** A copy of `a` read after `a` changes in place, which it doesn't see. */ -export function copyThenWrite(a: [rt.u8, rt.u8]): rt.u8 { +export function copyThenWrite(a: [rs.u8, rs.u8]): rs.u8 { a = copy$tuple2_u8_u8(a); - const b: [rt.u8, rt.u8] = copy$tuple2_u8_u8(a); + const b: [rs.u8, rs.u8] = copy$tuple2_u8_u8(a); a[0] = 9; - return rt.u8WrappingAdd(b[0], a[0]); + return rs.u8WrappingAdd(b[0], a[0]); } /** `a` itself. */ @@ -543,8 +543,8 @@ export function same(a: Uint8Array): Uint8Array { } /** Logs `b`, returning how much is logged. */ -export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { - rt.byteVecPush(out, b); +export function mark(out: rs.ByteVec, b: rs.u8): rs.usize { + rs.byteVecPush(out, b); return out.length; } @@ -552,57 +552,57 @@ export function mark(out: rt.ByteVec, b: rt.u8): rt.usize { * Aggregates written with their fields out of declaration order evaluate them as * written: each field logs as it runs. */ -export function order(data: rt.ByteSlice, out: rt.ByteVec): void { +export function order(data: rs.ByteSlice, out: rs.ByteVec): void { let taken!: Shape.Shape; - let _75!: rt.usize; - const at: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i2), 0); + let _75!: rs.usize; + const at: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i2), 0); }; - const _5: rt.u16 = mark(out, at(0)) & 0xffff; - const _10: rt.u16 = mark(out, at(1)) & 0xffff; - const _16: rt.i32 = mark(out, 2) | 0; + const _5: rs.u16 = mark(out, at(0)) & 0xffff; + const _10: rs.u16 = mark(out, at(1)) & 0xffff; + const _16: rs.i32 = mark(out, 2) | 0; const rect: Shape.Shape = { tag: "Rect", corner: { x: mark(out, 3) | 0, y: _16 }, width: _10, height: _5 }; const _21: Point.Point = Point.new(mark(out, 4) | 0, 0); const line: Shape.Shape = { tag: "Line", _0: Point.new(mark(out, 5) | 0, 0), _1: _21 }; - const _28: rt.i64 = mark(out, 6) as rt.i64; + const _28: rs.i64 = mark(out, 6) as rs.i64; const pair: Pair.Pair = { _0: mark(out, 7) & 0xff, _1: _28 }; const n: Uint8Array = Uint8Array.of(at(2)); - const _37: rt.i32 = n[0] as rt.i32; - const read: Point.Point = { x: increment(rt.byteSliceFrom(n)) as rt.i32, y: _37 }; + const _37: rs.i32 = n[0] as rs.i32; + const read: Point.Point = { x: increment(rs.byteSliceFrom(n)) as rs.i32, y: _37 }; const base: Moved.Moved = { _0: at(4), _1: 0 }; - const _49: rt.u16 = reset(base); + const _49: rs.u16 = reset(base); const updated: Moved.Moved = { _0: base._0, _1: _49 }; - if (rt.u8Rem(at(3), 2) === 0) { - const _57: rt.u16 = mark(out, 8) & 0xffff; + if (rs.u8Rem(at(3), 2) === 0) { + const _57: rs.u16 = mark(out, 8) & 0xffff; taken = { tag: "Rect", corner: Point.new(0, mark(out, 9) | 0), width: _57, height: 1 } as Shape.Shape; } else { taken = { tag: "Dot" } as Shape.Shape; } - const _63: rt.usize = mark(out, 10); - const _64: rt.usize = rt.usizeDiv(mark(out, 11), 2); - new rt.Range(_64, _63); - let sum: rt.usize = 0; - const _70: rt.usize = mark(out, 12); - let iterStart: rt.usize = rt.usizeSub(mark(out, 13), 4); - const iterEnd: rt.usize = _70; + const _63: rs.usize = mark(out, 10); + const _64: rs.usize = rs.usizeDiv(mark(out, 11), 2); + new rs.Range(_64, _63); + let sum: rs.usize = 0; + const _70: rs.usize = mark(out, 12); + let iterStart: rs.usize = rs.usizeSub(mark(out, 13), 4); + const iterEnd: rs.usize = _70; while ((_75 = iterStart++) < iterEnd) { - sum = rt.usizeAdd(sum, _75); - } - const len: rt.usize = data.length; - const _83: rt.ByteSlice = logged(data, out); - const _85: rt.usize = rt.min(mark(out, 14), len); - const _82: rt.ByteSlice = rt.byteSliceRange(_83, rt.usizeDiv(rt.min(mark(out, 15), len), 2), _85); - const _103: rt.usize = sum; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rt.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rt.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rt.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rt.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rt.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rt.Formatter) => rt.usizeDisplay(_64, f), (f: rt.Formatter) => rt.usizeDisplay(_63, f), (f: rt.Formatter) => rt.usizeDisplay(_103, f), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_82), f, rt.u8Debug)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); - const _125: rt.usize = mark(out, 16); - const _127: rt.usize = out.length; - rt.byteVecPush(out, _125 & 0xff); - rt.byteVecPush(out, _127 & 0xff); + sum = rs.usizeAdd(sum, _75); + } + const len: rs.usize = data.length; + const _83: rs.ByteSlice = logged(data, out); + const _85: rs.usize = rs.min(mark(out, 14), len); + const _82: rs.ByteSlice = rs.byteSliceRange(_83, rs.usizeDiv(rs.min(mark(out, 15), len), 2), _85); + const _103: rs.usize = sum; + const args2: rs.Fmt[] = [(f: rs.Formatter) => Shape.fmt$fmt_Debug(rect, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(line, f), (f: rs.Formatter) => Pair.fmt$fmt_Debug(pair, f), (f: rs.Formatter) => Point.fmt$fmt_Debug(read, f), (f: rs.Formatter) => Moved.fmt$fmt_Debug(updated, f), (f: rs.Formatter) => Shape.fmt$fmt_Debug(taken, f), (f: rs.Formatter) => rs.usizeDisplay(_64, f), (f: rs.Formatter) => rs.usizeDisplay(_63, f), (f: rs.Formatter) => rs.usizeDisplay(_103, f), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_82), f, rs.u8Debug)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", args2[6], " ", args2[7], " ", args2[8], " ", args2[9]]))); + const _125: rs.usize = mark(out, 16); + const _127: rs.usize = out.length; + rs.byteVecPush(out, _125 & 0xff); + rs.byteVecPush(out, _127 & 0xff); const part = mark(out, 17); - const _143: [rt.usize, rt.usize] = [mark(out, 18), mark(out, 19)]; - rt.byteVecPush(out, part & 0xff); - rt.byteVecPush(out, _143[0] & 0xff); + const _143: [rs.usize, rs.usize] = [mark(out, 18), mark(out, 19)]; + rs.byteVecPush(out, part & 0xff); + rs.byteVecPush(out, _143[0] & 0xff); indexed(data, out); } @@ -611,108 +611,108 @@ export function order(data: rt.ByteSlice, out: rt.ByteVec): void { * evaluate what comes before those first: each logs as it runs, or changes what an * earlier operand read. */ -export function indexed(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0); +export function indexed(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0); }; - const _7: rt.ByteVec = listed(out, at(0)); - rt.byteVecPush(out, 225); - const first: rt.u8 = _7.data[rt.idx(_7, 1)]; + const _7: rs.ByteVec = listed(out, at(0)); + rs.byteVecPush(out, 225); + const first: rs.u8 = _7.data[rs.idx(_7, 1)]; const bytes: Uint8Array = Uint8Array.of(at(1), at(2), at(3), 4); - const _23: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); - rt.byteVecPush(out, 227); - rt.byteVecPush(out, 228); - rt.byteSliceCopyWithin(_23, 1, 3, 0); - const _30: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); - rt.byteVecPush(out, 229); - rt.byteSliceCopyWithin(_30, 2, _30.length, 1); - const _36: rt.ByteSlice = loggedMut(rt.byteSliceFrom(bytes), out); - rt.byteSliceCopyWithin(_36, 3, _36.length, 0); - const _41: rt.ByteSlice = logged(rt.byteSliceFrom(bytes), out); - rt.byteVecPush(out, 230); - rt.idx(_41, 1); - const second: rt.u8 = _41.data[_41.start + 1]; - let f: (a0: rt.u8) => rt.u8 = halve; - const _50: (a0: rt.u8) => rt.u8 = f; + const _23: rs.ByteSlice = loggedMut(rs.byteSliceFrom(bytes), out); + rs.byteVecPush(out, 227); + rs.byteVecPush(out, 228); + rs.byteSliceCopyWithin(_23, 1, 3, 0); + const _30: rs.ByteSlice = loggedMut(rs.byteSliceFrom(bytes), out); + rs.byteVecPush(out, 229); + rs.byteSliceCopyWithin(_30, 2, _30.length, 1); + const _36: rs.ByteSlice = loggedMut(rs.byteSliceFrom(bytes), out); + rs.byteSliceCopyWithin(_36, 3, _36.length, 0); + const _41: rs.ByteSlice = logged(rs.byteSliceFrom(bytes), out); + rs.byteVecPush(out, 230); + rs.idx(_41, 1); + const second: rs.u8 = _41.data[_41.start + 1]; + let f: (a0: rs.u8) => rs.u8 = halve; + const _50: (a0: rs.u8) => rs.u8 = f; f = twice; - const called: rt.u8 = _50(at(4)); - let n: rt.u8 = at(5); - const slots: Uint8Array = rt.bytes(2); - const _58: rt.u8 = n; - n = rt.u8WrappingAdd(n, 1); - slots[0] = rt.u8Add(slots[0], _58); + const called: rs.u8 = _50(at(4)); + let n: rs.u8 = at(5); + const slots: Uint8Array = rs.bytes(2); + const _58: rs.u8 = n; + n = rs.u8WrappingAdd(n, 1); + slots[0] = rs.u8Add(slots[0], _58); const m: Uint8Array = Uint8Array.of(at(6)); - const before: rt.u8 = m[0]; - const after: rt.u8 = rt.u8WrappingSub(increment(rt.byteSliceFrom(m)), before); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(first, second, called, f(1), slots[0], n, after))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - const mid: number = rt.usizeDiv(data.length, 2); + const before: rs.u8 = m[0]; + const after: rs.u8 = rs.u8WrappingSub(increment(rs.byteSliceFrom(m)), before); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(first, second, called, f(1), slots[0], n, after))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); + const mid: number = rs.usizeDiv(data.length, 2); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - ends([new rt.ByteSlice(data.data, data.start, mid), new rt.ByteSlice(data.data, data.start + mid, data.length - mid)], out); - if (rt.u8Rem(at(7), 4) === 0) { - const _106: [rt.u8, rt.u8, rt.u8] = [at(8), at(9), at(10)]; - const x: rt.u8 = _106[0]; - const y: rt.u8 = _106[1]; - const z: rt.u8 = _106[2]; - const quotient: rt.u8 = rt.u8Div(x, y); - rt.byteVecPush(out, rt.u8WrappingAdd(rt.u8Add(z, 200), quotient)); + ends([new rs.ByteSlice(data.data, data.start, mid), new rs.ByteSlice(data.data, data.start + mid, data.length - mid)], out); + if (rs.u8Rem(at(7), 4) === 0) { + const _106: [rs.u8, rs.u8, rs.u8] = [at(8), at(9), at(10)]; + const x: rs.u8 = _106[0]; + const y: rs.u8 = _106[1]; + const z: rs.u8 = _106[2]; + const quotient: rs.u8 = rs.u8Div(x, y); + rs.byteVecPush(out, rs.u8WrappingAdd(rs.u8Add(z, 200), quotient)); } } /** Each part's length and first byte. */ -export function ends(parts: rt.ByteSlice[], out: rt.ByteVec): void { +export function ends(parts: rs.ByteSlice[], out: rs.ByteVec): void { for (const _5 of parts) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_5.length & 0xff, option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_5), 0)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_5.length & 0xff, option_unwrapOr$1fr498u(rs.byteSliceFirst(_5), 0)))); } } /** A vector of `b`, logging that it was made. */ -export function listed(out: rt.ByteVec, b: rt.u8): rt.ByteVec { - rt.byteVecPush(out, 224); - return rt.byteSliceToByteVec(rt.byteSliceFrom(Uint8Array.of(b, b ^ 1))); +export function listed(out: rs.ByteVec, b: rs.u8): rs.ByteVec { + rs.byteVecPush(out, 224); + return rs.byteSliceToByteVec(rs.byteSliceFrom(Uint8Array.of(b, b ^ 1))); } /** `s`, logging that it was read. */ -export function loggedMut(s: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { - rt.byteVecPush(out, 226); +export function loggedMut(s: rs.ByteSlice, out: rs.ByteVec): rs.ByteSlice { + rs.byteVecPush(out, 226); return s; } -export function halve(b: rt.u8): rt.u8 { - return rt.u8Div(b, 2); +export function halve(b: rs.u8): rs.u8 { + return rs.u8Div(b, 2); } -export function twice(b: rt.u8): rt.u8 { - return rt.u8WrappingAdd(b, b); +export function twice(b: rs.u8): rs.u8 { + return rs.u8WrappingAdd(b, b); } /** `data`, logging that it was read. */ -export function logged(data: rt.ByteSlice, out: rt.ByteVec): rt.ByteSlice { - rt.byteVecPush(out, 238); +export function logged(data: rs.ByteSlice, out: rs.ByteVec): rs.ByteSlice { + rs.byteVecPush(out, 238); return data; } /** `n`'s byte, incremented. */ -export function increment(n: rt.ByteSlice): rt.u8 { - const _2: rt.u8 = rt.u8WrappingAdd(n.data[n.start], 1); +export function increment(n: rs.ByteSlice): rs.u8 { + const _2: rs.u8 = rs.u8WrappingAdd(n.data[n.start], 1); n.data[n.start] = _2; return n.data[n.start]; } /** Changes `m`'s first field. */ -export function reset(m: Moved.Moved): rt.u16 { +export function reset(m: Moved.Moved): rs.u16 { m._0 = 9; return 1; } /** Fieldless enums cast to every width, past their discriminant's range and sign. */ -export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { +export function discriminants(data: rs.ByteSlice, out: rs.ByteVec): void { let wide!: shapes_Wide.Wide; let signed!: Signed.Signed; - for (const b of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(b, 3); + for (const b of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(b, 3); if (_10 === 0) { wide = "Low" as shapes_Wide.Wide; } else if (_10 === 1) { @@ -720,7 +720,7 @@ export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { } else { wide = "Top" as shapes_Wide.Wide; } - const _13: rt.u8 = rt.u8Rem(b, 3); + const _13: rs.u8 = rs.u8Rem(b, 3); if (_13 === 0) { signed = "Neg" as Signed.Signed; } else if (_13 === 1) { @@ -728,15 +728,15 @@ export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { } else { signed = "Pos" as Signed.Signed; } - rt.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); - rt.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rt.u64))); - rt.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rt.i64))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed])))); + rs.byteVecPush(out, { Low: 1, High: 300, Top: 65535 }[wide] & 0xff); + rs.byteVecPush(out, (({ Low: 1, High: 300, Top: 65535 }[wide] << 24) >> 24) & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(({ Low: 1, High: 300, Top: 65535 }[wide] << 16) >> 16))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes({ Low: 1, High: 300, Top: 65535 }[wide] as rs.u64))); + rs.byteVecPush(out, { Neg: -1, Min: -128, Pos: 100 }[signed] & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] & 0xffff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] >>> 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes({ Neg: -1, Min: -128, Pos: 100 }[signed] as rs.i64))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128Cast({ Neg: -1, Min: -128, Pos: 100 }[signed])))); } } @@ -744,30 +744,30 @@ export function discriminants(data: rt.ByteSlice, out: rt.ByteVec): void { * Loops: labeled, `while let`, ranges, values out of `break`, loops that end a function, * and values of type `!`. */ -export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { - let _24!: rt.usize; - let _34!: rt.usize; - let steps!: rt.u8; - let _65!: rt.u64; - let _124!: rt.i32; - let _136!: rt.i8; - const _158: (a0: rt.u8) => rt.u8 = (x3: rt.u8): rt.u8 => { +export function loops(data: rs.ByteSlice, out: rs.ByteVec): void { + let _24!: rs.usize; + let _34!: rs.usize; + let steps!: rs.u8; + let _65!: rs.u64; + let _124!: rs.i32; + let _136!: rs.i8; + const _158: (a0: rs.u8) => rs.u8 = (x3: rs.u8): rs.u8 => { while (true) { if (!(x3 < 10)) { - x3 = rt.u8Div(x3, 3); + x3 = rs.u8Div(x3, 3); } else { return x3; } } }; - const stack: rt.ByteVec = rt.byteSliceToByteVec(data); - let popped: rt.u32 = 0; + const stack: rs.ByteVec = rs.byteSliceToByteVec(data); + let popped: rs.u32 = 0; while (true) { - const _5: rt.u8 | undefined = rt.byteVecPop(stack); + const _5: rs.u8 | undefined = rs.byteVecPop(stack); if (_5 !== undefined) { - const top: rt.u8 = _5; + const top: rs.u8 = _5; if (!(top === 0)) { - popped = rt.u32Add(popped, top as rt.u32); + popped = rs.u32Add(popped, top as rs.u32); if (popped > 1000) { break; } @@ -776,94 +776,94 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(popped))); - let found = undefined as [rt.usize, rt.usize] | undefined; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = data.length; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(popped))); + let found = undefined as [rs.usize, rs.usize] | undefined; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = data.length; l3: while ((_24 = iterStart++) < iterEnd) { - const i: rt.usize = _24; - let iterStart2: rt.usize = rt.usizeAdd(i, 1); - const iterEnd2: rt.usize = data.length; + const i: rs.usize = _24; + let iterStart2: rs.usize = rs.usizeAdd(i, 1); + const iterEnd2: rs.usize = data.length; while (true) { if (!((_34 = iterStart2++) < iterEnd2)) { continue l3; } - const j: rt.usize = _34; - rt.idx(data, i); - const _39: rt.u8 = data.data[data.start + i]; - rt.idx(data, j); + const j: rs.usize = _34; + rs.idx(data, i); + const _39: rs.u8 = data.data[data.start + i]; + rs.idx(data, j); if (!(_39 === data.data[data.start + j])) { - rt.idx(data, j); + rs.idx(data, j); if (data.data[data.start + j] === 0) { continue l3; } } else { - found = [i, j] as [rt.usize, rt.usize]; + found = [i, j] as [rs.usize, rs.usize]; break l3; } } } if (found === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(found[0] & 0xff, found[1] & 0xff))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(found[0] & 0xff, found[1] & 0xff))); } - let n: rt.u64 = data.length as rt.u64; + let n: rs.u64 = data.length as rs.u64; b6: { - while (!rt.u64Le(n, 1)) { - if (!(rt.u64Rem(n, 2) === 0)) { - _65 = rt.u64Add(rt.u64Mul(3, n), 1); + while (!rs.u64Le(n, 1)) { + if (!(rs.u64Rem(n, 2) === 0)) { + _65 = rs.u64Add(rs.u64Mul(3, n), 1); } else { - _65 = rt.u64Div(n, 2); + _65 = rs.u64Div(n, 2); } n = _65; - if (rt.u64Gt(n, 100)) { + if (rs.u64Gt(n, 100)) { steps = 1; break b6; } } steps = 0; } - rt.byteVecPush(out, steps); - let count: rt.u8 = 0; - const iter3: rt.RangeInclusive = new rt.RangeInclusive(0, 3, rt.u8Step); - while (iter3.next() !== rt.DONE) { - count = rt.u8Add(count, 1); + rs.byteVecPush(out, steps); + let count: rs.u8 = 0; + const iter3: rs.RangeInclusive = new rs.RangeInclusive(0, 3, rs.u8Step); + while (iter3.next() !== rs.DONE) { + count = rs.u8Add(count, 1); } - let i3: rt.i8 = 10; + let i3: rs.i8 = 10; while (i3 > -3) { - i3 = rt.i8Sub(i3, 4); - count = rt.u8Add(count, 1); + i3 = rs.i8Sub(i3, 4); + count = rs.u8Add(count, 1); } - rt.byteVecPush(out, count); - const lo: rt.i32 = rt.i32Neg(rt.usizeRem(data.length, 4) | 0); - const r: rt.Range = new rt.Range(lo, rt.i32Add(lo, 3)); - const first: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; + rs.byteVecPush(out, count); + const lo: rs.i32 = rs.i32Neg(rs.usizeRem(data.length, 4) | 0); + const r: rs.Range = new rs.Range(lo, rs.i32Add(lo, 3)); + const first: rs.i32 | undefined = r.start < r.end ? r.start++ : undefined; r.end = r.start; - const second: rt.i32 | undefined = r.start < r.end ? r.start++ : undefined; + const second: rs.i32 | undefined = r.start < r.end ? r.start++ : undefined; if (first !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(first))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(first))); } if (second !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(second))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(second))); } - let iterStart3: rt.i32 = lo; - const iterEnd3: rt.i32 = 2; + let iterStart3: rs.i32 = lo; + const iterEnd3: rs.i32 = 2; while ((_124 = iterStart3++) < iterEnd3) { - rt.byteVecPush(out, _124 & 0xff); + rs.byteVecPush(out, _124 & 0xff); } - let iterStart4: rt.i8 = rt.i8Sub(124, (lo << 24) >> 24); - const iterEnd4: rt.i8 = 127; + let iterStart4: rs.i8 = rs.i8Sub(124, (lo << 24) >> 24); + const iterEnd4: rs.i8 = 127; while ((_136 = iterStart4++) < iterEnd4) { - rt.byteVecPush(out, _136 & 0xff); + rs.byteVecPush(out, _136 & 0xff); } - rt.byteVecPush(out, firstRepeat(data.data, data.start, data.length)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(tailBreak(data)))); - rt.byteVecPush(out, armLoop(data)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(position$u8(data.data, data.start, data.length, 0) as rt.u32))); - rt.byteVecPush(out, _158(rt.u8Mul(data.length & 0xff, 7))); + rs.byteVecPush(out, firstRepeat(data.data, data.start, data.length)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(tailBreak(data)))); + rs.byteVecPush(out, armLoop(data)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(position$u8(data.data, data.start, data.length, 0) as rs.u32))); + rs.byteVecPush(out, _158(rs.u8Mul(data.length & 0xff, 7))); drain(data.data, data.start, data.length, out); - rt.byteVecPush(out, returnedLoop(data)); + rs.byteVecPush(out, returnedLoop(data)); branchLoops(data, out); diverging(data, out); } @@ -872,22 +872,22 @@ export function loops(data: rt.ByteSlice, out: rt.ByteVec): void { * Values of type `!` where a value goes, triggered by the first two bytes so most * inputs run every case to its end. */ -export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { - const _15: (a0: rt.u8) => rt.u8 = (b2: rt.u8): rt.u8 => { +export function diverging(data: rs.ByteSlice, out: rs.ByteVec): void { + const _15: (a0: rs.u8) => rs.u8 = (b2: rs.u8): rs.u8 => { if (!(b2 === 253)) { - return rt.u8Div(b2, 3); + return rs.u8Div(b2, 3); } - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b2, f)]; - rt.panicFmt(["closure ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b2, f)]; + rs.panicFmt(["closure ", args2[0]]); }; - const head: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 2)); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(head), 0); - rt.byteVecPush(out, returnedNever(b, data.length)); - rt.byteVecPush(out, brokenNever(head.data, head.start, head.length)); - rt.byteVecPush(out, _15(b)); - rt.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); - rt.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); - rt.byteVecPush(out, closureNever(b)); + const head: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 2)); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(head), 0); + rs.byteVecPush(out, returnedNever(b, data.length)); + rs.byteVecPush(out, brokenNever(head.data, head.start, head.length)); + rs.byteVecPush(out, _15(b)); + rs.byteVecPush(out, guardedReturn(head.data, head.start, head.length)); + rs.byteVecPush(out, boundNever(head.data, head.start, head.length, out)); + rs.byteVecPush(out, closureNever(b)); genericNever(b, data.length); } @@ -895,16 +895,16 @@ export function diverging(data: rt.ByteSlice, out: rt.ByteVec): void { * Calls that never return, through a closure, a function pointer, and a closure a * function made: a statement, a bound value, and the tail. */ -export function closureNever(b: rt.u8): rt.u8 { - const _2: (a0: rt.u8) => never = (b2: rt.u8): never => { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8LowerHex(b2, f)]; - rt.panicFmt(["closure failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); +export function closureNever(b: rs.u8): rs.u8 { + const _2: (a0: rs.u8) => never = (b2: rs.u8): never => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(b2, f)]; + rs.panicFmt(["closure failed on ", rs.fmtSpec({ alternate: true }, args2[0])]); }; - const _4: (a0: rt.u8) => never = madeNever(); - const ptr: (a0: rt.u8) => never = bail; + const _4: (a0: rs.u8) => never = madeNever(); + const ptr: (a0: rs.u8) => never = bail; if (!(b === 245)) { if (!(b === 244)) { - const x: rt.u8 = rt.u8Div(b, 5); + const x: rs.u8 = rs.u8Div(b, 5); if (b === 243) { _2(b); } else if (b === 250) { @@ -921,10 +921,10 @@ export function closureNever(b: rt.u8): rt.u8 { } /** A closure that never returns, made by a function. */ -export function madeNever(): (a0: rt.u8) => never { - return (b: rt.u8): never => { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - rt.panicFmt(["made ", args2[0]]); +export function madeNever(): (a0: rs.u8) => never { + return (b: rs.u8): never => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + rs.panicFmt(["made ", args2[0]]); }; } @@ -932,20 +932,20 @@ export function madeNever(): (a0: rt.u8) => never { * Generic functions instantiated at `!`, which edition 2024 infers for a value that * never exists: given one, and given an `Option` of none, which then calls one. */ -export function genericNever(b: rt.u8, len: rt.usize): void { +export function genericNever(b: rs.u8, len: rs.usize): void { if (!(b === 241)) { if (!(b === 246)) { if (b === 249) { if (!(len > 1)) { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - rt.panicFmt(["some ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + rs.panicFmt(["some ", args4[0]]); } else { unwrapOrBail$generic_never_never(undefined, b); } } } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - rt.panicFmt(["passed ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + rs.panicFmt(["passed ", args2[0]]); } } else { bail(b); @@ -953,35 +953,35 @@ export function genericNever(b: rt.u8, len: rt.usize): void { } export function pass$generic_never_never(_: never): never { - rt.unreachable(undefined); + rs.unreachable(undefined); } -export function unwrapOrBail$generic_never_never(o: never | undefined, b: rt.u8): never { +export function unwrapOrBail$generic_never_never(o: never | undefined, b: rs.u8): never { if (o === undefined) { bail(b); } else { - pass$generic_never_never(rt.unreachable(undefined)); - rt.unreachable(undefined); + pass$generic_never_never(rs.unreachable(undefined)); + rs.unreachable(undefined); } } /** A function that never returns. */ -export function bail(b: rt.u8): never { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8LowerHex(b, f)]; - rt.panicFmt(["failed on ", rt.fmtSpec({ alternate: true }, args2[0])]); +export function bail(b: rs.u8): never { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8LowerHex(b, f)]; + rs.panicFmt(["failed on ", rs.fmtSpec({ alternate: true }, args2[0])]); } /** `return`, and `break` out of the function's labeled block, with values that never exist. */ -export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { +export function returnedNever(b: rs.u8, len: rs.usize): rs.u8 { if (b === 247) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - rt.panicFmt(["returned ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + rs.panicFmt(["returned ", args2[0]]); } else if (b === 248) { - if (!(rt.usizeRem(len, 2) === 0)) { + if (!(rs.usizeRem(len, 2) === 0)) { bail(b); } else { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(b, f)]; - rt.panicFmt(["then ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(b, f)]; + rs.panicFmt(["then ", args4[0]]); } } else { if (!(b === 254)) { @@ -992,13 +992,13 @@ export function returnedNever(b: rt.u8, len: rt.usize): rt.u8 { } /** A `return` of a `match` that guards, whose arms fall through to the next. */ -export function guardedReturn(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { +export function guardedReturn(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { if (!(dataLen === 0)) { if (dataLen === 2) { - const a: rt.u8 = dataData[dataStart]; - const b: rt.u8 = dataData[dataStart + 1]; + const a: rs.u8 = dataData[dataStart]; + const b: rs.u8 = dataData[dataStart + 1]; if (a > b) { - return rt.u8Sub(a, b); + return rs.u8Sub(a, b); } } if (dataLen >= 1) { @@ -1012,28 +1012,28 @@ export function guardedReturn(dataData: Uint8Array, dataStart: number, dataLen: } /** A loop ending the function, left by `break` with values that never exist. */ -export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - let i: rt.usize = 0; +export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { + let i: rs.usize = 0; while (!(i >= dataLen)) { - const _6: rt.usize = i; + const _6: rs.usize = i; if (_6 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _6); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _6); } const value = dataData[dataStart + _6]; if (value === 251) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; - rt.panicFmt(["broken at ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; + rs.panicFmt(["broken at ", args2[0]]); } else if (value === 252) { - const _19: rt.usize = i; + const _19: rs.usize = i; if (_19 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _19); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _19); } bail(dataData[dataStart + _19]); } else { if (value === 0) { return i & 0xff; } - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } } return 204; @@ -1043,21 +1043,21 @@ export function brokenNever(dataData: Uint8Array, dataStart: number, dataLen: nu * Values that never exist where a value is needed: bound, and passed. A loop that * only `return` leaves gives the function's result. */ -export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: number, _out: rt.ByteVec): rt.u8 { - let i: rt.usize = 0; +export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: number, _out: rs.ByteVec): rs.u8 { + let i: rs.usize = 0; while (!(i >= dataLen)) { - const _8: rt.usize = i; + const _8: rs.usize = i; if (_8 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _8); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _8); } const value = dataData[dataStart + _8]; if (value === 239) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; - rt.panicFmt(["bound at ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; + rs.panicFmt(["bound at ", args2[0]]); } else if (value === 240) { - const _22: rt.usize = i; + const _22: rs.usize = i; if (_22 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _22); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _22); } bail(dataData[dataStart + _22]); } else { @@ -1066,11 +1066,11 @@ export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: num } if (value === 128) { while (true) { - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); if (!(i >= dataLen)) { - const _32: rt.usize = i; + const _32: rs.usize = i; if (_32 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _32); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _32); } if (dataData[dataStart + _32] < 128) { break; @@ -1081,28 +1081,28 @@ export function boundNever(dataData: Uint8Array, dataStart: number, dataLen: num } return i & 0xff; } - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } } return 187; } /** Loops that `break` ending a guarded `match` arm and an `if let` chain branch. */ -export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { - let i: rt.usize = 0; - l1: while (rt.usizeAdd(i, 1) < data.length) { - const w: rt.ByteSlice = rt.byteSliceRange(data, i, rt.usizeAdd(i, 2)); +export function branchLoops(data: rs.ByteSlice, out: rs.ByteVec): void { + let i: rs.usize = 0; + l1: while (rs.usizeAdd(i, 1) < data.length) { + const w: rs.ByteSlice = rs.byteSliceRange(data, i, rs.usizeAdd(i, 2)); b2: { - i = rt.usizeAdd(i, 2); + i = rs.usizeAdd(i, 2); if (w.length === 2) { - const a: rt.u8 = w.data[w.start]; - const b: rt.u8 = w.data[w.start + 1]; + const a: rs.u8 = w.data[w.start]; + const b: rs.u8 = w.data[w.start + 1]; if (a > b) { - let n: rt.u8 = a; + let n: rs.u8 = a; while (true) { if (!(n <= b)) { - n = rt.u8Sub(n, 1); - rt.byteVecPush(out, n); + n = rs.u8Sub(n, 1); + rs.byteVecPush(out, n); } else { break b2; } @@ -1110,30 +1110,30 @@ export function branchLoops(data: rt.ByteSlice, out: rt.ByteVec): void { } } if (w.length >= 1) { - rt.byteVecPush(out, w.data[w.start]); + rs.byteVecPush(out, w.data[w.start]); } } if (w.length === 2) { - if (rt.u8Rem(w.data[w.start], 3) === rt.u8Rem(w.data[w.start + 1], 3)) { - let n2: rt.u8 = w.data[w.start]; + if (rs.u8Rem(w.data[w.start], 3) === rs.u8Rem(w.data[w.start + 1], 3)) { + let n2: rs.u8 = w.data[w.start]; while (true) { - n2 = rt.u8Div(n2, 2); - rt.byteVecPush(out, n2); + n2 = rs.u8Div(n2, 2); + rs.byteVecPush(out, n2); if (n2 < 4) { continue l1; } } } } - rt.byteVecPush(out, 170); + rs.byteVecPush(out, 170); } } /** A loop that only `return` leaves, returned itself, around loops that `break`. */ -export function returnedLoop(data: rt.ByteSlice): rt.u8 { - let i: rt.usize = 0; +export function returnedLoop(data: rs.ByteSlice): rs.u8 { + let i: rs.usize = 0; while (!(i >= data.length)) { - for (const b of rt.byteSliceView(rt.byteSliceRange(data, i))) { + for (const b of rs.byteSliceView(rs.byteSliceRange(data, i))) { if (!(b === 0)) { if (b > 240) { return b ^ (i & 0xff); @@ -1142,86 +1142,86 @@ export function returnedLoop(data: rt.ByteSlice): rt.u8 { break; } } - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } return 221; } /** A loop that ends the function, left only by `return` from nested scopes. */ -export function firstRepeat(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 { - let i: rt.usize = 0; +export function firstRepeat(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 { + let i: rs.usize = 0; l2: while (!(i >= dataLen)) { - let j: rt.usize = rt.usizeAdd(i, 1); + let j: rs.usize = rs.usizeAdd(i, 1); while (j < dataLen) { - const _14: rt.usize = j; + const _14: rs.usize = j; if (_14 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _14); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _14); } if (!(dataData[dataStart + _14] === 0)) { - const _21: rt.usize = i; + const _21: rs.usize = i; if (_21 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _21); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _21); } - const _20: rt.u8 = dataData[dataStart + _21]; - const _25: rt.usize = j; + const _20: rs.u8 = dataData[dataStart + _21]; + const _25: rs.usize = j; if (_25 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _25); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _25); } if (!(_20 === dataData[dataStart + _25])) { - j = rt.usizeAdd(j, 1); + j = rs.usizeAdd(j, 1); } else { - const _29: rt.usize = j; + const _29: rs.usize = j; if (_29 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _29); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _29); } return dataData[dataStart + _29] ^ (i & 0xff); } } else { - i = rt.usizeAdd(j, 1); + i = rs.usizeAdd(j, 1); continue l2; } } - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } return 255; } /** A loop that ends the function, left by `break` with a value from nested scopes. */ -export function tailBreak(data: rt.ByteSlice): rt.u16 { - let i: rt.usize = 0; +export function tailBreak(data: rs.ByteSlice): rs.u16 { + let i: rs.usize = 0; l2: while (true) { if (!(i >= data.length)) { - const _7: rt.usize = i; - rt.idx(data, _7); - const b: rt.u8 = data.data[data.start + _7]; - i = rt.usizeAdd(i, 1); - const _11: rt.u8 = rt.u8Rem(b, 4); + const _7: rs.usize = i; + rs.idx(data, _7); + const b: rs.u8 = data.data[data.start + _7]; + i = rs.usizeAdd(i, 1); + const _11: rs.u8 = rs.u8Rem(b, 4); if (_11 === 0) { continue; } if (_11 === 1) { - const iterS: Uint8Array = rt.byteSliceView(rt.byteSliceRange(data, i)); + const iterS: Uint8Array = rs.byteSliceView(rs.byteSliceRange(data, i)); let iterI: number = 0; while (true) { - const _18: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_18 === rt.DONE) { + const _18: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_18 === rs.DONE) { continue l2; } - const c: rt.u8 = _18; + const c: rs.u8 = _18; if (c === b) { - return rt.u16Mul(c as rt.u16, 2); + return rs.u16Mul(c as rs.u16, 2); } } } if (_11 === 2) { if (b > 100) { - return rt.u16Add(b as rt.u16, i & 0xffff); + return rs.u16Add(b as rs.u16, i & 0xffff); } } - let n: rt.u8 = b; + let n: rs.u8 = b; while (true) { if (!(n < 10)) { - n = rt.u8Div(n, 3); + n = rs.u8Div(n, 3); if (n === 7) { return 7; } @@ -1236,39 +1236,39 @@ export function tailBreak(data: rt.ByteSlice): rt.u16 { } /** A loop that only `return` leaves, in a `match` arm that needs a value. */ -export function armLoop(data: rt.ByteSlice): rt.u8 { - let k: rt.usize = 0; - const _3: rt.u8 | undefined = rt.byteSliceFirst(data); +export function armLoop(data: rs.ByteSlice): rs.u8 { + let k: rs.usize = 0; + const _3: rs.u8 | undefined = rs.byteSliceFirst(data); if (_3 !== undefined) { if (_3 >= 128) { - return rt.u8Div(_3, 2); + return rs.u8Div(_3, 2); } } while (!(k >= data.length)) { - const _13: rt.usize = k; - rt.idx(data, _13); + const _13: rs.usize = k; + rs.idx(data, _13); if (!(data.data[data.start + _13] >= 128)) { - k = rt.usizeAdd(k, 1); + k = rs.usizeAdd(k, 1); } else { - const _17: rt.usize = k; - rt.idx(data, _17); - return rt.u8Sub(data.data[data.start + _17], 128); + const _17: rs.usize = k; + rs.idx(data, _17); + return rs.u8Sub(data.data[data.start + _17], 128); } } return 238; } /** A generic function ending in a loop. */ -export function position$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, want: rt.u8): rt.usize { - let i: rt.usize = 0; +export function position$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: number, want: rs.u8): rs.usize { + let i: rs.usize = 0; while (true) { if (!(i === itemsLen)) { - const _9: rt.usize = i; + const _9: rs.usize = i; if (_9 >= itemsLen) { - rt.panic("index out of bounds: the len is " + itemsLen + " but the index is " + _9); + rs.panic("index out of bounds: the len is " + itemsLen + " but the index is " + _9); } if (!(itemsData[itemsStart + _9] === want)) { - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } else { return i; } @@ -1279,43 +1279,43 @@ export function position$u8(itemsData: Uint8Array, itemsStart: number, itemsLen: } /** A unit function ending in a loop. */ -export function drain(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let i: rt.usize = 0; +export function drain(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let i: rs.usize = 0; while (!(i >= dataLen)) { - const _10: rt.usize = i; + const _10: rs.usize = i; if (_10 >= dataLen) { - rt.panic("index out of bounds: the len is " + dataLen + " but the index is " + _10); + rs.panic("index out of bounds: the len is " + dataLen + " but the index is " + _10); } - rt.byteVecPush(out, dataData[dataStart + _10] ^ 90); - i = rt.usizeAdd(i, 2); + rs.byteVecPush(out, dataData[dataStart + _10] ^ 90); + i = rs.usizeAdd(i, 2); } } /** Patterns: slices, ranges, guards that bind, `@` bindings, and let chains. */ -export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { - let class_!: rt.u8; - let area!: rt.i64; - let either!: rt.Result; - let v!: rt.u8; +export function patterns(data: rs.ByteSlice, out: rs.ByteVec): void { + let class_!: rs.u8; + let area!: rs.i64; + let either!: rs.Result; + let v!: rs.u8; if (!(data.length === 0)) { if (!(data.length === 1)) { if (!(data.length >= 2)) { - rt.unreachable(undefined); + rs.unreachable(undefined); } else if (!(data.data[data.start] === data.data[data.start + (data.length - 1)])) { - rt.byteVecPush(out, data.data[data.start] ^ data.data[data.start + 1]); - rt.byteVecPush(out, (data.length - 2) & 0xff); + rs.byteVecPush(out, data.data[data.start] ^ data.data[data.start + 1]); + rs.byteVecPush(out, (data.length - 2) & 0xff); } else { - rt.byteVecPush(out, 2); + rs.byteVecPush(out, 2); } } else { - rt.byteVecPush(out, data.data[data.start]); + rs.byteVecPush(out, data.data[data.start]); } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } - for (const _33 of rt.byteSliceView(rt.byteSliceRange(data, 0, rt.min(data.length, 4)))) { + for (const _33 of rs.byteSliceView(rs.byteSliceRange(data, 0, rs.min(data.length, 4)))) { b3: { - const b: rt.u8 = _33; + const b: rs.u8 = _33; if (b === 0) { class_ = 0; } else if (b === 10 || b === 20 || b === 30) { @@ -1329,7 +1329,7 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { } if (100 <= b) { if (b < 200) { - if (rt.u8Rem(b, 2) === 0) { + if (rs.u8Rem(b, 2) === 0) { class_ = 3; break b3; } @@ -1342,7 +1342,7 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { } } } - rt.byteVecPush(out, class_); + rs.byteVecPush(out, class_); } b6: { if (data.length >= 2) { @@ -1350,12 +1350,12 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { if (_56 !== undefined) { const d: Dir.Dir = _56; if (data.data[data.start + 1] > 10) { - rt.byteVecPush(out, from$convert_From_shapes_Dir_u8(d)); + rs.byteVecPush(out, from$convert_From_shapes_Dir_u8(d)); break b6; } } } - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } const shape_: Shape.Shape = shape(data.data, data.start, data.length); b8: { @@ -1363,51 +1363,51 @@ export function patterns(data: rt.ByteSlice, out: rt.ByteVec): void { if (shape_.tag === "Line") { const a: Point.Point = shape_._0; const b2: Point.Point = shape_._1; - area = rt.i64Mul(rt.i32Sub(a.x, b2.x) as rt.i64, rt.i32Sub(a.y, b2.y) as rt.i64); + area = rs.i64Mul(rs.i32Sub(a.x, b2.x) as rs.i64, rs.i32Sub(a.y, b2.y) as rs.i64); break b8; } if (shape_.width !== 0) { if (!(shape_.corner.x > 0)) { - area = rt.i64Neg(rt.i64Mul(shape_.width as rt.i64, shape_.height as rt.i64)); + area = rs.i64Neg(rs.i64Mul(shape_.width as rs.i64, shape_.height as rs.i64)); break b8; } - area = rt.i64Mul(shape_.width as rt.i64, shape_.corner.x as rt.i64); + area = rs.i64Mul(shape_.width as rs.i64, shape_.corner.x as rs.i64); break b8; } } area = 0; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(area))); - if (!(rt.usizeRem(data.length, 2) === 0)) { - either = rt.Err(160); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(area))); + if (!(rs.usizeRem(data.length, 2) === 0)) { + either = rs.Err(160); } else { - either = rt.Ok(data.length & 0xff); + either = rs.Ok(data.length & 0xff); } if (either.ok) { v = either.value; } else { v = either.error; } - rt.byteVecPush(out, v); - rt.byteVecPush(out, rt.u8Add(rt.byteSliceFrom(Uint8Array.of()).length & 0xff, rt.iterSum(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of()))), rt.u8Add, 0))); + rs.byteVecPush(out, v); + rs.byteVecPush(out, rs.u8Add(rs.byteSliceFrom(Uint8Array.of()).length & 0xff, rs.iterSum(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of()))), rs.u8Add, 0))); const bytes: Uint8Array = Uint8Array.of(data.length & 0xff, 1, 2); - const slice = rt.byteSliceRange(rt.byteSliceFrom(bytes), 1, 3); + const slice = rs.byteSliceRange(rs.byteSliceFrom(bytes), 1, 3); slice.data[slice.start] = 9; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(bytes)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64Add(total$shapes_Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$shapes_Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }], out))))); - const parsed: rt.Result = rt.Ok(data.length & 0xff); - const a2: rt.u8 = (parsed as { ok: true; value: rt.u8 }).value; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rt.u8 }).value, (parsed as { ok: true; value: rt.u8 }).value, early(a2)))); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(parsed, f, rt.u8Debug, (value: Void.Void, f: rt.Formatter) => Void.fmt$fmt_Debug(value, f))]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(bytes)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64Add(total$shapes_Shape([shape_, { tag: "Dot" } as Shape.Shape], out), total$shapes_Meters([{ _0: 3 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64 }], out))))); + const parsed: rs.Result = rs.Ok(data.length & 0xff); + const a2: rs.u8 = (parsed as { ok: true; value: rs.u8 }).value; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a2, (parsed as { ok: true; value: rs.u8 }).value, (parsed as { ok: true; value: rs.u8 }).value, early(a2)))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(parsed, f, rs.u8Debug, (value: Void.Void, f: rs.Formatter) => Void.fmt$fmt_Debug(value, f))]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); payloads(data.data, data.start, data.length, out); known(data.data, data.start, data.length, out); rematched(data, out); } /** `n`'s result: `Ok` for an even `n`. */ -export function parity(n: rt.u8): rt.u8 | undefined { - if (!(rt.u8Rem(n, 2) === 0)) { +export function parity(n: rs.u8): rs.u8 | undefined { + if (!(rs.u8Rem(n, 2) === 0)) { out$u8.err = n; return undefined; } @@ -1418,171 +1418,171 @@ export function parity(n: rt.u8): rt.u8 | undefined { * Payloads changed through a borrow, which changes the enum holding them where it is * and none of its copies. */ -export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _86!: rt.u8; - let _104!: rt.u8; - let _109!: rt.u8; +export function payloads(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _86!: rs.u8; + let _104!: rs.u8; + let _109!: rs.u8; let _128!: Uint8Array; - let _133!: rt.u8; - let _143!: rt.u8; - let _149!: rt.u8; - const n: rt.u8 = dataLen & 0xff; + let _133!: rs.u8; + let _143!: rs.u8; + let _149!: rs.u8; + const n: rs.u8 = dataLen & 0xff; const part = parity(n); - let res: rt.Result = part === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part); - const before: rt.Result = res; + let res: rs.Result = part === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part); + const before: rs.Result = res; if (!res.ok) { - res = { ok: false, error: rt.u8WrappingAdd(res.error, 1) }; + res = { ok: false, error: rs.u8WrappingAdd(res.error, 1) }; } if (res.ok) { res = { ok: true, value: res.value ^ 85 }; } - let err: rt.Result = rt.Err(n); + let err: rs.Result = rs.Err(n); if (!err.ok) { - err = { ok: false, error: rt.u8WrappingAdd(err.error, 3) }; + err = { ok: false, error: rs.u8WrappingAdd(err.error, 3) }; } - let owned: rt.Result = rt.Ok(n); + let owned: rs.Result = rs.Ok(n); if (owned.ok) { - owned = { ok: true, value: rt.u8WrappingAdd(owned.value, 2) }; + owned = { ok: true, value: rs.u8WrappingAdd(owned.value, 2) }; } - const part2: rt.u8 | undefined = parity(rt.u8WrappingAdd(n, 1)); - const err2: rt.u8 | undefined = part2 === undefined ? out$u8.err as rt.u8 : undefined; - const slot: Slot.Slot = { res: (err2 !== undefined ? rt.Err(err2 as rt.u8) : rt.Ok(part2 as rt.u8)) as rt.Result }; + const part2: rs.u8 | undefined = parity(rs.u8WrappingAdd(n, 1)); + const err2: rs.u8 | undefined = part2 === undefined ? out$u8.err as rs.u8 : undefined; + const slot: Slot.Slot = { res: (err2 !== undefined ? rs.Err(err2 as rs.u8) : rs.Ok(part2 as rs.u8)) as rs.Result }; if (!slot.res.ok) { - const _33: rt.u8 = rt.u8WrappingSub(slot.res.error, 4); + const _33: rs.u8 = rs.u8WrappingSub(slot.res.error, 4); slot.res = { ok: false, error: _33 }; } - let flow: rt.Result = rt.Err(n); + let flow: rs.Result = rs.Err(n); if (!flow.ok) { - flow = { ok: false, error: rt.u8WrappingAdd(flow.error, 9) }; + flow = { ok: false, error: rs.u8WrappingAdd(flow.error, 9) }; } - let opt: rt.u8 | undefined = n; + let opt: rs.u8 | undefined = n; if (opt !== undefined) { - opt = rt.u8WrappingAdd(opt, 7); + opt = rs.u8WrappingAdd(opt, 7); } - let poll = n as rt.Poll; - if (poll !== rt.Pending) { - poll = rt.u8WrappingSub(poll, 1); + let poll = n as rs.Poll; + if (poll !== rs.Pending) { + poll = rs.u8WrappingSub(poll, 1); } - const part3: rt.u8 | undefined = parity(rt.u8WrappingAdd(n, 2)); - const err3: rt.u8 | undefined = part3 === undefined ? out$u8.err as rt.u8 : undefined; - let nested = ((err3 !== undefined ? rt.Err(err3 as rt.u8) : rt.Ok(part3 as rt.u8)) as rt.Result) as rt.Poll | undefined>; - if (nested !== rt.Pending) { + const part3: rs.u8 | undefined = parity(rs.u8WrappingAdd(n, 2)); + const err3: rs.u8 | undefined = part3 === undefined ? out$u8.err as rs.u8 : undefined; + let nested = ((err3 !== undefined ? rs.Err(err3 as rs.u8) : rs.Ok(part3 as rs.u8)) as rs.Result) as rs.Poll | undefined>; + if (nested !== rs.Pending) { if (nested !== undefined) { if (!nested.ok) { - nested = { ok: false, error: rt.u8WrappingAdd(nested.error, 6) }; + nested = { ok: false, error: rs.u8WrappingAdd(nested.error, 6) }; } } } - const part4 = parity(rt.u8WrappingAdd(n, 3)); - let caught: rt.Result = part4 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part4); + const part4 = parity(rs.u8WrappingAdd(n, 3)); + let caught: rs.Result = part4 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part4); const bump: () => undefined = (): undefined => { if (!caught.ok) { - caught = { ok: false, error: rt.u8WrappingAdd(caught.error, 5) }; + caught = { ok: false, error: rs.u8WrappingAdd(caught.error, 5) }; } }; bump(); bump(); - const part5 = parity(rt.u8WrappingAdd(n, 4)); - let replaced: rt.Result = part5 === undefined ? rt.Err(out$u8.err as rt.u8) : rt.Ok(part5); + const part5 = parity(rs.u8WrappingAdd(n, 4)); + let replaced: rs.Result = part5 === undefined ? rs.Err(out$u8.err as rs.u8) : rs.Ok(part5); if (replaced.ok) { const old = replaced.value; replaced = { ok: true, value: 66 }; - rt.byteVecPush(out, old); + rs.byteVecPush(out, old); } - let named: rt.Result = rt.Ok(""); + let named: rs.Result = rs.Ok(""); if (named.ok) { named = { ok: true, value: named.value + "r" }; } if (named.ok) { - _86 = rt.stringLen(named.value) & 0xff; + _86 = rs.stringLen(named.value) & 0xff; } else { _86 = named.error; } - rt.byteVecPush(out, _86); - let taken: rt.Result = rt.Ok(rt.u8CheckedSub(n, 1)); + rs.byteVecPush(out, _86); + let taken: rs.Result = rs.Ok(rs.u8CheckedSub(n, 1)); if (taken.ok) { const taken2 = taken.value; - taken = rt.OK; - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(taken2, 67)); + taken = rs.OK; + rs.byteVecPush(out, option_unwrapOr$1fr498u(taken2, 67)); } - if (nested !== rt.Pending) { + if (nested !== rs.Pending) { if (nested !== undefined) { - const r: rt.Result = nested; + const r: rs.Result = nested; if (r.ok) { _104 = r.value; } else { _104 = r.error ^ 128; } - rt.byteVecPush(out, _104); + rs.byteVecPush(out, _104); } } if (taken.ok) { - _109 = option_unwrapOr$0r2bmpr(taken.value, 68); + _109 = option_unwrapOr$1fr498u(taken.value, 68); } else { _109 = taken.error; } - rt.byteVecPush(out, _109); - const iter: rt.Iter> = rt.iterSlice([before, res, err, slot.res, caught, replaced]); + rs.byteVecPush(out, _109); + const iter: rs.Iter> = rs.iterSlice([before, res, err, slot.res, caught, replaced]); while (true) { - const _121: rt.Result | rt.Done = iter.next(); - if (_121 === rt.DONE) { + const _121: rs.Result | rs.Done = iter.next(); + if (_121 === rs.DONE) { break; } - const r2: rt.Result = _121; + const r2: rs.Result = _121; if (r2.ok) { _128 = Uint8Array.of(0, r2.value); } else { _128 = Uint8Array.of(1, r2.error); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(_128)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(_128)); } if (owned.ok) { _133 = owned.value; } else { _133 = owned.error.length & 0xff; } - rt.byteVecPush(out, _133); + rs.byteVecPush(out, _133); if (flow.ok) { _143 = flow.value; } else { _143 = flow.error; } - const _147: rt.u8 = option_unwrapOr$0r2bmpr(opt, 0); - if (poll !== rt.Pending) { + const _147: rs.u8 = option_unwrapOr$1fr498u(opt, 0); + if (poll !== rs.Pending) { _149 = poll; } else { _149 = 0; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_143, _147, _149))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_143, _147, _149))); } /** Enums matched where the variant they were made with is in sight. */ -export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _15!: rt.u8; - let _18!: rt.u8; - let _21!: rt.u8; - let _25!: rt.u8; - let _29!: rt.u8; - let _39!: rt.u8; - let _45!: rt.u8; - let _52!: rt.u8; - let _56!: rt.u8; - const n: rt.u8 = dataLen & 0xff; - const ready = n as rt.Poll; - const idle = rt.Pending as rt.Poll; +export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _15!: rs.u8; + let _18!: rs.u8; + let _21!: rs.u8; + let _25!: rs.u8; + let _29!: rs.u8; + let _39!: rs.u8; + let _45!: rs.u8; + let _52!: rs.u8; + let _56!: rs.u8; + const n: rs.u8 = dataLen & 0xff; + const ready = n as rs.Poll; + const idle = rs.Pending as rs.Poll; const none = undefined as Point.Point | undefined; - const some: Point.Point | undefined = Point.new(n as rt.i32, 1); - if (ready !== rt.Pending) { + const some: Point.Point | undefined = Point.new(n as rs.i32, 1); + if (ready !== rs.Pending) { _15 = ready; } else { _15 = 0; } - if (ready !== rt.Pending) { - _18 = rt.u8WrappingAdd(ready, 1); + if (ready !== rs.Pending) { + _18 = rs.u8WrappingAdd(ready, 1); } else { _18 = 0; } - if (idle !== rt.Pending) { + if (idle !== rs.Pending) { _21 = idle.x & 0xff; } else { _21 = 255; @@ -1597,9 +1597,9 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } else { _29 = some.x & 0xff; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(_15, _18, _21, _25, _29))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(_15, _18, _21, _25, _29))); const dot = { tag: "Dot" } as Shape.Shape; - const line = { tag: "Line", _0: Point.new(n as rt.i32, 2), _1: Point.new(3, 4) } as Shape.Shape; + const line = { tag: "Line", _0: Point.new(n as rs.i32, 2), _1: Point.new(3, 4) } as Shape.Shape; if (dot.tag === "Dot") { _39 = 1; } else if (dot.tag === "Line") { @@ -1607,7 +1607,7 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } else { _39 = dot.width & 0xff; } - rt.byteVecPush(out, _39); + rs.byteVecPush(out, _39); if (line.tag === "Dot") { _45 = 1; } else if (line.tag === "Line") { @@ -1615,7 +1615,7 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } else { _45 = line.width & 0xff; } - rt.byteVecPush(out, _45); + rs.byteVecPush(out, _45); const east = "East" as Dir.Dir; if (east === "North") { _52 = 1; @@ -1624,8 +1624,8 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } else { _52 = 3; } - rt.byteVecPush(out, _52); - const equal = 0 as rt.Ordering; + rs.byteVecPush(out, _52); + const equal = 0 as rs.Ordering; if (equal === -1) { _56 = 1; } else if (equal === 0) { @@ -1633,22 +1633,22 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } else { _56 = 3; } - rt.byteVecPush(out, _56); + rs.byteVecPush(out, _56); const noneLater = undefined as Point.Point | undefined; - const later = n as rt.Poll; - rt.byteVecPush(out, ((): rt.u8 => { - let a!: rt.u8; - if (later !== rt.Pending) { + const later = n as rs.Poll; + rs.byteVecPush(out, ((): rs.u8 => { + let a!: rs.u8; + if (later !== rs.Pending) { a = later; } else { a = 0; } - return a ^ option_mapOr$0rtdylj(noneLater, 16, (p4: Point.Point): rt.u8 => { + return a ^ option_mapOr$092ozr9(noneLater, 16, (p4: Point.Point): rs.u8 => { return p4.x & 0xff; }); })()); const captured = noneLater; - rt.byteVecPush(out, ((): rt.u8 => { + rs.byteVecPush(out, ((): rs.u8 => { if (captured === undefined) { return 32; } @@ -1657,25 +1657,25 @@ export function known(_dataData: Uint8Array, _dataStart: number, dataLen: number } /** Enums matched again where an enclosing match decided their variant. */ -export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { - let _5!: rt.u8; - let _15!: rt.u8; - let _19!: rt.u8; - let _29!: rt.u8; - let _43!: rt.u8; - let r!: rt.Result; - let _58!: rt.u8; - let _76!: rt.u8; - let _97!: rt.u8; - let _107!: rt.u8; - let _118!: rt.u8; - let _127!: rt.u8; +export function rematched(data: rs.ByteSlice, out: rs.ByteVec): void { + let _5!: rs.u8; + let _15!: rs.u8; + let _19!: rs.u8; + let _29!: rs.u8; + let _43!: rs.u8; + let r!: rs.Result; + let _58!: rs.u8; + let _76!: rs.u8; + let _97!: rs.u8; + let _107!: rs.u8; + let _118!: rs.u8; + let _127!: rs.u8; let _131!: Shape.Shape; - let _189!: rt.u8; - let _192!: rt.u8; - let lift!: rt.u8; - let _206!: rt.u8; - let _226!: rt.u8; + let _189!: rs.u8; + let _192!: rs.u8; + let lift!: rs.u8; + let _206!: rs.u8; + let _226!: rs.u8; const s: Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { _5 = 2; @@ -1684,13 +1684,13 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _5 = 4; } - rt.byteVecPush(out, _5); + rs.byteVecPush(out, _5); if (s.tag === "Dot") { _15 = 6; } else { _15 = 7; } - rt.byteVecPush(out, _15); + rs.byteVecPush(out, _15); if (s.tag === "Dot") { _19 = 8; } else if (s.tag === "Line") { @@ -1698,7 +1698,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _19 = s.width & 0xff; } - rt.byteVecPush(out, _19); + rs.byteVecPush(out, _19); const d: Dir.Dir | undefined = dir(data.length & 0xff); if (d === undefined) { _29 = 15; @@ -1707,64 +1707,64 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _29 = { North: 1, East: 2, South: 4, West: 8 }[d] & 0xff; } - rt.byteVecPush(out, _29); - const order: rt.Ordering = rt.cmp(data.length & 0xff, 2); + rs.byteVecPush(out, _29); + const order: rs.Ordering = rs.cmp(data.length & 0xff, 2); if (order === -1) { _43 = 17; } else { _43 = 0; } - rt.byteVecPush(out, _43); + rs.byteVecPush(out, _43); if (order === -1) { - rt.byteVecPush(out, 32); + rs.byteVecPush(out, 32); } if (!(data.length > 1)) { - r = rt.Err(2); + r = rs.Err(2); } else { - r = rt.Ok(1); + r = rs.Ok(1); } if (r.ok) { - if ((r as rt.Result).ok) { - _58 = ((r as rt.Result) as { ok: true; value: rt.u8 }).value; + if ((r as rs.Result).ok) { + _58 = ((r as rs.Result) as { ok: true; value: rs.u8 }).value; } else { - _58 = ((r as rt.Result) as { ok: false; error: rt.u8 }).error; + _58 = ((r as rs.Result) as { ok: false; error: rs.u8 }).error; } - rt.byteVecPush(out, _58); + rs.byteVecPush(out, _58); } - let assigned = -1 as rt.Ordering; + let assigned = -1 as rs.Ordering; if (data.length > 3) { assigned = 1; } if (assigned === 0) { - rt.byteVecPush(out, 34); + rs.byteVecPush(out, 34); } - const flow: rt.Result = step(0, data.length & 0xff); + const flow: rs.Result = step(0, data.length & 0xff); if (!flow.ok) { - if ((flow as rt.Result).ok) { - _76 = ((flow as rt.Result) as { ok: true; value: rt.u16 }).value & 0xff; + if ((flow as rs.Result).ok) { + _76 = ((flow as rs.Result) as { ok: true; value: rs.u16 }).value & 0xff; } else { - _76 = option_unwrapOr$0r2bmpr(((flow as rt.Result) as { ok: false; error: rt.u8 | undefined }).error, 33); + _76 = option_unwrapOr$1fr498u(((flow as rs.Result) as { ok: false; error: rs.u8 | undefined }).error, 33); } - rt.byteVecPush(out, _76); + rs.byteVecPush(out, _76); } - const counts: rt.HashMap = rt.hashNew() as rt.HashMap; - if (rt.usizeRem(data.length, 2) === 0) { - rt.hashInsert(counts, data.length & 0xff, 35); + const counts: rs.HashMap = rs.hashNew() as rs.HashMap; + if (rs.usizeRem(data.length, 2) === 0) { + rs.hashInsert(counts, data.length & 0xff, 35); } - const entry: rt.Entry | undefined = rt.entry(counts, data.length & 0xff); + const entry: rs.Entry | undefined = rs.entry(counts, data.length & 0xff); if (entry !== undefined) { - if ((entry as rt.Entry | undefined) === undefined) { + if ((entry as rs.Entry | undefined) === undefined) { _97 = 37; - } else if (rt.entryOccupied(((entry as rt.Entry | undefined) as rt.Entry) as rt.Entry)) { - _97 = rt.entryGet((entry as rt.Entry | undefined) as rt.Entry); + } else if (rs.entryOccupied(((entry as rs.Entry | undefined) as rs.Entry) as rs.Entry)) { + _97 = rs.entryGet((entry as rs.Entry | undefined) as rs.Entry); } else { - _97 = rt.entryOrInsertMut((entry as rt.Entry | undefined) as rt.Entry, 36).v; + _97 = rs.entryOrInsertMut((entry as rs.Entry | undefined) as rs.Entry, 36).v; } - rt.byteVecPush(out, _97); + rs.byteVecPush(out, _97); } let m: Shape.Shape = s; if (m.tag === "Dot") { - const _110: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + const _110: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 1)); m = shape(_110.data, _110.start, _110.length); if (m.tag === "Line") { _107 = 18; @@ -1774,7 +1774,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _107 = 20; } - rt.byteVecPush(out, _107); + rs.byteVecPush(out, _107); let held = copy$shapes_Shape(m) as Shape.Shape | undefined; if (held === undefined) { _118 = 22; @@ -1783,56 +1783,56 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { held = undefined; const taken: Shape.Shape | undefined = taken2; if ((held as Shape.Shape | undefined) === undefined) { - _118 = option_mapOr$0aserv9(taken, 22, (t: Shape.Shape): rt.u8 => { - return rt.u64Low(Shape.area$shapes_Area(t)) & 0xff; + _118 = option_mapOr$04m3h1l(taken, 22, (t: Shape.Shape): rs.u8 => { + return rs.u64Low(Shape.area$shapes_Area(t)) & 0xff; }); } else { _118 = 21; } } - rt.byteVecPush(out, _118); + rs.byteVecPush(out, _118); let cur: Shape.Shape = s; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 3; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 3; while ((_127 = iterStart++) < iterEnd) { - const i: rt.u8 = _127; + const i: rs.u8 = _127; if (cur.tag === "Dot") { - _131 = { tag: "Line", _0: Point.new(i as rt.i32, 0), _1: Point.new(0, 0) } as Shape.Shape; + _131 = { tag: "Line", _0: Point.new(i as rs.i32, 0), _1: Point.new(0, 0) } as Shape.Shape; } else if (cur.tag === "Line") { - _131 = { tag: "Rect", corner: cur._0, width: rt.u16Add(cur._1.x & 0xffff, 1), height: 2 } as Shape.Shape; + _131 = { tag: "Rect", corner: cur._0, width: rs.u16Add(cur._1.x & 0xffff, 1), height: 2 } as Shape.Shape; } else if (!(cur.width > 1)) { _131 = cur; } else { _131 = { tag: "Dot" } as Shape.Shape; } cur = _131; - rt.byteVecPush(out, rt.u64Low(Shape.area$shapes_Area(cur)) & 0xff); + rs.byteVecPush(out, rs.u64Low(Shape.area$shapes_Area(cur)) & 0xff); } const machine: Machine.Machine = { state: copy$shapes_Shape(s), steps: 0 }; - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 4; + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 4; while (iterStart2++ < iterEnd2) { - rt.byteVecPush(out, Machine.run(machine, data.length & 0xff)); + rs.byteVecPush(out, Machine.run(machine, data.length & 0xff)); } const filled: Filled.Filled = { shape: copy$Option_shapes_Shape(option_map$0600mq0(dir(data.length & 0xff), (_2: Dir.Dir): Shape.Shape => { return copy$shapes_Shape(s); })) }; - let iterStart3: rt.i32 = 0; - const iterEnd3: rt.i32 = 3; + let iterStart3: rs.i32 = 0; + const iterEnd3: rs.i32 = 3; while (iterStart3++ < iterEnd3) { - rt.byteVecPush(out, Filled.run(filled)); + rs.byteVecPush(out, Filled.run(filled)); } let original: Shape.Shape = shape(data.data, data.start, data.length); if (original.tag === "Dot") { - const _183: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + const _183: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(1)); original = shape(_183.data, _183.start, _183.length); - rt.byteVecPush(out, 24); + rs.byteVecPush(out, 24); if (original.tag === "Line") { _189 = 25; } else { _189 = 26; } - rt.byteVecPush(out, _189); + rs.byteVecPush(out, _189); } if (s.tag === "Line") { const from3: Point.Point = s._0; @@ -1845,7 +1845,7 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _192 = 49; } - rt.byteVecPush(out, _192); + rs.byteVecPush(out, _192); b29: { if (s.tag === "Dot") { if (!(data.length > 1)) { @@ -1863,17 +1863,17 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } _206 = 55; } - rt.byteVecPush(out, _206); + rs.byteVecPush(out, _206); b31: { let w: Shape.Shape = s; if (w.tag === "Dot") { - let i2: rt.usize = 0; + let i2: rs.usize = 0; while (true) { - if (!(i2 < rt.min(data.length, 3))) { + if (!(i2 < rs.min(data.length, 3))) { break b31; } if (w.tag === "Dot") { - const _229: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); + const _229: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(1)); w = shape(_229.data, _229.start, _229.length); _226 = 56; } else if (w.tag === "Line") { @@ -1881,8 +1881,8 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _226 = 58; } - rt.byteVecPush(out, _226); - i2 = rt.usizeAdd(i2, 1); + rs.byteVecPush(out, _226); + i2 = rs.usizeAdd(i2, 1); } } } @@ -1891,22 +1891,22 @@ export function rematched(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A match a `bool` already decided: `matches!`, and `==` of a derived `PartialEq`. */ -export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { +export function decidedByBool(data: rs.ByteSlice, out: rs.ByteVec): void { let _4!: boolean; let _9!: boolean; - let _12!: rt.u8; + let _12!: rs.u8; let _17!: boolean; let wide!: boolean; - let _29!: rt.u8; - let _61!: rt.u8; + let _29!: rs.u8; + let _61!: rs.u8; let dot!: boolean; - let _82!: rt.u8; + let _82!: rs.u8; let dot2!: boolean; - let _91!: rt.u8; + let _91!: rs.u8; let seen!: boolean; - let _99!: rt.u8; - let _105!: rt.u8; - let _111!: rt.u8; + let _99!: rs.u8; + let _105!: rs.u8; + let _111!: rs.u8; let _113!: boolean; const s: Shape.Shape = shape(data.data, data.start, data.length); if (s.tag === "Dot") { @@ -1915,7 +1915,7 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { _4 = false; } if (_4) { - rt.byteVecPush(out, 61); + rs.byteVecPush(out, 61); } if (s.tag === "Line" || s.tag === "Rect") { _9 = true; @@ -1926,9 +1926,9 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { if (s.tag === "Line") { _12 = s._0.x & 0xff; } else { - _12 = ((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rt.u16; height: rt.u16 }).width & 0xff; + _12 = ((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rs.u16; height: rs.u16 }).width & 0xff; } - rt.byteVecPush(out, _12); + rs.byteVecPush(out, _12); } if (s.tag === "Line") { _17 = true; @@ -1936,7 +1936,7 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { _17 = false; } if (!_17) { - rt.byteVecPush(out, 63); + rs.byteVecPush(out, 63); } if (!(data.length > 2)) { wide = false; @@ -1952,18 +1952,18 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { _29 = 66; } } else { - _29 = ((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rt.u16; height: rt.u16 }).height & 0xff; + _29 = ((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rs.u16; height: rs.u16 }).height & 0xff; } - rt.byteVecPush(out, _29); + rs.byteVecPush(out, _29); if (Shape.eq$cmp_PartialEq(s, { tag: "Dot" } as Shape.Shape)) { - rt.byteVecPush(out, 68); + rs.byteVecPush(out, 68); } if (!Shape.eq$cmp_PartialEq(s, { tag: "Dot" } as Shape.Shape)) { - rt.byteVecPush(out, 70); + rs.byteVecPush(out, 70); } const line = { tag: "Line", _0: Point.new(0, 0), _1: Point.new(0, 0) } as Shape.Shape; if (Shape.eq$cmp_PartialEq(s, line)) { - rt.byteVecPush(out, (((s as Shape.Shape) as { tag: "Line"; _0: Point.Point; _1: Point.Point })._1.x & 0xff) ^ 71); + rs.byteVecPush(out, (((s as Shape.Shape) as { tag: "Line"; _0: Point.Point; _1: Point.Point })._1.x & 0xff) ^ 71); } if (!Shape.eq$cmp_PartialEq(s, line)) { if ((s as Shape.Shape).tag === "Line") { @@ -1971,13 +1971,13 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _61 = 74; } - rt.byteVecPush(out, _61); + rs.byteVecPush(out, _61); } - const _64: rt.ByteSlice = rt.byteSliceRange(data, rt.min(data.length, 1)); + const _64: rs.ByteSlice = rs.byteSliceRange(data, rs.min(data.length, 1)); const t: Shape.Shape = shape(_64.data, _64.start, _64.length); if (t.tag === "Rect") { if (Shape.eq$cmp_PartialEq(s, t)) { - rt.byteVecPush(out, (((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rt.u16; height: rt.u16 }).width & 0xff) ^ 75); + rs.byteVecPush(out, (((s as Shape.Shape) as { tag: "Rect"; corner: Point.Point; width: rs.u16; height: rs.u16 }).width & 0xff) ^ 75); } } let m: Shape.Shape = s; @@ -1993,7 +1993,7 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _82 = 78; } - rt.byteVecPush(out, _82); + rs.byteVecPush(out, _82); } if ((s as Shape.Shape).tag === "Dot") { dot2 = true; @@ -2009,16 +2009,16 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _91 = 80; } - rt.byteVecPush(out, _91); + rs.byteVecPush(out, _91); } if ((s as Shape.Shape).tag === "Dot") { seen = true; } else { seen = false; } - const at: rt.Place = rt.place(() => seen, (value) => seen = value); + const at: rs.Place = rs.place(() => seen, (value) => seen = value); if (!seen) { - rt.byteVecPush(out, 85); + rs.byteVecPush(out, 85); } else { at.v = data.length > 4; if (!seen) { @@ -2026,21 +2026,21 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _99 = 83; } - rt.byteVecPush(out, _99); + rs.byteVecPush(out, _99); } let cur: Shape.Shape = s; let wasDot: boolean = false; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 3; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 3; while ((_105 = iterStart++) < iterEnd) { - const i: rt.u8 = _105; + const i: rs.u8 = _105; if (wasDot) { if (cur.tag === "Dot") { _111 = 81; } else { _111 = 82; } - rt.byteVecPush(out, _111); + rs.byteVecPush(out, _111); } if (cur.tag === "Dot") { _113 = true; @@ -2048,7 +2048,7 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { _113 = false; } wasDot = _113; - const _116: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(i, i)); + const _116: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(i, i)); cur = shape(_116.data, _116.start, _116.length); } } @@ -2057,13 +2057,13 @@ export function decidedByBool(data: rt.ByteSlice, out: rt.ByteVec): void { * A reference pointed elsewhere without an assignment to it: through a `&mut` to it, * a reborrow of that, a closure, and a call. */ -export function reseated(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _12!: rt.u8; - let _19!: rt.u8; - let _26!: rt.u8; - let _37!: rt.u8; - let _51!: rt.u8; - const _8: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(1)); +export function reseated(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _12!: rs.u8; + let _19!: rs.u8; + let _26!: rs.u8; + let _37!: rs.u8; + let _51!: rs.u8; + const _8: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(1)); const _5: [Shape.Shape, Shape.Shape] = [shape(dataData, dataStart, dataLen), shape(_8.data, _8.start, _8.length)]; const a: Shape.Shape = _5[0]; const b: Shape.Shape = _5[1]; @@ -2078,7 +2078,7 @@ export function reseated(dataData: Uint8Array, dataStart: number, dataLen: numbe } else { _12 = 29; } - rt.byteVecPush(out, _12); + rs.byteVecPush(out, _12); let r2: Shape.Shape = a; if (r2.tag === "Dot") { r2 = b; @@ -2090,7 +2090,7 @@ export function reseated(dataData: Uint8Array, dataStart: number, dataLen: numbe } else { _19 = 32; } - rt.byteVecPush(out, _19); + rs.byteVecPush(out, _19); let r3: Shape.Shape = a; if (r3.tag === "Dot") { ((): undefined => { @@ -2104,7 +2104,7 @@ export function reseated(dataData: Uint8Array, dataStart: number, dataLen: numbe } else { _26 = 38; } - rt.byteVecPush(out, _26); + rs.byteVecPush(out, _26); let r4: Shape.Shape = a; let other: Shape.Shape = b; if (r4.tag === "Dot") { @@ -2119,10 +2119,10 @@ export function reseated(dataData: Uint8Array, dataStart: number, dataLen: numbe } else { _37 = 41; } - rt.byteVecPush(out, _37); + rs.byteVecPush(out, _37); let r5: Shape.Shape = a; - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 2; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 2; while (iterStart++ < iterEnd) { if (r5.tag === "Dot") { r5 = b; @@ -2134,13 +2134,13 @@ export function reseated(dataData: Uint8Array, dataStart: number, dataLen: numbe } else { _51 = 44; } - rt.byteVecPush(out, _51); + rs.byteVecPush(out, _51); } - rt.byteVecPush(out, rebound(a, b)); + rs.byteVecPush(out, rebound(a, b)); } /** A parameter pointed elsewhere, after a copy of it that still points where it did. */ -export function rebound(r: Shape.Shape, b: Shape.Shape): rt.u8 { +export function rebound(r: Shape.Shape, b: Shape.Shape): rs.u8 { const kept: Shape.Shape = r; r = b; if (r.tag === "Line") { @@ -2153,347 +2153,347 @@ export function rebound(r: Shape.Shape, b: Shape.Shape): rt.u8 { } /** A `match` without arms on a scrutinee that diverges, not on an empty type. */ -export function early(n: rt.u8): rt.u8 { - return rt.u8WrappingAdd(n, 1); +export function early(n: rs.u8): rs.u8 { + return rs.u8WrappingAdd(n, 1); } /** A `Result` that can't fail, which counts its calls so their order shows. */ -export function counted(calls: rt.Place, b: rt.u8): rt.Result { - calls.v = rt.u8WrappingAdd(calls.v, 1); - return rt.Ok(rt.u8WrappingMul(b, calls.v)); +export function counted(calls: rs.Place, b: rs.u8): rs.Result { + calls.v = rs.u8WrappingAdd(calls.v, 1); + return rs.Ok(rs.u8WrappingMul(b, calls.v)); } /** * Patterns on parts of a place whose other variants can't exist, which test nothing * there, while what they read still runs in order. */ -export function uninhabited(data: rt.ByteSlice, out: rt.ByteVec): void { - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - let calls: rt.u8 = 0; - const _13: rt.Result = counted(rt.place(() => calls, (value) => calls = value), a); - const _12: [rt.Result, rt.Result] = [_13, counted(rt.place(() => calls, (value2) => calls = value2), b)]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((_13 as { ok: true; value: rt.u8 }).value, (_12[1] as { ok: true; value: rt.u8 }).value, calls))); - const _26: rt.Result[] = [counted(rt.place(() => calls, (value3) => calls = value3), b), counted(rt.place(() => calls, (value4) => calls = value4), a)]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((_26[0] as { ok: true; value: rt.u8 }).value, (_26[1] as { ok: true; value: rt.u8 }).value, calls))); - counted(rt.place(() => calls, (value5) => calls = value5), a); - rt.byteVecPush(out, calls); - counted(rt.place(() => calls, (value6) => calls = value6), a); - rt.byteVecPush(out, calls); - [counted(rt.place(() => calls, (value7) => calls = value7), a), [counted(rt.place(() => calls, (value8) => calls = value8), b)] as [rt.Result]] as [rt.Result, [rt.Result]]; - rt.byteVecPush(out, calls); - const pair: [rt.Result, Partial.Partial] = [counted(rt.place(() => calls, (value9) => calls = value9), a), { tag: "Real", _0: b } as Partial.Partial]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((pair[0] as { ok: true; value: rt.u8 }).value, (pair[1] as { tag: "Real"; _0: rt.u8 })._0))); - const held: Parts.Parts = { left: rt.Ok(a), right: thenSome$0ztng9q(rt.u8Rem(b, 2) === 0, rt.Ok(((b as rt.u16) << 4) & 0xffff)) }; - const l: rt.u8 = (held.left as { ok: true; value: rt.u8 }).value; - const right: rt.Result | undefined = held.right; +export function uninhabited(data: rs.ByteSlice, out: rs.ByteVec): void { + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + let calls: rs.u8 = 0; + const _13: rs.Result = counted(rs.place(() => calls, (value) => calls = value), a); + const _12: [rs.Result, rs.Result] = [_13, counted(rs.place(() => calls, (value2) => calls = value2), b)]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((_13 as { ok: true; value: rs.u8 }).value, (_12[1] as { ok: true; value: rs.u8 }).value, calls))); + const _26: rs.Result[] = [counted(rs.place(() => calls, (value3) => calls = value3), b), counted(rs.place(() => calls, (value4) => calls = value4), a)]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((_26[0] as { ok: true; value: rs.u8 }).value, (_26[1] as { ok: true; value: rs.u8 }).value, calls))); + counted(rs.place(() => calls, (value5) => calls = value5), a); + rs.byteVecPush(out, calls); + counted(rs.place(() => calls, (value6) => calls = value6), a); + rs.byteVecPush(out, calls); + [counted(rs.place(() => calls, (value7) => calls = value7), a), [counted(rs.place(() => calls, (value8) => calls = value8), b)] as [rs.Result]] as [rs.Result, [rs.Result]]; + rs.byteVecPush(out, calls); + const pair: [rs.Result, Partial.Partial] = [counted(rs.place(() => calls, (value9) => calls = value9), a), { tag: "Real", _0: b } as Partial.Partial]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((pair[0] as { ok: true; value: rs.u8 }).value, (pair[1] as { tag: "Real"; _0: rs.u8 })._0))); + const held: Parts.Parts = { left: rs.Ok(a), right: thenSome$1uv8pdy(rs.u8Rem(b, 2) === 0, rs.Ok(((b as rs.u16) << 4) & 0xffff)) }; + const l: rs.u8 = (held.left as { ok: true; value: rs.u8 }).value; + const right: rs.Result | undefined = held.right; if (right === undefined) { - rt.byteVecPush(out, l); + rs.byteVecPush(out, l); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes((right as { ok: true; value: rt.u16 }).value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes((right as { ok: true; value: rs.u16 }).value))); } - const _93: [Partial.Partial, rt.Result] = [{ tag: "Real", _0: a } as Partial.Partial, held.left]; - rt.byteVecPush(out, (_93[0] as { tag: "Real"; _0: rt.u8 })._0 ^ (_93[1] as { ok: true; value: rt.u8 }).value); - const _101: [rt.Result, rt.u8 | undefined] = [counted(rt.place(() => calls, (value10) => calls = value10), a), rt.byteSliceGet(data, 2)]; + const _93: [Partial.Partial, rs.Result] = [{ tag: "Real", _0: a } as Partial.Partial, held.left]; + rs.byteVecPush(out, (_93[0] as { tag: "Real"; _0: rs.u8 })._0 ^ (_93[1] as { ok: true; value: rs.u8 }).value); + const _101: [rs.Result, rs.u8 | undefined] = [counted(rs.place(() => calls, (value10) => calls = value10), a), rs.byteSliceGet(data, 2)]; if (_101[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((_101[0] as { ok: true; value: rt.u8 }).value, _101[1]))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((_101[0] as { ok: true; value: rs.u8 }).value, _101[1]))); } else { - rt.byteVecPush(out, calls); + rs.byteVecPush(out, calls); } - const _119: [rt.Result, rt.u8 | undefined] = [counted(rt.place(() => calls, (value11) => calls = value11), b), rt.byteSliceGet(data, 3)]; + const _119: [rs.Result, rs.u8 | undefined] = [counted(rs.place(() => calls, (value11) => calls = value11), b), rs.byteSliceGet(data, 3)]; if (_119[1] !== undefined) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of((_119[0] as { ok: true; value: rt.u8 }).value, _119[1], calls))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of((_119[0] as { ok: true; value: rs.u8 }).value, _119[1], calls))); } else { - rt.byteVecPush(out, calls); + rs.byteVecPush(out, calls); } } /** Closures capturing by reference and by move, and functions as values. */ -export function closures(data: rt.ByteSlice, out: rt.ByteVec): void { - let sum: rt.u32 = 0; - const add: (a0: rt.u8) => undefined = (v: rt.u8): undefined => { - sum = rt.u32Add(sum, v as rt.u32); +export function closures(data: rs.ByteSlice, out: rs.ByteVec): void { + let sum: rs.u32 = 0; + const add: (a0: rs.u8) => undefined = (v: rs.u8): undefined => { + sum = rs.u32Add(sum, v as rs.u32); }; - for (const _8 of rt.byteSliceView(data)) { + for (const _8 of rs.byteSliceView(data)) { add(_8); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(sum))); - const base: rt.u32 = data.length as rt.u32; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(sum))); + const base: rs.u32 = data.length as rs.u32; const captured = base; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(apply$shapes_closures_closure1((v2: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(v2, 3), captured); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(apply$shapes_closures_closure1((v2: rs.u32): rs.u32 => { + return rs.u32Add(rs.u32Mul(v2, 3), captured); }, sum)))); - let n: rt.u32 = base; + let n: rs.u32 = base; const captured2 = n; - n = rt.u32Add(n, 10); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32Add(((): rt.u32 => { - return rt.u32Add(captured2, 1); + n = rs.u32Add(n, 10); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32Add(((): rs.u32 => { + return rs.u32Add(captured2, 1); })(), n)))); const whole: Uint8Array = Uint8Array.of(data.length & 0xff); - overwrite(rt.byteSliceFrom(whole)); - rt.byteVecPush(out, whole[0]); - const parsed: rt.Vec = new rt.Vec(); - for (const _53 of rt.byteSliceView(data)) { + overwrite(rs.byteSliceFrom(whole)); + rs.byteVecPush(out, whole[0]); + const parsed: rs.Vec = new rs.Vec(); + for (const _53 of rs.byteSliceView(data)) { const _59: Dir.Dir | undefined = dir(_53); parsed.items.push(_59); } - const tags: rt.ByteVec = new rt.ByteVec(); + const tags: rs.ByteVec = new rs.ByteVec(); for (const _64 of parsed.items) { - const _70: rt.u8 = option_unwrapOr$0r2bmpr(option_map$18z3v8h(_64, from$convert_From_shapes_Dir_u8), 0); - rt.byteVecPush(tags, _70); + const _70: rs.u8 = option_unwrapOr$1fr498u(option_map$1mgv9ns(_64, from$convert_From_shapes_Dir_u8), 0); + rs.byteVecPush(tags, _70); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(tags)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(tags)); } /** Replaces `a` whole from a closure. */ -export function overwrite(a: rt.ByteSlice): void { +export function overwrite(a: rs.ByteSlice): void { ((): undefined => { a.data.set(Uint8Array.of(9), a.start); })(); } -export function apply$shapes_closures_closure1(f: (a0: rt.u32) => rt.u32, v: rt.u32): rt.u32 { +export function apply$shapes_closures_closure1(f: (a0: rs.u32) => rs.u32, v: rs.u32): rs.u32 { return f(v); } /** Options, results, `?`, and strings. */ -export function library(data: rt.ByteSlice, out: rt.ByteVec): void { - let parsed!: rt.Result; - const _3: (a0: rt.u8, a1: rt.u8) => rt.u8 | undefined = (a2: rt.u8, b2: rt.u8): rt.u8 | undefined => { - const _4: rt.u8 | undefined = rt.u8CheckedAdd(a2, b2); +export function library(data: rs.ByteSlice, out: rs.ByteVec): void { + let parsed!: rs.Result; + const _3: (a0: rs.u8, a1: rs.u8) => rs.u8 | undefined = (a2: rs.u8, b2: rs.u8): rs.u8 | undefined => { + const _4: rs.u8 | undefined = rs.u8CheckedAdd(a2, b2); if (_4 !== undefined) { - const _83: rt.u8 | undefined = rt.u8CheckedMul(_4, 2); + const _83: rs.u8 | undefined = rs.u8CheckedMul(_4, 2); if (_83 !== undefined) { - return rt.u8Sub(_83, 1); + return rs.u8Sub(_83, 1); } return undefined; } return undefined; }; - const _30: (a0: rt.u8) => rt.Poll> = (a3: rt.u8): rt.Poll> => { - let half2!: rt.Result; + const _30: (a0: rs.u8) => rs.Poll> = (a3: rs.u8): rs.Poll> => { + let half2!: rs.Result; const _45: Dir.Dir | undefined = dir(a3); b0: { if (_45 !== undefined) { - if (rt.u8Rem(a3, 2) === 1) { - half2 = rt.Err(_45); + if (rs.u8Rem(a3, 2) === 1) { + half2 = rs.Err(_45); break b0; } } - half2 = rt.Ok(rt.u8Div(a3, 2)); + half2 = rs.Ok(rs.u8Div(a3, 2)); } - const _132: rt.Result = half2; + const _132: rs.Result = half2; if (_132.ok) { - return rt.Ok(_132.value); + return rs.Ok(_132.value); } - return rt.Err(from$convert_From_shapes_Dir_u8((_132 as { ok: false; error: Dir.Dir }).error)); + return rs.Err(from$convert_From_shapes_Dir_u8((_132 as { ok: false; error: Dir.Dir }).error)); }; - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - const b: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_3(a, b), 255)); + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + const b: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0); + rs.byteVecPush(out, option_unwrapOr$1fr498u(_3(a, b), 255)); if (a === 0) { - parsed = rt.Err("zero"); + parsed = rs.Err("zero"); } else { - parsed = rt.Ok(a); + parsed = rs.Ok(a); } - const mapped: rt.Result = result_mapErr$0dzqwjy(result_map$1dbyvzi(parsed, (n7: rt.u8): rt.u8 => { - return rt.u8Div(n7, 2); - }), (e4: string): rt.u8 => { - return rt.stringLen(e4) & 0xff; + const mapped: rs.Result = result_mapErr$0hqg57m(result_map$1yblbjf(parsed, (n7: rs.u8): rs.u8 => { + return rs.u8Div(n7, 2); + }), (e4: string): rs.u8 => { + return rs.stringLen(e4) & 0xff; }); if (mapped.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(0, mapped.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(0, mapped.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(1, mapped.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(1, mapped.error))); } - const _32: rt.Poll> = _30(b); - if (_32 !== rt.Pending) { + const _32: rs.Poll> = _30(b); + if (_32 !== rs.Pending) { if (_32.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(2, _32.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(2, _32.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(3, _32.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(3, _32.error))); } } else { - rt.byteVecPush(out, 4); + rs.byteVecPush(out, 4); } - const _46: rt.Result = rt.stringFromUtf8(rt.byteSliceToByteVec(data)); + const _46: rs.Result = rs.stringFromUtf8(rs.byteSliceToByteVec(data)); if (_46.ok) { const s: string = _46.value; - rt.byteVecPush(out, 1); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.stringLen(s) as rt.u32))); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); + rs.byteVecPush(out, 1); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.stringLen(s) as rs.u32))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } - let calls: rt.u8 = 0; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(data)), 6); + let calls: rs.u8 = 0; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(data)), 6); while (true) { - const _66: rt.u8 | rt.Done = iter.next(); - if (_66 === rt.DONE) { + const _66: rs.u8 | rs.Done = iter.next(); + if (_66 === rs.DONE) { break; } - const x: rt.u8 = _66; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(option_unwrapOr$0r2bmpr(then$1btzga3(rt.u8Rem(x, 2) === 0, (): rt.u8 => { - calls = rt.u8Add(calls, 1); - return rt.u8Div(x, 2); + const x: rs.u8 = _66; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(option_unwrapOr$1fr498u(then$1ldvmdq(rs.u8Rem(x, 2) === 0, (): rs.u8 => { + calls = rs.u8Add(calls, 1); + return rs.u8Div(x, 2); }), 238), calls))); - rt.byteVecPush(out, option_mapOr$1a3irjf(then$1i9qaz4(x > 128, (): rt.ByteVec => { - return new rt.ByteVec(); - }), 2, (v: rt.ByteVec): rt.u8 => { + rs.byteVecPush(out, option_mapOr$0g5x999(then$0y7on52(x > 128, (): rs.ByteVec => { + return new rs.ByteVec(); + }), 2, (v: rs.ByteVec): rs.u8 => { return v.length & 0xff; })); - const flag: boolean = rt.u8Rem(x, 3) === 0; - rt.byteVecPush(out, rt.u8Add(rt.u8Add(flag ? 1 : 0, (flag ? 1 : 0) & 0xff), (flag ? 1 : 0) & 0xff)); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(flag ? 1 : 0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(flag ? 1 : 0))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(flag ? 1 : 0))); + const flag: boolean = rs.u8Rem(x, 3) === 0; + rs.byteVecPush(out, rs.u8Add(rs.u8Add(flag ? 1 : 0, (flag ? 1 : 0) & 0xff), (flag ? 1 : 0) & 0xff)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(flag ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(flag ? 1 : 0))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(flag ? 1 : 0))); } - const _117: rt.Result = option_okOr$1vxk0yk(undefined as rt.u8 | undefined, a); + const _117: rs.Result = option_okOr$1j8owgb(undefined as rs.u8 | undefined, a); if (_117.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(5, _117.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(5, _117.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(6, _117.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(6, _117.error))); } - const iter2: rt.Iter> = rt.iterSlice([option_okOr$1vxk0yk(undefined as rt.u8 | undefined, b), option_okOr$1vxk0yk(undefined, a)]); + const iter2: rs.Iter> = rs.iterSlice([option_okOr$1j8owgb(undefined as rs.u8 | undefined, b), option_okOr$1j8owgb(undefined, a)]); while (true) { - const _134: rt.Result | rt.Done = iter2.next(); - if (_134 === rt.DONE) { + const _134: rs.Result | rs.Done = iter2.next(); + if (_134 === rs.DONE) { break; } - const result: rt.Result = _134; + const result: rs.Result = _134; if (result.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(5, result.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(5, result.value))); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(6, result.error))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(6, result.error))); } } } /** A result with nothing set yet. */ -export function unset(): rt.u8 | undefined { +export function unset(): rs.u8 | undefined { out$Option_u8.p = undefined; return undefined; } /** Steps a total by `x`: breaks with what it can't take, or continues with the new total. */ -export function step(total: rt.u16, x: rt.u8): rt.Result { - const _3: rt.u16 | undefined = rt.u16CheckedAdd(total, rt.u16Mul(x as rt.u16, 64)); +export function step(total: rs.u16, x: rs.u8): rs.Result { + const _3: rs.u16 | undefined = rs.u16CheckedAdd(total, rs.u16Mul(x as rs.u16, 64)); if (!(x === 0)) { if (_3 === undefined) { - return rt.Err(255); + return rs.Err(255); } if (!(_3 > 8192)) { - return rt.Ok(_3); + return rs.Ok(_3); } - return rt.Err(x); + return rs.Err(x); } - return rt.ERR; + return rs.ERR; } /** A step that may be pending, as a polled read is. */ -export function polled(x: rt.u8): rt.Poll, rt.u8>> { - const _2: rt.u8 = rt.u8Rem(x, 4); +export function polled(x: rs.u8): rs.Poll, rs.u8>> { + const _2: rs.u8 = rs.u8Rem(x, 4); if (_2 === 0) { - return rt.Pending; + return rs.Pending; } if (_2 === 1) { - return rt.Err(x); + return rs.Err(x); } if (_2 === 2) { - return rt.Ok(rt.ERR); + return rs.Ok(rs.ERR); } - return rt.Ok(rt.OK); + return rs.Ok(rs.OK); } /** * `ControlFlow`s made by hand rather than by `?`, and a value replaced through a * `MutexGuard`. */ -export function flows(data: rt.ByteSlice, out: rt.ByteVec): void { - let result!: rt.Result; - let option!: rt.u8 | undefined; - let _116!: rt.u8; +export function flows(data: rs.ByteSlice, out: rs.ByteVec): void { + let result!: rs.Result; + let option!: rs.u8 | undefined; + let _116!: rs.u8; let _132!: boolean; - let total: rt.u16 = 0; - for (const x of rt.byteSliceView(data)) { - const flow: rt.Result = step(total, x); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(!flow.ok ? 1 : 0, flow.ok ? 1 : 0))); + let total: rs.u16 = 0; + for (const x of rs.byteSliceView(data)) { + const flow: rs.Result = step(total, x); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(!flow.ok ? 1 : 0, flow.ok ? 1 : 0))); if (flow.ok) { total = flow.value; } else if (flow.error === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - rt.byteVecPush(out, flow.error); + rs.byteVecPush(out, flow.error); } - const _28: rt.Poll, rt.u8>> = polled(x); - if (_28 !== rt.Pending) { + const _28: rs.Poll, rs.u8>> = polled(x); + if (_28 !== rs.Pending) { if (_28.ok) { - rt.byteVecPush(out, rt.u8Add(2, !_28.value.ok ? 1 : 0)); + rs.byteVecPush(out, rs.u8Add(2, !_28.value.ok ? 1 : 0)); } else { - rt.byteVecPush(out, _28.error); + rs.byteVecPush(out, _28.error); } } else { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(total))); - const a: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - if (rt.u8Rem(a, 3) === 0) { - result = rt.Err(a) as rt.Result; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(total))); + const a: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + if (rs.u8Rem(a, 3) === 0) { + result = rs.Err(a) as rs.Result; } else { - result = rt.Ok(rt.u16Add(a as rt.u16, 256)); + result = rs.Ok(rs.u16Add(a as rs.u16, 256)); } - rt.byteVecPush(out, result.ok ? 1 : 0); + rs.byteVecPush(out, result.ok ? 1 : 0); if (result.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(result.value))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(result.value))); } else { - rt.byteVecPush(out, (result as { ok: false; error: rt.u8 }).error); + rs.byteVecPush(out, (result as { ok: false; error: rs.u8 }).error); } - if (rt.u8Rem(a, 5) === 0) { - option = undefined as rt.u8 | undefined; + if (rs.u8Rem(a, 5) === 0) { + option = undefined as rs.u8 | undefined; } else { - option = rt.u8Div(a, 5) as rt.u8 | undefined; + option = rs.u8Div(a, 5) as rs.u8 | undefined; } - rt.byteVecPush(out, option === undefined ? 1 : 0); + rs.byteVecPush(out, option === undefined ? 1 : 0); if (option !== undefined) { - rt.byteVecPush(out, option); + rs.byteVecPush(out, option); } else { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } - const original: rt.Result = rt.Ok(Uint8Array.of(a, 1)); - const copied: rt.Result = copy$ops_ControlFlow_unit_array2_u8(original); + const original: rs.Result = rs.Ok(Uint8Array.of(a, 1)); + const copied: rs.Result = copy$ops_ControlFlow_unit_array2_u8(original); if (copied.ok) { - const v: rt.ByteSlice = rt.byteSliceFrom(copied.value); - const _83: rt.u8 = rt.u8WrappingAdd(v.data[v.start], 1); + const v: rs.ByteSlice = rs.byteSliceFrom(copied.value); + const _83: rs.u8 = rs.u8WrappingAdd(v.data[v.start], 1); v.data[v.start] = _83; } - const _91: rt.Result = copy$ops_ControlFlow_unit_array2_u8(copied); - const iter2: rt.Iter> = rt.iterSlice([copy$ops_ControlFlow_unit_array2_u8(original), _91]); + const _91: rs.Result = copy$ops_ControlFlow_unit_array2_u8(copied); + const iter2: rs.Iter> = rs.iterSlice([copy$ops_ControlFlow_unit_array2_u8(original), _91]); while (true) { - const _93: rt.Result | rt.Done = iter2.next(); - if (_93 === rt.DONE) { + const _93: rs.Result | rs.Done = iter2.next(); + if (_93 === rs.DONE) { break; } - const flow3: rt.Result = _93; + const flow3: rs.Result = _93; if (flow3.ok) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(flow3.value)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(flow3.value)); } } const err = unset(); - let set: rt.Result = err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(out$Option_u8.p); + let set: rs.Result = err !== undefined ? rs.Err(err as rs.u8) : rs.Ok(out$Option_u8.p); if (set.ok) { set = { ok: true, value: a }; } - const _108: rt.Result = set; - const err2: rt.u8 | undefined = unset(); - const part: rt.u8 | undefined = out$Option_u8.p; - const iter3: rt.Iter> = rt.iterSlice([_108, (err2 !== undefined ? rt.Err(err2 as rt.u8) : rt.Ok(part)) as rt.Result]); + const _108: rs.Result = set; + const err2: rs.u8 | undefined = unset(); + const part: rs.u8 | undefined = out$Option_u8.p; + const iter3: rs.Iter> = rs.iterSlice([_108, (err2 !== undefined ? rs.Err(err2 as rs.u8) : rs.Ok(part)) as rs.Result]); while (true) { - const _111: rt.Result | rt.Done = iter3.next(); - if (_111 === rt.DONE) { + const _111: rs.Result | rs.Done = iter3.next(); + if (_111 === rs.DONE) { break; } - const result2: rt.Result = _111; + const result2: rs.Result = _111; if (result2.ok) { if (result2.value === undefined) { _116 = 254; @@ -2503,12 +2503,12 @@ export function flows(data: rt.ByteSlice, out: rt.ByteVec): void { } else { _116 = result2.error; } - rt.byteVecPush(out, _116); + rs.byteVecPush(out, _116); } - const slot: rt.Mutex = new rt.Mutex(undefined as rt.u8 | undefined); - for (const x2 of rt.byteSliceView(data)) { - const held: rt.Mutex = rt.mutexLock(slot); - const _133: rt.u8 | undefined = held.value; + const slot: rs.Mutex = new rs.Mutex(undefined as rs.u8 | undefined); + for (const x2 of rs.byteSliceView(data)) { + const held: rs.Mutex = rs.mutexLock(slot); + const _133: rs.u8 | undefined = held.value; b16: { if (_133 !== undefined) { if (_133 >= x2) { @@ -2521,11 +2521,11 @@ export function flows(data: rt.ByteSlice, out: rt.ByteVec): void { if (!_132) { held.value = x2; } - rt.mutexUnlock(held); + rs.mutexUnlock(held); } - const _148: rt.Mutex = rt.mutexLock(slot); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(_148.value, 252)); - rt.mutexUnlock(_148); + const _148: rs.Mutex = rs.mutexLock(slot); + rs.byteVecPush(out, option_unwrapOr$1fr498u(_148.value, 252)); + rs.mutexUnlock(_148); } //# sourceMappingURL=shapes.ts.map diff --git a/ts/fixtures/lang/shapes/src/fmt.rs b/ts/fixtures/lang/shapes/src/fmt.rs index 7699c4c57..e6f94aa49 100644 --- a/ts/fixtures/lang/shapes/src/fmt.rs +++ b/ts/fixtures/lang/shapes/src/fmt.rs @@ -794,7 +794,7 @@ pub fn enums(data: &[u8], out: &mut Vec) { 0 => ControlFlow::Break(None), _ => ControlFlow::Continue(at(2)), }; - // `()` is `undefined`, so its `None` is `rt.None`. + // `()` is `undefined`, so its `None` is `rs.None`. let unit_none: ControlFlow> = match at(2) % 2 { 0 => ControlFlow::Break(None), _ => ControlFlow::Continue(()), diff --git a/ts/fixtures/lang/shapes/src/shapes.rs b/ts/fixtures/lang/shapes/src/shapes.rs index a9a525aaf..67000a6c8 100644 --- a/ts/fixtures/lang/shapes/src/shapes.rs +++ b/ts/fixtures/lang/shapes/src/shapes.rs @@ -447,7 +447,7 @@ fn shares(data: &[u8], out: &mut Vec) { fn write_at(live: &mut [u8], at: usize, b: u8) -> u8 { live[at] = b; live[0] ^= live[at].wrapping_add(1); - // Reassigned, so its bounds checks read its length apart from `rt.idx`. + // Reassigned, so its bounds checks read its length apart from `rs.idx`. let mut rest = &mut *live; if b % 2 == 0 { rest = &mut rest[1..]; diff --git a/ts/fixtures/lang/shares/expected/core/bool.ts b/ts/fixtures/lang/shares/expected/core/bool.ts index c74fef0e6..08773db88 100644 --- a/ts/fixtures/lang/shares/expected/core/bool.ts +++ b/ts/fixtures/lang/shares/expected/core/bool.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function then$1kj52rc(self: boolean, f: () => [rt.Arc, rt.Arc]): [rt.Arc, rt.Arc] | undefined { +export function then$1m4hja7(self: boolean, f: () => [rs.Arc, rs.Arc]): [rs.Arc, rs.Arc] | undefined { if (!self) { return undefined; } return f(); } -export function then$1ugtkd3(self: boolean, f: () => [rt.Weak, rt.Weak]): [rt.Weak, rt.Weak] | undefined { +export function then$1mk0ygo(self: boolean, f: () => [rs.Weak, rs.Weak]): [rs.Weak, rs.Weak] | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/lang/shares/expected/core/option.ts b/ts/fixtures/lang/shares/expected/core/option.ts index 8389bfa54..2ffd150eb 100644 --- a/ts/fixtures/lang/shares/expected/core/option.ts +++ b/ts/fixtures/lang/shares/expected/core/option.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Logged from "../shares.Logged.ts"; -export function isSomeAnd$0vr0nda(self: rt.Arc | undefined, f: (a0: rt.Arc) => boolean): boolean { +export function isSomeAnd$136asov(self: rs.Arc | undefined, f: (a0: rs.Arc) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function isSomeAnd$0uiydx2(self: [rt.Weak, rt.Weak] | undefined, f: (a0: [rt.Weak, rt.Weak]) => boolean): boolean { +export function isSomeAnd$0jg0wcy(self: [rs.Weak, rs.Weak] | undefined, f: (a0: [rs.Weak, rs.Weak]) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$03siheh(self: rt.Arc | undefined, default_: rt.u8, f: (a0: rt.Arc) => rt.u8): rt.u8 { +export function mapOr$00xrvtw(self: rs.Arc | undefined, default_: rs.u8, f: (a0: rs.Arc) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$148vfk5(self: Logged.Logged | undefined, default_: rt.u8, f: (a0: Logged.Logged) => rt.u8): rt.u8 { +export function mapOr$1tej7ml(self: Logged.Logged | undefined, default_: rs.u8, f: (a0: Logged.Logged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/shares/expected/harness.ts b/ts/fixtures/lang/shares/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/shares/expected/harness.ts +++ b/ts/fixtures/lang/shares/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/shares/expected/lib.ts b/ts/fixtures/lang/shares/expected/lib.ts index 70cc0f8ed..6bc702474 100644 --- a/ts/fixtures/lang/shares/expected/lib.ts +++ b/ts/fixtures/lang/shares/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { bytes, wides, copies, drops, strs, generics, keys, addresses } from "./shares.ts"; import type * as Logged from "./shares.Logged.ts"; @@ -8,42 +8,42 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function copy$tuple2_u8_u16(v: [rt.u8, rt.u16]): [rt.u8, rt.u16] { +export function copy$tuple2_u8_u16(v: [rs.u8, rs.u16]): [rs.u8, rs.u16] { return [v[0], v[1]]; } -export function drop$Option_Rc_slice_shares_Logged(_1: rt.Arc | undefined): void { +export function drop$Option_Rc_slice_shares_Logged(_1: rs.Arc | undefined): void { if (_1 !== undefined) { - rt.arcDrop(_1, drop$slice_shares_Logged); + rs.arcDrop(_1, drop$slice_shares_Logged); } } -export function drop$Option_tuple2_Rc_slice_u16_sync_Arc_slice_u8(_1: [rt.Arc, rt.Arc] | undefined): void { +export function drop$Option_tuple2_Rc_slice_u16_sync_Arc_slice_u8(_1: [rs.Arc, rs.Arc] | undefined): void { if (_1 !== undefined) { drop$tuple2_Rc_slice_u16_sync_Arc_slice_u8(_1); } } -export function drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rt.Weak, rt.Weak] | undefined): void { +export function drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rs.Weak, rs.Weak] | undefined): void { if (_1 !== undefined) { drop$tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1); } } -export function drop$Rc_slice_shares_Logged(value: rt.Arc): void { - rt.arcDrop(value, drop$slice_shares_Logged); +export function drop$Rc_slice_shares_Logged(value: rs.Arc): void { + rs.arcDrop(value, drop$slice_shares_Logged); } export function drop$slice_shares_Logged(value: Logged.Logged[]): void { - rt.dropAll(value); + rs.dropAll(value); } -export function drop$tuple2_Rc_slice_u16_sync_Arc_slice_u8(_1: [rt.Arc, rt.Arc]): void { +export function drop$tuple2_Rc_slice_u16_sync_Arc_slice_u8(_1: [rs.Arc, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } -export function drop$tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rt.Weak, rt.Weak]): void { +export function drop$tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rs.Weak, rs.Weak]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } @@ -52,8 +52,8 @@ export function drop$tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(_1: [rt.Weak undefined]> { - return rt.vecFrom([["shares::bytes", bytes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::wides", wides as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::copies", copies as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::drops", drops as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::generics", generics as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::keys", keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["shares::addresses", addresses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["shares::bytes", bytes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::wides", wides as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::copies", copies as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::drops", drops as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::strs", strs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::generics", generics as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::keys", keys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["shares::addresses", addresses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/shares/expected/shares.Held.ts b/ts/fixtures/lang/shares/expected/shares.Held.ts index 69e187fcd..9cda30335 100644 --- a/ts/fixtures/lang/shares/expected/shares.Held.ts +++ b/ts/fixtures/lang/shares/expected/shares.Held.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$slice_shares_Logged } from "./lib.ts"; import type * as Logged from "./shares.Logged.ts"; /** A shared slice in a field, beside one that drops after it. */ export class Held { - items: rt.Arc; + items: rs.Arc; last: Logged.Logged; - constructor(items: rt.Arc, last: Logged.Logged) { + constructor(items: rs.Arc, last: Logged.Logged) { this.items = items; this.last = last; } [Symbol.dispose](): void { - rt.arcDrop(this.items, drop$slice_shares_Logged); + rs.arcDrop(this.items, drop$slice_shares_Logged); this.last[Symbol.dispose](); } } diff --git a/ts/fixtures/lang/shares/expected/shares.Logged.ts b/ts/fixtures/lang/shares/expected/shares.Logged.ts index a66030ef8..ad6683eec 100644 --- a/ts/fixtures/lang/shares/expected/shares.Logged.ts +++ b/ts/fixtures/lang/shares/expected/shares.Logged.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops, and as it is cloned, the id with the high bit set: its clone's * id is one more. */ export class Logged { - id: rt.u8; - log: rt.Arc>; + id: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, log: rs.Arc>) { this.id = id; this.log = log; } @@ -22,16 +22,16 @@ export class Logged { } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, 128 | self.id); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1), rt.arcClone(self.log)); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, 128 | self.id); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1), rs.arcClone(self.log)); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=shares.Logged.ts.map diff --git a/ts/fixtures/lang/shares/expected/shares.Shared.ts b/ts/fixtures/lang/shares/expected/shares.Shared.ts index b29e93635..abe58f9d4 100644 --- a/ts/fixtures/lang/shares/expected/shares.Shared.ts +++ b/ts/fixtures/lang/shares/expected/shares.Shared.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Rc_slice_shares_Logged } from "./lib.ts"; import * as Logged from "./shares.Logged.ts"; @@ -9,42 +9,42 @@ import * as Logged from "./shares.Logged.ts"; * as each instance holds it. */ export class Shared { - items: rt.Arc>; + items: rs.Arc>; - constructor(items: rt.Arc>) { + constructor(items: rs.Arc>) { this.items = items; } [Symbol.dispose](): void { - rt.arcDrop(this.items as rt.Arc, (value: T[]) => rt.dropAll(value)); + rs.arcDrop(this.items as rs.Arc, (value: T[]) => rs.dropAll(value)); } } -export function new$shares_Logged(items: rt.Vec): Shared { - return new Shared(new rt.Arc(items.items)); +export function new$shares_Logged(items: rs.Vec): Shared { + return new Shared(new rs.Arc(items.items)); } -export function new$u8(items: rt.ByteVec): Shared { - return new Shared(new rt.Arc(rt.byteVecSlice(items))); +export function new$u8(items: rs.ByteVec): Shared { + return new Shared(new rs.Arc(rs.byteVecSlice(items))); } -export function collected$u16_iter_Map_slice_Iter_u8_shares_generics_closure0(items: rt.Iter): Shared { - return new Shared(new rt.Arc(rt.iterToVec(items, undefined, 2, true).items)); +export function collected$u16_iter_Map_slice_Iter_u8_shares_generics_closure0(items: rs.Iter): Shared { + return new Shared(new rs.Arc(rs.iterToVec(items, undefined, 2, true).items)); } export function first$shares_Logged(self: Shared): Logged.Logged | undefined { - return rt.sliceFirst((self.items as rt.Arc).value); + return rs.sliceFirst((self.items as rs.Arc).value); } -export function first$u8(self: Shared): rt.u8 | undefined { - return rt.byteSliceFirst((self.items as rt.Arc).value); +export function first$u8(self: Shared): rs.u8 | undefined { + return rs.byteSliceFirst((self.items as rs.Arc).value); } /** Its items, made its own, with `item` in place of its last. */ export function setLast$shares_Logged(self: Shared, item: Logged.Logged): void { let _9: boolean = false; _9 = true; - const _3: Logged.Logged | undefined = rt.sliceLast(rt.arcMakeMut(rt.place(() => self.items as rt.Arc, (value) => (self.items as rt.Arc) = value), (a0: Logged.Logged[]): Logged.Logged[] => { + const _3: Logged.Logged | undefined = rs.sliceLast(rs.arcMakeMut(rs.place(() => self.items as rs.Arc, (value) => (self.items as rs.Arc) = value), (a0: Logged.Logged[]): Logged.Logged[] => { return a0.map(Logged.clone$Clone); }, drop$Rc_slice_shares_Logged)); if (_3 !== undefined) { @@ -58,35 +58,35 @@ export function setLast$shares_Logged(self: Shared, item: Logged. } /** Its items, made its own, with `item` in place of its last. */ -export function setLast$u16(self: Shared, item: rt.u16): void { - const _3: rt.Place | undefined = rt.sliceLastMut(rt.arcMakeMut(rt.place(() => self.items as rt.Arc, (value) => (self.items as rt.Arc) = value), (a0: rt.u16[]): rt.u16[] => { +export function setLast$u16(self: Shared, item: rs.u16): void { + const _3: rs.Place | undefined = rs.sliceLastMut(rs.arcMakeMut(rs.place(() => self.items as rs.Arc, (value) => (self.items as rs.Arc) = value), (a0: rs.u16[]): rs.u16[] => { return a0.slice(); - }, rt.drop)); + }, rs.drop)); if (_3 !== undefined) { _3.v = item; } } /** Its items, made its own, with `item` in place of its last. */ -export function setLast$u8(self: Shared, item: rt.u8): void { - const _3: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.arcMakeMut(rt.place(() => self.items as rt.Arc, (value) => (self.items as rt.Arc) = value), (a0: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a0)); - }, rt.drop))); +export function setLast$u8(self: Shared, item: rs.u8): void { + const _3: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.arcMakeMut(rs.place(() => self.items as rs.Arc, (value) => (self.items as rs.Arc) = value), (a0: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a0)); + }, rs.drop))); if (_3 !== undefined) { _3.v = item; } } export function clone$Clone_shares_Logged(self: Shared): Shared { - return new Shared(rt.arcClone(self.items as rt.Arc)); + return new Shared(rs.arcClone(self.items as rs.Arc)); } -export function clone$Clone_u16(self: Shared): Shared { - return new Shared(rt.arcClone(self.items as rt.Arc)); +export function clone$Clone_u16(self: Shared): Shared { + return new Shared(rs.arcClone(self.items as rs.Arc)); } -export function clone$Clone_u8(self: Shared): Shared { - return new Shared(rt.arcClone(self.items as rt.Arc)); +export function clone$Clone_u8(self: Shared): Shared { + return new Shared(rs.arcClone(self.items as rs.Arc)); } //# sourceMappingURL=shares.Shared.ts.map diff --git a/ts/fixtures/lang/shares/expected/shares.ts b/ts/fixtures/lang/shares/expected/shares.ts index 5668b6d3e..a40bef5f3 100644 --- a/ts/fixtures/lang/shares/expected/shares.ts +++ b/ts/fixtures/lang/shares/expected/shares.ts @@ -1,205 +1,205 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8, copy$tuple2_u8_u16, drop$Option_Rc_slice_shares_Logged, drop$Option_tuple2_Rc_slice_u16_sync_Arc_slice_u8, drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8, drop$Rc_slice_shares_Logged, drop$slice_shares_Logged } from "./lib.ts"; -import { then$1kj52rc, then$1ugtkd3 } from "./core/bool.ts"; -import { isSomeAnd$0vr0nda, isSomeAnd$0uiydx2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$03siheh as option_mapOr$03siheh, mapOr$148vfk5 as option_mapOr$148vfk5 } from "./core/option.ts"; +import { then$1m4hja7, then$1mk0ygo } from "./core/bool.ts"; +import { isSomeAnd$136asov, isSomeAnd$0jg0wcy, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, mapOr$00xrvtw as option_mapOr$00xrvtw, mapOr$1tej7ml as option_mapOr$1tej7ml } from "./core/option.ts"; import { put, text } from "./harness.ts"; import * as Held from "./shares.Held.ts"; import * as Logged from "./shares.Logged.ts"; import * as Shared from "./shares.Shared.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } -export function hash$Rc_slice_u16(value: rt.Arc): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashInts(2))(value, h); - return rt.hashFinish(h); +export function hash$Rc_slice_u16(value: rs.Arc): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashInts(2))(value, h); + return rs.hashFinish(h); } -export function hash$Rc_slice_u8(value: rt.Arc): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashBytes)(value, h); - return rt.hashFinish(h); +export function hash$Rc_slice_u8(value: rs.Arc): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashBytes)(value, h); + return rs.hashFinish(h); } -export function hash$Rc_str(value: rt.Arc): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashStr)(value, h); - return rt.hashFinish(h); +export function hash$Rc_str(value: rs.Arc): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashStr)(value, h); + return rs.hashFinish(h); } -export function hash$slice_u16(value: rt.u16[]): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashInts(2)(value, h); - return rt.hashFinish(h); +export function hash$slice_u16(value: rs.u16[]): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashInts(2)(value, h); + return rs.hashFinish(h); } -export function hash$slice_u8(value: rt.ByteSlice): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashBytes(value, h); - return rt.hashFinish(h); +export function hash$slice_u8(value: rs.ByteSlice): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashBytes(value, h); + return rs.hashFinish(h); } -export function hash$str(value: string): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashStr(value, h); - return rt.hashFinish(h); +export function hash$str(value: string): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashStr(value, h); + return rs.hashFinish(h); } -export function hash$sync_Arc_slice_u8(value: rt.Arc): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashArc(rt.hashBytes)(value, h); - return rt.hashFinish(h); +export function hash$sync_Arc_slice_u8(value: rs.Arc): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashArc(rs.hashBytes)(value, h); + return rs.hashFinish(h); } /** Puts `b`'s length and bytes. */ -export function putBytes(b: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); - rt.byteVecExtendFromSlice(out, b); +export function putBytes(b: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); + rs.byteVecExtendFromSlice(out, b); } /** Puts `b`'s length and each `u16`'s bytes. */ -export function putWides(b: rt.u16[], out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); +export function putWides(b: rs.u16[], out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); for (const _8 of b) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_8).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_8).reverse()), undefined, true); } } /** Puts the ids of `b`. */ -export function ids(b: Logged.Logged[], out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(b), (l: Logged.Logged): rt.u8 => { +export function ids(b: Logged.Logged[], out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(b), (l: Logged.Logged): rs.u8 => { return l.id; }), undefined, true); } /** Puts each pair's bytes. */ -export function pairs(b: [rt.u8, rt.u16][], out: rt.ByteVec): void { - rt.byteVecPush(out, b.length & 0xff); +export function pairs(b: [rs.u8, rs.u16][], out: rs.ByteVec): void { + rs.byteVecPush(out, b.length & 0xff); for (const _8 of b) { - rt.byteVecPush(out, _8[0]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(_8[1]).reverse()), undefined, true); + rs.byteVecPush(out, _8[0]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(_8[1]).reverse()), undefined, true); } } /** Puts an `Rc`'s strong and weak counts. */ -export function counts$slice_u16(rc: rt.Arc, out: rt.ByteVec): void { - rt.byteVecPush(out, rc.strong & 0xff); - rt.byteVecPush(out, rc.weak & 0xff); +export function counts$slice_u16(rc: rs.Arc, out: rs.ByteVec): void { + rs.byteVecPush(out, rc.strong & 0xff); + rs.byteVecPush(out, rc.weak & 0xff); } /** Puts an `Rc`'s strong and weak counts. */ -export function counts$slice_u8(rc: rt.Arc, out: rt.ByteVec): void { - rt.byteVecPush(out, rc.strong & 0xff); - rt.byteVecPush(out, rc.weak & 0xff); +export function counts$slice_u8(rc: rs.Arc, out: rs.ByteVec): void { + rs.byteVecPush(out, rc.strong & 0xff); + rs.byteVecPush(out, rc.weak & 0xff); } /** Puts an `Rc`'s strong and weak counts. */ -export function counts$str(rc: rt.Arc, out: rt.ByteVec): void { - rt.byteVecPush(out, rc.strong & 0xff); - rt.byteVecPush(out, rc.weak & 0xff); +export function counts$str(rc: rs.Arc, out: rs.ByteVec): void { + rs.byteVecPush(out, rc.strong & 0xff); + rs.byteVecPush(out, rc.weak & 0xff); } /** Puts an `Arc`'s strong and weak counts. */ -export function arcCounts$slice_u8(arc: rt.Arc, out: rt.ByteVec): void { - rt.byteVecPush(out, arc.strong & 0xff); - rt.byteVecPush(out, arc.weak & 0xff); +export function arcCounts$slice_u8(arc: rs.Arc, out: rs.ByteVec): void { + rs.byteVecPush(out, arc.strong & 0xff); + rs.byteVecPush(out, arc.weak & 0xff); } /** Writes through a `&mut` to bytes another function was handed. */ -export function scramble(b: rt.ByteSlice): void { - rt.byteSliceView(b).reverse(); - const iter: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(b)); +export function scramble(b: rs.ByteSlice): void { + rs.byteSliceView(b).reverse(); + const iter: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(b)); while (true) { - const _6: rt.Place | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: rs.Place | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } - _6.v = rt.u8WrappingAdd(_6.v, 1); + _6.v = rs.u8WrappingAdd(_6.v, 1); } - const _12: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(b)); + const _12: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(b)); if (_12 !== undefined) { _12.v = _12.v ^ 255; } } /** Bytes, each way, read, counted, and written apart from what they came from. */ -export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const _15: rt.u8 = rt.u8Rem(kind, 4); +export function bytes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const _15: rs.u8 = rs.u8Rem(kind, 4); if (_15 === 0) { - const source: rt.ByteVec = rt.byteSliceToByteVec(data2); - const fromRef: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(rt.byteVecSlice(source), 0)))); - const fromMut: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(rt.byteVecSlice(source), 0)))); - scramble(rt.byteVecSlice(source)); + const source: rs.ByteVec = rs.byteSliceToByteVec(data2); + const fromRef: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(rs.byteVecSlice(source), 0)))); + const fromMut: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(rs.byteVecSlice(source), 0)))); + scramble(rs.byteVecSlice(source)); putBytes(fromRef.value, out); putBytes(fromMut.value, out); - putBytes(rt.byteVecSlice(source), out); - const spare: rt.ByteVec = rt.byteVecWithCapacity(64); - rt.byteVecExtendFromSlice(spare, data2); - const fromVec: rt.Arc = new rt.Arc(rt.byteVecSlice(spare)); + putBytes(rs.byteVecSlice(source), out); + const spare: rs.ByteVec = rs.byteVecWithCapacity(64); + rs.byteVecExtendFromSlice(spare, data2); + const fromVec: rs.Arc = new rs.Arc(rs.byteVecSlice(spare)); putBytes(fromVec.value, out); - const into: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.byteSliceToByteVec(data2))); + const into: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteSliceToByteVec(data2))); putBytes(into.value, out); - const fromBox: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); + const fromBox: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); putBytes(fromBox.value, out); - const fromArray: rt.Arc = new rt.Arc(rt.byteSliceFrom(copy$array_u8(Uint8Array.of(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 1), 2, 3)))); + const fromArray: rs.Arc = new rs.Arc(rs.byteSliceFrom(copy$array_u8(Uint8Array.of(option_unwrapOr$1fr498u(rs.byteSliceFirst(data2), 1), 2, 3)))); putBytes(fromArray.value, out); - const collected: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u8 => { + const collected: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): rs.u8 => { return _2 ^ 85; }), undefined, true))); putBytes(collected.value, out); - const arcCollected: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.iterToByteVec(rt.iterRev(rt.iterSlice(rt.byteSliceView(data2))), undefined, true))); + const arcCollected: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data2))), undefined, true))); putBytes(arcCollected.value, out); - const empty: rt.Arc = new rt.Arc(rt.byteSliceFrom(new Uint8Array(0))); + const empty: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); putBytes(empty.value, out); - const arcEmpty: rt.Arc = new rt.Arc(rt.byteSliceFrom(new Uint8Array(0))); + const arcEmpty: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); putBytes(arcEmpty.value, out); - const borrowed: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.byteCowIntoOwned(data2))); + const borrowed: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteCowIntoOwned(data2))); putBytes(borrowed.value, out); - const owned: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.byteCowIntoOwned(rt.byteSliceToByteVec(data2)))); + const owned: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteCowIntoOwned(rs.byteSliceToByteVec(data2)))); putBytes(owned.value, out); - const s: rt.Arc = new rt.Arc(text(data2)); - const twin: rt.Arc = rt.arcClone(s); - const ofStr: rt.Arc = rt.arcStrBytes(s); + const s: rs.Arc = new rs.Arc(text(data2)); + const twin: rs.Arc = rs.arcClone(s); + const ofStr: rs.Arc = rs.arcStrBytes(s); counts$slice_u8(ofStr, out); - const ofTwin: rt.Arc = rt.arcStrBytes(twin); - rt.byteVecPush(out, ofStr === ofTwin ? 1 : 0); + const ofTwin: rs.Arc = rs.arcStrBytes(twin); + rs.byteVecPush(out, ofStr === ofTwin ? 1 : 0); counts$slice_u8(ofTwin, out); ofTwin[Symbol.dispose](); counts$slice_u8(ofStr, out); putBytes(ofStr.value, out); - const s2: rt.Arc = new rt.Arc(text(data2)); - rt.arcStrBytes(rt.arcClone(s2))[Symbol.dispose](); - const _121: rt.Place | undefined = rt.arcGetMutPlace(s2); + const s2: rs.Arc = new rs.Arc(text(data2)); + rs.arcStrBytes(rs.arcClone(s2))[Symbol.dispose](); + const _121: rs.Place | undefined = rs.arcGetMutPlace(s2); if (_121 !== undefined) { - _121.v = rt.strToAsciiUppercase(_121.v); + _121.v = rs.strToAsciiUppercase(_121.v); } - const same: rt.Arc = rt.arcClone(s2); - rt.byteVecPush(out, same === s2 ? 1 : 0); - const _137: rt.Arc = rt.arcStrBytes(s2); + const same: rs.Arc = rs.arcClone(s2); + rs.byteVecPush(out, same === s2 ? 1 : 0); + const _137: rs.Arc = rs.arcStrBytes(s2); putBytes(_137.value, out); _137[Symbol.dispose](); - const n: rt.Arc = new rt.Arc((data2.length & 0xff) as rt.u32); - const same2: rt.Arc = rt.arcClone(n); - rt.byteVecPush(out, same2 === n ? 1 : 0); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(same2.value).reverse()), undefined, true); - const arcOfStr: rt.Arc = rt.arcStrBytes(new rt.Arc(text(data2))); + const n: rs.Arc = new rs.Arc((data2.length & 0xff) as rs.u32); + const same2: rs.Arc = rs.arcClone(n); + rs.byteVecPush(out, same2 === n ? 1 : 0); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(same2.value).reverse()), undefined, true); + const arcOfStr: rs.Arc = rs.arcStrBytes(new rs.Arc(text(data2))); putBytes(arcOfStr.value, out); - const v: rt.ByteVec = rt.byteSliceToByteVec(fromVec.value); - rt.byteVecPush(v, 238); - rt.byteVecExtendFromSlice(v, collected.value); - putBytes(rt.byteVecSlice(v), out); - putBytes(rt.byteVecSlice(rt.byteSliceToByteVec(into.value)), out); - putBytes(rt.byteSliceFrom(rt.byteSliceToArray(fromBox.value)), out); + const v: rs.ByteVec = rs.byteSliceToByteVec(fromVec.value); + rs.byteVecPush(v, 238); + rs.byteVecExtendFromSlice(v, collected.value); + putBytes(rs.byteVecSlice(v), out); + putBytes(rs.byteVecSlice(rs.byteSliceToByteVec(into.value)), out); + putBytes(rs.byteSliceFrom(rs.byteSliceToArray(fromBox.value)), out); arcOfStr[Symbol.dispose](); same2[Symbol.dispose](); n[Symbol.dispose](); @@ -218,65 +218,65 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { fromMut[Symbol.dispose](); fromRef[Symbol.dispose](); } else if (_15 === 1) { - const a: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - const b2: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, 0, rt.usizeDiv(data2.length, 2))))); - rt.byteVecPush(out, rt.eqArc(rt.eqBytes, true)(a, b2) ? 1 : 0); - rt.byteVecPush(out, !rt.eqArc(rt.eqBytes, true)(a, b2) ? 1 : 0); - rt.byteVecPush(out, rt.cmpArc(rt.cmpBytes)(a, b2) === -1 ? 1 : 0); - rt.byteVecPush(out, rt.cmpArc(rt.cmpBytes)(a, b2) & 0xff); - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.cmpArc(rt.cmpBytes)(b2, a), 9, (o: rt.Ordering): rt.u8 => { + const a: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + const b2: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, 0, rs.usizeDiv(data2.length, 2))))); + rs.byteVecPush(out, rs.eqArc(rs.eqBytes, true)(a, b2) ? 1 : 0); + rs.byteVecPush(out, !rs.eqArc(rs.eqBytes, true)(a, b2) ? 1 : 0); + rs.byteVecPush(out, rs.cmpArc(rs.cmpBytes)(a, b2) === -1 ? 1 : 0); + rs.byteVecPush(out, rs.cmpArc(rs.cmpBytes)(a, b2) & 0xff); + rs.byteVecPush(out, option_mapOr$14runhi(rs.cmpArc(rs.cmpBytes)(b2, a), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); - rt.byteVecPush(out, rt.byteSliceEq(a.value, data2) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(hash$Rc_slice_u8(a), hash$slice_u8(data2)) ? 1 : 0); - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(hash$Rc_slice_u8(b2)).reverse()), undefined, true); - rt.byteVecPush(out, a.value.length & 0xff); - rt.byteVecPush(out, a.value.length === 0 ? 1 : 0); - rt.byteVecPush(out, rt.iterFold(rt.iterSlice(rt.byteSliceView(a.value)), 0, (a05: rt.u8, a1: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a05, a1); + rs.byteVecPush(out, rs.byteSliceEq(a.value, data2) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$Rc_slice_u8(a), hash$slice_u8(data2)) ? 1 : 0); + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(hash$Rc_slice_u8(b2)).reverse()), undefined, true); + rs.byteVecPush(out, a.value.length & 0xff); + rs.byteVecPush(out, a.value.length === 0 ? 1 : 0); + rs.byteVecPush(out, rs.iterFold(rs.iterSlice(rs.byteSliceView(a.value)), 0, (a05: rs.u8, a1: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a05, a1); })); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceFirst(a.value), 170)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.byteSliceGet(a.value, 1), 187)); - const arc: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - rt.byteVecPush(out, rt.byteSliceEq(arc.value, a.value) ? 1 : 0); - rt.byteVecPush(out, rt.u64Eq(hash$sync_Arc_slice_u8(arc), hash$Rc_slice_u8(a)) ? 1 : 0); - const _285: rt.Arc = new rt.Arc(rt.byteSliceFrom(new Uint8Array(0))); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rt.byteSliceView(a.value), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(b2.value), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arc.value), f, rt.u8Debug), (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(_285.value), f, rt.u8Debug)]; - const _281: string = rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceFirst(a.value), 170)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.byteSliceGet(a.value, 1), 187)); + const arc: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + rs.byteVecPush(out, rs.byteSliceEq(arc.value, a.value) ? 1 : 0); + rs.byteVecPush(out, rs.u64Eq(hash$sync_Arc_slice_u8(arc), hash$Rc_slice_u8(a)) ? 1 : 0); + const _285: rs.Arc = new rs.Arc(rs.byteSliceFrom(new Uint8Array(0))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rs.byteSliceView(a.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(b2.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arc.value), f, rs.u8Debug), (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(_285.value), f, rs.u8Debug)]; + const _281: string = rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2], "|", args2[3]]); _285[Symbol.dispose](); put(out, _281); arc[Symbol.dispose](); b2[Symbol.dispose](); a[Symbol.dispose](); } else if (_15 === 2) { - const a2: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); + const a2: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); counts$slice_u8(a2, out); - const b3: rt.Arc = rt.arcClone(a2); + const b3: rs.Arc = rs.arcClone(a2); counts$slice_u8(a2, out); - rt.byteVecPush(out, a2 === b3 ? 1 : 0); - const c: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - rt.byteVecPush(out, a2 === c ? 1 : 0); - rt.byteVecPush(out, rt.eqArc(rt.eqBytes, true)(a2, c) ? 1 : 0); - const weak: rt.Weak = new rt.Weak(a2); + rs.byteVecPush(out, a2 === b3 ? 1 : 0); + const c: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + rs.byteVecPush(out, a2 === c ? 1 : 0); + rs.byteVecPush(out, rs.eqArc(rs.eqBytes, true)(a2, c) ? 1 : 0); + const weak: rs.Weak = new rs.Weak(a2); counts$slice_u8(b3, out); a2[Symbol.dispose](); counts$slice_u8(b3, out); - rt.byteVecPush(out, isSomeAnd$0vr0nda(rt.weakUpgrade(weak), (up: rt.Arc): boolean => { + rs.byteVecPush(out, isSomeAnd$136asov(rs.weakUpgrade(weak), (up: rs.Arc): boolean => { const _05: boolean = up === b3; up[Symbol.dispose](); return _05; }) ? 1 : 0); - rt.byteVecPush(out, weak.arc.strong & 0xff); + rs.byteVecPush(out, weak.arc.strong & 0xff); b3[Symbol.dispose](); - const _342: rt.Arc | undefined = rt.weakUpgrade(weak); - rt.byteVecPush(out, _342 === undefined ? 1 : 0); - rt.drop(_342); - rt.byteVecPush(out, weak.arc.strong & 0xff); - const arc2: rt.Arc = new rt.Arc(rt.byteVecSlice(rt.byteSliceToByteVec(data2))); - const twin2: rt.Arc = rt.arcClone(arc2); + const _342: rs.Arc | undefined = rs.weakUpgrade(weak); + rs.byteVecPush(out, _342 === undefined ? 1 : 0); + rs.drop(_342); + rs.byteVecPush(out, weak.arc.strong & 0xff); + const arc2: rs.Arc = new rs.Arc(rs.byteVecSlice(rs.byteSliceToByteVec(data2))); + const twin2: rs.Arc = rs.arcClone(arc2); arcCounts$slice_u8(arc2, out); - rt.byteVecPush(out, arc2 === twin2 ? 1 : 0); - const arcWeak: rt.Weak = new rt.Weak(twin2); + rs.byteVecPush(out, arc2 === twin2 ? 1 : 0); + const arcWeak: rs.Weak = new rs.Weak(twin2); arcCounts$slice_u8(arc2, out); twin2[Symbol.dispose](); arcCounts$slice_u8(arc2, out); @@ -287,47 +287,47 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { weak[Symbol.dispose](); c[Symbol.dispose](); } else { - let a3: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - const _373: rt.ByteSlice | undefined = rt.arcGetMut(a3); + let a3: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + const _373: rs.ByteSlice | undefined = rs.arcGetMut(a3); if (_373 !== undefined) { scramble(_373); } putBytes(a3.value, out); - const b4: rt.Arc = rt.arcClone(a3); - rt.byteVecPush(out, rt.arcGetMut(a3) === undefined ? 1 : 0); - scramble(rt.arcMakeMut(rt.place(() => a3, (value) => a3 = value), (a0: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a0)); - }, rt.drop)); - rt.byteVecPush(out, a3 === b4 ? 1 : 0); + const b4: rs.Arc = rs.arcClone(a3); + rs.byteVecPush(out, rs.arcGetMut(a3) === undefined ? 1 : 0); + scramble(rs.arcMakeMut(rs.place(() => a3, (value) => a3 = value), (a0: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a0)); + }, rs.drop)); + rs.byteVecPush(out, a3 === b4 ? 1 : 0); counts$slice_u8(a3, out); counts$slice_u8(b4, out); putBytes(a3.value, out); putBytes(b4.value, out); - rt.arcClone(a3)[Symbol.dispose](); - rt.byteSliceFill(rt.arcMakeMut(rt.place(() => a3, (value2) => a3 = value2), (a02: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a02)); - }, rt.drop), 17); + rs.arcClone(a3)[Symbol.dispose](); + rs.byteSliceFill(rs.arcMakeMut(rs.place(() => a3, (value2) => a3 = value2), (a02: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a02)); + }, rs.drop), 17); counts$slice_u8(a3, out); putBytes(a3.value, out); - const weak2: rt.Weak = new rt.Weak(a3); - const _420: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.arcMakeMut(rt.place(() => a3, (value3) => a3 = value3), (a03: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a03)); - }, rt.drop))); + const weak2: rs.Weak = new rs.Weak(a3); + const _420: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.arcMakeMut(rs.place(() => a3, (value3) => a3 = value3), (a03: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a03)); + }, rs.drop))); if (_420 !== undefined) { _420.v = 34; } - const _429: rt.Arc | undefined = rt.weakUpgrade(weak2); - rt.byteVecPush(out, _429 === undefined ? 1 : 0); - rt.drop(_429); + const _429: rs.Arc | undefined = rs.weakUpgrade(weak2); + rs.byteVecPush(out, _429 === undefined ? 1 : 0); + rs.drop(_429); putBytes(a3.value, out); - let arc3: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - const shared: rt.Arc = rt.arcClone(arc3); - rt.byteSliceView(rt.arcMakeMut(rt.place(() => arc3, (value4) => arc3 = value4), (a04: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a04)); - }, rt.drop)).reverse(); - const _440: rt.ByteSlice | undefined = rt.arcGetMut(arc3); + let arc3: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + const shared: rs.Arc = rs.arcClone(arc3); + rs.byteSliceView(rs.arcMakeMut(rs.place(() => arc3, (value4) => arc3 = value4), (a04: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a04)); + }, rs.drop)).reverse(); + const _440: rs.ByteSlice | undefined = rs.arcGetMut(arc3); if (_440 !== undefined) { - rt.iterForEach(rt.iterSliceMut(rt.byteSliceView(_440)), (x: rt.Place): undefined => { + rs.iterForEach(rs.iterSliceMut(rs.byteSliceView(_440)), (x: rs.Place): undefined => { x.v = x.v ^ 15; }); } @@ -343,57 +343,57 @@ export function bytes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** `u16`s, each way, written, compared, and counted. */ -export function wides(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const wide: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))))), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); +export function wides(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const wide: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))))), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const fromRef: rt.Arc = new rt.Arc(rt.sliceRange(wide.items, 0).slice()); - const fromVec: rt.Arc = new rt.Arc(rt.vecFrom(wide.items.slice()).items); - const fromBox: rt.Arc = new rt.Arc(rt.vecFrom(wide.items.slice()).items); - const fromArray: rt.Arc = new rt.Arc([1, 2, 768]); - const collected: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.iterSlice(wide.items), (_23: rt.u16): rt.u16 => { - return rt.intRotateLeft(_23, 3, 16, false); + const fromRef: rs.Arc = new rs.Arc(rs.sliceRange(wide.items, 0).slice()); + const fromVec: rs.Arc = new rs.Arc(rs.vecFrom(wide.items.slice()).items); + const fromBox: rs.Arc = new rs.Arc(rs.vecFrom(wide.items.slice()).items); + const fromArray: rs.Arc = new rs.Arc([1, 2, 768]); + const collected: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.iterSlice(wide.items), (_23: rs.u16): rs.u16 => { + return rs.intRotateLeft(_23, 3, 16, false); }), undefined, 2, true).items); - const empty: rt.Arc = new rt.Arc([]); - const iter: rt.Iter> = rt.iterSlice([fromRef, fromBox, fromArray, collected]); + const empty: rs.Arc = new rs.Arc([]); + const iter: rs.Iter> = rs.iterSlice([fromRef, fromBox, fromArray, collected]); while (true) { - const _43: rt.Arc | rt.Done = iter.next(); - if (_43 === rt.DONE) { + const _43: rs.Arc | rs.Done = iter.next(); + if (_43 === rs.DONE) { break; } putWides(_43.value, out); } putWides(fromVec.value, out); putWides(empty.value, out); - rt.byteVecPush(out, rt.eqArc(rt.eqSlice(rt.same), true)(fromRef, fromBox) ? 1 : 0); - rt.byteVecPush(out, rt.cmpArc(rt.cmpSlice(rt.cmp))(collected, fromRef) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hash$Rc_slice_u16(collected), hash$slice_u16(rt.sliceRange(collected.value, 0))) ? 1 : 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(collected.value, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(fromVec.value, f, rt.u16Debug)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1]])); - let shared: rt.Arc = rt.arcClone(fromRef); + rs.byteVecPush(out, rs.eqArc(rs.eqSlice(rs.same), true)(fromRef, fromBox) ? 1 : 0); + rs.byteVecPush(out, rs.cmpArc(rs.cmpSlice(rs.cmp))(collected, fromRef) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hash$Rc_slice_u16(collected), hash$slice_u16(rs.sliceRange(collected.value, 0))) ? 1 : 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(collected.value, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(fromVec.value, f, rs.u16Debug)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + let shared: rs.Arc = rs.arcClone(fromRef); counts$slice_u16(fromRef, out); - if (rt.u8Rem(kind, 2) === 0) { - rt.sliceSortUnstable(rt.arcMakeMut(rt.place(() => shared, (value2) => shared = value2), (a02: rt.u16[]): rt.u16[] => { + if (rs.u8Rem(kind, 2) === 0) { + rs.sliceSortUnstable(rs.arcMakeMut(rs.place(() => shared, (value2) => shared = value2), (a02: rs.u16[]): rs.u16[] => { return a02.slice(); - }, rt.drop), rt.cmpLt((a: rt.u16, b: rt.u16): rt.Ordering => { - return rt.cmp(b, a); + }, rs.drop), rs.cmpLt((a: rs.u16, b: rs.u16): rs.Ordering => { + return rs.cmp(b, a); }), 2, true, true); } else { - const _98: rt.Place | undefined = rt.sliceLastMut(rt.arcMakeMut(rt.place(() => shared, (value) => shared = value), (a0: rt.u16[]): rt.u16[] => { + const _98: rs.Place | undefined = rs.sliceLastMut(rs.arcMakeMut(rs.place(() => shared, (value) => shared = value), (a0: rs.u16[]): rs.u16[] => { return a0.slice(); - }, rt.drop)); + }, rs.drop)); if (_98 !== undefined) { _98.v = 48879; } } counts$slice_u16(fromRef, out); - rt.byteVecPush(out, shared === fromRef ? 1 : 0); + rs.byteVecPush(out, shared === fromRef ? 1 : 0); putWides(shared.value, out); putWides(fromRef.value, out); - const alone: rt.Arc = collected; - const _117: rt.u16[] | undefined = rt.arcGetMut(alone); + const alone: rs.Arc = collected; + const _117: rs.u16[] | undefined = rs.arcGetMut(alone); if (_117 !== undefined) { - rt.iterForEach(rt.iterSliceMut(_117), (x3: rt.Place): undefined => { + rs.iterForEach(rs.iterSliceMut(_117), (x3: rs.Place): undefined => { x3.v = x3.v ^ 3855; }); } @@ -411,63 +411,63 @@ export function wides(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Values JS copies, held in a shared slice apart from what they came from, and from each * clone `make_mut` makes. */ -export function copies(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const source: rt.Vec<[rt.u8, rt.u16]> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): [rt.u8, rt.u16] => { - const b: rt.u8 = _2; - return [b, ((b as rt.u16) << 4) & 0xffff] as [rt.u8, rt.u16]; +export function copies(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const source: rs.Vec<[rs.u8, rs.u16]> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): [rs.u8, rs.u16] => { + const b: rs.u8 = _2; + return [b, ((b as rs.u16) << 4) & 0xffff] as [rs.u8, rs.u16]; }), undefined, 4, true); - const fromRef: rt.Arc<[rt.u8, rt.u16][]> = new rt.Arc(rt.sliceRange(source.items, 0).map(copy$tuple2_u8_u16)); - const fromVec: rt.Arc<[rt.u8, rt.u16][]> = new rt.Arc(rt.vecFrom(source.items.map(copy$tuple2_u8_u16)).items); - const p: [rt.u8, rt.u16] = [option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data2), 5), 6]; - const twins: rt.Arc<[rt.u8, rt.u16][]> = new rt.Arc([copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]); - const iter: rt.Iter<[rt.u8, rt.u16]> = rt.iterSlice(source.items); + const fromRef: rs.Arc<[rs.u8, rs.u16][]> = new rs.Arc(rs.sliceRange(source.items, 0).map(copy$tuple2_u8_u16)); + const fromVec: rs.Arc<[rs.u8, rs.u16][]> = new rs.Arc(rs.vecFrom(source.items.map(copy$tuple2_u8_u16)).items); + const p: [rs.u8, rs.u16] = [option_unwrapOr$1fr498u(rs.byteSliceFirst(data2), 5), 6]; + const twins: rs.Arc<[rs.u8, rs.u16][]> = new rs.Arc([copy$tuple2_u8_u16(p), copy$tuple2_u8_u16(p)]); + const iter: rs.Iter<[rs.u8, rs.u16]> = rs.iterSlice(source.items); while (true) { - const _35: [rt.u8, rt.u16] | rt.Done = iter.next(); - if (_35 === rt.DONE) { + const _35: [rs.u8, rs.u16] | rs.Done = iter.next(); + if (_35 === rs.DONE) { break; } _35[0] = _35[0] ^ 255; } - const _39: [rt.u8, rt.u16][] = rt.optionExpect(rt.arcGetMut(twins), "alone"); - rt.idx(_39, 0); + const _39: [rs.u8, rs.u16][] = rs.optionExpect(rs.arcGetMut(twins), "alone"); + rs.idx(_39, 0); _39[0][0] = _39[0][0] ^ 1; pairs(source.items, out); pairs(fromRef.value, out); pairs(fromVec.value, out); pairs(twins.value, out); - rt.byteVecPush(out, p[0]); - let shared: rt.Arc<[rt.u8, rt.u16][]> = rt.arcClone(fromRef); - const _63: [rt.u8, rt.u16] | undefined = rt.sliceFirst(rt.arcMakeMut(rt.place(() => shared, (value) => shared = value), (a0: [rt.u8, rt.u16][]): [rt.u8, rt.u16][] => { + rs.byteVecPush(out, p[0]); + let shared: rs.Arc<[rs.u8, rs.u16][]> = rs.arcClone(fromRef); + const _63: [rs.u8, rs.u16] | undefined = rs.sliceFirst(rs.arcMakeMut(rs.place(() => shared, (value) => shared = value), (a0: [rs.u8, rs.u16][]): [rs.u8, rs.u16][] => { return a0.map(copy$tuple2_u8_u16); - }, rt.drop)); + }, rs.drop)); if (_63 !== undefined) { _63[1] = 1; } pairs(shared.value, out); pairs(fromRef.value, out); - const quads: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.byteSliceChunksExact(data2, 2), (c: rt.ByteSlice): Uint8Array => { - rt.idx(c, 0); - const _3: rt.u8 = c.data[c.start]; - rt.idx(c, 1); + const quads: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.byteSliceChunksExact(data2, 2), (c: rs.ByteSlice): Uint8Array => { + rs.idx(c, 0); + const _3: rs.u8 = c.data[c.start]; + rs.idx(c, 1); return Uint8Array.of(_3, c.data[c.start + 1]); }), undefined, 2, true).items); - let copy: rt.Arc = rt.arcClone(quads); - const _79: rt.ByteSlice | undefined = rt.optionMap(rt.sliceFirst(rt.arcMakeMut(rt.place(() => copy, (value2) => copy = value2), (a02: Uint8Array[]): Uint8Array[] => { + let copy: rs.Arc = rs.arcClone(quads); + const _79: rs.ByteSlice | undefined = rs.optionMap(rs.sliceFirst(rs.arcMakeMut(rs.place(() => copy, (value2) => copy = value2), (a02: Uint8Array[]): Uint8Array[] => { return a02.map(copy$array_u8); - }, rt.drop)), rt.byteSliceFrom); + }, rs.drop)), rs.byteSliceFrom); if (_79 !== undefined) { _79.data[_79.start] = 119; } - const iter2: rt.Iter = rt.iterChain(rt.iterLend(rt.iterSlice(quads.value), rt.byteSliceFrom), rt.iterLend(rt.iterSlice(copy.value), rt.byteSliceFrom)); + const iter2: rs.Iter = rs.iterChain(rs.iterLend(rs.iterSlice(quads.value), rs.byteSliceFrom), rs.iterLend(rs.iterSlice(copy.value), rs.byteSliceFrom)); while (true) { - const _95: rt.ByteSlice | rt.Done = iter2.next(); - if (_95 === rt.DONE) { + const _95: rs.ByteSlice | rs.Done = iter2.next(); + if (_95 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, _95); + rs.byteVecExtendFromSlice(out, _95); } - rt.byteVecPush(out, rt.eqArc(rt.eqSlice(rt.eqBytes), true)(quads, copy) ? 1 : 0); + rs.byteVecPush(out, rs.eqArc(rs.eqSlice(rs.eqBytes), true)(quads, copy) ? 1 : 0); copy[Symbol.dispose](); quads[Symbol.dispose](); shared[Symbol.dispose](); @@ -480,69 +480,69 @@ export function copies(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Items that log their clones and drops: each shared slice drops its items in order as its * last owner drops, and not before, however it was made. */ -export function drops(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let kept!: rt.Arc | undefined; - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); +export function drops(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let kept!: rs.Arc | undefined; + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const shared: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): Logged.Logged => { + const shared: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): Logged.Logged => { return logged(_2 & 126); }), undefined, 8, true).items); ids(shared.value, out); flush(log.value, out); - const twin: rt.Arc = rt.arcClone(shared); - const weak: rt.Weak = new rt.Weak(twin); + const twin: rs.Arc = rs.arcClone(shared); + const weak: rs.Weak = new rs.Weak(twin); flush(log.value, out); - rt.arcDrop(shared, drop$slice_shares_Logged); + rs.arcDrop(shared, drop$slice_shares_Logged); flush(log.value, out); - const fromRef: rt.Arc = new rt.Arc(rt.sliceRange(twin.value, 0).map(Logged.clone$Clone)); + const fromRef: rs.Arc = new rs.Arc(rs.sliceRange(twin.value, 0).map(Logged.clone$Clone)); flush(log.value, out); - rt.arcDrop(twin, drop$slice_shares_Logged); + rs.arcDrop(twin, drop$slice_shares_Logged); flush(log.value, out); - const _58: rt.Arc | undefined = rt.weakUpgrade(weak); - rt.byteVecPush(out, _58 === undefined ? 1 : 0); + const _58: rs.Arc | undefined = rs.weakUpgrade(weak); + rs.byteVecPush(out, _58 === undefined ? 1 : 0); drop$Option_Rc_slice_shares_Logged(_58); weak[Symbol.dispose](); flush(log.value, out); - const collected: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_24: rt.u8): Logged.Logged => { + const collected: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_24: rs.u8): Logged.Logged => { return logged(_24 | 1); }), undefined, 8, true).items); ids(collected.value, out); - const fromBox: rt.Arc = new rt.Arc([logged(16), logged(18)]); - const fromArray: rt.Arc = new rt.Arc([logged(20)]); - const cow: rt.Arc = new rt.Arc(rt.cowIntoOwned(new rt.Borrowed(rt.sliceRange(fromRef.value, 0)), Logged.clone$Clone).items); + const fromBox: rs.Arc = new rs.Arc([logged(16), logged(18)]); + const fromArray: rs.Arc = new rs.Arc([logged(20)]); + const cow: rs.Arc = new rs.Arc(rs.cowIntoOwned(new rs.Borrowed(rs.sliceRange(fromRef.value, 0)), Logged.clone$Clone).items); flush(log.value, out); - rt.arcDrop(fromArray, drop$slice_shares_Logged); - rt.arcDrop(collected, drop$slice_shares_Logged); + rs.arcDrop(fromArray, drop$slice_shares_Logged); + rs.arcDrop(collected, drop$slice_shares_Logged); flush(log.value, out); - let mine: rt.Arc = rt.arcClone(fromBox); + let mine: rs.Arc = rs.arcClone(fromBox); const _101: Logged.Logged = logged(22); - const _104: Logged.Logged[] = rt.arcMakeMut(rt.place(() => mine, (value) => mine = value), (a0: Logged.Logged[]): Logged.Logged[] => { + const _104: Logged.Logged[] = rs.arcMakeMut(rs.place(() => mine, (value) => mine = value), (a0: Logged.Logged[]): Logged.Logged[] => { return a0.map(Logged.clone$Clone); }, drop$Rc_slice_shares_Logged); - rt.idx(_104, 0); + rs.idx(_104, 0); _104[0][Symbol.dispose](); _104[0] = _101; flush(log.value, out); ids(mine.value, out); ids(fromBox.value, out); - rt.arcDrop(fromBox, drop$slice_shares_Logged); + rs.arcDrop(fromBox, drop$slice_shares_Logged); flush(log.value, out); - const _123: Logged.Logged[] | undefined = rt.arcGetMut(mine); + const _123: Logged.Logged[] | undefined = rs.arcGetMut(mine); if (_123 !== undefined) { const _127: Logged.Logged = logged(24); - rt.idx(_123, 1); + rs.idx(_123, 1); _123[1][Symbol.dispose](); _123[1] = _127; } flush(log.value, out); const held: Held.Held = new Held.Held(mine, logged(32)); - rt.byteVecPush(out, held.items.value.length & 0xff); - rt.byteVecPush(out, held.last.id); - if (rt.u8Rem(kind, 2) === 0) { - kept = rt.arcClone(held.items); + rs.byteVecPush(out, held.items.value.length & 0xff); + rs.byteVecPush(out, held.last.id); + if (rs.u8Rem(kind, 2) === 0) { + kept = rs.arcClone(held.items); } else { kept = undefined; } @@ -550,31 +550,31 @@ export function drops(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { flush(log.value, out); drop$Option_Rc_slice_shares_Logged(kept); flush(log.value, out); - const empty: rt.Arc = new rt.Arc([]); - const _167: rt.Arc = rt.arcClone(empty); + const empty: rs.Arc = new rs.Arc([]); + const _167: rs.Arc = rs.arcClone(empty); ids(_167.value, out); - rt.arcDrop(_167, drop$slice_shares_Logged); - rt.arcDrop(cow, drop$slice_shares_Logged); - rt.arcDrop(fromRef, drop$slice_shares_Logged); + rs.arcDrop(_167, drop$slice_shares_Logged); + rs.arcDrop(cow, drop$slice_shares_Logged); + rs.arcDrop(fromRef, drop$slice_shares_Logged); flush(log.value, out); - rt.arcDrop(empty, drop$slice_shares_Logged); + rs.arcDrop(empty, drop$slice_shares_Logged); log[Symbol.dispose](); } /** `Rc` and `Arc`, each way, read, counted, and written. */ -export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const s: string = text(data); - const fromRef: rt.Arc = new rt.Arc(s); - const fromString: rt.Arc = new rt.Arc(s); - const fromBox: rt.Arc = new rt.Arc(s); + const fromRef: rs.Arc = new rs.Arc(s); + const fromString: rs.Arc = new rs.Arc(s); + const fromBox: rs.Arc = new rs.Arc(s); let source: string = s; - const fromMut: rt.Arc = new rt.Arc(source); - source = rt.strToAsciiUppercase(source); - const borrowed: rt.Arc = new rt.Arc(rt.strCowStr(new rt.Borrowed(s))); - const owned: rt.Arc = new rt.Arc(rt.strCowStr(s)); - const into: rt.Arc = new rt.Arc(s); - const empty: rt.Arc = new rt.Arc(""); - const arcEmpty: rt.Arc = new rt.Arc(""); + const fromMut: rs.Arc = new rs.Arc(source); + source = rs.strToAsciiUppercase(source); + const borrowed: rs.Arc = new rs.Arc(rs.strCowStr(new rs.Borrowed(s))); + const owned: rs.Arc = new rs.Arc(rs.strCowStr(s)); + const into: rs.Arc = new rs.Arc(s); + const empty: rs.Arc = new rs.Arc(""); + const arcEmpty: rs.Arc = new rs.Arc(""); put(out, fromRef.value); put(out, fromString.value); put(out, fromBox.value); @@ -585,44 +585,44 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { put(out, into.value); put(out, empty.value); put(out, arcEmpty.value); - rt.byteVecPush(out, rt.eqArc(rt.same, true)(fromRef, into) ? 1 : 0); - rt.byteVecPush(out, rt.cmpArc(rt.cmpStr)(fromRef, empty) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hash$Rc_str(fromRef), hash$str(s)) ? 1 : 0); - rt.byteVecPush(out, rt.stringLen(fromRef.value) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.strChars(fromRef.value)) & 0xff); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, fromRef.value), (f: rt.Formatter) => rt.fmtStr(fromString.value, f), (f: rt.Formatter) => rt.fmtStr(empty.value, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); - const twin: rt.Arc = rt.arcClone(fromRef); + rs.byteVecPush(out, rs.eqArc(rs.same, true)(fromRef, into) ? 1 : 0); + rs.byteVecPush(out, rs.cmpArc(rs.cmpStr)(fromRef, empty) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hash$Rc_str(fromRef), hash$str(s)) ? 1 : 0); + rs.byteVecPush(out, rs.stringLen(fromRef.value) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.strChars(fromRef.value)) & 0xff); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, fromRef.value), (f: rs.Formatter) => rs.fmtStr(fromString.value, f), (f: rs.Formatter) => rs.fmtStr(empty.value, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1], "|", args2[2]])); + const twin: rs.Arc = rs.arcClone(fromRef); counts$str(twin, out); - rt.byteVecPush(out, twin === fromRef ? 1 : 0); - rt.byteVecPush(out, into === fromRef ? 1 : 0); - const mine: rt.Arc = into; - if (rt.u8Rem(kind, 2) === 0) { - const _130: rt.Place | undefined = rt.arcGetMutPlace(mine); + rs.byteVecPush(out, twin === fromRef ? 1 : 0); + rs.byteVecPush(out, into === fromRef ? 1 : 0); + const mine: rs.Arc = into; + if (rs.u8Rem(kind, 2) === 0) { + const _130: rs.Place | undefined = rs.arcGetMutPlace(mine); if (_130 !== undefined) { - _130.v = rt.strToAsciiUppercase(_130.v); + _130.v = rs.strToAsciiUppercase(_130.v); } } else { - let _137: rt.Arc = rt.arcClone(twin); - const _135: rt.Place = rt.arcMakeMutPlace(rt.place(() => _137, (value2) => _137 = value2), undefined, rt.drop); - _135.v = rt.strToAsciiLowercase(_135.v); + let _137: rs.Arc = rs.arcClone(twin); + const _135: rs.Place = rs.arcMakeMutPlace(rs.place(() => _137, (value2) => _137 = value2), undefined, rs.drop); + _135.v = rs.strToAsciiLowercase(_135.v); _137[Symbol.dispose](); } - let shared: rt.Arc = twin; - const _141: rt.Place = rt.arcMakeMutPlace(rt.place(() => shared, (value3) => shared = value3), undefined, rt.drop); - _141.v = rt.strToAsciiUppercase(_141.v); + let shared: rs.Arc = twin; + const _141: rs.Place = rs.arcMakeMutPlace(rs.place(() => shared, (value3) => shared = value3), undefined, rs.drop); + _141.v = rs.strToAsciiUppercase(_141.v); counts$str(shared, out); counts$str(fromRef, out); put(out, mine.value); put(out, shared.value); put(out, fromRef.value); - let arc: rt.Arc = rt.arcClone(fromString); - const _159: rt.Place = rt.arcMakeMutPlace(rt.place(() => arc, (value4) => arc = value4), undefined, rt.drop); - _159.v = rt.strToAsciiUppercase(_159.v); + let arc: rs.Arc = rs.arcClone(fromString); + const _159: rs.Place = rs.arcMakeMutPlace(rs.place(() => arc, (value4) => arc = value4), undefined, rs.drop); + _159.v = rs.strToAsciiUppercase(_159.v); put(out, arc.value); put(out, fromString.value); put(out, arc.value); - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtPad(f, fromBox.value))); + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtPad(f, fromBox.value))); arc[Symbol.dispose](); shared[Symbol.dispose](); mine[Symbol.dispose](); @@ -637,28 +637,28 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** A generic type's shared slice, of bytes, of `u16`s, and of items that log. */ -export function generics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const bytes: Shared.Shared = Shared.new$u8(rt.byteSliceToByteVec(data2)); - const copy: Shared.Shared = Shared.clone$Clone_u8(bytes); +export function generics(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const bytes: Shared.Shared = Shared.new$u8(rs.byteSliceToByteVec(data2)); + const copy: Shared.Shared = Shared.clone$Clone_u8(bytes); Shared.setLast$u8(bytes, 238); - putBytes((bytes.items as rt.Arc).value, out); - putBytes((copy.items as rt.Arc).value, out); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(Shared.first$u8(bytes), 170)); - counts$slice_u8(copy.items as rt.Arc, out); - const wide: Shared.Shared = Shared.collected$u16_iter_Map_slice_Iter_u8_shares_generics_closure0(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { - return ((_2 as rt.u16) << 8) & 0xffff; + putBytes((bytes.items as rs.Arc).value, out); + putBytes((copy.items as rs.Arc).value, out); + rs.byteVecPush(out, option_unwrapOr$1fr498u(Shared.first$u8(bytes), 170)); + counts$slice_u8(copy.items as rs.Arc, out); + const wide: Shared.Shared = Shared.collected$u16_iter_Map_slice_Iter_u8_shares_generics_closure0(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): rs.u16 => { + return ((_2 as rs.u16) << 8) & 0xffff; })); - const twin: Shared.Shared = Shared.clone$Clone_u16(wide); - counts$slice_u16(wide.items as rt.Arc, out); + const twin: Shared.Shared = Shared.clone$Clone_u16(wide); + counts$slice_u16(wide.items as rs.Arc, out); Shared.setLast$u16(wide, 48879); - putWides((wide.items as rt.Arc).value, out); - putWides((twin.items as rt.Arc).value, out); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8) => Logged.Logged = (id: rt.u8): Logged.Logged => { - return new Logged.Logged(id, rt.arcClone(log)); + putWides((wide.items as rs.Arc).value, out); + putWides((twin.items as rs.Arc).value, out); + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8) => Logged.Logged = (id: rs.u8): Logged.Logged => { + return new Logged.Logged(id, rs.arcClone(log)); }; - const items: Shared.Shared = Shared.new$shares_Logged(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_23: rt.u8): Logged.Logged => { + const items: Shared.Shared = Shared.new$shares_Logged(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_23: rs.u8): Logged.Logged => { return logged(_23 & 126); }), undefined, 8, true)); const kept: Shared.Shared = Shared.clone$Clone_shares_Logged(items); @@ -666,8 +666,8 @@ export function generics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _67: Logged.Logged = logged(64); Shared.setLast$shares_Logged(items, _67); flush(log.value, out); - ids((items.items as rt.Arc).value, out); - rt.byteVecPush(out, option_mapOr$148vfk5(Shared.first$shares_Logged(items), 170, (l: Logged.Logged): rt.u8 => { + ids((items.items as rs.Arc).value, out); + rs.byteVecPush(out, option_mapOr$1tej7ml(Shared.first$shares_Logged(items), 170, (l: Logged.Logged): rs.u8 => { return l.id; })); kept[Symbol.dispose](); @@ -685,118 +685,118 @@ export function generics(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * Shared slices and text as keys a borrow of their slice or text looks up, and through * `AsRef`, `Borrow`, and `FromIterator::from_iter`. */ -export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeRem(kind >> 3 as rt.usize, rt.usizeAdd(data.length, 1))); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data2, 2), text), undefined, 12, true); - const _19: rt.Iter> = rt.iterMap(rt.iterSlice(words.items), (w: string): rt.Arc => { - return new rt.Arc(w); +export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeRem(kind >> 3 as rs.usize, rs.usizeAdd(data.length, 1))); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data2, 2), text), undefined, 12, true); + const _19: rs.Iter> = rs.iterMap(rs.iterSlice(words.items), (w: string): rs.Arc => { + return new rs.Arc(w); }); - const interned: rt.HashSet> = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashArc(rt.hashStr), rt.eqArc(rt.same, true))) as rt.HashSet>, _19, rt.drop, undefined, 117440512); - rt.byteVecPush(out, rt.hashLen(interned) & 0xff); + const interned: rs.HashSet> = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashArc(rs.hashStr), rs.eqArc(rs.same, true))) as rs.HashSet>, _19, rs.drop, undefined, 117440512); + rs.byteVecPush(out, rs.hashLen(interned) & 0xff); for (const _30 of words.items) { - rt.byteVecPush(out, rt.hashContains(interned, new rt.Arc(_30)) ? 1 : 0); - rt.byteVecPush(out, option_mapOr$03siheh(rt.hashKey(interned, new rt.Arc(_30)), 0, (k: rt.Arc): rt.u8 => { + rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc(_30)) ? 1 : 0); + rs.byteVecPush(out, option_mapOr$00xrvtw(rs.hashKey(interned, new rs.Arc(_30)), 0, (k: rs.Arc): rs.u8 => { return k.strong & 0xff; })); } - rt.byteVecPush(out, rt.hashContains(interned, new rt.Arc("\u0000")) ? 1 : 0); - const counted: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashArc(rt.hashBytes), rt.eqArc(rt.eqBytes, true))) as rt.HashMap, rt.u8>; - const iter2: rt.Iter = rt.byteSliceChunks(data2, 3); + rs.byteVecPush(out, rs.hashContains(interned, new rs.Arc("\u0000")) ? 1 : 0); + const counted: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashArc(rs.hashBytes), rs.eqArc(rs.eqBytes, true))) as rs.HashMap, rs.u8>; + const iter2: rs.Iter = rs.byteSliceChunks(data2, 3); while (true) { - const _53: rt.ByteSlice | rt.Done = iter2.next(); - if (_53 === rt.DONE) { + const _53: rs.ByteSlice | rs.Done = iter2.next(); + if (_53 === rs.DONE) { break; } - const _60: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(_53))); - const _57: rt.Place = rt.entryOrInsertWithMut(rt.entry(counted, _60, rt.drop), (): rt.u8 => { + const _60: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(_53))); + const _57: rs.Place = rs.entryOrInsertWithMut(rs.entry(counted, _60, rs.drop), (): rs.u8 => { return 0; }); - _57.v = rt.u8Add(_57.v, 1); + _57.v = rs.u8Add(_57.v, 1); } - const iter3: rt.Iter = rt.byteSliceChunks(data2, 3); + const iter3: rs.Iter = rs.byteSliceChunks(data2, 3); while (true) { - const _65: rt.ByteSlice | rt.Done = iter3.next(); - if (_65 === rt.DONE) { + const _65: rs.ByteSlice | rs.Done = iter3.next(); + if (_65 === rs.DONE) { break; } - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(counted, new rt.Arc(_65)), 0)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(counted, new rs.Arc(_65)), 0)); } - const fromIter: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data2)), (_2: rt.u8): rt.u16 => { - return rt.u16Add(_2 as rt.u16, 1); + const fromIter: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data2)), (_2: rs.u8): rs.u16 => { + return rs.u16Add(_2 as rs.u16, 1); }), undefined, 2, true).items); putWides(fromIter.value, out); putWides(fromIter.value, out); - const text_: rt.Arc = new rt.Arc(rt.strsJoin(words.items, "")); + const text_: rs.Arc = new rs.Arc(rs.strsJoin(words.items, "")); put(out, text_.value); put(out, text_.value); - let slot: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data2))); - const other: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(rt.byteSliceRange(data2, 0, rt.usizeDiv(data2.length, 2))))); + let slot: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data2))); + const other: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(rs.byteSliceRange(data2, 0, rs.usizeDiv(data2.length, 2))))); const old = slot; - slot = rt.arcClone(other); + slot = rs.arcClone(other); old[Symbol.dispose](); - rt.byteVecPush(out, slot === other ? 1 : 0); + rs.byteVecPush(out, slot === other ? 1 : 0); counts$slice_u8(other, out); other[Symbol.dispose](); slot[Symbol.dispose](); text_[Symbol.dispose](); fromIter[Symbol.dispose](); - rt.hashDrop(counted, rt.drop); - rt.hashDrop(interned, rt.drop); + rs.hashDrop(counted, rs.drop); + rs.hashDrop(interned, rs.drop); } /** * What `as_ptr` points at in an `Rc<[u16]>` and an `Arc<[u8]>`, by `kind` alone, shared by * another handle, or by a `Weak` alone, read after `make_mut` writes it. */ -export function addresses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function addresses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _48!: boolean; let _52: boolean = false; - let wide: rt.Arc = new rt.Arc(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return ((_2 as rt.u16) << 4) & 0xffff; + let wide: rs.Arc = new rs.Arc(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return ((_2 as rs.u16) << 4) & 0xffff; }), undefined, 2, true).items); - let bytes: rt.Arc = new rt.Arc(rt.byteSliceFrom(rt.byteSliceToArray(data))); - const other: [rt.Arc, rt.Arc] | undefined = then$1kj52rc(rt.u8Rem(kind, 3) === 1, (): [rt.Arc, rt.Arc] => { - return [rt.arcClone(wide), rt.arcClone(bytes)] as [rt.Arc, rt.Arc]; + let bytes: rs.Arc = new rs.Arc(rs.byteSliceFrom(rs.byteSliceToArray(data))); + const other: [rs.Arc, rs.Arc] | undefined = then$1m4hja7(rs.u8Rem(kind, 3) === 1, (): [rs.Arc, rs.Arc] => { + return [rs.arcClone(wide), rs.arcClone(bytes)] as [rs.Arc, rs.Arc]; }); - const weak: [rt.Weak, rt.Weak] | undefined = then$1ugtkd3(rt.u8Rem(kind, 3) === 2, (): [rt.Weak, rt.Weak] => { - return [new rt.Weak(wide), new rt.Weak(bytes)] as [rt.Weak, rt.Weak]; + const weak: [rs.Weak, rs.Weak] | undefined = then$1mk0ygo(rs.u8Rem(kind, 3) === 2, (): [rs.Weak, rs.Weak] => { + return [new rs.Weak(wide), new rs.Weak(bytes)] as [rs.Weak, rs.Weak]; }); _52 = true; - const _22: rt.Place | undefined = rt.sliceFirstMut(rt.arcMakeMut(rt.place(() => wide, (value) => wide = value), (a0: rt.u16[]): rt.u16[] => { + const _22: rs.Place | undefined = rs.sliceFirstMut(rs.arcMakeMut(rs.place(() => wide, (value) => wide = value), (a0: rs.u16[]): rs.u16[] => { return a0.slice(); - }, rt.drop)); + }, rs.drop)); if (_22 !== undefined) { - _22.v = _22.v ^ kind as rt.u16; + _22.v = _22.v ^ kind as rs.u16; } - const _28: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.arcMakeMut(rt.place(() => bytes, (value2) => bytes = value2), (a02: rt.ByteSlice): rt.ByteSlice => { - return rt.byteSliceFrom(rt.byteSliceToArray(a02)); - }, rt.drop))); + const _28: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.arcMakeMut(rs.place(() => bytes, (value2) => bytes = value2), (a02: rs.ByteSlice): rs.ByteSlice => { + return rs.byteSliceFrom(rs.byteSliceToArray(a02)); + }, rs.drop))); if (_28 !== undefined) { _28.v = _28.v ^ kind; } - const _37: rt.RawSlice = rt.rawSliceOf(wide.value); - const _40: rt.RawSlice = rt.rawByteSliceOf(bytes.value); + const _37: rs.RawSlice = rs.rawSliceOf(wide.value); + const _40: rs.RawSlice = rs.rawByteSliceOf(bytes.value); const part = _37.deref(); const part2 = _40.derefBytes(false); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(part), (w: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(w).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(part), (w: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(w).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); putBytes(part2, out); if (!(other !== undefined)) { _52 = false; - _48 = isSomeAnd$0uiydx2(weak, (_26: [rt.Weak, rt.Weak]): boolean => { + _48 = isSomeAnd$0jg0wcy(weak, (_26: [rs.Weak, rs.Weak]): boolean => { let _07!: boolean; - const a: rt.Weak = _26[0]; - const b2: rt.Weak = _26[1]; - const _7: rt.Arc | undefined = rt.weakUpgrade(a); + const a: rs.Weak = _26[0]; + const b2: rs.Weak = _26[1]; + const _7: rs.Arc | undefined = rs.weakUpgrade(a); if (!(_7 === undefined)) { - rt.drop(_7); + rs.drop(_7); _07 = false; } else { - rt.drop(_7); - const _102: rt.Arc | undefined = rt.weakUpgrade(b2); + rs.drop(_7); + const _102: rs.Arc | undefined = rs.weakUpgrade(b2); _07 = _102 === undefined; - rt.drop(_102); + rs.drop(_102); } b2[Symbol.dispose](); a[Symbol.dispose](); @@ -805,7 +805,7 @@ export function addresses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } else { _48 = true; } - rt.byteVecPush(out, _48 ? 1 : 0); + rs.byteVecPush(out, _48 ? 1 : 0); if (_52) { drop$Option_tuple2_rc_Weak_slice_u16_sync_Weak_slice_u8(weak); } diff --git a/ts/fixtures/lang/singles/expected/core/option.ts b/ts/fixtures/lang/singles/expected/core/option.ts index 0928bfcd9..18a3c8010 100644 --- a/ts/fixtures/lang/singles/expected/core/option.ts +++ b/ts/fixtures/lang/singles/expected/core/option.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$19h8ynp(self: rt.f32 | undefined, default_: rt.f32): rt.f32 { +export function unwrapOr$15mrooo(self: rs.f32 | undefined, default_: rs.f32): rs.f32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$15zxk73(self: rt.u8 | undefined, default_: rt.u64, f: (a0: rt.u8) => rt.u64): rt.u64 { +export function mapOr$1imzf9s(self: rs.u8 | undefined, default_: rs.u64, f: (a0: rs.u8) => rs.u64): rs.u64 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/singles/expected/harness.ts b/ts/fixtures/lang/singles/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/singles/expected/harness.ts +++ b/ts/fixtures/lang/singles/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/singles/expected/lib.ts b/ts/fixtures/lang/singles/expected/lib.ts index 22670c516..56074ba4b 100644 --- a/ts/fixtures/lang/singles/expected/lib.ts +++ b/ts/fixtures/lang/singles/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { singles, mulAdds, formats, parses } from "./singles.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["singles::singles", singles as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::formats", formats as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::parses", parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["singles::mul_adds", mulAdds as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["singles::singles", singles as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["singles::formats", formats as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["singles::parses", parses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["singles::mul_adds", mulAdds as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/singles/expected/singles.Gauge.ts b/ts/fixtures/lang/singles/expected/singles.Gauge.ts index cdaa576fb..ed0503cda 100644 --- a/ts/fixtures/lang/singles/expected/singles.Gauge.ts +++ b/ts/fixtures/lang/singles/expected/singles.Gauge.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Gauge, other: Gauge): boolean { if (!(self.level === other.level)) { @@ -15,8 +15,8 @@ export function default$Default(): Gauge { /** A struct with an `f32` field, changed in place through a `&mut`. */ export interface Gauge { - level: rt.f32; - peak: rt.f32 | undefined; + level: rs.f32; + peak: rs.f32 | undefined; } //# sourceMappingURL=singles.Gauge.ts.map diff --git a/ts/fixtures/lang/singles/expected/singles.Reading.ts b/ts/fixtures/lang/singles/expected/singles.Reading.ts index 9a34e898c..50a207cdf 100644 --- a/ts/fixtures/lang/singles/expected/singles.Reading.ts +++ b/ts/fixtures/lang/singles/expected/singles.Reading.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(self: Reading, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Reading, f: rs.Formatter): rs.Result { const _3: string = "Reading"; const _4: string = "level"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.f32Debug(self.level, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.f32Debug(self.level, f); const _7: string = "history"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.history.items, f, rt.f32Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.history.items, f, rs.f32Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** A reading whose derived `Debug` writes each `f32` with the placeholder's options. */ export interface Reading { - level: rt.f32; - history: rt.Vec; + level: rs.f32; + history: rs.Vec; } //# sourceMappingURL=singles.Reading.ts.map diff --git a/ts/fixtures/lang/singles/expected/singles.ts b/ts/fixtures/lang/singles/expected/singles.ts index f11435970..c8bcdb6ad 100644 --- a/ts/fixtures/lang/singles/expected/singles.ts +++ b/ts/fixtures/lang/singles/expected/singles.ts @@ -1,81 +1,81 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$19h8ynp as option_unwrapOr$19h8ynp, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0, mapOr$15zxk73 as option_mapOr$15zxk73 } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$15mrooo as option_unwrapOr$15mrooo, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi, mapOr$1imzf9s as option_mapOr$1imzf9s } from "./core/option.ts"; import { put } from "./harness.ts"; import * as Gauge from "./singles.Gauge.ts"; import * as Reading from "./singles.Reading.ts"; /** The bits of an `f32` from the front of `data`, big-endian and zero-padded. */ -export function takeBits(data: rt.ByteSlice): [rt.u32, rt.ByteSlice] { - const buf: Uint8Array = rt.bytes(4); - const n: rt.usize = rt.min(data.length, rt.byteSliceFrom(buf).length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(buf), 0, n), rt.byteSliceRange(data, 0, n)); - return [rt.u32FromBeBytes(buf), rt.byteSliceRange(data, n)] as [rt.u32, rt.ByteSlice]; +export function takeBits(data: rs.ByteSlice): [rs.u32, rs.ByteSlice] { + const buf: Uint8Array = rs.bytes(4); + const n: rs.usize = rs.min(data.length, rs.byteSliceFrom(buf).length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(buf), 0, n), rs.byteSliceRange(data, 0, n)); + return [rs.u32FromBeBytes(buf), rs.byteSliceRange(data, n)] as [rs.u32, rs.ByteSlice]; } /** An `f32` from the front of `data`. */ -export function take(data: rt.ByteSlice): [rt.f32, rt.ByteSlice] { - const _4: [rt.u32, rt.ByteSlice] = takeBits(data); - return [rt.f32FromBits(_4[0]), _4[1]] as [rt.f32, rt.ByteSlice]; +export function take(data: rs.ByteSlice): [rs.f32, rs.ByteSlice] { + const _4: [rs.u32, rs.ByteSlice] = takeBits(data); + return [rs.f32FromBits(_4[0]), _4[1]] as [rs.f32, rs.ByteSlice]; } /** `x`'s bits, any NaN as `f32::NAN`'s. */ -export function putF32(out: rt.ByteVec, x: rt.f32): void { - let x2!: rt.f32; +export function putF32(out: rs.ByteVec, x: rs.f32): void { + let x2!: rs.f32; if (!Number.isNaN(x)) { x2 = x; } else { x2 = NaN; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(x2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(x2)))); } /** `x`'s bits, any NaN as `f64::NAN`'s. */ -export function putF64(out: rt.ByteVec, x: rt.f64): void { - let x2!: rt.f64; +export function putF64(out: rs.ByteVec, x: rs.f64): void { + let x2!: rs.f64; if (!Number.isNaN(x)) { x2 = x; } else { x2 = NaN; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.f64ToBits(x2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.f64ToBits(x2)))); } -export function putDuration(out: rt.ByteVec, d: rt.Duration): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.durationAsSecs(d)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.durationSubsecNanos(d)))); +export function putDuration(out: rs.ByteVec, d: rs.Duration): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.durationAsSecs(d)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.durationSubsecNanos(d)))); } /** What `try_from_secs_f32` made, or its error printed. */ -export function putSecs(out: rt.ByteVec, d: rt.Result): void { +export function putSecs(out: rs.ByteVec, d: rs.Result): void { if (d.ok) { putDuration(out, d.value); } else { - const e: rt.TryFromFloatSecsError = d.error; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtTryFromFloatSecsErrorDebug(e, f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1]])); + const e: rs.TryFromFloatSecsError = d.error; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtTryFromFloatSecsErrorDebug(e, f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]])); } } -export function raise(level: rt.Place, by: rt.f32): void { +export function raise(level: rs.Place, by: rs.f32): void { level.v = Math.fround(level.v + by); level.v = Math.fround(level.v * 2.0); } -export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function singles(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let zeros!: boolean; - let _300!: rt.f32; - const _6: [rt.f32, rt.ByteSlice] = take(data); - const a: rt.f32 = _6[0]; - const _9: [rt.f32, rt.ByteSlice] = take(_6[1]); - const b: rt.f32 = _9[0]; - const _10: rt.u8 = rt.u8Rem(kind, 10); + let _300!: rs.f32; + const _6: [rs.f32, rs.ByteSlice] = take(data); + const a: rs.f32 = _6[0]; + const _9: [rs.f32, rs.ByteSlice] = take(_6[1]); + const b: rs.f32 = _9[0]; + const _10: rs.u8 = rs.u8Rem(kind, 10); if (_10 === 0) { - const iter: rt.Iter = rt.iterSlice([Math.fround(a + b), Math.fround(a - b), Math.fround(a * b), Math.fround(a / b), a % b, -a, Math.fround(a + 1.5), Math.fround(0.10000000149011612 * a), Math.fround(Math.fround(a * b) + a), Math.fround(Math.fround(a - b) / Math.fround(a + b))]); + const iter: rs.Iter = rs.iterSlice([Math.fround(a + b), Math.fround(a - b), Math.fround(a * b), Math.fround(a / b), a % b, -a, Math.fround(a + 1.5), Math.fround(0.10000000149011612 * a), Math.fround(Math.fround(a * b) + a), Math.fround(Math.fround(a - b) / Math.fround(a + b))]); while (true) { - const _28: rt.f32 | rt.Done = iter.next(); - if (_28 === rt.DONE) { + const _28: rs.f32 | rs.Done = iter.next(); + if (_28 === rs.DONE) { break; } putF32(out, _28); @@ -87,94 +87,94 @@ export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void const _39: boolean = a > b; const _40: boolean = a >= b; const _41: boolean = a === 0.0; - const _42: boolean = rt.f32PartialCmp(a, b) === -1; - const order = rt.f32PartialCmp(a, b); - const iter2: rt.Iter = rt.iterSlice([_35, _36, _37, _38, _39, _40, _41, _42, order !== undefined && order >= 0]); + const _42: boolean = rs.f32PartialCmp(a, b) === -1; + const order = rs.f32PartialCmp(a, b); + const iter2: rs.Iter = rs.iterSlice([_35, _36, _37, _38, _39, _40, _41, _42, order !== undefined && order >= 0]); while (true) { - const _50: boolean | rt.Done = iter2.next(); - if (_50 === rt.DONE) { + const _50: boolean | rs.Done = iter2.next(); + if (_50 === rs.DONE) { break; } - rt.byteVecPush(out, _50 ? 1 : 0); + rs.byteVecPush(out, _50 ? 1 : 0); } - let c: rt.f32 = a; + let c: rs.f32 = a; c = Math.fround(c + b); c = Math.fround(c - 0.25); c = Math.fround(c * b); c = Math.fround(c / 3.0); c = c % a; putF32(out, c); - const _61: [rt.f64, rt.f64] = [a as rt.f64, b as rt.f64]; - const wa: rt.f64 = _61[0]; - const wb: rt.f64 = _61[1]; - const iter3: rt.Iter = rt.iterSlice([wa, wa * wb, wa / wb, wa + 1e-30]); + const _61: [rs.f64, rs.f64] = [a as rs.f64, b as rs.f64]; + const wa: rs.f64 = _61[0]; + const wb: rs.f64 = _61[1]; + const iter3: rs.Iter = rs.iterSlice([wa, wa * wb, wa / wb, wa + 1e-30]); while (true) { - const _70: rt.f64 | rt.Done = iter3.next(); - if (_70 === rt.DONE) { + const _70: rs.f64 | rs.Done = iter3.next(); + if (_70 === rs.DONE) { break; } putF64(out, _70); } - const iter4: rt.Iter = rt.iterSlice([Math.fround(wa * wb), Math.fround(wa / wb), Math.fround(wa + 1e-30), Math.fround(wa + wb)]); + const iter4: rs.Iter = rs.iterSlice([Math.fround(wa * wb), Math.fround(wa / wb), Math.fround(wa + 1e-30), Math.fround(wa + wb)]); while (true) { - const _86: rt.f32 | rt.Done = iter4.next(); - if (_86 === rt.DONE) { + const _86: rs.f32 | rs.Done = iter4.next(); + if (_86 === rs.DONE) { break; } putF32(out, _86); } } else if (_10 === 1) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u8ToBeBytes(rt.u8FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(rt.u16FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(rt.u128FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.usizeToBeBytes(rt.usizeFromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i8ToBeBytes(rt.i8FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(rt.i16FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i32ToBeBytes(rt.i32FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i64ToBeBytes(rt.i64FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128FromF64(a as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.isizeToBeBytes(rt.isizeFromF64(a as rt.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u8ToBeBytes(rs.u8FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(rs.u16FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(rs.u128FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.usizeToBeBytes(rs.usizeFromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i8ToBeBytes(rs.i8FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(rs.i16FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i32ToBeBytes(rs.i32FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i64ToBeBytes(rs.i64FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128FromF64(a as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.isizeToBeBytes(rs.isizeFromF64(a as rs.f64)))); } else if (_10 === 2) { - const wide: Uint8Array = rt.bytes(16); - const n: rt.usize = rt.min(data.length, 16); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(rt.byteSliceFrom(wide), 0, n), rt.byteSliceRange(data, 0, n)); - const v: rt.u128 = rt.u128FromBeBytes(wide); - const w: rt.f64 = rt.f64FromBits(rt.u64Cast(v)); - const iter5: rt.Iter = rt.iterSlice([Math.fround(rt.u128Low(v) & 0xff), Math.fround(rt.u128Low(v) & 0xffff), Math.fround(rt.u128Low(v)), rt.u64ToF32(rt.u64Cast(v)), rt.u128ToF32(v), Math.fround(rt.u128Low(v)), Math.fround((rt.u128Low(v) << 24) >> 24), Math.fround((rt.u128Low(v) << 16) >> 16), Math.fround(rt.u128Low(v) | 0), rt.i64ToF32(rt.i64Cast(v)), rt.i128ToF32(rt.i128Cast(v)), Math.fround(rt.u128Low(v) | 0), rt.u64ToF32(rt.u64Cast(rt.u128Shr(v, 64))), rt.i64ToF32(rt.i64Cast(rt.u128Shr(v, 64))), Math.fround(rt.u128Low(v) & 0xffff), Math.fround((rt.u128Low(v) << 16) >> 16), rt.u128And(v, 1) === 1 ? 1.0 : 0.0, Math.fround(rt.u128Low(v) & 0xff), Math.fround(w), 1.8446744073709552e19, -9.223372036854776e18, Infinity, 2147483648.0]); + const wide: Uint8Array = rs.bytes(16); + const n: rs.usize = rs.min(data.length, 16); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(rs.byteSliceFrom(wide), 0, n), rs.byteSliceRange(data, 0, n)); + const v: rs.u128 = rs.u128FromBeBytes(wide); + const w: rs.f64 = rs.f64FromBits(rs.u64Cast(v)); + const iter5: rs.Iter = rs.iterSlice([Math.fround(rs.u128Low(v) & 0xff), Math.fround(rs.u128Low(v) & 0xffff), Math.fround(rs.u128Low(v)), rs.u64ToF32(rs.u64Cast(v)), rs.u128ToF32(v), Math.fround(rs.u128Low(v)), Math.fround((rs.u128Low(v) << 24) >> 24), Math.fround((rs.u128Low(v) << 16) >> 16), Math.fround(rs.u128Low(v) | 0), rs.i64ToF32(rs.i64Cast(v)), rs.i128ToF32(rs.i128Cast(v)), Math.fround(rs.u128Low(v) | 0), rs.u64ToF32(rs.u64Cast(rs.u128Shr(v, 64))), rs.i64ToF32(rs.i64Cast(rs.u128Shr(v, 64))), Math.fround(rs.u128Low(v) & 0xffff), Math.fround((rs.u128Low(v) << 16) >> 16), rs.u128And(v, 1) === 1 ? 1.0 : 0.0, Math.fround(rs.u128Low(v) & 0xff), Math.fround(w), 1.8446744073709552e19, -9.223372036854776e18, Infinity, 2147483648.0]); while (true) { - const _214: rt.f32 | rt.Done = iter5.next(); - if (_214 === rt.DONE) { + const _214: rs.f32 | rs.Done = iter5.next(); + if (_214 === rs.DONE) { break; } putF32(out, _214); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.u64FromF64(rt.u64ToF32(rt.u64Cast(v)) as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i128ToBeBytes(rt.i128FromF64(rt.i128ToF32(rt.i128Cast(v)) as rt.f64)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32FromF64(Math.fround(rt.u128Low(v)) as rt.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.u64FromF64(rs.u64ToF32(rs.u64Cast(v)) as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i128ToBeBytes(rs.i128FromF64(rs.i128ToF32(rs.i128Cast(v)) as rs.f64)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32FromF64(Math.fround(rs.u128Low(v)) as rs.f64)))); } else if (_10 === 3) { - const iter6: rt.Iter = rt.iterSlice([Math.floor(a), Math.ceil(a), Math.trunc(a), rt.f32Round(a), rt.f32RoundTiesEven(a), rt.f32Fract(a), Math.abs(a), rt.f32Signum(a), Math.fround(Math.sqrt(a)), Math.fround(1 / a), Math.fround(a * 57.295780181884766), Math.fround(a * 0.01745329238474369)]); + const iter6: rs.Iter = rs.iterSlice([Math.floor(a), Math.ceil(a), Math.trunc(a), rs.f32Round(a), rs.f32RoundTiesEven(a), rs.f32Fract(a), Math.abs(a), rs.f32Signum(a), Math.fround(Math.sqrt(a)), Math.fround(1 / a), Math.fround(a * 57.295780181884766), Math.fround(a * 0.01745329238474369)]); while (true) { - const _255: rt.f32 | rt.Done = iter6.next(); - if (_255 === rt.DONE) { + const _255: rs.f32 | rs.Done = iter6.next(); + if (_255 === rs.DONE) { break; } putF32(out, _255); } } else if (_10 === 4) { - const iter7: rt.Iter = rt.iterSlice([Number.isNaN(a), Number.isFinite(a), rt.f32IsInfinite(a), rt.f32IsNormal(a), rt.f32IsSubnormal(a), rt.f32IsSignPositive(a), rt.f32IsSignNegative(a)]); + const iter7: rs.Iter = rs.iterSlice([Number.isNaN(a), Number.isFinite(a), rs.f32IsInfinite(a), rs.f32IsNormal(a), rs.f32IsSubnormal(a), rs.f32IsSignPositive(a), rs.f32IsSignNegative(a)]); while (true) { - const _270: boolean | rt.Done = iter7.next(); - if (_270 === rt.DONE) { + const _270: boolean | rs.Done = iter7.next(); + if (_270 === rs.DONE) { break; } - rt.byteVecPush(out, _270 ? 1 : 0); + rs.byteVecPush(out, _270 ? 1 : 0); } - const iter8: rt.Iter = rt.iterSlice([rt.f32Copysign(a, b), rt.f32Copysign(1.5, a), rt.f32NextUp(a), rt.f32NextDown(a)]); + const iter8: rs.Iter = rs.iterSlice([rs.f32Copysign(a, b), rs.f32Copysign(1.5, a), rs.f32NextUp(a), rs.f32NextDown(a)]); while (true) { - const _283: rt.f32 | rt.Done = iter8.next(); - if (_283 === rt.DONE) { + const _283: rs.f32 | rs.Done = iter8.next(); + if (_283 === rs.DONE) { break; } putF32(out, _283); @@ -185,13 +185,13 @@ export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } else { zeros = b === 0.0; } - const iter9: rt.Iter = rt.iterSlice([rt.f32Max(a, b), rt.f32Min(a, b)]); + const iter9: rs.Iter = rs.iterSlice([rs.f32Max(a, b), rs.f32Min(a, b)]); while (true) { - const _295: rt.f32 | rt.Done = iter9.next(); - if (_295 === rt.DONE) { + const _295: rs.f32 | rs.Done = iter9.next(); + if (_295 === rs.DONE) { break; } - const x7: rt.f32 = _295; + const x7: rs.f32 = _295; if (!zeros) { _300 = x7; } else { @@ -199,102 +199,102 @@ export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void } putF32(out, _300); } - const _304: rt.f32 = rt.f32Midpoint(a, b); - const _305: rt.f32 = rt.f32DivEuclid(a, b); - const _306: rt.f32 = rt.f32RemEuclid(a, b); - const _308: rt.i32 = rt.i32Rem(rt.f32ToBits(b) | 0, 300); - const iter10: rt.Iter = rt.iterSlice([_304, _305, _306, rt.f32Powi(a, _308)]); + const _304: rs.f32 = rs.f32Midpoint(a, b); + const _305: rs.f32 = rs.f32DivEuclid(a, b); + const _306: rs.f32 = rs.f32RemEuclid(a, b); + const _308: rs.i32 = rs.i32Rem(rs.f32ToBits(b) | 0, 300); + const iter10: rs.Iter = rs.iterSlice([_304, _305, _306, rs.f32Powi(a, _308)]); while (true) { - const _316: rt.f32 | rt.Done = iter10.next(); - if (_316 === rt.DONE) { + const _316: rs.f32 | rs.Done = iter10.next(); + if (_316 === rs.DONE) { break; } putF32(out, _316); } - rt.byteVecPush(out, rt.f32TotalCmp(a, b) & 0xff); - rt.byteVecPush(out, option_mapOr$1e4a1e0(rt.f32PartialCmp(a, b), 9, (o: rt.Ordering): rt.u8 => { + rs.byteVecPush(out, rs.f32TotalCmp(a, b) & 0xff); + rs.byteVecPush(out, option_mapOr$14runhi(rs.f32PartialCmp(a, b), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; })); } else if (_10 === 6) { - const bits2: rt.u32 = takeBits(data)[0]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromBits(bits2))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f32ToBeBytes(rt.f32FromBits(bits2)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f32ToLeBytes(rt.f32FromBits(bits2)))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromBeBytes(rt.u32ToBeBytes(bits2)))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromLeBytes(rt.u32ToBeBytes(bits2).reverse()))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.f32ToLeBytes(rt.f32FromLeBytes(rt.u32ToBeBytes(bits2).reverse())))); - rt.byteVecPush(out, rt.f32IsSignNegative(rt.f32FromBits(bits2)) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32Copysign(rt.f32FromBits(bits2), -1.0))))); + const bits2: rs.u32 = takeBits(data)[0]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32FromBits(bits2))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f32ToBeBytes(rs.f32FromBits(bits2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f32ToLeBytes(rs.f32FromBits(bits2)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32FromBeBytes(rs.u32ToBeBytes(bits2)))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32FromLeBytes(rs.u32ToBeBytes(bits2).reverse()))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.f32ToLeBytes(rs.f32FromLeBytes(rs.u32ToBeBytes(bits2).reverse())))); + rs.byteVecPush(out, rs.f32IsSignNegative(rs.f32FromBits(bits2)) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32Copysign(rs.f32FromBits(bits2), -1.0))))); if (!Number.isNaN(a)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(a)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(a)))); } - putF32(out, rt.f32FromBits((rt.f32ToBits(a) ^ 1) >>> 0)); + putF32(out, rs.f32FromBits((rs.f32ToBits(a) ^ 1) >>> 0)); } else if (_10 === 7) { - const _393: [rt.f32, rt.f32] = rt.f32SinCos(a); - const s: rt.f32 = _393[0]; - const c2: rt.f32 = _393[1]; - const iter11: rt.Iter = rt.iterSlice([Math.fround(Math.sin(a)), Math.fround(Math.cos(a)), Math.fround(Math.tan(a)), Math.fround(Math.asin(a)), Math.fround(Math.acos(a)), Math.fround(Math.atan(a)), Math.fround(Math.atan2(a, b)), Math.fround(Math.sinh(a)), Math.fround(Math.cosh(a)), Math.fround(Math.tanh(a)), Math.fround(Math.asinh(a)), Math.fround(Math.acosh(a)), rt.f32Atanh(a), Math.fround(Math.exp(a)), Math.fround(Math.pow(2, a)), Math.fround(Math.expm1(a)), Math.fround(Math.log(a)), Math.fround(Math.fround(Math.log(a)) / Math.fround(Math.log(b))), Math.fround(Math.log2(a)), Math.fround(Math.log10(a)), Math.fround(Math.log1p(a)), rt.f32Powf(a, b), Math.fround(Math.cbrt(a)), Math.fround(Math.hypot(a, b)), s, c2]); + const _393: [rs.f32, rs.f32] = rs.f32SinCos(a); + const s: rs.f32 = _393[0]; + const c2: rs.f32 = _393[1]; + const iter11: rs.Iter = rs.iterSlice([Math.fround(Math.sin(a)), Math.fround(Math.cos(a)), Math.fround(Math.tan(a)), Math.fround(Math.asin(a)), Math.fround(Math.acos(a)), Math.fround(Math.atan(a)), Math.fround(Math.atan2(a, b)), Math.fround(Math.sinh(a)), Math.fround(Math.cosh(a)), Math.fround(Math.tanh(a)), Math.fround(Math.asinh(a)), Math.fround(Math.acosh(a)), rs.f32Atanh(a), Math.fround(Math.exp(a)), Math.fround(Math.pow(2, a)), Math.fround(Math.expm1(a)), Math.fround(Math.log(a)), Math.fround(Math.fround(Math.log(a)) / Math.fround(Math.log(b))), Math.fround(Math.log2(a)), Math.fround(Math.log10(a)), Math.fround(Math.log1p(a)), rs.f32Powf(a, b), Math.fround(Math.cbrt(a)), Math.fround(Math.hypot(a, b)), s, c2]); while (true) { - const _421: rt.f32 | rt.Done = iter11.next(); - if (_421 === rt.DONE) { + const _421: rs.f32 | rs.Done = iter11.next(); + if (_421 === rs.DONE) { break; } putF32(out, _421); } } else if (_10 === 8) { - const d: rt.Duration = rt.durationNew(rt.u64Shl(option_mapOr$15zxk73(rt.byteSliceFirst(_9[1]), 0, (_2: rt.u8): rt.u64 => { - return _2 as rt.u64; + const d: rs.Duration = rs.durationNew(rs.u64Shl(option_mapOr$1imzf9s(rs.byteSliceFirst(_9[1]), 0, (_2: rs.u8): rs.u64 => { + return _2 as rs.u64; }), 20), 123456789); - putF32(out, rt.durationAsSecsF32(d)); - putF32(out, rt.durationAsSecsF32(rt.durationNew(rt.f32ToBits(b) as rt.u64, rt.u32Rem(rt.f32ToBits(a), 1000000000)))); - const _446: rt.Duration = rt.durationFromMillis(1500); - putF32(out, rt.durationDivDurationF32(d, _446)); - putF32(out, rt.durationDivDurationF32({ secs: 0, nanos: 0 }, { secs: 0, nanos: 0 })); - putSecs(out, rt.durationTryFromSecsF32(a)); - putSecs(out, rt.durationTryFromSecsF32(Math.abs(a))); - putSecs(out, rt.durationTryFromSecsF32(Math.fround(Math.abs(a) * 9.999999717180685e-10))); - const _458: rt.u8 = rt.u8Rem(rt.u8Div(kind, 10), 4); + putF32(out, rs.durationAsSecsF32(d)); + putF32(out, rs.durationAsSecsF32(rs.durationNew(rs.f32ToBits(b) as rs.u64, rs.u32Rem(rs.f32ToBits(a), 1000000000)))); + const _446: rs.Duration = rs.durationFromMillis(1500); + putF32(out, rs.durationDivDurationF32(d, _446)); + putF32(out, rs.durationDivDurationF32({ secs: 0, nanos: 0 }, { secs: 0, nanos: 0 })); + putSecs(out, rs.durationTryFromSecsF32(a)); + putSecs(out, rs.durationTryFromSecsF32(Math.abs(a))); + putSecs(out, rs.durationTryFromSecsF32(Math.fround(Math.abs(a) * 9.999999717180685e-10))); + const _458: rs.u8 = rs.u8Rem(rs.u8Div(kind, 10), 4); if (_458 === 0) { - putDuration(out, rt.durationFromSecsF32(a)); + putDuration(out, rs.durationFromSecsF32(a)); } else if (_458 === 1) { - putDuration(out, rt.durationMulF32(d, a)); + putDuration(out, rs.durationMulF32(d, a)); } else if (_458 === 2) { - putDuration(out, rt.durationDivF32(d, a)); + putDuration(out, rs.durationDivF32(d, a)); } else { - putDuration(out, rt.durationMulF32({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, nanos: 999999999 }, b)); + putDuration(out, rs.durationMulF32({ secs: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, nanos: 999999999 }, b)); } } else { - const iter12: rt.Iter = rt.iterSlice([3.4028234663852886e38, -3.4028234663852886e38, 1.1754943508222875e-38, 1.1920928955078125e-7, Infinity, -Infinity, NaN, -0.0, 3.1415927410125732, 6.2831854820251465, 2.7182817459106445, 1.4142135381698608, 0.7071067690849304, 0.6931471824645996, 2.3025851249694824, 1.4426950216293335, 0.4342944920063019, 0.31830987334251404, 9.99994610111476e-41, 0.10000000149011612, 16777216.0]); + const iter12: rs.Iter = rs.iterSlice([3.4028234663852886e38, -3.4028234663852886e38, 1.1754943508222875e-38, 1.1920928955078125e-7, Infinity, -Infinity, NaN, -0.0, 3.1415927410125732, 6.2831854820251465, 2.7182817459106445, 1.4142135381698608, 0.7071067690849304, 0.6931471824645996, 2.3025851249694824, 1.4426950216293335, 0.4342944920063019, 0.31830987334251404, 9.99994610111476e-41, 0.10000000149011612, 16777216.0]); while (true) { - const _468: rt.f32 | rt.Done = iter12.next(); - if (_468 === rt.DONE) { + const _468: rs.f32 | rs.Done = iter12.next(); + if (_468 === rs.DONE) { break; } putF32(out, _468); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromBits(4290773283))))); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.f32ToBits(rt.f32FromBits(2139095041))))); - rt.byteVecPush(out, rt.f32IsSignNegative(rt.f32FromBits(4290773283)) ? 1 : 0); - const v2: rt.f32[] = [a, b, 0.10000000149011612]; - putF32(out, rt.iterSum(rt.iterSlice(v2), rt.f32Add, -0.0)); - putF32(out, rt.iterProduct(rt.iterSlice(v2), rt.f32Mul, 1.0)); - const _499: rt.f32[] = []; - putF32(out, rt.iterSum(rt.iterSlice(_499), rt.f32Add, -0.0)); - putF32(out, rt.iterSum(rt.iterSlice([-0.0, -0.0]), rt.f32Add, -0.0)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32FromBits(4290773283))))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.f32ToBits(rs.f32FromBits(2139095041))))); + rs.byteVecPush(out, rs.f32IsSignNegative(rs.f32FromBits(4290773283)) ? 1 : 0); + const v2: rs.f32[] = [a, b, 0.10000000149011612]; + putF32(out, rs.iterSum(rs.iterSlice(v2), rs.f32Add, -0.0)); + putF32(out, rs.iterProduct(rs.iterSlice(v2), rs.f32Mul, 1.0)); + const _499: rs.f32[] = []; + putF32(out, rs.iterSum(rs.iterSlice(_499), rs.f32Add, -0.0)); + putF32(out, rs.iterSum(rs.iterSlice([-0.0, -0.0]), rs.f32Add, -0.0)); putF32(out, 0.0); const g: Gauge.Gauge = { level: a, peak: b }; - raise(rt.place(() => g.level, (value) => g.level = value), b); + raise(rs.place(() => g.level, (value) => g.level = value), b); if (g.peak !== undefined) { - const _513: rt.f32 = rt.f32Max(g.peak, g.level); + const _513: rs.f32 = rs.f32Max(g.peak, g.level); g.peak = _513; } putF32(out, g.level); - putF32(out, option_unwrapOr$19h8ynp(g.peak, -1.0)); + putF32(out, option_unwrapOr$15mrooo(g.peak, -1.0)); const _526: Gauge.Gauge = Gauge.default$Default(); - rt.byteVecPush(out, Gauge.eq$cmp_PartialEq(g, _526) ? 1 : 0); - rt.byteVecPush(out, g.peak === b ? 1 : 0); - let local: rt.f32 = a; - raise(rt.place(() => local, (value2) => local = value2), 0.10000000149011612); + rs.byteVecPush(out, Gauge.eq$cmp_PartialEq(g, _526) ? 1 : 0); + rs.byteVecPush(out, g.peak === b ? 1 : 0); + let local: rs.f32 = a; + raise(rs.place(() => local, (value2) => local = value2), 0.10000000149011612); putF32(out, local); } } @@ -305,80 +305,80 @@ export function singles(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * exactly halfway between two singles, plus a tiny addend, subnormal sums, products past * `f32::MAX` that the sum brings back, and half the product's last place. */ -export function mulAdds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _53!: [rt.f32, rt.f32, rt.f32]; - let _95!: rt.f32; - const _63: (a0: rt.f32) => rt.f32 = (x: rt.f32): rt.f32 => { - return rt.f32FromBits((((rt.f32ToBits(x) & 4294963200) >>> 0) | 2048) >>> 0); +export function mulAdds(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _53!: [rs.f32, rs.f32, rs.f32]; + let _95!: rs.f32; + const _63: (a0: rs.f32) => rs.f32 = (x: rs.f32): rs.f32 => { + return rs.f32FromBits((((rs.f32ToBits(x) & 4294963200) >>> 0) | 2048) >>> 0); }; b0: { - if (!(rt.u8Rem(kind, 2) === 0)) { - let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 32; + if (!(rs.u8Rem(kind, 2) === 0)) { + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 32; while (true) { if (!(iterStart++ < iterEnd)) { break b0; } - const r: rt.u32 = step(rt.place(() => state, (value) => state = value)); - const pick: (a0: rt.u32, a1: rt.u32) => rt.i32 = (shift: rt.u32, n: rt.u32): rt.i32 => { - return rt.u32Rem(rt.u32Shr(r, shift), n) | 0; + const r: rs.u32 = step(rs.place(() => state, (value) => state = value)); + const pick: (a0: rs.u32, a1: rs.u32) => rs.i32 = (shift: rs.u32, n: rs.u32): rs.i32 => { + return rs.u32Rem(rs.u32Shr(r, shift), n) | 0; }; - const ea: rt.i32 = rt.i32Sub(pick(4, 32), 16); - const e: rt.i32 = rt.i32Sub(pick(9, 32), 16); - const a2: rt.f32 = near(step(rt.place(() => state, (value2) => state = value2)), ea); - const b2: rt.f32 = near(step(rt.place(() => state, (value3) => state = value3)), rt.i32Sub(e, ea)); - const c2: rt.u32 = step(rt.place(() => state, (value4) => state = value4)); - const _54: rt.u32 = rt.u32Rem(r, 6); + const ea: rs.i32 = rs.i32Sub(pick(4, 32), 16); + const e: rs.i32 = rs.i32Sub(pick(9, 32), 16); + const a2: rs.f32 = near(step(rs.place(() => state, (value2) => state = value2)), ea); + const b2: rs.f32 = near(step(rs.place(() => state, (value3) => state = value3)), rs.i32Sub(e, ea)); + const c2: rs.u32 = step(rs.place(() => state, (value4) => state = value4)); + const _54: rs.u32 = rs.u32Rem(r, 6); if (_54 === 0) { - _53 = [rt.f32FromBits(r), rt.f32FromBits(step(rt.place(() => state, (value5) => state = value5))), rt.f32FromBits(c2)] as [rt.f32, rt.f32, rt.f32]; + _53 = [rs.f32FromBits(r), rs.f32FromBits(step(rs.place(() => state, (value5) => state = value5))), rs.f32FromBits(c2)] as [rs.f32, rs.f32, rs.f32]; } else if (_54 === 1) { - _53 = [a2, b2, -Math.fround(a2 * b2)] as [rt.f32, rt.f32, rt.f32]; + _53 = [a2, b2, -Math.fround(a2 * b2)] as [rs.f32, rs.f32, rs.f32]; } else if (_54 === 2) { - _53 = [_63(a2), _63(b2), near(c2, rt.i32Sub(rt.i32Sub(e, 26), pick(14, 100)))] as [rt.f32, rt.f32, rt.f32]; + _53 = [_63(a2), _63(b2), near(c2, rs.i32Sub(rs.i32Sub(e, 26), pick(14, 100)))] as [rs.f32, rs.f32, rs.f32]; } else if (_54 === 3) { - const ea2: rt.i32 = rt.i32Sub(pick(14, 120), 60); - const e2: rt.i32 = rt.i32Sub(-130, pick(21, 30)); - const _90: [rt.f32, rt.f32] = [near(r, ea2), near(c2, rt.i32Sub(e2, ea2))]; - const a4: rt.f32 = _90[0]; - const b4: rt.f32 = _90[1]; + const ea2: rs.i32 = rs.i32Sub(pick(14, 120), 60); + const e2: rs.i32 = rs.i32Sub(-130, pick(21, 30)); + const _90: [rs.f32, rs.f32] = [near(r, ea2), near(c2, rs.i32Sub(e2, ea2))]; + const a4: rs.f32 = _90[0]; + const b4: rs.f32 = _90[1]; if (!((r >>> 31) === 0)) { - _95 = near(c2 >>> 1, rt.i32Sub(rt.i32Add(e2, pick(26, 30)), 15)); + _95 = near(c2 >>> 1, rs.i32Sub(rs.i32Add(e2, pick(26, 30)), 15)); } else { _95 = -Math.fround(a4 * b4); } - _53 = [a4, b4, _95] as [rt.f32, rt.f32, rt.f32]; + _53 = [a4, b4, _95] as [rs.f32, rs.f32, rs.f32]; } else if (_54 === 4) { - const ea3: rt.i32 = rt.i32Add(100, pick(14, 27)); - const a5: rt.f32 = near(r, ea3); - const b5: rt.f32 = near(c2, rt.i32Sub(rt.i32Add(rt.i32Sub(127, ea3), pick(21, 4)), 1)); - _53 = [a5, b5, rt.f32Copysign(near(c2 >>> 1, rt.i32Add(124, pick(26, 4))), -Math.fround(a5 * b5))] as [rt.f32, rt.f32, rt.f32]; + const ea3: rs.i32 = rs.i32Add(100, pick(14, 27)); + const a5: rs.f32 = near(r, ea3); + const b5: rs.f32 = near(c2, rs.i32Sub(rs.i32Add(rs.i32Sub(127, ea3), pick(21, 4)), 1)); + _53 = [a5, b5, rs.f32Copysign(near(c2 >>> 1, rs.i32Add(124, pick(26, 4))), -Math.fround(a5 * b5))] as [rs.f32, rs.f32, rs.f32]; } else { - const p: rt.f32 = Math.abs(Math.fround(a2 * b2)); - const _143: rt.usize = pick(14, 5) >>> 0; + const p: rs.f32 = Math.abs(Math.fround(a2 * b2)); + const _143: rs.usize = pick(14, 5) >>> 0; if (!(_143 < 5)) { - rt.panic("index out of bounds: the len is " + 5 + " but the index is " + _143); + rs.panic("index out of bounds: the len is " + 5 + " but the index is " + _143); } - const half: rt.f32 = [0.5, -0.5, 0.25, -0.75, 1.5][_143]; - _53 = [a2, b2, Math.fround(Math.fround(rt.f32NextUp(p) - p) * half)] as [rt.f32, rt.f32, rt.f32]; + const half: rs.f32 = [0.5, -0.5, 0.25, -0.75, 1.5][_143]; + _53 = [a2, b2, Math.fround(Math.fround(rs.f32NextUp(p) - p) * half)] as [rs.f32, rs.f32, rs.f32]; } - putF32(out, rt.f32MulAdd(_53[0], _53[1], _53[2])); + putF32(out, rs.f32MulAdd(_53[0], _53[1], _53[2])); } } - const _9: [rt.f32, rt.ByteSlice] = take(data); - const a: rt.f32 = _9[0]; - const _12: [rt.f32, rt.ByteSlice] = take(_9[1]); - putF32(out, rt.f32MulAdd(a, _12[0], take(_12[1])[0])); + const _9: [rs.f32, rs.ByteSlice] = take(data); + const a: rs.f32 = _9[0]; + const _12: [rs.f32, rs.ByteSlice] = take(_9[1]); + putF32(out, rs.f32MulAdd(a, _12[0], take(_12[1])[0])); } } /** A single of exponent `e`, or the nearest a finite one has, with the significand and sign of `bits`. */ -export function near(bits: rt.u32, e: rt.i32): rt.f32 { - return rt.f32FromBits((((bits & 2155872255) >>> 0) | (((rt.clamp(rt.i32Add(e, 127), 0, 254) >>> 0) << 23) >>> 0)) >>> 0); +export function near(bits: rs.u32, e: rs.i32): rs.f32 { + return rs.f32FromBits((((bits & 2155872255) >>> 0) | (((rs.clamp(rs.i32Add(e, 127), 0, 254) >>> 0) << 23) >>> 0)) >>> 0); } /** xorshift32, for the singles and decimals a case makes from its seed. */ -export function step(state: rt.Place): rt.u32 { +export function step(state: rs.Place): rs.u32 { state.v = (state.v ^ ((state.v << 13) >>> 0)) >>> 0; state.v = (state.v ^ (state.v >>> 17)) >>> 0; state.v = (state.v ^ ((state.v << 5) >>> 0)) >>> 0; @@ -389,51 +389,51 @@ export function step(state: rt.Place): rt.u32 { * `f32`'s `Display`, `Debug`, `LowerExp`, and `UpperExp`, with a precision from the byte * after the single, and every other option. */ -export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: [rt.f32, rt.ByteSlice] = take(data); - const a: rt.f32 = _6[0]; - const p: rt.usize = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(_6[1]), 0) as rt.usize; +export function formats(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: [rs.f32, rs.ByteSlice] = take(data); + const a: rs.f32 = _6[0]; + const p: rs.usize = option_unwrapOr$1fr498u(rs.byteSliceFirst(_6[1]), 0) as rs.usize; b0: { - const w: rt.usize = rt.usizeDiv(p, 4); - const _13: rt.u8 = rt.u8Rem(kind, 5); + const w: rs.usize = rs.usizeDiv(p, 4); + const _13: rs.u8 = rs.u8Rem(kind, 5); if (_13 === 0) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Display(a, f), (f: rt.Formatter) => rt.f32Debug(a, f), (f: rt.Formatter) => rt.f32LowerExp(a, f), (f: rt.Formatter) => rt.f32UpperExp(a, f), rt.fmtCount(p)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[0]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[1]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[2]), " ", rt.fmtSpec({ precision: rt.fmtCountOf(args2[4]) }, args2[3]), " ", rt.fmtSpec({ plus: true }, args2[0]), " ", rt.fmtSpec({ plus: true }, args2[1]), " ", rt.fmtSpec({ plus: true, precision: rt.fmtCountOf(args2[4]) }, args2[2])])); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Display(a, f), (f: rt.Formatter) => rt.f32LowerExp(a, f), (f: rt.Formatter) => rt.f32Debug(a, f), (f: rt.Formatter) => rt.f32UpperExp(a, f), rt.fmtCount(w), rt.fmtCount(p)]; - put(out, rt.fmtFormat([rt.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rt.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rt.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rt.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rt.fmtSpec({ alternate: true }, args4[2]), "|", rt.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rt.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: rt.fmtCountOf(args4[4]), precision: rt.fmtCountOf(args4[5]) }, args4[0])])); - put(out, rt.fmtToString((f: rt.Formatter) => rt.f32Display(a, f))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(p)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[0]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[1]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[2]), " ", rs.fmtSpec({ precision: rs.fmtCountOf(args2[4]) }, args2[3]), " ", rs.fmtSpec({ plus: true }, args2[0]), " ", rs.fmtSpec({ plus: true }, args2[1]), " ", rs.fmtSpec({ plus: true, precision: rs.fmtCountOf(args2[4]) }, args2[2])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f), (f: rs.Formatter) => rs.f32UpperExp(a, f), rs.fmtCount(w), rs.fmtCount(p)]; + put(out, rs.fmtFormat([rs.fmtSpec({ zero: true, width: 8, precision: 3 }, args4[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[0]), "|", rs.fmtSpec({ align: "^", width: 12 }, args4[2]), "|", rs.fmtSpec({ fill: "*", align: ">", width: 10, precision: 1 }, args4[0]), "|", rs.fmtSpec({ alternate: true }, args4[2]), "|", rs.fmtSpec({ fill: "-", align: "^", plus: true, width: 15, precision: 2 }, args4[3]), "|", rs.fmtSpec({ zero: true, width: 10 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: rs.fmtCountOf(args4[4]), precision: rs.fmtCountOf(args4[5]) }, args4[0])])); + put(out, rs.fmtToString((f: rs.Formatter) => rs.f32Display(a, f))); } else if (_13 === 1) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Display(a, f), (f: rt.Formatter) => rt.f32LowerExp(a, f), (f: rt.Formatter) => rt.f32Debug(a, f)]; - put(out, rt.fmtFormat([rt.fmtSpec({ precision: 160 }, args6[0]), " ", rt.fmtSpec({ precision: 120 }, args6[1]), " ", rt.fmtSpec({ precision: 160 }, args6[2])])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(a, f), (f: rs.Formatter) => rs.f32LowerExp(a, f), (f: rs.Formatter) => rs.f32Debug(a, f)]; + put(out, rs.fmtFormat([rs.fmtSpec({ precision: 160 }, args6[0]), " ", rs.fmtSpec({ precision: 120 }, args6[1]), " ", rs.fmtSpec({ precision: 160 }, args6[2])])); } else if (_13 === 2) { - const _72: [rt.f32, rt.ByteSlice] = take(_6[1]); - const b: rt.f32 = _72[0]; - const c: rt.f32 = take(_72[1])[0]; - putF32(out, rt.f32Clamp(a, b, c)); + const _72: [rs.f32, rs.ByteSlice] = take(_6[1]); + const b: rs.f32 = _72[0]; + const c: rs.f32 = take(_72[1])[0]; + putF32(out, rs.f32Clamp(a, b, c)); } else if (_13 === 3) { - const _78: rt.Vec = rt.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); + const _78: rs.Vec = rs.vecFrom([Math.fround(a * 0.5), -0.0, 9.999999747378752e-5, 1.0000000272564224e16, NaN]); const part = { level: a, history: _78 }; - const args8: rt.Fmt[] = [(f: rt.Formatter) => Reading.fmt$fmt_Debug(part, f)]; - put(out, rt.fmtFormat([args8[0], "|", rt.fmtSpec({ precision: 2 }, args8[0]), "|", rt.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => Reading.fmt$fmt_Debug(part, f)]; + put(out, rs.fmtFormat([args8[0], "|", rs.fmtSpec({ precision: 2 }, args8[0]), "|", rs.fmtSpec({ plus: true, zero: true, width: 12 }, args8[0])])); } else { - let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 64; + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 64; while (iterStart++ < iterEnd) { - const x: rt.f32 = rt.f32FromBits(step(rt.place(() => state, (value) => state = value))); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Display(x, f), (f: rt.Formatter) => rt.f32Debug(x, f), (f: rt.Formatter) => rt.f32LowerExp(x, f)]; - put(out, rt.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); + const x: rs.f32 = rs.f32FromBits(step(rs.place(() => state, (value) => state = value))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Display(x, f), (f: rs.Formatter) => rs.f32Debug(x, f), (f: rs.Formatter) => rs.f32LowerExp(x, f)]; + put(out, rs.fmtFormat([args10[0], " ", args10[1], " ", args10[2]])); } - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 64; + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 64; while (true) { if (!(iterStart2++ < iterEnd2)) { break b0; } - const r2: rt.u32 = step(rt.place(() => state, (value2) => state = value2)); - const x2: rt.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rt.u32Shl(1, rt.u32Add(rt.u32Rem(r2, 16), 1)))); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Debug(x2, f), (f: rt.Formatter) => rt.f32LowerExp(x2, f)]; - put(out, rt.fmtFormat([args12[0], " ", args12[1]])); + const r2: rs.u32 = step(rs.place(() => state, (value2) => state = value2)); + const x2: rs.f32 = Math.fround(Math.fround(r2 >>> 8) / Math.fround(rs.u32Shl(1, rs.u32Add(rs.u32Rem(r2, 16), 1)))); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(x2, f), (f: rs.Formatter) => rs.f32LowerExp(x2, f)]; + put(out, rs.fmtFormat([args12[0], " ", args12[1]])); } } } @@ -443,78 +443,78 @@ export function formats(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * `str::parse::`, with its errors, of the input as text, of bytes mapped into the * grammar's alphabet, or of decimals made from a seed. */ -export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _108!: rt.usize; +export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _108!: rs.usize; b0: { - const _4: rt.u8 = rt.u8Rem(kind, 3); + const _4: rs.u8 = rs.u8Rem(kind, 3); if (_4 === 0) { - const _6: rt.Result = rt.strFromUtf8(data); + const _6: rs.Result = rs.strFromUtf8(data); if (_6.ok) { one(_6.value, out); } } else if (_4 === 1) { let s: string = ""; - for (const b of rt.byteSliceView(data)) { - const _21: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); - const _22: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); - rt.idx(_21, _22); - s = s + String.fromCodePoint(_21.data[_21.start + _22] as rt.char); + for (const b of rs.byteSliceView(data)) { + const _21: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)); + const _22: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 48, 46, 101, 69, 43, 45, 95, 105, 110, 102, 73, 78, 70, 116, 121, 84, 89, 97, 32)).length); + rs.idx(_21, _22); + s = s + String.fromCodePoint(_21.data[_21.start + _22] as rs.char); } one(s, out); } else { - let state: rt.u32 = (takeBits(data)[0] | 1) >>> 0; - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 16; + let state: rs.u32 = (takeBits(data)[0] | 1) >>> 0; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 16; while (iterStart++ < iterEnd) { - const x: rt.f32 = rt.f32FromBits((step(rt.place(() => state, (value) => state = value)) & 2147483647) >>> 0); - const half: rt.f64 = ((x as rt.f64) + (rt.f32NextUp(x) as rt.f64)) / 2.0; - const p: rt.usize = rt.u32Add(rt.u32Rem(step(rt.place(() => state, (value2) => state = value2)), 30), 8) as rt.usize; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.f64LowerExp(half, f), rt.fmtCount(p)]; - one(rt.fmtFormat([rt.fmtSpec({ precision: rt.fmtCountOf(args2[1]) }, args2[0])]), out); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.f64LowerExp(half, f)]; - one(rt.fmtFormat([args4[0]]), out); + const x: rs.f32 = rs.f32FromBits((step(rs.place(() => state, (value) => state = value)) & 2147483647) >>> 0); + const half: rs.f64 = ((x as rs.f64) + (rs.f32NextUp(x) as rs.f64)) / 2.0; + const p: rs.usize = rs.u32Add(rs.u32Rem(step(rs.place(() => state, (value2) => state = value2)), 30), 8) as rs.usize; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f), rs.fmtCount(p)]; + one(rs.fmtFormat([rs.fmtSpec({ precision: rs.fmtCountOf(args2[1]) }, args2[0])]), out); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.f64LowerExp(half, f)]; + one(rs.fmtFormat([args4[0]]), out); } - let iterStart2: rt.i32 = 0; - const iterEnd2: rt.i32 = 16; + let iterStart2: rs.i32 = 0; + const iterEnd2: rs.i32 = 16; while (true) { if (!(iterStart2++ < iterEnd2)) { break b0; } - const r: rt.u32 = step(rt.place(() => state, (value3) => state = value3)); - const len: rt.usize = rt.u32Add(rt.u32Rem(r, 20), 1) as rt.usize; - const point: rt.usize = rt.usizeRem(r >>> 8 as rt.usize, rt.usizeAdd(len, 1)); + const r: rs.u32 = step(rs.place(() => state, (value3) => state = value3)); + const len: rs.usize = rs.u32Add(rs.u32Rem(r, 20), 1) as rs.usize; + const point: rs.usize = rs.usizeRem(r >>> 8 as rs.usize, rs.usizeAdd(len, 1)); let s2: string = ""; - let iterStart3: rt.usize = 0; - const iterEnd3: rt.usize = len; + let iterStart3: rs.usize = 0; + const iterEnd3: rs.usize = len; while ((_108 = iterStart3++) < iterEnd3) { if (_108 === point) { s2 = s2 + "."; } - const _117: rt.char = rt.u8Add(48, rt.u32Rem(step(rt.place(() => state, (value4) => state = value4)), 10) & 0xff) as rt.char; + const _117: rs.char = rs.u8Add(48, rs.u32Rem(step(rs.place(() => state, (value4) => state = value4)), 10) & 0xff) as rs.char; s2 = s2 + String.fromCodePoint(_117); } - const _133: rt.i64 = rt.i64Sub(rt.u32Rem(r >>> 16, 100) as rt.i64, 50); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s2), (f: rt.Formatter) => rt.i64Display(_133, f)]; - one(rt.fmtFormat([args6[0], "e", args6[1]]), out); + const _133: rs.i64 = rs.i64Sub(rs.u32Rem(r >>> 16, 100) as rs.i64, 50); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s2), (f: rs.Formatter) => rs.i64Display(_133, f)]; + one(rs.fmtFormat([args6[0], "e", args6[1]]), out); } } } } /** What parsing `s` makes: the single's bits and its `Debug`, or the error printed. */ -export function one(s: string, out: rt.ByteVec): void { - const _4: rt.Result = rt.f32FromStr(s); +export function one(s: string, out: rs.ByteVec): void { + const _4: rs.Result = rs.f32FromStr(s); if (_4.ok) { - const v: rt.f32 = _4.value; + const v: rs.f32 = _4.value; putF32(out, v); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.f32Debug(v, f)]; - put(out, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.f32Debug(v, f)]; + put(out, rs.fmtFormat([args2[0]])); } else { - const e: rt.ParseFloatError = _4.error; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseFloatErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtParseFloatErrorDebug(e, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1]])); + const e: rs.ParseFloatError = _4.error; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseFloatErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseFloatErrorDebug(e, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1]])); } - rt.byteVecPush(out, rt.f32FromStr(s).ok ? 1 : 0); + rs.byteVecPush(out, rs.f32FromStr(s).ok ? 1 : 0); } //# sourceMappingURL=singles.ts.map diff --git a/ts/fixtures/lang/slices/expected/core/option.ts b/ts/fixtures/lang/slices/expected/core/option.ts index 8d9b4e707..ad7a977b5 100644 --- a/ts/fixtures/lang/slices/expected/core/option.ts +++ b/ts/fixtures/lang/slices/expected/core/option.ts @@ -1,80 +1,80 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { digest, digestWords } from "../slices.ts"; import type * as Item from "../slices.Item.ts"; import * as Noisy from "../slices.Noisy.ts"; import type * as Pair from "../slices.Pair.ts"; -export function isSomeAnd$0eocbrl(self: [rt.ByteSlice, rt.ByteSlice] | undefined, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => boolean): boolean { +export function isSomeAnd$1ouf3e6(self: [rs.ByteSlice, rs.ByteSlice] | undefined, f: (a0: [rs.ByteSlice, rs.ByteSlice]) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function map$1wqzuhy(self: rt.u16[] | undefined, f: (a0: rt.u16[]) => rt.u8): rt.u8 | undefined { +export function map$1sh08h7(self: rs.u16[] | undefined, f: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0c2keyb(self: rt.ByteSlice | undefined, f: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { +export function map$0q6fk7x(self: rs.ByteSlice | undefined, f: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$11y9s7r(self: Pair.Pair[] | undefined, f: (a0: Pair.Pair[]) => rt.u8): rt.u8 | undefined { +export function map$0k54dqg(self: Pair.Pair[] | undefined, f: (a0: Pair.Pair[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0qyyft9(self: rt.u16[] | undefined, _: (a0: rt.u16[]) => rt.u8): rt.u8 | undefined { +export function map$07x3qxw(self: rs.u16[] | undefined, _: (a0: rs.u16[]) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return digestWords(self); } -export function map$1xk4yz1(self: rt.ByteSlice | undefined, _: (a0: rt.ByteSlice) => rt.u8): rt.u8 | undefined { +export function map$0vk4zok(self: rs.ByteSlice | undefined, _: (a0: rs.ByteSlice) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return digest(self); } -export function map$003seos(self: Item.Item | undefined, f: (a0: Item.Item) => rt.u8): rt.u8 | undefined { +export function map$1aqm6sp(self: Item.Item | undefined, f: (a0: Item.Item) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0a57co2(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u8): rt.u8 | undefined { +export function map$04ry0e1(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u8): rs.u8 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$189goit(self: Noisy.Noisy | undefined, default_: rt.u8, f: (a0: Noisy.Noisy) => rt.u8): rt.u8 { +export function mapOr$135q041(self: Noisy.Noisy | undefined, default_: rs.u8, f: (a0: Noisy.Noisy) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function zip$0n9ueec(self: rt.ByteSlice | undefined, other: rt.ByteSlice | undefined): [rt.ByteSlice, rt.ByteSlice] | undefined { - let _0!: [rt.ByteSlice, rt.ByteSlice] | undefined; +export function zip$0wdt346(self: rs.ByteSlice | undefined, other: rs.ByteSlice | undefined): [rs.ByteSlice, rs.ByteSlice] | undefined { + let _0!: [rs.ByteSlice, rs.ByteSlice] | undefined; b0: { if (self !== undefined) { if (other !== undefined) { - _0 = [self, other] as [rt.ByteSlice, rt.ByteSlice]; + _0 = [self, other] as [rs.ByteSlice, rs.ByteSlice]; break b0; } } diff --git a/ts/fixtures/lang/slices/expected/harness.ts b/ts/fixtures/lang/slices/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/slices/expected/harness.ts +++ b/ts/fixtures/lang/slices/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/slices/expected/lib.ts b/ts/fixtures/lang/slices/expected/lib.ts index db69bfa96..e4771ad4e 100644 --- a/ts/fixtures/lang/slices/expected/lib.ts +++ b/ts/fixtures/lang/slices/expected/lib.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { parts, chunked, subslices, drains, ranges, edits, arrays, arraysMut } from "./slices.ts"; import type * as Noisy from "./slices.Noisy.ts"; import type * as Pair from "./slices.Pair.ts"; -export function copy$Option_array2_u16(v: rt.u16[] | undefined): rt.u16[] | undefined { +export function copy$Option_array2_u16(v: rs.u16[] | undefined): rs.u16[] | undefined { return v === undefined ? v : copy$array_u16(v); } @@ -17,7 +17,7 @@ export function copy$array_array2_array2_u8(v: Uint8Array[][]): Uint8Array[][] { return v.map(copy$array_array2_u8); } -export function copy$array_array2_u16(v: rt.u16[][]): rt.u16[][] { +export function copy$array_array2_u16(v: rs.u16[][]): rs.u16[][] { return v.map(copy$array_u16); } @@ -25,7 +25,7 @@ export function copy$array_array2_u8(v: Uint8Array[]): Uint8Array[] { return v.map(copy$array_u8); } -export function copy$array_u16(v: rt.u16[]): rt.u16[] { +export function copy$array_u16(v: rs.u16[]): rs.u16[] { return v.slice(); } @@ -37,16 +37,16 @@ export function copy$slices_Pair(v: Pair.Pair): Pair.Pair { return { a: v.a, b: v.b }; } -export function drop$tuple2_Vec_slices_Noisy_Vec_u8(_1: [rt.Vec, rt.ByteVec]): void { - rt.dropVec(_1[0]); +export function drop$tuple2_Vec_slices_Noisy_Vec_u8(_1: [rs.Vec, rs.ByteVec]): void { + rs.dropVec(_1[0]); } /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["slices::parts", parts as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::drains", drains as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::ranges", ranges as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::edits", edits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::arrays", arrays as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["slices::arrays_mut", arraysMut as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["slices::parts", parts as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::drains", drains as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::chunked", chunked as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::subslices", subslices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::ranges", ranges as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::edits", edits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays", arrays as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["slices::arrays_mut", arraysMut as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/slices/expected/slices.Counted.ts b/ts/fixtures/lang/slices/expected/slices.Counted.ts index 0bfa358c8..7a26fba3b 100644 --- a/ts/fixtures/lang/slices/expected/slices.Counted.ts +++ b/ts/fixtures/lang/slices/expected/slices.Counted.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { LOG } from "./slices.ts"; /** @@ -8,12 +8,12 @@ import { LOG } from "./slices.ts"; * `copy_within` and `copy_from_slice` do not. */ export interface Counted { - n: rt.u8; + n: rs.u8; } export function clone$Clone(self: Counted): Counted { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, self.n ^ 64); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, self.n ^ 64); }); return self; } diff --git a/ts/fixtures/lang/slices/expected/slices.Item.ts b/ts/fixtures/lang/slices/expected/slices.Item.ts index abc8e8ffb..40ced14b9 100644 --- a/ts/fixtures/lang/slices/expected/slices.Item.ts +++ b/ts/fixtures/lang/slices/expected/slices.Item.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { LOG } from "./slices.ts"; /** Logs its tag as it drops. */ export class Item { - tag: rt.u8; + tag: rs.u8; - constructor(tag: rt.u8) { + constructor(tag: rs.u8) { this.tag = tag; } @@ -17,8 +17,8 @@ export class Item { } export function drop$ops_Drop(self: Item): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, self.tag); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, self.tag); }); } diff --git a/ts/fixtures/lang/slices/expected/slices.Noisy.ts b/ts/fixtures/lang/slices/expected/slices.Noisy.ts index 77c872292..62eb8e192 100644 --- a/ts/fixtures/lang/slices/expected/slices.Noisy.ts +++ b/ts/fixtures/lang/slices/expected/slices.Noisy.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { LOG } from "./slices.ts"; /** @@ -8,9 +8,9 @@ import { LOG } from "./slices.ts"; * its tag as it drops. */ export class Noisy { - tag: rt.u8; + tag: rs.u8; - constructor(tag: rt.u8) { + constructor(tag: rs.u8) { this.tag = tag; } @@ -20,15 +20,15 @@ export class Noisy { } export function clone$Clone(self: Noisy): Noisy { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, self.tag | 128); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, self.tag | 128); }); - return new Noisy(rt.u8WrappingAdd(self.tag, 1)); + return new Noisy(rs.u8WrappingAdd(self.tag, 1)); } export function drop$ops_Drop(self: Noisy): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, self.tag); + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, self.tag); }); } diff --git a/ts/fixtures/lang/slices/expected/slices.Pair.ts b/ts/fixtures/lang/slices/expected/slices.Pair.ts index 97f7dc4f4..51a221e7e 100644 --- a/ts/fixtures/lang/slices/expected/slices.Pair.ts +++ b/ts/fixtures/lang/slices/expected/slices.Pair.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function partialCmp$cmp_PartialOrd(self: Pair, other: Pair): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Pair, other: Pair): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Pair, other: Pair): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.a, other.a); +export function cmp$cmp_Ord(self: Pair, other: Pair): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.a, other.a); if (cmp === 0) { - return rt.cmp(self.b, other.b); + return rs.cmp(self.b, other.b); } return cmp; } /** An element kept as an object, which a mutable chunk writes whole and by field. */ export interface Pair { - a: rt.u8; - b: rt.u16; + a: rs.u8; + b: rs.u16; } //# sourceMappingURL=slices.Pair.ts.map diff --git a/ts/fixtures/lang/slices/expected/slices.ts b/ts/fixtures/lang/slices/expected/slices.ts index a7f49c11d..87f98d871 100644 --- a/ts/fixtures/lang/slices/expected/slices.ts +++ b/ts/fixtures/lang/slices/expected/slices.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$Option_array2_u16, copy$Option_array2_u8, copy$array_array2_array2_u8, copy$array_array2_u16, copy$array_array2_u8, copy$array_u16, copy$array_u8, copy$slices_Pair, drop$tuple2_Vec_slices_Noisy_Vec_u8 } from "./lib.ts"; -import { isSomeAnd$0eocbrl, map$1wqzuhy as option_map$1wqzuhy, map$0c2keyb as option_map$0c2keyb, map$11y9s7r as option_map$11y9s7r, map$0qyyft9 as option_map$0qyyft9, map$1xk4yz1 as option_map$1xk4yz1, map$003seos as option_map$003seos, map$0a57co2 as option_map$0a57co2, mapOr$189goit as option_mapOr$189goit, zip$0n9ueec, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; +import { isSomeAnd$1ouf3e6, map$1sh08h7 as option_map$1sh08h7, map$0q6fk7x as option_map$0q6fk7x, map$0k54dqg as option_map$0k54dqg, map$07x3qxw as option_map$07x3qxw, map$0vk4zok as option_map$0vk4zok, map$1aqm6sp as option_map$1aqm6sp, map$04ry0e1 as option_map$04ry0e1, mapOr$135q041 as option_mapOr$135q041, zip$0wdt346, clone$1omlcob as option_clone$1omlcob } from "./core/option.ts"; import * as Counted from "./slices.Counted.ts"; import * as Item from "./slices.Item.ts"; import * as Noisy from "./slices.Noisy.ts"; import * as Pair from "./slices.Pair.ts"; -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LOG$init, false); +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); -export function LOG$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function LOG$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } /** Puts which items dropped since the last flush. */ -export function flush(out: rt.ByteVec): void { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(log)); - rt.byteVecClear(log); +export function flush(out: rs.ByteVec): void { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(log)); + rs.byteVecClear(log); }); } /** A digest of a part, which tells parts of different lengths or contents apart. */ -export function digest(part: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(part)), part.length & 0xff, (acc: rt.u8, _32: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(rt.u8WrappingMul(acc, 31), _32); +export function digest(part: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(part)), part.length & 0xff, (acc: rs.u8, _32: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(rs.u8WrappingMul(acc, 31), _32); }); } -export function digestWords(part: rt.u16[]): rt.u8 { - return rt.iterFold(rt.iterSlice(part), part.length & 0xff, (acc: rt.u8, _32: rt.u16): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ ((_32 >> 3) & 0xff); +export function digestWords(part: rs.u16[]): rs.u8 { + return rs.iterFold(rs.iterSlice(part), part.length & 0xff, (acc: rs.u8, _32: rs.u16): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ ((_32 >> 3) & 0xff); }); } @@ -39,162 +39,162 @@ export function digestWords(part: rt.u16[]): rt.u8 { * `windows` or `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in * six, which panics. */ -export function parts(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 2), 6) as rt.usize; - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); +export function parts(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const size: rs.usize = rs.u8Rem(rs.u8Div(kind, 2), 6) as rs.usize; + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - if (rt.u8Rem(kind, 2) === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceWindows(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceWindows(data, size)), digest), undefined, true); - const it: rt.Iter = rt.byteSliceWindows(data, size); - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceWindows(data, size)), digest)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceWindows(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceWindows(data, size), 2), 2), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceWindows(words.items, size), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceWindows(words.items, size)), digestWords), undefined, true); - const it2: rt.Iter = rt.sliceWindows(words.items, size); - rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it2.next()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNth(it2, 1), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNthBack(it2, 1), digestWords)), undefined, true); - rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it2, digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterLast(rt.sliceWindows(words.items, size)), digestWords)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.sliceWindows(words.items, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceWindows(words.items, size), 2), 2), digestWords), undefined, true); - const steps: rt.Iter = rt.byteSliceWindows(data, size); - const _123: [rt.ByteSlice | undefined, rt.ByteSlice | undefined] = [rt.iterToOption(steps.next()), rt.iterToOption(steps.next())]; + if (rs.u8Rem(kind, 2) === 0) { + rs.iterExtendBytes(out, rs.iterMap(rs.byteSliceWindows(data, size), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.byteSliceWindows(data, size)), digest), undefined, true); + const it: rs.Iter = rs.byteSliceWindows(data, size); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it.next()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it.nextBack()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNth(it, 1), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNthBack(it, 1), digest)), undefined, true); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it, digest), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterLast(rs.byteSliceWindows(data, size)), digest)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceWindows(data, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.byteSliceWindows(data, size), 2), 2), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceWindows(words.items, size), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.sliceWindows(words.items, size)), digestWords), undefined, true); + const it2: rs.Iter = rs.sliceWindows(words.items, size); + rs.byteVecPush(out, it2.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it2.next()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it2.nextBack()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNth(it2, 1), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNthBack(it2, 1), digestWords)), undefined, true); + rs.byteVecPush(out, it2.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it2, digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterLast(rs.sliceWindows(words.items, size)), digestWords)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.sliceWindows(words.items, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.sliceWindows(words.items, size), 2), 2), digestWords), undefined, true); + const steps: rs.Iter = rs.byteSliceWindows(data, size); + const _123: [rs.ByteSlice | undefined, rs.ByteSlice | undefined] = [rs.iterToOption(steps.next()), rs.iterToOption(steps.next())]; if (_123[0] !== undefined) { if (_123[1] !== undefined) { - const a: rt.ByteSlice = _123[0]; - const b: rt.ByteSlice = _123[1]; - const _134: rt.u8 = rt.byteSliceEq(a, b) ? 1 : 0; - rt.idx(a, 0); - const _138: rt.u8 = a.data[a.start]; - const _143: rt.usize = rt.usizeSub(size, 1); - rt.idx(b, _143); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_134, _138, b.data[b.start + _143])), undefined, true); + const a: rs.ByteSlice = _123[0]; + const b: rs.ByteSlice = _123[1]; + const _134: rs.u8 = rs.byteSliceEq(a, b) ? 1 : 0; + rs.idx(a, 0); + const _138: rs.u8 = a.data[a.start]; + const _143: rs.usize = rs.usizeSub(size, 1); + rs.idx(b, _143); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_134, _138, b.data[b.start + _143])), undefined, true); } } } else { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunks(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunks(data, size)), digest), undefined, true); - const it3: rt.Iter = rt.byteSliceChunks(data, size); - rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it3.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it3, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it3, 1), digest)), undefined, true); - rt.byteVecPush(out, it3.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it3, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunks(data, size)), digest)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunks(data, size), 2), 2), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunks(words.items, size), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunks(words.items, size)), digestWords), undefined, true); - const it4: rt.Iter = rt.sliceChunks(words.items, size); - rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it4.next()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it4.nextBack()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNth(it4, 1), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNthBack(it4, 1), digestWords)), undefined, true); - rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterLast(rt.sliceChunks(words.items, size)), digestWords)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.sliceChunks(words.items, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunks(words.items, size), 2), 2), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.iterToOption(rt.byteSliceChunks(data, size).nextBack()), (c: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.byteSliceChunks(data, size), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.byteSliceChunks(data, size)), digest), undefined, true); + const it3: rs.Iter = rs.byteSliceChunks(data, size); + rs.byteVecPush(out, it3.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it3.next()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it3.nextBack()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNth(it3, 1), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNthBack(it3, 1), digest)), undefined, true); + rs.byteVecPush(out, it3.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it3, digest), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterLast(rs.byteSliceChunks(data, size)), digest)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceChunks(data, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.byteSliceChunks(data, size), 2), 2), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceChunks(words.items, size), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.sliceChunks(words.items, size)), digestWords), undefined, true); + const it4: rs.Iter = rs.sliceChunks(words.items, size); + rs.byteVecPush(out, it4.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it4.next()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it4.nextBack()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNth(it4, 1), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNthBack(it4, 1), digestWords)), undefined, true); + rs.byteVecPush(out, it4.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it4, digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterLast(rs.sliceChunks(words.items, size)), digestWords)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunks(words.items, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.sliceChunks(words.items, size), 2), 2), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.iterToOption(rs.byteSliceChunks(data, size).nextBack()), (c: rs.ByteSlice): rs.u8 => { return c.length & 0xff; })), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.sliceChunks(words.items, size), (c2: rt.u16[]): rt.u16 => { - return rt.iterSum(rt.iterSlice(c2), rt.u16Add, 0) >> 2; - }), undefined, 2, true).items), (_22: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.sliceChunks(words.items, size), (c2: rs.u16[]): rs.u16 => { + return rs.iterSum(rs.iterSlice(c2), rs.u16Add, 0) >> 2; + }), undefined, 2, true).items), (_22: rs.u16): rs.u8 => { return _22 & 0xff; }), undefined, true); } } /** Writes through one mutable chunk, the `i`th, as each element type allows. */ -export function scribble(i: rt.usize, chunk: rt.ByteSlice): void { - const n: rt.usize = chunk.length; - rt.idx(chunk, 0); - const _5: rt.u8 = rt.u8WrappingAdd(chunk.data[chunk.start], i & 0xff); - rt.idx(chunk, 0); +export function scribble(i: rs.usize, chunk: rs.ByteSlice): void { + const n: rs.usize = chunk.length; + rs.idx(chunk, 0); + const _5: rs.u8 = rs.u8WrappingAdd(chunk.data[chunk.start], i & 0xff); + rs.idx(chunk, 0); chunk.data[chunk.start] = _5; - rt.byteSliceSwap(chunk, 0, rt.usizeSub(n, 1)); - if (rt.usizeRem(i, 2) === 1) { - rt.byteSliceView(chunk).reverse(); + rs.byteSliceSwap(chunk, 0, rs.usizeSub(n, 1)); + if (rs.usizeRem(i, 2) === 1) { + rs.byteSliceView(chunk).reverse(); } - const iter: rt.Iter> = rt.iterSliceMut(rt.byteSliceView(chunk)); + const iter: rs.Iter> = rs.iterSliceMut(rs.byteSliceView(chunk)); while (true) { - const _26: rt.Place | rt.Done = iter.next(); - if (_26 === rt.DONE) { + const _26: rs.Place | rs.Done = iter.next(); + if (_26 === rs.DONE) { break; } _26.v = _26.v ^ 90; } } -export function scribbleWords(i: rt.usize, chunk: rt.u16[]): void { - const n: rt.usize = chunk.length; - const _8: rt.usize = rt.usizeSub(n, 1); - rt.idx(chunk, _8); - const _5: rt.u16 = rt.u16WrappingAdd(rt.u16WrappingMul(chunk[_8], 3), i & 0xffff); - const _14: rt.usize = rt.usizeSub(n, 1); - rt.idx(chunk, _14); +export function scribbleWords(i: rs.usize, chunk: rs.u16[]): void { + const n: rs.usize = chunk.length; + const _8: rs.usize = rs.usizeSub(n, 1); + rs.idx(chunk, _8); + const _5: rs.u16 = rs.u16WrappingAdd(rs.u16WrappingMul(chunk[_8], 3), i & 0xffff); + const _14: rs.usize = rs.usizeSub(n, 1); + rs.idx(chunk, _14); chunk[_14] = _5; - rt.sliceSwap(chunk, 0, rt.usizeDiv(n, 2)); - const _22: rt.Place | undefined = rt.sliceFirstMut(chunk); + rs.sliceSwap(chunk, 0, rs.usizeDiv(n, 2)); + const _22: rs.Place | undefined = rs.sliceFirstMut(chunk); if (_22 !== undefined) { _22.v = _22.v ^ 4660; } - if (rt.usizeRem(i, 3) === 2) { + if (rs.usizeRem(i, 3) === 2) { chunk.fill(i & 0xffff); } - const iter: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksMut(chunk, 2)); + const iter: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceChunksMut(chunk, 2)); while (true) { - const _34: [rt.usize, rt.u16[]] | rt.Done = iter.next(); - if (_34 === rt.DONE) { + const _34: [rs.usize, rs.u16[]] | rs.Done = iter.next(); + if (_34 === rs.DONE) { break; } - const j: rt.usize = _34[0]; - rt.idx(_34[1], 0); - const _39: rt.u16 = rt.u16WrappingAdd(_34[1][0], j & 0xffff); - rt.idx(_34[1], 0); + const j: rs.usize = _34[0]; + rs.idx(_34[1], 0); + const _39: rs.u16 = rs.u16WrappingAdd(_34[1][0], j & 0xffff); + rs.idx(_34[1], 0); _34[1][0] = _39; } } -export function scribblePairs(i: rt.usize, chunk: Pair.Pair[]): void { - const n: rt.usize = chunk.length; - rt.idx(chunk, 0); - const _5: rt.u8 = rt.u8WrappingAdd(chunk[0].a, i & 0xff); - rt.idx(chunk, 0); +export function scribblePairs(i: rs.usize, chunk: Pair.Pair[]): void { + const n: rs.usize = chunk.length; + rs.idx(chunk, 0); + const _5: rs.u8 = rs.u8WrappingAdd(chunk[0].a, i & 0xff); + rs.idx(chunk, 0); chunk[0].a = _5; - const _19: rt.usize = rt.usizeSub(n, 1); - rt.idx(chunk, _19); - const _17: rt.u8 = chunk[_19].b & 0xff; - rt.idx(chunk, 0); - const _16: Pair.Pair = { a: _17, b: chunk[0].a as rt.u16 }; - const _30: rt.usize = rt.usizeSub(n, 1); - rt.idx(chunk, _30); + const _19: rs.usize = rs.usizeSub(n, 1); + rs.idx(chunk, _19); + const _17: rs.u8 = chunk[_19].b & 0xff; + rs.idx(chunk, 0); + const _16: Pair.Pair = { a: _17, b: chunk[0].a as rs.u16 }; + const _30: rs.usize = rs.usizeSub(n, 1); + rs.idx(chunk, _30); chunk[_30] = _16; - rt.sliceSort(chunk, rt.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); - rt.sliceSwap(chunk, 0, rt.usizeDiv(n, 2)); + rs.sliceSort(chunk, rs.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); + rs.sliceSwap(chunk, 0, rs.usizeDiv(n, 2)); } -export function digestPairs(part: Pair.Pair[]): rt.u8 { - return rt.iterFold(rt.iterSlice(part), part.length & 0xff, (acc: rt.u8, p: Pair.Pair): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ p.a ^ ((p.b >> 4) & 0xff); +export function digestPairs(part: Pair.Pair[]): rs.u8 { + return rs.iterFold(rs.iterSlice(part), part.length & 0xff, (acc: rs.u8, p: Pair.Pair): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ p.a ^ ((p.b >> 4) & 0xff); }); } @@ -203,741 +203,741 @@ export function digestPairs(part: Pair.Pair[]): rt.u8 { * `chunks`, as `kind` picks, of a size it picks too, which is 0 one time in six, which * panics. */ -export function chunked(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const size: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 6) as rt.usize; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); +export function chunked(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const size: rs.usize = rs.u8Rem(rs.u8Div(kind, 8), 6) as rs.usize; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): Pair.Pair => { - const b2: rt.u8 = _25; - return { a: b2, b: rt.u16Mul(b2 as rt.u16, 3) }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): Pair.Pair => { + const b2: rs.u8 = _25; + return { a: b2, b: rs.u16Mul(b2 as rs.u16, 3) }; }), undefined, 4, true); b0: { - const _16: rt.u8 = rt.u8Rem(kind, 8); + const _16: rs.u8 = rs.u8Rem(kind, 8); if (_16 === 0) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceChunksExact(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceChunksExact(data, size)), digest), undefined, true); - const it: rt.Iter = rt.byteSliceChunksExact(data, size); - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it, 1), digest)), undefined, true); - rt.byteVecPush(out, it.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceChunksExact(data, size)), digest)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceChunksExact(data, size), 2), 2), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceChunksExact(words.items, size), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceChunksExact(words.items, size)), digestWords), undefined, true); - const it2: rt.Iter = rt.sliceChunksExact(words.items, size); - rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it2.next()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it2.nextBack()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNth(it2, 1), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNthBack(it2, 1), digestWords)), undefined, true); - rt.byteVecPush(out, it2.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it2, digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterLast(rt.sliceChunksExact(words.items, size)), digestWords)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExact(words.items, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceChunksExact(words.items, size), 2), 2), digestWords), undefined, true); - const it3: rt.Iter = rt.byteSliceChunksExact(data, size); - rt.byteVecPush(out, digest(rt.partsRemainder(it3))); + rs.iterExtendBytes(out, rs.iterMap(rs.byteSliceChunksExact(data, size), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.byteSliceChunksExact(data, size)), digest), undefined, true); + const it: rs.Iter = rs.byteSliceChunksExact(data, size); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it.next()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it.nextBack()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNth(it, 1), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNthBack(it, 1), digest)), undefined, true); + rs.byteVecPush(out, it.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it, digest), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterLast(rs.byteSliceChunksExact(data, size)), digest)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceChunksExact(data, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.byteSliceChunksExact(data, size), 2), 2), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceChunksExact(words.items, size), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.sliceChunksExact(words.items, size)), digestWords), undefined, true); + const it2: rs.Iter = rs.sliceChunksExact(words.items, size); + rs.byteVecPush(out, it2.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it2.next()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it2.nextBack()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNth(it2, 1), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNthBack(it2, 1), digestWords)), undefined, true); + rs.byteVecPush(out, it2.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it2, digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterLast(rs.sliceChunksExact(words.items, size)), digestWords)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunksExact(words.items, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.sliceChunksExact(words.items, size), 2), 2), digestWords), undefined, true); + const it3: rs.Iter = rs.byteSliceChunksExact(data, size); + rs.byteVecPush(out, digest(rs.partsRemainder(it3))); it3.next(); - rt.iterToOption(it3.nextBack()); - rt.byteVecPush(out, digest(rt.partsRemainder(it3))); - rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceChunksExact(words.items, size)))); + rs.iterToOption(it3.nextBack()); + rs.byteVecPush(out, digest(rs.partsRemainder(it3))); + rs.byteVecPush(out, digestWords(rs.partsRemainder(rs.sliceChunksExact(words.items, size)))); } else if (_16 === 1) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunks(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunks(data, size)), digest), undefined, true); - const it4: rt.Iter = rt.byteSliceRchunks(data, size); - rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it4.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it4, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it4, 1), digest)), undefined, true); - rt.byteVecPush(out, it4.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it4, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunks(data, size)), digest)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunks(data, size), 2), 2), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunks(words.items, size), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunks(words.items, size)), digestWords), undefined, true); - const it5: rt.Iter = rt.sliceRchunks(words.items, size); - rt.byteVecPush(out, it5.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it5.next()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it5.nextBack()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNth(it5, 1), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNthBack(it5, 1), digestWords)), undefined, true); - rt.byteVecPush(out, it5.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it5, digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterLast(rt.sliceRchunks(words.items, size)), digestWords)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunks(words.items, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunks(words.items, size), 2), 2), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.iterToOption(rt.byteSliceRchunks(data, size).nextBack()), (c13: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.byteSliceRchunks(data, size), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.byteSliceRchunks(data, size)), digest), undefined, true); + const it4: rs.Iter = rs.byteSliceRchunks(data, size); + rs.byteVecPush(out, it4.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it4.next()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it4.nextBack()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNth(it4, 1), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNthBack(it4, 1), digest)), undefined, true); + rs.byteVecPush(out, it4.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it4, digest), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterLast(rs.byteSliceRchunks(data, size)), digest)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRchunks(data, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.byteSliceRchunks(data, size), 2), 2), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceRchunks(words.items, size), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.sliceRchunks(words.items, size)), digestWords), undefined, true); + const it5: rs.Iter = rs.sliceRchunks(words.items, size); + rs.byteVecPush(out, it5.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it5.next()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it5.nextBack()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNth(it5, 1), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNthBack(it5, 1), digestWords)), undefined, true); + rs.byteVecPush(out, it5.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it5, digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterLast(rs.sliceRchunks(words.items, size)), digestWords)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunks(words.items, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.sliceRchunks(words.items, size), 2), 2), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.iterToOption(rs.byteSliceRchunks(data, size).nextBack()), (c13: rs.ByteSlice): rs.u8 => { return c13.length & 0xff; })), undefined, true); } else if (_16 === 2) { - rt.iterExtendBytes(out, rt.iterMap(rt.byteSliceRchunksExact(data, size), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.byteSliceRchunksExact(data, size)), digest), undefined, true); - const it6: rt.Iter = rt.byteSliceRchunksExact(data, size); - rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.next()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterToOption(it6.nextBack()), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNth(it6, 1), digest)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterNthBack(it6, 1), digest)), undefined, true); - rt.byteVecPush(out, it6.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it6, digest), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1xk4yz1(rt.iterLast(rt.byteSliceRchunksExact(data, size)), digest)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(data, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.byteSliceRchunksExact(data, size), 2), 2), digest), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.sliceRchunksExact(words.items, size), digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.sliceRchunksExact(words.items, size)), digestWords), undefined, true); - const it7: rt.Iter = rt.sliceRchunksExact(words.items, size); - rt.byteVecPush(out, it7.len() & 0xff); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it7.next()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterToOption(it7.nextBack()), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNth(it7, 1), digestWords)), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterNthBack(it7, 1), digestWords)), undefined, true); - rt.byteVecPush(out, it7.len() & 0xff); - rt.iterExtendBytes(out, rt.iterMap(it7, digestWords), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0qyyft9(rt.iterLast(rt.sliceRchunksExact(words.items, size)), digestWords)), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExact(words.items, size)) & 0xff); - rt.iterExtendBytes(out, rt.iterMap(rt.iterStepBy(rt.iterSkip(rt.sliceRchunksExact(words.items, size), 2), 2), digestWords), undefined, true); - const it8: rt.Iter = rt.byteSliceRchunksExact(data, size); - rt.byteVecPush(out, digest(rt.partsRemainder(it8))); - rt.iterNth(it8, 1); - rt.byteVecPush(out, digest(rt.partsRemainder(it8))); - rt.byteVecPush(out, digestWords(rt.partsRemainder(rt.sliceRchunksExact(words.items, size)))); + rs.iterExtendBytes(out, rs.iterMap(rs.byteSliceRchunksExact(data, size), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.byteSliceRchunksExact(data, size)), digest), undefined, true); + const it6: rs.Iter = rs.byteSliceRchunksExact(data, size); + rs.byteVecPush(out, it6.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it6.next()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterToOption(it6.nextBack()), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNth(it6, 1), digest)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterNthBack(it6, 1), digest)), undefined, true); + rs.byteVecPush(out, it6.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it6, digest), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$0vk4zok(rs.iterLast(rs.byteSliceRchunksExact(data, size)), digest)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRchunksExact(data, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.byteSliceRchunksExact(data, size), 2), 2), digest), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.sliceRchunksExact(words.items, size), digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.sliceRchunksExact(words.items, size)), digestWords), undefined, true); + const it7: rs.Iter = rs.sliceRchunksExact(words.items, size); + rs.byteVecPush(out, it7.len() & 0xff); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it7.next()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterToOption(it7.nextBack()), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNth(it7, 1), digestWords)), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterNthBack(it7, 1), digestWords)), undefined, true); + rs.byteVecPush(out, it7.len() & 0xff); + rs.iterExtendBytes(out, rs.iterMap(it7, digestWords), undefined, true); + rs.iterExtendBytes(out, rs.iterOption(option_map$07x3qxw(rs.iterLast(rs.sliceRchunksExact(words.items, size)), digestWords)), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunksExact(words.items, size)) & 0xff); + rs.iterExtendBytes(out, rs.iterMap(rs.iterStepBy(rs.iterSkip(rs.sliceRchunksExact(words.items, size), 2), 2), digestWords), undefined, true); + const it8: rs.Iter = rs.byteSliceRchunksExact(data, size); + rs.byteVecPush(out, digest(rs.partsRemainder(it8))); + rs.iterNth(it8, 1); + rs.byteVecPush(out, digest(rs.partsRemainder(it8))); + rs.byteVecPush(out, digestWords(rs.partsRemainder(rs.sliceRchunksExact(words.items, size)))); } else if (_16 === 3) { - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceChunks(rs.byteVecSlice(bytes), size)); while (true) { - const _391: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_391 === rt.DONE) { + const _391: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_391 === rs.DONE) { break; } scribble(_391[0], _391[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held: rt.Vec = rt.iterToVec(rt.byteSliceChunks(rt.byteVecSlice(bytes), size), undefined, 8, true); - const iter2: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held.items))); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const held: rs.Vec = rs.iterToVec(rs.byteSliceChunks(rs.byteVecSlice(bytes), size), undefined, 8, true); + const iter2: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held.items))); while (true) { - const _412: [rt.usize, rt.Place] | rt.Done = iter2.next(); - if (_412 === rt.DONE) { + const _412: [rs.usize, rs.Place] | rs.Done = iter2.next(); + if (_412 === rs.DONE) { break; } - scribble(rt.usizeAdd(_412[0], 7), _412[1].v); + scribble(rs.usizeAdd(_412[0], 7), _412[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held.items), (c10: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held.items), (c10: rs.ByteSlice): rs.u8 => { return digest(c10); }), undefined, true); - const it9: rt.Iter = rt.byteSliceChunks(rt.byteVecSlice(bytes), size); - rt.byteVecPush(out, it9.len() & 0xff); - const _432: rt.ByteSlice | undefined = rt.iterToOption(it9.nextBack()); + const it9: rs.Iter = rs.byteSliceChunks(rs.byteVecSlice(bytes), size); + rs.byteVecPush(out, it9.len() & 0xff); + const _432: rs.ByteSlice | undefined = rs.iterToOption(it9.nextBack()); if (_432 !== undefined) { scribble(1, _432); } - const _437: rt.ByteSlice | undefined = rt.iterNth(it9, 1); + const _437: rs.ByteSlice | undefined = rs.iterNth(it9, 1); if (_437 !== undefined) { scribble(2, _437); } - const _442: rt.ByteSlice | undefined = rt.iterNthBack(it9, 1); + const _442: rs.ByteSlice | undefined = rs.iterNthBack(it9, 1); if (_442 !== undefined) { scribble(3, _442); } - rt.byteVecPush(out, it9.len() & 0xff); - const _451: rt.ByteSlice | undefined = rt.iterLast(it9); + rs.byteVecPush(out, it9.len() & 0xff); + const _451: rs.ByteSlice | undefined = rs.iterLast(it9); if (_451 !== undefined) { scribble(4, _451); } - rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunks(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const iter3: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksMut(words.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceChunks(rs.byteVecSlice(bytes), size)) & 0xff); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const iter3: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceChunksMut(words.items, size)); while (true) { - const _472: [rt.usize, rt.u16[]] | rt.Done = iter3.next(); - if (_472 === rt.DONE) { + const _472: [rs.usize, rs.u16[]] | rs.Done = iter3.next(); + if (_472 === rs.DONE) { break; } scribbleWords(_472[0], _472[1]); } - rt.byteVecPush(out, digestWords(words.items)); - const held2: rt.Vec = rt.iterToVec(rt.sliceChunksMut(words.items, size), undefined, 8, true); - const iter4: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held2.items))); + rs.byteVecPush(out, digestWords(words.items)); + const held2: rs.Vec = rs.iterToVec(rs.sliceChunksMut(words.items, size), undefined, 8, true); + const iter4: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held2.items))); while (true) { - const _493: [rt.usize, rt.Place] | rt.Done = iter4.next(); - if (_493 === rt.DONE) { + const _493: [rs.usize, rs.Place] | rs.Done = iter4.next(); + if (_493 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_493[0], 7), _493[1].v); + scribbleWords(rs.usizeAdd(_493[0], 7), _493[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held2.items), (c11: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held2.items), (c11: rs.u16[]): rs.u8 => { return digestWords(c11); }), undefined, true); - const it10: rt.Iter = rt.sliceChunksMut(words.items, size); - rt.byteVecPush(out, it10.len() & 0xff); - const _513: rt.u16[] | undefined = rt.iterToOption(it10.nextBack()); + const it10: rs.Iter = rs.sliceChunksMut(words.items, size); + rs.byteVecPush(out, it10.len() & 0xff); + const _513: rs.u16[] | undefined = rs.iterToOption(it10.nextBack()); if (_513 !== undefined) { scribbleWords(1, _513); } - const _518: rt.u16[] | undefined = rt.iterNth(it10, 1); + const _518: rs.u16[] | undefined = rs.iterNth(it10, 1); if (_518 !== undefined) { scribbleWords(2, _518); } - const _523: rt.u16[] | undefined = rt.iterNthBack(it10, 1); + const _523: rs.u16[] | undefined = rs.iterNthBack(it10, 1); if (_523 !== undefined) { scribbleWords(3, _523); } - rt.byteVecPush(out, it10.len() & 0xff); - const _532: rt.u16[] | undefined = rt.iterLast(it10); + rs.byteVecPush(out, it10.len() & 0xff); + const _532: rs.u16[] | undefined = rs.iterLast(it10); if (_532 !== undefined) { scribbleWords(4, _532); } - rt.byteVecPush(out, rt.iterCount(rt.sliceChunksMut(words.items, size)) & 0xff); - rt.byteVecPush(out, digestWords(words.items)); - const iter5: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceChunksMut(pairs.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunksMut(words.items, size)) & 0xff); + rs.byteVecPush(out, digestWords(words.items)); + const iter5: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceChunksMut(pairs.items, size)); while (true) { - const _553: [rt.usize, Pair.Pair[]] | rt.Done = iter5.next(); - if (_553 === rt.DONE) { + const _553: [rs.usize, Pair.Pair[]] | rs.Done = iter5.next(); + if (_553 === rs.DONE) { break; } scribblePairs(_553[0], _553[1]); } - rt.byteVecPush(out, digestPairs(pairs.items)); - const held3: rt.Vec = rt.iterToVec(rt.sliceChunksMut(pairs.items, size), undefined, 8, true); - const iter6: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held3.items))); + rs.byteVecPush(out, digestPairs(pairs.items)); + const held3: rs.Vec = rs.iterToVec(rs.sliceChunksMut(pairs.items, size), undefined, 8, true); + const iter6: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held3.items))); while (true) { - const _574: [rt.usize, rt.Place] | rt.Done = iter6.next(); - if (_574 === rt.DONE) { + const _574: [rs.usize, rs.Place] | rs.Done = iter6.next(); + if (_574 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_574[0], 7), _574[1].v); + scribblePairs(rs.usizeAdd(_574[0], 7), _574[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held3.items), (c12: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held3.items), (c12: Pair.Pair[]): rs.u8 => { return digestPairs(c12); }), undefined, true); - const it11: rt.Iter = rt.sliceChunksMut(pairs.items, size); - rt.byteVecPush(out, it11.len() & 0xff); - const _594: Pair.Pair[] | undefined = rt.iterToOption(it11.nextBack()); + const it11: rs.Iter = rs.sliceChunksMut(pairs.items, size); + rs.byteVecPush(out, it11.len() & 0xff); + const _594: Pair.Pair[] | undefined = rs.iterToOption(it11.nextBack()); if (_594 !== undefined) { scribblePairs(1, _594); } - const _599: Pair.Pair[] | undefined = rt.iterNth(it11, 1); + const _599: Pair.Pair[] | undefined = rs.iterNth(it11, 1); if (_599 !== undefined) { scribblePairs(2, _599); } - const _604: Pair.Pair[] | undefined = rt.iterNthBack(it11, 1); + const _604: Pair.Pair[] | undefined = rs.iterNthBack(it11, 1); if (_604 !== undefined) { scribblePairs(3, _604); } - rt.byteVecPush(out, it11.len() & 0xff); - const _613: Pair.Pair[] | undefined = rt.iterLast(it11); + rs.byteVecPush(out, it11.len() & 0xff); + const _613: Pair.Pair[] | undefined = rs.iterLast(it11); if (_613 !== undefined) { scribblePairs(4, _613); } - rt.byteVecPush(out, rt.iterCount(rt.sliceChunksMut(pairs.items, size)) & 0xff); - rt.byteVecPush(out, digestPairs(pairs.items)); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunksMut(pairs.items, size)) & 0xff); + rs.byteVecPush(out, digestPairs(pairs.items)); } else if (_16 === 4) { - const iter7: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size)); + const iter7: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceChunksExact(rs.byteVecSlice(bytes), size)); while (true) { - const _634: [rt.usize, rt.ByteSlice] | rt.Done = iter7.next(); - if (_634 === rt.DONE) { + const _634: [rs.usize, rs.ByteSlice] | rs.Done = iter7.next(); + if (_634 === rs.DONE) { break; } scribble(_634[0], _634[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held4: rt.Vec = rt.iterToVec(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); - const iter8: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held4.items))); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const held4: rs.Vec = rs.iterToVec(rs.byteSliceChunksExact(rs.byteVecSlice(bytes), size), undefined, 8, true); + const iter8: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held4.items))); while (true) { - const _655: [rt.usize, rt.Place] | rt.Done = iter8.next(); - if (_655 === rt.DONE) { + const _655: [rs.usize, rs.Place] | rs.Done = iter8.next(); + if (_655 === rs.DONE) { break; } - scribble(rt.usizeAdd(_655[0], 7), _655[1].v); + scribble(rs.usizeAdd(_655[0], 7), _655[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held4.items), (c7: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held4.items), (c7: rs.ByteSlice): rs.u8 => { return digest(c7); }), undefined, true); - const it12: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size); - rt.byteVecPush(out, it12.len() & 0xff); - const _675: rt.ByteSlice | undefined = rt.iterToOption(it12.nextBack()); + const it12: rs.Iter = rs.byteSliceChunksExact(rs.byteVecSlice(bytes), size); + rs.byteVecPush(out, it12.len() & 0xff); + const _675: rs.ByteSlice | undefined = rs.iterToOption(it12.nextBack()); if (_675 !== undefined) { scribble(1, _675); } - const _680: rt.ByteSlice | undefined = rt.iterNth(it12, 1); + const _680: rs.ByteSlice | undefined = rs.iterNth(it12, 1); if (_680 !== undefined) { scribble(2, _680); } - const _685: rt.ByteSlice | undefined = rt.iterNthBack(it12, 1); + const _685: rs.ByteSlice | undefined = rs.iterNthBack(it12, 1); if (_685 !== undefined) { scribble(3, _685); } - rt.byteVecPush(out, it12.len() & 0xff); - const _694: rt.ByteSlice | undefined = rt.iterLast(it12); + rs.byteVecPush(out, it12.len() & 0xff); + const _694: rs.ByteSlice | undefined = rs.iterLast(it12); if (_694 !== undefined) { scribble(4, _694); } - rt.byteVecPush(out, rt.iterCount(rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const iter9: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksExactMut(words.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceChunksExact(rs.byteVecSlice(bytes), size)) & 0xff); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const iter9: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceChunksExactMut(words.items, size)); while (true) { - const _715: [rt.usize, rt.u16[]] | rt.Done = iter9.next(); - if (_715 === rt.DONE) { + const _715: [rs.usize, rs.u16[]] | rs.Done = iter9.next(); + if (_715 === rs.DONE) { break; } scribbleWords(_715[0], _715[1]); } - rt.byteVecPush(out, digestWords(words.items)); - const held5: rt.Vec = rt.iterToVec(rt.sliceChunksExactMut(words.items, size), undefined, 8, true); - const iter10: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held5.items))); + rs.byteVecPush(out, digestWords(words.items)); + const held5: rs.Vec = rs.iterToVec(rs.sliceChunksExactMut(words.items, size), undefined, 8, true); + const iter10: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held5.items))); while (true) { - const _736: [rt.usize, rt.Place] | rt.Done = iter10.next(); - if (_736 === rt.DONE) { + const _736: [rs.usize, rs.Place] | rs.Done = iter10.next(); + if (_736 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_736[0], 7), _736[1].v); + scribbleWords(rs.usizeAdd(_736[0], 7), _736[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held5.items), (c8: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held5.items), (c8: rs.u16[]): rs.u8 => { return digestWords(c8); }), undefined, true); - const it13: rt.Iter = rt.sliceChunksExactMut(words.items, size); - rt.byteVecPush(out, it13.len() & 0xff); - const _756: rt.u16[] | undefined = rt.iterToOption(it13.nextBack()); + const it13: rs.Iter = rs.sliceChunksExactMut(words.items, size); + rs.byteVecPush(out, it13.len() & 0xff); + const _756: rs.u16[] | undefined = rs.iterToOption(it13.nextBack()); if (_756 !== undefined) { scribbleWords(1, _756); } - const _761: rt.u16[] | undefined = rt.iterNth(it13, 1); + const _761: rs.u16[] | undefined = rs.iterNth(it13, 1); if (_761 !== undefined) { scribbleWords(2, _761); } - const _766: rt.u16[] | undefined = rt.iterNthBack(it13, 1); + const _766: rs.u16[] | undefined = rs.iterNthBack(it13, 1); if (_766 !== undefined) { scribbleWords(3, _766); } - rt.byteVecPush(out, it13.len() & 0xff); - const _775: rt.u16[] | undefined = rt.iterLast(it13); + rs.byteVecPush(out, it13.len() & 0xff); + const _775: rs.u16[] | undefined = rs.iterLast(it13); if (_775 !== undefined) { scribbleWords(4, _775); } - rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExactMut(words.items, size)) & 0xff); - rt.byteVecPush(out, digestWords(words.items)); - const iter11: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceChunksExactMut(pairs.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunksExactMut(words.items, size)) & 0xff); + rs.byteVecPush(out, digestWords(words.items)); + const iter11: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceChunksExactMut(pairs.items, size)); while (true) { - const _796: [rt.usize, Pair.Pair[]] | rt.Done = iter11.next(); - if (_796 === rt.DONE) { + const _796: [rs.usize, Pair.Pair[]] | rs.Done = iter11.next(); + if (_796 === rs.DONE) { break; } scribblePairs(_796[0], _796[1]); } - rt.byteVecPush(out, digestPairs(pairs.items)); - const held6: rt.Vec = rt.iterToVec(rt.sliceChunksExactMut(pairs.items, size), undefined, 8, true); - const iter12: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held6.items))); + rs.byteVecPush(out, digestPairs(pairs.items)); + const held6: rs.Vec = rs.iterToVec(rs.sliceChunksExactMut(pairs.items, size), undefined, 8, true); + const iter12: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held6.items))); while (true) { - const _817: [rt.usize, rt.Place] | rt.Done = iter12.next(); - if (_817 === rt.DONE) { + const _817: [rs.usize, rs.Place] | rs.Done = iter12.next(); + if (_817 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_817[0], 7), _817[1].v); + scribblePairs(rs.usizeAdd(_817[0], 7), _817[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held6.items), (c9: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held6.items), (c9: Pair.Pair[]): rs.u8 => { return digestPairs(c9); }), undefined, true); - const it14: rt.Iter = rt.sliceChunksExactMut(pairs.items, size); - rt.byteVecPush(out, it14.len() & 0xff); - const _837: Pair.Pair[] | undefined = rt.iterToOption(it14.nextBack()); + const it14: rs.Iter = rs.sliceChunksExactMut(pairs.items, size); + rs.byteVecPush(out, it14.len() & 0xff); + const _837: Pair.Pair[] | undefined = rs.iterToOption(it14.nextBack()); if (_837 !== undefined) { scribblePairs(1, _837); } - const _842: Pair.Pair[] | undefined = rt.iterNth(it14, 1); + const _842: Pair.Pair[] | undefined = rs.iterNth(it14, 1); if (_842 !== undefined) { scribblePairs(2, _842); } - const _847: Pair.Pair[] | undefined = rt.iterNthBack(it14, 1); + const _847: Pair.Pair[] | undefined = rs.iterNthBack(it14, 1); if (_847 !== undefined) { scribblePairs(3, _847); } - rt.byteVecPush(out, it14.len() & 0xff); - const _856: Pair.Pair[] | undefined = rt.iterLast(it14); + rs.byteVecPush(out, it14.len() & 0xff); + const _856: Pair.Pair[] | undefined = rs.iterLast(it14); if (_856 !== undefined) { scribblePairs(4, _856); } - rt.byteVecPush(out, rt.iterCount(rt.sliceChunksExactMut(pairs.items, size)) & 0xff); - rt.byteVecPush(out, digestPairs(pairs.items)); - const it15: rt.Iter = rt.byteSliceChunksExact(rt.byteVecSlice(bytes), size); + rs.byteVecPush(out, rs.iterCount(rs.sliceChunksExactMut(pairs.items, size)) & 0xff); + rs.byteVecPush(out, digestPairs(pairs.items)); + const it15: rs.Iter = rs.byteSliceChunksExact(rs.byteVecSlice(bytes), size); it15.next(); - rt.byteSliceView(rt.partsRemainder(it15)).reverse(); - const it16: rt.Iter = rt.sliceChunksExactMut(words.items, size); - rt.iterToOption(it16.nextBack()); - const iter13: rt.Iter> = rt.iterSliceMut(rt.partsRemainder(it16)); + rs.byteSliceView(rs.partsRemainder(it15)).reverse(); + const it16: rs.Iter = rs.sliceChunksExactMut(words.items, size); + rs.iterToOption(it16.nextBack()); + const iter13: rs.Iter> = rs.iterSliceMut(rs.partsRemainder(it16)); while (true) { - const _888: rt.Place | rt.Done = iter13.next(); - if (_888 === rt.DONE) { + const _888: rs.Place | rs.Done = iter13.next(); + if (_888 === rs.DONE) { break; } - _888.v = rt.u16WrappingAdd(_888.v, 1); + _888.v = rs.u16WrappingAdd(_888.v, 1); } - const _894: Pair.Pair | undefined = rt.sliceFirst(rt.partsRemainder(rt.sliceChunksExactMut(pairs.items, size))); + const _894: Pair.Pair | undefined = rs.sliceFirst(rs.partsRemainder(rs.sliceChunksExactMut(pairs.items, size))); if (_894 !== undefined) { Object.assign(_894, { a: 238, b: 61166 }); } } else if (_16 === 5) { - const iter14: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size)); + const iter14: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceRchunks(rs.byteVecSlice(bytes), size)); while (true) { - const _908: [rt.usize, rt.ByteSlice] | rt.Done = iter14.next(); - if (_908 === rt.DONE) { + const _908: [rs.usize, rs.ByteSlice] | rs.Done = iter14.next(); + if (_908 === rs.DONE) { break; } scribble(_908[0], _908[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held7: rt.Vec = rt.iterToVec(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size), undefined, 8, true); - const iter15: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held7.items))); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const held7: rs.Vec = rs.iterToVec(rs.byteSliceRchunks(rs.byteVecSlice(bytes), size), undefined, 8, true); + const iter15: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held7.items))); while (true) { - const _929: [rt.usize, rt.Place] | rt.Done = iter15.next(); - if (_929 === rt.DONE) { + const _929: [rs.usize, rs.Place] | rs.Done = iter15.next(); + if (_929 === rs.DONE) { break; } - scribble(rt.usizeAdd(_929[0], 7), _929[1].v); + scribble(rs.usizeAdd(_929[0], 7), _929[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held7.items), (c4: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held7.items), (c4: rs.ByteSlice): rs.u8 => { return digest(c4); }), undefined, true); - const it17: rt.Iter = rt.byteSliceRchunks(rt.byteVecSlice(bytes), size); - rt.byteVecPush(out, it17.len() & 0xff); - const _949: rt.ByteSlice | undefined = rt.iterToOption(it17.nextBack()); + const it17: rs.Iter = rs.byteSliceRchunks(rs.byteVecSlice(bytes), size); + rs.byteVecPush(out, it17.len() & 0xff); + const _949: rs.ByteSlice | undefined = rs.iterToOption(it17.nextBack()); if (_949 !== undefined) { scribble(1, _949); } - const _954: rt.ByteSlice | undefined = rt.iterNth(it17, 1); + const _954: rs.ByteSlice | undefined = rs.iterNth(it17, 1); if (_954 !== undefined) { scribble(2, _954); } - const _959: rt.ByteSlice | undefined = rt.iterNthBack(it17, 1); + const _959: rs.ByteSlice | undefined = rs.iterNthBack(it17, 1); if (_959 !== undefined) { scribble(3, _959); } - rt.byteVecPush(out, it17.len() & 0xff); - const _968: rt.ByteSlice | undefined = rt.iterLast(it17); + rs.byteVecPush(out, it17.len() & 0xff); + const _968: rs.ByteSlice | undefined = rs.iterLast(it17); if (_968 !== undefined) { scribble(4, _968); } - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunks(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const iter16: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksMut(words.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRchunks(rs.byteVecSlice(bytes), size)) & 0xff); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const iter16: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceRchunksMut(words.items, size)); while (true) { - const _989: [rt.usize, rt.u16[]] | rt.Done = iter16.next(); - if (_989 === rt.DONE) { + const _989: [rs.usize, rs.u16[]] | rs.Done = iter16.next(); + if (_989 === rs.DONE) { break; } scribbleWords(_989[0], _989[1]); } - rt.byteVecPush(out, digestWords(words.items)); - const held8: rt.Vec = rt.iterToVec(rt.sliceRchunksMut(words.items, size), undefined, 8, true); - const iter17: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held8.items))); + rs.byteVecPush(out, digestWords(words.items)); + const held8: rs.Vec = rs.iterToVec(rs.sliceRchunksMut(words.items, size), undefined, 8, true); + const iter17: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held8.items))); while (true) { - const _1010: [rt.usize, rt.Place] | rt.Done = iter17.next(); - if (_1010 === rt.DONE) { + const _1010: [rs.usize, rs.Place] | rs.Done = iter17.next(); + if (_1010 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_1010[0], 7), _1010[1].v); + scribbleWords(rs.usizeAdd(_1010[0], 7), _1010[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held8.items), (c5: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held8.items), (c5: rs.u16[]): rs.u8 => { return digestWords(c5); }), undefined, true); - const it18: rt.Iter = rt.sliceRchunksMut(words.items, size); - rt.byteVecPush(out, it18.len() & 0xff); - const _1030: rt.u16[] | undefined = rt.iterToOption(it18.nextBack()); + const it18: rs.Iter = rs.sliceRchunksMut(words.items, size); + rs.byteVecPush(out, it18.len() & 0xff); + const _1030: rs.u16[] | undefined = rs.iterToOption(it18.nextBack()); if (_1030 !== undefined) { scribbleWords(1, _1030); } - const _1035: rt.u16[] | undefined = rt.iterNth(it18, 1); + const _1035: rs.u16[] | undefined = rs.iterNth(it18, 1); if (_1035 !== undefined) { scribbleWords(2, _1035); } - const _1040: rt.u16[] | undefined = rt.iterNthBack(it18, 1); + const _1040: rs.u16[] | undefined = rs.iterNthBack(it18, 1); if (_1040 !== undefined) { scribbleWords(3, _1040); } - rt.byteVecPush(out, it18.len() & 0xff); - const _1049: rt.u16[] | undefined = rt.iterLast(it18); + rs.byteVecPush(out, it18.len() & 0xff); + const _1049: rs.u16[] | undefined = rs.iterLast(it18); if (_1049 !== undefined) { scribbleWords(4, _1049); } - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksMut(words.items, size)) & 0xff); - rt.byteVecPush(out, digestWords(words.items)); - const iter18: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceRchunksMut(pairs.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunksMut(words.items, size)) & 0xff); + rs.byteVecPush(out, digestWords(words.items)); + const iter18: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceRchunksMut(pairs.items, size)); while (true) { - const _1070: [rt.usize, Pair.Pair[]] | rt.Done = iter18.next(); - if (_1070 === rt.DONE) { + const _1070: [rs.usize, Pair.Pair[]] | rs.Done = iter18.next(); + if (_1070 === rs.DONE) { break; } scribblePairs(_1070[0], _1070[1]); } - rt.byteVecPush(out, digestPairs(pairs.items)); - const held9: rt.Vec = rt.iterToVec(rt.sliceRchunksMut(pairs.items, size), undefined, 8, true); - const iter19: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held9.items))); + rs.byteVecPush(out, digestPairs(pairs.items)); + const held9: rs.Vec = rs.iterToVec(rs.sliceRchunksMut(pairs.items, size), undefined, 8, true); + const iter19: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held9.items))); while (true) { - const _1091: [rt.usize, rt.Place] | rt.Done = iter19.next(); - if (_1091 === rt.DONE) { + const _1091: [rs.usize, rs.Place] | rs.Done = iter19.next(); + if (_1091 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_1091[0], 7), _1091[1].v); + scribblePairs(rs.usizeAdd(_1091[0], 7), _1091[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held9.items), (c6: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held9.items), (c6: Pair.Pair[]): rs.u8 => { return digestPairs(c6); }), undefined, true); - const it19: rt.Iter = rt.sliceRchunksMut(pairs.items, size); - rt.byteVecPush(out, it19.len() & 0xff); - const _1111: Pair.Pair[] | undefined = rt.iterToOption(it19.nextBack()); + const it19: rs.Iter = rs.sliceRchunksMut(pairs.items, size); + rs.byteVecPush(out, it19.len() & 0xff); + const _1111: Pair.Pair[] | undefined = rs.iterToOption(it19.nextBack()); if (_1111 !== undefined) { scribblePairs(1, _1111); } - const _1116: Pair.Pair[] | undefined = rt.iterNth(it19, 1); + const _1116: Pair.Pair[] | undefined = rs.iterNth(it19, 1); if (_1116 !== undefined) { scribblePairs(2, _1116); } - const _1121: Pair.Pair[] | undefined = rt.iterNthBack(it19, 1); + const _1121: Pair.Pair[] | undefined = rs.iterNthBack(it19, 1); if (_1121 !== undefined) { scribblePairs(3, _1121); } - rt.byteVecPush(out, it19.len() & 0xff); - const _1130: Pair.Pair[] | undefined = rt.iterLast(it19); + rs.byteVecPush(out, it19.len() & 0xff); + const _1130: Pair.Pair[] | undefined = rs.iterLast(it19); if (_1130 !== undefined) { scribblePairs(4, _1130); } - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksMut(pairs.items, size)) & 0xff); - rt.byteVecPush(out, digestPairs(pairs.items)); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunksMut(pairs.items, size)) & 0xff); + rs.byteVecPush(out, digestPairs(pairs.items)); } else if (_16 === 6) { - const iter20: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)); + const iter20: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceRchunksExact(rs.byteVecSlice(bytes), size)); while (true) { - const _1151: [rt.usize, rt.ByteSlice] | rt.Done = iter20.next(); - if (_1151 === rt.DONE) { + const _1151: [rs.usize, rs.ByteSlice] | rs.Done = iter20.next(); + if (_1151 === rs.DONE) { break; } scribble(_1151[0], _1151[1]); } - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const held10: rt.Vec = rt.iterToVec(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size), undefined, 8, true); - const iter21: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held10.items))); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const held10: rs.Vec = rs.iterToVec(rs.byteSliceRchunksExact(rs.byteVecSlice(bytes), size), undefined, 8, true); + const iter21: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held10.items))); while (true) { - const _1172: [rt.usize, rt.Place] | rt.Done = iter21.next(); - if (_1172 === rt.DONE) { + const _1172: [rs.usize, rs.Place] | rs.Done = iter21.next(); + if (_1172 === rs.DONE) { break; } - scribble(rt.usizeAdd(_1172[0], 7), _1172[1].v); + scribble(rs.usizeAdd(_1172[0], 7), _1172[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held10.items), (c: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held10.items), (c: rs.ByteSlice): rs.u8 => { return digest(c); }), undefined, true); - const it20: rt.Iter = rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size); - rt.byteVecPush(out, it20.len() & 0xff); - const _1192: rt.ByteSlice | undefined = rt.iterToOption(it20.nextBack()); + const it20: rs.Iter = rs.byteSliceRchunksExact(rs.byteVecSlice(bytes), size); + rs.byteVecPush(out, it20.len() & 0xff); + const _1192: rs.ByteSlice | undefined = rs.iterToOption(it20.nextBack()); if (_1192 !== undefined) { scribble(1, _1192); } - const _1197: rt.ByteSlice | undefined = rt.iterNth(it20, 1); + const _1197: rs.ByteSlice | undefined = rs.iterNth(it20, 1); if (_1197 !== undefined) { scribble(2, _1197); } - const _1202: rt.ByteSlice | undefined = rt.iterNthBack(it20, 1); + const _1202: rs.ByteSlice | undefined = rs.iterNthBack(it20, 1); if (_1202 !== undefined) { scribble(3, _1202); } - rt.byteVecPush(out, it20.len() & 0xff); - const _1211: rt.ByteSlice | undefined = rt.iterLast(it20); + rs.byteVecPush(out, it20.len() & 0xff); + const _1211: rs.ByteSlice | undefined = rs.iterLast(it20); if (_1211 !== undefined) { scribble(4, _1211); } - rt.byteVecPush(out, rt.iterCount(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)) & 0xff); - rt.byteVecPush(out, digest(rt.byteVecSlice(bytes))); - const iter22: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceRchunksExactMut(words.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.byteSliceRchunksExact(rs.byteVecSlice(bytes), size)) & 0xff); + rs.byteVecPush(out, digest(rs.byteVecSlice(bytes))); + const iter22: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceRchunksExactMut(words.items, size)); while (true) { - const _1232: [rt.usize, rt.u16[]] | rt.Done = iter22.next(); - if (_1232 === rt.DONE) { + const _1232: [rs.usize, rs.u16[]] | rs.Done = iter22.next(); + if (_1232 === rs.DONE) { break; } scribbleWords(_1232[0], _1232[1]); } - rt.byteVecPush(out, digestWords(words.items)); - const held11: rt.Vec = rt.iterToVec(rt.sliceRchunksExactMut(words.items, size), undefined, 8, true); - const iter23: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held11.items))); + rs.byteVecPush(out, digestWords(words.items)); + const held11: rs.Vec = rs.iterToVec(rs.sliceRchunksExactMut(words.items, size), undefined, 8, true); + const iter23: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held11.items))); while (true) { - const _1253: [rt.usize, rt.Place] | rt.Done = iter23.next(); - if (_1253 === rt.DONE) { + const _1253: [rs.usize, rs.Place] | rs.Done = iter23.next(); + if (_1253 === rs.DONE) { break; } - scribbleWords(rt.usizeAdd(_1253[0], 7), _1253[1].v); + scribbleWords(rs.usizeAdd(_1253[0], 7), _1253[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held11.items), (c2: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held11.items), (c2: rs.u16[]): rs.u8 => { return digestWords(c2); }), undefined, true); - const it21: rt.Iter = rt.sliceRchunksExactMut(words.items, size); - rt.byteVecPush(out, it21.len() & 0xff); - const _1273: rt.u16[] | undefined = rt.iterToOption(it21.nextBack()); + const it21: rs.Iter = rs.sliceRchunksExactMut(words.items, size); + rs.byteVecPush(out, it21.len() & 0xff); + const _1273: rs.u16[] | undefined = rs.iterToOption(it21.nextBack()); if (_1273 !== undefined) { scribbleWords(1, _1273); } - const _1278: rt.u16[] | undefined = rt.iterNth(it21, 1); + const _1278: rs.u16[] | undefined = rs.iterNth(it21, 1); if (_1278 !== undefined) { scribbleWords(2, _1278); } - const _1283: rt.u16[] | undefined = rt.iterNthBack(it21, 1); + const _1283: rs.u16[] | undefined = rs.iterNthBack(it21, 1); if (_1283 !== undefined) { scribbleWords(3, _1283); } - rt.byteVecPush(out, it21.len() & 0xff); - const _1292: rt.u16[] | undefined = rt.iterLast(it21); + rs.byteVecPush(out, it21.len() & 0xff); + const _1292: rs.u16[] | undefined = rs.iterLast(it21); if (_1292 !== undefined) { scribbleWords(4, _1292); } - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExactMut(words.items, size)) & 0xff); - rt.byteVecPush(out, digestWords(words.items)); - const iter24: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceRchunksExactMut(pairs.items, size)); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunksExactMut(words.items, size)) & 0xff); + rs.byteVecPush(out, digestWords(words.items)); + const iter24: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceRchunksExactMut(pairs.items, size)); while (true) { - const _1313: [rt.usize, Pair.Pair[]] | rt.Done = iter24.next(); - if (_1313 === rt.DONE) { + const _1313: [rs.usize, Pair.Pair[]] | rs.Done = iter24.next(); + if (_1313 === rs.DONE) { break; } scribblePairs(_1313[0], _1313[1]); } - rt.byteVecPush(out, digestPairs(pairs.items)); - const held12: rt.Vec = rt.iterToVec(rt.sliceRchunksExactMut(pairs.items, size), undefined, 8, true); - const iter25: rt.Iter<[rt.usize, rt.Place]> = rt.iterRev(rt.iterEnumerate(rt.iterSliceMut(held12.items))); + rs.byteVecPush(out, digestPairs(pairs.items)); + const held12: rs.Vec = rs.iterToVec(rs.sliceRchunksExactMut(pairs.items, size), undefined, 8, true); + const iter25: rs.Iter<[rs.usize, rs.Place]> = rs.iterRev(rs.iterEnumerate(rs.iterSliceMut(held12.items))); while (true) { - const _1334: [rt.usize, rt.Place] | rt.Done = iter25.next(); - if (_1334 === rt.DONE) { + const _1334: [rs.usize, rs.Place] | rs.Done = iter25.next(); + if (_1334 === rs.DONE) { break; } - scribblePairs(rt.usizeAdd(_1334[0], 7), _1334[1].v); + scribblePairs(rs.usizeAdd(_1334[0], 7), _1334[1].v); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held12.items), (c3: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held12.items), (c3: Pair.Pair[]): rs.u8 => { return digestPairs(c3); }), undefined, true); - const it22: rt.Iter = rt.sliceRchunksExactMut(pairs.items, size); - rt.byteVecPush(out, it22.len() & 0xff); - const _1354: Pair.Pair[] | undefined = rt.iterToOption(it22.nextBack()); + const it22: rs.Iter = rs.sliceRchunksExactMut(pairs.items, size); + rs.byteVecPush(out, it22.len() & 0xff); + const _1354: Pair.Pair[] | undefined = rs.iterToOption(it22.nextBack()); if (_1354 !== undefined) { scribblePairs(1, _1354); } - const _1359: Pair.Pair[] | undefined = rt.iterNth(it22, 1); + const _1359: Pair.Pair[] | undefined = rs.iterNth(it22, 1); if (_1359 !== undefined) { scribblePairs(2, _1359); } - const _1364: Pair.Pair[] | undefined = rt.iterNthBack(it22, 1); + const _1364: Pair.Pair[] | undefined = rs.iterNthBack(it22, 1); if (_1364 !== undefined) { scribblePairs(3, _1364); } - rt.byteVecPush(out, it22.len() & 0xff); - const _1373: Pair.Pair[] | undefined = rt.iterLast(it22); + rs.byteVecPush(out, it22.len() & 0xff); + const _1373: Pair.Pair[] | undefined = rs.iterLast(it22); if (_1373 !== undefined) { scribblePairs(4, _1373); } - rt.byteVecPush(out, rt.iterCount(rt.sliceRchunksExactMut(pairs.items, size)) & 0xff); - rt.byteVecPush(out, digestPairs(pairs.items)); - const _1392: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.partsRemainder(rt.byteSliceRchunksExact(rt.byteVecSlice(bytes), size)))); + rs.byteVecPush(out, rs.iterCount(rs.sliceRchunksExactMut(pairs.items, size)) & 0xff); + rs.byteVecPush(out, digestPairs(pairs.items)); + const _1392: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.partsRemainder(rs.byteSliceRchunksExact(rs.byteVecSlice(bytes), size)))); if (_1392 !== undefined) { _1392.v = 238; } - const it23: rt.Iter = rt.sliceRchunksExactMut(words.items, size); + const it23: rs.Iter = rs.sliceRchunksExactMut(words.items, size); it23.next(); - rt.partsRemainder(it23).fill(7); - rt.partsRemainder(rt.sliceRchunksExactMut(pairs.items, size)).reverse(); + rs.partsRemainder(it23).fill(7); + rs.partsRemainder(rs.sliceRchunksExactMut(pairs.items, size)).reverse(); } else { - const part = rt.usizeDiv(data.length, 3); - const iter26: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceRchunks(rt.byteSliceRange(rt.byteVecSlice(bytes), part), size)); + const part = rs.usizeDiv(data.length, 3); + const iter26: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), part), size)); while (true) { - const _1418: [rt.usize, rt.ByteSlice] | rt.Done = iter26.next(); - if (_1418 === rt.DONE) { + const _1418: [rs.usize, rs.ByteSlice] | rs.Done = iter26.next(); + if (_1418 === rs.DONE) { break; } scribble(_1418[0], _1418[1]); } - const iter27: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.iterRev(rt.sliceChunksExactMut(words.items, size))); + const iter27: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterRev(rs.sliceChunksExactMut(words.items, size))); while (true) { - const _1431: [rt.usize, rt.u16[]] | rt.Done = iter27.next(); - if (_1431 === rt.DONE) { + const _1431: [rs.usize, rs.u16[]] | rs.Done = iter27.next(); + if (_1431 === rs.DONE) { break b0; } scribbleWords(_1431[0], _1431[1]); } } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_26: rt.u16): rt.u8 => { - const w: rt.u16 = _26; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_26: rs.u16): rs.u8 => { + const w: rs.u16 = _26; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, digestPairs(pairs.items)); + rs.byteVecPush(out, digestPairs(pairs.items)); } /** Writes through a mutable subslice, which may be empty, as each element type allows. */ -export function pokeWords(i: rt.usize, s: rt.u16[]): void { - const n: rt.usize = s.length; - const _5: rt.Place | undefined = rt.sliceFirstMut(s); +export function pokeWords(i: rs.usize, s: rs.u16[]): void { + const n: rs.usize = s.length; + const _5: rs.Place | undefined = rs.sliceFirstMut(s); if (_5 !== undefined) { - _5.v = rt.u16WrappingAdd(_5.v, rt.u16Add(i & 0xffff, 1)); + _5.v = rs.u16WrappingAdd(_5.v, rs.u16Add(i & 0xffff, 1)); } - const _13: rt.Place | undefined = rt.sliceLastMut(s); + const _13: rs.Place | undefined = rs.sliceLastMut(s); if (_13 !== undefined) { _13.v = _13.v ^ 3855; } s.reverse(); - rt.sliceRotateLeft(s, rt.usizeDiv(n, 3)); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(s)); + rs.sliceRotateLeft(s, rs.usizeDiv(n, 3)); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(s)); while (true) { - const _24: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - const j: rt.usize = _24[0]; - const _30: rt.u16 = rt.u16WrappingMul(_24[1].v, 3); - _24[1].v = rt.u16WrappingAdd(_30, j & 0xffff); + const j: rs.usize = _24[0]; + const _30: rs.u16 = rs.u16WrappingMul(_24[1].v, 3); + _24[1].v = rs.u16WrappingAdd(_30, j & 0xffff); } if (n > 1) { - rt.sliceSwap(s, 0, rt.usizeSub(n, 1)); - const _39: rt.usize = rt.usizeDiv(n, 2); - rt.idx(s, _39); - const _37: rt.u16 = rt.u16WrappingAdd(s[_39], 257); - const _44: rt.usize = rt.usizeDiv(n, 2); - rt.idx(s, _44); + rs.sliceSwap(s, 0, rs.usizeSub(n, 1)); + const _39: rs.usize = rs.usizeDiv(n, 2); + rs.idx(s, _39); + const _37: rs.u16 = rs.u16WrappingAdd(s[_39], 257); + const _44: rs.usize = rs.usizeDiv(n, 2); + rs.idx(s, _44); s[_44] = _37; } } -export function pokePairs(i: rt.usize, s: Pair.Pair[]): void { - const _3: Pair.Pair | undefined = rt.sliceFirst(s); +export function pokePairs(i: rs.usize, s: Pair.Pair[]): void { + const _3: Pair.Pair | undefined = rs.sliceFirst(s); if (_3 !== undefined) { - _3.a = rt.u8WrappingAdd(_3.a, i & 0xff); + _3.a = rs.u8WrappingAdd(_3.a, i & 0xff); } - const _9: Pair.Pair | undefined = rt.sliceLast(s); + const _9: Pair.Pair | undefined = rs.sliceLast(s); if (_9 !== undefined) { - Object.assign(_9, { a: _9.b & 0xff, b: rt.u16Mul(_9.a as rt.u16, 7) }); + Object.assign(_9, { a: _9.b & 0xff, b: rs.u16Mul(_9.a as rs.u16, 7) }); } - rt.sliceSort(s, rt.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); + rs.sliceSort(s, rs.cmpLt(Pair.partialCmp$cmp_PartialOrd), 4, true); if (s.length > 1) { - rt.sliceSwap(s, 0, rt.usizeDiv(s.length, 2)); + rs.sliceSwap(s, 0, rs.usizeDiv(s.length, 2)); } - const iter: rt.Iter = rt.iterSlice(s); + const iter: rs.Iter = rs.iterSlice(s); while (true) { - const _31: Pair.Pair | rt.Done = iter.next(); - if (_31 === rt.DONE) { + const _31: Pair.Pair | rs.Done = iter.next(); + if (_31 === rs.DONE) { break; } - _31.b = rt.u16WrappingAdd(_31.b, 1); + _31.b = rs.u16WrappingAdd(_31.b, 1); } } -export function pokeArray(s: rt.u32[]): void { - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(s)); +export function pokeArray(s: rs.u32[]): void { + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(s)); while (true) { - const _6: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_6 === rt.DONE) { + const _6: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_6 === rs.DONE) { break; } - const j: rt.usize = _6[0]; - const _12: rt.u32 = rt.u32WrappingMul(_6[1].v, 31); - _6[1].v = rt.u32WrappingAdd(_12, j as rt.u32); + const j: rs.usize = _6[0]; + const _12: rs.u32 = rs.u32WrappingMul(_6[1].v, 31); + _6[1].v = rs.u32WrappingAdd(_12, j as rs.u32); } s.reverse(); } @@ -948,59 +948,59 @@ export function pokeArray(s: rt.u32[]): void { * bounds from the first two bytes, which may be out of bounds or backwards, which * panics; with what is written through each part landing in what it came from. */ -export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function subslices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; - const a: rt.usize = _14[0]; - const b: rt.usize = _14[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 2).length, 2); + const _14: [rs.usize, rs.usize] = [rs.usizeRem(data.data[data.start] as rs.usize, reach), rs.usizeRem(data.data[data.start + 1] as rs.usize, reach)]; + const a: rs.usize = _14[0]; + const b: rs.usize = _14[1]; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): Pair.Pair => { - const b4: rt.u8 = _23; - return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_23: rs.u8): Pair.Pair => { + const b4: rs.u8 = _23; + return { a: b4, b: rs.u16Mul(b4 as rs.u16, 3) }; }), undefined, 4, true); - const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { + const array: rs.u32[] = Array.from({ length: 5 }, (): rs.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); + const iter: rs.Iter<[rs.Place, rs.u8]> = rs.iterZip(rs.iterSliceMut(array), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), [false, false]); while (true) { - const _37: [rt.Place, rt.u8] | rt.Done = iter.next(); - if (_37 === rt.DONE) { + const _37: [rs.Place, rs.u8] | rs.Done = iter.next(); + if (_37 === rs.DONE) { break; } - _37[0].v = rt.u32Mul(_37[1] as rt.u32, 65599); + _37[0].v = rs.u32Mul(_37[1] as rs.u32, 65599); } - const _45: rt.u8 = rt.u8Rem(kind, 8); + const _45: rs.u8 = rs.u8Rem(kind, 8); if (_45 === 0) { - pokeWords(0, rt.sliceRangeMut(words.items, a, b)); - pokePairs(0, rt.sliceRangeMut(pairs.items, a, b)); - pokeArray(rt.sliceRangeMut(array, rt.min(a, 5), rt.min(b, 5))); + pokeWords(0, rs.sliceRangeMut(words.items, a, b)); + pokePairs(0, rs.sliceRangeMut(pairs.items, a, b)); + pokeArray(rs.sliceRangeMut(array, rs.min(a, 5), rs.min(b, 5))); } else if (_45 === 1) { - pokeWords(1, rt.sliceRangeMut(words.items, 0, b)); - pokeWords(2, rt.sliceRangeMut(words.items, a)); - pokePairs(1, rt.sliceRangeMut(pairs.items, a)); + pokeWords(1, rs.sliceRangeMut(words.items, 0, b)); + pokeWords(2, rs.sliceRangeMut(words.items, a)); + pokePairs(1, rs.sliceRangeMut(pairs.items, a)); pokePairs(2, pairs.items); - pokeWords(3, rt.sliceRangeMut(words.items, 0, b)); - pokeArray(rt.sliceRangeMut(array, a)); + pokeWords(3, rs.sliceRangeMut(words.items, 0, b)); + pokeArray(rs.sliceRangeMut(array, a)); } else if (_45 === 2) { - const outer: rt.u16[] = rt.sliceRangeMut(words.items, rt.usizeDiv(a, 2)); - pokeWords(4, rt.sliceRangeMut(outer, 0, rt.usizeDiv(b, 2))); - const _95: rt.Place | undefined = rt.sliceLastMut(outer); + const outer: rs.u16[] = rs.sliceRangeMut(words.items, rs.usizeDiv(a, 2)); + pokeWords(4, rs.sliceRangeMut(outer, 0, rs.usizeDiv(b, 2))); + const _95: rs.Place | undefined = rs.sliceLastMut(outer); if (_95 !== undefined) { _95.v = 48879; } - const outer2: Pair.Pair[] = rt.sliceRangeMut(pairs.items, 0, b); - const inner: Pair.Pair[] = rt.sliceRangeMut(outer2, rt.usizeDiv(a, 2)); - pokePairs(3, rt.sliceRangeMut(inner, rt.min(1, inner.length))); + const outer2: Pair.Pair[] = rs.sliceRangeMut(pairs.items, 0, b); + const inner: Pair.Pair[] = rs.sliceRangeMut(outer2, rs.usizeDiv(a, 2)); + pokePairs(3, rs.sliceRangeMut(inner, rs.min(1, inner.length))); outer2.reverse(); } else if (_45 === 3) { - const _114: [rt.u16[], rt.u16[]] = rt.sliceSplitAtMut(words.items, a); + const _114: [rs.u16[], rs.u16[]] = rs.sliceSplitAtMut(words.items, a); pokeWords(5, _114[0]); pokeWords(6, _114[1]); - const _119: [rt.Place | undefined, rt.Place | undefined] = [rt.sliceLastMut(_114[0]), rt.sliceFirstMut(_114[1])]; + const _119: [rs.Place | undefined, rs.Place | undefined] = [rs.sliceLastMut(_114[0]), rs.sliceFirstMut(_114[1])]; if (_119[0] !== undefined) { if (_119[1] !== undefined) { const swapped2 = _119[0].v; @@ -1008,80 +1008,80 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi _119[1].v = swapped2; } } - const _129: [Pair.Pair[], Pair.Pair[]] = rt.sliceSplitAtMut(pairs.items, b); + const _129: [Pair.Pair[], Pair.Pair[]] = rs.sliceSplitAtMut(pairs.items, b); pokePairs(4, _129[1]); pokePairs(5, _129[0]); - const _134: [Pair.Pair | undefined, Pair.Pair | undefined] = [rt.sliceFirst(_129[0]), rt.sliceLast(_129[1])]; + const _134: [Pair.Pair | undefined, Pair.Pair | undefined] = [rs.sliceFirst(_129[0]), rs.sliceLast(_129[1])]; if (_134[0] !== undefined) { if (_134[1] !== undefined) { - const swapped3 = rt.replaceIn(_134[1], _134[0]); + const swapped3 = rs.replaceIn(_134[1], _134[0]); Object.assign(_134[0], swapped3); } } - const _144: [rt.u32[], rt.u32[]] = rt.sliceSplitAtMut(array, rt.min(a, 5)); + const _144: [rs.u32[], rs.u32[]] = rs.sliceSplitAtMut(array, rs.min(a, 5)); pokeArray(_144[1]); pokeArray(_144[0]); } else if (_45 === 4) { - const _151: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitAtMutChecked(words.items, a); + const _151: [rs.u16[], rs.u16[]] | undefined = rs.sliceSplitAtMutChecked(words.items, a); if (_151 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { _151[0].reverse(); pokeWords(7, _151[1]); } - const n2: rt.usize = pairs.items.length; - const _163: [Pair.Pair[], Pair.Pair[]] = rt.sliceSplitAtMut(pairs.items, 0); + const n2: rs.usize = pairs.items.length; + const _163: [Pair.Pair[], Pair.Pair[]] = rs.sliceSplitAtMut(pairs.items, 0); pokePairs(6, _163[1]); - rt.byteVecPush(out, _163[0].length & 0xff); - const _173: [Pair.Pair[], Pair.Pair[]] = rt.sliceSplitAtMut(pairs.items, n2); + rs.byteVecPush(out, _163[0].length & 0xff); + const _173: [Pair.Pair[], Pair.Pair[]] = rs.sliceSplitAtMut(pairs.items, n2); pokePairs(7, _173[0]); - rt.byteVecPush(out, _173[1].length & 0xff); - const n3: rt.usize = words.items.length; - const _185: [rt.u16[], rt.u16[]] = rt.sliceSplitAtMut(words.items, n3); + rs.byteVecPush(out, _173[1].length & 0xff); + const n3: rs.usize = words.items.length; + const _185: [rs.u16[], rs.u16[]] = rs.sliceSplitAtMut(words.items, n3); pokeWords(8, _185[0]); - rt.byteVecPush(out, _185[1].length & 0xff); - const _195: [rt.u16[], rt.u16[]] = rt.sliceSplitAtMut(words.items, rt.min(a, n3)); - const _201: [rt.u16[], rt.u16[]] = rt.sliceSplitAtMut(_195[1], rt.min(b, rt.usizeSub(n3, rt.min(a, n3)))); + rs.byteVecPush(out, _185[1].length & 0xff); + const _195: [rs.u16[], rs.u16[]] = rs.sliceSplitAtMut(words.items, rs.min(a, n3)); + const _201: [rs.u16[], rs.u16[]] = rs.sliceSplitAtMut(_195[1], rs.min(b, rs.usizeSub(n3, rs.min(a, n3)))); pokeWords(9, _201[1]); pokeWords(10, _195[0]); pokeWords(11, _201[0]); } else if (_45 === 5) { - const _209: [rt.Place, rt.u16[]] | undefined = rt.sliceSplitFirstMut(words.items, true); + const _209: [rs.Place, rs.u16[]] | undefined = rs.sliceSplitFirstMut(words.items, true); if (_209 !== undefined) { - _209[0].v = rt.u16WrappingAdd(_209[0].v, _209[1].length & 0xffff); + _209[0].v = rs.u16WrappingAdd(_209[0].v, _209[1].length & 0xffff); pokeWords(12, _209[1]); } - const _221: [rt.Place, rt.u16[]] | undefined = rt.sliceSplitLastMut(words.items, true); + const _221: [rs.Place, rs.u16[]] | undefined = rs.sliceSplitLastMut(words.items, true); if (_221 !== undefined) { _221[0].v = _221[0].v ^ 23130; - const _227: [rt.Place, rt.u16[]] | undefined = rt.sliceSplitFirstMut(_221[1], true); + const _227: [rs.Place, rs.u16[]] | undefined = rs.sliceSplitFirstMut(_221[1], true); if (_227 !== undefined) { _227[0].v = _221[0].v; } } - const _231: [Pair.Pair, Pair.Pair[]] | undefined = rt.sliceSplitFirstMut(pairs.items, false); + const _231: [Pair.Pair, Pair.Pair[]] | undefined = rs.sliceSplitFirstMut(pairs.items, false); if (_231 !== undefined) { _231[0].b = _231[1].length & 0xffff; pokePairs(8, _231[1]); - const _240: Pair.Pair | undefined = rt.sliceFirst(_231[1]); + const _240: Pair.Pair | undefined = rs.sliceFirst(_231[1]); if (_240 !== undefined) { Object.assign(_231[0], copy$slices_Pair(_240)); } } - const _244: [Pair.Pair, Pair.Pair[]] | undefined = rt.sliceSplitLastMut(pairs.items, false); + const _244: [Pair.Pair, Pair.Pair[]] | undefined = rs.sliceSplitLastMut(pairs.items, false); if (_244 !== undefined) { Object.assign(_244[0], { a: 1, b: 2 }); pokePairs(9, _244[1]); } - const _252: [rt.Place, rt.u32[]] | undefined = rt.sliceSplitLastMut(array, true); + const _252: [rs.Place, rs.u32[]] | undefined = rs.sliceSplitLastMut(array, true); if (_252 !== undefined) { - _252[0].v = _252[1].length as rt.u32; + _252[0].v = _252[1].length as rs.u32; pokeArray(_252[1]); } } else if (_45 === 6) { - const _261: rt.u16[] = words.items; + const _261: rs.u16[] = words.items; if (_261.length >= 2) { - const view = rt.sliceView(_261, 1, _261.length - 1); + const view = rs.sliceView(_261, 1, _261.length - 1); const swapped = _261[0]; _261[0] = _261[_261.length - 1]; _261[_261.length - 1] = swapped; @@ -1089,52 +1089,52 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi } const _271: Pair.Pair[] = pairs.items; if (_271.length >= 1) { - pokePairs(10, rt.sliceView(_271, 0, _271.length - 1)); + pokePairs(10, rs.sliceView(_271, 0, _271.length - 1)); } - const view3 = rt.sliceView(array, 1, 5); + const view3 = rs.sliceView(array, 1, 5); pokeArray(view3); view3[3] = 7; - rt.sliceSwap(rt.sliceView(array, 1, 4), 0, 2); + rs.sliceSwap(rs.sliceView(array, 1, 4), 0, 2); } else { - const _290: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), a); - rt.byteSliceView(_290[0]).reverse(); - const _294: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_290[1])); + const _290: [rs.ByteSlice, rs.ByteSlice] = rs.byteSliceSplitAt(rs.byteVecSlice(bytes), a); + rs.byteSliceView(_290[0]).reverse(); + const _294: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_290[1])); if (_294 !== undefined) { _294.v = _294.v ^ 255; } - const _297: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(_290[0])); + const _297: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(_290[0])); if (_297 !== undefined) { - _297.v = rt.u8WrappingAdd(_297.v, 1); + _297.v = rs.u8WrappingAdd(_297.v, 1); } - const _302: [rt.Place, rt.ByteSlice] | undefined = rt.byteSliceSplitFirstMut(rt.byteVecSlice(bytes)); + const _302: [rs.Place, rs.ByteSlice] | undefined = rs.byteSliceSplitFirstMut(rs.byteVecSlice(bytes)); if (_302 !== undefined) { _302[0].v = _302[1].length & 0xff; - rt.byteSliceView(_302[1]).reverse(); + rs.byteSliceView(_302[1]).reverse(); } - const _311: [rt.Place, rt.ByteSlice] | undefined = rt.byteSliceSplitLastMut(rt.byteVecSlice(bytes)); + const _311: [rs.Place, rs.ByteSlice] | undefined = rs.byteSliceSplitLastMut(rs.byteVecSlice(bytes)); if (_311 !== undefined) { - _311[0].v = rt.u8WrappingMul(_311[0].v, 3); - const _319: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(_311[1])); + _311[0].v = rs.u8WrappingMul(_311[0].v, 3); + const _319: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(_311[1])); if (_319 !== undefined) { _319.v = 17; } } - const _322: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(bytes), b); + const _322: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(bytes), b); if (_322 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { - rt.byteSliceView(_322[1]).reverse(); - rt.byteVecPush(out, _322[0].length & 0xff); + rs.byteSliceView(_322[1]).reverse(); + rs.byteVecPush(out, _322[0].length & 0xff); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_24: rt.u16): rt.u8 => { - const w: rt.u16 = _24; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_24: rs.u16): rs.u8 => { + const w: rs.u16 = _24; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, digestPairs(pairs.items)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_27: rt.u32): rt.u8 => { - const x: rt.u32 = _27; + rs.byteVecPush(out, digestPairs(pairs.items)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(array), (_27: rs.u32): rs.u8 => { + const x: rs.u32 = _27; return ((x ^ (x >>> 13)) >>> 0) & 0xff; }), undefined, true); } @@ -1145,138 +1145,138 @@ export function subslices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi * backwards, which panics, of the rest as items, bytes, and integers: what it yields, and * what each drops and keeps as the drain drops, or as it is forgotten. */ -export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function drains(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); - const _14: [rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach)]; - const a: rt.usize = _14[0]; - const b: rt.usize = _14[1]; - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): Item.Item => { + const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 2).length, 2); + const _14: [rs.usize, rs.usize] = [rs.usizeRem(data.data[data.start] as rs.usize, reach), rs.usizeRem(data.data[data.start + 1] as rs.usize, reach)]; + const a: rs.usize = _14[0]; + const b: rs.usize = _14[1]; + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_2: rs.u8): Item.Item => { return new Item.Item(_2); }), undefined, 1, true); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_23: rt.u8): rt.u32 => { - return rt.u32Add(_23 as rt.u32, 1000); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_23: rs.u8): rs.u32 => { + return rs.u32Add(_23 as rs.u32, 1000); }), undefined, 4, true); - const _31: rt.u8 = rt.u8Rem(kind, 8); + const _31: rs.u8 = rs.u8Rem(kind, 8); if (_31 === 0) { - const iter: rt.Iter = rt.vecDrain(items, new rt.Range(a, b), rt.drop); + const iter: rs.Iter = rs.vecDrain(items, new rs.Range(a, b), rs.drop); while (true) { - const _38: Item.Item | rt.Done = iter.next(); - if (_38 === rt.DONE) { + const _38: Item.Item | rs.Done = iter.next(); + if (_38 === rs.DONE) { break; } const x: Item.Item = _38; - rt.byteVecPush(out, x.tag); + rs.byteVecPush(out, x.tag); flush(out); x[Symbol.dispose](); } - rt.drop(iter); - rt.iterExtendBytes(out, rt.byteVecDrain(bytes, new rt.Range(a, b)), "fold", true); - rt.iterExtendBytes(out, rt.iterMap(rt.vecDrain(words, new rt.Range(a, b)), (w3: rt.u32): rt.u8 => { + rs.drop(iter); + rs.iterExtendBytes(out, rs.byteVecDrain(bytes, new rs.Range(a, b)), "fold", true); + rs.iterExtendBytes(out, rs.iterMap(rs.vecDrain(words, new rs.Range(a, b)), (w3: rs.u32): rs.u8 => { return w3 & 0xff; }), "fold", true); } else if (_31 === 1) { - const _56: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const drain: rt.Iter = rt.vecDrain(items, _56, rt.drop); - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.iterToOption(drain.next()), (x9: Item.Item): rt.u8 => { - const _011: rt.u8 = x9.tag; + const _56: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const drain: rs.Iter = rs.vecDrain(items, _56, rs.drop); + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.iterToOption(drain.next()), (x9: Item.Item): rs.u8 => { + const _011: rs.u8 = x9.tag; x9[Symbol.dispose](); return _011; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.iterToOption(drain.nextBack()), (x10: Item.Item): rt.u8 => { - const _012: rt.u8 = x10.tag; + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.iterToOption(drain.nextBack()), (x10: Item.Item): rs.u8 => { + const _012: rs.u8 = x10.tag; x10[Symbol.dispose](); return _012; })), undefined, true); - rt.byteVecPush(out, drain.len() & 0xff); - rt.drop(drain); + rs.byteVecPush(out, drain.len() & 0xff); + rs.drop(drain); flush(out); - const _74: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const drain2: rt.Iter = rt.byteVecDrain(bytes, _74); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(drain2.nextBack())), undefined, true); - rt.drop(drain2); - const _82: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const drain3: rt.Iter = rt.vecDrain(words, _82); - rt.iterExtendBytes(out, rt.iterOption(option_map$0a57co2(rt.iterToOption(drain3.next()), (w2: rt.u32): rt.u8 => { + const _74: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const drain2: rs.Iter = rs.byteVecDrain(bytes, _74); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(drain2.nextBack())), undefined, true); + rs.drop(drain2); + const _82: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const drain3: rs.Iter = rs.vecDrain(words, _82); + rs.iterExtendBytes(out, rs.iterOption(option_map$04ry0e1(rs.iterToOption(drain3.next()), (w2: rs.u32): rs.u8 => { return w2 & 0xff; })), undefined, true); - rt.drop(drain3); + rs.drop(drain3); } else if (_31 === 2) { - const taken: rt.Vec = rt.iterToVec(rt.vecDrain(items, { end: b }, rt.drop), "fold", 1, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(taken.items), (x8: Item.Item): rt.u8 => { + const taken: rs.Vec = rs.iterToVec(rs.vecDrain(items, { end: b }, rs.drop), "fold", 1, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(taken.items), (x8: Item.Item): rs.u8 => { return x8.tag; }), undefined, true); - rt.dropVec(taken); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); - rt.drop(rt.vecDrain(words, { end: b })); + rs.dropVec(taken); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.byteVecDrain(bytes, { end: b }), "fold", true)), undefined, true); + rs.drop(rs.vecDrain(words, { end: b })); } else if (_31 === 3) { - const drain4: rt.Iter = rt.vecDrain(items, new rt.RangeFrom(a, rt.usizeStep), rt.drop); - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.iterNth(drain4, 1, rt.drop), (x6: Item.Item): rt.u8 => { - const _07: rt.u8 = x6.tag; + const drain4: rs.Iter = rs.vecDrain(items, new rs.RangeFrom(a, rs.usizeStep), rs.drop); + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.iterNth(drain4, 1, rs.drop), (x6: Item.Item): rs.u8 => { + const _07: rs.u8 = x6.tag; x6[Symbol.dispose](); return _07; })), undefined, true); flush(out); - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.iterNthBack(drain4, 1, rt.drop), (x7: Item.Item): rt.u8 => { - const _08: rt.u8 = x7.tag; + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.iterNthBack(drain4, 1, rs.drop), (x7: Item.Item): rs.u8 => { + const _08: rs.u8 = x7.tag; x7[Symbol.dispose](); return _08; })), undefined, true); flush(out); - rt.byteVecPush(out, drain4.len() & 0xff); - rt.drop(drain4); - const _127: rt.Iter = rt.byteVecDrain(bytes, new rt.RangeFrom(a, rt.usizeStep)); - rt.iterExtendBytes(out, rt.iterOption(rt.iterNth(_127, 2)), undefined, true); - rt.drop(_127); - rt.iterExtendBytes(out, rt.iterMap(rt.iterRev(rt.vecDrain(words, new rt.RangeFrom(a, rt.usizeStep))), (w: rt.u32): rt.u8 => { + rs.byteVecPush(out, drain4.len() & 0xff); + rs.drop(drain4); + const _127: rs.Iter = rs.byteVecDrain(bytes, new rs.RangeFrom(a, rs.usizeStep)); + rs.iterExtendBytes(out, rs.iterOption(rs.iterNth(_127, 2)), undefined, true); + rs.drop(_127); + rs.iterExtendBytes(out, rs.iterMap(rs.iterRev(rs.vecDrain(words, new rs.RangeFrom(a, rs.usizeStep))), (w: rs.u32): rs.u8 => { return w & 0xff; }), "fold", true); } else if (_31 === 4) { - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.ownedLast(rt.vecDrain(items, undefined, rt.drop), rt.drop), (x5: Item.Item): rt.u8 => { - const _06: rt.u8 = x5.tag; + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.ownedLast(rs.vecDrain(items, undefined, rs.drop), rs.drop), (x5: Item.Item): rs.u8 => { + const _06: rs.u8 = x5.tag; x5[Symbol.dispose](); return _06; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.ownedLast(rt.byteVecDrain(bytes, undefined))), undefined, true); - rt.byteVecPush(out, rt.ownedCount(rt.vecDrain(words, undefined)) & 0xff); + rs.iterExtendBytes(out, rs.iterOption(rs.ownedLast(rs.byteVecDrain(bytes, undefined))), undefined, true); + rs.byteVecPush(out, rs.ownedCount(rs.vecDrain(words, undefined)) & 0xff); } else if (_31 === 5) { - rt.iterExtendBytes(out, rt.iterOption(option_map$003seos(rt.iterToOption(rt.vecDrain(items, new rt.Range(a, b), rt.drop).next()), (x4: Item.Item): rt.u8 => { - const _05: rt.u8 = x4.tag; + rs.iterExtendBytes(out, rs.iterOption(option_map$1aqm6sp(rs.iterToOption(rs.vecDrain(items, new rs.Range(a, b), rs.drop).next()), (x4: Item.Item): rs.u8 => { + const _05: rs.u8 = x4.tag; x4[Symbol.dispose](); return _05; })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(rt.iterToOption(rt.byteVecDrain(bytes, new rt.Range(a, b)).next())), undefined, true); - rt.vecDrain(words, new rt.Range(a, b)); + rs.iterExtendBytes(out, rs.iterOption(rs.iterToOption(rs.byteVecDrain(bytes, new rs.Range(a, b)).next())), undefined, true); + rs.vecDrain(words, new rs.Range(a, b)); } else if (_31 === 6) { - rt.byteVecPush(out, rt.ownedCount(rt.vecDrain(items, new rt.Range(a, b), rt.drop), rt.drop) & 0xff); + rs.byteVecPush(out, rs.ownedCount(rs.vecDrain(items, new rs.Range(a, b), rs.drop), rs.drop) & 0xff); } else { - const kept: rt.Vec = rt.vecFrom([new Item.Item(238)]); - const _181: rt.Iter = rt.iterFilter(rt.vecDrain(items, new rt.Range(a, b), rt.drop), (x2: Item.Item): boolean => { - return rt.u8Rem(x2.tag, 2) === 0; - }, rt.drop); - rt.iterExtend(kept, _181, "next", 1); + const kept: rs.Vec = rs.vecFrom([new Item.Item(238)]); + const _181: rs.Iter = rs.iterFilter(rs.vecDrain(items, new rs.Range(a, b), rs.drop), (x2: Item.Item): boolean => { + return rs.u8Rem(x2.tag, 2) === 0; + }, rs.drop); + rs.iterExtend(kept, _181, "next", 1); flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(kept.items), (x3: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(kept.items), (x3: Item.Item): rs.u8 => { return x3.tag; }), undefined, true); - const other: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(238)); - const _195: rt.Iter = rt.iterRev(rt.byteVecDrain(bytes, new rt.Range(a, b))); - rt.iterExtendBytes(other, _195, "fold", true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(other), undefined, true); - rt.dropVec(kept); + const other: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(238)); + const _195: rs.Iter = rs.iterRev(rs.byteVecDrain(bytes, new rs.Range(a, b))); + rs.iterExtendBytes(other, _195, "fold", true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(other), undefined, true); + rs.dropVec(kept); } flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items.items), (x11: Item.Item): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(items.items), (x11: Item.Item): rs.u8 => { return x11.tag; }), undefined, true); - rt.byteVecPush(out, items.items.length & 0xff); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_26: rt.u32): rt.u8 => { + rs.byteVecPush(out, items.items.length & 0xff); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_26: rs.u32): rs.u8 => { return _26 & 0xff; }), undefined, true); items.items.push(new Item.Item(255)); - rt.dropVec(items); + rs.dropVec(items); flush(out); } } @@ -1288,440 +1288,440 @@ export function drains(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * backwards, which panics or gives `None`; with what is written through each mutable * part landing in what it came from. */ -export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _104!: rt.u8; - let _112!: rt.u8; - let _120!: rt.u8; - let _128!: rt.u8; - let _136!: rt.u8; - let _144!: rt.u8; - let _151!: rt.u8; - let _157!: rt.u8; - let _165!: rt.u8; - let _173!: rt.u8; - let _181!: rt.u8; - let _189!: rt.u8; - let _197!: rt.u8; - let _207!: rt.u8; - let _287!: rt.u8; - let _296!: rt.u8; - let _305!: rt.u8; - let _344!: rt.u8; - let _352!: rt.u8; - const _46: (a0: rt.u32[]) => rt.u8 = (s2: rt.u32[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(s2), s2.length & 0xff, (acc: rt.u8, _32: rt.u32): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ ((_32 >>> 5) & 0xff); +export function ranges(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _104!: rs.u8; + let _112!: rs.u8; + let _120!: rs.u8; + let _128!: rs.u8; + let _136!: rs.u8; + let _144!: rs.u8; + let _151!: rs.u8; + let _157!: rs.u8; + let _165!: rs.u8; + let _173!: rs.u8; + let _181!: rs.u8; + let _189!: rs.u8; + let _197!: rs.u8; + let _207!: rs.u8; + let _287!: rs.u8; + let _296!: rs.u8; + let _305!: rs.u8; + let _344!: rs.u8; + let _352!: rs.u8; + const _46: (a0: rs.u32[]) => rs.u8 = (s2: rs.u32[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(s2), s2.length & 0xff, (acc: rs.u8, _32: rs.u32): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ ((_32 >>> 5) & 0xff); }); }; - const _329: (a0: rt.usize, a1: rt.u8) => rt.RangeBound = (x2: rt.usize, k: rt.u8): rt.RangeBound => { - const _42: rt.u8 = rt.u8Rem(k, 3); + const _329: (a0: rs.usize, a1: rs.u8) => rs.RangeBound = (x2: rs.usize, k: rs.u8): rs.RangeBound => { + const _42: rs.u8 = rs.u8Rem(k, 3); if (_42 === 0) { - return { tag: "Included", _0: x2 } as rt.RangeBound; + return { tag: "Included", _0: x2 } as rs.RangeBound; } if (_42 === 1) { - return { tag: "Excluded", _0: x2 } as rt.RangeBound; + return { tag: "Excluded", _0: x2 } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; }; if (data.length >= 2) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 2).length, 2); - const at: (a0: rt.u8) => rt.usize = (x3: rt.u8): rt.usize => { + const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 2).length, 2); + const at: (a0: rs.u8) => rs.usize = (x3: rs.u8): rs.usize => { if (!(x3 === 255)) { - return rt.usizeRem(x3 as rt.usize, reach); + return rs.usizeRem(x3 as rs.usize, reach); } return 4294967295; }; - const _16: [rt.usize, rt.usize] = [at(data.data[data.start]), at(data.data[data.start + 1])]; - const a: rt.usize = _16[0]; - const b: rt.usize = _16[1]; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 2)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const _16: [rs.usize, rs.usize] = [at(data.data[data.start]), at(data.data[data.start + 1])]; + const a: rs.usize = _16[0]; + const b: rs.usize = _16[1]; + const bytes: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 2)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), (_22: rt.u8): Pair.Pair => { - const b4: rt.u8 = _22; - return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), (_22: rs.u8): Pair.Pair => { + const b4: rs.u8 = _22; + return { a: b4, b: rs.u16Mul(b4 as rs.u16, 3) }; }), undefined, 4, true); - const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { + const array: rs.u32[] = Array.from({ length: 5 }, (): rs.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 2))), [false, false]); + const iter: rs.Iter<[rs.Place, rs.u8]> = rs.iterZip(rs.iterSliceMut(array), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 2))), [false, false]); while (true) { - const _39: [rt.Place, rt.u8] | rt.Done = iter.next(); - if (_39 === rt.DONE) { + const _39: [rs.Place, rs.u8] | rs.Done = iter.next(); + if (_39 === rs.DONE) { break; } - _39[0].v = rt.u32Mul(_39[1] as rt.u32, 65599); + _39[0].v = rs.u32Mul(_39[1] as rs.u32, 65599); } - const _47: rt.u8 = rt.u8Rem(kind, 8); + const _47: rs.u8 = rs.u8Rem(kind, 8); if (_47 === 0) { - const _53: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice7 = rt.byteVecSlice(bytes); - const bounds26 = rt.sliceIndexBounds(_53, slice7.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice7, bounds26[0], bounds26[1]))); - const bounds27 = rt.sliceIndexBounds(new rt.RangeInclusive(a, b, rt.usizeStep), words.items.length); - rt.byteVecPush(out, digestWords(rt.sliceRange(words.items, bounds27[0], bounds27[1]))); - const bounds28 = rt.sliceIndexBounds({ end: b, inclusive: true }, pairs.items.length); - rt.byteVecPush(out, digestPairs(rt.sliceRange(pairs.items, bounds28[0], bounds28[1]))); - const bounds29 = rt.sliceIndexBounds(new rt.RangeInclusive(rt.min(a, 4), rt.min(b, 4), rt.usizeStep), array.length); - const part6 = rt.sliceRange(array, bounds29[0], bounds29[1]); - rt.byteVecPush(out, _46(part6)); - const slice8 = rt.byteSliceRange(data, 2); - const bounds30 = rt.sliceIndexBounds({ end: b, inclusive: true }, slice8.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice8, bounds30[0], bounds30[1]))); + const _53: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const slice7 = rs.byteVecSlice(bytes); + const bounds26 = rs.sliceIndexBounds(_53, slice7.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice7, bounds26[0], bounds26[1]))); + const bounds27 = rs.sliceIndexBounds(new rs.RangeInclusive(a, b, rs.usizeStep), words.items.length); + rs.byteVecPush(out, digestWords(rs.sliceRange(words.items, bounds27[0], bounds27[1]))); + const bounds28 = rs.sliceIndexBounds({ end: b, inclusive: true }, pairs.items.length); + rs.byteVecPush(out, digestPairs(rs.sliceRange(pairs.items, bounds28[0], bounds28[1]))); + const bounds29 = rs.sliceIndexBounds(new rs.RangeInclusive(rs.min(a, 4), rs.min(b, 4), rs.usizeStep), array.length); + const part6 = rs.sliceRange(array, bounds29[0], bounds29[1]); + rs.byteVecPush(out, _46(part6)); + const slice8 = rs.byteSliceRange(data, 2); + const bounds30 = rs.sliceIndexBounds({ end: b, inclusive: true }, slice8.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice8, bounds30[0], bounds30[1]))); } else if (_47 === 1) { - const _79: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const slice6 = rt.byteVecSlice(bytes); - const bounds21 = rt.sliceIndexBounds(_79, slice6.length); - const part: rt.ByteSlice = rt.byteSliceRange(slice6, bounds21[0], bounds21[1]); - rt.byteSliceView(part).reverse(); - rt.idx(part, 0); + const _79: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const slice6 = rs.byteVecSlice(bytes); + const bounds21 = rs.sliceIndexBounds(_79, slice6.length); + const part: rs.ByteSlice = rs.byteSliceRange(slice6, bounds21[0], bounds21[1]); + rs.byteSliceView(part).reverse(); + rs.idx(part, 0); part.data[part.start] = part.data[part.start] ^ 90; - const bounds22 = rt.sliceIndexBounds({ end: b, inclusive: true }, words.items.length); - pokeWords(0, rt.sliceRangeMut(words.items, bounds22[0], bounds22[1])); - const bounds23 = rt.sliceIndexBounds(new rt.RangeInclusive(a, b, rt.usizeStep), pairs.items.length); - pokePairs(1, rt.sliceRangeMut(pairs.items, bounds23[0], bounds23[1])); - const bounds24 = rt.sliceIndexBounds({ end: rt.min(b, 4), inclusive: true }, array.length); - pokeArray(rt.sliceRangeMut(array, bounds24[0], bounds24[1])); - const s: rt.u16[] = words.items; - const bounds25 = rt.sliceIndexBounds(new rt.RangeInclusive(a, b, rt.usizeStep), s.length); - pokeWords(2, rt.sliceRangeMut(s, bounds25[0], bounds25[1])); + const bounds22 = rs.sliceIndexBounds({ end: b, inclusive: true }, words.items.length); + pokeWords(0, rs.sliceRangeMut(words.items, bounds22[0], bounds22[1])); + const bounds23 = rs.sliceIndexBounds(new rs.RangeInclusive(a, b, rs.usizeStep), pairs.items.length); + pokePairs(1, rs.sliceRangeMut(pairs.items, bounds23[0], bounds23[1])); + const bounds24 = rs.sliceIndexBounds({ end: rs.min(b, 4), inclusive: true }, array.length); + pokeArray(rs.sliceRangeMut(array, bounds24[0], bounds24[1])); + const s: rs.u16[] = words.items; + const bounds25 = rs.sliceIndexBounds(new rs.RangeInclusive(a, b, rs.usizeStep), s.length); + pokeWords(2, rs.sliceRangeMut(s, bounds25[0], bounds25[1])); } else if (_47 === 2) { - const _105: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), a, b); + const _105: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), a, b); if (_105 === undefined) { _104 = 238; } else { _104 = digest(_105); } - rt.byteVecPush(out, _104); - const _114: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds16 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _114.length); - const _113: rt.ByteSlice | undefined = rt.byteSliceGetRange(_114, bounds16[0], bounds16[1]); + rs.byteVecPush(out, _104); + const _114: rs.ByteSlice = rs.byteVecSlice(bytes); + const bounds16 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _114.length); + const _113: rs.ByteSlice | undefined = rs.byteSliceGetRange(_114, bounds16[0], bounds16[1]); if (_113 === undefined) { _112 = 238; } else { _112 = digest(_113); } - rt.byteVecPush(out, _112); - const _121: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, b); + rs.byteVecPush(out, _112); + const _121: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, b); if (_121 === undefined) { _120 = 238; } else { _120 = digest(_121); } - rt.byteVecPush(out, _120); - const _130: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds17 = rt.sliceGetBounds({ end: b, inclusive: true }, _130.length); - const _129: rt.ByteSlice | undefined = rt.byteSliceGetRange(_130, bounds17[0], bounds17[1]); + rs.byteVecPush(out, _120); + const _130: rs.ByteSlice = rs.byteVecSlice(bytes); + const bounds17 = rs.sliceGetBounds({ end: b, inclusive: true }, _130.length); + const _129: rs.ByteSlice | undefined = rs.byteSliceGetRange(_130, bounds17[0], bounds17[1]); if (_129 === undefined) { _128 = 238; } else { _128 = digest(_129); } - rt.byteVecPush(out, _128); - const _137: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), a); + rs.byteVecPush(out, _128); + const _137: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), a); if (_137 === undefined) { _136 = 238; } else { _136 = digest(_137); } - rt.byteVecPush(out, _136); - const _145: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0); + rs.byteVecPush(out, _136); + const _145: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0); if (_145 === undefined) { _144 = 238; } else { _144 = digest(_145); } - rt.byteVecPush(out, _144); - const _152: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceRange(data, 2), a, b); + rs.byteVecPush(out, _144); + const _152: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceRange(data, 2), a, b); if (_152 === undefined) { _151 = 238; } else { _151 = digest(_152); } - rt.byteVecPush(out, _151); - const _158: rt.u16[] | undefined = rt.sliceGetRange(words.items, a, b); + rs.byteVecPush(out, _151); + const _158: rs.u16[] | undefined = rs.sliceGetRange(words.items, a, b); if (_158 === undefined) { _157 = 238; } else { _157 = digestWords(_158); } - rt.byteVecPush(out, _157); - const _167: rt.u16[] = words.items; - const bounds18 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _167.length); - const _166: rt.u16[] | undefined = rt.sliceGetRange(_167, bounds18[0], bounds18[1]); + rs.byteVecPush(out, _157); + const _167: rs.u16[] = words.items; + const bounds18 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _167.length); + const _166: rs.u16[] | undefined = rs.sliceGetRange(_167, bounds18[0], bounds18[1]); if (_166 === undefined) { _165 = 238; } else { _165 = digestWords(_166); } - rt.byteVecPush(out, _165); - const _175: rt.u16[] = words.items; - const bounds19 = rt.sliceGetBounds({ end: b, inclusive: true }, _175.length); - const _174: rt.u16[] | undefined = rt.sliceGetRange(_175, bounds19[0], bounds19[1]); + rs.byteVecPush(out, _165); + const _175: rs.u16[] = words.items; + const bounds19 = rs.sliceGetBounds({ end: b, inclusive: true }, _175.length); + const _174: rs.u16[] | undefined = rs.sliceGetRange(_175, bounds19[0], bounds19[1]); if (_174 === undefined) { _173 = 238; } else { _173 = digestWords(_174); } - rt.byteVecPush(out, _173); - const _182: Pair.Pair[] | undefined = rt.sliceGetRange(pairs.items, a); + rs.byteVecPush(out, _173); + const _182: Pair.Pair[] | undefined = rs.sliceGetRange(pairs.items, a); if (_182 === undefined) { _181 = 238; } else { _181 = digestPairs(_182); } - rt.byteVecPush(out, _181); - const _190: Pair.Pair[] | undefined = rt.sliceGetRange(pairs.items, 0, b); + rs.byteVecPush(out, _181); + const _190: Pair.Pair[] | undefined = rs.sliceGetRange(pairs.items, 0, b); if (_190 === undefined) { _189 = 238; } else { _189 = digestPairs(_190); } - rt.byteVecPush(out, _189); - const _199: rt.u32[] = array; - const bounds20 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _199.length); - const _198: rt.u32[] | undefined = rt.sliceGetRange(_199, bounds20[0], bounds20[1]); + rs.byteVecPush(out, _189); + const _199: rs.u32[] = array; + const bounds20 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _199.length); + const _198: rs.u32[] | undefined = rs.sliceGetRange(_199, bounds20[0], bounds20[1]); if (_198 === undefined) { _197 = 238; } else { _197 = _46(_198); } - rt.byteVecPush(out, _197); - const _208: rt.u32[] | undefined = rt.sliceGetRange(array, 0); + rs.byteVecPush(out, _197); + const _208: rs.u32[] | undefined = rs.sliceGetRange(array, 0); if (_208 === undefined) { _207 = 238; } else { _207 = _46(_208); } - rt.byteVecPush(out, _207); + rs.byteVecPush(out, _207); } else if (_47 === 3) { - const _217: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds12 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _217.length); - const _216: rt.ByteSlice | undefined = rt.byteSliceGetRange(_217, bounds12[0], bounds12[1]); + const _217: rs.ByteSlice = rs.byteVecSlice(bytes); + const bounds12 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _217.length); + const _216: rs.ByteSlice | undefined = rs.byteSliceGetRange(_217, bounds12[0], bounds12[1]); if (_216 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { - rt.byteSliceView(_216).reverse(); + rs.byteSliceView(_216).reverse(); } - const _222: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, b); + const _222: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, b); if (_222 !== undefined) { - rt.byteSliceFill(_222, 119); + rs.byteSliceFill(_222, 119); } - const _230: rt.u16[] | undefined = rt.sliceGetRangeMut(words.items, a, b); + const _230: rs.u16[] | undefined = rs.sliceGetRangeMut(words.items, a, b); if (_230 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { pokeWords(3, _230); } - const _237: rt.u16[] = words.items; - const bounds13 = rt.sliceGetBounds({ end: b, inclusive: true }, _237.length); - const _236: rt.u16[] | undefined = rt.sliceGetRangeMut(_237, bounds13[0], bounds13[1]); + const _237: rs.u16[] = words.items; + const bounds13 = rs.sliceGetBounds({ end: b, inclusive: true }, _237.length); + const _236: rs.u16[] | undefined = rs.sliceGetRangeMut(_237, bounds13[0], bounds13[1]); if (_236 !== undefined) { pokeWords(4, _236); } const _245: Pair.Pair[] = pairs.items; - const bounds14 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _245.length); - const _244: Pair.Pair[] | undefined = rt.sliceGetRangeMut(_245, bounds14[0], bounds14[1]); + const bounds14 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _245.length); + const _244: Pair.Pair[] | undefined = rs.sliceGetRangeMut(_245, bounds14[0], bounds14[1]); if (_244 === undefined) { - rt.byteVecPush(out, 238); + rs.byteVecPush(out, 238); } else { pokePairs(5, _244); } - const _250: Pair.Pair[] | undefined = rt.sliceGetRangeMut(pairs.items, a); + const _250: Pair.Pair[] | undefined = rs.sliceGetRangeMut(pairs.items, a); if (_250 !== undefined) { pokePairs(6, _250); } - const _258: rt.u32[] = array; - const bounds15 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), _258.length); - const _257: rt.u32[] | undefined = rt.sliceGetRangeMut(_258, bounds15[0], bounds15[1]); + const _258: rs.u32[] = array; + const bounds15 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), _258.length); + const _257: rs.u32[] | undefined = rs.sliceGetRangeMut(_258, bounds15[0], bounds15[1]); if (_257 !== undefined) { pokeArray(_257); } } else if (_47 === 4) { - const stepped: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const iter2: rt.Iter = rt.iterTake(rt.iterBorrow(stepped), 8); - while (iter2.next() !== rt.DONE) { - } - const folded: rt.RangeInclusive = new rt.RangeInclusive(a, rt.min(b, reach), rt.usizeStep); - rt.iterSum(rt.iterBorrow(folded), rt.usizeAdd, 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.rangeInclusiveIsEmpty(stepped) ? 1 : 0, rt.rangeInclusiveIsEmpty(folded) ? 1 : 0)), undefined, true); - const _289: rt.u16[] = words.items; - const bounds6 = rt.sliceGetBounds(stepped.clone(), _289.length); - const _288: rt.u16[] | undefined = rt.sliceGetRange(_289, bounds6[0], bounds6[1]); + const stepped: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const iter2: rs.Iter = rs.iterTake(rs.iterBorrow(stepped), 8); + while (iter2.next() !== rs.DONE) { + } + const folded: rs.RangeInclusive = new rs.RangeInclusive(a, rs.min(b, reach), rs.usizeStep); + rs.iterSum(rs.iterBorrow(folded), rs.usizeAdd, 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.rangeInclusiveIsEmpty(stepped) ? 1 : 0, rs.rangeInclusiveIsEmpty(folded) ? 1 : 0)), undefined, true); + const _289: rs.u16[] = words.items; + const bounds6 = rs.sliceGetBounds(stepped.clone(), _289.length); + const _288: rs.u16[] | undefined = rs.sliceGetRange(_289, bounds6[0], bounds6[1]); if (_288 === undefined) { _287 = 238; } else { _287 = digestWords(_288); } - rt.byteVecPush(out, _287); - const _298: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds7 = rt.sliceGetBounds(folded.clone(), _298.length); - const _297: rt.ByteSlice | undefined = rt.byteSliceGetRange(_298, bounds7[0], bounds7[1]); + rs.byteVecPush(out, _287); + const _298: rs.ByteSlice = rs.byteVecSlice(bytes); + const bounds7 = rs.sliceGetBounds(folded.clone(), _298.length); + const _297: rs.ByteSlice | undefined = rs.byteSliceGetRange(_298, bounds7[0], bounds7[1]); if (_297 === undefined) { _296 = 238; } else { _296 = digest(_297); } - rt.byteVecPush(out, _296); + rs.byteVecPush(out, _296); const _307: Pair.Pair[] = pairs.items; - const bounds8 = rt.sliceGetBounds(folded.clone(), _307.length); - const _306: Pair.Pair[] | undefined = rt.sliceGetRangeMut(_307, bounds8[0], bounds8[1]); + const bounds8 = rs.sliceGetBounds(folded.clone(), _307.length); + const _306: Pair.Pair[] | undefined = rs.sliceGetRangeMut(_307, bounds8[0], bounds8[1]); if (_306 === undefined) { _305 = 238; } else { - _305 = ((p: Pair.Pair[]): rt.u8 => { + _305 = ((p: Pair.Pair[]): rs.u8 => { return digestPairs(p); })(_306); } - rt.byteVecPush(out, _305); - const bounds9 = rt.sliceIndexBounds(folded.clone(), words.items.length); - pokeWords(7, rt.sliceRangeMut(words.items, bounds9[0], bounds9[1])); - const _324: rt.RangeInclusive = stepped; - const slice3 = rt.byteVecSlice(bytes); - const bounds10 = rt.sliceIndexBounds(_324, slice3.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice3, bounds10[0], bounds10[1]))); - const _328: rt.RangeInclusive = folded; - const slice4 = rt.byteSliceRange(data, 2); - const bounds11 = rt.sliceIndexBounds(_328, slice4.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice4, bounds11[0], bounds11[1]))); + rs.byteVecPush(out, _305); + const bounds9 = rs.sliceIndexBounds(folded.clone(), words.items.length); + pokeWords(7, rs.sliceRangeMut(words.items, bounds9[0], bounds9[1])); + const _324: rs.RangeInclusive = stepped; + const slice3 = rs.byteVecSlice(bytes); + const bounds10 = rs.sliceIndexBounds(_324, slice3.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice3, bounds10[0], bounds10[1]))); + const _328: rs.RangeInclusive = folded; + const slice4 = rs.byteSliceRange(data, 2); + const bounds11 = rs.sliceIndexBounds(_328, slice4.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice4, bounds11[0], bounds11[1]))); } else if (_47 === 5) { - const part4 = rt.byteSliceRange(data, 2).length & 0xff; - const _333: rt.RangeBound = _329(a, part4); - const _332: [rt.RangeBound, rt.RangeBound] = [_333, _329(b, rt.u8Div(kind, 8))]; - const lo: rt.RangeBound = _333; - const hi: rt.RangeBound = _332[1]; - const _346: rt.ByteSlice = rt.byteVecSlice(bytes); - const bounds = rt.sliceGetBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], _346.length); - const _345: rt.ByteSlice | undefined = rt.byteSliceGetRange(_346, bounds[0], bounds[1]); + const part4 = rs.byteSliceRange(data, 2).length & 0xff; + const _333: rs.RangeBound = _329(a, part4); + const _332: [rs.RangeBound, rs.RangeBound] = [_333, _329(b, rs.u8Div(kind, 8))]; + const lo: rs.RangeBound = _333; + const hi: rs.RangeBound = _332[1]; + const _346: rs.ByteSlice = rs.byteVecSlice(bytes); + const bounds = rs.sliceGetBounds([lo, hi] as [rs.RangeBound, rs.RangeBound], _346.length); + const _345: rs.ByteSlice | undefined = rs.byteSliceGetRange(_346, bounds[0], bounds[1]); if (_345 === undefined) { _344 = 238; } else { _344 = digest(_345); } - rt.byteVecPush(out, _344); + rs.byteVecPush(out, _344); const _354: Pair.Pair[] = pairs.items; - const bounds2 = rt.sliceGetBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], _354.length); - const _353: Pair.Pair[] | undefined = rt.sliceGetRange(_354, bounds2[0], bounds2[1]); + const bounds2 = rs.sliceGetBounds([lo, hi] as [rs.RangeBound, rs.RangeBound], _354.length); + const _353: Pair.Pair[] | undefined = rs.sliceGetRange(_354, bounds2[0], bounds2[1]); if (_353 === undefined) { _352 = 238; } else { _352 = digestPairs(_353); } - rt.byteVecPush(out, _352); - const _360: rt.u16[] = words.items; - const bounds3 = rt.sliceGetBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], _360.length); - const _359: rt.u16[] | undefined = rt.sliceGetRangeMut(_360, bounds3[0], bounds3[1]); + rs.byteVecPush(out, _352); + const _360: rs.u16[] = words.items; + const bounds3 = rs.sliceGetBounds([lo, hi] as [rs.RangeBound, rs.RangeBound], _360.length); + const _359: rs.u16[] | undefined = rs.sliceGetRangeMut(_360, bounds3[0], bounds3[1]); if (_359 !== undefined) { pokeWords(8, _359); } - const bounds4 = rt.sliceIndexBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], pairs.items.length); - pokePairs(9, rt.sliceRangeMut(pairs.items, bounds4[0], bounds4[1])); - const slice2 = rt.byteVecSlice(bytes); - const bounds5 = rt.sliceIndexBounds([lo, hi] as [rt.RangeBound, rt.RangeBound], slice2.length); - rt.byteVecPush(out, digest(rt.byteSliceRange(slice2, bounds5[0], bounds5[1]))); + const bounds4 = rs.sliceIndexBounds([lo, hi] as [rs.RangeBound, rs.RangeBound], pairs.items.length); + pokePairs(9, rs.sliceRangeMut(pairs.items, bounds4[0], bounds4[1])); + const slice2 = rs.byteVecSlice(bytes); + const bounds5 = rs.sliceIndexBounds([lo, hi] as [rs.RangeBound, rs.RangeBound], slice2.length); + rs.byteVecPush(out, digest(rs.byteSliceRange(slice2, bounds5[0], bounds5[1]))); } else if (_47 === 6) { - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 0), (c2: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 0), (c2: rs.ByteSlice): rs.u8 => { return digest(c2); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3), (c3: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 3), (c3: rs.ByteSlice): rs.u8 => { return digest(c3); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 1), (c4: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.byteSliceLastChunk(rs.byteSliceRange(data, 2), 1), (c4: rs.ByteSlice): rs.u8 => { return digest(c4); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$0c2keyb(rt.byteSliceLastChunk(rt.byteSliceRange(data, 2), 4), (c5: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0q6fk7x(rs.byteSliceLastChunk(rs.byteSliceRange(data, 2), 4), (c5: rs.ByteSlice): rs.u8 => { return digest(c5); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(rt.sliceGetRange(words.items, 0, 4), (c6: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceGetRange(words.items, 0, 4), (c6: rs.u16[]): rs.u8 => { return digestWords(c6); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(rt.sliceLastChunk(words.items, 0), (c7: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceLastChunk(words.items, 0), (c7: rs.u16[]): rs.u8 => { return digestWords(c7); })), undefined, true); - rt.iterExtendBytes(out, rt.iterOption(option_map$11y9s7r(rt.sliceLastChunk(pairs.items, 3), (c8: Pair.Pair[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$0k54dqg(rs.sliceLastChunk(pairs.items, 3), (c8: Pair.Pair[]): rs.u8 => { return digestPairs(c8); })), undefined, true); - const slice: rt.ByteSlice = rt.byteVecSlice(bytes); + const slice: rs.ByteSlice = rs.byteVecSlice(bytes); if (slice.length >= 1) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(new rt.ByteSlice(slice.data, slice.start, 1)), digest(new rt.ByteSlice(slice.data, slice.start + 1, slice.length - 1)))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digest(new rs.ByteSlice(slice.data, slice.start, 1)), digest(new rs.ByteSlice(slice.data, slice.start + 1, slice.length - 1)))), undefined, true); } - const _417: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitLastChunk(rt.byteVecSlice(bytes), 4); + const _417: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitLastChunk(rs.byteVecSlice(bytes), 4); if (_417 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digest(_417[0]), digest(_417[1]))), undefined, true); } - const _428: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitAtChecked(words.items, 0); + const _428: [rs.u16[], rs.u16[]] | undefined = rs.sliceSplitAtChecked(words.items, 0); if (_428 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestWords(_428[0]), digestWords(_428[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestWords(_428[0]), digestWords(_428[1]))), undefined, true); } - const _439: [Pair.Pair[], Pair.Pair[]] | undefined = rt.sliceSplitLastChunk(pairs.items, 3); + const _439: [Pair.Pair[], Pair.Pair[]] | undefined = rs.sliceSplitLastChunk(pairs.items, 3); if (_439 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(_439[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digestPairs(_439[0]), digestPairs(_439[1]))), undefined, true); } - const _450: [rt.u32[], rt.u32[]] | undefined = rt.sliceSplitLastChunk(array, 5); + const _450: [rs.u32[], rs.u32[]] | undefined = rs.sliceSplitLastChunk(array, 5); if (_450 !== undefined) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_46(_450[0]), _46(_450[1]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_46(_450[0]), _46(_450[1]))), undefined, true); } } else { - const _465: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 3); + const _465: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 3); if (_465 !== undefined) { - const _470: rt.u8 = rt.u8WrappingAdd(_465.data[_465.start + 2], 1); + const _470: rs.u8 = rs.u8WrappingAdd(_465.data[_465.start + 2], 1); _465.data[_465.start] = _470; - rt.byteSliceView(_465).reverse(); + rs.byteSliceView(_465).reverse(); } - const _478: rt.ByteSlice | undefined = rt.byteSliceLastChunk(rt.byteVecSlice(bytes), 1); + const _478: rs.ByteSlice | undefined = rs.byteSliceLastChunk(rs.byteVecSlice(bytes), 1); if (_478 !== undefined) { _478.data[_478.start] = _478.data[_478.start] ^ 255; } - const _485: rt.u16[] | undefined = rt.sliceGetRangeMut(words.items, 0, 4); + const _485: rs.u16[] | undefined = rs.sliceGetRangeMut(words.items, 0, 4); if (_485 !== undefined) { pokeWords(10, _485); } - const _492: rt.u16[] | undefined = rt.sliceLastChunkMut(words.items, 0); + const _492: rs.u16[] | undefined = rs.sliceLastChunkMut(words.items, 0); if (_492 !== undefined) { pokeWords(11, _492); } - const _499: Pair.Pair[] | undefined = rt.sliceLastChunkMut(pairs.items, 3); + const _499: Pair.Pair[] | undefined = rs.sliceLastChunkMut(pairs.items, 3); if (_499 !== undefined) { pokePairs(12, _499); _499[0].b = 9; } - const _508: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(rt.byteVecSlice(bytes), 1); + const _508: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(rs.byteVecSlice(bytes), 1); if (_508 !== undefined) { _508[0].data[_508[0].start] = _508[1].length & 0xff; - rt.byteSliceView(_508[1]).reverse(); + rs.byteSliceView(_508[1]).reverse(); } - const _519: [rt.u16[], rt.u16[]] | undefined = rt.sliceSplitLastChunkMut(words.items, 4); + const _519: [rs.u16[], rs.u16[]] | undefined = rs.sliceSplitLastChunkMut(words.items, 4); if (_519 !== undefined) { pokeWords(13, _519[0]); - rt.sliceSwap(_519[1], 0, 3); + rs.sliceSwap(_519[1], 0, 3); _519[1][1] = 43981; } - const _530: [Pair.Pair[], Pair.Pair[]] | undefined = rt.sliceSplitAtMutChecked(pairs.items, 0); + const _530: [Pair.Pair[], Pair.Pair[]] | undefined = rs.sliceSplitAtMutChecked(pairs.items, 0); if (_530 !== undefined) { pokePairs(14, _530[0]); pokePairs(15, _530[1]); } - const _539: [Pair.Pair[], Pair.Pair[]] | undefined = rt.sliceSplitAtMutChecked(pairs.items, 2); + const _539: [Pair.Pair[], Pair.Pair[]] | undefined = rs.sliceSplitAtMutChecked(pairs.items, 2); if (_539 !== undefined) { - rt.idx(_539[1], 0); - rt.sliceSwapAcross(_539[0], 0, _539[1], 0); + rs.idx(_539[1], 0); + rs.sliceSwapAcross(_539[0], 0, _539[1], 0); _539[0][1].a = 3; } - const _556: [rt.u32[], rt.u32[]] | undefined = rt.sliceSplitLastChunkMut(array, 2); + const _556: [rs.u32[], rs.u32[]] | undefined = rs.sliceSplitLastChunkMut(array, 2); if (_556 !== undefined) { - _556[1][1] = _556[0].length as rt.u32; + _556[1][1] = _556[0].length as rs.u32; pokeArray(_556[0]); } } - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_25: rt.u16): rt.u8 => { - const w: rt.u16 = _25; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_25: rs.u16): rs.u8 => { + const w: rs.u16 = _25; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, digestPairs(pairs.items)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_26: rt.u32): rt.u8 => { - const x4: rt.u32 = _26; + rs.byteVecPush(out, digestPairs(pairs.items)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(array), (_26: rs.u32): rs.u8 => { + const x4: rs.u32 = _26; return ((x4 ^ (x4 >>> 13)) >>> 0) & 0xff; }), undefined, true); } @@ -1734,298 +1734,298 @@ export function ranges(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * options of them, on the whole slice and on mutable parts and chunks of it, at bounds * from the first three bytes, which may be out of bounds or backwards, which panics. */ -export function edits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function edits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { if (data.length >= 3) { - const reach: rt.usize = rt.usizeAdd(rt.byteSliceRange(data, 3).length, 2); - const _16: [rt.usize, rt.usize, rt.usize] = [rt.usizeRem(data.data[data.start] as rt.usize, reach), rt.usizeRem(data.data[data.start + 1] as rt.usize, reach), rt.usizeRem(data.data[data.start + 2] as rt.usize, reach)]; - const a: rt.usize = _16[0]; - const b: rt.usize = _16[1]; - const c: rt.usize = _16[2]; - const size: rt.usize = rt.usizeAdd(rt.usizeRem(c, 3), 1); - const bytes: rt.ByteVec = rt.byteSliceToByteVec(rt.byteSliceRange(data, 3)); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const reach: rs.usize = rs.usizeAdd(rs.byteSliceRange(data, 3).length, 2); + const _16: [rs.usize, rs.usize, rs.usize] = [rs.usizeRem(data.data[data.start] as rs.usize, reach), rs.usizeRem(data.data[data.start + 1] as rs.usize, reach), rs.usizeRem(data.data[data.start + 2] as rs.usize, reach)]; + const a: rs.usize = _16[0]; + const b: rs.usize = _16[1]; + const c: rs.usize = _16[2]; + const size: rs.usize = rs.usizeAdd(rs.usizeRem(c, 3), 1); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(rs.byteSliceRange(data, 3)); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_29: rt.u8): Pair.Pair => { - const b4: rt.u8 = _29; - return { a: b4, b: rt.u16Mul(b4 as rt.u16, 3) }; + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_29: rs.u8): Pair.Pair => { + const b4: rs.u8 = _29; + return { a: b4, b: rs.u16Mul(b4 as rs.u16, 3) }; }), undefined, 4, true); - const counted: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_211: rt.u8): Counted.Counted => { + const counted: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_211: rs.u8): Counted.Counted => { return { n: _211 }; }), undefined, 1, true); - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_212: rt.u8): Noisy.Noisy => { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_212: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_212); }), undefined, 1, true); - const array: rt.u32[] = Array.from({ length: 5 }, (): rt.u32 => { + const array: rs.u32[] = Array.from({ length: 5 }, (): rs.u32 => { return 0; }); - const iter: rt.Iter<[rt.Place, rt.u8]> = rt.iterZip(rt.iterSliceMut(array), rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), [false, false]); + const iter: rs.Iter<[rs.Place, rs.u8]> = rs.iterZip(rs.iterSliceMut(array), rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), [false, false]); while (true) { - const _53: [rt.Place, rt.u8] | rt.Done = iter.next(); - if (_53 === rt.DONE) { + const _53: [rs.Place, rs.u8] | rs.Done = iter.next(); + if (_53 === rs.DONE) { break; } - _53[0].v = rt.u32Mul(_53[1] as rt.u32, 65599); + _53[0].v = rs.u32Mul(_53[1] as rs.u32, 65599); } - const _60: rt.u8 = rt.u8Rem(kind, 8); + const _60: rs.u8 = rs.u8Rem(kind, 8); if (_60 === 0) { - rt.byteSliceFill(rt.byteVecSlice(bytes), c & 0xff); + rs.byteSliceFill(rs.byteVecSlice(bytes), c & 0xff); const part14 = a; - rt.byteSliceFill(rt.byteSliceRange(rt.byteVecSlice(bytes), part14), 90); - rt.sliceRangeMut(words.items, 0, b).fill(rt.u16Mul(c & 0xffff, 257)); - rt.sliceFill(pairs.items, { a: 1, b: 2 }, copy$slices_Pair); - const _81: Pair.Pair | undefined = rt.sliceFirst(pairs.items); + rs.byteSliceFill(rs.byteSliceRange(rs.byteVecSlice(bytes), part14), 90); + rs.sliceRangeMut(words.items, 0, b).fill(rs.u16Mul(c & 0xffff, 257)); + rs.sliceFill(pairs.items, { a: 1, b: 2 }, copy$slices_Pair); + const _81: Pair.Pair | undefined = rs.sliceFirst(pairs.items); if (_81 !== undefined) { _81.a = 9; } const pair: Pair.Pair = { a: 3, b: c & 0xffff }; - rt.sliceFill(rt.sliceRangeMut(pairs.items, a, b), copy$slices_Pair(pair), copy$slices_Pair); - const _92: Pair.Pair | undefined = rt.sliceGet(pairs.items, rt.usizeWrappingSub(b, 1)); + rs.sliceFill(rs.sliceRangeMut(pairs.items, a, b), copy$slices_Pair(pair), copy$slices_Pair); + const _92: Pair.Pair | undefined = rs.sliceGet(pairs.items, rs.usizeWrappingSub(b, 1)); if (_92 !== undefined) { _92.b = _92.b ^ 1; } - rt.byteVecPush(out, pair.b & 0xff); - rt.sliceFill(rt.sliceRangeMut(counted.items, 0, b), { n: 17 }, Counted.clone$Clone); + rs.byteVecPush(out, pair.b & 0xff); + rs.sliceFill(rs.sliceRangeMut(counted.items, 0, b), { n: 17 }, Counted.clone$Clone); flush(out); - rt.sliceFill(rt.sliceRangeMut(items.items, a), new Noisy.Noisy(32), Noisy.clone$Clone, rt.drop); + rs.sliceFill(rs.sliceRangeMut(items.items, a), new Noisy.Noisy(32), Noisy.clone$Clone, rs.drop); flush(out); - rt.sliceFill(rt.sliceRangeMut(items.items, 0, 0), new Noisy.Noisy(48), Noisy.clone$Clone, rt.drop); + rs.sliceFill(rs.sliceRangeMut(items.items, 0, 0), new Noisy.Noisy(48), Noisy.clone$Clone, rs.drop); flush(out); - rt.sliceFill(items.items, new Noisy.Noisy(c & 0xff), Noisy.clone$Clone, rt.drop); + rs.sliceFill(items.items, new Noisy.Noisy(c & 0xff), Noisy.clone$Clone, rs.drop); flush(out); - rt.sliceRangeMut(array, rt.min(a, 5)).fill(c as rt.u32); - const opts: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 3))), (_224: rt.u8): Noisy.Noisy | undefined => { + rs.sliceRangeMut(array, rs.min(a, 5)).fill(c as rs.u32); + const opts: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteSliceRange(data, 3))), (_224: rs.u8): Noisy.Noisy | undefined => { return new Noisy.Noisy(_224); }), undefined, 2, true); - rt.sliceFill(rt.sliceRangeMut(opts.items, a), undefined as Noisy.Noisy | undefined, option_clone$1omlcob, rt.drop); + rs.sliceFill(rs.sliceRangeMut(opts.items, a), undefined as Noisy.Noisy | undefined, option_clone$1omlcob, rs.drop); flush(out); - rt.sliceFill(opts.items, new Noisy.Noisy(64), option_clone$1omlcob, rt.drop); + rs.sliceFill(opts.items, new Noisy.Noisy(64), option_clone$1omlcob, rs.drop); flush(out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(opts.items), (o: Noisy.Noisy | undefined): rt.u8 => { - return option_mapOr$189goit(o, 238, (x: Noisy.Noisy): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(opts.items), (o: Noisy.Noisy | undefined): rs.u8 => { + return option_mapOr$135q041(o, 238, (x: Noisy.Noisy): rs.u8 => { return x.tag; }); }), undefined, true); - rt.dropVec(opts); + rs.dropVec(opts); } else if (_60 === 1) { - let n: rt.u8 = c & 0xff; - rt.byteSliceFillWith(rt.byteSliceRange(rt.byteVecSlice(bytes), 0, b), (): rt.u8 => { - n = rt.u8WrappingAdd(n, 3); + let n: rs.u8 = c & 0xff; + rs.byteSliceFillWith(rs.byteSliceRange(rs.byteVecSlice(bytes), 0, b), (): rs.u8 => { + n = rs.u8WrappingAdd(n, 3); return n; }); - rt.sliceFillWith(rt.sliceRangeMut(words.items, a), (): rt.u16 => { - n = rt.u8WrappingMul(n, 5); - return n as rt.u16; + rs.sliceFillWith(rs.sliceRangeMut(words.items, a), (): rs.u16 => { + n = rs.u8WrappingMul(n, 5); + return n as rs.u16; }); - rt.sliceFillWith(pairs.items, (): Pair.Pair => { + rs.sliceFillWith(pairs.items, (): Pair.Pair => { n = n ^ 33; - return { a: n, b: n as rt.u16 }; + return { a: n, b: n as rs.u16 }; }); - rt.sliceFillWith(rt.sliceRangeMut(counted.items, a, b), (): Counted.Counted => { + rs.sliceFillWith(rs.sliceRangeMut(counted.items, a, b), (): Counted.Counted => { return { n: 7 }; }); flush(out); - let tag: rt.u8 = 96; - rt.sliceFillWith(rt.sliceRangeMut(items.items, a), (): Noisy.Noisy => { - rt.localKeyWithBorrowMut(LOG, (log: rt.ByteVec): undefined => { - rt.byteVecPush(log, 254); + let tag: rs.u8 = 96; + rs.sliceFillWith(rs.sliceRangeMut(items.items, a), (): Noisy.Noisy => { + rs.localKeyWithBorrowMut(LOG, (log: rs.ByteVec): undefined => { + rs.byteVecPush(log, 254); }); - tag = rt.u8Add(tag, 1); + tag = rs.u8Add(tag, 1); return new Noisy.Noisy(tag); - }, rt.drop); + }, rs.drop); flush(out); const held: Noisy.Noisy = new Noisy.Noisy(112); const _184: Noisy.Noisy[] = items.items; const captured = held; - const _186: () => Noisy.Noisy = rt.closure((): Noisy.Noisy => { + const _186: () => Noisy.Noisy = rs.closure((): Noisy.Noisy => { return new Noisy.Noisy(captured.tag ^ 1); }, (): void => { captured[Symbol.dispose](); }); - rt.dropAfter(_186, () => rt.sliceFillWith(_184, _186, rt.drop)); + rs.dropAfter(_186, () => rs.sliceFillWith(_184, _186, rs.drop)); flush(out); - rt.byteVecPush(out, 153); - rt.sliceFillWith(array, (): rt.u32 => { + rs.byteVecPush(out, 153); + rs.sliceFillWith(array, (): rs.u32 => { return 0; }); } else if (_60 === 2) { - rt.byteSliceRotateLeft(rt.byteVecSlice(bytes), c); - rt.sliceRotateRight(words.items, a); - rt.sliceRotateLeft(rt.sliceRangeMut(pairs.items, a), b); - rt.sliceRotateRight(counted.items, c); - rt.sliceRotateLeft(items.items, c); + rs.byteSliceRotateLeft(rs.byteVecSlice(bytes), c); + rs.sliceRotateRight(words.items, a); + rs.sliceRotateLeft(rs.sliceRangeMut(pairs.items, a), b); + rs.sliceRotateRight(counted.items, c); + rs.sliceRotateLeft(items.items, c); flush(out); - rt.sliceRotateRight(array, c); - rt.byteSliceRotateRight(rt.byteSliceRange(rt.byteVecSlice(bytes), 0, b), a); + rs.sliceRotateRight(array, c); + rs.byteSliceRotateRight(rs.byteSliceRange(rs.byteVecSlice(bytes), 0, b), a); } else if (_60 === 3) { - const iter2: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.sliceChunksMut(words.items, size)); + const iter2: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.sliceChunksMut(words.items, size)); while (true) { - const _222: [rt.usize, rt.u16[]] | rt.Done = iter2.next(); - if (_222 === rt.DONE) { + const _222: [rs.usize, rs.u16[]] | rs.Done = iter2.next(); + if (_222 === rs.DONE) { break; } - rt.sliceRotateLeft(_222[1], rt.usizeRem(_222[0], rt.usizeAdd(_222[1].length, 1))); + rs.sliceRotateLeft(_222[1], rs.usizeRem(_222[0], rs.usizeAdd(_222[1].length, 1))); } - const iter3: rt.Iter = rt.sliceChunksExactMut(pairs.items, size); + const iter3: rs.Iter = rs.sliceChunksExactMut(pairs.items, size); while (true) { - const _239: Pair.Pair[] | rt.Done = iter3.next(); - if (_239 === rt.DONE) { + const _239: Pair.Pair[] | rs.Done = iter3.next(); + if (_239 === rs.DONE) { break; } - rt.sliceRotateRight(_239, 1); + rs.sliceRotateRight(_239, 1); } - const _246: [Noisy.Noisy[], Noisy.Noisy[]] = rt.sliceSplitAtMut(items.items, a); - rt.sliceRotateRight(_246[0], 0); - const n2: rt.usize = _246[1].length; - rt.sliceRotateLeft(_246[1], n2); - rt.sliceRotateRight(_246[1], rt.min(b, n2)); + const _246: [Noisy.Noisy[], Noisy.Noisy[]] = rs.sliceSplitAtMut(items.items, a); + rs.sliceRotateRight(_246[0], 0); + const n2: rs.usize = _246[1].length; + rs.sliceRotateLeft(_246[1], n2); + rs.sliceRotateRight(_246[1], rs.min(b, n2)); flush(out); - const _258: [rt.ByteSlice, rt.ByteSlice] = rt.byteSliceSplitAt(rt.byteVecSlice(bytes), rt.min(b, rt.byteSliceRange(data, 3).length)); - rt.byteSliceRotateLeft(_258[0], _258[0].length); - rt.byteSliceRotateRight(_258[1], rt.usizeDiv(_258[1].length, 2)); - rt.sliceRotateLeft(rt.sliceRangeMut(array, 1), c); + const _258: [rs.ByteSlice, rs.ByteSlice] = rs.byteSliceSplitAt(rs.byteVecSlice(bytes), rs.min(b, rs.byteSliceRange(data, 3).length)); + rs.byteSliceRotateLeft(_258[0], _258[0].length); + rs.byteSliceRotateRight(_258[1], rs.usizeDiv(_258[1].length, 2)); + rs.sliceRotateLeft(rs.sliceRangeMut(array, 1), c); } else if (_60 === 4) { - const _276: rt.ByteSlice = rt.byteVecSlice(bytes); - const _278: rt.Range = new rt.Range(a, b); - rt.byteSliceCopyWithin(_276, _278.start, _278.end, c); - const _280: rt.u16[] = words.items; - rt.sliceCopyWithin(_280, new rt.RangeFrom(a, rt.usizeStep).start, _280.length, c); - rt.sliceCopyWithin(pairs.items, 0, b, c, copy$slices_Pair); - const _287: Pair.Pair | undefined = rt.sliceGet(pairs.items, c); + const _276: rs.ByteSlice = rs.byteVecSlice(bytes); + const _278: rs.Range = new rs.Range(a, b); + rs.byteSliceCopyWithin(_276, _278.start, _278.end, c); + const _280: rs.u16[] = words.items; + rs.sliceCopyWithin(_280, new rs.RangeFrom(a, rs.usizeStep).start, _280.length, c); + rs.sliceCopyWithin(pairs.items, 0, b, c, copy$slices_Pair); + const _287: Pair.Pair | undefined = rs.sliceGet(pairs.items, c); if (_287 !== undefined) { _287.a = _287.a ^ 255; } const _293: Counted.Counted[] = counted.items; - const bounds = rt.boundsRange(new rt.RangeInclusive(a, b, rt.usizeStep), _293.length); - rt.sliceCopyWithin(_293, bounds[0], bounds[1], c); + const bounds = rs.boundsRange(new rs.RangeInclusive(a, b, rs.usizeStep), _293.length); + rs.sliceCopyWithin(_293, bounds[0], bounds[1], c); flush(out); - const _298: rt.u32[] = array; - rt.sliceCopyWithin(_298, new rt.RangeFrom(rt.min(a, 5), rt.usizeStep).start, _298.length, rt.min(c, 5)); - const part: rt.u16[] = rt.sliceRangeMut(words.items, rt.usizeDiv(a, 2)); - rt.sliceCopyWithin(part, new rt.RangeFrom(rt.usizeDiv(b, 2), rt.usizeStep).start, part.length, 0); - const _313: rt.ByteSlice = rt.byteVecSlice(bytes); - const _315: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound]; - const bounds2 = rt.boundsRange(_315, _313.length); - rt.byteSliceCopyWithin(_313, bounds2[0], bounds2[1], c); + const _298: rs.u32[] = array; + rs.sliceCopyWithin(_298, new rs.RangeFrom(rs.min(a, 5), rs.usizeStep).start, _298.length, rs.min(c, 5)); + const part: rs.u16[] = rs.sliceRangeMut(words.items, rs.usizeDiv(a, 2)); + rs.sliceCopyWithin(part, new rs.RangeFrom(rs.usizeDiv(b, 2), rs.usizeStep).start, part.length, 0); + const _313: rs.ByteSlice = rs.byteVecSlice(bytes); + const _315: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound]; + const bounds2 = rs.boundsRange(_315, _313.length); + rs.byteSliceCopyWithin(_313, bounds2[0], bounds2[1], c); } else if (_60 === 5) { - const _320: [rt.u16[], rt.u16[]] = rt.sliceSplitAtMut(words.items, a); - const n3: rt.usize = rt.min(_320[0].length, _320[1].length); - rt.sliceCopyFromSlice(rt.sliceRangeMut(_320[0], 0, n3), rt.sliceRange(_320[1], 0, n3)); - const _336: [Pair.Pair[], Pair.Pair[]] = rt.sliceSplitAtMut(pairs.items, b); - const n4: rt.usize = rt.min(_336[0].length, _336[1].length); - rt.sliceCopyFromSlice(rt.sliceRangeMut(_336[1], 0, n4), rt.sliceRange(_336[0], 0, n4), copy$slices_Pair); - const _350: Pair.Pair | undefined = rt.sliceFirst(_336[0]); + const _320: [rs.u16[], rs.u16[]] = rs.sliceSplitAtMut(words.items, a); + const n3: rs.usize = rs.min(_320[0].length, _320[1].length); + rs.sliceCopyFromSlice(rs.sliceRangeMut(_320[0], 0, n3), rs.sliceRange(_320[1], 0, n3)); + const _336: [Pair.Pair[], Pair.Pair[]] = rs.sliceSplitAtMut(pairs.items, b); + const n4: rs.usize = rs.min(_336[0].length, _336[1].length); + rs.sliceCopyFromSlice(rs.sliceRangeMut(_336[1], 0, n4), rs.sliceRange(_336[0], 0, n4), copy$slices_Pair); + const _350: Pair.Pair | undefined = rs.sliceFirst(_336[0]); if (_350 !== undefined) { _350.b = 48879; } - const other: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, c), (n9: rt.usize): Counted.Counted => { + const other: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, c), (n9: rs.usize): Counted.Counted => { return { n: n9 & 0xff }; }), undefined, 1, true); - const _357: Counted.Counted[] = rt.sliceRangeMut(counted.items, a); - const part8 = rt.usizeSub(rt.byteSliceRange(data, 3).length, a); - rt.sliceCopyFromSlice(_357, rt.sliceRange(other.items, 0, part8)); + const _357: Counted.Counted[] = rs.sliceRangeMut(counted.items, a); + const part8 = rs.usizeSub(rs.byteSliceRange(data, 3).length, a); + rs.sliceCopyFromSlice(_357, rs.sliceRange(other.items, 0, part8)); flush(out); - const more: rt.u32[] = Array.from({ length: 3 }, (): rt.u32 => { + const more: rs.u32[] = Array.from({ length: 3 }, (): rs.u32 => { return 0; }); - rt.sliceCopyFromSlice(more, rt.sliceRange(array, 0, 3)); - rt.sliceCopyFromSlice(rt.sliceRangeMut(array, 2), more); - const source: rt.Vec = rt.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair); - rt.sliceCopyFromSlice(rt.sliceRangeMut(pairs.items, 0, b), source.items, copy$slices_Pair); + rs.sliceCopyFromSlice(more, rs.sliceRange(array, 0, 3)); + rs.sliceCopyFromSlice(rs.sliceRangeMut(array, 2), more); + const source: rs.Vec = rs.vecFromElem({ a: 4, b: 5 }, c, copy$slices_Pair); + rs.sliceCopyFromSlice(rs.sliceRangeMut(pairs.items, 0, b), source.items, copy$slices_Pair); } else if (_60 === 6) { - const source2: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(0, c), (tag3: rt.usize): Noisy.Noisy => { + const source2: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(0, c), (tag3: rs.usize): Noisy.Noisy => { return new Noisy.Noisy((tag3 & 0xff) | 80); }), undefined, 1, true); - const n5: rt.usize = rt.min(rt.byteSliceRange(data, 3).length, c); - rt.sliceCloneFromSlice(rt.sliceRangeMut(items.items, 0, n5), rt.sliceRange(source2.items, 0, n5), Noisy.clone$Clone, rt.drop); + const n5: rs.usize = rs.min(rs.byteSliceRange(data, 3).length, c); + rs.sliceCloneFromSlice(rs.sliceRangeMut(items.items, 0, n5), rs.sliceRange(source2.items, 0, n5), Noisy.clone$Clone, rs.drop); flush(out); - const _403: [Counted.Counted[], Counted.Counted[]] = rt.sliceSplitAtMut(counted.items, a); - const n6: rt.usize = rt.min(_403[0].length, _403[1].length); - rt.sliceCloneFromSlice(rt.sliceRangeMut(_403[0], 0, n6), rt.sliceRange(_403[1], 0, n6), Counted.clone$Clone); + const _403: [Counted.Counted[], Counted.Counted[]] = rs.sliceSplitAtMut(counted.items, a); + const n6: rs.usize = rs.min(_403[0].length, _403[1].length); + rs.sliceCloneFromSlice(rs.sliceRangeMut(_403[0], 0, n6), rs.sliceRange(_403[1], 0, n6), Counted.clone$Clone); flush(out); - const _420: [Pair.Pair[], Pair.Pair[]] = rt.sliceSplitAtMut(pairs.items, a); - const n7: rt.usize = rt.min(_420[0].length, _420[1].length); - rt.sliceCopyFromSlice(rt.sliceRangeMut(_420[1], 0, n7), rt.sliceRange(_420[0], 0, n7), copy$slices_Pair); - const _434: Pair.Pair | undefined = rt.sliceFirst(_420[0]); + const _420: [Pair.Pair[], Pair.Pair[]] = rs.sliceSplitAtMut(pairs.items, a); + const n7: rs.usize = rs.min(_420[0].length, _420[1].length); + rs.sliceCopyFromSlice(rs.sliceRangeMut(_420[1], 0, n7), rs.sliceRange(_420[0], 0, n7), copy$slices_Pair); + const _434: Pair.Pair | undefined = rs.sliceFirst(_420[0]); if (_434 !== undefined) { _434.b = 48879; } - const _438: rt.u16[] = rt.sliceRangeMut(words.items, a); - const _442: rt.u16[] = [7, 8, 9]; - rt.sliceCopyFromSlice(_438, rt.sliceRange(_442, 0, rt.min(b, 3))); - rt.sliceCloneFromSlice(rt.sliceRangeMut(items.items, a), rt.sliceRange(source2.items, 0, rt.min(b, c)), Noisy.clone$Clone, rt.drop); + const _438: rs.u16[] = rs.sliceRangeMut(words.items, a); + const _442: rs.u16[] = [7, 8, 9]; + rs.sliceCopyFromSlice(_438, rs.sliceRange(_442, 0, rs.min(b, 3))); + rs.sliceCloneFromSlice(rs.sliceRangeMut(items.items, a), rs.sliceRange(source2.items, 0, rs.min(b, c)), Noisy.clone$Clone, rs.drop); flush(out); - rt.sliceCopyFromSlice(rt.sliceRangeMut(pairs.items, 0, c), [{ a: 1, b: 1 }, { a: 1, b: 1 }], copy$slices_Pair); - rt.dropVec(source2); + rs.sliceCopyFromSlice(rs.sliceRangeMut(pairs.items, 0, c), [{ a: 1, b: 1 }, { a: 1, b: 1 }], copy$slices_Pair); + rs.dropVec(source2); } else { - const iter4: rt.Iter<[rt.usize, Pair.Pair[]]> = rt.iterEnumerate(rt.sliceChunksMut(pairs.items, size)); + const iter4: rs.Iter<[rs.usize, Pair.Pair[]]> = rs.iterEnumerate(rs.sliceChunksMut(pairs.items, size)); while (true) { - const _467: [rt.usize, Pair.Pair[]] | rt.Done = iter4.next(); - if (_467 === rt.DONE) { + const _467: [rs.usize, Pair.Pair[]] | rs.Done = iter4.next(); + if (_467 === rs.DONE) { break; } - const i2: rt.usize = _467[0]; - const _472: rt.usize = rt.usizeRem(i2, 3); + const i2: rs.usize = _467[0]; + const _472: rs.usize = rs.usizeRem(i2, 3); if (_472 === 0) { - rt.sliceFill(_467[1], { a: i2 & 0xff, b: 0 }, copy$slices_Pair); + rs.sliceFill(_467[1], { a: i2 & 0xff, b: 0 }, copy$slices_Pair); } else if (_472 === 1) { const slice = _467[1]; - rt.sliceCopyWithin(slice, 1, slice.length, 0, copy$slices_Pair); + rs.sliceCopyWithin(slice, 1, slice.length, 0, copy$slices_Pair); } else { - rt.sliceRotateLeft(_467[1], 1); + rs.sliceRotateLeft(_467[1], 1); } } - const it: rt.Iter = rt.sliceRchunksExactMut(items.items, size); - const _480: [Noisy.Noisy[] | undefined, Noisy.Noisy[] | undefined] = [rt.iterToOption(it.next()), rt.iterToOption(it.next())]; + const it: rs.Iter = rs.sliceRchunksExactMut(items.items, size); + const _480: [Noisy.Noisy[] | undefined, Noisy.Noisy[] | undefined] = [rs.iterToOption(it.next()), rs.iterToOption(it.next())]; if (_480[0] !== undefined) { if (_480[1] !== undefined) { - rt.sliceCloneFromSlice(_480[0], _480[1], Noisy.clone$Clone, rt.drop); - rt.sliceRotateRight(_480[1], 1); - rt.sliceFill(_480[1], new Noisy.Noisy(15), Noisy.clone$Clone, rt.drop); + rs.sliceCloneFromSlice(_480[0], _480[1], Noisy.clone$Clone, rs.drop); + rs.sliceRotateRight(_480[1], 1); + rs.sliceFill(_480[1], new Noisy.Noisy(15), Noisy.clone$Clone, rs.drop); } } flush(out); - const iter5: rt.Iter = rt.sliceChunksExactMut(words.items, size); + const iter5: rs.Iter = rs.sliceChunksExactMut(words.items, size); while (true) { - const _500: rt.u16[] | rt.Done = iter5.next(); - if (_500 === rt.DONE) { + const _500: rs.u16[] | rs.Done = iter5.next(); + if (_500 === rs.DONE) { break; } - rt.sliceFillWith(_500, (): rt.u16 => { + rs.sliceFillWith(_500, (): rs.u16 => { return a & 0xffff; }); } - const _507: [Counted.Counted[], Counted.Counted[]] | undefined = rt.sliceSplitAtMutChecked(counted.items, 1); + const _507: [Counted.Counted[], Counted.Counted[]] | undefined = rs.sliceSplitAtMutChecked(counted.items, 1); if (_507 !== undefined) { - rt.sliceCopyFromSlice(_507[0], rt.sliceRange(_507[1], 0, rt.min(1, _507[1].length))); + rs.sliceCopyFromSlice(_507[0], rs.sliceRange(_507[1], 0, rs.min(1, _507[1].length))); } flush(out); } flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_225: rt.u16): rt.u8 => { - const w: rt.u16 = _225; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_225: rs.u16): rs.u8 => { + const w: rs.u16 = _225; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, digestPairs(pairs.items)); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(counted.items), (x2: Counted.Counted): rt.u8 => { + rs.byteVecPush(out, digestPairs(pairs.items)); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(counted.items), (x2: Counted.Counted): rs.u8 => { return x2.n; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(items.items), (x3: Noisy.Noisy): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(items.items), (x3: Noisy.Noisy): rs.u8 => { return x3.tag; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(array), (_226: rt.u32): rt.u8 => { - const x4: rt.u32 = _226; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(array), (_226: rs.u32): rs.u8 => { + const x4: rs.u32 = _226; return ((x4 ^ (x4 >>> 13)) >>> 0) & 0xff; }), undefined, true); - rt.dropVec(items); + rs.dropVec(items); flush(out); } } /** How many runs of `N` `data` holds, by `as_chunks`, which panics at none. */ -export function runs$0(data: rt.ByteSlice): rt.u8 { - return rt.byteSliceAsChunks(data, 0)[0].length & 0xff; +export function runs$0(data: rs.ByteSlice): rs.u8 { + return rs.byteSliceAsChunks(data, 0)[0].length & 0xff; } /** @@ -2034,140 +2034,140 @@ export function runs$0(data: rt.ByteSlice): rt.u8 { * chunk, and at none, which panics; and a `Vec` cloned from a shared and a mutable slice * and array, which later writes to what it cloned leave as they were. */ -export function arrays(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _11: (a0: Noisy.Noisy[]) => rt.u8 = (s: Noisy.Noisy[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(s), s.length & 0xff, (acc: rt.u8, x: Noisy.Noisy): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ x.tag; +export function arrays(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _11: (a0: Noisy.Noisy[]) => rs.u8 = (s: Noisy.Noisy[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(s), s.length & 0xff, (acc: rs.u8, x: Noisy.Noisy): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ x.tag; }); }; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): Noisy.Noisy => { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): Noisy.Noisy => { return new Noisy.Noisy(_26); }), undefined, 1, true); - const _13: rt.u8 = rt.u8Rem(kind, 4); + const _13: rs.u8 = rs.u8Rem(kind, 4); if (_13 === 0) { - const _17: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunks(data, 2); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_17[0]), rt.byteSliceFrom), (c3: rt.ByteSlice): rt.u8 => { + const _17: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunks(data, 2); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_17[0]), rs.byteSliceFrom), (c3: rs.ByteSlice): rs.u8 => { return digest(c3); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_17[0].length & 0xff, digest(_17[1]))), undefined, true); - const _28: [rt.ByteSlice, Uint8Array[]] = rt.byteSliceAsRchunks(data, 3); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_28[1]), rt.byteSliceFrom), (c4: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_17[0].length & 0xff, digest(_17[1]))), undefined, true); + const _28: [rs.ByteSlice, Uint8Array[]] = rs.byteSliceAsRchunks(data, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_28[1]), rs.byteSliceFrom), (c4: rs.ByteSlice): rs.u8 => { return c4.data[c4.start] ^ c4.data[c4.start + 2]; }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_28[1].length & 0xff, digest(_28[0]))), undefined, true); - const _39: [rt.u16[][], rt.u16[]] = rt.sliceAsChunks(words.items, 3); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_39[0]), (c5: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_28[1].length & 0xff, digest(_28[0]))), undefined, true); + const _39: [rs.u16[][], rs.u16[]] = rs.sliceAsChunks(words.items, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_39[0]), (c5: rs.u16[]): rs.u8 => { return digestWords(c5); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_39[0].length & 0xff, digestWords(_39[1]))), undefined, true); - const _52: [rt.u16[], rt.u16[][]] = rt.sliceAsRchunks(words.items, 1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_52[1]), (_211: rt.u16[]): rt.u8 => { - return rt.u16Shr(_211[0], 4) & 0xff; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_39[0].length & 0xff, digestWords(_39[1]))), undefined, true); + const _52: [rs.u16[], rs.u16[][]] = rs.sliceAsRchunks(words.items, 1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_52[1]), (_211: rs.u16[]): rs.u8 => { + return rs.u16Shr(_211[0], 4) & 0xff; }), undefined, true); - rt.byteVecPush(out, _52[0].length & 0xff); - const _63: [Noisy.Noisy[][], Noisy.Noisy[]] = rt.sliceAsChunks(items.items, 3); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_63[0]), (c6: Noisy.Noisy[]): rt.u8 => { + rs.byteVecPush(out, _52[0].length & 0xff); + const _63: [Noisy.Noisy[][], Noisy.Noisy[]] = rs.sliceAsChunks(items.items, 3); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_63[0]), (c6: Noisy.Noisy[]): rs.u8 => { return _11(c6); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_63[0].length & 0xff, _11(_63[1]))), undefined, true); - const _80: [Noisy.Noisy[], Noisy.Noisy[][]] = rt.sliceAsRchunks(items.items, 2); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_80[1]), (c7: Noisy.Noisy[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_63[0].length & 0xff, _11(_63[1]))), undefined, true); + const _80: [Noisy.Noisy[], Noisy.Noisy[][]] = rs.sliceAsRchunks(items.items, 2); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_80[1]), (c7: Noisy.Noisy[]): rs.u8 => { return _11(c7); }), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_80[1].length & 0xff, _11(_80[0]))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_80[1].length & 0xff, _11(_80[0]))), undefined, true); } else if (_13 === 1) { - const _97: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunks(rt.byteSliceRange(data, 0, 0), 4); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_97[0].length & 0xff, _97[1].length & 0xff)), undefined, true); - const _108: [Noisy.Noisy[], Noisy.Noisy[][]] = rt.sliceAsRchunks(rt.sliceRange(items.items, 0, 0), 2); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_108[1].length & 0xff, _108[0].length & 0xff)), undefined, true); - const start: rt.usize = rt.usizeDiv(data.length, 3); - const _123: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunks(rt.byteSliceRange(data, start), 3); - const iter: rt.Iter = rt.iterLend(rt.iterSlice(_123[0]), rt.byteSliceFrom); + const _97: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteSliceRange(data, 0, 0), 4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_97[0].length & 0xff, _97[1].length & 0xff)), undefined, true); + const _108: [Noisy.Noisy[], Noisy.Noisy[][]] = rs.sliceAsRchunks(rs.sliceRange(items.items, 0, 0), 2); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_108[1].length & 0xff, _108[0].length & 0xff)), undefined, true); + const start: rs.usize = rs.usizeDiv(data.length, 3); + const _123: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteSliceRange(data, start), 3); + const iter: rs.Iter = rs.iterLend(rs.iterSlice(_123[0]), rs.byteSliceFrom); while (true) { - const _128: rt.ByteSlice | rt.Done = iter.next(); - if (_128 === rt.DONE) { + const _128: rs.ByteSlice | rs.Done = iter.next(); + if (_128 === rs.DONE) { break; } - const _134: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunks(_128, 2); - const _138: rt.u8 = _134[0].length & 0xff; - rt.idx(_134[0], 0); - const _141: rt.u8 = _134[0][0][1]; - rt.idx(_134[1], 0); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_138, _141 ^ _134[1].data[_134[1].start])), undefined, true); + const _134: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunks(_128, 2); + const _138: rs.u8 = _134[0].length & 0xff; + rs.idx(_134[0], 0); + const _141: rs.u8 = _134[0][0][1]; + rs.idx(_134[1], 0); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_138, _141 ^ _134[1].data[_134[1].start])), undefined, true); } - rt.byteVecPush(out, digest(_123[1])); - const _155: [rt.u16[], rt.u16[][]] = rt.sliceAsRchunks(rt.sliceRange(words.items, start), 2); - rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(rt.sliceLast(_155[1]), (c: rt.u16[]): rt.u8 => { + rs.byteVecPush(out, digest(_123[1])); + const _155: [rs.u16[], rs.u16[][]] = rs.sliceAsRchunks(rs.sliceRange(words.items, start), 2); + rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(rs.sliceLast(_155[1]), (c: rs.u16[]): rs.u8 => { return digestWords(c); })), undefined, true); - rt.byteVecPush(out, digestWords(_155[0])); - const _165: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunks(rt.byteVecSlice(bytes), 2); - const _169: [rt.ByteSlice, Uint8Array[]] = rt.byteSliceAsRchunks(rt.byteSliceRange(rt.byteVecSlice(bytes), 1), 2); - rt.iterExtendBytes(out, rt.iterSlice(rt.bytesMap([isSomeAnd$0eocbrl(zip$0n9ueec(rt.optionMap(rt.sliceFirst(_165[0]), rt.byteSliceFrom), rt.byteSliceGetRange(rt.byteVecSlice(bytes), 0, 2)), (_27: [rt.ByteSlice, rt.ByteSlice]): boolean => { - return rt.byteSliceSame(_27[0], _27[1]); - }), isSomeAnd$0eocbrl(zip$0n9ueec(rt.optionMap(rt.sliceFirst(_165[0]), rt.byteSliceFrom), rt.optionMap(rt.sliceFirst(rt.byteSliceAsChunks(rt.byteVecSlice(bytes), 2)[0]), rt.byteSliceFrom)), (_29: [rt.ByteSlice, rt.ByteSlice]): boolean => { - return rt.byteSliceSame(_29[0], _29[1]); - }), isSomeAnd$0eocbrl(zip$0n9ueec(rt.optionMap(rt.sliceLast(_169[1]), rt.byteSliceFrom), rt.optionMap(rt.sliceLast(_165[0]), rt.byteSliceFrom)), (_210: [rt.ByteSlice, rt.ByteSlice]): boolean => { - return rt.byteSliceSame(_210[0], _210[1]); - })], (a0: boolean): rt.u8 => { + rs.byteVecPush(out, digestWords(_155[0])); + const _165: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunks(rs.byteVecSlice(bytes), 2); + const _169: [rs.ByteSlice, Uint8Array[]] = rs.byteSliceAsRchunks(rs.byteSliceRange(rs.byteVecSlice(bytes), 1), 2); + rs.iterExtendBytes(out, rs.iterSlice(rs.bytesMap([isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.byteSliceGetRange(rs.byteVecSlice(bytes), 0, 2)), (_27: [rs.ByteSlice, rs.ByteSlice]): boolean => { + return rs.byteSliceSame(_27[0], _27[1]); + }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.optionMap(rs.sliceFirst(rs.byteSliceAsChunks(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceFrom)), (_29: [rs.ByteSlice, rs.ByteSlice]): boolean => { + return rs.byteSliceSame(_29[0], _29[1]); + }), isSomeAnd$1ouf3e6(zip$0wdt346(rs.optionMap(rs.sliceLast(_169[1]), rs.byteSliceFrom), rs.optionMap(rs.sliceLast(_165[0]), rs.byteSliceFrom)), (_210: [rs.ByteSlice, rs.ByteSlice]): boolean => { + return rs.byteSliceSame(_210[0], _210[1]); + })], (a0: boolean): rs.u8 => { return a0 ? 1 : 0; })), undefined, true); - const kept: Uint8Array | undefined = copy$Option_array2_u8(rt.optionMap(rt.optionMap(rt.sliceFirst(_165[0]), rt.byteSliceFrom), rt.byteSliceView)); - const _195: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.byteVecSlice(bytes))); + const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.optionMap(rs.sliceFirst(_165[0]), rs.byteSliceFrom), rs.byteSliceView)); + const _195: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.byteVecSlice(bytes))); if (_195 !== undefined) { _195.v = _195.v ^ 255; } - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const kept2: rt.u16[] | undefined = copy$Option_array2_u16(rt.sliceFirst(rt.sliceAsChunks(words.items, 2)[0])); - const _208: rt.Place | undefined = rt.sliceFirstMut(words.items); + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const kept2: rs.u16[] | undefined = copy$Option_array2_u16(rs.sliceFirst(rs.sliceAsChunks(words.items, 2)[0])); + const _208: rs.Place | undefined = rs.sliceFirstMut(words.items); if (_208 !== undefined) { _208.v = _208.v ^ 65535; } - rt.iterExtendBytes(out, rt.iterOption(option_map$1wqzuhy(kept2, (c2: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterOption(option_map$1sh08h7(kept2, (c2: rs.u16[]): rs.u8 => { return digestWords(c2); })), undefined, true); } else if (_13 === 2) { - const owned: rt.ByteVec = rt.byteSliceToByteVec(data); - const copied: rt.Vec = rt.vecFrom(words.items.slice()); - const cloned: rt.Vec = rt.vecFrom(rt.sliceRange(items.items, 0).map(Noisy.clone$Clone)); - const more: rt.Vec = rt.vecFrom(rt.sliceRangeMut(items.items, rt.min(1, data.length)).map(Noisy.clone$Clone)); + const owned: rs.ByteVec = rs.byteSliceToByteVec(data); + const copied: rs.Vec = rs.vecFrom(words.items.slice()); + const cloned: rs.Vec = rs.vecFrom(rs.sliceRange(items.items, 0).map(Noisy.clone$Clone)); + const more: rs.Vec = rs.vecFrom(rs.sliceRangeMut(items.items, rs.min(1, data.length)).map(Noisy.clone$Clone)); const array: Noisy.Noisy[] = [new Noisy.Noisy(49), new Noisy.Noisy(50)]; const arrayBytes: Uint8Array = Uint8Array.of(data.length & 0xff, 7); - const fromArray: [rt.Vec, rt.ByteVec] = [rt.vecFrom(array.map(Noisy.clone$Clone)), rt.byteSliceToByteVec(rt.byteSliceFrom(arrayBytes))]; + const fromArray: [rs.Vec, rs.ByteVec] = [rs.vecFrom(array.map(Noisy.clone$Clone)), rs.byteSliceToByteVec(rs.byteSliceFrom(arrayBytes))]; flush(out); - rt.byteSliceView(rt.byteVecSlice(bytes)).reverse(); + rs.byteSliceView(rs.byteVecSlice(bytes)).reverse(); words.items.fill(3); - rt.vecTruncate(items, 0, rt.drop); + rs.vecTruncate(items, 0, rs.drop); arrayBytes[0] = 0; flush(out); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(digest(rt.byteVecSlice(owned)), digestWords(copied.items), _11(cloned.items), _11(more.items))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_11(fromArray[0].items), digest(rt.byteVecSlice(fromArray[1])), arrayBytes[0])), undefined, true); - rt.dropVec(cloned); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(digest(rs.byteVecSlice(owned)), digestWords(copied.items), _11(cloned.items), _11(more.items))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_11(fromArray[0].items), digest(rs.byteVecSlice(fromArray[1])), arrayBytes[0])), undefined, true); + rs.dropVec(cloned); drop$tuple2_Vec_slices_Noisy_Vec_u8(fromArray); flush(out); - rt.dropAll(array); - rt.dropVec(more); + rs.dropAll(array); + rs.dropVec(more); } else { - rt.byteVecPush(out, runs$0(data)); + rs.byteVecPush(out, runs$0(data)); } flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_212: rt.u16): rt.u8 => { - const w: rt.u16 = _212; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_212: rs.u16): rs.u8 => { + const w: rs.u16 = _212; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, _11(items.items)); - rt.dropVec(items); + rs.byteVecPush(out, _11(items.items)); + rs.dropVec(items); flush(out); } /** How many runs of `N` `data` holds, by `as_chunks_mut`, which panics at none. */ -export function runsMut$0(data: rt.ByteSlice): rt.u8 { - return rt.byteSliceAsChunksMut(data, 0)[0].length & 0xff; +export function runsMut$0(data: rs.ByteSlice): rs.u8 { + return rs.byteSliceAsChunksMut(data, 0)[0].length & 0xff; } /** @@ -2176,392 +2176,392 @@ export function runsMut$0(data: rt.ByteSlice): rt.u8 { * filtering them, and whole after a read of a run by value, which keeps what it read, as * does one the slice's own writes follow; and at none, which panics. */ -export function arraysMut(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _11: (a0: Item.Item[]) => rt.u8 = (s: Item.Item[]): rt.u8 => { - return rt.iterFold(rt.iterSlice(s), s.length & 0xff, (acc: rt.u8, x: Item.Item): rt.u8 => { - return rt.u8WrappingMul(acc, 31) ^ x.tag; +export function arraysMut(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _11: (a0: Item.Item[]) => rs.u8 = (s: Item.Item[]): rs.u8 => { + return rs.iterFold(rs.iterSlice(s), s.length & 0xff, (acc: rs.u8, x: Item.Item): rs.u8 => { + return rs.u8WrappingMul(acc, 31) ^ x.tag; }); }; - const bytes: rt.ByteVec = rt.byteSliceToByteVec(data); - const words: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - return rt.u16Mul(_2 as rt.u16, 257); + const bytes: rs.ByteVec = rs.byteSliceToByteVec(data); + const words: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + return rs.u16Mul(_2 as rs.u16, 257); }), undefined, 2, true); - const items: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): Item.Item => { + const items: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): Item.Item => { return new Item.Item(_22); }), undefined, 1, true); - const _12: rt.u8 = rt.u8Rem(kind, 5); + const _12: rs.u8 = rs.u8Rem(kind, 5); if (_12 === 0) { - const _16: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunksMut(rt.byteVecSlice(bytes), 3); - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.iterLend(rt.iterSlice(_16[0]), rt.byteSliceFrom)); + const _16: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 3); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.iterLend(rs.iterSlice(_16[0]), rs.byteSliceFrom)); while (true) { - const _23: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_23 === rs.DONE) { break; } _23[1].data[_23[1].start] = _23[1].data[_23[1].start] ^ (_23[0] & 0xff); const swapped: Uint8Array = Uint8Array.of(_23[1].data[_23[1].start + 2], _23[1].data[_23[1].start + 1]); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(_23[1], 1), rt.byteSliceFrom(swapped)); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(_23[1], 1), rs.byteSliceFrom(swapped)); } - const iter2: rt.Iter<[rt.ByteSlice, rt.u8]> = rt.iterZip(rt.iterRev(rt.iterLend(rt.iterSlice(_16[0]), rt.byteSliceFrom)), rt.iterSlice(rt.byteSliceView(data)), "len"); + const iter2: rs.Iter<[rs.ByteSlice, rs.u8]> = rs.iterZip(rs.iterRev(rs.iterLend(rs.iterSlice(_16[0]), rs.byteSliceFrom)), rs.iterSlice(rs.byteSliceView(data)), "len"); while (true) { - const _48: [rt.ByteSlice, rt.u8] | rt.Done = iter2.next(); - if (_48 === rt.DONE) { + const _48: [rs.ByteSlice, rs.u8] | rs.Done = iter2.next(); + if (_48 === rs.DONE) { break; } - const _53: rt.u8 = rt.u8WrappingAdd(_48[0].data[_48[0].start + 2], _48[1]); + const _53: rs.u8 = rs.u8WrappingAdd(_48[0].data[_48[0].start + 2], _48[1]); _48[0].data[_48[0].start + 2] = _53; } - const odd: rt.Peekable = rt.iterPeekable(rt.iterFilter(rt.iterLend(rt.iterSlice(_16[0]), rt.byteSliceFrom), (c33: rt.ByteSlice): boolean => { - const _719: rt.ByteSlice = c33; + const odd: rs.Peekable = rs.iterPeekable(rs.iterFilter(rs.iterLend(rs.iterSlice(_16[0]), rs.byteSliceFrom), (c33: rs.ByteSlice): boolean => { + const _719: rs.ByteSlice = c33; return (_719.data[_719.start] & 1) !== 0; })); - const _62: rt.Place | undefined = rt.peekablePeekMut(odd, true); + const _62: rs.Place | undefined = rs.peekablePeekMut(odd, true); if (_62 !== undefined) { - const _963: rt.ByteSlice = _62.v; - const _964: rt.ByteSlice = _62.v; + const _963: rs.ByteSlice = _62.v; + const _964: rs.ByteSlice = _62.v; _963.data[_963.start + 1] = _964.data[_964.start + 1] | 128; } - const iter3: rt.Peekable = odd; + const iter3: rs.Peekable = odd; while (true) { - const _71: rt.ByteSlice | rt.Done = iter3.next(); - if (_71 === rt.DONE) { + const _71: rs.ByteSlice | rs.Done = iter3.next(); + if (_71 === rs.DONE) { break; } _71.data[_71.start] = ~_71.data[_71.start] & 0xff; } - rt.byteSliceFill(_16[1], 1); - const _83: [rt.u16[], rt.u16[][]] = rt.sliceAsRchunksMut(words.items, 2); - const iter4: rt.Iter<[rt.usize, rt.u16[]]> = rt.iterEnumerate(rt.iterSlice(_83[1])); + rs.byteSliceFill(_16[1], 1); + const _83: [rs.u16[], rs.u16[][]] = rs.sliceAsRchunksMut(words.items, 2); + const iter4: rs.Iter<[rs.usize, rs.u16[]]> = rs.iterEnumerate(rs.iterSlice(_83[1])); while (true) { - const _90: [rt.usize, rt.u16[]] | rt.Done = iter4.next(); - if (_90 === rt.DONE) { + const _90: [rs.usize, rs.u16[]] | rs.Done = iter4.next(); + if (_90 === rs.DONE) { break; } _90[1][0] = _90[1][0] ^ (_90[0] & 0xffff); - _90[1][1] = rt.intRotateLeft(_90[1][1], 3, 16, false); + _90[1][1] = rs.intRotateLeft(_90[1][1], 3, 16, false); } _83[0].fill(1); - const part7 = rt.usizeDiv(data.length, 3); - const iter5: rt.Iter = rt.iterLend(rt.iterSlice(rt.byteSliceAsChunksMut(rt.byteSliceRange(rt.byteVecSlice(bytes), part7), 2)[0]), rt.byteSliceFrom); + const part7 = rs.usizeDiv(data.length, 3); + const iter5: rs.Iter = rs.iterLend(rs.iterSlice(rs.byteSliceAsChunksMut(rs.byteSliceRange(rs.byteVecSlice(bytes), part7), 2)[0]), rs.byteSliceFrom); while (true) { - const _110: rt.ByteSlice | rt.Done = iter5.next(); - if (_110 === rt.DONE) { + const _110: rs.ByteSlice | rs.Done = iter5.next(); + if (_110 === rs.DONE) { break; } - rt.byteSliceSwap(_110, 0, 1); + rs.byteSliceSwap(_110, 0, 1); } - const kept: Uint8Array | undefined = copy$Option_array2_u8(rt.optionMap(rt.optionMap(rt.sliceFirst(rt.byteSliceAsChunksMut(rt.byteVecSlice(bytes), 2)[0]), rt.byteSliceFrom), rt.byteSliceView)); - const keptWords: rt.u16[] | undefined = copy$Option_array2_u16(rt.sliceFirst(rt.sliceAsChunksMut(words.items, 2)[0])); - rt.byteSliceFill(rt.byteVecSlice(bytes), 9); + const kept: Uint8Array | undefined = copy$Option_array2_u8(rs.optionMap(rs.optionMap(rs.sliceFirst(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0]), rs.byteSliceFrom), rs.byteSliceView)); + const keptWords: rs.u16[] | undefined = copy$Option_array2_u16(rs.sliceFirst(rs.sliceAsChunksMut(words.items, 2)[0])); + rs.byteSliceFill(rs.byteVecSlice(bytes), 9); words.items.fill(9); - rt.iterExtendBytes(out, rt.iterFlatten(rt.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterFlatten(rt.iterOption(copy$Option_array2_u16(keptWords)), (value: rt.u16[]) => rt.iterSlice(value), true, 2), (w2: rt.u16): rt.u8 => { + rs.iterExtendBytes(out, rs.iterFlatten(rs.iterOption(copy$Option_array2_u8(kept)), (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterFlatten(rs.iterOption(copy$Option_array2_u16(keptWords)), (value: rs.u16[]) => rs.iterSlice(value), true, 2), (w2: rs.u16): rs.u8 => { return (w2 ^ (w2 >> 8)) & 0xff; }), undefined, true); } else if (_12 === 1) { - const _142: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunksMut(rt.byteVecSlice(bytes), 2); + const _142: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2); if (_142[0].length >= 2) { - const first: rt.ByteSlice = rt.byteSliceFrom(_142[0][0]); - const last: rt.ByteSlice = rt.byteSliceFrom(_142[0][_142[0].length - 1]); - const _152: [Uint8Array, Uint8Array] = [rt.byteSliceToArray(first), rt.byteSliceToArray(last)]; + const first: rs.ByteSlice = rs.byteSliceFrom(_142[0][0]); + const last: rs.ByteSlice = rs.byteSliceFrom(_142[0][_142[0].length - 1]); + const _152: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(first), rs.byteSliceToArray(last)]; const first2: Uint8Array = copy$array_u8(_152[0]); const last2: Uint8Array = copy$array_u8(_152[1]); - rt.sliceSwap(_142[0], 0, rt.usizeSub(_142[0].length, 1)); + rs.sliceSwap(_142[0], 0, rs.usizeSub(_142[0].length, 1)); _142[0].reverse(); - const n: rt.usize = _142[0].length; - rt.sliceRangeMut(_142[0], 1).reverse(); - rt.sliceRotateLeft(_142[0], 1); - rt.sliceRotateRight(_142[0], rt.usizeDiv(n, 2)); - const _171: rt.usize = rt.usizeSub(n, 1); - rt.idx(_142[0], _171); + const n: rs.usize = _142[0].length; + rs.sliceRangeMut(_142[0], 1).reverse(); + rs.sliceRotateLeft(_142[0], 1); + rs.sliceRotateRight(_142[0], rs.usizeDiv(n, 2)); + const _171: rs.usize = rs.usizeSub(n, 1); + rs.idx(_142[0], _171); const kept2: Uint8Array = copy$array_u8(_142[0][_171]); - const _177: { end: rt.usize } = { end: rt.usizeSub(n, 1) }; - rt.sliceCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice([copy$array_u8(first2), copy$array_u8(last2), copy$array_u8(kept2)]), rt.byteSliceFrom), (c28: rt.ByteSlice): rt.u8 => { + const _177: { end: rs.usize } = { end: rs.usizeSub(n, 1) }; + rs.sliceCopyWithin(_142[0], 0, _177.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_u8(first2), copy$array_u8(last2), copy$array_u8(kept2)]), rs.byteSliceFrom), (c28: rs.ByteSlice): rs.u8 => { return digest(c28); }), undefined, true); - rt.sliceSort(_142[0], rt.cmpLt(rt.cmpBytes), 2, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_142[0]), rt.byteSliceFrom), (c29: rt.ByteSlice): rt.u8 => { + rs.sliceSort(_142[0], rs.cmpLt(rs.cmpBytes), 2, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_142[0]), rs.byteSliceFrom), (c29: rs.ByteSlice): rs.u8 => { return digest(c29); }), undefined, true); - const f3 = (c30: rt.ByteSlice): rt.u8 => { + const f3 = (c30: rs.ByteSlice): rs.u8 => { return c30.data[c30.start + 1]; }; - rt.sliceSort(_142[0], rt.keyLt((held3) => f3(rt.byteSliceFrom(held3)), rt.cmpLt(rt.cmpReverse(rt.cmp))), 2, true); - rt.sliceSortUnstable(_142[0], rt.cmpLt(rt.cmpBytes), 2, true, true); - const f4 = (c31: rt.ByteSlice): rt.u8 => { + rs.sliceSort(_142[0], rs.keyLt((held3) => f3(rs.byteSliceFrom(held3)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 2, true); + rs.sliceSortUnstable(_142[0], rs.cmpLt(rs.cmpBytes), 2, true, true); + const f4 = (c31: rs.ByteSlice): rs.u8 => { return c31.data[c31.start]; }; - rt.sliceSortByCachedKey(_142[0], (held4) => f4(rt.byteSliceFrom(held4)), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])), 8, true, true); - const _196: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(_142[0], 1); - rt.idx(_196[0], 0); - const _198: rt.ByteSlice = rt.byteSliceFrom(_196[0][0]); - const _204: rt.usize = rt.usizeSub(n, 2); - rt.idx(_196[1], _204); - const _203: rt.ByteSlice = rt.byteSliceFrom(_196[1][_204]); - const swapped3 = rt.byteSliceToArray(_198); - _198.data.set(rt.byteSliceToArray(_203), _198.start); + rs.sliceSortByCachedKey(_142[0], (held4) => f4(rs.byteSliceFrom(held4)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + const _196: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(_142[0], 1); + rs.idx(_196[0], 0); + const _198: rs.ByteSlice = rs.byteSliceFrom(_196[0][0]); + const _204: rs.usize = rs.usizeSub(n, 2); + rs.idx(_196[1], _204); + const _203: rs.ByteSlice = rs.byteSliceFrom(_196[1][_204]); + const swapped3 = rs.byteSliceToArray(_198); + _198.data.set(rs.byteSliceToArray(_203), _198.start); _203.data.set(swapped3, _203.start); - rt.idx(_142[0], 0); - const _210: rt.ByteSlice = rt.byteSliceFrom(_142[0][0]); - const old13 = rt.byteSliceToArray(_210); + rs.idx(_142[0], 0); + const _210: rs.ByteSlice = rs.byteSliceFrom(_142[0][0]); + const old13 = rs.byteSliceToArray(_210); _210.data.set(Uint8Array.of(7, 8), _210.start); const old: Uint8Array = old13; - const _216: rt.usize = rt.usizeSub(n, 1); - rt.idx(_142[0], _216); + const _216: rs.usize = rs.usizeSub(n, 1); + rs.idx(_142[0], _216); _142[0][_216] = copy$array_u8(old); - rt.idx(_142[0], 1); + rs.idx(_142[0], 1); const kept3: Uint8Array = copy$array_u8(_142[0][1]); - rt.idx(_142[0], 0); + rs.idx(_142[0], 0); const _226: Uint8Array = copy$array_u8(_142[0][0]); - rt.idx(_142[0], 1); + rs.idx(_142[0], 1); _142[0][1] = _226; - rt.idx(_142[0], 0); + rs.idx(_142[0], 0); _142[0][0] = copy$array_u8(kept3); - const _239: rt.ByteSlice | undefined = rt.optionMap(rt.sliceLast(_142[0]), rt.byteSliceFrom); + const _239: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(_142[0]), rs.byteSliceFrom); if (_239 !== undefined) { _239.data.set(Uint8Array.of(9, 10), _239.start); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_142[0]), rt.byteSliceFrom), (c32: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_142[0]), rs.byteSliceFrom), (c32: rs.ByteSlice): rs.u8 => { return digest(c32); }), undefined, true); - rt.sliceFill(rt.sliceRangeMut(_142[0], rt.usizeDiv(n, 2)), Uint8Array.of(9, 10), copy$array_u8); + rs.sliceFill(rs.sliceRangeMut(_142[0], rs.usizeDiv(n, 2)), Uint8Array.of(9, 10), copy$array_u8); } } else if (_12 === 2) { - const _253: [rt.u16[], rt.u16[][]] = rt.sliceAsRchunksMut(words.items, 2); + const _253: [rs.u16[], rs.u16[][]] = rs.sliceAsRchunksMut(words.items, 2); if (_253[1].length >= 2) { - const _263: [rt.u16[], rt.u16[]] = [copy$array_u16(_253[1][0]), copy$array_u16(_253[1][_253[1].length - 1])]; - const first3: rt.u16[] = _263[0]; - const last3: rt.u16[] = _263[1]; - rt.sliceSwap(_253[1], 0, rt.usizeSub(_253[1].length, 1)); + const _263: [rs.u16[], rs.u16[]] = [copy$array_u16(_253[1][0]), copy$array_u16(_253[1][_253[1].length - 1])]; + const first3: rs.u16[] = _263[0]; + const last3: rs.u16[] = _263[1]; + rs.sliceSwap(_253[1], 0, rs.usizeSub(_253[1].length, 1)); _253[1].reverse(); - const n2: rt.usize = _253[1].length; - rt.sliceRangeMut(_253[1], 1).reverse(); - rt.sliceRotateLeft(_253[1], 1); - rt.sliceRotateRight(_253[1], rt.usizeDiv(n2, 2)); - const _282: rt.usize = rt.usizeSub(n2, 1); - rt.idx(_253[1], _282); - const kept4: rt.u16[] = copy$array_u16(_253[1][_282]); - const _288: { end: rt.usize } = { end: rt.usizeSub(n2, 1) }; - rt.sliceCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice([first3, last3, kept4]), (c3: rt.u16[]): rt.u8 => { + const n2: rs.usize = _253[1].length; + rs.sliceRangeMut(_253[1], 1).reverse(); + rs.sliceRotateLeft(_253[1], 1); + rs.sliceRotateRight(_253[1], rs.usizeDiv(n2, 2)); + const _282: rs.usize = rs.usizeSub(n2, 1); + rs.idx(_253[1], _282); + const kept4: rs.u16[] = copy$array_u16(_253[1][_282]); + const _288: { end: rs.usize } = { end: rs.usizeSub(n2, 1) }; + rs.sliceCopyWithin(_253[1], 0, _288.end, 1, copy$array_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([first3, last3, kept4]), (c3: rs.u16[]): rs.u8 => { return digestWords(c3); }), undefined, true); - rt.sliceSort(_253[1], rt.cmpLt(rt.cmpSlice(rt.cmp)), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_253[1]), (c4: rt.u16[]): rt.u8 => { + rs.sliceSort(_253[1], rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_253[1]), (c4: rs.u16[]): rs.u8 => { return digestWords(c4); }), undefined, true); - rt.sliceSort(_253[1], rt.keyLt((c5: rt.u16[]): rt.u16 => { + rs.sliceSort(_253[1], rs.keyLt((c5: rs.u16[]): rs.u16 => { return c5[1]; - }, rt.cmpLt(rt.cmpReverse(rt.cmp))), 4, true); - rt.sliceSortUnstable(_253[1], rt.cmpLt(rt.cmpSlice(rt.cmp)), 4, true, true); - rt.sliceSortByCachedKey(_253[1], (c6: rt.u16[]): rt.u16 => { + }, rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); + rs.sliceSortUnstable(_253[1], rs.cmpLt(rs.cmpSlice(rs.cmp)), 4, true, true); + rs.sliceSortByCachedKey(_253[1], (c6: rs.u16[]): rs.u16 => { return c6[0]; - }, rt.cmpLt(rt.cmpTuple<[rt.u16, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])), 8, true, true); - const _307: [rt.u16[][], rt.u16[][]] = rt.sliceSplitAtMut(_253[1], 1); - rt.idx(_307[0], 0); - const _315: rt.usize = rt.usizeSub(n2, 2); - rt.idx(_307[1], _315); - rt.sliceSwapAcross(_307[0], 0, _307[1], _315); - rt.idx(_253[1], 0); - const old2: rt.u16[] = rt.sliceReplace(_253[1], 0, [7, 8]); - const _327: rt.usize = rt.usizeSub(n2, 1); - rt.idx(_253[1], _327); + }, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + const _307: [rs.u16[][], rs.u16[][]] = rs.sliceSplitAtMut(_253[1], 1); + rs.idx(_307[0], 0); + const _315: rs.usize = rs.usizeSub(n2, 2); + rs.idx(_307[1], _315); + rs.sliceSwapAcross(_307[0], 0, _307[1], _315); + rs.idx(_253[1], 0); + const old2: rs.u16[] = rs.sliceReplace(_253[1], 0, [7, 8]); + const _327: rs.usize = rs.usizeSub(n2, 1); + rs.idx(_253[1], _327); _253[1][_327] = copy$array_u16(old2); - rt.idx(_253[1], 1); - const kept5: rt.u16[] = copy$array_u16(_253[1][1]); - rt.idx(_253[1], 0); - const _337: rt.u16[] = copy$array_u16(_253[1][0]); - rt.idx(_253[1], 1); + rs.idx(_253[1], 1); + const kept5: rs.u16[] = copy$array_u16(_253[1][1]); + rs.idx(_253[1], 0); + const _337: rs.u16[] = copy$array_u16(_253[1][0]); + rs.idx(_253[1], 1); _253[1][1] = _337; - rt.idx(_253[1], 0); + rs.idx(_253[1], 0); _253[1][0] = copy$array_u16(kept5); - const _350: rt.u16[] | undefined = rt.sliceLast(_253[1]); + const _350: rs.u16[] | undefined = rs.sliceLast(_253[1]); if (_350 !== undefined) { Object.assign(_350, [9, 10]); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_253[1]), (c7: rt.u16[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_253[1]), (c7: rs.u16[]): rs.u8 => { return digestWords(c7); }), undefined, true); - rt.sliceFill(rt.sliceRangeMut(_253[1], rt.usizeDiv(n2, 2)), [9, 10], copy$array_u16); + rs.sliceFill(rs.sliceRangeMut(_253[1], rs.usizeDiv(n2, 2)), [9, 10], copy$array_u16); } - const _364: [rt.ByteSlice, Uint8Array[]] = rt.byteSliceAsRchunksMut(rt.byteVecSlice(bytes), 4); + const _364: [rs.ByteSlice, Uint8Array[]] = rs.byteSliceAsRchunksMut(rs.byteVecSlice(bytes), 4); if (_364[1].length >= 2) { - const first4: rt.ByteSlice = rt.byteSliceFrom(_364[1][0]); - const last4: rt.ByteSlice = rt.byteSliceFrom(_364[1][_364[1].length - 1]); - const _374: [Uint8Array, Uint8Array] = [rt.byteSliceToArray(first4), rt.byteSliceToArray(last4)]; + const first4: rs.ByteSlice = rs.byteSliceFrom(_364[1][0]); + const last4: rs.ByteSlice = rs.byteSliceFrom(_364[1][_364[1].length - 1]); + const _374: [Uint8Array, Uint8Array] = [rs.byteSliceToArray(first4), rs.byteSliceToArray(last4)]; const first5: Uint8Array = copy$array_u8(_374[0]); const last5: Uint8Array = copy$array_u8(_374[1]); - rt.sliceSwap(_364[1], 0, rt.usizeSub(_364[1].length, 1)); + rs.sliceSwap(_364[1], 0, rs.usizeSub(_364[1].length, 1)); _364[1].reverse(); - const n3: rt.usize = _364[1].length; - rt.sliceRangeMut(_364[1], 1).reverse(); - rt.sliceRotateLeft(_364[1], 1); - rt.sliceRotateRight(_364[1], rt.usizeDiv(n3, 2)); - const _393: rt.usize = rt.usizeSub(n3, 1); - rt.idx(_364[1], _393); + const n3: rs.usize = _364[1].length; + rs.sliceRangeMut(_364[1], 1).reverse(); + rs.sliceRotateLeft(_364[1], 1); + rs.sliceRotateRight(_364[1], rs.usizeDiv(n3, 2)); + const _393: rs.usize = rs.usizeSub(n3, 1); + rs.idx(_364[1], _393); const kept6: Uint8Array = copy$array_u8(_364[1][_393]); - const _399: { end: rt.usize } = { end: rt.usizeSub(n3, 1) }; - rt.sliceCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice([copy$array_u8(first5), copy$array_u8(last5), copy$array_u8(kept6)]), rt.byteSliceFrom), (c8: rt.ByteSlice): rt.u8 => { + const _399: { end: rs.usize } = { end: rs.usizeSub(n3, 1) }; + rs.sliceCopyWithin(_364[1], 0, _399.end, 1, copy$array_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice([copy$array_u8(first5), copy$array_u8(last5), copy$array_u8(kept6)]), rs.byteSliceFrom), (c8: rs.ByteSlice): rs.u8 => { return digest(c8); }), undefined, true); - rt.sliceSort(_364[1], rt.cmpLt(rt.cmpBytes), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_364[1]), rt.byteSliceFrom), (c9: rt.ByteSlice): rt.u8 => { + rs.sliceSort(_364[1], rs.cmpLt(rs.cmpBytes), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_364[1]), rs.byteSliceFrom), (c9: rs.ByteSlice): rs.u8 => { return digest(c9); }), undefined, true); - const f = (c10: rt.ByteSlice): rt.u8 => { + const f = (c10: rs.ByteSlice): rs.u8 => { return c10.data[c10.start + 1]; }; - rt.sliceSort(_364[1], rt.keyLt((held) => f(rt.byteSliceFrom(held)), rt.cmpLt(rt.cmpReverse(rt.cmp))), 4, true); - rt.sliceSortUnstable(_364[1], rt.cmpLt(rt.cmpBytes), 4, true, true); - const f2 = (c11: rt.ByteSlice): rt.u8 => { + rs.sliceSort(_364[1], rs.keyLt((held) => f(rs.byteSliceFrom(held)), rs.cmpLt(rs.cmpReverse(rs.cmp))), 4, true); + rs.sliceSortUnstable(_364[1], rs.cmpLt(rs.cmpBytes), 4, true, true); + const f2 = (c11: rs.ByteSlice): rs.u8 => { return c11.data[c11.start]; }; - rt.sliceSortByCachedKey(_364[1], (held2) => f2(rt.byteSliceFrom(held2)), rt.cmpLt(rt.cmpTuple<[rt.u8, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])), 8, true, true); - const _418: [Uint8Array[], Uint8Array[]] = rt.sliceSplitAtMut(_364[1], 1); - rt.idx(_418[0], 0); - const _420: rt.ByteSlice = rt.byteSliceFrom(_418[0][0]); - const _426: rt.usize = rt.usizeSub(n3, 2); - rt.idx(_418[1], _426); - const _425: rt.ByteSlice = rt.byteSliceFrom(_418[1][_426]); - const swapped2 = rt.byteSliceToArray(_420); - _420.data.set(rt.byteSliceToArray(_425), _420.start); + rs.sliceSortByCachedKey(_364[1], (held2) => f2(rs.byteSliceFrom(held2)), rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + const _418: [Uint8Array[], Uint8Array[]] = rs.sliceSplitAtMut(_364[1], 1); + rs.idx(_418[0], 0); + const _420: rs.ByteSlice = rs.byteSliceFrom(_418[0][0]); + const _426: rs.usize = rs.usizeSub(n3, 2); + rs.idx(_418[1], _426); + const _425: rs.ByteSlice = rs.byteSliceFrom(_418[1][_426]); + const swapped2 = rs.byteSliceToArray(_420); + _420.data.set(rs.byteSliceToArray(_425), _420.start); _425.data.set(swapped2, _425.start); - rt.idx(_364[1], 0); - const _432: rt.ByteSlice = rt.byteSliceFrom(_364[1][0]); - const old9 = rt.byteSliceToArray(_432); + rs.idx(_364[1], 0); + const _432: rs.ByteSlice = rs.byteSliceFrom(_364[1][0]); + const old9 = rs.byteSliceToArray(_432); _432.data.set(Uint8Array.of(1, 2, 3, 4), _432.start); const old3: Uint8Array = old9; - const _438: rt.usize = rt.usizeSub(n3, 1); - rt.idx(_364[1], _438); + const _438: rs.usize = rs.usizeSub(n3, 1); + rs.idx(_364[1], _438); _364[1][_438] = copy$array_u8(old3); - rt.idx(_364[1], 1); + rs.idx(_364[1], 1); const kept7: Uint8Array = copy$array_u8(_364[1][1]); - rt.idx(_364[1], 0); + rs.idx(_364[1], 0); const _448: Uint8Array = copy$array_u8(_364[1][0]); - rt.idx(_364[1], 1); + rs.idx(_364[1], 1); _364[1][1] = _448; - rt.idx(_364[1], 0); + rs.idx(_364[1], 0); _364[1][0] = copy$array_u8(kept7); - const _461: rt.ByteSlice | undefined = rt.optionMap(rt.sliceLast(_364[1]), rt.byteSliceFrom); + const _461: rs.ByteSlice | undefined = rs.optionMap(rs.sliceLast(_364[1]), rs.byteSliceFrom); if (_461 !== undefined) { - _461.data.set(rt.bytes(4).fill(5), _461.start); + _461.data.set(rs.bytes(4).fill(5), _461.start); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterLend(rt.iterSlice(_364[1]), rt.byteSliceFrom), (c12: rt.ByteSlice): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterLend(rs.iterSlice(_364[1]), rs.byteSliceFrom), (c12: rs.ByteSlice): rs.u8 => { return digest(c12); }), undefined, true); - rt.sliceFill(rt.sliceRangeMut(_364[1], rt.usizeDiv(n3, 2)), rt.bytes(4).fill(5), copy$array_u8); + rs.sliceFill(rs.sliceRangeMut(_364[1], rs.usizeDiv(n3, 2)), rs.bytes(4).fill(5), copy$array_u8); } - const _479: [Uint8Array[][], Uint8Array[]] = rt.sliceAsChunksMut(rt.byteSliceAsChunksMut(rt.byteVecSlice(bytes), 2)[0], 2); + const _479: [Uint8Array[][], Uint8Array[]] = rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2); if (_479[0].length >= 2) { const _487: [Uint8Array[], Uint8Array[]] = [copy$array_array2_u8(_479[0][0]), copy$array_array2_u8(_479[0][_479[0].length - 1])]; const first6: Uint8Array[] = copy$array_array2_u8(_487[0]); const last6: Uint8Array[] = copy$array_array2_u8(_487[1]); - rt.sliceSwap(_479[0], 0, rt.usizeSub(_479[0].length, 1)); + rs.sliceSwap(_479[0], 0, rs.usizeSub(_479[0].length, 1)); _479[0].reverse(); - const n4: rt.usize = _479[0].length; - rt.sliceRangeMut(_479[0], 1).reverse(); - rt.sliceRotateLeft(_479[0], 1); - rt.sliceRotateRight(_479[0], rt.usizeDiv(n4, 2)); - const _506: rt.usize = rt.usizeSub(n4, 1); - rt.idx(_479[0], _506); + const n4: rs.usize = _479[0].length; + rs.sliceRangeMut(_479[0], 1).reverse(); + rs.sliceRotateLeft(_479[0], 1); + rs.sliceRotateRight(_479[0], rs.usizeDiv(n4, 2)); + const _506: rs.usize = rs.usizeSub(n4, 1); + rs.idx(_479[0], _506); const kept8: Uint8Array[] = copy$array_array2_u8(_479[0][_506]); - const _512: { end: rt.usize } = { end: rt.usizeSub(n4, 1) }; - rt.sliceCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice([copy$array_array2_u8(first6), copy$array_array2_u8(last6), copy$array_array2_u8(kept8)]), (c13: Uint8Array[]): rt.u8 => { + const _512: { end: rs.usize } = { end: rs.usizeSub(n4, 1) }; + rs.sliceCopyWithin(_479[0], 0, _512.end, 1, copy$array_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([copy$array_array2_u8(first6), copy$array_array2_u8(last6), copy$array_array2_u8(kept8)]), (c13: Uint8Array[]): rs.u8 => { return c13[0][0] ^ c13[1][1]; }), undefined, true); - rt.sliceSort(_479[0], rt.cmpLt(rt.cmpSlice(rt.cmpBytes)), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_479[0]), (c14: Uint8Array[]): rt.u8 => { + rs.sliceSort(_479[0], rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_479[0]), (c14: Uint8Array[]): rs.u8 => { return c14[0][0] ^ c14[1][1]; }), undefined, true); - rt.sliceSort(_479[0], rt.keyLt((c15: Uint8Array[]): Uint8Array => { + rs.sliceSort(_479[0], rs.keyLt((c15: Uint8Array[]): Uint8Array => { return copy$array_u8(c15[1]); - }, rt.cmpLt(rt.cmpReverse(rt.cmpBytes))), 4, true); - rt.sliceSortUnstable(_479[0], rt.cmpLt(rt.cmpSlice(rt.cmpBytes)), 4, true, true); - rt.sliceSortByCachedKey(_479[0], (c16: Uint8Array[]): Uint8Array => { + }, rs.cmpLt(rs.cmpReverse(rs.cmpBytes))), 4, true); + rs.sliceSortUnstable(_479[0], rs.cmpLt(rs.cmpSlice(rs.cmpBytes)), 4, true, true); + rs.sliceSortByCachedKey(_479[0], (c16: Uint8Array[]): Uint8Array => { return copy$array_u8(c16[0]); - }, rt.cmpLt(rt.cmpTuple<[Uint8Array, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmpBytes), rt.cmp])), 8, true, true); - const _531: [Uint8Array[][], Uint8Array[][]] = rt.sliceSplitAtMut(_479[0], 1); - rt.idx(_531[0], 0); - const _539: rt.usize = rt.usizeSub(n4, 2); - rt.idx(_531[1], _539); - rt.sliceSwapAcross(_531[0], 0, _531[1], _539, 1); - rt.idx(_479[0], 0); - const old4: Uint8Array[] = rt.sliceReplace(_479[0], 0, [Uint8Array.of(1, 2), Uint8Array.of(3, 4)], 1); - const _553: rt.usize = rt.usizeSub(n4, 1); - rt.idx(_479[0], _553); + }, rs.cmpLt(rs.cmpTuple<[Uint8Array, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpBytes), rs.cmp])), 8, true, true); + const _531: [Uint8Array[][], Uint8Array[][]] = rs.sliceSplitAtMut(_479[0], 1); + rs.idx(_531[0], 0); + const _539: rs.usize = rs.usizeSub(n4, 2); + rs.idx(_531[1], _539); + rs.sliceSwapAcross(_531[0], 0, _531[1], _539, 1); + rs.idx(_479[0], 0); + const old4: Uint8Array[] = rs.sliceReplace(_479[0], 0, [Uint8Array.of(1, 2), Uint8Array.of(3, 4)], 1); + const _553: rs.usize = rs.usizeSub(n4, 1); + rs.idx(_479[0], _553); _479[0][_553] = copy$array_array2_u8(old4); - rt.idx(_479[0], 1); + rs.idx(_479[0], 1); const kept9: Uint8Array[] = copy$array_array2_u8(_479[0][1]); - rt.idx(_479[0], 0); + rs.idx(_479[0], 0); const _563: Uint8Array[] = copy$array_array2_u8(_479[0][0]); - rt.idx(_479[0], 1); + rs.idx(_479[0], 1); _479[0][1] = _563; - rt.idx(_479[0], 0); + rs.idx(_479[0], 0); _479[0][0] = copy$array_array2_u8(kept9); - const _576: Uint8Array[] | undefined = rt.sliceLast(_479[0]); + const _576: Uint8Array[] | undefined = rs.sliceLast(_479[0]); if (_576 !== undefined) { Object.assign(_576, [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_479[0]), (c17: Uint8Array[]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_479[0]), (c17: Uint8Array[]): rs.u8 => { return c17[0][0] ^ c17[1][1]; }), undefined, true); - rt.sliceFill(rt.sliceRangeMut(_479[0], rt.usizeDiv(n4, 2)), [Uint8Array.of(5, 6), Uint8Array.of(7, 8)], copy$array_array2_u8); + rs.sliceFill(rs.sliceRangeMut(_479[0], rs.usizeDiv(n4, 2)), [Uint8Array.of(5, 6), Uint8Array.of(7, 8)], copy$array_array2_u8); } - const _600: [Uint8Array[][][], Uint8Array[][]] = rt.sliceAsChunksMut(rt.sliceAsChunksMut(rt.byteSliceAsChunksMut(rt.byteVecSlice(bytes), 2)[0], 2)[0], 2); + const _600: [Uint8Array[][][], Uint8Array[][]] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(rs.byteSliceAsChunksMut(rs.byteVecSlice(bytes), 2)[0], 2)[0], 2); const one: Uint8Array[][] = [[Uint8Array.of(1, 2), Uint8Array.of(3, 4)], [Uint8Array.of(5, 6), Uint8Array.of(7, 8)]]; if (_600[0].length >= 2) { const _615: [Uint8Array[][], Uint8Array[][]] = [copy$array_array2_array2_u8(_600[0][0]), copy$array_array2_array2_u8(_600[0][_600[0].length - 1])]; const first7: Uint8Array[][] = copy$array_array2_array2_u8(_615[0]); const last7: Uint8Array[][] = copy$array_array2_array2_u8(_615[1]); - rt.sliceSwap(_600[0], 0, rt.usizeSub(_600[0].length, 1)); + rs.sliceSwap(_600[0], 0, rs.usizeSub(_600[0].length, 1)); _600[0].reverse(); - const n5: rt.usize = _600[0].length; - rt.sliceRangeMut(_600[0], 1).reverse(); - rt.sliceRotateLeft(_600[0], 1); - rt.sliceRotateRight(_600[0], rt.usizeDiv(n5, 2)); - const _634: rt.usize = rt.usizeSub(n5, 1); - rt.idx(_600[0], _634); + const n5: rs.usize = _600[0].length; + rs.sliceRangeMut(_600[0], 1).reverse(); + rs.sliceRotateLeft(_600[0], 1); + rs.sliceRotateRight(_600[0], rs.usizeDiv(n5, 2)); + const _634: rs.usize = rs.usizeSub(n5, 1); + rs.idx(_600[0], _634); const kept10: Uint8Array[][] = copy$array_array2_array2_u8(_600[0][_634]); - const _640: { end: rt.usize } = { end: rt.usizeSub(n5, 1) }; - rt.sliceCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice([copy$array_array2_array2_u8(first7), copy$array_array2_array2_u8(last7), copy$array_array2_array2_u8(kept10)]), (c18: Uint8Array[][]): rt.u8 => { + const _640: { end: rs.usize } = { end: rs.usizeSub(n5, 1) }; + rs.sliceCopyWithin(_600[0], 0, _640.end, 1, copy$array_array2_array2_u8); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([copy$array_array2_array2_u8(first7), copy$array_array2_array2_u8(last7), copy$array_array2_array2_u8(kept10)]), (c18: Uint8Array[][]): rs.u8 => { return c18[0][0][0] ^ c18[1][1][1]; }), undefined, true); - rt.sliceSort(_600[0], rt.cmpLt(rt.cmpSlice(rt.cmpSlice(rt.cmpBytes))), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_600[0]), (c19: Uint8Array[][]): rt.u8 => { + rs.sliceSort(_600[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_600[0]), (c19: Uint8Array[][]): rs.u8 => { return c19[0][0][0] ^ c19[1][1][1]; }), undefined, true); - rt.sliceSort(_600[0], rt.keyLt((c20: Uint8Array[][]): Uint8Array[] => { + rs.sliceSort(_600[0], rs.keyLt((c20: Uint8Array[][]): Uint8Array[] => { return copy$array_array2_u8(c20[1]); - }, rt.cmpLt(rt.cmpReverse(rt.cmpSlice(rt.cmpBytes)))), 8, true); - rt.sliceSortUnstable(_600[0], rt.cmpLt(rt.cmpSlice(rt.cmpSlice(rt.cmpBytes))), 8, true, true); - rt.sliceSortByCachedKey(_600[0], (c21: Uint8Array[][]): Uint8Array[] => { + }, rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)))), 8, true); + rs.sliceSortUnstable(_600[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmpBytes))), 8, true, true); + rs.sliceSortByCachedKey(_600[0], (c21: Uint8Array[][]): Uint8Array[] => { return copy$array_array2_u8(c21[0]); - }, rt.cmpLt(rt.cmpTuple<[Uint8Array[], rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmpSlice(rt.cmpBytes)), rt.cmp])), 8, true, true); - const _659: [Uint8Array[][][], Uint8Array[][][]] = rt.sliceSplitAtMut(_600[0], 1); - rt.idx(_659[0], 0); - const _667: rt.usize = rt.usizeSub(n5, 2); - rt.idx(_659[1], _667); - rt.sliceSwapAcross(_659[0], 0, _659[1], _667, 2); - rt.idx(_600[0], 0); - const old5: Uint8Array[][] = rt.sliceReplace(_600[0], 0, copy$array_array2_array2_u8(one), 2); - const _678: rt.usize = rt.usizeSub(n5, 1); - rt.idx(_600[0], _678); + }, rs.cmpLt(rs.cmpTuple<[Uint8Array[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmpBytes)), rs.cmp])), 8, true, true); + const _659: [Uint8Array[][][], Uint8Array[][][]] = rs.sliceSplitAtMut(_600[0], 1); + rs.idx(_659[0], 0); + const _667: rs.usize = rs.usizeSub(n5, 2); + rs.idx(_659[1], _667); + rs.sliceSwapAcross(_659[0], 0, _659[1], _667, 2); + rs.idx(_600[0], 0); + const old5: Uint8Array[][] = rs.sliceReplace(_600[0], 0, copy$array_array2_array2_u8(one), 2); + const _678: rs.usize = rs.usizeSub(n5, 1); + rs.idx(_600[0], _678); _600[0][_678] = copy$array_array2_array2_u8(old5); - rt.idx(_600[0], 1); + rs.idx(_600[0], 1); const kept11: Uint8Array[][] = copy$array_array2_array2_u8(_600[0][1]); - rt.idx(_600[0], 0); + rs.idx(_600[0], 0); const _688: Uint8Array[][] = copy$array_array2_array2_u8(_600[0][0]); - rt.idx(_600[0], 1); + rs.idx(_600[0], 1); _600[0][1] = _688; - rt.idx(_600[0], 0); + rs.idx(_600[0], 0); _600[0][0] = copy$array_array2_array2_u8(kept11); - const _701: Uint8Array[][] | undefined = rt.sliceLast(_600[0]); + const _701: Uint8Array[][] | undefined = rs.sliceLast(_600[0]); if (_701 !== undefined) { - const _705: Uint8Array = rt.bytes(2).fill(9); + const _705: Uint8Array = rs.bytes(2).fill(9); const item = copy$array_array2_u8(Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_705); })); @@ -2569,135 +2569,135 @@ export function arraysMut(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): voi return copy$array_array2_u8(item); })); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_600[0]), (c22: Uint8Array[][]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_600[0]), (c22: Uint8Array[][]): rs.u8 => { return c22[0][0][0] ^ c22[1][1][1]; }), undefined, true); - const _711: Uint8Array[][][] = rt.sliceRangeMut(_600[0], rt.usizeDiv(n5, 2)); - const _717: Uint8Array = rt.bytes(2).fill(9); + const _711: Uint8Array[][][] = rs.sliceRangeMut(_600[0], rs.usizeDiv(n5, 2)); + const _717: Uint8Array = rs.bytes(2).fill(9); const item2 = copy$array_array2_u8(Array.from({ length: 2 }, (): Uint8Array => { return copy$array_u8(_717); })); - rt.sliceFill(_711, Array.from({ length: 2 }, (): Uint8Array[] => { + rs.sliceFill(_711, Array.from({ length: 2 }, (): Uint8Array[] => { return copy$array_array2_u8(item2); }), copy$array_array2_array2_u8); } - const backing: rt.Vec = rt.vecFrom(words.items.slice()); - const refs: rt.Vec = rt.iterToVec(rt.sliceChunksMut(backing.items, 1), undefined, 8, true); - const _729: [rt.u16[][][][], rt.u16[][][]] = rt.sliceAsChunksMut(rt.sliceAsChunksMut(refs.items, 2)[0], 2); + const backing: rs.Vec = rs.vecFrom(words.items.slice()); + const refs: rs.Vec = rs.iterToVec(rs.sliceChunksMut(backing.items, 1), undefined, 8, true); + const _729: [rs.u16[][][][], rs.u16[][][]] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(refs.items, 2)[0], 2); if (_729[0].length >= 2) { - rt.sliceSwap(_729[0], 0, 1); + rs.sliceSwap(_729[0], 0, 1); } - const iter6: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(refs.items)); + const iter6: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(refs.items)); while (true) { - const _740: [rt.usize, rt.Place] | rt.Done = iter6.next(); - if (_740 === rt.DONE) { + const _740: [rs.usize, rs.Place] | rs.Done = iter6.next(); + if (_740 === rs.DONE) { break; } - const _745: rt.u16 = _740[0] & 0xffff; - rt.idx(_740[1].v, 0); + const _745: rs.u16 = _740[0] & 0xffff; + rs.idx(_740[1].v, 0); _740[1].v[0] = _740[1].v[0] ^ _745; } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(backing.items), (_24: rt.u16): rt.u8 => { - const w: rt.u16 = _24; + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(backing.items), (_24: rs.u16): rs.u8 => { + const w: rs.u16 = _24; return (w ^ (w >> 8)) & 0xff; }), undefined, true); - const _760: [rt.u16[][][], rt.u16[][]] = rt.sliceAsChunksMut(rt.sliceAsChunksMut(words.items, 2)[0], 2); + const _760: [rs.u16[][][], rs.u16[][]] = rs.sliceAsChunksMut(rs.sliceAsChunksMut(words.items, 2)[0], 2); if (_760[0].length >= 2) { - const _768: [rt.u16[][], rt.u16[][]] = [copy$array_array2_u16(_760[0][0]), copy$array_array2_u16(_760[0][_760[0].length - 1])]; - const first8: rt.u16[][] = _768[0]; - const last8: rt.u16[][] = _768[1]; - rt.sliceSwap(_760[0], 0, rt.usizeSub(_760[0].length, 1)); + const _768: [rs.u16[][], rs.u16[][]] = [copy$array_array2_u16(_760[0][0]), copy$array_array2_u16(_760[0][_760[0].length - 1])]; + const first8: rs.u16[][] = _768[0]; + const last8: rs.u16[][] = _768[1]; + rs.sliceSwap(_760[0], 0, rs.usizeSub(_760[0].length, 1)); _760[0].reverse(); - const n6: rt.usize = _760[0].length; - rt.sliceRangeMut(_760[0], 1).reverse(); - rt.sliceRotateLeft(_760[0], 1); - rt.sliceRotateRight(_760[0], rt.usizeDiv(n6, 2)); - const _787: rt.usize = rt.usizeSub(n6, 1); - rt.idx(_760[0], _787); - const kept12: rt.u16[][] = copy$array_array2_u16(_760[0][_787]); - const _793: { end: rt.usize } = { end: rt.usizeSub(n6, 1) }; - rt.sliceCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice([first8, last8, kept12]), (c23: rt.u16[][]): rt.u8 => { + const n6: rs.usize = _760[0].length; + rs.sliceRangeMut(_760[0], 1).reverse(); + rs.sliceRotateLeft(_760[0], 1); + rs.sliceRotateRight(_760[0], rs.usizeDiv(n6, 2)); + const _787: rs.usize = rs.usizeSub(n6, 1); + rs.idx(_760[0], _787); + const kept12: rs.u16[][] = copy$array_array2_u16(_760[0][_787]); + const _793: { end: rs.usize } = { end: rs.usizeSub(n6, 1) }; + rs.sliceCopyWithin(_760[0], 0, _793.end, 1, copy$array_array2_u16); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice([first8, last8, kept12]), (c23: rs.u16[][]): rs.u8 => { return (c23[0][0] ^ c23[1][1]) & 0xff; }), undefined, true); - rt.sliceSort(_760[0], rt.cmpLt(rt.cmpSlice(rt.cmpSlice(rt.cmp))), 8, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_760[0]), (c24: rt.u16[][]): rt.u8 => { + rs.sliceSort(_760[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_760[0]), (c24: rs.u16[][]): rs.u8 => { return (c24[0][0] ^ c24[1][1]) & 0xff; }), undefined, true); - rt.sliceSort(_760[0], rt.keyLt((c25: rt.u16[][]): rt.u16[] => { + rs.sliceSort(_760[0], rs.keyLt((c25: rs.u16[][]): rs.u16[] => { return copy$array_u16(c25[1]); - }, rt.cmpLt(rt.cmpReverse(rt.cmpSlice(rt.cmp)))), 8, true); - rt.sliceSortUnstable(_760[0], rt.cmpLt(rt.cmpSlice(rt.cmpSlice(rt.cmp))), 8, true, true); - rt.sliceSortByCachedKey(_760[0], (c26: rt.u16[][]): rt.u16[] => { + }, rs.cmpLt(rs.cmpReverse(rs.cmpSlice(rs.cmp)))), 8, true); + rs.sliceSortUnstable(_760[0], rs.cmpLt(rs.cmpSlice(rs.cmpSlice(rs.cmp))), 8, true, true); + rs.sliceSortByCachedKey(_760[0], (c26: rs.u16[][]): rs.u16[] => { return copy$array_u16(c26[0]); - }, rt.cmpLt(rt.cmpTuple<[rt.u16[], rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmpSlice(rt.cmp)), rt.cmp])), 8, true, true); - const _812: [rt.u16[][][], rt.u16[][][]] = rt.sliceSplitAtMut(_760[0], 1); - rt.idx(_812[0], 0); - const _820: rt.usize = rt.usizeSub(n6, 2); - rt.idx(_812[1], _820); - rt.sliceSwapAcross(_812[0], 0, _812[1], _820, 1); - rt.idx(_760[0], 0); - const old6: rt.u16[][] = rt.sliceReplace(_760[0], 0, [[1, 2], [3, 4]], 1); - const _834: rt.usize = rt.usizeSub(n6, 1); - rt.idx(_760[0], _834); + }, rs.cmpLt(rs.cmpTuple<[rs.u16[], rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmpSlice(rs.cmp)), rs.cmp])), 8, true, true); + const _812: [rs.u16[][][], rs.u16[][][]] = rs.sliceSplitAtMut(_760[0], 1); + rs.idx(_812[0], 0); + const _820: rs.usize = rs.usizeSub(n6, 2); + rs.idx(_812[1], _820); + rs.sliceSwapAcross(_812[0], 0, _812[1], _820, 1); + rs.idx(_760[0], 0); + const old6: rs.u16[][] = rs.sliceReplace(_760[0], 0, [[1, 2], [3, 4]], 1); + const _834: rs.usize = rs.usizeSub(n6, 1); + rs.idx(_760[0], _834); _760[0][_834] = copy$array_array2_u16(old6); - rt.idx(_760[0], 1); - const kept13: rt.u16[][] = copy$array_array2_u16(_760[0][1]); - rt.idx(_760[0], 0); - const _844: rt.u16[][] = copy$array_array2_u16(_760[0][0]); - rt.idx(_760[0], 1); + rs.idx(_760[0], 1); + const kept13: rs.u16[][] = copy$array_array2_u16(_760[0][1]); + rs.idx(_760[0], 0); + const _844: rs.u16[][] = copy$array_array2_u16(_760[0][0]); + rs.idx(_760[0], 1); _760[0][1] = _844; - rt.idx(_760[0], 0); + rs.idx(_760[0], 0); _760[0][0] = copy$array_array2_u16(kept13); - const _857: rt.u16[][] | undefined = rt.sliceLast(_760[0]); + const _857: rs.u16[][] | undefined = rs.sliceLast(_760[0]); if (_857 !== undefined) { Object.assign(_857, [[5, 6], [7, 8]]); } - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_760[0]), (c27: rt.u16[][]): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_760[0]), (c27: rs.u16[][]): rs.u8 => { return (c27[0][0] ^ c27[1][1]) & 0xff; }), undefined, true); - rt.sliceFill(rt.sliceRangeMut(_760[0], rt.usizeDiv(n6, 2)), [[5, 6], [7, 8]], copy$array_array2_u16); + rs.sliceFill(rs.sliceRangeMut(_760[0], rs.usizeDiv(n6, 2)), [[5, 6], [7, 8]], copy$array_array2_u16); } } else if (_12 === 3) { - const _875: [Item.Item[][], Item.Item[]] = rt.sliceAsChunksMut(items.items, 2); + const _875: [Item.Item[][], Item.Item[]] = rs.sliceAsChunksMut(items.items, 2); if (_875[0].length >= 2) { - rt.idx(_875[0], 0); - const first9: Item.Item[] = rt.sliceReplace(_875[0], 0, [new Item.Item(65), new Item.Item(66)], 1); + rs.idx(_875[0], 0); + const first9: Item.Item[] = rs.sliceReplace(_875[0], 0, [new Item.Item(65), new Item.Item(66)], 1); flush(out); - rt.sliceSwap(_875[0], 0, 1); + rs.sliceSwap(_875[0], 0, 1); _875[0].reverse(); - rt.sliceSort(_875[0], rt.keyLt((c: Item.Item[]): rt.u8 => { + rs.sliceSort(_875[0], rs.keyLt((c: Item.Item[]): rs.u8 => { return c[1].tag; - }, rt.lt), 2, true); - rt.idx(_875[0], 1); - rt.dropAll(_875[0][1]); + }, rs.lt), 2, true); + rs.idx(_875[0], 1); + rs.dropAll(_875[0][1]); _875[0][1] = first9; flush(out); - rt.idx(_875[0], 0); + rs.idx(_875[0], 0); _875[0][0][1][Symbol.dispose](); _875[0][0][1] = new Item.Item(67); flush(out); - const _909: [Item.Item[][], Item.Item[][]] = rt.sliceSplitAtMut(_875[0], 1); - rt.idx(_909[0], 0); - rt.idx(_909[1], 0); - rt.sliceSwapAcross(_909[0], 0, _909[1], 0, 1); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(_875[0]), (c2: Item.Item[]): rt.u8 => { + const _909: [Item.Item[][], Item.Item[][]] = rs.sliceSplitAtMut(_875[0], 1); + rs.idx(_909[0], 0); + rs.idx(_909[1], 0); + rs.sliceSwapAcross(_909[0], 0, _909[1], 0, 1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(_875[0]), (c2: Item.Item[]): rs.u8 => { return _11(c2); }), undefined, true); } } else { - const _929: [Uint8Array[], rt.ByteSlice] = rt.byteSliceAsChunksMut(rt.byteSliceRange(rt.byteVecSlice(bytes), 0, 0), 4); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_929[0].length & 0xff, _929[1].length & 0xff)), undefined, true); - rt.byteVecPush(out, runsMut$0(rt.byteVecSlice(bytes))); + const _929: [Uint8Array[], rs.ByteSlice] = rs.byteSliceAsChunksMut(rs.byteSliceRange(rs.byteVecSlice(bytes), 0, 0), 4); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_929[0].length & 0xff, _929[1].length & 0xff)), undefined, true); + rs.byteVecPush(out, runsMut$0(rs.byteVecSlice(bytes))); } flush(out); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes)), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(words.items), (_25: rt.u16): rt.u8 => { - const w3: rt.u16 = _25; + rs.iterExtendBytes(out, rs.iterSlice(rs.byteVecView(bytes)), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(words.items), (_25: rs.u16): rs.u8 => { + const w3: rs.u16 = _25; return (w3 ^ (w3 >> 8)) & 0xff; }), undefined, true); - rt.byteVecPush(out, _11(items.items)); - rt.dropVec(items); + rs.byteVecPush(out, _11(items.items)); + rs.dropVec(items); flush(out); } diff --git a/ts/fixtures/lang/sorts/expected/core/option.ts b/ts/fixtures/lang/sorts/expected/core/option.ts index 07f3e7865..5263a7208 100644 --- a/ts/fixtures/lang/sorts/expected/core/option.ts +++ b/ts/fixtures/lang/sorts/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1ttssgs(self: [rt.u8, rt.ByteSlice] | undefined, default_: [rt.u8, rt.ByteSlice], f: (a0: [rt.u8, rt.ByteSlice]) => [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] { +export function mapOr$0z4nmg2(self: [rs.u8, rs.ByteSlice] | undefined, default_: [rs.u8, rs.ByteSlice], f: (a0: [rs.u8, rs.ByteSlice]) => [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/sorts/expected/harness.ts b/ts/fixtures/lang/sorts/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/sorts/expected/harness.ts +++ b/ts/fixtures/lang/sorts/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/sorts/expected/lib.ts b/ts/fixtures/lang/sorts/expected/lib.ts index 5c12df228..36b0d81f2 100644 --- a/ts/fixtures/lang/sorts/expected/lib.ts +++ b/ts/fixtures/lang/sorts/expected/lib.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { sorts, disorders, btrees } from "./sorts.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["sorts::sorts", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["sorts::sorts", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { sorts(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["sorts::btrees", (a02: rs.u8, a12: rs.ByteSlice, a22: rs.ByteVec): undefined => { btrees(a02, a12.data, a12.start, a12.length, a22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/sorts/expected/sorts.Item.ts b/ts/fixtures/lang/sorts/expected/sorts.Item.ts index f262b56f2..ccd87f632 100644 --- a/ts/fixtures/lang/sorts/expected/sorts.Item.ts +++ b/ts/fixtures/lang/sorts/expected/sorts.Item.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { note } from "./sorts.ts"; import type * as Held from "./sorts.Held.ts"; /** Ordered by `key` alone, so `tag` tells equal ones apart, beside `pad`, which sizes it. */ export class Item

{ - key: rt.u16; - tag: rt.u16; + key: rs.u16; + tag: rs.u16; pad: P; - constructor(key: rt.u16, tag: rt.u16, pad: P) { + constructor(key: rs.u16, tag: rs.u16, pad: P) { this.key = key; this.tag = tag; this.pad = pad; } } -export function eq$cmp_PartialEq_array30_u32(self: Item, other: Item): boolean { +export function eq$cmp_PartialEq_array30_u32(self: Item, other: Item): boolean { return self.key === other.key; } @@ -25,31 +25,31 @@ export function eq$cmp_PartialEq_unit(self: Item, other: Item, other: Item): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd_u8(self: Item, other: Item): rs.Ordering | undefined { return cmp$cmp_Ord_u8(self, other); } -export function lt$cmp_PartialOrd_Cell_u32(self: Item>, other: Item>): boolean { +export function lt$cmp_PartialOrd_Cell_u32(self: Item>, other: Item>): boolean { note(60, self.tag, other.tag); return self.key < other.key; } -export function lt$cmp_PartialOrd_array10_u32(self: Item, other: Item): boolean { +export function lt$cmp_PartialOrd_array10_u32(self: Item, other: Item): boolean { note(60, self.tag, other.tag); return self.key < other.key; } -export function lt$cmp_PartialOrd_array1100_u32(self: Item, other: Item): boolean { +export function lt$cmp_PartialOrd_array1100_u32(self: Item, other: Item): boolean { note(60, self.tag, other.tag); return self.key < other.key; } -export function lt$cmp_PartialOrd_array22_u32(self: Item, other: Item): boolean { +export function lt$cmp_PartialOrd_array22_u32(self: Item, other: Item): boolean { note(60, self.tag, other.tag); return self.key < other.key; } -export function lt$cmp_PartialOrd_array30_u32(self: Item, other: Item): boolean { +export function lt$cmp_PartialOrd_array30_u32(self: Item, other: Item): boolean { note(60, self.tag, other.tag); return self.key < other.key; } @@ -64,39 +64,39 @@ export function lt$cmp_PartialOrd_unit(self: Item, other: Item>, other: Item>): rt.Ordering { +export function cmp$cmp_Ord_Cell_u32(self: Item>, other: Item>): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_array10_u32(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_array10_u32(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_array22_u32(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_array22_u32(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_array30_u32(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_array30_u32(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_sorts_Held(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_sorts_Held(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_u8(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_u8(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } -export function cmp$cmp_Ord_unit(self: Item, other: Item): rt.Ordering { +export function cmp$cmp_Ord_unit(self: Item, other: Item): rs.Ordering { note(99, self.tag, other.tag); - return rt.cmp(self.key, other.key); + return rs.cmp(self.key, other.key); } //# sourceMappingURL=sorts.Item.ts.map diff --git a/ts/fixtures/lang/sorts/expected/sorts.ts b/ts/fixtures/lang/sorts/expected/sorts.ts index e21ae535b..be8bfdcf1 100644 --- a/ts/fixtures/lang/sorts/expected/sorts.ts +++ b/ts/fixtures/lang/sorts/expected/sorts.ts @@ -1,177 +1,177 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1ttssgs as option_mapOr$1ttssgs } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$0z4nmg2 as option_mapOr$0z4nmg2 } from "./core/option.ts"; import type * as Held from "./sorts.Held.ts"; import * as Item from "./sorts.Item.ts"; -export const LOG: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(LOG$init, false); +export const LOG: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(LOG$init, false); -export function LOG$init(): rt.Cell<[rt.u32, rt.u32]> { - return new rt.Cell([2166136261, 0]); +export function LOG$init(): rs.Cell<[rs.u32, rs.u32]> { + return new rs.Cell([2166136261, 0]); } /** Forgets what an earlier case logged, which its panic may have left. */ export function begin(): void { - ((log: rt.Cell<[rt.u32, rt.u32]>): undefined => { - rt.cellSet(log, [2166136261, 0]); + ((log: rs.Cell<[rs.u32, rs.u32]>): undefined => { + rs.cellSet(log, [2166136261, 0]); })(LOG.get()); } -export function note(what: rt.u8, a: rt.u16, b: rt.u16): void { - ((log: rt.Cell<[rt.u32, rt.u32]>): undefined => { - const _52: [rt.u32, rt.u32] = log.v; - let hash: rt.u32 = _52[0]; - const count: rt.u32 = _52[1]; - const iter: rt.Iter = rt.iterSlice(Uint8Array.of(what, a & 0xff, (a >> 8) & 0xff, b & 0xff, (b >> 8) & 0xff)); +export function note(what: rs.u8, a: rs.u16, b: rs.u16): void { + ((log: rs.Cell<[rs.u32, rs.u32]>): undefined => { + const _52: [rs.u32, rs.u32] = log.v; + let hash: rs.u32 = _52[0]; + const count: rs.u32 = _52[1]; + const iter: rs.Iter = rs.iterSlice(Uint8Array.of(what, a & 0xff, (a >> 8) & 0xff, b & 0xff, (b >> 8) & 0xff)); while (true) { - const _24: rt.u8 | rt.Done = iter.next(); - if (_24 === rt.DONE) { + const _24: rs.u8 | rs.Done = iter.next(); + if (_24 === rs.DONE) { break; } - hash = rt.u32WrappingMul((hash ^ _24 as rt.u32) >>> 0, 16777619); + hash = rs.u32WrappingMul((hash ^ _24 as rs.u32) >>> 0, 16777619); } - rt.cellSet(log, [hash, rt.u32Add(count, 1)] as [rt.u32, rt.u32]); + rs.cellSet(log, [hash, rs.u32Add(count, 1)] as [rs.u32, rs.u32]); })(LOG.get()); } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$Cell_u32(v: Item.Item>[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$Cell_u32(v: Item.Item>[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item>): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item>): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item>): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item>): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$array10_u32(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$array10_u32(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$array1100_u32(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$array1100_u32(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$array22_u32(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$array22_u32(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$array30_u32(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$array30_u32(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$sorts_Held(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$sorts_Held(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } /** Puts the log's hash and count, then each tag in order, or a hash of them past 64. */ -export function put$unit(v: Item.Item[], out: rt.ByteVec): void { - const _5: [rt.u32, rt.u32] = ((log: rt.Cell<[rt.u32, rt.u32]>): [rt.u32, rt.u32] => { - return rt.cellReplace(log, [2166136261, 0]); +export function put$unit(v: Item.Item[], out: rs.ByteVec): void { + const _5: [rs.u32, rs.u32] = ((log: rs.Cell<[rs.u32, rs.u32]>): [rs.u32, rs.u32] => { + return rs.cellReplace(log, [2166136261, 0]); })(LOG.get()); - const hash: rt.u32 = _5[0]; - const count: rt.u32 = _5[1]; - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(hash).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(count).reverse()), undefined, true); + const hash: rs.u32 = _5[0]; + const count: rs.u32 = _5[1]; + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(hash).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(count).reverse()), undefined, true); if (!(v.length <= 64)) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.iterFold(rt.iterSlice(v), 0, (h: rt.u32, x2: Item.Item): rt.u32 => { - return rt.u32WrappingMul((h ^ x2.tag as rt.u32) >>> 0, 16777619); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.iterFold(rs.iterSlice(v), 0, (h: rs.u32, x2: Item.Item): rs.u32 => { + return rs.u32WrappingMul((h ^ x2.tag as rs.u32) >>> 0, 16777619); })).reverse()), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v), (x: Item.Item): Uint8Array => { - return rt.u16ToBeBytes(x.tag).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v), (x: Item.Item): Uint8Array => { + return rs.u16ToBeBytes(x.tag).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } } @@ -179,45 +179,45 @@ export function put$unit(v: Item.Item[], out: rt.ByteVec): void { * Each sort of items of each kind, of the length `kind` picks, keyed as the first byte of * `data` picks from the rest. */ -export function sorts(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function sorts(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { begin(); - const _7: rt.usize = rt.usizeRem(kind as rt.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); + const _7: rs.usize = rs.usizeRem(kind as rs.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); if (!(_7 < 20)) { - rt.panic("index out of bounds: the len is " + 20 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 20 + " but the index is " + _7); } - const n: rt.usize = [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_7]; - const keys_: rt.Vec = keys(n, dataData, dataStart, dataLen); + const n: rs.usize = [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_7]; + const keys_: rs.Vec = keys(n, dataData, dataStart, dataLen); sorted$unit_sorts_sorts_closure0(keys_.items, (): undefined => {}, out); - sorted$Cell_u32_sorts_sorts_closure1(keys_.items, (): rt.Cell => { - return new rt.Cell(0); + sorted$Cell_u32_sorts_sorts_closure1(keys_.items, (): rs.Cell => { + return new rs.Cell(0); }, out); if (n <= 300) { sorted$sorts_Held_sorts_sorts_closure2(keys_.items, (): Held.Held => { - return { _0: rt.bytes(2) }; + return { _0: rs.bytes(2) }; }, out); - sorted$array10_u32_sorts_sorts_closure3(keys_.items, (): rt.u32[] => { - return Array.from({ length: 10 }, (): rt.u32 => { + sorted$array10_u32_sorts_sorts_closure3(keys_.items, (): rs.u32[] => { + return Array.from({ length: 10 }, (): rs.u32 => { return 0; }); }, out); - sorted$array22_u32_sorts_sorts_closure4(keys_.items, (): rt.u32[] => { - return Array.from({ length: 22 }, (): rt.u32 => { + sorted$array22_u32_sorts_sorts_closure4(keys_.items, (): rs.u32[] => { + return Array.from({ length: 22 }, (): rs.u32 => { return 0; }); }, out); - sorted$array30_u32_sorts_sorts_closure5(keys_.items, (): rt.u32[] => { - return Array.from({ length: 30 }, (): rt.u32 => { + sorted$array30_u32_sorts_sorts_closure5(keys_.items, (): rs.u32[] => { + return Array.from({ length: 30 }, (): rs.u32 => { return 0; }); }, out); } if (n === 2000) { - const v: rt.Vec> = items$array1100_u32_sorts_sorts_closure6(keys_.items, (): rt.u32[] => { - return Array.from({ length: 1100 }, (): rt.u32 => { + const v: rs.Vec> = items$array1100_u32_sorts_sorts_closure6(keys_.items, (): rs.u32[] => { + return Array.from({ length: 1100 }, (): rs.u32 => { return 0; }); }); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_array1100_u32, 4404, true); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_array1100_u32, 4404, true); put$array1100_u32(v.items, out); } } @@ -226,394 +226,394 @@ export function sorts(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * `n` keys, random, of few values, ascending, strictly descending, or ascending with some * out of place, as the first byte of `data` picks, from the rest. */ -export function keys(n: rt.usize, dataData: Uint8Array, dataStart: number, dataLen: number): rt.Vec { - const _7: [rt.u8, rt.ByteSlice] = [0, rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of()), 0)]; - const _5: [rt.u8, rt.ByteSlice] = option_mapOr$1ttssgs((dataLen !== 0 ? [dataData[dataStart], new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rt.u8, rt.ByteSlice] : undefined) as [rt.u8, rt.ByteSlice] | undefined, _7, (_2: [rt.u8, rt.ByteSlice]): [rt.u8, rt.ByteSlice] => { - return [_2[0], _2[1]] as [rt.u8, rt.ByteSlice]; +export function keys(n: rs.usize, dataData: Uint8Array, dataStart: number, dataLen: number): rs.Vec { + const _7: [rs.u8, rs.ByteSlice] = [0, rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of()), 0)]; + const _5: [rs.u8, rs.ByteSlice] = option_mapOr$0z4nmg2((dataLen !== 0 ? [dataData[dataStart], new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)] as [rs.u8, rs.ByteSlice] : undefined) as [rs.u8, rs.ByteSlice] | undefined, _7, (_2: [rs.u8, rs.ByteSlice]): [rs.u8, rs.ByteSlice] => { + return [_2[0], _2[1]] as [rs.u8, rs.ByteSlice]; }); - const pick: rt.u8 = _5[0]; - let captured = (rt.iterFold(rt.iterSlice(rt.byteSliceView(_5[1])), 2654435769, (h: rt.u32, _3: rt.u8): rt.u32 => { - return rt.u32WrappingMul((h ^ _3 as rt.u32) >>> 0, 16777619); + const pick: rs.u8 = _5[0]; + let captured = (rs.iterFold(rs.iterSlice(rs.byteSliceView(_5[1])), 2654435769, (h: rs.u32, _3: rs.u8): rs.u32 => { + return rs.u32WrappingMul((h ^ _3 as rs.u32) >>> 0, 16777619); }) | 1) >>> 0; - const random: () => rt.u32 = (): rt.u32 => { + const random: () => rs.u32 = (): rs.u32 => { captured = (captured ^ ((captured << 13) >>> 0)) >>> 0; captured = (captured ^ (captured >>> 17)) >>> 0; captured = (captured ^ ((captured << 5) >>> 0)) >>> 0; return captured; }; - return rt.iterToVec(rt.iterMap(new rt.Range(0, n), (i: rt.usize): rt.u16 => { - const r: rt.u32 = random(); - const _42: rt.u8 = rt.u8Rem(pick, 5); + return rs.iterToVec(rs.iterMap(new rs.Range(0, n), (i: rs.usize): rs.u16 => { + const r: rs.u32 = random(); + const _42: rs.u8 = rs.u8Rem(pick, 5); if (_42 === 0) { return r & 0xffff; } if (_42 === 1) { - return rt.u32Rem(r, 3) & 0xffff; + return rs.u32Rem(r, 3) & 0xffff; } if (_42 === 2) { return i & 0xffff; } if (_42 === 3) { - return rt.usizeSub(n, i) & 0xffff; + return rs.usizeSub(n, i) & 0xffff; } - if (!(rt.u32Rem(r, 8) === 0)) { + if (!(rs.u32Rem(r, 8) === 0)) { return i & 0xffff; } - return rt.u32Rem(r, 64) & 0xffff; + return rs.u32Rem(r, 64) & 0xffff; }), undefined, 2, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$Cell_u32_ref_sorts_sorts_closure1(keys: rt.u16[], pad: () => rt.Cell): rt.Vec>> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item> => { +export function items$Cell_u32_ref_sorts_sorts_closure1(keys: rs.u16[], pad: () => rs.Cell): rs.Vec>> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item> => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 8, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$Cell_u32_sorts_disorders_closure3(keys: rt.u16[], pad: () => rt.Cell): rt.Vec>> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item> => { +export function items$Cell_u32_sorts_disorders_closure3(keys: rs.u16[], pad: () => rs.Cell): rs.Vec>> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item> => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 8, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array10_u32_ref_sorts_sorts_closure3(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array10_u32_ref_sorts_sorts_closure3(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 44, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array10_u32_sorts_disorders_closure1(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array10_u32_sorts_disorders_closure1(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 44, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array1100_u32_sorts_sorts_closure6(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array1100_u32_sorts_sorts_closure6(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 4404, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array22_u32_ref_sorts_sorts_closure4(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array22_u32_ref_sorts_sorts_closure4(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 92, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array30_u32_ref_sorts_sorts_closure5(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array30_u32_ref_sorts_sorts_closure5(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 124, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array30_u32_sorts_btrees_closure3(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array30_u32_sorts_btrees_closure3(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 124, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$array30_u32_sorts_disorders_closure2(keys: rt.u16[], pad: () => rt.u32[]): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$array30_u32_sorts_disorders_closure2(keys: rs.u16[], pad: () => rs.u32[]): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 124, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$sorts_Held_ref_sorts_sorts_closure2(keys: rt.u16[], pad: () => Held.Held): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { +export function items$sorts_Held_ref_sorts_sorts_closure2(keys: rs.u16[], pad: () => Held.Held): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { return new Item.Item(_2[1], _2[0] & 0xffff, pad()); }), undefined, 6, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$unit_ref_sorts_sorts_closure0(keys: rt.u16[], pad: () => undefined): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { - const i: rt.usize = _2[0]; - const key: rt.u16 = _2[1]; - const _52: rt.u16 = i & 0xffff; +export function items$unit_ref_sorts_sorts_closure0(keys: rs.u16[], pad: () => undefined): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { + const i: rs.usize = _2[0]; + const key: rs.u16 = _2[1]; + const _52: rs.u16 = i & 0xffff; pad(); return new Item.Item(key, _52, undefined); }), undefined, 4, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$unit_sorts_btrees_closure0(keys: rt.u16[], pad: () => undefined): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { - const i: rt.usize = _2[0]; - const key: rt.u16 = _2[1]; - const _52: rt.u16 = i & 0xffff; +export function items$unit_sorts_btrees_closure0(keys: rs.u16[], pad: () => undefined): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { + const i: rs.usize = _2[0]; + const key: rs.u16 = _2[1]; + const _52: rs.u16 = i & 0xffff; pad(); return new Item.Item(key, _52, undefined); }), undefined, 4, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$unit_sorts_btrees_closure1(keys: rt.u16[], pad: () => undefined): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { - const i: rt.usize = _2[0]; - const key: rt.u16 = _2[1]; - const _52: rt.u16 = i & 0xffff; +export function items$unit_sorts_btrees_closure1(keys: rs.u16[], pad: () => undefined): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { + const i: rs.usize = _2[0]; + const key: rs.u16 = _2[1]; + const _52: rs.u16 = i & 0xffff; pad(); return new Item.Item(key, _52, undefined); }), undefined, 4, true); } /** `keys` as items, each padded by `pad` and tagged by where it is. */ -export function items$unit_sorts_disorders_closure0(keys: rt.u16[], pad: () => undefined): rt.Vec> { - return rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(keys)), (_2: [rt.usize, rt.u16]): Item.Item => { - const i: rt.usize = _2[0]; - const key: rt.u16 = _2[1]; - const _52: rt.u16 = i & 0xffff; +export function items$unit_sorts_disorders_closure0(keys: rs.u16[], pad: () => undefined): rs.Vec> { + return rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(keys)), (_2: [rs.usize, rs.u16]): Item.Item => { + const i: rs.usize = _2[0]; + const key: rs.u16 = _2[1]; + const _52: rs.u16 = i & 0xffff; pad(); return new Item.Item(key, _52, undefined); }), undefined, 4, true); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$Cell_u32_sorts_sorts_closure1(keys: rt.u16[], pad: () => rt.Cell, out: rt.ByteVec): void { - const items: () => rt.Vec>> = (): rt.Vec>> => { +export function sorted$Cell_u32_sorts_sorts_closure1(keys: rs.u16[], pad: () => rs.Cell, out: rs.ByteVec): void { + const items: () => rs.Vec>> = (): rs.Vec>> => { return items$Cell_u32_ref_sorts_sorts_closure1(keys, pad); }; - const v: rt.Vec>> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_Cell_u32, 8, false); + const v: rs.Vec>> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_Cell_u32, 8, false); put$Cell_u32(v.items, out); - const v2: rt.Vec>> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_Cell_u32, 8, false, false); + const v2: rs.Vec>> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_Cell_u32, 8, false, false); put$Cell_u32(v2.items, out); - const v3: rt.Vec>> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item>, b: Item.Item>): rt.Ordering => { + const v3: rs.Vec>> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item>, b: Item.Item>): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 8, false); put$Cell_u32(v3.items, out); - const v4: rt.Vec>> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_Cell_u32), 8, false, false); + const v4: rs.Vec>> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_Cell_u32), 8, false, false); put$Cell_u32(v4.items, out); - const v5: rt.Vec>> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item>): rt.u16 => { + const v5: rs.Vec>> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item>): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 8, false); + return rs.u16Div(x.key, 4); + }, rs.lt), 8, false); put$Cell_u32(v5.items, out); - const v6: rt.Vec>> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item>): rt.u16 => { + const v6: rs.Vec>> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item>): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 8, false, false); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 8, false, false); put$Cell_u32(v6.items, out); - const v7: rt.Vec>> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item>): Item.Item => { + const v7: rs.Vec>> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item>): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$Cell_u32(v7.items, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$array10_u32_sorts_sorts_closure3(keys: rt.u16[], pad: () => rt.u32[], out: rt.ByteVec): void { - const items: () => rt.Vec> = (): rt.Vec> => { +export function sorted$array10_u32_sorts_sorts_closure3(keys: rs.u16[], pad: () => rs.u32[], out: rs.ByteVec): void { + const items: () => rs.Vec> = (): rs.Vec> => { return items$array10_u32_ref_sorts_sorts_closure3(keys, pad); }; - const v: rt.Vec> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_array10_u32, 44, true); + const v: rs.Vec> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_array10_u32, 44, true); put$array10_u32(v.items, out); - const v2: rt.Vec> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array10_u32, 44, true, true); + const v2: rs.Vec> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array10_u32, 44, true, true); put$array10_u32(v2.items, out); - const v3: rt.Vec> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item, b: Item.Item): rt.Ordering => { + const v3: rs.Vec> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item, b: Item.Item): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 44, true); put$array10_u32(v3.items, out); - const v4: rt.Vec> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_array10_u32), 44, true, true); + const v4: rs.Vec> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_array10_u32), 44, true, true); put$array10_u32(v4.items, out); - const v5: rt.Vec> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item): rt.u16 => { + const v5: rs.Vec> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 44, true); + return rs.u16Div(x.key, 4); + }, rs.lt), 44, true); put$array10_u32(v5.items, out); - const v6: rt.Vec> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item): rt.u16 => { + const v6: rs.Vec> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 44, true, true); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 44, true, true); put$array10_u32(v6.items, out); - const v7: rt.Vec> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { + const v7: rs.Vec> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$array10_u32(v7.items, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$array22_u32_sorts_sorts_closure4(keys: rt.u16[], pad: () => rt.u32[], out: rt.ByteVec): void { - const items: () => rt.Vec> = (): rt.Vec> => { +export function sorted$array22_u32_sorts_sorts_closure4(keys: rs.u16[], pad: () => rs.u32[], out: rs.ByteVec): void { + const items: () => rs.Vec> = (): rs.Vec> => { return items$array22_u32_ref_sorts_sorts_closure4(keys, pad); }; - const v: rt.Vec> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_array22_u32, 92, true); + const v: rs.Vec> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_array22_u32, 92, true); put$array22_u32(v.items, out); - const v2: rt.Vec> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array22_u32, 92, true, true); + const v2: rs.Vec> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array22_u32, 92, true, true); put$array22_u32(v2.items, out); - const v3: rt.Vec> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item, b: Item.Item): rt.Ordering => { + const v3: rs.Vec> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item, b: Item.Item): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 92, true); put$array22_u32(v3.items, out); - const v4: rt.Vec> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_array22_u32), 92, true, true); + const v4: rs.Vec> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_array22_u32), 92, true, true); put$array22_u32(v4.items, out); - const v5: rt.Vec> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item): rt.u16 => { + const v5: rs.Vec> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 92, true); + return rs.u16Div(x.key, 4); + }, rs.lt), 92, true); put$array22_u32(v5.items, out); - const v6: rt.Vec> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item): rt.u16 => { + const v6: rs.Vec> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 92, true, true); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 92, true, true); put$array22_u32(v6.items, out); - const v7: rt.Vec> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { + const v7: rs.Vec> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$array22_u32(v7.items, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$array30_u32_sorts_sorts_closure5(keys: rt.u16[], pad: () => rt.u32[], out: rt.ByteVec): void { - const items: () => rt.Vec> = (): rt.Vec> => { +export function sorted$array30_u32_sorts_sorts_closure5(keys: rs.u16[], pad: () => rs.u32[], out: rs.ByteVec): void { + const items: () => rs.Vec> = (): rs.Vec> => { return items$array30_u32_ref_sorts_sorts_closure5(keys, pad); }; - const v: rt.Vec> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_array30_u32, 124, true); + const v: rs.Vec> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_array30_u32, 124, true); put$array30_u32(v.items, out); - const v2: rt.Vec> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array30_u32, 124, true, true); + const v2: rs.Vec> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_array30_u32, 124, true, true); put$array30_u32(v2.items, out); - const v3: rt.Vec> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item, b: Item.Item): rt.Ordering => { + const v3: rs.Vec> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item, b: Item.Item): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 124, true); put$array30_u32(v3.items, out); - const v4: rt.Vec> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_array30_u32), 124, true, true); + const v4: rs.Vec> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_array30_u32), 124, true, true); put$array30_u32(v4.items, out); - const v5: rt.Vec> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item): rt.u16 => { + const v5: rs.Vec> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 124, true); + return rs.u16Div(x.key, 4); + }, rs.lt), 124, true); put$array30_u32(v5.items, out); - const v6: rt.Vec> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item): rt.u16 => { + const v6: rs.Vec> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 124, true, true); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 124, true, true); put$array30_u32(v6.items, out); - const v7: rt.Vec> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { + const v7: rs.Vec> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$array30_u32(v7.items, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$sorts_Held_sorts_sorts_closure2(keys: rt.u16[], pad: () => Held.Held, out: rt.ByteVec): void { - const items: () => rt.Vec> = (): rt.Vec> => { +export function sorted$sorts_Held_sorts_sorts_closure2(keys: rs.u16[], pad: () => Held.Held, out: rs.ByteVec): void { + const items: () => rs.Vec> = (): rs.Vec> => { return items$sorts_Held_ref_sorts_sorts_closure2(keys, pad); }; - const v: rt.Vec> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_sorts_Held, 6, true); + const v: rs.Vec> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_sorts_Held, 6, true); put$sorts_Held(v.items, out); - const v2: rt.Vec> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_sorts_Held, 6, true, false); + const v2: rs.Vec> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_sorts_Held, 6, true, false); put$sorts_Held(v2.items, out); - const v3: rt.Vec> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item, b: Item.Item): rt.Ordering => { + const v3: rs.Vec> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item, b: Item.Item): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 6, true); put$sorts_Held(v3.items, out); - const v4: rt.Vec> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_sorts_Held), 6, true, false); + const v4: rs.Vec> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_sorts_Held), 6, true, false); put$sorts_Held(v4.items, out); - const v5: rt.Vec> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item): rt.u16 => { + const v5: rs.Vec> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 6, true); + return rs.u16Div(x.key, 4); + }, rs.lt), 6, true); put$sorts_Held(v5.items, out); - const v6: rt.Vec> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item): rt.u16 => { + const v6: rs.Vec> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 6, true, false); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 6, true, false); put$sorts_Held(v6.items, out); - const v7: rt.Vec> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { + const v7: rs.Vec> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$sorts_Held(v7.items, out); } /** Each sort of `keys` as items padded by `pad`, and what it tested and left. */ -export function sorted$unit_sorts_sorts_closure0(keys: rt.u16[], pad: () => undefined, out: rt.ByteVec): void { - const items: () => rt.Vec> = (): rt.Vec> => { +export function sorted$unit_sorts_sorts_closure0(keys: rs.u16[], pad: () => undefined, out: rs.ByteVec): void { + const items: () => rs.Vec> = (): rs.Vec> => { return items$unit_ref_sorts_sorts_closure0(keys, pad); }; - const v: rt.Vec> = items(); - rt.sliceSort(v.items, Item.lt$cmp_PartialOrd_unit, 4, true); + const v: rs.Vec> = items(); + rs.sliceSort(v.items, Item.lt$cmp_PartialOrd_unit, 4, true); put$unit(v.items, out); - const v2: rt.Vec> = items(); - rt.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_unit, 4, true, true); + const v2: rs.Vec> = items(); + rs.sliceSortUnstable(v2.items, Item.lt$cmp_PartialOrd_unit, 4, true, true); put$unit(v2.items, out); - const v3: rt.Vec> = items(); - rt.sliceSort(v3.items, rt.cmpLt((a: Item.Item, b: Item.Item): rt.Ordering => { + const v3: rs.Vec> = items(); + rs.sliceSort(v3.items, rs.cmpLt((a: Item.Item, b: Item.Item): rs.Ordering => { note(98, a.tag, b.tag); - return rt.cmp(b.key, a.key); + return rs.cmp(b.key, a.key); }), 4, true); put$unit(v3.items, out); - const v4: rt.Vec> = items(); - rt.sliceSortUnstable(v4.items, rt.cmpLt(Item.cmp$cmp_Ord_unit), 4, true, true); + const v4: rs.Vec> = items(); + rs.sliceSortUnstable(v4.items, rs.cmpLt(Item.cmp$cmp_Ord_unit), 4, true, true); put$unit(v4.items, out); - const v5: rt.Vec> = items(); - rt.sliceSort(v5.items, rt.keyLt((x: Item.Item): rt.u16 => { + const v5: rs.Vec> = items(); + rs.sliceSort(v5.items, rs.keyLt((x: Item.Item): rs.u16 => { note(107, x.tag, 0); - return rt.u16Div(x.key, 4); - }, rt.lt), 4, true); + return rs.u16Div(x.key, 4); + }, rs.lt), 4, true); put$unit(v5.items, out); - const v6: rt.Vec> = items(); - rt.sliceSortUnstable(v6.items, rt.keyLt((x2: Item.Item): rt.u16 => { + const v6: rs.Vec> = items(); + rs.sliceSortUnstable(v6.items, rs.keyLt((x2: Item.Item): rs.u16 => { note(107, x2.tag, 0); - return rt.u16Rem(x2.key, 3); - }, rt.lt), 4, true, true); + return rs.u16Rem(x2.key, 3); + }, rs.lt), 4, true, true); put$unit(v6.items, out); - const v7: rt.Vec> = items(); - rt.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { + const v7: rs.Vec> = items(); + rs.sliceSortByCachedKey(v7.items, (x3: Item.Item): Item.Item => { note(107, x3.tag, 0); - return new Item.Item(rt.u16Rem(x3.key, 5), x3.tag, 0); - }, rt.cmpLt(rt.cmpTuple<[Item.Item, rt.usize], rt.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rt.cmp])), 12, true, true); + return new Item.Item(rs.u16Rem(x3.key, 5), x3.tag, 0); + }, rs.cmpLt(rs.cmpTuple<[Item.Item, rs.usize], rs.Ordering | undefined>([Item.partialCmp$cmp_PartialOrd_u8, rs.cmp])), 12, true, true); put$unit(v7.items, out); } @@ -622,45 +622,45 @@ export function sorted$unit_sorts_sorts_closure0(keys: rt.u16[], pad: () => unde * answers follow `data` rather than any order, which std may panic at: what it tested * and left. */ -export function disorders(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function disorders(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { begin(); - const _8: rt.usize = rt.usizeRem(kind as rt.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); + const _8: rs.usize = rs.usizeRem(kind as rs.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); if (!(_8 < 20)) { - rt.panic("index out of bounds: the len is " + 20 + " but the index is " + _8); + rs.panic("index out of bounds: the len is " + 20 + " but the index is " + _8); } - const keys_: rt.Vec = keys(rt.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), data.data, data.start, data.length); - const stable: boolean = rt.u8Rem(rt.u8Div(kind, 20), 2) === 0; - const _21: rt.u8 = rt.u8Rem(rt.u8Div(kind, 40), 4); + const keys_: rs.Vec = keys(rs.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), data.data, data.start, data.length); + const stable: boolean = rs.u8Rem(rs.u8Div(kind, 20), 2) === 0; + const _21: rs.u8 = rs.u8Rem(rs.u8Div(kind, 40), 4); if (_21 === 0) { disordered$unit_sorts_disorders_closure0(keys_.items, stable, (): undefined => {}, data, out); } else if (_21 === 1) { - disordered$array10_u32_sorts_disorders_closure1(keys_.items, stable, (): rt.u32[] => { - return Array.from({ length: 10 }, (): rt.u32 => { + disordered$array10_u32_sorts_disorders_closure1(keys_.items, stable, (): rs.u32[] => { + return Array.from({ length: 10 }, (): rs.u32 => { return 0; }); }, data, out); } else if (_21 === 2) { - disordered$array30_u32_sorts_disorders_closure2(keys_.items, stable, (): rt.u32[] => { - return Array.from({ length: 30 }, (): rt.u32 => { + disordered$array30_u32_sorts_disorders_closure2(keys_.items, stable, (): rs.u32[] => { + return Array.from({ length: 30 }, (): rs.u32 => { return 0; }); }, data, out); } else { - disordered$Cell_u32_sorts_disorders_closure3(keys_.items, stable, (): rt.Cell => { - return new rt.Cell(0); + disordered$Cell_u32_sorts_disorders_closure3(keys_.items, stable, (): rs.Cell => { + return new rs.Cell(0); }, data, out); } } -export function disordered$Cell_u32_sorts_disorders_closure3(keys: rt.u16[], stable: boolean, pad: () => rt.Cell, data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.Vec>> = items$Cell_u32_sorts_disorders_closure3(keys, pad); - const calls: rt.Cell = new rt.Cell(0); - const by: (a0: Item.Item>, a1: Item.Item>) => rt.Ordering = (a: Item.Item>, b: Item.Item>): rt.Ordering => { +export function disordered$Cell_u32_sorts_disorders_closure3(keys: rs.u16[], stable: boolean, pad: () => rs.Cell, data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.Vec>> = items$Cell_u32_sorts_disorders_closure3(keys, pad); + const calls: rs.Cell = new rs.Cell(0); + const by: (a0: Item.Item>, a1: Item.Item>) => rs.Ordering = (a: Item.Item>, b: Item.Item>): rs.Ordering => { note(63, a.tag, b.tag); - const i: rt.usize = calls.v; - rt.cellSet(calls, rt.usizeAdd(i, 1)); - const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeRem(i, rt.max(data.length, 1))), 0) ^ (i & 0xff); - const _20: rt.u16 = rt.u16Rem(a.key ^ b.key ^ bits as rt.u16, 3); + const i: rs.usize = calls.v; + rs.cellSet(calls, rs.usizeAdd(i, 1)); + const bits: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeRem(i, rs.max(data.length, 1))), 0) ^ (i & 0xff); + const _20: rs.u16 = rs.u16Rem(a.key ^ b.key ^ bits as rs.u16, 3); if (_20 === 0) { return -1; } @@ -670,22 +670,22 @@ export function disordered$Cell_u32_sorts_disorders_closure3(keys: rt.u16[], sta return 1; }; if (!stable) { - rt.sliceSortUnstable(v.items, rt.cmpLt(by), 8, false, false); + rs.sliceSortUnstable(v.items, rs.cmpLt(by), 8, false, false); } else { - rt.sliceSort(v.items, rt.cmpLt(by), 8, false); + rs.sliceSort(v.items, rs.cmpLt(by), 8, false); } put$Cell_u32(v.items, out); } -export function disordered$array10_u32_sorts_disorders_closure1(keys: rt.u16[], stable: boolean, pad: () => rt.u32[], data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.Vec> = items$array10_u32_sorts_disorders_closure1(keys, pad); - const calls: rt.Cell = new rt.Cell(0); - const by: (a0: Item.Item, a1: Item.Item) => rt.Ordering = (a: Item.Item, b: Item.Item): rt.Ordering => { +export function disordered$array10_u32_sorts_disorders_closure1(keys: rs.u16[], stable: boolean, pad: () => rs.u32[], data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.Vec> = items$array10_u32_sorts_disorders_closure1(keys, pad); + const calls: rs.Cell = new rs.Cell(0); + const by: (a0: Item.Item, a1: Item.Item) => rs.Ordering = (a: Item.Item, b: Item.Item): rs.Ordering => { note(63, a.tag, b.tag); - const i: rt.usize = calls.v; - rt.cellSet(calls, rt.usizeAdd(i, 1)); - const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeRem(i, rt.max(data.length, 1))), 0) ^ (i & 0xff); - const _20: rt.u16 = rt.u16Rem(a.key ^ b.key ^ bits as rt.u16, 3); + const i: rs.usize = calls.v; + rs.cellSet(calls, rs.usizeAdd(i, 1)); + const bits: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeRem(i, rs.max(data.length, 1))), 0) ^ (i & 0xff); + const _20: rs.u16 = rs.u16Rem(a.key ^ b.key ^ bits as rs.u16, 3); if (_20 === 0) { return -1; } @@ -695,22 +695,22 @@ export function disordered$array10_u32_sorts_disorders_closure1(keys: rt.u16[], return 1; }; if (!stable) { - rt.sliceSortUnstable(v.items, rt.cmpLt(by), 44, true, true); + rs.sliceSortUnstable(v.items, rs.cmpLt(by), 44, true, true); } else { - rt.sliceSort(v.items, rt.cmpLt(by), 44, true); + rs.sliceSort(v.items, rs.cmpLt(by), 44, true); } put$array10_u32(v.items, out); } -export function disordered$array30_u32_sorts_disorders_closure2(keys: rt.u16[], stable: boolean, pad: () => rt.u32[], data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.Vec> = items$array30_u32_sorts_disorders_closure2(keys, pad); - const calls: rt.Cell = new rt.Cell(0); - const by: (a0: Item.Item, a1: Item.Item) => rt.Ordering = (a: Item.Item, b: Item.Item): rt.Ordering => { +export function disordered$array30_u32_sorts_disorders_closure2(keys: rs.u16[], stable: boolean, pad: () => rs.u32[], data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.Vec> = items$array30_u32_sorts_disorders_closure2(keys, pad); + const calls: rs.Cell = new rs.Cell(0); + const by: (a0: Item.Item, a1: Item.Item) => rs.Ordering = (a: Item.Item, b: Item.Item): rs.Ordering => { note(63, a.tag, b.tag); - const i: rt.usize = calls.v; - rt.cellSet(calls, rt.usizeAdd(i, 1)); - const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeRem(i, rt.max(data.length, 1))), 0) ^ (i & 0xff); - const _20: rt.u16 = rt.u16Rem(a.key ^ b.key ^ bits as rt.u16, 3); + const i: rs.usize = calls.v; + rs.cellSet(calls, rs.usizeAdd(i, 1)); + const bits: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeRem(i, rs.max(data.length, 1))), 0) ^ (i & 0xff); + const _20: rs.u16 = rs.u16Rem(a.key ^ b.key ^ bits as rs.u16, 3); if (_20 === 0) { return -1; } @@ -720,22 +720,22 @@ export function disordered$array30_u32_sorts_disorders_closure2(keys: rt.u16[], return 1; }; if (!stable) { - rt.sliceSortUnstable(v.items, rt.cmpLt(by), 124, true, true); + rs.sliceSortUnstable(v.items, rs.cmpLt(by), 124, true, true); } else { - rt.sliceSort(v.items, rt.cmpLt(by), 124, true); + rs.sliceSort(v.items, rs.cmpLt(by), 124, true); } put$array30_u32(v.items, out); } -export function disordered$unit_sorts_disorders_closure0(keys: rt.u16[], stable: boolean, pad: () => undefined, data: rt.ByteSlice, out: rt.ByteVec): void { - const v: rt.Vec> = items$unit_sorts_disorders_closure0(keys, pad); - const calls: rt.Cell = new rt.Cell(0); - const by: (a0: Item.Item, a1: Item.Item) => rt.Ordering = (a: Item.Item, b: Item.Item): rt.Ordering => { +export function disordered$unit_sorts_disorders_closure0(keys: rs.u16[], stable: boolean, pad: () => undefined, data: rs.ByteSlice, out: rs.ByteVec): void { + const v: rs.Vec> = items$unit_sorts_disorders_closure0(keys, pad); + const calls: rs.Cell = new rs.Cell(0); + const by: (a0: Item.Item, a1: Item.Item) => rs.Ordering = (a: Item.Item, b: Item.Item): rs.Ordering => { note(63, a.tag, b.tag); - const i: rt.usize = calls.v; - rt.cellSet(calls, rt.usizeAdd(i, 1)); - const bits: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeRem(i, rt.max(data.length, 1))), 0) ^ (i & 0xff); - const _20: rt.u16 = rt.u16Rem(a.key ^ b.key ^ bits as rt.u16, 3); + const i: rs.usize = calls.v; + rs.cellSet(calls, rs.usizeAdd(i, 1)); + const bits: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeRem(i, rs.max(data.length, 1))), 0) ^ (i & 0xff); + const _20: rs.u16 = rs.u16Rem(a.key ^ b.key ^ bits as rs.u16, 3); if (_20 === 0) { return -1; } @@ -745,9 +745,9 @@ export function disordered$unit_sorts_disorders_closure0(keys: rt.u16[], stable: return 1; }; if (!stable) { - rt.sliceSortUnstable(v.items, rt.cmpLt(by), 4, true, true); + rs.sliceSortUnstable(v.items, rs.cmpLt(by), 4, true, true); } else { - rt.sliceSort(v.items, rt.cmpLt(by), 4, true); + rs.sliceSort(v.items, rs.cmpLt(by), 4, true); } put$unit(v.items, out); } @@ -757,27 +757,27 @@ export function disordered$unit_sorts_disorders_closure0(keys: rt.u16[], stable: * and by `Ord::cmp` as a map's, before keeping the last of equal ones: which each tested * and kept. */ -export function btrees(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function btrees(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { begin(); - const _8: rt.usize = rt.usizeRem(kind as rt.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); + const _8: rs.usize = rs.usizeRem(kind as rs.usize, [0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097].length); if (!(_8 < 20)) { - rt.panic("index out of bounds: the len is " + 20 + " but the index is " + _8); + rs.panic("index out of bounds: the len is " + 20 + " but the index is " + _8); } - const keys_: rt.Vec = keys(rt.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), dataData, dataStart, dataLen); - const _17: rt.Iter> = rt.vecIntoIter(items$unit_sorts_btrees_closure0(keys_.items, (): undefined => {})); - put$unit(rt.iterToVec(rt.btreeKeys(rt.btreeCollectKeys(rt.btreeNew(Item.cmp$cmp_Ord_unit) as rt.BTreeSet>, rt.iterToVec(_17, "next", 4, true, 4).items, 4, true, Item.lt$cmp_PartialOrd_unit, Item.eq$cmp_PartialEq_unit)), undefined, 4, true).items, out); - const _27: rt.Iter<[Item.Item, rt.u16]> = rt.iterMap(rt.vecIntoIter(items$unit_sorts_btrees_closure1(keys_.items, (): undefined => {})), (x: Item.Item): [Item.Item, rt.u16] => { - return [x, x.tag] as [Item.Item, rt.u16]; + const keys_: rs.Vec = keys(rs.min([0, 1, 2, 9, 13, 16, 17, 18, 20, 21, 32, 33, 48, 64, 65, 100, 300, 2000, 4096, 4097][_8], 300), dataData, dataStart, dataLen); + const _17: rs.Iter> = rs.vecIntoIter(items$unit_sorts_btrees_closure0(keys_.items, (): undefined => {})); + put$unit(rs.iterToVec(rs.btreeKeys(rs.btreeCollectKeys(rs.btreeNew(Item.cmp$cmp_Ord_unit) as rs.BTreeSet>, rs.iterToVec(_17, "next", 4, true, 4).items, 4, true, Item.lt$cmp_PartialOrd_unit, Item.eq$cmp_PartialEq_unit)), undefined, 4, true).items, out); + const _27: rs.Iter<[Item.Item, rs.u16]> = rs.iterMap(rs.vecIntoIter(items$unit_sorts_btrees_closure1(keys_.items, (): undefined => {})), (x: Item.Item): [Item.Item, rs.u16] => { + return [x, x.tag] as [Item.Item, rs.u16]; }); - put$unit(rt.iterToVec(rt.btreeKeys(rt.btreeCollect(rt.btreeNew(Item.cmp$cmp_Ord_unit) as rt.BTreeMap, rt.u16>, rt.iterToVec(_27, undefined, 6, true).items, 6, true, Item.eq$cmp_PartialEq_unit)), undefined, 4, true).items, out); - const _38: rt.Iter<[Item.Item, rt.u16]> = rt.iterMap(rt.vecIntoIter(items$array30_u32_sorts_btrees_closure3(keys_.items, (): rt.u32[] => { - return Array.from({ length: 30 }, (): rt.u32 => { + put$unit(rs.iterToVec(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(Item.cmp$cmp_Ord_unit) as rs.BTreeMap, rs.u16>, rs.iterToVec(_27, undefined, 6, true).items, 6, true, Item.eq$cmp_PartialEq_unit)), undefined, 4, true).items, out); + const _38: rs.Iter<[Item.Item, rs.u16]> = rs.iterMap(rs.vecIntoIter(items$array30_u32_sorts_btrees_closure3(keys_.items, (): rs.u32[] => { + return Array.from({ length: 30 }, (): rs.u32 => { return 0; }); - })), (x2: Item.Item): [Item.Item, rt.u16] => { - return [x2, x2.tag] as [Item.Item, rt.u16]; + })), (x2: Item.Item): [Item.Item, rs.u16] => { + return [x2, x2.tag] as [Item.Item, rs.u16]; }); - put$array30_u32(rt.iterToVec(rt.btreeKeys(rt.btreeCollect(rt.btreeNew(Item.cmp$cmp_Ord_array30_u32) as rt.BTreeMap, rt.u16>, rt.iterToVec(_38, undefined, 128, true).items, 128, true, Item.eq$cmp_PartialEq_array30_u32)), undefined, 124, true).items, out); + put$array30_u32(rs.iterToVec(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(Item.cmp$cmp_Ord_array30_u32) as rs.BTreeMap, rs.u16>, rs.iterToVec(_38, undefined, 128, true).items, 128, true, Item.eq$cmp_PartialEq_array30_u32)), undefined, 124, true).items, out); } //# sourceMappingURL=sorts.ts.map diff --git a/ts/fixtures/lang/splits/expected/core/option.ts b/ts/fixtures/lang/splits/expected/core/option.ts index 5ee85205f..894054719 100644 --- a/ts/fixtures/lang/splits/expected/core/option.ts +++ b/ts/fixtures/lang/splits/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$11e0ggl(self: [rt.ByteSlice, rt.ByteSlice] | undefined, default_: rt.u8, f: (a0: [rt.ByteSlice, rt.ByteSlice]) => rt.u8): rt.u8 { +export function mapOr$17znd5c(self: [rs.ByteSlice, rs.ByteSlice] | undefined, default_: rs.u8, f: (a0: [rs.ByteSlice, rs.ByteSlice]) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/splits/expected/harness.ts b/ts/fixtures/lang/splits/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/splits/expected/harness.ts +++ b/ts/fixtures/lang/splits/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/splits/expected/lib.ts b/ts/fixtures/lang/splits/expected/lib.ts index 9dabf3889..d430f0ba5 100644 --- a/ts/fixtures/lang/splits/expected/lib.ts +++ b/ts/fixtures/lang/splits/expected/lib.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { splits } from "./splits.ts"; export const out$tuple2_ref_slice_u8_ref_slice_u8: { p_0Data: Uint8Array; p_0Start: number; p_0Len: number; p_1Data: Uint8Array; p_1Start: number; p_1Len: number } = { p_0Data: undefined as never, p_0Start: undefined as never, p_0Len: undefined as never, p_1Data: undefined as never, p_1Start: undefined as never, p_1Len: undefined as never }; -export const out$tuple3_u8_u16_ref_slice_u8: { err: unknown; p_1: rt.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; +export const out$tuple3_u8_u16_ref_slice_u8: { err: unknown; p_1: rs.u16; p_2Data: Uint8Array; p_2Start: number; p_2Len: number } = { err: undefined, p_1: undefined as never, p_2Data: undefined as never, p_2Start: undefined as never, p_2Len: undefined as never }; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["splits::splits", splits as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["splits::splits", splits as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/splits/expected/splits.Short.ts b/ts/fixtures/lang/splits/expected/splits.Short.ts index e41481882..0979382c5 100644 --- a/ts/fixtures/lang/splits/expected/splits.Short.ts +++ b/ts/fixtures/lang/splits/expected/splits.Short.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Why a read came up short. */ -export type Short = { tag: "Empty" } | { tag: "Need"; _0: rt.usize }; +export type Short = { tag: "Empty" } | { tag: "Need"; _0: rs.usize }; //# sourceMappingURL=splits.Short.ts.map diff --git a/ts/fixtures/lang/splits/expected/splits.ts b/ts/fixtures/lang/splits/expected/splits.ts index 21812f066..330aafaef 100644 --- a/ts/fixtures/lang/splits/expected/splits.ts +++ b/ts/fixtures/lang/splits/expected/splits.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$tuple2_ref_slice_u8_ref_slice_u8, out$tuple3_u8_u16_ref_slice_u8 } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$11e0ggl as option_mapOr$11e0ggl } from "./core/option.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$17znd5c as option_mapOr$17znd5c } from "./core/option.ts"; import type * as Short from "./splits.Short.ts"; /** The first byte, then a big-endian `u16`, by `?` on `ok_or`. */ -export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rt.u8 | undefined { +export function header(dataData: Uint8Array, dataStart: number, dataLen: number): rs.u8 | undefined { if (dataLen !== 0) { - const a: rt.u8 = dataData[dataStart]; + const a: rs.u8 = dataData[dataStart]; if (dataLen - 1 >= 2) { out$tuple3_u8_u16_ref_slice_u8.p_1 = (dataData[dataStart + 1] << 8) | dataData[dataStart + 2]; out$tuple3_u8_u16_ref_slice_u8.p_2Data = dataData; @@ -24,11 +24,11 @@ export function header(dataData: Uint8Array, dataStart: number, dataLen: number) } /** Two bytes, by `?` on an `Option`. */ -export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rt.u8, rt.u8, rt.ByteSlice] | undefined { +export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [rs.u8, rs.u8, rs.ByteSlice] | undefined { if (dataLen !== 0) { - const a: rt.u8 = dataData[dataStart]; + const a: rs.u8 = dataData[dataStart]; if (dataLen - 1 !== 0) { - return [a, dataData[dataStart + 1], new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)] as [rt.u8, rt.u8, rt.ByteSlice]; + return [a, dataData[dataStart + 1], new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)] as [rs.u8, rs.u8, rs.ByteSlice]; } return undefined; } @@ -36,7 +36,7 @@ export function two(dataData: Uint8Array, dataStart: number, dataLen: number): [ } /** `n` bytes, or how many it needed. */ -export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rt.usize): Short.Short | undefined { +export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n: rs.usize): Short.Short | undefined { if (!(n <= dataLen)) { return { tag: "Need", _0: n } as Short.Short; } @@ -50,43 +50,43 @@ export function take(dataData: Uint8Array, dataStart: number, dataLen: number, n } /** The byte after the first, or an error that is itself an enum, held whole. */ -export function second(dataData: Uint8Array, dataStart: number, dataLen: number, e: rt.u8 | undefined): rt.Result { +export function second(dataData: Uint8Array, dataStart: number, dataLen: number, e: rs.u8 | undefined): rs.Result { if (1 <= dataLen) { - return rt.Ok(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1)), 0)); + return rs.Ok(option_unwrapOr$1fr498u(rs.byteSliceFirst(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1)), 0)); } - return rt.Err(e); + return rs.Err(e); } /** A use that needs the slice itself. */ -export function opaque(s: rt.ByteSlice): rt.u8 { - return rt.iterFold(rt.iterSlice(rt.byteSliceView(s)), s.length & 0xff, (a: rt.u8, b: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(a ^ (a >> 3), b); +export function opaque(s: rs.ByteSlice): rs.u8 { + return rs.iterFold(rs.iterSlice(rs.byteSliceView(s)), s.length & 0xff, (a: rs.u8, b: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(a ^ (a >> 3), b); }); } /** An error made by a call that does something, which runs even when it isn't needed. */ -export function code(out: rt.ByteVec, n: rt.u8): rt.u8 { - rt.byteVecPush(out, 238); +export function code(out: rs.ByteVec, n: rs.u8): rs.u8 { + rs.byteVecPush(out, 238); return n; } -export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _58!: rt.u8; - let _169!: rt.u8; +export function splits(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _58!: rs.u8; + let _169!: rs.u8; let err!: Short.Short; - const _4: rt.u8 = rt.u8Rem(kind, 8); + const _4: rs.u8 = rs.u8Rem(kind, 8); if (_4 === 0) { let restData: Uint8Array = data.data; let restStart: number = data.start; let restLen: number = data.length; - let sum: rt.u8 = 0; + let sum: rs.u8 = 0; while (true) { const _9Data: Uint8Array = restData; const _9Start: number = restStart; const _9Len: number = restLen; if (_9Len !== 0) { - const b: rt.u8 = _9Data[_9Start]; - sum = rt.u8WrappingAdd(sum, b); + const b: rs.u8 = _9Data[_9Start]; + sum = rs.u8WrappingAdd(sum, b); restData = _9Data; restStart = _9Start + 1; restLen = _9Len - 1; @@ -97,49 +97,49 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { break; } } - rt.byteVecPush(out, sum); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(restData, restStart, restLen)); + rs.byteVecPush(out, sum); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(restData, restStart, restLen)); } else if (_4 === 1) { - const mid4: number = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; + const mid4: number = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8) as rs.usize; if (mid4 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - rt.byteVecPush(out, mid4 & 0xff); - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(data.data, data.start + mid4, data.length - mid4)); + rs.byteVecPush(out, mid4 & 0xff); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(data.data, data.start + mid4, data.length - mid4)); } else if (_4 === 2) { - const part7: rt.u8 | undefined = header(data.data, data.start, data.length); + const part7: rs.u8 | undefined = header(data.data, data.start, data.length); const err3: Short.Short | undefined = part7 === undefined ? out$tuple3_u8_u16_ref_slice_u8.err as Short.Short : undefined; - const part8: rt.u16 = out$tuple3_u8_u16_ref_slice_u8.p_1; + const part8: rs.u16 = out$tuple3_u8_u16_ref_slice_u8.p_1; const part9: Uint8Array = out$tuple3_u8_u16_ref_slice_u8.p_2Data; const part10: number = out$tuple3_u8_u16_ref_slice_u8.p_2Start; const part11: number = out$tuple3_u8_u16_ref_slice_u8.p_2Len; if (err3 === undefined) { - const a2: rt.u8 = part7 as rt.u8; - const b3: rt.u16 = part8; - rt.byteVecPush(out, a2); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u16ToBeBytes(b3))); - rt.byteVecPush(out, opaque(new rt.ByteSlice(part9, part10, part11))); + const a2: rs.u8 = part7 as rs.u8; + const b3: rs.u16 = part8; + rs.byteVecPush(out, a2); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u16ToBeBytes(b3))); + rs.byteVecPush(out, opaque(new rs.ByteSlice(part9, part10, part11))); } else if ((err3 as Short.Short).tag === "Empty") { - rt.byteVecPush(out, 240); + rs.byteVecPush(out, 240); } else { - rt.byteVecPush(out, 241 ^ (((err3 as Short.Short) as { tag: "Need"; _0: rt.usize })._0 & 0xff)); + rs.byteVecPush(out, 241 ^ (((err3 as Short.Short) as { tag: "Need"; _0: rs.usize })._0 & 0xff)); } } else if (_4 === 3) { - const mid3: number = rt.usizeDiv(data.length, 2); + const mid3: number = rs.usizeDiv(data.length, 2); if (mid3 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const head: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid3); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 3; + const head: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid3); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 3; while ((_58 = iterStart++) < iterEnd) { - rt.byteVecPush(out, opaque(head) ^ _58); + rs.byteVecPush(out, opaque(head) ^ _58); } - rt.byteVecPush(out, opaque(new rt.ByteSlice(data.data, data.start + mid3, data.length - mid3))); + rs.byteVecPush(out, opaque(new rs.ByteSlice(data.data, data.start + mid3, data.length - mid3))); } else if (_4 === 4) { - const mid: number = rt.usizeDiv(data.length, 3); + const mid: number = rs.usizeDiv(data.length, 3); if (mid > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } let pair_0Data: Uint8Array = data.data; let pair_0Start: number = data.start; @@ -147,9 +147,9 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { let pair_1Data: Uint8Array = data.data; let pair_1Start: number = data.start + mid; let pair_1Len: number = data.length - mid; - const _73: rt.usize = rt.usizeRem(data.length, 3); - let iterStart2: rt.usize = 0; - const iterEnd2: rt.usize = _73; + const _73: rs.usize = rs.usizeRem(data.length, 3); + let iterStart2: rs.usize = 0; + const iterEnd2: rs.usize = _73; while (iterStart2++ < iterEnd2) { const _80Data: Uint8Array = pair_1Data; const _80Start: number = pair_1Start; @@ -164,58 +164,58 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { pair_1Start = _81Start; pair_1Len = _81Len; } - rt.byteVecPush(out, pair_0Len & 0xff); + rs.byteVecPush(out, pair_0Len & 0xff); if (!(pair_1Len === 0)) { const _224Len: number = pair_1Len; if (0 >= _224Len) { - rt.panic("index out of bounds: the len is " + _224Len + " but the index is " + 0); + rs.panic("index out of bounds: the len is " + _224Len + " but the index is " + 0); } - rt.byteVecPush(out, pair_1Data[pair_1Start]); + rs.byteVecPush(out, pair_1Data[pair_1Start]); } - rt.byteVecExtendFromSlice(out, new rt.ByteSlice(pair_0Data, pair_0Start, pair_0Len)); - const mid2: number = rt.usizeDiv(data.length, 2); + rs.byteVecExtendFromSlice(out, new rs.ByteSlice(pair_0Data, pair_0Start, pair_0Len)); + const mid2: number = rs.usizeDiv(data.length, 2); if (mid2 > data.length) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - let a3: rt.ByteSlice = new rt.ByteSlice(data.data, data.start, mid2); - let b4: rt.ByteSlice = new rt.ByteSlice(data.data, data.start + mid2, data.length - mid2); - const _101: rt.usize = rt.usizeRem(data.length, 3); - let iterStart3: rt.usize = 0; - const iterEnd3: rt.usize = _101; + let a3: rs.ByteSlice = new rs.ByteSlice(data.data, data.start, mid2); + let b4: rs.ByteSlice = new rs.ByteSlice(data.data, data.start + mid2, data.length - mid2); + const _101: rs.usize = rs.usizeRem(data.length, 3); + let iterStart3: rs.usize = 0; + const iterEnd3: rs.usize = _101; while (iterStart3++ < iterEnd3) { - const _111: rt.ByteSlice = b4; - const _112: rt.ByteSlice = a3; + const _111: rs.ByteSlice = b4; + const _112: rs.ByteSlice = a3; a3 = _111; b4 = _112; - rt.byteVecPush(out, opaque(a3)); + rs.byteVecPush(out, opaque(a3)); } - rt.byteVecPush(out, a3.length & 0xff); - rt.byteVecPush(out, opaque(b4)); + rs.byteVecPush(out, a3.length & 0xff); + rs.byteVecPush(out, opaque(b4)); } else if (_4 === 5) { - let rest3: rt.ByteSlice = data; + let rest3: rs.ByteSlice = data; while (true) { - const _125: rt.ByteSlice = rest3; - const _124: [rt.u8, rt.u8, rt.ByteSlice] | undefined = two(_125.data, _125.start, _125.length); + const _125: rs.ByteSlice = rest3; + const _124: [rs.u8, rs.u8, rs.ByteSlice] | undefined = two(_125.data, _125.start, _125.length); if (_124 !== undefined) { - rt.byteVecPush(out, _124[0] ^ _124[1]); + rs.byteVecPush(out, _124[0] ^ _124[1]); rest3 = _124[2]; } else { break; } } - rt.byteVecPush(out, rest3.length & 0xff); + rs.byteVecPush(out, rest3.length & 0xff); } else if (_4 === 6) { - const split: [rt.ByteSlice, rt.ByteSlice] | undefined = rt.byteSliceSplitAtChecked(data, 4); + const split: [rs.ByteSlice, rs.ByteSlice] | undefined = rs.byteSliceSplitAtChecked(data, 4); b5: { if (split !== undefined) { - const _227: rt.ByteSlice = split[0]; + const _227: rs.ByteSlice = split[0]; if ((_227.data[_227.start] & 1) === 0) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.u32WrappingAdd(((split[0].data[split[0].start] << 24) | (split[0].data[split[0].start + 1] << 16) | (split[0].data[split[0].start + 2] << 8) | split[0].data[split[0].start + 3]) >>> 0, 3)))); - rt.byteVecPush(out, split[1].length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.u32WrappingAdd(((split[0].data[split[0].start] << 24) | (split[0].data[split[0].start + 1] << 16) | (split[0].data[split[0].start + 2] << 8) | split[0].data[split[0].start + 3]) >>> 0, 3)))); + rs.byteVecPush(out, split[1].length & 0xff); break b5; } } - rt.byteVecPush(out, option_mapOr$11e0ggl(split, 255, (_2: [rt.ByteSlice, rt.ByteSlice]): rt.u8 => { + rs.byteVecPush(out, option_mapOr$17znd5c(split, 255, (_2: [rs.ByteSlice, rs.ByteSlice]): rs.u8 => { return _2[0].data[_2[0].start + 3] ^ (_2[1].length & 0xff); })); } @@ -225,8 +225,8 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { const part3: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_0Len; const part6: number = out$tuple2_ref_slice_u8_ref_slice_u8.p_1Len; if (err2 === undefined) { - rt.byteVecPush(out, opaque(new rt.ByteSlice(part, part2, part3))); - rt.byteVecPush(out, part6 & 0xff); + rs.byteVecPush(out, opaque(new rs.ByteSlice(part, part2, part3))); + rs.byteVecPush(out, part6 & 0xff); } else { const e: Short.Short = err2 as Short.Short; if (e.tag === "Empty") { @@ -234,39 +234,39 @@ export function splits(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { _169 = e._0 & 0xff; } - rt.byteVecPush(out, _169); + rs.byteVecPush(out, _169); } } else { - const first2: rt.u8 = code(out, 7); + const first2: rs.u8 = code(out, 7); if (data.length !== 0) { - rt.byteVecPush(out, data.data[data.start]); - rt.byteVecPush(out, (data.length - 1) & 0xff); + rs.byteVecPush(out, data.data[data.start]); + rs.byteVecPush(out, (data.length - 1) & 0xff); } else { - rt.byteVecPush(out, first2); + rs.byteVecPush(out, first2); } - if (rt.usizeRem(data.length, 2) === 0) { + if (rs.usizeRem(data.length, 2) === 0) { err = { tag: "Empty" } as Short.Short; } else { err = { tag: "Need", _0: data.length } as Short.Short; } const _1902: Short.Short = err; if (data.length !== 0) { - rt.byteVecPush(out, data.data[data.start]); + rs.byteVecPush(out, data.data[data.start]); } else if (_1902.tag === "Empty") { - rt.byteVecPush(out, 224); + rs.byteVecPush(out, 224); } else { - rt.byteVecPush(out, 225 ^ (_1902._0 & 0xff)); + rs.byteVecPush(out, 225 ^ (_1902._0 & 0xff)); } - const _200: rt.Result = second(data.data, data.start, data.length, rt.byteSliceFirst(data)); + const _200: rs.Result = second(data.data, data.start, data.length, rs.byteSliceFirst(data)); if (_200.ok) { - rt.byteVecPush(out, _200.value); + rs.byteVecPush(out, _200.value); } else if (_200.error === undefined) { - rt.byteVecPush(out, 170); + rs.byteVecPush(out, 170); } else { - rt.byteVecPush(out, _200.error ^ 85); + rs.byteVecPush(out, _200.error ^ 85); } if (2 <= data.length) { - rt.byteVecPush(out, data.data[data.start + 1] ^ ((data.length - 2) & 0xff)); + rs.byteVecPush(out, data.data[data.start + 1] ^ ((data.length - 2) & 0xff)); } } } diff --git a/ts/fixtures/lang/statics/expected/harness.ts b/ts/fixtures/lang/statics/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/statics/expected/harness.ts +++ b/ts/fixtures/lang/statics/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/statics/expected/lib.ts b/ts/fixtures/lang/statics/expected/lib.ts index 851960e7d..2bd0740d5 100644 --- a/ts/fixtures/lang/statics/expected/lib.ts +++ b/ts/fixtures/lang/statics/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { statics, cells, onces, lazies, writes } from "./statics.ts"; import type * as Dropped from "./statics.Dropped.ts"; import * as Lock from "./statics.Lock.ts"; @@ -9,23 +9,23 @@ export function copy$array_u8(v: Uint8Array): Uint8Array { return v.slice(); } -export function drop$cell_LazyCell_statics_Dropped_statics_cell_closure0(value: rt.LazyCell): void { - rt.lazyDrop(value, rt.drop); +export function drop$cell_LazyCell_statics_Dropped_statics_cell_closure0(value: rs.LazyCell): void { + rs.lazyDrop(value, rs.drop); } -export function drop$statics_Lock_Rc_unit(_1: Lock.Lock>): void { +export function drop$statics_Lock_Rc_unit(_1: Lock.Lock>): void { Lock.drop$ops_Drop_Rc_unit(_1); } -export function drop$statics_Lock_tuple2_u8_Rc_unit(_1: Lock.Lock<[rt.u8, rt.Arc]>): void { +export function drop$statics_Lock_tuple2_u8_Rc_unit(_1: Lock.Lock<[rs.u8, rs.Arc]>): void { Lock.drop$ops_Drop_tuple2_u8_Rc_unit(_1); } -export function drop$sync_LazyLock_statics_Dropped_statics_lock_closure0(value: rt.LazyLock): void { - rt.lazyDrop(value, rt.drop); +export function drop$sync_LazyLock_statics_Dropped_statics_lock_closure0(value: rs.LazyLock): void { + rs.lazyDrop(value, rs.drop); } -export function drop$tuple2_u8_Rc_unit(_1: [rt.u8, rt.Arc]): void { +export function drop$tuple2_u8_Rc_unit(_1: [rs.u8, rs.Arc]): void { _1[1][Symbol.dispose](); } @@ -33,18 +33,18 @@ export function drop$tuple2_u8_Rc_unit(_1: [rt.u8, rt.Arc]): void { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["statics::statics", (_22: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["statics::statics", (_22: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): undefined => { statics(data, out); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::cells", (_23: rt.u8, data2: rt.ByteSlice, out2: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["statics::cells", (_23: rs.u8, data2: rs.ByteSlice, out2: rs.ByteVec): undefined => { cells(data2, out2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::onces", (_24: rt.u8, data3: rt.ByteSlice, out3: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["statics::onces", (_24: rs.u8, data3: rs.ByteSlice, out3: rs.ByteVec): undefined => { onces(data3, out3); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::lazies", (_25: rt.u8, data4: rt.ByteSlice, out4: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["statics::lazies", (_25: rs.u8, data4: rs.ByteSlice, out4: rs.ByteVec): undefined => { lazies(data4, out4); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["statics::writes", (_26: rt.u8, data5: rt.ByteSlice, out5: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["statics::writes", (_26: rs.u8, data5: rs.ByteSlice, out5: rs.ByteVec): undefined => { writes(data5, out5); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/statics/expected/statics.Collector.ts b/ts/fixtures/lang/statics/expected/statics.Collector.ts index 56c44367c..43c9b4075 100644 --- a/ts/fixtures/lang/statics/expected/statics.Collector.ts +++ b/ts/fixtures/lang/statics/expected/statics.Collector.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** What crossbeam-epoch's collector holds: a struct JS keeps as an object. */ export class Collector { - global: rt.Arc; + global: rs.Arc; - constructor(global: rt.Arc) { + constructor(global: rs.Arc) { this.global = global; } diff --git a/ts/fixtures/lang/statics/expected/statics.Counter.ts b/ts/fixtures/lang/statics/expected/statics.Counter.ts index fe8a7c9e4..9660c838e 100644 --- a/ts/fixtures/lang/statics/expected/statics.Counter.ts +++ b/ts/fixtures/lang/statics/expected/statics.Counter.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A static's counter beside what it never changes, as foldhash's seed storage keeps its state. */ export interface Counter { name: string; - hits: rt.Atomic; - limit: rt.u32; + hits: rs.Atomic; + limit: rs.u32; steps: Uint8Array; - state: [rt.u8, rt.char] | undefined; + state: [rs.u8, rs.char] | undefined; } //# sourceMappingURL=statics.Counter.ts.map diff --git a/ts/fixtures/lang/statics/expected/statics.Dropped.ts b/ts/fixtures/lang/statics/expected/statics.Dropped.ts index 4da0ef4f1..add877131 100644 --- a/ts/fixtures/lang/statics/expected/statics.Dropped.ts +++ b/ts/fixtures/lang/statics/expected/statics.Dropped.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { DROPS } from "./statics.ts"; -export function fmt$fmt_Debug(self: Dropped, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Dropped, f: rs.Formatter): rs.Result { const _3: string = "Dropped"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } /** Logs its id when it drops. */ export class Dropped { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } @@ -23,8 +23,8 @@ export class Dropped { } export function drop$ops_Drop(self: Dropped): void { - rt.localKeyWithBorrowMut(DROPS, (drops: rt.ByteVec): undefined => { - rt.byteVecPush(drops, self._0); + rs.localKeyWithBorrowMut(DROPS, (drops: rs.ByteVec): undefined => { + rs.byteVecPush(drops, self._0); }); } diff --git a/ts/fixtures/lang/statics/expected/statics.Lock.ts b/ts/fixtures/lang/statics/expected/statics.Lock.ts index f4d6c7439..2c379ef67 100644 --- a/ts/fixtures/lang/statics/expected/statics.Lock.ts +++ b/ts/fixtures/lang/statics/expected/statics.Lock.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$tuple2_u8_Rc_unit } from "./lib.ts"; import type * as Collector from "./statics.Collector.ts"; @@ -10,59 +10,59 @@ import type * as Collector from "./statics.Collector.ts"; * says it ran, and dropped in place if it did. */ export class Lock { - once: rt.Once; - value: rt.Cell; + once: rs.Once; + value: rs.Cell; - constructor(once: rt.Once, value: rt.Cell) { + constructor(once: rs.Once, value: rs.Cell) { this.once = once; this.value = value; } } -export function new$Rc_unit(): Lock> { - return new Lock(new rt.OnceLock(undefined), new rt.Cell((undefined as unknown) as rt.Arc)); +export function new$Rc_unit(): Lock> { + return new Lock(new rs.OnceLock(undefined), new rs.Cell((undefined as unknown) as rs.Arc)); } -export function new$tuple2_u8_Rc_unit(): Lock<[rt.u8, rt.Arc]> { - return new Lock(new rt.OnceLock(undefined), new rt.Cell(([undefined, undefined] as unknown) as [rt.u8, rt.Arc])); +export function new$tuple2_u8_Rc_unit(): Lock<[rs.u8, rs.Arc]> { + return new Lock(new rs.OnceLock(undefined), new rs.Cell(([undefined, undefined] as unknown) as [rs.u8, rs.Arc])); } -export function getOrInit$Rc_unit_statics_onces_closure6(self: Lock>, f: () => rt.Arc): rt.Arc { +export function getOrInit$Rc_unit_statics_onces_closure6(self: Lock>, f: () => rs.Arc): rs.Arc { let _14: boolean = false; _14 = true; if (!(self.once.v === true)) { - const slot: rt.Place> = self.value; + const slot: rs.Place> = self.value; _14 = false; const captured = f; - rt.onceCall(self.once, rt.closure((): undefined => { + rs.onceCall(self.once, rs.closure((): undefined => { slot.v = captured(); }, (): void => { - rt.drop(captured); - }), rt.drop); + rs.drop(captured); + }), rs.drop); } - const _11: rt.Place> = self.value; + const _11: rs.Place> = self.value; if (_14) { - rt.drop(f); + rs.drop(f); } return _11.v; } -export function getOrInit$Rc_unit_statics_onces_closure7(self: Lock>, f: () => rt.Arc): rt.Arc { +export function getOrInit$Rc_unit_statics_onces_closure7(self: Lock>, f: () => rs.Arc): rs.Arc { let _14: boolean = false; _14 = true; if (!(self.once.v === true)) { - const slot: rt.Place> = self.value; + const slot: rs.Place> = self.value; _14 = false; const captured = f; - rt.onceCall(self.once, rt.closure((): undefined => { + rs.onceCall(self.once, rs.closure((): undefined => { slot.v = captured(); }, (): void => { - rt.drop(captured); - }), rt.drop); + rs.drop(captured); + }), rs.drop); } - const _11: rt.Place> = self.value; + const _11: rs.Place> = self.value; if (_14) { - rt.drop(f); + rs.drop(f); } return _11.v; } @@ -71,62 +71,62 @@ export function getOrInit$statics_Collector_statics_onces_closure5(self: Lock { - rt.ptrWrite(slot, captured()); + rs.onceCall(self.once, (): undefined => { + rs.ptrWrite(slot, captured()); }); } return self.value.v; } -export function getOrInit$tuple2_u8_Rc_unit_statics_onces_closure8(self: Lock<[rt.u8, rt.Arc]>, f: () => [rt.u8, rt.Arc]): [rt.u8, rt.Arc] { +export function getOrInit$tuple2_u8_Rc_unit_statics_onces_closure8(self: Lock<[rs.u8, rs.Arc]>, f: () => [rs.u8, rs.Arc]): [rs.u8, rs.Arc] { let _14: boolean = false; _14 = true; if (!(self.once.v === true)) { - const slot: [rt.u8, rt.Arc] = self.value.v; + const slot: [rs.u8, rs.Arc] = self.value.v; _14 = false; const captured = f; - rt.onceCall(self.once, rt.closure((): undefined => { - rt.ptrWrite(slot, captured()); + rs.onceCall(self.once, rs.closure((): undefined => { + rs.ptrWrite(slot, captured()); }, (): void => { - rt.drop(captured); - }), rt.drop); + rs.drop(captured); + }), rs.drop); } - const _11: [rt.u8, rt.Arc] = self.value.v; + const _11: [rs.u8, rs.Arc] = self.value.v; if (_14) { - rt.drop(f); + rs.drop(f); return _11; } return _11; } -export function getOrInit$tuple2_u8_Rc_unit_statics_onces_closure9(self: Lock<[rt.u8, rt.Arc]>, f: () => [rt.u8, rt.Arc]): [rt.u8, rt.Arc] { +export function getOrInit$tuple2_u8_Rc_unit_statics_onces_closure9(self: Lock<[rs.u8, rs.Arc]>, f: () => [rs.u8, rs.Arc]): [rs.u8, rs.Arc] { let _14: boolean = false; _14 = true; if (!(self.once.v === true)) { - const slot: [rt.u8, rt.Arc] = self.value.v; + const slot: [rs.u8, rs.Arc] = self.value.v; _14 = false; const captured = f; - rt.onceCall(self.once, rt.closure((): undefined => { - rt.ptrWrite(slot, captured()); + rs.onceCall(self.once, rs.closure((): undefined => { + rs.ptrWrite(slot, captured()); }, (): void => { - rt.drop(captured); - }), rt.drop); + rs.drop(captured); + }), rs.drop); } - const _11: [rt.u8, rt.Arc] = self.value.v; + const _11: [rs.u8, rs.Arc] = self.value.v; if (_14) { - rt.drop(f); + rs.drop(f); return _11; } return _11; } -export function drop$ops_Drop_Rc_unit(self: Lock>): void { +export function drop$ops_Drop_Rc_unit(self: Lock>): void { if (self.once.v === true) { self.value.v[Symbol.dispose](); } } -export function drop$ops_Drop_tuple2_u8_Rc_unit(self: Lock<[rt.u8, rt.Arc]>): void { +export function drop$ops_Drop_tuple2_u8_Rc_unit(self: Lock<[rs.u8, rs.Arc]>): void { if (self.once.v === true) { drop$tuple2_u8_Rc_unit(self.value.v); } diff --git a/ts/fixtures/lang/statics/expected/statics.Node.ts b/ts/fixtures/lang/statics/expected/statics.Node.ts index 88a1ebfd5..6d56d5b5d 100644 --- a/ts/fixtures/lang/statics/expected/statics.Node.ts +++ b/ts/fixtures/lang/statics/expected/statics.Node.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A boxed node a pointer static holds. */ export interface Node { - value: rt.u8; + value: rs.u8; } //# sourceMappingURL=statics.Node.ts.map diff --git a/ts/fixtures/lang/statics/expected/statics.Raw.ts b/ts/fixtures/lang/statics/expected/statics.Raw.ts index f135ea2c0..9c3921499 100644 --- a/ts/fixtures/lang/statics/expected/statics.Raw.ts +++ b/ts/fixtures/lang/statics/expected/statics.Raw.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A lock's state as lock_api's `RawMutex::INIT` holds it: every use a lock of its own. */ export interface Raw { - locked: rt.Atomic; - count: rt.Atomic; + locked: rs.Atomic; + count: rs.Atomic; } //# sourceMappingURL=statics.Raw.ts.map diff --git a/ts/fixtures/lang/statics/expected/statics.ts b/ts/fixtures/lang/statics/expected/statics.ts index c7ad85a08..7af8a195b 100644 --- a/ts/fixtures/lang/statics/expected/statics.ts +++ b/ts/fixtures/lang/statics/expected/statics.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8, drop$cell_LazyCell_statics_Dropped_statics_cell_closure0, drop$statics_Lock_Rc_unit, drop$statics_Lock_tuple2_u8_Rc_unit, drop$sync_LazyLock_statics_Dropped_statics_lock_closure0 } from "./lib.ts"; import { LATER, read } from "./statics/elsewhere.ts"; import * as Collector from "./statics.Collector.ts"; @@ -9,346 +9,346 @@ import * as Dropped from "./statics.Dropped.ts"; import * as Lock from "./statics.Lock.ts"; import type * as Node from "./statics.Node.ts"; import type * as Raw from "./statics.Raw.ts"; -import { withBorrow$1roy6g4, take$1357qwq, take$122f15k } from "./std/thread/local.ts"; +import { withBorrow$03hv9ge, take$1ni7uux, take$1snv7rd } from "./std/thread/local.ts"; -export const COUNT: rt.Atomic = /* @__PURE__ */ new rt.Atomic({ hi: 0xffffffff, lo: 0xfffffffd } as rt.u64); +export const COUNT: rs.Atomic = /* @__PURE__ */ new rs.Atomic({ hi: 0xffffffff, lo: 0xfffffffd } as rs.u64); -export const SIGNED: rt.Atomic = /* @__PURE__ */ new rt.Atomic(-128); +export const SIGNED: rs.Atomic = /* @__PURE__ */ new rs.Atomic(-128); -export const FLAG: rt.Atomic = /* @__PURE__ */ new rt.Atomic(true); +export const FLAG: rs.Atomic = /* @__PURE__ */ new rs.Atomic(true); -export const WIDE: rt.Atomic = /* @__PURE__ */ new rt.Atomic({ hi: -0x80000000, lo: 0x1 } as rt.i64); +export const WIDE: rs.Atomic = /* @__PURE__ */ new rs.Atomic({ hi: -0x80000000, lo: 0x1 } as rs.i64); -export const SIZE: rt.Atomic = /* @__PURE__ */ new rt.Atomic(7); +export const SIZE: rs.Atomic = /* @__PURE__ */ new rs.Atomic(7); -export const TABLE: rt.ByteSlice = /* @__PURE__ */ rt.byteSliceFrom(Uint8Array.of(9, 8, 7, 6)); +export const TABLE: rs.ByteSlice = /* @__PURE__ */ rs.byteSliceFrom(Uint8Array.of(9, 8, 7, 6)); /** * Each byte an operation on the statics; each puts what it read. First, what each holds, * which only the value it starts with can be. */ -export function statics(data: rt.ByteSlice, out: rt.ByteVec): void { - let _68!: rt.u8; - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicLoad(COUNT, 0)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicLoad(WIDE, 0)).reverse()), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicLoad(SIGNED, 0) & 0xff, rt.atomicLoad(FLAG, 0) ? 1 : 0, rt.atomicLoad(SIZE, 0) & 0xff)), undefined, true); - rt.byteVecPush(out, next(false)); - for (const op of rt.byteSliceView(data)) { - const n: rt.u8 = rt.u8Div(op, 6); - const _38: rt.u8 = rt.u8Rem(op, 6); +export function statics(data: rs.ByteSlice, out: rs.ByteVec): void { + let _68!: rs.u8; + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(rs.atomicLoad(COUNT, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.i64ToBeBytes(rs.atomicLoad(WIDE, 0)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.atomicLoad(SIGNED, 0) & 0xff, rs.atomicLoad(FLAG, 0) ? 1 : 0, rs.atomicLoad(SIZE, 0) & 0xff)), undefined, true); + rs.byteVecPush(out, next(false)); + for (const op of rs.byteSliceView(data)) { + const n: rs.u8 = rs.u8Div(op, 6); + const _38: rs.u8 = rs.u8Rem(op, 6); if (_38 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u64ToBeBytes(rt.atomicFetch(COUNT, rt.u64WrappingAdd, n as rt.u64, 3)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u64ToBeBytes(rs.atomicFetch(COUNT, rs.u64WrappingAdd, n as rs.u64, 3)).reverse()), undefined, true); continue; } if (_38 === 1) { - rt.byteVecPush(out, rt.atomicFetch(SIGNED, rt.i8WrappingSub, (n << 24) >> 24, 4) & 0xff); + rs.byteVecPush(out, rs.atomicFetch(SIGNED, rs.i8WrappingSub, (n << 24) >> 24, 4) & 0xff); continue; } if (_38 === 2) { - rt.byteVecPush(out, rt.atomicFetch(FLAG, (old, value) => old !== value, rt.u8Rem(n, 2) === 0, 0) ? 1 : 0); + rs.byteVecPush(out, rs.atomicFetch(FLAG, (old, value) => old !== value, rs.u8Rem(n, 2) === 0, 0) ? 1 : 0); continue; } if (_38 === 3) { - rt.iterExtendBytes(out, rt.iterSlice(rt.i64ToBeBytes(rt.atomicSwap(WIDE, rt.i64Neg(n as rt.i64), 2)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.i64ToBeBytes(rs.atomicSwap(WIDE, rs.i64Neg(n as rs.i64), 2)).reverse()), undefined, true); continue; } if (_38 === 4) { - const seen: rt.usize = rt.atomicLoad(SIZE, 0); - const _69: rt.Result = rt.atomicCompareExchange(SIZE, seen, rt.usizeWrappingMul(seen, n as rt.usize), 4, 0); + const seen: rs.usize = rs.atomicLoad(SIZE, 0); + const _69: rs.Result = rs.atomicCompareExchange(SIZE, seen, rs.usizeWrappingMul(seen, n as rs.usize), 4, 0); if (_69.ok) { _68 = _69.value & 0xff; } else { _68 = 253; } - rt.byteVecPush(out, _68); + rs.byteVecPush(out, _68); continue; } if (_38 === 5) { - if (rt.u8Rem(n, 2) === 0) { - rt.byteVecPush(out, next(false)); + if (rs.u8Rem(n, 2) === 0) { + rs.byteVecPush(out, next(false)); continue; } } - const _83: rt.ByteSlice = table(); - const _84: rt.usize = rt.usizeRem(n as rt.usize, 4); + const _83: rs.ByteSlice = table(); + const _84: rs.usize = rs.usizeRem(n as rs.usize, 4); if (!(_84 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _84); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _84); } - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_83.data[_83.start + _84], rt.byteSliceSame(table(), table()) ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_83.data[_83.start + _84], rs.byteSliceSame(table(), table()) ? 1 : 0)), undefined, true); } - rt.atomicStore(COUNT, { hi: 0xffffffff, lo: 0xfffffffd } as rt.u64, 0); - rt.atomicStore(SIGNED, -128, 0); - rt.atomicStore(FLAG, true, 0); - rt.atomicStore(WIDE, { hi: -0x80000000, lo: 0x1 } as rt.i64, 0); - rt.atomicStore(SIZE, 7, 0); + rs.atomicStore(COUNT, { hi: 0xffffffff, lo: 0xfffffffd } as rs.u64, 0); + rs.atomicStore(SIGNED, -128, 0); + rs.atomicStore(FLAG, true, 0); + rs.atomicStore(WIDE, { hi: -0x80000000, lo: 0x1 } as rs.i64, 0); + rs.atomicStore(SIZE, 7, 0); next(true); } -export function table(): rt.ByteSlice { +export function table(): rs.ByteSlice { return TABLE; } /** The next id from a static in a function, as kio's `waiter` takes one; starts over if `reset`. */ -export function next(reset: boolean): rt.u8 { +export function next(reset: boolean): rs.u8 { if (!reset) { - return rt.u64Low(rt.atomicFetch(NEXT$next, rt.u64WrappingAdd, 1, 0)) & 0xff; + return rs.u64Low(rs.atomicFetch(NEXT$next, rs.u64WrappingAdd, 1, 0)) & 0xff; } - rt.atomicStore(NEXT$next, 1, 0); + rs.atomicStore(NEXT$next, 1, 0); return 0; } -export const NEXT$next: rt.Atomic = /* @__PURE__ */ new rt.Atomic(1); +export const NEXT$next: rs.Atomic = /* @__PURE__ */ new rs.Atomic(1); -export const COUNTER: Counter.Counter = { name: "hits", hits: new rt.Atomic(4294967294), limit: 3, steps: Uint8Array.of(1, 2, 4), state: [9, 122] }; +export const COUNTER: Counter.Counter = { name: "hits", hits: new rs.Atomic(4294967294), limit: 3, steps: Uint8Array.of(1, 2, 4), state: [9, 122] }; -export const SHARED: rt.LazyCell> = /* @__PURE__ */ new rt.LazyCell((): rt.Atomic => { +export const SHARED: rs.LazyCell> = /* @__PURE__ */ new rs.LazyCell((): rs.Atomic => { return LATER; }); -export const SLOT: rt.Atomic = /* @__PURE__ */ new rt.Atomic(rt.NULL); +export const SLOT: rs.Atomic = /* @__PURE__ */ new rs.Atomic(rs.NULL); -export const ONCE: rt.OnceLock<[rt.u8, rt.u32]> = /* @__PURE__ */ new rt.OnceLock(undefined); +export const ONCE: rs.OnceLock<[rs.u8, rs.u32]> = /* @__PURE__ */ new rs.OnceLock(undefined); -export const MADE: rt.Atomic = /* @__PURE__ */ new rt.Atomic(0); +export const MADE: rs.Atomic = /* @__PURE__ */ new rs.Atomic(0); -export const FIRST: rt.LazyLock = /* @__PURE__ */ new rt.LazyLock(first); +export const FIRST: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(first); -export const SECOND: rt.LazyLock<[rt.u8, rt.ByteVec]> = /* @__PURE__ */ new rt.LazyLock((): [rt.u8, rt.ByteVec] => { - const first: rt.ByteVec = rt.byteVecFrom(rt.byteVecView(FIRST.force())); - return [rt.atomicFetch(MADE, rt.u8WrappingAdd, 1, 0), first] as [rt.u8, rt.ByteVec]; +export const SECOND: rs.LazyLock<[rs.u8, rs.ByteVec]> = /* @__PURE__ */ new rs.LazyLock((): [rs.u8, rs.ByteVec] => { + const first: rs.ByteVec = rs.byteVecFrom(rs.byteVecView(FIRST.force())); + return [rs.atomicFetch(MADE, rs.u8WrappingAdd, 1, 0), first] as [rs.u8, rs.ByteVec]; }); -export function first(): rt.ByteVec { - return rt.byteVecFrom(Uint8Array.of(rt.atomicFetch(MADE, rt.u8WrappingAdd, 1, 0), 7, 8)); +export function first(): rs.ByteVec { + return rs.byteVecFrom(Uint8Array.of(rs.atomicFetch(MADE, rs.u8WrappingAdd, 1, 0), 7, 8)); } -export const FORCED: rt.Atomic = /* @__PURE__ */ new rt.Atomic(0); +export const FORCED: rs.Atomic = /* @__PURE__ */ new rs.Atomic(0); /** Each byte an operation on statics and constants read from memory; each puts what it read. */ -export function cells(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.stringAsBytes(COUNTER.name))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(copy$array_u8(COUNTER.steps)), undefined, true); +export function cells(data: rs.ByteSlice, out: rs.ByteVec): void { + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.stringAsBytes(COUNTER.name))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(copy$array_u8(COUNTER.steps)), undefined, true); const _10: Counter.Counter = COUNTER; if (_10.state === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_10.state[0], _10.state[1] & 0xff)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_10.state[0], _10.state[1] & 0xff)), undefined, true); } - const a: Raw.Raw = { locked: new rt.Atomic(false), count: new rt.Atomic(200) }; - const b: Raw.Raw = { locked: new rt.Atomic(false), count: new rt.Atomic(200) }; - const _22: [rt.u8, rt.ByteVec] = SECOND.force(); - const _19: Raw.Raw = { locked: new rt.Atomic(false), count: new rt.Atomic(200) }; - const _26: rt.u8 = _22[0]; - const _29: rt.ByteVec = FIRST.force(); - const _27: rt.u8 = _29.data[rt.idx(_29, 0)]; + const a: Raw.Raw = { locked: new rs.Atomic(false), count: new rs.Atomic(200) }; + const b: Raw.Raw = { locked: new rs.Atomic(false), count: new rs.Atomic(200) }; + const _22: [rs.u8, rs.ByteVec] = SECOND.force(); + const _19: Raw.Raw = { locked: new rs.Atomic(false), count: new rs.Atomic(200) }; + const _26: rs.u8 = _22[0]; + const _29: rs.ByteVec = FIRST.force(); + const _27: rs.u8 = _29.data[rs.idx(_29, 0)]; const slice = _22[1]; - const _31: rt.u8 = slice.data[rt.idx(slice, 0)]; - const _35: rt.ByteVec = FIRST.force(); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_26, _27, _31, _35.data[rt.idx(_35, 1)])), undefined, true); - const tally: rt.Cell = new rt.Cell(250); - const _40: rt.u8 = rt.u8WrappingAdd(tally.v, 10); - rt.cellSet(tally, _40); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(tally.v, new rt.Cell(250).v, new rt.Cell([1, 2] as [rt.u8, rt.u8]).v[1])), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(new rt.Cell(new rt.Cell(3)).v.v, new rt.Cell(new rt.Cell(4)).v.v)), undefined, true); - for (const op of rt.byteSliceView(data)) { - const n2: rt.u8 = rt.u8Div(op, 8); - const _68: rt.u8 = rt.u8Rem(op, 8); + const _31: rs.u8 = slice.data[rs.idx(slice, 0)]; + const _35: rs.ByteVec = FIRST.force(); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_26, _27, _31, _35.data[rs.idx(_35, 1)])), undefined, true); + const tally: rs.Cell = new rs.Cell(250); + const _40: rs.u8 = rs.u8WrappingAdd(tally.v, 10); + rs.cellSet(tally, _40); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(tally.v, new rs.Cell(250).v, new rs.Cell([1, 2] as [rs.u8, rs.u8]).v[1])), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(new rs.Cell(new rs.Cell(3)).v.v, new rs.Cell(new rs.Cell(4)).v.v)), undefined, true); + for (const op of rs.byteSliceView(data)) { + const n2: rs.u8 = rs.u8Div(op, 8); + const _68: rs.u8 = rs.u8Rem(op, 8); if (_68 === 0) { - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicFetch(COUNTER.hits, rt.u32WrappingAdd, rt.u32Rem(n2 as rt.u32, COUNTER.limit), 3)).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicFetch(COUNTER.hits, rs.u32WrappingAdd, rs.u32Rem(n2 as rs.u32, COUNTER.limit), 3)).reverse()), undefined, true); continue; } if (_68 === 1) { - rt.byteVecPush(out, rt.atomicSwap(a.locked, rt.u8Rem(n2, 2) === 0, 2) ? 1 : 0); + rs.byteVecPush(out, rs.atomicSwap(a.locked, rs.u8Rem(n2, 2) === 0, 2) ? 1 : 0); continue; } if (_68 === 2) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(a.count, rt.u8WrappingAdd, n2, 0), rt.atomicLoad(b.count, 0), rt.atomicLoad(_19.count, 0))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.atomicFetch(a.count, rs.u8WrappingAdd, n2, 0), rs.atomicLoad(b.count, 0), rs.atomicLoad(_19.count, 0))), undefined, true); continue; } if (_68 === 3) { - rt.byteVecPush(out, rt.atomicLoad(b.locked, 0) ? 1 : 0); + rs.byteVecPush(out, rs.atomicLoad(b.locked, 0) ? 1 : 0); continue; } if (_68 === 4) { const node: Node.Node = { value: n2 }; - const old: Node.Node = rt.atomicSwap(SLOT, node, 3); - rt.byteVecPush(out, old === rt.NULL ? 1 : 0); - rt.byteVecPush(out, rt.atomicLoad(SLOT, 2).value); - const _116: rt.Result = rt.atomicCompareExchange(SLOT, old, rt.NULL, 3, 2); + const old: Node.Node = rs.atomicSwap(SLOT, node, 3); + rs.byteVecPush(out, old === rs.NULL ? 1 : 0); + rs.byteVecPush(out, rs.atomicLoad(SLOT, 2).value); + const _116: rs.Result = rs.atomicCompareExchange(SLOT, old, rs.NULL, 3, 2); if (_116.ok) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { - rt.byteVecPush(out, _116.error === node ? 1 : 0); + rs.byteVecPush(out, _116.error === node ? 1 : 0); } - const _125: rt.Result = rt.atomicCompareExchange(SLOT, node, rt.NULL, 3, 2); + const _125: rs.Result = rs.atomicCompareExchange(SLOT, node, rs.NULL, 3, 2); if (_125.ok) { - rt.byteVecPush(out, _125.value.value); + rs.byteVecPush(out, _125.value.value); } else { - rt.byteVecPush(out, 252); + rs.byteVecPush(out, 252); } - rt.byteVecPush(out, rt.atomicLoad(SLOT, 0) === rt.NULL ? 1 : 0); + rs.byteVecPush(out, rs.atomicLoad(SLOT, 0) === rs.NULL ? 1 : 0); continue; } if (_68 === 5) { - const _141: [rt.u8, rt.u32] = rt.onceGetOrInit(ONCE, (): [rt.u8, rt.u32] => { - return [3, 9] as [rt.u8, rt.u32]; + const _141: [rs.u8, rs.u32] = rs.onceGetOrInit(ONCE, (): [rs.u8, rs.u32] => { + return [3, 9] as [rs.u8, rs.u32]; }); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_141[0], _141[1] & 0xff, ONCE.v !== undefined ? 1 : 0)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_141[0], _141[1] & 0xff, ONCE.v !== undefined ? 1 : 0)), undefined, true); continue; } if (_68 === 6) { - const x: rt.LazyCell = new rt.LazyCell((): rt.u8 => { - return rt.u8Add(rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0), 10); + const x: rs.LazyCell = new rs.LazyCell((): rs.u8 => { + return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); - const y: rt.LazyCell = new rt.LazyCell((): rt.u8 => { - return rt.u8Add(rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0), 10); + const y: rs.LazyCell = new rs.LazyCell((): rs.u8 => { + return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); - rt.byteVecPush(out, rt.atomicLoad(FORCED, 0)); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(y.force(), x.force(), y.force(), x.force())), undefined, true); - rt.byteVecPush(out, rt.atomicSwap(FORCED, 0, 0)); + rs.byteVecPush(out, rs.atomicLoad(FORCED, 0)); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(y.force(), x.force(), y.force(), x.force())), undefined, true); + rs.byteVecPush(out, rs.atomicSwap(FORCED, 0, 0)); continue; } if (_68 === 7) { - if (rt.u8Rem(n2, 2) === 0) { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.atomicFetch(SHARED.force(), rt.u8WrappingAdd, n2, 0), rt.atomicLoad(LATER, 0), read())), undefined, true); - rt.atomicStore(LATER, 40, 0); + if (rs.u8Rem(n2, 2) === 0) { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.atomicFetch(SHARED.force(), rs.u8WrappingAdd, n2, 0), rs.atomicLoad(LATER, 0), read())), undefined, true); + rs.atomicStore(LATER, 40, 0); continue; } } - const item = (undefined as unknown) as rt.u16; - const slots: rt.u16[] = Array.from({ length: 3 }, (): rt.u16 => { + const item = (undefined as unknown) as rs.u16; + const slots: rs.u16[] = Array.from({ length: 3 }, (): rs.u16 => { return item; }); - const i: rt.usize = rt.usizeRem(n2 as rt.usize, 3); + const i: rs.usize = rs.usizeRem(n2 as rs.usize, 3); if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - const _199: rt.u16 = rt.u16Mul(n2 as rt.u16, 300); - const uninit = rt.place(() => slots[i], (value) => slots[i] = value); + const _199: rs.u16 = rs.u16Mul(n2 as rs.u16, 300); + const uninit = rs.place(() => slots[i], (value) => slots[i] = value); uninit.v = _199; uninit; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - rt.iterExtendBytes(out, rt.iterSlice(rt.u16ToBeBytes(slots[i]).reverse()), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u16ToBeBytes(slots[i]).reverse()), undefined, true); } - rt.atomicStore(COUNTER.hits, 4294967295 - 1, 0); + rs.atomicStore(COUNTER.hits, 4294967295 - 1, 0); } -export const COLLECTOR: rt.LazyCell> = /* @__PURE__ */ new rt.LazyCell((): Lock.Lock => { - return new Lock.Lock(new rt.OnceLock(undefined), new rt.Cell((new Collector.Collector((undefined as unknown) as rt.Arc) as unknown) as Collector.Collector)); +export const COLLECTOR: rs.LazyCell> = /* @__PURE__ */ new rs.LazyCell((): Lock.Lock => { + return new Lock.Lock(new rs.OnceLock(undefined), new rs.Cell((new Collector.Collector((undefined as unknown) as rs.Arc) as unknown) as Collector.Collector)); }); -export const STARTED: rt.Once = /* @__PURE__ */ new rt.OnceLock(undefined); +export const STARTED: rs.Once = /* @__PURE__ */ new rs.OnceLock(undefined); /** * Each byte an operation on a `Once`, its own or a static's; each puts what it saw. One * whose function runs again from within it panics, as wasm32's does, if its byte is odd. */ -export function onces(data: rt.ByteSlice, out: rt.ByteVec): void { - const once: rt.Once = new rt.OnceLock(undefined); - const owned: rt.Arc = new rt.Arc(undefined); - for (const op of rt.byteSliceView(data)) { - const n: rt.u8 = rt.u8Div(op, 6); - const _13: rt.u8 = rt.u8Rem(op, 6); +export function onces(data: rs.ByteSlice, out: rs.ByteVec): void { + const once: rs.Once = new rs.OnceLock(undefined); + const owned: rs.Arc = new rs.Arc(undefined); + for (const op of rs.byteSliceView(data)) { + const n: rs.u8 = rs.u8Div(op, 6); + const _13: rs.u8 = rs.u8Rem(op, 6); if (_13 === 0) { - rt.byteVecPush(out, once.v === true ? 1 : 0); - rt.onceCall(once, (): undefined => { - rt.byteVecPush(out, n); + rs.byteVecPush(out, once.v === true ? 1 : 0); + rs.onceCall(once, (): undefined => { + rs.byteVecPush(out, n); }); - rt.byteVecPush(out, once.v === true ? 1 : 0); + rs.byteVecPush(out, once.v === true ? 1 : 0); } else if (_13 === 1) { - const captured5 = rt.arcClone(owned); - rt.onceCall(once, rt.closure((state: rt.OnceState): undefined => { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.onceIsPoisoned(state) ? 1 : 0, once.v === true ? 1 : 0, n)), undefined, true); + const captured5 = rs.arcClone(owned); + rs.onceCall(once, rs.closure((state: rs.OnceState): undefined => { + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.onceIsPoisoned(state) ? 1 : 0, once.v === true ? 1 : 0, n)), undefined, true); captured5[Symbol.dispose](); }, (): void => { captured5[Symbol.dispose](); - }), rt.drop); - rt.byteVecPush(out, owned.strong & 0xff); + }), rs.drop); + rs.byteVecPush(out, owned.strong & 0xff); } else if (_13 === 2) { - const fresh: rt.Once = new rt.OnceLock(undefined); - rt.onceCall(fresh, (): undefined => { - rt.byteVecPush(out, fresh.v === true ? 1 : 0); - if (rt.u8Rem(n, 2) === 1) { - rt.onceCall(fresh, (): undefined => { - rt.byteVecPush(out, 238); + const fresh: rs.Once = new rs.OnceLock(undefined); + rs.onceCall(fresh, (): undefined => { + rs.byteVecPush(out, fresh.v === true ? 1 : 0); + if (rs.u8Rem(n, 2) === 1) { + rs.onceCall(fresh, (): undefined => { + rs.byteVecPush(out, 238); }); } }); - rt.byteVecPush(out, fresh.v === true ? 1 : 0); + rs.byteVecPush(out, fresh.v === true ? 1 : 0); } else if (_13 === 3) { - if (!(rt.u8Rem(n, 2) === 1)) { - rt.onceCall(STARTED, (): undefined => {}); - rt.byteVecPush(out, STARTED.v === true ? 1 : 0); + if (!(rs.u8Rem(n, 2) === 1)) { + rs.onceCall(STARTED, (): undefined => {}); + rs.byteVecPush(out, STARTED.v === true ? 1 : 0); } else { - const fresh2: rt.Once = new rt.OnceLock(undefined); - rt.onceCall(fresh2, (_26: rt.OnceState): undefined => { - rt.onceCall(fresh2, (_27: rt.OnceState): undefined => { - rt.byteVecPush(out, 238); + const fresh2: rs.Once = new rs.OnceLock(undefined); + rs.onceCall(fresh2, (_26: rs.OnceState): undefined => { + rs.onceCall(fresh2, (_27: rs.OnceState): undefined => { + rs.byteVecPush(out, 238); }); }); } } else if (_13 === 4) { const collector: Collector.Collector = Lock.getOrInit$statics_Collector_statics_onces_closure5(COLLECTOR.force(), (): Collector.Collector => { - return new Collector.Collector(new rt.Arc(16909060)); + return new Collector.Collector(new rs.Arc(16909060)); }); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(collector.global.value).reverse()), undefined, true); - rt.byteVecPush(out, collector.global.strong & 0xff); - } else if (!(rt.u8Rem(n, 3) === 0)) { - if (!(rt.u8Rem(n, 3) === 1)) { + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(collector.global.value).reverse()), undefined, true); + rs.byteVecPush(out, collector.global.strong & 0xff); + } else if (!(rs.u8Rem(n, 3) === 0)) { + if (!(rs.u8Rem(n, 3) === 1)) { drop$statics_Lock_Rc_unit(Lock.new$Rc_unit()); - rt.byteVecPush(out, owned.strong & 0xff); + rs.byteVecPush(out, owned.strong & 0xff); } else { - const slot2: Lock.Lock<[rt.u8, rt.Arc]> = Lock.new$tuple2_u8_Rc_unit(); - const captured3 = rt.arcClone(owned); - rt.byteVecPush(out, Lock.getOrInit$tuple2_u8_Rc_unit_statics_onces_closure8(slot2, rt.closure((): [rt.u8, rt.Arc] => { - return [n, captured3] as [rt.u8, rt.Arc]; + const slot2: Lock.Lock<[rs.u8, rs.Arc]> = Lock.new$tuple2_u8_Rc_unit(); + const captured3 = rs.arcClone(owned); + rs.byteVecPush(out, Lock.getOrInit$tuple2_u8_Rc_unit_statics_onces_closure8(slot2, rs.closure((): [rs.u8, rs.Arc] => { + return [n, captured3] as [rs.u8, rs.Arc]; }, (): void => { captured3[Symbol.dispose](); }))[0]); - const captured4 = rt.arcClone(owned); - rt.byteVecPush(out, Lock.getOrInit$tuple2_u8_Rc_unit_statics_onces_closure9(slot2, rt.closure((): [rt.u8, rt.Arc] => { - return [238, captured4] as [rt.u8, rt.Arc]; + const captured4 = rs.arcClone(owned); + rs.byteVecPush(out, Lock.getOrInit$tuple2_u8_Rc_unit_statics_onces_closure9(slot2, rs.closure((): [rs.u8, rs.Arc] => { + return [238, captured4] as [rs.u8, rs.Arc]; }, (): void => { captured4[Symbol.dispose](); }))[0]); - rt.byteVecPush(out, owned.strong & 0xff); + rs.byteVecPush(out, owned.strong & 0xff); drop$statics_Lock_tuple2_u8_Rc_unit(slot2); - rt.byteVecPush(out, owned.strong & 0xff); + rs.byteVecPush(out, owned.strong & 0xff); } } else { - const slot: Lock.Lock> = Lock.new$Rc_unit(); - const captured = rt.arcClone(owned); - rt.byteVecPush(out, Lock.getOrInit$Rc_unit_statics_onces_closure6(slot, rt.closure((): rt.Arc => { + const slot: Lock.Lock> = Lock.new$Rc_unit(); + const captured = rs.arcClone(owned); + rs.byteVecPush(out, Lock.getOrInit$Rc_unit_statics_onces_closure6(slot, rs.closure((): rs.Arc => { return captured; }, (): void => { captured[Symbol.dispose](); })).strong & 0xff); - const captured2 = rt.arcClone(owned); - rt.byteVecPush(out, Lock.getOrInit$Rc_unit_statics_onces_closure7(slot, rt.closure((): rt.Arc => { + const captured2 = rs.arcClone(owned); + rs.byteVecPush(out, Lock.getOrInit$Rc_unit_statics_onces_closure7(slot, rs.closure((): rs.Arc => { return captured2; }, (): void => { captured2[Symbol.dispose](); })).strong & 0xff); drop$statics_Lock_Rc_unit(slot); - rt.byteVecPush(out, owned.strong & 0xff); + rs.byteVecPush(out, owned.strong & 0xff); } } owned[Symbol.dispose](); } -export const SHOWN: rt.LazyLock = /* @__PURE__ */ new rt.LazyLock(shown); +export const SHOWN: rs.LazyLock = /* @__PURE__ */ new rs.LazyLock(shown); export function shown(): string { - const args2: rt.Fmt[] = [(f: rt.Formatter) => SHOWN.debug(f, "LazyLock", rt.fmtStr)]; - return rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0]), " ", rt.fmtSpec({ align: ">", width: 12 }, args2[0])]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; + return rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 12 }, args2[0])]); } -export const FORCING: rt.LocalKey> | undefined>> = /* @__PURE__ */ new rt.LocalKey(FORCING$init, false); +export const FORCING: rs.LocalKey> | undefined>> = /* @__PURE__ */ new rs.LocalKey(FORCING$init, false); -export function FORCING$init(): rt.RefCell> | undefined> { - return new rt.RefCell(undefined as rt.Arc> | undefined); +export function FORCING$init(): rs.RefCell> | undefined> { + return new rs.RefCell(undefined as rs.Arc> | undefined); } /** @@ -356,130 +356,130 @@ export function FORCING$init(): rt.RefCell> | undefin * `` unpadded before it is forced, and while its function runs, as printing it * forces neither; then its value, padded and pretty as its own `Debug` writes it. */ -export function lazies(data: rt.ByteSlice, out: rt.ByteVec): void { +export function lazies(data: rs.ByteSlice, out: rs.ByteVec): void { let text!: string; - for (const _5 of rt.byteSliceView(data)) { - const _10: rt.u8 = rt.u8Rem(_5, 6); + for (const _5 of rs.byteSliceView(data)) { + const _10: rs.u8 = rs.u8Rem(_5, 6); if (_10 === 0) { - const cell: rt.LazyCell = new rt.LazyCell((): rt.u8 => { - return rt.u8Add(rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0), 10); + const cell: rs.LazyCell = new rs.LazyCell((): rs.u8 => { + return rs.u8Add(rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0), 10); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => cell.debug(f, "LazyCell", rt.u8Debug)]; - const before: string = rt.fmtFormat([args2[0], " ", rt.fmtSpec({ alternate: true }, args2[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args2[0]), "|"]); - const forced: rt.u8 = rt.atomicLoad(FORCED, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; + const before: string = rs.fmtFormat([args2[0], " ", rs.fmtSpec({ alternate: true }, args2[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args2[0]), "|"]); + const forced: rs.u8 = rs.atomicLoad(FORCED, 0); cell.force(); - rt.atomicSwap(FORCED, 0, 0); - const args5: rt.Fmt[] = [(f: rt.Formatter) => cell.debug(f, "LazyCell", rt.u8Debug)]; - const _34: string = rt.fmtFormat([args5[0], " ", rt.fmtSpec({ alternate: true }, args5[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args5[0]), "|"]); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, before), (f: rt.Formatter) => rt.u8Display(forced, f), (f: rt.Formatter) => rt.fmtPad(f, _34)]; - text = rt.fmtFormat([args6[0], args6[1], args6[2]]); + rs.atomicSwap(FORCED, 0, 0); + const args5: rs.Fmt[] = [(f: rs.Formatter) => cell.debug(f, "LazyCell", rs.u8Debug)]; + const _34: string = rs.fmtFormat([args5[0], " ", rs.fmtSpec({ alternate: true }, args5[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args5[0]), "|"]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before), (f: rs.Formatter) => rs.u8Display(forced, f), (f: rs.Formatter) => rs.fmtPad(f, _34)]; + text = rs.fmtFormat([args6[0], args6[1], args6[2]]); } else if (_10 === 1) { - const cell2: rt.LazyCell = new rt.LazyCell((): undefined => {}); - const args8: rt.Fmt[] = [(f: rt.Formatter) => cell2.debug(f, "LazyCell", rt.fmtUnit)]; - const before2: string = rt.fmtFormat([args8[0], " ", rt.fmtSpec({ alternate: true }, args8[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args8[0]), "|"]); + const cell2: rs.LazyCell = new rs.LazyCell((): undefined => {}); + const args8: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; + const before2: string = rs.fmtFormat([args8[0], " ", rs.fmtSpec({ alternate: true }, args8[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args8[0]), "|"]); cell2.force(); - const args11: rt.Fmt[] = [(f: rt.Formatter) => cell2.debug(f, "LazyCell", rt.fmtUnit)]; - const _67: string = rt.fmtFormat([args11[0], " ", rt.fmtSpec({ alternate: true }, args11[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args11[0]), "|"]); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, before2), (f: rt.Formatter) => rt.fmtPad(f, _67)]; - text = rt.fmtFormat([args12[0], args12[1]]); + const args11: rs.Fmt[] = [(f: rs.Formatter) => cell2.debug(f, "LazyCell", rs.fmtUnit)]; + const _67: string = rs.fmtFormat([args11[0], " ", rs.fmtSpec({ alternate: true }, args11[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args11[0]), "|"]); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before2), (f: rs.Formatter) => rs.fmtPad(f, _67)]; + text = rs.fmtFormat([args12[0], args12[1]]); } else if (_10 === 2) { - const lock: rt.LazyLock = new rt.LazyLock((): rt.u8 | undefined => { + const lock: rs.LazyLock = new rs.LazyLock((): rs.u8 | undefined => { return undefined; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => lock.debug(f, "LazyLock", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - const before3: string = rt.fmtFormat([args14[0], " ", rt.fmtSpec({ alternate: true }, args14[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args14[0]), "|"]); + const args14: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const before3: string = rs.fmtFormat([args14[0], " ", rs.fmtSpec({ alternate: true }, args14[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args14[0]), "|"]); lock.force(); - const args17: rt.Fmt[] = [(f: rt.Formatter) => lock.debug(f, "LazyLock", (value: rt.u8 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u8Debug))]; - const _98: string = rt.fmtFormat([args17[0], " ", rt.fmtSpec({ alternate: true }, args17[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args17[0]), "|"]); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, before3), (f: rt.Formatter) => rt.fmtPad(f, _98)]; - text = rt.fmtFormat([args18[0], args18[1]]); + const args17: rs.Fmt[] = [(f: rs.Formatter) => lock.debug(f, "LazyLock", (value: rs.u8 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u8Debug))]; + const _98: string = rs.fmtFormat([args17[0], " ", rs.fmtSpec({ alternate: true }, args17[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args17[0]), "|"]); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before3), (f: rs.Formatter) => rs.fmtPad(f, _98)]; + text = rs.fmtFormat([args18[0], args18[1]]); } else if (_10 === 3) { - const lock2: rt.LazyLock> = new rt.LazyLock((): rt.Vec => { - return rt.vecFrom(["a", "bc"]); + const lock2: rs.LazyLock> = new rs.LazyLock((): rs.Vec => { + return rs.vecFrom(["a", "bc"]); }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => lock2.debug(f, "LazyLock", (value: rt.Vec, f: rt.Formatter) => rt.fmtList(value.items, f, rt.fmtStr))]; - const before4: string = rt.fmtFormat([args20[0], " ", rt.fmtSpec({ alternate: true }, args20[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args20[0]), "|"]); + const args20: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; + const before4: string = rs.fmtFormat([args20[0], " ", rs.fmtSpec({ alternate: true }, args20[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args20[0]), "|"]); lock2.force().items.length; - const args23: rt.Fmt[] = [(f: rt.Formatter) => lock2.debug(f, "LazyLock", (value: rt.Vec, f: rt.Formatter) => rt.fmtList(value.items, f, rt.fmtStr))]; - const _130: string = rt.fmtFormat([args23[0], " ", rt.fmtSpec({ alternate: true }, args23[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args23[0]), "|"]); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, before4), (f: rt.Formatter) => rt.fmtPad(f, _130)]; - text = rt.fmtFormat([args24[0], args24[1]]); + const args23: rs.Fmt[] = [(f: rs.Formatter) => lock2.debug(f, "LazyLock", (value: rs.Vec, f: rs.Formatter) => rs.fmtList(value.items, f, rs.fmtStr))]; + const _130: string = rs.fmtFormat([args23[0], " ", rs.fmtSpec({ alternate: true }, args23[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args23[0]), "|"]); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, before4), (f: rs.Formatter) => rs.fmtPad(f, _130)]; + text = rs.fmtFormat([args24[0], args24[1]]); } else if (_10 === 4) { const _148: string = SHOWN.force(); - const args27: rt.Fmt[] = [(f: rt.Formatter) => SHOWN.debug(f, "LazyLock", rt.fmtStr)]; - const _151: string = rt.fmtFormat([args27[0], " ", rt.fmtSpec({ alternate: true }, args27[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args27[0]), "|"]); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _148), (f: rt.Formatter) => rt.fmtPad(f, _151)]; - text = rt.fmtFormat([args28[0], " ", args28[1]]); + const args27: rs.Fmt[] = [(f: rs.Formatter) => SHOWN.debug(f, "LazyLock", rs.fmtStr)]; + const _151: string = rs.fmtFormat([args27[0], " ", rs.fmtSpec({ alternate: true }, args27[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args27[0]), "|"]); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _148), (f: rs.Formatter) => rs.fmtPad(f, _151)]; + text = rs.fmtFormat([args28[0], " ", args28[1]]); } else { - const cell3: rt.Arc> = new rt.Arc(new rt.LazyCell((): string => { - return withBorrow$1roy6g4(FORCING, (me: rt.Arc> | undefined): string => { - const part = rt.optionUnwrap(me); - const args34: rt.Fmt[] = [(f: rt.Formatter) => part.value.debug(f, "LazyCell", rt.fmtStr)]; - return rt.fmtFormat([args34[0], " ", rt.fmtSpec({ alternate: true }, args34[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args34[0]), "|"]); + const cell3: rs.Arc> = new rs.Arc(new rs.LazyCell((): string => { + return withBorrow$03hv9ge(FORCING, (me: rs.Arc> | undefined): string => { + const part = rs.optionUnwrap(me); + const args34: rs.Fmt[] = [(f: rs.Formatter) => part.value.debug(f, "LazyCell", rs.fmtStr)]; + return rs.fmtFormat([args34[0], " ", rs.fmtSpec({ alternate: true }, args34[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args34[0]), "|"]); }); })); - rt.localKeyRefCellSet(FORCING, rt.arcClone(cell3), rt.drop); + rs.localKeyRefCellSet(FORCING, rs.arcClone(cell3), rs.drop); const _175: string = cell3.value.force(); - const args31: rt.Fmt[] = [(f: rt.Formatter) => cell3.value.debug(f, "LazyCell", rt.fmtStr)]; - const _179: string = rt.fmtFormat([args31[0], " ", rt.fmtSpec({ alternate: true }, args31[0]), " ", rt.fmtSpec({ align: ">", width: 6 }, args31[0]), "|"]); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _175), (f: rt.Formatter) => rt.fmtPad(f, _179)]; - const text2: string = rt.fmtFormat([args32[0], " ", args32[1]]); - rt.drop(take$1357qwq(FORCING)); + const args31: rs.Fmt[] = [(f: rs.Formatter) => cell3.value.debug(f, "LazyCell", rs.fmtStr)]; + const _179: string = rs.fmtFormat([args31[0], " ", rs.fmtSpec({ alternate: true }, args31[0]), " ", rs.fmtSpec({ align: ">", width: 6 }, args31[0]), "|"]); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _175), (f: rs.Formatter) => rs.fmtPad(f, _179)]; + const text2: string = rs.fmtFormat([args32[0], " ", args32[1]]); + rs.drop(take$1ni7uux(FORCING)); text = text2; cell3[Symbol.dispose](); } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(text)); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(text)); } } -export const DROPS: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(DROPS$init, false); +export const DROPS: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(DROPS$init, false); -export function DROPS$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function DROPS$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } -export function cell(id: rt.u8): rt.LazyCell { +export function cell(id: rs.u8): rs.LazyCell { const held: Dropped.Dropped = new Dropped.Dropped(id); const captured = held._0; - const _0: rt.LazyCell = new rt.LazyCell((): Dropped.Dropped => { - return new Dropped.Dropped(rt.u8Add(rt.u8Add(captured, 10), rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0))); + const _0: rs.LazyCell = new rs.LazyCell((): Dropped.Dropped => { + return new Dropped.Dropped(rs.u8Add(rs.u8Add(captured, 10), rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0))); }); held[Symbol.dispose](); return _0; } -export function lock(id: rt.u8): rt.LazyLock { +export function lock(id: rs.u8): rs.LazyLock { const held: Dropped.Dropped = new Dropped.Dropped(id); const captured = held._0; - const _0: rt.LazyLock = new rt.LazyLock((): Dropped.Dropped => { - return new Dropped.Dropped(rt.u8Add(rt.u8Add(captured, 10), rt.atomicFetch(FORCED, rt.u8WrappingAdd, 1, 0))); + const _0: rs.LazyLock = new rs.LazyLock((): Dropped.Dropped => { + return new Dropped.Dropped(rs.u8Add(rs.u8Add(captured, 10), rs.atomicFetch(FORCED, rs.u8WrappingAdd, 1, 0))); }); held[Symbol.dispose](); return _0; } /** `*r = v`, through the reference. */ -export function assign$boxed_Box_cell_LazyCell_statics_Dropped_statics_cell_closure0(r: rt.Place>, v: rt.LazyCell): void { - rt.lazyDrop(r.v, rt.drop); +export function assign$boxed_Box_cell_LazyCell_statics_Dropped_statics_cell_closure0(r: rs.Place>, v: rs.LazyCell): void { + rs.lazyDrop(r.v, rs.drop); r.v = v; } /** `*r = v`, through the reference. */ -export function assign$boxed_Box_sync_LazyLock_statics_Dropped_statics_lock_closure0(r: rt.Place>, v: rt.LazyLock): void { - rt.lazyDrop(r.v, rt.drop); +export function assign$boxed_Box_sync_LazyLock_statics_Dropped_statics_lock_closure0(r: rs.Place>, v: rs.LazyLock): void { + rs.lazyDrop(r.v, rs.drop); r.v = v; } /** `*r = v`, through the reference. */ -export function assign$cell_LazyCell_statics_Dropped_statics_cell_closure0(r: rt.LazyCell, v: rt.LazyCell): void { - rt.lazyDrop(r, rt.drop); - rt.ptrWrite(r, v); +export function assign$cell_LazyCell_statics_Dropped_statics_cell_closure0(r: rs.LazyCell, v: rs.LazyCell): void { + rs.lazyDrop(r, rs.drop); + rs.ptrWrite(r, v); } /** `*r = v`, through the reference. */ -export function assign$sync_LazyLock_statics_Dropped_statics_lock_closure0(r: rt.LazyLock, v: rt.LazyLock): void { - rt.lazyDrop(r, rt.drop); - rt.ptrWrite(r, v); +export function assign$sync_LazyLock_statics_Dropped_statics_lock_closure0(r: rs.LazyLock, v: rs.LazyLock): void { + rs.lazyDrop(r, rs.drop); + rs.ptrWrite(r, v); } /** @@ -487,150 +487,150 @@ export function assign$sync_LazyLock_statics_Dropped_statics_lock_closure0(r: rt * value, after each, the one written and the one given, is forced or not; then it is * printed, forced, and dropped, and each `Dropped` dropped meanwhile put in order. */ -export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { - for (const op of rt.byteSliceView(data)) { - if (rt.u8Rem(op, 2) === 0) { - written$cell_LazyCell_statics_Dropped_statics_cell_closure0(rt.u8Div(op, 2), cell, out); +export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { + for (const op of rs.byteSliceView(data)) { + if (rs.u8Rem(op, 2) === 0) { + written$cell_LazyCell_statics_Dropped_statics_cell_closure0(rs.u8Div(op, 2), cell, out); } else { - written$sync_LazyLock_statics_Dropped_statics_lock_closure0(rt.u8Div(op, 2), lock, out); + written$sync_LazyLock_statics_Dropped_statics_lock_closure0(rs.u8Div(op, 2), lock, out); } - rt.iterExtendBytes(out, rt.byteVecIntoIter(take$122f15k(DROPS)), undefined, true); - rt.byteVecPush(out, rt.atomicSwap(FORCED, 0, 0)); + rs.iterExtendBytes(out, rs.byteVecIntoIter(take$1snv7rd(DROPS)), undefined, true); + rs.byteVecPush(out, rs.atomicSwap(FORCED, 0, 0)); } } -export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rt.u8, make: (a0: rt.u8) => rt.LazyCell, out: rt.ByteVec): void { - const _18: (a0: rt.LazyCell) => string = (l: rt.LazyCell): string => { - const args2: rt.Fmt[] = [(f: rt.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rt.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; - return rt.fmtFormat([args2[0], "|"]); +export function written$cell_LazyCell_statics_Dropped_statics_cell_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyCell, out: rs.ByteVec): void { + const _18: (a0: rs.LazyCell) => string = (l: rs.LazyCell): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyCell", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; + return rs.fmtFormat([args2[0], "|"]); }; let _103: boolean = false; - let a: rt.LazyCell = make(1); - let b: rt.LazyCell = make(2); + let a: rs.LazyCell = make(1); + let b: rs.LazyCell = make(2); _103 = true; if ((op & 1) !== 0) { - rt.byteVecPush(out, a.force()._0); + rs.byteVecPush(out, a.force()._0); } if ((op & 2) !== 0) { - rt.byteVecPush(out, b.force()._0); + rs.byteVecPush(out, b.force()._0); } - const _20: rt.u8 = rt.u8Rem(op >> 2, 7); + const _20: rs.u8 = rs.u8Rem(op >> 2, 7); if (_20 === 0) { - const _25: rt.LazyCell = a; + const _25: rs.LazyCell = a; _103 = false; assign$cell_LazyCell_statics_Dropped_statics_cell_closure0(_25, b); } else if (_20 === 1) { - const _28: rt.LazyCell = a; + const _28: rs.LazyCell = a; _103 = false; - const old: rt.LazyCell = rt.replaceIn(_28, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(old))); - rt.lazyDrop(old, rt.drop); + const old: rs.LazyCell = rs.replaceIn(_28, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { - b = rt.replaceIn(a, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(b))); - rt.byteVecPush(out, b.force()._0); + b = rs.replaceIn(a, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { - const _52: rt.Cell> = rt.cellIn(a); + const _52: rs.Cell> = rs.cellIn(a); _103 = false; - const old2: rt.LazyCell = rt.cellReplace(_52, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(old2))); - rt.lazyDrop(old2, rt.drop); + const old2: rs.LazyCell = rs.cellReplace(_52, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { - const _62: rt.Cell> = rt.cellIn(a); + const _62: rs.Cell> = rs.cellIn(a); _103 = false; - rt.cellSet(_62, b, drop$cell_LazyCell_statics_Dropped_statics_cell_closure0); + rs.cellSet(_62, b, drop$cell_LazyCell_statics_Dropped_statics_cell_closure0); } else if (_20 === 5) { - let boxed: rt.LazyCell = a; + let boxed: rs.LazyCell = a; _103 = false; - const _69: rt.LazyCell = b; - assign$boxed_Box_cell_LazyCell_statics_Dropped_statics_cell_closure0(rt.place(() => boxed, (value) => boxed = value), _69); + const _69: rs.LazyCell = b; + assign$boxed_Box_cell_LazyCell_statics_Dropped_statics_cell_closure0(rs.place(() => boxed, (value) => boxed = value), _69); a = boxed; } else { - const held: rt.RefCell<[rt.u8, rt.LazyCell]> = new rt.RefCell([0, a] as [rt.u8, rt.LazyCell]); - const _79: rt.RefCell<[rt.u8, rt.LazyCell]> = rt.refCellBorrowMut(held); - const _78: rt.RefCell> = rt.refMutMap(_79, rt.partPlace(((p: [rt.u8, rt.LazyCell]): rt.LazyCell => { + const held: rs.RefCell<[rs.u8, rs.LazyCell]> = new rs.RefCell([0, a] as [rs.u8, rs.LazyCell]); + const _79: rs.RefCell<[rs.u8, rs.LazyCell]> = rs.refCellBorrowMut(held); + const _78: rs.RefCell> = rs.refMutMap(_79, rs.partPlace(((p: [rs.u8, rs.LazyCell]): rs.LazyCell => { return p[1]; })(_79.value))); _103 = false; assign$cell_LazyCell_statics_Dropped_statics_cell_closure0(_78.value, b); - rt.refMutRelease(_78); + rs.refMutRelease(_78); a = held.value[1]; } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(a))); - rt.byteVecPush(out, a.force()._0); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecPush(out, a.force()._0); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); if (_103) { - rt.lazyDrop(b, rt.drop); + rs.lazyDrop(b, rs.drop); } _103 = false; - rt.lazyDrop(a, rt.drop); + rs.lazyDrop(a, rs.drop); } -export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rt.u8, make: (a0: rt.u8) => rt.LazyLock, out: rt.ByteVec): void { - const _18: (a0: rt.LazyLock) => string = (l: rt.LazyLock): string => { - const args2: rt.Fmt[] = [(f: rt.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rt.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; - return rt.fmtFormat([args2[0], "|"]); +export function written$sync_LazyLock_statics_Dropped_statics_lock_closure0(op: rs.u8, make: (a0: rs.u8) => rs.LazyLock, out: rs.ByteVec): void { + const _18: (a0: rs.LazyLock) => string = (l: rs.LazyLock): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => l.debug(f, "LazyLock", (value: Dropped.Dropped, f: rs.Formatter) => Dropped.fmt$fmt_Debug(value, f))]; + return rs.fmtFormat([args2[0], "|"]); }; let _103: boolean = false; - let a: rt.LazyLock = make(1); - let b: rt.LazyLock = make(2); + let a: rs.LazyLock = make(1); + let b: rs.LazyLock = make(2); _103 = true; if ((op & 1) !== 0) { - rt.byteVecPush(out, a.force()._0); + rs.byteVecPush(out, a.force()._0); } if ((op & 2) !== 0) { - rt.byteVecPush(out, b.force()._0); + rs.byteVecPush(out, b.force()._0); } - const _20: rt.u8 = rt.u8Rem(op >> 2, 7); + const _20: rs.u8 = rs.u8Rem(op >> 2, 7); if (_20 === 0) { - const _25: rt.LazyLock = a; + const _25: rs.LazyLock = a; _103 = false; assign$sync_LazyLock_statics_Dropped_statics_lock_closure0(_25, b); } else if (_20 === 1) { - const _28: rt.LazyLock = a; + const _28: rs.LazyLock = a; _103 = false; - const old: rt.LazyLock = rt.replaceIn(_28, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(old))); - rt.lazyDrop(old, rt.drop); + const old: rs.LazyLock = rs.replaceIn(_28, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old))); + rs.lazyDrop(old, rs.drop); } else if (_20 === 2) { - b = rt.replaceIn(a, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(b))); - rt.byteVecPush(out, b.force()._0); + b = rs.replaceIn(a, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(b))); + rs.byteVecPush(out, b.force()._0); } else if (_20 === 3) { - const _52: rt.Cell> = rt.cellIn(a); + const _52: rs.Cell> = rs.cellIn(a); _103 = false; - const old2: rt.LazyLock = rt.cellReplace(_52, b); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(old2))); - rt.lazyDrop(old2, rt.drop); + const old2: rs.LazyLock = rs.cellReplace(_52, b); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(old2))); + rs.lazyDrop(old2, rs.drop); } else if (_20 === 4) { - const _62: rt.Cell> = rt.cellIn(a); + const _62: rs.Cell> = rs.cellIn(a); _103 = false; - rt.cellSet(_62, b, drop$sync_LazyLock_statics_Dropped_statics_lock_closure0); + rs.cellSet(_62, b, drop$sync_LazyLock_statics_Dropped_statics_lock_closure0); } else if (_20 === 5) { - let boxed: rt.LazyLock = a; + let boxed: rs.LazyLock = a; _103 = false; - const _69: rt.LazyLock = b; - assign$boxed_Box_sync_LazyLock_statics_Dropped_statics_lock_closure0(rt.place(() => boxed, (value) => boxed = value), _69); + const _69: rs.LazyLock = b; + assign$boxed_Box_sync_LazyLock_statics_Dropped_statics_lock_closure0(rs.place(() => boxed, (value) => boxed = value), _69); a = boxed; } else { - const held: rt.RefCell<[rt.u8, rt.LazyLock]> = new rt.RefCell([0, a] as [rt.u8, rt.LazyLock]); - const _79: rt.RefCell<[rt.u8, rt.LazyLock]> = rt.refCellBorrowMut(held); - const _78: rt.RefCell> = rt.refMutMap(_79, rt.partPlace(((p: [rt.u8, rt.LazyLock]): rt.LazyLock => { + const held: rs.RefCell<[rs.u8, rs.LazyLock]> = new rs.RefCell([0, a] as [rs.u8, rs.LazyLock]); + const _79: rs.RefCell<[rs.u8, rs.LazyLock]> = rs.refCellBorrowMut(held); + const _78: rs.RefCell> = rs.refMutMap(_79, rs.partPlace(((p: [rs.u8, rs.LazyLock]): rs.LazyLock => { return p[1]; })(_79.value))); _103 = false; assign$sync_LazyLock_statics_Dropped_statics_lock_closure0(_78.value, b); - rt.refMutRelease(_78); + rs.refMutRelease(_78); a = held.value[1]; } - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(a))); - rt.byteVecPush(out, a.force()._0); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(_18(a))); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); + rs.byteVecPush(out, a.force()._0); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(_18(a))); if (_103) { - rt.lazyDrop(b, rt.drop); + rs.lazyDrop(b, rs.drop); } _103 = false; - rt.lazyDrop(a, rt.drop); + rs.lazyDrop(a, rs.drop); } //# sourceMappingURL=statics.ts.map diff --git a/ts/fixtures/lang/statics/expected/statics/elsewhere.ts b/ts/fixtures/lang/statics/expected/statics/elsewhere.ts index 67bfb2c8c..c658742c6 100644 --- a/ts/fixtures/lang/statics/expected/statics/elsewhere.ts +++ b/ts/fixtures/lang/statics/expected/statics/elsewhere.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { SHARED } from "../statics.ts"; -export const LATER: rt.Atomic = /* @__PURE__ */ new rt.Atomic(40); +export const LATER: rs.Atomic = /* @__PURE__ */ new rs.Atomic(40); /** Through the static that points here. */ -export function read(): rt.u8 { - return rt.atomicLoad(SHARED.force(), 0); +export function read(): rs.u8 { + return rs.atomicLoad(SHARED.force(), 0); } //# sourceMappingURL=elsewhere.ts.map diff --git a/ts/fixtures/lang/statics/expected/std/thread/local.ts b/ts/fixtures/lang/statics/expected/std/thread/local.ts index a53ad3333..7be29cc62 100644 --- a/ts/fixtures/lang/statics/expected/std/thread/local.ts +++ b/ts/fixtures/lang/statics/expected/std/thread/local.ts @@ -1,27 +1,27 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function withBorrow$1roy6g4(self: rt.LocalKey> | undefined>>, f: (a0: rt.Arc> | undefined) => string): string { +export function withBorrow$03hv9ge(self: rs.LocalKey> | undefined>>, f: (a0: rs.Arc> | undefined) => string): string { const captured = f; - return ((cell: rt.RefCell> | undefined>): string => { - const _32: (a0: rt.Arc> | undefined) => string = captured; - const _7: rt.RefCell> | undefined> = rt.refCellBorrow(cell); + return ((cell: rs.RefCell> | undefined>): string => { + const _32: (a0: rs.Arc> | undefined) => string = captured; + const _7: rs.RefCell> | undefined> = rs.refCellBorrow(cell); const _02: string = _32(_7.value); - rt.refRelease(_7); + rs.refRelease(_7); return _02; })(self.get()); } -export function take$1357qwq(self: rt.LocalKey> | undefined>>): rt.Arc> | undefined { - return ((a0: rt.RefCell> | undefined>): rt.Arc> | undefined => { - return rt.refCellReplace(a0, undefined); +export function take$1ni7uux(self: rs.LocalKey> | undefined>>): rs.Arc> | undefined { + return ((a0: rs.RefCell> | undefined>): rs.Arc> | undefined => { + return rs.refCellReplace(a0, undefined); })(self.get()); } -export function take$122f15k(self: rt.LocalKey>): rt.ByteVec { - return ((a0: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(a0, new rt.ByteVec()); +export function take$1snv7rd(self: rs.LocalKey>): rs.ByteVec { + return ((a0: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(a0, new rs.ByteVec()); })(self.get()); } diff --git a/ts/fixtures/lang/strs/expected/core/char/methods.ts b/ts/fixtures/lang/strs/expected/core/char/methods.ts index 992b1a141..5b52ab359 100644 --- a/ts/fixtures/lang/strs/expected/core/char/methods.ts +++ b/ts/fixtures/lang/strs/expected/core/char/methods.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefined { - let value!: rt.u32; +export function toDigit$14z95r4(self: rs.char, radix: rs.u32): rs.u32 | undefined { + let value!: rs.u32; if (radix >= 2) { if (radix <= 36) { b1: { if (self > 57) { if (radix > 10) { - value = rt.u32Add((rt.u32WrappingSub(self as rt.u32, 65 as rt.u32) & 4294967263) >>> 0, 10); + value = rs.u32Add((rs.u32WrappingSub(self as rs.u32, 65 as rs.u32) & 4294967263) >>> 0, 10); break b1; } } - value = rt.u32WrappingSub(self as rt.u32, 48 as rt.u32); + value = rs.u32WrappingSub(self as rs.u32, 48 as rs.u32); } if (!(value < radix)) { return undefined; @@ -21,7 +21,7 @@ export function toDigit$01k9ewn(self: rt.char, radix: rt.u32): rt.u32 | undefine return value; } } - rt.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); + rs.panicFmt(["to_digit: invalid radix -- radix must be in the range 2 to 36 inclusive"]); } //# sourceMappingURL=methods.ts.map diff --git a/ts/fixtures/lang/strs/expected/core/num.ts b/ts/fixtures/lang/strs/expected/core/num.ts index f5aeda954..da3da54fc 100644 --- a/ts/fixtures/lang/strs/expected/core/num.ts +++ b/ts/fixtures/lang/strs/expected/core/num.ts @@ -1,57 +1,57 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { toDigit$01k9ewn } from "../core/char/methods.ts"; +import * as rs from "../rs.ts"; +import { toDigit$14z95r4 } from "../core/char/methods.ts"; -export function canNotOverflow$0q497dn(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$05izqtt(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(16, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(16, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$1wu8g18(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$0du5ub4(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(2, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(2, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0uown4l(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$14pvtu0(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(4, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(4, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$03q1vv8(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$09fz75c(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(8, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(8, 2), isSignedTy ? 1 : 0); } -export function canNotOverflow$0aqh4yo(radix: rt.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { +export function canNotOverflow$0bdyog2(radix: rs.u32, isSignedTy: boolean, _digitsData: Uint8Array, _digitsStart: number, digitsLen: number): boolean { if (!(radix <= 16)) { return false; } - return digitsLen <= rt.usizeSub(rt.usizeMul(1, 2), isSignedTy ? 1 : 0); + return digitsLen <= rs.usizeSub(rs.usizeMul(1, 2), isSignedTy ? 1 : 0); } -export function fromAsciiBytesRadixPanic(radix: rt.u32): never { - doPanic$0sx2e1f(radix); +export function fromAsciiBytesRadixPanic(radix: rs.u32): never { + doPanic$16ya8t2(radix); } -export function doPanic$0sx2e1f(radix: rt.u32): never { - runtime$0bn0geu(radix); +export function doPanic$16ya8t2(radix: rs.u32): never { + runtime$0o4i17s(radix); } -export function runtime$0bn0geu(radix: rt.u32): never { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(radix, f)]; - rt.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); +export function runtime$0o4i17s(radix: rs.u32): never { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(radix, f)]; + rs.panicFmt(["from_ascii_bytes_radix: radix must lie in the range `[2, 36]` - found ", args2[0]]); } -export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1r0rye7(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -59,11 +59,11 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rt.i128); + const isSignedTy: boolean = rs.i128Gt(0, { hi: -0x80000000, w2: 0, w1: 0, lo: 0 } as rs.i128); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -77,7 +77,7 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -96,31 +96,31 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i128 = 0; + let result: rs.i128 = 0; b5: { - if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$05izqtt(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i128 = _92 as rt.i128; + const x4: rs.i128 = _92 as rs.i128; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i128 | undefined = rt.i128CheckedSub(result, x4); + const _103: rs.i128 | undefined = rs.i128CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -132,23 +132,23 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i128 | undefined = rt.i128CheckedMul(result, radix as rt.i128); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i128 | undefined = rs.i128CheckedMul(result, radix as rs.i128); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i128 = _67 as rt.i128; + const x3: rs.i128 = _67 as rs.i128; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i128 | undefined = rt.i128CheckedAdd(result, x3); + const _78: rs.i128 | undefined = rs.i128CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -161,16 +161,16 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingSub(result, _49 as rt.i128); + result = rs.i128WrappingSub(result, _49 as rs.i128); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -180,30 +180,30 @@ export function fromAsciiBytesRadixImpl$0xhcrxt(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i128WrappingMul(result, radix as rt.i128); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i128WrappingMul(result, radix as rs.i128); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i128WrappingAdd(result, _32 as rt.i128); + result = rs.i128WrappingAdd(result, _32 as rs.i128); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1gthu8q(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -215,7 +215,7 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -229,7 +229,7 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -248,31 +248,31 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i16 = 0; + let result: rs.i16 = 0; b5: { - if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0du5ub4(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i16 | undefined = rt.i16CheckedMul(result, (radix << 16) >> 16); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i16 | undefined = rs.i16CheckedMul(result, (radix << 16) >> 16); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i16 = (_92 << 16) >> 16; + const x4: rs.i16 = (_92 << 16) >> 16; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i16 | undefined = rt.i16CheckedSub(result, x4); + const _103: rs.i16 | undefined = rs.i16CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -284,23 +284,23 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i16 | undefined = rt.i16CheckedMul(result, (radix << 16) >> 16); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i16 | undefined = rs.i16CheckedMul(result, (radix << 16) >> 16); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i16 = (_67 << 16) >> 16; + const x3: rs.i16 = (_67 << 16) >> 16; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i16 | undefined = rt.i16CheckedAdd(result, x3); + const _78: rs.i16 | undefined = rs.i16CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -313,16 +313,16 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i16WrappingMul(result, (radix << 16) >> 16); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i16WrappingMul(result, (radix << 16) >> 16); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i16WrappingSub(result, (_49 << 16) >> 16); + result = rs.i16WrappingSub(result, (_49 << 16) >> 16); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -332,30 +332,30 @@ export function fromAsciiBytesRadixImpl$0ut8llb(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i16WrappingMul(result, (radix << 16) >> 16); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i16WrappingMul(result, (radix << 16) >> 16); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i16WrappingAdd(result, (_32 << 16) >> 16); + result = rs.i16WrappingAdd(result, (_32 << 16) >> 16); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$07oe1fj(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -367,7 +367,7 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -381,7 +381,7 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -400,31 +400,31 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i32 = 0; + let result: rs.i32 = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i32 | undefined = rt.i32CheckedMul(result, radix | 0); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i32 | undefined = rs.i32CheckedMul(result, radix | 0); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i32 = _92 | 0; + const x4: rs.i32 = _92 | 0; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i32 | undefined = rt.i32CheckedSub(result, x4); + const _103: rs.i32 | undefined = rs.i32CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -436,23 +436,23 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i32 | undefined = rt.i32CheckedMul(result, radix | 0); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i32 | undefined = rs.i32CheckedMul(result, radix | 0); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i32 = _67 | 0; + const x3: rs.i32 = _67 | 0; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i32 | undefined = rt.i32CheckedAdd(result, x3); + const _78: rs.i32 | undefined = rs.i32CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -465,16 +465,16 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i32WrappingMul(result, radix | 0); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i32WrappingMul(result, radix | 0); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i32WrappingSub(result, _49 | 0); + result = rs.i32WrappingSub(result, _49 | 0); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -484,30 +484,30 @@ export function fromAsciiBytesRadixImpl$1ykgy6m(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i32WrappingMul(result, radix | 0); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i32WrappingMul(result, radix | 0); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i32WrappingAdd(result, _32 | 0); + result = rs.i32WrappingAdd(result, _32 | 0); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0wzunhe(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -515,11 +515,11 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.i64Gt(0, { hi: -0x80000000, lo: 0 } as rt.i64); + const isSignedTy: boolean = rs.i64Gt(0, { hi: -0x80000000, lo: 0 } as rs.i64); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -533,7 +533,7 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -552,31 +552,31 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i64 = 0; + let result: rs.i64 = 0; b5: { - if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$09fz75c(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i64 | undefined = rt.i64CheckedMul(result, radix as rt.i64); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i64 | undefined = rs.i64CheckedMul(result, radix as rs.i64); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i64 = _92 as rt.i64; + const x4: rs.i64 = _92 as rs.i64; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i64 | undefined = rt.i64CheckedSub(result, x4); + const _103: rs.i64 | undefined = rs.i64CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -588,23 +588,23 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i64 | undefined = rt.i64CheckedMul(result, radix as rt.i64); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i64 | undefined = rs.i64CheckedMul(result, radix as rs.i64); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i64 = _67 as rt.i64; + const x3: rs.i64 = _67 as rs.i64; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i64 | undefined = rt.i64CheckedAdd(result, x3); + const _78: rs.i64 | undefined = rs.i64CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -617,16 +617,16 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i64WrappingMul(result, radix as rt.i64); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i64WrappingMul(result, radix as rs.i64); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i64WrappingSub(result, _49 as rt.i64); + result = rs.i64WrappingSub(result, _49 as rs.i64); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -636,30 +636,30 @@ export function fromAsciiBytesRadixImpl$01tfvb9(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i64WrappingMul(result, radix as rt.i64); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i64WrappingMul(result, radix as rs.i64); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i64WrappingAdd(result, _32 as rt.i64); + result = rs.i64WrappingAdd(result, _32 as rs.i64); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1amlmta(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -671,7 +671,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -685,7 +685,7 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -704,31 +704,31 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.i8 = 0; + let result: rs.i8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.i8 = (_92 << 24) >> 24; + const x4: rs.i8 = (_92 << 24) >> 24; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.i8 | undefined = rt.i8CheckedSub(result, x4); + const _103: rs.i8 | undefined = rs.i8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -740,23 +740,23 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.i8 | undefined = rt.i8CheckedMul(result, (radix << 24) >> 24); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.i8 | undefined = rs.i8CheckedMul(result, (radix << 24) >> 24); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.i8 = (_67 << 24) >> 24; + const x3: rs.i8 = (_67 << 24) >> 24; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.i8 | undefined = rt.i8CheckedAdd(result, x3); + const _78: rs.i8 | undefined = rs.i8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -769,16 +769,16 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingSub(result, (_49 << 24) >> 24); + result = rs.i8WrappingSub(result, (_49 << 24) >> 24); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -788,30 +788,30 @@ export function fromAsciiBytesRadixImpl$0k9pjln(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.i8WrappingMul(result, (radix << 24) >> 24); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.i8WrappingMul(result, (radix << 24) >> 24); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.i8WrappingAdd(result, (_32 << 24) >> 24); + result = rs.i8WrappingAdd(result, (_32 << 24) >> 24); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0d7us41(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -823,7 +823,7 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -837,7 +837,7 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -856,31 +856,31 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.isize = 0; + let result: rs.isize = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.isize | undefined = rt.isizeCheckedMul(result, radix | 0); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.isize | undefined = rs.isizeCheckedMul(result, radix | 0); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.isize = _92 | 0; + const x4: rs.isize = _92 | 0; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.isize | undefined = rt.isizeCheckedSub(result, x4); + const _103: rs.isize | undefined = rs.isizeCheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -892,23 +892,23 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.isize | undefined = rt.isizeCheckedMul(result, radix | 0); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.isize | undefined = rs.isizeCheckedMul(result, radix | 0); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.isize = _67 | 0; + const x3: rs.isize = _67 | 0; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.isize | undefined = rt.isizeCheckedAdd(result, x3); + const _78: rs.isize | undefined = rs.isizeCheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -921,16 +921,16 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.isizeWrappingMul(result, radix | 0); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.isizeWrappingMul(result, radix | 0); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.isizeWrappingSub(result, _49 | 0); + result = rs.isizeWrappingSub(result, _49 | 0); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -940,30 +940,30 @@ export function fromAsciiBytesRadixImpl$1hpkcx2(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.isizeWrappingMul(result, radix | 0); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.isizeWrappingMul(result, radix | 0); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.isizeWrappingAdd(result, _32 | 0); + result = rs.isizeWrappingAdd(result, _32 | 0); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0paozdl(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -971,11 +971,11 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.u128Gt(0, 0); + const isSignedTy: boolean = rs.u128Gt(0, 0); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -989,7 +989,7 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1008,31 +1008,31 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u128 = 0; + let result: rs.u128 = 0; b5: { - if (!canNotOverflow$0q497dn(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$05izqtt(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u128 | undefined = rt.u128CheckedMul(result, radix as rt.u128); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u128 | undefined = rs.u128CheckedMul(result, radix as rs.u128); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u128 = _92 as rt.u128; + const x4: rs.u128 = _92 as rs.u128; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u128 | undefined = rt.u128CheckedSub(result, x4); + const _103: rs.u128 | undefined = rs.u128CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1044,23 +1044,23 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u128 | undefined = rt.u128CheckedMul(result, radix as rt.u128); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u128 | undefined = rs.u128CheckedMul(result, radix as rs.u128); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u128 = _67 as rt.u128; + const x3: rs.u128 = _67 as rs.u128; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u128 | undefined = rt.u128CheckedAdd(result, x3); + const _78: rs.u128 | undefined = rs.u128CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1073,16 +1073,16 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u128WrappingMul(result, radix as rt.u128); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u128WrappingMul(result, radix as rs.u128); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u128WrappingSub(result, _49 as rt.u128); + result = rs.u128WrappingSub(result, _49 as rs.u128); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1092,30 +1092,30 @@ export function fromAsciiBytesRadixImpl$0r1q6uy(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u128WrappingMul(result, radix as rt.u128); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u128WrappingMul(result, radix as rs.u128); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u128WrappingAdd(result, _32 as rt.u128); + result = rs.u128WrappingAdd(result, _32 as rs.u128); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0wd05by(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1127,7 +1127,7 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1141,7 +1141,7 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1160,31 +1160,31 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u16 = 0; + let result: rs.u16 = 0; b5: { - if (!canNotOverflow$1wu8g18(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0du5ub4(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u16 | undefined = rt.u16CheckedMul(result, radix & 0xffff); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u16 | undefined = rs.u16CheckedMul(result, radix & 0xffff); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u16 = _92 & 0xffff; + const x4: rs.u16 = _92 & 0xffff; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u16 | undefined = rt.u16CheckedSub(result, x4); + const _103: rs.u16 | undefined = rs.u16CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1196,23 +1196,23 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u16 | undefined = rt.u16CheckedMul(result, radix & 0xffff); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u16 | undefined = rs.u16CheckedMul(result, radix & 0xffff); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u16 = _67 & 0xffff; + const x3: rs.u16 = _67 & 0xffff; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u16 | undefined = rt.u16CheckedAdd(result, x3); + const _78: rs.u16 | undefined = rs.u16CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1225,16 +1225,16 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u16WrappingMul(result, radix & 0xffff); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u16WrappingMul(result, radix & 0xffff); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u16WrappingSub(result, _49 & 0xffff); + result = rs.u16WrappingSub(result, _49 & 0xffff); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1244,30 +1244,30 @@ export function fromAsciiBytesRadixImpl$0q4dbht(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u16WrappingMul(result, radix & 0xffff); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u16WrappingMul(result, radix & 0xffff); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u16WrappingAdd(result, _32 & 0xffff); + result = rs.u16WrappingAdd(result, _32 & 0xffff); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$15o252c(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1279,7 +1279,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value5 = src.data[src.start]; if (value5 === 43 || value5 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1293,7 +1293,7 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value6 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1312,31 +1312,31 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u32 = 0; + let result: rs.u32 = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _84: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _84: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_84 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u32 = _84; + const x4: rs.u32 = _84; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _95: rt.u32 | undefined = rt.u32CheckedSub(result, x4); + const _95: rs.u32 | undefined = rs.u32CheckedSub(result, x4); if (_95 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _95; digitsData = restData5; @@ -1348,23 +1348,23 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u32 | undefined = rt.u32CheckedMul(result, radix); - const _61: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u32 | undefined = rs.u32CheckedMul(result, radix); + const _61: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_61 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u32 = _61; + const x3: rs.u32 = _61; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _72: rt.u32 | undefined = rt.u32CheckedAdd(result, x3); + const _72: rs.u32 | undefined = rs.u32CheckedAdd(result, x3); if (_72 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _72; digitsData = restData4; @@ -1377,16 +1377,16 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _46: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _46: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_46 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingSub(result, _46); + result = rs.u32WrappingSub(result, _46); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1396,30 +1396,30 @@ export function fromAsciiBytesRadixImpl$1xmrosk(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u32WrappingMul(result, radix); - const _31: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u32WrappingMul(result, radix); + const _31: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_31 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u32WrappingAdd(result, _31); + result = rs.u32WrappingAdd(result, _31); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$0zwqu7x(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1427,11 +1427,11 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(2 > radix)) { if (!(radix > 36)) { if (!(src.length === 0)) { - const isSignedTy: boolean = rt.u64Gt(0, 0); + const isSignedTy: boolean = rs.u64Gt(0, 0); if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1445,7 +1445,7 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1464,31 +1464,31 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u64 = 0; + let result: rs.u64 = 0; b5: { - if (!canNotOverflow$03q1vv8(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$09fz75c(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u64 = _92 as rt.u64; + const x4: rs.u64 = _92 as rs.u64; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u64 | undefined = rt.u64CheckedSub(result, x4); + const _103: rs.u64 | undefined = rs.u64CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1500,23 +1500,23 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u64 | undefined = rt.u64CheckedMul(result, radix as rt.u64); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u64 | undefined = rs.u64CheckedMul(result, radix as rs.u64); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u64 = _67 as rt.u64; + const x3: rs.u64 = _67 as rs.u64; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u64 | undefined = rt.u64CheckedAdd(result, x3); + const _78: rs.u64 | undefined = rs.u64CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1529,16 +1529,16 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingSub(result, _49 as rt.u64); + result = rs.u64WrappingSub(result, _49 as rs.u64); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1548,30 +1548,30 @@ export function fromAsciiBytesRadixImpl$02xpj41(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u64WrappingMul(result, radix as rt.u64); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u64WrappingMul(result, radix as rs.u64); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u64WrappingAdd(result, _32 as rt.u64); + result = rs.u64WrappingAdd(result, _32 as rs.u64); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1djtuzq(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1583,7 +1583,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1597,7 +1597,7 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1616,31 +1616,31 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.u8 = 0; + let result: rs.u8 = 0; b5: { - if (!canNotOverflow$0aqh4yo(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$0bdyog2(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.u8 = _92 & 0xff; + const x4: rs.u8 = _92 & 0xff; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.u8 | undefined = rt.u8CheckedSub(result, x4); + const _103: rs.u8 | undefined = rs.u8CheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1652,23 +1652,23 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.u8 | undefined = rt.u8CheckedMul(result, radix & 0xff); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.u8 | undefined = rs.u8CheckedMul(result, radix & 0xff); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.u8 = _67 & 0xff; + const x3: rs.u8 = _67 & 0xff; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.u8 | undefined = rt.u8CheckedAdd(result, x3); + const _78: rs.u8 | undefined = rs.u8CheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1681,16 +1681,16 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingSub(result, _49 & 0xff); + result = rs.u8WrappingSub(result, _49 & 0xff); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1700,30 +1700,30 @@ export function fromAsciiBytesRadixImpl$037x42t(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.u8WrappingMul(result, radix & 0xff); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.u8WrappingMul(result, radix & 0xff); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.u8WrappingAdd(result, _32 & 0xff); + result = rs.u8WrappingAdd(result, _32 & 0xff); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); } -export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32): rt.Result { +export function fromAsciiBytesRadixImpl$1lirmeu(src: rs.ByteSlice, radix: rs.u32): rs.Result { let _12_0!: boolean; let _12_1Data!: Uint8Array; let _12_1Start!: number; @@ -1735,7 +1735,7 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (src.length === 1) { const value7 = src.data[src.start]; if (value7 === 43 || value7 === 45) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } } b3: { @@ -1749,7 +1749,7 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 break b3; } if (value8 === 45) { - const rest2: rt.ByteSlice = rt.byteSliceRange(src, 1); + const rest2: rs.ByteSlice = rs.byteSliceRange(src, 1); if (isSignedTy) { _12_0 = false; _12_1Data = rest2.data; @@ -1768,31 +1768,31 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 let digitsData: Uint8Array = _12_1Data; let digitsStart: number = _12_1Start; let digitsLen: number = _12_1Len; - let result: rt.usize = 0; + let result: rs.usize = 0; b5: { - if (!canNotOverflow$0uown4l(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { + if (!canNotOverflow$14pvtu0(radix, isSignedTy, digitsData, digitsStart, digitsLen)) { if (!isPositive) { while (true) { if (!(digitsLen >= 1)) { break b5; } - const c4: rt.u8 = digitsData[digitsStart]; + const c4: rs.u8 = digitsData[digitsStart]; const restData5: Uint8Array = digitsData; const restStart5: number = digitsStart + 1; const restLen5: number = digitsLen - 1; - const mul2: rt.usize | undefined = rt.usizeCheckedMul(result, radix as rt.usize); - const _92: rt.u32 | undefined = toDigit$01k9ewn(c4 as rt.char, radix); + const mul2: rs.usize | undefined = rs.usizeCheckedMul(result, radix as rs.usize); + const _92: rs.u32 | undefined = toDigit$14z95r4(c4 as rs.char, radix); if (_92 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x4: rt.usize = _92 as rt.usize; + const x4: rs.usize = _92 as rs.usize; if (mul2 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = mul2; - const _103: rt.usize | undefined = rt.usizeCheckedSub(result, x4); + const _103: rs.usize | undefined = rs.usizeCheckedSub(result, x4); if (_103 === undefined) { - return rt.Err({ kind: "NegOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "NegOverflow" as rs.IntErrorKind }); } result = _103; digitsData = restData5; @@ -1804,23 +1804,23 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c3: rt.u8 = digitsData[digitsStart]; + const c3: rs.u8 = digitsData[digitsStart]; const restData4: Uint8Array = digitsData; const restStart4: number = digitsStart + 1; const restLen4: number = digitsLen - 1; - const mul: rt.usize | undefined = rt.usizeCheckedMul(result, radix as rt.usize); - const _67: rt.u32 | undefined = toDigit$01k9ewn(c3 as rt.char, radix); + const mul: rs.usize | undefined = rs.usizeCheckedMul(result, radix as rs.usize); + const _67: rs.u32 | undefined = toDigit$14z95r4(c3 as rs.char, radix); if (_67 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - const x3: rt.usize = _67 as rt.usize; + const x3: rs.usize = _67 as rs.usize; if (mul === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = mul; - const _78: rt.usize | undefined = rt.usizeCheckedAdd(result, x3); + const _78: rs.usize | undefined = rs.usizeCheckedAdd(result, x3); if (_78 === undefined) { - return rt.Err({ kind: "PosOverflow" as rt.IntErrorKind }); + return rs.Err({ kind: "PosOverflow" as rs.IntErrorKind }); } result = _78; digitsData = restData4; @@ -1833,16 +1833,16 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c2: rt.u8 = digitsData[digitsStart]; + const c2: rs.u8 = digitsData[digitsStart]; const restData3: Uint8Array = digitsData; const restStart3: number = digitsStart + 1; const restLen3: number = digitsLen - 1; - result = rt.usizeWrappingMul(result, radix as rt.usize); - const _49: rt.u32 | undefined = toDigit$01k9ewn(c2 as rt.char, radix); + result = rs.usizeWrappingMul(result, radix as rs.usize); + const _49: rs.u32 | undefined = toDigit$14z95r4(c2 as rs.char, radix); if (_49 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.usizeWrappingSub(result, _49 as rt.usize); + result = rs.usizeWrappingSub(result, _49 as rs.usize); digitsData = restData3; digitsStart = restStart3; digitsLen = restLen3; @@ -1852,24 +1852,24 @@ export function fromAsciiBytesRadixImpl$1cdwgun(src: rt.ByteSlice, radix: rt.u32 if (!(digitsLen >= 1)) { break b5; } - const c: rt.u8 = digitsData[digitsStart]; + const c: rs.u8 = digitsData[digitsStart]; const restData2: Uint8Array = digitsData; const restStart2: number = digitsStart + 1; const restLen2: number = digitsLen - 1; - result = rt.usizeWrappingMul(result, radix as rt.usize); - const _32: rt.u32 | undefined = toDigit$01k9ewn(c as rt.char, radix); + result = rs.usizeWrappingMul(result, radix as rs.usize); + const _32: rs.u32 | undefined = toDigit$14z95r4(c as rs.char, radix); if (_32 === undefined) { - return rt.Err({ kind: "InvalidDigit" as rt.IntErrorKind }); + return rs.Err({ kind: "InvalidDigit" as rs.IntErrorKind }); } - result = rt.usizeWrappingAdd(result, _32 as rt.usize); + result = rs.usizeWrappingAdd(result, _32 as rs.usize); digitsData = restData2; digitsStart = restStart2; digitsLen = restLen2; } } - return rt.Ok(result); + return rs.Ok(result); } - return rt.Err({ kind: "Empty" as rt.IntErrorKind }); + return rs.Err({ kind: "Empty" as rs.IntErrorKind }); } } fromAsciiBytesRadixPanic(radix); diff --git a/ts/fixtures/lang/strs/expected/core/num/nonzero.ts b/ts/fixtures/lang/strs/expected/core/num/nonzero.ts index a82efebc6..6a2e0a243 100644 --- a/ts/fixtures/lang/strs/expected/core/num/nonzero.ts +++ b/ts/fixtures/lang/strs/expected/core/num/nonzero.ts @@ -1,246 +1,246 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; -import { fromAsciiBytesRadixImpl$0xhcrxt as num_fromAsciiBytesRadixImpl$0xhcrxt, fromAsciiBytesRadixImpl$0ut8llb as num_fromAsciiBytesRadixImpl$0ut8llb, fromAsciiBytesRadixImpl$1ykgy6m as num_fromAsciiBytesRadixImpl$1ykgy6m, fromAsciiBytesRadixImpl$01tfvb9 as num_fromAsciiBytesRadixImpl$01tfvb9, fromAsciiBytesRadixImpl$0k9pjln as num_fromAsciiBytesRadixImpl$0k9pjln, fromAsciiBytesRadixImpl$1hpkcx2 as num_fromAsciiBytesRadixImpl$1hpkcx2, fromAsciiBytesRadixImpl$0r1q6uy as num_fromAsciiBytesRadixImpl$0r1q6uy, fromAsciiBytesRadixImpl$0q4dbht as num_fromAsciiBytesRadixImpl$0q4dbht, fromAsciiBytesRadixImpl$1xmrosk as num_fromAsciiBytesRadixImpl$1xmrosk, fromAsciiBytesRadixImpl$02xpj41 as num_fromAsciiBytesRadixImpl$02xpj41, fromAsciiBytesRadixImpl$037x42t as num_fromAsciiBytesRadixImpl$037x42t, fromAsciiBytesRadixImpl$1cdwgun as num_fromAsciiBytesRadixImpl$1cdwgun } from "../../core/num.ts"; +import * as rs from "../../rs.ts"; +import { fromAsciiBytesRadixImpl$1r0rye7 as num_fromAsciiBytesRadixImpl$1r0rye7, fromAsciiBytesRadixImpl$1gthu8q as num_fromAsciiBytesRadixImpl$1gthu8q, fromAsciiBytesRadixImpl$07oe1fj as num_fromAsciiBytesRadixImpl$07oe1fj, fromAsciiBytesRadixImpl$0wzunhe as num_fromAsciiBytesRadixImpl$0wzunhe, fromAsciiBytesRadixImpl$1amlmta as num_fromAsciiBytesRadixImpl$1amlmta, fromAsciiBytesRadixImpl$0d7us41 as num_fromAsciiBytesRadixImpl$0d7us41, fromAsciiBytesRadixImpl$0paozdl as num_fromAsciiBytesRadixImpl$0paozdl, fromAsciiBytesRadixImpl$0wd05by as num_fromAsciiBytesRadixImpl$0wd05by, fromAsciiBytesRadixImpl$15o252c as num_fromAsciiBytesRadixImpl$15o252c, fromAsciiBytesRadixImpl$0zwqu7x as num_fromAsciiBytesRadixImpl$0zwqu7x, fromAsciiBytesRadixImpl$1djtuzq as num_fromAsciiBytesRadixImpl$1djtuzq, fromAsciiBytesRadixImpl$1lirmeu as num_fromAsciiBytesRadixImpl$1lirmeu } from "../../core/num.ts"; -export function fromAsciiBytesRadixImpl$046b3ez(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$037x42t(src, radix); +export function fromAsciiBytesRadixImpl$0r9te78(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$1djtuzq(src, radix); if (_3.ok) { - const _7: rt.u8 | undefined = rt.nonZero(_3.value); + const _7: rs.u8 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1ka76tk(src: string): rt.Result { - return fromStrRadix$1c1a5i0(src, 10); +export function fromStr$1ikft6y(src: string): rs.Result { + return fromStrRadix$1i96daa(src, 10); } -export function fromStrRadix$1c1a5i0(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$046b3ez(rt.stringAsBytes(src), radix); +export function fromStrRadix$1i96daa(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0r9te78(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0yik78r(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0q4dbht(src, radix); +export function fromAsciiBytesRadixImpl$13nvchx(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$0wd05by(src, radix); if (_3.ok) { - const _7: rt.u16 | undefined = rt.nonZero(_3.value); + const _7: rs.u16 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1bidi2n(src: string): rt.Result { - return fromStrRadix$13ngn1e(src, 10); +export function fromStr$0t2qzou(src: string): rs.Result { + return fromStrRadix$0yk2yqd(src, 10); } -export function fromStrRadix$13ngn1e(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0yik78r(rt.stringAsBytes(src), radix); +export function fromStrRadix$0yk2yqd(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$13nvchx(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1e6dyne(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1xmrosk(src, radix); +export function fromAsciiBytesRadixImpl$0x21uh8(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$15o252c(src, radix); if (_3.ok) { - const _7: rt.u32 | undefined = rt.nonZero(_3.value); + const _7: rs.u32 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$0pscojv(src: string): rt.Result { - return fromStrRadix$14vzugb(src, 10); +export function fromStr$1qv4pqe(src: string): rs.Result { + return fromStrRadix$1y934te(src, 10); } -export function fromStrRadix$14vzugb(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1e6dyne(rt.stringAsBytes(src), radix); +export function fromStrRadix$1y934te(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0x21uh8(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0573ey0(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$02xpj41(src, radix); +export function fromAsciiBytesRadixImpl$0o0mci3(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$0zwqu7x(src, radix); if (_3.ok) { - const _7: rt.u64 | undefined = rt.nonZero(_3.value); + const _7: rs.u64 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$19lq810(src: string): rt.Result { - return fromStrRadix$1u3fi38(src, 10); +export function fromStr$1xddfo8(src: string): rs.Result { + return fromStrRadix$11u1rq7(src, 10); } -export function fromStrRadix$1u3fi38(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0573ey0(rt.stringAsBytes(src), radix); +export function fromStrRadix$11u1rq7(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0o0mci3(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$09eombh(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0r1q6uy(src, radix); +export function fromAsciiBytesRadixImpl$09hhvay(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$0paozdl(src, radix); if (_3.ok) { - const _7: rt.u128 | undefined = rt.nonZero(_3.value); + const _7: rs.u128 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1lyc2jq(src: string): rt.Result { - return fromStrRadix$0yvapq5(src, 10); +export function fromStr$06q0lw7(src: string): rs.Result { + return fromStrRadix$1ejhcoz(src, 10); } -export function fromStrRadix$0yvapq5(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$09eombh(rt.stringAsBytes(src), radix); +export function fromStrRadix$1ejhcoz(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$09hhvay(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0fwjjdv(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1cdwgun(src, radix); +export function fromAsciiBytesRadixImpl$0s0l7fv(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$1lirmeu(src, radix); if (_3.ok) { - const _7: rt.usize | undefined = rt.nonZero(_3.value); + const _7: rs.usize | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$0b146n7(src: string): rt.Result { - return fromStrRadix$0tal612(src, 10); +export function fromStr$0tn1xwn(src: string): rs.Result { + return fromStrRadix$1dc88z1(src, 10); } -export function fromStrRadix$0tal612(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0fwjjdv(rt.stringAsBytes(src), radix); +export function fromStrRadix$1dc88z1(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0s0l7fv(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1xnyrsk(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0k9pjln(src, radix); +export function fromAsciiBytesRadixImpl$13whx25(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$1amlmta(src, radix); if (_3.ok) { - const _7: rt.i8 | undefined = rt.nonZero(_3.value); + const _7: rs.i8 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1uo2nx5(src: string): rt.Result { - return fromStrRadix$0cahq64(src, 10); +export function fromStr$0h6taf0(src: string): rs.Result { + return fromStrRadix$011a32r(src, 10); } -export function fromStrRadix$0cahq64(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1xnyrsk(rt.stringAsBytes(src), radix); +export function fromStrRadix$011a32r(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$13whx25(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1ju244m(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0ut8llb(src, radix); +export function fromAsciiBytesRadixImpl$1ah3ln3(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$1gthu8q(src, radix); if (_3.ok) { - const _7: rt.i16 | undefined = rt.nonZero(_3.value); + const _7: rs.i16 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$05o7gm9(src: string): rt.Result { - return fromStrRadix$10ztqkr(src, 10); +export function fromStr$157gku3(src: string): rs.Result { + return fromStrRadix$1u0zwz8(src, 10); } -export function fromStrRadix$10ztqkr(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1ju244m(rt.stringAsBytes(src), radix); +export function fromStrRadix$1u0zwz8(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1ah3ln3(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0w0p9k6(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1ykgy6m(src, radix); +export function fromAsciiBytesRadixImpl$1ckzdqg(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$07oe1fj(src, radix); if (_3.ok) { - const _7: rt.i32 | undefined = rt.nonZero(_3.value); + const _7: rs.i32 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1cmdtf2(src: string): rt.Result { - return fromStrRadix$1vk8c0u(src, 10); +export function fromStr$13j6y8p(src: string): rs.Result { + return fromStrRadix$1m6epfo(src, 10); } -export function fromStrRadix$1vk8c0u(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0w0p9k6(rt.stringAsBytes(src), radix); +export function fromStrRadix$1m6epfo(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1ckzdqg(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$1tchpbx(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$01tfvb9(src, radix); +export function fromAsciiBytesRadixImpl$1cym2i5(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$0wzunhe(src, radix); if (_3.ok) { - const _7: rt.i64 | undefined = rt.nonZero(_3.value); + const _7: rs.i64 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$10p52cj(src: string): rt.Result { - return fromStrRadix$0ebk8xe(src, 10); +export function fromStr$1crondi(src: string): rs.Result { + return fromStrRadix$15i0o2z(src, 10); } -export function fromStrRadix$0ebk8xe(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$1tchpbx(rt.stringAsBytes(src), radix); +export function fromStrRadix$15i0o2z(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$1cym2i5(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0naj586(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$0xhcrxt(src, radix); +export function fromAsciiBytesRadixImpl$0gvfhkf(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$1r0rye7(src, radix); if (_3.ok) { - const _7: rt.i128 | undefined = rt.nonZero(_3.value); + const _7: rs.i128 | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$081k88g(src: string): rt.Result { - return fromStrRadix$17xzbib(src, 10); +export function fromStr$0q2xzd0(src: string): rs.Result { + return fromStrRadix$09x3avk(src, 10); } -export function fromStrRadix$17xzbib(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0naj586(rt.stringAsBytes(src), radix); +export function fromStrRadix$09x3avk(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0gvfhkf(rs.stringAsBytes(src), radix); } -export function fromAsciiBytesRadixImpl$0c07bbl(src: rt.ByteSlice, radix: rt.u32): rt.Result { - const _3: rt.Result = num_fromAsciiBytesRadixImpl$1hpkcx2(src, radix); +export function fromAsciiBytesRadixImpl$0vdgdur(src: rs.ByteSlice, radix: rs.u32): rs.Result { + const _3: rs.Result = num_fromAsciiBytesRadixImpl$0d7us41(src, radix); if (_3.ok) { - const _7: rt.isize | undefined = rt.nonZero(_3.value); + const _7: rs.isize | undefined = rs.nonZero(_3.value); if (_7 !== undefined) { - return rt.Ok(_7); + return rs.Ok(_7); } - return rt.Err({ kind: "Zero" as rt.IntErrorKind }); + return rs.Err({ kind: "Zero" as rs.IntErrorKind }); } return _3; } -export function fromStr$1nddmw0(src: string): rt.Result { - return fromStrRadix$07izbug(src, 10); +export function fromStr$0bvulbz(src: string): rs.Result { + return fromStrRadix$1jg523s(src, 10); } -export function fromStrRadix$07izbug(src: string, radix: rt.u32): rt.Result { - return fromAsciiBytesRadixImpl$0c07bbl(rt.stringAsBytes(src), radix); +export function fromStrRadix$1jg523s(src: string, radix: rs.u32): rs.Result { + return fromAsciiBytesRadixImpl$0vdgdur(rs.stringAsBytes(src), radix); } //# sourceMappingURL=nonzero.ts.map diff --git a/ts/fixtures/lang/strs/expected/core/option.ts b/ts/fixtures/lang/strs/expected/core/option.ts index 5edc961eb..7c67d11b9 100644 --- a/ts/fixtures/lang/strs/expected/core/option.ts +++ b/ts/fixtures/lang/strs/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1rbuegs(self: rt.ByteSlice | undefined, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$0yvilko(self: rs.ByteSlice | undefined, default_: rs.ByteSlice): rs.ByteSlice { if (self === undefined) { return default_; } @@ -16,28 +16,28 @@ export function unwrapOr$1iemzn8(self: string | undefined, default_: string): st return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$0gl6wke(self: [rt.usize, string] | undefined, f: (a0: [rt.usize, string]) => string): string | undefined { +export function map$0h0w6xi(self: [rs.usize, string] | undefined, f: (a0: [rs.usize, string]) => string): string | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$16umieg(self: [rt.usize, string] | undefined, default_: rt.usize, f: (a0: [rt.usize, string]) => rt.usize): rt.usize { +export function mapOr$1wbabuw(self: [rs.usize, string] | undefined, default_: rs.usize, f: (a0: [rs.usize, string]) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$147z9gi(self: rt.usize | undefined, default_: string, f: (a0: rt.usize) => string): string { +export function mapOr$19xt0tb(self: rs.usize | undefined, default_: string, f: (a0: rs.usize) => string): string { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/strs/expected/core/str.ts b/ts/fixtures/lang/strs/expected/core/str.ts index a08f495ee..075ee75a3 100644 --- a/ts/fixtures/lang/strs/expected/core/str.ts +++ b/ts/fixtures/lang/strs/expected/core/str.ts @@ -1,59 +1,59 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { fromStr$1ka76tk as nonzero_fromStr$1ka76tk, fromStr$1bidi2n as nonzero_fromStr$1bidi2n, fromStr$0pscojv as nonzero_fromStr$0pscojv, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStr$0b146n7 as nonzero_fromStr$0b146n7, fromStr$1uo2nx5 as nonzero_fromStr$1uo2nx5, fromStr$05o7gm9 as nonzero_fromStr$05o7gm9, fromStr$1cmdtf2 as nonzero_fromStr$1cmdtf2, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStr$081k88g as nonzero_fromStr$081k88g, fromStr$1nddmw0 as nonzero_fromStr$1nddmw0 } from "../core/num/nonzero.ts"; -import { fromStr$05d44vn as traits_fromStr$05d44vn } from "../core/str/traits.ts"; +import * as rs from "../rs.ts"; +import { fromStr$1ikft6y as nonzero_fromStr$1ikft6y, fromStr$0t2qzou as nonzero_fromStr$0t2qzou, fromStr$1qv4pqe as nonzero_fromStr$1qv4pqe, fromStr$1xddfo8 as nonzero_fromStr$1xddfo8, fromStr$06q0lw7 as nonzero_fromStr$06q0lw7, fromStr$0tn1xwn as nonzero_fromStr$0tn1xwn, fromStr$0h6taf0 as nonzero_fromStr$0h6taf0, fromStr$157gku3 as nonzero_fromStr$157gku3, fromStr$13j6y8p as nonzero_fromStr$13j6y8p, fromStr$1crondi as nonzero_fromStr$1crondi, fromStr$0q2xzd0 as nonzero_fromStr$0q2xzd0, fromStr$0bvulbz as nonzero_fromStr$0bvulbz } from "../core/num/nonzero.ts"; +import { fromStr$1dw9076 as traits_fromStr$1dw9076 } from "../core/str/traits.ts"; -export function parse$0vh4cry(self: string): rt.Result { - return traits_fromStr$05d44vn(self); +export function parse$1yfzdza(self: string): rs.Result { + return traits_fromStr$1dw9076(self); } -export function parse$1bh1yup(self: string): rt.Result { - return nonzero_fromStr$081k88g(self); +export function parse$1d17hvd(self: string): rs.Result { + return nonzero_fromStr$0q2xzd0(self); } -export function parse$08t7361(self: string): rt.Result { - return nonzero_fromStr$05o7gm9(self); +export function parse$0wntisu(self: string): rs.Result { + return nonzero_fromStr$157gku3(self); } -export function parse$0bf4pzp(self: string): rt.Result { - return nonzero_fromStr$1cmdtf2(self); +export function parse$18h4mna(self: string): rs.Result { + return nonzero_fromStr$13j6y8p(self); } -export function parse$00wf0ig(self: string): rt.Result { - return nonzero_fromStr$10p52cj(self); +export function parse$1gh8p0t(self: string): rs.Result { + return nonzero_fromStr$1crondi(self); } -export function parse$0wtmhwf(self: string): rt.Result { - return nonzero_fromStr$1uo2nx5(self); +export function parse$0jsh5gh(self: string): rs.Result { + return nonzero_fromStr$0h6taf0(self); } -export function parse$11q43n4(self: string): rt.Result { - return nonzero_fromStr$1nddmw0(self); +export function parse$09069e1(self: string): rs.Result { + return nonzero_fromStr$0bvulbz(self); } -export function parse$0y8gj7z(self: string): rt.Result { - return nonzero_fromStr$1lyc2jq(self); +export function parse$0j8ztlu(self: string): rs.Result { + return nonzero_fromStr$06q0lw7(self); } -export function parse$00ea569(self: string): rt.Result { - return nonzero_fromStr$1bidi2n(self); +export function parse$13tnb7e(self: string): rs.Result { + return nonzero_fromStr$0t2qzou(self); } -export function parse$00ibreq(self: string): rt.Result { - return nonzero_fromStr$0pscojv(self); +export function parse$04z9euf(self: string): rs.Result { + return nonzero_fromStr$1qv4pqe(self); } -export function parse$129b0a7(self: string): rt.Result { - return nonzero_fromStr$19lq810(self); +export function parse$1fob3ck(self: string): rs.Result { + return nonzero_fromStr$1xddfo8(self); } -export function parse$0r5638o(self: string): rt.Result { - return nonzero_fromStr$1ka76tk(self); +export function parse$1y4njjc(self: string): rs.Result { + return nonzero_fromStr$1ikft6y(self); } -export function parse$1kzahs9(self: string): rt.Result { - return nonzero_fromStr$0b146n7(self); +export function parse$1acldxi(self: string): rs.Result { + return nonzero_fromStr$0tn1xwn(self); } //# sourceMappingURL=str.ts.map diff --git a/ts/fixtures/lang/strs/expected/core/str/traits.ts b/ts/fixtures/lang/strs/expected/core/str/traits.ts index ecae3ef54..bf0ccbaec 100644 --- a/ts/fixtures/lang/strs/expected/core/str/traits.ts +++ b/ts/fixtures/lang/strs/expected/core/str/traits.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function fromStr$05d44vn(s: string): rt.Result { +export function fromStr$1dw9076(s: string): rs.Result { if (!(s === "true")) { if (!(s === "false")) { - return rt.Err(new rt.ParseBoolError()); + return rs.Err(new rs.ParseBoolError()); } - return rt.Ok(false); + return rs.Ok(false); } - return rt.Ok(true); + return rs.Ok(true); } //# sourceMappingURL=traits.ts.map diff --git a/ts/fixtures/lang/strs/expected/harness.ts b/ts/fixtures/lang/strs/expected/harness.ts index b6b350c07..78fad7cd8 100644 --- a/ts/fixtures/lang/strs/expected/harness.ts +++ b/ts/fixtures/lang/strs/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,44 +18,44 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } /** A char of the alphabet for each byte, by its low bits. */ -export function text(data: rt.ByteSlice): string { +export function text(data: rs.ByteSlice): string { let s: string = ""; - const iterS: Uint8Array = rt.byteSliceView(data); + const iterS: Uint8Array = rs.byteSliceView(data); let iterI: number = 0; while (true) { - const _5: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_5 === rt.DONE) { + const _5: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_5 === rs.DONE) { return s; } - const _13: rt.usize = rt.u8Rem(_5, 16) as rt.usize; + const _13: rs.usize = rs.u8Rem(_5, 16) as rs.usize; if (!(_13 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _13); } s = s + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_13]); } diff --git a/ts/fixtures/lang/strs/expected/lib.ts b/ts/fixtures/lang/strs/expected/lib.ts index 64687d90d..f7600b2f5 100644 --- a/ts/fixtures/lang/strs/expected/lib.ts +++ b/ts/fixtures/lang/strs/expected/lib.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { strs, slices, edits, parses, iters, drains, hinted, gets, unicode, utf16 } from "./strs.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["strs::strs", strs as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::slices", slices as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::edits", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["strs::strs", strs as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::slices", slices as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::edits", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { edits(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::parses", parses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::iters", iters as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::drains", (a02: rt.u8, a12: rt.ByteSlice, a22: rt.ByteVec): undefined => { + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::parses", parses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::iters", iters as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::drains", (a02: rs.u8, a12: rs.ByteSlice, a22: rs.ByteVec): undefined => { drains(a02, a12.data, a12.start, a12.length, a22); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::gets", gets as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::unicode", unicode as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["strs::utf16", utf16 as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::hinted", hinted as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::gets", gets as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::unicode", unicode as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["strs::utf16", utf16 as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/strs/expected/strs.Counted.ts b/ts/fixtures/lang/strs/expected/strs.Counted.ts index e96c71263..74397f189 100644 --- a/ts/fixtures/lang/strs/expected/strs.Counted.ts +++ b/ts/fixtures/lang/strs/expected/strs.Counted.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A crate's own iterator over `items`, which counts each `next` it is asked. */ export interface Counted { - items: rt.SliceOf; - nexts: rt.Cell; + items: rs.SliceOf; + nexts: rs.Cell; } -export function next$iter_Iterator_String(self: Counted): string | rt.Done { - rt.cellSet(self.nexts, rt.u8Add(self.nexts.v, 1)); - const _8: [string, string[]] | undefined = rt.sliceSplitFirst(self.items as string[]); +export function next$iter_Iterator_String(self: Counted): string | rs.Done { + rs.cellSet(self.nexts, rs.u8Add(self.nexts.v, 1)); + const _8: [string, string[]] | undefined = rs.sliceSplitFirst(self.items as string[]); if (_8 !== undefined) { const val: [string, string[]] = _8; (self.items as string[]) = val[1]; return val[0]; } - return rt.DONE; + return rs.DONE; } -export function next$iter_Iterator_char(self: Counted): rt.char | rt.Done { - rt.cellSet(self.nexts, rt.u8Add(self.nexts.v, 1)); - const _8: [rt.char, rt.char[]] | undefined = rt.sliceSplitFirst(self.items as rt.char[]); +export function next$iter_Iterator_char(self: Counted): rs.char | rs.Done { + rs.cellSet(self.nexts, rs.u8Add(self.nexts.v, 1)); + const _8: [rs.char, rs.char[]] | undefined = rs.sliceSplitFirst(self.items as rs.char[]); if (_8 !== undefined) { - const val: [rt.char, rt.char[]] = _8; - (self.items as rt.char[]) = val[1]; + const val: [rs.char, rs.char[]] = _8; + (self.items as rs.char[]) = val[1]; return val[0]; } - return rt.DONE; + return rs.DONE; } -export function next$iter_Iterator_ref_str(self: Counted): string | rt.Done { - rt.cellSet(self.nexts, rt.u8Add(self.nexts.v, 1)); - const _8: [string, string[]] | undefined = rt.sliceSplitFirst(self.items as string[]); +export function next$iter_Iterator_ref_str(self: Counted): string | rs.Done { + rs.cellSet(self.nexts, rs.u8Add(self.nexts.v, 1)); + const _8: [string, string[]] | undefined = rs.sliceSplitFirst(self.items as string[]); if (_8 !== undefined) { const val: [string, string[]] = _8; (self.items as string[]) = val[1]; return val[0]; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=strs.Counted.ts.map diff --git a/ts/fixtures/lang/strs/expected/strs.Named.ts b/ts/fixtures/lang/strs/expected/strs.Named.ts index 6d8315873..029969cd5 100644 --- a/ts/fixtures/lang/strs/expected/strs.Named.ts +++ b/ts/fixtures/lang/strs/expected/strs.Named.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Named { name: string; } -export function add(self: Named, c: rt.char): void { +export function add(self: Named, c: rs.char): void { self.name = self.name + String.fromCodePoint(c); } diff --git a/ts/fixtures/lang/strs/expected/strs.ts b/ts/fixtures/lang/strs/expected/strs.ts index e7e81a0b3..4cf094079 100644 --- a/ts/fixtures/lang/strs/expected/strs.ts +++ b/ts/fixtures/lang/strs/expected/strs.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { then$0havnzo } from "./core/bool.ts"; -import { fromStr$1ka76tk as nonzero_fromStr$1ka76tk, fromStrRadix$1c1a5i0 as nonzero_fromStrRadix$1c1a5i0, fromStr$1bidi2n as nonzero_fromStr$1bidi2n, fromStrRadix$13ngn1e as nonzero_fromStrRadix$13ngn1e, fromStr$0pscojv as nonzero_fromStr$0pscojv, fromStrRadix$14vzugb as nonzero_fromStrRadix$14vzugb, fromStr$19lq810 as nonzero_fromStr$19lq810, fromStrRadix$1u3fi38 as nonzero_fromStrRadix$1u3fi38, fromStr$1lyc2jq as nonzero_fromStr$1lyc2jq, fromStrRadix$0yvapq5 as nonzero_fromStrRadix$0yvapq5, fromStr$0b146n7 as nonzero_fromStr$0b146n7, fromStrRadix$0tal612 as nonzero_fromStrRadix$0tal612, fromStr$1uo2nx5 as nonzero_fromStr$1uo2nx5, fromStrRadix$0cahq64 as nonzero_fromStrRadix$0cahq64, fromStr$05o7gm9 as nonzero_fromStr$05o7gm9, fromStrRadix$10ztqkr as nonzero_fromStrRadix$10ztqkr, fromStr$1cmdtf2 as nonzero_fromStr$1cmdtf2, fromStrRadix$1vk8c0u as nonzero_fromStrRadix$1vk8c0u, fromStr$10p52cj as nonzero_fromStr$10p52cj, fromStrRadix$0ebk8xe as nonzero_fromStrRadix$0ebk8xe, fromStr$081k88g as nonzero_fromStr$081k88g, fromStrRadix$17xzbib as nonzero_fromStrRadix$17xzbib, fromStr$1nddmw0 as nonzero_fromStr$1nddmw0, fromStrRadix$07izbug as nonzero_fromStrRadix$07izbug } from "./core/num/nonzero.ts"; -import { unwrapOr$1rbuegs as option_unwrapOr$1rbuegs, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$0gl6wke as option_map$0gl6wke, mapOr$16umieg as option_mapOr$16umieg, mapOr$147z9gi as option_mapOr$147z9gi } from "./core/option.ts"; -import { parse$0vh4cry, parse$1bh1yup, parse$08t7361, parse$0bf4pzp, parse$00wf0ig, parse$0wtmhwf, parse$11q43n4, parse$0y8gj7z, parse$00ea569, parse$00ibreq, parse$129b0a7, parse$0r5638o, parse$1kzahs9 } from "./core/str.ts"; -import { fromStr$05d44vn as traits_fromStr$05d44vn } from "./core/str/traits.ts"; +import { fromStr$1ikft6y as nonzero_fromStr$1ikft6y, fromStrRadix$1i96daa as nonzero_fromStrRadix$1i96daa, fromStr$0t2qzou as nonzero_fromStr$0t2qzou, fromStrRadix$0yk2yqd as nonzero_fromStrRadix$0yk2yqd, fromStr$1qv4pqe as nonzero_fromStr$1qv4pqe, fromStrRadix$1y934te as nonzero_fromStrRadix$1y934te, fromStr$1xddfo8 as nonzero_fromStr$1xddfo8, fromStrRadix$11u1rq7 as nonzero_fromStrRadix$11u1rq7, fromStr$06q0lw7 as nonzero_fromStr$06q0lw7, fromStrRadix$1ejhcoz as nonzero_fromStrRadix$1ejhcoz, fromStr$0tn1xwn as nonzero_fromStr$0tn1xwn, fromStrRadix$1dc88z1 as nonzero_fromStrRadix$1dc88z1, fromStr$0h6taf0 as nonzero_fromStr$0h6taf0, fromStrRadix$011a32r as nonzero_fromStrRadix$011a32r, fromStr$157gku3 as nonzero_fromStr$157gku3, fromStrRadix$1u0zwz8 as nonzero_fromStrRadix$1u0zwz8, fromStr$13j6y8p as nonzero_fromStr$13j6y8p, fromStrRadix$1m6epfo as nonzero_fromStrRadix$1m6epfo, fromStr$1crondi as nonzero_fromStr$1crondi, fromStrRadix$15i0o2z as nonzero_fromStrRadix$15i0o2z, fromStr$0q2xzd0 as nonzero_fromStr$0q2xzd0, fromStrRadix$09x3avk as nonzero_fromStrRadix$09x3avk, fromStr$0bvulbz as nonzero_fromStr$0bvulbz, fromStrRadix$1jg523s as nonzero_fromStrRadix$1jg523s } from "./core/num/nonzero.ts"; +import { unwrapOr$0yvilko as option_unwrapOr$0yvilko, unwrapOr$1iemzn8 as option_unwrapOr$1iemzn8, unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$0h0w6xi as option_map$0h0w6xi, mapOr$1wbabuw as option_mapOr$1wbabuw, mapOr$19xt0tb as option_mapOr$19xt0tb } from "./core/option.ts"; +import { parse$1yfzdza, parse$1d17hvd, parse$0wntisu, parse$18h4mna, parse$1gh8p0t, parse$0jsh5gh, parse$09069e1, parse$0j8ztlu, parse$13tnb7e, parse$04z9euf, parse$1fob3ck, parse$1y4njjc, parse$1acldxi } from "./core/str.ts"; +import { fromStr$1dw9076 as traits_fromStr$1dw9076 } from "./core/str/traits.ts"; import { put, text } from "./harness.ts"; import * as Counted from "./strs.Counted.ts"; import * as Named from "./strs.Named.ts"; /** Whether the `i`th step reads from the back: by the byte's high bit. */ -export function fromBack(data: rt.ByteSlice, i: rt.usize): boolean { - const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); +export function fromBack(data: rs.ByteSlice, i: rs.usize): boolean { + const _3: rs.u8 | undefined = rs.byteSliceGet(data, i); if (_3 !== undefined) { if ((_3 & 128) !== 0) { return true; @@ -21,103 +21,103 @@ export function fromBack(data: rt.ByteSlice, i: rt.usize): boolean { return false; } -export function putChar(out: rt.ByteVec, c: rt.char | undefined): void { +export function putChar(out: rs.ByteVec, c: rs.char | undefined): void { if (c === undefined) { - rt.byteVecPush(out, 255); + rs.byteVecPush(out, 255); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(c as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(c as rs.u32))); } } -export function putOffset(out: rt.ByteVec, i: rt.usize | undefined): void { +export function putOffset(out: rs.ByteVec, i: rs.usize | undefined): void { if (i === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(i as rt.u32))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(i as rs.u32))); } } /** What a predicate saw, then where it stopped. */ -export function putSeen(out: rt.ByteVec, seen: rt.char[]): void { +export function putSeen(out: rs.ByteVec, seen: rs.char[]): void { for (const _5 of seen) { putChar(out, _5); } - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } -export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let c!: rt.char | undefined; +export function strs(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let c!: rs.char | undefined; let part!: string | undefined; let part3!: string | undefined; let part5!: string | undefined; - let item!: [rt.usize, string] | undefined; - let _260!: rt.char; + let item!: [rs.usize, string] | undefined; + let _260!: rs.char; const s: string = text(data); - const _7: rt.usize = rt.u8Rem(rt.u8Div(kind, 8), 16) as rt.usize; + const _7: rs.usize = rs.u8Rem(rs.u8Div(kind, 8), 16) as rs.usize; if (!(_7 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _7); } - const sep: rt.char = [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_7]; + const sep: rs.char = [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_7]; b0: { - const _13: rt.u8 = rt.u8Rem(kind, 8); + const _13: rs.u8 = rs.u8Rem(kind, 8); if (_13 === 0) { - const it: rt.Iter = rt.strChars(s); - let i: rt.usize = 0; + const it: rs.Iter = rs.strChars(s); + let i: rs.usize = 0; while (true) { if (!fromBack(data, i)) { - c = rt.iterToOption(it.next()); + c = rs.iterToOption(it.next()); } else { - c = rt.iterToOption(it.nextBack()); + c = rs.iterToOption(it.nextBack()); } putChar(out, c); if (!(c === undefined)) { - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } else { - rt.byteVecPush(out, rt.iterCount(rt.strChars(s)) & 0xff); - const iter: rt.Iter = rt.iterRev(rt.strChars(s)); + rs.byteVecPush(out, rs.iterCount(rs.strChars(s)) & 0xff); + const iter: rs.Iter = rs.iterRev(rs.strChars(s)); while (true) { - const _41: rt.char | rt.Done = iter.next(); - if (_41 === rt.DONE) { + const _41: rs.char | rs.Done = iter.next(); + if (_41 === rs.DONE) { break; } - rt.byteVecPush(out, rt.isAsciiDigit(_41) ? 1 : 0); + rs.byteVecPush(out, rs.isAsciiDigit(_41) ? 1 : 0); } - rt.byteVecPush(out, s.length === 0 ? 1 : 0); - rt.byteVecPush(out, s.length === 0 ? 1 : 0); + rs.byteVecPush(out, s.length === 0 ? 1 : 0); + rs.byteVecPush(out, s.length === 0 ? 1 : 0); break b0; } } } if (_13 === 1) { - const parts: rt.Iter = rt.strSplit(s, String.fromCodePoint(sep)); - let i2: rt.usize = 0; + const parts: rs.Iter = rs.strSplit(s, String.fromCodePoint(sep)); + let i2: rs.usize = 0; while (true) { if (!fromBack(data, i2)) { - part = rt.iterToOption(parts.next()); + part = rs.iterToOption(parts.next()); } else { - part = rt.iterToOption(parts.nextBack()); + part = rs.iterToOption(parts.nextBack()); } if (part !== undefined) { const part2: string = part; put(out, part2); - rt.byteVecPush(out, rt.stringLen(part2) & 0xff); - i2 = rt.usizeAdd(i2, 1); + rs.byteVecPush(out, rs.stringLen(part2) & 0xff); + i2 = rs.usizeAdd(i2, 1); } else { - rt.byteVecPush(out, i2 & 0xff); - put(out, option_unwrapOr$1iemzn8(rt.iterToOption(rt.strSplit(s, String.fromCodePoint(sep)).next()), "none")); - const parts2: rt.Iter = rt.strSplitTerminator(s, String.fromCodePoint(sep)); - let i3: rt.usize = 0; + rs.byteVecPush(out, i2 & 0xff); + put(out, option_unwrapOr$1iemzn8(rs.iterToOption(rs.strSplit(s, String.fromCodePoint(sep)).next()), "none")); + const parts2: rs.Iter = rs.strSplitTerminator(s, String.fromCodePoint(sep)); + let i3: rs.usize = 0; while (true) { if (!fromBack(data, i3)) { - part3 = rt.iterToOption(parts2.next()); + part3 = rs.iterToOption(parts2.next()); } else { - part3 = rt.iterToOption(parts2.nextBack()); + part3 = rs.iterToOption(parts2.nextBack()); } if (part3 !== undefined) { put(out, part3); - i3 = rt.usizeAdd(i3, 1); + i3 = rs.usizeAdd(i3, 1); } else { - rt.byteVecPush(out, i3 & 0xff); + rs.byteVecPush(out, i3 & 0xff); break b0; } } @@ -125,24 +125,24 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } if (_13 === 2) { - const seen: rt.Vec = new rt.Vec(); - const parts3: rt.Iter = rt.strSplit(s, (c9: rt.char): boolean => { + const seen: rs.Vec = new rs.Vec(); + const parts3: rs.Iter = rs.strSplit(s, (c9: rs.char): boolean => { seen.items.push(c9); if (!(c9 === sep)) { - return rt.isAsciiDigit(c9); + return rs.isAsciiDigit(c9); } return true; }); - let i4: rt.usize = 0; + let i4: rs.usize = 0; while (true) { if (!fromBack(data, i4)) { - part5 = rt.iterToOption(parts3.next()); + part5 = rs.iterToOption(parts3.next()); } else { - part5 = rt.iterToOption(parts3.nextBack()); + part5 = rs.iterToOption(parts3.nextBack()); } if (part5 !== undefined) { put(out, part5); - i4 = rt.usizeAdd(i4, 1); + i4 = rs.usizeAdd(i4, 1); } else { putSeen(out, seen.items); break b0; @@ -150,57 +150,57 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } if (_13 === 3) { - put(out, rt.strTrimStartMatches(s, String.fromCodePoint(sep))); - put(out, rt.strTrimEndMatches(s, String.fromCodePoint(sep))); - put(out, rt.strTrimEndMatches(rt.strTrimStartMatches(s, String.fromCodePoint(sep)), String.fromCodePoint(sep))); - rt.byteVecPush(out, rt.strStartsWith(s, String.fromCodePoint(sep)) ? 1 : 0); - putOffset(out, rt.strRfind(s, String.fromCodePoint(sep))); - const _143: [string, string] | undefined = rt.strRsplitOnce(s, String.fromCodePoint(sep)); + put(out, rs.strTrimStartMatches(s, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(s, String.fromCodePoint(sep))); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, String.fromCodePoint(sep)), String.fromCodePoint(sep))); + rs.byteVecPush(out, rs.strStartsWith(s, String.fromCodePoint(sep)) ? 1 : 0); + putOffset(out, rs.strRfind(s, String.fromCodePoint(sep))); + const _143: [string, string] | undefined = rs.strRsplitOnce(s, String.fromCodePoint(sep)); if (_143 === undefined) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { put(out, _143[0]); put(out, _143[1]); } } else if (_13 === 4) { - const seen2: rt.Vec = new rt.Vec(); - put(out, rt.strTrimStartMatches(s, (c5: rt.char): boolean => { + const seen2: rs.Vec = new rs.Vec(); + put(out, rs.strTrimStartMatches(s, (c5: rs.char): boolean => { seen2.items.push(c5); return c5 === sep; })); putSeen(out, seen2.items); - put(out, rt.strTrimEndMatches(s, (c6: rt.char): boolean => { + put(out, rs.strTrimEndMatches(s, (c6: rs.char): boolean => { seen2.items.push(c6); return c6 !== sep; })); putSeen(out, seen2.items); - rt.byteVecPush(out, rt.strStartsWith(s, (c7: rt.char): boolean => { - return rt.isAsciiDigit(c7); + rs.byteVecPush(out, rs.strStartsWith(s, (c7: rs.char): boolean => { + return rs.isAsciiDigit(c7); }) ? 1 : 0); - put(out, rt.strTrimStartMatches(s, digit)); - putOffset(out, rt.strRfind(s, (c8: rt.char): boolean => { + put(out, rs.strTrimStartMatches(s, digit)); + putOffset(out, rs.strRfind(s, (c8: rs.char): boolean => { seen2.items.push(c8); return c8 === sep; })); putSeen(out, seen2.items); } else { if (_13 === 5) { - const found2: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(s, String.fromCodePoint(sep)); - let i5: rt.usize = 0; + const found2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, String.fromCodePoint(sep)); + let i5: rs.usize = 0; while (true) { if (!fromBack(data, i5)) { - item = rt.iterToOption(found2.next()); + item = rs.iterToOption(found2.next()); } else { - item = rt.iterToOption(found2.nextBack()); + item = rs.iterToOption(found2.nextBack()); } if (item !== undefined) { - const at: rt.usize = item[0]; + const at: rs.usize = item[0]; const matched: string = item[1]; putOffset(out, at); put(out, matched); - i5 = rt.usizeAdd(i5, 1); + i5 = rs.usizeAdd(i5, 1); } else { - for (const _214 of rt.iterToVec(rt.iterMap(rt.strMatchIndices(s, "/"), (_2: [rt.usize, string]): rt.usize => { + for (const _214 of rs.iterToVec(rs.iterMap(rs.strMatchIndices(s, "/"), (_2: [rs.usize, string]): rs.usize => { return _2[0]; }), "next", 4).items) { putOffset(out, _214); @@ -210,7 +210,7 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } } if (_13 === 6) { - const parts4: rt.Vec = unescape(s); + const parts4: rs.Vec = unescape(s); for (const _226 of parts4.items) { put(out, _226); } @@ -218,26 +218,26 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { let built: string = ""; const named: Named.Named = { name: "" }; - const each: rt.Vec = rt.vecFrom(["", ""]); - const iter4: rt.Iter<[rt.usize, rt.char]> = rt.iterEnumerate(rt.strChars(s)); + const each: rs.Vec = rs.vecFrom(["", ""]); + const iter4: rs.Iter<[rs.usize, rs.char]> = rs.iterEnumerate(rs.strChars(s)); while (true) { - const _251: [rt.usize, rt.char] | rt.Done = iter4.next(); - if (_251 === rt.DONE) { + const _251: [rs.usize, rs.char] | rs.Done = iter4.next(); + if (_251 === rs.DONE) { break; } - const i6: rt.usize = _251[0]; - const c3: rt.char = _251[1]; + const i6: rs.usize = _251[0]; + const c3: rs.char = _251[1]; built = built + String.fromCodePoint(c3); - if (!(rt.usizeRem(i6, 2) === 0)) { + if (!(rs.usizeRem(i6, 2) === 0)) { _260 = sep; } else { _260 = c3; } named.name = named.name + String.fromCodePoint(_260); Named.add(named, c3); - const at2 = rt.idx(each.items, rt.usizeRem(i6, 2)); + const at2 = rs.idx(each.items, rs.usizeRem(i6, 2)); each.items[at2] = each.items[at2] + String.fromCodePoint(c3); - const _271: rt.char | undefined = rt.charFromU32(rt.u32Add(c3 as rt.u32, 1)); + const _271: rs.char | undefined = rs.charFromU32(rs.u32Add(c3 as rs.u32, 1)); if (_271 !== undefined) { built = built + String.fromCodePoint(_271); } @@ -245,19 +245,19 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { named.name = named.name + "􏿿"; put(out, built); put(out, named.name); - put(out, each.items[rt.idx(each.items, 0)]); - put(out, each.items[rt.idx(each.items, 1)]); + put(out, each.items[rs.idx(each.items, 0)]); + put(out, each.items[rs.idx(each.items, 1)]); const before: string = built; - const len: rt.usize = rt.stringLen(built); + const len: rs.usize = rs.stringLen(built); const empty: boolean = built.length === 0; built = built + String.fromCodePoint(sep); put(out, before); - rt.byteVecPush(out, len & 0xff); - rt.byteVecPush(out, empty ? 1 : 0); + rs.byteVecPush(out, len & 0xff); + rs.byteVecPush(out, empty ? 1 : 0); const taken2 = built; built = ""; put(out, taken2); - rt.byteVecPush(out, built.length === 0 ? 1 : 0); + rs.byteVecPush(out, built.length === 0 ? 1 : 0); } } } @@ -267,12 +267,12 @@ export function strs(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Up to three chars of `s`, from the char the kind's high bits pick: empty a quarter of * the time, and otherwise found at least once unless the text is shorter. */ -export function pattern(kind: rt.u8, s: string): string { +export function pattern(kind: rs.u8, s: string): string { let p: string = ""; - const iter: rt.Iter = rt.iterTake(rt.iterSkip(rt.strChars(s), rt.u8Div(kind, 32) as rt.usize), rt.u8Rem(rt.u8Div(kind, 8), 4) as rt.usize); + const iter: rs.Iter = rs.iterTake(rs.iterSkip(rs.strChars(s), rs.u8Div(kind, 32) as rs.usize), rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize); while (true) { - const _17: rt.char | rt.Done = iter.next(); - if (_17 === rt.DONE) { + const _17: rs.char | rs.Done = iter.next(); + if (_17 === rs.DONE) { return p; } p = p + String.fromCodePoint(_17); @@ -283,120 +283,120 @@ export function pattern(kind: rt.u8, s: string): string { * `&s[a..b]` by byte offsets, and the `str` methods by a `&str` pattern, which an empty * one matches before each char and after the last. */ -export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _219!: [rt.usize, rt.usize]; +export function slices(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _219!: [rs.usize, rs.usize]; let sliced!: string; const s: string = text(data); const p: string = pattern(kind, s); b0: { - const _8: rt.u8 = rt.u8Rem(kind, 8); + const _8: rs.u8 = rs.u8Rem(kind, 8); if (_8 === 0) { - let n: rt.i32 = 0; - const iter: rt.Iter = rt.strSplit(s, p); + let n: rs.i32 = 0; + const iter: rs.Iter = rs.strSplit(s, p); while (true) { - const _18: string | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: string | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } put(out, _18); - n = rt.i32Add(n, 1); + n = rs.i32Add(n, 1); } - rt.byteVecPush(out, n & 0xff); - put(out, option_unwrapOr$1iemzn8(rt.iterLast(rt.strSplit(s, p)), "none")); + rs.byteVecPush(out, n & 0xff); + put(out, option_unwrapOr$1iemzn8(rs.iterLast(rs.strSplit(s, p)), "none")); } else { if (_8 === 1) { - const iter2: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(s, p); + const iter2: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(s, p); while (true) { - const _42: [rt.usize, string] | rt.Done = iter2.next(); - if (_42 === rt.DONE) { + const _42: [rs.usize, string] | rs.Done = iter2.next(); + if (_42 === rs.DONE) { break b0; } - const at: rt.usize = _42[0]; + const at: rs.usize = _42[0]; putOffset(out, at); put(out, _42[1]); - put(out, rt.strSlice(s, 0, at)); - const part6 = rt.usizeAdd(at, rt.stringLen(_42[1])); - put(out, rt.strSlice(s, part6)); - const part7 = rt.usizeAdd(at, rt.stringLen(_42[1])); - put(out, rt.strSlice(s, at, part7)); + put(out, rs.strSlice(s, 0, at)); + const part6 = rs.usizeAdd(at, rs.stringLen(_42[1])); + put(out, rs.strSlice(s, part6)); + const part7 = rs.usizeAdd(at, rs.stringLen(_42[1])); + put(out, rs.strSlice(s, at, part7)); } } if (_8 === 2) { - put(out, rt.strTrimStartMatches(s, p)); - put(out, rt.strTrimEndMatches(s, p)); - put(out, rt.strTrimEndMatches(rt.strTrimStartMatches(s, p), p)); - rt.byteVecPush(out, rt.strStartsWith(s, p) ? 1 : 0); - rt.byteVecPush(out, rt.strContains(s, p) ? 1 : 0); - rt.byteVecPush(out, rt.strContains(s, p) ? 1 : 0); - rt.byteVecPush(out, rt.strContains(s, "/") ? 1 : 0); - rt.byteVecPush(out, rt.strContains(s, (c: rt.char): boolean => { - return rt.isAsciiDigit(c); + put(out, rs.strTrimStartMatches(s, p)); + put(out, rs.strTrimEndMatches(s, p)); + put(out, rs.strTrimEndMatches(rs.strTrimStartMatches(s, p), p)); + rs.byteVecPush(out, rs.strStartsWith(s, p) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s, p) ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s, "/") ? 1 : 0); + rs.byteVecPush(out, rs.strContains(s, (c: rs.char): boolean => { + return rs.isAsciiDigit(c); }) ? 1 : 0); - putOffset(out, rt.strRfind(s, p)); - const _123: [string, string] | undefined = rt.strRsplitOnce(s, p); + putOffset(out, rs.strRfind(s, p)); + const _123: [string, string] | undefined = rs.strRsplitOnce(s, p); if (_123 === undefined) { - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); } else { put(out, _123[0]); put(out, _123[1]); } } else { if (_8 === 3) { - const iter3: rt.Iter = rt.iterSuccessors(s, (path: string): string | undefined => { + const iter3: rs.Iter = rs.iterSuccessors(s, (path: string): string | undefined => { const _73: string = path; return then$0havnzo(!(path.length === 0), (): string => { - return option_mapOr$147z9gi(rt.strRfind(_73, "/"), "", (slash: rt.usize): string => { - return rt.strSlice(_73, 0, slash); + return option_mapOr$19xt0tb(rs.strRfind(_73, "/"), "", (slash: rs.usize): string => { + return rs.strSlice(_73, 0, slash); }); }); }); while (true) { - const _139: string | rt.Done = iter3.next(); - if (_139 === rt.DONE) { + const _139: string | rs.Done = iter3.next(); + if (_139 === rs.DONE) { break b0; } put(out, _139); } } if (_8 === 4) { - const keep: rt.usize = rt.usizeAdd(rt.u8Rem(rt.u8Div(kind, 8), 4) as rt.usize, 1); - put(out, option_unwrapOr$1iemzn8(option_map$0gl6wke(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), (_2: [rt.usize, string]): string => { - return rt.strSlice(s, 0, _2[0]); + const keep: rs.usize = rs.usizeAdd(rs.u8Rem(rs.u8Div(kind, 8), 4) as rs.usize, 1); + put(out, option_unwrapOr$1iemzn8(option_map$0h0w6xi(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), (_2: [rs.usize, string]): string => { + return rs.strSlice(s, 0, _2[0]); }), "none")); - const part5 = option_mapOr$16umieg(rt.iterNth(rt.strMatchIndices(s, "/"), rt.usizeSub(keep, 1)), rt.stringLen(s), (_22: [rt.usize, string]): rt.usize => { - return rt.usizeAdd(_22[0], 1); + const part5 = option_mapOr$1wbabuw(rs.iterNth(rs.strMatchIndices(s, "/"), rs.usizeSub(keep, 1)), rs.stringLen(s), (_22: [rs.usize, string]): rs.usize => { + return rs.usizeAdd(_22[0], 1); }); - put(out, rt.strSlice(s, part5)); + put(out, rs.strSlice(s, part5)); } else if (_8 === 5) { - const parts: rt.Vec = rt.iterToVec(rt.strSplit(s, "/"), "next", 8); - put(out, rt.strsJoin(parts.items, p)); - put(out, rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(parts.items), (part3: string): string => { + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + put(out, rs.strsJoin(parts.items, p)); + put(out, rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (part3: string): string => { return part3; }), undefined, 12, true).items, p)); - put(out, rt.strsJoin(["a", "", s], "/")); + put(out, rs.strsJoin(["a", "", s], "/")); } else { - const at2: (a0: rt.u8) => rt.usize = (b2: rt.u8): rt.usize => { + const at2: (a0: rs.u8) => rs.usize = (b2: rs.u8): rs.usize => { if ((kind & 32) === 0) { - return rt.usizeRem(b2 as rt.usize, rt.usizeAdd(rt.stringLen(s), 2)); + return rs.usizeRem(b2 as rs.usize, rs.usizeAdd(rs.stringLen(s), 2)); } - return rt.usizeSaturatingSub(rt.usizeAdd(rt.stringLen(s), 1), rt.usizeRem(b2 as rt.usize, 4)); + return rs.usizeSaturatingSub(rs.usizeAdd(rs.stringLen(s), 1), rs.usizeRem(b2 as rs.usize, 4)); }; if (!(data.length >= 2)) { - _219 = [0, 0] as [rt.usize, rt.usize]; + _219 = [0, 0] as [rs.usize, rs.usize]; } else { - _219 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rt.usize, rt.usize]; + _219 = [at2(data.data[data.start]), at2(data.data[data.start + 1])] as [rs.usize, rs.usize]; } - const a: rt.usize = _219[0]; - const b: rt.usize = _219[1]; - const _233: rt.u8 = rt.u8Rem(rt.u8Div(kind, 8), 4); + const a: rs.usize = _219[0]; + const b: rs.usize = _219[1]; + const _233: rs.u8 = rs.u8Rem(rs.u8Div(kind, 8), 4); if (_233 === 0) { - sliced = rt.strSlice(s, a, b); + sliced = rs.strSlice(s, a, b); } else if (_233 === 1) { - sliced = rt.strSlice(s, a); + sliced = rs.strSlice(s, a); } else if (_233 === 2) { - sliced = rt.strSlice(s, 0, b); + sliced = rs.strSlice(s, 0, b); } else { - sliced = rt.strSlice(s, 0); + sliced = rs.strSlice(s, 0); } put(out, sliced); } @@ -406,32 +406,32 @@ export function slices(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } /** A predicate that is a function, not a closure. */ -export function digit(c: rt.char): boolean { - return rt.isAsciiDigit(c); +export function digit(c: rs.char): boolean { + return rs.isAsciiDigit(c); } /** `/` separates parts, and `\` escapes a `/` or `\` within one. */ -export function unescape(path: string): rt.Vec { +export function unescape(path: string): rs.Vec { if (!(path.length === 0)) { - const parts: rt.Vec = new rt.Vec(); + const parts: rs.Vec = new rs.Vec(); let part: string = ""; - const chars: rt.Iter = rt.strChars(path); + const chars: rs.Iter = rs.strChars(path); while (true) { - const _7: rt.char | rt.Done = chars.next(); - if (_7 !== rt.DONE) { - const ch: rt.char = _7; + const _7: rs.char | rs.Done = chars.next(); + if (_7 !== rs.DONE) { + const ch: rs.char = _7; if (ch === 47) { const taken = part; part = ""; parts.items.push(taken); } else if (ch === 92) { - const _14: rt.char | rt.Done = chars.next(); - if (_14 === rt.DONE) { + const _14: rs.char | rs.Done = chars.next(); + if (_14 === rs.DONE) { part = part + "\\"; } else if (_14 === 47 || _14 === 92) { part = part + String.fromCodePoint(_14); } else { - const next2: rt.char = _14; + const next2: rs.char = _14; part = part + "\\"; part = part + String.fromCodePoint(next2); } @@ -445,28 +445,28 @@ export function unescape(path: string): rt.Vec { parts.items.push(part); return parts; } - return new rt.Vec(); + return new rs.Vec(); } export function escape(parts: string[]): string { let _23!: boolean; let path: string = ""; - const iter: rt.Iter<[rt.usize, string]> = rt.iterEnumerate(rt.iterSlice(parts)); + const iter: rs.Iter<[rs.usize, string]> = rs.iterEnumerate(rs.iterSlice(parts)); l1: while (true) { - const _7: [rt.usize, string] | rt.Done = iter.next(); - if (_7 === rt.DONE) { + const _7: [rs.usize, string] | rs.Done = iter.next(); + if (_7 === rs.DONE) { return path; } if (_7[0] > 0) { path = path + "/"; } - const iter2: rt.Iter = rt.strChars(_7[1]); + const iter2: rs.Iter = rs.strChars(_7[1]); while (true) { - const _19: rt.char | rt.Done = iter2.next(); - if (_19 === rt.DONE) { + const _19: rs.char | rs.Done = iter2.next(); + if (_19 === rs.DONE) { continue l1; } - const ch: rt.char = _19; + const ch: rs.char = _19; if (ch === 47 || ch === 92) { _23 = true; } else { @@ -484,57 +484,57 @@ export function escape(parts: string[]): string { * A byte offset into `s` from `b`: mostly where a char starts or the end, and otherwise * any offset up to two past the end, inside a char or out of bounds. */ -export function offset(s: string, b: rt.u8): rt.usize { - let _21!: rt.usize; +export function offset(s: string, b: rs.u8): rs.usize { + let _21!: rs.usize; if (!((b & 112) === 0)) { - let skip: rt.usize = rt.usizeRem(b as rt.usize, rt.usizeAdd(rt.iterCount(rt.strChars(s)), 1)); - const _19: rt.usize = rt.stringLen(s); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _19; + let skip: rs.usize = rs.usizeRem(b as rs.usize, rs.usizeAdd(rs.iterCount(rs.strChars(s)), 1)); + const _19: rs.usize = rs.stringLen(s); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _19; while ((_21 = iterStart++) < iterEnd) { - const i: rt.usize = _21; - if (rt.strIsCharBoundary(s, i)) { + const i: rs.usize = _21; + if (rs.strIsCharBoundary(s, i)) { if (!(skip === 0)) { - skip = rt.usizeSub(skip, 1); + skip = rs.usizeSub(skip, 1); } else { return i; } } } - return rt.stringLen(s); + return rs.stringLen(s); } - return rt.usizeRem(b as rt.usize, rt.usizeAdd(rt.stringLen(s), 3)); + return rs.usizeRem(b as rs.usize, rs.usizeAdd(rs.stringLen(s), 3)); } /** `String::retain` by a function behind a `&mut`, behind two, and boxed behind one. */ -export function retainBy(s: rt.Place, f: rt.Place<(a0: rt.char) => boolean>, how: rt.u8): void { - const _4: rt.u8 = rt.u8Rem(how, 3); +export function retainBy(s: rs.Place, f: rs.Place<(a0: rs.char) => boolean>, how: rs.u8): void { + const _4: rs.u8 = rs.u8Rem(how, 3); if (_4 === 0) { - s.v = rt.stringRetain(s.v, f.v); + s.v = rs.stringRetain(s.v, f.v); } else if (_4 === 1) { - let _7: rt.Place<(a0: rt.char) => boolean> = f; - s.v = rt.stringRetain(s.v, rt.place(() => _7, (value) => _7 = value).v.v); + let _7: rs.Place<(a0: rs.char) => boolean> = f; + s.v = rs.stringRetain(s.v, rs.place(() => _7, (value) => _7 = value).v.v); } else { - s.v = rt.stringRetain(s.v, f.v); + s.v = rs.stringRetain(s.v, f.v); } } -export function odd(c: rt.char): boolean { - return rt.u32Rem(c as rt.u32, 2) === 1; +export function odd(c: rs.char): boolean { + return rs.u32Rem(c as rs.u32, 2) === 1; } /** One edit of `s` by `op`, taking offsets and text from `a` and `b`, through a `&mut`. */ -export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt.ByteVec): void { - let capacity!: rt.usize; - const piece: string = text(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rt.u8Rem(a, 4) as rt.usize)); - const _17: [rt.usize, rt.usize] = [offset(s.v, a), offset(s.v, b)]; - const i: rt.usize = _17[0]; - const j: rt.usize = _17[1]; - const _24: rt.u8 = rt.u8Rem(op, 14); +export function edit(s: rs.Place, op: rs.u8, a: rs.u8, b: rs.u8, out: rs.ByteVec): void { + let capacity!: rs.usize; + const piece: string = text(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(a, b, a ^ b)), 0, rs.u8Rem(a, 4) as rs.usize)); + const _17: [rs.usize, rs.usize] = [offset(s.v, a), offset(s.v, b)]; + const i: rs.usize = _17[0]; + const j: rs.usize = _17[1]; + const _24: rs.u8 = rs.u8Rem(op, 14); if (_24 === 0) { s.v = s.v + piece; } else if (_24 === 1) { - const _28: rt.u8 = rt.u8Rem(b, 4); + const _28: rs.u8 = rs.u8Rem(b, 4); if (_28 === 0) { s.v = s.v + piece; } else if (_28 === 1) { @@ -546,106 +546,106 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt s.v = ""; s.v = taken + "" + piece + piece; } else { - s.v = rt.stringWithCapacity(a as rt.usize) + s.v + ""; + s.v = rs.stringWithCapacity(a as rs.usize) + s.v + ""; } } else if (_24 === 2) { - if (!(rt.u8Rem(a, 4) === 0)) { - const _59: rt.usize = rt.u8Rem(b, 16) as rt.usize; + if (!(rs.u8Rem(a, 4) === 0)) { + const _59: rs.usize = rs.u8Rem(b, 16) as rs.usize; if (!(_59 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); } s.v = s.v + String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_59]); } else { s.v = ""; } } else if (_24 === 3) { - s.v = rt.stringTruncate(s.v, i); + s.v = rs.stringTruncate(s.v, i); } else if (_24 === 4) { - const edit3 = rt.stringPop(s.v); + const edit3 = rs.stringPop(s.v); s.v = edit3[0]; putChar(out, edit3[1]); } else if (_24 === 5) { - const edit2 = rt.stringRemove(s.v, i); + const edit2 = rs.stringRemove(s.v, i); s.v = edit2[0]; putChar(out, edit2[1]); } else if (_24 === 6) { - const _68: rt.usize = rt.u8Rem(b, 16) as rt.usize; + const _68: rs.usize = rs.u8Rem(b, 16) as rs.usize; if (!(_68 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _68); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _68); } - s.v = rt.stringInsertStr(s.v, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); + s.v = rs.stringInsertStr(s.v, i, String.fromCodePoint([47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_68])); } else if (_24 === 7) { - s.v = rt.stringInsertStr(s.v, i, piece); + s.v = rs.stringInsertStr(s.v, i, piece); } else if (_24 === 8) { - if (!(rt.u8Rem(b, 2) === 1)) { - const seen: rt.Vec = new rt.Vec(); - s.v = rt.stringRetain(s.v, (c: rt.char): boolean => { + if (!(rs.u8Rem(b, 2) === 1)) { + const seen: rs.Vec = new rs.Vec(); + s.v = rs.stringRetain(s.v, (c: rs.char): boolean => { seen.items.push(c); - return rt.u32Rem(c as rt.u32, 3) !== rt.u8Rem(a, 3) as rt.u32; + return rs.u32Rem(c as rs.u32, 3) !== rs.u8Rem(a, 3) as rs.u32; }); putSeen(out, seen.items); } else { - let f: (a0: rt.char) => boolean = odd; - retainBy(s, rt.place(() => f, (value) => f = value), a); + let f: (a0: rs.char) => boolean = odd; + retainBy(s, rs.place(() => f, (value) => f = value), a); } } else if (_24 === 9) { - const edit = rt.stringSplitOff(s.v, i); + const edit = rs.stringSplitOff(s.v, i); s.v = edit[0]; put(out, edit[1]); } else if (_24 === 10) { - const _91: rt.u8 = rt.u8Rem(b, 7); + const _91: rs.u8 = rs.u8Rem(b, 7); if (_91 === 0) { - const _93: rt.Range = new rt.Range(i, j); - s.v = rt.stringReplaceRange(s.v, _93, piece); + const _93: rs.Range = new rs.Range(i, j); + s.v = rs.stringReplaceRange(s.v, _93, piece); } else if (_91 === 1) { - const _96: rt.RangeFrom = new rt.RangeFrom(i, rt.usizeStep); - s.v = rt.stringReplaceRange(s.v, _96, piece); + const _96: rs.RangeFrom = new rs.RangeFrom(i, rs.usizeStep); + s.v = rs.stringReplaceRange(s.v, _96, piece); } else if (_91 === 2) { - const _99: { end: rt.usize } = { end: j }; - s.v = rt.stringReplaceRange(s.v, _99, piece); + const _99: { end: rs.usize } = { end: j }; + s.v = rs.stringReplaceRange(s.v, _99, piece); } else if (_91 === 3) { - s.v = rt.stringReplaceRange(s.v, undefined, piece); + s.v = rs.stringReplaceRange(s.v, undefined, piece); } else if (_91 === 4) { - const _104: rt.RangeInclusive = new rt.RangeInclusive(i, j, rt.usizeStep); - s.v = rt.stringReplaceRange(s.v, _104, piece); + const _104: rs.RangeInclusive = new rs.RangeInclusive(i, j, rs.usizeStep); + s.v = rs.stringReplaceRange(s.v, _104, piece); } else if (_91 === 5) { - const _107: { end: rt.usize; inclusive: true } = { end: j, inclusive: true }; - s.v = rt.stringReplaceRange(s.v, _107, piece); + const _107: { end: rs.usize; inclusive: true } = { end: j, inclusive: true }; + s.v = rs.stringReplaceRange(s.v, _107, piece); } else { - const _110: [rt.RangeBound, rt.RangeBound] = [{ tag: "Excluded", _0: i } as rt.RangeBound, { tag: "Included", _0: j } as rt.RangeBound]; - s.v = rt.stringReplaceRange(s.v, _110, piece); + const _110: [rs.RangeBound, rs.RangeBound] = [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound]; + s.v = rs.stringReplaceRange(s.v, _110, piece); } } else if (_24 === 11) { - const _115: rt.u8 = rt.u8Rem(b, 5); + const _115: rs.u8 = rs.u8Rem(b, 5); if (_115 === 0) { - s.v = rt.stringExtendFromWithin(s.v, new rt.Range(i, j)); + s.v = rs.stringExtendFromWithin(s.v, new rs.Range(i, j)); } else if (_115 === 1) { - s.v = rt.stringExtendFromWithin(s.v, new rt.RangeFrom(i, rt.usizeStep)); + s.v = rs.stringExtendFromWithin(s.v, new rs.RangeFrom(i, rs.usizeStep)); } else if (_115 === 2) { - s.v = rt.stringExtendFromWithin(s.v, { end: j, inclusive: true }); + s.v = rs.stringExtendFromWithin(s.v, { end: j, inclusive: true }); } else if (_115 === 3) { - s.v = rt.stringExtendFromWithin(s.v, [{ tag: "Included", _0: i } as rt.RangeBound, { tag: "Excluded", _0: j } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + s.v = rs.stringExtendFromWithin(s.v, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Excluded", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); } else { - s.v = rt.stringExtendFromWithin(s.v, undefined); + s.v = rs.stringExtendFromWithin(s.v, undefined); } } else if (_24 === 12) { - const _123: rt.u8 = rt.u8Rem(a, 4); + const _123: rs.u8 = rs.u8Rem(a, 4); if (_123 === 0) { - rt.stringReserve(s.v, rt.usizeSub(4294967295, b as rt.usize)); + rs.stringReserve(s.v, rs.usizeSub(4294967295, b as rs.usize)); } else if (_123 === 1) { - const _128: rt.usize = rt.usizeAdd(rt.usizeAdd(rt.usizeSub(2147483647, rt.stringLen(s.v)), 1), rt.u8Rem(b, 2) as rt.usize); - rt.stringReserve(s.v, _128); + const _128: rs.usize = rs.usizeAdd(rs.usizeAdd(rs.usizeSub(2147483647, rs.stringLen(s.v)), 1), rs.u8Rem(b, 2) as rs.usize); + rs.stringReserve(s.v, _128); } else { - rt.stringReserve(s.v, a as rt.usize); - rt.stringReserve(s.v, b as rt.usize); + rs.stringReserve(s.v, a as rs.usize); + rs.stringReserve(s.v, b as rs.usize); } } else { - if (rt.u8Rem(a, 4) === 0) { - capacity = rt.usizeAdd(rt.usizeAdd(2147483647, 1), rt.u8Rem(b, 2) as rt.usize); + if (rs.u8Rem(a, 4) === 0) { + capacity = rs.usizeAdd(rs.usizeAdd(2147483647, 1), rs.u8Rem(b, 2) as rs.usize); } else { - capacity = a as rt.usize; + capacity = a as rs.usize; } - let fresh: string = rt.stringWithCapacity(capacity); + let fresh: string = rs.stringWithCapacity(capacity); fresh = fresh + s.v; s.v = fresh; } @@ -656,67 +656,67 @@ export function edit(s: rt.Place, op: rt.u8, a: rt.u8, b: rt.u8, out: rt * through a `&mut String`, on a local, and on a field, each printed after each edit. * An offset off a char boundary or out of bounds panics as std's does. */ -export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const mid: number = rt.min(dataLen, rt.u8Rem(kind, 8) as rt.usize); +export function edits(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const mid: number = rs.min(dataLen, rs.u8Rem(kind, 8) as rs.usize); if (mid > dataLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); + const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); let s: string = text(head); const named: Named.Named = { name: text(head) }; - const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); + const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 3); while (true) { - const _18: rt.ByteSlice | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: rs.ByteSlice | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } - rt.idx(_18, 0); - const _25: Uint8Array = Uint8Array.of(_18.data[_18.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_18, 1), 0), option_unwrapOr$0r2bmpr(rt.byteSliceGet(_18, 2), 16)); - const op: rt.u8 = _25[0]; - const a: rt.u8 = _25[1]; - const b: rt.u8 = _25[2]; - const _39: rt.u8 = rt.u8Div(op, 64); + rs.idx(_18, 0); + const _25: Uint8Array = Uint8Array.of(_18.data[_18.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_18, 1), 0), option_unwrapOr$1fr498u(rs.byteSliceGet(_18, 2), 16)); + const op: rs.u8 = _25[0]; + const a: rs.u8 = _25[1]; + const b: rs.u8 = _25[2]; + const _39: rs.u8 = rs.u8Div(op, 64); if (_39 === 0) { - edit(rt.place(() => named.name, (value10) => named.name = value10), op, a, b, out); + edit(rs.place(() => named.name, (value10) => named.name = value10), op, a, b, out); } else if (_39 === 1) { - const _42: rt.u8 = rt.u8Rem(op, 8); + const _42: rs.u8 = rs.u8Rem(op, 8); if (_42 === 0) { - const _44: rt.Place = rt.place(() => s, (value9) => s = value9); + const _44: rs.Place = rs.place(() => s, (value9) => s = value9); _44.v = _44.v + "é/"; } else if (_42 === 1) { - const _46: rt.Place = rt.place(() => s, (value8) => s = value8); - const _47: rt.usize = offset(s, a); - _46.v = rt.stringTruncate(_46.v, _47); + const _46: rs.Place = rs.place(() => s, (value8) => s = value8); + const _47: rs.usize = offset(s, a); + _46.v = rs.stringTruncate(_46.v, _47); } else if (_42 === 2) { - const _51: rt.Place = rt.place(() => s, (value7) => s = value7); - const edit4 = rt.stringPop(_51.v); + const _51: rs.Place = rs.place(() => s, (value7) => s = value7); + const edit4 = rs.stringPop(_51.v); _51.v = edit4[0]; putChar(out, edit4[1]); } else if (_42 === 3) { - const _52: rt.Place = rt.place(() => s, (value6) => s = value6); - const _53: rt.usize = offset(s, a); - _52.v = rt.stringInsertStr(_52.v, _53, "😀"); + const _52: rs.Place = rs.place(() => s, (value6) => s = value6); + const _53: rs.usize = offset(s, a); + _52.v = rs.stringInsertStr(_52.v, _53, "😀"); } else if (_42 === 4) { - const _60: rt.Place = rt.place(() => s, (value5) => s = value5); - const _61: rt.usize = offset(s, a); - const edit3 = rt.stringSplitOff(_60.v, _61); + const _60: rs.Place = rs.place(() => s, (value5) => s = value5); + const _61: rs.usize = offset(s, a); + const edit3 = rs.stringSplitOff(_60.v, _61); _60.v = edit3[0]; put(out, edit3[1]); } else if (_42 === 5) { - const _66: rt.Place = rt.place(() => s, (value4) => s = value4); - const edit2 = rt.stringRemove(_66.v, 0); + const _66: rs.Place = rs.place(() => s, (value4) => s = value4); + const edit2 = rs.stringRemove(_66.v, 0); _66.v = edit2[0]; putChar(out, edit2[1]); } else if (_42 === 6) { - const _70: rt.Place = rt.place(() => s, (value3) => s = value3); - const edit_ = rt.stringSplitOff(_70.v, 1); + const _70: rs.Place = rs.place(() => s, (value3) => s = value3); + const edit_ = rs.stringSplitOff(_70.v, 1); _70.v = edit_[0]; put(out, edit_[1]); } else { s = ""; } } else { - edit(rt.place(() => s, (value) => s = value), op, a, b, out); + edit(rs.place(() => s, (value) => s = value), op, a, b, out); } put(out, s); put(out, named.name); @@ -730,490 +730,490 @@ export function edits(kind: rt.u8, dataData: Uint8Array, dataStart: number, data * of every edge, of text of chars of every UTF-8 width, or of bytes mapped into an * alphabet of signs, digits, and the letters of `true` and `false`. */ -export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function parses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let one!: string | undefined; - let all!: rt.Vec; - const radix: rt.u32 = rt.u32Add(2, rt.u32Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0) as rt.u32, 35)); - const _13: rt.u8 = rt.u8Rem(rt.u8Div(kind, 14), 3); + let all!: rs.Vec; + const radix: rs.u32 = rs.u32Add(2, rs.u32Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0) as rs.u32, 35)); + const _13: rs.u8 = rs.u8Rem(rs.u8Div(kind, 14), 3); if (_13 === 0) { one = undefined; } else if (_13 === 1) { one = text(data); } else { let s: string = ""; - for (const b of rt.byteSliceView(data)) { - const _29: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)); - const _30: rt.usize = rt.usizeRem(b as rt.usize, rt.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)).length); - rt.idx(_29, _30); - s = s + String.fromCodePoint(_29.data[_29.start + _30] as rt.char); + for (const b of rs.byteSliceView(data)) { + const _29: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)); + const _30: rs.usize = rs.usizeRem(b as rs.usize, rs.byteSliceFrom(Uint8Array.of(48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 45, 116, 114, 117, 101, 102, 97, 108, 115, 84, 70, 32)).length); + rs.idx(_29, _30); + s = s + String.fromCodePoint(_29.data[_29.start + _30] as rs.char); } one = s; } const _39: string | undefined = one; if (_39 === undefined) { - all = rt.vecFrom(["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice()); + all = rs.vecFrom(["true", "false", "True", "FALSE", "", " true", "true ", "t", "truefalse", "a", "é", "ࠀ", "😀", "􏿿", "ab", "a😀", "😀a", "éé", "0", "+0", "-0", "000", "1", "+1", "-1", "+", "-", "--1", "+-1", "1_0", "0x1", "127", "128", "-128", "-129", "255", "256", "32767", "32768", "-32768", "-32769", "65535", "65536", "2147483647", "2147483648", "-2147483648", "-2147483649", "4294967295", "4294967296", "9223372036854775807", "9223372036854775808", "-9223372036854775808", "-9223372036854775809", "18446744073709551615", "18446744073709551616", "170141183460469231731687303715884105727", "170141183460469231731687303715884105728", "-170141183460469231731687303715884105728", "-170141183460469231731687303715884105729", "340282366920938463463374607431768211455", "340282366920938463463374607431768211456"].slice()); } else { - all = rt.vecFrom([_39]); + all = rs.vecFrom([_39]); } for (const _49 of all.items) { - const _53: rt.u8 = rt.u8Rem(kind, 14); + const _53: rs.u8 = rs.u8Rem(kind, 14); if (_53 === 0) { - const iter3: rt.Iter> = rt.iterSlice([parse$0vh4cry(_49), traits_fromStr$05d44vn(_49)]); + const iter3: rs.Iter> = rs.iterSlice([parse$1yfzdza(_49), traits_fromStr$1dw9076(_49)]); while (true) { - const _65: rt.Result | rt.Done = iter3.next(); - if (_65 === rt.DONE) { + const _65: rs.Result | rs.Done = iter3.next(); + if (_65 === rs.DONE) { break; } - const parsed: rt.Result = _65; + const parsed: rs.Result = _65; if (parsed.ok) { const arg26 = parsed.value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(arg26, f)]; - put(out, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg26, f)]; + put(out, rs.fmtFormat([args2[0]])); } else { - const part13 = new rt.ParseBoolError(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseBoolErrorDisplay(part13, f), (f: rt.Formatter) => rt.fmtParseBoolErrorDebug(part13, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args4[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args4[1]), "|", rt.fmtSpec({ alternate: true }, args4[1])])); + const part13 = new rs.ParseBoolError(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseBoolErrorDisplay(part13, f), (f: rs.Formatter) => rs.fmtParseBoolErrorDebug(part13, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args4[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args4[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args4[1]), "|", rs.fmtSpec({ alternate: true }, args4[1])])); } } - parse$0vh4cry(_49); + parse$1yfzdza(_49); } else if (_53 === 1) { - const iter4: rt.Iter> = rt.iterSlice([rt.charFromStr(_49), rt.charFromStr(_49)]); + const iter4: rs.Iter> = rs.iterSlice([rs.charFromStr(_49), rs.charFromStr(_49)]); while (true) { - const _105: rt.Result | rt.Done = iter4.next(); - if (_105 === rt.DONE) { + const _105: rs.Result | rs.Done = iter4.next(); + if (_105 === rs.DONE) { break; } - const parsed2: rt.Result = _105; + const parsed2: rs.Result = _105; if (parsed2.ok) { const arg25 = parsed2.value; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDebug(arg25, f)]; - put(out, rt.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDebug(arg25, f)]; + put(out, rs.fmtFormat([args6[0]])); } else { - const e: rt.ParseCharError = parsed2.error; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseCharErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtParseCharErrorDebug(e, f)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args8[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args8[1]), "|", rt.fmtSpec({ alternate: true }, args8[1])])); + const e: rs.ParseCharError = parsed2.error; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseCharErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtParseCharErrorDebug(e, f)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args8[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args8[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args8[1]), "|", rs.fmtSpec({ alternate: true }, args8[1])])); } } - rt.charFromStr(_49); + rs.charFromStr(_49); } else if (_53 === 2) { - const radix2: rt.u32 = radix; - const iter5: rt.Iter> = rt.iterSlice([parse$0r5638o(_49), nonzero_fromStr$1ka76tk(_49)]); + const radix2: rs.u32 = radix; + const iter5: rs.Iter> = rs.iterSlice([parse$1y4njjc(_49), nonzero_fromStr$1ikft6y(_49)]); while (true) { - const _149: rt.Result | rt.Done = iter5.next(); - if (_149 === rt.DONE) { + const _149: rs.Result | rs.Done = iter5.next(); + if (_149 === rs.DONE) { break; } - const parsed3: rt.Result = _149; + const parsed3: rs.Result = _149; if (parsed3.ok) { const arg23 = parsed3.value; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Debug(arg23, f)]; - put(out, rt.fmtFormat([args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Debug(arg23, f)]; + put(out, rs.fmtFormat([args10[0]])); } else { - const e2: rt.ParseIntError = parsed3.error; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e2, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e2, f)]; - put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rt.fmtSpec({ alternate: true }, args12[1])])); + const e2: rs.ParseIntError = parsed3.error; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e2, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e2, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args12[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args12[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args12[1]), "|", rs.fmtSpec({ alternate: true }, args12[1])])); } } - const _139: rt.Result = parse$0r5638o(_49); + const _139: rs.Result = parse$1y4njjc(_49); if (!_139.ok) { const part12 = _139.error.kind; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part12)]; - put(out, rt.fmtFormat([args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part12)]; + put(out, rs.fmtFormat([args14[0]])); } - const _195: rt.Result = nonzero_fromStrRadix$1c1a5i0(_49, radix2); + const _195: rs.Result = nonzero_fromStrRadix$1i96daa(_49, radix2); if (_195.ok) { const arg24 = _195.value; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg24, f)]; - put(out, rt.fmtFormat([args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg24, f)]; + put(out, rs.fmtFormat([args16[0]])); } else { - const e4: rt.ParseIntError = _195.error; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e4, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e4, f)]; - put(out, rt.fmtFormat([args18[0], "|", args18[1]])); + const e4: rs.ParseIntError = _195.error; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e4, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e4, f)]; + put(out, rs.fmtFormat([args18[0], "|", args18[1]])); } } else if (_53 === 3) { - const radix3: rt.u32 = radix; - const iter6: rt.Iter> = rt.iterSlice([parse$00ea569(_49), nonzero_fromStr$1bidi2n(_49)]); + const radix3: rs.u32 = radix; + const iter6: rs.Iter> = rs.iterSlice([parse$13tnb7e(_49), nonzero_fromStr$0t2qzou(_49)]); while (true) { - const _236: rt.Result | rt.Done = iter6.next(); - if (_236 === rt.DONE) { + const _236: rs.Result | rs.Done = iter6.next(); + if (_236 === rs.DONE) { break; } - const parsed4: rt.Result = _236; + const parsed4: rs.Result = _236; if (parsed4.ok) { const arg21 = parsed4.value; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Debug(arg21, f)]; - put(out, rt.fmtFormat([args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Debug(arg21, f)]; + put(out, rs.fmtFormat([args20[0]])); } else { - const e5: rt.ParseIntError = parsed4.error; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e5, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e5, f)]; - put(out, rt.fmtFormat([args22[0], "|", args22[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rt.fmtSpec({ alternate: true }, args22[1])])); + const e5: rs.ParseIntError = parsed4.error; + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e5, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e5, f)]; + put(out, rs.fmtFormat([args22[0], "|", args22[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args22[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args22[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args22[1]), "|", rs.fmtSpec({ alternate: true }, args22[1])])); } } - const _226: rt.Result = parse$00ea569(_49); + const _226: rs.Result = parse$13tnb7e(_49); if (!_226.ok) { const part11 = _226.error.kind; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part11)]; - put(out, rt.fmtFormat([args24[0]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part11)]; + put(out, rs.fmtFormat([args24[0]])); } - const _282: rt.Result = nonzero_fromStrRadix$13ngn1e(_49, radix3); + const _282: rs.Result = nonzero_fromStrRadix$0yk2yqd(_49, radix3); if (_282.ok) { const arg22 = _282.value; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(arg22, f)]; - put(out, rt.fmtFormat([args26[0]])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(arg22, f)]; + put(out, rs.fmtFormat([args26[0]])); } else { - const e7: rt.ParseIntError = _282.error; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e7, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e7, f)]; - put(out, rt.fmtFormat([args28[0], "|", args28[1]])); + const e7: rs.ParseIntError = _282.error; + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e7, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e7, f)]; + put(out, rs.fmtFormat([args28[0], "|", args28[1]])); } } else if (_53 === 4) { - const radix4: rt.u32 = radix; - const iter7: rt.Iter> = rt.iterSlice([parse$00ibreq(_49), nonzero_fromStr$0pscojv(_49)]); + const radix4: rs.u32 = radix; + const iter7: rs.Iter> = rs.iterSlice([parse$04z9euf(_49), nonzero_fromStr$1qv4pqe(_49)]); while (true) { - const _323: rt.Result | rt.Done = iter7.next(); - if (_323 === rt.DONE) { + const _323: rs.Result | rs.Done = iter7.next(); + if (_323 === rs.DONE) { break; } - const parsed5: rt.Result = _323; + const parsed5: rs.Result = _323; if (parsed5.ok) { const arg19 = parsed5.value; - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Debug(arg19, f)]; - put(out, rt.fmtFormat([args30[0]])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Debug(arg19, f)]; + put(out, rs.fmtFormat([args30[0]])); } else { - const e8: rt.ParseIntError = parsed5.error; - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e8, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e8, f)]; - put(out, rt.fmtFormat([args32[0], "|", args32[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rt.fmtSpec({ alternate: true }, args32[1])])); + const e8: rs.ParseIntError = parsed5.error; + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e8, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e8, f)]; + put(out, rs.fmtFormat([args32[0], "|", args32[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args32[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args32[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args32[1]), "|", rs.fmtSpec({ alternate: true }, args32[1])])); } } - const _313: rt.Result = parse$00ibreq(_49); + const _313: rs.Result = parse$04z9euf(_49); if (!_313.ok) { const part10 = _313.error.kind; - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part10)]; - put(out, rt.fmtFormat([args34[0]])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part10)]; + put(out, rs.fmtFormat([args34[0]])); } - const _369: rt.Result = nonzero_fromStrRadix$14vzugb(_49, radix4); + const _369: rs.Result = nonzero_fromStrRadix$1y934te(_49, radix4); if (_369.ok) { const arg20 = _369.value; - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg20, f)]; - put(out, rt.fmtFormat([args36[0]])); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg20, f)]; + put(out, rs.fmtFormat([args36[0]])); } else { - const e10: rt.ParseIntError = _369.error; - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e10, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e10, f)]; - put(out, rt.fmtFormat([args38[0], "|", args38[1]])); + const e10: rs.ParseIntError = _369.error; + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e10, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e10, f)]; + put(out, rs.fmtFormat([args38[0], "|", args38[1]])); } } else if (_53 === 5) { - const radix5: rt.u32 = radix; - const iter8: rt.Iter> = rt.iterSlice([parse$129b0a7(_49), nonzero_fromStr$19lq810(_49)]); + const radix5: rs.u32 = radix; + const iter8: rs.Iter> = rs.iterSlice([parse$1fob3ck(_49), nonzero_fromStr$1xddfo8(_49)]); while (true) { - const _410: rt.Result | rt.Done = iter8.next(); - if (_410 === rt.DONE) { + const _410: rs.Result | rs.Done = iter8.next(); + if (_410 === rs.DONE) { break; } - const parsed6: rt.Result = _410; + const parsed6: rs.Result = _410; if (parsed6.ok) { const arg17 = parsed6.value; - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Debug(arg17, f)]; - put(out, rt.fmtFormat([args40[0]])); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Debug(arg17, f)]; + put(out, rs.fmtFormat([args40[0]])); } else { - const e11: rt.ParseIntError = parsed6.error; - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e11, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e11, f)]; - put(out, rt.fmtFormat([args42[0], "|", args42[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rt.fmtSpec({ alternate: true }, args42[1])])); + const e11: rs.ParseIntError = parsed6.error; + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e11, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e11, f)]; + put(out, rs.fmtFormat([args42[0], "|", args42[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args42[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args42[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args42[1]), "|", rs.fmtSpec({ alternate: true }, args42[1])])); } } - const _400: rt.Result = parse$129b0a7(_49); + const _400: rs.Result = parse$1fob3ck(_49); if (!_400.ok) { const part9 = _400.error.kind; - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part9)]; - put(out, rt.fmtFormat([args44[0]])); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part9)]; + put(out, rs.fmtFormat([args44[0]])); } - const _456: rt.Result = nonzero_fromStrRadix$1u3fi38(_49, radix5); + const _456: rs.Result = nonzero_fromStrRadix$11u1rq7(_49, radix5); if (_456.ok) { const arg18 = _456.value; - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg18, f)]; - put(out, rt.fmtFormat([args46[0]])); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg18, f)]; + put(out, rs.fmtFormat([args46[0]])); } else { - const e13: rt.ParseIntError = _456.error; - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e13, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e13, f)]; - put(out, rt.fmtFormat([args48[0], "|", args48[1]])); + const e13: rs.ParseIntError = _456.error; + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e13, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e13, f)]; + put(out, rs.fmtFormat([args48[0], "|", args48[1]])); } } else if (_53 === 6) { - const radix6: rt.u32 = radix; - const iter9: rt.Iter> = rt.iterSlice([parse$0y8gj7z(_49), nonzero_fromStr$1lyc2jq(_49)]); + const radix6: rs.u32 = radix; + const iter9: rs.Iter> = rs.iterSlice([parse$0j8ztlu(_49), nonzero_fromStr$06q0lw7(_49)]); while (true) { - const _497: rt.Result | rt.Done = iter9.next(); - if (_497 === rt.DONE) { + const _497: rs.Result | rs.Done = iter9.next(); + if (_497 === rs.DONE) { break; } - const parsed7: rt.Result = _497; + const parsed7: rs.Result = _497; if (parsed7.ok) { const arg15 = parsed7.value; - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Debug(arg15, f)]; - put(out, rt.fmtFormat([args50[0]])); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Debug(arg15, f)]; + put(out, rs.fmtFormat([args50[0]])); } else { - const e14: rt.ParseIntError = parsed7.error; - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e14, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e14, f)]; - put(out, rt.fmtFormat([args52[0], "|", args52[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rt.fmtSpec({ alternate: true }, args52[1])])); + const e14: rs.ParseIntError = parsed7.error; + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e14, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e14, f)]; + put(out, rs.fmtFormat([args52[0], "|", args52[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args52[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args52[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args52[1]), "|", rs.fmtSpec({ alternate: true }, args52[1])])); } } - const _487: rt.Result = parse$0y8gj7z(_49); + const _487: rs.Result = parse$0j8ztlu(_49); if (!_487.ok) { const part8 = _487.error.kind; - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part8)]; - put(out, rt.fmtFormat([args54[0]])); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part8)]; + put(out, rs.fmtFormat([args54[0]])); } - const _543: rt.Result = nonzero_fromStrRadix$0yvapq5(_49, radix6); + const _543: rs.Result = nonzero_fromStrRadix$1ejhcoz(_49, radix6); if (_543.ok) { const arg16 = _543.value; - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(arg16, f)]; - put(out, rt.fmtFormat([args56[0]])); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(arg16, f)]; + put(out, rs.fmtFormat([args56[0]])); } else { - const e16: rt.ParseIntError = _543.error; - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e16, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e16, f)]; - put(out, rt.fmtFormat([args58[0], "|", args58[1]])); + const e16: rs.ParseIntError = _543.error; + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e16, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e16, f)]; + put(out, rs.fmtFormat([args58[0], "|", args58[1]])); } } else if (_53 === 7) { - const radix7: rt.u32 = radix; - const iter10: rt.Iter> = rt.iterSlice([parse$1kzahs9(_49), nonzero_fromStr$0b146n7(_49)]); + const radix7: rs.u32 = radix; + const iter10: rs.Iter> = rs.iterSlice([parse$1acldxi(_49), nonzero_fromStr$0tn1xwn(_49)]); while (true) { - const _584: rt.Result | rt.Done = iter10.next(); - if (_584 === rt.DONE) { + const _584: rs.Result | rs.Done = iter10.next(); + if (_584 === rs.DONE) { break; } - const parsed8: rt.Result = _584; + const parsed8: rs.Result = _584; if (parsed8.ok) { const arg13 = parsed8.value; - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDebug(arg13, f)]; - put(out, rt.fmtFormat([args60[0]])); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDebug(arg13, f)]; + put(out, rs.fmtFormat([args60[0]])); } else { - const e17: rt.ParseIntError = parsed8.error; - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e17, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e17, f)]; - put(out, rt.fmtFormat([args62[0], "|", args62[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rt.fmtSpec({ alternate: true }, args62[1])])); + const e17: rs.ParseIntError = parsed8.error; + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e17, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e17, f)]; + put(out, rs.fmtFormat([args62[0], "|", args62[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args62[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args62[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args62[1]), "|", rs.fmtSpec({ alternate: true }, args62[1])])); } } - const _574: rt.Result = parse$1kzahs9(_49); + const _574: rs.Result = parse$1acldxi(_49); if (!_574.ok) { const part7 = _574.error.kind; - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part7)]; - put(out, rt.fmtFormat([args64[0]])); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part7)]; + put(out, rs.fmtFormat([args64[0]])); } - const _630: rt.Result = nonzero_fromStrRadix$0tal612(_49, radix7); + const _630: rs.Result = nonzero_fromStrRadix$1dc88z1(_49, radix7); if (_630.ok) { const arg14 = _630.value; - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg14, f)]; - put(out, rt.fmtFormat([args66[0]])); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg14, f)]; + put(out, rs.fmtFormat([args66[0]])); } else { - const e19: rt.ParseIntError = _630.error; - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e19, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e19, f)]; - put(out, rt.fmtFormat([args68[0], "|", args68[1]])); + const e19: rs.ParseIntError = _630.error; + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e19, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e19, f)]; + put(out, rs.fmtFormat([args68[0], "|", args68[1]])); } } else if (_53 === 8) { - const radix8: rt.u32 = radix; - const iter11: rt.Iter> = rt.iterSlice([parse$0wtmhwf(_49), nonzero_fromStr$1uo2nx5(_49)]); + const radix8: rs.u32 = radix; + const iter11: rs.Iter> = rs.iterSlice([parse$0jsh5gh(_49), nonzero_fromStr$0h6taf0(_49)]); while (true) { - const _671: rt.Result | rt.Done = iter11.next(); - if (_671 === rt.DONE) { + const _671: rs.Result | rs.Done = iter11.next(); + if (_671 === rs.DONE) { break; } - const parsed9: rt.Result = _671; + const parsed9: rs.Result = _671; if (parsed9.ok) { const arg11 = parsed9.value; - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Debug(arg11, f)]; - put(out, rt.fmtFormat([args70[0]])); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Debug(arg11, f)]; + put(out, rs.fmtFormat([args70[0]])); } else { - const e20: rt.ParseIntError = parsed9.error; - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e20, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e20, f)]; - put(out, rt.fmtFormat([args72[0], "|", args72[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rt.fmtSpec({ alternate: true }, args72[1])])); + const e20: rs.ParseIntError = parsed9.error; + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e20, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e20, f)]; + put(out, rs.fmtFormat([args72[0], "|", args72[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args72[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args72[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args72[1]), "|", rs.fmtSpec({ alternate: true }, args72[1])])); } } - const _661: rt.Result = parse$0wtmhwf(_49); + const _661: rs.Result = parse$0jsh5gh(_49); if (!_661.ok) { const part6 = _661.error.kind; - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part6)]; - put(out, rt.fmtFormat([args74[0]])); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part6)]; + put(out, rs.fmtFormat([args74[0]])); } - const _717: rt.Result = nonzero_fromStrRadix$0cahq64(_49, radix8); + const _717: rs.Result = nonzero_fromStrRadix$011a32r(_49, radix8); if (_717.ok) { const arg12 = _717.value; - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(arg12, f)]; - put(out, rt.fmtFormat([args76[0]])); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(arg12, f)]; + put(out, rs.fmtFormat([args76[0]])); } else { - const e22: rt.ParseIntError = _717.error; - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e22, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e22, f)]; - put(out, rt.fmtFormat([args78[0], "|", args78[1]])); + const e22: rs.ParseIntError = _717.error; + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e22, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e22, f)]; + put(out, rs.fmtFormat([args78[0], "|", args78[1]])); } } else if (_53 === 9) { - const radix9: rt.u32 = radix; - const iter12: rt.Iter> = rt.iterSlice([parse$08t7361(_49), nonzero_fromStr$05o7gm9(_49)]); + const radix9: rs.u32 = radix; + const iter12: rs.Iter> = rs.iterSlice([parse$0wntisu(_49), nonzero_fromStr$157gku3(_49)]); while (true) { - const _758: rt.Result | rt.Done = iter12.next(); - if (_758 === rt.DONE) { + const _758: rs.Result | rs.Done = iter12.next(); + if (_758 === rs.DONE) { break; } - const parsed10: rt.Result = _758; + const parsed10: rs.Result = _758; if (parsed10.ok) { const arg9 = parsed10.value; - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Debug(arg9, f)]; - put(out, rt.fmtFormat([args80[0]])); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Debug(arg9, f)]; + put(out, rs.fmtFormat([args80[0]])); } else { - const e23: rt.ParseIntError = parsed10.error; - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e23, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e23, f)]; - put(out, rt.fmtFormat([args82[0], "|", args82[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rt.fmtSpec({ alternate: true }, args82[1])])); + const e23: rs.ParseIntError = parsed10.error; + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e23, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e23, f)]; + put(out, rs.fmtFormat([args82[0], "|", args82[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args82[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args82[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args82[1]), "|", rs.fmtSpec({ alternate: true }, args82[1])])); } } - const _748: rt.Result = parse$08t7361(_49); + const _748: rs.Result = parse$0wntisu(_49); if (!_748.ok) { const part5 = _748.error.kind; - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part5)]; - put(out, rt.fmtFormat([args84[0]])); + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part5)]; + put(out, rs.fmtFormat([args84[0]])); } - const _804: rt.Result = nonzero_fromStrRadix$10ztqkr(_49, radix9); + const _804: rs.Result = nonzero_fromStrRadix$1u0zwz8(_49, radix9); if (_804.ok) { const arg10 = _804.value; - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(arg10, f)]; - put(out, rt.fmtFormat([args86[0]])); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(arg10, f)]; + put(out, rs.fmtFormat([args86[0]])); } else { - const e25: rt.ParseIntError = _804.error; - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e25, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e25, f)]; - put(out, rt.fmtFormat([args88[0], "|", args88[1]])); + const e25: rs.ParseIntError = _804.error; + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e25, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e25, f)]; + put(out, rs.fmtFormat([args88[0], "|", args88[1]])); } } else if (_53 === 10) { - const radix10: rt.u32 = radix; - const iter13: rt.Iter> = rt.iterSlice([parse$0bf4pzp(_49), nonzero_fromStr$1cmdtf2(_49)]); + const radix10: rs.u32 = radix; + const iter13: rs.Iter> = rs.iterSlice([parse$18h4mna(_49), nonzero_fromStr$13j6y8p(_49)]); while (true) { - const _845: rt.Result | rt.Done = iter13.next(); - if (_845 === rt.DONE) { + const _845: rs.Result | rs.Done = iter13.next(); + if (_845 === rs.DONE) { break; } - const parsed11: rt.Result = _845; + const parsed11: rs.Result = _845; if (parsed11.ok) { const arg7 = parsed11.value; - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Debug(arg7, f)]; - put(out, rt.fmtFormat([args90[0]])); + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Debug(arg7, f)]; + put(out, rs.fmtFormat([args90[0]])); } else { - const e26: rt.ParseIntError = parsed11.error; - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e26, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e26, f)]; - put(out, rt.fmtFormat([args92[0], "|", args92[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rt.fmtSpec({ alternate: true }, args92[1])])); + const e26: rs.ParseIntError = parsed11.error; + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e26, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e26, f)]; + put(out, rs.fmtFormat([args92[0], "|", args92[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args92[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args92[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args92[1]), "|", rs.fmtSpec({ alternate: true }, args92[1])])); } } - const _835: rt.Result = parse$0bf4pzp(_49); + const _835: rs.Result = parse$18h4mna(_49); if (!_835.ok) { const part4 = _835.error.kind; - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part4)]; - put(out, rt.fmtFormat([args94[0]])); + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part4)]; + put(out, rs.fmtFormat([args94[0]])); } - const _891: rt.Result = nonzero_fromStrRadix$1vk8c0u(_49, radix10); + const _891: rs.Result = nonzero_fromStrRadix$1m6epfo(_49, radix10); if (_891.ok) { const arg8 = _891.value; - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(arg8, f)]; - put(out, rt.fmtFormat([args96[0]])); + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(arg8, f)]; + put(out, rs.fmtFormat([args96[0]])); } else { - const e28: rt.ParseIntError = _891.error; - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e28, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e28, f)]; - put(out, rt.fmtFormat([args98[0], "|", args98[1]])); + const e28: rs.ParseIntError = _891.error; + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e28, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e28, f)]; + put(out, rs.fmtFormat([args98[0], "|", args98[1]])); } } else if (_53 === 11) { - const radix11: rt.u32 = radix; - const iter14: rt.Iter> = rt.iterSlice([parse$00wf0ig(_49), nonzero_fromStr$10p52cj(_49)]); + const radix11: rs.u32 = radix; + const iter14: rs.Iter> = rs.iterSlice([parse$1gh8p0t(_49), nonzero_fromStr$1crondi(_49)]); while (true) { - const _932: rt.Result | rt.Done = iter14.next(); - if (_932 === rt.DONE) { + const _932: rs.Result | rs.Done = iter14.next(); + if (_932 === rs.DONE) { break; } - const parsed12: rt.Result = _932; + const parsed12: rs.Result = _932; if (parsed12.ok) { const arg5 = parsed12.value; - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Debug(arg5, f)]; - put(out, rt.fmtFormat([args100[0]])); + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Debug(arg5, f)]; + put(out, rs.fmtFormat([args100[0]])); } else { - const e29: rt.ParseIntError = parsed12.error; - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e29, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e29, f)]; - put(out, rt.fmtFormat([args102[0], "|", args102[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rt.fmtSpec({ alternate: true }, args102[1])])); + const e29: rs.ParseIntError = parsed12.error; + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e29, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e29, f)]; + put(out, rs.fmtFormat([args102[0], "|", args102[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args102[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args102[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args102[1]), "|", rs.fmtSpec({ alternate: true }, args102[1])])); } } - const _922: rt.Result = parse$00wf0ig(_49); + const _922: rs.Result = parse$1gh8p0t(_49); if (!_922.ok) { const part3 = _922.error.kind; - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part3)]; - put(out, rt.fmtFormat([args104[0]])); + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part3)]; + put(out, rs.fmtFormat([args104[0]])); } - const _978: rt.Result = nonzero_fromStrRadix$0ebk8xe(_49, radix11); + const _978: rs.Result = nonzero_fromStrRadix$15i0o2z(_49, radix11); if (_978.ok) { const arg6 = _978.value; - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(arg6, f)]; - put(out, rt.fmtFormat([args106[0]])); + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(arg6, f)]; + put(out, rs.fmtFormat([args106[0]])); } else { - const e31: rt.ParseIntError = _978.error; - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e31, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e31, f)]; - put(out, rt.fmtFormat([args108[0], "|", args108[1]])); + const e31: rs.ParseIntError = _978.error; + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e31, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e31, f)]; + put(out, rs.fmtFormat([args108[0], "|", args108[1]])); } } else if (_53 === 12) { - const radix12: rt.u32 = radix; - const iter15: rt.Iter> = rt.iterSlice([parse$1bh1yup(_49), nonzero_fromStr$081k88g(_49)]); + const radix12: rs.u32 = radix; + const iter15: rs.Iter> = rs.iterSlice([parse$1d17hvd(_49), nonzero_fromStr$0q2xzd0(_49)]); while (true) { - const _1019: rt.Result | rt.Done = iter15.next(); - if (_1019 === rt.DONE) { + const _1019: rs.Result | rs.Done = iter15.next(); + if (_1019 === rs.DONE) { break; } - const parsed13: rt.Result = _1019; + const parsed13: rs.Result = _1019; if (parsed13.ok) { const arg3 = parsed13.value; - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Debug(arg3, f)]; - put(out, rt.fmtFormat([args110[0]])); + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Debug(arg3, f)]; + put(out, rs.fmtFormat([args110[0]])); } else { - const e32: rt.ParseIntError = parsed13.error; - const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e32, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e32, f)]; - put(out, rt.fmtFormat([args112[0], "|", args112[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rt.fmtSpec({ alternate: true }, args112[1])])); + const e32: rs.ParseIntError = parsed13.error; + const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e32, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e32, f)]; + put(out, rs.fmtFormat([args112[0], "|", args112[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args112[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args112[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args112[1]), "|", rs.fmtSpec({ alternate: true }, args112[1])])); } } - const _1009: rt.Result = parse$1bh1yup(_49); + const _1009: rs.Result = parse$1d17hvd(_49); if (!_1009.ok) { const part2 = _1009.error.kind; - const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part2)]; - put(out, rt.fmtFormat([args114[0]])); + const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part2)]; + put(out, rs.fmtFormat([args114[0]])); } - const _1065: rt.Result = nonzero_fromStrRadix$17xzbib(_49, radix12); + const _1065: rs.Result = nonzero_fromStrRadix$09x3avk(_49, radix12); if (_1065.ok) { const arg4 = _1065.value; - const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(arg4, f)]; - put(out, rt.fmtFormat([args116[0]])); + const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(arg4, f)]; + put(out, rs.fmtFormat([args116[0]])); } else { - const e34: rt.ParseIntError = _1065.error; - const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e34, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e34, f)]; - put(out, rt.fmtFormat([args118[0], "|", args118[1]])); + const e34: rs.ParseIntError = _1065.error; + const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e34, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e34, f)]; + put(out, rs.fmtFormat([args118[0], "|", args118[1]])); } } else { - const radix13: rt.u32 = radix; - const iter16: rt.Iter> = rt.iterSlice([parse$11q43n4(_49), nonzero_fromStr$1nddmw0(_49)]); + const radix13: rs.u32 = radix; + const iter16: rs.Iter> = rs.iterSlice([parse$09069e1(_49), nonzero_fromStr$0bvulbz(_49)]); while (true) { - const _1106: rt.Result | rt.Done = iter16.next(); - if (_1106 === rt.DONE) { + const _1106: rs.Result | rs.Done = iter16.next(); + if (_1106 === rs.DONE) { break; } - const parsed14: rt.Result = _1106; + const parsed14: rs.Result = _1106; if (parsed14.ok) { const arg = parsed14.value; - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDebug(arg, f)]; - put(out, rt.fmtFormat([args120[0]])); + const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDebug(arg, f)]; + put(out, rs.fmtFormat([args120[0]])); } else { - const e35: rt.ParseIntError = parsed14.error; - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e35, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e35, f)]; - put(out, rt.fmtFormat([args122[0], "|", args122[1], "|", rt.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rt.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rt.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rt.fmtSpec({ alternate: true }, args122[1])])); + const e35: rs.ParseIntError = parsed14.error; + const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e35, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e35, f)]; + put(out, rs.fmtFormat([args122[0], "|", args122[1], "|", rs.fmtSpec({ align: ">", width: 50 }, args122[0]), "|", rs.fmtSpec({ align: "<", width: 3, precision: 5 }, args122[0]), "|", rs.fmtSpec({ align: ">", width: 20 }, args122[1]), "|", rs.fmtSpec({ alternate: true }, args122[1])])); } } - const _1096: rt.Result = parse$11q43n4(_49); + const _1096: rs.Result = parse$09069e1(_49); if (!_1096.ok) { const part = _1096.error.kind; - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteStr(f, part)]; - put(out, rt.fmtFormat([args124[0]])); + const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteStr(f, part)]; + put(out, rs.fmtFormat([args124[0]])); } - const _1152: rt.Result = nonzero_fromStrRadix$07izbug(_49, radix13); + const _1152: rs.Result = nonzero_fromStrRadix$1jg523s(_49, radix13); if (_1152.ok) { const arg2 = _1152.value; - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(arg2, f)]; - put(out, rt.fmtFormat([args126[0]])); + const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(arg2, f)]; + put(out, rs.fmtFormat([args126[0]])); } else { - const e37: rt.ParseIntError = _1152.error; - const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtParseIntErrorDisplay(e37, f), (f: rt.Formatter) => rt.fmtParseIntErrorDebug(e37, f)]; - put(out, rt.fmtFormat([args128[0], "|", args128[1]])); + const e37: rs.ParseIntError = _1152.error; + const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtParseIntErrorDisplay(e37, f), (f: rs.Formatter) => rs.fmtParseIntErrorDebug(e37, f)]; + put(out, rs.fmtFormat([args128[0], "|", args128[1]])); } } } @@ -1223,96 +1223,96 @@ export function parses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * `String` made from and extended by iterators of chars and of strings, each the kind * picks, from text of chars of every UTF-8 width and its parts between `/`s. */ -export function iters(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function iters(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { const s: string = text(data); - const chars: rt.Vec = rt.iterToVec(rt.strChars(s), "next", 4); - const parts: rt.Vec = rt.iterToVec(rt.strSplit(s, "/"), "next", 8); - const nexts: rt.Cell = new rt.Cell(0); - const named: Named.Named = { name: text(rt.byteSliceRange(data, 0, rt.usizeDiv(data.length, 2))) }; - const _21: rt.u8 = rt.u8Rem(kind, 4); + const chars: rs.Vec = rs.iterToVec(rs.strChars(s), "next", 4); + const parts: rs.Vec = rs.iterToVec(rs.strSplit(s, "/"), "next", 8); + const nexts: rs.Cell = new rs.Cell(0); + const named: Named.Named = { name: text(rs.byteSliceRange(data, 0, rs.usizeDiv(data.length, 2))) }; + const _21: rs.u8 = rs.u8Rem(kind, 4); if (_21 === 0) { - put(out, rt.stringExtendChars("", rt.strChars(s))); - put(out, rt.stringExtendChars("", rt.iterFilter(rt.iterRev(rt.strChars(s)), (c: rt.char): boolean => { - return !rt.isAsciiDigit(c); + put(out, rs.stringExtendChars("", rs.strChars(s))); + put(out, rs.stringExtendChars("", rs.iterFilter(rs.iterRev(rs.strChars(s)), (c: rs.char): boolean => { + return !rs.isAsciiDigit(c); }))); - put(out, rt.stringExtendChars("", rt.iterSlice(chars.items))); - put(out, rt.stringExtendChars("", rt.iterSkip(rt.iterSlice(chars.items), 1))); - rt.iterEmpty(); - put(out, rt.stringExtendChars("", rt.iterEmpty() as rt.Iter)); - put(out, rt.stringExtendChars("", rt.iterOption(rt.charFromU32(kind as rt.u32)))); - put(out, rt.stringExtendChars("", rt.iterFrom({ items: chars.items, nexts }, Counted.next$iter_Iterator_char))); + put(out, rs.stringExtendChars("", rs.iterSlice(chars.items))); + put(out, rs.stringExtendChars("", rs.iterSkip(rs.iterSlice(chars.items), 1))); + rs.iterEmpty(); + put(out, rs.stringExtendChars("", rs.iterEmpty() as rs.Iter)); + put(out, rs.stringExtendChars("", rs.iterOption(rs.charFromU32(kind as rs.u32)))); + put(out, rs.stringExtendChars("", rs.iterFrom({ items: chars.items, nexts }, Counted.next$iter_Iterator_char))); } else if (_21 === 1) { - put(out, rt.stringExtend("", rt.iterSlice(parts.items))); - put(out, rt.stringExtend("", rt.iterRev(rt.strSplit(s, "/")))); - put(out, rt.stringFromStrings(rt.iterMap(rt.iterSlice(parts.items), (p3: string): string => { + put(out, rs.stringExtend("", rs.iterSlice(parts.items))); + put(out, rs.stringExtend("", rs.iterRev(rs.strSplit(s, "/")))); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterSlice(parts.items), (p3: string): string => { return p3; }))); - put(out, rt.stringFromStrings(rt.iterFilter(rt.iterMap(rt.strSplit(s, "/"), (p4: string): string => { - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, p4)]; - return rt.fmtFormat([args4[0], args4[0]]); + put(out, rs.stringFromStrings(rs.iterFilter(rs.iterMap(rs.strSplit(s, "/"), (p4: string): string => { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p4)]; + return rs.fmtFormat([args4[0], args4[0]]); }), (p5: string): boolean => { return !(p5.length === 0); }))); - rt.iterEmpty(); - put(out, rt.stringFromStrings(rt.iterEmpty() as rt.Iter)); - put(out, rt.strCowStr(rt.stringExtendChars("", rt.iterRev(rt.strChars(s))))); - put(out, rt.stringExtend("", rt.iterSlice(parts.items))); - const owned: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts.items), (p6: string): string => { + rs.iterEmpty(); + put(out, rs.stringFromStrings(rs.iterEmpty() as rs.Iter)); + put(out, rs.strCowStr(rs.stringExtendChars("", rs.iterRev(rs.strChars(s))))); + put(out, rs.stringExtend("", rs.iterSlice(parts.items))); + const owned: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (p6: string): string => { return p6; }), undefined, 12, true); - put(out, rt.stringFromStrings(rt.iterMap(rt.iterMap(rt.iterSlice(owned.items), (p7: string): rt.StrCow => { - return new rt.Borrowed(p7); - }), rt.strCowStr))); - put(out, rt.stringFromStrings(rt.iterFrom({ items: owned.items, nexts }, Counted.next$iter_Iterator_String))); + put(out, rs.stringFromStrings(rs.iterMap(rs.iterMap(rs.iterSlice(owned.items), (p7: string): rs.StrCow => { + return new rs.Borrowed(p7); + }), rs.strCowStr))); + put(out, rs.stringFromStrings(rs.iterFrom({ items: owned.items, nexts }, Counted.next$iter_Iterator_String))); } else if (_21 === 2) { let t: string = "é"; - const _153: rt.char[] = chars.items; - extendChars(rt.place(() => t, (value) => t = value), _153, kind); - const _157: rt.Iter = rt.iterRev(rt.strChars(s)); - t = rt.stringExtendChars(t, _157); - named.name = rt.stringExtendChars(named.name, rt.iterSlice(chars.items)); - rt.iterEmpty(); - named.name = rt.stringExtendChars(named.name, rt.iterEmpty() as rt.Iter); - const counted3: Counted.Counted = { items: chars.items, nexts }; - t = rt.stringExtendChars(t, rt.iterFrom(counted3, Counted.next$iter_Iterator_char)); + const _153: rs.char[] = chars.items; + extendChars(rs.place(() => t, (value) => t = value), _153, kind); + const _157: rs.Iter = rs.iterRev(rs.strChars(s)); + t = rs.stringExtendChars(t, _157); + named.name = rs.stringExtendChars(named.name, rs.iterSlice(chars.items)); + rs.iterEmpty(); + named.name = rs.stringExtendChars(named.name, rs.iterEmpty() as rs.Iter); + const counted3: Counted.Counted = { items: chars.items, nexts }; + t = rs.stringExtendChars(t, rs.iterFrom(counted3, Counted.next$iter_Iterator_char)); put(out, t); } else { let t2: string = ""; - const _179: rt.Iter = rt.strSplit(s, "/"); - t2 = rt.stringExtend(t2, _179); - const _184: rt.Iter = rt.iterMap(rt.iterSlice(parts.items), (p: string): string => { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, p)]; - return rt.fmtFormat([args2[0], "é"]); + const _179: rs.Iter = rs.strSplit(s, "/"); + t2 = rs.stringExtend(t2, _179); + const _184: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p: string): string => { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, p)]; + return rs.fmtFormat([args2[0], "é"]); }); - t2 = rt.stringExtend(t2, _184); - const _190: rt.Iter = rt.iterRev(rt.iterSlice(parts.items)); - named.name = rt.stringExtend(named.name, _190); - const _197: rt.Iter = rt.iterMap(rt.iterSlice(parts.items), (p2: string): rt.StrCow => { + t2 = rs.stringExtend(t2, _184); + const _190: rs.Iter = rs.iterRev(rs.iterSlice(parts.items)); + named.name = rs.stringExtend(named.name, _190); + const _197: rs.Iter = rs.iterMap(rs.iterSlice(parts.items), (p2: string): rs.StrCow => { return p2; }); - named.name = rt.stringExtend(named.name, rt.iterMap(_197, rt.strCowStr)); - rt.iterEmpty(); - named.name = rt.stringExtend(named.name, rt.iterEmpty() as rt.Iter); + named.name = rs.stringExtend(named.name, rs.iterMap(_197, rs.strCowStr)); + rs.iterEmpty(); + named.name = rs.stringExtend(named.name, rs.iterEmpty() as rs.Iter); const counted4: Counted.Counted = { items: parts.items, nexts }; - t2 = rt.stringExtend(t2, rt.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); + t2 = rs.stringExtend(t2, rs.iterFrom(counted4, Counted.next$iter_Iterator_ref_str)); put(out, t2); } put(out, named.name); - rt.byteVecPush(out, nexts.v); + rs.byteVecPush(out, nexts.v); } -export function extendChars(t: rt.Place, chars: rt.char[], kind: rt.u8): void { - const _4: rt.u8 = rt.u8Rem(rt.u8Div(kind, 4), 3); +export function extendChars(t: rs.Place, chars: rs.char[], kind: rs.u8): void { + const _4: rs.u8 = rs.u8Rem(rs.u8Div(kind, 4), 3); if (_4 === 0) { - const _8: rt.Iter = rt.iterSlice(chars); - t.v = rt.stringExtendChars(t.v, _8); + const _8: rs.Iter = rs.iterSlice(chars); + t.v = rs.stringExtendChars(t.v, _8); } else if (_4 === 1) { - const _9: rt.Iter = rt.iterFilter(rt.iterSlice(chars), (c: rt.char): boolean => { - return rt.isAsciiDigit(c); + const _9: rs.Iter = rs.iterFilter(rs.iterSlice(chars), (c: rs.char): boolean => { + return rs.isAsciiDigit(c); }); - t.v = rt.stringExtendChars(t.v, _9); + t.v = rs.stringExtendChars(t.v, _9); } else { - t.v = rt.stringExtendChars(t.v, rt.iterOption(128512)); + t.v = rs.stringExtendChars(t.v, rs.iterOption(128512)); } } @@ -1320,74 +1320,74 @@ export function extendChars(t: rt.Place, chars: rt.char[], kind: rt.u8): * `String::drain` of `s` by the range `form` picks, between offsets from `a` and `b`, * read from either end by `steps`' bits, then dropped, forgotten, or read to its end. */ -export function drainBy(s: rt.Place, form: rt.u8, a: rt.u8, b: rt.u8, steps: rt.u8, out: rt.ByteVec): void { - let drain!: rt.Iter; - let _35!: rt.u8; - let c!: rt.char | undefined; +export function drainBy(s: rs.Place, form: rs.u8, a: rs.u8, b: rs.u8, steps: rs.u8, out: rs.ByteVec): void { + let drain!: rs.Iter; + let _35!: rs.u8; + let c!: rs.char | undefined; let _71: boolean = false; - const _9: [rt.usize, rt.usize] = [offset(s.v, a), offset(s.v, b)]; - const i: rt.usize = _9[0]; - const j: rt.usize = _9[1]; - const _17: rt.u8 = rt.u8Rem(form, 8); + const _9: [rs.usize, rs.usize] = [offset(s.v, a), offset(s.v, b)]; + const i: rs.usize = _9[0]; + const j: rs.usize = _9[1]; + const _17: rs.u8 = rs.u8Rem(form, 8); if (_17 === 0) { - drain = rt.stringDrain(s, new rt.Range(i, j)); + drain = rs.stringDrain(s, new rs.Range(i, j)); _71 = true; } else if (_17 === 1) { - drain = rt.stringDrain(s, new rt.RangeFrom(i, rt.usizeStep)); + drain = rs.stringDrain(s, new rs.RangeFrom(i, rs.usizeStep)); _71 = true; } else if (_17 === 2) { - drain = rt.stringDrain(s, { end: j }); + drain = rs.stringDrain(s, { end: j }); _71 = true; } else if (_17 === 3) { - drain = rt.stringDrain(s, undefined); + drain = rs.stringDrain(s, undefined); _71 = true; } else if (_17 === 4) { - drain = rt.stringDrain(s, new rt.RangeInclusive(i, j, rt.usizeStep)); + drain = rs.stringDrain(s, new rs.RangeInclusive(i, j, rs.usizeStep)); _71 = true; } else if (_17 === 5) { - drain = rt.stringDrain(s, { end: j, inclusive: true }); + drain = rs.stringDrain(s, { end: j, inclusive: true }); _71 = true; } else if (_17 === 6) { - drain = rt.stringDrain(s, [{ tag: "Excluded", _0: i } as rt.RangeBound, { tag: "Included", _0: j } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + drain = rs.stringDrain(s, [{ tag: "Excluded", _0: i } as rs.RangeBound, { tag: "Included", _0: j } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); _71 = true; } else { - drain = rt.stringDrain(s, [{ tag: "Included", _0: i } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound]); + drain = rs.stringDrain(s, [{ tag: "Included", _0: i } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound]); _71 = true; } - const _32: rt.u8 = rt.u8Rem(steps, 4); - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = _32; + const _32: rs.u8 = rs.u8Rem(steps, 4); + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = _32; while ((_35 = iterStart++) < iterEnd) { - if ((rt.u8Shr(steps, rt.u8Add(2, _35)) & 1) === 0) { - c = rt.iterToOption(drain.next()); + if ((rs.u8Shr(steps, rs.u8Add(2, _35)) & 1) === 0) { + c = rs.iterToOption(drain.next()); } else { - c = rt.iterToOption(drain.nextBack()); + c = rs.iterToOption(drain.nextBack()); } putChar(out, c); } - const _49: rt.u8 = rt.u8Rem(rt.u8Div(form, 8), 4); + const _49: rs.u8 = rs.u8Rem(rs.u8Div(form, 8), 4); if (_49 !== 0) { if (_49 === 1) { _71 = false; } else if (_49 === 2) { _71 = false; - put(out, rt.stringExtendChars("", drain, true)); + put(out, rs.stringExtendChars("", drain, true)); } else { - put(out, rt.stringDrainAsStr(drain)); + put(out, rs.stringDrainAsStr(drain)); _71 = false; - const iter2: rt.Iter = rt.iterRev(drain); + const iter2: rs.Iter = rs.iterRev(drain); while (true) { - const _65: rt.char | rt.Done = iter2.next(); - if (_65 === rt.DONE) { + const _65: rs.char | rs.Done = iter2.next(); + if (_65 === rs.DONE) { break; } putChar(out, _65); } - rt.drop(iter2); + rs.drop(iter2); } } if (_71) { - rt.drop(drain); + rs.drop(drain); } _71 = false; } @@ -1397,45 +1397,45 @@ export function drainBy(s: rt.Place, form: rt.u8, a: rt.u8, b: rt.u8, st * `&mut String`, on a local, and on a field, each printed after each drain. An offset off * a char boundary or out of bounds panics as std's does. */ -export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const mid: number = rt.min(dataLen, rt.u8Rem(kind, 8) as rt.usize); +export function drains(kind: rs.u8, dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const mid: number = rs.min(dataLen, rs.u8Rem(kind, 8) as rs.usize); if (mid > dataLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const head: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart, mid); + const head: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart, mid); let s: string = text(head); const named: Named.Named = { name: text(head) }; - const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); + const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + mid, dataLen - mid), 4); while (true) { - const _18: rt.ByteSlice | rt.Done = iter.next(); - if (_18 === rt.DONE) { + const _18: rs.ByteSlice | rs.Done = iter.next(); + if (_18 === rs.DONE) { break; } - rt.idx(_18, 0); - const _26: Uint8Array = Uint8Array.of(_18.data[_18.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_18, 1), 0), option_unwrapOr$0r2bmpr(rt.byteSliceGet(_18, 2), 16), option_unwrapOr$0r2bmpr(rt.byteSliceGet(_18, 3), 0)); - const form: rt.u8 = _26[0]; - const a: rt.u8 = _26[1]; - const b: rt.u8 = _26[2]; - const steps: rt.u8 = _26[3]; - const _44: rt.u8 = rt.u8Rem(rt.u8Div(form, 32), 4); + rs.idx(_18, 0); + const _26: Uint8Array = Uint8Array.of(_18.data[_18.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_18, 1), 0), option_unwrapOr$1fr498u(rs.byteSliceGet(_18, 2), 16), option_unwrapOr$1fr498u(rs.byteSliceGet(_18, 3), 0)); + const form: rs.u8 = _26[0]; + const a: rs.u8 = _26[1]; + const b: rs.u8 = _26[2]; + const steps: rs.u8 = _26[3]; + const _44: rs.u8 = rs.u8Rem(rs.u8Div(form, 32), 4); if (_44 === 0) { - drainBy(rt.place(() => named.name, (value6) => named.name = value6), form, a, b, steps, out); + drainBy(rs.place(() => named.name, (value6) => named.name = value6), form, a, b, steps, out); } else if (_44 === 1) { - const _49: rt.u8 = rt.u8Rem(form, 4); + const _49: rs.u8 = rs.u8Rem(form, 4); if (_49 === 0) { - const _56: { end: rt.usize } = { end: offset(s, a) }; - put(out, rt.stringExtendChars("", rt.stringDrain(rt.place(() => s, (value5) => s = value5), _56), true)); + const _56: { end: rs.usize } = { end: offset(s, a) }; + put(out, rs.stringExtendChars("", rs.stringDrain(rs.place(() => s, (value5) => s = value5), _56), true)); } else if (_49 === 1) { - const _64: rt.RangeFrom = new rt.RangeFrom(offset(s, a), rt.usizeStep); - rt.byteVecPush(out, rt.ownedCount(rt.stringDrain(rt.place(() => s, (value4) => s = value4), _64)) & 0xff); + const _64: rs.RangeFrom = new rs.RangeFrom(offset(s, a), rs.usizeStep); + rs.byteVecPush(out, rs.ownedCount(rs.stringDrain(rs.place(() => s, (value4) => s = value4), _64)) & 0xff); } else if (_49 === 2) { - putChar(out, rt.ownedLast(rt.stringDrain(rt.place(() => s, (value3) => s = value3), undefined))); + putChar(out, rs.ownedLast(rs.stringDrain(rs.place(() => s, (value3) => s = value3), undefined))); } else { - const _73: rt.Range = new rt.Range(offset(s, a), offset(s, b)); - rt.drop(rt.stringDrain(rt.place(() => s, (value2) => s = value2), _73)); + const _73: rs.Range = new rs.Range(offset(s, a), offset(s, b)); + rs.drop(rs.stringDrain(rs.place(() => s, (value2) => s = value2), _73)); } } else { - drainBy(rt.place(() => s, (value) => s = value), form, a, b, steps, out); + drainBy(rs.place(() => s, (value) => s = value), form, a, b, steps, out); } put(out, s); put(out, named.name); @@ -1448,132 +1448,132 @@ export function drains(kind: rt.u8, dataData: Uint8Array, dataStart: number, dat * hint's lower bound first, which panics past `isize::MAX` before it reads a char, and * else the chars panic with `consumed` past the eighth. */ -export function hinted(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _70!: rt.usize; - const pick: (a0: rt.usize) => rt.u32 = (i: rt.usize): rt.u32 => { - const _4: rt.usize = rt.usizeRem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), 0) as rt.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); +export function hinted(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _70!: rs.usize; + const pick: (a0: rs.usize) => rs.u32 = (i: rs.usize): rs.u32 => { + const _4: rs.usize = rs.usizeRem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), 0) as rs.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); if (!(_4 < 7)) { - rt.panic("index out of bounds: the len is " + 7 + " but the index is " + _4); + rs.panic("index out of bounds: the len is " + 7 + " but the index is " + _4); } return [0, 5, 8, 9, 2147483645, 2147483648, 4294967295][_4]; }; - const _7: [rt.u32, rt.u32] = [pick(0), pick(1)]; - const n: rt.u32 = _7[0]; - const m: rt.u32 = _7[1]; - const sub: rt.usize = rt.usizeDiv(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0) as rt.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); + const _7: [rs.u32, rs.u32] = [pick(0), pick(1)]; + const n: rs.u32 = _7[0]; + const m: rs.u32 = _7[1]; + const sub: rs.usize = rs.usizeDiv(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0) as rs.usize, [0, 5, 8, 9, 2147483645, 2147483648, 4294967295].length); let t: string = "aé"; - const _25: rt.Place = rt.place(() => t, (value) => t = value); - const _26: string = text(option_unwrapOr$1rbuegs(rt.byteSliceGetRange(data, 2), rt.byteSliceFrom(Uint8Array.of()))); + const _25: rs.Place = rs.place(() => t, (value) => t = value); + const _26: string = text(option_unwrapOr$0yvilko(rs.byteSliceGetRange(data, 2), rs.byteSliceFrom(Uint8Array.of()))); _25.v = _25.v + _26; - const calls: rt.Cell = new rt.Cell(0); - const f: (a0: rt.u32) => rt.char = (_2: rt.u32): rt.char => { - rt.cellSet(calls, rt.usizeAdd(calls.v, 1)); + const calls: rs.Cell = new rs.Cell(0); + const f: (a0: rs.u32) => rs.char = (_2: rs.u32): rs.char => { + rs.cellSet(calls, rs.usizeAdd(calls.v, 1)); if (!(calls.v <= 8)) { - rt.panicFmt(["consumed"]); + rs.panicFmt(["consumed"]); } else { - const _127: rt.usize = calls.v; + const _127: rs.usize = calls.v; if (!(_127 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _127); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _127); } return [47, 92, 97, 48, 57, 127, 128, 233, 2047, 2048, 55295, 57344, 65535, 65536, 128512, 1114111][_127]; } }; - const _38: rt.u8 = rt.u8Rem(kind, 10); + const _38: rs.u8 = rs.u8Rem(kind, 10); if (_38 === 0) { - const _40: rt.Place = rt.place(() => t, (value13) => t = value13); - const _41: rt.Iter = rt.iterMap(new rt.Range(0, n), f); - _40.v = rt.stringExtendChars(_40.v, _41); + const _40: rs.Place = rs.place(() => t, (value13) => t = value13); + const _41: rs.Iter = rs.iterMap(new rs.Range(0, n), f); + _40.v = rs.stringExtendChars(_40.v, _41); } else if (_38 === 1) { - t = rt.stringExtendChars("", rt.iterMap(rt.iterChain(new rt.RangeInclusive(0, n, rt.u32Step), new rt.Range(0, n)), f)); + t = rs.stringExtendChars("", rs.iterMap(rs.iterChain(new rs.RangeInclusive(0, n, rs.u32Step), new rs.Range(0, n)), f)); } else if (_38 === 2) { - const _48: rt.Place = rt.place(() => t, (value12) => t = value12); - const _49: rt.Iter = rt.iterSkip(rt.iterMap(new rt.Range(0, rt.u64Or(rt.u64Shl(n as rt.u64, 8), m as rt.u64), rt.u64Step), (i4: rt.u64): rt.char => { - return f(rt.u64Low(i4)); - }), m as rt.usize); - _48.v = rt.stringExtendChars(_48.v, _49); + const _48: rs.Place = rs.place(() => t, (value12) => t = value12); + const _49: rs.Iter = rs.iterSkip(rs.iterMap(new rs.Range(0, rs.u64Or(rs.u64Shl(n as rs.u64, 8), m as rs.u64), rs.u64Step), (i4: rs.u64): rs.char => { + return f(rs.u64Low(i4)); + }), m as rs.usize); + _48.v = rs.stringExtendChars(_48.v, _49); } else if (_38 === 3) { - const _61: rt.Place = rt.place(() => t, (value11) => t = value11); - const _62: rt.Iter = rt.iterTake(rt.iterMap(new rt.Range(0, n), f), m as rt.usize, undefined, true); - _61.v = rt.stringExtendChars(_61.v, _62); + const _61: rs.Place = rs.place(() => t, (value11) => t = value11); + const _62: rs.Iter = rs.iterTake(rs.iterMap(new rs.Range(0, n), f), m as rs.usize, undefined, true); + _61.v = rs.stringExtendChars(_61.v, _62); } else if (_38 === 4) { - const _66: rt.Place = rt.place(() => t, (value10) => t = value10); - const _69: rt.Range = new rt.Range(0, n); + const _66: rs.Place = rs.place(() => t, (value10) => t = value10); + const _69: rs.Range = new rs.Range(0, n); if (!(n === 4294967295)) { _70 = 1; } else { - _70 = rt.usizeAdd(1, rt.usizeRem(m as rt.usize, 2)); + _70 = rs.usizeAdd(1, rs.usizeRem(m as rs.usize, 2)); } - const _67: rt.Iter = rt.iterMap(rt.iterStepBy(_69, _70, undefined, 4294967295), f); - _66.v = rt.stringExtendChars(_66.v, _67); + const _67: rs.Iter = rs.iterMap(rs.iterStepBy(_69, _70, undefined, 4294967295), f); + _66.v = rs.stringExtendChars(_66.v, _67); } else if (_38 === 5) { - if (rt.u32Rem(m, 2) === 0) { - const _78: rt.Place = rt.place(() => t, (value9) => t = value9); - const _79: rt.Iter = rt.iterChain(rt.iterMap(new rt.Range(0, n), f), rt.iterMap(new rt.Range(0, m), f)); - _78.v = rt.stringExtendChars(_78.v, _79); + if (rs.u32Rem(m, 2) === 0) { + const _78: rs.Place = rs.place(() => t, (value9) => t = value9); + const _79: rs.Iter = rs.iterChain(rs.iterMap(new rs.Range(0, n), f), rs.iterMap(new rs.Range(0, m), f)); + _78.v = rs.stringExtendChars(_78.v, _79); } else { - const _84: rt.Place = rt.place(() => t, (value8) => t = value8); - const _85: rt.Iter = rt.iterMap(rt.iterZip(new rt.Range(0, n), new rt.Range(0, m), [false, false]), (_211: [rt.u32, rt.u32]): rt.char => { + const _84: rs.Place = rs.place(() => t, (value8) => t = value8); + const _85: rs.Iter = rs.iterMap(rs.iterZip(new rs.Range(0, n), new rs.Range(0, m), [false, false]), (_211: [rs.u32, rs.u32]): rs.char => { return f(_211[0]); }); - _84.v = rt.stringExtendChars(_84.v, _85); + _84.v = rs.stringExtendChars(_84.v, _85); } } else if (_38 === 6) { - const _91: rt.Place = rt.place(() => t, (value7) => t = value7); - const _92: rt.Iter = rt.iterFlatMap(new rt.Range(0, n), (i2: rt.u32): rt.char[] => { + const _91: rs.Place = rs.place(() => t, (value7) => t = value7); + const _92: rs.Iter = rs.iterFlatMap(new rs.Range(0, n), (i2: rs.u32): rs.char[] => { return [f(i2), f(i2)]; - }, (value: rt.char[]) => rt.iterSlice(value), true, 2); - _91.v = rt.stringExtendChars(_91.v, _92); + }, (value: rs.char[]) => rs.iterSlice(value), true, 2); + _91.v = rs.stringExtendChars(_91.v, _92); } else if (_38 === 7) { - const _96: rt.Place = rt.place(() => t, (value6) => t = value6); - const _97: rt.Iter = rt.iterChain(rt.iterChain(rt.iterChain(rt.iterChain(rt.iterMap(new rt.Range(0, rt.u32SaturatingSub(n, 5)), f), rt.iterOnce(120)), rt.iterOption(121)), rt.strChars("é😀")), rt.iterSlice([122])); - _96.v = rt.stringExtendChars(_96.v, _97); + const _96: rs.Place = rs.place(() => t, (value6) => t = value6); + const _97: rs.Iter = rs.iterChain(rs.iterChain(rs.iterChain(rs.iterChain(rs.iterMap(new rs.Range(0, rs.u32SaturatingSub(n, 5)), f), rs.iterOnce(120)), rs.iterOption(121)), rs.strChars("é😀")), rs.iterSlice([122])); + _96.v = rs.stringExtendChars(_96.v, _97); } else if (_38 === 8) { - const _112: rt.usize = rt.usizeRem(sub, 3); + const _112: rs.usize = rs.usizeRem(sub, 3); if (_112 === 0) { - const _114: rt.Place = rt.place(() => t, (value5) => t = value5); - const _115: rt.Iter = rt.iterMap(new rt.Range({ hi: 0x10000000, lo: 0 } as rt.u64, rt.u64Add({ hi: 0x10000000, lo: 0 } as rt.u64, n as rt.u64), rt.u64Step), (_210: rt.u64): rt.char => { + const _114: rs.Place = rs.place(() => t, (value5) => t = value5); + const _115: rs.Iter = rs.iterMap(new rs.Range({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_210: rs.u64): rs.char => { return f(0); }); - _114.v = rt.stringExtendChars(_114.v, _115); + _114.v = rs.stringExtendChars(_114.v, _115); } else if (_112 === 1) { - const _128: rt.Place = rt.place(() => t, (value4) => t = value4); - const _129: rt.Iter = rt.iterMap(new rt.Range(rt.i128Neg(rt.i128Shl(1, 100)), rt.i128Add(rt.i128Neg(rt.i128Shl(1, 100)), n as rt.i128), rt.i128Step), (_27: rt.i128): rt.char => { + const _128: rs.Place = rs.place(() => t, (value4) => t = value4); + const _129: rs.Iter = rs.iterMap(new rs.Range(rs.i128Neg(rs.i128Shl(1, 100)), rs.i128Add(rs.i128Neg(rs.i128Shl(1, 100)), n as rs.i128), rs.i128Step), (_27: rs.i128): rs.char => { return f(0); }); - _128.v = rt.stringExtendChars(_128.v, _129); + _128.v = rs.stringExtendChars(_128.v, _129); } else { - const _146: rt.Place = rt.place(() => t, (value3) => t = value3); - const _147: rt.Iter = rt.iterMap(new rt.RangeInclusive({ hi: 0x10000000, lo: 0 } as rt.u64, rt.u64Add({ hi: 0x10000000, lo: 0 } as rt.u64, n as rt.u64), rt.u64Step), (_24: rt.u64): rt.char => { + const _146: rs.Place = rs.place(() => t, (value3) => t = value3); + const _147: rs.Iter = rs.iterMap(new rs.RangeInclusive({ hi: 0x10000000, lo: 0 } as rs.u64, rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, n as rs.u64), rs.u64Step), (_24: rs.u64): rs.char => { return f(0); }); - _146.v = rt.stringExtendChars(_146.v, _147); + _146.v = rs.stringExtendChars(_146.v, _147); } } else { - const chars: rt.Peekable = rt.iterPeekable(rt.iterFuse(rt.iterRev(rt.iterMap(rt.iterEnumerate(rt.iterMap(new rt.Range(0, n), f)), (_23: [rt.usize, rt.char]): rt.char => { + const chars: rs.Peekable = rs.iterPeekable(rs.iterFuse(rs.iterRev(rs.iterMap(rs.iterEnumerate(rs.iterMap(new rs.Range(0, n), f)), (_23: [rs.usize, rs.char]): rs.char => { return _23[1]; })), true)); - putChar(out, rt.peekablePeek(chars)); - const _172: rt.Place = rt.place(() => t, (value2) => t = value2); - _172.v = rt.stringExtendChars(_172.v, chars); + putChar(out, rs.peekablePeek(chars)); + const _172: rs.Place = rs.place(() => t, (value2) => t = value2); + _172.v = rs.stringExtendChars(_172.v, chars); } put(out, t); } /** A part a checked read gives, or 0xfe if it gave none. */ -export function putPart(out: rt.ByteVec, part: string | undefined): void { +export function putPart(out: rs.ByteVec, part: string | undefined): void { if (part === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { put(out, part); } } /** A part a checked `&mut` read gives, upper-cased and put, or 0xfe if it gave none. */ -export function putUpper(out: rt.ByteVec, part: rt.Place | undefined): void { +export function putUpper(out: rs.ByteVec, part: rs.Place | undefined): void { if (part === undefined) { - rt.byteVecPush(out, 254); + rs.byteVecPush(out, 254); } else { - part.v = rt.strToAsciiUppercase(part.v); + part.v = rs.strToAsciiUppercase(part.v); put(out, part.v); } } @@ -1582,12 +1582,12 @@ export function putUpper(out: rt.ByteVec, part: rt.Place | undefined): v * `a..=b` searched to its end, which leaves it at `b` but exhausted: `b + 1..b + 1` as an * index. Skipped to `b` first, so a search to `usize::MAX` is short. */ -export function exhausted(a: rt.usize, b: rt.usize): rt.RangeInclusive { - const r: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); +export function exhausted(a: rs.usize, b: rs.usize): rs.RangeInclusive { + const r: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); if (b > a) { - rt.iterNth(r, rt.usizeSub(rt.usizeSub(b, a), 1)); + rs.iterNth(r, rs.usizeSub(rs.usizeSub(b, a), 1)); } - rt.iterFind(r, (_2: rt.usize): boolean => { + rs.iterFind(r, (_2: rs.usize): boolean => { return false; }); return r; @@ -1599,7 +1599,7 @@ export function exhausted(a: rt.usize, b: rt.usize): rt.RangeInclusive * up to two past the end, or `usize::MAX` for 0xff. A checked read out of bounds, backwards, * or inside a char gives `None`, and indexing panics as std's does. */ -export function gets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function gets(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let text!: string; if ((kind & 16) === 0) { text = "aébࠀc😀d"; @@ -1607,117 +1607,117 @@ export function gets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { text = ""; } const _7: string = text; - const at: (a0: rt.usize) => rt.usize = (i: rt.usize): rt.usize => { - const _3: rt.u8 | undefined = rt.byteSliceGet(data, i); + const at: (a0: rs.usize) => rs.usize = (i: rs.usize): rs.usize => { + const _3: rs.u8 | undefined = rs.byteSliceGet(data, i); if (_3 === undefined) { return 0; } if (_3 === 255) { return 4294967295; } - return rt.usizeRem(_3 as rt.usize, rt.usizeAdd(rt.stringLen(_7), 3)); + return rs.usizeRem(_3 as rs.usize, rs.usizeAdd(rs.stringLen(_7), 3)); }; - const _10: [rt.usize, rt.usize] = [at(0), at(1)]; - const a: rt.usize = _10[0]; - const b: rt.usize = _10[1]; + const _10: [rs.usize, rs.usize] = [at(0), at(1)]; + const a: rs.usize = _10[0]; + const b: rs.usize = _10[1]; const s: string = text; let string: string = text; - const _20: rt.u8 = rt.u8Rem(kind, 16); + const _20: rs.u8 = rs.u8Rem(kind, 16); if (_20 === 0) { - putPart(out, rt.strGet(s, a, b)); - putPart(out, rt.strGet(s, a)); - putPart(out, rt.strGet(s, 0, b)); - putPart(out, rt.strGet(s, 0)); + putPart(out, rs.strGet(s, a, b)); + putPart(out, rs.strGet(s, a)); + putPart(out, rs.strGet(s, 0, b)); + putPart(out, rs.strGet(s, 0)); } else if (_20 === 1) { - const bounds22 = rt.sliceGetBounds(new rt.RangeInclusive(a, b, rt.usizeStep), rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds22[0], bounds22[1])); - const bounds23 = rt.sliceGetBounds({ end: b, inclusive: true }, rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds23[0], bounds23[1])); + const bounds22 = rs.sliceGetBounds(new rs.RangeInclusive(a, b, rs.usizeStep), rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds22[0], bounds22[1])); + const bounds23 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds23[0], bounds23[1])); const _41: string = string; - const bounds24 = rt.sliceGetBounds(exhausted(a, b), rt.stringLen(_41)); - putPart(out, rt.strGet(_41, bounds24[0], bounds24[1])); + const bounds24 = rs.sliceGetBounds(exhausted(a, b), rs.stringLen(_41)); + putPart(out, rs.strGet(_41, bounds24[0], bounds24[1])); } else if (_20 === 2) { - const bounds18 = rt.sliceGetBounds([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds18[0], bounds18[1])); - const bounds19 = rt.sliceGetBounds([{ tag: "Included", _0: a } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds19[0], bounds19[1])); - const bounds20 = rt.sliceGetBounds([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Unbounded" } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds20[0], bounds20[1])); - const bounds21 = rt.sliceGetBounds([{ tag: "Unbounded" } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s)); - putPart(out, rt.strGet(s, bounds21[0], bounds21[1])); + const bounds18 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds18[0], bounds18[1])); + const bounds19 = rs.sliceGetBounds([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds19[0], bounds19[1])); + const bounds20 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Unbounded" } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds20[0], bounds20[1])); + const bounds21 = rs.sliceGetBounds([{ tag: "Unbounded" } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); + putPart(out, rs.strGet(s, bounds21[0], bounds21[1])); } else if (_20 === 3) { - const bounds17 = rt.strInclusive(s, new rt.RangeInclusive(a, b, rt.usizeStep)); - put(out, rt.strSlice(s, bounds17[0], bounds17[1])); + const bounds17 = rs.strInclusive(s, new rs.RangeInclusive(a, b, rs.usizeStep)); + put(out, rs.strSlice(s, bounds17[0], bounds17[1])); } else if (_20 === 4) { - const bounds16 = rt.strInclusive(s, { end: b, inclusive: true }); - put(out, rt.strSlice(s, bounds16[0], bounds16[1])); + const bounds16 = rs.strInclusive(s, { end: b, inclusive: true }); + put(out, rs.strSlice(s, bounds16[0], bounds16[1])); } else if (_20 === 5) { - const _70: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const bounds15 = rt.strInclusive(string, _70); - put(out, rt.strSlice(string, bounds15[0], bounds15[1])); + const _70: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const bounds15 = rs.strInclusive(string, _70); + put(out, rs.strSlice(string, bounds15[0], bounds15[1])); } else if (_20 === 6) { - const bounds14 = rt.strInclusive(string, { end: b, inclusive: true }); - put(out, rt.strSlice(string, bounds14[0], bounds14[1])); + const bounds14 = rs.strInclusive(string, { end: b, inclusive: true }); + put(out, rs.strSlice(string, bounds14[0], bounds14[1])); } else if (_20 === 7) { - const bounds13 = rt.strInclusive(s, exhausted(a, b)); - put(out, rt.strSlice(s, bounds13[0], bounds13[1])); + const bounds13 = rs.strInclusive(s, exhausted(a, b)); + put(out, rs.strSlice(s, bounds13[0], bounds13[1])); } else if (_20 === 8) { - const bounds12 = rt.boundsRange([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s)); - put(out, rt.strSlice(s, bounds12[0], bounds12[1])); + const bounds12 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s)); + put(out, rs.strSlice(s, bounds12[0], bounds12[1])); } else if (_20 === 9) { - const bounds11 = rt.boundsRange([{ tag: "Included", _0: a } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(string)); - put(out, rt.strSlice(string, bounds11[0], bounds11[1])); + const bounds11 = rs.boundsRange([{ tag: "Included", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(string)); + put(out, rs.strSlice(string, bounds11[0], bounds11[1])); } else if (_20 === 10) { - const _89: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const s7 = rt.place(() => string, (value6) => string = value6); - const bounds7 = rt.sliceGetBounds(_89, rt.stringLen(s7.v)); - putUpper(out, rt.strGetMut(s7, bounds7[0], bounds7[1])); - const s8 = rt.place(() => string, (value7) => string = value7); - const bounds8 = rt.sliceGetBounds({ end: b, inclusive: true }, rt.stringLen(s8.v)); - putUpper(out, rt.strGetMut(s8, bounds8[0], bounds8[1])); - const _99: rt.RangeInclusive = exhausted(a, b); - const s9 = rt.place(() => string, (value8) => string = value8); - const bounds9 = rt.sliceGetBounds(_99, rt.stringLen(s9.v)); - putUpper(out, rt.strGetMut(s9, bounds9[0], bounds9[1])); - const s10 = rt.place(() => string, (value9) => string = value9); - const bounds10 = rt.sliceGetBounds([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Included", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s10.v)); - putUpper(out, rt.strGetMut(s10, bounds10[0], bounds10[1])); + const _89: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const s7 = rs.place(() => string, (value6) => string = value6); + const bounds7 = rs.sliceGetBounds(_89, rs.stringLen(s7.v)); + putUpper(out, rs.strGetMut(s7, bounds7[0], bounds7[1])); + const s8 = rs.place(() => string, (value7) => string = value7); + const bounds8 = rs.sliceGetBounds({ end: b, inclusive: true }, rs.stringLen(s8.v)); + putUpper(out, rs.strGetMut(s8, bounds8[0], bounds8[1])); + const _99: rs.RangeInclusive = exhausted(a, b); + const s9 = rs.place(() => string, (value8) => string = value8); + const bounds9 = rs.sliceGetBounds(_99, rs.stringLen(s9.v)); + putUpper(out, rs.strGetMut(s9, bounds9[0], bounds9[1])); + const s10 = rs.place(() => string, (value9) => string = value9); + const bounds10 = rs.sliceGetBounds([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Included", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s10.v)); + putUpper(out, rs.strGetMut(s10, bounds10[0], bounds10[1])); put(out, string); } else if (_20 === 11) { - const _113: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - const s6 = rt.place(() => string, (value5) => string = value5); - const bounds6 = rt.strInclusive(s6.v, _113); - const _111: rt.Place = rt.strPart(s6, bounds6[0], bounds6[1]); - _111.v = rt.strToAsciiUppercase(_111.v); + const _113: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + const s6 = rs.place(() => string, (value5) => string = value5); + const bounds6 = rs.strInclusive(s6.v, _113); + const _111: rs.Place = rs.strPart(s6, bounds6[0], bounds6[1]); + _111.v = rs.strToAsciiUppercase(_111.v); put(out, string); } else if (_20 === 12) { - const s5 = rt.place(() => string, (value4) => string = value4); - const bounds5 = rt.strInclusive(s5.v, { end: b, inclusive: true }); - const _118: rt.Place = rt.strPart(s5, bounds5[0], bounds5[1]); - _118.v = rt.strToAsciiUppercase(_118.v); + const s5 = rs.place(() => string, (value4) => string = value4); + const bounds5 = rs.strInclusive(s5.v, { end: b, inclusive: true }); + const _118: rs.Place = rs.strPart(s5, bounds5[0], bounds5[1]); + _118.v = rs.strToAsciiUppercase(_118.v); put(out, string); } else if (_20 === 13) { - const _128: rt.RangeInclusive = exhausted(a, b); - const s4 = rt.place(() => string, (value3) => string = value3); - const bounds4 = rt.strInclusive(s4.v, _128); - const _126: rt.Place = rt.strPart(s4, bounds4[0], bounds4[1]); - _126.v = rt.strToAsciiUppercase(_126.v); + const _128: rs.RangeInclusive = exhausted(a, b); + const s4 = rs.place(() => string, (value3) => string = value3); + const bounds4 = rs.strInclusive(s4.v, _128); + const _126: rs.Place = rs.strPart(s4, bounds4[0], bounds4[1]); + _126.v = rs.strToAsciiUppercase(_126.v); put(out, string); } else if (_20 === 14) { - const s3 = rt.place(() => string, (value2) => string = value2); - const bounds3 = rt.boundsRange([{ tag: "Excluded", _0: a } as rt.RangeBound, { tag: "Excluded", _0: b } as rt.RangeBound] as [rt.RangeBound, rt.RangeBound], rt.stringLen(s3.v)); - const _133: rt.Place = rt.strPart(s3, bounds3[0], bounds3[1]); - _133.v = rt.strToAsciiUppercase(_133.v); + const s3 = rs.place(() => string, (value2) => string = value2); + const bounds3 = rs.boundsRange([{ tag: "Excluded", _0: a } as rs.RangeBound, { tag: "Excluded", _0: b } as rs.RangeBound] as [rs.RangeBound, rs.RangeBound], rs.stringLen(s3.v)); + const _133: rs.Place = rs.strPart(s3, bounds3[0], bounds3[1]); + _133.v = rs.strToAsciiUppercase(_133.v); put(out, string); } else { - const s2 = rt.place(() => string, (value) => string = value); - const bounds = rt.strInclusive(s2.v, { end: b, inclusive: true }); - const part: rt.Place = rt.strPart(s2, bounds[0], bounds[1]); - const last: rt.usize = rt.usizeSaturatingSub(rt.stringLen(part.v), 1); - const _150: rt.RangeInclusive = new rt.RangeInclusive(rt.min(a, last), last, rt.usizeStep); - const bounds2 = rt.strInclusive(part.v, _150); - const _149: rt.Place = rt.strPart(part, bounds2[0], bounds2[1]); - _149.v = rt.strToAsciiUppercase(_149.v); + const s2 = rs.place(() => string, (value) => string = value); + const bounds = rs.strInclusive(s2.v, { end: b, inclusive: true }); + const part: rs.Place = rs.strPart(s2, bounds[0], bounds[1]); + const last: rs.usize = rs.usizeSaturatingSub(rs.stringLen(part.v), 1); + const _150: rs.RangeInclusive = new rs.RangeInclusive(rs.min(a, last), last, rs.usizeStep); + const bounds2 = rs.strInclusive(part.v, _150); + const _149: rs.Place = rs.strPart(part, bounds2[0], bounds2[1]); + _149.v = rs.strToAsciiUppercase(_149.v); put(out, string); } } @@ -1726,27 +1726,27 @@ export function gets(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * An iterator's size hint, and then each item it yields with its `Display` and size hint * before it, and what a clone and its consumers read partway. */ -export function walk$str_EncodeUtf16(out: rt.ByteVec, it: rt.Iter, putItem: (a0: rt.ByteVec, a1: rt.u16) => undefined): void { - const copy: rt.Iter = it.clone(); +export function walk$str_EncodeUtf16(out: rs.ByteVec, it: rs.Iter, putItem: (a0: rs.ByteVec, a1: rs.u16) => undefined): void { + const copy: rs.Iter = it.clone(); while (true) { - const _9: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _9[0]; - const high: rt.usize | undefined = _9[1]; + const _9: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _9[0]; + const high: rs.usize | undefined = _9[1]; putOffset(out, low); putOffset(out, high); - const _14: rt.u16 | rt.Done = it.next(); - if (_14 === rt.DONE) { + const _14: rs.u16 | rs.Done = it.next(); + if (_14 === rs.DONE) { break; } putItem(out, _14); } - putOffset(out, rt.iterCount(copy.clone())); - const rest: rt.Iter = copy.clone(); - rt.iterForEach(rt.iterOption(rt.iterNth(rest, 2)), (item2: rt.u16): undefined => { + putOffset(out, rs.iterCount(copy.clone())); + const rest: rs.Iter = copy.clone(); + rs.iterForEach(rs.iterOption(rs.iterNth(rest, 2)), (item2: rs.u16): undefined => { putItem(out, item2); }); putOffset(out, rest.sizeHint()[0]); - rt.iterForEach(rt.iterOption(rt.iterLast(rest)), (item3: rt.u16): undefined => { + rs.iterForEach(rs.iterOption(rs.iterLast(rest)), (item3: rs.u16): undefined => { putItem(out, item3); }); } @@ -1755,27 +1755,27 @@ export function walk$str_EncodeUtf16(out: rt.ByteVec, it: rt.Iter, putIt * An iterator's size hint, and then each item it yields with its `Display` and size hint * before it, and what a clone and its consumers read partway. */ -export function walk$str_EscapeDebug(out: rt.ByteVec, it: rt.Iter, putItem: (a0: rt.ByteVec, a1: rt.char) => undefined): void { - const copy: rt.Iter = it.clone(); +export function walk$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter, putItem: (a0: rs.ByteVec, a1: rs.char) => undefined): void { + const copy: rs.Iter = it.clone(); while (true) { - const _9: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _9[0]; - const high: rt.usize | undefined = _9[1]; + const _9: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _9[0]; + const high: rs.usize | undefined = _9[1]; putOffset(out, low); putOffset(out, high); - const _14: rt.char | rt.Done = it.next(); - if (_14 === rt.DONE) { + const _14: rs.char | rs.Done = it.next(); + if (_14 === rs.DONE) { break; } putItem(out, _14); } - putOffset(out, rt.iterCount(copy.clone())); - const rest: rt.Iter = copy.clone(); - rt.iterForEach(rt.iterOption(rt.iterNth(rest, 2)), (item2: rt.char): undefined => { + putOffset(out, rs.iterCount(copy.clone())); + const rest: rs.Iter = copy.clone(); + rs.iterForEach(rs.iterOption(rs.iterNth(rest, 2)), (item2: rs.char): undefined => { putItem(out, item2); }); putOffset(out, rest.sizeHint()[0]); - rt.iterForEach(rt.iterOption(rt.iterLast(rest)), (item3: rt.char): undefined => { + rs.iterForEach(rs.iterOption(rs.iterLast(rest)), (item3: rs.char): undefined => { putItem(out, item3); }); } @@ -1784,27 +1784,27 @@ export function walk$str_EscapeDebug(out: rt.ByteVec, it: rt.Iter, putI * An iterator's size hint, and then each item it yields with its `Display` and size hint * before it, and what a clone and its consumers read partway. */ -export function walk$str_EscapeDefault(out: rt.ByteVec, it: rt.Iter, putItem: (a0: rt.ByteVec, a1: rt.char) => undefined): void { - const copy: rt.Iter = it.clone(); +export function walk$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter, putItem: (a0: rs.ByteVec, a1: rs.char) => undefined): void { + const copy: rs.Iter = it.clone(); while (true) { - const _9: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _9[0]; - const high: rt.usize | undefined = _9[1]; + const _9: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _9[0]; + const high: rs.usize | undefined = _9[1]; putOffset(out, low); putOffset(out, high); - const _14: rt.char | rt.Done = it.next(); - if (_14 === rt.DONE) { + const _14: rs.char | rs.Done = it.next(); + if (_14 === rs.DONE) { break; } putItem(out, _14); } - putOffset(out, rt.iterCount(copy.clone())); - const rest: rt.Iter = copy.clone(); - rt.iterForEach(rt.iterOption(rt.iterNth(rest, 2)), (item2: rt.char): undefined => { + putOffset(out, rs.iterCount(copy.clone())); + const rest: rs.Iter = copy.clone(); + rs.iterForEach(rs.iterOption(rs.iterNth(rest, 2)), (item2: rs.char): undefined => { putItem(out, item2); }); putOffset(out, rest.sizeHint()[0]); - rt.iterForEach(rt.iterOption(rt.iterLast(rest)), (item3: rt.char): undefined => { + rs.iterForEach(rs.iterOption(rs.iterLast(rest)), (item3: rs.char): undefined => { putItem(out, item3); }); } @@ -1813,27 +1813,27 @@ export function walk$str_EscapeDefault(out: rt.ByteVec, it: rt.Iter, pu * An iterator's size hint, and then each item it yields with its `Display` and size hint * before it, and what a clone and its consumers read partway. */ -export function walk$str_EscapeUnicode(out: rt.ByteVec, it: rt.Iter, putItem: (a0: rt.ByteVec, a1: rt.char) => undefined): void { - const copy: rt.Iter = it.clone(); +export function walk$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter, putItem: (a0: rs.ByteVec, a1: rs.char) => undefined): void { + const copy: rs.Iter = it.clone(); while (true) { - const _9: [rt.usize, rt.usize | undefined] = it.sizeHint(); - const low: rt.usize = _9[0]; - const high: rt.usize | undefined = _9[1]; + const _9: [rs.usize, rs.usize | undefined] = it.sizeHint(); + const low: rs.usize = _9[0]; + const high: rs.usize | undefined = _9[1]; putOffset(out, low); putOffset(out, high); - const _14: rt.char | rt.Done = it.next(); - if (_14 === rt.DONE) { + const _14: rs.char | rs.Done = it.next(); + if (_14 === rs.DONE) { break; } putItem(out, _14); } - putOffset(out, rt.iterCount(copy.clone())); - const rest: rt.Iter = copy.clone(); - rt.iterForEach(rt.iterOption(rt.iterNth(rest, 2)), (item2: rt.char): undefined => { + putOffset(out, rs.iterCount(copy.clone())); + const rest: rs.Iter = copy.clone(); + rs.iterForEach(rs.iterOption(rs.iterNth(rest, 2)), (item2: rs.char): undefined => { putItem(out, item2); }); putOffset(out, rest.sizeHint()[0]); - rt.iterForEach(rt.iterOption(rt.iterLast(rest)), (item3: rt.char): undefined => { + rs.iterForEach(rs.iterOption(rs.iterLast(rest)), (item3: rs.char): undefined => { putItem(out, item3); }); } @@ -1842,14 +1842,14 @@ export function walk$str_EscapeUnicode(out: rt.ByteVec, it: rt.Iter, pu * An escape's `Display`, which no width pads, then what `walk` reads, then its `Display` * after each char. */ -export function escaped$str_EscapeDebug(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 40 }, args2[0])])); - walk$str_EscapeDebug(out, it.clone(), (out2: rt.ByteVec, c: rt.char): undefined => { +export function escaped$str_EscapeDebug(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + walk$str_EscapeDebug(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); - while (rt.iterToOption(it.next()) !== undefined) { - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f))); + while (rs.iterToOption(it.next()) !== undefined) { + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); } } @@ -1857,14 +1857,14 @@ export function escaped$str_EscapeDebug(out: rt.ByteVec, it: rt.Iter): * An escape's `Display`, which no width pads, then what `walk` reads, then its `Display` * after each char. */ -export function escaped$str_EscapeDefault(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 40 }, args2[0])])); - walk$str_EscapeDefault(out, it.clone(), (out2: rt.ByteVec, c: rt.char): undefined => { +export function escaped$str_EscapeDefault(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + walk$str_EscapeDefault(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); - while (rt.iterToOption(it.next()) !== undefined) { - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f))); + while (rs.iterToOption(it.next()) !== undefined) { + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); } } @@ -1872,14 +1872,14 @@ export function escaped$str_EscapeDefault(out: rt.ByteVec, it: rt.Iter) * An escape's `Display`, which no width pads, then what `walk` reads, then its `Display` * after each char. */ -export function escaped$str_EscapeUnicode(out: rt.ByteVec, it: rt.Iter): void { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f)]; - put(out, rt.fmtFormat([args2[0], "|", rt.fmtSpec({ align: ">", width: 40 }, args2[0])])); - walk$str_EscapeUnicode(out, it.clone(), (out2: rt.ByteVec, c: rt.char): undefined => { +export function escaped$str_EscapeUnicode(out: rs.ByteVec, it: rs.Iter): void { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f)]; + put(out, rs.fmtFormat([args2[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args2[0])])); + walk$str_EscapeUnicode(out, it.clone(), (out2: rs.ByteVec, c: rs.char): undefined => { putChar(out2, c); }); - while (rt.iterToOption(it.next()) !== undefined) { - put(out, rt.fmtToString((f: rt.Formatter) => rt.fmtStrEscapeDisplay(it, f))); + while (rs.iterToOption(it.next()) !== undefined) { + put(out, rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(it, f))); } } @@ -1888,86 +1888,86 @@ export function escaped$str_EscapeUnicode(out: rt.ByteVec, it: rt.Iter) * values: a final sigma by the chars around it, each escape's `Display` before and partway, * and each iterator's size hints as it goes. */ -export function unicode(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const s: string = rt.stringExtendChars("", rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.char => { - const _54: rt.usize = rt.u8Rem(_2, 32) as rt.usize; +export function unicode(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const s: string = rs.stringExtendChars("", rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.char => { + const _54: rs.usize = rs.u8Rem(_2, 32) as rs.usize; if (!(_54 < 32)) { - rt.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); + rs.panic("index out of bounds: the len is " + 32 + " but the index is " + _54); } return [931, 931, 962, 65, 97, 453, 66560, 223, 304, 912, 64259, 46, 39, 58, 769, 837, 173, 119143, 32, 49, 20013, 128512, 233, 34, 92, 10, 9, 0, 127, 57344, 65279, 1114111][_54]; })); - const words: rt.Vec = rt.iterToVec(rt.strSplit(s, " "), "next", 8); - const _11: rt.u8 = rt.u8Rem(kind, 5); + const words: rs.Vec = rs.iterToVec(rs.strSplit(s, " "), "next", 8); + const _11: rs.u8 = rs.u8Rem(kind, 5); if (_11 === 0) { - put(out, rt.strToLowercase(s)); - put(out, rt.strToUppercase(s)); - const lower: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (a08: string): string => { - return rt.strToLowercase(a08); + put(out, rs.strToLowercase(s)); + put(out, rs.strToUppercase(s)); + const lower: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a08: string): string => { + return rs.strToLowercase(a08); }), undefined, 12, true); - const upper: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(words.items), (a09: string): string => { - return rt.strToUppercase(a09); + const upper: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(words.items), (a09: string): string => { + return rs.strToUppercase(a09); }), undefined, 12, true); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(lower.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(upper.items, f, rt.fmtStr)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(lower.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(upper.items, f, rs.fmtStr)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]])); } else if (_11 === 1) { - escaped$str_EscapeDebug(out, rt.strEscapeDebug(s)); - const each: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(words.items), (a07: string): rt.Iter => { - return rt.strEscapeDebug(a07); - }), (e2: rt.Iter): string => { - return rt.fmtToString((f: rt.Formatter) => rt.fmtStrEscapeDisplay(e2, f)); + escaped$str_EscapeDebug(out, rs.strEscapeDebug(s)); + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a07: string): rs.Iter => { + return rs.strEscapeDebug(a07); + }), (e2: rs.Iter): string => { + return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e2, f)); }), undefined, 12, true); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(each.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtStr(s, f)]; - put(out, rt.fmtFormat([args4[0], "|", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([args4[0], "|", args4[1]])); } else if (_11 === 2) { - escaped$str_EscapeDefault(out, rt.strEscapeDefault(s)); - const part2 = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(words.items), (a06: string): rt.Iter => { - return rt.strEscapeDefault(a06); - }), (e: rt.Iter): string => { - return rt.fmtToString((f: rt.Formatter) => rt.fmtStrEscapeDisplay(e, f)); + escaped$str_EscapeDefault(out, rs.strEscapeDefault(s)); + const part2 = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a06: string): rs.Iter => { + return rs.strEscapeDefault(a06); + }), (e: rs.Iter): string => { + return rs.fmtToString((f: rs.Formatter) => rs.fmtStrEscapeDisplay(e, f)); }), undefined, 12, true); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, rt.fmtStr)]; - put(out, rt.fmtFormat([args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.fmtStr)]; + put(out, rs.fmtFormat([args6[0]])); } else if (_11 === 3) { - escaped$str_EscapeUnicode(out, rt.strEscapeUnicode(s)); - const part = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(words.items), (a04: string): rt.Iter => { - return rt.strEscapeUnicode(a04); - }), (a05: rt.Iter): rt.usize => { - return rt.iterCount(a05); + escaped$str_EscapeUnicode(out, rs.strEscapeUnicode(s)); + const part = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a04: string): rs.Iter => { + return rs.strEscapeUnicode(a04); + }), (a05: rs.Iter): rs.usize => { + return rs.iterCount(a05); }), undefined, 4, true); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part.items, f, rt.usizeDebug)]; - put(out, rt.fmtFormat([args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part.items, f, rs.usizeDebug)]; + put(out, rs.fmtFormat([args8[0]])); } else { - const it: rt.Iter = rt.strEncodeUtf16(s); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.debugStructFinishNonExhaustive(rt.fmtDebugStruct(f, "EncodeUtf16"))]; - put(out, rt.fmtFormat([args10[0], "|", rt.fmtSpec({ alternate: true }, args10[0]), "|", rt.fmtSpec({ align: ">", width: 30 }, args10[0])])); - walk$str_EncodeUtf16(out, it.clone(), (out2: rt.ByteVec, u: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(u))); + const it: rs.Iter = rs.strEncodeUtf16(s); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.debugStructFinishNonExhaustive(rs.fmtDebugStruct(f, "EncodeUtf16"))]; + put(out, rs.fmtFormat([args10[0], "|", rs.fmtSpec({ alternate: true }, args10[0]), "|", rs.fmtSpec({ align: ">", width: 30 }, args10[0])])); + walk$str_EncodeUtf16(out, it.clone(), (out2: rs.ByteVec, u: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(u))); }); - const units: rt.Vec = rt.iterToVec(it, "next", 2); - const each4: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(words.items), (a0: string): rt.Iter => { - return rt.strEncodeUtf16(a0); - }), (a02: rt.Iter): rt.usize => { - return rt.iterCount(a02); + const units: rs.Vec = rs.iterToVec(it, "next", 2); + const each4: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(words.items), (a0: string): rs.Iter => { + return rs.strEncodeUtf16(a0); + }), (a02: rs.Iter): rs.usize => { + return rs.iterCount(a02); }), undefined, 4, true); - const _164: boolean = rt.stringExtendChars("", rt.iterMap(rt.charDecodeUtf16(rt.iterSlice(units.items)), (a03: rt.Result): rt.char => { - return rt.resultUnwrap(a03, rt.fmtDecodeUtf16ErrorDebug); + const _164: boolean = rs.stringExtendChars("", rs.iterMap(rs.charDecodeUtf16(rs.iterSlice(units.items)), (a03: rs.Result): rs.char => { + return rs.resultUnwrap(a03, rs.fmtDecodeUtf16ErrorDebug); })) === s; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(units.items, f, rt.u16Debug), (f: rt.Formatter) => rt.fmtList(each4.items, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtBool(_164, f)]; - put(out, rt.fmtFormat([args12[0], "|", args12[1], "|", args12[2]])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(units.items, f, rs.u16Debug), (f: rs.Formatter) => rs.fmtList(each4.items, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(_164, f)]; + put(out, rs.fmtFormat([args12[0], "|", args12[1], "|", args12[2]])); } } /** What a `String` from UTF-16 is, or its error's `Display`, padded or not, and `Debug`. */ -export function putUtf16(out: rt.ByteVec, r: rt.Result): void { +export function putUtf16(out: rs.ByteVec, r: rs.Result): void { if (r.ok) { const part = r.value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(part, f)]; - put(out, rt.fmtFormat([args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part, f)]; + put(out, rs.fmtFormat([args2[0]])); } else { - const e: rt.FromUtf16Error = r.error; - const _24: rt.usize = rt.stringLen(rt.fmtToString((f: rt.Formatter) => rt.fmtFromUtf16ErrorDisplay(e, f))); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtFromUtf16ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtFromUtf16ErrorDebug(e, f), (f: rt.Formatter) => rt.usizeDisplay(_24, f)]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ align: ">", width: 40 }, args4[0]), "|", rt.fmtSpec({ fill: "-", align: "<", width: 12 }, args4[0]), "|", args4[1], "|", rt.fmtSpec({ alternate: true }, args4[1]), "|", args4[2]])); + const e: rs.FromUtf16Error = r.error; + const _24: rs.usize = rs.stringLen(rs.fmtToString((f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f))); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtFromUtf16ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtFromUtf16ErrorDebug(e, f), (f: rs.Formatter) => rs.usizeDisplay(_24, f)]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 40 }, args4[0]), "|", rs.fmtSpec({ fill: "-", align: "<", width: 12 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1]), "|", args4[2]])); } } @@ -1977,82 +1977,82 @@ export function putUtf16(out: rt.ByteVec, r: rt.Result; - if (rt.u8Rem(kind, 2) === 0) { - units = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u16 => { - const _59: rt.usize = rt.u8Rem(_2, 16) as rt.usize; +export function utf16(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let units!: rs.Vec; + if (rs.u8Rem(kind, 2) === 0) { + units = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u16 => { + const _59: rs.usize = rs.u8Rem(_2, 16) as rs.usize; if (!(_59 < 16)) { - rt.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); + rs.panic("index out of bounds: the len is " + 16 + " but the index is " + _59); } return [0, 65, 233, 55295, 55296, 55297, 56319, 56320, 56321, 57343, 57344, 65279, 65533, 65535, 55357, 56832][_59]; }), undefined, 2, true); } else { - units = rt.iterToVec(rt.iterMap(rt.byteSliceChunks(data, 2), (p: rt.ByteSlice): rt.u16 => { - rt.idx(p, 0); - return (p.data[p.start] << 8) | option_unwrapOr$0r2bmpr(rt.byteSliceGet(p, 1), 0); + units = rs.iterToVec(rs.iterMap(rs.byteSliceChunks(data, 2), (p: rs.ByteSlice): rs.u16 => { + rs.idx(p, 0); + return (p.data[p.start] << 8) | option_unwrapOr$1fr498u(rs.byteSliceGet(p, 1), 0); }), undefined, 2, true); } - putUtf16(out, rt.stringFromUtf16(units.items)); - const part3 = rt.stringFromUtf16Lossy(units.items); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(part3, f)]; - put(out, rt.fmtFormat([args2[0]])); - const part4 = rt.stringFromUtf16(units.items); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part4, f, rt.fmtStr, rt.fmtFromUtf16ErrorDebug)]; - put(out, rt.fmtFormat([args4[0]])); - const le: rt.ByteVec = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(units.items), (u: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(u).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const be: rt.ByteVec = rt.iterToByteVec(rt.iterFlatMap(rt.iterSlice(units.items), (u2: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(u2); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const _57: [rt.ByteSlice, rt.ByteSlice] = [rt.byteSliceRange(rt.byteVecSlice(le), 0), rt.byteSliceRange(rt.byteVecSlice(be), 0)]; - const iter: rt.Iter<[rt.ByteSlice, rt.ByteSlice]> = rt.iterSlice([_57, [option_unwrapOr$1rbuegs(rt.byteSliceGetRange(rt.byteVecSlice(le), 1), rt.byteSliceFrom(Uint8Array.of())), option_unwrapOr$1rbuegs(rt.byteSliceGetRange(rt.byteVecSlice(be), 1), rt.byteSliceFrom(Uint8Array.of()))] as [rt.ByteSlice, rt.ByteSlice], [data, data] as [rt.ByteSlice, rt.ByteSlice]]); + putUtf16(out, rs.stringFromUtf16(units.items)); + const part3 = rs.stringFromUtf16Lossy(units.items); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(part3, f)]; + put(out, rs.fmtFormat([args2[0]])); + const part4 = rs.stringFromUtf16(units.items); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part4, f, rs.fmtStr, rs.fmtFromUtf16ErrorDebug)]; + put(out, rs.fmtFormat([args4[0]])); + const le: rs.ByteVec = rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(units.items), (u: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(u).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const be: rs.ByteVec = rs.iterToByteVec(rs.iterFlatMap(rs.iterSlice(units.items), (u2: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(u2); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const _57: [rs.ByteSlice, rs.ByteSlice] = [rs.byteSliceRange(rs.byteVecSlice(le), 0), rs.byteSliceRange(rs.byteVecSlice(be), 0)]; + const iter: rs.Iter<[rs.ByteSlice, rs.ByteSlice]> = rs.iterSlice([_57, [option_unwrapOr$0yvilko(rs.byteSliceGetRange(rs.byteVecSlice(le), 1), rs.byteSliceFrom(Uint8Array.of())), option_unwrapOr$0yvilko(rs.byteSliceGetRange(rs.byteVecSlice(be), 1), rs.byteSliceFrom(Uint8Array.of()))] as [rs.ByteSlice, rs.ByteSlice], [data, data] as [rs.ByteSlice, rs.ByteSlice]]); while (true) { - const _79: [rt.ByteSlice, rt.ByteSlice] | rt.Done = iter.next(); - if (_79 === rt.DONE) { + const _79: [rs.ByteSlice, rs.ByteSlice] | rs.Done = iter.next(); + if (_79 === rs.DONE) { break; } - putUtf16(out, rt.stringFromUtf16le(_79[0])); - putUtf16(out, rt.stringFromUtf16be(_79[1])); - const _96: string = rt.stringFromUtf16leLossy(_79[0]); - const _98: string = rt.stringFromUtf16beLossy(_79[1]); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(_96, f), (f: rt.Formatter) => rt.fmtStr(_98, f)]; - put(out, rt.fmtFormat([args6[0], "|", args6[1]])); + putUtf16(out, rs.stringFromUtf16le(_79[0])); + putUtf16(out, rs.stringFromUtf16be(_79[1])); + const _96: string = rs.stringFromUtf16leLossy(_79[0]); + const _98: string = rs.stringFromUtf16beLossy(_79[1]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(_96, f), (f: rs.Formatter) => rs.fmtStr(_98, f)]; + put(out, rs.fmtFormat([args6[0], "|", args6[1]])); } - const lossy: Array<(a0: rt.ByteSlice) => string> = [(a03: rt.ByteSlice): string => { - return rt.stringFromUtf16leLossy(a03); - }, (a04: rt.ByteSlice): string => { - return rt.stringFromUtf16beLossy(a04); + const lossy: Array<(a0: rs.ByteSlice) => string> = [(a03: rs.ByteSlice): string => { + return rs.stringFromUtf16leLossy(a03); + }, (a04: rs.ByteSlice): string => { + return rs.stringFromUtf16beLossy(a04); }]; - const iter2: rt.Iter<[(a0: rt.ByteSlice) => rt.Result, (a0: rt.ByteSlice) => string]> = rt.iterZip(rt.iterSlice([(a0: rt.ByteSlice): rt.Result => { - return rt.stringFromUtf16le(a0); - }, (a02: rt.ByteSlice): rt.Result => { - return rt.stringFromUtf16be(a02); - }]), rt.iterSlice(lossy), "index"); + const iter2: rs.Iter<[(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string]> = rs.iterZip(rs.iterSlice([(a0: rs.ByteSlice): rs.Result => { + return rs.stringFromUtf16le(a0); + }, (a02: rs.ByteSlice): rs.Result => { + return rs.stringFromUtf16be(a02); + }]), rs.iterSlice(lossy), "index"); while (true) { - const _114: [(a0: rt.ByteSlice) => rt.Result, (a0: rt.ByteSlice) => string] | rt.Done = iter2.next(); - if (_114 === rt.DONE) { + const _114: [(a0: rs.ByteSlice) => rs.Result, (a0: rs.ByteSlice) => string] | rs.Done = iter2.next(); + if (_114 === rs.DONE) { break; } - const decode2: (a0: rt.ByteSlice) => rt.Result = _114[0]; - const lossy2: (a0: rt.ByteSlice) => string = _114[1]; + const decode2: (a0: rs.ByteSlice) => rs.Result = _114[0]; + const lossy2: (a0: rs.ByteSlice) => string = _114[1]; putUtf16(out, decode2(data)); put(out, lossy2(data)); } - const parts: rt.Vec = rt.iterToVec(rt.sliceSplit(units.items, (_22: rt.u16): boolean => { + const parts: rs.Vec = rs.iterToVec(rs.sliceSplit(units.items, (_22: rs.u16): boolean => { return _22 === 0; }), "next", 8); - const each: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(parts.items), (a05: rt.u16[]): string => { - return rt.stringFromUtf16Lossy(a05); + const each: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(parts.items), (a05: rs.u16[]): string => { + return rs.stringFromUtf16Lossy(a05); }), undefined, 12, true); - const ok: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterMap(rt.iterSlice(parts.items), (a06: rt.u16[]): rt.Result => { - return rt.stringFromUtf16(a06); - }), (r: rt.Result): boolean => { + const ok: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterMap(rs.iterSlice(parts.items), (a06: rs.u16[]): rs.Result => { + return rs.stringFromUtf16(a06); + }), (r: rs.Result): boolean => { return r.ok; }), undefined, 1, true); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(each.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(ok.items, f, rt.fmtBool)]; - put(out, rt.fmtFormat([args8[0], "|", args8[1]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(each.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(ok.items, f, rs.fmtBool)]; + put(out, rs.fmtFormat([args8[0], "|", args8[1]])); } //# sourceMappingURL=strs.ts.map diff --git a/ts/fixtures/lang/tuples/expected/core/option.ts b/ts/fixtures/lang/tuples/expected/core/option.ts index 9786cd3ba..82d7521ac 100644 --- a/ts/fixtures/lang/tuples/expected/core/option.ts +++ b/ts/fixtures/lang/tuples/expected/core/option.ts @@ -1,29 +1,29 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function map$1pb5zw8(self: rt.u8 | undefined, f: (a0: rt.u8) => [rt.u16, rt.u8]): [rt.u16, rt.u8] | undefined { +export function map$1ykzdkq(self: rs.u8 | undefined, f: (a0: rs.u8) => [rs.u16, rs.u8]): [rs.u16, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1fmzefe(self: rt.u8 | undefined, f: (a0: rt.u8) => [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined { +export function map$1pv2dfs(self: rs.u8 | undefined, f: (a0: rs.u8) => [rs.u8, rs.u8]): [rs.u8, rs.u8] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/tuples/expected/harness.ts b/ts/fixtures/lang/tuples/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/tuples/expected/harness.ts +++ b/ts/fixtures/lang/tuples/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/tuples/expected/lib.ts b/ts/fixtures/lang/tuples/expected/lib.ts index 6e404accd..c112f627b 100644 --- a/ts/fixtures/lang/tuples/expected/lib.ts +++ b/ts/fixtures/lang/tuples/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { tuples } from "./tuples.ts"; import type * as Logged from "./tuples.Logged.ts"; import type * as Spot from "./tuples.Spot.ts"; @@ -10,21 +10,21 @@ export function copy$tuples_Spot(v: Spot.Spot): Spot.Spot { return { x: v.x, y: v.y }; } -export function drop$Result_tuple2_tuples_Logged_u8_u8(_1: rt.Result<[Logged.Logged, rt.u8], rt.u8>): void { +export function drop$Result_tuple2_tuples_Logged_u8_u8(_1: rs.Result<[Logged.Logged, rs.u8], rs.u8>): void { if (_1.ok) { drop$tuple2_tuples_Logged_u8(_1.value); } } -export function drop$tuple2_Vec_tuples_Logged_tuples_Tally(_1: [rt.Vec, Tally.Tally]): void { - rt.dropVec(_1[0]); +export function drop$tuple2_Vec_tuples_Logged_tuples_Tally(_1: [rs.Vec, Tally.Tally]): void { + rs.dropVec(_1[0]); } -export function drop$tuple2_tuples_Logged_u8(_1: [Logged.Logged, rt.u8]): void { +export function drop$tuple2_tuples_Logged_u8(_1: [Logged.Logged, rs.u8]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_u8_tuples_Logged(_1: [rt.u8, Logged.Logged]): void { +export function drop$tuple2_u8_tuples_Logged(_1: [rs.u8, Logged.Logged]): void { _1[1][Symbol.dispose](); } @@ -32,8 +32,8 @@ export function drop$tuple2_u8_tuples_Logged(_1: [rt.u8, Logged.Logged]): void { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["tuples::tuples", tuples as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["tuples::tuples", tuples as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/tuples/expected/std/thread/local.ts b/ts/fixtures/lang/tuples/expected/std/thread/local.ts index a41ea1713..02d26fec0 100644 --- a/ts/fixtures/lang/tuples/expected/std/thread/local.ts +++ b/ts/fixtures/lang/tuples/expected/std/thread/local.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function set$0xuu1fw(self: rt.LocalKey>, value: rt.u8): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell | undefined, cell: rt.Cell): undefined => { +export function set$0e2h2hd(self: rs.LocalKey>, value: rs.u8): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell | undefined, cell: rs.Cell): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function get$18ignl5(self: rt.LocalKey>): rt.u8 { - return ((a0: rt.Cell): rt.u8 => { +export function get$09fnt4b(self: rs.LocalKey>): rs.u8 { + return ((a0: rs.Cell): rs.u8 => { return a0.v; })(self.get()); } diff --git a/ts/fixtures/lang/tuples/expected/tuples.Last.ts b/ts/fixtures/lang/tuples/expected/tuples.Last.ts index 70e14c99a..b0e9a2fe0 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.Last.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.Last.ts @@ -1,55 +1,55 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Last { return { tag: "Empty" } as Last; } /** The crate's own enum, which JS keeps in a place: the last item and how many there were. */ -export type Last = { tag: "Empty" } | { tag: "Seen"; _0: rt.char; _1: rt.u8 }; +export type Last = { tag: "Empty" } | { tag: "Seen"; _0: rs.char; _1: rs.u8 }; -export function extend$iter_Extend_char_Option_char(self: rt.Place, iter: rt.char | undefined): void { +export function extend$iter_Extend_char_Option_char(self: rs.Place, iter: rs.char | undefined): void { let _9!: Last; - const iter2: rt.Iter = rt.iterOption(iter); + const iter2: rs.Iter = rs.iterOption(iter); while (true) { - const _5: rt.char | rt.Done = iter2.next(); - if (_5 === rt.DONE) { + const _5: rs.char | rs.Done = iter2.next(); + if (_5 === rs.DONE) { break; } - const c: rt.char = _5; + const c: rs.char = _5; if (self.v.tag === "Empty") { _9 = { tag: "Seen", _0: c, _1: 1 } as Last; } else { - _9 = { tag: "Seen", _0: c, _1: rt.u8Add(self.v._1, 1) } as Last; + _9 = { tag: "Seen", _0: c, _1: rs.u8Add(self.v._1, 1) } as Last; } self.v = _9; } } -export function extend$iter_Extend_char_iter_Map_iter_Map_slice_Iter_u8_tuples_own_closure13_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_char_tuples_Last_iter_Map_slice_Iter_u8_tuples_own_closure13(self: rt.Place, iter: rt.Iter): void { +export function extend$iter_Extend_char_iter_Map_iter_Map_slice_Iter_u8_tuples_own_closure13_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_char_tuples_Last_iter_Map_slice_Iter_u8_tuples_own_closure13(self: rs.Place, iter: rs.Iter): void { let _9!: Last; - const iter2: rt.Iter = iter; + const iter2: rs.Iter = iter; while (true) { - const _5: rt.char | rt.Done = iter2.next(); - if (_5 === rt.DONE) { + const _5: rs.char | rs.Done = iter2.next(); + if (_5 === rs.DONE) { break; } - const c: rt.char = _5; + const c: rs.char = _5; if (self.v.tag === "Empty") { _9 = { tag: "Seen", _0: c, _1: 1 } as Last; } else { - _9 = { tag: "Seen", _0: c, _1: rt.u8Add(self.v._1, 1) } as Last; + _9 = { tag: "Seen", _0: c, _1: rs.u8Add(self.v._1, 1) } as Last; } self.v = _9; } } -export function put(self: Last, out: rt.ByteVec): void { +export function put(self: Last, out: rs.ByteVec): void { if (self.tag === "Empty") { - rt.byteVecPush(out, 248); + rs.byteVecPush(out, 248); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(self._0 & 0xff, self._1)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(self._0 & 0xff, self._1)), undefined, true); } } diff --git a/ts/fixtures/lang/tuples/expected/tuples.Logged.ts b/ts/fixtures/lang/tuples/expected/tuples.Logged.ts index 6c55202c4..9d45c5162 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.Logged.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.Logged.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Logs its id as it drops. Equal, hashed, and ordered by `key` alone, so a collection * keeps one and drops another equal to it. */ export class Logged { - id: rt.u8; - key: rt.u8; - log: rt.Arc>; + id: rs.u8; + key: rs.u8; + log: rs.Arc>; - constructor(id: rt.u8, key: rt.u8, log: rt.Arc>) { + constructor(id: rs.u8, key: rs.u8, log: rs.Arc>) { this.id = id; this.key = key; this.log = log; @@ -27,18 +27,18 @@ export function eq$cmp_PartialEq(self: Logged, other: Logged): boolean { return self.key === other.key; } -export function hash$Hash_hash_DefaultHasher(self: Logged, state: rt.Hasher): void { - rt.hash8(self.key, state); +export function hash$Hash_hash_DefaultHasher(self: Logged, state: rs.Hasher): void { + rs.hash8(self.key, state); } -export function cmp$cmp_Ord(self: Logged, other: Logged): rt.Ordering { - return rt.cmp(self.key, other.key); +export function cmp$cmp_Ord(self: Logged, other: Logged): rs.Ordering { + return rs.cmp(self.key, other.key); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log.value); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log.value); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=tuples.Logged.ts.map diff --git a/ts/fixtures/lang/tuples/expected/tuples.Spot.ts b/ts/fixtures/lang/tuples/expected/tuples.Spot.ts index 72585e970..90f2c5354 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.Spot.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.Spot.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Copied out of the references `Extend<&T>` is given. */ export interface Spot { - x: rt.u8; - y: rt.u16; + x: rs.u8; + y: rs.u16; } //# sourceMappingURL=tuples.Spot.ts.map diff --git a/ts/fixtures/lang/tuples/expected/tuples.Tally.ts b/ts/fixtures/lang/tuples/expected/tuples.Tally.ts index 24571b54e..60718c48b 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.Tally.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.Tally.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; -import { set$0xuu1fw, get$18ignl5 } from "./std/thread/local.ts"; +import * as rs from "./rs.ts"; +import { mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { set$0e2h2hd, get$09fnt4b } from "./std/thread/local.ts"; import { NEXT, call } from "./tuples.ts"; /** @@ -10,175 +10,175 @@ import { NEXT, call } from "./tuples.ts"; * hint of the iterator it is given and how many items that held. An item of 0xee panics. */ export interface Tally { - id: rt.u8; - sum: rt.u8; + id: rs.u8; + sum: rs.u8; } export function default$Default(): Tally { - const id: rt.u8 = get$18ignl5(NEXT); - set$0xuu1fw(NEXT, rt.u8WrappingAdd(id, 1)); - call(rt.byteSliceFrom(Uint8Array.of(208, id))); + const id: rs.u8 = get$09fnt4b(NEXT); + set$0e2h2hd(NEXT, rs.u8WrappingAdd(id, 1)); + call(rs.byteSliceFrom(Uint8Array.of(208, id))); return { id, sum: 0 }; } -export function extend$iter_Extend_u8_Option_u8(self: Tally, iter: rt.u8 | undefined): void { - const iter2: rt.Iter = rt.iterOption(iter); - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_Option_u8(self: Tally, iter: rs.u8 | undefined): void { + const iter2: rs.Iter = rs.iterOption(iter); + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } -export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4_iter_Extend_tuple1_T_tuple1_ExtendT_extend_closure0_u8_tuples_Tally_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4(self: Tally, iter: rt.Iter): void { - const iter2: rt.Iter = iter; - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4_iter_Extend_tuple1_T_tuple1_ExtendT_extend_closure0_u8_tuples_Tally_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4(self: Tally, iter: rs.Iter): void { + const iter2: rs.Iter = iter; + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } -export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2(self: Tally, iter: rt.Iter): void { - const iter2: rt.Iter = iter; - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2(self: Tally, iter: rs.Iter): void { + const iter2: rs.Iter = iter; + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } -export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2(self: Tally, iter: rt.Iter): void { - const iter2: rt.Iter = iter; - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_iter_Map_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2(self: Tally, iter: rs.Iter): void { + const iter2: rs.Iter = iter; + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } -export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8(self: Tally, iter: rt.Iter): void { - const iter2: rt.Iter = iter; - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8(self: Tally, iter: rs.Iter): void { + const iter2: rs.Iter = iter; + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } -export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never(self: Tally, iter: rt.Iter): void { - const iter2: rt.Iter = iter; - const _6: [rt.usize, rt.usize | undefined] = iter2.sizeHint(); - const lower: rt.usize = _6[0]; - const upper: rt.usize | undefined = _6[1]; - let n: rt.u8 = 0; - const iter3: rt.Iter = iter2; +export function extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never(self: Tally, iter: rs.Iter): void { + const iter2: rs.Iter = iter; + const _6: [rs.usize, rs.usize | undefined] = iter2.sizeHint(); + const lower: rs.usize = _6[0]; + const upper: rs.usize | undefined = _6[1]; + let n: rs.u8 = 0; + const iter3: rs.Iter = iter2; while (true) { - const _12: rt.u8 | rt.Done = iter3.next(); - if (_12 === rt.DONE) { + const _12: rs.u8 | rs.Done = iter3.next(); + if (_12 === rs.DONE) { break; } - const b: rt.u8 = _12; + const b: rs.u8 = _12; if (!(b !== 238)) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg, f), (f: rt.Formatter) => rt.u8Display(n, f)]; - rt.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg, f), (f: rs.Formatter) => rs.u8Display(n, f)]; + rs.panicFmt(["tally ", args2[0], " at its item ", args2[1]]); } else { - self.sum = rt.u8WrappingAdd(self.sum, b); - n = rt.u8Add(n, 1); + self.sum = rs.u8WrappingAdd(self.sum, b); + n = rs.u8Add(n, 1); } } - call(rt.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$02k4ito(upper, 255, (u: rt.usize): rt.u8 => { + call(rs.byteSliceFrom(Uint8Array.of(224, self.id, lower & 0xff, option_mapOr$188iunt(upper, 255, (u: rs.usize): rs.u8 => { return u & 0xff; }), n))); } diff --git a/ts/fixtures/lang/tuples/expected/tuples.ts b/ts/fixtures/lang/tuples/expected/tuples.ts index 3a7865d26..010126aa4 100644 --- a/ts/fixtures/lang/tuples/expected/tuples.ts +++ b/ts/fixtures/lang/tuples/expected/tuples.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$tuples_Spot, drop$Result_tuple2_tuples_Logged_u8_u8, drop$tuple2_Vec_tuples_Logged_tuples_Tally, drop$tuple2_tuples_Logged_u8, drop$tuple2_u8_tuples_Logged } from "./lib.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, map$1pb5zw8 as option_map$1pb5zw8, map$1fmzefe as option_map$1fmzefe } from "./core/option.ts"; -import { set$0xuu1fw } from "./std/thread/local.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, map$1ykzdkq as option_map$1ykzdkq, map$1pv2dfs as option_map$1pv2dfs } from "./core/option.ts"; +import { set$0e2h2hd } from "./std/thread/local.ts"; import * as Last from "./tuples.Last.ts"; import * as Logged from "./tuples.Logged.ts"; import type * as Spot from "./tuples.Spot.ts"; import * as Tally from "./tuples.Tally.ts"; /** Puts what was logged since the last flush, after a marker. */ -export function flush(log: rt.RefCell, out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - const _8: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_8.value, undefined), "fold", true); - rt.refMutRelease(_8); +export function flush(log: rs.RefCell, out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + const _8: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_8.value, undefined), "fold", true); + rs.refMutRelease(_8); } /** Puts a hash set's keys, which it iterates in no order std promises, in order. */ -export function sorted(set: rt.HashSet, out: rt.ByteVec): void { - rt.byteVecPush(out, 252); - const _6: rt.Iter = rt.hashKeys(set); - rt.iterExtendBytes(out, rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _6, true, undefined, "next", 1)), undefined, true); +export function sorted(set: rs.HashSet, out: rs.ByteVec): void { + rs.byteVecPush(out, 252); + const _6: rs.Iter = rs.hashKeys(set); + rs.iterExtendBytes(out, rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _6, true, undefined, "next", 1)), undefined, true); } /** Puts a hash map's entries in key order. */ -export function entries(map: rt.HashMap, out: rt.ByteVec): void { - rt.byteVecPush(out, 251); - const _5: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.hashIter(map), (_2: [rt.u8, rt.u8]): [rt.u8, rt.u8] => { - return [_2[0], _2[1]] as [rt.u8, rt.u8]; +export function entries(map: rs.HashMap, out: rs.ByteVec): void { + rs.byteVecPush(out, 251); + const _5: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.hashIter(map), (_2: [rs.u8, rs.u8]): [rs.u8, rs.u8] => { + return [_2[0], _2[1]] as [rs.u8, rs.u8]; }); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, _5, true, undefined, undefined, "next", 2)), (_22: [rt.u8, rt.u8]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, _5, true, undefined, undefined, "next", 2)), (_22: [rs.u8, rs.u8]): Uint8Array => { return Uint8Array.of(_22[0], _22[1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } /** Collected, unzipped, or extended as `kind` picks, from at most 24 bytes of `data`. */ -export function tuples(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.min(data.length, 24)); - const _8: rt.u8 = rt.u8Rem(kind, 12); +export function tuples(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.min(data.length, 24)); + const _8: rs.u8 = rs.u8Rem(kind, 12); if (_8 === 0) { ones(data2, out); } else if (_8 === 1) { @@ -70,296 +70,296 @@ export function tuples(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * 1-tuples, each by its collection's own `extend`: a heap's rebuilds once, where a longer * tuple's pushes each item. */ -export function ones(data: rt.ByteSlice, out: rt.ByteVec): void { - const _5: rt.Iter<[rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u16] => { - return [((_2 as rt.u16) << 4) & 0xffff] as [rt.u16]; - }); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(rt.tupleExtendOne([new rt.Vec()] as [rt.Vec], _5, (c, items) => rt.iterExtend(c, items, undefined, 2, true))[0].items), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(rt.tupleExtendOne([""] as [string], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [rt.char] => { - return [_24 as rt.char] as [rt.char]; - }), (c2, items2) => rt.stringExtendChars(c2, items2))[0]), undefined, true); - const _22: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8] => { - return [_26] as [rt.u8]; - }); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(rt.tupleExtendOne([rt.heapNew() as rt.BinaryHeap] as [rt.BinaryHeap], _22, (c3, items3) => rt.heapExtend(c3, items3, rt.le, rt.ge, rt.lt, undefined, 1, true))[0])), undefined, true); - const _28: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): boolean => { +export function ones(data: rs.ByteSlice, out: rs.ByteVec): void { + const _5: rs.Iter<[rs.u16]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u16] => { + return [((_2 as rs.u16) << 4) & 0xffff] as [rs.u16]; + }); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(rs.tupleExtendOne([new rs.Vec()] as [rs.Vec], _5, (c, items) => rs.iterExtend(c, items, undefined, 2, true))[0].items), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(rs.tupleExtendOne([""] as [string], rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [rs.char] => { + return [_24 as rs.char] as [rs.char]; + }), (c2, items2) => rs.stringExtendChars(c2, items2))[0]), undefined, true); + const _22: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): [rs.u8] => { + return [_26] as [rs.u8]; + }); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(rs.tupleExtendOne([rs.heapNew() as rs.BinaryHeap] as [rs.BinaryHeap], _22, (c3, items3) => rs.heapExtend(c3, items3, rs.le, rs.ge, rs.lt, undefined, 1, true))[0])), undefined, true); + const _28: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): boolean => { return (_210 & 1) === 0; - }), (_211: rt.u8): [rt.u8] => { - return [_211] as [rt.u8]; + }), (_211: rs.u8): [rs.u8] => { + return [_211] as [rs.u8]; }); - rt.iterExtendBytes(out, rt.dequeIntoIter(rt.tupleExtendOne([rt.dequeNew(1, true) as rt.VecDeque] as [rt.VecDeque], _28, (c4, items4) => rt.dequeExtend(c4, items4, "next"))[0]), undefined, true); - const _34: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): [rt.u8] => { - return [rt.u8Rem(_212, 16)] as [rt.u8]; + rs.iterExtendBytes(out, rs.dequeIntoIter(rs.tupleExtendOne([rs.dequeNew(1, true) as rs.VecDeque] as [rs.VecDeque], _28, (c4, items4) => rs.dequeExtend(c4, items4, "next"))[0]), undefined, true); + const _34: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): [rs.u8] => { + return [rs.u8Rem(_212, 16)] as [rs.u8]; }); - sorted(rt.tupleExtendOne([rt.hashNew() as rt.HashSet] as [rt.HashSet], _34, (c5, items5) => rt.hashExtendKeys(c5, items5, undefined, undefined, 469762048))[0], out); - const _40: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): [rt.u8] => { - return [rt.u8Rem(_213, 16)] as [rt.u8]; + sorted(rs.tupleExtendOne([rs.hashNew() as rs.HashSet] as [rs.HashSet], _34, (c5, items5) => rs.hashExtendKeys(c5, items5, undefined, undefined, 469762048))[0], out); + const _40: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): [rs.u8] => { + return [rs.u8Rem(_213, 16)] as [rs.u8]; }); - rt.iterExtendBytes(out, rt.btreeKeys(rt.tupleExtendOne([rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.BTreeSet], _40, (c6, items6) => rt.btreeExtendKeys(c6, items6))[0]), undefined, true); - const t: [rt.ByteVec] = [rt.byteVecFrom(Uint8Array.of(170))]; - const _48: rt.Iter<[rt.u8]> = rt.iterMap(rt.byteSliceChunks(data, 2), (c7: rt.ByteSlice): [rt.u8] => { - rt.idx(c7, 0); - return [c7.data[c7.start]] as [rt.u8]; + rs.iterExtendBytes(out, rs.btreeKeys(rs.tupleExtendOne([rs.btreeNew(rs.cmp) as rs.BTreeSet] as [rs.BTreeSet], _40, (c6, items6) => rs.btreeExtendKeys(c6, items6))[0]), undefined, true); + const t: [rs.ByteVec] = [rs.byteVecFrom(Uint8Array.of(170))]; + const _48: rs.Iter<[rs.u8]> = rs.iterMap(rs.byteSliceChunks(data, 2), (c7: rs.ByteSlice): [rs.u8] => { + rs.idx(c7, 0); + return [c7.data[c7.start]] as [rs.u8]; }); - rt.tupleExtendOne(t, _48, (c8, items7) => rt.iterExtendBytes(c8, items7, undefined, true)); - rt.iterExtendBytes(out, rt.byteVecIntoIter(t[0]), undefined, true); + rs.tupleExtendOne(t, _48, (c8, items7) => rs.iterExtendBytes(c8, items7, undefined, true)); + rs.iterExtendBytes(out, rs.byteVecIntoIter(t[0]), undefined, true); const t2: [string] = ["ab"]; - const _56: rt.Iter<[string]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): [string] => { - const _84: rt.usize = rt.u8Rem(_214, 3) as rt.usize; + const _56: rs.Iter<[string]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): [string] => { + const _84: rs.usize = rs.u8Rem(_214, 3) as rs.usize; if (!(_84 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _84); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _84); } return [["x", "", "yz"][_84]] as [string]; }); - rt.tupleExtendOne(t2, _56, (c9, items8) => rt.stringExtend(c9, items8)); - rt.iterExtendBytes(out, rt.strBytes(t2[0]), undefined, true); - const _65: rt.Iter<[[rt.u8, rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): [[rt.u8, rt.u8]] => { - const b9: rt.u8 = _215; - return [[b9, b9] as [rt.u8, rt.u8]] as [[rt.u8, rt.u8]]; - }); - const _64: [[rt.ByteVec, rt.BinaryHeap]] = rt.tupleExtendOne([[new rt.ByteVec(), rt.heapNew() as rt.BinaryHeap]] as [[rt.ByteVec, rt.BinaryHeap]], _65, (c10, items9) => rt.tupleExtend(c10, items9, [rt.byteVecPart(), rt.heapPart(rt.le, 1)])); - const v2: rt.ByteVec = _64[0][0]; - const heap2: rt.BinaryHeap = _64[0][1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap2)), undefined, true); - rt.tupleExtendOne([undefined] as [undefined], rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): [undefined] => { + rs.tupleExtendOne(t2, _56, (c9, items8) => rs.stringExtend(c9, items8)); + rs.iterExtendBytes(out, rs.strBytes(t2[0]), undefined, true); + const _65: rs.Iter<[[rs.u8, rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): [[rs.u8, rs.u8]] => { + const b9: rs.u8 = _215; + return [[b9, b9] as [rs.u8, rs.u8]] as [[rs.u8, rs.u8]]; + }); + const _64: [[rs.ByteVec, rs.BinaryHeap]] = rs.tupleExtendOne([[new rs.ByteVec(), rs.heapNew() as rs.BinaryHeap]] as [[rs.ByteVec, rs.BinaryHeap]], _65, (c10, items9) => rs.tupleExtend(c10, items9, [rs.byteVecPart(), rs.heapPart(rs.le, 1)])); + const v2: rs.ByteVec = _64[0][0]; + const heap2: rs.BinaryHeap = _64[0][1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap2)), undefined, true); + rs.tupleExtendOne([undefined] as [undefined], rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): [undefined] => { return [undefined] as [undefined]; - }), (_c11, items10) => rt.iterForEach(items10, () => undefined)); - let seen: rt.u8 = 0; - rt.iterForEach(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_217: rt.u8): undefined => { - seen = rt.u8Add(seen, 1); + }), (_c11, items10) => rs.iterForEach(items10, () => undefined)); + let seen: rs.u8 = 0; + rs.iterForEach(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_217: rs.u8): undefined => { + seen = rs.u8Add(seen, 1); }), () => undefined); - rt.byteVecPush(out, seen); + rs.byteVecPush(out, seen); } /** Pairs, by `collect` and `unzip`, of `()` too. */ -export function pairs(data: rt.ByteSlice, out: rt.ByteVec): void { - const _6: rt.Iter<[rt.u8, rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char] => { - const b: rt.u8 = _2; - return [b ^ 90, b as rt.char] as [rt.u8, rt.char]; +export function pairs(data: rs.ByteSlice, out: rs.ByteVec): void { + const _6: rs.Iter<[rs.u8, rs.char]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.char] => { + const b: rs.u8 = _2; + return [b ^ 90, b as rs.char] as [rs.u8, rs.char]; }); - const _5: [rt.ByteVec, string] = rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], _6, [rt.byteVecPart(), rt.STRING_CHARS_PART]); - const v: rt.ByteVec = _5[0]; + const _5: [rs.ByteVec, string] = rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], _6, [rs.byteVecPart(), rs.STRING_CHARS_PART]); + const v: rs.ByteVec = _5[0]; const s: string = _5[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); - const _16: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): [rt.u8, rt.u8] => { - const b2: rt.u8 = _25; - return [b2, rt.u8Rem(b2, 8)] as [rt.u8, rt.u8]; - }); - const _15: [rt.ByteVec, rt.BTreeSet] = rt.tupleExtend([new rt.ByteVec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.ByteVec, rt.BTreeSet], _16, [rt.byteVecPart(), rt.btreeKeysPart()]); - const v2: rt.ByteVec = _15[0]; - const tree: rt.BTreeSet = _15[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); - rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); - const _23: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_27: rt.u8): [rt.u8, rt.u16] => { - const b3: rt.u8 = _27; - return [b3, rt.u16Mul(b3 as rt.u16, 3)] as [rt.u8, rt.u16]; - }); - const _22: [rt.BinaryHeap, rt.VecDeque] = rt.tupleExtend([rt.heapNew() as rt.BinaryHeap, rt.dequeNew(2) as rt.VecDeque] as [rt.BinaryHeap, rt.VecDeque], _23, [rt.heapPart(rt.le, 1), rt.dequePart()]); - const heap: rt.BinaryHeap = _22[0]; - const q: rt.VecDeque = _22[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap)), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const _33: rt.Iter<[undefined, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): [undefined, rt.u8] => { - return [undefined, _210] as [undefined, rt.u8]; - }); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.tupleExtend([undefined, new rt.ByteVec()] as [undefined, rt.ByteVec], _33, [rt.UNIT_PART, rt.byteVecPart()])[1]), undefined, true); - const _39: rt.Iter<[rt.u16, rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): boolean => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + const _16: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): [rs.u8, rs.u8] => { + const b2: rs.u8 = _25; + return [b2, rs.u8Rem(b2, 8)] as [rs.u8, rs.u8]; + }); + const _15: [rs.ByteVec, rs.BTreeSet] = rs.tupleExtend([new rs.ByteVec(), rs.btreeNew(rs.cmp) as rs.BTreeSet] as [rs.ByteVec, rs.BTreeSet], _16, [rs.byteVecPart(), rs.btreeKeysPart()]); + const v2: rs.ByteVec = _15[0]; + const tree: rs.BTreeSet = _15[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(tree), undefined, true); + const _23: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_27: rs.u8): [rs.u8, rs.u16] => { + const b3: rs.u8 = _27; + return [b3, rs.u16Mul(b3 as rs.u16, 3)] as [rs.u8, rs.u16]; + }); + const _22: [rs.BinaryHeap, rs.VecDeque] = rs.tupleExtend([rs.heapNew() as rs.BinaryHeap, rs.dequeNew(2) as rs.VecDeque] as [rs.BinaryHeap, rs.VecDeque], _23, [rs.heapPart(rs.le, 1), rs.dequePart()]); + const heap: rs.BinaryHeap = _22[0]; + const q: rs.VecDeque = _22[1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap)), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const _33: rs.Iter<[undefined, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): [undefined, rs.u8] => { + return [undefined, _210] as [undefined, rs.u8]; + }); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.tupleExtend([undefined, new rs.ByteVec()] as [undefined, rs.ByteVec], _33, [rs.UNIT_PART, rs.byteVecPart()])[1]), undefined, true); + const _39: rs.Iter<[rs.u16, rs.u8]> = rs.iterMap(rs.iterFilter(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): boolean => { return _211 > 64; - }), (_212: rt.u8): [rt.u16, rt.u8] => { - const b6: rt.u8 = _212; - return [b6 as rt.u16, b6] as [rt.u16, rt.u8]; - }); - const _38: [rt.Vec, rt.VecDeque] = rt.tupleExtend([new rt.Vec(), rt.dequeNew(1, true) as rt.VecDeque] as [rt.Vec, rt.VecDeque], _39, [rt.vecPart(2), rt.dequePart()]); - const v4: rt.Vec = _38[0]; - const q2: rt.VecDeque = _38[1]; - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v4.items), (n2: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.dequeIntoIter(q2), undefined, true); + }), (_212: rs.u8): [rs.u16, rs.u8] => { + const b6: rs.u8 = _212; + return [b6 as rs.u16, b6] as [rs.u16, rs.u8]; + }); + const _38: [rs.Vec, rs.VecDeque] = rs.tupleExtend([new rs.Vec(), rs.dequeNew(1, true) as rs.VecDeque] as [rs.Vec, rs.VecDeque], _39, [rs.vecPart(2), rs.dequePart()]); + const v4: rs.Vec = _38[0]; + const q2: rs.VecDeque = _38[1]; + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v4.items), (n2: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n2).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(q2), undefined, true); } /** Triples, of mixed collections, and tuples of collections within one. */ -export function triples(data: rt.ByteSlice, out: rt.ByteVec): void { - const _7: rt.Iter<[rt.u8, rt.u16, rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u16, rt.char] => { - const b: rt.u8 = _2; - return [b, ((b as rt.u16) << 8) & 0xffff, rt.u8Add(97, rt.u8Rem(b, 26)) as rt.char] as [rt.u8, rt.u16, rt.char]; - }); - const _6: [rt.ByteVec, rt.VecDeque, string] = rt.tupleExtend([new rt.ByteVec(), rt.dequeNew(2) as rt.VecDeque, ""] as [rt.ByteVec, rt.VecDeque, string], _7, [rt.byteVecPart(), rt.dequePart(), rt.STRING_CHARS_PART]); - const v: rt.ByteVec = _6[0]; - const q: rt.VecDeque = _6[1]; +export function triples(data: rs.ByteSlice, out: rs.ByteVec): void { + const _7: rs.Iter<[rs.u8, rs.u16, rs.char]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.u16, rs.char] => { + const b: rs.u8 = _2; + return [b, ((b as rs.u16) << 8) & 0xffff, rs.u8Add(97, rs.u8Rem(b, 26)) as rs.char] as [rs.u8, rs.u16, rs.char]; + }); + const _6: [rs.ByteVec, rs.VecDeque, string] = rs.tupleExtend([new rs.ByteVec(), rs.dequeNew(2) as rs.VecDeque, ""] as [rs.ByteVec, rs.VecDeque, string], _7, [rs.byteVecPart(), rs.dequePart(), rs.STRING_CHARS_PART]); + const v: rs.ByteVec = _6[0]; + const q: rs.VecDeque = _6[1]; const s: string = _6[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); - const _22: rt.Iter<[[rt.u8, rt.u8], [rt.u8, rt.u16], rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): [[rt.u8, rt.u8], [rt.u8, rt.u16], rt.u8] => { - const b2: rt.u8 = _24; - return [[rt.u8Rem(b2, 8), b2] as [rt.u8, rt.u8], [rt.u8Rem(b2, 5), b2 as rt.u16] as [rt.u8, rt.u16], b2] as [[rt.u8, rt.u8], [rt.u8, rt.u16], rt.u8]; - }); - const _21: [rt.HashMap, rt.BTreeMap, rt.BinaryHeap] = rt.tupleExtend([rt.hashNew() as rt.HashMap, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.heapNew() as rt.BinaryHeap] as [rt.HashMap, rt.BTreeMap, rt.BinaryHeap], _22, [rt.hashPart(undefined, undefined, 469762048), rt.btreePart(), rt.heapPart(rt.le, 1)]); - const map: rt.HashMap = _21[0]; - const tree: rt.BTreeMap = _21[1]; - const heap: rt.BinaryHeap = _21[2]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + const _22: rs.Iter<[[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8] => { + const b2: rs.u8 = _24; + return [[rs.u8Rem(b2, 8), b2] as [rs.u8, rs.u8], [rs.u8Rem(b2, 5), b2 as rs.u16] as [rs.u8, rs.u16], b2] as [[rs.u8, rs.u8], [rs.u8, rs.u16], rs.u8]; + }); + const _21: [rs.HashMap, rs.BTreeMap, rs.BinaryHeap] = rs.tupleExtend([rs.hashNew() as rs.HashMap, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.heapNew() as rs.BinaryHeap] as [rs.HashMap, rs.BTreeMap, rs.BinaryHeap], _22, [rs.hashPart(undefined, undefined, 469762048), rs.btreePart(), rs.heapPart(rs.le, 1)]); + const map: rs.HashMap = _21[0]; + const tree: rs.BTreeMap = _21[1]; + const heap: rs.BinaryHeap = _21[2]; entries(map, out); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_25: [rt.u8, rt.u16]): Uint8Array => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(tree), (_25: [rs.u8, rs.u16]): Uint8Array => { return Uint8Array.of(_25[0], _25[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap)), undefined, true); - const _35: rt.Iter<[rt.u8, [rt.char, rt.u16]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_26: rt.u8): [rt.u8, [rt.char, rt.u16]] => { - const b3: rt.u8 = _26; - return [b3, [b3 as rt.char, rt.u16Add(b3 as rt.u16, 1)] as [rt.char, rt.u16]] as [rt.u8, [rt.char, rt.u16]]; - }); - const _34: [rt.ByteVec, [string, rt.Vec]] = rt.tupleExtend([new rt.ByteVec(), ["", new rt.Vec()]] as [rt.ByteVec, [string, rt.Vec]], _35, [rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART, rt.vecPart(2)])]); - const v2: rt.ByteVec = _34[0]; + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap)), undefined, true); + const _35: rs.Iter<[rs.u8, [rs.char, rs.u16]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_26: rs.u8): [rs.u8, [rs.char, rs.u16]] => { + const b3: rs.u8 = _26; + return [b3, [b3 as rs.char, rs.u16Add(b3 as rs.u16, 1)] as [rs.char, rs.u16]] as [rs.u8, [rs.char, rs.u16]]; + }); + const _34: [rs.ByteVec, [string, rs.Vec]] = rs.tupleExtend([new rs.ByteVec(), ["", new rs.Vec()]] as [rs.ByteVec, [string, rs.Vec]], _35, [rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART, rs.vecPart(2)])]); + const v2: rs.ByteVec = _34[0]; const s2: string = _34[1][0]; - const w: rt.Vec = _34[1][1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w.items), (n2: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - const _50: rt.Iter<[rt.u8, [rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_29: rt.u8): [rt.u8, [rt.u8]] => { - const b4: rt.u8 = _29; - return [b4, [rt.u8Div(b4, 32)] as [rt.u8]] as [rt.u8, [rt.u8]]; - }); - const _49: [rt.ByteVec, [rt.BTreeSet]] = rt.tupleExtend([new rt.ByteVec(), [rt.btreeNew(rt.cmp) as rt.BTreeSet]] as [rt.ByteVec, [rt.BTreeSet]], _50, [rt.byteVecPart(), rt.tuplePart([rt.btreeKeysPart()])]); - const v3: rt.ByteVec = _49[0]; - const tree2: rt.BTreeSet = _49[1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); - rt.iterExtendBytes(out, rt.btreeKeys(tree2), undefined, true); + const w: rs.Vec = _34[1][1]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n2: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n2).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + const _50: rs.Iter<[rs.u8, [rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_29: rs.u8): [rs.u8, [rs.u8]] => { + const b4: rs.u8 = _29; + return [b4, [rs.u8Div(b4, 32)] as [rs.u8]] as [rs.u8, [rs.u8]]; + }); + const _49: [rs.ByteVec, [rs.BTreeSet]] = rs.tupleExtend([new rs.ByteVec(), [rs.btreeNew(rs.cmp) as rs.BTreeSet]] as [rs.ByteVec, [rs.BTreeSet]], _50, [rs.byteVecPart(), rs.tuplePart([rs.btreeKeysPart()])]); + const v3: rs.ByteVec = _49[0]; + const tree2: rs.BTreeSet = _49[1][0]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v3), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(tree2), undefined, true); } /** The longest tuple std's impls take, of every collection the runtime extends. */ -export function twelves(data: rt.ByteSlice, out: rt.ByteVec): void { - const _16: rt.Iter<[rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]] => { - const b: rt.u8 = _2; - const _8: rt.usize = rt.u8Rem(b, 3) as rt.usize; +export function twelves(data: rs.ByteSlice, out: rs.ByteVec): void { + const _16: rs.Iter<[rs.u8, rs.u16, rs.char, string, rs.u8, rs.u8, [rs.u8, rs.u8], rs.u8, [rs.u8, rs.u16], rs.u8, undefined, [rs.u8, [rs.char]]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.u16, rs.char, string, rs.u8, rs.u8, [rs.u8, rs.u8], rs.u8, [rs.u8, rs.u16], rs.u8, undefined, [rs.u8, [rs.char]]] => { + const b: rs.u8 = _2; + const _8: rs.usize = rs.u8Rem(b, 3) as rs.usize; if (!(_8 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _8); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _8); } const _5: string[] = ["", "q", "rs"]; - const _12: rt.u16 = rt.u16Mul(b as rt.u16, 257); - const _152: rt.char = b as rt.char; - const _162: rt.u8 = ~b & 0xff; - const _172: [rt.u8, rt.u8] = [rt.u8Rem(b, 4), b]; - const _202: rt.u8 = rt.u8Rem(b, 6); - const _222: [rt.u8, rt.u16] = [rt.u8Rem(b, 3), b as rt.u16]; - const _262: rt.u8 = rt.u8Div(b, 16); - const _28: [rt.u8, [rt.char]] = [b ^ 51, [rt.u8Add(65, rt.u8Rem(b, 26)) as rt.char] as [rt.char]]; - return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rt.u8, rt.u16, rt.char, string, rt.u8, rt.u8, [rt.u8, rt.u8], rt.u8, [rt.u8, rt.u16], rt.u8, undefined, [rt.u8, [rt.char]]]; - }); - const _15: [rt.ByteVec, rt.Vec, string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]] = rt.tupleExtend([new rt.ByteVec(), new rt.Vec(), "", "", rt.dequeNew(1, true) as rt.VecDeque, rt.heapNew() as rt.BinaryHeap, rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.btreeNew(rt.cmp) as rt.BTreeSet, undefined, [new rt.ByteVec(), [""]]] as [rt.ByteVec, rt.Vec, string, string, rt.VecDeque, rt.BinaryHeap, rt.HashMap, rt.HashSet, rt.BTreeMap, rt.BTreeSet, undefined, [rt.ByteVec, [string]]], _16, [rt.byteVecPart(), rt.vecPart(2), rt.STRING_CHARS_PART, rt.STRING_PART, rt.dequePart(), rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048), rt.hashKeysPart(undefined, 469762048), rt.btreePart(), rt.btreeKeysPart(), rt.UNIT_PART, rt.tuplePart([rt.byteVecPart(), rt.tuplePart([rt.STRING_CHARS_PART])])]); - const bytes: rt.ByteVec = _15[0]; - const wide: rt.Vec = _15[1]; + const _12: rs.u16 = rs.u16Mul(b as rs.u16, 257); + const _152: rs.char = b as rs.char; + const _162: rs.u8 = ~b & 0xff; + const _172: [rs.u8, rs.u8] = [rs.u8Rem(b, 4), b]; + const _202: rs.u8 = rs.u8Rem(b, 6); + const _222: [rs.u8, rs.u16] = [rs.u8Rem(b, 3), b as rs.u16]; + const _262: rs.u8 = rs.u8Div(b, 16); + const _28: [rs.u8, [rs.char]] = [b ^ 51, [rs.u8Add(65, rs.u8Rem(b, 26)) as rs.char] as [rs.char]]; + return [b, _12, _152, _5[_8], _162, b, _172, _202, _222, _262, undefined, _28] as [rs.u8, rs.u16, rs.char, string, rs.u8, rs.u8, [rs.u8, rs.u8], rs.u8, [rs.u8, rs.u16], rs.u8, undefined, [rs.u8, [rs.char]]]; + }); + const _15: [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]] = rs.tupleExtend([new rs.ByteVec(), new rs.Vec(), "", "", rs.dequeNew(1, true) as rs.VecDeque, rs.heapNew() as rs.BinaryHeap, rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.btreeNew(rs.cmp) as rs.BTreeSet, undefined, [new rs.ByteVec(), [""]]] as [rs.ByteVec, rs.Vec, string, string, rs.VecDeque, rs.BinaryHeap, rs.HashMap, rs.HashSet, rs.BTreeMap, rs.BTreeSet, undefined, [rs.ByteVec, [string]]], _16, [rs.byteVecPart(), rs.vecPart(2), rs.STRING_CHARS_PART, rs.STRING_PART, rs.dequePart(), rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048), rs.hashKeysPart(undefined, 469762048), rs.btreePart(), rs.btreeKeysPart(), rs.UNIT_PART, rs.tuplePart([rs.byteVecPart(), rs.tuplePart([rs.STRING_CHARS_PART])])]); + const bytes: rs.ByteVec = _15[0]; + const wide: rs.Vec = _15[1]; const chars: string = _15[2]; const texts: string = _15[3]; - const q: rt.VecDeque = _15[4]; - const heap: rt.BinaryHeap = _15[5]; - const map: rt.HashMap = _15[6]; - const set: rt.HashSet = _15[7]; - const tree: rt.BTreeMap = _15[8]; - const keys: rt.BTreeSet = _15[9]; - const v: rt.ByteVec = _15[11][0]; + const q: rs.VecDeque = _15[4]; + const heap: rs.BinaryHeap = _15[5]; + const map: rs.HashMap = _15[6]; + const set: rs.HashSet = _15[7]; + const tree: rs.BTreeMap = _15[8]; + const keys: rs.BTreeSet = _15[9]; + const v: rs.ByteVec = _15[11][0]; const s: string = _15[11][1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(wide.items), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(chars), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(texts), undefined, true); - rt.iterExtendBytes(out, rt.dequeIntoIter(q), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(heap)), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(wide.items), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(chars), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(texts), undefined, true); + rs.iterExtendBytes(out, rs.dequeIntoIter(q), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(heap)), undefined, true); entries(map, out); sorted(set, out); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_210: [rt.u8, rt.u16]): Uint8Array => { - const k: rt.u8 = _210[0]; - return rt.bytesMap(rt.u16ToBeBytes(_210[1]).reverse(), (x: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(tree), (_210: [rs.u8, rs.u16]): Uint8Array => { + const k: rs.u8 = _210[0]; + return rs.bytesMap(rs.u16ToBeBytes(_210[1]).reverse(), (x: rs.u8): rs.u8 => { return x ^ k; }); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.btreeKeys(keys), undefined, true); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(keys), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); } /** * `extend` onto collections that hold some already: a heap sifts each item up past them, * and a map or set keeps an equal key already there. */ -export function extended(data: rt.ByteSlice, out: rt.ByteVec): void { - const t: [rt.ByteVec, string, rt.BTreeMap, rt.VecDeque, rt.HashSet] = [rt.byteVecFrom(Uint8Array.of(9, 8)), "pre", rt.btreeExtend(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterSlice([[3, 30] as [rt.u8, rt.u16]]), true, undefined, undefined, undefined, 4, true), rt.dequeFromArray([1], 2) as rt.VecDeque, rt.hashExtendKeys(rt.hashNew() as rt.HashSet, rt.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; - const _16: rt.Iter<[rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8] => { - const b: rt.u8 = _2; - return [b, b as rt.char, [rt.u8Rem(b, 8), b as rt.u16] as [rt.u8, rt.u16], b as rt.u16, rt.u8Rem(b, 16)] as [rt.u8, rt.char, [rt.u8, rt.u16], rt.u16, rt.u8]; - }); - rt.tupleExtend(t, _16, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.btreePart(), rt.dequePart(), rt.hashKeysPart(undefined, 469762048)]); - const v: rt.ByteVec = t[0]; +export function extended(data: rs.ByteSlice, out: rs.ByteVec): void { + const t: [rs.ByteVec, string, rs.BTreeMap, rs.VecDeque, rs.HashSet] = [rs.byteVecFrom(Uint8Array.of(9, 8)), "pre", rs.btreeExtend(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterSlice([[3, 30] as [rs.u8, rs.u16]]), true, undefined, undefined, undefined, 4, true), rs.dequeFromArray([1], 2) as rs.VecDeque, rs.hashExtendKeys(rs.hashNew() as rs.HashSet, rs.iterSlice(Uint8Array.of(5)), undefined, undefined, 469762048)]; + const _16: rs.Iter<[rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8] => { + const b: rs.u8 = _2; + return [b, b as rs.char, [rs.u8Rem(b, 8), b as rs.u16] as [rs.u8, rs.u16], b as rs.u16, rs.u8Rem(b, 16)] as [rs.u8, rs.char, [rs.u8, rs.u16], rs.u16, rs.u8]; + }); + rs.tupleExtend(t, _16, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.btreePart(), rs.dequePart(), rs.hashKeysPart(undefined, 469762048)]); + const v: rs.ByteVec = t[0]; const s: string = t[1]; - const tree: rt.BTreeMap = t[2]; - const q: rt.VecDeque = t[3]; - const set: rt.HashSet = t[4]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.btreeIter(tree), (_22: [rt.u8, rt.u16]): Uint8Array => { + const tree: rs.BTreeMap = t[2]; + const q: rs.VecDeque = t[3]; + const set: rs.HashSet = t[4]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.btreeIter(tree), (_22: [rs.u8, rs.u16]): Uint8Array => { return Uint8Array.of(_22[0], _22[1] & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.dequeIter(q), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.dequeIter(q), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); sorted(set, out); - const t2: [rt.BinaryHeap, rt.HashMap] = [rt.heapFrom(rt.iterToVec(rt.iterSlice(Uint8Array.of(7, 200, 30)), undefined, 1, true), rt.le, rt.ge, rt.lt), rt.hashExtend(rt.hashNew() as rt.HashMap, rt.iterSlice([[1, 1] as [rt.u8, rt.u8]]), undefined, undefined, undefined, 469762048)]; - const _45: rt.Iter<[rt.u8, [rt.u8, rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_23: rt.u8): [rt.u8, [rt.u8, rt.u8]] => { - const b2: rt.u8 = _23; - return [b2, [rt.u8Rem(b2, 4), b2] as [rt.u8, rt.u8]] as [rt.u8, [rt.u8, rt.u8]]; + const t2: [rs.BinaryHeap, rs.HashMap] = [rs.heapFrom(rs.iterToVec(rs.iterSlice(Uint8Array.of(7, 200, 30)), undefined, 1, true), rs.le, rs.ge, rs.lt), rs.hashExtend(rs.hashNew() as rs.HashMap, rs.iterSlice([[1, 1] as [rs.u8, rs.u8]]), undefined, undefined, undefined, 469762048)]; + const _45: rs.Iter<[rs.u8, [rs.u8, rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_23: rs.u8): [rs.u8, [rs.u8, rs.u8]] => { + const b2: rs.u8 = _23; + return [b2, [rs.u8Rem(b2, 4), b2] as [rs.u8, rs.u8]] as [rs.u8, [rs.u8, rs.u8]]; }); - rt.tupleExtend(t2, _45, [rt.heapPart(rt.le, 1), rt.hashPart(undefined, undefined, 469762048)]); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.byteVecFromVec(t2[0])), undefined, true); + rs.tupleExtend(t2, _45, [rs.heapPart(rs.le, 1), rs.hashPart(undefined, undefined, 469762048)]); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.byteVecFromVec(t2[0])), undefined, true); entries(t2[1], out); } /** `Extend<&T>` and `Extend<(&K, &V)>`, which store copies of what the items borrow. */ -export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { - const points: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Spot.Spot => { - const b: rt.u8 = _2; - return { x: b, y: ((b as rt.u16) << 2) & 0xffff }; +export function borrowed(data: rs.ByteSlice, out: rs.ByteVec): void { + const points: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Spot.Spot => { + const b: rs.u8 = _2; + return { x: b, y: ((b as rs.u16) << 2) & 0xffff }; }), undefined, 4, true); - const t: [rt.ByteVec, rt.Vec, rt.HashMap, string] = [new rt.ByteVec(), new rt.Vec(), rt.hashNew() as rt.HashMap, ""]; - const marks: rt.char[] = [122, 233]; - const _10: rt.Iter<[rt.u8, Spot.Spot, [rt.u8, rt.u8], rt.char]> = rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(data)), rt.iterSlice(points.items), [false, false]), (_23: [rt.u8, Spot.Spot]): [rt.u8, Spot.Spot, [rt.u8, rt.u8], rt.char] => { - const _54: [rt.u8, rt.u8] = [_23[0], _23[0]]; - const _72: rt.usize = (_23[0] & 1) as rt.usize; + const t: [rs.ByteVec, rs.Vec, rs.HashMap, string] = [new rs.ByteVec(), new rs.Vec(), rs.hashNew() as rs.HashMap, ""]; + const marks: rs.char[] = [122, 233]; + const _10: rs.Iter<[rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]> = rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(data)), rs.iterSlice(points.items), [false, false]), (_23: [rs.u8, Spot.Spot]): [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char] => { + const _54: [rs.u8, rs.u8] = [_23[0], _23[0]]; + const _72: rs.usize = (_23[0] & 1) as rs.usize; if (!(_72 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _72); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _72); } - return [_23[0], _23[1], _54, marks[_72]] as [rt.u8, Spot.Spot, [rt.u8, rt.u8], rt.char]; + return [_23[0], _23[1], _54, marks[_72]] as [rs.u8, Spot.Spot, [rs.u8, rs.u8], rs.char]; }); - rt.tupleExtend(t, _10, [rt.byteVecPart(), rt.copiedPart(rt.vecPart(4), copy$tuples_Spot), rt.hashPart(undefined, undefined, 469762048), rt.STRING_CHARS_PART]); - const ones: [rt.Vec] = [new rt.Vec()]; - const _20: rt.Iter<[Spot.Spot]> = rt.iterMap(rt.iterSlice(points.items), (p: Spot.Spot): [Spot.Spot] => { + rs.tupleExtend(t, _10, [rs.byteVecPart(), rs.copiedPart(rs.vecPart(4), copy$tuples_Spot), rs.hashPart(undefined, undefined, 469762048), rs.STRING_CHARS_PART]); + const ones: [rs.Vec] = [new rs.Vec()]; + const _20: rs.Iter<[Spot.Spot]> = rs.iterMap(rs.iterSlice(points.items), (p: Spot.Spot): [Spot.Spot] => { return [p] as [Spot.Spot]; }); - rt.tupleExtendOne(ones, _20, (c, items) => rt.iterExtend(c, rt.iterMap(items, copy$tuples_Spot), undefined, 4, true)); + rs.tupleExtendOne(ones, _20, (c, items) => rs.iterExtend(c, rs.iterMap(items, copy$tuples_Spot), undefined, 4, true)); for (const _27 of points.items) { _27.x = 238; } - const v: rt.ByteVec = t[0]; - const copied: rt.Vec = t[1]; - const map: rt.HashMap = t[2]; + const v: rs.ByteVec = t[0]; + const copied: rs.Vec = t[1]; + const map: rs.HashMap = t[2]; const s: string = t[3]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterChain(rt.iterSlice(copied.items), rt.iterSlice(ones[0].items)), (p2: Spot.Spot): Uint8Array => { + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterChain(rs.iterSlice(copied.items), rs.iterSlice(ones[0].items)), (p2: Spot.Spot): Uint8Array => { return Uint8Array.of(p2.x, p2.y & 0xff); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); entries(map, out); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(points.items), (p3: Spot.Spot): rt.u8 => { + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(points.items), (p3: Spot.Spot): rs.u8 => { return p3.x; }), undefined, true); } @@ -369,216 +369,216 @@ export function borrowed(data: rt.ByteSlice, out: rt.ByteVec): void { * to one it holds, as each item's fields extend in order, and what an iterator still * holds drops once the tuple extended by it is done. */ -export function dropped(data: rt.ByteSlice, out: rt.ByteVec): void { - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const logged: (a0: rt.u8, a1: rt.u8) => Logged.Logged = (id: rt.u8, key: rt.u8): Logged.Logged => { - return new Logged.Logged(id, key, rt.arcClone(log)); +export function dropped(data: rs.ByteSlice, out: rs.ByteVec): void { + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const logged: (a0: rs.u8, a1: rs.u8) => Logged.Logged = (id: rs.u8, key: rs.u8): Logged.Logged => { + return new Logged.Logged(id, key, rs.arcClone(log)); }; - const _12: rt.Iter<[Logged.Logged, [rt.u8, Logged.Logged], Logged.Logged]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [Logged.Logged, [rt.u8, Logged.Logged], Logged.Logged] => { - const i: rt.usize = _2[0]; - const b: rt.u8 = _2[1]; - const i2: rt.u8 = i & 0xff; - return [logged(i2, b), [rt.u8Rem(b, 4), logged(64 | i2, 0)] as [rt.u8, Logged.Logged], logged(128 | i2, rt.u8Rem(b, 3))] as [Logged.Logged, [rt.u8, Logged.Logged], Logged.Logged]; - }); - const _11: [rt.Vec, rt.HashMap, rt.BTreeSet] = rt.tupleExtend([new rt.Vec(), rt.hashNew() as rt.HashMap, rt.btreeNew(Logged.cmp$cmp_Ord) as rt.BTreeSet] as [rt.Vec, rt.HashMap, rt.BTreeSet], _12, [rt.vecPart(8), rt.hashPart(undefined, rt.drop, 117440512), rt.btreeKeysPart(rt.drop)]); - const v: rt.Vec = _11[0]; - const map: rt.HashMap = _11[1]; - const set: rt.BTreeSet = _11[2]; + const _12: rs.Iter<[Logged.Logged, [rs.u8, Logged.Logged], Logged.Logged]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): [Logged.Logged, [rs.u8, Logged.Logged], Logged.Logged] => { + const i: rs.usize = _2[0]; + const b: rs.u8 = _2[1]; + const i2: rs.u8 = i & 0xff; + return [logged(i2, b), [rs.u8Rem(b, 4), logged(64 | i2, 0)] as [rs.u8, Logged.Logged], logged(128 | i2, rs.u8Rem(b, 3))] as [Logged.Logged, [rs.u8, Logged.Logged], Logged.Logged]; + }); + const _11: [rs.Vec, rs.HashMap, rs.BTreeSet] = rs.tupleExtend([new rs.Vec(), rs.hashNew() as rs.HashMap, rs.btreeNew(Logged.cmp$cmp_Ord) as rs.BTreeSet] as [rs.Vec, rs.HashMap, rs.BTreeSet], _12, [rs.vecPart(8), rs.hashPart(undefined, rs.drop, 117440512), rs.btreeKeysPart(rs.drop)]); + const v: rs.Vec = _11[0]; + const map: rs.HashMap = _11[1]; + const set: rs.BTreeSet = _11[2]; flush(log.value, out); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v.items), (l: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v.items), (l: Logged.Logged): rs.u8 => { return l.id; }), undefined, true); - const held: rt.Vec<[rt.u8, Logged.Logged]> = rt.iterToVec(rt.hashIter(map, undefined, rt.drop), "next", 12); - rt.sliceSort(held.items, rt.keyLt((_24: [rt.u8, Logged.Logged]): rt.u8 => { + const held: rs.Vec<[rs.u8, Logged.Logged]> = rs.iterToVec(rs.hashIter(map, undefined, rs.drop), "next", 12); + rs.sliceSort(held.items, rs.keyLt((_24: [rs.u8, Logged.Logged]): rs.u8 => { return _24[0]; - }, rt.lt), 12, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held.items), (_25: [rt.u8, Logged.Logged]): rt.u8 => { + }, rs.lt), 12, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held.items), (_25: [rs.u8, Logged.Logged]): rs.u8 => { return _25[0] ^ _25[1].id; }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.btreeKeys(set), (l2: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.btreeKeys(set), (l2: Logged.Logged): rs.u8 => { return l2.id; }), undefined, true); - rt.dropVec(v); - rt.dropVec(held, drop$tuple2_u8_tuples_Logged); - rt.btreeDrop(set, rt.drop); + rs.dropVec(v); + rs.dropVec(held, drop$tuple2_u8_tuples_Logged); + rs.btreeDrop(set, rs.drop); flush(log.value, out); - const _49: rt.Iter<[[rt.u8, Logged.Logged], Logged.Logged]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_27: [rt.usize, rt.u8]): [[rt.u8, Logged.Logged], Logged.Logged] => { - const i3: rt.usize = _27[0]; - const b2: rt.u8 = _27[1]; - return [[rt.u8Rem(b2, 3), logged(i3 & 0xff, 0)] as [rt.u8, Logged.Logged], logged(128 | (i3 & 0xff), rt.u8Rem(b2, 5))] as [[rt.u8, Logged.Logged], Logged.Logged]; - }); - const _48: [rt.BTreeMap, rt.HashSet] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.hashNew(rt.hashing(Logged.hash$Hash_hash_DefaultHasher as (a0: Logged.Logged, a1: rt.Hasher) => undefined, Logged.eq$cmp_PartialEq)) as rt.HashSet] as [rt.BTreeMap, rt.HashSet], _49, [rt.btreePart(undefined, rt.drop), rt.hashKeysPart(rt.drop, 117440512)]); - const tree: rt.BTreeMap = _48[0]; - const keys: rt.HashSet = _48[1]; + const _49: rs.Iter<[[rs.u8, Logged.Logged], Logged.Logged]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_27: [rs.usize, rs.u8]): [[rs.u8, Logged.Logged], Logged.Logged] => { + const i3: rs.usize = _27[0]; + const b2: rs.u8 = _27[1]; + return [[rs.u8Rem(b2, 3), logged(i3 & 0xff, 0)] as [rs.u8, Logged.Logged], logged(128 | (i3 & 0xff), rs.u8Rem(b2, 5))] as [[rs.u8, Logged.Logged], Logged.Logged]; + }); + const _48: [rs.BTreeMap, rs.HashSet] = rs.tupleExtend([rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.hashNew(rs.hashing(Logged.hash$Hash_hash_DefaultHasher as (a0: Logged.Logged, a1: rs.Hasher) => undefined, Logged.eq$cmp_PartialEq)) as rs.HashSet] as [rs.BTreeMap, rs.HashSet], _49, [rs.btreePart(undefined, rs.drop), rs.hashKeysPart(rs.drop, 117440512)]); + const tree: rs.BTreeMap = _48[0]; + const keys: rs.HashSet = _48[1]; flush(log.value, out); - const held2: rt.Vec = rt.iterToVec(rt.hashKeys(keys), "next", 4); - rt.sliceSort(held2.items, rt.keyLt((l3: Logged.Logged): rt.u8 => { + const held2: rs.Vec = rs.iterToVec(rs.hashKeys(keys), "next", 4); + rs.sliceSort(held2.items, rs.keyLt((l3: Logged.Logged): rs.u8 => { return l3.key; - }, rt.lt), 4, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(held2.items), (l4: Logged.Logged): rt.u8 => { + }, rs.lt), 4, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(held2.items), (l4: Logged.Logged): rs.u8 => { return l4.id; }), undefined, true); - rt.btreeDrop(tree, undefined, rt.drop); + rs.btreeDrop(tree, undefined, rs.drop); flush(log.value, out); - const source: rt.Vec<[Logged.Logged, rt.u8]> = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_29: [rt.usize, rt.u8]): [Logged.Logged, rt.u8] => { - const i4: rt.usize = _29[0]; - const b3: rt.u8 = _29[1]; - return [logged(i4 & 0xff, b3), b3] as [Logged.Logged, rt.u8]; + const source: rs.Vec<[Logged.Logged, rs.u8]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_29: [rs.usize, rs.u8]): [Logged.Logged, rs.u8] => { + const i4: rs.usize = _29[0]; + const b3: rs.u8 = _29[1]; + return [logged(i4 & 0xff, b3), b3] as [Logged.Logged, rs.u8]; }), undefined, 12, true); - const n: rt.usize = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; - const _87: rt.Iter<[Logged.Logged, rt.u8]> = rt.iterTake(rt.vecIntoIter(source, drop$tuple2_tuples_Logged_u8), n, drop$tuple2_tuples_Logged_u8); - const _86: [rt.Vec, rt.ByteVec] = rt.tupleExtend([new rt.Vec(), new rt.ByteVec()] as [rt.Vec, rt.ByteVec], _87, [rt.vecPart(8), rt.byteVecPart()], "fold"); - const taken: rt.Vec = _86[0]; - const bytes: rt.ByteVec = _86[1]; + const n: rs.usize = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8) as rs.usize; + const _87: rs.Iter<[Logged.Logged, rs.u8]> = rs.iterTake(rs.vecIntoIter(source, drop$tuple2_tuples_Logged_u8), n, drop$tuple2_tuples_Logged_u8); + const _86: [rs.Vec, rs.ByteVec] = rs.tupleExtend([new rs.Vec(), new rs.ByteVec()] as [rs.Vec, rs.ByteVec], _87, [rs.vecPart(8), rs.byteVecPart()], "fold"); + const taken: rs.Vec = _86[0]; + const bytes: rs.ByteVec = _86[1]; flush(log.value, out); - rt.iterExtendBytes(out, rt.byteVecIntoIter(bytes), undefined, true); - rt.dropVec(taken); + rs.iterExtendBytes(out, rs.byteVecIntoIter(bytes), undefined, true); + rs.dropVec(taken); flush(log.value, out); - rt.hashDrop(keys, rt.drop); - const _101: rt.RefCell = rt.refCellBorrowMut(log.value); - rt.byteVecClear(_101.value); - rt.refMutRelease(_101); + rs.hashDrop(keys, rs.drop); + const _101: rs.RefCell = rs.refCellBorrowMut(log.value); + rs.byteVecClear(_101.value); + rs.refMutRelease(_101); log[Symbol.dispose](); } /** A panic midway, from what makes the items. */ -export function panicked(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: rt.usize = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; - const _13: rt.Iter<[rt.u8, rt.char, rt.u16]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [rt.u8, rt.char, rt.u16] => { - const i: rt.usize = _2[0]; - const b: rt.u8 = _2[1]; +export function panicked(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: rs.usize = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8) as rs.usize; + const _13: rs.Iter<[rs.u8, rs.char, rs.u16]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): [rs.u8, rs.char, rs.u16] => { + const i: rs.usize = _2[0]; + const b: rs.u8 = _2[1]; if (!(i !== at)) { - const _11: rt.usize = data.length; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f), (f: rt.Formatter) => rt.usizeDisplay(_11, f)]; - rt.panicFmt(["item ", args2[0], " of ", args2[1]]); + const _11: rs.usize = data.length; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f), (f: rs.Formatter) => rs.usizeDisplay(_11, f)]; + rs.panicFmt(["item ", args2[0], " of ", args2[1]]); } else { - return [b, b as rt.char, b as rt.u16] as [rt.u8, rt.char, rt.u16]; + return [b, b as rs.char, b as rs.u16] as [rs.u8, rs.char, rs.u16]; } }); - const _12: [rt.ByteVec, string, rt.Vec] = rt.tupleExtend([new rt.ByteVec(), "", new rt.Vec()] as [rt.ByteVec, string, rt.Vec], _13, [rt.byteVecPart(), rt.STRING_CHARS_PART, rt.vecPart(2)]); - const v: rt.ByteVec = _12[0]; + const _12: [rs.ByteVec, string, rs.Vec] = rs.tupleExtend([new rs.ByteVec(), "", new rs.Vec()] as [rs.ByteVec, string, rs.Vec], _13, [rs.byteVecPart(), rs.STRING_CHARS_PART, rs.vecPart(2)]); + const v: rs.ByteVec = _12[0]; const s: string = _12[1]; - const w: rt.Vec = _12[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w.items), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + const w: rs.Vec = _12[2]; + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); } /** * A size hint past what a collection may hold, which the first to reserve for it panics * at, in field order, before any item is made. */ -export function reserved(data: rt.ByteSlice, out: rt.ByteVec): void { - const items: rt.Range = new rt.Range(0, 4294967295); - const _4: rt.u8 = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 6); +export function reserved(data: rs.ByteSlice, out: rs.ByteVec): void { + const items: rs.Range = new rs.Range(0, 4294967295); + const _4: rs.u8 = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 6); if (_4 === 0) { - const _11: rt.Iter<[undefined, rt.u32]> = rt.iterMap(items, (i5: rt.u32): [undefined, rt.u32] => { - return [undefined, i5] as [undefined, rt.u32]; + const _11: rs.Iter<[undefined, rs.u32]> = rs.iterMap(items, (i5: rs.u32): [undefined, rs.u32] => { + return [undefined, i5] as [undefined, rs.u32]; }); - rt.byteVecPush(out, rt.tupleExtend([undefined, new rt.Vec()] as [undefined, rt.Vec], _11, [rt.UNIT_PART, rt.vecPart(4)])[1].items.length & 0xff); + rs.byteVecPush(out, rs.tupleExtend([undefined, new rs.Vec()] as [undefined, rs.Vec], _11, [rs.UNIT_PART, rs.vecPart(4)])[1].items.length & 0xff); } else if (_4 === 1) { - const _19: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(items, (i4: rt.u32): [rt.u8, rt.u8] => { - return [i4 & 0xff, i4 & 0xff] as [rt.u8, rt.u8]; + const _19: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(items, (i4: rs.u32): [rs.u8, rs.u8] => { + return [i4 & 0xff, i4 & 0xff] as [rs.u8, rs.u8]; }); - const _18: [rt.HashSet, rt.ByteVec] = rt.tupleExtend([rt.hashNew() as rt.HashSet, new rt.ByteVec()] as [rt.HashSet, rt.ByteVec], _19, [rt.hashKeysPart(undefined, 469762048), rt.byteVecPart()]); - const set: rt.HashSet = _18[0]; - const v2: rt.ByteVec = _18[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(set) & 0xff, v2.length & 0xff)), undefined, true); + const _18: [rs.HashSet, rs.ByteVec] = rs.tupleExtend([rs.hashNew() as rs.HashSet, new rs.ByteVec()] as [rs.HashSet, rs.ByteVec], _19, [rs.hashKeysPart(undefined, 469762048), rs.byteVecPart()]); + const set: rs.HashSet = _18[0]; + const v2: rs.ByteVec = _18[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(set) & 0xff, v2.length & 0xff)), undefined, true); } else if (_4 === 2) { - const _31: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(items, (i3: rt.u32): [rt.u8, rt.u8] => { - return [i3 & 0xff, i3 & 0xff] as [rt.u8, rt.u8]; + const _31: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(items, (i3: rs.u32): [rs.u8, rs.u8] => { + return [i3 & 0xff, i3 & 0xff] as [rs.u8, rs.u8]; }); - const _30: [rt.ByteVec, rt.HashSet] = rt.tupleExtend([new rt.ByteVec(), rt.hashNew() as rt.HashSet] as [rt.ByteVec, rt.HashSet], _31, [rt.byteVecPart(), rt.hashKeysPart(undefined, 469762048)]); - const v3: rt.ByteVec = _30[0]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.hashLen(_30[1]) & 0xff, v3.length & 0xff)), undefined, true); + const _30: [rs.ByteVec, rs.HashSet] = rs.tupleExtend([new rs.ByteVec(), rs.hashNew() as rs.HashSet] as [rs.ByteVec, rs.HashSet], _31, [rs.byteVecPart(), rs.hashKeysPart(undefined, 469762048)]); + const v3: rs.ByteVec = _30[0]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.hashLen(_30[1]) & 0xff, v3.length & 0xff)), undefined, true); } else if (_4 === 3) { - const _43: rt.Iter<[undefined, rt.char]> = rt.iterMap(items, (_2: rt.u32): [undefined, rt.char] => { - return [undefined, 97] as [undefined, rt.char]; + const _43: rs.Iter<[undefined, rs.char]> = rs.iterMap(items, (_2: rs.u32): [undefined, rs.char] => { + return [undefined, 97] as [undefined, rs.char]; }); - const _42: [rt.Vec, string] = rt.tupleExtend([new rt.Vec(), ""] as [rt.Vec, string], _43, [rt.vecPart(0), rt.STRING_CHARS_PART]); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, rt.stringLen(_42[1]) & 0xff)), undefined, true); + const _42: [rs.Vec, string] = rs.tupleExtend([new rs.Vec(), ""] as [rs.Vec, string], _43, [rs.vecPart(0), rs.STRING_CHARS_PART]); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(_42[0].items.length & 0xff, rs.stringLen(_42[1]) & 0xff)), undefined, true); } else if (_4 === 4) { - const _55: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(items, (i2: rt.u32): [rt.u8, rt.u16] => { - return [i2 & 0xff, i2 & 0xffff] as [rt.u8, rt.u16]; + const _55: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(items, (i2: rs.u32): [rs.u8, rs.u16] => { + return [i2 & 0xff, i2 & 0xffff] as [rs.u8, rs.u16]; }); - const _54: [rt.BTreeSet, rt.VecDeque] = rt.tupleExtend([rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.dequeNew(2) as rt.VecDeque] as [rt.BTreeSet, rt.VecDeque], _55, [rt.btreeKeysPart(), rt.dequePart()]); - const tree: rt.BTreeSet = _54[0]; - const q: rt.VecDeque = _54[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(rt.btreeLen(tree) & 0xff, q.n & 0xff)), undefined, true); + const _54: [rs.BTreeSet, rs.VecDeque] = rs.tupleExtend([rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.dequeNew(2) as rs.VecDeque] as [rs.BTreeSet, rs.VecDeque], _55, [rs.btreeKeysPart(), rs.dequePart()]); + const tree: rs.BTreeSet = _54[0]; + const q: rs.VecDeque = _54[1]; + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(rs.btreeLen(tree) & 0xff, q.n & 0xff)), undefined, true); } else { - const _66: rt.Iter<[rt.u8]> = rt.iterMap(items, (i: rt.u32): [rt.u8] => { - return [i & 0xff] as [rt.u8]; + const _66: rs.Iter<[rs.u8]> = rs.iterMap(items, (i: rs.u32): [rs.u8] => { + return [i & 0xff] as [rs.u8]; }); - rt.byteVecPush(out, rt.tupleExtendOne([new rt.ByteVec()] as [rt.ByteVec], _66, (c, items2) => rt.iterExtendBytes(c, items2, undefined, true))[0].length & 0xff); + rs.byteVecPush(out, rs.tupleExtendOne([new rs.ByteVec()] as [rs.ByteVec], _66, (c, items2) => rs.iterExtendBytes(c, items2, undefined, true))[0].length & 0xff); } } /** `collect` of `Result`s and `Option`s of pairs, into one of a tuple, which std's docs show. */ -export function shunted(data: rt.ByteSlice, out: rt.ByteVec): void { - const parsed: rt.Result<[rt.ByteVec, string], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.Result<[rt.u8, rt.char], rt.u8> => { - const b: rt.u8 = _2; +export function shunted(data: rs.ByteSlice, out: rs.ByteVec): void { + const parsed: rs.Result<[rs.ByteVec, string], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.Result<[rs.u8, rs.char], rs.u8> => { + const b: rs.u8 = _2; if (!(b === 0)) { - return rt.Ok([b, b as rt.char] as [rt.u8, rt.char]); + return rs.Ok([b, b as rs.char] as [rs.u8, rs.char]); } - return rt.Err(b); - }), (values: rt.Iter<[rt.u8, rt.char]>) => rt.tupleExtend([new rt.ByteVec(), ""] as [rt.ByteVec, string], values, [rt.byteVecPart(), rt.STRING_CHARS_PART])); + return rs.Err(b); + }), (values: rs.Iter<[rs.u8, rs.char]>) => rs.tupleExtend([new rs.ByteVec(), ""] as [rs.ByteVec, string], values, [rs.byteVecPart(), rs.STRING_CHARS_PART])); if (parsed.ok) { - const v: rt.ByteVec = parsed.value[0]; + const v: rs.ByteVec = parsed.value[0]; const s: string = parsed.value[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } - const found: [rt.Vec, rt.BTreeSet] | undefined = rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): [rt.u16, rt.u8] | undefined => { - const b2: rt.u8 = _22; - return option_map$1pb5zw8(rt.u8CheckedSub(b2, 4), (n: rt.u8): [rt.u16, rt.u8] => { - return [n as rt.u16, rt.u8Rem(b2, 8)] as [rt.u16, rt.u8]; + const found: [rs.Vec, rs.BTreeSet] | undefined = rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): [rs.u16, rs.u8] | undefined => { + const b2: rs.u8 = _22; + return option_map$1ykzdkq(rs.u8CheckedSub(b2, 4), (n: rs.u8): [rs.u16, rs.u8] => { + return [n as rs.u16, rs.u8Rem(b2, 8)] as [rs.u16, rs.u8]; }); - }), (values: rt.Iter<[rt.u16, rt.u8]>) => rt.tupleExtend([new rt.Vec(), rt.btreeNew(rt.cmp) as rt.BTreeSet] as [rt.Vec, rt.BTreeSet], values, [rt.vecPart(2), rt.btreeKeysPart()])); + }), (values: rs.Iter<[rs.u16, rs.u8]>) => rs.tupleExtend([new rs.Vec(), rs.btreeNew(rs.cmp) as rs.BTreeSet] as [rs.Vec, rs.BTreeSet], values, [rs.vecPart(2), rs.btreeKeysPart()])); if (found === undefined) { - rt.byteVecPush(out, 249); + rs.byteVecPush(out, 249); } else { - const v2: rt.Vec = found[0]; - const tree: rt.BTreeSet = found[1]; - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(v2.items), (n2: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n2).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); - rt.iterExtendBytes(out, rt.btreeKeys(tree), undefined, true); + const v2: rs.Vec = found[0]; + const tree: rs.BTreeSet = found[1]; + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(v2.items), (n2: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n2).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); + rs.iterExtendBytes(out, rs.btreeKeys(tree), undefined, true); } } -export const CALLS: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(CALLS$init, false); +export const CALLS: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(CALLS$init, false); -export function CALLS$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function CALLS$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } -export const NEXT: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(NEXT$init, false); +export const NEXT: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(NEXT$init, false); -export function NEXT$init(): rt.Cell { - return new rt.Cell(0); +export function NEXT$init(): rs.Cell { + return new rs.Cell(0); } -export function call(entry: rt.ByteSlice): void { - rt.localKeyWithBorrowMut(CALLS, (calls: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(calls, entry); +export function call(entry: rs.ByteSlice): void { + rs.localKeyWithBorrowMut(CALLS, (calls: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(calls, entry); }); } /** Puts what was logged since the last, after a marker. */ -export function calls(out: rt.ByteVec): void { - rt.byteVecPush(out, 253); - rt.localKeyWithBorrowMut(CALLS, (calls: rt.ByteVec): undefined => { - rt.iterExtendBytes(out, rt.byteVecDrain(calls, undefined), "fold", true); +export function calls(out: rs.ByteVec): void { + rs.byteVecPush(out, 253); + rs.localKeyWithBorrowMut(CALLS, (calls: rs.ByteVec): undefined => { + rs.iterExtendBytes(out, rs.byteVecDrain(calls, undefined), "fold", true); }); } /** Logs each item as it is made, before the collections are given its fields. */ -export function made(b: rt.u8): void { - call(rt.byteSliceFrom(Uint8Array.of(160, b))); +export function made(b: rs.u8): void { + call(rs.byteSliceFrom(Uint8Array.of(160, b))); } /** @@ -586,228 +586,228 @@ export function made(b: rt.u8): void { * `unzip`: a 1-tuple's by its own `extend` of every item, and a longer one's by its * `extend` of `Some` of each item, in field order, after each default in field order. */ -export function own(data: rt.ByteSlice, out: rt.ByteVec): void { - const data2: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { - const b2: rt.u8 = _2; +export function own(data: rs.ByteSlice, out: rs.ByteVec): void { + const data2: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { + const b2: rs.u8 = _2; if (!(b2 === 238)) { return b2; } return 237; }), undefined, true); - set$0xuu1fw(NEXT, 0); - rt.localKeyWithBorrowMut(CALLS, (a0: rt.ByteVec): undefined => { - rt.byteVecClear(a0); + set$0e2h2hd(NEXT, 0); + rs.localKeyWithBorrowMut(CALLS, (a0: rs.ByteVec): undefined => { + rs.byteVecClear(a0); }); - const _12: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (b3: rt.u8): undefined => { + const _12: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterInspect(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (b3: rs.u8): undefined => { made(b3); - }), (_22: rt.u8): [rt.u8] => { - return [_22] as [rt.u8]; + }), (_22: rs.u8): [rs.u8] => { + return [_22] as [rs.u8]; }); - rt.byteVecPush(out, rt.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], _12, (c, items) => rt.ownExtend(c, items, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2 as (a0: Tally.Tally, a1: rt.Iter) => undefined))[0].sum); + rs.byteVecPush(out, rs.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], _12, (c, items) => rs.ownExtend(c, items, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Inspect_slice_Iter_u8_tuples_own_closure1_tuples_own_closure2 as (a0: Tally.Tally, a1: rs.Iter) => undefined))[0].sum); calls(out); const one: [Tally.Tally] = [Tally.default$Default()]; - const _24: rt.Iter<[rt.u8]> = rt.iterMap(rt.iterFilter(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_23: rt.u8): boolean => { + const _24: rs.Iter<[rs.u8]> = rs.iterMap(rs.iterFilter(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_23: rs.u8): boolean => { return (_23 & 1) === 0; - }), (_28: rt.u8): [rt.u8] => { - return [_28] as [rt.u8]; + }), (_28: rs.u8): [rs.u8] => { + return [_28] as [rs.u8]; }); - rt.tupleExtendOne(one, _24, (c2, items2) => rt.ownExtend(c2, items2, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4_iter_Extend_tuple1_T_tuple1_ExtendT_extend_closure0_u8_tuples_Tally_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4 as (a0: Tally.Tally, a1: rt.Iter) => undefined)); - rt.byteVecPush(out, one[0].sum); + rs.tupleExtendOne(one, _24, (c2, items2) => rs.ownExtend(c2, items2, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4_iter_Extend_tuple1_T_tuple1_ExtendT_extend_closure0_u8_tuples_Tally_iter_Map_iter_Filter_slice_Iter_u8_tuples_own_closure3_tuples_own_closure4 as (a0: Tally.Tally, a1: rs.Iter) => undefined)); + rs.byteVecPush(out, one[0].sum); calls(out); - const _35: rt.Iter<[rt.u8, rt.u8]> = rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (b7: rt.u8): undefined => { + const _35: rs.Iter<[rs.u8, rs.u8]> = rs.iterMap(rs.iterInspect(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (b7: rs.u8): undefined => { made(b7); - }), (_29: rt.u8): [rt.u8, rt.u8] => { - const b8: rt.u8 = _29; - return [b8 ^ 90, b8] as [rt.u8, rt.u8]; + }), (_29: rs.u8): [rs.u8, rs.u8] => { + const b8: rs.u8 = _29; + return [b8 ^ 90, b8] as [rs.u8, rs.u8]; }); - const _34: [rt.ByteVec, Tally.Tally] = rt.tupleExtend([new rt.ByteVec(), Tally.default$Default()] as [rt.ByteVec, Tally.Tally], _35, [rt.byteVecPart(), rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)]); - const v: rt.ByteVec = _34[0]; + const _34: [rs.ByteVec, Tally.Tally] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default()] as [rs.ByteVec, Tally.Tally], _35, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); + const v: rs.ByteVec = _34[0]; const t2: Tally.Tally = _34[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.byteVecPush(out, t2.sum); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.byteVecPush(out, t2.sum); calls(out); - const _47: rt.Iter<[rt.u8, rt.u16]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_210: rt.u8): [rt.u8, rt.u16] => { - const b9: rt.u8 = _210; - return [b9, ((b9 as rt.u16) << 3) & 0xffff] as [rt.u8, rt.u16]; + const _47: rs.Iter<[rs.u8, rs.u16]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_210: rs.u8): [rs.u8, rs.u16] => { + const b9: rs.u8 = _210; + return [b9, ((b9 as rs.u16) << 3) & 0xffff] as [rs.u8, rs.u16]; }); - const _46: [Tally.Tally, rt.Vec] = rt.tupleExtend([Tally.default$Default(), new rt.Vec()] as [Tally.Tally, rt.Vec], _47, [rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.vecPart(2)]); + const _46: [Tally.Tally, rs.Vec] = rs.tupleExtend([Tally.default$Default(), new rs.Vec()] as [Tally.Tally, rs.Vec], _47, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.vecPart(2)]); const t3: Tally.Tally = _46[0]; - const w: rt.Vec = _46[1]; - rt.byteVecPush(out, t3.sum); - rt.iterExtendBytes(out, rt.iterFlatMap(rt.iterSlice(w.items), (n: rt.u16): Uint8Array => { - return rt.u16ToBeBytes(n).reverse(); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2), undefined, true); + const w: rs.Vec = _46[1]; + rs.byteVecPush(out, t3.sum); + rs.iterExtendBytes(out, rs.iterFlatMap(rs.iterSlice(w.items), (n: rs.u16): Uint8Array => { + return rs.u16ToBeBytes(n).reverse(); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2), undefined, true); calls(out); - const _63: rt.Iter<[rt.u8, rt.char, rt.u8]> = rt.iterMap(rt.iterInspect(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (b10: rt.u8): undefined => { + const _63: rs.Iter<[rs.u8, rs.char, rs.u8]> = rs.iterMap(rs.iterInspect(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (b10: rs.u8): undefined => { made(b10); - }), (_211: rt.u8): [rt.u8, rt.char, rt.u8] => { - const b11: rt.u8 = _211; - return [b11, b11 as rt.char, ~b11 & 0xff] as [rt.u8, rt.char, rt.u8]; + }), (_211: rs.u8): [rs.u8, rs.char, rs.u8] => { + const b11: rs.u8 = _211; + return [b11, b11 as rs.char, ~b11 & 0xff] as [rs.u8, rs.char, rs.u8]; }); - const _62: [Tally.Tally, string, Tally.Tally] = rt.tupleExtend([Tally.default$Default(), "", Tally.default$Default()] as [Tally.Tally, string, Tally.Tally], _63, [rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.STRING_CHARS_PART, rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)]); + const _62: [Tally.Tally, string, Tally.Tally] = rs.tupleExtend([Tally.default$Default(), "", Tally.default$Default()] as [Tally.Tally, string, Tally.Tally], _63, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART, rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); const a: Tally.Tally = _62[0]; const s: string = _62[1]; - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a.sum, _62[2].sum)), undefined, true); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a.sum, _62[2].sum)), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); calls(out); - const _81: rt.Iter<[rt.char, rt.char, rt.u8]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_212: rt.u8): [rt.char, rt.char, rt.u8] => { - const b12: rt.u8 = _212; - return [b12 as rt.char, rt.u8Add(97, rt.u8Rem(b12, 26)) as rt.char, b12] as [rt.char, rt.char, rt.u8]; + const _81: rs.Iter<[rs.char, rs.char, rs.u8]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_212: rs.u8): [rs.char, rs.char, rs.u8] => { + const b12: rs.u8 = _212; + return [b12 as rs.char, rs.u8Add(97, rs.u8Rem(b12, 26)) as rs.char, b12] as [rs.char, rs.char, rs.u8]; }); - const _80: [string, Last.Last, Tally.Tally] = rt.tupleExtend(["", Last.default$Default(), Tally.default$Default()] as [string, Last.Last, Tally.Tally], _81, [rt.STRING_CHARS_PART, rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true), rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)]); + const _80: [string, Last.Last, Tally.Tally] = rs.tupleExtend(["", Last.default$Default(), Tally.default$Default()] as [string, Last.Last, Tally.Tally], _81, [rs.STRING_CHARS_PART, rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)]); const s2: string = _80[0]; const last: Last.Last = _80[1]; const t4: Tally.Tally = _80[2]; - rt.iterExtendBytes(out, rt.strBytes(s2), undefined, true); + rs.iterExtendBytes(out, rs.strBytes(s2), undefined, true); Last.put(last, out); - rt.byteVecPush(out, t4.sum); + rs.byteVecPush(out, t4.sum); calls(out); - const _97: rt.Iter<[rt.u8, [rt.u8]]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_214: rt.u8): [rt.u8, [rt.u8]] => { - const b13: rt.u8 = _214; - return [b13, [b13] as [rt.u8]] as [rt.u8, [rt.u8]]; + const _97: rs.Iter<[rs.u8, [rs.u8]]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_214: rs.u8): [rs.u8, [rs.u8]] => { + const b13: rs.u8 = _214; + return [b13, [b13] as [rs.u8]] as [rs.u8, [rs.u8]]; }); - const _96: [rt.ByteVec, [Tally.Tally]] = rt.tupleExtend([new rt.ByteVec(), [Tally.default$Default()]] as [rt.ByteVec, [Tally.Tally]], _97, [rt.byteVecPart(), rt.tuplePart([rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)])]); - const v2: rt.ByteVec = _96[0]; + const _96: [rs.ByteVec, [Tally.Tally]] = rs.tupleExtend([new rs.ByteVec(), [Tally.default$Default()]] as [rs.ByteVec, [Tally.Tally]], _97, [rs.byteVecPart(), rs.tuplePart([rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)])]); + const v2: rs.ByteVec = _96[0]; const t5: Tally.Tally = _96[1][0]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v2), undefined, true); - rt.byteVecPush(out, t5.sum); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v2), undefined, true); + rs.byteVecPush(out, t5.sum); calls(out); - const _107: rt.Iter<[rt.char]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_216: rt.u8): [rt.char] => { - return [_216 as rt.char] as [rt.char]; - }); - Last.put(rt.tupleExtendOne([Last.default$Default()] as [Last.Last], _107, (c3, items3) => rt.ownExtend(c3, items3, Last.extend$iter_Extend_char_iter_Map_iter_Map_slice_Iter_u8_tuples_own_closure13_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_char_tuples_Last_iter_Map_slice_Iter_u8_tuples_own_closure13 as (a0: rt.Place, a1: rt.Iter) => undefined, true))[0], out); - const t6: [Tally.Tally, rt.ByteVec, Last.Last] = [Tally.default$Default(), rt.byteVecFrom(Uint8Array.of(7)), { tag: "Seen", _0: 113, _1: 9 } as Last.Last]; - const _120: rt.Iter<[rt.u8, rt.u8, rt.char]> = rt.iterMap(rt.byteSliceChunks(rt.byteVecSlice(data2), 2), (c4: rt.ByteSlice): [rt.u8, rt.u8, rt.char] => { - rt.idx(c4, 0); - const _310: rt.u8 = c4.data[c4.start]; - rt.idx(c4, 0); - const _76: rt.u8 = c4.data[c4.start]; - rt.idx(c4, 0); - return [_310, _76, c4.data[c4.start] as rt.char] as [rt.u8, rt.u8, rt.char]; - }); - rt.tupleExtend(t6, _120, [rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart(), rt.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rt.Place, a1: rt.char | undefined) => undefined, true)]); - rt.byteVecPush(out, t6[0].sum); - rt.iterExtendBytes(out, rt.byteVecIntoIter(t6[1]), undefined, true); + const _107: rs.Iter<[rs.char]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_216: rs.u8): [rs.char] => { + return [_216 as rs.char] as [rs.char]; + }); + Last.put(rs.tupleExtendOne([Last.default$Default()] as [Last.Last], _107, (c3, items3) => rs.ownExtend(c3, items3, Last.extend$iter_Extend_char_iter_Map_iter_Map_slice_Iter_u8_tuples_own_closure13_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_char_tuples_Last_iter_Map_slice_Iter_u8_tuples_own_closure13 as (a0: rs.Place, a1: rs.Iter) => undefined, true))[0], out); + const t6: [Tally.Tally, rs.ByteVec, Last.Last] = [Tally.default$Default(), rs.byteVecFrom(Uint8Array.of(7)), { tag: "Seen", _0: 113, _1: 9 } as Last.Last]; + const _120: rs.Iter<[rs.u8, rs.u8, rs.char]> = rs.iterMap(rs.byteSliceChunks(rs.byteVecSlice(data2), 2), (c4: rs.ByteSlice): [rs.u8, rs.u8, rs.char] => { + rs.idx(c4, 0); + const _310: rs.u8 = c4.data[c4.start]; + rs.idx(c4, 0); + const _76: rs.u8 = c4.data[c4.start]; + rs.idx(c4, 0); + return [_310, _76, c4.data[c4.start] as rs.char] as [rs.u8, rs.u8, rs.char]; + }); + rs.tupleExtend(t6, _120, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.byteVecPart(), rs.ownPart(Last.extend$iter_Extend_char_Option_char as (a0: rs.Place, a1: rs.char | undefined) => undefined, true)]); + rs.byteVecPush(out, t6[0].sum); + rs.iterExtendBytes(out, rs.byteVecIntoIter(t6[1]), undefined, true); Last.put(t6[2], out); calls(out); - const parsed: rt.Result<[Tally.Tally, rt.ByteVec], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_217: rt.u8): rt.Result<[rt.u8, rt.u8], rt.u8> => { - const b15: rt.u8 = _217; + const parsed: rs.Result<[Tally.Tally, rs.ByteVec], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_217: rs.u8): rs.Result<[rs.u8, rs.u8], rs.u8> => { + const b15: rs.u8 = _217; if (!(b15 === 0)) { - return rt.Ok([b15, b15] as [rt.u8, rt.u8]); + return rs.Ok([b15, b15] as [rs.u8, rs.u8]); } - return rt.Err(b15); - }), (values: rt.Iter<[rt.u8, rt.u8]>) => rt.tupleExtend([Tally.default$Default(), new rt.ByteVec()] as [Tally.Tally, rt.ByteVec], values, [rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.byteVecPart()])); + return rs.Err(b15); + }), (values: rs.Iter<[rs.u8, rs.u8]>) => rs.tupleExtend([Tally.default$Default(), new rs.ByteVec()] as [Tally.Tally, rs.ByteVec], values, [rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.byteVecPart()])); if (parsed.ok) { const t7: Tally.Tally = parsed.value[0]; - const v3: rt.ByteVec = parsed.value[1]; - rt.byteVecPush(out, t7.sum); - rt.iterExtendBytes(out, rt.byteVecIntoIter(v3), undefined, true); + const v3: rs.ByteVec = parsed.value[1]; + rs.byteVecPush(out, t7.sum); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v3), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, parsed.error)), undefined, true); } calls(out); - const found: [rt.ByteVec, Tally.Tally] | undefined = rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_218: rt.u8): [rt.u8, rt.u8] | undefined => { - const b16: rt.u8 = _218; - return option_map$1fmzefe(rt.u8CheckedSub(b16, 4), (n2: rt.u8): [rt.u8, rt.u8] => { - return [n2, b16] as [rt.u8, rt.u8]; + const found: [rs.ByteVec, Tally.Tally] | undefined = rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_218: rs.u8): [rs.u8, rs.u8] | undefined => { + const b16: rs.u8 = _218; + return option_map$1pv2dfs(rs.u8CheckedSub(b16, 4), (n2: rs.u8): [rs.u8, rs.u8] => { + return [n2, b16] as [rs.u8, rs.u8]; }); - }), (values: rt.Iter<[rt.u8, rt.u8]>) => rt.tupleExtend([new rt.ByteVec(), Tally.default$Default()] as [rt.ByteVec, Tally.Tally], values, [rt.byteVecPart(), rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)])); + }), (values: rs.Iter<[rs.u8, rs.u8]>) => rs.tupleExtend([new rs.ByteVec(), Tally.default$Default()] as [rs.ByteVec, Tally.Tally], values, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)])); if (found === undefined) { - rt.byteVecPush(out, 249); + rs.byteVecPush(out, 249); } else { - const v4: rt.ByteVec = found[0]; + const v4: rs.ByteVec = found[0]; const t8: Tally.Tally = found[1]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v4), undefined, true); - rt.byteVecPush(out, t8.sum); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v4), undefined, true); + rs.byteVecPush(out, t8.sum); } calls(out); - const log: rt.Arc> = new rt.Arc(new rt.RefCell(new rt.ByteVec())); - const held: rt.Result<[rt.Vec, Tally.Tally], rt.u8> = rt.iterCollectResult(rt.vecIntoIter(rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2)))), (_219: [rt.usize, rt.u8]): rt.Result<[Logged.Logged, rt.u8], rt.u8> => { - const i: rt.usize = _219[0]; - const b17: rt.u8 = _219[1]; + const log: rs.Arc> = new rs.Arc(new rs.RefCell(new rs.ByteVec())); + const held: rs.Result<[rs.Vec, Tally.Tally], rs.u8> = rs.iterCollectResult(rs.vecIntoIter(rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2)))), (_219: [rs.usize, rs.u8]): rs.Result<[Logged.Logged, rs.u8], rs.u8> => { + const i: rs.usize = _219[0]; + const b17: rs.u8 = _219[1]; if (!(128 <= b17)) { - return rt.Ok([new Logged.Logged(i & 0xff, b17, rt.arcClone(log)), b17] as [Logged.Logged, rt.u8]); + return rs.Ok([new Logged.Logged(i & 0xff, b17, rs.arcClone(log)), b17] as [Logged.Logged, rs.u8]); } - return rt.Err(b17); - }), undefined, 12, true), drop$Result_tuple2_tuples_Logged_u8_u8), (values: rt.Iter<[Logged.Logged, rt.u8]>) => rt.tupleExtend([new rt.Vec(), Tally.default$Default()] as [rt.Vec, Tally.Tally], values, [rt.vecPart(8), rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined)], "fold"), drop$tuple2_Vec_tuples_Logged_tuples_Tally); + return rs.Err(b17); + }), undefined, 12, true), drop$Result_tuple2_tuples_Logged_u8_u8), (values: rs.Iter<[Logged.Logged, rs.u8]>) => rs.tupleExtend([new rs.Vec(), Tally.default$Default()] as [rs.Vec, Tally.Tally], values, [rs.vecPart(8), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined)], "fold"), drop$tuple2_Vec_tuples_Logged_tuples_Tally); flush(log.value, out); if (held.ok) { - const v5: rt.Vec = held.value[0]; + const v5: rs.Vec = held.value[0]; const t9: Tally.Tally = held.value[1]; - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(v5.items), (l: Logged.Logged): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(v5.items), (l: Logged.Logged): rs.u8 => { return l.id; }), undefined, true); - rt.byteVecPush(out, t9.sum); - rt.dropVec(v5); + rs.byteVecPush(out, t9.sum); + rs.dropVec(v5); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, held.error)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, held.error)), undefined, true); } flush(log.value, out); calls(out); - const nested: rt.Result<[Tally.Tally] | undefined, rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_221: rt.u8): rt.Result<[rt.u8] | undefined, rt.u8> => { - const b18: rt.u8 = _221; + const nested: rs.Result<[Tally.Tally] | undefined, rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_221: rs.u8): rs.Result<[rs.u8] | undefined, rs.u8> => { + const b18: rs.u8 = _221; if (!(240 <= b18)) { if (!(224 <= b18)) { - return rt.Ok([b18] as [rt.u8]); + return rs.Ok([b18] as [rs.u8]); } - return rt.OK; + return rs.OK; } - return rt.Err(b18); - }), (values: rt.Iter<[rt.u8] | undefined>) => rt.iterCollectOption(values, (values: rt.Iter<[rt.u8]>) => rt.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], values, (c5, items4) => rt.ownExtend(c5, items4, Tally.extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never as (a0: Tally.Tally, a1: rt.Iter) => undefined)))); + return rs.Err(b18); + }), (values: rs.Iter<[rs.u8] | undefined>) => rs.iterCollectOption(values, (values: rs.Iter<[rs.u8]>) => rs.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], values, (c5, items4) => rs.ownExtend(c5, items4, Tally.extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure19_Result_never_u8_Option_never as (a0: Tally.Tally, a1: rs.Iter) => undefined)))); if (nested.ok) { if (nested.value === undefined) { - rt.byteVecPush(out, 249); + rs.byteVecPush(out, 249); } else { - rt.byteVecPush(out, nested.value[0].sum); + rs.byteVecPush(out, nested.value[0].sum); } } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, nested.error)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, nested.error)), undefined, true); } calls(out); - const alone: rt.Result<[Tally.Tally], rt.u8> = rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(data2))), (_222: rt.u8): rt.Result<[rt.u8], rt.u8> => { - const b19: rt.u8 = _222; + const alone: rs.Result<[Tally.Tally], rs.u8> = rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(data2))), (_222: rs.u8): rs.Result<[rs.u8], rs.u8> => { + const b19: rs.u8 = _222; if (!(b19 === 255)) { - return rt.Ok([b19] as [rt.u8]); + return rs.Ok([b19] as [rs.u8]); } - return rt.Err(b19); - }), (values: rt.Iter<[rt.u8]>) => rt.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], values, (c6, items5) => rt.ownExtend(c6, items5, Tally.extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8 as (a0: Tally.Tally, a1: rt.Iter) => undefined))); + return rs.Err(b19); + }), (values: rs.Iter<[rs.u8]>) => rs.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], values, (c6, items5) => rs.ownExtend(c6, items5, Tally.extend$iter_Extend_u8_iter_Map_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_adapters_GenericShunt_iter_Map_slice_Iter_u8_tuples_own_closure20_Result_never_u8 as (a0: Tally.Tally, a1: rs.Iter) => undefined))); if (alone.ok) { - rt.byteVecPush(out, alone.value[0].sum); + rs.byteVecPush(out, alone.value[0].sum); } else { - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(250, alone.error)), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(250, alone.error)), undefined, true); } calls(out); log[Symbol.dispose](); } /** A panic in the crate's own `extend` at an item partway, which the panic message names. */ -export function ownPanicked(data: rt.ByteSlice, out: rt.ByteVec): void { - const at: rt.usize = rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0), 8) as rt.usize; - const items: rt.Iter = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): rt.u8 => { - const i: rt.usize = _2[0]; - const b: rt.u8 = _2[1]; +export function ownPanicked(data: rs.ByteSlice, out: rs.ByteVec): void { + const at: rs.usize = rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0), 8) as rs.usize; + const items: rs.Iter = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _2[0]; + const b: rs.u8 = _2[1]; if (!(i === at)) { return b & 127; } return 238; }); - set$0xuu1fw(NEXT, 0); - if (rt.u8Rem(option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, 1), 0), 2) === 0) { - const _25: rt.Iter<[rt.u8, rt.u8, rt.char]> = rt.iterMap(items, (b3: rt.u8): [rt.u8, rt.u8, rt.char] => { - return [b3, b3, b3 as rt.char] as [rt.u8, rt.u8, rt.char]; + set$0e2h2hd(NEXT, 0); + if (rs.u8Rem(option_unwrapOr$1fr498u(rs.byteSliceGet(data, 1), 0), 2) === 0) { + const _25: rs.Iter<[rs.u8, rs.u8, rs.char]> = rs.iterMap(items, (b3: rs.u8): [rs.u8, rs.u8, rs.char] => { + return [b3, b3, b3 as rs.char] as [rs.u8, rs.u8, rs.char]; }); - const _24: [rt.ByteVec, Tally.Tally, string] = rt.tupleExtend([new rt.ByteVec(), Tally.default$Default(), ""] as [rt.ByteVec, Tally.Tally, string], _25, [rt.byteVecPart(), rt.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rt.u8 | undefined) => undefined), rt.STRING_CHARS_PART]); - const v: rt.ByteVec = _24[0]; + const _24: [rs.ByteVec, Tally.Tally, string] = rs.tupleExtend([new rs.ByteVec(), Tally.default$Default(), ""] as [rs.ByteVec, Tally.Tally, string], _25, [rs.byteVecPart(), rs.ownPart(Tally.extend$iter_Extend_u8_Option_u8 as (a0: Tally.Tally, a1: rs.u8 | undefined) => undefined), rs.STRING_CHARS_PART]); + const v: rs.ByteVec = _24[0]; const t: Tally.Tally = _24[1]; const s: string = _24[2]; - rt.iterExtendBytes(out, rt.byteVecIntoIter(v), undefined, true); - rt.byteVecPush(out, t.sum); - rt.iterExtendBytes(out, rt.strBytes(s), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(v), undefined, true); + rs.byteVecPush(out, t.sum); + rs.iterExtendBytes(out, rs.strBytes(s), undefined, true); } else { - const _35: rt.Iter<[rt.u8]> = rt.iterMap(items, (b2: rt.u8): [rt.u8] => { - return [b2] as [rt.u8]; + const _35: rs.Iter<[rs.u8]> = rs.iterMap(items, (b2: rs.u8): [rs.u8] => { + return [b2] as [rs.u8]; }); - rt.byteVecPush(out, rt.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], _35, (c, items2) => rt.ownExtend(c, items2, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2 as (a0: Tally.Tally, a1: rt.Iter) => undefined))[0].sum); + rs.byteVecPush(out, rs.tupleExtendOne([Tally.default$Default()] as [Tally.Tally], _35, (c, items2) => rs.ownExtend(c, items2, Tally.extend$iter_Extend_u8_iter_Map_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2_iter_FromIterator_tuple1_T_tuple1_ExtendT_from_iter_closure0_u8_tuples_Tally_iter_Map_iter_Map_iter_Enumerate_slice_Iter_u8_tuples_own_panicked_closure0_tuples_own_panicked_closure2 as (a0: Tally.Tally, a1: rs.Iter) => undefined))[0].sum); } } diff --git a/ts/fixtures/lang/utf8/expected/alloc/string.ts b/ts/fixtures/lang/utf8/expected/alloc/string.ts index b2cfd6bd2..9fc3f0119 100644 --- a/ts/fixtures/lang/utf8/expected/alloc/string.ts +++ b/ts/fixtures/lang/utf8/expected/alloc/string.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { eq$1v93ipo as str_error_eq$1v93ipo } from "../core/str/error.ts"; +import * as rs from "../rs.ts"; +import { eq$0jlawuy as str_error_eq$0jlawuy } from "../core/str/error.ts"; -export function eq$09knsz6(self: rt.FromUtf8Error, other: rt.FromUtf8Error): boolean { - if (!rt.eqBytes(self.bytes, other.bytes)) { +export function eq$1enuhj8(self: rs.FromUtf8Error, other: rs.FromUtf8Error): boolean { + if (!rs.eqBytes(self.bytes, other.bytes)) { return false; } - return str_error_eq$1v93ipo(self.error, other.error); + return str_error_eq$0jlawuy(self.error, other.error); } //# sourceMappingURL=string.ts.map diff --git a/ts/fixtures/lang/utf8/expected/core/option.ts b/ts/fixtures/lang/utf8/expected/core/option.ts index d52610286..bf46aab96 100644 --- a/ts/fixtures/lang/utf8/expected/core/option.ts +++ b/ts/fixtures/lang/utf8/expected/core/option.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/utf8/expected/core/str/error.ts b/ts/fixtures/lang/utf8/expected/core/str/error.ts index 1c9975cc3..6d655e482 100644 --- a/ts/fixtures/lang/utf8/expected/core/str/error.ts +++ b/ts/fixtures/lang/utf8/expected/core/str/error.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$1v93ipo(self: rt.Utf8Error, other: rt.Utf8Error): boolean { +export function eq$0jlawuy(self: rs.Utf8Error, other: rs.Utf8Error): boolean { if (!(self.validUpTo === other.validUpTo)) { return false; } diff --git a/ts/fixtures/lang/utf8/expected/core/str/lossy.ts b/ts/fixtures/lang/utf8/expected/core/str/lossy.ts index 666f08a7b..ef876993f 100644 --- a/ts/fixtures/lang/utf8/expected/core/str/lossy.ts +++ b/ts/fixtures/lang/utf8/expected/core/str/lossy.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function eq$00vlkdw(self: rt.Utf8Chunk, other: rt.Utf8Chunk): boolean { +export function eq$1kzzmg3(self: rs.Utf8Chunk, other: rs.Utf8Chunk): boolean { if (!(self.valid === other.valid)) { return false; } - return rt.byteSliceEq(self.invalid, other.invalid); + return rs.byteSliceEq(self.invalid, other.invalid); } //# sourceMappingURL=lossy.ts.map diff --git a/ts/fixtures/lang/utf8/expected/harness.ts b/ts/fixtures/lang/utf8/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/utf8/expected/harness.ts +++ b/ts/fixtures/lang/utf8/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/utf8/expected/lib.ts b/ts/fixtures/lang/utf8/expected/lib.ts index 02c9462d8..724ddb6cf 100644 --- a/ts/fixtures/lang/utf8/expected/lib.ts +++ b/ts/fixtures/lang/utf8/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { decodes, lossy } from "./utf8.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["utf8::decodes", decodes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["utf8::lossy", lossy as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["utf8::decodes", decodes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["utf8::lossy", lossy as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/utf8/expected/utf8.ts b/ts/fixtures/lang/utf8/expected/utf8.ts index 8c5b66e95..8c7b601fc 100644 --- a/ts/fixtures/lang/utf8/expected/utf8.ts +++ b/ts/fixtures/lang/utf8/expected/utf8.ts @@ -1,127 +1,127 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { eq$09knsz6 as string_eq$09knsz6 } from "./alloc/string.ts"; -import { mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; -import { eq$00vlkdw as lossy_eq$00vlkdw } from "./core/str/lossy.ts"; +import * as rs from "./rs.ts"; +import { eq$1enuhj8 as string_eq$1enuhj8 } from "./alloc/string.ts"; +import { mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; +import { eq$1kzzmg3 as lossy_eq$1kzzmg3 } from "./core/str/lossy.ts"; import { put } from "./harness.ts"; /** The raw input, or each byte's from `BYTES`. */ -export function input(kind: rt.u8, data: rt.ByteSlice): rt.ByteVec { - if (rt.u8Rem(kind, 2) === 0) { - return rt.byteSliceToByteVec(data); +export function input(kind: rs.u8, data: rs.ByteSlice): rs.ByteVec { + if (rs.u8Rem(kind, 2) === 0) { + return rs.byteSliceToByteVec(data); } - return rt.iterToByteVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): rt.u8 => { - const _52: rt.usize = rt.u8Rem(_2, 32) as rt.usize; + return rs.iterToByteVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): rs.u8 => { + const _52: rs.usize = rs.u8Rem(_2, 32) as rs.usize; if (!(_52 < 32)) { - rt.panic("index out of bounds: the len is " + 32 + " but the index is " + _52); + rs.panic("index out of bounds: the len is " + 32 + " but the index is " + _52); } return Uint8Array.of(0, 65, 127, 192, 193, 194, 223, 224, 225, 237, 238, 239, 240, 241, 244, 245, 128, 143, 144, 159, 160, 191, 128, 143, 144, 159, 160, 191, 128, 191, 152, 187)[_52]; }), undefined, true); } -export function decodes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const bytes: rt.ByteVec = input(kind, data); - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, bytes.length, rt.usizeStep); +export function decodes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const bytes: rs.ByteVec = input(kind, data); + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, bytes.length, rs.usizeStep); while (true) { - const _10: rt.usize | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: rs.usize | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const _14: rt.Result = rt.strFromUtf8(rt.byteSliceRange(rt.byteVecSlice(bytes), _10)); + const _14: rs.Result = rs.strFromUtf8(rs.byteSliceRange(rs.byteVecSlice(bytes), _10)); if (_14.ok) { const s: string = _14.value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(s, f)]; - put(out, rt.fmtFormat([args2[0]])); - rt.byteVecPush(out, rt.stringLen(s) & 0xff); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(s, f)]; + put(out, rs.fmtFormat([args2[0]])); + rs.byteVecPush(out, rs.stringLen(s) & 0xff); } else { - const e: rt.Utf8Error = _14.error; - rt.byteVecPush(out, e.validUpTo & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(e.errorLen, 255, (n: rt.usize): rt.u8 => { + const e: rs.Utf8Error = _14.error; + rs.byteVecPush(out, e.validUpTo & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(e.errorLen, 255, (n: rs.usize): rs.u8 => { return n & 0xff; })); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8ErrorDisplay(e, f), (f: rt.Formatter) => rt.fmtUtf8ErrorDebug(e, f)]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ align: ">", width: 64 }, args4[0]), "|", args4[1], "|", rt.fmtSpec({ alternate: true }, args4[1])])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(e, f), (f: rs.Formatter) => rs.fmtUtf8ErrorDebug(e, f)]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ align: ">", width: 64 }, args4[0]), "|", args4[1], "|", rs.fmtSpec({ alternate: true }, args4[1])])); } } - const _57: rt.Result = rt.strFromUtf8(rt.byteVecSlice(bytes)); + const _57: rs.Result = rs.strFromUtf8(rs.byteVecSlice(bytes)); if (_57.ok) { - rt.byteVecPush(out, rt.stringLen(_57.value) & 0xff); + rs.byteVecPush(out, rs.stringLen(_57.value) & 0xff); } else { - rt.byteVecPush(out, _57.error.validUpTo & 0xff); + rs.byteVecPush(out, _57.error.validUpTo & 0xff); } } -export function lossy(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function lossy(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let _20!: boolean; - const bytes: rt.ByteVec = input(kind, data); - const iter: rt.RangeInclusive = new rt.RangeInclusive(0, bytes.length, rt.usizeStep); + const bytes: rs.ByteVec = input(kind, data); + const iter: rs.RangeInclusive = new rs.RangeInclusive(0, bytes.length, rs.usizeStep); while (true) { - const _10: rt.usize | rt.Done = iter.next(); - if (_10 === rt.DONE) { + const _10: rs.usize | rs.Done = iter.next(); + if (_10 === rs.DONE) { break; } - const rest: rt.ByteSlice = rt.byteSliceRange(rt.byteVecSlice(bytes), _10); - const text: rt.StrCow = rt.stringFromUtf8Lossy(rest); - if (text instanceof rt.Borrowed) { + const rest: rs.ByteSlice = rs.byteSliceRange(rs.byteVecSlice(bytes), _10); + const text: rs.StrCow = rs.stringFromUtf8Lossy(rest); + if (text instanceof rs.Borrowed) { _20 = true; } else { _20 = false; } - rt.byteVecPush(out, _20 ? 1 : 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, rt.strCowStr(text)), (f: rt.Formatter) => rt.fmtStr(rt.strCowStr(text), f)]; - put(out, rt.fmtFormat([args2[0], "|", args2[1]])); - rt.byteVecPush(out, rt.stringLen(rt.strCowStr(text)) & 0xff); - const owned: string = rt.strCowStr(text); + rs.byteVecPush(out, _20 ? 1 : 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, rs.strCowStr(text)), (f: rs.Formatter) => rs.fmtStr(rs.strCowStr(text), f)]; + put(out, rs.fmtFormat([args2[0], "|", args2[1]])); + rs.byteVecPush(out, rs.stringLen(rs.strCowStr(text)) & 0xff); + const owned: string = rs.strCowStr(text); put(out, owned); - put(out, rt.strFromUtf8Unchecked(rt.stringAsBytes(owned))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.stringIntoBytes(owned))); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.stringIntoBytes(owned))); - put(out, rt.strFromUtf8Unchecked(rt.byteVecSlice(rt.stringIntoBytes(owned)))); - const chunks: rt.Iter = rt.byteSliceUtf8Chunks(rest); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8Chunks(chunks, f)]; - put(out, rt.fmtFormat([args4[0], "|", rt.fmtSpec({ alternate: true }, args4[0])])); - let last: rt.Utf8Chunk | undefined = undefined; + put(out, rs.strFromUtf8Unchecked(rs.stringAsBytes(owned))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.stringIntoBytes(owned))); + put(out, rs.strFromUtf8Unchecked(rs.byteVecSlice(rs.stringIntoBytes(owned)))); + const chunks: rs.Iter = rs.byteSliceUtf8Chunks(rest); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; + put(out, rs.fmtFormat([args4[0], "|", rs.fmtSpec({ alternate: true }, args4[0])])); + let last: rs.Utf8Chunk | undefined = undefined; while (true) { - const _79: rt.Utf8Chunk | rt.Done = chunks.next(); - if (_79 !== rt.DONE) { - const chunk: rt.Utf8Chunk = _79; + const _79: rs.Utf8Chunk | rs.Done = chunks.next(); + if (_79 !== rs.DONE) { + const chunk: rs.Utf8Chunk = _79; put(out, chunk.valid); - rt.byteVecExtendFromSlice(out, chunk.invalid); - rt.byteVecPush(out, chunk.invalid.length & 0xff); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8ChunkDebug(chunk, f)]; - put(out, rt.fmtFormat([args6[0], "|", rt.fmtSpec({ alternate: true }, args6[0])])); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8Chunks(chunks, f)]; - put(out, rt.fmtFormat([args8[0]])); - rt.byteVecPush(out, rt.iterCount(chunks.clone()) & 0xff); - rt.byteVecPush(out, lossy_eq$00vlkdw(chunk, chunk) ? 1 : 0); - const _134: rt.Utf8Chunk | undefined = last; - const _137: rt.Utf8Chunk | undefined = chunk; - rt.byteVecPush(out, rt.eqOption(lossy_eq$00vlkdw)(_134, _137) ? 1 : 0); + rs.byteVecExtendFromSlice(out, chunk.invalid); + rs.byteVecPush(out, chunk.invalid.length & 0xff); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ChunkDebug(chunk, f)]; + put(out, rs.fmtFormat([args6[0], "|", rs.fmtSpec({ alternate: true }, args6[0])])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; + put(out, rs.fmtFormat([args8[0]])); + rs.byteVecPush(out, rs.iterCount(chunks.clone()) & 0xff); + rs.byteVecPush(out, lossy_eq$1kzzmg3(chunk, chunk) ? 1 : 0); + const _134: rs.Utf8Chunk | undefined = last; + const _137: rs.Utf8Chunk | undefined = chunk; + rs.byteVecPush(out, rs.eqOption(lossy_eq$1kzzmg3)(_134, _137) ? 1 : 0); last = chunk; } else { break; } } - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8Chunks(chunks, f)]; - put(out, rt.fmtFormat([args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8Chunks(chunks, f)]; + put(out, rs.fmtFormat([args10[0]])); } - const _152: rt.Result = rt.stringFromUtf8(bytes); + const _152: rs.Result = rs.stringFromUtf8(bytes); if (_152.ok) { put(out, _152.value); } else { - const e: rt.FromUtf8Error = _152.error; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(e.bytes)); - const u: rt.Utf8Error = e.error; - rt.byteVecPush(out, u.validUpTo & 0xff); - rt.byteVecPush(out, option_mapOr$02k4ito(u.errorLen, 255, (n: rt.usize): rt.u8 => { + const e: rs.FromUtf8Error = _152.error; + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); + const u: rs.Utf8Error = e.error; + rs.byteVecPush(out, u.validUpTo & 0xff); + rs.byteVecPush(out, option_mapOr$188iunt(u.errorLen, 255, (n: rs.usize): rs.u8 => { return n & 0xff; })); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtUtf8ErrorDisplay(u, f)]; - put(out, rt.fmtFormat([args12[0]])); - put(out, rt.strCowStr(rt.stringFromUtf8Lossy(rt.byteVecSlice(e.bytes)))); - rt.byteVecPush(out, string_eq$09knsz6(rt.fromUtf8ErrorClone(e), e) ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(e.bytes)); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtUtf8ErrorDisplay(u, f)]; + put(out, rs.fmtFormat([args12[0]])); + put(out, rs.strCowStr(rs.stringFromUtf8Lossy(rs.byteVecSlice(e.bytes)))); + rs.byteVecPush(out, string_eq$1enuhj8(rs.fromUtf8ErrorClone(e), e) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(e.bytes)); } } diff --git a/ts/fixtures/lang/wrappers/expected/core/option.ts b/ts/fixtures/lang/wrappers/expected/core/option.ts index f2635ab41..93b13b0f3 100644 --- a/ts/fixtures/lang/wrappers/expected/core/option.ts +++ b/ts/fixtures/lang/wrappers/expected/core/option.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1tvry1i(self: rt.u64 | undefined, default_: rt.u64): rt.u64 { +export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs.u64 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$02k4ito(self: rt.usize | undefined, default_: rt.u8, f: (a0: rt.usize) => rt.u8): rt.u8 { +export function mapOr$188iunt(self: rs.usize | undefined, default_: rs.u8, f: (a0: rs.usize) => rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/wrappers/expected/harness.ts b/ts/fixtures/lang/wrappers/expected/harness.ts index bdd7f29e7..610e5cf7d 100644 --- a/ts/fixtures/lang/wrappers/expected/harness.ts +++ b/ts/fixtures/lang/wrappers/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,29 +18,29 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } /** Write `s` and the byte no UTF-8 holds, which ends it. */ -export function put(out: rt.ByteVec, s: string): void { - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(s)); - rt.byteVecPush(out, 255); +export function put(out: rs.ByteVec, s: string): void { + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(s)); + rs.byteVecPush(out, 255); } //# sourceMappingURL=harness.ts.map diff --git a/ts/fixtures/lang/wrappers/expected/lib.ts b/ts/fixtures/lang/wrappers/expected/lib.ts index d83b65d0c..f314b06e3 100644 --- a/ts/fixtures/lang/wrappers/expected/lib.ts +++ b/ts/fixtures/lang/wrappers/expected/lib.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { wrappers, reverses } from "./wrappers.ts"; /** * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["wrappers::wrappers", wrappers as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wrappers::reverses", reverses as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["wrappers::wrappers", wrappers as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wrappers::reverses", reverses as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.Logged.ts b/ts/fixtures/lang/wrappers/expected/wrappers.Logged.ts index 51746233b..74ce3df4d 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.Logged.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.Logged.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Logs its id as it is cloned, and as it drops. */ export class Logged { - id: rt.u8; - log: rt.RefCell; + id: rs.u8; + log: rs.RefCell; - constructor(id: rt.u8, log: rt.RefCell) { + constructor(id: rs.u8, log: rs.RefCell) { this.id = id; this.log = log; } @@ -18,16 +18,16 @@ export class Logged { } export function clone$Clone(self: Logged): Logged { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, self.id | 128); - rt.refMutRelease(_5); - return new Logged(rt.u8WrappingAdd(self.id, 1) & 127, self.log); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, self.id | 128); + rs.refMutRelease(_5); + return new Logged(rs.u8WrappingAdd(self.id, 1) & 127, self.log); } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self.log); - rt.byteVecPush(_5.value, self.id); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self.log); + rs.byteVecPush(_5.value, self.id); + rs.refMutRelease(_5); } //# sourceMappingURL=wrappers.Logged.ts.map diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.Scale.ts b/ts/fixtures/lang/wrappers/expected/wrappers.Scale.ts index 0cc07a665..f4128fabb 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.Scale.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.Scale.ts @@ -1,22 +1,22 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function eq$cmp_PartialEq(self: Scale, other: Scale): boolean { - return rt.u64Eq(self._0, other._0); + return rs.u64Eq(self._0, other._0); } -export function partialCmp$cmp_PartialOrd(self: Scale, other: Scale): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Scale, other: Scale): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Scale, other: Scale): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord(self: Scale, other: Scale): rs.Ordering { + return rs.cmp(self._0, other._0); } /** A rate that is never 0, as a timescale is. */ export interface Scale { - _0: rt.u64; + _0: rs.u64; } //# sourceMappingURL=wrappers.Scale.ts.map diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.Tally.ts b/ts/fixtures/lang/wrappers/expected/wrappers.Tally.ts index f4119f947..684a00e1c 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.Tally.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.Tally.ts @@ -1,12 +1,12 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A sum that drops, as a fold's accumulator may. */ export class Tally { - _0: rt.u64; + _0: rs.u64; - constructor(_0: rt.u64) { + constructor(_0: rs.u64) { this._0 = _0; } diff --git a/ts/fixtures/lang/wrappers/expected/wrappers.ts b/ts/fixtures/lang/wrappers/expected/wrappers.ts index 5fdccfbd7..254068bd7 100644 --- a/ts/fixtures/lang/wrappers/expected/wrappers.ts +++ b/ts/fixtures/lang/wrappers/expected/wrappers.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$02k4ito as option_mapOr$02k4ito } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$188iunt as option_mapOr$188iunt } from "./core/option.ts"; import { put } from "./harness.ts"; import * as Logged from "./wrappers.Logged.ts"; import * as Scale from "./wrappers.Scale.ts"; import * as Tally from "./wrappers.Tally.ts"; -export function putU64(out: rt.ByteVec, v: rt.u64): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(v))); +export function putU64(out: rs.ByteVec, v: rs.u64): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(v))); } -export function putBound(out: rt.ByteVec, b: rt.RangeBound): void { +export function putBound(out: rs.ByteVec, b: rs.RangeBound): void { if (b.tag === "Included") { - rt.byteVecPush(out, 1); - putU64(out, (b as { tag: "Included"; _0: rt.u64 })._0); + rs.byteVecPush(out, 1); + putU64(out, (b as { tag: "Included"; _0: rs.u64 })._0); } else if (b.tag === "Excluded") { - rt.byteVecPush(out, 2); - putU64(out, (b as { tag: "Excluded"; _0: rt.u64 })._0); + rs.byteVecPush(out, 2); + putU64(out, (b as { tag: "Excluded"; _0: rs.u64 })._0); } else { - rt.byteVecPush(out, 3); + rs.byteVecPush(out, 3); } } @@ -27,475 +27,475 @@ export function putBound(out: rt.ByteVec, b: rt.RangeBound): void { * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_RangeFrom_u64(out: rt.ByteVec, r: rt.RangeFrom): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, { tag: "Included", _0: r.start } as rt.RangeBound); - putBound(out, { tag: "Unbounded" } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Included", _0: r.start } as rt.RangeBound; +export function bounds$ops_RangeFrom_u64(out: rs.ByteVec, r: rs.RangeFrom): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, { tag: "Included", _0: r.start } as rs.RangeBound); + putBound(out, { tag: "Unbounded" } as rs.RangeBound); + const _10: rs.RangeBound = { tag: "Included", _0: r.start } as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _17: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_RangeFull(out: rt.ByteVec, _: undefined): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, { tag: "Unbounded" } as rt.RangeBound); - putBound(out, { tag: "Unbounded" } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; +export function bounds$ops_RangeFull(out: rs.ByteVec, _: undefined): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, { tag: "Unbounded" } as rs.RangeBound); + putBound(out, { tag: "Unbounded" } as rs.RangeBound); + const _10: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; + const _17: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_RangeInclusive_u64(out: rt.ByteVec, r: rt.RangeInclusive): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, rt.rangeInclusiveStartBound(r) as rt.RangeBound); - putBound(out, rt.rangeInclusiveEndBound(r) as rt.RangeBound); - const _10: rt.RangeBound = rt.rangeInclusiveStartBound(r) as rt.RangeBound; +export function bounds$ops_RangeInclusive_u64(out: rs.ByteVec, r: rs.RangeInclusive): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, rs.rangeInclusiveStartBound(r) as rs.RangeBound); + putBound(out, rs.rangeInclusiveEndBound(r) as rs.RangeBound); + const _10: rs.RangeBound = rs.rangeInclusiveStartBound(r) as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = rt.rangeInclusiveEndBound(r) as rt.RangeBound; + const _17: rs.RangeBound = rs.rangeInclusiveEndBound(r) as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_RangeToInclusive_u64(out: rt.ByteVec, r: { end: rt.u64; inclusive: true }): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, { tag: "Unbounded" } as rt.RangeBound); - putBound(out, { tag: "Included", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; +export function bounds$ops_RangeToInclusive_u64(out: rs.ByteVec, r: { end: rs.u64; inclusive: true }): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, { tag: "Unbounded" } as rs.RangeBound); + putBound(out, { tag: "Included", _0: r.end } as rs.RangeBound); + const _10: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = { tag: "Included", _0: r.end } as rt.RangeBound; + const _17: rs.RangeBound = { tag: "Included", _0: r.end } as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_RangeTo_u64(out: rt.ByteVec, r: { end: rt.u64 }): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, { tag: "Unbounded" } as rt.RangeBound); - putBound(out, { tag: "Excluded", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Unbounded" } as rt.RangeBound; +export function bounds$ops_RangeTo_u64(out: rs.ByteVec, r: { end: rs.u64 }): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, { tag: "Unbounded" } as rs.RangeBound); + putBound(out, { tag: "Excluded", _0: r.end } as rs.RangeBound); + const _10: rs.RangeBound = { tag: "Unbounded" } as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = { tag: "Excluded", _0: r.end } as rt.RangeBound; + const _17: rs.RangeBound = { tag: "Excluded", _0: r.end } as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$ops_Range_u64(out: rt.ByteVec, r: rt.Range): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; - putBound(out, { tag: "Included", _0: r.start } as rt.RangeBound); - putBound(out, { tag: "Excluded", _0: r.end } as rt.RangeBound); - const _10: rt.RangeBound = { tag: "Included", _0: r.start } as rt.RangeBound; +export function bounds$ops_Range_u64(out: rs.ByteVec, r: rs.Range): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; + putBound(out, { tag: "Included", _0: r.start } as rs.RangeBound); + putBound(out, { tag: "Excluded", _0: r.end } as rs.RangeBound); + const _10: rs.RangeBound = { tag: "Included", _0: r.start } as rs.RangeBound; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = { tag: "Excluded", _0: r.end } as rt.RangeBound; + const _17: rs.RangeBound = { tag: "Excluded", _0: r.end } as rs.RangeBound; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** * The bounds of `r`, written, then the first sequence and the end past the last it holds, * as a range of groups reads them. */ -export function bounds$tuple2_ops_Bound_u64_ops_Bound_u64(out: rt.ByteVec, r: [rt.RangeBound, rt.RangeBound]): void { - let start!: rt.u64 | undefined; - let end!: rt.u64 | undefined; +export function bounds$tuple2_ops_Bound_u64_ops_Bound_u64(out: rs.ByteVec, r: [rs.RangeBound, rs.RangeBound]): void { + let start!: rs.u64 | undefined; + let end!: rs.u64 | undefined; putBound(out, r[0]); putBound(out, r[1]); - const _10: rt.RangeBound = r[0]; + const _10: rs.RangeBound = r[0]; if (_10.tag === "Included") { - start = (_10 as { tag: "Included"; _0: rt.u64 })._0; + start = (_10 as { tag: "Included"; _0: rs.u64 })._0; } else if (_10.tag === "Excluded") { - start = rt.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rt.u64 })._0, 1); + start = rs.u64CheckedAdd((_10 as { tag: "Excluded"; _0: rs.u64 })._0, 1); } else { start = 0; } - const _17: rt.RangeBound = r[1]; + const _17: rs.RangeBound = r[1]; if (_17.tag === "Included") { - end = rt.u64CheckedAdd((_17 as { tag: "Included"; _0: rt.u64 })._0, 1); + end = rs.u64CheckedAdd((_17 as { tag: "Included"; _0: rs.u64 })._0, 1); } else if (_17.tag === "Excluded") { - end = (_17 as { tag: "Excluded"; _0: rt.u64 })._0; + end = (_17 as { tag: "Excluded"; _0: rs.u64 })._0; } else { end = undefined; } - putU64(out, option_unwrapOr$1tvry1i(start, 0)); - putU64(out, option_unwrapOr$1tvry1i(end, 0)); - rt.byteVecPush(out, rt.u8Add(start !== undefined ? 1 : 0, rt.u8Mul(2, end !== undefined ? 1 : 0))); + putU64(out, option_unwrapOr$15hbiwd(start, 0)); + putU64(out, option_unwrapOr$15hbiwd(end, 0)); + rs.byteVecPush(out, rs.u8Add(start !== undefined ? 1 : 0, rs.u8Mul(2, end !== undefined ? 1 : 0))); } /** A bound of `a` picked by `kind`, held by value. */ -export function boundOf(kind: rt.u8, a: rt.u64): rt.RangeBound { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function boundOf(kind: rs.u8, a: rs.u64): rs.RangeBound { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return { tag: "Included", _0: a } as rt.RangeBound; + return { tag: "Included", _0: a } as rs.RangeBound; } if (_3 === 1) { - return { tag: "Excluded", _0: a } as rt.RangeBound; + return { tag: "Excluded", _0: a } as rs.RangeBound; } - return { tag: "Unbounded" } as rt.RangeBound; + return { tag: "Unbounded" } as rs.RangeBound; } -export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { +export function wrappers(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { let scale!: Scale.Scale; let name!: string; - const _5: (a0: rt.u8) => rt.u64 = (b3: rt.u8): rt.u64 => { - const _3: rt.u8 = rt.u8Rem(b3, 4); + const _5: (a0: rs.u8) => rs.u64 = (b3: rs.u8): rs.u64 => { + const _3: rs.u8 = rs.u8Rem(b3, 4); if (_3 === 0) { - return b3 as rt.u64; + return b3 as rs.u64; } if (_3 === 1) { - return rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, b3 as rt.u64); + return rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, b3 as rs.u64); } if (_3 === 2) { - return rt.u64Add({ hi: 0x200000, lo: 0 } as rt.u64, b3 as rt.u64); + return rs.u64Add({ hi: 0x200000, lo: 0 } as rs.u64, b3 as rs.u64); } - return rt.u64Mul(b3 as rt.u64, 7); + return rs.u64Mul(b3 as rs.u64, 7); }; - const at: (a0: rt.usize) => rt.u8 = (i3: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i3), 0); + const at: (a0: rs.usize) => rs.u8 = (i3: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i3), 0); }; const part = at(0); - const _9: rt.u64 = _5(part); + const _9: rs.u64 = _5(part); const part2 = at(1); - const _8: [rt.u64, rt.u64] = [_9, _5(part2)]; - const a: rt.u64 = _9; - const b: rt.u64 = _8[1]; - const _21: rt.u8 = rt.u8Rem(kind, 5); + const _8: [rs.u64, rs.u64] = [_9, _5(part2)]; + const a: rs.u64 = _9; + const b: rs.u64 = _8[1]; + const _21: rs.u8 = rs.u8Rem(kind, 5); if (_21 === 0) { - bounds$ops_Range_u64(out, new rt.Range(a, b, rt.u64Step)); - bounds$ops_RangeInclusive_u64(out, new rt.RangeInclusive(a, b, rt.u64Step)); - const stepped: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Rem(a, 4), rt.u64Rem(b, 4), rt.u64Step); - while (rt.iterToOption(stepped.next()) !== undefined) { + bounds$ops_Range_u64(out, new rs.Range(a, b, rs.u64Step)); + bounds$ops_RangeInclusive_u64(out, new rs.RangeInclusive(a, b, rs.u64Step)); + const stepped: rs.RangeInclusive = new rs.RangeInclusive(rs.u64Rem(a, 4), rs.u64Rem(b, 4), rs.u64Step); + while (rs.iterToOption(stepped.next()) !== undefined) { } bounds$ops_RangeInclusive_u64(out, stepped); - const top: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a, 2)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step); - while (rt.iterToOption(top.next()) !== undefined) { + const top: rs.RangeInclusive = new rs.RangeInclusive(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Rem(a, 2)), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step); + while (rs.iterToOption(top.next()) !== undefined) { } bounds$ops_RangeInclusive_u64(out, top); - const down: rt.RangeInclusive = new rt.RangeInclusive(0, rt.u64Rem(b, 3), rt.u64Step); - while (rt.iterToOption(down.nextBack()) !== undefined) { + const down: rs.RangeInclusive = new rs.RangeInclusive(0, rs.u64Rem(b, 3), rs.u64Step); + while (rs.iterToOption(down.nextBack()) !== undefined) { } bounds$ops_RangeInclusive_u64(out, down); - const _60: [rt.u64, rt.u64] = [rt.u64Rem(a, 4), rt.u64Rem(b, 4)]; - const lo: rt.u64 = _60[0]; - const hi: rt.u64 = _60[1]; - const found: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, rt.iterAny(found, (x3: rt.u64): boolean => { - return rt.u64Eq(x3, hi); + const _60: [rs.u64, rs.u64] = [rs.u64Rem(a, 4), rs.u64Rem(b, 4)]; + const lo: rs.u64 = _60[0]; + const hi: rs.u64 = _60[1]; + const found: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.byteVecPush(out, rs.iterAny(found, (x3: rs.u64): boolean => { + return rs.u64Eq(x3, hi); }) ? 1 : 0); bounds$ops_RangeInclusive_u64(out, found); - const rejected: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, rt.iterAll(rejected, (x4: rt.u64): boolean => { - return rt.u64Lt(x4, hi); + const rejected: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.byteVecPush(out, rs.iterAll(rejected, (x4: rs.u64): boolean => { + return rs.u64Lt(x4, hi); }) ? 1 : 0); bounds$ops_RangeInclusive_u64(out, rejected.clone()); - rt.byteVecPush(out, rt.iterFind(rejected, (_27: rt.u64): boolean => { + rs.byteVecPush(out, rs.iterFind(rejected, (_27: rs.u64): boolean => { return true; }) !== undefined ? 1 : 0); - const placed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, option_mapOr$02k4ito(rt.iterPosition(placed, (x5: rt.u64): boolean => { - return rt.u64Eq(x5, rt.u64Add(lo, 1)); - }), 238, (i7: rt.usize): rt.u8 => { + const placed: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.byteVecPush(out, option_mapOr$188iunt(rs.iterPosition(placed, (x5: rs.u64): boolean => { + return rs.u64Eq(x5, rs.u64Add(lo, 1)); + }), 238, (i7: rs.usize): rs.u8 => { return i7 & 0xff; })); bounds$ops_RangeInclusive_u64(out, placed); - const each: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.iterForEach(rt.iterBorrow(each), (x6: rt.u64): undefined => { - rt.byteVecPush(out, rt.u64Low(x6) & 0xff); + const each: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.iterForEach(rs.iterBorrow(each), (x6: rs.u64): undefined => { + rs.byteVecPush(out, rs.u64Low(x6) & 0xff); }); bounds$ops_RangeInclusive_u64(out, each); - const summed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - putU64(out, rt.iterSum(rt.iterBorrow(summed), rt.u64Add, 0)); + const summed: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + putU64(out, rs.iterSum(rs.iterBorrow(summed), rs.u64Add, 0)); bounds$ops_RangeInclusive_u64(out, summed); - const top2: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step); - putU64(out, rt.iterCount(rt.iterBorrow(top2)) as rt.u64); + const top2: rs.RangeInclusive = new rs.RangeInclusive(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Rem(a, 3)), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step); + putU64(out, rs.iterCount(rs.iterBorrow(top2)) as rs.u64); bounds$ops_RangeInclusive_u64(out, top2); - const last: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - putU64(out, option_unwrapOr$1tvry1i(rt.iterLast(rt.iterBorrow(last)), 238)); + const last: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + putU64(out, option_unwrapOr$15hbiwd(rs.iterLast(rs.iterBorrow(last)), 238)); bounds$ops_RangeInclusive_u64(out, last); - const most: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - putU64(out, option_unwrapOr$1tvry1i(rt.iterMax(rt.iterBorrow(most), rt.lt), 238)); + const most: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + putU64(out, option_unwrapOr$15hbiwd(rs.iterMax(rs.iterBorrow(most), rs.lt), 238)); bounds$ops_RangeInclusive_u64(out, most); - const collected: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, rt.iterToVec(rt.iterBorrow(collected), undefined, 8, true).items.length & 0xff); + const collected: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.byteVecPush(out, rs.iterToVec(rs.iterBorrow(collected), undefined, 8, true).items.length & 0xff); bounds$ops_RangeInclusive_u64(out, collected); - const gathered: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - const _154: Tally.Tally = rt.iterFold(rt.iterBorrow(gathered), new Tally.Tally(0), (t: Tally.Tally, x7: rt.u64): Tally.Tally => { - const _010: Tally.Tally = new Tally.Tally(rt.u64Add(t._0, x7)); + const gathered: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + const _154: Tally.Tally = rs.iterFold(rs.iterBorrow(gathered), new Tally.Tally(0), (t: Tally.Tally, x7: rs.u64): Tally.Tally => { + const _010: Tally.Tally = new Tally.Tally(rs.u64Add(t._0, x7)); t[Symbol.dispose](); return _010; }); putU64(out, _154._0); _154[Symbol.dispose](); bounds$ops_RangeInclusive_u64(out, gathered); - const keyed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - const _166: rt.RangeInclusive = keyed; - rt.byteVecPush(out, rt.btreeLen(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, rt.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); + const keyed: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + const _166: rs.RangeInclusive = keyed; + rs.byteVecPush(out, rs.btreeLen(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, rs.iterBorrow(_166), true, undefined, undefined, 8, true)) & 0xff); bounds$ops_RangeInclusive_u64(out, keyed); - const queued: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - rt.byteVecPush(out, (rt.dequeFromVec(rt.iterToVec(rt.iterBorrow(queued), undefined, 8, true), 8) as rt.VecDeque).n & 0xff); + const queued: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + rs.byteVecPush(out, (rs.dequeFromVec(rs.iterToVec(rs.iterBorrow(queued), undefined, 8, true), 8) as rs.VecDeque).n & 0xff); bounds$ops_RangeInclusive_u64(out, queued); - const hashed: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - const _186: rt.RangeInclusive = hashed; - rt.byteVecPush(out, rt.hashLen(rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, rt.iterBorrow(_186), undefined, undefined, 117440512)) & 0xff); + const hashed: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + const _186: rs.RangeInclusive = hashed; + rs.byteVecPush(out, rs.hashLen(rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet, rs.iterBorrow(_186), undefined, undefined, 117440512)) & 0xff); bounds$ops_RangeInclusive_u64(out, hashed); - const extended: rt.RangeInclusive = new rt.RangeInclusive(lo, hi, rt.u64Step); - const held: rt.Vec = new rt.Vec(); - rt.iterExtend(held, rt.iterBorrow(extended), undefined, 8, true); - rt.byteVecPush(out, held.items.length & 0xff); + const extended: rs.RangeInclusive = new rs.RangeInclusive(lo, hi, rs.u64Step); + const held: rs.Vec = new rs.Vec(); + rs.iterExtend(held, rs.iterBorrow(extended), undefined, 8, true); + rs.byteVecPush(out, held.items.length & 0xff); bounds$ops_RangeInclusive_u64(out, extended); - const narrow: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Low(lo) & 0xff, rt.u64Low(hi) & 0xff, rt.u8Step); - rt.iterExtendBytes(out, rt.byteVecIntoIter(rt.iterToByteVec(rt.iterBorrow(narrow), undefined, true)), undefined, true); - rt.byteVecPush(out, rt.rangeInclusiveStart(narrow)); - rt.byteVecPush(out, rt.rangeInclusiveIsEmpty(narrow) ? 1 : 0); + const narrow: rs.RangeInclusive = new rs.RangeInclusive(rs.u64Low(lo) & 0xff, rs.u64Low(hi) & 0xff, rs.u8Step); + rs.iterExtendBytes(out, rs.byteVecIntoIter(rs.iterToByteVec(rs.iterBorrow(narrow), undefined, true)), undefined, true); + rs.byteVecPush(out, rs.rangeInclusiveStart(narrow)); + rs.byteVecPush(out, rs.rangeInclusiveIsEmpty(narrow) ? 1 : 0); bounds$ops_RangeTo_u64(out, { end: b }); bounds$ops_RangeToInclusive_u64(out, { end: b, inclusive: true }); - bounds$ops_RangeFrom_u64(out, new rt.RangeFrom(a, rt.u64Step)); + bounds$ops_RangeFrom_u64(out, new rs.RangeFrom(a, rs.u64Step)); bounds$ops_RangeFull(out, undefined); - bounds$tuple2_ops_Bound_u64_ops_Bound_u64(out, [boundOf(at(2), a), boundOf(at(3), b)] as [rt.RangeBound, rt.RangeBound]); - const held2: [rt.RangeBound, rt.RangeBound] = [boundOf(at(3), b), { tag: "Unbounded" } as rt.RangeBound]; + bounds$tuple2_ops_Bound_u64_ops_Bound_u64(out, [boundOf(at(2), a), boundOf(at(3), b)] as [rs.RangeBound, rs.RangeBound]); + const held2: [rs.RangeBound, rs.RangeBound] = [boundOf(at(3), b), { tag: "Unbounded" } as rs.RangeBound]; bounds$tuple2_ops_Bound_u64_ops_Bound_u64(out, held2); putBound(out, held2[0]); - const _246: [{ end: rt.usize }, rt.RangeFrom] = [{ end: rt.usizeRem(at(2) as rt.usize, rt.usizeAdd(data.length, 1)) }, new rt.RangeFrom(rt.usizeRem(at(3) as rt.usize, rt.usizeAdd(data.length, 1)), rt.usizeStep)]; - const to: { end: rt.usize } = _246[0]; - const from: rt.RangeFrom = _246[1]; - putU64(out, rt.usizeAdd(to.end, from.start) as rt.u64); + const _246: [{ end: rs.usize }, rs.RangeFrom] = [{ end: rs.usizeRem(at(2) as rs.usize, rs.usizeAdd(data.length, 1)) }, new rs.RangeFrom(rs.usizeRem(at(3) as rs.usize, rs.usizeAdd(data.length, 1)), rs.usizeStep)]; + const to: { end: rs.usize } = _246[0]; + const from: rs.RangeFrom = _246[1]; + putU64(out, rs.usizeAdd(to.end, from.start) as rs.u64); putU64(out, b); - rt.byteVecPush(out, rt.byteSliceRange(data, 0, to.end).length & 0xff); - rt.byteVecPush(out, rt.byteSliceRange(data, from.start).length & 0xff); + rs.byteVecPush(out, rs.byteSliceRange(data, 0, to.end).length & 0xff); + rs.byteVecPush(out, rs.byteSliceRange(data, from.start).length & 0xff); } else if (_21 === 1) { - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))); + const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const iter: rs.Iter<[rs.usize, rs.u8]> = rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))); while (true) { - const _291: [rt.usize, rt.u8] | rt.Done = iter.next(); - if (_291 === rt.DONE) { + const _291: [rs.usize, rs.u8] | rs.Done = iter.next(); + if (_291 === rs.DONE) { break; } - rt.btreeInsert(map, _291[1] as rt.u64, _291[0] as rt.u64); + rs.btreeInsert(map, _291[1] as rs.u64, _291[0] as rs.u64); } - const _302: [rt.u64, rt.u64] = [at(0) as rt.u64, at(1) as rt.u64]; - const a2: rt.u64 = _302[0]; - const b2: rt.u64 = _302[1]; - const iter2: rt.Iter<[rt.u64, rt.u64]> = rt.btreeRange(map, { end: a2, inclusive: true }); + const _302: [rs.u64, rs.u64] = [at(0) as rs.u64, at(1) as rs.u64]; + const a2: rs.u64 = _302[0]; + const b2: rs.u64 = _302[1]; + const iter2: rs.Iter<[rs.u64, rs.u64]> = rs.btreeRange(map, { end: a2, inclusive: true }); while (true) { - const _316: [rt.u64, rt.u64] | rt.Done = iter2.next(); - if (_316 === rt.DONE) { + const _316: [rs.u64, rs.u64] | rs.Done = iter2.next(); + if (_316 === rs.DONE) { break; } putU64(out, _316[0]); putU64(out, _316[1]); } - rt.byteVecPush(out, 254); - const _326: [rt.u64, rt.u64] | undefined = rt.iterToOption(rt.btreeRange(map, { end: b2, inclusive: true }).nextBack()); + rs.byteVecPush(out, 254); + const _326: [rs.u64, rs.u64] | undefined = rs.iterToOption(rs.btreeRange(map, { end: b2, inclusive: true }).nextBack()); if (_326 !== undefined) { putU64(out, _326[0]); } - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(map, { end: a2 })) & 0xff); - const top3: rt.RangeInclusive = new rt.RangeInclusive(rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Rem(a2, 2)), { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step); - while (rt.iterToOption(top3.next()) !== undefined) { + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(map, { end: a2 })) & 0xff); + const top3: rs.RangeInclusive = new rs.RangeInclusive(rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Rem(a2, 2)), { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step); + while (rs.iterToOption(top3.next()) !== undefined) { } - const bottom: rt.RangeInclusive = new rt.RangeInclusive(0, rt.u64Rem(b2, 2), rt.u64Step); - while (rt.iterToOption(bottom.nextBack()) !== undefined) { + const bottom: rs.RangeInclusive = new rs.RangeInclusive(0, rs.u64Rem(b2, 2), rs.u64Step); + while (rs.iterToOption(bottom.nextBack()) !== undefined) { } - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(map, top3)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.btreeRange(map, bottom)) & 0xff); - const above: rt.BTreeMap = rt.btreeSplitOff(map, b2); - const iter3: rt.Iter<[rt.u64, rt.u64]> = rt.iterChain(rt.btreeIter(map), rt.btreeIter(above)); + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(map, top3)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.btreeRange(map, bottom)) & 0xff); + const above: rs.BTreeMap = rs.btreeSplitOff(map, b2); + const iter3: rs.Iter<[rs.u64, rs.u64]> = rs.iterChain(rs.btreeIter(map), rs.btreeIter(above)); while (true) { - const _379: [rt.u64, rt.u64] | rt.Done = iter3.next(); - if (_379 === rt.DONE) { + const _379: [rs.u64, rs.u64] | rs.Done = iter3.next(); + if (_379 === rs.DONE) { break; } putU64(out, _379[0]); putU64(out, _379[1]); } - rt.byteVecPush(out, rt.btreeLen(map) & 0xff); - rt.byteVecPush(out, rt.btreeLen(above) & 0xff); - const _397: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _397, true, undefined, undefined, 1, true); - const _402: rt.u8 = at(2); - const high: rt.BTreeSet = rt.btreeSplitOff(set, _402); - rt.iterExtendBytes(out, rt.iterChain(rt.btreeKeys(set), rt.btreeKeys(high)), undefined, true); - rt.byteVecPush(out, rt.btreeLen(high) & 0xff); + rs.byteVecPush(out, rs.btreeLen(map) & 0xff); + rs.byteVecPush(out, rs.btreeLen(above) & 0xff); + const _397: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _397, true, undefined, undefined, 1, true); + const _402: rs.u8 = at(2); + const high: rs.BTreeSet = rs.btreeSplitOff(set, _402); + rs.iterExtendBytes(out, rs.iterChain(rs.btreeKeys(set), rs.btreeKeys(high)), undefined, true); + rs.byteVecPush(out, rs.btreeLen(high) & 0xff); } else if (_21 === 2) { - const _417: [rt.u8, rt.u8] = [at(0), at(1)]; - const x2: rt.u8 = _417[0]; - const y: rt.u8 = _417[1]; - rt.byteVecPush(out, rt.cmpReverse(rt.cmp)(x2, y) & 0xff); - rt.byteVecPush(out, rt.cmpReverse(rt.cmp)(x2, y) === -1 ? 1 : 0); - rt.byteVecPush(out, rt.cmpReverse(rt.cmpOption(rt.cmp))(x2, undefined) === 1 ? 1 : 0); - rt.byteVecPush(out, rt.ordMax(x2, y, rt.cmpLt(rt.cmpReverse(rt.cmp)))); - const order = rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])([x2, y] as [rt.u8, rt.u8], [y, x2] as [rt.u8, rt.u8]); - rt.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); - const _461: rt.Iter<[rt.u8, rt.usize]> = rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_2: [rt.usize, rt.u8]): [rt.u8, rt.usize] => { - return [_2[1], _2[0]] as [rt.u8, rt.usize]; + const _417: [rs.u8, rs.u8] = [at(0), at(1)]; + const x2: rs.u8 = _417[0]; + const y: rs.u8 = _417[1]; + rs.byteVecPush(out, rs.cmpReverse(rs.cmp)(x2, y) & 0xff); + rs.byteVecPush(out, rs.cmpReverse(rs.cmp)(x2, y) === -1 ? 1 : 0); + rs.byteVecPush(out, rs.cmpReverse(rs.cmpOption(rs.cmp))(x2, undefined) === 1 ? 1 : 0); + rs.byteVecPush(out, rs.ordMax(x2, y, rs.cmpLt(rs.cmpReverse(rs.cmp)))); + const order = rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])([x2, y] as [rs.u8, rs.u8], [y, x2] as [rs.u8, rs.u8]); + rs.byteVecPush(out, order !== undefined && order <= 0 ? 1 : 0); + const _461: rs.Iter<[rs.u8, rs.usize]> = rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_2: [rs.usize, rs.u8]): [rs.u8, rs.usize] => { + return [_2[1], _2[0]] as [rs.u8, rs.usize]; }); - const iter4: rt.Iter<[rt.u8, rt.usize]> = rt.btreeIter(rt.btreeExtend(rt.btreeNew(rt.cmpReverse(rt.cmp)) as rt.BTreeMap, _461, true, undefined, undefined, undefined, 8, true)); + const iter4: rs.Iter<[rs.u8, rs.usize]> = rs.btreeIter(rs.btreeExtend(rs.btreeNew(rs.cmpReverse(rs.cmp)) as rs.BTreeMap, _461, true, undefined, undefined, undefined, 8, true)); while (true) { - const _467: [rt.u8, rt.usize] | rt.Done = iter4.next(); - if (_467 === rt.DONE) { + const _467: [rs.u8, rs.usize] | rs.Done = iter4.next(); + if (_467 === rs.DONE) { break; } - rt.byteVecPush(out, _467[0]); - rt.byteVecPush(out, _467[1] & 0xff); + rs.byteVecPush(out, _467[0]); + rs.byteVecPush(out, _467[1] & 0xff); } - const ranked: rt.Vec<[rt.u8, rt.usize]> = rt.iterToVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_23: [rt.usize, rt.u8]): [rt.u8, rt.usize] => { - return [_23[1], _23[0]] as [rt.u8, rt.usize]; + const ranked: rs.Vec<[rs.u8, rs.usize]> = rs.iterToVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_23: [rs.usize, rs.u8]): [rs.u8, rs.usize] => { + return [_23[1], _23[0]] as [rs.u8, rs.usize]; }), undefined, 8, true); - rt.sliceSort(ranked.items, rt.keyLt((_25: [rt.u8, rt.usize]): [rt.u8, rt.usize] => { - return [rt.u8Rem(_25[0], 4), _25[1]] as [rt.u8, rt.usize]; - }, rt.cmpLt(rt.cmpTuple<[rt.u8, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp]))), 8, true); + rs.sliceSort(ranked.items, rs.keyLt((_25: [rs.u8, rs.usize]): [rs.u8, rs.usize] => { + return [rs.u8Rem(_25[0], 4), _25[1]] as [rs.u8, rs.usize]; + }, rs.cmpLt(rs.cmpTuple<[rs.u8, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp]))), 8, true); for (const _487 of ranked.items) { - const d: rt.u8 = _487[0]; - const i2: rt.usize = _487[1]; - rt.byteVecPush(out, d); - rt.byteVecPush(out, i2 & 0xff); + const d: rs.u8 = _487[0]; + const i2: rs.usize = _487[1]; + rs.byteVecPush(out, d); + rs.byteVecPush(out, i2 & 0xff); } put(out, "held"); } else if (_21 === 3) { - const n: rt.u64 | undefined = rt.nonZero(a); + const n: rs.u64 | undefined = rs.nonZero(a); if (n === undefined) { - rt.byteVecPush(out, 0); + rs.byteVecPush(out, 0); } else { - const n2: rt.u64 = n; + const n2: rs.u64 = n; putU64(out, n2); putU64(out, n2); - const _519: rt.u64 = option_unwrapOr$1tvry1i(rt.nonZero(b), n2); - const _516: boolean = rt.u64Eq(n2, _519); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(n2, f), (f: rt.Formatter) => rt.u64Debug(n2, f), (f: rt.Formatter) => rt.fmtBool(_516, f)]; - put(out, rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])); - rt.byteVecPush(out, rt.u64Gt(n2, { _0: 1 }._0) ? 1 : 0); - rt.byteVecPush(out, rt.cmp(n2, { _0: 1000 }._0) & 0xff); + const _519: rs.u64 = option_unwrapOr$15hbiwd(rs.nonZero(b), n2); + const _516: boolean = rs.u64Eq(n2, _519); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(n2, f), (f: rs.Formatter) => rs.u64Debug(n2, f), (f: rs.Formatter) => rs.fmtBool(_516, f)]; + put(out, rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2]])); + rs.byteVecPush(out, rs.u64Gt(n2, { _0: 1 }._0) ? 1 : 0); + rs.byteVecPush(out, rs.cmp(n2, { _0: 1000 }._0) & 0xff); } - rt.byteVecPush(out, rt.nonZero(rt.u64And(a, 1)) !== undefined ? 1 : 0); + rs.byteVecPush(out, rs.nonZero(rs.u64And(a, 1)) !== undefined ? 1 : 0); } else { - const _546: rt.u64 | undefined = rt.nonZero(a); + const _546: rs.u64 | undefined = rs.nonZero(a); b1: { if (_546 !== undefined) { - if (rt.u8Rem(at(2), 2) === 0) { + if (rs.u8Rem(at(2), 2) === 0) { scale = { _0: _546 }; break b1; } } - const _557: rt.usize = rt.usizeRem(at(3) as rt.usize, 3); + const _557: rs.usize = rs.usizeRem(at(3) as rs.usize, 3); if (!(_557 < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + _557); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + _557); } - scale = [{ _0: 1 }, { _0: 1000 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }][_557]; + scale = [{ _0: 1 }, { _0: 1000 }, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64 }][_557]; } - if (!rt.u64Eq(1, scale._0)) { - if (!rt.u64Eq(1000, scale._0)) { - if (!rt.u64Eq({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, scale._0)) { + if (!rs.u64Eq(1, scale._0)) { + if (!rs.u64Eq(1000, scale._0)) { + if (!rs.u64Eq({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, scale._0)) { name = "other"; } else { name = "wide"; @@ -507,8 +507,8 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void name = "one"; } put(out, name); - rt.byteVecPush(out, Scale.eq$cmp_PartialEq(scale, { _0: 1000 }) ? 1 : 0); - rt.byteVecPush(out, Scale.partialCmp$cmp_PartialOrd(scale, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rt.u64 }) === -1 ? 1 : 0); + rs.byteVecPush(out, Scale.eq$cmp_PartialEq(scale, { _0: 1000 }) ? 1 : 0); + rs.byteVecPush(out, Scale.partialCmp$cmp_PartialOrd(scale, { _0: { hi: 0xffffffff, lo: 0xffffffff } as rs.u64 }) === -1 ? 1 : 0); putU64(out, scale._0); } } @@ -518,51 +518,51 @@ export function wrappers(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void * that logs as it is cloned and drops, and a `Vec`, which JS shares and whose * `clone_from` keeps its buffer. */ -export function reverses(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const at: (a0: rt.usize) => rt.u8 = (i: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, i), i & 0xff); +export function reverses(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const at: (a0: rs.usize) => rs.u8 = (i: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, i), i & 0xff); }; - const _5: rt.u8 = rt.u8Rem(kind, 3); + const _5: rs.u8 = rs.u8Rem(kind, 3); if (_5 === 0) { - const a: rt.u8 = at(0); - let b: rt.u8 = a; - b = rt.u8WrappingAdd(b, 1); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a, b)), undefined, true); + const a: rs.u8 = at(0); + let b: rs.u8 = a; + b = rs.u8WrappingAdd(b, 1); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a, b)), undefined, true); b = a; - rt.byteVecPush(out, b); + rs.byteVecPush(out, b); } else if (_5 === 1) { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const a2: Logged.Logged = new Logged.Logged(at(0) & 127, log); let b2: Logged.Logged = Logged.clone$Clone(a2); - const _38: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_38.value, 254); - rt.refMutRelease(_38); + const _38: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_38.value, 254); + rs.refMutRelease(_38); const _43: Logged.Logged = new Logged.Logged(at(1) & 127, log); const old = b2; b2 = Logged.clone$Clone(_43); old[Symbol.dispose](); _43[Symbol.dispose](); - const _53: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_53.value, 254); - rt.refMutRelease(_53); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a2.id, b2.id)), undefined, true); + const _53: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_53.value, 254); + rs.refMutRelease(_53); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a2.id, b2.id)), undefined, true); b2[Symbol.dispose](); a2[Symbol.dispose](); - rt.iterExtendBytes(out, rt.byteVecIntoIter(log.value), undefined, true); + rs.iterExtendBytes(out, rs.byteVecIntoIter(log.value), undefined, true); } else { - const a3: rt.ByteVec = rt.iterToByteVec(new rt.Range(0, rt.u8Rem(at(0), 6)), undefined, true); - const b3: rt.ByteVec = ((a0: rt.ByteVec): rt.ByteVec => { - return rt.byteVecFrom(rt.byteVecView(a0)); + const a3: rs.ByteVec = rs.iterToByteVec(new rs.Range(0, rs.u8Rem(at(0), 6)), undefined, true); + const b3: rs.ByteVec = ((a0: rs.ByteVec): rs.ByteVec => { + return rs.byteVecFrom(rs.byteVecView(a0)); })(a3); - rt.byteVecPush(b3, 85); - rt.iterExtendBytes(out, rt.iterChain(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(a3))), rt.iterSlice(rt.byteVecView(b3))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(a3.data.length & 0xff, b3.data.length & 0xff)), undefined, true); - const kept: rt.ByteVec = rt.byteVecWithCapacity(rt.u8Rem(at(1), 16) as rt.usize); - const _98: rt.u8 = at(2); - rt.byteVecPush(kept, _98); - rt.byteVecCloneFrom(kept, a3); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(kept))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(Uint8Array.of(kept.length & 0xff, kept.data.length & 0xff)), undefined, true); + rs.byteVecPush(b3, 85); + rs.iterExtendBytes(out, rs.iterChain(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(a3))), rs.iterSlice(rs.byteVecView(b3))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(a3.data.length & 0xff, b3.data.length & 0xff)), undefined, true); + const kept: rs.ByteVec = rs.byteVecWithCapacity(rs.u8Rem(at(1), 16) as rs.usize); + const _98: rs.u8 = at(2); + rs.byteVecPush(kept, _98); + rs.byteVecCloneFrom(kept, a3); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(kept))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(Uint8Array.of(kept.length & 0xff, kept.data.length & 0xff)), undefined, true); } } diff --git a/ts/fixtures/lang/wraps/expected/core/option.ts b/ts/fixtures/lang/wraps/expected/core/option.ts index 45fcd396d..0856a8d27 100644 --- a/ts/fixtures/lang/wraps/expected/core/option.ts +++ b/ts/fixtures/lang/wraps/expected/core/option.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function isSomeAnd$08u1px1(self: rt.Ordering | undefined, f: (a0: rt.Ordering) => boolean): boolean { +export function isSomeAnd$0dtzjhd(self: rs.Ordering | undefined, f: (a0: rs.Ordering) => boolean): boolean { if (self === undefined) { return false; } return f(self); } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } diff --git a/ts/fixtures/lang/wraps/expected/harness.ts b/ts/fixtures/lang/wraps/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/wraps/expected/harness.ts +++ b/ts/fixtures/lang/wraps/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/wraps/expected/lib.ts b/ts/fixtures/lang/wraps/expected/lib.ts index 680f6bd2f..d46d54859 100644 --- a/ts/fixtures/lang/wraps/expected/lib.ts +++ b/ts/fixtures/lang/wraps/expected/lib.ts @@ -1,54 +1,54 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { u8s, u16s, u32s, u64s, u128s, usizes, i8s, i16s, i32s, i64s, i128s, isizes } from "./wraps.ts"; import * as Tick from "./wraps.Tick.ts"; -export function copy$wraps_Tick_i128(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_i128(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_i16(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_i16(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_i32(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_i32(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_i64(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_i64(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_i8(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_i8(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_isize(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_isize(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_u128(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_u128(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_u16(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_u16(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_u32(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_u32(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_u64(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_u64(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_u8(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_u8(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } -export function copy$wraps_Tick_usize(v: Tick.Tick): Tick.Tick { +export function copy$wraps_Tick_usize(v: Tick.Tick): Tick.Tick { return new Tick.Tick(v._0); } @@ -56,8 +56,8 @@ export function copy$wraps_Tick_usize(v: Tick.Tick): Tick.Tick undefined]> { - return rt.vecFrom([["wraps::u8s", u8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u16s", u16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u32s", u32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u64s", u64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::u128s", u128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::usizes", usizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i8s", i8s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i16s", i16s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i32s", i32s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i64s", i64s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::i128s", i128s as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["wraps::isizes", isizes as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["wraps::u8s", u8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::u16s", u16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::u32s", u32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::u64s", u64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::u128s", u128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::usizes", usizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::i8s", i8s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::i16s", i16s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::i32s", i32s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::i64s", i64s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::i128s", i128s as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["wraps::isizes", isizes as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/wraps/expected/wraps.Tick.ts b/ts/fixtures/lang/wraps/expected/wraps.Tick.ts index c9ea77606..f30a16a87 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.Tick.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.Tick.ts @@ -1,269 +1,269 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug_i128(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i128(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i128Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i128Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i16(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i16(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i32(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i32(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i32Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i32Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i64(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i64(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i64Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i64Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_i8(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_i8(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.i8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.i8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_isize(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_isize(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.isizeDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.isizeDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u128(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u128(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u128Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u128Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u16(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u16(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u16Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u16Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u32(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u32(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u32Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u32Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u64(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u64(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u64Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u64Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_u8(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function fmt$fmt_Debug_usize(self: Tick, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_usize(self: Tick, f: rs.Formatter): rs.Result { const _3: string = "Tick"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.usizeDebug(self._0, f); - return rt.debugTupleFinish(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.usizeDebug(self._0, f); + return rs.debugTupleFinish(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4)); } -export function default$Default_i128(): Tick { +export function default$Default_i128(): Tick { return new Tick(0); } -export function default$Default_i16(): Tick { +export function default$Default_i16(): Tick { return new Tick(0); } -export function default$Default_i32(): Tick { +export function default$Default_i32(): Tick { return new Tick(0); } -export function default$Default_i64(): Tick { +export function default$Default_i64(): Tick { return new Tick(0); } -export function default$Default_i8(): Tick { +export function default$Default_i8(): Tick { return new Tick(0); } -export function default$Default_isize(): Tick { +export function default$Default_isize(): Tick { return new Tick(0); } -export function default$Default_u128(): Tick { +export function default$Default_u128(): Tick { return new Tick(0); } -export function default$Default_u16(): Tick { +export function default$Default_u16(): Tick { return new Tick(0); } -export function default$Default_u32(): Tick { +export function default$Default_u32(): Tick { return new Tick(0); } -export function default$Default_u64(): Tick { +export function default$Default_u64(): Tick { return new Tick(0); } -export function default$Default_u8(): Tick { +export function default$Default_u8(): Tick { return new Tick(0); } -export function default$Default_usize(): Tick { +export function default$Default_usize(): Tick { return new Tick(0); } -export function eq$cmp_PartialEq_i128(self: Tick, other: Tick): boolean { - return rt.i128Eq(self._0, other._0); +export function eq$cmp_PartialEq_i128(self: Tick, other: Tick): boolean { + return rs.i128Eq(self._0, other._0); } -export function eq$cmp_PartialEq_i16(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_i16(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_i32(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_i32(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_i64(self: Tick, other: Tick): boolean { - return rt.i64Eq(self._0, other._0); +export function eq$cmp_PartialEq_i64(self: Tick, other: Tick): boolean { + return rs.i64Eq(self._0, other._0); } -export function eq$cmp_PartialEq_i8(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_i8(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_isize(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_isize(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u128(self: Tick, other: Tick): boolean { - return rt.u128Eq(self._0, other._0); +export function eq$cmp_PartialEq_u128(self: Tick, other: Tick): boolean { + return rs.u128Eq(self._0, other._0); } -export function eq$cmp_PartialEq_u16(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_u16(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u32(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_u32(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_u64(self: Tick, other: Tick): boolean { - return rt.u64Eq(self._0, other._0); +export function eq$cmp_PartialEq_u64(self: Tick, other: Tick): boolean { + return rs.u64Eq(self._0, other._0); } -export function eq$cmp_PartialEq_u8(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_u8(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function eq$cmp_PartialEq_usize(self: Tick, other: Tick): boolean { +export function eq$cmp_PartialEq_usize(self: Tick, other: Tick): boolean { return self._0 === other._0; } -export function hash$Hash_i128_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashI128(self._0, state); +export function hash$Hash_i128_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashI128(self._0, state); } -export function hash$Hash_i16_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashI16(self._0, state); +export function hash$Hash_i16_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashI16(self._0, state); } -export function hash$Hash_i32_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashI32(self._0, state); +export function hash$Hash_i32_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashI32(self._0, state); } -export function hash$Hash_i64_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashI64(self._0, state); +export function hash$Hash_i64_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashI64(self._0, state); } -export function hash$Hash_i8_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashI8(self._0, state); +export function hash$Hash_i8_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashI8(self._0, state); } -export function hash$Hash_isize_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashIsize(self._0, state); +export function hash$Hash_isize_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashIsize(self._0, state); } -export function hash$Hash_u128_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hash128(self._0, state); +export function hash$Hash_u128_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hash128(self._0, state); } -export function hash$Hash_u16_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hash16(self._0, state); +export function hash$Hash_u16_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hash16(self._0, state); } -export function hash$Hash_u32_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hash32(self._0, state); +export function hash$Hash_u32_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hash32(self._0, state); } -export function hash$Hash_u64_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hash64(self._0, state); +export function hash$Hash_u64_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hash64(self._0, state); } -export function hash$Hash_u8_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hash8(self._0, state); +export function hash$Hash_u8_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hash8(self._0, state); } -export function hash$Hash_usize_hash_DefaultHasher(self: Tick, state: rt.Hasher): void { - rt.hashUsize(self._0, state); +export function hash$Hash_usize_hash_DefaultHasher(self: Tick, state: rs.Hasher): void { + rs.hashUsize(self._0, state); } -export function cmp$cmp_Ord_i128(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i128(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i16(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i16(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i32(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i32(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i64(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i64(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_i8(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_i8(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_isize(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_isize(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u128(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u128(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u16(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u16(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u32(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u32(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u64(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u64(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_u8(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_u8(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } -export function cmp$cmp_Ord_usize(self: Tick, other: Tick): rt.Ordering { - return rt.cmp(self._0, other._0); +export function cmp$cmp_Ord_usize(self: Tick, other: Tick): rs.Ordering { + return rs.cmp(self._0, other._0); } /** A `Wrapping` in a field, with each derived impl reading it. */ diff --git a/ts/fixtures/lang/wraps/expected/wraps.ts b/ts/fixtures/lang/wraps/expected/wraps.ts index bbd71bf80..7ecfc27b2 100644 --- a/ts/fixtures/lang/wraps/expected/wraps.ts +++ b/ts/fixtures/lang/wraps/expected/wraps.ts @@ -1,270 +1,270 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$wraps_Tick_i128, copy$wraps_Tick_i16, copy$wraps_Tick_i32, copy$wraps_Tick_i64, copy$wraps_Tick_i8, copy$wraps_Tick_isize, copy$wraps_Tick_u128, copy$wraps_Tick_u16, copy$wraps_Tick_u32, copy$wraps_Tick_u64, copy$wraps_Tick_u8, copy$wraps_Tick_usize } from "./lib.ts"; -import { isSomeAnd$08u1px1, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import { isSomeAnd$0dtzjhd, unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; import * as Tick from "./wraps.Tick.ts"; -export function hashed$i128(v: rt.i128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI128(v, h); - return rt.hashFinish(h); +export function hashed$i128(v: rs.i128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI128(v, h); + return rs.hashFinish(h); } -export function hashed$i16(v: rt.i16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI16(v, h); - return rt.hashFinish(h); +export function hashed$i16(v: rs.i16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI16(v, h); + return rs.hashFinish(h); } -export function hashed$i32(v: rt.i32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI32(v, h); - return rt.hashFinish(h); +export function hashed$i32(v: rs.i32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI32(v, h); + return rs.hashFinish(h); } -export function hashed$i64(v: rt.i64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI64(v, h); - return rt.hashFinish(h); +export function hashed$i64(v: rs.i64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI64(v, h); + return rs.hashFinish(h); } -export function hashed$i8(v: rt.i8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(v, h); - return rt.hashFinish(h); +export function hashed$i8(v: rs.i8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(v, h); + return rs.hashFinish(h); } -export function hashed$isize(v: rt.isize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashIsize(v, h); - return rt.hashFinish(h); +export function hashed$isize(v: rs.isize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashIsize(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_i128(v: rt.i128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI128(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_i128(v: rs.i128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI128(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_i16(v: rt.i16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI16(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_i16(v: rs.i16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI16(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_i32(v: rt.i32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI32(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_i32(v: rs.i32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI32(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_i64(v: rt.i64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI64(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_i64(v: rs.i64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI64(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_i8(v: rt.i8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashI8(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_i8(v: rs.i8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashI8(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_isize(v: rt.isize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashIsize(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_isize(v: rs.isize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashIsize(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_u128(v: rt.u128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash128(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_u128(v: rs.u128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash128(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_u16(v: rt.u16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash16(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_u16(v: rs.u16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash16(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_u32(v: rt.u32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash32(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_u32(v: rs.u32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash32(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_u64(v: rt.u64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash64(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_u64(v: rs.u64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash64(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_u8(v: rt.u8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash8(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_u8(v: rs.u8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash8(v, h); + return rs.hashFinish(h); } -export function hashed$num_Wrapping_usize(v: rt.usize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashUsize(v, h); - return rt.hashFinish(h); +export function hashed$num_Wrapping_usize(v: rs.usize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashUsize(v, h); + return rs.hashFinish(h); } -export function hashed$u128(v: rt.u128): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash128(v, h); - return rt.hashFinish(h); +export function hashed$u128(v: rs.u128): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash128(v, h); + return rs.hashFinish(h); } -export function hashed$u16(v: rt.u16): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash16(v, h); - return rt.hashFinish(h); +export function hashed$u16(v: rs.u16): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash16(v, h); + return rs.hashFinish(h); } -export function hashed$u32(v: rt.u32): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash32(v, h); - return rt.hashFinish(h); +export function hashed$u32(v: rs.u32): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash32(v, h); + return rs.hashFinish(h); } -export function hashed$u64(v: rt.u64): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash64(v, h); - return rt.hashFinish(h); +export function hashed$u64(v: rs.u64): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash64(v, h); + return rs.hashFinish(h); } -export function hashed$u8(v: rt.u8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash8(v, h); - return rt.hashFinish(h); +export function hashed$u8(v: rs.u8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash8(v, h); + return rs.hashFinish(h); } -export function hashed$usize(v: rt.usize): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashUsize(v, h); - return rt.hashFinish(h); +export function hashed$usize(v: rs.usize): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashUsize(v, h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_i128(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_i128(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_i128_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_i16(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_i16(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_i16_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_i32(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_i32(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_i32_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_i64(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_i64(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_i64_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_i8(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_i8(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_i8_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_isize(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_isize(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_isize_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_u128(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_u128(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_u128_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_u16(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_u16(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_u16_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_u32(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_u32(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_u32_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_u64(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_u64(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_u64_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_u8(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_u8(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_u8_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } -export function hashed$wraps_Tick_usize(v: Tick.Tick): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hashed$wraps_Tick_usize(v: Tick.Tick): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tick.hash$Hash_usize_hash_DefaultHasher(v, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } /** * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.u8) => undefined = (out2: rt.ByteVec, v: rt.u8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u8ToBeBytes(v))); +export function u8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.u8) => undefined = (out2: rs.ByteVec, v: rs.u8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u8ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u8 = (at: rt.usize): rt.u8 => { + const take: (a0: rs.usize) => rs.u8 = (at: rs.usize): rs.u8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u8FromBeBytes(buf); + return rs.u8FromBeBytes(buf); }; - const _8: [rt.u8, rt.u8, rt.u8] = [take(0), take(1), take(2 * 1)]; - const a: rt.u8 = _8[0]; - const b: rt.u8 = _8[1]; - const c: rt.u8 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 1, i2)), 0); + const _8: [rs.u8, rs.u8, rs.u8] = [take(0), take(1), take(2 * 1)]; + const a: rs.u8 = _8[0]; + const b: rs.u8 = _8[1]; + const c: rs.u8 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 1, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.u8WrappingAdd(a, b); + const part45 = rs.u8WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.u8WrappingSub(a, b); + const part44 = rs.u8WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.u8WrappingMul(a, b); + const part43 = rs.u8WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.u8Div(a, b)); + _30(out, rs.u8Div(a, b)); } else if (_31 === 4) { - _30(out, rt.u8Rem(a, b)); + _30(out, rs.u8Rem(a, b)); } else if (_31 === 5) { - const part40 = rt.u8WrappingSub(0, a); + const part40 = rs.u8WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a & 0xff); @@ -275,131 +275,131 @@ export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.u8Shl(a, n & 7)); + _30(out, rs.u8Shl(a, n & 7)); } else if (_31 === 11) { - _30(out, rt.u8Shr(a, n & 7)); + _30(out, rs.u8Shr(a, n & 7)); } else if (_31 === 12) { - let x: rt.u8 = a; - x = rt.u8WrappingAdd(x, b); + let x: rs.u8 = a; + x = rs.u8WrappingAdd(x, b); _30(out, x); - x = rt.u8WrappingMul(x, c); + x = rs.u8WrappingMul(x, c); _30(out, x); - x = rt.u8WrappingSub(x, b); + x = rs.u8WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.u8 = a; - x2 = rt.u8Div(x2, b); + let x2: rs.u8 = a; + x2 = rs.u8Div(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.u8 = a; - x3 = rt.u8Rem(x3, b); + let x3: rs.u8 = a; + x3 = rs.u8Rem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.u8 = a; + let x4: rs.u8 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.u8 = a; - x5 = rt.u8Shl(x5, n & 7); + let x5: rs.u8 = a; + x5 = rs.u8Shl(x5, n & 7); _30(out, x5); - x5 = rt.u8Shr(x5, n & 7); + x5 = rs.u8Shr(x5, n & 7); _30(out, x5); _30(out, (a << 3) & 0xff); - _30(out, rt.u8Shr(a, rt.usizeAdd(8, 1) & 7)); + _30(out, rs.u8Shr(a, rs.usizeAdd(8, 1) & 7)); } else if (_31 === 17) { - const part15 = rt.u8WrappingAdd(a, b); + const part15 = rs.u8WrappingAdd(a, b); _30(out, part15); - const part16 = rt.u8WrappingSub(a, b); + const part16 = rs.u8WrappingSub(a, b); _30(out, part16); - const part17 = rt.u8WrappingMul(a, c); + const part17 = rs.u8WrappingMul(a, c); _30(out, part17); - const part18 = rt.u8WrappingSub(0, a); + const part18 = rs.u8WrappingSub(0, a); _30(out, part18); _30(out, ~b & 0xff); - _30(out, rt.u8Shl(a, n & 7)); - _30(out, rt.u8Shr(a, n & 7)); + _30(out, rs.u8Shl(a, n & 7)); + _30(out, rs.u8Shr(a, n & 7)); _30(out, a ^ c); - let x6: rt.u8 = a; - x6 = rt.u8WrappingAdd(x6, b); - x6 = rt.u8Shl(x6, n & 7); + let x6: rs.u8 = a; + x6 = rs.u8WrappingAdd(x6, b); + x6 = rs.u8Shl(x6, n & 7); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.u8 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.u8 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.u8 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.u8 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_u8(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_u8(a), hashed$u8(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 1, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_u8(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_u8(a), hashed$u8(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 1, true)); while (true) { - const _258: rt.u8 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.u8 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash8, rt.same)) as rt.HashSet, _267, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash8, rs.same)) as rs.HashSet, _267, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(a, f), (f: rt.Formatter) => rt.u8Debug(b, f), (f: rt.Formatter) => rt.u8LowerHex(a, f), (f: rt.Formatter) => rt.u8UpperHex(b, f), (f: rt.Formatter) => rt.u8Octal(c, f), (f: rt.Formatter) => rt.u8Binary(a, f), (f: rt.Formatter) => rt.u8Display(b, f), (f: rt.Formatter) => rt.u8LowerHex(c, f), (f: rt.Formatter) => rt.u8Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(a, f), (f: rs.Formatter) => rs.u8Debug(b, f), (f: rs.Formatter) => rs.u8LowerHex(a, f), (f: rs.Formatter) => rs.u8UpperHex(b, f), (f: rs.Formatter) => rs.u8Octal(c, f), (f: rs.Formatter) => rs.u8Binary(a, f), (f: rs.Formatter) => rs.u8Display(b, f), (f: rs.Formatter) => rs.u8LowerHex(c, f), (f: rs.Formatter) => rs.u8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.u8[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.u8WrappingAdd, 0); + const all: rs.u8[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.u8WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.u8WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.u8WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.u8WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.u8WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.u8WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.u8WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u8WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u8WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u8WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u8WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_u8(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_u8(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_u8(x7), hashed$num_Wrapping_u8(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_u8(x7); - z._0 = rt.u8WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_u8(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u8(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u8(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_u8(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u8(x7), hashed$num_Wrapping_u8(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_u8(x7); + z._0 = rs.u8WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -408,46 +408,46 @@ export function u8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.u16) => undefined = (out2: rt.ByteVec, v: rt.u16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u16ToBeBytes(v))); +export function u16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.u16) => undefined = (out2: rs.ByteVec, v: rs.u16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u16ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u16 = (at: rt.usize): rt.u16 => { - const buf: Uint8Array = rt.bytes(2); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u16 = (at: rs.usize): rs.u16 => { + const buf: Uint8Array = rs.bytes(2); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u16FromBeBytes(buf); + return rs.u16FromBeBytes(buf); }; - const _8: [rt.u16, rt.u16, rt.u16] = [take(0), take(2), take(2 * 2)]; - const a: rt.u16 = _8[0]; - const b: rt.u16 = _8[1]; - const c: rt.u16 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 2, i2)), 0); + const _8: [rs.u16, rs.u16, rs.u16] = [take(0), take(2), take(2 * 2)]; + const a: rs.u16 = _8[0]; + const b: rs.u16 = _8[1]; + const c: rs.u16 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 2, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.u16WrappingAdd(a, b); + const part45 = rs.u16WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.u16WrappingSub(a, b); + const part44 = rs.u16WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.u16WrappingMul(a, b); + const part43 = rs.u16WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.u16Div(a, b)); + _30(out, rs.u16Div(a, b)); } else if (_31 === 4) { - _30(out, rt.u16Rem(a, b)); + _30(out, rs.u16Rem(a, b)); } else if (_31 === 5) { - const part40 = rt.u16WrappingSub(0, a); + const part40 = rs.u16WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a & 0xffff); @@ -458,131 +458,131 @@ export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.u16Shl(a, n & 15)); + _30(out, rs.u16Shl(a, n & 15)); } else if (_31 === 11) { - _30(out, rt.u16Shr(a, n & 15)); + _30(out, rs.u16Shr(a, n & 15)); } else if (_31 === 12) { - let x: rt.u16 = a; - x = rt.u16WrappingAdd(x, b); + let x: rs.u16 = a; + x = rs.u16WrappingAdd(x, b); _30(out, x); - x = rt.u16WrappingMul(x, c); + x = rs.u16WrappingMul(x, c); _30(out, x); - x = rt.u16WrappingSub(x, b); + x = rs.u16WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.u16 = a; - x2 = rt.u16Div(x2, b); + let x2: rs.u16 = a; + x2 = rs.u16Div(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.u16 = a; - x3 = rt.u16Rem(x3, b); + let x3: rs.u16 = a; + x3 = rs.u16Rem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.u16 = a; + let x4: rs.u16 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.u16 = a; - x5 = rt.u16Shl(x5, n & 15); + let x5: rs.u16 = a; + x5 = rs.u16Shl(x5, n & 15); _30(out, x5); - x5 = rt.u16Shr(x5, n & 15); + x5 = rs.u16Shr(x5, n & 15); _30(out, x5); _30(out, (a << 3) & 0xffff); - _30(out, rt.u16Shr(a, rt.usizeAdd(16, 1) & 15)); + _30(out, rs.u16Shr(a, rs.usizeAdd(16, 1) & 15)); } else if (_31 === 17) { - const part15 = rt.u16WrappingAdd(a, b); + const part15 = rs.u16WrappingAdd(a, b); _30(out, part15); - const part16 = rt.u16WrappingSub(a, b); + const part16 = rs.u16WrappingSub(a, b); _30(out, part16); - const part17 = rt.u16WrappingMul(a, c); + const part17 = rs.u16WrappingMul(a, c); _30(out, part17); - const part18 = rt.u16WrappingSub(0, a); + const part18 = rs.u16WrappingSub(0, a); _30(out, part18); _30(out, ~b & 0xffff); - _30(out, rt.u16Shl(a, n & 15)); - _30(out, rt.u16Shr(a, n & 15)); + _30(out, rs.u16Shl(a, n & 15)); + _30(out, rs.u16Shr(a, n & 15)); _30(out, a ^ c); - let x6: rt.u16 = a; - x6 = rt.u16WrappingAdd(x6, b); - x6 = rt.u16Shl(x6, n & 15); + let x6: rs.u16 = a; + x6 = rs.u16WrappingAdd(x6, b); + x6 = rs.u16Shl(x6, n & 15); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.u16 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.u16 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.u16 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.u16 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_u16(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_u16(a), hashed$u16(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 2, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_u16(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_u16(a), hashed$u16(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 2, true)); while (true) { - const _258: rt.u16 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.u16 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash16, rt.same)) as rt.HashSet, _267, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash16, rs.same)) as rs.HashSet, _267, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(a, f), (f: rt.Formatter) => rt.u16Debug(b, f), (f: rt.Formatter) => rt.u16LowerHex(a, f), (f: rt.Formatter) => rt.u16UpperHex(b, f), (f: rt.Formatter) => rt.u16Octal(c, f), (f: rt.Formatter) => rt.u16Binary(a, f), (f: rt.Formatter) => rt.u16Display(b, f), (f: rt.Formatter) => rt.u16LowerHex(c, f), (f: rt.Formatter) => rt.u16Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(a, f), (f: rs.Formatter) => rs.u16Debug(b, f), (f: rs.Formatter) => rs.u16LowerHex(a, f), (f: rs.Formatter) => rs.u16UpperHex(b, f), (f: rs.Formatter) => rs.u16Octal(c, f), (f: rs.Formatter) => rs.u16Binary(a, f), (f: rs.Formatter) => rs.u16Display(b, f), (f: rs.Formatter) => rs.u16LowerHex(c, f), (f: rs.Formatter) => rs.u16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.u16[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.u16WrappingAdd, 0); + const all: rs.u16[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.u16WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.u16WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.u16WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.u16WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.u16WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.u16WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.u16WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u16WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u16WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u16WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u16WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_u16(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_u16(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_u16(x7), hashed$num_Wrapping_u16(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_u16(x7); - z._0 = rt.u16WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_u16(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u16(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u16(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_u16(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u16(x7), hashed$num_Wrapping_u16(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_u16(x7); + z._0 = rs.u16WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -591,46 +591,46 @@ export function u16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.u32) => undefined = (out2: rt.ByteVec, v: rt.u32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(v))); +export function u32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.u32) => undefined = (out2: rs.ByteVec, v: rs.u32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u32 = (at: rt.usize): rt.u32 => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u32 = (at: rs.usize): rs.u32 => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u32FromBeBytes(buf); + return rs.u32FromBeBytes(buf); }; - const _8: [rt.u32, rt.u32, rt.u32] = [take(0), take(4), take(2 * 4)]; - const a: rt.u32 = _8[0]; - const b: rt.u32 = _8[1]; - const c: rt.u32 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 4, i2)), 0); + const _8: [rs.u32, rs.u32, rs.u32] = [take(0), take(4), take(2 * 4)]; + const a: rs.u32 = _8[0]; + const b: rs.u32 = _8[1]; + const c: rs.u32 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.u32WrappingAdd(a, b); + const part45 = rs.u32WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.u32WrappingSub(a, b); + const part44 = rs.u32WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.u32WrappingMul(a, b); + const part43 = rs.u32WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.u32Div(a, b)); + _30(out, rs.u32Div(a, b)); } else if (_31 === 4) { - _30(out, rt.u32Rem(a, b)); + _30(out, rs.u32Rem(a, b)); } else if (_31 === 5) { - const part40 = rt.u32WrappingSub(0, a); + const part40 = rs.u32WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a >>> 0); @@ -641,131 +641,131 @@ export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, (a ^ b) >>> 0); } else if (_31 === 10) { - _30(out, rt.u32Shl(a, n & 31)); + _30(out, rs.u32Shl(a, n & 31)); } else if (_31 === 11) { - _30(out, rt.u32Shr(a, n & 31)); + _30(out, rs.u32Shr(a, n & 31)); } else if (_31 === 12) { - let x: rt.u32 = a; - x = rt.u32WrappingAdd(x, b); + let x: rs.u32 = a; + x = rs.u32WrappingAdd(x, b); _30(out, x); - x = rt.u32WrappingMul(x, c); + x = rs.u32WrappingMul(x, c); _30(out, x); - x = rt.u32WrappingSub(x, b); + x = rs.u32WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.u32 = a; - x2 = rt.u32Div(x2, b); + let x2: rs.u32 = a; + x2 = rs.u32Div(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.u32 = a; - x3 = rt.u32Rem(x3, b); + let x3: rs.u32 = a; + x3 = rs.u32Rem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.u32 = a; + let x4: rs.u32 = a; x4 = (x4 & b) >>> 0; x4 = (x4 | c) >>> 0; x4 = (x4 ^ b) >>> 0; _30(out, x4); } else if (_31 === 16) { - let x5: rt.u32 = a; - x5 = rt.u32Shl(x5, n & 31); + let x5: rs.u32 = a; + x5 = rs.u32Shl(x5, n & 31); _30(out, x5); - x5 = rt.u32Shr(x5, n & 31); + x5 = rs.u32Shr(x5, n & 31); _30(out, x5); _30(out, (a << 3) >>> 0); - _30(out, rt.u32Shr(a, rt.usizeAdd(32, 1) & 31)); + _30(out, rs.u32Shr(a, rs.usizeAdd(32, 1) & 31)); } else if (_31 === 17) { - const part15 = rt.u32WrappingAdd(a, b); + const part15 = rs.u32WrappingAdd(a, b); _30(out, part15); - const part16 = rt.u32WrappingSub(a, b); + const part16 = rs.u32WrappingSub(a, b); _30(out, part16); - const part17 = rt.u32WrappingMul(a, c); + const part17 = rs.u32WrappingMul(a, c); _30(out, part17); - const part18 = rt.u32WrappingSub(0, a); + const part18 = rs.u32WrappingSub(0, a); _30(out, part18); _30(out, ~b >>> 0); - _30(out, rt.u32Shl(a, n & 31)); - _30(out, rt.u32Shr(a, n & 31)); + _30(out, rs.u32Shl(a, n & 31)); + _30(out, rs.u32Shr(a, n & 31)); _30(out, (a ^ c) >>> 0); - let x6: rt.u32 = a; - x6 = rt.u32WrappingAdd(x6, b); - x6 = rt.u32Shl(x6, n & 31); + let x6: rs.u32 = a; + x6 = rs.u32WrappingAdd(x6, b); + x6 = rs.u32Shl(x6, n & 31); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.u32 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.u32 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.u32 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.u32 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_u32(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_u32(a), hashed$u32(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_u32(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_u32(a), hashed$u32(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 4, true)); while (true) { - const _258: rt.u32 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.u32 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash32, rt.same)) as rt.HashSet, _267, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash32, rs.same)) as rs.HashSet, _267, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(a, f), (f: rt.Formatter) => rt.u32Debug(b, f), (f: rt.Formatter) => rt.u32LowerHex(a, f), (f: rt.Formatter) => rt.u32UpperHex(b, f), (f: rt.Formatter) => rt.u32Octal(c, f), (f: rt.Formatter) => rt.u32Binary(a, f), (f: rt.Formatter) => rt.u32Display(b, f), (f: rt.Formatter) => rt.u32LowerHex(c, f), (f: rt.Formatter) => rt.u32Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(a, f), (f: rs.Formatter) => rs.u32Debug(b, f), (f: rs.Formatter) => rs.u32LowerHex(a, f), (f: rs.Formatter) => rs.u32UpperHex(b, f), (f: rs.Formatter) => rs.u32Octal(c, f), (f: rs.Formatter) => rs.u32Binary(a, f), (f: rs.Formatter) => rs.u32Display(b, f), (f: rs.Formatter) => rs.u32LowerHex(c, f), (f: rs.Formatter) => rs.u32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.u32[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.u32WrappingAdd, 0); + const all: rs.u32[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.u32WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.u32WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.u32WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.u32WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.u32WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.u32WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.u32WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u32WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u32WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u32WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u32WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_u32(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_u32(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_u32(x7), hashed$num_Wrapping_u32(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_u32(x7); - z._0 = rt.u32WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_u32(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u32(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u32(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_u32(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u32(x7), hashed$num_Wrapping_u32(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_u32(x7); + z._0 = rs.u32WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -774,181 +774,181 @@ export function u32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.u64) => undefined = (out2: rt.ByteVec, v: rt.u64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u64ToBeBytes(v))); +export function u64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.u64) => undefined = (out2: rs.ByteVec, v: rs.u64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u64ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u64 = (at: rt.usize): rt.u64 => { - const buf: Uint8Array = rt.bytes(8); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u64 = (at: rs.usize): rs.u64 => { + const buf: Uint8Array = rs.bytes(8); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u64FromBeBytes(buf); + return rs.u64FromBeBytes(buf); }; - const _8: [rt.u64, rt.u64, rt.u64] = [take(0), take(8), take(2 * 8)]; - const a: rt.u64 = _8[0]; - const b: rt.u64 = _8[1]; - const c: rt.u64 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 8, i2)), 0); + const _8: [rs.u64, rs.u64, rs.u64] = [take(0), take(8), take(2 * 8)]; + const a: rs.u64 = _8[0]; + const b: rs.u64 = _8[1]; + const c: rs.u64 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 8, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.u64WrappingAdd(a, b); + const part45 = rs.u64WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.u64WrappingSub(a, b); + const part44 = rs.u64WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.u64WrappingMul(a, b); + const part43 = rs.u64WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.u64Div(a, b)); + _30(out, rs.u64Div(a, b)); } else if (_31 === 4) { - _30(out, rt.u64Rem(a, b)); + _30(out, rs.u64Rem(a, b)); } else if (_31 === 5) { - const part40 = rt.u64WrappingSub(0, a); + const part40 = rs.u64WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { - _30(out, rt.u64Not(a)); + _30(out, rs.u64Not(a)); } else if (_31 === 7) { - _30(out, rt.u64And(a, b)); + _30(out, rs.u64And(a, b)); } else if (_31 === 8) { - _30(out, rt.u64Or(a, b)); + _30(out, rs.u64Or(a, b)); } else if (_31 === 9) { - _30(out, rt.u64Xor(a, b)); + _30(out, rs.u64Xor(a, b)); } else if (_31 === 10) { - _30(out, rt.u64Shl(a, n & 63)); + _30(out, rs.u64Shl(a, n & 63)); } else if (_31 === 11) { - _30(out, rt.u64Shr(a, n & 63)); + _30(out, rs.u64Shr(a, n & 63)); } else if (_31 === 12) { - let x: rt.u64 = a; - x = rt.u64WrappingAdd(x, b); + let x: rs.u64 = a; + x = rs.u64WrappingAdd(x, b); _30(out, x); - x = rt.u64WrappingMul(x, c); + x = rs.u64WrappingMul(x, c); _30(out, x); - x = rt.u64WrappingSub(x, b); + x = rs.u64WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.u64 = a; - x2 = rt.u64Div(x2, b); + let x2: rs.u64 = a; + x2 = rs.u64Div(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.u64 = a; - x3 = rt.u64Rem(x3, b); + let x3: rs.u64 = a; + x3 = rs.u64Rem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.u64 = a; - x4 = rt.u64And(x4, b); - x4 = rt.u64Or(x4, c); - x4 = rt.u64Xor(x4, b); + let x4: rs.u64 = a; + x4 = rs.u64And(x4, b); + x4 = rs.u64Or(x4, c); + x4 = rs.u64Xor(x4, b); _30(out, x4); } else if (_31 === 16) { - let x5: rt.u64 = a; - x5 = rt.u64Shl(x5, n & 63); + let x5: rs.u64 = a; + x5 = rs.u64Shl(x5, n & 63); _30(out, x5); - x5 = rt.u64Shr(x5, n & 63); + x5 = rs.u64Shr(x5, n & 63); _30(out, x5); - _30(out, rt.u64Shl(a, 3)); - _30(out, rt.u64Shr(a, rt.usizeAdd(64, 1) & 63)); + _30(out, rs.u64Shl(a, 3)); + _30(out, rs.u64Shr(a, rs.usizeAdd(64, 1) & 63)); } else if (_31 === 17) { - const part15 = rt.u64WrappingAdd(a, b); + const part15 = rs.u64WrappingAdd(a, b); _30(out, part15); - const part16 = rt.u64WrappingSub(a, b); + const part16 = rs.u64WrappingSub(a, b); _30(out, part16); - const part17 = rt.u64WrappingMul(a, c); + const part17 = rs.u64WrappingMul(a, c); _30(out, part17); - const part18 = rt.u64WrappingSub(0, a); + const part18 = rs.u64WrappingSub(0, a); _30(out, part18); - _30(out, rt.u64Not(b)); - _30(out, rt.u64Shl(a, n & 63)); - _30(out, rt.u64Shr(a, n & 63)); - _30(out, rt.u64Xor(a, c)); - let x6: rt.u64 = a; - x6 = rt.u64WrappingAdd(x6, b); - x6 = rt.u64Shl(x6, n & 63); + _30(out, rs.u64Not(b)); + _30(out, rs.u64Shl(a, n & 63)); + _30(out, rs.u64Shr(a, n & 63)); + _30(out, rs.u64Xor(a, c)); + let x6: rs.u64 = a; + x6 = rs.u64WrappingAdd(x6, b); + x6 = rs.u64Shl(x6, n & 63); _30(out, x6); } else if (_31 === 18) { - const _191: boolean = rt.u64Eq(a, b); - const _194: boolean = !rt.u64Eq(a, b); - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _191: boolean = rs.u64Eq(a, b); + const _194: boolean = !rs.u64Eq(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.u64 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.u64 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.u64 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.u64 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_u64(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_u64(a), hashed$u64(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 8, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_u64(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_u64(a), hashed$u64(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 8, true)); while (true) { - const _258: rt.u64 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.u64 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash64, rt.u64Eq)) as rt.HashSet, _267, undefined, undefined, 117440512); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash64, rs.u64Eq)) as rs.HashSet, _267, undefined, undefined, 117440512); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(a, f), (f: rt.Formatter) => rt.u64Debug(b, f), (f: rt.Formatter) => rt.u64LowerHex(a, f), (f: rt.Formatter) => rt.u64UpperHex(b, f), (f: rt.Formatter) => rt.u64Octal(c, f), (f: rt.Formatter) => rt.u64Binary(a, f), (f: rt.Formatter) => rt.u64Display(b, f), (f: rt.Formatter) => rt.u64LowerHex(c, f), (f: rt.Formatter) => rt.u64Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(a, f), (f: rs.Formatter) => rs.u64Debug(b, f), (f: rs.Formatter) => rs.u64LowerHex(a, f), (f: rs.Formatter) => rs.u64UpperHex(b, f), (f: rs.Formatter) => rs.u64Octal(c, f), (f: rs.Formatter) => rs.u64Binary(a, f), (f: rs.Formatter) => rs.u64Display(b, f), (f: rs.Formatter) => rs.u64LowerHex(c, f), (f: rs.Formatter) => rs.u64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.u64[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.u64WrappingAdd, 0); + const all: rs.u64[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.u64WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.u64WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.u64WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.u64WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.u64WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.u64WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.u64WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u64WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u64WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u64WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u64WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_u64(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_u64(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_u64(x7), hashed$num_Wrapping_u64(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_u64(x7); - z._0 = rt.u64WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_u64(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u64(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u64(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_u64(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u64(x7), hashed$num_Wrapping_u64(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_u64(x7); + z._0 = rs.u64WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -957,181 +957,181 @@ export function u64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.u128) => undefined = (out2: rt.ByteVec, v: rt.u128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u128ToBeBytes(v))); +export function u128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.u128) => undefined = (out2: rs.ByteVec, v: rs.u128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u128ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.u128 = (at: rt.usize): rt.u128 => { - const buf: Uint8Array = rt.bytes(16); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.u128 = (at: rs.usize): rs.u128 => { + const buf: Uint8Array = rs.bytes(16); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.u128FromBeBytes(buf); + return rs.u128FromBeBytes(buf); }; - const _8: [rt.u128, rt.u128, rt.u128] = [take(0), take(16), take(2 * 16)]; - const a: rt.u128 = _8[0]; - const b: rt.u128 = _8[1]; - const c: rt.u128 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 16, i2)), 0); + const _8: [rs.u128, rs.u128, rs.u128] = [take(0), take(16), take(2 * 16)]; + const a: rs.u128 = _8[0]; + const b: rs.u128 = _8[1]; + const c: rs.u128 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 16, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.u128WrappingAdd(a, b); + const part45 = rs.u128WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.u128WrappingSub(a, b); + const part44 = rs.u128WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.u128WrappingMul(a, b); + const part43 = rs.u128WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.u128Div(a, b)); + _30(out, rs.u128Div(a, b)); } else if (_31 === 4) { - _30(out, rt.u128Rem(a, b)); + _30(out, rs.u128Rem(a, b)); } else if (_31 === 5) { - const part40 = rt.u128WrappingSub(0, a); + const part40 = rs.u128WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { - _30(out, rt.u128Not(a)); + _30(out, rs.u128Not(a)); } else if (_31 === 7) { - _30(out, rt.u128And(a, b)); + _30(out, rs.u128And(a, b)); } else if (_31 === 8) { - _30(out, rt.u128Or(a, b)); + _30(out, rs.u128Or(a, b)); } else if (_31 === 9) { - _30(out, rt.u128Xor(a, b)); + _30(out, rs.u128Xor(a, b)); } else if (_31 === 10) { - _30(out, rt.u128Shl(a, n & 127)); + _30(out, rs.u128Shl(a, n & 127)); } else if (_31 === 11) { - _30(out, rt.u128Shr(a, n & 127)); + _30(out, rs.u128Shr(a, n & 127)); } else if (_31 === 12) { - let x: rt.u128 = a; - x = rt.u128WrappingAdd(x, b); + let x: rs.u128 = a; + x = rs.u128WrappingAdd(x, b); _30(out, x); - x = rt.u128WrappingMul(x, c); + x = rs.u128WrappingMul(x, c); _30(out, x); - x = rt.u128WrappingSub(x, b); + x = rs.u128WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.u128 = a; - x2 = rt.u128Div(x2, b); + let x2: rs.u128 = a; + x2 = rs.u128Div(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.u128 = a; - x3 = rt.u128Rem(x3, b); + let x3: rs.u128 = a; + x3 = rs.u128Rem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.u128 = a; - x4 = rt.u128And(x4, b); - x4 = rt.u128Or(x4, c); - x4 = rt.u128Xor(x4, b); + let x4: rs.u128 = a; + x4 = rs.u128And(x4, b); + x4 = rs.u128Or(x4, c); + x4 = rs.u128Xor(x4, b); _30(out, x4); } else if (_31 === 16) { - let x5: rt.u128 = a; - x5 = rt.u128Shl(x5, n & 127); + let x5: rs.u128 = a; + x5 = rs.u128Shl(x5, n & 127); _30(out, x5); - x5 = rt.u128Shr(x5, n & 127); + x5 = rs.u128Shr(x5, n & 127); _30(out, x5); - _30(out, rt.u128Shl(a, 3)); - _30(out, rt.u128Shr(a, rt.usizeAdd(128, 1) & 127)); + _30(out, rs.u128Shl(a, 3)); + _30(out, rs.u128Shr(a, rs.usizeAdd(128, 1) & 127)); } else if (_31 === 17) { - const part15 = rt.u128WrappingAdd(a, b); + const part15 = rs.u128WrappingAdd(a, b); _30(out, part15); - const part16 = rt.u128WrappingSub(a, b); + const part16 = rs.u128WrappingSub(a, b); _30(out, part16); - const part17 = rt.u128WrappingMul(a, c); + const part17 = rs.u128WrappingMul(a, c); _30(out, part17); - const part18 = rt.u128WrappingSub(0, a); + const part18 = rs.u128WrappingSub(0, a); _30(out, part18); - _30(out, rt.u128Not(b)); - _30(out, rt.u128Shl(a, n & 127)); - _30(out, rt.u128Shr(a, n & 127)); - _30(out, rt.u128Xor(a, c)); - let x6: rt.u128 = a; - x6 = rt.u128WrappingAdd(x6, b); - x6 = rt.u128Shl(x6, n & 127); + _30(out, rs.u128Not(b)); + _30(out, rs.u128Shl(a, n & 127)); + _30(out, rs.u128Shr(a, n & 127)); + _30(out, rs.u128Xor(a, c)); + let x6: rs.u128 = a; + x6 = rs.u128WrappingAdd(x6, b); + x6 = rs.u128Shl(x6, n & 127); _30(out, x6); } else if (_31 === 18) { - const _191: boolean = rt.u128Eq(a, b); - const _194: boolean = !rt.u128Eq(a, b); - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _191: boolean = rs.u128Eq(a, b); + const _194: boolean = !rs.u128Eq(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.u128 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.u128 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.u128 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.u128 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_u128(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_u128(a), hashed$u128(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 16, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_u128(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_u128(a), hashed$u128(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 16, true)); while (true) { - const _258: rt.u128 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.u128 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hash128, rt.u128Eq)) as rt.HashSet, _267, undefined, undefined, 58720256); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hash128, rs.u128Eq)) as rs.HashSet, _267, undefined, undefined, 58720256); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u128Display(a, f), (f: rt.Formatter) => rt.u128Debug(b, f), (f: rt.Formatter) => rt.u128LowerHex(a, f), (f: rt.Formatter) => rt.u128UpperHex(b, f), (f: rt.Formatter) => rt.u128Octal(c, f), (f: rt.Formatter) => rt.u128Binary(a, f), (f: rt.Formatter) => rt.u128Display(b, f), (f: rt.Formatter) => rt.u128LowerHex(c, f), (f: rt.Formatter) => rt.u128Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u128Display(a, f), (f: rs.Formatter) => rs.u128Debug(b, f), (f: rs.Formatter) => rs.u128LowerHex(a, f), (f: rs.Formatter) => rs.u128UpperHex(b, f), (f: rs.Formatter) => rs.u128Octal(c, f), (f: rs.Formatter) => rs.u128Binary(a, f), (f: rs.Formatter) => rs.u128Display(b, f), (f: rs.Formatter) => rs.u128LowerHex(c, f), (f: rs.Formatter) => rs.u128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.u128[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.u128WrappingAdd, 0); + const all: rs.u128[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.u128WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.u128WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.u128WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.u128WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.u128WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.u128WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.u128WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u128WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u128WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.u128WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.u128WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_u128(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_u128(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_u128(x7), hashed$num_Wrapping_u128(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_u128(x7); - z._0 = rt.u128WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_u128(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_u128(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_u128(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_u128(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_u128(x7), hashed$num_Wrapping_u128(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_u128(x7); + z._0 = rs.u128WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -1140,46 +1140,46 @@ export function u128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.usize) => undefined = (out2: rt.ByteVec, v: rt.usize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.usizeToBeBytes(v))); +export function usizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.usize) => undefined = (out2: rs.ByteVec, v: rs.usize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.usizeToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.usize = (at: rt.usize): rt.usize => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.usize = (at: rs.usize): rs.usize => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.usizeFromBeBytes(buf); + return rs.usizeFromBeBytes(buf); }; - const _8: [rt.usize, rt.usize, rt.usize] = [take(0), take(4), take(2 * 4)]; - const a: rt.usize = _8[0]; - const b: rt.usize = _8[1]; - const c: rt.usize = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 4, i2)), 0); + const _8: [rs.usize, rs.usize, rs.usize] = [take(0), take(4), take(2 * 4)]; + const a: rs.usize = _8[0]; + const b: rs.usize = _8[1]; + const c: rs.usize = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.usizeWrappingAdd(a, b); + const part45 = rs.usizeWrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.usizeWrappingSub(a, b); + const part44 = rs.usizeWrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.usizeWrappingMul(a, b); + const part43 = rs.usizeWrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - _30(out, rt.usizeDiv(a, b)); + _30(out, rs.usizeDiv(a, b)); } else if (_31 === 4) { - _30(out, rt.usizeRem(a, b)); + _30(out, rs.usizeRem(a, b)); } else if (_31 === 5) { - const part40 = rt.usizeWrappingSub(0, a); + const part40 = rs.usizeWrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a >>> 0); @@ -1190,131 +1190,131 @@ export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, (a ^ b) >>> 0); } else if (_31 === 10) { - _30(out, rt.usizeShl(a, n & 31)); + _30(out, rs.usizeShl(a, n & 31)); } else if (_31 === 11) { - _30(out, rt.usizeShr(a, n & 31)); + _30(out, rs.usizeShr(a, n & 31)); } else if (_31 === 12) { - let x: rt.usize = a; - x = rt.usizeWrappingAdd(x, b); + let x: rs.usize = a; + x = rs.usizeWrappingAdd(x, b); _30(out, x); - x = rt.usizeWrappingMul(x, c); + x = rs.usizeWrappingMul(x, c); _30(out, x); - x = rt.usizeWrappingSub(x, b); + x = rs.usizeWrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.usize = a; - x2 = rt.usizeDiv(x2, b); + let x2: rs.usize = a; + x2 = rs.usizeDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.usize = a; - x3 = rt.usizeRem(x3, b); + let x3: rs.usize = a; + x3 = rs.usizeRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.usize = a; + let x4: rs.usize = a; x4 = (x4 & b) >>> 0; x4 = (x4 | c) >>> 0; x4 = (x4 ^ b) >>> 0; _30(out, x4); } else if (_31 === 16) { - let x5: rt.usize = a; - x5 = rt.usizeShl(x5, n & 31); + let x5: rs.usize = a; + x5 = rs.usizeShl(x5, n & 31); _30(out, x5); - x5 = rt.usizeShr(x5, n & 31); + x5 = rs.usizeShr(x5, n & 31); _30(out, x5); _30(out, (a << 3) >>> 0); - _30(out, rt.usizeShr(a, rt.usizeAdd(32, 1) & 31)); + _30(out, rs.usizeShr(a, rs.usizeAdd(32, 1) & 31)); } else if (_31 === 17) { - const part15 = rt.usizeWrappingAdd(a, b); + const part15 = rs.usizeWrappingAdd(a, b); _30(out, part15); - const part16 = rt.usizeWrappingSub(a, b); + const part16 = rs.usizeWrappingSub(a, b); _30(out, part16); - const part17 = rt.usizeWrappingMul(a, c); + const part17 = rs.usizeWrappingMul(a, c); _30(out, part17); - const part18 = rt.usizeWrappingSub(0, a); + const part18 = rs.usizeWrappingSub(0, a); _30(out, part18); _30(out, ~b >>> 0); - _30(out, rt.usizeShl(a, n & 31)); - _30(out, rt.usizeShr(a, n & 31)); + _30(out, rs.usizeShl(a, n & 31)); + _30(out, rs.usizeShr(a, n & 31)); _30(out, (a ^ c) >>> 0); - let x6: rt.usize = a; - x6 = rt.usizeWrappingAdd(x6, b); - x6 = rt.usizeShl(x6, n & 31); + let x6: rs.usize = a; + x6 = rs.usizeWrappingAdd(x6, b); + x6 = rs.usizeShl(x6, n & 31); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.usize = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.usize = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.usize = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.usize = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_usize(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_usize(a), hashed$usize(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_usize(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_usize(a), hashed$usize(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 4, true)); while (true) { - const _258: rt.usize | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.usize | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashUsize, rt.same)) as rt.HashSet, _267, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashUsize, rs.same)) as rs.HashSet, _267, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(a, f), (f: rt.Formatter) => rt.usizeDebug(b, f), (f: rt.Formatter) => rt.usizeLowerHex(a, f), (f: rt.Formatter) => rt.usizeUpperHex(b, f), (f: rt.Formatter) => rt.usizeOctal(c, f), (f: rt.Formatter) => rt.usizeBinary(a, f), (f: rt.Formatter) => rt.usizeDisplay(b, f), (f: rt.Formatter) => rt.usizeLowerHex(c, f), (f: rt.Formatter) => rt.usizeDebug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(a, f), (f: rs.Formatter) => rs.usizeDebug(b, f), (f: rs.Formatter) => rs.usizeLowerHex(a, f), (f: rs.Formatter) => rs.usizeUpperHex(b, f), (f: rs.Formatter) => rs.usizeOctal(c, f), (f: rs.Formatter) => rs.usizeBinary(a, f), (f: rs.Formatter) => rs.usizeDisplay(b, f), (f: rs.Formatter) => rs.usizeLowerHex(c, f), (f: rs.Formatter) => rs.usizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.usize[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.usizeWrappingAdd, 0); + const all: rs.usize[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.usizeWrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.usizeWrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.usizeWrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.usizeWrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.usizeWrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.usizeWrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.usizeWrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.usizeWrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.usizeWrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.usizeWrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.usizeWrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_usize(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_usize(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_usize(x7), hashed$num_Wrapping_usize(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_usize(x7); - z._0 = rt.usizeWrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_usize(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_usize(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_usize(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_usize(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_usize(x7), hashed$num_Wrapping_usize(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_usize(x7); + z._0 = rs.usizeWrappingSub(z._0, y._0); _30(out, z._0); } } @@ -1323,48 +1323,48 @@ export function usizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.i8) => undefined = (out2: rt.ByteVec, v: rt.i8): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i8ToBeBytes(v))); +export function i8s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.i8) => undefined = (out2: rs.ByteVec, v: rs.i8): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i8ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i8 = (at: rt.usize): rt.i8 => { + const take: (a0: rs.usize) => rs.i8 = (at: rs.usize): rs.i8 => { const buf: Uint8Array = Uint8Array.of(0); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i8FromBeBytes(buf); + return rs.i8FromBeBytes(buf); }; - const _8: [rt.i8, rt.i8, rt.i8] = [take(0), take(1), take(2 * 1)]; - const a: rt.i8 = _8[0]; - const b: rt.i8 = _8[1]; - const c: rt.i8 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 1, i2)), 0); + const _8: [rs.i8, rs.i8, rs.i8] = [take(0), take(1), take(2 * 1)]; + const a: rs.i8 = _8[0]; + const b: rs.i8 = _8[1]; + const c: rs.i8 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 1, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.i8WrappingAdd(a, b); + const part45 = rs.i8WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.i8WrappingSub(a, b); + const part44 = rs.i8WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.i8WrappingMul(a, b); + const part43 = rs.i8WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.i8WrappingDiv(a, b); + const part42 = rs.i8WrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.i8WrappingRem(a, b); + const part41 = rs.i8WrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.i8WrappingSub(0, a); + const part40 = rs.i8WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a); @@ -1375,131 +1375,131 @@ export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.i8Shl(a, n & 7)); + _30(out, rs.i8Shl(a, n & 7)); } else if (_31 === 11) { - _30(out, rt.i8Shr(a, n & 7)); + _30(out, rs.i8Shr(a, n & 7)); } else if (_31 === 12) { - let x: rt.i8 = a; - x = rt.i8WrappingAdd(x, b); + let x: rs.i8 = a; + x = rs.i8WrappingAdd(x, b); _30(out, x); - x = rt.i8WrappingMul(x, c); + x = rs.i8WrappingMul(x, c); _30(out, x); - x = rt.i8WrappingSub(x, b); + x = rs.i8WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.i8 = a; - x2 = rt.i8WrappingDiv(x2, b); + let x2: rs.i8 = a; + x2 = rs.i8WrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.i8 = a; - x3 = rt.i8WrappingRem(x3, b); + let x3: rs.i8 = a; + x3 = rs.i8WrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.i8 = a; + let x4: rs.i8 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.i8 = a; - x5 = rt.i8Shl(x5, n & 7); + let x5: rs.i8 = a; + x5 = rs.i8Shl(x5, n & 7); _30(out, x5); - x5 = rt.i8Shr(x5, n & 7); + x5 = rs.i8Shr(x5, n & 7); _30(out, x5); _30(out, (a << 3 << 24) >> 24); - _30(out, rt.i8Shr(a, rt.usizeAdd(8, 1) & 7)); + _30(out, rs.i8Shr(a, rs.usizeAdd(8, 1) & 7)); } else if (_31 === 17) { - const part15 = rt.i8WrappingAdd(a, b); + const part15 = rs.i8WrappingAdd(a, b); _30(out, part15); - const part16 = rt.i8WrappingSub(a, b); + const part16 = rs.i8WrappingSub(a, b); _30(out, part16); - const part17 = rt.i8WrappingMul(a, c); + const part17 = rs.i8WrappingMul(a, c); _30(out, part17); - const part18 = rt.i8WrappingSub(0, a); + const part18 = rs.i8WrappingSub(0, a); _30(out, part18); _30(out, ~b); - _30(out, rt.i8Shl(a, n & 7)); - _30(out, rt.i8Shr(a, n & 7)); + _30(out, rs.i8Shl(a, n & 7)); + _30(out, rs.i8Shr(a, n & 7)); _30(out, a ^ c); - let x6: rt.i8 = a; - x6 = rt.i8WrappingAdd(x6, b); - x6 = rt.i8Shl(x6, n & 7); + let x6: rs.i8 = a; + x6 = rs.i8WrappingAdd(x6, b); + x6 = rs.i8Shl(x6, n & 7); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.i8 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.i8 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.i8 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.i8 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_i8(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_i8(a), hashed$i8(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 1, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_i8(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_i8(a), hashed$i8(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 1, true)); while (true) { - const _258: rt.i8 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.i8 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI8, rt.same)) as rt.HashSet, _267, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI8, rs.same)) as rs.HashSet, _267, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(a, f), (f: rt.Formatter) => rt.i8Debug(b, f), (f: rt.Formatter) => rt.i8LowerHex(a, f), (f: rt.Formatter) => rt.i8UpperHex(b, f), (f: rt.Formatter) => rt.i8Octal(c, f), (f: rt.Formatter) => rt.i8Binary(a, f), (f: rt.Formatter) => rt.i8Display(b, f), (f: rt.Formatter) => rt.i8LowerHex(c, f), (f: rt.Formatter) => rt.i8Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(a, f), (f: rs.Formatter) => rs.i8Debug(b, f), (f: rs.Formatter) => rs.i8LowerHex(a, f), (f: rs.Formatter) => rs.i8UpperHex(b, f), (f: rs.Formatter) => rs.i8Octal(c, f), (f: rs.Formatter) => rs.i8Binary(a, f), (f: rs.Formatter) => rs.i8Display(b, f), (f: rs.Formatter) => rs.i8LowerHex(c, f), (f: rs.Formatter) => rs.i8Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.i8[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.i8WrappingAdd, 0); + const all: rs.i8[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.i8WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.i8WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.i8WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.i8WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.i8WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.i8WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.i8WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i8WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i8WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i8WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i8WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_i8(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_i8(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_i8(x7), hashed$num_Wrapping_i8(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_i8(x7); - z._0 = rt.i8WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_i8(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i8(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i8(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_i8(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i8(x7), hashed$num_Wrapping_i8(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_i8(x7); + z._0 = rs.i8WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -1508,48 +1508,48 @@ export function i8s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.i16) => undefined = (out2: rt.ByteVec, v: rt.i16): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i16ToBeBytes(v))); +export function i16s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.i16) => undefined = (out2: rs.ByteVec, v: rs.i16): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i16ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i16 = (at: rt.usize): rt.i16 => { - const buf: Uint8Array = rt.bytes(2); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i16 = (at: rs.usize): rs.i16 => { + const buf: Uint8Array = rs.bytes(2); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i16FromBeBytes(buf); + return rs.i16FromBeBytes(buf); }; - const _8: [rt.i16, rt.i16, rt.i16] = [take(0), take(2), take(2 * 2)]; - const a: rt.i16 = _8[0]; - const b: rt.i16 = _8[1]; - const c: rt.i16 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 2, i2)), 0); + const _8: [rs.i16, rs.i16, rs.i16] = [take(0), take(2), take(2 * 2)]; + const a: rs.i16 = _8[0]; + const b: rs.i16 = _8[1]; + const c: rs.i16 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 2, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.i16WrappingAdd(a, b); + const part45 = rs.i16WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.i16WrappingSub(a, b); + const part44 = rs.i16WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.i16WrappingMul(a, b); + const part43 = rs.i16WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.i16WrappingDiv(a, b); + const part42 = rs.i16WrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.i16WrappingRem(a, b); + const part41 = rs.i16WrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.i16WrappingSub(0, a); + const part40 = rs.i16WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a); @@ -1560,131 +1560,131 @@ export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.i16Shl(a, n & 15)); + _30(out, rs.i16Shl(a, n & 15)); } else if (_31 === 11) { - _30(out, rt.i16Shr(a, n & 15)); + _30(out, rs.i16Shr(a, n & 15)); } else if (_31 === 12) { - let x: rt.i16 = a; - x = rt.i16WrappingAdd(x, b); + let x: rs.i16 = a; + x = rs.i16WrappingAdd(x, b); _30(out, x); - x = rt.i16WrappingMul(x, c); + x = rs.i16WrappingMul(x, c); _30(out, x); - x = rt.i16WrappingSub(x, b); + x = rs.i16WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.i16 = a; - x2 = rt.i16WrappingDiv(x2, b); + let x2: rs.i16 = a; + x2 = rs.i16WrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.i16 = a; - x3 = rt.i16WrappingRem(x3, b); + let x3: rs.i16 = a; + x3 = rs.i16WrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.i16 = a; + let x4: rs.i16 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.i16 = a; - x5 = rt.i16Shl(x5, n & 15); + let x5: rs.i16 = a; + x5 = rs.i16Shl(x5, n & 15); _30(out, x5); - x5 = rt.i16Shr(x5, n & 15); + x5 = rs.i16Shr(x5, n & 15); _30(out, x5); _30(out, (a << 3 << 16) >> 16); - _30(out, rt.i16Shr(a, rt.usizeAdd(16, 1) & 15)); + _30(out, rs.i16Shr(a, rs.usizeAdd(16, 1) & 15)); } else if (_31 === 17) { - const part15 = rt.i16WrappingAdd(a, b); + const part15 = rs.i16WrappingAdd(a, b); _30(out, part15); - const part16 = rt.i16WrappingSub(a, b); + const part16 = rs.i16WrappingSub(a, b); _30(out, part16); - const part17 = rt.i16WrappingMul(a, c); + const part17 = rs.i16WrappingMul(a, c); _30(out, part17); - const part18 = rt.i16WrappingSub(0, a); + const part18 = rs.i16WrappingSub(0, a); _30(out, part18); _30(out, ~b); - _30(out, rt.i16Shl(a, n & 15)); - _30(out, rt.i16Shr(a, n & 15)); + _30(out, rs.i16Shl(a, n & 15)); + _30(out, rs.i16Shr(a, n & 15)); _30(out, a ^ c); - let x6: rt.i16 = a; - x6 = rt.i16WrappingAdd(x6, b); - x6 = rt.i16Shl(x6, n & 15); + let x6: rs.i16 = a; + x6 = rs.i16WrappingAdd(x6, b); + x6 = rs.i16Shl(x6, n & 15); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.i16 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.i16 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.i16 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.i16 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_i16(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_i16(a), hashed$i16(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 2, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_i16(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_i16(a), hashed$i16(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 2, true)); while (true) { - const _258: rt.i16 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.i16 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI16, rt.same)) as rt.HashSet, _267, undefined, undefined, 469762048); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI16, rs.same)) as rs.HashSet, _267, undefined, undefined, 469762048); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i16Display(a, f), (f: rt.Formatter) => rt.i16Debug(b, f), (f: rt.Formatter) => rt.i16LowerHex(a, f), (f: rt.Formatter) => rt.i16UpperHex(b, f), (f: rt.Formatter) => rt.i16Octal(c, f), (f: rt.Formatter) => rt.i16Binary(a, f), (f: rt.Formatter) => rt.i16Display(b, f), (f: rt.Formatter) => rt.i16LowerHex(c, f), (f: rt.Formatter) => rt.i16Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i16Display(a, f), (f: rs.Formatter) => rs.i16Debug(b, f), (f: rs.Formatter) => rs.i16LowerHex(a, f), (f: rs.Formatter) => rs.i16UpperHex(b, f), (f: rs.Formatter) => rs.i16Octal(c, f), (f: rs.Formatter) => rs.i16Binary(a, f), (f: rs.Formatter) => rs.i16Display(b, f), (f: rs.Formatter) => rs.i16LowerHex(c, f), (f: rs.Formatter) => rs.i16Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.i16[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.i16WrappingAdd, 0); + const all: rs.i16[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.i16WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.i16WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.i16WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.i16WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.i16WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.i16WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.i16WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i16WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i16WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i16WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i16WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_i16(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_i16(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_i16(x7), hashed$num_Wrapping_i16(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_i16(x7); - z._0 = rt.i16WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_i16(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i16(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i16(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_i16(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i16(x7), hashed$num_Wrapping_i16(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_i16(x7); + z._0 = rs.i16WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -1693,48 +1693,48 @@ export function i16s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.i32) => undefined = (out2: rt.ByteVec, v: rt.i32): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i32ToBeBytes(v))); +export function i32s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.i32) => undefined = (out2: rs.ByteVec, v: rs.i32): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i32ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i32 = (at: rt.usize): rt.i32 => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i32 = (at: rs.usize): rs.i32 => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i32FromBeBytes(buf); + return rs.i32FromBeBytes(buf); }; - const _8: [rt.i32, rt.i32, rt.i32] = [take(0), take(4), take(2 * 4)]; - const a: rt.i32 = _8[0]; - const b: rt.i32 = _8[1]; - const c: rt.i32 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 4, i2)), 0); + const _8: [rs.i32, rs.i32, rs.i32] = [take(0), take(4), take(2 * 4)]; + const a: rs.i32 = _8[0]; + const b: rs.i32 = _8[1]; + const c: rs.i32 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.i32WrappingAdd(a, b); + const part45 = rs.i32WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.i32WrappingSub(a, b); + const part44 = rs.i32WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.i32WrappingMul(a, b); + const part43 = rs.i32WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.i32WrappingDiv(a, b); + const part42 = rs.i32WrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.i32WrappingRem(a, b); + const part41 = rs.i32WrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.i32WrappingSub(0, a); + const part40 = rs.i32WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a); @@ -1745,131 +1745,131 @@ export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.i32Shl(a, n & 31)); + _30(out, rs.i32Shl(a, n & 31)); } else if (_31 === 11) { - _30(out, rt.i32Shr(a, n & 31)); + _30(out, rs.i32Shr(a, n & 31)); } else if (_31 === 12) { - let x: rt.i32 = a; - x = rt.i32WrappingAdd(x, b); + let x: rs.i32 = a; + x = rs.i32WrappingAdd(x, b); _30(out, x); - x = rt.i32WrappingMul(x, c); + x = rs.i32WrappingMul(x, c); _30(out, x); - x = rt.i32WrappingSub(x, b); + x = rs.i32WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.i32 = a; - x2 = rt.i32WrappingDiv(x2, b); + let x2: rs.i32 = a; + x2 = rs.i32WrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.i32 = a; - x3 = rt.i32WrappingRem(x3, b); + let x3: rs.i32 = a; + x3 = rs.i32WrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.i32 = a; + let x4: rs.i32 = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.i32 = a; - x5 = rt.i32Shl(x5, n & 31); + let x5: rs.i32 = a; + x5 = rs.i32Shl(x5, n & 31); _30(out, x5); - x5 = rt.i32Shr(x5, n & 31); + x5 = rs.i32Shr(x5, n & 31); _30(out, x5); _30(out, (a << 3) | 0); - _30(out, rt.i32Shr(a, rt.usizeAdd(32, 1) & 31)); + _30(out, rs.i32Shr(a, rs.usizeAdd(32, 1) & 31)); } else if (_31 === 17) { - const part15 = rt.i32WrappingAdd(a, b); + const part15 = rs.i32WrappingAdd(a, b); _30(out, part15); - const part16 = rt.i32WrappingSub(a, b); + const part16 = rs.i32WrappingSub(a, b); _30(out, part16); - const part17 = rt.i32WrappingMul(a, c); + const part17 = rs.i32WrappingMul(a, c); _30(out, part17); - const part18 = rt.i32WrappingSub(0, a); + const part18 = rs.i32WrappingSub(0, a); _30(out, part18); _30(out, ~b); - _30(out, rt.i32Shl(a, n & 31)); - _30(out, rt.i32Shr(a, n & 31)); + _30(out, rs.i32Shl(a, n & 31)); + _30(out, rs.i32Shr(a, n & 31)); _30(out, a ^ c); - let x6: rt.i32 = a; - x6 = rt.i32WrappingAdd(x6, b); - x6 = rt.i32Shl(x6, n & 31); + let x6: rs.i32 = a; + x6 = rs.i32WrappingAdd(x6, b); + x6 = rs.i32Shl(x6, n & 31); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.i32 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.i32 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.i32 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.i32 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_i32(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_i32(a), hashed$i32(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_i32(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_i32(a), hashed$i32(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 4, true)); while (true) { - const _258: rt.i32 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.i32 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI32, rt.same)) as rt.HashSet, _267, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI32, rs.same)) as rs.HashSet, _267, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(a, f), (f: rt.Formatter) => rt.i32Debug(b, f), (f: rt.Formatter) => rt.i32LowerHex(a, f), (f: rt.Formatter) => rt.i32UpperHex(b, f), (f: rt.Formatter) => rt.i32Octal(c, f), (f: rt.Formatter) => rt.i32Binary(a, f), (f: rt.Formatter) => rt.i32Display(b, f), (f: rt.Formatter) => rt.i32LowerHex(c, f), (f: rt.Formatter) => rt.i32Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(a, f), (f: rs.Formatter) => rs.i32Debug(b, f), (f: rs.Formatter) => rs.i32LowerHex(a, f), (f: rs.Formatter) => rs.i32UpperHex(b, f), (f: rs.Formatter) => rs.i32Octal(c, f), (f: rs.Formatter) => rs.i32Binary(a, f), (f: rs.Formatter) => rs.i32Display(b, f), (f: rs.Formatter) => rs.i32LowerHex(c, f), (f: rs.Formatter) => rs.i32Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.i32[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.i32WrappingAdd, 0); + const all: rs.i32[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.i32WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.i32WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.i32WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.i32WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.i32WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.i32WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.i32WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i32WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i32WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i32WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i32WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_i32(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_i32(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_i32(x7), hashed$num_Wrapping_i32(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_i32(x7); - z._0 = rt.i32WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_i32(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i32(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i32(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_i32(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i32(x7), hashed$num_Wrapping_i32(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_i32(x7); + z._0 = rs.i32WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -1878,183 +1878,183 @@ export function i32s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.i64) => undefined = (out2: rt.ByteVec, v: rt.i64): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i64ToBeBytes(v))); +export function i64s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.i64) => undefined = (out2: rs.ByteVec, v: rs.i64): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i64ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i64 = (at: rt.usize): rt.i64 => { - const buf: Uint8Array = rt.bytes(8); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i64 = (at: rs.usize): rs.i64 => { + const buf: Uint8Array = rs.bytes(8); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i64FromBeBytes(buf); + return rs.i64FromBeBytes(buf); }; - const _8: [rt.i64, rt.i64, rt.i64] = [take(0), take(8), take(2 * 8)]; - const a: rt.i64 = _8[0]; - const b: rt.i64 = _8[1]; - const c: rt.i64 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 8, i2)), 0); + const _8: [rs.i64, rs.i64, rs.i64] = [take(0), take(8), take(2 * 8)]; + const a: rs.i64 = _8[0]; + const b: rs.i64 = _8[1]; + const c: rs.i64 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 8, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.i64WrappingAdd(a, b); + const part45 = rs.i64WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.i64WrappingSub(a, b); + const part44 = rs.i64WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.i64WrappingMul(a, b); + const part43 = rs.i64WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.i64WrappingDiv(a, b); + const part42 = rs.i64WrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.i64WrappingRem(a, b); + const part41 = rs.i64WrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.i64WrappingSub(0, a); + const part40 = rs.i64WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { - _30(out, rt.i64Not(a)); + _30(out, rs.i64Not(a)); } else if (_31 === 7) { - _30(out, rt.i64And(a, b)); + _30(out, rs.i64And(a, b)); } else if (_31 === 8) { - _30(out, rt.i64Or(a, b)); + _30(out, rs.i64Or(a, b)); } else if (_31 === 9) { - _30(out, rt.i64Xor(a, b)); + _30(out, rs.i64Xor(a, b)); } else if (_31 === 10) { - _30(out, rt.i64Shl(a, n & 63)); + _30(out, rs.i64Shl(a, n & 63)); } else if (_31 === 11) { - _30(out, rt.i64Shr(a, n & 63)); + _30(out, rs.i64Shr(a, n & 63)); } else if (_31 === 12) { - let x: rt.i64 = a; - x = rt.i64WrappingAdd(x, b); + let x: rs.i64 = a; + x = rs.i64WrappingAdd(x, b); _30(out, x); - x = rt.i64WrappingMul(x, c); + x = rs.i64WrappingMul(x, c); _30(out, x); - x = rt.i64WrappingSub(x, b); + x = rs.i64WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.i64 = a; - x2 = rt.i64WrappingDiv(x2, b); + let x2: rs.i64 = a; + x2 = rs.i64WrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.i64 = a; - x3 = rt.i64WrappingRem(x3, b); + let x3: rs.i64 = a; + x3 = rs.i64WrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.i64 = a; - x4 = rt.i64And(x4, b); - x4 = rt.i64Or(x4, c); - x4 = rt.i64Xor(x4, b); + let x4: rs.i64 = a; + x4 = rs.i64And(x4, b); + x4 = rs.i64Or(x4, c); + x4 = rs.i64Xor(x4, b); _30(out, x4); } else if (_31 === 16) { - let x5: rt.i64 = a; - x5 = rt.i64Shl(x5, n & 63); + let x5: rs.i64 = a; + x5 = rs.i64Shl(x5, n & 63); _30(out, x5); - x5 = rt.i64Shr(x5, n & 63); + x5 = rs.i64Shr(x5, n & 63); _30(out, x5); - _30(out, rt.i64Shl(a, 3)); - _30(out, rt.i64Shr(a, rt.usizeAdd(64, 1) & 63)); + _30(out, rs.i64Shl(a, 3)); + _30(out, rs.i64Shr(a, rs.usizeAdd(64, 1) & 63)); } else if (_31 === 17) { - const part15 = rt.i64WrappingAdd(a, b); + const part15 = rs.i64WrappingAdd(a, b); _30(out, part15); - const part16 = rt.i64WrappingSub(a, b); + const part16 = rs.i64WrappingSub(a, b); _30(out, part16); - const part17 = rt.i64WrappingMul(a, c); + const part17 = rs.i64WrappingMul(a, c); _30(out, part17); - const part18 = rt.i64WrappingSub(0, a); + const part18 = rs.i64WrappingSub(0, a); _30(out, part18); - _30(out, rt.i64Not(b)); - _30(out, rt.i64Shl(a, n & 63)); - _30(out, rt.i64Shr(a, n & 63)); - _30(out, rt.i64Xor(a, c)); - let x6: rt.i64 = a; - x6 = rt.i64WrappingAdd(x6, b); - x6 = rt.i64Shl(x6, n & 63); + _30(out, rs.i64Not(b)); + _30(out, rs.i64Shl(a, n & 63)); + _30(out, rs.i64Shr(a, n & 63)); + _30(out, rs.i64Xor(a, c)); + let x6: rs.i64 = a; + x6 = rs.i64WrappingAdd(x6, b); + x6 = rs.i64Shl(x6, n & 63); _30(out, x6); } else if (_31 === 18) { - const _191: boolean = rt.i64Eq(a, b); - const _194: boolean = !rt.i64Eq(a, b); - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _191: boolean = rs.i64Eq(a, b); + const _194: boolean = !rs.i64Eq(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.i64 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.i64 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.i64 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.i64 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_i64(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_i64(a), hashed$i64(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 8, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_i64(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_i64(a), hashed$i64(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 8, true)); while (true) { - const _258: rt.i64 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.i64 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI64, rt.i64Eq)) as rt.HashSet, _267, undefined, undefined, 117440512); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI64, rs.i64Eq)) as rs.HashSet, _267, undefined, undefined, 117440512); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i64Display(a, f), (f: rt.Formatter) => rt.i64Debug(b, f), (f: rt.Formatter) => rt.i64LowerHex(a, f), (f: rt.Formatter) => rt.i64UpperHex(b, f), (f: rt.Formatter) => rt.i64Octal(c, f), (f: rt.Formatter) => rt.i64Binary(a, f), (f: rt.Formatter) => rt.i64Display(b, f), (f: rt.Formatter) => rt.i64LowerHex(c, f), (f: rt.Formatter) => rt.i64Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i64Display(a, f), (f: rs.Formatter) => rs.i64Debug(b, f), (f: rs.Formatter) => rs.i64LowerHex(a, f), (f: rs.Formatter) => rs.i64UpperHex(b, f), (f: rs.Formatter) => rs.i64Octal(c, f), (f: rs.Formatter) => rs.i64Binary(a, f), (f: rs.Formatter) => rs.i64Display(b, f), (f: rs.Formatter) => rs.i64LowerHex(c, f), (f: rs.Formatter) => rs.i64Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.i64[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.i64WrappingAdd, 0); + const all: rs.i64[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.i64WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.i64WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.i64WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.i64WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.i64WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.i64WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.i64WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i64WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i64WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i64WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i64WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_i64(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_i64(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_i64(x7), hashed$num_Wrapping_i64(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_i64(x7); - z._0 = rt.i64WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_i64(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i64(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i64(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_i64(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i64(x7), hashed$num_Wrapping_i64(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_i64(x7); + z._0 = rs.i64WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -2063,183 +2063,183 @@ export function i64s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.i128) => undefined = (out2: rt.ByteVec, v: rt.i128): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.i128ToBeBytes(v))); +export function i128s(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.i128) => undefined = (out2: rs.ByteVec, v: rs.i128): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.i128ToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.i128 = (at: rt.usize): rt.i128 => { - const buf: Uint8Array = rt.bytes(16); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.i128 = (at: rs.usize): rs.i128 => { + const buf: Uint8Array = rs.bytes(16); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.i128FromBeBytes(buf); + return rs.i128FromBeBytes(buf); }; - const _8: [rt.i128, rt.i128, rt.i128] = [take(0), take(16), take(2 * 16)]; - const a: rt.i128 = _8[0]; - const b: rt.i128 = _8[1]; - const c: rt.i128 = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 16, i2)), 0); + const _8: [rs.i128, rs.i128, rs.i128] = [take(0), take(16), take(2 * 16)]; + const a: rs.i128 = _8[0]; + const b: rs.i128 = _8[1]; + const c: rs.i128 = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 16, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.i128WrappingAdd(a, b); + const part45 = rs.i128WrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.i128WrappingSub(a, b); + const part44 = rs.i128WrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.i128WrappingMul(a, b); + const part43 = rs.i128WrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.i128WrappingDiv(a, b); + const part42 = rs.i128WrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.i128WrappingRem(a, b); + const part41 = rs.i128WrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.i128WrappingSub(0, a); + const part40 = rs.i128WrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { - _30(out, rt.i128Not(a)); + _30(out, rs.i128Not(a)); } else if (_31 === 7) { - _30(out, rt.i128And(a, b)); + _30(out, rs.i128And(a, b)); } else if (_31 === 8) { - _30(out, rt.i128Or(a, b)); + _30(out, rs.i128Or(a, b)); } else if (_31 === 9) { - _30(out, rt.i128Xor(a, b)); + _30(out, rs.i128Xor(a, b)); } else if (_31 === 10) { - _30(out, rt.i128Shl(a, n & 127)); + _30(out, rs.i128Shl(a, n & 127)); } else if (_31 === 11) { - _30(out, rt.i128Shr(a, n & 127)); + _30(out, rs.i128Shr(a, n & 127)); } else if (_31 === 12) { - let x: rt.i128 = a; - x = rt.i128WrappingAdd(x, b); + let x: rs.i128 = a; + x = rs.i128WrappingAdd(x, b); _30(out, x); - x = rt.i128WrappingMul(x, c); + x = rs.i128WrappingMul(x, c); _30(out, x); - x = rt.i128WrappingSub(x, b); + x = rs.i128WrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.i128 = a; - x2 = rt.i128WrappingDiv(x2, b); + let x2: rs.i128 = a; + x2 = rs.i128WrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.i128 = a; - x3 = rt.i128WrappingRem(x3, b); + let x3: rs.i128 = a; + x3 = rs.i128WrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.i128 = a; - x4 = rt.i128And(x4, b); - x4 = rt.i128Or(x4, c); - x4 = rt.i128Xor(x4, b); + let x4: rs.i128 = a; + x4 = rs.i128And(x4, b); + x4 = rs.i128Or(x4, c); + x4 = rs.i128Xor(x4, b); _30(out, x4); } else if (_31 === 16) { - let x5: rt.i128 = a; - x5 = rt.i128Shl(x5, n & 127); + let x5: rs.i128 = a; + x5 = rs.i128Shl(x5, n & 127); _30(out, x5); - x5 = rt.i128Shr(x5, n & 127); + x5 = rs.i128Shr(x5, n & 127); _30(out, x5); - _30(out, rt.i128Shl(a, 3)); - _30(out, rt.i128Shr(a, rt.usizeAdd(128, 1) & 127)); + _30(out, rs.i128Shl(a, 3)); + _30(out, rs.i128Shr(a, rs.usizeAdd(128, 1) & 127)); } else if (_31 === 17) { - const part15 = rt.i128WrappingAdd(a, b); + const part15 = rs.i128WrappingAdd(a, b); _30(out, part15); - const part16 = rt.i128WrappingSub(a, b); + const part16 = rs.i128WrappingSub(a, b); _30(out, part16); - const part17 = rt.i128WrappingMul(a, c); + const part17 = rs.i128WrappingMul(a, c); _30(out, part17); - const part18 = rt.i128WrappingSub(0, a); + const part18 = rs.i128WrappingSub(0, a); _30(out, part18); - _30(out, rt.i128Not(b)); - _30(out, rt.i128Shl(a, n & 127)); - _30(out, rt.i128Shr(a, n & 127)); - _30(out, rt.i128Xor(a, c)); - let x6: rt.i128 = a; - x6 = rt.i128WrappingAdd(x6, b); - x6 = rt.i128Shl(x6, n & 127); + _30(out, rs.i128Not(b)); + _30(out, rs.i128Shl(a, n & 127)); + _30(out, rs.i128Shr(a, n & 127)); + _30(out, rs.i128Xor(a, c)); + let x6: rs.i128 = a; + x6 = rs.i128WrappingAdd(x6, b); + x6 = rs.i128Shl(x6, n & 127); _30(out, x6); } else if (_31 === 18) { - const _191: boolean = rt.i128Eq(a, b); - const _194: boolean = !rt.i128Eq(a, b); - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _191: boolean = rs.i128Eq(a, b); + const _194: boolean = !rs.i128Eq(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.i128 = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.i128 = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.i128 = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.i128 = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_i128(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_i128(a), hashed$i128(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 16, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_i128(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_i128(a), hashed$i128(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 16, true)); while (true) { - const _258: rt.i128 | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.i128 | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashI128, rt.i128Eq)) as rt.HashSet, _267, undefined, undefined, 58720256); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashI128, rs.i128Eq)) as rs.HashSet, _267, undefined, undefined, 58720256); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.i128Display(a, f), (f: rt.Formatter) => rt.i128Debug(b, f), (f: rt.Formatter) => rt.i128LowerHex(a, f), (f: rt.Formatter) => rt.i128UpperHex(b, f), (f: rt.Formatter) => rt.i128Octal(c, f), (f: rt.Formatter) => rt.i128Binary(a, f), (f: rt.Formatter) => rt.i128Display(b, f), (f: rt.Formatter) => rt.i128LowerHex(c, f), (f: rt.Formatter) => rt.i128Debug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.i128Display(a, f), (f: rs.Formatter) => rs.i128Debug(b, f), (f: rs.Formatter) => rs.i128LowerHex(a, f), (f: rs.Formatter) => rs.i128UpperHex(b, f), (f: rs.Formatter) => rs.i128Octal(c, f), (f: rs.Formatter) => rs.i128Binary(a, f), (f: rs.Formatter) => rs.i128Display(b, f), (f: rs.Formatter) => rs.i128LowerHex(c, f), (f: rs.Formatter) => rs.i128Debug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.i128[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.i128WrappingAdd, 0); + const all: rs.i128[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.i128WrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.i128WrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.i128WrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.i128WrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.i128WrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.i128WrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.i128WrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i128WrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i128WrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.i128WrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.i128WrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_i128(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_i128(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_i128(x7), hashed$num_Wrapping_i128(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_i128(x7); - z._0 = rt.i128WrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_i128(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_i128(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_i128(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_i128(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_i128(x7), hashed$num_Wrapping_i128(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_i128(x7); + z._0 = rs.i128WrappingSub(z._0, y._0); _30(out, z._0); } } @@ -2248,48 +2248,48 @@ export function i128s(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { * Apply operation `kind` to `Wrapping`s taken from `data`: three operands, then a * shift amount, which may pass the width many times over. */ -export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _30: (a0: rt.ByteVec, a1: rt.isize) => undefined = (out2: rt.ByteVec, v: rt.isize): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.isizeToBeBytes(v))); +export function isizes(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _30: (a0: rs.ByteVec, a1: rs.isize) => undefined = (out2: rs.ByteVec, v: rs.isize): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.isizeToBeBytes(v))); }; - const take: (a0: rt.usize) => rt.isize = (at: rt.usize): rt.isize => { - const buf: Uint8Array = rt.bytes(4); - const iter3: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceFrom(buf)))); + const take: (a0: rs.usize) => rs.isize = (at: rs.usize): rs.isize => { + const buf: Uint8Array = rs.bytes(4); + const iter3: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceFrom(buf)))); while (true) { - const _10: [rt.usize, rt.Place] | rt.Done = iter3.next(); - if (_10 === rt.DONE) { + const _10: [rs.usize, rs.Place] | rs.Done = iter3.next(); + if (_10 === rs.DONE) { break; } - _10[1].v = option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(at, _10[0])), 0); + _10[1].v = option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(at, _10[0])), 0); } - return rt.isizeFromBeBytes(buf); + return rs.isizeFromBeBytes(buf); }; - const _8: [rt.isize, rt.isize, rt.isize] = [take(0), take(4), take(2 * 4)]; - const a: rt.isize = _8[0]; - const b: rt.isize = _8[1]; - const c: rt.isize = _8[2]; - const byte: (a0: rt.usize) => rt.u8 = (i2: rt.usize): rt.u8 => { - return option_unwrapOr$0r2bmpr(rt.byteSliceGet(data, rt.usizeAdd(3 * 4, i2)), 0); + const _8: [rs.isize, rs.isize, rs.isize] = [take(0), take(4), take(2 * 4)]; + const a: rs.isize = _8[0]; + const b: rs.isize = _8[1]; + const c: rs.isize = _8[2]; + const byte: (a0: rs.usize) => rs.u8 = (i2: rs.usize): rs.u8 => { + return option_unwrapOr$1fr498u(rs.byteSliceGet(data, rs.usizeAdd(3 * 4, i2)), 0); }; - const n: rt.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rt.usize; - const _31: rt.u8 = rt.u8Rem(kind, 24); + const n: rs.usize = ((byte(1) << 24) | byte(0)) >>> 0 as rs.usize; + const _31: rs.u8 = rs.u8Rem(kind, 24); if (_31 === 0) { - const part45 = rt.isizeWrappingAdd(a, b); + const part45 = rs.isizeWrappingAdd(a, b); _30(out, part45); } else if (_31 === 1) { - const part44 = rt.isizeWrappingSub(a, b); + const part44 = rs.isizeWrappingSub(a, b); _30(out, part44); } else if (_31 === 2) { - const part43 = rt.isizeWrappingMul(a, b); + const part43 = rs.isizeWrappingMul(a, b); _30(out, part43); } else if (_31 === 3) { - const part42 = rt.isizeWrappingDiv(a, b); + const part42 = rs.isizeWrappingDiv(a, b); _30(out, part42); } else if (_31 === 4) { - const part41 = rt.isizeWrappingRem(a, b); + const part41 = rs.isizeWrappingRem(a, b); _30(out, part41); } else if (_31 === 5) { - const part40 = rt.isizeWrappingSub(0, a); + const part40 = rs.isizeWrappingSub(0, a); _30(out, part40); } else if (_31 === 6) { _30(out, ~a); @@ -2300,131 +2300,131 @@ export function isizes(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else if (_31 === 9) { _30(out, a ^ b); } else if (_31 === 10) { - _30(out, rt.isizeShl(a, n & 31)); + _30(out, rs.isizeShl(a, n & 31)); } else if (_31 === 11) { - _30(out, rt.isizeShr(a, n & 31)); + _30(out, rs.isizeShr(a, n & 31)); } else if (_31 === 12) { - let x: rt.isize = a; - x = rt.isizeWrappingAdd(x, b); + let x: rs.isize = a; + x = rs.isizeWrappingAdd(x, b); _30(out, x); - x = rt.isizeWrappingMul(x, c); + x = rs.isizeWrappingMul(x, c); _30(out, x); - x = rt.isizeWrappingSub(x, b); + x = rs.isizeWrappingSub(x, b); _30(out, x); } else if (_31 === 13) { - let x2: rt.isize = a; - x2 = rt.isizeWrappingDiv(x2, b); + let x2: rs.isize = a; + x2 = rs.isizeWrappingDiv(x2, b); _30(out, x2); } else if (_31 === 14) { - let x3: rt.isize = a; - x3 = rt.isizeWrappingRem(x3, b); + let x3: rs.isize = a; + x3 = rs.isizeWrappingRem(x3, b); _30(out, x3); } else if (_31 === 15) { - let x4: rt.isize = a; + let x4: rs.isize = a; x4 = x4 & b; x4 = x4 | c; x4 = x4 ^ b; _30(out, x4); } else if (_31 === 16) { - let x5: rt.isize = a; - x5 = rt.isizeShl(x5, n & 31); + let x5: rs.isize = a; + x5 = rs.isizeShl(x5, n & 31); _30(out, x5); - x5 = rt.isizeShr(x5, n & 31); + x5 = rs.isizeShr(x5, n & 31); _30(out, x5); _30(out, (a << 3) | 0); - _30(out, rt.isizeShr(a, rt.usizeAdd(32, 1) & 31)); + _30(out, rs.isizeShr(a, rs.usizeAdd(32, 1) & 31)); } else if (_31 === 17) { - const part15 = rt.isizeWrappingAdd(a, b); + const part15 = rs.isizeWrappingAdd(a, b); _30(out, part15); - const part16 = rt.isizeWrappingSub(a, b); + const part16 = rs.isizeWrappingSub(a, b); _30(out, part16); - const part17 = rt.isizeWrappingMul(a, c); + const part17 = rs.isizeWrappingMul(a, c); _30(out, part17); - const part18 = rt.isizeWrappingSub(0, a); + const part18 = rs.isizeWrappingSub(0, a); _30(out, part18); _30(out, ~b); - _30(out, rt.isizeShl(a, n & 31)); - _30(out, rt.isizeShr(a, n & 31)); + _30(out, rs.isizeShl(a, n & 31)); + _30(out, rs.isizeShr(a, n & 31)); _30(out, a ^ c); - let x6: rt.isize = a; - x6 = rt.isizeWrappingAdd(x6, b); - x6 = rt.isizeShl(x6, n & 31); + let x6: rs.isize = a; + x6 = rs.isizeWrappingAdd(x6, b); + x6 = rs.isizeShl(x6, n & 31); _30(out, x6); } else if (_31 === 18) { const _191: boolean = a === b; const _194: boolean = a !== b; - const _197: boolean = rt.cmp(a, b) === -1; - const order = rt.cmp(a, b); + const _197: boolean = rs.cmp(a, b) === -1; + const order = rs.cmp(a, b); const _200: boolean = order !== undefined && order <= 0; - const _203: boolean = rt.cmp(a, b) === 1; - const order2 = rt.cmp(a, b); - const iter: rt.Iter = rt.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rt.cmp(a, b) < 0, isSomeAnd$08u1px1(rt.cmp(a, c), (o: rt.Ordering): boolean => { + const _203: boolean = rs.cmp(a, b) === 1; + const order2 = rs.cmp(a, b); + const iter: rs.Iter = rs.iterSlice([_191, _194, _197, _200, _203, order2 !== undefined && order2 >= 0, rs.cmp(a, b) < 0, isSomeAnd$0dtzjhd(rs.cmp(a, c), (o: rs.Ordering): boolean => { return o > 0; })]); while (true) { - const _219: boolean | rt.Done = iter.next(); - if (_219 === rt.DONE) { + const _219: boolean | rs.Done = iter.next(); + if (_219 === rs.DONE) { break; } - rt.byteVecPush(out, _219 ? 1 : 0); + rs.byteVecPush(out, _219 ? 1 : 0); } - const part12 = rt.ordMax(a, b, rt.cmpLt(rt.cmp)); + const part12 = rs.ordMax(a, b, rs.cmpLt(rs.cmp)); _30(out, part12); - const part13 = rt.ordMin(a, c, rt.cmpLt(rt.cmp)); + const part13 = rs.ordMin(a, c, rs.cmpLt(rs.cmp)); _30(out, part13); - const _237: rt.isize = rt.ordMin(b, c, rt.cmpLt(rt.cmp)); - const _238: rt.isize = rt.ordMax(b, c, rt.cmpLt(rt.cmp)); - const part14 = rt.ordClamp(a, _237, _238, rt.cmpLe(rt.cmp), rt.cmpLt(rt.cmp), rt.cmpGt(rt.cmp)); + const _237: rs.isize = rs.ordMin(b, c, rs.cmpLt(rs.cmp)); + const _238: rs.isize = rs.ordMax(b, c, rs.cmpLt(rs.cmp)); + const part14 = rs.ordClamp(a, _237, _238, rs.cmpLe(rs.cmp), rs.cmpLt(rs.cmp), rs.cmpGt(rs.cmp)); _30(out, part14); } else if (_31 === 19) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hashed$num_Wrapping_isize(a)))); - rt.byteVecPush(out, rt.u64Eq(hashed$num_Wrapping_isize(a), hashed$isize(a)) ? 1 : 0); - const _253: rt.Iter = rt.iterSlice([a, b, c, a]); - const iter2: rt.Iter = rt.btreeKeys(rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, _253, true, undefined, undefined, 4, true)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hashed$num_Wrapping_isize(a)))); + rs.byteVecPush(out, rs.u64Eq(hashed$num_Wrapping_isize(a), hashed$isize(a)) ? 1 : 0); + const _253: rs.Iter = rs.iterSlice([a, b, c, a]); + const iter2: rs.Iter = rs.btreeKeys(rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, _253, true, undefined, undefined, 4, true)); while (true) { - const _258: rt.isize | rt.Done = iter2.next(); - if (_258 === rt.DONE) { + const _258: rs.isize | rs.Done = iter2.next(); + if (_258 === rs.DONE) { break; } _30(out, _258); } - const _267: rt.Iter = rt.iterSlice([a, b]); - const seen: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(rt.hashIsize, rt.same)) as rt.HashSet, _267, undefined, undefined, 234881024); - rt.byteVecPush(out, rt.hashContains(seen, c) ? 1 : 0); - rt.byteVecPush(out, rt.hashLen(seen) & 0xff); + const _267: rs.Iter = rs.iterSlice([a, b]); + const seen: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(rs.hashIsize, rs.same)) as rs.HashSet, _267, undefined, undefined, 234881024); + rs.byteVecPush(out, rs.hashContains(seen, c) ? 1 : 0); + rs.byteVecPush(out, rs.hashLen(seen) & 0xff); } else if (_31 === 20) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.isizeDisplay(a, f), (f: rt.Formatter) => rt.isizeDebug(b, f), (f: rt.Formatter) => rt.isizeLowerHex(a, f), (f: rt.Formatter) => rt.isizeUpperHex(b, f), (f: rt.Formatter) => rt.isizeOctal(c, f), (f: rt.Formatter) => rt.isizeBinary(a, f), (f: rt.Formatter) => rt.isizeDisplay(b, f), (f: rt.Formatter) => rt.isizeLowerHex(c, f), (f: rt.Formatter) => rt.isizeDebug(a, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rt.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rt.fmtSpec({ alternate: true }, args2[7]), " ", rt.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rt.fmtSpec({ plus: true }, args2[6])]))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.isizeDisplay(a, f), (f: rs.Formatter) => rs.isizeDebug(b, f), (f: rs.Formatter) => rs.isizeLowerHex(a, f), (f: rs.Formatter) => rs.isizeUpperHex(b, f), (f: rs.Formatter) => rs.isizeOctal(c, f), (f: rs.Formatter) => rs.isizeBinary(a, f), (f: rs.Formatter) => rs.isizeDisplay(b, f), (f: rs.Formatter) => rs.isizeLowerHex(c, f), (f: rs.Formatter) => rs.isizeDebug(a, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3], " ", args2[4], " ", args2[5], " ", rs.fmtSpec({ align: ">", width: 6 }, args2[6]), " ", rs.fmtSpec({ alternate: true }, args2[7]), " ", rs.fmtSpec({ zero: true, width: 8 }, args2[8]), " ", rs.fmtSpec({ plus: true }, args2[6])]))); } else if (_31 === 21) { - const all: rt.isize[] = [a, b, c]; - const part6 = rt.iterSum(rt.iterSlice(all), rt.isizeWrappingAdd, 0); + const all: rs.isize[] = [a, b, c]; + const part6 = rs.iterSum(rs.iterSlice(all), rs.isizeWrappingAdd, 0); _30(out, part6); - const part7 = rt.iterSum(rt.iterSlice(all), rt.isizeWrappingAdd, 0); + const part7 = rs.iterSum(rs.iterSlice(all), rs.isizeWrappingAdd, 0); _30(out, part7); - const part8 = rt.iterProduct(rt.iterSlice(all), rt.isizeWrappingMul, 1); + const part8 = rs.iterProduct(rs.iterSlice(all), rs.isizeWrappingMul, 1); _30(out, part8); - const part9 = rt.iterProduct(rt.iterSlice(all), rt.isizeWrappingMul, 1); + const part9 = rs.iterProduct(rs.iterSlice(all), rs.isizeWrappingMul, 1); _30(out, part9); - const part10 = rt.iterSum(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.isizeWrappingAdd, 0); + const part10 = rs.iterSum(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.isizeWrappingAdd, 0); _30(out, part10); - const part11 = rt.iterProduct(rt.iterSlice(rt.sliceRange(all, 0, 0)), rt.isizeWrappingMul, 1); + const part11 = rs.iterProduct(rs.iterSlice(rs.sliceRange(all, 0, 0)), rs.isizeWrappingMul, 1); _30(out, part11); } else if (_31 === 22) { _30(out, 0); _30(out, a); _30(out, a); } else { - const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; - const x7: Tick.Tick = _357[0]; - const y: Tick.Tick = _357[1]; - const _365: Tick.Tick = Tick.default$Default_isize(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rt.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1]]))); - rt.byteVecPush(out, Tick.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); - rt.byteVecPush(out, Tick.cmp$cmp_Ord_isize(x7, y) & 0xff); - rt.byteVecPush(out, rt.u64Eq(hashed$wraps_Tick_isize(x7), hashed$num_Wrapping_isize(a)) ? 1 : 0); - const z: Tick.Tick = copy$wraps_Tick_isize(x7); - z._0 = rt.isizeWrappingSub(z._0, y._0); + const _357: [Tick.Tick, Tick.Tick] = [new Tick.Tick(a), new Tick.Tick(b)]; + const x7: Tick.Tick = _357[0]; + const y: Tick.Tick = _357[1]; + const _365: Tick.Tick = Tick.default$Default_isize(); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(x7, f), (f: rs.Formatter) => Tick.fmt$fmt_Debug_isize(_365, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1]]))); + rs.byteVecPush(out, Tick.eq$cmp_PartialEq_isize(x7, y) ? 1 : 0); + rs.byteVecPush(out, Tick.cmp$cmp_Ord_isize(x7, y) & 0xff); + rs.byteVecPush(out, rs.u64Eq(hashed$wraps_Tick_isize(x7), hashed$num_Wrapping_isize(a)) ? 1 : 0); + const z: Tick.Tick = copy$wraps_Tick_isize(x7); + z._0 = rs.isizeWrappingSub(z._0, y._0); _30(out, z._0); } } diff --git a/ts/fixtures/lang/zeros/expected/core/bool.ts b/ts/fixtures/lang/zeros/expected/core/bool.ts index 91286d446..5c07a116e 100644 --- a/ts/fixtures/lang/zeros/expected/core/bool.ts +++ b/ts/fixtures/lang/zeros/expected/core/bool.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { +export function thenSome$1n1oy1h(self: boolean, _: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return undefined; } diff --git a/ts/fixtures/lang/zeros/expected/core/option.ts b/ts/fixtures/lang/zeros/expected/core/option.ts index cba46e081..9210f934d 100644 --- a/ts/fixtures/lang/zeros/expected/core/option.ts +++ b/ts/fixtures/lang/zeros/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Loud from "../zeros.Loud.ts"; import * as Tagged from "../zeros.Tagged.ts"; @@ -11,7 +11,7 @@ export function unwrapOr$1la41a6(self: Uint8Array | undefined, default_: Uint8Ar return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } @@ -25,28 +25,28 @@ export function unwrapOrDefault$1b97y1a(self: Tagged.Tagged | undefined) return self; } -export function map$1cosm7d(self: rt.Vec | undefined, f: (a0: rt.Vec) => Uint8Array): Uint8Array | undefined { +export function map$1b6tbot(self: rs.Vec | undefined, f: (a0: rs.Vec) => Uint8Array): Uint8Array | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1qp1ym6(self: rt.u8 | undefined, f: (a0: rt.u8) => rt.u32): rt.u32 | undefined { +export function map$12cu62z(self: rs.u8 | undefined, f: (a0: rs.u8) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1ibcmaa(self: rt.u8 | undefined, f: (a0: rt.u8) => Loud.Loud): Loud.Loud | undefined { +export function map$0ul65ro(self: rs.u8 | undefined, f: (a0: rs.u8) => Loud.Loud): Loud.Loud | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1iwwjee(self: rt.u8 | undefined, f: (a0: rt.u8) => Uint8Array): Uint8Array | undefined { +export function map$0w716ia(self: rs.u8 | undefined, f: (a0: rs.u8) => Uint8Array): Uint8Array | undefined { if (self === undefined) { return undefined; } diff --git a/ts/fixtures/lang/zeros/expected/harness.ts b/ts/fixtures/lang/zeros/expected/harness.ts index be427c737..ecf6757a6 100644 --- a/ts/fixtures/lang/zeros/expected/harness.ts +++ b/ts/fixtures/lang/zeros/expected/harness.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { cases } from "./lib.ts"; /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 3)) { return out; } - const cases_: rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rt.usize, cases_.items.length))][1](input.data[input.start + 2], new rt.ByteSlice(input.data, input.start + 3, input.length - 3), out); + const cases_: rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(((input.data[input.start] << 8) | input.data[input.start + 1]) as rs.usize, cases_.items.length))][1](input.data[input.start + 2], new rs.ByteSlice(input.data, input.start + 3, input.length - 3), out); return out; } @@ -18,22 +18,22 @@ export function run(input: rt.ByteSlice): rt.ByteVec { * The first two bytes, as one big-endian number, that pick the case named `name`, which * `lang.ts` targets by. */ -export function op(name: string): rt.u16 { - const _11: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_2: [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u16 { + const _11: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_2: [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]): boolean => { return _2[0] === name; }); if (_11 !== undefined) { - const _20: rt.Result = rt.u16TryFrom(_11); + const _20: rs.Result = rs.u16TryFrom(_11); if (_20.ok) { if ((_20.value >> 8) !== 255) { return _20.value; } } - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["case ", args4[0], " is past what two bytes pick"]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["case ", args4[0], " is past what two bytes pick"]); } else { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } } diff --git a/ts/fixtures/lang/zeros/expected/lib.ts b/ts/fixtures/lang/zeros/expected/lib.ts index 854f90c8a..b388545f6 100644 --- a/ts/fixtures/lang/zeros/expected/lib.ts +++ b/ts/fixtures/lang/zeros/expected/lib.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { zeros, impls, keys, unread, writes } from "./zeros.ts"; import * as Lock from "./zeros.Lock.ts"; import type * as Loud from "./zeros.Loud.ts"; -export function drop$zeros_Lock_u32(_1: Lock.Lock): void { +export function drop$zeros_Lock_u32(_1: Lock.Lock): void { Lock.drop$ops_Drop_u32(_1); } @@ -17,10 +17,10 @@ export function drop$zeros_Lock_zeros_Loud(_1: Lock.Lock): void { * Each case's name and what it runs. The first two bytes, big-endian, pick one modulo * their count, so a case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]> { - return rt.vecFrom([["zeros::zeros", zeros as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::impls", impls as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::keys", keys as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::unread", unread as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["zeros::writes", (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]> { + return rs.vecFrom([["zeros::zeros", zeros as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["zeros::impls", impls as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["zeros::keys", keys as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["zeros::unread", unread as (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined], ["zeros::writes", (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec): undefined => { writes(a0, a1.data, a1.start, a1.length, a2); - }] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.u8, a1: rs.ByteSlice, a2: rs.ByteVec) => undefined]]); } //# sourceMappingURL=lib.ts.map diff --git a/ts/fixtures/lang/zeros/expected/zeros.Lock.ts b/ts/fixtures/lang/zeros/expected/zeros.Lock.ts index 52bc3aecf..9a2401c46 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Lock.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Lock.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Loud from "./zeros.Loud.ts"; /** @@ -9,23 +9,23 @@ import * as Loud from "./zeros.Loud.ts"; */ export class Lock { set: boolean; - value: rt.Cell; + value: rs.Cell; - constructor(set: boolean, value: rt.Cell) { + constructor(set: boolean, value: rs.Cell) { this.set = set; this.value = value; } } -export function new$u32(value: rt.u32 | undefined): Lock { - let value2!: rt.u32; +export function new$u32(value: rs.u32 | undefined): Lock { + let value2!: rs.u32; const set: boolean = value !== undefined; if (value === undefined) { - value2 = (undefined as unknown) as rt.u32; + value2 = (undefined as unknown) as rs.u32; } else { value2 = value; } - return new Lock(set, new rt.Cell(value2)); + return new Lock(set, new rs.Cell(value2)); } export function new$zeros_Loud(value: Loud.Loud | undefined): Lock { @@ -36,10 +36,10 @@ export function new$zeros_Loud(value: Loud.Loud | undefined): Lock { } else { value2 = value; } - return new Lock(set, new rt.Cell(value2)); + return new Lock(set, new rs.Cell(value2)); } -export function drop$ops_Drop_u32(_self: Lock): void { +export function drop$ops_Drop_u32(_self: Lock): void { } export function drop$ops_Drop_zeros_Loud(self: Lock): void { diff --git a/ts/fixtures/lang/zeros/expected/zeros.Names.ts b/ts/fixtures/lang/zeros/expected/zeros.Names.ts index 089208756..7334582cc 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Names.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Names.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Names): Names { self._0; @@ -16,9 +16,9 @@ export function clone$Clone(self: Names): Names { return { _0: undefined, _1: undefined, _2: undefined, _3: undefined, _4: undefined, _5: undefined, _6: undefined, _7: undefined, _8: undefined, _9: undefined }; } -export function fmt$fmt_Debug(_self: Names, f: rt.Formatter): rt.Result { - const values: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "(i64, bool)", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "&str", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "[u16; 3]", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "alloc::vec::Vec>", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "fn(u8) -> u8", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Unit", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Tagged<()>", ">"]), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "()", ">"])]; - return rt.fmtDebugTupleFields(f, "Names", values); +export function fmt$fmt_Debug(_self: Names, f: rs.Formatter): rs.Result { + const values: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "(i64, bool)", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "&str", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "[u16; 3]", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::vec::Vec>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "fn(u8) -> u8", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Unit", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "lang_zeros_fixture::zeros::Tagged<()>", ">"]), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "()", ">"])]; + return rs.fmtDebugTupleFields(f, "Names", values); } export function default$Default(): Names { @@ -58,26 +58,26 @@ export function eq$cmp_PartialEq(_self: Names, _other: Names): boolean { return false; } -export function cmp$cmp_Ord(self: Names, other: Names): rt.Ordering { - const cmp: rt.Ordering = rt.cmpNothing(self._0, other._0); +export function cmp$cmp_Ord(self: Names, other: Names): rs.Ordering { + const cmp: rs.Ordering = rs.cmpNothing(self._0, other._0); if (cmp === 0) { - const cmp2: rt.Ordering = rt.cmpNothing(self._1, other._1); + const cmp2: rs.Ordering = rs.cmpNothing(self._1, other._1); if (cmp2 === 0) { - const cmp3: rt.Ordering = rt.cmpNothing(self._2, other._2); + const cmp3: rs.Ordering = rs.cmpNothing(self._2, other._2); if (cmp3 === 0) { - const cmp4: rt.Ordering = rt.cmpNothing(self._3, other._3); + const cmp4: rs.Ordering = rs.cmpNothing(self._3, other._3); if (cmp4 === 0) { - const cmp5: rt.Ordering = rt.cmpNothing(self._4, other._4); + const cmp5: rs.Ordering = rs.cmpNothing(self._4, other._4); if (cmp5 === 0) { - const cmp6: rt.Ordering = rt.cmpNothing(self._5, other._5); + const cmp6: rs.Ordering = rs.cmpNothing(self._5, other._5); if (cmp6 === 0) { - const cmp7: rt.Ordering = rt.cmpNothing(self._6, other._6); + const cmp7: rs.Ordering = rs.cmpNothing(self._6, other._6); if (cmp7 === 0) { - const cmp8: rt.Ordering = rt.cmpNothing(self._7, other._7); + const cmp8: rs.Ordering = rs.cmpNothing(self._7, other._7); if (cmp8 === 0) { - const cmp9: rt.Ordering = rt.cmpNothing(self._8, other._8); + const cmp9: rs.Ordering = rs.cmpNothing(self._8, other._8); if (cmp9 === 0) { - return rt.cmpNothing(self._9, other._9); + return rs.cmpNothing(self._9, other._9); } return cmp9; } @@ -98,17 +98,17 @@ export function cmp$cmp_Ord(self: Names, other: Names): rt.Ordering { return cmp; } -export function hash$Hash_hash_DefaultHasher(self: Names, state: rt.Hasher): void { - rt.hashNothing(self._0, state); - rt.hashNothing(self._1, state); - rt.hashNothing(self._2, state); - rt.hashNothing(self._3, state); - rt.hashNothing(self._4, state); - rt.hashNothing(self._5, state); - rt.hashNothing(self._6, state); - rt.hashNothing(self._7, state); - rt.hashNothing(self._8, state); - rt.hashNothing(self._9, state); +export function hash$Hash_hash_DefaultHasher(self: Names, state: rs.Hasher): void { + rs.hashNothing(self._0, state); + rs.hashNothing(self._1, state); + rs.hashNothing(self._2, state); + rs.hashNothing(self._3, state); + rs.hashNothing(self._4, state); + rs.hashNothing(self._5, state); + rs.hashNothing(self._6, state); + rs.hashNothing(self._7, state); + rs.hashNothing(self._8, state); + rs.hashNothing(self._9, state); } /** `PhantomData` of several types, whose `Debug` names each. */ diff --git a/ts/fixtures/lang/zeros/expected/zeros.One.ts b/ts/fixtures/lang/zeros/expected/zeros.One.ts index ae49b508a..d2f5a674b 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.One.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.One.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(_self: One): One { return "Only" as One; } -export function fmt$fmt_Debug(_self: One, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Only"); +export function fmt$fmt_Debug(_self: One, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Only"); } export function eq$cmp_PartialEq(_self: One, _other: One): boolean { diff --git a/ts/fixtures/lang/zeros/expected/zeros.Rest.ts b/ts/fixtures/lang/zeros/expected/zeros.Rest.ts index 063be0180..462d31760 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Rest.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Rest.ts @@ -1,30 +1,30 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Rest): Rest { self._0; - rt.iterEmpty() as rt.Iter; - return { _0: undefined, _1: rt.iterEmpty() as rt.Iter }; + rs.iterEmpty() as rs.Iter; + return { _0: undefined, _1: rs.iterEmpty() as rs.Iter }; } -export function fmt$fmt_Debug(self: Rest, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Rest, f: rs.Formatter): rs.Result { const _3: string = "Rest"; - const _4: rt.Fmt = (f: rt.Formatter) => rt.fmtRangeFull(self._0, f); - const _6: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteStr(f, "Empty"); - return rt.debugTupleFinish(rt.debugTupleField(rt.debugTupleField(rt.fmtDebugTuple(f, _3), _4), _6)); + const _4: rs.Fmt = (f: rs.Formatter) => rs.fmtRangeFull(self._0, f); + const _6: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "Empty"); + return rs.debugTupleFinish(rs.debugTupleField(rs.debugTupleField(rs.fmtDebugTuple(f, _3), _4), _6)); } export function default$Default(): Rest { undefined; - rt.iterEmpty() as rt.Iter; - return { _0: undefined, _1: rt.iterEmpty() as rt.Iter }; + rs.iterEmpty() as rs.Iter; + return { _0: undefined, _1: rs.iterEmpty() as rs.Iter }; } /** `..` and `Empty`, whose impls are std's own, of what each has. */ export interface Rest { _0: undefined; - _1: rt.Iter; + _1: rs.Iter; } //# sourceMappingURL=zeros.Rest.ts.map diff --git a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts index ffa914a63..9c715e053 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Tagged.ts @@ -1,50 +1,50 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone_String(self: Tagged): Tagged { - const _2: rt.u8 = self.n; + const _2: rs.u8 = self.n; self.of; self.pin; return { n: _2, of: undefined, pin: undefined, unit: undefined }; } -export function fmt$fmt_Debug_String(self: Tagged, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_String(self: Tagged, f: rs.Formatter): rs.Result { const _3: string = "Tagged"; const _4: string = "n"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.n, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); const _7: string = "of"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "alloc::string::String", ">"]); const _10: string = "pin"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteStr(f, "PhantomPinned"); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"); const _13: string = "unit"; - const _14: rt.Fmt = (f: rt.Formatter) => rt.fmtUnit(self.unit, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); + const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self.unit, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); } -export function fmt$fmt_Debug_u8(self: Tagged, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug_u8(self: Tagged, f: rs.Formatter): rs.Result { const _3: string = "Tagged"; const _4: string = "n"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.u8Debug(self.n, f); + const _5: rs.Fmt = (f: rs.Formatter) => rs.u8Debug(self.n, f); const _7: string = "of"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"]); const _10: string = "pin"; - const _11: rt.Fmt = (f: rt.Formatter) => rt.fmtWriteStr(f, "PhantomPinned"); + const _11: rs.Fmt = (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"); const _13: string = "unit"; - const _14: rt.Fmt = (f: rt.Formatter) => rt.fmtUnit(self.unit, f); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); + const _14: rs.Fmt = (f: rs.Formatter) => rs.fmtUnit(self.unit, f); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8), _10, _11), _13, _14)); } export function default$Default_String(): Tagged { - const _1: rt.u8 = 0; + const _1: rs.u8 = 0; undefined; undefined; undefined; return { n: _1, of: undefined, pin: undefined, unit: undefined }; } -export function default$Default_u8(): Tagged { - const _1: rt.u8 = 0; +export function default$Default_u8(): Tagged { + const _1: rs.u8 = 0; undefined; undefined; undefined; @@ -62,17 +62,17 @@ export function eq$cmp_PartialEq_String(self: Tagged, other: Tagged, other: Tagged): rt.Ordering | undefined { - const cmp: rt.Ordering | undefined = rt.cmp(self.n, other.n); +export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Tagged): rs.Ordering | undefined { + const cmp: rs.Ordering | undefined = rs.cmp(self.n, other.n); if (cmp !== undefined) { if (cmp === 0) { - const cmp2: rt.Ordering | undefined = rt.cmpNothing(self.of, other.of); + const cmp2: rs.Ordering | undefined = rs.cmpNothing(self.of, other.of); if (cmp2 !== undefined) { if (cmp2 === 0) { - const cmp3: rt.Ordering | undefined = rt.cmpNothing(self.pin, other.pin); + const cmp3: rs.Ordering | undefined = rs.cmpNothing(self.pin, other.pin); if (cmp3 !== undefined) { if (cmp3 === 0) { - return rt.cmpNothing(self.unit, other.unit); + return rs.cmpNothing(self.unit, other.unit); } } return cmp3; @@ -84,14 +84,14 @@ export function partialCmp$cmp_PartialOrd_String(self: Tagged, other: Ta return cmp; } -export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rt.Ordering { - const cmp: rt.Ordering = rt.cmp(self.n, other.n); +export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): rs.Ordering { + const cmp: rs.Ordering = rs.cmp(self.n, other.n); if (cmp === 0) { - const cmp2: rt.Ordering = rt.cmpNothing(self.of, other.of); + const cmp2: rs.Ordering = rs.cmpNothing(self.of, other.of); if (cmp2 === 0) { - const cmp3: rt.Ordering = rt.cmpNothing(self.pin, other.pin); + const cmp3: rs.Ordering = rs.cmpNothing(self.pin, other.pin); if (cmp3 === 0) { - return rt.cmpNothing(self.unit, other.unit); + return rs.cmpNothing(self.unit, other.unit); } return cmp3; } @@ -100,16 +100,16 @@ export function cmp$cmp_Ord_String(self: Tagged, other: Tagged): return cmp; } -export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rt.Hasher): void { - rt.hash8(self.n, state); - rt.hashNothing(self.of, state); - rt.hashNothing(self.pin, state); - rt.hashNothing(self.unit, state); +export function hash$Hash_String_hash_DefaultHasher(self: Tagged, state: rs.Hasher): void { + rs.hash8(self.n, state); + rs.hashNothing(self.of, state); + rs.hashNothing(self.pin, state); + rs.hashNothing(self.unit, state); } /** Each derivable impl, on fields of std's zero-sized types beside one that isn't. */ export interface Tagged<_T> { - n: rt.u8; + n: rs.u8; of: undefined; pin: undefined; unit: undefined; diff --git a/ts/fixtures/lang/zeros/expected/zeros.Unit.ts b/ts/fixtures/lang/zeros/expected/zeros.Unit.ts index aa756d729..1b23aba49 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.Unit.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.Unit.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(_self: Unit): Unit { return {}; } -export function fmt$fmt_Debug(_self: Unit, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Unit"); +export function fmt$fmt_Debug(_self: Unit, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Unit"); } export function default$Default(): Unit { diff --git a/ts/fixtures/lang/zeros/expected/zeros.ts b/ts/fixtures/lang/zeros/expected/zeros.ts index 31adefb03..f7d55c4b4 100644 --- a/ts/fixtures/lang/zeros/expected/zeros.ts +++ b/ts/fixtures/lang/zeros/expected/zeros.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$zeros_Lock_u32, drop$zeros_Lock_zeros_Loud } from "./lib.ts"; -import { thenSome$1j8foe9 } from "./core/bool.ts"; -import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOrDefault$1b97y1a as option_unwrapOrDefault$1b97y1a, map$1cosm7d as option_map$1cosm7d, map$1qp1ym6 as option_map$1qp1ym6, map$1ibcmaa as option_map$1ibcmaa, map$1iwwjee as option_map$1iwwjee } from "./core/option.ts"; +import { thenSome$1n1oy1h } from "./core/bool.ts"; +import { unwrapOr$1la41a6 as option_unwrapOr$1la41a6, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOrDefault$1b97y1a as option_unwrapOrDefault$1b97y1a, map$1b6tbot as option_map$1b6tbot, map$12cu62z as option_map$12cu62z, map$0ul65ro as option_map$0ul65ro, map$0w716ia as option_map$0w716ia } from "./core/option.ts"; import * as Both from "./zeros.Both.ts"; import * as Defaulted from "./zeros.Defaulted.ts"; import * as Holds from "./zeros.Holds.ts"; @@ -17,10 +17,10 @@ import * as Rest from "./zeros.Rest.ts"; import * as Tagged from "./zeros.Tagged.ts"; import * as Unit from "./zeros.Unit.ts"; -export const LOG: rt.Atomic = /* @__PURE__ */ new rt.Atomic(0); +export const LOG: rs.Atomic = /* @__PURE__ */ new rs.Atomic(0); -export function log(tag: rt.u32): void { - rt.atomicStore(LOG, (((rt.atomicLoad(LOG, 0) << 4) >>> 0) | tag) >>> 0, 0); +export function log(tag: rs.u32): void { + rs.atomicStore(LOG, (((rs.atomicLoad(LOG, 0) << 4) >>> 0) | tag) >>> 0, 0); } export function unit(): Unit.Unit { @@ -51,9 +51,9 @@ export function phantom$u8(): undefined { return undefined; } -export function adder(): (a0: rt.u8) => rt.u8 { - return (b: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(b, 1); +export function adder(): (a0: rs.u8) => rs.u8 { + return (b: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(b, 1); }; } @@ -66,62 +66,62 @@ export function made$zeros_Unit(): Unit.Unit { } /** The case `kind` picks, on `data`; each puts what it read. */ -export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const _72: (a0: rt.u8) => One.One = (_2: rt.u8): One.One => { +export function zeros(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const _72: (a0: rs.u8) => One.One = (_2: rs.u8): One.One => { return "Only" as One.One; }; - rt.atomicStore(LOG, 0, 0); - const n: rt.usize = data.length; - const _8: rt.u8 = rt.u8Rem(kind, 7); + rs.atomicStore(LOG, 0, 0); + const n: rs.usize = data.length; + const _8: rs.u8 = rs.u8Rem(kind, 7); if (_8 === 0) { const _11: Unit.Unit = Unit.clone$Clone({}); const _13: Pair.Pair = Pair.clone$Clone(pair()); const _16: Unit.Unit = made$zeros_Unit(); phantom$u8(); - rt.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(_11, {}) ? 1 : 0) | (((Unit.eq$cmp_PartialEq(_13._0, _16) ? 1 : 0) << 1) & 0xff)); const _40: One.One = One.clone$Clone("Only" as One.One); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rt.Formatter) => One.fmt$fmt_Debug(_40, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1]])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_11, f), (f: rs.Formatter) => One.fmt$fmt_Debug(_40, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1]])), undefined, true); } else if (_8 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_213: rt.u8): Uint8Array => { + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_213: rs.u8): Uint8Array => { return Uint8Array.of(); })) & 0xff); - rt.byteVecPush(out, rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_214: rt.u8): Unit.Unit => { + rs.byteVecPush(out, rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_214: rs.u8): Unit.Unit => { return {}; }), undefined, 0, true).items.length & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFlatten(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_215: rt.u8): Unit.Unit[] => { + rs.byteVecPush(out, rs.iterCount(rs.iterFlatten(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_215: rs.u8): Unit.Unit[] => { return [{}, {}, {}]; - }), (value: Unit.Unit[]) => rt.iterSlice(value), true, 3)) & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_216: rt.u8): Pair.Pair => { + }), (value: Unit.Unit[]) => rs.iterSlice(value), true, 3)) & 0xff); + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_216: rs.u8): Pair.Pair => { return pair(); }), (p: Pair.Pair): boolean => { return Unit.eq$cmp_PartialEq(p._0, { _0: {}, _1: undefined }._0); })) & 0xff); - rt.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); + rs.byteVecPush(out, One.eq$cmp_PartialEq(_72(1), one()) ? 1 : 0); } else if (_8 === 2) { const _87: Unit.Unit = unit(); const _89: string[] = none$String(); const _91: Unit.Unit[] = units(); const _93: One.One = one(); const _95: [undefined, Unit.Unit, Uint8Array] = tuple(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rt.Formatter) => rt.fmtList(_89, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(_91, f, (value: Unit.Unit, f: rt.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rt.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtUnit(_95[0], f), (f: rt.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rt.Formatter) => rt.fmtList(_95[2], f, rt.u8Debug)], f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]])), undefined, true); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Unit.fmt$fmt_Debug(_87, f), (f: rs.Formatter) => rs.fmtList(_89, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(_91, f, (value: Unit.Unit, f: rs.Formatter) => Unit.fmt$fmt_Debug(value, f)), (f: rs.Formatter) => One.fmt$fmt_Debug(_93, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtUnit(_95[0], f), (f: rs.Formatter) => Unit.fmt$fmt_Debug(_95[1], f), (f: rs.Formatter) => rs.fmtList(_95[2], f, rs.u8Debug)], f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", args4[1], " ", args4[2], " ", args4[3], " ", args4[4]])), undefined, true); } else if (_8 === 3) { - const _108: (a0: rt.u8) => rt.u8 = adder(); + const _108: (a0: rs.u8) => rs.u8 = adder(); adder(); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_211: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_211: rs.u8): rs.u8 => { return _108(_211); }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b5: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(b5, 1); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b5: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(b5, 1); }), undefined, true); - const _122: rt.Iter = rt.iterSlice(rt.byteSliceView(data)); + const _122: rs.Iter = rs.iterSlice(rs.byteSliceView(data)); adder(); - rt.iterExtendBytes(out, rt.iterMap(_122, (b6: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(b6, 1); + rs.iterExtendBytes(out, rs.iterMap(_122, (b6: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(b6, 1); }), undefined, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_212: rt.u8): rt.u8 => { - return new Holds.Holds((b: rt.u8): rt.u8 => { + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_212: rs.u8): rs.u8 => { + return new Holds.Holds((b: rs.u8): rs.u8 => { return b ^ 90; })._0(_212); }), undefined, true); @@ -130,192 +130,192 @@ export function zeros(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { new Loud.Loud()[Symbol.dispose](); loud(); new Loud.Loud()[Symbol.dispose](); - const v: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_210: rt.u8): Loud.Loud => { + const v: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_210: rs.u8): Loud.Loud => { return new Loud.Loud(); }), undefined, 0, true); - rt.byteVecPush(out, v.items.length & 0xff); - rt.dropVec(v); + rs.byteVecPush(out, v.items.length & 0xff); + rs.dropVec(v); new Both.Both(new Loud.Loud(), new Quiet.Quiet())[Symbol.dispose](); new Quiet.Quiet()[Symbol.dispose](); - rt.dropAll([new Quiet.Quiet(), new Quiet.Quiet()]); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicLoad(LOG, 0))), undefined, true); + rs.dropAll([new Quiet.Quiet(), new Quiet.Quiet()]); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicLoad(LOG, 0))), undefined, true); } else if (_8 === 5) { - const v2: rt.Vec = rt.vecWithCapacity(n, 0); - const _154: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_28: rt.u8): undefined => {}); - rt.iterExtend(v2, _154, undefined, 0, true); - rt.byteVecPush(out, rt.vecFromElem({}, n, undefined).items.length & 0xff); - rt.byteVecPush(out, v2.items.length & 0xff); + const v2: rs.Vec = rs.vecWithCapacity(n, 0); + const _154: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_28: rs.u8): undefined => {}); + rs.iterExtend(v2, _154, undefined, 0, true); + rs.byteVecPush(out, rs.vecFromElem({}, n, undefined).items.length & 0xff); + rs.byteVecPush(out, v2.items.length & 0xff); } else { - rt.iterFromFn((): rt.u8 | undefined => { + rs.iterFromFn((): rs.u8 | undefined => { return undefined; }); - rt.byteVecPush(out, rt.iterCount(rt.iterFromFn((): rt.u8 | undefined => { + rs.byteVecPush(out, rs.iterCount(rs.iterFromFn((): rs.u8 | undefined => { return undefined; })) & 0xff); - rt.iterFromFn((): Unit.Unit | undefined => { + rs.iterFromFn((): Unit.Unit | undefined => { return {}; }); - rt.byteVecPush(out, rt.iterCount(rt.iterTake(rt.iterFromFn((): Unit.Unit | undefined => { + rs.byteVecPush(out, rs.iterCount(rs.iterTake(rs.iterFromFn((): Unit.Unit | undefined => { return {}; }), n)) & 0xff); let captured = n; - rt.iterExtendBytes(out, rt.iterFromFn((): rt.u8 | undefined => { - const _22: rt.usize | undefined = rt.usizeCheckedSub(captured, 1); + rs.iterExtendBytes(out, rs.iterFromFn((): rs.u8 | undefined => { + const _22: rs.usize | undefined = rs.usizeCheckedSub(captured, 1); if (_22 !== undefined) { captured = _22; return captured & 0xff; } return undefined; }), "next"); - rt.iterEmpty(); - rt.byteVecPush(out, rt.iterMap(rt.iterEmpty() as rt.Iter, (b2: rt.u8): rt.u8 => { - return rt.u8Add(b2, 1); + rs.iterEmpty(); + rs.byteVecPush(out, rs.iterMap(rs.iterEmpty() as rs.Iter, (b2: rs.u8): rs.u8 => { + return rs.u8Add(b2, 1); }).sizeHint()[0] & 0xff); - rt.byteVecPush(out, rt.iterCount(rt.iterMap(rt.iterEmpty() as rt.Iter, (b3: rt.u8): rt.u8 => { - return rt.u8Add(b3, 1); + rs.byteVecPush(out, rs.iterCount(rs.iterMap(rs.iterEmpty() as rs.Iter, (b3: rs.u8): rs.u8 => { + return rs.u8Add(b3, 1); })) & 0xff); - rt.iterEmpty(); - rt.iterEmpty() as rt.Iter; - rt.iterRev(rt.iterEmpty() as rt.Iter); - rt.iterFilter(rt.iterRev(rt.iterEmpty() as rt.Iter), (_23: rt.u8): boolean => { + rs.iterEmpty(); + rs.iterEmpty() as rs.Iter; + rs.iterRev(rs.iterEmpty() as rs.Iter); + rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_23: rs.u8): boolean => { return true; }); - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterRev(rt.iterEmpty() as rt.Iter), (_27: rt.u8): boolean => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterRev(rs.iterEmpty() as rs.Iter), (_27: rs.u8): boolean => { return true; })) & 0xff); } } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$marker_PhantomData_u64(value: undefined): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashNothing(value, h); - return rt.hashFinish(h); +export function hash$marker_PhantomData_u64(value: undefined): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashNothing(value, h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$marker_PhantomPinned(value: undefined): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashNothing(value, h); - return rt.hashFinish(h); +export function hash$marker_PhantomPinned(value: undefined): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashNothing(value, h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$ops_RangeFull(value: undefined): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashNothing(value, h); - return rt.hashFinish(h); +export function hash$ops_RangeFull(value: undefined): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashNothing(value, h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$u8(value: rt.u8): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hash8(value, h); - return rt.hashFinish(h); +export function hash$u8(value: rs.u8): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hash8(value, h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$unit(value: undefined): rt.u64 { - const h: rt.Hasher = rt.hasher(); - rt.hashNothing(value, h); - return rt.hashFinish(h); +export function hash$unit(value: undefined): rs.u64 { + const h: rs.Hasher = rs.hasher(); + rs.hashNothing(value, h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$zeros_Names(value: Names.Names): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hash$zeros_Names(value: Names.Names): rs.u64 { + const h: rs.Hasher = rs.hasher(); Names.hash$Hash_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } /** `DefaultHasher::new`'s hash of `value`. */ -export function hash$zeros_Tagged_String(value: Tagged.Tagged): rt.u64 { - const h: rt.Hasher = rt.hasher(); +export function hash$zeros_Tagged_String(value: Tagged.Tagged): rs.u64 { + const h: rs.Hasher = rs.hasher(); Tagged.hash$Hash_String_hash_DefaultHasher(value, h); - return rt.hashFinish(h); + return rs.hashFinish(h); } /** [`hash`] of `value`, little-endian. */ -export function digest$marker_PhantomData_u64(value: undefined, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$marker_PhantomData_u64(value)).reverse())); +export function digest$marker_PhantomData_u64(value: undefined, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$marker_PhantomData_u64(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$marker_PhantomPinned(value: undefined, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$marker_PhantomPinned(value)).reverse())); +export function digest$marker_PhantomPinned(value: undefined, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$marker_PhantomPinned(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$ops_RangeFull(value: undefined, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$ops_RangeFull(value)).reverse())); +export function digest$ops_RangeFull(value: undefined, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$ops_RangeFull(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$u8(value: rt.u8, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$u8(value)).reverse())); +export function digest$u8(value: rs.u8, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$u8(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$unit(value: undefined, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$unit(value)).reverse())); +export function digest$unit(value: undefined, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$unit(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$zeros_Names(value: Names.Names, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$zeros_Names(value)).reverse())); +export function digest$zeros_Names(value: Names.Names, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$zeros_Names(value)).reverse())); } /** [`hash`] of `value`, little-endian. */ -export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rt.ByteVec): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(hash$zeros_Tagged_String(value)).reverse())); +export function digest$zeros_Tagged_String(value: Tagged.Tagged, out: rs.ByteVec): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(hash$zeros_Tagged_String(value)).reverse())); } /** The impls `#[derive]` calls on `PhantomData`, `PhantomPinned`, and `()` fields. */ -export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - const tags: rt.Vec> = rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): Tagged.Tagged => { - const n: rt.u8 = _2; +export function impls(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + const tags: rs.Vec> = rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): Tagged.Tagged => { + const n: rs.u8 = _2; Tagged.default$Default_String(); return { n, of: undefined, pin: undefined, unit: undefined }; }), undefined, 1, true); - const _7: rt.u8 = rt.u8Rem(kind, 4); + const _7: rs.u8 = rs.u8Rem(kind, 4); if (_7 === 0) { - const _11: Tagged.Tagged | undefined = rt.sliceFirst(tags.items); + const _11: Tagged.Tagged | undefined = rs.sliceFirst(tags.items); const t: Tagged.Tagged = option_unwrapOrDefault$1b97y1a(_11 === undefined ? undefined : Tagged.clone$Clone_String(_11)); - const _15: rt.u8 = t.n; + const _15: rs.u8 = t.n; Tagged.default$Default_u8(); - const copied: Tagged.Tagged = { n: _15, of: undefined, pin: undefined, unit: undefined }; - const again: Tagged.Tagged = copied; + const copied: Tagged.Tagged = { n: _15, of: undefined, pin: undefined, unit: undefined }; + const again: Tagged.Tagged = copied; const _27: Names.Names = Names.default$Default(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rt.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rt.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rt.Formatter) => Names.fmt$fmt_Debug(_27, f)]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", rt.fmtSpec({ alternate: true }, args2[2]), " ", rt.fmtSpec({ alternate: true }, args2[3])])), undefined, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Tagged.fmt$fmt_Debug_String(t, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(copied, f), (f: rs.Formatter) => Tagged.fmt$fmt_Debug_u8(again, f), (f: rs.Formatter) => Names.fmt$fmt_Debug(_27, f)]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", rs.fmtSpec({ alternate: true }, args2[2]), " ", rs.fmtSpec({ alternate: true }, args2[3])])), undefined, true); const _38: Rest.Rest = Rest.clone$Clone(Rest.default$Default()); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rt.Formatter) => rt.fmtWriteStr(f, "PhantomPinned"), (f: rt.Formatter) => rt.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; - rt.iterExtendBytes(out, rt.strBytes(rt.fmtFormat([args4[0], " ", rt.fmtSpec({ alternate: true }, args4[0]), " ", rt.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rt.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"])), undefined, true); - rt.byteVecPush(out, rt.iterCount(rt.iterEmpty() as rt.Iter) & 0xff); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Rest.fmt$fmt_Debug(_38, f), (f: rs.Formatter) => rs.fmtWriteStr(f, "PhantomPinned"), (f: rs.Formatter) => rs.fmtWriteFmt(f, ["PhantomData<", "u8", ">"])]; + rs.iterExtendBytes(out, rs.strBytes(rs.fmtFormat([args4[0], " ", rs.fmtSpec({ alternate: true }, args4[0]), " ", rs.fmtSpec({ align: ">", width: 9 }, args4[1]), "|", rs.fmtSpec({ align: "<", width: 9 }, args4[2]), "|"])), undefined, true); + rs.byteVecPush(out, rs.iterCount(rs.iterEmpty() as rs.Iter) & 0xff); } else if (_7 === 1) { - const sorted: rt.Vec> = rt.vecFrom(tags.items.map(Tagged.clone$Clone_String)); - rt.sliceSort(sorted.items, rt.cmpLt(Tagged.partialCmp$cmp_PartialOrd_String), 1, true); - rt.iterExtendBytes(out, rt.iterMap(rt.iterSlice(sorted.items), (t3: Tagged.Tagged): rt.u8 => { + const sorted: rs.Vec> = rs.vecFrom(tags.items.map(Tagged.clone$Clone_String)); + rs.sliceSort(sorted.items, rs.cmpLt(Tagged.partialCmp$cmp_PartialOrd_String), 1, true); + rs.iterExtendBytes(out, rs.iterMap(rs.iterSlice(sorted.items), (t3: Tagged.Tagged): rs.u8 => { return t3.n; }), undefined, true); - const iter: rt.Iter[]> = rt.sliceWindows(tags.items, 2); + const iter: rs.Iter[]> = rs.sliceWindows(tags.items, 2); while (true) { - const _76: Tagged.Tagged[] | rt.Done = iter.next(); - if (_76 === rt.DONE) { + const _76: Tagged.Tagged[] | rs.Done = iter.next(); + if (_76 === rs.DONE) { break; } - rt.idx(_76, 0); - rt.idx(_76, 1); + rs.idx(_76, 0); + rs.idx(_76, 1); const part = _76[0]; const part2 = _76[1]; const a: Tagged.Tagged = part; const b: Tagged.Tagged = part2; - rt.byteVecPush(out, (Tagged.cmp$cmp_Ord_String(a, b) & 0xff) | (((Tagged.eq$cmp_PartialEq_String(a, b) ? 1 : 0) << 2) & 0xff) | (((Tagged.partialCmp$cmp_PartialOrd_String(a, b) === Tagged.cmp$cmp_Ord_String(a, b) as rt.Ordering | undefined ? 1 : 0) << 3) & 0xff)); - rt.byteVecPush(out, Tagged.cmp$cmp_Ord_String(a, b) === 0 === rt.u64Eq(hash$zeros_Tagged_String(a), hash$zeros_Tagged_String(b)) ? 1 : 0); + rs.byteVecPush(out, (Tagged.cmp$cmp_Ord_String(a, b) & 0xff) | (((Tagged.eq$cmp_PartialEq_String(a, b) ? 1 : 0) << 2) & 0xff) | (((Tagged.partialCmp$cmp_PartialOrd_String(a, b) === Tagged.cmp$cmp_Ord_String(a, b) as rs.Ordering | undefined ? 1 : 0) << 3) & 0xff)); + rs.byteVecPush(out, Tagged.cmp$cmp_Ord_String(a, b) === 0 === rs.u64Eq(hash$zeros_Tagged_String(a), hash$zeros_Tagged_String(b)) ? 1 : 0); } - rt.byteVecPush(out, (true ? 1 : 0) | (((true ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, rt.cmpNothing(undefined, undefined) & 0xff); - rt.byteVecPush(out, rt.cmpNothing(undefined, undefined) & 0xff); + rs.byteVecPush(out, (true ? 1 : 0) | (((true ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, rs.cmpNothing(undefined, undefined) & 0xff); + rs.byteVecPush(out, rs.cmpNothing(undefined, undefined) & 0xff); } else if (_7 === 2) { for (const _150 of tags.items) { digest$zeros_Tagged_String(_150, out); @@ -329,98 +329,98 @@ export function impls(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { } else { const _168: Names.Names = Names.clone$Clone(Names.default$Default()); const _176: Names.Names = Names.default$Default(); - rt.byteVecPush(out, Names.eq$cmp_PartialEq(_168, _176) ? 1 : 0); + rs.byteVecPush(out, Names.eq$cmp_PartialEq(_168, _176) ? 1 : 0); const _183: Names.Names = Names.default$Default(); - rt.byteVecPush(out, Names.cmp$cmp_Ord(_168, _183) === 0 ? 1 : 0); - rt.byteVecPush(out, rt.iterAll(rt.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { + rs.byteVecPush(out, Names.cmp$cmp_Ord(_168, _183) === 0 ? 1 : 0); + rs.byteVecPush(out, rs.iterAll(rs.iterSlice(tags.items), (t2: Tagged.Tagged): boolean => { return Tagged.eq$cmp_PartialEq_String(Tagged.clone$Clone_String(t2), t2); }) ? 1 : 0); Rest.default$Default(); - rt.byteVecPush(out, true ? 1 : 0); + rs.byteVecPush(out, true ? 1 : 0); } } /** `Some(())` if every byte of `data` is below 0x80. */ -export function small(data: rt.ByteSlice): undefined | rt.None { - return rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): undefined | rt.None => { - return thenSome$1j8foe9(_22 < 128, undefined); - }), (values: rt.Iter) => rt.iterFold(values, undefined, () => undefined), undefined, rt.None, rt.None); +export function small(data: rs.ByteSlice): undefined | rs.None { + return rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): undefined | rs.None => { + return thenSome$1n1oy1h(_22 < 128, undefined); + }), (values: rs.Iter) => rs.iterFold(values, undefined, () => undefined), undefined, rs.None, rs.None); } /** `Ok(())`, or the first byte of `data` that is 0xff. */ -export function checked(data: rt.ByteSlice): rt.Result { - return rt.iterCollectResult(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_22: rt.u8): rt.Result => { - const b: rt.u8 = _22; +export function checked(data: rs.ByteSlice): rs.Result { + return rs.iterCollectResult(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_22: rs.u8): rs.Result => { + const b: rs.u8 = _22; if (!(b === 255)) { - return rt.OK; + return rs.OK; } - return rt.Err(b); - }), (values: rt.Iter) => rt.iterFold(values, undefined, () => undefined)); + return rs.Err(b); + }), (values: rs.Iter) => rs.iterFold(values, undefined, () => undefined)); } /** `()` as a hash and B-tree key and as `collect::>`'s item. */ -export function keys(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - let _148!: rt.u8; - const _4: rt.u8 = rt.u8Rem(kind, 3); +export function keys(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + let _148!: rs.u8; + const _4: rs.u8 = rs.u8Rem(kind, 3); if (_4 === 0) { - const hash: rt.HashSet = rt.hashNew() as rt.HashSet; - const tree: rt.BTreeSet = rt.btreeNew(rt.cmpNothing) as rt.BTreeSet; - for (const _10 of rt.byteSliceView(data)) { + const hash: rs.HashSet = rs.hashNew() as rs.HashSet; + const tree: rs.BTreeSet = rs.btreeNew(rs.cmpNothing) as rs.BTreeSet; + for (const _10 of rs.byteSliceView(data)) { if (!((_10 & 1) === 0)) { - rt.byteVecPush(out, (rt.hashDelete(hash, undefined) ? 1 : 0) | (((rt.btreeDelete(tree, undefined) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.hashDelete(hash, undefined) ? 1 : 0) | (((rs.btreeDelete(tree, undefined) ? 1 : 0) << 1) & 0xff)); } else { - rt.byteVecPush(out, (rt.hashAdd(hash, undefined) ? 1 : 0) | (((rt.btreeAdd(tree, undefined) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, (rs.hashAdd(hash, undefined) ? 1 : 0) | (((rs.btreeAdd(tree, undefined) ? 1 : 0) << 1) & 0xff)); } - rt.byteVecPush(out, (rt.hashLen(hash) & 0xff) | (((rt.btreeLen(tree) & 0xff) << 4) & 0xff)); + rs.byteVecPush(out, (rs.hashLen(hash) & 0xff) | (((rs.btreeLen(tree) & 0xff) << 4) & 0xff)); } - rt.byteVecPush(out, (rt.hashContains(hash, undefined) ? 1 : 0) | (((rt.btreeContains(tree, undefined) ? 1 : 0) << 1) & 0xff)); - rt.byteVecPush(out, rt.btreeFirstKey(tree, false, rt.None) === rt.btreeFirstKey(tree, true, rt.None) ? 1 : 0); + rs.byteVecPush(out, (rs.hashContains(hash, undefined) ? 1 : 0) | (((rs.btreeContains(tree, undefined) ? 1 : 0) << 1) & 0xff)); + rs.byteVecPush(out, rs.btreeFirstKey(tree, false, rs.None) === rs.btreeFirstKey(tree, true, rs.None) ? 1 : 0); } else if (_4 === 1) { - const map: rt.HashMap = rt.hashNew() as rt.HashMap; - const tree2: rt.BTreeMap = rt.btreeNew(rt.cmpNothing) as rt.BTreeMap; - for (const b2 of rt.byteSliceView(data)) { + const map: rs.HashMap = rs.hashNew() as rs.HashMap; + const tree2: rs.BTreeMap = rs.btreeNew(rs.cmpNothing) as rs.BTreeMap; + for (const b2 of rs.byteSliceView(data)) { if (!((b2 & 3) === 3)) { - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$1iwwjee(rt.hashInsert(map, undefined, b2), (v4: rt.u8): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$0w716ia(rs.hashInsert(map, undefined, b2), (v4: rs.u8): Uint8Array => { return Uint8Array.of(1, v4); }), Uint8Array.of(0, 0))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$1iwwjee(rt.btreeInsert(tree2, undefined, b2), (v5: rt.u8): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$0w716ia(rs.btreeInsert(tree2, undefined, b2), (v5: rs.u8): Uint8Array => { return Uint8Array.of(1, v5); }), Uint8Array.of(0, 0))), undefined, true); } else { - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$1iwwjee(rt.hashRemove(map, undefined), (v2: rt.u8): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$0w716ia(rs.hashRemove(map, undefined), (v2: rs.u8): Uint8Array => { return Uint8Array.of(1, v2); }), Uint8Array.of(0, 0))), undefined, true); - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$1iwwjee(rt.btreeRemove(tree2, undefined), (v3: rt.u8): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$0w716ia(rs.btreeRemove(tree2, undefined), (v3: rs.u8): Uint8Array => { return Uint8Array.of(1, v3); }), Uint8Array.of(0, 0))), undefined, true); } - rt.byteVecPush(out, (rt.hashLen(map) & 0xff) | (((rt.btreeLen(tree2) & 0xff) << 4) & 0xff)); - rt.byteVecPush(out, option_unwrapOr$0r2bmpr(rt.hashGet(map, undefined), 0)); + rs.byteVecPush(out, (rs.hashLen(map) & 0xff) | (((rs.btreeLen(tree2) & 0xff) << 4) & 0xff)); + rs.byteVecPush(out, option_unwrapOr$1fr498u(rs.hashGet(map, undefined), 0)); } } else { - rt.iterExtendBytes(out, rt.iterSlice(option_unwrapOr$1la41a6(option_map$1cosm7d(rt.iterCollectOption(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_2: rt.u8): undefined | rt.None => { - return thenSome$1j8foe9(_2 !== 0, undefined); - }), (values: rt.Iter) => rt.iterToVec(values, undefined, 0), undefined, rt.None), (v: rt.Vec): Uint8Array => { + rs.iterExtendBytes(out, rs.iterSlice(option_unwrapOr$1la41a6(option_map$1b6tbot(rs.iterCollectOption(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_2: rs.u8): undefined | rs.None => { + return thenSome$1n1oy1h(_2 !== 0, undefined); + }), (values: rs.Iter) => rs.iterToVec(values, undefined, 0), undefined, rs.None), (v: rs.Vec): Uint8Array => { return Uint8Array.of(1, v.items.length & 0xff); }), Uint8Array.of(0, 0))), undefined, true); - rt.byteVecPush(out, rt.iterCollectOption(rt.iterInspect(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_24: rt.u8): undefined | rt.None => { - return thenSome$1j8foe9(_24 !== 0, undefined); - }), (_27: undefined | rt.None): undefined => { - rt.byteVecPush(out, 9); - }), (values: rt.Iter) => rt.iterToVec(values, "next", 0), undefined, rt.None) !== undefined ? 1 : 0); - rt.byteVecPush(out, small(data) !== rt.None ? 1 : 0); - const _149: rt.Result = checked(data); + rs.byteVecPush(out, rs.iterCollectOption(rs.iterInspect(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_24: rs.u8): undefined | rs.None => { + return thenSome$1n1oy1h(_24 !== 0, undefined); + }), (_27: undefined | rs.None): undefined => { + rs.byteVecPush(out, 9); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 0), undefined, rs.None) !== undefined ? 1 : 0); + rs.byteVecPush(out, small(data) !== rs.None ? 1 : 0); + const _149: rs.Result = checked(data); if (_149.ok) { _148 = 0; } else { _148 = _149.error; } - rt.byteVecPush(out, _148); + rs.byteVecPush(out, _148); } } /** Whether `p` equals another `PhantomData`, which it always does. */ -export function phantomEq$String(_1: undefined, n: rt.u8): rt.u8 { +export function phantomEq$String(_1: undefined, n: rs.u8): rs.u8 { if (false) { return 0; } @@ -428,7 +428,7 @@ export function phantomEq$String(_1: undefined, n: rt.u8): rt.u8 { } /** Whether `u` is `()`, which it always is. */ -export function unitEq(_u: undefined, n: rt.u8): rt.u8 { +export function unitEq(_u: undefined, n: rs.u8): rs.u8 { if (false) { return 0; } @@ -436,7 +436,7 @@ export function unitEq(_u: undefined, n: rt.u8): rt.u8 { } /** `n` if `p`, reassigned, equals another `PhantomData`, which it always does. */ -export function rewritten(_1: undefined, n: rt.u8): rt.u8 { +export function rewritten(_1: undefined, n: rs.u8): rs.u8 { if (false) { return 0; } @@ -447,85 +447,85 @@ export function rewritten(_1: undefined, n: rt.u8): rt.u8 { * How many items `xs` hold if `value` is `()`, which it always is, beside a function * std's `flatten` makes, whose own parameter is `value` too. */ -export function flattened(_value: undefined, xs: rt.ByteVec[]): rt.u8 { +export function flattened(_value: undefined, xs: rs.ByteVec[]): rs.u8 { if (false) { return 0; } - return rt.iterCount(rt.iterFlatten(rt.iterSlice(xs), (value: rt.ByteVec) => rt.iterSlice(rt.byteVecView(value)), true)) & 0xff; + return rs.iterCount(rs.iterFlatten(rs.iterSlice(xs), (value: rs.ByteVec) => rs.iterSlice(rs.byteVecView(value)), true)) & 0xff; } /** * Functions, closures, and locals whose every read lowers to nothing: a drop of what * drops nothing, and a comparison of what holds nothing. */ -export function unread(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void { - rt.atomicStore(LOG, 0, 0); - const n: rt.u8 = data.length & 0xff; - const _9: rt.u8 = rt.u8Rem(kind, 3); +export function unread(kind: rs.u8, data: rs.ByteSlice, out: rs.ByteVec): void { + rs.atomicStore(LOG, 0, 0); + const n: rs.u8 = data.length & 0xff; + const _9: rs.u8 = rs.u8Rem(kind, 3); if (_9 === 0) { - drop$zeros_Lock_u32(Lock.new$u32(option_map$1qp1ym6(rt.byteSliceFirst(data), (_210: rt.u8): rt.u32 => { - return _210 as rt.u32; + drop$zeros_Lock_u32(Lock.new$u32(option_map$12cu62z(rs.byteSliceFirst(data), (_210: rs.u8): rs.u32 => { + return _210 as rs.u32; }))); drop$zeros_Lock_u32(Lock.new$u32(undefined)); - drop$zeros_Lock_zeros_Loud(Lock.new$zeros_Loud(option_map$1ibcmaa(rt.byteSliceFirst(data), (_211: rt.u8): Loud.Loud => { + drop$zeros_Lock_zeros_Loud(Lock.new$zeros_Loud(option_map$0ul65ro(rs.byteSliceFirst(data), (_211: rs.u8): Loud.Loud => { return new Loud.Loud(); }))); drop$zeros_Lock_zeros_Loud(Lock.new$zeros_Loud(undefined)); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicLoad(LOG, 0))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicLoad(LOG, 0))), undefined, true); } else if (_9 === 1) { - rt.byteVecPush(out, rt.iterCount(rt.iterFilter(rt.iterSlice(rt.iterToVec(rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (_25: rt.u8): undefined => {}), undefined, 0, true).items), (_u: undefined): boolean => { + rs.byteVecPush(out, rs.iterCount(rs.iterFilter(rs.iterSlice(rs.iterToVec(rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (_25: rs.u8): undefined => {}), undefined, 0, true).items), (_u: undefined): boolean => { return true; })) & 0xff); - rt.byteVecPush(out, phantomEq$String(undefined, n)); - rt.byteVecPush(out, unitEq(undefined, n)); - rt.byteVecPush(out, rewritten(undefined, n)); - rt.byteVecPush(out, flattened(undefined, [rt.byteSliceToByteVec(data), rt.byteSliceToByteVec(data)])); + rs.byteVecPush(out, phantomEq$String(undefined, n)); + rs.byteVecPush(out, unitEq(undefined, n)); + rs.byteVecPush(out, rewritten(undefined, n)); + rs.byteVecPush(out, flattened(undefined, [rs.byteSliceToByteVec(data), rs.byteSliceToByteVec(data)])); } else { - const lock: Lock.Lock = Lock.new$u32(option_map$1qp1ym6(rt.byteSliceFirst(data), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; + const lock: Lock.Lock = Lock.new$u32(option_map$12cu62z(rs.byteSliceFirst(data), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; })); - rt.byteVecPush(out, (((_22: undefined): boolean => { + rs.byteVecPush(out, (((_22: undefined): boolean => { return true; })(([undefined] as [undefined])[0]) ? 1 : 0) | (((true ? 1 : 0) << 1) & 0xff)); drop$zeros_Lock_u32(lock); - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicLoad(LOG, 0))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicLoad(LOG, 0))), undefined, true); } } /** A fresh `&mut ()`, after logging `tag`. */ -export function leaked(tag: rt.u32): rt.Place { +export function leaked(tag: rs.u32): rs.Place { log(tag); - return rt.DANGLING_UNIT; + return rs.DANGLING_UNIT; } /** A fresh `*mut ()`, after logging `tag`. */ -export function raw(tag: rt.u32): rt.Place { +export function raw(tag: rs.u32): rs.Place { log(tag); - return rt.DANGLING_UNIT; + return rs.DANGLING_UNIT; } /** * Writes through a `&mut` or a pointer to a value of no bytes, which have nothing to * read or write but still run their operands. */ -export function writes(kind: rt.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rt.ByteVec): void { - rt.atomicStore(LOG, 0, 0); - const n: rt.u8 = dataLen & 0xff; - const _9: rt.u8 = rt.u8Rem(kind, 5); +export function writes(kind: rs.u8, _dataData: Uint8Array, _dataStart: number, dataLen: number, out: rs.ByteVec): void { + rs.atomicStore(LOG, 0, 0); + const n: rs.u8 = dataLen & 0xff; + const _9: rs.u8 = rs.u8Rem(kind, 5); if (_9 === 0) { leaked(1); - rt.byteVecPush(out, true ? 1 : 0); + rs.byteVecPush(out, true ? 1 : 0); leaked(2); leaked(3); leaked(4); leaked(6); - rt.byteVecPush(out, (true ? 1 : 0) | ((n << 1) & 0xff)); + rs.byteVecPush(out, (true ? 1 : 0) | ((n << 1) & 0xff)); } else if (_9 === 1) { - rt.byteVecPush(out, true ? 1 : 0); + rs.byteVecPush(out, true ? 1 : 0); unit(); Unit.default$Default(); - rt.byteVecPush(out, (Unit.eq$cmp_PartialEq({}, Unit.default$Default()) ? 1 : 0) | ((n << 1) & 0xff)); - rt.byteVecPush(out, Defaulted.eq$cmp_PartialEq({}, Defaulted.default$Default()) ? 1 : 0); + rs.byteVecPush(out, (Unit.eq$cmp_PartialEq({}, Unit.default$Default()) ? 1 : 0) | ((n << 1) & 0xff)); + rs.byteVecPush(out, Defaulted.eq$cmp_PartialEq({}, Defaulted.default$Default()) ? 1 : 0); } else if (_9 === 2) { raw(1); raw(2); @@ -534,39 +534,39 @@ export function writes(kind: rt.u8, _dataData: Uint8Array, _dataStart: number, d const q: Unit.Unit = {}; unit(); const _96: Unit.Unit = {}; - rt.byteVecPush(out, (Unit.eq$cmp_PartialEq(q, _96) ? 1 : 0) | ((n << 1) & 0xff)); + rs.byteVecPush(out, (Unit.eq$cmp_PartialEq(q, _96) ? 1 : 0) | ((n << 1) & 0xff)); } else if (_9 === 3) { - const _113: rt.Cell = new rt.Cell(undefined); - rt.cellReplace(_113, undefined); - rt.cellReplace(_113, undefined); - rt.cellSet(_113, undefined); - rt.sliceSwap([undefined, undefined, undefined], 0, n as rt.usize); - const v: rt.Vec = rt.vecFromElem({}, 2, undefined); - rt.sliceSwap(v.items, 0, 1); - rt.byteVecPush(out, ([undefined, undefined, undefined].length & 0xff) | (((v.items.length & 0xff) << 4) & 0xff)); - const _141: rt.Cell = new rt.Cell(undefined); - rt.cellReplace(_141, undefined); - rt.cellReplace(_141, undefined); - rt.byteVecPush(out, true ? 1 : 0); + const _113: rs.Cell = new rs.Cell(undefined); + rs.cellReplace(_113, undefined); + rs.cellReplace(_113, undefined); + rs.cellSet(_113, undefined); + rs.sliceSwap([undefined, undefined, undefined], 0, n as rs.usize); + const v: rs.Vec = rs.vecFromElem({}, 2, undefined); + rs.sliceSwap(v.items, 0, 1); + rs.byteVecPush(out, ([undefined, undefined, undefined].length & 0xff) | (((v.items.length & 0xff) << 4) & 0xff)); + const _141: rs.Cell = new rs.Cell(undefined); + rs.cellReplace(_141, undefined); + rs.cellReplace(_141, undefined); + rs.byteVecPush(out, true ? 1 : 0); } else { - let o: undefined | rt.None = thenSome$1j8foe9(n > 0, undefined); - const old2: undefined | rt.None = o; + let o: undefined | rs.None = thenSome$1n1oy1h(n > 0, undefined); + const old2: undefined | rs.None = o; o = undefined; - rt.byteVecPush(out, (old2 !== rt.None ? 1 : 0) | (((o !== rt.None ? 1 : 0) << 1) & 0xff)); - const taken2: undefined | rt.None = o; - o = rt.None; - const taken: undefined | rt.None = taken2; - o = rt.None; - rt.byteVecPush(out, (taken !== rt.None ? 1 : 0) | (((o !== rt.None ? 1 : 0) << 1) & 0xff)); - let x: rt.u8 = n; + rs.byteVecPush(out, (old2 !== rs.None ? 1 : 0) | (((o !== rs.None ? 1 : 0) << 1) & 0xff)); + const taken2: undefined | rs.None = o; + o = rs.None; + const taken: undefined | rs.None = taken2; + o = rs.None; + rs.byteVecPush(out, (taken !== rs.None ? 1 : 0) | (((o !== rs.None ? 1 : 0) << 1) & 0xff)); + let x: rs.u8 = n; x = 1; x = 0; - let y: rt.u8 | undefined = n; + let y: rs.u8 | undefined = n; y = undefined; y = n; - rt.byteVecPush(out, x | ((option_unwrapOr$0r2bmpr(y, 0) << 4) & 0xff)); + rs.byteVecPush(out, x | ((option_unwrapOr$1fr498u(y, 0) << 4) & 0xff)); } - rt.iterExtendBytes(out, rt.iterSlice(rt.u32ToBeBytes(rt.atomicLoad(LOG, 0))), undefined, true); + rs.iterExtendBytes(out, rs.iterSlice(rs.u32ToBeBytes(rs.atomicLoad(LOG, 0))), undefined, true); } //# sourceMappingURL=zeros.ts.map diff --git a/ts/fixtures/names/expected/bytes.ts b/ts/fixtures/names/expected/bytes.ts index 18b1ecde3..51c584da3 100644 --- a/ts/fixtures/names/expected/bytes.ts +++ b/ts/fixtures/names/expected/bytes.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$ref_slice_u8 } from "./lib.ts"; -import { okOr$1qu2qk5 as option_okOr$1qu2qk5 } from "./core/option.ts"; +import { okOr$1pcnf6t as option_okOr$1pcnf6t } from "./core/option.ts"; -export function read(data: rt.ByteSlice): rt.u8 | undefined { - const _0: rt.Result = option_okOr$1qu2qk5(rt.byteSliceGetRange(data, 0, 1), 0); +export function read(data: rs.ByteSlice): rs.u8 | undefined { + const _0: rs.Result = option_okOr$1pcnf6t(rs.byteSliceGetRange(data, 0, 1), 0); if (!_0.ok) { return _0.error; } - const slice: rt.ByteSlice = _0.value; + const slice: rs.ByteSlice = _0.value; out$ref_slice_u8.pData = slice.data; out$ref_slice_u8.pStart = slice.start; out$ref_slice_u8.pLen = slice.length; diff --git a/ts/fixtures/names/expected/core/option.ts b/ts/fixtures/names/expected/core/option.ts index b947207ed..df8ed1517 100644 --- a/ts/fixtures/names/expected/core/option.ts +++ b/ts/fixtures/names/expected/core/option.ts @@ -1,26 +1,26 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function mapOr$1e4a1e0(self: rt.Ordering | undefined, default_: rt.u8, f: (a0: rt.Ordering) => rt.u8): rt.u8 { +export function mapOr$14runhi(self: rs.Ordering | undefined, default_: rs.u8, f: (a0: rs.Ordering) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function okOr$1qu2qk5(self: rt.ByteSlice | undefined, err: rt.u8): rt.Result { +export function okOr$1pcnf6t(self: rs.ByteSlice | undefined, err: rs.u8): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/names/expected/core/result.ts b/ts/fixtures/names/expected/core/result.ts index cc323f644..53af77c5c 100644 --- a/ts/fixtures/names/expected/core/result.ts +++ b/ts/fixtures/names/expected/core/result.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function unwrapOr$1vwel7p(self: rt.Result, default_: rt.ByteSlice): rt.ByteSlice { +export function unwrapOr$1a67ziq(self: rs.Result, default_: rs.ByteSlice): rs.ByteSlice { if (self.ok) { return self.value; } diff --git a/ts/fixtures/names/expected/lib.ts b/ts/fixtures/names/expected/lib.ts index c6c998192..9897fe3ac 100644 --- a/ts/fixtures/names/expected/lib.ts +++ b/ts/fixtures/names/expected/lib.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { read } from "./bytes.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, mapOr$1e4a1e0 as option_mapOr$1e4a1e0 } from "./core/option.ts"; -import { unwrapOr$1vwel7p as result_unwrapOr$1vwel7p } from "./core/result.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u, mapOr$14runhi as option_mapOr$14runhi } from "./core/option.ts"; +import { unwrapOr$1a67ziq as result_unwrapOr$1a67ziq } from "./core/result.ts"; import * as shapes_Shape from "./shapes.Shape.ts"; import { run as tally_run } from "./tally.ts"; import type * as Pair from "./wrap.Pair.ts"; @@ -12,36 +12,36 @@ import * as Wrap from "./wrap.Wrap.ts"; export const out$ref_slice_u8: { pData: Uint8Array; pStart: number; pLen: number } = { pData: undefined as never, pStart: undefined as never, pLen: undefined as never }; /** One instance of each generic item it reaches. */ -export function run(data: rt.ByteSlice): rt.ByteVec { +export function run(data: rs.ByteSlice): rs.ByteVec { let shape!: shapes_Shape.Shape; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); const pair: Pair.Pair = Wrap.intoInner$wrap_Pair(Wrap.new$wrap_Pair({ _0: first, _1: 1 })); - const out: rt.ByteVec = rt.byteVecFrom(Uint8Array.of(Wrap.intoInner$u8(Wrap.map$wrap_Pair_u8_run_closure1(Wrap.new$wrap_Pair(pair), (p: Pair.Pair): rt.u8 => { + const out: rs.ByteVec = rs.byteVecFrom(Uint8Array.of(Wrap.intoInner$u8(Wrap.map$wrap_Pair_u8_run_closure1(Wrap.new$wrap_Pair(pair), (p: Pair.Pair): rs.u8 => { return p._0; })))); - const _15: rt.u8 = option_mapOr$1e4a1e0(rt.cmp(data.length, 4), 9, (o: rt.Ordering): rt.u8 => { + const _15: rs.u8 = option_mapOr$14runhi(rs.cmp(data.length, 4), 9, (o: rs.Ordering): rs.u8 => { return o & 0xff; }); - rt.byteVecPush(out, _15); + rs.byteVecPush(out, _15); const part = Wrap.new$wrap_Pair(pair); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)]; - const _22: rt.ByteSlice = rt.stringAsBytes(rt.fmtFormat([args2[0]])); - rt.byteVecExtendFromSlice(out, _22); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Wrap.fmt$fmt_Display_wrap_Pair(part, f)]; + const _22: rs.ByteSlice = rs.stringAsBytes(rs.fmtFormat([args2[0]])); + rs.byteVecExtendFromSlice(out, _22); if (!(first === 0)) { shape = "Line" as shapes_Shape.Shape; } else { shape = "Dot" as shapes_Shape.Shape; } - const _38: rt.u8 = shapes_Shape.sides(shape); - rt.byteVecPush(out, _38); - const _42: rt.ByteSlice = rt.byteSliceFrom(rt.u32ToBeBytes(tally_run(data))); - rt.byteVecExtendFromSlice(out, _42); - const err: rt.u8 | undefined = read(data); + const _38: rs.u8 = shapes_Shape.sides(shape); + rs.byteVecPush(out, _38); + const _42: rs.ByteSlice = rs.byteSliceFrom(rs.u32ToBeBytes(tally_run(data))); + rs.byteVecExtendFromSlice(out, _42); + const err: rs.u8 | undefined = read(data); const part2: Uint8Array = out$ref_slice_u8.pData; const part3: number = out$ref_slice_u8.pStart; const part4: number = out$ref_slice_u8.pLen; - const _48: rt.ByteSlice = result_unwrapOr$1vwel7p((err !== undefined ? rt.Err(err as rt.u8) : rt.Ok(new rt.ByteSlice(part2, part3, part4))) as rt.Result, rt.byteSliceFrom(Uint8Array.of())); - rt.byteVecExtendFromSlice(out, _48); + const _48: rs.ByteSlice = result_unwrapOr$1a67ziq((err !== undefined ? rs.Err(err as rs.u8) : rs.Ok(new rs.ByteSlice(part2, part3, part4))) as rs.Result, rs.byteSliceFrom(Uint8Array.of())); + rs.byteVecExtendFromSlice(out, _48); return out; } diff --git a/ts/fixtures/names/expected/shapes.Shape.ts b/ts/fixtures/names/expected/shapes.Shape.ts index 5ebf67652..6a360fbaa 100644 --- a/ts/fixtures/names/expected/shapes.Shape.ts +++ b/ts/fixtures/names/expected/shapes.Shape.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A type named as `dyns::Shape` is. */ export type Shape = "Dot" | "Line"; -export function sides(self: Shape): rt.u8 { +export function sides(self: Shape): rs.u8 { if (self === "Dot") { return 0; } diff --git a/ts/fixtures/names/expected/tally.ts b/ts/fixtures/names/expected/tally.ts index 939fc7e11..7fd6e9ace 100644 --- a/ts/fixtures/names/expected/tally.ts +++ b/ts/fixtures/names/expected/tally.ts @@ -1,38 +1,38 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function tally$tally_Tally_u32(self: rt.Place, n: rt.u8): void { - self.v = rt.u32Add(self.v, n as rt.u32); +export function tally$tally_Tally_u32(self: rs.Place, n: rs.u8): void { + self.v = rs.u32Add(self.v, n as rs.u32); } -export function total$tally_Tally_u32(self: rt.u32): rt.u32 { +export function total$tally_Tally_u32(self: rs.u32): rs.u32 { return self; } -export function tally$tally_Tally_mut_u32(self: rt.Place>, n: rt.u8): void { +export function tally$tally_Tally_mut_u32(self: rs.Place>, n: rs.u8): void { tally$tally_Tally_u32(self.v, n); } -export function total$tally_Tally_mut_mut_u32(self: rt.Place>): rt.u32 { +export function total$tally_Tally_mut_mut_u32(self: rs.Place>): rs.u32 { return total$tally_Tally_mut_u32(self.v); } -export function total$tally_Tally_mut_u32(self: rt.Place): rt.u32 { +export function total$tally_Tally_mut_u32(self: rs.Place): rs.u32 { return total$tally_Tally_u32(self.v); } -export function tallyAll$mut_u32(t: rt.Place>, data: rt.ByteSlice): rt.u32 { - for (const _5 of rt.byteSliceView(data)) { +export function tallyAll$mut_u32(t: rs.Place>, data: rs.ByteSlice): rs.u32 { + for (const _5 of rs.byteSliceView(data)) { tally$tally_Tally_mut_u32(t, _5); } return total$tally_Tally_mut_mut_u32(t); } -export function run(data: rt.ByteSlice): rt.u32 { - let count: rt.u32 = 0; - let _4: rt.Place = rt.place(() => count, (value) => count = value); - return tallyAll$mut_u32(rt.place(() => _4, (value2) => _4 = value2), data); +export function run(data: rs.ByteSlice): rs.u32 { + let count: rs.u32 = 0; + let _4: rs.Place = rs.place(() => count, (value) => count = value); + return tallyAll$mut_u32(rs.place(() => _4, (value2) => _4 = value2), data); } //# sourceMappingURL=tally.ts.map diff --git a/ts/fixtures/names/expected/wrap.Pair.ts b/ts/fixtures/names/expected/wrap.Pair.ts index 10a7375f8..078c1385a 100644 --- a/ts/fixtures/names/expected/wrap.Pair.ts +++ b/ts/fixtures/names/expected/wrap.Pair.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Printed by `Display` in `run`, and by `Debug` only in `added`. */ export interface Pair { - _0: rt.u8; - _1: rt.u8; + _0: rs.u8; + _1: rs.u8; } -export function fmt$fmt_Display(self: Pair, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display(self: Pair, f: rs.Formatter): rs.Result { const arg = self._0; - const _8: rt.Fmt = (f: rt.Formatter) => rt.u8Display(arg, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.u8Display(arg, f); const arg2 = self._1; - const args2: rt.Fmt[] = [_8, (f: rt.Formatter) => rt.u8Display(arg2, f)]; - return rt.fmtWriteFmt(f, [args2[0], "-", args2[1]]); + const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.u8Display(arg2, f)]; + return rs.fmtWriteFmt(f, [args2[0], "-", args2[1]]); } //# sourceMappingURL=wrap.Pair.ts.map diff --git a/ts/fixtures/names/expected/wrap.Wrap.ts b/ts/fixtures/names/expected/wrap.Wrap.ts index 339f822ff..66b2ce349 100644 --- a/ts/fixtures/names/expected/wrap.Wrap.ts +++ b/ts/fixtures/names/expected/wrap.Wrap.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Pair from "./wrap.Pair.ts"; /** A generic type, with a method generic over a closure. */ @@ -16,7 +16,7 @@ export function new$wrap_Pair(value: Pair.Pair): Wrap { return new Wrap(value); } -export function intoInner$u8(self: Wrap): rt.u8 { +export function intoInner$u8(self: Wrap): rs.u8 { return self._0; } @@ -24,14 +24,14 @@ export function intoInner$wrap_Pair(self: Wrap): Pair.Pair { return self._0; } -export function map$wrap_Pair_u8_run_closure1(self: Wrap, f: (a0: Pair.Pair) => rt.u8): Wrap { +export function map$wrap_Pair_u8_run_closure1(self: Wrap, f: (a0: Pair.Pair) => rs.u8): Wrap { return new Wrap(f(self._0)); } -export function fmt$fmt_Display_wrap_Pair(self: Wrap, f: rt.Formatter): rt.Result { +export function fmt$fmt_Display_wrap_Pair(self: Wrap, f: rs.Formatter): rs.Result { const arg = self._0; - const args2: rt.Fmt[] = [(f: rt.Formatter) => Pair.fmt$fmt_Display(arg, f)]; - return rt.fmtWriteFmt(f, ["[", args2[0], "]"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Pair.fmt$fmt_Display(arg, f)]; + return rs.fmtWriteFmt(f, ["[", args2[0], "]"]); } //# sourceMappingURL=wrap.Wrap.ts.map diff --git a/ts/fixtures/reject/census.txt b/ts/fixtures/reject/census.txt index 24bc87cbf..57cf6f312 100644 --- a/ts/fixtures/reject/census.txt +++ b/ts/fixtures/reject/census.txt @@ -36,11 +36,11 @@ fixtures/reject/src/config.rs:generic+0:51: unsupported type `f16` fixtures/reject/src/config.rs:generic+2:2: a cast from `u64` to `f16` fixtures/reject/src/fmt.rs:chunks_address+1:2: `Debug` of a `ChunksMut`, whose slice std writes as an address, which JS has no counterpart of fixtures/reject/src/fmt.rs:pointer+1:2: `Pointer` formatting, as in `{:p}`, is not supported -fixtures/reject/src/futures.rs:generic_pending+1:2: `futures::Waiting>` is not supported: its field `poll` is `Poll`, typed `rt.Poll`, whose `Pending` would be `rt.OuterPending` as `Poll>` -fixtures/reject/src/futures.rs:nested_poll+0:20: `Poll>>>` is not supported: its `Pending` and `Ready` would both be `rt.OuterPending` -fixtures/reject/src/futures.rs:pending_output+0:34: a future of `std::task::Poll`, which can be `rt.Pending`, as the future's own `Pending` is +fixtures/reject/src/futures.rs:generic_pending+1:2: `futures::Waiting>` is not supported: its field `poll` is `Poll`, typed `rs.Poll`, whose `Pending` would be `rs.OuterPending` as `Poll>` +fixtures/reject/src/futures.rs:nested_poll+0:20: `Poll>>>` is not supported: its `Pending` and `Ready` would both be `rs.OuterPending` +fixtures/reject/src/futures.rs:pending_output+0:34: a future of `std::task::Poll`, which can be `rs.Pending`, as the future's own `Pending` is fixtures/reject/src/futures.rs:raw_waker_debug+1:2: `Debug` of `std::task::RawWaker`, which writes addresses, which JS has no counterpart of -fixtures/reject/src/futures.rs:ready_pending+0:27: a future of `std::task::Poll`, which can be `rt.Pending`, as the future's own `Pending` is +fixtures/reject/src/futures.rs:ready_pending+0:27: a future of `std::task::Poll`, which can be `rs.Pending`, as the future's own `Pending` is fixtures/reject/src/futures.rs:waker_debug+1:2: `Debug` of `std::task::Waker`, which writes addresses, which JS has no counterpart of fixtures/reject/src/iters.rs:backs+1:8: `DoubleEndedIterator::rfind` of `iters::Backs`, whose closure takes a reference to `[u8; 2]`, which is not supported yet fixtures/reject/src/iters.rs:borrows+1:4: `Vec::splice` of `iters::Borrows`, whose own `by_ref` std's calls, which is not supported yet @@ -283,13 +283,13 @@ fixtures/reject/src/values.rs:float+0:14: unsupported type `f16` fixtures/reject/src/values.rs:float+0:25: unsupported type `f16` fixtures/reject/src/values.rs:float+1:2: a scalar constant of type `f16` fixtures/reject/src/values.rs:float+1:2: arithmetic on `f16` -fixtures/reject/src/values.rs:generic_unit+1:2: `values::Maybe<()>` is not supported: its field `value` is `Option`, typed `T | undefined`, whose `None` would be `rt.None` as `Option<()>` +fixtures/reject/src/values.rs:generic_unit+1:2: `values::Maybe<()>` is not supported: its field `value` is `Option`, typed `T | undefined`, whose `None` would be `rs.None` as `Option<()>` fixtures/reject/src/values.rs:lists+1:4: `std::collections::LinkedList::::retain` with a mutable reference to a value JS copies, which its mapping would copy fixtures/reject/src/values.rs:manual_impls+2:2: unsupported call to ` as std::fmt::Debug>::fmt` fixtures/reject/src/values.rs:manual_impls+2:25: unsupported call to ` as std::cmp::PartialEq>::eq` fixtures/reject/src/values.rs:manual_impls+2:34: a constant of type `std::mem::ManuallyDrop` -fixtures/reject/src/values.rs:nested+0:15: `Option>>` is not supported: its `None` and `Some` would both be `rt.None` -fixtures/reject/src/values.rs:nested+1:2: `Option>>` is not supported: its `None` and `Some` would both be `rt.None` +fixtures/reject/src/values.rs:nested+0:15: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` +fixtures/reject/src/values.rs:nested+1:2: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` fixtures/reject/src/values.rs:reclone+3:13: a reference to `std::option::Option>`, through which a raw pointer may be made, in a variable assigned again while that pointer may point there fixtures/reject/src/values.rs:units_compared+2:15: a raw pointer to a place of `()`, which has no address of its own fixtures/reject/src/values.rs:units_compared+2:29: a raw pointer to a place of `()`, which has no address of its own diff --git a/ts/fixtures/reject/expected.txt b/ts/fixtures/reject/expected.txt index 3454532a3..885ef2c5f 100644 --- a/ts/fixtures/reject/expected.txt +++ b/ts/fixtures/reject/expected.txt @@ -39,11 +39,11 @@ fixtures/reject/src/config.rs:Meters+0:1: a printable type must implement `Displ fixtures/reject/src/config.rs:generic+0:1: a root must not be generic fixtures/reject/src/fmt.rs:chunks_address+1:11: `Debug` of a `ChunksMut`, whose slice std writes as an address, which JS has no counterpart of fixtures/reject/src/fmt.rs:pointer+1:11: `Pointer` formatting, as in `{:p}`, is not supported -fixtures/reject/src/futures.rs:generic_pending+1:2: `futures::Waiting>` is not supported: its field `poll` is `Poll`, typed `rt.Poll`, whose `Pending` would be `rt.OuterPending` as `Poll>` -fixtures/reject/src/futures.rs:nested_poll+0:20: `Poll>>>` is not supported: its `Pending` and `Ready` would both be `rt.OuterPending` -fixtures/reject/src/futures.rs:pending_output+0:34: a future of `std::task::Poll`, which can be `rt.Pending`, as the future's own `Pending` is +fixtures/reject/src/futures.rs:generic_pending+1:2: `futures::Waiting>` is not supported: its field `poll` is `Poll`, typed `rs.Poll`, whose `Pending` would be `rs.OuterPending` as `Poll>` +fixtures/reject/src/futures.rs:nested_poll+0:20: `Poll>>>` is not supported: its `Pending` and `Ready` would both be `rs.OuterPending` +fixtures/reject/src/futures.rs:pending_output+0:34: a future of `std::task::Poll`, which can be `rs.Pending`, as the future's own `Pending` is fixtures/reject/src/futures.rs:raw_waker_debug+1:11: `Debug` of `std::task::RawWaker`, which writes addresses, which JS has no counterpart of -fixtures/reject/src/futures.rs:ready_pending+0:27: a future of `std::task::Poll`, which can be `rt.Pending`, as the future's own `Pending` is +fixtures/reject/src/futures.rs:ready_pending+0:27: a future of `std::task::Poll`, which can be `rs.Pending`, as the future's own `Pending` is fixtures/reject/src/futures.rs:waker_debug+1:11: `Debug` of `std::task::Waker`, which writes addresses, which JS has no counterpart of fixtures/reject/src/iters.rs:backs+1:8: `DoubleEndedIterator::rfind` of `iters::Backs`, whose closure takes a reference to `[u8; 2]`, which is not supported yet fixtures/reject/src/iters.rs:borrows+1:4: `Vec::splice` of `iters::Borrows`, whose own `by_ref` std's calls, which is not supported yet @@ -284,13 +284,13 @@ fixtures/reject/src/values.rs:float+0:14: unsupported type `f16` fixtures/reject/src/values.rs:float+0:25: unsupported type `f16` fixtures/reject/src/values.rs:float+1:2: a scalar constant of type `f16` fixtures/reject/src/values.rs:float+1:2: arithmetic on `f16` -fixtures/reject/src/values.rs:generic_unit+1:2: `values::Maybe<()>` is not supported: its field `value` is `Option`, typed `T | undefined`, whose `None` would be `rt.None` as `Option<()>` +fixtures/reject/src/values.rs:generic_unit+1:2: `values::Maybe<()>` is not supported: its field `value` is `Option`, typed `T | undefined`, whose `None` would be `rs.None` as `Option<()>` fixtures/reject/src/values.rs:lists+1:4: `std::collections::LinkedList::::retain` with a mutable reference to a value JS copies, which its mapping would copy fixtures/reject/src/values.rs:manual_impls+2:11: unsupported call to ` as std::fmt::Debug>::fmt` fixtures/reject/src/values.rs:manual_impls+2:25: unsupported call to ` as std::cmp::PartialEq>::eq` fixtures/reject/src/values.rs:manual_impls+2:34: a constant of type `std::mem::ManuallyDrop` -fixtures/reject/src/values.rs:nested+0:15: `Option>>` is not supported: its `None` and `Some` would both be `rt.None` -fixtures/reject/src/values.rs:nested+1:2: `Option>>` is not supported: its `None` and `Some` would both be `rt.None` +fixtures/reject/src/values.rs:nested+0:15: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` +fixtures/reject/src/values.rs:nested+1:2: `Option>>` is not supported: its `None` and `Some` would both be `rs.None` fixtures/reject/src/values.rs:reclone+3:13: a reference to `std::option::Option>`, through which a raw pointer may be made, in a variable assigned again while that pointer may point there fixtures/reject/src/values.rs:units_compared+2:15: a raw pointer to a place of `()`, which has no address of its own fixtures/reject/src/values.rs:units_compared+2:29: a raw pointer to a place of `()`, which has no address of its own diff --git a/ts/fixtures/reject/spans.txt b/ts/fixtures/reject/spans.txt index a5be6c08c..fb6de056c 100644 --- a/ts/fixtures/reject/spans.txt +++ b/ts/fixtures/reject/spans.txt @@ -1,12 +1,12 @@ fixtures/reject/src/spans.rs:chained+1:2: spans.ts:23:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:chained+1:2: spans.ts:23:68 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, v -fixtures/reject/src/spans.rs:chained+1:4: spans.ts:23:55 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.iterSlice(v) -fixtures/reject/src/spans.rs:chained+1:11: spans.ts:23:44 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.iterMap(rt.iterSlice(v), (x: rt.u32): rt.u32 => { -fixtures/reject/src/spans.rs:chained+1:11: spans.ts:23:72 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, (x: rt.u32): rt.u32 => { +fixtures/reject/src/spans.rs:chained+1:4: spans.ts:23:55 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.iterSlice(v) +fixtures/reject/src/spans.rs:chained+1:11: spans.ts:23:44 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.iterMap(rs.iterSlice(v), (x: rs.u32): rs.u32 => { +fixtures/reject/src/spans.rs:chained+1:11: spans.ts:23:72 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, (x: rs.u32): rs.u32 => { fixtures/reject/src/spans.rs:chained+1:19: spans.ts:24:29 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, x fixtures/reject/src/spans.rs:chained+1:19: spans.ts:24:3 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return -fixtures/reject/src/spans.rs:chained+1:38: spans.ts:23:33 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.iterMax(rt.iterMap(rt.iterSlice(v), (x: rt.u32): rt.u32 => { -fixtures/reject/src/spans.rs:chained+1:38: spans.ts:25:6 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.lt +fixtures/reject/src/spans.rs:chained+1:38: spans.ts:23:33 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.iterMax(rs.iterMap(rs.iterSlice(v), (x: rs.u32): rs.u32 => { +fixtures/reject/src/spans.rs:chained+1:38: spans.ts:25:6 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.lt fixtures/reject/src/spans.rs:chained+1:44: spans.ts:25:14 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, 0 fixtures/reject/src/spans.rs:early+2:10: spans.ts:15:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:early+2:10: spans.ts:15:26 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, a @@ -17,7 +17,7 @@ fixtures/reject/src/spans.rs:early+4:2: spans.ts:13:26 doesn't type-check, which fixtures/reject/src/spans.rs:early+4:2: spans.ts:13:3 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:early+4:4: spans.ts:13:29 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, 32 fixtures/reject/src/spans.rs:early+4:4: spans.ts:13:33 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, false -fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:19 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, self.reads.items[rt.idx(self.reads.items, at)] +fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:19 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, self.reads.items[rs.idx(self.reads.items, at)] fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:43 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, self.reads.items fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:61 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, at @@ -25,19 +25,19 @@ fixtures/reject/src/spans.rs:impl Meter+2:3: spans.Meter.ts:10:67 doesn't type-c fixtures/reject/src/spans.rs:method+1:2: spans.ts:19:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:method+1:2: spans.ts:19:22 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, m fixtures/reject/src/spans.rs:method+1:11: spans.ts:19:43 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, a -fixtures/reject/src/spans.rs:method+1:13: spans.ts:19:25 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.u32WrappingAdd(a, 1) +fixtures/reject/src/spans.rs:method+1:13: spans.ts:19:25 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.u32WrappingAdd(a, 1) fixtures/reject/src/spans.rs:method+1:13: spans.ts:19:46 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, 1 -fixtures/reject/src/spans.rs:method+1:30: spans.ts:19:50 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.usizeSub(m.reads.items.length, 1) +fixtures/reject/src/spans.rs:method+1:30: spans.ts:19:50 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.usizeSub(m.reads.items.length, 1) fixtures/reject/src/spans.rs:method+1:30: spans.ts:19:84 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, 1 fixtures/reject/src/spans.rs:method+1:38: spans.ts:19:62 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, m.reads.items.length fixtures/reject/src/spans.rs:operators+1:2: spans.ts:29:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:operators+1:2: spans.ts:29:22 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, m fixtures/reject/src/spans.rs:operators+1:11: spans.ts:29:25 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, (a ^ 7) >>> 0 -fixtures/reject/src/spans.rs:operators+1:18: spans.ts:29:40 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.usizeDiv(at, 2) +fixtures/reject/src/spans.rs:operators+1:18: spans.ts:29:40 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.usizeDiv(at, 2) fixtures/reject/src/spans.rs:operators+1:18: spans.ts:29:52 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, at fixtures/reject/src/spans.rs:operators+1:18: spans.ts:29:56 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, 2 fixtures/reject/src/spans.rs:tail+2:2: spans.ts:8:2 doesn't type-check, which is a bug in rust2-ts: error TS2322: a return fixtures/reject/src/spans.rs:tail+2:2: spans.ts:8:37 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, (a ^ b) >>> 0 fixtures/reject/src/spans.rs:tail+2:2: spans.ts:8:56 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, b -fixtures/reject/src/spans.rs:tail+2:4: spans.ts:8:19 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rt.u32WrappingMul((a ^ b) >>> 0, a) +fixtures/reject/src/spans.rs:tail+2:4: spans.ts:8:19 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, rs.u32WrappingMul((a ^ b) >>> 0, a) fixtures/reject/src/spans.rs:tail+2:17: spans.ts:8:52 doesn't type-check, which is a bug in rust2-ts: error TS2345: an argument, a diff --git a/ts/fixtures/reject/src/buffers.rs b/ts/fixtures/reject/src/buffers.rs index 0dcbd5777..fdf649e8d 100644 --- a/ts/fixtures/reject/src/buffers.rs +++ b/ts/fixtures/reject/src/buffers.rs @@ -10,7 +10,7 @@ pub fn owned_bytes(owner: std::sync::Arc<[u8]>) -> usize { bytes::Bytes::from_owner(owner).len() } -/// A buffer of the crate's own that JS copies, so `&mut` to it is an `rt.Place`, which the +/// A buffer of the crate's own that JS copies, so `&mut` to it is an `rs.Place`, which the /// provided `copy_to_bytes` doesn't read through. pub enum Blank { Empty, diff --git a/ts/fixtures/reject/src/futures.rs b/ts/fixtures/reject/src/futures.rs index 1083ac229..3207bc1d9 100644 --- a/ts/fixtures/reject/src/futures.rs +++ b/ts/fixtures/reject/src/futures.rs @@ -1,16 +1,16 @@ //! Futures and polls whose `Pending`s JS can't tell apart. -/// `Ready(Some(Ready(Pending)))` would be `rt.OuterPending`, as the outer `Pending` is. +/// `Ready(Some(Ready(Pending)))` would be `rs.OuterPending`, as the outer `Pending` is. pub fn nested_poll(p: std::task::Poll>>>) -> bool { matches!(p, std::task::Poll::Pending) } -/// A future's `Ready(Pending)` would be `rt.Pending`, as its own pending is. +/// A future's `Ready(Pending)` would be `rs.Pending`, as its own pending is. pub async fn pending_output() -> std::task::Poll { std::task::Poll::Pending } -/// A generic type's `Poll` is `rt.Poll`, which can't hold `rt.OuterPending`, the +/// A generic type's `Poll` is `rs.Poll`, which can't hold `rs.OuterPending`, the /// `Pending` of a `Poll>`. pub struct Waiting { pub poll: std::task::Poll, @@ -38,7 +38,7 @@ fn poll_pinned( o.poll(cx) } -/// A `Ready`'s `Ready(Pending)` would be `rt.Pending`, as its own poll's pending is. +/// A `Ready`'s `Ready(Pending)` would be `rs.Pending`, as its own poll's pending is. pub fn ready_pending() -> std::future::Ready> { std::future::ready(std::task::Poll::Pending) } diff --git a/ts/fixtures/reject/src/iters.rs b/ts/fixtures/reject/src/iters.rs index 545c8d16a..4373a0d91 100644 --- a/ts/fixtures/reject/src/iters.rs +++ b/ts/fixtures/reject/src/iters.rs @@ -1,6 +1,6 @@ //! Iterators and collections of the crate's own that override what std's adaptors call. -/// An iterator whose own `fold` holds its accumulator in an `Option`, of an `rt.None` or not. +/// An iterator whose own `fold` holds its accumulator in an `Option`, of an `rs.None` or not. pub struct Folds; impl Iterator for Folds { diff --git a/ts/fixtures/reject/src/kept.rs b/ts/fixtures/reject/src/kept.rs index 3fd2c06b5..5a8e93ab3 100644 --- a/ts/fixtures/reject/src/kept.rs +++ b/ts/fixtures/reject/src/kept.rs @@ -2,7 +2,7 @@ use crate::parts::cell; -/// Structs JS keeps as objects, each holding an `rt.Cell` of an object, one for each write +/// Structs JS keeps as objects, each holding an `rs.Cell` of an object, one for each write /// of fresh memory made while a pointer into it may still be read, which gives the cell /// another object. pub struct Escaped(pub std::cell::UnsafeCell<(u16, u16)>); @@ -202,7 +202,7 @@ pub fn pushed_part_kept(n: u16) -> u16 { unsafe { (*part).0 } } -/// Structs JS keeps as objects, each holding an `rt.Cell`, one for each path by which a +/// Structs JS keeps as objects, each holding an `rs.Cell`, one for each path by which a /// pointer kept in memory reaches a whole write of what it points at, which gives it /// another cell, while a pointer to the cell, taken through a reference to the struct, /// may still be read. @@ -372,7 +372,7 @@ pub fn atomic_exchanged(n: u16) -> u16 { unsafe { *part } } -/// Structs JS keeps as objects, each holding an `rt.Cell`, one for each std function that +/// Structs JS keeps as objects, each holding an `rs.Cell`, one for each std function that /// puts another object in place of a `RefCell`'s value through a shared reference, while a /// pointer to the cell, taken through a borrow of that value, may still be read. pub struct ByRefReplace(pub std::cell::UnsafeCell); diff --git a/ts/fixtures/reject/src/objects.rs b/ts/fixtures/reject/src/objects.rs index 08095b004..3f67a8d5c 100644 --- a/ts/fixtures/reject/src/objects.rs +++ b/ts/fixtures/reject/src/objects.rs @@ -34,7 +34,7 @@ impl First for [u8; 4] { } /// A trait object of a byte array, which a box holds as a `Uint8Array` and a reference as -/// an `rt.ByteSlice`. +/// an `rs.ByteSlice`. pub fn first_of(n: u8) -> u8 { let b: Box = Box::new([n, 8, 9, 10]); b.first() diff --git a/ts/fixtures/reject/src/parts.rs b/ts/fixtures/reject/src/parts.rs index ee481eb43..4bacf5df7 100644 --- a/ts/fixtures/reject/src/parts.rs +++ b/ts/fixtures/reject/src/parts.rs @@ -2,7 +2,7 @@ use crate::rebound::part_cell; -/// Structs JS keeps as objects, each holding an `rt.Cell`, one for each kind of whole +/// Structs JS keeps as objects, each holding an `rs.Cell`, one for each kind of whole /// write of a value that holds one, which gives it another cell, while a pointer to the /// cell, taken through a reference to the struct, may still be read. pub struct InArray(pub std::cell::UnsafeCell); diff --git a/ts/fixtures/reject/src/places.rs b/ts/fixtures/reject/src/places.rs index 68680b229..680492dc8 100644 --- a/ts/fixtures/reject/src/places.rs +++ b/ts/fixtures/reject/src/places.rs @@ -56,14 +56,14 @@ fn bumped(x: &mut u8) { } /// A `Result`'s value passed on: a store through it makes the `Result` again, which no -/// `rt.Place` of a path does. +/// `rs.Place` of a path does. pub fn ok_passed(r: &mut Result) { if let Ok(v) = r { bumped(v); } } -/// `Option`s holding `rt.Place`s, which std's runtime would compare as the Places. +/// `Option`s holding `rs.Place`s, which std's runtime would compare as the Places. pub fn places_equal(a: &mut u32, b: &mut u32) -> bool { Some(a) == Some(b) } @@ -82,14 +82,14 @@ pub fn rebound_reference(a: &u32, b: &u32) -> (u32, u32) { (x(), y()) } -/// Two `rt.Place`s of one number, which are two objects. +/// Two `rs.Place`s of one number, which are two objects. pub fn places_compared(n: &mut u32) -> bool { let a = &raw mut *n; let b = &raw mut *n; a == b } -/// An `Option` of pointers to a number, each an `rt.Place` JS makes of its own. +/// An `Option` of pointers to a number, each an `rs.Place` JS makes of its own. pub fn optional_places_compared(n: &mut u32) -> bool { let p = std::ptr::NonNull::from(&mut *n); Some(p) == std::ptr::NonNull::new(&raw mut *n) diff --git a/ts/fixtures/reject/src/pointers.rs b/ts/fixtures/reject/src/pointers.rs index f38890687..5c1001f3f 100644 --- a/ts/fixtures/reject/src/pointers.rs +++ b/ts/fixtures/reject/src/pointers.rs @@ -84,7 +84,7 @@ pub fn element_pointer(n: u32) -> u32 { unsafe { (*p).0 } } -/// The pointer `UnsafeCell::get` gives to the object its `rt.Cell` holds, which a whole +/// The pointer `UnsafeCell::get` gives to the object its `rs.Cell` holds, which a whole /// write of the cell elsewhere replaces with another object. pub fn cell_replaced(n: u32) -> u32 { let mut cell = std::cell::UnsafeCell::new((n, n)); @@ -93,7 +93,7 @@ pub fn cell_replaced(n: u32) -> u32 { unsafe { (*p).0 + old.into_inner().1 } } -/// The pointer `UnsafeCell::get` gives to a number, the `rt.Cell` itself, which an +/// The pointer `UnsafeCell::get` gives to a number, the `rs.Cell` itself, which an /// assignment of the whole variable replaces. pub fn cell_reassigned(n: u32) -> u32 { let mut cell = std::cell::UnsafeCell::new(n); @@ -106,7 +106,7 @@ pub struct Hits { pub count: std::cell::UnsafeCell, } -/// The pointer `UnsafeCell::get` gives to a number, the `rt.Cell` itself, which +/// The pointer `UnsafeCell::get` gives to a number, the `rs.Cell` itself, which /// `mem::take` of the whole variable replaces. pub fn cell_taken(n: u32) -> u32 { let mut cell = std::cell::UnsafeCell::new(n); @@ -115,7 +115,7 @@ pub fn cell_taken(n: u32) -> u32 { unsafe { *p + old.into_inner() } } -/// The pointer `UnsafeCell::get` gives to a number, the `rt.Cell` in a struct, which a +/// The pointer `UnsafeCell::get` gives to a number, the `rs.Cell` in a struct, which a /// write of the whole field replaces. pub fn cell_field_replaced(n: u32) -> u32 { let mut hits = Hits { @@ -432,12 +432,12 @@ pub fn reached_out(h: Halves, lanes: [u32; 4]) -> u32 { } } -/// A slice of one `u8`'s place, which no `rt.ByteSlice` views. +/// A slice of one `u8`'s place, which no `rs.ByteSlice` views. pub fn byte_slice_of_place(b: &mut u8) { std::slice::from_mut(b)[0] = 1; } -/// A slice of an `Option`'s byte, which no `rt.ByteSlice` views either. +/// A slice of an `Option`'s byte, which no `rs.ByteSlice` views either. pub fn byte_option_slice(o: &mut Option) { o.as_mut_slice().fill(1); } diff --git a/ts/fixtures/reject/src/rebound.rs b/ts/fixtures/reject/src/rebound.rs index 6b527411b..ecd2a7981 100644 --- a/ts/fixtures/reject/src/rebound.rs +++ b/ts/fixtures/reject/src/rebound.rs @@ -4,7 +4,7 @@ fn cell_of(c: &std::cell::UnsafeCell) -> *mut u64 { c.get() } -/// The pointer `UnsafeCell::get` gives a callee, the `rt.Cell` itself, which the caller's +/// The pointer `UnsafeCell::get` gives a callee, the `rs.Cell` itself, which the caller's /// assignment of the variable replaces. pub fn cell_rebound(n: u64) -> u64 { let mut cell = std::cell::UnsafeCell::new(n); diff --git a/ts/fixtures/reject/src/statics.rs b/ts/fixtures/reject/src/statics.rs index e130c2327..e131959d5 100644 --- a/ts/fixtures/reject/src/statics.rs +++ b/ts/fixtures/reject/src/statics.rs @@ -13,7 +13,7 @@ static SLOT: std::sync::atomic::AtomicPtr = std::sync::atomic::AtomicPtr::n pub fn pointer_statics(p: *mut u32) -> u32 { use std::sync::atomic::Ordering::Relaxed; - // Two `rt.Place`s of one place are two objects, which `===` can't tell are one. + // Two `rs.Place`s of one place are two objects, which `===` can't tell are one. let _ = SLOT.compare_exchange(p, std::ptr::null_mut(), Relaxed, Relaxed); *NAMED } diff --git a/ts/fixtures/reject/src/values.rs b/ts/fixtures/reject/src/values.rs index f07158184..c6c5dfc0f 100644 --- a/ts/fixtures/reject/src/values.rs +++ b/ts/fixtures/reject/src/values.rs @@ -6,12 +6,12 @@ pub fn float(a: f16) -> f16 { a * 2.0 } -/// `None` and `Some(None)` would both be `rt.None`, as `Some(Some(None))` is `undefined`. +/// `None` and `Some(None)` would both be `rs.None`, as `Some(Some(None))` is `undefined`. pub fn nested(x: Option>>) -> bool { x.is_some() } -/// A generic type's `Option` is `T | undefined`, which can't hold `rt.None`, the `None` +/// A generic type's `Option` is `T | undefined`, which can't hold `rs.None`, the `None` /// of an `Option<()>`. pub struct Maybe { pub value: Option, diff --git a/ts/fixtures/share/expected/harness.ts b/ts/fixtures/share/expected/harness.ts index 1143e6fc9..3140334ae 100644 --- a/ts/fixtures/share/expected/harness.ts +++ b/ts/fixtures/share/expected/harness.ts @@ -1,41 +1,41 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$array_u8 } from "./lib.ts"; /** * Copy two bytes of the input into an array, overwrite the copy, and output both: a * shared array would change the original too. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (!(input.length >= 2)) { return out; } const bytes: Uint8Array = Uint8Array.of(input.data[input.start], input.data[input.start + 1]); const copy: Uint8Array = copy$array_u8(bytes); - overwrite$array2_u8(rt.byteSliceFrom(copy), Uint8Array.of(rt.u8WrappingAdd(input.data[input.start + 1], 1), ~input.data[input.start] & 0xff)); - rt.byteVecPush(out, bytes[0]); - rt.byteVecPush(out, bytes[1]); - rt.byteVecPush(out, copy[0]); - rt.byteVecPush(out, copy[1]); - const pairs: rt.Vec = rt.iterToVec(rt.iterMap(rt.byteSliceWindows(input, 2), (w: rt.ByteSlice): Uint8Array => { - rt.idx(w, 0); - const _3: rt.u8 = w.data[w.start]; - rt.idx(w, 1); + overwrite$array2_u8(rs.byteSliceFrom(copy), Uint8Array.of(rs.u8WrappingAdd(input.data[input.start + 1], 1), ~input.data[input.start] & 0xff)); + rs.byteVecPush(out, bytes[0]); + rs.byteVecPush(out, bytes[1]); + rs.byteVecPush(out, copy[0]); + rs.byteVecPush(out, copy[1]); + const pairs: rs.Vec = rs.iterToVec(rs.iterMap(rs.byteSliceWindows(input, 2), (w: rs.ByteSlice): Uint8Array => { + rs.idx(w, 0); + const _3: rs.u8 = w.data[w.start]; + rs.idx(w, 1); return Uint8Array.of(_3, w.data[w.start + 1]); }), undefined, 2, true); - const deque: rt.VecDeque = rt.dequeNew(2) as rt.VecDeque; - rt.dequeExtend(deque, rt.iterMap(rt.iterLend(rt.iterSlice(pairs.items), rt.byteSliceFrom), rt.byteSliceToArray), undefined, true); - const _47: rt.Iter = rt.iterFlatMap(rt.iterLend(rt.dequeIter(deque), rt.byteSliceFrom), (p: rt.ByteSlice): Uint8Array => { + const deque: rs.VecDeque = rs.dequeNew(2) as rs.VecDeque; + rs.dequeExtend(deque, rs.iterMap(rs.iterLend(rs.iterSlice(pairs.items), rs.byteSliceFrom), rs.byteSliceToArray), undefined, true); + const _47: rs.Iter = rs.iterFlatMap(rs.iterLend(rs.dequeIter(deque), rs.byteSliceFrom), (p: rs.ByteSlice): Uint8Array => { return Uint8Array.of(p.data[p.start], p.data[p.start + 1]); - }, (value: Uint8Array) => rt.iterSlice(value), true, 2); - rt.iterExtendBytes(out, _47, undefined, true); + }, (value: Uint8Array) => rs.iterSlice(value), true, 2); + rs.iterExtendBytes(out, _47, undefined, true); return out; } /** The crate's only write into a byte array: whole, through a type parameter. */ -export function overwrite$array2_u8(dst: rt.ByteSlice, value: Uint8Array): void { +export function overwrite$array2_u8(dst: rs.ByteSlice, value: Uint8Array): void { dst.data.set(copy$array_u8(value), dst.start); } diff --git a/ts/fixtures/stock/expected/buf.Counted.ts b/ts/fixtures/stock/expected/buf.Counted.ts index 8bbc98788..5691e97da 100644 --- a/ts/fixtures/stock/expected/buf.Counted.ts +++ b/ts/fixtures/stock/expected/buf.Counted.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$u8 } from "./lib.ts"; import * as Pieces from "./buf.Pieces.ts"; import { panicAdvance, panicDoesNotFit } from "./bytes.ts"; import { signExtend } from "./bytes/buf/buf_impl.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; -import { unwrapOrElse$1wp5sd9 as result_unwrapOrElse$1wp5sd9, unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "./core/result.ts"; +import { unwrapOrElse$1b4ownx as result_unwrapOrElse$1b4ownx, unwrapOrElse$1fg63zn as result_unwrapOrElse$1fg63zn } from "./core/result.ts"; /** Pieces that count their drops. */ export class Counted { _0: Pieces.Pieces; - _1: rt.Arc>; + _1: rs.Arc>; - constructor(_0: Pieces.Pieces, _1: rt.Arc>) { + constructor(_0: Pieces.Pieces, _1: rs.Arc>) { this._0 = _0; this._1 = _1; } @@ -51,7 +51,7 @@ export class Counted { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf(self: Counted): rt.usize { +export function remaining$bytes_Buf(self: Counted): rs.usize { return Pieces.remaining$bytes_Buf(self._0); } @@ -85,7 +85,7 @@ export function remaining$bytes_Buf(self: Counted): rt.usize { * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf(self: Counted): rt.ByteSlice { +export function chunk$bytes_Buf(self: Counted): rs.ByteSlice { return Pieces.chunk$bytes_Buf(self._0); } @@ -121,12 +121,12 @@ export function chunk$bytes_Buf(self: Counted): rt.ByteSlice { * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf(self: Counted, cnt: rt.usize): void { +export function advance$bytes_Buf(self: Counted, cnt: rs.usize): void { Pieces.advance$bytes_Buf(self._0, cnt); } export function drop$ops_Drop(self: Counted): void { - rt.cellSet(self._1.value, rt.u8Add(self._1.value.v, 1)); + rs.cellSet(self._1.value, rs.u8Add(self._1.value.v, 1)); } /** @@ -175,8 +175,8 @@ export function hasRemaining$bytes_Buf(self: Counted): boolean { * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf(self: Counted, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf(self: Counted, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -199,11 +199,11 @@ export function copyToSlice$bytes_Buf(self: Counted, dst: rt.ByteSlice): void { * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf(self: Counted): rt.u8 { +export function getU8$bytes_Buf(self: Counted): rs.u8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf(self, 1); return ret; } @@ -228,11 +228,11 @@ export function getU8$bytes_Buf(self: Counted): rt.u8 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf(self: Counted): rt.i8 { +export function getI8$bytes_Buf(self: Counted): rs.i8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf(self, 1); return ret; } @@ -258,21 +258,21 @@ export function getI8$bytes_Buf(self: Counted): rt.i8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf(self: Counted, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf(self: Counted, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -296,20 +296,20 @@ export function getUint$bytes_Buf(self: Counted, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf(self: Counted, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf(self: Counted, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -333,7 +333,7 @@ export function getUintLe$bytes_Buf(self: Counted, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf(self: Counted, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf(self: Counted, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf(self, nbytes), nbytes); } @@ -356,8 +356,8 @@ export function getIntLe$bytes_Buf(self: Counted, nbytes: rt.usize): rt.i64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf(self: Counted): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Counted, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Counted, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf(self: Counted): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Counted, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Counted, a1: rs.ByteSlice) => undefined)); } /** @@ -379,8 +379,8 @@ export function getF32Le$bytes_Buf(self: Counted): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf(self: Counted): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Counted, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Counted, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf(self: Counted): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Counted, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Counted, a1: rs.ByteSlice) => undefined)); } /** @@ -415,18 +415,18 @@ export function getF64$bytes_Buf(self: Counted): rt.f64 { * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf(self: Counted, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf(self: Counted, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); } /** @@ -454,11 +454,11 @@ export function tryCopyToSlice$bytes_Buf(self: Counted, dst: rt.ByteSlice): rt.R * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf(self: Counted): rt.u8 | undefined { +export function tryGetU8$bytes_Buf(self: Counted): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf(self, 1); return ret; } @@ -496,7 +496,7 @@ export function tryGetU8$bytes_Buf(self: Counted): rt.u8 | undefined { * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut(self: Counted): rt.ByteSlice { +export function chunk$bytes_Buf_mut(self: Counted): rs.ByteSlice { return chunk$bytes_Buf(self); } @@ -527,7 +527,7 @@ export function chunk$bytes_Buf_mut(self: Counted): rt.ByteSlice { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut(self: Counted): rt.usize { +export function remaining$bytes_Buf_mut(self: Counted): rs.usize { return remaining$bytes_Buf(self); } diff --git a/ts/fixtures/stock/expected/buf.Leased.ts b/ts/fixtures/stock/expected/buf.Leased.ts index c5e0abcc8..d4ae7fded 100644 --- a/ts/fixtures/stock/expected/buf.Leased.ts +++ b/ts/fixtures/stock/expected/buf.Leased.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Buf from "./bytes/buf/buf_impl.Buf.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; /** A buffer of the crate's own over `Buf`, as moq's transports lend a stream's chunks. */ export type Leased = - | { pieces$Leased: () => rt.usize; skip$Leased: (a0: Buf.Buf) => void; remaining$Buf: () => rt.usize; chunk$Buf: () => rt.ByteSlice; advance$Buf: (a0: rt.usize) => void; hasRemaining$Buf: () => boolean; copyToSlice$Buf: (a0: rt.ByteSlice) => void; getU8$Buf: () => rt.u8; getI8$Buf: () => rt.i8; getU16$Buf: () => rt.u16; getU16Le$Buf: () => rt.u16; getU16Ne$Buf: () => rt.u16; getI16$Buf: () => rt.i16; getI16Le$Buf: () => rt.i16; getI16Ne$Buf: () => rt.i16; getU32$Buf: () => rt.u32; getU32Le$Buf: () => rt.u32; getU32Ne$Buf: () => rt.u32; getI32$Buf: () => rt.i32; getI32Le$Buf: () => rt.i32; getI32Ne$Buf: () => rt.i32; getU64$Buf: () => rt.u64; getU64Le$Buf: () => rt.u64; getU64Ne$Buf: () => rt.u64; getI64$Buf: () => rt.i64; getI64Le$Buf: () => rt.i64; getI64Ne$Buf: () => rt.i64; getU128$Buf: () => rt.u128; getU128Le$Buf: () => rt.u128; getU128Ne$Buf: () => rt.u128; getI128$Buf: () => rt.i128; getI128Le$Buf: () => rt.i128; getI128Ne$Buf: () => rt.i128; getUint$Buf: (a0: rt.usize) => rt.u64; getUintLe$Buf: (a0: rt.usize) => rt.u64; getUintNe$Buf: (a0: rt.usize) => rt.u64; getInt$Buf: (a0: rt.usize) => rt.i64; getIntLe$Buf: (a0: rt.usize) => rt.i64; getIntNe$Buf: (a0: rt.usize) => rt.i64; getF32$Buf: () => rt.f32; getF32Le$Buf: () => rt.f32; getF32Ne$Buf: () => rt.f32; getF64$Buf: () => rt.f64; getF64Le$Buf: () => rt.f64; getF64Ne$Buf: () => rt.f64; tryCopyToSlice$Buf: (a0: rt.ByteSlice) => rt.Result; tryGetU8$Buf: () => rt.Result; tryGetI8$Buf: () => rt.Result; tryGetU16$Buf: () => rt.Result; tryGetU16Le$Buf: () => rt.Result; tryGetU16Ne$Buf: () => rt.Result; tryGetI16$Buf: () => rt.Result; tryGetI16Le$Buf: () => rt.Result; tryGetI16Ne$Buf: () => rt.Result; tryGetU32$Buf: () => rt.Result; tryGetU32Le$Buf: () => rt.Result; tryGetU32Ne$Buf: () => rt.Result; tryGetI32$Buf: () => rt.Result; tryGetI32Le$Buf: () => rt.Result; tryGetI32Ne$Buf: () => rt.Result; tryGetU64$Buf: () => rt.Result; tryGetU64Le$Buf: () => rt.Result; tryGetU64Ne$Buf: () => rt.Result; tryGetI64$Buf: () => rt.Result; tryGetI64Le$Buf: () => rt.Result; tryGetI64Ne$Buf: () => rt.Result; tryGetU128$Buf: () => rt.Result; tryGetU128Le$Buf: () => rt.Result; tryGetU128Ne$Buf: () => rt.Result; tryGetI128$Buf: () => rt.Result; tryGetI128Le$Buf: () => rt.Result; tryGetI128Ne$Buf: () => rt.Result; tryGetUint$Buf: (a0: rt.usize) => rt.Result; tryGetUintLe$Buf: (a0: rt.usize) => rt.Result; tryGetUintNe$Buf: (a0: rt.usize) => rt.Result; tryGetInt$Buf: (a0: rt.usize) => rt.Result; tryGetIntLe$Buf: (a0: rt.usize) => rt.Result; tryGetIntNe$Buf: (a0: rt.usize) => rt.Result; tryGetF32$Buf: () => rt.Result; tryGetF32Le$Buf: () => rt.Result; tryGetF32Ne$Buf: () => rt.Result; tryGetF64$Buf: () => rt.Result; tryGetF64Le$Buf: () => rt.Result; tryGetF64Ne$Buf: () => rt.Result; copyToBytes$Buf: (a0: rt.usize) => rt.ByteSlice }; + | { pieces$Leased: () => rs.usize; skip$Leased: (a0: Buf.Buf) => void; remaining$Buf: () => rs.usize; chunk$Buf: () => rs.ByteSlice; advance$Buf: (a0: rs.usize) => void; hasRemaining$Buf: () => boolean; copyToSlice$Buf: (a0: rs.ByteSlice) => void; getU8$Buf: () => rs.u8; getI8$Buf: () => rs.i8; getU16$Buf: () => rs.u16; getU16Le$Buf: () => rs.u16; getU16Ne$Buf: () => rs.u16; getI16$Buf: () => rs.i16; getI16Le$Buf: () => rs.i16; getI16Ne$Buf: () => rs.i16; getU32$Buf: () => rs.u32; getU32Le$Buf: () => rs.u32; getU32Ne$Buf: () => rs.u32; getI32$Buf: () => rs.i32; getI32Le$Buf: () => rs.i32; getI32Ne$Buf: () => rs.i32; getU64$Buf: () => rs.u64; getU64Le$Buf: () => rs.u64; getU64Ne$Buf: () => rs.u64; getI64$Buf: () => rs.i64; getI64Le$Buf: () => rs.i64; getI64Ne$Buf: () => rs.i64; getU128$Buf: () => rs.u128; getU128Le$Buf: () => rs.u128; getU128Ne$Buf: () => rs.u128; getI128$Buf: () => rs.i128; getI128Le$Buf: () => rs.i128; getI128Ne$Buf: () => rs.i128; getUint$Buf: (a0: rs.usize) => rs.u64; getUintLe$Buf: (a0: rs.usize) => rs.u64; getUintNe$Buf: (a0: rs.usize) => rs.u64; getInt$Buf: (a0: rs.usize) => rs.i64; getIntLe$Buf: (a0: rs.usize) => rs.i64; getIntNe$Buf: (a0: rs.usize) => rs.i64; getF32$Buf: () => rs.f32; getF32Le$Buf: () => rs.f32; getF32Ne$Buf: () => rs.f32; getF64$Buf: () => rs.f64; getF64Le$Buf: () => rs.f64; getF64Ne$Buf: () => rs.f64; tryCopyToSlice$Buf: (a0: rs.ByteSlice) => rs.Result; tryGetU8$Buf: () => rs.Result; tryGetI8$Buf: () => rs.Result; tryGetU16$Buf: () => rs.Result; tryGetU16Le$Buf: () => rs.Result; tryGetU16Ne$Buf: () => rs.Result; tryGetI16$Buf: () => rs.Result; tryGetI16Le$Buf: () => rs.Result; tryGetI16Ne$Buf: () => rs.Result; tryGetU32$Buf: () => rs.Result; tryGetU32Le$Buf: () => rs.Result; tryGetU32Ne$Buf: () => rs.Result; tryGetI32$Buf: () => rs.Result; tryGetI32Le$Buf: () => rs.Result; tryGetI32Ne$Buf: () => rs.Result; tryGetU64$Buf: () => rs.Result; tryGetU64Le$Buf: () => rs.Result; tryGetU64Ne$Buf: () => rs.Result; tryGetI64$Buf: () => rs.Result; tryGetI64Le$Buf: () => rs.Result; tryGetI64Ne$Buf: () => rs.Result; tryGetU128$Buf: () => rs.Result; tryGetU128Le$Buf: () => rs.Result; tryGetU128Ne$Buf: () => rs.Result; tryGetI128$Buf: () => rs.Result; tryGetI128Le$Buf: () => rs.Result; tryGetI128Ne$Buf: () => rs.Result; tryGetUint$Buf: (a0: rs.usize) => rs.Result; tryGetUintLe$Buf: (a0: rs.usize) => rs.Result; tryGetUintNe$Buf: (a0: rs.usize) => rs.Result; tryGetInt$Buf: (a0: rs.usize) => rs.Result; tryGetIntLe$Buf: (a0: rs.usize) => rs.Result; tryGetIntNe$Buf: (a0: rs.usize) => rs.Result; tryGetF32$Buf: () => rs.Result; tryGetF32Le$Buf: () => rs.Result; tryGetF32Ne$Buf: () => rs.Result; tryGetF64$Buf: () => rs.Result; tryGetF64Le$Buf: () => rs.Result; tryGetF64Ne$Buf: () => rs.Result; copyToBytes$Buf: (a0: rs.usize) => rs.ByteSlice }; //# sourceMappingURL=buf.Leased.ts.map diff --git a/ts/fixtures/stock/expected/buf.Ops.ts b/ts/fixtures/stock/expected/buf.Ops.ts index b181e1dab..6914f8578 100644 --- a/ts/fixtures/stock/expected/buf.Ops.ts +++ b/ts/fixtures/stock/expected/buf.Ops.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$1fr498u as option_unwrapOr$1fr498u } from "./core/option.ts"; /** The bytes of a case's input, taken from the front. */ export interface Ops { @@ -10,12 +10,12 @@ export interface Ops { _0Len: number; } -export function next(self: Ops): rt.u8 | undefined { +export function next(self: Ops): rs.u8 | undefined { const _8Data: Uint8Array = self._0Data; const _8Start: number = self._0Start; const _8Len: number = self._0Len; if (_8Len !== 0) { - const first: rt.u8 = _8Data[_8Start]; + const first: rs.u8 = _8Data[_8Start]; self._0Data = _8Data; self._0Start = _8Start + 1; self._0Len = _8Len - 1; @@ -24,19 +24,19 @@ export function next(self: Ops): rt.u8 | undefined { return undefined; } -export function byte(self: Ops): rt.u8 { - return option_unwrapOr$0r2bmpr(next(self), 0); +export function byte(self: Ops): rs.u8 { + return option_unwrapOr$1fr498u(next(self), 0); } -export function take(self: Ops, n: rt.usize): rt.ByteSlice { +export function take(self: Ops, n: rs.usize): rs.ByteSlice { const _7Data: Uint8Array = self._0Data; const _7Start: number = self._0Start; const _7Len: number = self._0Len; - const mid: number = rt.min(n, self._0Len); + const mid: number = rs.min(n, self._0Len); if (mid > _7Len) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const taken: rt.ByteSlice = new rt.ByteSlice(_7Data, _7Start, mid); + const taken: rs.ByteSlice = new rs.ByteSlice(_7Data, _7Start, mid); self._0Data = _7Data; self._0Start = _7Start + mid; self._0Len = _7Len - mid; diff --git a/ts/fixtures/stock/expected/buf.Pieces.ts b/ts/fixtures/stock/expected/buf.Pieces.ts index d9e3ed7f5..7896d5cc3 100644 --- a/ts/fixtures/stock/expected/buf.Pieces.ts +++ b/ts/fixtures/stock/expected/buf.Pieces.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$f32, out$f64, out$i64, out$i8, out$u128, out$u16, out$u64, out$u8 } from "./lib.ts"; import type * as Provided from "./buf.Provided.ts"; import { panicAdvance, panicDoesNotFit } from "./bytes.ts"; @@ -10,23 +10,23 @@ import * as Chain from "./bytes/buf/chain.Chain.ts"; import { new_$mut_buf_Pieces as take_new_$mut_buf_Pieces } from "./bytes/buf/take.ts"; import type * as Take from "./bytes/buf/take.Take.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; -import { unwrapOrElse$1wp5sd9 as result_unwrapOrElse$1wp5sd9, unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "./core/result.ts"; +import { unwrapOrElse$1b4ownx as result_unwrapOrElse$1b4ownx, unwrapOrElse$1fg63zn as result_unwrapOrElse$1fg63zn } from "./core/result.ts"; /** A buffer of the crate's own, in pieces: `Buf`'s provided methods read across them. */ export interface Pieces { /** None empty, so `chunk` is empty only once nothing remains, as `Buf` requires. */ - parts: rt.Vec; + parts: rs.Vec; /** How far into the first part reads are. */ - at: rt.usize; + at: rs.usize; } /** `input` in two parts, cut at `cut`. */ -function new_(inputData: Uint8Array, inputStart: number, inputLen: number, cut: rt.usize): Pieces { +function new_(inputData: Uint8Array, inputStart: number, inputLen: number, cut: rs.usize): Pieces { if (cut > inputLen) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const parts: rt.Vec = rt.vecFrom([rt.byteSliceToByteVec(new rt.ByteSlice(inputData, inputStart, cut)), rt.byteSliceToByteVec(new rt.ByteSlice(inputData, inputStart + cut, inputLen - cut))]); - rt.vecRetain(parts, (part: rt.ByteVec): boolean => { + const parts: rs.Vec = rs.vecFrom([rs.byteSliceToByteVec(new rs.ByteSlice(inputData, inputStart, cut)), rs.byteSliceToByteVec(new rs.ByteSlice(inputData, inputStart + cut, inputLen - cut))]); + rs.vecRetain(parts, (part: rs.ByteVec): boolean => { return !(part.length === 0); }); return { parts, at: 0 }; @@ -59,10 +59,10 @@ function new_(inputData: Uint8Array, inputStart: number, inputLen: number, cut: * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf(self: Pieces): rt.usize { - return rt.usizeSub(rt.iterSum(rt.iterMap(rt.iterSlice(self.parts.items), (a0: rt.ByteVec): rt.usize => { +export function remaining$bytes_Buf(self: Pieces): rs.usize { + return rs.usizeSub(rs.iterSum(rs.iterMap(rs.iterSlice(self.parts.items), (a0: rs.ByteVec): rs.usize => { return a0.length; - }), rt.usizeAdd, 0), self.at); + }), rs.usizeAdd, 0), self.at); } /** @@ -95,13 +95,13 @@ export function remaining$bytes_Buf(self: Pieces): rt.usize { * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf(self: Pieces): rt.ByteSlice { - const _3: rt.ByteVec | undefined = rt.sliceFirst(self.parts.items); +export function chunk$bytes_Buf(self: Pieces): rs.ByteSlice { + const _3: rs.ByteVec | undefined = rs.sliceFirst(self.parts.items); if (_3 === undefined) { - return rt.byteSliceFrom(Uint8Array.of()); + return rs.byteSliceFrom(Uint8Array.of()); } const part = self.at; - return rt.byteSliceRange(rt.byteVecSlice(_3), part); + return rs.byteSliceRange(rs.byteVecSlice(_3), part); } /** @@ -136,15 +136,15 @@ export function chunk$bytes_Buf(self: Pieces): rt.ByteSlice { * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf(self: Pieces, cnt: rt.usize): void { +export function advance$bytes_Buf(self: Pieces, cnt: rs.usize): void { while (cnt > 0) { - const left: rt.usize = rt.usizeSub(self.parts.items[rt.idx(self.parts.items, 0)].length, self.at); + const left: rs.usize = rs.usizeSub(self.parts.items[rs.idx(self.parts.items, 0)].length, self.at); if (!(cnt < left)) { - cnt = rt.usizeSub(cnt, left); - rt.vecRemove(self.parts, 0); + cnt = rs.usizeSub(cnt, left); + rs.vecRemove(self.parts, 0); self.at = 0; } else { - self.at = rt.usizeAdd(self.at, cnt); + self.at = rs.usizeAdd(self.at, cnt); break; } } @@ -171,22 +171,22 @@ export function advance$bytes_Buf(self: Pieces, cnt: rt.usize): void { * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf(self: Pieces, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf(self: Pieces, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const out: rt.BytesMut = rt.bytesMutWithCapacity(len); + const out: rs.BytesMut = rs.bytesMutWithCapacity(len); while (out.length < len) { - const take: rt.usize = rt.min(chunk$bytes_Buf_mut(self).length, rt.usizeSub(len, out.length)); - const _22: rt.ByteSlice = rt.byteSliceRange(chunk$bytes_Buf_mut(self), 0, take); - rt.bytesMutExtend(out, _22); + const take: rs.usize = rs.min(chunk$bytes_Buf_mut(self).length, rs.usizeSub(len, out.length)); + const _22: rs.ByteSlice = rs.byteSliceRange(chunk$bytes_Buf_mut(self), 0, take); + rs.bytesMutExtend(out, _22); advance$bytes_Buf(self, take); } - return rt.bytesMutFreeze(out); + return rs.bytesMutFreeze(out); } } -export function pieces$buf_Leased(self: Pieces): rt.usize { +export function pieces$buf_Leased(self: Pieces): rs.usize { return self.parts.items.length; } @@ -195,7 +195,7 @@ export function skip$buf_Leased(self: Pieces, other: Buf.Buf): void { if (hasRemaining$bytes_Buf_mut_dyn_bytes_Buf(other)) { other.advance$Buf(1); } - const _7: rt.usize = rt.min(remaining$bytes_Buf_mut_dyn_bytes_Buf(other), remaining$bytes_Buf_mut(self)); + const _7: rs.usize = rs.min(remaining$bytes_Buf_mut_dyn_bytes_Buf(other), remaining$bytes_Buf_mut(self)); advance$bytes_Buf(self, _7); } @@ -245,8 +245,8 @@ export function hasRemaining$bytes_Buf(self: Pieces): boolean { * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf(self: Pieces, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf(self: Pieces, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -269,11 +269,11 @@ export function copyToSlice$bytes_Buf(self: Pieces, dst: rt.ByteSlice): void { * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf(self: Pieces): rt.u8 { +export function getU8$bytes_Buf(self: Pieces): rs.u8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf(self, 1); return ret; } @@ -298,11 +298,11 @@ export function getU8$bytes_Buf(self: Pieces): rt.u8 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf(self: Pieces): rt.i8 { +export function getI8$bytes_Buf(self: Pieces): rs.i8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf(self, 1); return ret; } @@ -328,21 +328,21 @@ export function getI8$bytes_Buf(self: Pieces): rt.i8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -366,20 +366,20 @@ export function getUint$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -406,7 +406,7 @@ export function getUintLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { +export function getUintNe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 { return getUintLe$bytes_Buf(self, nbytes); } @@ -429,7 +429,7 @@ export function getUintNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getInt$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { +export function getInt$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 { return signExtend(getUint$bytes_Buf(self, nbytes), nbytes); } @@ -452,7 +452,7 @@ export function getInt$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf(self, nbytes), nbytes); } @@ -478,7 +478,7 @@ export function getIntLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { +export function getIntNe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 { return getIntLe$bytes_Buf(self, nbytes); } @@ -501,8 +501,8 @@ export function getIntNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF32$bytes_Buf(self: Pieces): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, false, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF32$bytes_Buf(self: Pieces): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, false, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -524,8 +524,8 @@ export function getF32$bytes_Buf(self: Pieces): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf(self: Pieces): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf(self: Pieces): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -550,8 +550,8 @@ export function getF32Le$bytes_Buf(self: Pieces): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Ne$bytes_Buf(self: Pieces): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF32Ne$bytes_Buf(self: Pieces): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -573,8 +573,8 @@ export function getF32Ne$bytes_Buf(self: Pieces): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf(self: Pieces): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf(self: Pieces): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -596,8 +596,8 @@ export function getF64$bytes_Buf(self: Pieces): rt.f64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64Le$bytes_Buf(self: Pieces): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, true, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF64Le$bytes_Buf(self: Pieces): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, true, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -622,8 +622,8 @@ export function getF64Le$bytes_Buf(self: Pieces): rt.f64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64Ne$bytes_Buf(self: Pieces): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, true, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined)); +export function getF64Ne$bytes_Buf(self: Pieces): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, true, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined)); } /** @@ -658,18 +658,18 @@ export function getF64Ne$bytes_Buf(self: Pieces): rt.f64 { * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf(self: Pieces, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf(self: Pieces, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); } /** @@ -697,11 +697,11 @@ export function tryCopyToSlice$bytes_Buf(self: Pieces, dst: rt.ByteSlice): rt.Re * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf(self: Pieces): rt.u8 | undefined { +export function tryGetU8$bytes_Buf(self: Pieces): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf(self, 1); return ret; } @@ -734,11 +734,11 @@ export function tryGetU8$bytes_Buf(self: Pieces): rt.u8 | undefined { * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_i8()); * ``` */ -export function tryGetI8$bytes_Buf(self: Pieces): rt.i8 | undefined { +export function tryGetI8$bytes_Buf(self: Pieces): rs.i8 | undefined { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _10: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_10, 0); - const ret: rt.i8 = (_10.data[_10.start] << 24) >> 24; + const _10: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_10, 0); + const ret: rs.i8 = (_10.data[_10.start] << 24) >> 24; advance$bytes_Buf(self, 1); return ret; } @@ -776,16 +776,16 @@ export function tryGetI8$bytes_Buf(self: Pieces): rt.i8 | undefined { * * This function panics if `nbytes` > 8. */ -export function tryGetUint$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | undefined { - const _3: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function tryGetUint$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 | undefined { + const _3: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_3 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _3; - const buf: Uint8Array = rt.bytes(8); - const _8: rt.Result = tryCopyToSlice$bytes_Buf(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _3; + const buf: Uint8Array = rs.bytes(8); + const _8: rs.Result = tryCopyToSlice$bytes_Buf(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_8.ok) { - return rt.u64FromBeBytes(buf); + return rs.u64FromBeBytes(buf); } out$u64.err = (_8 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -822,15 +822,15 @@ export function tryGetUint$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | u * * This function panics if `nbytes` > 8. */ -export function tryGetUintLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | undefined { - const buf: Uint8Array = rt.bytes(8); - const _4: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function tryGetUintLe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 | undefined { + const buf: Uint8Array = rs.bytes(8); + const _4: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_4 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _11: rt.Result = tryCopyToSlice$bytes_Buf(self, _4); + const _11: rs.Result = tryCopyToSlice$bytes_Buf(self, _4); if (_11.ok) { - return rt.u64FromBeBytes(buf.slice().reverse()); + return rs.u64FromBeBytes(buf.slice().reverse()); } out$u64.err = (_11 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -873,7 +873,7 @@ export function tryGetUintLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | * * This function panics if `nbytes` is greater than 8. */ -export function tryGetUintNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | undefined { +export function tryGetUintNe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.u64 | undefined { return tryGetUintLe$bytes_Buf(self, nbytes); } @@ -907,16 +907,16 @@ export function tryGetUintNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.u64 | * * This function panics if `nbytes` is greater than 8. */ -export function tryGetInt$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | undefined { - const _3: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function tryGetInt$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 | undefined { + const _3: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_3 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _3; - const buf: Uint8Array = rt.bytes(8); - const _8: rt.Result = tryCopyToSlice$bytes_Buf(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _3; + const buf: Uint8Array = rs.bytes(8); + const _8: rs.Result = tryCopyToSlice$bytes_Buf(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_8.ok) { - return rt.i64FromBeBytes(buf); + return rs.i64FromBeBytes(buf); } out$i64.err = (_8 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -953,15 +953,15 @@ export function tryGetInt$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | un * * This function panics if `nbytes` is greater than 8. */ -export function tryGetIntLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | undefined { - const buf: Uint8Array = rt.bytes(8); - const _4: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function tryGetIntLe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 | undefined { + const buf: Uint8Array = rs.bytes(8); + const _4: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_4 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _11: rt.Result = tryCopyToSlice$bytes_Buf(self, _4); + const _11: rs.Result = tryCopyToSlice$bytes_Buf(self, _4); if (_11.ok) { - return rt.i64FromBeBytes(buf.slice().reverse()); + return rs.i64FromBeBytes(buf.slice().reverse()); } out$i64.err = (_11 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1004,7 +1004,7 @@ export function tryGetIntLe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | * * This function panics if `nbytes` is greater than 8. */ -export function tryGetIntNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | undefined { +export function tryGetIntNe$bytes_Buf(self: Pieces, nbytes: rs.usize): rs.i64 | undefined { return tryGetIntLe$bytes_Buf(self, nbytes); } @@ -1035,10 +1035,10 @@ export function tryGetIntNe$bytes_Buf(self: Pieces, nbytes: rt.usize): rt.i64 | * assert_eq!(3, buf.remaining()); * ``` */ -export function tryGetF32$bytes_Buf(self: Pieces): rt.f32 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 4, false, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF32$bytes_Buf(self: Pieces): rs.f32 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 4, false, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f32FromBits(_3.value); + return rs.f32FromBits(_3.value); } out$f32.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1071,10 +1071,10 @@ export function tryGetF32$bytes_Buf(self: Pieces): rt.f32 | undefined { * assert_eq!(3, buf.remaining()); * ``` */ -export function tryGetF32Le$bytes_Buf(self: Pieces): rt.f32 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF32Le$bytes_Buf(self: Pieces): rs.f32 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f32FromBits(_3.value); + return rs.f32FromBits(_3.value); } out$f32.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1110,10 +1110,10 @@ export function tryGetF32Le$bytes_Buf(self: Pieces): rt.f32 | undefined { * assert_eq!(3, buf.remaining()); * ``` */ -export function tryGetF32Ne$bytes_Buf(self: Pieces): rt.f32 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF32Ne$bytes_Buf(self: Pieces): rs.f32 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f32FromBits(_3.value); + return rs.f32FromBits(_3.value); } out$f32.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1146,10 +1146,10 @@ export function tryGetF32Ne$bytes_Buf(self: Pieces): rt.f32 | undefined { * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetF64$bytes_Buf(self: Pieces): rt.f64 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF64$bytes_Buf(self: Pieces): rs.f64 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f64FromBits(_3.value); + return rs.f64FromBits(_3.value); } out$f64.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1182,10 +1182,10 @@ export function tryGetF64$bytes_Buf(self: Pieces): rt.f64 | undefined { * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetF64Le$bytes_Buf(self: Pieces): rt.f64 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 8, true, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF64Le$bytes_Buf(self: Pieces): rs.f64 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 8, true, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f64FromBits(_3.value); + return rs.f64FromBits(_3.value); } out$f64.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1221,10 +1221,10 @@ export function tryGetF64Le$bytes_Buf(self: Pieces): rt.f64 | undefined { * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetF64Ne$bytes_Buf(self: Pieces): rt.f64 | undefined { - const _3: rt.Result = rt.bufTryGet(self, 8, true, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetF64Ne$bytes_Buf(self: Pieces): rs.f64 | undefined { + const _3: rs.Result = rs.bufTryGet(self, 8, true, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (_3.ok) { - return rt.f64FromBits(_3.value); + return rs.f64FromBits(_3.value); } out$f64.err = (_3 as { ok: false; error: TryGetError.TryGetError }).error; return undefined; @@ -1253,7 +1253,7 @@ export function tryGetF64Ne$bytes_Buf(self: Pieces): rt.f64 | undefined { * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_mut(self: Pieces, limit: rt.usize): Take.Take { +export function take$bytes_Buf_mut(self: Pieces, limit: rs.usize): Take.Take { return take_new_$mut_buf_Pieces(self, limit); } @@ -1310,7 +1310,7 @@ export function chain$bytes_Buf_buf_Provided(self: Pieces, next: Provided.Provid * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut(self: rt.Place, cnt: rt.usize): void { +export function advance$bytes_Buf_mut(self: rs.Place, cnt: rs.usize): void { advance$bytes_Buf(self.v, cnt); } @@ -1344,7 +1344,7 @@ export function advance$bytes_Buf_mut(self: rt.Place, cnt: rt.usize): vo * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut(self: Pieces): rt.ByteSlice { +export function chunk$bytes_Buf_mut(self: Pieces): rs.ByteSlice { return chunk$bytes_Buf(self); } @@ -1369,7 +1369,7 @@ export function chunk$bytes_Buf_mut(self: Pieces): rt.ByteSlice { * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut(self: rt.Place, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut(self: rs.Place, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf(self.v, len); } @@ -1396,7 +1396,7 @@ export function copyToBytes$bytes_Buf_mut(self: rt.Place, len: rt.usize) * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_mut(self: rt.Place, dst: rt.ByteSlice): void { +export function copyToSlice$bytes_Buf_mut(self: rs.Place, dst: rs.ByteSlice): void { copyToSlice$bytes_Buf(self.v, dst); } @@ -1419,7 +1419,7 @@ export function copyToSlice$bytes_Buf_mut(self: rt.Place, dst: rt.ByteSl * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_mut(self: rt.Place): rt.f32 { +export function getF32Le$bytes_Buf_mut(self: rs.Place): rs.f32 { return getF32Le$bytes_Buf(self.v); } @@ -1442,7 +1442,7 @@ export function getF32Le$bytes_Buf_mut(self: rt.Place): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_mut(self: rt.Place): rt.f64 { +export function getF64$bytes_Buf_mut(self: rs.Place): rs.f64 { return getF64$bytes_Buf(self.v); } @@ -1464,8 +1464,8 @@ export function getF64$bytes_Buf_mut(self: rt.Place): rt.f64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getI128$bytes_Buf_mut(self: rt.Place): rt.i128 { - return rt.bufGet(self.v, 16, false, rt.i128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getI128$bytes_Buf_mut(self: rs.Place): rs.i128 { + return rs.bufGet(self.v, 16, false, rs.i128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1486,8 +1486,8 @@ export function getI128$bytes_Buf_mut(self: rt.Place): rt.i128 { * * This function panics if there is not enough remaining data in `self`. */ -export function getI16Le$bytes_Buf_mut(self: rt.Place): rt.i16 { - return rt.bufGet(self.v, 2, true, rt.i16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getI16Le$bytes_Buf_mut(self: rs.Place): rs.i16 { + return rs.bufGet(self.v, 2, true, rs.i16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1508,8 +1508,8 @@ export function getI16Le$bytes_Buf_mut(self: rt.Place): rt.i16 { * * This function panics if there is not enough remaining data in `self`. */ -export function getI32$bytes_Buf_mut(self: rt.Place): rt.i32 { - return rt.bufGet(self.v, 4, false, rt.i32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getI32$bytes_Buf_mut(self: rs.Place): rs.i32 { + return rs.bufGet(self.v, 4, false, rs.i32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1530,8 +1530,8 @@ export function getI32$bytes_Buf_mut(self: rt.Place): rt.i32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getI64Le$bytes_Buf_mut(self: rt.Place): rt.i64 { - return rt.bufGet(self.v, 8, true, rt.i64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getI64Le$bytes_Buf_mut(self: rs.Place): rs.i64 { + return rs.bufGet(self.v, 8, true, rs.i64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1552,7 +1552,7 @@ export function getI64Le$bytes_Buf_mut(self: rt.Place): rt.i64 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_mut(self: rt.Place): rt.i8 { +export function getI8$bytes_Buf_mut(self: rs.Place): rs.i8 { return getI8$bytes_Buf(self.v); } @@ -1575,7 +1575,7 @@ export function getI8$bytes_Buf_mut(self: rt.Place): rt.i8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_mut(self: rt.Place, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_mut(self: rs.Place, nbytes: rs.usize): rs.i64 { return getIntLe$bytes_Buf(self.v, nbytes); } @@ -1597,8 +1597,8 @@ export function getIntLe$bytes_Buf_mut(self: rt.Place, nbytes: rt.usize) * * This function panics if there is not enough remaining data in `self`. */ -export function getU128Le$bytes_Buf_mut(self: rt.Place): rt.u128 { - return rt.bufGet(self.v, 16, true, rt.u128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getU128Le$bytes_Buf_mut(self: rs.Place): rs.u128 { + return rs.bufGet(self.v, 16, true, rs.u128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1619,8 +1619,8 @@ export function getU128Le$bytes_Buf_mut(self: rt.Place): rt.u128 { * * This function panics if there is not enough remaining data in `self`. */ -export function getU16$bytes_Buf_mut(self: rt.Place): rt.u16 { - return rt.bufGet(self.v, 2, false, rt.u16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getU16$bytes_Buf_mut(self: rs.Place): rs.u16 { + return rs.bufGet(self.v, 2, false, rs.u16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1641,8 +1641,8 @@ export function getU16$bytes_Buf_mut(self: rt.Place): rt.u16 { * * This function panics if there is not enough remaining data in `self`. */ -export function getU32Le$bytes_Buf_mut(self: rt.Place): rt.u32 { - return rt.bufGet(self.v, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getU32Le$bytes_Buf_mut(self: rs.Place): rs.u32 { + return rs.bufGet(self.v, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1663,8 +1663,8 @@ export function getU32Le$bytes_Buf_mut(self: rt.Place): rt.u32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getU64$bytes_Buf_mut(self: rt.Place): rt.u64 { - return rt.bufGet(self.v, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function getU64$bytes_Buf_mut(self: rs.Place): rs.u64 { + return rs.bufGet(self.v, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); } /** @@ -1685,7 +1685,7 @@ export function getU64$bytes_Buf_mut(self: rt.Place): rt.u64 { * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_mut(self: rt.Place): rt.u8 { +export function getU8$bytes_Buf_mut(self: rs.Place): rs.u8 { return getU8$bytes_Buf(self.v); } @@ -1708,7 +1708,7 @@ export function getU8$bytes_Buf_mut(self: rt.Place): rt.u8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_mut(self: rt.Place, nbytes: rt.usize): rt.u64 { +export function getUint$bytes_Buf_mut(self: rs.Place, nbytes: rs.usize): rs.u64 { return getUint$bytes_Buf(self.v, nbytes); } @@ -1754,7 +1754,7 @@ export function hasRemaining$bytes_Buf_mut(self: Pieces): boolean { * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_mut_mut(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_mut_mut(self: rs.Place): boolean { return hasRemaining$bytes_Buf_mut(self.v); } @@ -1785,7 +1785,7 @@ export function hasRemaining$bytes_Buf_mut_mut(self: rt.Place): boolean * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut(self: Pieces): rt.usize { +export function remaining$bytes_Buf_mut(self: Pieces): rs.usize { return remaining$bytes_Buf(self); } @@ -1816,7 +1816,7 @@ export function remaining$bytes_Buf_mut(self: Pieces): rt.usize { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_mut(self: rt.Place): rt.usize { +export function remaining$bytes_Buf_mut_mut(self: rs.Place): rs.usize { return remaining$bytes_Buf_mut(self.v); } @@ -1846,8 +1846,8 @@ export function remaining$bytes_Buf_mut_mut(self: rt.Place): rt.usize { * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetI64Le$bytes_Buf_mut(self: rt.Place): rt.i64 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 8, true, rt.i64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetI64Le$bytes_Buf_mut(self: rs.Place): rs.i64 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 8, true, rs.i64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (!_0.ok) { out$i64.err = _0.error; return undefined; @@ -1881,8 +1881,8 @@ export function tryGetI64Le$bytes_Buf_mut(self: rt.Place): rt.i64 | unde * assert_eq!(15, buf.remaining()); * ``` */ -export function tryGetU128$bytes_Buf_mut(self: rt.Place): rt.u128 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 16, false, rt.u128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetU128$bytes_Buf_mut(self: rs.Place): rs.u128 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 16, false, rs.u128FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (!_0.ok) { out$u128.err = _0.error; return undefined; @@ -1916,8 +1916,8 @@ export function tryGetU128$bytes_Buf_mut(self: rt.Place): rt.u128 | unde * assert_eq!(1, buf.remaining()); * ``` */ -export function tryGetU16$bytes_Buf_mut(self: rt.Place): rt.u16 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 2, false, rt.u16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rt.ByteSlice) => undefined); +export function tryGetU16$bytes_Buf_mut(self: rs.Place): rs.u16 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 2, false, rs.u16FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Pieces, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Pieces, a1: rs.ByteSlice) => undefined); if (!_0.ok) { out$u16.err = _0.error; return undefined; @@ -1950,7 +1950,7 @@ export function tryGetU16$bytes_Buf_mut(self: rt.Place): rt.u16 | undefi * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_mut(self: rt.Place): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_mut(self: rs.Place): rs.u8 | undefined { return tryGetU8$bytes_Buf(self.v); } diff --git a/ts/fixtures/stock/expected/buf.Provided.ts b/ts/fixtures/stock/expected/buf.Provided.ts index 72958dee7..7dbf423b2 100644 --- a/ts/fixtures/stock/expected/buf.Provided.ts +++ b/ts/fixtures/stock/expected/buf.Provided.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { out$u8 } from "./lib.ts"; import * as Pieces from "./buf.Pieces.ts"; import { panicAdvance, panicDoesNotFit } from "./bytes.ts"; @@ -9,7 +9,7 @@ import * as Chain from "./bytes/buf/chain.Chain.ts"; import { new_$mut_buf_Provided as take_new_$mut_buf_Provided } from "./bytes/buf/take.ts"; import type * as Take from "./bytes/buf/take.Take.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; -import { unwrapOrElse$1wp5sd9 as result_unwrapOrElse$1wp5sd9, unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "./core/result.ts"; +import { unwrapOrElse$1b4ownx as result_unwrapOrElse$1b4ownx, unwrapOrElse$1fg63zn as result_unwrapOrElse$1fg63zn } from "./core/result.ts"; /** * A buffer in pieces with only `Buf`'s required methods, so `copy_to_bytes` is the @@ -46,7 +46,7 @@ export interface Provided { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf(self: Provided): rt.usize { +export function remaining$bytes_Buf(self: Provided): rs.usize { return Pieces.remaining$bytes_Buf(self._0); } @@ -80,7 +80,7 @@ export function remaining$bytes_Buf(self: Provided): rt.usize { * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf(self: Provided): rt.ByteSlice { +export function chunk$bytes_Buf(self: Provided): rs.ByteSlice { return Pieces.chunk$bytes_Buf(self._0); } @@ -116,7 +116,7 @@ export function chunk$bytes_Buf(self: Provided): rt.ByteSlice { * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf(self: Provided, cnt: rt.usize): void { +export function advance$bytes_Buf(self: Provided, cnt: rs.usize): void { Pieces.advance$bytes_Buf(self._0, cnt); } @@ -166,8 +166,8 @@ export function hasRemaining$bytes_Buf(self: Provided): boolean { * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf(self: Provided, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf(self: Provided, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -190,11 +190,11 @@ export function copyToSlice$bytes_Buf(self: Provided, dst: rt.ByteSlice): void { * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf(self: Provided): rt.u8 { +export function getU8$bytes_Buf(self: Provided): rs.u8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf(self, 1); return ret; } @@ -219,11 +219,11 @@ export function getU8$bytes_Buf(self: Provided): rt.u8 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf(self: Provided): rt.i8 { +export function getI8$bytes_Buf(self: Provided): rs.i8 { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf(self, 1); return ret; } @@ -249,21 +249,21 @@ export function getI8$bytes_Buf(self: Provided): rt.i8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf(self: Provided, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf(self: Provided, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -287,20 +287,20 @@ export function getUint$bytes_Buf(self: Provided, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf(self: Provided, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf(self: Provided, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -324,7 +324,7 @@ export function getUintLe$bytes_Buf(self: Provided, nbytes: rt.usize): rt.u64 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf(self: Provided, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf(self: Provided, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf(self, nbytes), nbytes); } @@ -347,8 +347,8 @@ export function getIntLe$bytes_Buf(self: Provided, nbytes: rt.usize): rt.i64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf(self: Provided): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Provided, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf(self: Provided): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Provided, a1: rs.ByteSlice) => undefined)); } /** @@ -370,8 +370,8 @@ export function getF32Le$bytes_Buf(self: Provided): rt.f32 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf(self: Provided): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rt.usize) => undefined, copyToSlice$bytes_Buf as (a0: Provided, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf(self: Provided): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rs.usize) => undefined, copyToSlice$bytes_Buf as (a0: Provided, a1: rs.ByteSlice) => undefined)); } /** @@ -406,18 +406,18 @@ export function getF64$bytes_Buf(self: Provided): rt.f64 { * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf(self: Provided, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf(self: Provided, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_mut(self) }); } /** @@ -445,11 +445,11 @@ export function tryCopyToSlice$bytes_Buf(self: Provided, dst: rt.ByteSlice): rt. * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf(self: Provided): rt.u8 | undefined { +export function tryGetU8$bytes_Buf(self: Provided): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf(self, 1); return ret; } @@ -480,7 +480,7 @@ export function tryGetU8$bytes_Buf(self: Provided): rt.u8 | undefined { * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_mut(self: Provided, limit: rt.usize): Take.Take { +export function take$bytes_Buf_mut(self: Provided, limit: rs.usize): Take.Take { return take_new_$mut_buf_Provided(self, limit); } @@ -501,7 +501,7 @@ export function take$bytes_Buf_mut(self: Provided, limit: rt.usize): Take.Take

{ +export function chain$bytes_Buf_bytes_Bytes(self: Provided, next: rs.ByteSlice): Chain.Chain { return Chain.new$buf_Provided_bytes_Bytes(self, next); } @@ -522,7 +522,7 @@ export function chain$bytes_Buf_bytes_Bytes(self: Provided, next: rt.ByteSlice): * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_mut_ref_slice_u8(self: Provided, next: rt.Place): Chain.Chain> { +export function chain$bytes_Buf_mut_ref_slice_u8(self: Provided, next: rs.Place): Chain.Chain> { return Chain.new$buf_Provided_mut_ref_slice_u8(self, next); } @@ -543,7 +543,7 @@ export function chain$bytes_Buf_mut_ref_slice_u8(self: Provided, next: rt.Place< * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_ref_slice_u8(self: Provided, next: rt.ByteSlice): Chain.Chain { +export function chain$bytes_Buf_ref_slice_u8(self: Provided, next: rs.ByteSlice): Chain.Chain { return Chain.new$buf_Provided_ref_slice_u8(self, next); } @@ -579,7 +579,7 @@ export function chain$bytes_Buf_ref_slice_u8(self: Provided, next: rt.ByteSlice) * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut(self: rt.Place, cnt: rt.usize): void { +export function advance$bytes_Buf_mut(self: rs.Place, cnt: rs.usize): void { advance$bytes_Buf(self.v, cnt); } @@ -613,7 +613,7 @@ export function advance$bytes_Buf_mut(self: rt.Place, cnt: rt.usize): * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut(self: Provided): rt.ByteSlice { +export function chunk$bytes_Buf_mut(self: Provided): rs.ByteSlice { return chunk$bytes_Buf(self); } @@ -638,8 +638,8 @@ export function chunk$bytes_Buf_mut(self: Provided): rt.ByteSlice { * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut(self: rt.Place, len: rt.usize): rt.ByteSlice { - return rt.bufCopyToBytes(self.v, len, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rt.usize) => undefined); +export function copyToBytes$bytes_Buf_mut(self: rs.Place, len: rs.usize): rs.ByteSlice { + return rs.bufCopyToBytes(self.v, len, remaining$bytes_Buf, chunk$bytes_Buf, advance$bytes_Buf as (a0: Provided, a1: rs.usize) => undefined); } /** @@ -692,7 +692,7 @@ export function hasRemaining$bytes_Buf_mut(self: Provided): boolean { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut(self: Provided): rt.usize { +export function remaining$bytes_Buf_mut(self: Provided): rs.usize { return remaining$bytes_Buf(self); } diff --git a/ts/fixtures/stock/expected/buf.ts b/ts/fixtures/stock/expected/buf.ts index ccd0260c9..17684f527 100644 --- a/ts/fixtures/stock/expected/buf.ts +++ b/ts/fixtures/stock/expected/buf.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Option_bytes_Bytes as lib_drop$Option_bytes_Bytes, drop$bytes_buf_Chain_buf_Provided_bytes_Bytes as lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes, drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8 as lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8, drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces as lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces, drop$bytes_buf_Take_bytes_Bytes as lib_drop$bytes_buf_Take_bytes_Bytes, of$buf_Counted, of$buf_Pieces, of$buf_Provided, of$bytes_Bytes, of$bytes_BytesMut, of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8, of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, of$bytes_buf_Take_bytes_Bytes, of$bytes_buf_Take_ref_slice_u8, of$ref_slice_u8, ofPlace$bytes_Bytes, ofPlace$ref_slice_u8, out$i64, out$u128, out$u16, out$u8 } from "./lib.ts"; import * as buf_Counted from "./buf.Counted.ts"; import type * as Leased from "./buf.Leased.ts"; @@ -13,8 +13,8 @@ import { putI16Le$bytes_BufMut_mut_Vec_u8, putI16Le$bytes_BufMut_mut_bytes_Bytes import * as Chain from "./bytes/buf/chain.Chain.ts"; import * as Take from "./bytes/buf/take.Take.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; -import { clone$0ey9vhe as option_clone$0ey9vhe } from "./core/option.ts"; -import { map$0c3nzkx as result_map$0c3nzkx, map$0hs8st9 as result_map$0hs8st9, map$01kzrm1 as result_map$01kzrm1 } from "./core/result.ts"; +import { clone$1i3gmk3 as option_clone$1i3gmk3 } from "./core/option.ts"; +import { map$1rpus2m as result_map$1rpus2m, map$1cosroz as result_map$1cosroz, map$1k6isgs as result_map$1k6isgs } from "./core/result.ts"; /** * A `BytesMut` split, frozen, grown, written, and joined, its handles and `Bytes` dropped, @@ -23,1497 +23,1497 @@ import { map$0c3nzkx as result_map$0c3nzkx, map$0hs8st9 as result_map$0hs8st9, m * and so would a capacity `bytes` reclaimed only once the other handles of its storage * dropped, or a write to its spare room that missed its storage. */ -export function bytesMut(data: rt.ByteSlice, out: rt.ByteVec): void { - let _80!: rt.usize; - let _101!: rt.usize; - let _351!: rt.usize; +export function bytesMut(data: rs.ByteSlice, out: rs.ByteVec): void { + let _80!: rs.usize; + let _101!: rs.usize; + let _351!: rs.usize; const ops: Ops.Ops = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; - let buf: rt.BytesMut = rt.bytesMutWithCapacity(rt.usizeRem(Ops.byte(ops) as rt.usize, 24)); - const pieces: rt.Vec = new rt.Vec(); - const frozen: rt.Vec = new rt.Vec(); + let buf: rs.BytesMut = rs.bytesMutWithCapacity(rs.usizeRem(Ops.byte(ops) as rs.usize, 24)); + const pieces: rs.Vec = new rs.Vec(); + const frozen: rs.Vec = new rs.Vec(); while (true) { - const _13: rt.u8 | undefined = Ops.next(ops); + const _13: rs.u8 | undefined = Ops.next(ops); if (_13 !== undefined) { - const op: rt.u8 = _13; - const n: rt.usize = Ops.byte(ops) as rt.usize; - const _20: rt.u8 = rt.u8Rem(op, 30); + const op: rs.u8 = _13; + const n: rs.usize = Ops.byte(ops) as rs.usize; + const _20: rs.u8 = rs.u8Rem(op, 30); if (_20 === 0) { - const _23: rt.ByteSlice = Ops.take(ops, rt.usizeRem(n, 12)); - rt.bytesMutExtend(buf, _23); + const _23: rs.ByteSlice = Ops.take(ops, rs.usizeRem(n, 12)); + rs.bytesMutExtend(buf, _23); continue; } if (_20 === 1) { - rt.bytesMutPutWord(buf, n & 0xff, 1, false); + rs.bytesMutPutWord(buf, n & 0xff, 1, false); continue; } if (_20 === 2) { - rt.bytesMutPutWord(buf, rt.u16Mul(n & 0xffff, 257), 2, false); + rs.bytesMutPutWord(buf, rs.u16Mul(n & 0xffff, 257), 2, false); continue; } if (_20 === 3) { - const _34: rt.BytesMut = rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); + const _34: rs.BytesMut = rs.bytesMutSplitTo(buf, rs.usizeRem(n, rs.usizeAdd(buf.length, 2))); pieces.items.push(_34); continue; } if (_20 === 4) { - const _42: rt.BytesMut | undefined = rt.vecPop(pieces); + const _42: rs.BytesMut | undefined = rs.vecPop(pieces); if (_42 !== undefined) { - const _48: rt.ByteSlice = rt.bytesMutFreeze(_42); + const _48: rs.ByteSlice = rs.bytesMutFreeze(_42); frozen.items.push(_48); continue; } continue; } if (_20 === 5) { - rt.bytesMutTruncate(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); + rs.bytesMutTruncate(buf, rs.usizeRem(n, rs.usizeAdd(buf.length, 2))); continue; } if (_20 === 6) { - rt.bytesMutResize(buf, rt.usizeRem(n, 40), n & 0xff); + rs.bytesMutResize(buf, rs.usizeRem(n, 40), n & 0xff); continue; } if (_20 === 7) { - if (!(rt.usizeRem(n, 4) === 0)) { - if (!(rt.usizeRem(n, 4) === 2)) { - rt.bytesMutReserve(buf, n); + if (!(rs.usizeRem(n, 4) === 0)) { + if (!(rs.usizeRem(n, 4) === 2)) { + rs.bytesMutReserve(buf, n); continue; } - const len2: rt.usize = buf.length; - if (rt.usizeRem(n, 8) === 2) { + const len2: rs.usize = buf.length; + if (rs.usizeRem(n, 8) === 2) { _101 = 4294967295; } else { - _101 = rt.usizeAdd(rt.usizeSub(2147483647, len2), 1); + _101 = rs.usizeAdd(rs.usizeSub(2147483647, len2), 1); } - rt.bytesMutReserve(buf, _101); + rs.bytesMutReserve(buf, _101); continue; } - const fresh: rt.BytesMut = rt.bytesMutFrom(Ops.take(ops, rt.usizeRem(n, 6))); - const read: rt.usize = rt.usizeRem(n, rt.usizeAdd(fresh.length, 1)); - rt.bytesMutAdvance(fresh, read); - const len: rt.usize = fresh.length; - const _81: rt.usize = rt.usizeRem(n, 3); + const fresh: rs.BytesMut = rs.bytesMutFrom(Ops.take(ops, rs.usizeRem(n, 6))); + const read: rs.usize = rs.usizeRem(n, rs.usizeAdd(fresh.length, 1)); + rs.bytesMutAdvance(fresh, read); + const len: rs.usize = fresh.length; + const _81: rs.usize = rs.usizeRem(n, 3); if (_81 === 0) { - _80 = rt.usizeSub(4294967295, n); + _80 = rs.usizeSub(4294967295, n); } else if (_81 === 1) { - _80 = rt.usizeAdd(rt.usizeSub(2147483647, len), 1); + _80 = rs.usizeAdd(rs.usizeSub(2147483647, len), 1); } else { - _80 = rt.usizeSub(rt.usizeSub(rt.usizeAdd(2147483647, 1), read), len); + _80 = rs.usizeSub(rs.usizeSub(rs.usizeAdd(2147483647, 1), read), len); } - rt.bytesMutReserve(fresh, _80); + rs.bytesMutReserve(fresh, _80); fresh[Symbol.dispose](); continue; } if (_20 === 8) { - const _109: rt.BytesMut | undefined = rt.vecPop(pieces); + const _109: rs.BytesMut | undefined = rs.vecPop(pieces); if (_109 !== undefined) { - rt.bytesMutUnsplit(buf, _109); + rs.bytesMutUnsplit(buf, _109); continue; } continue; } if (_20 === 9) { - rt.bytesMutAdvance(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2))); + rs.bytesMutAdvance(buf, rs.usizeRem(n, rs.usizeAdd(buf.length, 2))); continue; } if (_20 === 10) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_BytesMut(buf, n)))); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_BytesMut(buf, n)))); continue; } if (_20 === 11) { - rt.bytesMutTruncate(buf, 0); + rs.bytesMutTruncate(buf, 0); continue; } if (_20 === 12) { const buf2 = buf; - const _129: rt.BytesMut = rt.bytesMutSplitTo(buf2, buf2.length); + const _129: rs.BytesMut = rs.bytesMutSplitTo(buf2, buf2.length); pieces.items.push(_129); continue; } if (_20 === 13) { - const _132: rt.ByteSlice = rt.bytesMutFreeze(rt.bytesMutSplitTo(buf, rt.usizeRem(n, rt.usizeAdd(buf.length, 2)))); + const _132: rs.ByteSlice = rs.bytesMutFreeze(rs.bytesMutSplitTo(buf, rs.usizeRem(n, rs.usizeAdd(buf.length, 2)))); frozen.items.push(_132); continue; } if (_20 === 14) { - rt.bytesMutPutFill(buf, n & 0xff, rt.usizeRem(n, 9)); + rs.bytesMutPutFill(buf, n & 0xff, rs.usizeRem(n, 9)); continue; } if (_20 === 15) { if (!(buf.length === 0)) { - const at: rt.usize = rt.usizeRem(n, buf.length); - const _150: rt.ByteSlice = rt.bytesMutView(buf); - rt.idx(_150, at); + const at: rs.usize = rs.usizeRem(n, buf.length); + const _150: rs.ByteSlice = rs.bytesMutView(buf); + rs.idx(_150, at); _150.data[_150.start + at] = _150.data[_150.start + at] ^ 255; } - const _155: rt.BytesMut | undefined = rt.sliceLast(pieces.items); + const _155: rs.BytesMut | undefined = rs.sliceLast(pieces.items); if (_155 !== undefined) { - rt.bytesMutExtend(_155, rt.byteSliceFrom(Uint8Array.of(120, 121))); + rs.bytesMutExtend(_155, rs.byteSliceFrom(Uint8Array.of(120, 121))); continue; } continue; } if (_20 === 16) { - const _164: rt.ByteSlice = rt.bytesCopyFromSlice(Ops.take(ops, rt.usizeRem(n, 5))); - rt.bytesMutPutStorage(buf, _164); + const _164: rs.ByteSlice = rs.bytesCopyFromSlice(Ops.take(ops, rs.usizeRem(n, 5))); + rs.bytesMutPutStorage(buf, _164); continue; } if (_20 === 17) { - const source: rt.BytesMut = rt.bytesMutFrom(Ops.take(ops, rt.usizeRem(n, 6))); - const first: rt.u8 = getU8Checked$buf_Checked_bytes_BytesMut(source); - rt.bytesMutPutWord(buf, first, 1, false); - rt.bytesMutPutMut(buf, source); + const source: rs.BytesMut = rs.bytesMutFrom(Ops.take(ops, rs.usizeRem(n, 6))); + const first: rs.u8 = getU8Checked$buf_Checked_bytes_BytesMut(source); + rs.bytesMutPutWord(buf, first, 1, false); + rs.bytesMutPutMut(buf, source); continue; } if (_20 === 18) { - const _182: rt.BytesMut = rt.bytesMutSplitOff(buf, rt.usizeRem(n, rt.usizeAdd(buf.cap, 2))); + const _182: rs.BytesMut = rs.bytesMutSplitOff(buf, rs.usizeRem(n, rs.usizeAdd(buf.cap, 2))); pieces.items.push(_182); continue; } if (_20 === 19) { - rt.byteVecPush(out, rt.bytesMutTryReclaim(buf, n) ? 1 : 0); + rs.byteVecPush(out, rs.bytesMutTryReclaim(buf, n) ? 1 : 0); continue; } if (_20 === 20) { - const _193: rt.BytesMut | undefined = rt.vecPop(pieces); + const _193: rs.BytesMut | undefined = rs.vecPop(pieces); if (_193 !== undefined) { - const _197: rt.Result = rt.bytesMutTryUnsplit(buf, _193); + const _197: rs.Result = rs.bytesMutTryUnsplit(buf, _193); if (_197.ok) { - rt.byteVecPush(out, 1); + rs.byteVecPush(out, 1); continue; } - const piece4: rt.BytesMut = _197.error; - rt.byteVecPush(out, 0); + const piece4: rs.BytesMut = _197.error; + rs.byteVecPush(out, 0); pieces.items.push(piece4); continue; } continue; } if (_20 === 21) { - if (rt.usizeRem(n, 2) === 0) { + if (rs.usizeRem(n, 2) === 0) { if (!(pieces.items.length === 0)) { - rt.vecSwapRemove(pieces, rt.usizeRem(rt.usizeDiv(n, 2), pieces.items.length))[Symbol.dispose](); + rs.vecSwapRemove(pieces, rs.usizeRem(rs.usizeDiv(n, 2), pieces.items.length))[Symbol.dispose](); continue; } } if (!(frozen.items.length === 0)) { - rt.bytesDrop(rt.vecSwapRemove(frozen, rt.usizeRem(rt.usizeDiv(n, 2), frozen.items.length))); + rs.bytesDrop(rs.vecSwapRemove(frozen, rs.usizeRem(rs.usizeDiv(n, 2), frozen.items.length))); continue; } } else { if (_20 === 22) { - const _227: rt.ByteSlice | undefined = rt.sliceGet(frozen.items, rt.usizeRem(n, rt.usizeAdd(frozen.items.length, 1))); + const _227: rs.ByteSlice | undefined = rs.sliceGet(frozen.items, rs.usizeRem(n, rs.usizeAdd(frozen.items.length, 1))); if (_227 !== undefined) { - const _240: rt.ByteSlice = rt.bytesClone(_227); + const _240: rs.ByteSlice = rs.bytesClone(_227); frozen.items.push(_240); continue; } continue; } if (_20 === 23) { - const _241: rt.ByteSlice | undefined = rt.vecPop(frozen); + const _241: rs.ByteSlice | undefined = rs.vecPop(frozen); if (_241 !== undefined) { - const bytes: rt.ByteSlice = _241; - const _245: rt.usize = rt.usizeRem(n, 3); + const bytes: rs.ByteSlice = _241; + const _245: rs.usize = rs.usizeRem(n, 3); if (_245 === 0) { - const _248: rt.BytesMut = rt.bytesMutFromBytes(bytes); + const _248: rs.BytesMut = rs.bytesMutFromBytes(bytes); pieces.items.push(_248); continue; } if (_245 === 1) { - const _249: rt.Result = rt.bytesTryIntoMut(bytes); + const _249: rs.Result = rs.bytesTryIntoMut(bytes); if (_249.ok) { pieces.items.push(_249.value); continue; } - const bytes2: rt.ByteSlice = _249.error; - rt.byteVecPush(out, 2); + const bytes2: rs.ByteSlice = _249.error; + rs.byteVecPush(out, 2); frozen.items.push(bytes2); continue; } - const vec: rt.ByteVec = rt.bytesToByteVec(bytes); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(vec.data.length as rt.u32).reverse())); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec)); + const vec: rs.ByteVec = rs.bytesToByteVec(bytes); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(vec.data.length as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(vec)); continue; } continue; } if (_20 === 24) { - const _268: rt.Place | undefined = rt.sliceLastMut(frozen.items); + const _268: rs.Place | undefined = rs.sliceLastMut(frozen.items); if (_268 !== undefined) { - const _273: rt.usize = rt.usizeRem(n, 3); + const _273: rs.usize = rs.usizeRem(n, 3); if (_273 === 0) { - rt.bytesTruncate(_268, rt.usizeRem(rt.usizeDiv(n, 3), rt.usizeAdd(_268.v.length, 1))); + rs.bytesTruncate(_268, rs.usizeRem(rs.usizeDiv(n, 3), rs.usizeAdd(_268.v.length, 1))); continue; } if (_273 === 1) { - rt.bytesTruncate(_268, 0); + rs.bytesTruncate(_268, 0); continue; } - rt.byteVecPush(out, rt.bytesIsUnique(_268.v) ? 1 : 0); + rs.byteVecPush(out, rs.bytesIsUnique(_268.v) ? 1 : 0); continue; } continue; } if (_20 === 25) { - const _286: rt.BytesMut | undefined = rt.sliceLast(pieces.items); + const _286: rs.BytesMut | undefined = rs.sliceLast(pieces.items); if (_286 !== undefined) { - buf = rt.replaceIn(_286, buf); + buf = rs.replaceIn(_286, buf); continue; } continue; } if (_20 === 26) { - const spare: rt.ByteSlice = rt.bytesMutSpare(buf); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(spare.length as rt.u32).reverse())); - const k: rt.usize = rt.usizeRem(n, rt.usizeAdd(spare.length, 1)); - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceRange(spare, 0, k)))); + const spare: rs.ByteSlice = rs.bytesMutSpare(buf); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(spare.length as rs.u32).reverse())); + const k: rs.usize = rs.usizeRem(n, rs.usizeAdd(spare.length, 1)); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceRange(spare, 0, k)))); while (true) { - const _314: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_314 === rt.DONE) { + const _314: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_314 === rs.DONE) { break; } _314[1].v = (n & 0xff) ^ (_314[0] & 0xff); } - rt.bytesMutSetLen(buf, rt.usizeAdd(buf.length, k)); + rs.bytesMutSetLen(buf, rs.usizeAdd(buf.length, k)); continue; } if (_20 === 27) { - const src: rt.ByteSlice = Ops.take(ops, rt.usizeRem(n, 6)); - const spare2: rt.ByteSlice = rt.bytesMutSpare(buf); - const _337: [rt.usize, rt.usize] = [rt.min(src.length, spare2.length), spare2.length]; - const k2: rt.usize = _337[0]; - const room: rt.usize = _337[1]; - rt.byteSliceCopyFromSlice(rt.byteSliceRange(spare2, 0, k2), rt.byteSliceRange(src, 0, k2)); - if (!(rt.usizeRem(n, 16) === 15)) { + const src: rs.ByteSlice = Ops.take(ops, rs.usizeRem(n, 6)); + const spare2: rs.ByteSlice = rs.bytesMutSpare(buf); + const _337: [rs.usize, rs.usize] = [rs.min(src.length, spare2.length), spare2.length]; + const k2: rs.usize = _337[0]; + const room: rs.usize = _337[1]; + rs.byteSliceCopyFromSlice(rs.byteSliceRange(spare2, 0, k2), rs.byteSliceRange(src, 0, k2)); + if (!(rs.usizeRem(n, 16) === 15)) { _351 = k2; } else { - _351 = rt.usizeAdd(room, 1); + _351 = rs.usizeAdd(room, 1); } - rt.bytesMutAdvanceMut(buf, _351); + rs.bytesMutAdvanceMut(buf, _351); continue; } if (_20 === 28) { - const _356: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(rt.bytesMutSpare(buf))); + const _356: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(rs.bytesMutSpare(buf))); if (_356 !== undefined) { _356.v = n & 0xff; } - const _363: rt.u8 | undefined = rt.byteSliceFirst(rt.bytesMutSpare(buf)); + const _363: rs.u8 | undefined = rs.byteSliceFirst(rs.bytesMutSpare(buf)); if (_363 !== undefined) { - rt.byteVecPush(out, _363); + rs.byteVecPush(out, _363); continue; } continue; } } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(buf.cap as rt.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(buf.cap as rs.u32).reverse())); } else { break; } } - const tail: rt.BytesMut = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(116, 97, 105, 108)), 0)); - rt.byteVecPush(out, rt.byteSliceEq(rt.bytesMutView(buf), rt.bytesMutView(tail)) ? 1 : 0); - const _390: rt.BytesMut = rt.bytesMutFrom(rt.bytesMutView(buf)); - const _392: rt.ByteSlice = rt.byteSliceRange(rt.bytesMutView(buf), 0); - rt.byteVecPush(out, rt.byteSliceEq(rt.bytesMutView(_390), _392) ? 1 : 0); + const tail: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(116, 97, 105, 108)), 0)); + rs.byteVecPush(out, rs.byteSliceEq(rs.bytesMutView(buf), rs.bytesMutView(tail)) ? 1 : 0); + const _390: rs.BytesMut = rs.bytesMutFrom(rs.bytesMutView(buf)); + const _392: rs.ByteSlice = rs.byteSliceRange(rs.bytesMutView(buf), 0); + rs.byteVecPush(out, rs.byteSliceEq(rs.bytesMutView(_390), _392) ? 1 : 0); _390[Symbol.dispose](); - const _403: rt.usize = buf.length; - const _406: rt.usize = buf.cap; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(rt.bytesMutView(buf), f), (f: rt.Formatter) => rt.usizeDisplay(_403, f), (f: rt.Formatter) => rt.usizeDisplay(_406, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]))); + const _403: rs.usize = buf.length; + const _406: rs.usize = buf.cap; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(buf), f), (f: rs.Formatter) => rs.usizeDisplay(_403, f), (f: rs.Formatter) => rs.usizeDisplay(_406, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], "\n"]))); for (const piece6 of pieces.items) { - const _430: rt.usize = piece6.cap; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(rt.bytesMutView(piece6), f), (f: rt.Formatter) => rt.usizeDisplay(_430, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1], "\n"]))); + const _430: rs.usize = piece6.cap; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(rs.bytesMutView(piece6), f), (f: rs.Formatter) => rs.usizeDisplay(_430, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); } for (const bytes3 of frozen.items) { - const _452: boolean = rt.bytesIsUnique(bytes3); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(bytes3, f), (f: rt.Formatter) => rt.fmtBool(_452, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args6[0], " ", args6[1], "\n"]))); + const _452: boolean = rs.bytesIsUnique(bytes3); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes3, f), (f: rs.Formatter) => rs.fmtBool(_452, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args6[0], " ", args6[1], "\n"]))); } - const vec2: rt.ByteVec = rt.bytesMutToByteVec(buf); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(vec2.data.length as rt.u32).reverse())); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec2)); + const vec2: rs.ByteVec = rs.bytesMutToByteVec(buf); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(vec2.data.length as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(vec2)); tail[Symbol.dispose](); - rt.dropVec(frozen, rt.bytesDrop); - rt.dropVec(pieces); + rs.dropVec(frozen, rs.bytesDrop); + rs.dropVec(pieces); } /** The next byte, or 0 if none remains. */ -export function getU8Checked$buf_Checked_bytes_BytesMut(self: rt.BytesMut): rt.u8 { +export function getU8Checked$buf_Checked_bytes_BytesMut(self: rs.BytesMut): rs.u8 { if (!hasRemaining$bytes_Buf_mut_bytes_BytesMut(self)) { return 0; } - return rt.bytesMutReadWord(self, 1, false) as rt.u8; + return rs.bytesMutReadWord(self, 1, false) as rs.u8; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$boxed_Box_dyn_bytes_Buf(buf: rt.Place, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$boxed_Box_dyn_bytes_Buf(buf: rs.Place, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part8: rt.u16 | undefined = tryGetU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); + const part8: rs.u16 | undefined = tryGetU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); const err4: TryGetError.TryGetError | undefined = part8 === undefined ? out$u16.err as TryGetError.TryGetError : undefined; - const part9 = result_map$0hs8st9((err4 !== undefined ? rt.Err(err4 as TryGetError.TryGetError) : rt.Ok(part8 as rt.u16)) as rt.Result, (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part9 = result_map$1cosroz((err4 !== undefined ? rs.Err(err4 as TryGetError.TryGetError) : rs.Ok(part8 as rs.u16)) as rs.Result, (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part9); } if (_4 === 16) { - const part6: rt.i64 | undefined = tryGetI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); + const part6: rs.i64 | undefined = tryGetI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); const err3: TryGetError.TryGetError | undefined = part6 === undefined ? out$i64.err as TryGetError.TryGetError : undefined; - const part7 = result_map$0c3nzkx((err3 !== undefined ? rt.Err(err3 as TryGetError.TryGetError) : rt.Ok(part6 as rt.i64)) as rt.Result, (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part7 = result_map$1rpus2m((err3 !== undefined ? rs.Err(err3 as TryGetError.TryGetError) : rs.Ok(part6 as rs.i64)) as rs.Result, (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part7); } if (_4 === 17) { - const part5: rt.u128 | undefined = tryGetU128$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); + const part5: rs.u128 | undefined = tryGetU128$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); const err2: TryGetError.TryGetError | undefined = part5 === undefined ? out$u128.err as TryGetError.TryGetError : undefined; - const args = [(err2 !== undefined ? rt.Err(err2 as TryGetError.TryGetError) : rt.Ok(part5 as rt.u128)) as rt.Result] as [rt.Result]; + const args = [(err2 !== undefined ? rs.Err(err2 as TryGetError.TryGetError) : rs.Ok(part5 as rs.u128)) as rs.Result] as [rs.Result]; return _3(args[0]); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return getU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rt.u128; + return getU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(getI8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI8$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 2) { - return getU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rt.u128; + return getU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(getI16Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI16Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 4) { - return getU32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rt.u128; + return getU32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(getI32$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI32$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 6) { - return rt.u128Cast(getU64$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getU64$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 7) { - return rt.u128Cast(getI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 8) { return getU128Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf); } if (_4 === 9) { - return rt.u128Cast(getI128$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI128$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)); } if (_4 === 10) { - return rt.u128Cast(getUint$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getUint$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(getIntLe$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getIntLe$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(getF64$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf))); + return rs.u128Cast(rs.f64ToBits(getF64$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf))); } if (_4 === 13) { - return rt.f32ToBits(getF32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)) as rt.u128; + return rs.f32ToBits(getF32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - copyToSlice$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + copyToSlice$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$buf_Pieces(buf: Pieces.Pieces, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$buf_Pieces(buf: Pieces.Pieces, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Pieces.tryGetU8$bytes_Buf(buf); + const part3: rs.u8 | undefined = Pieces.tryGetU8$bytes_Buf(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Pieces.getU8$bytes_Buf(buf) as rt.u128; + return Pieces.getU8$bytes_Buf(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Pieces.getI8$bytes_Buf(buf)); + return rs.u128Cast(Pieces.getI8$bytes_Buf(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Pieces.getUint$bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Pieces.getUint$bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Pieces.getIntLe$bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Pieces.getIntLe$bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Pieces.getF64$bytes_Buf(buf))); + return rs.u128Cast(rs.f64ToBits(Pieces.getF64$bytes_Buf(buf))); } if (_4 === 13) { - return rt.f32ToBits(Pieces.getF32Le$bytes_Buf(buf)) as rt.u128; + return rs.f32ToBits(Pieces.getF32Le$bytes_Buf(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Pieces.copyToSlice$bytes_Buf(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Pieces.copyToSlice$bytes_Buf(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$buf_Provided(buf: Provided.Provided, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$buf_Provided(buf: Provided.Provided, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Provided.tryGetU8$bytes_Buf(buf); + const part3: rs.u8 | undefined = Provided.tryGetU8$bytes_Buf(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Provided.getU8$bytes_Buf(buf) as rt.u128; + return Provided.getU8$bytes_Buf(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Provided.getI8$bytes_Buf(buf)); + return rs.u128Cast(Provided.getI8$bytes_Buf(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Provided.getUint$bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Provided.getUint$bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Provided.getIntLe$bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Provided.getIntLe$bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Provided.getF64$bytes_Buf(buf))); + return rs.u128Cast(rs.f64ToBits(Provided.getF64$bytes_Buf(buf))); } if (_4 === 13) { - return rt.f32ToBits(Provided.getF32Le$bytes_Buf(buf)) as rt.u128; + return rs.f32ToBits(Provided.getF32Le$bytes_Buf(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Provided.copyToSlice$bytes_Buf(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Provided.copyToSlice$bytes_Buf(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_Bytes(buf: rt.Place, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_Bytes(buf: rs.Place, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a010: rt.ByteSlice): rt.usize => { + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a010: rs.ByteSlice): rs.usize => { return a010.length; - })(p.v), (p: rt.Place) => ((a011: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a011: rs.ByteSlice): rs.ByteSlice => { return a011; - })(p.v), (a012: rt.Place, a15: rt.usize): undefined => { - rt.bytesAdvance(a012, a15); - }, (a013: rt.Place, a16: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a013, a16); - }), (a014: rt.u16): rt.u128 => { - return a014 as rt.u128; + })(p.v), (a012: rs.Place, a15: rs.usize): undefined => { + rs.bytesAdvance(a012, a15); + }, (a013: rs.Place, a16: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a013, a16); + }), (a014: rs.u16): rs.u128 => { + return a014 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a06: rt.ByteSlice): rt.usize => { + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a06: rs.ByteSlice): rs.usize => { return a06.length; - })(p.v), (p: rt.Place) => ((a07: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a07: rs.ByteSlice): rs.ByteSlice => { return a07; - })(p.v), (a08: rt.Place, a13: rt.usize): undefined => { - rt.bytesAdvance(a08, a13); - }, (a09: rt.Place, a14: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a09, a14); - }), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + })(p.v), (a08: rs.Place, a13: rs.usize): undefined => { + rs.bytesAdvance(a08, a13); + }, (a09: rs.Place, a14: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a09, a14); + }), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a02: rt.ByteSlice): rt.usize => { + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a02: rs.ByteSlice): rs.usize => { return a02.length; - })(p.v), (p: rt.Place) => ((a03: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a03: rs.ByteSlice): rs.ByteSlice => { return a03; - })(p.v), (a04: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a04, a1); - }, (a05: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a05, a12); + })(p.v), (a04: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a04, a1); + }, (a05: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a05, a12); }); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_bytes_Bytes(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_bytes_Bytes(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return (rt.bytesReadWord(buf, 1, false) as rt.u8) as rt.u128; + return (rs.bytesReadWord(buf, 1, false) as rs.u8) as rs.u128; } if (_4 === 1) { - return rt.u128Cast((rt.bytesReadWord(buf, 1, false) << 24) >> 24 as rt.i8); + return rs.u128Cast((rs.bytesReadWord(buf, 1, false) << 24) >> 24 as rs.i8); } if (_4 === 2) { - return (rt.bytesReadWord(buf, 2, false) as rt.u16) as rt.u128; + return (rs.bytesReadWord(buf, 2, false) as rs.u16) as rs.u128; } if (_4 === 3) { - return rt.u128Cast((rt.bytesReadWord(buf, 2, true) << 16) >> 16 as rt.i16); + return rs.u128Cast((rs.bytesReadWord(buf, 2, true) << 16) >> 16 as rs.i16); } if (_4 === 4) { - return (rt.bytesReadWord(buf, 4, true) as rt.u32) as rt.u128; + return (rs.bytesReadWord(buf, 4, true) as rs.u32) as rs.u128; } if (_4 === 5) { - return rt.u128Cast((rt.bytesReadWord(buf, 4, false) | 0) as rt.i32); + return rs.u128Cast((rs.bytesReadWord(buf, 4, false) | 0) as rs.i32); } if (_4 === 6) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesRead(buf, 8, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesRead(buf, 8, false))); } if (_4 === 7) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesRead(buf, 8, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesRead(buf, 8, true))); } if (_4 === 8) { - return rt.u128FromBeBytes(rt.bytesRead(buf, 16, true)); + return rs.u128FromBeBytes(rs.bytesRead(buf, 16, true)); } if (_4 === 9) { - return rt.u128Cast(rt.i128FromBeBytes(rt.bytesRead(buf, 16, false))); + return rs.u128Cast(rs.i128FromBeBytes(rs.bytesRead(buf, 16, false))); } if (_4 === 10) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesReadInt(buf, 8, rt.usizeRem(n, 10), false, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesReadInt(buf, 8, rs.usizeRem(n, 10), false, false))); } if (_4 === 11) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesReadInt(buf, 8, rt.usizeRem(n, 10), true, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesReadInt(buf, 8, rs.usizeRem(n, 10), true, true))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(rt.f64FromBeBytes(rt.bytesRead(buf, 8, false)))); + return rs.u128Cast(rs.f64ToBits(rs.f64FromBeBytes(rs.bytesRead(buf, 8, false)))); } if (_4 === 13) { - return rt.f32ToBits(rt.f32FromBeBytes(rt.bytesRead(buf, 4, true))) as rt.u128; + return rs.f32ToBits(rs.f32FromBeBytes(rs.bytesRead(buf, 4, true))) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - rt.bytesCopyToSlice(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + rs.bytesCopyToSlice(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_BytesMut(buf: rt.BytesMut, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_BytesMut(buf: rs.BytesMut, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, (a010: rt.BytesMut): rt.usize => { + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, (a010: rs.BytesMut): rs.usize => { return a010.length; - }, (a011: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a011); - }, (a012: rt.BytesMut, a15: rt.usize): undefined => { - rt.bytesMutAdvance(a012, a15); - }, (a013: rt.BytesMut, a16: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a013, a16); - }), (a014: rt.u16): rt.u128 => { - return a014 as rt.u128; + }, (a011: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a011); + }, (a012: rs.BytesMut, a15: rs.usize): undefined => { + rs.bytesMutAdvance(a012, a15); + }, (a013: rs.BytesMut, a16: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a013, a16); + }), (a014: rs.u16): rs.u128 => { + return a014 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, (a06: rt.BytesMut): rt.usize => { + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, (a06: rs.BytesMut): rs.usize => { return a06.length; - }, (a07: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a07); - }, (a08: rt.BytesMut, a13: rt.usize): undefined => { - rt.bytesMutAdvance(a08, a13); - }, (a09: rt.BytesMut, a14: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a09, a14); - }), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + }, (a07: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a07); + }, (a08: rs.BytesMut, a13: rs.usize): undefined => { + rs.bytesMutAdvance(a08, a13); + }, (a09: rs.BytesMut, a14: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a09, a14); + }), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, (a02: rt.BytesMut): rt.usize => { + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, (a02: rs.BytesMut): rs.usize => { return a02.length; - }, (a03: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a03); - }, (a04: rt.BytesMut, a1: rt.usize): undefined => { - rt.bytesMutAdvance(a04, a1); - }, (a05: rt.BytesMut, a12: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a05, a12); + }, (a03: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a03); + }, (a04: rs.BytesMut, a1: rs.usize): undefined => { + rs.bytesMutAdvance(a04, a1); + }, (a05: rs.BytesMut, a12: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a05, a12); }); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_bytes_BytesMut(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_bytes_BytesMut(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return (rt.bytesMutReadWord(buf, 1, false) as rt.u8) as rt.u128; + return (rs.bytesMutReadWord(buf, 1, false) as rs.u8) as rs.u128; } if (_4 === 1) { - return rt.u128Cast((rt.bytesMutReadWord(buf, 1, false) << 24) >> 24 as rt.i8); + return rs.u128Cast((rs.bytesMutReadWord(buf, 1, false) << 24) >> 24 as rs.i8); } if (_4 === 2) { - return (rt.bytesMutReadWord(buf, 2, false) as rt.u16) as rt.u128; + return (rs.bytesMutReadWord(buf, 2, false) as rs.u16) as rs.u128; } if (_4 === 3) { - return rt.u128Cast((rt.bytesMutReadWord(buf, 2, true) << 16) >> 16 as rt.i16); + return rs.u128Cast((rs.bytesMutReadWord(buf, 2, true) << 16) >> 16 as rs.i16); } if (_4 === 4) { - return (rt.bytesMutReadWord(buf, 4, true) as rt.u32) as rt.u128; + return (rs.bytesMutReadWord(buf, 4, true) as rs.u32) as rs.u128; } if (_4 === 5) { - return rt.u128Cast((rt.bytesMutReadWord(buf, 4, false) | 0) as rt.i32); + return rs.u128Cast((rs.bytesMutReadWord(buf, 4, false) | 0) as rs.i32); } if (_4 === 6) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesMutRead(buf, 8, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesMutRead(buf, 8, false))); } if (_4 === 7) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesMutRead(buf, 8, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesMutRead(buf, 8, true))); } if (_4 === 8) { - return rt.u128FromBeBytes(rt.bytesMutRead(buf, 16, true)); + return rs.u128FromBeBytes(rs.bytesMutRead(buf, 16, true)); } if (_4 === 9) { - return rt.u128Cast(rt.i128FromBeBytes(rt.bytesMutRead(buf, 16, false))); + return rs.u128Cast(rs.i128FromBeBytes(rs.bytesMutRead(buf, 16, false))); } if (_4 === 10) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesMutReadInt(buf, 8, rt.usizeRem(n, 10), false, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesMutReadInt(buf, 8, rs.usizeRem(n, 10), false, false))); } if (_4 === 11) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesMutReadInt(buf, 8, rt.usizeRem(n, 10), true, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesMutReadInt(buf, 8, rs.usizeRem(n, 10), true, true))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(rt.f64FromBeBytes(rt.bytesMutRead(buf, 8, false)))); + return rs.u128Cast(rs.f64ToBits(rs.f64FromBeBytes(rs.bytesMutRead(buf, 8, false)))); } if (_4 === 13) { - return rt.f32ToBits(rt.f32FromBeBytes(rt.bytesMutRead(buf, 4, true))) as rt.u128; + return rs.f32ToBits(rs.f32FromBeBytes(rs.bytesMutRead(buf, 4, true))) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - rt.bytesMutCopyToSlice(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + rs.bytesMutCopyToSlice(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_buf_Pieces_buf_Provided(buf: Chain.Chain, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_buf_Pieces_buf_Provided(buf: Chain.Chain, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_buf_Pieces_buf_Provided(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_buf_Pieces_buf_Provided(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_buf_Pieces_buf_Provided(buf) as rt.u128; + return Chain.getU8$bytes_Buf_buf_Pieces_buf_Provided(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_buf_Pieces_buf_Provided(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_buf_Pieces_buf_Provided(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided, Chain.chunk$bytes_Buf_buf_Pieces_buf_Provided, Chain.advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_buf_Pieces_buf_Provided(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_buf_Pieces_buf_Provided(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_buf_Pieces_buf_Provided(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_buf_Pieces_buf_Provided(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_buf_Pieces_buf_Provided(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_buf_Pieces_buf_Provided(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_buf_Pieces_buf_Provided(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_buf_Pieces_buf_Provided(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_buf_Pieces_buf_Provided(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf: Chain.Chain, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf: Chain.Chain, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_buf_Provided_bytes_Bytes(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_buf_Provided_bytes_Bytes(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_buf_Provided_bytes_Bytes(buf) as rt.u128; + return Chain.getU8$bytes_Buf_buf_Provided_bytes_Bytes(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_buf_Provided_bytes_Bytes(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_buf_Provided_bytes_Bytes(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes, Chain.chunk$bytes_Buf_buf_Provided_bytes_Bytes, Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_buf_Provided_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_buf_Provided_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_buf_Provided_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_buf_Provided_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_buf_Provided_bytes_Bytes(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_buf_Provided_bytes_Bytes(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_buf_Provided_bytes_Bytes(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_buf_Provided_bytes_Bytes(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf: Chain.Chain>, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf: Chain.Chain>, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf) as rt.u128; + return Chain.getU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf: Chain.Chain, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf: Chain.Chain, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf) as rt.u128; + return Chain.getU8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_bytes_Bytes_ref_slice_u8(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_bytes_Bytes_ref_slice_u8(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_bytes_Bytes_ref_slice_u8(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_Bytes_ref_slice_u8(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_Bytes_ref_slice_u8(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf) as rt.u128; + return Chain.getU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf) as rt.u128; + return Chain.getU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain.Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf: Chain.Chain, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf: Chain.Chain, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Chain.tryGetU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf); + const part3: rs.u8 | undefined = Chain.tryGetU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Chain.getU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf) as rt.u128; + return Chain.getU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Chain.getI8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf)); + return rs.u128Cast(Chain.getI8$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain.Chain, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Chain.getUint$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getUint$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Chain.getIntLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Chain.getIntLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Chain.getF64$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf))); + return rs.u128Cast(rs.f64ToBits(Chain.getF64$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf))); } if (_4 === 13) { - return rt.f32ToBits(Chain.getF32Le$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf)) as rt.u128; + return rs.f32ToBits(Chain.getF32Le$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Chain.copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$bytes_buf_Take_bytes_Bytes(buf: Take.Take, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$bytes_buf_Take_bytes_Bytes(buf: Take.Take, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = Take.tryGetU8$bytes_Buf_bytes_Bytes(buf); + const part3: rs.u8 | undefined = Take.tryGetU8$bytes_Buf_bytes_Bytes(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Take.getU8$bytes_Buf_bytes_Bytes(buf) as rt.u128; + return Take.getU8$bytes_Buf_bytes_Bytes(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Take.getI8$bytes_Buf_bytes_Bytes(buf)); + return rs.u128Cast(Take.getI8$bytes_Buf_bytes_Bytes(buf)); } if (_4 === 2) { - return rt.bufGet(buf, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(rt.bufGet(buf, 2, true, rt.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 2, true, rs.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined)); } if (_4 === 4) { - return rt.bufGet(buf, 4, true, rt.u32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined) as rt.u128; + return rs.bufGet(buf, 4, true, rs.u32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(rt.bufGet(buf, 4, false, rt.i32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 4, false, rs.i32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined)); } if (_4 === 6) { - return rt.u128Cast(rt.bufGet(buf, 8, false, rt.u64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, false, rs.u64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined)); } if (_4 === 7) { - return rt.u128Cast(rt.bufGet(buf, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined)); } if (_4 === 8) { - return rt.bufGet(buf, 16, true, rt.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + return rs.bufGet(buf, 16, true, rs.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } if (_4 === 9) { - return rt.u128Cast(rt.bufGet(buf, 16, false, rt.i128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined)); + return rs.u128Cast(rs.bufGet(buf, 16, false, rs.i128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined)); } if (_4 === 10) { - return rt.u128Cast(Take.getUint$bytes_Buf_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Take.getUint$bytes_Buf_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Take.getIntLe$bytes_Buf_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Take.getIntLe$bytes_Buf_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Take.getF64$bytes_Buf_bytes_Bytes(buf))); + return rs.u128Cast(rs.f64ToBits(Take.getF64$bytes_Buf_bytes_Bytes(buf))); } if (_4 === 13) { - return rt.f32ToBits(Take.getF32Le$bytes_Buf_bytes_Bytes(buf)) as rt.u128; + return rs.f32ToBits(Take.getF32Le$bytes_Buf_bytes_Bytes(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Take.copyToSlice$bytes_Buf_bytes_Bytes(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Take.copyToSlice$bytes_Buf_bytes_Bytes(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$dyn_buf_Leased(buf: Leased.Leased, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$dyn_buf_Leased(buf: Leased.Leased, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part6 = result_map$0hs8st9(buf.tryGetU16$Buf(), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part6 = result_map$1cosroz(buf.tryGetU16$Buf(), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part6); } if (_4 === 16) { - const part5 = result_map$0c3nzkx(buf.tryGetI64Le$Buf(), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part5 = result_map$1rpus2m(buf.tryGetI64Le$Buf(), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part5); } @@ -1522,80 +1522,80 @@ export function read$dyn_buf_Leased(buf: Leased.Leased, n: rt.usize): rt.u128 { return _3(part4); } if (_4 === 18) { - const part3 = result_map$01kzrm1(buf.tryGetU8$Buf(), (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part3 = result_map$1k6isgs(buf.tryGetU8$Buf(), (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part3); } if (_4 === 0) { - return buf.getU8$Buf() as rt.u128; + return buf.getU8$Buf() as rs.u128; } if (_4 === 1) { - return rt.u128Cast(buf.getI8$Buf()); + return rs.u128Cast(buf.getI8$Buf()); } if (_4 === 2) { - return buf.getU16$Buf() as rt.u128; + return buf.getU16$Buf() as rs.u128; } if (_4 === 3) { - return rt.u128Cast(buf.getI16Le$Buf()); + return rs.u128Cast(buf.getI16Le$Buf()); } if (_4 === 4) { - return buf.getU32Le$Buf() as rt.u128; + return buf.getU32Le$Buf() as rs.u128; } if (_4 === 5) { - return rt.u128Cast(buf.getI32$Buf()); + return rs.u128Cast(buf.getI32$Buf()); } if (_4 === 6) { - return rt.u128Cast(buf.getU64$Buf()); + return rs.u128Cast(buf.getU64$Buf()); } if (_4 === 7) { - return rt.u128Cast(buf.getI64Le$Buf()); + return rs.u128Cast(buf.getI64Le$Buf()); } if (_4 === 8) { return buf.getU128Le$Buf(); } if (_4 === 9) { - return rt.u128Cast(buf.getI128$Buf()); + return rs.u128Cast(buf.getI128$Buf()); } if (_4 === 10) { - return rt.u128Cast(buf.getUint$Buf(rt.usizeRem(n, 10))); + return rs.u128Cast(buf.getUint$Buf(rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(buf.getIntLe$Buf(rt.usizeRem(n, 10))); + return rs.u128Cast(buf.getIntLe$Buf(rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(buf.getF64$Buf())); + return rs.u128Cast(rs.f64ToBits(buf.getF64$Buf())); } if (_4 === 13) { - return rt.f32ToBits(buf.getF32Le$Buf()) as rt.u128; + return rs.f32ToBits(buf.getF32Le$Buf()) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - buf.copyToSlice$Buf(rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + buf.copyToSlice$Buf(rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$dyn_bytes_Buf(buf: Buf.Buf, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$dyn_bytes_Buf(buf: Buf.Buf, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part6 = result_map$0hs8st9(buf.tryGetU16$Buf(), (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part6 = result_map$1cosroz(buf.tryGetU16$Buf(), (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part6); } if (_4 === 16) { - const part5 = result_map$0c3nzkx(buf.tryGetI64Le$Buf(), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part5 = result_map$1rpus2m(buf.tryGetI64Le$Buf(), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part5); } @@ -1604,524 +1604,524 @@ export function read$dyn_bytes_Buf(buf: Buf.Buf, n: rt.usize): rt.u128 { return _3(part4); } if (_4 === 18) { - const part3 = result_map$01kzrm1(buf.tryGetU8$Buf(), (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part3 = result_map$1k6isgs(buf.tryGetU8$Buf(), (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part3); } if (_4 === 0) { - return buf.getU8$Buf() as rt.u128; + return buf.getU8$Buf() as rs.u128; } if (_4 === 1) { - return rt.u128Cast(buf.getI8$Buf()); + return rs.u128Cast(buf.getI8$Buf()); } if (_4 === 2) { - return buf.getU16$Buf() as rt.u128; + return buf.getU16$Buf() as rs.u128; } if (_4 === 3) { - return rt.u128Cast(buf.getI16Le$Buf()); + return rs.u128Cast(buf.getI16Le$Buf()); } if (_4 === 4) { - return buf.getU32Le$Buf() as rt.u128; + return buf.getU32Le$Buf() as rs.u128; } if (_4 === 5) { - return rt.u128Cast(buf.getI32$Buf()); + return rs.u128Cast(buf.getI32$Buf()); } if (_4 === 6) { - return rt.u128Cast(buf.getU64$Buf()); + return rs.u128Cast(buf.getU64$Buf()); } if (_4 === 7) { - return rt.u128Cast(buf.getI64Le$Buf()); + return rs.u128Cast(buf.getI64Le$Buf()); } if (_4 === 8) { return buf.getU128Le$Buf(); } if (_4 === 9) { - return rt.u128Cast(buf.getI128$Buf()); + return rs.u128Cast(buf.getI128$Buf()); } if (_4 === 10) { - return rt.u128Cast(buf.getUint$Buf(rt.usizeRem(n, 10))); + return rs.u128Cast(buf.getUint$Buf(rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(buf.getIntLe$Buf(rt.usizeRem(n, 10))); + return rs.u128Cast(buf.getIntLe$Buf(rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(buf.getF64$Buf())); + return rs.u128Cast(rs.f64ToBits(buf.getF64$Buf())); } if (_4 === 13) { - return rt.f32ToBits(buf.getF32Le$Buf()) as rt.u128; + return rs.f32ToBits(buf.getF32Le$Buf()) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - buf.copyToSlice$Buf(rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + buf.copyToSlice$Buf(rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$mut_buf_Pieces(buf: rt.Place, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$mut_buf_Pieces(buf: rs.Place, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part8: rt.u16 | undefined = Pieces.tryGetU16$bytes_Buf_mut(buf); + const part8: rs.u16 | undefined = Pieces.tryGetU16$bytes_Buf_mut(buf); const err4: TryGetError.TryGetError | undefined = part8 === undefined ? out$u16.err as TryGetError.TryGetError : undefined; - const part9 = result_map$0hs8st9((err4 !== undefined ? rt.Err(err4 as TryGetError.TryGetError) : rt.Ok(part8 as rt.u16)) as rt.Result, (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part9 = result_map$1cosroz((err4 !== undefined ? rs.Err(err4 as TryGetError.TryGetError) : rs.Ok(part8 as rs.u16)) as rs.Result, (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part9); } if (_4 === 16) { - const part6: rt.i64 | undefined = Pieces.tryGetI64Le$bytes_Buf_mut(buf); + const part6: rs.i64 | undefined = Pieces.tryGetI64Le$bytes_Buf_mut(buf); const err3: TryGetError.TryGetError | undefined = part6 === undefined ? out$i64.err as TryGetError.TryGetError : undefined; - const part7 = result_map$0c3nzkx((err3 !== undefined ? rt.Err(err3 as TryGetError.TryGetError) : rt.Ok(part6 as rt.i64)) as rt.Result, (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part7 = result_map$1rpus2m((err3 !== undefined ? rs.Err(err3 as TryGetError.TryGetError) : rs.Ok(part6 as rs.i64)) as rs.Result, (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part7); } if (_4 === 17) { - const part5: rt.u128 | undefined = Pieces.tryGetU128$bytes_Buf_mut(buf); + const part5: rs.u128 | undefined = Pieces.tryGetU128$bytes_Buf_mut(buf); const err2: TryGetError.TryGetError | undefined = part5 === undefined ? out$u128.err as TryGetError.TryGetError : undefined; - const args = [(err2 !== undefined ? rt.Err(err2 as TryGetError.TryGetError) : rt.Ok(part5 as rt.u128)) as rt.Result] as [rt.Result]; + const args = [(err2 !== undefined ? rs.Err(err2 as TryGetError.TryGetError) : rs.Ok(part5 as rs.u128)) as rs.Result] as [rs.Result]; return _3(args[0]); } if (_4 === 18) { - const part3: rt.u8 | undefined = Pieces.tryGetU8$bytes_Buf_mut(buf); + const part3: rs.u8 | undefined = Pieces.tryGetU8$bytes_Buf_mut(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return Pieces.getU8$bytes_Buf_mut(buf) as rt.u128; + return Pieces.getU8$bytes_Buf_mut(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(Pieces.getI8$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getI8$bytes_Buf_mut(buf)); } if (_4 === 2) { - return Pieces.getU16$bytes_Buf_mut(buf) as rt.u128; + return Pieces.getU16$bytes_Buf_mut(buf) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(Pieces.getI16Le$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getI16Le$bytes_Buf_mut(buf)); } if (_4 === 4) { - return Pieces.getU32Le$bytes_Buf_mut(buf) as rt.u128; + return Pieces.getU32Le$bytes_Buf_mut(buf) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(Pieces.getI32$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getI32$bytes_Buf_mut(buf)); } if (_4 === 6) { - return rt.u128Cast(Pieces.getU64$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getU64$bytes_Buf_mut(buf)); } if (_4 === 7) { - return rt.u128Cast(Pieces.getI64Le$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getI64Le$bytes_Buf_mut(buf)); } if (_4 === 8) { return Pieces.getU128Le$bytes_Buf_mut(buf); } if (_4 === 9) { - return rt.u128Cast(Pieces.getI128$bytes_Buf_mut(buf)); + return rs.u128Cast(Pieces.getI128$bytes_Buf_mut(buf)); } if (_4 === 10) { - return rt.u128Cast(Pieces.getUint$bytes_Buf_mut(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Pieces.getUint$bytes_Buf_mut(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(Pieces.getIntLe$bytes_Buf_mut(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(Pieces.getIntLe$bytes_Buf_mut(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(Pieces.getF64$bytes_Buf_mut(buf))); + return rs.u128Cast(rs.f64ToBits(Pieces.getF64$bytes_Buf_mut(buf))); } if (_4 === 13) { - return rt.f32ToBits(Pieces.getF32Le$bytes_Buf_mut(buf)) as rt.u128; + return rs.f32ToBits(Pieces.getF32Le$bytes_Buf_mut(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - Pieces.copyToSlice$bytes_Buf_mut(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + Pieces.copyToSlice$bytes_Buf_mut(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$mut_bytes_Bytes(buf: rt.Place>, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$mut_bytes_Bytes(buf: rs.Place>, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part8: rt.u16 | undefined = tryGetU16$bytes_Buf_mut_bytes_Bytes(buf); + const part8: rs.u16 | undefined = tryGetU16$bytes_Buf_mut_bytes_Bytes(buf); const err4: TryGetError.TryGetError | undefined = part8 === undefined ? out$u16.err as TryGetError.TryGetError : undefined; - const part9 = result_map$0hs8st9((err4 !== undefined ? rt.Err(err4 as TryGetError.TryGetError) : rt.Ok(part8 as rt.u16)) as rt.Result, (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part9 = result_map$1cosroz((err4 !== undefined ? rs.Err(err4 as TryGetError.TryGetError) : rs.Ok(part8 as rs.u16)) as rs.Result, (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part9); } if (_4 === 16) { - const part6: rt.i64 | undefined = tryGetI64Le$bytes_Buf_mut_bytes_Bytes(buf); + const part6: rs.i64 | undefined = tryGetI64Le$bytes_Buf_mut_bytes_Bytes(buf); const err3: TryGetError.TryGetError | undefined = part6 === undefined ? out$i64.err as TryGetError.TryGetError : undefined; - const part7 = result_map$0c3nzkx((err3 !== undefined ? rt.Err(err3 as TryGetError.TryGetError) : rt.Ok(part6 as rt.i64)) as rt.Result, (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part7 = result_map$1rpus2m((err3 !== undefined ? rs.Err(err3 as TryGetError.TryGetError) : rs.Ok(part6 as rs.i64)) as rs.Result, (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part7); } if (_4 === 17) { - const part5: rt.u128 | undefined = tryGetU128$bytes_Buf_mut_bytes_Bytes(buf); + const part5: rs.u128 | undefined = tryGetU128$bytes_Buf_mut_bytes_Bytes(buf); const err2: TryGetError.TryGetError | undefined = part5 === undefined ? out$u128.err as TryGetError.TryGetError : undefined; - const args = [(err2 !== undefined ? rt.Err(err2 as TryGetError.TryGetError) : rt.Ok(part5 as rt.u128)) as rt.Result] as [rt.Result]; + const args = [(err2 !== undefined ? rs.Err(err2 as TryGetError.TryGetError) : rs.Ok(part5 as rs.u128)) as rs.Result] as [rs.Result]; return _3(args[0]); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_mut_bytes_Bytes(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_mut_bytes_Bytes(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return getU8$bytes_Buf_mut_bytes_Bytes(buf) as rt.u128; + return getU8$bytes_Buf_mut_bytes_Bytes(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(getI8$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getI8$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 2) { - return getU16$bytes_Buf_mut_bytes_Bytes(buf) as rt.u128; + return getU16$bytes_Buf_mut_bytes_Bytes(buf) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(getI16Le$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getI16Le$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 4) { - return getU32Le$bytes_Buf_mut_bytes_Bytes(buf) as rt.u128; + return getU32Le$bytes_Buf_mut_bytes_Bytes(buf) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(getI32$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getI32$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 6) { - return rt.u128Cast(getU64$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getU64$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 7) { - return rt.u128Cast(getI64Le$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getI64Le$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 8) { return getU128Le$bytes_Buf_mut_bytes_Bytes(buf); } if (_4 === 9) { - return rt.u128Cast(getI128$bytes_Buf_mut_bytes_Bytes(buf)); + return rs.u128Cast(getI128$bytes_Buf_mut_bytes_Bytes(buf)); } if (_4 === 10) { - return rt.u128Cast(getUint$bytes_Buf_mut_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getUint$bytes_Buf_mut_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(getIntLe$bytes_Buf_mut_bytes_Bytes(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getIntLe$bytes_Buf_mut_bytes_Bytes(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(getF64$bytes_Buf_mut_bytes_Bytes(buf))); + return rs.u128Cast(rs.f64ToBits(getF64$bytes_Buf_mut_bytes_Bytes(buf))); } if (_4 === 13) { - return rt.f32ToBits(getF32Le$bytes_Buf_mut_bytes_Bytes(buf)) as rt.u128; + return rs.f32ToBits(getF32Le$bytes_Buf_mut_bytes_Bytes(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - copyToSlice$bytes_Buf_mut_bytes_Bytes(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + copyToSlice$bytes_Buf_mut_bytes_Bytes(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$mut_dyn_bytes_Buf(buf: rt.Place, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$mut_dyn_bytes_Buf(buf: rs.Place, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part8: rt.u16 | undefined = tryGetU16$bytes_Buf_mut_dyn_bytes_Buf(buf); + const part8: rs.u16 | undefined = tryGetU16$bytes_Buf_mut_dyn_bytes_Buf(buf); const err4: TryGetError.TryGetError | undefined = part8 === undefined ? out$u16.err as TryGetError.TryGetError : undefined; - const part9 = result_map$0hs8st9((err4 !== undefined ? rt.Err(err4 as TryGetError.TryGetError) : rt.Ok(part8 as rt.u16)) as rt.Result, (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part9 = result_map$1cosroz((err4 !== undefined ? rs.Err(err4 as TryGetError.TryGetError) : rs.Ok(part8 as rs.u16)) as rs.Result, (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part9); } if (_4 === 16) { - const part6: rt.i64 | undefined = tryGetI64Le$bytes_Buf_mut_dyn_bytes_Buf(buf); + const part6: rs.i64 | undefined = tryGetI64Le$bytes_Buf_mut_dyn_bytes_Buf(buf); const err3: TryGetError.TryGetError | undefined = part6 === undefined ? out$i64.err as TryGetError.TryGetError : undefined; - const part7 = result_map$0c3nzkx((err3 !== undefined ? rt.Err(err3 as TryGetError.TryGetError) : rt.Ok(part6 as rt.i64)) as rt.Result, (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part7 = result_map$1rpus2m((err3 !== undefined ? rs.Err(err3 as TryGetError.TryGetError) : rs.Ok(part6 as rs.i64)) as rs.Result, (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part7); } if (_4 === 17) { - const part5: rt.u128 | undefined = tryGetU128$bytes_Buf_mut_dyn_bytes_Buf(buf); + const part5: rs.u128 | undefined = tryGetU128$bytes_Buf_mut_dyn_bytes_Buf(buf); const err2: TryGetError.TryGetError | undefined = part5 === undefined ? out$u128.err as TryGetError.TryGetError : undefined; - const args = [(err2 !== undefined ? rt.Err(err2 as TryGetError.TryGetError) : rt.Ok(part5 as rt.u128)) as rt.Result] as [rt.Result]; + const args = [(err2 !== undefined ? rs.Err(err2 as TryGetError.TryGetError) : rs.Ok(part5 as rs.u128)) as rs.Result] as [rs.Result]; return _3(args[0]); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_mut_dyn_bytes_Buf(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_mut_dyn_bytes_Buf(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return getU8$bytes_Buf_mut_dyn_bytes_Buf(buf) as rt.u128; + return getU8$bytes_Buf_mut_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(getI8$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI8$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 2) { - return getU16$bytes_Buf_mut_dyn_bytes_Buf(buf) as rt.u128; + return getU16$bytes_Buf_mut_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(getI16Le$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI16Le$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 4) { - return getU32Le$bytes_Buf_mut_dyn_bytes_Buf(buf) as rt.u128; + return getU32Le$bytes_Buf_mut_dyn_bytes_Buf(buf) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(getI32$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI32$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 6) { - return rt.u128Cast(getU64$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getU64$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 7) { - return rt.u128Cast(getI64Le$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI64Le$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 8) { return getU128Le$bytes_Buf_mut_dyn_bytes_Buf(buf); } if (_4 === 9) { - return rt.u128Cast(getI128$bytes_Buf_mut_dyn_bytes_Buf(buf)); + return rs.u128Cast(getI128$bytes_Buf_mut_dyn_bytes_Buf(buf)); } if (_4 === 10) { - return rt.u128Cast(getUint$bytes_Buf_mut_dyn_bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getUint$bytes_Buf_mut_dyn_bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(getIntLe$bytes_Buf_mut_dyn_bytes_Buf(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getIntLe$bytes_Buf_mut_dyn_bytes_Buf(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(getF64$bytes_Buf_mut_dyn_bytes_Buf(buf))); + return rs.u128Cast(rs.f64ToBits(getF64$bytes_Buf_mut_dyn_bytes_Buf(buf))); } if (_4 === 13) { - return rt.f32ToBits(getF32Le$bytes_Buf_mut_dyn_bytes_Buf(buf)) as rt.u128; + return rs.f32ToBits(getF32Le$bytes_Buf_mut_dyn_bytes_Buf(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - copyToSlice$bytes_Buf_mut_dyn_bytes_Buf(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + copyToSlice$bytes_Buf_mut_dyn_bytes_Buf(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$mut_ref_slice_u8(buf: rt.Place>, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$mut_ref_slice_u8(buf: rs.Place>, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part8: rt.u16 | undefined = tryGetU16$bytes_Buf_mut_ref_slice_u8(buf); + const part8: rs.u16 | undefined = tryGetU16$bytes_Buf_mut_ref_slice_u8(buf); const err4: TryGetError.TryGetError | undefined = part8 === undefined ? out$u16.err as TryGetError.TryGetError : undefined; - const part9 = result_map$0hs8st9((err4 !== undefined ? rt.Err(err4 as TryGetError.TryGetError) : rt.Ok(part8 as rt.u16)) as rt.Result, (a02: rt.u16): rt.u128 => { - return a02 as rt.u128; + const part9 = result_map$1cosroz((err4 !== undefined ? rs.Err(err4 as TryGetError.TryGetError) : rs.Ok(part8 as rs.u16)) as rs.Result, (a02: rs.u16): rs.u128 => { + return a02 as rs.u128; }); return _3(part9); } if (_4 === 16) { - const part6: rt.i64 | undefined = tryGetI64Le$bytes_Buf_mut_ref_slice_u8(buf); + const part6: rs.i64 | undefined = tryGetI64Le$bytes_Buf_mut_ref_slice_u8(buf); const err3: TryGetError.TryGetError | undefined = part6 === undefined ? out$i64.err as TryGetError.TryGetError : undefined; - const part7 = result_map$0c3nzkx((err3 !== undefined ? rt.Err(err3 as TryGetError.TryGetError) : rt.Ok(part6 as rt.i64)) as rt.Result, (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + const part7 = result_map$1rpus2m((err3 !== undefined ? rs.Err(err3 as TryGetError.TryGetError) : rs.Ok(part6 as rs.i64)) as rs.Result, (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part7); } if (_4 === 17) { - const part5: rt.u128 | undefined = tryGetU128$bytes_Buf_mut_ref_slice_u8(buf); + const part5: rs.u128 | undefined = tryGetU128$bytes_Buf_mut_ref_slice_u8(buf); const err2: TryGetError.TryGetError | undefined = part5 === undefined ? out$u128.err as TryGetError.TryGetError : undefined; - const args = [(err2 !== undefined ? rt.Err(err2 as TryGetError.TryGetError) : rt.Ok(part5 as rt.u128)) as rt.Result] as [rt.Result]; + const args = [(err2 !== undefined ? rs.Err(err2 as TryGetError.TryGetError) : rs.Ok(part5 as rs.u128)) as rs.Result] as [rs.Result]; return _3(args[0]); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_mut_ref_slice_u8(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_mut_ref_slice_u8(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return getU8$bytes_Buf_mut_ref_slice_u8(buf) as rt.u128; + return getU8$bytes_Buf_mut_ref_slice_u8(buf) as rs.u128; } if (_4 === 1) { - return rt.u128Cast(getI8$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getI8$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 2) { - return getU16$bytes_Buf_mut_ref_slice_u8(buf) as rt.u128; + return getU16$bytes_Buf_mut_ref_slice_u8(buf) as rs.u128; } if (_4 === 3) { - return rt.u128Cast(getI16Le$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getI16Le$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 4) { - return getU32Le$bytes_Buf_mut_ref_slice_u8(buf) as rt.u128; + return getU32Le$bytes_Buf_mut_ref_slice_u8(buf) as rs.u128; } if (_4 === 5) { - return rt.u128Cast(getI32$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getI32$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 6) { - return rt.u128Cast(getU64$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getU64$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 7) { - return rt.u128Cast(getI64Le$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getI64Le$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 8) { return getU128Le$bytes_Buf_mut_ref_slice_u8(buf); } if (_4 === 9) { - return rt.u128Cast(getI128$bytes_Buf_mut_ref_slice_u8(buf)); + return rs.u128Cast(getI128$bytes_Buf_mut_ref_slice_u8(buf)); } if (_4 === 10) { - return rt.u128Cast(getUint$bytes_Buf_mut_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getUint$bytes_Buf_mut_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 11) { - return rt.u128Cast(getIntLe$bytes_Buf_mut_ref_slice_u8(buf, rt.usizeRem(n, 10))); + return rs.u128Cast(getIntLe$bytes_Buf_mut_ref_slice_u8(buf, rs.usizeRem(n, 10))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(getF64$bytes_Buf_mut_ref_slice_u8(buf))); + return rs.u128Cast(rs.f64ToBits(getF64$bytes_Buf_mut_ref_slice_u8(buf))); } if (_4 === 13) { - return rt.f32ToBits(getF32Le$bytes_Buf_mut_ref_slice_u8(buf)) as rt.u128; + return rs.f32ToBits(getF32Le$bytes_Buf_mut_ref_slice_u8(buf)) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - copyToSlice$bytes_Buf_mut_ref_slice_u8(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + copyToSlice$bytes_Buf_mut_ref_slice_u8(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** * A scalar read off the front of a buffer by `n`'s pick, as a `u128`'s bytes, or a * `try_get_*`'s error as what it asked for and what remained. */ -export function read$ref_slice_u8(buf: rt.Place, n: rt.usize): rt.u128 { - const _3: (a0: rt.Result) => rt.u128 = (got: rt.Result): rt.u128 => { +export function read$ref_slice_u8(buf: rs.Place, n: rs.usize): rs.u128 { + const _3: (a0: rs.Result) => rs.u128 = (got: rs.Result): rs.u128 => { if (got.ok) { return got.value; } const e: TryGetError.TryGetError = got.error; - return rt.u128Or(rt.u128Shl(e.requested as rt.u128, 64), e.available as rt.u128); + return rs.u128Or(rs.u128Shl(e.requested as rs.u128, 64), e.available as rs.u128); }; - const _4: rt.usize = rt.usizeRem(n, 19); + const _4: rs.usize = rs.usizeRem(n, 19); if (_4 === 15) { - const part7 = result_map$0hs8st9(rt.bufTryGet(buf, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a010: rt.ByteSlice): rt.usize => { + const part7 = result_map$1cosroz(rs.bufTryGet(buf, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a010: rs.ByteSlice): rs.usize => { return a010.length; - })(p.v), (p: rt.Place) => ((a011: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a011: rs.ByteSlice): rs.ByteSlice => { return a011; - })(p.v), (a012: rt.Place, a15: rt.usize): undefined => { - rt.byteSliceAdvance(a012, a15); - }, (a013: rt.Place, a16: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a013, a16); - }), (a014: rt.u16): rt.u128 => { - return a014 as rt.u128; + })(p.v), (a012: rs.Place, a15: rs.usize): undefined => { + rs.byteSliceAdvance(a012, a15); + }, (a013: rs.Place, a16: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a013, a16); + }), (a014: rs.u16): rs.u128 => { + return a014 as rs.u128; }); return _3(part7); } if (_4 === 16) { - const part6 = result_map$0c3nzkx(rt.bufTryGet(buf, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a06: rt.ByteSlice): rt.usize => { + const part6 = result_map$1rpus2m(rs.bufTryGet(buf, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a06: rs.ByteSlice): rs.usize => { return a06.length; - })(p.v), (p: rt.Place) => ((a07: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a07: rs.ByteSlice): rs.ByteSlice => { return a07; - })(p.v), (a08: rt.Place, a13: rt.usize): undefined => { - rt.byteSliceAdvance(a08, a13); - }, (a09: rt.Place, a14: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a09, a14); - }), (v2: rt.i64): rt.u128 => { - return rt.u128Cast(v2); + })(p.v), (a08: rs.Place, a13: rs.usize): undefined => { + rs.byteSliceAdvance(a08, a13); + }, (a09: rs.Place, a14: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a09, a14); + }), (v2: rs.i64): rs.u128 => { + return rs.u128Cast(v2); }); return _3(part6); } if (_4 === 17) { - const part5 = rt.bufTryGet(buf, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a02: rt.ByteSlice): rt.usize => { + const part5 = rs.bufTryGet(buf, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a02: rs.ByteSlice): rs.usize => { return a02.length; - })(p.v), (p: rt.Place) => ((a03: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a03: rs.ByteSlice): rs.ByteSlice => { return a03; - })(p.v), (a04: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a04, a1); - }, (a05: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a05, a12); + })(p.v), (a04: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a04, a1); + }, (a05: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a05, a12); }); return _3(part5); } if (_4 === 18) { - const part3: rt.u8 | undefined = tryGetU8$bytes_Buf_ref_slice_u8(buf); + const part3: rs.u8 | undefined = tryGetU8$bytes_Buf_ref_slice_u8(buf); const err: TryGetError.TryGetError | undefined = part3 === undefined ? out$u8.err as TryGetError.TryGetError : undefined; - const part4 = result_map$01kzrm1((err !== undefined ? rt.Err(err as TryGetError.TryGetError) : rt.Ok(part3 as rt.u8)) as rt.Result, (a0: rt.u8): rt.u128 => { - return a0 as rt.u128; + const part4 = result_map$1k6isgs((err !== undefined ? rs.Err(err as TryGetError.TryGetError) : rs.Ok(part3 as rs.u8)) as rs.Result, (a0: rs.u8): rs.u128 => { + return a0 as rs.u128; }); return _3(part4); } if (_4 === 0) { - return (rt.bytesReadWord(buf, 1, false) as rt.u8) as rt.u128; + return (rs.bytesReadWord(buf, 1, false) as rs.u8) as rs.u128; } if (_4 === 1) { - return rt.u128Cast((rt.bytesReadWord(buf, 1, false) << 24) >> 24 as rt.i8); + return rs.u128Cast((rs.bytesReadWord(buf, 1, false) << 24) >> 24 as rs.i8); } if (_4 === 2) { - return (rt.bytesReadWord(buf, 2, false) as rt.u16) as rt.u128; + return (rs.bytesReadWord(buf, 2, false) as rs.u16) as rs.u128; } if (_4 === 3) { - return rt.u128Cast((rt.bytesReadWord(buf, 2, true) << 16) >> 16 as rt.i16); + return rs.u128Cast((rs.bytesReadWord(buf, 2, true) << 16) >> 16 as rs.i16); } if (_4 === 4) { - return (rt.bytesReadWord(buf, 4, true) as rt.u32) as rt.u128; + return (rs.bytesReadWord(buf, 4, true) as rs.u32) as rs.u128; } if (_4 === 5) { - return rt.u128Cast((rt.bytesReadWord(buf, 4, false) | 0) as rt.i32); + return rs.u128Cast((rs.bytesReadWord(buf, 4, false) | 0) as rs.i32); } if (_4 === 6) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesRead(buf, 8, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesRead(buf, 8, false))); } if (_4 === 7) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesRead(buf, 8, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesRead(buf, 8, true))); } if (_4 === 8) { - return rt.u128FromBeBytes(rt.bytesRead(buf, 16, true)); + return rs.u128FromBeBytes(rs.bytesRead(buf, 16, true)); } if (_4 === 9) { - return rt.u128Cast(rt.i128FromBeBytes(rt.bytesRead(buf, 16, false))); + return rs.u128Cast(rs.i128FromBeBytes(rs.bytesRead(buf, 16, false))); } if (_4 === 10) { - return rt.u128Cast(rt.u64FromBeBytes(rt.bytesReadInt(buf, 8, rt.usizeRem(n, 10), false, false))); + return rs.u128Cast(rs.u64FromBeBytes(rs.bytesReadInt(buf, 8, rs.usizeRem(n, 10), false, false))); } if (_4 === 11) { - return rt.u128Cast(rt.i64FromBeBytes(rt.bytesReadInt(buf, 8, rt.usizeRem(n, 10), true, true))); + return rs.u128Cast(rs.i64FromBeBytes(rs.bytesReadInt(buf, 8, rs.usizeRem(n, 10), true, true))); } if (_4 === 12) { - return rt.u128Cast(rt.f64ToBits(rt.f64FromBeBytes(rt.bytesRead(buf, 8, false)))); + return rs.u128Cast(rs.f64ToBits(rs.f64FromBeBytes(rs.bytesRead(buf, 8, false)))); } if (_4 === 13) { - return rt.f32ToBits(rt.f32FromBeBytes(rt.bytesRead(buf, 4, true))) as rt.u128; + return rs.f32ToBits(rs.f32FromBeBytes(rs.bytesRead(buf, 4, true))) as rs.u128; } - const dst: Uint8Array = rt.bytes(3); - rt.bytesCopyToSlice(buf, rt.byteSliceRange(rt.byteSliceFrom(dst), 0, rt.usizeRem(n, 4))); - return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rt.u128; + const dst: Uint8Array = rs.bytes(3); + rs.bytesCopyToSlice(buf, rs.byteSliceRange(rs.byteSliceFrom(dst), 0, rs.usizeRem(n, 4))); + return ((dst[0] << 16) | (dst[1] << 8) | dst[2]) as rs.u128; } /** @@ -2130,38 +2130,38 @@ export function read$ref_slice_u8(buf: rt.Place, n: rt.usize): rt. * is promotable only of a vector, and taken back through a clone, and grown or reclaimed. * Only the inputs `caller.ts` names reach these, as each allocates that much. */ -export function far(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function far(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen === 5) { if (dataData[dataStart] === 102) { if (dataData[dataStart + 1] === 97) { if (dataData[dataStart + 2] === 114) { - const past: rt.u8 = dataData[dataStart + 3]; - const op: rt.u8 = dataData[dataStart + 4]; - let buf: rt.BytesMut = rt.bytesMutWithCapacity(134217727 + 64); - rt.bytesMutResize(buf, 134217727 + 8, 1); - rt.bytesMutAdvance(buf, rt.usizeAdd(134217727, rt.u8Rem(past, 2) as rt.usize)); + const past: rs.u8 = dataData[dataStart + 3]; + const op: rs.u8 = dataData[dataStart + 4]; + let buf: rs.BytesMut = rs.bytesMutWithCapacity(134217727 + 64); + rs.bytesMutResize(buf, 134217727 + 8, 1); + rs.bytesMutAdvance(buf, rs.usizeAdd(134217727, rs.u8Rem(past, 2) as rs.usize)); if ((op & 4) !== 0) { - rt.bytesMutResize(buf, buf.cap, 2); - let bytes: rt.ByteSlice = rt.bytesMutFreeze(buf); - const clone: rt.ByteSlice = rt.bytesClone(bytes); - rt.bytesTruncate(rt.place(() => bytes, (value) => bytes = value), 0); - buf = rt.bytesMutFromBytes(clone); - rt.bytesDrop(bytes); + rs.bytesMutResize(buf, buf.cap, 2); + let bytes: rs.ByteSlice = rs.bytesMutFreeze(buf); + const clone: rs.ByteSlice = rs.bytesClone(bytes); + rs.bytesTruncate(rs.place(() => bytes, (value) => bytes = value), 0); + buf = rs.bytesMutFromBytes(clone); + rs.bytesDrop(bytes); } - const _35: rt.u8 = rt.u8Rem(op, 4); + const _35: rs.u8 = rs.u8Rem(op, 4); if (_35 === 0) { - rt.bytesMutReserve(buf, 100); + rs.bytesMutReserve(buf, 100); } else if (_35 === 1) { - rt.byteVecPush(out, rt.bytesMutTryReclaim(buf, 1 << 20) ? 1 : 0); + rs.byteVecPush(out, rs.bytesMutTryReclaim(buf, 1 << 20) ? 1 : 0); } else if (_35 === 2) { - rt.bytesMutSplitOff(buf, buf.length)[Symbol.dispose](); - rt.bytesMutReserve(buf, 4); + rs.bytesMutSplitOff(buf, buf.length)[Symbol.dispose](); + rs.bytesMutReserve(buf, 4); } else { const buf2 = buf; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(rt.bytesMutToByteVec(rt.bytesMutSplitTo(buf2, buf2.length)).data.length as rt.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(rs.bytesMutToByteVec(rs.bytesMutSplitTo(buf2, buf2.length)).data.length as rs.u32).reverse())); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(buf.cap as rt.u32).reverse())); - rt.byteVecExtendFromSlice(out, rt.bytesMutView(buf)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(buf.cap as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(buf)); buf[Symbol.dispose](); } } @@ -2175,30 +2175,30 @@ export function far(dataData: Uint8Array, dataStart: number, dataLen: number, ou * what it split off its front, and a clone of that. `bytes` reclaims the storage only once * no other handle holds it, and the `Bytes` taken back takes it only then too. */ -export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - const _60: (a0: rt.BytesMut, a1: rt.ByteVec) => undefined = (buf2: rt.BytesMut, out2: rt.ByteVec): undefined => { - rt.byteVecExtendFromSlice(out2, rt.byteSliceFrom(rt.u32ToBeBytes(buf2.cap as rt.u32).reverse())); +export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + const _60: (a0: rs.BytesMut, a1: rs.ByteVec) => undefined = (buf2: rs.BytesMut, out2: rs.ByteVec): undefined => { + rs.byteVecExtendFromSlice(out2, rs.byteSliceFrom(rs.u32ToBeBytes(buf2.cap as rs.u32).reverse())); }; if (dataLen === 4) { - const cap: rt.u8 = dataData[dataStart]; - const kept: rt.u8 = dataData[dataStart + 1]; - const add: rt.u8 = dataData[dataStart + 2]; - const read: rt.u8 = dataData[dataStart + 3]; - const _12: rt.usize = rt.usizeMul(cap as rt.usize, 8); - const _11: [rt.usize, rt.usize] = [_12, add as rt.usize]; - const cap2: rt.usize = _12; - const add2: rt.usize = _11[1]; - const buf: rt.BytesMut = rt.bytesMutWithCapacity(cap2); - rt.bytesMutPutFill(buf, 7, rt.usizeDiv(cap2, 2)); - rt.bytesMutAdvance(buf, rt.usizeRem(read as rt.usize, rt.usizeAdd(buf.length, 1))); - const head: rt.BytesMut = rt.bytesMutSplitTo(buf, rt.usizeDiv(buf.length, 3)); - let tail: rt.BytesMut | undefined = rt.bytesMutSplitOff(buf, buf.length); - let frozen: rt.ByteSlice | undefined = rt.bytesMutFreeze(head); - let clone: rt.ByteSlice | undefined = option_clone$0ey9vhe(frozen); + const cap: rs.u8 = dataData[dataStart]; + const kept: rs.u8 = dataData[dataStart + 1]; + const add: rs.u8 = dataData[dataStart + 2]; + const read: rs.u8 = dataData[dataStart + 3]; + const _12: rs.usize = rs.usizeMul(cap as rs.usize, 8); + const _11: [rs.usize, rs.usize] = [_12, add as rs.usize]; + const cap2: rs.usize = _12; + const add2: rs.usize = _11[1]; + const buf: rs.BytesMut = rs.bytesMutWithCapacity(cap2); + rs.bytesMutPutFill(buf, 7, rs.usizeDiv(cap2, 2)); + rs.bytesMutAdvance(buf, rs.usizeRem(read as rs.usize, rs.usizeAdd(buf.length, 1))); + const head: rs.BytesMut = rs.bytesMutSplitTo(buf, rs.usizeDiv(buf.length, 3)); + let tail: rs.BytesMut | undefined = rs.bytesMutSplitOff(buf, buf.length); + let frozen: rs.ByteSlice | undefined = rs.bytesMutFreeze(head); + let clone: rs.ByteSlice | undefined = option_clone$1i3gmk3(frozen); if ((kept & 1) === 0) { const taken = tail; tail = undefined; - rt.drop(taken); + rs.drop(taken); } if ((kept & 2) === 0) { const taken2 = frozen; @@ -2210,25 +2210,25 @@ export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: numbe clone = undefined; lib_drop$Option_bytes_Bytes(taken3); } - rt.byteVecPush(out, rt.bytesMutTryReclaim(buf, add2) ? 1 : 0); + rs.byteVecPush(out, rs.bytesMutTryReclaim(buf, add2) ? 1 : 0); _60(buf, out); - rt.bytesMutReserve(buf, rt.usizeMul(add2, 2)); + rs.bytesMutReserve(buf, rs.usizeMul(add2, 2)); _60(buf, out); const taken4 = frozen; frozen = undefined; - const _77: rt.ByteSlice | undefined = taken4; + const _77: rs.ByteSlice | undefined = taken4; if (_77 !== undefined) { - const _85: rt.BytesMut = rt.bytesMutFromBytes(_77); + const _85: rs.BytesMut = rs.bytesMutFromBytes(_77); _60(_85, out); _85[Symbol.dispose](); } - rt.drop(tail); + rs.drop(tail); if (clone !== undefined) { - const _94: rt.BytesMut = rt.bytesMutFromBytes(clone); + const _94: rs.BytesMut = rs.bytesMutFromBytes(clone); _60(_94, out); _94[Symbol.dispose](); } - rt.byteVecExtendFromSlice(out, rt.bytesMutView(buf)); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(buf)); lib_drop$Option_bytes_Bytes(frozen); buf[Symbol.dispose](); } @@ -2238,398 +2238,398 @@ export function reclaims(dataData: Uint8Array, dataStart: number, dataLen: numbe * The same reads off a `Bytes`, a `BytesMut`, a `&[u8]`, buffers in pieces, a `Take`, and * each through the impl forwarding through a `&mut`: each scalar, and what remains. */ -export function reads(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let rest!: rt.ByteVec; +export function reads(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let rest!: rs.ByteVec; if (dataLen >= 2) { - const mid: number = rt.usizeDiv(dataLen - 2, 2); + const mid: number = rs.usizeDiv(dataLen - 2, 2); if (mid > dataLen - 2) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const input: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); - const cut: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(input.length, 1)); - const _22: rt.u8 = rt.u8Rem(dataData[dataStart], 9); + const input: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); + const cut: rs.usize = rs.usizeRem(dataData[dataStart + 1] as rs.usize, rs.usizeAdd(input.length, 1)); + const _22: rs.u8 = rs.u8Rem(dataData[dataStart], 9); if (_22 === 0) { - let _24: rt.ByteSlice = rt.bytesCopyFromSlice(input); - rest = readAll$bytes_Bytes(rt.place(() => _24, (value7) => _24 = value7), new rt.ByteSlice(dataData, dataStart + 2, mid), out); - rt.bytesDrop(_24); + let _24: rs.ByteSlice = rs.bytesCopyFromSlice(input); + rest = readAll$bytes_Bytes(rs.place(() => _24, (value7) => _24 = value7), new rs.ByteSlice(dataData, dataStart + 2, mid), out); + rs.bytesDrop(_24); } else if (_22 === 1) { - const _26: rt.BytesMut = rt.bytesMutFrom(input); - rest = readAll$bytes_BytesMut(_26, new rt.ByteSlice(dataData, dataStart + 2, mid), out); + const _26: rs.BytesMut = rs.bytesMutFrom(input); + rest = readAll$bytes_BytesMut(_26, new rs.ByteSlice(dataData, dataStart + 2, mid), out); _26[Symbol.dispose](); } else if (_22 === 2) { - rest = readAll$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut), new rt.ByteSlice(dataData, dataStart + 2, mid), out); + rest = readAll$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut), new rs.ByteSlice(dataData, dataStart + 2, mid), out); } else if (_22 === 3) { - let _30: rt.ByteSlice = rt.byteSliceRange(input, 0); - rest = readAll$ref_slice_u8(rt.place(() => _30, (value6) => _30 = value6), new rt.ByteSlice(dataData, dataStart + 2, mid), out); + let _30: rs.ByteSlice = rs.byteSliceRange(input, 0); + rest = readAll$ref_slice_u8(rs.place(() => _30, (value6) => _30 = value6), new rs.ByteSlice(dataData, dataStart + 2, mid), out); } else if (_22 === 4) { const _33: Provided.Provided = { _0: Pieces.new(input.data, input.start, input.length, cut) }; - rest = readAll$buf_Provided(_33, new rt.ByteSlice(dataData, dataStart + 2, mid), out); + rest = readAll$buf_Provided(_33, new rs.ByteSlice(dataData, dataStart + 2, mid), out); } else if (_22 === 5) { - let _37: rt.ByteSlice = rt.bytesCopyFromSlice(input); - let _36: rt.Place = rt.place(() => _37, (value4) => _37 = value4); - rest = readAll$mut_bytes_Bytes(rt.place(() => _36, (value5) => _36 = value5), new rt.ByteSlice(dataData, dataStart + 2, mid), out); - rt.bytesDrop(_37); + let _37: rs.ByteSlice = rs.bytesCopyFromSlice(input); + let _36: rs.Place = rs.place(() => _37, (value4) => _37 = value4); + rest = readAll$mut_bytes_Bytes(rs.place(() => _36, (value5) => _36 = value5), new rs.ByteSlice(dataData, dataStart + 2, mid), out); + rs.bytesDrop(_37); } else if (_22 === 6) { - let _40: rt.ByteSlice = rt.byteSliceRange(input, 0); - let _39: rt.Place = rt.place(() => _40, (value2) => _40 = value2); - rest = readAll$mut_ref_slice_u8(rt.place(() => _39, (value3) => _39 = value3), new rt.ByteSlice(dataData, dataStart + 2, mid), out); + let _40: rs.ByteSlice = rs.byteSliceRange(input, 0); + let _39: rs.Place = rs.place(() => _40, (value2) => _40 = value2); + rest = readAll$mut_ref_slice_u8(rs.place(() => _39, (value3) => _39 = value3), new rs.ByteSlice(dataData, dataStart + 2, mid), out); } else if (_22 === 7) { - const _43: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rt.bytesCopyFromSlice(input), cut); - rest = readAll$bytes_buf_Take_bytes_Bytes(_43, new rt.ByteSlice(dataData, dataStart + 2, mid), out); + const _43: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesCopyFromSlice(input), cut); + rest = readAll$bytes_buf_Take_bytes_Bytes(_43, new rs.ByteSlice(dataData, dataStart + 2, mid), out); lib_drop$bytes_buf_Take_bytes_Bytes(_43); } else { let _46: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); - rest = readAll$mut_buf_Pieces(rt.place(() => _46, (value) => _46 = value), new rt.ByteSlice(dataData, dataStart + 2, mid), out); + rest = readAll$mut_buf_Pieces(rs.place(() => _46, (value) => _46 = value), new rs.ByteSlice(dataData, dataStart + 2, mid), out); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rest)); - const vec: rt.ByteVec = new rt.ByteVec(); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rest)); + const vec: rs.ByteVec = new rs.ByteVec(); const _54: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); - rt.byteVecPutBuf(vec, _54, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec)); - const slice: rt.ByteSlice = input; - rt.byteVecPush(out, slice.length === input.length ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEq(slice, input) ? 1 : 0); - rt.byteVecPush(out, slice.length !== 0 ? 1 : 0); + rs.byteVecPutBuf(vec, _54, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(vec)); + const slice: rs.ByteSlice = input; + rs.byteVecPush(out, slice.length === input.length ? 1 : 0); + rs.byteVecPush(out, rs.byteSliceEq(slice, input) ? 1 : 0); + rs.byteVecPush(out, slice.length !== 0 ? 1 : 0); } } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$boxed_Box_dyn_bytes_Buf(buf: rt.Place, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$boxed_Box_dyn_bytes_Buf(buf: rs.Place, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$boxed_Box_dyn_bytes_Buf(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$boxed_Box_dyn_bytes_Buf(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(buf) ? 1 : 0); } else { advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(buf); - const _26: rt.ByteSlice = copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(buf); + const _26: rs.ByteSlice = copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$buf_Pieces(buf: Pieces.Pieces, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$buf_Pieces(buf: Pieces.Pieces, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$buf_Pieces(buf, op as rt.usize)))); - rt.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$buf_Pieces(buf, op as rs.usize)))); + rs.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); } else { Pieces.advance$bytes_Buf(buf, 1); } } - const n: rt.usize = Pieces.remaining$bytes_Buf_mut(buf); - const _26: rt.ByteSlice = Pieces.copyToBytes$bytes_Buf(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Pieces.remaining$bytes_Buf_mut(buf); + const _26: rs.ByteSlice = Pieces.copyToBytes$bytes_Buf(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$buf_Provided(buf: Provided.Provided, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$buf_Provided(buf: Provided.Provided, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$buf_Provided(buf, op as rt.usize)))); - rt.byteVecPush(out, Provided.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$buf_Provided(buf, op as rs.usize)))); + rs.byteVecPush(out, Provided.hasRemaining$bytes_Buf_mut(buf) ? 1 : 0); } else { Provided.advance$bytes_Buf(buf, 1); } } - const n: rt.usize = Provided.remaining$bytes_Buf_mut(buf); - const _26: rt.ByteSlice = rt.bufCopyToBytes(buf, n, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Provided.remaining$bytes_Buf_mut(buf); + const _26: rs.ByteSlice = rs.bufCopyToBytes(buf, n, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_Bytes(buf: rt.Place, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_Bytes(buf: rs.Place, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_Bytes(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_Bytes(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_Bytes(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_Bytes(buf) ? 1 : 0); } else { - rt.bytesAdvance(buf, 1); + rs.bytesAdvance(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_bytes_Bytes(buf); - const _26: rt.ByteSlice = rt.bytesSplitTo(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_bytes_Bytes(buf); + const _26: rs.ByteSlice = rs.bytesSplitTo(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_BytesMut(buf: rt.BytesMut, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_BytesMut(buf: rs.BytesMut, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_BytesMut(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_BytesMut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_BytesMut(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_bytes_BytesMut(buf) ? 1 : 0); } else { - rt.bytesMutAdvance(buf, 1); + rs.bytesMutAdvance(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_bytes_BytesMut(buf); - const _26: rt.ByteSlice = rt.bytesMutFreeze(rt.bytesMutSplitTo(buf, n)); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_bytes_BytesMut(buf); + const _26: rs.ByteSlice = rs.bytesMutFreeze(rs.bytesMutSplitTo(buf, n)); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_buf_Pieces_buf_Provided(buf: Chain.Chain, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_buf_Pieces_buf_Provided(buf: Chain.Chain, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_buf_Pieces_buf_Provided(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_buf_Pieces_buf_Provided(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_buf_Pieces_buf_Provided(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf: Chain.Chain, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf: Chain.Chain, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_buf_Provided_bytes_Bytes(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf: Chain.Chain>, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf: Chain.Chain>, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf: Chain.Chain, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf: Chain.Chain, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf: Chain.Chain, Pieces.Pieces>, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf: Chain.Chain, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf: Chain.Chain, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf, op as rt.usize)))); - rt.byteVecPush(out, Chain.hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf, op as rs.usize)))); + rs.byteVecPush(out, Chain.hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf) ? 1 : 0); } else { Chain.advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, 1); } } - const n: rt.usize = Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf); - const _26: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf); + const _26: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$bytes_buf_Take_bytes_Bytes(buf: Take.Take, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$bytes_buf_Take_bytes_Bytes(buf: Take.Take, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$bytes_buf_Take_bytes_Bytes(buf, op as rt.usize)))); - rt.byteVecPush(out, Take.hasRemaining$bytes_Buf_bytes_Bytes_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$bytes_buf_Take_bytes_Bytes(buf, op as rs.usize)))); + rs.byteVecPush(out, Take.hasRemaining$bytes_Buf_bytes_Bytes_mut(buf) ? 1 : 0); } else { Take.advance$bytes_Buf_bytes_Bytes(buf, 1); } } - const n: rt.usize = Take.remaining$bytes_Buf_bytes_Bytes_mut(buf); - const _26: rt.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Take.remaining$bytes_Buf_bytes_Bytes_mut(buf); + const _26: rs.ByteSlice = Take.copyToBytes$bytes_Buf_bytes_Bytes(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$dyn_buf_Leased(buf: Leased.Leased, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$dyn_buf_Leased(buf: Leased.Leased, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$dyn_buf_Leased(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_dyn_buf_Leased(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$dyn_buf_Leased(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_dyn_buf_Leased(buf) ? 1 : 0); } else { buf.advance$Buf(1); } } - const n: rt.usize = remaining$bytes_Buf_mut_dyn_buf_Leased(buf); - const _26: rt.ByteSlice = buf.copyToBytes$Buf(n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_dyn_buf_Leased(buf); + const _26: rs.ByteSlice = buf.copyToBytes$Buf(n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$dyn_bytes_Buf(buf: Buf.Buf, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$dyn_bytes_Buf(buf: Buf.Buf, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$dyn_bytes_Buf(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_dyn_bytes_Buf(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$dyn_bytes_Buf(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_dyn_bytes_Buf(buf) ? 1 : 0); } else { buf.advance$Buf(1); } } - const n: rt.usize = remaining$bytes_Buf_mut_dyn_bytes_Buf(buf); - const _26: rt.ByteSlice = buf.copyToBytes$Buf(n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_dyn_bytes_Buf(buf); + const _26: rs.ByteSlice = buf.copyToBytes$Buf(n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_buf_Pieces(buf: rt.Place, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$mut_buf_Pieces(buf: rs.Place, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$mut_buf_Pieces(buf, op as rt.usize)))); - rt.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut_mut(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$mut_buf_Pieces(buf, op as rs.usize)))); + rs.byteVecPush(out, Pieces.hasRemaining$bytes_Buf_mut_mut(buf) ? 1 : 0); } else { Pieces.advance$bytes_Buf_mut(buf, 1); } } - const n: rt.usize = Pieces.remaining$bytes_Buf_mut_mut(buf); - const _26: rt.ByteSlice = Pieces.copyToBytes$bytes_Buf_mut(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = Pieces.remaining$bytes_Buf_mut_mut(buf); + const _26: rs.ByteSlice = Pieces.copyToBytes$bytes_Buf_mut(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_bytes_Bytes(buf: rt.Place>, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$mut_bytes_Bytes(buf: rs.Place>, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$mut_bytes_Bytes(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_bytes_Bytes(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$mut_bytes_Bytes(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_bytes_Bytes(buf) ? 1 : 0); } else { advance$bytes_Buf_mut_bytes_Bytes(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_mut_bytes_Bytes(buf); - const _26: rt.ByteSlice = copyToBytes$bytes_Buf_mut_bytes_Bytes(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_mut_bytes_Bytes(buf); + const _26: rs.ByteSlice = copyToBytes$bytes_Buf_mut_bytes_Bytes(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_dyn_bytes_Buf(buf: rt.Place, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$mut_dyn_bytes_Buf(buf: rs.Place, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$mut_dyn_bytes_Buf(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_dyn_bytes_Buf(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$mut_dyn_bytes_Buf(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_dyn_bytes_Buf(buf) ? 1 : 0); } else { advance$bytes_Buf_mut_dyn_bytes_Buf(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_mut_dyn_bytes_Buf(buf); - const _26: rt.ByteSlice = copyToBytes$bytes_Buf_mut_dyn_bytes_Buf(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_mut_dyn_bytes_Buf(buf); + const _26: rs.ByteSlice = copyToBytes$bytes_Buf_mut_dyn_bytes_Buf(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$mut_ref_slice_u8(buf: rt.Place>, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$mut_ref_slice_u8(buf: rs.Place>, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$mut_ref_slice_u8(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$mut_ref_slice_u8(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(buf) ? 1 : 0); } else { advance$bytes_Buf_mut_ref_slice_u8(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_mut_ref_slice_u8(buf); - const _26: rt.ByteSlice = copyToBytes$bytes_Buf_mut_ref_slice_u8(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_mut_ref_slice_u8(buf); + const _26: rs.ByteSlice = copyToBytes$bytes_Buf_mut_ref_slice_u8(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } /** `read`s by each of `ops`, then the rest, as `copy_to_bytes` takes it. */ -export function readAll$ref_slice_u8(buf: rt.Place, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - for (const op of rt.byteSliceView(ops)) { +export function readAll$ref_slice_u8(buf: rs.Place, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + for (const op of rs.byteSliceView(ops)) { if (!(op === 255)) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u128ToBeBytes(read$ref_slice_u8(buf, op as rt.usize)))); - rt.byteVecPush(out, hasRemaining$bytes_Buf_mut_ref_slice_u8(buf) ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u128ToBeBytes(read$ref_slice_u8(buf, op as rs.usize)))); + rs.byteVecPush(out, hasRemaining$bytes_Buf_mut_ref_slice_u8(buf) ? 1 : 0); } else { - rt.byteSliceAdvance(buf, 1); + rs.byteSliceAdvance(buf, 1); } } - const n: rt.usize = remaining$bytes_Buf_mut_ref_slice_u8(buf); - const _26: rt.ByteSlice = rt.byteSliceCopyToBytes(buf, n); - const _0: rt.ByteVec = rt.byteSliceToByteVec(_26); - rt.bytesDrop(_26); + const n: rs.usize = remaining$bytes_Buf_mut_ref_slice_u8(buf); + const _26: rs.ByteSlice = rs.byteSliceCopyToBytes(buf, n); + const _0: rs.ByteVec = rs.byteSliceToByteVec(_26); + rs.bytesDrop(_26); return _0; } @@ -2639,31 +2639,31 @@ export function readAll$ref_slice_u8(buf: rt.Place, ops: rt.ByteSl * own trait over `Buf`, whose method takes another `dyn Buf`. A box drops what it owns * once. */ -export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let _30!: Buf.Buf; - let rest!: rt.ByteVec; + let rest!: rs.ByteVec; let _58!: Buf.Buf; if (dataLen >= 2) { - const mid: number = rt.usizeDiv(dataLen - 2, 2); + const mid: number = rs.usizeDiv(dataLen - 2, 2); if (mid > dataLen - 2) { - rt.panic("mid > len"); - } - const ops2: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2, mid); - const input: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); - const cut: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(input.length, 1)); - let bytes: rt.ByteSlice = rt.bytesCopyFromSlice(input); - const owned: rt.BytesMut = rt.bytesMutFrom(input); - let slice: rt.ByteSlice = input; + rs.panic("mid > len"); + } + const ops2: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 2, mid); + const input: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 2 + mid, dataLen - 2 - mid); + const cut: rs.usize = rs.usizeRem(dataData[dataStart + 1] as rs.usize, rs.usizeAdd(input.length, 1)); + let bytes: rs.ByteSlice = rs.bytesCopyFromSlice(input); + const owned: rs.BytesMut = rs.bytesMutFrom(input); + let slice: rs.ByteSlice = input; const pieces: Pieces.Pieces = Pieces.new(input.data, input.start, input.length, cut); const provided: Provided.Provided = { _0: Pieces.new(input.data, input.start, input.length, cut) }; - const take: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rt.bytesCopyFromSlice(input), cut); - const _31: rt.u8 = rt.u8Rem(dataData[dataStart], 6); + const take: Take.Take = buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesCopyFromSlice(input), cut); + const _31: rs.u8 = rs.u8Rem(dataData[dataStart], 6); if (_31 === 0) { - _30 = new ofPlace$bytes_Bytes(rt.place(() => bytes, (value2) => bytes = value2)); + _30 = new ofPlace$bytes_Bytes(rs.place(() => bytes, (value2) => bytes = value2)); } else if (_31 === 1) { _30 = new of$bytes_BytesMut(owned); } else if (_31 === 2) { - _30 = new ofPlace$ref_slice_u8(rt.place(() => slice, (value) => slice = value)); + _30 = new ofPlace$ref_slice_u8(rs.place(() => slice, (value) => slice = value)); } else if (_31 === 3) { _30 = new of$buf_Pieces(pieces); } else if (_31 === 4) { @@ -2672,40 +2672,40 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o _30 = new of$bytes_buf_Take_bytes_Bytes(take); } const buf: Buf.Buf = _30; - if (rt.u8Rem(rt.u8Div(dataData[dataStart], 6), 3) === 0) { + if (rs.u8Rem(rs.u8Div(dataData[dataStart], 6), 3) === 0) { rest = readAll$dyn_bytes_Buf(buf, ops2, out); } else { let _43: Buf.Buf = buf; - rest = readAll$mut_dyn_bytes_Buf(rt.place(() => _43, (value3) => _43 = value3), ops2, out); + rest = readAll$mut_dyn_bytes_Buf(rs.place(() => _43, (value3) => _43 = value3), ops2, out); } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rest)); - rt.byteVecPush(out, bytes.length & 0xff); - rt.byteVecPush(out, slice.length & 0xff); - const drops: rt.Arc> = new rt.Arc(new rt.Cell(0)); - const _59: rt.u8 = rt.u8Rem(dataData[dataStart], 3); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rest)); + rs.byteVecPush(out, bytes.length & 0xff); + rs.byteVecPush(out, slice.length & 0xff); + const drops: rs.Arc> = new rs.Arc(new rs.Cell(0)); + const _59: rs.u8 = rs.u8Rem(dataData[dataStart], 3); if (_59 === 0) { - _58 = new of$buf_Counted(new buf_Counted.Counted(Pieces.new(input.data, input.start, input.length, cut), rt.arcClone(drops))); + _58 = new of$buf_Counted(new buf_Counted.Counted(Pieces.new(input.data, input.start, input.length, cut), rs.arcClone(drops))); } else if (_59 === 1) { - _58 = new of$bytes_Bytes(rt.bytesCopyFromSlice(input)); + _58 = new of$bytes_Bytes(rs.bytesCopyFromSlice(input)); } else { - _58 = new of$ref_slice_u8(rt.byteSliceRange(input, 0)); + _58 = new of$ref_slice_u8(rs.byteSliceRange(input, 0)); } let boxed: Buf.Buf = _58; - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(readAll$boxed_Box_dyn_bytes_Buf(rt.place(() => boxed, (value4) => boxed = value4), ops2, out))); - rt.drop(boxed); - rt.byteVecPush(out, drops.value.v); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(readAll$boxed_Box_dyn_bytes_Buf(rs.place(() => boxed, (value4) => boxed = value4), ops2, out))); + rs.drop(boxed); + rs.byteVecPush(out, drops.value.v); const leased: Leased.Leased = new of$buf_Pieces(Pieces.new(input.data, input.start, input.length, cut)); - rt.byteVecPush(out, leased.pieces$Leased() & 0xff); - let skipped: rt.ByteSlice = ops2; - leased.skip$Leased(new ofPlace$ref_slice_u8(rt.place(() => skipped, (value5) => skipped = value5))); - rt.byteVecPush(out, skipped.length & 0xff); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(readAll$dyn_buf_Leased(leased, ops2, out))); - rt.byteVecPush(out, leased.pieces$Leased() & 0xff); - rt.drop(leased); + rs.byteVecPush(out, leased.pieces$Leased() & 0xff); + let skipped: rs.ByteSlice = ops2; + leased.skip$Leased(new ofPlace$ref_slice_u8(rs.place(() => skipped, (value5) => skipped = value5))); + rs.byteVecPush(out, skipped.length & 0xff); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(readAll$dyn_buf_Leased(leased, ops2, out))); + rs.byteVecPush(out, leased.pieces$Leased() & 0xff); + rs.drop(leased); drops[Symbol.dispose](); lib_drop$bytes_buf_Take_bytes_Bytes(take); owned[Symbol.dispose](); - rt.bytesDrop(bytes); + rs.bytesDrop(bytes); } } @@ -2714,23 +2714,23 @@ export function dyns(dataData: Uint8Array, dataStart: number, dataLen: number, o * a function this one calls, which translation reaches after, so the object holds the * method before that buffer's class is made. */ -export function late(data: rt.ByteSlice, out: rt.ByteVec): void { - let slice: rt.ByteSlice = data; - const buf: Buf.Buf = new ofPlace$ref_slice_u8(rt.place(() => slice, (value) => slice = value)); +export function late(data: rs.ByteSlice, out: rs.ByteVec): void { + let slice: rs.ByteSlice = data; + const buf: Buf.Buf = new ofPlace$ref_slice_u8(rs.place(() => slice, (value) => slice = value)); if (remaining$bytes_Buf_mut_dyn_bytes_Buf(buf) >= 2) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(buf.getI16Ne$Buf()).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(buf.getI16Ne$Buf()).reverse())); } lateTake(slice, out); } /** `get_i16_ne` through a box of a `Take` of `data`, a type no other `dyn Buf` is made of. */ -export function lateTake(data: rt.ByteSlice, out: rt.ByteVec): void { - let boxed: Buf.Buf = new of$bytes_buf_Take_ref_slice_u8(buf_impl_take$bytes_Buf_ref_slice_u8(data, rt.usizeSaturatingSub(data.length, 1))); +export function lateTake(data: rs.ByteSlice, out: rs.ByteVec): void { + let boxed: Buf.Buf = new of$bytes_buf_Take_ref_slice_u8(buf_impl_take$bytes_Buf_ref_slice_u8(data, rs.usizeSaturatingSub(data.length, 1))); while (remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(boxed) >= 2) { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.i16ToBeBytes(getI16Ne$bytes_Buf_boxed_Box_dyn_bytes_Buf(rt.place(() => boxed, (value) => boxed = value))).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.i16ToBeBytes(getI16Ne$bytes_Buf_boxed_Box_dyn_bytes_Buf(rs.place(() => boxed, (value) => boxed = value))).reverse())); } - rt.byteVecPush(out, remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(boxed) & 0xff); - rt.drop(boxed); + rs.byteVecPush(out, remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(boxed) & 0xff); + rs.drop(boxed); } /** @@ -2740,86 +2740,86 @@ export function lateTake(data: rt.ByteSlice, out: rt.ByteVec): void { * panics past the room; written and read again through a second call; grown and cut. Each * step puts its length, capacity, and room, then its bytes. */ -export function vecSpares(data: rt.ByteSlice, out: rt.ByteVec): void { - let _67!: rt.usize; +export function vecSpares(data: rs.ByteSlice, out: rs.ByteVec): void { + let _67!: rs.usize; const ops: Ops.Ops = { _0Data: data.data, _0Start: data.start, _0Len: data.length }; - const vec: rt.ByteVec = rt.byteVecWithCapacity(rt.usizeRem(Ops.byte(ops) as rt.usize, 20)); + const vec: rs.ByteVec = rs.byteVecWithCapacity(rs.usizeRem(Ops.byte(ops) as rs.usize, 20)); while (true) { - const _10: rt.u8 | undefined = Ops.next(ops); + const _10: rs.u8 | undefined = Ops.next(ops); if (_10 !== undefined) { - const op: rt.u8 = _10; - const n: rt.u8 = Ops.byte(ops); - const spare: rt.ByteSlice = rt.byteVecSpare(vec); - const _20: [rt.usize, rt.usize] = [spare.length, rt.usizeRem(n as rt.usize, rt.usizeAdd(spare.length, 1))]; - const room: rt.usize = _20[0]; - const k: rt.usize = _20[1]; - const _31: rt.u8 = rt.u8Rem(op, 7); + const op: rs.u8 = _10; + const n: rs.u8 = Ops.byte(ops); + const spare: rs.ByteSlice = rs.byteVecSpare(vec); + const _20: [rs.usize, rs.usize] = [spare.length, rs.usizeRem(n as rs.usize, rs.usizeAdd(spare.length, 1))]; + const room: rs.usize = _20[0]; + const k: rs.usize = _20[1]; + const _31: rs.u8 = rs.u8Rem(op, 7); if (_31 === 0) { - const iter: rt.Iter<[rt.usize, rt.Place]> = rt.iterEnumerate(rt.iterSliceMut(rt.byteSliceView(rt.byteSliceRange(spare, 0, k)))); + const iter: rs.Iter<[rs.usize, rs.Place]> = rs.iterEnumerate(rs.iterSliceMut(rs.byteSliceView(rs.byteSliceRange(spare, 0, k)))); while (true) { - const _39: [rt.usize, rt.Place] | rt.Done = iter.next(); - if (_39 === rt.DONE) { + const _39: [rs.usize, rs.Place] | rs.Done = iter.next(); + if (_39 === rs.DONE) { break; } const uninit2 = _39[1]; uninit2.v = n ^ (_39[0] & 0xff); uninit2; } - rt.byteVecSetLen(vec, rt.usizeAdd(vec.length, k)); + rs.byteVecSetLen(vec, rs.usizeAdd(vec.length, k)); } else if (_31 === 1) { - const src: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, k & 0xff), (i2: rt.u8): rt.u8 => { - return rt.u8WrappingAdd(n, i2); + const src: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, k & 0xff), (i2: rs.u8): rs.u8 => { + return rs.u8WrappingAdd(n, i2); }), undefined, true); - const dst = rt.byteSliceRange(spare, 0, k); - rt.byteSliceCopyFromSlice(dst, rt.byteVecSlice(src)); - rt.byteSliceView(dst).reverse(); - if (!(rt.u8Rem(n, 16) === 15)) { + const dst = rs.byteSliceRange(spare, 0, k); + rs.byteSliceCopyFromSlice(dst, rs.byteVecSlice(src)); + rs.byteSliceView(dst).reverse(); + if (!(rs.u8Rem(n, 16) === 15)) { _67 = k; } else { - _67 = rt.usizeAdd(room, 1); + _67 = rs.usizeAdd(room, 1); } - rt.byteVecAdvanceMut(vec, _67); + rs.byteVecAdvanceMut(vec, _67); } else if (_31 === 2) { - const src2: Uint8Array = rt.bytes(64).fill(n); - const k2: rt.usize = rt.min(k, rt.byteSliceFrom(src2).length); - rt.ptrCopy(rt.byteSliceAsPtr(rt.byteSliceFrom(src2)), rt.byteSliceAsPtr(spare), k2); - rt.byteVecSetLen(vec, rt.usizeAdd(vec.length, k2)); + const src2: Uint8Array = rs.bytes(64).fill(n); + const k2: rs.usize = rs.min(k, rs.byteSliceFrom(src2).length); + rs.ptrCopy(rs.byteSliceAsPtr(rs.byteSliceFrom(src2)), rs.byteSliceAsPtr(spare), k2); + rs.byteVecSetLen(vec, rs.usizeAdd(vec.length, k2)); } else if (_31 === 3) { - rt.byteSliceFill(rt.byteSliceRange(spare, 0, k), n); - const _93: rt.Place | undefined = rt.sliceLastMut(rt.byteSliceView(rt.byteSliceSplitAt(rt.byteSliceRange(spare, 0, k), rt.usizeDiv(k, 2))[0])); + rs.byteSliceFill(rs.byteSliceRange(spare, 0, k), n); + const _93: rs.Place | undefined = rs.sliceLastMut(rs.byteSliceView(rs.byteSliceSplitAt(rs.byteSliceRange(spare, 0, k), rs.usizeDiv(k, 2))[0])); if (_93 !== undefined) { _93.v = ~n & 0xff; } - rt.byteVecSetLen(vec, rt.usizeAdd(vec.length, k)); + rs.byteVecSetLen(vec, rs.usizeAdd(vec.length, k)); } else if (_31 === 4) { - const _109: rt.Place | undefined = rt.sliceFirstMut(rt.byteSliceView(spare)); + const _109: rs.Place | undefined = rs.sliceFirstMut(rs.byteSliceView(spare)); if (_109 !== undefined) { const uninit = _109; uninit.v = n; uninit; } - const _113: rt.u8 | undefined = rt.byteSliceFirst(rt.byteVecSpare(vec)); + const _113: rs.u8 | undefined = rs.byteSliceFirst(rs.byteVecSpare(vec)); if (_113 !== undefined) { - rt.byteVecPush(out, _113); + rs.byteVecPush(out, _113); } } else if (_31 === 5) { - rt.byteVecReserve(vec, rt.usizeRem(n as rt.usize, 40)); + rs.byteVecReserve(vec, rs.usizeRem(n as rs.usize, 40)); } else { - rt.byteVecTruncate(vec, rt.usizeRem(n as rt.usize, rt.usizeAdd(vec.length, 1))); + rs.byteVecTruncate(vec, rs.usizeRem(n as rs.usize, rs.usizeAdd(vec.length, 1))); } - const iter2: rt.Iter = rt.iterSlice([vec.length, vec.data.length, rt.byteVecSpare(vec).length]); + const iter2: rs.Iter = rs.iterSlice([vec.length, vec.data.length, rs.byteVecSpare(vec).length]); while (true) { - const _145: rt.usize | rt.Done = iter2.next(); - if (_145 === rt.DONE) { + const _145: rs.usize | rs.Done = iter2.next(); + if (_145 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_145 as rt.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_145 as rs.u32).reverse())); } } else { break; } } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(vec)); } /** @@ -2827,120 +2827,120 @@ export function vecSpares(data: rt.ByteSlice, out: rt.ByteVec): void { * impls forwarding through a `&mut` and a `Box`, whose provided `put` and `put_bytes` * grow by `chunk_mut` instead: the bytes, and each vector's capacity. */ -export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { - let _33!: rt.u8; - let _145!: rt.u8; +export function writes(data: rs.ByteSlice, out: rs.ByteVec): void { + let _33!: rs.u8; + let _145!: rs.u8; if (data.length >= 2) { - const cap: rt.usize = rt.u8Rem(data.data[data.start + 1], 24) as rt.usize; - const _14: [rt.ByteVec, rt.BytesMut] = [rt.byteVecWithCapacity(cap), rt.bytesMutWithCapacity(cap)]; - const vec: rt.ByteVec = _14[0]; - const buf: rt.BytesMut = _14[1]; - const _19: [rt.ByteVec, rt.BytesMut] = [rt.byteVecWithCapacity(cap), rt.bytesMutWithCapacity(cap)]; - const throughVec: rt.ByteVec = _19[0]; - const throughBuf: rt.BytesMut = _19[1]; - const _24: [rt.ByteVec, rt.BytesMut] = [rt.byteVecWithCapacity(cap), rt.bytesMutWithCapacity(cap)]; - let boxedVec: rt.ByteVec = _24[0]; - let boxedBuf: rt.BytesMut = _24[1]; - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 6; + const cap: rs.usize = rs.u8Rem(data.data[data.start + 1], 24) as rs.usize; + const _14: [rs.ByteVec, rs.BytesMut] = [rs.byteVecWithCapacity(cap), rs.bytesMutWithCapacity(cap)]; + const vec: rs.ByteVec = _14[0]; + const buf: rs.BytesMut = _14[1]; + const _19: [rs.ByteVec, rs.BytesMut] = [rs.byteVecWithCapacity(cap), rs.bytesMutWithCapacity(cap)]; + const throughVec: rs.ByteVec = _19[0]; + const throughBuf: rs.BytesMut = _19[1]; + const _24: [rs.ByteVec, rs.BytesMut] = [rs.byteVecWithCapacity(cap), rs.bytesMutWithCapacity(cap)]; + let boxedVec: rs.ByteVec = _24[0]; + let boxedBuf: rs.BytesMut = _24[1]; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 6; while ((_33 = iterStart++) < iterEnd) { - const _37: rt.u8 = rt.u8Rem(rt.u8WrappingAdd(data.data[data.start], _33), 6); + const _37: rs.u8 = rs.u8Rem(rs.u8WrappingAdd(data.data[data.start], _33), 6); if (_37 === 0) { const arg6 = vec; - const slice6 = rt.byteSliceRange(data, 2); + const slice6 = rs.byteSliceRange(data, 2); writeAll$Vec_u8(arg6, slice6.data, slice6.start, slice6.length); } else if (_37 === 1) { const arg5 = buf; - const slice5 = rt.byteSliceRange(data, 2); + const slice5 = rs.byteSliceRange(data, 2); writeAll$bytes_BytesMut(arg5, slice5.data, slice5.start, slice5.length); } else if (_37 === 2) { - let _44: rt.ByteVec = throughVec; - const arg4 = rt.place(() => _44, (value4) => _44 = value4); - const slice4 = rt.byteSliceRange(data, 2); + let _44: rs.ByteVec = throughVec; + const arg4 = rs.place(() => _44, (value4) => _44 = value4); + const slice4 = rs.byteSliceRange(data, 2); writeAll$mut_Vec_u8(arg4, slice4.data, slice4.start, slice4.length); } else if (_37 === 3) { - let _46: rt.BytesMut = throughBuf; - const arg3 = rt.place(() => _46, (value3) => _46 = value3); - const slice3 = rt.byteSliceRange(data, 2); + let _46: rs.BytesMut = throughBuf; + const arg3 = rs.place(() => _46, (value3) => _46 = value3); + const slice3 = rs.byteSliceRange(data, 2); writeAll$mut_bytes_BytesMut(arg3, slice3.data, slice3.start, slice3.length); } else if (_37 === 4) { - const arg2 = rt.place(() => boxedVec, (value2) => boxedVec = value2); - const slice2 = rt.byteSliceRange(data, 2); + const arg2 = rs.place(() => boxedVec, (value2) => boxedVec = value2); + const slice2 = rs.byteSliceRange(data, 2); writeAll$boxed_Box_Vec_u8(arg2, slice2.data, slice2.start, slice2.length); } else { - const arg = rt.place(() => boxedBuf, (value) => boxedBuf = value); - const slice = rt.byteSliceRange(data, 2); + const arg = rs.place(() => boxedBuf, (value) => boxedBuf = value); + const slice = rs.byteSliceRange(data, 2); writeAll$boxed_Box_bytes_BytesMut(arg, slice.data, slice.start, slice.length); } } const pieces: () => Pieces.Pieces = (): Pieces.Pieces => { - const _2: rt.usize = rt.usizeDiv(rt.byteSliceRange(data, 2).length, 2); - const slice7 = rt.byteSliceRange(data, 2); + const _2: rs.usize = rs.usizeDiv(rs.byteSliceRange(data, 2).length, 2); + const slice7 = rs.byteSliceRange(data, 2); return Pieces.new(slice7.data, slice7.start, slice7.length, _2); }; const lent: Pieces.Pieces = pieces(); - rt.byteVecPutBuf(vec, { v: lent }, (p: rt.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined); - rt.byteVecPutBuf(vec, { v: lent }, (p: rt.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined); - const _60: rt.ByteVec = throughVec; + rs.byteVecPutBuf(vec, { v: lent }, (p: rs.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined); + rs.byteVecPutBuf(vec, { v: lent }, (p: rs.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined); + const _60: rs.ByteVec = throughVec; const _61: Pieces.Pieces = pieces(); - rt.byteVecPutBufChunked(_60, _61, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + rs.byteVecPutBufChunked(_60, _61, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); const _66: Pieces.Pieces = pieces(); - rt.byteVecPutBufChunked(boxedVec, { v: _66 }, (p: rt.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined); - const iter2: rt.Iter = rt.iterSlice([vec, throughVec, boxedVec]); + rs.byteVecPutBufChunked(boxedVec, { v: _66 }, (p: rs.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined); + const iter2: rs.Iter = rs.iterSlice([vec, throughVec, boxedVec]); while (true) { - const _75: rt.ByteVec | rt.Done = iter2.next(); - if (_75 === rt.DONE) { + const _75: rs.ByteVec | rs.Done = iter2.next(); + if (_75 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_75.data.length as rt.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_75.data.length as rs.u32).reverse())); } - const iter3: rt.Iter = rt.iterSlice([buf, throughBuf, boxedBuf]); + const iter3: rs.Iter = rs.iterSlice([buf, throughBuf, boxedBuf]); while (true) { - const _92: rt.BytesMut | rt.Done = iter3.next(); - if (_92 === rt.DONE) { + const _92: rs.BytesMut | rs.Done = iter3.next(); + if (_92 === rs.DONE) { break; } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(_92.cap as rt.u32).reverse())); - } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(throughVec)); - rt.byteVecExtendFromSlice(out, rt.bytesMutView(throughBuf)); - rt.byteVecPush(out, rt.eqBytes(boxedVec, throughVec) ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEq(rt.bytesMutView(boxedBuf), rt.bytesMutView(throughBuf)) ? 1 : 0); - rt.byteVecPush(out, rt.byteSliceEq(rt.byteVecSlice(vec), rt.bytesMutView(buf)) ? 1 : 0); - rt.byteVecPush(out, (0x7fffffff - vec.length as rt.usize) === 0x7fffffff - buf.length as rt.usize ? 1 : 0); - rt.byteVecPush(out, buf.length < 0x7fffffff ? 1 : 0); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(vec)); - const part = rt.usizeDiv(rt.byteSliceRange(data, 2).length, 2); - const half: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceRange(data, 2), 0, part); - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 6; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(_92.cap as rs.u32).reverse())); + } + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(throughVec)); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(throughBuf)); + rs.byteVecPush(out, rs.eqBytes(boxedVec, throughVec) ? 1 : 0); + rs.byteVecPush(out, rs.byteSliceEq(rs.bytesMutView(boxedBuf), rs.bytesMutView(throughBuf)) ? 1 : 0); + rs.byteVecPush(out, rs.byteSliceEq(rs.byteVecSlice(vec), rs.bytesMutView(buf)) ? 1 : 0); + rs.byteVecPush(out, (0x7fffffff - vec.length as rs.usize) === 0x7fffffff - buf.length as rs.usize ? 1 : 0); + rs.byteVecPush(out, buf.length < 0x7fffffff ? 1 : 0); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(vec)); + const part = rs.usizeDiv(rs.byteSliceRange(data, 2).length, 2); + const half: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceRange(data, 2), 0, part); + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 6; while ((_145 = iterStart2++) < iterEnd2) { - const kind: rt.u8 = _145; - const fresh: rt.BytesMut = rt.bytesMutWithCapacity(0); + const kind: rs.u8 = _145; + const fresh: rs.BytesMut = rs.bytesMutWithCapacity(0); if (kind === 0) { - rt.bytesMutPutSlice(fresh, half); + rs.bytesMutPutSlice(fresh, half); } else if (kind === 1) { - const _153: rt.ByteSlice = rt.bytesCopyFromSlice(half); - rt.bytesMutPutStorage(fresh, _153); + const _153: rs.ByteSlice = rs.bytesCopyFromSlice(half); + rs.bytesMutPutStorage(fresh, _153); } else if (kind === 2) { - const _155: rt.BytesMut = rt.bytesMutFrom(half); - rt.bytesMutPutMut(fresh, _155); + const _155: rs.BytesMut = rs.bytesMutFrom(half); + rs.bytesMutPutMut(fresh, _155); } else if (kind === 3) { - const _157: Pieces.Pieces = Pieces.new(half.data, half.start, half.length, rt.usizeDiv(half.length, 2)); - rt.bytesMutPutBuf(fresh, _157, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToBytes$bytes_Buf); + const _157: Pieces.Pieces = Pieces.new(half.data, half.start, half.length, rs.usizeDiv(half.length, 2)); + rs.bytesMutPutBuf(fresh, _157, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToBytes$bytes_Buf); } else if (kind === 4) { - const _162: Provided.Provided = { _0: Pieces.new(half.data, half.start, half.length, rt.usizeDiv(half.length, 2)) }; - rt.bytesMutPutBuf(fresh, _162, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, (a0: Provided.Provided, a1: rt.usize): rt.ByteSlice => { - return rt.bufCopyToBytes(a0, a1, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _162: Provided.Provided = { _0: Pieces.new(half.data, half.start, half.length, rs.usizeDiv(half.length, 2)) }; + rs.bytesMutPutBuf(fresh, _162, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, (a0: Provided.Provided, a1: rs.usize): rs.ByteSlice => { + return rs.bufCopyToBytes(a0, a1, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); }); } else { - const _168: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(half), half); - rt.bytesMutPutBuf(fresh, _168, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8, lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8); + const _168: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(half), half); + rs.bytesMutPutBuf(fresh, _168, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8, lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8); } - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(fresh.cap as rt.u32).reverse())); - rt.bytesMutPutWord(fresh, kind, 1, false); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(fresh.cap as rt.u32).reverse())); - rt.byteVecExtendFromSlice(out, rt.bytesMutView(fresh)); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(fresh.cap as rs.u32).reverse())); + rs.bytesMutPutWord(fresh, kind, 1, false); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(fresh.cap as rs.u32).reverse())); + rs.byteVecExtendFromSlice(out, rs.bytesMutView(fresh)); fresh[Symbol.dispose](); } boxedBuf[Symbol.dispose](); @@ -2950,552 +2950,552 @@ export function writes(data: rt.ByteSlice, out: rt.ByteVec): void { } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$Vec_u8(buf: rt.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$Vec_u8(buf: rs.ByteVec, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { - rt.byteVecPutWord(buf, n2, 1, false); + rs.byteVecPutWord(buf, n2, 1, false); } else if (_18 === 1) { - rt.byteVecPutWord(buf, (n2 << 24) >> 24, 1, false); + rs.byteVecPutWord(buf, (n2 << 24) >> 24, 1, false); } else if (_18 === 2) { - rt.byteVecPutWord(buf, rt.u64Low(v) & 0xffff, 2, false); + rs.byteVecPutWord(buf, rs.u64Low(v) & 0xffff, 2, false); } else if (_18 === 3) { - rt.byteVecPutWord(buf, (rt.u64Low(v) << 16) >> 16, 2, true); + rs.byteVecPutWord(buf, (rs.u64Low(v) << 16) >> 16, 2, true); } else if (_18 === 4) { - rt.byteVecPutWord(buf, rt.u64Low(v), 4, false); + rs.byteVecPutWord(buf, rs.u64Low(v), 4, false); } else if (_18 === 5) { - rt.byteVecPutWord(buf, rt.u64Low(v) | 0, 4, true); + rs.byteVecPutWord(buf, rs.u64Low(v) | 0, 4, true); } else if (_18 === 6) { - rt.byteVecPutBytes(buf, rt.u64ToBeBytes(v), true); + rs.byteVecPutBytes(buf, rs.u64ToBeBytes(v), true); } else if (_18 === 7) { - rt.byteVecPutBytes(buf, rt.i64ToBeBytes(rt.i64Cast(v)), false); + rs.byteVecPutBytes(buf, rs.i64ToBeBytes(rs.i64Cast(v)), false); } else if (_18 === 8) { - rt.byteVecPutBytes(buf, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.byteVecPutBytes(buf, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - rt.byteVecExtendFromSlice(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + rs.byteVecExtendFromSlice(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.byteVecPutFill(buf, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.byteVecPutFill(buf, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.byteVecPutFill(buf, n2, 4294967295); + rs.byteVecPutFill(buf, n2, 4294967295); } } else if (_18 === 13) { - const src3 = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.byteVecExtendFromSlice(buf, src3); - rt.bytesDrop(src3); + const src3 = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.byteVecExtendFromSlice(buf, src3); + rs.bytesDrop(src3); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.byteVecExtendFromSlice(buf, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.byteVecExtendFromSlice(buf, _47); } else if (_18 === 15) { - const src2 = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.byteVecExtendFromSlice(buf, rt.bytesMutView(src2)); + const src2 = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.byteVecExtendFromSlice(buf, rs.bytesMutView(src2)); src2[Symbol.dispose](); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.byteVecPutBytes(buf, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.byteVecPutBytes(buf, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.byteVecPutBytes(buf, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.byteVecPutBytes(buf, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.byteVecPutBuf(buf, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.byteVecPutBuf(buf, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.byteVecPutBuf(buf, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.byteVecPutBuf(buf, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } else { - const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.byteVecPutBuf(buf, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined); + const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.byteVecPutBuf(buf, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(src); } - const _97: rt.u8 = rt.u8Add(buf.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_Vec_u8(buf), 7) & 0xff); - rt.byteVecPutWord(buf, _97, 1, false); + const _97: rs.u8 = rs.u8Add(buf.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_Vec_u8(buf), 7) & 0xff); + rs.byteVecPutWord(buf, _97, 1, false); } } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$boxed_Box_Vec_u8(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$boxed_Box_Vec_u8(buf: rs.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { putU8$bytes_BufMut_boxed_Box_Vec_u8(buf, n2); } else if (_18 === 1) { putI8$bytes_BufMut_boxed_Box_Vec_u8(buf, (n2 << 24) >> 24); } else if (_18 === 2) { - putU16$bytes_BufMut_boxed_Box_Vec_u8(buf, rt.u64Low(v) & 0xffff); + putU16$bytes_BufMut_boxed_Box_Vec_u8(buf, rs.u64Low(v) & 0xffff); } else if (_18 === 3) { - putI16Le$bytes_BufMut_boxed_Box_Vec_u8(buf, (rt.u64Low(v) << 16) >> 16); + putI16Le$bytes_BufMut_boxed_Box_Vec_u8(buf, (rs.u64Low(v) << 16) >> 16); } else if (_18 === 4) { - putU32$bytes_BufMut_boxed_Box_Vec_u8(buf, rt.u64Low(v)); + putU32$bytes_BufMut_boxed_Box_Vec_u8(buf, rs.u64Low(v)); } else if (_18 === 5) { - putI32Le$bytes_BufMut_boxed_Box_Vec_u8(buf, rt.u64Low(v) | 0); + putI32Le$bytes_BufMut_boxed_Box_Vec_u8(buf, rs.u64Low(v) | 0); } else if (_18 === 6) { putU64Le$bytes_BufMut_boxed_Box_Vec_u8(buf, v); } else if (_18 === 7) { - putI64$bytes_BufMut_boxed_Box_Vec_u8(buf, rt.i64Cast(v)); + putI64$bytes_BufMut_boxed_Box_Vec_u8(buf, rs.i64Cast(v)); } else if (_18 === 8) { - rt.byteVecPutBytes(buf.v, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.byteVecPutBytes(buf.v, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - putSlice$bytes_BufMut_boxed_Box_Vec_u8(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + putSlice$bytes_BufMut_boxed_Box_Vec_u8(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.byteVecPutFillChunked(buf.v, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.byteVecPutFillChunked(buf.v, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.byteVecPutFillChunked(buf.v, n2, 4294967295); + rs.byteVecPutFillChunked(buf.v, n2, 4294967295); } } else if (_18 === 13) { - const src3 = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.byteVecPutChunked(buf.v, src3); - rt.bytesDrop(src3); + const src3 = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.byteVecPutChunked(buf.v, src3); + rs.bytesDrop(src3); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.byteVecPutChunked(buf.v, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.byteVecPutChunked(buf.v, _47); } else if (_18 === 15) { - const src2 = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.byteVecPutChunked(buf.v, rt.bytesMutView(src2)); + const src2 = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.byteVecPutChunked(buf.v, rs.bytesMutView(src2)); src2[Symbol.dispose](); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.byteVecPutBytes(buf.v, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.byteVecPutBytes(buf.v, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.byteVecPutBytes(buf.v, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.byteVecPutBytes(buf.v, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.byteVecPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.byteVecPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.byteVecPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.byteVecPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } else { - const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.byteVecPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined); + const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.byteVecPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(src); } - const _97: rt.u8 = rt.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_boxed_Box_Vec_u8(buf), 7) & 0xff); + const _97: rs.u8 = rs.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_boxed_Box_Vec_u8(buf), 7) & 0xff); putU8$bytes_BufMut_boxed_Box_Vec_u8(buf, _97); } } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$boxed_Box_bytes_BytesMut(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$boxed_Box_bytes_BytesMut(buf: rs.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { putU8$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, n2); } else if (_18 === 1) { putI8$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, (n2 << 24) >> 24); } else if (_18 === 2) { - putU16$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rt.u64Low(v) & 0xffff); + putU16$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rs.u64Low(v) & 0xffff); } else if (_18 === 3) { - putI16Le$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, (rt.u64Low(v) << 16) >> 16); + putI16Le$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, (rs.u64Low(v) << 16) >> 16); } else if (_18 === 4) { - putU32$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rt.u64Low(v)); + putU32$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rs.u64Low(v)); } else if (_18 === 5) { - putI32Le$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rt.u64Low(v) | 0); + putI32Le$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rs.u64Low(v) | 0); } else if (_18 === 6) { putU64Le$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, v); } else if (_18 === 7) { - putI64$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rt.i64Cast(v)); + putI64$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rs.i64Cast(v)); } else if (_18 === 8) { - rt.bytesMutPutBytes(buf.v, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.bytesMutPutBytes(buf.v, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - putSlice$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + putSlice$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.bytesMutPutFillChunked(buf.v, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.bytesMutPutFillChunked(buf.v, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.bytesMutPutFillChunked(buf.v, n2, 4294967295); + rs.bytesMutPutFillChunked(buf.v, n2, 4294967295); } } else if (_18 === 13) { - const src3 = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.bytesMutPutChunked(buf.v, src3); - rt.bytesDrop(src3); + const src3 = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.bytesMutPutChunked(buf.v, src3); + rs.bytesDrop(src3); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.bytesMutPutChunked(buf.v, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.bytesMutPutChunked(buf.v, _47); } else if (_18 === 15) { - const src2 = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.bytesMutPutChunked(buf.v, rt.bytesMutView(src2)); + const src2 = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.bytesMutPutChunked(buf.v, rs.bytesMutView(src2)); src2[Symbol.dispose](); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.bytesMutPutBytes(buf.v, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.bytesMutPutBytes(buf.v, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.bytesMutPutBytes(buf.v, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.bytesMutPutBytes(buf.v, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.bytesMutPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.bytesMutPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.bytesMutPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.bytesMutPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } else { - const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.bytesMutPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined); + const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.bytesMutPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(src); } - const _97: rt.u8 = rt.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_boxed_Box_bytes_BytesMut(buf), 7) & 0xff); + const _97: rs.u8 = rs.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_boxed_Box_bytes_BytesMut(buf), 7) & 0xff); putU8$bytes_BufMut_boxed_Box_bytes_BytesMut(buf, _97); } } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$bytes_BytesMut(buf: rt.BytesMut, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$bytes_BytesMut(buf: rs.BytesMut, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { - rt.bytesMutPutWord(buf, n2, 1, false); + rs.bytesMutPutWord(buf, n2, 1, false); } else if (_18 === 1) { - rt.bytesMutPutWord(buf, (n2 << 24) >> 24, 1, false); + rs.bytesMutPutWord(buf, (n2 << 24) >> 24, 1, false); } else if (_18 === 2) { - rt.bytesMutPutWord(buf, rt.u64Low(v) & 0xffff, 2, false); + rs.bytesMutPutWord(buf, rs.u64Low(v) & 0xffff, 2, false); } else if (_18 === 3) { - rt.bytesMutPutWord(buf, (rt.u64Low(v) << 16) >> 16, 2, true); + rs.bytesMutPutWord(buf, (rs.u64Low(v) << 16) >> 16, 2, true); } else if (_18 === 4) { - rt.bytesMutPutWord(buf, rt.u64Low(v), 4, false); + rs.bytesMutPutWord(buf, rs.u64Low(v), 4, false); } else if (_18 === 5) { - rt.bytesMutPutWord(buf, rt.u64Low(v) | 0, 4, true); + rs.bytesMutPutWord(buf, rs.u64Low(v) | 0, 4, true); } else if (_18 === 6) { - rt.bytesMutPutBytes(buf, rt.u64ToBeBytes(v), true); + rs.bytesMutPutBytes(buf, rs.u64ToBeBytes(v), true); } else if (_18 === 7) { - rt.bytesMutPutBytes(buf, rt.i64ToBeBytes(rt.i64Cast(v)), false); + rs.bytesMutPutBytes(buf, rs.i64ToBeBytes(rs.i64Cast(v)), false); } else if (_18 === 8) { - rt.bytesMutPutBytes(buf, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.bytesMutPutBytes(buf, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - rt.bytesMutExtend(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + rs.bytesMutExtend(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.bytesMutPutFill(buf, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.bytesMutPutFill(buf, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.bytesMutPutFill(buf, n2, 4294967295); + rs.bytesMutPutFill(buf, n2, 4294967295); } } else if (_18 === 13) { - const _44: rt.ByteSlice = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.bytesMutPutStorage(buf, _44); + const _44: rs.ByteSlice = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.bytesMutPutStorage(buf, _44); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.bytesMutPutSlice(buf, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.bytesMutPutSlice(buf, _47); } else if (_18 === 15) { - const _54: rt.BytesMut = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.bytesMutPutMut(buf, _54); + const _54: rs.BytesMut = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.bytesMutPutMut(buf, _54); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.bytesMutPutBytes(buf, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.bytesMutPutBytes(buf, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.bytesMutPutBytes(buf, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.bytesMutPutBytes(buf, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.bytesMutPutBuf(buf, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToBytes$bytes_Buf); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.bytesMutPutBuf(buf, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToBytes$bytes_Buf); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.bytesMutPutBuf(buf, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, (a0: Provided.Provided, a1: rt.usize): rt.ByteSlice => { - return rt.bufCopyToBytes(a0, a1, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.bytesMutPutBuf(buf, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, (a0: Provided.Provided, a1: rs.usize): rs.ByteSlice => { + return rs.bufCopyToBytes(a0, a1, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); }); } else { - const _84: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.bytesMutPutBuf(buf, _84, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined, Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8, lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8); + const _84: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.bytesMutPutBuf(buf, _84, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined, Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8, lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8); } - const _97: rt.u8 = rt.u8Add(buf.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_bytes_BytesMut(buf), 7) & 0xff); - rt.bytesMutPutWord(buf, _97, 1, false); + const _97: rs.u8 = rs.u8Add(buf.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_bytes_BytesMut(buf), 7) & 0xff); + rs.bytesMutPutWord(buf, _97, 1, false); } } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$mut_Vec_u8(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$mut_Vec_u8(buf: rs.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { putU8$bytes_BufMut_mut_Vec_u8(buf, n2); } else if (_18 === 1) { putI8$bytes_BufMut_mut_Vec_u8(buf, (n2 << 24) >> 24); } else if (_18 === 2) { - putU16$bytes_BufMut_mut_Vec_u8(buf, rt.u64Low(v) & 0xffff); + putU16$bytes_BufMut_mut_Vec_u8(buf, rs.u64Low(v) & 0xffff); } else if (_18 === 3) { - putI16Le$bytes_BufMut_mut_Vec_u8(buf, (rt.u64Low(v) << 16) >> 16); + putI16Le$bytes_BufMut_mut_Vec_u8(buf, (rs.u64Low(v) << 16) >> 16); } else if (_18 === 4) { - putU32$bytes_BufMut_mut_Vec_u8(buf, rt.u64Low(v)); + putU32$bytes_BufMut_mut_Vec_u8(buf, rs.u64Low(v)); } else if (_18 === 5) { - putI32Le$bytes_BufMut_mut_Vec_u8(buf, rt.u64Low(v) | 0); + putI32Le$bytes_BufMut_mut_Vec_u8(buf, rs.u64Low(v) | 0); } else if (_18 === 6) { putU64Le$bytes_BufMut_mut_Vec_u8(buf, v); } else if (_18 === 7) { - putI64$bytes_BufMut_mut_Vec_u8(buf, rt.i64Cast(v)); + putI64$bytes_BufMut_mut_Vec_u8(buf, rs.i64Cast(v)); } else if (_18 === 8) { - rt.byteVecPutBytes(buf.v, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.byteVecPutBytes(buf.v, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - putSlice$bytes_BufMut_mut_Vec_u8(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + putSlice$bytes_BufMut_mut_Vec_u8(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.byteVecPutFillChunked(buf.v, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.byteVecPutFillChunked(buf.v, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.byteVecPutFillChunked(buf.v, n2, 4294967295); + rs.byteVecPutFillChunked(buf.v, n2, 4294967295); } } else if (_18 === 13) { - const src3 = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.byteVecPutChunked(buf.v, src3); - rt.bytesDrop(src3); + const src3 = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.byteVecPutChunked(buf.v, src3); + rs.bytesDrop(src3); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.byteVecPutChunked(buf.v, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.byteVecPutChunked(buf.v, _47); } else if (_18 === 15) { - const src2 = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.byteVecPutChunked(buf.v, rt.bytesMutView(src2)); + const src2 = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.byteVecPutChunked(buf.v, rs.bytesMutView(src2)); src2[Symbol.dispose](); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.byteVecPutBytes(buf.v, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.byteVecPutBytes(buf.v, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.byteVecPutInt(buf.v, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.byteVecPutInt(buf.v, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.byteVecPutBytes(buf.v, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.byteVecPutBytes(buf.v, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.byteVecPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.byteVecPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.byteVecPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.byteVecPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } else { - const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.byteVecPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined); + const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.byteVecPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(src); } - const _97: rt.u8 = rt.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_mut_Vec_u8(buf), 7) & 0xff); + const _97: rs.u8 = rs.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_mut_Vec_u8(buf), 7) & 0xff); putU8$bytes_BufMut_mut_Vec_u8(buf, _97); } } /** A write by each pair of `data`'s bytes, one past what a vector holds included. */ -export function writeAll$mut_bytes_BytesMut(buf: rt.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { +export function writeAll$mut_bytes_BytesMut(buf: rs.Place, dataData: Uint8Array, dataStart: number, dataLen: number): void { let dataData2: Uint8Array = dataData; let dataStart2: number = dataStart; let dataLen2: number = dataLen; while (dataLen2 >= 2) { - const op: rt.u8 = dataData2[dataStart2]; - const n: rt.u8 = dataData2[dataStart2 + 1]; + const op: rs.u8 = dataData2[dataStart2]; + const n: rs.u8 = dataData2[dataStart2 + 1]; const restData: Uint8Array = dataData2; const restStart: number = dataStart2 + 2; const restLen: number = dataLen2 - 2; dataData2 = restData; dataStart2 = restStart; dataLen2 = restLen; - const op2: rt.u8 = op; - const n2: rt.u8 = n; - const v: rt.u64 = rt.u64Mul(n2 as rt.u64, { hi: 0x1010101, lo: 0x1010101 } as rt.u64); - const _18: rt.u8 = rt.u8Rem(op2, 23); + const op2: rs.u8 = op; + const n2: rs.u8 = n; + const v: rs.u64 = rs.u64Mul(n2 as rs.u64, { hi: 0x1010101, lo: 0x1010101 } as rs.u64); + const _18: rs.u8 = rs.u8Rem(op2, 23); if (_18 === 0) { putU8$bytes_BufMut_mut_bytes_BytesMut(buf, n2); } else if (_18 === 1) { putI8$bytes_BufMut_mut_bytes_BytesMut(buf, (n2 << 24) >> 24); } else if (_18 === 2) { - putU16$bytes_BufMut_mut_bytes_BytesMut(buf, rt.u64Low(v) & 0xffff); + putU16$bytes_BufMut_mut_bytes_BytesMut(buf, rs.u64Low(v) & 0xffff); } else if (_18 === 3) { - putI16Le$bytes_BufMut_mut_bytes_BytesMut(buf, (rt.u64Low(v) << 16) >> 16); + putI16Le$bytes_BufMut_mut_bytes_BytesMut(buf, (rs.u64Low(v) << 16) >> 16); } else if (_18 === 4) { - putU32$bytes_BufMut_mut_bytes_BytesMut(buf, rt.u64Low(v)); + putU32$bytes_BufMut_mut_bytes_BytesMut(buf, rs.u64Low(v)); } else if (_18 === 5) { - putI32Le$bytes_BufMut_mut_bytes_BytesMut(buf, rt.u64Low(v) | 0); + putI32Le$bytes_BufMut_mut_bytes_BytesMut(buf, rs.u64Low(v) | 0); } else if (_18 === 6) { putU64Le$bytes_BufMut_mut_bytes_BytesMut(buf, v); } else if (_18 === 7) { - putI64$bytes_BufMut_mut_bytes_BytesMut(buf, rt.i64Cast(v)); + putI64$bytes_BufMut_mut_bytes_BytesMut(buf, rs.i64Cast(v)); } else if (_18 === 8) { - rt.bytesMutPutBytes(buf.v, rt.u128ToBeBytes(rt.u128Shl(rt.u128Cast(v), 40)), true); + rs.bytesMutPutBytes(buf.v, rs.u128ToBeBytes(rs.u128Shl(rs.u128Cast(v), 40)), true); } else if (_18 === 9) { - const _30: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.u64ToBeBytes(v), _30, false); + const _30: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.u64ToBeBytes(v), _30, false); } else if (_18 === 10) { - const _33: rt.i64 = rt.i64Cast(v); - const _34: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.i64ToBeBytes(_33), _34, true); + const _33: rs.i64 = rs.i64Cast(v); + const _34: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.i64ToBeBytes(_33), _34, true); } else if (_18 === 11) { - putSlice$bytes_BufMut_mut_bytes_BytesMut(buf, rt.byteSliceFrom(Uint8Array.of(op2, n2))); + putSlice$bytes_BufMut_mut_bytes_BytesMut(buf, rs.byteSliceFrom(Uint8Array.of(op2, n2))); } else if (_18 === 12) { if (!(n2 === 255)) { - rt.bytesMutPutFillChunked(buf.v, n2, rt.usizeRem(n2 as rt.usize, 100)); + rs.bytesMutPutFillChunked(buf.v, n2, rs.usizeRem(n2 as rs.usize, 100)); } else { - rt.bytesMutPutFillChunked(buf.v, n2, 4294967295); + rs.bytesMutPutFillChunked(buf.v, n2, 4294967295); } } else if (_18 === 13) { - const src3 = rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(112, 117, 116))); - rt.bytesMutPutChunked(buf.v, src3); - rt.bytesDrop(src3); + const src3 = rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(112, 117, 116))); + rs.bytesMutPutChunked(buf.v, src3); + rs.bytesDrop(src3); } else if (_18 === 14) { - const _47: rt.ByteSlice = rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(70).fill(op2)), 0, rt.usizeRem(n2 as rt.usize, 71)); - rt.bytesMutPutChunked(buf.v, _47); + const _47: rs.ByteSlice = rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(70).fill(op2)), 0, rs.usizeRem(n2 as rs.usize, 71)); + rs.bytesMutPutChunked(buf.v, _47); } else if (_18 === 15) { - const src2 = rt.bytesMutFrom(rt.byteSliceRange(rt.byteSliceFrom(rt.bytes(3).fill(n2)), 0)); - rt.bytesMutPutChunked(buf.v, rt.bytesMutView(src2)); + const src2 = rs.bytesMutFrom(rs.byteSliceRange(rs.byteSliceFrom(rs.bytes(3).fill(n2)), 0)); + rs.bytesMutPutChunked(buf.v, rs.bytesMutView(src2)); src2[Symbol.dispose](); } else if (_18 === 16) { - const _58: rt.f32 = Math.fround(Math.fround(n2) / 3.0); - rt.bytesMutPutBytes(buf.v, rt.f32ToBeBytes(_58), false); + const _58: rs.f32 = Math.fround(Math.fround(n2) / 3.0); + rs.bytesMutPutBytes(buf.v, rs.f32ToBeBytes(_58), false); } else if (_18 === 17) { - const _60: rt.i64 = rt.i64Cast(v); - const _61: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.i64ToBeBytes(_60), _61, false); + const _60: rs.i64 = rs.i64Cast(v); + const _61: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.i64ToBeBytes(_60), _61, false); } else if (_18 === 18) { - const _64: rt.usize = rt.usizeRem(n2 as rt.usize, 10); - rt.bytesMutPutInt(buf.v, rt.u64ToBeBytes(v), _64, true); + const _64: rs.usize = rs.usizeRem(n2 as rs.usize, 10); + rs.bytesMutPutInt(buf.v, rs.u64ToBeBytes(v), _64, true); } else if (_18 === 19) { - rt.bytesMutPutBytes(buf.v, rt.f64ToBeBytes((n2 as rt.f64) / 3.0), false); + rs.bytesMutPutBytes(buf.v, rs.f64ToBeBytes((n2 as rs.f64) / 3.0), false); } else if (_18 === 20) { - const _70: rt.ByteSlice = rt.byteSliceFrom(Uint8Array.of(op2, n2, op2)); - const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rt.usizeRem(n2 as rt.usize, 4)); - rt.bytesMutPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined); + const _70: rs.ByteSlice = rs.byteSliceFrom(Uint8Array.of(op2, n2, op2)); + const _69: Pieces.Pieces = Pieces.new(_70.data, _70.start, _70.length, rs.usizeRem(n2 as rs.usize, 4)); + rs.bytesMutPutBufChunked(buf.v, _69, Pieces.hasRemaining$bytes_Buf, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined); } else if (_18 === 21) { - const _78: rt.ByteSlice = rt.byteSliceFrom(rt.bytes(5).fill(n2)); - const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rt.usizeRem(n2 as rt.usize, 6)) }; - rt.bytesMutPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + const _78: rs.ByteSlice = rs.byteSliceFrom(rs.bytes(5).fill(n2)); + const _76: Provided.Provided = { _0: Pieces.new(_78.data, _78.start, _78.length, rs.usizeRem(n2 as rs.usize, 6)) }; + rs.bytesMutPutBufChunked(buf.v, _76, Provided.hasRemaining$bytes_Buf, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } else { - const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(rt.byteSliceFrom(rt.bytes(2).fill(n2))), rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(op2)), 0, rt.usizeRem(n2 as rt.usize, 2))); - rt.bytesMutPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rt.usize) => undefined); + const src = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(rs.byteSliceFrom(rs.bytes(2).fill(n2))), rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(op2)), 0, rs.usizeRem(n2 as rs.usize, 2))); + rs.bytesMutPutBufChunked(buf.v, src, Chain.hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, a1: rs.usize) => undefined); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(src); } - const _97: rt.u8 = rt.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rt.usizeRem(remainingMut$bytes_BufMut_mut_mut_bytes_BytesMut(buf), 7) & 0xff); + const _97: rs.u8 = rs.u8Add(buf.v.length < 0x7fffffff ? 1 : 0, rs.usizeRem(remainingMut$bytes_BufMut_mut_mut_bytes_BytesMut(buf), 7) & 0xff); putU8$bytes_BufMut_mut_bytes_BytesMut(buf, _97); } } @@ -3505,50 +3505,50 @@ export function writeAll$mut_bytes_BytesMut(buf: rt.Place, dataData * part is the last handle of the storage: a promotable `Bytes` truncated to nothing gives * it up, none of its clones is promotable, and a `Bytes` of what it lends holds none. */ -export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let part!: rt.ByteSlice; +export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let part!: rs.ByteSlice; if (dataLen >= 2) { - let bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2)); - const a: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 2, 2)); - const _17: rt.u8 = rt.u8Rem(dataData[dataStart], 9); + let bytes: rs.ByteSlice = rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2)); + const a: rs.usize = rs.usizeRem(dataData[dataStart + 1] as rs.usize, rs.usizeAdd(dataLen - 2, 2)); + const _17: rs.u8 = rs.u8Rem(dataData[dataStart], 9); if (_17 === 0) { - part = rt.bytesSplitTo(rt.place(() => bytes, (value8) => bytes = value8), a); + part = rs.bytesSplitTo(rs.place(() => bytes, (value8) => bytes = value8), a); } else if (_17 === 1) { - part = rt.bytesSplitOff(rt.place(() => bytes, (value7) => bytes = value7), a); + part = rs.bytesSplitOff(rs.place(() => bytes, (value7) => bytes = value7), a); } else if (_17 === 2) { - rt.bytesTruncate(rt.place(() => bytes, (value6) => bytes = value6), a); - part = rt.bytesClone(bytes); + rs.bytesTruncate(rs.place(() => bytes, (value6) => bytes = value6), a); + part = rs.bytesClone(bytes); } else if (_17 === 3) { - rt.bytesTruncate(rt.place(() => bytes, (value5) => bytes = value5), 0); - part = rt.bytesNew(); + rs.bytesTruncate(rs.place(() => bytes, (value5) => bytes = value5), 0); + part = rs.bytesNew(); } else if (_17 === 4) { - const sub: rt.ByteSlice = rt.byteSliceRange(bytes, rt.min(a, dataLen - 2)); - part = rt.bytesSliceRef(bytes, sub); + const sub: rs.ByteSlice = rs.byteSliceRange(bytes, rs.min(a, dataLen - 2)); + part = rs.bytesSliceRef(bytes, sub); } else if (_17 === 5) { - rt.bytesAdvance(rt.place(() => bytes, (value3) => bytes = value3), a); - const _35: rt.usize = rt.usizeDiv(a, 2); - part = rt.bytesSplitTo(rt.place(() => bytes, (value4) => bytes = value4), _35); + rs.bytesAdvance(rs.place(() => bytes, (value3) => bytes = value3), a); + const _35: rs.usize = rs.usizeDiv(a, 2); + part = rs.bytesSplitTo(rs.place(() => bytes, (value4) => bytes = value4), _35); } else if (_17 === 6) { - let clone: rt.ByteSlice = rt.bytesClone(bytes); - rt.bytesTruncate(rt.place(() => clone, (value2) => clone = value2), a); + let clone: rs.ByteSlice = rs.bytesClone(bytes); + rs.bytesTruncate(rs.place(() => clone, (value2) => clone = value2), a); part = clone; } else if (_17 === 7) { - const clone2: rt.ByteSlice = rt.bytesClone(bytes); - rt.bytesTruncate(rt.place(() => bytes, (value) => bytes = value), a); + const clone2: rs.ByteSlice = rs.bytesClone(bytes); + rs.bytesTruncate(rs.place(() => bytes, (value) => bytes = value), a); part = clone2; } else { - const _46: rt.Place = { v: rt.bytesClone(bytes) }; - rt.bytesDrop(rt.bytesStatic(_46.v)); - rt.bytesDrop(rt.bytesStatic(rt.byteSliceRange(_46.v, 0))); - part = rt.bytesStatic(_46.v); + const _46: rs.Place = { v: rs.bytesClone(bytes) }; + rs.bytesDrop(rs.bytesStatic(_46.v)); + rs.bytesDrop(rs.bytesStatic(rs.byteSliceRange(_46.v, 0))); + part = rs.bytesStatic(_46.v); } - const _65: boolean = rt.bytesIsUnique(part); - const _68: boolean = rt.bytesIsUnique(bytes); - const _70: rt.ByteSlice = part; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(_70, f), (f: rt.Formatter) => rt.bytesDebug(bytes, f), (f: rt.Formatter) => rt.fmtBool(_65, f), (f: rt.Formatter) => rt.fmtBool(_68, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]))); - rt.bytesDrop(part); - rt.bytesDrop(bytes); + const _65: boolean = rs.bytesIsUnique(part); + const _68: boolean = rs.bytesIsUnique(bytes); + const _70: rs.ByteSlice = part; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(_70, f), (f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.fmtBool(_65, f), (f: rs.Formatter) => rs.fmtBool(_68, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0], " ", args2[1], " ", args2[2], " ", args2[3]]))); + rs.bytesDrop(part); + rs.bytesDrop(bytes); } } @@ -3557,60 +3557,60 @@ export function edits(dataData: Uint8Array, dataStart: number, dataLen: number, * length picked about where the first half ends, which takes from either half or copies * across both, then the reads of `reads` across them. */ -export function chains(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let rest!: rt.ByteVec; +export function chains(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let rest!: rs.ByteVec; if (dataLen >= 3) { - const mid: number = rt.usizeDiv(dataLen - 3, 2); + const mid: number = rs.usizeDiv(dataLen - 3, 2); if (mid > dataLen - 3) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const cut: rt.usize = rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 3 - mid, 1)); + const cut: rs.usize = rs.usizeRem(dataData[dataStart + 1] as rs.usize, rs.usizeAdd(dataLen - 3 - mid, 1)); if (cut > dataLen - 3 - mid) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const mid2: number = rt.usizeDiv(dataLen - 3 - mid - cut, 2); + const mid2: number = rs.usizeDiv(dataLen - 3 - mid - cut, 2); if (mid2 > dataLen - 3 - mid - cut) { - rt.panic("mid > len"); + rs.panic("mid > len"); } - const at: rt.usize[] = [cut, rt.usizeAdd(cut, mid2)]; - const _38: rt.u8 = rt.u8Rem(dataData[dataStart], 9); + const at: rs.usize[] = [cut, rs.usizeAdd(cut, mid2)]; + const _38: rs.u8 = rs.u8Rem(dataData[dataStart], 9); if (_38 === 0) { - const _40: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid, cut)), new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut)); - rest = chained$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(at, _40, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _40: Chain.Chain = chain$bytes_Buf_bytes_Bytes_ref_slice_u8(rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid, cut)), new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut)); + rest = chained$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(at, _40, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); lib_drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(_40); } else if (_38 === 1) { - const _43: Chain.Chain = chain$bytes_Buf_ref_slice_u8_bytes_BytesMut(new rt.ByteSlice(dataData, dataStart + 3 + mid, cut), rt.bytesMutFrom(new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut))); - rest = chained$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(at, _43, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _43: Chain.Chain = chain$bytes_Buf_ref_slice_u8_bytes_BytesMut(new rs.ByteSlice(dataData, dataStart + 3 + mid, cut), rs.bytesMutFrom(new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut))); + rest = chained$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(at, _43, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); _43[Symbol.dispose](); } else if (_38 === 2) { - rest = chained$bytes_buf_Chain_buf_Pieces_buf_Provided(at, Pieces.chain$bytes_Buf_buf_Provided(Pieces.new(dataData, dataStart + 3 + mid, cut, rt.usizeDiv(cut, 2)), { _0: Pieces.new(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut, 1) }), dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + rest = chained$bytes_buf_Chain_buf_Pieces_buf_Provided(at, Pieces.chain$bytes_Buf_buf_Provided(Pieces.new(dataData, dataStart + 3 + mid, cut, rs.usizeDiv(cut, 2)), { _0: Pieces.new(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut, 1) }), dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); } else if (_38 === 3) { - const _54: Chain.Chain = Provided.chain$bytes_Buf_bytes_Bytes({ _0: Pieces.new(dataData, dataStart + 3 + mid, cut, 1) }, rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut))); - rest = chained$bytes_buf_Chain_buf_Provided_bytes_Bytes(at, _54, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _54: Chain.Chain = Provided.chain$bytes_Buf_bytes_Bytes({ _0: Pieces.new(dataData, dataStart + 3 + mid, cut, 1) }, rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut))); + rest = chained$bytes_buf_Chain_buf_Provided_bytes_Bytes(at, _54, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); lib_drop$bytes_buf_Chain_buf_Provided_bytes_Bytes(_54); } else if (_38 === 4) { - const _59: Chain.Chain, Pieces.Pieces> = Take.chain$bytes_Buf_bytes_Bytes_buf_Pieces(buf_impl_take$bytes_Buf_bytes_Bytes(rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid, dataLen - 3 - mid)), cut), Pieces.new(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut, 0)); - rest = chained$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(at, _59, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _59: Chain.Chain, Pieces.Pieces> = Take.chain$bytes_Buf_bytes_Bytes_buf_Pieces(buf_impl_take$bytes_Buf_bytes_Bytes(rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid, dataLen - 3 - mid)), cut), Pieces.new(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut, 0)); + rest = chained$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(at, _59, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); lib_drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(_59); } else if (_38 === 5) { - const _64: Chain.Chain, Pieces.Pieces> = Chain.chain$bytes_Buf_ref_slice_u8_bytes_Bytes_buf_Pieces(chain$bytes_Buf_ref_slice_u8_bytes_Bytes(new rt.ByteSlice(dataData, dataStart + 3 + mid, cut), rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, mid2))), Pieces.new(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2, 1)); - rest = chained$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(at, _64, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _64: Chain.Chain, Pieces.Pieces> = Chain.chain$bytes_Buf_ref_slice_u8_bytes_Bytes_buf_Pieces(chain$bytes_Buf_ref_slice_u8_bytes_Bytes(new rs.ByteSlice(dataData, dataStart + 3 + mid, cut), rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, mid2))), Pieces.new(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2, 1)); + rest = chained$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(at, _64, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); lib_drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(_64); } else if (_38 === 6) { - const _69: Chain.Chain> = chain$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid, cut)), Provided.chain$bytes_Buf_ref_slice_u8({ _0: Pieces.new(dataData, dataStart + 3 + mid + cut, mid2, 0) }, new rt.ByteSlice(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2))); - rest = chained$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(at, _69, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); + const _69: Chain.Chain> = chain$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid, cut)), Provided.chain$bytes_Buf_ref_slice_u8({ _0: Pieces.new(dataData, dataStart + 3 + mid + cut, mid2, 0) }, new rs.ByteSlice(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2))); + rest = chained$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(at, _69, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); lib_drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(_69); } else if (_38 === 7) { - const chain: Buf.Buf = new of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(Chain.chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(new of$buf_Pieces(Pieces.new(dataData, dataStart + 3 + mid, cut, 1)), rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, mid2))), new rt.ByteSlice(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2))); - rest = chained$dyn_bytes_Buf(at, chain, dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); - rt.drop(chain); + const chain: Buf.Buf = new of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(Chain.chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(new of$buf_Pieces(Pieces.new(dataData, dataStart + 3 + mid, cut, 1)), rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, mid2))), new rs.ByteSlice(dataData, dataStart + 3 + mid + cut + mid2, dataLen - 3 - mid - cut - mid2))); + rest = chained$dyn_bytes_Buf(at, chain, dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); + rs.drop(chain); } else { - let last: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut); - const rest2: rt.ByteVec = chained$dyn_bytes_Buf(at, new of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8(Provided.chain$bytes_Buf_mut_ref_slice_u8({ _0: Pieces.new(dataData, dataStart + 3 + mid, cut, 0) }, rt.place(() => last, (value) => last = value))), dataData[dataStart + 2], new rt.ByteSlice(dataData, dataStart + 3, mid), out); - rt.byteVecPush(out, last.length & 0xff); + let last: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 3 + mid + cut, dataLen - 3 - mid - cut); + const rest2: rs.ByteVec = chained$dyn_bytes_Buf(at, new of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8(Provided.chain$bytes_Buf_mut_ref_slice_u8({ _0: Pieces.new(dataData, dataStart + 3 + mid, cut, 0) }, rs.place(() => last, (value) => last = value))), dataData[dataStart + 2], new rs.ByteSlice(dataData, dataStart + 3, mid), out); + rs.byteVecPush(out, last.length & 0xff); rest = rest2; } - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rest)); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rest)); } } @@ -3618,30 +3618,30 @@ export function chains(dataData: Uint8Array, dataStart: number, dataLen: number, * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_buf_Pieces_buf_Provided(at: rt.usize[], buf: Chain.Chain, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_buf_Pieces_buf_Provided(at: rs.usize[], buf: Chain.Chain, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_buf_Pieces_buf_Provided(buf, ops, out); } @@ -3649,30 +3649,30 @@ export function chained$bytes_buf_Chain_buf_Pieces_buf_Provided(at: rt.usize[], * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_buf_Provided_bytes_Bytes(at: rt.usize[], buf: Chain.Chain, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_buf_Provided_bytes_Bytes(at: rs.usize[], buf: Chain.Chain, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_buf_Provided_bytes_Bytes(buf, ops, out); } @@ -3680,30 +3680,30 @@ export function chained$bytes_buf_Chain_buf_Provided_bytes_Bytes(at: rt.usize[], * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(at: rt.usize[], buf: Chain.Chain>, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(at: rs.usize[], buf: Chain.Chain>, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(buf, ops, out); } @@ -3711,30 +3711,30 @@ export function chained$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(at: rt.usize[], buf: Chain.Chain, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(at: rs.usize[], buf: Chain.Chain, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(buf, ops, out); } @@ -3742,30 +3742,30 @@ export function chained$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(at: rt.usize[], * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(at: rt.usize[], buf: Chain.Chain, Pieces.Pieces>, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(at: rs.usize[], buf: Chain.Chain, Pieces.Pieces>, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(buf, ops, out); } @@ -3773,30 +3773,30 @@ export function chained$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(at: rt.usize[], buf: Chain.Chain, Pieces.Pieces>, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(at: rs.usize[], buf: Chain.Chain, Pieces.Pieces>, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(buf, ops, out); } @@ -3804,30 +3804,30 @@ export function chained$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(at * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(at: rt.usize[], buf: Chain.Chain, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(at: rs.usize[], buf: Chain.Chain, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = Chain.remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(buf, len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(buf, ops, out); } @@ -3835,30 +3835,30 @@ export function chained$bytes_buf_Chain_ref_slice_u8_bytes_BytesMut(at: rt.usize * `copy_to_bytes` of a length by `pick`: where a half ends by `at`, one more or less, all * of it, one past it, which panics, or any, then `read_all` of the rest. */ -export function chained$dyn_bytes_Buf(at: rt.usize[], buf: Buf.Buf, pick: rt.u8, ops: rt.ByteSlice, out: rt.ByteVec): rt.ByteVec { - let len!: rt.usize; - const all: rt.usize = remaining$bytes_Buf_mut_dyn_bytes_Buf(buf); - const _9: rt.u8 = rt.u8Rem(pick, 8); +export function chained$dyn_bytes_Buf(at: rs.usize[], buf: Buf.Buf, pick: rs.u8, ops: rs.ByteSlice, out: rs.ByteVec): rs.ByteVec { + let len!: rs.usize; + const all: rs.usize = remaining$bytes_Buf_mut_dyn_bytes_Buf(buf); + const _9: rs.u8 = rs.u8Rem(pick, 8); if (_9 === 0) { len = at[0]; } else if (_9 === 1) { - len = rt.usizeAdd(at[0], 1); + len = rs.usizeAdd(at[0], 1); } else if (_9 === 2) { - len = rt.usizeSaturatingSub(at[0], 1); + len = rs.usizeSaturatingSub(at[0], 1); } else if (_9 === 3) { len = at[1]; } else if (_9 === 4) { - len = rt.usizeAdd(at[1], 1); + len = rs.usizeAdd(at[1], 1); } else if (_9 === 5) { len = all; } else if (_9 === 6) { - len = rt.usizeAdd(all, 1); + len = rs.usizeAdd(all, 1); } else { - len = rt.usizeRem(rt.u8Div(pick, 8) as rt.usize, rt.usizeAdd(all, 2)); + len = rs.usizeRem(rs.u8Div(pick, 8) as rs.usize, rs.usizeAdd(all, 2)); } - const _34: rt.ByteSlice = buf.copyToBytes$Buf(len); - rt.byteVecExtendFromSlice(out, _34); - rt.bytesDrop(_34); + const _34: rs.ByteSlice = buf.copyToBytes$Buf(len); + rs.byteVecExtendFromSlice(out, _34); + rs.bytesDrop(_34); return readAll$dyn_bytes_Buf(buf, ops, out); } diff --git a/ts/fixtures/stock/expected/bytes.TryGetError.ts b/ts/fixtures/stock/expected/bytes.TryGetError.ts index 4b6b5f3b8..f049245dc 100644 --- a/ts/fixtures/stock/expected/bytes.TryGetError.ts +++ b/ts/fixtures/stock/expected/bytes.TryGetError.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Error type for the `try_get_` methods of [`Buf`]. @@ -11,9 +11,9 @@ import * as rt from "./rt.ts"; */ export interface TryGetError { /** The number of bytes necessary to get the value */ - requested: rt.usize; + requested: rs.usize; /** The number of bytes available in the buffer */ - available: rt.usize; + available: rs.usize; } //# sourceMappingURL=bytes.TryGetError.ts.map diff --git a/ts/fixtures/stock/expected/bytes.ts b/ts/fixtures/stock/expected/bytes.ts index 26d89855f..89771c58a 100644 --- a/ts/fixtures/stock/expected/bytes.ts +++ b/ts/fixtures/stock/expected/bytes.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as TryGetError from "./bytes.TryGetError.ts"; export function panicAdvance(errorInfo: TryGetError.TryGetError): never { const arg = errorInfo.available; - const _8: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(arg, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = errorInfo.requested; - const args2: rt.Fmt[] = [_8, (f: rt.Formatter) => rt.usizeDisplay(arg2, f)]; - rt.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]]); + const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["advance out of bounds: the len is ", args2[0], " but advancing by ", args2[1]]); } -export function panicDoesNotFit(size: rt.usize, nbytes: rt.usize): never { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(size, f), (f: rt.Formatter) => rt.usizeDisplay(nbytes, f)]; - rt.panicFmt(["size too large: the integer type can fit ", args2[0], " bytes, but nbytes is ", args2[1]]); +export function panicDoesNotFit(size: rs.usize, nbytes: rs.usize): never { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(size, f), (f: rs.Formatter) => rs.usizeDisplay(nbytes, f)]; + rs.panicFmt(["size too large: the integer type can fit ", args2[0], " bytes, but nbytes is ", args2[1]]); } //# sourceMappingURL=bytes.ts.map diff --git a/ts/fixtures/stock/expected/bytes/buf/buf_impl.Buf.ts b/ts/fixtures/stock/expected/bytes/buf/buf_impl.Buf.ts index 724e36c22..3a010cfb3 100644 --- a/ts/fixtures/stock/expected/bytes/buf/buf_impl.Buf.ts +++ b/ts/fixtures/stock/expected/bytes/buf/buf_impl.Buf.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import type * as TryGetError from "../../bytes.TryGetError.ts"; /** @@ -30,6 +30,6 @@ import type * as TryGetError from "../../bytes.TryGetError.ts"; * ``` */ export type Buf = - | { remaining$Buf: () => rt.usize; chunk$Buf: () => rt.ByteSlice; advance$Buf: (a0: rt.usize) => void; hasRemaining$Buf: () => boolean; copyToSlice$Buf: (a0: rt.ByteSlice) => void; getU8$Buf: () => rt.u8; getI8$Buf: () => rt.i8; getU16$Buf: () => rt.u16; getI16Le$Buf: () => rt.i16; getI16Ne$Buf: () => rt.i16; getU32Le$Buf: () => rt.u32; getI32$Buf: () => rt.i32; getU64$Buf: () => rt.u64; getI64Le$Buf: () => rt.i64; getU128Le$Buf: () => rt.u128; getI128$Buf: () => rt.i128; getUint$Buf: (a0: rt.usize) => rt.u64; getIntLe$Buf: (a0: rt.usize) => rt.i64; getF32Le$Buf: () => rt.f32; getF64$Buf: () => rt.f64; tryGetU8$Buf: () => rt.Result; tryGetU16$Buf: () => rt.Result; tryGetI64Le$Buf: () => rt.Result; tryGetU128$Buf: () => rt.Result; copyToBytes$Buf: (a0: rt.usize) => rt.ByteSlice }; + | { remaining$Buf: () => rs.usize; chunk$Buf: () => rs.ByteSlice; advance$Buf: (a0: rs.usize) => void; hasRemaining$Buf: () => boolean; copyToSlice$Buf: (a0: rs.ByteSlice) => void; getU8$Buf: () => rs.u8; getI8$Buf: () => rs.i8; getU16$Buf: () => rs.u16; getI16Le$Buf: () => rs.i16; getI16Ne$Buf: () => rs.i16; getU32Le$Buf: () => rs.u32; getI32$Buf: () => rs.i32; getU64$Buf: () => rs.u64; getI64Le$Buf: () => rs.i64; getU128Le$Buf: () => rs.u128; getI128$Buf: () => rs.i128; getUint$Buf: (a0: rs.usize) => rs.u64; getIntLe$Buf: (a0: rs.usize) => rs.i64; getF32Le$Buf: () => rs.f32; getF64$Buf: () => rs.f64; tryGetU8$Buf: () => rs.Result; tryGetU16$Buf: () => rs.Result; tryGetI64Le$Buf: () => rs.Result; tryGetU128$Buf: () => rs.Result; copyToBytes$Buf: (a0: rs.usize) => rs.ByteSlice }; //# sourceMappingURL=buf_impl.Buf.ts.map diff --git a/ts/fixtures/stock/expected/bytes/buf/buf_impl.ts b/ts/fixtures/stock/expected/bytes/buf/buf_impl.ts index 905c65c8b..e6d0be100 100644 --- a/ts/fixtures/stock/expected/bytes/buf/buf_impl.ts +++ b/ts/fixtures/stock/expected/bytes/buf/buf_impl.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import { out$i64, out$u128, out$u16, out$u8 } from "../../lib.ts"; import type * as Leased from "../../buf.Leased.ts"; import type * as Provided from "../../buf.Provided.ts"; @@ -10,10 +10,10 @@ import { new_$bytes_Bytes as take_new_$bytes_Bytes, new_$mut_bytes_Bytes as take import type * as Take from "../../bytes/buf/take.Take.ts"; import type * as TryGetError from "../../bytes.TryGetError.ts"; -export function signExtend(val: rt.u64, nbytes: rt.usize): rt.i64 { +export function signExtend(val: rs.u64, nbytes: rs.usize): rs.i64 { if (!(nbytes === 0)) { - const shift: rt.usize = rt.usizeMul(rt.usizeSub(8, nbytes), 8); - return rt.i64Shr(rt.i64Cast(rt.u64Shl(val, shift)), shift); + const shift: rs.usize = rs.usizeMul(rs.usizeSub(8, nbytes), 8); + return rs.i64Shr(rs.i64Cast(rs.u64Shl(val, shift)), shift); } return 0; } @@ -43,12 +43,12 @@ export function signExtend(val: rt.u64, nbytes: rt.usize): rt.i64 { * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_Bytes(self: rt.Place): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_Bytes(self: rs.Place): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut_bytes_Bytes(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut_bytes_Bytes(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; - rt.bytesAdvance(self, 1); + const _9: rs.ByteSlice = chunk$bytes_Buf_mut_bytes_Bytes(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; + rs.bytesAdvance(self, 1); return ret; } out$u8.err = { requested: 1, available: remaining$bytes_Buf_mut_bytes_Bytes(self) }; @@ -80,12 +80,12 @@ export function tryGetU8$bytes_Buf_bytes_Bytes(self: rt.Place): rt * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_BytesMut(self: rt.BytesMut): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_BytesMut(self: rs.BytesMut): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut_bytes_BytesMut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut_bytes_BytesMut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; - rt.bytesMutAdvance(self, 1); + const _9: rs.ByteSlice = chunk$bytes_Buf_mut_bytes_BytesMut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; + rs.bytesMutAdvance(self, 1); return ret; } out$u8.err = { requested: 1, available: remaining$bytes_Buf_mut_bytes_BytesMut(self) }; @@ -117,12 +117,12 @@ export function tryGetU8$bytes_Buf_bytes_BytesMut(self: rt.BytesMut): rt.u8 | un * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_ref_slice_u8(self: rt.Place): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_ref_slice_u8(self: rs.Place): rs.u8 | undefined { if (!(remaining$bytes_Buf_mut_ref_slice_u8(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_mut_ref_slice_u8(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; - rt.byteSliceAdvance(self, 1); + const _9: rs.ByteSlice = chunk$bytes_Buf_mut_ref_slice_u8(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; + rs.byteSliceAdvance(self, 1); return ret; } out$u8.err = { requested: 1, available: remaining$bytes_Buf_mut_ref_slice_u8(self) }; @@ -152,7 +152,7 @@ export function tryGetU8$bytes_Buf_ref_slice_u8(self: rt.Place): r * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_bytes_Bytes(self: rt.ByteSlice, limit: rt.usize): Take.Take { +export function take$bytes_Buf_bytes_Bytes(self: rs.ByteSlice, limit: rs.usize): Take.Take { return take_new_$bytes_Bytes(self, limit); } @@ -179,7 +179,7 @@ export function take$bytes_Buf_bytes_Bytes(self: rt.ByteSlice, limit: rt.usize): * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_mut_bytes_Bytes(self: rt.Place, limit: rt.usize): Take.Take> { +export function take$bytes_Buf_mut_bytes_Bytes(self: rs.Place, limit: rs.usize): Take.Take> { return take_new_$mut_bytes_Bytes(self, limit); } @@ -206,7 +206,7 @@ export function take$bytes_Buf_mut_bytes_Bytes(self: rt.Place, lim * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut, limit: rt.usize): Take.Take { +export function take$bytes_Buf_mut_bytes_BytesMut(self: rs.BytesMut, limit: rs.usize): Take.Take { return take_new_$mut_bytes_BytesMut(self, limit); } @@ -233,7 +233,7 @@ export function take$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut, limit: rt.u * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place>, limit: rt.usize): Take.Take>> { +export function take$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>, limit: rs.usize): Take.Take>> { return take_new_$mut_mut_ref_slice_u8(self, limit); } @@ -260,7 +260,7 @@ export function take$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place, limit: rt.usize): Take.Take> { +export function take$bytes_Buf_mut_ref_slice_u8(self: rs.Place, limit: rs.usize): Take.Take> { return take_new_$mut_ref_slice_u8(self, limit); } @@ -287,7 +287,7 @@ export function take$bytes_Buf_mut_ref_slice_u8(self: rt.Place, li * assert_eq!(dst, b" world"); * ``` */ -export function take$bytes_Buf_ref_slice_u8(self: rt.ByteSlice, limit: rt.usize): Take.Take { +export function take$bytes_Buf_ref_slice_u8(self: rs.ByteSlice, limit: rs.usize): Take.Take { return take_new_$ref_slice_u8(self, limit); } @@ -308,7 +308,7 @@ export function take$bytes_Buf_ref_slice_u8(self: rt.ByteSlice, limit: rt.usize) * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Buf.Buf, next: rt.ByteSlice): Chain.Chain { +export function chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Buf.Buf, next: rs.ByteSlice): Chain.Chain { return Chain.new$boxed_Box_dyn_bytes_Buf_bytes_Bytes(self, next); } @@ -329,7 +329,7 @@ export function chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Buf.Bu * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: rt.ByteSlice, next: Chain.Chain): Chain.Chain> { +export function chain$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: rs.ByteSlice, next: Chain.Chain): Chain.Chain> { return Chain.new$bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, next); } @@ -350,7 +350,7 @@ export function chain$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sli * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_bytes_Bytes_ref_slice_u8(self: rt.ByteSlice, next: rt.ByteSlice): Chain.Chain { +export function chain$bytes_Buf_bytes_Bytes_ref_slice_u8(self: rs.ByteSlice, next: rs.ByteSlice): Chain.Chain { return Chain.new$bytes_Bytes_ref_slice_u8(self, next); } @@ -371,7 +371,7 @@ export function chain$bytes_Buf_bytes_Bytes_ref_slice_u8(self: rt.ByteSlice, nex * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes(self: rt.ByteSlice, next: rt.ByteSlice): Chain.Chain { +export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes(self: rs.ByteSlice, next: rs.ByteSlice): Chain.Chain { return Chain.new$ref_slice_u8_bytes_Bytes(self, next); } @@ -392,7 +392,7 @@ export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes(self: rt.ByteSlice, nex * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: rt.ByteSlice, next: rt.BytesMut): Chain.Chain { +export function chain$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: rs.ByteSlice, next: rs.BytesMut): Chain.Chain { return Chain.new$ref_slice_u8_bytes_BytesMut(self, next); } @@ -428,7 +428,7 @@ export function chain$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: rt.ByteSlice, * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rs.Place>, cnt: rs.usize): void { advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.v, cnt); } @@ -464,8 +464,8 @@ export function advance$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place>, cnt: rt.usize): void { - rt.bytesAdvance(self.v, cnt); +export function advance$bytes_Buf_mut_bytes_Bytes(self: rs.Place>, cnt: rs.usize): void { + rs.bytesAdvance(self.v, cnt); } /** @@ -500,8 +500,8 @@ export function advance$bytes_Buf_mut_bytes_Bytes(self: rt.Place, cnt: rt.usize): void { - rt.bytesMutAdvance(self.v, cnt); +export function advance$bytes_Buf_mut_bytes_BytesMut(self: rs.Place, cnt: rs.usize): void { + rs.bytesMutAdvance(self.v, cnt); } /** @@ -536,7 +536,7 @@ export function advance$bytes_Buf_mut_bytes_BytesMut(self: rt.Place * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place, cnt: rs.usize): void { self.v.advance$Buf(cnt); } @@ -572,7 +572,7 @@ export function advance$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, cnt * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place>>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>>, cnt: rs.usize): void { advance$bytes_Buf_mut_ref_slice_u8(self.v, cnt); } @@ -608,8 +608,8 @@ export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place>, cnt: rt.usize): void { - rt.byteSliceAdvance(self.v, cnt); +export function advance$bytes_Buf_mut_ref_slice_u8(self: rs.Place>, cnt: rs.usize): void { + rs.byteSliceAdvance(self.v, cnt); } /** @@ -642,7 +642,7 @@ export function advance$bytes_Buf_mut_ref_slice_u8(self: rt.Place): rt.ByteSlice { +export function chunk$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.ByteSlice { return chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.v); } @@ -676,7 +676,7 @@ export function chunk$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.ByteSlice { +export function chunk$bytes_Buf_mut_bytes_Bytes(self: rs.Place): rs.ByteSlice { return self.v; } @@ -710,8 +710,8 @@ export function chunk$bytes_Buf_mut_bytes_Bytes(self: rt.Place): r * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut): rt.ByteSlice { - return rt.bytesMutView(self); +export function chunk$bytes_Buf_mut_bytes_BytesMut(self: rs.BytesMut): rs.ByteSlice { + return rs.bytesMutView(self); } /** @@ -744,7 +744,7 @@ export function chunk$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut): rt.ByteSl * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place>): rt.ByteSlice { +export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>): rs.ByteSlice { return chunk$bytes_Buf_mut_ref_slice_u8(self.v); } @@ -778,7 +778,7 @@ export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place): rt.ByteSlice { +export function chunk$bytes_Buf_mut_ref_slice_u8(self: rs.Place): rs.ByteSlice { return self.v; } @@ -803,7 +803,7 @@ export function chunk$bytes_Buf_mut_ref_slice_u8(self: rt.Place): * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rs.Place>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.v, len); } @@ -828,8 +828,8 @@ export function copyToBytes$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: rt.Place>, len: rt.usize): rt.ByteSlice { - return rt.bytesSplitTo(self.v, len); +export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: rs.Place>, len: rs.usize): rs.ByteSlice { + return rs.bytesSplitTo(self.v, len); } /** @@ -853,8 +853,8 @@ export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: rt.Place self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: rt.Place, len: rt.usize): rt.ByteSlice { - return rt.bytesMutFreeze(rt.bytesMutSplitTo(self.v, len)); +export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: rs.Place, len: rs.usize): rs.ByteSlice { + return rs.bytesMutFreeze(rs.bytesMutSplitTo(self.v, len)); } /** @@ -878,7 +878,7 @@ export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: rt.Place self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place, len: rs.usize): rs.ByteSlice { return self.v.copyToBytes$Buf(len); } @@ -903,7 +903,7 @@ export function copyToBytes$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place>>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_mut_ref_slice_u8(self.v, len); } @@ -928,8 +928,8 @@ export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, len: rt.usize): rt.ByteSlice { - return rt.byteSliceCopyToBytes(self.v, len); +export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: rs.Place>, len: rs.usize): rs.ByteSlice { + return rs.byteSliceCopyToBytes(self.v, len); } /** @@ -955,8 +955,8 @@ export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, dst: rt.ByteSlice): void { - rt.bytesCopyToSlice(self.v, dst); +export function copyToSlice$bytes_Buf_mut_bytes_Bytes(self: rs.Place>, dst: rs.ByteSlice): void { + rs.bytesCopyToSlice(self.v, dst); } /** @@ -982,7 +982,7 @@ export function copyToSlice$bytes_Buf_mut_bytes_Bytes(self: rt.Place, dst: rt.ByteSlice): void { +export function copyToSlice$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place, dst: rs.ByteSlice): void { self.v.copyToSlice$Buf(dst); } @@ -1009,8 +1009,8 @@ export function copyToSlice$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, dst: rt.ByteSlice): void { - rt.bytesCopyToSlice(self.v, dst); +export function copyToSlice$bytes_Buf_mut_ref_slice_u8(self: rs.Place>, dst: rs.ByteSlice): void { + rs.bytesCopyToSlice(self.v, dst); } /** @@ -1032,8 +1032,8 @@ export function copyToSlice$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(self.v, 4, true)); +export function getF32Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(self.v, 4, true)); } /** @@ -1055,7 +1055,7 @@ export function getF32Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.f32 { +export function getF32Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.f32 { return self.v.getF32Le$Buf(); } @@ -1078,8 +1078,8 @@ export function getF32Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): r * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(self.v, 4, true)); +export function getF32Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(self.v, 4, true)); } /** @@ -1101,8 +1101,8 @@ export function getF32Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(self.v, 8, false)); +export function getF64$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(self.v, 8, false)); } /** @@ -1124,7 +1124,7 @@ export function getF64$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.f64 { +export function getF64$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.f64 { return self.v.getF64$Buf(); } @@ -1147,8 +1147,8 @@ export function getF64$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt. * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(self.v, 8, false)); +export function getF64$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(self.v, 8, false)); } /** @@ -1169,8 +1169,8 @@ export function getF64$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(self.v, 16, false)); +export function getI128$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(self.v, 16, false)); } /** @@ -1191,7 +1191,7 @@ export function getI128$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i128 { +export function getI128$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i128 { return self.v.getI128$Buf(); } @@ -1213,8 +1213,8 @@ export function getI128$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt * * This function panics if there is not enough remaining data in `self`. */ -export function getI128$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(self.v, 16, false)); +export function getI128$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(self.v, 16, false)); } /** @@ -1235,8 +1235,8 @@ export function getI128$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i16 { - return (rt.bytesReadWord(self.v, 2, true) << 16) >> 16 as rt.i16; +export function getI16Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i16 { + return (rs.bytesReadWord(self.v, 2, true) << 16) >> 16 as rs.i16; } /** @@ -1257,7 +1257,7 @@ export function getI16Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i16 { +export function getI16Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i16 { return self.v.getI16Le$Buf(); } @@ -1279,8 +1279,8 @@ export function getI16Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): r * * This function panics if there is not enough remaining data in `self`. */ -export function getI16Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i16 { - return (rt.bytesReadWord(self.v, 2, true) << 16) >> 16 as rt.i16; +export function getI16Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i16 { + return (rs.bytesReadWord(self.v, 2, true) << 16) >> 16 as rs.i16; } /** @@ -1301,8 +1301,8 @@ export function getI16Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i32 { - return (rt.bytesReadWord(self.v, 4, false) | 0) as rt.i32; +export function getI32$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i32 { + return (rs.bytesReadWord(self.v, 4, false) | 0) as rs.i32; } /** @@ -1323,7 +1323,7 @@ export function getI32$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i32 { +export function getI32$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i32 { return self.v.getI32$Buf(); } @@ -1345,8 +1345,8 @@ export function getI32$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt. * * This function panics if there is not enough remaining data in `self`. */ -export function getI32$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i32 { - return (rt.bytesReadWord(self.v, 4, false) | 0) as rt.i32; +export function getI32$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i32 { + return (rs.bytesReadWord(self.v, 4, false) | 0) as rs.i32; } /** @@ -1367,8 +1367,8 @@ export function getI32$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(self.v, 8, true)); +export function getI64Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(self.v, 8, true)); } /** @@ -1389,7 +1389,7 @@ export function getI64Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i64 { +export function getI64Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i64 { return self.v.getI64Le$Buf(); } @@ -1411,8 +1411,8 @@ export function getI64Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): r * * This function panics if there is not enough remaining data in `self`. */ -export function getI64Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(self.v, 8, true)); +export function getI64Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(self.v, 8, true)); } /** @@ -1433,8 +1433,8 @@ export function getI64Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i8 { - return (rt.bytesReadWord(self.v, 1, false) << 24) >> 24 as rt.i8; +export function getI8$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i8 { + return (rs.bytesReadWord(self.v, 1, false) << 24) >> 24 as rs.i8; } /** @@ -1455,7 +1455,7 @@ export function getI8$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i8 { +export function getI8$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i8 { return self.v.getI8$Buf(); } @@ -1477,8 +1477,8 @@ export function getI8$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt.i * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i8 { - return (rt.bytesReadWord(self.v, 1, false) << 24) >> 24 as rt.i8; +export function getI8$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i8 { + return (rs.bytesReadWord(self.v, 1, false) << 24) >> 24 as rs.i8; } /** @@ -1500,8 +1500,8 @@ export function getI8$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, nbytes: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(self.v, 8, nbytes, true, true)); +export function getIntLe$bytes_Buf_mut_bytes_Bytes(self: rs.Place>, nbytes: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(self.v, 8, nbytes, true, true)); } /** @@ -1523,7 +1523,7 @@ export function getIntLe$bytes_Buf_mut_bytes_Bytes(self: rt.Place, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place, nbytes: rs.usize): rs.i64 { return self.v.getIntLe$Buf(nbytes); } @@ -1546,8 +1546,8 @@ export function getIntLe$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, nb * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, nbytes: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(self.v, 8, nbytes, true, true)); +export function getIntLe$bytes_Buf_mut_ref_slice_u8(self: rs.Place>, nbytes: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(self.v, 8, nbytes, true, true)); } /** @@ -1568,8 +1568,8 @@ export function getIntLe$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(self.v, 16, true)); +export function getU128Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(self.v, 16, true)); } /** @@ -1590,7 +1590,7 @@ export function getU128Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u128 { +export function getU128Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u128 { return self.v.getU128Le$Buf(); } @@ -1612,8 +1612,8 @@ export function getU128Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): * * This function panics if there is not enough remaining data in `self`. */ -export function getU128Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(self.v, 16, true)); +export function getU128Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(self.v, 16, true)); } /** @@ -1634,8 +1634,8 @@ export function getU128Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u16 { - return rt.bytesReadWord(self.v, 2, false) as rt.u16; +export function getU16$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u16 { + return rs.bytesReadWord(self.v, 2, false) as rs.u16; } /** @@ -1656,7 +1656,7 @@ export function getU16$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u16 { +export function getU16$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u16 { return self.v.getU16$Buf(); } @@ -1678,8 +1678,8 @@ export function getU16$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt. * * This function panics if there is not enough remaining data in `self`. */ -export function getU16$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u16 { - return rt.bytesReadWord(self.v, 2, false) as rt.u16; +export function getU16$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u16 { + return rs.bytesReadWord(self.v, 2, false) as rs.u16; } /** @@ -1700,8 +1700,8 @@ export function getU16$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u32 { - return rt.bytesReadWord(self.v, 4, true) as rt.u32; +export function getU32Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u32 { + return rs.bytesReadWord(self.v, 4, true) as rs.u32; } /** @@ -1722,7 +1722,7 @@ export function getU32Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u32 { +export function getU32Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u32 { return self.v.getU32Le$Buf(); } @@ -1744,8 +1744,8 @@ export function getU32Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): r * * This function panics if there is not enough remaining data in `self`. */ -export function getU32Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u32 { - return rt.bytesReadWord(self.v, 4, true) as rt.u32; +export function getU32Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u32 { + return rs.bytesReadWord(self.v, 4, true) as rs.u32; } /** @@ -1766,8 +1766,8 @@ export function getU32Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(self.v, 8, false)); +export function getU64$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(self.v, 8, false)); } /** @@ -1788,7 +1788,7 @@ export function getU64$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u64 { +export function getU64$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u64 { return self.v.getU64$Buf(); } @@ -1810,8 +1810,8 @@ export function getU64$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt. * * This function panics if there is not enough remaining data in `self`. */ -export function getU64$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(self.v, 8, false)); +export function getU64$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(self.v, 8, false)); } /** @@ -1832,8 +1832,8 @@ export function getU64$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u8 { - return rt.bytesReadWord(self.v, 1, false) as rt.u8; +export function getU8$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u8 { + return rs.bytesReadWord(self.v, 1, false) as rs.u8; } /** @@ -1854,7 +1854,7 @@ export function getU8$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u8 { +export function getU8$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u8 { return self.v.getU8$Buf(); } @@ -1876,8 +1876,8 @@ export function getU8$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): rt.u * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u8 { - return rt.bytesReadWord(self.v, 1, false) as rt.u8; +export function getU8$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u8 { + return rs.bytesReadWord(self.v, 1, false) as rs.u8; } /** @@ -1899,8 +1899,8 @@ export function getU8$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, nbytes: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(self.v, 8, nbytes, false, false)); +export function getUint$bytes_Buf_mut_bytes_Bytes(self: rs.Place>, nbytes: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(self.v, 8, nbytes, false, false)); } /** @@ -1922,7 +1922,7 @@ export function getUint$bytes_Buf_mut_bytes_Bytes(self: rt.Place, nbytes: rt.usize): rt.u64 { +export function getUint$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place, nbytes: rs.usize): rs.u64 { return self.v.getUint$Buf(nbytes); } @@ -1945,8 +1945,8 @@ export function getUint$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place, nby * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_mut_ref_slice_u8(self: rt.Place>, nbytes: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(self.v, 8, nbytes, false, false)); +export function getUint$bytes_Buf_mut_ref_slice_u8(self: rs.Place>, nbytes: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(self.v, 8, nbytes, false, false)); } /** @@ -1968,7 +1968,7 @@ export function getUint$bytes_Buf_mut_ref_slice_u8(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rs.Place): boolean { return hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.v); } @@ -1991,7 +1991,7 @@ export function hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Plac * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_mut_bytes_Bytes(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_mut_bytes_Bytes(self: rs.Place): boolean { return self.v.length !== 0; } @@ -2014,7 +2014,7 @@ export function hasRemaining$bytes_Buf_mut_bytes_Bytes(self: rt.Place>): boolean { +export function hasRemaining$bytes_Buf_mut_mut_bytes_Bytes(self: rs.Place>): boolean { return hasRemaining$bytes_Buf_mut_bytes_Bytes(self.v); } @@ -2106,7 +2106,7 @@ export function hasRemaining$bytes_Buf_mut_mut_bytes_Bytes(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_mut_mut_dyn_bytes_Buf(self: rs.Place): boolean { return hasRemaining$bytes_Buf_mut_dyn_bytes_Buf(self.v); } @@ -2129,7 +2129,7 @@ export function hasRemaining$bytes_Buf_mut_mut_dyn_bytes_Buf(self: rt.Place>): boolean { +export function hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>): boolean { return hasRemaining$bytes_Buf_mut_ref_slice_u8(self.v); } @@ -2152,7 +2152,7 @@ export function hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_mut_ref_slice_u8(self: rs.Place): boolean { return self.v.length !== 0; } @@ -2183,7 +2183,7 @@ export function hasRemaining$bytes_Buf_mut_ref_slice_u8(self: rt.Place): rt.usize { +export function remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.usize { return remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.v); } @@ -2214,7 +2214,7 @@ export function remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.usize { +export function remaining$bytes_Buf_mut_bytes_Bytes(self: rs.Place): rs.usize { return self.v.length; } @@ -2245,7 +2245,7 @@ export function remaining$bytes_Buf_mut_bytes_Bytes(self: rt.Place * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut): rt.usize { +export function remaining$bytes_Buf_mut_bytes_BytesMut(self: rs.BytesMut): rs.usize { return self.length; } @@ -2276,7 +2276,7 @@ export function remaining$bytes_Buf_mut_bytes_BytesMut(self: rt.BytesMut): rt.us * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_dyn_buf_Leased(self: Leased.Leased): rt.usize { +export function remaining$bytes_Buf_mut_dyn_buf_Leased(self: Leased.Leased): rs.usize { return self.remaining$Buf(); } @@ -2307,7 +2307,7 @@ export function remaining$bytes_Buf_mut_dyn_buf_Leased(self: Leased.Leased): rt. * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_dyn_bytes_Buf(self: Buf.Buf): rt.usize { +export function remaining$bytes_Buf_mut_dyn_bytes_Buf(self: Buf.Buf): rs.usize { return self.remaining$Buf(); } @@ -2338,7 +2338,7 @@ export function remaining$bytes_Buf_mut_dyn_bytes_Buf(self: Buf.Buf): rt.usize { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_mut_bytes_Bytes(self: rt.Place>): rt.usize { +export function remaining$bytes_Buf_mut_mut_bytes_Bytes(self: rs.Place>): rs.usize { return remaining$bytes_Buf_mut_bytes_Bytes(self.v); } @@ -2369,7 +2369,7 @@ export function remaining$bytes_Buf_mut_mut_bytes_Bytes(self: rt.Place): rt.usize { +export function remaining$bytes_Buf_mut_mut_dyn_bytes_Buf(self: rs.Place): rs.usize { return remaining$bytes_Buf_mut_dyn_bytes_Buf(self.v); } @@ -2400,7 +2400,7 @@ export function remaining$bytes_Buf_mut_mut_dyn_bytes_Buf(self: rt.Place>): rt.usize { +export function remaining$bytes_Buf_mut_mut_ref_slice_u8(self: rs.Place>): rs.usize { return remaining$bytes_Buf_mut_ref_slice_u8(self.v); } @@ -2431,7 +2431,7 @@ export function remaining$bytes_Buf_mut_mut_ref_slice_u8(self: rt.Place): rt.usize { +export function remaining$bytes_Buf_mut_ref_slice_u8(self: rs.Place): rs.usize { return self.v.length; } @@ -2461,15 +2461,15 @@ export function remaining$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i64 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetI64Le$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.i64 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$i64.err = _0.error; @@ -2504,8 +2504,8 @@ export function tryGetI64Le$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.i64 | undefined { - const _0: rt.Result = self.v.tryGetI64Le$Buf(); +export function tryGetI64Le$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.i64 | undefined { + const _0: rs.Result = self.v.tryGetI64Le$Buf(); if (!_0.ok) { out$i64.err = _0.error; return undefined; @@ -2539,15 +2539,15 @@ export function tryGetI64Le$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place) * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetI64Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.i64 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetI64Le$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.i64 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$i64.err = _0.error; @@ -2582,15 +2582,15 @@ export function tryGetI64Le$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u128 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetU128$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u128 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$u128.err = _0.error; @@ -2625,8 +2625,8 @@ export function tryGetU128$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u128 | undefined { - const _0: rt.Result = self.v.tryGetU128$Buf(); +export function tryGetU128$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u128 | undefined { + const _0: rs.Result = self.v.tryGetU128$Buf(); if (!_0.ok) { out$u128.err = _0.error; return undefined; @@ -2660,15 +2660,15 @@ export function tryGetU128$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): * assert_eq!(15, buf.remaining()); * ``` */ -export function tryGetU128$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u128 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetU128$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u128 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$u128.err = _0.error; @@ -2703,15 +2703,15 @@ export function tryGetU128$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u16 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetU16$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u16 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$u16.err = _0.error; @@ -2746,8 +2746,8 @@ export function tryGetU16$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u16 | undefined { - const _0: rt.Result = self.v.tryGetU16$Buf(); +export function tryGetU16$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u16 | undefined { + const _0: rs.Result = self.v.tryGetU16$Buf(); if (!_0.ok) { out$u16.err = _0.error; return undefined; @@ -2781,15 +2781,15 @@ export function tryGetU16$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): * assert_eq!(1, buf.remaining()); * ``` */ -export function tryGetU16$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u16 | undefined { - const _0: rt.Result = rt.bufTryGet(self.v, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { +export function tryGetU16$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u16 | undefined { + const _0: rs.Result = rs.bufTryGet(self.v, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); if (!_0.ok) { out$u16.err = _0.error; @@ -2823,7 +2823,7 @@ export function tryGetU16$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_mut_bytes_Bytes(self: rs.Place>): rs.u8 | undefined { return tryGetU8$bytes_Buf_bytes_Bytes(self.v); } @@ -2852,8 +2852,8 @@ export function tryGetU8$bytes_Buf_mut_bytes_Bytes(self: rt.Place): rt.u8 | undefined { - const _0: rt.Result = self.v.tryGetU8$Buf(); +export function tryGetU8$bytes_Buf_mut_dyn_bytes_Buf(self: rs.Place): rs.u8 | undefined { + const _0: rs.Result = self.v.tryGetU8$Buf(); if (!_0.ok) { out$u8.err = _0.error; return undefined; @@ -2886,7 +2886,7 @@ export function tryGetU8$bytes_Buf_mut_dyn_bytes_Buf(self: rt.Place): r * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_mut_ref_slice_u8(self: rt.Place>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_mut_ref_slice_u8(self: rs.Place>): rs.u8 | undefined { return tryGetU8$bytes_Buf_ref_slice_u8(self.v); } @@ -2922,7 +2922,7 @@ export function tryGetU8$bytes_Buf_mut_ref_slice_u8(self: rt.Place, cnt: rt.usize): void { +export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place, cnt: rs.usize): void { self.v.advance$Buf(cnt); } @@ -2956,7 +2956,7 @@ export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place self.remaining()`. */ -export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place, len: rs.usize): rs.ByteSlice { return self.v.copyToBytes$Buf(len); } @@ -3008,7 +3008,7 @@ export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place, dst: rt.ByteSlice): void { +export function copyToSlice$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place, dst: rs.ByteSlice): void { self.v.copyToSlice$Buf(dst); } @@ -3031,7 +3031,7 @@ export function copyToSlice$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.f32 { +export function getF32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.f32 { return self.v.getF32Le$Buf(); } @@ -3054,7 +3054,7 @@ export function getF32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.f64 { +export function getF64$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.f64 { return self.v.getF64$Buf(); } @@ -3076,7 +3076,7 @@ export function getF64$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place * * This function panics if there is not enough remaining data in `self`. */ -export function getI128$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i128 { +export function getI128$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i128 { return self.v.getI128$Buf(); } @@ -3098,7 +3098,7 @@ export function getI128$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i16 { +export function getI16Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i16 { return self.v.getI16Le$Buf(); } @@ -3123,7 +3123,7 @@ export function getI16Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i16 { +export function getI16Ne$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i16 { return self.v.getI16Ne$Buf(); } @@ -3145,7 +3145,7 @@ export function getI16Ne$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i32 { +export function getI32$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i32 { return self.v.getI32$Buf(); } @@ -3167,7 +3167,7 @@ export function getI32$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place * * This function panics if there is not enough remaining data in `self`. */ -export function getI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i64 { +export function getI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i64 { return self.v.getI64Le$Buf(); } @@ -3189,7 +3189,7 @@ export function getI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i8 { +export function getI8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i8 { return self.v.getI8$Buf(); } @@ -3212,7 +3212,7 @@ export function getI8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place) * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place, nbytes: rs.usize): rs.i64 { return self.v.getIntLe$Buf(nbytes); } @@ -3234,7 +3234,7 @@ export function getIntLe$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u128 { +export function getU128Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u128 { return self.v.getU128Le$Buf(); } @@ -3256,7 +3256,7 @@ export function getU128Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u16 { +export function getU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u16 { return self.v.getU16$Buf(); } @@ -3278,7 +3278,7 @@ export function getU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place * * This function panics if there is not enough remaining data in `self`. */ -export function getU32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u32 { +export function getU32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u32 { return self.v.getU32Le$Buf(); } @@ -3300,7 +3300,7 @@ export function getU32Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u64 { +export function getU64$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u64 { return self.v.getU64$Buf(); } @@ -3322,7 +3322,7 @@ export function getU64$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u8 { +export function getU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u8 { return self.v.getU8$Buf(); } @@ -3345,7 +3345,7 @@ export function getU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place) * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place, nbytes: rt.usize): rt.u64 { +export function getUint$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place, nbytes: rs.usize): rs.u64 { return self.v.getUint$Buf(nbytes); } @@ -3399,7 +3399,7 @@ export function hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: Buf.Buf): b * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: Buf.Buf): rt.usize { +export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: Buf.Buf): rs.usize { return self.remaining$Buf(); } @@ -3429,8 +3429,8 @@ export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: Buf.Buf): rt.u * assert_eq!(7, buf.remaining()); * ``` */ -export function tryGetI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.i64 | undefined { - const _0: rt.Result = self.v.tryGetI64Le$Buf(); +export function tryGetI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.i64 | undefined { + const _0: rs.Result = self.v.tryGetI64Le$Buf(); if (!_0.ok) { out$i64.err = _0.error; return undefined; @@ -3464,8 +3464,8 @@ export function tryGetI64Le$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u128 | undefined { - const _0: rt.Result = self.v.tryGetU128$Buf(); +export function tryGetU128$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u128 | undefined { + const _0: rs.Result = self.v.tryGetU128$Buf(); if (!_0.ok) { out$u128.err = _0.error; return undefined; @@ -3499,8 +3499,8 @@ export function tryGetU128$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u16 | undefined { - const _0: rt.Result = self.v.tryGetU16$Buf(); +export function tryGetU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u16 | undefined { + const _0: rs.Result = self.v.tryGetU16$Buf(); if (!_0.ok) { out$u16.err = _0.error; return undefined; @@ -3533,8 +3533,8 @@ export function tryGetU16$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rt.Place): rt.u8 | undefined { - const _0: rt.Result = self.v.tryGetU8$Buf(); +export function tryGetU8$bytes_Buf_boxed_Box_dyn_bytes_Buf(self: rs.Place): rs.u8 | undefined { + const _0: rs.Result = self.v.tryGetU8$Buf(); if (!_0.ok) { out$u8.err = _0.error; return undefined; diff --git a/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts b/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts index def4958af..1a11d1175 100644 --- a/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts +++ b/ts/fixtures/stock/expected/bytes/buf/buf_mut.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; /** * Writes a signed 16 bit integer to `self` in little-endian byte order. @@ -22,8 +22,8 @@ import * as rt from "../../rt.ts"; * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI16Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt.i16): void { - rt.byteVecPutWord(self.v, n, 2, true); +export function putI16Le$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.i16): void { + rs.byteVecPutWord(self.v, n, 2, true); } /** @@ -46,8 +46,8 @@ export function putI16Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI16Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i16): void { - rt.bytesMutPutWord(self.v, n, 2, true); +export function putI16Le$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.i16): void { + rs.bytesMutPutWord(self.v, n, 2, true); } /** @@ -70,8 +70,8 @@ export function putI16Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i32): void { - rt.byteVecPutWord(self.v, n, 4, true); +export function putI32Le$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.i32): void { + rs.byteVecPutWord(self.v, n, 4, true); } /** @@ -94,8 +94,8 @@ export function putI32Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI32Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i32): void { - rt.bytesMutPutWord(self.v, n, 4, true); +export function putI32Le$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.i32): void { + rs.bytesMutPutWord(self.v, n, 4, true); } /** @@ -118,8 +118,8 @@ export function putI32Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i64): void { - rt.byteVecPutBytes(self.v, rt.i64ToBeBytes(n), false); +export function putI64$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.i64): void { + rs.byteVecPutBytes(self.v, rs.i64ToBeBytes(n), false); } /** @@ -142,8 +142,8 @@ export function putI64$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI64$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i64): void { - rt.bytesMutPutBytes(self.v, rt.i64ToBeBytes(n), false); +export function putI64$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.i64): void { + rs.bytesMutPutBytes(self.v, rs.i64ToBeBytes(n), false); } /** @@ -166,8 +166,8 @@ export function putI64$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i8): void { - rt.byteVecPutWord(self.v, n, 1, false); +export function putI8$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.i8): void { + rs.byteVecPutWord(self.v, n, 1, false); } /** @@ -190,8 +190,8 @@ export function putI8$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt. * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI8$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.i8): void { - rt.bytesMutPutWord(self.v, n, 1, false); +export function putI8$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.i8): void { + rs.bytesMutPutWord(self.v, n, 1, false); } /** @@ -215,8 +215,8 @@ export function putI8$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, src: rt.ByteSlice): void { - rt.byteVecExtendFromSlice(self.v, src); +export function putSlice$bytes_BufMut_mut_Vec_u8(self: rs.Place, src: rs.ByteSlice): void { + rs.byteVecExtendFromSlice(self.v, src); } /** @@ -240,8 +240,8 @@ export function putSlice$bytes_BufMut_mut_Vec_u8(self: rt.Place, src * assert_eq!(b"hello\0", &dst); * ``` */ -export function putSlice$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, src: rt.ByteSlice): void { - rt.bytesMutExtend(self.v, src); +export function putSlice$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, src: rs.ByteSlice): void { + rs.bytesMutExtend(self.v, src); } /** @@ -264,8 +264,8 @@ export function putSlice$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u16): void { - rt.byteVecPutWord(self.v, n, 2, false); +export function putU16$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.u16): void { + rs.byteVecPutWord(self.v, n, 2, false); } /** @@ -288,8 +288,8 @@ export function putU16$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU16$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u16): void { - rt.bytesMutPutWord(self.v, n, 2, false); +export function putU16$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.u16): void { + rs.bytesMutPutWord(self.v, n, 2, false); } /** @@ -312,8 +312,8 @@ export function putU16$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u32): void { - rt.byteVecPutWord(self.v, n, 4, false); +export function putU32$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.u32): void { + rs.byteVecPutWord(self.v, n, 4, false); } /** @@ -336,8 +336,8 @@ export function putU32$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU32$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u32): void { - rt.bytesMutPutWord(self.v, n, 4, false); +export function putU32$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.u32): void { + rs.bytesMutPutWord(self.v, n, 4, false); } /** @@ -360,8 +360,8 @@ export function putU32$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u64): void { - rt.byteVecPutBytes(self.v, rt.u64ToBeBytes(n), true); +export function putU64Le$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.u64): void { + rs.byteVecPutBytes(self.v, rs.u64ToBeBytes(n), true); } /** @@ -384,8 +384,8 @@ export function putU64Le$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU64Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u64): void { - rt.bytesMutPutBytes(self.v, rt.u64ToBeBytes(n), true); +export function putU64Le$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.u64): void { + rs.bytesMutPutBytes(self.v, rs.u64ToBeBytes(n), true); } /** @@ -408,8 +408,8 @@ export function putU64Le$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u8): void { - rt.byteVecPutWord(self.v, n, 1, false); +export function putU8$bytes_BufMut_mut_Vec_u8(self: rs.Place, n: rs.u8): void { + rs.byteVecPutWord(self.v, n, 1, false); } /** @@ -432,8 +432,8 @@ export function putU8$bytes_BufMut_mut_Vec_u8(self: rt.Place, n: rt. * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU8$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place, n: rt.u8): void { - rt.bytesMutPutWord(self.v, n, 1, false); +export function putU8$bytes_BufMut_mut_bytes_BytesMut(self: rs.Place, n: rs.u8): void { + rs.bytesMutPutWord(self.v, n, 1, false); } /** @@ -471,8 +471,8 @@ export function putU8$bytes_BufMut_mut_bytes_BytesMut(self: rt.Place): rt.usize { +export function remainingMut$bytes_BufMut_mut_boxed_Box_Vec_u8(self: rs.Place): rs.usize { return remainingMut$bytes_BufMut_boxed_Box_Vec_u8(self.v); } @@ -549,7 +549,7 @@ export function remainingMut$bytes_BufMut_mut_boxed_Box_Vec_u8(self: rt.Place): rt.usize { +export function remainingMut$bytes_BufMut_mut_boxed_Box_bytes_BytesMut(self: rs.Place): rs.usize { return remainingMut$bytes_BufMut_boxed_Box_bytes_BytesMut(self.v); } @@ -588,8 +588,8 @@ export function remainingMut$bytes_BufMut_mut_boxed_Box_bytes_BytesMut(self: rt. * * `remaining_mut` may return value smaller than actual available space. */ -export function remainingMut$bytes_BufMut_mut_bytes_BytesMut(self: rt.BytesMut): rt.usize { - return 0x7fffffff - self.length as rt.usize; +export function remainingMut$bytes_BufMut_mut_bytes_BytesMut(self: rs.BytesMut): rs.usize { + return 0x7fffffff - self.length as rs.usize; } /** @@ -627,7 +627,7 @@ export function remainingMut$bytes_BufMut_mut_bytes_BytesMut(self: rt.BytesMut): * * `remaining_mut` may return value smaller than actual available space. */ -export function remainingMut$bytes_BufMut_mut_mut_Vec_u8(self: rt.Place): rt.usize { +export function remainingMut$bytes_BufMut_mut_mut_Vec_u8(self: rs.Place): rs.usize { return remainingMut$bytes_BufMut_mut_Vec_u8(self.v); } @@ -666,7 +666,7 @@ export function remainingMut$bytes_BufMut_mut_mut_Vec_u8(self: rt.Place): rt.usize { +export function remainingMut$bytes_BufMut_mut_mut_bytes_BytesMut(self: rs.Place): rs.usize { return remainingMut$bytes_BufMut_mut_bytes_BytesMut(self.v); } @@ -690,8 +690,8 @@ export function remainingMut$bytes_BufMut_mut_mut_bytes_BytesMut(self: rt.Place< * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI16Le$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, n: rt.i16): void { - rt.byteVecPutWord(self.v, n, 2, true); +export function putI16Le$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.i16): void { + rs.byteVecPutWord(self.v, n, 2, true); } /** @@ -714,8 +714,8 @@ export function putI16Le$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, n: rt.i16): void { - rt.bytesMutPutWord(self.v, n, 2, true); +export function putI16Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.i16): void { + rs.bytesMutPutWord(self.v, n, 2, true); } /** @@ -738,8 +738,8 @@ export function putI16Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.i32): void { - rt.byteVecPutWord(self.v, n, 4, true); +export function putI32Le$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.i32): void { + rs.byteVecPutWord(self.v, n, 4, true); } /** @@ -762,8 +762,8 @@ export function putI32Le$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, n: rt.i32): void { - rt.bytesMutPutWord(self.v, n, 4, true); +export function putI32Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.i32): void { + rs.bytesMutPutWord(self.v, n, 4, true); } /** @@ -786,8 +786,8 @@ export function putI32Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.i64): void { - rt.byteVecPutBytes(self.v, rt.i64ToBeBytes(n), false); +export function putI64$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.i64): void { + rs.byteVecPutBytes(self.v, rs.i64ToBeBytes(n), false); } /** @@ -810,8 +810,8 @@ export function putI64$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI64$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.i64): void { - rt.bytesMutPutBytes(self.v, rt.i64ToBeBytes(n), false); +export function putI64$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.i64): void { + rs.bytesMutPutBytes(self.v, rs.i64ToBeBytes(n), false); } /** @@ -834,8 +834,8 @@ export function putI64$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.i8): void { - rt.byteVecPutWord(self.v, n, 1, false); +export function putI8$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.i8): void { + rs.byteVecPutWord(self.v, n, 1, false); } /** @@ -858,8 +858,8 @@ export function putI8$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, * This function panics if there is not enough remaining capacity in * `self`. */ -export function putI8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.i8): void { - rt.bytesMutPutWord(self.v, n, 1, false); +export function putI8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.i8): void { + rs.bytesMutPutWord(self.v, n, 1, false); } /** @@ -883,8 +883,8 @@ export function putI8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, src: rt.ByteSlice): void { - rt.byteVecExtendFromSlice(self.v, src); +export function putSlice$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, src: rs.ByteSlice): void { + rs.byteVecExtendFromSlice(self.v, src); } /** @@ -908,8 +908,8 @@ export function putSlice$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, src: rt.ByteSlice): void { - rt.bytesMutExtend(self.v, src); +export function putSlice$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, src: rs.ByteSlice): void { + rs.bytesMutExtend(self.v, src); } /** @@ -932,8 +932,8 @@ export function putSlice$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u16): void { - rt.byteVecPutWord(self.v, n, 2, false); +export function putU16$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.u16): void { + rs.byteVecPutWord(self.v, n, 2, false); } /** @@ -956,8 +956,8 @@ export function putU16$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU16$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u16): void { - rt.bytesMutPutWord(self.v, n, 2, false); +export function putU16$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.u16): void { + rs.bytesMutPutWord(self.v, n, 2, false); } /** @@ -980,8 +980,8 @@ export function putU16$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u32): void { - rt.byteVecPutWord(self.v, n, 4, false); +export function putU32$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.u32): void { + rs.byteVecPutWord(self.v, n, 4, false); } /** @@ -1004,8 +1004,8 @@ export function putU32$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU32$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u32): void { - rt.bytesMutPutWord(self.v, n, 4, false); +export function putU32$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.u32): void { + rs.bytesMutPutWord(self.v, n, 4, false); } /** @@ -1028,8 +1028,8 @@ export function putU32$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u64): void { - rt.byteVecPutBytes(self.v, rt.u64ToBeBytes(n), true); +export function putU64Le$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.u64): void { + rs.byteVecPutBytes(self.v, rs.u64ToBeBytes(n), true); } /** @@ -1052,8 +1052,8 @@ export function putU64Le$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, n: rt.u64): void { - rt.bytesMutPutBytes(self.v, rt.u64ToBeBytes(n), true); +export function putU64Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.u64): void { + rs.bytesMutPutBytes(self.v, rs.u64ToBeBytes(n), true); } /** @@ -1076,8 +1076,8 @@ export function putU64Le$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u8): void { - rt.byteVecPutWord(self.v, n, 1, false); +export function putU8$bytes_BufMut_boxed_Box_Vec_u8(self: rs.Place, n: rs.u8): void { + rs.byteVecPutWord(self.v, n, 1, false); } /** @@ -1100,8 +1100,8 @@ export function putU8$bytes_BufMut_boxed_Box_Vec_u8(self: rt.Place, * This function panics if there is not enough remaining capacity in * `self`. */ -export function putU8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place, n: rt.u8): void { - rt.bytesMutPutWord(self.v, n, 1, false); +export function putU8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rs.Place, n: rs.u8): void { + rs.bytesMutPutWord(self.v, n, 1, false); } /** @@ -1139,8 +1139,8 @@ export function putU8$bytes_BufMut_boxed_Box_bytes_BytesMut(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain): boolean { return remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self) > 0; } @@ -77,7 +77,7 @@ export function hasRemaining$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): boolean { +export function hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): boolean { return remaining$bytes_Buf_buf_Provided_bytes_Bytes(self) > 0; } @@ -100,7 +100,7 @@ export function hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): boolean { +export function hasRemaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): boolean { return remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self) > 0; } @@ -123,7 +123,7 @@ export function hasRemaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): boolean { return remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self) > 0; } @@ -146,7 +146,7 @@ export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): boolean { return remaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self) > 0; } @@ -169,7 +169,7 @@ export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): boolean { +export function hasRemaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): boolean { return remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self) > 0; } @@ -192,7 +192,7 @@ export function hasRemaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_b * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): boolean { +export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): boolean { return remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self) > 0; } @@ -215,7 +215,7 @@ export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_ * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): boolean { +export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): boolean { return remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self) > 0; } @@ -238,7 +238,7 @@ export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(sel * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): boolean { +export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): boolean { return remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self) > 0; } @@ -261,7 +261,7 @@ export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): boolean { +export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): boolean { return remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self) > 0; } @@ -288,8 +288,8 @@ export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -317,8 +317,8 @@ export function copyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -346,8 +346,8 @@ export function copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -375,8 +375,8 @@ export function copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain< * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -404,8 +404,8 @@ export function copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_r * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -433,8 +433,8 @@ export function copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -462,8 +462,8 @@ export function copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_by * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -491,8 +491,8 @@ export function copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_b * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -520,8 +520,8 @@ export function copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -544,11 +544,11 @@ export function copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.u8 { +export function getU8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.u8 { if (!(remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_buf_Pieces_buf_Provided(self, 1); return ret; } @@ -573,11 +573,11 @@ export function getU8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.u8 { +export function getU8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.u8 { if (!(remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_buf_Provided_bytes_Bytes(self, 1); return ret; } @@ -602,11 +602,11 @@ export function getU8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.u8 { +export function getU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.u8 { if (!(remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, 1); return ret; } @@ -631,11 +631,11 @@ export function getU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rt.u8 { +export function getU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.u8 { if (!(remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, 1); return ret; } @@ -660,11 +660,11 @@ export function getU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sli * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.u8 { +export function getU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.u8 { if (!(remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -689,11 +689,11 @@ export function getU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.u8 { +export function getU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.u8 { if (!(remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -718,11 +718,11 @@ export function getU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.u8 { +export function getU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.u8 { if (!(remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -747,11 +747,11 @@ export function getU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pie * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.u8 { +export function getU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.u8 { if (!(remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -776,11 +776,11 @@ export function getU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chai * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.u8 { +export function getU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.u8 { if (!(remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, 1); return ret; } @@ -805,11 +805,11 @@ export function getU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.i8 { +export function getI8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.i8 { if (!(remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_buf_Pieces_buf_Provided(self, 1); return ret; } @@ -834,11 +834,11 @@ export function getI8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.i8 { +export function getI8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.i8 { if (!(remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_buf_Provided_bytes_Bytes(self, 1); return ret; } @@ -863,11 +863,11 @@ export function getI8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.i8 { +export function getI8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.i8 { if (!(remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, 1); return ret; } @@ -892,11 +892,11 @@ export function getI8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rt.i8 { +export function getI8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.i8 { if (!(remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, 1); return ret; } @@ -921,11 +921,11 @@ export function getI8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sli * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.i8 { +export function getI8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.i8 { if (!(remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -950,11 +950,11 @@ export function getI8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.i8 { +export function getI8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.i8 { if (!(remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -979,11 +979,11 @@ export function getI8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.i8 { +export function getI8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.i8 { if (!(remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -1008,11 +1008,11 @@ export function getI8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pie * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.i8 { +export function getI8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.i8 { if (!(remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -1037,11 +1037,11 @@ export function getI8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chai * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.i8 { +export function getI8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.i8 { if (!(remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, 1); return ret; } @@ -1067,21 +1067,21 @@ export function getI8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1105,21 +1105,21 @@ export function getUint$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1143,21 +1143,21 @@ export function getUint$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1181,21 +1181,21 @@ export function getUint$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1219,21 +1219,21 @@ export function getUint$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_s * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1257,21 +1257,21 @@ export function getUint$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1295,21 +1295,21 @@ export function getUint$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_ * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1333,21 +1333,21 @@ export function getUint$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_P * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1371,21 +1371,21 @@ export function getUint$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Ch * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1409,20 +1409,20 @@ export function getUint$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1446,20 +1446,20 @@ export function getUintLe$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1483,20 +1483,20 @@ export function getUintLe$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1520,20 +1520,20 @@ export function getUintLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1557,20 +1557,20 @@ export function getUintLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1594,20 +1594,20 @@ export function getUintLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1631,20 +1631,20 @@ export function getUintLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_byte * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1668,20 +1668,20 @@ export function getUintLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1705,20 +1705,20 @@ export function getUintLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -1742,7 +1742,7 @@ export function getUintLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_buf_Pieces_buf_Provided(self, nbytes), nbytes); } @@ -1765,7 +1765,7 @@ export function getIntLe$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_buf_Provided_bytes_Bytes(self, nbytes), nbytes); } @@ -1788,7 +1788,7 @@ export function getIntLe$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, nbytes), nbytes); } @@ -1811,7 +1811,7 @@ export function getIntLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, nbytes), nbytes); } @@ -1834,7 +1834,7 @@ export function getIntLe$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_ * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self, nbytes), nbytes); } @@ -1857,7 +1857,7 @@ export function getIntLe$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, nbytes), nbytes); } @@ -1880,7 +1880,7 @@ export function getIntLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, nbytes), nbytes); } @@ -1903,7 +1903,7 @@ export function getIntLe$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_ * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, nbytes), nbytes); } @@ -1926,7 +1926,7 @@ export function getIntLe$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: C * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, nbytes), nbytes); } @@ -1949,8 +1949,8 @@ export function getIntLe$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_buf_Pieces_buf_Provided, chunk$bytes_Buf_buf_Pieces_buf_Provided, advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_buf_Pieces_buf_Provided, chunk$bytes_Buf_buf_Pieces_buf_Provided, advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -1972,8 +1972,8 @@ export function getF32Le$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_buf_Provided_bytes_Bytes, chunk$bytes_Buf_buf_Provided_bytes_Bytes, advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_buf_Provided_bytes_Bytes, chunk$bytes_Buf_buf_Provided_bytes_Bytes, advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -1995,8 +1995,8 @@ export function getF32Le$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rs.ByteSlice) => undefined)); } /** @@ -2018,8 +2018,8 @@ export function getF32Le$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rs.ByteSlice) => undefined)); } /** @@ -2041,8 +2041,8 @@ export function getF32Le$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_ * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2064,8 +2064,8 @@ export function getF32Le$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rt.ByteSlice>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rs.ByteSlice>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined)); } /** @@ -2087,8 +2087,8 @@ export function getF32Le$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } /** @@ -2110,8 +2110,8 @@ export function getF32Le$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_ * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } /** @@ -2133,8 +2133,8 @@ export function getF32Le$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: C * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2156,8 +2156,8 @@ export function getF32Le$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_buf_Pieces_buf_Provided, chunk$bytes_Buf_buf_Pieces_buf_Provided, advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_buf_Pieces_buf_Provided, chunk$bytes_Buf_buf_Pieces_buf_Provided, advance$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Pieces_buf_Provided as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2179,8 +2179,8 @@ export function getF64$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_buf_Provided_bytes_Bytes, chunk$bytes_Buf_buf_Provided_bytes_Bytes, advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_buf_Provided_bytes_Bytes, chunk$bytes_Buf_buf_Provided_bytes_Bytes, advance$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_bytes_Bytes as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2202,8 +2202,8 @@ export function getF64$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain>, a1: rs.ByteSlice) => undefined)); } /** @@ -2225,8 +2225,8 @@ export function getF64$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Chain>, a1: rs.ByteSlice) => undefined)); } /** @@ -2248,8 +2248,8 @@ export function getF64$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sl * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2271,8 +2271,8 @@ export function getF64$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rt.ByteSlice>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rs.ByteSlice>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined)); } /** @@ -2294,8 +2294,8 @@ export function getF64$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_B * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } /** @@ -2317,8 +2317,8 @@ export function getF64$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pi * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces, advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces as (a0: Chain, Pieces.Pieces>, a1: rs.ByteSlice) => undefined)); } /** @@ -2340,8 +2340,8 @@ export function getF64$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Cha * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut, chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut, advance$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut as (a0: Chain, a1: rs.ByteSlice) => undefined)); } /** @@ -2376,18 +2376,18 @@ export function getF64$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_buf_Pieces_buf_Provided(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) }); } /** @@ -2422,18 +2422,18 @@ export function tryCopyToSlice$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_buf_Provided_bytes_Bytes(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) }); } /** @@ -2468,18 +2468,18 @@ export function tryCopyToSlice$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) }); } /** @@ -2514,18 +2514,18 @@ export function tryCopyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Cha * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) }); } /** @@ -2560,18 +2560,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provide * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) }); } /** @@ -2606,18 +2606,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) }); } /** @@ -2652,18 +2652,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) }); } /** @@ -2698,18 +2698,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Byte * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) }); } /** @@ -2744,18 +2744,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(s * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) }); } /** @@ -2783,11 +2783,11 @@ export function tryCopyToSlice$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.u8 | undefined { if (!(remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_buf_Pieces_buf_Provided(self, 1); return ret; } @@ -2820,11 +2820,11 @@ export function tryGetU8$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.u8 | undefined { if (!(remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_buf_Provided_bytes_Bytes(self, 1); return ret; } @@ -2857,11 +2857,11 @@ export function tryGetU8$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.u8 | undefined { if (!(remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self, 1); return ret; } @@ -2894,11 +2894,11 @@ export function tryGetU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, 1); return ret; } @@ -2931,11 +2931,11 @@ export function tryGetU8$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_ * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -2968,11 +2968,11 @@ export function tryGetU8$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, 1); return ret; } @@ -3005,11 +3005,11 @@ export function tryGetU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -3042,11 +3042,11 @@ export function tryGetU8$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_ * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self, 1); return ret; } @@ -3079,11 +3079,11 @@ export function tryGetU8$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: C * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.u8 | undefined { if (!(remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self, 1); return ret; } @@ -3114,7 +3114,7 @@ export function tryGetU8$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, limit: rt.usize): Take.Take> { +export function take$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain, limit: rs.usize): Take.Take> { return take_new_$mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self, limit); } @@ -3135,7 +3135,7 @@ export function take$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain, next: rt.ByteSlice): Chain, rt.ByteSlice> { +export function chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, next: rs.ByteSlice): Chain, rs.ByteSlice> { return new$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self, next); } @@ -3156,7 +3156,7 @@ export function chain$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, next: Pieces.Pieces): Chain, Pieces.Pieces> { +export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, next: Pieces.Pieces): Chain, Pieces.Pieces> { return new$bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self, next); } @@ -3192,7 +3192,7 @@ export function chain$bytes_Buf_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain< * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: rt.Place>, cnt: rt.usize): void { +export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: rs.Place>, cnt: rs.usize): void { advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.v, cnt); } @@ -3228,7 +3228,7 @@ export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rt.Place>, cnt: rt.usize): void { +export function advance$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rs.Place>, cnt: rs.usize): void { advance$bytes_Buf_buf_Provided_ref_slice_u8(self.v, cnt); } @@ -3264,7 +3264,7 @@ export function advance$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rt.Place>, cnt: rt.usize): void { +export function advance$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: rs.Place>, cnt: rs.usize): void { advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self.v, cnt); } @@ -3298,7 +3298,7 @@ export function advance$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: rt.Place): rt.ByteSlice { +export function chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self); } @@ -3332,7 +3332,7 @@ export function chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Ch * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_buf_Pieces_buf_Provided(self); } @@ -3366,7 +3366,7 @@ export function chunk$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_buf_Provided_bytes_Bytes(self); } @@ -3400,7 +3400,7 @@ export function chunk$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain>): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self: Chain>): rs.ByteSlice { return chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8(self); } @@ -3434,7 +3434,7 @@ export function chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_buf_Provided_ref_slice_u8(self); } @@ -3468,7 +3468,7 @@ export function chunk$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self: Chain>): rs.ByteSlice { return chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self); } @@ -3502,7 +3502,7 @@ export function chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sli * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_bytes_Bytes_ref_slice_u8(self); } @@ -3536,7 +3536,7 @@ export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain, rt.ByteSlice>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain, rs.ByteSlice>): rs.ByteSlice { return chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self); } @@ -3570,7 +3570,7 @@ export function chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rs.ByteSlice { return chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self); } @@ -3604,7 +3604,7 @@ export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pie * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rs.ByteSlice { return chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self); } @@ -3638,7 +3638,7 @@ export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut(self); } @@ -3672,7 +3672,7 @@ export function chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain): rs.ByteSlice { return chunk$bytes_Buf_ref_slice_u8_bytes_Bytes(self); } @@ -3697,7 +3697,7 @@ export function chunk$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: rt.Place>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: rs.Place>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.v, len); } @@ -3722,7 +3722,7 @@ export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(se * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rt.Place>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rs.Place>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8(self.v, len); } @@ -3747,7 +3747,7 @@ export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: rt.Pla * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: rt.Place>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: rs.Place>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes(self.v, len); } @@ -3770,7 +3770,7 @@ export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: rt.Plac * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Chain): boolean { +export function hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Chain): boolean { return hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self); } @@ -3816,7 +3816,7 @@ export function hasRemaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain

): boolean { +export function hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain): boolean { return hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes(self); } @@ -3839,7 +3839,7 @@ export function hasRemaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain< * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self: Chain>): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self: Chain>): boolean { return hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self); } @@ -3862,7 +3862,7 @@ export function hasRemaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): boolean { return hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self); } @@ -3885,7 +3885,7 @@ export function hasRemaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain< * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): boolean { +export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): boolean { return hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self); } @@ -3908,7 +3908,7 @@ export function hasRemaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_ * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): boolean { +export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): boolean { return hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self); } @@ -3931,7 +3931,7 @@ export function hasRemaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): boolean { +export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): boolean { return hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self); } @@ -3954,7 +3954,7 @@ export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Cha * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain): boolean { +export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain): boolean { return hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self); } @@ -3985,7 +3985,7 @@ export function hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain< * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self: Chain): rs.usize { return remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self); } @@ -4016,7 +4016,7 @@ export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(self * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rs.usize { return remaining$bytes_Buf_buf_Pieces_buf_Provided(self); } @@ -4047,7 +4047,7 @@ export function remaining$bytes_Buf_buf_Pieces_buf_Provided_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain): rs.usize { return remaining$bytes_Buf_buf_Provided_bytes_Bytes(self); } @@ -4078,7 +4078,7 @@ export function remaining$bytes_Buf_buf_Provided_bytes_Bytes_mut(self: Chain>): rt.usize { +export function remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self: Chain>): rs.usize { return remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self); } @@ -4109,7 +4109,7 @@ export function remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8_mut(self: Chai * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain): rs.usize { return remaining$bytes_Buf_buf_Provided_ref_slice_u8(self); } @@ -4140,7 +4140,7 @@ export function remaining$bytes_Buf_buf_Provided_ref_slice_u8_mut(self: Chain>): rt.usize { +export function remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self: Chain>): rs.usize { return remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self); } @@ -4171,7 +4171,7 @@ export function remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain): rs.usize { return remaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self); } @@ -4202,7 +4202,7 @@ export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain, rt.ByteSlice>): rt.usize { +export function remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8_mut(self: Chain, rs.ByteSlice>): rs.usize { return remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self); } @@ -4233,7 +4233,7 @@ export function remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_byte * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rt.usize { +export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rs.usize { return remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self); } @@ -4264,7 +4264,7 @@ export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rt.usize { +export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(self: Chain, Pieces.Pieces>): rs.usize { return remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self); } @@ -4295,7 +4295,7 @@ export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces_mut(se * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain): rs.usize { return remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self); } @@ -4326,7 +4326,7 @@ export function remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut_mut(self: Chain< * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain): rt.usize { +export function remaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(self: Chain): rs.usize { return remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self); } @@ -4364,12 +4364,12 @@ export class Chain { } [Symbol.dispose](): void { - rt.drop(this.a); - rt.drop(this.b); + rs.drop(this.a); + rs.drop(this.b); } } -export function new$boxed_Box_dyn_bytes_Buf_bytes_Bytes(a: Buf.Buf, b: rt.ByteSlice): Chain { +export function new$boxed_Box_dyn_bytes_Buf_bytes_Bytes(a: Buf.Buf, b: rs.ByteSlice): Chain { return new Chain(a, b); } @@ -4377,43 +4377,43 @@ export function new$buf_Pieces_buf_Provided(a: Pieces.Pieces, b: Provided.Provid return new Chain(a, b); } -export function new$buf_Provided_bytes_Bytes(a: Provided.Provided, b: rt.ByteSlice): Chain { +export function new$buf_Provided_bytes_Bytes(a: Provided.Provided, b: rs.ByteSlice): Chain { return new Chain(a, b); } -export function new$buf_Provided_mut_ref_slice_u8(a: Provided.Provided, b: rt.Place): Chain> { +export function new$buf_Provided_mut_ref_slice_u8(a: Provided.Provided, b: rs.Place): Chain> { return new Chain(a, b); } -export function new$buf_Provided_ref_slice_u8(a: Provided.Provided, b: rt.ByteSlice): Chain { +export function new$buf_Provided_ref_slice_u8(a: Provided.Provided, b: rs.ByteSlice): Chain { return new Chain(a, b); } -export function new$bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(a: rt.ByteSlice, b: Chain): Chain> { +export function new$bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(a: rs.ByteSlice, b: Chain): Chain> { return new Chain(a, b); } -export function new$bytes_Bytes_ref_slice_u8(a: rt.ByteSlice, b: rt.ByteSlice): Chain { +export function new$bytes_Bytes_ref_slice_u8(a: rs.ByteSlice, b: rs.ByteSlice): Chain { return new Chain(a, b); } -export function new$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(a: Chain, b: rt.ByteSlice): Chain, rt.ByteSlice> { +export function new$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(a: Chain, b: rs.ByteSlice): Chain, rs.ByteSlice> { return new Chain(a, b); } -export function new$bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(a: Chain, b: Pieces.Pieces): Chain, Pieces.Pieces> { +export function new$bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(a: Chain, b: Pieces.Pieces): Chain, Pieces.Pieces> { return new Chain(a, b); } -export function new$bytes_buf_Take_bytes_Bytes_buf_Pieces(a: Take.Take, b: Pieces.Pieces): Chain, Pieces.Pieces> { +export function new$bytes_buf_Take_bytes_Bytes_buf_Pieces(a: Take.Take, b: Pieces.Pieces): Chain, Pieces.Pieces> { return new Chain(a, b); } -export function new$ref_slice_u8_bytes_Bytes(a: rt.ByteSlice, b: rt.ByteSlice): Chain { +export function new$ref_slice_u8_bytes_Bytes(a: rs.ByteSlice, b: rs.ByteSlice): Chain { return new Chain(a, b); } -export function new$ref_slice_u8_bytes_BytesMut(a: rt.ByteSlice, b: rt.BytesMut): Chain { +export function new$ref_slice_u8_bytes_BytesMut(a: rs.ByteSlice, b: rs.BytesMut): Chain { return new Chain(a, b); } @@ -4444,8 +4444,8 @@ export function new$ref_slice_u8_bytes_BytesMut(a: rt.ByteSlice, b: rt.BytesMut) * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a), self.b.length); +export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a), self.b.length); } /** @@ -4475,8 +4475,8 @@ export function remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Ch * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(Pieces.remaining$bytes_Buf(self.a), Provided.remaining$bytes_Buf(self.b)); +export function remaining$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(Pieces.remaining$bytes_Buf(self.a), Provided.remaining$bytes_Buf(self.b)); } /** @@ -4506,8 +4506,8 @@ export function remaining$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), self.b.length); +export function remaining$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), self.b.length); } /** @@ -4537,8 +4537,8 @@ export function remaining$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.usize { - return rt.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), remaining$bytes_Buf_mut_ref_slice_u8(self.b)); +export function remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.usize { + return rs.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), remaining$bytes_Buf_mut_ref_slice_u8(self.b)); } /** @@ -4568,8 +4568,8 @@ export function remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), self.b.length); +export function remaining$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(Provided.remaining$bytes_Buf(self.a), self.b.length); } /** @@ -4599,8 +4599,8 @@ export function remaining$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain>): rt.usize { - return rt.usizeSaturatingAdd(self.a.length, remaining$bytes_Buf_buf_Provided_ref_slice_u8(self.b)); +export function remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.usize { + return rs.usizeSaturatingAdd(self.a.length, remaining$bytes_Buf_buf_Provided_ref_slice_u8(self.b)); } /** @@ -4630,8 +4630,8 @@ export function remaining$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(self.a.length, self.b.length); +export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(self.a.length, self.b.length); } /** @@ -4661,8 +4661,8 @@ export function remaining$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.usize { - return rt.usizeSaturatingAdd(remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a), self.b.length); +export function remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.usize { + return rs.usizeSaturatingAdd(remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a), self.b.length); } /** @@ -4692,8 +4692,8 @@ export function remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_byte * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.usize { - return rt.usizeSaturatingAdd(remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a), Pieces.remaining$bytes_Buf(self.b)); +export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.usize { + return rs.usizeSaturatingAdd(remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a), Pieces.remaining$bytes_Buf(self.b)); } /** @@ -4723,8 +4723,8 @@ export function remaining$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.usize { - return rt.usizeSaturatingAdd(Take.remaining$bytes_Buf_bytes_Bytes(self.a), Pieces.remaining$bytes_Buf(self.b)); +export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.usize { + return rs.usizeSaturatingAdd(Take.remaining$bytes_Buf_bytes_Bytes(self.a), Pieces.remaining$bytes_Buf(self.b)); } /** @@ -4754,8 +4754,8 @@ export function remaining$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(self.a.length, self.b.length); +export function remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(self.a.length, self.b.length); } /** @@ -4785,8 +4785,8 @@ export function remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rt.usize { - return rt.usizeSaturatingAdd(self.a.length, self.b.length); +export function remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.usize { + return rs.usizeSaturatingAdd(self.a.length, self.b.length); } /** @@ -4819,7 +4819,7 @@ export function remaining$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain): rs.ByteSlice { if (!hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a)) { return self.b; } @@ -4856,7 +4856,7 @@ export function chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain< * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rs.ByteSlice { if (!Pieces.hasRemaining$bytes_Buf(self.a)) { return Provided.chunk$bytes_Buf(self.b); } @@ -4893,7 +4893,7 @@ export function chunk$bytes_Buf_buf_Pieces_buf_Provided(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain): rs.ByteSlice { if (!Provided.hasRemaining$bytes_Buf(self.a)) { return self.b; } @@ -4930,7 +4930,7 @@ export function chunk$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>): rs.ByteSlice { if (!Provided.hasRemaining$bytes_Buf(self.a)) { return chunk$bytes_Buf_mut_ref_slice_u8(self.b); } @@ -4967,7 +4967,7 @@ export function chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain): rs.ByteSlice { if (!Provided.hasRemaining$bytes_Buf(self.a)) { return self.b; } @@ -5004,7 +5004,7 @@ export function chunk$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>): rs.ByteSlice { if (!(self.a.length !== 0)) { return chunk$bytes_Buf_buf_Provided_ref_slice_u8(self.b); } @@ -5041,7 +5041,7 @@ export function chunk$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_sli * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain): rs.ByteSlice { if (!(self.a.length !== 0)) { return self.b; } @@ -5078,7 +5078,7 @@ export function chunk$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>): rs.ByteSlice { if (!hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a)) { return self.b; } @@ -5115,7 +5115,7 @@ export function chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.ByteSlice { if (!hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a)) { return Pieces.chunk$bytes_Buf(self.b); } @@ -5152,7 +5152,7 @@ export function chunk$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pie * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>): rs.ByteSlice { if (!Take.hasRemaining$bytes_Buf_bytes_Bytes(self.a)) { return Pieces.chunk$bytes_Buf(self.b); } @@ -5189,7 +5189,7 @@ export function chunk$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chai * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rs.ByteSlice { if (!(self.a.length !== 0)) { return self.b; } @@ -5226,9 +5226,9 @@ export function chunk$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain): rt.ByteSlice { +export function chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain): rs.ByteSlice { if (!(self.a.length !== 0)) { - return rt.bytesMutView(self.b); + return rs.bytesMutView(self.b); } return self.a; } @@ -5265,19 +5265,19 @@ export function chunk$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a); +export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { - advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(rt.place(() => self.a, (value2) => self.a = value2), aRem); - cnt = rt.usizeSub(cnt, aRem); + advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(rs.place(() => self.a, (value2) => self.a = value2), aRem); + cnt = rs.usizeSub(cnt, aRem); } else { - advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(rt.place(() => self.a, (value) => self.a = value), cnt); + advance$bytes_Buf_boxed_Box_dyn_bytes_Buf(rs.place(() => self.a, (value) => self.a = value), cnt); break b0; } } - rt.bytesAdvance(rt.place(() => self.b, (value3) => self.b = value3), cnt); + rs.bytesAdvance(rs.place(() => self.b, (value3) => self.b = value3), cnt); } } @@ -5313,13 +5313,13 @@ export function advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chai * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = Pieces.remaining$bytes_Buf(self.a); +export function advance$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = Pieces.remaining$bytes_Buf(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { Pieces.advance$bytes_Buf(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { Pieces.advance$bytes_Buf(self.a, cnt); break b0; @@ -5361,19 +5361,19 @@ export function advance$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function advance$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { Provided.advance$bytes_Buf(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { Provided.advance$bytes_Buf(self.a, cnt); break b0; } } - rt.bytesAdvance(rt.place(() => self.b, (value) => self.b = value), cnt); + rs.bytesAdvance(rs.place(() => self.b, (value) => self.b = value), cnt); } } @@ -5409,19 +5409,19 @@ export function advance$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain>, cnt: rt.usize): void { - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, cnt: rs.usize): void { + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { Provided.advance$bytes_Buf(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { Provided.advance$bytes_Buf(self.a, cnt); break b0; } } - advance$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.b, (value) => self.b = value), cnt); + advance$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.b, (value) => self.b = value), cnt); } } @@ -5457,19 +5457,19 @@ export function advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function advance$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { Provided.advance$bytes_Buf(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { Provided.advance$bytes_Buf(self.a, cnt); break b0; } } - rt.byteSliceAdvance(rt.place(() => self.b, (value) => self.b = value), cnt); + rs.byteSliceAdvance(rs.place(() => self.b, (value) => self.b = value), cnt); } } @@ -5505,15 +5505,15 @@ export function advance$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain>, cnt: rt.usize): void { - const aRem: rt.usize = self.a.length; +export function advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, cnt: rs.usize): void { + const aRem: rs.usize = self.a.length; b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { - rt.bytesAdvance(rt.place(() => self.a, (value2) => self.a = value2), aRem); - cnt = rt.usizeSub(cnt, aRem); + rs.bytesAdvance(rs.place(() => self.a, (value2) => self.a = value2), aRem); + cnt = rs.usizeSub(cnt, aRem); } else { - rt.bytesAdvance(rt.place(() => self.a, (value) => self.a = value), cnt); + rs.bytesAdvance(rs.place(() => self.a, (value) => self.a = value), cnt); break b0; } } @@ -5553,19 +5553,19 @@ export function advance$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_s * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = self.a.length; +export function advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = self.a.length; b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { - rt.bytesAdvance(rt.place(() => self.a, (value2) => self.a = value2), aRem); - cnt = rt.usizeSub(cnt, aRem); + rs.bytesAdvance(rs.place(() => self.a, (value2) => self.a = value2), aRem); + cnt = rs.usizeSub(cnt, aRem); } else { - rt.bytesAdvance(rt.place(() => self.a, (value) => self.a = value), cnt); + rs.bytesAdvance(rs.place(() => self.a, (value) => self.a = value), cnt); break b0; } } - rt.byteSliceAdvance(rt.place(() => self.b, (value3) => self.b = value3), cnt); + rs.byteSliceAdvance(rs.place(() => self.b, (value3) => self.b = value3), cnt); } } @@ -5601,19 +5601,19 @@ export function advance$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, cnt: rt.usize): void { - const aRem: rt.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a); +export function advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, cnt: rs.usize): void { + const aRem: rs.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a, cnt); break b0; } } - rt.byteSliceAdvance(rt.place(() => self.b, (value) => self.b = value), cnt); + rs.byteSliceAdvance(rs.place(() => self.b, (value) => self.b = value), cnt); } } @@ -5649,13 +5649,13 @@ export function advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_ * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, cnt: rt.usize): void { - const aRem: rt.usize = remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a); +export function advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, cnt: rs.usize): void { + const aRem: rs.usize = remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a, cnt); break b0; @@ -5697,13 +5697,13 @@ export function advance$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_P * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, cnt: rt.usize): void { - const aRem: rt.usize = Take.remaining$bytes_Buf_bytes_Bytes(self.a); +export function advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, cnt: rs.usize): void { + const aRem: rs.usize = Take.remaining$bytes_Buf_bytes_Bytes(self.a); b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { Take.advance$bytes_Buf_bytes_Bytes(self.a, aRem); - cnt = rt.usizeSub(cnt, aRem); + cnt = rs.usizeSub(cnt, aRem); } else { Take.advance$bytes_Buf_bytes_Bytes(self.a, cnt); break b0; @@ -5745,19 +5745,19 @@ export function advance$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Ch * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = self.a.length; +export function advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = self.a.length; b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { - rt.byteSliceAdvance(rt.place(() => self.a, (value2) => self.a = value2), aRem); - cnt = rt.usizeSub(cnt, aRem); + rs.byteSliceAdvance(rs.place(() => self.a, (value2) => self.a = value2), aRem); + cnt = rs.usizeSub(cnt, aRem); } else { - rt.byteSliceAdvance(rt.place(() => self.a, (value) => self.a = value), cnt); + rs.byteSliceAdvance(rs.place(() => self.a, (value) => self.a = value), cnt); break b0; } } - rt.bytesAdvance(rt.place(() => self.b, (value3) => self.b = value3), cnt); + rs.bytesAdvance(rs.place(() => self.b, (value3) => self.b = value3), cnt); } } @@ -5793,19 +5793,19 @@ export function advance$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain, cnt: rt.usize): void { - const aRem: rt.usize = self.a.length; +export function advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, cnt: rs.usize): void { + const aRem: rs.usize = self.a.length; b0: { if (aRem !== 0) { if (!(aRem >= cnt)) { - rt.byteSliceAdvance(rt.place(() => self.a, (value2) => self.a = value2), aRem); - cnt = rt.usizeSub(cnt, aRem); + rs.byteSliceAdvance(rs.place(() => self.a, (value2) => self.a = value2), aRem); + cnt = rs.usizeSub(cnt, aRem); } else { - rt.byteSliceAdvance(rt.place(() => self.a, (value) => self.a = value), cnt); + rs.byteSliceAdvance(rs.place(() => self.a, (value) => self.a = value), cnt); break b0; } } - rt.bytesMutAdvance(self.b, cnt); + rs.bytesMutAdvance(self.b, cnt); } } @@ -5830,25 +5830,25 @@ export function advance$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a); +export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: rt.place(() => self.a, (value3) => self.a = value3) }, (p: rt.Place>) => hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), (p: rt.Place>) => remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), (p: rt.Place>) => chunk$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), advance$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rt.place(() => self.b, (value4) => self.b = value4), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: rs.place(() => self.a, (value3) => self.a = value3) }, (p: rs.Place>) => hasRemaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), (p: rs.Place>) => remaining$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), (p: rs.Place>) => chunk$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf(p.v), advance$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_mut_boxed_Box_dyn_bytes_Buf); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rs.place(() => self.b, (value4) => self.b = value4), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); + return rs.bytesMutFreeze(ret); } - return rt.bytesSplitTo(rt.place(() => self.b, (value2) => self.b = value2), len); + return rs.bytesSplitTo(rs.place(() => self.b, (value2) => self.b = value2), len); } - return copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(rt.place(() => self.a, (value) => self.a = value), len); + return copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf(rs.place(() => self.a, (value) => self.a = value), len); } /** @@ -5872,22 +5872,22 @@ export function copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self: * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = Pieces.remaining$bytes_Buf(self.a); +export function copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = Pieces.remaining$bytes_Buf(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= Provided.remaining$bytes_Buf(self.b))) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= Provided.remaining$bytes_Buf(self.b))) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined, Pieces.copyToBytes$bytes_Buf_mut); - const _22: Take.Take = Provided.take$bytes_Buf_mut(self.b, rt.usizeSub(len, aRem)); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Provided, Take.remaining$bytes_Buf_mut_buf_Provided, Take.chunk$bytes_Buf_mut_buf_Provided, Take.advance$bytes_Buf_mut_buf_Provided as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Provided); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place) => Pieces.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Pieces.chunk$bytes_Buf_mut(p.v), Pieces.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined, Pieces.copyToBytes$bytes_Buf_mut); + const _22: Take.Take = Provided.take$bytes_Buf_mut(self.b, rs.usizeSub(len, aRem)); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Provided, Take.remaining$bytes_Buf_mut_buf_Provided, Take.chunk$bytes_Buf_mut_buf_Provided, Take.advance$bytes_Buf_mut_buf_Provided as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Provided); + return rs.bytesMutFreeze(ret); } - return rt.bufCopyToBytes(self.b, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + return rs.bufCopyToBytes(self.b, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } return Pieces.copyToBytes$bytes_Buf(self.a, len); } @@ -5913,25 +5913,25 @@ export function copyToBytes$bytes_Buf_buf_Pieces_buf_Provided(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rt.place(() => self.b, (value2) => self.b = value2), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rs.place(() => self.b, (value2) => self.b = value2), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); + return rs.bytesMutFreeze(ret); } - return rt.bytesSplitTo(rt.place(() => self.b, (value) => self.b = value), len); + return rs.bytesSplitTo(rs.place(() => self.b, (value) => self.b = value), len); } - return rt.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + return rs.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } /** @@ -5955,25 +5955,25 @@ export function copyToBytes$bytes_Buf_buf_Provided_bytes_Bytes(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function copyToBytes$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain>, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= remaining$bytes_Buf_mut_ref_slice_u8(self.b))) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= remaining$bytes_Buf_mut_ref_slice_u8(self.b))) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take>> = buf_impl_take$bytes_Buf_mut_mut_ref_slice_u8(rt.place(() => self.b, (value2) => self.b = value2), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_mut_ref_slice_u8 as (a0: Take.Take>>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_mut_ref_slice_u8); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take>> = buf_impl_take$bytes_Buf_mut_mut_ref_slice_u8(rs.place(() => self.b, (value2) => self.b = value2), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_mut_ref_slice_u8 as (a0: Take.Take>>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_mut_ref_slice_u8); + return rs.bytesMutFreeze(ret); } - return copyToBytes$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.b, (value) => self.b = value), len); + return copyToBytes$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.b, (value) => self.b = value), len); } - return rt.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + return rs.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } /** @@ -5997,25 +5997,25 @@ export function copyToBytes$bytes_Buf_buf_Provided_mut_ref_slice_u8(self: Chain< * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = Provided.remaining$bytes_Buf(self.a); +export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = Provided.remaining$bytes_Buf(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rt.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rt.Place, a1: rt.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.b, (value2) => self.b = value2), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place) => Provided.hasRemaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.remaining$bytes_Buf_mut(p.v), (p: rs.Place) => Provided.chunk$bytes_Buf_mut(p.v), Provided.advance$bytes_Buf_mut as (a0: rs.Place, a1: rs.usize) => undefined, Provided.copyToBytes$bytes_Buf_mut); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.b, (value2) => self.b = value2), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); + return rs.bytesMutFreeze(ret); } - return rt.byteSliceCopyToBytes(rt.place(() => self.b, (value) => self.b = value), len); + return rs.byteSliceCopyToBytes(rs.place(() => self.b, (value) => self.b = value), len); } - return rt.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + return rs.bufCopyToBytes(self.a, len, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } /** @@ -6039,24 +6039,24 @@ export function copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = self.a.length; +export function copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Chain>, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = self.a.length; if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= remaining$bytes_Buf_buf_Provided_ref_slice_u8(self.b))) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= remaining$bytes_Buf_buf_Provided_ref_slice_u8(self.b))) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: rt.place(() => self.a, (value2) => self.a = value2) }, (p: rt.Place>) => hasRemaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rt.Place>) => remaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rt.Place>) => chunk$bytes_Buf_mut_bytes_Bytes(p.v), advance$bytes_Buf_mut_bytes_Bytes as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_mut_bytes_Bytes); - const _22: Take.Take> = take$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.b, rt.usizeSub(len, aRem)); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.chunk$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.advance$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: rs.place(() => self.a, (value2) => self.a = value2) }, (p: rs.Place>) => hasRemaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rs.Place>) => remaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rs.Place>) => chunk$bytes_Buf_mut_bytes_Bytes(p.v), advance$bytes_Buf_mut_bytes_Bytes as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_mut_bytes_Bytes); + const _22: Take.Take> = take$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.b, rs.usizeSub(len, aRem)); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.chunk$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8, Take.advance$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8 as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8); + return rs.bytesMutFreeze(ret); } return copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8(self.b, len); } - return rt.bytesSplitTo(rt.place(() => self.a, (value) => self.a = value), len); + return rs.bytesSplitTo(rs.place(() => self.a, (value) => self.a = value), len); } /** @@ -6080,25 +6080,25 @@ export function copyToBytes$bytes_Buf_bytes_Bytes_bytes_buf_Chain_buf_Provided_r * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = self.a.length; +export function copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = self.a.length; if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: rt.place(() => self.a, (value3) => self.a = value3) }, (p: rt.Place>) => hasRemaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rt.Place>) => remaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rt.Place>) => chunk$bytes_Buf_mut_bytes_Bytes(p.v), advance$bytes_Buf_mut_bytes_Bytes as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_mut_bytes_Bytes); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.b, (value4) => self.b = value4), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: rs.place(() => self.a, (value3) => self.a = value3) }, (p: rs.Place>) => hasRemaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rs.Place>) => remaining$bytes_Buf_mut_bytes_Bytes(p.v), (p: rs.Place>) => chunk$bytes_Buf_mut_bytes_Bytes(p.v), advance$bytes_Buf_mut_bytes_Bytes as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_mut_bytes_Bytes); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.b, (value4) => self.b = value4), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); + return rs.bytesMutFreeze(ret); } - return rt.byteSliceCopyToBytes(rt.place(() => self.b, (value2) => self.b = value2), len); + return rs.byteSliceCopyToBytes(rs.place(() => self.b, (value2) => self.b = value2), len); } - return rt.bytesSplitTo(rt.place(() => self.a, (value) => self.a = value), len); + return rs.bytesSplitTo(rs.place(() => self.a, (value) => self.a = value), len); } /** @@ -6122,23 +6122,23 @@ export function copyToBytes$bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rt.ByteSlice>, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a); +export function copyToBytes$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(self: Chain, rs.ByteSlice>, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place>) => hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), (p: rt.Place>) => remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), (p: rt.Place>) => chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.b, (value2) => self.b = value2), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place>) => hasRemaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), (p: rs.Place>) => remaining$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), (p: rs.Place>) => chunk$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut(p.v), advance$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes_mut); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.b, (value2) => self.b = value2), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_ref_slice_u8, Take.remaining$bytes_Buf_mut_ref_slice_u8, Take.chunk$bytes_Buf_mut_ref_slice_u8, Take.advance$bytes_Buf_mut_ref_slice_u8 as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_ref_slice_u8); + return rs.bytesMutFreeze(ret); } - return rt.byteSliceCopyToBytes(rt.place(() => self.b, (value) => self.b = value), len); + return rs.byteSliceCopyToBytes(rs.place(() => self.b, (value) => self.b = value), len); } return copyToBytes$bytes_Buf_boxed_Box_dyn_bytes_Buf_bytes_Bytes(self.a, len); } @@ -6164,20 +6164,20 @@ export function copyToBytes$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_by * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a); +export function copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = remaining$bytes_Buf_ref_slice_u8_bytes_Bytes(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= Pieces.remaining$bytes_Buf(self.b))) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= Pieces.remaining$bytes_Buf(self.b))) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place>) => hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), (p: rt.Place>) => remaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), (p: rt.Place>) => chunk$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), advance$bytes_Buf_ref_slice_u8_bytes_Bytes_mut as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes_mut); - const _22: Take.Take = Pieces.take$bytes_Buf_mut(self.b, rt.usizeSub(len, aRem)); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Pieces, Take.remaining$bytes_Buf_mut_buf_Pieces, Take.chunk$bytes_Buf_mut_buf_Pieces, Take.advance$bytes_Buf_mut_buf_Pieces as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Pieces); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place>) => hasRemaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), (p: rs.Place>) => remaining$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), (p: rs.Place>) => chunk$bytes_Buf_ref_slice_u8_bytes_Bytes_mut(p.v), advance$bytes_Buf_ref_slice_u8_bytes_Bytes_mut as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes_mut); + const _22: Take.Take = Pieces.take$bytes_Buf_mut(self.b, rs.usizeSub(len, aRem)); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Pieces, Take.remaining$bytes_Buf_mut_buf_Pieces, Take.chunk$bytes_Buf_mut_buf_Pieces, Take.advance$bytes_Buf_mut_buf_Pieces as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Pieces); + return rs.bytesMutFreeze(ret); } return Pieces.copyToBytes$bytes_Buf(self.b, len); } @@ -6205,20 +6205,20 @@ export function copyToBytes$bytes_Buf_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_b * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = Take.remaining$bytes_Buf_bytes_Bytes(self.a); +export function copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self: Chain, Pieces.Pieces>, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = Take.remaining$bytes_Buf_bytes_Bytes(self.a); if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= Pieces.remaining$bytes_Buf(self.b))) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= Pieces.remaining$bytes_Buf(self.b))) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: self.a }, (p: rt.Place>) => Take.hasRemaining$bytes_Buf_bytes_Bytes_mut(p.v), (p: rt.Place>) => Take.remaining$bytes_Buf_bytes_Bytes_mut(p.v), (p: rt.Place>) => Take.chunk$bytes_Buf_bytes_Bytes_mut(p.v), Take.advance$bytes_Buf_bytes_Bytes_mut as (a0: rt.Place>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_bytes_Bytes_mut); - const _22: Take.Take = Pieces.take$bytes_Buf_mut(self.b, rt.usizeSub(len, aRem)); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Pieces, Take.remaining$bytes_Buf_mut_buf_Pieces, Take.chunk$bytes_Buf_mut_buf_Pieces, Take.advance$bytes_Buf_mut_buf_Pieces as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Pieces); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: self.a }, (p: rs.Place>) => Take.hasRemaining$bytes_Buf_bytes_Bytes_mut(p.v), (p: rs.Place>) => Take.remaining$bytes_Buf_bytes_Bytes_mut(p.v), (p: rs.Place>) => Take.chunk$bytes_Buf_bytes_Bytes_mut(p.v), Take.advance$bytes_Buf_bytes_Bytes_mut as (a0: rs.Place>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_bytes_Bytes_mut); + const _22: Take.Take = Pieces.take$bytes_Buf_mut(self.b, rs.usizeSub(len, aRem)); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_buf_Pieces, Take.remaining$bytes_Buf_mut_buf_Pieces, Take.chunk$bytes_Buf_mut_buf_Pieces, Take.advance$bytes_Buf_mut_buf_Pieces as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_buf_Pieces); + return rs.bytesMutFreeze(ret); } return Pieces.copyToBytes$bytes_Buf(self.b, len); } @@ -6246,25 +6246,25 @@ export function copyToBytes$bytes_Buf_bytes_buf_Take_bytes_Bytes_buf_Pieces(self * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = self.a.length; +export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = self.a.length; if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: rt.place(() => self.a, (value3) => self.a = value3) }, (p: rt.Place>) => hasRemaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rt.Place>) => remaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rt.Place>) => chunk$bytes_Buf_mut_ref_slice_u8(p.v), advance$bytes_Buf_mut_ref_slice_u8 as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_mut_ref_slice_u8); - const _24: rt.usize = rt.usizeSub(len, aRem); - const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rt.place(() => self.b, (value4) => self.b = value4), _24); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: rs.place(() => self.a, (value3) => self.a = value3) }, (p: rs.Place>) => hasRemaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rs.Place>) => remaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rs.Place>) => chunk$bytes_Buf_mut_ref_slice_u8(p.v), advance$bytes_Buf_mut_ref_slice_u8 as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_mut_ref_slice_u8); + const _24: rs.usize = rs.usizeSub(len, aRem); + const _22: Take.Take> = buf_impl_take$bytes_Buf_mut_bytes_Bytes(rs.place(() => self.b, (value4) => self.b = value4), _24); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_Bytes, Take.remaining$bytes_Buf_mut_bytes_Bytes, Take.chunk$bytes_Buf_mut_bytes_Bytes, Take.advance$bytes_Buf_mut_bytes_Bytes as (a0: Take.Take>, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_Bytes); + return rs.bytesMutFreeze(ret); } - return rt.bytesSplitTo(rt.place(() => self.b, (value2) => self.b = value2), len); + return rs.bytesSplitTo(rs.place(() => self.b, (value2) => self.b = value2), len); } - return rt.byteSliceCopyToBytes(rt.place(() => self.a, (value) => self.a = value), len); + return rs.byteSliceCopyToBytes(rs.place(() => self.a, (value) => self.a = value), len); } /** @@ -6288,24 +6288,24 @@ export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_Bytes(self: Chain self.remaining()`. */ -export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, len: rt.usize): rt.ByteSlice { - let _0!: rt.ByteSlice; - const aRem: rt.usize = self.a.length; +export function copyToBytes$bytes_Buf_ref_slice_u8_bytes_BytesMut(self: Chain, len: rs.usize): rs.ByteSlice { + let _0!: rs.ByteSlice; + const aRem: rs.usize = self.a.length; if (!(aRem >= len)) { if (!(aRem === 0)) { - if (!(rt.usizeSub(len, aRem) <= self.b.length)) { - rt.panicFmt(["`len` greater than remaining"]); + if (!(rs.usizeSub(len, aRem) <= self.b.length)) { + rs.panicFmt(["`len` greater than remaining"]); return _0; } - const ret: rt.BytesMut = rt.bytesMutWithCapacity(len); - rt.bytesMutPutBuf(ret, { v: rt.place(() => self.a, (value2) => self.a = value2) }, (p: rt.Place>) => hasRemaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rt.Place>) => remaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rt.Place>) => chunk$bytes_Buf_mut_ref_slice_u8(p.v), advance$bytes_Buf_mut_ref_slice_u8 as (a0: rt.Place>, a1: rt.usize) => undefined, copyToBytes$bytes_Buf_mut_ref_slice_u8); - const _22: Take.Take = buf_impl_take$bytes_Buf_mut_bytes_BytesMut(self.b, rt.usizeSub(len, aRem)); - rt.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_BytesMut, Take.remaining$bytes_Buf_mut_bytes_BytesMut, Take.chunk$bytes_Buf_mut_bytes_BytesMut, Take.advance$bytes_Buf_mut_bytes_BytesMut as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_BytesMut); - return rt.bytesMutFreeze(ret); + const ret: rs.BytesMut = rs.bytesMutWithCapacity(len); + rs.bytesMutPutBuf(ret, { v: rs.place(() => self.a, (value2) => self.a = value2) }, (p: rs.Place>) => hasRemaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rs.Place>) => remaining$bytes_Buf_mut_ref_slice_u8(p.v), (p: rs.Place>) => chunk$bytes_Buf_mut_ref_slice_u8(p.v), advance$bytes_Buf_mut_ref_slice_u8 as (a0: rs.Place>, a1: rs.usize) => undefined, copyToBytes$bytes_Buf_mut_ref_slice_u8); + const _22: Take.Take = buf_impl_take$bytes_Buf_mut_bytes_BytesMut(self.b, rs.usizeSub(len, aRem)); + rs.bytesMutPutBuf(ret, _22, Take.hasRemaining$bytes_Buf_mut_bytes_BytesMut, Take.remaining$bytes_Buf_mut_bytes_BytesMut, Take.chunk$bytes_Buf_mut_bytes_BytesMut, Take.advance$bytes_Buf_mut_bytes_BytesMut as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToBytes$bytes_Buf_mut_bytes_BytesMut); + return rs.bytesMutFreeze(ret); } - return rt.bytesMutFreeze(rt.bytesMutSplitTo(self.b, len)); + return rs.bytesMutFreeze(rs.bytesMutSplitTo(self.b, len)); } - return rt.byteSliceCopyToBytes(rt.place(() => self.a, (value) => self.a = value), len); + return rs.byteSliceCopyToBytes(rs.place(() => self.a, (value) => self.a = value), len); } //# sourceMappingURL=chain.Chain.ts.map diff --git a/ts/fixtures/stock/expected/bytes/buf/take.Take.ts b/ts/fixtures/stock/expected/bytes/buf/take.Take.ts index 188b4eef8..9f079a887 100644 --- a/ts/fixtures/stock/expected/bytes/buf/take.Take.ts +++ b/ts/fixtures/stock/expected/bytes/buf/take.Take.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import { out$u8 } from "../../lib.ts"; import * as Pieces from "../../buf.Pieces.ts"; import * as Provided from "../../buf.Provided.ts"; @@ -8,8 +8,8 @@ import { panicAdvance, panicDoesNotFit } from "../../bytes.ts"; import { signExtend, advance$bytes_Buf_mut_bytes_Bytes as buf_impl_advance$bytes_Buf_mut_bytes_Bytes, advance$bytes_Buf_mut_bytes_BytesMut as buf_impl_advance$bytes_Buf_mut_bytes_BytesMut, advance$bytes_Buf_mut_mut_ref_slice_u8 as buf_impl_advance$bytes_Buf_mut_mut_ref_slice_u8, advance$bytes_Buf_mut_ref_slice_u8 as buf_impl_advance$bytes_Buf_mut_ref_slice_u8, chunk$bytes_Buf_mut_bytes_Bytes as buf_impl_chunk$bytes_Buf_mut_bytes_Bytes, chunk$bytes_Buf_mut_bytes_BytesMut as buf_impl_chunk$bytes_Buf_mut_bytes_BytesMut, chunk$bytes_Buf_mut_mut_ref_slice_u8 as buf_impl_chunk$bytes_Buf_mut_mut_ref_slice_u8, chunk$bytes_Buf_mut_ref_slice_u8 as buf_impl_chunk$bytes_Buf_mut_ref_slice_u8, copyToBytes$bytes_Buf_mut_bytes_Bytes as buf_impl_copyToBytes$bytes_Buf_mut_bytes_Bytes, copyToBytes$bytes_Buf_mut_bytes_BytesMut as buf_impl_copyToBytes$bytes_Buf_mut_bytes_BytesMut, copyToBytes$bytes_Buf_mut_mut_ref_slice_u8 as buf_impl_copyToBytes$bytes_Buf_mut_mut_ref_slice_u8, copyToBytes$bytes_Buf_mut_ref_slice_u8 as buf_impl_copyToBytes$bytes_Buf_mut_ref_slice_u8, remaining$bytes_Buf_mut_bytes_Bytes as buf_impl_remaining$bytes_Buf_mut_bytes_Bytes, remaining$bytes_Buf_mut_bytes_BytesMut as buf_impl_remaining$bytes_Buf_mut_bytes_BytesMut, remaining$bytes_Buf_mut_mut_ref_slice_u8 as buf_impl_remaining$bytes_Buf_mut_mut_ref_slice_u8, remaining$bytes_Buf_mut_ref_slice_u8 as buf_impl_remaining$bytes_Buf_mut_ref_slice_u8 } from "../../bytes/buf/buf_impl.ts"; import * as Chain from "../../bytes/buf/chain.Chain.ts"; import type * as TryGetError from "../../bytes.TryGetError.ts"; -import { min$0wa4xqw } from "../../core/cmp.ts"; -import { unwrapOrElse$1wp5sd9 as result_unwrapOrElse$1wp5sd9, unwrapOrElse$0s2lrc9 as result_unwrapOrElse$0s2lrc9 } from "../../core/result.ts"; +import { min$00xoube } from "../../core/cmp.ts"; +import { unwrapOrElse$1b4ownx as result_unwrapOrElse$1b4ownx, unwrapOrElse$1fg63zn as result_unwrapOrElse$1fg63zn } from "../../core/result.ts"; /** * Returns true if there are any more bytes to consume @@ -30,7 +30,7 @@ import { unwrapOrElse$1wp5sd9 as result_unwrapOrElse$1wp5sd9, unwrapOrElse$0s2lr * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_bytes_Bytes(self: Take): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes(self: Take): boolean { return remaining$bytes_Buf_bytes_Bytes(self) > 0; } @@ -99,7 +99,7 @@ export function hasRemaining$bytes_Buf_mut_buf_Provided(self: Take>): boolean { +export function hasRemaining$bytes_Buf_mut_bytes_Bytes(self: Take>): boolean { return remaining$bytes_Buf_mut_bytes_Bytes(self) > 0; } @@ -122,7 +122,7 @@ export function hasRemaining$bytes_Buf_mut_bytes_Bytes(self: Take): boolean { +export function hasRemaining$bytes_Buf_mut_bytes_BytesMut(self: Take): boolean { return remaining$bytes_Buf_mut_bytes_BytesMut(self) > 0; } @@ -145,7 +145,7 @@ export function hasRemaining$bytes_Buf_mut_bytes_BytesMut(self: Take>): boolean { +export function hasRemaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>): boolean { return remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self) > 0; } @@ -168,7 +168,7 @@ export function hasRemaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slic * assert!(!buf.has_remaining()); * ``` */ -export function hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): boolean { +export function hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): boolean { return remaining$bytes_Buf_mut_mut_ref_slice_u8(self) > 0; } @@ -191,7 +191,7 @@ export function hasRemaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>): boolean { +export function hasRemaining$bytes_Buf_mut_ref_slice_u8(self: Take>): boolean { return remaining$bytes_Buf_mut_ref_slice_u8(self) > 0; } @@ -214,7 +214,7 @@ export function hasRemaining$bytes_Buf_mut_ref_slice_u8(self: Take): boolean { +export function hasRemaining$bytes_Buf_ref_slice_u8(self: Take): boolean { return remaining$bytes_Buf_ref_slice_u8(self) > 0; } @@ -241,8 +241,8 @@ export function hasRemaining$bytes_Buf_ref_slice_u8(self: Take): b * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_bytes_Bytes(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -270,8 +270,8 @@ export function copyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: * * This function panics if `self.remaining() < dst.len()`. */ -export function copyToSlice$bytes_Buf_ref_slice_u8(self: Take, dst: rt.ByteSlice): void { - result_unwrapOrElse$0s2lrc9(tryCopyToSlice$bytes_Buf_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { +export function copyToSlice$bytes_Buf_ref_slice_u8(self: Take, dst: rs.ByteSlice): void { + result_unwrapOrElse$1fg63zn(tryCopyToSlice$bytes_Buf_ref_slice_u8(self, dst), (error: TryGetError.TryGetError): undefined => { panicAdvance(error); }); } @@ -294,11 +294,11 @@ export function copyToSlice$bytes_Buf_ref_slice_u8(self: Take, dst * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_bytes_Bytes(self: Take): rt.u8 { +export function getU8$bytes_Buf_bytes_Bytes(self: Take): rs.u8 { if (!(remaining$bytes_Buf_bytes_Bytes_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_bytes_Bytes(self, 1); return ret; } @@ -323,11 +323,11 @@ export function getU8$bytes_Buf_bytes_Bytes(self: Take): rt.u8 { * * This function panics if there is no more remaining data in `self`. */ -export function getU8$bytes_Buf_ref_slice_u8(self: Take): rt.u8 { +export function getU8$bytes_Buf_ref_slice_u8(self: Take): rs.u8 { if (!(remaining$bytes_Buf_ref_slice_u8_mut(self) < 1)) { - const _7: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); - rt.idx(_7, 0); - const ret: rt.u8 = _7.data[_7.start]; + const _7: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); + rs.idx(_7, 0); + const ret: rs.u8 = _7.data[_7.start]; advance$bytes_Buf_ref_slice_u8(self, 1); return ret; } @@ -352,11 +352,11 @@ export function getU8$bytes_Buf_ref_slice_u8(self: Take): rt.u8 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_bytes_Bytes(self: Take): rt.i8 { +export function getI8$bytes_Buf_bytes_Bytes(self: Take): rs.i8 { if (!(remaining$bytes_Buf_bytes_Bytes_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_bytes_Bytes(self, 1); return ret; } @@ -381,11 +381,11 @@ export function getI8$bytes_Buf_bytes_Bytes(self: Take): rt.i8 { * * This function panics if there is no more remaining data in `self`. */ -export function getI8$bytes_Buf_ref_slice_u8(self: Take): rt.i8 { +export function getI8$bytes_Buf_ref_slice_u8(self: Take): rs.i8 { if (!(remaining$bytes_Buf_ref_slice_u8_mut(self) < 1)) { - const _8: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); - rt.idx(_8, 0); - const ret: rt.i8 = (_8.data[_8.start] << 24) >> 24; + const _8: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); + rs.idx(_8, 0); + const ret: rs.i8 = (_8.data[_8.start] << 24) >> 24; advance$bytes_Buf_ref_slice_u8(self, 1); return ret; } @@ -411,21 +411,21 @@ export function getI8$bytes_Buf_ref_slice_u8(self: Take): rt.i8 { * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_bytes_Bytes(self: Take, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_bytes_Bytes(self: Take, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -449,21 +449,21 @@ export function getUint$bytes_Buf_bytes_Bytes(self: Take, nbytes: * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUint$bytes_Buf_ref_slice_u8(self: Take, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const _2: rt.usize | undefined = rt.usizeCheckedSub(8, nbytes); +export function getUint$bytes_Buf_ref_slice_u8(self: Take, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const _2: rs.usize | undefined = rs.usizeCheckedSub(8, nbytes); if (_2 === undefined) { panicDoesNotFit(8, nbytes); } else { - const sliceAt: rt.usize = _2; - const buf: Uint8Array = rt.bytes(8); - const _9: rt.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8(self, rt.byteSliceRange(rt.byteSliceFrom(buf), sliceAt)); + const sliceAt: rs.usize = _2; + const buf: Uint8Array = rs.bytes(8); + const _9: rs.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8(self, rs.byteSliceRange(rs.byteSliceFrom(buf), sliceAt)); if (_9.ok) { - return rt.Ok(rt.u64FromBeBytes(buf)); + return rs.Ok(rs.u64FromBeBytes(buf)); } return _9; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -487,20 +487,20 @@ export function getUint$bytes_Buf_ref_slice_u8(self: Take, nbytes: * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_bytes_Bytes(self: Take, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_bytes_Bytes(self: Take, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_bytes_Bytes(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -524,20 +524,20 @@ export function getUintLe$bytes_Buf_bytes_Bytes(self: Take, nbytes * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getUintLe$bytes_Buf_ref_slice_u8(self: Take, nbytes: rt.usize): rt.u64 { - return result_unwrapOrElse$1wp5sd9(((): rt.Result => { - const buf: Uint8Array = rt.bytes(8); - const _32: rt.ByteSlice | undefined = rt.byteSliceGetRange(rt.byteSliceFrom(buf), 0, nbytes); +export function getUintLe$bytes_Buf_ref_slice_u8(self: Take, nbytes: rs.usize): rs.u64 { + return result_unwrapOrElse$1b4ownx(((): rs.Result => { + const buf: Uint8Array = rs.bytes(8); + const _32: rs.ByteSlice | undefined = rs.byteSliceGetRange(rs.byteSliceFrom(buf), 0, nbytes); if (_32 === undefined) { panicDoesNotFit(8, nbytes); } else { - const _12: rt.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8(self, _32); + const _12: rs.Result = tryCopyToSlice$bytes_Buf_ref_slice_u8(self, _32); if (_12.ok) { - return rt.Ok(rt.u64FromBeBytes(buf.slice().reverse())); + return rs.Ok(rs.u64FromBeBytes(buf.slice().reverse())); } return _12; } - })(), (error: TryGetError.TryGetError): rt.u64 => { + })(), (error: TryGetError.TryGetError): rs.u64 => { panicAdvance(error); }); } @@ -561,7 +561,7 @@ export function getUintLe$bytes_Buf_ref_slice_u8(self: Take, nbyte * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_bytes_Bytes(self: Take, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_bytes_Bytes(self: Take, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_bytes_Bytes(self, nbytes), nbytes); } @@ -584,7 +584,7 @@ export function getIntLe$bytes_Buf_bytes_Bytes(self: Take, nbytes: * This function panics if there is not enough remaining data in `self`, or * if `nbytes` is greater than 8. */ -export function getIntLe$bytes_Buf_ref_slice_u8(self: Take, nbytes: rt.usize): rt.i64 { +export function getIntLe$bytes_Buf_ref_slice_u8(self: Take, nbytes: rs.usize): rs.i64 { return signExtend(getUintLe$bytes_Buf_ref_slice_u8(self, nbytes), nbytes); } @@ -607,8 +607,8 @@ export function getIntLe$bytes_Buf_ref_slice_u8(self: Take, nbytes * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_bytes_Bytes(self: Take): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes, chunk$bytes_Buf_bytes_Bytes, advance$bytes_Buf_bytes_Bytes as (a0: Take, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_bytes_Bytes(self: Take): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_bytes_Bytes, chunk$bytes_Buf_bytes_Bytes, advance$bytes_Buf_bytes_Bytes as (a0: Take, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take, a1: rs.ByteSlice) => undefined)); } /** @@ -630,8 +630,8 @@ export function getF32Le$bytes_Buf_bytes_Bytes(self: Take): rt.f32 * * This function panics if there is not enough remaining data in `self`. */ -export function getF32Le$bytes_Buf_ref_slice_u8(self: Take): rt.f32 { - return rt.f32FromBits(rt.bufGet(self, 4, true, rt.u32FromBeBytes, remaining$bytes_Buf_ref_slice_u8, chunk$bytes_Buf_ref_slice_u8, advance$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rt.ByteSlice) => undefined)); +export function getF32Le$bytes_Buf_ref_slice_u8(self: Take): rs.f32 { + return rs.f32FromBits(rs.bufGet(self, 4, true, rs.u32FromBeBytes, remaining$bytes_Buf_ref_slice_u8, chunk$bytes_Buf_ref_slice_u8, advance$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rs.ByteSlice) => undefined)); } /** @@ -653,8 +653,8 @@ export function getF32Le$bytes_Buf_ref_slice_u8(self: Take): rt.f3 * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_bytes_Bytes(self: Take): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes, chunk$bytes_Buf_bytes_Bytes, advance$bytes_Buf_bytes_Bytes as (a0: Take, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_bytes_Bytes(self: Take): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_bytes_Bytes, chunk$bytes_Buf_bytes_Bytes, advance$bytes_Buf_bytes_Bytes as (a0: Take, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take, a1: rs.ByteSlice) => undefined)); } /** @@ -676,8 +676,8 @@ export function getF64$bytes_Buf_bytes_Bytes(self: Take): rt.f64 { * * This function panics if there is not enough remaining data in `self`. */ -export function getF64$bytes_Buf_ref_slice_u8(self: Take): rt.f64 { - return rt.f64FromBits(rt.bufGet(self, 8, false, rt.u64FromBeBytes, remaining$bytes_Buf_ref_slice_u8, chunk$bytes_Buf_ref_slice_u8, advance$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rt.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rt.ByteSlice) => undefined)); +export function getF64$bytes_Buf_ref_slice_u8(self: Take): rs.f64 { + return rs.f64FromBits(rs.bufGet(self, 8, false, rs.u64FromBeBytes, remaining$bytes_Buf_ref_slice_u8, chunk$bytes_Buf_ref_slice_u8, advance$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rs.usize) => undefined, copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take, a1: rs.ByteSlice) => undefined)); } /** @@ -712,18 +712,18 @@ export function getF64$bytes_Buf_ref_slice_u8(self: Take): rt.f64 * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_bytes_Bytes_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_bytes_Bytes(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_bytes_Bytes_mut(self) }); } /** @@ -758,18 +758,18 @@ export function tryCopyToSlice$bytes_Buf_bytes_Bytes(self: Take, d * assert_eq!(11, buf.remaining()); * ``` */ -export function tryCopyToSlice$bytes_Buf_ref_slice_u8(self: Take, dst: rt.ByteSlice): rt.Result { +export function tryCopyToSlice$bytes_Buf_ref_slice_u8(self: Take, dst: rs.ByteSlice): rs.Result { if (!(remaining$bytes_Buf_ref_slice_u8_mut(self) < dst.length)) { while (!(dst.length === 0)) { - const src: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); - const cnt: rt.usize = rt.min(src.length, dst.length); - rt.byteSliceCopyFromSlice(rt.byteSliceRange(dst, 0, cnt), rt.byteSliceRange(src, 0, cnt)); - dst = rt.byteSliceRange(dst, cnt); + const src: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); + const cnt: rs.usize = rs.min(src.length, dst.length); + rs.byteSliceCopyFromSlice(rs.byteSliceRange(dst, 0, cnt), rs.byteSliceRange(src, 0, cnt)); + dst = rs.byteSliceRange(dst, cnt); advance$bytes_Buf_ref_slice_u8(self, cnt); } - return rt.OK; + return rs.OK; } - return rt.Err({ requested: dst.length, available: remaining$bytes_Buf_ref_slice_u8_mut(self) }); + return rs.Err({ requested: dst.length, available: remaining$bytes_Buf_ref_slice_u8_mut(self) }); } /** @@ -797,11 +797,11 @@ export function tryCopyToSlice$bytes_Buf_ref_slice_u8(self: Take, * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_bytes_Bytes(self: Take): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_bytes_Bytes(self: Take): rs.u8 | undefined { if (!(remaining$bytes_Buf_bytes_Bytes_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_bytes_Bytes_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_bytes_Bytes(self, 1); return ret; } @@ -834,11 +834,11 @@ export function tryGetU8$bytes_Buf_bytes_Bytes(self: Take): rt.u8 * assert_eq!(Err(TryGetError{requested: 1, available: 0}), buf.try_get_u8()); * ``` */ -export function tryGetU8$bytes_Buf_ref_slice_u8(self: Take): rt.u8 | undefined { +export function tryGetU8$bytes_Buf_ref_slice_u8(self: Take): rs.u8 | undefined { if (!(remaining$bytes_Buf_ref_slice_u8_mut(self) < 1)) { - const _9: rt.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); - rt.idx(_9, 0); - const ret: rt.u8 = _9.data[_9.start]; + const _9: rs.ByteSlice = chunk$bytes_Buf_ref_slice_u8_mut(self); + rs.idx(_9, 0); + const ret: rs.u8 = _9.data[_9.start]; advance$bytes_Buf_ref_slice_u8(self, 1); return ret; } @@ -863,7 +863,7 @@ export function tryGetU8$bytes_Buf_ref_slice_u8(self: Take): rt.u8 * assert_eq!(full.chunk(), b"hello world"); * ``` */ -export function chain$bytes_Buf_bytes_Bytes_buf_Pieces(self: Take, next: Pieces.Pieces): Chain.Chain, Pieces.Pieces> { +export function chain$bytes_Buf_bytes_Bytes_buf_Pieces(self: Take, next: Pieces.Pieces): Chain.Chain, Pieces.Pieces> { return Chain.new$bytes_buf_Take_bytes_Bytes_buf_Pieces(self, next); } @@ -899,7 +899,7 @@ export function chain$bytes_Buf_bytes_Bytes_buf_Pieces(self: Take, * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_Bytes_mut(self: rt.Place>, cnt: rt.usize): void { +export function advance$bytes_Buf_bytes_Bytes_mut(self: rs.Place>, cnt: rs.usize): void { advance$bytes_Buf_bytes_Bytes(self.v, cnt); } @@ -933,7 +933,7 @@ export function advance$bytes_Buf_bytes_Bytes_mut(self: rt.Place): rt.ByteSlice { +export function chunk$bytes_Buf_bytes_Bytes_mut(self: Take): rs.ByteSlice { return chunk$bytes_Buf_bytes_Bytes(self); } @@ -967,7 +967,7 @@ export function chunk$bytes_Buf_bytes_Bytes_mut(self: Take): rt.By * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_ref_slice_u8_mut(self: Take): rt.ByteSlice { +export function chunk$bytes_Buf_ref_slice_u8_mut(self: Take): rs.ByteSlice { return chunk$bytes_Buf_ref_slice_u8(self); } @@ -992,7 +992,7 @@ export function chunk$bytes_Buf_ref_slice_u8_mut(self: Take): rt.B * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_Bytes_mut(self: rt.Place>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_bytes_Bytes_mut(self: rs.Place>, len: rs.usize): rs.ByteSlice { return copyToBytes$bytes_Buf_bytes_Bytes(self.v, len); } @@ -1015,7 +1015,7 @@ export function copyToBytes$bytes_Buf_bytes_Bytes_mut(self: rt.Place): boolean { +export function hasRemaining$bytes_Buf_bytes_Bytes_mut(self: Take): boolean { return hasRemaining$bytes_Buf_bytes_Bytes(self); } @@ -1046,7 +1046,7 @@ export function hasRemaining$bytes_Buf_bytes_Bytes_mut(self: Take) * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): rs.usize { return remaining$bytes_Buf_bytes_Bytes(self); } @@ -1077,7 +1077,7 @@ export function remaining$bytes_Buf_bytes_Bytes_mut(self: Take): r * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_buf_Pieces_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_mut_buf_Pieces_mut(self: Take): rs.usize { return remaining$bytes_Buf_mut_buf_Pieces(self); } @@ -1108,7 +1108,7 @@ export function remaining$bytes_Buf_mut_buf_Pieces_mut(self: Take * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_buf_Provided_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_mut_buf_Provided_mut(self: Take): rs.usize { return remaining$bytes_Buf_mut_buf_Provided(self); } @@ -1139,7 +1139,7 @@ export function remaining$bytes_Buf_mut_buf_Provided_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_mut_bytes_BytesMut_mut(self: Take): rs.usize { return remaining$bytes_Buf_mut_bytes_BytesMut(self); } @@ -1170,7 +1170,7 @@ export function remaining$bytes_Buf_mut_bytes_BytesMut_mut(self: Take>): rt.usize { +export function remaining$bytes_Buf_mut_bytes_Bytes_mut(self: Take>): rs.usize { return remaining$bytes_Buf_mut_bytes_Bytes(self); } @@ -1201,7 +1201,7 @@ export function remaining$bytes_Buf_mut_bytes_Bytes_mut(self: Take>): rt.usize { +export function remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self: Take>): rs.usize { return remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self); } @@ -1232,7 +1232,7 @@ export function remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_mut_ref_slice_u8_mut(self: Take>>): rt.usize { +export function remaining$bytes_Buf_mut_mut_ref_slice_u8_mut(self: Take>>): rs.usize { return remaining$bytes_Buf_mut_mut_ref_slice_u8(self); } @@ -1263,7 +1263,7 @@ export function remaining$bytes_Buf_mut_mut_ref_slice_u8_mut(self: Take>): rt.usize { +export function remaining$bytes_Buf_mut_ref_slice_u8_mut(self: Take>): rs.usize { return remaining$bytes_Buf_mut_ref_slice_u8(self); } @@ -1294,7 +1294,7 @@ export function remaining$bytes_Buf_mut_ref_slice_u8_mut(self: Take): rt.usize { +export function remaining$bytes_Buf_ref_slice_u8_mut(self: Take): rs.usize { return remaining$bytes_Buf_ref_slice_u8(self); } @@ -1306,9 +1306,9 @@ export function remaining$bytes_Buf_ref_slice_u8_mut(self: Take): */ export class Take { inner: T; - limit: rt.usize; + limit: rs.usize; - constructor(inner: T, limit: rt.usize) { + constructor(inner: T, limit: rs.usize) { this.inner = inner; this.limit = limit; } @@ -1341,8 +1341,8 @@ export class Take { * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_bytes_Bytes(self: Take): rt.usize { - return min$0wa4xqw(self.inner.length, self.limit); +export function remaining$bytes_Buf_bytes_Bytes(self: Take): rs.usize { + return min$00xoube(self.inner.length, self.limit); } /** @@ -1372,8 +1372,8 @@ export function remaining$bytes_Buf_bytes_Bytes(self: Take): rt.us * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_buf_Pieces(self: Take): rt.usize { - return min$0wa4xqw(Pieces.remaining$bytes_Buf_mut(self.inner), self.limit); +export function remaining$bytes_Buf_mut_buf_Pieces(self: Take): rs.usize { + return min$00xoube(Pieces.remaining$bytes_Buf_mut(self.inner), self.limit); } /** @@ -1403,8 +1403,8 @@ export function remaining$bytes_Buf_mut_buf_Pieces(self: Take): r * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_buf_Provided(self: Take): rt.usize { - return min$0wa4xqw(Provided.remaining$bytes_Buf_mut(self.inner), self.limit); +export function remaining$bytes_Buf_mut_buf_Provided(self: Take): rs.usize { + return min$00xoube(Provided.remaining$bytes_Buf_mut(self.inner), self.limit); } /** @@ -1434,8 +1434,8 @@ export function remaining$bytes_Buf_mut_buf_Provided(self: Take>): rt.usize { - return min$0wa4xqw(buf_impl_remaining$bytes_Buf_mut_bytes_Bytes(self.inner), self.limit); +export function remaining$bytes_Buf_mut_bytes_Bytes(self: Take>): rs.usize { + return min$00xoube(buf_impl_remaining$bytes_Buf_mut_bytes_Bytes(self.inner), self.limit); } /** @@ -1465,8 +1465,8 @@ export function remaining$bytes_Buf_mut_bytes_Bytes(self: Take): rt.usize { - return min$0wa4xqw(buf_impl_remaining$bytes_Buf_mut_bytes_BytesMut(self.inner), self.limit); +export function remaining$bytes_Buf_mut_bytes_BytesMut(self: Take): rs.usize { + return min$00xoube(buf_impl_remaining$bytes_Buf_mut_bytes_BytesMut(self.inner), self.limit); } /** @@ -1496,8 +1496,8 @@ export function remaining$bytes_Buf_mut_bytes_BytesMut(self: Take): * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>): rt.usize { - return min$0wa4xqw(Chain.remaining$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.inner), self.limit); +export function remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>): rs.usize { + return min$00xoube(Chain.remaining$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.inner), self.limit); } /** @@ -1527,8 +1527,8 @@ export function remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u * not change unless a call is made to `advance` or any other function that * is documented to change the `Buf`'s current position. */ -export function remaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): rt.usize { - return min$0wa4xqw(buf_impl_remaining$bytes_Buf_mut_mut_ref_slice_u8(self.inner), self.limit); +export function remaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): rs.usize { + return min$00xoube(buf_impl_remaining$bytes_Buf_mut_mut_ref_slice_u8(self.inner), self.limit); } /** @@ -1558,8 +1558,8 @@ export function remaining$bytes_Buf_mut_mut_ref_slice_u8(self: Take>): rt.usize { - return min$0wa4xqw(buf_impl_remaining$bytes_Buf_mut_ref_slice_u8(self.inner), self.limit); +export function remaining$bytes_Buf_mut_ref_slice_u8(self: Take>): rs.usize { + return min$00xoube(buf_impl_remaining$bytes_Buf_mut_ref_slice_u8(self.inner), self.limit); } /** @@ -1589,8 +1589,8 @@ export function remaining$bytes_Buf_mut_ref_slice_u8(self: Take): rt.usize { - return min$0wa4xqw(self.inner.length, self.limit); +export function remaining$bytes_Buf_ref_slice_u8(self: Take): rs.usize { + return min$00xoube(self.inner.length, self.limit); } /** @@ -1623,9 +1623,9 @@ export function remaining$bytes_Buf_ref_slice_u8(self: Take): rt.u * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_bytes_Bytes(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = self.inner; - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_bytes_Bytes(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = self.inner; + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1658,9 +1658,9 @@ export function chunk$bytes_Buf_bytes_Bytes(self: Take): rt.ByteSl * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_buf_Pieces(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = Pieces.chunk$bytes_Buf_mut(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_buf_Pieces(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = Pieces.chunk$bytes_Buf_mut(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1693,9 +1693,9 @@ export function chunk$bytes_Buf_mut_buf_Pieces(self: Take): rt.By * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_buf_Provided(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = Provided.chunk$bytes_Buf_mut(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_buf_Provided(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = Provided.chunk$bytes_Buf_mut(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1728,9 +1728,9 @@ export function chunk$bytes_Buf_mut_buf_Provided(self: Take): * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_bytes_Bytes(self: Take>): rt.ByteSlice { - const bytes: rt.ByteSlice = buf_impl_chunk$bytes_Buf_mut_bytes_Bytes(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_bytes_Bytes(self: Take>): rs.ByteSlice { + const bytes: rs.ByteSlice = buf_impl_chunk$bytes_Buf_mut_bytes_Bytes(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1763,9 +1763,9 @@ export function chunk$bytes_Buf_mut_bytes_Bytes(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = buf_impl_chunk$bytes_Buf_mut_bytes_BytesMut(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_bytes_BytesMut(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = buf_impl_chunk$bytes_Buf_mut_bytes_BytesMut(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1798,9 +1798,9 @@ export function chunk$bytes_Buf_mut_bytes_BytesMut(self: Take): rt. * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>): rt.ByteSlice { - const bytes: rt.ByteSlice = Chain.chunk$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>): rs.ByteSlice { + const bytes: rs.ByteSlice = Chain.chunk$bytes_Buf_buf_Provided_ref_slice_u8_mut(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1833,9 +1833,9 @@ export function chunk$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(se * return 0 and `remaining()` returning 0 implies that `chunk()` will * return an empty slice. */ -export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): rt.ByteSlice { - const bytes: rt.ByteSlice = buf_impl_chunk$bytes_Buf_mut_mut_ref_slice_u8(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>): rs.ByteSlice { + const bytes: rs.ByteSlice = buf_impl_chunk$bytes_Buf_mut_mut_ref_slice_u8(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1868,9 +1868,9 @@ export function chunk$bytes_Buf_mut_mut_ref_slice_u8(self: Take>): rt.ByteSlice { - const bytes: rt.ByteSlice = buf_impl_chunk$bytes_Buf_mut_ref_slice_u8(self.inner); - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_mut_ref_slice_u8(self: Take>): rs.ByteSlice { + const bytes: rs.ByteSlice = buf_impl_chunk$bytes_Buf_mut_ref_slice_u8(self.inner); + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1903,9 +1903,9 @@ export function chunk$bytes_Buf_mut_ref_slice_u8(self: Take): rt.ByteSlice { - const bytes: rt.ByteSlice = self.inner; - return rt.byteSliceRange(bytes, 0, min$0wa4xqw(bytes.length, self.limit)); +export function chunk$bytes_Buf_ref_slice_u8(self: Take): rs.ByteSlice { + const bytes: rs.ByteSlice = self.inner; + return rs.byteSliceRange(bytes, 0, min$00xoube(bytes.length, self.limit)); } /** @@ -1940,12 +1940,12 @@ export function chunk$bytes_Buf_ref_slice_u8(self: Take): rt.ByteS * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - rt.bytesAdvance(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + rs.bytesAdvance(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -1981,12 +1981,12 @@ export function advance$bytes_Buf_bytes_Bytes(self: Take, cnt: rt. * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_buf_Pieces(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_buf_Pieces(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - Pieces.advance$bytes_Buf_mut(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + Pieces.advance$bytes_Buf_mut(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2022,12 +2022,12 @@ export function advance$bytes_Buf_mut_buf_Pieces(self: Take, cnt: * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_buf_Provided(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_buf_Provided(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - Provided.advance$bytes_Buf_mut(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + Provided.advance$bytes_Buf_mut(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2063,12 +2063,12 @@ export function advance$bytes_Buf_mut_buf_Provided(self: Take * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_bytes_Bytes(self: Take>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_bytes_Bytes(self: Take>, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - buf_impl_advance$bytes_Buf_mut_bytes_Bytes(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + buf_impl_advance$bytes_Buf_mut_bytes_Bytes(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2104,12 +2104,12 @@ export function advance$bytes_Buf_mut_bytes_Bytes(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_bytes_BytesMut(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - buf_impl_advance$bytes_Buf_mut_bytes_BytesMut(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + buf_impl_advance$bytes_Buf_mut_bytes_BytesMut(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2145,12 +2145,12 @@ export function advance$bytes_Buf_mut_bytes_BytesMut(self: Take, cn * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - Chain.advance$bytes_Buf_buf_Provided_ref_slice_u8_mut(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + Chain.advance$bytes_Buf_buf_Provided_ref_slice_u8_mut(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2186,12 +2186,12 @@ export function advance$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8( * * A call with `cnt == 0` should never panic and be a no-op. */ -export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - buf_impl_advance$bytes_Buf_mut_mut_ref_slice_u8(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + buf_impl_advance$bytes_Buf_mut_mut_ref_slice_u8(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2227,12 +2227,12 @@ export function advance$bytes_Buf_mut_mut_ref_slice_u8(self: Take>, cnt: rt.usize): void { +export function advance$bytes_Buf_mut_ref_slice_u8(self: Take>, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - buf_impl_advance$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + buf_impl_advance$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2268,12 +2268,12 @@ export function advance$bytes_Buf_mut_ref_slice_u8(self: Take, cnt: rt.usize): void { +export function advance$bytes_Buf_ref_slice_u8(self: Take, cnt: rs.usize): void { if (!(cnt <= self.limit)) { - rt.panic("assertion failed: cnt <= self.limit"); + rs.panic("assertion failed: cnt <= self.limit"); } else { - rt.byteSliceAdvance(rt.place(() => self.inner, (value) => self.inner = value), cnt); - self.limit = rt.usizeSub(self.limit, cnt); + rs.byteSliceAdvance(rs.place(() => self.inner, (value) => self.inner = value), cnt); + self.limit = rs.usizeSub(self.limit, cnt); } } @@ -2298,12 +2298,12 @@ export function advance$bytes_Buf_ref_slice_u8(self: Take, cnt: rt * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_bytes_Bytes(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_bytes_Bytes(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_bytes_Bytes_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = rt.bytesSplitTo(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = rs.bytesSplitTo(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2329,12 +2329,12 @@ export function copyToBytes$bytes_Buf_bytes_Bytes(self: Take, len: * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_buf_Pieces(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_buf_Pieces(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_buf_Pieces_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = Pieces.copyToBytes$bytes_Buf_mut(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = Pieces.copyToBytes$bytes_Buf_mut(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2360,12 +2360,12 @@ export function copyToBytes$bytes_Buf_mut_buf_Pieces(self: Take, * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_buf_Provided(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_buf_Provided(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_buf_Provided_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = Provided.copyToBytes$bytes_Buf_mut(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = Provided.copyToBytes$bytes_Buf_mut(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2391,12 +2391,12 @@ export function copyToBytes$bytes_Buf_mut_buf_Provided(self: Take self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: Take>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: Take>, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_bytes_Bytes_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_bytes_Bytes(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_bytes_Bytes(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2422,12 +2422,12 @@ export function copyToBytes$bytes_Buf_mut_bytes_Bytes(self: Take self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_bytes_BytesMut_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_bytes_BytesMut(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_bytes_BytesMut(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2453,12 +2453,12 @@ export function copyToBytes$bytes_Buf_mut_bytes_BytesMut(self: Take * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(self: Take>, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice_u8_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8_mut(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = Chain.copyToBytes$bytes_Buf_buf_Provided_ref_slice_u8_mut(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2484,12 +2484,12 @@ export function copyToBytes$bytes_Buf_mut_bytes_buf_Chain_buf_Provided_ref_slice * * This function panics if `len > self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: Take>>, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_mut_ref_slice_u8_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2515,12 +2515,12 @@ export function copyToBytes$bytes_Buf_mut_mut_ref_slice_u8(self: Take self.remaining()`. */ -export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: Take>, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: Take>, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_mut_ref_slice_u8_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_ref_slice_u8(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = buf_impl_copyToBytes$bytes_Buf_mut_ref_slice_u8(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } @@ -2546,12 +2546,12 @@ export function copyToBytes$bytes_Buf_mut_ref_slice_u8(self: Take self.remaining()`. */ -export function copyToBytes$bytes_Buf_ref_slice_u8(self: Take, len: rt.usize): rt.ByteSlice { +export function copyToBytes$bytes_Buf_ref_slice_u8(self: Take, len: rs.usize): rs.ByteSlice { if (!(len <= remaining$bytes_Buf_ref_slice_u8_mut(self))) { - rt.panicFmt(["`len` greater than remaining"]); + rs.panicFmt(["`len` greater than remaining"]); } else { - const r: rt.ByteSlice = rt.byteSliceCopyToBytes(rt.place(() => self.inner, (value) => self.inner = value), len); - self.limit = rt.usizeSub(self.limit, len); + const r: rs.ByteSlice = rs.byteSliceCopyToBytes(rs.place(() => self.inner, (value) => self.inner = value), len); + self.limit = rs.usizeSub(self.limit, len); return r; } } diff --git a/ts/fixtures/stock/expected/bytes/buf/take.ts b/ts/fixtures/stock/expected/bytes/buf/take.ts index 15f364407..e444c88cb 100644 --- a/ts/fixtures/stock/expected/bytes/buf/take.ts +++ b/ts/fixtures/stock/expected/bytes/buf/take.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; import type * as Pieces from "../../buf.Pieces.ts"; import type * as Provided from "../../buf.Provided.ts"; import type * as Chain from "../../bytes/buf/chain.Chain.ts"; import * as Take from "../../bytes/buf/take.Take.ts"; -export function new_$bytes_Bytes(inner: rt.ByteSlice, limit: rt.usize): Take.Take { +export function new_$bytes_Bytes(inner: rs.ByteSlice, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } -export function new_$mut_buf_Pieces(inner: Pieces.Pieces, limit: rt.usize): Take.Take { +export function new_$mut_buf_Pieces(inner: Pieces.Pieces, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } -export function new_$mut_buf_Provided(inner: Provided.Provided, limit: rt.usize): Take.Take { +export function new_$mut_buf_Provided(inner: Provided.Provided, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } -export function new_$mut_bytes_Bytes(inner: rt.Place, limit: rt.usize): Take.Take> { +export function new_$mut_bytes_Bytes(inner: rs.Place, limit: rs.usize): Take.Take> { return new Take.Take(inner, limit); } -export function new_$mut_bytes_BytesMut(inner: rt.BytesMut, limit: rt.usize): Take.Take { +export function new_$mut_bytes_BytesMut(inner: rs.BytesMut, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } -export function new_$mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(inner: Chain.Chain, limit: rt.usize): Take.Take> { +export function new_$mut_bytes_buf_Chain_buf_Provided_ref_slice_u8(inner: Chain.Chain, limit: rs.usize): Take.Take> { return new Take.Take(inner, limit); } -export function new_$mut_mut_ref_slice_u8(inner: rt.Place>, limit: rt.usize): Take.Take>> { +export function new_$mut_mut_ref_slice_u8(inner: rs.Place>, limit: rs.usize): Take.Take>> { return new Take.Take(inner, limit); } -export function new_$mut_ref_slice_u8(inner: rt.Place, limit: rt.usize): Take.Take> { +export function new_$mut_ref_slice_u8(inner: rs.Place, limit: rs.usize): Take.Take> { return new Take.Take(inner, limit); } -export function new_$ref_slice_u8(inner: rt.ByteSlice, limit: rt.usize): Take.Take { +export function new_$ref_slice_u8(inner: rs.ByteSlice, limit: rs.usize): Take.Take { return new Take.Take(inner, limit); } diff --git a/ts/fixtures/stock/expected/core/cmp.ts b/ts/fixtures/stock/expected/core/cmp.ts index 65d98d4e3..5924327ca 100644 --- a/ts/fixtures/stock/expected/core/cmp.ts +++ b/ts/fixtures/stock/expected/core/cmp.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export function min$0wa4xqw(v1: rt.usize, v2: rt.usize): rt.usize { - return rt.min(v1, v2); +export function min$00xoube(v1: rs.usize, v2: rs.usize): rs.usize { + return rs.min(v1, v2); } //# sourceMappingURL=cmp.ts.map diff --git a/ts/fixtures/stock/expected/core/option.ts b/ts/fixtures/stock/expected/core/option.ts index 87e0540b1..ed8d563ed 100644 --- a/ts/fixtures/stock/expected/core/option.ts +++ b/ts/fixtures/stock/expected/core/option.ts @@ -1,97 +1,97 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Logged from "../maps.Logged.ts"; -export function unwrapOr$11c0we2(self: rt.u32 | undefined, default_: rt.u32): rt.u32 { +export function unwrapOr$1b5hww3(self: rs.u32 | undefined, default_: rs.u32): rs.u32 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0r2bmpr(self: rt.u8 | undefined, default_: rt.u8): rt.u8 { +export function unwrapOr$1fr498u(self: rs.u8 | undefined, default_: rs.u8): rs.u8 { if (self === undefined) { return default_; } return self; } -export function unwrapOr$0l7j3f6(self: rt.usize | undefined, default_: rt.usize): rt.usize { +export function unwrapOr$05jq4mv(self: rs.usize | undefined, default_: rs.usize): rs.usize { if (self === undefined) { return default_; } return self; } -export function map$0h57z6f(self: [rt.u16, rt.Place] | undefined, f: (a0: [rt.u16, rt.Place]) => rt.Place): rt.Place | undefined { +export function map$0faa8rw(self: [rs.u16, rs.Place] | undefined, f: (a0: [rs.u16, rs.Place]) => rs.Place): rs.Place | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$127uyaz(self: [rt.u16, rt.u32] | undefined, f: (a0: [rt.u16, rt.u32]) => rt.u16): rt.u16 | undefined { +export function map$1uqo0rf(self: [rs.u16, rs.u32] | undefined, f: (a0: [rs.u16, rs.u32]) => rs.u16): rs.u16 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1st5iv4(self: [rt.u16, rt.u32] | undefined, f: (a0: [rt.u16, rt.u32]) => rt.u32): rt.u32 | undefined { +export function map$1nxhy7e(self: [rs.u16, rs.u32] | undefined, f: (a0: [rs.u16, rs.u32]) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$085zvfb(self: Logged.Logged | undefined, default_: rt.u8, f: (a0: Logged.Logged) => rt.u8): rt.u8 { +export function mapOr$00octnd(self: Logged.Logged | undefined, default_: rs.u8, f: (a0: Logged.Logged) => rs.u8): rs.u8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1787w44(self: rt.Place | undefined, default_: rt.usize, f: (a0: rt.Place) => rt.usize): rt.usize { +export function mapOr$17oc7db(self: rs.Place | undefined, default_: rs.usize, f: (a0: rs.Place) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0iaogpf(self: [rt.u16, rt.u32] | undefined, default_: rt.usize, f: (a0: [rt.u16, rt.u32]) => rt.usize): rt.usize { +export function mapOr$0o00yzv(self: [rs.u16, rs.u32] | undefined, default_: rs.usize, f: (a0: [rs.u16, rs.u32]) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0yixjb2(self: rt.u16 | undefined, default_: rt.usize, f: (a0: rt.u16) => rt.usize): rt.usize { +export function mapOr$066oa3q(self: rs.u16 | undefined, default_: rs.usize, f: (a0: rs.u16) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1vcgixw(self: rt.u32 | undefined, default_: rt.usize, f: (a0: rt.u32) => rt.usize): rt.usize { +export function mapOr$0as7mjc(self: rs.u32 | undefined, default_: rs.usize, f: (a0: rs.u32) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1noewr3(self: [rt.u16, rt.Place] | undefined, default_: rt.usize, f: (a0: [rt.u16, rt.Place]) => rt.usize): rt.usize { +export function mapOr$0bhoutc(self: [rs.u16, rs.Place] | undefined, default_: rs.usize, f: (a0: [rs.u16, rs.Place]) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function clone$0ey9vhe(self: rt.ByteSlice | undefined): rt.ByteSlice | undefined { +export function clone$1i3gmk3(self: rs.ByteSlice | undefined): rs.ByteSlice | undefined { if (self === undefined) { return undefined; } - return rt.bytesClone(self); + return rs.bytesClone(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/stock/expected/core/result.ts b/ts/fixtures/stock/expected/core/result.ts index c509e1c27..b67edac92 100644 --- a/ts/fixtures/stock/expected/core/result.ts +++ b/ts/fixtures/stock/expected/core/result.ts @@ -1,37 +1,37 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as TryGetError from "../bytes.TryGetError.ts"; -export function map$0c3nzkx(self: rt.Result, op: (a0: rt.i64) => rt.u128): rt.Result { +export function map$1rpus2m(self: rs.Result, op: (a0: rs.i64) => rs.u128): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function map$0hs8st9(self: rt.Result, _: (a0: rt.u16) => rt.u128): rt.Result { +export function map$1cosroz(self: rs.Result, _: (a0: rs.u16) => rs.u128): rs.Result { if (self.ok) { - return rt.Ok(self.value as rt.u128); + return rs.Ok(self.value as rs.u128); } - return self as rt.Result; + return self as rs.Result; } -export function map$01kzrm1(self: rt.Result, _: (a0: rt.u8) => rt.u128): rt.Result { +export function map$1k6isgs(self: rs.Result, _: (a0: rs.u8) => rs.u128): rs.Result { if (self.ok) { - return rt.Ok(self.value as rt.u128); + return rs.Ok(self.value as rs.u128); } - return self as rt.Result; + return self as rs.Result; } -export function unwrapOrElse$1wp5sd9(self: rt.Result, op: (a0: TryGetError.TryGetError) => rt.u64): rt.u64 { +export function unwrapOrElse$1b4ownx(self: rs.Result, op: (a0: TryGetError.TryGetError) => rs.u64): rs.u64 { if (self.ok) { return self.value; } return op(self.error); } -export function unwrapOrElse$0s2lrc9(self: rt.Result, op: (a0: TryGetError.TryGetError) => undefined): void { +export function unwrapOrElse$1fg63zn(self: rs.Result, op: (a0: TryGetError.TryGetError) => undefined): void { if (!self.ok) { op(self.error); } diff --git a/ts/fixtures/stock/expected/harness.Owner.ts b/ts/fixtures/stock/expected/harness.Owner.ts index 5d891c54b..8cfe40721 100644 --- a/ts/fixtures/stock/expected/harness.Owner.ts +++ b/ts/fixtures/stock/expected/harness.Owner.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** An owner `Bytes::from_owner` reads once, and drops nothing JS sees. */ export interface Owner { - data: rt.ByteVec; - skip: rt.usize; + data: rs.ByteVec; + skip: rs.usize; } -export function asRef$convert_AsRef_slice_u8(self: Owner): rt.ByteSlice { - const part = rt.min(self.skip, self.data.length); - return rt.byteSliceRange(rt.byteVecSlice(self.data), part); +export function asRef$convert_AsRef_slice_u8(self: Owner): rs.ByteSlice { + const part = rs.min(self.skip, self.data.length); + return rs.byteSliceRange(rs.byteVecSlice(self.data), part); } //# sourceMappingURL=harness.Owner.ts.map diff --git a/ts/fixtures/stock/expected/harness.ts b/ts/fixtures/stock/expected/harness.ts index af56d2d9c..c67c51909 100644 --- a/ts/fixtures/stock/expected/harness.ts +++ b/ts/fixtures/stock/expected/harness.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { bytesMut, far, reclaims, reads, dyns, late, vecSpares, writes, edits, chains } from "./buf.ts"; import * as Owner from "./harness.Owner.ts"; import { map as maps_map, table, capacity, linked, linkedIters, nested, ownHasher, ownFromIter, equal, defaultHasher } from "./maps.ts"; @@ -9,56 +9,56 @@ import { map as maps_map, table, capacity, linked, linkedIters, nested, ownHashe * Each case's name and what it runs. The first byte picks one modulo their count, so a * case added at the end moves no other. */ -export function cases(): rt.Vec<[string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]> { - return rt.vecFrom([["slices", (a0: rt.ByteSlice, a1: rt.ByteVec): undefined => { +export function cases(): rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]> { + return rs.vecFrom([["slices", (a0: rs.ByteSlice, a1: rs.ByteVec): undefined => { slices(a0.data, a0.start, a0.length, a1); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["made", (a02: rt.ByteSlice, a12: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["made", (a02: rs.ByteSlice, a12: rs.ByteVec): undefined => { made(a02.data, a02.start, a02.length, a12); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["events", events as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["random", (a03: rt.ByteSlice, a13: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["events", events as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["random", (a03: rs.ByteSlice, a13: rs.ByteVec): undefined => { random(a03.data, a03.start, a03.length, a13); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reads", (a04: rt.ByteSlice, a14: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::bytes_mut", bytesMut as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::reads", (a04: rs.ByteSlice, a14: rs.ByteVec): undefined => { reads(a04.data, a04.start, a04.length, a14); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::writes", writes as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::edits", (a05: rt.ByteSlice, a15: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::writes", writes as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::edits", (a05: rs.ByteSlice, a15: rs.ByteVec): undefined => { edits(a05.data, a05.start, a05.length, a15); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::far", (a06: rt.ByteSlice, a16: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::far", (a06: rs.ByteSlice, a16: rs.ByteVec): undefined => { far(a06.data, a06.start, a06.length, a16); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::dyns", (a07: rt.ByteSlice, a17: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::dyns", (a07: rs.ByteSlice, a17: rs.ByteVec): undefined => { dyns(a07.data, a07.start, a07.length, a17); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::map", maps_map as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::table", (a08: rt.ByteSlice, a18: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::map", maps_map as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::table", (a08: rs.ByteSlice, a18: rs.ByteVec): undefined => { table(a08.data, a08.start, a08.length, a18); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::capacity", (a09: rt.ByteSlice, a19: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::capacity", (a09: rs.ByteSlice, a19: rs.ByteVec): undefined => { capacity(a09.data, a09.start, a09.length, a19); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::linked", linked as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::linked_iters", (a010: rt.ByteSlice, a110: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::linked", linked as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::linked_iters", (a010: rs.ByteSlice, a110: rs.ByteVec): undefined => { linkedIters(a010.data, a010.start, a010.length, a110); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::chains", (a011: rt.ByteSlice, a111: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::chains", (a011: rs.ByteSlice, a111: rs.ByteVec): undefined => { chains(a011.data, a011.start, a011.length, a111); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::nested", (a012: rt.ByteSlice, a112: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::nested", (a012: rs.ByteSlice, a112: rs.ByteVec): undefined => { nested(a012.data, a012.start, a012.length, a112); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::late", late as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::own_hasher", ownHasher as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::own_from_iter", ownFromIter as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::equal", equal as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["maps::default_hasher", defaultHasher as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::reclaims", (a013: rt.ByteSlice, a113: rt.ByteVec): undefined => { + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::late", late as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::own_hasher", ownHasher as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::own_from_iter", ownFromIter as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::equal", equal as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["maps::default_hasher", defaultHasher as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::reclaims", (a013: rs.ByteSlice, a113: rs.ByteVec): undefined => { reclaims(a013.data, a013.start, a013.length, a113); - }] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined], ["buf::vec_spares", vecSpares as (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined] as [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]]); + }] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined], ["buf::vec_spares", vecSpares as (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined] as [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]]); } /** Run one case. */ -export function run(input: rt.ByteSlice): rt.ByteVec { - const out: rt.ByteVec = new rt.ByteVec(); +export function run(input: rs.ByteSlice): rs.ByteVec { + const out: rs.ByteVec = new rs.ByteVec(); if (input.length !== 0) { - const op: rt.u8 = input.data[input.start]; - const cases_: rt.Vec<[string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]> = cases(); - cases_.items[rt.idx(cases_.items, rt.usizeRem(op as rt.usize, cases_.items.length))][1](new rt.ByteSlice(input.data, input.start + 1, input.length - 1), out); + const op: rs.u8 = input.data[input.start]; + const cases_: rs.Vec<[string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]> = cases(); + cases_.items[rs.idx(cases_.items, rs.usizeRem(op as rs.usize, cases_.items.length))][1](new rs.ByteSlice(input.data, input.start + 1, input.length - 1), out); return out; } return out; } /** The first byte that picks the case named `name`, which `caller.ts` targets by. */ -export function op(name: string): rt.u8 { - const _2: rt.usize | undefined = rt.iterPosition(rt.iterSlice(cases().items), (_22: [string, (a0: rt.ByteSlice, a1: rt.ByteVec) => undefined]): boolean => { +export function op(name: string): rs.u8 { + const _2: rs.usize | undefined = rs.iterPosition(rs.iterSlice(cases().items), (_22: [string, (a0: rs.ByteSlice, a1: rs.ByteVec) => undefined]): boolean => { return _22[0] === name; }); if (_2 === undefined) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, name)]; - rt.panicFmt(["no case ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, name)]; + rs.panicFmt(["no case ", args2[0]]); } else { return _2 & 0xff; } @@ -68,97 +68,97 @@ export function op(name: string): rt.u8 { * `Bytes`'s slices by every kind of range, out of bounds included, which panic as * `bytes` does, and what they compare equal to. */ -export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let part!: rt.ByteSlice; - let range!: rt.RangeInclusive; +export function slices(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let part!: rs.ByteSlice; + let range!: rs.RangeInclusive; if (dataLen >= 3) { - const bytes: rt.ByteSlice = rt.bytesCopyFromSlice(new rt.ByteSlice(dataData, dataStart + 3, dataLen - 3)); + const bytes: rs.ByteSlice = rs.bytesCopyFromSlice(new rs.ByteSlice(dataData, dataStart + 3, dataLen - 3)); const past: boolean = dataData[dataStart + 2] === 255; - const _14: [rt.usize, rt.usize] = [rt.usizeRem(dataData[dataStart + 1] as rt.usize, rt.usizeAdd(dataLen - 3, 2)), rt.usizeRem(dataData[dataStart + 2] as rt.usize, rt.usizeAdd(dataLen - 3, 2))]; - const a: rt.usize = _14[0]; - const b: rt.usize = _14[1]; + const _14: [rs.usize, rs.usize] = [rs.usizeRem(dataData[dataStart + 1] as rs.usize, rs.usizeAdd(dataLen - 3, 2)), rs.usizeRem(dataData[dataStart + 2] as rs.usize, rs.usizeAdd(dataLen - 3, 2))]; + const a: rs.usize = _14[0]; + const b: rs.usize = _14[1]; if ((dataData[dataStart] & 128) !== 0) { - rt.bytesDrop(rt.bytesSlice(bytes, b)); + rs.bytesDrop(rs.bytesSlice(bytes, b)); } - const _35: rt.u8 = rt.u8Rem(dataData[dataStart], 7); + const _35: rs.u8 = rs.u8Rem(dataData[dataStart], 7); if (_35 === 0) { - part = rt.bytesSlice(bytes, a, b); + part = rs.bytesSlice(bytes, a, b); } else if (_35 === 1) { - part = rt.bytesSlice(bytes, a); + part = rs.bytesSlice(bytes, a); } else if (_35 === 2) { - part = rt.bytesSlice(bytes, 0, b); + part = rs.bytesSlice(bytes, 0, b); } else if (_35 === 3) { - part = rt.bytesSlice(bytes, 0); + part = rs.bytesSlice(bytes, 0); } else if (_35 === 4) { if (!past) { - const _46: rt.RangeInclusive = new rt.RangeInclusive(a, b, rt.usizeStep); - part = rt.bytesSliceInclusive(bytes, _46); + const _46: rs.RangeInclusive = new rs.RangeInclusive(a, b, rs.usizeStep); + part = rs.bytesSliceInclusive(bytes, _46); } else { - const _44: rt.RangeInclusive = new rt.RangeInclusive(a, 4294967295, rt.usizeStep); - part = rt.bytesSliceInclusive(bytes, _44); + const _44: rs.RangeInclusive = new rs.RangeInclusive(a, 4294967295, rs.usizeStep); + part = rs.bytesSliceInclusive(bytes, _44); } } else if (_35 === 5) { if (!past) { - part = rt.bytesSliceToInclusive(bytes, b); + part = rs.bytesSliceToInclusive(bytes, b); } else { - part = rt.bytesSliceToInclusive(bytes, 4294967295); + part = rs.bytesSliceToInclusive(bytes, 4294967295); } } else { if (!past) { - range = new rt.RangeInclusive(a, b, rt.usizeStep); + range = new rs.RangeInclusive(a, b, rs.usizeStep); } else { - range = new rt.RangeInclusive(4294967295, 4294967295, rt.usizeStep); + range = new rs.RangeInclusive(4294967295, 4294967295, rs.usizeStep); } - while (rt.iterToOption(range.next()) !== undefined) { + while (rs.iterToOption(range.next()) !== undefined) { } - part = rt.bytesSliceInclusive(bytes, range); + part = rs.bytesSliceInclusive(bytes, range); } - rt.byteVecPush(out, part.length & 0xff); - rt.byteVecPush(out, part.length === 0 ? 1 : 0); - rt.byteVecExtendFromSlice(out, part); - rt.byteVecPush(out, rt.byteSliceEq(part, bytes) ? 1 : 0); - const _78: rt.ByteSlice = rt.bytesClone(part); - const _80: rt.ByteSlice = rt.byteSliceRange(part, 0); - rt.byteVecPush(out, rt.byteSliceEq(_78, _80) ? 1 : 0); - rt.bytesDrop(_78); - const _89: rt.ByteSlice = rt.bytesSlice(bytes, rt.min(a, dataLen - 3)); - const _87: rt.ByteSlice = rt.bytesSlice(_89, 0, 0); - const _96: rt.ByteSlice = rt.bytesNew(); - rt.byteVecPush(out, rt.byteSliceEq(_87, _96) ? 1 : 0); - rt.bytesDrop(_96); - rt.bytesDrop(_87); - rt.bytesDrop(_89); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.bytesToByteVec(part))); - rt.bytesDrop(bytes); + rs.byteVecPush(out, part.length & 0xff); + rs.byteVecPush(out, part.length === 0 ? 1 : 0); + rs.byteVecExtendFromSlice(out, part); + rs.byteVecPush(out, rs.byteSliceEq(part, bytes) ? 1 : 0); + const _78: rs.ByteSlice = rs.bytesClone(part); + const _80: rs.ByteSlice = rs.byteSliceRange(part, 0); + rs.byteVecPush(out, rs.byteSliceEq(_78, _80) ? 1 : 0); + rs.bytesDrop(_78); + const _89: rs.ByteSlice = rs.bytesSlice(bytes, rs.min(a, dataLen - 3)); + const _87: rs.ByteSlice = rs.bytesSlice(_89, 0, 0); + const _96: rs.ByteSlice = rs.bytesNew(); + rs.byteVecPush(out, rs.byteSliceEq(_87, _96) ? 1 : 0); + rs.bytesDrop(_96); + rs.bytesDrop(_87); + rs.bytesDrop(_89); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.bytesToByteVec(part))); + rs.bytesDrop(bytes); } } /** `Bytes` made each way, printed with `Debug`. */ -export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function made(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { - const skip: rt.u8 = dataData[dataStart]; - const rest: rt.ByteSlice = new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1); - const made: rt.ByteSlice[] = [rt.bytesFromVec(rt.byteSliceToByteVec(rest)), rt.bytesStatic(rt.byteSliceFrom(Uint8Array.of(0, 9, 13, 10, 92, 34, 39, 126, 127, 128, 255))), rt.stringAsBytes("text"), rt.bytesStatic(rt.byteSliceRange(rt.byteSliceFrom(Uint8Array.of(115, 116, 97, 116, 105, 99)), 0)), rt.bytesNew(), rt.bytesStatic(Owner.asRef$convert_AsRef_slice_u8({ data: rt.byteSliceToByteVec(rest), skip: skip as rt.usize }))]; - const source: rt.ByteVec = rt.byteSliceToByteVec(rest); - const copied: rt.ByteSlice = rt.bytesCopyFromSlice(rt.byteVecSlice(source)); - rt.byteVecClear(source); - rt.byteVecPush(source, 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(copied, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args2[0]]))); - const iter: rt.Iter = rt.iterSlice(made, rt.bytesDrop); + const skip: rs.u8 = dataData[dataStart]; + const rest: rs.ByteSlice = new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1); + const made: rs.ByteSlice[] = [rs.bytesFromVec(rs.byteSliceToByteVec(rest)), rs.bytesStatic(rs.byteSliceFrom(Uint8Array.of(0, 9, 13, 10, 92, 34, 39, 126, 127, 128, 255))), rs.stringAsBytes("text"), rs.bytesStatic(rs.byteSliceRange(rs.byteSliceFrom(Uint8Array.of(115, 116, 97, 116, 105, 99)), 0)), rs.bytesNew(), rs.bytesStatic(Owner.asRef$convert_AsRef_slice_u8({ data: rs.byteSliceToByteVec(rest), skip: skip as rs.usize }))]; + const source: rs.ByteVec = rs.byteSliceToByteVec(rest); + const copied: rs.ByteSlice = rs.bytesCopyFromSlice(rs.byteVecSlice(source)); + rs.byteVecClear(source); + rs.byteVecPush(source, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(copied, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args2[0]]))); + const iter: rs.Iter = rs.iterSlice(made, rs.bytesDrop); while (true) { - const _44: rt.ByteSlice | rt.Done = iter.next(); - if (_44 === rt.DONE) { + const _44: rs.ByteSlice | rs.Done = iter.next(); + if (_44 === rs.DONE) { break; } - const bytes: rt.ByteSlice = _44; - const _56: rt.usize = bytes.length; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.bytesDebug(bytes, f), (f: rt.Formatter) => rt.usizeDisplay(_56, f)]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.fmtFormat([args4[0], " ", args4[1], "\n"]))); - rt.bytesDrop(bytes); + const bytes: rs.ByteSlice = _44; + const _56: rs.usize = bytes.length; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.bytesDebug(bytes, f), (f: rs.Formatter) => rs.usizeDisplay(_56, f)]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.fmtFormat([args4[0], " ", args4[1], "\n"]))); + rs.bytesDrop(bytes); } - rt.drop(iter); - rt.bytesDrop(copied); + rs.drop(iter); + rs.bytesDrop(copied); } } @@ -166,107 +166,107 @@ export function made(dataData: Uint8Array, dataStart: number, dataLen: number, o * `tracing`'s events, which evaluate nothing without a subscriber: no field marks `out`, * one in a branch included. */ -export function events(data: rt.ByteSlice, out: rt.ByteVec): void { - rt.byteVecPush(out, data.length & 0xff); +export function events(data: rs.ByteSlice, out: rs.ByteVec): void { + rs.byteVecPush(out, data.length & 0xff); } /** * `rand::rng()`'s values: each in its range, an empty range panicking as `rand`'s does, * and every value of a small range drawn. */ -export function random(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function random(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let inRange!: boolean; if (dataLen >= 3) { - const kind: rt.u8 = dataData[dataStart]; - const a: rt.u8 = dataData[dataStart + 1]; - const b: rt.u8 = dataData[dataStart + 2]; - rt.randRng(); + const kind: rs.u8 = dataData[dataStart]; + const a: rs.u8 = dataData[dataStart + 1]; + const b: rs.u8 = dataData[dataStart + 2]; + rs.randRng(); b1: { - const _10: rt.u8 = rt.u8Rem(kind, 10); + const _10: rs.u8 = rs.u8Rem(kind, 10); if (_10 === 0) { - const range4 = new rt.Range(a, b); - const x: rt.u8 = rt.randRange(range4.start, range4.end, 8, false) as rt.u8; + const range4 = new rs.Range(a, b); + const x: rs.u8 = rs.randRange(range4.start, range4.end, 8, false) as rs.u8; if (!(a <= x)) { inRange = false; } else { inRange = x < b; } } else if (_10 === 1) { - const x2: rt.u8 = rt.randRangeInclusive(new rt.RangeInclusive(a, b, rt.u8Step), 8, false) as rt.u8; + const x2: rs.u8 = rs.randRangeInclusive(new rs.RangeInclusive(a, b, rs.u8Step), 8, false) as rs.u8; if (!(a <= x2)) { inRange = false; } else { inRange = x2 <= b; } } else if (_10 === 2) { - const _22: [rt.i32, rt.i32] = [rt.i32Mul((a << 24) >> 24 as rt.i32, 1000), rt.i32Mul((b << 24) >> 24 as rt.i32, 1000)]; - const lo: rt.i32 = _22[0]; - const hi: rt.i32 = _22[1]; - const range3 = new rt.Range(lo, hi); - const x3: rt.i32 = rt.randRange(range3.start, range3.end, 32, true) as rt.i32; + const _22: [rs.i32, rs.i32] = [rs.i32Mul((a << 24) >> 24 as rs.i32, 1000), rs.i32Mul((b << 24) >> 24 as rs.i32, 1000)]; + const lo: rs.i32 = _22[0]; + const hi: rs.i32 = _22[1]; + const range3 = new rs.Range(lo, hi); + const x3: rs.i32 = rs.randRange(range3.start, range3.end, 32, true) as rs.i32; if (!(lo <= x3)) { inRange = false; } else { inRange = x3 < hi; } } else if (_10 === 3) { - const lo2: rt.u64 = rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Mul(a as rt.u64, 1099511627776)); - inRange = rt.u64Le(lo2, rt.randRangeInclusive(new rt.RangeInclusive(lo2, { hi: 0xffffffff, lo: 0xffffffff } as rt.u64, rt.u64Step), 64, false) as rt.u64); + const lo2: rs.u64 = rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Mul(a as rs.u64, 1099511627776)); + inRange = rs.u64Le(lo2, rs.randRangeInclusive(new rs.RangeInclusive(lo2, { hi: 0xffffffff, lo: 0xffffffff } as rs.u64, rs.u64Step), 64, false) as rs.u64); } else if (_10 === 4) { - const _48: [rt.i128, rt.i128] = [rt.i128Shl((a << 24) >> 24 as rt.i128, 100), rt.i128Shl((b << 24) >> 24 as rt.i128, 100)]; - const lo3: rt.i128 = _48[0]; - const hi2: rt.i128 = _48[1]; - const range2 = new rt.Range(lo3, hi2, rt.i128Step); - const x5: rt.i128 = rt.randRange(range2.start, range2.end, 128, true) as rt.i128; - if (!rt.i128Le(lo3, x5)) { + const _48: [rs.i128, rs.i128] = [rs.i128Shl((a << 24) >> 24 as rs.i128, 100), rs.i128Shl((b << 24) >> 24 as rs.i128, 100)]; + const lo3: rs.i128 = _48[0]; + const hi2: rs.i128 = _48[1]; + const range2 = new rs.Range(lo3, hi2, rs.i128Step); + const x5: rs.i128 = rs.randRange(range2.start, range2.end, 128, true) as rs.i128; + if (!rs.i128Le(lo3, x5)) { inRange = false; } else { - inRange = rt.i128Lt(x5, hi2); + inRange = rs.i128Lt(x5, hi2); } } else if (_10 === 5) { - const lo4: rt.u64 = rt.u64Add({ hi: 0x10000000, lo: 0 } as rt.u64, a as rt.u64); + const lo4: rs.u64 = rs.u64Add({ hi: 0x10000000, lo: 0 } as rs.u64, a as rs.u64); const seen: boolean[] = Array.from({ length: 4 }, (): boolean => { return false; }); - let iterStart: rt.i32 = 0; - const iterEnd: rt.i32 = 256; + let iterStart: rs.i32 = 0; + const iterEnd: rs.i32 = 256; while (iterStart++ < iterEnd) { - const range = new rt.Range(lo4, rt.u64Add(lo4, 4), rt.u64Step); - const _76: rt.usize = rt.u64Low(rt.u64Sub(rt.randRange(range.start, range.end, 64, false) as rt.u64, lo4)); + const range = new rs.Range(lo4, rs.u64Add(lo4, 4), rs.u64Step); + const _76: rs.usize = rs.u64Low(rs.u64Sub(rs.randRange(range.start, range.end, 64, false) as rs.u64, lo4)); if (!(_76 < 4)) { - rt.panic("index out of bounds: the len is " + 4 + " but the index is " + _76); + rs.panic("index out of bounds: the len is " + 4 + " but the index is " + _76); } seen[_76] = true; } - inRange = rt.iterAll(rt.iterSlice(seen), (_2: boolean): boolean => { + inRange = rs.iterAll(rs.iterSlice(seen), (_2: boolean): boolean => { return _2; }); } else if (_10 === 6) { - const _91: [rt.i64, rt.i64] = [rt.i64Add({ hi: -0x80000000, lo: 0 } as rt.i64, a as rt.i64), rt.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rt.i64, b as rt.i64)]; - const lo5: rt.i64 = _91[0]; - const hi3: rt.i64 = _91[1]; - const x6: rt.i64 = rt.randRangeInclusive(new rt.RangeInclusive(lo5, hi3, rt.i64Step), 64, true) as rt.i64; - if (!rt.i64Le(lo5, x6)) { + const _91: [rs.i64, rs.i64] = [rs.i64Add({ hi: -0x80000000, lo: 0 } as rs.i64, a as rs.i64), rs.i64Sub({ hi: 0x7fffffff, lo: 0xffffffff } as rs.i64, b as rs.i64)]; + const lo5: rs.i64 = _91[0]; + const hi3: rs.i64 = _91[1]; + const x6: rs.i64 = rs.randRangeInclusive(new rs.RangeInclusive(lo5, hi3, rs.i64Step), 64, true) as rs.i64; + if (!rs.i64Le(lo5, x6)) { inRange = false; } else { - inRange = rt.i64Le(x6, hi3); + inRange = rs.i64Le(x6, hi3); } } else if (_10 === 7) { - inRange = (rt.randRange(0, { end: b }.end, 8, false) as rt.u8) < b; + inRange = (rs.randRange(0, { end: b }.end, 8, false) as rs.u8) < b; } else if (_10 === 8) { - const hi4: rt.u64 = rt.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rt.u64, a as rt.u64); - if (!((rt.randRangeToInclusive({ end: b, inclusive: true }.end, 8) as rt.u8) <= b)) { + const hi4: rs.u64 = rs.u64Sub({ hi: 0xffffffff, lo: 0xffffffff } as rs.u64, a as rs.u64); + if (!((rs.randRangeToInclusive({ end: b, inclusive: true }.end, 8) as rs.u8) <= b)) { inRange = false; } else { - inRange = rt.u64Le(rt.randRangeToInclusive({ end: hi4, inclusive: true }.end, 64) as rt.u64, hi4); + inRange = rs.u64Le(rs.randRangeToInclusive({ end: hi4, inclusive: true }.end, 64) as rs.u64, hi4); } } else { - const _117: [rt.u64, rt.i16] = [rt.randInt(64, false) as rt.u64, rt.randInt(16, true) as rt.i16]; - const x7: rt.u64 = _117[0]; - const y: rt.i16 = _117[1]; - rt.randRng(); - const flag: boolean = rt.randBool(); - if (rt.u64Eq(x7, x7)) { + const _117: [rs.u64, rs.i16] = [rs.randInt(64, false) as rs.u64, rs.randInt(16, true) as rs.i16]; + const x7: rs.u64 = _117[0]; + const y: rs.i16 = _117[1]; + rs.randRng(); + const flag: boolean = rs.randBool(); + if (rs.u64Eq(x7, x7)) { if (y === y) { if (!flag) { inRange = !flag; @@ -279,7 +279,7 @@ export function random(dataData: Uint8Array, dataStart: number, dataLen: number, inRange = false; } } - rt.byteVecPush(out, inRange ? 1 : 0); + rs.byteVecPush(out, inRange ? 1 : 0); } } diff --git a/ts/fixtures/stock/expected/hashlink.DefaultHashBuilder.ts b/ts/fixtures/stock/expected/hashlink.DefaultHashBuilder.ts index 7bd683dd4..584902f51 100644 --- a/ts/fixtures/stock/expected/hashlink.DefaultHashBuilder.ts +++ b/ts/fixtures/stock/expected/hashlink.DefaultHashBuilder.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as DefaultHasher from "./hashlink.DefaultHasher.ts"; export function default$Default(): DefaultHashBuilder { - return { _0: rt.randomState() }; + return { _0: rs.randomState() }; } /** @@ -13,11 +13,11 @@ export function default$Default(): DefaultHashBuilder { * See [`DefaultHasher`] for more details. */ export interface DefaultHashBuilder { - _0: rt.RandomState; + _0: rs.RandomState; } export function buildHasher$hash_BuildHasher(self: DefaultHashBuilder): DefaultHasher.DefaultHasher { - return { _0: rt.buildHasher(self._0) }; + return { _0: rs.buildHasher(self._0) }; } //# sourceMappingURL=hashlink.DefaultHashBuilder.ts.map diff --git a/ts/fixtures/stock/expected/hashlink.DefaultHasher.ts b/ts/fixtures/stock/expected/hashlink.DefaultHasher.ts index 237329a10..ee506114b 100644 --- a/ts/fixtures/stock/expected/hashlink.DefaultHasher.ts +++ b/ts/fixtures/stock/expected/hashlink.DefaultHasher.ts @@ -1,69 +1,69 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** Default hasher, as selected by hashbrown. */ export interface DefaultHasher { - _0: rt.Hasher; + _0: rs.Hasher; } -export function write$hash_Hasher(self: DefaultHasher, bytes: rt.ByteSlice): void { - rt.hashWrite(bytes, self._0); +export function write$hash_Hasher(self: DefaultHasher, bytes: rs.ByteSlice): void { + rs.hashWrite(bytes, self._0); } -export function writeU8$hash_Hasher(self: DefaultHasher, i: rt.u8): void { - rt.hash8(i, self._0); +export function writeU8$hash_Hasher(self: DefaultHasher, i: rs.u8): void { + rs.hash8(i, self._0); } -export function writeU16$hash_Hasher(self: DefaultHasher, i: rt.u16): void { - rt.hash16(i, self._0); +export function writeU16$hash_Hasher(self: DefaultHasher, i: rs.u16): void { + rs.hash16(i, self._0); } -export function writeU32$hash_Hasher(self: DefaultHasher, i: rt.u32): void { - rt.hash32(i, self._0); +export function writeU32$hash_Hasher(self: DefaultHasher, i: rs.u32): void { + rs.hash32(i, self._0); } -export function writeU64$hash_Hasher(self: DefaultHasher, i: rt.u64): void { - rt.hash64(i, self._0); +export function writeU64$hash_Hasher(self: DefaultHasher, i: rs.u64): void { + rs.hash64(i, self._0); } -export function writeU128$hash_Hasher(self: DefaultHasher, i: rt.u128): void { - rt.hash128(i, self._0); +export function writeU128$hash_Hasher(self: DefaultHasher, i: rs.u128): void { + rs.hash128(i, self._0); } -export function writeUsize$hash_Hasher(self: DefaultHasher, i: rt.usize): void { - rt.hashUsize(i, self._0); +export function writeUsize$hash_Hasher(self: DefaultHasher, i: rs.usize): void { + rs.hashUsize(i, self._0); } -export function finish$hash_Hasher(self: DefaultHasher): rt.u64 { - return rt.hashFinish(self._0); +export function finish$hash_Hasher(self: DefaultHasher): rs.u64 { + return rs.hashFinish(self._0); } /** The methods of `hashlink::DefaultHasher`'s impl, which the runtime's hashing calls. */ -export const hasher$hash_Hasher: rt.HasherImpl = { write: write$hash_Hasher as (a0: DefaultHasher, a1: rt.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: DefaultHasher, a1: rt.u8) => undefined, u16: writeU16$hash_Hasher as (a0: DefaultHasher, a1: rt.u16) => undefined, u32: writeU32$hash_Hasher as (a0: DefaultHasher, a1: rt.u32) => undefined, u64: writeU64$hash_Hasher as (a0: DefaultHasher, a1: rt.u64) => undefined, u128: writeU128$hash_Hasher as (a0: DefaultHasher, a1: rt.u128) => undefined, usize: writeUsize$hash_Hasher as (a0: DefaultHasher, a1: rt.usize) => undefined, i8: writeI8$hash_Hasher as (a0: DefaultHasher, a1: rt.i8) => undefined, i16: writeI16$hash_Hasher as (a0: DefaultHasher, a1: rt.i16) => undefined, i32: writeI32$hash_Hasher as (a0: DefaultHasher, a1: rt.i32) => undefined, i64: writeI64$hash_Hasher as (a0: DefaultHasher, a1: rt.i64) => undefined, i128: writeI128$hash_Hasher as (a0: DefaultHasher, a1: rt.i128) => undefined, isize: writeIsize$hash_Hasher as (a0: DefaultHasher, a1: rt.isize) => undefined }; +export const hasher$hash_Hasher: rs.HasherImpl = { write: write$hash_Hasher as (a0: DefaultHasher, a1: rs.ByteSlice) => undefined, finish: finish$hash_Hasher, u8: writeU8$hash_Hasher as (a0: DefaultHasher, a1: rs.u8) => undefined, u16: writeU16$hash_Hasher as (a0: DefaultHasher, a1: rs.u16) => undefined, u32: writeU32$hash_Hasher as (a0: DefaultHasher, a1: rs.u32) => undefined, u64: writeU64$hash_Hasher as (a0: DefaultHasher, a1: rs.u64) => undefined, u128: writeU128$hash_Hasher as (a0: DefaultHasher, a1: rs.u128) => undefined, usize: writeUsize$hash_Hasher as (a0: DefaultHasher, a1: rs.usize) => undefined, i8: writeI8$hash_Hasher as (a0: DefaultHasher, a1: rs.i8) => undefined, i16: writeI16$hash_Hasher as (a0: DefaultHasher, a1: rs.i16) => undefined, i32: writeI32$hash_Hasher as (a0: DefaultHasher, a1: rs.i32) => undefined, i64: writeI64$hash_Hasher as (a0: DefaultHasher, a1: rs.i64) => undefined, i128: writeI128$hash_Hasher as (a0: DefaultHasher, a1: rs.i128) => undefined, isize: writeIsize$hash_Hasher as (a0: DefaultHasher, a1: rs.isize) => undefined }; -export function writeI8$hash_Hasher(self: DefaultHasher, i: rt.i8): void { - rt.hashI8(i, self._0); +export function writeI8$hash_Hasher(self: DefaultHasher, i: rs.i8): void { + rs.hashI8(i, self._0); } -export function writeI16$hash_Hasher(self: DefaultHasher, i: rt.i16): void { - rt.hashI16(i, self._0); +export function writeI16$hash_Hasher(self: DefaultHasher, i: rs.i16): void { + rs.hashI16(i, self._0); } -export function writeI32$hash_Hasher(self: DefaultHasher, i: rt.i32): void { - rt.hashI32(i, self._0); +export function writeI32$hash_Hasher(self: DefaultHasher, i: rs.i32): void { + rs.hashI32(i, self._0); } -export function writeI64$hash_Hasher(self: DefaultHasher, i: rt.i64): void { - rt.hashI64(i, self._0); +export function writeI64$hash_Hasher(self: DefaultHasher, i: rs.i64): void { + rs.hashI64(i, self._0); } -export function writeI128$hash_Hasher(self: DefaultHasher, i: rt.i128): void { - rt.hashI128(i, self._0); +export function writeI128$hash_Hasher(self: DefaultHasher, i: rs.i128): void { + rs.hashI128(i, self._0); } -export function writeIsize$hash_Hasher(self: DefaultHasher, i: rt.isize): void { - rt.hashIsize(i, self._0); +export function writeIsize$hash_Hasher(self: DefaultHasher, i: rs.isize): void { + rs.hashIsize(i, self._0); } //# sourceMappingURL=hashlink.DefaultHasher.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Drain.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Drain.ts index d7675847a..0a051c8a6 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Drain.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Drain.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32, pushFree$u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; export class Drain { - free: rt.Place | undefined>; + free: rs.Place | undefined>; head: Node.Node | undefined; tail: Node.Node | undefined; - remaining: rt.usize; + remaining: rs.usize; marker: undefined; - constructor(free: rt.Place | undefined>, head: Node.Node | undefined, tail: Node.Node | undefined, remaining: rt.usize, marker: undefined) { + constructor(free: rs.Place | undefined>, head: Node.Node | undefined, tail: Node.Node | undefined, remaining: rs.usize, marker: undefined) { this.free = free; this.head = head; this.tail = tail; @@ -20,40 +20,40 @@ export class Drain { } } -export function next$iter_Iterator_u16_u32(self: Drain): [rt.u16, rt.u32] | rt.Done { +export function next$iter_Iterator_u16_u32(self: Drain): [rs.u16, rs.u32] | rs.Done { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); - self.head = head.links.at0 as Node.Node; - const entry: [rt.u16, rt.u32] = Node.takeEntry$u16_u32(head); + self.remaining = rs.usizeSub(self.remaining, 1); + const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); + self.head = head.links.at0 as Node.Node; + const entry: [rs.u16, rs.u32] = Node.takeEntry$u16_u32(head); pushFree$u16_u32(self.free, head); return entry; } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator_u16_u32(self: Drain): [rt.usize, rt.usize | undefined] { - return [self.remaining, self.remaining] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator_u16_u32(self: Drain): [rs.usize, rs.usize | undefined] { + return [self.remaining, self.remaining] as [rs.usize, rs.usize | undefined]; } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Drain): [rt.u16, rt.u32] | undefined { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Drain): [rs.u16, rs.u32] | undefined { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); + self.remaining = rs.usizeSub(self.remaining, 1); + const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); self.tail = tail.links.at4; - const entry: [rt.u16, rt.u32] = Node.takeEntry$u16_u32(tail); + const entry: [rs.u16, rs.u32] = Node.takeEntry$u16_u32(tail); pushFree$u16_u32(self.free, tail); return entry; } return undefined; } -export function drop$ops_Drop_u16_u32(self: Drain): void { - const _4: rt.usize = self.remaining; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _4; +export function drop$ops_Drop_u16_u32(self: Drain): void { + const _4: rs.usize = self.remaining; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _4; while (iterStart++ < iterEnd) { - const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); + const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); self.tail = tail.links.at4; Node.takeEntry$u16_u32(tail); pushFree$u16_u32(self.free, tail); diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.DropFilteredValues.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.DropFilteredValues.ts index f765b87e8..6945f9a8a 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.DropFilteredValues.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.DropFilteredValues.ts @@ -1,32 +1,32 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32, detachNode$u16_u32, pushFree$u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; export class DropFilteredValues { - free: rt.Place | undefined>; + free: rs.Place | undefined>; curFree: Node.Node | undefined; - constructor(free: rt.Place | undefined>, curFree: Node.Node | undefined) { + constructor(free: rs.Place | undefined>, curFree: Node.Node | undefined) { this.free = free; this.curFree = curFree; } } -export function dropLater$u16_u32(self: DropFilteredValues, node: Node.Node): void { +export function dropLater$u16_u32(self: DropFilteredValues, node: Node.Node): void { detachNode$u16_u32(node); - pushFree$u16_u32(rt.place(() => self.curFree, (value) => self.curFree = value), node); + pushFree$u16_u32(rs.place(() => self.curFree, (value) => self.curFree = value), node); } -export function drop$ops_Drop_u16_u32(self: DropFilteredValues): void { - let endFree!: Node.Node | undefined; +export function drop$ops_Drop_u16_u32(self: DropFilteredValues): void { + let endFree!: Node.Node | undefined; while (true) { endFree = self.curFree; if (!(self.curFree !== self.free.v)) { break; } - const curFree: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.curFree); + const curFree: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.curFree); Node.takeEntry$u16_u32(curFree); self.curFree = curFree.links.at0; } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.IntoIter.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.IntoIter.ts index c17dbebe8..e813754cb 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.IntoIter.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.IntoIter.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; export class IntoIter { head: Node.Node | undefined; tail: Node.Node | undefined; - remaining: rt.usize; + remaining: rs.usize; marker: undefined; - constructor(head: Node.Node | undefined, tail: Node.Node | undefined, remaining: rt.usize, marker: undefined) { + constructor(head: Node.Node | undefined, tail: Node.Node | undefined, remaining: rs.usize, marker: undefined) { this.head = head; this.tail = tail; this.remaining = remaining; @@ -18,36 +18,36 @@ export class IntoIter { } } -export function next$iter_Iterator_u16_u32(self: IntoIter): [rt.u16, rt.u32] | rt.Done { +export function next$iter_Iterator_u16_u32(self: IntoIter): [rs.u16, rs.u32] | rs.Done { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); - self.head = head.links.at0 as Node.Node; + self.remaining = rs.usizeSub(self.remaining, 1); + const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); + self.head = head.links.at0 as Node.Node; return Node.takeEntry$u16_u32(head); } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator_u16_u32(self: IntoIter): [rt.usize, rt.usize | undefined] { - return [self.remaining, self.remaining] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator_u16_u32(self: IntoIter): [rs.usize, rs.usize | undefined] { + return [self.remaining, self.remaining] as [rs.usize, rs.usize | undefined]; } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: IntoIter): [rt.u16, rt.u32] | undefined { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: IntoIter): [rs.u16, rs.u32] | undefined { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const e: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); + self.remaining = rs.usizeSub(self.remaining, 1); + const e: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); self.tail = e.links.at4; return Node.takeEntry$u16_u32(e); } return undefined; } -export function drop$ops_Drop_u16_u32(self: IntoIter): void { - const _4: rt.usize = self.remaining; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = _4; +export function drop$ops_Drop_u16_u32(self: IntoIter): void { + const _4: rs.usize = self.remaining; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = _4; while (iterStart++ < iterEnd) { - const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); + const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); self.tail = tail.links.at4; Node.takeEntry$u16_u32(tail); } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Iter.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Iter.ts index c552b471d..4662acc07 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Iter.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Iter.ts @@ -1,36 +1,36 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; export interface Iter { head: Node.Node; tail: Node.Node; - remaining: rt.usize; + remaining: rs.usize; marker: undefined; } -export function next$iter_Iterator_u16_u32(self: Iter): [rt.u16, rt.u32] | rt.Done { +export function next$iter_Iterator_u16_u32(self: Iter): [rs.u16, rs.u32] | rs.Done { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const _7: [rt.u16, rt.u32] = Node.entryRef$u16_u32(self.head); - self.head = self.head.links.at0 as Node.Node; - return [_7[0], _7[1]] as [rt.u16, rt.u32]; + self.remaining = rs.usizeSub(self.remaining, 1); + const _7: [rs.u16, rs.u32] = Node.entryRef$u16_u32(self.head); + self.head = self.head.links.at0 as Node.Node; + return [_7[0], _7[1]] as [rs.u16, rs.u32]; } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator_u16_u32(self: Iter): [rt.usize, rt.usize | undefined] { - return [self.remaining, self.remaining] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator_u16_u32(self: Iter): [rs.usize, rs.usize | undefined] { + return [self.remaining, self.remaining] as [rs.usize, rs.usize | undefined]; } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Iter): [rt.u16, rt.u32] | undefined { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Iter): [rs.u16, rs.u32] | undefined { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const tail: Node.Node = self.tail; + self.remaining = rs.usizeSub(self.remaining, 1); + const tail: Node.Node = self.tail; self.tail = tail.links.at4; - const _10: [rt.u16, rt.u32] = Node.entryRef$u16_u32(tail); - return [_10[0], _10[1]] as [rt.u16, rt.u32]; + const _10: [rs.u16, rs.u32] = Node.entryRef$u16_u32(tail); + return [_10[0], _10[1]] as [rs.u16, rs.u32]; } return undefined; } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.IterMut.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.IterMut.ts index 66ae0299c..ca109234f 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.IterMut.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.IterMut.ts @@ -1,38 +1,38 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; export interface IterMut { head: Node.Node | undefined; tail: Node.Node | undefined; - remaining: rt.usize; + remaining: rs.usize; marker: undefined; } -export function next$iter_Iterator_u16_u32(self: IterMut): [rt.u16, rt.Place] | rt.Done { +export function next$iter_Iterator_u16_u32(self: IterMut): [rs.u16, rs.Place] | rs.Done { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); - const _9: [rt.u16, rt.u32] = Node.entryMut$u16_u32(head); - self.head = head.links.at0 as Node.Node; - return [_9[0], rt.place(() => _9[1], (value) => _9[1] = value)] as [rt.u16, rt.Place]; + self.remaining = rs.usizeSub(self.remaining, 1); + const head: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.head); + const _9: [rs.u16, rs.u32] = Node.entryMut$u16_u32(head); + self.head = head.links.at0 as Node.Node; + return [_9[0], rs.place(() => _9[1], (value) => _9[1] = value)] as [rs.u16, rs.Place]; } - return rt.DONE; + return rs.DONE; } -export function sizeHint$iter_Iterator_u16_u32(self: IterMut): [rt.usize, rt.usize | undefined] { - return [self.remaining, self.remaining] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator_u16_u32(self: IterMut): [rs.usize, rs.usize | undefined] { + return [self.remaining, self.remaining] as [rs.usize, rs.usize | undefined]; } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: IterMut): [rt.u16, rt.Place] | undefined { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: IterMut): [rs.u16, rs.Place] | undefined { if (!(self.remaining === 0)) { - self.remaining = rt.usizeSub(self.remaining, 1); - const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); + self.remaining = rs.usizeSub(self.remaining, 1); + const tail: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.tail); self.tail = tail.links.at4; - const _11: [rt.u16, rt.u32] = Node.entryMut$u16_u32(tail); - return [_11[0], rt.place(() => _11[1], (value) => _11[1] = value)] as [rt.u16, rt.Place]; + const _11: [rs.u16, rs.u32] = Node.entryMut$u16_u32(tail); + return [_11[0], rs.place(() => _11[1], (value) => _11[1] = value)] as [rs.u16, rs.Place]; } return undefined; } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Keys.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Keys.ts index 54dd3fc38..f43401b89 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Keys.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Keys.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { map$127uyaz as option_map$127uyaz } from "../core/option.ts"; +import * as rs from "../rs.ts"; +import { map$1uqo0rf as option_map$1uqo0rf } from "../core/option.ts"; import * as linked_hash_map_Iter from "../hashlink/linked_hash_map.Iter.ts"; export interface Keys { inner: linked_hash_map_Iter.Iter; } -export function next$iter_Iterator_u16_u32(self: Keys): rt.u16 | rt.Done { - return rt.iterFromOption(option_map$127uyaz(rt.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(self.inner)), (e: [rt.u16, rt.u32]): rt.u16 => { +export function next$iter_Iterator_u16_u32(self: Keys): rs.u16 | rs.Done { + return rs.iterFromOption(option_map$1uqo0rf(rs.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(self.inner)), (e: [rs.u16, rs.u32]): rs.u16 => { return e[0]; })); } -export function sizeHint$iter_Iterator_u16_u32(self: Keys): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator_u16_u32(self: Keys): [rs.usize, rs.usize | undefined] { return linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32(self.inner); } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Keys): rt.u16 | undefined { - return option_map$127uyaz(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rt.u16, rt.u32]): rt.u16 => { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Keys): rs.u16 | undefined { + return option_map$1uqo0rf(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rs.u16, rs.u32]): rs.u16 => { return e[0]; }); } -export function len$iter_ExactSizeIterator_u16_u32(self: Keys): rt.usize { - return rt.iterFrom(self.inner, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); +export function len$iter_ExactSizeIterator_u16_u32(self: Keys): rs.usize { + return rs.iterFrom(self.inner, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); } //# sourceMappingURL=linked_hash_map.Keys.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.LinkedHashMap.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.LinkedHashMap.ts index f13a9ea95..8d3178ba1 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.LinkedHashMap.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.LinkedHashMap.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState as lib_drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState, drop$hashlink_linked_hash_map_DropFilteredValues_u16_u32 as lib_drop$hashlink_linked_hash_map_DropFilteredValues_u16_u32 } from "../lib.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32, dropValueNodes$maps_Logged_maps_Logged, dropValueNodes$maps_Logged_unit, dropValueNodes$sync_Arc_str_u32, dropValueNodes$u16_maps_Logged, dropValueNodes$u16_u32, dropFreeNodes$maps_Logged_maps_Logged, dropFreeNodes$maps_Logged_unit, dropFreeNodes$sync_Arc_str_u32, dropFreeNodes$u16_maps_Logged, dropFreeNodes$u16_u32, hashNode$hashlink_DefaultHashBuilder_maps_Logged_maps_Logged, hashNode$hashlink_DefaultHashBuilder_sync_Arc_str_u32, hashNode$hashlink_DefaultHashBuilder_u16_maps_Logged, hashNode$hashlink_DefaultHashBuilder_u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as linked_hash_map_Drain from "../hashlink/linked_hash_map.Drain.ts"; @@ -38,12 +38,12 @@ import * as Logged from "../maps.Logged.ts"; * back*. */ export class LinkedHashMap { - table: rt.HashTable>; + table: rs.HashTable>; hashBuilder: S; values: Node.Node | undefined; free: Node.Node | undefined; - constructor(table: rt.HashTable>, hashBuilder: S, values: Node.Node | undefined, free: Node.Node | undefined) { + constructor(table: rs.HashTable>, hashBuilder: S, values: Node.Node | undefined, free: Node.Node | undefined) { this.table = table; this.hashBuilder = hashBuilder; this.values = values; @@ -53,152 +53,152 @@ export class LinkedHashMap { export function new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(): LinkedHashMap { const _1: DefaultHashBuilder.DefaultHashBuilder = DefaultHashBuilder.default$Default(); - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, _1, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, _1, undefined, undefined); } export function new$maps_Logged_unit_hashlink_DefaultHashBuilder(): LinkedHashMap { const _1: DefaultHashBuilder.DefaultHashBuilder = DefaultHashBuilder.default$Default(); - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, _1, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, _1, undefined, undefined); } -export function new$sync_Arc_str_u32_hashlink_DefaultHashBuilder(): LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function new$sync_Arc_str_u32_hashlink_DefaultHashBuilder(): LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { const _1: DefaultHashBuilder.DefaultHashBuilder = DefaultHashBuilder.default$Default(); - return new LinkedHashMap(rt.hashNew() as rt.HashTable, rt.u32>>, _1, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable, rs.u32>>, _1, undefined, undefined); } -export function new$u16_maps_Logged_hashlink_DefaultHashBuilder(): LinkedHashMap { +export function new$u16_maps_Logged_hashlink_DefaultHashBuilder(): LinkedHashMap { const _1: DefaultHashBuilder.DefaultHashBuilder = DefaultHashBuilder.default$Default(); - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, _1, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, _1, undefined, undefined); } -export function new$u16_u32_hashlink_DefaultHashBuilder(): LinkedHashMap { +export function new$u16_u32_hashlink_DefaultHashBuilder(): LinkedHashMap { const _1: DefaultHashBuilder.DefaultHashBuilder = DefaultHashBuilder.default$Default(); - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, _1, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, _1, undefined, undefined); } export function withHasher$maps_Logged_unit_hashlink_DefaultHashBuilder(hashBuilder: DefaultHashBuilder.DefaultHashBuilder): LinkedHashMap { - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, hashBuilder, undefined, undefined); + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, hashBuilder, undefined, undefined); } -export function withHasher$u16_u32_hash_RandomState(hashBuilder: rt.RandomState): LinkedHashMap { - return new LinkedHashMap(rt.hashNew() as rt.HashTable>, hashBuilder, undefined, undefined); +export function withHasher$u16_u32_hash_RandomState(hashBuilder: rs.RandomState): LinkedHashMap { + return new LinkedHashMap(rs.hashNew() as rs.HashTable>, hashBuilder, undefined, undefined); } -export function len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): rt.usize { - return rt.hashLen(self.table); +export function len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): rs.usize { + return rs.hashLen(self.table); } -export function len$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): rt.usize { - return rt.hashLen(self.table); +export function len$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): rs.usize { + return rs.hashLen(self.table); } -export function len$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): rt.usize { - return rt.hashLen(self.table); +export function len$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): rs.usize { + return rs.hashLen(self.table); } -export function len$u16_u32_hash_RandomState(self: LinkedHashMap): rt.usize { - return rt.hashLen(self.table); +export function len$u16_u32_hash_RandomState(self: LinkedHashMap): rs.usize { + return rs.hashLen(self.table); } -export function len$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): rt.usize { - return rt.hashLen(self.table); +export function len$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): rs.usize { + return rs.hashLen(self.table); } export function isEmpty$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): boolean { return len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self) === 0; } -export function isEmpty$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): boolean { +export function isEmpty$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): boolean { return len$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self) === 0; } -export function isEmpty$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): boolean { +export function isEmpty$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): boolean { return len$u16_maps_Logged_hashlink_DefaultHashBuilder(self) === 0; } -export function isEmpty$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): boolean { +export function isEmpty$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): boolean { return len$u16_u32_hashlink_DefaultHashBuilder(self) === 0; } -export function iter$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Iter.Iter { - let _4!: [Node.Node, Node.Node]; +export function iter$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Iter.Iter { + let _4!: [Node.Node, Node.Node]; if (self.values !== undefined) { - const _9: Node.Node = self.values; - _4 = [_9.links.at0 as Node.Node, _9.links.at4] as [Node.Node, Node.Node]; + const _9: Node.Node = self.values; + _4 = [_9.links.at0 as Node.Node, _9.links.at4] as [Node.Node, Node.Node]; } else { - _4 = [rt.NULL, rt.NULL] as [Node.Node, Node.Node]; + _4 = [rs.NULL, rs.NULL] as [Node.Node, Node.Node]; } return { head: _4[0], tail: _4[1], remaining: len$u16_u32_hash_RandomState(self), marker: undefined }; } -export function iterMut$u16_u32_hash_RandomState(self: LinkedHashMap): IterMut.IterMut { - let _4!: [Node.Node | undefined, Node.Node | undefined]; +export function iterMut$u16_u32_hash_RandomState(self: LinkedHashMap): IterMut.IterMut { + let _4!: [Node.Node | undefined, Node.Node | undefined]; if (self.values !== undefined) { - const _9: Node.Node = self.values; - _4 = [_9.links.at0 as Node.Node, _9.links.at4] as [Node.Node | undefined, Node.Node | undefined]; + const _9: Node.Node = self.values; + _4 = [_9.links.at0 as Node.Node, _9.links.at4] as [Node.Node | undefined, Node.Node | undefined]; } else { - _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; + _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; } return { head: _4[0], tail: _4[1], remaining: len$u16_u32_hash_RandomState(self), marker: undefined }; } -export function drain$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Drain.Drain { - let _4!: [Node.Node | undefined, Node.Node | undefined]; +export function drain$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Drain.Drain { + let _4!: [Node.Node | undefined, Node.Node | undefined]; if (self.values !== undefined) { - const values: Node.Node = self.values; - const _9: Node.Node = values; - const next: Node.Node = _9.links.at0 as Node.Node; - const prev: Node.Node = _9.links.at4; - const _11: ValueLinks.ValueLinks = { next: values, prev: values }; - const _14: Node.Node = values; + const values: Node.Node = self.values; + const _9: Node.Node = values; + const next: Node.Node = _9.links.at0 as Node.Node; + const prev: Node.Node = _9.links.at4; + const _11: ValueLinks.ValueLinks = { next: values, prev: values }; + const _14: Node.Node = values; _14.links.at0 = _11.next; _14.links.at4 = _11.prev; - _4 = [next, prev] as [Node.Node | undefined, Node.Node | undefined]; + _4 = [next, prev] as [Node.Node | undefined, Node.Node | undefined]; } else { - _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; + _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; } - const head: Node.Node | undefined = _4[0]; - const tail: Node.Node | undefined = _4[1]; - const len: rt.usize = len$u16_u32_hash_RandomState(self); - rt.hashClear(self.table, undefined); - return new linked_hash_map_Drain.Drain(rt.place(() => self.free, (value) => self.free = value), head, tail, len, undefined); + const head: Node.Node | undefined = _4[0]; + const tail: Node.Node | undefined = _4[1]; + const len: rs.usize = len$u16_u32_hash_RandomState(self); + rs.hashClear(self.table, undefined); + return new linked_hash_map_Drain.Drain(rs.place(() => self.free, (value) => self.free = value), head, tail, len, undefined); } -export function keys$u16_u32_hash_RandomState(self: LinkedHashMap): Keys.Keys { +export function keys$u16_u32_hash_RandomState(self: LinkedHashMap): Keys.Keys { return { inner: iter$u16_u32_hash_RandomState(self) }; } -export function values$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Values.Values { +export function values$u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_Values.Values { return { inner: iter$u16_u32_hash_RandomState(self) }; } -export function valuesMut$u16_u32_hash_RandomState(self: LinkedHashMap): ValuesMut.ValuesMut { +export function valuesMut$u16_u32_hash_RandomState(self: LinkedHashMap): ValuesMut.ValuesMut { return { inner: iterMut$u16_u32_hash_RandomState(self) }; } -export function front$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rt.u16, rt.u32] | undefined { +export function front$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rs.u16, rs.u32] | undefined { if (!isEmpty$u16_u32_hashlink_DefaultHashBuilder(self)) { - const _9: [rt.u16, rt.u32] = Node.entryRef$u16_u32(asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at0 as Node.Node); - return [_9[0], _9[1]] as [rt.u16, rt.u32]; + const _9: [rs.u16, rs.u32] = Node.entryRef$u16_u32(asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at0 as Node.Node); + return [_9[0], _9[1]] as [rs.u16, rs.u32]; } return undefined; } -export function back$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rt.u16, rt.u32] | undefined { +export function back$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rs.u16, rs.u32] | undefined { if (!isEmpty$u16_u32_hashlink_DefaultHashBuilder(self)) { - const _10: [rt.u16, rt.u32] = Node.entryRef$u16_u32(asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at4); - return [_10[0], _10[1]] as [rt.u16, rt.u32]; + const _10: [rs.u16, rs.u32] = Node.entryRef$u16_u32(asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at4); + return [_10[0], _10[1]] as [rs.u16, rs.u32]; } return undefined; } -export function retain$u16_u32_hashlink_DefaultHashBuilder_maps_linked_closure11(self: LinkedHashMap, f: (a0: rt.u16, a1: rt.Place) => boolean): void { - const free: Node.Node | undefined = self.free; - const dropFilteredValues: DropFilteredValues.DropFilteredValues = new DropFilteredValues.DropFilteredValues(rt.place(() => self.free, (value) => self.free = value), free); - rt.tableRetainMut(self.table, (_2: rt.Place>): boolean => { - const node: Node.Node = _2.v; - const _6: [rt.u16, rt.u32] = Node.entryMut$u16_u32(node); - if (!f(_6[0], rt.place(() => _6[1], (value2) => _6[1] = value2))) { +export function retain$u16_u32_hashlink_DefaultHashBuilder_maps_linked_closure11(self: LinkedHashMap, f: (a0: rs.u16, a1: rs.Place) => boolean): void { + const free: Node.Node | undefined = self.free; + const dropFilteredValues: DropFilteredValues.DropFilteredValues = new DropFilteredValues.DropFilteredValues(rs.place(() => self.free, (value) => self.free = value), free); + rs.tableRetainMut(self.table, (_2: rs.Place>): boolean => { + const node: Node.Node = _2.v; + const _6: [rs.u16, rs.u32] = Node.entryMut$u16_u32(node); + if (!f(_6[0], rs.place(() => _6[1], (value2) => _6[1] = value2))) { DropFilteredValues.dropLater$u16_u32(dropFilteredValues, node); return false; } @@ -207,8 +207,8 @@ export function retain$u16_u32_hashlink_DefaultHashBuilder_maps_linked_closure11 lib_drop$hashlink_linked_hash_map_DropFilteredValues_u16_u32(dropFilteredValues); } -export function capacity$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): rt.usize { - return rt.hashCapacity(self.table); +export function capacity$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): rs.usize { + return rs.hashCapacity(self.table); } /** @@ -245,8 +245,8 @@ export function insert$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: * Returns the previously set value, if one existed prior to this call. After this call, * calling `LinkedHashMap::back` will return a reference to this key / value pair. */ -export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: Logged.Logged, _: undefined): undefined | rt.None { - let _0!: undefined | rt.None; +export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: Logged.Logged, _: undefined): undefined | rs.None { + let _0!: undefined | rs.None; let _16: boolean = false; _16 = true; const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(rawEntryMut$maps_Logged_unit_hashlink_DefaultHashBuilder(self), k); @@ -259,7 +259,7 @@ export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: Linked const vacant: RawVacantEntryMut.RawVacantEntryMut = _4._0; _16 = false; RawVacantEntryMut.insert$maps_Logged_unit_hashlink_DefaultHashBuilder(vacant, k, undefined); - _0 = rt.None; + _0 = rs.None; } if (_16) { k[Symbol.dispose](); @@ -274,17 +274,17 @@ export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: Linked * Returns the previously set value, if one existed prior to this call. After this call, * calling `LinkedHashMap::back` will return a reference to this key / value pair. */ -export function insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, k: rt.Arc, v: rt.u32): rt.u32 | undefined { - let _0!: rt.u32 | undefined; +export function insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, k: rs.Arc, v: rs.u32): rs.u32 | undefined { + let _0!: rs.u32 | undefined; let _16: boolean = false; _16 = true; - const _4: RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); + const _4: RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); if (_4.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = _4._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = _4._0; RawOccupiedEntryMut.toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder(occupied); _0 = RawOccupiedEntryMut.replaceValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(occupied, v); } else { - const vacant: RawVacantEntryMut.RawVacantEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = _4._0; + const vacant: RawVacantEntryMut.RawVacantEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = _4._0; _16 = false; RawVacantEntryMut.insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(vacant, k, v); _0 = undefined; @@ -302,10 +302,10 @@ export function insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: Linked * Returns the previously set value, if one existed prior to this call. After this call, * calling `LinkedHashMap::back` will return a reference to this key / value pair. */ -export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: rt.u16, v: Logged.Logged): Logged.Logged | undefined { - const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self), k); +export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: rs.u16, v: Logged.Logged): Logged.Logged | undefined { + const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self), k); if (_4.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; RawOccupiedEntryMut.toBack$u16_maps_Logged_hashlink_DefaultHashBuilder(occupied); return RawOccupiedEntryMut.replaceValue$u16_maps_Logged_hashlink_DefaultHashBuilder(occupied, v); } @@ -319,10 +319,10 @@ export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedH * Returns the previously set value, if one existed prior to this call. After this call, * calling `LinkedHashMap::back` will return a reference to this key / value pair. */ -export function insert$u16_u32_hash_RandomState(self: LinkedHashMap, k: rt.u16, v: rt.u32): rt.u32 | undefined { - const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hash_RandomState_u16(rawEntryMut$u16_u32_hash_RandomState(self), k); +export function insert$u16_u32_hash_RandomState(self: LinkedHashMap, k: rs.u16, v: rs.u32): rs.u32 | undefined { + const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hash_RandomState_u16(rawEntryMut$u16_u32_hash_RandomState(self), k); if (_4.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; RawOccupiedEntryMut.toBack$u16_u32_hash_RandomState(occupied); return RawOccupiedEntryMut.replaceValue$u16_u32_hash_RandomState(occupied, v); } @@ -336,10 +336,10 @@ export function insert$u16_u32_hash_RandomState(self: LinkedHashMap, k: rt.u16, v: rt.u32): rt.u32 | undefined { - const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); +export function insert$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: rs.u16, v: rs.u32): rs.u32 | undefined { + const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); if (_4.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; RawOccupiedEntryMut.toBack$u16_u32_hashlink_DefaultHashBuilder(occupied); return RawOccupiedEntryMut.replaceValue$u16_u32_hashlink_DefaultHashBuilder(occupied, v); } @@ -353,10 +353,10 @@ export function insert$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: rt.u16, v: rt.u32): rt.u32 | undefined { - const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); +export function insertFront$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, k: rs.u16, v: rs.u32): rs.u32 | undefined { + const _4: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); if (_4.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _4._0; RawOccupiedEntryMut.toFront$u16_u32_hashlink_DefaultHashBuilder(occupied); return RawOccupiedEntryMut.replaceValue$u16_u32_hashlink_DefaultHashBuilder(occupied, v); } @@ -372,25 +372,25 @@ export function remove$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_ return undefined; } -export function remove$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: LinkedHashMap, k: Logged.Logged): undefined | rt.None { +export function remove$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: LinkedHashMap, k: Logged.Logged): undefined | rs.None { const _3: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(rawEntryMut$maps_Logged_unit_hashlink_DefaultHashBuilder(self), k); if (_3.tag === "Occupied") { RawOccupiedEntryMut.remove$maps_Logged_unit_hashlink_DefaultHashBuilder(_3._0); return undefined; } - return rt.None; + return rs.None; } -export function remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): rt.u32 | undefined { - const _3: RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); +export function remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): rs.u32 | undefined { + const _3: RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); if (_3.tag === "Occupied") { return RawOccupiedEntryMut.remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder(_3._0); } return undefined; } -export function remove$u16_u32_hashlink_DefaultHashBuilder_u16(self: LinkedHashMap, k: rt.u16): rt.u32 | undefined { - const _3: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); +export function remove$u16_u32_hashlink_DefaultHashBuilder_u16(self: LinkedHashMap, k: rs.u16): rs.u32 | undefined { + const _3: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); if (_3.tag === "Occupied") { return RawOccupiedEntryMut.remove$u16_u32_hashlink_DefaultHashBuilder(_3._0); } @@ -400,7 +400,7 @@ export function remove$u16_u32_hashlink_DefaultHashBuilder_u16(self: LinkedHashM export function popFront$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): [Logged.Logged, Logged.Logged] | undefined { if (!isEmpty$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self)) { const front: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged(self.values).links.at0 as Node.Node; - const hash: rt.u64 = hashNode$hashlink_DefaultHashBuilder_maps_Logged_maps_Logged(self.hashBuilder, front); + const hash: rs.u64 = hashNode$hashlink_DefaultHashBuilder_maps_Logged_maps_Logged(self.hashBuilder, front); const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(rawEntryMut$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self), hash, (k: Logged.Logged): boolean => { return Logged.eq$cmp_PartialEq(k, Node.keyRef$maps_Logged_maps_Logged(front)); }); @@ -412,13 +412,13 @@ export function popFront$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(sel return undefined; } -export function popFront$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): [rt.Arc, rt.u32] | undefined { +export function popFront$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): [rs.Arc, rs.u32] | undefined { if (!isEmpty$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self)) { - const front: Node.Node, rt.u32> = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self.values).links.at0 as Node.Node, rt.u32>; - const hash: rt.u64 = hashNode$hashlink_DefaultHashBuilder_sync_Arc_str_u32(self.hashBuilder, front); - const _9: RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), hash, (k: rt.Arc): boolean => { - const _3: rt.Arc = Node.keyRef$sync_Arc_str_u32(front); - return rt.eqArc(rt.same, true)(k, _3); + const front: Node.Node, rs.u32> = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self.values).links.at0 as Node.Node, rs.u32>; + const hash: rs.u64 = hashNode$hashlink_DefaultHashBuilder_sync_Arc_str_u32(self.hashBuilder, front); + const _9: RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), hash, (k: rs.Arc): boolean => { + const _3: rs.Arc = Node.keyRef$sync_Arc_str_u32(front); + return rs.eqArc(rs.same, true)(k, _3); }); if (_9.tag === "Occupied") { return RawOccupiedEntryMut.removeEntry$sync_Arc_str_u32_hashlink_DefaultHashBuilder(_9._0); @@ -428,11 +428,11 @@ export function popFront$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: Link return undefined; } -export function popFront$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rt.u16, Logged.Logged] | undefined { +export function popFront$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rs.u16, Logged.Logged] | undefined { if (!isEmpty$u16_maps_Logged_hashlink_DefaultHashBuilder(self)) { - const front: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self.values).links.at0 as Node.Node; - const hash: rt.u64 = hashNode$hashlink_DefaultHashBuilder_u16_maps_Logged(self.hashBuilder, front); - const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self), hash, (k: rt.u16): boolean => { + const front: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self.values).links.at0 as Node.Node; + const hash: rs.u64 = hashNode$hashlink_DefaultHashBuilder_u16_maps_Logged(self.hashBuilder, front); + const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self), hash, (k: rs.u16): boolean => { return k === Node.keyRef$u16_maps_Logged(front); }); if (_9.tag === "Occupied") { @@ -443,11 +443,11 @@ export function popFront$u16_maps_Logged_hashlink_DefaultHashBuilder(self: Linke return undefined; } -export function popFront$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rt.u16, rt.u32] | undefined { +export function popFront$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rs.u16, rs.u32] | undefined { if (!isEmpty$u16_u32_hashlink_DefaultHashBuilder(self)) { - const front: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at0 as Node.Node; - const hash: rt.u64 = hashNode$hashlink_DefaultHashBuilder_u16_u32(self.hashBuilder, front); - const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_u32_hashlink_DefaultHashBuilder(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), hash, (k: rt.u16): boolean => { + const front: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at0 as Node.Node; + const hash: rs.u64 = hashNode$hashlink_DefaultHashBuilder_u16_u32(self.hashBuilder, front); + const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_u32_hashlink_DefaultHashBuilder(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), hash, (k: rs.u16): boolean => { return k === Node.keyRef$u16_u32(front); }); if (_9.tag === "Occupied") { @@ -458,11 +458,11 @@ export function popFront$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap return undefined; } -export function popBack$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rt.u16, rt.u32] | undefined { +export function popBack$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): [rs.u16, rs.u32] | undefined { if (!isEmpty$u16_u32_hashlink_DefaultHashBuilder(self)) { - const back: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at4; - const hash: rt.u64 = hashNode$hashlink_DefaultHashBuilder_u16_u32(self.hashBuilder, back); - const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_back_closure0_u16_u32_hashlink_DefaultHashBuilder(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), hash, (k: rt.u16): boolean => { + const back: Node.Node = asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values).links.at4; + const hash: rs.u64 = hashNode$hashlink_DefaultHashBuilder_u16_u32(self.hashBuilder, back); + const _9: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_back_closure0_u16_u32_hashlink_DefaultHashBuilder(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), hash, (k: rs.u16): boolean => { return k === Node.keyRef$u16_u32(back); }); if (_9.tag === "Occupied") { @@ -477,10 +477,10 @@ export function popBack$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap< * If an entry with this key exists, move it to the back of the list and return a reference to * the value. */ -export function toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): rt.Place | undefined { - const _3: RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); +export function toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): rs.Place | undefined { + const _3: RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = RawEntryBuilderMut.fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self), k); if (_3.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = _3._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = _3._0; RawOccupiedEntryMut.toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder(occupied); return RawOccupiedEntryMut.intoMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(occupied); } @@ -491,10 +491,10 @@ export function toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: Li * If an entry with this key exists, move it to the back of the list and return a reference to * the value. */ -export function toBack$u16_u32_hashlink_DefaultHashBuilder_u16(self: LinkedHashMap, k: rt.u16): rt.Place | undefined { - const _3: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); +export function toBack$u16_u32_hashlink_DefaultHashBuilder_u16(self: LinkedHashMap, k: rs.u16): rs.Place | undefined { + const _3: RawEntryMut.RawEntryMut = RawEntryBuilderMut.fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self), k); if (_3.tag === "Occupied") { - const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _3._0; + const occupied: RawOccupiedEntryMut.RawOccupiedEntryMut = _3._0; RawOccupiedEntryMut.toBack$u16_u32_hashlink_DefaultHashBuilder(occupied); return RawOccupiedEntryMut.intoMut$u16_u32_hashlink_DefaultHashBuilder(occupied); } @@ -509,19 +509,19 @@ export function rawEntryMut$maps_Logged_unit_hashlink_DefaultHashBuilder(self: L return { map: self }; } -export function rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): RawEntryBuilderMut.RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function rawEntryMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): RawEntryBuilderMut.RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { return { map: self }; } -export function rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { +export function rawEntryMut$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { return { map: self }; } -export function rawEntryMut$u16_u32_hash_RandomState(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { +export function rawEntryMut$u16_u32_hash_RandomState(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { return { map: self }; } -export function rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { +export function rawEntryMut$u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): RawEntryBuilderMut.RawEntryBuilderMut { return { map: self }; } @@ -547,61 +547,61 @@ export function drop$ops_Drop_maps_Logged_unit_hashlink_DefaultHashBuilder(self: dropFreeNodes$maps_Logged_unit(self.free); } -export function drop$ops_Drop_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): void { +export function drop$ops_Drop_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): void { if (self.values !== undefined) { - const values: Node.Node, rt.u32> = self.values; + const values: Node.Node, rs.u32> = self.values; dropValueNodes$sync_Arc_str_u32(values); values; } dropFreeNodes$sync_Arc_str_u32(self.free); } -export function drop$ops_Drop_u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): void { +export function drop$ops_Drop_u16_maps_Logged_hashlink_DefaultHashBuilder(self: LinkedHashMap): void { if (self.values !== undefined) { - const values: Node.Node = self.values; + const values: Node.Node = self.values; dropValueNodes$u16_maps_Logged(values); values; } dropFreeNodes$u16_maps_Logged(self.free); } -export function drop$ops_Drop_u16_u32_hash_RandomState(self: LinkedHashMap): void { +export function drop$ops_Drop_u16_u32_hash_RandomState(self: LinkedHashMap): void { if (self.values !== undefined) { - const values: Node.Node = self.values; + const values: Node.Node = self.values; dropValueNodes$u16_u32(values); values; } dropFreeNodes$u16_u32(self.free); } -export function drop$ops_Drop_u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): void { +export function drop$ops_Drop_u16_u32_hashlink_DefaultHashBuilder(self: LinkedHashMap): void { if (self.values !== undefined) { - const values: Node.Node = self.values; + const values: Node.Node = self.values; dropValueNodes$u16_u32(values); values; } dropFreeNodes$u16_u32(self.free); } -export function intoIter$iter_IntoIterator_u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_IntoIter.IntoIter { - let _4!: [Node.Node | undefined, Node.Node | undefined]; +export function intoIter$iter_IntoIterator_u16_u32_hash_RandomState(self: LinkedHashMap): linked_hash_map_IntoIter.IntoIter { + let _4!: [Node.Node | undefined, Node.Node | undefined]; if (self.values !== undefined) { - const _9: Node.Node = self.values; - const head2: Node.Node = _9.links.at0 as Node.Node; - const tail2: Node.Node = _9.links.at4; + const _9: Node.Node = self.values; + const head2: Node.Node = _9.links.at0 as Node.Node; + const tail2: Node.Node = _9.links.at4; asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values); self.values = undefined; - _4 = [head2, tail2] as [Node.Node | undefined, Node.Node | undefined]; + _4 = [head2, tail2] as [Node.Node | undefined, Node.Node | undefined]; } else { - _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; + _4 = [undefined, undefined] as [Node.Node | undefined, Node.Node | undefined]; } - const head: Node.Node | undefined = _4[0]; - const tail: Node.Node | undefined = _4[1]; - const len: rt.usize = len$u16_u32_hash_RandomState(self); + const head: Node.Node | undefined = _4[0]; + const tail: Node.Node | undefined = _4[1]; + const len: rs.usize = len$u16_u32_hash_RandomState(self); const taken = self.free; self.free = undefined; dropFreeNodes$u16_u32(taken); - rt.hashClear(self.table, undefined); + rs.hashClear(self.table, undefined); lib_drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState(self); return new linked_hash_map_IntoIter.IntoIter(head, tail, len, undefined); } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Node.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Node.ts index 783f45a72..b5a9bf1fc 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Node.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Node.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$tuple2_maps_Logged_maps_Logged, copy$tuple2_maps_Logged_unit, copy$tuple2_sync_Arc_str_u32, copy$tuple2_u16_maps_Logged, copy$tuple2_u16_u32 } from "../lib.ts"; import type * as Links from "../hashlink/linked_hash_map.Links.ts"; import type * as Logged from "../maps.Logged.ts"; @@ -11,26 +11,26 @@ export interface Node { } export function putEntry$maps_Logged_maps_Logged(self: Node, entry: [Logged.Logged, Logged.Logged]): void { - rt.ptrWrite(self.entry, entry); + rs.ptrWrite(self.entry, entry); } export function putEntry$maps_Logged_unit(self: Node, entry: [Logged.Logged, undefined]): void { - rt.ptrWrite(self.entry, entry); + rs.ptrWrite(self.entry, entry); } -export function putEntry$sync_Arc_str_u32(self: Node, rt.u32>, entry: [rt.Arc, rt.u32]): void { - rt.ptrWrite(self.entry, entry); +export function putEntry$sync_Arc_str_u32(self: Node, rs.u32>, entry: [rs.Arc, rs.u32]): void { + rs.ptrWrite(self.entry, entry); } -export function putEntry$u16_maps_Logged(self: Node, entry: [rt.u16, Logged.Logged]): void { - rt.ptrWrite(self.entry, entry); +export function putEntry$u16_maps_Logged(self: Node, entry: [rs.u16, Logged.Logged]): void { + rs.ptrWrite(self.entry, entry); } -export function putEntry$u16_u32(self: Node, entry: [rt.u16, rt.u32]): void { - rt.ptrWrite(self.entry, copy$tuple2_u16_u32(entry)); +export function putEntry$u16_u32(self: Node, entry: [rs.u16, rs.u32]): void { + rs.ptrWrite(self.entry, copy$tuple2_u16_u32(entry)); } -export function entryRef$u16_u32(self: Node): [rt.u16, rt.u32] { +export function entryRef$u16_u32(self: Node): [rs.u16, rs.u32] { return self.entry; } @@ -42,15 +42,15 @@ export function keyRef$maps_Logged_unit(self: Node): L return self.entry[0]; } -export function keyRef$sync_Arc_str_u32(self: Node, rt.u32>): rt.Arc { +export function keyRef$sync_Arc_str_u32(self: Node, rs.u32>): rs.Arc { return self.entry[0]; } -export function keyRef$u16_maps_Logged(self: Node): rt.u16 { +export function keyRef$u16_maps_Logged(self: Node): rs.u16 { return self.entry[0]; } -export function keyRef$u16_u32(self: Node): rt.u16 { +export function keyRef$u16_u32(self: Node): rs.u16 { return self.entry[0]; } @@ -62,15 +62,15 @@ export function entryMut$maps_Logged_unit(self: Node): return self.entry; } -export function entryMut$sync_Arc_str_u32(self: Node, rt.u32>): [rt.Arc, rt.u32] { +export function entryMut$sync_Arc_str_u32(self: Node, rs.u32>): [rs.Arc, rs.u32] { return self.entry; } -export function entryMut$u16_maps_Logged(self: Node): [rt.u16, Logged.Logged] { +export function entryMut$u16_maps_Logged(self: Node): [rs.u16, Logged.Logged] { return self.entry; } -export function entryMut$u16_u32(self: Node): [rt.u16, rt.u32] { +export function entryMut$u16_u32(self: Node): [rs.u16, rs.u32] { return self.entry; } @@ -82,15 +82,15 @@ export function takeEntry$maps_Logged_unit(self: Node) return copy$tuple2_maps_Logged_unit(self.entry); } -export function takeEntry$sync_Arc_str_u32(self: Node, rt.u32>): [rt.Arc, rt.u32] { +export function takeEntry$sync_Arc_str_u32(self: Node, rs.u32>): [rs.Arc, rs.u32] { return copy$tuple2_sync_Arc_str_u32(self.entry); } -export function takeEntry$u16_maps_Logged(self: Node): [rt.u16, Logged.Logged] { +export function takeEntry$u16_maps_Logged(self: Node): [rs.u16, Logged.Logged] { return copy$tuple2_u16_maps_Logged(self.entry); } -export function takeEntry$u16_u32(self: Node): [rt.u16, rt.u32] { +export function takeEntry$u16_u32(self: Node): [rs.u16, rs.u32] { return copy$tuple2_u16_u32(self.entry); } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawEntryBuilderMut.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawEntryBuilderMut.ts index 719efe122..436e9ff26 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawEntryBuilderMut.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawEntryBuilderMut.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { hashKey$hash_RandomState_u16, hashKey$hashlink_DefaultHashBuilder_maps_Logged, hashKey$hashlink_DefaultHashBuilder_str, hashKey$hashlink_DefaultHashBuilder_sync_Arc_str, hashKey$hashlink_DefaultHashBuilder_u16 } from "../hashlink/linked_hash_map.ts"; import type * as LinkedHashMap from "../hashlink/linked_hash_map.LinkedHashMap.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; @@ -20,270 +20,270 @@ export function fromKey$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged return fromKeyHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self, hashKey$hashlink_DefaultHashBuilder_maps_Logged(self.map.hashBuilder, k), k); } -export function fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, k: string): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { return fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self, hashKey$hashlink_DefaultHashBuilder_str(self.map.hashBuilder, k), k); } -export function fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, k: rt.Arc): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function fromKey$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, k: rs.Arc): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { return fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self, hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(self.map.hashBuilder, k), k); } -export function fromKey$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, k: rt.u16): RawEntryMut.RawEntryMut { +export function fromKey$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, k: rs.u16): RawEntryMut.RawEntryMut { return fromKeyHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self, hashKey$hashlink_DefaultHashBuilder_u16(self.map.hashBuilder, k), k); } -export function fromKey$u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, k: rt.u16): RawEntryMut.RawEntryMut { +export function fromKey$u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, k: rs.u16): RawEntryMut.RawEntryMut { return fromKeyHashedNocheck$u16_u32_hash_RandomState_u16(self, hashKey$hash_RandomState_u16(self.map.hashBuilder, k), k); } -export function fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, k: rt.u16): RawEntryMut.RawEntryMut { +export function fromKey$u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, k: rs.u16): RawEntryMut.RawEntryMut { return fromKeyHashedNocheck$u16_u32_hashlink_DefaultHashBuilder_u16(self, hashKey$hashlink_DefaultHashBuilder_u16(self.map.hashBuilder, k), k); } -export function fromKeyHashedNocheck$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rt.u64, k: Logged.Logged): RawEntryMut.RawEntryMut { +export function fromKeyHashedNocheck$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rs.u64, k: Logged.Logged): RawEntryMut.RawEntryMut { return fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self, hash, (o: Logged.Logged): boolean => { return Logged.eq$cmp_PartialEq(k, o); }); } -export function fromKeyHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rt.u64, k: Logged.Logged): RawEntryMut.RawEntryMut { +export function fromKeyHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rs.u64, k: Logged.Logged): RawEntryMut.RawEntryMut { return fromHash$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self, hash, (o: Logged.Logged): boolean => { return Logged.eq$cmp_PartialEq(k, o); }); } -export function fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, k: string): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { - return fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self, hash, (o: rt.Arc): boolean => { +export function fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, k: string): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { + return fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self, hash, (o: rs.Arc): boolean => { return k === o.value; }); } -export function fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, k: rt.Arc): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { - return fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self, hash, (o: rt.Arc): boolean => { - return rt.eqArc(rt.same, true)(k, o); +export function fromKeyHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, k: rs.Arc): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { + return fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self, hash, (o: rs.Arc): boolean => { + return rs.eqArc(rs.same, true)(k, o); }); } -export function fromKeyHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rt.u64, k: rt.u16): RawEntryMut.RawEntryMut { - return fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self, hash, (o: rt.u16): boolean => { +export function fromKeyHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rs.u64, k: rs.u16): RawEntryMut.RawEntryMut { + return fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self, hash, (o: rs.u16): boolean => { return k === o; }); } -export function fromKeyHashedNocheck$u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, hash: rt.u64, k: rt.u16): RawEntryMut.RawEntryMut { - return fromHash$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hash_RandomState_u16(self, hash, (o: rt.u16): boolean => { +export function fromKeyHashedNocheck$u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, hash: rs.u64, k: rs.u16): RawEntryMut.RawEntryMut { + return fromHash$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hash_RandomState_u16(self, hash, (o: rs.u16): boolean => { return k === o; }); } -export function fromKeyHashedNocheck$u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rt.u64, k: rt.u16): RawEntryMut.RawEntryMut { - return fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder_u16(self, hash, (o: rt.u16): boolean => { +export function fromKeyHashedNocheck$u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rs.u64, k: rs.u16): RawEntryMut.RawEntryMut { + return fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder_u16(self, hash, (o: rs.u16): boolean => { return k === o; }); } -export function fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$maps_Logged_maps_Logged(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$maps_Logged_maps_Logged(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: Logged.Logged) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$maps_Logged_unit(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, isMatch: (a0: rt.Arc) => boolean): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, isMatch: (a0: rs.Arc) => boolean): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { let captured = isMatch; - const entry: rt.Result, rt.u32>>, rt.TableEntry, rt.u32>>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node, rt.u32>): boolean => { + const entry: rs.Result, rs.u32>>, rs.TableEntry, rs.u32>>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node, rs.u32>): boolean => { return captured(Node.keyRef$sync_Arc_str_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry, rt.u32>> = entry.value; + const occupied: rs.TableEntry, rs.u32>> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } - const absent: rt.TableEntry, rt.u32>> = entry.error; + const absent: rs.TableEntry, rs.u32>> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } -export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, isMatch: (a0: rt.Arc) => boolean): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, isMatch: (a0: rs.Arc) => boolean): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { let captured = isMatch; - const entry: rt.Result, rt.u32>>, rt.TableEntry, rt.u32>>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node, rt.u32>): boolean => { + const entry: rs.Result, rs.u32>>, rs.TableEntry, rs.u32>>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node, rs.u32>): boolean => { return captured(Node.keyRef$sync_Arc_str_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry, rt.u32>> = entry.value; + const occupied: rs.TableEntry, rs.u32>> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } - const absent: rt.TableEntry, rt.u32>> = entry.error; + const absent: rs.TableEntry, rs.u32>> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } -export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, isMatch: (a0: rt.Arc) => boolean): RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function fromHash$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder_sync_Arc_str(self: RawEntryBuilderMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, isMatch: (a0: rs.Arc) => boolean): RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { let captured = isMatch; - const entry: rt.Result, rt.u32>>, rt.TableEntry, rt.u32>>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node, rt.u32>): boolean => { + const entry: rs.Result, rs.u32>>, rs.TableEntry, rs.u32>>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node, rs.u32>): boolean => { return captured(Node.keyRef$sync_Arc_str_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry, rt.u32>> = entry.value; + const occupied: rs.TableEntry, rs.u32>> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } - const absent: rt.TableEntry, rt.u32>> = entry.error; + const absent: rs.TableEntry, rs.u32>> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>; } -export function fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_maps_Logged(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_maps_Logged(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hash_RandomState_u16(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_back_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_back_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_LinkedHashMap_K_V_S_pop_front_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } -export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rt.u64, isMatch: (a0: rt.u16) => boolean): RawEntryMut.RawEntryMut { +export function fromHash$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawEntryBuilderMut_K_V_S_from_key_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder_u16(self: RawEntryBuilderMut, hash: rs.u64, isMatch: (a0: rs.u16) => boolean): RawEntryMut.RawEntryMut { let captured = isMatch; - const entry: rt.Result>, rt.TableEntry>> = rt.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { + const entry: rs.Result>, rs.TableEntry>> = rs.tableFindEntry(self.map.table, hash, (k: Node.Node): boolean => { return captured(Node.keyRef$u16_u32(k)); }); if (entry.ok) { - const occupied: rt.TableEntry> = entry.value; + const occupied: rs.TableEntry> = entry.value; const borrowed3 = self.map; const borrowed4 = self.map; - return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rt.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rt.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; + return { tag: "Occupied", _0: { hashBuilder: self.map.hashBuilder, free: rs.place(() => borrowed3.free, (value3) => borrowed3.free = value3), values: rs.place(() => borrowed4.values, (value4) => borrowed4.values = value4), entry: occupied } } as RawEntryMut.RawEntryMut; } - const absent: rt.TableEntry> = entry.error; + const absent: rs.TableEntry> = entry.error; const borrowed = self.map; const borrowed2 = self.map; - return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rt.place(() => borrowed.values, (value) => borrowed.values = value), free: rt.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; + return { tag: "Vacant", _0: { hashBuilder: self.map.hashBuilder, values: rs.place(() => borrowed.values, (value) => borrowed.values = value), free: rs.place(() => borrowed2.free, (value2) => borrowed2.free = value2), entry: absent } } as RawEntryMut.RawEntryMut; } //# sourceMappingURL=linked_hash_map.RawEntryBuilderMut.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawOccupiedEntryMut.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawOccupiedEntryMut.ts index 932f331df..4a35ca14e 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawOccupiedEntryMut.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawOccupiedEntryMut.ts @@ -1,23 +1,23 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_unit_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_unit, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32, attachBefore$maps_Logged_maps_Logged, attachBefore$maps_Logged_unit, attachBefore$sync_Arc_str_u32, attachBefore$u16_maps_Logged, attachBefore$u16_u32, detachNode$maps_Logged_maps_Logged, detachNode$maps_Logged_unit, detachNode$sync_Arc_str_u32, detachNode$u16_maps_Logged, detachNode$u16_u32, removeNode$maps_Logged_maps_Logged, removeNode$maps_Logged_unit, removeNode$sync_Arc_str_u32, removeNode$u16_maps_Logged, removeNode$u16_u32 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; import type * as DefaultHashBuilder from "../hashlink.DefaultHashBuilder.ts"; import type * as Logged from "../maps.Logged.ts"; export interface RawOccupiedEntryMut { - hashBuilder: rt.Ptr; - free: rt.Place | undefined>; - values: rt.Place | undefined>; - entry: rt.TableEntry>; + hashBuilder: rs.Ptr; + free: rs.Place | undefined>; + values: rs.Place | undefined>; + entry: rs.TableEntry>; } -export function intoMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): rt.Place { +export function intoMut$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): rs.Place { return intoKeyValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self)[1]; } -export function intoMut$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): rt.Place { +export function intoMut$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): rs.Place { return intoKeyValue$u16_u32_hashlink_DefaultHashBuilder(self)[1]; } @@ -26,29 +26,29 @@ export function intoKeyValue$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder return [_7[0], _7[1]] as [Logged.Logged, Logged.Logged]; } -export function intoKeyValue$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [Logged.Logged, rt.Place] { +export function intoKeyValue$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [Logged.Logged, rs.Place] { const _7: [Logged.Logged, undefined] = Node.entryMut$maps_Logged_unit(self.entry.v); - return [_7[0], rt.place(() => _7[1], (value) => _7[1] = value)] as [Logged.Logged, rt.Place]; + return [_7[0], rs.place(() => _7[1], (value) => _7[1] = value)] as [Logged.Logged, rs.Place]; } -export function intoKeyValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): [rt.Place>, rt.Place] { - const _7: [rt.Arc, rt.u32] = Node.entryMut$sync_Arc_str_u32(self.entry.v); - return [rt.place(() => _7[0], (value) => _7[0] = value), rt.place(() => _7[1], (value2) => _7[1] = value2)] as [rt.Place>, rt.Place]; +export function intoKeyValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): [rs.Place>, rs.Place] { + const _7: [rs.Arc, rs.u32] = Node.entryMut$sync_Arc_str_u32(self.entry.v); + return [rs.place(() => _7[0], (value) => _7[0] = value), rs.place(() => _7[1], (value2) => _7[1] = value2)] as [rs.Place>, rs.Place]; } -export function intoKeyValue$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rt.Place, Logged.Logged] { - const _7: [rt.u16, Logged.Logged] = Node.entryMut$u16_maps_Logged(self.entry.v); - return [rt.place(() => _7[0], (value) => _7[0] = value), _7[1]] as [rt.Place, Logged.Logged]; +export function intoKeyValue$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rs.Place, Logged.Logged] { + const _7: [rs.u16, Logged.Logged] = Node.entryMut$u16_maps_Logged(self.entry.v); + return [rs.place(() => _7[0], (value) => _7[0] = value), _7[1]] as [rs.Place, Logged.Logged]; } -export function intoKeyValue$u16_u32_hash_RandomState(self: RawOccupiedEntryMut): [rt.Place, rt.Place] { - const _7: [rt.u16, rt.u32] = Node.entryMut$u16_u32(self.entry.v); - return [rt.place(() => _7[0], (value) => _7[0] = value), rt.place(() => _7[1], (value2) => _7[1] = value2)] as [rt.Place, rt.Place]; +export function intoKeyValue$u16_u32_hash_RandomState(self: RawOccupiedEntryMut): [rs.Place, rs.Place] { + const _7: [rs.u16, rs.u32] = Node.entryMut$u16_u32(self.entry.v); + return [rs.place(() => _7[0], (value) => _7[0] = value), rs.place(() => _7[1], (value2) => _7[1] = value2)] as [rs.Place, rs.Place]; } -export function intoKeyValue$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rt.Place, rt.Place] { - const _7: [rt.u16, rt.u32] = Node.entryMut$u16_u32(self.entry.v); - return [rt.place(() => _7[0], (value) => _7[0] = value), rt.place(() => _7[1], (value2) => _7[1] = value2)] as [rt.Place, rt.Place]; +export function intoKeyValue$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rs.Place, rs.Place] { + const _7: [rs.u16, rs.u32] = Node.entryMut$u16_u32(self.entry.v); + return [rs.place(() => _7[0], (value) => _7[0] = value), rs.place(() => _7[1], (value2) => _7[1] = value2)] as [rs.Place, rs.Place]; } export function toBack$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { @@ -63,34 +63,34 @@ export function toBack$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawOcc attachBefore$maps_Logged_unit(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_unit_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_unit(self.values.v)); } -export function toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): void { - const node: Node.Node, rt.u32> = self.entry.v; +export function toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): void { + const node: Node.Node, rs.u32> = self.entry.v; detachNode$sync_Arc_str_u32(node); attachBefore$sync_Arc_str_u32(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self.values.v)); } -export function toBack$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { - const node: Node.Node = self.entry.v; +export function toBack$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { + const node: Node.Node = self.entry.v; detachNode$u16_maps_Logged(node); attachBefore$u16_maps_Logged(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self.values.v)); } -export function toBack$u16_u32_hash_RandomState(self: RawOccupiedEntryMut): void { - const node: Node.Node = self.entry.v; +export function toBack$u16_u32_hash_RandomState(self: RawOccupiedEntryMut): void { + const node: Node.Node = self.entry.v; detachNode$u16_u32(node); attachBefore$u16_u32(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v)); } -export function toBack$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { - const node: Node.Node = self.entry.v; +export function toBack$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { + const node: Node.Node = self.entry.v; detachNode$u16_u32(node); attachBefore$u16_u32(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v)); } -export function toFront$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { - const node: Node.Node = self.entry.v; +export function toFront$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): void { + const node: Node.Node = self.entry.v; detachNode$u16_u32(node); - attachBefore$u16_u32(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v).links.at0 as Node.Node); + attachBefore$u16_u32(node, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v).links.at0 as Node.Node); } export function replaceValue$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, value: Logged.Logged): Logged.Logged { @@ -104,29 +104,29 @@ export function replaceValue$maps_Logged_unit_hashlink_DefaultHashBuilder(self: Node.entryMut$maps_Logged_unit(self.entry.v); } -export function replaceValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, value: rt.u32): rt.u32 { - const _7: [rt.Arc, rt.u32] = Node.entryMut$sync_Arc_str_u32(self.entry.v); +export function replaceValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, value: rs.u32): rs.u32 { + const _7: [rs.Arc, rs.u32] = Node.entryMut$sync_Arc_str_u32(self.entry.v); const old = _7[1]; _7[1] = value; return old; } -export function replaceValue$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, value: Logged.Logged): Logged.Logged { - const _7: [rt.u16, Logged.Logged] = Node.entryMut$u16_maps_Logged(self.entry.v); +export function replaceValue$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, value: Logged.Logged): Logged.Logged { + const _7: [rs.u16, Logged.Logged] = Node.entryMut$u16_maps_Logged(self.entry.v); const old = _7[1]; _7[1] = value; return old; } -export function replaceValue$u16_u32_hash_RandomState(self: RawOccupiedEntryMut, value: rt.u32): rt.u32 { - const _7: [rt.u16, rt.u32] = Node.entryMut$u16_u32(self.entry.v); +export function replaceValue$u16_u32_hash_RandomState(self: RawOccupiedEntryMut, value: rs.u32): rs.u32 { + const _7: [rs.u16, rs.u32] = Node.entryMut$u16_u32(self.entry.v); const old = _7[1]; _7[1] = value; return old; } -export function replaceValue$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, value: rt.u32): rt.u32 { - const _7: [rt.u16, rt.u32] = Node.entryMut$u16_u32(self.entry.v); +export function replaceValue$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, value: rs.u32): rs.u32 { + const _7: [rs.u16, rs.u32] = Node.entryMut$u16_u32(self.entry.v); const old = _7[1]; _7[1] = value; return old; @@ -143,39 +143,39 @@ export function remove$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawOcc removeEntry$maps_Logged_unit_hashlink_DefaultHashBuilder(self)[0][Symbol.dispose](); } -export function remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): rt.u32 { - const _2: [rt.Arc, rt.u32] = removeEntry$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self); - const _0: rt.u32 = _2[1]; +export function remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): rs.u32 { + const _2: [rs.Arc, rs.u32] = removeEntry$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self); + const _0: rs.u32 = _2[1]; _2[0][Symbol.dispose](); return _0; } -export function remove$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): rt.u32 { +export function remove$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): rs.u32 { return removeEntry$u16_u32_hashlink_DefaultHashBuilder(self)[1]; } export function removeEntry$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [Logged.Logged, Logged.Logged] { - const node: Node.Node = rt.tableRemove(self.entry)[0]; + const node: Node.Node = rs.tableRemove(self.entry)[0]; return removeNode$maps_Logged_maps_Logged(self.free, node); } export function removeEntry$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [Logged.Logged, undefined] { - const node: Node.Node = rt.tableRemove(self.entry)[0]; + const node: Node.Node = rs.tableRemove(self.entry)[0]; return removeNode$maps_Logged_unit(self.free, node); } -export function removeEntry$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): [rt.Arc, rt.u32] { - const node: Node.Node, rt.u32> = rt.tableRemove(self.entry)[0]; +export function removeEntry$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): [rs.Arc, rs.u32] { + const node: Node.Node, rs.u32> = rs.tableRemove(self.entry)[0]; return removeNode$sync_Arc_str_u32(self.free, node); } -export function removeEntry$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rt.u16, Logged.Logged] { - const node: Node.Node = rt.tableRemove(self.entry)[0]; +export function removeEntry$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rs.u16, Logged.Logged] { + const node: Node.Node = rs.tableRemove(self.entry)[0]; return removeNode$u16_maps_Logged(self.free, node); } -export function removeEntry$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rt.u16, rt.u32] { - const node: Node.Node = rt.tableRemove(self.entry)[0]; +export function removeEntry$u16_u32_hashlink_DefaultHashBuilder(self: RawOccupiedEntryMut): [rs.u16, rs.u32] { + const node: Node.Node = rs.tableRemove(self.entry)[0]; return removeNode$u16_u32(self.free, node); } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawVacantEntryMut.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawVacantEntryMut.ts index 14acf3565..f3ff2ccb9 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawVacantEntryMut.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.RawVacantEntryMut.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_unit_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_unit, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32, ensureGuardNode$maps_Logged_maps_Logged, ensureGuardNode$maps_Logged_unit, ensureGuardNode$sync_Arc_str_u32, ensureGuardNode$u16_maps_Logged, ensureGuardNode$u16_u32, attachBefore$maps_Logged_maps_Logged, attachBefore$maps_Logged_unit, attachBefore$sync_Arc_str_u32, attachBefore$u16_maps_Logged, attachBefore$u16_u32, allocateNode$maps_Logged_maps_Logged, allocateNode$maps_Logged_unit, allocateNode$sync_Arc_str_u32, allocateNode$u16_maps_Logged, allocateNode$u16_u32, hashKey$hash_RandomState_u16, hashKey$hashlink_DefaultHashBuilder_maps_Logged, hashKey$hashlink_DefaultHashBuilder_sync_Arc_str, hashKey$hashlink_DefaultHashBuilder_u16 } from "../hashlink/linked_hash_map.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; import * as RawOccupiedEntryMut from "../hashlink/linked_hash_map.RawOccupiedEntryMut.ts"; @@ -8,208 +8,208 @@ import type * as DefaultHashBuilder from "../hashlink.DefaultHashBuilder.ts"; import type * as Logged from "../maps.Logged.ts"; export interface RawVacantEntryMut { - hashBuilder: rt.Ptr; - values: rt.Place | undefined>; - free: rt.Place | undefined>; - entry: rt.TableEntry>; + hashBuilder: rs.Ptr; + values: rs.Place | undefined>; + free: rs.Place | undefined>; + entry: rs.TableEntry>; } export function insert$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: Logged.Logged, value: Logged.Logged): [Logged.Logged, Logged.Logged] { return insertHashedNocheck$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_maps_Logged(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, value); } -export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: Logged.Logged, _: undefined): [Logged.Logged, rt.Place] { +export function insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: Logged.Logged, _: undefined): [Logged.Logged, rs.Place] { return insertHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_maps_Logged(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, undefined); } -export function insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, key: rt.Arc, value: rt.u32): [rt.Place>, rt.Place] { +export function insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, key: rs.Arc, value: rs.u32): [rs.Place>, rs.Place] { return insertHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, value); } -export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rt.u16, value: Logged.Logged): [rt.Place, Logged.Logged] { +export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rs.u16, value: Logged.Logged): [rs.Place, Logged.Logged] { return insertHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_u16(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, value); } -export function insert$u16_u32_hash_RandomState(self: RawVacantEntryMut, key: rt.u16, value: rt.u32): [rt.Place, rt.Place] { - return insertHashedNocheck$u16_u32_hash_RandomState(self, hashKey$hash_RandomState_u16(self.hashBuilder as rt.RandomState, key), key, value); +export function insert$u16_u32_hash_RandomState(self: RawVacantEntryMut, key: rs.u16, value: rs.u32): [rs.Place, rs.Place] { + return insertHashedNocheck$u16_u32_hash_RandomState(self, hashKey$hash_RandomState_u16(self.hashBuilder as rs.RandomState, key), key, value); } -export function insert$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rt.u16, value: rt.u32): [rt.Place, rt.Place] { +export function insert$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rs.u16, value: rs.u32): [rs.Place, rs.Place] { return insertHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_u16(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, value); } -export function insertHashedNocheck$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, value: Logged.Logged): [Logged.Logged, Logged.Logged] { +export function insertHashedNocheck$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, value: Logged.Logged): [Logged.Logged, Logged.Logged] { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, (k: Logged.Logged): rt.u64 => { + return insertWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, (k: Logged.Logged): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_maps_Logged(hashBuilder, k); }); } -export function insertHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, _: undefined): [Logged.Logged, rt.Place] { +export function insertHashedNocheck$maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, _: undefined): [Logged.Logged, rs.Place] { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self, hash, key, undefined, (k: Logged.Logged): rt.u64 => { + return insertWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self, hash, key, undefined, (k: Logged.Logged): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_maps_Logged(hashBuilder, k); }); } -export function insertHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, key: rt.Arc, value: rt.u32): [rt.Place>, rt.Place] { +export function insertHashedNocheck$sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, key: rs.Arc, value: rs.u32): [rs.Place>, rs.Place] { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rt.Arc): rt.u64 => { + return insertWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rs.Arc): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(hashBuilder, k); }); } -export function insertHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: Logged.Logged): [rt.Place, Logged.Logged] { +export function insertHashedNocheck$u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: Logged.Logged): [rs.Place, Logged.Logged] { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rt.u16): rt.u64 => { + return insertWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rs.u16): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_u16(hashBuilder, k); }); } -export function insertHashedNocheck$u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32): [rt.Place, rt.Place] { - const hashBuilder: rt.RandomState = self.hashBuilder as rt.RandomState; - return insertWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self, hash, key, value, (k: rt.u16): rt.u64 => { +export function insertHashedNocheck$u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32): [rs.Place, rs.Place] { + const hashBuilder: rs.RandomState = self.hashBuilder as rs.RandomState; + return insertWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self, hash, key, value, (k: rs.u16): rs.u64 => { return hashKey$hash_RandomState_u16(hashBuilder, k); }); } -export function insertHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32): [rt.Place, rt.Place] { +export function insertHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32): [rs.Place, rs.Place] { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rt.u16): rt.u64 => { + return insertWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rs.u16): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_u16(hashBuilder, k); }); } -export function insertWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, value: Logged.Logged, hasher: (a0: Logged.Logged) => rt.u64): [Logged.Logged, Logged.Logged] { +export function insertWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, value: Logged.Logged, hasher: (a0: Logged.Logged) => rs.u64): [Logged.Logged, Logged.Logged] { return RawOccupiedEntryMut.intoKeyValue$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(insertEntryWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, hasher)); } -export function insertWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, _: undefined, hasher: (a0: Logged.Logged) => rt.u64): [Logged.Logged, rt.Place] { +export function insertWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, _: undefined, hasher: (a0: Logged.Logged) => rs.u64): [Logged.Logged, rs.Place] { return RawOccupiedEntryMut.intoKeyValue$maps_Logged_unit_hashlink_DefaultHashBuilder(insertEntryWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self, hash, key, undefined, hasher)); } -export function insertWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, key: rt.Arc, value: rt.u32, hasher: (a0: rt.Arc) => rt.u64): [rt.Place>, rt.Place] { +export function insertWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, key: rs.Arc, value: rs.u32, hasher: (a0: rs.Arc) => rs.u64): [rs.Place>, rs.Place] { return RawOccupiedEntryMut.intoKeyValue$sync_Arc_str_u32_hashlink_DefaultHashBuilder(insertEntryWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self, hash, key, value, hasher)); } -export function insertWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: Logged.Logged, hasher: (a0: rt.u16) => rt.u64): [rt.Place, Logged.Logged] { +export function insertWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: Logged.Logged, hasher: (a0: rs.u16) => rs.u64): [rs.Place, Logged.Logged] { return RawOccupiedEntryMut.intoKeyValue$u16_maps_Logged_hashlink_DefaultHashBuilder(insertEntryWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self, hash, key, value, hasher)); } -export function insertWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32, hasher: (a0: rt.u16) => rt.u64): [rt.Place, rt.Place] { +export function insertWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32, hasher: (a0: rs.u16) => rs.u64): [rs.Place, rs.Place] { return RawOccupiedEntryMut.intoKeyValue$u16_u32_hash_RandomState(insertEntryWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self, hash, key, value, hasher)); } -export function insertWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32, hasher: (a0: rt.u16) => rt.u64): [rt.Place, rt.Place] { +export function insertWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32, hasher: (a0: rs.u16) => rs.u64): [rs.Place, rs.Place] { return RawOccupiedEntryMut.intoKeyValue$u16_u32_hashlink_DefaultHashBuilder(insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self, hash, key, value, hasher)); } -export function insertEntryWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, value: Logged.Logged, hasher: (a0: Logged.Logged) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, value: Logged.Logged, hasher: (a0: Logged.Logged) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$maps_Logged_maps_Logged(self.values); const newNode: Node.Node = allocateNode$maps_Logged_maps_Logged(self.free); Node.putEntry$maps_Logged_maps_Logged(newNode, [key, value] as [Logged.Logged, Logged.Logged]); attachBefore$maps_Logged_maps_Logged(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged(self.values.v)); - const _18: rt.HashTable> = self.entry.t; + const _18: rs.HashTable> = self.entry.t; const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$maps_Logged_maps_Logged(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: Logged.Logged, _: undefined, hasher: (a0: Logged.Logged) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$maps_Logged_unit_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_maps_Logged_unit_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: Logged.Logged, _: undefined, hasher: (a0: Logged.Logged) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$maps_Logged_unit(self.values); const newNode: Node.Node = allocateNode$maps_Logged_unit(self.free); Node.putEntry$maps_Logged_unit(newNode, [key, undefined] as [Logged.Logged, undefined]); attachBefore$maps_Logged_unit(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_unit_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_unit(self.values.v)); - const _18: rt.HashTable> = self.entry.t; + const _18: rs.HashTable> = self.entry.t; const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$maps_Logged_unit(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rt.u64, key: rt.Arc, value: rt.u32, hasher: (a0: rt.Arc) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut, rt.u32, DefaultHashBuilder.DefaultHashBuilder> { +export function insertEntryWithHasher$sync_Arc_str_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_sync_Arc_str_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder>, hash: rs.u64, key: rs.Arc, value: rs.u32, hasher: (a0: rs.Arc) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut, rs.u32, DefaultHashBuilder.DefaultHashBuilder> { ensureGuardNode$sync_Arc_str_u32(self.values); - const newNode: Node.Node, rt.u32> = allocateNode$sync_Arc_str_u32(self.free); - Node.putEntry$sync_Arc_str_u32(newNode, [key, value] as [rt.Arc, rt.u32]); + const newNode: Node.Node, rs.u32> = allocateNode$sync_Arc_str_u32(self.free); + Node.putEntry$sync_Arc_str_u32(newNode, [key, value] as [rs.Arc, rs.u32]); attachBefore$sync_Arc_str_u32(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self.values.v)); - const _18: rt.HashTable, rt.u32>> = self.entry.t; - const _20: Node.Node, rt.u32> = newNode; + const _18: rs.HashTable, rs.u32>> = self.entry.t; + const _20: Node.Node, rs.u32> = newNode; const captured = hasher; - const node: rt.TableEntry, rt.u32>> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node, rt.u32>): rt.u64 => { + const node: rs.TableEntry, rs.u32>> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node, rs.u32>): rs.u64 => { return captured(Node.keyRef$sync_Arc_str_u32(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: Logged.Logged, hasher: (a0: rt.u16) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$u16_maps_Logged_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_maps_Logged_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: Logged.Logged, hasher: (a0: rs.u16) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$u16_maps_Logged(self.values); - const newNode: Node.Node = allocateNode$u16_maps_Logged(self.free); - Node.putEntry$u16_maps_Logged(newNode, [key, value] as [rt.u16, Logged.Logged]); + const newNode: Node.Node = allocateNode$u16_maps_Logged(self.free); + Node.putEntry$u16_maps_Logged(newNode, [key, value] as [rs.u16, Logged.Logged]); attachBefore$u16_maps_Logged(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self.values.v)); - const _18: rt.HashTable> = self.entry.t; - const _20: Node.Node = newNode; + const _18: rs.HashTable> = self.entry.t; + const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$u16_maps_Logged(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32, hasher: (a0: rt.u16) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$u16_u32_hash_RandomState_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hash_RandomState(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32, hasher: (a0: rs.u16) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$u16_u32(self.values); - const newNode: Node.Node = allocateNode$u16_u32(self.free); - Node.putEntry$u16_u32(newNode, [key, value] as [rt.u16, rt.u32]); + const newNode: Node.Node = allocateNode$u16_u32(self.free); + Node.putEntry$u16_u32(newNode, [key, value] as [rs.u16, rs.u32]); attachBefore$u16_u32(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v)); - const _18: rt.HashTable> = self.entry.t; - const _20: Node.Node = newNode; + const _18: rs.HashTable> = self.entry.t; + const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$u16_u32(k)); }); - return { hashBuilder: self.hashBuilder as rt.RandomState, free: self.free, values: self.values, entry: node }; + return { hashBuilder: self.hashBuilder as rs.RandomState, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_entry_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32, hasher: (a0: rt.u16) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_entry_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32, hasher: (a0: rs.u16) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$u16_u32(self.values); - const newNode: Node.Node = allocateNode$u16_u32(self.free); - Node.putEntry$u16_u32(newNode, [key, value] as [rt.u16, rt.u32]); + const newNode: Node.Node = allocateNode$u16_u32(self.free); + Node.putEntry$u16_u32(newNode, [key, value] as [rs.u16, rs.u32]); attachBefore$u16_u32(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v)); - const _18: rt.HashTable> = self.entry.t; - const _20: Node.Node = newNode; + const _18: rs.HashTable> = self.entry.t; + const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$u16_u32(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32, hasher: (a0: rt.u16) => rt.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32, hasher: (a0: rs.u16) => rs.u64): RawOccupiedEntryMut.RawOccupiedEntryMut { ensureGuardNode$u16_u32(self.values); - const newNode: Node.Node = allocateNode$u16_u32(self.free); - Node.putEntry$u16_u32(newNode, [key, value] as [rt.u16, rt.u32]); + const newNode: Node.Node = allocateNode$u16_u32(self.free); + Node.putEntry$u16_u32(newNode, [key, value] as [rs.u16, rs.u32]); attachBefore$u16_u32(newNode, asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self.values.v)); - const _18: rt.HashTable> = self.entry.t; - const _20: Node.Node = newNode; + const _18: rs.HashTable> = self.entry.t; + const _20: Node.Node = newNode; const captured = hasher; - const node: rt.TableEntry> = rt.tableInsertUnique(_18, hash, _20, (k: Node.Node): rt.u64 => { + const node: rs.TableEntry> = rs.tableInsertUnique(_18, hash, _20, (k: Node.Node): rs.u64 => { return captured(Node.keyRef$u16_u32(k)); }); return { hashBuilder: self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, free: self.free, values: self.values, entry: node }; } -export function insertEntryHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rt.u64, key: rt.u16, value: rt.u32): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntryHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, hash: rs.u64, key: rs.u16, value: rs.u32): RawOccupiedEntryMut.RawOccupiedEntryMut { const hashBuilder: DefaultHashBuilder.DefaultHashBuilder = self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder; - return insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_entry_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rt.u16): rt.u64 => { + return insertEntryWithHasher$u16_u32_hashlink_DefaultHashBuilder_hashlink_linked_hash_map_RawVacantEntryMut_K_V_S_insert_entry_hashed_nocheck_closure0_u16_u32_hashlink_DefaultHashBuilder(self, hash, key, value, (k: rs.u16): rs.u64 => { return hashKey$hashlink_DefaultHashBuilder_u16(hashBuilder, k); }); } -export function insertEntry$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rt.u16, value: rt.u32): RawOccupiedEntryMut.RawOccupiedEntryMut { +export function insertEntry$u16_u32_hashlink_DefaultHashBuilder(self: RawVacantEntryMut, key: rs.u16, value: rs.u32): RawOccupiedEntryMut.RawOccupiedEntryMut { return insertEntryHashedNocheck$u16_u32_hashlink_DefaultHashBuilder(self, hashKey$hashlink_DefaultHashBuilder_u16(self.hashBuilder as DefaultHashBuilder.DefaultHashBuilder, key), key, value); } diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Remainder$drop_value_nodes.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Remainder$drop_value_nodes.ts index cdd94843f..f8d9a959e 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Remainder$drop_value_nodes.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Remainder$drop_value_nodes.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$tuple2_maps_Logged_maps_Logged as lib_drop$tuple2_maps_Logged_maps_Logged, drop$tuple2_maps_Logged_unit as lib_drop$tuple2_maps_Logged_unit, drop$tuple2_sync_Arc_str_u32 as lib_drop$tuple2_sync_Arc_str_u32, drop$tuple2_u16_maps_Logged as lib_drop$tuple2_u16_maps_Logged } from "../lib.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; import type * as Logged from "../maps.Logged.ts"; @@ -33,27 +33,27 @@ export function drop$drop_value_nodes_ops_Drop_maps_Logged_unit(self: Remainder< } } -export function drop$drop_value_nodes_ops_Drop_sync_Arc_str_u32(self: Remainder, rt.u32>): void { +export function drop$drop_value_nodes_ops_Drop_sync_Arc_str_u32(self: Remainder, rs.u32>): void { while (self.cur !== self.guard) { - const prev: Node.Node, rt.u32> = self.cur.links.at4; + const prev: Node.Node, rs.u32> = self.cur.links.at4; lib_drop$tuple2_sync_Arc_str_u32(Node.takeEntry$sync_Arc_str_u32(self.cur)); self.cur; self.cur = prev; } } -export function drop$drop_value_nodes_ops_Drop_u16_maps_Logged(self: Remainder): void { +export function drop$drop_value_nodes_ops_Drop_u16_maps_Logged(self: Remainder): void { while (self.cur !== self.guard) { - const prev: Node.Node = self.cur.links.at4; + const prev: Node.Node = self.cur.links.at4; lib_drop$tuple2_u16_maps_Logged(Node.takeEntry$u16_maps_Logged(self.cur)); self.cur; self.cur = prev; } } -export function drop$drop_value_nodes_ops_Drop_u16_u32(self: Remainder): void { +export function drop$drop_value_nodes_ops_Drop_u16_u32(self: Remainder): void { while (self.cur !== self.guard) { - const prev: Node.Node = self.cur.links.at4; + const prev: Node.Node = self.cur.links.at4; Node.takeEntry$u16_u32(self.cur); self.cur; self.cur = prev; diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Values.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Values.ts index a8b52fc55..8c324772a 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.Values.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.Values.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { map$1st5iv4 as option_map$1st5iv4 } from "../core/option.ts"; +import * as rs from "../rs.ts"; +import { map$1nxhy7e as option_map$1nxhy7e } from "../core/option.ts"; import * as linked_hash_map_Iter from "../hashlink/linked_hash_map.Iter.ts"; export interface Values { inner: linked_hash_map_Iter.Iter; } -export function next$iter_Iterator_u16_u32(self: Values): rt.u32 | rt.Done { - return rt.iterFromOption(option_map$1st5iv4(rt.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(self.inner)), (e: [rt.u16, rt.u32]): rt.u32 => { +export function next$iter_Iterator_u16_u32(self: Values): rs.u32 | rs.Done { + return rs.iterFromOption(option_map$1nxhy7e(rs.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(self.inner)), (e: [rs.u16, rs.u32]): rs.u32 => { return e[1]; })); } -export function sizeHint$iter_Iterator_u16_u32(self: Values): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator_u16_u32(self: Values): [rs.usize, rs.usize | undefined] { return linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32(self.inner); } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Values): rt.u32 | undefined { - return option_map$1st5iv4(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rt.u16, rt.u32]): rt.u32 => { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: Values): rs.u32 | undefined { + return option_map$1nxhy7e(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rs.u16, rs.u32]): rs.u32 => { return e[1]; }); } -export function len$iter_ExactSizeIterator_u16_u32(self: Values): rt.usize { - return rt.iterFrom(self.inner, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); +export function len$iter_ExactSizeIterator_u16_u32(self: Values): rs.usize { + return rs.iterFrom(self.inner, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); } //# sourceMappingURL=linked_hash_map.Values.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.ValuesMut.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.ValuesMut.ts index c46de6f79..be0fd7064 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.ValuesMut.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.ValuesMut.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { map$0h57z6f as option_map$0h57z6f } from "../core/option.ts"; +import * as rs from "../rs.ts"; +import { map$0faa8rw as option_map$0faa8rw } from "../core/option.ts"; import * as IterMut from "../hashlink/linked_hash_map.IterMut.ts"; export interface ValuesMut { inner: IterMut.IterMut; } -export function next$iter_Iterator_u16_u32(self: ValuesMut): rt.Place | rt.Done { - return rt.iterFromOption(option_map$0h57z6f(rt.iterToOption(IterMut.next$iter_Iterator_u16_u32(self.inner)), (e: [rt.u16, rt.Place]): rt.Place => { +export function next$iter_Iterator_u16_u32(self: ValuesMut): rs.Place | rs.Done { + return rs.iterFromOption(option_map$0faa8rw(rs.iterToOption(IterMut.next$iter_Iterator_u16_u32(self.inner)), (e: [rs.u16, rs.Place]): rs.Place => { return e[1]; })); } -export function sizeHint$iter_Iterator_u16_u32(self: ValuesMut): [rt.usize, rt.usize | undefined] { +export function sizeHint$iter_Iterator_u16_u32(self: ValuesMut): [rs.usize, rs.usize | undefined] { return IterMut.sizeHint$iter_Iterator_u16_u32(self.inner); } -export function nextBack$iter_DoubleEndedIterator_u16_u32(self: ValuesMut): rt.Place | undefined { - return option_map$0h57z6f(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rt.u16, rt.Place]): rt.Place => { +export function nextBack$iter_DoubleEndedIterator_u16_u32(self: ValuesMut): rs.Place | undefined { + return option_map$0faa8rw(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(self.inner), (e: [rs.u16, rs.Place]): rs.Place => { return e[1]; }); } -export function len$iter_ExactSizeIterator_u16_u32(self: ValuesMut): rt.usize { - return rt.iterFrom(self.inner, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rt.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); +export function len$iter_ExactSizeIterator_u16_u32(self: ValuesMut): rs.usize { + return rs.iterFrom(self.inner, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rs.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len(); } //# sourceMappingURL=linked_hash_map.ValuesMut.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_map.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_map.ts index 4f6d26326..c6d0d6058 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_map.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_map.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$mem_MaybeUninit_tuple2_u16_u32, drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_maps_Logged_maps_Logged as lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_maps_Logged_maps_Logged, drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_maps_Logged_unit as lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_maps_Logged_unit, drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_sync_Arc_str_u32 as lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_sync_Arc_str_u32, drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_maps_Logged as lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_maps_Logged, drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_u32 as lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_u32, drop$tuple2_maps_Logged_maps_Logged as lib_drop$tuple2_maps_Logged_maps_Logged, drop$tuple2_maps_Logged_unit as lib_drop$tuple2_maps_Logged_unit, drop$tuple2_sync_Arc_str_u32 as lib_drop$tuple2_sync_Arc_str_u32, drop$tuple2_u16_maps_Logged as lib_drop$tuple2_u16_maps_Logged } from "../lib.ts"; import type * as Links from "../hashlink/linked_hash_map.Links.ts"; import * as Node from "../hashlink/linked_hash_map.Node.ts"; @@ -12,43 +12,43 @@ import * as Logged from "../maps.Logged.ts"; export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_maps_Logged(self: Node.Node | undefined): Node.Node { if (self === undefined) { - return rt.NULL; + return rs.NULL; } return self; } export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_maps_Logged_unit_Option_ptr_NonNull_hashlink_linked_hash_map_Node_maps_Logged_unit(self: Node.Node | undefined): Node.Node { if (self === undefined) { - return rt.NULL; + return rs.NULL; } return self; } -export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self: Node.Node, rt.u32> | undefined): Node.Node, rt.u32> { +export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_sync_Arc_str_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_sync_Arc_str_u32(self: Node.Node, rs.u32> | undefined): Node.Node, rs.u32> { if (self === undefined) { - return rt.NULL; + return rs.NULL; } return self; } -export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self: Node.Node | undefined): Node.Node { +export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_maps_Logged_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_maps_Logged(self: Node.Node | undefined): Node.Node { if (self === undefined) { - return rt.NULL; + return rs.NULL; } return self; } -export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self: Node.Node | undefined): Node.Node { +export function asPtr$hashlink_linked_hash_map_OptNonNullExt_hashlink_linked_hash_map_Node_u16_u32_Option_ptr_NonNull_hashlink_linked_hash_map_Node_u16_u32(self: Node.Node | undefined): Node.Node { if (self === undefined) { - return rt.NULL; + return rs.NULL; } return self; } -export function ensureGuardNode$maps_Logged_maps_Logged(head: rt.Place | undefined>): void { +export function ensureGuardNode$maps_Logged_maps_Logged(head: rs.Place | undefined>): void { if (head.v === undefined) { - const _8: [Logged.Logged, Logged.Logged] = ([new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell), new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell)] as unknown) as [Logged.Logged, Logged.Logged]; - const _10: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _8: [Logged.Logged, Logged.Logged] = ([new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell), new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell)] as unknown) as [Logged.Logged, Logged.Logged]; + const _10: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; const _13: ValueLinks.ValueLinks = { next: p, prev: p }; const _16: Node.Node = p; @@ -58,10 +58,10 @@ export function ensureGuardNode$maps_Logged_maps_Logged(head: rt.Place | undefined>): void { +export function ensureGuardNode$maps_Logged_unit(head: rs.Place | undefined>): void { if (head.v === undefined) { - const _8: [Logged.Logged, undefined] = ([new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell), undefined] as unknown) as [Logged.Logged, undefined]; - const _10: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _8: [Logged.Logged, undefined] = ([new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell), undefined] as unknown) as [Logged.Logged, undefined]; + const _10: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; const _13: ValueLinks.ValueLinks = { next: p, prev: p }; const _16: Node.Node = p; @@ -71,39 +71,39 @@ export function ensureGuardNode$maps_Logged_unit(head: rt.Place, rt.u32> | undefined>): void { +export function ensureGuardNode$sync_Arc_str_u32(head: rs.Place, rs.u32> | undefined>): void { if (head.v === undefined) { - const _8: [rt.Arc, rt.u32] = ([undefined, undefined] as unknown) as [rt.Arc, rt.u32]; - const _10: ValueLinks.ValueLinks, rt.u32> = { next: rt.DANGLING, prev: rt.DANGLING }; - const p: Node.Node, rt.u32> = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links, rt.u32> }; - const _13: ValueLinks.ValueLinks, rt.u32> = { next: p, prev: p }; - const _16: Node.Node, rt.u32> = p; + const _8: [rs.Arc, rs.u32] = ([undefined, undefined] as unknown) as [rs.Arc, rs.u32]; + const _10: ValueLinks.ValueLinks, rs.u32> = { next: rs.DANGLING, prev: rs.DANGLING }; + const p: Node.Node, rs.u32> = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links, rs.u32> }; + const _13: ValueLinks.ValueLinks, rs.u32> = { next: p, prev: p }; + const _16: Node.Node, rs.u32> = p; _16.links.at0 = _13.next; _16.links.at4 = _13.prev; head.v = p; } } -export function ensureGuardNode$u16_maps_Logged(head: rt.Place | undefined>): void { +export function ensureGuardNode$u16_maps_Logged(head: rs.Place | undefined>): void { if (head.v === undefined) { - const _8: [rt.u16, Logged.Logged] = ([undefined, new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell)] as unknown) as [rt.u16, Logged.Logged]; - const _10: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; - const _13: ValueLinks.ValueLinks = { next: p, prev: p }; - const _16: Node.Node = p; + const _8: [rs.u16, Logged.Logged] = ([undefined, new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell)] as unknown) as [rs.u16, Logged.Logged]; + const _10: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; + const _13: ValueLinks.ValueLinks = { next: p, prev: p }; + const _16: Node.Node = p; _16.links.at0 = _13.next; _16.links.at4 = _13.prev; head.v = p; } } -export function ensureGuardNode$u16_u32(head: rt.Place | undefined>): void { +export function ensureGuardNode$u16_u32(head: rs.Place | undefined>): void { if (head.v === undefined) { - const _8: [rt.u16, rt.u32] = copy$mem_MaybeUninit_tuple2_u16_u32(([undefined, undefined] as unknown) as [rt.u16, rt.u32]); - const _10: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; - const _13: ValueLinks.ValueLinks = { next: p, prev: p }; - const _16: Node.Node = p; + const _8: [rs.u16, rs.u32] = copy$mem_MaybeUninit_tuple2_u16_u32(([undefined, undefined] as unknown) as [rs.u16, rs.u32]); + const _10: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + const p: Node.Node = { entry: _8, links: ({ at0: _10.next, at4: _10.prev } as unknown) as Links.Links }; + const _13: ValueLinks.ValueLinks = { next: p, prev: p }; + const _16: Node.Node = p; _16.links.at0 = _13.next; _16.links.at4 = _13.prev; head.v = p; @@ -128,31 +128,31 @@ export function attachBefore$maps_Logged_unit(toAttach: Node.Node) = toAttach; } -export function attachBefore$sync_Arc_str_u32(toAttach: Node.Node, rt.u32>, node: Node.Node, rt.u32>): void { - const _3: ValueLinks.ValueLinks, rt.u32> = { next: node, prev: node.links.at4 }; - const _8: Node.Node, rt.u32> = toAttach; +export function attachBefore$sync_Arc_str_u32(toAttach: Node.Node, rs.u32>, node: Node.Node, rs.u32>): void { + const _3: ValueLinks.ValueLinks, rs.u32> = { next: node, prev: node.links.at4 }; + const _8: Node.Node, rs.u32> = toAttach; _8.links.at0 = _3.next; _8.links.at4 = _3.prev; node.links.at4 = toAttach; - (toAttach.links.at4.links.at0 as Node.Node, rt.u32>) = toAttach; + (toAttach.links.at4.links.at0 as Node.Node, rs.u32>) = toAttach; } -export function attachBefore$u16_maps_Logged(toAttach: Node.Node, node: Node.Node): void { - const _3: ValueLinks.ValueLinks = { next: node, prev: node.links.at4 }; - const _8: Node.Node = toAttach; +export function attachBefore$u16_maps_Logged(toAttach: Node.Node, node: Node.Node): void { + const _3: ValueLinks.ValueLinks = { next: node, prev: node.links.at4 }; + const _8: Node.Node = toAttach; _8.links.at0 = _3.next; _8.links.at4 = _3.prev; node.links.at4 = toAttach; - (toAttach.links.at4.links.at0 as Node.Node) = toAttach; + (toAttach.links.at4.links.at0 as Node.Node) = toAttach; } -export function attachBefore$u16_u32(toAttach: Node.Node, node: Node.Node): void { - const _3: ValueLinks.ValueLinks = { next: node, prev: node.links.at4 }; - const _8: Node.Node = toAttach; +export function attachBefore$u16_u32(toAttach: Node.Node, node: Node.Node): void { + const _3: ValueLinks.ValueLinks = { next: node, prev: node.links.at4 }; + const _8: Node.Node = toAttach; _8.links.at0 = _3.next; _8.links.at4 = _3.prev; node.links.at4 = toAttach; - (toAttach.links.at4.links.at0 as Node.Node) = toAttach; + (toAttach.links.at4.links.at0 as Node.Node) = toAttach; } export function detachNode$maps_Logged_maps_Logged(node: Node.Node): void { @@ -165,47 +165,47 @@ export function detachNode$maps_Logged_unit(node: Node.Node).links.at4 = node.links.at4; } -export function detachNode$sync_Arc_str_u32(node: Node.Node, rt.u32>): void { - (node.links.at4.links.at0 as Node.Node, rt.u32>) = node.links.at0 as Node.Node, rt.u32>; - (node.links.at0 as Node.Node, rt.u32>).links.at4 = node.links.at4; +export function detachNode$sync_Arc_str_u32(node: Node.Node, rs.u32>): void { + (node.links.at4.links.at0 as Node.Node, rs.u32>) = node.links.at0 as Node.Node, rs.u32>; + (node.links.at0 as Node.Node, rs.u32>).links.at4 = node.links.at4; } -export function detachNode$u16_maps_Logged(node: Node.Node): void { - (node.links.at4.links.at0 as Node.Node) = node.links.at0 as Node.Node; - (node.links.at0 as Node.Node).links.at4 = node.links.at4; +export function detachNode$u16_maps_Logged(node: Node.Node): void { + (node.links.at4.links.at0 as Node.Node) = node.links.at0 as Node.Node; + (node.links.at0 as Node.Node).links.at4 = node.links.at4; } -export function detachNode$u16_u32(node: Node.Node): void { - (node.links.at4.links.at0 as Node.Node) = node.links.at0 as Node.Node; - (node.links.at0 as Node.Node).links.at4 = node.links.at4; +export function detachNode$u16_u32(node: Node.Node): void { + (node.links.at4.links.at0 as Node.Node) = node.links.at0 as Node.Node; + (node.links.at0 as Node.Node).links.at4 = node.links.at4; } -export function pushFree$maps_Logged_maps_Logged(freeList: rt.Place | undefined>, node: Node.Node): void { +export function pushFree$maps_Logged_maps_Logged(freeList: rs.Place | undefined>, node: Node.Node): void { node.links.at0 = freeList.v; freeList.v = node; } -export function pushFree$maps_Logged_unit(freeList: rt.Place | undefined>, node: Node.Node): void { +export function pushFree$maps_Logged_unit(freeList: rs.Place | undefined>, node: Node.Node): void { node.links.at0 = freeList.v; freeList.v = node; } -export function pushFree$sync_Arc_str_u32(freeList: rt.Place, rt.u32> | undefined>, node: Node.Node, rt.u32>): void { +export function pushFree$sync_Arc_str_u32(freeList: rs.Place, rs.u32> | undefined>, node: Node.Node, rs.u32>): void { node.links.at0 = freeList.v; freeList.v = node; } -export function pushFree$u16_maps_Logged(freeList: rt.Place | undefined>, node: Node.Node): void { +export function pushFree$u16_maps_Logged(freeList: rs.Place | undefined>, node: Node.Node): void { node.links.at0 = freeList.v; freeList.v = node; } -export function pushFree$u16_u32(freeList: rt.Place | undefined>, node: Node.Node): void { +export function pushFree$u16_u32(freeList: rs.Place | undefined>, node: Node.Node): void { node.links.at0 = freeList.v; freeList.v = node; } -export function popFree$maps_Logged_maps_Logged(freeList: rt.Place | undefined>): Node.Node | undefined { +export function popFree$maps_Logged_maps_Logged(freeList: rs.Place | undefined>): Node.Node | undefined { if (freeList.v !== undefined) { const free: Node.Node = freeList.v; freeList.v = free.links.at0; @@ -214,7 +214,7 @@ export function popFree$maps_Logged_maps_Logged(freeList: rt.Place | undefined>): Node.Node | undefined { +export function popFree$maps_Logged_unit(freeList: rs.Place | undefined>): Node.Node | undefined { if (freeList.v !== undefined) { const free: Node.Node = freeList.v; freeList.v = free.links.at0; @@ -223,106 +223,106 @@ export function popFree$maps_Logged_unit(freeList: rt.Place, rt.u32> | undefined>): Node.Node, rt.u32> | undefined { +export function popFree$sync_Arc_str_u32(freeList: rs.Place, rs.u32> | undefined>): Node.Node, rs.u32> | undefined { if (freeList.v !== undefined) { - const free: Node.Node, rt.u32> = freeList.v; + const free: Node.Node, rs.u32> = freeList.v; freeList.v = free.links.at0; return free; } return undefined; } -export function popFree$u16_maps_Logged(freeList: rt.Place | undefined>): Node.Node | undefined { +export function popFree$u16_maps_Logged(freeList: rs.Place | undefined>): Node.Node | undefined { if (freeList.v !== undefined) { - const free: Node.Node = freeList.v; + const free: Node.Node = freeList.v; freeList.v = free.links.at0; return free; } return undefined; } -export function popFree$u16_u32(freeList: rt.Place | undefined>): Node.Node | undefined { +export function popFree$u16_u32(freeList: rs.Place | undefined>): Node.Node | undefined { if (freeList.v !== undefined) { - const free: Node.Node = freeList.v; + const free: Node.Node = freeList.v; freeList.v = free.links.at0; return free; } return undefined; } -export function allocateNode$maps_Logged_maps_Logged(freeList: rt.Place | undefined>): Node.Node { +export function allocateNode$maps_Logged_maps_Logged(freeList: rs.Place | undefined>): Node.Node { const _2: Node.Node | undefined = popFree$maps_Logged_maps_Logged(freeList); if (_2 !== undefined) { const free: Node.Node = _2; - const _5: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _5: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; const _8: Node.Node = free; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; return free; } - const _13: [Logged.Logged, Logged.Logged] = ([new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell), new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell)] as unknown) as [Logged.Logged, Logged.Logged]; - const _15: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _13: [Logged.Logged, Logged.Logged] = ([new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell), new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell)] as unknown) as [Logged.Logged, Logged.Logged]; + const _15: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; } -export function allocateNode$maps_Logged_unit(freeList: rt.Place | undefined>): Node.Node { +export function allocateNode$maps_Logged_unit(freeList: rs.Place | undefined>): Node.Node { const _2: Node.Node | undefined = popFree$maps_Logged_unit(freeList); if (_2 !== undefined) { const free: Node.Node = _2; - const _5: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _5: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; const _8: Node.Node = free; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; return free; } - const _13: [Logged.Logged, undefined] = ([new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell), undefined] as unknown) as [Logged.Logged, undefined]; - const _15: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; + const _13: [Logged.Logged, undefined] = ([new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell), undefined] as unknown) as [Logged.Logged, undefined]; + const _15: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; } -export function allocateNode$sync_Arc_str_u32(freeList: rt.Place, rt.u32> | undefined>): Node.Node, rt.u32> { - const _2: Node.Node, rt.u32> | undefined = popFree$sync_Arc_str_u32(freeList); +export function allocateNode$sync_Arc_str_u32(freeList: rs.Place, rs.u32> | undefined>): Node.Node, rs.u32> { + const _2: Node.Node, rs.u32> | undefined = popFree$sync_Arc_str_u32(freeList); if (_2 !== undefined) { - const free: Node.Node, rt.u32> = _2; - const _5: ValueLinks.ValueLinks, rt.u32> = { next: rt.DANGLING, prev: rt.DANGLING }; - const _8: Node.Node, rt.u32> = free; + const free: Node.Node, rs.u32> = _2; + const _5: ValueLinks.ValueLinks, rs.u32> = { next: rs.DANGLING, prev: rs.DANGLING }; + const _8: Node.Node, rs.u32> = free; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; return free; } - const _13: [rt.Arc, rt.u32] = ([undefined, undefined] as unknown) as [rt.Arc, rt.u32]; - const _15: ValueLinks.ValueLinks, rt.u32> = { next: rt.DANGLING, prev: rt.DANGLING }; - return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links, rt.u32> }; + const _13: [rs.Arc, rs.u32] = ([undefined, undefined] as unknown) as [rs.Arc, rs.u32]; + const _15: ValueLinks.ValueLinks, rs.u32> = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links, rs.u32> }; } -export function allocateNode$u16_maps_Logged(freeList: rt.Place | undefined>): Node.Node { - const _2: Node.Node | undefined = popFree$u16_maps_Logged(freeList); +export function allocateNode$u16_maps_Logged(freeList: rs.Place | undefined>): Node.Node { + const _2: Node.Node | undefined = popFree$u16_maps_Logged(freeList); if (_2 !== undefined) { - const free: Node.Node = _2; - const _5: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - const _8: Node.Node = free; + const free: Node.Node = _2; + const _5: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + const _8: Node.Node = free; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; return free; } - const _13: [rt.u16, Logged.Logged] = ([undefined, new Logged.Logged((undefined as unknown) as rt.u8, (undefined as unknown) as rt.RefCell)] as unknown) as [rt.u16, Logged.Logged]; - const _15: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; + const _13: [rs.u16, Logged.Logged] = ([undefined, new Logged.Logged((undefined as unknown) as rs.u8, (undefined as unknown) as rs.RefCell)] as unknown) as [rs.u16, Logged.Logged]; + const _15: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; } -export function allocateNode$u16_u32(freeList: rt.Place | undefined>): Node.Node { - const _2: Node.Node | undefined = popFree$u16_u32(freeList); +export function allocateNode$u16_u32(freeList: rs.Place | undefined>): Node.Node { + const _2: Node.Node | undefined = popFree$u16_u32(freeList); if (_2 !== undefined) { - const free: Node.Node = _2; - const _5: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - const _8: Node.Node = free; + const free: Node.Node = _2; + const _5: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + const _8: Node.Node = free; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; return free; } - const _13: [rt.u16, rt.u32] = copy$mem_MaybeUninit_tuple2_u16_u32(([undefined, undefined] as unknown) as [rt.u16, rt.u32]); - const _15: ValueLinks.ValueLinks = { next: rt.DANGLING, prev: rt.DANGLING }; - return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; + const _13: [rs.u16, rs.u32] = copy$mem_MaybeUninit_tuple2_u16_u32(([undefined, undefined] as unknown) as [rs.u16, rs.u32]); + const _15: ValueLinks.ValueLinks = { next: rs.DANGLING, prev: rs.DANGLING }; + return { entry: _13, links: ({ at0: _15.next, at4: _15.prev } as unknown) as Links.Links }; } export function dropValueNodes$maps_Logged_maps_Logged(guard: Node.Node): void { @@ -359,16 +359,16 @@ export function dropValueNodes$maps_Logged_unit(guard: Node.Node, rt.u32>): void { - const cur: Node.Node, rt.u32> = guard.links.at4; - const _5: ValueLinks.ValueLinks, rt.u32> = { next: guard, prev: guard }; - const _8: Node.Node, rt.u32> = guard; +export function dropValueNodes$sync_Arc_str_u32(guard: Node.Node, rs.u32>): void { + const cur: Node.Node, rs.u32> = guard.links.at4; + const _5: ValueLinks.ValueLinks, rs.u32> = { next: guard, prev: guard }; + const _8: Node.Node, rs.u32> = guard; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; - const rem: Remainder$drop_value_nodes.Remainder, rt.u32> = new Remainder$drop_value_nodes.Remainder(cur, guard); + const rem: Remainder$drop_value_nodes.Remainder, rs.u32> = new Remainder$drop_value_nodes.Remainder(cur, guard); while (rem.cur !== guard) { - const prev: Node.Node, rt.u32> = rem.cur.links.at4; - const entry: [rt.Arc, rt.u32] = Node.takeEntry$sync_Arc_str_u32(rem.cur); + const prev: Node.Node, rs.u32> = rem.cur.links.at4; + const entry: [rs.Arc, rs.u32] = Node.takeEntry$sync_Arc_str_u32(rem.cur); rem.cur; rem.cur = prev; lib_drop$tuple2_sync_Arc_str_u32(entry); @@ -376,16 +376,16 @@ export function dropValueNodes$sync_Arc_str_u32(guard: Node.Node, lib_drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_sync_Arc_str_u32(rem); } -export function dropValueNodes$u16_maps_Logged(guard: Node.Node): void { - const cur: Node.Node = guard.links.at4; - const _5: ValueLinks.ValueLinks = { next: guard, prev: guard }; - const _8: Node.Node = guard; +export function dropValueNodes$u16_maps_Logged(guard: Node.Node): void { + const cur: Node.Node = guard.links.at4; + const _5: ValueLinks.ValueLinks = { next: guard, prev: guard }; + const _8: Node.Node = guard; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; - const rem: Remainder$drop_value_nodes.Remainder = new Remainder$drop_value_nodes.Remainder(cur, guard); + const rem: Remainder$drop_value_nodes.Remainder = new Remainder$drop_value_nodes.Remainder(cur, guard); while (rem.cur !== guard) { - const prev: Node.Node = rem.cur.links.at4; - const entry: [rt.u16, Logged.Logged] = Node.takeEntry$u16_maps_Logged(rem.cur); + const prev: Node.Node = rem.cur.links.at4; + const entry: [rs.u16, Logged.Logged] = Node.takeEntry$u16_maps_Logged(rem.cur); rem.cur; rem.cur = prev; lib_drop$tuple2_u16_maps_Logged(entry); @@ -393,15 +393,15 @@ export function dropValueNodes$u16_maps_Logged(guard: Node.Node): void { - const cur: Node.Node = guard.links.at4; - const _5: ValueLinks.ValueLinks = { next: guard, prev: guard }; - const _8: Node.Node = guard; +export function dropValueNodes$u16_u32(guard: Node.Node): void { + const cur: Node.Node = guard.links.at4; + const _5: ValueLinks.ValueLinks = { next: guard, prev: guard }; + const _8: Node.Node = guard; _8.links.at0 = _5.next; _8.links.at4 = _5.prev; - const rem: Remainder$drop_value_nodes.Remainder = new Remainder$drop_value_nodes.Remainder(cur, guard); + const rem: Remainder$drop_value_nodes.Remainder = new Remainder$drop_value_nodes.Remainder(cur, guard); while (rem.cur !== guard) { - const prev: Node.Node = rem.cur.links.at4; + const prev: Node.Node = rem.cur.links.at4; Node.takeEntry$u16_u32(rem.cur); rem.cur = prev; } @@ -426,97 +426,97 @@ export function dropFreeNodes$maps_Logged_unit(free: Node.Node, rt.u32> | undefined): void { +export function dropFreeNodes$sync_Arc_str_u32(free: Node.Node, rs.u32> | undefined): void { while (free !== undefined) { - const someFree: Node.Node, rt.u32> = free; - const nextFree: Node.Node, rt.u32> | undefined = someFree.links.at0; + const someFree: Node.Node, rs.u32> = free; + const nextFree: Node.Node, rs.u32> | undefined = someFree.links.at0; someFree; free = nextFree; } } -export function dropFreeNodes$u16_maps_Logged(free: Node.Node | undefined): void { +export function dropFreeNodes$u16_maps_Logged(free: Node.Node | undefined): void { while (free !== undefined) { - const someFree: Node.Node = free; - const nextFree: Node.Node | undefined = someFree.links.at0; + const someFree: Node.Node = free; + const nextFree: Node.Node | undefined = someFree.links.at0; someFree; free = nextFree; } } -export function dropFreeNodes$u16_u32(free: Node.Node | undefined): void { +export function dropFreeNodes$u16_u32(free: Node.Node | undefined): void { while (free !== undefined) { - const someFree: Node.Node = free; - const nextFree: Node.Node | undefined = someFree.links.at0; + const someFree: Node.Node = free; + const nextFree: Node.Node | undefined = someFree.links.at0; someFree; free = nextFree; } } -export function removeNode$maps_Logged_maps_Logged(freeList: rt.Place | undefined>, node: Node.Node): [Logged.Logged, Logged.Logged] { +export function removeNode$maps_Logged_maps_Logged(freeList: rs.Place | undefined>, node: Node.Node): [Logged.Logged, Logged.Logged] { detachNode$maps_Logged_maps_Logged(node); pushFree$maps_Logged_maps_Logged(freeList, node); return Node.takeEntry$maps_Logged_maps_Logged(node); } -export function removeNode$maps_Logged_unit(freeList: rt.Place | undefined>, node: Node.Node): [Logged.Logged, undefined] { +export function removeNode$maps_Logged_unit(freeList: rs.Place | undefined>, node: Node.Node): [Logged.Logged, undefined] { detachNode$maps_Logged_unit(node); pushFree$maps_Logged_unit(freeList, node); return Node.takeEntry$maps_Logged_unit(node); } -export function removeNode$sync_Arc_str_u32(freeList: rt.Place, rt.u32> | undefined>, node: Node.Node, rt.u32>): [rt.Arc, rt.u32] { +export function removeNode$sync_Arc_str_u32(freeList: rs.Place, rs.u32> | undefined>, node: Node.Node, rs.u32>): [rs.Arc, rs.u32] { detachNode$sync_Arc_str_u32(node); pushFree$sync_Arc_str_u32(freeList, node); return Node.takeEntry$sync_Arc_str_u32(node); } -export function removeNode$u16_maps_Logged(freeList: rt.Place | undefined>, node: Node.Node): [rt.u16, Logged.Logged] { +export function removeNode$u16_maps_Logged(freeList: rs.Place | undefined>, node: Node.Node): [rs.u16, Logged.Logged] { detachNode$u16_maps_Logged(node); pushFree$u16_maps_Logged(freeList, node); return Node.takeEntry$u16_maps_Logged(node); } -export function removeNode$u16_u32(freeList: rt.Place | undefined>, node: Node.Node): [rt.u16, rt.u32] { +export function removeNode$u16_u32(freeList: rs.Place | undefined>, node: Node.Node): [rs.u16, rs.u32] { detachNode$u16_u32(node); pushFree$u16_u32(freeList, node); return Node.takeEntry$u16_u32(node); } -export function hashNode$hashlink_DefaultHashBuilder_maps_Logged_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rt.u64 { +export function hashNode$hashlink_DefaultHashBuilder_maps_Logged_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rs.u64 { return hashKey$hashlink_DefaultHashBuilder_maps_Logged(s, Node.keyRef$maps_Logged_maps_Logged(node)); } -export function hashNode$hashlink_DefaultHashBuilder_sync_Arc_str_u32(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node, rt.u32>): rt.u64 { +export function hashNode$hashlink_DefaultHashBuilder_sync_Arc_str_u32(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node, rs.u32>): rs.u64 { return hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(s, Node.keyRef$sync_Arc_str_u32(node)); } -export function hashNode$hashlink_DefaultHashBuilder_u16_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rt.u64 { +export function hashNode$hashlink_DefaultHashBuilder_u16_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rs.u64 { return hashKey$hashlink_DefaultHashBuilder_u16(s, Node.keyRef$u16_maps_Logged(node)); } -export function hashNode$hashlink_DefaultHashBuilder_u16_u32(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rt.u64 { +export function hashNode$hashlink_DefaultHashBuilder_u16_u32(s: DefaultHashBuilder.DefaultHashBuilder, node: Node.Node): rs.u64 { return hashKey$hashlink_DefaultHashBuilder_u16(s, Node.keyRef$u16_u32(node)); } -export function hashKey$hash_RandomState_u16(s: rt.RandomState, k: rt.u16): rt.u64 { - return rt.hashOne(rt.buildHasher(s), k, rt.hash16); +export function hashKey$hash_RandomState_u16(s: rs.RandomState, k: rs.u16): rs.u64 { + return rs.hashOne(rs.buildHasher(s), k, rs.hash16); } -export function hashKey$hashlink_DefaultHashBuilder_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, k: Logged.Logged): rt.u64 { - return rt.hashOne(new rt.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rt.hashOwn(Logged.hash$Hash_hashlink_DefaultHasher as (a0: Logged.Logged, a1: DefaultHasher.DefaultHasher) => undefined)); +export function hashKey$hashlink_DefaultHashBuilder_maps_Logged(s: DefaultHashBuilder.DefaultHashBuilder, k: Logged.Logged): rs.u64 { + return rs.hashOne(new rs.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rs.hashOwn(Logged.hash$Hash_hashlink_DefaultHasher as (a0: Logged.Logged, a1: DefaultHasher.DefaultHasher) => undefined)); } -export function hashKey$hashlink_DefaultHashBuilder_str(s: DefaultHashBuilder.DefaultHashBuilder, k: string): rt.u64 { - return rt.hashOne(new rt.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rt.hashStr); +export function hashKey$hashlink_DefaultHashBuilder_str(s: DefaultHashBuilder.DefaultHashBuilder, k: string): rs.u64 { + return rs.hashOne(new rs.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rs.hashStr); } -export function hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(s: DefaultHashBuilder.DefaultHashBuilder, k: rt.Arc): rt.u64 { - return rt.hashOne(new rt.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rt.hashArc(rt.hashStr)); +export function hashKey$hashlink_DefaultHashBuilder_sync_Arc_str(s: DefaultHashBuilder.DefaultHashBuilder, k: rs.Arc): rs.u64 { + return rs.hashOne(new rs.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rs.hashArc(rs.hashStr)); } -export function hashKey$hashlink_DefaultHashBuilder_u16(s: DefaultHashBuilder.DefaultHashBuilder, k: rt.u16): rt.u64 { - return rt.hashOne(new rt.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rt.hash16); +export function hashKey$hashlink_DefaultHashBuilder_u16(s: DefaultHashBuilder.DefaultHashBuilder, k: rs.u16): rs.u64 { + return rs.hashOne(new rs.OwnHasher(DefaultHashBuilder.buildHasher$hash_BuildHasher(s), DefaultHasher.hasher$hash_Hasher), k, rs.hash16); } //# sourceMappingURL=linked_hash_map.ts.map diff --git a/ts/fixtures/stock/expected/hashlink/linked_hash_set.LinkedHashSet.ts b/ts/fixtures/stock/expected/hashlink/linked_hash_set.LinkedHashSet.ts index 1070d52eb..1a76274eb 100644 --- a/ts/fixtures/stock/expected/hashlink/linked_hash_set.LinkedHashSet.ts +++ b/ts/fixtures/stock/expected/hashlink/linked_hash_set.LinkedHashSet.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as LinkedHashMap from "../hashlink/linked_hash_map.LinkedHashMap.ts"; import type * as DefaultHashBuilder from "../hashlink.DefaultHashBuilder.ts"; import type * as Logged from "../maps.Logged.ts"; @@ -25,11 +25,11 @@ export function new$maps_Logged_hashlink_DefaultHashBuilder(): LinkedHashSet, value: Logged.Logged): boolean { - return LinkedHashMap.insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self.map, value, undefined) === rt.None; + return LinkedHashMap.insert$maps_Logged_unit_hashlink_DefaultHashBuilder(self.map, value, undefined) === rs.None; } export function remove$maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(self: LinkedHashSet, value: Logged.Logged): boolean { - return LinkedHashMap.remove$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self.map, value) !== rt.None; + return LinkedHashMap.remove$maps_Logged_unit_hashlink_DefaultHashBuilder_maps_Logged(self.map, value) !== rs.None; } export function default$Default_maps_Logged_hashlink_DefaultHashBuilder(): LinkedHashSet { diff --git a/ts/fixtures/stock/expected/hashlink/lru_cache.LruCache.ts b/ts/fixtures/stock/expected/hashlink/lru_cache.LruCache.ts index b8fd5a176..f5ca13d64 100644 --- a/ts/fixtures/stock/expected/hashlink/lru_cache.LruCache.ts +++ b/ts/fixtures/stock/expected/hashlink/lru_cache.LruCache.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_tuple2_maps_Logged_maps_Logged as lib_drop$Option_tuple2_maps_Logged_maps_Logged, drop$Option_tuple2_u16_maps_Logged as lib_drop$Option_tuple2_u16_maps_Logged } from "../lib.ts"; import * as LinkedHashMap from "../hashlink/linked_hash_map.LinkedHashMap.ts"; import type * as DefaultHashBuilder from "../hashlink.DefaultHashBuilder.ts"; @@ -8,19 +8,19 @@ import type * as Logged from "../maps.Logged.ts"; export class LruCache { map: LinkedHashMap.LinkedHashMap; - maxSize: rt.usize; + maxSize: rs.usize; - constructor(map: LinkedHashMap.LinkedHashMap, maxSize: rt.usize) { + constructor(map: LinkedHashMap.LinkedHashMap, maxSize: rs.usize) { this.map = map; this.maxSize = maxSize; } } -export function new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(capacity: rt.usize): LruCache { +export function new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(capacity: rs.usize): LruCache { return new LruCache(LinkedHashMap.new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(), capacity); } -export function new$u16_maps_Logged_hashlink_DefaultHashBuilder(capacity: rt.usize): LruCache { +export function new$u16_maps_Logged_hashlink_DefaultHashBuilder(capacity: rs.usize): LruCache { return new LruCache(LinkedHashMap.new$u16_maps_Logged_hashlink_DefaultHashBuilder(), capacity); } @@ -29,23 +29,23 @@ export function new$u16_maps_Logged_hashlink_DefaultHashBuilder(capacity: rt.usi * * A simple convenience method that is equivalent to `LruCache::new(usize::MAX)` */ -export function newUnbounded$u16_maps_Logged_hashlink_DefaultHashBuilder(): LruCache { +export function newUnbounded$u16_maps_Logged_hashlink_DefaultHashBuilder(): LruCache { return new$u16_maps_Logged_hashlink_DefaultHashBuilder(4294967295); } -export function capacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rt.usize { +export function capacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rs.usize { return self.maxSize; } -export function capacity$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rt.usize { +export function capacity$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rs.usize { return self.maxSize; } -export function len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rt.usize { +export function len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rs.usize { return LinkedHashMap.len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self.map); } -export function len$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rt.usize { +export function len$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): rs.usize { return LinkedHashMap.len$u16_maps_Logged_hashlink_DefaultHashBuilder(self.map); } @@ -68,7 +68,7 @@ export function insert$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: * * If necessary, will remove the value at the front of the LRU list to make room. */ -export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache, k: rt.u16, v: Logged.Logged): Logged.Logged | undefined { +export function insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache, k: rs.u16, v: Logged.Logged): Logged.Logged | undefined { const oldVal: Logged.Logged | undefined = LinkedHashMap.insert$u16_maps_Logged_hashlink_DefaultHashBuilder(self.map, k, v); if (len$u16_maps_Logged_hashlink_DefaultHashBuilder(self) > capacity$u16_maps_Logged_hashlink_DefaultHashBuilder(self)) { lib_drop$Option_tuple2_u16_maps_Logged(removeLru$u16_maps_Logged_hashlink_DefaultHashBuilder(self)); @@ -87,10 +87,10 @@ export function remove$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_ * If there are more entries in the `LruCache` than the new capacity will allow, they are * removed. */ -export function setCapacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache, capacity: rt.usize): void { - const _5: rt.usize = len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self); - let iterStart: rt.usize = capacity; - const iterEnd: rt.usize = _5; +export function setCapacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache, capacity: rs.usize): void { + const _5: rs.usize = len$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self); + let iterStart: rs.usize = capacity; + const iterEnd: rs.usize = _5; while (iterStart++ < iterEnd) { lib_drop$Option_tuple2_maps_Logged_maps_Logged(removeLru$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(self)); } @@ -111,7 +111,7 @@ export function removeLru$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(se * * If the `LruCache` is empty this will return None. */ -export function removeLru$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): [rt.u16, Logged.Logged] | undefined { +export function removeLru$u16_maps_Logged_hashlink_DefaultHashBuilder(self: LruCache): [rs.u16, Logged.Logged] | undefined { return LinkedHashMap.popFront$u16_maps_Logged_hashlink_DefaultHashBuilder(self.map); } diff --git a/ts/fixtures/stock/expected/lib.ts b/ts/fixtures/stock/expected/lib.ts index 75cd28fd7..b6c1611a6 100644 --- a/ts/fixtures/stock/expected/lib.ts +++ b/ts/fixtures/stock/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as buf_Counted from "./buf.Counted.ts"; import * as Pieces from "./buf.Pieces.ts"; import * as Provided from "./buf.Provided.ts"; @@ -24,7 +24,7 @@ export function copy$maps_Logged(v: Logged.Logged): Logged.Logged { return new Logged.Logged(v._0, v._1); } -export function copy$mem_MaybeUninit_tuple2_u16_u32(v: [rt.u16, rt.u32]): [rt.u16, rt.u32] { +export function copy$mem_MaybeUninit_tuple2_u16_u32(v: [rs.u16, rs.u32]): [rs.u16, rs.u32] { if (v === undefined) { return v; } @@ -39,21 +39,21 @@ export function copy$tuple2_maps_Logged_unit(v: [Logged.Logged, undefined]): [Lo return [copy$maps_Logged(v[0]), v[1]]; } -export function copy$tuple2_sync_Arc_str_u32(v: [rt.Arc, rt.u32]): [rt.Arc, rt.u32] { +export function copy$tuple2_sync_Arc_str_u32(v: [rs.Arc, rs.u32]): [rs.Arc, rs.u32] { return [v[0], v[1]]; } -export function copy$tuple2_u16_maps_Logged(v: [rt.u16, Logged.Logged]): [rt.u16, Logged.Logged] { +export function copy$tuple2_u16_maps_Logged(v: [rs.u16, Logged.Logged]): [rs.u16, Logged.Logged] { return [v[0], copy$maps_Logged(v[1])]; } -export function copy$tuple2_u16_u32(v: [rt.u16, rt.u32]): [rt.u16, rt.u32] { +export function copy$tuple2_u16_u32(v: [rs.u16, rs.u32]): [rs.u16, rs.u32] { return [v[0], v[1]]; } -export function drop$Option_bytes_Bytes(_1: rt.ByteSlice | undefined): void { +export function drop$Option_bytes_Bytes(_1: rs.ByteSlice | undefined): void { if (_1 !== undefined) { - rt.bytesDrop(_1); + rs.bytesDrop(_1); } } @@ -69,53 +69,53 @@ export function drop$Option_tuple2_maps_Logged_maps_Logged(_1: [Logged.Logged, L } } -export function drop$Option_tuple2_tuple2_u8_u8_maps_Logged(_1: [[rt.u8, rt.u8], Logged.Logged] | undefined): void { +export function drop$Option_tuple2_tuple2_u8_u8_maps_Logged(_1: [[rs.u8, rs.u8], Logged.Logged] | undefined): void { if (_1 !== undefined) { drop$tuple2_tuple2_u8_u8_maps_Logged(_1); } } -export function drop$Option_tuple2_u16_maps_Logged(_1: [rt.u16, Logged.Logged] | undefined): void { +export function drop$Option_tuple2_u16_maps_Logged(_1: [rs.u16, Logged.Logged] | undefined): void { if (_1 !== undefined) { drop$tuple2_u16_maps_Logged(_1); } } -export function drop$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes(_1: Chain.Chain): void { - rt.drop(_1.a); - rt.bytesDrop(_1.b); +export function drop$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes(_1: Chain.Chain): void { + rs.drop(_1.a); + rs.bytesDrop(_1.b); } -export function drop$bytes_buf_Chain_buf_Provided_bytes_Bytes(_1: Chain.Chain): void { - rt.bytesDrop(_1.b); +export function drop$bytes_buf_Chain_buf_Provided_bytes_Bytes(_1: Chain.Chain): void { + rs.bytesDrop(_1.b); } -export function drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(_1: Chain.Chain>): void { - rt.bytesDrop(_1.a); +export function drop$bytes_buf_Chain_bytes_Bytes_bytes_buf_Chain_buf_Provided_ref_slice_u8(_1: Chain.Chain>): void { + rs.bytesDrop(_1.a); } -export function drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(_1: Chain.Chain): void { - rt.bytesDrop(_1.a); +export function drop$bytes_buf_Chain_bytes_Bytes_ref_slice_u8(_1: Chain.Chain): void { + rs.bytesDrop(_1.a); } -export function drop$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(_1: Chain.Chain, rt.ByteSlice>): void { +export function drop$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(_1: Chain.Chain, rs.ByteSlice>): void { drop$bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes(_1.a); } -export function drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(_1: Chain.Chain, Pieces.Pieces>): void { +export function drop$bytes_buf_Chain_bytes_buf_Chain_ref_slice_u8_bytes_Bytes_buf_Pieces(_1: Chain.Chain, Pieces.Pieces>): void { drop$bytes_buf_Chain_ref_slice_u8_bytes_Bytes(_1.a); } -export function drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(_1: Chain.Chain, Pieces.Pieces>): void { +export function drop$bytes_buf_Chain_bytes_buf_Take_bytes_Bytes_buf_Pieces(_1: Chain.Chain, Pieces.Pieces>): void { drop$bytes_buf_Take_bytes_Bytes(_1.a); } -export function drop$bytes_buf_Chain_ref_slice_u8_bytes_Bytes(_1: Chain.Chain): void { - rt.bytesDrop(_1.b); +export function drop$bytes_buf_Chain_ref_slice_u8_bytes_Bytes(_1: Chain.Chain): void { + rs.bytesDrop(_1.b); } -export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): void { - rt.bytesDrop(_1.inner); +export function drop$bytes_buf_Take_bytes_Bytes(_1: Take.Take): void { + rs.bytesDrop(_1.inner); } export function drop$hashlink_LinkedHashMap_maps_Logged_maps_Logged(_1: LinkedHashMap.LinkedHashMap): void { @@ -126,19 +126,19 @@ export function drop$hashlink_LinkedHashMap_maps_Logged_unit(_1: LinkedHashMap.L LinkedHashMap.drop$ops_Drop_maps_Logged_unit_hashlink_DefaultHashBuilder(_1); } -export function drop$hashlink_LinkedHashMap_sync_Arc_str_u32(_1: LinkedHashMap.LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder>): void { +export function drop$hashlink_LinkedHashMap_sync_Arc_str_u32(_1: LinkedHashMap.LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder>): void { LinkedHashMap.drop$ops_Drop_sync_Arc_str_u32_hashlink_DefaultHashBuilder(_1); } -export function drop$hashlink_LinkedHashMap_u16_maps_Logged(_1: LinkedHashMap.LinkedHashMap): void { +export function drop$hashlink_LinkedHashMap_u16_maps_Logged(_1: LinkedHashMap.LinkedHashMap): void { LinkedHashMap.drop$ops_Drop_u16_maps_Logged_hashlink_DefaultHashBuilder(_1); } -export function drop$hashlink_LinkedHashMap_u16_u32(_1: LinkedHashMap.LinkedHashMap): void { +export function drop$hashlink_LinkedHashMap_u16_u32(_1: LinkedHashMap.LinkedHashMap): void { LinkedHashMap.drop$ops_Drop_u16_u32_hashlink_DefaultHashBuilder(_1); } -export function drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState(_1: LinkedHashMap.LinkedHashMap): void { +export function drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState(_1: LinkedHashMap.LinkedHashMap): void { LinkedHashMap.drop$ops_Drop_u16_u32_hash_RandomState(_1); } @@ -150,19 +150,19 @@ export function drop$hashlink_LruCache_maps_Logged_maps_Logged(_1: LruCache.LruC drop$hashlink_LinkedHashMap_maps_Logged_maps_Logged(_1.map); } -export function drop$hashlink_LruCache_u16_maps_Logged(_1: LruCache.LruCache): void { +export function drop$hashlink_LruCache_u16_maps_Logged(_1: LruCache.LruCache): void { drop$hashlink_LinkedHashMap_u16_maps_Logged(_1.map); } -export function drop$hashlink_linked_hash_map_Drain_u16_u32(_1: linked_hash_map_Drain.Drain): void { +export function drop$hashlink_linked_hash_map_Drain_u16_u32(_1: linked_hash_map_Drain.Drain): void { linked_hash_map_Drain.drop$ops_Drop_u16_u32(_1); } -export function drop$hashlink_linked_hash_map_DropFilteredValues_u16_u32(_1: DropFilteredValues.DropFilteredValues): void { +export function drop$hashlink_linked_hash_map_DropFilteredValues_u16_u32(_1: DropFilteredValues.DropFilteredValues): void { DropFilteredValues.drop$ops_Drop_u16_u32(_1); } -export function drop$hashlink_linked_hash_map_IntoIter_u16_u32(_1: linked_hash_map_IntoIter.IntoIter): void { +export function drop$hashlink_linked_hash_map_IntoIter_u16_u32(_1: linked_hash_map_IntoIter.IntoIter): void { linked_hash_map_IntoIter.drop$ops_Drop_u16_u32(_1); } @@ -174,15 +174,15 @@ export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_maps_Lo Remainder$drop_value_nodes.drop$drop_value_nodes_ops_Drop_maps_Logged_unit(_1); } -export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_sync_Arc_str_u32(_1: Remainder$drop_value_nodes.Remainder, rt.u32>): void { +export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_sync_Arc_str_u32(_1: Remainder$drop_value_nodes.Remainder, rs.u32>): void { Remainder$drop_value_nodes.drop$drop_value_nodes_ops_Drop_sync_Arc_str_u32(_1); } -export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_maps_Logged(_1: Remainder$drop_value_nodes.Remainder): void { +export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_maps_Logged(_1: Remainder$drop_value_nodes.Remainder): void { Remainder$drop_value_nodes.drop$drop_value_nodes_ops_Drop_u16_maps_Logged(_1); } -export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_u32(_1: Remainder$drop_value_nodes.Remainder): void { +export function drop$hashlink_linked_hash_map_drop_value_nodes_Remainder_u16_u32(_1: Remainder$drop_value_nodes.Remainder): void { Remainder$drop_value_nodes.drop$drop_value_nodes_ops_Drop_u16_u32(_1); } @@ -191,9 +191,9 @@ export function drop$maps_Held_maps_Logged(_1: Held.Held): void { _1.last[Symbol.dispose](); } -export function drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made(_1: [rt.HashMap, rt.HashSet]): void { - rt.hashDrop(_1[0], undefined, undefined, rt.drop); - rt.hashDrop(_1[1], undefined, undefined, rt.drop); +export function drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made(_1: [rs.HashMap, rs.HashSet]): void { + rs.hashDrop(_1[0], undefined, undefined, rs.drop); + rs.hashDrop(_1[1], undefined, undefined, rs.drop); } export function drop$tuple2_hashlink_LinkedHashSet_maps_Logged_maps_Logged(_1: [LinkedHashSet.LinkedHashSet, Logged.Logged]): void { @@ -210,22 +210,22 @@ export function drop$tuple2_maps_Logged_unit(_1: [Logged.Logged, undefined]): vo _1[0][Symbol.dispose](); } -export function drop$tuple2_sync_Arc_str_u32(_1: [rt.Arc, rt.u32]): void { +export function drop$tuple2_sync_Arc_str_u32(_1: [rs.Arc, rs.u32]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_tuple2_u8_u8_maps_Logged(_1: [[rt.u8, rt.u8], Logged.Logged]): void { +export function drop$tuple2_tuple2_u8_u8_maps_Logged(_1: [[rs.u8, rs.u8], Logged.Logged]): void { _1[1][Symbol.dispose](); } -export function drop$tuple2_u16_maps_Logged(_1: [rt.u16, Logged.Logged]): void { +export function drop$tuple2_u16_maps_Logged(_1: [rs.u16, Logged.Logged]): void { _1[1][Symbol.dispose](); } -export function drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded(_1: [rt.HashMap<[rt.u8, rt.u8], rt.u32>, rt.HashSet, rt.HashSet]): void { - rt.hashDrop(_1[0], undefined, undefined, rt.drop); - rt.hashDrop(_1[1], undefined, undefined, rt.drop); - rt.hashDrop(_1[2], undefined, undefined, rt.drop); +export function drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded(_1: [rs.HashMap<[rs.u8, rs.u8], rs.u32>, rs.HashSet, rs.HashSet]): void { + rs.hashDrop(_1[0], undefined, undefined, rs.drop); + rs.hashDrop(_1[1], undefined, undefined, rs.drop); + rs.hashDrop(_1[2], undefined, undefined, rs.drop); } export class of$buf_Counted { @@ -239,79 +239,79 @@ export class of$buf_Counted { this.v[Symbol.dispose](); } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return buf_Counted.advance$bytes_Buf(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return buf_Counted.chunk$bytes_Buf(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.bufCopyToBytes(this.v, a, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.bufCopyToBytes(this.v, a, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return buf_Counted.copyToSlice$bytes_Buf(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return buf_Counted.getF32Le$bytes_Buf(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return buf_Counted.getF64$bytes_Buf(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return buf_Counted.getI8$bytes_Buf(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return buf_Counted.getIntLe$bytes_Buf(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return buf_Counted.getU8$bytes_Buf(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return buf_Counted.getUint$bytes_Buf(this.v, a); } @@ -319,25 +319,25 @@ export class of$buf_Counted { return buf_Counted.hasRemaining$bytes_Buf(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return buf_Counted.remaining$bytes_Buf(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, buf_Counted.remaining$bytes_Buf, buf_Counted.chunk$bytes_Buf, buf_Counted.advance$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.usize) => undefined, buf_Counted.copyToSlice$bytes_Buf as (a0: buf_Counted.Counted, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = buf_Counted.tryGetU8$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } @@ -349,171 +349,171 @@ export class of$buf_Pieces { this.v = v; } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Pieces.advance$bytes_Buf(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Pieces.chunk$bytes_Buf(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { return Pieces.copyToBytes$bytes_Buf(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Pieces.copyToSlice$bytes_Buf(this.v, a); } - getF32$Buf(): rt.f32 { + getF32$Buf(): rs.f32 { return Pieces.getF32$bytes_Buf(this.v); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Pieces.getF32Le$bytes_Buf(this.v); } - getF32Ne$Buf(): rt.f32 { + getF32Ne$Buf(): rs.f32 { return Pieces.getF32Ne$bytes_Buf(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Pieces.getF64$bytes_Buf(this.v); } - getF64Le$Buf(): rt.f64 { + getF64Le$Buf(): rs.f64 { return Pieces.getF64Le$bytes_Buf(this.v); } - getF64Ne$Buf(): rt.f64 { + getF64Ne$Buf(): rs.f64 { return Pieces.getF64Ne$bytes_Buf(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI128Le$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, true, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI128Le$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, true, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI128Ne$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, true, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI128Ne$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, true, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI16$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, false, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI16$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, false, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI32Le$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, true, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI32Le$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, true, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI32Ne$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, true, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI32Ne$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, true, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI64$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, false, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI64$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, false, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI64Ne$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getI64Ne$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Pieces.getI8$bytes_Buf(this.v); } - getInt$Buf(a: rt.usize): rt.i64 { + getInt$Buf(a: rs.usize): rs.i64 { return Pieces.getInt$bytes_Buf(this.v, a); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Pieces.getIntLe$bytes_Buf(this.v, a); } - getIntNe$Buf(a: rt.usize): rt.i64 { + getIntNe$Buf(a: rs.usize): rs.i64 { return Pieces.getIntNe$bytes_Buf(this.v, a); } - getU128$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, false, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU128$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, false, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU128Ne$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU128Ne$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU16Le$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, true, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU16Le$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, true, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU16Ne$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, true, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU16Ne$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, true, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU32$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, false, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU32$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, false, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU32Ne$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU32Ne$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU64Le$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, true, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU64Le$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, true, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU64Ne$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, true, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + getU64Ne$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, true, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Pieces.getU8$bytes_Buf(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Pieces.getUint$bytes_Buf(this.v, a); } - getUintLe$Buf(a: rt.usize): rt.u64 { + getUintLe$Buf(a: rs.usize): rs.u64 { return Pieces.getUintLe$bytes_Buf(this.v, a); } - getUintNe$Buf(a: rt.usize): rt.u64 { + getUintNe$Buf(a: rs.usize): rs.u64 { return Pieces.getUintNe$bytes_Buf(this.v, a); } @@ -521,11 +521,11 @@ export class of$buf_Pieces { return Pieces.hasRemaining$bytes_Buf(this.v); } - pieces$Leased(): rt.usize { + pieces$Leased(): rs.usize { return Pieces.pieces$buf_Leased(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Pieces.remaining$bytes_Buf(this.v); } @@ -533,187 +533,187 @@ export class of$buf_Pieces { return Pieces.skip$buf_Leased(this.v, a); } - tryCopyToSlice$Buf(a: rt.ByteSlice): rt.Result { + tryCopyToSlice$Buf(a: rs.ByteSlice): rs.Result { return Pieces.tryCopyToSlice$bytes_Buf(this.v, a); } - tryGetF32$Buf(): rt.Result { + tryGetF32$Buf(): rs.Result { const part = Pieces.tryGetF32$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f32.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f32.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetF32Le$Buf(): rt.Result { + tryGetF32Le$Buf(): rs.Result { const part = Pieces.tryGetF32Le$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f32.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f32.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetF32Ne$Buf(): rt.Result { + tryGetF32Ne$Buf(): rs.Result { const part = Pieces.tryGetF32Ne$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f32.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f32.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetF64$Buf(): rt.Result { + tryGetF64$Buf(): rs.Result { const part = Pieces.tryGetF64$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetF64Le$Buf(): rt.Result { + tryGetF64Le$Buf(): rs.Result { const part = Pieces.tryGetF64Le$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetF64Ne$Buf(): rt.Result { + tryGetF64Ne$Buf(): rs.Result { const part = Pieces.tryGetF64Ne$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$f64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$f64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetI128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI128Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, true, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI128Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, true, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI128Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, true, rt.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI128Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, true, rs.i128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI16Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, true, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI16Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, true, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI16Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, true, rt.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI16Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, true, rs.i16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI32$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, false, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI32$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, false, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI32Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, true, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI32Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, true, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI32Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, true, rt.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI32Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, true, rs.i32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI64$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, false, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI64$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, false, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI64Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetI64Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetI8$Buf(): rt.Result { + tryGetI8$Buf(): rs.Result { const part = Pieces.tryGetI8$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$i8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$i8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetInt$Buf(a: rt.usize): rt.Result { + tryGetInt$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetInt$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$i64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$i64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetIntLe$Buf(a: rt.usize): rt.Result { + tryGetIntLe$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetIntLe$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$i64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$i64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetIntNe$Buf(a: rt.usize): rt.Result { + tryGetIntNe$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetIntNe$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$i64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$i64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU128Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, true, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU128Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, true, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU128Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, true, rt.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU128Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, true, rs.u128FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU16Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, true, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU16Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, true, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU16Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, true, rt.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU16Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, true, rs.u16FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU32$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, false, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU32$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, false, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU32Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, true, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU32Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, true, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU32Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 4, true, rt.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU32Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 4, true, rs.u32FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU64$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, false, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU64$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, false, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU64Ne$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rt.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rt.ByteSlice) => undefined); + tryGetU64Ne$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.u64FromBeBytes, Pieces.remaining$bytes_Buf, Pieces.chunk$bytes_Buf, Pieces.advance$bytes_Buf as (a0: Pieces.Pieces, a1: rs.usize) => undefined, Pieces.copyToSlice$bytes_Buf as (a0: Pieces.Pieces, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Pieces.tryGetU8$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetUint$Buf(a: rt.usize): rt.Result { + tryGetUint$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetUint$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$u64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetUintLe$Buf(a: rt.usize): rt.Result { + tryGetUintLe$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetUintLe$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$u64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } - tryGetUintNe$Buf(a: rt.usize): rt.Result { + tryGetUintNe$Buf(a: rs.usize): rs.Result { const part = Pieces.tryGetUintNe$bytes_Buf(this.v, a); - const result: rt.Result = part === undefined ? rt.Err(out$u64.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u64.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } @@ -725,79 +725,79 @@ export class of$buf_Provided { this.v = v; } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Provided.advance$bytes_Buf(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Provided.chunk$bytes_Buf(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.bufCopyToBytes(this.v, a, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.bufCopyToBytes(this.v, a, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Provided.copyToSlice$bytes_Buf(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Provided.getF32Le$bytes_Buf(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Provided.getF64$bytes_Buf(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Provided.getI8$bytes_Buf(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Provided.getIntLe$bytes_Buf(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Provided.getU8$bytes_Buf(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Provided.getUint$bytes_Buf(this.v, a); } @@ -805,171 +805,171 @@ export class of$buf_Provided { return Provided.hasRemaining$bytes_Buf(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Provided.remaining$bytes_Buf(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rt.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Provided.remaining$bytes_Buf, Provided.chunk$bytes_Buf, Provided.advance$bytes_Buf as (a0: Provided.Provided, a1: rs.usize) => undefined, Provided.copyToSlice$bytes_Buf as (a0: Provided.Provided, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Provided.tryGetU8$bytes_Buf(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_Bytes { - v: rt.ByteSlice; + v: rs.ByteSlice; - constructor(v: rt.ByteSlice) { + constructor(v: rs.ByteSlice) { this.v = v; } [Symbol.dispose](): void { - rt.bytesDrop(this.v); + rs.bytesDrop(this.v); } - advance$Buf(a: rt.usize): void { - return rt.bytesAdvance(this, a); + advance$Buf(a: rs.usize): void { + return rs.bytesAdvance(this, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return this.v; } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.bytesSplitTo(this, a); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.bytesSplitTo(this, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { - return rt.bytesCopyToSlice(this, a); + copyToSlice$Buf(a: rs.ByteSlice): void { + return rs.bytesCopyToSlice(this, a); } - getF32Le$Buf(): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(this, 4, true)); + getF32Le$Buf(): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(this, 4, true)); } - getF64$Buf(): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(this, 8, false)); + getF64$Buf(): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(this, 8, false)); } - getI128$Buf(): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(this, 16, false)); + getI128$Buf(): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(this, 16, false)); } - getI16Le$Buf(): rt.i16 { - return (rt.bytesReadWord(this, 2, true) << 16) >> 16 as rt.i16; + getI16Le$Buf(): rs.i16 { + return (rs.bytesReadWord(this, 2, true) << 16) >> 16 as rs.i16; } - getI16Ne$Buf(): rt.i16 { - return (rt.bytesReadWord(this, 2, true) << 16) >> 16 as rt.i16; + getI16Ne$Buf(): rs.i16 { + return (rs.bytesReadWord(this, 2, true) << 16) >> 16 as rs.i16; } - getI32$Buf(): rt.i32 { - return (rt.bytesReadWord(this, 4, false) | 0) as rt.i32; + getI32$Buf(): rs.i32 { + return (rs.bytesReadWord(this, 4, false) | 0) as rs.i32; } - getI64Le$Buf(): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(this, 8, true)); + getI64Le$Buf(): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(this, 8, true)); } - getI8$Buf(): rt.i8 { - return (rt.bytesReadWord(this, 1, false) << 24) >> 24 as rt.i8; + getI8$Buf(): rs.i8 { + return (rs.bytesReadWord(this, 1, false) << 24) >> 24 as rs.i8; } - getIntLe$Buf(a: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(this, 8, a, true, true)); + getIntLe$Buf(a: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(this, 8, a, true, true)); } - getU128Le$Buf(): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(this, 16, true)); + getU128Le$Buf(): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(this, 16, true)); } - getU16$Buf(): rt.u16 { - return rt.bytesReadWord(this, 2, false) as rt.u16; + getU16$Buf(): rs.u16 { + return rs.bytesReadWord(this, 2, false) as rs.u16; } - getU32Le$Buf(): rt.u32 { - return rt.bytesReadWord(this, 4, true) as rt.u32; + getU32Le$Buf(): rs.u32 { + return rs.bytesReadWord(this, 4, true) as rs.u32; } - getU64$Buf(): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(this, 8, false)); + getU64$Buf(): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(this, 8, false)); } - getU8$Buf(): rt.u8 { - return rt.bytesReadWord(this, 1, false) as rt.u8; + getU8$Buf(): rs.u8 { + return rs.bytesReadWord(this, 1, false) as rs.u8; } - getUint$Buf(a: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(this, 8, a, false, false)); + getUint$Buf(a: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(this, 8, a, false, false)); } hasRemaining$Buf(): boolean { return this.v.length !== 0; } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return this.v.length; } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = tryGetU8$bytes_Buf_bytes_Bytes(this); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_BytesMut { - v: rt.BytesMut; + v: rs.BytesMut; - constructor(v: rt.BytesMut) { + constructor(v: rs.BytesMut) { this.v = v; } @@ -977,213 +977,213 @@ export class of$bytes_BytesMut { this.v[Symbol.dispose](); } - advance$Buf(a: rt.usize): void { - return rt.bytesMutAdvance(this.v, a); + advance$Buf(a: rs.usize): void { + return rs.bytesMutAdvance(this.v, a); } - chunk$Buf(): rt.ByteSlice { - return rt.bytesMutView(this.v); + chunk$Buf(): rs.ByteSlice { + return rs.bytesMutView(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.bytesMutFreeze(rt.bytesMutSplitTo(this.v, a)); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.bytesMutFreeze(rs.bytesMutSplitTo(this.v, a)); } - copyToSlice$Buf(a: rt.ByteSlice): void { - return rt.bytesMutCopyToSlice(this.v, a); + copyToSlice$Buf(a: rs.ByteSlice): void { + return rs.bytesMutCopyToSlice(this.v, a); } - getF32Le$Buf(): rt.f32 { - return rt.f32FromBeBytes(rt.bytesMutRead(this.v, 4, true)); + getF32Le$Buf(): rs.f32 { + return rs.f32FromBeBytes(rs.bytesMutRead(this.v, 4, true)); } - getF64$Buf(): rt.f64 { - return rt.f64FromBeBytes(rt.bytesMutRead(this.v, 8, false)); + getF64$Buf(): rs.f64 { + return rs.f64FromBeBytes(rs.bytesMutRead(this.v, 8, false)); } - getI128$Buf(): rt.i128 { - return rt.i128FromBeBytes(rt.bytesMutRead(this.v, 16, false)); + getI128$Buf(): rs.i128 { + return rs.i128FromBeBytes(rs.bytesMutRead(this.v, 16, false)); } - getI16Le$Buf(): rt.i16 { - return (rt.bytesMutReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Le$Buf(): rs.i16 { + return (rs.bytesMutReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI16Ne$Buf(): rt.i16 { - return (rt.bytesMutReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Ne$Buf(): rs.i16 { + return (rs.bytesMutReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI32$Buf(): rt.i32 { - return (rt.bytesMutReadWord(this.v, 4, false) | 0) as rt.i32; + getI32$Buf(): rs.i32 { + return (rs.bytesMutReadWord(this.v, 4, false) | 0) as rs.i32; } - getI64Le$Buf(): rt.i64 { - return rt.i64FromBeBytes(rt.bytesMutRead(this.v, 8, true)); + getI64Le$Buf(): rs.i64 { + return rs.i64FromBeBytes(rs.bytesMutRead(this.v, 8, true)); } - getI8$Buf(): rt.i8 { - return (rt.bytesMutReadWord(this.v, 1, false) << 24) >> 24 as rt.i8; + getI8$Buf(): rs.i8 { + return (rs.bytesMutReadWord(this.v, 1, false) << 24) >> 24 as rs.i8; } - getIntLe$Buf(a: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesMutReadInt(this.v, 8, a, true, true)); + getIntLe$Buf(a: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesMutReadInt(this.v, 8, a, true, true)); } - getU128Le$Buf(): rt.u128 { - return rt.u128FromBeBytes(rt.bytesMutRead(this.v, 16, true)); + getU128Le$Buf(): rs.u128 { + return rs.u128FromBeBytes(rs.bytesMutRead(this.v, 16, true)); } - getU16$Buf(): rt.u16 { - return rt.bytesMutReadWord(this.v, 2, false) as rt.u16; + getU16$Buf(): rs.u16 { + return rs.bytesMutReadWord(this.v, 2, false) as rs.u16; } - getU32Le$Buf(): rt.u32 { - return rt.bytesMutReadWord(this.v, 4, true) as rt.u32; + getU32Le$Buf(): rs.u32 { + return rs.bytesMutReadWord(this.v, 4, true) as rs.u32; } - getU64$Buf(): rt.u64 { - return rt.u64FromBeBytes(rt.bytesMutRead(this.v, 8, false)); + getU64$Buf(): rs.u64 { + return rs.u64FromBeBytes(rs.bytesMutRead(this.v, 8, false)); } - getU8$Buf(): rt.u8 { - return rt.bytesMutReadWord(this.v, 1, false) as rt.u8; + getU8$Buf(): rs.u8 { + return rs.bytesMutReadWord(this.v, 1, false) as rs.u8; } - getUint$Buf(a: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesMutReadInt(this.v, 8, a, false, false)); + getUint$Buf(a: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesMutReadInt(this.v, 8, a, false, false)); } hasRemaining$Buf(): boolean { return this.v.length !== 0; } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return this.v.length; } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, (a0: rt.BytesMut): rt.usize => { + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, (a0: rs.BytesMut): rs.usize => { return a0.length; - }, (a02: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a02); - }, (a03: rt.BytesMut, a1: rt.usize): undefined => { - rt.bytesMutAdvance(a03, a1); - }, (a04: rt.BytesMut, a12: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a04, a12); + }, (a02: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a02); + }, (a03: rs.BytesMut, a1: rs.usize): undefined => { + rs.bytesMutAdvance(a03, a1); + }, (a04: rs.BytesMut, a12: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a04, a12); }); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, (a0: rt.BytesMut): rt.usize => { + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, (a0: rs.BytesMut): rs.usize => { return a0.length; - }, (a02: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a02); - }, (a03: rt.BytesMut, a1: rt.usize): undefined => { - rt.bytesMutAdvance(a03, a1); - }, (a04: rt.BytesMut, a12: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a04, a12); + }, (a02: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a02); + }, (a03: rs.BytesMut, a1: rs.usize): undefined => { + rs.bytesMutAdvance(a03, a1); + }, (a04: rs.BytesMut, a12: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a04, a12); }); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, (a0: rt.BytesMut): rt.usize => { + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, (a0: rs.BytesMut): rs.usize => { return a0.length; - }, (a02: rt.BytesMut): rt.ByteSlice => { - return rt.bytesMutView(a02); - }, (a03: rt.BytesMut, a1: rt.usize): undefined => { - rt.bytesMutAdvance(a03, a1); - }, (a04: rt.BytesMut, a12: rt.ByteSlice): undefined => { - rt.bytesMutCopyToSlice(a04, a12); + }, (a02: rs.BytesMut): rs.ByteSlice => { + return rs.bytesMutView(a02); + }, (a03: rs.BytesMut, a1: rs.usize): undefined => { + rs.bytesMutAdvance(a03, a1); + }, (a04: rs.BytesMut, a12: rs.ByteSlice): undefined => { + rs.bytesMutCopyToSlice(a04, a12); }); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = tryGetU8$bytes_Buf_bytes_BytesMut(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8 { - v: Chain.Chain>; + v: Chain.Chain>; - constructor(v: Chain.Chain>) { + constructor(v: Chain.Chain>) { this.v = v; } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { return Chain.copyToBytes$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Chain.getF32Le$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Chain.getF64$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Chain.getI8$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Chain.getIntLe$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Chain.getU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Chain.getUint$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v, a); } @@ -1191,33 +1191,33 @@ export class of$bytes_buf_Chain_buf_Provided_mut_ref_slice_u8 { return Chain.hasRemaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.chunk$bytes_Buf_buf_Provided_mut_ref_slice_u8, Chain.advance$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_buf_Provided_mut_ref_slice_u8 as (a0: Chain.Chain>, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Chain.tryGetU8$bytes_Buf_buf_Provided_mut_ref_slice_u8(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 { - v: Chain.Chain, rt.ByteSlice>; + v: Chain.Chain, rs.ByteSlice>; - constructor(v: Chain.Chain, rt.ByteSlice>) { + constructor(v: Chain.Chain, rs.ByteSlice>) { this.v = v; } @@ -1225,79 +1225,79 @@ export class of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By drop$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { return Chain.copyToBytes$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Chain.getF32Le$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Chain.getF64$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Chain.getI8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Chain.getIntLe$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Chain.getU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Chain.getUint$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v, a); } @@ -1305,33 +1305,33 @@ export class of$bytes_buf_Chain_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_By return Chain.hasRemaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rt.ByteSlice>, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Chain.remaining$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.chunk$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8, Chain.advance$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.usize) => undefined, Chain.copyToSlice$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8 as (a0: Chain.Chain, rs.ByteSlice>, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Chain.tryGetU8$bytes_Buf_bytes_buf_Chain_boxed_Box_dyn_bytes_Buf_bytes_Bytes_ref_slice_u8(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_buf_Take_bytes_Bytes { - v: Take.Take; + v: Take.Take; - constructor(v: Take.Take) { + constructor(v: Take.Take) { this.v = v; } @@ -1339,79 +1339,79 @@ export class of$bytes_buf_Take_bytes_Bytes { drop$bytes_buf_Take_bytes_Bytes(this.v); } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Take.advance$bytes_Buf_bytes_Bytes(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Take.chunk$bytes_Buf_bytes_Bytes(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { return Take.copyToBytes$bytes_Buf_bytes_Bytes(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Take.copyToSlice$bytes_Buf_bytes_Bytes(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Take.getF32Le$bytes_Buf_bytes_Bytes(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Take.getF64$bytes_Buf_bytes_Bytes(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Take.getI8$bytes_Buf_bytes_Bytes(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Take.getIntLe$bytes_Buf_bytes_Bytes(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Take.getU8$bytes_Buf_bytes_Bytes(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Take.getUint$bytes_Buf_bytes_Bytes(this.v, a); } @@ -1419,109 +1419,109 @@ export class of$bytes_buf_Take_bytes_Bytes { return Take.hasRemaining$bytes_Buf_bytes_Bytes(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Take.remaining$bytes_Buf_bytes_Bytes(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_bytes_Bytes, Take.chunk$bytes_Buf_bytes_Bytes, Take.advance$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_bytes_Bytes as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Take.tryGetU8$bytes_Buf_bytes_Bytes(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$bytes_buf_Take_ref_slice_u8 { - v: Take.Take; + v: Take.Take; - constructor(v: Take.Take) { + constructor(v: Take.Take) { this.v = v; } - advance$Buf(a: rt.usize): void { + advance$Buf(a: rs.usize): void { return Take.advance$bytes_Buf_ref_slice_u8(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return Take.chunk$bytes_Buf_ref_slice_u8(this.v); } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { return Take.copyToBytes$bytes_Buf_ref_slice_u8(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { + copyToSlice$Buf(a: rs.ByteSlice): void { return Take.copyToSlice$bytes_Buf_ref_slice_u8(this.v, a); } - getF32Le$Buf(): rt.f32 { + getF32Le$Buf(): rs.f32 { return Take.getF32Le$bytes_Buf_ref_slice_u8(this.v); } - getF64$Buf(): rt.f64 { + getF64$Buf(): rs.f64 { return Take.getF64$bytes_Buf_ref_slice_u8(this.v); } - getI128$Buf(): rt.i128 { - return rt.bufGet(this.v, 16, false, rt.i128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI128$Buf(): rs.i128 { + return rs.bufGet(this.v, 16, false, rs.i128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI16Le$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI16Le$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI16Ne$Buf(): rt.i16 { - return rt.bufGet(this.v, 2, true, rt.i16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI16Ne$Buf(): rs.i16 { + return rs.bufGet(this.v, 2, true, rs.i16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI32$Buf(): rt.i32 { - return rt.bufGet(this.v, 4, false, rt.i32FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI32$Buf(): rs.i32 { + return rs.bufGet(this.v, 4, false, rs.i32FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI64Le$Buf(): rt.i64 { - return rt.bufGet(this.v, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getI64Le$Buf(): rs.i64 { + return rs.bufGet(this.v, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getI8$Buf(): rt.i8 { + getI8$Buf(): rs.i8 { return Take.getI8$bytes_Buf_ref_slice_u8(this.v); } - getIntLe$Buf(a: rt.usize): rt.i64 { + getIntLe$Buf(a: rs.usize): rs.i64 { return Take.getIntLe$bytes_Buf_ref_slice_u8(this.v, a); } - getU128Le$Buf(): rt.u128 { - return rt.bufGet(this.v, 16, true, rt.u128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU128Le$Buf(): rs.u128 { + return rs.bufGet(this.v, 16, true, rs.u128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU16$Buf(): rt.u16 { - return rt.bufGet(this.v, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU16$Buf(): rs.u16 { + return rs.bufGet(this.v, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU32Le$Buf(): rt.u32 { - return rt.bufGet(this.v, 4, true, rt.u32FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU32Le$Buf(): rs.u32 { + return rs.bufGet(this.v, 4, true, rs.u32FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU64$Buf(): rt.u64 { - return rt.bufGet(this.v, 8, false, rt.u64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + getU64$Buf(): rs.u64 { + return rs.bufGet(this.v, 8, false, rs.u64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - getU8$Buf(): rt.u8 { + getU8$Buf(): rs.u8 { return Take.getU8$bytes_Buf_ref_slice_u8(this.v); } - getUint$Buf(a: rt.usize): rt.u64 { + getUint$Buf(a: rs.usize): rs.u64 { return Take.getUint$bytes_Buf_ref_slice_u8(this.v, a); } @@ -1529,431 +1529,431 @@ export class of$bytes_buf_Take_ref_slice_u8 { return Take.hasRemaining$bytes_Buf_ref_slice_u8(this.v); } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return Take.remaining$bytes_Buf_ref_slice_u8(this.v); } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rt.ByteSlice) => undefined); + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, Take.remaining$bytes_Buf_ref_slice_u8, Take.chunk$bytes_Buf_ref_slice_u8, Take.advance$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.usize) => undefined, Take.copyToSlice$bytes_Buf_ref_slice_u8 as (a0: Take.Take, a1: rs.ByteSlice) => undefined); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = Take.tryGetU8$bytes_Buf_ref_slice_u8(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class of$ref_slice_u8 { - v: rt.ByteSlice; + v: rs.ByteSlice; - constructor(v: rt.ByteSlice) { + constructor(v: rs.ByteSlice) { this.v = v; } - advance$Buf(a: rt.usize): void { - return rt.byteSliceAdvance(this, a); + advance$Buf(a: rs.usize): void { + return rs.byteSliceAdvance(this, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return this.v; } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.byteSliceCopyToBytes(this, a); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.byteSliceCopyToBytes(this, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { - return rt.bytesCopyToSlice(this, a); + copyToSlice$Buf(a: rs.ByteSlice): void { + return rs.bytesCopyToSlice(this, a); } - getF32Le$Buf(): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(this, 4, true)); + getF32Le$Buf(): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(this, 4, true)); } - getF64$Buf(): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(this, 8, false)); + getF64$Buf(): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(this, 8, false)); } - getI128$Buf(): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(this, 16, false)); + getI128$Buf(): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(this, 16, false)); } - getI16Le$Buf(): rt.i16 { - return (rt.bytesReadWord(this, 2, true) << 16) >> 16 as rt.i16; + getI16Le$Buf(): rs.i16 { + return (rs.bytesReadWord(this, 2, true) << 16) >> 16 as rs.i16; } - getI16Ne$Buf(): rt.i16 { - return (rt.bytesReadWord(this, 2, true) << 16) >> 16 as rt.i16; + getI16Ne$Buf(): rs.i16 { + return (rs.bytesReadWord(this, 2, true) << 16) >> 16 as rs.i16; } - getI32$Buf(): rt.i32 { - return (rt.bytesReadWord(this, 4, false) | 0) as rt.i32; + getI32$Buf(): rs.i32 { + return (rs.bytesReadWord(this, 4, false) | 0) as rs.i32; } - getI64Le$Buf(): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(this, 8, true)); + getI64Le$Buf(): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(this, 8, true)); } - getI8$Buf(): rt.i8 { - return (rt.bytesReadWord(this, 1, false) << 24) >> 24 as rt.i8; + getI8$Buf(): rs.i8 { + return (rs.bytesReadWord(this, 1, false) << 24) >> 24 as rs.i8; } - getIntLe$Buf(a: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(this, 8, a, true, true)); + getIntLe$Buf(a: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(this, 8, a, true, true)); } - getU128Le$Buf(): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(this, 16, true)); + getU128Le$Buf(): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(this, 16, true)); } - getU16$Buf(): rt.u16 { - return rt.bytesReadWord(this, 2, false) as rt.u16; + getU16$Buf(): rs.u16 { + return rs.bytesReadWord(this, 2, false) as rs.u16; } - getU32Le$Buf(): rt.u32 { - return rt.bytesReadWord(this, 4, true) as rt.u32; + getU32Le$Buf(): rs.u32 { + return rs.bytesReadWord(this, 4, true) as rs.u32; } - getU64$Buf(): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(this, 8, false)); + getU64$Buf(): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(this, 8, false)); } - getU8$Buf(): rt.u8 { - return rt.bytesReadWord(this, 1, false) as rt.u8; + getU8$Buf(): rs.u8 { + return rs.bytesReadWord(this, 1, false) as rs.u8; } - getUint$Buf(a: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(this, 8, a, false, false)); + getUint$Buf(a: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(this, 8, a, false, false)); } hasRemaining$Buf(): boolean { return this.v.length !== 0; } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return this.v.length; } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = tryGetU8$bytes_Buf_ref_slice_u8(this); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class ofPlace$bytes_Bytes { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } [Symbol.dispose](): void { - rt.bytesDrop(this.v.v); + rs.bytesDrop(this.v.v); } - advance$Buf(a: rt.usize): void { - return rt.bytesAdvance(this.v, a); + advance$Buf(a: rs.usize): void { + return rs.bytesAdvance(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return this.v.v; } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.bytesSplitTo(this.v, a); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.bytesSplitTo(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { - return rt.bytesCopyToSlice(this.v, a); + copyToSlice$Buf(a: rs.ByteSlice): void { + return rs.bytesCopyToSlice(this.v, a); } - getF32Le$Buf(): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(this.v, 4, true)); + getF32Le$Buf(): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(this.v, 4, true)); } - getF64$Buf(): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(this.v, 8, false)); + getF64$Buf(): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(this.v, 8, false)); } - getI128$Buf(): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(this.v, 16, false)); + getI128$Buf(): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(this.v, 16, false)); } - getI16Le$Buf(): rt.i16 { - return (rt.bytesReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Le$Buf(): rs.i16 { + return (rs.bytesReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI16Ne$Buf(): rt.i16 { - return (rt.bytesReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Ne$Buf(): rs.i16 { + return (rs.bytesReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI32$Buf(): rt.i32 { - return (rt.bytesReadWord(this.v, 4, false) | 0) as rt.i32; + getI32$Buf(): rs.i32 { + return (rs.bytesReadWord(this.v, 4, false) | 0) as rs.i32; } - getI64Le$Buf(): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(this.v, 8, true)); + getI64Le$Buf(): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(this.v, 8, true)); } - getI8$Buf(): rt.i8 { - return (rt.bytesReadWord(this.v, 1, false) << 24) >> 24 as rt.i8; + getI8$Buf(): rs.i8 { + return (rs.bytesReadWord(this.v, 1, false) << 24) >> 24 as rs.i8; } - getIntLe$Buf(a: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(this.v, 8, a, true, true)); + getIntLe$Buf(a: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(this.v, 8, a, true, true)); } - getU128Le$Buf(): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(this.v, 16, true)); + getU128Le$Buf(): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(this.v, 16, true)); } - getU16$Buf(): rt.u16 { - return rt.bytesReadWord(this.v, 2, false) as rt.u16; + getU16$Buf(): rs.u16 { + return rs.bytesReadWord(this.v, 2, false) as rs.u16; } - getU32Le$Buf(): rt.u32 { - return rt.bytesReadWord(this.v, 4, true) as rt.u32; + getU32Le$Buf(): rs.u32 { + return rs.bytesReadWord(this.v, 4, true) as rs.u32; } - getU64$Buf(): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(this.v, 8, false)); + getU64$Buf(): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(this.v, 8, false)); } - getU8$Buf(): rt.u8 { - return rt.bytesReadWord(this.v, 1, false) as rt.u8; + getU8$Buf(): rs.u8 { + return rs.bytesReadWord(this.v, 1, false) as rs.u8; } - getUint$Buf(a: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(this.v, 8, a, false, false)); + getUint$Buf(a: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(this.v, 8, a, false, false)); } hasRemaining$Buf(): boolean { return this.v.v.length !== 0; } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return this.v.v.length; } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.bytesAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.bytesAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = tryGetU8$bytes_Buf_bytes_Bytes(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } export class ofPlace$ref_slice_u8 { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } - advance$Buf(a: rt.usize): void { - return rt.byteSliceAdvance(this.v, a); + advance$Buf(a: rs.usize): void { + return rs.byteSliceAdvance(this.v, a); } - chunk$Buf(): rt.ByteSlice { + chunk$Buf(): rs.ByteSlice { return this.v.v; } - copyToBytes$Buf(a: rt.usize): rt.ByteSlice { - return rt.byteSliceCopyToBytes(this.v, a); + copyToBytes$Buf(a: rs.usize): rs.ByteSlice { + return rs.byteSliceCopyToBytes(this.v, a); } - copyToSlice$Buf(a: rt.ByteSlice): void { - return rt.bytesCopyToSlice(this.v, a); + copyToSlice$Buf(a: rs.ByteSlice): void { + return rs.bytesCopyToSlice(this.v, a); } - getF32Le$Buf(): rt.f32 { - return rt.f32FromBeBytes(rt.bytesRead(this.v, 4, true)); + getF32Le$Buf(): rs.f32 { + return rs.f32FromBeBytes(rs.bytesRead(this.v, 4, true)); } - getF64$Buf(): rt.f64 { - return rt.f64FromBeBytes(rt.bytesRead(this.v, 8, false)); + getF64$Buf(): rs.f64 { + return rs.f64FromBeBytes(rs.bytesRead(this.v, 8, false)); } - getI128$Buf(): rt.i128 { - return rt.i128FromBeBytes(rt.bytesRead(this.v, 16, false)); + getI128$Buf(): rs.i128 { + return rs.i128FromBeBytes(rs.bytesRead(this.v, 16, false)); } - getI16Le$Buf(): rt.i16 { - return (rt.bytesReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Le$Buf(): rs.i16 { + return (rs.bytesReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI16Ne$Buf(): rt.i16 { - return (rt.bytesReadWord(this.v, 2, true) << 16) >> 16 as rt.i16; + getI16Ne$Buf(): rs.i16 { + return (rs.bytesReadWord(this.v, 2, true) << 16) >> 16 as rs.i16; } - getI32$Buf(): rt.i32 { - return (rt.bytesReadWord(this.v, 4, false) | 0) as rt.i32; + getI32$Buf(): rs.i32 { + return (rs.bytesReadWord(this.v, 4, false) | 0) as rs.i32; } - getI64Le$Buf(): rt.i64 { - return rt.i64FromBeBytes(rt.bytesRead(this.v, 8, true)); + getI64Le$Buf(): rs.i64 { + return rs.i64FromBeBytes(rs.bytesRead(this.v, 8, true)); } - getI8$Buf(): rt.i8 { - return (rt.bytesReadWord(this.v, 1, false) << 24) >> 24 as rt.i8; + getI8$Buf(): rs.i8 { + return (rs.bytesReadWord(this.v, 1, false) << 24) >> 24 as rs.i8; } - getIntLe$Buf(a: rt.usize): rt.i64 { - return rt.i64FromBeBytes(rt.bytesReadInt(this.v, 8, a, true, true)); + getIntLe$Buf(a: rs.usize): rs.i64 { + return rs.i64FromBeBytes(rs.bytesReadInt(this.v, 8, a, true, true)); } - getU128Le$Buf(): rt.u128 { - return rt.u128FromBeBytes(rt.bytesRead(this.v, 16, true)); + getU128Le$Buf(): rs.u128 { + return rs.u128FromBeBytes(rs.bytesRead(this.v, 16, true)); } - getU16$Buf(): rt.u16 { - return rt.bytesReadWord(this.v, 2, false) as rt.u16; + getU16$Buf(): rs.u16 { + return rs.bytesReadWord(this.v, 2, false) as rs.u16; } - getU32Le$Buf(): rt.u32 { - return rt.bytesReadWord(this.v, 4, true) as rt.u32; + getU32Le$Buf(): rs.u32 { + return rs.bytesReadWord(this.v, 4, true) as rs.u32; } - getU64$Buf(): rt.u64 { - return rt.u64FromBeBytes(rt.bytesRead(this.v, 8, false)); + getU64$Buf(): rs.u64 { + return rs.u64FromBeBytes(rs.bytesRead(this.v, 8, false)); } - getU8$Buf(): rt.u8 { - return rt.bytesReadWord(this.v, 1, false) as rt.u8; + getU8$Buf(): rs.u8 { + return rs.bytesReadWord(this.v, 1, false) as rs.u8; } - getUint$Buf(a: rt.usize): rt.u64 { - return rt.u64FromBeBytes(rt.bytesReadInt(this.v, 8, a, false, false)); + getUint$Buf(a: rs.usize): rs.u64 { + return rs.u64FromBeBytes(rs.bytesReadInt(this.v, 8, a, false, false)); } hasRemaining$Buf(): boolean { return this.v.v.length !== 0; } - remaining$Buf(): rt.usize { + remaining$Buf(): rs.usize { return this.v.v.length; } - tryGetI64Le$Buf(): rt.Result { - return rt.bufTryGet(this.v, 8, true, rt.i64FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetI64Le$Buf(): rs.Result { + return rs.bufTryGet(this.v, 8, true, rs.i64FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU128$Buf(): rt.Result { - return rt.bufTryGet(this.v, 16, false, rt.u128FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU128$Buf(): rs.Result { + return rs.bufTryGet(this.v, 16, false, rs.u128FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU16$Buf(): rt.Result { - return rt.bufTryGet(this.v, 2, false, rt.u16FromBeBytes, (p: rt.Place) => ((a0: rt.ByteSlice): rt.usize => { + tryGetU16$Buf(): rs.Result { + return rs.bufTryGet(this.v, 2, false, rs.u16FromBeBytes, (p: rs.Place) => ((a0: rs.ByteSlice): rs.usize => { return a0.length; - })(p.v), (p: rt.Place) => ((a02: rt.ByteSlice): rt.ByteSlice => { + })(p.v), (p: rs.Place) => ((a02: rs.ByteSlice): rs.ByteSlice => { return a02; - })(p.v), (a03: rt.Place, a1: rt.usize): undefined => { - rt.byteSliceAdvance(a03, a1); - }, (a04: rt.Place, a12: rt.ByteSlice): undefined => { - rt.bytesCopyToSlice(a04, a12); + })(p.v), (a03: rs.Place, a1: rs.usize): undefined => { + rs.byteSliceAdvance(a03, a1); + }, (a04: rs.Place, a12: rs.ByteSlice): undefined => { + rs.bytesCopyToSlice(a04, a12); }); } - tryGetU8$Buf(): rt.Result { + tryGetU8$Buf(): rs.Result { const part = tryGetU8$bytes_Buf_ref_slice_u8(this.v); - const result: rt.Result = part === undefined ? rt.Err(out$u8.err as TryGetError.TryGetError) : rt.Ok(part); + const result: rs.Result = part === undefined ? rs.Err(out$u8.err as TryGetError.TryGetError) : rs.Ok(part); return result; } } diff --git a/ts/fixtures/stock/expected/maps.Counted.ts b/ts/fixtures/stock/expected/maps.Counted.ts index ba51130f9..78804c2d9 100644 --- a/ts/fixtures/stock/expected/maps.Counted.ts +++ b/ts/fixtures/stock/expected/maps.Counted.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * Counts its drop in the cell it borrows, so a closure that owns one shows whether it * dropped before it was called, and that it dropped at all. */ export class Counted { - _0: rt.Cell; + _0: rs.Cell; - constructor(_0: rt.Cell) { + constructor(_0: rs.Cell) { this._0 = _0; } @@ -19,7 +19,7 @@ export class Counted { } export function drop$ops_Drop(self: Counted): void { - rt.cellSet(self._0, rt.u32Add(self._0.v, 1)); + rs.cellSet(self._0, rs.u32Add(self._0.v, 1)); } //# sourceMappingURL=maps.Counted.ts.map diff --git a/ts/fixtures/stock/expected/maps.Held.ts b/ts/fixtures/stock/expected/maps.Held.ts index df2f8f759..831e48af7 100644 --- a/ts/fixtures/stock/expected/maps.Held.ts +++ b/ts/fixtures/stock/expected/maps.Held.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as LruCache from "./hashlink/lru_cache.LruCache.ts"; import type * as DefaultHashBuilder from "./hashlink.DefaultHashBuilder.ts"; @@ -9,10 +9,10 @@ import type * as DefaultHashBuilder from "./hashlink.DefaultHashBuilder.ts"; * of its own, and a value after it. */ export class Held { - cache: LruCache.LruCache; + cache: LruCache.LruCache; last: T; - constructor(cache: LruCache.LruCache, last: T) { + constructor(cache: LruCache.LruCache, last: T) { this.cache = cache; this.last = last; } diff --git a/ts/fixtures/stock/expected/maps.Hinted.ts b/ts/fixtures/stock/expected/maps.Hinted.ts index 80ff5f09e..066eb9971 100644 --- a/ts/fixtures/stock/expected/maps.Hinted.ts +++ b/ts/fixtures/stock/expected/maps.Hinted.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { MADE } from "./maps.ts"; /** An iterator of the crate's own that logs each `size_hint`. */ @@ -12,28 +12,28 @@ export class Hinted { } } -export function next$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8(self: Hinted>): [rt.u8, rt.u8] | rt.Done { +export function next$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8(self: Hinted>): [rs.u8, rs.u8] | rs.Done { return self._0.next(); } -export function next$iter_Iterator_hashbrown_hash_set_IntoIter_u8(self: Hinted>): rt.u8 | rt.Done { +export function next$iter_Iterator_hashbrown_hash_set_IntoIter_u8(self: Hinted>): rs.u8 | rs.Done { return self._0.next(); } -export function sizeHint$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8(self: Hinted>): [rt.usize, rt.usize | undefined] { - ((made: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(made); - rt.byteVecPush(_5.value, 104); - rt.refMutRelease(_5); +export function sizeHint$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8(self: Hinted>): [rs.usize, rs.usize | undefined] { + ((made: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(made); + rs.byteVecPush(_5.value, 104); + rs.refMutRelease(_5); })(MADE.get()); return self._0.sizeHint(); } -export function sizeHint$iter_Iterator_hashbrown_hash_set_IntoIter_u8(self: Hinted>): [rt.usize, rt.usize | undefined] { - ((made: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(made); - rt.byteVecPush(_5.value, 104); - rt.refMutRelease(_5); +export function sizeHint$iter_Iterator_hashbrown_hash_set_IntoIter_u8(self: Hinted>): [rs.usize, rs.usize | undefined] { + ((made: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(made); + rs.byteVecPush(_5.value, 104); + rs.refMutRelease(_5); })(MADE.get()); return self._0.sizeHint(); } diff --git a/ts/fixtures/stock/expected/maps.Logged.ts b/ts/fixtures/stock/expected/maps.Logged.ts index 96deaa764..45bcbfcd8 100644 --- a/ts/fixtures/stock/expected/maps.Logged.ts +++ b/ts/fixtures/stock/expected/maps.Logged.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as DefaultHasher from "./hashlink.DefaultHasher.ts"; /** @@ -8,10 +8,10 @@ import * as DefaultHasher from "./hashlink.DefaultHasher.ts"; * the byte alone. */ export class Logged { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -22,9 +22,9 @@ export class Logged { } export function drop$ops_Drop(self: Logged): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, self._0); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, self._0); + rs.refMutRelease(_5); } export function eq$cmp_PartialEq(self: Logged, other: Logged): boolean { @@ -32,7 +32,7 @@ export function eq$cmp_PartialEq(self: Logged, other: Logged): boolean { } export function hash$Hash_hashlink_DefaultHasher(self: Logged, h: DefaultHasher.DefaultHasher): void { - rt.hash8(self._0, new rt.OwnHasher(h, DefaultHasher.hasher$hash_Hasher)); + rs.hash8(self._0, new rs.OwnHasher(h, DefaultHasher.hasher$hash_Hasher)); } //# sourceMappingURL=maps.Logged.ts.map diff --git a/ts/fixtures/stock/expected/maps.Made.ts b/ts/fixtures/stock/expected/maps.Made.ts index d379fcca5..0de86a573 100644 --- a/ts/fixtures/stock/expected/maps.Made.ts +++ b/ts/fixtures/stock/expected/maps.Made.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { MADE } from "./maps.ts"; /** @@ -8,9 +8,9 @@ import { MADE } from "./maps.ts"; * each drop. */ export class Made { - _0: rt.u8; + _0: rs.u8; - constructor(_0: rt.u8) { + constructor(_0: rs.u8) { this._0 = _0; } @@ -20,19 +20,19 @@ export class Made { } export function default$Default(): Made { - ((made: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(made); - rt.byteVecPush(_5.value, 110); - rt.refMutRelease(_5); + ((made: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(made); + rs.byteVecPush(_5.value, 110); + rs.refMutRelease(_5); })(MADE.get()); return new Made(0); } export function drop$ops_Drop(self: Made): void { - ((made: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(made); - rt.iterExtendBytes(_5.value, rt.iterSlice(Uint8Array.of(120, self._0)), undefined, true); - rt.refMutRelease(_5); + ((made: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(made); + rs.iterExtendBytes(_5.value, rs.iterSlice(Uint8Array.of(120, self._0)), undefined, true); + rs.refMutRelease(_5); })(MADE.get()); } diff --git a/ts/fixtures/stock/expected/maps.Seeded.ts b/ts/fixtures/stock/expected/maps.Seeded.ts index 755176295..9de2f88a7 100644 --- a/ts/fixtures/stock/expected/maps.Seeded.ts +++ b/ts/fixtures/stock/expected/maps.Seeded.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A `BuildHasher` of the crate's own, numbered, which logs its clone and its drop, and * builds std's `DefaultHasher`. */ export class Seeded { - _0: rt.u8; - _1: rt.RefCell; + _0: rs.u8; + _1: rs.RefCell; - constructor(_0: rt.u8, _1: rt.RefCell) { + constructor(_0: rs.u8, _1: rs.RefCell) { this._0 = _0; this._1 = _1; } @@ -21,16 +21,16 @@ export class Seeded { } export function clone$Clone(self: Seeded): Seeded { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.byteVecPush(_5.value, 99); - rt.refMutRelease(_5); - return new Seeded(rt.u8Add(self._0, 1), self._1); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.byteVecPush(_5.value, 99); + rs.refMutRelease(_5); + return new Seeded(rs.u8Add(self._0, 1), self._1); } export function drop$ops_Drop(self: Seeded): void { - const _5: rt.RefCell = rt.refCellBorrowMut(self._1); - rt.iterExtendBytes(_5.value, rt.iterSlice(Uint8Array.of(120, self._0)), undefined, true); - rt.refMutRelease(_5); + const _5: rs.RefCell = rs.refCellBorrowMut(self._1); + rs.iterExtendBytes(_5.value, rs.iterSlice(Uint8Array.of(120, self._0)), undefined, true); + rs.refMutRelease(_5); } //# sourceMappingURL=maps.Seeded.ts.map diff --git a/ts/fixtures/stock/expected/maps.ts b/ts/fixtures/stock/expected/maps.ts index 9071e8e50..0c45a7ee2 100644 --- a/ts/fixtures/stock/expected/maps.ts +++ b/ts/fixtures/stock/expected/maps.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$tuple2_u16_u32, drop$Option_tuple2_hashlink_LinkedHashSet_maps_Logged_maps_Logged as lib_drop$Option_tuple2_hashlink_LinkedHashSet_maps_Logged_maps_Logged, drop$Option_tuple2_tuple2_u8_u8_maps_Logged as lib_drop$Option_tuple2_tuple2_u8_u8_maps_Logged, drop$hashlink_LinkedHashMap_sync_Arc_str_u32 as lib_drop$hashlink_LinkedHashMap_sync_Arc_str_u32, drop$hashlink_LinkedHashMap_u16_u32 as lib_drop$hashlink_LinkedHashMap_u16_u32, drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState as lib_drop$hashlink_LinkedHashMap_u16_u32_hash_RandomState, drop$hashlink_LinkedHashSet_maps_Logged as lib_drop$hashlink_LinkedHashSet_maps_Logged, drop$hashlink_LruCache_maps_Logged_maps_Logged as lib_drop$hashlink_LruCache_maps_Logged_maps_Logged, drop$hashlink_LruCache_u16_maps_Logged as lib_drop$hashlink_LruCache_u16_maps_Logged, drop$hashlink_linked_hash_map_Drain_u16_u32 as lib_drop$hashlink_linked_hash_map_Drain_u16_u32, drop$hashlink_linked_hash_map_IntoIter_u16_u32 as lib_drop$hashlink_linked_hash_map_IntoIter_u16_u32, drop$maps_Held_maps_Logged as lib_drop$maps_Held_maps_Logged, drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made as lib_drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made, drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded as lib_drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded } from "./lib.ts"; -import { unwrapOr$11c0we2 as option_unwrapOr$11c0we2, unwrapOr$0r2bmpr as option_unwrapOr$0r2bmpr, unwrapOr$0l7j3f6 as option_unwrapOr$0l7j3f6, mapOr$085zvfb as option_mapOr$085zvfb, mapOr$1787w44 as option_mapOr$1787w44, mapOr$0iaogpf as option_mapOr$0iaogpf, mapOr$0yixjb2 as option_mapOr$0yixjb2, mapOr$1vcgixw as option_mapOr$1vcgixw, mapOr$1noewr3 as option_mapOr$1noewr3 } from "./core/option.ts"; +import { unwrapOr$1b5hww3 as option_unwrapOr$1b5hww3, unwrapOr$1fr498u as option_unwrapOr$1fr498u, unwrapOr$05jq4mv as option_unwrapOr$05jq4mv, mapOr$00octnd as option_mapOr$00octnd, mapOr$17oc7db as option_mapOr$17oc7db, mapOr$0o00yzv as option_mapOr$0o00yzv, mapOr$066oa3q as option_mapOr$066oa3q, mapOr$0as7mjc as option_mapOr$0as7mjc, mapOr$0bhoutc as option_mapOr$0bhoutc } from "./core/option.ts"; import * as linked_hash_map_Drain from "./hashlink/linked_hash_map.Drain.ts"; import * as linked_hash_map_IntoIter from "./hashlink/linked_hash_map.IntoIter.ts"; import * as linked_hash_map_Iter from "./hashlink/linked_hash_map.Iter.ts"; @@ -22,261 +22,261 @@ import * as Made from "./maps.Made.ts"; import * as Seeded from "./maps.Seeded.ts"; /** A length, capacity, or value, as four bytes. */ -export function put(out: rt.ByteVec, n: rt.usize): void { - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u32ToBeBytes(n as rt.u32).reverse())); +export function put(out: rs.ByteVec, n: rs.usize): void { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u32ToBeBytes(n as rs.u32).reverse())); } /** * `hashbrown::HashMap` and `HashSet` by its own hasher, of keys that are JS primitives * and keys that are not, through each pair of bytes: a step and its key. */ -export function map(data: rt.ByteSlice, out: rt.ByteVec): void { - const own: rt.HashMap = rt.hashNew() as rt.HashMap; - const pairs: rt.HashMap<[rt.u8, rt.u8], rt.u32> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same]))) as rt.HashMap<[rt.u8, rt.u8], rt.u32>; - const set: rt.HashSet = rt.hashWithCapacity(rt.usizeDiv(data.length, 4), 117440512) as rt.HashSet; - const iter: rt.Iter = rt.byteSliceChunks(data, 2); +export function map(data: rs.ByteSlice, out: rs.ByteVec): void { + const own: rs.HashMap = rs.hashNew() as rs.HashMap; + const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same]))) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; + const set: rs.HashSet = rs.hashWithCapacity(rs.usizeDiv(data.length, 4), 117440512) as rs.HashSet; + const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { - const _12: rt.ByteSlice | rt.Done = iter.next(); - if (_12 === rt.DONE) { + const _12: rs.ByteSlice | rs.Done = iter.next(); + if (_12 === rs.DONE) { break; } - rt.idx(_12, 0); - const _18: [rt.u8, rt.u8] = [_12.data[_12.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_12, 1), 0)]; - const op: rt.u8 = _18[0]; - const arg: rt.u8 = _18[1]; - const key: rt.u16 = rt.u8Rem(arg, 16) as rt.u16; - const pair: [rt.u8, rt.u8] = [rt.u8Rem(arg, 4), rt.u8Rem(arg, 3)]; - const _35: rt.u8 = rt.u8Rem(op, 10); + rs.idx(_12, 0); + const _18: [rs.u8, rs.u8] = [_12.data[_12.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_12, 1), 0)]; + const op: rs.u8 = _18[0]; + const arg: rs.u8 = _18[1]; + const key: rs.u16 = rs.u8Rem(arg, 16) as rs.u16; + const pair: [rs.u8, rs.u8] = [rs.u8Rem(arg, 4), rs.u8Rem(arg, 3)]; + const _35: rs.u8 = rs.u8Rem(op, 10); if (_35 === 0 || _35 === 1) { - put(out, option_mapOr$1vcgixw(rt.hashInsert(own, key, op as rt.u32), 256, (v9: rt.u32): rt.usize => { - return v9 as rt.usize; + put(out, option_mapOr$0as7mjc(rs.hashInsert(own, key, op as rs.u32), 256, (v9: rs.u32): rs.usize => { + return v9 as rs.usize; })); - put(out, option_mapOr$1vcgixw(rt.hashInsert(pairs, pair, op as rt.u32), 256, (v10: rt.u32): rt.usize => { - return v10 as rt.usize; + put(out, option_mapOr$0as7mjc(rs.hashInsert(pairs, pair, op as rs.u32), 256, (v10: rs.u32): rs.usize => { + return v10 as rs.usize; })); } else if (_35 === 2) { - put(out, option_mapOr$1vcgixw(rt.hashRemove(own, key), 256, (v7: rt.u32): rt.usize => { - return v7 as rt.usize; + put(out, option_mapOr$0as7mjc(rs.hashRemove(own, key), 256, (v7: rs.u32): rs.usize => { + return v7 as rs.usize; })); - put(out, option_mapOr$1vcgixw(rt.hashRemove(pairs, pair), 256, (v8: rt.u32): rt.usize => { - return v8 as rt.usize; + put(out, option_mapOr$0as7mjc(rs.hashRemove(pairs, pair), 256, (v8: rs.u32): rs.usize => { + return v8 as rs.usize; })); } else if (_35 === 3) { - rt.byteVecPush(out, rt.hashContains(own, key) ? 1 : 0); - put(out, option_mapOr$1vcgixw(rt.hashGet(pairs, pair), 256, (_29: rt.u32): rt.usize => { - return _29 as rt.usize; + rs.byteVecPush(out, rs.hashContains(own, key) ? 1 : 0); + put(out, option_mapOr$0as7mjc(rs.hashGet(pairs, pair), 256, (_29: rs.u32): rs.usize => { + return _29 as rs.usize; })); } else if (_35 === 4) { - const _67: rt.Place | undefined = rt.hashGetMut(own, key); + const _67: rs.Place | undefined = rs.hashGetMut(own, key); if (_67 !== undefined) { - _67.v = rt.u32Add(_67.v, 1); + _67.v = rs.u32Add(_67.v, 1); } - const _73: rt.u32 = arg as rt.u32; - const _74: rt.Place = rt.entryOrInsertMut(rt.entry(pairs, pair), 7); - _74.v = rt.u32Add(_74.v, _73); + const _73: rs.u32 = arg as rs.u32; + const _74: rs.Place = rs.entryOrInsertMut(rs.entry(pairs, pair), 7); + _74.v = rs.u32Add(_74.v, _73); } else if (_35 === 5) { - rt.hashRetainMut(own, (k4: rt.u16, v5: rt.Place): boolean => { - return rt.u16Rem(rt.u16Add(k4, v5.v & 0xffff), 3) !== 0; + rs.hashRetainMut(own, (k4: rs.u16, v5: rs.Place): boolean => { + return rs.u16Rem(rs.u16Add(k4, v5.v & 0xffff), 3) !== 0; }); - rt.hashRetainMut(pairs, (k5: [rt.u8, rt.u8], _3: rt.Place): boolean => { - return k5[0] !== rt.u8Rem(arg, 4); + rs.hashRetainMut(pairs, (k5: [rs.u8, rs.u8], _3: rs.Place): boolean => { + return k5[0] !== rs.u8Rem(arg, 4); }); } else if (_35 === 6) { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(key, f)]; - const _88: string = rt.fmtFormat([args2[0]]); - rt.byteVecPush(out, rt.hashAdd(set, _88) ? 1 : 0); - const part = rt.u16Add(key, 1); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(part, f)]; - const _102: string = rt.fmtFormat([args4[0]]); - rt.byteVecPush(out, rt.hashContains(set, _102) ? 1 : 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; + const _88: string = rs.fmtFormat([args2[0]]); + rs.byteVecPush(out, rs.hashAdd(set, _88) ? 1 : 0); + const part = rs.u16Add(key, 1); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(part, f)]; + const _102: string = rs.fmtFormat([args4[0]]); + rs.byteVecPush(out, rs.hashContains(set, _102) ? 1 : 0); } else if (_35 === 7) { - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u16Display(key, f)]; - const _117: string = rt.fmtFormat([args6[0]]); - rt.byteVecPush(out, rt.hashDelete(set, _117) ? 1 : 0); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u16Display(key, f)]; + const _117: string = rs.fmtFormat([args6[0]]); + rs.byteVecPush(out, rs.hashDelete(set, _117) ? 1 : 0); } else if (_35 === 8) { - put(out, option_mapOr$0iaogpf(rt.hashRemoveEntry(own, key), 256, (_26: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(_26[0] as rt.usize, _26[1] as rt.usize); + put(out, option_mapOr$0o00yzv(rs.hashRemoveEntry(own, key), 256, (_26: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(_26[0] as rs.usize, _26[1] as rs.usize); })); } else { - put(out, rt.iterSum(rt.iterMap(rt.hashDrain(own), (_2: [rt.u16, rt.u32]): rt.u32 => { - return rt.u32Add(_2[0] as rt.u32, _2[1]); - }), rt.u32Add, 0) as rt.usize); + put(out, rs.iterSum(rs.iterMap(rs.hashDrain(own), (_2: [rs.u16, rs.u32]): rs.u32 => { + return rs.u32Add(_2[0] as rs.u32, _2[1]); + }), rs.u32Add, 0) as rs.usize); } - put(out, rt.hashLen(own)); - put(out, rt.hashLen(pairs)); - put(out, rt.hashLen(set)); + put(out, rs.hashLen(own)); + put(out, rs.hashLen(pairs)); + put(out, rs.hashLen(set)); } - const own2: rt.Vec<[rt.u16, rt.u32]> = rt.iterToVec(rt.hashIter(own), "next", 8); - rt.sliceSort(own2.items, rt.cmpLt(rt.cmpTuple<[rt.u16, rt.u32], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true); + const own2: rs.Vec<[rs.u16, rs.u32]> = rs.iterToVec(rs.hashIter(own), "next", 8); + rs.sliceSort(own2.items, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.u32], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 8, true); for (const _155 of own2.items) { - const k: rt.u16 = _155[0]; - const v: rt.u32 = _155[1]; - put(out, k as rt.usize); - put(out, v as rt.usize); + const k: rs.u16 = _155[0]; + const v: rs.u32 = _155[1]; + put(out, k as rs.usize); + put(out, v as rs.usize); } - const pairs2: rt.Vec<[[rt.u8, rt.u8], rt.u32]> = rt.iterToVec(rt.iterMap(rt.hashIter(pairs), (_210: [[rt.u8, rt.u8], rt.u32]): [[rt.u8, rt.u8], rt.u32] => { - return [_210[0], _210[1]] as [[rt.u8, rt.u8], rt.u32]; + const pairs2: rs.Vec<[[rs.u8, rs.u8], rs.u32]> = rs.iterToVec(rs.iterMap(rs.hashIter(pairs), (_210: [[rs.u8, rs.u8], rs.u32]): [[rs.u8, rs.u8], rs.u32] => { + return [_210[0], _210[1]] as [[rs.u8, rs.u8], rs.u32]; }), "next", 8); - rt.sliceSort(pairs2.items, rt.cmpLt(rt.cmpTuple<[[rt.u8, rt.u8], rt.u32], rt.Ordering | undefined>([rt.cmpTuple<[rt.u8, rt.u8], rt.Ordering | undefined>([rt.cmp, rt.cmp]), rt.cmp])), 8, true); + rs.sliceSort(pairs2.items, rs.cmpLt(rs.cmpTuple<[[rs.u8, rs.u8], rs.u32], rs.Ordering | undefined>([rs.cmpTuple<[rs.u8, rs.u8], rs.Ordering | undefined>([rs.cmp, rs.cmp]), rs.cmp])), 8, true); for (const _174 of pairs2.items) { - const a: rt.u8 = _174[0][0]; - const b: rt.u8 = _174[0][1]; - const v2: rt.u32 = _174[1]; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(Uint8Array.of(a, b))); - put(out, v2 as rt.usize); + const a: rs.u8 = _174[0][0]; + const b: rs.u8 = _174[0][1]; + const v2: rs.u32 = _174[1]; + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(Uint8Array.of(a, b))); + put(out, v2 as rs.usize); } - const set2: rt.Vec = rt.iterToVec(rt.hashKeys(set), "next", 12); - rt.sliceSort(set2.items, rt.cmpLt(rt.cmpStr), 12, true); - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(rt.strsJoin(set2.items, ","))); + const set2: rs.Vec = rs.iterToVec(rs.hashKeys(set), "next", 12); + rs.sliceSort(set2.items, rs.cmpLt(rs.cmpStr), 12, true); + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(rs.strsJoin(set2.items, ","))); } /** * The hash of `key` that `kind` picks: one past 2^53 that sets apart a few keys, the * same for every key, or each key's own. */ -export function hash(kind: rt.u8, key: rt.u16): rt.u64 { - const _3: rt.u8 = rt.u8Rem(kind, 3); +export function hash(kind: rs.u8, key: rs.u16): rs.u64 { + const _3: rs.u8 = rs.u8Rem(kind, 3); if (_3 === 0) { - return rt.u64WrappingMul(rt.u16Rem(key, 5) as rt.u64, { hi: 0x9e3779b9, lo: 0x7f4a7c15 } as rt.u64); + return rs.u64WrappingMul(rs.u16Rem(key, 5) as rs.u64, { hi: 0x9e3779b9, lo: 0x7f4a7c15 } as rs.u64); } if (_3 === 1) { return 7; } - return key as rt.u64; + return key as rs.u64; } /** * `hashbrown::HashTable` of `(key, value)`, found by the hash `data`'s first byte picks * and the key's equality, through each pair of bytes after it: a step and its key. */ -export function table(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function table(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { if (dataLen !== 0) { - const kind: rt.u8 = dataData[dataStart]; - let t: rt.HashTable<[rt.u16, rt.u32]> = rt.hashNew() as rt.HashTable<[rt.u16, rt.u32]>; - const rehash: (a0: [rt.u16, rt.u32]) => rt.u64 = (e8: [rt.u16, rt.u32]): rt.u64 => { + const kind: rs.u8 = dataData[dataStart]; + let t: rs.HashTable<[rs.u16, rs.u32]> = rs.hashNew() as rs.HashTable<[rs.u16, rs.u32]>; + const rehash: (a0: [rs.u16, rs.u32]) => rs.u64 = (e8: [rs.u16, rs.u32]): rs.u64 => { return hash(kind, e8[0]); }; - const n: rt.HashTable = rt.hashWithCapacity(rt.u8Rem(kind, 8) as rt.usize, 234881024) as rt.HashTable; - const iter: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2); + const n: rs.HashTable = rs.hashWithCapacity(rs.u8Rem(kind, 8) as rs.usize, 234881024) as rs.HashTable; + const iter: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2); while (true) { - const _17: rt.ByteSlice | rt.Done = iter.next(); - if (_17 === rt.DONE) { + const _17: rs.ByteSlice | rs.Done = iter.next(); + if (_17 === rs.DONE) { break; } - rt.idx(_17, 0); - const _23: [rt.u8, rt.u8] = [_17.data[_17.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_17, 1), 0)]; - const op: rt.u8 = _23[0]; - const arg: rt.u8 = _23[1]; - const key: rt.u16 = rt.u8Rem(arg, 16) as rt.u16; - const h: rt.u64 = hash(kind, key); + rs.idx(_17, 0); + const _23: [rs.u8, rs.u8] = [_17.data[_17.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_17, 1), 0)]; + const op: rs.u8 = _23[0]; + const arg: rs.u8 = _23[1]; + const key: rs.u16 = rs.u8Rem(arg, 16) as rs.u16; + const h: rs.u64 = hash(kind, key); numbers(n, kind, op, key, out); - const _38: rt.u8 = rt.u8Rem(op, 9); + const _38: rs.u8 = rs.u8Rem(op, 9); if (_38 === 0 || _38 === 1) { - const _40: rt.Result, rt.TableEntry<[rt.u16, rt.u32]>> = rt.tableFindEntry(t, h, (e20: [rt.u16, rt.u32]): boolean => { + const _40: rs.Result, rs.TableEntry<[rs.u16, rs.u32]>> = rs.tableFindEntry(t, h, (e20: [rs.u16, rs.u32]): boolean => { return e20[0] === key; }); if (_40.ok) { - const e: rt.TableEntry<[rt.u16, rt.u32]> = _40.value; - const _46: rt.u32 = op as rt.u32; - const _47: [rt.u16, rt.u32] = e.v; - _47[1] = rt.u32Add(_47[1], _46); - put(out, e.v[1] as rt.usize); + const e: rs.TableEntry<[rs.u16, rs.u32]> = _40.value; + const _46: rs.u32 = op as rs.u32; + const _47: [rs.u16, rs.u32] = e.v; + _47[1] = rs.u32Add(_47[1], _46); + put(out, e.v[1] as rs.usize); } else { - put(out, rt.tableInsertUnique(_40.error.t, h, [key, op as rt.u32] as [rt.u16, rt.u32], rehash).v[1] as rt.usize); + put(out, rs.tableInsertUnique(_40.error.t, h, [key, op as rs.u32] as [rs.u16, rs.u32], rehash).v[1] as rs.usize); } } else if (_38 === 2) { - const _65: rt.Result, rt.TableEntry<[rt.u16, rt.u32]>> = rt.tableFindEntry(t, h, (e19: [rt.u16, rt.u32]): boolean => { + const _65: rs.Result, rs.TableEntry<[rs.u16, rs.u32]>> = rs.tableFindEntry(t, h, (e19: [rs.u16, rs.u32]): boolean => { return e19[0] === key; }); if (_65.ok) { - const _74: [[rt.u16, rt.u32], rt.TableEntry<[rt.u16, rt.u32]>] = rt.tableRemove(_65.value); - const k: rt.u16 = _74[0][0]; - const v: rt.u32 = _74[0][1]; - const vacant: rt.TableEntry<[rt.u16, rt.u32]> = _74[1]; - put(out, rt.usizeAdd(k as rt.usize, v as rt.usize)); - put(out, rt.hashLen(vacant.t)); + const _74: [[rs.u16, rs.u32], rs.TableEntry<[rs.u16, rs.u32]>] = rs.tableRemove(_65.value); + const k: rs.u16 = _74[0][0]; + const v: rs.u32 = _74[0][1]; + const vacant: rs.TableEntry<[rs.u16, rs.u32]> = _74[1]; + put(out, rs.usizeAdd(k as rs.usize, v as rs.usize)); + put(out, rs.hashLen(vacant.t)); } else { put(out, 256); } } else if (_38 === 3) { - put(out, option_mapOr$0iaogpf(rt.tableFind(t, h, (e17: [rt.u16, rt.u32]): boolean => { + put(out, option_mapOr$0o00yzv(rs.tableFind(t, h, (e17: [rs.u16, rs.u32]): boolean => { return e17[0] === key; - }), 256, (e18: [rt.u16, rt.u32]): rt.usize => { - return e18[1] as rt.usize; + }), 256, (e18: [rs.u16, rs.u32]): rs.usize => { + return e18[1] as rs.usize; })); } else if (_38 === 4) { - const _89: [rt.u16, rt.u32] | undefined = rt.tableFind(t, h, (e16: [rt.u16, rt.u32]): boolean => { + const _89: [rs.u16, rs.u32] | undefined = rs.tableFind(t, h, (e16: [rs.u16, rs.u32]): boolean => { return e16[0] === key; }); if (_89 !== undefined) { - _89[1] = rt.u32Mul(_89[1], 2); + _89[1] = rs.u32Mul(_89[1], 2); } } else if (_38 === 5) { - const _96: rt.TableEntry<[rt.u16, rt.u32]> = rt.tableEntry(t, h, (e15: [rt.u16, rt.u32]): boolean => { + const _96: rs.TableEntry<[rs.u16, rs.u32]> = rs.tableEntry(t, h, (e15: [rs.u16, rs.u32]): boolean => { return e15[0] === key; }, rehash); - if (rt.tableOccupied(_96)) { - put(out, _96.v[1] as rt.usize); + if (rs.tableOccupied(_96)) { + put(out, _96.v[1] as rs.usize); } else { - put(out, rt.tableEntryInsert(_96, [key, 1] as [rt.u16, rt.u32]).v[1] as rt.usize); + put(out, rs.tableEntryInsert(_96, [key, 1] as [rs.u16, rs.u32]).v[1] as rs.usize); } } else if (_38 === 6) { if (!((arg & 16) === 0)) { - const drops: rt.Cell = new rt.Cell(0); + const drops: rs.Cell = new rs.Cell(0); const captured = new maps_Counted.Counted(drops); const captured2 = key; - const made: () => [rt.u16, rt.u32] = rt.closure((): [rt.u16, rt.u32] => { - return [captured2, rt.u32Add(3, captured._0.v)] as [rt.u16, rt.u32]; + const made: () => [rs.u16, rs.u32] = rs.closure((): [rs.u16, rs.u32] => { + return [captured2, rs.u32Add(3, captured._0.v)] as [rs.u16, rs.u32]; }, (): void => { captured[Symbol.dispose](); }); - put(out, rt.tableOrInsertWith(rt.tableEntry(t, h, (e14: [rt.u16, rt.u32]): boolean => { + put(out, rs.tableOrInsertWith(rs.tableEntry(t, h, (e14: [rs.u16, rs.u32]): boolean => { return e14[0] === key; - }, rehash), rt.once(made), rt.drop).v[1] as rt.usize); - put(out, drops.v as rt.usize); + }, rehash), rs.once(made), rs.drop).v[1] as rs.usize); + put(out, drops.v as rs.usize); } else { - put(out, rt.tableOrInsert(rt.tableEntry(t, h, (e13: [rt.u16, rt.u32]): boolean => { + put(out, rs.tableOrInsert(rs.tableEntry(t, h, (e13: [rs.u16, rs.u32]): boolean => { return e13[0] === key; - }, rehash), [key, 3] as [rt.u16, rt.u32]).v[1] as rt.usize); + }, rehash), [key, 3] as [rs.u16, rs.u32]).v[1] as rs.usize); } } else if (_38 === 7) { - rt.tableRetain(t, (e12: [rt.u16, rt.u32]): boolean => { - e12[1] = rt.u32Add(e12[1], 1); - return rt.u16Rem(e12[0], 3) !== rt.u8Rem(arg, 3) as rt.u16; + rs.tableRetain(t, (e12: [rs.u16, rs.u32]): boolean => { + e12[1] = rs.u32Add(e12[1], 1); + return rs.u16Rem(e12[0], 3) !== rs.u8Rem(arg, 3) as rs.u16; }); } else { - put(out, rt.iterSum(rt.iterMap(rt.hashValues(t), (e9: [rt.u16, rt.u32]): rt.u32 => { - return rt.u32Add(e9[0] as rt.u32, e9[1]); - }), rt.u32Add, 0) as rt.usize); - const copy: rt.HashTable<[rt.u16, rt.u32]> = rt.hashClone(t, undefined, copy$tuple2_u16_u32); - const drained: rt.Vec<[rt.u16, rt.u32]> = rt.iterToVec(rt.tableDrain(t), "next", 8); - rt.sliceSort(drained.items, rt.cmpLt(rt.cmpTuple<[rt.u16, rt.u32], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true); + put(out, rs.iterSum(rs.iterMap(rs.hashValues(t), (e9: [rs.u16, rs.u32]): rs.u32 => { + return rs.u32Add(e9[0] as rs.u32, e9[1]); + }), rs.u32Add, 0) as rs.usize); + const copy: rs.HashTable<[rs.u16, rs.u32]> = rs.hashClone(t, undefined, copy$tuple2_u16_u32); + const drained: rs.Vec<[rs.u16, rs.u32]> = rs.iterToVec(rs.tableDrain(t), "next", 8); + rs.sliceSort(drained.items, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.u32], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 8, true); for (const _162 of drained.items) { - const k2: rt.u16 = _162[0]; - const v2: rt.u32 = _162[1]; - put(out, k2 as rt.usize); - put(out, v2 as rt.usize); + const k2: rs.u16 = _162[0]; + const v2: rs.u32 = _162[1]; + put(out, k2 as rs.usize); + put(out, v2 as rs.usize); } - put(out, option_mapOr$0iaogpf(rt.tableFind(copy, h, (e10: [rt.u16, rt.u32]): boolean => { + put(out, option_mapOr$0o00yzv(rs.tableFind(copy, h, (e10: [rs.u16, rs.u32]): boolean => { return e10[0] === key; - }), 256, (e11: [rt.u16, rt.u32]): rt.usize => { - return e11[1] as rt.usize; + }), 256, (e11: [rs.u16, rs.u32]): rs.usize => { + return e11[1] as rs.usize; })); - put(out, rt.hashLen(copy)); + put(out, rs.hashLen(copy)); if ((arg & 1) === 1) { t = copy; } } - put(out, rt.hashLen(t)); - rt.byteVecPush(out, rt.hashLen(t) === 0 ? 1 : 0); + put(out, rs.hashLen(t)); + rs.byteVecPush(out, rs.hashLen(t) === 0 ? 1 : 0); } - const left: rt.Vec<[rt.u16, rt.u32]> = rt.iterToVec(rt.hashValues(t), "next", 8); - rt.sliceSort(left.items, rt.cmpLt(rt.cmpTuple<[rt.u16, rt.u32], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true); + const left: rs.Vec<[rs.u16, rs.u32]> = rs.iterToVec(rs.hashValues(t), "next", 8); + rs.sliceSort(left.items, rs.cmpLt(rs.cmpTuple<[rs.u16, rs.u32], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 8, true); for (const _199 of left.items) { - const k3: rt.u16 = _199[0]; - const v3: rt.u32 = _199[1]; - put(out, k3 as rt.usize); - put(out, v3 as rt.usize); + const k3: rs.u16 = _199[0]; + const v3: rs.u32 = _199[1]; + put(out, k3 as rs.usize); + put(out, v3 as rs.usize); } } } @@ -285,80 +285,80 @@ export function table(dataData: Uint8Array, dataStart: number, dataLen: number, * `HashTable`, whose items JS copies, so a `&mut` to one is its place: each item's * key in its high half and a count in its low half, changed by step `op` of `key`. */ -export function numbers(n: rt.HashTable, kind: rt.u8, op: rt.u8, key: rt.u16, out: rt.ByteVec): void { - const h: rt.u64 = hash(kind, key); - const ours: (a0: rt.u32) => boolean = (e5: rt.u32): boolean => { - return (e5 >>> 16) === key as rt.u32; +export function numbers(n: rs.HashTable, kind: rs.u8, op: rs.u8, key: rs.u16, out: rs.ByteVec): void { + const h: rs.u64 = hash(kind, key); + const ours: (a0: rs.u32) => boolean = (e5: rs.u32): boolean => { + return (e5 >>> 16) === key as rs.u32; }; - const rehash: (a0: rt.u32) => rt.u64 = (e6: rt.u32): rt.u64 => { + const rehash: (a0: rs.u32) => rs.u64 = (e6: rs.u32): rs.u64 => { return hash(kind, (e6 >>> 16) & 0xffff); }; b0: { - const _12: rt.u8 = rt.u8Rem(op, 6); + const _12: rs.u8 = rs.u8Rem(op, 6); if (_12 === 0) { - const drops: rt.Cell = new rt.Cell(0); + const drops: rs.Cell = new rs.Cell(0); const held: maps_Counted.Counted = new maps_Counted.Counted(drops); - const _18: rt.TableEntry = rt.tableEntry(n, h, ours, rehash); + const _18: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); const captured = held; - const e: rt.TableEntry = rt.tableAndModifyMut(_18, rt.closure((e8: rt.Place): undefined => { - e8.v = rt.u32Add(e8.v, rt.u32Add(1, captured._0.v)); + const e: rs.TableEntry = rs.tableAndModifyMut(_18, rs.closure((e8: rs.Place): undefined => { + e8.v = rs.u32Add(e8.v, rs.u32Add(1, captured._0.v)); captured[Symbol.dispose](); }, (): void => { captured[Symbol.dispose](); - }), rt.drop); - put(out, drops.v as rt.usize); - put(out, rt.tableOrInsert(e, ((key as rt.u32) << 16) >>> 0).v as rt.usize); + }), rs.drop); + put(out, drops.v as rs.usize); + put(out, rs.tableOrInsert(e, ((key as rs.u32) << 16) >>> 0).v as rs.usize); } else if (_12 === 1) { - const _34: rt.Place | undefined = rt.tableFindMut(n, h, ours); + const _34: rs.Place | undefined = rs.tableFindMut(n, h, ours); if (_34 === undefined) { - put(out, rt.tableInsertUnique(n, h, ((key as rt.u32) << 16) >>> 0, rehash).v as rt.usize); + put(out, rs.tableInsertUnique(n, h, ((key as rs.u32) << 16) >>> 0, rehash).v as rs.usize); } else { - _34.v = rt.u32Add(_34.v, 2); + _34.v = rs.u32Add(_34.v, 2); } } else if (_12 === 2) { - const _46: rt.Result, rt.TableEntry> = rt.tableFindEntry(n, h, ours); + const _46: rs.Result, rs.TableEntry> = rs.tableFindEntry(n, h, ours); if (_46.ok) { - const e2: rt.TableEntry = _46.value; - const _49: rt.Place = e2; - _49.v = rt.u32Add(_49.v, 3); - const e3: rt.Place = e2; - e3.v = rt.u32Add(e3.v, 4); + const e2: rs.TableEntry = _46.value; + const _49: rs.Place = e2; + _49.v = rs.u32Add(_49.v, 3); + const e3: rs.Place = e2; + e3.v = rs.u32Add(e3.v, 4); } } else if (_12 === 3) { - rt.tableRetainMut(n, (e7: rt.Place): boolean => { - e7.v = rt.u32Add(e7.v, 5); + rs.tableRetainMut(n, (e7: rs.Place): boolean => { + e7.v = rs.u32Add(e7.v, 5); return ((e7.v & 255) >>> 0) < 200; }); } else { if (_12 === 4) { - const iter: rt.Iter> = rt.hashValuesMut(n); + const iter: rs.Iter> = rs.hashValuesMut(n); while (true) { - const _58: rt.Place | rt.Done = iter.next(); - if (_58 === rt.DONE) { + const _58: rs.Place | rs.Done = iter.next(); + if (_58 === rs.DONE) { break; } _58.v = (_58.v ^ 1) >>> 0; } - const iter2: rt.Iter> = rt.hashValuesMut(n); + const iter2: rs.Iter> = rs.hashValuesMut(n); while (true) { - const _64: rt.Place | rt.Done = iter2.next(); - if (_64 === rt.DONE) { + const _64: rs.Place | rs.Done = iter2.next(); + if (_64 === rs.DONE) { break b0; } - _64.v = rt.u32Add(_64.v, 1); + _64.v = rs.u32Add(_64.v, 1); } } - const _69: rt.TableEntry = rt.tableEntry(n, h, ours, rehash); - if (rt.tableOccupied(_69)) { - const _72: rt.Place = _69; - _72.v = rt.u32Add(_72.v, 6); + const _69: rs.TableEntry = rs.tableEntry(n, h, ours, rehash); + if (rs.tableOccupied(_69)) { + const _72: rs.Place = _69; + _72.v = rs.u32Add(_72.v, 6); } } } - const items: rt.Vec = rt.iterToVec(rt.hashValues(n), "next", 4); - rt.sliceSort(items.items, rt.lt, 4, true); + const items: rs.Vec = rs.iterToVec(rs.hashValues(n), "next", 4); + rs.sliceSort(items.items, rs.lt, 4, true); for (const _85 of items.items) { - put(out, _85 as rt.usize); + put(out, _85 as rs.usize); } } @@ -366,9 +366,9 @@ export function numbers(n: rt.HashTable, kind: rt.u8, op: rt.u8, key: rt * What std's guarantees fix of a hash collection's capacity, `cap`, holding `len`: at * least `len` and `floor`, the most an operation just asked for. */ -export function holds(out: rt.ByteVec, len: rt.usize, cap: rt.usize, floor: rt.usize): void { +export function holds(out: rs.ByteVec, len: rs.usize, cap: rs.usize, floor: rs.usize): void { put(out, len); - rt.byteVecPush(out, cap >= rt.max(len, floor) ? 1 : 0); + rs.byteVecPush(out, cap >= rs.max(len, floor) ? 1 : 0); } /** @@ -378,230 +378,230 @@ export function holds(out: rt.ByteVec, len: rt.usize, cap: rt.usize, floor: rt.u * than it asked for of what there was, doubled as inserts grow it, none until one * allocates, and an allocation while it holds any. */ -export function capacity(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _14!: [rt.HashMap, rt.HashSet, rt.HashTable]; - let floor!: rt.usize; +export function capacity(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _14!: [rs.HashMap, rs.HashSet, rs.HashTable]; + let floor!: rs.usize; let _53!: boolean; let _164!: boolean; - let _206!: rt.usize; - let floor2!: rt.usize; + let _206!: rs.usize; + let floor2!: rs.usize; let grew!: boolean; let _242!: boolean; let _259!: boolean; if (dataLen !== 0) { - const first: rt.u8 = dataData[dataStart]; - const made: rt.usize = first >> 2 as rt.usize; + const first: rs.u8 = dataData[dataStart]; + const made: rs.usize = first >> 2 as rs.usize; if ((first & 3) === 0) { - _14 = [rt.hashNew() as rt.HashMap, rt.hashNew() as rt.HashSet, rt.hashNew() as rt.HashTable] as [rt.HashMap, rt.HashSet, rt.HashTable]; + _14 = [rs.hashNew() as rs.HashMap, rs.hashNew() as rs.HashSet, rs.hashNew() as rs.HashTable] as [rs.HashMap, rs.HashSet, rs.HashTable]; } else { - rt.randomState(); - _14 = [rt.hashWithCapacity(made, 58720256) as rt.HashMap, rt.hashWithCapacity(made, 469762048) as rt.HashSet, rt.hashWithCapacity(made, 234881024) as rt.HashTable] as [rt.HashMap, rt.HashSet, rt.HashTable]; + rs.randomState(); + _14 = [rs.hashWithCapacity(made, 58720256) as rs.HashMap, rs.hashWithCapacity(made, 469762048) as rs.HashSet, rs.hashWithCapacity(made, 234881024) as rs.HashTable] as [rs.HashMap, rs.HashSet, rs.HashTable]; } - const m: rt.HashMap = _14[0]; - const s: rt.HashSet = _14[1]; - const t: rt.HashTable = _14[2]; + const m: rs.HashMap = _14[0]; + const s: rs.HashSet = _14[1]; + const t: rs.HashTable = _14[2]; if (!((first & 3) === 0)) { floor = made; } else { floor = 0; } - const iter: rt.Iter<[rt.usize, rt.usize]> = rt.iterSlice([[rt.hashCapacity(m), rt.hashLen(m)] as [rt.usize, rt.usize], [rt.hashCapacity(s), rt.hashLen(s)] as [rt.usize, rt.usize], [rt.hashCapacity(t), rt.hashLen(t)] as [rt.usize, rt.usize]]); + const iter: rs.Iter<[rs.usize, rs.usize]> = rs.iterSlice([[rs.hashCapacity(m), rs.hashLen(m)] as [rs.usize, rs.usize], [rs.hashCapacity(s), rs.hashLen(s)] as [rs.usize, rs.usize], [rs.hashCapacity(t), rs.hashLen(t)] as [rs.usize, rs.usize]]); while (true) { - const _44: [rt.usize, rt.usize] | rt.Done = iter.next(); - if (_44 === rt.DONE) { + const _44: [rs.usize, rs.usize] | rs.Done = iter.next(); + if (_44 === rs.DONE) { break; } - const cap: rt.usize = _44[0]; + const cap: rs.usize = _44[0]; holds(out, _44[1], cap, floor); if (!(cap === 0)) { _53 = (first & 3) !== 0; } else { _53 = true; } - rt.byteVecPush(out, _53 ? 1 : 0); + rs.byteVecPush(out, _53 ? 1 : 0); } - const hasher: rt.RandomState = rt.randomState(); - const rehash: (a0: rt.u32) => rt.u64 = (v3: rt.u32): rt.u64 => { - return rt.hashOne(rt.buildHasher(hasher), v3, rt.hash32); + const hasher: rs.RandomState = rs.randomState(); + const rehash: (a0: rs.u32) => rs.u64 = (v3: rs.u32): rs.u64 => { + return rs.hashOne(rs.buildHasher(hasher), v3, rs.hash32); }; let kept: boolean[] = Array.from({ length: 3 }, (): boolean => { return true; }); - const iter2: rt.Iter = rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2); + const iter2: rs.Iter = rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2); l7: while (true) { - const _63: rt.ByteSlice | rt.Done = iter2.next(); - if (_63 === rt.DONE) { + const _63: rs.ByteSlice | rs.Done = iter2.next(); + if (_63 === rs.DONE) { break; } - rt.idx(_63, 0); - const _69: [rt.u8, rt.u8] = [_63.data[_63.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_63, 1), 0)]; - const op: rt.u8 = _69[0]; - const arg: rt.u8 = _69[1]; - const before: rt.usize[] = [rt.hashCapacity(m), rt.hashCapacity(s), rt.hashCapacity(t)]; - let additional: rt.usize | undefined = undefined; - let keptMin: rt.usize | undefined = undefined; + rs.idx(_63, 0); + const _69: [rs.u8, rs.u8] = [_63.data[_63.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_63, 1), 0)]; + const op: rs.u8 = _69[0]; + const arg: rs.u8 = _69[1]; + const before: rs.usize[] = [rs.hashCapacity(m), rs.hashCapacity(s), rs.hashCapacity(t)]; + let additional: rs.usize | undefined = undefined; + let keptMin: rs.usize | undefined = undefined; b8: { - const _89: rt.u8 = rt.u8Rem(op, 7); + const _89: rs.u8 = rs.u8Rem(op, 7); if (0 <= _89) { if (_89 <= 2) { - rt.hashInsert(m, arg as rt.u16, op as rt.u64); - rt.hashAdd(s, arg); - const v: rt.u32 = arg as rt.u32; - const _104: rt.u64 = rt.hashOne(rt.buildHasher(hasher), v, rt.hash32); - if (!(rt.tableFind(t, _104, (_2: rt.u32): boolean => { + rs.hashInsert(m, arg as rs.u16, op as rs.u64); + rs.hashAdd(s, arg); + const v: rs.u32 = arg as rs.u32; + const _104: rs.u64 = rs.hashOne(rs.buildHasher(hasher), v, rs.hash32); + if (!(rs.tableFind(t, _104, (_2: rs.u32): boolean => { return _2 === v; }) === undefined)) { break b8; } - const _110: rt.u64 = rt.hashOne(rt.buildHasher(hasher), v, rt.hash32); - rt.tableInsertUnique(t, _110, v, rehash); + const _110: rs.u64 = rs.hashOne(rs.buildHasher(hasher), v, rs.hash32); + rs.tableInsertUnique(t, _110, v, rehash); break b8; } } if (_89 === 3) { - rt.hashRemove(m, arg as rt.u16); - rt.hashDelete(s, arg); - const v2: rt.u32 = arg as rt.u32; - const _122: rt.u64 = rt.hashOne(rt.buildHasher(hasher), v2, rt.hash32); - const _120: rt.Result, rt.TableEntry> = rt.tableFindEntry(t, _122, (_23: rt.u32): boolean => { + rs.hashRemove(m, arg as rs.u16); + rs.hashDelete(s, arg); + const v2: rs.u32 = arg as rs.u32; + const _122: rs.u64 = rs.hashOne(rs.buildHasher(hasher), v2, rs.hash32); + const _120: rs.Result, rs.TableEntry> = rs.tableFindEntry(t, _122, (_23: rs.u32): boolean => { return _23 === v2; }); if (_120.ok) { - rt.tableRemove(_120.value); + rs.tableRemove(_120.value); } kept = Array.from({ length: 3 }, (): boolean => { return false; }); } else if (_89 === 4) { - const n: rt.usize = rt.u8Rem(arg, 40) as rt.usize; - rt.hashReserve(m, n, 58720256); - rt.hashReserve(s, n, 469762048); - rt.hashReserve(t, n, 234881024, rehash); + const n: rs.usize = rs.u8Rem(arg, 40) as rs.usize; + rs.hashReserve(m, n, 58720256); + rs.hashReserve(s, n, 469762048); + rs.hashReserve(t, n, 234881024, rehash); additional = n; } else if (_89 === 5) { - const min: rt.usize = rt.u8Rem(arg, 20) as rt.usize; + const min: rs.usize = rs.u8Rem(arg, 20) as rs.usize; if ((arg & 128) === 0) { - rt.hashShrinkTo(m, min); - rt.hashShrinkTo(s, min); - rt.hashShrinkTo(t, min, rehash); + rs.hashShrinkTo(m, min); + rs.hashShrinkTo(s, min); + rs.hashShrinkTo(t, min, rehash); keptMin = min; } else { - rt.hashShrinkTo(m, 0); - rt.hashShrinkTo(s, 0); - rt.hashShrinkTo(t, 0, rehash); + rs.hashShrinkTo(m, 0); + rs.hashShrinkTo(s, 0); + rs.hashShrinkTo(t, 0, rehash); } kept = Array.from({ length: 3 }, (): boolean => { return true; }); } else { - rt.hashClear(m); - rt.hashClear(s); - rt.hashClear(t, undefined); + rs.hashClear(m); + rs.hashClear(s); + rs.hashClear(t, undefined); b10: { - if (rt.hashCapacity(m) >= before[0]) { - if (rt.hashCapacity(s) >= before[1]) { - _164 = rt.hashCapacity(t) >= before[2]; + if (rs.hashCapacity(m) >= before[0]) { + if (rs.hashCapacity(s) >= before[1]) { + _164 = rs.hashCapacity(t) >= before[2]; break b10; } } _164 = false; } - rt.byteVecPush(out, _164 ? 1 : 0); + rs.byteVecPush(out, _164 ? 1 : 0); } } - const lens: rt.usize[] = [rt.hashLen(m), rt.hashLen(s), rt.hashLen(t)]; - const caps: rt.usize[] = [rt.hashCapacity(m), rt.hashCapacity(s), rt.hashCapacity(t)]; - const sizes: rt.usize[] = [rt.hashAllocationSize(m, 16), rt.hashAllocationSize(s, 1), rt.hashAllocationSize(t, 4)]; - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 3; + const lens: rs.usize[] = [rs.hashLen(m), rs.hashLen(s), rs.hashLen(t)]; + const caps: rs.usize[] = [rs.hashCapacity(m), rs.hashCapacity(s), rs.hashCapacity(t)]; + const sizes: rs.usize[] = [rs.hashAllocationSize(m, 16), rs.hashAllocationSize(s, 1), rs.hashAllocationSize(t, 4)]; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 3; while (true) { if (!((_206 = iterStart++) < iterEnd)) { continue l7; } - const i: rt.usize = _206; - const _211: [rt.usize | undefined, rt.usize | undefined] = [additional, keptMin]; + const i: rs.usize = _206; + const _211: [rs.usize | undefined, rs.usize | undefined] = [additional, keptMin]; if (_211[0] !== undefined) { - const n2: rt.usize = _211[0]; + const n2: rs.usize = _211[0]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - floor2 = rt.usizeAdd(lens[i], n2); + floor2 = rs.usizeAdd(lens[i], n2); } else if (_211[1] !== undefined) { - const min2: rt.usize = _211[1]; + const min2: rs.usize = _211[1]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - const _221: rt.usize = before[i]; + const _221: rs.usize = before[i]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - floor2 = rt.min(_221, rt.max(lens[i], min2)); + floor2 = rs.min(_221, rs.max(lens[i], min2)); } else { floor2 = 0; } if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - const _227: rt.usize = lens[i]; + const _227: rs.usize = lens[i]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } holds(out, _227, caps[i], floor2); - if (!(rt.u8Rem(op, 7) <= 2)) { + if (!(rs.u8Rem(op, 7) <= 2)) { grew = false; } else { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - const _236: rt.usize = caps[i]; + const _236: rs.usize = caps[i]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } grew = _236 > before[i]; } b17: { if (grew) { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } if (kept[i]) { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } if (!(before[i] === 0)) { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - const _249: rt.usize = caps[i]; + const _249: rs.usize = caps[i]; if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } - _242 = _249 >= rt.usizeMul(2, before[i]); + _242 = _249 >= rs.usizeMul(2, before[i]); break b17; } } } _242 = true; } - rt.byteVecPush(out, _242 ? 1 : 0); + rs.byteVecPush(out, _242 ? 1 : 0); if (grew) { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } kept[i] = true; } if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } if (!(lens[i] === 0)) { if (!(i < 3)) { - rt.panic("index out of bounds: the len is " + 3 + " but the index is " + i); + rs.panic("index out of bounds: the len is " + 3 + " but the index is " + i); } _259 = sizes[i] > 0; } else { _259 = true; } - rt.byteVecPush(out, _259 ? 1 : 0); + rs.byteVecPush(out, _259 ? 1 : 0); } } } @@ -612,96 +612,96 @@ export function capacity(dataData: Uint8Array, dataStart: number, dataLen: numbe * hashbrown's, whose order is its own: each step of `data` and then every entry, from the * front. Beside it, one keyed by `Arc` and found by `&str`, as moq's are. */ -export function linked(data: rt.ByteSlice, out: rt.ByteVec): void { - const m: LinkedHashMap.LinkedHashMap = LinkedHashMap.new$u16_u32_hashlink_DefaultHashBuilder(); - const named: LinkedHashMap.LinkedHashMap, rt.u32, DefaultHashBuilder.DefaultHashBuilder> = LinkedHashMap.new$sync_Arc_str_u32_hashlink_DefaultHashBuilder(); - const iter: rt.Iter = rt.byteSliceChunks(data, 2); +export function linked(data: rs.ByteSlice, out: rs.ByteVec): void { + const m: LinkedHashMap.LinkedHashMap = LinkedHashMap.new$u16_u32_hashlink_DefaultHashBuilder(); + const named: LinkedHashMap.LinkedHashMap, rs.u32, DefaultHashBuilder.DefaultHashBuilder> = LinkedHashMap.new$sync_Arc_str_u32_hashlink_DefaultHashBuilder(); + const iter: rs.Iter = rs.byteSliceChunks(data, 2); while (true) { - const _8: rt.ByteSlice | rt.Done = iter.next(); - if (_8 === rt.DONE) { + const _8: rs.ByteSlice | rs.Done = iter.next(); + if (_8 === rs.DONE) { break; } - rt.idx(_8, 0); - const _14: [rt.u8, rt.u8] = [_8.data[_8.start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_8, 1), 0)]; - const op: rt.u8 = _14[0]; - const arg: rt.u8 = _14[1]; - const key: rt.u16 = rt.u8Rem(arg, 12) as rt.u16; - const _27: rt.usize = key as rt.usize; + rs.idx(_8, 0); + const _14: [rs.u8, rs.u8] = [_8.data[_8.start], option_unwrapOr$1fr498u(rs.byteSliceGet(_8, 1), 0)]; + const op: rs.u8 = _14[0]; + const arg: rs.u8 = _14[1]; + const key: rs.u16 = rs.u8Rem(arg, 12) as rs.u16; + const _27: rs.usize = key as rs.usize; if (!(_27 < 12)) { - rt.panic("index out of bounds: the len is " + 12 + " but the index is " + _27); + rs.panic("index out of bounds: the len is " + 12 + " but the index is " + _27); } const _26: string[] = ["", "a", "b", "ab", "é", "✓", "😀", "a\u0000", "ÿ", "track", "group", "frame"]; - const _30: rt.u8 = rt.u8Rem(op, 8); + const _30: rs.u8 = rs.u8Rem(op, 8); if (_30 === 0 || _30 === 1) { - put(out, option_mapOr$1vcgixw(LinkedHashMap.insert$u16_u32_hashlink_DefaultHashBuilder(m, key, op as rt.u32), 256, (v11: rt.u32): rt.usize => { - return v11 as rt.usize; + put(out, option_mapOr$0as7mjc(LinkedHashMap.insert$u16_u32_hashlink_DefaultHashBuilder(m, key, op as rs.u32), 256, (v11: rs.u32): rs.usize => { + return v11 as rs.usize; })); - const _41: rt.Arc = new rt.Arc(_26[_27]); - put(out, option_mapOr$1vcgixw(LinkedHashMap.insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(named, _41, op as rt.u32), 256, (v12: rt.u32): rt.usize => { - return v12 as rt.usize; + const _41: rs.Arc = new rs.Arc(_26[_27]); + put(out, option_mapOr$0as7mjc(LinkedHashMap.insert$sync_Arc_str_u32_hashlink_DefaultHashBuilder(named, _41, op as rs.u32), 256, (v12: rs.u32): rs.usize => { + return v12 as rs.usize; })); } else if (_30 === 2) { - put(out, option_mapOr$1vcgixw(LinkedHashMap.remove$u16_u32_hashlink_DefaultHashBuilder_u16(m, key), 256, (v9: rt.u32): rt.usize => { - return v9 as rt.usize; + put(out, option_mapOr$0as7mjc(LinkedHashMap.remove$u16_u32_hashlink_DefaultHashBuilder_u16(m, key), 256, (v9: rs.u32): rs.usize => { + return v9 as rs.usize; })); - put(out, option_mapOr$1vcgixw(LinkedHashMap.remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(named, _26[_27]), 256, (v10: rt.u32): rt.usize => { - return v10 as rt.usize; + put(out, option_mapOr$0as7mjc(LinkedHashMap.remove$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(named, _26[_27]), 256, (v10: rs.u32): rs.usize => { + return v10 as rs.usize; })); } else if (_30 === 3) { - put(out, option_mapOr$1787w44(LinkedHashMap.toBack$u16_u32_hashlink_DefaultHashBuilder_u16(m, key), 256, (v7: rt.Place): rt.usize => { - return v7.v as rt.usize; + put(out, option_mapOr$17oc7db(LinkedHashMap.toBack$u16_u32_hashlink_DefaultHashBuilder_u16(m, key), 256, (v7: rs.Place): rs.usize => { + return v7.v as rs.usize; })); - put(out, option_mapOr$1787w44(LinkedHashMap.toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(named, _26[_27]), 256, (v8: rt.Place): rt.usize => { - return v8.v as rt.usize; + put(out, option_mapOr$17oc7db(LinkedHashMap.toBack$sync_Arc_str_u32_hashlink_DefaultHashBuilder_str(named, _26[_27]), 256, (v8: rs.Place): rs.usize => { + return v8.v as rs.usize; })); } else if (_30 === 4) { if ((arg & 1) === 0) { - put(out, option_mapOr$0iaogpf(LinkedHashMap.popFront$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_29: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_29[0] as rt.usize, 4096), _29[1] as rt.usize); + put(out, option_mapOr$0o00yzv(LinkedHashMap.popFront$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_29: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_29[0] as rs.usize, 4096), _29[1] as rs.usize); })); } else { - put(out, option_mapOr$0iaogpf(LinkedHashMap.popBack$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_25: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_25[0] as rt.usize, 4096), _25[1] as rt.usize); + put(out, option_mapOr$0o00yzv(LinkedHashMap.popBack$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_25: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_25[0] as rs.usize, 4096), _25[1] as rs.usize); })); } } else if (_30 === 5) { - put(out, option_mapOr$0iaogpf(LinkedHashMap.front$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_2: [rt.u16, rt.u32]): rt.usize => { - return _2[0] as rt.usize; + put(out, option_mapOr$0o00yzv(LinkedHashMap.front$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_2: [rs.u16, rs.u32]): rs.usize => { + return _2[0] as rs.usize; })); - put(out, option_mapOr$0iaogpf(LinkedHashMap.back$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_22: [rt.u16, rt.u32]): rt.usize => { - return _22[0] as rt.usize; + put(out, option_mapOr$0o00yzv(LinkedHashMap.back$u16_u32_hashlink_DefaultHashBuilder(m), 256, (_22: [rs.u16, rs.u32]): rs.usize => { + return _22[0] as rs.usize; })); } else if (_30 === 6) { - put(out, option_mapOr$1vcgixw(LinkedHashMap.insertFront$u16_u32_hashlink_DefaultHashBuilder(m, key, op as rt.u32), 256, (v4: rt.u32): rt.usize => { - return v4 as rt.usize; + put(out, option_mapOr$0as7mjc(LinkedHashMap.insertFront$u16_u32_hashlink_DefaultHashBuilder(m, key, op as rs.u32), 256, (v4: rs.u32): rs.usize => { + return v4 as rs.usize; })); } else { - LinkedHashMap.retain$u16_u32_hashlink_DefaultHashBuilder_maps_linked_closure11(m, (k3: rt.u16, v3: rt.Place): boolean => { - v3.v = rt.u32Add(v3.v, 1); - return rt.u16Rem(k3, 3) !== rt.u8Rem(arg, 3) as rt.u16; + LinkedHashMap.retain$u16_u32_hashlink_DefaultHashBuilder_maps_linked_closure11(m, (k3: rs.u16, v3: rs.Place): boolean => { + v3.v = rs.u32Add(v3.v, 1); + return rs.u16Rem(k3, 3) !== rs.u8Rem(arg, 3) as rs.u16; }); } put(out, LinkedHashMap.len$u16_u32_hashlink_DefaultHashBuilder(m)); - rt.byteVecPush(out, LinkedHashMap.capacity$u16_u32_hashlink_DefaultHashBuilder(m) >= LinkedHashMap.len$u16_u32_hashlink_DefaultHashBuilder(m) ? 1 : 0); + rs.byteVecPush(out, LinkedHashMap.capacity$u16_u32_hashlink_DefaultHashBuilder(m) >= LinkedHashMap.len$u16_u32_hashlink_DefaultHashBuilder(m) ? 1 : 0); } while (true) { - const _93: [rt.u16, rt.u32] | undefined = LinkedHashMap.popFront$u16_u32_hashlink_DefaultHashBuilder(m); + const _93: [rs.u16, rs.u32] | undefined = LinkedHashMap.popFront$u16_u32_hashlink_DefaultHashBuilder(m); if (_93 !== undefined) { - const k: rt.u16 = _93[0]; - const v: rt.u32 = _93[1]; - put(out, k as rt.usize); - put(out, v as rt.usize); + const k: rs.u16 = _93[0]; + const v: rs.u32 = _93[1]; + put(out, k as rs.usize); + put(out, v as rs.usize); } else { break; } } while (true) { - const _102: [rt.Arc, rt.u32] | undefined = LinkedHashMap.popFront$sync_Arc_str_u32_hashlink_DefaultHashBuilder(named); + const _102: [rs.Arc, rs.u32] | undefined = LinkedHashMap.popFront$sync_Arc_str_u32_hashlink_DefaultHashBuilder(named); if (_102 !== undefined) { - const k2: rt.Arc = _102[0]; - const v2: rt.u32 = _102[1]; - rt.byteVecExtendFromSlice(out, rt.stringAsBytes(k2.value)); - put(out, v2 as rt.usize); + const k2: rs.Arc = _102[0]; + const v2: rs.u32 = _102[1]; + rs.byteVecExtendFromSlice(out, rs.stringAsBytes(k2.value)); + put(out, v2 as rs.usize); k2[Symbol.dispose](); } else { break; @@ -716,42 +716,42 @@ export function linked(data: rt.ByteSlice, out: rt.ByteVec): void { * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_Drain_u16_u32_maps_linked_iters_closure6(it: linked_hash_map_Drain.Drain, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: [rt.u16, rt.u32]) => rt.usize): void { - let item!: [rt.u16, rt.u32] | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_Drain_u16_u32_maps_linked_iters_closure6(it: linked_hash_map_Drain.Drain, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: [rs.u16, rs.u32]) => rs.usize): void { + let item!: [rs.u16, rs.u32] | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(linked_hash_map_Drain.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(linked_hash_map_Drain.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rt.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNth(rs.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rs.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rt.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNthBack(rs.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rs.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } - put(out, option_mapOr$0iaogpf(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$0o00yzv(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter<[rt.u16, rt.u32]> = rt.iterRev(rt.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, lib_drop$hashlink_linked_hash_map_Drain_u16_u32, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rt.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); + const iter2: rs.Iter<[rs.u16, rs.u32]> = rs.iterRev(rs.iterFrom(it, linked_hash_map_Drain.next$iter_Iterator_u16_u32, lib_drop$hashlink_linked_hash_map_Drain_u16_u32, { hint: linked_hash_map_Drain.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Drain.Drain) => rs.iterFromOption(linked_hash_map_Drain.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); while (true) { - const _41: [rt.u16, rt.u32] | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: [rs.u16, rs.u32] | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); } - rt.drop(iter2); + rs.drop(iter2); } /** @@ -759,42 +759,42 @@ export function ends$hashlink_linked_hash_map_Drain_u16_u32_maps_linked_iters_cl * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_IntoIter_u16_u32_maps_linked_iters_closure5(it: linked_hash_map_IntoIter.IntoIter, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: [rt.u16, rt.u32]) => rt.usize): void { - let item!: [rt.u16, rt.u32] | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_IntoIter_u16_u32_maps_linked_iters_closure5(it: linked_hash_map_IntoIter.IntoIter, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: [rs.u16, rs.u32]) => rs.usize): void { + let item!: [rs.u16, rs.u32] | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(linked_hash_map_IntoIter.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(linked_hash_map_IntoIter.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rt.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNth(rs.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rs.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rt.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNthBack(rs.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rs.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } - put(out, option_mapOr$0iaogpf(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$0o00yzv(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter<[rt.u16, rt.u32]> = rt.iterRev(rt.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, lib_drop$hashlink_linked_hash_map_IntoIter_u16_u32, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rt.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); + const iter2: rs.Iter<[rs.u16, rs.u32]> = rs.iterRev(rs.iterFrom(it, linked_hash_map_IntoIter.next$iter_Iterator_u16_u32, lib_drop$hashlink_linked_hash_map_IntoIter_u16_u32, { hint: linked_hash_map_IntoIter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_IntoIter.IntoIter) => rs.iterFromOption(linked_hash_map_IntoIter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); while (true) { - const _41: [rt.u16, rt.u32] | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: [rs.u16, rs.u32] | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); } - rt.drop(iter2); + rs.drop(iter2); } /** @@ -802,37 +802,37 @@ export function ends$hashlink_linked_hash_map_IntoIter_u16_u32_maps_linked_iters * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_IterMut_u16_u32_maps_linked_iters_closure1(it: IterMut.IterMut, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: [rt.u16, rt.Place]) => rt.usize): void { - let item!: [rt.u16, rt.Place] | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_IterMut_u16_u32_maps_linked_iters_closure1(it: IterMut.IterMut, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: [rs.u16, rs.Place]) => rs.usize): void { + let item!: [rs.u16, rs.Place] | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(IterMut.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(IterMut.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rt.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNth(rs.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rs.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rt.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNthBack(rs.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rs.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } - put(out, option_mapOr$1noewr3(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = IterMut.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$0bhoutc(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = IterMut.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter<[rt.u16, rt.Place]> = rt.iterRev(rt.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rt.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); + const iter2: rs.Iter<[rs.u16, rs.Place]> = rs.iterRev(rs.iterFrom(it, IterMut.next$iter_Iterator_u16_u32, undefined, { hint: IterMut.sizeHint$iter_Iterator_u16_u32, back: (it: IterMut.IterMut) => rs.iterFromOption(IterMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); while (true) { - const _41: [rt.u16, rt.Place] | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: [rs.u16, rs.Place] | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); @@ -844,37 +844,37 @@ export function ends$hashlink_linked_hash_map_IterMut_u16_u32_maps_linked_iters_ * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_closure0(it: linked_hash_map_Iter.Iter, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: [rt.u16, rt.u32]) => rt.usize): void { - let item!: [rt.u16, rt.u32] | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_closure0(it: linked_hash_map_Iter.Iter, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: [rs.u16, rs.u32]) => rs.usize): void { + let item!: [rs.u16, rs.u32] | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNth(rs.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); + item = rs.iterNthBack(rs.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), n); } - put(out, option_mapOr$0iaogpf(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$0o00yzv(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter<[rt.u16, rt.u32]> = rt.iterRev(rt.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); + const iter2: rs.Iter<[rs.u16, rs.u32]> = rs.iterRev(rs.iterFrom(it, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })); while (true) { - const _41: [rt.u16, rt.u32] | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: [rs.u16, rs.u32] | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); @@ -886,37 +886,37 @@ export function ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_clo * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_Keys_u16_u32_maps_linked_iters_closure3(it: Keys.Keys, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: rt.u16) => rt.usize): void { - let item!: rt.u16 | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_Keys_u16_u32_maps_linked_iters_closure3(it: Keys.Keys, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: rs.u16) => rs.usize): void { + let item!: rs.u16 | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(Keys.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(Keys.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rt.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), n); + item = rs.iterNth(rs.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rs.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rt.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), n); + item = rs.iterNthBack(rs.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rs.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), n); } - put(out, option_mapOr$0yixjb2(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = Keys.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$066oa3q(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = Keys.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter = rt.iterRev(rt.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rt.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 })); + const iter2: rs.Iter = rs.iterRev(rs.iterFrom(it, Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rs.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 })); while (true) { - const _41: rt.u16 | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: rs.u16 | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); @@ -928,37 +928,37 @@ export function ends$hashlink_linked_hash_map_Keys_u16_u32_maps_linked_iters_clo * `nth`, or `nth_back`, each item by `f` and then its size hint, and then the rest from * the back. */ -export function ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_closure4(it: linked_hash_map_Values.Values, steps: rt.ByteSlice, out: rt.ByteVec, f: (a0: rt.u32) => rt.usize): void { - let item!: rt.u32 | undefined; - const iter: rt.Iter = rt.iterTake(rt.iterSlice(rt.byteSliceView(steps)), 6); +export function ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_closure4(it: linked_hash_map_Values.Values, steps: rs.ByteSlice, out: rs.ByteVec, f: (a0: rs.u32) => rs.usize): void { + let item!: rs.u32 | undefined; + const iter: rs.Iter = rs.iterTake(rs.iterSlice(rs.byteSliceView(steps)), 6); while (true) { - const _9: rt.u8 | rt.Done = iter.next(); - if (_9 === rt.DONE) { + const _9: rs.u8 | rs.Done = iter.next(); + if (_9 === rs.DONE) { break; } - const step: rt.u8 = _9; - const n: rt.usize = rt.usizeRem(step >> 2 as rt.usize, 3); - const _20: rt.u8 = rt.u8Rem(step, 4); + const step: rs.u8 = _9; + const n: rs.usize = rs.usizeRem(step >> 2 as rs.usize, 3); + const _20: rs.u8 = rs.u8Rem(step, 4); if (_20 === 0) { - item = rt.iterToOption(linked_hash_map_Values.next$iter_Iterator_u16_u32(it)); + item = rs.iterToOption(linked_hash_map_Values.next$iter_Iterator_u16_u32(it)); } else if (_20 === 1) { item = linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it); } else if (_20 === 2) { - item = rt.iterNth(rt.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rt.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), n); + item = rs.iterNth(rs.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rs.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), n); } else { - item = rt.iterNthBack(rt.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rt.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), n); + item = rs.iterNthBack(rs.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rs.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), n); } - put(out, option_mapOr$1vcgixw(item, 256, f)); - const _32: [rt.usize, rt.usize | undefined] = linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32(it); - const lower: rt.usize = _32[0]; - const upper: rt.usize | undefined = _32[1]; + put(out, option_mapOr$0as7mjc(item, 256, f)); + const _32: [rs.usize, rs.usize | undefined] = linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32(it); + const lower: rs.usize = _32[0]; + const upper: rs.usize | undefined = _32[1]; put(out, lower); - put(out, option_unwrapOr$0l7j3f6(upper, 256)); + put(out, option_unwrapOr$05jq4mv(upper, 256)); } - const iter2: rt.Iter = rt.iterRev(rt.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rt.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 })); + const iter2: rs.Iter = rs.iterRev(rs.iterFrom(it, linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rs.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 })); while (true) { - const _41: rt.u32 | rt.Done = iter2.next(); - if (_41 === rt.DONE) { + const _41: rs.u32 | rs.Done = iter2.next(); + if (_41 === rs.DONE) { break; } put(out, f(_41)); @@ -969,85 +969,85 @@ export function ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_c * `hashlink::LinkedHashMap`'s iterators, of up to 11 entries in the order `data`'s first * byte inserts them, each read from either end and through std's adaptors. */ -export function linkedIters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { - let _15!: rt.u16; - let it!: ValuesMut.ValuesMut; - const _34: (a0: [rt.u16, rt.u32]) => rt.usize = (_2: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_2[0] as rt.usize, 4096), _2[1] as rt.usize); +export function linkedIters(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { + let _15!: rs.u16; + let it!: ValuesMut.ValuesMut; + const _34: (a0: [rs.u16, rs.u32]) => rs.usize = (_2: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_2[0] as rs.usize, 4096), _2[1] as rs.usize); }; let _104: boolean = false; if (dataLen >= 2) { - const m: LinkedHashMap.LinkedHashMap = LinkedHashMap.withHasher$u16_u32_hash_RandomState(rt.randomState()); + const m: LinkedHashMap.LinkedHashMap = LinkedHashMap.withHasher$u16_u32_hash_RandomState(rs.randomState()); _104 = true; - const _12: rt.u16 = rt.u8Rem(dataData[dataStart], 12) as rt.u16; - let iterStart: rt.u16 = 0; - const iterEnd: rt.u16 = _12; + const _12: rs.u16 = rs.u8Rem(dataData[dataStart], 12) as rs.u16; + let iterStart: rs.u16 = 0; + const iterEnd: rs.u16 = _12; while ((_15 = iterStart++) < iterEnd) { - const i: rt.u16 = _15; - LinkedHashMap.insert$u16_u32_hash_RandomState(m, rt.u16Rem(rt.u16Add(rt.u16Mul(i, 5), rt.u8Shr(dataData[dataStart], 4) as rt.u16), 12), rt.u32Mul(i as rt.u32, 3)); + const i: rs.u16 = _15; + LinkedHashMap.insert$u16_u32_hash_RandomState(m, rs.u16Rem(rs.u16Add(rs.u16Mul(i, 5), rs.u8Shr(dataData[dataStart], 4) as rs.u16), 12), rs.u32Mul(i as rs.u32, 3)); } - const k: rt.usize = rt.u8Shr(dataData[dataStart + 1], 3) as rt.usize; - const _35: rt.u8 = rt.u8Rem(dataData[dataStart + 1], 8); + const k: rs.usize = rs.u8Shr(dataData[dataStart + 1], 3) as rs.usize; + const _35: rs.u8 = rs.u8Rem(dataData[dataStart + 1], 8); if (_35 === 0) { - ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_closure0(LinkedHashMap.iter$u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_215: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_215[0] as rt.usize, 4096), _215[1] as rt.usize); + ends$hashlink_linked_hash_map_Iter_u16_u32_maps_linked_iters_closure0(LinkedHashMap.iter$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_215: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_215[0] as rs.usize, 4096), _215[1] as rs.usize); }); } else if (_35 === 1) { - ends$hashlink_linked_hash_map_IterMut_u16_u32_maps_linked_iters_closure1(LinkedHashMap.iterMut$u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_214: [rt.u16, rt.Place]): rt.usize => { - _214[1].v = rt.u32Add(_214[1].v, 100); - return _214[0] as rt.usize; + ends$hashlink_linked_hash_map_IterMut_u16_u32_maps_linked_iters_closure1(LinkedHashMap.iterMut$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_214: [rs.u16, rs.Place]): rs.usize => { + _214[1].v = rs.u32Add(_214[1].v, 100); + return _214[0] as rs.usize; }); - const _42: linked_hash_map_Iter.Iter = LinkedHashMap.iter$u16_u32_hash_RandomState(m); - const _44: (a0: [rt.u16, rt.u32]) => undefined = (e2: [rt.u16, rt.u32]): undefined => { + const _42: linked_hash_map_Iter.Iter = LinkedHashMap.iter$u16_u32_hash_RandomState(m); + const _44: (a0: [rs.u16, rs.u32]) => undefined = (e2: [rs.u16, rs.u32]): undefined => { put(out, _34(e2)); }; - rt.iterForEach(rt.iterFrom(_42, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), _44); + rs.iterForEach(rs.iterFrom(_42, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }), _44); } else if (_35 === 2) { - ends$hashlink_linked_hash_map_Keys_u16_u32_maps_linked_iters_closure3(LinkedHashMap.keys$u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (k5: rt.u16): rt.usize => { - return k5 as rt.usize; + ends$hashlink_linked_hash_map_Keys_u16_u32_maps_linked_iters_closure3(LinkedHashMap.keys$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (k5: rs.u16): rs.usize => { + return k5 as rs.usize; }); } else if (_35 === 3) { - ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_closure4(LinkedHashMap.values$u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (v6: rt.u32): rt.usize => { - return v6 as rt.usize; + ends$hashlink_linked_hash_map_Values_u16_u32_maps_linked_iters_closure4(LinkedHashMap.values$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (v6: rs.u32): rs.usize => { + return v6 as rs.usize; }); } else if (_35 === 4) { _104 = false; - ends$hashlink_linked_hash_map_IntoIter_u16_u32_maps_linked_iters_closure5(LinkedHashMap.intoIter$iter_IntoIterator_u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_213: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_213[0] as rt.usize, 4096), _213[1] as rt.usize); + ends$hashlink_linked_hash_map_IntoIter_u16_u32_maps_linked_iters_closure5(LinkedHashMap.intoIter$iter_IntoIterator_u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_213: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_213[0] as rs.usize, 4096), _213[1] as rs.usize); }); } else if (_35 === 5) { - ends$hashlink_linked_hash_map_Drain_u16_u32_maps_linked_iters_closure6(LinkedHashMap.drain$u16_u32_hash_RandomState(m), new rt.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_212: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_212[0] as rt.usize, 4096), _212[1] as rt.usize); + ends$hashlink_linked_hash_map_Drain_u16_u32_maps_linked_iters_closure6(LinkedHashMap.drain$u16_u32_hash_RandomState(m), new rs.ByteSlice(dataData, dataStart + 2, dataLen - 2), out, (_212: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_212[0] as rs.usize, 4096), _212[1] as rs.usize); }); put(out, LinkedHashMap.len$u16_u32_hash_RandomState(m)); } else if (_35 === 6) { it = LinkedHashMap.valuesMut$u16_u32_hash_RandomState(m); - const _64: rt.usize = rt.usizeRem(k, 4); - put(out, option_mapOr$1787w44(rt.iterNthBack(rt.iterFrom(it, ValuesMut.next$iter_Iterator_u16_u32, undefined, { hint: ValuesMut.sizeHint$iter_Iterator_u16_u32, back: (it: ValuesMut.ValuesMut) => rt.iterFromOption(ValuesMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: ValuesMut.len$iter_ExactSizeIterator_u16_u32 }), _64), 256, (v: rt.Place): rt.usize => { - return v.v as rt.usize; + const _64: rs.usize = rs.usizeRem(k, 4); + put(out, option_mapOr$17oc7db(rs.iterNthBack(rs.iterFrom(it, ValuesMut.next$iter_Iterator_u16_u32, undefined, { hint: ValuesMut.sizeHint$iter_Iterator_u16_u32, back: (it: ValuesMut.ValuesMut) => rs.iterFromOption(ValuesMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: ValuesMut.len$iter_ExactSizeIterator_u16_u32 }), _64), 256, (v: rs.Place): rs.usize => { + return v.v as rs.usize; })); put(out, ValuesMut.len$iter_ExactSizeIterator_u16_u32(it)); - rt.iterForEach(rt.iterRev(rt.iterFrom(it, ValuesMut.next$iter_Iterator_u16_u32, undefined, { hint: ValuesMut.sizeHint$iter_Iterator_u16_u32, back: (it: ValuesMut.ValuesMut) => rt.iterFromOption(ValuesMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: ValuesMut.len$iter_ExactSizeIterator_u16_u32 })), (v2: rt.Place): undefined => { - v2.v = rt.u32Add(v2.v, 1); + rs.iterForEach(rs.iterRev(rs.iterFrom(it, ValuesMut.next$iter_Iterator_u16_u32, undefined, { hint: ValuesMut.sizeHint$iter_Iterator_u16_u32, back: (it: ValuesMut.ValuesMut) => rs.iterFromOption(ValuesMut.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: ValuesMut.len$iter_ExactSizeIterator_u16_u32 })), (v2: rs.Place): undefined => { + v2.v = rs.u32Add(v2.v, 1); }); - rt.iterForEach(rt.iterFrom(LinkedHashMap.values$u16_u32_hash_RandomState(m), linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rt.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), (v3: rt.u32): undefined => { - put(out, v3 as rt.usize); + rs.iterForEach(rs.iterFrom(LinkedHashMap.values$u16_u32_hash_RandomState(m), linked_hash_map_Values.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Values.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Values.Values) => rs.iterFromOption(linked_hash_map_Values.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: linked_hash_map_Values.len$iter_ExactSizeIterator_u16_u32 }), (v3: rs.u32): undefined => { + put(out, v3 as rs.usize); }); } else { - const it2: linked_hash_map_Iter.Iter = LinkedHashMap.iter$u16_u32_hash_RandomState(m); - put(out, option_mapOr$0iaogpf(rt.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(it2)), 256, (_210: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_210[0] as rt.usize, 4096), _210[1] as rt.usize); + const it2: linked_hash_map_Iter.Iter = LinkedHashMap.iter$u16_u32_hash_RandomState(m); + put(out, option_mapOr$0o00yzv(rs.iterToOption(linked_hash_map_Iter.next$iter_Iterator_u16_u32(it2)), 256, (_210: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_210[0] as rs.usize, 4096), _210[1] as rs.usize); })); - put(out, rt.iterFrom(it2, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len()); - const rest: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterSkip(rt.iterRev(rt.iterFrom(it2, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rt.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })), rt.usizeRem(k, 4)), (_211: [rt.u16, rt.u32]): rt.usize => { - return rt.usizeAdd(rt.usizeMul(_211[0] as rt.usize, 4096), _211[1] as rt.usize); + put(out, rs.iterFrom(it2, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) }).len()); + const rest: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterSkip(rs.iterRev(rs.iterFrom(it2, linked_hash_map_Iter.next$iter_Iterator_u16_u32, undefined, { hint: linked_hash_map_Iter.sizeHint$iter_Iterator_u16_u32, back: (it: linked_hash_map_Iter.Iter) => rs.iterFromOption(linked_hash_map_Iter.nextBack$iter_DoubleEndedIterator_u16_u32(it)) })), rs.usizeRem(k, 4)), (_211: [rs.u16, rs.u32]): rs.usize => { + return rs.usizeAdd(rs.usizeMul(_211[0] as rs.usize, 4096), _211[1] as rs.usize); }), "next", 4); - put(out, rt.vecCapacity(rest, 4)); - rt.iterForEach(rt.vecIntoIter(rest), (e: rt.usize): undefined => { + put(out, rs.vecCapacity(rest, 4)); + rs.iterForEach(rs.vecIntoIter(rest), (e: rs.usize): undefined => { put(out, e); }); - put(out, option_unwrapOr$0l7j3f6(rt.iterRposition(rt.iterFrom(LinkedHashMap.keys$u16_u32_hash_RandomState(m), Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rt.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), (k2: rt.u16): boolean => { - return rt.u16Rem(k2, 2) === 0; + put(out, option_unwrapOr$05jq4mv(rs.iterRposition(rs.iterFrom(LinkedHashMap.keys$u16_u32_hash_RandomState(m), Keys.next$iter_Iterator_u16_u32, undefined, { hint: Keys.sizeHint$iter_Iterator_u16_u32, back: (it: Keys.Keys) => rs.iterFromOption(Keys.nextBack$iter_DoubleEndedIterator_u16_u32(it)), len: Keys.len$iter_ExactSizeIterator_u16_u32 }), (k2: rs.u16): boolean => { + return rs.u16Rem(k2, 2) === 0; }), 256)); } if (_104) { @@ -1062,61 +1062,61 @@ export function linkedIters(dataData: Uint8Array, dataStart: number, dataLen: nu * drops, through each pair of bytes after a capacity: a step and its key. What dropped is * written after each step, and after the end. */ -export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, out: rt.ByteVec): void { +export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, out: rs.ByteVec): void { let _139: boolean = false; if (dataLen >= 1) { - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const cache: LruCache.LruCache = LruCache.new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(rt.u8Rem(dataData[dataStart], 5) as rt.usize); + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const cache: LruCache.LruCache = LruCache.new$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(rs.u8Rem(dataData[dataStart], 5) as rs.usize); let set: LinkedHashSet.LinkedHashSet = LinkedHashSet.new$maps_Logged_hashlink_DefaultHashBuilder(); let held: Held.Held = new Held.Held(LruCache.newUnbounded$u16_maps_Logged_hashlink_DefaultHashBuilder(), new Logged.Logged(240, log)); - const kept: rt.Vec> = new rt.Vec(); + const kept: rs.Vec> = new rs.Vec(); let once: [LinkedHashSet.LinkedHashSet, Logged.Logged] | undefined = undefined; - const iter: rt.Iter<[rt.usize, rt.ByteSlice]> = rt.iterEnumerate(rt.byteSliceChunks(new rt.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2)); + const iter: rs.Iter<[rs.usize, rs.ByteSlice]> = rs.iterEnumerate(rs.byteSliceChunks(new rs.ByteSlice(dataData, dataStart + 1, dataLen - 1), 2)); while (true) { - const _23: [rt.usize, rt.ByteSlice] | rt.Done = iter.next(); - if (_23 === rt.DONE) { + const _23: [rs.usize, rs.ByteSlice] | rs.Done = iter.next(); + if (_23 === rs.DONE) { break; } - const i: rt.usize = _23[0]; - rt.idx(_23[1], 0); - const _30: [rt.u8, rt.u8] = [_23[1].data[_23[1].start], option_unwrapOr$0r2bmpr(rt.byteSliceGet(_23[1], 1), 0)]; - const op: rt.u8 = _30[0]; - const arg: rt.u8 = _30[1]; - const _40: [rt.u8, rt.u8] = [rt.u8Rem(arg, 6), rt.u8WrappingAdd(i & 0xff, 16)]; - const key: rt.u8 = _40[0]; - const id: rt.u8 = _40[1]; - const _46: rt.u8 = rt.u8Rem(op, 9); + const i: rs.usize = _23[0]; + rs.idx(_23[1], 0); + const _30: [rs.u8, rs.u8] = [_23[1].data[_23[1].start], option_unwrapOr$1fr498u(rs.byteSliceGet(_23[1], 1), 0)]; + const op: rs.u8 = _30[0]; + const arg: rs.u8 = _30[1]; + const _40: [rs.u8, rs.u8] = [rs.u8Rem(arg, 6), rs.u8WrappingAdd(i & 0xff, 16)]; + const key: rs.u8 = _40[0]; + const id: rs.u8 = _40[1]; + const _46: rs.u8 = rs.u8Rem(op, 9); if (_46 === 0 || _46 === 1) { - rt.byteVecPush(out, option_mapOr$085zvfb(LruCache.insert$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(cache, new Logged.Logged(key, log), new Logged.Logged(id, log)), 255, (v2: Logged.Logged): rt.u8 => { - const _02: rt.u8 = v2._0; + rs.byteVecPush(out, option_mapOr$00octnd(LruCache.insert$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(cache, new Logged.Logged(key, log), new Logged.Logged(id, log)), 255, (v2: Logged.Logged): rs.u8 => { + const _02: rs.u8 = v2._0; v2[Symbol.dispose](); return _02; })); } else if (_46 === 2) { - rt.byteVecPush(out, LinkedHashSet.insert$maps_Logged_hashlink_DefaultHashBuilder(set, new Logged.Logged(key | 128, log)) ? 1 : 0); + rs.byteVecPush(out, LinkedHashSet.insert$maps_Logged_hashlink_DefaultHashBuilder(set, new Logged.Logged(key | 128, log)) ? 1 : 0); } else if (_46 === 3) { - const _64: rt.u16 = key as rt.u16; + const _64: rs.u16 = key as rs.u16; const _65: Logged.Logged = new Logged.Logged(id, log); - rt.drop(LruCache.insert$u16_maps_Logged_hashlink_DefaultHashBuilder(held.cache, _64, _65)); + rs.drop(LruCache.insert$u16_maps_Logged_hashlink_DefaultHashBuilder(held.cache, _64, _65)); } else if (_46 === 4) { const _72: Logged.Logged = new Logged.Logged(key, log); - rt.byteVecPush(out, option_mapOr$085zvfb(LruCache.remove$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(cache, _72), 255, (v: Logged.Logged): rt.u8 => { - const _0: rt.u8 = v._0; + rs.byteVecPush(out, option_mapOr$00octnd(LruCache.remove$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(cache, _72), 255, (v: Logged.Logged): rs.u8 => { + const _0: rs.u8 = v._0; v[Symbol.dispose](); return _0; })); _72[Symbol.dispose](); const _79: Logged.Logged = new Logged.Logged(key | 128, log); - rt.byteVecPush(out, LinkedHashSet.remove$maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(set, _79) ? 1 : 0); + rs.byteVecPush(out, LinkedHashSet.remove$maps_Logged_hashlink_DefaultHashBuilder_maps_Logged(set, _79) ? 1 : 0); _79[Symbol.dispose](); } else if (_46 === 5) { - LruCache.setCapacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(cache, rt.u8Rem(arg, 4) as rt.usize); + LruCache.setCapacity$maps_Logged_maps_Logged_hashlink_DefaultHashBuilder(cache, rs.u8Rem(arg, 4) as rs.usize); } else if (_46 === 6) { - const _88: LruCache.LruCache = LruCache.new$u16_maps_Logged_hashlink_DefaultHashBuilder(rt.u8Rem(arg, 3) as rt.usize); + const _88: LruCache.LruCache = LruCache.new$u16_maps_Logged_hashlink_DefaultHashBuilder(rs.u8Rem(arg, 3) as rs.usize); const old3 = held.cache; held.cache = _88; kept.items.push(old3); - rt.vecTruncate(kept, rt.u8Rem(arg, 2) as rt.usize, lib_drop$hashlink_LruCache_u16_maps_Logged); + rs.vecTruncate(kept, rs.u8Rem(arg, 2) as rs.usize, lib_drop$hashlink_LruCache_u16_maps_Logged); } else if (_46 === 7) { const default_ = LinkedHashSet.default$Default_maps_Logged_hashlink_DefaultHashBuilder(); const taken2 = set; @@ -1130,35 +1130,35 @@ export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, held = _109; const _107: Held.Held = old2; _139 = true; - const moved: LruCache.LruCache = _107.cache; + const moved: LruCache.LruCache = _107.cache; const last: Logged.Logged = _107.last; - rt.byteVecPush(out, last._0); + rs.byteVecPush(out, last._0); if ((arg & 1) === 1) { _139 = false; lib_drop$hashlink_LruCache_u16_maps_Logged(moved); } - rt.byteVecPush(out, 253); + rs.byteVecPush(out, 253); last[Symbol.dispose](); if (_139) { lib_drop$hashlink_LruCache_u16_maps_Logged(moved); } _139 = false; } - rt.byteVecPush(out, 254); - const _125: rt.RefCell = rt.refCellBorrowMut(log); - rt.iterExtendBytes(out, rt.byteVecDrain(_125.value, undefined), "fold", true); - rt.refMutRelease(_125); + rs.byteVecPush(out, 254); + const _125: rs.RefCell = rs.refCellBorrowMut(log); + rs.iterExtendBytes(out, rs.byteVecDrain(_125.value, undefined), "fold", true); + rs.refMutRelease(_125); } - rt.byteVecPush(out, once !== undefined ? 1 : 0); - rt.byteVecPush(out, 254); + rs.byteVecPush(out, once !== undefined ? 1 : 0); + rs.byteVecPush(out, 254); lib_drop$Option_tuple2_hashlink_LinkedHashSet_maps_Logged_maps_Logged(once); - rt.dropVec(kept, lib_drop$hashlink_LruCache_u16_maps_Logged); + rs.dropVec(kept, lib_drop$hashlink_LruCache_u16_maps_Logged); lib_drop$maps_Held_maps_Logged(held); lib_drop$hashlink_LinkedHashSet_maps_Logged(set); lib_drop$hashlink_LruCache_maps_Logged_maps_Logged(cache); - const _137: rt.RefCell = rt.refCellBorrow(log); - rt.iterExtendBytes(out, rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(_137.value))), undefined, true); - rt.refRelease(_137); + const _137: rs.RefCell = rs.refCellBorrow(log); + rs.iterExtendBytes(out, rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(_137.value))), undefined, true); + rs.refRelease(_137); } } @@ -1168,54 +1168,54 @@ export function nested(dataData: Uint8Array, dataStart: number, dataLen: number, * it before what it holds, and drops it before them, and at once from `into_iter`. Only * maps of one entry say what they drop, as hashbrown's order is its own. */ -export function ownHasher(data: rt.ByteSlice, out: rt.ByteVec): void { - let _36!: rt.u8; - let _43!: rt.u8; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); +export function ownHasher(data: rs.ByteSlice, out: rs.ByteVec): void { + let _36!: rs.u8; + let _43!: rs.u8; + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); const _6: Seeded.Seeded = new Seeded.Seeded(1, log); - const pairs: rt.HashMap<[rt.u8, rt.u8], rt.u32> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same])), _6) as rt.HashMap<[rt.u8, rt.u8], rt.u32>; - const set: rt.HashSet = rt.hashWithCapacity(data.length, 469762048, undefined, new Seeded.Seeded(10, log)) as rt.HashSet; - for (const b of rt.byteSliceView(data)) { - const _21: [rt.u8, rt.u8] = [rt.u8Rem(b, 4), rt.u8Rem(b, 3)]; - const _18: rt.Place = rt.entryOrInsertMut(rt.entry(pairs, _21), 0); - _18.v = rt.u32Add(_18.v, 1); - rt.byteVecPush(out, rt.hashAdd(set, rt.u8Rem(b, 8)) ? 1 : 0); + const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), _6) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; + const set: rs.HashSet = rs.hashWithCapacity(data.length, 469762048, undefined, new Seeded.Seeded(10, log)) as rs.HashSet; + for (const b of rs.byteSliceView(data)) { + const _21: [rs.u8, rs.u8] = [rs.u8Rem(b, 4), rs.u8Rem(b, 3)]; + const _18: rs.Place = rs.entryOrInsertMut(rs.entry(pairs, _21), 0); + _18.v = rs.u32Add(_18.v, 1); + rs.byteVecPush(out, rs.hashAdd(set, rs.u8Rem(b, 8)) ? 1 : 0); } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 4; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 4; l3: while ((_36 = iterStart++) < iterEnd) { - const a: rt.u8 = _36; - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 3; + const a: rs.u8 = _36; + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 3; while (true) { if (!((_43 = iterStart2++) < iterEnd2)) { continue l3; } - put(out, option_unwrapOr$11c0we2(rt.hashGet(pairs, [a, _43] as [rt.u8, rt.u8]), 0) as rt.usize); + put(out, option_unwrapOr$1b5hww3(rs.hashGet(pairs, [a, _43] as [rs.u8, rs.u8]), 0) as rs.usize); } } - rt.byteVecPush(out, (pairs.s as Seeded.Seeded)._0); - rt.byteVecPush(out, (set.s as Seeded.Seeded)._0); + rs.byteVecPush(out, (pairs.s as Seeded.Seeded)._0); + rs.byteVecPush(out, (set.s as Seeded.Seeded)._0); const _64: Seeded.Seeded = new Seeded.Seeded(20, log); - const one: rt.HashMap<[rt.u8, rt.u8], Logged.Logged> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same])), _64) as rt.HashMap<[rt.u8, rt.u8], Logged.Logged>; - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - rt.drop(rt.hashInsert(one, [first, 0] as [rt.u8, rt.u8], new Logged.Logged(first, log))); - const copy: rt.HashSet = rt.hashClone(set, undefined, undefined, Seeded.clone$Clone); - rt.byteVecPush(out, (copy.s as Seeded.Seeded)._0); - const entries: rt.Iter<[[rt.u8, rt.u8], Logged.Logged]> = rt.hashIter(one, undefined, rt.drop, rt.drop); - const _85: rt.RefCell = rt.refCellBorrowMut(log); - rt.byteVecPush(_85.value, 105); - rt.refMutRelease(_85); - lib_drop$Option_tuple2_tuple2_u8_u8_maps_Logged(rt.iterToOption(entries.next())); - rt.drop(entries); - lib_drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded([pairs, set, copy] as [rt.HashMap<[rt.u8, rt.u8], rt.u32>, rt.HashSet, rt.HashSet]); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(rt.refCellReplace(log, new rt.ByteVec()))); + const one: rs.HashMap<[rs.u8, rs.u8], Logged.Logged> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), _64) as rs.HashMap<[rs.u8, rs.u8], Logged.Logged>; + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + rs.drop(rs.hashInsert(one, [first, 0] as [rs.u8, rs.u8], new Logged.Logged(first, log))); + const copy: rs.HashSet = rs.hashClone(set, undefined, undefined, Seeded.clone$Clone); + rs.byteVecPush(out, (copy.s as Seeded.Seeded)._0); + const entries: rs.Iter<[[rs.u8, rs.u8], Logged.Logged]> = rs.hashIter(one, undefined, rs.drop, rs.drop); + const _85: rs.RefCell = rs.refCellBorrowMut(log); + rs.byteVecPush(_85.value, 105); + rs.refMutRelease(_85); + lib_drop$Option_tuple2_tuple2_u8_u8_maps_Logged(rs.iterToOption(entries.next())); + rs.drop(entries); + lib_drop$tuple3_hashbrown_HashMap_tuple2_u8_u8_u32_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded_hashbrown_HashSet_u8_maps_Seeded([pairs, set, copy] as [rs.HashMap<[rs.u8, rs.u8], rs.u32>, rs.HashSet, rs.HashSet]); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(rs.refCellReplace(log, new rs.ByteVec()))); } -export const MADE: rt.LocalKey> = /* @__PURE__ */ new rt.LocalKey(MADE$init, false); +export const MADE: rs.LocalKey> = /* @__PURE__ */ new rs.LocalKey(MADE$init, false); -export function MADE$init(): rt.RefCell { - return new rt.RefCell(new rt.ByteVec()); +export function MADE$init(): rs.RefCell { + return new rs.RefCell(new rs.ByteVec()); } /** @@ -1223,31 +1223,31 @@ export function MADE$init(): rt.RefCell { * a map's takes the source's items, which drops its hasher, and reads their size hint * before it makes its own, and a set's after. */ -export function ownFromIter(data: rt.ByteSlice, out: rt.ByteVec): void { - ((made: rt.RefCell): undefined => { - const _5: rt.RefCell = rt.refCellBorrowMut(made); - rt.byteVecClear(_5.value); - rt.refMutRelease(_5); +export function ownFromIter(data: rs.ByteSlice, out: rs.ByteVec): void { + ((made: rs.RefCell): undefined => { + const _5: rs.RefCell = rs.refCellBorrowMut(made); + rs.byteVecClear(_5.value); + rs.refMutRelease(_5); })(MADE.get()); - const map: rt.HashMap = rt.hashNew(undefined, new Made.Made(1)) as rt.HashMap; - const set: rt.HashSet = rt.hashNew(undefined, new Made.Made(2)) as rt.HashSet; - for (const b of rt.byteSliceView(data)) { - rt.hashInsert(map, rt.u8Rem(b, 8), b); - rt.hashAdd(set, rt.u8Rem(b, 8)); + const map: rs.HashMap = rs.hashNew(undefined, new Made.Made(1)) as rs.HashMap; + const set: rs.HashSet = rs.hashNew(undefined, new Made.Made(2)) as rs.HashSet; + for (const b of rs.byteSliceView(data)) { + rs.hashInsert(map, rs.u8Rem(b, 8), b); + rs.hashAdd(set, rs.u8Rem(b, 8)); } - const map2: rt.HashMap = rt.hashFromIter(rt.hashIter(map, undefined, undefined, rt.drop), () => rt.hashNew(undefined, Made.default$Default()) as rt.HashMap, undefined, undefined, undefined, 469762048); - const _26: rt.HashSet = set; - const set2: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, Made.default$Default()) as rt.HashSet, rt.hashKeys(_26, undefined, undefined, rt.drop), undefined, undefined, 469762048); - put(out, rt.hashLen(map2)); - put(out, rt.hashLen(set2)); - const hinted: rt.HashMap = rt.hashFromIter(rt.iterFrom(new Hinted.Hinted(rt.hashIter(map2, undefined, undefined, rt.drop)), Hinted.next$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8, undefined, { hint: Hinted.sizeHint$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8 }), () => rt.hashNew(undefined, Made.default$Default()) as rt.HashMap, undefined, undefined, undefined, 469762048); - const _37: Hinted.Hinted> = new Hinted.Hinted(rt.hashKeys(set2, undefined, undefined, rt.drop)); - const keys: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, Made.default$Default()) as rt.HashSet, rt.iterFrom(_37, Hinted.next$iter_Iterator_hashbrown_hash_set_IntoIter_u8, undefined, { hint: Hinted.sizeHint$iter_Iterator_hashbrown_hash_set_IntoIter_u8 }), undefined, undefined, 469762048); - put(out, rt.hashLen(hinted)); - put(out, rt.hashLen(keys)); - lib_drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made([hinted, keys] as [rt.HashMap, rt.HashSet]); - rt.byteVecExtendFromSlice(out, rt.byteVecSlice(((made2: rt.RefCell): rt.ByteVec => { - return rt.refCellReplace(made2, new rt.ByteVec()); + const map2: rs.HashMap = rs.hashFromIter(rs.hashIter(map, undefined, undefined, rs.drop), () => rs.hashNew(undefined, Made.default$Default()) as rs.HashMap, undefined, undefined, undefined, 469762048); + const _26: rs.HashSet = set; + const set2: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, Made.default$Default()) as rs.HashSet, rs.hashKeys(_26, undefined, undefined, rs.drop), undefined, undefined, 469762048); + put(out, rs.hashLen(map2)); + put(out, rs.hashLen(set2)); + const hinted: rs.HashMap = rs.hashFromIter(rs.iterFrom(new Hinted.Hinted(rs.hashIter(map2, undefined, undefined, rs.drop)), Hinted.next$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8, undefined, { hint: Hinted.sizeHint$iter_Iterator_hashbrown_hash_map_IntoIter_u8_u8 }), () => rs.hashNew(undefined, Made.default$Default()) as rs.HashMap, undefined, undefined, undefined, 469762048); + const _37: Hinted.Hinted> = new Hinted.Hinted(rs.hashKeys(set2, undefined, undefined, rs.drop)); + const keys: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, Made.default$Default()) as rs.HashSet, rs.iterFrom(_37, Hinted.next$iter_Iterator_hashbrown_hash_set_IntoIter_u8, undefined, { hint: Hinted.sizeHint$iter_Iterator_hashbrown_hash_set_IntoIter_u8 }), undefined, undefined, 469762048); + put(out, rs.hashLen(hinted)); + put(out, rs.hashLen(keys)); + lib_drop$tuple2_hashbrown_HashMap_u8_u8_maps_Made_hashbrown_HashSet_u8_maps_Made([hinted, keys] as [rs.HashMap, rs.HashSet]); + rs.byteVecExtendFromSlice(out, rs.byteVecSlice(((made2: rs.RefCell): rs.ByteVec => { + return rs.refCellReplace(made2, new rs.ByteVec()); })(MADE.get()))); } @@ -1258,115 +1258,115 @@ export function ownFromIter(data: rt.ByteSlice, out: rt.ByteVec): void { * another order, so a key given twice keeps the value it was given last; or of all but the * last, or of one byte flipped. */ -export function equal(data: rt.ByteSlice, out: rt.ByteVec): void { - const _22: (a0: rt.ByteSlice) => rt.HashMap = (bytes: rt.ByteSlice): rt.HashMap => { - const _3: rt.Iter<[rt.u16, rt.u32]> = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes)), (_2: rt.u8): [rt.u16, rt.u32] => { - const b: rt.u8 = _2; - return [rt.u8Rem(b, 8) as rt.u16, b as rt.u32] as [rt.u16, rt.u32]; +export function equal(data: rs.ByteSlice, out: rs.ByteVec): void { + const _22: (a0: rs.ByteSlice) => rs.HashMap = (bytes: rs.ByteSlice): rs.HashMap => { + const _3: rs.Iter<[rs.u16, rs.u32]> = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes)), (_2: rs.u8): [rs.u16, rs.u32] => { + const b: rs.u8 = _2; + return [rs.u8Rem(b, 8) as rs.u16, b as rs.u32] as [rs.u16, rs.u32]; }); - return rt.hashExtend(rt.hashNew() as rt.HashMap, _3, undefined, undefined, undefined, 117440512); + return rs.hashExtend(rs.hashNew() as rs.HashMap, _3, undefined, undefined, undefined, 117440512); }; - const log: rt.RefCell = new rt.RefCell(new rt.ByteVec()); - const reversed: rt.ByteVec = rt.iterToByteVec(rt.iterRev(rt.iterSlice(rt.byteSliceView(data))), undefined, true); - const flipped: rt.ByteVec = rt.iterToByteVec(rt.iterMap(rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(data))), (_23: [rt.usize, rt.u8]): rt.u8 => { - const i: rt.usize = _23[0]; - const b2: rt.u8 = _23[1]; - if (!(i === rt.usizeDiv(data.length, 2))) { + const log: rs.RefCell = new rs.RefCell(new rs.ByteVec()); + const reversed: rs.ByteVec = rs.iterToByteVec(rs.iterRev(rs.iterSlice(rs.byteSliceView(data))), undefined, true); + const flipped: rs.ByteVec = rs.iterToByteVec(rs.iterMap(rs.iterEnumerate(rs.iterSlice(rs.byteSliceView(data))), (_23: [rs.usize, rs.u8]): rs.u8 => { + const i: rs.usize = _23[0]; + const b2: rs.u8 = _23[1]; + if (!(i === rs.usizeDiv(data.length, 2))) { return b2; } return b2 ^ 33; }), undefined, true); - const shorter: rt.ByteSlice = rt.byteSliceRange(data, 0, rt.usizeSaturatingSub(data.length, 1)); - const pairs: (a0: rt.u8, a1: rt.ByteSlice) => rt.HashMap<[rt.u8, boolean], rt.u8> = (seed: rt.u8, bytes2: rt.ByteSlice): rt.HashMap<[rt.u8, boolean], rt.u8> => { + const shorter: rs.ByteSlice = rs.byteSliceRange(data, 0, rs.usizeSaturatingSub(data.length, 1)); + const pairs: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashMap<[rs.u8, boolean], rs.u8> = (seed: rs.u8, bytes2: rs.ByteSlice): rs.HashMap<[rs.u8, boolean], rs.u8> => { const _54: Seeded.Seeded = new Seeded.Seeded(seed, log); - const m: rt.HashMap<[rt.u8, boolean], rt.u8> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same])), _54) as rt.HashMap<[rt.u8, boolean], rt.u8>; - const iterS: Uint8Array = rt.byteSliceView(bytes2); + const m: rs.HashMap<[rs.u8, boolean], rs.u8> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), _54) as rs.HashMap<[rs.u8, boolean], rs.u8>; + const iterS: Uint8Array = rs.byteSliceView(bytes2); let iterI: number = 0; while (true) { - const _83: rt.u8 | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_83 === rt.DONE) { + const _83: rs.u8 | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_83 === rs.DONE) { return m; } - const b3: rt.u8 = _83; - const _142: [rt.u8, boolean] = [rt.u8Rem(b3, 8), rt.u8Rem(b3, 3) === 0]; - rt.hashInsert(m, _142, b3 >> 5); + const b3: rs.u8 = _83; + const _142: [rs.u8, boolean] = [rs.u8Rem(b3, 8), rs.u8Rem(b3, 3) === 0]; + rs.hashInsert(m, _142, b3 >> 5); } }; - const keys: (a0: rt.u8, a1: rt.ByteSlice) => rt.HashSet = (seed2: rt.u8, bytes3: rt.ByteSlice): rt.HashSet => { - const s: rt.HashSet = rt.hashNew(undefined, new Seeded.Seeded(seed2, log)) as rt.HashSet; - const _84: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(bytes3)), (b4: rt.u8): rt.u8 => { - return rt.u8Rem(b4, 16); + const keys: (a0: rs.u8, a1: rs.ByteSlice) => rs.HashSet = (seed2: rs.u8, bytes3: rs.ByteSlice): rs.HashSet => { + const s: rs.HashSet = rs.hashNew(undefined, new Seeded.Seeded(seed2, log)) as rs.HashSet; + const _84: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(bytes3)), (b4: rs.u8): rs.u8 => { + return rs.u8Rem(b4, 16); }); - rt.hashExtendKeys(s, _84, undefined, undefined, 469762048); + rs.hashExtendKeys(s, _84, undefined, undefined, 469762048); return s; }; - const _26: [rt.HashMap<[rt.u8, boolean], rt.u8>, rt.HashSet, rt.HashMap] = [pairs(1, data), keys(1, data), _22(data)]; - const left: rt.HashMap<[rt.u8, boolean], rt.u8> = _26[0]; - const set: rt.HashSet = _26[1]; - const counts: rt.HashMap = _26[2]; - const iter: rt.Iter = rt.iterSlice([rt.byteSliceRange(rt.byteVecSlice(reversed), 0), data, shorter, rt.byteVecSlice(flipped)]); + const _26: [rs.HashMap<[rs.u8, boolean], rs.u8>, rs.HashSet, rs.HashMap] = [pairs(1, data), keys(1, data), _22(data)]; + const left: rs.HashMap<[rs.u8, boolean], rs.u8> = _26[0]; + const set: rs.HashSet = _26[1]; + const counts: rs.HashMap = _26[2]; + const iter: rs.Iter = rs.iterSlice([rs.byteSliceRange(rs.byteVecSlice(reversed), 0), data, shorter, rs.byteVecSlice(flipped)]); while (true) { - const _43: rt.ByteSlice | rt.Done = iter.next(); - if (_43 === rt.DONE) { + const _43: rs.ByteSlice | rs.Done = iter.next(); + if (_43 === rs.DONE) { break; } - const right: rt.HashMap<[rt.u8, boolean], rt.u8> = pairs(2, _43); - rt.byteVecPush(out, rt.hashEq(rt.same)(left, right) ? 1 : 0); - rt.byteVecPush(out, !rt.hashEq(rt.same)(right, left) ? 1 : 0); - const other: rt.HashSet = keys(2, _43); - rt.byteVecPush(out, rt.hashEq()(set, other) ? 1 : 0); - rt.byteVecPush(out, !rt.hashEq()(other, set) ? 1 : 0); - const _78: rt.HashMap = _22(_43); - rt.byteVecPush(out, rt.hashEq(rt.same)(counts, _78) ? 1 : 0); - rt.hashDrop(other, undefined, undefined, rt.drop); - rt.hashDrop(right, undefined, undefined, rt.drop); + const right: rs.HashMap<[rs.u8, boolean], rs.u8> = pairs(2, _43); + rs.byteVecPush(out, rs.hashEq(rs.same)(left, right) ? 1 : 0); + rs.byteVecPush(out, !rs.hashEq(rs.same)(right, left) ? 1 : 0); + const other: rs.HashSet = keys(2, _43); + rs.byteVecPush(out, rs.hashEq()(set, other) ? 1 : 0); + rs.byteVecPush(out, !rs.hashEq()(other, set) ? 1 : 0); + const _78: rs.HashMap = _22(_43); + rs.byteVecPush(out, rs.hashEq(rs.same)(counts, _78) ? 1 : 0); + rs.hashDrop(other, undefined, undefined, rs.drop); + rs.hashDrop(right, undefined, undefined, rs.drop); } - rt.hashDrop(set, undefined, undefined, rt.drop); - rt.hashDrop(left, undefined, undefined, rt.drop); + rs.hashDrop(set, undefined, undefined, rs.drop); + rs.hashDrop(left, undefined, undefined, rs.drop); } /** * `hashbrown::HashMap` and `HashSet` with `BuildHasherDefault` of std's `DefaultHasher`, * made by `default` and `from_iter`, whose `hasher` hashes as `DefaultHasher::new` does. */ -export function defaultHasher(data: rt.ByteSlice, out: rt.ByteVec): void { - let _25!: rt.u8; - let _32!: rt.u8; - const pairs: rt.HashMap<[rt.u8, rt.u8], rt.u32> = rt.hashNew(rt.hashing(rt.hashTuple([rt.hash8, rt.hash8]), rt.eqTuple([rt.same, rt.same])), undefined) as rt.HashMap<[rt.u8, rt.u8], rt.u32>; - const _5: rt.Iter = rt.iterMap(rt.iterSlice(rt.byteSliceView(data)), (b3: rt.u8): rt.u8 => { - return rt.u8Rem(b3, 8); +export function defaultHasher(data: rs.ByteSlice, out: rs.ByteVec): void { + let _25!: rs.u8; + let _32!: rs.u8; + const pairs: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashNew(rs.hashing(rs.hashTuple([rs.hash8, rs.hash8]), rs.eqTuple([rs.same, rs.same])), undefined) as rs.HashMap<[rs.u8, rs.u8], rs.u32>; + const _5: rs.Iter = rs.iterMap(rs.iterSlice(rs.byteSliceView(data)), (b3: rs.u8): rs.u8 => { + return rs.u8Rem(b3, 8); }); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(undefined, undefined) as rt.HashSet, _5, undefined, undefined, 469762048); - for (const b of rt.byteSliceView(data)) { - const _16: [rt.u8, rt.u8] = [rt.u8Rem(b, 4), rt.u8Rem(b, 3)]; - const _13: rt.Place = rt.entryOrInsertMut(rt.entry(pairs, _16), 0); - _13.v = rt.u32Add(_13.v, 1); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew(undefined, undefined) as rs.HashSet, _5, undefined, undefined, 469762048); + for (const b of rs.byteSliceView(data)) { + const _16: [rs.u8, rs.u8] = [rs.u8Rem(b, 4), rs.u8Rem(b, 3)]; + const _13: rs.Place = rs.entryOrInsertMut(rs.entry(pairs, _16), 0); + _13.v = rs.u32Add(_13.v, 1); } - let iterStart: rt.u8 = 0; - const iterEnd: rt.u8 = 4; + let iterStart: rs.u8 = 0; + const iterEnd: rs.u8 = 4; l3: while ((_25 = iterStart++) < iterEnd) { - const a: rt.u8 = _25; - let iterStart2: rt.u8 = 0; - const iterEnd2: rt.u8 = 3; + const a: rs.u8 = _25; + let iterStart2: rs.u8 = 0; + const iterEnd2: rs.u8 = 3; while (true) { if (!((_32 = iterStart2++) < iterEnd2)) { continue l3; } - put(out, option_unwrapOr$11c0we2(rt.hashGet(pairs, [a, _32] as [rt.u8, rt.u8]), 0) as rt.usize); + put(out, option_unwrapOr$1b5hww3(rs.hashGet(pairs, [a, _32] as [rs.u8, rs.u8]), 0) as rs.usize); } } - put(out, rt.hashLen(set)); - const first: rt.u8 = option_unwrapOr$0r2bmpr(rt.byteSliceFirst(data), 0); - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(rt.hasher(), [first, 0] as [rt.u8, rt.u8], rt.hashTuple([rt.hash8, rt.hash8]))).reverse())); - rt.hashClone(set, undefined, undefined, (_a0: undefined): undefined => { + put(out, rs.hashLen(set)); + const first: rs.u8 = option_unwrapOr$1fr498u(rs.byteSliceFirst(data), 0); + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(rs.hasher(), [first, 0] as [rs.u8, rs.u8], rs.hashTuple([rs.hash8, rs.hash8]))).reverse())); + rs.hashClone(set, undefined, undefined, (_a0: undefined): undefined => { return undefined; }).s as undefined; - rt.byteVecExtendFromSlice(out, rt.byteSliceFrom(rt.u64ToBeBytes(rt.hashOne(rt.hasher(), first, rt.hash8)).reverse())); - rt.byteVecPush(out, true ? 1 : 0); - const _79: rt.HashMap<[rt.u8, rt.u8], rt.u32> = rt.hashClone(pairs, undefined, undefined, (_a02: undefined): undefined => { + rs.byteVecExtendFromSlice(out, rs.byteSliceFrom(rs.u64ToBeBytes(rs.hashOne(rs.hasher(), first, rs.hash8)).reverse())); + rs.byteVecPush(out, true ? 1 : 0); + const _79: rs.HashMap<[rs.u8, rs.u8], rs.u32> = rs.hashClone(pairs, undefined, undefined, (_a02: undefined): undefined => { return undefined; }); - rt.byteVecPush(out, rt.hashEq(rt.same)(pairs, _79) ? 1 : 0); + rs.byteVecPush(out, rs.hashEq(rs.same)(pairs, _79) ? 1 : 0); } //# sourceMappingURL=maps.ts.map diff --git a/ts/fixtures/task/expected/closures.ts b/ts/fixtures/task/expected/closures.ts index 7d0587f7d..2c968068c 100644 --- a/ts/fixtures/task/expected/closures.ts +++ b/ts/fixtures/task/expected/closures.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; -import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$1cf8u0y as option_map$1cf8u0y } from "./core/option.ts"; +import * as rs from "./rs.ts"; +import { unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1haiqd3 as option_map$1haiqd3 } from "./core/option.ts"; import { recvFuture$kio_Consumer } from "./kio.ts"; import type * as Consumer from "./kio.Consumer.ts"; import * as Log from "./log.Log.ts"; @@ -21,7 +21,7 @@ import * as Guard from "./model.Guard.ts"; * dropped before their first poll. A clone of the one that owns a count changes its own. A * cancel drops what the future in flight holds, then the closures, in reverse. */ -export function closures(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function closures(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new closuresFuture(rx, guard); } @@ -29,33 +29,33 @@ export class closuresFuture { #state: number = 0; #rx: Consumer.Consumer; #guard: Guard.Guard; - #id!: rt.u32; + #id!: rs.u32; #log!: Log.Log; - #seen!: rt.Vec; - #reads!: rt.u32; - #next!: (a0: rt.u64) => rt.Future; - #first!: rt.u64 | undefined; - #awaitee!: rt.Future; - #second!: rt.u64 | undefined; - #count!: rt.u32; - #tally!: (a0: rt.u32) => rt.Future; - #awaitee$2!: rt.Future; - #copy!: (a0: rt.u32) => rt.Future; - #tallied!: [rt.u32, rt.u32, rt.u32]; - #saved!: rt.u32; - #saved$2!: rt.u32; - #third!: rt.u64; - #awaitee$3!: rt.Future; + #seen!: rs.Vec; + #reads!: rs.u32; + #next!: (a0: rs.u64) => rs.Future; + #first!: rs.u64 | undefined; + #awaitee!: rs.Future; + #second!: rs.u64 | undefined; + #count!: rs.u32; + #tally!: (a0: rs.u32) => rs.Future; + #awaitee$2!: rs.Future; + #copy!: (a0: rs.u32) => rs.Future; + #tallied!: [rs.u32, rs.u32, rs.u32]; + #saved!: rs.u32; + #saved$2!: rs.u32; + #third!: rs.u64; + #awaitee$3!: rs.Future; #lent!: Guard.Guard; - #peek!: (a0: rt.u64) => rt.Future; - #fourth!: rt.u64; - #add!: (a0: rt.u64) => rt.Future; - #finish!: (a0: rt.u64) => rt.Future; - #fifth!: rt.u64; - #saved$3!: (a0: rt.u64) => rt.Future; - #sixth!: rt.u64; + #peek!: (a0: rs.u64) => rs.Future; + #fourth!: rs.u64; + #add!: (a0: rs.u64) => rs.Future; + #finish!: (a0: rs.u64) => rs.Future; + #fifth!: rs.u64; + #saved$3!: (a0: rs.u64) => rs.Future; + #sixth!: rs.u64; #unpolled!: Guard.Guard; - #slot!: rt.Future | undefined; + #slot!: rs.Future | undefined; #saved$4!: boolean; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { @@ -72,64 +72,64 @@ export class closuresFuture { return; } if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); break b0; } if (this.#state === 4) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); break b0; } if (this.#state === 5) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); break b0; } if (this.#state === 6) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); break b0; } if (this.#state === 7) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); break b0; } if (this.#state === 8) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b0; } if (this.#state === 9) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b1; } if (this.#state === 10) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b1; } if (this.#state === 11) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b1; } if (this.#state === 12) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); break b1; } if (this.#state === 13) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 14) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 15) { - rt.drop(this.#awaitee); - rt.drop(this.#saved$3); + rs.drop(this.#awaitee); + rs.drop(this.#saved$3); } else if (this.#state === 16) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 17) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 18) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); this.#unpolled[Symbol.dispose](); } else { return; } if (this.#saved$4) { - rt.drop(this.#finish); + rs.drop(this.#finish); } this.#saved$4 = false; } @@ -140,7 +140,7 @@ export class closuresFuture { this.#rx[Symbol.dispose](); } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { b1: { b2: { @@ -158,17 +158,17 @@ export class closuresFuture { b14: { if (this.#state === 0) { this.#saved$4 = false; - const _3: [rt.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; + const _3: [rs.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; this.#id = _3[0]; this.#log = _3[1]; - this.#seen = new rt.Vec(); + this.#seen = new rs.Vec(); this.#reads = 0; - this.#next = (scale: rt.u64): rt.Future => { - return new closuresFuture$closure0_closure0(scale, this.#rx, this.#seen, rt.place(() => this.#reads, (value) => this.#reads = value)); + this.#next = (scale: rs.u64): rs.Future => { + return new closuresFuture$closure0_closure0(scale, this.#rx, this.#seen, rs.place(() => this.#reads, (value) => this.#reads = value)); }; this.#awaitee = this.#next(1); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { if (this.#state === 4) { break b14; @@ -214,155 +214,155 @@ export class closuresFuture { } break b0; } - const _16: rt.Poll = this.#awaitee.poll(_2); - if (_16 !== rt.Pending) { + const _16: rs.Poll = this.#awaitee.poll(_2); + if (_16 !== rs.Pending) { this.#first = _16; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#awaitee = new twiceFuture$closures_closures_closure0_closure0(this.#next); } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _27: rt.Poll = this.#awaitee.poll(_2); - if (_27 !== rt.Pending) { + const _27: rs.Poll = this.#awaitee.poll(_2); + if (_27 !== rs.Pending) { this.#second = _27; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#count = this.#reads; - const make2 = (captured: rt.u32): (a0: rt.u32) => rt.Future => { - return rt.cloning((by: rt.u32): rt.Future => { - return new closuresFuture$closure1_closure0(by, rt.place(() => captured, (value2) => captured = value2)); + const make2 = (captured: rs.u32): (a0: rs.u32) => rs.Future => { + return rs.cloning((by: rs.u32): rs.Future => { + return new closuresFuture$closure1_closure0(by, rs.place(() => captured, (value2) => captured = value2)); }, () => make2(captured)); }; this.#tally = make2(this.#count); this.#awaitee$2 = this.#tally(10); } else { this.#state = 4; - return rt.Pending; + return rs.Pending; } } - const _39: rt.Poll = this.#awaitee$2.poll(_2); - if (_39 !== rt.Pending) { - const once: rt.u32 = _39; - rt.drop(this.#awaitee$2); - this.#copy = rt.closureClone(this.#tally); + const _39: rs.Poll = this.#awaitee$2.poll(_2); + if (_39 !== rs.Pending) { + const once: rs.u32 = _39; + rs.drop(this.#awaitee$2); + this.#copy = rs.closureClone(this.#tally); this.#saved = once; this.#awaitee$2 = this.#copy(100); } else { this.#state = 5; - return rt.Pending; + return rs.Pending; } } - const _52: rt.Poll = this.#awaitee$2.poll(_2); - if (_52 !== rt.Pending) { + const _52: rs.Poll = this.#awaitee$2.poll(_2); + if (_52 !== rs.Pending) { this.#saved$2 = _52; - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); this.#awaitee$2 = this.#tally(1000); } else { this.#state = 6; - return rt.Pending; + return rs.Pending; } } - const _64: rt.Poll = this.#awaitee$2.poll(_2); - if (_64 !== rt.Pending) { - const result4: rt.u32 = _64; - rt.drop(this.#awaitee$2); - this.#tallied = [this.#saved, this.#saved$2, result4] as [rt.u32, rt.u32, rt.u32]; + const _64: rs.Poll = this.#awaitee$2.poll(_2); + if (_64 !== rs.Pending) { + const result4: rs.u32 = _64; + rs.drop(this.#awaitee$2); + this.#tallied = [this.#saved, this.#saved$2, result4] as [rs.u32, rs.u32, rs.u32]; const arg = this.#seen; - const _87: rt.Fmt = (f: rt.Formatter) => rt.fmtList(arg.items, f, (value: rt.u64 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u64Debug)); + const _87: rs.Fmt = (f: rs.Formatter) => rs.fmtList(arg.items, f, (value: rs.u64 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)); const arg2 = this.#first; - const _88: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(arg2, f, rt.u64Debug); + const _88: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(arg2, f, rs.u64Debug); const arg3 = this.#second; - const _89: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(arg3, f, rt.u64Debug); + const _89: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(arg3, f, rs.u64Debug); const arg4 = this.#reads; - const _90: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg4, f); + const _90: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg4, f); const arg5 = this.#tallied; - const _91: rt.Fmt = (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(arg5[0], f), (f: rt.Formatter) => rt.u32Debug(arg5[1], f), (f: rt.Formatter) => rt.u32Debug(arg5[2], f)], f); + const _91: rs.Fmt = (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(arg5[0], f), (f: rs.Formatter) => rs.u32Debug(arg5[1], f), (f: rs.Formatter) => rs.u32Debug(arg5[2], f)], f); const arg6 = this.#count; - const args2: rt.Fmt[] = [_87, _88, _89, _90, _91, (f: rt.Formatter) => rt.u32Display(arg6, f)]; - const _74: string = rt.fmtFormat(["seen ", args2[0], " first ", args2[1], " second ", args2[2], " reads ", args2[3], " tallied ", args2[4], " count ", args2[5]]); + const args2: rs.Fmt[] = [_87, _88, _89, _90, _91, (f: rs.Formatter) => rs.u32Display(arg6, f)]; + const _74: string = rs.fmtFormat(["seen ", args2[0], " first ", args2[1], " second ", args2[2], " reads ", args2[3], " tallied ", args2[4], " count ", args2[5]]); Guard.note(this.#guard, _74); - const captured2 = Guard.new(rt.u32Add(this.#id, 500), Log.clone$Clone(this.#log)); - this.#awaitee$3 = new callOnceFuture$closures_closures_closure0_closure2(rt.closure(rt.byMove((rx: Consumer.Consumer): rt.Future => { + const captured2 = Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)); + this.#awaitee$3 = new callOnceFuture$closures_closures_closure0_closure2(rs.closure(rs.byMove((rx: Consumer.Consumer): rs.Future => { return new closuresFuture$closure2_closure0(rx, captured2); - }, (_22: Consumer.Consumer): rt.Future => { + }, (_22: Consumer.Consumer): rs.Future => { return new closuresFuture$closure2_closure0_once(_22, captured2); }), (): void => { captured2[Symbol.dispose](); }), this.#rx); } else { this.#state = 7; - return rt.Pending; + return rs.Pending; } } - const _105: rt.Poll = this.#awaitee$3.poll(_2); - if (_105 !== rt.Pending) { + const _105: rs.Poll = this.#awaitee$3.poll(_2); + if (_105 !== rs.Pending) { this.#third = _105; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); const arg7 = this.#third; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg7, f)]; - const _115: string = rt.fmtFormat(["third ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg7, f)]; + const _115: string = rs.fmtFormat(["third ", args4[0]]); Guard.note(this.#guard, _115); - this.#lent = Guard.new(rt.u32Add(this.#id, 600), Log.clone$Clone(this.#log)); - this.#peek = (value3: rt.u64): rt.Future => { + this.#lent = Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)); + this.#peek = (value3: rs.u64): rs.Future => { return new closuresFuture$closure3_closure0(value3, this.#lent); }; this.#awaitee$3 = new callFuture$closures_closures_closure0_closure3(this.#peek, 4); } else { this.#state = 8; - return rt.Pending; + return rs.Pending; } } - const _135: rt.Poll = this.#awaitee$3.poll(_2); - if (_135 !== rt.Pending) { + const _135: rs.Poll = this.#awaitee$3.poll(_2); + if (_135 !== rs.Pending) { this.#fourth = _135; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); this.#awaitee$3 = new throughFnFuture$ref_closures_closures_closure0_closure3_closures_closures_closure0_closure3_closure0(this.#peek, 5); } else { this.#state = 9; - return rt.Pending; + return rs.Pending; } } - const _146: rt.Poll = this.#awaitee$3.poll(_2); - if (_146 !== rt.Pending) { - const result7: rt.u64 = _146; - rt.drop(this.#awaitee$3); - this.#fourth = rt.u64Add(this.#fourth, result7); - this.#awaitee$3 = new throughFnFuture$closures_closures_closure0_closure4_closures_closures_closure0_closure4_closure0((value4: rt.u64): rt.Future => { + const _146: rs.Poll = this.#awaitee$3.poll(_2); + if (_146 !== rs.Pending) { + const result7: rs.u64 = _146; + rs.drop(this.#awaitee$3); + this.#fourth = rs.u64Add(this.#fourth, result7); + this.#awaitee$3 = new throughFnFuture$closures_closures_closure0_closure4_closures_closures_closure0_closure4_closure0((value4: rs.u64): rs.Future => { return new closuresFuture$closure4_closure0(value4); }, 6); } else { this.#state = 10; - return rt.Pending; + return rs.Pending; } } - const _158: rt.Poll = this.#awaitee$3.poll(_2); - if (_158 !== rt.Pending) { - const result8: rt.u64 = _158; - rt.drop(this.#awaitee$3); - this.#fourth = rt.u64Add(this.#fourth, result8); - const captured3 = Guard.new(rt.u32Add(this.#id, 700), Log.clone$Clone(this.#log)); - this.#awaitee$2 = rt.closure((): rt.Future => { + const _158: rs.Poll = this.#awaitee$3.poll(_2); + if (_158 !== rs.Pending) { + const result8: rs.u64 = _158; + rs.drop(this.#awaitee$3); + this.#fourth = rs.u64Add(this.#fourth, result8); + const captured3 = Guard.new(rs.u32Add(this.#id, 700), Log.clone$Clone(this.#log)); + this.#awaitee$2 = rs.closure((): rs.Future => { return new closuresFuture$closure5_closure0(captured3); }, (): void => { captured3[Symbol.dispose](); })(); } else { this.#state = 11; - return rt.Pending; + return rs.Pending; } } - const _178: rt.Poll = this.#awaitee$2.poll(_2); - if (_178 !== rt.Pending) { - const result9: rt.u32 = _178; - rt.drop(this.#awaitee$2); - this.#add = adder(result9 as rt.u64); - const last: Guard.Guard = Guard.new(rt.u32Add(this.#id, 800), Log.clone$Clone(this.#log)); + const _178: rs.Poll = this.#awaitee$2.poll(_2); + if (_178 !== rs.Pending) { + const result9: rs.u32 = _178; + rs.drop(this.#awaitee$2); + this.#add = adder(result9 as rs.u64); + const last: Guard.Guard = Guard.new(rs.u32Add(this.#id, 800), Log.clone$Clone(this.#log)); this.#saved$4 = true; const captured4 = last; - this.#finish = rt.closure(rt.byMove((value5: rt.u64): rt.Future => { + this.#finish = rs.closure(rs.byMove((value5: rs.u64): rs.Future => { return new closuresFuture$closure6_closure0(value5, captured4); - }, (_26: rt.u64): rt.Future => { + }, (_26: rs.u64): rs.Future => { return new closuresFuture$closure6_closure0_once(_26, captured4); }), (): void => { captured4[Symbol.dispose](); @@ -370,120 +370,120 @@ export class closuresFuture { this.#awaitee$3 = new callFuture$closures_adder_closure0(this.#add, 10); } else { this.#state = 12; - return rt.Pending; + return rs.Pending; } } - const _195: rt.Poll = this.#awaitee$3.poll(_2); - if (_195 !== rt.Pending) { + const _195: rs.Poll = this.#awaitee$3.poll(_2); + if (_195 !== rs.Pending) { this.#fifth = _195; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); this.#awaitee$3 = new callFuture$closures_closures_closure0_closure6(this.#finish, 20); } else { this.#state = 13; - return rt.Pending; + return rs.Pending; } } - const _206: rt.Poll = this.#awaitee$3.poll(_2); - if (_206 !== rt.Pending) { - const result11: rt.u64 = _206; - rt.drop(this.#awaitee$3); - this.#fifth = rt.u64Add(this.#fifth, result11); + const _206: rs.Poll = this.#awaitee$3.poll(_2); + if (_206 !== rs.Pending) { + const result11: rs.u64 = _206; + rs.drop(this.#awaitee$3); + this.#fifth = rs.u64Add(this.#fifth, result11); this.#saved$4 = false; this.#saved$3 = this.#finish; this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else { this.#state = 14; - return rt.Pending; + return rs.Pending; } } - const _221: rt.Poll = this.#awaitee.poll(_2); - if (_221 !== rt.Pending) { - const result12: rt.u64 | undefined = _221; - rt.drop(this.#awaitee); - const _217: rt.u64 = option_unwrapOr$1tvry1i(result12, 0); + const _221: rs.Poll = this.#awaitee.poll(_2); + if (_221 !== rs.Pending) { + const result12: rs.u64 | undefined = _221; + rs.drop(this.#awaitee); + const _217: rs.u64 = option_unwrapOr$15hbiwd(result12, 0); this.#awaitee$3 = new throughFnOnceFuture$closures_closures_closure0_closure6_closures_closures_closure0_closure6_closure0(this.#saved$3, _217); } else { this.#state = 15; - return rt.Pending; + return rs.Pending; } } - const _229: rt.Poll = this.#awaitee$3.poll(_2); - if (_229 !== rt.Pending) { - const result13: rt.u64 = _229; - rt.drop(this.#awaitee$3); - this.#fifth = rt.u64Add(this.#fifth, result13); + const _229: rs.Poll = this.#awaitee$3.poll(_2); + if (_229 !== rs.Pending) { + const result13: rs.u64 = _229; + rs.drop(this.#awaitee$3); + this.#fifth = rs.u64Add(this.#fifth, result13); const arg8 = this.#fourth; - const _249: rt.Fmt = (f: rt.Formatter) => rt.u64Display(arg8, f); + const _249: rs.Fmt = (f: rs.Formatter) => rs.u64Display(arg8, f); const arg9 = this.#fifth; - const args6: rt.Fmt[] = [_249, (f: rt.Formatter) => rt.u64Display(arg9, f)]; - const _240: string = rt.fmtFormat(["fourth ", args6[0], " fifth ", args6[1]]); + const args6: rs.Fmt[] = [_249, (f: rs.Formatter) => rs.u64Display(arg9, f)]; + const _240: string = rs.fmtFormat(["fourth ", args6[0], " fifth ", args6[1]]); Guard.note(this.#guard, _240); - const captured5 = Guard.new(rt.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); - this.#awaitee$3 = new callOnceFuture$boxed_Box_closures_closures_closure0_closure7(rt.closure(rt.byMove((rx2: Consumer.Consumer): rt.Future => { + const captured5 = Guard.new(rs.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); + this.#awaitee$3 = new callOnceFuture$boxed_Box_closures_closures_closure0_closure7(rs.closure(rs.byMove((rx2: Consumer.Consumer): rs.Future => { return new closuresFuture$closure7_closure0(rx2, captured5); - }, (_29: Consumer.Consumer): rt.Future => { + }, (_29: Consumer.Consumer): rs.Future => { return new closuresFuture$closure7_closure0_once(_29, captured5); }), (): void => { captured5[Symbol.dispose](); }), this.#rx); } else { this.#state = 16; - return rt.Pending; + return rs.Pending; } } - const _264: rt.Poll = this.#awaitee$3.poll(_2); - if (_264 !== rt.Pending) { + const _264: rs.Poll = this.#awaitee$3.poll(_2); + if (_264 !== rs.Pending) { this.#sixth = _264; - rt.drop(this.#awaitee$3); - const _274: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rt.u32Add(this.#id, 1000), Log.clone$Clone(this.#log)), Guard.new(rt.u32Add(this.#id, 1100), Log.clone$Clone(this.#log)), Guard.new(rt.u32Add(this.#id, 1200), Log.clone$Clone(this.#log))]; + rs.drop(this.#awaitee$3); + const _274: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rs.u32Add(this.#id, 1000), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 1100), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 1200), Log.clone$Clone(this.#log))]; const made: Guard.Guard = _274[0]; const erased: Guard.Guard = _274[1]; this.#unpolled = _274[2]; const captured6 = made; - this.#slot = undefined as rt.Future | undefined; - const make: () => rt.Future = rt.closure(rt.byMove((): rt.Future => { + this.#slot = undefined as rs.Future | undefined; + const make: () => rs.Future = rs.closure(rs.byMove((): rs.Future => { return new closuresFuture$closure8_closure0(captured6); - }, (): rt.Future => { + }, (): rs.Future => { return new closuresFuture$closure8_closure0_once(captured6); }), (): void => { captured6[Symbol.dispose](); }); if (this.#slot === undefined) { - this.#slot = rt.callOnce(make); + this.#slot = rs.callOnce(make); } else { - rt.drop(make); + rs.drop(make); } - rt.drop(this.#slot); + rs.drop(this.#slot); const captured7 = erased; - this.#awaitee$2 = erase$closures_closures_closure0_closure9_closures_closures_closure0_closure9_closure0(rt.closure(rt.byMove((): rt.Future => { + this.#awaitee$2 = erase$closures_closures_closure0_closure9_closures_closures_closure0_closure9_closure0(rs.closure(rs.byMove((): rs.Future => { return new closuresFuture$closure9_closure0(captured7); - }, (): rt.Future => { + }, (): rs.Future => { return new closuresFuture$closure9_closure0_once(captured7); }), (): void => { captured7[Symbol.dispose](); }))(); } else { this.#state = 17; - return rt.Pending; + return rs.Pending; } } - const _304: rt.Poll = this.#awaitee$2.poll(_2); - if (_304 !== rt.Pending) { - const seventh: rt.u32 = _304; - rt.drop(this.#awaitee$2); + const _304: rs.Poll = this.#awaitee$2.poll(_2); + if (_304 !== rs.Pending) { + const seventh: rs.u32 = _304; + rs.drop(this.#awaitee$2); const captured8 = this.#unpolled; - rt.drop(erase$closures_closures_closure0_closure10_closures_closures_closure0_closure10_closure0(rt.closure(rt.byMove((): rt.Future => { + rs.drop(erase$closures_closures_closure0_closure10_closures_closures_closure0_closure10_closure0(rs.closure(rs.byMove((): rs.Future => { return new closuresFuture$closure10_closure0(captured8); - }, (): rt.Future => { + }, (): rs.Future => { return new closuresFuture$closure10_closure0_once(captured8); }), (): void => { captured8[Symbol.dispose](); }))()); const arg10 = this.#sixth; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg10, f), (f: rt.Formatter) => rt.u32Display(seventh, f)]; - const _319: string = rt.fmtFormat(["sixth ", args8[0], " seventh ", args8[1]]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg10, f), (f: rs.Formatter) => rs.u32Display(seventh, f)]; + const _319: string = rs.fmtFormat(["sixth ", args8[0], " seventh ", args8[1]]); Guard.note(this.#guard, _319); - const _360: rt.u64 = rt.u64Add(rt.u64Add(rt.u64Add(rt.u64Add(rt.u64Add(option_unwrapOr$1tvry1i(this.#first, 0), option_unwrapOr$1tvry1i(this.#second, 0)), this.#third), this.#fourth), this.#fifth), this.#sixth); + const _360: rs.u64 = rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(rs.u64Add(option_unwrapOr$15hbiwd(this.#first, 0), option_unwrapOr$15hbiwd(this.#second, 0)), this.#third), this.#fourth), this.#fifth), this.#sixth); this.#saved$4 = false; this.#lent[Symbol.dispose](); this.#log[Symbol.dispose](); @@ -493,19 +493,19 @@ export class closuresFuture { return _360; } this.#state = 18; - return rt.Pending; + return rs.Pending; } } export class closuresFuture$closure0_closure0 { #state: number = 0; - #scale: rt.u64; + #scale: rs.u64; #rx: Consumer.Consumer; - #seen: rt.Vec; - #reads: rt.Place; - #awaitee!: rt.Future; + #seen: rs.Vec; + #reads: rs.Place; + #awaitee!: rs.Future; - constructor(scale: rt.u64, rx: Consumer.Consumer, seen: rt.Vec, reads: rt.Place) { + constructor(scale: rs.u64, rx: Consumer.Consumer, seen: rs.Vec, reads: rs.Place) { this.#scale = scale; this.#rx = rx; this.#seen = seen; @@ -514,39 +514,39 @@ export class closuresFuture$closure0_closure0 { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _5: rt.Poll = this.#awaitee.poll(_2); - if (_5 !== rt.Pending) { - const value: rt.u64 | undefined = _5; - rt.drop(this.#awaitee); + const _5: rs.Poll = this.#awaitee.poll(_2); + if (_5 !== rs.Pending) { + const value: rs.u64 | undefined = _5; + rs.drop(this.#awaitee); this.#seen.items.push(value); - this.#reads.v = rt.u32Add(this.#reads.v, 1); - const _0: rt.Poll = option_map$1cf8u0y(value, (value2: rt.u64): rt.u64 => { - return rt.u64Mul(value2, this.#scale); + this.#reads.v = rs.u32Add(this.#reads.v, 1); + const _0: rs.Poll = option_map$1haiqd3(value, (value2: rs.u64): rs.u64 => { + return rs.u64Mul(value2, this.#scale); }); this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class closuresFuture$closure1_closure0 { #state: number = 0; - #by: rt.u32; - #count: rt.Place; + #by: rs.u32; + #count: rs.Place; - constructor(by: rt.u32, count: rt.Place) { + constructor(by: rs.u32, count: rs.Place) { this.#by = by; this.#count = count; } @@ -554,14 +554,14 @@ export class closuresFuture$closure1_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - this.#count.v = rt.u32Add(this.#count.v, this.#by); - const _0: rt.Poll = this.#count.v; + this.#count.v = rs.u32Add(this.#count.v, this.#by); + const _0: rs.Poll = this.#count.v; this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -569,7 +569,7 @@ export class closuresFuture$closure2_closure0 { #state: number = 0; #rx: Consumer.Consumer; #owned: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, owned: Guard.Guard) { this.#rx = rx; @@ -578,29 +578,29 @@ export class closuresFuture$closure2_closure0 { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const value: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const value: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); const _27: Guard.Guard = this.#owned; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u64Debug)]; - Guard.note(_27, rt.fmtFormat(["once ", args2[0]])); - const _0: rt.Poll = option_unwrapOr$1tvry1i(value, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; + Guard.note(_27, rs.fmtFormat(["once ", args2[0]])); + const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -608,7 +608,7 @@ export class closuresFuture$closure2_closure0_once { #state: number = 0; #rx: Consumer.Consumer; #owned: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, owned: Guard.Guard) { this.#rx = rx; @@ -619,40 +619,40 @@ export class closuresFuture$closure2_closure0_once { if (this.#state === 0) { this.#owned[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#owned[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const value: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u64Debug)]; - const _17: string = rt.fmtFormat(["once ", args2[0]]); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const value: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; + const _17: string = rs.fmtFormat(["once ", args2[0]]); Guard.note(this.#owned, _17); - const _29: rt.u64 = option_unwrapOr$1tvry1i(value, 0); + const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#owned[Symbol.dispose](); this.#state = 1; return _29; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class closuresFuture$closure3_closure0 { #state: number = 0; - #value: rt.u64; + #value: rs.u64; #lent: Guard.Guard; - constructor(value: rt.u64, lent: Guard.Guard) { + constructor(value: rs.u64, lent: Guard.Guard) { this.#value = value; this.#lent = lent; } @@ -660,38 +660,38 @@ export class closuresFuture$closure3_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const value: rt.u64 = this.#value; + const value: rs.u64 = this.#value; const _17: Guard.Guard = this.#lent; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(value, f)]; - Guard.note(_17, rt.fmtFormat(["peek ", args2[0]])); - const _0: rt.Poll = rt.u64Add(value, 1); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; + Guard.note(_17, rs.fmtFormat(["peek ", args2[0]])); + const _0: rs.Poll = rs.u64Add(value, 1); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class closuresFuture$closure4_closure0 { #state: number = 0; - #value: rt.u64; + #value: rs.u64; - constructor(value: rt.u64) { + constructor(value: rs.u64) { this.#value = value; } [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = rt.u64Mul(this.#value, 3); + const _0: rs.Poll = rs.u64Mul(this.#value, 3); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -709,23 +709,23 @@ export class closuresFuture$closure5_closure0 { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const id: rt.u32 = Guard.id(this.#moved); + const id: rs.u32 = Guard.id(this.#moved); this.#moved[Symbol.dispose](); this.#state = 1; return id; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class closuresFuture$closure6_closure0 { #state: number = 0; - #value: rt.u64; + #value: rs.u64; #last: Guard.Guard; - constructor(value: rt.u64, last: Guard.Guard) { + constructor(value: rs.u64, last: Guard.Guard) { this.#value = value; this.#last = last; } @@ -733,25 +733,25 @@ export class closuresFuture$closure6_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const value: rt.u64 = this.#value; + const value: rs.u64 = this.#value; const _16: Guard.Guard = this.#last; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(value, f)]; - Guard.note(_16, rt.fmtFormat(["last ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; + Guard.note(_16, rs.fmtFormat(["last ", args2[0]])); this.#state = 1; return value; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class closuresFuture$closure6_closure0_once { #state: number = 0; - #value: rt.u64; + #value: rs.u64; #last: Guard.Guard; - constructor(value: rt.u64, last: Guard.Guard) { + constructor(value: rs.u64, last: Guard.Guard) { this.#value = value; this.#last = last; } @@ -762,17 +762,17 @@ export class closuresFuture$closure6_closure0_once { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const value: rt.u64 = this.#value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(value, f)]; - const _6: string = rt.fmtFormat(["last ", args2[0]]); + const value: rs.u64 = this.#value; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; + const _6: string = rs.fmtFormat(["last ", args2[0]]); Guard.note(this.#last, _6); this.#last[Symbol.dispose](); this.#state = 1; return value; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -780,7 +780,7 @@ export class closuresFuture$closure7_closure0 { #state: number = 0; #rx: Consumer.Consumer; #boxed: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, boxed: Guard.Guard) { this.#rx = rx; @@ -789,29 +789,29 @@ export class closuresFuture$closure7_closure0 { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const value: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const value: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); const _27: Guard.Guard = this.#boxed; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u64Debug)]; - Guard.note(_27, rt.fmtFormat(["boxed ", args2[0]])); - const _0: rt.Poll = option_unwrapOr$1tvry1i(value, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; + Guard.note(_27, rs.fmtFormat(["boxed ", args2[0]])); + const _0: rs.Poll = option_unwrapOr$15hbiwd(value, 0); this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -819,7 +819,7 @@ export class closuresFuture$closure7_closure0_once { #state: number = 0; #rx: Consumer.Consumer; #boxed: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, boxed: Guard.Guard) { this.#rx = rx; @@ -830,31 +830,31 @@ export class closuresFuture$closure7_closure0_once { if (this.#state === 0) { this.#boxed[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#boxed[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const value: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(value, f, rt.u64Debug)]; - const _17: string = rt.fmtFormat(["boxed ", args2[0]]); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const value: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(value, f, rs.u64Debug)]; + const _17: string = rs.fmtFormat(["boxed ", args2[0]]); Guard.note(this.#boxed, _17); - const _29: rt.u64 = option_unwrapOr$1tvry1i(value, 0); + const _29: rs.u64 = option_unwrapOr$15hbiwd(value, 0); this.#boxed[Symbol.dispose](); this.#state = 1; return _29; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -869,13 +869,13 @@ export class closuresFuture$closure8_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { Guard.note(this.#made, "made"); this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -893,14 +893,14 @@ export class closuresFuture$closure8_closure0_once { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { Guard.note(this.#made, "made"); this.#made[Symbol.dispose](); this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -915,13 +915,13 @@ export class closuresFuture$closure9_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = Guard.id(this.#erased); + const _0: rs.Poll = Guard.id(this.#erased); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -939,14 +939,14 @@ export class closuresFuture$closure9_closure0_once { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _4: rt.u32 = Guard.id(this.#erased); + const _4: rs.u32 = Guard.id(this.#erased); this.#erased[Symbol.dispose](); this.#state = 1; return _4; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -961,13 +961,13 @@ export class closuresFuture$closure10_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = Guard.id(this.#unpolled); + const _0: rs.Poll = Guard.id(this.#unpolled); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -985,53 +985,53 @@ export class closuresFuture$closure10_closure0_once { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _4: rt.u32 = Guard.id(this.#unpolled); + const _4: rs.u32 = Guard.id(this.#unpolled); this.#unpolled[Symbol.dispose](); this.#state = 1; return _4; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class twiceFuture$closures_closures_closure0_closure0 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #saved!: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #saved!: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future) { + constructor(f: (a0: rs.u64) => rs.Future) { this.#f = f; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else if (this.#state === 4) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else { return; } } - poll(_2: rt.Context): rt.Poll { - let _35!: rt.u64 | undefined; + poll(_2: rs.Context): rs.Poll { + let _35!: rs.u64 | undefined; b0: { b1: { if (this.#state === 0) { this.#awaitee = this.#f(2); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { break b1; } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - const result: rt.u64 | undefined = _8; - rt.drop(this.#awaitee); - const _4: rt.u64 | undefined = result; + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + const result: rs.u64 | undefined = _8; + rs.drop(this.#awaitee); + const _4: rs.u64 | undefined = result; if (_4 !== undefined) { this.#saved = _4; this.#awaitee = this.#f(3); @@ -1041,22 +1041,22 @@ export class twiceFuture$closures_closures_closure0_closure0 { } } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _23: rt.Poll = this.#awaitee.poll(_2); - if (_23 !== rt.Pending) { - const result2: rt.u64 | undefined = _23; - rt.drop(this.#awaitee); - const _19: rt.u64 | undefined = result2; + const _23: rs.Poll = this.#awaitee.poll(_2); + if (_23 !== rs.Pending) { + const result2: rs.u64 | undefined = _23; + rs.drop(this.#awaitee); + const _19: rs.u64 | undefined = result2; if (_19 !== undefined) { - _35 = rt.u64Add(this.#saved, _19); + _35 = rs.u64Add(this.#saved, _19); } else { _35 = undefined; } } else { this.#state = 4; - return rt.Pending; + return rs.Pending; } } this.#state = 1; @@ -1066,185 +1066,185 @@ export class twiceFuture$closures_closures_closure0_closure0 { export class callOnceFuture$boxed_Box_closures_closures_closure0_closure7 { #state: number = 0; - #f: (a0: Consumer.Consumer) => rt.Future; + #f: (a0: Consumer.Consumer) => rs.Future; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; - constructor(f: (a0: Consumer.Consumer) => rt.Future, rx: Consumer.Consumer) { + constructor(f: (a0: Consumer.Consumer) => rs.Future, rx: Consumer.Consumer) { this.#f = f; this.#rx = rx; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#f); + rs.drop(this.#f); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - this.#awaitee = rt.callOnce(this.#f, this.#rx); + this.#awaitee = rs.callOnce(this.#f, this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class callOnceFuture$closures_closures_closure0_closure2 { #state: number = 0; - #f: (a0: Consumer.Consumer) => rt.Future; + #f: (a0: Consumer.Consumer) => rs.Future; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; - constructor(f: (a0: Consumer.Consumer) => rt.Future, rx: Consumer.Consumer) { + constructor(f: (a0: Consumer.Consumer) => rs.Future, rx: Consumer.Consumer) { this.#f = f; this.#rx = rx; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#f); + rs.drop(this.#f); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - this.#awaitee = rt.callOnce(this.#f, this.#rx); + this.#awaitee = rs.callOnce(this.#f, this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class callFuture$closures_adder_closure0 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#f(this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class callFuture$closures_closures_closure0_closure3 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#f(this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class callFuture$closures_closures_closure0_closure6 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#f(this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class throughFnFuture$closures_closures_closure0_closure4_closures_closures_closure0_closure4_closure0 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } @@ -1252,35 +1252,35 @@ export class throughFnFuture$closures_closures_closure0_closure4_closures_closur [Symbol.dispose](): void { if (this.#state !== 0) { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#f(this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class throughFnFuture$ref_closures_closures_closure0_closure3_closures_closures_closure0_closure3_closure0 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } @@ -1288,88 +1288,88 @@ export class throughFnFuture$ref_closures_closures_closure0_closure3_closures_cl [Symbol.dispose](): void { if (this.#state !== 0) { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = this.#f(this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class throughFnOnceFuture$closures_closures_closure0_closure6_closures_closures_closure0_closure6_closure0 { #state: number = 0; - #f: (a0: rt.u64) => rt.Future; - #value: rt.u64; - #awaitee!: rt.Future; + #f: (a0: rs.u64) => rs.Future; + #value: rs.u64; + #awaitee!: rs.Future; - constructor(f: (a0: rt.u64) => rt.Future, value: rt.u64) { + constructor(f: (a0: rs.u64) => rs.Future, value: rs.u64) { this.#f = f; this.#value = value; } [Symbol.dispose](): void { if (this.#state === 0) { - rt.drop(this.#f); + rs.drop(this.#f); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - this.#awaitee = rt.callOnce(this.#f, this.#value); + this.#awaitee = rs.callOnce(this.#f, this.#value); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll = this.#awaitee.poll(_2); - if (_8 !== rt.Pending) { - rt.drop(this.#awaitee); + const _8: rs.Poll = this.#awaitee.poll(_2); + if (_8 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** `f` as a `dyn FnOnce`. */ -export function erase$closures_closures_closure0_closure10_closures_closures_closure0_closure10_closure0(f: () => rt.Future): () => rt.Future { - return rt.once(f); +export function erase$closures_closures_closure0_closure10_closures_closures_closure0_closure10_closure0(f: () => rs.Future): () => rs.Future { + return rs.once(f); } /** `f` as a `dyn FnOnce`. */ -export function erase$closures_closures_closure0_closure9_closures_closures_closure0_closure9_closure0(f: () => rt.Future): () => rt.Future { - return rt.once(f); +export function erase$closures_closures_closure0_closure9_closures_closures_closure0_closure9_closure0(f: () => rs.Future): () => rs.Future { + return rs.once(f); } /** An async closure adding `n`. */ -export function adder(n: rt.u64): (a0: rt.u64) => rt.Future { +export function adder(n: rs.u64): (a0: rs.u64) => rs.Future { const captured = n; - return (value: rt.u64): rt.Future => { + return (value: rs.u64): rs.Future => { return new adderFuture$closure0_closure0(value, captured); }; } export class adderFuture$closure0_closure0 { #state: number = 0; - #value: rt.u64; - #n: rt.u64; + #value: rs.u64; + #n: rs.u64; - constructor(value: rt.u64, n: rt.u64) { + constructor(value: rs.u64, n: rs.u64) { this.#value = value; this.#n = n; } @@ -1377,13 +1377,13 @@ export class adderFuture$closure0_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = rt.u64Add(this.#value, this.#n); + const _0: rs.Poll = rs.u64Add(this.#value, this.#n); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } diff --git a/ts/fixtures/task/expected/core/bool.ts b/ts/fixtures/task/expected/core/bool.ts index 91ede7538..5dd9b4d7b 100644 --- a/ts/fixtures/task/expected/core/bool.ts +++ b/ts/fixtures/task/expected/core/bool.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Guard from "../model.Guard.ts"; export function thenSome$0zvoczk(self: boolean, t: Guard.Guard): Guard.Guard | undefined { @@ -20,23 +20,23 @@ export function thenSome$0zvoczk(self: boolean, t: Guard.Guard): Guard.Guard | u return _0; } -export function thenSome$1af3oea(self: boolean, t: rt.u32): rt.u32 | undefined { +export function thenSome$1bahm2u(self: boolean, t: rs.u32): rs.u32 | undefined { if (!self) { return undefined; } return t; } -export function thenSome$1j8foe9(self: boolean, _: undefined): undefined | rt.None { +export function thenSome$1n1oy1h(self: boolean, _: undefined): undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return undefined; } -export function then$06wuxll(self: boolean, f: () => Guard.Guard | undefined): Guard.Guard | undefined | rt.None { +export function then$0frk932(self: boolean, f: () => Guard.Guard | undefined): Guard.Guard | undefined | rs.None { if (!self) { - return rt.None; + return rs.None; } return f(); } @@ -48,8 +48,8 @@ export function then$1xpp3sz(self: boolean, f: () => Guard.Guard): Guard.Guard | return f(); } -export function then$1j9nint(self: boolean, f: () => rt.u32): rt.u32 | undefined { - let _0!: rt.u32 | undefined; +export function then$0awnlmn(self: boolean, f: () => rs.u32): rs.u32 | undefined { + let _0!: rs.u32 | undefined; let _5: boolean = false; _5 = true; if (!self) { @@ -59,30 +59,30 @@ export function then$1j9nint(self: boolean, f: () => rt.u32): rt.u32 | undefined _0 = f(); } if (_5) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function then$0kxuq3f(self: boolean, f: () => rt.u32): rt.u32 | undefined { - let _0!: rt.u32 | undefined; +export function then$04r7us0(self: boolean, f: () => rs.u32): rs.u32 | undefined { + let _0!: rs.u32 | undefined; let _5: boolean = false; _5 = true; if (!self) { _0 = undefined; } else { _5 = false; - _0 = rt.callOnce(f); + _0 = rs.callOnce(f); } if (_5) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function then$0ea5h05(self: boolean, f: () => rt.u32): rt.u32 | undefined { +export function then$0apfzgv(self: boolean, f: () => rs.u32): rs.u32 | undefined { if (!self) { return undefined; } diff --git a/ts/fixtures/task/expected/core/option.ts b/ts/fixtures/task/expected/core/option.ts index 4f7e423e9..dc66226a9 100644 --- a/ts/fixtures/task/expected/core/option.ts +++ b/ts/fixtures/task/expected/core/option.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Any from "../core/any.Any.ts"; import type * as Part from "../drops/objects.Part.ts"; import type * as Ranked from "../drops/orders.Ranked.ts"; @@ -31,232 +31,232 @@ export function unwrapOr$0v6ziq2(self: Guard.Guard | undefined, default_: Guard. return _0; } -export function unwrapOr$1tvry1i(self: rt.u64 | undefined, default_: rt.u64): rt.u64 { +export function unwrapOr$15hbiwd(self: rs.u64 | undefined, default_: rs.u64): rs.u64 { if (self === undefined) { return default_; } return self; } -export function map$0hegtde(self: Key.Key | undefined | rt.None, f: (a0: Key.Key | undefined) => rt.u32 | undefined): rt.u32 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$150c7g4(self: Key.Key | undefined | rs.None, f: (a0: Key.Key | undefined) => rs.u32 | undefined): rs.u32 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return f(self); } -export function map$0ccnsmq(self: Guard.Guard | undefined | rt.None, f: (a0: Guard.Guard | undefined) => rt.u32 | undefined): rt.u32 | undefined | rt.None { - if (self === rt.None) { - return rt.None; +export function map$1x5kkz1(self: Guard.Guard | undefined | rs.None, f: (a0: Guard.Guard | undefined) => rs.u32 | undefined): rs.u32 | undefined | rs.None { + if (self === rs.None) { + return rs.None; } return f(self); } -export function map$09vq4lk(self: Any.Any | undefined, f: (a0: Any.Any) => rt.Result): rt.Result | undefined { +export function map$0cuxp9c(self: Any.Any | undefined, f: (a0: Any.Any) => rs.Result): rs.Result | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0s8hob8(self: Part.Part | undefined, _: (a0: Part.Part) => rt.u32): rt.u32 | undefined { +export function map$0aiphi9(self: Part.Part | undefined, _: (a0: Part.Part) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return self.take$Part(); } -export function map$0782hf5(self: Key.Key | undefined, f: (a0: Key.Key) => rt.u32): rt.u32 | undefined { +export function map$0bmexgo(self: Key.Key | undefined, f: (a0: Key.Key) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1t2fqxi(self: Ranked.Ranked | undefined, f: (a0: Ranked.Ranked) => rt.u32): rt.u32 | undefined { +export function map$16oph0b(self: Ranked.Ranked | undefined, f: (a0: Ranked.Ranked) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1raha9y(self: Guard.Guard | undefined, f: (a0: Guard.Guard) => rt.u32): rt.u32 | undefined { +export function map$06w9waf(self: Guard.Guard | undefined, f: (a0: Guard.Guard) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$19e1ji3(self: rt.Result | undefined, f: (a0: rt.Result) => boolean): boolean | undefined { +export function map$0cktt1a(self: rs.Result | undefined, f: (a0: rs.Result) => boolean): boolean | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0lq7mno(self: Guard.Guard | undefined, _: (a0: Guard.Guard) => rt.u32): rt.u32 | undefined { +export function map$02u0dmi(self: Guard.Guard | undefined, _: (a0: Guard.Guard) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return Guard.id(self); } -export function map$06e51ml(self: rt.Arc<[Guard.Guard, Guard.Guard]> | undefined, f: (a0: rt.Arc<[Guard.Guard, Guard.Guard]>) => [rt.u32, rt.usize]): [rt.u32, rt.usize] | undefined { +export function map$0chhxcr(self: rs.Arc<[Guard.Guard, Guard.Guard]> | undefined, f: (a0: rs.Arc<[Guard.Guard, Guard.Guard]>) => [rs.u32, rs.usize]): [rs.u32, rs.usize] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$01pvlgn(self: [Guard.Guard, Guard.Guard] | undefined, f: (a0: [Guard.Guard, Guard.Guard]) => [rt.u32, rt.u32]): [rt.u32, rt.u32] | undefined { +export function map$0j32j8c(self: [Guard.Guard, Guard.Guard] | undefined, f: (a0: [Guard.Guard, Guard.Guard]) => [rs.u32, rs.u32]): [rs.u32, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$01vf10a(self: [Guard.Guard, Guard.Guard] | undefined, f: (a0: [Guard.Guard, Guard.Guard]) => rt.u32): rt.u32 | undefined { +export function map$0j94wbv(self: [Guard.Guard, Guard.Guard] | undefined, f: (a0: [Guard.Guard, Guard.Guard]) => rs.u32): rs.u32 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0uom32p(self: [Guard.Guard, rt.u32] | undefined, f: (a0: [Guard.Guard, rt.u32]) => [rt.u32, rt.u32]): [rt.u32, rt.u32] | undefined { +export function map$1nsn0pp(self: [Guard.Guard, rs.u32] | undefined, f: (a0: [Guard.Guard, rs.u32]) => [rs.u32, rs.u32]): [rs.u32, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$04djm2e(self: [[Guard.Guard, Guard.Guard], rt.u32] | undefined, f: (a0: [[Guard.Guard, Guard.Guard], rt.u32]) => [rt.u32, rt.u32, rt.u32]): [rt.u32, rt.u32, rt.u32] | undefined { +export function map$0zjm57m(self: [[Guard.Guard, Guard.Guard], rs.u32] | undefined, f: (a0: [[Guard.Guard, Guard.Guard], rs.u32]) => [rs.u32, rs.u32, rs.u32]): [rs.u32, rs.u32, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1s61o75(self: [[[Guard.Guard, Guard.Guard], rt.u32], rt.u32] | undefined, f: (a0: [[[Guard.Guard, Guard.Guard], rt.u32], rt.u32]) => [rt.u32, rt.u32, rt.u32, rt.u32]): [rt.u32, rt.u32, rt.u32, rt.u32] | undefined { +export function map$0ss4ft9(self: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32] | undefined, f: (a0: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]) => [rs.u32, rs.u32, rs.u32, rs.u32]): [rs.u32, rs.u32, rs.u32, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1uj27tb(self: [[[rt.usize, Guard.Guard], Guard.Guard], rt.u32] | undefined, f: (a0: [[[rt.usize, Guard.Guard], Guard.Guard], rt.u32]) => [rt.usize, rt.u32, rt.u32, rt.u32]): [rt.usize, rt.u32, rt.u32, rt.u32] | undefined { +export function map$1pp5yot(self: [[[rs.usize, Guard.Guard], Guard.Guard], rs.u32] | undefined, f: (a0: [[[rs.usize, Guard.Guard], Guard.Guard], rs.u32]) => [rs.usize, rs.u32, rs.u32, rs.u32]): [rs.usize, rs.u32, rs.u32, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1sprpgt(self: [[rt.usize, [Guard.Guard, Guard.Guard]], rt.i32] | undefined, f: (a0: [[rt.usize, [Guard.Guard, Guard.Guard]], rt.i32]) => [rt.usize, rt.u32, rt.i32]): [rt.usize, rt.u32, rt.i32] | undefined { +export function map$0nncxiz(self: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32] | undefined, f: (a0: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32]) => [rs.usize, rs.u32, rs.i32]): [rs.usize, rs.u32, rs.i32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$14zg54s(self: [rt.usize, Guard.Guard] | undefined, f: (a0: [rt.usize, Guard.Guard]) => [rt.usize, rt.u32]): [rt.usize, rt.u32] | undefined { +export function map$1389p4b(self: [rs.usize, Guard.Guard] | undefined, f: (a0: [rs.usize, Guard.Guard]) => [rs.usize, rs.u32]): [rs.usize, rs.u32] | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$0b0x7xy(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u32): rt.u32 | undefined { - let _0!: rt.u32 | undefined; +export function map$0cxn9jm(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u32): rs.u32 | undefined { + let _0!: rs.u32 | undefined; let _8: boolean = false; _8 = true; if (self === undefined) { _0 = undefined; } else { - const x: rt.u32 = self; + const x: rs.u32 = self; _8 = false; - _0 = rt.callOnce(f, x); + _0 = rs.callOnce(f, x); } if (_8) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function map$1thjygq(self: rt.u32 | undefined, f: (a0: rt.u32) => rt.u32): rt.u32 | undefined { - let _0!: rt.u32 | undefined; +export function map$1ol7nt5(self: rs.u32 | undefined, f: (a0: rs.u32) => rs.u32): rs.u32 | undefined { + let _0!: rs.u32 | undefined; let _8: boolean = false; _8 = true; if (self === undefined) { _0 = undefined; } else { - const x: rt.u32 = self; + const x: rs.u32 = self; _8 = false; _0 = f(x); } if (_8) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function map$0upmgd9(self: rt.u64 | undefined, f: (a0: rt.u64) => rt.Result): rt.Result | undefined { +export function map$1nux4ms(self: rs.u64 | undefined, f: (a0: rs.u64) => rs.Result): rs.Result | undefined { if (self === undefined) { return undefined; } return f(self); } -export function map$1cf8u0y(self: rt.u64 | undefined, f: (a0: rt.u64) => rt.u64): rt.u64 | undefined { +export function map$1haiqd3(self: rs.u64 | undefined, f: (a0: rs.u64) => rs.u64): rs.u64 | undefined { if (self === undefined) { return undefined; } return f(self); } -export function mapOr$184639r(self: rt.Vec | undefined, default_: rt.usize, f: (a0: rt.Vec) => rt.usize): rt.usize { +export function mapOr$090948l(self: rs.Vec | undefined, default_: rs.usize, f: (a0: rs.Vec) => rs.usize): rs.usize { if (self === undefined) { return default_; } return f(self); } -export function mapOr$00i7kb3(self: rt.Ordering | undefined, default_: rt.i8, f: (a0: rt.Ordering) => rt.i8): rt.i8 { +export function mapOr$16nkz0h(self: rs.Ordering | undefined, default_: rs.i8, f: (a0: rs.Ordering) => rs.i8): rs.i8 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1w10sgd(self: Key.Key | undefined, default_: rt.u32, f: (a0: Key.Key) => rt.u32): rt.u32 { +export function mapOr$0mko9ta(self: Key.Key | undefined, default_: rs.u32, f: (a0: Key.Key) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$01ozsk3(self: Guard.Guard | undefined, default_: rt.u32, f: (a0: Guard.Guard) => rt.u32): rt.u32 { +export function mapOr$1re20rq(self: Guard.Guard | undefined, default_: rs.u32, f: (a0: Guard.Guard) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$1jn2pas(self: Part.Part | undefined, default_: rt.u32, f: (a0: Part.Part) => rt.u32): rt.u32 { +export function mapOr$1uf7d6r(self: Part.Part | undefined, default_: rs.u32, f: (a0: Part.Part) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0lu2pr2(self: rt.Arc | undefined, default_: rt.u32, f: (a0: rt.Arc) => rt.u32): rt.u32 { +export function mapOr$1yfuqyd(self: rs.Arc | undefined, default_: rs.u32, f: (a0: rs.Arc) => rs.u32): rs.u32 { if (self === undefined) { return default_; } return f(self); } -export function mapOr$0ey19f0(self: rt.u32 | undefined, default_: Guard.Guard, f: (a0: rt.u32) => Guard.Guard): Guard.Guard { +export function mapOr$19gmzl7(self: rs.u32 | undefined, default_: Guard.Guard, f: (a0: rs.u32) => Guard.Guard): Guard.Guard { let _0!: Guard.Guard; let _9: boolean = false; _9 = true; @@ -273,33 +273,33 @@ export function mapOr$0ey19f0(self: rt.u32 | undefined, default_: Guard.Guard, f return _0; } -export function mapOr$0nrpycp(self: rt.u32 | undefined, default_: rt.u32, f: (a0: rt.u32) => rt.u32): rt.u32 { - let _0!: rt.u32; +export function mapOr$0lyy1bs(self: rs.u32 | undefined, default_: rs.u32, f: (a0: rs.u32) => rs.u32): rs.u32 { + let _0!: rs.u32; let _8: boolean = false; _8 = true; if (self === undefined) { _0 = default_; } else { - const t: rt.u32 = self; + const t: rs.u32 = self; _8 = false; _0 = f(t); } if (_8) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function okOr$1alhe7b(self: Guard.Guard | undefined, err: Guard.Guard): rt.Result { - let _0!: rt.Result; +export function okOr$0qyzozq(self: Guard.Guard | undefined, err: Guard.Guard): rs.Result { + let _0!: rs.Result; let _6: boolean = false; _6 = true; if (self === undefined) { _6 = false; - _0 = rt.Err(err); + _0 = rs.Err(err); } else { - _0 = rt.Ok(self); + _0 = rs.Ok(self); } if (_6) { err[Symbol.dispose](); @@ -308,11 +308,11 @@ export function okOr$1alhe7b(self: Guard.Guard | undefined, err: Guard.Guard): r return _0; } -export function okOr$03aiwur(self: rt.u64 | undefined, err: rt.u64): rt.Result { +export function okOr$1fxnv80(self: rs.u64 | undefined, err: rs.u64): rs.Result { if (self === undefined) { - return rt.Err(err); + return rs.Err(err); } - return rt.Ok(self); + return rs.Ok(self); } export function filter$1vqc90z(self: Guard.Guard | undefined, predicate: (a0: Guard.Guard) => boolean): Guard.Guard | undefined { @@ -327,7 +327,7 @@ export function filter$1vqc90z(self: Guard.Guard | undefined, predicate: (a0: Gu return undefined; } -export function orElse$02wco5t(self: Guard.Guard | undefined, f: () => Guard.Guard | undefined): Guard.Guard | undefined { +export function orElse$0gn8afw(self: Guard.Guard | undefined, f: () => Guard.Guard | undefined): Guard.Guard | undefined { let _0!: Guard.Guard | undefined; let _7: boolean = false; _7 = true; @@ -338,7 +338,7 @@ export function orElse$02wco5t(self: Guard.Guard | undefined, f: () => Guard.Gua _0 = self; } if (_7) { - rt.drop(self); + rs.drop(self); return _0; } return _0; @@ -379,11 +379,11 @@ export function zip$1rr0evn(self: Guard.Guard | undefined, other: Guard.Guard | return _0; } -export function clone$1sxxxkp(self: rt.Arc | undefined): rt.Arc | undefined { +export function clone$0cpy9zy(self: rs.Arc | undefined): rs.Arc | undefined { if (self === undefined) { return undefined; } - return rt.arcClone(self); + return rs.arcClone(self); } //# sourceMappingURL=option.ts.map diff --git a/ts/fixtures/task/expected/core/result.ts b/ts/fixtures/task/expected/core/result.ts index b70062126..7c106c0da 100644 --- a/ts/fixtures/task/expected/core/result.ts +++ b/ts/fixtures/task/expected/core/result.ts @@ -1,11 +1,11 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Result_model_Guard_model_Guard as lib_drop$Result_model_Guard_model_Guard, drop$Result_sync_Arc_tuple2_model_Guard_model_Guard_sync_Arc_dyn_Any_marker_Sync_marker_Send as lib_drop$Result_sync_Arc_tuple2_model_Guard_model_Guard_sync_Arc_dyn_Any_marker_Sync_marker_Send } from "../lib.ts"; import type * as Any from "../core/any.Any.ts"; import * as Guard from "../model.Guard.ts"; -export function ok$0rngk0g(self: rt.Result): Guard.Guard | undefined { +export function ok$0p21n6j(self: rs.Result): Guard.Guard | undefined { let _0!: Guard.Guard | undefined; if (self.ok) { _0 = self.value; @@ -19,8 +19,8 @@ export function ok$0rngk0g(self: rt.Result): Guard.Gua return _0; } -export function ok$02syyam(self: rt.Result, rt.Arc>): rt.Arc<[Guard.Guard, Guard.Guard]> | undefined { - let _0!: rt.Arc<[Guard.Guard, Guard.Guard]> | undefined; +export function ok$1xmzatr(self: rs.Result, rs.Arc>): rs.Arc<[Guard.Guard, Guard.Guard]> | undefined { + let _0!: rs.Arc<[Guard.Guard, Guard.Guard]> | undefined; if (self.ok) { _0 = self.value; } else { @@ -33,7 +33,7 @@ export function ok$02syyam(self: rt.Result, r return _0; } -export function err$126l6wy(self: rt.Result): Guard.Guard | undefined { +export function err$1guw4rh(self: rs.Result): Guard.Guard | undefined { let _0!: Guard.Guard | undefined; if (self.ok) { _0 = undefined; @@ -47,125 +47,125 @@ export function err$126l6wy(self: rt.Result): Guard.Gu return _0; } -export function asRef$1km6sxf(self: rt.Result): rt.Result { +export function asRef$165wjcp(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function asRef$01pd5k9(self: rt.Result): rt.Result { +export function asRef$0auemm6(self: rs.Result): rs.Result { if (self.ok) { - return rt.Ok(self.value); + return rs.Ok(self.value); } - return rt.Err(self.error); + return rs.Err(self.error); } -export function map$0k5r5cs(self: rt.Result, op: (a0: Guard.Guard) => rt.u32): rt.Result { +export function map$0k9xqln(self: rs.Result, op: (a0: Guard.Guard) => rs.u32): rs.Result { if (self.ok) { - return rt.Ok(op(self.value)); + return rs.Ok(op(self.value)); } - return self as rt.Result; + return self as rs.Result; } -export function map$1rk4yqp(self: rt.Result, op: (a0: rt.u32) => rt.u32): rt.Result { - let _0!: rt.Result; +export function map$1tajsw3(self: rs.Result, op: (a0: rs.u32) => rs.u32): rs.Result { + let _0!: rs.Result; let _9: boolean = false; _9 = true; if (self.ok) { - const t: rt.u32 = self.value; + const t: rs.u32 = self.value; _9 = false; - _0 = rt.Ok(op(t)); + _0 = rs.Ok(op(t)); } else { _0 = self; } if (_9) { - rt.drop(op); + rs.drop(op); return _0; } return _0; } -export function mapOr$1hlk3iq(self: rt.Result, default_: rt.u32, _: (a0: Guard.Guard) => rt.u32): rt.u32 { +export function mapOr$1g4n0cf(self: rs.Result, default_: rs.u32, _: (a0: Guard.Guard) => rs.u32): rs.u32 { if (self.ok) { return Guard.id(self.value); } return default_; } -export function mapOrElse$196aho3(self: rt.Result, default_: (a0: Guard.Guard) => rt.u32, f: (a0: Guard.Guard) => rt.u32): rt.u32 { +export function mapOrElse$0cjv9n5(self: rs.Result, default_: (a0: Guard.Guard) => rs.u32, f: (a0: Guard.Guard) => rs.u32): rs.u32 { if (self.ok) { return f(self.value); } return default_(self.error); } -export function mapErr$0nvqjog(self: rt.Result, op: (a0: Guard.Guard) => rt.u32): rt.Result { +export function mapErr$18fct1o(self: rs.Result, op: (a0: Guard.Guard) => rs.u32): rs.Result { if (self.ok) { - return self as rt.Result; + return self as rs.Result; } - return rt.Err(op(self.error)); + return rs.Err(op(self.error)); } -export function mapErr$1c43xsx(self: rt.Result, op: (a0: rt.u32) => rt.u32): rt.Result { - let _0!: rt.Result; +export function mapErr$04hu1u8(self: rs.Result, op: (a0: rs.u32) => rs.u32): rs.Result { + let _0!: rs.Result; let _9: boolean = false; _9 = true; if (self.ok) { _0 = self; } else { - const e: rt.u32 = self.error; + const e: rs.u32 = self.error; _9 = false; - _0 = rt.Err(op(e)); + _0 = rs.Err(op(e)); } if (_9) { - rt.drop(op); + rs.drop(op); return _0; } return _0; } -export function inspectErr$0hrcm18(self: rt.Result, f: (a0: rt.u32) => undefined): rt.Result { +export function inspectErr$1vjhjw3(self: rs.Result, f: (a0: rs.u32) => undefined): rs.Result { let _8: boolean = false; _8 = true; if (!self.ok) { _8 = false; f(self.error); } - const _0: rt.Result = self; + const _0: rs.Result = self; if (_8) { - rt.drop(f); + rs.drop(f); return _0; } return _0; } -export function andThen$0r804hk(self: rt.Result, _: (a0: Guard.Guard) => rt.Result): rt.Result { +export function andThen$1wsai1p(self: rs.Result, _: (a0: Guard.Guard) => rs.Result): rs.Result { if (self.ok) { - return rt.Err(self.value); + return rs.Err(self.value); } return self; } -export function andThen$1so3lx6(self: rt.Result, op: (a0: rt.u32) => rt.Result): rt.Result { - let _0!: rt.Result; +export function andThen$0wxwepe(self: rs.Result, op: (a0: rs.u32) => rs.Result): rs.Result { + let _0!: rs.Result; let _8: boolean = false; _8 = true; if (self.ok) { - const t: rt.u32 = self.value; + const t: rs.u32 = self.value; _8 = false; _0 = op(t); } else { _0 = self; } if (_8) { - rt.drop(op); + rs.drop(op); return _0; } return _0; } -export function unwrapOr$0urixfm(self: rt.Result, default_: Guard.Guard): Guard.Guard { +export function unwrapOr$19ff01h(self: rs.Result, default_: Guard.Guard): Guard.Guard { let _0!: Guard.Guard; let _5: boolean = false; _5 = true; diff --git a/ts/fixtures/task/expected/core/task/poll.ts b/ts/fixtures/task/expected/core/task/poll.ts index 1204528c7..5436a6c3b 100644 --- a/ts/fixtures/task/expected/core/task/poll.ts +++ b/ts/fixtures/task/expected/core/task/poll.ts @@ -1,89 +1,89 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function map$0luclc8(self: rt.Poll, f: (a0: rt.u64 | undefined) => rt.Result | undefined): rt.Poll | undefined> { - if (self !== rt.Pending) { +export function map$0u2hwi8(self: rs.Poll, f: (a0: rs.u64 | undefined) => rs.Result | undefined): rs.Poll | undefined> { + if (self !== rs.Pending) { return f(self); } - return rt.Pending; + return rs.Pending; } -export function map$034yafl(self: rt.Poll, f: (a0: rt.u64 | undefined) => rt.Result): rt.Poll> { - if (self !== rt.Pending) { +export function map$124wjfo(self: rs.Poll, f: (a0: rs.u64 | undefined) => rs.Result): rs.Poll> { + if (self !== rs.Pending) { return f(self); } - return rt.Pending; + return rs.Pending; } -export function map$1vdv176(self: rt.Poll, f: (a0: rt.u64 | undefined) => rt.u64): rt.Poll { - if (self !== rt.Pending) { +export function map$1a7g3ip(self: rs.Poll, f: (a0: rs.u64 | undefined) => rs.u64): rs.Poll { + if (self !== rs.Pending) { return f(self); } - return rt.Pending; + return rs.Pending; } -export function map$1rs8nqy(self: rt.Poll, _: (a0: rt.u64) => rt.u64 | undefined): rt.Poll { - if (self !== rt.Pending) { +export function map$1wr0dnp(self: rs.Poll, _: (a0: rs.u64) => rs.u64 | undefined): rs.Poll { + if (self !== rs.Pending) { return self; } - return rt.Pending; + return rs.Pending; } -export function map$1ooj6xj(self: rt.Poll, f: (a0: rt.u64) => rt.u64): rt.Poll { - if (self !== rt.Pending) { +export function map$1a7lmes(self: rs.Poll, f: (a0: rs.u64) => rs.u64): rs.Poll { + if (self !== rs.Pending) { return f(self); } - return rt.Pending; + return rs.Pending; } -export function isReady$0entgvk(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$1wybfmi(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isReady$0xd3q6j(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$158fdyi(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isReady$1sc8not(self: rt.Poll): boolean { - if (self !== rt.Pending) { +export function isReady$0mapnag(self: rs.Poll): boolean { + if (self !== rs.Pending) { return true; } return false; } -export function isPending$0vr1nz6(self: rt.Poll): boolean { - return !isReady$0entgvk(self); +export function isPending$0mrvg1b(self: rs.Poll): boolean { + return !isReady$1wybfmi(self); } -export function isPending$1xsrr9j(self: rt.Poll): boolean { - return !isReady$0xd3q6j(self); +export function isPending$04edpij(self: rs.Poll): boolean { + return !isReady$158fdyi(self); } -export function mapOk$051v09m(self: rt.Poll>, f: (a0: rt.u64) => rt.u64): rt.Poll> { - if (self !== rt.Pending) { +export function mapOk$0q2t3zp(self: rs.Poll>, f: (a0: rs.u64) => rs.u64): rs.Poll> { + if (self !== rs.Pending) { if (self.ok) { - return rt.Ok(f(self.value)); + return rs.Ok(f(self.value)); } return self; } - return rt.Pending; + return rs.Pending; } -export function mapErr$1yfeuu2(self: rt.Poll>, f: (a0: rt.u64) => rt.u64): rt.Poll> { - if (self !== rt.Pending) { +export function mapErr$1s7wmg4(self: rs.Poll>, f: (a0: rs.u64) => rs.u64): rs.Poll> { + if (self !== rs.Pending) { if (self.ok) { return self; } - return rt.Err(f(self.error)); + return rs.Err(f(self.error)); } - return rt.Pending; + return rs.Pending; } //# sourceMappingURL=poll.ts.map diff --git a/ts/fixtures/task/expected/drops.Held.ts b/ts/fixtures/task/expected/drops.Held.ts index ed223552c..fa137d923 100644 --- a/ts/fixtures/task/expected/drops.Held.ts +++ b/ts/fixtures/task/expected/drops.Held.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$drops_Held as lib_drop$drops_Held } from "./lib.ts"; import * as Guard from "./model.Guard.ts"; @@ -21,18 +21,18 @@ export function isSome(self: Held): boolean { } /** Consumes the box, dropping it on return. */ -export function take$drops_objects_Part(self: Held): rt.u32 { - const _0: rt.u32 = rt.u32WrappingAdd(id$drops_objects_Part(self), 1); +export function take$drops_objects_Part(self: Held): rs.u32 { + const _0: rs.u32 = rs.u32WrappingAdd(id$drops_objects_Part(self), 1); lib_drop$drops_Held(self); return _0; } -export function id$drops_objects_Part(self: Held): rt.u32 { +export function id$drops_objects_Part(self: Held): rs.u32 { if (self.tag === "One") { return Guard.id(self._0); } if (self.tag === "Two") { - return rt.u32Add(Guard.id(self._0), Guard.id(self._1)); + return rs.u32Add(Guard.id(self._0), Guard.id(self._1)); } return 0; } diff --git a/ts/fixtures/task/expected/drops.Key.ts b/ts/fixtures/task/expected/drops.Key.ts index 411713154..12d9010ca 100644 --- a/ts/fixtures/task/expected/drops.Key.ts +++ b/ts/fixtures/task/expected/drops.Key.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Log from "./log.Log.ts"; /** A key that logs its own drop, compared, ordered, and hashed by its id alone. */ export class Key { - id: rt.u32; + id: rs.u32; log: Log.Log; /** Whether its `Hash` logs each call. */ counted: boolean; - constructor(id: rt.u32, log: Log.Log, counted: boolean) { + constructor(id: rs.u32, log: Log.Log, counted: boolean) { this.id = id; this.log = log; this.counted = counted; @@ -22,14 +22,14 @@ export class Key { } } -function new_(id: rt.u32, log: Log.Log): Key { +function new_(id: rs.u32, log: Log.Log): Key { return new Key(id, log, false); } export function drop$ops_Drop(self: Key): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["k", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); Log.note(self.log, _4); self.id = 4294967295; } @@ -38,28 +38,28 @@ export function eq$cmp_PartialEq(self: Key, other: Key): boolean { return self.id === other.id; } -export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Key, other: Key): rs.Ordering | undefined { return cmp$cmp_Ord(self, other); } -export function cmp$cmp_Ord(self: Key, other: Key): rt.Ordering { - return rt.cmp(self.id, other.id); +export function cmp$cmp_Ord(self: Key, other: Key): rs.Ordering { + return rs.cmp(self.id, other.id); } -export function hash$Hash_hash_DefaultHasher(self: Key, state: rt.Hasher): void { +export function hash$Hash_hash_DefaultHasher(self: Key, state: rs.Hasher): void { if (self.counted) { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _6: string = rt.fmtFormat(["k", args2[0], " hashed"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _6: string = rs.fmtFormat(["k", args2[0], " hashed"]); Log.note(self.log, _6); } - rt.hash32(self.id, state); + rs.hash32(self.id, state); } export function clone$Clone(self: Key): Key { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["k", args2[0], " cloned"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["k", args2[0], " cloned"]); Log.note(self.log, _4); return new Key(self.id, Log.clone$Clone(self.log), self.counted); } diff --git a/ts/fixtures/task/expected/drops.Pair.ts b/ts/fixtures/task/expected/drops.Pair.ts index 34692b02c..27f2da869 100644 --- a/ts/fixtures/task/expected/drops.Pair.ts +++ b/ts/fixtures/task/expected/drops.Pair.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Guard from "./model.Guard.ts"; /** A generic type without a `Drop` impl, dropping its fields in order. */ @@ -14,7 +14,7 @@ export class Pair { } [Symbol.dispose](): void { - rt.drop(this.first); + rs.drop(this.first); this.second[Symbol.dispose](); } } diff --git a/ts/fixtures/task/expected/drops.Wrap.ts b/ts/fixtures/task/expected/drops.Wrap.ts index 7f8fb704f..2f78b4528 100644 --- a/ts/fixtures/task/expected/drops.Wrap.ts +++ b/ts/fixtures/task/expected/drops.Wrap.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$drops_Wrap_u32 as lib_drop$drops_Wrap_u32 } from "./lib.ts"; import type * as Held from "./drops.Held.ts"; import type * as Pair from "./drops.Pair.ts"; @@ -9,68 +9,68 @@ import type * as Guard from "./model.Guard.ts"; /** Logs its own drop before its fields', whatever it holds. */ export class Wrap { - id: rt.u32; + id: rs.u32; log: Log.Log; inner: T; - constructor(id: rt.u32, log: Log.Log, inner: T) { + constructor(id: rs.u32, log: Log.Log, inner: T) { this.id = id; this.log = log; this.inner = inner; } } -export function drop$ops_Drop_Vec_drops_Wrap_drops_Held(self: Wrap>>): void { +export function drop$ops_Drop_Vec_drops_Wrap_drops_Held(self: Wrap>>): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Held(self: Wrap): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_drops_Pair_drops_Held(self: Wrap>): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } export function drop$ops_Drop_model_Guard(self: Wrap): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } -export function drop$ops_Drop_sync_Arc_drops_Held(self: Wrap>): void { +export function drop$ops_Drop_sync_Arc_drops_Held(self: Wrap>): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } -export function drop$ops_Drop_u32(self: Wrap): void { +export function drop$ops_Drop_u32(self: Wrap): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["w", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["w", args2[0], " drop"]); Log.note(self.log, _4); } -export function id$drops_objects_Part_u32(self: Wrap): rt.u32 { +export function id$drops_objects_Part_u32(self: Wrap): rs.u32 { return self.id; } /** Consumes the box, dropping it on return. */ -export function take$drops_objects_Part_u32(self: Wrap): rt.u32 { - const id: rt.u32 = self.id; +export function take$drops_objects_Part_u32(self: Wrap): rs.u32 { + const id: rs.u32 = self.id; lib_drop$drops_Wrap_u32(self); - return rt.u32WrappingMul(id, 2); + return rs.u32WrappingMul(id, 2); } //# sourceMappingURL=drops.Wrap.ts.map diff --git a/ts/fixtures/task/expected/drops.ts b/ts/fixtures/task/expected/drops.ts index 559e9f4c6..5cb4bfd1f 100644 --- a/ts/fixtures/task/expected/drops.ts +++ b/ts/fixtures/task/expected/drops.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$Option_Result_model_Guard_u8 as lib_drop$Option_Result_model_Guard_u8, drop$Option_boxed_Box_drops_Held as lib_drop$Option_boxed_Box_drops_Held, drop$Option_drops_Held as lib_drop$Option_drops_Held, drop$Option_tuple2_model_Guard_model_Guard as lib_drop$Option_tuple2_model_Guard_model_Guard, drop$Result_model_Guard_model_Guard as lib_drop$Result_model_Guard_model_Guard, drop$Result_model_Guard_u8 as lib_drop$Result_model_Guard_u8, drop$drops_Held as lib_drop$drops_Held, drop$drops_Pair_drops_Held as lib_drop$drops_Pair_drops_Held, drop$drops_Wrap_Vec_drops_Wrap_drops_Held as lib_drop$drops_Wrap_Vec_drops_Wrap_drops_Held, drop$drops_Wrap_drops_Held as lib_drop$drops_Wrap_drops_Held, drop$drops_Wrap_drops_Pair_drops_Held as lib_drop$drops_Wrap_drops_Pair_drops_Held, drop$drops_Wrap_model_Guard as lib_drop$drops_Wrap_model_Guard, drop$drops_Wrap_sync_Arc_drops_Held as lib_drop$drops_Wrap_sync_Arc_drops_Held, drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held as lib_drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held, drop$sync_Mutex_drops_Held as lib_drop$sync_Mutex_drops_Held, drop$tuple2_drops_Key_drops_Key as lib_drop$tuple2_drops_Key_drops_Key, drop$tuple2_sync_Arc_str_sync_Arc_str as lib_drop$tuple2_sync_Arc_str_sync_Arc_str, out$u32 } from "./lib.ts"; import { thenSome$0zvoczk } from "./core/bool.ts"; -import { isSomeAnd$17cacqw, unwrapOr$0v6ziq2 as option_unwrapOr$0v6ziq2, unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$0hegtde as option_map$0hegtde, map$0ccnsmq as option_map$0ccnsmq, map$0782hf5 as option_map$0782hf5, map$0lq7mno as option_map$0lq7mno, mapOr$1w10sgd as option_mapOr$1w10sgd, mapOr$0ey19f0 as option_mapOr$0ey19f0, okOr$1alhe7b as option_okOr$1alhe7b, filter$1vqc90z, orElse$02wco5t as option_orElse$02wco5t, zip$1rr0evn, clone$1sxxxkp as option_clone$1sxxxkp } from "./core/option.ts"; -import { ok$0rngk0g, err$126l6wy, asRef$01pd5k9, mapOr$1hlk3iq as result_mapOr$1hlk3iq, mapOrElse$196aho3 as result_mapOrElse$196aho3, andThen$0r804hk as result_andThen$0r804hk, unwrapOr$0urixfm as result_unwrapOr$0urixfm } from "./core/result.ts"; +import { isSomeAnd$17cacqw, unwrapOr$0v6ziq2 as option_unwrapOr$0v6ziq2, unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$150c7g4 as option_map$150c7g4, map$1x5kkz1 as option_map$1x5kkz1, map$0bmexgo as option_map$0bmexgo, map$02u0dmi as option_map$02u0dmi, mapOr$0mko9ta as option_mapOr$0mko9ta, mapOr$19gmzl7 as option_mapOr$19gmzl7, okOr$0qyzozq as option_okOr$0qyzozq, filter$1vqc90z, orElse$0gn8afw as option_orElse$0gn8afw, zip$1rr0evn, clone$0cpy9zy as option_clone$0cpy9zy } from "./core/option.ts"; +import { ok$0p21n6j, err$1guw4rh, asRef$0auemm6, mapOr$1g4n0cf as result_mapOr$1g4n0cf, mapOrElse$0cjv9n5 as result_mapOrElse$0cjv9n5, andThen$1wsai1p as result_andThen$1wsai1p, unwrapOr$19ff01h as result_unwrapOr$19ff01h } from "./core/result.ts"; import { called as called_called } from "./drops/called.ts"; import { scoped, discarded, iterated } from "./drops/closures.ts"; import { flattened as flattened_flattened } from "./drops/flattened.ts"; @@ -30,8 +30,8 @@ import * as Log from "./log.Log.ts"; import * as Guard from "./model.Guard.ts"; /** Run trait object scenario `arg % 4`: boxed, shared, as `dyn Any`, or as `dyn Fn*`. */ -export function dyns(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const _4: rt.u8 = rt.u8Rem(arg, 4); +export function dyns(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const _4: rs.u8 = rs.u8Rem(arg, 4); if (_4 === 0) { objects_boxed(log, id); } else if (_4 === 1) { @@ -44,7 +44,7 @@ export function dyns(log: Log.Log, id: rt.u32, arg: rt.u8): void { } /** Run one-time cells' scenario `arg % 6`. */ -export function cells(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function cells(log: Log.Log, id: rs.u32, arg: rs.u8): void { once_run(log, id, arg); } @@ -52,11 +52,11 @@ export function cells(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Run scenario `arg % 16`: what every value std holds drops, where Rust drops it, and in * Rust's order. */ -export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const _6: rt.u8 = rt.u8Rem(arg, 16); + const _6: rs.u8 = rs.u8Rem(arg, 16); if (_6 === 15) { elements(log, id); } else if (_6 === 14) { @@ -82,109 +82,109 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else if (_6 === 7) { arcs(log, id); } else if (_6 === 0) { - const v: rt.Vec = new rt.Vec(); + const v: rs.Vec = new rs.Vec(); const _12 = { tag: "One", _0: guard(1) } as Held.Held; v.items.push(_12); v.items.push({ tag: "Empty" } as Held.Held); const _21 = { tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held; v.items.push(_21); - const held: rt.Vec = v; - const arc: rt.Arc = new rt.Arc({ tag: "One", _0: guard(4) } as Held.Held); - const shared: rt.Arc = rt.arcClone(arc); - rt.arcDrop(arc, lib_drop$drops_Held); + const held: rs.Vec = v; + const arc: rs.Arc = new rs.Arc({ tag: "One", _0: guard(4) } as Held.Held); + const shared: rs.Arc = rs.arcClone(arc); + rs.arcDrop(arc, lib_drop$drops_Held); const part5 = shared.strong; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part5, f)]; - Log.note(log, rt.fmtFormat(["arc ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; + Log.note(log, rs.fmtFormat(["arc ", args2[0]])); const part6 = shared.strong; - const cloned: rt.Arc = rt.arcClone(shared); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part6, f)]; - Log.note(log, rt.fmtFormat(["counted ", args4[0]])); - rt.arcDrop(cloned, lib_drop$drops_Held); - const v2: rt.Vec = new rt.Vec(); + const cloned: rs.Arc = rs.arcClone(shared); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; + Log.note(log, rs.fmtFormat(["counted ", args4[0]])); + rs.arcDrop(cloned, lib_drop$drops_Held); + const v2: rs.Vec = new rs.Vec(); const _70 = { tag: "One", _0: guard(5) } as Held.Held; v2.items.push(_70); - const mutex: rt.Mutex> = new rt.Mutex(v2); + const mutex: rs.Mutex> = new rs.Mutex(v2); const boxed: Held.Held = { tag: "Two", _0: guard(6), _1: guard(7) }; const maybe = ({ tag: "One", _0: guard(8) } as Held.Held) as Held.Held | undefined; - const _94: rt.usize = held.items.length; + const _94: rs.usize = held.items.length; const _97: boolean = maybe !== undefined; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_94, f), (f: rt.Formatter) => rt.fmtBool(_97, f)]; - Log.note(log, rt.fmtFormat(["held ", args6[0], " ", args6[1]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_94, f), (f: rs.Formatter) => rs.fmtBool(_97, f)]; + Log.note(log, rs.fmtFormat(["held ", args6[0], " ", args6[1]])); lib_drop$drops_Held(boxed); - rt.dropVec(mutex.value, lib_drop$drops_Held); + rs.dropVec(mutex.value, lib_drop$drops_Held); lib_drop$Option_boxed_Box_drops_Held(maybe); - rt.arcDrop(shared, lib_drop$drops_Held); - rt.dropVec(held, lib_drop$drops_Held); + rs.arcDrop(shared, lib_drop$drops_Held); + rs.dropVec(held, lib_drop$drops_Held); } else if (_6 === 1) { - const wrapped: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 10), Log.clone$Clone(log), { tag: "One", _0: guard(11) } as Held.Held); - const guarded: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 20), Log.clone$Clone(log), guard(21)); + const wrapped: Wrap.Wrap = new Wrap.Wrap(rs.u32Add(id, 10), Log.clone$Clone(log), { tag: "One", _0: guard(11) } as Held.Held); + const guarded: Wrap.Wrap = new Wrap.Wrap(rs.u32Add(id, 20), Log.clone$Clone(log), guard(21)); const pair: Pair.Pair = new Pair.Pair({ tag: "Two", _0: guard(31), _1: guard(32) } as Held.Held, guard(33)); - const v3: rt.Vec> = new rt.Vec(); + const v3: rs.Vec> = new rs.Vec(); const _136: Pair.Pair = new Pair.Pair(guard(41), guard(42)); v3.items.push(_136); const _145: Pair.Pair = new Pair.Pair(guard(43), guard(44)); v3.items.push(_145); - const pairs: rt.Vec> = v3; + const pairs: rs.Vec> = v3; const _owned: Named.Named = new Named.Named({ tag: "Owned", _0: guard(45) } as Text.Text); - const _161: rt.u32 = rt.u32Add(id, 50); + const _161: rs.u32 = rs.u32Add(id, 50); const _163: Log.Log = Log.clone$Clone(log); - const v4: rt.Vec> = new rt.Vec(); + const v4: rs.Vec> = new rs.Vec(); const _borrowed: Named.Named = new Named.Named({ tag: "Borrowed", _0: "text" } as Text.Text); - const _168: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 60), Log.clone$Clone(log), { tag: "One", _0: guard(61) } as Held.Held); + const _168: Wrap.Wrap = new Wrap.Wrap(rs.u32Add(id, 60), Log.clone$Clone(log), { tag: "One", _0: guard(61) } as Held.Held); v4.items.push(_168); - const nested: Wrap.Wrap>> = new Wrap.Wrap(_161, _163, v4); + const nested: Wrap.Wrap>> = new Wrap.Wrap(_161, _163, v4); lib_drop$drops_Pair_drops_Held(pair); const _183: boolean = Held.isSome(wrapped.inner); - const _186: rt.u32 = Guard.id(guarded.inner); - const _189: rt.u32 = rt.u32Add(rt.u32Add(Guard.id(pairs.items[rt.idx(pairs.items, 1)].first), Guard.id(pairs.items[rt.idx(pairs.items, 0)].second)), nested.inner.items.length as rt.u32); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_183, f), (f: rt.Formatter) => rt.u32Display(_186, f), (f: rt.Formatter) => rt.u32Display(_189, f)]; - Log.note(log, rt.fmtFormat(["wraps ", args8[0], " ", args8[1], " ", args8[2]])); + const _186: rs.u32 = Guard.id(guarded.inner); + const _189: rs.u32 = rs.u32Add(rs.u32Add(Guard.id(pairs.items[rs.idx(pairs.items, 1)].first), Guard.id(pairs.items[rs.idx(pairs.items, 0)].second)), nested.inner.items.length as rs.u32); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.u32Display(_186, f), (f: rs.Formatter) => rs.u32Display(_189, f)]; + Log.note(log, rs.fmtFormat(["wraps ", args8[0], " ", args8[1], " ", args8[2]])); lib_drop$drops_Wrap_Vec_drops_Wrap_drops_Held(nested); _owned[Symbol.dispose](); _borrowed[Symbol.dispose](); - rt.dropVec(pairs); + rs.dropVec(pairs); lib_drop$drops_Wrap_model_Guard(guarded); lib_drop$drops_Wrap_drops_Held(wrapped); } else if (_6 === 2) { - const shared2: rt.Arc>> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 70), Log.clone$Clone(log), new Pair.Pair({ tag: "One", _0: guard(71) } as Held.Held, guard(72)))); - const v5: rt.Vec>>> = new rt.Vec(); - const _227: rt.Arc>> = rt.arcClone(shared2); + const shared2: rs.Arc>> = new rs.Arc(new Wrap.Wrap(rs.u32Add(id, 70), Log.clone$Clone(log), new Pair.Pair({ tag: "One", _0: guard(71) } as Held.Held, guard(72)))); + const v5: rs.Vec>>> = new rs.Vec(); + const _227: rs.Arc>> = rs.arcClone(shared2); v5.items.push(_227); - const _231: rt.Arc>> = rt.arcClone(shared2); + const _231: rs.Arc>> = rs.arcClone(shared2); v5.items.push(_231); - const clones: rt.Vec>>> = v5; - rt.arcDrop(shared2, lib_drop$drops_Wrap_drops_Pair_drops_Held); + const clones: rs.Vec>>> = v5; + rs.arcDrop(shared2, lib_drop$drops_Wrap_drops_Pair_drops_Held); const part2 = clones.items.length; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part2, f)]; - Log.note(log, rt.fmtFormat(["clones ", args10[0]])); - const part3: rt.u32 | undefined = bail(log, id, true); - const err: rt.u32 | undefined = part3 === undefined ? out$u32.err as rt.u32 : undefined; - const part4: rt.u32 | undefined = bail(log, rt.u32Add(id, 2), false); - const err2: rt.u32 | undefined = part4 === undefined ? out$u32.err as rt.u32 : undefined; - const _256: boolean = !((err !== undefined ? rt.Err(err as rt.u32) : rt.Ok(part3 as rt.u32)) as rt.Result).ok; - const _259: boolean = !((err2 !== undefined ? rt.Err(err2 as rt.u32) : rt.Ok(part4 as rt.u32)) as rt.Result).ok; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_256, f), (f: rt.Formatter) => rt.fmtBool(_259, f)]; - Log.note(log, rt.fmtFormat(["bailed ", args12[0], " ", args12[1]])); - rt.dropVec(clones, lib_drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; + Log.note(log, rs.fmtFormat(["clones ", args10[0]])); + const part3: rs.u32 | undefined = bail(log, id, true); + const err: rs.u32 | undefined = part3 === undefined ? out$u32.err as rs.u32 : undefined; + const part4: rs.u32 | undefined = bail(log, rs.u32Add(id, 2), false); + const err2: rs.u32 | undefined = part4 === undefined ? out$u32.err as rs.u32 : undefined; + const _256: boolean = !((err !== undefined ? rs.Err(err as rs.u32) : rs.Ok(part3 as rs.u32)) as rs.Result).ok; + const _259: boolean = !((err2 !== undefined ? rs.Err(err2 as rs.u32) : rs.Ok(part4 as rs.u32)) as rs.Result).ok; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_256, f), (f: rs.Formatter) => rs.fmtBool(_259, f)]; + Log.note(log, rs.fmtFormat(["bailed ", args12[0], " ", args12[1]])); + rs.dropVec(clones, lib_drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held); } else { - const arc2: rt.Arc> = new rt.Arc(new rt.Mutex({ tag: "Two", _0: guard(81), _1: guard(82) } as Held.Held)); - const other: rt.Arc> = rt.arcClone(arc2); - rt.arcDrop(arc2, lib_drop$sync_Mutex_drops_Held); - const _281: rt.Mutex = rt.mutexLock(other.value); + const arc2: rs.Arc> = new rs.Arc(new rs.Mutex({ tag: "Two", _0: guard(81), _1: guard(82) } as Held.Held)); + const other: rs.Arc> = rs.arcClone(arc2); + rs.arcDrop(arc2, lib_drop$sync_Mutex_drops_Held); + const _281: rs.Mutex = rs.mutexLock(other.value); const held2: boolean = Held.isSome(_281.value); - rt.mutexUnlock(_281); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(held2, f)]; - Log.note(log, rt.fmtFormat(["locked ", args14[0]])); + rs.mutexUnlock(_281); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(held2, f)]; + Log.note(log, rs.fmtFormat(["locked ", args14[0]])); const lent: Guard.Guard = guard(83); - const borrowed: rt.Arc = new rt.Arc(lent); - const again: rt.Arc = rt.arcClone(borrowed); - rt.arcDrop(borrowed); - rt.arcDrop(again); + const borrowed: rs.Arc = new rs.Arc(lent); + const again: rs.Arc = rs.arcClone(borrowed); + rs.arcDrop(borrowed); + rs.arcDrop(again); const part = Guard.id(lent); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["lent ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["lent ", args16[0]])); lent[Symbol.dispose](); - rt.arcDrop(other, lib_drop$sync_Mutex_drops_Held); + rs.arcDrop(other, lib_drop$sync_Mutex_drops_Held); } } @@ -192,32 +192,32 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Returns early through `?`, if it `fails`, with an enum's guards and a generic `Drop` * type live. */ -export function bail(log: Log.Log, id: rt.u32, fails: boolean): rt.u32 | undefined { +export function bail(log: Log.Log, id: rs.u32, fails: boolean): rs.u32 | undefined { let _0Err!: boolean; - let _02!: rt.u32; - let _03!: rt.u32; - const v: rt.Vec = new rt.Vec(); - const _8 = { tag: "One", _0: Guard.new(rt.u32Add(id, 90), Log.clone$Clone(log)) } as Held.Held; + let _02!: rs.u32; + let _03!: rs.u32; + const v: rs.Vec = new rs.Vec(); + const _8 = { tag: "One", _0: Guard.new(rs.u32Add(id, 90), Log.clone$Clone(log)) } as Held.Held; v.items.push(_8); - const held: rt.Vec = v; - const wrap: Wrap.Wrap = new Wrap.Wrap(rt.u32Add(id, 91), Log.clone$Clone(log), { tag: "Empty" } as Held.Held); - const part: rt.u32 | undefined = failed(fails); - const err: rt.u32 | undefined = part === undefined ? out$u32.err as rt.u32 : undefined; + const held: rs.Vec = v; + const wrap: Wrap.Wrap = new Wrap.Wrap(rs.u32Add(id, 91), Log.clone$Clone(log), { tag: "Empty" } as Held.Held); + const part: rs.u32 | undefined = failed(fails); + const err: rs.u32 | undefined = part === undefined ? out$u32.err as rs.u32 : undefined; if (err === undefined) { - const n: rt.u32 = part as rt.u32; - const _29: rt.usize = held.items.length; + const n: rs.u32 = part as rs.u32; + const _29: rs.usize = held.items.length; const _32: boolean = Held.isSome(wrap.inner); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_29, f), (f: rt.Formatter) => rt.fmtBool(_32, f)]; - Log.note(log, rt.fmtFormat(["not bailed ", args2[0], " ", args2[1]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_29, f), (f: rs.Formatter) => rs.fmtBool(_32, f)]; + Log.note(log, rs.fmtFormat(["not bailed ", args2[0], " ", args2[1]])); _0Err = false; _02 = n; lib_drop$drops_Wrap_drops_Held(wrap); - rt.dropVec(held, lib_drop$drops_Held); + rs.dropVec(held, lib_drop$drops_Held); } else { _0Err = true; - _03 = err as rt.u32; + _03 = err as rs.u32; lib_drop$drops_Wrap_drops_Held(wrap); - rt.dropVec(held, lib_drop$drops_Held); + rs.dropVec(held, lib_drop$drops_Held); } if (_0Err) { out$u32.err = _03; @@ -226,7 +226,7 @@ export function bail(log: Log.Log, id: rt.u32, fails: boolean): rt.u32 | undefin return _02; } -export function failed(fails: boolean): rt.u32 | undefined { +export function failed(fails: boolean): rs.u32 | undefined { if (!fails) { return 1; } @@ -238,7 +238,7 @@ export function failed(fails: boolean): rt.u32 | undefined { * Holds an enum's guards in std types and a generic `Drop` type across an await, * which a cancel drops. */ -export function held(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function held(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new heldFuture(rx, guard); } @@ -247,10 +247,10 @@ export class heldFuture { #rx: Consumer.Consumer; #guard: Guard.Guard; #log!: Log.Log; - #id!: rt.u32; - #held!: rt.Vec; - #wrap!: Wrap.Wrap>; - #awaitee!: rt.Future; + #id!: rs.u32; + #held!: rs.Vec; + #wrap!: Wrap.Wrap>; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { this.#rx = rx; @@ -262,42 +262,42 @@ export class heldFuture { this.#rx[Symbol.dispose](); this.#guard[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); lib_drop$drops_Wrap_sync_Arc_drops_Held(this.#wrap); - rt.dropVec(this.#held, lib_drop$drops_Held); + rs.dropVec(this.#held, lib_drop$drops_Held); this.#log[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#log = Log.clone$Clone(Guard.log(this.#guard)); this.#id = Guard.id(this.#guard); - const v: rt.Vec = new rt.Vec(); - const _9 = { tag: "One", _0: Guard.new(rt.u32Add(this.#id, 500), Log.clone$Clone(this.#log)) } as Held.Held; + const v: rs.Vec = new rs.Vec(); + const _9 = { tag: "One", _0: Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)) } as Held.Held; v.items.push(_9); v.items.push({ tag: "Empty" } as Held.Held); this.#held = v; - this.#wrap = new Wrap.Wrap(rt.u32Add(this.#id, 510), Log.clone$Clone(this.#log), new rt.Arc({ tag: "One", _0: Guard.new(rt.u32Add(this.#id, 520), Log.clone$Clone(this.#log)) } as Held.Held)); + this.#wrap = new Wrap.Wrap(rs.u32Add(this.#id, 510), Log.clone$Clone(this.#log), new rs.Arc({ tag: "One", _0: Guard.new(rs.u32Add(this.#id, 520), Log.clone$Clone(this.#log)) } as Held.Held)); this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _36: rt.Poll = this.#awaitee.poll(_2); - if (_36 !== rt.Pending) { - const result: rt.u64 | undefined = _36; - rt.drop(this.#awaitee); - const value: rt.u64 = option_unwrapOr$1tvry1i(result, 0); - const _51: rt.usize = this.#held.items.length; + const _36: rs.Poll = this.#awaitee.poll(_2); + if (_36 !== rs.Pending) { + const result: rs.u64 | undefined = _36; + rs.drop(this.#awaitee); + const value: rs.u64 = option_unwrapOr$15hbiwd(result, 0); + const _51: rs.usize = this.#held.items.length; const _54: boolean = Held.isSome(this.#wrap.inner.value); const arg = this.#id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.usizeDisplay(_51, f), (f: rt.Formatter) => rt.fmtBool(_54, f)]; - const _46: string = rt.fmtFormat(["g", args2[0], " held ", args2[1], " ", args2[2]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.usizeDisplay(_51, f), (f: rs.Formatter) => rs.fmtBool(_54, f)]; + const _46: string = rs.fmtFormat(["g", args2[0], " held ", args2[1], " ", args2[2]]); Log.note(this.#log, _46); lib_drop$drops_Wrap_sync_Arc_drops_Held(this.#wrap); - rt.dropVec(this.#held, lib_drop$drops_Held); + rs.dropVec(this.#held, lib_drop$drops_Held); this.#log[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); @@ -305,7 +305,7 @@ export class heldFuture { return value; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -314,305 +314,305 @@ export class heldFuture { * `insert` and `entry` find there already, the key `remove` takes out, the value * `or_insert` is given, and what `retain`, `truncate`, and `clear` discard. */ -export function ordered(log: Log.Log, id: rt.u32): void { - let _208!: rt.u32; - let _267!: rt.u32; - const key: (a0: rt.u32) => Key.Key = (n6: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n6), Log.clone$Clone(log)); +export function ordered(log: Log.Log, id: rs.u32): void { + let _208!: rs.u32; + let _267!: rs.u32; + const key: (a0: rs.u32) => Key.Key = (n6: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n6), Log.clone$Clone(log)); }; - const guard: (a0: rt.u32) => Guard.Guard = (n7: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n7), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n7: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n7), Log.clone$Clone(log)); }; - const map: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; + const map: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; const _10: Key.Key = key(1); const _13: Guard.Guard = guard(1); - rt.drop(rt.btreeInsert(map, _10, _13, rt.drop)); + rs.drop(rs.btreeInsert(map, _10, _13, rs.drop)); const _18: Key.Key = key(2); const _21: Guard.Guard = guard(2); - rt.drop(rt.btreeInsert(map, _18, _21, rt.drop)); + rs.drop(rs.btreeInsert(map, _18, _21, rs.drop)); const _26: Key.Key = key(3); const _29: Guard.Guard = guard(3); - rt.drop(rt.btreeInsert(map, _26, _29, rt.drop)); + rs.drop(rs.btreeInsert(map, _26, _29, rs.drop)); const _34: Key.Key = key(1); const _37: Guard.Guard = guard(4); - const old: Guard.Guard | undefined = rt.btreeInsert(map, _34, _37, rt.drop); + const old: Guard.Guard | undefined = rs.btreeInsert(map, _34, _37, rs.drop); const part = old !== undefined; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - Log.note(log, rt.fmtFormat(["replaced ", args2[0]])); - rt.drop(old); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + Log.note(log, rs.fmtFormat(["replaced ", args2[0]])); + rs.drop(old); const _56: Key.Key = key(2); - const removed: Guard.Guard | undefined = rt.btreeRemove(map, _56, rt.drop); + const removed: Guard.Guard | undefined = rs.btreeRemove(map, _56, rs.drop); _56[Symbol.dispose](); const part2 = removed !== undefined; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; - Log.note(log, rt.fmtFormat(["removed ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; + Log.note(log, rs.fmtFormat(["removed ", args4[0]])); const _74: Key.Key = key(3); - const _72: rt.Entry = rt.entry(map, _74, rt.drop); - if (!rt.entryOccupied(_72)) { - Log.note(log, rt.fmtFormat(["vacant"])); + const _72: rs.Entry = rs.entry(map, _74, rs.drop); + if (!rs.entryOccupied(_72)) { + Log.note(log, rs.fmtFormat(["vacant"])); } else { - const _86: Guard.Guard = rt.entryRemove(_72, rt.drop); + const _86: Guard.Guard = rs.entryRemove(_72, rs.drop); const part3 = Guard.id(_86); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - const _80: string = rt.fmtFormat(["occupied ", args6[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + const _80: string = rs.fmtFormat(["occupied ", args6[0]]); _86[Symbol.dispose](); Log.note(log, _80); } - if (!rt.entryOccupied(_72)) { - rt.entryDrop(_72, rt.drop); + if (!rs.entryOccupied(_72)) { + rs.entryDrop(_72, rs.drop); } const _96: Key.Key = key(5); - const _94: rt.Entry = rt.entry(map, _96, rt.drop); - if (!rt.entryOccupied(_94)) { - const e2: rt.Entry = _94; - const part4 = rt.entryKey(e2).id; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["left ", args8[0]])); + const _94: rs.Entry = rs.entry(map, _96, rs.drop); + if (!rs.entryOccupied(_94)) { + const e2: rs.Entry = _94; + const part4 = rs.entryKey(e2).id; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["left ", args8[0]])); e2.k[Symbol.dispose](); } const _118: Key.Key = key(1); - const kept: rt.u32 = Guard.id(rt.entryOrInsert(rt.entry(map, _118, rt.drop), guard(6), rt.drop)); + const kept: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _118, rs.drop), guard(6), rs.drop)); const _129: Key.Key = key(7); - const added: rt.u32 = Guard.id(rt.entryOrInsert(rt.entry(map, _129, rt.drop), guard(7), rt.drop)); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(kept, f), (f: rt.Formatter) => rt.u32Display(added, f)]; - Log.note(log, rt.fmtFormat(["or_insert ", args10[0], " ", args10[1]])); + const added: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _129, rs.drop), guard(7), rs.drop)); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; + Log.note(log, rs.fmtFormat(["or_insert ", args10[0], " ", args10[1]])); const _149: Key.Key = key(8); const _152: Guard.Guard = guard(8); - rt.drop(rt.btreeInsert(map, _149, _152, rt.drop)); - rt.btreeRetain(map, (k: Key.Key, _33: Guard.Guard): boolean => { - return rt.u32Rem(k.id, 2) === 0; - }, rt.drop, rt.drop); - const set: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; + rs.drop(rs.btreeInsert(map, _149, _152, rs.drop)); + rs.btreeRetain(map, (k: Key.Key, _33: Guard.Guard): boolean => { + return rs.u32Rem(k.id, 2) === 0; + }, rs.drop, rs.drop); + const set: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; const _160: Key.Key = key(10); - rt.btreeAdd(set, _160, rt.drop); + rs.btreeAdd(set, _160, rs.drop); const _165: Key.Key = key(11); - rt.btreeAdd(set, _165, rt.drop); + rs.btreeAdd(set, _165, rs.drop); const _176: Key.Key = key(10); - const part5 = rt.btreeAdd(set, _176, rt.drop); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; - Log.note(log, rt.fmtFormat(["again ", args12[0]])); + const part5 = rs.btreeAdd(set, _176, rs.drop); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; + Log.note(log, rs.fmtFormat(["again ", args12[0]])); const _192: Key.Key = key(11); - const part6 = rt.btreeDelete(set, _192, rt.drop); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part6, f)]; - const _185: string = rt.fmtFormat(["gone ", args14[0]]); + const part6 = rs.btreeDelete(set, _192, rs.drop); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; + const _185: string = rs.fmtFormat(["gone ", args14[0]]); _192[Symbol.dispose](); Log.note(log, _185); const _201: Key.Key = key(12); - rt.btreeAdd(set, _201, rt.drop); - const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; - let iterStart: rt.u32 = 20; - const iterEnd: rt.u32 = 26; + rs.btreeAdd(set, _201, rs.drop); + const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; + let iterStart: rs.u32 = 20; + const iterEnd: rs.u32 = 26; while ((_208 = iterStart++) < iterEnd) { const _214: Guard.Guard = guard(_208); - rt.dequePushBack(queue, _214); + rs.dequePushBack(queue, _214); } const _219: Guard.Guard = guard(19); - rt.dequePushFront(queue, _219); - rt.dequeRetain(queue, (g: Guard.Guard): boolean => { - return rt.u32Rem(Guard.id(g), 3) !== 0; - }, rt.drop); - rt.dequeTruncate(queue, 2, rt.drop); + rs.dequePushFront(queue, _219); + rs.dequeRetain(queue, (g: Guard.Guard): boolean => { + return rs.u32Rem(Guard.id(g), 3) !== 0; + }, rs.drop); + rs.dequeTruncate(queue, 2, rs.drop); const part7 = queue.n; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; - Log.note(log, rt.fmtFormat(["queue ", args16[0]])); - rt.btreeClear(map, rt.drop, rt.drop); - rt.btreeClear(set, rt.drop); - const _248: rt.usize = rt.btreeLen(map); - const _251: rt.usize = rt.btreeLen(set); - const _254: rt.usize = queue.n; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_248, f), (f: rt.Formatter) => rt.usizeDisplay(_251, f), (f: rt.Formatter) => rt.usizeDisplay(_254, f)]; - Log.note(log, rt.fmtFormat(["left ", args18[0], " ", args18[1], " ", args18[2]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; + Log.note(log, rs.fmtFormat(["queue ", args16[0]])); + rs.btreeClear(map, rs.drop, rs.drop); + rs.btreeClear(set, rs.drop); + const _248: rs.usize = rs.btreeLen(map); + const _251: rs.usize = rs.btreeLen(set); + const _254: rs.usize = queue.n; + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_248, f), (f: rs.Formatter) => rs.usizeDisplay(_251, f), (f: rs.Formatter) => rs.usizeDisplay(_254, f)]; + Log.note(log, rs.fmtFormat(["left ", args18[0], " ", args18[1], " ", args18[2]])); const sink: Log.Log = Log.new(); - const many: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; - let iterStart2: rt.u32 = 0; - const iterEnd2: rt.u32 = 400; + const many: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; + let iterStart2: rs.u32 = 0; + const iterEnd2: rs.u32 = 400; while ((_267 = iterStart2++) < iterEnd2) { const _273: Key.Key = Key.new(_267, Log.clone$Clone(sink)); - rt.btreeAdd(many, _273, rt.drop); + rs.btreeAdd(many, _273, rs.drop); } - const found: (a0: rt.BTreeSet) => rt.usize = (many2: rt.BTreeSet): rt.usize => { - return rt.iterCount(rt.iterFilter(new rt.Range(0, 400), (_2: rt.u32): boolean => { + const found: (a0: rs.BTreeSet) => rs.usize = (many2: rs.BTreeSet): rs.usize => { + return rs.iterCount(rs.iterFilter(new rs.Range(0, 400), (_2: rs.u32): boolean => { const _57: Key.Key = Key.new(_2, Log.clone$Clone(sink)); - const _06: boolean = rt.btreeContains(many2, _57); + const _06: boolean = rs.btreeContains(many2, _57); _57[Symbol.dispose](); return _06; })); }; - const iter3: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 3, undefined, 4294967295); + const iter3: rs.Iter = rs.iterStepBy(new rs.Range(0, 400), 3, undefined, 4294967295); while (true) { - const _282: rt.u32 | rt.Done = iter3.next(); - if (_282 === rt.DONE) { + const _282: rs.u32 | rs.Done = iter3.next(); + if (_282 === rs.DONE) { break; } const _289: Key.Key = Key.new(_282, Log.clone$Clone(sink)); - rt.drop(rt.btreeReplace(many, _289)); + rs.drop(rs.btreeReplace(many, _289)); } - const _298: rt.usize = found(many); - const _303: rt.usize = rt.btreeLen(many); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_298, f), (f: rt.Formatter) => rt.usizeDisplay(_303, f)]; - Log.note(log, rt.fmtFormat(["replaced ", args20[0], " ", args20[1]])); - const iter4: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 7, undefined, 4294967295); + const _298: rs.usize = found(many); + const _303: rs.usize = rs.btreeLen(many); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_298, f), (f: rs.Formatter) => rs.usizeDisplay(_303, f)]; + Log.note(log, rs.fmtFormat(["replaced ", args20[0], " ", args20[1]])); + const iter4: rs.Iter = rs.iterStepBy(new rs.Range(0, 400), 7, undefined, 4294967295); while (true) { - const _314: rt.u32 | rt.Done = iter4.next(); - if (_314 === rt.DONE) { + const _314: rs.u32 | rs.Done = iter4.next(); + if (_314 === rs.DONE) { break; } const _322: Key.Key = Key.new(_314, Log.clone$Clone(sink)); - rt.drop(rt.btreeKey(many, _322, true)); + rs.drop(rs.btreeKey(many, _322, true)); _322[Symbol.dispose](); } - const _331: rt.usize = found(many); - const _336: rt.usize = rt.btreeLen(many); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_331, f), (f: rt.Formatter) => rt.usizeDisplay(_336, f)]; - Log.note(log, rt.fmtFormat(["taken ", args22[0], " ", args22[1]])); - const iter5: rt.Iter = rt.iterStepBy(new rt.Range(0, 400), 5, undefined, 4294967295); + const _331: rs.usize = found(many); + const _336: rs.usize = rs.btreeLen(many); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_331, f), (f: rs.Formatter) => rs.usizeDisplay(_336, f)]; + Log.note(log, rs.fmtFormat(["taken ", args22[0], " ", args22[1]])); + const iter5: rs.Iter = rs.iterStepBy(new rs.Range(0, 400), 5, undefined, 4294967295); while (true) { - const _347: rt.u32 | rt.Done = iter5.next(); - if (_347 === rt.DONE) { + const _347: rs.u32 | rs.Done = iter5.next(); + if (_347 === rs.DONE) { break; } const _354: Key.Key = Key.new(_347, Log.clone$Clone(sink)); - rt.btreeDelete(many, _354, rt.drop); + rs.btreeDelete(many, _354, rs.drop); _354[Symbol.dispose](); } - const _363: rt.usize = found(many); - const _368: rt.usize = rt.btreeLen(many); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_363, f), (f: rt.Formatter) => rt.usizeDisplay(_368, f)]; - Log.note(log, rt.fmtFormat(["removed ", args24[0], " ", args24[1]])); - rt.btreeDrop(many, rt.drop); + const _363: rs.usize = found(many); + const _368: rs.usize = rs.btreeLen(many); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_363, f), (f: rs.Formatter) => rs.usizeDisplay(_368, f)]; + Log.note(log, rs.fmtFormat(["removed ", args24[0], " ", args24[1]])); + rs.btreeDrop(many, rs.drop); sink[Symbol.dispose](); - rt.dequeDrop(queue, rt.drop); - rt.btreeDrop(set, rt.drop); - rt.drop(removed); - rt.btreeDrop(map, rt.drop, rt.drop); + rs.dequeDrop(queue, rs.drop); + rs.btreeDrop(set, rs.drop); + rs.drop(removed); + rs.btreeDrop(map, rs.drop, rs.drop); } /** * The same of hash collections, whose order of drops std leaves unspecified: each key * and value logs to a sink, and the log reads how much it holds, in an order it ignores. */ -export function hashed(log: Log.Log, id: rt.u32): void { +export function hashed(log: Log.Log, id: rs.u32): void { const sink: Log.Log = Log.new(); - const key: (a0: rt.u32) => Key.Key = (n: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n), Log.clone$Clone(sink)); + const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n), Log.clone$Clone(sink)); }; - const guard: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(sink)); + const guard: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n2), Log.clone$Clone(sink)); }; const tally: (a0: string) => undefined = (what: string): undefined => { - const text: rt.ByteVec = Log.text(sink); - const sum: rt.u32 = rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(text))), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; - }), rt.u32Add, 0); - const _152: rt.usize = text.length; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, what), (f: rt.Formatter) => rt.usizeDisplay(_152, f), (f: rt.Formatter) => rt.u32Display(sum, f)]; - Log.note(log, rt.fmtFormat([args10[0], ": ", args10[1], " ", args10[2]])); + const text: rs.ByteVec = Log.text(sink); + const sum: rs.u32 = rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(text))), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; + }), rs.u32Add, 0); + const _152: rs.usize = text.length; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_152, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat([args10[0], ": ", args10[1], " ", args10[2]])); }; - const map: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap; + const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _15: Key.Key = key(1); const _18: Guard.Guard = guard(1); - rt.drop(rt.hashInsert(map, _15, _18, rt.drop)); + rs.drop(rs.hashInsert(map, _15, _18, rs.drop)); const _23: Key.Key = key(2); const _26: Guard.Guard = guard(2); - rt.drop(rt.hashInsert(map, _23, _26, rt.drop)); + rs.drop(rs.hashInsert(map, _23, _26, rs.drop)); const _31: Key.Key = key(3); const _34: Guard.Guard = guard(3); - rt.drop(rt.hashInsert(map, _31, _34, rt.drop)); + rs.drop(rs.hashInsert(map, _31, _34, rs.drop)); const _39: Key.Key = key(1); const _42: Guard.Guard = guard(4); - const old: Guard.Guard | undefined = rt.hashInsert(map, _39, _42, rt.drop); + const old: Guard.Guard | undefined = rs.hashInsert(map, _39, _42, rs.drop); tally("insert"); - rt.drop(old); + rs.drop(old); const _53: Key.Key = key(2); - const removed: Guard.Guard | undefined = rt.hashRemove(map, _53, rt.drop); + const removed: Guard.Guard | undefined = rs.hashRemove(map, _53, rs.drop); _53[Symbol.dispose](); tally("remove"); - rt.drop(removed); + rs.drop(removed); const _64: Key.Key = key(3); - const _62: rt.Entry = rt.entry(map, _64, rt.drop); - if (rt.entryOccupied(_62)) { - rt.entryRemove(_62, rt.drop)[Symbol.dispose](); + const _62: rs.Entry = rs.entry(map, _64, rs.drop); + if (rs.entryOccupied(_62)) { + rs.entryRemove(_62, rs.drop)[Symbol.dispose](); } else { - Log.note(log, rt.fmtFormat(["vacant"])); + Log.note(log, rs.fmtFormat(["vacant"])); } - if (!rt.entryOccupied(_62)) { - rt.entryDrop(_62, rt.drop); + if (!rs.entryOccupied(_62)) { + rs.entryDrop(_62, rs.drop); } const _75: Key.Key = key(5); - const _73: rt.Entry = rt.entry(map, _75, rt.drop); - if (!rt.entryOccupied(_73)) { - const e2: rt.Entry = _73; - const part = rt.entryKey(e2).id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["left ", args2[0]])); + const _73: rs.Entry = rs.entry(map, _75, rs.drop); + if (!rs.entryOccupied(_73)) { + const e2: rs.Entry = _73; + const part = rs.entryKey(e2).id; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["left ", args2[0]])); e2.k[Symbol.dispose](); } tally("entry"); const _101: Key.Key = key(1); - const kept: rt.u32 = Guard.id(rt.entryOrInsert(rt.entry(map, _101, rt.drop), guard(6), rt.drop)); + const kept: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _101, rs.drop), guard(6), rs.drop)); const _112: Key.Key = key(7); - const added: rt.u32 = Guard.id(rt.entryOrInsert(rt.entry(map, _112, rt.drop), guard(7), rt.drop)); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(kept, f), (f: rt.Formatter) => rt.u32Display(added, f)]; - Log.note(log, rt.fmtFormat(["or_insert ", args4[0], " ", args4[1]])); + const added: rs.u32 = Guard.id(rs.entryOrInsert(rs.entry(map, _112, rs.drop), guard(7), rs.drop)); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept, f), (f: rs.Formatter) => rs.u32Display(added, f)]; + Log.note(log, rs.fmtFormat(["or_insert ", args4[0], " ", args4[1]])); tally("or_insert"); const _136: Key.Key = key(8); const _139: Guard.Guard = guard(8); - rt.drop(rt.hashInsert(map, _136, _139, rt.drop)); - rt.hashRetain(map, (k: Key.Key, _35: Guard.Guard): boolean => { - return rt.u32Rem(k.id, 2) === 0; - }, rt.drop, rt.drop); + rs.drop(rs.hashInsert(map, _136, _139, rs.drop)); + rs.hashRetain(map, (k: Key.Key, _35: Guard.Guard): boolean => { + return rs.u32Rem(k.id, 2) === 0; + }, rs.drop, rs.drop); tally("retain"); - const set: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet; + const set: rs.HashSet = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashSet; const _151: Key.Key = key(10); - rt.hashAdd(set, _151, rt.drop); + rs.hashAdd(set, _151, rs.drop); const _156: Key.Key = key(11); - rt.hashAdd(set, _156, rt.drop); + rs.hashAdd(set, _156, rs.drop); const _167: Key.Key = key(10); - const part2 = rt.hashAdd(set, _167, rt.drop); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; - Log.note(log, rt.fmtFormat(["again ", args6[0]])); + const part2 = rs.hashAdd(set, _167, rs.drop); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; + Log.note(log, rs.fmtFormat(["again ", args6[0]])); const _183: Key.Key = key(11); - const part3 = rt.hashDelete(set, _183, rt.drop); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - const _176: string = rt.fmtFormat(["gone ", args8[0]]); + const part3 = rs.hashDelete(set, _183, rs.drop); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + const _176: string = rs.fmtFormat(["gone ", args8[0]]); _183[Symbol.dispose](); Log.note(log, _176); const _192: Key.Key = key(12); - rt.hashAdd(set, _192, rt.drop); - rt.hashRetain(set, (k2: Key.Key): boolean => { - return rt.u32Rem(k2.id, 2) === 1; - }, rt.drop); + rs.hashAdd(set, _192, rs.drop); + rs.hashRetain(set, (k2: Key.Key): boolean => { + return rs.u32Rem(k2.id, 2) === 1; + }, rs.drop); tally("set"); - const counted: (a0: rt.u32) => Key.Key = (n3: rt.u32): Key.Key => { - return new Key.Key(rt.u32Add(id, n3), Log.clone$Clone(sink), true); + const counted: (a0: rs.u32) => Key.Key = (n3: rs.u32): Key.Key => { + return new Key.Key(rs.u32Add(id, n3), Log.clone$Clone(sink), true); }; - const counts: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap; + const counts: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _207: Key.Key = counted(20); const _210: Guard.Guard = guard(20); - rt.drop(rt.hashInsert(counts, _207, _210, rt.drop)); + rs.drop(rs.hashInsert(counts, _207, _210, rs.drop)); const _217: Key.Key = counted(20); - rt.entryOrInsert(rt.entry(counts, _217, rt.drop), guard(21), rt.drop); + rs.entryOrInsert(rs.entry(counts, _217, rs.drop), guard(21), rs.drop); const _227: Key.Key = counted(22); - rt.entryOrInsertWith(rt.entry(counts, _227, rt.drop), (): Guard.Guard => { + rs.entryOrInsertWith(rs.entry(counts, _227, rs.drop), (): Guard.Guard => { return guard(22); }); const _237: Key.Key = counted(20); - rt.entryOrInsert(rt.entryAndModify(rt.entry(counts, _237, rt.drop), (_27: Guard.Guard): undefined => {}), guard(23), rt.drop); + rs.entryOrInsert(rs.entryAndModify(rs.entry(counts, _237, rs.drop), (_27: Guard.Guard): undefined => {}), guard(23), rs.drop); const _245: Key.Key = counted(22); - const _243: rt.Entry = rt.entry(counts, _245, rt.drop); - if (rt.entryOccupied(_243)) { - rt.entryRemove(_243, rt.drop)[Symbol.dispose](); - rt.entryDrop(_243, rt.drop); + const _243: rs.Entry = rs.entry(counts, _245, rs.drop); + if (rs.entryOccupied(_243)) { + rs.entryRemove(_243, rs.drop)[Symbol.dispose](); + rs.entryDrop(_243, rs.drop); } else { - rt.entryDrop(_243, rt.drop); + rs.entryDrop(_243, rs.drop); } tally("counted"); - rt.hashClear(map, rt.drop, rt.drop); + rs.hashClear(map, rs.drop, rs.drop); tally("clear"); - rt.hashDrop(set, rt.drop); - rt.hashDrop(map, rt.drop, rt.drop); + rs.hashDrop(set, rs.drop); + rs.hashDrop(map, rs.drop, rs.drop); tally("end"); - rt.hashDrop(counts, rt.drop, rt.drop); + rs.hashDrop(counts, rs.drop, rs.drop); sink[Symbol.dispose](); } @@ -620,60 +620,60 @@ export function hashed(log: Log.Log, id: rt.u32): void { * What std's functions on `Option`, `Result`, and `bool` drop of what they are given * rather than return: an unused error or fallback, after any closure they call. */ -export function options(log: Log.Log, id: rt.u32): void { +export function options(log: Log.Log, id: rs.u32): void { let _338!: boolean; - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const some: rt.Result = option_okOr$1alhe7b(guard(1), guard(2)); - const none: rt.Result = option_okOr$1alhe7b(undefined as Guard.Guard | undefined, guard(3)); + const some: rs.Result = option_okOr$0qyzozq(guard(1), guard(2)); + const none: rs.Result = option_okOr$0qyzozq(undefined as Guard.Guard | undefined, guard(3)); const _24: boolean = some.ok; const _27: boolean = none.ok; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_24, f), (f: rt.Formatter) => rt.fmtBool(_27, f)]; - Log.note(log, rt.fmtFormat(["ok_or ", args2[0], " ", args2[1]])); - const ok: Guard.Guard | undefined = ok$0rngk0g(rt.Ok(guard(4))); - const err: Guard.Guard | undefined = ok$0rngk0g(rt.Err(guard(5))); - const flipped: Guard.Guard | undefined = err$126l6wy(rt.Ok(guard(6))); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_24, f), (f: rs.Formatter) => rs.fmtBool(_27, f)]; + Log.note(log, rs.fmtFormat(["ok_or ", args2[0], " ", args2[1]])); + const ok: Guard.Guard | undefined = ok$0p21n6j(rs.Ok(guard(4))); + const err: Guard.Guard | undefined = ok$0p21n6j(rs.Err(guard(5))); + const flipped: Guard.Guard | undefined = err$1guw4rh(rs.Ok(guard(6))); const _55: boolean = ok !== undefined; const _58: boolean = err !== undefined; const _61: boolean = flipped !== undefined; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_55, f), (f: rt.Formatter) => rt.fmtBool(_58, f), (f: rt.Formatter) => rt.fmtBool(_61, f)]; - Log.note(log, rt.fmtFormat(["ok ", args4[0], " ", args4[1], " ", args4[2]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_55, f), (f: rs.Formatter) => rs.fmtBool(_58, f), (f: rs.Formatter) => rs.fmtBool(_61, f)]; + Log.note(log, rs.fmtFormat(["ok ", args4[0], " ", args4[1], " ", args4[2]])); const kept: Guard.Guard = option_unwrapOr$0v6ziq2(guard(7), guard(8)); const fallback: Guard.Guard = option_unwrapOr$0v6ziq2(undefined as Guard.Guard | undefined, guard(9)); - const value: Guard.Guard = result_unwrapOr$0urixfm(rt.Ok(guard(10)), guard(11)); - const error: Guard.Guard = result_unwrapOr$0urixfm(rt.Err(guard(12)), guard(13)); - const _104: rt.u32 = Guard.id(kept); - const _107: rt.u32 = Guard.id(fallback); - const _110: rt.u32 = Guard.id(value); - const _113: rt.u32 = Guard.id(error); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_104, f), (f: rt.Formatter) => rt.u32Display(_107, f), (f: rt.Formatter) => rt.u32Display(_110, f), (f: rt.Formatter) => rt.u32Display(_113, f)]; - Log.note(log, rt.fmtFormat(["unwrap_or ", args6[0], " ", args6[1], " ", args6[2], " ", args6[3]])); - const mapped: Guard.Guard = option_mapOr$0ey19f0(id, guard(14), (n2: rt.u32): Guard.Guard => { - Log.note(log, rt.fmtFormat(["mapped"])); - return Guard.new(rt.u32Add(n2, 15), Log.clone$Clone(log)); + const value: Guard.Guard = result_unwrapOr$19ff01h(rs.Ok(guard(10)), guard(11)); + const error: Guard.Guard = result_unwrapOr$19ff01h(rs.Err(guard(12)), guard(13)); + const _104: rs.u32 = Guard.id(kept); + const _107: rs.u32 = Guard.id(fallback); + const _110: rs.u32 = Guard.id(value); + const _113: rs.u32 = Guard.id(error); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_107, f), (f: rs.Formatter) => rs.u32Display(_110, f), (f: rs.Formatter) => rs.u32Display(_113, f)]; + Log.note(log, rs.fmtFormat(["unwrap_or ", args6[0], " ", args6[1], " ", args6[2], " ", args6[3]])); + const mapped: Guard.Guard = option_mapOr$19gmzl7(id, guard(14), (n2: rs.u32): Guard.Guard => { + Log.note(log, rs.fmtFormat(["mapped"])); + return Guard.new(rs.u32Add(n2, 15), Log.clone$Clone(log)); }); - const unmapped: Guard.Guard = option_mapOr$0ey19f0(undefined as rt.u32 | undefined, guard(16), (n3: rt.u32): Guard.Guard => { + const unmapped: Guard.Guard = option_mapOr$19gmzl7(undefined as rs.u32 | undefined, guard(16), (n3: rs.u32): Guard.Guard => { return Guard.new(n3, Log.clone$Clone(log)); }); - const _140: rt.u32 = Guard.id(mapped); - const _143: rt.u32 = Guard.id(unmapped); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_140, f), (f: rt.Formatter) => rt.u32Display(_143, f)]; - Log.note(log, rt.fmtFormat(["map_or ", args8[0], " ", args8[1]])); + const _140: rs.u32 = Guard.id(mapped); + const _143: rs.u32 = Guard.id(unmapped); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_140, f), (f: rs.Formatter) => rs.u32Display(_143, f)]; + Log.note(log, rs.fmtFormat(["map_or ", args8[0], " ", args8[1]])); const then: Guard.Guard | undefined = thenSome$0zvoczk(some.ok, guard(17)); const never: Guard.Guard | undefined = thenSome$0zvoczk(false, guard(18)); const _166: boolean = then !== undefined; const _169: boolean = never !== undefined; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_166, f), (f: rt.Formatter) => rt.fmtBool(_169, f)]; - Log.note(log, rt.fmtFormat(["then_some ", args10[0], " ", args10[1]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_166, f), (f: rs.Formatter) => rs.fmtBool(_169, f)]; + Log.note(log, rs.fmtFormat(["then_some ", args10[0], " ", args10[1]])); const kept2: Guard.Guard | undefined = filter$1vqc90z(guard(19), (g: Guard.Guard): boolean => { - return rt.u32Rem(Guard.id(g), 2) === 0; + return rs.u32Rem(Guard.id(g), 2) === 0; }); const dropped: Guard.Guard | undefined = filter$1vqc90z(guard(20), (_2: Guard.Guard): boolean => { return false; }); const zipped: [Guard.Guard, Guard.Guard] | undefined = zip$1rr0evn(guard(21), guard(22)); - const other: Guard.Guard | undefined = option_orElse$02wco5t(undefined as Guard.Guard | undefined, (): Guard.Guard | undefined => { + const other: Guard.Guard | undefined = option_orElse$0gn8afw(undefined as Guard.Guard | undefined, (): Guard.Guard | undefined => { return guard(23); }); const flag: boolean = isSomeAnd$17cacqw(guard(24), (g2: Guard.Guard): boolean => { @@ -685,27 +685,27 @@ export function options(log: Log.Log, id: rt.u32): void { const _215: boolean = dropped !== undefined; const _218: boolean = zipped !== undefined; const _221: boolean = other !== undefined; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_212, f), (f: rt.Formatter) => rt.fmtBool(_215, f), (f: rt.Formatter) => rt.fmtBool(_218, f), (f: rt.Formatter) => rt.fmtBool(_221, f), (f: rt.Formatter) => rt.fmtBool(flag, f)]; - Log.note(log, rt.fmtFormat(["filter ", args12[0], " ", args12[1], " zip ", args12[2], " or_else ", args12[3], " is_some_and ", args12[4]])); - const chained: rt.Result = result_andThen$0r804hk(rt.Ok(guard(25)), (a0: Guard.Guard): rt.Result => { - return rt.Err(a0); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_212, f), (f: rs.Formatter) => rs.fmtBool(_215, f), (f: rs.Formatter) => rs.fmtBool(_218, f), (f: rs.Formatter) => rs.fmtBool(_221, f), (f: rs.Formatter) => rs.fmtBool(flag, f)]; + Log.note(log, rs.fmtFormat(["filter ", args12[0], " ", args12[1], " zip ", args12[2], " or_else ", args12[3], " is_some_and ", args12[4]])); + const chained: rs.Result = result_andThen$1wsai1p(rs.Ok(guard(25)), (a0: Guard.Guard): rs.Result => { + return rs.Err(a0); }); - const error2: rt.u32 = result_mapOrElse$196aho3(rt.Err(guard(26)), (e: Guard.Guard): rt.u32 => { - const _07: rt.u32 = Guard.id(e); + const error2: rs.u32 = result_mapOrElse$0cjv9n5(rs.Err(guard(26)), (e: Guard.Guard): rs.u32 => { + const _07: rs.u32 = Guard.id(e); e[Symbol.dispose](); return _07; - }, (v: Guard.Guard): rt.u32 => { - const _08: rt.u32 = Guard.id(v); + }, (v: Guard.Guard): rs.u32 => { + const _08: rs.u32 = Guard.id(v); v[Symbol.dispose](); return _08; }); - const _244: rt.Arc | undefined = new rt.Arc(guard(27)); - const cloned: rt.Arc | undefined = option_clone$1sxxxkp(_244); - rt.drop(_244); + const _244: rs.Arc | undefined = new rs.Arc(guard(27)); + const cloned: rs.Arc | undefined = option_clone$0cpy9zy(_244); + rs.drop(_244); const _255: boolean = chained.ok; const _258: boolean = cloned !== undefined; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_255, f), (f: rt.Formatter) => rt.u32Display(error2, f), (f: rt.Formatter) => rt.fmtBool(_258, f)]; - Log.note(log, rt.fmtFormat(["and_then ", args14[0], " map_or_else ", args14[1], " clone ", args14[2]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_255, f), (f: rs.Formatter) => rs.u32Display(error2, f), (f: rs.Formatter) => rs.fmtBool(_258, f)]; + Log.note(log, rs.fmtFormat(["and_then ", args14[0], " map_or_else ", args14[1], " clone ", args14[2]])); let slot = undefined as Guard.Guard | undefined; const _270: Guard.Guard = guard(28); if (slot === undefined) { @@ -720,7 +720,7 @@ export function options(log: Log.Log, id: rt.u32): void { _275[Symbol.dispose](); } const captured = guard(30); - const _283: () => Guard.Guard = rt.closure((): Guard.Guard => { + const _283: () => Guard.Guard = rs.closure((): Guard.Guard => { return captured; }, (): void => { captured[Symbol.dispose](); @@ -728,12 +728,12 @@ export function options(log: Log.Log, id: rt.u32): void { if (slot === undefined) { slot = _283(); } else { - rt.drop(_283); + rs.drop(_283); } const owned2: Guard.Guard = guard(31); let empty = undefined as Guard.Guard | undefined; const captured2 = owned2; - const _292: () => Guard.Guard = rt.closure((): Guard.Guard => { + const _292: () => Guard.Guard = rs.closure((): Guard.Guard => { return captured2; }, (): void => { captured2[Symbol.dispose](); @@ -741,36 +741,36 @@ export function options(log: Log.Log, id: rt.u32): void { if (empty === undefined) { empty = _292(); } else { - rt.drop(_292); + rs.drop(_292); } - const made: rt.u32 = Guard.id(empty as Guard.Guard); + const made: rs.u32 = Guard.id(empty as Guard.Guard); const _297: Guard.Guard = guard(32); const old = slot; slot = _297; - rt.drop(old); - const replaced: rt.u32 = Guard.id(slot as Guard.Guard); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(made, f), (f: rt.Formatter) => rt.u32Display(replaced, f)]; - Log.note(log, rt.fmtFormat(["get_or_insert ", args16[0], " ", args16[1]])); - let answered = undefined as rt.Result | undefined; - const _315: rt.Result = rt.Ok(guard(33)); + rs.drop(old); + const replaced: rs.u32 = Guard.id(slot as Guard.Guard); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(made, f), (f: rs.Formatter) => rs.u32Display(replaced, f)]; + Log.note(log, rs.fmtFormat(["get_or_insert ", args16[0], " ", args16[1]])); + let answered = undefined as rs.Result | undefined; + const _315: rs.Result = rs.Ok(guard(33)); if (answered === undefined) { answered = _315; } else { lib_drop$Result_model_Guard_u8(_315); } - const _324: rt.Result = rt.Ok(guard(34)); + const _324: rs.Result = rs.Ok(guard(34)); if (answered === undefined) { answered = _324; } else { lib_drop$Result_model_Guard_u8(_324); } - const kept3: rt.u32 = result_mapOr$1hlk3iq(asRef$01pd5k9(answered as rt.Result), 0, Guard.id); - const _328: rt.Result = rt.Err(4); - const _331: rt.Result = rt.Err(3); + const kept3: rs.u32 = result_mapOr$1g4n0cf(asRef$0auemm6(answered as rs.Result), 0, Guard.id); + const _328: rs.Result = rs.Err(4); + const _331: rs.Result = rs.Err(3); const old2 = answered; answered = _331; lib_drop$Option_Result_model_Guard_u8(old2); - lib_drop$Result_model_Guard_u8(answered as rt.Result); + lib_drop$Result_model_Guard_u8(answered as rs.Result); b0: { answered = _328; if (answered !== undefined) { @@ -783,28 +783,28 @@ export function options(log: Log.Log, id: rt.u32): void { } _338 = false; } - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(kept3, f), (f: rt.Formatter) => rt.fmtBool(_338, f)]; - Log.note(log, rt.fmtFormat(["answered ", args18[0], " ", args18[1]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(kept3, f), (f: rs.Formatter) => rs.fmtBool(_338, f)]; + Log.note(log, rs.fmtFormat(["answered ", args18[0], " ", args18[1]])); lib_drop$Option_Result_model_Guard_u8(answered); - rt.drop(empty); - rt.drop(slot); - rt.drop(cloned); + rs.drop(empty); + rs.drop(slot); + rs.drop(cloned); lib_drop$Result_model_Guard_model_Guard(chained); - rt.drop(other); + rs.drop(other); lib_drop$Option_tuple2_model_Guard_model_Guard(zipped); - rt.drop(dropped); - rt.drop(kept2); - rt.drop(never); - rt.drop(then); + rs.drop(dropped); + rs.drop(kept2); + rs.drop(never); + rs.drop(then); unmapped[Symbol.dispose](); mapped[Symbol.dispose](); error[Symbol.dispose](); value[Symbol.dispose](); fallback[Symbol.dispose](); kept[Symbol.dispose](); - rt.drop(flipped); - rt.drop(err); - rt.drop(ok); + rs.drop(flipped); + rs.drop(err); + rs.drop(ok); lib_drop$Result_model_Guard_model_Guard(none); lib_drop$Result_model_Guard_model_Guard(some); } @@ -814,363 +814,363 @@ export function options(log: Log.Log, id: rt.u32): void { * and drop: `None` for no element, apart from the `Some(None)` of a `None` one, and each * value once, where Rust drops it. */ -export function elements(log: Log.Log, id: rt.u32): void { - const _7: (a0: Guard.Guard | undefined) => rt.u32 | undefined = (o3: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o3, Guard.id); +export function elements(log: Log.Log, id: rs.u32): void { + const _7: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (o3: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o3, Guard.id); }; - const _348: (a0: Key.Key | undefined) => rt.u32 | undefined = (o4: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o4, (k: Key.Key): rt.u32 => { + const _348: (a0: Key.Key | undefined) => rs.u32 | undefined = (o4: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o4, (k: Key.Key): rs.u32 => { return k.id; }); }; - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const key: (a0: rt.u32) => Key.Key = (n2: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n2: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; - const v2: rt.Vec = new rt.Vec(); + const v2: rs.Vec = new rs.Vec(); const _12: Guard.Guard | undefined = guard(1); v2.items.push(_12); v2.items.push(undefined as Guard.Guard | undefined); const _21: Guard.Guard | undefined = guard(2); v2.items.push(_21); v2.items.push(undefined as Guard.Guard | undefined); - const v: rt.Vec = v2; - const _34: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceFirst(v.items, rt.None), (o5: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o5, Guard.id); + const v: rs.Vec = v2; + const _34: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceFirst(v.items, rs.None), (o5: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o5, Guard.id); }); - const _39: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceLast(v.items, rt.None), (o6: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o6, Guard.id); + const _39: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceLast(v.items, rs.None), (o6: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o6, Guard.id); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_34, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_39, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["vec ", args2[0], " ", args2[1]])); - const _54: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceGet(v.items, 1, rt.None), (o7: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o7, Guard.id); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_34, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_39, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["vec ", args2[0], " ", args2[1]])); + const _54: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(v.items, 1, rs.None), (o7: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o7, Guard.id); }); - const _59: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.sliceGet(v.items, 4, rt.None), (o8: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o8, Guard.id); + const _59: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.sliceGet(v.items, 4, rs.None), (o8: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o8, Guard.id); }); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_54, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_59, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["get ", args4[0], " ", args4[1]])); - const _68: rt.Place | undefined = rt.sliceLastMut(v.items); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_54, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_59, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["get ", args4[0], " ", args4[1]])); + const _68: rs.Place | undefined = rs.sliceLastMut(v.items); if (_68 !== undefined) { const _73: Guard.Guard | undefined = guard(3); - rt.drop(_68.v); + rs.drop(_68.v); _68.v = _73; } - const _77: rt.Place | undefined = rt.sliceFirstMut(v.items); + const _77: rs.Place | undefined = rs.sliceFirstMut(v.items); if (_77 !== undefined) { - rt.drop(_77.v); + rs.drop(_77.v); _77.v = undefined; } - const kept: Guard.Guard | undefined | rt.None = rt.vecPopIfMut(v, (o9: rt.Place): boolean => { - rt.drop(o9.v); + const kept: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o9: rs.Place): boolean => { + rs.drop(o9.v); o9.v = undefined; return false; - }, undefined, rt.None); - const taken: Guard.Guard | undefined | rt.None = rt.vecPopIfMut(v, (o10: rt.Place): boolean => { + }, undefined, rs.None); + const taken: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, (o10: rs.Place): boolean => { const _318: Guard.Guard | undefined = guard(12); - rt.drop(o10.v); + rs.drop(o10.v); o10.v = _318; return true; - }, undefined, rt.None); - const _95: boolean = kept !== rt.None; - const _98: rt.u32 | undefined | rt.None = option_map$0ccnsmq(taken, (o11: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o11, Guard.id); + }, undefined, rs.None); + const _95: boolean = kept !== rs.None; + const _98: rs.u32 | undefined | rs.None = option_map$1x5kkz1(taken, (o11: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o11, Guard.id); }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_95, f), (f: rt.Formatter) => rt.fmtOption(_98, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["pop_if ", args6[0], " ", args6[1]])); - rt.drop(taken); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_95, f), (f: rs.Formatter) => rs.fmtOption(_98, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["pop_if ", args6[0], " ", args6[1]])); + rs.drop(taken); while (true) { - const _107: Guard.Guard | undefined | rt.None = rt.vecPop(v, rt.None); - if (_107 !== rt.None) { + const _107: Guard.Guard | undefined | rs.None = rs.vecPop(v, rs.None); + if (_107 !== rs.None) { const o: Guard.Guard | undefined = _107; const part2 = _7(o); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["pop ", args8[0]])); - rt.drop(o); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["pop ", args8[0]])); + rs.drop(o); } else { break; } } - const part4 = option_map$0ccnsmq(rt.vecPop(v, rt.None), (o12: Guard.Guard | undefined): rt.u32 | undefined => { - const _011: rt.u32 | undefined = _7(o12); - rt.drop(o12); + const part4 = option_map$1x5kkz1(rs.vecPop(v, rs.None), (o12: Guard.Guard | undefined): rs.u32 | undefined => { + const _011: rs.u32 | undefined = _7(o12); + rs.drop(o12); return _011; }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["popped ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["popped ", args10[0]])); const captured = guard(14); - const _151: Guard.Guard | undefined | rt.None = rt.vecPopIfMut(v, rt.closure((_2: rt.Place): boolean => { + const _151: Guard.Guard | undefined | rs.None = rs.vecPopIfMut(v, rs.closure((_2: rs.Place): boolean => { const _012: boolean = Guard.id(captured) > 0; captured[Symbol.dispose](); return _012; }, (): void => { captured[Symbol.dispose](); - }), rt.drop, rt.None); - const part5 = _151 !== rt.None; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; - const _145: string = rt.fmtFormat(["uncalled ", args12[0]]); - rt.drop(_151); + }), rs.drop, rs.None); + const part5 = _151 !== rs.None; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; + const _145: string = rs.fmtFormat(["uncalled ", args12[0]]); + rs.drop(_151); Log.note(log, _145); v.items.push(undefined as Guard.Guard | undefined); const captured2 = guard(15); - const part8 = option_map$0ccnsmq(rt.vecPopIfMut(v, rt.closure((o13: rt.Place): boolean => { + const part8 = option_map$1x5kkz1(rs.vecPopIfMut(v, rs.closure((o13: rs.Place): boolean => { const part6 = Guard.id(captured2); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["test ", args52[0]])); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["test ", args52[0]])); const _013: boolean = o13.v === undefined; captured2[Symbol.dispose](); return _013; }, (): void => { captured2[Symbol.dispose](); - }), rt.drop, rt.None), (o14: Guard.Guard | undefined): rt.u32 | undefined => { - const _014: rt.u32 | undefined = _7(o14); - rt.drop(o14); + }), rs.drop, rs.None), (o14: Guard.Guard | undefined): rs.u32 | undefined => { + const _014: rs.u32 | undefined = _7(o14); + rs.drop(o14); return _014; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["called ", args14[0]])); - const q: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; - rt.dequePushBack(q, undefined as Guard.Guard | undefined); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["called ", args14[0]])); + const q: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; + rs.dequePushBack(q, undefined as Guard.Guard | undefined); const _186: Guard.Guard | undefined = guard(4); - rt.dequePushBack(q, _186); + rs.dequePushBack(q, _186); const _192: Guard.Guard | undefined = guard(5); - rt.dequePushFront(q, _192); - rt.dequePushBack(q, undefined as Guard.Guard | undefined); - const _205: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeEnd(q, false, rt.None), (o15: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o15, Guard.id); + rs.dequePushFront(q, _192); + rs.dequePushBack(q, undefined as Guard.Guard | undefined); + const _205: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, false, rs.None), (o15: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o15, Guard.id); }); - const _209: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeEnd(q, true, rt.None), (o16: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o16, Guard.id); + const _209: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeEnd(q, true, rs.None), (o16: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o16, Guard.id); }); - const _213: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeGet(q, 4, rt.None), (o17: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o17, Guard.id); + const _213: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeGet(q, 4, rs.None), (o17: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o17, Guard.id); }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_205, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_209, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_213, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["deque ", args16[0], " ", args16[1], " ", args16[2]])); - const _222: rt.Place | undefined = rt.dequeEndMut(q); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_205, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_209, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_213, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["deque ", args16[0], " ", args16[1], " ", args16[2]])); + const _222: rs.Place | undefined = rs.dequeEndMut(q); if (_222 !== undefined) { - rt.drop(_222.v); + rs.drop(_222.v); _222.v = undefined; } - const removed: Guard.Guard | undefined | rt.None = rt.dequeRemove(q, 2, rt.None); - const _235: rt.u32 | undefined | rt.None = option_map$0ccnsmq(removed, (o18: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o18, Guard.id); + const removed: Guard.Guard | undefined | rs.None = rs.dequeRemove(q, 2, rs.None); + const _235: rs.u32 | undefined | rs.None = option_map$1x5kkz1(removed, (o18: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o18, Guard.id); }); - const _239: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeRemove(q, 3, rt.None), (o19: Guard.Guard | undefined): rt.u32 | undefined => { - const _019: rt.u32 | undefined = _7(o19); - rt.drop(o19); + const _239: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeRemove(q, 3, rs.None), (o19: Guard.Guard | undefined): rs.u32 | undefined => { + const _019: rs.u32 | undefined = _7(o19); + rs.drop(o19); return _019; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_235, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_239, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["remove ", args18[0], " ", args18[1]])); - rt.drop(removed); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_235, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_239, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["remove ", args18[0], " ", args18[1]])); + rs.drop(removed); const _252: Guard.Guard | undefined = guard(6); - rt.dequePushBack(q, _252); + rs.dequePushBack(q, _252); const _258: Guard.Guard | undefined = guard(13); - rt.dequePushBack(q, _258); - rt.dequePushFront(q, undefined as Guard.Guard | undefined); - const back: Guard.Guard | undefined | rt.None = rt.dequeSwapRemove(q, 0, true, rt.None); - const _273: rt.u32 | undefined | rt.None = option_map$0ccnsmq(back, (o20: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o20, Guard.id); + rs.dequePushBack(q, _258); + rs.dequePushFront(q, undefined as Guard.Guard | undefined); + const back: Guard.Guard | undefined | rs.None = rs.dequeSwapRemove(q, 0, true, rs.None); + const _273: rs.u32 | undefined | rs.None = option_map$1x5kkz1(back, (o20: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o20, Guard.id); }); - const _277: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeSwapRemove(q, 9, false, rt.None), (o21: Guard.Guard | undefined): rt.u32 | undefined => { - const _021: rt.u32 | undefined = _7(o21); - rt.drop(o21); + const _277: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 9, false, rs.None), (o21: Guard.Guard | undefined): rs.u32 | undefined => { + const _021: rs.u32 | undefined = _7(o21); + rs.drop(o21); return _021; }); - const _283: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequeSwapRemove(q, 1, false, rt.None), (o22: Guard.Guard | undefined): rt.u32 | undefined => { - const _022: rt.u32 | undefined = _7(o22); - rt.drop(o22); + const _283: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequeSwapRemove(q, 1, false, rs.None), (o22: Guard.Guard | undefined): rs.u32 | undefined => { + const _022: rs.u32 | undefined = _7(o22); + rs.drop(o22); return _022; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_273, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_277, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_283, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["swap_remove ", args20[0], " ", args20[1], " ", args20[2]])); - rt.drop(back); - const front: Guard.Guard | undefined | rt.None = rt.dequePopFront(q, rt.None); - const part12 = option_map$0ccnsmq(front, (o23: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o23, Guard.id); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_273, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_277, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_283, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["swap_remove ", args20[0], " ", args20[1], " ", args20[2]])); + rs.drop(back); + const front: Guard.Guard | undefined | rs.None = rs.dequePopFront(q, rs.None); + const part12 = option_map$1x5kkz1(front, (o23: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o23, Guard.id); }); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part12, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["front ", args22[0]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["front ", args22[0]])); while (true) { - const _310: Guard.Guard | undefined | rt.None = rt.dequePopBack(q, rt.None); - if (_310 !== rt.None) { + const _310: Guard.Guard | undefined | rs.None = rs.dequePopBack(q, rs.None); + if (_310 !== rs.None) { const o2: Guard.Guard | undefined = _310; const part14 = _7(o2); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part14, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["back ", args24[0]])); - rt.drop(o2); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["back ", args24[0]])); + rs.drop(o2); } else { break; } } - const _334: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.dequePopFront(q, rt.None), (o24: Guard.Guard | undefined): rt.u32 | undefined => { - const _024: rt.u32 | undefined = _7(o24); - rt.drop(o24); + const _334: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.dequePopFront(q, rs.None), (o24: Guard.Guard | undefined): rs.u32 | undefined => { + const _024: rs.u32 | undefined = _7(o24); + rs.drop(o24); return _024; }); - const _340: rt.u32 | undefined | rt.None = option_map$0ccnsmq(front, (o25: Guard.Guard | undefined): rt.u32 | undefined => { - const _025: rt.u32 | undefined = _7(o25); - rt.drop(o25); + const _340: rs.u32 | undefined | rs.None = option_map$1x5kkz1(front, (o25: Guard.Guard | undefined): rs.u32 | undefined => { + const _025: rs.u32 | undefined = _7(o25); + rs.drop(o25); return _025; }); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_334, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_340, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["emptied ", args26[0], " ", args26[1]])); - const heap: rt.BinaryHeap = rt.heapNew() as rt.BinaryHeap; + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_334, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_340, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["emptied ", args26[0], " ", args26[1]])); + const heap: rs.BinaryHeap = rs.heapNew() as rs.BinaryHeap; const _352: Key.Key | undefined = key(7); - rt.heapPush(heap, _352, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); - rt.heapPush(heap, undefined as Key.Key | undefined, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); + rs.heapPush(heap, _352, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd))); + rs.heapPush(heap, undefined as Key.Key | undefined, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd))); const _361: Key.Key | undefined = key(8); - rt.heapPush(heap, _361, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd))); - const part17 = option_map$0hegtde(rt.heapPeek(heap, rt.None), (o26: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o26, (k2: Key.Key): rt.u32 => { + rs.heapPush(heap, _361, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd))); + const part17 = option_map$150c7g4(rs.heapPeek(heap, rs.None), (o26: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o26, (k2: Key.Key): rs.u32 => { return k2.id; }); }); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part17, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["heap ", args28[0]])); - const top: Key.Key | undefined | rt.None = rt.heapPop(heap, rt.cmpLe(rt.cmpOption(Key.partialCmp$cmp_PartialOrd)), rt.None); - const part18 = option_map$0hegtde(top, (o27: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o27, (k3: Key.Key): rt.u32 => { + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["heap ", args28[0]])); + const top: Key.Key | undefined | rs.None = rs.heapPop(heap, rs.cmpLe(rs.cmpOption(Key.partialCmp$cmp_PartialOrd)), rs.None); + const part18 = option_map$150c7g4(top, (o27: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o27, (k3: Key.Key): rs.u32 => { return k3.id; }); }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part18, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["top ", args30[0]])); - rt.drop(top); - const sorted: rt.BTreeSet = rt.btreeNew(rt.cmpOption(Key.cmp$cmp_Ord)) as rt.BTreeSet; + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part18, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["top ", args30[0]])); + rs.drop(top); + const sorted: rs.BTreeSet = rs.btreeNew(rs.cmpOption(Key.cmp$cmp_Ord)) as rs.BTreeSet; const _397: Key.Key | undefined = key(9); - rt.btreeAdd(sorted, _397, rt.drop); - rt.btreeAdd(sorted, undefined as Key.Key | undefined, rt.drop); + rs.btreeAdd(sorted, _397, rs.drop); + rs.btreeAdd(sorted, undefined as Key.Key | undefined, rs.drop); const _406: Key.Key | undefined = key(10); - rt.btreeAdd(sorted, _406, rt.drop); - const _416: rt.u32 | undefined | rt.None = option_map$0hegtde(rt.btreeFirstKey(sorted, false, rt.None), (o28: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o28, (k4: Key.Key): rt.u32 => { + rs.btreeAdd(sorted, _406, rs.drop); + const _416: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.btreeFirstKey(sorted, false, rs.None), (o28: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o28, (k4: Key.Key): rs.u32 => { return k4.id; }); }); - const _420: rt.u32 | undefined | rt.None = option_map$0hegtde(rt.btreeFirstKey(sorted, true, rt.None), (o29: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o29, (k5: Key.Key): rt.u32 => { + const _420: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.btreeFirstKey(sorted, true, rs.None), (o29: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o29, (k5: Key.Key): rs.u32 => { return k5.id; }); }); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_416, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_420, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["set ", args32[0], " ", args32[1]])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_416, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_420, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["set ", args32[0], " ", args32[1]])); const _430: Key.Key | undefined = key(9); - const replaced: Key.Key | undefined | rt.None = rt.btreeReplace(sorted, _430, rt.None); - const _440: rt.u32 | undefined | rt.None = option_map$0hegtde(replaced, (o30: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o30, (k6: Key.Key): rt.u32 => { + const replaced: Key.Key | undefined | rs.None = rs.btreeReplace(sorted, _430, rs.None); + const _440: rs.u32 | undefined | rs.None = option_map$150c7g4(replaced, (o30: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o30, (k6: Key.Key): rs.u32 => { return k6.id; }); }); - const _444: rt.u32 | undefined | rt.None = option_map$0hegtde(rt.btreeReplace(sorted, undefined as Key.Key | undefined, rt.None), (o31: Key.Key | undefined): rt.u32 | undefined => { - const _036: rt.u32 | undefined = _348(o31); - rt.drop(o31); + const _444: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.btreeReplace(sorted, undefined as Key.Key | undefined, rs.None), (o31: Key.Key | undefined): rs.u32 | undefined => { + const _036: rs.u32 | undefined = _348(o31); + rs.drop(o31); return _036; }); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_440, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_444, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["replace ", args34[0], " ", args34[1]])); - rt.drop(replaced); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_440, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_444, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["replace ", args34[0], " ", args34[1]])); + rs.drop(replaced); const _466: Key.Key | undefined = key(10); - const part20 = option_map$0hegtde(rt.btreeKey(sorted, _466, false, rt.None), (o32: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o32, (k7: Key.Key): rt.u32 => { + const part20 = option_map$150c7g4(rs.btreeKey(sorted, _466, false, rs.None), (o32: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o32, (k7: Key.Key): rs.u32 => { return k7.id; }); }); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part20, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - const _458: string = rt.fmtFormat(["get ", args36[0]]); - rt.drop(_466); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + const _458: string = rs.fmtFormat(["get ", args36[0]]); + rs.drop(_466); Log.note(log, _458); const _477: Key.Key | undefined = key(10); - const taken2: Key.Key | undefined | rt.None = rt.btreeKey(sorted, _477, true, rt.None); - rt.drop(_477); - const _487: rt.u32 | undefined | rt.None = option_map$0hegtde(taken2, (o33: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o33, (k8: Key.Key): rt.u32 => { + const taken2: Key.Key | undefined | rs.None = rs.btreeKey(sorted, _477, true, rs.None); + rs.drop(_477); + const _487: rs.u32 | undefined | rs.None = option_map$150c7g4(taken2, (o33: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o33, (k8: Key.Key): rs.u32 => { return k8.id; }); }); const _496: Key.Key | undefined = key(14); - const _493: Key.Key | undefined | rt.None = rt.btreeKey(sorted, _496, true, rt.None); - const _491: boolean = _493 !== rt.None; - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_487, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtBool(_491, f)]; - const _483: string = rt.fmtFormat(["take ", args38[0], " ", args38[1]]); - rt.drop(_493); - rt.drop(_496); + const _493: Key.Key | undefined | rs.None = rs.btreeKey(sorted, _496, true, rs.None); + const _491: boolean = _493 !== rs.None; + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_487, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtBool(_491, f)]; + const _483: string = rs.fmtFormat(["take ", args38[0], " ", args38[1]]); + rs.drop(_493); + rs.drop(_496); Log.note(log, _483); - rt.drop(taken2); + rs.drop(taken2); const _508: Key.Key | undefined = key(10); - rt.btreeAdd(sorted, _508, rt.drop); - const least: Key.Key | undefined | rt.None = rt.btreePopKey(sorted, false, rt.None); - const most: Key.Key | undefined | rt.None = rt.btreePopKey(sorted, true, rt.None); - const _522: rt.u32 | undefined | rt.None = option_map$0hegtde(least, (o34: Key.Key | undefined): rt.u32 | undefined => { - const _041: rt.u32 | undefined = _348(o34); - rt.drop(o34); + rs.btreeAdd(sorted, _508, rs.drop); + const least: Key.Key | undefined | rs.None = rs.btreePopKey(sorted, false, rs.None); + const most: Key.Key | undefined | rs.None = rs.btreePopKey(sorted, true, rs.None); + const _522: rs.u32 | undefined | rs.None = option_map$150c7g4(least, (o34: Key.Key | undefined): rs.u32 | undefined => { + const _041: rs.u32 | undefined = _348(o34); + rs.drop(o34); return _041; }); - const _526: rt.u32 | undefined | rt.None = option_map$0hegtde(most, (o35: Key.Key | undefined): rt.u32 | undefined => { - const _042: rt.u32 | undefined = _348(o35); - rt.drop(o35); + const _526: rs.u32 | undefined | rs.None = option_map$150c7g4(most, (o35: Key.Key | undefined): rs.u32 | undefined => { + const _042: rs.u32 | undefined = _348(o35); + rs.drop(o35); return _042; }); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_522, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_526, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["popped ", args40[0], " ", args40[1]])); - const hashed: rt.HashSet = rt.hashNew(rt.hashing(rt.hashOption(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined), rt.eqOption(Key.eq$cmp_PartialEq))) as rt.HashSet; + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_522, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_526, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["popped ", args40[0], " ", args40[1]])); + const hashed: rs.HashSet = rs.hashNew(rs.hashing(rs.hashOption(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined), rs.eqOption(Key.eq$cmp_PartialEq))) as rs.HashSet; const _537: Key.Key | undefined = key(11); - rt.hashAdd(hashed, _537, rt.drop); - const part23 = option_map$0hegtde(rt.hashKey(hashed, undefined, false, rt.None), (o36: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o36, (k9: Key.Key): rt.u32 => { + rs.hashAdd(hashed, _537, rs.drop); + const part23 = option_map$150c7g4(rs.hashKey(hashed, undefined, false, rs.None), (o36: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o36, (k9: Key.Key): rs.u32 => { return k9.id; }); }); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part23, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["hashed ", args42[0]])); - rt.hashAdd(hashed, undefined as Key.Key | undefined, rt.drop); - const _567: rt.u32 | undefined | rt.None = option_map$0hegtde(rt.hashKey(hashed, undefined, true, rt.None), (o37: Key.Key | undefined): rt.u32 | undefined => { - const _045: rt.u32 | undefined = _348(o37); - rt.drop(o37); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["hashed ", args42[0]])); + rs.hashAdd(hashed, undefined as Key.Key | undefined, rs.drop); + const _567: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.hashKey(hashed, undefined, true, rs.None), (o37: Key.Key | undefined): rs.u32 | undefined => { + const _045: rs.u32 | undefined = _348(o37); + rs.drop(o37); return _045; }); - const _571: rt.u32 | undefined | rt.None = option_map$0hegtde(rt.hashKey(hashed, undefined, true, rt.None), (o38: Key.Key | undefined): rt.u32 | undefined => { - const _046: rt.u32 | undefined = _348(o38); - rt.drop(o38); + const _571: rs.u32 | undefined | rs.None = option_map$150c7g4(rs.hashKey(hashed, undefined, true, rs.None), (o38: Key.Key | undefined): rs.u32 | undefined => { + const _046: rs.u32 | undefined = _348(o38); + rs.drop(o38); return _046; }); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_567, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(_571, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["taken ", args44[0], " ", args44[1]])); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_567, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(_571, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["taken ", args44[0], " ", args44[1]])); const _584: Key.Key | undefined = key(11); - const replaced2: Key.Key | undefined | rt.None = rt.hashReplace(hashed, _584, rt.None); - const part26 = option_map$0hegtde(replaced2, (o39: Key.Key | undefined): rt.u32 | undefined => { - return option_map$0782hf5(o39, (k10: Key.Key): rt.u32 => { + const replaced2: Key.Key | undefined | rs.None = rs.hashReplace(hashed, _584, rs.None); + const part26 = option_map$150c7g4(replaced2, (o39: Key.Key | undefined): rs.u32 | undefined => { + return option_map$0bmexgo(o39, (k10: Key.Key): rs.u32 => { return k10.id; }); }); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part26, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["replaced ", args46[0]])); - rt.drop(replaced2); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part26, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["replaced ", args46[0]])); + rs.drop(replaced2); const _605: Key.Key | undefined = key(11); - const held: Key.Key | undefined | rt.None = rt.hashKey(hashed, _605, true, rt.None); - rt.drop(_605); - const part28 = option_map$0hegtde(held, (o40: Key.Key | undefined): rt.u32 | undefined => { - const _049: rt.u32 | undefined = _348(o40); - rt.drop(o40); + const held: Key.Key | undefined | rs.None = rs.hashKey(hashed, _605, true, rs.None); + rs.drop(_605); + const part28 = option_map$150c7g4(held, (o40: Key.Key | undefined): rs.u32 | undefined => { + const _049: rs.u32 | undefined = _348(o40); + rs.drop(o40); return _049; }); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part28, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["held ", args48[0]])); - const _628: rt.usize = heap.items.length; - const _631: rt.usize = rt.btreeLen(sorted); - const _634: rt.usize = rt.hashLen(hashed); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_628, f), (f: rt.Formatter) => rt.usizeDisplay(_631, f), (f: rt.Formatter) => rt.usizeDisplay(_634, f)]; - Log.note(log, rt.fmtFormat(["left ", args50[0], " ", args50[1], " ", args50[2]])); - rt.hashDrop(hashed, rt.drop); - rt.btreeDrop(sorted, rt.drop); - rt.heapDrop(heap, rt.drop); - rt.dequeDrop(q, rt.drop); - rt.drop(kept); - rt.dropVec(v); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["held ", args48[0]])); + const _628: rs.usize = heap.items.length; + const _631: rs.usize = rs.btreeLen(sorted); + const _634: rs.usize = rs.hashLen(hashed); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_628, f), (f: rs.Formatter) => rs.usizeDisplay(_631, f), (f: rs.Formatter) => rs.usizeDisplay(_634, f)]; + Log.note(log, rs.fmtFormat(["left ", args50[0], " ", args50[1], " ", args50[2]])); + rs.hashDrop(hashed, rs.drop); + rs.btreeDrop(sorted, rs.drop); + rs.heapDrop(heap, rs.drop); + rs.dequeDrop(q, rs.drop); + rs.drop(kept); + rs.dropVec(v); } /** @@ -1178,92 +1178,92 @@ export function elements(log: Log.Log, id: rt.u32): void { * `min` of the operand they do not return, read by the keys' counts; what `or_insert` * drops of a value JS copies, which it returns a place for; and what `into_inner` gives. */ -export function arcs(log: Log.Log, id: rt.u32): void { - const count: (a0: string, a1: rt.Arc) => undefined = (what: string, key: rt.Arc): undefined => { - const _92: rt.usize = key.strong; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, what), (f: rt.Formatter) => rt.usizeDisplay(_92, f)]; - Log.note(log, rt.fmtFormat([args14[0], " ", args14[1]])); +export function arcs(log: Log.Log, id: rs.u32): void { + const count: (a0: string, a1: rs.Arc) => undefined = (what: string, key: rs.Arc): undefined => { + const _92: rs.usize = key.strong; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, what), (f: rs.Formatter) => rs.usizeDisplay(_92, f)]; + Log.note(log, rs.fmtFormat([args14[0], " ", args14[1]])); }; - const name: rt.Arc = new rt.Arc("name"); - const other: rt.Arc = new rt.Arc("other"); - const map: rt.HashMap, rt.u8> = rt.hashNew(rt.hashing(rt.hashArc(rt.hashStr), rt.eqArc(rt.same, true))) as rt.HashMap, rt.u8>; - const _9: rt.Arc = rt.arcClone(name); - rt.hashInsert(map, _9, 1, rt.drop); - const _13: rt.Arc = rt.arcClone(name); - rt.hashInsert(map, _13, 2, rt.drop); - const _17: rt.Arc = rt.arcClone(other); - rt.hashInsert(map, _17, 3, rt.drop); + const name: rs.Arc = new rs.Arc("name"); + const other: rs.Arc = new rs.Arc("other"); + const map: rs.HashMap, rs.u8> = rs.hashNew(rs.hashing(rs.hashArc(rs.hashStr), rs.eqArc(rs.same, true))) as rs.HashMap, rs.u8>; + const _9: rs.Arc = rs.arcClone(name); + rs.hashInsert(map, _9, 1, rs.drop); + const _13: rs.Arc = rs.arcClone(name); + rs.hashInsert(map, _13, 2, rs.drop); + const _17: rs.Arc = rs.arcClone(other); + rs.hashInsert(map, _17, 3, rs.drop); count("insert", name); - const tree: rt.BTreeMap, rt.u8> = rt.btreeNew(rt.cmpArc(rt.cmpStr)) as rt.BTreeMap, rt.u8>; - const _27: rt.Arc = rt.arcClone(other); - rt.btreeInsert(tree, _27, 1, rt.drop); - const _31: rt.Arc = rt.arcClone(other); - rt.btreeInsert(tree, _31, 2, rt.drop); + const tree: rs.BTreeMap, rs.u8> = rs.btreeNew(rs.cmpArc(rs.cmpStr)) as rs.BTreeMap, rs.u8>; + const _27: rs.Arc = rs.arcClone(other); + rs.btreeInsert(tree, _27, 1, rs.drop); + const _31: rs.Arc = rs.arcClone(other); + rs.btreeInsert(tree, _31, 2, rs.drop); count("tree", other); - const _41: rt.Arc = rt.arcClone(name); - const _38: rt.Place = rt.entryOrInsertMut(rt.entry(map, _41, rt.drop), 0); - _38.v = rt.u8Add(_38.v, 1); + const _41: rs.Arc = rs.arcClone(name); + const _38: rs.Place = rs.entryOrInsertMut(rs.entry(map, _41, rs.drop), 0); + _38.v = rs.u8Add(_38.v, 1); count("entry", name); - rt.hashRemove(map, name, rt.drop); + rs.hashRemove(map, name, rs.drop); count("remove", name); - rt.btreeRemove(tree, new rt.Arc("other"), rt.drop); + rs.btreeRemove(tree, new rs.Arc("other"), rs.drop); count("removed", other); - const max: rt.Arc = rt.ordMax(rt.arcClone(name), rt.arcClone(other), rt.cmpLt(rt.cmpArc(rt.cmpStr)), rt.drop); - const min: rt.Arc = rt.ordMin(rt.arcClone(name), rt.arcClone(other), rt.cmpLt(rt.cmpArc(rt.cmpStr)), rt.drop); + const max: rs.Arc = rs.ordMax(rs.arcClone(name), rs.arcClone(other), rs.cmpLt(rs.cmpArc(rs.cmpStr)), rs.drop); + const min: rs.Arc = rs.ordMin(rs.arcClone(name), rs.arcClone(other), rs.cmpLt(rs.cmpArc(rs.cmpStr)), rs.drop); const _82: string = max.value; const _86: string = min.value; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _82), (f: rt.Formatter) => rt.fmtPad(f, _86)]; - Log.note(log, rt.fmtFormat(["max ", args2[0], " min ", args2[1]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _82), (f: rs.Formatter) => rs.fmtPad(f, _86)]; + Log.note(log, rs.fmtFormat(["max ", args2[0], " min ", args2[1]])); count("name", name); count("other", other); - lib_drop$tuple2_sync_Arc_str_sync_Arc_str([max, min] as [rt.Arc, rt.Arc]); - const tags: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _108 = { tag: "One", _0: Guard.new(rt.u32Add(id, 1), Log.clone$Clone(log)) } as Held.Held; - lib_drop$Option_drops_Held(rt.btreeInsert(tags, 1, _108)); - const _113: rt.Place = rt.entryOrInsertMut(rt.entry(tags, 1), { tag: "One", _0: Guard.new(rt.u32Add(id, 2), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); + lib_drop$tuple2_sync_Arc_str_sync_Arc_str([max, min] as [rs.Arc, rs.Arc]); + const tags: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _108 = { tag: "One", _0: Guard.new(rs.u32Add(id, 1), Log.clone$Clone(log)) } as Held.Held; + lib_drop$Option_drops_Held(rs.btreeInsert(tags, 1, _108)); + const _113: rs.Place = rs.entryOrInsertMut(rs.entry(tags, 1), { tag: "One", _0: Guard.new(rs.u32Add(id, 2), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); if (_113.v.tag === "One") { const part8 = Guard.id(_113.v._0); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part8, f)]; - Log.note(log, rt.fmtFormat(["tag ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; + Log.note(log, rs.fmtFormat(["tag ", args4[0]])); } - rt.entryOrInsertMut(rt.entry(tags, 2), { tag: "Two", _0: Guard.new(rt.u32Add(id, 3), Log.clone$Clone(log)), _1: Guard.new(rt.u32Add(id, 4), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); - const part9 = rt.btreeLen(tags); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part9, f)]; - Log.note(log, rt.fmtFormat(["tags ", args6[0]])); - const shared: rt.Arc = new rt.Arc(Guard.new(rt.u32Add(id, 5), Log.clone$Clone(log))); - const weak: rt.Weak = new rt.Weak(shared); - const clone: rt.Arc = rt.arcClone(shared); - const _176: Guard.Guard | undefined = rt.arcIntoInner(shared); + rs.entryOrInsertMut(rs.entry(tags, 2), { tag: "Two", _0: Guard.new(rs.u32Add(id, 3), Log.clone$Clone(log)), _1: Guard.new(rs.u32Add(id, 4), Log.clone$Clone(log)) } as Held.Held, lib_drop$drops_Held); + const part9 = rs.btreeLen(tags); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; + Log.note(log, rs.fmtFormat(["tags ", args6[0]])); + const shared: rs.Arc = new rs.Arc(Guard.new(rs.u32Add(id, 5), Log.clone$Clone(log))); + const weak: rs.Weak = new rs.Weak(shared); + const clone: rs.Arc = rs.arcClone(shared); + const _176: Guard.Guard | undefined = rs.arcIntoInner(shared); const part10 = _176 !== undefined; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part10, f)]; - const _170: string = rt.fmtFormat(["into_inner ", args8[0]]); - rt.drop(_176); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part10, f)]; + const _170: string = rs.fmtFormat(["into_inner ", args8[0]]); + rs.drop(_176); Log.note(log, _170); - const inner: Guard.Guard | undefined = rt.arcIntoInner(clone); - const _188: rt.u32 | undefined = option_map$0lq7mno(inner, Guard.id); - const _194: rt.Arc | undefined = rt.weakUpgrade(weak); + const inner: Guard.Guard | undefined = rs.arcIntoInner(clone); + const _188: rs.u32 | undefined = option_map$02u0dmi(inner, Guard.id); + const _194: rs.Arc | undefined = rs.weakUpgrade(weak); const _192: boolean = _194 !== undefined; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_188, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtBool(_192, f)]; - const _184: string = rt.fmtFormat(["into_inner ", args10[0], " ", args10[1]]); - rt.drop(_194); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_188, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_192, f)]; + const _184: string = rs.fmtFormat(["into_inner ", args10[0], " ", args10[1]]); + rs.drop(_194); Log.note(log, _184); - rt.drop(inner); - const held: rt.Arc = new rt.Arc(Guard.new(rt.u32Add(id, 6), Log.clone$Clone(log))); - const again: rt.Arc = rt.arcClone(held); - rt.drop(rt.arcIntoInner(held, rt.None)); - const inner2: Guard.Guard | undefined | rt.None = rt.arcIntoInner(again, rt.None); - const part11 = option_map$0ccnsmq(inner2, (o: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(o, Guard.id); + rs.drop(inner); + const held: rs.Arc = new rs.Arc(Guard.new(rs.u32Add(id, 6), Log.clone$Clone(log))); + const again: rs.Arc = rs.arcClone(held); + rs.drop(rs.arcIntoInner(held, rs.None)); + const inner2: Guard.Guard | undefined | rs.None = rs.arcIntoInner(again, rs.None); + const part11 = option_map$1x5kkz1(inner2, (o: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(o, Guard.id); }); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part11, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["rc ", args12[0]])); - rt.drop(inner2); - rt.hashDrop(map, rt.drop); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part11, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["rc ", args12[0]])); + rs.drop(inner2); + rs.hashDrop(map, rs.drop); count("dropped", name); count("dropped", other); weak[Symbol.dispose](); - rt.btreeDrop(tags, undefined, lib_drop$drops_Held); - rt.btreeDrop(tree, rt.drop); + rs.btreeDrop(tags, undefined, lib_drop$drops_Held); + rs.btreeDrop(tree, rs.drop); other[Symbol.dispose](); name[Symbol.dispose](); } @@ -1272,7 +1272,7 @@ export function arcs(log: Log.Log, id: rt.u32): void { * Run scenario `arg % 42` of what std's by-value consumers drop of adaptors that hold * closures that drop, and of zips of items that drop. */ -export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { folds_folded(log, id, arg); } @@ -1280,7 +1280,7 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Run scenario `arg % 12` of std's calls of a closure that owns a guard. The last panics * in a `try_fold`. */ -export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { called_called(log, id, arg); } @@ -1288,7 +1288,7 @@ export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Run scenario `arg % 18` of what folds back to front, through what wraps a closure beside * another, and through a crate's iterator with folds of its own. The last panics in a fold. */ -export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { folds_rfolded(log, id, arg); } @@ -1297,7 +1297,7 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Three panic, each with std's message: in a `for_each`, a drain past the end, and a * range that panics as `String`'s drop it. */ -export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { inside_inside(log, id, arg); } @@ -1305,12 +1305,12 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Run scenario `arg % 10` of what a `flatten` drops of inner iterators that hold items * once they end. */ -export function flattened(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { flattened_flattened(log, id, arg); } /** Run scenario `arg % 9` of what std drops of a zip it reads by index. */ -export function indexed(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { indexed_indexed(log, id, arg); } @@ -1318,7 +1318,7 @@ export function indexed(log: Log.Log, id: rt.u32, arg: rt.u8): void { * Run scenario `arg % 7` of where std drops a closure given to a consumer or an entry. * The last panics in a fold. */ -export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { released_released(log, id, arg); } @@ -1327,22 +1327,22 @@ export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { * of keys whose own impls disagree, `max_by_key` and `min_by_key` by keys that drop, and * a map's `into_keys`' `max` and `min`. The last panics in the sort. */ -export function orders(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { orders_orders(log, id, arg); } /** Run scenario `arg % 3` of where std drops a closure given to a string's search or edit. */ -export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { searched_searched(log, id, arg); } /** Run scenario `arg % 9` of what std's comparisons of iterators drop. */ -export function compared(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { iters_compared(log, id, arg); } /** Run scenario `arg % 8` of what a `LinkedList` drops, and when. */ -export function lists(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function lists(log: Log.Log, id: rs.u32, arg: rs.u8): void { lists_run(log, id, arg); } @@ -1351,19 +1351,19 @@ export function lists(log: Log.Log, id: rt.u32, arg: rt.u8): void { * `Ord`'s defaults, and an iterator's `max` and `min` drop. One ends in an index past the * end, which panics with std's message. */ -export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const key: (a0: rt.u32) => Key.Key = (n: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function edited(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; const ids: (a0: Key.Key[]) => string = (v13: Key.Key[]): string => { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.iterSlice(v13), (k: Key.Key): string => { - const _43: rt.u32 = rt.u32Sub(k.id, id); - return rt.fmtToString((f: rt.Formatter) => rt.u32Display(_43, f)); + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.iterSlice(v13), (k: Key.Key): string => { + const _43: rs.u32 = rs.u32Sub(k.id, id); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_43, f)); }), undefined, 12, true).items, ","); }; - const _8: rt.u8 = rt.u8Rem(arg, 9); + const _8: rs.u8 = rs.u8Rem(arg, 9); if (_8 === 0) { - const v2: rt.Vec = new rt.Vec(); + const v2: rs.Vec = new rs.Vec(); const _14: Key.Key = key(1); v2.items.push(_14); const _19: Key.Key = key(2); @@ -1372,22 +1372,22 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { v2.items.push(_24); const _29: Key.Key = key(4); v2.items.push(_29); - const v: rt.Vec = v2; - rt.vecRetain(v, (k6: Key.Key): boolean => { - return rt.u32Rem(rt.u32Sub(k6.id, id), 2) === 1; - }, rt.drop); + const v: rs.Vec = v2; + rs.vecRetain(v, (k6: Key.Key): boolean => { + return rs.u32Rem(rs.u32Sub(k6.id, id), 2) === 1; + }, rs.drop); const part25 = ids(v.items); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part25)]; - Log.note(log, rt.fmtFormat(["retained ", args2[0]])); - rt.vecRetain(v, (k7: Key.Key): boolean => { - return k7.id !== rt.u32Add(id, 3); - }, rt.drop); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; + Log.note(log, rs.fmtFormat(["retained ", args2[0]])); + rs.vecRetain(v, (k7: Key.Key): boolean => { + return k7.id !== rs.u32Add(id, 3); + }, rs.drop); const part27 = ids(v.items); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part27)]; - Log.note(log, rt.fmtFormat(["retained ", args4[0]])); - rt.dropVec(v); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part27)]; + Log.note(log, rs.fmtFormat(["retained ", args4[0]])); + rs.dropVec(v); } else if (_8 === 1) { - const v4: rt.Vec = new rt.Vec(); + const v4: rs.Vec = new rs.Vec(); const _74: Key.Key = key(1); v4.items.push(_74); const _79: Key.Key = key(1); @@ -1398,144 +1398,144 @@ export function edited(log: Log.Log, id: rt.u32, arg: rt.u8): void { v4.items.push(_89); const _94: Key.Key = key(3); v4.items.push(_94); - const v3: rt.Vec = v4; - rt.vecDedupBy(v3, Key.eq$cmp_PartialEq, rt.drop); + const v3: rs.Vec = v4; + rs.vecDedupBy(v3, Key.eq$cmp_PartialEq, rs.drop); const part19 = ids(v3.items); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part19)]; - Log.note(log, rt.fmtFormat(["deduped ", args6[0]])); - rt.vecDedupByKey(v3, (k5: Key.Key): rt.u32 => { - return rt.u32Div(k5.id, 2); - }, rt.same, rt.drop); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part19)]; + Log.note(log, rs.fmtFormat(["deduped ", args6[0]])); + rs.vecDedupByKey(v3, (k5: Key.Key): rs.u32 => { + return rs.u32Div(k5.id, 2); + }, rs.same, rs.drop); const part21 = ids(v3.items); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part21)]; - Log.note(log, rt.fmtFormat(["deduped ", args8[0]])); - rt.vecDedupBy(v3, (a: Key.Key, b: Key.Key): boolean => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; + Log.note(log, rs.fmtFormat(["deduped ", args8[0]])); + rs.vecDedupBy(v3, (a: Key.Key, b: Key.Key): boolean => { return a.id > b.id; - }, rt.drop); + }, rs.drop); const part23 = ids(v3.items); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part23)]; - Log.note(log, rt.fmtFormat(["deduped ", args10[0]])); - rt.dropVec(v3); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; + Log.note(log, rs.fmtFormat(["deduped ", args10[0]])); + rs.dropVec(v3); } else if (_8 === 2) { - const v6: rt.Vec = new rt.Vec(); + const v6: rs.Vec = new rs.Vec(); const _152: Key.Key = key(1); v6.items.push(_152); const _157: Key.Key = key(2); v6.items.push(_157); const _162: Key.Key = key(3); v6.items.push(_162); - const v5: rt.Vec = v6; - rt.vecSwapRemove(v5, 0)[Symbol.dispose](); + const v5: rs.Vec = v6; + rs.vecSwapRemove(v5, 0)[Symbol.dispose](); const part17 = ids(v5.items); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part17)]; - Log.note(log, rt.fmtFormat(["swapped ", args12[0]])); - rt.vecSwapRemove(v5, 3)[Symbol.dispose](); - rt.dropVec(v5); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part17)]; + Log.note(log, rs.fmtFormat(["swapped ", args12[0]])); + rs.vecSwapRemove(v5, 3)[Symbol.dispose](); + rs.dropVec(v5); } else if (_8 === 3) { - const v8: rt.Vec = new rt.Vec(); + const v8: rs.Vec = new rs.Vec(); const _190: Key.Key = key(1); v8.items.push(_190); const _195: Key.Key = key(2); v8.items.push(_195); - const v7: rt.Vec = v8; - const _209: rt.Vec = rt.vecFrom(v7.items.map(Key.clone$Clone)); + const v7: rs.Vec = v8; + const _209: rs.Vec = rs.vecFrom(v7.items.map(Key.clone$Clone)); const part15 = ids(_209.items); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part15)]; - const _200: string = rt.fmtFormat(["cloned ", args14[0]]); - rt.dropVec(_209); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; + const _200: string = rs.fmtFormat(["cloned ", args14[0]]); + rs.dropVec(_209); Log.note(log, _200); - rt.dropVec(v7); + rs.dropVec(v7); } else if (_8 === 4) { const pair: [Key.Key, Key.Key] = [key(1), key(2)]; - lib_drop$tuple2_drops_Key_drops_Key(rt.tupleClone(pair, [Key.clone$Clone, Key.clone$Clone])); + lib_drop$tuple2_drops_Key_drops_Key(rs.tupleClone(pair, [Key.clone$Clone, Key.clone$Clone])); lib_drop$tuple2_drops_Key_drops_Key(pair); } else if (_8 === 5) { - const v10: rt.Vec = new rt.Vec(); + const v10: rs.Vec = new rs.Vec(); const _229: Key.Key = key(1); v10.items.push(_229); const _234: Key.Key = key(2); v10.items.push(_234); const _239: Key.Key = key(3); v10.items.push(_239); - const v9: rt.Vec = v10; + const v9: rs.Vec = v10; const _244: Key.Key = key(4); - rt.vecInsert(v9, 1, _244); + rs.vecInsert(v9, 1, _244); const part9 = ids(v9.items); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part9)]; - Log.note(log, rt.fmtFormat(["inserted ", args16[0]])); - rt.vecRemove(v9, 0)[Symbol.dispose](); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part9)]; + Log.note(log, rs.fmtFormat(["inserted ", args16[0]])); + rs.vecRemove(v9, 0)[Symbol.dispose](); const part11 = ids(v9.items); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part11)]; - Log.note(log, rt.fmtFormat(["removed ", args18[0]])); - rt.vecTruncate(v9, 1, rt.drop); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; + Log.note(log, rs.fmtFormat(["removed ", args18[0]])); + rs.vecTruncate(v9, 1, rs.drop); const part13 = ids(v9.items); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part13)]; - Log.note(log, rt.fmtFormat(["truncated ", args20[0]])); - rt.vecTruncate(v9, 0, rt.drop); - rt.dropVec(v9); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part13)]; + Log.note(log, rs.fmtFormat(["truncated ", args20[0]])); + rs.vecTruncate(v9, 0, rs.drop); + rs.dropVec(v9); } else if (_8 === 6) { - const v11: rt.Vec = new rt.Vec(); + const v11: rs.Vec = new rs.Vec(); const _305: Key.Key = key(1); v11.items.push(_305); const _310: Key.Key = key(3); v11.items.push(_310); const _315: Key.Key = key(5); v11.items.push(_315); - const part6 = option_mapOr$1w10sgd(rt.iterMaxByKey(rt.vecIntoIter(v11, rt.drop), (k2: Key.Key): rt.u32 => { - return rt.u32Rem(rt.u32Sub(k2.id, id), 3); - }, rt.lt, true, rt.drop), 0, (k3: Key.Key): rt.u32 => { - const _05: rt.u32 = rt.u32Sub(k3.id, id); + const part6 = option_mapOr$0mko9ta(rs.iterMaxByKey(rs.vecIntoIter(v11, rs.drop), (k2: Key.Key): rs.u32 => { + return rs.u32Rem(rs.u32Sub(k2.id, id), 3); + }, rs.lt, true, rs.drop), 0, (k3: Key.Key): rs.u32 => { + const _05: rs.u32 = rs.u32Sub(k3.id, id); k3[Symbol.dispose](); return _05; }); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["max ", args22[0]])); - const v12: rt.Vec = new rt.Vec(); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["max ", args22[0]])); + const v12: rs.Vec = new rs.Vec(); const _339: Key.Key = key(3); v12.items.push(_339); const _344: Key.Key = key(1); v12.items.push(_344); const _349: Key.Key = key(2); v12.items.push(_349); - const part7 = option_mapOr$1w10sgd(rt.iterMin(rt.vecIntoIter(v12, rt.drop), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), true, rt.drop), 0, (k4: Key.Key): rt.u32 => { - const _06: rt.u32 = rt.u32Sub(k4.id, id); + const part7 = option_mapOr$0mko9ta(rs.iterMin(rs.vecIntoIter(v12, rs.drop), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), true, rs.drop), 0, (k4: Key.Key): rs.u32 => { + const _06: rs.u32 = rs.u32Sub(k4.id, id); k4[Symbol.dispose](); return _06; }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["min ", args24[0]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["min ", args24[0]])); } else if (_8 === 7) { const boxed: Key.Key = key(1); const _377: Key.Key = Key.clone$Clone(boxed); - const part5 = rt.u32Sub(_377.id, id); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - const _371: string = rt.fmtFormat(["boxed ", args26[0]]); + const part5 = rs.u32Sub(_377.id, id); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + const _371: string = rs.fmtFormat(["boxed ", args26[0]]); _377[Symbol.dispose](); Log.note(log, _371); boxed[Symbol.dispose](); } else { - const _392: Key.Key = rt.ordMax(key(1), key(2), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), rt.drop); - const part = rt.u32Sub(_392.id, id); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - const _386: string = rt.fmtFormat(["max ", args28[0]]); + const _392: Key.Key = rs.ordMax(key(1), key(2), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); + const part = rs.u32Sub(_392.id, id); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + const _386: string = rs.fmtFormat(["max ", args28[0]]); _392[Symbol.dispose](); Log.note(log, _386); - const _412: Key.Key = rt.ordMin(key(5), key(4), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), rt.drop); - const part2 = rt.u32Sub(_412.id, id); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - const _406: string = rt.fmtFormat(["min ", args30[0]]); + const _412: Key.Key = rs.ordMin(key(5), key(4), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.drop); + const part2 = rs.u32Sub(_412.id, id); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + const _406: string = rs.fmtFormat(["min ", args30[0]]); _412[Symbol.dispose](); Log.note(log, _406); - const _432: Key.Key = rt.ordClamp(key(2), key(1), key(3), rt.cmpLe(Key.partialCmp$cmp_PartialOrd), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), rt.cmpGt(Key.partialCmp$cmp_PartialOrd), rt.drop); - const part3 = rt.u32Sub(_432.id, id); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - const _426: string = rt.fmtFormat(["clamped ", args32[0]]); + const _432: Key.Key = rs.ordClamp(key(2), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); + const part3 = rs.u32Sub(_432.id, id); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + const _426: string = rs.fmtFormat(["clamped ", args32[0]]); _432[Symbol.dispose](); Log.note(log, _426); - const _455: Key.Key = rt.ordClamp(key(0), key(1), key(3), rt.cmpLe(Key.partialCmp$cmp_PartialOrd), rt.cmpLt(Key.partialCmp$cmp_PartialOrd), rt.cmpGt(Key.partialCmp$cmp_PartialOrd), rt.drop); - const part4 = rt.u32Sub(_455.id, id); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - const _449: string = rt.fmtFormat(["clamped ", args34[0]]); + const _455: Key.Key = rs.ordClamp(key(0), key(1), key(3), rs.cmpLe(Key.partialCmp$cmp_PartialOrd), rs.cmpLt(Key.partialCmp$cmp_PartialOrd), rs.cmpGt(Key.partialCmp$cmp_PartialOrd), rs.drop); + const part4 = rs.u32Sub(_455.id, id); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + const _449: string = rs.fmtFormat(["clamped ", args34[0]]); _455[Symbol.dispose](); Log.note(log, _449); } diff --git a/ts/fixtures/task/expected/drops/called.ts b/ts/fixtures/task/expected/drops/called.ts index 118af39a1..3be660318 100644 --- a/ts/fixtures/task/expected/drops/called.ts +++ b/ts/fixtures/task/expected/drops/called.ts @@ -1,127 +1,127 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { copy$array_u32, drop$Result_cell_Ref_u32_cell_BorrowError as lib_drop$Result_cell_Ref_u32_cell_BorrowError, drop$Vec_model_Guard as lib_drop$Vec_model_Guard } from "../lib.ts"; -import { thenSome$1af3oea, thenSome$1j8foe9 } from "../core/bool.ts"; -import { map$1raha9y as option_map$1raha9y } from "../core/option.ts"; -import { mapErr$0nvqjog as result_mapErr$0nvqjog } from "../core/result.ts"; +import { thenSome$1bahm2u, thenSome$1n1oy1h } from "../core/bool.ts"; +import { map$06w9waf as option_map$06w9waf } from "../core/option.ts"; +import { mapErr$18fct1o as result_mapErr$18fct1o } from "../core/result.ts"; import * as Key from "../drops.Key.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 12`. The last panics in a `try_fold`, with the log so far. */ -export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { - let broke!: rt.u32 | undefined; +export function called(log: Log.Log, id: rs.u32, arg: rs.u8): void { + let broke!: rs.u32 | undefined; let f!: Guard.Guard; - const _536: () => rt.Iter = (): rt.Iter => { - return rt.vecIntoIter(new rt.Vec(), rt.drop); + const _536: () => rs.Iter = (): rs.Iter => { + return rs.vecIntoIter(new rs.Vec(), rs.drop); }; let _679: boolean = false; let _678: boolean = false; - const guard: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n3), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n3), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _10: [Guard.Guard, Guard.Guard] = [guard(20), guard(21)]; _679 = true; const c: Guard.Guard = _10[0]; _678 = true; const d: Guard.Guard = _10[1]; - const _17: rt.u8 = rt.u8Rem(arg, 12); + const _17: rs.u8 = rs.u8Rem(arg, 12); if (_17 === 0) { - const it: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const it: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _679 = false; const captured32 = c; const captured33 = id; - const n: rt.u32 | undefined = rt.iterTryFold(it, 0, rt.closure((n17: rt.u32, g24: Guard.Guard): rt.u32 | undefined => { - const _1014: rt.u32 = Guard.id(g24); - const _1317: rt.u32 = Guard.id(captured32); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1014, f), (f: rt.Formatter) => rt.u32Display(_1317, f)]; - Log.note(log, rt.fmtFormat(["try ", args82[0], " ", args82[1]])); - const _039: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g24) !== rt.u32Add(captured33, 3), rt.u32Sub(rt.u32Add(n17, Guard.id(g24)), captured33)); + const n: rs.u32 | undefined = rs.iterTryFold(it, 0, rs.closure((n17: rs.u32, g24: Guard.Guard): rs.u32 | undefined => { + const _1014: rs.u32 = Guard.id(g24); + const _1317: rs.u32 = Guard.id(captured32); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1317, f)]; + Log.note(log, rs.fmtFormat(["try ", args82[0], " ", args82[1]])); + const _039: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g24) !== rs.u32Add(captured33, 3), rs.u32Sub(rs.u32Add(n17, Guard.id(g24)), captured33)); g24[Symbol.dispose](); return _039; }, (): void => { captured32[Symbol.dispose](); }), true, true); - const _32: rt.u32 | undefined = option_map$1raha9y(rt.iterToOption(it.next()), (g25: Guard.Guard): rt.u32 => { - const _040: rt.u32 = Guard.id(g25); + const _32: rs.u32 | undefined = option_map$06w9waf(rs.iterToOption(it.next()), (g25: Guard.Guard): rs.u32 => { + const _040: rs.u32 = Guard.id(g25); g25[Symbol.dispose](); return _040; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(n, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_32, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["broke ", args2[0], " ", args2[1]])); - const m: rt.u32 | undefined = rt.iterTryFold(it, 0, (n18: rt.u32, g26: Guard.Guard): rt.u32 | undefined => { - const _041: rt.u32 | undefined = rt.u32Sub(rt.u32Add(n18, Guard.id(g26)), id); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(n, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_32, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["broke ", args2[0], " ", args2[1]])); + const m: rs.u32 | undefined = rs.iterTryFold(it, 0, (n18: rs.u32, g26: Guard.Guard): rs.u32 | undefined => { + const _041: rs.u32 | undefined = rs.u32Sub(rs.u32Add(n18, Guard.id(g26)), id); g26[Symbol.dispose](); return _041; }, true); - const _51: rt.u32 = Guard.id(d); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(m, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_51, f)]; - Log.note(log, rt.fmtFormat(["ended ", args4[0], " ", args4[1]])); - rt.drop(it); + const _51: rs.u32 = Guard.id(d); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(m, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_51, f)]; + Log.note(log, rs.fmtFormat(["ended ", args4[0], " ", args4[1]])); + rs.drop(it); } else if (_17 === 1) { - const _60: rt.Iter = rt.iterChain(rt.vecIntoIter(guards(1, 3), rt.drop), rt.vecIntoIter(guards(3, 6), rt.drop)); + const _60: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop)); _679 = false; const captured31 = c; - const it2: rt.Iter<[Guard.Guard, rt.u32]> = rt.iterMap(_60, rt.closure((g20: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g20, Guard.id(captured31)] as [Guard.Guard, rt.u32]; + const it2: rs.Iter<[Guard.Guard, rs.u32]> = rs.iterMap(_60, rs.closure((g20: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g20, Guard.id(captured31)] as [Guard.Guard, rs.u32]; }, (): void => { captured31[Symbol.dispose](); })); - const part17 = result_mapErr$0nvqjog(rt.iterTryFold(it2, 0, (n15: rt.u32, _335: [Guard.Guard, rt.u32]): rt.Result => { - let _036!: rt.Result; + const part17 = result_mapErr$18fct1o(rs.iterTryFold(it2, 0, (n15: rs.u32, _335: [Guard.Guard, rs.u32]): rs.Result => { + let _036!: rs.Result; let _2112: boolean = false; _2112 = true; const g21: Guard.Guard = _335[0]; - if (!(Guard.id(g21) === rt.u32Add(id, 4))) { - _036 = rt.Ok(rt.u32Sub(rt.u32Add(n15, Guard.id(g21)), id)); + if (!(Guard.id(g21) === rs.u32Add(id, 4))) { + _036 = rs.Ok(rs.u32Sub(rs.u32Add(n15, Guard.id(g21)), id)); } else { _2112 = false; - _036 = rt.Err(g21); + _036 = rs.Err(g21); } if (_2112) { g21[Symbol.dispose](); } _2112 = false; return _036; - }), (g22: Guard.Guard): rt.u32 => { - const _037: rt.u32 = Guard.id(g22); + }), (g22: Guard.Guard): rs.u32 => { + const _037: rs.u32 = Guard.id(g22); g22[Symbol.dispose](); return _037; }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part17, f, rt.u32Debug, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["err ", args6[0]])); - const r2: rt.Result = rt.iterTryFold(it2, 0, (n16: rt.u32, _336: [Guard.Guard, rt.u32]): rt.Result => { + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part17, f, rs.u32Debug, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["err ", args6[0]])); + const r2: rs.Result = rs.iterTryFold(it2, 0, (n16: rs.u32, _336: [Guard.Guard, rs.u32]): rs.Result => { const g23: Guard.Guard = _336[0]; - const _038: rt.Result = rt.Ok(rt.u32Sub(rt.u32Add(n16, Guard.id(g23)), id)); + const _038: rs.Result = rs.Ok(rs.u32Sub(rs.u32Add(n16, Guard.id(g23)), id)); g23[Symbol.dispose](); return _038; }); - const _94: rt.u32 = Guard.id(d); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r2, f, rt.u32Debug, rt.fmtUnit), (f: rt.Formatter) => rt.u32Display(_94, f)]; - Log.note(log, rt.fmtFormat(["ok ", args8[0], " ", args8[1]])); - rt.drop(it2); + const _94: rs.u32 = Guard.id(d); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r2, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_94, f)]; + Log.note(log, rs.fmtFormat(["ok ", args8[0], " ", args8[1]])); + rs.drop(it2); } else if (_17 === 2) { - const _103: rt.Iter = rt.iterRev(rt.vecIntoIter(guards(1, 6), rt.drop)); + const _103: rs.Iter = rs.iterRev(rs.vecIntoIter(guards(1, 6), rs.drop)); _679 = false; const captured29 = c; - const it3: rt.Iter = rt.iterFilter(_103, rt.closure((g17: Guard.Guard): boolean => { - return Guard.id(g17) !== rt.u32Sub(Guard.id(captured29), 18); + const it3: rs.Iter = rs.iterFilter(_103, rs.closure((g17: Guard.Guard): boolean => { + return Guard.id(g17) !== rs.u32Sub(Guard.id(captured29), 18); }, (): void => { captured29[Symbol.dispose](); - }), rt.drop); - const r3: rt.Result = rt.iterTryFold(it3, 0, (n13: rt.u32, g18: Guard.Guard): rt.Result => { - let _033!: rt.Result; + }), rs.drop); + const r3: rs.Result = rs.iterTryFold(it3, 0, (n13: rs.u32, g18: Guard.Guard): rs.Result => { + let _033!: rs.Result; let _2013: boolean = false; _2013 = true; - if (!(Guard.id(g18) === rt.u32Add(id, 3))) { - _033 = rt.Ok(rt.u32Sub(rt.u32Add(n13, Guard.id(g18)), id)); + if (!(Guard.id(g18) === rs.u32Add(id, 3))) { + _033 = rs.Ok(rs.u32Sub(rs.u32Add(n13, Guard.id(g18)), id)); } else { _2013 = false; - _033 = rt.Err(g18); + _033 = rs.Err(g18); } if (_2013) { g18[Symbol.dispose](); @@ -136,421 +136,421 @@ export function called(log: Log.Log, id: rt.u32, arg: rt.u8): void { broke = Guard.id(g); g[Symbol.dispose](); } - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(broke, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["break ", args10[0]])); - const _130: rt.Iter = rt.vecIntoIter(new rt.Vec(), rt.drop); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["break ", args10[0]])); + const _130: rs.Iter = rs.vecIntoIter(new rs.Vec(), rs.drop); _678 = false; const captured30 = d; - const none: rt.u32 | undefined = rt.iterTryFold(_130, 0, rt.closure((n14: rt.u32, g19: Guard.Guard): rt.u32 | undefined => { - const _034: rt.u32 | undefined = rt.u32Add(rt.u32Add(n14, Guard.id(g19)), Guard.id(captured30)); + const none: rs.u32 | undefined = rs.iterTryFold(_130, 0, rs.closure((n14: rs.u32, g19: Guard.Guard): rs.u32 | undefined => { + const _034: rs.u32 | undefined = rs.u32Add(rs.u32Add(n14, Guard.id(g19)), Guard.id(captured30)); g19[Symbol.dispose](); return _034; }, (): void => { captured30[Symbol.dispose](); }), true, true); - rt.drop(_130); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(none, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["none ", args12[0]])); - rt.drop(it3); + rs.drop(_130); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["none ", args12[0]])); + rs.drop(it3); } else if (_17 === 3) { - const it4: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const it4: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _679 = false; const captured26 = id; const captured27 = c; - const part14 = rt.iterTryForEach(it4, rt.closure((g14: Guard.Guard): rt.Result => { - let _029!: rt.Result; - if (!(Guard.id(g14) === rt.u32Add(captured26, 2))) { + const part14 = rs.iterTryForEach(it4, rs.closure((g14: Guard.Guard): rs.Result => { + let _029!: rs.Result; + if (!(Guard.id(g14) === rs.u32Add(captured26, 2))) { const part13 = Guard.id(g14); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part13, f)]; - Log.note(log, rt.fmtFormat(["each ", args80[0]])); - _029 = rt.OK; + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; + Log.note(log, rs.fmtFormat(["each ", args80[0]])); + _029 = rs.OK; } else { - _029 = rt.Err(rt.u32Sub(rt.u32Add(Guard.id(g14), Guard.id(captured27)), Guard.id(captured27))); + _029 = rs.Err(rs.u32Sub(rs.u32Add(Guard.id(g14), Guard.id(captured27)), Guard.id(captured27))); } g14[Symbol.dispose](); return _029; }, (): void => { captured27[Symbol.dispose](); }), undefined, true); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part14, f, rt.fmtUnit, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["each ", args14[0]])); - const part15 = rt.iterTryForEach(it4, (g15: Guard.Guard): rt.Result => { - let _030!: rt.Result; - if (!(Guard.id(g15) === rt.u32Add(id, 4))) { - _030 = rt.OK; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part14, f, rs.fmtUnit, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["each ", args14[0]])); + const part15 = rs.iterTryForEach(it4, (g15: Guard.Guard): rs.Result => { + let _030!: rs.Result; + if (!(Guard.id(g15) === rs.u32Add(id, 4))) { + _030 = rs.OK; } else { - _030 = rt.Err(Guard.id(g15)); + _030 = rs.Err(Guard.id(g15)); } g15[Symbol.dispose](); return _030; }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(part15, f, rt.fmtUnit, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["flow ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(part15, f, rs.fmtUnit, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flow ", args16[0]])); _678 = false; const captured28 = d; - const part16 = rt.iterTryForEach(it4, rt.closure((g16: Guard.Guard): undefined | rt.None => { - const _031: undefined | rt.None = thenSome$1j8foe9(Guard.id(g16) !== Guard.id(captured28), undefined); + const part16 = rs.iterTryForEach(it4, rs.closure((g16: Guard.Guard): undefined | rs.None => { + const _031: undefined | rs.None = thenSome$1n1oy1h(Guard.id(g16) !== Guard.id(captured28), undefined); g16[Symbol.dispose](); return _031; }, (): void => { captured28[Symbol.dispose](); - }), true, true, rt.None); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part16, f, rt.fmtUnit, rt.None)]; - Log.note(log, rt.fmtFormat(["some ", args18[0]])); - rt.drop(it4); + }), true, true, rs.None); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, rs.fmtUnit, rs.None)]; + Log.note(log, rs.fmtFormat(["some ", args18[0]])); + rs.drop(it4); } else if (_17 === 4) { - const _190: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _190: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _679 = false; const captured22 = c; - const _189: [rt.Vec, rt.Vec] = rt.iterPartition(_190, rt.closure((g11: Guard.Guard): boolean => { - const _913: rt.u32 = Guard.id(g11); - const _1115: rt.u32 = Guard.id(captured22); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_913, f), (f: rt.Formatter) => rt.u32Display(_1115, f)]; - Log.note(log, rt.fmtFormat(["side ", args78[0], " ", args78[1]])); - return rt.u32Rem(Guard.id(g11), 2) === 1; + const _189: [rs.Vec, rs.Vec] = rs.iterPartition(_190, rs.closure((g11: Guard.Guard): boolean => { + const _913: rs.u32 = Guard.id(g11); + const _1115: rs.u32 = Guard.id(captured22); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1115, f)]; + Log.note(log, rs.fmtFormat(["side ", args78[0], " ", args78[1]])); + return rs.u32Rem(Guard.id(g11), 2) === 1; }, (): void => { captured22[Symbol.dispose](); - }), [new rt.Vec() as rt.Vec, new rt.Vec() as rt.Vec], rt.vecPart(8), true, true); - const odd: rt.Vec = _189[0]; - const even: rt.Vec = _189[1]; - const part12 = rt.iterToVec(rt.iterMap(rt.iterSlice(odd.items), Guard.id), undefined, 4, true); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part12.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["odd ", args20[0]])); - rt.dropVec(even); - const _213: [rt.Vec, rt.Vec] = rt.iterPartition(new rt.Range(1, 4), (_220: rt.u32): boolean => { + }), [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(8), true, true); + const odd: rs.Vec = _189[0]; + const even: rs.Vec = _189[1]; + const part12 = rs.iterToVec(rs.iterMap(rs.iterSlice(odd.items), Guard.id), undefined, 4, true); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["odd ", args20[0]])); + rs.dropVec(even); + const _213: [rs.Vec, rs.Vec] = rs.iterPartition(new rs.Range(1, 4), (_220: rs.u32): boolean => { return true; - }, [new rt.Vec() as rt.Vec, new rt.Vec() as rt.Vec], rt.vecPart(4)); - const all: rt.Vec = _213[0]; - const none2: rt.Vec = _213[1]; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(all.items, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtList(none2.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["all ", args22[0], " ", args22[1]])); + }, [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(4)); + const all: rs.Vec = _213[0]; + const none2: rs.Vec = _213[1]; + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(all.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtList(none2.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["all ", args22[0], " ", args22[1]])); const e: Guard.Guard = guard(22); - const _234: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _234: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); const captured23 = e; - const _233: rt.Iter = rt.iterMap(_234, rt.closure((g12: Guard.Guard): Guard.Guard => { - return ([g12, Guard.id(captured23)] as [Guard.Guard, rt.u32])[0]; + const _233: rs.Iter = rs.iterMap(_234, rs.closure((g12: Guard.Guard): Guard.Guard => { + return ([g12, Guard.id(captured23)] as [Guard.Guard, rs.u32])[0]; }, (): void => { captured23[Symbol.dispose](); })); _678 = false; const captured24 = d; const captured25 = id; - const _232: [rt.Vec, rt.Vec] = rt.iterPartition(_233, rt.closure((g13: Guard.Guard): boolean => { - return rt.u32Sub(rt.u32Add(Guard.id(g13), Guard.id(captured24)), Guard.id(captured24)) < rt.u32Add(captured25, 2); + const _232: [rs.Vec, rs.Vec] = rs.iterPartition(_233, rs.closure((g13: Guard.Guard): boolean => { + return rs.u32Sub(rs.u32Add(Guard.id(g13), Guard.id(captured24)), Guard.id(captured24)) < rs.u32Add(captured25, 2); }, (): void => { captured24[Symbol.dispose](); - }), [new rt.Vec() as rt.Vec, new rt.Vec() as rt.Vec], rt.vecPart(8), true, true); - const low: rt.Vec = _232[0]; - const high: rt.Vec = _232[1]; - const _246: rt.usize = low.items.length; - const _249: rt.usize = high.items.length; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_246, f), (f: rt.Formatter) => rt.usizeDisplay(_249, f)]; - Log.note(log, rt.fmtFormat(["sides ", args24[0], " ", args24[1]])); - rt.dropVec(high); - rt.dropVec(low); - rt.dropVec(odd); + }), [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(8), true, true); + const low: rs.Vec = _232[0]; + const high: rs.Vec = _232[1]; + const _246: rs.usize = low.items.length; + const _249: rs.usize = high.items.length; + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_246, f), (f: rs.Formatter) => rs.usizeDisplay(_249, f)]; + Log.note(log, rs.fmtFormat(["sides ", args24[0], " ", args24[1]])); + rs.dropVec(high); + rs.dropVec(low); + rs.dropVec(odd); } else if (_17 === 5) { _679 = false; - let captured18: rt.u32 = 0; + let captured18: rs.u32 = 0; const captured19 = c; const captured20 = guard; - const made: rt.Vec = rt.iterToVec(rt.iterTake(rt.iterRepeatWith(rt.closure((): Guard.Guard => { - captured18 = rt.u32Add(captured18, 1); - const _912: rt.u32 = Guard.id(captured19); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(captured18, f), (f: rt.Formatter) => rt.u32Display(_912, f)]; - Log.note(log, rt.fmtFormat(["make ", args76[0], " ", args76[1]])); + const made: rs.Vec = rs.iterToVec(rs.iterTake(rs.iterRepeatWith(rs.closure((): Guard.Guard => { + captured18 = rs.u32Add(captured18, 1); + const _912: rs.u32 = Guard.id(captured19); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(captured18, f), (f: rs.Formatter) => rs.u32Display(_912, f)]; + Log.note(log, rs.fmtFormat(["make ", args76[0], " ", args76[1]])); return captured20(captured18); }, (): void => { captured19[Symbol.dispose](); - })), 3, rt.drop), "fold", 8, true); + })), 3, rs.drop), "fold", 8, true); const part11 = made.items.length; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part11, f)]; - Log.note(log, rt.fmtFormat(["made ", args26[0]])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part11, f)]; + Log.note(log, rs.fmtFormat(["made ", args26[0]])); _678 = false; const captured21 = d; - const it5: rt.Iter = rt.iterRepeatWith(rt.closure((): rt.u32 => { + const it5: rs.Iter = rs.iterRepeatWith(rs.closure((): rs.u32 => { return Guard.id(captured21); }, (): void => { captured21[Symbol.dispose](); })); - const _280: rt.u32 | undefined = rt.iterToOption(it5.next()); - const _283: [rt.usize, rt.usize | undefined] = it5.sizeHint(); - const _286: [rt.usize, rt.usize | undefined] = rt.iterTake(rt.iterBorrow(it5), 2).sizeHint(); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_280, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_283[0], f), (f: rt.Formatter) => rt.fmtOption(_283[1], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(_286[0], f), (f: rt.Formatter) => rt.fmtOption(_286[1], f, rt.usizeDebug)], f)]; - Log.note(log, rt.fmtFormat(["first ", args28[0], " ", args28[1], " ", args28[2]])); - rt.drop(it5); + const _280: rs.u32 | undefined = rs.iterToOption(it5.next()); + const _283: [rs.usize, rs.usize | undefined] = it5.sizeHint(); + const _286: [rs.usize, rs.usize | undefined] = rs.iterTake(rs.iterBorrow(it5), 2).sizeHint(); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_280, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_283[0], f), (f: rs.Formatter) => rs.fmtOption(_283[1], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(_286[0], f), (f: rs.Formatter) => rs.fmtOption(_286[1], f, rs.usizeDebug)], f)]; + Log.note(log, rs.fmtFormat(["first ", args28[0], " ", args28[1], " ", args28[2]])); + rs.drop(it5); Log.note(log, "dropped"); - rt.dropVec(made); + rs.dropVec(made); } else if (_17 === 6) { - const _303: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _303: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _679 = false; const captured13 = id; const captured14 = c; - const it6: rt.Iter = rt.iterScan(_303, 0, rt.closure((sum: rt.Place, g9: Guard.Guard): rt.u32 | undefined => { - const _433: rt.u32 = rt.u32Sub(Guard.id(g9), captured13); - sum.v = rt.u32Add(sum.v, _433); - const _169: rt.u32 = Guard.id(g9); - const _1910: rt.u32 = Guard.id(captured14); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_169, f), (f: rt.Formatter) => rt.u32Display(sum.v, f), (f: rt.Formatter) => rt.u32Display(_1910, f)]; - Log.note(log, rt.fmtFormat(["scan ", args72[0], " ", args72[1], " ", args72[2]])); - const _020: rt.u32 | undefined = thenSome$1af3oea(sum.v < 10, sum.v); + const it6: rs.Iter = rs.iterScan(_303, 0, rs.closure((sum: rs.Place, g9: Guard.Guard): rs.u32 | undefined => { + const _433: rs.u32 = rs.u32Sub(Guard.id(g9), captured13); + sum.v = rs.u32Add(sum.v, _433); + const _169: rs.u32 = Guard.id(g9); + const _1910: rs.u32 = Guard.id(captured14); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_169, f), (f: rs.Formatter) => rs.u32Display(sum.v, f), (f: rs.Formatter) => rs.u32Display(_1910, f)]; + Log.note(log, rs.fmtFormat(["scan ", args72[0], " ", args72[1], " ", args72[2]])); + const _020: rs.u32 | undefined = thenSome$1bahm2u(sum.v < 10, sum.v); g9[Symbol.dispose](); return _020; }, (): void => { captured14[Symbol.dispose](); }), true); - const sums: rt.Vec = rt.iterToVec(rt.iterBorrow(it6), "next", 4); - const _317: rt.u32 | undefined = rt.iterToOption(it6.next()); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(sums.items, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_317, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["sums ", args30[0], " ", args30[1]])); - rt.drop(it6); - const part9 = rt.iterSum(rt.iterScan(new rt.Range(1, 4), 1, (n11: rt.Place, k2: rt.u32): rt.u32 | undefined => { - n11.v = rt.u32Mul(n11.v, k2); + const sums: rs.Vec = rs.iterToVec(rs.iterBorrow(it6), "next", 4); + const _317: rs.u32 | undefined = rs.iterToOption(it6.next()); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(sums.items, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_317, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["sums ", args30[0], " ", args30[1]])); + rs.drop(it6); + const part9 = rs.iterSum(rs.iterScan(new rs.Range(1, 4), 1, (n11: rs.Place, k2: rs.u32): rs.u32 | undefined => { + n11.v = rs.u32Mul(n11.v, k2); return n11.v; - }, true), rt.u32Add, 0); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part9, f)]; - Log.note(log, rt.fmtFormat(["total ", args32[0]])); + }, true), rs.u32Add, 0); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; + Log.note(log, rs.fmtFormat(["total ", args32[0]])); const e2: Guard.Guard = guard(22); - const v: rt.Vec> = new rt.Vec(); - const _351: rt.Vec = guards(1, 3); + const v: rs.Vec> = new rs.Vec(); + const _351: rs.Vec = guards(1, 3); v.items.push(_351); - const _356: rt.Vec = guards(3, 6); + const _356: rs.Vec = guards(3, 6); v.items.push(_356); - const _345: rt.Iter = rt.iterFlatten(rt.vecIntoIter(v, lib_drop$Vec_model_Guard), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); + const _345: rs.Iter = rs.iterFlatten(rs.vecIntoIter(v, lib_drop$Vec_model_Guard), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); const _359: Guard.Guard = guard(23); _678 = false; const captured15 = d; const captured16 = id; const captured17 = e2; - const part10 = rt.iterFold(rt.iterScan(_345, _359, rt.closure((held: Guard.Guard, g10: Guard.Guard): rt.u32 | undefined => { - const _109: rt.u32 = Guard.id(held); - const _1311: rt.u32 = Guard.id(g10); - const _1610: rt.u32 = Guard.id(captured15); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_109, f), (f: rt.Formatter) => rt.u32Display(_1311, f), (f: rt.Formatter) => rt.u32Display(_1610, f)]; - Log.note(log, rt.fmtFormat(["held ", args74[0], " ", args74[1], " ", args74[2]])); - const _022: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g10) !== rt.u32Add(captured16, 4), rt.u32Sub(rt.u32Add(Guard.id(g10), Guard.id(captured17)), Guard.id(captured17))); + const part10 = rs.iterFold(rs.iterScan(_345, _359, rs.closure((held: Guard.Guard, g10: Guard.Guard): rs.u32 | undefined => { + const _109: rs.u32 = Guard.id(held); + const _1311: rs.u32 = Guard.id(g10); + const _1610: rs.u32 = Guard.id(captured15); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_109, f), (f: rs.Formatter) => rs.u32Display(_1311, f), (f: rs.Formatter) => rs.u32Display(_1610, f)]; + Log.note(log, rs.fmtFormat(["held ", args74[0], " ", args74[1], " ", args74[2]])); + const _022: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g10) !== rs.u32Add(captured16, 4), rs.u32Sub(rs.u32Add(Guard.id(g10), Guard.id(captured17)), Guard.id(captured17))); g10[Symbol.dispose](); return _022; }, (): void => { captured15[Symbol.dispose](); captured17[Symbol.dispose](); - }), undefined, rt.drop), 0, (n12: rt.u32, k3: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Add(n12, k3), id); + }), undefined, rs.drop), 0, (n12: rs.u32, k3: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Add(n12, k3), id); }, true); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; - Log.note(log, rt.fmtFormat(["flat ", args34[0]])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; + Log.note(log, rs.fmtFormat(["flat ", args34[0]])); } else if (_17 === 7) { - const v2: rt.Vec = rt.iterToVec(rt.iterSlice(rt.arrayMap([3, 1, 4, 5, 2], guard), rt.drop), "fold", 8, true); + const v2: rs.Vec = rs.iterToVec(rs.iterSlice(rs.arrayMap([3, 1, 4, 5, 2], guard), rs.drop), "fold", 8, true); const _380: Guard.Guard[] = v2.items; _679 = false; const captured12 = c; - rt.sliceSortByCachedKey(_380, rt.closure((g8: Guard.Guard): Key.Key => { - const _910: rt.u32 = Guard.id(g8); - const _1113: rt.u32 = Guard.id(captured12); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_910, f), (f: rt.Formatter) => rt.u32Display(_1113, f)]; - Log.note(log, rt.fmtFormat(["key ", args70[0], " ", args70[1]])); - return Key.new(rt.u32Rem(rt.u32Mul(Guard.id(g8), 7), 5), Log.clone$Clone(log)); + rs.sliceSortByCachedKey(_380, rs.closure((g8: Guard.Guard): Key.Key => { + const _910: rs.u32 = Guard.id(g8); + const _1113: rs.u32 = Guard.id(captured12); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1113, f)]; + Log.note(log, rs.fmtFormat(["key ", args70[0], " ", args70[1]])); + return Key.new(rs.u32Rem(rs.u32Mul(Guard.id(g8), 7), 5), Log.clone$Clone(log)); }, (): void => { captured12[Symbol.dispose](); - }), rt.cmpLt(rt.cmpTuple<[Key.Key, rt.usize], rt.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rt.cmp])), 16, true, false, true, rt.drop); - const part8 = rt.iterToVec(rt.iterMap(rt.iterSlice(v2.items), Guard.id), undefined, 4, true); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part8.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["sorted ", args36[0]])); - const w: rt.Vec = rt.vecFrom([3, 1, 2]); - rt.sliceSortByCachedKey(w.items, (_210: rt.u32): rt.u32 => { - return rt.u32Add(_210, Guard.id(d)); - }, rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmpReverse(rt.cmp), rt.cmp])), 8, true, true); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(w.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["rev ", args38[0]])); - rt.dropVec(v2); + }), rs.cmpLt(rs.cmpTuple<[Key.Key, rs.usize], rs.Ordering | undefined>([Key.partialCmp$cmp_PartialOrd, rs.cmp])), 16, true, false, true, rs.drop); + const part8 = rs.iterToVec(rs.iterMap(rs.iterSlice(v2.items), Guard.id), undefined, 4, true); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part8.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["sorted ", args36[0]])); + const w: rs.Vec = rs.vecFrom([3, 1, 2]); + rs.sliceSortByCachedKey(w.items, (_210: rs.u32): rs.u32 => { + return rs.u32Add(_210, Guard.id(d)); + }, rs.cmpLt(rs.cmpTuple<[rs.u32, rs.usize], rs.Ordering | undefined>([rs.cmpReverse(rs.cmp), rs.cmp])), 8, true, true); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(w.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["rev ", args38[0]])); + rs.dropVec(v2); } else if (_17 === 8) { _679 = false; const captured9 = c; - const lazy: rt.LazyCell = new rt.LazyCell(rt.closure((): rt.u32 => { + const lazy: rs.LazyCell = new rs.LazyCell(rs.closure((): rs.u32 => { const part6 = Guard.id(captured9); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["force ", args68[0]])); - const _015: rt.u32 = rt.u32Add(Guard.id(captured9), 1); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["force ", args68[0]])); + const _015: rs.u32 = rs.u32Add(Guard.id(captured9), 1); captured9[Symbol.dispose](); return _015; }, (): void => { captured9[Symbol.dispose](); })); Log.note(log, "made"); - const _425: rt.u32 = lazy.force(); - const _427: rt.u32 = lazy.force(); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_425, f), (f: rt.Formatter) => rt.u32Display(_427, f)]; - Log.note(log, rt.fmtFormat(["forced ", args40[0], " ", args40[1]])); + const _425: rs.u32 = lazy.force(); + const _427: rs.u32 = lazy.force(); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_425, f), (f: rs.Formatter) => rs.u32Display(_427, f)]; + Log.note(log, rs.fmtFormat(["forced ", args40[0], " ", args40[1]])); _678 = false; const captured10 = d; - rt.lazyDrop(new rt.LazyCell(rt.closure((): rt.u32 => { - const _016: rt.u32 = Guard.id(captured10); + rs.lazyDrop(new rs.LazyCell(rs.closure((): rs.u32 => { + const _016: rs.u32 = Guard.id(captured10); captured10[Symbol.dispose](); return _016; }, (): void => { captured10[Symbol.dispose](); - })), undefined, rt.drop); + })), undefined, rs.drop); Log.note(log, "unused"); const captured11 = guard(22); - const lazy2: rt.LazyCell = new rt.LazyCell(rt.once(rt.closure((): rt.u32 => { + const lazy2: rs.LazyCell = new rs.LazyCell(rs.once(rs.closure((): rs.u32 => { return Guard.id(captured11); }, (): void => { captured11[Symbol.dispose](); }))); const part7 = lazy2.force(); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["by Fn ", args42[0]])); - rt.lazyDrop(lazy2, undefined, rt.drop); - rt.lazyDrop(lazy, undefined, rt.drop); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["by Fn ", args42[0]])); + rs.lazyDrop(lazy2, undefined, rs.drop); + rs.lazyDrop(lazy, undefined, rs.drop); } else if (_17 === 9) { - const cell: rt.Cell = new rt.Cell(1); + const cell: rs.Cell = new rs.Cell(1); _679 = false; const captured6 = c; - rt.cellUpdate(cell, rt.closure((n7: rt.u32): rt.u32 => { - const _93: rt.u32 = Guard.id(captured6); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n7, f), (f: rt.Formatter) => rt.u32Display(_93, f)]; - Log.note(log, rt.fmtFormat(["update ", args62[0], " ", args62[1]])); - const _010: rt.u32 = rt.u32Add(n7, 1); + rs.cellUpdate(cell, rs.closure((n7: rs.u32): rs.u32 => { + const _93: rs.u32 = Guard.id(captured6); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n7, f), (f: rs.Formatter) => rs.u32Display(_93, f)]; + Log.note(log, rs.fmtFormat(["update ", args62[0], " ", args62[1]])); + const _010: rs.u32 = rs.u32Add(n7, 1); captured6[Symbol.dispose](); return _010; }, (): void => { captured6[Symbol.dispose](); })); const part = cell.v; - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["updated ", args44[0]])); - const cell2: rt.RefCell = new rt.RefCell(5); - const old: rt.u32 = rt.refCellReplaceWith(cell2, (n8: rt.Place): rt.u32 => { - const _95: rt.u32 = Guard.id(d); - const _137: rt.Result, rt.BorrowError> = rt.refCellTryBorrow(cell2); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["updated ", args44[0]])); + const cell2: rs.RefCell = new rs.RefCell(5); + const old: rs.u32 = rs.refCellReplaceWith(cell2, (n8: rs.Place): rs.u32 => { + const _95: rs.u32 = Guard.id(d); + const _137: rs.Result, rs.BorrowError> = rs.refCellTryBorrow(cell2); const _1110: boolean = !_137.ok; - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n8.v, f), (f: rt.Formatter) => rt.u32Display(_95, f), (f: rt.Formatter) => rt.fmtBool(_1110, f)]; - const _511: string = rt.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8.v, f), (f: rs.Formatter) => rs.u32Display(_95, f), (f: rs.Formatter) => rs.fmtBool(_1110, f)]; + const _511: string = rs.fmtFormat(["replace ", args64[0], " ", args64[1], " ", args64[2]]); lib_drop$Result_cell_Ref_u32_cell_BorrowError(_137); Log.note(log, _511); - n8.v = rt.u32Add(n8.v, 1); - return rt.u32Mul(n8.v, 2); + n8.v = rs.u32Add(n8.v, 1); + return rs.u32Mul(n8.v, 2); }, true); - const _484: rt.RefCell = rt.refCellBorrow(cell2); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(old, f), (f: rt.Formatter) => rt.u32Display(_484.value, f)]; - const _480: string = rt.fmtFormat(["replaced ", args46[0], " ", args46[1]]); - rt.refRelease(_484); + const _484: rs.RefCell = rs.refCellBorrow(cell2); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(old, f), (f: rs.Formatter) => rs.u32Display(_484.value, f)]; + const _480: string = rs.fmtFormat(["replaced ", args46[0], " ", args46[1]]); + rs.refRelease(_484); Log.note(log, _480); const _494: [Guard.Guard, Guard.Guard] = [guard(22), guard(23)]; const e4: Guard.Guard = _494[0]; f = _494[1]; const captured7 = e4; const captured8 = f; - const add: (a0: rt.u32) => rt.u32 = rt.closure((n9: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Sub(rt.u32Add(n9, Guard.id(captured7)), Guard.id(captured7)), 1); + const add: (a0: rs.u32) => rs.u32 = rs.closure((n9: rs.u32): rs.u32 => { + return rs.u32Add(rs.u32Sub(rs.u32Add(n9, Guard.id(captured7)), Guard.id(captured7)), 1); }, (): void => { captured7[Symbol.dispose](); }); - const doubled: (a0: rt.Place) => rt.u32 = rt.closure((n10: rt.Place): rt.u32 => { - return rt.u32Sub(rt.u32Add(rt.u32Mul(n10.v, 2), Guard.id(captured8)), Guard.id(captured8)); + const doubled: (a0: rs.Place) => rs.u32 = rs.closure((n10: rs.Place): rs.u32 => { + return rs.u32Sub(rs.u32Add(rs.u32Mul(n10.v, 2), Guard.id(captured8)), Guard.id(captured8)); }, (): void => { captured8[Symbol.dispose](); }); - rt.cellUpdate(new rt.Cell(1), rt.once(add)); - const pair: rt.Cell = new rt.Cell([1, 2]); - rt.cellUpdate(pair, (p: rt.u32[]): rt.u32[] => { + rs.cellUpdate(new rs.Cell(1), rs.once(add)); + const pair: rs.Cell = new rs.Cell([1, 2]); + rs.cellUpdate(pair, (p: rs.u32[]): rs.u32[] => { p = copy$array_u32(p); - p[0] = rt.u32Add(p[0], 10); - const _155: rt.u32[] = copy$array_u32(pair.v); + p[0] = rs.u32Add(p[0], 10); + const _155: rs.u32[] = copy$array_u32(pair.v); const part2 = p[0]; const part3 = _155[0]; - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f), (f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["pair ", args66[0], " ", args66[1]])); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f), (f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["pair ", args66[0], " ", args66[1]])); return copy$array_u32(p); }); const part4 = copy$array_u32(pair.v); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["paired ", args48[0]])); - const part5 = rt.refCellReplaceWith(cell2, rt.once(doubled), true); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - Log.note(log, rt.fmtFormat(["by Fn ", args50[0]])); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["paired ", args48[0]])); + const part5 = rs.refCellReplaceWith(cell2, rs.once(doubled), true); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + Log.note(log, rs.fmtFormat(["by Fn ", args50[0]])); } else if (_17 === 10) { - const _539: rt.Iter = _536(); + const _539: rs.Iter = _536(); _679 = false; const captured3 = c; - const r7: rt.Result = rt.iterTryFold(_539, 0, rt.closure((n5: rt.u32, g3: Guard.Guard): rt.Result => { - const _05: rt.Result = rt.Ok(rt.u32Add(rt.u32Add(n5, Guard.id(g3)), Guard.id(captured3))); + const r7: rs.Result = rs.iterTryFold(_539, 0, rs.closure((n5: rs.u32, g3: Guard.Guard): rs.Result => { + const _05: rs.Result = rs.Ok(rs.u32Add(rs.u32Add(n5, Guard.id(g3)), Guard.id(captured3))); g3[Symbol.dispose](); return _05; }, (): void => { captured3[Symbol.dispose](); }), undefined, true); - rt.drop(_539); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(r7, f, rt.u32Debug, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["fold ", args52[0]])); - const _554: rt.Iter = _536(); + rs.drop(_539); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(r7, f, rs.u32Debug, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["fold ", args52[0]])); + const _554: rs.Iter = _536(); _678 = false; const captured4 = d; - const r8: undefined | rt.None = rt.iterTryForEach(_554, rt.closure((g4: Guard.Guard): undefined | rt.None => { - const _06: undefined | rt.None = thenSome$1j8foe9(Guard.id(g4) !== Guard.id(captured4), undefined); + const r8: undefined | rs.None = rs.iterTryForEach(_554, rs.closure((g4: Guard.Guard): undefined | rs.None => { + const _06: undefined | rs.None = thenSome$1n1oy1h(Guard.id(g4) !== Guard.id(captured4), undefined); g4[Symbol.dispose](); return _06; }, (): void => { captured4[Symbol.dispose](); - }), true, true, rt.None); - rt.drop(_554); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(r8, f, rt.fmtUnit, rt.None)]; - Log.note(log, rt.fmtFormat(["each ", args54[0]])); - const _569: [rt.Vec, rt.Vec] = rt.iterPartition(_536(), (g5: Guard.Guard): boolean => { + }), true, true, rs.None); + rs.drop(_554); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(r8, f, rs.fmtUnit, rs.None)]; + Log.note(log, rs.fmtFormat(["each ", args54[0]])); + const _569: [rs.Vec, rs.Vec] = rs.iterPartition(_536(), (g5: Guard.Guard): boolean => { return Guard.id(g5) > 0; - }, [new rt.Vec() as rt.Vec, new rt.Vec() as rt.Vec], rt.vecPart(8), true); - const a: rt.Vec = _569[0]; - const b: rt.Vec = _569[1]; - const _578: rt.usize = a.items.length; - const _581: rt.usize = b.items.length; - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_578, f), (f: rt.Formatter) => rt.usizeDisplay(_581, f)]; - Log.note(log, rt.fmtFormat(["sides ", args56[0], " ", args56[1]])); - const scanned: rt.Vec = rt.iterToVec(rt.iterScan(_536(), 0, (n6: rt.Place, g6: Guard.Guard): rt.u32 | undefined => { - const _08: rt.u32 | undefined = rt.u32Add(n6.v, Guard.id(g6)); + }, [new rs.Vec() as rs.Vec, new rs.Vec() as rs.Vec], rs.vecPart(8), true); + const a: rs.Vec = _569[0]; + const b: rs.Vec = _569[1]; + const _578: rs.usize = a.items.length; + const _581: rs.usize = b.items.length; + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_578, f), (f: rs.Formatter) => rs.usizeDisplay(_581, f)]; + Log.note(log, rs.fmtFormat(["sides ", args56[0], " ", args56[1]])); + const scanned: rs.Vec = rs.iterToVec(rs.iterScan(_536(), 0, (n6: rs.Place, g6: Guard.Guard): rs.u32 | undefined => { + const _08: rs.u32 | undefined = rs.u32Add(n6.v, Guard.id(g6)); g6[Symbol.dispose](); return _08; }, true), "next", 4, false, 8); - const empty: rt.Vec = new rt.Vec(); - rt.sliceSortByCachedKey(empty.items, Guard.id, rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true, true); - const one: rt.Vec = guards(1, 2); + const empty: rs.Vec = new rs.Vec(); + rs.sliceSortByCachedKey(empty.items, Guard.id, rs.cmpLt(rs.cmpTuple<[rs.u32, rs.usize], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 8, true, true); + const one: rs.Vec = guards(1, 2); const e5: Guard.Guard = guard(22); const _603: Guard.Guard[] = one.items; const captured5 = e5; - rt.sliceSortByCachedKey(_603, rt.closure((g7: Guard.Guard): rt.u32 => { - return rt.u32Add(Guard.id(g7), Guard.id(captured5)); + rs.sliceSortByCachedKey(_603, rs.closure((g7: Guard.Guard): rs.u32 => { + return rs.u32Add(Guard.id(g7), Guard.id(captured5)); }, (): void => { captured5[Symbol.dispose](); - }), rt.cmpLt(rt.cmpTuple<[rt.u32, rt.usize], rt.Ordering | undefined>([rt.cmp, rt.cmp])), 8, true, true, true); - const _612: rt.usize = scanned.items.length; - const _615: rt.usize = empty.items.length; - const _618: rt.usize = one.items.length; - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_612, f), (f: rt.Formatter) => rt.usizeDisplay(_615, f), (f: rt.Formatter) => rt.usizeDisplay(_618, f)]; - Log.note(log, rt.fmtFormat(["scanned ", args58[0], " ", args58[1], " ", args58[2]])); - rt.dropVec(one); - rt.dropVec(empty); - rt.dropVec(b); - rt.dropVec(a); + }), rs.cmpLt(rs.cmpTuple<[rs.u32, rs.usize], rs.Ordering | undefined>([rs.cmp, rs.cmp])), 8, true, true, true); + const _612: rs.usize = scanned.items.length; + const _615: rs.usize = empty.items.length; + const _618: rs.usize = one.items.length; + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_612, f), (f: rs.Formatter) => rs.usizeDisplay(_615, f), (f: rs.Formatter) => rs.usizeDisplay(_618, f)]; + Log.note(log, rs.fmtFormat(["scanned ", args58[0], " ", args58[1], " ", args58[2]])); + rs.dropVec(one); + rs.dropVec(empty); + rs.dropVec(b); + rs.dropVec(a); } else { const a2: Guard.Guard = guard(30); - const _631: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _631: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); const captured = id; const captured2 = a2; - rt.iterTryFold(_631, 0, rt.closure((n4: rt.u32, g2: Guard.Guard): rt.u32 | undefined => { - if (!(Guard.id(g2) !== rt.u32Add(captured, 3))) { - const _142: rt.u32 = Guard.id(g2); - const _173: rt.u32 = Guard.id(captured2); - const _205: string = rt.resultUnwrap(rt.stringFromUtf8(Log.text(log)), rt.fmtFromUtf8ErrorDebug); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_142, f), (f: rt.Formatter) => rt.u32Display(_173, f), (f: rt.Formatter) => rt.fmtPad(f, _205)]; - rt.panicFmt(["try_fold of g", args60[0], " with g", args60[1], " after\n", args60[2]]); + rs.iterTryFold(_631, 0, rs.closure((n4: rs.u32, g2: Guard.Guard): rs.u32 | undefined => { + if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { + const _142: rs.u32 = Guard.id(g2); + const _173: rs.u32 = Guard.id(captured2); + const _205: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_142, f), (f: rs.Formatter) => rs.u32Display(_173, f), (f: rs.Formatter) => rs.fmtPad(f, _205)]; + rs.panicFmt(["try_fold of g", args60[0], " with g", args60[1], " after\n", args60[2]]); } else { - const _04: rt.u32 | undefined = rt.u32Add(n4, Guard.id(g2)); + const _04: rs.u32 | undefined = rs.u32Add(n4, Guard.id(g2)); g2[Symbol.dispose](); return _04; } }, (): void => { captured2[Symbol.dispose](); }), true, true); - rt.drop(_631); + rs.drop(_631); } if (_678) { d[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/closures.Holder.ts b/ts/fixtures/task/expected/drops/closures.Holder.ts index 4199af32e..514cdde7e 100644 --- a/ts/fixtures/task/expected/drops/closures.Holder.ts +++ b/ts/fixtures/task/expected/drops/closures.Holder.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import type * as Guard from "../model.Guard.ts"; /** Hold `f`, which drops with it. */ @@ -14,7 +14,7 @@ export class Holder { } [Symbol.dispose](): void { - rt.drop(this.f); + rs.drop(this.f); this.guard[Symbol.dispose](); } } diff --git a/ts/fixtures/task/expected/drops/closures.ts b/ts/fixtures/task/expected/drops/closures.ts index 72e05fa58..0d9ac7ec7 100644 --- a/ts/fixtures/task/expected/drops/closures.ts +++ b/ts/fixtures/task/expected/drops/closures.ts @@ -1,44 +1,44 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { thenSome$0zvoczk, thenSome$1af3oea, then$1xpp3sz, then$1j9nint, then$0kxuq3f } from "../core/bool.ts"; -import { map$1raha9y as option_map$1raha9y, map$0lq7mno as option_map$0lq7mno, map$0b0x7xy as option_map$0b0x7xy, map$1thjygq as option_map$1thjygq, mapOr$0nrpycp as option_mapOr$0nrpycp } from "../core/option.ts"; -import { map$1rk4yqp as result_map$1rk4yqp, mapErr$1c43xsx as result_mapErr$1c43xsx, inspectErr$0hrcm18, andThen$1so3lx6 as result_andThen$1so3lx6 } from "../core/result.ts"; +import * as rs from "../rs.ts"; +import { thenSome$0zvoczk, thenSome$1bahm2u, then$1xpp3sz, then$0awnlmn, then$04r7us0 } from "../core/bool.ts"; +import { map$06w9waf as option_map$06w9waf, map$02u0dmi as option_map$02u0dmi, map$0cxn9jm as option_map$0cxn9jm, map$1ol7nt5 as option_map$1ol7nt5, mapOr$0lyy1bs as option_mapOr$0lyy1bs } from "../core/option.ts"; +import { map$1tajsw3 as result_map$1tajsw3, mapErr$04hu1u8 as result_mapErr$04hu1u8, inspectErr$1vjhjw3, andThen$0wxwepe as result_andThen$0wxwepe } from "../core/result.ts"; import * as Holder from "../drops/closures.Holder.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Call `f` once, which consumes it. */ -export function once$u32_drops_closures_scoped_closure3(f: () => rt.u32): rt.u32 { +export function once$u32_drops_closures_scoped_closure3(f: () => rs.u32): rs.u32 { return f(); } /** Call `f` once, which consumes it. */ -export function once$u32_drops_closures_scoped_closure4(f: () => rt.u32): rt.u32 { +export function once$u32_drops_closures_scoped_closure4(f: () => rs.u32): rs.u32 { return f(); } /** Call `f` once, which consumes it. */ -export function once$u32_drops_closures_scoped_closure5(f: () => rt.u32): rt.u32 { - return rt.callOnce(f); +export function once$u32_drops_closures_scoped_closure5(f: () => rs.u32): rs.u32 { + return rs.callOnce(f); } /** Call `f` once, which consumes it. */ -export function once$u32_drops_closures_scoped_closure8(f: () => rt.u32): rt.u32 { - return rt.callOnce(f); +export function once$u32_drops_closures_scoped_closure8(f: () => rs.u32): rs.u32 { + return rs.callOnce(f); } /** Call `f` with each of `n` and `n + 1`, which borrows it, and drop it. */ -export function twice$drops_closures_scoped_closure10(n: rt.u32, f: (a0: rt.u32) => rt.u32): rt.u32 { - const _0: rt.u32 = rt.u32Add(f(n), f(rt.u32Add(n, 1))); - rt.drop(f); +export function twice$drops_closures_scoped_closure10(n: rs.u32, f: (a0: rs.u32) => rs.u32): rs.u32 { + const _0: rs.u32 = rs.u32Add(f(n), f(rs.u32Add(n, 1))); + rs.drop(f); return _0; } /** What closures that own guards drop. */ -export function scoped(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function scoped(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; const _7: [Guard.Guard, Guard.Guard] = [guard(1), guard(2)]; const a: Guard.Guard = _7[0]; @@ -46,184 +46,184 @@ export function scoped(log: Log.Log, id: rt.u32): void { const captured = a; const captured2 = b; const captured3 = guard(3); - const read: (a0: rt.u32) => rt.u32 = rt.closure((n2: rt.u32): rt.u32 => { - return rt.u32Add(n2, Guard.id(captured3)); + const read: (a0: rs.u32) => rs.u32 = rs.closure((n2: rs.u32): rs.u32 => { + return rs.u32Add(n2, Guard.id(captured3)); }, (): void => { captured3[Symbol.dispose](); }); - const unused: () => rt.u32 = rt.closure((): rt.u32 => { - return rt.u32Add(Guard.id(captured), Guard.id(captured2)); + const unused: () => rs.u32 = rs.closure((): rs.u32 => { + return rs.u32Add(Guard.id(captured), Guard.id(captured2)); }, (): void => { captured[Symbol.dispose](); captured2[Symbol.dispose](); }); - const part = rt.u32Add(read(1), read(2)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["read ", args2[0]])); - rt.drop(unused); + const part = rs.u32Add(read(1), read(2)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["read ", args2[0]])); + rs.drop(unused); const captured4 = guard(4); - const part2 = once$u32_drops_closures_scoped_closure3(rt.closure((): rt.u32 => { - const n3: rt.u32 = Guard.id(captured4); + const part2 = once$u32_drops_closures_scoped_closure3(rs.closure((): rs.u32 => { + const n3: rs.u32 = Guard.id(captured4); captured4[Symbol.dispose](); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n3, f)]; - Log.note(log, rt.fmtFormat(["moved ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f)]; + Log.note(log, rs.fmtFormat(["moved ", args16[0]])); return n3; }, (): void => { captured4[Symbol.dispose](); })); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["moved ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["moved ", args4[0]])); const captured5 = guard(5); - const part3 = once$u32_drops_closures_scoped_closure4(rt.closure((): rt.u32 => { - const _04: rt.u32 = Guard.id(captured5); + const part3 = once$u32_drops_closures_scoped_closure4(rs.closure((): rs.u32 => { + const _04: rs.u32 = Guard.id(captured5); captured5[Symbol.dispose](); return _04; }, (): void => { captured5[Symbol.dispose](); })); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["kept ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["kept ", args6[0]])); const captured6 = guard(6); - const part4 = once$u32_drops_closures_scoped_closure5(rt.closure((): rt.u32 => { + const part4 = once$u32_drops_closures_scoped_closure5(rs.closure((): rs.u32 => { return Guard.id(captured6); }, (): void => { captured6[Symbol.dispose](); })); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["by ref ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["by ref ", args8[0]])); const captured7 = guard(7); - const part5 = twice$drops_closures_scoped_closure10(1, rt.closure((n4: rt.u32): rt.u32 => { - return rt.u32Add(n4, Guard.id(captured7)); + const part5 = twice$drops_closures_scoped_closure10(1, rs.closure((n4: rs.u32): rs.u32 => { + return rs.u32Add(n4, Guard.id(captured7)); }, (): void => { captured7[Symbol.dispose](); })); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - Log.note(log, rt.fmtFormat(["twice ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + Log.note(log, rs.fmtFormat(["twice ", args10[0]])); const captured8 = guard(8); - const holder: Holder.Holder<(a0: rt.u32) => rt.u32> = new Holder.Holder(rt.closure((n5: rt.u32): rt.u32 => { - return rt.u32Add(n5, Guard.id(captured8)); + const holder: Holder.Holder<(a0: rs.u32) => rs.u32> = new Holder.Holder(rs.closure((n5: rs.u32): rs.u32 => { + return rs.u32Add(n5, Guard.id(captured8)); }, (): void => { captured8[Symbol.dispose](); }), guard(9)); - const part6 = rt.u32Add(holder.f(1), Guard.id(holder.guard)); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["holder ", args12[0]])); + const part6 = rs.u32Add(holder.f(1), Guard.id(holder.guard)); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["holder ", args12[0]])); const captured9 = guard(10); - const captured10 = rt.closure((n6: rt.u32): rt.u32 => { - return rt.u32Add(n6, Guard.id(captured9)); + const captured10 = rs.closure((n6: rs.u32): rs.u32 => { + return rs.u32Add(n6, Guard.id(captured9)); }, (): void => { captured9[Symbol.dispose](); }); - const part7 = once$u32_drops_closures_scoped_closure8(rt.closure((): rt.u32 => { + const part7 = once$u32_drops_closures_scoped_closure8(rs.closure((): rs.u32 => { return captured10(1); }, (): void => { - rt.drop(captured10); + rs.drop(captured10); })); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["outer ", args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["outer ", args14[0]])); holder[Symbol.dispose](); - let captured11 = new rt.Vec(); - const push: (a0: Guard.Guard) => rt.usize = rt.closure((g2: Guard.Guard): rt.usize => { + let captured11 = new rs.Vec(); + const push: (a0: Guard.Guard) => rs.usize = rs.closure((g2: Guard.Guard): rs.usize => { captured11.items.push(g2); return captured11.items.length; }, (): void => { - rt.dropVec(captured11); + rs.dropVec(captured11); }); const part8 = guard(11); push(part8); const part9 = guard(12); push(part9); - rt.drop(push); - rt.drop(read); + rs.drop(push); + rs.drop(read); } /** * What std does with a closure that owns a guard: drops it where it is not called, and * leaves it to the call where it is. */ -export function discarded(log: Log.Log, id: rt.u32): void { +export function discarded(log: Log.Log, id: rs.u32): void { let f!: Guard.Guard; - const guard: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; - const some: rt.u32 | undefined = id; - const none = undefined as rt.u32 | undefined; + const some: rs.u32 | undefined = id; + const none = undefined as rs.u32 | undefined; const _9: [Guard.Guard, Guard.Guard] = [guard(1), guard(2)]; const a: Guard.Guard = _9[0]; const b: Guard.Guard = _9[1]; const captured = a; - const mapped: rt.u32 | undefined = option_map$1thjygq(some, rt.closure((n3: rt.u32): rt.u32 => { - const _02: rt.u32 = rt.u32Add(n3, Guard.id(captured)); + const mapped: rs.u32 | undefined = option_map$1ol7nt5(some, rs.closure((n3: rs.u32): rs.u32 => { + const _02: rs.u32 = rs.u32Add(n3, Guard.id(captured)); captured[Symbol.dispose](); return _02; }, (): void => { captured[Symbol.dispose](); })); const captured2 = b; - const unmapped: rt.u32 | undefined = option_map$1thjygq(none, rt.closure((n4: rt.u32): rt.u32 => { - const _03: rt.u32 = rt.u32Add(n4, Guard.id(captured2)); + const unmapped: rs.u32 | undefined = option_map$1ol7nt5(none, rs.closure((n4: rs.u32): rs.u32 => { + const _03: rs.u32 = rs.u32Add(n4, Guard.id(captured2)); captured2[Symbol.dispose](); return _03; }, (): void => { captured2[Symbol.dispose](); })); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(mapped, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(unmapped, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["map ", args2[0], " ", args2[1]])); - const ok: rt.Result = rt.Ok(id); - const err: rt.Result = rt.Err(id); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(mapped, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(unmapped, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); + const ok: rs.Result = rs.Ok(id); + const err: rs.Result = rs.Err(id); const _38: [Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard] = [guard(3), guard(4), guard(5), guard(6)]; const c: Guard.Guard = _38[0]; const d: Guard.Guard = _38[1]; const e: Guard.Guard = _38[2]; f = _38[3]; const captured3 = c; - const _52: rt.Result = result_map$1rk4yqp(ok, rt.closure((n5: rt.u32): rt.u32 => { - const _04: rt.u32 = rt.u32Add(n5, Guard.id(captured3)); + const _52: rs.Result = result_map$1tajsw3(ok, rs.closure((n5: rs.u32): rs.u32 => { + const _04: rs.u32 = rs.u32Add(n5, Guard.id(captured3)); captured3[Symbol.dispose](); return _04; }, (): void => { captured3[Symbol.dispose](); })); const captured4 = d; - const values: [rt.Result, rt.Result] = [_52, result_map$1rk4yqp(err, rt.closure((n6: rt.u32): rt.u32 => { - const _05: rt.u32 = rt.u32Add(n6, Guard.id(captured4)); + const values: [rs.Result, rs.Result] = [_52, result_map$1tajsw3(err, rs.closure((n6: rs.u32): rs.u32 => { + const _05: rs.u32 = rs.u32Add(n6, Guard.id(captured4)); captured4[Symbol.dispose](); return _05; }, (): void => { captured4[Symbol.dispose](); }))]; const captured5 = e; - const _57: rt.Result = result_mapErr$1c43xsx(ok, rt.closure((n7: rt.u32): rt.u32 => { - const _06: rt.u32 = rt.u32Add(n7, Guard.id(captured5)); + const _57: rs.Result = result_mapErr$04hu1u8(ok, rs.closure((n7: rs.u32): rs.u32 => { + const _06: rs.u32 = rs.u32Add(n7, Guard.id(captured5)); captured5[Symbol.dispose](); return _06; }, (): void => { captured5[Symbol.dispose](); })); const captured6 = f; - const errors: [rt.Result, rt.Result] = [_57, result_mapErr$1c43xsx(err, rt.closure((n8: rt.u32): rt.u32 => { - const _07: rt.u32 = rt.u32Add(n8, Guard.id(captured6)); + const errors: [rs.Result, rs.Result] = [_57, result_mapErr$04hu1u8(err, rs.closure((n8: rs.u32): rs.u32 => { + const _07: rs.u32 = rs.u32Add(n8, Guard.id(captured6)); captured6[Symbol.dispose](); return _07; }, (): void => { captured6[Symbol.dispose](); }))]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtResult(values[0], f, rt.u32Debug, rt.u32Debug), (f: rt.Formatter) => rt.fmtResult(values[1], f, rt.u32Debug, rt.u32Debug)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtResult(errors[0], f, rt.u32Debug, rt.u32Debug), (f: rt.Formatter) => rt.fmtResult(errors[1], f, rt.u32Debug, rt.u32Debug)], f)]; - Log.note(log, rt.fmtFormat(["result ", args4[0], " ", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(values[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(values[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(errors[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(errors[1], f, rs.u32Debug, rs.u32Debug)], f)]; + Log.note(log, rs.fmtFormat(["result ", args4[0], " ", args4[1]])); const _75: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _75[0]; const h: Guard.Guard = _75[1]; const captured7 = g; - const _83: rt.Result = result_andThen$1so3lx6(ok, rt.closure((n9: rt.u32): rt.Result => { - const _08: rt.Result = rt.Ok(rt.u32Add(n9, Guard.id(captured7))); + const _83: rs.Result = result_andThen$0wxwepe(ok, rs.closure((n9: rs.u32): rs.Result => { + const _08: rs.Result = rs.Ok(rs.u32Add(n9, Guard.id(captured7))); captured7[Symbol.dispose](); return _08; }, (): void => { captured7[Symbol.dispose](); })); const captured8 = h; - const chained: [rt.Result, rt.Result] = [_83, result_andThen$1so3lx6(err, rt.closure((n10: rt.u32): rt.Result => { - const _09: rt.Result = rt.Ok(rt.u32Add(n10, Guard.id(captured8))); + const chained: [rs.Result, rs.Result] = [_83, result_andThen$0wxwepe(err, rs.closure((n10: rs.u32): rs.Result => { + const _09: rs.Result = rs.Ok(rs.u32Add(n10, Guard.id(captured8))); captured8[Symbol.dispose](); return _09; }, (): void => { @@ -233,119 +233,119 @@ export function discarded(log: Log.Log, id: rt.u32): void { const i: Guard.Guard = _89[0]; const j: Guard.Guard = _89[1]; const captured9 = i; - const _97: rt.Result = inspectErr$0hrcm18(ok, rt.closure((_2: rt.u32): undefined => { + const _97: rs.Result = inspectErr$1vjhjw3(ok, rs.closure((_2: rs.u32): undefined => { const part = Guard.id(captured9); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args18[0]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args18[0]])); captured9[Symbol.dispose](); }, (): void => { captured9[Symbol.dispose](); })); const captured10 = j; - const inspected: [rt.Result, rt.Result] = [_97, inspectErr$0hrcm18(err, rt.closure((_24: rt.u32): undefined => { + const inspected: [rs.Result, rs.Result] = [_97, inspectErr$1vjhjw3(err, rs.closure((_24: rs.u32): undefined => { const part2 = Guard.id(captured10); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args20[0]])); captured10[Symbol.dispose](); }, (): void => { captured10[Symbol.dispose](); }))]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtResult(chained[0], f, rt.u32Debug, rt.u32Debug), (f: rt.Formatter) => rt.fmtResult(chained[1], f, rt.u32Debug, rt.u32Debug)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtResult(inspected[0], f, rt.u32Debug, rt.u32Debug), (f: rt.Formatter) => rt.fmtResult(inspected[1], f, rt.u32Debug, rt.u32Debug)], f)]; - Log.note(log, rt.fmtFormat(["chained ", args6[0], " ", args6[1]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(chained[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(chained[1], f, rs.u32Debug, rs.u32Debug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtResult(inspected[0], f, rs.u32Debug, rs.u32Debug), (f: rs.Formatter) => rs.fmtResult(inspected[1], f, rs.u32Debug, rs.u32Debug)], f)]; + Log.note(log, rs.fmtFormat(["chained ", args6[0], " ", args6[1]])); const _115: [Guard.Guard, Guard.Guard] = [guard(11), guard(12)]; const k: Guard.Guard = _115[0]; const l: Guard.Guard = _115[1]; const captured11 = k; - const _123: rt.u32 = option_mapOr$0nrpycp(some, 0, rt.closure((n11: rt.u32): rt.u32 => { - const _010: rt.u32 = rt.u32Add(n11, Guard.id(captured11)); + const _123: rs.u32 = option_mapOr$0lyy1bs(some, 0, rs.closure((n11: rs.u32): rs.u32 => { + const _010: rs.u32 = rs.u32Add(n11, Guard.id(captured11)); captured11[Symbol.dispose](); return _010; }, (): void => { captured11[Symbol.dispose](); })); const captured12 = l; - const part3 = [_123, option_mapOr$0nrpycp(none, 0, rt.closure((n12: rt.u32): rt.u32 => { - const _011: rt.u32 = rt.u32Add(n12, Guard.id(captured12)); + const part3 = [_123, option_mapOr$0lyy1bs(none, 0, rs.closure((n12: rs.u32): rs.u32 => { + const _011: rs.u32 = rs.u32Add(n12, Guard.id(captured12)); captured12[Symbol.dispose](); return _011; }, (): void => { captured12[Symbol.dispose](); - }))] as [rt.u32, rt.u32]; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(part3[0], f), (f: rt.Formatter) => rt.u32Debug(part3[1], f)], f)]; - Log.note(log, rt.fmtFormat(["map_or ", args8[0]])); + }))] as [rs.u32, rs.u32]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(part3[0], f), (f: rs.Formatter) => rs.u32Debug(part3[1], f)], f)]; + Log.note(log, rs.fmtFormat(["map_or ", args8[0]])); const _139: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; const m: Guard.Guard = _139[0]; const n: Guard.Guard = _139[1]; const yes: boolean = some !== undefined; const captured13 = m; - const _149: rt.u32 | undefined = then$1j9nint(yes, rt.closure((): rt.u32 => { - const _012: rt.u32 = Guard.id(captured13); + const _149: rs.u32 | undefined = then$0awnlmn(yes, rs.closure((): rs.u32 => { + const _012: rs.u32 = Guard.id(captured13); captured13[Symbol.dispose](); return _012; }, (): void => { captured13[Symbol.dispose](); })); const captured14 = n; - const part4 = [_149, then$1j9nint(!yes, rt.closure((): rt.u32 => { - const _013: rt.u32 = Guard.id(captured14); + const part4 = [_149, then$0awnlmn(!yes, rs.closure((): rs.u32 => { + const _013: rs.u32 = Guard.id(captured14); captured14[Symbol.dispose](); return _013; }, (): void => { captured14[Symbol.dispose](); - }))] as [rt.u32 | undefined, rt.u32 | undefined]; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part4[0], f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(part4[1], f, rt.u32Debug)], f)]; - Log.note(log, rt.fmtFormat(["then ", args10[0]])); + }))] as [rs.u32 | undefined, rs.u32 | undefined]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part4[0], f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(part4[1], f, rs.u32Debug)], f)]; + Log.note(log, rs.fmtFormat(["then ", args10[0]])); const _166: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const o: Guard.Guard = _166[0]; const p: Guard.Guard = _166[1]; const captured15 = o; const captured16 = p; - const other: (a0: rt.u32) => rt.u32 = rt.closure((n14: rt.u32): rt.u32 => { - return rt.u32Add(n14, Guard.id(captured16)); + const other: (a0: rs.u32) => rs.u32 = rs.closure((n14: rs.u32): rs.u32 => { + return rs.u32Add(n14, Guard.id(captured16)); }, (): void => { captured16[Symbol.dispose](); }); - const _181: rt.u32 | undefined = option_map$0b0x7xy(some, rt.closure((n13: rt.u32): rt.u32 => { - return rt.u32Add(n13, Guard.id(captured15)); + const _181: rs.u32 | undefined = option_map$0cxn9jm(some, rs.closure((n13: rs.u32): rs.u32 => { + return rs.u32Add(n13, Guard.id(captured15)); }, (): void => { captured15[Symbol.dispose](); })); - const _183: rt.u32 | undefined = option_map$0b0x7xy(none, other); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_181, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_183, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["by ref ", args12[0], " ", args12[1]])); + const _183: rs.u32 | undefined = option_map$0cxn9jm(none, other); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_181, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_183, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["by ref ", args12[0], " ", args12[1]])); const _191: [Guard.Guard, Guard.Guard] = [guard(18), guard(19)]; const r: Guard.Guard = _191[0]; const s: Guard.Guard = _191[1]; const captured17 = r; const captured18 = s; - const skipped: () => rt.u32 = rt.closure((): rt.u32 => { + const skipped: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured18); }, (): void => { captured18[Symbol.dispose](); }); - const _206: rt.u32 | undefined = then$0kxuq3f(yes, rt.closure((): rt.u32 => { + const _206: rs.u32 | undefined = then$04r7us0(yes, rs.closure((): rs.u32 => { return Guard.id(captured17); }, (): void => { captured17[Symbol.dispose](); })); - const _208: rt.u32 | undefined = then$0kxuq3f(!yes, skipped); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_206, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_208, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["then by ref ", args14[0], " ", args14[1]])); + const _208: rs.u32 | undefined = then$04r7us0(!yes, skipped); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_206, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_208, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["then by ref ", args14[0], " ", args14[1]])); const captured19 = guard(17); - const captured20 = rt.closure((n15: rt.u32): rt.u32 => { - return rt.u32Add(n15, Guard.id(captured19)); + const captured20 = rs.closure((n15: rs.u32): rs.u32 => { + return rs.u32Add(n15, Guard.id(captured19)); }, (): void => { captured19[Symbol.dispose](); }); - const part5 = option_map$1thjygq(some, rt.closure((n16: rt.u32): rt.u32 => { - const _019: rt.u32 = captured20(n16); - rt.drop(captured20); + const part5 = option_map$1ol7nt5(some, rs.closure((n16: rs.u32): rs.u32 => { + const _019: rs.u32 = captured20(n16); + rs.drop(captured20); return _019; }, (): void => { - rt.drop(captured20); + rs.drop(captured20); })); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["nested ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["nested ", args16[0]])); } /** @@ -353,70 +353,70 @@ export function discarded(log: Log.Log, id: rt.u32): void { * after the iterator it wraps, and a call that keeps nothing of it as it returns, with * what each drops of its own before it. */ -export function iterated(log: Log.Log, id: rt.u32): void { +export function iterated(log: Log.Log, id: rs.u32): void { let f!: Guard.Guard; - const guard: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n3), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n3), Log.clone$Clone(log)); }; const a: Guard.Guard = guard(1); - const v: rt.Vec = new rt.Vec(); + const v: rs.Vec = new rs.Vec(); const _14: Guard.Guard = guard(2); v.items.push(_14); const _19: Guard.Guard = guard(3); v.items.push(_19); const _24: Guard.Guard = guard(4); v.items.push(_24); - const _9: rt.Iter = rt.vecIntoIter(v, rt.drop); + const _9: rs.Iter = rs.vecIntoIter(v, rs.drop); const captured = a; - const mapped: rt.Iter = rt.iterMap(_9, rt.closure((g3: Guard.Guard): rt.u32 => { - const _02: rt.u32 = rt.u32Add(Guard.id(g3), Guard.id(captured)); + const mapped: rs.Iter = rs.iterMap(_9, rs.closure((g3: Guard.Guard): rs.u32 => { + const _02: rs.u32 = rs.u32Add(Guard.id(g3), Guard.id(captured)); g3[Symbol.dispose](); return _02; }, (): void => { captured[Symbol.dispose](); })); - const _34: rt.u32 | undefined = rt.iterToOption(mapped.next()); - const _37: rt.u32 | undefined = rt.iterToOption(mapped.next()); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_34, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_37, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["map ", args2[0], " ", args2[1]])); - rt.drop(mapped); + const _34: rs.u32 | undefined = rs.iterToOption(mapped.next()); + const _37: rs.u32 | undefined = rs.iterToOption(mapped.next()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_34, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_37, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); + rs.drop(mapped); const b: Guard.Guard = guard(5); - const v2: rt.Vec = new rt.Vec(); + const v2: rs.Vec = new rs.Vec(); const _56: Guard.Guard = guard(6); v2.items.push(_56); const _61: Guard.Guard = guard(7); v2.items.push(_61); const _66: Guard.Guard = guard(8); v2.items.push(_66); - const _51: rt.Iter = rt.vecIntoIter(v2, rt.drop); + const _51: rs.Iter = rs.vecIntoIter(v2, rs.drop); const captured2 = b; - const iter: rt.Iter = rt.iterFilter(_51, rt.closure((g4: Guard.Guard): boolean => { - return Guard.id(g4) !== rt.u32Add(Guard.id(captured2), 1); + const iter: rs.Iter = rs.iterFilter(_51, rs.closure((g4: Guard.Guard): boolean => { + return Guard.id(g4) !== rs.u32Add(Guard.id(captured2), 1); }, (): void => { captured2[Symbol.dispose](); - }), rt.drop); + }), rs.drop); while (true) { - const _71: Guard.Guard | rt.Done = iter.next(); - if (_71 === rt.DONE) { + const _71: Guard.Guard | rs.Done = iter.next(); + if (_71 === rs.DONE) { break; } const g: Guard.Guard = _71; const part = Guard.id(g); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["filter ", args4[0]])); - if (!(Guard.id(g) === rt.u32Add(id, 7))) { + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["filter ", args4[0]])); + if (!(Guard.id(g) === rs.u32Add(id, 7))) { g[Symbol.dispose](); } else { g[Symbol.dispose](); break; } } - rt.drop(iter); + rs.drop(iter); const _95: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(9), guard(10), guard(11)]; const c: Guard.Guard = _95[0]; const d: Guard.Guard = _95[1]; const e: Guard.Guard = _95[2]; - const v3: rt.Vec = new rt.Vec(); + const v3: rs.Vec = new rs.Vec(); const _113: Guard.Guard = guard(12); v3.items.push(_113); const _118: Guard.Guard = guard(13); @@ -425,294 +425,294 @@ export function iterated(log: Log.Log, id: rt.u32): void { v3.items.push(_123); const _128: Guard.Guard = guard(15); v3.items.push(_128); - const _108: rt.Iter = rt.vecIntoIter(v3, rt.drop); + const _108: rs.Iter = rs.vecIntoIter(v3, rs.drop); const captured3 = c; - const _107: rt.Iter = rt.iterSkipWhile(_108, rt.closure((g5: Guard.Guard): boolean => { - return Guard.id(g5) < rt.u32Add(Guard.id(captured3), 4); + const _107: rs.Iter = rs.iterSkipWhile(_108, rs.closure((g5: Guard.Guard): boolean => { + return Guard.id(g5) < rs.u32Add(Guard.id(captured3), 4); }, (): void => { captured3[Symbol.dispose](); - }), rt.drop); + }), rs.drop); const captured4 = d; - const _106: rt.Iter = rt.iterTakeWhile(_107, rt.closure((g6: Guard.Guard): boolean => { - return Guard.id(g6) < rt.u32Add(Guard.id(captured4), 5); + const _106: rs.Iter = rs.iterTakeWhile(_107, rs.closure((g6: Guard.Guard): boolean => { + return Guard.id(g6) < rs.u32Add(Guard.id(captured4), 5); }, (): void => { captured4[Symbol.dispose](); - }), rt.drop); + }), rs.drop); const captured5 = e; - const chained: rt.Iter = rt.iterInspect(_106, rt.closure((g7: Guard.Guard): undefined => { - const _92: rt.u32 = Guard.id(g7); - const _11: rt.u32 = Guard.id(captured5); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_92, f), (f: rt.Formatter) => rt.u32Display(_11, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args30[0], " ", args30[1]])); + const chained: rs.Iter = rs.iterInspect(_106, rs.closure((g7: Guard.Guard): undefined => { + const _92: rs.u32 = Guard.id(g7); + const _11: rs.u32 = Guard.id(captured5); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_11, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args30[0], " ", args30[1]])); }, (): void => { captured5[Symbol.dispose](); })); - const part2 = option_map$1raha9y(rt.iterToOption(chained.next()), (g8: Guard.Guard): rt.u32 => { - const _06: rt.u32 = Guard.id(g8); + const part2 = option_map$06w9waf(rs.iterToOption(chained.next()), (g8: Guard.Guard): rs.u32 => { + const _06: rs.u32 = Guard.id(g8); g8[Symbol.dispose](); return _06; }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["chained ", args6[0]])); - const part3 = option_map$1raha9y(rt.iterToOption(chained.next()), (g9: Guard.Guard): rt.u32 => { - const _07: rt.u32 = Guard.id(g9); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["chained ", args6[0]])); + const part3 = option_map$06w9waf(rs.iterToOption(chained.next()), (g9: Guard.Guard): rs.u32 => { + const _07: rs.u32 = Guard.id(g9); g9[Symbol.dispose](); return _07; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["chained ", args8[0]])); - rt.drop(chained); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["chained ", args8[0]])); + rs.drop(chained); const _164: [Guard.Guard, Guard.Guard] = [guard(16), guard(17)]; f = _164[0]; const g2: Guard.Guard = _164[1]; - const v4: rt.Vec = new rt.Vec(); + const v4: rs.Vec = new rs.Vec(); v4.items.push(1); v4.items.push(2); v4.items.push(3); - const _173: rt.Iter = rt.vecIntoIter(v4); + const _173: rs.Iter = rs.vecIntoIter(v4); const captured6 = f; - const _172: rt.Iter = rt.iterFilterMap(_173, rt.closure((n4: rt.u32): rt.u32 | undefined => { - return thenSome$1af3oea(n4 !== 2, rt.u32Add(n4, Guard.id(captured6))); + const _172: rs.Iter = rs.iterFilterMap(_173, rs.closure((n4: rs.u32): rs.u32 | undefined => { + return thenSome$1bahm2u(n4 !== 2, rs.u32Add(n4, Guard.id(captured6))); }, (): void => { captured6[Symbol.dispose](); })); const captured7 = g2; - const flat: rt.Iter = rt.iterFlatMap(_172, rt.closure((n5: rt.u32): rt.Vec => { - const v7: rt.Vec = new rt.Vec(); + const flat: rs.Iter = rs.iterFlatMap(_172, rs.closure((n5: rs.u32): rs.Vec => { + const v7: rs.Vec = new rs.Vec(); v7.items.push(n5); - const _8: rt.u32 = rt.u32Add(n5, Guard.id(captured7)); + const _8: rs.u32 = rs.u32Add(n5, Guard.id(captured7)); v7.items.push(_8); return v7; }, (): void => { captured7[Symbol.dispose](); - }), (value: rt.Vec) => rt.vecIntoIter(value), true); - const part4 = rt.iterToOption(flat.next()); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["flat ", args10[0]])); - rt.drop(flat); + }), (value: rs.Vec) => rs.vecIntoIter(value), true); + const part4 = rs.iterToOption(flat.next()); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flat ", args10[0]])); + rs.drop(flat); const w: Guard.Guard = guard(47); - const _202: rt.Iter = rt.iterSlice([1]); + const _202: rs.Iter = rs.iterSlice([1]); const captured8 = w; - const ended: rt.Iter = rt.iterFlatMap(_202, rt.closure((_2: rt.u32): rt.u32[] => { + const ended: rs.Iter = rs.iterFlatMap(_202, rs.closure((_2: rs.u32): rs.u32[] => { return [_2, Guard.id(captured8)]; }, (): void => { captured8[Symbol.dispose](); - }), (value: rt.u32[]) => rt.iterSlice(value), true, 2); - while (rt.iterToOption(ended.next()) !== undefined) { + }), (value: rs.u32[]) => rs.iterSlice(value), true, 2); + while (rs.iterToOption(ended.next()) !== undefined) { } - Log.note(log, rt.fmtFormat(["flat_map ended"])); - rt.drop(ended); + Log.note(log, rs.fmtFormat(["flat_map ended"])); + rs.drop(ended); const h: Guard.Guard = guard(18); - const _221: rt.Iter = rt.iterSlice([1, 2, 3]); + const _221: rs.Iter = rs.iterSlice([1, 2, 3]); const captured9 = h; - const part5 = rt.iterToVec(rt.iterMapWhile(_221, rt.closure((_22: rt.u32): rt.u32 | undefined => { - const n7: rt.u32 = _22; - return thenSome$1af3oea(n7 < 3, rt.u32Add(n7, Guard.id(captured9))); + const part5 = rs.iterToVec(rs.iterMapWhile(_221, rs.closure((_22: rs.u32): rs.u32 | undefined => { + const n7: rs.u32 = _22; + return thenSome$1bahm2u(n7 < 3, rs.u32Add(n7, Guard.id(captured9))); }, (): void => { captured9[Symbol.dispose](); })), "next", 4); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part5.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["map_while ", args12[0]])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map_while ", args12[0]])); const _237: [Guard.Guard, Guard.Guard] = [guard(19), guard(20)]; const i: Guard.Guard = _237[0]; const j: Guard.Guard = _237[1]; const captured10 = i; - const made: rt.usize = rt.ownedCount(rt.iterTake(rt.iterFromFn(rt.closure((): rt.u32 | undefined => { + const made: rs.usize = rs.ownedCount(rs.iterTake(rs.iterFromFn(rs.closure((): rs.u32 | undefined => { return Guard.id(captured10); }, (): void => { captured10[Symbol.dispose](); })), 2)); const captured11 = j; - const walked: rt.u32 = rt.iterSum(rt.iterSuccessors(1, rt.closure((_25: rt.u32): rt.u32 | undefined => { - const n8: rt.u32 = _25; - return thenSome$1af3oea(n8 < 3, rt.u32Sub(rt.u32Add(rt.u32Add(n8, 1), Guard.id(captured11)), Guard.id(captured11))); + const walked: rs.u32 = rs.iterSum(rs.iterSuccessors(1, rs.closure((_25: rs.u32): rs.u32 | undefined => { + const n8: rs.u32 = _25; + return thenSome$1bahm2u(n8 < 3, rs.u32Sub(rs.u32Add(rs.u32Add(n8, 1), Guard.id(captured11)), Guard.id(captured11))); }, (): void => { captured11[Symbol.dispose](); - })), rt.u32Add, 0, true); + })), rs.u32Add, 0, true); const s: Guard.Guard = guard(43); const _256: Guard.Guard | undefined = guard(40); const captured12 = s; - const chain: rt.Iter = rt.iterSuccessors(_256, rt.closure((g10: Guard.Guard): Guard.Guard | undefined => { - return then$1xpp3sz(rt.u32Add(Guard.id(g10), 1) < Guard.id(captured12), (): Guard.Guard => { - return Guard.new(rt.u32Add(Guard.id(g10), 1), Log.clone$Clone(log)); + const chain: rs.Iter = rs.iterSuccessors(_256, rs.closure((g10: Guard.Guard): Guard.Guard | undefined => { + return then$1xpp3sz(rs.u32Add(Guard.id(g10), 1) < Guard.id(captured12), (): Guard.Guard => { + return Guard.new(rs.u32Add(Guard.id(g10), 1), Log.clone$Clone(log)); }); }, (): void => { captured12[Symbol.dispose](); - }), rt.drop); - const _267: rt.u32 | undefined = option_map$1raha9y(rt.iterToOption(chain.next()), (g11: Guard.Guard): rt.u32 => { - const _016: rt.u32 = Guard.id(g11); + }), rs.drop); + const _267: rs.u32 | undefined = option_map$06w9waf(rs.iterToOption(chain.next()), (g11: Guard.Guard): rs.u32 => { + const _016: rs.u32 = Guard.id(g11); g11[Symbol.dispose](); return _016; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(made, f), (f: rt.Formatter) => rt.u32Display(walked, f), (f: rt.Formatter) => rt.fmtOption(_267, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["lazy ", args14[0], " ", args14[1], " ", args14[2]])); - const part6 = option_map$1raha9y(rt.iterToOption(chain.next()), (g12: Guard.Guard): rt.u32 => { - const _017: rt.u32 = Guard.id(g12); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(made, f), (f: rs.Formatter) => rs.u32Display(walked, f), (f: rs.Formatter) => rs.fmtOption(_267, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["lazy ", args14[0], " ", args14[1], " ", args14[2]])); + const part6 = option_map$06w9waf(rs.iterToOption(chain.next()), (g12: Guard.Guard): rs.u32 => { + const _017: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _017; }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["successor ", args16[0]])); - rt.drop(chain); - const v5: rt.Vec = new rt.Vec(); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["successor ", args16[0]])); + rs.drop(chain); + const v5: rs.Vec = new rs.Vec(); const _297: Guard.Guard = guard(21); v5.items.push(_297); const _302: Guard.Guard = guard(22); v5.items.push(_302); const _307: Guard.Guard = guard(23); v5.items.push(_307); - const items: rt.Vec = v5; + const items: rs.Vec = v5; const _313: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(24), guard(25), guard(26)]; const k: Guard.Guard = _313[0]; const l: Guard.Guard = _313[1]; const m: Guard.Guard = _313[2]; - const _325: rt.Iter = rt.iterSlice(items.items); + const _325: rs.Iter = rs.iterSlice(items.items); const captured13 = k; - const _328: (a0: Guard.Guard) => boolean = rt.closure((g13: Guard.Guard): boolean => { + const _328: (a0: Guard.Guard) => boolean = rs.closure((g13: Guard.Guard): boolean => { return Guard.id(g13) === Guard.id(captured13); }, (): void => { captured13[Symbol.dispose](); }); - const any: boolean = rt.dropAfter(_328, () => rt.iterAny(_325, _328)); - const _332: rt.Iter = rt.iterSlice(items.items); + const any: boolean = rs.dropAfter(_328, () => rs.iterAny(_325, _328)); + const _332: rs.Iter = rs.iterSlice(items.items); const captured14 = l; - const _335: (a0: Guard.Guard) => boolean = rt.closure((g14: Guard.Guard): boolean => { - return Guard.id(g14) === rt.u32Sub(Guard.id(captured14), 3); + const _335: (a0: Guard.Guard) => boolean = rs.closure((g14: Guard.Guard): boolean => { + return Guard.id(g14) === rs.u32Sub(Guard.id(captured14), 3); }, (): void => { captured14[Symbol.dispose](); }); - const found: rt.u32 | undefined = option_map$1raha9y(rt.dropAfter(_335, () => rt.iterFind(_332, _335)), (g15: Guard.Guard): rt.u32 => { + const found: rs.u32 | undefined = option_map$06w9waf(rs.dropAfter(_335, () => rs.iterFind(_332, _335)), (g15: Guard.Guard): rs.u32 => { return Guard.id(g15); }); - const _338: rt.Iter = rt.iterSlice(items.items); + const _338: rs.Iter = rs.iterSlice(items.items); const captured15 = m; - const _341: (a0: Guard.Guard) => boolean = rt.closure((g16: Guard.Guard): boolean => { - return rt.u32Add(Guard.id(g16), 2) === Guard.id(captured15); + const _341: (a0: Guard.Guard) => boolean = rs.closure((g16: Guard.Guard): boolean => { + return rs.u32Add(Guard.id(g16), 2) === Guard.id(captured15); }, (): void => { captured15[Symbol.dispose](); }); - const atPos: rt.usize | undefined = rt.dropAfter(_341, () => rt.iterPosition(_338, _341)); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(any, f), (f: rt.Formatter) => rt.fmtOption(found, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(atPos, f, rt.usizeDebug)]; - Log.note(log, rt.fmtFormat(["found ", args18[0], " ", args18[1], " ", args18[2]])); + const atPos: rs.usize | undefined = rs.dropAfter(_341, () => rs.iterPosition(_338, _341)); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(found, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(atPos, f, rs.usizeDebug)]; + Log.note(log, rs.fmtFormat(["found ", args18[0], " ", args18[1], " ", args18[2]])); const n: Guard.Guard = guard(27); - const _361: rt.Iter = rt.iterSlice([1, 2, 3]); + const _361: rs.Iter = rs.iterSlice([1, 2, 3]); const captured16 = n; - const sum: rt.u32 = rt.iterSum(rt.iterMap(_361, rt.closure((_210: rt.u32): rt.u32 => { - return rt.u32Add(_210, Guard.id(captured16)); + const sum: rs.u32 = rs.iterSum(rs.iterMap(_361, rs.closure((_210: rs.u32): rs.u32 => { + return rs.u32Add(_210, Guard.id(captured16)); }, (): void => { captured16[Symbol.dispose](); - })), rt.u32Add, 0, true); + })), rs.u32Add, 0, true); const o: Guard.Guard = guard(28); - const _369: rt.Iter = rt.iterSlice([1, 2]); + const _369: rs.Iter = rs.iterSlice([1, 2]); const captured17 = o; - rt.iterForEach(_369, rt.closure((_214: rt.u32): undefined => { - const part7 = rt.u32Add(_214, Guard.id(captured17)); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["each ", args32[0]])); + rs.iterForEach(_369, rs.closure((_214: rs.u32): undefined => { + const part7 = rs.u32Add(_214, Guard.id(captured17)); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["each ", args32[0]])); }, (): void => { captured17[Symbol.dispose](); }), undefined, true); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f)]; - Log.note(log, rt.fmtFormat(["sum ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat(["sum ", args20[0]])); const _386: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(44), guard(45), guard(46)]; const t: Guard.Guard = _386[0]; const u: Guard.Guard = _386[1]; const v6: Guard.Guard = _386[2]; - const _399: rt.Iter = rt.iterSlice([1, 2]); + const _399: rs.Iter = rs.iterSlice([1, 2]); const captured18 = t; - const peeked: rt.usize = rt.ownedCount(rt.iterPeekable(rt.iterMap(_399, rt.closure((_216: rt.u32): rt.u32 => { - return rt.u32Add(_216, Guard.id(captured18)); + const peeked: rs.usize = rs.ownedCount(rs.iterPeekable(rs.iterMap(_399, rs.closure((_216: rs.u32): rs.u32 => { + return rs.u32Add(_216, Guard.id(captured18)); }, (): void => { captured18[Symbol.dispose](); })))); - const _406: rt.Iter = rt.iterSlice([1, 2, 3]); + const _406: rs.Iter = rs.iterSlice([1, 2, 3]); const captured19 = u; - const skipped: rt.usize = rt.ownedCount(rt.iterSkip(rt.iterMap(_406, rt.closure((_217: rt.u32): rt.u32 => { - return rt.u32Add(_217, Guard.id(captured19)); + const skipped: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterMap(_406, rs.closure((_217: rs.u32): rs.u32 => { + return rs.u32Add(_217, Guard.id(captured19)); }, (): void => { captured19[Symbol.dispose](); })), 1)); - const _413: rt.Iter = rt.iterSlice([1, 2]); + const _413: rs.Iter = rs.iterSlice([1, 2]); const captured20 = v6; - const last: rt.u32 | undefined = rt.ownedLast(rt.iterSkip(rt.iterMap(_413, rt.closure((_219: rt.u32): rt.u32 => { - return rt.u32Add(_219, Guard.id(captured20)); + const last: rs.u32 | undefined = rs.ownedLast(rs.iterSkip(rs.iterMap(_413, rs.closure((_219: rs.u32): rs.u32 => { + return rs.u32Add(_219, Guard.id(captured20)); }, (): void => { captured20[Symbol.dispose](); })), 1)); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(peeked, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtOption(last, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["counted ", args22[0], " ", args22[1], " ", args22[2]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(peeked, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtOption(last, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["counted ", args22[0], " ", args22[1], " ", args22[2]])); const r: Guard.Guard = guard(36); - const _435: rt.Iter = rt.iterMap(rt.iterSlice([1, 2, 3]), (_225: rt.u32): Guard.Guard => { - return guard(rt.u32Add(36, _225)); + const _435: rs.Iter = rs.iterMap(rs.iterSlice([1, 2, 3]), (_225: rs.u32): Guard.Guard => { + return guard(rs.u32Add(36, _225)); }); const captured21 = r; - const part9 = option_map$1raha9y(rt.iterMaxByKey(_435, rt.closure((g17: Guard.Guard): rt.u32 => { - return rt.u32Add(rt.u32Rem(Guard.id(g17), 2), Guard.id(captured21)); + const part9 = option_map$06w9waf(rs.iterMaxByKey(_435, rs.closure((g17: Guard.Guard): rs.u32 => { + return rs.u32Add(rs.u32Rem(Guard.id(g17), 2), Guard.id(captured21)); }, (): void => { captured21[Symbol.dispose](); - }), rt.lt, undefined, rt.drop, true), (g18: Guard.Guard): rt.u32 => { - const _028: rt.u32 = Guard.id(g18); + }), rs.lt, undefined, rs.drop, true), (g18: Guard.Guard): rs.u32 => { + const _028: rs.u32 = Guard.id(g18); g18[Symbol.dispose](); return _028; }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["best ", args24[0]])); - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const iter2: rt.Iter<[rt.u32, rt.u32]> = rt.iterSlice([[1, 29] as [rt.u32, rt.u32], [2, 30] as [rt.u32, rt.u32], [3, 31] as [rt.u32, rt.u32]]); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["best ", args24[0]])); + const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const iter2: rs.Iter<[rs.u32, rs.u32]> = rs.iterSlice([[1, 29] as [rs.u32, rs.u32], [2, 30] as [rs.u32, rs.u32], [3, 31] as [rs.u32, rs.u32]]); while (true) { - const _460: [rt.u32, rt.u32] | rt.Done = iter2.next(); - if (_460 === rt.DONE) { + const _460: [rs.u32, rs.u32] | rs.Done = iter2.next(); + if (_460 === rs.DONE) { break; } - const k2: rt.u32 = _460[0]; + const k2: rs.u32 = _460[0]; const _467: Guard.Guard = guard(_460[1]); - rt.drop(rt.btreeInsert(map, k2, _467)); + rs.drop(rs.btreeInsert(map, k2, _467)); } const captured22 = guard(32); const captured23 = id; - const _475: (a0: rt.u32, a1: Guard.Guard) => boolean = rt.closure((_229: rt.u32, _321: Guard.Guard): boolean => { - return rt.u32Add(_229, Guard.id(captured22)) !== rt.u32Add(captured23, 34); + const _475: (a0: rs.u32, a1: Guard.Guard) => boolean = rs.closure((_229: rs.u32, _321: Guard.Guard): boolean => { + return rs.u32Add(_229, Guard.id(captured22)) !== rs.u32Add(captured23, 34); }, (): void => { captured22[Symbol.dispose](); }); - rt.dropAfter(_475, () => rt.btreeRetain(map, _475, undefined, rt.drop)); - const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; + rs.dropAfter(_475, () => rs.btreeRetain(map, _475, undefined, rs.drop)); + const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; const _479: Guard.Guard = guard(33); - rt.dequePushBack(queue, _479); + rs.dequePushBack(queue, _479); const _484: Guard.Guard = guard(34); - rt.dequePushBack(queue, _484); + rs.dequePushBack(queue, _484); const captured24 = guard(35); - const _492: (a0: Guard.Guard) => boolean = rt.closure((g19: Guard.Guard): boolean => { - return rt.u32Add(Guard.id(g19), 2) !== Guard.id(captured24); + const _492: (a0: Guard.Guard) => boolean = rs.closure((g19: Guard.Guard): boolean => { + return rs.u32Add(Guard.id(g19), 2) !== Guard.id(captured24); }, (): void => { captured24[Symbol.dispose](); }); - rt.dropAfter(_492, () => rt.dequeRetain(queue, _492, rt.drop)); - const _499: rt.usize = rt.btreeLen(map); - const _502: rt.usize = queue.n; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_499, f), (f: rt.Formatter) => rt.usizeDisplay(_502, f)]; - Log.note(log, rt.fmtFormat(["retained ", args26[0], " ", args26[1]])); + rs.dropAfter(_492, () => rs.dequeRetain(queue, _492, rs.drop)); + const _499: rs.usize = rs.btreeLen(map); + const _502: rs.usize = queue.n; + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_499, f), (f: rs.Formatter) => rs.usizeDisplay(_502, f)]; + Log.note(log, rs.fmtFormat(["retained ", args26[0], " ", args26[1]])); const x: Guard.Guard = guard(48); const _513: Guard.Guard[] = [guard(49), guard(50), guard(51)]; const captured25 = x; - const _523: (a0: Guard.Guard) => Guard.Guard | undefined = rt.closure((g20: Guard.Guard): Guard.Guard | undefined => { + const _523: (a0: Guard.Guard) => Guard.Guard | undefined = rs.closure((g20: Guard.Guard): Guard.Guard | undefined => { const part10 = Guard.id(g20); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; - Log.note(log, rt.fmtFormat(["array map ", args34[0]])); - return thenSome$0zvoczk(Guard.id(g20) !== rt.u32Add(Guard.id(captured25), 2), g20); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; + Log.note(log, rs.fmtFormat(["array map ", args34[0]])); + return thenSome$0zvoczk(Guard.id(g20) !== rs.u32Add(Guard.id(captured25), 2), g20); }, (): void => { captured25[Symbol.dispose](); }); - const kept: Array = rt.dropAfter(_523, () => rt.arrayMap(_513, _523)); - const part11 = rt.arrayMap(rt.arrayFrom(kept), (g21: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$0lq7mno(g21, Guard.id); + const kept: Array = rs.dropAfter(_523, () => rs.arrayMap(_513, _523)); + const part11 = rs.arrayMap(rs.arrayFrom(kept), (g21: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$02u0dmi(g21, Guard.id); }); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part11, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; - Log.note(log, rt.fmtFormat(["array mapped ", args28[0]])); - rt.dropAll(kept); - rt.dequeDrop(queue, rt.drop); - rt.btreeDrop(map, undefined, rt.drop); - rt.dropVec(items); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part11, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))]; + Log.note(log, rs.fmtFormat(["array mapped ", args28[0]])); + rs.dropAll(kept); + rs.dequeDrop(queue, rs.drop); + rs.btreeDrop(map, undefined, rs.drop); + rs.dropVec(items); } //# sourceMappingURL=closures.ts.map diff --git a/ts/fixtures/task/expected/drops/flattened.ts b/ts/fixtures/task/expected/drops/flattened.ts index 2c4334231..e0c3ecb1c 100644 --- a/ts/fixtures/task/expected/drops/flattened.ts +++ b/ts/fixtures/task/expected/drops/flattened.ts @@ -1,346 +1,346 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Vec_model_Guard as lib_drop$Vec_model_Guard, drop$tuple2_usize_model_Guard as lib_drop$tuple2_usize_model_Guard } from "../lib.ts"; import { thenSome$0zvoczk } from "../core/bool.ts"; -import { map$1raha9y as option_map$1raha9y, map$14zg54s as option_map$14zg54s } from "../core/option.ts"; +import { map$06w9waf as option_map$06w9waf, map$1389p4b as option_map$1389p4b } from "../core/option.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Three `Vec`s of guards, of 3, 2, and 3, numbered from `n`. */ -export function nested(log: Log.Log, id: rt.u32, n: rt.u32): rt.Vec> { - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), (k: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, k), Log.clone$Clone(log)); +export function nested(log: Log.Log, id: rs.u32, n: rs.u32): rs.Vec> { + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), (k: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, k), Log.clone$Clone(log)); }), undefined, 8, true); }; - const all: rt.Vec> = new rt.Vec(); - const _9: rt.Vec = guards(n, rt.u32Add(n, 3)); + const all: rs.Vec> = new rs.Vec(); + const _9: rs.Vec = guards(n, rs.u32Add(n, 3)); all.items.push(_9); - const _16: rt.Vec = guards(rt.u32Add(n, 3), rt.u32Add(n, 5)); + const _16: rs.Vec = guards(rs.u32Add(n, 3), rs.u32Add(n, 5)); all.items.push(_16); - const _25: rt.Vec = guards(rt.u32Add(n, 5), rt.u32Add(n, 8)); + const _25: rs.Vec = guards(rs.u32Add(n, 5), rs.u32Add(n, 8)); all.items.push(_25); return all; } /** A flatten of the first of each of `nested`'s from `n`, which logs each it makes. */ -export function firsts(log: Log.Log, id: rt.u32, n: rt.u32): rt.Iter { - const _5: rt.Iter> = rt.vecIntoIter(nested(log, id, n), lib_drop$Vec_model_Guard); +export function firsts(log: Log.Log, id: rs.u32, n: rs.u32): rs.Iter { + const _5: rs.Iter> = rs.vecIntoIter(nested(log, id, n), lib_drop$Vec_model_Guard); const captured = id; - return rt.iterFlatten(rt.iterMap(_5, (v: rt.Vec): rt.Iter => { - const part = rt.u32Sub(Guard.id(v.items[rt.idx(v.items, 0)]), captured); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["inner ", args2[0]])); - return rt.iterTake(rt.vecIntoIter(v, rt.drop), 1, rt.drop); + return rs.iterFlatten(rs.iterMap(_5, (v: rs.Vec): rs.Iter => { + const part = rs.u32Sub(Guard.id(v.items[rs.idx(v.items, 0)]), captured); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["inner ", args2[0]])); + return rs.iterTake(rs.vecIntoIter(v, rs.drop), 1, rs.drop); }), undefined, true); } /** Run scenario `arg % 10`. */ -export function flattened(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const idOf: (a0: Guard.Guard | undefined) => rt.u32 | undefined = (g2: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(g2, (g3: Guard.Guard): rt.u32 => { - const _02: rt.u32 = rt.u32Sub(Guard.id(g3), id); +export function flattened(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const idOf: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (g2: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(g2, (g3: Guard.Guard): rs.u32 => { + const _02: rs.u32 = rs.u32Sub(Guard.id(g3), id); g3[Symbol.dispose](); return _02; }); }; - const _6: rt.u8 = rt.u8Rem(arg, 10); + const _6: rs.u8 = rs.u8Rem(arg, 10); if (_6 === 0) { - const it: rt.Iter = firsts(log, id, 1); - const part62 = rt.iterToOption(it.next()); + const it: rs.Iter = firsts(log, id, 1); + const part62 = rs.iterToOption(it.next()); const part63 = idOf(part62); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part63, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["next ", args2[0]])); - const part64 = rt.iterToOption(it.next()); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part63, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["next ", args2[0]])); + const part64 = rs.iterToOption(it.next()); const part65 = idOf(part64); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part65, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["next ", args4[0]])); - rt.drop(it); - const iter: rt.Iter = firsts(log, id, 20); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part65, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["next ", args4[0]])); + rs.drop(it); + const iter: rs.Iter = firsts(log, id, 20); while (true) { - const _44: Guard.Guard | rt.Done = iter.next(); - if (_44 === rt.DONE) { + const _44: Guard.Guard | rs.Done = iter.next(); + if (_44 === rs.DONE) { break; } const g: Guard.Guard = _44; - const part66 = rt.u32Sub(Guard.id(g), id); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part66, f)]; - Log.note(log, rt.fmtFormat(["for ", args6[0]])); + const part66 = rs.u32Sub(Guard.id(g), id); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part66, f)]; + Log.note(log, rs.fmtFormat(["for ", args6[0]])); g[Symbol.dispose](); } - rt.drop(iter); + rs.drop(iter); } else if (_6 === 1) { - rt.iterForEach(firsts(log, id, 1), (g26: Guard.Guard): undefined => { - const part58 = rt.u32Sub(Guard.id(g26), id); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part58, f)]; - Log.note(log, rt.fmtFormat(["each ", args82[0]])); + rs.iterForEach(firsts(log, id, 1), (g26: Guard.Guard): undefined => { + const part58 = rs.u32Sub(Guard.id(g26), id); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part58, f)]; + Log.note(log, rs.fmtFormat(["each ", args82[0]])); g26[Symbol.dispose](); }, true); - const part59 = rt.ownedCount(firsts(log, id, 20), rt.drop); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part59, f)]; - Log.note(log, rt.fmtFormat(["count ", args8[0]])); - const part60 = rt.ownedLast(firsts(log, id, 40), rt.drop); + const part59 = rs.ownedCount(firsts(log, id, 20), rs.drop); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part59, f)]; + Log.note(log, rs.fmtFormat(["count ", args8[0]])); + const part60 = rs.ownedLast(firsts(log, id, 40), rs.drop); const part61 = idOf(part60); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part61, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["last ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part61, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args10[0]])); } else if (_6 === 2) { - const it2: rt.Iter = firsts(log, id, 1); - const part51 = rt.iterFind(it2, (g22: Guard.Guard): boolean => { - return Guard.id(g22) === rt.u32Add(id, 4); - }, rt.drop); + const it2: rs.Iter = firsts(log, id, 1); + const part51 = rs.iterFind(it2, (g22: Guard.Guard): boolean => { + return Guard.id(g22) === rs.u32Add(id, 4); + }, rs.drop); const part52 = idOf(part51); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part52, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["find ", args12[0]])); - const part53 = rt.iterToOption(it2.next()); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part52, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["find ", args12[0]])); + const part53 = rs.iterToOption(it2.next()); const part54 = idOf(part53); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part54, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["then ", args14[0]])); - rt.drop(it2); - const it3: rt.Iter = firsts(log, id, 20); - const part55 = rt.iterAny(it3, (g23: Guard.Guard): boolean => { - const _025: boolean = Guard.id(g23) === rt.u32Add(id, 99); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part54, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["then ", args14[0]])); + rs.drop(it2); + const it3: rs.Iter = firsts(log, id, 20); + const part55 = rs.iterAny(it3, (g23: Guard.Guard): boolean => { + const _025: boolean = Guard.id(g23) === rs.u32Add(id, 99); g23[Symbol.dispose](); return _025; }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part55, f)]; - Log.note(log, rt.fmtFormat(["any ", args16[0]])); - rt.drop(it3); - const _153: rt.Iter = firsts(log, id, 40); - const part56 = rt.iterAll(_153, (g24: Guard.Guard): boolean => { - const _026: boolean = Guard.id(g24) !== rt.u32Add(id, 43); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part55, f)]; + Log.note(log, rs.fmtFormat(["any ", args16[0]])); + rs.drop(it3); + const _153: rs.Iter = firsts(log, id, 40); + const part56 = rs.iterAll(_153, (g24: Guard.Guard): boolean => { + const _026: boolean = Guard.id(g24) !== rs.u32Add(id, 43); g24[Symbol.dispose](); return _026; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part56, f)]; - const _147: string = rt.fmtFormat(["all ", args18[0]]); - rt.drop(_153); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part56, f)]; + const _147: string = rs.fmtFormat(["all ", args18[0]]); + rs.drop(_153); Log.note(log, _147); - const _168: rt.Iter = firsts(log, id, 60); - const part57 = rt.iterPosition(_168, (g25: Guard.Guard): boolean => { - const _027: boolean = Guard.id(g25) === rt.u32Add(id, 63); + const _168: rs.Iter = firsts(log, id, 60); + const part57 = rs.iterPosition(_168, (g25: Guard.Guard): boolean => { + const _027: boolean = Guard.id(g25) === rs.u32Add(id, 63); g25[Symbol.dispose](); return _027; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part57, f, rt.usizeDebug)]; - const _162: string = rt.fmtFormat(["position ", args20[0]]); - rt.drop(_168); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part57, f, rs.usizeDebug)]; + const _162: string = rs.fmtFormat(["position ", args20[0]]); + rs.drop(_168); Log.note(log, _162); } else if (_6 === 3) { - const it4: rt.Iter = rt.iterFilter(firsts(log, id, 1), (g19: Guard.Guard): boolean => { - return Guard.id(g19) !== rt.u32Add(id, 1); - }, rt.drop); - const part43 = rt.iterToOption(it4.next()); + const it4: rs.Iter = rs.iterFilter(firsts(log, id, 1), (g19: Guard.Guard): boolean => { + return Guard.id(g19) !== rs.u32Add(id, 1); + }, rs.drop); + const part43 = rs.iterToOption(it4.next()); const part44 = idOf(part43); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part44, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["filter ", args22[0]])); - const part45 = rt.iterToOption(it4.next()); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part44, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["filter ", args22[0]])); + const part45 = rs.iterToOption(it4.next()); const part46 = idOf(part45); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part46, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["filter ", args24[0]])); - rt.drop(it4); - const it5: rt.Iter = rt.iterFilterMap(firsts(log, id, 20), (g20: Guard.Guard): Guard.Guard | undefined => { - return thenSome$0zvoczk(Guard.id(g20) !== rt.u32Add(id, 20), g20); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part46, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["filter ", args24[0]])); + rs.drop(it4); + const it5: rs.Iter = rs.iterFilterMap(firsts(log, id, 20), (g20: Guard.Guard): Guard.Guard | undefined => { + return thenSome$0zvoczk(Guard.id(g20) !== rs.u32Add(id, 20), g20); }); - const part47 = rt.iterToOption(it5.next()); + const part47 = rs.iterToOption(it5.next()); const part48 = idOf(part47); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part48, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["filter_map ", args26[0]])); - rt.drop(it5); - const it6: rt.Iter = rt.iterSkipWhile(firsts(log, id, 40), (g21: Guard.Guard): boolean => { - return Guard.id(g21) < rt.u32Add(id, 44); - }, rt.drop); - const part49 = rt.iterToOption(it6.next()); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part48, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["filter_map ", args26[0]])); + rs.drop(it5); + const it6: rs.Iter = rs.iterSkipWhile(firsts(log, id, 40), (g21: Guard.Guard): boolean => { + return Guard.id(g21) < rs.u32Add(id, 44); + }, rs.drop); + const part49 = rs.iterToOption(it6.next()); const part50 = idOf(part49); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part50, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["skip_while ", args28[0]])); - rt.drop(it6); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part50, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["skip_while ", args28[0]])); + rs.drop(it6); } else if (_6 === 4) { - const it7: rt.Iter = firsts(log, id, 1); - const part35 = rt.iterNth(it7, 1, rt.drop); + const it7: rs.Iter = firsts(log, id, 1); + const part35 = rs.iterNth(it7, 1, rs.drop); const part36 = idOf(part35); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part36, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["nth ", args30[0]])); - rt.drop(it7); - const it8: rt.Iter = rt.iterSkip(firsts(log, id, 20), 1, rt.drop); - const part37 = rt.iterToOption(it8.next()); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["nth ", args30[0]])); + rs.drop(it7); + const it8: rs.Iter = rs.iterSkip(firsts(log, id, 20), 1, rs.drop); + const part37 = rs.iterToOption(it8.next()); const part38 = idOf(part37); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part38, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["skip ", args32[0]])); - rt.drop(it8); - const it9: rt.Iter = rt.iterStepBy(firsts(log, id, 40), 2, rt.drop); - const part39 = rt.iterToOption(it9.next()); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part38, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["skip ", args32[0]])); + rs.drop(it8); + const it9: rs.Iter = rs.iterStepBy(firsts(log, id, 40), 2, rs.drop); + const part39 = rs.iterToOption(it9.next()); const part40 = idOf(part39); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part40, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["step ", args34[0]])); - const part41 = rt.iterToOption(it9.next()); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part40, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["step ", args34[0]])); + const part41 = rs.iterToOption(it9.next()); const part42 = idOf(part41); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part42, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["step ", args36[0]])); - rt.drop(it9); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part42, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["step ", args36[0]])); + rs.drop(it9); } else if (_6 === 5) { - const it10: rt.Iter = firsts(log, id, 1); - const part21 = rt.iterToOption(it10.nextBack()); + const it10: rs.Iter = firsts(log, id, 1); + const part21 = rs.iterToOption(it10.nextBack()); const part22 = idOf(part21); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part22, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["back ", args38[0]])); - const part23 = rt.iterToOption(it10.next()); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part22, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["back ", args38[0]])); + const part23 = rs.iterToOption(it10.next()); const part24 = idOf(part23); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part24, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["front ", args40[0]])); - rt.drop(it10); - const it11: rt.Iter = firsts(log, id, 20); - const part25 = rt.iterRfind(it11, (g16: Guard.Guard): boolean => { - return Guard.id(g16) === rt.u32Add(id, 20); - }, rt.drop); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["front ", args40[0]])); + rs.drop(it10); + const it11: rs.Iter = firsts(log, id, 20); + const part25 = rs.iterRfind(it11, (g16: Guard.Guard): boolean => { + return Guard.id(g16) === rs.u32Add(id, 20); + }, rs.drop); const part26 = idOf(part25); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part26, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["rfind ", args42[0]])); - rt.drop(it11); - const it12: rt.Iter = rt.iterRev(firsts(log, id, 40)); - const part27 = rt.iterFind(it12, (g17: Guard.Guard): boolean => { - return Guard.id(g17) === rt.u32Add(id, 43); - }, rt.drop); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part26, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["rfind ", args42[0]])); + rs.drop(it11); + const it12: rs.Iter = rs.iterRev(firsts(log, id, 40)); + const part27 = rs.iterFind(it12, (g17: Guard.Guard): boolean => { + return Guard.id(g17) === rs.u32Add(id, 43); + }, rs.drop); const part28 = idOf(part27); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part28, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["rev find ", args44[0]])); - const part29 = rt.iterToOption(it12.next()); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["rev find ", args44[0]])); + const part29 = rs.iterToOption(it12.next()); const part30 = idOf(part29); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part30, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["rev next ", args46[0]])); - rt.drop(it12); - const it13: rt.Iter = rt.iterFilter(rt.iterRev(firsts(log, id, 60)), (g18: Guard.Guard): boolean => { - return Guard.id(g18) !== rt.u32Add(id, 65); - }, rt.drop); - const part31 = rt.iterToOption(it13.next()); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["rev next ", args46[0]])); + rs.drop(it12); + const it13: rs.Iter = rs.iterFilter(rs.iterRev(firsts(log, id, 60)), (g18: Guard.Guard): boolean => { + return Guard.id(g18) !== rs.u32Add(id, 65); + }, rs.drop); + const part31 = rs.iterToOption(it13.next()); const part32 = idOf(part31); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part32, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["rev filter ", args48[0]])); - rt.drop(it13); - const _439: rt.Vec> = nested(log, id, 80); - const it14: rt.Iter = rt.iterTake(rt.vecIntoIter(rt.vecSwapRemove(_439, 0), rt.drop), 1, rt.drop); - rt.dropVec(_439, lib_drop$Vec_model_Guard); - const part33 = rt.iterRfind(it14, (_28: Guard.Guard): boolean => { + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part32, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["rev filter ", args48[0]])); + rs.drop(it13); + const _439: rs.Vec> = nested(log, id, 80); + const it14: rs.Iter = rs.iterTake(rs.vecIntoIter(rs.vecSwapRemove(_439, 0), rs.drop), 1, rs.drop); + rs.dropVec(_439, lib_drop$Vec_model_Guard); + const part33 = rs.iterRfind(it14, (_28: Guard.Guard): boolean => { return true; - }, rt.drop); + }, rs.drop); const part34 = idOf(part33); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part34, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["take rfind ", args50[0]])); - rt.drop(it14); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part34, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["take rfind ", args50[0]])); + rs.drop(it14); } else if (_6 === 6) { - const it15: rt.Iter = rt.iterMap(firsts(log, id, 1), (g12: Guard.Guard): rt.u32 => { - const _012: rt.u32 = rt.u32Sub(Guard.id(g12), id); + const it15: rs.Iter = rs.iterMap(firsts(log, id, 1), (g12: Guard.Guard): rs.u32 => { + const _012: rs.u32 = rs.u32Sub(Guard.id(g12), id); g12[Symbol.dispose](); return _012; }); - const part16 = rt.iterFind(it15, (_2: rt.u32): boolean => { + const part16 = rs.iterFind(it15, (_2: rs.u32): boolean => { return _2 === 4; }); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part16, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["map find ", args52[0]])); - rt.drop(it15); - const it16: rt.Iter<[rt.usize, Guard.Guard]> = rt.iterEnumerate(firsts(log, id, 20)); - const part17 = option_map$14zg54s(rt.iterFind(it16, (_23: [rt.usize, Guard.Guard]): boolean => { + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map find ", args52[0]])); + rs.drop(it15); + const it16: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(firsts(log, id, 20)); + const part17 = option_map$1389p4b(rs.iterFind(it16, (_23: [rs.usize, Guard.Guard]): boolean => { return _23[0] === 1; - }, lib_drop$tuple2_usize_model_Guard), (_24: [rt.usize, Guard.Guard]): [rt.usize, rt.u32] => { - const i: rt.usize = _24[0]; + }, lib_drop$tuple2_usize_model_Guard), (_24: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { + const i: rs.usize = _24[0]; const g13: Guard.Guard = _24[1]; - const _015: [rt.usize, rt.u32] = [i, rt.u32Sub(Guard.id(g13), id)]; + const _015: [rs.usize, rs.u32] = [i, rs.u32Sub(Guard.id(g13), id)]; g13[Symbol.dispose](); return _015; }); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part17, f, (value: [rt.usize, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["enumerate ", args54[0]])); - rt.drop(it16); - const part18 = rt.iterFold(rt.iterTake(firsts(log, id, 40), 2, rt.drop), 0, (n3: rt.u32, g14: Guard.Guard): rt.u32 => { - const _016: rt.u32 = rt.u32Sub(rt.u32Add(n3, Guard.id(g14)), id); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["enumerate ", args54[0]])); + rs.drop(it16); + const part18 = rs.iterFold(rs.iterTake(firsts(log, id, 40), 2, rs.drop), 0, (n3: rs.u32, g14: Guard.Guard): rs.u32 => { + const _016: rs.u32 = rs.u32Sub(rs.u32Add(n3, Guard.id(g14)), id); g14[Symbol.dispose](); return _016; }, true); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part18, f)]; - Log.note(log, rt.fmtFormat(["take ", args56[0]])); - const it17: rt.Iter = rt.iterChain(firsts(log, id, 60), firsts(log, id, 80)); - const part19 = rt.iterFind(it17, (g15: Guard.Guard): boolean => { - return Guard.id(g15) === rt.u32Add(id, 81); - }, rt.drop); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part18, f)]; + Log.note(log, rs.fmtFormat(["take ", args56[0]])); + const it17: rs.Iter = rs.iterChain(firsts(log, id, 60), firsts(log, id, 80)); + const part19 = rs.iterFind(it17, (g15: Guard.Guard): boolean => { + return Guard.id(g15) === rs.u32Add(id, 81); + }, rs.drop); const part20 = idOf(part19); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part20, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["chain ", args58[0]])); - rt.drop(it17); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["chain ", args58[0]])); + rs.drop(it17); } else if (_6 === 7) { - const it18: rt.Iter = rt.iterFlatMap(rt.vecIntoIter(nested(log, id, 1), lib_drop$Vec_model_Guard), (v: rt.Vec): rt.Iter => { - return rt.iterTake(rt.vecIntoIter(v, rt.drop), 1, rt.drop); + const it18: rs.Iter = rs.iterFlatMap(rs.vecIntoIter(nested(log, id, 1), lib_drop$Vec_model_Guard), (v: rs.Vec): rs.Iter => { + return rs.iterTake(rs.vecIntoIter(v, rs.drop), 1, rs.drop); }, undefined, true); - const part9 = rt.iterFind(it18, (g9: Guard.Guard): boolean => { - return Guard.id(g9) === rt.u32Add(id, 4); - }, rt.drop); + const part9 = rs.iterFind(it18, (g9: Guard.Guard): boolean => { + return Guard.id(g9) === rs.u32Add(id, 4); + }, rs.drop); const part10 = idOf(part9); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part10, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["flat_map ", args60[0]])); - const part11 = rt.iterToOption(it18.next()); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flat_map ", args60[0]])); + const part11 = rs.iterToOption(it18.next()); const part12 = idOf(part11); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part12, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["flat_map ", args62[0]])); - rt.drop(it18); - const it19: rt.Peekable = rt.iterPeekable(firsts(log, id, 20), rt.drop); - const part13 = option_map$1raha9y(rt.peekablePeek(it19), (g10: Guard.Guard): rt.u32 => { - return rt.u32Sub(Guard.id(g10), id); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flat_map ", args62[0]])); + rs.drop(it18); + const it19: rs.Peekable = rs.iterPeekable(firsts(log, id, 20), rs.drop); + const part13 = option_map$06w9waf(rs.peekablePeek(it19), (g10: Guard.Guard): rs.u32 => { + return rs.u32Sub(Guard.id(g10), id); }); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part13, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek ", args64[0]])); - const part14 = rt.iterFind(it19, (g11: Guard.Guard): boolean => { - return Guard.id(g11) === rt.u32Add(id, 23); - }, rt.drop); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek ", args64[0]])); + const part14 = rs.iterFind(it19, (g11: Guard.Guard): boolean => { + return Guard.id(g11) === rs.u32Add(id, 23); + }, rs.drop); const part15 = idOf(part14); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part15, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek find ", args66[0]])); - rt.drop(it19); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek find ", args66[0]])); + rs.drop(it19); } else if (_6 === 8) { - const all: rt.Vec = rt.iterToVec(firsts(log, id, 1), "next", 8); + const all: rs.Vec = rs.iterToVec(firsts(log, id, 1), "next", 8); const part5 = all.items.length; - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part5, f)]; - Log.note(log, rt.fmtFormat(["collect ", args68[0]])); - rt.dropVec(all); - const part6 = rt.iterMaxByKey(firsts(log, id, 20), (g7: Guard.Guard): rt.u32 => { - return rt.u32Rem(Guard.id(g7), 3); - }, rt.lt, true, rt.drop); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; + Log.note(log, rs.fmtFormat(["collect ", args68[0]])); + rs.dropVec(all); + const part6 = rs.iterMaxByKey(firsts(log, id, 20), (g7: Guard.Guard): rs.u32 => { + return rs.u32Rem(Guard.id(g7), 3); + }, rs.lt, true, rs.drop); const part7 = idOf(part6); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part7, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["max ", args70[0]])); - const part8 = rt.iterSum(rt.iterMap(firsts(log, id, 40), (g8: Guard.Guard): rt.u32 => { - const _07: rt.u32 = rt.u32Sub(Guard.id(g8), id); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["max ", args70[0]])); + const part8 = rs.iterSum(rs.iterMap(firsts(log, id, 40), (g8: Guard.Guard): rs.u32 => { + const _07: rs.u32 = rs.u32Sub(Guard.id(g8), id); g8[Symbol.dispose](); return _07; - }), rt.u32Add, 0, true); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part8, f)]; - Log.note(log, rt.fmtFormat(["sum ", args72[0]])); + }), rs.u32Add, 0, true); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; + Log.note(log, rs.fmtFormat(["sum ", args72[0]])); } else { - const it20: rt.Iter = firsts(log, id, 1); - const part = rt.iterAny(it20, (g4: Guard.Guard): boolean => { - const _03: boolean = Guard.id(g4) === rt.u32Add(id, 1); + const it20: rs.Iter = firsts(log, id, 1); + const part = rs.iterAny(it20, (g4: Guard.Guard): boolean => { + const _03: boolean = Guard.id(g4) === rs.u32Add(id, 1); g4[Symbol.dispose](); return _03; }); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - Log.note(log, rt.fmtFormat(["any ", args74[0]])); - const part2 = rt.iterFold(it20, 0, (n: rt.u32, g5: Guard.Guard): rt.u32 => { - const _04: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Mul(n, 100), Guard.id(g5)), id); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + Log.note(log, rs.fmtFormat(["any ", args74[0]])); + const part2 = rs.iterFold(it20, 0, (n: rs.u32, g5: Guard.Guard): rs.u32 => { + const _04: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n, 100), Guard.id(g5)), id); g5[Symbol.dispose](); return _04; }, true); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["rest ", args76[0]])); - const it21: rt.Iter = firsts(log, id, 20); - const part3 = rt.iterAny(it21, (g6: Guard.Guard): boolean => { - const _05: boolean = Guard.id(g6) === rt.u32Add(id, 23); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["rest ", args76[0]])); + const it21: rs.Iter = firsts(log, id, 20); + const part3 = rs.iterAny(it21, (g6: Guard.Guard): boolean => { + const _05: boolean = Guard.id(g6) === rs.u32Add(id, 23); g6[Symbol.dispose](); return _05; }); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - Log.note(log, rt.fmtFormat(["any ", args78[0]])); - const part4 = rt.ownedCount(it21, rt.drop); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; - Log.note(log, rt.fmtFormat(["count ", args80[0]])); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + Log.note(log, rs.fmtFormat(["any ", args78[0]])); + const part4 = rs.ownedCount(it21, rs.drop); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; + Log.note(log, rs.fmtFormat(["count ", args80[0]])); } } diff --git a/ts/fixtures/task/expected/drops/folds.Pile.ts b/ts/fixtures/task/expected/drops/folds.Pile.ts index 5edc3c97d..ef293336e 100644 --- a/ts/fixtures/task/expected/drops/folds.Pile.ts +++ b/ts/fixtures/task/expected/drops/folds.Pile.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { then$1xpp3sz } from "../core/bool.ts"; import * as Log from "../log.Log.ts"; import type * as Guard from "../model.Guard.ts"; @@ -11,64 +11,64 @@ import type * as Guard from "../model.Guard.ts"; * and drop their closure before they note they folded, and the rest drop with it. */ export class Pile { - held: rt.Vec; + held: rs.Vec; log: Log.Log; - constructor(held: rt.Vec, log: Log.Log) { + constructor(held: rs.Vec, log: Log.Log) { this.held = held; this.log = log; } [Symbol.dispose](): void { - rt.dropVec(this.held); + rs.dropVec(this.held); this.log[Symbol.dispose](); } } -export function next$iter_Iterator(self: Pile): Guard.Guard | rt.Done { - return rt.iterFromOption(rt.vecPop(self.held)); +export function next$iter_Iterator(self: Pile): Guard.Guard | rs.Done { + return rs.iterFromOption(rs.vecPop(self.held)); } -export function sizeHint$iter_Iterator(self: Pile): [rt.usize, rt.usize | undefined] { - return [self.held.items.length, self.held.items.length] as [rt.usize, rt.usize | undefined]; +export function sizeHint$iter_Iterator(self: Pile): [rs.usize, rs.usize | undefined] { + return [self.held.items.length, self.held.items.length] as [rs.usize, rs.usize | undefined]; } -export function nth$iter_Iterator(self: Pile, n: rt.usize): Guard.Guard | undefined { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n, f)]; - const _5: string = rt.fmtFormat(["pile nth ", args2[0]]); +export function nth$iter_Iterator(self: Pile, n: rs.usize): Guard.Guard | undefined { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; + const _5: string = rs.fmtFormat(["pile nth ", args2[0]]); Log.note(self.log, _5); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = n; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = n; while (iterStart++ < iterEnd) { - const _21: Guard.Guard | undefined = rt.vecPop(self.held); + const _21: Guard.Guard | undefined = rs.vecPop(self.held); if (_21 !== undefined) { _21[Symbol.dispose](); } else { return undefined; } } - return rt.vecPop(self.held); + return rs.vecPop(self.held); } -export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rt.u32 | undefined, f: (a0: rt.u32 | undefined, a1: Guard.Guard) => rt.u32 | undefined): rt.u32 | undefined { +export function fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { Log.note(self.log, "pile fold"); - let acc: rt.u32 | undefined = init; + let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { - const part = rt.optionUnwrap(rt.vecPop(self.held)); + const part = rs.optionUnwrap(rs.vecPop(self.held)); acc = f(acc, part); } - rt.drop(f); + rs.drop(f); Log.note(self.log, "pile folded"); self[Symbol.dispose](); return acc; } -export function count$iter_Iterator(self: Pile): rt.usize { +export function count$iter_Iterator(self: Pile): rs.usize { const part = self.held.items.length; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; - const _4: string = rt.fmtFormat(["pile count ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; + const _4: string = rs.fmtFormat(["pile count ", args2[0]]); Log.note(self.log, _4); - const _0: rt.usize = self.held.items.length; + const _0: rs.usize = self.held.items.length; self[Symbol.dispose](); return _0; } @@ -76,7 +76,7 @@ export function count$iter_Iterator(self: Pile): rt.usize { export function last$iter_Iterator(self: Pile): Guard.Guard | undefined { Log.note(self.log, "pile last"); const _0: Guard.Guard | undefined = then$1xpp3sz(!(self.held.items.length === 0), (): Guard.Guard => { - return rt.vecRemove(self.held, 0); + return rs.vecRemove(self.held, 0); }); self[Symbol.dispose](); return _0; @@ -84,16 +84,16 @@ export function last$iter_Iterator(self: Pile): Guard.Guard | undefined { export function nextBack$iter_DoubleEndedIterator(self: Pile): Guard.Guard | undefined { return then$1xpp3sz(!(self.held.items.length === 0), (): Guard.Guard => { - return rt.vecRemove(self.held, 0); + return rs.vecRemove(self.held, 0); }); } -export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rt.usize): Guard.Guard | undefined { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n, f)]; - const _5: string = rt.fmtFormat(["pile nth_back ", args2[0]]); +export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rs.usize): Guard.Guard | undefined { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f)]; + const _5: string = rs.fmtFormat(["pile nth_back ", args2[0]]); Log.note(self.log, _5); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = n; + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = n; while (iterStart++ < iterEnd) { const _21: Guard.Guard | undefined = nextBack$iter_DoubleEndedIterator(self); if (_21 !== undefined) { @@ -105,14 +105,14 @@ export function nthBack$iter_DoubleEndedIterator(self: Pile, n: rt.usize): Guard return nextBack$iter_DoubleEndedIterator(self); } -export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rt.u32 | undefined, f: (a0: rt.u32 | undefined, a1: Guard.Guard) => rt.u32 | undefined): rt.u32 | undefined { +export function rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32(self: Pile, init: rs.u32 | undefined, f: (a0: rs.u32 | undefined, a1: Guard.Guard) => rs.u32 | undefined): rs.u32 | undefined { Log.note(self.log, "pile rfold"); - let acc: rt.u32 | undefined = init; + let acc: rs.u32 | undefined = init; while (self.held.items.length > 1) { - const part = rt.vecRemove(self.held, 0); + const part = rs.vecRemove(self.held, 0); acc = f(acc, part); } - rt.drop(f); + rs.drop(f); Log.note(self.log, "pile rfolded"); self[Symbol.dispose](); return acc; diff --git a/ts/fixtures/task/expected/drops/folds.ts b/ts/fixtures/task/expected/drops/folds.ts index 321f9e6cc..c73aa0931 100644 --- a/ts/fixtures/task/expected/drops/folds.ts +++ b/ts/fixtures/task/expected/drops/folds.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_tuple2_tuple2_model_Guard_model_Guard_model_Guard as lib_drop$Option_tuple2_tuple2_model_Guard_model_Guard_model_Guard, drop$tuple2_i32_model_Guard as lib_drop$tuple2_i32_model_Guard, drop$tuple2_model_Guard_i32 as lib_drop$tuple2_model_Guard_i32, drop$tuple2_model_Guard_model_Guard as lib_drop$tuple2_model_Guard_model_Guard, drop$tuple2_model_Guard_u64 as lib_drop$tuple2_model_Guard_u64, drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard as lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard, drop$tuple2_usize_model_Guard as lib_drop$tuple2_usize_model_Guard } from "../lib.ts"; -import { thenSome$0zvoczk, thenSome$1af3oea, then$06wuxll, then$1xpp3sz, then$0ea5h05 } from "../core/bool.ts"; -import { map$0ccnsmq as option_map$0ccnsmq, map$1raha9y as option_map$1raha9y, map$0lq7mno as option_map$0lq7mno, map$01pvlgn as option_map$01pvlgn, map$14zg54s as option_map$14zg54s, mapOr$01ozsk3 as option_mapOr$01ozsk3 } from "../core/option.ts"; -import { mapErr$0nvqjog as result_mapErr$0nvqjog } from "../core/result.ts"; +import { thenSome$0zvoczk, thenSome$1bahm2u, then$0frk932, then$1xpp3sz, then$0apfzgv } from "../core/bool.ts"; +import { map$1x5kkz1 as option_map$1x5kkz1, map$06w9waf as option_map$06w9waf, map$02u0dmi as option_map$02u0dmi, map$0j32j8c as option_map$0j32j8c, map$1389p4b as option_map$1389p4b, mapOr$1re20rq as option_mapOr$1re20rq } from "../core/option.ts"; +import { mapErr$18fct1o as result_mapErr$18fct1o } from "../core/result.ts"; import * as Pile from "../drops/folds.Pile.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 42`. Items are guards 1 to 7; what closures own, 10 and up. */ -export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function folded(log: Log.Log, id: rs.u32, arg: rs.u8): void { let f!: Guard.Guard; let _1090: boolean = false; let _1089: boolean = false; - const guard: (a0: rt.u32) => Guard.Guard = (n24: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n24), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n24: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n24), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _10: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; _1090 = true; @@ -26,52 +26,52 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { _1089 = true; const d: Guard.Guard = _10[1]; b0: { - const _17: rt.u8 = rt.u8Rem(arg, 42); + const _17: rs.u8 = rs.u8Rem(arg, 42); if (_17 === 0) { - const _23: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _23: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured65 = c; - const n: rt.usize = rt.ownedCount(rt.iterMap(_23, rt.closure((g83: Guard.Guard): rt.u32 => { - const _090: rt.u32 = rt.u32Add(Guard.id(g83), Guard.id(captured65)); + const n: rs.usize = rs.ownedCount(rs.iterMap(_23, rs.closure((g83: Guard.Guard): rs.u32 => { + const _090: rs.u32 = rs.u32Add(Guard.id(g83), Guard.id(captured65)); g83[Symbol.dispose](); return _090; }, (): void => { captured65[Symbol.dispose](); }))); - const _30: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + const _30: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _1089 = false; const captured66 = id; const captured67 = d; - const sum: rt.u32 = rt.iterSum(rt.iterMap(_30, rt.closure((g84: Guard.Guard): rt.u32 => { - const _091: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g84), captured66), Guard.id(captured67)), captured66); + const sum: rs.u32 = rs.iterSum(rs.iterMap(_30, rs.closure((g84: Guard.Guard): rs.u32 => { + const _091: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g84), captured66), Guard.id(captured67)), captured66); g84[Symbol.dispose](); return _091; }, (): void => { captured67[Symbol.dispose](); - })), rt.u32Add, 0, true); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n, f), (f: rt.Formatter) => rt.u32Display(sum, f)]; - Log.note(log, rt.fmtFormat(["count ", args2[0], " ", args2[1]])); + })), rs.u32Add, 0, true); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat(["count ", args2[0], " ", args2[1]])); } else if (_17 === 1) { - const _49: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _49: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; const captured64 = c; - const _62: rt.u32 | undefined = option_map$1raha9y(rt.iterFold(rt.iterFilter(_49, rt.closure((g81: Guard.Guard): boolean => { - return rt.u32Rem(Guard.id(g81), 2) === rt.u32Rem(Guard.id(captured64), 2); + const _62: rs.u32 | undefined = option_map$06w9waf(rs.iterFold(rs.iterFilter(_49, rs.closure((g81: Guard.Guard): boolean => { + return rs.u32Rem(Guard.id(g81), 2) === rs.u32Rem(Guard.id(captured64), 2); }, (): void => { captured64[Symbol.dispose](); - }), rt.drop), undefined as Guard.Guard | undefined, (kept4: Guard.Guard | undefined, g82: Guard.Guard): Guard.Guard | undefined => { + }), rs.drop), undefined as Guard.Guard | undefined, (kept4: Guard.Guard | undefined, g82: Guard.Guard): Guard.Guard | undefined => { let _087!: Guard.Guard | undefined; let _3110: boolean = false; let _304: boolean = false; _3110 = true; _304 = true; - const _1020: rt.u32 = Guard.id(g82); - const _1317: rt.u32 | undefined = option_map$1raha9y(kept4, (k2: Guard.Guard): rt.u32 => { + const _1020: rs.u32 = Guard.id(g82); + const _1317: rs.u32 | undefined = option_map$06w9waf(kept4, (k2: Guard.Guard): rs.u32 => { return Guard.id(k2); }); - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1020, f), (f: rt.Formatter) => rt.fmtOption(_1317, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["fold ", args110[0], " ", args110[1]])); - if (!(rt.u32Rem(Guard.id(g82), 4) === 0)) { + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1020, f), (f: rs.Formatter) => rs.fmtOption(_1317, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["fold ", args110[0], " ", args110[1]])); + if (!(rs.u32Rem(Guard.id(g82), 4) === 0)) { _304 = false; _087 = g82; } else { @@ -82,731 +82,731 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { g82[Symbol.dispose](); } if (_3110) { - rt.drop(kept4); + rs.drop(kept4); return _087; } return _087; - }, true), (k3: Guard.Guard): rt.u32 => { - const _089: rt.u32 = Guard.id(k3); + }, true), (k3: Guard.Guard): rs.u32 => { + const _089: rs.u32 = Guard.id(k3); k3[Symbol.dispose](); return _089; }); - const _64: rt.u32 = Guard.id(d); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_62, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_64, f)]; - Log.note(log, rt.fmtFormat(["fold ", args4[0], " ", args4[1]])); + const _64: rs.u32 = Guard.id(d); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_62, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_64, f)]; + Log.note(log, rs.fmtFormat(["fold ", args4[0], " ", args4[1]])); } else if (_17 === 2) { - const _73: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _73: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; const captured63 = c; - rt.iterForEach(rt.iterFilterMap(_73, rt.closure((g79: Guard.Guard): Guard.Guard | undefined => { - return thenSome$0zvoczk(rt.u32Rem(Guard.id(g79), 3) !== rt.u32Rem(Guard.id(captured63), 3), g79); + rs.iterForEach(rs.iterFilterMap(_73, rs.closure((g79: Guard.Guard): Guard.Guard | undefined => { + return thenSome$0zvoczk(rs.u32Rem(Guard.id(g79), 3) !== rs.u32Rem(Guard.id(captured63), 3), g79); }, (): void => { captured63[Symbol.dispose](); })), (g80: Guard.Guard): undefined => { const part13 = Guard.id(g80); - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part13, f)]; - Log.note(log, rt.fmtFormat(["each ", args108[0]])); + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; + Log.note(log, rs.fmtFormat(["each ", args108[0]])); g80[Symbol.dispose](); }, true); const part14 = Guard.id(d); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part14, f)]; - Log.note(log, rt.fmtFormat(["each ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; + Log.note(log, rs.fmtFormat(["each ", args6[0]])); } else if (_17 === 3) { - const _93: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _93: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured62 = c; - const _104: rt.u32 | undefined = option_map$1raha9y(rt.ownedLast(rt.iterInspect(_93, rt.closure((g77: Guard.Guard): undefined => { - const _982: rt.u32 = Guard.id(g77); - const _1175: rt.u32 = Guard.id(captured62); - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_982, f), (f: rt.Formatter) => rt.u32Display(_1175, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args106[0], " ", args106[1]])); + const _104: rs.u32 | undefined = option_map$06w9waf(rs.ownedLast(rs.iterInspect(_93, rs.closure((g77: Guard.Guard): undefined => { + const _982: rs.u32 = Guard.id(g77); + const _1175: rs.u32 = Guard.id(captured62); + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_982, f), (f: rs.Formatter) => rs.u32Display(_1175, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args106[0], " ", args106[1]])); }, (): void => { captured62[Symbol.dispose](); - })), rt.drop), (g78: Guard.Guard): rt.u32 => { - const _084: rt.u32 = Guard.id(g78); + })), rs.drop), (g78: Guard.Guard): rs.u32 => { + const _084: rs.u32 = Guard.id(g78); g78[Symbol.dispose](); return _084; }); - const _106: rt.u32 = Guard.id(d); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_104, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_106, f)]; - Log.note(log, rt.fmtFormat(["last ", args8[0], " ", args8[1]])); + const _106: rs.u32 = Guard.id(d); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_104, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_106, f)]; + Log.note(log, rs.fmtFormat(["last ", args8[0], " ", args8[1]])); } else if (_17 === 4) { - const _115: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _115: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _1090 = false; const captured61 = c; - const best: Guard.Guard | undefined = rt.iterMaxByKey(rt.iterMap(_115, rt.closure((g72: Guard.Guard): Guard.Guard => { - const _978: rt.u32 = Guard.id(g72); - const _1226: rt.u32 = Guard.id(captured61); - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_978, f), (f: rt.Formatter) => rt.u32Display(_1226, f)]; - Log.note(log, rt.fmtFormat(["map ", args104[0], " ", args104[1]])); + const best: Guard.Guard | undefined = rs.iterMaxByKey(rs.iterMap(_115, rs.closure((g72: Guard.Guard): Guard.Guard => { + const _978: rs.u32 = Guard.id(g72); + const _1226: rs.u32 = Guard.id(captured61); + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_978, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; + Log.note(log, rs.fmtFormat(["map ", args104[0], " ", args104[1]])); return g72; }, (): void => { captured61[Symbol.dispose](); - })), (g73: Guard.Guard): rt.u32 => { - return rt.u32Rem(Guard.id(g73), 3); - }, rt.lt, true, rt.drop); - const least: Guard.Guard | undefined = rt.iterMinByKey(rt.vecIntoIter(guards(6, 8), rt.drop), (g74: Guard.Guard): rt.u32 => { - return rt.u32Add(Guard.id(g74), Guard.id(d)); - }, rt.lt, true, rt.drop); - const _133: rt.u32 | undefined = option_map$1raha9y(best, (g75: Guard.Guard): rt.u32 => { - const _082: rt.u32 = Guard.id(g75); + })), (g73: Guard.Guard): rs.u32 => { + return rs.u32Rem(Guard.id(g73), 3); + }, rs.lt, true, rs.drop); + const least: Guard.Guard | undefined = rs.iterMinByKey(rs.vecIntoIter(guards(6, 8), rs.drop), (g74: Guard.Guard): rs.u32 => { + return rs.u32Add(Guard.id(g74), Guard.id(d)); + }, rs.lt, true, rs.drop); + const _133: rs.u32 | undefined = option_map$06w9waf(best, (g75: Guard.Guard): rs.u32 => { + const _082: rs.u32 = Guard.id(g75); g75[Symbol.dispose](); return _082; }); - const _135: rt.u32 | undefined = option_map$1raha9y(least, (g76: Guard.Guard): rt.u32 => { - const _083: rt.u32 = Guard.id(g76); + const _135: rs.u32 | undefined = option_map$06w9waf(least, (g76: Guard.Guard): rs.u32 => { + const _083: rs.u32 = Guard.id(g76); g76[Symbol.dispose](); return _083; }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_133, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_135, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["best ", args10[0], " ", args10[1]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_133, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_135, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["best ", args10[0], " ", args10[1]])); } else if (_17 === 5) { - const _143: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _143: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured58 = c; - const max: rt.u32 | undefined = rt.iterMax(rt.iterMap(_143, rt.closure((g70: Guard.Guard): rt.u32 => { - const _077: rt.u32 = rt.u32Rem(Guard.id(g70), Guard.id(captured58)); + const max: rs.u32 | undefined = rs.iterMax(rs.iterMap(_143, rs.closure((g70: Guard.Guard): rs.u32 => { + const _077: rs.u32 = rs.u32Rem(Guard.id(g70), Guard.id(captured58)); g70[Symbol.dispose](); return _077; }, (): void => { captured58[Symbol.dispose](); - })), rt.lt, true); - const _150: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + })), rs.lt, true); + const _150: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured59 = id; const captured60 = d; - const product: rt.u32 = rt.iterProduct(rt.iterMap(_150, rt.closure((g71: Guard.Guard): rt.u32 => { - const _078: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g71), captured59), Guard.id(captured60)), Guard.id(captured60)); + const product: rs.u32 = rs.iterProduct(rs.iterMap(_150, rs.closure((g71: Guard.Guard): rs.u32 => { + const _078: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g71), captured59), Guard.id(captured60)), Guard.id(captured60)); g71[Symbol.dispose](); return _078; }, (): void => { captured60[Symbol.dispose](); - })), rt.u32Mul, 1, true); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(max, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(product, f)]; - Log.note(log, rt.fmtFormat(["max ", args12[0], " ", args12[1]])); + })), rs.u32Mul, 1, true); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(max, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(product, f)]; + Log.note(log, rs.fmtFormat(["max ", args12[0], " ", args12[1]])); } else if (_17 === 6) { - const _169: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _169: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured56 = c; - const same: rt.Vec = rt.iterToVec(rt.iterMap(_169, rt.closure((g68: Guard.Guard): Guard.Guard => { - const _976: rt.u32 = Guard.id(g68); - const _1224: rt.u32 = Guard.id(captured56); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_976, f), (f: rt.Formatter) => rt.u32Display(_1224, f)]; - Log.note(log, rt.fmtFormat(["map ", args102[0], " ", args102[1]])); + const same: rs.Vec = rs.iterToVec(rs.iterMap(_169, rs.closure((g68: Guard.Guard): Guard.Guard => { + const _976: rs.u32 = Guard.id(g68); + const _1224: rs.u32 = Guard.id(captured56); + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_976, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; + Log.note(log, rs.fmtFormat(["map ", args102[0], " ", args102[1]])); return g68; }, (): void => { captured56[Symbol.dispose](); })), "next", 8, true, 8); - const _176: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + const _176: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured57 = d; - const wider: rt.Vec<[Guard.Guard, rt.u64]> = rt.iterToVec(rt.iterMap(_176, rt.closure((g69: Guard.Guard): [Guard.Guard, rt.u64] => { - return [g69, Guard.id(captured57) as rt.u64] as [Guard.Guard, rt.u64]; + const wider: rs.Vec<[Guard.Guard, rs.u64]> = rs.iterToVec(rs.iterMap(_176, rs.closure((g69: Guard.Guard): [Guard.Guard, rs.u64] => { + return [g69, Guard.id(captured57) as rs.u64] as [Guard.Guard, rs.u64]; }, (): void => { captured57[Symbol.dispose](); })), "fold", 16, true); - const _187: rt.usize = same.items.length; - const _190: rt.usize = wider.items.length; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_187, f), (f: rt.Formatter) => rt.usizeDisplay(_190, f)]; - Log.note(log, rt.fmtFormat(["collected ", args14[0], " ", args14[1]])); - rt.dropVec(wider, lib_drop$tuple2_model_Guard_u64); - rt.dropVec(same); + const _187: rs.usize = same.items.length; + const _190: rs.usize = wider.items.length; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_187, f), (f: rs.Formatter) => rs.usizeDisplay(_190, f)]; + Log.note(log, rs.fmtFormat(["collected ", args14[0], " ", args14[1]])); + rs.dropVec(wider, lib_drop$tuple2_model_Guard_u64); + rs.dropVec(same); } else if (_17 === 7) { - const _199: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _199: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured54 = c; - const queue: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(_199, rt.closure((g66: Guard.Guard): Guard.Guard => { - const _974: rt.u32 = Guard.id(g66); - const _1223: rt.u32 = Guard.id(captured54); - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_974, f), (f: rt.Formatter) => rt.u32Display(_1223, f)]; - Log.note(log, rt.fmtFormat(["map ", args100[0], " ", args100[1]])); + const queue: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(_199, rs.closure((g66: Guard.Guard): Guard.Guard => { + const _974: rs.u32 = Guard.id(g66); + const _1223: rs.u32 = Guard.id(captured54); + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_974, f), (f: rs.Formatter) => rs.u32Display(_1223, f)]; + Log.note(log, rs.fmtFormat(["map ", args100[0], " ", args100[1]])); return g66; }, (): void => { captured54[Symbol.dispose](); - })), "next", 8, true, 8), 8) as rt.VecDeque; - const _206: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + })), "next", 8, true, 8), 8) as rs.VecDeque; + const _206: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured55 = d; - const _205: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterMap(_206, rt.closure((g67: Guard.Guard): [rt.u32, Guard.Guard] => { - return [rt.u32Add(Guard.id(g67), Guard.id(captured55)), g67] as [rt.u32, Guard.Guard]; + const _205: rs.Iter<[rs.u32, Guard.Guard]> = rs.iterMap(_206, rs.closure((g67: Guard.Guard): [rs.u32, Guard.Guard] => { + return [rs.u32Add(Guard.id(g67), Guard.id(captured55)), g67] as [rs.u32, Guard.Guard]; }, (): void => { captured55[Symbol.dispose](); })); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToVec(_205, "fold", 12, true).items, 12, true, undefined, undefined, rt.drop); - const _217: rt.usize = queue.n; - const _220: rt.usize = rt.btreeLen(tree); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_217, f), (f: rt.Formatter) => rt.usizeDisplay(_220, f)]; - Log.note(log, rt.fmtFormat(["collected ", args16[0], " ", args16[1]])); - rt.btreeDrop(tree, undefined, rt.drop); - rt.dequeDrop(queue, rt.drop); + const tree: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_205, "fold", 12, true).items, 12, true, undefined, undefined, rs.drop); + const _217: rs.usize = queue.n; + const _220: rs.usize = rs.btreeLen(tree); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_217, f), (f: rs.Formatter) => rs.usizeDisplay(_220, f)]; + Log.note(log, rs.fmtFormat(["collected ", args16[0], " ", args16[1]])); + rs.btreeDrop(tree, undefined, rs.drop); + rs.dequeDrop(queue, rs.drop); } else if (_17 === 8) { - const v: rt.Vec = guards(1, 2); - const _233: rt.Iter = rt.vecIntoIter(guards(2, 4), rt.drop); + const v: rs.Vec = guards(1, 2); + const _233: rs.Iter = rs.vecIntoIter(guards(2, 4), rs.drop); _1090 = false; const captured52 = c; - const _232: rt.Iter = rt.iterMap(_233, rt.closure((g64: Guard.Guard): Guard.Guard => { - const _973: rt.u32 = Guard.id(g64); - const _1222: rt.u32 = Guard.id(captured52); - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_973, f), (f: rt.Formatter) => rt.u32Display(_1222, f)]; - Log.note(log, rt.fmtFormat(["map ", args98[0], " ", args98[1]])); + const _232: rs.Iter = rs.iterMap(_233, rs.closure((g64: Guard.Guard): Guard.Guard => { + const _973: rs.u32 = Guard.id(g64); + const _1222: rs.u32 = Guard.id(captured52); + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_973, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; + Log.note(log, rs.fmtFormat(["map ", args98[0], " ", args98[1]])); return g64; }, (): void => { captured52[Symbol.dispose](); })); - rt.iterExtend(v, _232, "fold", 8, true); - const tree2: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const _242: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + rs.iterExtend(v, _232, "fold", 8, true); + const tree2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const _242: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured53 = d; - const _241: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterMap(_242, rt.closure((g65: Guard.Guard): [rt.u32, Guard.Guard] => { - return [rt.u32Add(Guard.id(g65), Guard.id(captured53)), g65] as [rt.u32, Guard.Guard]; + const _241: rs.Iter<[rs.u32, Guard.Guard]> = rs.iterMap(_242, rs.closure((g65: Guard.Guard): [rs.u32, Guard.Guard] => { + return [rs.u32Add(Guard.id(g65), Guard.id(captured53)), g65] as [rs.u32, Guard.Guard]; }, (): void => { captured53[Symbol.dispose](); })); - rt.btreeExtend(tree2, _241, false, undefined, rt.drop, "fold"); - const _253: rt.usize = v.items.length; - const _256: rt.usize = rt.btreeLen(tree2); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_253, f), (f: rt.Formatter) => rt.usizeDisplay(_256, f)]; - Log.note(log, rt.fmtFormat(["extended ", args18[0], " ", args18[1]])); - rt.btreeDrop(tree2, undefined, rt.drop); - rt.dropVec(v); + rs.btreeExtend(tree2, _241, false, undefined, rs.drop, "fold"); + const _253: rs.usize = v.items.length; + const _256: rs.usize = rs.btreeLen(tree2); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_253, f), (f: rs.Formatter) => rs.usizeDisplay(_256, f)]; + Log.note(log, rs.fmtFormat(["extended ", args18[0], " ", args18[1]])); + rs.btreeDrop(tree2, undefined, rs.drop); + rs.dropVec(v); } else if (_17 === 9) { - const _266: rt.Iter = rt.iterSlice([1, 2, 3, 4, 5]); + const _266: rs.Iter = rs.iterSlice([1, 2, 3, 4, 5]); _1090 = false; const captured50 = c; - const _265: rt.Iter = rt.iterMap(_266, rt.closure((_218: rt.u32): rt.u32 => { - return rt.u32Add(_218, Guard.id(captured50)); + const _265: rs.Iter = rs.iterMap(_266, rs.closure((_218: rs.u32): rs.u32 => { + return rs.u32Add(_218, Guard.id(captured50)); }, (): void => { captured50[Symbol.dispose](); })); _1089 = false; const captured51 = d; - const part12 = rt.ownedCount(rt.iterFilter(_265, rt.closure((n39: rt.u32): boolean => { - return rt.u32Rem(n39, 2) === rt.u32Rem(Guard.id(captured51), 2); + const part12 = rs.ownedCount(rs.iterFilter(_265, rs.closure((n39: rs.u32): boolean => { + return rs.u32Rem(n39, 2) === rs.u32Rem(Guard.id(captured51), 2); }, (): void => { captured51[Symbol.dispose](); }))); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part12, f)]; - Log.note(log, rt.fmtFormat(["count ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part12, f)]; + Log.note(log, rs.fmtFormat(["count ", args20[0]])); } else if (_17 === 10) { - const _284: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _284: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured45 = c; - const _283: rt.Iter = rt.iterFilter(_284, rt.closure((g60: Guard.Guard): boolean => { + const _283: rs.Iter = rs.iterFilter(_284, rs.closure((g60: Guard.Guard): boolean => { return Guard.id(g60) !== Guard.id(captured45); }, (): void => { captured45[Symbol.dispose](); - }), rt.drop); + }), rs.drop); _1089 = false; const captured46 = id; const captured47 = d; - const n3: rt.u32 = rt.iterSum(rt.iterMap(_283, rt.closure((g61: Guard.Guard): rt.u32 => { - const _067: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g61), captured46), Guard.id(captured47)), Guard.id(captured47)); + const n3: rs.u32 = rs.iterSum(rs.iterMap(_283, rs.closure((g61: Guard.Guard): rs.u32 => { + const _067: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g61), captured46), Guard.id(captured47)), Guard.id(captured47)); g61[Symbol.dispose](); return _067; }, (): void => { captured47[Symbol.dispose](); - })), rt.u32Add, 0, true); + })), rs.u32Add, 0, true); const _292: [Guard.Guard, Guard.Guard] = [guard(12), guard(13)]; const e: Guard.Guard = _292[0]; f = _292[1]; - const _302: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + const _302: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); const captured48 = e; - const _301: rt.Iter = rt.iterFilterMap(_302, rt.closure((g62: Guard.Guard): Guard.Guard | undefined => { + const _301: rs.Iter = rs.iterFilterMap(_302, rs.closure((g62: Guard.Guard): Guard.Guard | undefined => { return thenSome$0zvoczk(Guard.id(g62) !== Guard.id(captured48), g62); }, (): void => { captured48[Symbol.dispose](); })); const captured49 = f; - const m: rt.usize = rt.ownedCount(rt.iterInspect(_301, rt.closure((g63: Guard.Guard): undefined => { - const _835: rt.u32 = Guard.id(g63); - const _1019: rt.u32 = Guard.id(captured49); - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_835, f), (f: rt.Formatter) => rt.u32Display(_1019, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args96[0], " ", args96[1]])); + const m: rs.usize = rs.ownedCount(rs.iterInspect(_301, rs.closure((g63: Guard.Guard): undefined => { + const _835: rs.u32 = Guard.id(g63); + const _1019: rs.u32 = Guard.id(captured49); + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_835, f), (f: rs.Formatter) => rs.u32Display(_1019, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args96[0], " ", args96[1]])); }, (): void => { captured49[Symbol.dispose](); - })), rt.drop); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n3, f), (f: rt.Formatter) => rt.usizeDisplay(m, f)]; - Log.note(log, rt.fmtFormat(["two ", args22[0], " ", args22[1]])); + })), rs.drop); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["two ", args22[0], " ", args22[1]])); } else if (_17 === 11) { - const _322: rt.Iter = rt.iterChain(rt.vecIntoIter(guards(1, 3), rt.drop), rt.vecIntoIter(guards(3, 5), rt.drop)); + const _322: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 5), rs.drop)); _1090 = false; const captured42 = id; const captured43 = c; - const n4: rt.u32 = rt.iterSum(rt.iterMap(_322, rt.closure((g58: Guard.Guard): rt.u32 => { - const _064: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g58), captured42), Guard.id(captured43)), captured42); + const n4: rs.u32 = rs.iterSum(rs.iterMap(_322, rs.closure((g58: Guard.Guard): rs.u32 => { + const _064: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g58), captured42), Guard.id(captured43)), captured42); g58[Symbol.dispose](); return _064; }, (): void => { captured43[Symbol.dispose](); - })), rt.u32Add, 0, true); - const _334: rt.Iter = rt.vecIntoIter(guards(5, 7), rt.drop); + })), rs.u32Add, 0, true); + const _334: rs.Iter = rs.vecIntoIter(guards(5, 7), rs.drop); _1089 = false; const captured44 = d; - const m2: rt.usize = rt.ownedCount(rt.iterChain(rt.iterMap(_334, rt.closure((g59: Guard.Guard): rt.u32 => { - const _065: rt.u32 = rt.u32Add(Guard.id(g59), Guard.id(captured44)); + const m2: rs.usize = rs.ownedCount(rs.iterChain(rs.iterMap(_334, rs.closure((g59: Guard.Guard): rs.u32 => { + const _065: rs.u32 = rs.u32Add(Guard.id(g59), Guard.id(captured44)); g59[Symbol.dispose](); return _065; }, (): void => { captured44[Symbol.dispose](); - })), rt.iterSlice([1, 2]))); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n4, f), (f: rt.Formatter) => rt.usizeDisplay(m2, f)]; - Log.note(log, rt.fmtFormat(["chain ", args24[0], " ", args24[1]])); + })), rs.iterSlice([1, 2]))); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; + Log.note(log, rs.fmtFormat(["chain ", args24[0], " ", args24[1]])); } else if (_17 === 12) { - const _354: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); - const _359: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + const _354: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); + const _359: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1090 = false; const captured41 = c; - const n5: rt.u32 = rt.iterFold(rt.iterChain(_354, rt.iterFilter(_359, rt.closure((g55: Guard.Guard): boolean => { + const n5: rs.u32 = rs.iterFold(rs.iterChain(_354, rs.iterFilter(_359, rs.closure((g55: Guard.Guard): boolean => { return Guard.id(g55) !== Guard.id(captured41); }, (): void => { captured41[Symbol.dispose](); - }), rt.drop)), 0, (n37: rt.u32, g56: Guard.Guard): rt.u32 => { - const _062: rt.u32 = rt.u32Sub(rt.u32Add(n37, Guard.id(g56)), id); + }), rs.drop)), 0, (n37: rs.u32, g56: Guard.Guard): rs.u32 => { + const _062: rs.u32 = rs.u32Sub(rs.u32Add(n37, Guard.id(g56)), id); g56[Symbol.dispose](); return _062; }, true); - const _379: rt.u32 | undefined = option_map$1raha9y(rt.ownedLast(rt.iterChain(rt.vecIntoIter(guards(7, 8), rt.drop), rt.vecIntoIter(new rt.Vec(), rt.drop)), rt.drop), (g57: Guard.Guard): rt.u32 => { - const _063: rt.u32 = Guard.id(g57); + const _379: rs.u32 | undefined = option_map$06w9waf(rs.ownedLast(rs.iterChain(rs.vecIntoIter(guards(7, 8), rs.drop), rs.vecIntoIter(new rs.Vec(), rs.drop)), rs.drop), (g57: Guard.Guard): rs.u32 => { + const _063: rs.u32 = Guard.id(g57); g57[Symbol.dispose](); return _063; }); - const _381: rt.u32 = Guard.id(d); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n5, f), (f: rt.Formatter) => rt.fmtOption(_379, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_381, f)]; - Log.note(log, rt.fmtFormat(["chain ", args26[0], " ", args26[1], " ", args26[2]])); + const _381: rs.u32 = Guard.id(d); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.fmtOption(_379, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_381, f)]; + Log.note(log, rs.fmtFormat(["chain ", args26[0], " ", args26[1], " ", args26[2]])); } else if (_17 === 13) { - const _396: rt.Iter = rt.vecIntoIter(guards(1, 8), rt.drop); + const _396: rs.Iter = rs.vecIntoIter(guards(1, 8), rs.drop); _1090 = false; const captured40 = c; - const n6: rt.u32 = rt.iterFold(rt.iterTake(rt.iterStepBy(rt.iterSkip(rt.iterRev(rt.iterMap(_396, rt.closure((g53: Guard.Guard): Guard.Guard => { - const _954: rt.u32 = Guard.id(g53); - const _1219: rt.u32 = Guard.id(captured40); - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_954, f), (f: rt.Formatter) => rt.u32Display(_1219, f)]; - Log.note(log, rt.fmtFormat(["map ", args94[0], " ", args94[1]])); + const n6: rs.u32 = rs.iterFold(rs.iterTake(rs.iterStepBy(rs.iterSkip(rs.iterRev(rs.iterMap(_396, rs.closure((g53: Guard.Guard): Guard.Guard => { + const _954: rs.u32 = Guard.id(g53); + const _1219: rs.u32 = Guard.id(captured40); + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_954, f), (f: rs.Formatter) => rs.u32Display(_1219, f)]; + Log.note(log, rs.fmtFormat(["map ", args94[0], " ", args94[1]])); return g53; }, (): void => { captured40[Symbol.dispose](); - }))), 1, rt.drop), 2, rt.drop), 2, rt.drop), 0, (n36: rt.u32, g54: Guard.Guard): rt.u32 => { - const _060: rt.u32 = rt.u32Sub(rt.u32Add(n36, Guard.id(g54)), id); + }))), 1, rs.drop), 2, rs.drop), 2, rs.drop), 0, (n36: rs.u32, g54: Guard.Guard): rs.u32 => { + const _060: rs.u32 = rs.u32Sub(rs.u32Add(n36, Guard.id(g54)), id); g54[Symbol.dispose](); return _060; }, true); - const _409: rt.u32 = Guard.id(d); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n6, f), (f: rt.Formatter) => rt.u32Display(_409, f)]; - Log.note(log, rt.fmtFormat(["read ", args28[0], " ", args28[1]])); + const _409: rs.u32 = Guard.id(d); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n6, f), (f: rs.Formatter) => rs.u32Display(_409, f)]; + Log.note(log, rs.fmtFormat(["read ", args28[0], " ", args28[1]])); } else if (_17 === 14) { - const _419: rt.Iter<[rt.usize, Guard.Guard]> = rt.iterEnumerate(rt.vecIntoIter(guards(1, 4), rt.drop)); + const _419: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(rs.vecIntoIter(guards(1, 4), rs.drop)); _1090 = false; const captured38 = c; - const n7: rt.usize = rt.iterSum(rt.iterMap(_419, rt.closure((_215: [rt.usize, Guard.Guard]): rt.usize => { - const _056: rt.usize = rt.usizeAdd(_215[0], Guard.id(captured38) as rt.usize); + const n7: rs.usize = rs.iterSum(rs.iterMap(_419, rs.closure((_215: [rs.usize, Guard.Guard]): rs.usize => { + const _056: rs.usize = rs.usizeAdd(_215[0], Guard.id(captured38) as rs.usize); lib_drop$tuple2_usize_model_Guard(_215); return _056; }, (): void => { captured38[Symbol.dispose](); - })), rt.usizeAdd, 0, true); - const _428: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + })), rs.usizeAdd, 0, true); + const _428: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured39 = d; - const _439: [rt.usize, rt.u32] | undefined = option_map$14zg54s(rt.ownedLast(rt.iterEnumerate(rt.iterMap(_428, rt.closure((g51: Guard.Guard): Guard.Guard => { - const _953: rt.u32 = Guard.id(g51); - const _1218: rt.u32 = Guard.id(captured39); - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_953, f), (f: rt.Formatter) => rt.u32Display(_1218, f)]; - Log.note(log, rt.fmtFormat(["map ", args92[0], " ", args92[1]])); + const _439: [rs.usize, rs.u32] | undefined = option_map$1389p4b(rs.ownedLast(rs.iterEnumerate(rs.iterMap(_428, rs.closure((g51: Guard.Guard): Guard.Guard => { + const _953: rs.u32 = Guard.id(g51); + const _1218: rs.u32 = Guard.id(captured39); + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_953, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; + Log.note(log, rs.fmtFormat(["map ", args92[0], " ", args92[1]])); return g51; }, (): void => { captured39[Symbol.dispose](); - }))), lib_drop$tuple2_usize_model_Guard), (_216: [rt.usize, Guard.Guard]): [rt.usize, rt.u32] => { - const i3: rt.usize = _216[0]; + }))), lib_drop$tuple2_usize_model_Guard), (_216: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { + const i3: rs.usize = _216[0]; const g52: Guard.Guard = _216[1]; - const _058: [rt.usize, rt.u32] = [i3, Guard.id(g52)]; + const _058: [rs.usize, rs.u32] = [i3, Guard.id(g52)]; g52[Symbol.dispose](); return _058; }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n7, f), (f: rt.Formatter) => rt.fmtOption(_439, f, (value: [rt.usize, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["enumerate ", args30[0], " ", args30[1]])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.fmtOption(_439, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["enumerate ", args30[0], " ", args30[1]])); } else if (_17 === 15) { - const _448: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _448: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured36 = c; - const peek: rt.Peekable = rt.iterPeekable(rt.iterMap(_448, rt.closure((g46: Guard.Guard): Guard.Guard => { - const _948: rt.u32 = Guard.id(g46); - const _1217: rt.u32 = Guard.id(captured36); - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_948, f), (f: rt.Formatter) => rt.u32Display(_1217, f)]; - Log.note(log, rt.fmtFormat(["map ", args90[0], " ", args90[1]])); + const peek: rs.Peekable = rs.iterPeekable(rs.iterMap(_448, rs.closure((g46: Guard.Guard): Guard.Guard => { + const _948: rs.u32 = Guard.id(g46); + const _1217: rs.u32 = Guard.id(captured36); + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_948, f), (f: rs.Formatter) => rs.u32Display(_1217, f)]; + Log.note(log, rs.fmtFormat(["map ", args90[0], " ", args90[1]])); return g46; }, (): void => { captured36[Symbol.dispose](); - })), rt.drop); - const part11 = option_map$1raha9y(rt.peekablePeek(peek), (g47: Guard.Guard): rt.u32 => { + })), rs.drop); + const part11 = option_map$06w9waf(rs.peekablePeek(peek), (g47: Guard.Guard): rs.u32 => { return Guard.id(g47); }); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part11, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek ", args32[0]])); - const n8: rt.u32 = rt.iterFold(peek, 0, (n34: rt.u32, g48: Guard.Guard): rt.u32 => { - const _053: rt.u32 = rt.u32Sub(rt.u32Add(n34, Guard.id(g48)), id); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part11, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek ", args32[0]])); + const n8: rs.u32 = rs.iterFold(peek, 0, (n34: rs.u32, g48: Guard.Guard): rs.u32 => { + const _053: rs.u32 = rs.u32Sub(rs.u32Add(n34, Guard.id(g48)), id); g48[Symbol.dispose](); return _053; }, true); - const _472: rt.Iter = rt.iterFuse(rt.vecIntoIter(guards(5, 8), rt.drop), true); + const _472: rs.Iter = rs.iterFuse(rs.vecIntoIter(guards(5, 8), rs.drop), true); _1089 = false; const captured37 = d; - const m4: rt.u32 = rt.iterFold(rt.iterFilter(_472, rt.closure((g49: Guard.Guard): boolean => { + const m4: rs.u32 = rs.iterFold(rs.iterFilter(_472, rs.closure((g49: Guard.Guard): boolean => { return Guard.id(g49) !== Guard.id(captured37); }, (): void => { captured37[Symbol.dispose](); - }), rt.drop), 0, (n35: rt.u32, g50: Guard.Guard): rt.u32 => { - const _055: rt.u32 = rt.u32Add(n35, Guard.id(g50)); + }), rs.drop), 0, (n35: rs.u32, g50: Guard.Guard): rs.u32 => { + const _055: rs.u32 = rs.u32Add(n35, Guard.id(g50)); g50[Symbol.dispose](); return _055; }, true); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n8, f), (f: rt.Formatter) => rt.u32Display(m4, f)]; - Log.note(log, rt.fmtFormat(["peek ", args34[0], " ", args34[1]])); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(m4, f)]; + Log.note(log, rs.fmtFormat(["peek ", args34[0], " ", args34[1]])); } else if (_17 === 16) { - const _493: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _493: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured34 = c; - const n9: rt.u32 = rt.iterSum(rt.iterMap(rt.iterSkipWhile(_493, rt.closure((g41: Guard.Guard): boolean => { - return Guard.id(g41) < rt.u32Sub(Guard.id(captured34), 8); + const n9: rs.u32 = rs.iterSum(rs.iterMap(rs.iterSkipWhile(_493, rs.closure((g41: Guard.Guard): boolean => { + return Guard.id(g41) < rs.u32Sub(Guard.id(captured34), 8); }, (): void => { captured34[Symbol.dispose](); - }), rt.drop), (g42: Guard.Guard): rt.u32 => { - const _047: rt.u32 = rt.u32Sub(Guard.id(g42), id); + }), rs.drop), (g42: Guard.Guard): rs.u32 => { + const _047: rs.u32 = rs.u32Sub(Guard.id(g42), id); g42[Symbol.dispose](); return _047; - }), rt.u32Add, 0, true); - const _504: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + }), rs.u32Add, 0, true); + const _504: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _1089 = false; const captured35 = d; - const m5: rt.u32 = rt.iterSum(rt.iterMap(rt.iterTakeWhile(rt.iterSkipWhile(_504, rt.closure((g43: Guard.Guard): boolean => { - return Guard.id(g43) < rt.u32Sub(Guard.id(captured35), 5); + const m5: rs.u32 = rs.iterSum(rs.iterMap(rs.iterTakeWhile(rs.iterSkipWhile(_504, rs.closure((g43: Guard.Guard): boolean => { + return Guard.id(g43) < rs.u32Sub(Guard.id(captured35), 5); }, (): void => { captured35[Symbol.dispose](); - }), rt.drop), (g44: Guard.Guard): boolean => { - return Guard.id(g44) < rt.u32Add(id, 7); - }, rt.drop), (g45: Guard.Guard): rt.u32 => { - const _050: rt.u32 = rt.u32Sub(Guard.id(g45), id); + }), rs.drop), (g44: Guard.Guard): boolean => { + return Guard.id(g44) < rs.u32Add(id, 7); + }, rs.drop), (g45: Guard.Guard): rs.u32 => { + const _050: rs.u32 = rs.u32Sub(Guard.id(g45), id); g45[Symbol.dispose](); return _050; - }), rt.u32Add, 0, true); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n9, f), (f: rt.Formatter) => rt.u32Display(m5, f)]; - Log.note(log, rt.fmtFormat(["skip ", args36[0], " ", args36[1]])); + }), rs.u32Add, 0, true); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n9, f), (f: rs.Formatter) => rs.u32Display(m5, f)]; + Log.note(log, rs.fmtFormat(["skip ", args36[0], " ", args36[1]])); } else if (_17 === 17) { - const _527: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _527: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured31 = c; const captured32 = id; - const n10: rt.u32 = rt.iterSum(rt.iterMapWhile(_527, rt.closure((g39: Guard.Guard): rt.u32 | undefined => { - const _043: rt.u32 | undefined = then$0ea5h05(Guard.id(g39) !== rt.u32Sub(Guard.id(captured31), 7), (): rt.u32 => { - return rt.u32Sub(Guard.id(g39), captured32); + const n10: rs.u32 = rs.iterSum(rs.iterMapWhile(_527, rs.closure((g39: Guard.Guard): rs.u32 | undefined => { + const _043: rs.u32 | undefined = then$0apfzgv(Guard.id(g39) !== rs.u32Sub(Guard.id(captured31), 7), (): rs.u32 => { + return rs.u32Sub(Guard.id(g39), captured32); }); g39[Symbol.dispose](); return _043; }, (): void => { captured31[Symbol.dispose](); - })), rt.u32Add, 0, true); - const _534: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + })), rs.u32Add, 0, true); + const _534: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _1089 = false; const captured33 = d; - const m6: rt.usize = rt.ownedCount(rt.iterTakeWhile(_534, rt.closure((g40: Guard.Guard): boolean => { - return Guard.id(g40) !== rt.u32Sub(Guard.id(captured33), 4); + const m6: rs.usize = rs.ownedCount(rs.iterTakeWhile(_534, rs.closure((g40: Guard.Guard): boolean => { + return Guard.id(g40) !== rs.u32Sub(Guard.id(captured33), 4); }, (): void => { captured33[Symbol.dispose](); - }), rt.drop), rt.drop); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n10, f), (f: rt.Formatter) => rt.usizeDisplay(m6, f)]; - Log.note(log, rt.fmtFormat(["while ", args38[0], " ", args38[1]])); + }), rs.drop), rs.drop); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(m6, f)]; + Log.note(log, rs.fmtFormat(["while ", args38[0], " ", args38[1]])); } else if (_17 === 18) { - const _553: rt.Iter = rt.iterSlice([1, 3, 5]); + const _553: rs.Iter = rs.iterSlice([1, 3, 5]); _1090 = false; const captured29 = guard; const captured30 = c; - const n11: rt.usize = rt.ownedCount(rt.iterFlatMap(_553, rt.closure((n33: rt.u32): rt.Vec => { - const v6: rt.Vec = new rt.Vec(); + const n11: rs.usize = rs.ownedCount(rs.iterFlatMap(_553, rs.closure((n33: rs.u32): rs.Vec => { + const v6: rs.Vec = new rs.Vec(); const _659: Guard.Guard = captured29(n33); v6.items.push(_659); - const _1128: Guard.Guard = captured29(rt.u32Add(n33, 1)); + const _1128: Guard.Guard = captured29(rs.u32Add(n33, 1)); v6.items.push(_1128); - const _226: rt.u32 = Guard.id(captured30); - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n33, f), (f: rt.Formatter) => rt.u32Display(_226, f)]; - Log.note(log, rt.fmtFormat(["flat ", args88[0], " ", args88[1]])); + const _226: rs.u32 = Guard.id(captured30); + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n33, f), (f: rs.Formatter) => rs.u32Display(_226, f)]; + Log.note(log, rs.fmtFormat(["flat ", args88[0], " ", args88[1]])); return v6; }, (): void => { captured30[Symbol.dispose](); - }), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true), rt.drop); - const _562: rt.u32 = Guard.id(d); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n11, f), (f: rt.Formatter) => rt.u32Display(_562, f)]; - Log.note(log, rt.fmtFormat(["flat ", args40[0], " ", args40[1]])); + }), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true), rs.drop); + const _562: rs.u32 = Guard.id(d); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n11, f), (f: rs.Formatter) => rs.u32Display(_562, f)]; + Log.note(log, rs.fmtFormat(["flat ", args40[0], " ", args40[1]])); } else if (_17 === 19) { - const _572: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _572: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured23 = guard; const captured24 = c; const captured25 = id; - const flat: rt.Iter = rt.iterFlatten(rt.iterMap(_572, rt.closure((g35: Guard.Guard): rt.Vec => { - const v3: rt.Vec = new rt.Vec(); + const flat: rs.Iter = rs.iterFlatten(rs.iterMap(_572, rs.closure((g35: Guard.Guard): rs.Vec => { + const v3: rs.Vec = new rs.Vec(); v3.items.push(g35); - const _818: Guard.Guard = captured23(rt.u32Add(rt.u32Sub(Guard.id(captured24), captured25), 1)); + const _818: Guard.Guard = captured23(rs.u32Add(rs.u32Sub(Guard.id(captured24), captured25), 1)); v3.items.push(_818); return v3; }, (): void => { captured24[Symbol.dispose](); - })), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); - const part7 = option_map$1raha9y(rt.iterToOption(flat.next()), (g36: Guard.Guard): rt.u32 => { - const _039: rt.u32 = Guard.id(g36); + })), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); + const part7 = option_map$06w9waf(rs.iterToOption(flat.next()), (g36: Guard.Guard): rs.u32 => { + const _039: rs.u32 = Guard.id(g36); g36[Symbol.dispose](); return _039; }); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part7, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["front ", args42[0]])); - const n12: rt.u32 = rt.iterSum(rt.iterMap(flat, (g37: Guard.Guard): rt.u32 => { - const _040: rt.u32 = rt.u32Sub(Guard.id(g37), id); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part7, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["front ", args42[0]])); + const n12: rs.u32 = rs.iterSum(rs.iterMap(flat, (g37: Guard.Guard): rs.u32 => { + const _040: rs.u32 = rs.u32Sub(Guard.id(g37), id); g37[Symbol.dispose](); return _040; - }), rt.u32Add, 0, true); - const _597: rt.Iter = rt.iterSlice([4, 6]); + }), rs.u32Add, 0, true); + const _597: rs.Iter = rs.iterSlice([4, 6]); _1089 = false; const captured26 = guard; const captured27 = d; const captured28 = id; - const _606: rt.u32 | undefined = option_map$1raha9y(rt.ownedLast(rt.iterFlatMap(_597, rt.closure((n32: rt.u32): rt.Vec => { - const v4: rt.Vec = new rt.Vec(); + const _606: rs.u32 | undefined = option_map$06w9waf(rs.ownedLast(rs.iterFlatMap(_597, rs.closure((n32: rs.u32): rs.Vec => { + const v4: rs.Vec = new rs.Vec(); const _658: Guard.Guard = captured26(n32); v4.items.push(_658); - const _1125: Guard.Guard = captured26(rt.u32Add(rt.u32Sub(Guard.id(captured27), captured28), n32)); + const _1125: Guard.Guard = captured26(rs.u32Add(rs.u32Sub(Guard.id(captured27), captured28), n32)); v4.items.push(_1125); return v4; }, (): void => { captured27[Symbol.dispose](); - }), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true), rt.drop), (g38: Guard.Guard): rt.u32 => { - const _042: rt.u32 = Guard.id(g38); + }), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true), rs.drop), (g38: Guard.Guard): rs.u32 => { + const _042: rs.u32 = Guard.id(g38); g38[Symbol.dispose](); return _042; }); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n12, f), (f: rt.Formatter) => rt.fmtOption(_606, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["flat ", args44[0], " ", args44[1]])); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n12, f), (f: rs.Formatter) => rs.fmtOption(_606, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["flat ", args44[0], " ", args44[1]])); } else if (_17 === 20) { - const held: rt.Vec = guards(1, 5); + const held: rs.Vec = guards(1, 5); _1090 = false; let captured19 = held; const captured20 = c; - const n13: rt.usize = rt.ownedCount(rt.iterFromFn(rt.closure((): rt.u32 | undefined => { - const _336: Guard.Guard | undefined = rt.vecPop(captured19); + const n13: rs.usize = rs.ownedCount(rs.iterFromFn(rs.closure((): rs.u32 | undefined => { + const _336: Guard.Guard | undefined = rs.vecPop(captured19); if (_336 !== undefined) { const g32: Guard.Guard = _336; - const _034: rt.u32 | undefined = rt.u32Add(Guard.id(g32), Guard.id(captured20)); + const _034: rs.u32 | undefined = rs.u32Add(Guard.id(g32), Guard.id(captured20)); g32[Symbol.dispose](); return _034; } return undefined; }, (): void => { - rt.dropVec(captured19); + rs.dropVec(captured19); captured20[Symbol.dispose](); }))); const _621: Guard.Guard | undefined = guard(5); _1089 = false; const captured21 = id; const captured22 = d; - const m8: rt.u32 = rt.iterFold(rt.iterSuccessors(_621, rt.closure((g33: Guard.Guard): Guard.Guard | undefined => { - return then$1xpp3sz(Guard.id(g33) < rt.u32Add(captured21, 7), (): Guard.Guard => { - return Guard.new(rt.u32Sub(rt.u32Add(rt.u32Add(Guard.id(g33), 1), Guard.id(captured22)), Guard.id(captured22)), Log.clone$Clone(log)); + const m8: rs.u32 = rs.iterFold(rs.iterSuccessors(_621, rs.closure((g33: Guard.Guard): Guard.Guard | undefined => { + return then$1xpp3sz(Guard.id(g33) < rs.u32Add(captured21, 7), (): Guard.Guard => { + return Guard.new(rs.u32Sub(rs.u32Add(rs.u32Add(Guard.id(g33), 1), Guard.id(captured22)), Guard.id(captured22)), Log.clone$Clone(log)); }); }, (): void => { captured22[Symbol.dispose](); - }), rt.drop), 0, (n31: rt.u32, g34: Guard.Guard): rt.u32 => { - const _037: rt.u32 = rt.u32Sub(rt.u32Add(n31, Guard.id(g34)), id); + }), rs.drop), 0, (n31: rs.u32, g34: Guard.Guard): rs.u32 => { + const _037: rs.u32 = rs.u32Sub(rs.u32Add(n31, Guard.id(g34)), id); g34[Symbol.dispose](); return _037; }, true); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n13, f), (f: rt.Formatter) => rt.u32Display(m8, f)]; - Log.note(log, rt.fmtFormat(["lazy ", args46[0], " ", args46[1]])); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n13, f), (f: rs.Formatter) => rs.u32Display(m8, f)]; + Log.note(log, rs.fmtFormat(["lazy ", args46[0], " ", args46[1]])); } else if (_17 === 21) { - const _643: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _643: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured18 = c; - const n14: rt.usize = rt.ownedCount(rt.iterSkip(rt.iterMap(_643, rt.closure((g31: Guard.Guard): rt.u32 => { - const _033: rt.u32 = rt.u32Add(Guard.id(g31), Guard.id(captured18)); + const n14: rs.usize = rs.ownedCount(rs.iterSkip(rs.iterMap(_643, rs.closure((g31: Guard.Guard): rs.u32 => { + const _033: rs.u32 = rs.u32Add(Guard.id(g31), Guard.id(captured18)); g31[Symbol.dispose](); return _033; }, (): void => { captured18[Symbol.dispose](); })), 1)); - const m9: rt.usize = rt.ownedCount(rt.iterTake(rt.vecIntoIter(guards(5, 8), rt.drop), 2, rt.drop), rt.drop); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n14, f), (f: rt.Formatter) => rt.usizeDisplay(m9, f)]; - Log.note(log, rt.fmtFormat(["over ", args48[0], " ", args48[1]])); + const m9: rs.usize = rs.ownedCount(rs.iterTake(rs.vecIntoIter(guards(5, 8), rs.drop), 2, rs.drop), rs.drop); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n14, f), (f: rs.Formatter) => rs.usizeDisplay(m9, f)]; + Log.note(log, rs.fmtFormat(["over ", args48[0], " ", args48[1]])); } else if (_17 === 22) { - const _669: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _669: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured15 = c; const captured16 = id; - const n15: rt.u32 = rt.iterFold(rt.iterRev(rt.iterMap(_669, rt.closure((g29: Guard.Guard): rt.u32 => { - const _940: rt.u32 = Guard.id(g29); - const _1215: rt.u32 = Guard.id(captured15); - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_940, f), (f: rt.Formatter) => rt.u32Display(_1215, f)]; - Log.note(log, rt.fmtFormat(["map ", args86[0], " ", args86[1]])); - const _030: rt.u32 = rt.u32Sub(Guard.id(g29), captured16); + const n15: rs.u32 = rs.iterFold(rs.iterRev(rs.iterMap(_669, rs.closure((g29: Guard.Guard): rs.u32 => { + const _940: rs.u32 = Guard.id(g29); + const _1215: rs.u32 = Guard.id(captured15); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_940, f), (f: rs.Formatter) => rs.u32Display(_1215, f)]; + Log.note(log, rs.fmtFormat(["map ", args86[0], " ", args86[1]])); + const _030: rs.u32 = rs.u32Sub(Guard.id(g29), captured16); g29[Symbol.dispose](); return _030; }, (): void => { captured15[Symbol.dispose](); - }))), 0, (n30: rt.u32, k: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(n30, 10), k); + }))), 0, (n30: rs.u32, k: rs.u32): rs.u32 => { + return rs.u32Add(rs.u32Mul(n30, 10), k); }, true); - const _677: rt.Iter = rt.iterChain(rt.vecIntoIter(guards(5, 6), rt.drop), rt.vecIntoIter(guards(6, 8), rt.drop)); + const _677: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(5, 6), rs.drop), rs.vecIntoIter(guards(6, 8), rs.drop)); _1089 = false; const captured17 = d; - const m10: rt.usize = rt.ownedCount(rt.iterRev(rt.iterFilter(_677, rt.closure((g30: Guard.Guard): boolean => { - return Guard.id(g30) !== rt.u32Sub(Guard.id(captured17), 5); + const m10: rs.usize = rs.ownedCount(rs.iterRev(rs.iterFilter(_677, rs.closure((g30: Guard.Guard): boolean => { + return Guard.id(g30) !== rs.u32Sub(Guard.id(captured17), 5); }, (): void => { captured17[Symbol.dispose](); - }), rt.drop)), rt.drop); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n15, f), (f: rt.Formatter) => rt.usizeDisplay(m10, f)]; - Log.note(log, rt.fmtFormat(["rev ", args50[0], " ", args50[1]])); + }), rs.drop)), rs.drop); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n15, f), (f: rs.Formatter) => rs.usizeDisplay(m10, f)]; + Log.note(log, rs.fmtFormat(["rev ", args50[0], " ", args50[1]])); } else if (_17 === 23) { - const _702: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _702: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _1090 = false; const captured13 = c; - const n16: rt.u32 = rt.iterFold(rt.iterRev(rt.iterTake(rt.iterMap(_702, rt.closure((g26: Guard.Guard): Guard.Guard => { - const _931: rt.u32 = Guard.id(g26); - const _1214: rt.u32 = Guard.id(captured13); - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_931, f), (f: rt.Formatter) => rt.u32Display(_1214, f)]; - Log.note(log, rt.fmtFormat(["map ", args84[0], " ", args84[1]])); + const n16: rs.u32 = rs.iterFold(rs.iterRev(rs.iterTake(rs.iterMap(_702, rs.closure((g26: Guard.Guard): Guard.Guard => { + const _931: rs.u32 = Guard.id(g26); + const _1214: rs.u32 = Guard.id(captured13); + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_931, f), (f: rs.Formatter) => rs.u32Display(_1214, f)]; + Log.note(log, rs.fmtFormat(["map ", args84[0], " ", args84[1]])); return g26; }, (): void => { captured13[Symbol.dispose](); - })), 3, rt.drop)), 0, (n29: rt.u32, g27: Guard.Guard): rt.u32 => { - const _028: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Mul(n29, 10), Guard.id(g27)), id); + })), 3, rs.drop)), 0, (n29: rs.u32, g27: Guard.Guard): rs.u32 => { + const _028: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n29, 10), Guard.id(g27)), id); g27[Symbol.dispose](); return _028; }, true); - const _713: rt.Iter = rt.vecIntoIter(guards(6, 8), rt.drop); + const _713: rs.Iter = rs.vecIntoIter(guards(6, 8), rs.drop); const captured14 = id; - const m11: rt.u32 = rt.iterSum(rt.iterRev(rt.iterTake(rt.iterMap(_713, (g28: Guard.Guard): rt.u32 => { - const _029: rt.u32 = rt.u32Sub(Guard.id(g28), captured14); + const m11: rs.u32 = rs.iterSum(rs.iterRev(rs.iterTake(rs.iterMap(_713, (g28: Guard.Guard): rs.u32 => { + const _029: rs.u32 = rs.u32Sub(Guard.id(g28), captured14); g28[Symbol.dispose](); return _029; - }), 0)), rt.u32Add, 0, true); - const _724: rt.u32 = Guard.id(d); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n16, f), (f: rt.Formatter) => rt.u32Display(m11, f), (f: rt.Formatter) => rt.u32Display(_724, f)]; - Log.note(log, rt.fmtFormat(["take ", args52[0], " ", args52[1], " ", args52[2]])); + }), 0)), rs.u32Add, 0, true); + const _724: rs.u32 = Guard.id(d); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n16, f), (f: rs.Formatter) => rs.u32Display(m11, f), (f: rs.Formatter) => rs.u32Display(_724, f)]; + Log.note(log, rs.fmtFormat(["take ", args52[0], " ", args52[1], " ", args52[2]])); } else if (_17 === 24) { - const _739: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _739: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); _1090 = false; const captured11 = c; - const n17: rt.u32 = rt.iterSum(rt.iterMap(rt.iterRev(rt.iterStepBy(rt.iterMap(_739, rt.closure((g23: Guard.Guard): Guard.Guard => { - const _928: rt.u32 = Guard.id(g23); - const _1213: rt.u32 = Guard.id(captured11); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_928, f), (f: rt.Formatter) => rt.u32Display(_1213, f)]; - Log.note(log, rt.fmtFormat(["map ", args82[0], " ", args82[1]])); + const n17: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterStepBy(rs.iterMap(_739, rs.closure((g23: Guard.Guard): Guard.Guard => { + const _928: rs.u32 = Guard.id(g23); + const _1213: rs.u32 = Guard.id(captured11); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_928, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; + Log.note(log, rs.fmtFormat(["map ", args82[0], " ", args82[1]])); return g23; }, (): void => { captured11[Symbol.dispose](); - })), 2, rt.drop)), (g24: Guard.Guard): rt.u32 => { - const _025: rt.u32 = rt.u32Sub(Guard.id(g24), id); + })), 2, rs.drop)), (g24: Guard.Guard): rs.u32 => { + const _025: rs.u32 = rs.u32Sub(Guard.id(g24), id); g24[Symbol.dispose](); return _025; - }), rt.u32Add, 0, true); - const _749: rt.Iter = rt.vecIntoIter(guards(7, 8), rt.drop); + }), rs.u32Add, 0, true); + const _749: rs.Iter = rs.vecIntoIter(guards(7, 8), rs.drop); _1089 = false; const captured12 = d; - const m12: rt.usize = rt.ownedCount(rt.iterStepBy(rt.iterFilter(_749, rt.closure((g25: Guard.Guard): boolean => { + const m12: rs.usize = rs.ownedCount(rs.iterStepBy(rs.iterFilter(_749, rs.closure((g25: Guard.Guard): boolean => { return Guard.id(g25) !== Guard.id(captured12); }, (): void => { captured12[Symbol.dispose](); - }), rt.drop), 3, rt.drop), rt.drop); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n17, f), (f: rt.Formatter) => rt.usizeDisplay(m12, f)]; - Log.note(log, rt.fmtFormat(["step ", args54[0], " ", args54[1]])); + }), rs.drop), 3, rs.drop), rs.drop); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n17, f), (f: rs.Formatter) => rs.usizeDisplay(m12, f)]; + Log.note(log, rs.fmtFormat(["step ", args54[0], " ", args54[1]])); } else if (_17 === 25) { - const _768: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _768: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured10 = c; - const peek2: rt.Peekable = rt.iterPeekable(rt.iterMap(_768, rt.closure((g18: Guard.Guard): Guard.Guard => { - const _922: rt.u32 = Guard.id(g18); - const _1212: rt.u32 = Guard.id(captured10); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_922, f), (f: rt.Formatter) => rt.u32Display(_1212, f)]; - Log.note(log, rt.fmtFormat(["map ", args80[0], " ", args80[1]])); + const peek2: rs.Peekable = rs.iterPeekable(rs.iterMap(_768, rs.closure((g18: Guard.Guard): Guard.Guard => { + const _922: rs.u32 = Guard.id(g18); + const _1212: rs.u32 = Guard.id(captured10); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_922, f), (f: rs.Formatter) => rs.u32Display(_1212, f)]; + Log.note(log, rs.fmtFormat(["map ", args80[0], " ", args80[1]])); return g18; }, (): void => { captured10[Symbol.dispose](); - })), rt.drop); - const part3 = option_map$1raha9y(rt.peekablePeek(peek2), (g19: Guard.Guard): rt.u32 => { + })), rs.drop); + const part3 = option_map$06w9waf(rs.peekablePeek(peek2), (g19: Guard.Guard): rs.u32 => { return Guard.id(g19); }); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek ", args56[0]])); - const n18: rt.u32 = rt.iterFold(rt.iterRev(peek2), 0, (n28: rt.u32, g20: Guard.Guard): rt.u32 => { - const _021: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Mul(n28, 10), Guard.id(g20)), id); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek ", args56[0]])); + const n18: rs.u32 = rs.iterFold(rs.iterRev(peek2), 0, (n28: rs.u32, g20: Guard.Guard): rs.u32 => { + const _021: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n28, 10), Guard.id(g20)), id); g20[Symbol.dispose](); return _021; }, true); - const ended: rt.Peekable = rt.iterPeekable(rt.vecIntoIter(guards(5, 6), rt.drop), rt.drop); - const part4 = option_map$1raha9y(rt.iterToOption(ended.next()), (g21: Guard.Guard): rt.u32 => { - const _022: rt.u32 = Guard.id(g21); + const ended: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(guards(5, 6), rs.drop), rs.drop); + const part4 = option_map$06w9waf(rs.iterToOption(ended.next()), (g21: Guard.Guard): rs.u32 => { + const _022: rs.u32 = Guard.id(g21); g21[Symbol.dispose](); return _022; }); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek ", args58[0]])); - const part5 = option_map$1raha9y(rt.peekablePeek(ended), (g22: Guard.Guard): rt.u32 => { + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek ", args58[0]])); + const part5 = option_map$06w9waf(rs.peekablePeek(ended), (g22: Guard.Guard): rs.u32 => { return Guard.id(g22); }); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["peek ", args60[0]])); - const _828: rt.usize = rt.ownedCount(rt.iterRev(ended), rt.drop); - const _832: rt.u32 = Guard.id(d); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n18, f), (f: rt.Formatter) => rt.usizeDisplay(_828, f), (f: rt.Formatter) => rt.u32Display(_832, f)]; - Log.note(log, rt.fmtFormat(["peek ", args62[0], " ", args62[1], " ", args62[2]])); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["peek ", args60[0]])); + const _828: rs.usize = rs.ownedCount(rs.iterRev(ended), rs.drop); + const _832: rs.u32 = Guard.id(d); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n18, f), (f: rs.Formatter) => rs.usizeDisplay(_828, f), (f: rs.Formatter) => rs.u32Display(_832, f)]; + Log.note(log, rs.fmtFormat(["peek ", args62[0], " ", args62[1], " ", args62[2]])); } else if (_17 === 26) { - const _843: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _843: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _1090 = false; const captured7 = guard; const captured8 = c; const captured9 = id; - const flat2: rt.Iter = rt.iterFlatten(rt.iterMap(_843, rt.closure((g14: Guard.Guard): rt.Vec => { - const v2: rt.Vec = new rt.Vec(); + const flat2: rs.Iter = rs.iterFlatten(rs.iterMap(_843, rs.closure((g14: Guard.Guard): rs.Vec => { + const v2: rs.Vec = new rs.Vec(); v2.items.push(g14); - const _86: Guard.Guard = captured7(rt.u32Add(rt.u32Sub(Guard.id(captured8), captured9), 1)); + const _86: Guard.Guard = captured7(rs.u32Add(rs.u32Sub(Guard.id(captured8), captured9), 1)); v2.items.push(_86); return v2; }, (): void => { captured8[Symbol.dispose](); - })), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); - const part2 = option_map$1raha9y(rt.iterToOption(flat2.nextBack()), (g15: Guard.Guard): rt.u32 => { - const _016: rt.u32 = Guard.id(g15); + })), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); + const part2 = option_map$06w9waf(rs.iterToOption(flat2.nextBack()), (g15: Guard.Guard): rs.u32 => { + const _016: rs.u32 = Guard.id(g15); g15[Symbol.dispose](); return _016; }); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["back ", args64[0]])); - const n19: rt.u32 = rt.iterFold(rt.iterRev(flat2), 0, (n27: rt.u32, g16: Guard.Guard): rt.u32 => { - const _017: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Mul(n27, 100), Guard.id(g16)), id); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["back ", args64[0]])); + const n19: rs.u32 = rs.iterFold(rs.iterRev(flat2), 0, (n27: rs.u32, g16: Guard.Guard): rs.u32 => { + const _017: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n27, 100), Guard.id(g16)), id); g16[Symbol.dispose](); return _017; }, true); - const _879: [rt.usize, rt.u32] | undefined = option_map$14zg54s(rt.ownedLast(rt.iterRev(rt.iterEnumerate(rt.vecIntoIter(guards(4, 8), rt.drop))), lib_drop$tuple2_usize_model_Guard), (_2: [rt.usize, Guard.Guard]): [rt.usize, rt.u32] => { - const i: rt.usize = _2[0]; + const _879: [rs.usize, rs.u32] | undefined = option_map$1389p4b(rs.ownedLast(rs.iterRev(rs.iterEnumerate(rs.vecIntoIter(guards(4, 8), rs.drop))), lib_drop$tuple2_usize_model_Guard), (_2: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { + const i: rs.usize = _2[0]; const g17: Guard.Guard = _2[1]; - const _018: [rt.usize, rt.u32] = [i, Guard.id(g17)]; + const _018: [rs.usize, rs.u32] = [i, Guard.id(g17)]; g17[Symbol.dispose](); return _018; }); - const _881: rt.u32 = Guard.id(d); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n19, f), (f: rt.Formatter) => rt.fmtOption(_879, f, (value: [rt.usize, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.u32Display(_881, f)]; - Log.note(log, rt.fmtFormat(["flat ", args66[0], " ", args66[1], " ", args66[2]])); + const _881: rs.u32 = Guard.id(d); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n19, f), (f: rs.Formatter) => rs.fmtOption(_879, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_881, f)]; + Log.note(log, rs.fmtFormat(["flat ", args66[0], " ", args66[1], " ", args66[2]])); } else if (_17 === 27) { - const _893: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _893: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured5 = c; - const kept2: Guard.Guard | undefined = rt.iterFold(rt.iterRev(rt.iterFilter(_893, rt.closure((g9: Guard.Guard): boolean => { - return Guard.id(g9) !== rt.u32Sub(Guard.id(captured5), 8); + const kept2: Guard.Guard | undefined = rs.iterFold(rs.iterRev(rs.iterFilter(_893, rs.closure((g9: Guard.Guard): boolean => { + return Guard.id(g9) !== rs.u32Sub(Guard.id(captured5), 8); }, (): void => { captured5[Symbol.dispose](); - }), rt.drop)), undefined as Guard.Guard | undefined, (kept3: Guard.Guard | undefined, g10: Guard.Guard): Guard.Guard | undefined => { + }), rs.drop)), undefined as Guard.Guard | undefined, (kept3: Guard.Guard | undefined, g10: Guard.Guard): Guard.Guard | undefined => { let _011!: Guard.Guard | undefined; let _1113: boolean = false; let _105: boolean = false; _1113 = true; _105 = true; - if (!(rt.u32Rem(Guard.id(g10), 2) === 0)) { + if (!(rs.u32Rem(Guard.id(g10), 2) === 0)) { _1113 = false; _011 = kept3; } else { @@ -817,66 +817,66 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { g10[Symbol.dispose](); } if (_1113) { - rt.drop(kept3); + rs.drop(kept3); return _011; } return _011; }, true); - const _903: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + const _903: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _1089 = false; const captured6 = d; - const n20: rt.u32 = rt.iterSum(rt.iterMap(rt.iterRev(rt.iterFilterMap(_903, rt.closure((g11: Guard.Guard): Guard.Guard | undefined => { - return thenSome$0zvoczk(Guard.id(g11) !== rt.u32Sub(Guard.id(captured6), 5), g11); + const n20: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterFilterMap(_903, rs.closure((g11: Guard.Guard): Guard.Guard | undefined => { + return thenSome$0zvoczk(Guard.id(g11) !== rs.u32Sub(Guard.id(captured6), 5), g11); }, (): void => { captured6[Symbol.dispose](); - }))), (g12: Guard.Guard): rt.u32 => { - const _013: rt.u32 = rt.u32Sub(Guard.id(g12), id); + }))), (g12: Guard.Guard): rs.u32 => { + const _013: rs.u32 = rs.u32Sub(Guard.id(g12), id); g12[Symbol.dispose](); return _013; - }), rt.u32Add, 0, true); - const _916: rt.u32 | undefined = option_map$1raha9y(kept2, (g13: Guard.Guard): rt.u32 => { - const _014: rt.u32 = Guard.id(g13); + }), rs.u32Add, 0, true); + const _916: rs.u32 | undefined = option_map$06w9waf(kept2, (g13: Guard.Guard): rs.u32 => { + const _014: rs.u32 = Guard.id(g13); g13[Symbol.dispose](); return _014; }); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_916, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(n20, f)]; - Log.note(log, rt.fmtFormat(["rev ", args68[0], " ", args68[1]])); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_916, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n20, f)]; + Log.note(log, rs.fmtFormat(["rev ", args68[0], " ", args68[1]])); } else if (_17 === 28) { - const _926: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _926: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _1090 = false; const captured4 = c; - const n21: rt.usize = rt.ownedCount(rt.iterRev(rt.iterInspect(_926, rt.closure((g7: Guard.Guard): undefined => { - const _910: rt.u32 = Guard.id(g7); - const _1111: rt.u32 = Guard.id(captured4); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_910, f), (f: rt.Formatter) => rt.u32Display(_1111, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args78[0], " ", args78[1]])); + const n21: rs.usize = rs.ownedCount(rs.iterRev(rs.iterInspect(_926, rs.closure((g7: Guard.Guard): undefined => { + const _910: rs.u32 = Guard.id(g7); + const _1111: rs.u32 = Guard.id(captured4); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args78[0], " ", args78[1]])); }, (): void => { captured4[Symbol.dispose](); - }))), rt.drop); - const m14: rt.u32 = rt.iterSum(rt.iterMap(rt.iterRev(rt.iterFuse(rt.vecIntoIter(guards(5, 8), rt.drop), true)), (g8: Guard.Guard): rt.u32 => { - const _09: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g8), id), Guard.id(d)), Guard.id(d)); + }))), rs.drop); + const m14: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterFuse(rs.vecIntoIter(guards(5, 8), rs.drop), true)), (g8: Guard.Guard): rs.u32 => { + const _09: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g8), id), Guard.id(d)), Guard.id(d)); g8[Symbol.dispose](); return _09; - }), rt.u32Add, 0, true); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n21, f), (f: rt.Formatter) => rt.u32Display(m14, f)]; - Log.note(log, rt.fmtFormat(["rev ", args70[0], " ", args70[1]])); + }), rs.u32Add, 0, true); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n21, f), (f: rs.Formatter) => rs.u32Display(m14, f)]; + Log.note(log, rs.fmtFormat(["rev ", args70[0], " ", args70[1]])); } else if (_17 === 29) { - const _957: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); - const _962: rt.Iter = rt.vecIntoIter(guards(4, 7), rt.drop); + const _957: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); + const _962: rs.Iter = rs.vecIntoIter(guards(4, 7), rs.drop); _1089 = false; const captured3 = d; - const n22: rt.u32 = rt.iterFold(rt.iterRev(rt.iterChain(_957, rt.iterFilter(_962, rt.closure((g5: Guard.Guard): boolean => { - return Guard.id(g5) !== rt.u32Sub(Guard.id(captured3), 6); + const n22: rs.u32 = rs.iterFold(rs.iterRev(rs.iterChain(_957, rs.iterFilter(_962, rs.closure((g5: Guard.Guard): boolean => { + return Guard.id(g5) !== rs.u32Sub(Guard.id(captured3), 6); }, (): void => { captured3[Symbol.dispose](); - }), rt.drop))), 0, (n26: rt.u32, g6: Guard.Guard): rt.u32 => { - const _08: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Mul(n26, 10), Guard.id(g6)), id); + }), rs.drop))), 0, (n26: rs.u32, g6: Guard.Guard): rs.u32 => { + const _08: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Mul(n26, 10), Guard.id(g6)), id); g6[Symbol.dispose](); return _08; }, true); - const _975: rt.u32 = Guard.id(c); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n22, f), (f: rt.Formatter) => rt.u32Display(_975, f)]; - Log.note(log, rt.fmtFormat(["rev ", args72[0], " ", args72[1]])); + const _975: rs.u32 = Guard.id(c); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n22, f), (f: rs.Formatter) => rs.u32Display(_975, f)]; + Log.note(log, rs.fmtFormat(["rev ", args72[0], " ", args72[1]])); } else if (_17 === 31) { options(log, id); } else if (_17 === 32) { @@ -886,40 +886,40 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { } else { if (34 <= _17) { if (_17 < 42) { - zips(log, id, rt.u8Sub(arg, 34)); + zips(log, id, rs.u8Sub(arg, 34)); break b0; } } - const _990: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _990: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _1090 = false; const captured = c; - const n23: rt.u32 = rt.iterSum(rt.iterMap(rt.iterRev(rt.iterSkip(rt.iterMap(_990, rt.closure((g: Guard.Guard): Guard.Guard => { - const _9: rt.u32 = Guard.id(g); - const _123: rt.u32 = Guard.id(captured); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_9, f), (f: rt.Formatter) => rt.u32Display(_123, f)]; - Log.note(log, rt.fmtFormat(["map ", args76[0], " ", args76[1]])); + const n23: rs.u32 = rs.iterSum(rs.iterMap(rs.iterRev(rs.iterSkip(rs.iterMap(_990, rs.closure((g: Guard.Guard): Guard.Guard => { + const _9: rs.u32 = Guard.id(g); + const _123: rs.u32 = Guard.id(captured); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_9, f), (f: rs.Formatter) => rs.u32Display(_123, f)]; + Log.note(log, rs.fmtFormat(["map ", args76[0], " ", args76[1]])); return g; }, (): void => { captured[Symbol.dispose](); - })), 2, rt.drop)), (g2: Guard.Guard): rt.u32 => { - const _04: rt.u32 = rt.u32Sub(Guard.id(g2), id); + })), 2, rs.drop)), (g2: Guard.Guard): rs.u32 => { + const _04: rs.u32 = rs.u32Sub(Guard.id(g2), id); g2[Symbol.dispose](); return _04; - }), rt.u32Add, 0, true); - const _1000: rt.Iter = rt.vecIntoIter(guards(6, 8), rt.drop); + }), rs.u32Add, 0, true); + const _1000: rs.Iter = rs.vecIntoIter(guards(6, 8), rs.drop); _1089 = false; const captured2 = d; - const m15: rt.u32 = rt.iterFold(rt.iterSkip(rt.iterFilter(_1000, rt.closure((g3: Guard.Guard): boolean => { + const m15: rs.u32 = rs.iterFold(rs.iterSkip(rs.iterFilter(_1000, rs.closure((g3: Guard.Guard): boolean => { return Guard.id(g3) !== Guard.id(captured2); }, (): void => { captured2[Symbol.dispose](); - }), rt.drop), 1, rt.drop), 0, (n25: rt.u32, g4: Guard.Guard): rt.u32 => { - const _06: rt.u32 = rt.u32Sub(rt.u32Add(n25, Guard.id(g4)), id); + }), rs.drop), 1, rs.drop), 0, (n25: rs.u32, g4: Guard.Guard): rs.u32 => { + const _06: rs.u32 = rs.u32Sub(rs.u32Add(n25, Guard.id(g4)), id); g4[Symbol.dispose](); return _06; }, true); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n23, f), (f: rt.Formatter) => rt.u32Display(m15, f)]; - Log.note(log, rt.fmtFormat(["skip ", args74[0], " ", args74[1]])); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n23, f), (f: rs.Formatter) => rs.u32Display(m15, f)]; + Log.note(log, rs.fmtFormat(["skip ", args74[0], " ", args74[1]])); } } if (_1089) { @@ -938,18 +938,18 @@ export function folded(log: Log.Log, id: rt.u32, arg: rt.u8): void { * crate's iterator with folds of its own. The last panics in a `try_rfold`, with what * dropped before. */ -export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { - let n!: rt.u32; +export function rfolded(log: Log.Log, id: rs.u32, arg: rs.u8): void { + let n!: rs.u32; let f!: Guard.Guard; - let broke!: rt.u32 | undefined; + let broke!: rs.u32 | undefined; let _775: boolean = false; let _774: boolean = false; let _773: boolean = false; - const guard: (a0: rt.u32) => Guard.Guard = (n12: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n12), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n12: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n12), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _11: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12)]; _775 = true; @@ -958,19 +958,19 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const d: Guard.Guard = _11[1]; _773 = true; const e: Guard.Guard = _11[2]; - const pile: (a0: rt.u32, a1: rt.u32) => Pile.Pile = (from2: rt.u32, to2: rt.u32): Pile.Pile => { + const pile: (a0: rs.u32, a1: rs.u32) => Pile.Pile = (from2: rs.u32, to2: rs.u32): Pile.Pile => { return new Pile.Pile(guards(from2, to2), Log.clone$Clone(log)); }; - const _23: rt.u8 = rt.u8Rem(arg, 18); + const _23: rs.u8 = rs.u8Rem(arg, 18); if (_23 === 0) { - const _29: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _29: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured48 = c; - const _27: rt.Iter = rt.iterRev(rt.iterMap(_29, rt.closure((g53: Guard.Guard): Guard.Guard => { - const _928: rt.u32 = Guard.id(g53); - const _1226: rt.u32 = Guard.id(captured48); - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_928, f), (f: rt.Formatter) => rt.u32Display(_1226, f)]; - Log.note(log, rt.fmtFormat(["map ", args86[0], " ", args86[1]])); + const _27: rs.Iter = rs.iterRev(rs.iterMap(_29, rs.closure((g53: Guard.Guard): Guard.Guard => { + const _928: rs.u32 = Guard.id(g53); + const _1226: rs.u32 = Guard.id(captured48); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_928, f), (f: rs.Formatter) => rs.u32Display(_1226, f)]; + Log.note(log, rs.fmtFormat(["map ", args86[0], " ", args86[1]])); return g53; }, (): void => { captured48[Symbol.dispose](); @@ -978,173 +978,173 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { _774 = false; const captured49 = id; const captured50 = d; - n = rt.iterSum(rt.iterMap(_27, rt.closure((g54: Guard.Guard): rt.u32 => { - const _060: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g54), captured49), Guard.id(captured50)), Guard.id(captured50)); + n = rs.iterSum(rs.iterMap(_27, rs.closure((g54: Guard.Guard): rs.u32 => { + const _060: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g54), captured49), Guard.id(captured50)), Guard.id(captured50)); g54[Symbol.dispose](); return _060; }, (): void => { captured50[Symbol.dispose](); - })), rt.u32Add, 0, true); - const _41: rt.u32 = Guard.id(e); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n, f), (f: rt.Formatter) => rt.u32Display(_41, f)]; - Log.note(log, rt.fmtFormat(["map ", args2[0], " ", args2[1]])); + })), rs.u32Add, 0, true); + const _41: rs.u32 = Guard.id(e); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n, f), (f: rs.Formatter) => rs.u32Display(_41, f)]; + Log.note(log, rs.fmtFormat(["map ", args2[0], " ", args2[1]])); } else if (_23 === 1) { - const _53: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _53: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured43 = c; - const _51: rt.Iter = rt.iterRev(rt.iterFilter(_53, rt.closure((g49: Guard.Guard): boolean => { + const _51: rs.Iter = rs.iterRev(rs.iterFilter(_53, rs.closure((g49: Guard.Guard): boolean => { return Guard.id(g49) !== Guard.id(captured43); }, (): void => { captured43[Symbol.dispose](); - }), rt.drop)); + }), rs.drop)); _774 = false; const captured44 = id; const captured45 = d; - const n2: rt.u32 = rt.iterSum(rt.iterMap(_51, rt.closure((g50: Guard.Guard): rt.u32 => { - const _056: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g50), captured44), Guard.id(captured45)), Guard.id(captured45)); + const n2: rs.u32 = rs.iterSum(rs.iterMap(_51, rs.closure((g50: Guard.Guard): rs.u32 => { + const _056: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g50), captured44), Guard.id(captured45)), Guard.id(captured45)); g50[Symbol.dispose](); return _056; }, (): void => { captured45[Symbol.dispose](); - })), rt.u32Add, 0, true); + })), rs.u32Add, 0, true); f = guard(13); - const _66: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + const _66: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _773 = false; const captured46 = e; - const _64: rt.Iter = rt.iterRev(rt.iterFilterMap(_66, rt.closure((g51: Guard.Guard): Guard.Guard | undefined => { + const _64: rs.Iter = rs.iterRev(rs.iterFilterMap(_66, rs.closure((g51: Guard.Guard): Guard.Guard | undefined => { return thenSome$0zvoczk(Guard.id(g51) !== Guard.id(captured46), g51); }, (): void => { captured46[Symbol.dispose](); }))); const captured47 = f; - const m: rt.usize = rt.ownedCount(rt.iterMap(_64, rt.closure((g52: Guard.Guard): rt.u32 => { - const _058: rt.u32 = rt.u32Add(Guard.id(g52), Guard.id(captured47)); + const m: rs.usize = rs.ownedCount(rs.iterMap(_64, rs.closure((g52: Guard.Guard): rs.u32 => { + const _058: rs.u32 = rs.u32Add(Guard.id(g52), Guard.id(captured47)); g52[Symbol.dispose](); return _058; }, (): void => { captured47[Symbol.dispose](); }))); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n2, f), (f: rt.Formatter) => rt.usizeDisplay(m, f)]; - Log.note(log, rt.fmtFormat(["filter ", args4[0], " ", args4[1]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n2, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["filter ", args4[0], " ", args4[1]])); } else if (_23 === 2) { - const _87: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _87: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _775 = false; const captured39 = c; - const _86: rt.Iter = rt.iterInspect(_87, rt.closure((g45: Guard.Guard): undefined => { - const _925: rt.u32 = Guard.id(g45); - const _1136: rt.u32 = Guard.id(captured39); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_925, f), (f: rt.Formatter) => rt.u32Display(_1136, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args82[0], " ", args82[1]])); + const _86: rs.Iter = rs.iterInspect(_87, rs.closure((g45: Guard.Guard): undefined => { + const _925: rs.u32 = Guard.id(g45); + const _1136: rs.u32 = Guard.id(captured39); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_925, f), (f: rs.Formatter) => rs.u32Display(_1136, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args82[0], " ", args82[1]])); }, (): void => { captured39[Symbol.dispose](); })); _774 = false; const captured40 = d; - const n3: rt.usize = rt.ownedCount(rt.iterMap(_86, rt.closure((g46: Guard.Guard): rt.u32 => { - const _053: rt.u32 = rt.u32Add(Guard.id(g46), Guard.id(captured40)); + const n3: rs.usize = rs.ownedCount(rs.iterMap(_86, rs.closure((g46: Guard.Guard): rs.u32 => { + const _053: rs.u32 = rs.u32Add(Guard.id(g46), Guard.id(captured40)); g46[Symbol.dispose](); return _053; }, (): void => { captured40[Symbol.dispose](); }))); const f2: Guard.Guard = guard(13); - const _100: rt.Iter = rt.vecIntoIter(guards(4, 8), rt.drop); + const _100: rs.Iter = rs.vecIntoIter(guards(4, 8), rs.drop); _773 = false; const captured41 = e; - const _98: rt.Iter = rt.iterRev(rt.iterInspect(_100, rt.closure((g47: Guard.Guard): undefined => { - const _926: rt.u32 = Guard.id(g47); - const _1139: rt.u32 = Guard.id(captured41); - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_926, f), (f: rt.Formatter) => rt.u32Display(_1139, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args84[0], " ", args84[1]])); + const _98: rs.Iter = rs.iterRev(rs.iterInspect(_100, rs.closure((g47: Guard.Guard): undefined => { + const _926: rs.u32 = Guard.id(g47); + const _1139: rs.u32 = Guard.id(captured41); + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_926, f), (f: rs.Formatter) => rs.u32Display(_1139, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args84[0], " ", args84[1]])); }, (): void => { captured41[Symbol.dispose](); }))); const captured42 = f2; - const m2: rt.usize = rt.ownedCount(rt.iterMap(_98, rt.closure((g48: Guard.Guard): rt.u32 => { - const _054: rt.u32 = rt.u32Add(Guard.id(g48), Guard.id(captured42)); + const m2: rs.usize = rs.ownedCount(rs.iterMap(_98, rs.closure((g48: Guard.Guard): rs.u32 => { + const _054: rs.u32 = rs.u32Add(Guard.id(g48), Guard.id(captured42)); g48[Symbol.dispose](); return _054; }, (): void => { captured42[Symbol.dispose](); }))); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.usizeDisplay(m2, f)]; - Log.note(log, rt.fmtFormat(["inspect ", args6[0], " ", args6[1]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f)]; + Log.note(log, rs.fmtFormat(["inspect ", args6[0], " ", args6[1]])); } else if (_23 === 3) { - const _122: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _122: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured38 = c; - const _133: [rt.usize, rt.u32] | undefined = option_map$14zg54s(rt.ownedLast(rt.iterRev(rt.iterEnumerate(rt.iterMap(_122, rt.closure((g43: Guard.Guard): Guard.Guard => { - const _924: rt.u32 = Guard.id(g43); - const _1224: rt.u32 = Guard.id(captured38); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_924, f), (f: rt.Formatter) => rt.u32Display(_1224, f)]; - Log.note(log, rt.fmtFormat(["map ", args80[0], " ", args80[1]])); + const _133: [rs.usize, rs.u32] | undefined = option_map$1389p4b(rs.ownedLast(rs.iterRev(rs.iterEnumerate(rs.iterMap(_122, rs.closure((g43: Guard.Guard): Guard.Guard => { + const _924: rs.u32 = Guard.id(g43); + const _1224: rs.u32 = Guard.id(captured38); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_924, f), (f: rs.Formatter) => rs.u32Display(_1224, f)]; + Log.note(log, rs.fmtFormat(["map ", args80[0], " ", args80[1]])); return g43; }, (): void => { captured38[Symbol.dispose](); - })))), lib_drop$tuple2_usize_model_Guard), (_230: [rt.usize, Guard.Guard]): [rt.usize, rt.u32] => { - const i: rt.usize = _230[0]; + })))), lib_drop$tuple2_usize_model_Guard), (_230: [rs.usize, Guard.Guard]): [rs.usize, rs.u32] => { + const i: rs.usize = _230[0]; const g44: Guard.Guard = _230[1]; - const _052: [rt.usize, rt.u32] = [i, Guard.id(g44)]; + const _052: [rs.usize, rs.u32] = [i, Guard.id(g44)]; g44[Symbol.dispose](); return _052; }); - const _135: rt.u32 = Guard.id(d); - const _138: rt.u32 = Guard.id(e); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_133, f, (value: [rt.usize, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.u32Display(_135, f), (f: rt.Formatter) => rt.u32Display(_138, f)]; - Log.note(log, rt.fmtFormat(["enumerate ", args8[0], " ", args8[1], " ", args8[2]])); + const _135: rs.u32 = Guard.id(d); + const _138: rs.u32 = Guard.id(e); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_133, f, (value: [rs.usize, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.u32Display(_135, f), (f: rs.Formatter) => rs.u32Display(_138, f)]; + Log.note(log, rs.fmtFormat(["enumerate ", args8[0], " ", args8[1], " ", args8[2]])); } else if (_23 === 4) { - const _150: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _150: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured36 = c; - const n4: rt.usize = rt.ownedCount(rt.iterRev(rt.iterRev(rt.iterMap(_150, rt.closure((g41: Guard.Guard): rt.u32 => { - const _048: rt.u32 = rt.u32Add(Guard.id(g41), Guard.id(captured36)); + const n4: rs.usize = rs.ownedCount(rs.iterRev(rs.iterRev(rs.iterMap(_150, rs.closure((g41: Guard.Guard): rs.u32 => { + const _048: rs.u32 = rs.u32Add(Guard.id(g41), Guard.id(captured36)); g41[Symbol.dispose](); return _048; }, (): void => { captured36[Symbol.dispose](); }))))); - const _158: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + const _158: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _774 = false; const captured37 = d; - const m3: rt.u32 = rt.iterFold(rt.iterSkip(rt.iterMap(_158, rt.closure((g42: Guard.Guard): rt.u32 => { - const _049: rt.u32 = rt.u32Add(Guard.id(g42), Guard.id(captured37)); + const m3: rs.u32 = rs.iterFold(rs.iterSkip(rs.iterMap(_158, rs.closure((g42: Guard.Guard): rs.u32 => { + const _049: rs.u32 = rs.u32Add(Guard.id(g42), Guard.id(captured37)); g42[Symbol.dispose](); return _049; }, (): void => { captured37[Symbol.dispose](); - })), 1), 0, (n25: rt.u32, k6: rt.u32): rt.u32 => { - return rt.u32Add(n25, k6); + })), 1), 0, (n25: rs.u32, k6: rs.u32): rs.u32 => { + return rs.u32Add(n25, k6); }, true); - const _169: rt.u32 = Guard.id(e); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n4, f), (f: rt.Formatter) => rt.u32Display(m3, f), (f: rt.Formatter) => rt.u32Display(_169, f)]; - Log.note(log, rt.fmtFormat(["twice ", args10[0], " ", args10[1], " ", args10[2]])); + const _169: rs.u32 = Guard.id(e); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.u32Display(m3, f), (f: rs.Formatter) => rs.u32Display(_169, f)]; + Log.note(log, rs.fmtFormat(["twice ", args10[0], " ", args10[1], " ", args10[2]])); } else if (_23 === 5) { - const _183: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _183: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured34 = c; - const _181: rt.Iter = rt.iterStepBy(rt.iterMap(_183, rt.closure((g37: Guard.Guard): Guard.Guard => { - const _922: rt.u32 = Guard.id(g37); - const _1222: rt.u32 = Guard.id(captured34); - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_922, f), (f: rt.Formatter) => rt.u32Display(_1222, f)]; - Log.note(log, rt.fmtFormat(["map ", args78[0], " ", args78[1]])); + const _181: rs.Iter = rs.iterStepBy(rs.iterMap(_183, rs.closure((g37: Guard.Guard): Guard.Guard => { + const _922: rs.u32 = Guard.id(g37); + const _1222: rs.u32 = Guard.id(captured34); + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_922, f), (f: rs.Formatter) => rs.u32Display(_1222, f)]; + Log.note(log, rs.fmtFormat(["map ", args78[0], " ", args78[1]])); return g37; }, (): void => { captured34[Symbol.dispose](); - })), 2, rt.drop); + })), 2, rs.drop); _774 = false; const captured35 = d; - const _199: rt.u32 | undefined = option_map$1raha9y(rt.iterFold(rt.iterMap(_181, rt.closure((g38: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g38, Guard.id(captured35)] as [Guard.Guard, rt.u32]; + const _199: rs.u32 | undefined = option_map$06w9waf(rs.iterFold(rs.iterMap(_181, rs.closure((g38: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g38, Guard.id(captured35)] as [Guard.Guard, rs.u32]; }, (): void => { captured35[Symbol.dispose](); - })), guard(20), (kept7: Guard.Guard | undefined, _347: [Guard.Guard, rt.u32]): Guard.Guard | undefined => { + })), guard(20), (kept7: Guard.Guard | undefined, _347: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { let _046!: Guard.Guard | undefined; let _1223: boolean = false; let _1128: boolean = false; _1223 = true; _1128 = true; const g39: Guard.Guard = _347[0]; - if (!(rt.u32Rem(Guard.id(g39), 2) === 1)) { + if (!(rs.u32Rem(Guard.id(g39), 2) === 1)) { _1223 = false; _046 = kept7; } else { @@ -1156,45 +1156,45 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { } _1128 = false; if (_1223) { - rt.drop(kept7); + rs.drop(kept7); return _046; } return _046; - }, true), (g40: Guard.Guard): rt.u32 => { - const _047: rt.u32 = Guard.id(g40); + }, true), (g40: Guard.Guard): rs.u32 => { + const _047: rs.u32 = Guard.id(g40); g40[Symbol.dispose](); return _047; }); - const _201: rt.u32 = Guard.id(e); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_199, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_201, f)]; - Log.note(log, rt.fmtFormat(["step ", args12[0], " ", args12[1]])); + const _201: rs.u32 = Guard.id(e); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_199, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_201, f)]; + Log.note(log, rs.fmtFormat(["step ", args12[0], " ", args12[1]])); } else if (_23 === 6) { - const _213: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _213: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; const captured32 = c; - const _210: rt.Iter = rt.iterRev(rt.iterStepBy(rt.iterMap(_213, rt.closure((g33: Guard.Guard): Guard.Guard => { - const _920: rt.u32 = Guard.id(g33); - const _1220: rt.u32 = Guard.id(captured32); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_920, f), (f: rt.Formatter) => rt.u32Display(_1220, f)]; - Log.note(log, rt.fmtFormat(["map ", args76[0], " ", args76[1]])); + const _210: rs.Iter = rs.iterRev(rs.iterStepBy(rs.iterMap(_213, rs.closure((g33: Guard.Guard): Guard.Guard => { + const _920: rs.u32 = Guard.id(g33); + const _1220: rs.u32 = Guard.id(captured32); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_920, f), (f: rs.Formatter) => rs.u32Display(_1220, f)]; + Log.note(log, rs.fmtFormat(["map ", args76[0], " ", args76[1]])); return g33; }, (): void => { captured32[Symbol.dispose](); - })), 2, rt.drop)); + })), 2, rs.drop)); _774 = false; const captured33 = d; - const _229: rt.u32 | undefined = option_map$1raha9y(rt.iterFold(rt.iterMap(_210, rt.closure((g34: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g34, Guard.id(captured33)] as [Guard.Guard, rt.u32]; + const _229: rs.u32 | undefined = option_map$06w9waf(rs.iterFold(rs.iterMap(_210, rs.closure((g34: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g34, Guard.id(captured33)] as [Guard.Guard, rs.u32]; }, (): void => { captured33[Symbol.dispose](); - })), guard(20), (kept6: Guard.Guard | undefined, _344: [Guard.Guard, rt.u32]): Guard.Guard | undefined => { + })), guard(20), (kept6: Guard.Guard | undefined, _344: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { let _042!: Guard.Guard | undefined; let _1221: boolean = false; let _1123: boolean = false; _1221 = true; _1123 = true; const g35: Guard.Guard = _344[0]; - if (!(rt.u32Rem(Guard.id(g35), 2) === 1)) { + if (!(rs.u32Rem(Guard.id(g35), 2) === 1)) { _1221 = false; _042 = kept6; } else { @@ -1206,98 +1206,98 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { } _1123 = false; if (_1221) { - rt.drop(kept6); + rs.drop(kept6); return _042; } return _042; - }, true), (g36: Guard.Guard): rt.u32 => { - const _043: rt.u32 = Guard.id(g36); + }, true), (g36: Guard.Guard): rs.u32 => { + const _043: rs.u32 = Guard.id(g36); g36[Symbol.dispose](); return _043; }); - const _231: rt.u32 = Guard.id(e); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_229, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_231, f)]; - Log.note(log, rt.fmtFormat(["step ", args14[0], " ", args14[1]])); + const _231: rs.u32 = Guard.id(e); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_229, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_231, f)]; + Log.note(log, rs.fmtFormat(["step ", args14[0], " ", args14[1]])); } else if (_23 === 7) { - const _241: rt.Iter = rt.vecIntoIter(guards(1, 5), rt.drop); + const _241: rs.Iter = rs.vecIntoIter(guards(1, 5), rs.drop); _775 = false; const captured29 = id; const captured30 = c; - const n5: rt.u32 = rt.iterSum(rt.iterFuse(rt.iterMap(_241, rt.closure((g31: Guard.Guard): rt.u32 => { - const _038: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Sub(Guard.id(g31), captured29), Guard.id(captured30)), Guard.id(captured30)); + const n5: rs.u32 = rs.iterSum(rs.iterFuse(rs.iterMap(_241, rs.closure((g31: Guard.Guard): rs.u32 => { + const _038: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Sub(Guard.id(g31), captured29), Guard.id(captured30)), Guard.id(captured30)); g31[Symbol.dispose](); return _038; }, (): void => { captured30[Symbol.dispose](); - })), true), rt.u32Add, 0, true); - const _250: rt.Iter = rt.vecIntoIter(guards(5, 8), rt.drop); + })), true), rs.u32Add, 0, true); + const _250: rs.Iter = rs.vecIntoIter(guards(5, 8), rs.drop); _774 = false; const captured31 = d; - const m4: rt.usize = rt.ownedCount(rt.iterRev(rt.iterFuse(rt.iterMap(_250, rt.closure((g32: Guard.Guard): rt.u32 => { - const _039: rt.u32 = rt.u32Add(Guard.id(g32), Guard.id(captured31)); + const m4: rs.usize = rs.ownedCount(rs.iterRev(rs.iterFuse(rs.iterMap(_250, rs.closure((g32: Guard.Guard): rs.u32 => { + const _039: rs.u32 = rs.u32Add(Guard.id(g32), Guard.id(captured31)); g32[Symbol.dispose](); return _039; }, (): void => { captured31[Symbol.dispose](); })), true))); - const _261: rt.u32 = Guard.id(e); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n5, f), (f: rt.Formatter) => rt.usizeDisplay(m4, f), (f: rt.Formatter) => rt.u32Display(_261, f)]; - Log.note(log, rt.fmtFormat(["fuse ", args16[0], " ", args16[1], " ", args16[2]])); + const _261: rs.u32 = Guard.id(e); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m4, f), (f: rs.Formatter) => rs.u32Display(_261, f)]; + Log.note(log, rs.fmtFormat(["fuse ", args16[0], " ", args16[1], " ", args16[2]])); } else if (_23 === 8) { - const _273: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _273: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); _775 = false; const captured25 = c; const captured26 = guard; const captured27 = id; - const flat: rt.Iter = rt.iterFlatten(rt.iterMap(_273, rt.closure((g27: Guard.Guard): rt.Vec => { - const _918: rt.u32 = Guard.id(g27); - const _1218: rt.u32 = Guard.id(captured25); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_918, f), (f: rt.Formatter) => rt.u32Display(_1218, f)]; - Log.note(log, rt.fmtFormat(["map ", args74[0], " ", args74[1]])); - const v: rt.Vec = new rt.Vec(); - const _2211: Guard.Guard = captured26(rt.u32Add(rt.u32Sub(Guard.id(g27), captured27), 3)); + const flat: rs.Iter = rs.iterFlatten(rs.iterMap(_273, rs.closure((g27: Guard.Guard): rs.Vec => { + const _918: rs.u32 = Guard.id(g27); + const _1218: rs.u32 = Guard.id(captured25); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_918, f), (f: rs.Formatter) => rs.u32Display(_1218, f)]; + Log.note(log, rs.fmtFormat(["map ", args74[0], " ", args74[1]])); + const v: rs.Vec = new rs.Vec(); + const _2211: Guard.Guard = captured26(rs.u32Add(rs.u32Sub(Guard.id(g27), captured27), 3)); v.items.push(_2211); v.items.push(g27); return v; }, (): void => { captured25[Symbol.dispose](); - })), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); - const part8 = option_map$1raha9y(rt.iterToOption(flat.next()), (g28: Guard.Guard): rt.u32 => { - const _035: rt.u32 = Guard.id(g28); + })), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); + const part8 = option_map$06w9waf(rs.iterToOption(flat.next()), (g28: Guard.Guard): rs.u32 => { + const _035: rs.u32 = Guard.id(g28); g28[Symbol.dispose](); return _035; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["ends ", args18[0]])); - const part9 = option_map$1raha9y(rt.iterToOption(flat.nextBack()), (g29: Guard.Guard): rt.u32 => { - const _036: rt.u32 = Guard.id(g29); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["ends ", args18[0]])); + const part9 = option_map$06w9waf(rs.iterToOption(flat.nextBack()), (g29: Guard.Guard): rs.u32 => { + const _036: rs.u32 = Guard.id(g29); g29[Symbol.dispose](); return _036; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["ends ", args20[0]])); - const _306: rt.Iter = flat; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["ends ", args20[0]])); + const _306: rs.Iter = flat; _774 = false; const captured28 = d; - const n6: rt.usize = rt.ownedCount(rt.iterMap(_306, rt.closure((g30: Guard.Guard): rt.u32 => { - const _037: rt.u32 = rt.u32Add(Guard.id(g30), Guard.id(captured28)); + const n6: rs.usize = rs.ownedCount(rs.iterMap(_306, rs.closure((g30: Guard.Guard): rs.u32 => { + const _037: rs.u32 = rs.u32Add(Guard.id(g30), Guard.id(captured28)); g30[Symbol.dispose](); return _037; }, (): void => { captured28[Symbol.dispose](); }))); - const _314: rt.u32 = Guard.id(e); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n6, f), (f: rt.Formatter) => rt.u32Display(_314, f)]; - Log.note(log, rt.fmtFormat(["flat ", args22[0], " ", args22[1]])); + const _314: rs.u32 = Guard.id(e); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.u32Display(_314, f)]; + Log.note(log, rs.fmtFormat(["flat ", args22[0], " ", args22[1]])); } else if (_23 === 9) { - const _324: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _324: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; const captured22 = c; - const _323: rt.Iter = rt.iterMap(_324, rt.closure((g24: Guard.Guard): Guard.Guard => { - const _916: rt.u32 = Guard.id(g24); - const _1216: rt.u32 = Guard.id(captured22); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_916, f), (f: rt.Formatter) => rt.u32Display(_1216, f)]; - Log.note(log, rt.fmtFormat(["map ", args70[0], " ", args70[1]])); + const _323: rs.Iter = rs.iterMap(_324, rs.closure((g24: Guard.Guard): Guard.Guard => { + const _916: rs.u32 = Guard.id(g24); + const _1216: rs.u32 = Guard.id(captured22); + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_916, f), (f: rs.Formatter) => rs.u32Display(_1216, f)]; + Log.note(log, rs.fmtFormat(["map ", args70[0], " ", args70[1]])); return g24; }, (): void => { captured22[Symbol.dispose](); @@ -1305,17 +1305,17 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { const _329: Guard.Guard | undefined = guard(20); _774 = false; const captured23 = d; - const kept3: Guard.Guard | undefined = rt.iterRfold(_323, _329, rt.closure((kept5: Guard.Guard | undefined, g25: Guard.Guard): Guard.Guard | undefined => { + const kept3: Guard.Guard | undefined = rs.iterRfold(_323, _329, rs.closure((kept5: Guard.Guard | undefined, g25: Guard.Guard): Guard.Guard | undefined => { let _031!: Guard.Guard | undefined; let _304: boolean = false; let _296: boolean = false; _304 = true; _296 = true; - const _1014: rt.u32 = Guard.id(g25); - const _1316: rt.u32 = Guard.id(captured23); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1014, f), (f: rt.Formatter) => rt.u32Display(_1316, f)]; - Log.note(log, rt.fmtFormat(["rfold ", args72[0], " ", args72[1]])); - if (!(rt.u32Rem(Guard.id(g25), 2) === 1)) { + const _1014: rs.u32 = Guard.id(g25); + const _1316: rs.u32 = Guard.id(captured23); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1014, f), (f: rs.Formatter) => rs.u32Display(_1316, f)]; + Log.note(log, rs.fmtFormat(["rfold ", args72[0], " ", args72[1]])); + if (!(rs.u32Rem(Guard.id(g25), 2) === 1)) { _304 = false; _031 = kept5; } else { @@ -1326,71 +1326,71 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { g25[Symbol.dispose](); } if (_304) { - rt.drop(kept5); + rs.drop(kept5); return _031; } return _031; }, (): void => { captured23[Symbol.dispose](); }), true, true); - const _335: rt.Iter = rt.iterSlice([1, 2, 3]); + const _335: rs.Iter = rs.iterSlice([1, 2, 3]); _773 = false; const captured24 = e; - const n7: rt.u32 = rt.iterRfold(_335, 0, rt.closure((n24: rt.u32, _326: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Add(rt.u32Add(rt.u32Mul(n24, 10), _326), Guard.id(captured24)), Guard.id(captured24)); + const n7: rs.u32 = rs.iterRfold(_335, 0, rs.closure((n24: rs.u32, _326: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n24, 10), _326), Guard.id(captured24)), Guard.id(captured24)); }, (): void => { captured24[Symbol.dispose](); }), undefined, true); - const _345: rt.u32 | undefined = option_map$1raha9y(kept3, (g26: Guard.Guard): rt.u32 => { - const _033: rt.u32 = Guard.id(g26); + const _345: rs.u32 | undefined = option_map$06w9waf(kept3, (g26: Guard.Guard): rs.u32 => { + const _033: rs.u32 = Guard.id(g26); g26[Symbol.dispose](); return _033; }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_345, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(n7, f)]; - Log.note(log, rt.fmtFormat(["rfold ", args24[0], " ", args24[1]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_345, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(n7, f)]; + Log.note(log, rs.fmtFormat(["rfold ", args24[0], " ", args24[1]])); } else if (_23 === 10) { - const held: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const held: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; const captured19 = c; const captured20 = id; - const sum: rt.u32 | undefined = rt.iterTryRfold(held, 0, rt.closure((n22: rt.u32, g22: Guard.Guard): rt.u32 | undefined => { - const _1012: rt.u32 = Guard.id(g22); - const _1314: rt.u32 = Guard.id(captured19); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1012, f), (f: rt.Formatter) => rt.u32Display(_1314, f)]; - Log.note(log, rt.fmtFormat(["try ", args68[0], " ", args68[1]])); - const _027: rt.u32 | undefined = then$0ea5h05(Guard.id(g22) !== rt.u32Add(captured20, 3), (): rt.u32 => { - return rt.u32Sub(rt.u32Add(n22, Guard.id(g22)), captured20); + const sum: rs.u32 | undefined = rs.iterTryRfold(held, 0, rs.closure((n22: rs.u32, g22: Guard.Guard): rs.u32 | undefined => { + const _1012: rs.u32 = Guard.id(g22); + const _1314: rs.u32 = Guard.id(captured19); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1012, f), (f: rs.Formatter) => rs.u32Display(_1314, f)]; + Log.note(log, rs.fmtFormat(["try ", args68[0], " ", args68[1]])); + const _027: rs.u32 | undefined = then$0apfzgv(Guard.id(g22) !== rs.u32Add(captured20, 3), (): rs.u32 => { + return rs.u32Sub(rs.u32Add(n22, Guard.id(g22)), captured20); }); g22[Symbol.dispose](); return _027; }, (): void => { captured19[Symbol.dispose](); }), true, true); - const _365: rt.usize = held.len(); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(sum, f, rt.u32Debug), (f: rt.Formatter) => rt.usizeDisplay(_365, f)]; - Log.note(log, rt.fmtFormat(["tried ", args26[0], " ", args26[1]])); + const _365: rs.usize = held.len(); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(sum, f, rs.u32Debug), (f: rs.Formatter) => rs.usizeDisplay(_365, f)]; + Log.note(log, rs.fmtFormat(["tried ", args26[0], " ", args26[1]])); _774 = false; const captured21 = d; - const rest: rt.u32 | undefined = rt.iterTryRfold(held, 0, rt.closure((n23: rt.u32, g23: Guard.Guard): rt.u32 | undefined => { - const _029: rt.u32 | undefined = rt.u32Sub(rt.u32Add(rt.u32Add(n23, Guard.id(g23)), Guard.id(captured21)), Guard.id(captured21)); + const rest: rs.u32 | undefined = rs.iterTryRfold(held, 0, rs.closure((n23: rs.u32, g23: Guard.Guard): rs.u32 | undefined => { + const _029: rs.u32 | undefined = rs.u32Sub(rs.u32Add(rs.u32Add(n23, Guard.id(g23)), Guard.id(captured21)), Guard.id(captured21)); g23[Symbol.dispose](); return _029; }, (): void => { captured21[Symbol.dispose](); }), true, true); - const _382: rt.u32 = Guard.id(e); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(rest, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_382, f)]; - Log.note(log, rt.fmtFormat(["rest ", args28[0], " ", args28[1]])); - rt.drop(held); + const _382: rs.u32 = Guard.id(e); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(rest, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_382, f)]; + Log.note(log, rs.fmtFormat(["rest ", args28[0], " ", args28[1]])); + rs.drop(held); } else if (_23 === 11) { - const _391: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _391: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); _775 = false; const captured16 = c; - const mapped: rt.Iter = rt.iterMap(_391, rt.closure((g19: Guard.Guard): Guard.Guard => { - const _913: rt.u32 = Guard.id(g19); - const _1213: rt.u32 = Guard.id(captured16); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_913, f), (f: rt.Formatter) => rt.u32Display(_1213, f)]; - Log.note(log, rt.fmtFormat(["map ", args66[0], " ", args66[1]])); + const mapped: rs.Iter = rs.iterMap(_391, rs.closure((g19: Guard.Guard): Guard.Guard => { + const _913: rs.u32 = Guard.id(g19); + const _1213: rs.u32 = Guard.id(captured16); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_913, f), (f: rs.Formatter) => rs.u32Display(_1213, f)]; + Log.note(log, rs.fmtFormat(["map ", args66[0], " ", args66[1]])); return g19; }, (): void => { captured16[Symbol.dispose](); @@ -1398,15 +1398,15 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { _774 = false; const captured17 = id; const captured18 = d; - const part5 = result_mapErr$0nvqjog(rt.iterTryRfold(mapped, 0, rt.closure((n21: rt.u32, g20: Guard.Guard): rt.Result => { - let _025!: rt.Result; + const part5 = result_mapErr$18fct1o(rs.iterTryRfold(mapped, 0, rs.closure((n21: rs.u32, g20: Guard.Guard): rs.Result => { + let _025!: rs.Result; let _233: boolean = false; _233 = true; - if (!(Guard.id(g20) === rt.u32Add(captured17, 2))) { - _025 = rt.Ok(rt.u32Sub(rt.u32Add(rt.u32Add(n21, Guard.id(g20)), Guard.id(captured18)), Guard.id(captured18))); + if (!(Guard.id(g20) === rs.u32Add(captured17, 2))) { + _025 = rs.Ok(rs.u32Sub(rs.u32Add(rs.u32Add(n21, Guard.id(g20)), Guard.id(captured18)), Guard.id(captured18))); } else { _233 = false; - _025 = rt.Err(g20); + _025 = rs.Err(g20); } if (_233) { g20[Symbol.dispose](); @@ -1415,31 +1415,31 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { return _025; }, (): void => { captured18[Symbol.dispose](); - }), undefined, true), (g21: Guard.Guard): rt.u32 => { - const _026: rt.u32 = Guard.id(g21); + }), undefined, true), (g21: Guard.Guard): rs.u32 => { + const _026: rs.u32 = Guard.id(g21); g21[Symbol.dispose](); return _026; }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtResult(part5, f, rt.u32Debug, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["tried ", args30[0]])); - rt.drop(mapped); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtResult(part5, f, rs.u32Debug, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["tried ", args30[0]])); + rs.drop(mapped); const part6 = Guard.id(e); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["dropped ", args32[0]])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["dropped ", args32[0]])); } else if (_23 === 12) { - const chained: rt.Iter = rt.iterRev(rt.iterChain(rt.vecIntoIter(guards(1, 3), rt.drop), rt.vecIntoIter(guards(3, 6), rt.drop))); + const chained: rs.Iter = rs.iterRev(rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop))); _775 = false; const captured14 = id; const captured15 = c; - const r2: rt.Result = rt.iterTryRfold(chained, 0, rt.closure((n19: rt.u32, g17: Guard.Guard): rt.Result => { - let _022!: rt.Result; + const r2: rs.Result = rs.iterTryRfold(chained, 0, rs.closure((n19: rs.u32, g17: Guard.Guard): rs.Result => { + let _022!: rs.Result; let _232: boolean = false; _232 = true; - if (!(Guard.id(g17) === rt.u32Add(captured14, 4))) { - _022 = rt.Ok(rt.u32Sub(rt.u32Add(rt.u32Add(n19, Guard.id(g17)), Guard.id(captured15)), Guard.id(captured15))); + if (!(Guard.id(g17) === rs.u32Add(captured14, 4))) { + _022 = rs.Ok(rs.u32Sub(rs.u32Add(rs.u32Add(n19, Guard.id(g17)), Guard.id(captured15)), Guard.id(captured15))); } else { _232 = false; - _022 = rt.Err(g17); + _022 = rs.Err(g17); } if (_232) { g17[Symbol.dispose](); @@ -1456,37 +1456,37 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { broke = Guard.id(g); g[Symbol.dispose](); } - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(broke, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["broke ", args34[0]])); - const n8: rt.Result = rt.iterTryRfold(chained, 0, (n20: rt.u32, g18: Guard.Guard): rt.Result => { - const _023: rt.Result = rt.Ok(rt.u32Sub(rt.u32Add(n20, Guard.id(g18)), id)); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(broke, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["broke ", args34[0]])); + const n8: rs.Result = rs.iterTryRfold(chained, 0, (n20: rs.u32, g18: Guard.Guard): rs.Result => { + const _023: rs.Result = rs.Ok(rs.u32Sub(rs.u32Add(n20, Guard.id(g18)), id)); g18[Symbol.dispose](); return _023; }); - const _461: rt.u32 = Guard.id(d); - const _464: rt.u32 = Guard.id(e); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtControlFlow(n8, f, rt.u32Debug, rt.fmtUnit), (f: rt.Formatter) => rt.u32Display(_461, f), (f: rt.Formatter) => rt.u32Display(_464, f)]; - Log.note(log, rt.fmtFormat(["rest ", args36[0], " ", args36[1], " ", args36[2]])); - rt.drop(chained); + const _461: rs.u32 = Guard.id(d); + const _464: rs.u32 = Guard.id(e); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtControlFlow(n8, f, rs.u32Debug, rs.fmtUnit), (f: rs.Formatter) => rs.u32Display(_461, f), (f: rs.Formatter) => rs.u32Display(_464, f)]; + Log.note(log, rs.fmtFormat(["rest ", args36[0], " ", args36[1], " ", args36[2]])); + rs.drop(chained); } else if (_23 === 13) { - const _474: rt.Iter = rt.vecIntoIter(guards(1, 1), rt.drop); + const _474: rs.Iter = rs.vecIntoIter(guards(1, 1), rs.drop); const _478: Guard.Guard = guard(20); _775 = false; const captured11 = c; - const none: Guard.Guard = rt.iterRfold(_474, _478, rt.closure((acc: Guard.Guard, _316: Guard.Guard): Guard.Guard => { + const none: Guard.Guard = rs.iterRfold(_474, _478, rs.closure((acc: Guard.Guard, _316: Guard.Guard): Guard.Guard => { const part3 = Guard.id(captured11); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["never ", args62[0]])); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["never ", args62[0]])); _316[Symbol.dispose](); return acc; }, (): void => { captured11[Symbol.dispose](); }), true, true); - const _483: rt.Iter = rt.vecIntoIter(guards(1, 1), rt.drop); + const _483: rs.Iter = rs.vecIntoIter(guards(1, 1), rs.drop); _774 = false; const captured12 = d; - const empty: rt.Iter = rt.iterMap(_483, rt.closure((g16: Guard.Guard): rt.u32 => { - const _020: rt.u32 = rt.u32Add(Guard.id(g16), Guard.id(captured12)); + const empty: rs.Iter = rs.iterMap(_483, rs.closure((g16: Guard.Guard): rs.u32 => { + const _020: rs.u32 = rs.u32Add(Guard.id(g16), Guard.id(captured12)); g16[Symbol.dispose](); return _020; }, (): void => { @@ -1494,185 +1494,185 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { })); _773 = false; const captured13 = e; - const tried: rt.u32 | undefined = rt.iterTryRfold(empty, 0, rt.closure((n18: rt.u32, k4: rt.u32): rt.u32 | undefined => { + const tried: rs.u32 | undefined = rs.iterTryRfold(empty, 0, rs.closure((n18: rs.u32, k4: rs.u32): rs.u32 | undefined => { const part4 = Guard.id(captured13); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["never ", args64[0]])); - return rt.u32CheckedAdd(n18, k4); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["never ", args64[0]])); + return rs.u32CheckedAdd(n18, k4); }, (): void => { captured13[Symbol.dispose](); }), true, true); - const _497: rt.u32 = Guard.id(none); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_497, f), (f: rt.Formatter) => rt.fmtOption(tried, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["empty ", args38[0], " ", args38[1]])); - rt.drop(empty); + const _497: rs.u32 = Guard.id(none); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_497, f), (f: rs.Formatter) => rs.fmtOption(tried, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["empty ", args38[0], " ", args38[1]])); + rs.drop(empty); none[Symbol.dispose](); } else if (_23 === 14) { const _507: Pile.Pile = pile(1, 5); _775 = false; const captured7 = c; const captured8 = id; - const _510: (a0: Guard.Guard) => rt.u32 = rt.closure((g13: Guard.Guard): rt.u32 => { - const _910: rt.u32 = Guard.id(g13); - const _1211: rt.u32 = Guard.id(captured7); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_910, f), (f: rt.Formatter) => rt.u32Display(_1211, f)]; - Log.note(log, rt.fmtFormat(["map ", args58[0], " ", args58[1]])); - const _016: rt.u32 = rt.u32Sub(Guard.id(g13), captured8); + const _510: (a0: Guard.Guard) => rs.u32 = rs.closure((g13: Guard.Guard): rs.u32 => { + const _910: rs.u32 = Guard.id(g13); + const _1211: rs.u32 = Guard.id(captured7); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_910, f), (f: rs.Formatter) => rs.u32Display(_1211, f)]; + Log.note(log, rs.fmtFormat(["map ", args58[0], " ", args58[1]])); + const _016: rs.u32 = rs.u32Sub(Guard.id(g13), captured8); g13[Symbol.dispose](); return _016; }, (): void => { captured7[Symbol.dispose](); }); - const part2 = rt.iterFold(rt.iterMap(rt.iterFrom(_507, Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _510), 0, (n17: rt.u32, k3: rt.u32): rt.u32 => { - return rt.u32Add(rt.u32Mul(n17, 10), k3); + const part2 = rs.iterFold(rs.iterMap(rs.iterFrom(_507, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _510), 0, (n17: rs.u32, k3: rs.u32): rs.u32 => { + return rs.u32Add(rs.u32Mul(n17, 10), k3); }, true); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["fold ", args40[0]])); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["fold ", args40[0]])); const _522: Pile.Pile = pile(5, 8); _774 = false; const captured9 = d; - const _525: (a0: Guard.Guard) => undefined = rt.closure((g14: Guard.Guard): undefined => { - const _810: rt.u32 = Guard.id(g14); - const _1112: rt.u32 = Guard.id(captured9); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_810, f), (f: rt.Formatter) => rt.u32Display(_1112, f)]; - Log.note(log, rt.fmtFormat(["each ", args60[0], " ", args60[1]])); + const _525: (a0: Guard.Guard) => undefined = rs.closure((g14: Guard.Guard): undefined => { + const _810: rs.u32 = Guard.id(g14); + const _1112: rs.u32 = Guard.id(captured9); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_810, f), (f: rs.Formatter) => rs.u32Display(_1112, f)]; + Log.note(log, rs.fmtFormat(["each ", args60[0], " ", args60[1]])); g14[Symbol.dispose](); }, (): void => { captured9[Symbol.dispose](); }); - rt.iterForEach(rt.iterFrom(_522, Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _525, true, true); + rs.iterForEach(rs.iterFrom(_522, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _525, true, true); const _528: Pile.Pile = pile(1, 4); _773 = false; const captured10 = e; - const _531: (a0: Guard.Guard) => rt.u32 = rt.closure((g15: Guard.Guard): rt.u32 => { - const _018: rt.u32 = rt.u32Add(Guard.id(g15), Guard.id(captured10)); + const _531: (a0: Guard.Guard) => rs.u32 = rs.closure((g15: Guard.Guard): rs.u32 => { + const _018: rs.u32 = rs.u32Add(Guard.id(g15), Guard.id(captured10)); g15[Symbol.dispose](); return _018; }, (): void => { captured10[Symbol.dispose](); }); - const m5: rt.usize = rt.ownedCount(rt.iterMap(rt.iterFrom(_528, Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _531)); - const _538: rt.usize = Pile.count$iter_Iterator(pile(4, 6)); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(m5, f), (f: rt.Formatter) => rt.usizeDisplay(_538, f)]; - Log.note(log, rt.fmtFormat(["count ", args42[0], " ", args42[1]])); + const m5: rs.usize = rs.ownedCount(rs.iterMap(rs.iterFrom(_528, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), _531)); + const _538: rs.usize = Pile.count$iter_Iterator(pile(4, 6)); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(m5, f), (f: rs.Formatter) => rs.usizeDisplay(_538, f)]; + Log.note(log, rs.fmtFormat(["count ", args42[0], " ", args42[1]])); } else if (_23 === 15) { const last2: Guard.Guard | undefined = Pile.last$iter_Iterator(pile(1, 4)); - const back: Guard.Guard | undefined = rt.ownedLast(rt.iterRev(rt.iterFrom(pile(4, 7), Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })), rt.drop); - const skipped: Guard.Guard | undefined = rt.ownedLast(rt.iterSkip(rt.iterFrom(pile(7, 9), Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), 1, rt.drop), rt.drop); - const _568: rt.u32 | undefined = option_map$1raha9y(last2, (g7: Guard.Guard): rt.u32 => { - const _010: rt.u32 = Guard.id(g7); + const back: Guard.Guard | undefined = rs.ownedLast(rs.iterRev(rs.iterFrom(pile(4, 7), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })), rs.drop); + const skipped: Guard.Guard | undefined = rs.ownedLast(rs.iterSkip(rs.iterFrom(pile(7, 9), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), 1, rs.drop), rs.drop); + const _568: rs.u32 | undefined = option_map$06w9waf(last2, (g7: Guard.Guard): rs.u32 => { + const _010: rs.u32 = Guard.id(g7); g7[Symbol.dispose](); return _010; }); - const _570: rt.u32 | undefined = option_map$1raha9y(back, (g8: Guard.Guard): rt.u32 => { - const _011: rt.u32 = Guard.id(g8); + const _570: rs.u32 | undefined = option_map$06w9waf(back, (g8: Guard.Guard): rs.u32 => { + const _011: rs.u32 = Guard.id(g8); g8[Symbol.dispose](); return _011; }); - const _572: rt.u32 | undefined = option_map$1raha9y(skipped, (g9: Guard.Guard): rt.u32 => { - const _012: rt.u32 = Guard.id(g9); + const _572: rs.u32 | undefined = option_map$06w9waf(skipped, (g9: Guard.Guard): rs.u32 => { + const _012: rs.u32 = Guard.id(g9); g9[Symbol.dispose](); return _012; }); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_568, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_570, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_572, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["last ", args44[0], " ", args44[1], " ", args44[2]])); - const _581: rt.Iter = rt.iterRev(rt.iterFrom(pile(1, 6), Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_568, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_570, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_572, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args44[0], " ", args44[1], " ", args44[2]])); + const _581: rs.Iter = rs.iterRev(rs.iterFrom(pile(1, 6), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })); _775 = false; const captured6 = c; - const _593: rt.u32 | undefined = option_map$1raha9y(rt.iterFold(rt.iterMap(_581, rt.closure((g10: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g10, Guard.id(captured6)] as [Guard.Guard, rt.u32]; + const _593: rs.u32 | undefined = option_map$06w9waf(rs.iterFold(rs.iterMap(_581, rs.closure((g10: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g10, Guard.id(captured6)] as [Guard.Guard, rs.u32]; }, (): void => { captured6[Symbol.dispose](); - })), undefined as Guard.Guard | undefined, (_2: Guard.Guard | undefined, _312: [Guard.Guard, rt.u32]): Guard.Guard | undefined => { + })), undefined as Guard.Guard | undefined, (_2: Guard.Guard | undefined, _312: [Guard.Guard, rs.u32]): Guard.Guard | undefined => { const _014: Guard.Guard | undefined = _312[0]; - rt.drop(_2); + rs.drop(_2); return _014; - }, true), (g12: Guard.Guard): rt.u32 => { - const _015: rt.u32 = Guard.id(g12); + }, true), (g12: Guard.Guard): rs.u32 => { + const _015: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _015; }); - const _595: rt.u32 = Guard.id(d); - const _598: rt.u32 = Guard.id(e); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_593, f, rt.u32Debug), (f: rt.Formatter) => rt.u32Display(_595, f), (f: rt.Formatter) => rt.u32Display(_598, f)]; - Log.note(log, rt.fmtFormat(["rev ", args46[0], " ", args46[1], " ", args46[2]])); + const _595: rs.u32 = Guard.id(d); + const _598: rs.u32 = Guard.id(e); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_593, f, rs.u32Debug), (f: rs.Formatter) => rs.u32Display(_595, f), (f: rs.Formatter) => rs.u32Display(_598, f)]; + Log.note(log, rs.fmtFormat(["rev ", args46[0], " ", args46[1], " ", args46[2]])); } else if (_23 === 16) { const held2: Pile.Pile = pile(1, 6); - const part = option_map$1raha9y(rt.iterNth(rt.iterRev(rt.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) })), 1, rt.drop), (g3: Guard.Guard): rt.u32 => { - const _05: rt.u32 = Guard.id(g3); + const part = option_map$06w9waf(rs.iterNth(rs.iterRev(rs.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) })), 1, rs.drop), (g3: Guard.Guard): rs.u32 => { + const _05: rs.u32 = Guard.id(g3); g3[Symbol.dispose](); return _05; }); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["nth ", args48[0]])); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["nth ", args48[0]])); _775 = false; const captured3 = c; - const n10: rt.u32 = rt.iterFold(rt.iterMap(rt.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) }), rt.closure((g4: Guard.Guard): rt.u32 => { - const _06: rt.u32 = rt.u32Sub(rt.u32Add(Guard.id(g4), Guard.id(captured3)), Guard.id(captured3)); + const n10: rs.u32 = rs.iterFold(rs.iterMap(rs.iterFrom(held2, Pile.next$iter_Iterator, undefined, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)) }), rs.closure((g4: Guard.Guard): rs.u32 => { + const _06: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(g4), Guard.id(captured3)), Guard.id(captured3)); g4[Symbol.dispose](); return _06; }, (): void => { captured3[Symbol.dispose](); - })), 0, (n14: rt.u32, k2: rt.u32): rt.u32 => { - return rt.u32Add(n14, k2); + })), 0, (n14: rs.u32, k2: rs.u32): rs.u32 => { + return rs.u32Add(n14, k2); }, true); - const _635: rt.usize = held2.held.items.length; - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n10, f), (f: rt.Formatter) => rt.usizeDisplay(_635, f)]; - Log.note(log, rt.fmtFormat(["borrowed ", args50[0], " ", args50[1]])); + const _635: rs.usize = held2.held.items.length; + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f), (f: rs.Formatter) => rs.usizeDisplay(_635, f)]; + Log.note(log, rs.fmtFormat(["borrowed ", args50[0], " ", args50[1]])); const _645: Pile.Pile = pile(6, 8); - const _648: rt.Vec = guards(8, 10); - const m6: rt.usize = rt.ownedCount(rt.iterChain(rt.iterFrom(_645, Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), rt.vecIntoIter(_648, rt.drop)), rt.drop); - const _657: rt.u32 = Guard.id(d); - const _660: rt.u32 = Guard.id(e); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(m6, f), (f: rt.Formatter) => rt.u32Display(_657, f), (f: rt.Formatter) => rt.u32Display(_660, f)]; - Log.note(log, rt.fmtFormat(["chain ", args52[0], " ", args52[1], " ", args52[2]])); + const _648: rs.Vec = guards(8, 10); + const m6: rs.usize = rs.ownedCount(rs.iterChain(rs.iterFrom(_645, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), rs.vecIntoIter(_648, rs.drop)), rs.drop); + const _657: rs.u32 = Guard.id(d); + const _660: rs.u32 = Guard.id(e); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(m6, f), (f: rs.Formatter) => rs.u32Display(_657, f), (f: rs.Formatter) => rs.u32Display(_660, f)]; + Log.note(log, rs.fmtFormat(["chain ", args52[0], " ", args52[1], " ", args52[2]])); const _671: [Guard.Guard, Guard.Guard] = [guard(30), guard(31)]; const k: Guard.Guard = _671[0]; const l: Guard.Guard = _671[1]; const _680: Pile.Pile = pile(1, 4); - const _683: rt.Vec = guards(4, 6); - const _679: rt.Iter = rt.iterChain(rt.iterFrom(_680, Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), rt.vecIntoIter(_683, rt.drop)); + const _683: rs.Vec = guards(4, 6); + const _679: rs.Iter = rs.iterChain(rs.iterFrom(_680, Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 }), rs.vecIntoIter(_683, rs.drop)); const captured4 = k; - const n11: rt.u32 = rt.iterFold(_679, 0, rt.closure((n15: rt.u32, g5: Guard.Guard): rt.u32 => { - const _08: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Add(n15, Guard.id(g5)), Guard.id(captured4)), Guard.id(captured4)); + const n11: rs.u32 = rs.iterFold(_679, 0, rs.closure((n15: rs.u32, g5: Guard.Guard): rs.u32 => { + const _08: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(n15, Guard.id(g5)), Guard.id(captured4)), Guard.id(captured4)); g5[Symbol.dispose](); return _08; }, (): void => { captured4[Symbol.dispose](); }), true, true); - const _688: rt.Iter = rt.iterChain(rt.vecIntoIter(guards(1, 3), rt.drop), rt.iterFrom(pile(3, 6), Pile.next$iter_Iterator, rt.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rt.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rt.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rt.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })); + const _688: rs.Iter = rs.iterChain(rs.vecIntoIter(guards(1, 3), rs.drop), rs.iterFrom(pile(3, 6), Pile.next$iter_Iterator, rs.drop, { hint: Pile.sizeHint$iter_Iterator, nth: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nth$iter_Iterator(it, n)), fold: Pile.fold$iter_Iterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32, count: Pile.count$iter_Iterator, last: (it: Pile.Pile) => rs.iterFromOption(Pile.last$iter_Iterator(it)), back: (it: Pile.Pile) => rs.iterFromOption(Pile.nextBack$iter_DoubleEndedIterator(it)), nthBack: (it: Pile.Pile, n) => rs.iterFromOption(Pile.nthBack$iter_DoubleEndedIterator(it, n)), rfold: Pile.rfold$iter_DoubleEndedIterator_Option_u32_boxed_Box_dyn_ops_FnMut_tuple2_Option_u32_model_Guard_Option_u32 })); const captured5 = l; - const r3: rt.u32 = rt.iterRfold(_688, 0, rt.closure((n16: rt.u32, g6: Guard.Guard): rt.u32 => { - const _09: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Add(n16, Guard.id(g6)), Guard.id(captured5)), Guard.id(captured5)); + const r3: rs.u32 = rs.iterRfold(_688, 0, rs.closure((n16: rs.u32, g6: Guard.Guard): rs.u32 => { + const _09: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(n16, Guard.id(g6)), Guard.id(captured5)), Guard.id(captured5)); g6[Symbol.dispose](); return _09; }, (): void => { captured5[Symbol.dispose](); }), true, true); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n11, f), (f: rt.Formatter) => rt.u32Display(r3, f)]; - Log.note(log, rt.fmtFormat(["lent ", args54[0], " ", args54[1]])); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n11, f), (f: rs.Formatter) => rs.u32Display(r3, f)]; + Log.note(log, rs.fmtFormat(["lent ", args54[0], " ", args54[1]])); held2[Symbol.dispose](); } else { const a: Guard.Guard = guard(20); - const _714: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _714: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); const captured = id; const captured2 = a; - rt.iterTryRfold(_714, 0, rt.closure((n13: rt.u32, g2: Guard.Guard): rt.u32 | undefined => { - if (!(Guard.id(g2) !== rt.u32Add(captured, 3))) { - const _145: rt.u32 = Guard.id(g2); - const _172: rt.u32 = Guard.id(captured2); - const _202: string = rt.resultUnwrap(rt.stringFromUtf8(Log.text(log)), rt.fmtFromUtf8ErrorDebug); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_145, f), (f: rt.Formatter) => rt.u32Display(_172, f), (f: rt.Formatter) => rt.fmtPad(f, _202)]; - rt.panicFmt(["try_rfold of g", args56[0], " with g", args56[1], " after\n", args56[2]]); + rs.iterTryRfold(_714, 0, rs.closure((n13: rs.u32, g2: Guard.Guard): rs.u32 | undefined => { + if (!(Guard.id(g2) !== rs.u32Add(captured, 3))) { + const _145: rs.u32 = Guard.id(g2); + const _172: rs.u32 = Guard.id(captured2); + const _202: string = rs.resultUnwrap(rs.stringFromUtf8(Log.text(log)), rs.fmtFromUtf8ErrorDebug); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_145, f), (f: rs.Formatter) => rs.u32Display(_172, f), (f: rs.Formatter) => rs.fmtPad(f, _202)]; + rs.panicFmt(["try_rfold of g", args56[0], " with g", args56[1], " after\n", args56[2]]); } else { - const _04: rt.u32 | undefined = rt.u32Add(n13, Guard.id(g2)); + const _04: rs.u32 | undefined = rs.u32Add(n13, Guard.id(g2)); g2[Symbol.dispose](); return _04; } }, (): void => { captured2[Symbol.dispose](); }), true, true); - rt.drop(_714); + rs.drop(_714); } if (_773) { e[Symbol.dispose](); @@ -1689,96 +1689,96 @@ export function rfolded(log: Log.Log, id: rt.u32, arg: rt.u8): void { } /** `last` and `min` of `Option`s, by what drops: a `None` item apart from no items. */ -export function options(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function options(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _10: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12)]; const c: Guard.Guard = _10[0]; const d: Guard.Guard = _10[1]; const e: Guard.Guard = _10[2]; - const _22: rt.Iter = rt.vecIntoIter(guards(1, 4), rt.drop); + const _22: rs.Iter = rs.vecIntoIter(guards(1, 4), rs.drop); const captured = c; - const odd: rt.u32 | undefined | rt.None = rt.ownedLast(rt.iterMap(_22, rt.closure((g: Guard.Guard): rt.u32 | undefined => { - const _03: rt.u32 | undefined = thenSome$1af3oea(rt.u32Rem(Guard.id(g), 2) === rt.u32Rem(Guard.id(captured), 2), Guard.id(g)); + const odd: rs.u32 | undefined | rs.None = rs.ownedLast(rs.iterMap(_22, rs.closure((g: Guard.Guard): rs.u32 | undefined => { + const _03: rs.u32 | undefined = thenSome$1bahm2u(rs.u32Rem(Guard.id(g), 2) === rs.u32Rem(Guard.id(captured), 2), Guard.id(g)); g[Symbol.dispose](); return _03; }, (): void => { captured[Symbol.dispose](); - })), undefined, rt.None); - const _29: rt.Iter = rt.vecIntoIter(guards(4, 4), rt.drop); + })), undefined, rs.None); + const _29: rs.Iter = rs.vecIntoIter(guards(4, 4), rs.drop); const captured2 = d; - const none: rt.u32 | undefined | rt.None = rt.ownedLast(rt.iterMap(_29, rt.closure((g2: Guard.Guard): rt.u32 | undefined => { - const _04: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g2) !== Guard.id(captured2), Guard.id(g2)); + const none: rs.u32 | undefined | rs.None = rs.ownedLast(rs.iterMap(_29, rs.closure((g2: Guard.Guard): rs.u32 | undefined => { + const _04: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g2) !== Guard.id(captured2), Guard.id(g2)); g2[Symbol.dispose](); return _04; }, (): void => { captured2[Symbol.dispose](); - })), undefined, rt.None); - const _36: rt.Iter = rt.vecIntoIter(guards(4, 4), rt.drop); + })), undefined, rs.None); + const _36: rs.Iter = rs.vecIntoIter(guards(4, 4), rs.drop); const captured3 = e; - const least: rt.u32 | undefined | rt.None = rt.iterMin(rt.iterMap(_36, rt.closure((g3: Guard.Guard): rt.u32 | undefined => { - const _05: rt.u32 | undefined = thenSome$1af3oea(Guard.id(g3) !== Guard.id(captured3), Guard.id(g3)); + const least: rs.u32 | undefined | rs.None = rs.iterMin(rs.iterMap(_36, rs.closure((g3: Guard.Guard): rs.u32 | undefined => { + const _05: rs.u32 | undefined = thenSome$1bahm2u(Guard.id(g3) !== Guard.id(captured3), Guard.id(g3)); g3[Symbol.dispose](); return _05; }, (): void => { captured3[Symbol.dispose](); - })), rt.cmpLt(rt.cmpOption(rt.cmp)), true, undefined, rt.None); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(odd, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(none, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(least, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["options ", args2[0], " ", args2[1], " ", args2[2]])); + })), rs.cmpLt(rs.cmpOption(rs.cmp)), true, undefined, rs.None); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(odd, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(none, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(least, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["options ", args2[0], " ", args2[1], " ", args2[2]])); } /** * `max_by`, `min_by`, and `reduce` of items that drop, by what drops when: each loser as * it loses, and the iterator with the closure it holds once it ends, at once if empty. */ -export function reducers(log: Log.Log, id: rt.u32): void { - const _41: (a0: Guard.Guard | undefined) => rt.u32 | undefined = (g: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(g, (g2: Guard.Guard): rt.u32 => { - const _02: rt.u32 = Guard.id(g2); +export function reducers(log: Log.Log, id: rs.u32): void { + const _41: (a0: Guard.Guard | undefined) => rs.u32 | undefined = (g: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(g, (g2: Guard.Guard): rs.u32 => { + const _02: rs.u32 = Guard.id(g2); g2[Symbol.dispose](); return _02; }); }; - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _9: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; const c: Guard.Guard = _9[0]; const d: Guard.Guard = _9[1]; - const _18: rt.Iter = rt.vecIntoIter(guards(1, 6), rt.drop); + const _18: rs.Iter = rs.vecIntoIter(guards(1, 6), rs.drop); const captured = c; - const most: Guard.Guard | undefined = rt.iterMaxBy(rt.iterMap(_18, rt.closure((g3: Guard.Guard): Guard.Guard => { - const _92: rt.u32 = Guard.id(g3); - const _122: rt.u32 = Guard.id(captured); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_92, f), (f: rt.Formatter) => rt.u32Display(_122, f)]; - Log.note(log, rt.fmtFormat(["map ", args6[0], " ", args6[1]])); + const most: Guard.Guard | undefined = rs.iterMaxBy(rs.iterMap(_18, rs.closure((g3: Guard.Guard): Guard.Guard => { + const _92: rs.u32 = Guard.id(g3); + const _122: rs.u32 = Guard.id(captured); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_122, f)]; + Log.note(log, rs.fmtFormat(["map ", args6[0], " ", args6[1]])); return g3; }, (): void => { captured[Symbol.dispose](); - })), (a: Guard.Guard, b: Guard.Guard): rt.Ordering => { - return rt.cmp(rt.u32Rem(Guard.id(a), 2), rt.u32Rem(Guard.id(b), 2)); - }, true, rt.drop); - const least: Guard.Guard | undefined = rt.iterMinBy(rt.vecIntoIter(guards(1, 6), rt.drop), (a2: Guard.Guard, b2: Guard.Guard): rt.Ordering => { - return rt.cmp(rt.u32Rem(Guard.id(a2), 3), rt.u32Rem(Guard.id(b2), 3)); - }, true, rt.drop); - const kept: Guard.Guard | undefined = rt.iterReduce(rt.vecIntoIter(guards(1, 4), rt.drop), (a3: Guard.Guard, b3: Guard.Guard): Guard.Guard => { + })), (a: Guard.Guard, b: Guard.Guard): rs.Ordering => { + return rs.cmp(rs.u32Rem(Guard.id(a), 2), rs.u32Rem(Guard.id(b), 2)); + }, true, rs.drop); + const least: Guard.Guard | undefined = rs.iterMinBy(rs.vecIntoIter(guards(1, 6), rs.drop), (a2: Guard.Guard, b2: Guard.Guard): rs.Ordering => { + return rs.cmp(rs.u32Rem(Guard.id(a2), 3), rs.u32Rem(Guard.id(b2), 3)); + }, true, rs.drop); + const kept: Guard.Guard | undefined = rs.iterReduce(rs.vecIntoIter(guards(1, 4), rs.drop), (a3: Guard.Guard, b3: Guard.Guard): Guard.Guard => { let _08!: Guard.Guard; let _292: boolean = false; let _28: boolean = false; _292 = true; _28 = true; - const _104: rt.u32 = Guard.id(a3); - const _132: rt.u32 = Guard.id(b3); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_104, f), (f: rt.Formatter) => rt.u32Display(_132, f)]; - Log.note(log, rt.fmtFormat(["reduce ", args8[0], " ", args8[1]])); - if (!(rt.u32Rem(Guard.id(b3), 2) === 0)) { + const _104: rs.u32 = Guard.id(a3); + const _132: rs.u32 = Guard.id(b3); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_104, f), (f: rs.Formatter) => rs.u32Display(_132, f)]; + Log.note(log, rs.fmtFormat(["reduce ", args8[0], " ", args8[1]])); + if (!(rs.u32Rem(Guard.id(b3), 2) === 0)) { _292 = false; _08 = a3; } else { @@ -1794,35 +1794,35 @@ export function reducers(log: Log.Log, id: rt.u32): void { } return _08; }, true); - const _36: rt.Iter = rt.vecIntoIter(guards(4, 4), rt.drop); + const _36: rs.Iter = rs.vecIntoIter(guards(4, 4), rs.drop); const captured2 = d; - const none: rt.u32 | undefined = rt.iterReduce(rt.iterMap(_36, rt.closure((g4: Guard.Guard): rt.u32 => { - const _09: rt.u32 = rt.u32Add(Guard.id(g4), Guard.id(captured2)); + const none: rs.u32 | undefined = rs.iterReduce(rs.iterMap(_36, rs.closure((g4: Guard.Guard): rs.u32 => { + const _09: rs.u32 = rs.u32Add(Guard.id(g4), Guard.id(captured2)); g4[Symbol.dispose](); return _09; }, (): void => { captured2[Symbol.dispose](); - })), (a4: rt.u32, b4: rt.u32): rt.u32 => { - return rt.u32Add(a4, b4); + })), (a4: rs.u32, b4: rs.u32): rs.u32 => { + return rs.u32Add(a4, b4); }, true); - const _48: rt.u32 | undefined = _41(most); - const _52: rt.u32 | undefined = _41(least); - const _56: rt.u32 | undefined = _41(kept); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_48, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_52, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(_56, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtOption(none, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["reducers ", args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); - const _69: [rt.Vec, Guard.Guard] = [guards(1, 3), guard(12)]; - const held: rt.Vec = _69[0]; + const _48: rs.u32 | undefined = _41(most); + const _52: rs.u32 | undefined = _41(least); + const _56: rs.u32 | undefined = _41(kept); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_48, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_52, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(_56, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtOption(none, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["reducers ", args2[0], " ", args2[1], " ", args2[2], " ", args2[3]])); + const _69: [rs.Vec, Guard.Guard] = [guards(1, 3), guard(12)]; + const held: rs.Vec = _69[0]; const e: Guard.Guard = _69[1]; - const _77: rt.Iter = rt.iterSlice(held.items); + const _77: rs.Iter = rs.iterSlice(held.items); const captured3 = e; - const part = option_map$0lq7mno(rt.iterMinBy(_77, rt.closure((a5: Guard.Guard, b5: Guard.Guard): rt.Ordering => { - return rt.cmp(rt.u32Add(Guard.id(a5), Guard.id(captured3)), rt.u32Add(Guard.id(b5), Guard.id(captured3))); + const part = option_map$02u0dmi(rs.iterMinBy(_77, rs.closure((a5: Guard.Guard, b5: Guard.Guard): rs.Ordering => { + return rs.cmp(rs.u32Add(Guard.id(a5), Guard.id(captured3)), rs.u32Add(Guard.id(b5), Guard.id(captured3))); }, (): void => { captured3[Symbol.dispose](); }), undefined, undefined, true), Guard.id); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["first ", args4[0]])); - rt.dropVec(held); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["first ", args4[0]])); + rs.dropVec(held); } /** @@ -1830,12 +1830,12 @@ export function reducers(log: Log.Log, id: rt.u32): void { * an item: each drops what it rejects as it returns, and with its adaptor, after the * source it reads. */ -export function closures(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); +export function closures(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; const _12: [Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12), guard(13), guard(14)]; const c: Guard.Guard = _12[0]; @@ -1843,13 +1843,13 @@ export function closures(log: Log.Log, id: rt.u32): void { const e: Guard.Guard = _12[2]; const f: Guard.Guard = _12[3]; const h: Guard.Guard = _12[4]; - const pick: (a0: Guard.Guard) => Guard.Guard | undefined | rt.None = (g: Guard.Guard): Guard.Guard | undefined | rt.None => { - let _03!: Guard.Guard | undefined | rt.None; + const pick: (a0: Guard.Guard) => Guard.Guard | undefined | rs.None = (g: Guard.Guard): Guard.Guard | undefined | rs.None => { + let _03!: Guard.Guard | undefined | rs.None; let _142: boolean = false; _142 = true; - const _35: rt.u32 = rt.u32Rem(rt.u32Sub(Guard.id(g), id), 3); + const _35: rs.u32 = rs.u32Rem(rs.u32Sub(Guard.id(g), id), 3); if (_35 === 0) { - _03 = rt.None; + _03 = rs.None; } else if (_35 === 1) { _03 = undefined; } else { @@ -1862,163 +1862,163 @@ export function closures(log: Log.Log, id: rt.u32): void { } return _03; }; - const _33: rt.Iter = rt.vecIntoIter(guards(1, 7), rt.drop); + const _33: rs.Iter = rs.vecIntoIter(guards(1, 7), rs.drop); const captured = c; const captured2 = pick; - const part2 = rt.iterToVec(rt.iterMap(rt.iterFilterMap(_33, rt.closure((g2: Guard.Guard): Guard.Guard | undefined | rt.None => { - const _92: rt.u32 = Guard.id(g2); - const _127: rt.u32 = Guard.id(captured); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_92, f), (f: rt.Formatter) => rt.u32Display(_127, f)]; - Log.note(log, rt.fmtFormat(["filter_map ", args16[0], " ", args16[1]])); + const part2 = rs.iterToVec(rs.iterMap(rs.iterFilterMap(_33, rs.closure((g2: Guard.Guard): Guard.Guard | undefined | rs.None => { + const _92: rs.u32 = Guard.id(g2); + const _127: rs.u32 = Guard.id(captured); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_92, f), (f: rs.Formatter) => rs.u32Display(_127, f)]; + Log.note(log, rs.fmtFormat(["filter_map ", args16[0], " ", args16[1]])); return captured2(g2); }, (): void => { captured[Symbol.dispose](); - }), rt.None), (o: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o, (g3: Guard.Guard): rt.u32 => { - const _06: rt.u32 = Guard.id(g3); + }), rs.None), (o: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o, (g3: Guard.Guard): rs.u32 => { + const _06: rs.u32 = Guard.id(g3); g3[Symbol.dispose](); return _06; }); }), "next", 8, false, 8); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug))]; - Log.note(log, rt.fmtFormat(["kept ", args2[0]])); - const part3 = rt.iterFold(rt.iterFilterMap(rt.vecIntoIter(guards(1, 7), rt.drop), pick, rt.None), 0, (n3: rt.u32, o2: Guard.Guard | undefined): rt.u32 => { - return rt.u32Add(rt.u32Mul(n3, 10), option_mapOr$01ozsk3(o2, 9, (g4: Guard.Guard): rt.u32 => { - const _08: rt.u32 = rt.u32Sub(Guard.id(g4), id); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug))]; + Log.note(log, rs.fmtFormat(["kept ", args2[0]])); + const part3 = rs.iterFold(rs.iterFilterMap(rs.vecIntoIter(guards(1, 7), rs.drop), pick, rs.None), 0, (n3: rs.u32, o2: Guard.Guard | undefined): rs.u32 => { + return rs.u32Add(rs.u32Mul(n3, 10), option_mapOr$1re20rq(o2, 9, (g4: Guard.Guard): rs.u32 => { + const _08: rs.u32 = rs.u32Sub(Guard.id(g4), id); g4[Symbol.dispose](); return _08; })); }, true); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["folded ", args4[0]])); - const _67: rt.Iter = rt.vecIntoIter(guards(4, 8), rt.drop); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["folded ", args4[0]])); + const _67: rs.Iter = rs.vecIntoIter(guards(4, 8), rs.drop); const captured3 = d; const captured4 = pick; - const whiles: rt.Iter = rt.iterMapWhile(_67, rt.closure((g5: Guard.Guard): Guard.Guard | undefined | rt.None => { - const _93: rt.u32 = Guard.id(g5); - const _128: rt.u32 = Guard.id(captured3); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_93, f), (f: rt.Formatter) => rt.u32Display(_128, f)]; - Log.note(log, rt.fmtFormat(["map_while ", args18[0], " ", args18[1]])); + const whiles: rs.Iter = rs.iterMapWhile(_67, rs.closure((g5: Guard.Guard): Guard.Guard | undefined | rs.None => { + const _93: rs.u32 = Guard.id(g5); + const _128: rs.u32 = Guard.id(captured3); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_93, f), (f: rs.Formatter) => rs.u32Display(_128, f)]; + Log.note(log, rs.fmtFormat(["map_while ", args18[0], " ", args18[1]])); return captured4(g5); }, (): void => { captured3[Symbol.dispose](); - }), rt.None); - const first: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(whiles.next(), rt.None), (o3: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o3, (g6: Guard.Guard): rt.u32 => { - const _011: rt.u32 = Guard.id(g6); + }), rs.None); + const first: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(whiles.next(), rs.None), (o3: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o3, (g6: Guard.Guard): rs.u32 => { + const _011: rs.u32 = Guard.id(g6); g6[Symbol.dispose](); return _011; }); }); - const second: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(whiles.next(), rt.None), (o4: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o4, (g7: Guard.Guard): rt.u32 => { - const _013: rt.u32 = Guard.id(g7); + const second: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(whiles.next(), rs.None), (o4: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o4, (g7: Guard.Guard): rs.u32 => { + const _013: rs.u32 = Guard.id(g7); g7[Symbol.dispose](); return _013; }); }); - rt.drop(whiles); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(second, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["whiles ", args6[0], " ", args6[1]])); - const _94: rt.Iter = rt.vecIntoIter(guards(3, 7), rt.drop); + rs.drop(whiles); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["whiles ", args6[0], " ", args6[1]])); + const _94: rs.Iter = rs.vecIntoIter(guards(3, 7), rs.drop); const captured5 = e; const captured6 = pick; - const _98: (a0: Guard.Guard) => Guard.Guard | undefined | rt.None = rt.closure((g8: Guard.Guard): Guard.Guard | undefined | rt.None => { - const _96: rt.u32 = Guard.id(g8); - const _1210: rt.u32 = Guard.id(captured5); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_96, f), (f: rt.Formatter) => rt.u32Display(_1210, f)]; - Log.note(log, rt.fmtFormat(["find_map ", args20[0], " ", args20[1]])); + const _98: (a0: Guard.Guard) => Guard.Guard | undefined | rs.None = rs.closure((g8: Guard.Guard): Guard.Guard | undefined | rs.None => { + const _96: rs.u32 = Guard.id(g8); + const _1210: rs.u32 = Guard.id(captured5); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_96, f), (f: rs.Formatter) => rs.u32Display(_1210, f)]; + Log.note(log, rs.fmtFormat(["find_map ", args20[0], " ", args20[1]])); return captured6(g8); }, (): void => { captured5[Symbol.dispose](); }); - const found: Guard.Guard | undefined | rt.None = rt.dropAfter(_98, () => rt.iterFindMap(_94, _98, rt.None)); - rt.drop(_94); - const part6 = option_map$0ccnsmq(found, (o5: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o5, (g9: Guard.Guard): rt.u32 => { - const _016: rt.u32 = Guard.id(g9); + const found: Guard.Guard | undefined | rs.None = rs.dropAfter(_98, () => rs.iterFindMap(_94, _98, rs.None)); + rs.drop(_94); + const part6 = option_map$1x5kkz1(found, (o5: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o5, (g9: Guard.Guard): rs.u32 => { + const _016: rs.u32 = Guard.id(g9); g9[Symbol.dispose](); return _016; }); }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["found ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["found ", args8[0]])); let captured7 = guards(1, 6); const captured8 = f; - const made: rt.Iter = rt.iterFromFn(rt.closure((): Guard.Guard | undefined | rt.None => { - const _310: Guard.Guard | undefined = rt.vecPop(captured7); + const made: rs.Iter = rs.iterFromFn(rs.closure((): Guard.Guard | undefined | rs.None => { + const _310: Guard.Guard | undefined = rs.vecPop(captured7); if (_310 !== undefined) { const g10: Guard.Guard = _310; - const _144: rt.u32 = Guard.id(g10); - const _177: rt.u32 = Guard.id(captured8); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_144, f), (f: rt.Formatter) => rt.u32Display(_177, f)]; - Log.note(log, rt.fmtFormat(["from_fn ", args22[0], " ", args22[1]])); - return thenSome$0zvoczk(rt.u32Rem(Guard.id(g10), 2) === 0, g10); + const _144: rs.u32 = Guard.id(g10); + const _177: rs.u32 = Guard.id(captured8); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_144, f), (f: rs.Formatter) => rs.u32Display(_177, f)]; + Log.note(log, rs.fmtFormat(["from_fn ", args22[0], " ", args22[1]])); + return thenSome$0zvoczk(rs.u32Rem(Guard.id(g10), 2) === 0, g10); } - return rt.None; + return rs.None; }, (): void => { - rt.dropVec(captured7); + rs.dropVec(captured7); captured8[Symbol.dispose](); - }), rt.None); - const first2: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(made.next(), rt.None), (o6: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o6, (g11: Guard.Guard): rt.u32 => { - const _019: rt.u32 = Guard.id(g11); + }), rs.None); + const first2: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(made.next(), rs.None), (o6: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o6, (g11: Guard.Guard): rs.u32 => { + const _019: rs.u32 = Guard.id(g11); g11[Symbol.dispose](); return _019; }); }); - const second2: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(made.next(), rt.None), (o7: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o7, (g12: Guard.Guard): rt.u32 => { - const _021: rt.u32 = Guard.id(g12); + const second2: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(made.next(), rs.None), (o7: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o7, (g12: Guard.Guard): rs.u32 => { + const _021: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _021; }); }); - rt.drop(made); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(second2, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["made ", args10[0], " ", args10[1]])); + rs.drop(made); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second2, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["made ", args10[0], " ", args10[1]])); const captured9 = id; const captured10 = h; - const walked: rt.Iter = rt.iterSuccessors(undefined as Guard.Guard | undefined | rt.None, rt.closure((prev: Guard.Guard | undefined): Guard.Guard | undefined | rt.None => { - const next: rt.u32 = option_mapOr$01ozsk3(prev, 5, (g13: Guard.Guard): rt.u32 => { - return rt.u32Add(rt.u32Sub(Guard.id(g13), captured9), 1); + const walked: rs.Iter = rs.iterSuccessors(undefined as Guard.Guard | undefined | rs.None, rs.closure((prev: Guard.Guard | undefined): Guard.Guard | undefined | rs.None => { + const next: rs.u32 = option_mapOr$1re20rq(prev, 5, (g13: Guard.Guard): rs.u32 => { + return rs.u32Add(rs.u32Sub(Guard.id(g13), captured9), 1); }); - const _1310: rt.u32 = Guard.id(captured10); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(next, f), (f: rt.Formatter) => rt.u32Display(_1310, f)]; - Log.note(log, rt.fmtFormat(["successors ", args24[0], " ", args24[1]])); - return then$06wuxll(next < 8, (): Guard.Guard | undefined => { - return Guard.new(rt.u32Add(captured9, next), Log.clone$Clone(log)); + const _1310: rs.u32 = Guard.id(captured10); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(next, f), (f: rs.Formatter) => rs.u32Display(_1310, f)]; + Log.note(log, rs.fmtFormat(["successors ", args24[0], " ", args24[1]])); + return then$0frk932(next < 8, (): Guard.Guard | undefined => { + return Guard.new(rs.u32Add(captured9, next), Log.clone$Clone(log)); }); }, (): void => { captured10[Symbol.dispose](); - }), rt.drop, rt.None); - const first3: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(walked.next(), rt.None), (o8: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o8, (g14: Guard.Guard): rt.u32 => { - const _026: rt.u32 = Guard.id(g14); + }), rs.drop, rs.None); + const first3: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(walked.next(), rs.None), (o8: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o8, (g14: Guard.Guard): rs.u32 => { + const _026: rs.u32 = Guard.id(g14); g14[Symbol.dispose](); return _026; }); }); - const second3: rt.u32 | undefined | rt.None = option_map$0ccnsmq(rt.iterToOption(walked.next(), rt.None), (o9: Guard.Guard | undefined): rt.u32 | undefined => { - return option_map$1raha9y(o9, (g15: Guard.Guard): rt.u32 => { - const _028: rt.u32 = Guard.id(g15); + const second3: rs.u32 | undefined | rs.None = option_map$1x5kkz1(rs.iterToOption(walked.next(), rs.None), (o9: Guard.Guard | undefined): rs.u32 | undefined => { + return option_map$06w9waf(o9, (g15: Guard.Guard): rs.u32 => { + const _028: rs.u32 = Guard.id(g15); g15[Symbol.dispose](); return _028; }); }); - rt.drop(walked); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(first3, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None), (f: rt.Formatter) => rt.fmtOption(second3, f, (value: rt.u32 | undefined, f: rt.Formatter) => rt.fmtOption(value, f, rt.u32Debug), rt.None)]; - Log.note(log, rt.fmtFormat(["walked ", args12[0], " ", args12[1]])); - const part7 = rt.ownedCount(rt.iterSuccessors(undefined as Guard.Guard | undefined | rt.None, (prev2: Guard.Guard | undefined): Guard.Guard | undefined | rt.None => { - const next2: rt.u32 = option_mapOr$01ozsk3(prev2, 5, (g16: Guard.Guard): rt.u32 => { - return rt.u32Add(rt.u32Sub(Guard.id(g16), id), 1); + rs.drop(walked); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(first3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None), (f: rs.Formatter) => rs.fmtOption(second3, f, (value: rs.u32 | undefined, f: rs.Formatter) => rs.fmtOption(value, f, rs.u32Debug), rs.None)]; + Log.note(log, rs.fmtFormat(["walked ", args12[0], " ", args12[1]])); + const part7 = rs.ownedCount(rs.iterSuccessors(undefined as Guard.Guard | undefined | rs.None, (prev2: Guard.Guard | undefined): Guard.Guard | undefined | rs.None => { + const next2: rs.u32 = option_mapOr$1re20rq(prev2, 5, (g16: Guard.Guard): rs.u32 => { + return rs.u32Add(rs.u32Sub(Guard.id(g16), id), 1); }); - return then$06wuxll(next2 < 8, (): Guard.Guard | undefined => { - return Guard.new(rt.u32Add(id, next2), Log.clone$Clone(log)); + return then$0frk932(next2 < 8, (): Guard.Guard | undefined => { + return Guard.new(rs.u32Add(id, next2), Log.clone$Clone(log)); }); - }, rt.drop, rt.None), rt.drop); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; - Log.note(log, rt.fmtFormat(["walked ", args14[0]])); + }, rs.drop, rs.None), rs.drop); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; + Log.note(log, rs.fmtFormat(["walked ", args14[0]])); } /** @@ -2028,167 +2028,167 @@ export function closures(log: Log.Log, id: rt.u32): void { * `TrustedRandomAccessNoCoerce`, folds no pair past its size hint, and drops the rest with * itself, where `try_fold` and `next` read the first side once more and drop that item. */ -export function zips(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const guard: (a0: rt.u32) => Guard.Guard = (n7: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n7), Log.clone$Clone(log)); +export function zips(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const guard: (a0: rs.u32) => Guard.Guard = (n7: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n7), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), guard), undefined, 8, true); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), guard), undefined, 8, true); }; - const made: (a0: rt.u32) => Guard.Guard = (n8: rt.u32): Guard.Guard => { - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n8, f)]; - Log.note(log, rt.fmtFormat(["make ", args20[0]])); + const made: (a0: rs.u32) => Guard.Guard = (n8: rs.u32): Guard.Guard => { + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f)]; + Log.note(log, rs.fmtFormat(["make ", args20[0]])); return guard(n8); }; - const ids: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rt.u32, rt.u32] | undefined = (p: [Guard.Guard, Guard.Guard] | undefined): [rt.u32, rt.u32] | undefined => { - return option_map$01pvlgn(p, (_2: [Guard.Guard, Guard.Guard]): [rt.u32, rt.u32] => { + const ids: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rs.u32, rs.u32] | undefined = (p: [Guard.Guard, Guard.Guard] | undefined): [rs.u32, rs.u32] | undefined => { + return option_map$0j32j8c(p, (_2: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { const a: Guard.Guard = _2[0]; const b: Guard.Guard = _2[1]; - const _05: [rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a), id), rt.u32Sub(Guard.id(b), id)]; + const _05: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a), id), rs.u32Sub(Guard.id(b), id)]; b[Symbol.dispose](); a[Symbol.dispose](); return _05; }); }; if (arg === 0) { - const n: rt.usize = rt.ownedCount(rt.iterZip(rt.iterMap(new rt.Range(1, 4), made), rt.iterMap(new rt.Range(4, 6), made), [true, true], rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const part8 = rt.iterNth(rt.iterZip(rt.iterMap(new rt.Range(1, 4), made), rt.iterMap(new rt.Range(4, 7), made), [true, true], rt.drop, rt.drop), 1, lib_drop$tuple2_model_Guard_model_Guard); - const nth: [rt.u32, rt.u32] | undefined = ids(part8); - const part9 = rt.iterNth(rt.iterZip(rt.iterMap(new rt.Range(1, 3), made), rt.iterMap(new rt.Range(3, 6), made), [true, true], rt.drop, rt.drop), 3, lib_drop$tuple2_model_Guard_model_Guard); - const past: [rt.u32, rt.u32] | undefined = ids(part9); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n, f), (f: rt.Formatter) => rt.fmtOption(nth, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(past, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["index ", args2[0], " ", args2[1], " ", args2[2]])); + const n: rs.usize = rs.ownedCount(rs.iterZip(rs.iterMap(new rs.Range(1, 4), made), rs.iterMap(new rs.Range(4, 6), made), [true, true], rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const part8 = rs.iterNth(rs.iterZip(rs.iterMap(new rs.Range(1, 4), made), rs.iterMap(new rs.Range(4, 7), made), [true, true], rs.drop, rs.drop), 1, lib_drop$tuple2_model_Guard_model_Guard); + const nth: [rs.u32, rs.u32] | undefined = ids(part8); + const part9 = rs.iterNth(rs.iterZip(rs.iterMap(new rs.Range(1, 3), made), rs.iterMap(new rs.Range(3, 6), made), [true, true], rs.drop, rs.drop), 3, lib_drop$tuple2_model_Guard_model_Guard); + const past: [rs.u32, rs.u32] | undefined = ids(part9); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(nth, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(past, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["index ", args2[0], " ", args2[1], " ", args2[2]])); } else if (arg === 1) { - const longer: rt.Iter<[Guard.Guard, Guard.Guard]> = rt.iterZip(rt.iterMap(new rt.Range(1, 5), made), rt.iterMap(new rt.Range(5, 7), made), [true, true], rt.drop, rt.drop); - const part5 = rt.iterToOption(longer.nextBack()); - const back: [rt.u32, rt.u32] | undefined = ids(part5); - const part6 = rt.iterToOption(longer.next()); - const front: [rt.u32, rt.u32] | undefined = ids(part6); - const shorter: rt.Iter<[Guard.Guard, Guard.Guard]> = rt.iterZip(rt.iterMap(new rt.Range(1, 3), made), rt.iterMap(new rt.Range(3, 7), made), [true, true], rt.drop, rt.drop); - const part7 = rt.iterToOption(shorter.next()); - const next: [rt.u32, rt.u32] | undefined = ids(part7); - const rest: rt.Vec = rt.iterToVec(rt.iterMap(rt.iterRev(shorter), (_235: [Guard.Guard, Guard.Guard]): rt.u32 => { + const longer: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.iterMap(new rs.Range(1, 5), made), rs.iterMap(new rs.Range(5, 7), made), [true, true], rs.drop, rs.drop); + const part5 = rs.iterToOption(longer.nextBack()); + const back: [rs.u32, rs.u32] | undefined = ids(part5); + const part6 = rs.iterToOption(longer.next()); + const front: [rs.u32, rs.u32] | undefined = ids(part6); + const shorter: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.iterMap(new rs.Range(1, 3), made), rs.iterMap(new rs.Range(3, 7), made), [true, true], rs.drop, rs.drop); + const part7 = rs.iterToOption(shorter.next()); + const next: [rs.u32, rs.u32] | undefined = ids(part7); + const rest: rs.Vec = rs.iterToVec(rs.iterMap(rs.iterRev(shorter), (_235: [Guard.Guard, Guard.Guard]): rs.u32 => { const a4: Guard.Guard = _235[0]; const b4: Guard.Guard = _235[1]; - const _019: rt.u32 = rt.u32Sub(rt.u32Add(Guard.id(a4), Guard.id(b4)), rt.u32Mul(2, id)); + const _019: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a4), Guard.id(b4)), rs.u32Mul(2, id)); b4[Symbol.dispose](); a4[Symbol.dispose](); return _019; }), undefined, 4, true); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(back, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(front, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(next, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f)), (f: rt.Formatter) => rt.fmtList(rest.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["back ", args4[0], " ", args4[1], " ", args4[2], " ", args4[3]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(back, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(front, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(next, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f)), (f: rs.Formatter) => rs.fmtList(rest.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["back ", args4[0], " ", args4[1], " ", args4[2], " ", args4[3]])); } else if (arg === 2) { - const n2: rt.usize = rt.ownedCount(rt.iterZip(rt.vecIntoIter(guards(1, 4), rt.drop), rt.vecIntoIter(guards(4, 6), rt.drop), "len", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const _110: rt.Iter<[Guard.Guard, Guard.Guard]> = rt.iterZip(rt.vecIntoIter(guards(1, 4), rt.drop), rt.vecIntoIter(guards(4, 6), rt.drop), "len", rt.drop, rt.drop); - const any: boolean = rt.iterAny(_110, (_230: [Guard.Guard, Guard.Guard]): boolean => { + const n2: rs.usize = rs.ownedCount(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const _110: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop); + const any: boolean = rs.iterAny(_110, (_230: [Guard.Guard, Guard.Guard]): boolean => { lib_drop$tuple2_model_Guard_model_Guard(_230); return false; }); - rt.drop(_110); - const part4 = rt.ownedLast(rt.iterZip(rt.vecIntoIter(guards(1, 3), rt.drop), rt.vecIntoIter(guards(3, 6), rt.drop), "len", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const last: [rt.u32, rt.u32] | undefined = ids(part4); - rt.iterForEach(rt.iterZip(rt.vecIntoIter(guards(1, 4), rt.drop), rt.vecIntoIter(guards(4, 6), rt.drop), "len", rt.drop, rt.drop), (_233: [Guard.Guard, Guard.Guard]): undefined => { + rs.drop(_110); + const part4 = rs.ownedLast(rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.vecIntoIter(guards(3, 6), rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const last: [rs.u32, rs.u32] | undefined = ids(part4); + rs.iterForEach(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), (_233: [Guard.Guard, Guard.Guard]): undefined => { const a3: Guard.Guard = _233[0]; const b3: Guard.Guard = _233[1]; - const _1010: rt.u32 = rt.u32Sub(Guard.id(a3), id); - const _163: rt.u32 = rt.u32Sub(Guard.id(b3), id); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1010, f), (f: rt.Formatter) => rt.u32Display(_163, f)]; - Log.note(log, rt.fmtFormat(["each ", args22[0], " ", args22[1]])); + const _1010: rs.u32 = rs.u32Sub(Guard.id(a3), id); + const _163: rs.u32 = rs.u32Sub(Guard.id(b3), id); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1010, f), (f: rs.Formatter) => rs.u32Display(_163, f)]; + Log.note(log, rs.fmtFormat(["each ", args22[0], " ", args22[1]])); b3[Symbol.dispose](); a3[Symbol.dispose](); }, true); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n2, f), (f: rt.Formatter) => rt.fmtBool(any, f), (f: rt.Formatter) => rt.fmtOption(last, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["len ", args6[0], " ", args6[1], " ", args6[2]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtBool(any, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["len ", args6[0], " ", args6[1], " ", args6[2]])); } else if (arg === 3) { - const zip: () => rt.Iter<[Guard.Guard, Guard.Guard]> = (): rt.Iter<[Guard.Guard, Guard.Guard]> => { - return rt.iterZip(rt.iterMap(rt.vecIntoIter(rt.vecFrom([1, 2, 3])), made), rt.iterMap(rt.vecIntoIter(rt.vecFrom([4, 5])), made), "index", rt.drop, rt.drop); + const zip: () => rs.Iter<[Guard.Guard, Guard.Guard]> = (): rs.Iter<[Guard.Guard, Guard.Guard]> => { + return rs.iterZip(rs.iterMap(rs.vecIntoIter(rs.vecFrom([1, 2, 3])), made), rs.iterMap(rs.vecIntoIter(rs.vecFrom([4, 5])), made), "index", rs.drop, rs.drop); }; - const n3: rt.usize = rt.ownedCount(zip(), lib_drop$tuple2_model_Guard_model_Guard); - const at: rt.usize | undefined = rt.iterPosition(zip(), (_227: [Guard.Guard, Guard.Guard]): boolean => { + const n3: rs.usize = rs.ownedCount(zip(), lib_drop$tuple2_model_Guard_model_Guard); + const at: rs.usize | undefined = rs.iterPosition(zip(), (_227: [Guard.Guard, Guard.Guard]): boolean => { lib_drop$tuple2_model_Guard_model_Guard(_227); return false; }); - const sum: rt.u32 = rt.iterSum(rt.iterMap(zip(), (_229: [Guard.Guard, Guard.Guard]): rt.u32 => { + const sum: rs.u32 = rs.iterSum(rs.iterMap(zip(), (_229: [Guard.Guard, Guard.Guard]): rs.u32 => { const a2: Guard.Guard = _229[0]; const b2: Guard.Guard = _229[1]; - const _016: rt.u32 = rt.u32Sub(rt.u32Add(Guard.id(a2), Guard.id(b2)), rt.u32Mul(2, id)); + const _016: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a2), Guard.id(b2)), rs.u32Mul(2, id)); b2[Symbol.dispose](); a2[Symbol.dispose](); return _016; - }), rt.u32Add, 0); - const skipped: rt.usize = rt.ownedCount(rt.iterZip(rt.iterMap(rt.iterSkip(rt.vecIntoIter(rt.vecFrom([1, 2, 3, 4])), 1), made), rt.iterMap(new rt.Range(5, 7), made), "index", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); + }), rs.u32Add, 0); + const skipped: rs.usize = rs.ownedCount(rs.iterZip(rs.iterMap(rs.iterSkip(rs.vecIntoIter(rs.vecFrom([1, 2, 3, 4])), 1), made), rs.iterMap(new rs.Range(5, 7), made), "index", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); const _181: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; const c: Guard.Guard = _181[0]; const d: Guard.Guard = _181[1]; - const _191: rt.Iter = rt.vecIntoIter(rt.vecFrom([1, 2, 3])); + const _191: rs.Iter = rs.vecIntoIter(rs.vecFrom([1, 2, 3])); const captured = c; const captured2 = id; - const _190: rt.Iter = rt.iterMap(_191, rt.closure((x: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Add(x, Guard.id(captured)), captured2); + const _190: rs.Iter = rs.iterMap(_191, rs.closure((x: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Add(x, Guard.id(captured)), captured2); }, (): void => { captured[Symbol.dispose](); })); const captured3 = d; const captured4 = id; - const kept: rt.Vec = rt.iterToVec(rt.iterMap(_190, rt.closure((x2: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Add(x2, Guard.id(captured3)), captured4); + const kept: rs.Vec = rs.iterToVec(rs.iterMap(_190, rs.closure((x2: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Add(x2, Guard.id(captured3)), captured4); }, (): void => { captured3[Symbol.dispose](); })), "next", 4, true, 4); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.u32Display(sum, f), (f: rt.Formatter) => rt.usizeDisplay(skipped, f), (f: rt.Formatter) => rt.fmtList(kept.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.u32Display(sum, f), (f: rs.Formatter) => rs.usizeDisplay(skipped, f), (f: rs.Formatter) => rs.fmtList(kept.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["no coerce ", args8[0], " ", args8[1], " ", args8[2], " ", args8[3], " ", args8[4]])); } else if (arg === 4) { - const v: rt.Vec<[Guard.Guard, Guard.Guard]> = rt.iterToVec(rt.iterZip(rt.vecIntoIter(guards(1, 4), rt.drop), rt.iterMap(new rt.Range(4, 6), guard), "len", rt.drop, rt.drop), "fold", 16, true); + const v: rs.Vec<[Guard.Guard, Guard.Guard]> = rs.iterToVec(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.iterMap(new rs.Range(4, 6), guard), "len", rs.drop, rs.drop), "fold", 16, true); const part2 = v.items.length; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part2, f)]; - Log.note(log, rt.fmtFormat(["collect ", args10[0]])); - rt.dropVec(v, lib_drop$tuple2_model_Guard_model_Guard); - const _240: rt.Iter<[Guard.Guard, Guard.Guard]> = rt.iterZip(rt.vecIntoIter(guards(1, 3), rt.drop), rt.iterMap(new rt.Range(3, 6), guard), "len", rt.drop, rt.drop); - const part3 = rt.iterFind(_240, (_222: [Guard.Guard, Guard.Guard]): boolean => { - return Guard.id(_222[0]) === rt.u32Add(id, 9); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; + Log.note(log, rs.fmtFormat(["collect ", args10[0]])); + rs.dropVec(v, lib_drop$tuple2_model_Guard_model_Guard); + const _240: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.iterMap(new rs.Range(3, 6), guard), "len", rs.drop, rs.drop); + const part3 = rs.iterFind(_240, (_222: [Guard.Guard, Guard.Guard]): boolean => { + return Guard.id(_222[0]) === rs.u32Add(id, 9); }, lib_drop$tuple2_model_Guard_model_Guard); - const found: [rt.u32, rt.u32] | undefined = ids(part3); - rt.drop(_240); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(found, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["find ", args12[0]])); + const found: [rs.u32, rs.u32] | undefined = ids(part3); + rs.drop(_240); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(found, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["find ", args12[0]])); } else if (arg === 5) { - const nested: () => rt.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = (): rt.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> => { - return rt.iterZip(rt.iterZip(rt.vecIntoIter(guards(1, 4), rt.drop), rt.vecIntoIter(guards(4, 6), rt.drop), "len", rt.drop, rt.drop), rt.iterMap(new rt.Range(6, 9), guard), "len", lib_drop$tuple2_model_Guard_model_Guard, rt.drop); + const nested: () => rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = (): rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> => { + return rs.iterZip(rs.iterZip(rs.vecIntoIter(guards(1, 4), rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), "len", rs.drop, rs.drop), rs.iterMap(new rs.Range(6, 9), guard), "len", lib_drop$tuple2_model_Guard_model_Guard, rs.drop); }; - const n4: rt.usize = rt.ownedCount(nested(), lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard); - const _269: rt.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = nested(); - const _267: [[Guard.Guard, Guard.Guard], Guard.Guard] | undefined = rt.iterFind(_269, (_218: [[Guard.Guard, Guard.Guard], Guard.Guard]): boolean => { - return Guard.id(_218[0][0]) === rt.u32Add(id, 9); + const n4: rs.usize = rs.ownedCount(nested(), lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard); + const _269: rs.Iter<[[Guard.Guard, Guard.Guard], Guard.Guard]> = nested(); + const _267: [[Guard.Guard, Guard.Guard], Guard.Guard] | undefined = rs.iterFind(_269, (_218: [[Guard.Guard, Guard.Guard], Guard.Guard]): boolean => { + return Guard.id(_218[0][0]) === rs.u32Add(id, 9); }, lib_drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard); const found2: boolean = _267 !== undefined; lib_drop$Option_tuple2_tuple2_model_Guard_model_Guard_model_Guard(_267); - rt.drop(_269); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n4, f), (f: rt.Formatter) => rt.fmtBool(found2, f)]; - Log.note(log, rt.fmtFormat(["nested ", args14[0], " ", args14[1]])); + rs.drop(_269); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n4, f), (f: rs.Formatter) => rs.fmtBool(found2, f)]; + Log.note(log, rs.fmtFormat(["nested ", args14[0], " ", args14[1]])); } else if (arg === 6) { - const n5: rt.usize = rt.ownedCount(rt.iterZip(rt.iterFilter(rt.vecIntoIter(guards(1, 4), rt.drop), (g: Guard.Guard): boolean => { + const n5: rs.usize = rs.ownedCount(rs.iterZip(rs.iterFilter(rs.vecIntoIter(guards(1, 4), rs.drop), (g: Guard.Guard): boolean => { return Guard.id(g) !== id; - }, rt.drop), rt.vecIntoIter(guards(4, 6), rt.drop), undefined, rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const m: rt.usize = rt.ownedCount(rt.iterZip(rt.vecIntoIter(guards(1, 3), rt.drop), rt.iterFilter(rt.vecIntoIter(guards(3, 6), rt.drop), (g2: Guard.Guard): boolean => { + }, rs.drop), rs.vecIntoIter(guards(4, 6), rs.drop), undefined, rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const m: rs.usize = rs.ownedCount(rs.iterZip(rs.vecIntoIter(guards(1, 3), rs.drop), rs.iterFilter(rs.vecIntoIter(guards(3, 6), rs.drop), (g2: Guard.Guard): boolean => { return Guard.id(g2) !== id; - }, rt.drop), undefined, rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n5, f), (f: rt.Formatter) => rt.usizeDisplay(m, f)]; - Log.note(log, rt.fmtFormat(["neither ", args16[0], " ", args16[1]])); + }, rs.drop), undefined, rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n5, f), (f: rs.Formatter) => rs.usizeDisplay(m, f)]; + Log.note(log, rs.fmtFormat(["neither ", args16[0], " ", args16[1]])); } else { - const v2: rt.u32[] = [1, 2, 3]; - const n6: rt.usize = rt.ownedCount(rt.iterZip(rt.iterMap(rt.iterSlice(v2), (_22: rt.u32): Guard.Guard => { + const v2: rs.u32[] = [1, 2, 3]; + const n6: rs.usize = rs.ownedCount(rs.iterZip(rs.iterMap(rs.iterSlice(v2), (_22: rs.u32): Guard.Guard => { return made(_22); - }), new rt.Range(0, 2), [true, false], rt.drop), lib_drop$tuple2_model_Guard_i32); - const back2: rt.usize = rt.ownedCount(rt.iterRev(rt.iterZip(rt.iterMap(rt.iterSlice(v2), (_28: rt.u32): Guard.Guard => { + }), new rs.Range(0, 2), [true, false], rs.drop), lib_drop$tuple2_model_Guard_i32); + const back2: rs.usize = rs.ownedCount(rs.iterRev(rs.iterZip(rs.iterMap(rs.iterSlice(v2), (_28: rs.u32): Guard.Guard => { return made(_28); - }), new rt.Range(0, 2), [true, false], rt.drop)), lib_drop$tuple2_model_Guard_i32); - const empty: rt.usize = rt.usizeAdd(rt.ownedCount(rt.iterZip(rt.iterMap(rt.iterSlice(v2), (_29: rt.u32): Guard.Guard => { + }), new rs.Range(0, 2), [true, false], rs.drop)), lib_drop$tuple2_model_Guard_i32); + const empty: rs.usize = rs.usizeAdd(rs.ownedCount(rs.iterZip(rs.iterMap(rs.iterSlice(v2), (_29: rs.u32): Guard.Guard => { return made(_29); - }), new rt.Range(0, 0), [true, false], rt.drop), lib_drop$tuple2_model_Guard_i32), rt.ownedCount(rt.iterZip(new rt.Range(0, 0), rt.iterMap(rt.iterSlice(v2), (_213: rt.u32): Guard.Guard => { + }), new rs.Range(0, 0), [true, false], rs.drop), lib_drop$tuple2_model_Guard_i32), rs.ownedCount(rs.iterZip(new rs.Range(0, 0), rs.iterMap(rs.iterSlice(v2), (_213: rs.u32): Guard.Guard => { return made(_213); - }), [false, true], undefined, rt.drop), lib_drop$tuple2_i32_model_Guard)); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n6, f), (f: rt.Formatter) => rt.usizeDisplay(back2, f), (f: rt.Formatter) => rt.usizeDisplay(empty, f)]; - Log.note(log, rt.fmtFormat(["trimmed ", args18[0], " ", args18[1], " ", args18[2]])); + }), [false, true], undefined, rs.drop), lib_drop$tuple2_i32_model_Guard)); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.usizeDisplay(back2, f), (f: rs.Formatter) => rs.usizeDisplay(empty, f)]; + Log.note(log, rs.fmtFormat(["trimmed ", args18[0], " ", args18[1], " ", args18[2]])); } } diff --git a/ts/fixtures/task/expected/drops/indexed.ts b/ts/fixtures/task/expected/drops/indexed.ts index 63a7894a6..51fe4e0ef 100644 --- a/ts/fixtures/task/expected/drops/indexed.ts +++ b/ts/fixtures/task/expected/drops/indexed.ts @@ -1,415 +1,415 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$tuple2_model_Guard_model_Guard as lib_drop$tuple2_model_Guard_model_Guard, drop$tuple2_tuple2_model_Guard_model_Guard_i32 as lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32, drop$tuple2_tuple2_model_Guard_model_Guard_u32 as lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32, drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32 as lib_drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32, drop$tuple2_tuple2_usize_model_Guard_model_Guard as lib_drop$tuple2_tuple2_usize_model_Guard_model_Guard, drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32 as lib_drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32, drop$tuple2_usize_model_Guard as lib_drop$tuple2_usize_model_Guard, drop$tuple2_usize_tuple2_model_Guard_model_Guard as lib_drop$tuple2_usize_tuple2_model_Guard_model_Guard } from "../lib.ts"; -import { map$01pvlgn as option_map$01pvlgn, map$01vf10a as option_map$01vf10a, map$0uom32p as option_map$0uom32p, map$04djm2e as option_map$04djm2e, map$1s61o75 as option_map$1s61o75, map$1uj27tb as option_map$1uj27tb, map$1sprpgt as option_map$1sprpgt } from "../core/option.ts"; +import { map$0j32j8c as option_map$0j32j8c, map$0j94wbv as option_map$0j94wbv, map$1nsn0pp as option_map$1nsn0pp, map$0zjm57m as option_map$0zjm57m, map$0ss4ft9 as option_map$0ss4ft9, map$1pp5yot as option_map$1pp5yot, map$0nncxiz as option_map$0nncxiz } from "../core/option.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 9`. */ -export function indexed(log: Log.Log, id: rt.u32, arg: rt.u8): void { - let f!: rt.usize; - const guard: (a0: rt.u32) => Guard.Guard = (n9: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n9), Log.clone$Clone(log)); +export function indexed(log: Log.Log, id: rs.u32, arg: rs.u8): void { + let f!: rs.usize; + const guard: (a0: rs.u32) => Guard.Guard = (n9: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n9), Log.clone$Clone(log)); }; - const made: (a0: rt.u32) => Guard.Guard = (n10: rt.u32): Guard.Guard => { - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n10, f)]; - Log.note(log, rt.fmtFormat(["make ", args76[0]])); + const made: (a0: rs.u32) => Guard.Guard = (n10: rs.u32): Guard.Guard => { + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n10, f)]; + Log.note(log, rs.fmtFormat(["make ", args76[0]])); return guard(n10); }; - const v: rt.u32[] = [1, 2, 3, 4]; - const w: rt.u32[] = [11, 12, 13, 14]; - const pairs: () => rt.Iter<[Guard.Guard, Guard.Guard]> = (): rt.Iter<[Guard.Guard, Guard.Guard]> => { - const _33: rt.Iter = rt.iterSlice(v); + const v: rs.u32[] = [1, 2, 3, 4]; + const w: rs.u32[] = [11, 12, 13, 14]; + const pairs: () => rs.Iter<[Guard.Guard, Guard.Guard]> = (): rs.Iter<[Guard.Guard, Guard.Guard]> => { + const _33: rs.Iter = rs.iterSlice(v); const captured = made; - const _2: rt.Iter = rt.iterMap(_33, (_22: rt.u32): Guard.Guard => { + const _2: rs.Iter = rs.iterMap(_33, (_22: rs.u32): Guard.Guard => { return captured(_22); }); - const _7: rt.Iter = rt.iterSlice(w); + const _7: rs.Iter = rs.iterSlice(w); const captured2 = made; - return rt.iterZip(_2, rt.iterMap(_7, (_24: rt.u32): Guard.Guard => { + return rs.iterZip(_2, rs.iterMap(_7, (_24: rs.u32): Guard.Guard => { return captured2(_24); - }), [true, true], rt.drop, rt.drop); + }), [true, true], rs.drop, rs.drop); }; - const ids: (a0: [[Guard.Guard, Guard.Guard], rt.u32] | undefined) => [rt.u32, rt.u32, rt.u32] | undefined = (p2: [[Guard.Guard, Guard.Guard], rt.u32] | undefined): [rt.u32, rt.u32, rt.u32] | undefined => { - return option_map$04djm2e(p2, (_27: [[Guard.Guard, Guard.Guard], rt.u32]): [rt.u32, rt.u32, rt.u32] => { + const ids: (a0: [[Guard.Guard, Guard.Guard], rs.u32] | undefined) => [rs.u32, rs.u32, rs.u32] | undefined = (p2: [[Guard.Guard, Guard.Guard], rs.u32] | undefined): [rs.u32, rs.u32, rs.u32] | undefined => { + return option_map$0zjm57m(p2, (_27: [[Guard.Guard, Guard.Guard], rs.u32]): [rs.u32, rs.u32, rs.u32] => { const a2: Guard.Guard = _27[0][0]; const b2: Guard.Guard = _27[0][1]; - const n13: rt.u32 = _27[1]; - const _07: [rt.u32, rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a2), id), rt.u32Sub(Guard.id(b2), id), n13]; + const n13: rs.u32 = _27[1]; + const _07: [rs.u32, rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a2), id), rs.u32Sub(Guard.id(b2), id), n13]; b2[Symbol.dispose](); a2[Symbol.dispose](); return _07; }); }; - const _16: rt.u8 = rt.u8Rem(arg, 9); + const _16: rs.u8 = rs.u8Rem(arg, 9); if (_16 === 0) { - const n: rt.usize = rt.ownedCount(rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const it: rt.Iter<[[Guard.Guard, Guard.Guard], rt.u32]> = rt.iterZip(rt.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); - const part51 = rt.iterToOption(it.next()); - const _35: [rt.u32, rt.u32, rt.u32] | undefined = ids(part51); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n, f), (f: rt.Formatter) => rt.fmtOption(_35, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["count ", args2[0], " ", args2[1]])); - const part52 = rt.iterToOption(it.next()); + const n: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + const it: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); + const part51 = rs.iterToOption(it.next()); + const _35: [rs.u32, rs.u32, rs.u32] | undefined = ids(part51); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n, f), (f: rs.Formatter) => rs.fmtOption(_35, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["count ", args2[0], " ", args2[1]])); + const part52 = rs.iterToOption(it.next()); const part53 = ids(part52); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part53, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["next ", args4[0]])); - const part54 = rt.iterToOption(it.next()); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part53, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["next ", args4[0]])); + const part54 = rs.iterToOption(it.next()); const part55 = ids(part54); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part55, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["past ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part55, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["past ", args6[0]])); } else if (_16 === 1) { - const it2: rt.Iter<[[Guard.Guard, Guard.Guard], rt.u32]> = rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard); - const part39 = rt.iterToOption(it2.nextBack()); + const it2: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard); + const part39 = rs.iterToOption(it2.nextBack()); const part40 = ids(part39); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part40, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args8[0]])); - const part41 = rt.iterToOption(it2.nextBack()); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part40, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args8[0]])); + const part41 = rs.iterToOption(it2.nextBack()); const part42 = ids(part41); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part42, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args10[0]])); - const part43 = rt.iterToOption(it2.nextBack()); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part42, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args10[0]])); + const part43 = rs.iterToOption(it2.nextBack()); const part44 = ids(part43); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part44, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args12[0]])); - const part45 = rt.iterNth(rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part44, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args12[0]])); + const part45 = rs.iterNth(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); const part46 = ids(part45); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part46, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["nth ", args14[0]])); - const it4: rt.Iter<[[Guard.Guard, Guard.Guard], rt.u32]> = rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard); - const part47 = rt.iterToOption(it4.next()); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part46, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["nth ", args14[0]])); + const it4: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard); + const part47 = rs.iterToOption(it4.next()); const part48 = ids(part47); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part48, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["front ", args16[0]])); - const part49 = rt.iterToOption(it4.nextBack()); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part48, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["front ", args16[0]])); + const part49 = rs.iterToOption(it4.nextBack()); const part50 = ids(part49); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part50, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args18[0]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part50, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args18[0]])); } else if (_16 === 2) { - const part38 = option_map$01pvlgn(rt.iterToOption(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard).next()), (_258: [Guard.Guard, Guard.Guard]): [rt.u32, rt.u32] => { + const part38 = option_map$0j32j8c(rs.iterToOption(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard).next()), (_258: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { const a15: Guard.Guard = _258[0]; const b12: Guard.Guard = _258[1]; - const _040: [rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a15), id), rt.u32Sub(Guard.id(b12), id)]; + const _040: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a15), id), rs.u32Sub(Guard.id(b12), id)]; b12[Symbol.dispose](); a15[Symbol.dispose](); return _040; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part38, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["skip next ", args20[0]])); - const n2: rt.usize = rt.ownedCount(rt.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard); - const last: [rt.u32, rt.u32] | undefined = option_map$01pvlgn(rt.ownedLast(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard), (_259: [Guard.Guard, Guard.Guard]): [rt.u32, rt.u32] => { + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part38, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["skip next ", args20[0]])); + const n2: rs.usize = rs.ownedCount(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard); + const last: [rs.u32, rs.u32] | undefined = option_map$0j32j8c(rs.ownedLast(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_model_Guard_model_Guard), (_259: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { const a16: Guard.Guard = _259[0]; const b13: Guard.Guard = _259[1]; - const _041: [rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a16), id), rt.u32Sub(Guard.id(b13), id)]; + const _041: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a16), id), rs.u32Sub(Guard.id(b13), id)]; b13[Symbol.dispose](); a16[Symbol.dispose](); return _041; }); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n2, f), (f: rt.Formatter) => rt.fmtOption(last, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["skip count ", args22[0], " ", args22[1]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["skip count ", args22[0], " ", args22[1]])); } else if (_16 === 3) { - const part35 = rt.iterFold(rt.iterTake(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n35: rt.u32, _320: [Guard.Guard, Guard.Guard]): rt.u32 => { + const part35 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n35: rs.u32, _320: [Guard.Guard, Guard.Guard]): rs.u32 => { const a10: Guard.Guard = _320[0]; const b8: Guard.Guard = _320[1]; - const _035: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Add(rt.u32Mul(n35, 100), Guard.id(a10)), Guard.id(b8)), rt.u32Mul(2, id)); + const _035: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n35, 100), Guard.id(a10)), Guard.id(b8)), rs.u32Mul(2, id)); b8[Symbol.dispose](); a10[Symbol.dispose](); return _035; }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part35, f)]; - Log.note(log, rt.fmtFormat(["take fold ", args24[0]])); - rt.iterForEach(rt.iterTake(rt.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), 5, lib_drop$tuple2_model_Guard_model_Guard, true), (_250: [Guard.Guard, Guard.Guard]): undefined => { + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part35, f)]; + Log.note(log, rs.fmtFormat(["take fold ", args24[0]])); + rs.iterForEach(rs.iterTake(rs.iterSkip(pairs(), 2, lib_drop$tuple2_model_Guard_model_Guard), 5, lib_drop$tuple2_model_Guard_model_Guard, true), (_250: [Guard.Guard, Guard.Guard]): undefined => { const a11: Guard.Guard = _250[0]; const b9: Guard.Guard = _250[1]; - const _1019: rt.u32 = rt.u32Sub(Guard.id(a11), id); - const _1613: rt.u32 = rt.u32Sub(Guard.id(b9), id); - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_1019, f), (f: rt.Formatter) => rt.u32Display(_1613, f)]; - Log.note(log, rt.fmtFormat(["each ", args80[0], " ", args80[1]])); + const _1019: rs.u32 = rs.u32Sub(Guard.id(a11), id); + const _1613: rs.u32 = rs.u32Sub(Guard.id(b9), id); + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_1019, f), (f: rs.Formatter) => rs.u32Display(_1613, f)]; + Log.note(log, rs.fmtFormat(["each ", args80[0], " ", args80[1]])); b9[Symbol.dispose](); a11[Symbol.dispose](); }); - const part36 = option_map$01vf10a(rt.iterFind(rt.iterTake(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 3, lib_drop$tuple2_model_Guard_model_Guard, true), (_254: [Guard.Guard, Guard.Guard]): boolean => { - return Guard.id(_254[0]) === rt.u32Add(id, 3); - }, lib_drop$tuple2_model_Guard_model_Guard), (_256: [Guard.Guard, Guard.Guard]): rt.u32 => { + const part36 = option_map$0j94wbv(rs.iterFind(rs.iterTake(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 3, lib_drop$tuple2_model_Guard_model_Guard, true), (_254: [Guard.Guard, Guard.Guard]): boolean => { + return Guard.id(_254[0]) === rs.u32Add(id, 3); + }, lib_drop$tuple2_model_Guard_model_Guard), (_256: [Guard.Guard, Guard.Guard]): rs.u32 => { const a12: Guard.Guard = _256[0]; - const _037: rt.u32 = rt.u32Sub(Guard.id(a12), id); + const _037: rs.u32 = rs.u32Sub(Guard.id(a12), id); a12[Symbol.dispose](); _256[1][Symbol.dispose](); return _037; }); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part36, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["take find ", args26[0]])); - const n4: rt.u32 = rt.iterFold(rt.iterTake(rt.iterSkip(pairs(), 4, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n36: rt.u32, _326: [Guard.Guard, Guard.Guard]): rt.u32 => { + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part36, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["take find ", args26[0]])); + const n4: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 4, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n36: rs.u32, _326: [Guard.Guard, Guard.Guard]): rs.u32 => { const a13: Guard.Guard = _326[0]; const b10: Guard.Guard = _326[1]; - const _038: rt.u32 = rt.u32Add(rt.u32Add(n36, Guard.id(a13)), Guard.id(b10)); + const _038: rs.u32 = rs.u32Add(rs.u32Add(n36, Guard.id(a13)), Guard.id(b10)); b10[Symbol.dispose](); a13[Symbol.dispose](); return _038; }); - const m: rt.u32 = rt.iterFold(rt.iterTake(rt.iterSkip(pairs(), 3, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n37: rt.u32, _329: [Guard.Guard, Guard.Guard]): rt.u32 => { + const m: rs.u32 = rs.iterFold(rs.iterTake(rs.iterSkip(pairs(), 3, lib_drop$tuple2_model_Guard_model_Guard), 2, lib_drop$tuple2_model_Guard_model_Guard, true), 0, (n37: rs.u32, _329: [Guard.Guard, Guard.Guard]): rs.u32 => { const a14: Guard.Guard = _329[0]; const b11: Guard.Guard = _329[1]; - const _039: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Add(rt.u32Mul(n37, 100), Guard.id(a14)), Guard.id(b11)), rt.u32Mul(2, id)); + const _039: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(n37, 100), Guard.id(a14)), Guard.id(b11)), rs.u32Mul(2, id)); b11[Symbol.dispose](); a14[Symbol.dispose](); return _039; }); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n4, f), (f: rt.Formatter) => rt.u32Display(m, f)]; - Log.note(log, rt.fmtFormat(["take past ", args28[0], " ", args28[1]])); - const part37 = rt.ownedCount(rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), rt.vecIntoIter(rt.vecFrom([0, 1])), "index", lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part37, f)]; - Log.note(log, rt.fmtFormat(["vec count ", args30[0]])); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n4, f), (f: rs.Formatter) => rs.u32Display(m, f)]; + Log.note(log, rs.fmtFormat(["take past ", args28[0], " ", args28[1]])); + const part37 = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), rs.vecIntoIter(rs.vecFrom([0, 1])), "index", lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part37, f)]; + Log.note(log, rs.fmtFormat(["vec count ", args30[0]])); } else if (_16 === 4) { - const n6: rt.usize = rt.iterCount(rt.iterZip(rt.iterMap(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), (_247: [Guard.Guard, Guard.Guard]): rt.u32 => { + const n6: rs.usize = rs.iterCount(rs.iterZip(rs.iterMap(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), (_247: [Guard.Guard, Guard.Guard]): rs.u32 => { const a8: Guard.Guard = _247[0]; const b7: Guard.Guard = _247[1]; - const _033: rt.u32 = rt.u32Sub(rt.u32Add(Guard.id(a8), Guard.id(b7)), rt.u32Mul(2, id)); + const _033: rs.u32 = rs.u32Sub(rs.u32Add(Guard.id(a8), Guard.id(b7)), rs.u32Mul(2, id)); b7[Symbol.dispose](); a8[Symbol.dispose](); return _033; - }), new rt.Range(0, 2), [true, false])); - const e: [rt.usize, rt.u32, rt.i32] | undefined = option_map$1sprpgt(rt.ownedLast(rt.iterZip(rt.iterEnumerate(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard)), new rt.Range(0, 2), [true, false], lib_drop$tuple2_usize_tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32), (_248: [[rt.usize, [Guard.Guard, Guard.Guard]], rt.i32]): [rt.usize, rt.u32, rt.i32] => { - const i2: rt.usize = _248[0][0]; + }), new rs.Range(0, 2), [true, false])); + const e: [rs.usize, rs.u32, rs.i32] | undefined = option_map$0nncxiz(rs.ownedLast(rs.iterZip(rs.iterEnumerate(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard)), new rs.Range(0, 2), [true, false], lib_drop$tuple2_usize_tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32), (_248: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32]): [rs.usize, rs.u32, rs.i32] => { + const i2: rs.usize = _248[0][0]; const a9: Guard.Guard = _248[0][1][0]; - const n34: rt.i32 = _248[1]; - const _034: [rt.usize, rt.u32, rt.i32] = [i2, rt.u32Sub(Guard.id(a9), id), n34]; + const n34: rs.i32 = _248[1]; + const _034: [rs.usize, rs.u32, rs.i32] = [i2, rs.u32Sub(Guard.id(a9), id), n34]; a9[Symbol.dispose](); _248[0][1][1][Symbol.dispose](); return _034; }); - f = rt.ownedCount(rt.iterZip(rt.iterFuse(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), true), new rt.Range(0, 1), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n6, f), (f: rt.Formatter) => rt.fmtOption(e, f, (value: [rt.usize, rt.u32, rt.i32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.i32Debug(value[2], f)], f)), (f2: rt.Formatter) => rt.usizeDisplay(f, f2)]; - Log.note(log, rt.fmtFormat(["adapted ", args32[0], " ", args32[1], " ", args32[2]])); + f = rs.ownedCount(rs.iterZip(rs.iterFuse(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), true), new rs.Range(0, 1), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n6, f), (f: rs.Formatter) => rs.fmtOption(e, f, (value: [rs.usize, rs.u32, rs.i32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.i32Debug(value[2], f)], f)), (f2: rs.Formatter) => rs.usizeDisplay(f, f2)]; + Log.note(log, rs.fmtFormat(["adapted ", args32[0], " ", args32[1], " ", args32[2]])); } else if (_16 === 5) { - const n7: rt.usize = rt.ownedCount(rt.iterZip(rt.iterSkip(pairs(), 9, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const m2: rt.usize = rt.ownedCount(rt.iterZip(rt.iterSkip(pairs(), 0, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const o: rt.usize = rt.ownedCount(rt.iterZip(rt.iterSkip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); - const p: rt.usize = rt.ownedCount(rt.iterZip(rt.iterSkip(rt.iterZip(rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), new rt.Range(0, 1), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), lib_drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(n7, f), (f: rt.Formatter) => rt.usizeDisplay(m2, f), (f: rt.Formatter) => rt.usizeDisplay(o, f), (f: rt.Formatter) => rt.usizeDisplay(p, f)]; - Log.note(log, rt.fmtFormat(["edges ", args34[0], " ", args34[1], " ", args34[2], " ", args34[3]])); + const n7: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 9, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + const m2: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(pairs(), 0, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + const o: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32); + const p: rs.usize = rs.ownedCount(rs.iterZip(rs.iterSkip(rs.iterZip(rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 3), [true, false], lib_drop$tuple2_model_Guard_model_Guard), 1, lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), new rs.Range(0, 1), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_i32), lib_drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(n7, f), (f: rs.Formatter) => rs.usizeDisplay(m2, f), (f: rs.Formatter) => rs.usizeDisplay(o, f), (f: rs.Formatter) => rs.usizeDisplay(p, f)]; + Log.note(log, rs.fmtFormat(["edges ", args34[0], " ", args34[1], " ", args34[2], " ", args34[3]])); } else if (_16 === 6) { - const _398: rt.Iter = rt.iterSlice(v); + const _398: rs.Iter = rs.iterSlice(v); const captured14 = made; - const it6: rt.Iter<[Guard.Guard, rt.u32]> = rt.iterZip(rt.iterSkip(rt.iterMap(_398, (_218: rt.u32): Guard.Guard => { + const it6: rs.Iter<[Guard.Guard, rs.u32]> = rs.iterZip(rs.iterSkip(rs.iterMap(_398, (_218: rs.u32): Guard.Guard => { return captured14(_218); - }), 1, rt.drop), new rt.Range(0, 2), [true, false], rt.drop); - const id1: (a0: [Guard.Guard, rt.u32] | undefined) => [rt.u32, rt.u32] | undefined = (p3: [Guard.Guard, rt.u32] | undefined): [rt.u32, rt.u32] | undefined => { - return option_map$0uom32p(p3, (_219: [Guard.Guard, rt.u32]): [rt.u32, rt.u32] => { + }), 1, rs.drop), new rs.Range(0, 2), [true, false], rs.drop); + const id1: (a0: [Guard.Guard, rs.u32] | undefined) => [rs.u32, rs.u32] | undefined = (p3: [Guard.Guard, rs.u32] | undefined): [rs.u32, rs.u32] | undefined => { + return option_map$1nsn0pp(p3, (_219: [Guard.Guard, rs.u32]): [rs.u32, rs.u32] => { const a4: Guard.Guard = _219[0]; - const n23: rt.u32 = _219[1]; - const _019: [rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a4), id), n23]; + const n23: rs.u32 = _219[1]; + const _019: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a4), id), n23]; a4[Symbol.dispose](); return _019; }); }; - const part7 = rt.iterToOption(it6.nextBack()); + const part7 = rs.iterToOption(it6.nextBack()); const part8 = id1(part7); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args36[0]])); - const part9 = rt.iterToOption(it6.nextBack()); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args36[0]])); + const part9 = rs.iterToOption(it6.nextBack()); const part10 = id1(part9); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part10, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args38[0]])); - const part11 = rt.iterToOption(it6.nextBack()); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args38[0]])); + const part11 = rs.iterToOption(it6.nextBack()); const part12 = id1(part11); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part12, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["back ", args40[0]])); - const _453: rt.Iter = rt.iterSlice(v); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["back ", args40[0]])); + const _453: rs.Iter = rs.iterSlice(v); const captured15 = made; - const _452: rt.Iter = rt.iterMap(_453, (_223: rt.u32): Guard.Guard => { + const _452: rs.Iter = rs.iterMap(_453, (_223: rs.u32): Guard.Guard => { return captured15(_223); }); - const _458: rt.Iter = rt.iterSlice(rt.sliceRange(w, 0, 3)); + const _458: rs.Iter = rs.iterSlice(rs.sliceRange(w, 0, 3)); const captured16 = made; - const it7: rt.Iter<[[Guard.Guard, Guard.Guard], rt.u32]> = rt.iterZip(rt.iterZip(_452, rt.iterMap(_458, (_224: rt.u32): Guard.Guard => { + const it7: rs.Iter<[[Guard.Guard, Guard.Guard], rs.u32]> = rs.iterZip(rs.iterZip(_452, rs.iterMap(_458, (_224: rs.u32): Guard.Guard => { return captured16(_224); - }), [true, true], rt.drop, rt.drop), new rt.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); - const part13 = rt.iterToOption(it7.nextBack()); + }), [true, true], rs.drop, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard); + const part13 = rs.iterToOption(it7.nextBack()); const part14 = ids(part13); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part14, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["uneven ", args42[0]])); - const part15 = rt.iterToOption(it7.next()); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["uneven ", args42[0]])); + const part15 = rs.iterToOption(it7.next()); const part16 = ids(part15); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part16, f, (value: [rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f)], f))]; - Log.note(log, rt.fmtFormat(["uneven ", args44[0]])); - const _499: rt.Iter = rt.iterSlice(v); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part16, f, (value: [rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f)], f))]; + Log.note(log, rs.fmtFormat(["uneven ", args44[0]])); + const _499: rs.Iter = rs.iterSlice(v); const captured17 = made; - const _498: rt.Iter = rt.iterMap(_499, (_228: rt.u32): Guard.Guard => { + const _498: rs.Iter = rs.iterMap(_499, (_228: rs.u32): Guard.Guard => { return captured17(_228); }); - const _504: rt.Iter = rt.iterSlice(rt.sliceRange(w, 0, 2)); + const _504: rs.Iter = rs.iterSlice(rs.sliceRange(w, 0, 2)); const captured18 = made; - const part17 = rt.ownedCount(rt.iterRev(rt.iterZip(rt.iterZip(_498, rt.iterMap(_504, (_230: rt.u32): Guard.Guard => { + const part17 = rs.ownedCount(rs.iterRev(rs.iterZip(rs.iterZip(_498, rs.iterMap(_504, (_230: rs.u32): Guard.Guard => { return captured18(_230); - }), [true, true], rt.drop, rt.drop), new rt.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard)), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part17, f)]; - Log.note(log, rt.fmtFormat(["uneven rev ", args46[0]])); - const _522: rt.Iter = rt.iterSlice(v); + }), [true, true], rs.drop, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_model_Guard_model_Guard)), lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part17, f)]; + Log.note(log, rs.fmtFormat(["uneven rev ", args46[0]])); + const _522: rs.Iter = rs.iterSlice(v); const captured19 = made; - const _521: rt.Iter = rt.iterMap(_522, (_231: rt.u32): Guard.Guard => { + const _521: rs.Iter = rs.iterMap(_522, (_231: rs.u32): Guard.Guard => { return captured19(_231); }); - const _527: rt.Iter = rt.iterSlice(rt.sliceRange(w, 0, 3)); + const _527: rs.Iter = rs.iterSlice(rs.sliceRange(w, 0, 3)); const captured20 = made; - const it8: rt.Iter<[Guard.Guard, Guard.Guard]> = rt.iterZip(_521, rt.iterMap(_527, (_235: rt.u32): Guard.Guard => { + const it8: rs.Iter<[Guard.Guard, Guard.Guard]> = rs.iterZip(_521, rs.iterMap(_527, (_235: rs.u32): Guard.Guard => { return captured20(_235); - }), [true, true], rt.drop, rt.drop); - const id2: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rt.u32, rt.u32] | undefined = (p4: [Guard.Guard, Guard.Guard] | undefined): [rt.u32, rt.u32] | undefined => { - return option_map$01pvlgn(p4, (_236: [Guard.Guard, Guard.Guard]): [rt.u32, rt.u32] => { + }), [true, true], rs.drop, rs.drop); + const id2: (a0: [Guard.Guard, Guard.Guard] | undefined) => [rs.u32, rs.u32] | undefined = (p4: [Guard.Guard, Guard.Guard] | undefined): [rs.u32, rs.u32] | undefined => { + return option_map$0j32j8c(p4, (_236: [Guard.Guard, Guard.Guard]): [rs.u32, rs.u32] => { const a5: Guard.Guard = _236[0]; const b4: Guard.Guard = _236[1]; - const _027: [rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a5), id), rt.u32Sub(Guard.id(b4), id)]; + const _027: [rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a5), id), rs.u32Sub(Guard.id(b4), id)]; b4[Symbol.dispose](); a5[Symbol.dispose](); return _027; }); }; - const part18 = rt.iterToOption(it8.next()); + const part18 = rs.iterToOption(it8.next()); const part19 = id2(part18); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part19, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["ends ", args48[0]])); - const part20 = rt.iterToOption(it8.nextBack()); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part19, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["ends ", args48[0]])); + const part20 = rs.iterToOption(it8.nextBack()); const part21 = id2(part20); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part21, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["ends ", args50[0]])); - const part22 = rt.iterToOption(it8.next()); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part21, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["ends ", args50[0]])); + const part22 = rs.iterToOption(it8.next()); const part23 = id2(part22); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part23, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["ends ", args52[0]])); - const part24 = rt.iterToOption(it8.nextBack()); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["ends ", args52[0]])); + const part24 = rs.iterToOption(it8.nextBack()); const part25 = id2(part24); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part25, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["ends ", args54[0]])); - const inner: rt.Iter<[Guard.Guard, Guard.Guard]> = pairs(); - const part26 = rt.iterToOption(inner.nextBack()); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part25, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["ends ", args54[0]])); + const inner: rs.Iter<[Guard.Guard, Guard.Guard]> = pairs(); + const part26 = rs.iterToOption(inner.nextBack()); const part27 = id2(part26); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part27, f, (value: [rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["inner ", args56[0]])); - const it9: rt.Iter<[[[Guard.Guard, Guard.Guard], rt.u32], rt.u32]> = rt.iterZip(rt.iterZip(inner, new rt.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), new rt.Range(0, 2), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); - const id3: (a0: [[[Guard.Guard, Guard.Guard], rt.u32], rt.u32] | undefined) => [rt.u32, rt.u32, rt.u32, rt.u32] | undefined = (p5: [[[Guard.Guard, Guard.Guard], rt.u32], rt.u32] | undefined): [rt.u32, rt.u32, rt.u32, rt.u32] | undefined => { - return option_map$1s61o75(p5, (_237: [[[Guard.Guard, Guard.Guard], rt.u32], rt.u32]): [rt.u32, rt.u32, rt.u32, rt.u32] => { + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part27, f, (value: [rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["inner ", args56[0]])); + const it9: rs.Iter<[[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]> = rs.iterZip(rs.iterZip(inner, new rs.Range(0, 2), [true, false], lib_drop$tuple2_model_Guard_model_Guard), new rs.Range(0, 2), [true, false], lib_drop$tuple2_tuple2_model_Guard_model_Guard_u32); + const id3: (a0: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32] | undefined) => [rs.u32, rs.u32, rs.u32, rs.u32] | undefined = (p5: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32] | undefined): [rs.u32, rs.u32, rs.u32, rs.u32] | undefined => { + return option_map$0ss4ft9(p5, (_237: [[[Guard.Guard, Guard.Guard], rs.u32], rs.u32]): [rs.u32, rs.u32, rs.u32, rs.u32] => { const a6: Guard.Guard = _237[0][0][0]; const b5: Guard.Guard = _237[0][0][1]; - const m3: rt.u32 = _237[0][1]; - const n30: rt.u32 = _237[1]; - const _029: [rt.u32, rt.u32, rt.u32, rt.u32] = [rt.u32Sub(Guard.id(a6), id), rt.u32Sub(Guard.id(b5), id), m3, n30]; + const m3: rs.u32 = _237[0][1]; + const n30: rs.u32 = _237[1]; + const _029: [rs.u32, rs.u32, rs.u32, rs.u32] = [rs.u32Sub(Guard.id(a6), id), rs.u32Sub(Guard.id(b5), id), m3, n30]; b5[Symbol.dispose](); a6[Symbol.dispose](); return _029; }); }; - const part28 = rt.iterToOption(it9.nextBack()); + const part28 = rs.iterToOption(it9.nextBack()); const part29 = id3(part28); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part29, f, (value: [rt.u32, rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f), (f: rt.Formatter) => rt.u32Debug(value[3], f)], f))]; - Log.note(log, rt.fmtFormat(["nested ", args58[0]])); - const part30 = rt.iterToOption(it9.nextBack()); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part29, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; + Log.note(log, rs.fmtFormat(["nested ", args58[0]])); + const part30 = rs.iterToOption(it9.nextBack()); const part31 = id3(part30); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part31, f, (value: [rt.u32, rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f), (f: rt.Formatter) => rt.u32Debug(value[3], f)], f))]; - Log.note(log, rt.fmtFormat(["nested ", args60[0]])); - const part32 = rt.iterToOption(it9.nextBack()); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part31, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; + Log.note(log, rs.fmtFormat(["nested ", args60[0]])); + const part32 = rs.iterToOption(it9.nextBack()); const part33 = id3(part32); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part33, f, (value: [rt.u32, rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f), (f: rt.Formatter) => rt.u32Debug(value[3], f)], f))]; - Log.note(log, rt.fmtFormat(["nested ", args62[0]])); - const _667: rt.Iter = rt.iterSlice(v); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part33, f, (value: [rs.u32, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; + Log.note(log, rs.fmtFormat(["nested ", args62[0]])); + const _667: rs.Iter = rs.iterSlice(v); const captured21 = made; - const _665: rt.Iter<[rt.usize, Guard.Guard]> = rt.iterEnumerate(rt.iterMap(_667, (_240: rt.u32): Guard.Guard => { + const _665: rs.Iter<[rs.usize, Guard.Guard]> = rs.iterEnumerate(rs.iterMap(_667, (_240: rs.u32): Guard.Guard => { return captured21(_240); })); - const _672: rt.Iter = rt.iterSlice(rt.sliceRange(w, 0, 3)); + const _672: rs.Iter = rs.iterSlice(rs.sliceRange(w, 0, 3)); const captured22 = made; - const part34 = option_map$1uj27tb(rt.iterToOption(rt.iterZip(rt.iterZip(_665, rt.iterMap(_672, (_241: rt.u32): Guard.Guard => { + const part34 = option_map$1pp5yot(rs.iterToOption(rs.iterZip(rs.iterZip(_665, rs.iterMap(_672, (_241: rs.u32): Guard.Guard => { return captured22(_241); - }), [true, true], lib_drop$tuple2_usize_model_Guard, rt.drop), new rt.Range(0, 5), [true, false], lib_drop$tuple2_tuple2_usize_model_Guard_model_Guard).nextBack()), (_245: [[[rt.usize, Guard.Guard], Guard.Guard], rt.u32]): [rt.usize, rt.u32, rt.u32, rt.u32] => { - const i: rt.usize = _245[0][0][0]; + }), [true, true], lib_drop$tuple2_usize_model_Guard, rs.drop), new rs.Range(0, 5), [true, false], lib_drop$tuple2_tuple2_usize_model_Guard_model_Guard).nextBack()), (_245: [[[rs.usize, Guard.Guard], Guard.Guard], rs.u32]): [rs.usize, rs.u32, rs.u32, rs.u32] => { + const i: rs.usize = _245[0][0][0]; const a7: Guard.Guard = _245[0][0][1]; const b6: Guard.Guard = _245[0][1]; - const n33: rt.u32 = _245[1]; - const _032: [rt.usize, rt.u32, rt.u32, rt.u32] = [i, rt.u32Sub(Guard.id(a7), id), rt.u32Sub(Guard.id(b6), id), n33]; + const n33: rs.u32 = _245[1]; + const _032: [rs.usize, rs.u32, rs.u32, rs.u32] = [i, rs.u32Sub(Guard.id(a7), id), rs.u32Sub(Guard.id(b6), id), n33]; b6[Symbol.dispose](); a7[Symbol.dispose](); return _032; }); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part34, f, (value: [rt.usize, rt.u32, rt.u32, rt.u32], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.u32Debug(value[1], f), (f: rt.Formatter) => rt.u32Debug(value[2], f), (f: rt.Formatter) => rt.u32Debug(value[3], f)], f))]; - Log.note(log, rt.fmtFormat(["enumerated ", args64[0]])); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part34, f, (value: [rs.usize, rs.u32, rs.u32, rs.u32], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.u32Debug(value[1], f), (f: rs.Formatter) => rs.u32Debug(value[2], f), (f: rs.Formatter) => rs.u32Debug(value[3], f)], f))]; + Log.note(log, rs.fmtFormat(["enumerated ", args64[0]])); } else if (_16 === 7) { const _695: [Guard.Guard, Guard.Guard] = [guard(20), guard(21)]; const a: Guard.Guard = _695[0]; const b: Guard.Guard = _695[1]; - const x: rt.u32 = rt.u32Sub(Guard.id(a), id); - const _712: rt.Iter = rt.vecIntoIter(rt.vecFrom([1, 2, 3, 4])); + const x: rs.u32 = rs.u32Sub(Guard.id(a), id); + const _712: rs.Iter = rs.vecIntoIter(rs.vecFrom([1, 2, 3, 4])); const captured6 = a; const captured7 = id; const captured8 = x; - const _710: rt.Iter<[rt.u32, rt.u32]> = rt.iterZip(rt.iterMap(_712, rt.closure((n19: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Sub(rt.u32Add(n19, Guard.id(captured6)), captured7), captured8); + const _710: rs.Iter<[rs.u32, rs.u32]> = rs.iterZip(rs.iterMap(_712, rs.closure((n19: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Sub(rs.u32Add(n19, Guard.id(captured6)), captured7), captured8); }, (): void => { captured6[Symbol.dispose](); - })), new rt.Range(0, 2), "index"); + })), new rs.Range(0, 2), "index"); const captured9 = b; const captured10 = id; const captured11 = x; - const part5 = rt.iterToVec(rt.iterMap(_710, rt.closure((_216: [rt.u32, rt.u32]): rt.u32 => { - return rt.u32Sub(rt.u32Sub(rt.u32Sub(rt.u32Add(rt.u32Add(rt.u32Mul(_216[0], 10), _216[1]), Guard.id(captured9)), captured10), captured11), 1); + const part5 = rs.iterToVec(rs.iterMap(_710, rs.closure((_216: [rs.u32, rs.u32]): rs.u32 => { + return rs.u32Sub(rs.u32Sub(rs.u32Sub(rs.u32Add(rs.u32Add(rs.u32Mul(_216[0], 10), _216[1]), Guard.id(captured9)), captured10), captured11), 1); }, (): void => { captured9[Symbol.dispose](); })), "index", 4, true, 4); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part5.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["in place ", args66[0]])); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part5.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["in place ", args66[0]])); const c: Guard.Guard = guard(22); - const _732: rt.Iter = rt.vecIntoIter(rt.vecFrom([5, 6, 7])); - const _736: rt.Range = new rt.Range(0, 9); + const _732: rs.Iter = rs.vecIntoIter(rs.vecFrom([5, 6, 7])); + const _736: rs.Range = new rs.Range(0, 9); const captured12 = c; const captured13 = id; - const part6 = rt.iterToVec(rt.iterMap(rt.iterZip(_732, rt.iterMap(_736, rt.closure((k4: rt.u32): rt.u32 => { - return rt.u32Sub(rt.u32Sub(rt.u32Add(k4, Guard.id(captured12)), captured13), 22); + const part6 = rs.iterToVec(rs.iterMap(rs.iterZip(_732, rs.iterMap(_736, rs.closure((k4: rs.u32): rs.u32 => { + return rs.u32Sub(rs.u32Sub(rs.u32Add(k4, Guard.id(captured12)), captured13), 22); }, (): void => { captured12[Symbol.dispose](); - })), "index"), (_217: [rt.u32, rt.u32]): rt.u32 => { - return rt.u32Add(_217[0], _217[1]); + })), "index"), (_217: [rs.u32, rs.u32]): rs.u32 => { + return rs.u32Add(_217[0], _217[1]); }), "index", 4, true, 4); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part6.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["in place ", args68[0]])); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part6.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["in place ", args68[0]])); } else { const d: Guard.Guard = guard(23); - const _756: rt.Iter = rt.vecIntoIter(rt.vecFrom([1, 2, 3, 4])); + const _756: rs.Iter = rs.vecIntoIter(rs.vecFrom([1, 2, 3, 4])); const captured3 = d; const captured4 = id; - const part2 = rt.iterToVec(rt.iterMap(rt.iterSkip(rt.iterZip(rt.iterMap(_756, rt.closure((n14: rt.u32): rt.u32 => { - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n14, f)]; - Log.note(log, rt.fmtFormat(["map ", args78[0]])); - const _156: rt.u32 = Guard.id(captured3); - return rt.u32Sub(rt.u32Sub(rt.u32Add(n14, _156), captured4), 23); + const part2 = rs.iterToVec(rs.iterMap(rs.iterSkip(rs.iterZip(rs.iterMap(_756, rs.closure((n14: rs.u32): rs.u32 => { + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n14, f)]; + Log.note(log, rs.fmtFormat(["map ", args78[0]])); + const _156: rs.u32 = Guard.id(captured3); + return rs.u32Sub(rs.u32Sub(rs.u32Add(n14, _156), captured4), 23); }, (): void => { captured3[Symbol.dispose](); - })), new rt.Range(0, 3), "index"), 1), (_29: [rt.u32, rt.u32]): rt.u32 => { - return rt.u32Add(_29[0], _29[1]); + })), new rs.Range(0, 3), "index"), 1), (_29: [rs.u32, rs.u32]): rs.u32 => { + return rs.u32Add(_29[0], _29[1]); }), "index", 4, true, 4); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["skipped ", args70[0]])); - const part3 = rt.iterToVec(rt.iterMap(rt.iterZip(rt.vecIntoIter(rt.vecFrom([1, 2, 3])), rt.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), "index", undefined, lib_drop$tuple2_model_Guard_model_Guard), (_211: [rt.u32, [Guard.Guard, Guard.Guard]]): rt.u32 => { - const n16: rt.u32 = _211[0]; + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["skipped ", args70[0]])); + const part3 = rs.iterToVec(rs.iterMap(rs.iterZip(rs.vecIntoIter(rs.vecFrom([1, 2, 3])), rs.iterSkip(pairs(), 1, lib_drop$tuple2_model_Guard_model_Guard), "index", undefined, lib_drop$tuple2_model_Guard_model_Guard), (_211: [rs.u32, [Guard.Guard, Guard.Guard]]): rs.u32 => { + const n16: rs.u32 = _211[0]; const a3: Guard.Guard = _211[1][0]; const b3: Guard.Guard = _211[1][1]; - const _010: rt.u32 = rt.u32Sub(rt.u32Add(rt.u32Add(n16, Guard.id(a3)), Guard.id(b3)), rt.u32Mul(2, id)); + const _010: rs.u32 = rs.u32Sub(rs.u32Add(rs.u32Add(n16, Guard.id(a3)), Guard.id(b3)), rs.u32Mul(2, id)); b3[Symbol.dispose](); a3[Symbol.dispose](); return _010; }), "index", 4, true, 4); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part3.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["beside ", args72[0]])); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part3.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["beside ", args72[0]])); const e2: Guard.Guard = guard(24); - const _799: rt.Iter = rt.vecIntoIter(new rt.Vec()); + const _799: rs.Iter = rs.vecIntoIter(new rs.Vec()); const captured5 = e2; - const part4 = rt.iterToVec(rt.iterMap(rt.iterZip(rt.iterMap(_799, rt.closure((n17: rt.u32): rt.u32 => { - return rt.u32Add(n17, Guard.id(captured5)); + const part4 = rs.iterToVec(rs.iterMap(rs.iterZip(rs.iterMap(_799, rs.closure((n17: rs.u32): rs.u32 => { + return rs.u32Add(n17, Guard.id(captured5)); }, (): void => { captured5[Symbol.dispose](); - })), new rt.Range(0, 3), "index"), (_212: [rt.u32, rt.u32]): rt.u32 => { - return rt.u32Add(_212[0], _212[1]); + })), new rs.Range(0, 3), "index"), (_212: [rs.u32, rs.u32]): rs.u32 => { + return rs.u32Add(_212[0], _212[1]); }), "index", 4, true, 4); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part4.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["empty ", args74[0]])); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part4.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["empty ", args74[0]])); } } diff --git a/ts/fixtures/task/expected/drops/inside.Bomb.ts b/ts/fixtures/task/expected/drops/inside.Bomb.ts index 126b446c9..41b678b9f 100644 --- a/ts/fixtures/task/expected/drops/inside.Bomb.ts +++ b/ts/fixtures/task/expected/drops/inside.Bomb.ts @@ -1,13 +1,13 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; /** A range whose drop panics, which shows where std drops it. */ export class Bomb { - _0: rt.usize; - _1: rt.usize; + _0: rs.usize; + _1: rs.usize; - constructor(_0: rt.usize, _1: rt.usize) { + constructor(_0: rs.usize, _1: rs.usize) { this._0 = _0; this._1 = _1; } @@ -19,18 +19,18 @@ export class Bomb { export function drop$ops_Drop(self: Bomb): void { const arg = self._0; - const _8: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(arg, f); + const _8: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(arg, f); const arg2 = self._1; - const args2: rt.Fmt[] = [_8, (f: rt.Formatter) => rt.usizeDisplay(arg2, f)]; - rt.panicFmt(["range ", args2[0], "..", args2[1], " dropped"]); + const args2: rs.Fmt[] = [_8, (f: rs.Formatter) => rs.usizeDisplay(arg2, f)]; + rs.panicFmt(["range ", args2[0], "..", args2[1], " dropped"]); } -export function startBound$ops_RangeBounds_usize(self: Bomb): rt.RangeBound { - return { tag: "Included", _0: self._0 } as rt.RangeBound; +export function startBound$ops_RangeBounds_usize(self: Bomb): rs.RangeBound { + return { tag: "Included", _0: self._0 } as rs.RangeBound; } -export function endBound$ops_RangeBounds_usize(self: Bomb): rt.RangeBound { - return { tag: "Excluded", _0: self._1 } as rt.RangeBound; +export function endBound$ops_RangeBounds_usize(self: Bomb): rs.RangeBound { + return { tag: "Excluded", _0: self._1 } as rs.RangeBound; } //# sourceMappingURL=inside.Bomb.ts.map diff --git a/ts/fixtures/task/expected/drops/inside.Listed.ts b/ts/fixtures/task/expected/drops/inside.Listed.ts index 481203ad9..55b81eb63 100644 --- a/ts/fixtures/task/expected/drops/inside.Listed.ts +++ b/ts/fixtures/task/expected/drops/inside.Listed.ts @@ -1,17 +1,17 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Shown from "../drops/inside.Shown.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Writes the guards a step makes from `0..n` by `entries` of each kind of iterable. */ export class Listed { - _0: rt.u32; + _0: rs.u32; _1: Log.Log; - _2: rt.u8; + _2: rs.u8; - constructor(_0: rt.u32, _1: Log.Log, _2: rt.u8) { + constructor(_0: rs.u32, _1: Log.Log, _2: rs.u8) { this._0 = _0; this._1 = _1; this._2 = _2; @@ -22,25 +22,25 @@ export class Listed { } } -export function fmt$fmt_Debug(self: Listed, f: rt.Formatter): rt.Result { - const guard: (a0: rt.u8) => Shown.Shown = (n: rt.u8): Shown.Shown => { - return new Shown.Shown(Guard.new(rt.u32Add(self._0, n as rt.u32), Log.clone$Clone(self._1))); +export function fmt$fmt_Debug(self: Listed, f: rs.Formatter): rs.Result { + const guard: (a0: rs.u8) => Shown.Shown = (n: rs.u8): Shown.Shown => { + return new Shown.Shown(Guard.new(rs.u32Add(self._0, n as rs.u32), Log.clone$Clone(self._1))); }; - const list: rt.DebugList = rt.fmtDebugList(f); - const _11: rt.Iter = rt.iterMap(new rt.Range(0, self._2), guard); - rt.debugListEntries(list, _11, (value: Shown.Shown, f: rt.Formatter) => Shown.fmt$fmt_Debug(value, f), rt.drop); - const _16: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(10, rt.u8Add(10, self._2)), guard), undefined, 8, true); - rt.debugListEntries(list, _16.items, (value: Shown.Shown, f: rt.Formatter) => Shown.fmt$fmt_Debug(value, f), rt.drop); - const _24: rt.Iter = rt.iterMap(rt.vecIntoIter(rt.iterToVec(rt.iterMap(new rt.Range(20, rt.u8Add(20, self._2)), guard), undefined, 8, true), rt.drop), (g: Shown.Shown): rt.u32 => { - const _03: rt.u32 = Guard.id(g._0); + const list: rs.DebugList = rs.fmtDebugList(f); + const _11: rs.Iter = rs.iterMap(new rs.Range(0, self._2), guard); + rs.debugListEntries(list, _11, (value: Shown.Shown, f: rs.Formatter) => Shown.fmt$fmt_Debug(value, f), rs.drop); + const _16: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(10, rs.u8Add(10, self._2)), guard), undefined, 8, true); + rs.debugListEntries(list, _16.items, (value: Shown.Shown, f: rs.Formatter) => Shown.fmt$fmt_Debug(value, f), rs.drop); + const _24: rs.Iter = rs.iterMap(rs.vecIntoIter(rs.iterToVec(rs.iterMap(new rs.Range(20, rs.u8Add(20, self._2)), guard), undefined, 8, true), rs.drop), (g: Shown.Shown): rs.u32 => { + const _03: rs.u32 = Guard.id(g._0); g[Symbol.dispose](); return _03; }); - rt.debugListEntries(list, _24, rt.u32Debug); - const kept: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(30, rt.u8Add(30, self._2)), guard), undefined, 8, true); - rt.debugListEntries(list, kept.items, (value: Shown.Shown, f: rt.Formatter) => Shown.fmt$fmt_Debug(value, f)); - const _0: rt.Result = rt.debugListFinish(list); - rt.dropVec(kept); + rs.debugListEntries(list, _24, rs.u32Debug); + const kept: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(30, rs.u8Add(30, self._2)), guard), undefined, 8, true); + rs.debugListEntries(list, kept.items, (value: Shown.Shown, f: rs.Formatter) => Shown.fmt$fmt_Debug(value, f)); + const _0: rs.Result = rs.debugListFinish(list); + rs.dropVec(kept); return _0; } diff --git a/ts/fixtures/task/expected/drops/inside.Shown.ts b/ts/fixtures/task/expected/drops/inside.Shown.ts index 70792c62c..9091db6d2 100644 --- a/ts/fixtures/task/expected/drops/inside.Shown.ts +++ b/ts/fixtures/task/expected/drops/inside.Shown.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Guard from "../model.Guard.ts"; /** A guard written as its id. */ @@ -16,11 +16,11 @@ export class Shown { } } -export function fmt$fmt_Debug(self: Shown, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Shown, f: rs.Formatter): rs.Result { Guard.note(self._0, "shown"); const part = Guard.id(self._0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - return rt.fmtWriteFmt(f, [args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + return rs.fmtWriteFmt(f, [args2[0]]); } //# sourceMappingURL=inside.Shown.ts.map diff --git a/ts/fixtures/task/expected/drops/inside.Spent.ts b/ts/fixtures/task/expected/drops/inside.Spent.ts index 846780b25..edb5c3abc 100644 --- a/ts/fixtures/task/expected/drops/inside.Spent.ts +++ b/ts/fixtures/task/expected/drops/inside.Spent.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Guard from "../model.Guard.ts"; /** A `RangeBounds` that logs reading its bounds and its drop. */ export class Spent { _0: Guard.Guard; - _1: rt.usize; - _2: rt.usize; + _1: rs.usize; + _2: rs.usize; - constructor(_0: Guard.Guard, _1: rt.usize, _2: rt.usize) { + constructor(_0: Guard.Guard, _1: rs.usize, _2: rs.usize) { this._0 = _0; this._1 = _1; this._2 = _2; @@ -20,14 +20,14 @@ export class Spent { } } -export function startBound$ops_RangeBounds_usize(self: Spent): rt.RangeBound { +export function startBound$ops_RangeBounds_usize(self: Spent): rs.RangeBound { Guard.note(self._0, "start"); - return { tag: "Included", _0: self._1 } as rt.RangeBound; + return { tag: "Included", _0: self._1 } as rs.RangeBound; } -export function endBound$ops_RangeBounds_usize(self: Spent): rt.RangeBound { +export function endBound$ops_RangeBounds_usize(self: Spent): rs.RangeBound { Guard.note(self._0, "end"); - return { tag: "Excluded", _0: self._2 } as rt.RangeBound; + return { tag: "Excluded", _0: self._2 } as rs.RangeBound; } //# sourceMappingURL=inside.Spent.ts.map diff --git a/ts/fixtures/task/expected/drops/inside.ts b/ts/fixtures/task/expected/drops/inside.ts index 1b701a5ac..c9931b0a8 100644 --- a/ts/fixtures/task/expected/drops/inside.ts +++ b/ts/fixtures/task/expected/drops/inside.ts @@ -1,8 +1,8 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$ops_RangeInclusive_drops_Key as lib_drop$ops_RangeInclusive_drops_Key, drop$ops_Range_drops_Key as lib_drop$ops_Range_drops_Key, drop$ops_Range_model_Guard as lib_drop$ops_Range_model_Guard, drop$tuple2_drops_Key_model_Guard as lib_drop$tuple2_drops_Key_model_Guard } from "../lib.ts"; -import { map$0782hf5 as option_map$0782hf5, map$1raha9y as option_map$1raha9y } from "../core/option.ts"; +import { map$0bmexgo as option_map$0bmexgo, map$06w9waf as option_map$06w9waf } from "../core/option.ts"; import * as Bomb from "../drops/inside.Bomb.ts"; import * as Listed from "../drops/inside.Listed.ts"; import * as Spent from "../drops/inside.Spent.ts"; @@ -11,284 +11,284 @@ import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 10`. */ -export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { - let _261!: rt.usize; - let _328!: rt.u32; +export function inside(log: Log.Log, id: rs.u32, arg: rs.u8): void { + let _261!: rs.usize; + let _328!: rs.u32; let f!: Guard.Guard; - const guard: (a0: rt.u32) => Guard.Guard = (n5: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n5), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n5: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n5), Log.clone$Clone(log)); }; - const key: (a0: rt.u32) => Key.Key = (n6: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n6), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n6: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n6), Log.clone$Clone(log)); }; - const _8: rt.u8 = rt.u8Rem(arg, 10); + const _8: rs.u8 = rs.u8Rem(arg, 10); if (_8 === 0) { - const iter: rt.Iter = rt.iterSlice(Uint8Array.of(0, 1, 3)); + const iter: rs.Iter = rs.iterSlice(Uint8Array.of(0, 1, 3)); while (true) { - const _13: rt.u8 | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: rs.u8 | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const n: rt.u8 = _13; + const n: rs.u8 = _13; const _24: Log.Log = Log.clone$Clone(log); const _23: Listed.Listed = new Listed.Listed(id, _24, n); - const args2: rt.Fmt[] = [(f: rt.Formatter) => Listed.fmt$fmt_Debug(_23, f)]; - const _19: string = rt.fmtFormat(["listed ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_23, f)]; + const _19: string = rs.fmtFormat(["listed ", args2[0]]); _23[Symbol.dispose](); Log.note(log, _19); } const _36: Log.Log = Log.clone$Clone(log); const _35: Listed.Listed = new Listed.Listed(id, _36, 2); - const args4: rt.Fmt[] = [(f: rt.Formatter) => Listed.fmt$fmt_Debug(_35, f)]; - const _31: string = rt.fmtFormat(["pretty ", rt.fmtSpec({ alternate: true }, args4[0])]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => Listed.fmt$fmt_Debug(_35, f)]; + const _31: string = rs.fmtFormat(["pretty ", rs.fmtSpec({ alternate: true }, args4[0])]); _35[Symbol.dispose](); Log.note(log, _31); } else if (_8 === 1) { - const _42: rt.Range = new rt.Range(guard(1), guard(2)); - rt.dropAll([_42.start, _42.end]); - const _50: rt.RangeInclusive = new rt.RangeInclusive(guard(3), guard(4)); - rt.dropAll([_50.lo, _50.hi]); - new rt.RangeFrom(guard(5)).start[Symbol.dispose](); + const _42: rs.Range = new rs.Range(guard(1), guard(2)); + rs.dropAll([_42.start, _42.end]); + const _50: rs.RangeInclusive = new rs.RangeInclusive(guard(3), guard(4)); + rs.dropAll([_50.lo, _50.hi]); + new rs.RangeFrom(guard(5)).start[Symbol.dispose](); ({ end: guard(6) }.end[Symbol.dispose]()); ({ end: guard(7), inclusive: true }.end[Symbol.dispose]()); - const r: rt.Range = new rt.Range(guard(8), guard(9)); + const r: rs.Range = new rs.Range(guard(8), guard(9)); const start: Guard.Guard = r.start; const part20 = Guard.id(start); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part20, f)]; - Log.note(log, rt.fmtFormat(["moved ", args6[0]])); - const ranges: rt.Vec> = rt.vecFrom([new rt.Range(guard(10), guard(11)), new rt.Range(guard(12), guard(13))]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part20, f)]; + Log.note(log, rs.fmtFormat(["moved ", args6[0]])); + const ranges: rs.Vec> = rs.vecFrom([new rs.Range(guard(10), guard(11)), new rs.Range(guard(12), guard(13))]); const part21 = ranges.items.length; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part21, f)]; - Log.note(log, rt.fmtFormat(["ranges ", args8[0]])); - rt.dropVec(ranges, lib_drop$ops_Range_model_Guard); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part21, f)]; + Log.note(log, rs.fmtFormat(["ranges ", args8[0]])); + rs.dropVec(ranges, lib_drop$ops_Range_model_Guard); start[Symbol.dispose](); r.end[Symbol.dispose](); } else if (_8 === 2) { - const v: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(1, 6), guard), undefined, 8, true); - const taken: rt.Vec = rt.iterToVec(rt.dropAfter(new Spent.Spent(guard(10), 1, 3), (range12) => rt.vecDrain(v, rt.boundsOf(range12, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop), "fold", 8, true); - const _136: rt.usize = taken.items.length; - const _139: rt.usize = v.items.length; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_136, f), (f: rt.Formatter) => rt.usizeDisplay(_139, f)]; - Log.note(log, rt.fmtFormat(["drained ", args10[0], " ", args10[1]])); - const q: rt.VecDeque = rt.dequeFromVec(rt.iterToVec(rt.iterMap(new rt.Range(6, 9), guard), undefined, 8, true), 8) as rt.VecDeque; - const it: rt.Iter = rt.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rt.dequeDrain(q, rt.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop); - const part17 = option_map$1raha9y(rt.iterToOption(it.next()), (g12: Guard.Guard): rt.u32 => { - const _012: rt.u32 = Guard.id(g12); + const v: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(1, 6), guard), undefined, 8, true); + const taken: rs.Vec = rs.iterToVec(rs.dropAfter(new Spent.Spent(guard(10), 1, 3), (range12) => rs.vecDrain(v, rs.boundsOf(range12, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop), "fold", 8, true); + const _136: rs.usize = taken.items.length; + const _139: rs.usize = v.items.length; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_136, f), (f: rs.Formatter) => rs.usizeDisplay(_139, f)]; + Log.note(log, rs.fmtFormat(["drained ", args10[0], " ", args10[1]])); + const q: rs.VecDeque = rs.dequeFromVec(rs.iterToVec(rs.iterMap(new rs.Range(6, 9), guard), undefined, 8, true), 8) as rs.VecDeque; + const it: rs.Iter = rs.dropAfter(new Spent.Spent(guard(11), 0, 2), (range13) => rs.dequeDrain(q, rs.boundsOf(range13, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop); + const part17 = option_map$06w9waf(rs.iterToOption(it.next()), (g12: Guard.Guard): rs.u32 => { + const _012: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _012; }); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part17, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["deque ", args12[0]])); - rt.drop(it); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part17, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["deque ", args12[0]])); + rs.drop(it); let s: string = "abcdef"; const _180: Spent.Spent = new Spent.Spent(guard(12), 1, 3); - const s4 = rt.place(() => s, (value2) => s = value2); - const part18 = rt.stringExtendChars("", rt.stringDrain(s4, rt.dropAfter(_180, (range14) => rt.boundsChecked(rt.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.stringLen(s4.v)), rt.drop)), true); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part18)]; - Log.note(log, rt.fmtFormat(["text ", args14[0]])); + const s4 = rs.place(() => s, (value2) => s = value2); + const part18 = rs.stringExtendChars("", rs.stringDrain(s4, rs.dropAfter(_180, (range14) => rs.boundsChecked(rs.boundsOf(range14, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s4.v)), rs.drop)), true); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; + Log.note(log, rs.fmtFormat(["text ", args14[0]])); const _190: Spent.Spent = new Spent.Spent(guard(13), 0, 1); - s = rt.stringReplaceRange(s, rt.dropAfter(_190, (range15) => rt.boundsChecked(rt.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.stringLen(s)), rt.drop), "xy"); + s = rs.stringReplaceRange(s, rs.dropAfter(_190, (range15) => rs.boundsChecked(rs.boundsOf(range15, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop), "xy"); const _197: Spent.Spent = new Spent.Spent(guard(14), 2, 4); - s = rt.stringExtendFromWithin(s, rt.dropAfter(_197, (range16) => rt.boundsChecked(rt.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.stringLen(s)), rt.drop)); + s = rs.stringExtendFromWithin(s, rs.dropAfter(_197, (range16) => rs.boundsChecked(rs.boundsOf(range16, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.stringLen(s)), rs.drop)); const bytes: Uint8Array = Uint8Array.of(1, 2, 3, 4); - const _203: rt.ByteSlice = rt.byteSliceFrom(bytes); - const bounds = rt.dropAfter(new Spent.Spent(guard(15), 0, 2), (range17) => rt.boundsRange(rt.boundsOf(range17, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), _203.length), rt.drop); - rt.byteSliceCopyWithin(_203, bounds[0], bounds[1], 2); - [s, rt.byteSliceFrom(bytes)] as [string, rt.ByteSlice]; - const _217: rt.Fmt = (f: rt.Formatter) => rt.fmtPad(f, s); - const arg2 = rt.byteSliceFrom(bytes); - const args16: rt.Fmt[] = [_217, (f: rt.Formatter) => rt.fmtList(rt.byteSliceView(arg2), f, rt.u8Debug)]; - Log.note(log, rt.fmtFormat(["edited ", args16[0], " ", args16[1]])); - const none: rt.Vec = rt.iterToVec(rt.dropAfter(new Spent.Spent(guard(16), 1, 1), (range18) => rt.vecDrain(v, rt.boundsOf(range18, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop), "fold", 8, true); + const _203: rs.ByteSlice = rs.byteSliceFrom(bytes); + const bounds = rs.dropAfter(new Spent.Spent(guard(15), 0, 2), (range17) => rs.boundsRange(rs.boundsOf(range17, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), _203.length), rs.drop); + rs.byteSliceCopyWithin(_203, bounds[0], bounds[1], 2); + [s, rs.byteSliceFrom(bytes)] as [string, rs.ByteSlice]; + const _217: rs.Fmt = (f: rs.Formatter) => rs.fmtPad(f, s); + const arg2 = rs.byteSliceFrom(bytes); + const args16: rs.Fmt[] = [_217, (f: rs.Formatter) => rs.fmtList(rs.byteSliceView(arg2), f, rs.u8Debug)]; + Log.note(log, rs.fmtFormat(["edited ", args16[0], " ", args16[1]])); + const none: rs.Vec = rs.iterToVec(rs.dropAfter(new Spent.Spent(guard(16), 1, 1), (range18) => rs.vecDrain(v, rs.boundsOf(range18, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop), "fold", 8, true); const part19 = none.items.length; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part19, f)]; - Log.note(log, rt.fmtFormat(["none ", args18[0]])); - rt.dropVec(none); - rt.dequeDrop(q, rt.drop); - rt.dropVec(taken); - rt.dropVec(v); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part19, f)]; + Log.note(log, rs.fmtFormat(["none ", args18[0]])); + rs.dropVec(none); + rs.dequeDrop(q, rs.drop); + rs.dropVec(taken); + rs.dropVec(v); } else if (_8 === 3) { - const map: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; - const part13 = rt.iterCount(rt.dropAfter(new Spent.Spent(guard(1), 0, 1), (range8) => rt.btreeRange(map, rt.boundsOf(range8, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rt.drop)); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part13, f)]; - Log.note(log, rt.fmtFormat(["empty ", args20[0]])); - let iterStart: rt.usize = 0; - const iterEnd: rt.usize = 4; + const map: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; + const part13 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(1), 0, 1), (range8) => rs.btreeRange(map, rs.boundsOf(range8, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part13, f)]; + Log.note(log, rs.fmtFormat(["empty ", args20[0]])); + let iterStart: rs.usize = 0; + const iterEnd: rs.usize = 4; while ((_261 = iterStart++) < iterEnd) { - const n2: rt.usize = _261; - const _267: Guard.Guard = guard(rt.u32Add(10, n2 as rt.u32)); - rt.drop(rt.btreeInsert(map, n2, _267)); + const n2: rs.usize = _261; + const _267: Guard.Guard = guard(rs.u32Add(10, n2 as rs.u32)); + rs.drop(rs.btreeInsert(map, n2, _267)); } - const part15 = rt.iterCount(rt.dropAfter(new Spent.Spent(guard(2), 1, 3), (range9) => rt.btreeRange(map, rt.boundsOf(range9, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rt.drop)); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part15, f)]; - Log.note(log, rt.fmtFormat(["map ", args22[0]])); - const iter3: rt.Iter<[rt.usize, Guard.Guard]> = rt.dropAfter(new Spent.Spent(guard(3), 2, 9), (range10) => rt.btreeRange(map, rt.boundsOf(range10, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rt.drop); + const part15 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(2), 1, 3), (range9) => rs.btreeRange(map, rs.boundsOf(range9, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part15, f)]; + Log.note(log, rs.fmtFormat(["map ", args22[0]])); + const iter3: rs.Iter<[rs.usize, Guard.Guard]> = rs.dropAfter(new Spent.Spent(guard(3), 2, 9), (range10) => rs.btreeRange(map, rs.boundsOf(range10, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop); while (true) { - const _298: [rt.usize, Guard.Guard] | rt.Done = iter3.next(); - if (_298 === rt.DONE) { + const _298: [rs.usize, Guard.Guard] | rs.Done = iter3.next(); + if (_298 === rs.DONE) { break; } Guard.note(_298[1], "ranged"); } - const set: rt.BTreeSet = rt.btreeExtendKeys(rt.btreeNew(rt.cmp) as rt.BTreeSet, new rt.Range(0, 5), true, undefined, undefined, 4, true); - const part16 = rt.iterCount(rt.dropAfter(new Spent.Spent(guard(4), 3, 5), (range11) => rt.btreeRangeKeys(set, rt.boundsOf(range11, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rt.drop)); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part16, f)]; - Log.note(log, rt.fmtFormat(["set ", args24[0]])); - rt.btreeDrop(map, undefined, rt.drop); + const set: rs.BTreeSet = rs.btreeExtendKeys(rs.btreeNew(rs.cmp) as rs.BTreeSet, new rs.Range(0, 5), true, undefined, undefined, 4, true); + const part16 = rs.iterCount(rs.dropAfter(new Spent.Spent(guard(4), 3, 5), (range11) => rs.btreeRangeKeys(set, rs.boundsOf(range11, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize)), rs.drop)); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part16, f)]; + Log.note(log, rs.fmtFormat(["set ", args24[0]])); + rs.btreeDrop(map, undefined, rs.drop); } else if (_8 === 4) { - const map2: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; - let iterStart2: rt.u32 = 1; - const iterEnd2: rt.u32 = 5; + const map2: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; + let iterStart2: rs.u32 = 1; + const iterEnd2: rs.u32 = 5; while ((_328 = iterStart2++) < iterEnd2) { - const n3: rt.u32 = _328; + const n3: rs.u32 = _328; const _334: Key.Key = key(n3); - rt.btreeInsert(map2, _334, n3, rt.drop); + rs.btreeInsert(map2, _334, n3, rs.drop); } - const part12 = rt.iterToVec(rt.iterMap(rt.dropAfter(new rt.Range(key(2), key(4)), (range5) => rt.btreeRange(map2, range5, Key.eq$cmp_PartialEq, rt.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key), (_2: [Key.Key, rt.u32]): rt.u32 => { + const part12 = rs.iterToVec(rs.iterMap(rs.dropAfter(new rs.Range(key(2), key(4)), (range5) => rs.btreeRange(map2, range5, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key), (_2: [Key.Key, rs.u32]): rs.u32 => { return _2[1]; }), "next", 4); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part12.items, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["keys ", args26[0]])); - const found2: rt.usize = rt.iterCount(rt.dropAfter(new rt.RangeInclusive(key(3), key(9)), (range6) => rt.btreeRange(map2, range6, Key.eq$cmp_PartialEq, rt.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_RangeInclusive_drops_Key)); - const _371: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; - const none2: rt.usize = rt.iterCount(rt.dropAfter(new rt.Range(key(5), key(6)), (range7) => rt.btreeRange(_371, range7, Key.eq$cmp_PartialEq, rt.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key)); - rt.btreeDrop(_371, rt.drop); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(found2, f), (f: rt.Formatter) => rt.usizeDisplay(none2, f)]; - Log.note(log, rt.fmtFormat(["keys ", args28[0], " ", args28[1]])); - rt.btreeDrop(map2, rt.drop); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part12.items, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["keys ", args26[0]])); + const found2: rs.usize = rs.iterCount(rs.dropAfter(new rs.RangeInclusive(key(3), key(9)), (range6) => rs.btreeRange(map2, range6, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_RangeInclusive_drops_Key)); + const _371: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; + const none2: rs.usize = rs.iterCount(rs.dropAfter(new rs.Range(key(5), key(6)), (range7) => rs.btreeRange(_371, range7, Key.eq$cmp_PartialEq, rs.cmpGt(Key.partialCmp$cmp_PartialOrd)), lib_drop$ops_Range_drops_Key)); + rs.btreeDrop(_371, rs.drop); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(found2, f), (f: rs.Formatter) => rs.usizeDisplay(none2, f)]; + Log.note(log, rs.fmtFormat(["keys ", args28[0], " ", args28[1]])); + rs.btreeDrop(map2, rs.drop); } else if (_8 === 5) { - const map3: (a0: rt.u32) => rt.HashMap = (n9: rt.u32): rt.HashMap => { + const map3: (a0: rs.u32) => rs.HashMap = (n9: rs.u32): rs.HashMap => { const _318: [Key.Key, Guard.Guard][] = [[key(n9), guard(n9)] as [Key.Key, Guard.Guard]]; - return rt.hashExtend(rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap, rt.iterSlice(_318, lib_drop$tuple2_drops_Key_model_Guard), rt.drop, rt.drop, "fold", 58720256); + return rs.hashExtend(rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap, rs.iterSlice(_318, lib_drop$tuple2_drops_Key_model_Guard), rs.drop, rs.drop, "fold", 58720256); }; - const keys: rt.Iter = rt.hashKeys(map3(1), rt.drop, rt.drop); - const part5 = option_map$0782hf5(rt.iterToOption(keys.next()), (k2: Key.Key): rt.u32 => { - const _07: rt.u32 = rt.u32Sub(k2.id, id); + const keys: rs.Iter = rs.hashKeys(map3(1), rs.drop, rs.drop); + const part5 = option_map$0bmexgo(rs.iterToOption(keys.next()), (k2: Key.Key): rs.u32 => { + const _07: rs.u32 = rs.u32Sub(k2.id, id); k2[Symbol.dispose](); return _07; }); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["next ", args30[0]])); - const _421: Key.Key | undefined = rt.iterToOption(keys.next()); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["next ", args30[0]])); + const _421: Key.Key | undefined = rs.iterToOption(keys.next()); const part6 = _421 === undefined; - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part6, f)]; - const _415: string = rt.fmtFormat(["done ", args32[0]]); - rt.drop(_421); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; + const _415: string = rs.fmtFormat(["done ", args32[0]]); + rs.drop(_421); Log.note(log, _415); - rt.iterForEach(rt.hashValues(map3(2), rt.drop, rt.drop), (g8: Guard.Guard): undefined => { + rs.iterForEach(rs.hashValues(map3(2), rs.drop, rs.drop), (g8: Guard.Guard): undefined => { Guard.note(g8, "each"); g8[Symbol.dispose](); }, true); - rt.iterFold(rt.hashKeys(map3(3), rt.drop, rt.drop), undefined, (_: undefined, k3: Key.Key): undefined => { - const part7 = rt.u32Sub(k3.id, id); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["fold ", args58[0]])); + rs.iterFold(rs.hashKeys(map3(3), rs.drop, rs.drop), undefined, (_: undefined, k3: Key.Key): undefined => { + const part7 = rs.u32Sub(k3.id, id); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["fold ", args58[0]])); k3[Symbol.dispose](); }, true); - const part8 = option_map$1raha9y(rt.ownedLast(rt.hashValues(map3(4), rt.drop, rt.drop), rt.drop), (g9: Guard.Guard): rt.u32 => { - const _08: rt.u32 = Guard.id(g9); + const part8 = option_map$06w9waf(rs.ownedLast(rs.hashValues(map3(4), rs.drop, rs.drop), rs.drop), (g9: Guard.Guard): rs.u32 => { + const _08: rs.u32 = Guard.id(g9); g9[Symbol.dispose](); return _08; }); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["last ", args34[0]])); - const part9 = rt.ownedCount(rt.hashKeys(map3(5), rt.drop, rt.drop), rt.drop); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part9, f)]; - Log.note(log, rt.fmtFormat(["count ", args36[0]])); - const _472: rt.Iter = rt.hashValues(map3(6), rt.drop, rt.drop); - const found3: Guard.Guard | undefined = rt.iterFind(_472, (g10: Guard.Guard): boolean => { - return Guard.id(g10) === rt.u32Add(id, 6); - }, rt.drop); - rt.drop(_472); - const part10 = option_map$1raha9y(found3, (g11: Guard.Guard): rt.u32 => { - const _010: rt.u32 = Guard.id(g11); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args34[0]])); + const part9 = rs.ownedCount(rs.hashKeys(map3(5), rs.drop, rs.drop), rs.drop); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; + Log.note(log, rs.fmtFormat(["count ", args36[0]])); + const _472: rs.Iter = rs.hashValues(map3(6), rs.drop, rs.drop); + const found3: Guard.Guard | undefined = rs.iterFind(_472, (g10: Guard.Guard): boolean => { + return Guard.id(g10) === rs.u32Add(id, 6); + }, rs.drop); + rs.drop(_472); + const part10 = option_map$06w9waf(found3, (g11: Guard.Guard): rs.u32 => { + const _010: rs.u32 = Guard.id(g11); g11[Symbol.dispose](); return _010; }); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part10, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["found ", args38[0]])); - const part11 = rt.iterSum(rt.iterMap(rt.hashKeys(map3(7), rt.drop, rt.drop), (k4: Key.Key): rt.u32 => { - const _011: rt.u32 = rt.u32Sub(k4.id, id); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["found ", args38[0]])); + const part11 = rs.iterSum(rs.iterMap(rs.hashKeys(map3(7), rs.drop, rs.drop), (k4: Key.Key): rs.u32 => { + const _011: rs.u32 = rs.u32Sub(k4.id, id); k4[Symbol.dispose](); return _011; - }), rt.u32Add, 0, true); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part11, f)]; - Log.note(log, rt.fmtFormat(["sum ", args40[0]])); - const taken2: rt.Vec = rt.iterToVec(rt.iterTake(rt.hashValues(map3(8), rt.drop, rt.drop), 0, rt.drop), "next", 8); - const none3: rt.usize = rt.ownedCount(rt.hashKeys(rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap, rt.drop, rt.drop), rt.drop); - const _522: rt.usize = taken2.items.length; - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_522, f), (f: rt.Formatter) => rt.usizeDisplay(none3, f)]; - Log.note(log, rt.fmtFormat(["taken ", args42[0], " ", args42[1]])); - rt.dropVec(taken2); - rt.drop(keys); + }), rs.u32Add, 0, true); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; + Log.note(log, rs.fmtFormat(["sum ", args40[0]])); + const taken2: rs.Vec = rs.iterToVec(rs.iterTake(rs.hashValues(map3(8), rs.drop, rs.drop), 0, rs.drop), "next", 8); + const none3: rs.usize = rs.ownedCount(rs.hashKeys(rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap, rs.drop, rs.drop), rs.drop); + const _522: rs.usize = taken2.items.length; + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_522, f), (f: rs.Formatter) => rs.usizeDisplay(none3, f)]; + Log.note(log, rs.fmtFormat(["taken ", args42[0], " ", args42[1]])); + rs.dropVec(taken2); + rs.drop(keys); } else if (_8 === 6) { const _534: [Guard.Guard, Guard.Guard, Guard.Guard, Guard.Guard] = [guard(10), guard(11), guard(12), guard(13)]; const c: Guard.Guard = _534[0]; const d: Guard.Guard = _534[1]; const e: Guard.Guard = _534[2]; f = _534[3]; - const _551: rt.Iter = rt.iterTake(rt.vecIntoIter(rt.iterToVec(rt.iterMap(new rt.Range(1, 5), guard), undefined, 8, true), rt.drop), 2, rt.drop); + const _551: rs.Iter = rs.iterTake(rs.vecIntoIter(rs.iterToVec(rs.iterMap(new rs.Range(1, 5), guard), undefined, 8, true), rs.drop), 2, rs.drop); const captured3 = c; - rt.iterForEach(_551, rt.closure((g2: Guard.Guard): undefined => { + rs.iterForEach(_551, rs.closure((g2: Guard.Guard): undefined => { const part = Guard.id(captured3); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - const _49: string = rt.fmtFormat(["each ", args50[0]]); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + const _49: string = rs.fmtFormat(["each ", args50[0]]); Guard.note(g2, _49); g2[Symbol.dispose](); }, (): void => { captured3[Symbol.dispose](); }), true, true); const held: Guard.Guard = guard(14); - const _559: rt.Iter = rt.vecIntoIter(rt.iterToVec(rt.iterMap(new rt.Range(5, 8), guard), undefined, 8, true), rt.drop); + const _559: rs.Iter = rs.vecIntoIter(rs.iterToVec(rs.iterMap(new rs.Range(5, 8), guard), undefined, 8, true), rs.drop); const captured4 = held; - const _558: rt.Iter<[Guard.Guard, rt.u32]> = rt.iterMap(_559, rt.closure((g3: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g3, Guard.id(captured4)] as [Guard.Guard, rt.u32]; + const _558: rs.Iter<[Guard.Guard, rs.u32]> = rs.iterMap(_559, rs.closure((g3: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g3, Guard.id(captured4)] as [Guard.Guard, rs.u32]; }, (): void => { captured4[Symbol.dispose](); })); const captured5 = d; - const part2 = rt.iterFold(_558, 0, rt.closure((n7: rt.i32, _311: [Guard.Guard, rt.u32]): rt.i32 => { + const part2 = rs.iterFold(_558, 0, rs.closure((n7: rs.i32, _311: [Guard.Guard, rs.u32]): rs.i32 => { const g4: Guard.Guard = _311[0]; - const h: rt.u32 = _311[1]; - const _155: rt.u32 = Guard.id(captured5); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(h, f), (f: rt.Formatter) => rt.u32Display(_155, f)]; - const _87: string = rt.fmtFormat(["fold ", args52[0], " ", args52[1]]); + const h: rs.u32 = _311[1]; + const _155: rs.u32 = Guard.id(captured5); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(h, f), (f: rs.Formatter) => rs.u32Display(_155, f)]; + const _87: string = rs.fmtFormat(["fold ", args52[0], " ", args52[1]]); Guard.note(g4, _87); - const _04: rt.i32 = rt.i32Add(n7, 1); + const _04: rs.i32 = rs.i32Add(n7, 1); g4[Symbol.dispose](); return _04; }, (): void => { captured5[Symbol.dispose](); }), true, true); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.i32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["folded ", args44[0]])); - const _576: rt.Iter = rt.iterSlice([1, 2]); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.i32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["folded ", args44[0]])); + const _576: rs.Iter = rs.iterSlice([1, 2]); const captured6 = e; - rt.iterForEach(_576, rt.closure((n8: rt.u32): undefined => { - const _88: rt.u32 = Guard.id(captured6); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n8, f), (f: rt.Formatter) => rt.u32Display(_88, f)]; - Log.note(log, rt.fmtFormat(["plain ", args54[0], " ", args54[1]])); + rs.iterForEach(_576, rs.closure((n8: rs.u32): undefined => { + const _88: rs.u32 = Guard.id(captured6); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n8, f), (f: rs.Formatter) => rs.u32Display(_88, f)]; + Log.note(log, rs.fmtFormat(["plain ", args54[0], " ", args54[1]])); }, (): void => { captured6[Symbol.dispose](); }), undefined, true); - const _581: rt.Iter = rt.vecIntoIter(new rt.Vec(), rt.drop); + const _581: rs.Iter = rs.vecIntoIter(new rs.Vec(), rs.drop); const captured7 = f; - rt.iterForEach(_581, rt.closure((g5: Guard.Guard): undefined => { + rs.iterForEach(_581, rs.closure((g5: Guard.Guard): undefined => { const part3 = Guard.id(captured7); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - const _413: string = rt.fmtFormat([args56[0]]); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + const _413: string = rs.fmtFormat([args56[0]]); Guard.note(g5, _413); g5[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); }), true, true); - const kept: Guard.Guard = rt.iterFold(rt.iterMap(new rt.Range(8, 10), guard), guard(15), (kept2: Guard.Guard, g6: Guard.Guard): Guard.Guard => { + const kept: Guard.Guard = rs.iterFold(rs.iterMap(new rs.Range(8, 10), guard), guard(15), (kept2: Guard.Guard, g6: Guard.Guard): Guard.Guard => { let _05!: Guard.Guard; let _108: boolean = false; let _92: boolean = false; _108 = true; _92 = true; - if (!(rt.u32Rem(Guard.id(g6), 2) === 0)) { + if (!(rs.u32Rem(Guard.id(g6), 2) === 0)) { _108 = false; _05 = kept2; } else { @@ -305,34 +305,34 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { return _05; }); const part4 = Guard.id(kept); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["kept ", args46[0]])); - const _604: [Guard.Guard, rt.u32] = [guard(16), 0]; + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["kept ", args46[0]])); + const _604: [Guard.Guard, rs.u32] = [guard(16), 0]; const k: Guard.Guard = _604[0]; let captured8 = 0; const captured9 = k; const captured10 = id; - const count: (a0: Guard.Guard) => undefined = rt.closure((g7: Guard.Guard): undefined => { - captured8 = rt.u32Add(captured8, rt.u32Sub(rt.u32Add(Guard.id(g7), Guard.id(captured9)), rt.u32Mul(2, captured10))); + const count: (a0: Guard.Guard) => undefined = rs.closure((g7: Guard.Guard): undefined => { + captured8 = rs.u32Add(captured8, rs.u32Sub(rs.u32Add(Guard.id(g7), Guard.id(captured9)), rs.u32Mul(2, captured10))); g7[Symbol.dispose](); }, (): void => { captured9[Symbol.dispose](); }); - rt.iterForEach(rt.iterMap(new rt.Range(17, 19), guard), count); + rs.iterForEach(rs.iterMap(new rs.Range(17, 19), guard), count); Log.note(log, "lent"); - rt.drop(count); + rs.drop(count); kept[Symbol.dispose](); } else if (_8 === 7) { const c2: Guard.Guard = guard(10); - const _622: rt.Iter = rt.iterMap(new rt.Range(1, 4), guard); + const _622: rs.Iter = rs.iterMap(new rs.Range(1, 4), guard); const captured = id; const captured2 = c2; - rt.iterForEach(_622, rt.closure((g: Guard.Guard): undefined => { - if (!(Guard.id(g) !== rt.u32Add(captured, 2))) { - const _134: rt.u32 = Guard.id(g); - const _16: rt.u32 = Guard.id(captured2); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_134, f), (f: rt.Formatter) => rt.u32Display(_16, f)]; - rt.panicFmt(["g", args48[0], " with ", args48[1]]); + rs.iterForEach(_622, rs.closure((g: Guard.Guard): undefined => { + if (!(Guard.id(g) !== rs.u32Add(captured, 2))) { + const _134: rs.u32 = Guard.id(g); + const _16: rs.u32 = Guard.id(captured2); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_134, f), (f: rs.Formatter) => rs.u32Display(_16, f)]; + rs.panicFmt(["g", args48[0], " with ", args48[1]]); } else { g[Symbol.dispose](); } @@ -340,20 +340,20 @@ export function inside(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured2[Symbol.dispose](); }), undefined, true); } else if (_8 === 8) { - const v3: rt.Vec = rt.iterToVec(rt.iterMap(new rt.Range(1, 3), guard), undefined, 8, true); - rt.drop(rt.dropAfter(new Spent.Spent(guard(10), 1, 4), (range4) => rt.vecDrain(v3, rt.boundsOf(range4, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rt.drop), rt.drop)); - rt.dropVec(v3); + const v3: rs.Vec = rs.iterToVec(rs.iterMap(new rs.Range(1, 3), guard), undefined, 8, true); + rs.drop(rs.dropAfter(new Spent.Spent(guard(10), 1, 4), (range4) => rs.vecDrain(v3, rs.boundsOf(range4, Spent.startBound$ops_RangeBounds_usize, Spent.endBound$ops_RangeBounds_usize), rs.drop), rs.drop)); + rs.dropVec(v3); } else { let s2: string = "é"; const bomb: Bomb.Bomb = new Bomb.Bomb(1, 2); - const _636: rt.u8 = rt.u8Rem(rt.u8Div(arg, 10), 3); + const _636: rs.u8 = rs.u8Rem(rs.u8Div(arg, 10), 3); if (_636 === 0) { - const s3 = rt.place(() => s2, (value) => s2 = value); - rt.drop(rt.stringDrain(s3, rt.dropAfter(bomb, (range3) => rt.boundsChecked(rt.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rt.stringLen(s3.v)), rt.drop))); + const s3 = rs.place(() => s2, (value) => s2 = value); + rs.drop(rs.stringDrain(s3, rs.dropAfter(bomb, (range3) => rs.boundsChecked(rs.boundsOf(range3, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s3.v)), rs.drop))); } else if (_636 === 1) { - s2 = rt.stringReplaceRange(s2, rt.dropAfter(bomb, (range2) => rt.boundsChecked(rt.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rt.stringLen(s2)), rt.drop), "x"); + s2 = rs.stringReplaceRange(s2, rs.dropAfter(bomb, (range2) => rs.boundsChecked(rs.boundsOf(range2, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop), "x"); } else { - s2 = rt.stringExtendFromWithin(s2, rt.dropAfter(bomb, (range) => rt.boundsChecked(rt.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rt.stringLen(s2)), rt.drop)); + s2 = rs.stringExtendFromWithin(s2, rs.dropAfter(bomb, (range) => rs.boundsChecked(rs.boundsOf(range, Bomb.startBound$ops_RangeBounds_usize, Bomb.endBound$ops_RangeBounds_usize), rs.stringLen(s2)), rs.drop)); } } } diff --git a/ts/fixtures/task/expected/drops/iters.ts b/ts/fixtures/task/expected/drops/iters.ts index bbfba9a55..13adec8c3 100644 --- a/ts/fixtures/task/expected/drops/iters.ts +++ b/ts/fixtures/task/expected/drops/iters.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_tuple2_drops_Key_model_Guard as lib_drop$Option_tuple2_drops_Key_model_Guard, drop$Result_Vec_model_Guard_model_Guard as lib_drop$Result_Vec_model_Guard_model_Guard, drop$Vec_model_Guard as lib_drop$Vec_model_Guard, drop$tuple2_drops_Key_model_Guard as lib_drop$tuple2_drops_Key_model_Guard, drop$tuple2_model_Guard_model_Guard as lib_drop$tuple2_model_Guard_model_Guard, drop$tuple2_model_Guard_u32 as lib_drop$tuple2_model_Guard_u32, drop$tuple2_u32_model_Guard as lib_drop$tuple2_u32_model_Guard } from "../lib.ts"; -import { mapOr$184639r as option_mapOr$184639r, mapOr$00i7kb3 as option_mapOr$00i7kb3, mapOr$1w10sgd as option_mapOr$1w10sgd, mapOr$01ozsk3 as option_mapOr$01ozsk3 } from "../core/option.ts"; +import { mapOr$090948l as option_mapOr$090948l, mapOr$16nkz0h as option_mapOr$16nkz0h, mapOr$0mko9ta as option_mapOr$0mko9ta, mapOr$1re20rq as option_mapOr$1re20rq } from "../core/option.ts"; import * as Key from "../drops.Key.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** What `for` leaves of what it iterates, and what adaptors discard, hold, and return. */ -export function looped(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function looped(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const v: rt.Vec = new rt.Vec(); + const v: rs.Vec = new rs.Vec(); const _10: Guard.Guard = guard(1); v.items.push(_10); const _15: Guard.Guard = guard(2); @@ -22,46 +22,46 @@ export function looped(log: Log.Log, id: rt.u32): void { const iterS: Guard.Guard[] = v.items; let iterI: number = 0; while (true) { - const _24: Guard.Guard | rt.Done = iterI < iterS.length ? iterS[iterI++] : rt.DONE; - if (_24 === rt.DONE) { + const _24: Guard.Guard | rs.Done = iterI < iterS.length ? iterS[iterI++] : rs.DONE; + if (_24 === rs.DONE) { break; } const g: Guard.Guard = _24; - if (!(Guard.id(g) === rt.u32Add(id, 2))) { + if (!(Guard.id(g) === rs.u32Add(id, 2))) { g[Symbol.dispose](); } else { g[Symbol.dispose](); break; } } - rt.dropAll(iterS, rt.drop, iterI); - const iter2: rt.Iter = rt.iterSlice([guard(4), guard(5), guard(6)], rt.drop); + rs.dropAll(iterS, rs.drop, iterI); + const iter2: rs.Iter = rs.iterSlice([guard(4), guard(5), guard(6)], rs.drop); while (true) { - const _45: Guard.Guard | rt.Done = iter2.next(); - if (_45 === rt.DONE) { + const _45: Guard.Guard | rs.Done = iter2.next(); + if (_45 === rs.DONE) { break; } const g2: Guard.Guard = _45; const part = Guard.id(g2); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["array ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["array ", args2[0]])); g2[Symbol.dispose](); } - rt.drop(iter2); - const iter3: rt.Iter = rt.iterOption(guard(7), rt.drop); + rs.drop(iter2); + const iter3: rs.Iter = rs.iterOption(guard(7), rs.drop); while (true) { - const _67: Guard.Guard | rt.Done = iter3.next(); - if (_67 === rt.DONE) { + const _67: Guard.Guard | rs.Done = iter3.next(); + if (_67 === rs.DONE) { break; } const g3: Guard.Guard = _67; const part2 = Guard.id(g3); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["option ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["option ", args4[0]])); g3[Symbol.dispose](); } - rt.drop(iter3); - const v2: rt.Vec = new rt.Vec(); + rs.drop(iter3); + const v2: rs.Vec = new rs.Vec(); const _90: Guard.Guard = guard(8); v2.items.push(_90); const _95: Guard.Guard = guard(9); @@ -70,13 +70,13 @@ export function looped(log: Log.Log, id: rt.u32): void { v2.items.push(_100); const _105: Guard.Guard = guard(11); v2.items.push(_105); - const even: rt.Vec = rt.iterToVec(rt.iterFilter(rt.vecIntoIter(v2, rt.drop), (g4: Guard.Guard): boolean => { - return rt.u32Rem(Guard.id(g4), 2) === 0; - }, rt.drop), "next", 8, false, 8); + const even: rs.Vec = rs.iterToVec(rs.iterFilter(rs.vecIntoIter(v2, rs.drop), (g4: Guard.Guard): boolean => { + return rs.u32Rem(Guard.id(g4), 2) === 0; + }, rs.drop), "next", 8, false, 8); const part3 = even.items.length; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; - Log.note(log, rt.fmtFormat(["even ", args6[0]])); - const v3: rt.Vec = new rt.Vec(); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; + Log.note(log, rs.fmtFormat(["even ", args6[0]])); + const v3: rs.Vec = new rs.Vec(); const _127: Guard.Guard = guard(12); v3.items.push(_127); const _132: Guard.Guard = guard(13); @@ -87,78 +87,78 @@ export function looped(log: Log.Log, id: rt.u32): void { v3.items.push(_142); const _147: Guard.Guard = guard(16); v3.items.push(_147); - const rest: rt.Iter = rt.iterTake(rt.iterSkip(rt.vecIntoIter(v3, rt.drop), 1, rt.drop), 3, rt.drop); - const part4 = option_mapOr$01ozsk3(rt.iterToOption(rest.next()), 0, (g5: Guard.Guard): rt.u32 => { - const _03: rt.u32 = Guard.id(g5); + const rest: rs.Iter = rs.iterTake(rs.iterSkip(rs.vecIntoIter(v3, rs.drop), 1, rs.drop), 3, rs.drop); + const part4 = option_mapOr$1re20rq(rs.iterToOption(rest.next()), 0, (g5: Guard.Guard): rs.u32 => { + const _03: rs.u32 = Guard.id(g5); g5[Symbol.dispose](); return _03; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["next ", args8[0]])); - const part5 = rt.ownedCount(rest, rt.drop); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part5, f)]; - Log.note(log, rt.fmtFormat(["count ", args10[0]])); - const v4: rt.Vec = new rt.Vec(); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["next ", args8[0]])); + const part5 = rs.ownedCount(rest, rs.drop); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; + Log.note(log, rs.fmtFormat(["count ", args10[0]])); + const v4: rs.Vec = new rs.Vec(); const _181: Guard.Guard = guard(17); v4.items.push(_181); const _186: Guard.Guard = guard(18); v4.items.push(_186); - const peek: rt.Peekable = rt.iterPeekable(rt.vecIntoIter(v4, rt.drop), rt.drop); - const first: Guard.Guard | undefined = rt.peekableNextIf(peek, (g6: Guard.Guard): boolean => { - return Guard.id(g6) === rt.u32Add(id, 17); + const peek: rs.Peekable = rs.iterPeekable(rs.vecIntoIter(v4, rs.drop), rs.drop); + const first: Guard.Guard | undefined = rs.peekableNextIf(peek, (g6: Guard.Guard): boolean => { + return Guard.id(g6) === rs.u32Add(id, 17); }); - const second: Guard.Guard | undefined = rt.peekableNextIf(peek, (g7: Guard.Guard): boolean => { - return Guard.id(g7) === rt.u32Add(id, 99); + const second: Guard.Guard | undefined = rs.peekableNextIf(peek, (g7: Guard.Guard): boolean => { + return Guard.id(g7) === rs.u32Add(id, 99); }); const _203: boolean = first !== undefined; const _206: boolean = second !== undefined; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_203, f), (f: rt.Formatter) => rt.fmtBool(_206, f)]; - Log.note(log, rt.fmtFormat(["peek ", args12[0], " ", args12[1]])); - rt.drop(peek); - const v5: rt.Vec = new rt.Vec(); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_203, f), (f: rs.Formatter) => rs.fmtBool(_206, f)]; + Log.note(log, rs.fmtFormat(["peek ", args12[0], " ", args12[1]])); + rs.drop(peek); + const v5: rs.Vec = new rs.Vec(); const _221: Guard.Guard = guard(20); v5.items.push(_221); const _226: Guard.Guard = guard(21); v5.items.push(_226); const _231: Guard.Guard = guard(22); v5.items.push(_231); - const _216: rt.Iter = rt.vecIntoIter(v5, rt.drop); - const v6: rt.Vec = new rt.Vec(); + const _216: rs.Iter = rs.vecIntoIter(v5, rs.drop); + const v6: rs.Vec = new rs.Vec(); const _238: Guard.Guard = guard(23); v6.items.push(_238); - const part6 = rt.ownedCount(rt.iterZip(_216, rt.vecIntoIter(v6, rt.drop), "len", rt.drop, rt.drop), lib_drop$tuple2_model_Guard_model_Guard); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part6, f)]; - Log.note(log, rt.fmtFormat(["zip ", args14[0]])); - const v7: rt.Vec = new rt.Vec(); + const part6 = rs.ownedCount(rs.iterZip(_216, rs.vecIntoIter(v6, rs.drop), "len", rs.drop, rs.drop), lib_drop$tuple2_model_Guard_model_Guard); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part6, f)]; + Log.note(log, rs.fmtFormat(["zip ", args14[0]])); + const v7: rs.Vec = new rs.Vec(); const _261: Guard.Guard = guard(24); v7.items.push(_261); - const _256: rt.Iter = rt.vecIntoIter(v7, rt.drop); - const v8: rt.Vec = new rt.Vec(); + const _256: rs.Iter = rs.vecIntoIter(v7, rs.drop); + const v8: rs.Vec = new rs.Vec(); const _268: Guard.Guard = guard(25); v8.items.push(_268); const _273: Guard.Guard = guard(26); v8.items.push(_273); - const _254: rt.Iter = rt.iterRev(rt.iterChain(_256, rt.vecIntoIter(v8, rt.drop))); - const nth: Guard.Guard | undefined = rt.iterNth(_254, 1, rt.drop); - rt.drop(_254); - const part7 = option_mapOr$01ozsk3(nth, 0, (g8: Guard.Guard): rt.u32 => { - const _06: rt.u32 = Guard.id(g8); + const _254: rs.Iter = rs.iterRev(rs.iterChain(_256, rs.vecIntoIter(v8, rs.drop))); + const nth: Guard.Guard | undefined = rs.iterNth(_254, 1, rs.drop); + rs.drop(_254); + const part7 = option_mapOr$1re20rq(nth, 0, (g8: Guard.Guard): rs.u32 => { + const _06: rs.u32 = Guard.id(g8); g8[Symbol.dispose](); return _06; }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["nth ", args16[0]])); - const v9: rt.Vec = new rt.Vec(); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["nth ", args16[0]])); + const v9: rs.Vec = new rs.Vec(); const _293: Guard.Guard = guard(27); v9.items.push(_293); const _298: Guard.Guard = guard(28); v9.items.push(_298); const _303: Guard.Guard = guard(29); v9.items.push(_303); - const best: Guard.Guard | undefined = rt.iterMaxByKey(rt.vecIntoIter(v9, rt.drop), (g9: Guard.Guard): rt.u32 => { - return rt.u32Rem(Guard.id(g9), 2); - }, rt.lt, true, rt.drop); - const v10: rt.Vec = new rt.Vec(); + const best: Guard.Guard | undefined = rs.iterMaxByKey(rs.vecIntoIter(v9, rs.drop), (g9: Guard.Guard): rs.u32 => { + return rs.u32Rem(Guard.id(g9), 2); + }, rs.lt, true, rs.drop); + const v10: rs.Vec = new rs.Vec(); const _314: Guard.Guard | undefined = guard(30); v10.items.push(_314); v10.items.push(undefined as Guard.Guard | undefined); @@ -166,131 +166,131 @@ export function looped(log: Log.Log, id: rt.u32): void { v10.items.push(_323); const _329: Guard.Guard | undefined = guard(32); v10.items.push(_329); - const _308: rt.Iter = rt.iterFlatten(rt.vecIntoIter(v10, rt.drop), (value: Guard.Guard | undefined) => rt.iterOption(value, rt.drop), true, undefined, true); - const found: Guard.Guard | undefined = rt.iterFind(_308, (g10: Guard.Guard): boolean => { - return Guard.id(g10) === rt.u32Add(id, 31); - }, rt.drop); - rt.drop(_308); - const _341: rt.u32 = option_mapOr$01ozsk3(best, 0, (g11: Guard.Guard): rt.u32 => { - const _09: rt.u32 = Guard.id(g11); + const _308: rs.Iter = rs.iterFlatten(rs.vecIntoIter(v10, rs.drop), (value: Guard.Guard | undefined) => rs.iterOption(value, rs.drop), true, undefined, true); + const found: Guard.Guard | undefined = rs.iterFind(_308, (g10: Guard.Guard): boolean => { + return Guard.id(g10) === rs.u32Add(id, 31); + }, rs.drop); + rs.drop(_308); + const _341: rs.u32 = option_mapOr$1re20rq(best, 0, (g11: Guard.Guard): rs.u32 => { + const _09: rs.u32 = Guard.id(g11); g11[Symbol.dispose](); return _09; }); const _343: boolean = found !== undefined; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_341, f), (f: rt.Formatter) => rt.fmtBool(_343, f)]; - Log.note(log, rt.fmtFormat(["found ", args18[0], " ", args18[1]])); - const v11: rt.Vec = new rt.Vec(); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_341, f), (f: rs.Formatter) => rs.fmtBool(_343, f)]; + Log.note(log, rs.fmtFormat(["found ", args18[0], " ", args18[1]])); + const v11: rs.Vec = new rs.Vec(); const _356: Guard.Guard = guard(33); v11.items.push(_356); const _361: Guard.Guard = guard(34); v11.items.push(_361); const _366: Guard.Guard = guard(35); v11.items.push(_366); - const folded: rt.u32 = rt.iterFold(rt.vecIntoIter(v11, rt.drop), 0, (n2: rt.u32, g12: Guard.Guard): rt.u32 => { - const _010: rt.u32 = rt.u32Sub(rt.u32Add(n2, Guard.id(g12)), id); + const folded: rs.u32 = rs.iterFold(rs.vecIntoIter(v11, rs.drop), 0, (n2: rs.u32, g12: Guard.Guard): rs.u32 => { + const _010: rs.u32 = rs.u32Sub(rs.u32Add(n2, Guard.id(g12)), id); g12[Symbol.dispose](); return _010; }, true); - const v12: rt.Vec = new rt.Vec(); + const v12: rs.Vec = new rs.Vec(); const _378: Guard.Guard = guard(36); v12.items.push(_378); const _383: Guard.Guard = guard(37); v12.items.push(_383); const _388: Guard.Guard = guard(38); v12.items.push(_388); - const _397: rt.u32 = option_mapOr$01ozsk3(rt.ownedLast(rt.iterStepBy(rt.vecIntoIter(v12, rt.drop), 2, rt.drop), rt.drop), 0, (g13: Guard.Guard): rt.u32 => { - const _011: rt.u32 = Guard.id(g13); + const _397: rs.u32 = option_mapOr$1re20rq(rs.ownedLast(rs.iterStepBy(rs.vecIntoIter(v12, rs.drop), 2, rs.drop), rs.drop), 0, (g13: Guard.Guard): rs.u32 => { + const _011: rs.u32 = Guard.id(g13); g13[Symbol.dispose](); return _011; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(folded, f), (f: rt.Formatter) => rt.u32Display(_397, f)]; - Log.note(log, rt.fmtFormat(["fold ", args20[0], " ", args20[1]])); - const v13: rt.Vec> = new rt.Vec(); - const v14: rt.Vec = new rt.Vec(); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(folded, f), (f: rs.Formatter) => rs.u32Display(_397, f)]; + Log.note(log, rs.fmtFormat(["fold ", args20[0], " ", args20[1]])); + const v13: rs.Vec> = new rs.Vec(); + const v14: rs.Vec = new rs.Vec(); const _414: Guard.Guard = guard(39); v14.items.push(_414); const _419: Guard.Guard = guard(40); v14.items.push(_419); v13.items.push(v14); - const v15: rt.Vec = new rt.Vec(); + const v15: rs.Vec = new rs.Vec(); const _428: Guard.Guard = guard(41); v15.items.push(_428); v13.items.push(v15); - const v16: rt.Vec = new rt.Vec(); + const v16: rs.Vec = new rs.Vec(); const _437: Guard.Guard = guard(42); v16.items.push(_437); const _442: Guard.Guard = guard(43); v16.items.push(_442); v13.items.push(v16); - const flat: rt.Iter = rt.iterFlatten(rt.vecIntoIter(v13, lib_drop$Vec_model_Guard), (value: rt.Vec) => rt.vecIntoIter(value, rt.drop), true); - const front: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(flat.next()), 0, (g14: Guard.Guard): rt.u32 => { - const _012: rt.u32 = Guard.id(g14); + const flat: rs.Iter = rs.iterFlatten(rs.vecIntoIter(v13, lib_drop$Vec_model_Guard), (value: rs.Vec) => rs.vecIntoIter(value, rs.drop), true); + const front: rs.u32 = option_mapOr$1re20rq(rs.iterToOption(flat.next()), 0, (g14: Guard.Guard): rs.u32 => { + const _012: rs.u32 = Guard.id(g14); g14[Symbol.dispose](); return _012; }); - const back: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(flat.nextBack()), 0, (g15: Guard.Guard): rt.u32 => { - const _013: rt.u32 = Guard.id(g15); + const back: rs.u32 = option_mapOr$1re20rq(rs.iterToOption(flat.nextBack()), 0, (g15: Guard.Guard): rs.u32 => { + const _013: rs.u32 = Guard.id(g15); g15[Symbol.dispose](); return _013; }); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(front, f), (f: rt.Formatter) => rt.u32Display(back, f)]; - Log.note(log, rt.fmtFormat(["flat ", args22[0], " ", args22[1]])); - rt.drop(flat); - const five: (a0: rt.u32) => rt.Vec = (n3: rt.u32): rt.Vec => { - const v17: rt.Vec = new rt.Vec(); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(front, f), (f: rs.Formatter) => rs.u32Display(back, f)]; + Log.note(log, rs.fmtFormat(["flat ", args22[0], " ", args22[1]])); + rs.drop(flat); + const five: (a0: rs.u32) => rs.Vec = (n3: rs.u32): rs.Vec => { + const v17: rs.Vec = new rs.Vec(); const _610: Guard.Guard = guard(n3); v17.items.push(_610); - const _103: Guard.Guard = guard(rt.u32Add(n3, 1)); + const _103: Guard.Guard = guard(rs.u32Add(n3, 1)); v17.items.push(_103); - const _162: Guard.Guard = guard(rt.u32Add(n3, 2)); + const _162: Guard.Guard = guard(rs.u32Add(n3, 2)); v17.items.push(_162); - const _222: Guard.Guard = guard(rt.u32Add(n3, 3)); + const _222: Guard.Guard = guard(rs.u32Add(n3, 3)); v17.items.push(_222); - const _283: Guard.Guard = guard(rt.u32Add(n3, 4)); + const _283: Guard.Guard = guard(rs.u32Add(n3, 4)); v17.items.push(_283); return v17; }; - const _471: rt.Iter = rt.iterSkip(rt.vecIntoIter(five(44), rt.drop), 2, rt.drop); - const _469: Guard.Guard | undefined = rt.iterNthBack(_471, 3, rt.drop); + const _471: rs.Iter = rs.iterSkip(rs.vecIntoIter(five(44), rs.drop), 2, rs.drop); + const _469: Guard.Guard | undefined = rs.iterNthBack(_471, 3, rs.drop); const skipped: boolean = _469 !== undefined; - rt.drop(_469); - rt.drop(_471); - const _479: rt.Iter = rt.iterStepBy(rt.vecIntoIter(five(49), rt.drop), 2, rt.drop); - const stepped: rt.u32 = option_mapOr$01ozsk3(rt.iterNthBack(_479, 1, rt.drop), 0, (g16: Guard.Guard): rt.u32 => { - const _015: rt.u32 = Guard.id(g16); + rs.drop(_469); + rs.drop(_471); + const _479: rs.Iter = rs.iterStepBy(rs.vecIntoIter(five(49), rs.drop), 2, rs.drop); + const stepped: rs.u32 = option_mapOr$1re20rq(rs.iterNthBack(_479, 1, rs.drop), 0, (g16: Guard.Guard): rs.u32 => { + const _015: rs.u32 = Guard.id(g16); g16[Symbol.dispose](); return _015; }); - rt.drop(_479); - const _487: rt.Iter = rt.iterChain(rt.iterRev(rt.iterTake(rt.vecIntoIter(five(59), rt.drop), 3, rt.drop)), rt.vecIntoIter(new rt.Vec(), rt.drop)); - const taken: rt.u32 = option_mapOr$01ozsk3(rt.iterNth(_487, 1, rt.drop), 0, (g17: Guard.Guard): rt.u32 => { - const _016: rt.u32 = Guard.id(g17); + rs.drop(_479); + const _487: rs.Iter = rs.iterChain(rs.iterRev(rs.iterTake(rs.vecIntoIter(five(59), rs.drop), 3, rs.drop)), rs.vecIntoIter(new rs.Vec(), rs.drop)); + const taken: rs.u32 = option_mapOr$1re20rq(rs.iterNth(_487, 1, rs.drop), 0, (g17: Guard.Guard): rs.u32 => { + const _016: rs.u32 = Guard.id(g17); g17[Symbol.dispose](); return _016; }); - rt.drop(_487); - const _498: rt.Iter = rt.iterChain(rt.iterRev(rt.iterSkip(rt.vecIntoIter(five(64), rt.drop), 2, rt.drop)), rt.vecIntoIter(new rt.Vec(), rt.drop)); - const passed: rt.u32 = option_mapOr$01ozsk3(rt.iterNth(_498, 2, rt.drop), 0, (g18: Guard.Guard): rt.u32 => { - const _017: rt.u32 = Guard.id(g18); + rs.drop(_487); + const _498: rs.Iter = rs.iterChain(rs.iterRev(rs.iterSkip(rs.vecIntoIter(five(64), rs.drop), 2, rs.drop)), rs.vecIntoIter(new rs.Vec(), rs.drop)); + const passed: rs.u32 = option_mapOr$1re20rq(rs.iterNth(_498, 2, rs.drop), 0, (g18: Guard.Guard): rs.u32 => { + const _017: rs.u32 = Guard.id(g18); g18[Symbol.dispose](); return _017; }); - rt.drop(_498); - const _509: rt.Iter = rt.iterStepBy(rt.iterRev(rt.vecIntoIter(five(69), rt.drop)), 2, rt.drop); - const strode: rt.u32 = option_mapOr$01ozsk3(rt.iterNth(_509, 2, rt.drop), 0, (g19: Guard.Guard): rt.u32 => { - const _018: rt.u32 = Guard.id(g19); + rs.drop(_498); + const _509: rs.Iter = rs.iterStepBy(rs.iterRev(rs.vecIntoIter(five(69), rs.drop)), 2, rs.drop); + const strode: rs.u32 = option_mapOr$1re20rq(rs.iterNth(_509, 2, rs.drop), 0, (g19: Guard.Guard): rs.u32 => { + const _018: rs.u32 = Guard.id(g19); g19[Symbol.dispose](); return _018; }); - rt.drop(_509); - const counted: rt.usize = rt.ownedCount(rt.iterTake(rt.iterRev(rt.vecIntoIter(five(74), rt.drop)), 3, rt.drop), rt.drop); - const far: boolean = rt.iterNthBack(rt.iterStepBy(new rt.Range(0, 10), 4294967295), 4294967295) === undefined; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(skipped, f), (f: rt.Formatter) => rt.u32Display(stepped, f), (f: rt.Formatter) => rt.u32Display(taken, f), (f: rt.Formatter) => rt.u32Display(passed, f), (f: rt.Formatter) => rt.u32Display(strode, f), (f: rt.Formatter) => rt.usizeDisplay(counted, f), (f: rt.Formatter) => rt.fmtBool(far, f)]; - Log.note(log, rt.fmtFormat(["back ", args24[0], " ", args24[1], " ", args24[2], " ", args24[3], " ", args24[4], " ", args24[5], " ", args24[6]])); - rt.drop(found); - rt.drop(second); - rt.drop(first); - rt.dropVec(even); + rs.drop(_509); + const counted: rs.usize = rs.ownedCount(rs.iterTake(rs.iterRev(rs.vecIntoIter(five(74), rs.drop)), 3, rs.drop), rs.drop); + const far: boolean = rs.iterNthBack(rs.iterStepBy(new rs.Range(0, 10), 4294967295), 4294967295) === undefined; + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(skipped, f), (f: rs.Formatter) => rs.u32Display(stepped, f), (f: rs.Formatter) => rs.u32Display(taken, f), (f: rs.Formatter) => rs.u32Display(passed, f), (f: rs.Formatter) => rs.u32Display(strode, f), (f: rs.Formatter) => rs.usizeDisplay(counted, f), (f: rs.Formatter) => rs.fmtBool(far, f)]; + Log.note(log, rs.fmtFormat(["back ", args24[0], " ", args24[1], " ", args24[2], " ", args24[3], " ", args24[4], " ", args24[5], " ", args24[6]])); + rs.drop(found); + rs.drop(second); + rs.drop(first); + rs.dropVec(even); } /** @@ -298,382 +298,382 @@ export function looped(log: Log.Log, id: rt.u32): void { * first; the values before the first `Err` or `None`, and the rest; and of equal keys, * the one a map or set does not keep. */ -export function collected(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function collected(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const key: (a0: rt.u32) => Key.Key = (n2: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n2: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; - const v: rt.Vec = new rt.Vec(); + const v: rs.Vec = new rs.Vec(); const _13: Guard.Guard = guard(1); v.items.push(_13); const _18: Guard.Guard = guard(2); v.items.push(_18); const _23: Guard.Guard = guard(3); v.items.push(_23); - const same: rt.Vec = rt.iterToVec(rt.vecIntoIter(v, rt.drop), "next", 8, true, 8); - const v2: rt.Vec = new rt.Vec(); + const same: rs.Vec = rs.iterToVec(rs.vecIntoIter(v, rs.drop), "next", 8, true, 8); + const v2: rs.Vec = new rs.Vec(); const _33: Guard.Guard = guard(4); v2.items.push(_33); const _38: Guard.Guard = guard(5); v2.items.push(_38); const _43: Guard.Guard = guard(6); v2.items.push(_43); - const wider: rt.Vec<[Guard.Guard, rt.u32]> = rt.iterToVec(rt.iterMap(rt.vecIntoIter(v2, rt.drop), (g: Guard.Guard): [Guard.Guard, rt.u32] => { - return [g, 0] as [Guard.Guard, rt.u32]; + const wider: rs.Vec<[Guard.Guard, rs.u32]> = rs.iterToVec(rs.iterMap(rs.vecIntoIter(v2, rs.drop), (g: Guard.Guard): [Guard.Guard, rs.u32] => { + return [g, 0] as [Guard.Guard, rs.u32]; }), "fold", 12, true); - const v3: rt.Vec = new rt.Vec(); + const v3: rs.Vec = new rs.Vec(); const _53: Guard.Guard = guard(7); v3.items.push(_53); - const _48: rt.Iter = rt.vecIntoIter(v3, rt.drop); - const v4: rt.Vec = new rt.Vec(); + const _48: rs.Iter = rs.vecIntoIter(v3, rs.drop); + const v4: rs.Vec = new rs.Vec(); const _60: Guard.Guard = guard(8); v4.items.push(_60); const _65: Guard.Guard = guard(9); v4.items.push(_65); - const chained: rt.Vec = rt.iterToVec(rt.iterChain(_48, rt.vecIntoIter(v4, rt.drop)), "fold", 8, true); - const _74: rt.usize = same.items.length; - const _77: rt.usize = wider.items.length; - const _80: rt.usize = chained.items.length; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_74, f), (f: rt.Formatter) => rt.usizeDisplay(_77, f), (f: rt.Formatter) => rt.usizeDisplay(_80, f)]; - Log.note(log, rt.fmtFormat(["vecs ", args2[0], " ", args2[1], " ", args2[2]])); - const v5: rt.Vec = new rt.Vec(); + const chained: rs.Vec = rs.iterToVec(rs.iterChain(_48, rs.vecIntoIter(v4, rs.drop)), "fold", 8, true); + const _74: rs.usize = same.items.length; + const _77: rs.usize = wider.items.length; + const _80: rs.usize = chained.items.length; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_74, f), (f: rs.Formatter) => rs.usizeDisplay(_77, f), (f: rs.Formatter) => rs.usizeDisplay(_80, f)]; + Log.note(log, rs.fmtFormat(["vecs ", args2[0], " ", args2[1], " ", args2[2]])); + const v5: rs.Vec = new rs.Vec(); const _95: Guard.Guard = guard(10); v5.items.push(_95); const _100: Guard.Guard = guard(11); v5.items.push(_100); const _105: Guard.Guard = guard(12); v5.items.push(_105); - const results: rt.Result, Guard.Guard> = rt.iterCollectResult(rt.iterMap(rt.vecIntoIter(v5, rt.drop), (g2: Guard.Guard): rt.Result => { - if (!(Guard.id(g2) === rt.u32Add(id, 11))) { - return rt.Ok(g2); + const results: rs.Result, Guard.Guard> = rs.iterCollectResult(rs.iterMap(rs.vecIntoIter(v5, rs.drop), (g2: Guard.Guard): rs.Result => { + if (!(Guard.id(g2) === rs.u32Add(id, 11))) { + return rs.Ok(g2); } - return rt.Err(g2); - }), (values: rt.Iter) => rt.iterToVec(values, "next", 8, false, 8), lib_drop$Vec_model_Guard); + return rs.Err(g2); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 8, false, 8), lib_drop$Vec_model_Guard); const part = results.ok; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - Log.note(log, rt.fmtFormat(["result ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + Log.note(log, rs.fmtFormat(["result ", args4[0]])); lib_drop$Result_Vec_model_Guard_model_Guard(results); - const v6: rt.Vec = new rt.Vec(); + const v6: rs.Vec = new rs.Vec(); const _130: Guard.Guard = guard(13); v6.items.push(_130); const _135: Guard.Guard = guard(14); v6.items.push(_135); const _140: Guard.Guard = guard(15); v6.items.push(_140); - const part2 = option_mapOr$184639r(rt.iterCollectOption(rt.iterMap(rt.vecIntoIter(v6, rt.drop), (g3: Guard.Guard): Guard.Guard | undefined => { + const part2 = option_mapOr$090948l(rs.iterCollectOption(rs.iterMap(rs.vecIntoIter(v6, rs.drop), (g3: Guard.Guard): Guard.Guard | undefined => { return g3; - }), (values: rt.Iter) => rt.iterToVec(values, "next", 8, false, 8), lib_drop$Vec_model_Guard), 0, (v12: rt.Vec): rt.usize => { - const _06: rt.usize = v12.items.length; - rt.dropVec(v12); + }), (values: rs.Iter) => rs.iterToVec(values, "next", 8, false, 8), lib_drop$Vec_model_Guard), 0, (v12: rs.Vec): rs.usize => { + const _06: rs.usize = v12.items.length; + rs.dropVec(v12); return _06; }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part2, f)]; - Log.note(log, rt.fmtFormat(["option ", args6[0]])); - const v7: rt.Vec<[rt.u32, Guard.Guard]> = new rt.Vec(); - const _160: [rt.u32, Guard.Guard] = [2, guard(16)]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; + Log.note(log, rs.fmtFormat(["option ", args6[0]])); + const v7: rs.Vec<[rs.u32, Guard.Guard]> = new rs.Vec(); + const _160: [rs.u32, Guard.Guard] = [2, guard(16)]; v7.items.push(_160); - const _166: [rt.u32, Guard.Guard] = [1, guard(17)]; + const _166: [rs.u32, Guard.Guard] = [1, guard(17)]; v7.items.push(_166); - const _172: [rt.u32, Guard.Guard] = [2, guard(18)]; + const _172: [rs.u32, Guard.Guard] = [2, guard(18)]; v7.items.push(_172); - const _155: rt.Iter<[rt.u32, Guard.Guard]> = rt.vecIntoIter(v7, lib_drop$tuple2_u32_model_Guard); - const tree: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToVec(_155, "next", 12, true, 12).items, 12, true, undefined, undefined, rt.drop); - const part3 = rt.btreeLen(tree); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; - Log.note(log, rt.fmtFormat(["tree ", args8[0]])); - const v8: rt.Vec = new rt.Vec(); + const _155: rs.Iter<[rs.u32, Guard.Guard]> = rs.vecIntoIter(v7, lib_drop$tuple2_u32_model_Guard); + const tree: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_155, "next", 12, true, 12).items, 12, true, undefined, undefined, rs.drop); + const part3 = rs.btreeLen(tree); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; + Log.note(log, rs.fmtFormat(["tree ", args8[0]])); + const v8: rs.Vec = new rs.Vec(); const _195: Guard.Guard = guard(24); v8.items.push(_195); const _200: Guard.Guard = guard(25); v8.items.push(_200); - const part4 = rt.iterToVec(rt.iterMap(rt.vecIntoIter(v8, rt.drop), (_2: Guard.Guard): Guard.Guard => { - const at = rt.idx(same.items, 0); + const part4 = rs.iterToVec(rs.iterMap(rs.vecIntoIter(v8, rs.drop), (_2: Guard.Guard): Guard.Guard => { + const at = rs.idx(same.items, 0); _2[Symbol.dispose](); return same.items[at]; }), "next", 4, true, 8).items.length; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; - Log.note(log, rt.fmtFormat(["refs ", args10[0]])); - const v9: rt.Vec = new rt.Vec(); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; + Log.note(log, rs.fmtFormat(["refs ", args10[0]])); + const v9: rs.Vec = new rs.Vec(); const _223: Guard.Guard = guard(19); v9.items.push(_223); const _228: Guard.Guard = guard(20); v9.items.push(_228); - const queue: rt.VecDeque = rt.dequeFromIntoIter(rt.vecIntoIter(v9, rt.drop), 8) as rt.VecDeque; - const v10: rt.Vec<[rt.u32, Guard.Guard]> = new rt.Vec(); - const _237: [rt.u32, Guard.Guard] = [1, guard(21)]; + const queue: rs.VecDeque = rs.dequeFromIntoIter(rs.vecIntoIter(v9, rs.drop), 8) as rs.VecDeque; + const v10: rs.Vec<[rs.u32, Guard.Guard]> = new rs.Vec(); + const _237: [rs.u32, Guard.Guard] = [1, guard(21)]; v10.items.push(_237); - const _243: [rt.u32, Guard.Guard] = [1, guard(22)]; + const _243: [rs.u32, Guard.Guard] = [1, guard(22)]; v10.items.push(_243); - const _232: rt.Iter<[rt.u32, Guard.Guard]> = rt.vecIntoIter(v10, lib_drop$tuple2_u32_model_Guard); - const hashed: rt.HashMap = rt.hashExtend(rt.hashNew() as rt.HashMap, _232, undefined, rt.drop, "fold", 117440512); - const v11: rt.Vec = new rt.Vec(); + const _232: rs.Iter<[rs.u32, Guard.Guard]> = rs.vecIntoIter(v10, lib_drop$tuple2_u32_model_Guard); + const hashed: rs.HashMap = rs.hashExtend(rs.hashNew() as rs.HashMap, _232, undefined, rs.drop, "fold", 117440512); + const v11: rs.Vec = new rs.Vec(); const _253: Key.Key = key(23); v11.items.push(_253); const _258: Key.Key = key(23); v11.items.push(_258); - const _248: rt.Iter = rt.vecIntoIter(v11, rt.drop); - const set: rt.HashSet = rt.hashExtendKeys(rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet, _248, rt.drop, "fold", 117440512); - const _267: rt.usize = queue.n; - const _270: rt.usize = rt.hashLen(hashed); - const _273: rt.usize = rt.hashLen(set); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_267, f), (f: rt.Formatter) => rt.usizeDisplay(_270, f), (f: rt.Formatter) => rt.usizeDisplay(_273, f)]; - Log.note(log, rt.fmtFormat(["collected ", args12[0], " ", args12[1], " ", args12[2]])); - rt.hashDrop(set, rt.drop); - rt.hashDrop(hashed, undefined, rt.drop); - rt.dequeDrop(queue, rt.drop); - rt.btreeDrop(tree, undefined, rt.drop); - rt.dropVec(chained); - rt.dropVec(wider, lib_drop$tuple2_model_Guard_u32); - rt.dropVec(same); + const _248: rs.Iter = rs.vecIntoIter(v11, rs.drop); + const set: rs.HashSet = rs.hashExtendKeys(rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashSet, _248, rs.drop, "fold", 117440512); + const _267: rs.usize = queue.n; + const _270: rs.usize = rs.hashLen(hashed); + const _273: rs.usize = rs.hashLen(set); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_267, f), (f: rs.Formatter) => rs.usizeDisplay(_270, f), (f: rs.Formatter) => rs.usizeDisplay(_273, f)]; + Log.note(log, rs.fmtFormat(["collected ", args12[0], " ", args12[1], " ", args12[2]])); + rs.hashDrop(set, rs.drop); + rs.hashDrop(hashed, undefined, rs.drop); + rs.dequeDrop(queue, rs.drop); + rs.btreeDrop(tree, undefined, rs.drop); + rs.dropVec(chained); + rs.dropVec(wider, lib_drop$tuple2_model_Guard_u32); + rs.dropVec(same); } /** * What draining a collection drops: the items taken, the half of each entry * `into_keys` or `into_values` leaves, and what is left when the iterator drops. */ -export function drained(log: Log.Log, id: rt.u32): void { - let _80!: rt.u32; - let _201!: rt.u32; - const guard: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n3), Log.clone$Clone(log)); +export function drained(log: Log.Log, id: rs.u32): void { + let _80!: rs.u32; + let _201!: rs.u32; + const guard: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n3), Log.clone$Clone(log)); }; - const key: (a0: rt.u32) => Key.Key = (n4: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n4), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n4: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n4), Log.clone$Clone(log)); }; - const tree: (a0: rt.u32) => rt.BTreeMap = (base: rt.u32): rt.BTreeMap => { - let _9!: rt.u32; - const map4: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; - const _66: rt.u32 = rt.u32Add(base, 4); - let iterStart3: rt.u32 = base; - const iterEnd3: rt.u32 = _66; + const tree: (a0: rs.u32) => rs.BTreeMap = (base: rs.u32): rs.BTreeMap => { + let _9!: rs.u32; + const map4: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; + const _66: rs.u32 = rs.u32Add(base, 4); + let iterStart3: rs.u32 = base; + const iterEnd3: rs.u32 = _66; while (true) { if (!((_9 = iterStart3++) < iterEnd3)) { return map4; } - const n5: rt.u32 = _9; + const n5: rs.u32 = _9; const _15: Key.Key = key(n5); const _17: Guard.Guard = guard(n5); - rt.drop(rt.btreeInsert(map4, _15, _17, rt.drop)); + rs.drop(rs.btreeInsert(map4, _15, _17, rs.drop)); } }; - const it: rt.Iter<[Key.Key, Guard.Guard]> = rt.btreeIter(tree(1), rt.drop, rt.drop); - const first: [Key.Key, Guard.Guard] | undefined = rt.iterToOption(it.next()); - const back: [Key.Key, Guard.Guard] | undefined = rt.iterToOption(it.nextBack()); + const it: rs.Iter<[Key.Key, Guard.Guard]> = rs.btreeIter(tree(1), rs.drop, rs.drop); + const first: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(it.next()); + const back: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(it.nextBack()); lib_drop$Option_tuple2_drops_Key_model_Guard(first); - rt.drop(it); + rs.drop(it); lib_drop$Option_tuple2_drops_Key_model_Guard(back); - const keys: rt.Vec = rt.iterToVec(rt.btreeKeys(tree(5), rt.drop, rt.drop, true), "fold", 12, true); - const values: rt.Iter = rt.btreeValues(tree(9), rt.drop, rt.drop); - const _37: rt.usize = keys.items.length; - const _40: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(values.next()), 0, (g: Guard.Guard): rt.u32 => { - const _04: rt.u32 = Guard.id(g); + const keys: rs.Vec = rs.iterToVec(rs.btreeKeys(tree(5), rs.drop, rs.drop, true), "fold", 12, true); + const values: rs.Iter = rs.btreeValues(tree(9), rs.drop, rs.drop); + const _37: rs.usize = keys.items.length; + const _40: rs.u32 = option_mapOr$1re20rq(rs.iterToOption(values.next()), 0, (g: Guard.Guard): rs.u32 => { + const _04: rs.u32 = Guard.id(g); g[Symbol.dispose](); return _04; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_37, f), (f: rt.Formatter) => rt.u32Display(_40, f)]; - Log.note(log, rt.fmtFormat(["values ", args2[0], " ", args2[1]])); - rt.drop(values); - const set: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_37, f), (f: rs.Formatter) => rs.u32Display(_40, f)]; + Log.note(log, rs.fmtFormat(["values ", args2[0], " ", args2[1]])); + rs.drop(values); + const set: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; const _53: Key.Key = key(13); - rt.btreeAdd(set, _53, rt.drop); + rs.btreeAdd(set, _53, rs.drop); const _58: Key.Key = key(14); - rt.btreeAdd(set, _58, rt.drop); - const _70: rt.Iter = rt.btreeKeys(set, rt.drop); - const part = option_mapOr$1w10sgd(rt.iterToOption(_70.next()), 0, (k: Key.Key): rt.u32 => { - const _05: rt.u32 = k.id; + rs.btreeAdd(set, _58, rs.drop); + const _70: rs.Iter = rs.btreeKeys(set, rs.drop); + const part = option_mapOr$0mko9ta(rs.iterToOption(_70.next()), 0, (k: Key.Key): rs.u32 => { + const _05: rs.u32 = k.id; k[Symbol.dispose](); return _05; }); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - const _63: string = rt.fmtFormat(["set ", args4[0]]); - rt.drop(_70); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + const _63: string = rs.fmtFormat(["set ", args4[0]]); + rs.drop(_70); Log.note(log, _63); - const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; - let iterStart: rt.u32 = 15; - const iterEnd: rt.u32 = 20; + const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; + let iterStart: rs.u32 = 15; + const iterEnd: rs.u32 = 20; while ((_80 = iterStart++) < iterEnd) { const _86: Guard.Guard = guard(_80); - rt.dequePushBack(queue, _86); + rs.dequePushBack(queue, _86); } - const range: rt.Iter = rt.dequeDrain(queue, new rt.Range(1, 4), rt.drop); - const part2 = option_mapOr$01ozsk3(rt.iterToOption(range.next()), 0, (g2: Guard.Guard): rt.u32 => { - const _06: rt.u32 = Guard.id(g2); + const range: rs.Iter = rs.dequeDrain(queue, new rs.Range(1, 4), rs.drop); + const part2 = option_mapOr$1re20rq(rs.iterToOption(range.next()), 0, (g2: Guard.Guard): rs.u32 => { + const _06: rs.u32 = Guard.id(g2); g2[Symbol.dispose](); return _06; }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["drain ", args6[0]])); - rt.drop(range); - const _113: rt.usize = queue.n; - const _119: rt.Iter = rt.dequeIntoIter(queue, rt.drop); - const _116: rt.u32 = option_mapOr$01ozsk3(rt.iterToOption(_119.next()), 0, (g3: Guard.Guard): rt.u32 => { - const _07: rt.u32 = Guard.id(g3); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["drain ", args6[0]])); + rs.drop(range); + const _113: rs.usize = queue.n; + const _119: rs.Iter = rs.dequeIntoIter(queue, rs.drop); + const _116: rs.u32 = option_mapOr$1re20rq(rs.iterToOption(_119.next()), 0, (g3: Guard.Guard): rs.u32 => { + const _07: rs.u32 = Guard.id(g3); g3[Symbol.dispose](); return _07; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_113, f), (f: rt.Formatter) => rt.u32Display(_116, f)]; - const _109: string = rt.fmtFormat(["queue ", args8[0], " ", args8[1]]); - rt.drop(_119); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_113, f), (f: rs.Formatter) => rs.u32Display(_116, f)]; + const _109: string = rs.fmtFormat(["queue ", args8[0], " ", args8[1]]); + rs.drop(_119); Log.note(log, _109); - const map: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap; + const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _129: Key.Key = key(20); const _132: Guard.Guard = guard(20); - rt.drop(rt.hashInsert(map, _129, _132, rt.drop)); - const entries: rt.Iter<[Key.Key, Guard.Guard]> = rt.hashIter(map, rt.drop, rt.drop); - const _145: [Key.Key, Guard.Guard] | undefined = rt.iterToOption(entries.next()); + rs.drop(rs.hashInsert(map, _129, _132, rs.drop)); + const entries: rs.Iter<[Key.Key, Guard.Guard]> = rs.hashIter(map, rs.drop, rs.drop); + const _145: [Key.Key, Guard.Guard] | undefined = rs.iterToOption(entries.next()); const part3 = _145 !== undefined; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - const _139: string = rt.fmtFormat(["entry ", args10[0]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + const _139: string = rs.fmtFormat(["entry ", args10[0]]); lib_drop$Option_tuple2_drops_Key_model_Guard(_145); Log.note(log, _139); - const map2: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap; + const map2: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _154: Key.Key = key(21); const _157: Guard.Guard = guard(21); - rt.drop(rt.hashInsert(map2, _154, _157, rt.drop)); - rt.drop(rt.hashDrain(map2, rt.drop, rt.drop)); - const part4 = rt.hashLen(map2); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part4, f)]; - Log.note(log, rt.fmtFormat(["drained ", args12[0]])); - const set2: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet; + rs.drop(rs.hashInsert(map2, _154, _157, rs.drop)); + rs.drop(rs.hashDrain(map2, rs.drop, rs.drop)); + const part4 = rs.hashLen(map2); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part4, f)]; + Log.note(log, rs.fmtFormat(["drained ", args12[0]])); + const set2: rs.HashSet = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashSet; const _178: Key.Key = key(22); - rt.hashAdd(set2, _178, rt.drop); - const taken: rt.Iter = rt.hashDrainKeys(set2, rt.drop); - const part5 = option_mapOr$1w10sgd(rt.iterToOption(taken.next()), 0, (k2: Key.Key): rt.u32 => { - const _08: rt.u32 = k2.id; + rs.hashAdd(set2, _178, rs.drop); + const taken: rs.Iter = rs.hashDrainKeys(set2, rs.drop); + const part5 = option_mapOr$0mko9ta(rs.iterToOption(taken.next()), 0, (k2: Key.Key): rs.u32 => { + const _08: rs.u32 = k2.id; k2[Symbol.dispose](); return _08; }); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - Log.note(log, rt.fmtFormat(["taken ", args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + Log.note(log, rs.fmtFormat(["taken ", args14[0]])); const sink: Log.Log = Log.new(); - const map3: rt.HashMap = rt.hashNew() as rt.HashMap; - let iterStart2: rt.u32 = 23; - const iterEnd2: rt.u32 = 27; + const map3: rs.HashMap = rs.hashNew() as rs.HashMap; + let iterStart2: rs.u32 = 23; + const iterEnd2: rs.u32 = 27; while ((_201 = iterStart2++) < iterEnd2) { - const n2: rt.u32 = _201; - const _207: Guard.Guard = Guard.new(rt.u32Add(id, n2), Log.clone$Clone(sink)); - rt.drop(rt.hashInsert(map3, n2, _207)); + const n2: rs.u32 = _201; + const _207: Guard.Guard = Guard.new(rs.u32Add(id, n2), Log.clone$Clone(sink)); + rs.drop(rs.hashInsert(map3, n2, _207)); } - const values2: rt.Iter = rt.hashValues(map3, rt.drop); - const one: Guard.Guard | undefined = rt.iterToOption(values2.next()); - const _222: rt.usize = rt.ownedCount(values2, rt.drop); + const values2: rs.Iter = rs.hashValues(map3, rs.drop); + const one: Guard.Guard | undefined = rs.iterToOption(values2.next()); + const _222: rs.usize = rs.ownedCount(values2, rs.drop); const _225: boolean = one !== undefined; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_222, f), (f: rt.Formatter) => rt.fmtBool(_225, f)]; - Log.note(log, rt.fmtFormat(["rest ", args16[0], " ", args16[1]])); - rt.drop(one); - const part6 = rt.iterSum(rt.iterMap(rt.iterSlice(rt.byteSliceView(rt.byteVecSlice(Log.text(sink)))), (_2: rt.u8): rt.u32 => { - return _2 as rt.u32; - }), rt.u32Add, 0); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["sink ", args18[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_222, f), (f: rs.Formatter) => rs.fmtBool(_225, f)]; + Log.note(log, rs.fmtFormat(["rest ", args16[0], " ", args16[1]])); + rs.drop(one); + const part6 = rs.iterSum(rs.iterMap(rs.iterSlice(rs.byteSliceView(rs.byteVecSlice(Log.text(sink)))), (_2: rs.u8): rs.u32 => { + return _2 as rs.u32; + }), rs.u32Add, 0); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["sink ", args18[0]])); sink[Symbol.dispose](); - rt.drop(taken); - rt.hashDrop(set2, rt.drop); - rt.hashDrop(map2, rt.drop, rt.drop); - rt.drop(entries); - rt.dropVec(keys); + rs.drop(taken); + rs.hashDrop(set2, rs.drop); + rs.hashDrop(map2, rs.drop, rs.drop); + rs.drop(entries); + rs.dropVec(keys); } /** What `extend` drops: what a map or set does not keep of equal keys. */ -export function extended(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function extended(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const key: (a0: rt.u32) => Key.Key = (n2: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n2), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n2: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; - const v: rt.Vec = new rt.Vec(); + const v: rs.Vec = new rs.Vec(); const _11: Guard.Guard = guard(1); v.items.push(_11); - const list: rt.Vec = v; - const v2: rt.Vec = new rt.Vec(); + const list: rs.Vec = v; + const v2: rs.Vec = new rs.Vec(); const _20: Guard.Guard = guard(2); v2.items.push(_20); const _25: Guard.Guard = guard(3); v2.items.push(_25); const _30: Guard.Guard = guard(4); v2.items.push(_30); - rt.iterExtend(list, rt.vecIntoIter(v2, rt.drop), "fold", 8, true); - const v3: rt.Vec = new rt.Vec(); + rs.iterExtend(list, rs.vecIntoIter(v2, rs.drop), "fold", 8, true); + const v3: rs.Vec = new rs.Vec(); const _41: Guard.Guard = guard(5); v3.items.push(_41); const _46: Guard.Guard = guard(6); v3.items.push(_46); const _51: Guard.Guard = guard(7); v3.items.push(_51); - const _35: rt.Iter = rt.iterFilter(rt.vecIntoIter(v3, rt.drop), (g: Guard.Guard): boolean => { - return Guard.id(g) !== rt.u32Add(id, 5); - }, rt.drop); - rt.iterExtend(list, _35, "next", 8); + const _35: rs.Iter = rs.iterFilter(rs.vecIntoIter(v3, rs.drop), (g: Guard.Guard): boolean => { + return Guard.id(g) !== rs.u32Add(id, 5); + }, rs.drop); + rs.iterExtend(list, _35, "next", 8); const part = list.items.length; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; - Log.note(log, rt.fmtFormat(["list ", args2[0]])); - const map: rt.HashMap = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashMap; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; + Log.note(log, rs.fmtFormat(["list ", args2[0]])); + const map: rs.HashMap = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashMap; const _71: Key.Key = key(8); const _74: Guard.Guard = guard(8); - rt.drop(rt.hashInsert(map, _71, _74, rt.drop)); - const v4: rt.Vec<[Key.Key, Guard.Guard]> = new rt.Vec(); + rs.drop(rs.hashInsert(map, _71, _74, rs.drop)); + const v4: rs.Vec<[Key.Key, Guard.Guard]> = new rs.Vec(); const _83: [Key.Key, Guard.Guard] = [key(8), guard(9)]; v4.items.push(_83); const _92: [Key.Key, Guard.Guard] = [key(8), guard(10)]; v4.items.push(_92); - rt.hashExtend(map, rt.vecIntoIter(v4, lib_drop$tuple2_drops_Key_model_Guard), rt.drop, rt.drop, "fold", 58720256); - const set: rt.HashSet = rt.hashNew(rt.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rt.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rt.HashSet; + rs.hashExtend(map, rs.vecIntoIter(v4, lib_drop$tuple2_drops_Key_model_Guard), rs.drop, rs.drop, "fold", 58720256); + const set: rs.HashSet = rs.hashNew(rs.hashing(Key.hash$Hash_hash_DefaultHasher as (a0: Key.Key, a1: rs.Hasher) => undefined, Key.eq$cmp_PartialEq)) as rs.HashSet; const _102: Key.Key = key(11); - rt.hashAdd(set, _102, rt.drop); - const v5: rt.Vec = new rt.Vec(); + rs.hashAdd(set, _102, rs.drop); + const v5: rs.Vec = new rs.Vec(); const _111: Key.Key = key(11); v5.items.push(_111); const _116: Key.Key = key(11); v5.items.push(_116); - rt.hashExtendKeys(set, rt.vecIntoIter(v5, rt.drop), rt.drop, "fold", 117440512); - const _125: rt.usize = rt.hashLen(map); - const _128: rt.usize = rt.hashLen(set); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_125, f), (f: rt.Formatter) => rt.usizeDisplay(_128, f)]; - Log.note(log, rt.fmtFormat(["hashed ", args4[0], " ", args4[1]])); - const tree: rt.BTreeMap = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeMap; + rs.hashExtendKeys(set, rs.vecIntoIter(v5, rs.drop), rs.drop, "fold", 117440512); + const _125: rs.usize = rs.hashLen(map); + const _128: rs.usize = rs.hashLen(set); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_125, f), (f: rs.Formatter) => rs.usizeDisplay(_128, f)]; + Log.note(log, rs.fmtFormat(["hashed ", args4[0], " ", args4[1]])); + const tree: rs.BTreeMap = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeMap; const _138: Key.Key = key(12); const _141: Guard.Guard = guard(12); - rt.drop(rt.btreeInsert(tree, _138, _141, rt.drop)); - const v6: rt.Vec<[Key.Key, Guard.Guard]> = new rt.Vec(); + rs.drop(rs.btreeInsert(tree, _138, _141, rs.drop)); + const v6: rs.Vec<[Key.Key, Guard.Guard]> = new rs.Vec(); const _150: [Key.Key, Guard.Guard] = [key(13), guard(13)]; v6.items.push(_150); const _159: [Key.Key, Guard.Guard] = [key(12), guard(14)]; v6.items.push(_159); const _168: [Key.Key, Guard.Guard] = [key(15), guard(15)]; v6.items.push(_168); - rt.btreeExtend(tree, rt.vecIntoIter(v6, lib_drop$tuple2_drops_Key_model_Guard), false, rt.drop, rt.drop, "fold"); - const ordered: rt.BTreeSet = rt.btreeNew(Key.cmp$cmp_Ord) as rt.BTreeSet; + rs.btreeExtend(tree, rs.vecIntoIter(v6, lib_drop$tuple2_drops_Key_model_Guard), false, rs.drop, rs.drop, "fold"); + const ordered: rs.BTreeSet = rs.btreeNew(Key.cmp$cmp_Ord) as rs.BTreeSet; const _178: Key.Key = key(16); - rt.btreeAdd(ordered, _178, rt.drop); - const v7: rt.Vec = new rt.Vec(); + rs.btreeAdd(ordered, _178, rs.drop); + const v7: rs.Vec = new rs.Vec(); const _187: Key.Key = key(17); v7.items.push(_187); const _192: Key.Key = key(16); v7.items.push(_192); - rt.btreeExtendKeys(ordered, rt.vecIntoIter(v7, rt.drop), false, rt.drop, "fold"); - const queue: rt.VecDeque = rt.dequeNew(8) as rt.VecDeque; + rs.btreeExtendKeys(ordered, rs.vecIntoIter(v7, rs.drop), false, rs.drop, "fold"); + const queue: rs.VecDeque = rs.dequeNew(8) as rs.VecDeque; const _198: Guard.Guard = guard(18); - rt.dequePushBack(queue, _198); - const v8: rt.Vec = new rt.Vec(); + rs.dequePushBack(queue, _198); + const v8: rs.Vec = new rs.Vec(); const _207: Guard.Guard = guard(19); v8.items.push(_207); const _212: Guard.Guard = guard(20); v8.items.push(_212); - rt.dequeExtend(queue, rt.vecIntoIter(v8, rt.drop), "fold", true); - const _221: rt.usize = rt.btreeLen(tree); - const _224: rt.usize = rt.btreeLen(ordered); - const _227: rt.usize = queue.n; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_221, f), (f: rt.Formatter) => rt.usizeDisplay(_224, f), (f: rt.Formatter) => rt.usizeDisplay(_227, f)]; - Log.note(log, rt.fmtFormat(["ordered ", args6[0], " ", args6[1], " ", args6[2]])); - rt.dequeDrop(queue, rt.drop); - rt.btreeDrop(ordered, rt.drop); - rt.btreeDrop(tree, rt.drop, rt.drop); - rt.hashDrop(set, rt.drop); - rt.hashDrop(map, rt.drop, rt.drop); - rt.dropVec(list); + rs.dequeExtend(queue, rs.vecIntoIter(v8, rs.drop), "fold", true); + const _221: rs.usize = rs.btreeLen(tree); + const _224: rs.usize = rs.btreeLen(ordered); + const _227: rs.usize = queue.n; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_221, f), (f: rs.Formatter) => rs.usizeDisplay(_224, f), (f: rs.Formatter) => rs.usizeDisplay(_227, f)]; + Log.note(log, rs.fmtFormat(["ordered ", args6[0], " ", args6[1], " ", args6[2]])); + rs.dequeDrop(queue, rs.drop); + rs.btreeDrop(ordered, rs.drop); + rs.btreeDrop(tree, rs.drop, rs.drop); + rs.hashDrop(set, rs.drop); + rs.hashDrop(map, rs.drop, rs.drop); + rs.dropVec(list); } /** @@ -682,80 +682,80 @@ export function extended(log: Log.Log, id: rt.u32): void { * form owns, as the first side's fold ends; then the second side and the first. `eq` of * two `TrustedLen` sides of unlike lengths reads neither. */ -export function compared(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const _12: (a0: rt.Ordering | undefined) => rt.i8 = (o: rt.Ordering | undefined): rt.i8 => { - return option_mapOr$00i7kb3(o, 9, (o2: rt.Ordering): rt.i8 => { +export function compared(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const _12: (a0: rs.Ordering | undefined) => rs.i8 = (o: rs.Ordering | undefined): rs.i8 => { + return option_mapOr$16nkz0h(o, 9, (o2: rs.Ordering): rs.i8 => { return o2; }); }; let _283: boolean = false; - const key: (a0: rt.u32) => Key.Key = (n: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n), Log.clone$Clone(log)); + const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const keys: (a0: rt.u32[]) => rt.Vec = (ns: rt.u32[]): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(ns), (_2: rt.u32): Key.Key => { + const keys: (a0: rs.u32[]) => rs.Vec = (ns: rs.u32[]): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(ns), (_2: rs.u32): Key.Key => { return key(_2); }), undefined, 12, true); }; - const guard: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n3), Log.clone$Clone(log)); + const guard: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n3), Log.clone$Clone(log)); }; - const guards: (a0: rt.u32[]) => rt.Vec = (ns2: rt.u32[]): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterSlice(ns2), (_26: rt.u32): Guard.Guard => { + const guards: (a0: rs.u32[]) => rs.Vec = (ns2: rs.u32[]): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterSlice(ns2), (_26: rs.u32): Guard.Guard => { return guard(_26); }), undefined, 8, true); }; const c: Guard.Guard = guard(10); _283 = true; - const _16: rt.u8 = rt.u8Rem(arg, 9); + const _16: rs.u8 = rs.u8Rem(arg, 9); if (_16 === 0) { - const part8 = rt.iterEq(rt.vecIntoIter(keys([1, 2, 3]), rt.drop), rt.vecIntoIter(keys([1, 5, 6]), rt.drop), rt.consuming(Key.eq$cmp_PartialEq, rt.drop, rt.drop), true, true, true, undefined, rt.drop, rt.drop); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part8, f)]; - Log.note(log, rt.fmtFormat(["eq ", args2[0]])); + const part8 = rs.iterEq(rs.vecIntoIter(keys([1, 2, 3]), rs.drop), rs.vecIntoIter(keys([1, 5, 6]), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; + Log.note(log, rs.fmtFormat(["eq ", args2[0]])); } else if (_16 === 1) { - const eq2: boolean = rt.iterEq(rt.vecIntoIter(keys([1, 2, 3]), rt.drop), rt.vecIntoIter(keys([1, 2]), rt.drop), rt.consuming(Key.eq$cmp_PartialEq, rt.drop, rt.drop), true, true, true, undefined, rt.drop, rt.drop); - const ne: boolean = !rt.iterEq(rt.vecIntoIter(keys([4]), rt.drop), rt.vecIntoIter(keys([4, 5]), rt.drop), rt.consuming(Key.eq$cmp_PartialEq, rt.drop, rt.drop), true, true, true, undefined, rt.drop, rt.drop); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(eq2, f), (f: rt.Formatter) => rt.fmtBool(ne, f)]; - Log.note(log, rt.fmtFormat(["eq ", args4[0], " ", args4[1]])); + const eq2: boolean = rs.iterEq(rs.vecIntoIter(keys([1, 2, 3]), rs.drop), rs.vecIntoIter(keys([1, 2]), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); + const ne: boolean = !rs.iterEq(rs.vecIntoIter(keys([4]), rs.drop), rs.vecIntoIter(keys([4, 5]), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), true, true, true, undefined, rs.drop, rs.drop); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(eq2, f), (f: rs.Formatter) => rs.fmtBool(ne, f)]; + Log.note(log, rs.fmtFormat(["eq ", args4[0], " ", args4[1]])); } else if (_16 === 2) { - const part7 = rt.iterEq(rt.iterFilter(rt.vecIntoIter(keys([1, 2, 3]), rt.drop), (_210: Key.Key): boolean => { + const part7 = rs.iterEq(rs.iterFilter(rs.vecIntoIter(keys([1, 2, 3]), rs.drop), (_210: Key.Key): boolean => { return true; - }, rt.drop), rt.vecIntoIter(keys([1, 2]), rt.drop), rt.consuming(Key.eq$cmp_PartialEq, rt.drop, rt.drop), undefined, true, true, undefined, rt.drop, rt.drop); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part7, f)]; - Log.note(log, rt.fmtFormat(["eq ", args6[0]])); + }, rs.drop), rs.vecIntoIter(keys([1, 2]), rs.drop), rs.consuming(Key.eq$cmp_PartialEq, rs.drop, rs.drop), undefined, true, true, undefined, rs.drop, rs.drop); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part7, f)]; + Log.note(log, rs.fmtFormat(["eq ", args6[0]])); } else if (_16 === 3) { - const part6 = rt.iterCmp(rt.vecIntoIter(keys([1, 2]), rt.drop), rt.vecIntoIter(keys([1, 2, 4]), rt.drop), rt.consuming(Key.cmp$cmp_Ord, rt.drop, rt.drop), true, true, undefined, rt.drop, rt.drop); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(part6, f)]; - Log.note(log, rt.fmtFormat(["cmp ", args8[0]])); + const part6 = rs.iterCmp(rs.vecIntoIter(keys([1, 2]), rs.drop), rs.vecIntoIter(keys([1, 2, 4]), rs.drop), rs.consuming(Key.cmp$cmp_Ord, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part6, f)]; + Log.note(log, rs.fmtFormat(["cmp ", args8[0]])); } else if (_16 === 4) { - const cmp2: rt.Ordering | undefined = rt.iterCmp(rt.vecIntoIter(keys([1, 3, 5]), rt.drop), rt.vecIntoIter(keys([1, 2]), rt.drop), rt.consuming(Key.partialCmp$cmp_PartialOrd, rt.drop, rt.drop), true, true, undefined, rt.drop, rt.drop); - const lt: boolean = rt.iterCmp(rt.vecIntoIter(keys([6]), rt.drop), rt.vecIntoIter(keys([6]), rt.drop), rt.consuming(Key.partialCmp$cmp_PartialOrd, rt.drop, rt.drop), true, true, undefined, rt.drop, rt.drop) === -1; - const _153: rt.i8 = _12(cmp2); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(_153, f), (f: rt.Formatter) => rt.fmtBool(lt, f)]; - Log.note(log, rt.fmtFormat(["partial_cmp ", args10[0], " ", args10[1]])); + const cmp2: rs.Ordering | undefined = rs.iterCmp(rs.vecIntoIter(keys([1, 3, 5]), rs.drop), rs.vecIntoIter(keys([1, 2]), rs.drop), rs.consuming(Key.partialCmp$cmp_PartialOrd, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop); + const lt: boolean = rs.iterCmp(rs.vecIntoIter(keys([6]), rs.drop), rs.vecIntoIter(keys([6]), rs.drop), rs.consuming(Key.partialCmp$cmp_PartialOrd, rs.drop, rs.drop), true, true, undefined, rs.drop, rs.drop) === -1; + const _153: rs.i8 = _12(cmp2); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(_153, f), (f: rs.Formatter) => rs.fmtBool(lt, f)]; + Log.note(log, rs.fmtFormat(["partial_cmp ", args10[0], " ", args10[1]])); } else if (_16 === 5) { - const _163: rt.Iter = rt.vecIntoIter(keys([1, 2]), rt.drop); - const _169: rt.Vec = guards([1, 2, 5]); + const _163: rs.Iter = rs.vecIntoIter(keys([1, 2]), rs.drop); + const _169: rs.Vec = guards([1, 2, 5]); _283 = false; const captured3 = c; - const part5 = rt.iterCmp(_163, rt.vecIntoIter(_169, rt.drop), rt.closure((x3: Key.Key, y3: Guard.Guard): rt.Ordering => { + const part5 = rs.iterCmp(_163, rs.vecIntoIter(_169, rs.drop), rs.closure((x3: Key.Key, y3: Guard.Guard): rs.Ordering => { Guard.note(captured3, "compared"); - const _93: rt.u32 = Guard.id(y3); - const _011: rt.Ordering = rt.cmp(x3.id, _93); + const _93: rs.u32 = Guard.id(y3); + const _011: rs.Ordering = rs.cmp(x3.id, _93); y3[Symbol.dispose](); x3[Symbol.dispose](); return _011; }, (): void => { captured3[Symbol.dispose](); - }), true, true, true, rt.drop, rt.drop); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(part5, f)]; - Log.note(log, rt.fmtFormat(["cmp_by ", args12[0]])); + }), true, true, true, rs.drop, rs.drop); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part5, f)]; + Log.note(log, rs.fmtFormat(["cmp_by ", args12[0]])); } else if (_16 === 6) { - const _188: rt.Iter = rt.vecIntoIter(keys([1, 2]), rt.drop); - const _194: rt.Vec = guards([1]); + const _188: rs.Iter = rs.vecIntoIter(keys([1, 2]), rs.drop); + const _194: rs.Vec = guards([1]); _283 = false; const captured2 = c; - const part4 = rt.iterEq(_188, rt.vecIntoIter(_194, rt.drop), rt.closure((x2: Key.Key, y2: Guard.Guard): boolean => { + const part4 = rs.iterEq(_188, rs.vecIntoIter(_194, rs.drop), rs.closure((x2: Key.Key, y2: Guard.Guard): boolean => { Guard.note(captured2, "compared"); const _010: boolean = x2.id === Guard.id(y2); y2[Symbol.dispose](); @@ -763,38 +763,38 @@ export function compared(log: Log.Log, id: rt.u32, arg: rt.u8): void { return _010; }, (): void => { captured2[Symbol.dispose](); - }), true, true, true, true, rt.drop, rt.drop); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; - Log.note(log, rt.fmtFormat(["eq_by ", args14[0]])); + }), true, true, true, true, rs.drop, rs.drop); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; + Log.note(log, rs.fmtFormat(["eq_by ", args14[0]])); } else if (_16 === 7) { - const _211: rt.Iter = rt.vecIntoIter(keys([1, 2, 3]), rt.drop); - const _217: rt.Vec = guards([1]); + const _211: rs.Iter = rs.vecIntoIter(keys([1, 2, 3]), rs.drop); + const _217: rs.Vec = guards([1]); _283 = false; const captured = c; - const part2 = rt.iterCmp(_211, rt.vecIntoIter(_217, rt.drop), rt.closure((x: Key.Key, y: Guard.Guard): rt.Ordering | undefined => { + const part2 = rs.iterCmp(_211, rs.vecIntoIter(_217, rs.drop), rs.closure((x: Key.Key, y: Guard.Guard): rs.Ordering | undefined => { Guard.note(captured, "compared"); - const _9: rt.u32 = Guard.id(y); - const _09: rt.Ordering | undefined = rt.cmp(x.id, _9); + const _9: rs.u32 = Guard.id(y); + const _09: rs.Ordering | undefined = rs.cmp(x.id, _9); y[Symbol.dispose](); x[Symbol.dispose](); return _09; }, (): void => { captured[Symbol.dispose](); - }), true, true, true, rt.drop, rt.drop); + }), true, true, true, rs.drop, rs.drop); const part3 = _12(part2); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(part3, f)]; - Log.note(log, rt.fmtFormat(["partial_cmp_by ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part3, f)]; + Log.note(log, rs.fmtFormat(["partial_cmp_by ", args16[0]])); } else { - const _238: [rt.Iter, rt.Iter] = [rt.vecIntoIter(keys([1, 2, 3]), rt.drop), rt.vecIntoIter(keys([1, 4, 5]), rt.drop)]; - const a: rt.Iter = _238[0]; - const b: rt.Iter = _238[1]; - const _252: rt.Iter = a; - const _254: rt.Iter = b; - const part = rt.iterCmp(rt.iterBorrow(_252), rt.iterBorrow(_254), rt.consuming(Key.cmp$cmp_Ord, rt.drop, rt.drop), undefined, undefined, undefined, rt.drop, rt.drop); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.i8Display(part, f)]; - Log.note(log, rt.fmtFormat(["cmp ", args18[0]])); - rt.drop(b); - rt.drop(a); + const _238: [rs.Iter, rs.Iter] = [rs.vecIntoIter(keys([1, 2, 3]), rs.drop), rs.vecIntoIter(keys([1, 4, 5]), rs.drop)]; + const a: rs.Iter = _238[0]; + const b: rs.Iter = _238[1]; + const _252: rs.Iter = a; + const _254: rs.Iter = b; + const part = rs.iterCmp(rs.iterBorrow(_252), rs.iterBorrow(_254), rs.consuming(Key.cmp$cmp_Ord, rs.drop, rs.drop), undefined, undefined, undefined, rs.drop, rs.drop); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.i8Display(part, f)]; + Log.note(log, rs.fmtFormat(["cmp ", args18[0]])); + rs.drop(b); + rs.drop(a); } if (_283) { c[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/drops/lists.ts b/ts/fixtures/task/expected/drops/lists.ts index 43e49c10c..cec4e1966 100644 --- a/ts/fixtures/task/expected/drops/lists.ts +++ b/ts/fixtures/task/expected/drops/lists.ts @@ -1,182 +1,182 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { map$0782hf5 as option_map$0782hf5 } from "../core/option.ts"; +import * as rs from "../rs.ts"; +import { map$0bmexgo as option_map$0bmexgo } from "../core/option.ts"; import * as Key from "../drops.Key.ts"; import * as Log from "../log.Log.ts"; /** The ids of a list's keys, front to back, apart from `id`. */ -export function ids(id: rt.u32, l: rt.LinkedList): string { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.listIter(l), (k: Key.Key): string => { - const _4: rt.u32 = rt.u32Sub(k.id, id); - return rt.fmtToString((f: rt.Formatter) => rt.u32Display(_4, f)); +export function ids(id: rs.u32, l: rs.LinkedList): string { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.listIter(l), (k: Key.Key): string => { + const _4: rs.u32 = rs.u32Sub(k.id, id); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_4, f)); }), undefined, 12, true).items, ","); } /** Run scenario `arg % 8`. */ -export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const key: (a0: rt.u32) => Key.Key = (n: rt.u32): Key.Key => { - return Key.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const key: (a0: rs.u32) => Key.Key = (n: rs.u32): Key.Key => { + return Key.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const keys: (a0: rt.u32[]) => rt.LinkedList = (ns: rt.u32[]): rt.LinkedList => { - const _32: rt.Iter = rt.iterMap(rt.iterSlice(ns), (_2: rt.u32): Key.Key => { + const keys: (a0: rs.u32[]) => rs.LinkedList = (ns: rs.u32[]): rs.LinkedList => { + const _32: rs.Iter = rs.iterMap(rs.iterSlice(ns), (_2: rs.u32): Key.Key => { return key(_2); }); - return rt.listExtend(rt.listNew() as rt.LinkedList, _32); + return rs.listExtend(rs.listNew() as rs.LinkedList, _32); }; - const _8: rt.u8 = rt.u8Rem(arg, 8); + const _8: rs.u8 = rs.u8Rem(arg, 8); if (_8 === 0) { - const l: rt.LinkedList = rt.listNew() as rt.LinkedList; + const l: rs.LinkedList = rs.listNew() as rs.LinkedList; const _13: Key.Key = key(2); - rt.listPushBack(l, _13); + rs.listPushBack(l, _13); const _18: Key.Key = key(1); - rt.listPushFront(l, _18); + rs.listPushFront(l, _18); const _23: Key.Key = key(3); - rt.listPushBack(l, _23); + rs.listPushBack(l, _23); const _28: Key.Key = key(4); - rt.listPushBack(l, _28); + rs.listPushBack(l, _28); const _33: Key.Key = key(0); - rt.listPushFront(l, _33); - rt.drop(rt.listPopBack(l)); + rs.listPushFront(l, _33); + rs.drop(rs.listPopBack(l)); Log.note(log, "popped back"); - rt.drop(rt.listPopFront(l)); + rs.drop(rs.listPopFront(l)); const part11 = ids(id, l); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part11)]; - Log.note(log, rt.fmtFormat(["left ", args2[0]])); - rt.listDrop(l, rt.drop); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part11)]; + Log.note(log, rs.fmtFormat(["left ", args2[0]])); + rs.listDrop(l, rs.drop); } else if (_8 === 1) { - let l2: rt.LinkedList = keys([1, 2, 3]); - rt.listClear(l2, rt.drop); + let l2: rs.LinkedList = keys([1, 2, 3]); + rs.listClear(l2, rs.drop); const part9 = l2.n; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part9, f)]; - Log.note(log, rt.fmtFormat(["cleared ", args4[0]])); - rt.listPushBack(l2, key(4)); - const _81: rt.LinkedList = keys([5, 6]); - rt.listDrop(l2, rt.drop); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part9, f)]; + Log.note(log, rs.fmtFormat(["cleared ", args4[0]])); + rs.listPushBack(l2, key(4)); + const _81: rs.LinkedList = keys([5, 6]); + rs.listDrop(l2, rs.drop); l2 = _81; const part10 = ids(id, l2); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part10)]; - Log.note(log, rt.fmtFormat(["replaced ", args6[0]])); - rt.listDrop(l2, rt.drop); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part10)]; + Log.note(log, rs.fmtFormat(["replaced ", args6[0]])); + rs.listDrop(l2, rs.drop); } else if (_8 === 2) { - const it: rt.Iter = rt.listIter(keys([1, 2, 3, 4, 5, 6]), rt.drop); - rt.drop(rt.iterToOption(it.nextBack())); - rt.drop(rt.iterToOption(it.next())); - rt.drop(rt.iterToOption(it.nextBack())); + const it: rs.Iter = rs.listIter(keys([1, 2, 3, 4, 5, 6]), rs.drop); + rs.drop(rs.iterToOption(it.nextBack())); + rs.drop(rs.iterToOption(it.next())); + rs.drop(rs.iterToOption(it.nextBack())); const part7 = it.len(); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; - Log.note(log, rt.fmtFormat(["len ", args8[0]])); - const part8 = option_map$0782hf5(rt.iterNth(it, 1, rt.drop), (k6: Key.Key): rt.u32 => { - const _09: rt.u32 = rt.u32Sub(k6.id, id); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; + Log.note(log, rs.fmtFormat(["len ", args8[0]])); + const part8 = option_map$0bmexgo(rs.iterNth(it, 1, rs.drop), (k6: Key.Key): rs.u32 => { + const _09: rs.u32 = rs.u32Sub(k6.id, id); k6[Symbol.dispose](); return _09; }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["nth ", args10[0]])); - rt.drop(it); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["nth ", args10[0]])); + rs.drop(it); } else if (_8 === 3) { - const l3: rt.LinkedList = keys([1, 2, 3, 4, 5]); - const back: rt.LinkedList = rt.listSplitOff(l3, 3); - const none: rt.LinkedList = rt.listSplitOff(l3, 3); - const all: rt.LinkedList = rt.listSplitOff(l3, 0); + const l3: rs.LinkedList = keys([1, 2, 3, 4, 5]); + const back: rs.LinkedList = rs.listSplitOff(l3, 3); + const none: rs.LinkedList = rs.listSplitOff(l3, 3); + const all: rs.LinkedList = rs.listSplitOff(l3, 0); const _157: string = ids(id, l3); const _160: string = ids(id, back); const _163: string = ids(id, none); const _166: string = ids(id, all); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _157), (f: rt.Formatter) => rt.fmtPad(f, _160), (f: rt.Formatter) => rt.fmtPad(f, _163), (f: rt.Formatter) => rt.fmtPad(f, _166)]; - Log.note(log, rt.fmtFormat(["split ", args12[0], " ", args12[1], " ", args12[2], " ", args12[3]])); - rt.listDrop(all, rt.drop); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _157), (f: rs.Formatter) => rs.fmtPad(f, _160), (f: rs.Formatter) => rs.fmtPad(f, _163), (f: rs.Formatter) => rs.fmtPad(f, _166)]; + Log.note(log, rs.fmtFormat(["split ", args12[0], " ", args12[1], " ", args12[2], " ", args12[3]])); + rs.listDrop(all, rs.drop); Log.note(log, "front dropped"); - rt.listDrop(back, rt.drop); - rt.listDrop(none, rt.drop); - rt.listDrop(l3, rt.drop); + rs.listDrop(back, rs.drop); + rs.listDrop(none, rs.drop); + rs.listDrop(l3, rs.drop); } else if (_8 === 4) { - const l4: rt.LinkedList = keys([1, 2]); - const other: rt.LinkedList = keys([3, 4]); - rt.listAppend(l4, other); + const l4: rs.LinkedList = keys([1, 2]); + const other: rs.LinkedList = keys([3, 4]); + rs.listAppend(l4, other); const _199: string = ids(id, l4); - const _202: rt.usize = other.n; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _199), (f: rt.Formatter) => rt.usizeDisplay(_202, f)]; - Log.note(log, rt.fmtFormat(["appended ", args14[0], " ", args14[1]])); + const _202: rs.usize = other.n; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _199), (f: rs.Formatter) => rs.usizeDisplay(_202, f)]; + Log.note(log, rs.fmtFormat(["appended ", args14[0], " ", args14[1]])); const _211: Key.Key = key(5); - rt.listPushBack(other, _211); - rt.listAppend(l4, other); + rs.listPushBack(other, _211); + rs.listAppend(l4, other); const _219: Key.Key[] = [key(6), key(7)]; - rt.listExtend(l4, rt.iterSlice(_219, rt.drop), "fold"); - const empty: rt.LinkedList = rt.listNew() as rt.LinkedList; - rt.listAppend(empty, l4); + rs.listExtend(l4, rs.iterSlice(_219, rs.drop), "fold"); + const empty: rs.LinkedList = rs.listNew() as rs.LinkedList; + rs.listAppend(empty, l4); const _236: string = ids(id, empty); - const _239: rt.usize = l4.n; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, _236), (f: rt.Formatter) => rt.usizeDisplay(_239, f)]; - Log.note(log, rt.fmtFormat(["moved ", args16[0], " ", args16[1]])); - rt.listDrop(empty, rt.drop); - rt.listDrop(l4, rt.drop); + const _239: rs.usize = l4.n; + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, _236), (f: rs.Formatter) => rs.usizeDisplay(_239, f)]; + Log.note(log, rs.fmtFormat(["moved ", args16[0], " ", args16[1]])); + rs.listDrop(empty, rs.drop); + rs.listDrop(l4, rs.drop); } else if (_8 === 5) { - const l5: rt.LinkedList = keys([1, 2, 3, 4]); - const source: rt.LinkedList = keys([5, 6]); - rt.listCloneFrom(l5, source, Key.clone$Clone, rt.drop); + const l5: rs.LinkedList = keys([1, 2, 3, 4]); + const source: rs.LinkedList = keys([5, 6]); + rs.listCloneFrom(l5, source, Key.clone$Clone, rs.drop); const part5 = ids(id, l5); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part5)]; - Log.note(log, rt.fmtFormat(["cloned ", args18[0]])); - const longer: rt.LinkedList = keys([7, 8, 9]); - rt.listCloneFrom(l5, longer, Key.clone$Clone, rt.drop); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part5)]; + Log.note(log, rs.fmtFormat(["cloned ", args18[0]])); + const longer: rs.LinkedList = keys([7, 8, 9]); + rs.listCloneFrom(l5, longer, Key.clone$Clone, rs.drop); const part6 = ids(id, l5); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part6)]; - Log.note(log, rt.fmtFormat(["cloned ", args20[0]])); - rt.listDrop(longer, rt.drop); - rt.listDrop(source, rt.drop); - rt.listDrop(l5, rt.drop); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part6)]; + Log.note(log, rs.fmtFormat(["cloned ", args20[0]])); + rs.listDrop(longer, rs.drop); + rs.listDrop(source, rs.drop); + rs.listDrop(l5, rs.drop); } else if (_8 === 6) { - const l6: rt.LinkedList = keys([1, 2, 3, 4, 5, 6]); - const taken: rt.Vec = rt.iterToVec(rt.listExtractIf(l6, (k2: Key.Key): boolean => { - return rt.u32Rem(rt.u32Sub(k2.id, id), 2) === 0; + const l6: rs.LinkedList = keys([1, 2, 3, 4, 5, 6]); + const taken: rs.Vec = rs.iterToVec(rs.listExtractIf(l6, (k2: Key.Key): boolean => { + return rs.u32Rem(rs.u32Sub(k2.id, id), 2) === 0; }), "next", 12); - const _307: rt.usize = taken.items.length; + const _307: rs.usize = taken.items.length; const _310: string = ids(id, l6); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_307, f), (f: rt.Formatter) => rt.fmtPad(f, _310)]; - Log.note(log, rt.fmtFormat(["taken ", args22[0], " left ", args22[1]])); - rt.dropVec(taken); - const first: Key.Key | undefined = rt.iterToOption(rt.listExtractIf(l6, (k3: Key.Key): boolean => { - return rt.u32Sub(k3.id, id) > 1; + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_307, f), (f: rs.Formatter) => rs.fmtPad(f, _310)]; + Log.note(log, rs.fmtFormat(["taken ", args22[0], " left ", args22[1]])); + rs.dropVec(taken); + const first: Key.Key | undefined = rs.iterToOption(rs.listExtractIf(l6, (k3: Key.Key): boolean => { + return rs.u32Sub(k3.id, id) > 1; }).next()); - const _330: rt.u32 | undefined = option_map$0782hf5(first, (k4: Key.Key): rt.u32 => { - return rt.u32Sub(k4.id, id); + const _330: rs.u32 | undefined = option_map$0bmexgo(first, (k4: Key.Key): rs.u32 => { + return rs.u32Sub(k4.id, id); }); const _336: string = ids(id, l6); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_330, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtPad(f, _336)]; - Log.note(log, rt.fmtFormat(["first ", args24[0], " left ", args24[1]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_330, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtPad(f, _336)]; + Log.note(log, rs.fmtFormat(["first ", args24[0], " left ", args24[1]])); const captured = key(9); - const it2: rt.Iter = rt.listExtractIf(l6, rt.closure((k5: Key.Key): boolean => { + const it2: rs.Iter = rs.listExtractIf(l6, rs.closure((k5: Key.Key): boolean => { return k5.id > captured.id; }, (): void => { captured[Symbol.dispose](); })); - const _357: Key.Key | undefined = rt.iterToOption(it2.next()); + const _357: Key.Key | undefined = rs.iterToOption(it2.next()); const part3 = _357 === undefined; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - const _351: string = rt.fmtFormat(["none ", args26[0]]); - rt.drop(_357); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + const _351: string = rs.fmtFormat(["none ", args26[0]]); + rs.drop(_357); Log.note(log, _351); - rt.drop(it2); + rs.drop(it2); const part4 = ids(id, l6); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part4)]; - Log.note(log, rt.fmtFormat(["kept ", args28[0]])); - rt.drop(first); - rt.listDrop(l6, rt.drop); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part4)]; + Log.note(log, rs.fmtFormat(["kept ", args28[0]])); + rs.drop(first); + rs.listDrop(l6, rs.drop); } else { - const it3: rt.Iter = rt.listIter(keys([1, 2, 3]), rt.drop); - rt.drop(rt.iterToOption(it3.next())); - const copy: rt.Iter = it3.clone({ v: Key.clone$Clone }); - const part = rt.ownedCount(it3, rt.drop); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; - Log.note(log, rt.fmtFormat(["counted ", args30[0]])); - const part2 = option_map$0782hf5(rt.ownedLast(copy, rt.drop), (k: Key.Key): rt.u32 => { - const _04: rt.u32 = rt.u32Sub(k.id, id); + const it3: rs.Iter = rs.listIter(keys([1, 2, 3]), rs.drop); + rs.drop(rs.iterToOption(it3.next())); + const copy: rs.Iter = it3.clone({ v: Key.clone$Clone }); + const part = rs.ownedCount(it3, rs.drop); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; + Log.note(log, rs.fmtFormat(["counted ", args30[0]])); + const part2 = option_map$0bmexgo(rs.ownedLast(copy, rs.drop), (k: Key.Key): rs.u32 => { + const _04: rs.u32 = rs.u32Sub(k.id, id); k[Symbol.dispose](); return _04; }); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part2, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["last ", args32[0]])); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part2, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args32[0]])); } } diff --git a/ts/fixtures/task/expected/drops/objects.Part.ts b/ts/fixtures/task/expected/drops/objects.Part.ts index e449615e1..337e28a6b 100644 --- a/ts/fixtures/task/expected/drops/objects.Part.ts +++ b/ts/fixtures/task/expected/drops/objects.Part.ts @@ -1,7 +1,7 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; -export type Part = { id$Part: () => rt.u32; take$Part: () => rt.u32 }; +export type Part = { id$Part: () => rs.u32; take$Part: () => rs.u32 }; //# sourceMappingURL=objects.Part.ts.map diff --git a/ts/fixtures/task/expected/drops/objects.ts b/ts/fixtures/task/expected/drops/objects.ts index 3f0171101..577b3d371 100644 --- a/ts/fixtures/task/expected/drops/objects.ts +++ b/ts/fixtures/task/expected/drops/objects.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any as lib_drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any, drop$Option_sync_Arc_tuple2_model_Guard_model_Guard as lib_drop$Option_sync_Arc_tuple2_model_Guard_model_Guard, drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any as lib_drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any, drop$drops_Held as lib_drop$drops_Held, drop$drops_Wrap_u32 as lib_drop$drops_Wrap_u32, of$drops_Held, of$drops_Wrap_u32, of$model_Guard, of$tuple2_model_Guard_model_Guard, of$u32, ofPlace$drops_Held } from "../lib.ts"; import type * as Any from "../core/any.Any.ts"; -import { map$09vq4lk as option_map$09vq4lk, map$0s8hob8 as option_map$0s8hob8, map$19e1ji3 as option_map$19e1ji3, map$06e51ml as option_map$06e51ml, map$0b0x7xy as option_map$0b0x7xy, mapOr$1jn2pas as option_mapOr$1jn2pas, mapOr$0lu2pr2 as option_mapOr$0lu2pr2 } from "../core/option.ts"; -import { ok$02syyam, asRef$1km6sxf, map$0k5r5cs as result_map$0k5r5cs } from "../core/result.ts"; +import { map$0cuxp9c as option_map$0cuxp9c, map$0aiphi9 as option_map$0aiphi9, map$0cktt1a as option_map$0cktt1a, map$0chhxcr as option_map$0chhxcr, map$0cxn9jm as option_map$0cxn9jm, mapOr$1uf7d6r as option_mapOr$1uf7d6r, mapOr$1yfuqyd as option_mapOr$1yfuqyd } from "../core/option.ts"; +import { ok$1xmzatr, asRef$165wjcp, map$0k9xqln as result_map$0k9xqln } from "../core/result.ts"; import type * as Part from "../drops/objects.Part.ts"; import type * as Held from "../drops.Held.ts"; import * as Wrap from "../drops.Wrap.ts"; @@ -12,135 +12,135 @@ import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Consumes the box, dropping it on return. */ -export function take$drops_objects_Part_u32(self: rt.u32): rt.u32 { - return rt.u32WrappingAdd(id$drops_objects_Part_u32(self), 1); +export function take$drops_objects_Part_u32(self: rs.u32): rs.u32 { + return rs.u32WrappingAdd(id$drops_objects_Part_u32(self), 1); } -export function id$drops_objects_Part_u32(self: rt.u32): rt.u32 { +export function id$drops_objects_Part_u32(self: rs.u32): rs.u32 { return self; } /** Boxed parts of each kind. */ -export function boxed(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function boxed(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; const first: Part.Part = new of$model_Guard(guard(1)); - const parts: rt.Vec = new rt.Vec(); + const parts: rs.Vec = new rs.Vec(); const _13: Part.Part = new of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); parts.items.push(_13); const _24: Part.Part = new of$u32(7); parts.items.push(_24); - const _28: Part.Part = new of$drops_Wrap_u32(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); + const _28: Part.Part = new of$drops_Wrap_u32(new Wrap.Wrap(rs.u32Add(id, 4), Log.clone$Clone(log), 0)); parts.items.push(_28); const _36: Part.Part = new of$drops_Held({ tag: "One", _0: guard(5) } as Held.Held); parts.items.push(_36); - rt.sliceSwap(parts.items, 2, 3); - const part = rt.iterFold(rt.iterMap(rt.iterSlice(parts.items), (p: Part.Part): rt.u32 => { + rs.sliceSwap(parts.items, 2, 3); + const part = rs.iterFold(rs.iterMap(rs.iterSlice(parts.items), (p: Part.Part): rs.u32 => { return p.id$Part(); - }), 0, (a0: rt.u32, a1: rt.u32): rt.u32 => { - return rt.u32WrappingAdd(a0, a1); + }), 0, (a0: rs.u32, a1: rs.u32): rs.u32 => { + return rs.u32WrappingAdd(a0, a1); }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["ids ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["ids ", args2[0]])); let slot: Part.Part = new of$model_Guard(guard(6)); const part2 = slot.id$Part(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["slot ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["slot ", args4[0]])); const _77: Held.Held = { tag: "Empty" }; - rt.drop(slot); + rs.drop(slot); slot = new of$drops_Held(_77); const part3 = slot.id$Part(); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["slot ", args6[0]])); - const _91: rt.u32 = 7; - rt.drop(slot); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["slot ", args6[0]])); + const _91: rs.u32 = 7; + rs.drop(slot); slot = new of$u32(_91); const part4 = first.take$Part(); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["took ", args8[0]])); - const part5 = option_map$0s8hob8(rt.vecPop(parts), (a02: Part.Part): rt.u32 => { + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["took ", args8[0]])); + const part5 = option_map$0aiphi9(rs.vecPop(parts), (a02: Part.Part): rs.u32 => { return a02.take$Part(); }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part5, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["last ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part5, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["last ", args10[0]])); const kept: Part.Part | undefined = new of$model_Guard(guard(7)); - rt.dropVec(parts); - const _130: rt.u32 = option_mapOr$1jn2pas(kept, 0, (p2: Part.Part): rt.u32 => { + rs.dropVec(parts); + const _130: rs.u32 = option_mapOr$1uf7d6r(kept, 0, (p2: Part.Part): rs.u32 => { return p2.id$Part(); }); - const _134: rt.u32 = slot.id$Part(); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_130, f), (f: rt.Formatter) => rt.u32Display(_134, f)]; - Log.note(log, rt.fmtFormat(["kept ", args12[0], " ", args12[1]])); - rt.drop(kept); - rt.drop(slot); + const _134: rs.u32 = slot.id$Part(); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_130, f), (f: rs.Formatter) => rs.u32Display(_134, f)]; + Log.note(log, rs.fmtFormat(["kept ", args12[0], " ", args12[1]])); + rs.drop(kept); + rs.drop(slot); } /** * Shared parts of each kind, each dropped by the last `Arc` of it, a trait object's or * its own. */ -export function shared(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function shared(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const held: rt.Arc = new rt.Arc({ tag: "Two", _0: guard(1), _1: guard(2) } as Held.Held); - const _14: rt.Arc = rt.arcClone(held); - const first: rt.Arc = new rt.ArcDyn(_14, new of$drops_Held(_14.value)); - const _17: rt.Arc = rt.arcClone(held); - const second: rt.Arc = new rt.ArcDyn(_17, new of$drops_Held(_17.value)); - const _25: rt.u32 = first.value.id$Part(); - const _29: rt.usize = held.strong; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_25, f), (f: rt.Formatter) => rt.usizeDisplay(_29, f)]; - Log.note(log, rt.fmtFormat(["held ", args2[0], " ", args2[1]])); - rt.arcDrop(held, lib_drop$drops_Held); + const held: rs.Arc = new rs.Arc({ tag: "Two", _0: guard(1), _1: guard(2) } as Held.Held); + const _14: rs.Arc = rs.arcClone(held); + const first: rs.Arc = new rs.ArcDyn(_14, new of$drops_Held(_14.value)); + const _17: rs.Arc = rs.arcClone(held); + const second: rs.Arc = new rs.ArcDyn(_17, new of$drops_Held(_17.value)); + const _25: rs.u32 = first.value.id$Part(); + const _29: rs.usize = held.strong; + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_25, f), (f: rs.Formatter) => rs.usizeDisplay(_29, f)]; + Log.note(log, rs.fmtFormat(["held ", args2[0], " ", args2[1]])); + rs.arcDrop(held, lib_drop$drops_Held); first[Symbol.dispose](); const part = second.strong; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part, f)]; - Log.note(log, rt.fmtFormat(["count ", args4[0]])); - const kept: rt.Arc = new rt.Arc(guard(3)); - const wrap: rt.Arc> = new rt.Arc(new Wrap.Wrap(rt.u32Add(id, 4), Log.clone$Clone(log), 0)); - const parts: rt.Vec> = new rt.Vec(); - const _63: rt.Arc> = rt.arcClone(wrap); - parts.items.push(new rt.ArcDyn(_63, new of$drops_Wrap_u32(_63.value))); - const _68: rt.Arc = rt.arcClone(kept); - parts.items.push(new rt.ArcDyn(_68, new of$model_Guard(_68.value))); - const _72: rt.Arc = rt.arcClone(second); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part, f)]; + Log.note(log, rs.fmtFormat(["count ", args4[0]])); + const kept: rs.Arc = new rs.Arc(guard(3)); + const wrap: rs.Arc> = new rs.Arc(new Wrap.Wrap(rs.u32Add(id, 4), Log.clone$Clone(log), 0)); + const parts: rs.Vec> = new rs.Vec(); + const _63: rs.Arc> = rs.arcClone(wrap); + parts.items.push(new rs.ArcDyn(_63, new of$drops_Wrap_u32(_63.value))); + const _68: rs.Arc = rs.arcClone(kept); + parts.items.push(new rs.ArcDyn(_68, new of$model_Guard(_68.value))); + const _72: rs.Arc = rs.arcClone(second); parts.items.push(_72); - const _77: rt.Arc = new rt.Arc(7); - parts.items.push(new rt.ArcDyn(_77, new of$u32(_77.value))); - const weak: rt.Weak = new rt.Weak(parts.items[rt.idx(parts.items, 1)]); + const _77: rs.Arc = new rs.Arc(7); + parts.items.push(new rs.ArcDyn(_77, new of$u32(_77.value))); + const weak: rs.Weak = new rs.Weak(parts.items[rs.idx(parts.items, 1)]); second[Symbol.dispose](); - const part2 = rt.iterFold(rt.iterMap(rt.iterSlice(parts.items), (p: rt.Arc): rt.u32 => { + const part2 = rs.iterFold(rs.iterMap(rs.iterSlice(parts.items), (p: rs.Arc): rs.u32 => { return p.value.id$Part(); - }), 0, (a0: rt.u32, a1: rt.u32): rt.u32 => { - return rt.u32WrappingAdd(a0, a1); + }), 0, (a0: rs.u32, a1: rs.u32): rs.u32 => { + return rs.u32WrappingAdd(a0, a1); }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["ids ", args6[0]])); - rt.arcDrop(wrap, lib_drop$drops_Wrap_u32); - rt.dropVec(parts); - const part3 = option_mapOr$0lu2pr2(rt.weakUpgrade(weak), 0, (p2: rt.Arc): rt.u32 => { - const _04: rt.u32 = p2.value.id$Part(); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["ids ", args6[0]])); + rs.arcDrop(wrap, lib_drop$drops_Wrap_u32); + rs.dropVec(parts); + const part3 = option_mapOr$1yfuqyd(rs.weakUpgrade(weak), 0, (p2: rs.Arc): rs.u32 => { + const _04: rs.u32 = p2.value.id$Part(); p2[Symbol.dispose](); return _04; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["weak ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["weak ", args8[0]])); kept[Symbol.dispose](); - const _122: rt.Arc | undefined = rt.weakUpgrade(weak); + const _122: rs.Arc | undefined = rs.weakUpgrade(weak); const part4 = _122 === undefined; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; - const _116: string = rt.fmtFormat(["gone ", args10[0]]); - rt.drop(_122); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; + const _116: string = rs.fmtFormat(["gone ", args10[0]]); + rs.drop(_122); Log.note(log, _116); - const _132: rt.Arc> = new rt.Arc(new sharedFuture$closure1(guard(6))); - const future: rt.Arc> = new rt.ArcDyn(_132, _132.value); - const other: rt.Arc> = rt.arcClone(future); + const _132: rs.Arc> = new rs.Arc(new sharedFuture$closure1(guard(6))); + const future: rs.Arc> = new rs.ArcDyn(_132, _132.value); + const other: rs.Arc> = rs.arcClone(future); future[Symbol.dispose](); const part5 = other.strong; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part5, f)]; - Log.note(log, rt.fmtFormat(["future ", args12[0]])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part5, f)]; + Log.note(log, rs.fmtFormat(["future ", args12[0]])); other[Symbol.dispose](); weak[Symbol.dispose](); } @@ -159,14 +159,14 @@ export class sharedFuture$closure1 { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _4: rt.u32 = Guard.id(this.#captured); + const _4: rs.u32 = Guard.id(this.#captured); this.#captured[Symbol.dispose](); this.#state = 1; return _4; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -174,11 +174,11 @@ export class sharedFuture$closure1 { * Boxed and shared values as `dyn Any`: each drops what it was made of, as is or downcast, * and an `Arc` held only for its drop drops it with its last clone. */ -export function anys(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function anys(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const boxes: rt.Vec = new rt.Vec(); + const boxes: rs.Vec = new rs.Vec(); const _8: Any.Any = new of$model_Guard(guard(1)); boxes.items.push(_8); const _15: Any.Any = new of$drops_Held({ tag: "Two", _0: guard(2), _1: guard(3) } as Held.Held); @@ -187,345 +187,345 @@ export function anys(log: Log.Log, id: rt.u32): void { boxes.items.push(_26); const _30: Any.Any = new of$model_Guard(guard(4)); boxes.items.push(_30); - const last: rt.Result | undefined = option_map$09vq4lk(rt.vecPop(boxes), (b2: Any.Any): rt.Result => { - return b2 instanceof of$model_Guard ? rt.Ok(b2.v) : rt.Err(b2); + const last: rs.Result | undefined = option_map$0cuxp9c(rs.vecPop(boxes), (b2: Any.Any): rs.Result => { + return b2 instanceof of$model_Guard ? rs.Ok(b2.v) : rs.Err(b2); }); - const part = option_map$19e1ji3(last, (g: rt.Result): boolean => { - return result_map$0k5r5cs(asRef$1km6sxf(g), (g2: Guard.Guard): rt.u32 => { + const part = option_map$0cktt1a(last, (g: rs.Result): boolean => { + return result_map$0k9xqln(asRef$165wjcp(g), (g2: Guard.Guard): rs.u32 => { return Guard.id(g2); }).ok; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part, f, rt.fmtBool)]; - Log.note(log, rt.fmtFormat(["last ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part, f, rs.fmtBool)]; + Log.note(log, rs.fmtFormat(["last ", args2[0]])); lib_drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(last); - const _53: Any.Any = rt.vecRemove(boxes, 1); - const held: rt.Result = _53 instanceof of$model_Guard ? rt.Ok(_53.v) : rt.Err(_53); + const _53: Any.Any = rs.vecRemove(boxes, 1); + const held: rs.Result = _53 instanceof of$model_Guard ? rs.Ok(_53.v) : rs.Err(_53); const part2 = !held.ok; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; - Log.note(log, rt.fmtFormat(["held ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; + Log.note(log, rs.fmtFormat(["held ", args4[0]])); let slot: Any.Any = new of$model_Guard(guard(5)); const _72: Held.Held = { tag: "Empty" }; - rt.drop(slot); + rs.drop(slot); slot = new of$drops_Held(_72); const _81: Any.Any = slot; const arg = _81 instanceof of$drops_Held || _81 instanceof ofPlace$drops_Held; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(arg, f)]; - Log.note(log, rt.fmtFormat(["slot ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(arg, f)]; + Log.note(log, rs.fmtFormat(["slot ", args6[0]])); lib_drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(held); - rt.dropVec(boxes); - const _90: rt.Arc<[Guard.Guard, Guard.Guard]> = new rt.Arc([guard(6), guard(7)] as [Guard.Guard, Guard.Guard]); - const hold: rt.Arc = new rt.ArcDyn(_90, new of$tuple2_model_Guard_model_Guard(_90.value)); - const clones: rt.Arc[] = [rt.arcClone(hold), rt.arcClone(hold)]; + rs.dropVec(boxes); + const _90: rs.Arc<[Guard.Guard, Guard.Guard]> = new rs.Arc([guard(6), guard(7)] as [Guard.Guard, Guard.Guard]); + const hold: rs.Arc = new rs.ArcDyn(_90, new of$tuple2_model_Guard_model_Guard(_90.value)); + const clones: rs.Arc[] = [rs.arcClone(hold), rs.arcClone(hold)]; hold[Symbol.dispose](); const part3 = clones[0].strong; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part3, f)]; - Log.note(log, rt.fmtFormat(["clones ", args8[0]])); - const a: rt.Arc = clones[0]; - const b: rt.Arc = clones[1]; - const typed: rt.Arc<[Guard.Guard, Guard.Guard]> | undefined = ok$02syyam(rt.arcDowncast(a, of$tuple2_model_Guard_model_Guard, (object) => object.v)); - const part4 = option_map$06e51ml(typed, (t: rt.Arc<[Guard.Guard, Guard.Guard]>): [rt.u32, rt.usize] => { - return [Guard.id(t.value[0]), t.strong] as [rt.u32, rt.usize]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part3, f)]; + Log.note(log, rs.fmtFormat(["clones ", args8[0]])); + const a: rs.Arc = clones[0]; + const b: rs.Arc = clones[1]; + const typed: rs.Arc<[Guard.Guard, Guard.Guard]> | undefined = ok$1xmzatr(rs.arcDowncast(a, of$tuple2_model_Guard_model_Guard, (object) => object.v)); + const part4 = option_map$0chhxcr(typed, (t: rs.Arc<[Guard.Guard, Guard.Guard]>): [rs.u32, rs.usize] => { + return [Guard.id(t.value[0]), t.strong] as [rs.u32, rs.usize]; }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, (value: [rt.u32, rt.usize], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.u32Debug(value[0], f), (f: rt.Formatter) => rt.usizeDebug(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["typed ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, (value: [rs.u32, rs.usize], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.u32Debug(value[0], f), (f: rs.Formatter) => rs.usizeDebug(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["typed ", args10[0]])); lib_drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(typed); Log.note(log, "dropped"); b[Symbol.dispose](); const _149: Any.Any = slot; const part5 = (_149 instanceof of$drops_Held ? _149.v : _149 instanceof ofPlace$drops_Held ? _149.v.v : undefined) !== undefined; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; - Log.note(log, rt.fmtFormat(["slot ", args12[0]])); - rt.drop(slot); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; + Log.note(log, rs.fmtFormat(["slot ", args12[0]])); + rs.drop(slot); } /** * Boxed and shared closures as `dyn Fn*`: each drops what it owns where the box or the * last `Arc` goes, or, called through `FnOnce`, where its body or the call ends. */ -export function fns(log: Log.Log, id: rt.u32): void { - const guard: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); +export function fns(log: Log.Log, id: rs.u32): void { + const guard: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; const _7: [Guard.Guard, Guard.Guard] = [guard(1), guard(2)]; const a: Guard.Guard = _7[0]; const b: Guard.Guard = _7[1]; const captured = a; - const moved: () => rt.u32 = rt.closure((): rt.u32 => { - const id2: rt.u32 = Guard.id(captured); + const moved: () => rs.u32 = rs.closure((): rs.u32 => { + const id2: rs.u32 = Guard.id(captured); captured[Symbol.dispose](); return id2; }, (): void => { captured[Symbol.dispose](); }); const captured2 = b; - const uncalled: () => rt.u32 = rt.closure((): rt.u32 => { - const _02: rt.u32 = Guard.id(captured2); + const uncalled: () => rs.u32 = rs.closure((): rs.u32 => { + const _02: rs.u32 = Guard.id(captured2); captured2[Symbol.dispose](); return _02; }, (): void => { captured2[Symbol.dispose](); }); const part = moved(); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["moved ", args2[0]])); - rt.drop(uncalled); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["moved ", args2[0]])); + rs.drop(uncalled); const captured3 = guard(3); - const part2 = rt.closure((): rt.u32 => { - const _03: rt.u32 = Guard.id(captured3); + const part2 = rs.closure((): rs.u32 => { + const _03: rs.u32 = Guard.id(captured3); captured3[Symbol.dispose](); return _03; }, (): void => { captured3[Symbol.dispose](); })(); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["once ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["once ", args4[0]])); const captured4 = guard(4); - const part3 = rt.once(rt.closure((): rt.u32 => { - return rt.u32Add(Guard.id(captured4), 1); + const part3 = rs.once(rs.closure((): rs.u32 => { + return rs.u32Add(Guard.id(captured4), 1); }, (): void => { captured4[Symbol.dispose](); }))(); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["up ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["up ", args6[0]])); const captured5 = guard(5); - let slot: () => rt.u32 = rt.closure((): rt.u32 => { + let slot: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured5); }, (): void => { captured5[Symbol.dispose](); }); const part4 = slot(); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["slot ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["slot ", args8[0]])); const captured6 = guard(6); - const _88: () => rt.u32 = rt.closure((): rt.u32 => { + const _88: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured6); }, (): void => { captured6[Symbol.dispose](); }); - rt.drop(slot); + rs.drop(slot); slot = _88; const part5 = slot(); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - Log.note(log, rt.fmtFormat(["slot ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + Log.note(log, rs.fmtFormat(["slot ", args10[0]])); const _104: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _104[0]; const h: Guard.Guard = _104[1]; const captured7 = g; - const _113: () => rt.u32 = rt.closure((): rt.u32 => { + const _113: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured7); }, (): void => { captured7[Symbol.dispose](); }); const captured8 = h; - const list: rt.Vec<() => rt.u32> = rt.vecFrom([_113, rt.closure((): rt.u32 => { + const list: rs.Vec<() => rs.u32> = rs.vecFrom([_113, rs.closure((): rs.u32 => { return Guard.id(captured8); }, (): void => { captured8[Symbol.dispose](); })]); - const part6 = rt.u32Add(list.items[rt.idx(list.items, 1)](), list.items[rt.idx(list.items, 0)]()); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Log.note(log, rt.fmtFormat(["list ", args12[0]])); - rt.dropVec(list); + const part6 = rs.u32Add(list.items[rs.idx(list.items, 1)](), list.items[rs.idx(list.items, 0)]()); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Log.note(log, rs.fmtFormat(["list ", args12[0]])); + rs.dropVec(list); const captured9 = guard(9); - const _143: rt.Arc<() => rt.u32> = new rt.Arc(rt.closure((): rt.u32 => { + const _143: rs.Arc<() => rs.u32> = new rs.Arc(rs.closure((): rs.u32 => { return Guard.id(captured9); }, (): void => { captured9[Symbol.dispose](); })); - const shared: rt.Arc<() => rt.u32> = new rt.ArcDyn(_143, _143.value); - const other: rt.Arc<() => rt.u32> = rt.arcClone(shared); + const shared: rs.Arc<() => rs.u32> = new rs.ArcDyn(_143, _143.value); + const other: rs.Arc<() => rs.u32> = rs.arcClone(shared); shared[Symbol.dispose](); const part7 = other.value(); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["shared ", args14[0]])); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["shared ", args14[0]])); other[Symbol.dispose](); const part8 = slot(); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part8, f)]; - Log.note(log, rt.fmtFormat(["slot ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; + Log.note(log, rs.fmtFormat(["slot ", args16[0]])); const captured10 = guard(10); - const lent: () => rt.u32 = rt.closure((): rt.u32 => { + const lent: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured10); }, (): void => { captured10[Symbol.dispose](); }); - const boxed: () => rt.u32 = rt.lent(lent); + const boxed: () => rs.u32 = rs.lent(lent); const part9 = boxed(); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part9, f)]; - Log.note(log, rt.fmtFormat(["lent ", args18[0]])); - rt.drop(boxed); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; + Log.note(log, rs.fmtFormat(["lent ", args18[0]])); + rs.drop(boxed); const part10 = lent(); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; - Log.note(log, rt.fmtFormat(["lent ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; + Log.note(log, rs.fmtFormat(["lent ", args20[0]])); const captured11 = guard(11); - const part11 = rt.once(rt.closure((): rt.u32 => { + const part11 = rs.once(rs.closure((): rs.u32 => { return Guard.id(captured11); }, (): void => { captured11[Symbol.dispose](); }))(); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part11, f)]; - Log.note(log, rt.fmtFormat(["outer ", args22[0]])); - rt.drop(lent); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; + Log.note(log, rs.fmtFormat(["outer ", args22[0]])); + rs.drop(lent); const captured12 = guard(12); - const _230: rt.Arc<() => rt.u32> = new rt.Arc(rt.closure((): rt.u32 => { + const _230: rs.Arc<() => rs.u32> = new rs.Arc(rs.closure((): rs.u32 => { return Guard.id(captured12); }, (): void => { captured12[Symbol.dispose](); })); - const shared2: rt.Arc<() => rt.u32> = new rt.ArcDyn(_230, _230.value); - const up3: rt.Arc<() => rt.u32> = rt.arcClone(shared2); - const again: rt.Arc<() => rt.u32> = rt.arcClone(up3); + const shared2: rs.Arc<() => rs.u32> = new rs.ArcDyn(_230, _230.value); + const up3: rs.Arc<() => rs.u32> = rs.arcClone(shared2); + const again: rs.Arc<() => rs.u32> = rs.arcClone(up3); shared2[Symbol.dispose](); up3[Symbol.dispose](); const part12 = again.strong; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part12, f)]; - Log.note(log, rt.fmtFormat(["up ", args24[0]])); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part12, f)]; + Log.note(log, rs.fmtFormat(["up ", args24[0]])); again[Symbol.dispose](); Log.note(log, "gone"); const _257: [Guard.Guard, Guard.Guard] = [guard(13), guard(14)]; const n: Guard.Guard = _257[0]; const o: Guard.Guard = _257[1]; const captured13 = n; - const part13 = run$boxed_Box_dyn_ops_Fn_unit_u32(rt.closure((): rt.u32 => { + const part13 = run$boxed_Box_dyn_ops_Fn_unit_u32(rs.closure((): rs.u32 => { return Guard.id(captured13); }, (): void => { captured13[Symbol.dispose](); })); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part13, f)]; - Log.note(log, rt.fmtFormat(["run ", args26[0]])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; + Log.note(log, rs.fmtFormat(["run ", args26[0]])); const captured14 = o; - const part14 = run$boxed_Box_drops_objects_fns_closure22(rt.closure((): rt.u32 => { + const part14 = run$boxed_Box_drops_objects_fns_closure22(rs.closure((): rs.u32 => { return Guard.id(captured14); }, (): void => { captured14[Symbol.dispose](); })); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part14, f)]; - Log.note(log, rt.fmtFormat(["run ", args28[0]])); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; + Log.note(log, rs.fmtFormat(["run ", args28[0]])); Log.note(log, "ran"); const _296: [Guard.Guard, Guard.Guard] = [guard(15), guard(16)]; const p: Guard.Guard = _296[0]; const captured15 = _296[1]; - const part15 = option_map$0b0x7xy(1, rt.closure((x2: rt.u32): rt.u32 => { - return rt.u32Add(x2, Guard.id(captured15)); + const part15 = option_map$0cxn9jm(1, rs.closure((x2: rs.u32): rs.u32 => { + return rs.u32Add(x2, Guard.id(captured15)); }, (): void => { captured15[Symbol.dispose](); })); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part15, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["map ", args30[0]])); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part15, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["map ", args30[0]])); const captured16 = guard(18); - const scale: (a0: rt.u32) => rt.u32 = rt.closure((x3: rt.u32): rt.u32 => { - return rt.u32Mul(x3, Guard.id(captured16)); + const scale: (a0: rs.u32) => rs.u32 = rs.closure((x3: rs.u32): rs.u32 => { + return rs.u32Mul(x3, Guard.id(captured16)); }, (): void => { captured16[Symbol.dispose](); }); - const part16 = rt.iterSum(rt.iterMap(rt.iterSlice([1, 2]), scale), rt.u32Add, 0, true); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part16, f)]; - Log.note(log, rt.fmtFormat(["sum ", args32[0]])); + const part16 = rs.iterSum(rs.iterMap(rs.iterSlice([1, 2]), scale), rs.u32Add, 0, true); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part16, f)]; + Log.note(log, rs.fmtFormat(["sum ", args32[0]])); const captured17 = guard(17); - const init: () => rt.u32 = rt.closure((): rt.u32 => { + const init: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured17); }, (): void => { captured17[Symbol.dispose](); }); const captured18 = p; - const unused: () => rt.u32 = rt.closure((): rt.u32 => { + const unused: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured18); }, (): void => { captured18[Symbol.dispose](); }); - const cell: rt.OnceCell = new rt.OnceCell(undefined); - const part17 = rt.onceGetOrInit(cell, rt.once(init), rt.drop); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part17, f)]; - Log.note(log, rt.fmtFormat(["cell ", args34[0]])); - const part18 = rt.onceGetOrInit(cell, rt.once(unused), rt.drop); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part18, f)]; - Log.note(log, rt.fmtFormat(["cell ", args36[0]])); + const cell: rs.OnceCell = new rs.OnceCell(undefined); + const part17 = rs.onceGetOrInit(cell, rs.once(init), rs.drop); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part17, f)]; + Log.note(log, rs.fmtFormat(["cell ", args34[0]])); + const part18 = rs.onceGetOrInit(cell, rs.once(unused), rs.drop); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part18, f)]; + Log.note(log, rs.fmtFormat(["cell ", args36[0]])); const _376: [Guard.Guard, Guard.Guard] = [guard(19), guard(20)]; const u: Guard.Guard = _376[0]; const v: Guard.Guard = _376[1]; const captured19 = u; - const fill: () => rt.u32 = rt.closure((): rt.u32 => { + const fill: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured19); }, (): void => { captured19[Symbol.dispose](); }); const captured20 = v; - const skip: () => rt.u32 = rt.closure((): rt.u32 => { + const skip: () => rs.u32 = rs.closure((): rs.u32 => { return Guard.id(captured20); }, (): void => { captured20[Symbol.dispose](); }); - let lazy = undefined as rt.u32 | undefined; + let lazy = undefined as rs.u32 | undefined; if (lazy === undefined) { - lazy = rt.callOnce(fill); + lazy = rs.callOnce(fill); } else { - rt.drop(fill); + rs.drop(fill); } - const part19 = rt.place(() => lazy as rt.u32, (value4) => (lazy as rt.u32) = value4); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part19.v, f)]; - Log.note(log, rt.fmtFormat(["lazy ", args38[0]])); + const part19 = rs.place(() => lazy as rs.u32, (value4) => (lazy as rs.u32) = value4); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part19.v, f)]; + Log.note(log, rs.fmtFormat(["lazy ", args38[0]])); if (lazy === undefined) { - lazy = rt.callOnce(skip); + lazy = rs.callOnce(skip); } else { - rt.drop(skip); + rs.drop(skip); } - const part20 = rt.place(() => lazy as rt.u32, (value5) => (lazy as rt.u32) = value5); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part20.v, f)]; - Log.note(log, rt.fmtFormat(["lazy ", args40[0]])); + const part20 = rs.place(() => lazy as rs.u32, (value5) => (lazy as rs.u32) = value5); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part20.v, f)]; + Log.note(log, rs.fmtFormat(["lazy ", args40[0]])); const captured21 = guard(21); - const f2: (a0: Guard.Guard) => rt.u32 = rt.closure((g2: Guard.Guard): rt.u32 => { - const _021: rt.u32 = rt.u32Add(Guard.id(g2), Guard.id(captured21)); + const f2: (a0: Guard.Guard) => rs.u32 = rs.closure((g2: Guard.Guard): rs.u32 => { + const _021: rs.u32 = rs.u32Add(Guard.id(g2), Guard.id(captured21)); g2[Symbol.dispose](); return _021; }, (): void => { captured21[Symbol.dispose](); }); - const borrowed: (a0: Guard.Guard) => rt.u32 = f2; - const part21 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([guard(22), guard(23)]), rt.drop), rt.lent(borrowed)), rt.u32Add, 0, true); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part21, f)]; - Log.note(log, rt.fmtFormat(["borrowed ", args42[0]])); - const part22 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([guard(24)]), rt.drop), rt.lent(f2)), rt.u32Add, 0, true); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part22, f)]; - Log.note(log, rt.fmtFormat(["by ref ", args44[0]])); - const part23 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([guard(26)]), rt.drop), rt.lent(borrowed)), rt.u32Add, 0, true); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part23, f)]; - Log.note(log, rt.fmtFormat(["twice ", args46[0]])); - const part24 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([guard(27)]), rt.drop), rt.lent(f2)), rt.u32Add, 0, true); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part24, f)]; - Log.note(log, rt.fmtFormat(["boxed ", args48[0]])); + const borrowed: (a0: Guard.Guard) => rs.u32 = f2; + const part21 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(22), guard(23)]), rs.drop), rs.lent(borrowed)), rs.u32Add, 0, true); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part21, f)]; + Log.note(log, rs.fmtFormat(["borrowed ", args42[0]])); + const part22 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(24)]), rs.drop), rs.lent(f2)), rs.u32Add, 0, true); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part22, f)]; + Log.note(log, rs.fmtFormat(["by ref ", args44[0]])); + const part23 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(26)]), rs.drop), rs.lent(borrowed)), rs.u32Add, 0, true); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part23, f)]; + Log.note(log, rs.fmtFormat(["twice ", args46[0]])); + const part24 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(27)]), rs.drop), rs.lent(f2)), rs.u32Add, 0, true); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part24, f)]; + Log.note(log, rs.fmtFormat(["boxed ", args48[0]])); const captured22 = guard(28); - let h2: (a0: Guard.Guard) => rt.u32 = rt.closure((g3: Guard.Guard): rt.u32 => { - const _022: rt.u32 = rt.u32Add(Guard.id(g3), Guard.id(captured22)); + let h2: (a0: Guard.Guard) => rs.u32 = rs.closure((g3: Guard.Guard): rs.u32 => { + const _022: rs.u32 = rs.u32Add(Guard.id(g3), Guard.id(captured22)); g3[Symbol.dispose](); return _022; }, (): void => { captured22[Symbol.dispose](); }); - const part25 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([guard(29)]), rt.drop), rt.lent(rt.place(() => h2, (value6) => h2 = value6).v)), rt.u32Add, 0, true); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part25, f)]; - Log.note(log, rt.fmtFormat(["mut ", args50[0]])); - let p2: (a0: rt.u32) => rt.u32 = (a0: rt.u32): rt.u32 => { + const part25 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([guard(29)]), rs.drop), rs.lent(rs.place(() => h2, (value6) => h2 = value6).v)), rs.u32Add, 0, true); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part25, f)]; + Log.note(log, rs.fmtFormat(["mut ", args50[0]])); + let p2: (a0: rs.u32) => rs.u32 = (a0: rs.u32): rs.u32 => { return a0; }; - const part26 = rt.iterSum(rt.iterMap(rt.vecIntoIter(rt.vecFrom([1, 2])), rt.place(() => p2, (value7) => p2 = value7).v), rt.u32Add, 0); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part26, f)]; - Log.note(log, rt.fmtFormat(["pointer ", args52[0]])); + const part26 = rs.iterSum(rs.iterMap(rs.vecIntoIter(rs.vecFrom([1, 2])), rs.place(() => p2, (value7) => p2 = value7).v), rs.u32Add, 0); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part26, f)]; + Log.note(log, rs.fmtFormat(["pointer ", args52[0]])); const part27 = guard(25); const part28 = f2(part27); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part28, f)]; - Log.note(log, rt.fmtFormat(["kept ", args54[0]])); - rt.drop(h2); - rt.drop(f2); - rt.drop(slot); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part28, f)]; + Log.note(log, rs.fmtFormat(["kept ", args54[0]])); + rs.drop(h2); + rs.drop(f2); + rs.drop(slot); } /** Call `f` once, which consumes it. */ -export function run$boxed_Box_drops_objects_fns_closure22(f: () => rt.u32): rt.u32 { - return rt.callOnce(f); +export function run$boxed_Box_drops_objects_fns_closure22(f: () => rs.u32): rs.u32 { + return rs.callOnce(f); } /** Call `f` once, which consumes it. */ -export function run$boxed_Box_dyn_ops_Fn_unit_u32(f: () => rt.u32): rt.u32 { - return rt.callOnce(f); +export function run$boxed_Box_dyn_ops_Fn_unit_u32(f: () => rs.u32): rs.u32 { + return rs.callOnce(f); } //# sourceMappingURL=objects.ts.map diff --git a/ts/fixtures/task/expected/drops/once.Cached.ts b/ts/fixtures/task/expected/drops/once.Cached.ts index b5a139010..f6f5948d7 100644 --- a/ts/fixtures/task/expected/drops/once.Cached.ts +++ b/ts/fixtures/task/expected/drops/once.Cached.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_drops_Held as lib_drop$Option_drops_Held } from "../lib.ts"; import type * as Held from "../drops.Held.ts"; import type * as Guard from "../model.Guard.ts"; /** A struct holding a cell, as moq's caches do. */ export class Cached { - sweep: rt.OnceLock; + sweep: rs.OnceLock; guard: Guard.Guard; - constructor(sweep: rt.OnceLock, guard: Guard.Guard) { + constructor(sweep: rs.OnceLock, guard: Guard.Guard) { this.sweep = sweep; this.guard = guard; } diff --git a/ts/fixtures/task/expected/drops/once.ts b/ts/fixtures/task/expected/drops/once.ts index 357d662bd..8a678c2d0 100644 --- a/ts/fixtures/task/expected/drops/once.ts +++ b/ts/fixtures/task/expected/drops/once.ts @@ -1,89 +1,89 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$Option_drops_Held as lib_drop$Option_drops_Held, drop$Result_unit_Option_model_Guard as lib_drop$Result_unit_Option_model_Guard, drop$Result_unit_drops_Held as lib_drop$Result_unit_drops_Held, drop$Result_unit_model_Guard as lib_drop$Result_unit_model_Guard } from "../lib.ts"; -import { mapOr$01ozsk3 as option_mapOr$01ozsk3 } from "../core/option.ts"; +import { mapOr$1re20rq as option_mapOr$1re20rq } from "../core/option.ts"; import * as Cached from "../drops/once.Cached.ts"; import type * as Held from "../drops.Held.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 6`: what each cell drops, where Rust drops it, and in Rust's order. */ -export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function run(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const _6: rt.u8 = rt.u8Rem(arg, 6); + const _6: rs.u8 = rs.u8Rem(arg, 6); if (_6 === 0) { - const cell: rt.OnceCell = new rt.OnceCell(undefined); + const cell: rs.OnceCell = new rs.OnceCell(undefined); const _19: Guard.Guard = guard(1); - const _17: rt.Result = rt.onceSet(cell, _19); + const _17: rs.Result = rs.onceSet(cell, _19); const part13 = _17.ok; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part13, f)]; - const _11: string = rt.fmtFormat(["set ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part13, f)]; + const _11: string = rs.fmtFormat(["set ", args2[0]]); lib_drop$Result_unit_model_Guard(_17); Log.note(log, _11); const _28: Guard.Guard = guard(2); - const refused: rt.Result = rt.onceSet(cell, _28); + const refused: rs.Result = rs.onceSet(cell, _28); const part14 = !refused.ok; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part14, f)]; - Log.note(log, rt.fmtFormat(["refused ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part14, f)]; + Log.note(log, rs.fmtFormat(["refused ", args4[0]])); lib_drop$Result_unit_model_Guard(refused); - const part15 = option_mapOr$01ozsk3(cell.v, 0, (g2: Guard.Guard): rt.u32 => { - return rt.u32Sub(Guard.id(g2), id); + const part15 = option_mapOr$1re20rq(cell.v, 0, (g2: Guard.Guard): rs.u32 => { + return rs.u32Sub(Guard.id(g2), id); }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part15, f)]; - Log.note(log, rt.fmtFormat(["held ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part15, f)]; + Log.note(log, rs.fmtFormat(["held ", args6[0]])); cell[Symbol.dispose](); - const lock: rt.OnceLock = new rt.OnceLock({ tag: "Two", _0: guard(3), _1: guard(4) } as Held.Held); + const lock: rs.OnceLock = new rs.OnceLock({ tag: "Two", _0: guard(3), _1: guard(4) } as Held.Held); const _71 = { tag: "One", _0: guard(5) } as Held.Held; - lib_drop$Result_unit_drops_Held(rt.onceSet(lock, _71)); + lib_drop$Result_unit_drops_Held(rs.onceSet(lock, _71)); const part16 = lock.v !== undefined; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part16, f)]; - Log.note(log, rt.fmtFormat(["kept ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part16, f)]; + Log.note(log, rs.fmtFormat(["kept ", args8[0]])); lib_drop$Option_drops_Held(lock.v); } else if (_6 === 1) { - const cell2: rt.OnceLock = new rt.OnceLock(undefined); + const cell2: rs.OnceLock = new rs.OnceLock(undefined); const captured3 = guard(11); const captured4 = guard; - const part11 = rt.u32Sub(Guard.id(rt.onceGetOrInit(cell2, rt.closure((): Guard.Guard => { + const part11 = rs.u32Sub(Guard.id(rs.onceGetOrInit(cell2, rs.closure((): Guard.Guard => { Guard.note(captured3, "init"); const _05: Guard.Guard = captured4(12); captured3[Symbol.dispose](); return _05; }, (): void => { captured3[Symbol.dispose](); - }), rt.drop)), id); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part11, f)]; - Log.note(log, rt.fmtFormat(["made ", args10[0]])); + }), rs.drop)), id); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; + Log.note(log, rs.fmtFormat(["made ", args10[0]])); const captured5 = guard(13); const captured6 = guard; - const part12 = rt.u32Sub(Guard.id(rt.onceGetOrInit(cell2, rt.closure((): Guard.Guard => { + const part12 = rs.u32Sub(Guard.id(rs.onceGetOrInit(cell2, rs.closure((): Guard.Guard => { Guard.note(captured5, "init"); const _06: Guard.Guard = captured6(14); captured5[Symbol.dispose](); return _06; }, (): void => { captured5[Symbol.dispose](); - }), rt.drop)), id); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part12, f)]; - Log.note(log, rt.fmtFormat(["kept ", args12[0]])); - const other: rt.OnceCell = new rt.OnceCell(undefined); + }), rs.drop)), id); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part12, f)]; + Log.note(log, rs.fmtFormat(["kept ", args12[0]])); + const other: rs.OnceCell = new rs.OnceCell(undefined); const captured7 = guard(15); const captured8 = guard; - rt.onceGetOrInit(other, rt.closure((): Held.Held => { + rs.onceGetOrInit(other, rs.closure((): Held.Held => { return { tag: "Two", _0: captured7, _1: captured8(16) } as Held.Held; }, (): void => { captured7[Symbol.dispose](); - }), rt.drop); + }), rs.drop); lib_drop$Option_drops_Held(other.v); - const fresh: rt.OnceCell = new rt.OnceCell(undefined); + const fresh: rs.OnceCell = new rs.OnceCell(undefined); const _140: [Guard.Guard, Guard.Guard] = [guard(17), guard(18)]; const first: Guard.Guard = _140[0]; const second: Guard.Guard = _140[1]; const captured9 = first; const captured10 = guard; - const first2: () => Guard.Guard = rt.closure((): Guard.Guard => { + const first2: () => Guard.Guard = rs.closure((): Guard.Guard => { Guard.note(captured9, "init"); return captured10(19); }, (): void => { @@ -91,109 +91,109 @@ export function run(log: Log.Log, id: rt.u32, arg: rt.u8): void { }); const captured11 = second; const captured12 = guard; - const second2: () => Guard.Guard = rt.closure((): Guard.Guard => { + const second2: () => Guard.Guard = rs.closure((): Guard.Guard => { Guard.note(captured11, "init"); return captured12(20); }, (): void => { captured11[Symbol.dispose](); }); - const made2: rt.u32 = rt.u32Sub(Guard.id(rt.onceGetOrInit(fresh, rt.once(first2), rt.drop)), id); - const _160: rt.u32 = rt.u32Sub(Guard.id(rt.onceGetOrInit(fresh, rt.once(second2), rt.drop)), id); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(made2, f), (f: rt.Formatter) => rt.u32Display(_160, f)]; - Log.note(log, rt.fmtFormat(["by ref ", args14[0], " ", args14[1]])); + const made2: rs.u32 = rs.u32Sub(Guard.id(rs.onceGetOrInit(fresh, rs.once(first2), rs.drop)), id); + const _160: rs.u32 = rs.u32Sub(Guard.id(rs.onceGetOrInit(fresh, rs.once(second2), rs.drop)), id); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(made2, f), (f: rs.Formatter) => rs.u32Display(_160, f)]; + Log.note(log, rs.fmtFormat(["by ref ", args14[0], " ", args14[1]])); fresh[Symbol.dispose](); cell2[Symbol.dispose](); } else if (_6 === 2) { - const cell3: rt.OnceCell = new rt.OnceCell(guard(21)); - const taken: Guard.Guard | undefined = rt.onceTake(cell3); + const cell3: rs.OnceCell = new rs.OnceCell(guard(21)); + const taken: Guard.Guard | undefined = rs.onceTake(cell3); const part8 = taken !== undefined; - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part8, f)]; - Log.note(log, rt.fmtFormat(["taken ", args16[0]])); - rt.drop(taken); - const _198: Guard.Guard | undefined = rt.onceTake(cell3); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part8, f)]; + Log.note(log, rs.fmtFormat(["taken ", args16[0]])); + rs.drop(taken); + const _198: Guard.Guard | undefined = rs.onceTake(cell3); const part9 = _198 === undefined; - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part9, f)]; - const _192: string = rt.fmtFormat(["empty ", args18[0]]); - rt.drop(_198); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part9, f)]; + const _192: string = rs.fmtFormat(["empty ", args18[0]]); + rs.drop(_198); Log.note(log, _192); const _206: Guard.Guard = guard(22); - lib_drop$Result_unit_model_Guard(rt.onceSet(cell3, _206)); - rt.drop(new rt.OnceLock(guard(23)).v); - const part10 = option_mapOr$01ozsk3(cell3.v, 0, (g: Guard.Guard): rt.u32 => { - const _04: rt.u32 = rt.u32Sub(Guard.id(g), id); + lib_drop$Result_unit_model_Guard(rs.onceSet(cell3, _206)); + rs.drop(new rs.OnceLock(guard(23)).v); + const part10 = option_mapOr$1re20rq(cell3.v, 0, (g: Guard.Guard): rs.u32 => { + const _04: rs.u32 = rs.u32Sub(Guard.id(g), id); g[Symbol.dispose](); return _04; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; - Log.note(log, rt.fmtFormat(["inner ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; + Log.note(log, rs.fmtFormat(["inner ", args20[0]])); } else if (_6 === 3) { - const cell4: rt.OnceCell = new rt.OnceCell(undefined); + const cell4: rs.OnceCell = new rs.OnceCell(undefined); const owned3: Guard.Guard = guard(31); const captured = guard; const captured2 = owned3; - rt.onceGetOrInit(cell4, rt.closure((): Guard.Guard => { - lib_drop$Result_unit_model_Guard(rt.onceSet(cell4, captured(32))); + rs.onceGetOrInit(cell4, rs.closure((): Guard.Guard => { + lib_drop$Result_unit_model_Guard(rs.onceSet(cell4, captured(32))); Guard.note(captured2, "init"); const _03: Guard.Guard = captured(33); captured2[Symbol.dispose](); return _03; }, (): void => { captured2[Symbol.dispose](); - }), rt.drop); + }), rs.drop); cell4[Symbol.dispose](); } else if (_6 === 4) { - const shared: rt.Arc = new rt.Arc(new Cached.Cached(new rt.OnceLock(undefined), guard(61))); - const other2: rt.Arc = rt.arcClone(shared); - rt.onceGetOrInit(shared.value.sweep, (): Held.Held => { + const shared: rs.Arc = new rs.Arc(new Cached.Cached(new rs.OnceLock(undefined), guard(61))); + const other2: rs.Arc = rs.arcClone(shared); + rs.onceGetOrInit(shared.value.sweep, (): Held.Held => { return { tag: "One", _0: guard(62) } as Held.Held; }); shared[Symbol.dispose](); const part6 = other2.value.sweep.v !== undefined; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part6, f)]; - Log.note(log, rt.fmtFormat(["swept ", args22[0]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part6, f)]; + Log.note(log, rs.fmtFormat(["swept ", args22[0]])); other2[Symbol.dispose](); - const v: rt.Vec> = new rt.Vec(); - const _274: rt.OnceCell = new rt.OnceCell(guard(63)); + const v: rs.Vec> = new rs.Vec(); + const _274: rs.OnceCell = new rs.OnceCell(guard(63)); v.items.push(_274); - const _280: rt.OnceCell = new rt.OnceCell(undefined); + const _280: rs.OnceCell = new rs.OnceCell(undefined); v.items.push(_280); - const _283: rt.OnceCell = new rt.OnceCell(guard(64)); + const _283: rs.OnceCell = new rs.OnceCell(guard(64)); v.items.push(_283); - const cells: rt.Vec> = v; + const cells: rs.Vec> = v; const part7 = cells.items.length; - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part7, f)]; - Log.note(log, rt.fmtFormat(["cells ", args24[0]])); - rt.dropVec(cells); - rt.drop(new rt.OnceLock(guard(65))); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part7, f)]; + Log.note(log, rs.fmtFormat(["cells ", args24[0]])); + rs.dropVec(cells); + rs.drop(new rs.OnceLock(guard(65))); } else { - const cell5: rt.OnceCell = new rt.OnceCell(rt.None); - const _315: rt.Result = rt.onceSet(cell5, undefined as Guard.Guard | undefined, rt.None); + const cell5: rs.OnceCell = new rs.OnceCell(rs.None); + const _315: rs.Result = rs.onceSet(cell5, undefined as Guard.Guard | undefined, rs.None); const part = _315.ok; - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part, f)]; - const _309: string = rt.fmtFormat(["none ", args26[0]]); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part, f)]; + const _309: string = rs.fmtFormat(["none ", args26[0]]); lib_drop$Result_unit_Option_model_Guard(_315); Log.note(log, _309); const _332: Guard.Guard | undefined = guard(71); - const _330: rt.Result = rt.onceSet(cell5, _332, rt.None); + const _330: rs.Result = rs.onceSet(cell5, _332, rs.None); const part2 = !_330.ok; - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part2, f)]; - const _324: string = rt.fmtFormat(["full ", args28[0]]); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part2, f)]; + const _324: string = rs.fmtFormat(["full ", args28[0]]); lib_drop$Result_unit_Option_model_Guard(_330); Log.note(log, _324); - const unit: rt.OnceLock = new rt.OnceLock(rt.None); - const part3 = rt.onceSet(unit, undefined, rt.None).ok; - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - Log.note(log, rt.fmtFormat(["unit ", args30[0]])); - const part4 = !rt.onceSet(unit, undefined, rt.None).ok; - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; - Log.note(log, rt.fmtFormat(["again ", args32[0]])); - const part5 = cell5.v !== rt.None; - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; - Log.note(log, rt.fmtFormat(["got ", args34[0]])); + const unit: rs.OnceLock = new rs.OnceLock(rs.None); + const part3 = rs.onceSet(unit, undefined, rs.None).ok; + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + Log.note(log, rs.fmtFormat(["unit ", args30[0]])); + const part4 = !rs.onceSet(unit, undefined, rs.None).ok; + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; + Log.note(log, rs.fmtFormat(["again ", args32[0]])); + const part5 = cell5.v !== rs.None; + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; + Log.note(log, rs.fmtFormat(["got ", args34[0]])); cell5[Symbol.dispose](); } - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(id, f)]; - Log.note(log, rt.fmtFormat(["d", args36[0], " cells done"])); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(id, f)]; + Log.note(log, rs.fmtFormat(["d", args36[0], " cells done"])); } //# sourceMappingURL=once.ts.map diff --git a/ts/fixtures/task/expected/drops/orders.Rank.ts b/ts/fixtures/task/expected/drops/orders.Rank.ts index e468194b2..1c7323628 100644 --- a/ts/fixtures/task/expected/drops/orders.Rank.ts +++ b/ts/fixtures/task/expected/drops/orders.Rank.ts @@ -1,18 +1,18 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; /** A key that copies, so a `Cell` of it orders by it, by its own `Ord` modulo 4. */ export interface Rank { - _0: rt.u8; + _0: rs.u8; } export function eq$cmp_PartialEq(self: Rank, other: Rank): boolean { - return rt.u8Rem(self._0, 4) === rt.u8Rem(other._0, 4); + return rs.u8Rem(self._0, 4) === rs.u8Rem(other._0, 4); } -export function cmp$cmp_Ord(self: Rank, other: Rank): rt.Ordering { - return rt.cmp(rt.u8Rem(self._0, 4), rt.u8Rem(other._0, 4)); +export function cmp$cmp_Ord(self: Rank, other: Rank): rs.Ordering { + return rs.cmp(rs.u8Rem(self._0, 4), rs.u8Rem(other._0, 4)); } //# sourceMappingURL=orders.Rank.ts.map diff --git a/ts/fixtures/task/expected/drops/orders.Ranked.ts b/ts/fixtures/task/expected/drops/orders.Ranked.ts index 2dd91976d..040b52238 100644 --- a/ts/fixtures/task/expected/drops/orders.Ranked.ts +++ b/ts/fixtures/task/expected/drops/orders.Ranked.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Log from "../log.Log.ts"; /** @@ -8,11 +8,11 @@ import * as Log from "../log.Log.ts"; * `partial_cmp` by half of it, and `eq` by it modulo 3. `cmp` panics of a rank of 99. */ export class Ranked { - id: rt.u32; - rank: rt.u8; + id: rs.u32; + rank: rs.u8; log: Log.Log; - constructor(id: rt.u32, rank: rt.u8, log: Log.Log) { + constructor(id: rs.u32, rank: rs.u8, log: Log.Log) { this.id = id; this.rank = rank; this.log = log; @@ -26,48 +26,48 @@ export class Ranked { export function drop$ops_Drop(self: Ranked): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["k", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["k", args2[0], " drop"]); Log.note(self.log, _4); } export function eq$cmp_PartialEq(self: Ranked, other: Ranked): boolean { const arg = self.id; - const _12: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg, f); + const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rt.Fmt[] = [_12, (f: rt.Formatter) => rt.u32Display(arg2, f)]; - const _5: string = rt.fmtFormat(["eq ", args2[0], " ", args2[1]]); + const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["eq ", args2[0], " ", args2[1]]); Log.note(self.log, _5); - return rt.u8Rem(self.rank, 3) === rt.u8Rem(other.rank, 3); + return rs.u8Rem(self.rank, 3) === rs.u8Rem(other.rank, 3); } -export function partialCmp$cmp_PartialOrd(self: Ranked, other: Ranked): rt.Ordering | undefined { +export function partialCmp$cmp_PartialOrd(self: Ranked, other: Ranked): rs.Ordering | undefined { const arg = self.id; - const _12: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg, f); + const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rt.Fmt[] = [_12, (f: rt.Formatter) => rt.u32Display(arg2, f)]; - const _5: string = rt.fmtFormat(["partial_cmp ", args2[0], " ", args2[1]]); + const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["partial_cmp ", args2[0], " ", args2[1]]); Log.note(self.log, _5); - return rt.cmp(rt.u8Div(self.rank, 2), rt.u8Div(other.rank, 2)); + return rs.cmp(rs.u8Div(self.rank, 2), rs.u8Div(other.rank, 2)); } -export function cmp$cmp_Ord(self: Ranked, other: Ranked): rt.Ordering { +export function cmp$cmp_Ord(self: Ranked, other: Ranked): rs.Ordering { const arg = self.id; - const _12: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg, f); + const _12: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg, f); const arg2 = other.id; - const args2: rt.Fmt[] = [_12, (f: rt.Formatter) => rt.u32Display(arg2, f)]; - const _5: string = rt.fmtFormat(["cmp ", args2[0], " ", args2[1]]); + const args2: rs.Fmt[] = [_12, (f: rs.Formatter) => rs.u32Display(arg2, f)]; + const _5: string = rs.fmtFormat(["cmp ", args2[0], " ", args2[1]]); Log.note(self.log, _5); if (self.rank !== 99) { if (other.rank !== 99) { - return rt.cmp(self.rank, other.rank); + return rs.cmp(self.rank, other.rank); } } const arg3 = self.id; - const _26: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg3, f); + const _26: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = other.id; - const args4: rt.Fmt[] = [_26, (f: rt.Formatter) => rt.u32Display(arg4, f)]; - rt.panicFmt(["cmp of k", args4[0], " with k", args4[1]]); + const args4: rs.Fmt[] = [_26, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + rs.panicFmt(["cmp of k", args4[0], " with k", args4[1]]); } //# sourceMappingURL=orders.Ranked.ts.map diff --git a/ts/fixtures/task/expected/drops/orders.ts b/ts/fixtures/task/expected/drops/orders.ts index 3a47603d4..8e8a5ee99 100644 --- a/ts/fixtures/task/expected/drops/orders.ts +++ b/ts/fixtures/task/expected/drops/orders.ts @@ -1,193 +1,193 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import { drop$tuple2_drops_orders_Ranked_model_Guard as lib_drop$tuple2_drops_orders_Ranked_model_Guard } from "../lib.ts"; -import { map$1t2fqxi as option_map$1t2fqxi, map$1raha9y as option_map$1raha9y } from "../core/option.ts"; +import { map$16oph0b as option_map$16oph0b, map$06w9waf as option_map$06w9waf } from "../core/option.ts"; import * as Rank from "../drops/orders.Rank.ts"; import * as Ranked from "../drops/orders.Ranked.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 8`. The last panics in the sort, which aborts before anything drops. */ -export function orders(log: Log.Log, id: rt.u32, arg: rt.u8): void { - const key: (a0: rt.u32, a1: rt.u8) => Ranked.Ranked = (n: rt.u32, rank: rt.u8): Ranked.Ranked => { - return new Ranked.Ranked(rt.u32Add(id, n), rank, Log.clone$Clone(log)); +export function orders(log: Log.Log, id: rs.u32, arg: rs.u8): void { + const key: (a0: rs.u32, a1: rs.u8) => Ranked.Ranked = (n: rs.u32, rank: rs.u8): Ranked.Ranked => { + return new Ranked.Ranked(rs.u32Add(id, n), rank, Log.clone$Clone(log)); }; - const entry: (a0: rt.u32, a1: rt.u8) => [Ranked.Ranked, Guard.Guard] = (n2: rt.u32, rank2: rt.u8): [Ranked.Ranked, Guard.Guard] => { - return [key(n2, rank2), Guard.new(rt.u32Add(rt.u32Add(id, n2), 100), Log.clone$Clone(log))] as [Ranked.Ranked, Guard.Guard]; + const entry: (a0: rs.u32, a1: rs.u8) => [Ranked.Ranked, Guard.Guard] = (n2: rs.u32, rank2: rs.u8): [Ranked.Ranked, Guard.Guard] => { + return [key(n2, rank2), Guard.new(rs.u32Add(rs.u32Add(id, n2), 100), Log.clone$Clone(log))] as [Ranked.Ranked, Guard.Guard]; }; - const keys: (a0: rt.ByteSlice) => rt.Vec = (ranks: rt.ByteSlice): rt.Vec => { - return rt.iterToVec(rt.iterMap(rt.iterZip(new rt.RangeFrom(1, rt.u32Step), rt.iterSlice(rt.byteSliceView(ranks)), "len"), (_2: [rt.u32, rt.u8]): Ranked.Ranked => { + const keys: (a0: rs.ByteSlice) => rs.Vec = (ranks: rs.ByteSlice): rs.Vec => { + return rs.iterToVec(rs.iterMap(rs.iterZip(new rs.RangeFrom(1, rs.u32Step), rs.iterSlice(rs.byteSliceView(ranks)), "len"), (_2: [rs.u32, rs.u8]): Ranked.Ranked => { return key(_2[0], _2[1]); }), undefined, 12, true); }; - const entries: (a0: rt.ByteSlice) => rt.Vec<[Ranked.Ranked, Guard.Guard]> = (ranks2: rt.ByteSlice): rt.Vec<[Ranked.Ranked, Guard.Guard]> => { - return rt.iterToVec(rt.iterMap(rt.iterZip(new rt.RangeFrom(1, rt.u32Step), rt.iterSlice(rt.byteSliceView(ranks2)), "len"), (_23: [rt.u32, rt.u8]): [Ranked.Ranked, Guard.Guard] => { + const entries: (a0: rs.ByteSlice) => rs.Vec<[Ranked.Ranked, Guard.Guard]> = (ranks2: rs.ByteSlice): rs.Vec<[Ranked.Ranked, Guard.Guard]> => { + return rs.iterToVec(rs.iterMap(rs.iterZip(new rs.RangeFrom(1, rs.u32Step), rs.iterSlice(rs.byteSliceView(ranks2)), "len"), (_23: [rs.u32, rs.u8]): [Ranked.Ranked, Guard.Guard] => { return entry(_23[0], _23[1]); }), undefined, 20, true); }; - const setIds: (a0: rt.BTreeSet) => string = (s: rt.BTreeSet): string => { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.btreeKeys(s), (k: Ranked.Ranked): string => { - const _48: rt.u32 = rt.u32Sub(k.id, id); - return rt.fmtToString((f: rt.Formatter) => rt.u32Display(_48, f)); + const setIds: (a0: rs.BTreeSet) => string = (s: rs.BTreeSet): string => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeKeys(s), (k: Ranked.Ranked): string => { + const _48: rs.u32 = rs.u32Sub(k.id, id); + return rs.fmtToString((f: rs.Formatter) => rs.u32Display(_48, f)); }), undefined, 12, true).items, ","); }; - const mapIds: (a0: rt.BTreeMap) => string = (m: rt.BTreeMap): string => { - return rt.strsJoin(rt.iterToVec(rt.iterMap(rt.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): string => { - const _97: rt.u32 = rt.u32Sub(_26[0].id, id); - const _144: rt.u32 = rt.u32Sub(Guard.id(_26[1]), id); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_97, f), (f: rt.Formatter) => rt.u32Display(_144, f)]; - return rt.fmtFormat([args32[0], ":", args32[1]]); + const mapIds: (a0: rs.BTreeMap) => string = (m: rs.BTreeMap): string => { + return rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(m), (_26: [Ranked.Ranked, Guard.Guard]): string => { + const _97: rs.u32 = rs.u32Sub(_26[0].id, id); + const _144: rs.u32 = rs.u32Sub(Guard.id(_26[1]), id); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_97, f), (f: rs.Formatter) => rs.u32Display(_144, f)]; + return rs.fmtFormat([args32[0], ":", args32[1]]); }), undefined, 12, true).items, ","); }; const short: Uint8Array = Uint8Array.of(3, 1, 3, 2, 1, 5, 4, 0); - const long: rt.ByteVec = rt.iterToByteVec(rt.iterMap(new rt.Range(0, 26), (n5: rt.u8): rt.u8 => { - return rt.u8Rem(rt.u8Mul(n5, 7), 9); + const long: rs.ByteVec = rs.iterToByteVec(rs.iterMap(new rs.Range(0, 26), (n5: rs.u8): rs.u8 => { + return rs.u8Rem(rs.u8Mul(n5, 7), 9); }), undefined, true); - const _21: rt.u8 = rt.u8Rem(arg, 8); + const _21: rs.u8 = rs.u8Rem(arg, 8); if (_21 === 0) { - const part29 = rt.byteSliceFrom(short); - const _24: rt.Iter = rt.vecIntoIter(keys(part29), rt.drop); - const set: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_24, "next", 12, true, 12).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop); + const part29 = rs.byteSliceFrom(short); + const _24: rs.Iter = rs.vecIntoIter(keys(part29), rs.drop); + const set: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_24, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part31 = setIds(set); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part31)]; - Log.note(log, rt.fmtFormat(["set ", args2[0]])); - rt.btreeDrop(set, rt.drop); - const _46: rt.Iter = rt.vecIntoIter(keys(rt.byteSliceFrom(Uint8Array.of())), rt.drop); - const none: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_46, "next", 12, true, 12).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop); - const _53: rt.Iter = rt.vecIntoIter(keys(rt.byteSliceFrom(Uint8Array.of(7))), rt.drop); - const one: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_53, "next", 12, true, 12).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop); - const _65: rt.usize = rt.btreeLen(none); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part31)]; + Log.note(log, rs.fmtFormat(["set ", args2[0]])); + rs.btreeDrop(set, rs.drop); + const _46: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of())), rs.drop); + const none: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_46, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); + const _53: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of(7))), rs.drop); + const one: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_53, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); + const _65: rs.usize = rs.btreeLen(none); const _68: string = setIds(one); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(_65, f), (f: rt.Formatter) => rt.fmtPad(f, _68)]; - Log.note(log, rt.fmtFormat(["small ", args4[0], " ", args4[1]])); - rt.btreeDrop(one, rt.drop); - rt.btreeDrop(none, rt.drop); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(_65, f), (f: rs.Formatter) => rs.fmtPad(f, _68)]; + Log.note(log, rs.fmtFormat(["small ", args4[0], " ", args4[1]])); + rs.btreeDrop(one, rs.drop); + rs.btreeDrop(none, rs.drop); } else if (_21 === 1) { - const part26 = rt.byteSliceFrom(short); - const _78: rt.Iter<[Ranked.Ranked, Guard.Guard]> = rt.vecIntoIter(entries(part26), lib_drop$tuple2_drops_orders_Ranked_model_Guard); - const map: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_78, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rt.drop, rt.drop); + const part26 = rs.byteSliceFrom(short); + const _78: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part26), lib_drop$tuple2_drops_orders_Ranked_model_Guard); + const map: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_78, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part28 = mapIds(map); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part28)]; - Log.note(log, rt.fmtFormat(["map ", args6[0]])); - rt.btreeDrop(map, rt.drop, rt.drop); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part28)]; + Log.note(log, rs.fmtFormat(["map ", args6[0]])); + rs.btreeDrop(map, rs.drop, rs.drop); } else if (_21 === 2) { const _99: Ranked.Ranked[] = [key(1, 4), key(2, 2), key(3, 4), key(4, 1), key(5, 2)]; - const set2: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(rt.iterSlice(_99, rt.drop), "fold", 12, true).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop); + const set2: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(rs.iterSlice(_99, rs.drop), "fold", 12, true).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part23 = setIds(set2); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part23)]; - Log.note(log, rt.fmtFormat(["set ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part23)]; + Log.note(log, rs.fmtFormat(["set ", args8[0]])); const _130: [Ranked.Ranked, Guard.Guard][] = [entry(1, 4), entry(2, 2), entry(3, 4), entry(4, 1), entry(5, 2)]; - const map2: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(rt.iterSlice(_130, lib_drop$tuple2_drops_orders_Ranked_model_Guard), "fold", 20, true).items, 20, true, Ranked.eq$cmp_PartialEq, rt.drop, rt.drop); + const map2: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(rs.iterSlice(_130, lib_drop$tuple2_drops_orders_Ranked_model_Guard), "fold", 20, true).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part25 = mapIds(map2); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part25)]; - Log.note(log, rt.fmtFormat(["map ", args10[0]])); - rt.btreeDrop(map2, rt.drop, rt.drop); - rt.btreeDrop(set2, rt.drop); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part25)]; + Log.note(log, rs.fmtFormat(["map ", args10[0]])); + rs.btreeDrop(map2, rs.drop, rs.drop); + rs.btreeDrop(set2, rs.drop); } else if (_21 === 3) { - const part16 = rt.byteVecSlice(long); - const _161: rt.Iter = rt.vecIntoIter(keys(part16), rt.drop); - const set3: rt.BTreeSet = rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_161, "next", 12, true, 12).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop); + const part16 = rs.byteVecSlice(long); + const _161: rs.Iter = rs.vecIntoIter(keys(part16), rs.drop); + const set3: rs.BTreeSet = rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_161, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop); const part18 = setIds(set3); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part18)]; - Log.note(log, rt.fmtFormat(["set ", args12[0]])); - rt.iterForEach(rt.btreeKeys(set3, rt.drop), (a0: Ranked.Ranked): undefined => { + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part18)]; + Log.note(log, rs.fmtFormat(["set ", args12[0]])); + rs.iterForEach(rs.btreeKeys(set3, rs.drop), (a0: Ranked.Ranked): undefined => { a0[Symbol.dispose](); }, true); - const part19 = rt.byteVecSlice(long); - const _184: rt.Iter<[Ranked.Ranked, Guard.Guard]> = rt.vecIntoIter(entries(part19), lib_drop$tuple2_drops_orders_Ranked_model_Guard); - const map3: rt.BTreeMap = rt.btreeCollect(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_184, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rt.drop, rt.drop); + const part19 = rs.byteVecSlice(long); + const _184: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part19), lib_drop$tuple2_drops_orders_Ranked_model_Guard); + const map3: rs.BTreeMap = rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_184, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop); const part21 = mapIds(map3); - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part21)]; - Log.note(log, rt.fmtFormat(["map ", args14[0]])); - rt.iterForEach(rt.btreeIter(map3, rt.drop, rt.drop), (a02: [Ranked.Ranked, Guard.Guard]): undefined => { + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part21)]; + Log.note(log, rs.fmtFormat(["map ", args14[0]])); + rs.iterForEach(rs.btreeIter(map3, rs.drop, rs.drop), (a02: [Ranked.Ranked, Guard.Guard]): undefined => { lib_drop$tuple2_drops_orders_Ranked_model_Guard(a02); }, true); } else if (_21 === 4) { - const _207: rt.Iter<[rt.Cell, Guard.Guard]> = rt.iterMap(rt.iterZip(rt.iterSlice(rt.byteSliceView(rt.byteSliceFrom(Uint8Array.of(5, 1, 9, 2, 6, 3)))), new rt.RangeFrom(1, rt.u32Step), "len"), (_217: [rt.u8, rt.u32]): [rt.Cell, Guard.Guard] => { - const r: rt.u8 = _217[0]; - const n9: rt.u32 = _217[1]; - return [new rt.Cell({ _0: r }), Guard.new(rt.u32Add(id, n9), Log.clone$Clone(log))] as [rt.Cell, Guard.Guard]; + const _207: rs.Iter<[rs.Cell, Guard.Guard]> = rs.iterMap(rs.iterZip(rs.iterSlice(rs.byteSliceView(rs.byteSliceFrom(Uint8Array.of(5, 1, 9, 2, 6, 3)))), new rs.RangeFrom(1, rs.u32Step), "len"), (_217: [rs.u8, rs.u32]): [rs.Cell, Guard.Guard] => { + const r: rs.u8 = _217[0]; + const n9: rs.u32 = _217[1]; + return [new rs.Cell({ _0: r }), Guard.new(rs.u32Add(id, n9), Log.clone$Clone(log))] as [rs.Cell, Guard.Guard]; }); - const map4: rt.BTreeMap, Guard.Guard> = rt.btreeCollect(rt.btreeNew(rt.cellBy(Rank.cmp$cmp_Ord)) as rt.BTreeMap, Guard.Guard>, rt.iterToVec(_207, undefined, 12, true).items, 12, false, rt.cellBy(Rank.eq$cmp_PartialEq), undefined, rt.drop); - const part15 = rt.strsJoin(rt.iterToVec(rt.iterMap(rt.btreeIter(map4), (_219: [rt.Cell, Guard.Guard]): string => { + const map4: rs.BTreeMap, Guard.Guard> = rs.btreeCollect(rs.btreeNew(rs.cellBy(Rank.cmp$cmp_Ord)) as rs.BTreeMap, Guard.Guard>, rs.iterToVec(_207, undefined, 12, true).items, 12, false, rs.cellBy(Rank.eq$cmp_PartialEq), undefined, rs.drop); + const part15 = rs.strsJoin(rs.iterToVec(rs.iterMap(rs.btreeIter(map4), (_219: [rs.Cell, Guard.Guard]): string => { const _912: Rank.Rank = _219[0].v; - const _1111: rt.u32 = rt.u32Sub(Guard.id(_219[1]), id); + const _1111: rs.u32 = rs.u32Sub(Guard.id(_219[1]), id); const arg2 = _912._0; - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u8Display(arg2, f), (f: rt.Formatter) => rt.u32Display(_1111, f)]; - return rt.fmtFormat([args36[0], ":", args36[1]]); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u8Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_1111, f)]; + return rs.fmtFormat([args36[0], ":", args36[1]]); }), undefined, 12, true).items, ","); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part15)]; - Log.note(log, rt.fmtFormat(["cells ", args16[0]])); - rt.btreeDrop(map4, undefined, rt.drop); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part15)]; + Log.note(log, rs.fmtFormat(["cells ", args16[0]])); + rs.btreeDrop(map4, undefined, rs.drop); } else if (_21 === 5) { const by: (a0: Guard.Guard) => Ranked.Ranked = (g: Guard.Guard): Ranked.Ranked => { - const n7: rt.u32 = rt.u32Sub(Guard.id(g), id); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(n7, f)]; - Log.note(log, rt.fmtFormat(["key ", args34[0]])); - return key(rt.u32Add(n7, 50), rt.u8Mul(rt.u32Rem(n7, 3) & 0xff, 2)); + const n7: rs.u32 = rs.u32Sub(Guard.id(g), id); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(n7, f)]; + Log.note(log, rs.fmtFormat(["key ", args34[0]])); + return key(rs.u32Add(n7, 50), rs.u8Mul(rs.u32Rem(n7, 3) & 0xff, 2)); }; - const guards: (a0: rt.u32, a1: rt.u32) => rt.Vec = (from: rt.u32, to: rt.u32): rt.Vec => { - return rt.iterToVec(rt.iterMap(new rt.Range(from, to), (n8: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n8), Log.clone$Clone(log)); + const guards: (a0: rs.u32, a1: rs.u32) => rs.Vec = (from: rs.u32, to: rs.u32): rs.Vec => { + return rs.iterToVec(rs.iterMap(new rs.Range(from, to), (n8: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n8), Log.clone$Clone(log)); }), undefined, 8, true); }; - const part13 = option_map$1raha9y(rt.iterMaxByKey(rt.vecIntoIter(guards(1, 6), rt.drop), by, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rt.drop, undefined, rt.drop), (g2: Guard.Guard): rt.u32 => { - const _018: rt.u32 = rt.u32Sub(Guard.id(g2), id); + const part13 = option_map$06w9waf(rs.iterMaxByKey(rs.vecIntoIter(guards(1, 6), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop), (g2: Guard.Guard): rs.u32 => { + const _018: rs.u32 = rs.u32Sub(Guard.id(g2), id); g2[Symbol.dispose](); return _018; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part13, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["max ", args18[0]])); - const part14 = option_map$1raha9y(rt.iterMinByKey(rt.vecIntoIter(guards(6, 11), rt.drop), by, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rt.drop, undefined, rt.drop), (g3: Guard.Guard): rt.u32 => { - const _019: rt.u32 = rt.u32Sub(Guard.id(g3), id); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part13, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["max ", args18[0]])); + const part14 = option_map$06w9waf(rs.iterMinByKey(rs.vecIntoIter(guards(6, 11), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop), (g3: Guard.Guard): rs.u32 => { + const _019: rs.u32 = rs.u32Sub(Guard.id(g3), id); g3[Symbol.dispose](); return _019; }); - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part14, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["min ", args20[0]])); - const one2: Guard.Guard | undefined = rt.iterMaxByKey(rt.vecIntoIter(guards(11, 12), rt.drop), by, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rt.drop, undefined, rt.drop); - const none2: Guard.Guard | undefined = rt.iterMinByKey(rt.vecIntoIter(guards(12, 12), rt.drop), by, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rt.drop, undefined, rt.drop); - const _292: rt.u32 | undefined = option_map$1raha9y(one2, (g4: Guard.Guard): rt.u32 => { - const _020: rt.u32 = rt.u32Sub(Guard.id(g4), id); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part14, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["min ", args20[0]])); + const one2: Guard.Guard | undefined = rs.iterMaxByKey(rs.vecIntoIter(guards(11, 12), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop); + const none2: Guard.Guard | undefined = rs.iterMinByKey(rs.vecIntoIter(guards(12, 12), rs.drop), by, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), true, rs.drop, undefined, rs.drop); + const _292: rs.u32 | undefined = option_map$06w9waf(one2, (g4: Guard.Guard): rs.u32 => { + const _020: rs.u32 = rs.u32Sub(Guard.id(g4), id); g4[Symbol.dispose](); return _020; }); const _296: boolean = none2 === undefined; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_292, f, rt.u32Debug), (f: rt.Formatter) => rt.fmtBool(_296, f)]; - Log.note(log, rt.fmtFormat(["one ", args22[0], " ", args22[1]])); - rt.drop(none2); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_292, f, rs.u32Debug), (f: rs.Formatter) => rs.fmtBool(_296, f)]; + Log.note(log, rs.fmtFormat(["one ", args22[0], " ", args22[1]])); + rs.drop(none2); } else if (_21 === 6) { - const part5 = rt.byteSliceFrom(short); - const _304: rt.Iter<[Ranked.Ranked, Guard.Guard]> = rt.vecIntoIter(entries(part5), lib_drop$tuple2_drops_orders_Ranked_model_Guard); - const part6 = option_map$1t2fqxi(rt.ownedEnd(rt.btreeKeys(rt.btreeCollect(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_304, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rt.drop, rt.drop), rt.drop, rt.drop, true), true), (k2: Ranked.Ranked): rt.u32 => { - const _012: rt.u32 = rt.u32Sub(k2.id, id); + const part5 = rs.byteSliceFrom(short); + const _304: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part5), lib_drop$tuple2_drops_orders_Ranked_model_Guard); + const part6 = option_map$16oph0b(rs.ownedEnd(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_304, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop), rs.drop, rs.drop, true), true), (k2: Ranked.Ranked): rs.u32 => { + const _012: rs.u32 = rs.u32Sub(k2.id, id); k2[Symbol.dispose](); return _012; }); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["max ", args24[0]])); - const part7 = rt.byteSliceFrom(short); - const _326: rt.Iter<[Ranked.Ranked, Guard.Guard]> = rt.vecIntoIter(entries(part7), lib_drop$tuple2_drops_orders_Ranked_model_Guard); - const part8 = option_map$1t2fqxi(rt.ownedEnd(rt.btreeKeys(rt.btreeCollect(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeMap, rt.iterToVec(_326, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rt.drop, rt.drop), rt.drop, rt.drop, true), false), (k3: Ranked.Ranked): rt.u32 => { - const _013: rt.u32 = rt.u32Sub(k3.id, id); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["max ", args24[0]])); + const part7 = rs.byteSliceFrom(short); + const _326: rs.Iter<[Ranked.Ranked, Guard.Guard]> = rs.vecIntoIter(entries(part7), lib_drop$tuple2_drops_orders_Ranked_model_Guard); + const part8 = option_map$16oph0b(rs.ownedEnd(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeMap, rs.iterToVec(_326, "next", 20, true, 20).items, 20, true, Ranked.eq$cmp_PartialEq, rs.drop, rs.drop), rs.drop, rs.drop, true), false), (k3: Ranked.Ranked): rs.u32 => { + const _013: rs.u32 = rs.u32Sub(k3.id, id); k3[Symbol.dispose](); return _013; }); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part8, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["min ", args26[0]])); - const _348: rt.Iter<[rt.u32, Guard.Guard]> = rt.iterMap(new rt.Range(1, 5), (n6: rt.u32): [rt.u32, Guard.Guard] => { - return [n6, Guard.new(rt.u32Add(rt.u32Add(id, n6), 200), Log.clone$Clone(log))] as [rt.u32, Guard.Guard]; + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part8, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["min ", args26[0]])); + const _348: rs.Iter<[rs.u32, Guard.Guard]> = rs.iterMap(new rs.Range(1, 5), (n6: rs.u32): [rs.u32, Guard.Guard] => { + return [n6, Guard.new(rs.u32Add(rs.u32Add(id, n6), 200), Log.clone$Clone(log))] as [rs.u32, Guard.Guard]; }); - const part9 = rt.ownedEnd(rt.btreeKeys(rt.btreeCollect(rt.btreeNew(rt.cmp) as rt.BTreeMap, rt.iterToVec(_348, undefined, 12, true).items, 12, true, undefined, undefined, rt.drop), undefined, rt.drop, true), true); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part9, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["plain ", args28[0]])); - const part10 = rt.ownedEnd(rt.btreeKeys(rt.btreeNew(rt.cmp) as rt.BTreeMap, undefined, rt.drop, true), false); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part10, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["empty ", args30[0]])); + const part9 = rs.ownedEnd(rs.btreeKeys(rs.btreeCollect(rs.btreeNew(rs.cmp) as rs.BTreeMap, rs.iterToVec(_348, undefined, 12, true).items, 12, true, undefined, undefined, rs.drop), undefined, rs.drop, true), true); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part9, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["plain ", args28[0]])); + const part10 = rs.ownedEnd(rs.btreeKeys(rs.btreeNew(rs.cmp) as rs.BTreeMap, undefined, rs.drop, true), false); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part10, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["empty ", args30[0]])); } else { - const _378: rt.Iter = rt.vecIntoIter(keys(rt.byteSliceFrom(Uint8Array.of(2, 1, 99, 3))), rt.drop); - rt.btreeDrop(rt.btreeCollectKeys(rt.btreeNew(Ranked.cmp$cmp_Ord) as rt.BTreeSet, rt.iterToVec(_378, "next", 12, true, 12).items, 12, true, rt.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rt.drop), rt.drop); + const _378: rs.Iter = rs.vecIntoIter(keys(rs.byteSliceFrom(Uint8Array.of(2, 1, 99, 3))), rs.drop); + rs.btreeDrop(rs.btreeCollectKeys(rs.btreeNew(Ranked.cmp$cmp_Ord) as rs.BTreeSet, rs.iterToVec(_378, "next", 12, true, 12).items, 12, true, rs.cmpLt(Ranked.partialCmp$cmp_PartialOrd), Ranked.eq$cmp_PartialEq, rs.drop), rs.drop); } } diff --git a/ts/fixtures/task/expected/drops/released.ts b/ts/fixtures/task/expected/drops/released.ts index 24e79c382..5d66cda7e 100644 --- a/ts/fixtures/task/expected/drops/released.ts +++ b/ts/fixtures/task/expected/drops/released.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; -import { map$1raha9y as option_map$1raha9y } from "../core/option.ts"; +import * as rs from "../rs.ts"; +import { map$06w9waf as option_map$06w9waf } from "../core/option.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** The guards of `ids`, in order. */ -export function guards(log: Log.Log, id: rt.u32, ids: rt.Range): rt.Vec { - return rt.iterToVec(rt.iterMap(ids, (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); +export function guards(log: Log.Log, id: rs.u32, ids: rs.Range): rs.Vec { + return rs.iterToVec(rs.iterMap(ids, (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }), undefined, 8, true); } @@ -16,27 +16,27 @@ export function guards(log: Log.Log, id: rt.u32, ids: rt.Range): rt.Vec< * Run scenario `arg % 7`. The last panics in a fold, which aborts before anything else * drops. */ -export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function released(log: Log.Log, id: rs.u32, arg: rs.u8): void { let f!: Guard.Guard; - let _430!: rt.u32; - let _564!: rt.u32; - const guard: (a0: rt.u32) => Guard.Guard = (n: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n), Log.clone$Clone(log)); + let _430!: rs.u32; + let _564!: rs.u32; + const guard: (a0: rs.u32) => Guard.Guard = (n: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n), Log.clone$Clone(log)); }; - const _6: rt.u8 = rt.u8Rem(arg, 7); + const _6: rs.u8 = rs.u8Rem(arg, 7); if (_6 === 0) { const a: Guard.Guard = guard(10); - const _12: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(1, 5)), rt.drop), 3, rt.drop); + const _12: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(1, 5)), rs.drop), 3, rs.drop); const captured26 = a; - const part28 = option_map$1raha9y(rt.iterReduce(_12, rt.closure((x4: Guard.Guard, y4: Guard.Guard): Guard.Guard => { + const part28 = option_map$06w9waf(rs.iterReduce(_12, rs.closure((x4: Guard.Guard, y4: Guard.Guard): Guard.Guard => { let _029!: Guard.Guard; let _262: boolean = false; let _252: boolean = false; _262 = true; _252 = true; const part27 = Guard.id(captured26); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part27, f)]; - const _626: string = rt.fmtFormat(["reduce ", args64[0]]); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part27, f)]; + const _626: string = rs.fmtFormat(["reduce ", args64[0]]); Guard.note(y4, _626); if (!(Guard.id(x4) < Guard.id(y4))) { _262 = false; @@ -55,17 +55,17 @@ export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { return _029; }, (): void => { captured26[Symbol.dispose](); - }), true, true), (g18: Guard.Guard): rt.u32 => { - const _030: rt.u32 = Guard.id(g18); + }), true, true), (g18: Guard.Guard): rs.u32 => { + const _030: rs.u32 = Guard.id(g18); g18[Symbol.dispose](); return _030; }); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part28, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["reduced ", args2[0]])); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part28, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["reduced ", args2[0]])); const b: Guard.Guard = guard(11); - const _32: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(5, 7)), rt.drop), 0, rt.drop); + const _32: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(5, 7)), rs.drop), 0, rs.drop); const captured27 = b; - const none: Guard.Guard | undefined = rt.iterReduce(_32, rt.closure((x5: Guard.Guard, _339: Guard.Guard): Guard.Guard => { + const none: Guard.Guard | undefined = rs.iterReduce(_32, rs.closure((x5: Guard.Guard, _339: Guard.Guard): Guard.Guard => { Guard.note(captured27, "never"); _339[Symbol.dispose](); return x5; @@ -73,18 +73,18 @@ export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured27[Symbol.dispose](); }), true, true); const part29 = none === undefined; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part29, f)]; - Log.note(log, rt.fmtFormat(["none ", args4[0]])); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part29, f)]; + Log.note(log, rs.fmtFormat(["none ", args4[0]])); const c: Guard.Guard = guard(12); - const _53: rt.Iter = rt.iterMap(new rt.Range(13, 16), guard); + const _53: rs.Iter = rs.iterMap(new rs.Range(13, 16), guard); const captured28 = c; - const part30 = option_map$1raha9y(rt.iterReduce(_53, rt.closure((x6: Guard.Guard, y5: Guard.Guard): Guard.Guard => { + const part30 = option_map$06w9waf(rs.iterReduce(_53, rs.closure((x6: Guard.Guard, y5: Guard.Guard): Guard.Guard => { let _032!: Guard.Guard; let _1211: boolean = false; let _1116: boolean = false; _1211 = true; _1116 = true; - if (!(Guard.id(y5) === rt.u32Add(Guard.id(captured28), 2))) { + if (!(Guard.id(y5) === rs.u32Add(Guard.id(captured28), 2))) { _1211 = false; _032 = x6; } else { @@ -101,350 +101,350 @@ export function released(log: Log.Log, id: rt.u32, arg: rt.u8): void { return _032; }, (): void => { captured28[Symbol.dispose](); - }), undefined, true), (g19: Guard.Guard): rt.u32 => { - const _033: rt.u32 = Guard.id(g19); + }), undefined, true), (g19: Guard.Guard): rs.u32 => { + const _033: rs.u32 = Guard.id(g19); g19[Symbol.dispose](); return _033; }); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part30, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["made ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part30, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["made ", args6[0]])); const captured29 = guard(16); - const first: (a0: Guard.Guard, a1: Guard.Guard) => Guard.Guard = rt.closure((x7: Guard.Guard, _340: Guard.Guard): Guard.Guard => { + const first: (a0: Guard.Guard, a1: Guard.Guard) => Guard.Guard = rs.closure((x7: Guard.Guard, _340: Guard.Guard): Guard.Guard => { Guard.note(captured29, "first"); _340[Symbol.dispose](); return x7; }, (): void => { captured29[Symbol.dispose](); }); - const part31 = option_map$1raha9y(rt.iterReduce(rt.vecIntoIter(guards(log, id, new rt.Range(17, 20)), rt.drop), first, true), (g20: Guard.Guard): rt.u32 => { - const _035: rt.u32 = Guard.id(g20); + const part31 = option_map$06w9waf(rs.iterReduce(rs.vecIntoIter(guards(log, id, new rs.Range(17, 20)), rs.drop), first, true), (g20: Guard.Guard): rs.u32 => { + const _035: rs.u32 = Guard.id(g20); g20[Symbol.dispose](); return _035; }); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part31, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["lent ", args8[0]])); - rt.drop(first); - rt.drop(none); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part31, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["lent ", args8[0]])); + rs.drop(first); + rs.drop(none); } else if (_6 === 1) { const a2: Guard.Guard = guard(10); - const _93: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(1, 5)), rt.drop), 3, rt.drop); + const _93: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(1, 5)), rs.drop), 3, rs.drop); const captured23 = a2; - const part24 = option_map$1raha9y(rt.iterMaxBy(_93, rt.closure((x: Guard.Guard, y: Guard.Guard): rt.Ordering => { - return rt.cmp(rt.u32Add(rt.u32Div(Guard.id(x), 2), Guard.id(captured23)), rt.u32Add(rt.u32Div(Guard.id(y), 2), Guard.id(captured23))); + const part24 = option_map$06w9waf(rs.iterMaxBy(_93, rs.closure((x: Guard.Guard, y: Guard.Guard): rs.Ordering => { + return rs.cmp(rs.u32Add(rs.u32Div(Guard.id(x), 2), Guard.id(captured23)), rs.u32Add(rs.u32Div(Guard.id(y), 2), Guard.id(captured23))); }, (): void => { captured23[Symbol.dispose](); - }), true, rt.drop, true), (g16: Guard.Guard): rt.u32 => { - const _025: rt.u32 = Guard.id(g16); + }), true, rs.drop, true), (g16: Guard.Guard): rs.u32 => { + const _025: rs.u32 = Guard.id(g16); g16[Symbol.dispose](); return _025; }); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part24, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["max ", args10[0]])); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part24, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["max ", args10[0]])); const b2: Guard.Guard = guard(11); - const _113: rt.Iter = rt.vecIntoIter(guards(log, id, new rt.Range(5, 8)), rt.drop); + const _113: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(5, 8)), rs.drop); const captured24 = b2; - const part25 = option_map$1raha9y(rt.iterMinBy(_113, rt.closure((x2: Guard.Guard, y2: Guard.Guard): rt.Ordering => { - return rt.cmp(rt.u32Add(rt.u32Div(Guard.id(x2), 2), Guard.id(captured24)), rt.u32Add(rt.u32Div(Guard.id(y2), 2), Guard.id(captured24))); + const part25 = option_map$06w9waf(rs.iterMinBy(_113, rs.closure((x2: Guard.Guard, y2: Guard.Guard): rs.Ordering => { + return rs.cmp(rs.u32Add(rs.u32Div(Guard.id(x2), 2), Guard.id(captured24)), rs.u32Add(rs.u32Div(Guard.id(y2), 2), Guard.id(captured24))); }, (): void => { captured24[Symbol.dispose](); - }), true, rt.drop, true), (g17: Guard.Guard): rt.u32 => { - const _027: rt.u32 = Guard.id(g17); + }), true, rs.drop, true), (g17: Guard.Guard): rs.u32 => { + const _027: rs.u32 = Guard.id(g17); g17[Symbol.dispose](); return _027; }); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part25, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["min ", args12[0]])); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part25, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["min ", args12[0]])); const c2: Guard.Guard = guard(12); - const _132: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(13, 15)), rt.drop), 0, rt.drop); + const _132: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured25 = c2; - const none2: Guard.Guard | undefined = rt.iterMaxBy(_132, rt.closure((x3: Guard.Guard, y3: Guard.Guard): rt.Ordering => { - return rt.cmp(Guard.id(x3), rt.u32Add(Guard.id(y3), Guard.id(captured25))); + const none2: Guard.Guard | undefined = rs.iterMaxBy(_132, rs.closure((x3: Guard.Guard, y3: Guard.Guard): rs.Ordering => { + return rs.cmp(Guard.id(x3), rs.u32Add(Guard.id(y3), Guard.id(captured25))); }, (): void => { captured25[Symbol.dispose](); - }), true, rt.drop, true); + }), true, rs.drop, true); const part26 = none2 === undefined; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part26, f)]; - Log.note(log, rt.fmtFormat(["none ", args14[0]])); - rt.drop(none2); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part26, f)]; + Log.note(log, rs.fmtFormat(["none ", args14[0]])); + rs.drop(none2); } else if (_6 === 2) { const a3: Guard.Guard = guard(10); - const _153: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(1, 5)), rt.drop), 3, rt.drop); + const _153: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(1, 5)), rs.drop), 3, rs.drop); const captured19 = a3; - const part20 = option_map$1raha9y(rt.iterMaxByKey(_153, rt.closure((g9: Guard.Guard): rt.u32 => { - return rt.u32Add(rt.u32Div(Guard.id(g9), 2), Guard.id(captured19)); + const part20 = option_map$06w9waf(rs.iterMaxByKey(_153, rs.closure((g9: Guard.Guard): rs.u32 => { + return rs.u32Add(rs.u32Div(Guard.id(g9), 2), Guard.id(captured19)); }, (): void => { captured19[Symbol.dispose](); - }), rt.lt, true, rt.drop, true), (g10: Guard.Guard): rt.u32 => { - const _018: rt.u32 = Guard.id(g10); + }), rs.lt, true, rs.drop, true), (g10: Guard.Guard): rs.u32 => { + const _018: rs.u32 = Guard.id(g10); g10[Symbol.dispose](); return _018; }); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part20, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["max ", args16[0]])); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part20, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["max ", args16[0]])); const b3: Guard.Guard = guard(11); - const _173: rt.Iter = rt.vecIntoIter(guards(log, id, new rt.Range(5, 8)), rt.drop); + const _173: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(5, 8)), rs.drop); const captured20 = b3; - const part21 = option_map$1raha9y(rt.iterMinByKey(_173, rt.closure((g11: Guard.Guard): rt.u32 => { - return rt.u32Add(rt.u32Div(Guard.id(g11), 2), Guard.id(captured20)); + const part21 = option_map$06w9waf(rs.iterMinByKey(_173, rs.closure((g11: Guard.Guard): rs.u32 => { + return rs.u32Add(rs.u32Div(Guard.id(g11), 2), Guard.id(captured20)); }, (): void => { captured20[Symbol.dispose](); - }), rt.lt, true, rt.drop, true), (g12: Guard.Guard): rt.u32 => { - const _020: rt.u32 = Guard.id(g12); + }), rs.lt, true, rs.drop, true), (g12: Guard.Guard): rs.u32 => { + const _020: rs.u32 = Guard.id(g12); g12[Symbol.dispose](); return _020; }); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part21, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["min ", args18[0]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part21, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["min ", args18[0]])); const c3: Guard.Guard = guard(12); - const _192: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(13, 15)), rt.drop), 0, rt.drop); + const _192: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured21 = c3; - const none3: Guard.Guard | undefined = rt.iterMinByKey(_192, rt.closure((g13: Guard.Guard): rt.u32 => { - return rt.u32Add(Guard.id(g13), Guard.id(captured21)); + const none3: Guard.Guard | undefined = rs.iterMinByKey(_192, rs.closure((g13: Guard.Guard): rs.u32 => { + return rs.u32Add(Guard.id(g13), Guard.id(captured21)); }, (): void => { captured21[Symbol.dispose](); - }), rt.lt, true, rt.drop, true); + }), rs.lt, true, rs.drop, true); const part22 = none3 === undefined; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part22, f)]; - Log.note(log, rt.fmtFormat(["none ", args20[0]])); + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part22, f)]; + Log.note(log, rs.fmtFormat(["none ", args20[0]])); const captured22 = guard(15); - const key: (a0: Guard.Guard) => rt.u32 = rt.closure((g14: Guard.Guard): rt.u32 => { - return rt.u32Add(Guard.id(g14), Guard.id(captured22)); + const key: (a0: Guard.Guard) => rs.u32 = rs.closure((g14: Guard.Guard): rs.u32 => { + return rs.u32Add(Guard.id(g14), Guard.id(captured22)); }, (): void => { captured22[Symbol.dispose](); }); - const part23 = option_map$1raha9y(rt.iterMaxByKey(rt.vecIntoIter(guards(log, id, new rt.Range(16, 18)), rt.drop), key, rt.lt, true, rt.drop), (g15: Guard.Guard): rt.u32 => { - const _023: rt.u32 = Guard.id(g15); + const part23 = option_map$06w9waf(rs.iterMaxByKey(rs.vecIntoIter(guards(log, id, new rs.Range(16, 18)), rs.drop), key, rs.lt, true, rs.drop), (g15: Guard.Guard): rs.u32 => { + const _023: rs.u32 = Guard.id(g15); g15[Symbol.dispose](); return _023; }); - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part23, f, rt.u32Debug)]; - Log.note(log, rt.fmtFormat(["lent ", args22[0]])); - rt.drop(key); - rt.drop(none3); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part23, f, rs.u32Debug)]; + Log.note(log, rs.fmtFormat(["lent ", args22[0]])); + rs.drop(key); + rs.drop(none3); } else if (_6 === 3) { const a4: Guard.Guard = guard(10); - const _235: rt.Iter = rt.vecIntoIter(guards(log, id, new rt.Range(1, 4)), rt.drop); + const _235: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(1, 4)), rs.drop); const captured15 = a4; - const part16 = rt.iterIsSortedBy(rt.iterMap(_235, rt.closure((g6: Guard.Guard): rt.u32 => { + const part16 = rs.iterIsSortedBy(rs.iterMap(_235, rs.closure((g6: Guard.Guard): rs.u32 => { const part15 = Guard.id(captured15); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part15, f)]; - const _517: string = rt.fmtFormat(["key ", args62[0]]); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part15, f)]; + const _517: string = rs.fmtFormat(["key ", args62[0]]); Guard.note(g6, _517); - const _013: rt.u32 = Guard.id(g6); + const _013: rs.u32 = Guard.id(g6); g6[Symbol.dispose](); return _013; }, (): void => { captured15[Symbol.dispose](); - })), rt.le, true); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part16, f)]; - Log.note(log, rt.fmtFormat(["sorted ", args24[0]])); + })), rs.le, true); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part16, f)]; + Log.note(log, rs.fmtFormat(["sorted ", args24[0]])); const b4: Guard.Guard = guard(11); - const _253: rt.Iter = rt.vecIntoIter(guards(log, id, new rt.Range(4, 8)), rt.drop); + const _253: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(4, 8)), rs.drop); const captured16 = b4; - const part17 = rt.iterIsSortedBy(rt.iterMap(_253, rt.closure((g7: Guard.Guard): rt.u32 => { - const _014: rt.u32 = rt.u32Rem(rt.u32Add(Guard.id(g7), Guard.id(captured16)), 3); + const part17 = rs.iterIsSortedBy(rs.iterMap(_253, rs.closure((g7: Guard.Guard): rs.u32 => { + const _014: rs.u32 = rs.u32Rem(rs.u32Add(Guard.id(g7), Guard.id(captured16)), 3); g7[Symbol.dispose](); return _014; }, (): void => { captured16[Symbol.dispose](); - })), rt.le, true); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part17, f)]; - Log.note(log, rt.fmtFormat(["unsorted ", args26[0]])); + })), rs.le, true); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part17, f)]; + Log.note(log, rs.fmtFormat(["unsorted ", args26[0]])); const c4: Guard.Guard = guard(12); - const _271: rt.Iter = rt.iterTake(rt.vecIntoIter(guards(log, id, new rt.Range(13, 15)), rt.drop), 0, rt.drop); + const _271: rs.Iter = rs.iterTake(rs.vecIntoIter(guards(log, id, new rs.Range(13, 15)), rs.drop), 0, rs.drop); const captured17 = c4; - const part18 = rt.iterIsSortedBy(rt.iterMap(_271, rt.closure((g8: Guard.Guard): rt.u32 => { - const _015: rt.u32 = rt.u32Add(Guard.id(g8), Guard.id(captured17)); + const part18 = rs.iterIsSortedBy(rs.iterMap(_271, rs.closure((g8: Guard.Guard): rs.u32 => { + const _015: rs.u32 = rs.u32Add(Guard.id(g8), Guard.id(captured17)); g8[Symbol.dispose](); return _015; }, (): void => { captured17[Symbol.dispose](); - })), rt.le, true); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part18, f)]; - Log.note(log, rt.fmtFormat(["empty ", args28[0]])); + })), rs.le, true); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part18, f)]; + Log.note(log, rs.fmtFormat(["empty ", args28[0]])); const d3: Guard.Guard = guard(15); - const _290: rt.Iter = rt.iterSlice([3, 1]); + const _290: rs.Iter = rs.iterSlice([3, 1]); const captured18 = d3; - const part19 = rt.iterIsSortedBy(rt.iterMap(_290, rt.closure((_24: rt.u32): rt.u32 => { - return rt.u32Add(_24, Guard.id(captured18)); + const part19 = rs.iterIsSortedBy(rs.iterMap(_290, rs.closure((_24: rs.u32): rs.u32 => { + return rs.u32Add(_24, Guard.id(captured18)); }, (): void => { captured18[Symbol.dispose](); - })), rt.le, true); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part19, f)]; - Log.note(log, rt.fmtFormat(["plain ", args30[0]])); + })), rs.le, true); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part19, f)]; + Log.note(log, rs.fmtFormat(["plain ", args30[0]])); } else if (_6 === 4) { - const id2: rt.u32 = id; - const guard2: (a0: rt.u32) => Guard.Guard = (n3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id2, n3), Log.clone$Clone(log)); + const id2: rs.u32 = id; + const guard2: (a0: rs.u32) => Guard.Guard = (n3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id2, n3), Log.clone$Clone(log)); }; - const map: rt.HashMap = rt.hashNew() as rt.HashMap; + const map: rs.HashMap = rs.hashNew() as rs.HashMap; const _312: Guard.Guard = guard2(1); - rt.drop(rt.hashInsert(map, 1, _312)); + rs.drop(rs.hashInsert(map, 1, _312)); const _317: [Guard.Guard, Guard.Guard] = [guard2(2), guard2(3)]; const a5: Guard.Guard = _317[0]; const b5: Guard.Guard = _317[1]; - const _333: rt.Entry = rt.entry(map, 1); + const _333: rs.Entry = rs.entry(map, 1); const captured9 = a5; - const part8 = Guard.id(rt.entryOrInsertWith(_333, rt.closure((): Guard.Guard => { + const part8 = Guard.id(rs.entryOrInsertWith(_333, rs.closure((): Guard.Guard => { return captured9; }, (): void => { captured9[Symbol.dispose](); - }), rt.drop)); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part8, f)]; - Log.note(log, rt.fmtFormat(["hash occupied ", args32[0]])); - const _349: rt.Entry = rt.entry(map, 2); + }), rs.drop)); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part8, f)]; + Log.note(log, rs.fmtFormat(["hash occupied ", args32[0]])); + const _349: rs.Entry = rs.entry(map, 2); const captured10 = b5; - const part9 = Guard.id(rt.entryOrInsertWith(_349, rt.closure((): Guard.Guard => { + const part9 = Guard.id(rs.entryOrInsertWith(_349, rs.closure((): Guard.Guard => { return captured10; }, (): void => { captured10[Symbol.dispose](); - }), rt.drop)); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part9, f)]; - Log.note(log, rt.fmtFormat(["hash vacant ", args34[0]])); + }), rs.drop)); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part9, f)]; + Log.note(log, rs.fmtFormat(["hash vacant ", args34[0]])); const captured11 = guard2(4); - const made2: () => Guard.Guard = rt.closure((): Guard.Guard => { - return Guard.new(rt.u32Add(Guard.id(captured11), 10), Log.clone$Clone(log)); + const made2: () => Guard.Guard = rs.closure((): Guard.Guard => { + return Guard.new(rs.u32Add(Guard.id(captured11), 10), Log.clone$Clone(log)); }, (): void => { captured11[Symbol.dispose](); }); - const part10 = Guard.id(rt.entryOrInsertWith(rt.entry(map, 3), rt.once(made2), rt.drop)); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part10, f)]; - Log.note(log, rt.fmtFormat(["hash made ", args36[0]])); + const part10 = Guard.id(rs.entryOrInsertWith(rs.entry(map, 3), rs.once(made2), rs.drop)); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part10, f)]; + Log.note(log, rs.fmtFormat(["hash made ", args36[0]])); const captured12 = guard2(5); - const keyed: (a0: rt.u32) => Guard.Guard = rt.closure((k4: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(Guard.id(captured12), k4), Log.clone$Clone(log)); + const keyed: (a0: rs.u32) => Guard.Guard = rs.closure((k4: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(Guard.id(captured12), k4), Log.clone$Clone(log)); }, (): void => { captured12[Symbol.dispose](); }); - const part11 = Guard.id(rt.entryOrInsertWith(rt.entry(map, 4), rt.once(keyed), rt.drop)); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part11, f)]; - Log.note(log, rt.fmtFormat(["hash keyed ", args38[0]])); + const part11 = Guard.id(rs.entryOrInsertWith(rs.entry(map, 4), rs.once(keyed), rs.drop)); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part11, f)]; + Log.note(log, rs.fmtFormat(["hash keyed ", args38[0]])); const _396: [Guard.Guard, Guard.Guard] = [guard2(6), guard2(7)]; const e: Guard.Guard = _396[0]; f = _396[1]; - const _404: rt.Entry = rt.entry(map, 1); + const _404: rs.Entry = rs.entry(map, 1); const captured13 = e; - rt.entryAndModify(_404, rt.closure((g4: Guard.Guard): undefined => { + rs.entryAndModify(_404, rs.closure((g4: Guard.Guard): undefined => { const part12 = Guard.id(captured13); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part12, f)]; - Guard.note(g4, rt.fmtFormat(["modified ", args58[0]])); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part12, f)]; + Guard.note(g4, rs.fmtFormat(["modified ", args58[0]])); captured13[Symbol.dispose](); }, (): void => { captured13[Symbol.dispose](); - }), rt.drop); - const _409: rt.Entry = rt.entry(map, 5); + }), rs.drop); + const _409: rs.Entry = rs.entry(map, 5); const captured14 = f; - const part14 = Guard.id(rt.entryOrInsert(rt.entryAndModify(_409, rt.closure((g5: Guard.Guard): undefined => { + const part14 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_409, rs.closure((g5: Guard.Guard): undefined => { const part13 = Guard.id(captured14); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part13, f)]; - Guard.note(g5, rt.fmtFormat([args60[0]])); + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part13, f)]; + Guard.note(g5, rs.fmtFormat([args60[0]])); captured14[Symbol.dispose](); }, (): void => { captured14[Symbol.dispose](); - }), rt.drop), guard2(8), rt.drop)); - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part14, f)]; - Log.note(log, rt.fmtFormat(["hash added ", args40[0]])); - let iterStart: rt.u32 = 1; - const iterEnd: rt.u32 = 6; + }), rs.drop), guard2(8), rs.drop)); + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part14, f)]; + Log.note(log, rs.fmtFormat(["hash added ", args40[0]])); + let iterStart: rs.u32 = 1; + const iterEnd: rs.u32 = 6; while ((_430 = iterStart++) < iterEnd) { - rt.drop(rt.hashRemove(map, _430)); + rs.drop(rs.hashRemove(map, _430)); } - rt.hashDrop(map, undefined, rt.drop); + rs.hashDrop(map, undefined, rs.drop); } else if (_6 === 5) { - const id3: rt.u32 = id; - const guard3: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id3, n2), Log.clone$Clone(log)); + const id3: rs.u32 = id; + const guard3: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id3, n2), Log.clone$Clone(log)); }; - const map2: rt.BTreeMap = rt.btreeNew(rt.cmp) as rt.BTreeMap; + const map2: rs.BTreeMap = rs.btreeNew(rs.cmp) as rs.BTreeMap; const _446: Guard.Guard = guard3(1); - rt.drop(rt.btreeInsert(map2, 1, _446)); + rs.drop(rs.btreeInsert(map2, 1, _446)); const _451: [Guard.Guard, Guard.Guard] = [guard3(2), guard3(3)]; const a6: Guard.Guard = _451[0]; const b6: Guard.Guard = _451[1]; - const _467: rt.Entry = rt.entry(map2, 1); + const _467: rs.Entry = rs.entry(map2, 1); const captured3 = a6; - const part = Guard.id(rt.entryOrInsertWith(_467, rt.closure((): Guard.Guard => { + const part = Guard.id(rs.entryOrInsertWith(_467, rs.closure((): Guard.Guard => { return captured3; }, (): void => { captured3[Symbol.dispose](); - }), rt.drop)); - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["btree occupied ", args42[0]])); - const _483: rt.Entry = rt.entry(map2, 2); + }), rs.drop)); + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["btree occupied ", args42[0]])); + const _483: rs.Entry = rs.entry(map2, 2); const captured4 = b6; - const part2 = Guard.id(rt.entryOrInsertWith(_483, rt.closure((): Guard.Guard => { + const part2 = Guard.id(rs.entryOrInsertWith(_483, rs.closure((): Guard.Guard => { return captured4; }, (): void => { captured4[Symbol.dispose](); - }), rt.drop)); - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["btree vacant ", args44[0]])); + }), rs.drop)); + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["btree vacant ", args44[0]])); const captured5 = guard3(4); - const made3: () => Guard.Guard = rt.closure((): Guard.Guard => { - return Guard.new(rt.u32Add(Guard.id(captured5), 10), Log.clone$Clone(log)); + const made3: () => Guard.Guard = rs.closure((): Guard.Guard => { + return Guard.new(rs.u32Add(Guard.id(captured5), 10), Log.clone$Clone(log)); }, (): void => { captured5[Symbol.dispose](); }); - const part3 = Guard.id(rt.entryOrInsertWith(rt.entry(map2, 3), rt.once(made3), rt.drop)); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["btree made ", args46[0]])); + const part3 = Guard.id(rs.entryOrInsertWith(rs.entry(map2, 3), rs.once(made3), rs.drop)); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["btree made ", args46[0]])); const captured6 = guard3(5); - const keyed2: (a0: rt.u32) => Guard.Guard = rt.closure((k3: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(Guard.id(captured6), k3), Log.clone$Clone(log)); + const keyed2: (a0: rs.u32) => Guard.Guard = rs.closure((k3: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(Guard.id(captured6), k3), Log.clone$Clone(log)); }, (): void => { captured6[Symbol.dispose](); }); - const part4 = Guard.id(rt.entryOrInsertWith(rt.entry(map2, 4), rt.once(keyed2), rt.drop)); - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part4, f)]; - Log.note(log, rt.fmtFormat(["btree keyed ", args48[0]])); + const part4 = Guard.id(rs.entryOrInsertWith(rs.entry(map2, 4), rs.once(keyed2), rs.drop)); + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part4, f)]; + Log.note(log, rs.fmtFormat(["btree keyed ", args48[0]])); const _530: [Guard.Guard, Guard.Guard] = [guard3(6), guard3(7)]; const e2: Guard.Guard = _530[0]; const f2: Guard.Guard = _530[1]; - const _538: rt.Entry = rt.entry(map2, 1); + const _538: rs.Entry = rs.entry(map2, 1); const captured7 = e2; - rt.entryAndModify(_538, rt.closure((g2: Guard.Guard): undefined => { + rs.entryAndModify(_538, rs.closure((g2: Guard.Guard): undefined => { const part5 = Guard.id(captured7); - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part5, f)]; - Guard.note(g2, rt.fmtFormat(["modified ", args54[0]])); + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part5, f)]; + Guard.note(g2, rs.fmtFormat(["modified ", args54[0]])); captured7[Symbol.dispose](); }, (): void => { captured7[Symbol.dispose](); - }), rt.drop); - const _543: rt.Entry = rt.entry(map2, 5); + }), rs.drop); + const _543: rs.Entry = rs.entry(map2, 5); const captured8 = f2; - const part7 = Guard.id(rt.entryOrInsert(rt.entryAndModify(_543, rt.closure((g3: Guard.Guard): undefined => { + const part7 = Guard.id(rs.entryOrInsert(rs.entryAndModify(_543, rs.closure((g3: Guard.Guard): undefined => { const part6 = Guard.id(captured8); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part6, f)]; - Guard.note(g3, rt.fmtFormat([args56[0]])); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part6, f)]; + Guard.note(g3, rs.fmtFormat([args56[0]])); captured8[Symbol.dispose](); }, (): void => { captured8[Symbol.dispose](); - }), rt.drop), guard3(8), rt.drop)); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part7, f)]; - Log.note(log, rt.fmtFormat(["btree added ", args50[0]])); - let iterStart2: rt.u32 = 1; - const iterEnd2: rt.u32 = 6; + }), rs.drop), guard3(8), rs.drop)); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part7, f)]; + Log.note(log, rs.fmtFormat(["btree added ", args50[0]])); + let iterStart2: rs.u32 = 1; + const iterEnd2: rs.u32 = 6; while ((_564 = iterStart2++) < iterEnd2) { - rt.drop(rt.btreeRemove(map2, _564)); + rs.drop(rs.btreeRemove(map2, _564)); } - rt.btreeDrop(map2, undefined, rt.drop); + rs.btreeDrop(map2, undefined, rs.drop); } else { const a7: Guard.Guard = guard(10); - const _576: rt.Iter = rt.vecIntoIter(guards(log, id, new rt.Range(1, 4)), rt.drop); + const _576: rs.Iter = rs.vecIntoIter(guards(log, id, new rs.Range(1, 4)), rs.drop); const captured = id; const captured2 = a7; - rt.drop(rt.iterMaxByKey(_576, rt.closure((g: Guard.Guard): rt.u32 => { - if (!(Guard.id(g) !== rt.u32Add(captured, 2))) { - const _122: rt.u32 = Guard.id(g); - const _142: rt.u32 = Guard.id(captured2); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(_122, f), (f: rt.Formatter) => rt.u32Display(_142, f)]; - rt.panicFmt(["key of g", args52[0], " with g", args52[1]]); + rs.drop(rs.iterMaxByKey(_576, rs.closure((g: Guard.Guard): rs.u32 => { + if (!(Guard.id(g) !== rs.u32Add(captured, 2))) { + const _122: rs.u32 = Guard.id(g); + const _142: rs.u32 = Guard.id(captured2); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(_122, f), (f: rs.Formatter) => rs.u32Display(_142, f)]; + rs.panicFmt(["key of g", args52[0], " with g", args52[1]]); } else { return Guard.id(g); } }, (): void => { captured2[Symbol.dispose](); - }), rt.lt, true, rt.drop, true)); + }), rs.lt, true, rs.drop, true)); } } diff --git a/ts/fixtures/task/expected/drops/searched.ts b/ts/fixtures/task/expected/drops/searched.ts index cdbc27608..515eb47cc 100644 --- a/ts/fixtures/task/expected/drops/searched.ts +++ b/ts/fixtures/task/expected/drops/searched.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../rt.ts"; +import * as rs from "../rs.ts"; import * as Log from "../log.Log.ts"; import * as Guard from "../model.Guard.ts"; /** Run scenario `arg % 9`. */ -export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { +export function searched(log: Log.Log, id: rs.u32, arg: rs.u8): void { let f!: Guard.Guard; - let p!: (a0: rt.char) => boolean; - const guard: (a0: rt.u32) => Guard.Guard = (n4: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n4), Log.clone$Clone(log)); + let p!: (a0: rs.char) => boolean; + const guard: (a0: rs.u32) => Guard.Guard = (n4: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n4), Log.clone$Clone(log)); }; const text: string = "a,b;c,,d"; - const _8: rt.u8 = rt.u8Rem(arg, 9); + const _8: rs.u8 = rs.u8Rem(arg, 9); if (_8 === 0) { const captured54 = guard(1); - const _14: (a0: rt.char) => boolean = rt.closure((c52: rt.char): boolean => { + const _14: (a0: rs.char) => boolean = rs.closure((c52: rs.char): boolean => { if (!(c52 === 59)) { return false; } @@ -23,9 +23,9 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured54[Symbol.dispose](); }); - const found: boolean = rt.dropAfter(_14, () => rt.strContains(text, _14)); + const found: boolean = rs.dropAfter(_14, () => rs.strContains(text, _14)); const captured55 = guard(2); - const _19: (a0: rt.char) => boolean = rt.closure((c53: rt.char): boolean => { + const _19: (a0: rs.char) => boolean = rs.closure((c53: rs.char): boolean => { if (!(c53 === 122)) { return false; } @@ -33,20 +33,20 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured55[Symbol.dispose](); }); - const missing: boolean = rt.dropAfter(_19, () => rt.strContains(text, _19)); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(found, f), (f: rt.Formatter) => rt.fmtBool(missing, f)]; - Log.note(log, rt.fmtFormat(["contains ", args2[0], " ", args2[1]])); + const missing: boolean = rs.dropAfter(_19, () => rs.strContains(text, _19)); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found, f), (f: rs.Formatter) => rs.fmtBool(missing, f)]; + Log.note(log, rs.fmtFormat(["contains ", args2[0], " ", args2[1]])); const _34: [Guard.Guard, Guard.Guard] = [guard(3), guard(4)]; const c: Guard.Guard = _34[0]; const d: Guard.Guard = _34[1]; - const captured56 = (c54: rt.char): boolean => { + const captured56 = (c54: rs.char): boolean => { if (!(c54 === 44)) { return c54 === 59; } return true; }; const captured57 = d; - const _43: (a0: rt.char) => boolean = rt.closure((c55: rt.char): boolean => { + const _43: (a0: rs.char) => boolean = rs.closure((c55: rs.char): boolean => { if (!captured56(c55)) { return false; } @@ -54,15 +54,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured57[Symbol.dispose](); }); - const _42: rt.usize | undefined = rt.dropAfter(_43, () => rt.strFind(text, _43)); - const captured58 = (c56: rt.char): boolean => { + const _42: rs.usize | undefined = rs.dropAfter(_43, () => rs.strFind(text, _43)); + const captured58 = (c56: rs.char): boolean => { if (!(c56 === 44)) { return c56 === 59; } return true; }; const captured59 = c; - const _45: (a0: rt.char) => boolean = rt.closure((ch3: rt.char): boolean => { + const _45: (a0: rs.char) => boolean = rs.closure((ch3: rs.char): boolean => { if (!captured58(ch3)) { return false; } @@ -70,14 +70,14 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured59[Symbol.dispose](); }); - const part14 = [_42, rt.dropAfter(_45, () => rt.strRfind(text, _45))] as [rt.usize | undefined, rt.usize | undefined]; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part14[0], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(part14[1], f, rt.usizeDebug)], f)]; - Log.note(log, rt.fmtFormat(["find ", args4[0]])); + const part14 = [_42, rs.dropAfter(_45, () => rs.strRfind(text, _45))] as [rs.usize | undefined, rs.usize | undefined]; + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part14[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part14[1], f, rs.usizeDebug)], f)]; + Log.note(log, rs.fmtFormat(["find ", args4[0]])); const _58: [Guard.Guard, Guard.Guard] = [guard(5), guard(6)]; const e: Guard.Guard = _58[0]; f = _58[1]; const captured60 = e; - const _67: (a0: rt.char) => boolean = rt.closure((c57: rt.char): boolean => { + const _67: (a0: rs.char) => boolean = rs.closure((c57: rs.char): boolean => { if (!(c57 === 97)) { return false; } @@ -85,15 +85,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured60[Symbol.dispose](); }); - const _66: boolean = rt.dropAfter(_67, () => rt.strStartsWith(text, _67)); - const captured61 = (c58: rt.char): boolean => { + const _66: boolean = rs.dropAfter(_67, () => rs.strStartsWith(text, _67)); + const captured61 = (c58: rs.char): boolean => { if (!(c58 === 44)) { return c58 === 59; } return true; }; const captured62 = f; - const _69: (a0: rt.char) => boolean = rt.closure((c59: rt.char): boolean => { + const _69: (a0: rs.char) => boolean = rs.closure((c59: rs.char): boolean => { if (!captured61(c59)) { return false; } @@ -101,14 +101,14 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured62[Symbol.dispose](); }); - const part15 = [_66, rt.dropAfter(_69, () => rt.strEndsWith(text, _69))] as [boolean, boolean]; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(part15[0], f), (f: rt.Formatter) => rt.fmtBool(part15[1], f)], f)]; - Log.note(log, rt.fmtFormat(["ends ", args6[0]])); + const part15 = [_66, rs.dropAfter(_69, () => rs.strEndsWith(text, _69))] as [boolean, boolean]; + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part15[0], f), (f: rs.Formatter) => rs.fmtBool(part15[1], f)], f)]; + Log.note(log, rs.fmtFormat(["ends ", args6[0]])); const _82: [Guard.Guard, Guard.Guard] = [guard(7), guard(8)]; const g: Guard.Guard = _82[0]; const h: Guard.Guard = _82[1]; const captured63 = g; - const _91: (a0: rt.char) => boolean = rt.closure((c60: rt.char): boolean => { + const _91: (a0: rs.char) => boolean = rs.closure((c60: rs.char): boolean => { if (!(c60 === 97)) { return false; } @@ -116,9 +116,9 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured63[Symbol.dispose](); }); - const _90: string | undefined = rt.dropAfter(_91, () => rt.strStripPrefix(text, _91)); + const _90: string | undefined = rs.dropAfter(_91, () => rs.strStripPrefix(text, _91)); const captured64 = h; - const _93: (a0: rt.char) => boolean = rt.closure((c61: rt.char): boolean => { + const _93: (a0: rs.char) => boolean = rs.closure((c61: rs.char): boolean => { if (!(c61 === 97)) { return false; } @@ -126,20 +126,20 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured64[Symbol.dispose](); }); - const part16 = [_90, rt.dropAfter(_93, () => rt.strStripSuffix(text, _93))] as [string | undefined, string | undefined]; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part16[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(part16[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["strip ", args8[0]])); + const part16 = [_90, rs.dropAfter(_93, () => rs.strStripSuffix(text, _93))] as [string | undefined, string | undefined]; + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part16[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(part16[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["strip ", args8[0]])); const _106: [Guard.Guard, Guard.Guard] = [guard(9), guard(10)]; const i: Guard.Guard = _106[0]; const j: Guard.Guard = _106[1]; - const captured65 = (c62: rt.char): boolean => { + const captured65 = (c62: rs.char): boolean => { if (!(c62 === 44)) { return c62 === 59; } return true; }; const captured66 = i; - const _115: (a0: rt.char) => boolean = rt.closure((c63: rt.char): boolean => { + const _115: (a0: rs.char) => boolean = rs.closure((c63: rs.char): boolean => { if (!captured65(c63)) { return false; } @@ -147,15 +147,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured66[Symbol.dispose](); }); - const _114: [string, string] | undefined = rt.dropAfter(_115, () => rt.strSplitOnce(text, _115)); - const captured67 = (c64: rt.char): boolean => { + const _114: [string, string] | undefined = rs.dropAfter(_115, () => rs.strSplitOnce(text, _115)); + const captured67 = (c64: rs.char): boolean => { if (!(c64 === 44)) { return c64 === 59; } return true; }; const captured68 = j; - const _117: (a0: rt.char) => boolean = rt.closure((c65: rt.char): boolean => { + const _117: (a0: rs.char) => boolean = rs.closure((c65: rs.char): boolean => { if (!captured67(c65)) { return false; } @@ -163,16 +163,16 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured68[Symbol.dispose](); }); - const part17 = [_114, rt.dropAfter(_117, () => rt.strRsplitOnce(text, _117))] as [[string, string] | undefined, [string, string] | undefined]; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part17[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(part17[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rt.fmtFormat(["once ", args10[0]])); + const part17 = [_114, rs.dropAfter(_117, () => rs.strRsplitOnce(text, _117))] as [[string, string] | undefined, [string, string] | undefined]; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part17[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part17[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["once ", args10[0]])); const _131: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(11), guard(12), guard(13)]; const k: Guard.Guard = _131[0]; const l: Guard.Guard = _131[1]; const m: Guard.Guard = _131[2]; const _143: string = ",a,"; const captured69 = k; - const _144: (a0: rt.char) => boolean = rt.closure((c66: rt.char): boolean => { + const _144: (a0: rs.char) => boolean = rs.closure((c66: rs.char): boolean => { if (!(c66 === 44)) { return false; } @@ -180,10 +180,10 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured69[Symbol.dispose](); }); - const _142: string = rt.dropAfter(_144, () => rt.strTrimMatches(_143, _144)); + const _142: string = rs.dropAfter(_144, () => rs.strTrimMatches(_143, _144)); const captured70 = l; const _146: string = ",a,"; - const _147: (a0: rt.char) => boolean = rt.closure((c67: rt.char): boolean => { + const _147: (a0: rs.char) => boolean = rs.closure((c67: rs.char): boolean => { if (!(c67 === 44)) { return false; } @@ -191,10 +191,10 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured70[Symbol.dispose](); }); - const _145: string = rt.dropAfter(_147, () => rt.strTrimStartMatches(_146, _147)); + const _145: string = rs.dropAfter(_147, () => rs.strTrimStartMatches(_146, _147)); const captured71 = m; const _149: string = ",a,"; - const _150: (a0: rt.char) => boolean = rt.closure((c68: rt.char): boolean => { + const _150: (a0: rs.char) => boolean = rs.closure((c68: rs.char): boolean => { if (!(c68 === 44)) { return false; } @@ -202,20 +202,20 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured71[Symbol.dispose](); }); - const part18 = [_142, _145, rt.dropAfter(_150, () => rt.strTrimEndMatches(_149, _150))] as [string, string, string]; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(part18[0], f), (f: rt.Formatter) => rt.fmtStr(part18[1], f), (f: rt.Formatter) => rt.fmtStr(part18[2], f)], f)]; - Log.note(log, rt.fmtFormat(["trim ", args12[0]])); + const part18 = [_142, _145, rs.dropAfter(_150, () => rs.strTrimEndMatches(_149, _150))] as [string, string, string]; + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part18[0], f), (f: rs.Formatter) => rs.fmtStr(part18[1], f), (f: rs.Formatter) => rs.fmtStr(part18[2], f)], f)]; + Log.note(log, rs.fmtFormat(["trim ", args12[0]])); const _163: [Guard.Guard, Guard.Guard] = [guard(14), guard(15)]; const n: Guard.Guard = _163[0]; const o: Guard.Guard = _163[1]; - const captured72 = (c69: rt.char): boolean => { + const captured72 = (c69: rs.char): boolean => { if (!(c69 === 44)) { return c69 === 59; } return true; }; const captured73 = n; - const _172: (a0: rt.char) => boolean = rt.closure((c70: rt.char): boolean => { + const _172: (a0: rs.char) => boolean = rs.closure((c70: rs.char): boolean => { if (!captured72(c70)) { return false; } @@ -224,15 +224,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured73[Symbol.dispose](); }); const _173: string = "+"; - const _171: string = rt.dropAfter(_172, () => rt.strReplace(text, _172, _173)); - const captured74 = (c71: rt.char): boolean => { + const _171: string = rs.dropAfter(_172, () => rs.strReplace(text, _172, _173)); + const captured74 = (c71: rs.char): boolean => { if (!(c71 === 44)) { return c71 === 59; } return true; }; const captured75 = o; - const _175: (a0: rt.char) => boolean = rt.closure((c72: rt.char): boolean => { + const _175: (a0: rs.char) => boolean = rs.closure((c72: rs.char): boolean => { if (!captured74(c72)) { return false; } @@ -241,19 +241,19 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured75[Symbol.dispose](); }); const _176: string = "+"; - const part19 = [_171, rt.dropAfter(_175, () => rt.strReplace(text, _175, _176, 2))] as [string, string]; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(part19[0], f), (f: rt.Formatter) => rt.fmtStr(part19[1], f)], f)]; - Log.note(log, rt.fmtFormat(["replace ", args14[0]])); + const part19 = [_171, rs.dropAfter(_175, () => rs.strReplace(text, _175, _176, 2))] as [string, string]; + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(part19[0], f), (f: rs.Formatter) => rs.fmtStr(part19[1], f)], f)]; + Log.note(log, rs.fmtFormat(["replace ", args14[0]])); } else if (_8 === 1) { const a2: Guard.Guard = guard(1); - const captured32 = (c31: rt.char): boolean => { + const captured32 = (c31: rs.char): boolean => { if (!(c31 === 44)) { return c31 === 59; } return true; }; const captured33 = a2; - const split: rt.Iter = rt.strSplit(text, rt.closure((c32: rt.char): boolean => { + const split: rs.Iter = rs.strSplit(text, rs.closure((c32: rs.char): boolean => { if (!captured32(c32)) { return false; } @@ -261,20 +261,20 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured33[Symbol.dispose](); })); - const _198: string | undefined = rt.iterToOption(split.next()); - const _201: string | undefined = rt.iterToOption(split.nextBack()); - const args16: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_198, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_201, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args16[0], " ", args16[1]])); - rt.drop(split); + const _198: string | undefined = rs.iterToOption(split.next()); + const _201: string | undefined = rs.iterToOption(split.nextBack()); + const args16: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_198, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_201, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args16[0], " ", args16[1]])); + rs.drop(split); const b2: Guard.Guard = guard(2); - const captured34 = (c33: rt.char): boolean => { + const captured34 = (c33: rs.char): boolean => { if (!(c33 === 44)) { return c33 === 59; } return true; }; const captured35 = b2; - const part10 = rt.iterToVec(rt.strRsplit(text, rt.closure((c34: rt.char): boolean => { + const part10 = rs.iterToVec(rs.strRsplit(text, rs.closure((c34: rs.char): boolean => { if (!captured34(c34)) { return false; } @@ -282,19 +282,19 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured35[Symbol.dispose](); })), "next", 8); - const args18: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part10.items, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["rsplit ", args18[0]])); + const args18: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part10.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["rsplit ", args18[0]])); const _228: [Guard.Guard, Guard.Guard] = [guard(3), guard(4)]; const c2: Guard.Guard = _228[0]; const d2: Guard.Guard = _228[1]; - const captured36 = (c35: rt.char): boolean => { + const captured36 = (c35: rs.char): boolean => { if (!(c35 === 44)) { return c35 === 59; } return true; }; const captured37 = d2; - const _236: rt.usize = rt.ownedCount(rt.strSplitn(text, 2, rt.closure((c36: rt.char): boolean => { + const _236: rs.usize = rs.ownedCount(rs.strSplitn(text, 2, rs.closure((c36: rs.char): boolean => { if (!captured36(c36)) { return false; } @@ -302,32 +302,32 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured37[Symbol.dispose](); }))); - const captured38 = (c37: rt.char): boolean => { + const captured38 = (c37: rs.char): boolean => { if (!(c37 === 44)) { return c37 === 59; } return true; }; const captured39 = c2; - const part11 = [_236, rt.ownedLast(rt.strRsplitn(text, 3, rt.closure((ch2: rt.char): boolean => { + const part11 = [_236, rs.ownedLast(rs.strRsplitn(text, 3, rs.closure((ch2: rs.char): boolean => { if (!captured38(ch2)) { return false; } return Guard.id(captured39) > 0; }, (): void => { captured39[Symbol.dispose](); - })))] as [rt.usize, string | undefined]; - const args20: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(part11[0], f), (f: rt.Formatter) => rt.fmtOption(part11[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["splitn ", args20[0]])); + })))] as [rs.usize, string | undefined]; + const args20: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(part11[0], f), (f: rs.Formatter) => rs.fmtOption(part11[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["splitn ", args20[0]])); const e2: Guard.Guard = guard(5); - const captured40 = (c38: rt.char): boolean => { + const captured40 = (c38: rs.char): boolean => { if (!(c38 === 44)) { return c38 === 59; } return true; }; const captured41 = e2; - const iter: rt.Iter = rt.strSplitTerminator(text, rt.closure((c39: rt.char): boolean => { + const iter: rs.Iter = rs.strSplitTerminator(text, rs.closure((c39: rs.char): boolean => { if (!captured40(c39)) { return false; } @@ -336,27 +336,27 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured41[Symbol.dispose](); })); while (true) { - const _259: string | rt.Done = iter.next(); - if (_259 === rt.DONE) { + const _259: string | rs.Done = iter.next(); + if (_259 === rs.DONE) { break; } const part: string = _259; - const args22: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, part)]; - Log.note(log, rt.fmtFormat(["part ", args22[0]])); + const args22: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, part)]; + Log.note(log, rs.fmtFormat(["part ", args22[0]])); if (part === "c") { break; } } - rt.drop(iter); + rs.drop(iter); const f2: Guard.Guard = guard(6); - const captured42 = (c40: rt.char): boolean => { + const captured42 = (c40: rs.char): boolean => { if (!(c40 === 44)) { return c40 === 59; } return true; }; const captured43 = f2; - const terminated: rt.Iter = rt.strRsplitTerminator(text, rt.closure((c41: rt.char): boolean => { + const terminated: rs.Iter = rs.strRsplitTerminator(text, rs.closure((c41: rs.char): boolean => { if (!captured42(c41)) { return false; } @@ -364,19 +364,19 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured43[Symbol.dispose](); })); - const part12 = rt.iterNth(terminated, 1); - const args24: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part12, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["rsplit_terminator ", args24[0]])); - rt.drop(terminated); + const part12 = rs.iterNth(terminated, 1); + const args24: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part12, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["rsplit_terminator ", args24[0]])); + rs.drop(terminated); const g2: Guard.Guard = guard(7); - const captured44 = (c42: rt.char): boolean => { + const captured44 = (c42: rs.char): boolean => { if (!(c42 === 44)) { return c42 === 59; } return true; }; const captured45 = g2; - const part13 = rt.iterToVec(rt.iterMap(rt.iterRev(rt.strSplitInclusive(text, rt.closure((c43: rt.char): boolean => { + const part13 = rs.iterToVec(rs.iterMap(rs.iterRev(rs.strSplitInclusive(text, rs.closure((c43: rs.char): boolean => { if (!captured44(c43)) { return false; } @@ -384,21 +384,21 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured45[Symbol.dispose](); }))), (s2: string): string => { - return rt.strTrimEndMatches(s2, ","); + return rs.strTrimEndMatches(s2, ","); }), "next", 8); - const args26: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part13.items, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split_inclusive ", args26[0]])); + const args26: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part13.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split_inclusive ", args26[0]])); const _315: [Guard.Guard, Guard.Guard] = [guard(8), guard(9)]; const h2: Guard.Guard = _315[0]; const i2: Guard.Guard = _315[1]; - const captured46 = (c44: rt.char): boolean => { + const captured46 = (c44: rs.char): boolean => { if (!(c44 === 44)) { return c44 === 59; } return true; }; const captured47 = h2; - const matched: rt.Iter = rt.strMatches(text, rt.closure((c45: rt.char): boolean => { + const matched: rs.Iter = rs.strMatches(text, rs.closure((c45: rs.char): boolean => { if (!captured46(c45)) { return false; } @@ -406,14 +406,14 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured47[Symbol.dispose](); })); - const captured48 = (c46: rt.char): boolean => { + const captured48 = (c46: rs.char): boolean => { if (!(c46 === 44)) { return c46 === 59; } return true; }; const captured49 = i2; - const _326: rt.Iter = rt.strRmatches(text, rt.closure((c47: rt.char): boolean => { + const _326: rs.Iter = rs.strRmatches(text, rs.closure((c47: rs.char): boolean => { if (!captured48(c47)) { return false; } @@ -421,23 +421,23 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured49[Symbol.dispose](); })); - const last: string | undefined = rt.iterToOption(_326.next()); - rt.drop(_326); - const _334: string | undefined = rt.iterToOption(matched.next()); - const args28: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_334, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(last, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["matches ", args28[0], " ", args28[1]])); - rt.drop(matched); + const last: string | undefined = rs.iterToOption(_326.next()); + rs.drop(_326); + const _334: string | undefined = rs.iterToOption(matched.next()); + const args28: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_334, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args28[0], " ", args28[1]])); + rs.drop(matched); const _346: [Guard.Guard, Guard.Guard] = [guard(10), guard(11)]; const j2: Guard.Guard = _346[0]; const k2: Guard.Guard = _346[1]; - const captured50 = (c48: rt.char): boolean => { + const captured50 = (c48: rs.char): boolean => { if (!(c48 === 44)) { return c48 === 59; } return true; }; const captured51 = j2; - const _356: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(text, rt.closure((c49: rt.char): boolean => { + const _356: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(text, rs.closure((c49: rs.char): boolean => { if (!captured50(c49)) { return false; } @@ -445,15 +445,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured51[Symbol.dispose](); })); - const _354: [rt.usize, string] | undefined = rt.iterNth(_356, 2); - const captured52 = (c50: rt.char): boolean => { + const _354: [rs.usize, string] | undefined = rs.iterNth(_356, 2); + const captured52 = (c50: rs.char): boolean => { if (!(c50 === 44)) { return c50 === 59; } return true; }; const captured53 = k2; - const _360: rt.Iter<[rt.usize, string]> = rt.strRmatchIndices(text, rt.closure((c51: rt.char): boolean => { + const _360: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(text, rs.closure((c51: rs.char): boolean => { if (!captured52(c51)) { return false; } @@ -461,73 +461,73 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured53[Symbol.dispose](); })); - const indices: [[rt.usize, string] | undefined, [rt.usize, string] | undefined] = [_354, rt.iterToOption(_360.next())]; - rt.drop(_360); - rt.drop(_356); - const args30: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(indices[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(indices[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rt.fmtFormat(["indices ", args30[0]])); + const indices: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [_354, rs.iterToOption(_360.next())]; + rs.drop(_360); + rs.drop(_356); + const args30: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["indices ", args30[0]])); } else if (_8 === 2) { const a3: Guard.Guard = guard(1); let s: string = text; const captured27 = a3; - const captured28 = (c29: rt.char): boolean => { + const captured28 = (c29: rs.char): boolean => { if (!(c29 === 44)) { return c29 === 59; } return true; }; - const _378: (a0: rt.char) => boolean = rt.closure((c30: rt.char): boolean => { - const args138: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtCharDisplay(c30, f)]; - Guard.note(captured27, rt.fmtFormat(["retain ", args138[0]])); + const _378: (a0: rs.char) => boolean = rs.closure((c30: rs.char): boolean => { + const args138: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtCharDisplay(c30, f)]; + Guard.note(captured27, rs.fmtFormat(["retain ", args138[0]])); return !captured28(c30); }, (): void => { captured27[Symbol.dispose](); }); - s = rt.stringRetain(s, _378); - rt.drop(_378); - const args32: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s)]; - Log.note(log, rt.fmtFormat(["retained ", args32[0]])); + s = rs.stringRetain(s, _378); + rs.drop(_378); + const args32: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + Log.note(log, rs.fmtFormat(["retained ", args32[0]])); const b3: Guard.Guard = guard(2); - let captured29: rt.i32 = 0; + let captured29: rs.i32 = 0; const captured30 = b3; - const everyOther: (a0: rt.char) => boolean = rt.closure((_2: rt.char): boolean => { - captured29 = rt.i32Add(captured29, 1); - if (!(rt.i32Rem(captured29, 2) === 0)) { + const everyOther: (a0: rs.char) => boolean = rs.closure((_2: rs.char): boolean => { + captured29 = rs.i32Add(captured29, 1); + if (!(rs.i32Rem(captured29, 2) === 0)) { return Guard.id(captured30) === 0; } return true; }, (): void => { captured30[Symbol.dispose](); }); - s = rt.stringRetain(s, everyOther); - const args34: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s)]; - Log.note(log, rt.fmtFormat(["every other ", args34[0]])); - s = rt.stringRetain(s, everyOther); - const args36: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtPad(f, s)]; - Log.note(log, rt.fmtFormat(["every other ", args36[0]])); - rt.drop(everyOther); + s = rs.stringRetain(s, everyOther); + const args34: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + Log.note(log, rs.fmtFormat(["every other ", args34[0]])); + s = rs.stringRetain(s, everyOther); + const args36: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtPad(f, s)]; + Log.note(log, rs.fmtFormat(["every other ", args36[0]])); + rs.drop(everyOther); const c3: Guard.Guard = guard(3); let empty: string = ""; const captured31 = c3; - const _427: (a0: rt.char) => boolean = rt.closure((_24: rt.char): boolean => { + const _427: (a0: rs.char) => boolean = rs.closure((_24: rs.char): boolean => { return Guard.id(captured31) > 0; }, (): void => { captured31[Symbol.dispose](); }); - empty = rt.stringRetain(empty, _427); - rt.drop(_427); - const args38: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtStr(empty, f)]; - Log.note(log, rt.fmtFormat(["empty ", args38[0]])); + empty = rs.stringRetain(empty, _427); + rs.drop(_427); + const args38: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtStr(empty, f)]; + Log.note(log, rs.fmtFormat(["empty ", args38[0]])); } else if (_8 === 3) { const a4: Guard.Guard = guard(1); - const captured25 = (c27: rt.char): boolean => { + const captured25 = (c27: rs.char): boolean => { if (!(c27 === 44)) { return c27 === 59; } return true; }; const captured26 = a4; - const f3: (a0: rt.char) => boolean = rt.closure((c28: rt.char): boolean => { + const f3: (a0: rs.char) => boolean = rs.closure((c28: rs.char): boolean => { if (!captured25(c28)) { return false; } @@ -535,67 +535,67 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured26[Symbol.dispose](); }); - const part7 = [rt.strContains(text, f3), rt.strFind(text, f3), rt.strRfind(text, f3)] as [boolean, rt.usize | undefined, rt.usize | undefined]; - const args40: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(part7[0], f), (f: rt.Formatter) => rt.fmtOption(part7[1], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(part7[2], f, rt.usizeDebug)], f)]; - Log.note(log, rt.fmtFormat(["contains ", args40[0]])); - const ends2: [boolean, boolean] = [rt.strStartsWith(text, f3), rt.strEndsWith(text, f3)]; - const stripped2: [string | undefined, string | undefined] = [rt.strStripPrefix(text, f3), rt.strStripSuffix(",a", f3)]; - const args42: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(ends2[0], f), (f: rt.Formatter) => rt.fmtBool(ends2[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(stripped2[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(stripped2[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["ends ", args42[0], " ", args42[1]])); - const once2: [[string, string] | undefined, [string, string] | undefined] = [rt.strSplitOnce(text, f3), rt.strRsplitOnce(text, f3)]; - const trimmed2: [string, string, string] = [rt.strTrimMatches(",a,", f3), rt.strTrimStartMatches(",a,", f3), rt.strTrimEndMatches(",a,", f3)]; - const replaced2: [string, string] = [rt.strReplace(text, f3, "+"), rt.strReplace(text, f3, "+", 2)]; - const args44: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(once2[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(once2[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(trimmed2[0], f), (f: rt.Formatter) => rt.fmtStr(trimmed2[1], f), (f: rt.Formatter) => rt.fmtStr(trimmed2[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(replaced2[0], f), (f: rt.Formatter) => rt.fmtStr(replaced2[1], f)], f)]; - Log.note(log, rt.fmtFormat(["once ", args44[0], " ", args44[1], " ", args44[2]])); - const split2: rt.Iter = rt.strSplit(text, rt.lent(f3)); - const _526: string | undefined = rt.iterToOption(split2.next()); - const _529: string | undefined = rt.iterToOption(split2.nextBack()); - const args46: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_526, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_529, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args46[0], " ", args46[1]])); - const rsplit2: rt.Vec = rt.iterToVec(rt.strRsplit(text, rt.lent(f3)), "next", 8); - const counts2: [rt.usize, string | undefined] = [rt.iterCount(rt.strSplitn(text, 2, rt.lent(f3))), rt.iterLast(rt.strRsplitn(text, 3, rt.lent(f3)))]; - const args48: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rsplit2.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(counts2[0], f), (f: rt.Formatter) => rt.fmtOption(counts2[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["rsplit ", args48[0], " ", args48[1]])); - const terminated2: [string | undefined, string | undefined] = [rt.iterNth(rt.strSplitTerminator(text, rt.lent(f3)), 3), rt.iterNth(rt.strRsplitTerminator(text, rt.lent(f3)), 1)]; - const inclusive2: rt.Vec = rt.iterToVec(rt.iterRev(rt.strSplitInclusive(text, rt.lent(f3))), "next", 8); - const args50: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(terminated2[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(terminated2[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtList(inclusive2.items, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["terminated ", args50[0], " ", args50[1]])); - const matched2: rt.Iter = rt.strMatches(text, rt.lent(f3)); - const last2: string | undefined = rt.iterToOption(rt.strRmatches(text, rt.lent(f3)).next()); - const _597: string | undefined = rt.iterToOption(matched2.next()); - const args52: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_597, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(last2, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["matches ", args52[0], " ", args52[1]])); - const part8 = [rt.iterNth(rt.strMatchIndices(text, rt.lent(f3)), 2), rt.iterToOption(rt.strRmatchIndices(text, rt.lent(f3)).next())] as [[rt.usize, string] | undefined, [rt.usize, string] | undefined]; - const args54: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(part8[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(part8[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rt.fmtFormat(["indices ", args54[0]])); - const parts: rt.Iter = rt.strSplit(text, rt.lent(f3)); + const part7 = [rs.strContains(text, f3), rs.strFind(text, f3), rs.strRfind(text, f3)] as [boolean, rs.usize | undefined, rs.usize | undefined]; + const args40: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part7[0], f), (f: rs.Formatter) => rs.fmtOption(part7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part7[2], f, rs.usizeDebug)], f)]; + Log.note(log, rs.fmtFormat(["contains ", args40[0]])); + const ends2: [boolean, boolean] = [rs.strStartsWith(text, f3), rs.strEndsWith(text, f3)]; + const stripped2: [string | undefined, string | undefined] = [rs.strStripPrefix(text, f3), rs.strStripSuffix(",a", f3)]; + const args42: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends2[0], f), (f: rs.Formatter) => rs.fmtBool(ends2[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped2[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["ends ", args42[0], " ", args42[1]])); + const once2: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f3), rs.strRsplitOnce(text, f3)]; + const trimmed2: [string, string, string] = [rs.strTrimMatches(",a,", f3), rs.strTrimStartMatches(",a,", f3), rs.strTrimEndMatches(",a,", f3)]; + const replaced2: [string, string] = [rs.strReplace(text, f3, "+"), rs.strReplace(text, f3, "+", 2)]; + const args44: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once2[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once2[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed2[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed2[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced2[0], f), (f: rs.Formatter) => rs.fmtStr(replaced2[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args44[0], " ", args44[1], " ", args44[2]])); + const split2: rs.Iter = rs.strSplit(text, rs.lent(f3)); + const _526: string | undefined = rs.iterToOption(split2.next()); + const _529: string | undefined = rs.iterToOption(split2.nextBack()); + const args46: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_526, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_529, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args46[0], " ", args46[1]])); + const rsplit2: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(f3)), "next", 8); + const counts2: [rs.usize, string | undefined] = [rs.iterCount(rs.strSplitn(text, 2, rs.lent(f3))), rs.iterLast(rs.strRsplitn(text, 3, rs.lent(f3)))]; + const args48: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts2[0], f), (f: rs.Formatter) => rs.fmtOption(counts2[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args48[0], " ", args48[1]])); + const terminated2: [string | undefined, string | undefined] = [rs.iterNth(rs.strSplitTerminator(text, rs.lent(f3)), 3), rs.iterNth(rs.strRsplitTerminator(text, rs.lent(f3)), 1)]; + const inclusive2: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(f3))), "next", 8); + const args50: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated2[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated2[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive2.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args50[0], " ", args50[1]])); + const matched2: rs.Iter = rs.strMatches(text, rs.lent(f3)); + const last2: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(f3)).next()); + const _597: string | undefined = rs.iterToOption(matched2.next()); + const args52: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_597, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last2, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args52[0], " ", args52[1]])); + const part8 = [rs.iterNth(rs.strMatchIndices(text, rs.lent(f3)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(f3)).next())] as [[rs.usize, string] | undefined, [rs.usize, string] | undefined]; + const args54: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(part8[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(part8[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["indices ", args54[0]])); + const parts: rs.Iter = rs.strSplit(text, rs.lent(f3)); parts.next(); - const rest: rt.Vec = rt.iterToVec(parts.clone(), "next", 8); - const _639: string | undefined = rt.iterToOption(parts.next()); - const args56: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rest.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_639, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["cloned ", args56[0], " ", args56[1]])); - const spaced: rt.Vec = rt.iterToVec(rt.strSplit("a b\tc", (a02: rt.char): boolean => { - return rt.charIsWhitespace(a02); + const rest: rs.Vec = rs.iterToVec(parts.clone(), "next", 8); + const _639: string | undefined = rs.iterToOption(parts.next()); + const args56: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rest.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_639, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["cloned ", args56[0], " ", args56[1]])); + const spaced: rs.Vec = rs.iterToVec(rs.strSplit("a b\tc", (a02: rs.char): boolean => { + return rs.charIsWhitespace(a02); }), "next", 8); const _659: boolean = f3(59); - const args58: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(spaced.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_659, f)]; - Log.note(log, rt.fmtFormat(["spaced ", args58[0], " ", args58[1]])); - rt.drop(f3); + const args58: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(spaced.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_659, f)]; + Log.note(log, rs.fmtFormat(["spaced ", args58[0], " ", args58[1]])); + rs.drop(f3); Log.note(log, "dropped"); } else if (_8 === 4) { const a5: Guard.Guard = guard(1); - let captured22: rt.i32 = 0; - const captured23 = (c25: rt.char): boolean => { + let captured22: rs.i32 = 0; + const captured23 = (c25: rs.char): boolean => { if (!(c25 === 44)) { return c25 === 59; } return true; }; const captured24 = a5; - const f4: (a0: rt.char) => boolean = rt.closure((c26: rt.char): boolean => { - captured22 = rt.i32Add(captured22, 1); + const f4: (a0: rs.char) => boolean = rs.closure((c26: rs.char): boolean => { + captured22 = rs.i32Add(captured22, 1); if (captured23(c26)) { - if (rt.i32Rem(captured22, 3) !== 0) { + if (rs.i32Rem(captured22, 3) !== 0) { return Guard.id(captured24) > 0; } } @@ -603,100 +603,100 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured24[Symbol.dispose](); }); - const found3: [boolean, rt.usize | undefined, rt.usize | undefined] = [rt.strContains(text, f4), rt.strFind(text, f4), rt.strRfind(text, f4)]; + const found3: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, f4), rs.strFind(text, f4), rs.strRfind(text, f4)]; const _689: boolean = f4(120); - const args60: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(found3[0], f), (f: rt.Formatter) => rt.fmtOption(found3[1], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(found3[2], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtBool(_689, f)]; - Log.note(log, rt.fmtFormat(["contains ", args60[0], " ", args60[1]])); - const ends3: [boolean, boolean] = [rt.strStartsWith(text, f4), rt.strEndsWith(text, f4)]; - const stripped3: [string | undefined, string | undefined] = [rt.strStripPrefix(",a", f4), rt.strStripSuffix(",a", f4)]; + const args60: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found3[0], f), (f: rs.Formatter) => rs.fmtOption(found3[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found3[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_689, f)]; + Log.note(log, rs.fmtFormat(["contains ", args60[0], " ", args60[1]])); + const ends3: [boolean, boolean] = [rs.strStartsWith(text, f4), rs.strEndsWith(text, f4)]; + const stripped3: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", f4), rs.strStripSuffix(",a", f4)]; const _716: boolean = f4(120); - const args62: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(ends3[0], f), (f: rt.Formatter) => rt.fmtBool(ends3[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(stripped3[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(stripped3[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtBool(_716, f)]; - Log.note(log, rt.fmtFormat(["ends ", args62[0], " ", args62[1], " ", args62[2]])); - const once3: [[string, string] | undefined, [string, string] | undefined] = [rt.strSplitOnce(text, f4), rt.strRsplitOnce(text, f4)]; - const trimmed3: [string, string] = [rt.strTrimMatches(",,a,,", f4), rt.strTrimStartMatches(",,a", f4)]; - const replaced3: [string, string] = [rt.strReplace(text, f4, "+"), rt.strReplace(text, f4, "+", 2)]; - const end: string = rt.strTrimEndMatches(",a,,", f4); + const args62: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends3[0], f), (f: rs.Formatter) => rs.fmtBool(ends3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_716, f)]; + Log.note(log, rs.fmtFormat(["ends ", args62[0], " ", args62[1], " ", args62[2]])); + const once3: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, f4), rs.strRsplitOnce(text, f4)]; + const trimmed3: [string, string] = [rs.strTrimMatches(",,a,,", f4), rs.strTrimStartMatches(",,a", f4)]; + const replaced3: [string, string] = [rs.strReplace(text, f4, "+"), rs.strReplace(text, f4, "+", 2)]; + const end: string = rs.strTrimEndMatches(",a,,", f4); const _755: boolean = f4(120); - const args64: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(once3[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(once3[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(trimmed3[0], f), (f: rt.Formatter) => rt.fmtStr(trimmed3[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(replaced3[0], f), (f: rt.Formatter) => rt.fmtStr(replaced3[1], f)], f), (f: rt.Formatter) => rt.fmtStr(end, f), (f: rt.Formatter) => rt.fmtBool(_755, f)]; - Log.note(log, rt.fmtFormat(["once ", args64[0], " ", args64[1], " ", args64[2], " ", args64[3], " ", args64[4]])); - const split3: rt.Iter = rt.strSplit(text, rt.lent(f4)); - const _778: string | undefined = rt.iterToOption(split3.next()); - const _781: string | undefined = rt.iterToOption(split3.nextBack()); - const args66: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_778, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_781, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args66[0], " ", args66[1]])); - const rsplit3: rt.Vec = rt.iterToVec(rt.strRsplit(text, rt.lent(f4)), "next", 8); - const n2: rt.usize = rt.iterCount(rt.strSplitn(text, 2, rt.lent(f4))); - const last3: string | undefined = rt.iterLast(rt.strRsplitn(text, 3, rt.lent(f4))); + const args64: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once3[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once3[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed3[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed3[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced3[0], f), (f: rs.Formatter) => rs.fmtStr(replaced3[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end, f), (f: rs.Formatter) => rs.fmtBool(_755, f)]; + Log.note(log, rs.fmtFormat(["once ", args64[0], " ", args64[1], " ", args64[2], " ", args64[3], " ", args64[4]])); + const split3: rs.Iter = rs.strSplit(text, rs.lent(f4)); + const _778: string | undefined = rs.iterToOption(split3.next()); + const _781: string | undefined = rs.iterToOption(split3.nextBack()); + const args66: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_778, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_781, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args66[0], " ", args66[1]])); + const rsplit3: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(f4)), "next", 8); + const n2: rs.usize = rs.iterCount(rs.strSplitn(text, 2, rs.lent(f4))); + const last3: string | undefined = rs.iterLast(rs.strRsplitn(text, 3, rs.lent(f4))); const _805: boolean = f4(120); - const args68: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rsplit3.items, f, rt.fmtStr), (f: rt.Formatter) => rt.usizeDisplay(n2, f), (f: rt.Formatter) => rt.fmtOption(last3, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_805, f)]; - Log.note(log, rt.fmtFormat(["rsplit ", args68[0], " ", args68[1], " ", args68[2], " ", args68[3]])); - const forward: string | undefined = rt.iterNth(rt.strSplitTerminator(text, rt.lent(f4)), 3); - const back: string | undefined = rt.iterNth(rt.strRsplitTerminator(text, rt.lent(f4)), 1); - const inclusive3: rt.Vec = rt.iterToVec(rt.iterRev(rt.strSplitInclusive(text, rt.lent(f4))), "next", 8); + const args68: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n2, f), (f: rs.Formatter) => rs.fmtOption(last3, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_805, f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args68[0], " ", args68[1], " ", args68[2], " ", args68[3]])); + const forward: string | undefined = rs.iterNth(rs.strSplitTerminator(text, rs.lent(f4)), 3); + const back: string | undefined = rs.iterNth(rs.strRsplitTerminator(text, rs.lent(f4)), 1); + const inclusive3: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(f4))), "next", 8); const _836: boolean = f4(120); - const args70: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(forward, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(back, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(inclusive3.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_836, f)]; - Log.note(log, rt.fmtFormat(["terminated ", args70[0], " ", args70[1], " ", args70[2], " ", args70[3]])); - const part6 = rt.iterToOption(rt.strMatches(text, rt.lent(f4)).next()); - const args72: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part6, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["matches ", args72[0]])); - const last4: string | undefined = rt.iterToOption(rt.strRmatches(text, rt.lent(f4)).next()); - const indices3: [[rt.usize, string] | undefined, [rt.usize, string] | undefined] = [rt.iterNth(rt.strMatchIndices(text, rt.lent(f4)), 2), rt.iterToOption(rt.strRmatchIndices(text, rt.lent(f4)).next())]; + const args70: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(forward, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_836, f)]; + Log.note(log, rs.fmtFormat(["terminated ", args70[0], " ", args70[1], " ", args70[2], " ", args70[3]])); + const part6 = rs.iterToOption(rs.strMatches(text, rs.lent(f4)).next()); + const args72: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part6, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args72[0]])); + const last4: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(f4)).next()); + const indices3: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, rs.lent(f4)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(f4)).next())]; const _884: boolean = f4(120); - const args74: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(last4, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(indices3[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(indices3[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtBool(_884, f)]; - Log.note(log, rt.fmtFormat(["indices ", args74[0], " ", args74[1], " ", args74[2]])); - let lent: (a0: rt.char) => boolean = f4; - const parts2: rt.Vec = rt.iterToVec(rt.strSplit(text, rt.lent(rt.place(() => lent, (value29) => lent = value29).v)), "next", 8); + const args74: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last4, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices3[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices3[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_884, f)]; + Log.note(log, rs.fmtFormat(["indices ", args74[0], " ", args74[1], " ", args74[2]])); + let lent: (a0: rs.char) => boolean = f4; + const parts2: rs.Vec = rs.iterToVec(rs.strSplit(text, rs.lent(rs.place(() => lent, (value29) => lent = value29).v)), "next", 8); const _905: boolean = f4(120); - const args76: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(parts2.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_905, f)]; - Log.note(log, rt.fmtFormat(["lent ", args76[0], " ", args76[1]])); - rt.drop(f4); + const args76: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(parts2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_905, f)]; + Log.note(log, rs.fmtFormat(["lent ", args76[0], " ", args76[1]])); + rs.drop(f4); Log.note(log, "dropped"); } else if (_8 === 5) { if (!(id < 4294967295)) { - p = (a0: rt.char): boolean => { - return rt.charIsWhitespace(a0); + p = (a0: rs.char): boolean => { + return rs.charIsWhitespace(a0); }; } else { p = isSep; } - const found4: [boolean, rt.usize | undefined, rt.usize | undefined] = [rt.strContains(text, p), rt.strFind(text, p), rt.strRfind(text, p)]; - const ends4: [boolean, boolean] = [rt.strStartsWith(text, p), rt.strEndsWith(text, p)]; - const stripped4: [string | undefined, string | undefined] = [rt.strStripPrefix(",a", p), rt.strStripSuffix(",a", p)]; - const args78: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(found4[0], f), (f: rt.Formatter) => rt.fmtOption(found4[1], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(found4[2], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(ends4[0], f), (f: rt.Formatter) => rt.fmtBool(ends4[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(stripped4[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(stripped4[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["contains ", args78[0], " ", args78[1], " ", args78[2]])); - const once4: [[string, string] | undefined, [string, string] | undefined] = [rt.strSplitOnce(text, p), rt.strRsplitOnce(text, p)]; - const trimmed4: [string, string, string] = [rt.strTrimMatches(",a,", p), rt.strTrimStartMatches(",a,", p), rt.strTrimEndMatches(",a,", p)]; - const replaced4: [string, string] = [rt.strReplace(text, p, "+"), rt.strReplace(text, p, "+", 2)]; - const args80: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(once4[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(once4[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(trimmed4[0], f), (f: rt.Formatter) => rt.fmtStr(trimmed4[1], f), (f: rt.Formatter) => rt.fmtStr(trimmed4[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(replaced4[0], f), (f: rt.Formatter) => rt.fmtStr(replaced4[1], f)], f)]; - Log.note(log, rt.fmtFormat(["once ", args80[0], " ", args80[1], " ", args80[2]])); - const split4: rt.Iter = rt.strSplit(text, p); - const _998: string | undefined = rt.iterToOption(split4.next()); - const _1001: string | undefined = rt.iterToOption(split4.nextBack()); - const args82: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_998, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1001, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args82[0], " ", args82[1]])); - const rsplit4: rt.Vec = rt.iterToVec(rt.strRsplit(text, p), "next", 8); - const counts3: [rt.usize, string | undefined] = [rt.iterCount(rt.strSplitn(text, 2, p)), rt.iterLast(rt.strRsplitn(text, 3, p))]; - const args84: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rsplit4.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(counts3[0], f), (f: rt.Formatter) => rt.fmtOption(counts3[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["rsplit ", args84[0], " ", args84[1]])); - const terminated3: [string | undefined, string | undefined] = [rt.iterNth(rt.strSplitTerminator(text, p), 3), rt.iterNth(rt.strRsplitTerminator(text, p), 1)]; - const inclusive4: rt.Vec = rt.iterToVec(rt.iterRev(rt.strSplitInclusive(text, p)), "next", 8); - const args86: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(terminated3[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(terminated3[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtList(inclusive4.items, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["terminated ", args86[0], " ", args86[1]])); - const matched4: [string | undefined, string | undefined] = [rt.iterToOption(rt.strMatches(text, p).next()), rt.iterToOption(rt.strRmatches(text, p).next())]; - const indices4: [[rt.usize, string] | undefined, [rt.usize, string] | undefined] = [rt.iterNth(rt.strMatchIndices(text, p), 2), rt.iterToOption(rt.strRmatchIndices(text, p).next())]; - const args88: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(matched4[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(matched4[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(indices4[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(indices4[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rt.fmtFormat(["matches ", args88[0], " ", args88[1]])); + const found4: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, p), rs.strFind(text, p), rs.strRfind(text, p)]; + const ends4: [boolean, boolean] = [rs.strStartsWith(text, p), rs.strEndsWith(text, p)]; + const stripped4: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", p), rs.strStripSuffix(",a", p)]; + const args78: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found4[0], f), (f: rs.Formatter) => rs.fmtOption(found4[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found4[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends4[0], f), (f: rs.Formatter) => rs.fmtBool(ends4[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped4[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["contains ", args78[0], " ", args78[1], " ", args78[2]])); + const once4: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, p), rs.strRsplitOnce(text, p)]; + const trimmed4: [string, string, string] = [rs.strTrimMatches(",a,", p), rs.strTrimStartMatches(",a,", p), rs.strTrimEndMatches(",a,", p)]; + const replaced4: [string, string] = [rs.strReplace(text, p, "+"), rs.strReplace(text, p, "+", 2)]; + const args80: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once4[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once4[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed4[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed4[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced4[0], f), (f: rs.Formatter) => rs.fmtStr(replaced4[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args80[0], " ", args80[1], " ", args80[2]])); + const split4: rs.Iter = rs.strSplit(text, p); + const _998: string | undefined = rs.iterToOption(split4.next()); + const _1001: string | undefined = rs.iterToOption(split4.nextBack()); + const args82: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_998, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1001, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args82[0], " ", args82[1]])); + const rsplit4: rs.Vec = rs.iterToVec(rs.strRsplit(text, p), "next", 8); + const counts3: [rs.usize, string | undefined] = [rs.iterCount(rs.strSplitn(text, 2, p)), rs.iterLast(rs.strRsplitn(text, 3, p))]; + const args84: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts3[0], f), (f: rs.Formatter) => rs.fmtOption(counts3[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args84[0], " ", args84[1]])); + const terminated3: [string | undefined, string | undefined] = [rs.iterNth(rs.strSplitTerminator(text, p), 3), rs.iterNth(rs.strRsplitTerminator(text, p), 1)]; + const inclusive4: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, p)), "next", 8); + const args86: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated3[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated3[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive4.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args86[0], " ", args86[1]])); + const matched4: [string | undefined, string | undefined] = [rs.iterToOption(rs.strMatches(text, p).next()), rs.iterToOption(rs.strRmatches(text, p).next())]; + const indices4: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, p), 2), rs.iterToOption(rs.strRmatchIndices(text, p).next())]; + const args88: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(matched4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(matched4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices4[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices4[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["matches ", args88[0], " ", args88[1]])); } else if (_8 === 6) { - const boxed: (a0: rt.u32) => (a0: rt.char) => boolean = (n5: rt.u32): (a0: rt.char) => boolean => { + const boxed: (a0: rs.u32) => (a0: rs.char) => boolean = (n5: rs.u32): (a0: rs.char) => boolean => { const g4: Guard.Guard = guard(n5); - const captured20 = (c22: rt.char): boolean => { + const captured20 = (c22: rs.char): boolean => { if (!(c22 === 44)) { return c22 === 59; } return true; }; const captured21 = g4; - return rt.closure((c23: rt.char): boolean => { + return rs.closure((c23: rs.char): boolean => { if (!captured20(c23)) { return false; } @@ -705,100 +705,100 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured21[Symbol.dispose](); }); }; - const _1090: (a0: rt.char) => boolean = boxed(1); - const _1094: (a0: rt.char) => boolean = boxed(2); - const _1098: (a0: rt.char) => boolean = boxed(3); - const part5 = [rt.dropAfter(_1090, () => rt.strContains(text, _1090)), rt.dropAfter(_1094, () => rt.strFind(text, _1094)), rt.dropAfter(_1098, () => rt.strRfind(text, _1098))] as [boolean, rt.usize | undefined, rt.usize | undefined]; - const args90: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(part5[0], f), (f: rt.Formatter) => rt.fmtOption(part5[1], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(part5[2], f, rt.usizeDebug)], f)]; - Log.note(log, rt.fmtFormat(["contains ", args90[0]])); - const _1113: (a0: rt.char) => boolean = boxed(4); - const _1117: (a0: rt.char) => boolean = boxed(5); + const _1090: (a0: rs.char) => boolean = boxed(1); + const _1094: (a0: rs.char) => boolean = boxed(2); + const _1098: (a0: rs.char) => boolean = boxed(3); + const part5 = [rs.dropAfter(_1090, () => rs.strContains(text, _1090)), rs.dropAfter(_1094, () => rs.strFind(text, _1094)), rs.dropAfter(_1098, () => rs.strRfind(text, _1098))] as [boolean, rs.usize | undefined, rs.usize | undefined]; + const args90: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(part5[0], f), (f: rs.Formatter) => rs.fmtOption(part5[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(part5[2], f, rs.usizeDebug)], f)]; + Log.note(log, rs.fmtFormat(["contains ", args90[0]])); + const _1113: (a0: rs.char) => boolean = boxed(4); + const _1117: (a0: rs.char) => boolean = boxed(5); const _1122: string = ",a"; - const _1123: (a0: rt.char) => boolean = boxed(6); + const _1123: (a0: rs.char) => boolean = boxed(6); const _1127: string = ",a"; - const _1128: (a0: rt.char) => boolean = boxed(7); - const ends5: [boolean, boolean] = [rt.dropAfter(_1113, () => rt.strStartsWith(text, _1113)), rt.dropAfter(_1117, () => rt.strEndsWith(text, _1117))]; - const stripped5: [string | undefined, string | undefined] = [rt.dropAfter(_1123, () => rt.strStripPrefix(_1122, _1123)), rt.dropAfter(_1128, () => rt.strStripSuffix(_1127, _1128))]; - const args92: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(ends5[0], f), (f: rt.Formatter) => rt.fmtBool(ends5[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(stripped5[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(stripped5[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["ends ", args92[0], " ", args92[1]])); - const _1145: (a0: rt.char) => boolean = boxed(8); - const _1149: (a0: rt.char) => boolean = boxed(9); + const _1128: (a0: rs.char) => boolean = boxed(7); + const ends5: [boolean, boolean] = [rs.dropAfter(_1113, () => rs.strStartsWith(text, _1113)), rs.dropAfter(_1117, () => rs.strEndsWith(text, _1117))]; + const stripped5: [string | undefined, string | undefined] = [rs.dropAfter(_1123, () => rs.strStripPrefix(_1122, _1123)), rs.dropAfter(_1128, () => rs.strStripSuffix(_1127, _1128))]; + const args92: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends5[0], f), (f: rs.Formatter) => rs.fmtBool(ends5[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped5[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped5[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["ends ", args92[0], " ", args92[1]])); + const _1145: (a0: rs.char) => boolean = boxed(8); + const _1149: (a0: rs.char) => boolean = boxed(9); const _1154: string = ",a,"; - const _1155: (a0: rt.char) => boolean = boxed(10); + const _1155: (a0: rs.char) => boolean = boxed(10); const _1159: string = ",a,"; - const _1160: (a0: rt.char) => boolean = boxed(11); + const _1160: (a0: rs.char) => boolean = boxed(11); const _1164: string = ",a,"; - const _1165: (a0: rt.char) => boolean = boxed(12); - const _1170: (a0: rt.char) => boolean = boxed(13); + const _1165: (a0: rs.char) => boolean = boxed(12); + const _1170: (a0: rs.char) => boolean = boxed(13); const _1173: string = "+"; - const _1175: (a0: rt.char) => boolean = boxed(14); + const _1175: (a0: rs.char) => boolean = boxed(14); const _1178: string = "+"; - const once5: [[string, string] | undefined, [string, string] | undefined] = [rt.dropAfter(_1145, () => rt.strSplitOnce(text, _1145)), rt.dropAfter(_1149, () => rt.strRsplitOnce(text, _1149))]; - const trimmed5: [string, string, string] = [rt.dropAfter(_1155, () => rt.strTrimMatches(_1154, _1155)), rt.dropAfter(_1160, () => rt.strTrimStartMatches(_1159, _1160)), rt.dropAfter(_1165, () => rt.strTrimEndMatches(_1164, _1165))]; - const replaced5: [string, string] = [rt.dropAfter(_1170, () => rt.strReplace(text, _1170, _1173)), rt.dropAfter(_1175, () => rt.strReplace(text, _1175, _1178, 2))]; - const args94: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(once5[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(once5[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(trimmed5[0], f), (f: rt.Formatter) => rt.fmtStr(trimmed5[1], f), (f: rt.Formatter) => rt.fmtStr(trimmed5[2], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(replaced5[0], f), (f: rt.Formatter) => rt.fmtStr(replaced5[1], f)], f)]; - Log.note(log, rt.fmtFormat(["once ", args94[0], " ", args94[1], " ", args94[2]])); - const split5: rt.Iter = rt.strSplit(text, boxed(15)); - const _1203: string | undefined = rt.iterToOption(split5.next()); - const _1206: string | undefined = rt.iterToOption(split5.nextBack()); - const args96: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1203, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1206, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args96[0], " ", args96[1]])); - rt.drop(split5); - const rsplit5: rt.Vec = rt.iterToVec(rt.strRsplit(text, boxed(16)), "next", 8); - const counts4: [rt.usize, string | undefined] = [rt.ownedCount(rt.strSplitn(text, 2, boxed(17))), rt.ownedLast(rt.strRsplitn(text, 3, boxed(18)))]; - const args98: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rsplit5.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(counts4[0], f), (f: rt.Formatter) => rt.fmtOption(counts4[1], f, rt.fmtStr)], f)]; - Log.note(log, rt.fmtFormat(["rsplit ", args98[0], " ", args98[1]])); - const _1246: rt.Iter = rt.strSplitTerminator(text, boxed(19)); - const _1244: string | undefined = rt.iterNth(_1246, 3); - const _1252: rt.Iter = rt.strRsplitTerminator(text, boxed(20)); - const terminated4: [string | undefined, string | undefined] = [_1244, rt.iterNth(_1252, 1)]; - rt.drop(_1252); - rt.drop(_1246); - const inclusive5: rt.Vec = rt.iterToVec(rt.iterRev(rt.strSplitInclusive(text, boxed(21))), "next", 8); - const args100: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(terminated4[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(terminated4[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtList(inclusive5.items, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["terminated ", args100[0], " ", args100[1]])); - const matched5: rt.Iter = rt.strMatches(text, boxed(22)); - const _1280: rt.Iter = rt.strRmatches(text, boxed(23)); - const last5: string | undefined = rt.iterToOption(_1280.next()); - rt.drop(_1280); - const _1290: string | undefined = rt.iterToOption(matched5.next()); - const args102: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1290, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(last5, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["matches ", args102[0], " ", args102[1]])); - rt.drop(matched5); - const _1303: rt.Iter<[rt.usize, string]> = rt.strMatchIndices(text, boxed(24)); - const _1301: [rt.usize, string] | undefined = rt.iterNth(_1303, 2); - const _1309: rt.Iter<[rt.usize, string]> = rt.strRmatchIndices(text, boxed(25)); - const indices5: [[rt.usize, string] | undefined, [rt.usize, string] | undefined] = [_1301, rt.iterToOption(_1309.next())]; - rt.drop(_1309); - rt.drop(_1303); - const args104: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(indices5[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(indices5[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f)]; - Log.note(log, rt.fmtFormat(["indices ", args104[0]])); - const split6: rt.Iter = rt.strSplit(text, isSep); - const _1327: (a0: rt.char) => boolean = (c24: rt.char): boolean => { + const once5: [[string, string] | undefined, [string, string] | undefined] = [rs.dropAfter(_1145, () => rs.strSplitOnce(text, _1145)), rs.dropAfter(_1149, () => rs.strRsplitOnce(text, _1149))]; + const trimmed5: [string, string, string] = [rs.dropAfter(_1155, () => rs.strTrimMatches(_1154, _1155)), rs.dropAfter(_1160, () => rs.strTrimStartMatches(_1159, _1160)), rs.dropAfter(_1165, () => rs.strTrimEndMatches(_1164, _1165))]; + const replaced5: [string, string] = [rs.dropAfter(_1170, () => rs.strReplace(text, _1170, _1173)), rs.dropAfter(_1175, () => rs.strReplace(text, _1175, _1178, 2))]; + const args94: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once5[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once5[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed5[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[1], f), (f: rs.Formatter) => rs.fmtStr(trimmed5[2], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced5[0], f), (f: rs.Formatter) => rs.fmtStr(replaced5[1], f)], f)]; + Log.note(log, rs.fmtFormat(["once ", args94[0], " ", args94[1], " ", args94[2]])); + const split5: rs.Iter = rs.strSplit(text, boxed(15)); + const _1203: string | undefined = rs.iterToOption(split5.next()); + const _1206: string | undefined = rs.iterToOption(split5.nextBack()); + const args96: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1203, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1206, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args96[0], " ", args96[1]])); + rs.drop(split5); + const rsplit5: rs.Vec = rs.iterToVec(rs.strRsplit(text, boxed(16)), "next", 8); + const counts4: [rs.usize, string | undefined] = [rs.ownedCount(rs.strSplitn(text, 2, boxed(17))), rs.ownedLast(rs.strRsplitn(text, 3, boxed(18)))]; + const args98: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit5.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(counts4[0], f), (f: rs.Formatter) => rs.fmtOption(counts4[1], f, rs.fmtStr)], f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args98[0], " ", args98[1]])); + const _1246: rs.Iter = rs.strSplitTerminator(text, boxed(19)); + const _1244: string | undefined = rs.iterNth(_1246, 3); + const _1252: rs.Iter = rs.strRsplitTerminator(text, boxed(20)); + const terminated4: [string | undefined, string | undefined] = [_1244, rs.iterNth(_1252, 1)]; + rs.drop(_1252); + rs.drop(_1246); + const inclusive5: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, boxed(21))), "next", 8); + const args100: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(terminated4[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(terminated4[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtList(inclusive5.items, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["terminated ", args100[0], " ", args100[1]])); + const matched5: rs.Iter = rs.strMatches(text, boxed(22)); + const _1280: rs.Iter = rs.strRmatches(text, boxed(23)); + const last5: string | undefined = rs.iterToOption(_1280.next()); + rs.drop(_1280); + const _1290: string | undefined = rs.iterToOption(matched5.next()); + const args102: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1290, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(last5, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args102[0], " ", args102[1]])); + rs.drop(matched5); + const _1303: rs.Iter<[rs.usize, string]> = rs.strMatchIndices(text, boxed(24)); + const _1301: [rs.usize, string] | undefined = rs.iterNth(_1303, 2); + const _1309: rs.Iter<[rs.usize, string]> = rs.strRmatchIndices(text, boxed(25)); + const indices5: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [_1301, rs.iterToOption(_1309.next())]; + rs.drop(_1309); + rs.drop(_1303); + const args104: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices5[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices5[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f)]; + Log.note(log, rs.fmtFormat(["indices ", args104[0]])); + const split6: rs.Iter = rs.strSplit(text, isSep); + const _1327: (a0: rs.char) => boolean = (c24: rs.char): boolean => { if (!(c24 === 44)) { return c24 === 59; } return true; }; - const found6: boolean = rt.dropAfter(_1327, () => rt.strContains(text, _1327)); - const _1335: string | undefined = rt.iterToOption(split6.next()); - const args106: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1335, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(found6, f)]; - Log.note(log, rt.fmtFormat(["plain ", args106[0], " ", args106[1]])); - rt.drop(split6); + const found6: boolean = rs.dropAfter(_1327, () => rs.strContains(text, _1327)); + const _1335: string | undefined = rs.iterToOption(split6.next()); + const args106: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1335, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(found6, f)]; + Log.note(log, rs.fmtFormat(["plain ", args106[0], " ", args106[1]])); + rs.drop(split6); } else if (_8 === 7) { const a6: Guard.Guard = guard(1); - let captured17: rt.i32 = 0; - const captured18 = (c20: rt.char): boolean => { + let captured17: rs.i32 = 0; + const captured18 = (c20: rs.char): boolean => { if (!(c20 === 44)) { return c20 === 59; } return true; }; const captured19 = a6; - let b4: (a0: rt.char) => boolean = rt.closure((c21: rt.char): boolean => { - captured17 = rt.i32Add(captured17, 1); + let b4: (a0: rs.char) => boolean = rs.closure((c21: rs.char): boolean => { + captured17 = rs.i32Add(captured17, 1); if (captured18(c21)) { - if (rt.i32Rem(captured17, 3) !== 0) { + if (rs.i32Rem(captured17, 3) !== 0) { return Guard.id(captured19) > 0; } } @@ -806,48 +806,48 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured19[Symbol.dispose](); }); - const found7: [boolean, rt.usize | undefined, rt.usize | undefined] = [rt.strContains(text, rt.place(() => b4, (value4) => b4 = value4).v), rt.strFind(text, rt.place(() => b4, (value5) => b4 = value5).v), rt.strRfind(text, rt.place(() => b4, (value6) => b4 = value6).v)]; + const found7: [boolean, rs.usize | undefined, rs.usize | undefined] = [rs.strContains(text, rs.place(() => b4, (value4) => b4 = value4).v), rs.strFind(text, rs.place(() => b4, (value5) => b4 = value5).v), rs.strRfind(text, rs.place(() => b4, (value6) => b4 = value6).v)]; const _1364: boolean = b4(120); - const args108: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(found7[0], f), (f: rt.Formatter) => rt.fmtOption(found7[1], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtOption(found7[2], f, rt.usizeDebug)], f), (f: rt.Formatter) => rt.fmtBool(_1364, f)]; - Log.note(log, rt.fmtFormat(["contains ", args108[0], " ", args108[1]])); - const ends6: [boolean, boolean] = [rt.strStartsWith(text, rt.place(() => b4, (value7) => b4 = value7).v), rt.strEndsWith(text, rt.place(() => b4, (value8) => b4 = value8).v)]; - const stripped6: [string | undefined, string | undefined] = [rt.strStripPrefix(",a", rt.place(() => b4, (value9) => b4 = value9).v), rt.strStripSuffix(",a", rt.place(() => b4, (value10) => b4 = value10).v)]; + const args108: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(found7[0], f), (f: rs.Formatter) => rs.fmtOption(found7[1], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtOption(found7[2], f, rs.usizeDebug)], f), (f: rs.Formatter) => rs.fmtBool(_1364, f)]; + Log.note(log, rs.fmtFormat(["contains ", args108[0], " ", args108[1]])); + const ends6: [boolean, boolean] = [rs.strStartsWith(text, rs.place(() => b4, (value7) => b4 = value7).v), rs.strEndsWith(text, rs.place(() => b4, (value8) => b4 = value8).v)]; + const stripped6: [string | undefined, string | undefined] = [rs.strStripPrefix(",a", rs.place(() => b4, (value9) => b4 = value9).v), rs.strStripSuffix(",a", rs.place(() => b4, (value10) => b4 = value10).v)]; const _1391: boolean = b4(120); - const args110: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(ends6[0], f), (f: rt.Formatter) => rt.fmtBool(ends6[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(stripped6[0], f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(stripped6[1], f, rt.fmtStr)], f), (f: rt.Formatter) => rt.fmtBool(_1391, f)]; - Log.note(log, rt.fmtFormat(["ends ", args110[0], " ", args110[1], " ", args110[2]])); - const once6: [[string, string] | undefined, [string, string] | undefined] = [rt.strSplitOnce(text, rt.place(() => b4, (value11) => b4 = value11).v), rt.strRsplitOnce(text, rt.place(() => b4, (value12) => b4 = value12).v)]; - const trimmed6: [string, string] = [rt.strTrimMatches(",,a,,", rt.place(() => b4, (value13) => b4 = value13).v), rt.strTrimStartMatches(",,a", rt.place(() => b4, (value14) => b4 = value14).v)]; - const replaced6: [string, string] = [rt.strReplace(text, rt.place(() => b4, (value15) => b4 = value15).v, "+"), rt.strReplace(text, rt.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; - const end2: string = rt.strTrimEndMatches(",a,,", rt.place(() => b4, (value17) => b4 = value17).v); + const args110: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(ends6[0], f), (f: rs.Formatter) => rs.fmtBool(ends6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(stripped6[0], f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(stripped6[1], f, rs.fmtStr)], f), (f: rs.Formatter) => rs.fmtBool(_1391, f)]; + Log.note(log, rs.fmtFormat(["ends ", args110[0], " ", args110[1], " ", args110[2]])); + const once6: [[string, string] | undefined, [string, string] | undefined] = [rs.strSplitOnce(text, rs.place(() => b4, (value11) => b4 = value11).v), rs.strRsplitOnce(text, rs.place(() => b4, (value12) => b4 = value12).v)]; + const trimmed6: [string, string] = [rs.strTrimMatches(",,a,,", rs.place(() => b4, (value13) => b4 = value13).v), rs.strTrimStartMatches(",,a", rs.place(() => b4, (value14) => b4 = value14).v)]; + const replaced6: [string, string] = [rs.strReplace(text, rs.place(() => b4, (value15) => b4 = value15).v, "+"), rs.strReplace(text, rs.place(() => b4, (value16) => b4 = value16).v, "+", 2)]; + const end2: string = rs.strTrimEndMatches(",a,,", rs.place(() => b4, (value17) => b4 = value17).v); const _1430: boolean = b4(120); - const args112: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(once6[0], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(once6[1], f, (value: [string, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(trimmed6[0], f), (f: rt.Formatter) => rt.fmtStr(trimmed6[1], f)], f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtStr(replaced6[0], f), (f: rt.Formatter) => rt.fmtStr(replaced6[1], f)], f), (f: rt.Formatter) => rt.fmtStr(end2, f), (f: rt.Formatter) => rt.fmtBool(_1430, f)]; - Log.note(log, rt.fmtFormat(["once ", args112[0], " ", args112[1], " ", args112[2], " ", args112[3], " ", args112[4]])); - const split7: rt.Iter = rt.strSplit(text, rt.lent(rt.place(() => b4, (value18) => b4 = value18).v)); - const _1453: string | undefined = rt.iterToOption(split7.next()); - const _1456: string | undefined = rt.iterToOption(split7.nextBack()); - const args114: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1453, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1456, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args114[0], " ", args114[1]])); - const rsplit6: rt.Vec = rt.iterToVec(rt.strRsplit(text, rt.lent(rt.place(() => b4, (value19) => b4 = value19).v)), "next", 8); - const n3: rt.usize = rt.iterCount(rt.strSplitn(text, 2, rt.lent(rt.place(() => b4, (value20) => b4 = value20).v))); - const last6: string | undefined = rt.iterLast(rt.strRsplitn(text, 3, rt.lent(rt.place(() => b4, (value21) => b4 = value21).v))); + const args112: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(once6[0], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(once6[1], f, (value: [string, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(trimmed6[0], f), (f: rs.Formatter) => rs.fmtStr(trimmed6[1], f)], f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtStr(replaced6[0], f), (f: rs.Formatter) => rs.fmtStr(replaced6[1], f)], f), (f: rs.Formatter) => rs.fmtStr(end2, f), (f: rs.Formatter) => rs.fmtBool(_1430, f)]; + Log.note(log, rs.fmtFormat(["once ", args112[0], " ", args112[1], " ", args112[2], " ", args112[3], " ", args112[4]])); + const split7: rs.Iter = rs.strSplit(text, rs.lent(rs.place(() => b4, (value18) => b4 = value18).v)); + const _1453: string | undefined = rs.iterToOption(split7.next()); + const _1456: string | undefined = rs.iterToOption(split7.nextBack()); + const args114: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1453, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1456, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args114[0], " ", args114[1]])); + const rsplit6: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(rs.place(() => b4, (value19) => b4 = value19).v)), "next", 8); + const n3: rs.usize = rs.iterCount(rs.strSplitn(text, 2, rs.lent(rs.place(() => b4, (value20) => b4 = value20).v))); + const last6: string | undefined = rs.iterLast(rs.strRsplitn(text, 3, rs.lent(rs.place(() => b4, (value21) => b4 = value21).v))); const _1480: boolean = b4(120); - const args116: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rsplit6.items, f, rt.fmtStr), (f: rt.Formatter) => rt.usizeDisplay(n3, f), (f: rt.Formatter) => rt.fmtOption(last6, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_1480, f)]; - Log.note(log, rt.fmtFormat(["rsplit ", args116[0], " ", args116[1], " ", args116[2], " ", args116[3]])); - const forward2: string | undefined = rt.iterNth(rt.strSplitTerminator(text, rt.lent(rt.place(() => b4, (value22) => b4 = value22).v)), 3); - const back2: string | undefined = rt.iterNth(rt.strRsplitTerminator(text, rt.lent(rt.place(() => b4, (value23) => b4 = value23).v)), 1); - const inclusive6: rt.Vec = rt.iterToVec(rt.iterRev(rt.strSplitInclusive(text, rt.lent(rt.place(() => b4, (value24) => b4 = value24).v))), "next", 8); + const args116: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rsplit6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.usizeDisplay(n3, f), (f: rs.Formatter) => rs.fmtOption(last6, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1480, f)]; + Log.note(log, rs.fmtFormat(["rsplit ", args116[0], " ", args116[1], " ", args116[2], " ", args116[3]])); + const forward2: string | undefined = rs.iterNth(rs.strSplitTerminator(text, rs.lent(rs.place(() => b4, (value22) => b4 = value22).v)), 3); + const back2: string | undefined = rs.iterNth(rs.strRsplitTerminator(text, rs.lent(rs.place(() => b4, (value23) => b4 = value23).v)), 1); + const inclusive6: rs.Vec = rs.iterToVec(rs.iterRev(rs.strSplitInclusive(text, rs.lent(rs.place(() => b4, (value24) => b4 = value24).v))), "next", 8); const _1511: boolean = b4(120); - const args118: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(forward2, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(back2, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtList(inclusive6.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_1511, f)]; - Log.note(log, rt.fmtFormat(["terminated ", args118[0], " ", args118[1], " ", args118[2], " ", args118[3]])); - const part4 = rt.iterToOption(rt.strMatches(text, rt.lent(rt.place(() => b4, (value25) => b4 = value25).v)).next()); - const args120: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part4, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["matches ", args120[0]])); - const last7: string | undefined = rt.iterToOption(rt.strRmatches(text, rt.lent(rt.place(() => b4, (value26) => b4 = value26).v)).next()); - const indices6: [[rt.usize, string] | undefined, [rt.usize, string] | undefined] = [rt.iterNth(rt.strMatchIndices(text, rt.lent(rt.place(() => b4, (value27) => b4 = value27).v)), 2), rt.iterToOption(rt.strRmatchIndices(text, rt.lent(rt.place(() => b4, (value28) => b4 = value28).v)).next())]; + const args118: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(forward2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(back2, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtList(inclusive6.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1511, f)]; + Log.note(log, rs.fmtFormat(["terminated ", args118[0], " ", args118[1], " ", args118[2], " ", args118[3]])); + const part4 = rs.iterToOption(rs.strMatches(text, rs.lent(rs.place(() => b4, (value25) => b4 = value25).v)).next()); + const args120: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part4, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["matches ", args120[0]])); + const last7: string | undefined = rs.iterToOption(rs.strRmatches(text, rs.lent(rs.place(() => b4, (value26) => b4 = value26).v)).next()); + const indices6: [[rs.usize, string] | undefined, [rs.usize, string] | undefined] = [rs.iterNth(rs.strMatchIndices(text, rs.lent(rs.place(() => b4, (value27) => b4 = value27).v)), 2), rs.iterToOption(rs.strRmatchIndices(text, rs.lent(rs.place(() => b4, (value28) => b4 = value28).v)).next())]; const _1559: boolean = b4(120); - const args122: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(last7, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(indices6[0], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f)), (f: rt.Formatter) => rt.fmtOption(indices6[1], f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))], f), (f: rt.Formatter) => rt.fmtBool(_1559, f)]; - Log.note(log, rt.fmtFormat(["indices ", args122[0], " ", args122[1], " ", args122[2]])); - rt.drop(b4); + const args122: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(last7, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(indices6[0], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f)), (f: rs.Formatter) => rs.fmtOption(indices6[1], f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))], f), (f: rs.Formatter) => rs.fmtBool(_1559, f)]; + Log.note(log, rs.fmtFormat(["indices ", args122[0], " ", args122[1], " ", args122[2]])); + rs.drop(b4); Log.note(log, "dropped"); } else { const _1578: [Guard.Guard, Guard.Guard, Guard.Guard] = [guard(1), guard(2), guard(3)]; @@ -855,7 +855,7 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { const b5: Guard.Guard = _1578[1]; const c4: Guard.Guard = _1578[2]; const captured = a7; - const _1589: (a0: rt.char) => boolean = rt.closure((c6: rt.char): boolean => { + const _1589: (a0: rs.char) => boolean = rs.closure((c6: rs.char): boolean => { if (!(c6 === 59)) { return false; } @@ -863,15 +863,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured[Symbol.dispose](); }); - const found8: boolean = rt.dropAfter(_1589, () => rt.strContains(text, _1589)); - const captured2 = (c7: rt.char): boolean => { + const found8: boolean = rs.dropAfter(_1589, () => rs.strContains(text, _1589)); + const captured2 = (c7: rs.char): boolean => { if (!(c7 === 44)) { return c7 === 59; } return true; }; const captured3 = b5; - const _1592: (a0: rt.char) => boolean = rt.closure((c8: rt.char): boolean => { + const _1592: (a0: rs.char) => boolean = rs.closure((c8: rs.char): boolean => { if (!captured2(c8)) { return false; } @@ -879,15 +879,15 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured3[Symbol.dispose](); }); - const at: rt.usize | undefined = rt.dropAfter(_1592, () => rt.strRfind(text, _1592)); - const captured4 = (c9: rt.char): boolean => { + const at: rs.usize | undefined = rs.dropAfter(_1592, () => rs.strRfind(text, _1592)); + const captured4 = (c9: rs.char): boolean => { if (!(c9 === 44)) { return c9 === 59; } return true; }; const captured5 = c4; - const _1595: (a0: rt.char) => boolean = rt.closure((ch: rt.char): boolean => { + const _1595: (a0: rs.char) => boolean = rs.closure((ch: rs.char): boolean => { if (!captured4(ch)) { return false; } @@ -896,18 +896,18 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { captured5[Symbol.dispose](); }); const _1597: string = "+"; - const replaced7: string = rt.dropAfter(_1595, () => rt.strReplace(text, _1595, _1597, 2)); - const args124: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(found8, f), (f: rt.Formatter) => rt.fmtOption(at, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtPad(f, replaced7)]; - Log.note(log, rt.fmtFormat(["contains ", args124[0], " ", args124[1], " ", args124[2]])); + const replaced7: string = rs.dropAfter(_1595, () => rs.strReplace(text, _1595, _1597, 2)); + const args124: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(found8, f), (f: rs.Formatter) => rs.fmtOption(at, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtPad(f, replaced7)]; + Log.note(log, rs.fmtFormat(["contains ", args124[0], " ", args124[1], " ", args124[2]])); const d3: Guard.Guard = guard(4); - const captured6 = (c10: rt.char): boolean => { + const captured6 = (c10: rs.char): boolean => { if (!(c10 === 44)) { return c10 === 59; } return true; }; const captured7 = d3; - const split8: rt.Iter = rt.strSplit(text, rt.closure((c11: rt.char): boolean => { + const split8: rs.Iter = rs.strSplit(text, rs.closure((c11: rs.char): boolean => { if (!captured6(c11)) { return false; } @@ -915,20 +915,20 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured7[Symbol.dispose](); })); - const _1624: string | undefined = rt.iterToOption(split8.next()); - const _1627: string | undefined = rt.iterToOption(split8.nextBack()); - const args126: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1624, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1627, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["split ", args126[0], " ", args126[1]])); - rt.drop(split8); + const _1624: string | undefined = rs.iterToOption(split8.next()); + const _1627: string | undefined = rs.iterToOption(split8.nextBack()); + const args126: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1624, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1627, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["split ", args126[0], " ", args126[1]])); + rs.drop(split8); const e3: Guard.Guard = guard(5); - const captured8 = (c12: rt.char): boolean => { + const captured8 = (c12: rs.char): boolean => { if (!(c12 === 44)) { return c12 === 59; } return true; }; const captured9 = e3; - const part2 = rt.iterToVec(rt.strRmatchIndices(text, rt.closure((c13: rt.char): boolean => { + const part2 = rs.iterToVec(rs.strRmatchIndices(text, rs.closure((c13: rs.char): boolean => { if (!captured8(c13)) { return false; } @@ -936,21 +936,21 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured9[Symbol.dispose](); })), "next", 12); - const args128: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(part2.items, f, (value: [rt.usize, string], f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.usizeDebug(value[0], f), (f: rt.Formatter) => rt.fmtStr(value[1], f)], f))]; - Log.note(log, rt.fmtFormat(["indices ", args128[0]])); + const args128: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(part2.items, f, (value: [rs.usize, string], f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.usizeDebug(value[0], f), (f: rs.Formatter) => rs.fmtStr(value[1], f)], f))]; + Log.note(log, rs.fmtFormat(["indices ", args128[0]])); const f5: Guard.Guard = guard(6); - let captured10: rt.i32 = 0; - const captured11 = (c14: rt.char): boolean => { + let captured10: rs.i32 = 0; + const captured11 = (c14: rs.char): boolean => { if (!(c14 === 44)) { return c14 === 59; } return true; }; const captured12 = f5; - let counted: (a0: rt.char) => boolean = rt.closure((c15: rt.char): boolean => { - captured10 = rt.i32Add(captured10, 1); + let counted: (a0: rs.char) => boolean = rs.closure((c15: rs.char): boolean => { + captured10 = rs.i32Add(captured10, 1); if (captured11(c15)) { - if (rt.i32Rem(captured10, 2) === 0) { + if (rs.i32Rem(captured10, 2) === 0) { return Guard.id(captured12) > 0; } } @@ -958,44 +958,44 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured12[Symbol.dispose](); }); - const found9: [rt.usize | undefined, boolean] = [rt.strFind(text, rt.place(() => counted, (value) => counted = value).v), rt.strContains(text, rt.place(() => counted, (value2) => counted = value2).v)]; - const parts3: rt.Vec = rt.iterToVec(rt.strSplit(text, rt.lent(rt.place(() => counted, (value3) => counted = value3).v)), "next", 8); + const found9: [rs.usize | undefined, boolean] = [rs.strFind(text, rs.place(() => counted, (value) => counted = value).v), rs.strContains(text, rs.place(() => counted, (value2) => counted = value2).v)]; + const parts3: rs.Vec = rs.iterToVec(rs.strSplit(text, rs.lent(rs.place(() => counted, (value3) => counted = value3).v)), "next", 8); const _1672: boolean = counted(120); - const args130: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtOption(found9[0], f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtBool(found9[1], f)], f), (f: rt.Formatter) => rt.fmtList(parts3.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtBool(_1672, f)]; - Log.note(log, rt.fmtFormat(["counted ", args130[0], " ", args130[1], " ", args130[2]])); - rt.drop(counted); - const make = (captured13: rt.i32, captured14: (a0: rt.char) => boolean): (a0: rt.char) => boolean => { - return rt.cloning((c17: rt.char): boolean => { - captured13 = rt.i32Add(captured13, 1); + const args130: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtOption(found9[0], f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtBool(found9[1], f)], f), (f: rs.Formatter) => rs.fmtList(parts3.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtBool(_1672, f)]; + Log.note(log, rs.fmtFormat(["counted ", args130[0], " ", args130[1], " ", args130[2]])); + rs.drop(counted); + const make = (captured13: rs.i32, captured14: (a0: rs.char) => boolean): (a0: rs.char) => boolean => { + return rs.cloning((c17: rs.char): boolean => { + captured13 = rs.i32Add(captured13, 1); if (!captured14(c17)) { return false; } return captured13 !== 2; }, () => make(captured13, captured14)); }; - const split9: rt.Iter = rt.strSplit(text, make(0, (c16: rt.char): boolean => { + const split9: rs.Iter = rs.strSplit(text, make(0, (c16: rs.char): boolean => { if (!(c16 === 44)) { return c16 === 59; } return true; })); - const cloned: rt.Iter = split9.clone({ f: rt.closureClone }); - const part3 = rt.iterToOption(split9.next()); - const args132: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(part3, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["first ", args132[0]])); - const rest2: rt.Vec = rt.iterToVec(cloned, "next", 8); - const _1709: string | undefined = rt.iterToOption(split9.next()); - const args134: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(rest2.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1709, f, rt.fmtStr)]; - Log.note(log, rt.fmtFormat(["cloned ", args134[0], " ", args134[1]])); + const cloned: rs.Iter = split9.clone({ f: rs.closureClone }); + const part3 = rs.iterToOption(split9.next()); + const args132: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(part3, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["first ", args132[0]])); + const rest2: rs.Vec = rs.iterToVec(cloned, "next", 8); + const _1709: string | undefined = rs.iterToOption(split9.next()); + const args134: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(rest2.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1709, f, rs.fmtStr)]; + Log.note(log, rs.fmtFormat(["cloned ", args134[0], " ", args134[1]])); const g3: Guard.Guard = guard(7); - const captured15 = (c18: rt.char): boolean => { + const captured15 = (c18: rs.char): boolean => { if (!(c18 === 44)) { return c18 === 59; } return true; }; const captured16 = g3; - const shared: (a0: rt.char) => boolean = rt.closure((c19: rt.char): boolean => { + const shared: (a0: rs.char) => boolean = rs.closure((c19: rs.char): boolean => { if (!captured15(c19)) { return false; } @@ -1003,18 +1003,18 @@ export function searched(log: Log.Log, id: rt.u32, arg: rt.u8): void { }, (): void => { captured16[Symbol.dispose](); }); - const parts4: rt.Vec = rt.iterToVec(rt.strRsplit(text, rt.lent(shared)), "next", 8); - const p2: (a0: rt.char) => boolean = isSep; - const _1736: rt.usize | undefined = rt.strRfind(text, shared); - const _1739: rt.usize | undefined = rt.strFind(text, p2); - const args136: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(_1736, f, rt.usizeDebug), (f: rt.Formatter) => rt.fmtList(parts4.items, f, rt.fmtStr), (f: rt.Formatter) => rt.fmtOption(_1739, f, rt.usizeDebug)]; - Log.note(log, rt.fmtFormat(["shared ", args136[0], " ", args136[1], " ", args136[2]])); - rt.drop(shared); + const parts4: rs.Vec = rs.iterToVec(rs.strRsplit(text, rs.lent(shared)), "next", 8); + const p2: (a0: rs.char) => boolean = isSep; + const _1736: rs.usize | undefined = rs.strRfind(text, shared); + const _1739: rs.usize | undefined = rs.strFind(text, p2); + const args136: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(_1736, f, rs.usizeDebug), (f: rs.Formatter) => rs.fmtList(parts4.items, f, rs.fmtStr), (f: rs.Formatter) => rs.fmtOption(_1739, f, rs.usizeDebug)]; + Log.note(log, rs.fmtFormat(["shared ", args136[0], " ", args136[1], " ", args136[2]])); + rs.drop(shared); Log.note(log, "dropped"); } } -export function isSep(c: rt.char): boolean { +export function isSep(c: rs.char): boolean { if (!(c === 44)) { return c === 59; } diff --git a/ts/fixtures/task/expected/futures.Forward.ts b/ts/fixtures/task/expected/futures.Forward.ts index 8971a5eda..2b5c7452b 100644 --- a/ts/fixtures/task/expected/futures.Forward.ts +++ b/ts/fixtures/task/expected/futures.Forward.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** * A future of the crate's that forwards its polls to a boxed one, as moq's session * driver does. */ export class Forward { - future: rt.Future; + future: rs.Future; - constructor(future: rt.Future) { + constructor(future: rs.Future) { this.future = future; } [Symbol.dispose](): void { - rt.drop(this.future); + rs.drop(this.future); } } -export function poll$Future(self: Forward, cx: rt.Context): rt.Poll { +export function poll$Future(self: Forward, cx: rs.Context): rs.Poll { return self.future.poll(cx); } diff --git a/ts/fixtures/task/expected/futures.Plain.ts b/ts/fixtures/task/expected/futures.Plain.ts index bbd8a0a8c..cd3a39615 100644 --- a/ts/fixtures/task/expected/futures.Plain.ts +++ b/ts/fixtures/task/expected/futures.Plain.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Relay from "./futures.Relay.ts"; import * as Guard from "./model.Guard.ts"; @@ -17,7 +17,7 @@ export class Plain { } } -export function wake$task_Wake(self: rt.Arc): void { +export function wake$task_Wake(self: rs.Arc): void { Guard.note(self.value._0.guard, "plain wake"); self.value._0.task.wakeByRef(); self[Symbol.dispose](); diff --git a/ts/fixtures/task/expected/futures.Relay.ts b/ts/fixtures/task/expected/futures.Relay.ts index 2e4e0b31a..f9c61cc94 100644 --- a/ts/fixtures/task/expected/futures.Relay.ts +++ b/ts/fixtures/task/expected/futures.Relay.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Guard from "./model.Guard.ts"; /** Wakes `task`, logging through `guard`, which logs the relay's drop. */ export class Relay { - task: rt.Waker; + task: rs.Waker; guard: Guard.Guard; - constructor(task: rt.Waker, guard: Guard.Guard) { + constructor(task: rs.Waker, guard: Guard.Guard) { this.task = task; this.guard = guard; } @@ -19,13 +19,13 @@ export class Relay { } } -export function wake$task_Wake(self: rt.Arc): void { +export function wake$task_Wake(self: rs.Arc): void { Guard.note(self.value.guard, "relay wake"); self.value.task.wakeByRef(); self[Symbol.dispose](); } -export function wakeByRef$task_Wake(self: rt.Arc): void { +export function wakeByRef$task_Wake(self: rs.Arc): void { Guard.note(self.value.guard, "relay wake_by_ref"); self.value.task.wakeByRef(); } diff --git a/ts/fixtures/task/expected/futures.ts b/ts/fixtures/task/expected/futures.ts index 4cc07c668..b81588340 100644 --- a/ts/fixtures/task/expected/futures.ts +++ b/ts/fixtures/task/expected/futures.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker as lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker } from "./lib.ts"; -import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, okOr$03aiwur as option_okOr$03aiwur } from "./core/option.ts"; -import { map$034yafl as poll_map$034yafl, map$1vdv176 as poll_map$1vdv176, map$1ooj6xj as poll_map$1ooj6xj, isReady$0entgvk, isPending$0vr1nz6, isPending$1xsrr9j, mapOk$051v09m, mapErr$1yfeuu2 as poll_mapErr$1yfeuu2 } from "./core/task/poll.ts"; +import { unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, okOr$1fxnv80 as option_okOr$1fxnv80 } from "./core/option.ts"; +import { map$124wjfo as poll_map$124wjfo, map$1a7g3ip as poll_map$1a7g3ip, map$1a7lmes as poll_map$1a7lmes, isReady$1wybfmi, isPending$0mrvg1b, isPending$04edpij, mapOk$0q2t3zp, mapErr$1s7wmg4 as poll_mapErr$1s7wmg4 } from "./core/task/poll.ts"; import * as Forward from "./futures.Forward.ts"; import * as Plain from "./futures.Plain.ts"; import * as Relay from "./futures.Relay.ts"; @@ -13,7 +13,7 @@ import * as Pending from "./kio.Pending.ts"; import type * as Waiter from "./kio.Waiter.ts"; import * as Log from "./log.Log.ts"; import * as Guard from "./model.Guard.ts"; -import { set$0mfcep2, replace$05l9d6x } from "./std/thread/local.ts"; +import { set$0ftsz7h, replace$0onyq3t } from "./std/thread/local.ts"; /** * Every value until the channel closes, summed through std's helpers: a pinned `recv` @@ -25,7 +25,7 @@ import { set$0mfcep2, replace$05l9d6x } from "./std/thread/local.ts"; * value of 77. First, a `poll_fn` of a borrowed function drops in an `Arc` without * dropping the function. */ -export function helpers(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function helpers(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new helpersFuture(rx, guard); } @@ -33,11 +33,11 @@ export class helpersFuture { #state: number = 0; #rx: Consumer.Consumer; #guard: Guard.Guard; - #lend!: (a0: rt.Context) => rt.Poll; - #total!: rt.u64; - #pinned!: rt.Future; - #pinned$2!: rt.Future; - #awaitee!: rt.Future>; + #lend!: (a0: rs.Context) => rs.Poll; + #total!: rs.u64; + #pinned!: rs.Future; + #pinned$2!: rs.Future; + #awaitee!: rs.Future>; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { this.#rx = rx; @@ -50,87 +50,87 @@ export class helpersFuture { this.#guard[Symbol.dispose](); } else if (this.#state === 3) { this.#awaitee[Symbol.dispose](); - rt.drop(this.#pinned$2); + rs.drop(this.#pinned$2); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { - let _51!: rt.u64; + poll(_2: rs.Context): rs.Poll { + let _51!: rs.u64; let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - const captured = Guard.new(rt.u32Add(Guard.id(this.#guard), 900), Log.clone$Clone(Guard.log(this.#guard))); - this.#lend = rt.closure((_23: rt.Context): rt.Poll => { + const captured = Guard.new(rs.u32Add(Guard.id(this.#guard), 900), Log.clone$Clone(Guard.log(this.#guard))); + this.#lend = rs.closure((_23: rs.Context): rs.Poll => { return Guard.id(captured); }, (): void => { captured[Symbol.dispose](); }); - new rt.Arc(new rt.PollFn(this.#lend))[Symbol.dispose](); + new rs.Arc(new rs.PollFn(this.#lend))[Symbol.dispose](); Guard.note(this.#guard, "lent"); - rt.drop(this.#lend); + rs.drop(this.#lend); this.#total = 0; bb0 = 11; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 23; continue; } case 11: - const owned: Guard.Guard = Guard.new(rt.u32Add(Guard.id(this.#guard), 500), Log.clone$Clone(Guard.log(this.#guard))); - this.#pinned = rt.NEVER; - const never: rt.Future = this.#pinned; + const owned: Guard.Guard = Guard.new(rs.u32Add(Guard.id(this.#guard), 500), Log.clone$Clone(Guard.log(this.#guard))); + this.#pinned = rs.NEVER; + const never: rs.Future = this.#pinned; this.#pinned$2 = new recvFuture$kio_Consumer(this.#rx); - const next: rt.Future = this.#pinned$2; + const next: rs.Future = this.#pinned$2; let captured2 = never; - let captured3 = undefined as rt.Waker | undefined; + let captured3 = undefined as rs.Waker | undefined; const captured4 = owned; let captured5 = next; const captured6 = this.#total; - this.#awaitee = new rt.PollFn(rt.closure((cx: rt.Context): rt.Poll> => { - const waiting: rt.Poll = captured2.poll(rt.NOOP_WAKER); + this.#awaitee = new rs.PollFn(rs.closure((cx: rs.Context): rs.Poll> => { + const waiting: rs.Poll = captured2.poll(rs.NOOP_WAKER); if (captured3 === undefined) { - const _11: rt.Waker | undefined = relayed(cx, Log.clone$Clone(Guard.log(captured4)), rt.u32Add(Guard.id(captured4), 100)); - rt.drop(captured3); + const _11: rs.Waker | undefined = relayed(cx, Log.clone$Clone(Guard.log(captured4)), rs.u32Add(Guard.id(captured4), 100)); + rs.drop(captured3); captured3 = _11; } - const relay2: rt.Waker = rt.optionUnwrap(captured3); - const polled: rt.Poll = captured5.poll(relay2); - const _392: boolean = isPending$1xsrr9j(waiting); - const _422: boolean = isReady$0entgvk(polled); - const _45: boolean = isPending$0vr1nz6(polled); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(_392, f), (f: rt.Formatter) => rt.fmtBool(_422, f), (f: rt.Formatter) => rt.fmtBool(_45, f)]; - Guard.note(captured4, rt.fmtFormat(["pending ", args2[0], " ready ", args2[1], " pending ", args2[2]])); - if (polled !== rt.Pending) { + const relay2: rs.Waker = rs.optionUnwrap(captured3); + const polled: rs.Poll = captured5.poll(relay2); + const _392: boolean = isPending$04edpij(waiting); + const _422: boolean = isReady$1wybfmi(polled); + const _45: boolean = isPending$0mrvg1b(polled); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(_392, f), (f: rs.Formatter) => rs.fmtBool(_422, f), (f: rs.Formatter) => rs.fmtBool(_45, f)]; + Guard.note(captured4, rs.fmtFormat(["pending ", args2[0], " ready ", args2[1], " pending ", args2[2]])); + if (polled !== rs.Pending) { if (polled !== undefined) { - if (rt.u64Rem(polled, 2) === 0) { + if (rs.u64Rem(polled, 2) === 0) { relay2.clone().wake(); } } } - return poll_mapErr$1yfeuu2(mapOk$051v09m(poll_map$034yafl(polled, (value3: rt.u64 | undefined): rt.Result => { - return option_okOr$03aiwur(value3, captured6); - }), (value4: rt.u64): rt.u64 => { - return rt.u64Mul(value4, 2); - }), (total: rt.u64): rt.u64 => { - return rt.u64Add(total, 1); + return poll_mapErr$1s7wmg4(mapOk$0q2t3zp(poll_map$124wjfo(polled, (value3: rs.u64 | undefined): rs.Result => { + return option_okOr$1fxnv80(value3, captured6); + }), (value4: rs.u64): rs.u64 => { + return rs.u64Mul(value4, 2); + }), (total: rs.u64): rs.u64 => { + return rs.u64Add(total, 1); }); }, (): void => { - rt.drop(captured3); + rs.drop(captured3); captured4[Symbol.dispose](); - }), rt.drop); + }), rs.drop); bb0 = 23; continue; case 23: - const _39: rt.Poll> = this.#awaitee.poll(_2); - if (_39 !== rt.Pending) { - const read: rt.Result = _39; + const _39: rs.Poll> = this.#awaitee.poll(_2); + if (_39 !== rs.Pending) { + const read: rs.Result = _39; this.#awaitee[Symbol.dispose](); if (read.ok) { if (read.value === 154) { @@ -138,8 +138,8 @@ export class helpersFuture { bb0 = 36; continue; } - this.#total = rt.u64Add(this.#total, read.value); - rt.drop(this.#pinned$2); + this.#total = rs.u64Add(this.#total, read.value); + rs.drop(this.#pinned$2); bb0 = 11; continue; } @@ -148,9 +148,9 @@ export class helpersFuture { continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 36: - rt.drop(this.#pinned$2); + rs.drop(this.#pinned$2); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); this.#state = 1; @@ -164,42 +164,42 @@ export class helpersFuture { * A waker relaying to `task`, through a `Wake` impl with its own `wake_by_ref` for an * even `id`, and `Wake`'s default otherwise. */ -export function relayed(task: rt.Waker, log: Log.Log, id: rt.u32): rt.Waker { +export function relayed(task: rs.Waker, log: Log.Log, id: rs.u32): rs.Waker { const relay: Relay.Relay = new Relay.Relay(task.clone(), Guard.new(id, log)); - if (rt.u32Rem(id, 2) === 0) { - return rt.arcWaker(new rt.Arc(relay), Relay.wake$task_Wake as (a0: rt.Arc) => undefined, (arc2: rt.Arc) => arc2[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rt.Arc) => undefined); + if (rs.u32Rem(id, 2) === 0) { + return rs.arcWaker(new rs.Arc(relay), Relay.wake$task_Wake as (a0: rs.Arc) => undefined, (arc2: rs.Arc) => arc2[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rs.Arc) => undefined); } - return rt.arcWaker(new rt.Arc(new Plain.Plain(relay)), Plain.wake$task_Wake as (a0: rt.Arc) => undefined, (arc: rt.Arc) => arc[Symbol.dispose]()); + return rs.arcWaker(new rs.Arc(new Plain.Plain(relay)), Plain.wake$task_Wake as (a0: rs.Arc) => undefined, (arc: rs.Arc) => arc[Symbol.dispose]()); } -export const POLLING: rt.LocalKey, rt.WakerVTable] | undefined>> = /* @__PURE__ */ new rt.LocalKey(POLLING$init, false); +export const POLLING: rs.LocalKey, rs.WakerVTable] | undefined>> = /* @__PURE__ */ new rs.LocalKey(POLLING$init, false); -export function POLLING$init(): rt.Cell<[rt.Place, rt.WakerVTable] | undefined> { - return new rt.Cell(undefined as [rt.Place, rt.WakerVTable] | undefined); +export function POLLING$init(): rs.Cell<[rs.Place, rs.WakerVTable] | undefined> { + return new rs.Cell(undefined as [rs.Place, rs.WakerVTable] | undefined); } /** Run `poll` as the task `waker` wakes, as kio's `Polling::run` does. */ -export function run$task_Poll_Option_u64_futures_wakers_closure0_closure1_closure0(waker: rt.Waker, poll: () => rt.Poll): rt.Poll { - const outer: [rt.Place, rt.WakerVTable] | undefined = replace$05l9d6x(POLLING, [waker.data as rt.Place, waker.vtable] as [rt.Place, rt.WakerVTable]); - const output: rt.Poll = poll(); - set$0mfcep2(POLLING, outer); +export function run$task_Poll_Option_u64_futures_wakers_closure0_closure1_closure0(waker: rs.Waker, poll: () => rs.Poll): rs.Poll { + const outer: [rs.Place, rs.WakerVTable] | undefined = replace$0onyq3t(POLLING, [waker.data as rs.Place, waker.vtable] as [rs.Place, rs.WakerVTable]); + const output: rs.Poll = poll(); + set$0ftsz7h(POLLING, outer); return output; } /** Run `poll` as the task `waker` wakes, as kio's `Polling::run` does. */ -export function run$tuple2_bool_bool_futures_wakers_closure0_closure1_closure0_closure0(waker: rt.Waker, poll: () => [boolean, boolean]): [boolean, boolean] { - const outer: [rt.Place, rt.WakerVTable] | undefined = replace$05l9d6x(POLLING, [waker.data as rt.Place, waker.vtable] as [rt.Place, rt.WakerVTable]); +export function run$tuple2_bool_bool_futures_wakers_closure0_closure1_closure0_closure0(waker: rs.Waker, poll: () => [boolean, boolean]): [boolean, boolean] { + const outer: [rs.Place, rs.WakerVTable] | undefined = replace$0onyq3t(POLLING, [waker.data as rs.Place, waker.vtable] as [rs.Place, rs.WakerVTable]); const output: [boolean, boolean] = poll(); - set$0mfcep2(POLLING, outer); + set$0ftsz7h(POLLING, outer); return output; } /** Whether `waker` is the one the innermost `run` holds, as kio's `Polling::hold` asks. */ -export function polling(waker: rt.Waker): boolean { - return ((polling: rt.Cell<[rt.Place, rt.WakerVTable] | undefined>): boolean => { - const _4: [rt.Place, rt.WakerVTable] | undefined = polling.v; - const _6: [rt.Place, rt.WakerVTable] | undefined = [waker.data as rt.Place, waker.vtable]; - return rt.eqOption(rt.eqTuple([rt.same, rt.same]))(_4, _6); +export function polling(waker: rs.Waker): boolean { + return ((polling: rs.Cell<[rs.Place, rs.WakerVTable] | undefined>): boolean => { + const _4: [rs.Place, rs.WakerVTable] | undefined = polling.v; + const _6: [rs.Place, rs.WakerVTable] | undefined = [waker.data as rs.Place, waker.vtable]; + return rs.eqOption(rs.eqTuple([rs.same, rs.same]))(_4, _6); })(POLLING.get()); } @@ -213,7 +213,7 @@ export function polling(waker: rt.Waker): boolean { * puts both in one codegen unit, as a non-incremental build does and an incremental one * may not. The executor's vtable is a `static`, so its clones compare reliably. */ -export function wakers(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function wakers(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new wakersFuture(rx, guard); } @@ -221,19 +221,19 @@ export class wakersFuture { #state: number = 0; #rx: Consumer.Consumer; #guard: Guard.Guard; - #relay!: (a0: rt.u32) => Relay.Relay; - #one!: rt.Arc; - #a!: rt.Waker; - #b!: rt.Waker; - #other!: rt.Waker; - #plain!: rt.Waker; - #noop!: rt.Waker; + #relay!: (a0: rs.u32) => Relay.Relay; + #one!: rs.Arc; + #a!: rs.Waker; + #b!: rs.Waker; + #other!: rs.Waker; + #plain!: rs.Waker; + #noop!: rs.Waker; #checks!: boolean[]; - #last!: [rt.Place, rt.WakerVTable] | undefined; - #total!: rt.u64; - #next!: rt.Future; - #pinned!: rt.Future; - #awaitee!: rt.Future; + #last!: [rs.Place, rs.WakerVTable] | undefined; + #total!: rs.u64; + #next!: rs.Future; + #pinned!: rs.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { this.#rx = rx; @@ -245,44 +245,44 @@ export class wakersFuture { this.#rx[Symbol.dispose](); this.#guard[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#pinned); + rs.drop(this.#pinned); this.#one[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - this.#relay = (id: rt.u32): Relay.Relay => { - return new Relay.Relay(rt.NOOP_WAKER.clone(), Guard.new(rt.u32Add(Guard.id(this.#guard), id), Log.clone$Clone(Guard.log(this.#guard)))); + this.#relay = (id: rs.u32): Relay.Relay => { + return new Relay.Relay(rs.NOOP_WAKER.clone(), Guard.new(rs.u32Add(Guard.id(this.#guard), id), Log.clone$Clone(Guard.log(this.#guard)))); }; - this.#one = new rt.Arc(this.#relay(100)); - const _7: [rt.Waker, rt.Waker] = [rt.arcWaker(rt.arcClone(this.#one), Relay.wake$task_Wake as (a0: rt.Arc) => undefined, (arc: rt.Arc) => arc[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rt.Arc) => undefined), rt.arcWaker(rt.arcClone(this.#one), Relay.wake$task_Wake as (a0: rt.Arc) => undefined, (arc2: rt.Arc) => arc2[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rt.Arc) => undefined)]; + this.#one = new rs.Arc(this.#relay(100)); + const _7: [rs.Waker, rs.Waker] = [rs.arcWaker(rs.arcClone(this.#one), Relay.wake$task_Wake as (a0: rs.Arc) => undefined, (arc: rs.Arc) => arc[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rs.Arc) => undefined), rs.arcWaker(rs.arcClone(this.#one), Relay.wake$task_Wake as (a0: rs.Arc) => undefined, (arc2: rs.Arc) => arc2[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rs.Arc) => undefined)]; this.#a = _7[0]; this.#b = _7[1]; - this.#other = rt.arcWaker(new rt.Arc(this.#relay(200)), Relay.wake$task_Wake as (a0: rt.Arc) => undefined, (arc3: rt.Arc) => arc3[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rt.Arc) => undefined); - this.#plain = rt.arcWaker(new rt.Arc(new Plain.Plain(this.#relay(300))), Plain.wake$task_Wake as (a0: rt.Arc) => undefined, (arc4: rt.Arc) => arc4[Symbol.dispose]()); - this.#noop = rt.NOOP_WAKER; - this.#checks = [rt.willWake(this.#a, this.#b), (this.#a.data as rt.Place) === this.#b.data as rt.Place, rt.willWake(this.#a, this.#other), (this.#a.data as rt.Place) === this.#other.data as rt.Place, this.#a.vtable === this.#other.vtable, this.#a.vtable === this.#plain.vtable, rt.willWake(this.#a, this.#noop), rt.willWake(this.#noop, rt.NOOP_WAKER), (this.#noop.data as rt.Place) === rt.NULL, rt.NULL === rt.DANGLING_UNIT, rt.DANGLING_UNIT === rt.DANGLING_UNIT, rt.DANGLING_UNIT === rt.DANGLING_UNIT, rt.DANGLING_UNIT === rt.DANGLING_UNIT]; - put$unit(rt.DANGLING_UNIT, undefined); - put$unit(rt.DANGLING_UNIT, undefined); + this.#other = rs.arcWaker(new rs.Arc(this.#relay(200)), Relay.wake$task_Wake as (a0: rs.Arc) => undefined, (arc3: rs.Arc) => arc3[Symbol.dispose](), Relay.wakeByRef$task_Wake as (a0: rs.Arc) => undefined); + this.#plain = rs.arcWaker(new rs.Arc(new Plain.Plain(this.#relay(300))), Plain.wake$task_Wake as (a0: rs.Arc) => undefined, (arc4: rs.Arc) => arc4[Symbol.dispose]()); + this.#noop = rs.NOOP_WAKER; + this.#checks = [rs.willWake(this.#a, this.#b), (this.#a.data as rs.Place) === this.#b.data as rs.Place, rs.willWake(this.#a, this.#other), (this.#a.data as rs.Place) === this.#other.data as rs.Place, this.#a.vtable === this.#other.vtable, this.#a.vtable === this.#plain.vtable, rs.willWake(this.#a, this.#noop), rs.willWake(this.#noop, rs.NOOP_WAKER), (this.#noop.data as rs.Place) === rs.NULL, rs.NULL === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT, rs.DANGLING_UNIT === rs.DANGLING_UNIT]; + put$unit(rs.DANGLING_UNIT, undefined); + put$unit(rs.DANGLING_UNIT, undefined); const arg = this.#checks; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtList(arg, f, rt.fmtBool)]; - const _88: string = rt.fmtFormat(["wakers ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtList(arg, f, rs.fmtBool)]; + const _88: string = rs.fmtFormat(["wakers ", args2[0]]); Guard.note(this.#guard, _88); - lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker([this.#a, this.#b, this.#other, this.#plain] as [rt.Waker, rt.Waker, rt.Waker, rt.Waker]); - this.#last = undefined as [rt.Place, rt.WakerVTable] | undefined; + lib_drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker([this.#a, this.#b, this.#other, this.#plain] as [rs.Waker, rs.Waker, rs.Waker, rs.Waker]); + this.#last = undefined as [rs.Place, rs.WakerVTable] | undefined; this.#total = 0; bb0 = 57; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 62; continue; @@ -290,25 +290,25 @@ export class wakersFuture { case 57: this.#pinned = new recvFuture$kio_Consumer(this.#rx); this.#next = this.#pinned; - const _132: rt.Waker = this.#noop; - this.#awaitee = new rt.PollFn((cx: rt.Context): rt.Poll => { - const waker: rt.Waker = cx; - const _83: [rt.Place, rt.WakerVTable] | undefined = [waker.data as rt.Place, waker.vtable]; - const same: boolean = rt.eqOption(rt.eqTuple([rt.same, rt.same]))(this.#last, _83); - this.#last = [waker.data as rt.Place, waker.vtable] as [rt.Place, rt.WakerVTable]; - return run$task_Poll_Option_u64_futures_wakers_closure0_closure1_closure0(waker, (): rt.Poll => { - const clone: rt.Waker = waker.clone(); - const lent: rt.Context = clone; + const _132: rs.Waker = this.#noop; + this.#awaitee = new rs.PollFn((cx: rs.Context): rs.Poll => { + const waker: rs.Waker = cx; + const _83: [rs.Place, rs.WakerVTable] | undefined = [waker.data as rs.Place, waker.vtable]; + const same: boolean = rs.eqOption(rs.eqTuple([rs.same, rs.same]))(this.#last, _83); + this.#last = [waker.data as rs.Place, waker.vtable] as [rs.Place, rs.WakerVTable]; + return run$task_Poll_Option_u64_futures_wakers_closure0_closure1_closure0(waker, (): rs.Poll => { + const clone: rs.Waker = waker.clone(); + const lent: rs.Context = clone; const inner: [boolean, boolean] = run$tuple2_bool_bool_futures_wakers_closure0_closure1_closure0_closure0(_132, (): [boolean, boolean] => { return [polling(_132), polling(waker)] as [boolean, boolean]; }); const _153: boolean = polling(clone); - const _183: boolean = rt.willWake(lent, waker); + const _183: boolean = rs.willWake(lent, waker); const _222: boolean = polling(waker); - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(same, f), (f: rt.Formatter) => rt.fmtBool(_153, f), (f: rt.Formatter) => rt.fmtBool(_183, f), (f: rt.Formatter) => rt.fmtTuple([(f: rt.Formatter) => rt.fmtBool(inner[0], f), (f: rt.Formatter) => rt.fmtBool(inner[1], f)], f), (f: rt.Formatter) => rt.fmtBool(_222, f)]; - const _85: string = rt.fmtFormat(["same ", args4[0], " clone ", args4[1], " lent ", args4[2], " inner ", args4[3], " after ", args4[4]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(same, f), (f: rs.Formatter) => rs.fmtBool(_153, f), (f: rs.Formatter) => rs.fmtBool(_183, f), (f: rs.Formatter) => rs.fmtTuple([(f: rs.Formatter) => rs.fmtBool(inner[0], f), (f: rs.Formatter) => rs.fmtBool(inner[1], f)], f), (f: rs.Formatter) => rs.fmtBool(_222, f)]; + const _85: string = rs.fmtFormat(["same ", args4[0], " clone ", args4[1], " lent ", args4[2], " inner ", args4[3], " after ", args4[4]]); Guard.note(this.#guard, _85); - const _04: rt.Poll = this.#next.poll(cx); + const _04: rs.Poll = this.#next.poll(cx); clone[Symbol.dispose](); return _04; }); @@ -316,44 +316,44 @@ export class wakersFuture { bb0 = 62; continue; case 62: - const _114: rt.Poll = this.#awaitee.poll(_2); - if (_114 !== rt.Pending) { - const value: rt.u64 | undefined = _114; + const _114: rs.Poll = this.#awaitee.poll(_2); + if (_114 !== rs.Pending) { + const value: rs.u64 | undefined = _114; if (value === undefined) { - const _126: rt.u64 = this.#total; - rt.drop(this.#pinned); + const _126: rs.u64 = this.#total; + rs.drop(this.#pinned); this.#one[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); this.#state = 1; return _126; } - this.#total = rt.u64Add(this.#total, value); - rt.drop(this.#pinned); + this.#total = rs.u64Add(this.#total, value); + rs.drop(this.#pinned); bb0 = 57; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } } /** Write `value` through `slot`, which a dangling pointer to `()` may give. */ -export function put$Pin_boxed_Box_future_PollFn_futures_owning_closure0(slot: rt.Future, value: rt.Future): void { +export function put$Pin_boxed_Box_future_PollFn_futures_owning_closure0(slot: rs.Future, value: rs.Future): void { slot[Symbol.dispose](); - rt.ptrWrite(slot, value); + rs.ptrWrite(slot, value); } /** Write `value` through `slot`, which a dangling pointer to `()` may give. */ -export function put$future_PollFn_futures_owning_closure0(slot: rt.Future, value: rt.Future): void { +export function put$future_PollFn_futures_owning_closure0(slot: rs.Future, value: rs.Future): void { slot[Symbol.dispose](); - rt.ptrWrite(slot, value); + rs.ptrWrite(slot, value); } /** Write `value` through `slot`, which a dangling pointer to `()` may give. */ -export function put$unit(slot: rt.Place, _: undefined): void { +export function put$unit(slot: rs.Place, _: undefined): void { slot.v = undefined; } @@ -369,7 +369,7 @@ export function put$unit(slot: rt.Place, _: undefined): void { * Future` of the crate's struct last. A cancel drops the futures the queue still holds, * in order. */ -export function boxed(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function boxed(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new boxedFuture(rx, guard); } @@ -377,21 +377,21 @@ export class boxedFuture { #state: number = 0; #rx: Consumer.Consumer; #guard: Guard.Guard; - #first!: rt.u64; - #awaitee!: rt.Future; - #id!: rt.u32; + #first!: rs.u64; + #awaitee!: rs.Future; + #id!: rs.u32; #log!: Log.Log; - #lend!: rt.Future; - #awaitee$2!: rt.Future; - #saved!: rt.u64; - #awaitee$3!: rt.Future; - #awaitee$4!: rt.Future; - #other!: rt.Future; - #old!: rt.Future; - #boxed!: rt.Future; - #moved!: rt.u64; - #awaitee$5!: rt.Future; - #pinned!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + #lend!: rs.Future; + #awaitee$2!: rs.Future; + #saved!: rs.u64; + #awaitee$3!: rs.Future; + #awaitee$4!: rs.Future; + #other!: rs.Future; + #old!: rs.Future; + #boxed!: rs.Future; + #moved!: rs.u64; + #awaitee$5!: rs.Future; + #pinned!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>; #awaitee$6!: Forward.Forward; #saved$2!: boolean; #saved$3!: boolean; @@ -413,15 +413,15 @@ export class boxedFuture { return; } if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); break b0; } if (this.#state === 4) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); break b1; } if (this.#state === 5) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b1; } if (this.#state === 6 || this.#state === 7) { @@ -467,7 +467,7 @@ export class boxedFuture { this.#saved$6 = false; } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { b1: { b2: { @@ -486,7 +486,7 @@ export class boxedFuture { this.#saved$6 = true; this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { if (this.#state === 4) { break b8; @@ -514,202 +514,202 @@ export class boxedFuture { } break b0; } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const result: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); - this.#first = option_unwrapOr$1tvry1i(result, 0); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const result: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); + this.#first = option_unwrapOr$15hbiwd(result, 0); const arg = this.#first; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg, f)]; - const _17: string = rt.fmtFormat(["first ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; + const _17: string = rs.fmtFormat(["first ", args2[0]]); Guard.note(this.#guard, _17); - const _28: [rt.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; + const _28: [rs.u32, Log.Log] = [Guard.id(this.#guard), Log.clone$Clone(Guard.log(this.#guard))]; this.#id = _28[0]; this.#log = _28[1]; - const captured = Guard.new(rt.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); - this.#lend = new rt.PollFn(rt.closure((_22: rt.Context): rt.Poll => { + const captured = Guard.new(rs.u32Add(this.#id, 900), Log.clone$Clone(this.#log)); + this.#lend = new rs.PollFn(rs.closure((_22: rs.Context): rs.Poll => { Guard.note(captured, "lent"); return 4; }, (): void => { captured[Symbol.dispose](); - }), rt.drop); + }), rs.drop); this.#saved$5 = true; - this.#awaitee$2 = new rt.DynFuture(this.#lend, rt.futurePoll); + this.#awaitee$2 = new rs.DynFuture(this.#lend, rs.futurePoll); } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _45: rt.Poll = this.#awaitee$2.poll(_2); - if (_45 !== rt.Pending) { - const lent2: rt.u64 = _45; - rt.drop(this.#awaitee$2); + const _45: rs.Poll = this.#awaitee$2.poll(_2); + if (_45 !== rs.Pending) { + const lent2: rs.u64 = _45; + rs.drop(this.#awaitee$2); this.#awaitee$2 = this.#lend; - const twice: rt.Future = new rt.DynFuture(this.#awaitee$2, rt.futurePoll); + const twice: rs.Future = new rs.DynFuture(this.#awaitee$2, rs.futurePoll); this.#saved = lent2; this.#awaitee$3 = twice; } else { this.#state = 4; - return rt.Pending; + return rs.Pending; } } - const _58: rt.Poll = this.#awaitee$3.poll(_2); - if (_58 !== rt.Pending) { - const result2: rt.u64 = _58; - rt.drop(this.#awaitee$3); - const lent3: rt.u64 = rt.u64Add(this.#saved, result2); + const _58: rs.Poll = this.#awaitee$3.poll(_2); + if (_58 !== rs.Pending) { + const result2: rs.u64 = _58; + rs.drop(this.#awaitee$3); + const lent3: rs.u64 = rs.u64Add(this.#saved, result2); this.#awaitee$3 = this.#lend; - const direct: rt.Future = this.#awaitee$3; + const direct: rs.Future = this.#awaitee$3; this.#saved = lent3; this.#awaitee$4 = direct; } else { this.#state = 5; - return rt.Pending; + return rs.Pending; } } - const _70: rt.Poll = this.#awaitee$4.poll(_2); - if (_70 !== rt.Pending) { - this.#saved = rt.u64Add(this.#saved, _70); + const _70: rs.Poll = this.#awaitee$4.poll(_2); + if (_70 !== rs.Pending) { + this.#saved = rs.u64Add(this.#saved, _70); this.#awaitee$4 = this.#lend; } else { this.#state = 6; - return rt.Pending; + return rs.Pending; } } - const _81: rt.Poll = this.#awaitee$4.poll(_2); - if (_81 !== rt.Pending) { - this.#saved = rt.u64Add(this.#saved, _81); + const _81: rs.Poll = this.#awaitee$4.poll(_2); + if (_81 !== rs.Pending) { + this.#saved = rs.u64Add(this.#saved, _81); const arg2 = this.#saved; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg2, f)]; - const _92: string = rt.fmtFormat(["lent ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg2, f)]; + const _92: string = rs.fmtFormat(["lent ", args4[0]]); Guard.note(this.#guard, _92); this.#saved$5 = false; this.#lend[Symbol.dispose](); - this.#awaitee$4 = owning(Guard.new(rt.u32Add(this.#id, 10), Log.clone$Clone(this.#log))); - this.#other = owning(Guard.new(rt.u32Add(this.#id, 40), Log.clone$Clone(this.#log))); + this.#awaitee$4 = owning(Guard.new(rs.u32Add(this.#id, 10), Log.clone$Clone(this.#log))); + this.#other = owning(Guard.new(rs.u32Add(this.#id, 40), Log.clone$Clone(this.#log))); this.#saved$4 = true; this.#old = rewrite$futures_owning_closure0(this.#awaitee$4, this.#other, owning, this.#guard); this.#saved$3 = true; - this.#boxed = owning(Guard.new(rt.u32Add(this.#id, 60), Log.clone$Clone(this.#log))); + this.#boxed = owning(Guard.new(rs.u32Add(this.#id, 60), Log.clone$Clone(this.#log))); this.#saved$2 = true; - const _130: rt.Future = owning(Guard.new(rt.u32Add(this.#id, 70), Log.clone$Clone(this.#log))); + const _130: rs.Future = owning(Guard.new(rs.u32Add(this.#id, 70), Log.clone$Clone(this.#log))); put$Pin_boxed_Box_future_PollFn_futures_owning_closure0(this.#boxed, _130); this.#awaitee$5 = this.#awaitee$4; } else { this.#state = 7; - return rt.Pending; + return rs.Pending; } } - const _140: rt.Poll = this.#awaitee$5.poll(_2); - if (_140 !== rt.Pending) { + const _140: rs.Poll = this.#awaitee$5.poll(_2); + if (_140 !== rs.Pending) { this.#moved = _140; this.#awaitee$5[Symbol.dispose](); this.#saved$3 = false; this.#old = this.#old; } else { this.#state = 8; - return rt.Pending; + return rs.Pending; } } - const _150: rt.Poll = this.#old.poll(_2); - if (_150 !== rt.Pending) { - const result6: rt.u64 = _150; + const _150: rs.Poll = this.#old.poll(_2); + if (_150 !== rs.Pending) { + const result6: rs.u64 = _150; this.#old[Symbol.dispose](); - this.#moved = rt.u64Add(this.#moved, result6); + this.#moved = rs.u64Add(this.#moved, result6); this.#saved$4 = false; this.#old = this.#other; } else { this.#state = 9; - return rt.Pending; + return rs.Pending; } } - const _161: rt.Poll = this.#old.poll(_2); - if (_161 !== rt.Pending) { - const result7: rt.u64 = _161; + const _161: rs.Poll = this.#old.poll(_2); + if (_161 !== rs.Pending) { + const result7: rs.u64 = _161; this.#old[Symbol.dispose](); - this.#moved = rt.u64Add(this.#moved, result7); + this.#moved = rs.u64Add(this.#moved, result7); this.#saved$2 = false; this.#old = this.#boxed; } else { this.#state = 10; - return rt.Pending; + return rs.Pending; } } - const _172: rt.Poll = this.#old.poll(_2); - if (_172 !== rt.Pending) { - const result8: rt.u64 = _172; + const _172: rs.Poll = this.#old.poll(_2); + if (_172 !== rs.Pending) { + const result8: rs.u64 = _172; this.#old[Symbol.dispose](); - this.#moved = rt.u64Add(this.#moved, result8); + this.#moved = rs.u64Add(this.#moved, result8); const arg3 = this.#moved; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg3, f)]; - const _183: string = rt.fmtFormat(["moved ", args6[0]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg3, f)]; + const _183: string = rs.fmtFormat(["moved ", args6[0]]); Guard.note(this.#guard, _183); - const _197: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rt.u32Add(this.#id, 500), Log.clone$Clone(this.#log)), Guard.new(rt.u32Add(this.#id, 600), Log.clone$Clone(this.#log)), Guard.new(rt.u32Add(this.#id, 700), Log.clone$Clone(this.#log))]; + const _197: [Guard.Guard, Guard.Guard, Guard.Guard] = [Guard.new(rs.u32Add(this.#id, 500), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 600), Log.clone$Clone(this.#log)), Guard.new(rs.u32Add(this.#id, 700), Log.clone$Clone(this.#log))]; const block: Guard.Guard = _197[0]; const waiting: Guard.Guard = _197[1]; const ready: Guard.Guard = _197[2]; const next: Consumer.Consumer = Consumer.clone$Clone(this.#rx); this.#saved$6 = false; - const _220: rt.Future = new boxedFuture$closure2(this.#rx, block); + const _220: rs.Future = new boxedFuture$closure2(this.#rx, block); let captured2 = next; const captured3 = waiting; - const _223: rt.Future = new rt.DynFuture(wait$futures_boxed_closure0_closure3_u64(rt.closure((waiter: Waiter.Waiter): rt.Poll => { - return poll_map$1vdv176(Consumer.pollRecv(captured2, waiter), (value5: rt.u64 | undefined): rt.u64 => { + const _223: rs.Future = new rs.DynFuture(wait$futures_boxed_closure0_closure3_u64(rs.closure((waiter: Waiter.Waiter): rs.Poll => { + return poll_map$1a7g3ip(Consumer.pollRecv(captured2, waiter), (value5: rs.u64 | undefined): rs.u64 => { Guard.note(captured3, "waited"); - return rt.u64Add(option_unwrapOr$1tvry1i(value5, 0), 2); + return rs.u64Add(option_unwrapOr$15hbiwd(value5, 0), 2); }); }, (): void => { captured2[Symbol.dispose](); captured3[Symbol.dispose](); - })), Pending.poll$Future_futures_boxed_closure0_closure3, rt.drop); + })), Pending.poll$Future_futures_boxed_closure0_closure3, rs.drop); const captured4 = ready; - const queue: rt.Vec> = rt.vecFrom([_220, _223, new rt.PollFn(rt.closure((_23: rt.Context): rt.Poll => { + const queue: rs.Vec> = rs.vecFrom([_220, _223, new rs.PollFn(rs.closure((_23: rs.Context): rs.Poll => { Guard.note(captured4, "ready"); return 3; }, (): void => { captured4[Symbol.dispose](); - }), rt.drop)]); - const captured5 = Guard.new(rt.u32Add(this.#id, 800), Log.clone$Clone(this.#log)); - this.#pinned = wait$futures_boxed_closure0_closure5_u64(rt.closure((_24: Waiter.Waiter): rt.Poll => { - return Guard.id(captured5) as rt.u64; + }), rs.drop)]); + const captured5 = Guard.new(rs.u32Add(this.#id, 800), Log.clone$Clone(this.#log)); + this.#pinned = wait$futures_boxed_closure0_closure5_u64(rs.closure((_24: Waiter.Waiter): rs.Poll => { + return Guard.id(captured5) as rs.u64; }, (): void => { captured5[Symbol.dispose](); })); - const last: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> = this.#pinned; + const last: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> = this.#pinned; let captured6 = queue; - let captured7: rt.u64 = 0; + let captured7: rs.u64 = 0; let captured8 = last; - this.#awaitee$6 = new Forward.Forward(new rt.PollFn(rt.closure((cx: rt.Context): rt.Poll => { - let i: rt.usize = 0; + this.#awaitee$6 = new Forward.Forward(new rs.PollFn(rs.closure((cx: rs.Context): rs.Poll => { + let i: rs.usize = 0; while (i < captured6.items.length) { - const _83: rt.Poll = pollUnsized$dyn_Future_u64(captured6.items[rt.idx(captured6.items, i)], cx); - if (_83 !== rt.Pending) { - captured7 = rt.u64Add(captured7, _83); - rt.drop(rt.vecSwapRemove(captured6, i)); + const _83: rs.Poll = pollUnsized$dyn_Future_u64(captured6.items[rs.idx(captured6.items, i)], cx); + if (_83 !== rs.Pending) { + captured7 = rs.u64Add(captured7, _83); + rs.drop(rs.vecSwapRemove(captured6, i)); } else { - i = rt.usizeAdd(i, 1); + i = rs.usizeAdd(i, 1); } } if (!(captured6.items.length === 0)) { - return rt.Pending; + return rs.Pending; } - return poll_map$1ooj6xj(pollUnsized$dyn_Future_u64(new rt.DynFuture(captured8, Pending.poll$Future_futures_boxed_closure0_closure5), cx), (value7: rt.u64): rt.u64 => { - return rt.u64Add(captured7, value7); + return poll_map$1a7lmes(pollUnsized$dyn_Future_u64(new rs.DynFuture(captured8, Pending.poll$Future_futures_boxed_closure0_closure5), cx), (value7: rs.u64): rs.u64 => { + return rs.u64Add(captured7, value7); }); }, (): void => { - rt.dropVec(captured6); - }), rt.drop)); + rs.dropVec(captured6); + }), rs.drop)); } else { this.#state = 11; - return rt.Pending; + return rs.Pending; } } - const _248: rt.Poll = Forward.poll$Future(this.#awaitee$6, _2); - if (_248 !== rt.Pending) { - const total: rt.u64 = _248; + const _248: rs.Poll = Forward.poll$Future(this.#awaitee$6, _2); + if (_248 !== rs.Pending) { + const total: rs.u64 = _248; this.#awaitee$6[Symbol.dispose](); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(total, f)]; - const _258: string = rt.fmtFormat(["boxed ", args8[0]]); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(total, f)]; + const _258: string = rs.fmtFormat(["boxed ", args8[0]]); Guard.note(this.#guard, _258); this.#pinned[Symbol.dispose](); this.#saved$2 = false; @@ -723,7 +723,7 @@ export class boxedFuture { return total; } this.#state = 12; - return rt.Pending; + return rs.Pending; } } @@ -731,7 +731,7 @@ export class boxedFuture$closure2 { #state: number = 0; #rx: Consumer.Consumer; #block: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, block: Guard.Guard) { this.#rx = rx; @@ -743,45 +743,45 @@ export class boxedFuture$closure2 { this.#rx[Symbol.dispose](); this.#block[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#rx[Symbol.dispose](); this.#block[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { - const result: rt.u64 | undefined = _7; - rt.drop(this.#awaitee); - const value: rt.u64 = option_unwrapOr$1tvry1i(result, 0); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(value, f)]; - const _17: string = rt.fmtFormat(["block ", args2[0]]); + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { + const result: rs.u64 | undefined = _7; + rs.drop(this.#awaitee); + const value: rs.u64 = option_unwrapOr$15hbiwd(result, 0); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; + const _17: string = rs.fmtFormat(["block ", args2[0]]); Guard.note(this.#block, _17); - const _30: rt.u64 = rt.u64Add(value, 1); + const _30: rs.u64 = rs.u64Add(value, 1); this.#rx[Symbol.dispose](); this.#block[Symbol.dispose](); this.#state = 1; return _30; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** A `poll_fn` that owns `guard`, ready with its id. */ -export function owning(guard: Guard.Guard): rt.Future { +export function owning(guard: Guard.Guard): rs.Future { const captured = guard; - return new rt.PollFn(rt.closure((_22: rt.Context): rt.Poll => { - return Guard.id(captured) as rt.u64; + return new rs.PollFn(rs.closure((_22: rs.Context): rs.Poll => { + return Guard.id(captured) as rs.u64; }, (): void => { captured[Symbol.dispose](); - }), rt.drop); + }), rs.drop); } /** @@ -789,19 +789,19 @@ export function owning(guard: Guard.Guard): rt.Future { * of guards past `guard`'s id: by assignment, `mem::replace`, whose old one it returns, * `mem::swap`, and `Cell::set`. */ -export function rewrite$futures_owning_closure0(written: rt.Future, other: rt.Future, make: (a0: Guard.Guard) => rt.Future, guard: Guard.Guard): rt.Future { - const made: (a0: rt.u32) => rt.Future = (n: rt.u32): rt.Future => { - return make(Guard.new(rt.u32Add(Guard.id(guard), n), Log.clone$Clone(Guard.log(guard)))); +export function rewrite$futures_owning_closure0(written: rs.Future, other: rs.Future, make: (a0: Guard.Guard) => rs.Future, guard: Guard.Guard): rs.Future { + const made: (a0: rs.u32) => rs.Future = (n: rs.u32): rs.Future => { + return make(Guard.new(rs.u32Add(Guard.id(guard), n), Log.clone$Clone(Guard.log(guard)))); }; put$future_PollFn_futures_owning_closure0(written, made(20)); - const old: rt.Future = rt.replaceIn(written, made(30)); - rt.ptrWrite(written, rt.replaceIn(other, written)); - rt.cellSet(rt.cellIn(other), made(50), rt.drop); + const old: rs.Future = rs.replaceIn(written, made(30)); + rs.ptrWrite(written, rs.replaceIn(other, written)); + rs.cellSet(rs.cellIn(other), made(50), rs.drop); return old; } /** Polls `future`, sized or not, as kio's `Waiter::poll_future` does. */ -export function pollUnsized$dyn_Future_u64(future: rt.Future, cx: rt.Context): rt.Poll { +export function pollUnsized$dyn_Future_u64(future: rs.Future, cx: rs.Context): rs.Poll { return future.poll(cx); } diff --git a/ts/fixtures/task/expected/kio.Closed.ts b/ts/fixtures/task/expected/kio.Closed.ts index daa733ba0..6a20c7788 100644 --- a/ts/fixtures/task/expected/kio.Closed.ts +++ b/ts/fixtures/task/expected/kio.Closed.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export function fmt$fmt_Debug(_self: Closed, f: rt.Formatter): rt.Result { - return rt.fmtWriteStr(f, "Closed"); +export function fmt$fmt_Debug(_self: Closed, f: rs.Formatter): rs.Result { + return rs.fmtWriteStr(f, "Closed"); } /** The error of a poll once the channel closed. */ diff --git a/ts/fixtures/task/expected/kio.Consumer.ts b/ts/fixtures/task/expected/kio.Consumer.ts index 706316a7e..cab23dae8 100644 --- a/ts/fixtures/task/expected/kio.Consumer.ts +++ b/ts/fixtures/task/expected/kio.Consumer.ts @@ -1,20 +1,20 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Closed from "./kio.Closed.ts"; import type * as State from "./kio.State.ts"; import * as Waiter from "./kio.Waiter.ts"; export function clone$Clone(self: Consumer): Consumer { - return new Consumer(rt.arcClone(self.state), self.next); + return new Consumer(rs.arcClone(self.state), self.next); } /** The receiving side of a channel: every value sent, in order. */ export class Consumer { - state: rt.Arc>; - next: rt.usize; + state: rs.Arc>; + next: rs.usize; - constructor(state: rt.Arc>, next: rt.usize) { + constructor(state: rs.Arc>, next: rs.usize) { this.state = state; this.next = next; } @@ -25,23 +25,23 @@ export class Consumer { } /** The next value, or `None` once the channel closed and every value was read. */ -export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - let _0!: rt.Poll; - const state: rt.Mutex = rt.mutexLock(self.state.value); +export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rs.Poll { + let _0!: rs.Poll; + const state: rs.Mutex = rs.mutexLock(self.state.value); if (!(self.next < state.value.queue.items.length)) { if (!state.value.closed) { Waiter.register(waiter, state.value.waiters); - rt.mutexUnlock(state); - return rt.Pending; + rs.mutexUnlock(state); + return rs.Pending; } _0 = undefined; } else { const _16: State.State = state.value; - const value: rt.u64 = _16.queue.items[rt.idx(_16.queue.items, self.next)]; - self.next = rt.usizeAdd(self.next, 1); + const value: rs.u64 = _16.queue.items[rs.idx(_16.queue.items, self.next)]; + self.next = rs.usizeAdd(self.next, 1); _0 = value; } - rt.mutexUnlock(state); + rs.mutexUnlock(state); return _0; } @@ -49,21 +49,21 @@ export function pollRecv(self: Consumer, waiter: Waiter.Waiter): rt.Poll rt.Poll | rt.OuterPending): rt.Poll, Closed.Closed>> { - let _0!: rt.Poll, Closed.Closed>>; - const state: rt.Mutex = rt.mutexLock(self.state.value); - const _8: rt.Poll | rt.OuterPending = f(state.value.queue.items); - if (_8 !== rt.OuterPending) { - _0 = rt.Ok(_8); +export function poll$model_held_closure0_task_Poll_u64(self: Consumer, waiter: Waiter.Waiter, f: (a0: rs.u64[]) => rs.Poll | rs.OuterPending): rs.Poll, Closed.Closed>> { + let _0!: rs.Poll, Closed.Closed>>; + const state: rs.Mutex = rs.mutexLock(self.state.value); + const _8: rs.Poll | rs.OuterPending = f(state.value.queue.items); + if (_8 !== rs.OuterPending) { + _0 = rs.Ok(_8); } else { if (!state.value.closed) { Waiter.register(waiter, state.value.waiters); - rt.mutexUnlock(state); - return rt.Pending; + rs.mutexUnlock(state); + return rs.Pending; } - _0 = rt.Err({}); + _0 = rs.Err({}); } - rt.mutexUnlock(state); + rs.mutexUnlock(state); return _0; } @@ -71,33 +71,33 @@ export function poll$model_held_closure0_task_Poll_u64(self: Consumer, waiter: W * `f` of every value sent so far, once it is ready, or the error once the channel * closed and `f` is not, registering `waiter` otherwise. */ -export function poll$mut_model_watch_closure0_closure1_usize(self: Consumer, waiter: Waiter.Waiter, f: (a0: rt.u64[]) => rt.Poll): rt.Poll> { - let _0!: rt.Poll>; - const state: rt.Mutex = rt.mutexLock(self.state.value); - const _8: rt.Poll = f(state.value.queue.items); - if (_8 !== rt.Pending) { - _0 = rt.Ok(_8); +export function poll$mut_model_watch_closure0_closure1_usize(self: Consumer, waiter: Waiter.Waiter, f: (a0: rs.u64[]) => rs.Poll): rs.Poll> { + let _0!: rs.Poll>; + const state: rs.Mutex = rs.mutexLock(self.state.value); + const _8: rs.Poll = f(state.value.queue.items); + if (_8 !== rs.Pending) { + _0 = rs.Ok(_8); } else { if (!state.value.closed) { Waiter.register(waiter, state.value.waiters); - rt.mutexUnlock(state); - return rt.Pending; + rs.mutexUnlock(state); + return rs.Pending; } - _0 = rt.Err({}); + _0 = rs.Err({}); } - rt.mutexUnlock(state); + rs.mutexUnlock(state); return _0; } /** Ready once the channel closed, registering `waiter` until then. */ -export function pollClosed(self: Consumer, waiter: Waiter.Waiter): rt.Poll { - const state: rt.Mutex = rt.mutexLock(self.state.value); +export function pollClosed(self: Consumer, waiter: Waiter.Waiter): rs.Poll { + const state: rs.Mutex = rs.mutexLock(self.state.value); if (!state.value.closed) { Waiter.register(waiter, state.value.waiters); - rt.mutexUnlock(state); - return rt.Pending; + rs.mutexUnlock(state); + return rs.Pending; } - rt.mutexUnlock(state); + rs.mutexUnlock(state); return undefined; } diff --git a/ts/fixtures/task/expected/kio.Park.ts b/ts/fixtures/task/expected/kio.Park.ts index 36eb2bea9..5994eae6c 100644 --- a/ts/fixtures/task/expected/kio.Park.ts +++ b/ts/fixtures/task/expected/kio.Park.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Waiter from "./kio.Waiter.ts"; export function default$Default(): Park { @@ -16,7 +16,7 @@ export class Park { } [Symbol.dispose](): void { - rt.drop(this._0); + rs.drop(this._0); } } @@ -24,19 +24,19 @@ export class Park { * The waiter for this poll: the one held if it wakes the same task, else a new one, * dropping the old and so its registrations. */ -export function hold(self: Park, cx: rt.Context): Waiter.Waiter { +export function hold(self: Park, cx: rs.Context): Waiter.Waiter { let reuse!: boolean; if (self._0 === undefined) { reuse = false; } else { - reuse = rt.willWake(cx, self._0.waker); + reuse = rs.willWake(cx, self._0.waker); } if (!reuse) { const _10: Waiter.Waiter | undefined = Waiter.new(cx.clone()); - rt.drop(self._0); + rs.drop(self._0); self._0 = _10; } - return rt.optionUnwrap(self._0); + return rs.optionUnwrap(self._0); } //# sourceMappingURL=kio.Park.ts.map diff --git a/ts/fixtures/task/expected/kio.Pending.ts b/ts/fixtures/task/expected/kio.Pending.ts index 04166a54c..49c62d811 100644 --- a/ts/fixtures/task/expected/kio.Pending.ts +++ b/ts/fixtures/task/expected/kio.Pending.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { poll$kio_Task_futures_boxed_closure0_closure3, poll$kio_Task_futures_boxed_closure0_closure5, poll$kio_Task_kio_Consumer_closed_closure0_closure0, poll$kio_Task_kio_Consumer_recv_closure0_closure0, poll$kio_Task_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize, poll$kio_Task_model_front_closure0_closure0, poll$kio_Task_model_watch_closure0_closure0 } from "./kio.ts"; import type * as Closed from "./kio.Closed.ts"; import * as Park from "./kio.Park.ts"; @@ -18,28 +18,28 @@ export class Pending

{ } [Symbol.dispose](): void { - rt.drop(this.inner); + rs.drop(this.inner); this.park[Symbol.dispose](); } } -export function new$futures_boxed_closure0_closure3(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$futures_boxed_closure0_closure3(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } -export function new$futures_boxed_closure0_closure5(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$futures_boxed_closure0_closure5(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } -export function new$kio_Consumer_closed_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$kio_Consumer_closed_closure0_closure0(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } -export function new$kio_Consumer_recv_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$kio_Consumer_recv_closure0_closure0(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } -export function new$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(inner: (a0: Waiter.Waiter) => rt.Poll>): Pending<(a0: Waiter.Waiter) => rt.Poll>> { +export function new$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(inner: (a0: Waiter.Waiter) => rs.Poll>): Pending<(a0: Waiter.Waiter) => rs.Poll>> { return new Pending(inner, Park.default$Default()); } @@ -47,11 +47,11 @@ export function new$model_Watch(inner: Watch.Watch): Pending { return new Pending(inner, Park.default$Default()); } -export function new$model_front_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$model_front_closure0_closure0(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } -export function new$model_watch_closure0_closure0(inner: (a0: Waiter.Waiter) => rt.Poll): Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function new$model_watch_closure0_closure0(inner: (a0: Waiter.Waiter) => rs.Poll): Pending<(a0: Waiter.Waiter) => rs.Poll> { return new Pending(inner, Park.default$Default()); } @@ -65,50 +65,50 @@ export function derefMut$ops_DerefMut_model_Watch(self: Pending): W return self.inner; } -export function poll$Future_futures_boxed_closure0_closure3(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_futures_boxed_closure0_closure3(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_futures_boxed_closure0_closure3(this_.inner, waiter); } -export function poll$Future_futures_boxed_closure0_closure5(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_futures_boxed_closure0_closure5(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_futures_boxed_closure0_closure5(this_.inner, waiter); } -export function poll$Future_kio_Consumer_closed_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_kio_Consumer_closed_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_kio_Consumer_closed_closure0_closure0(this_.inner, waiter); } -export function poll$Future_kio_Consumer_recv_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_kio_Consumer_recv_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_kio_Consumer_recv_closure0_closure0(this_.inner, waiter); } -export function poll$Future_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(self: Pending<(a0: Waiter.Waiter) => rt.Poll>>, cx: rt.Context): rt.Poll> { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll>> = self; +export function poll$Future_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(self: Pending<(a0: Waiter.Waiter) => rs.Poll>>, cx: rs.Context): rs.Poll> { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll>> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(this_.inner, waiter); } -export function poll$Future_model_Watch(self: Pending, cx: rt.Context): rt.Poll { +export function poll$Future_model_Watch(self: Pending, cx: rs.Context): rs.Poll { const this_: Pending = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return Watch.poll$kio_Task(this_.inner, waiter); } -export function poll$Future_model_front_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_model_front_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_model_front_closure0_closure0(this_.inner, waiter); } -export function poll$Future_model_watch_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rt.Poll>, cx: rt.Context): rt.Poll { - const this_: Pending<(a0: Waiter.Waiter) => rt.Poll> = self; +export function poll$Future_model_watch_closure0_closure0(self: Pending<(a0: Waiter.Waiter) => rs.Poll>, cx: rs.Context): rs.Poll { + const this_: Pending<(a0: Waiter.Waiter) => rs.Poll> = self; const waiter: Waiter.Waiter = Park.hold(this_.park, cx); return poll$kio_Task_model_watch_closure0_closure0(this_.inner, waiter); } diff --git a/ts/fixtures/task/expected/kio.Producer.ts b/ts/fixtures/task/expected/kio.Producer.ts index 9962a01dc..e9df2cea6 100644 --- a/ts/fixtures/task/expected/kio.Producer.ts +++ b/ts/fixtures/task/expected/kio.Producer.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as State from "./kio.State.ts"; import * as WaiterList from "./kio.WaiterList.ts"; /** The sending side of a channel, which closes when the last one drops. */ export class Producer { - state: rt.Arc>; + state: rs.Arc>; - constructor(state: rt.Arc>) { + constructor(state: rs.Arc>) { this.state = state; } @@ -20,41 +20,41 @@ export class Producer { } function new_(): Producer { - return new Producer(new rt.Arc(new rt.Mutex(new State.State(new rt.Vec(), false, 1, WaiterList.new())))); + return new Producer(new rs.Arc(new rs.Mutex(new State.State(new rs.Vec(), false, 1, WaiterList.new())))); } /** Queue `value` and wake every consumer, after releasing the lock. */ -export function send(self: Producer, value: rt.u64): void { - const state: rt.Mutex = rt.mutexLock(self.state.value); +export function send(self: Producer, value: rs.u64): void { + const state: rs.Mutex = rs.mutexLock(self.state.value); state.value.queue.items.push(value); const waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); - rt.mutexUnlock(state); + rs.mutexUnlock(state); WaiterList.wake(waiters); waiters[Symbol.dispose](); } export function consume(self: Producer): Consumer.Consumer { - return new Consumer.Consumer(rt.arcClone(self.state), 0); + return new Consumer.Consumer(rs.arcClone(self.state), 0); } export function clone$Clone(self: Producer): Producer { - const _4: rt.Mutex = rt.mutexLock(self.state.value); - _4.value.producers = rt.usizeAdd(_4.value.producers, 1); - rt.mutexUnlock(_4); - return new Producer(rt.arcClone(self.state)); + const _4: rs.Mutex = rs.mutexLock(self.state.value); + _4.value.producers = rs.usizeAdd(_4.value.producers, 1); + rs.mutexUnlock(_4); + return new Producer(rs.arcClone(self.state)); } export function drop$ops_Drop(self: Producer): void { - const state: rt.Mutex = rt.mutexLock(self.state.value); - state.value.producers = rt.usizeSub(state.value.producers, 1); + const state: rs.Mutex = rs.mutexLock(self.state.value); + state.value.producers = rs.usizeSub(state.value.producers, 1); if (!(state.value.producers > 0)) { state.value.closed = true; const waiters: WaiterList.WaiterList = WaiterList.take(state.value.waiters); - rt.mutexUnlock(state); + rs.mutexUnlock(state); WaiterList.wake(waiters); waiters[Symbol.dispose](); } else { - rt.mutexUnlock(state); + rs.mutexUnlock(state); } } diff --git a/ts/fixtures/task/expected/kio.State.ts b/ts/fixtures/task/expected/kio.State.ts index 1ef48421d..1b0dff36a 100644 --- a/ts/fixtures/task/expected/kio.State.ts +++ b/ts/fixtures/task/expected/kio.State.ts @@ -1,15 +1,15 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as WaiterList from "./kio.WaiterList.ts"; export class State { - queue: rt.Vec; + queue: rs.Vec; closed: boolean; - producers: rt.usize; + producers: rs.usize; waiters: WaiterList.WaiterList; - constructor(queue: rt.Vec, closed: boolean, producers: rt.usize, waiters: WaiterList.WaiterList) { + constructor(queue: rs.Vec, closed: boolean, producers: rs.usize, waiters: WaiterList.WaiterList) { this.queue = queue; this.closed = closed; this.producers = producers; diff --git a/ts/fixtures/task/expected/kio.Waiter.ts b/ts/fixtures/task/expected/kio.Waiter.ts index 2a60e621a..60735263b 100644 --- a/ts/fixtures/task/expected/kio.Waiter.ts +++ b/ts/fixtures/task/expected/kio.Waiter.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as WaiterList from "./kio.WaiterList.ts"; /** A task's waker, shared weakly with every list it registers on. */ export class Waiter { - waker: rt.Waker; - shared: rt.Arc; + waker: rs.Waker; + shared: rs.Arc; - constructor(waker: rt.Waker, shared: rt.Arc) { + constructor(waker: rs.Waker, shared: rs.Arc) { this.waker = waker; this.shared = shared; } @@ -19,8 +19,8 @@ export class Waiter { } } -function new_(waker: rt.Waker): Waiter { - const shared: rt.Arc = new rt.Arc(waker.clone()); +function new_(waker: rs.Waker): Waiter { + const shared: rs.Arc = new rs.Arc(waker.clone()); return new Waiter(waker, shared); } @@ -30,17 +30,17 @@ export function register(self: Waiter, list: WaiterList.WaiterList): void { } /** A [`Context`] that wakes this waiter's task. */ -export function context(self: Waiter): rt.Context { +export function context(self: Waiter): rs.Context { return self.waker; } /** Poll a std [`Future`], sized or not, so it wakes this waiter's task. */ -export function pollFuture$dyn_Future_Option_u64(self: Waiter, future: rt.Future): rt.Poll { - const _3: rt.Poll = future.poll(context(self)); - if (_3 !== rt.Pending) { +export function pollFuture$dyn_Future_Option_u64(self: Waiter, future: rs.Future): rs.Poll { + const _3: rs.Poll = future.poll(context(self)); + if (_3 !== rs.Pending) { return _3; } - return rt.Pending; + return rs.Pending; } export { new_ as new }; diff --git a/ts/fixtures/task/expected/kio.WaiterList.ts b/ts/fixtures/task/expected/kio.WaiterList.ts index 79f6c8efd..a065daae2 100644 --- a/ts/fixtures/task/expected/kio.WaiterList.ts +++ b/ts/fixtures/task/expected/kio.WaiterList.ts @@ -1,31 +1,31 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Waiter from "./kio.Waiter.ts"; /** Wakers waiting for one event, held weakly. */ export class WaiterList { - entries: rt.Vec>; - cursor: rt.usize; + entries: rs.Vec>; + cursor: rs.usize; - constructor(entries: rt.Vec>, cursor: rt.usize) { + constructor(entries: rs.Vec>, cursor: rs.usize) { this.entries = entries; this.cursor = cursor; } [Symbol.dispose](): void { - rt.dropVec(this.entries); + rs.dropVec(this.entries); } } function new_(): WaiterList { - return new WaiterList(new rt.Vec(), 0); + return new WaiterList(new rs.Vec(), 0); } export function register(self: WaiterList, waiter: Waiter.Waiter): void { let _58: boolean = false; let _57: boolean = false; - const weak: rt.Weak = new rt.Weak(waiter.shared); + const weak: rs.Weak = new rs.Weak(waiter.shared); _58 = true; b0: { b1: { @@ -34,27 +34,27 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { break b1; } } - let probes: rt.usize = rt.min(self.entries.items.length, 2); + let probes: rs.usize = rs.min(self.entries.items.length, 2); while (probes > 0) { - if (!(self.entries.items[rt.idx(self.entries.items, self.cursor)].arc.strong === 0)) { - self.cursor = rt.usizeRem(rt.usizeAdd(self.cursor, 1), self.entries.items.length); - probes = rt.usizeSub(probes, 1); + if (!(self.entries.items[rs.idx(self.entries.items, self.cursor)].arc.strong === 0)) { + self.cursor = rs.usizeRem(rs.usizeAdd(self.cursor, 1), self.entries.items.length); + probes = rs.usizeSub(probes, 1); } else { _58 = false; - const _24: rt.Weak = weak; - const at2 = rt.idx(self.entries.items, self.cursor); + const _24: rs.Weak = weak; + const at2 = rs.idx(self.entries.items, self.cursor); self.entries.items[at2][Symbol.dispose](); self.entries.items[at2] = _24; break b1; } } if (self.entries.items.length >= 4) { - const live: rt.Vec> = new rt.Vec(); + const live: rs.Vec> = new rs.Vec(); const taken = self.entries; - self.entries = new rt.Vec(); + self.entries = new rs.Vec(); for (const _43 of taken.items) { _57 = true; - const entry: rt.Weak = _43; + const entry: rs.Weak = _43; if (entry.arc.strong > 0) { _57 = false; live.items.push(entry); @@ -64,8 +64,8 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { } _57 = false; } - const _53: rt.Vec> = live; - rt.dropVec(self.entries); + const _53: rs.Vec> = live; + rs.dropVec(self.entries); self.entries = _53; self.cursor = 0; } @@ -85,7 +85,7 @@ export function register(self: WaiterList, waiter: Waiter.Waiter): void { export function take(self: WaiterList): WaiterList { self.cursor = 0; const taken = self.entries; - self.entries = new rt.Vec(); + self.entries = new rs.Vec(); return new WaiterList(taken, 0); } @@ -93,11 +93,11 @@ export function take(self: WaiterList): WaiterList { export function wake(self: WaiterList): void { self.cursor = 0; const taken = self.entries; - self.entries = new rt.Vec(); + self.entries = new rs.Vec(); for (const entry of taken.items) { - const _10: rt.Arc | undefined = rt.weakUpgrade(entry); + const _10: rs.Arc | undefined = rs.weakUpgrade(entry); if (_10 !== undefined) { - const waker: rt.Arc = _10; + const waker: rs.Arc = _10; waker.value.wakeByRef(); waker[Symbol.dispose](); } diff --git a/ts/fixtures/task/expected/kio.ts b/ts/fixtures/task/expected/kio.ts index 1437ccdf4..1694b178c 100644 --- a/ts/fixtures/task/expected/kio.ts +++ b/ts/fixtures/task/expected/kio.ts @@ -1,81 +1,81 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Closed from "./kio.Closed.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as Pending from "./kio.Pending.ts"; import type * as Waiter from "./kio.Waiter.ts"; -export function poll$kio_Task_futures_boxed_closure0_closure3(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_futures_boxed_closure0_closure3(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } -export function poll$kio_Task_futures_boxed_closure0_closure5(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_futures_boxed_closure0_closure5(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } -export function poll$kio_Task_kio_Consumer_closed_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_kio_Consumer_closed_closure0_closure0(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } -export function poll$kio_Task_kio_Consumer_recv_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_kio_Consumer_recv_closure0_closure0(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } -export function poll$kio_Task_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(self: (a0: Waiter.Waiter) => rt.Poll>, waiter: Waiter.Waiter): rt.Poll> { +export function poll$kio_Task_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(self: (a0: Waiter.Waiter) => rs.Poll>, waiter: Waiter.Waiter): rs.Poll> { return self(waiter); } -export function poll$kio_Task_model_front_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_model_front_closure0_closure0(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } -export function poll$kio_Task_model_watch_closure0_closure0(self: (a0: Waiter.Waiter) => rt.Poll, waiter: Waiter.Waiter): rt.Poll { +export function poll$kio_Task_model_watch_closure0_closure0(self: (a0: Waiter.Waiter) => rs.Poll, waiter: Waiter.Waiter): rs.Poll { return self(waiter); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$futures_boxed_closure0_closure3_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$futures_boxed_closure0_closure3_u64(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$futures_boxed_closure0_closure3(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$futures_boxed_closure0_closure5_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$futures_boxed_closure0_closure5_u64(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$futures_boxed_closure0_closure5(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$kio_Consumer_closed_closure0_closure0_unit(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$kio_Consumer_closed_closure0_closure0_unit(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$kio_Consumer_closed_closure0_closure0(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$kio_Consumer_recv_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$kio_Consumer_recv_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$kio_Consumer_recv_closure0_closure0(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize_Result_usize_kio_Closed(poll: (a0: Waiter.Waiter) => rt.Poll>): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>> { +export function wait$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize_Result_usize_kio_Closed(poll: (a0: Waiter.Waiter) => rs.Poll>): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>> { return Pending.new$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$model_front_closure0_closure0_usize(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$model_front_closure0_closure0_usize(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$model_front_closure0_closure0(poll); } /** A future from a poll function that receives a [`Waiter`]. */ -export function wait$model_watch_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rt.Poll): Pending.Pending<(a0: Waiter.Waiter) => rt.Poll> { +export function wait$model_watch_closure0_closure0_Option_u64(poll: (a0: Waiter.Waiter) => rs.Poll): Pending.Pending<(a0: Waiter.Waiter) => rs.Poll> { return Pending.new$model_watch_closure0_closure0(poll); } export class waitFuture$kio_Consumer_model_watch_closure0_closure1_usize { #state: number = 0; #self: Consumer.Consumer; - #f: (a0: rt.u64[]) => rt.Poll; - #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>>; + #f: (a0: rs.u64[]) => rs.Poll; + #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>>; - constructor(self: Consumer.Consumer, f: (a0: rt.u64[]) => rt.Poll) { + constructor(self: Consumer.Consumer, f: (a0: rs.u64[]) => rs.Poll) { this.#self = self; this.#f = f; } @@ -88,31 +88,31 @@ export class waitFuture$kio_Consumer_model_watch_closure0_closure1_usize { } } - poll(_2: rt.Context): rt.Poll> { + poll(_2: rs.Context): rs.Poll> { if (this.#state === 0) { const self: Consumer.Consumer = this.#self; let captured = this.#f; - this.#awaitee = wait$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize_Result_usize_kio_Closed((waiter: Waiter.Waiter): rt.Poll> => { + this.#awaitee = wait$kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize_Result_usize_kio_Closed((waiter: Waiter.Waiter): rs.Poll> => { return Consumer.poll$mut_model_watch_closure0_closure1_usize(self, waiter, captured); }); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _8: rt.Poll> = Pending.poll$Future_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(this.#awaitee, _2); - if (_8 !== rt.Pending) { + const _8: rs.Poll> = Pending.poll$Future_kio_Consumer_wait_closure0_closure0_model_watch_closure0_closure1_usize(this.#awaitee, _2); + if (_8 !== rs.Pending) { this.#awaitee[Symbol.dispose](); this.#state = 1; return _8; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class closedFuture$kio_Consumer { #state: number = 0; #self: Consumer.Consumer; - #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>; constructor(self: Consumer.Consumer) { this.#self = self; @@ -124,29 +124,29 @@ export class closedFuture$kio_Consumer { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const self: Consumer.Consumer = this.#self; - this.#awaitee = wait$kio_Consumer_closed_closure0_closure0_unit((waiter: Waiter.Waiter): rt.Poll => { + this.#awaitee = wait$kio_Consumer_closed_closure0_closure0_unit((waiter: Waiter.Waiter): rs.Poll => { return Consumer.pollClosed(self, waiter); }); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - if (Pending.poll$Future_kio_Consumer_closed_closure0_closure0(this.#awaitee, _2) !== rt.Pending) { + if (Pending.poll$Future_kio_Consumer_closed_closure0_closure0(this.#awaitee, _2) !== rs.Pending) { this.#awaitee[Symbol.dispose](); this.#state = 1; return undefined; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class recvFuture$kio_Consumer { #state: number = 0; #self: Consumer.Consumer; - #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>; constructor(self: Consumer.Consumer) { this.#self = self; @@ -158,23 +158,23 @@ export class recvFuture$kio_Consumer { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const self: Consumer.Consumer = this.#self; - this.#awaitee = wait$kio_Consumer_recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { + this.#awaitee = wait$kio_Consumer_recv_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rs.Poll => { return Consumer.pollRecv(self, waiter); }); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _7: rt.Poll = Pending.poll$Future_kio_Consumer_recv_closure0_closure0(this.#awaitee, _2); - if (_7 !== rt.Pending) { + const _7: rs.Poll = Pending.poll$Future_kio_Consumer_recv_closure0_closure0(this.#awaitee, _2); + if (_7 !== rs.Pending) { this.#awaitee[Symbol.dispose](); this.#state = 1; return _7; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } diff --git a/ts/fixtures/task/expected/lib.ts b/ts/fixtures/task/expected/lib.ts index 281b39b38..715d6f54d 100644 --- a/ts/fixtures/task/expected/lib.ts +++ b/ts/fixtures/task/expected/lib.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Any from "./core/any.Any.ts"; import { take$drops_objects_Part_u32 as objects_take$drops_objects_Part_u32, id$drops_objects_Part_u32 } from "./drops/objects.ts"; import type * as Ranked from "./drops/orders.Ranked.ts"; @@ -12,7 +12,7 @@ import * as Wrap from "./drops.Wrap.ts"; import * as Guard from "./model.Guard.ts"; import type * as Tally from "./model.Tally.ts"; -export function copy$array_u32(v: rt.u32[]): rt.u32[] { +export function copy$array_u32(v: rs.u32[]): rs.u32[] { return v.slice(); } @@ -20,13 +20,13 @@ export function copy$model_Tally(v: Tally.Tally): Tally.Tally { return { n: v.n }; } -export function drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1: rt.Result | undefined): void { +export function drop$Option_Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1: rs.Result | undefined): void { if (_1 !== undefined) { drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1); } } -export function drop$Option_Result_model_Guard_u8(_1: rt.Result | undefined): void { +export function drop$Option_Result_model_Guard_u8(_1: rs.Result | undefined): void { if (_1 !== undefined) { drop$Result_model_Guard_u8(_1); } @@ -44,9 +44,9 @@ export function drop$Option_drops_Held(_1: Held.Held | undefined): void { } } -export function drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(_1: rt.Arc<[Guard.Guard, Guard.Guard]> | undefined): void { +export function drop$Option_sync_Arc_tuple2_model_Guard_model_Guard(_1: rs.Arc<[Guard.Guard, Guard.Guard]> | undefined): void { if (_1 !== undefined) { - rt.arcDrop(_1, drop$tuple2_model_Guard_model_Guard); + rs.arcDrop(_1, drop$tuple2_model_Guard_model_Guard); } } @@ -68,29 +68,29 @@ export function drop$Option_tuple2_tuple2_model_Guard_model_Guard_model_Guard(_1 } } -export function drop$Result_Vec_model_Guard_model_Guard(_1: rt.Result, Guard.Guard>): void { +export function drop$Result_Vec_model_Guard_model_Guard(_1: rs.Result, Guard.Guard>): void { if (_1.ok) { - rt.dropVec(_1.value); + rs.dropVec(_1.value); } else { _1.error[Symbol.dispose](); } } -export function drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1: rt.Result): void { +export function drop$Result_boxed_Box_model_Guard_boxed_Box_dyn_Any(_1: rs.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { - rt.drop(_1.error); + rs.drop(_1.error); } } -export function drop$Result_cell_Ref_u32_cell_BorrowError(_1: rt.Result, rt.BorrowError>): void { +export function drop$Result_cell_Ref_u32_cell_BorrowError(_1: rs.Result, rs.BorrowError>): void { if (_1.ok) { - rt.refRelease(_1.value); + rs.refRelease(_1.value); } } -export function drop$Result_model_Guard_model_Guard(_1: rt.Result): void { +export function drop$Result_model_Guard_model_Guard(_1: rs.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); } else { @@ -98,46 +98,46 @@ export function drop$Result_model_Guard_model_Guard(_1: rt.Result): void { +export function drop$Result_model_Guard_u8(_1: rs.Result): void { if (_1.ok) { _1.value[Symbol.dispose](); } } -export function drop$Result_sync_Arc_tuple2_model_Guard_model_Guard_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rt.Result, rt.Arc>): void { +export function drop$Result_sync_Arc_tuple2_model_Guard_model_Guard_sync_Arc_dyn_Any_marker_Sync_marker_Send(_1: rs.Result, rs.Arc>): void { if (_1.ok) { - rt.arcDrop(_1.value, drop$tuple2_model_Guard_model_Guard); + rs.arcDrop(_1.value, drop$tuple2_model_Guard_model_Guard); } else { _1.error[Symbol.dispose](); } } -export function drop$Result_u32_model_Guard(_1: rt.Result): void { +export function drop$Result_u32_model_Guard(_1: rs.Result): void { if (!_1.ok) { _1.error[Symbol.dispose](); } } -export function drop$Result_unit_Option_model_Guard(_1: rt.Result): void { +export function drop$Result_unit_Option_model_Guard(_1: rs.Result): void { if (!_1.ok) { - rt.drop(_1.error); + rs.drop(_1.error); } } -export function drop$Result_unit_drops_Held(_1: rt.Result): void { +export function drop$Result_unit_drops_Held(_1: rs.Result): void { if (!_1.ok) { drop$drops_Held(_1.error); } } -export function drop$Result_unit_model_Guard(_1: rt.Result): void { +export function drop$Result_unit_model_Guard(_1: rs.Result): void { if (!_1.ok) { _1.error[Symbol.dispose](); } } -export function drop$Vec_model_Guard(value: rt.Vec): void { - rt.dropVec(value); +export function drop$Vec_model_Guard(value: rs.Vec): void { + rs.dropVec(value); } export function drop$drops_Held(_1: Held.Held): void { @@ -160,10 +160,10 @@ export function drop$drops_Text(_1: Text.Text): void { } } -export function drop$drops_Wrap_Vec_drops_Wrap_drops_Held(_1: Wrap.Wrap>>): void { +export function drop$drops_Wrap_Vec_drops_Wrap_drops_Held(_1: Wrap.Wrap>>): void { Wrap.drop$ops_Drop_Vec_drops_Wrap_drops_Held(_1); _1.log[Symbol.dispose](); - rt.dropVec(_1.inner, drop$drops_Wrap_drops_Held); + rs.dropVec(_1.inner, drop$drops_Wrap_drops_Held); } export function drop$drops_Wrap_drops_Held(_1: Wrap.Wrap): void { @@ -184,40 +184,40 @@ export function drop$drops_Wrap_model_Guard(_1: Wrap.Wrap): void { _1.inner[Symbol.dispose](); } -export function drop$drops_Wrap_sync_Arc_drops_Held(_1: Wrap.Wrap>): void { +export function drop$drops_Wrap_sync_Arc_drops_Held(_1: Wrap.Wrap>): void { Wrap.drop$ops_Drop_sync_Arc_drops_Held(_1); _1.log[Symbol.dispose](); - rt.arcDrop(_1.inner, drop$drops_Held); + rs.arcDrop(_1.inner, drop$drops_Held); } -export function drop$drops_Wrap_u32(_1: Wrap.Wrap): void { +export function drop$drops_Wrap_u32(_1: Wrap.Wrap): void { Wrap.drop$ops_Drop_u32(_1); _1.log[Symbol.dispose](); } -export function drop$ops_ControlFlow_model_Guard_u32(_1: rt.Result): void { +export function drop$ops_ControlFlow_model_Guard_u32(_1: rs.Result): void { if (!_1.ok) { _1.error[Symbol.dispose](); } } -export function drop$ops_RangeInclusive_drops_Key(value: rt.RangeInclusive): void { - rt.dropAll([value.lo, value.hi]); +export function drop$ops_RangeInclusive_drops_Key(value: rs.RangeInclusive): void { + rs.dropAll([value.lo, value.hi]); } -export function drop$ops_Range_drops_Key(value: rt.Range): void { - rt.dropAll([value.start, value.end]); +export function drop$ops_Range_drops_Key(value: rs.Range): void { + rs.dropAll([value.start, value.end]); } -export function drop$ops_Range_model_Guard(value: rt.Range): void { - rt.dropAll([value.start, value.end]); +export function drop$ops_Range_model_Guard(value: rs.Range): void { + rs.dropAll([value.start, value.end]); } -export function drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held(value: rt.Arc>>): void { - rt.arcDrop(value, drop$drops_Wrap_drops_Pair_drops_Held); +export function drop$sync_Arc_drops_Wrap_drops_Pair_drops_Held(value: rs.Arc>>): void { + rs.arcDrop(value, drop$drops_Wrap_drops_Pair_drops_Held); } -export function drop$sync_Mutex_drops_Held(value: rt.Mutex): void { +export function drop$sync_Mutex_drops_Held(value: rs.Mutex): void { drop$drops_Held(value.value); } @@ -236,11 +236,11 @@ export function drop$tuple2_drops_orders_Ranked_model_Guard(_1: [Ranked.Ranked, _1[1][Symbol.dispose](); } -export function drop$tuple2_i32_model_Guard(_1: [rt.i32, Guard.Guard]): void { +export function drop$tuple2_i32_model_Guard(_1: [rs.i32, Guard.Guard]): void { _1[1][Symbol.dispose](); } -export function drop$tuple2_model_Guard_i32(_1: [Guard.Guard, rt.i32]): void { +export function drop$tuple2_model_Guard_i32(_1: [Guard.Guard, rs.i32]): void { _1[0][Symbol.dispose](); } @@ -249,20 +249,20 @@ export function drop$tuple2_model_Guard_model_Guard(_1: [Guard.Guard, Guard.Guar _1[1][Symbol.dispose](); } -export function drop$tuple2_model_Guard_u32(_1: [Guard.Guard, rt.u32]): void { +export function drop$tuple2_model_Guard_u32(_1: [Guard.Guard, rs.u32]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_model_Guard_u64(_1: [Guard.Guard, rt.u64]): void { +export function drop$tuple2_model_Guard_u64(_1: [Guard.Guard, rs.u64]): void { _1[0][Symbol.dispose](); } -export function drop$tuple2_sync_Arc_str_sync_Arc_str(_1: [rt.Arc, rt.Arc]): void { +export function drop$tuple2_sync_Arc_str_sync_Arc_str(_1: [rs.Arc, rs.Arc]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); } -export function drop$tuple2_tuple2_model_Guard_model_Guard_i32(_1: [[Guard.Guard, Guard.Guard], rt.i32]): void { +export function drop$tuple2_tuple2_model_Guard_model_Guard_i32(_1: [[Guard.Guard, Guard.Guard], rs.i32]): void { drop$tuple2_model_Guard_model_Guard(_1[0]); } @@ -271,36 +271,36 @@ export function drop$tuple2_tuple2_model_Guard_model_Guard_model_Guard(_1: [[Gua _1[1][Symbol.dispose](); } -export function drop$tuple2_tuple2_model_Guard_model_Guard_u32(_1: [[Guard.Guard, Guard.Guard], rt.u32]): void { +export function drop$tuple2_tuple2_model_Guard_model_Guard_u32(_1: [[Guard.Guard, Guard.Guard], rs.u32]): void { drop$tuple2_model_Guard_model_Guard(_1[0]); } -export function drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32(_1: [[[Guard.Guard, Guard.Guard], rt.i32], rt.i32]): void { +export function drop$tuple2_tuple2_tuple2_model_Guard_model_Guard_i32_i32(_1: [[[Guard.Guard, Guard.Guard], rs.i32], rs.i32]): void { drop$tuple2_tuple2_model_Guard_model_Guard_i32(_1[0]); } -export function drop$tuple2_tuple2_usize_model_Guard_model_Guard(_1: [[rt.usize, Guard.Guard], Guard.Guard]): void { +export function drop$tuple2_tuple2_usize_model_Guard_model_Guard(_1: [[rs.usize, Guard.Guard], Guard.Guard]): void { drop$tuple2_usize_model_Guard(_1[0]); _1[1][Symbol.dispose](); } -export function drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32(_1: [[rt.usize, [Guard.Guard, Guard.Guard]], rt.i32]): void { +export function drop$tuple2_tuple2_usize_tuple2_model_Guard_model_Guard_i32(_1: [[rs.usize, [Guard.Guard, Guard.Guard]], rs.i32]): void { drop$tuple2_usize_tuple2_model_Guard_model_Guard(_1[0]); } -export function drop$tuple2_u32_model_Guard(_1: [rt.u32, Guard.Guard]): void { +export function drop$tuple2_u32_model_Guard(_1: [rs.u32, Guard.Guard]): void { _1[1][Symbol.dispose](); } -export function drop$tuple2_usize_model_Guard(_1: [rt.usize, Guard.Guard]): void { +export function drop$tuple2_usize_model_Guard(_1: [rs.usize, Guard.Guard]): void { _1[1][Symbol.dispose](); } -export function drop$tuple2_usize_tuple2_model_Guard_model_Guard(_1: [rt.usize, [Guard.Guard, Guard.Guard]]): void { +export function drop$tuple2_usize_tuple2_model_Guard_model_Guard(_1: [rs.usize, [Guard.Guard, Guard.Guard]]): void { drop$tuple2_model_Guard_model_Guard(_1[1]); } -export function drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker(_1: [rt.Waker, rt.Waker, rt.Waker, rt.Waker]): void { +export function drop$tuple4_task_Waker_task_Waker_task_Waker_task_Waker(_1: [rs.Waker, rs.Waker, rs.Waker, rs.Waker]): void { _1[0][Symbol.dispose](); _1[1][Symbol.dispose](); _1[2][Symbol.dispose](); @@ -318,19 +318,19 @@ export class of$drops_Held { drop$drops_Held(this.v); } - id$Part(): rt.u32 { + id$Part(): rs.u32 { return Held.id$drops_objects_Part(this.v); } - take$Part(): rt.u32 { + take$Part(): rs.u32 { return Held.take$drops_objects_Part(this.v); } } export class of$drops_Wrap_u32 { - v: Wrap.Wrap; + v: Wrap.Wrap; - constructor(v: Wrap.Wrap) { + constructor(v: Wrap.Wrap) { this.v = v; } @@ -338,11 +338,11 @@ export class of$drops_Wrap_u32 { drop$drops_Wrap_u32(this.v); } - id$Part(): rt.u32 { + id$Part(): rs.u32 { return Wrap.id$drops_objects_Part_u32(this.v); } - take$Part(): rt.u32 { + take$Part(): rs.u32 { return Wrap.take$drops_objects_Part_u32(this.v); } } @@ -358,11 +358,11 @@ export class of$model_Guard { this.v[Symbol.dispose](); } - id$Part(): rt.u32 { + id$Part(): rs.u32 { return Guard.id$drops_objects_Part(this.v); } - take$Part(): rt.u32 { + take$Part(): rs.u32 { return Guard.take$drops_objects_Part(this.v); } } @@ -380,25 +380,25 @@ export class of$tuple2_model_Guard_model_Guard { } export class of$u32 { - v: rt.u32; + v: rs.u32; - constructor(v: rt.u32) { + constructor(v: rs.u32) { this.v = v; } - id$Part(): rt.u32 { + id$Part(): rs.u32 { return id$drops_objects_Part_u32(this.v); } - take$Part(): rt.u32 { + take$Part(): rs.u32 { return objects_take$drops_objects_Part_u32(this.v); } } export class ofPlace$drops_Held { - v: rt.Place; + v: rs.Place; - constructor(v: rt.Place) { + constructor(v: rs.Place) { this.v = v; } diff --git a/ts/fixtures/task/expected/log.Log.ts b/ts/fixtures/task/expected/log.Log.ts index 3ce33bf52..0e283b983 100644 --- a/ts/fixtures/task/expected/log.Log.ts +++ b/ts/fixtures/task/expected/log.Log.ts @@ -1,16 +1,16 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function clone$Clone(self: Log): Log { - return new Log(rt.arcClone(self._0)); + return new Log(rs.arcClone(self._0)); } /** A shared, append-only list of events. */ export class Log { - _0: rt.Arc>>; + _0: rs.Arc>>; - constructor(_0: rt.Arc>>) { + constructor(_0: rs.Arc>>) { this._0 = _0; } @@ -20,31 +20,31 @@ export class Log { } function new_(): Log { - return new Log(new rt.Arc(new rt.Mutex(new rt.Vec()))); + return new Log(new rs.Arc(new rs.Mutex(new rs.Vec()))); } /** Append one event. */ export function note(self: Log, event: string): void { - const _6: rt.Mutex> = rt.mutexLock(self._0.value); + const _6: rs.Mutex> = rs.mutexLock(self._0.value); _6.value.items.push(event); - rt.mutexUnlock(_6); + rs.mutexUnlock(_6); } /** Every event so far, one per line. */ -export function text(self: Log): rt.ByteVec { - const events: rt.Mutex> = rt.mutexLock(self._0.value); - const out: rt.ByteVec = new rt.ByteVec(); - const iter: rt.Iter = rt.iterSlice(events.value.items); +export function text(self: Log): rs.ByteVec { + const events: rs.Mutex> = rs.mutexLock(self._0.value); + const out: rs.ByteVec = new rs.ByteVec(); + const iter: rs.Iter = rs.iterSlice(events.value.items); while (true) { - const _13: string | rt.Done = iter.next(); - if (_13 === rt.DONE) { + const _13: string | rs.Done = iter.next(); + if (_13 === rs.DONE) { break; } - const _19: rt.ByteSlice = rt.stringAsBytes(_13); - rt.byteVecExtendFromSlice(out, _19); - rt.byteVecPush(out, 10); + const _19: rs.ByteSlice = rs.stringAsBytes(_13); + rs.byteVecExtendFromSlice(out, _19); + rs.byteVecPush(out, 10); } - rt.mutexUnlock(events); + rs.mutexUnlock(events); return out; } diff --git a/ts/fixtures/task/expected/model.Channel.ts b/ts/fixtures/task/expected/model.Channel.ts index 2ae45ea40..ce5b1116d 100644 --- a/ts/fixtures/task/expected/model.Channel.ts +++ b/ts/fixtures/task/expected/model.Channel.ts @@ -1,21 +1,21 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Consumer from "./kio.Consumer.ts"; import * as Producer from "./kio.Producer.ts"; /** A channel's open producers, and a consumer to clone for each task. */ export class Channel { - producers: rt.Vec; + producers: rs.Vec; consumer: Consumer.Consumer; - constructor(producers: rt.Vec, consumer: Consumer.Consumer) { + constructor(producers: rs.Vec, consumer: Consumer.Consumer) { this.producers = producers; this.consumer = consumer; } [Symbol.dispose](): void { - rt.dropVec(this.producers); + rs.dropVec(this.producers); this.consumer[Symbol.dispose](); } } @@ -23,7 +23,7 @@ export class Channel { export function open(): Channel { const producer: Producer.Producer = Producer.new(); const consumer: Consumer.Consumer = Producer.consume(producer); - const producers: rt.Vec = new rt.Vec(); + const producers: rs.Vec = new rs.Vec(); producers.items.push(producer); return new Channel(producers, consumer); } @@ -34,8 +34,8 @@ export function consumer(self: Channel): Consumer.Consumer { } /** Send `value` through the first producer, if one is open. */ -export function send(self: Channel, value: rt.u64): boolean { - const _3: Producer.Producer | undefined = rt.sliceFirst(self.producers.items); +export function send(self: Channel, value: rs.u64): boolean { + const _3: Producer.Producer | undefined = rs.sliceFirst(self.producers.items); if (_3 === undefined) { return false; } @@ -45,7 +45,7 @@ export function send(self: Channel, value: rt.u64): boolean { /** Drop the last producer, if one is open: the last closes the channel. */ export function close(self: Channel): boolean { - const _2: Producer.Producer | undefined = rt.vecPop(self.producers); + const _2: Producer.Producer | undefined = rs.vecPop(self.producers); if (_2 === undefined) { return false; } @@ -55,7 +55,7 @@ export function close(self: Channel): boolean { /** Open another producer, if one is open to clone. */ export function cloneProducer(self: Channel): boolean { - const _3: Producer.Producer | undefined = rt.sliceFirst(self.producers.items); + const _3: Producer.Producer | undefined = rs.sliceFirst(self.producers.items); if (_3 === undefined) { return false; } diff --git a/ts/fixtures/task/expected/model.Countdown.ts b/ts/fixtures/task/expected/model.Countdown.ts index efcc54c1d..6ae0523f5 100644 --- a/ts/fixtures/task/expected/model.Countdown.ts +++ b/ts/fixtures/task/expected/model.Countdown.ts @@ -1,14 +1,14 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Guard from "./model.Guard.ts"; /** Counts down, holding a guard the loop drops after its last turn. */ export class Countdown { - left: rt.u32; + left: rs.u32; guard: Guard.Guard; - constructor(left: rt.u32, guard: Guard.Guard) { + constructor(left: rs.u32, guard: Guard.Guard) { this.left = left; this.guard = guard; } @@ -18,13 +18,13 @@ export class Countdown { } } -export function next$iter_Iterator(self: Countdown): rt.u32 | rt.Done { +export function next$iter_Iterator(self: Countdown): rs.u32 | rs.Done { if (!(self.left === 0)) { - self.left = rt.u32Sub(self.left, 1); + self.left = rs.u32Sub(self.left, 1); Guard.note(self.guard, "count"); return self.left; } - return rt.DONE; + return rs.DONE; } //# sourceMappingURL=model.Countdown.ts.map diff --git a/ts/fixtures/task/expected/model.Guard.ts b/ts/fixtures/task/expected/model.Guard.ts index f2b1ca471..0929ac995 100644 --- a/ts/fixtures/task/expected/model.Guard.ts +++ b/ts/fixtures/task/expected/model.Guard.ts @@ -1,25 +1,25 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import * as Log from "./log.Log.ts"; /** Consumes the box, dropping it on return. */ -export function take$drops_objects_Part(self: Guard): rt.u32 { - const _0: rt.u32 = rt.u32WrappingAdd(id$drops_objects_Part(self), 1); +export function take$drops_objects_Part(self: Guard): rs.u32 { + const _0: rs.u32 = rs.u32WrappingAdd(id$drops_objects_Part(self), 1); self[Symbol.dispose](); return _0; } -export function id$drops_objects_Part(self: Guard): rt.u32 { +export function id$drops_objects_Part(self: Guard): rs.u32 { return id(self); } /** Logs its own drop. */ export class Guard { - id: rt.u32; + id: rs.u32; log: Log.Log; - constructor(id: rt.u32, log: Log.Log) { + constructor(id: rs.u32, log: Log.Log) { this.id = id; this.log = log; } @@ -30,11 +30,11 @@ export class Guard { } } -function new_(id: rt.u32, log: Log.Log): Guard { +function new_(id: rs.u32, log: Log.Log): Guard { return new Guard(id, log); } -export function id(self: Guard): rt.u32 { +export function id(self: Guard): rs.u32 { return self.id; } @@ -45,28 +45,28 @@ export function log(self: Guard): Log.Log { /** Log `event` as this guard's. */ export function note(self: Guard, event: string): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.fmtPad(f, event)]; - const _5: string = rt.fmtFormat(["g", args2[0], " ", args2[1]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.fmtPad(f, event)]; + const _5: string = rs.fmtFormat(["g", args2[0], " ", args2[1]]); Log.note(self.log, _5); } /** Log `event`, then drop: `self`, taken by value, drops as the call returns. */ -export function finish(self: Guard, event: string): rt.u32 { +export function finish(self: Guard, event: string): rs.u32 { note(self, event); - const _0: rt.u32 = self.id; + const _0: rs.u32 = self.id; self[Symbol.dispose](); return _0; } /** [`Self::finish`], moved out of its box: freeing the box must not drop it again. */ -export function unbox(self: Guard, event: string): rt.u32 { +export function unbox(self: Guard, event: string): rs.u32 { return finish(self, event); } export function drop$ops_Drop(self: Guard): void { const arg = self.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _4: string = rt.fmtFormat(["g", args2[0], " drop"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _4: string = rs.fmtFormat(["g", args2[0], " drop"]); Log.note(self.log, _4); } diff --git a/ts/fixtures/task/expected/model.Inner.ts b/ts/fixtures/task/expected/model.Inner.ts index 36351f973..a7d88103b 100644 --- a/ts/fixtures/task/expected/model.Inner.ts +++ b/ts/fixtures/task/expected/model.Inner.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Outer from "./model.Outer.ts"; export class Inner { @@ -11,7 +11,7 @@ export class Inner { } [Symbol.dispose](): void { - rt.drop(this.outer); + rs.drop(this.outer); } } diff --git a/ts/fixtures/task/expected/model.Listing.ts b/ts/fixtures/task/expected/model.Listing.ts index cd041df45..8aa1d2b02 100644 --- a/ts/fixtures/task/expected/model.Listing.ts +++ b/ts/fixtures/task/expected/model.Listing.ts @@ -1,24 +1,24 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export function default$Default(): Listing { - return { last: undefined, listed: new rt.Vec() }; + return { last: undefined, listed: new rs.Vec() }; } -export function fmt$fmt_Debug(self: Listing, f: rt.Formatter): rt.Result { +export function fmt$fmt_Debug(self: Listing, f: rs.Formatter): rs.Result { const _3: string = "Listing"; const _4: string = "last"; - const _5: rt.Fmt = (f: rt.Formatter) => rt.fmtOption(self.last, f, rt.u64Debug); + const _5: rs.Fmt = (f: rs.Formatter) => rs.fmtOption(self.last, f, rs.u64Debug); const _7: string = "listed"; - const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtList(self.listed.items, f, rt.u64Debug); - return rt.debugStructFinish(rt.debugStructField(rt.debugStructField(rt.fmtDebugStruct(f, _3), _4, _5), _7, _8)); + const _8: rs.Fmt = (f: rs.Formatter) => rs.fmtList(self.listed.items, f, rs.u64Debug); + return rs.debugStructFinish(rs.debugStructField(rs.debugStructField(rs.fmtDebugStruct(f, _3), _4, _5), _7, _8)); } /** What [`front`] lists. */ export interface Listing { - last: rt.u64 | undefined; - listed: rt.Vec; + last: rs.u64 | undefined; + listed: rs.Vec; } //# sourceMappingURL=model.Listing.ts.map diff --git a/ts/fixtures/task/expected/model.Mark.ts b/ts/fixtures/task/expected/model.Mark.ts index fcccada3c..b48360b50 100644 --- a/ts/fixtures/task/expected/model.Mark.ts +++ b/ts/fixtures/task/expected/model.Mark.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; export interface Mark { - n: rt.u32; + n: rs.u32; } //# sourceMappingURL=model.Mark.ts.map diff --git a/ts/fixtures/task/expected/model.Outer.ts b/ts/fixtures/task/expected/model.Outer.ts index 3c16d3266..20c07a434 100644 --- a/ts/fixtures/task/expected/model.Outer.ts +++ b/ts/fixtures/task/expected/model.Outer.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Guard from "./model.Guard.ts"; import type * as Inner from "./model.Inner.ts"; @@ -18,7 +18,7 @@ export class Outer { } [Symbol.dispose](): void { - rt.drop(this.inner); + rs.drop(this.inner); this.guard[Symbol.dispose](); } } diff --git a/ts/fixtures/task/expected/model.Tally.ts b/ts/fixtures/task/expected/model.Tally.ts index f6d7dc7df..309f5fa8f 100644 --- a/ts/fixtures/task/expected/model.Tally.ts +++ b/ts/fixtures/task/expected/model.Tally.ts @@ -1,10 +1,10 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; /** A `Copy` value an `async move` block takes its own copy of. */ export interface Tally { - n: rt.u32; + n: rs.u32; } //# sourceMappingURL=model.Tally.ts.map diff --git a/ts/fixtures/task/expected/model.Watch.ts b/ts/fixtures/task/expected/model.Watch.ts index 0bb593383..dedaae1f1 100644 --- a/ts/fixtures/task/expected/model.Watch.ts +++ b/ts/fixtures/task/expected/model.Watch.ts @@ -1,6 +1,6 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import type * as Consumer from "./kio.Consumer.ts"; import type * as Waiter from "./kio.Waiter.ts"; import { streamed, at } from "./model.ts"; @@ -8,9 +8,9 @@ import { streamed, at } from "./model.ts"; /** The value at `index` of a channel, read by [`at`]. */ export class Watch { rx: Consumer.Consumer; - index: rt.usize; + index: rs.usize; - constructor(rx: Consumer.Consumer, index: rt.usize) { + constructor(rx: Consumer.Consumer, index: rs.usize) { this.rx = rx; this.index = index; } @@ -24,12 +24,12 @@ export class Watch { * What [`at`] reads, through [`streamed`]: a value of 3 modulo 4 errs, and is * watched as ten times itself. */ -export function poll$kio_Task(self: Watch, waiter: Waiter.Waiter): rt.Poll { - const _3: rt.Result, rt.u64> = streamed(at(self.rx, self.index, waiter)); +export function poll$kio_Task(self: Watch, waiter: Waiter.Waiter): rs.Poll { + const _3: rs.Result, rs.u64> = streamed(at(self.rx, self.index, waiter)); if (_3.ok) { return _3.value; } - return rt.u64Mul(_3.error, 10); + return rs.u64Mul(_3.error, 10); } //# sourceMappingURL=model.Watch.ts.map diff --git a/ts/fixtures/task/expected/model.ts b/ts/fixtures/task/expected/model.ts index a9d35d93d..94a3a2801 100644 --- a/ts/fixtures/task/expected/model.ts +++ b/ts/fixtures/task/expected/model.ts @@ -1,9 +1,9 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; import { copy$model_Tally, drop$Result_u32_model_Guard as lib_drop$Result_u32_model_Guard, drop$ops_ControlFlow_model_Guard_u32 as lib_drop$ops_ControlFlow_model_Guard_u32 } from "./lib.ts"; -import { unwrapOr$1tvry1i as option_unwrapOr$1tvry1i, map$0upmgd9 as option_map$0upmgd9 } from "./core/option.ts"; -import { map$0luclc8 as poll_map$0luclc8, map$1rs8nqy as poll_map$1rs8nqy, isReady$1sc8not, isPending$0vr1nz6 } from "./core/task/poll.ts"; +import { unwrapOr$15hbiwd as option_unwrapOr$15hbiwd, map$1nux4ms as option_map$1nux4ms } from "./core/option.ts"; +import { map$0u2hwi8 as poll_map$0u2hwi8, map$1wr0dnp as poll_map$1wr0dnp, isReady$0mapnag, isPending$0mrvg1b } from "./core/task/poll.ts"; import { wait$model_front_closure0_closure0_usize, wait$model_watch_closure0_closure0_Option_u64, waitFuture$kio_Consumer_model_watch_closure0_closure1_usize, closedFuture$kio_Consumer, recvFuture$kio_Consumer } from "./kio.ts"; import * as Closed from "./kio.Closed.ts"; import * as Consumer from "./kio.Consumer.ts"; @@ -23,7 +23,7 @@ import * as Watch from "./model.Watch.ts"; * Every value until the channel closes, summed, holding a guard of its own across * each await beside the one it was given. A value of 99 fails an `assert!`. */ -export function sum(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function sum(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new sumFuture(rx, guard); } @@ -32,8 +32,8 @@ export class sumFuture { #rx: Consumer.Consumer; #guard: Guard.Guard; #inner!: Guard.Guard; - #total!: rt.u64; - #awaitee!: rt.Future; + #total!: rs.u64; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { this.#rx = rx; @@ -45,26 +45,26 @@ export class sumFuture { this.#rx[Symbol.dispose](); this.#guard[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#inner[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { - this.#inner = Guard.new(rt.u32Add(this.#guard.id, 100), Log.clone$Clone(this.#guard.log)); + this.#inner = Guard.new(rs.u32Add(this.#guard.id, 100), Log.clone$Clone(this.#guard.log)); this.#total = 0; bb0 = 4; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 7; continue; @@ -74,27 +74,27 @@ export class sumFuture { bb0 = 7; continue; case 7: - const _11: rt.Poll = this.#awaitee.poll(_2); - if (_11 !== rt.Pending) { - const result: rt.u64 | undefined = _11; - rt.drop(this.#awaitee); + const _11: rs.Poll = this.#awaitee.poll(_2); + if (_11 !== rs.Pending) { + const result: rs.u64 | undefined = _11; + rs.drop(this.#awaitee); if (result !== undefined) { - const value: rt.u64 = result; + const value: rs.u64 = result; if (!(value !== 99)) { const arg2 = this.#guard.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg2, f)]; - rt.panicFmt(["g", args2[0], " poisoned"]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f)]; + rs.panicFmt(["g", args2[0], " poisoned"]); } else { const arg = this.#guard.id; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f), (f: rt.Formatter) => rt.u64Display(value, f)]; - const _32: string = rt.fmtFormat(["g", args4[0], " got ", args4[1]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f), (f: rs.Formatter) => rs.u64Display(value, f)]; + const _32: string = rs.fmtFormat(["g", args4[0], " got ", args4[1]]); Log.note(this.#inner.log, _32); - this.#total = rt.u64Add(this.#total, value); + this.#total = rs.u64Add(this.#total, value); bb0 = 4; continue; } } else { - const _47: rt.u64 = this.#total; + const _47: rs.u64 = this.#total; this.#inner[Symbol.dispose](); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); @@ -103,7 +103,7 @@ export class sumFuture { } } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -116,7 +116,7 @@ export class sumFuture { * `kio::wait`, then each by a `Task` of the crate's that a `Pending` drives, reached * through its `DerefMut` between awaits, which polls with [`at`]. */ -export function watch(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function watch(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new watchFuture(rx, guard); } @@ -124,17 +124,17 @@ export class watchFuture { #state: number = 0; #rx: Consumer.Consumer; #guard: Guard.Guard; - #first!: rt.u64 | undefined; - #next!: rt.Future; - #pinned!: rt.Future; - #next$2!: rt.Future; - #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + #first!: rs.u64 | undefined; + #next!: rs.Future; + #pinned!: rs.Future; + #next$2!: rs.Future; + #awaitee!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>; #pending!: Pending.Pending; - #total!: rt.u64; + #total!: rs.u64; #awaitee$2!: Pending.Pending; #watch!: Watch.Watch; - #awaitee$3!: rt.Future; - #awaitee$4!: rt.Future>; + #awaitee$3!: rs.Future; + #awaitee$4!: rs.Future>; #saved!: boolean; #saved$2!: boolean; @@ -153,16 +153,16 @@ export class watchFuture { } if (this.#state === 3) { this.#awaitee[Symbol.dispose](); - rt.drop(this.#pinned); + rs.drop(this.#pinned); break b0; } if (this.#state === 4) { break b1; } if (this.#state === 5) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 6) { - rt.drop(this.#awaitee$4); + rs.drop(this.#awaitee$4); } else { return; } @@ -180,8 +180,8 @@ export class watchFuture { this.#saved$2 = false; } - poll(_2: rt.Context): rt.Poll { - let value!: rt.u64; + poll(_2: rs.Context): rs.Poll { + let value!: rs.u64; let bb0: number = 0; while (true) { switch (bb0) { @@ -193,14 +193,14 @@ export class watchFuture { this.#pinned = new recvFuture$kio_Consumer(this.#rx); this.#next = this.#pinned; this.#next$2 = this.#next; - this.#awaitee = wait$model_watch_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rt.Poll => { + this.#awaitee = wait$model_watch_closure0_closure0_Option_u64((waiter: Waiter.Waiter): rs.Poll => { return Waiter.pollFuture$dyn_Future_Option_u64(waiter, this.#next$2); }); bb0 = 6; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { if (this.#state === 3) { bb0 = 6; @@ -218,40 +218,40 @@ export class watchFuture { continue; } case 6: - const _12: rt.Poll = Pending.poll$Future_model_watch_closure0_closure0(this.#awaitee, _2); - if (_12 !== rt.Pending) { + const _12: rs.Poll = Pending.poll$Future_model_watch_closure0_closure0(this.#awaitee, _2); + if (_12 !== rs.Pending) { this.#first = _12; this.#awaitee[Symbol.dispose](); - rt.drop(this.#pinned); + rs.drop(this.#pinned); const arg = this.#first; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(arg, f, rt.u64Debug)]; - const _22: string = rt.fmtFormat(["first ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, rs.u64Debug)]; + const _22: string = rs.fmtFormat(["first ", args2[0]]); Guard.note(this.#guard, _22); this.#saved$2 = false; this.#pending = Pending.new$model_Watch(new Watch.Watch(this.#rx, 1)); this.#saved = true; - this.#total = option_unwrapOr$1tvry1i(this.#first, 0); + this.#total = option_unwrapOr$15hbiwd(this.#first, 0); bb0 = 23; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 23: this.#awaitee$2 = this.#pending; bb0 = 25; continue; case 25: - const _38: rt.Poll = Pending.poll$Future_model_Watch(this.#awaitee$2, _2); - if (_38 !== rt.Pending) { - const result2: rt.u64 | undefined = _38; + const _38: rs.Poll = Pending.poll$Future_model_Watch(this.#awaitee$2, _2); + if (_38 !== rs.Pending) { + const result2: rs.u64 | undefined = _38; if (result2 !== undefined) { value = result2; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(value, f)]; - const _50: string = rt.fmtFormat(["watched ", args4[0]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(value, f)]; + const _50: string = rs.fmtFormat(["watched ", args4[0]]); Guard.note(this.#guard, _50); - this.#total = rt.u64Add(this.#total, value); + this.#total = rs.u64Add(this.#total, value); const _62: Watch.Watch = Pending.derefMut$ops_DerefMut_model_Watch(this.#pending); - _62.index = rt.usizeAdd(_62.index, 1); + _62.index = rs.usizeAdd(_62.index, 1); bb0 = 23; continue; } @@ -262,28 +262,28 @@ export class watchFuture { continue; } this.#state = 4; - return rt.Pending; + return rs.Pending; case 45: - if (this.#awaitee$3.poll(_2) !== rt.Pending) { - rt.drop(this.#awaitee$3); - this.#awaitee$4 = new waitFuture$kio_Consumer_model_watch_closure0_closure1_usize(this.#watch.rx, (queue: rt.u64[]): rt.Poll => { + if (this.#awaitee$3.poll(_2) !== rs.Pending) { + rs.drop(this.#awaitee$3); + this.#awaitee$4 = new waitFuture$kio_Consumer_model_watch_closure0_closure1_usize(this.#watch.rx, (queue: rs.u64[]): rs.Poll => { return queue.length; }); bb0 = 53; continue; } this.#state = 5; - return rt.Pending; + return rs.Pending; case 53: - const _82: rt.Poll> = this.#awaitee$4.poll(_2); - if (_82 !== rt.Pending) { - const sent: rt.Result = _82; - rt.drop(this.#awaitee$4); + const _82: rs.Poll> = this.#awaitee$4.poll(_2); + if (_82 !== rs.Pending) { + const sent: rs.Result = _82; + rs.drop(this.#awaitee$4); const arg2 = this.#watch.index; - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(arg2, f), (f: rt.Formatter) => rt.fmtResult(sent, f, rt.usizeDebug, (value: Closed.Closed, f: rt.Formatter) => Closed.fmt$fmt_Debug(value, f))]; - const _92: string = rt.fmtFormat(["watched to ", args6[0], " of ", args6[1]]); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(arg2, f), (f: rs.Formatter) => rs.fmtResult(sent, f, rs.usizeDebug, (value: Closed.Closed, f: rs.Formatter) => Closed.fmt$fmt_Debug(value, f))]; + const _92: string = rs.fmtFormat(["watched to ", args6[0], " of ", args6[1]]); Guard.note(this.#guard, _92); - const _109: rt.u64 = this.#total; + const _109: rs.u64 = this.#total; this.#watch[Symbol.dispose](); this.#saved = false; this.#guard[Symbol.dispose](); @@ -292,7 +292,7 @@ export class watchFuture { return _109; } this.#state = 6; - return rt.Pending; + return rs.Pending; } } } @@ -303,7 +303,7 @@ export class watchFuture { * values held in flight in a `Vec` that a `kio::wait` closure takes and refills on each * poll, halving each until it is zero. The caller reads both after. */ -export function front(rx: Consumer.Consumer, guard: Guard.Guard): rt.Future { +export function front(rx: Consumer.Consumer, guard: Guard.Guard): rs.Future { return new frontFuture(rx, guard); } @@ -312,9 +312,9 @@ export class frontFuture { #rx: Consumer.Consumer; #guard: Guard.Guard; #listing!: Listing.Listing | undefined; - #inFlight!: rt.Vec; - #awaitee!: rt.Future; - #awaitee$2!: Pending.Pending<(a0: Waiter.Waiter) => rt.Poll>; + #inFlight!: rs.Vec; + #awaitee!: rs.Future; + #awaitee$2!: Pending.Pending<(a0: Waiter.Waiter) => rs.Poll>; constructor(rx: Consumer.Consumer, guard: Guard.Guard) { this.#rx = rx; @@ -328,7 +328,7 @@ export class frontFuture { return; } if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else if (this.#state === 4) { this.#awaitee$2[Symbol.dispose](); } else { @@ -338,20 +338,20 @@ export class frontFuture { this.#rx[Symbol.dispose](); } - poll(_2: rt.Context): rt.Poll { - let value!: rt.u64; + poll(_2: rs.Context): rs.Poll { + let value!: rs.u64; let bb0: number = 0; while (true) { switch (bb0) { case 0: if (this.#state === 0) { this.#listing = undefined as Listing.Listing | undefined; - this.#inFlight = new rt.Vec(); + this.#inFlight = new rs.Vec(); bb0 = 1; continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { if (this.#state === 3) { bb0 = 4; @@ -365,20 +365,20 @@ export class frontFuture { bb0 = 4; continue; case 4: - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - const result: rt.u64 | undefined = _6; - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + const result: rs.u64 | undefined = _6; + rs.drop(this.#awaitee); if (result !== undefined) { value = result; - if (!(rt.u64Rem(value, 3) === 0)) { + if (!(rs.u64Rem(value, 3) === 0)) { if (this.#listing === undefined) { this.#listing = Listing.default$Default(); } (this.#listing as Listing.Listing).last = value; (this.#listing as Listing.Listing).listed.items.push(value); this.#inFlight.items.push(value); - if (!(rt.u64Rem(value, 3) === 2)) { + if (!(rs.u64Rem(value, 3) === 2)) { bb0 = 1; continue; } @@ -393,17 +393,17 @@ export class frontFuture { continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 23: const arg = this.#listing; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtOption(arg, f, (value: Listing.Listing, f: rt.Formatter) => Listing.fmt$fmt_Debug(value, f))]; - const _32: string = rt.fmtFormat(["listing ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtOption(arg, f, (value: Listing.Listing, f: rs.Formatter) => Listing.fmt$fmt_Debug(value, f))]; + const _32: string = rs.fmtFormat(["listing ", args2[0]]); Guard.note(this.#guard, _32); - this.#awaitee$2 = wait$model_front_closure0_closure0_usize((waiter: Waiter.Waiter): rt.Poll => { + this.#awaitee$2 = wait$model_front_closure0_closure0_usize((waiter: Waiter.Waiter): rs.Poll => { while (true) { - const _42: rt.Poll = Consumer.pollRecv(this.#rx, waiter); - if (_42 !== rt.Pending) { - const next: rt.u64 | undefined = _42; + const _42: rs.Poll = Consumer.pollRecv(this.#rx, waiter); + if (_42 !== rs.Pending) { + const next: rs.u64 | undefined = _42; if (next === undefined) { return this.#inFlight.items.length; } @@ -413,37 +413,37 @@ export class frontFuture { } } const taken = this.#inFlight; - this.#inFlight = new rt.Vec(); + this.#inFlight = new rs.Vec(); for (const _15 of taken.items) { - const half: rt.u64 = rt.u64Div(_15, 2); + const half: rs.u64 = rs.u64Div(_15, 2); if (half === 0) { Guard.note(this.#guard, "released"); } else { this.#inFlight.items.push(half); } } - return rt.Pending; + return rs.Pending; }); bb0 = 33; continue; case 33: - const _50: rt.Poll = Pending.poll$Future_model_front_closure0_closure0(this.#awaitee$2, _2); - if (_50 !== rt.Pending) { - const closed: rt.usize = _50; + const _50: rs.Poll = Pending.poll$Future_model_front_closure0_closure0(this.#awaitee$2, _2); + if (_50 !== rs.Pending) { + const closed: rs.usize = _50; this.#awaitee$2[Symbol.dispose](); - const _69: rt.Fmt = (f: rt.Formatter) => rt.usizeDisplay(closed, f); + const _69: rs.Fmt = (f: rs.Formatter) => rs.usizeDisplay(closed, f); const arg2 = this.#inFlight; - const args4: rt.Fmt[] = [_69, (f: rt.Formatter) => rt.fmtList(arg2.items, f, rt.u64Debug)]; - const _60: string = rt.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]); + const args4: rs.Fmt[] = [_69, (f: rs.Formatter) => rs.fmtList(arg2.items, f, rs.u64Debug)]; + const _60: string = rs.fmtFormat(["closed with ", args4[0], " in flight ", args4[1]]); Guard.note(this.#guard, _60); - const _79: rt.u64 = rt.iterSum(rt.iterSlice(this.#inFlight.items), rt.u64Add, 0); + const _79: rs.u64 = rs.iterSum(rs.iterSlice(this.#inFlight.items), rs.u64Add, 0); this.#guard[Symbol.dispose](); this.#rx[Symbol.dispose](); this.#state = 1; return _79; } this.#state = 4; - return rt.Pending; + return rs.Pending; } } } @@ -453,17 +453,17 @@ export class frontFuture { * `polled` as a stream's `poll_next` returns it, erring on a value of 3 modulo 4, then * back through `?`, which continues with its `Pending` and `Ready(None)`. */ -export function streamed(polled: rt.Poll): rt.Result, rt.u64> { - const _3: rt.Result, rt.u64> = rt.pollOptionBranch(poll_map$0luclc8(polled, (value: rt.u64 | undefined): rt.Result | undefined => { - return option_map$0upmgd9(value, (value2: rt.u64): rt.Result => { - if (!(rt.u64Rem(value2, 4) === 3)) { - return rt.Ok(value2); +export function streamed(polled: rs.Poll): rs.Result, rs.u64> { + const _3: rs.Result, rs.u64> = rs.pollOptionBranch(poll_map$0u2hwi8(polled, (value: rs.u64 | undefined): rs.Result | undefined => { + return option_map$1nux4ms(value, (value2: rs.u64): rs.Result => { + if (!(rs.u64Rem(value2, 4) === 3)) { + return rs.Ok(value2); } - return rt.Err(value2); + return rs.Err(value2); }); - }), rt.Pending, undefined); + }), rs.Pending, undefined); if (_3.ok) { - return rt.Ok(_3.value); + return rs.Ok(_3.value); } return _3; } @@ -474,22 +474,22 @@ export function streamed(polled: rt.Poll): rt.Result>`, outside until the value arrives, and inside while it is even and the * one after it hasn't: then it waits on the channel, and the close drops it. */ -export function at(rx: Consumer.Consumer, index: rt.usize, waiter: Waiter.Waiter): rt.Poll { - let res!: rt.Poll; - const _5: rt.Result | rt.OuterPending, Closed.Closed> = held(rx, index, waiter); +export function at(rx: Consumer.Consumer, index: rs.usize, waiter: Waiter.Waiter): rs.Poll { + let res!: rs.Poll; + const _5: rs.Result | rs.OuterPending, Closed.Closed> = held(rx, index, waiter); if (_5.ok) { - if (_5.value !== rt.OuterPending) { - res = poll_map$1rs8nqy(_5.value, (a0: rt.u64): rt.u64 | undefined => { + if (_5.value !== rs.OuterPending) { + res = poll_map$1wr0dnp(_5.value, (a0: rs.u64): rs.u64 | undefined => { return a0; }); } else { - res = rt.Pending as rt.Poll; + res = rs.Pending as rs.Poll; } } else { - res = undefined as rt.Poll; + res = undefined as rs.Poll; } - if (isPending$0vr1nz6(res)) { - if (isReady$1sc8not(Consumer.pollClosed(rx, waiter))) { + if (isPending$0mrvg1b(res)) { + if (isReady$0mapnag(Consumer.pollClosed(rx, waiter))) { return undefined; } } @@ -500,23 +500,23 @@ export function at(rx: Consumer.Consumer, index: rt.usize, waiter: Waiter.Waiter * [`at`]'s poll, through `?` on what kio's `Consumer::poll` returns, which continues with * its `Pending`. */ -export function held(rx: Consumer.Consumer, index: rt.usize, waiter: Waiter.Waiter): rt.Result | rt.OuterPending, Closed.Closed> { - const _4: rt.Result | rt.OuterPending, Closed.Closed> = rt.pollBranch(Consumer.poll$model_held_closure0_task_Poll_u64(rx, waiter, (queue: rt.u64[]): rt.Poll | rt.OuterPending => { - const _3: rt.u64 | undefined = rt.sliceGet(queue, index); +export function held(rx: Consumer.Consumer, index: rs.usize, waiter: Waiter.Waiter): rs.Result | rs.OuterPending, Closed.Closed> { + const _4: rs.Result | rs.OuterPending, Closed.Closed> = rs.pollBranch(Consumer.poll$model_held_closure0_task_Poll_u64(rx, waiter, (queue: rs.u64[]): rs.Poll | rs.OuterPending => { + const _3: rs.u64 | undefined = rs.sliceGet(queue, index); if (_3 === undefined) { - return rt.OuterPending; + return rs.OuterPending; } - if (rt.u64Rem(_3, 2) === 0) { - if (queue.length === rt.usizeAdd(index, 1)) { - return rt.Pending; + if (rs.u64Rem(_3, 2) === 0) { + if (queue.length === rs.usizeAdd(index, 1)) { + return rs.Pending; } } return _3; - }), rt.OuterPending); + }), rs.OuterPending); if (_4.ok) { - return rt.Ok(_4.value); + return rs.Ok(_4.value); } - return rt.Err({}); + return rs.Err({}); } /** @@ -528,7 +528,7 @@ export function held(rx: Consumer.Consumer, index: rt.usize, waiter: Waiter.Wait * a value of two types that hold each other, and guards held across awaits that read * values first. */ -export function blocks(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): rt.Future { +export function blocks(rx: Consumer.Consumer, guard: Guard.Guard, moves: boolean): rs.Future { return new blocksFuture(rx, guard, moves); } @@ -539,20 +539,20 @@ export class blocksFuture { #moves: boolean; #first!: Guard.Guard; #second!: Guard.Guard; - #waited!: rt.u64; + #waited!: rs.u64; #saved!: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; #slots!: Guard.Guard[]; - #awaitee$2!: rt.Future; + #awaitee$2!: rs.Future; #tally!: Tally.Tally; - #saved$2!: rt.u32; - #awaitee$3!: rt.Future; + #saved$2!: rs.u32; + #awaitee$3!: rs.Future; #mark!: Mark.Mark; - #count!: rt.u32; - #counted!: rt.u32; + #count!: rs.u32; + #counted!: rs.u32; #nested!: Inner.Inner; - #looped!: rt.u32; - #awaitee$4!: rt.Future; + #looped!: rs.u32; + #awaitee$4!: rs.Future; #saved$3!: boolean; #saved$4!: boolean; #saved$5!: boolean; @@ -574,31 +574,31 @@ export class blocksFuture { return; } if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#saved[Symbol.dispose](); break b0; } if (this.#state === 4) { - rt.drop(this.#awaitee$2); + rs.drop(this.#awaitee$2); this.#saved[Symbol.dispose](); break b1; } if (this.#state === 5) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b2; } if (this.#state === 6) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b2; } if (this.#state === 7) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); break b2; } if (this.#state === 8) { - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); } else if (this.#state === 9) { - rt.drop(this.#awaitee$4); + rs.drop(this.#awaitee$4); } else { return; } @@ -606,7 +606,7 @@ export class blocksFuture { this.#nested[Symbol.dispose](); } } - rt.dropAll(this.#slots); + rs.dropAll(this.#slots); } if (this.#saved$4) { this.#second[Symbol.dispose](); @@ -626,7 +626,7 @@ export class blocksFuture { this.#saved$6 = false; } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { b0: { b1: { b2: { @@ -640,17 +640,17 @@ export class blocksFuture { this.#saved$4 = false; this.#saved$6 = true; this.#saved$3 = true; - this.#first = Guard.new(rt.u32Add(this.#guard.id, 200), Log.clone$Clone(this.#guard.log)); + this.#first = Guard.new(rs.u32Add(this.#guard.id, 200), Log.clone$Clone(this.#guard.log)); this.#saved$5 = true; - this.#second = Guard.new(rt.u32Add(this.#guard.id, 300), Log.clone$Clone(this.#guard.log)); + this.#second = Guard.new(rs.u32Add(this.#guard.id, 300), Log.clone$Clone(this.#guard.log)); this.#saved$4 = true; - rt.drop(new blocksFuture$closure0(this.#first)); - turns(this.#guard.log, rt.u32Rem(this.#guard.id, 5)); + rs.drop(new blocksFuture$closure0(this.#first)); + turns(this.#guard.log, rs.u32Rem(this.#guard.id, 5)); temporaries(this.#guard.log, this.#guard.id); - this.#saved = Guard.new(rt.u32Add(this.#guard.id, 900), Log.clone$Clone(this.#guard.log)); + this.#saved = Guard.new(rs.u32Add(this.#guard.id, 900), Log.clone$Clone(this.#guard.log)); this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else if (this.#state !== 3) { if (this.#state === 4) { break b5; @@ -669,87 +669,87 @@ export class blocksFuture { } break b0; } - const _32: rt.Poll = this.#awaitee.poll(_2); - if (_32 !== rt.Pending) { - const result: rt.u64 | undefined = _32; - rt.drop(this.#awaitee); + const _32: rs.Poll = this.#awaitee.poll(_2); + if (_32 !== rs.Pending) { + const result: rs.u64 | undefined = _32; + rs.drop(this.#awaitee); this.#waited = consume(this.#saved, result); - this.#slots = [Guard.new(rt.u32Add(this.#guard.id, 910), Log.clone$Clone(this.#guard.log)), Guard.new(rt.u32Add(this.#guard.id, 920), Log.clone$Clone(this.#guard.log))]; - this.#saved = Guard.new(rt.u32Add(this.#guard.id, 930), Log.clone$Clone(this.#guard.log)); + this.#slots = [Guard.new(rs.u32Add(this.#guard.id, 910), Log.clone$Clone(this.#guard.log)), Guard.new(rs.u32Add(this.#guard.id, 920), Log.clone$Clone(this.#guard.log))]; + this.#saved = Guard.new(rs.u32Add(this.#guard.id, 930), Log.clone$Clone(this.#guard.log)); this.#awaitee$2 = new slotFuture(this.#rx, this.#slots.length); } else { this.#state = 3; - return rt.Pending; + return rs.Pending; } } - const _63: rt.Poll = this.#awaitee$2.poll(_2); - if (_63 !== rt.Pending) { - const result2: rt.usize = _63; - rt.drop(this.#awaitee$2); + const _63: rs.Poll = this.#awaitee$2.poll(_2); + if (_63 !== rs.Pending) { + const result2: rs.usize = _63; + rs.drop(this.#awaitee$2); if (!(result2 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + result2); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + result2); } this.#slots[result2][Symbol.dispose](); this.#slots[result2] = this.#saved; const arg = this.#waited; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u64Display(arg, f)]; - const _76: string = rt.fmtFormat(["slot after ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u64Display(arg, f)]; + const _76: string = rs.fmtFormat(["slot after ", args2[0]]); Guard.note(this.#slots[0], _76); this.#tally = { n: this.#guard.id }; - const seen: rt.Future = new blocksFuture$closure1(copy$model_Tally(this.#tally)); - this.#tally.n = rt.u32Add(this.#tally.n, 1000); + const seen: rs.Future = new blocksFuture$closure1(copy$model_Tally(this.#tally)); + this.#tally.n = rs.u32Add(this.#tally.n, 1000); this.#saved = this.#guard; this.#saved$2 = this.#tally.n; this.#awaitee$3 = seen; } else { this.#state = 4; - return rt.Pending; + return rs.Pending; } } - const _100: rt.Poll = this.#awaitee$3.poll(_2); - if (_100 !== rt.Pending) { - const _98: rt.u32 = _100; - rt.drop(this.#awaitee$3); + const _100: rs.Poll = this.#awaitee$3.poll(_2); + if (_100 !== rs.Pending) { + const _98: rs.u32 = _100; + rs.drop(this.#awaitee$3); const arg2 = this.#saved$2; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.u32Display(_98, f)]; - const _91: string = rt.fmtFormat(["tally ", args4[0], " then ", args4[1]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.u32Display(_98, f)]; + const _91: string = rs.fmtFormat(["tally ", args4[0], " then ", args4[1]]); Guard.note(this.#saved, _91); this.#mark = { n: 1 }; this.#awaitee$3 = new blocksFuture$closure2(this.#mark); } else { this.#state = 5; - return rt.Pending; + return rs.Pending; } } - const _116: rt.Poll = this.#awaitee$3.poll(_2); - if (_116 !== rt.Pending) { + const _116: rs.Poll = this.#awaitee$3.poll(_2); + if (_116 !== rs.Pending) { this.#saved$2 = _116; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); const arg3 = this.#saved$2; - const _135: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg3, f); + const _135: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg3, f); const arg4 = this.#mark.n; - const args6: rt.Fmt[] = [_135, (f: rt.Formatter) => rt.u32Display(arg4, f)]; - const _126: string = rt.fmtFormat(["mark ", args6[0], " ", args6[1]]); + const args6: rs.Fmt[] = [_135, (f: rs.Formatter) => rs.u32Display(arg4, f)]; + const _126: string = rs.fmtFormat(["mark ", args6[0], " ", args6[1]]); Guard.note(this.#guard, _126); this.#count = this.#guard.id; - this.#awaitee$3 = new blocksFuture$closure3(rt.place(() => this.#count, (value) => this.#count = value)); + this.#awaitee$3 = new blocksFuture$closure3(rs.place(() => this.#count, (value) => this.#count = value)); } else { this.#state = 6; - return rt.Pending; + return rs.Pending; } } - const _142: rt.Poll = this.#awaitee$3.poll(_2); - if (_142 !== rt.Pending) { + const _142: rs.Poll = this.#awaitee$3.poll(_2); + if (_142 !== rs.Pending) { this.#counted = _142; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); const arg5 = this.#counted; - const _161: rt.Fmt = (f: rt.Formatter) => rt.u32Display(arg5, f); + const _161: rs.Fmt = (f: rs.Formatter) => rs.u32Display(arg5, f); const arg6 = this.#count; - const args8: rt.Fmt[] = [_161, (f: rt.Formatter) => rt.u32Display(arg6, f)]; - const _152: string = rt.fmtFormat(["count ", args8[0], " ", args8[1]]); + const args8: rs.Fmt[] = [_161, (f: rs.Formatter) => rs.u32Display(arg6, f)]; + const _152: string = rs.fmtFormat(["count ", args8[0], " ", args8[1]]); Guard.note(this.#guard, _152); - this.#nested = new Inner.Inner(new Outer.Outer(undefined, Guard.new(rt.u32Add(this.#guard.id, 800), Log.clone$Clone(this.#guard.log)))); - const third: Guard.Guard = Guard.new(rt.u32Add(this.#guard.id, 400), Log.clone$Clone(this.#guard.log)); + this.#nested = new Inner.Inner(new Outer.Outer(undefined, Guard.new(rs.u32Add(this.#guard.id, 800), Log.clone$Clone(this.#guard.log)))); + const third: Guard.Guard = Guard.new(rs.u32Add(this.#guard.id, 400), Log.clone$Clone(this.#guard.log)); if (!this.#moves) { this.#saved = third; } else { @@ -759,20 +759,20 @@ export class blocksFuture { this.#awaitee$3 = new blocksFuture$closure4(this.#guard.id); } else { this.#state = 7; - return rt.Pending; + return rs.Pending; } } - const _187: rt.Poll = this.#awaitee$3.poll(_2); - if (_187 !== rt.Pending) { + const _187: rs.Poll = this.#awaitee$3.poll(_2); + if (_187 !== rs.Pending) { this.#looped = _187; - rt.drop(this.#awaitee$3); + rs.drop(this.#awaitee$3); const arg7 = this.#looped; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg7, f)]; - const _197: string = rt.fmtFormat(["looped ", args10[0]]); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg7, f)]; + const _197: string = rs.fmtFormat(["looped ", args10[0]]); Guard.note(this.#saved, _197); if (this.#moves) { this.#saved$3 = false; - rt.drop(new blocksFuture$closure5(this.#guard)); + rs.drop(new blocksFuture$closure5(this.#guard)); } this.#saved$5 = false; this.#saved$4 = false; @@ -780,16 +780,16 @@ export class blocksFuture { this.#awaitee$4 = new blocksFuture$closure6(this.#first, this.#second, this.#rx); } else { this.#state = 8; - return rt.Pending; + return rs.Pending; } } - const _213: rt.Poll = this.#awaitee$4.poll(_2); - if (_213 !== rt.Pending) { - const result7: rt.u64 = _213; - rt.drop(this.#awaitee$4); + const _213: rs.Poll = this.#awaitee$4.poll(_2); + if (_213 !== rs.Pending) { + const result7: rs.u64 = _213; + rs.drop(this.#awaitee$4); this.#saved[Symbol.dispose](); this.#nested[Symbol.dispose](); - rt.dropAll(this.#slots); + rs.dropAll(this.#slots); this.#saved$4 = false; this.#saved$5 = false; if (this.#saved$3) { @@ -801,7 +801,7 @@ export class blocksFuture { return result7; } this.#state = 9; - return rt.Pending; + return rs.Pending; } } @@ -816,13 +816,13 @@ export class blocksFuture$closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { Guard.note(this.#first, "borrowed"); this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -837,13 +837,13 @@ export class blocksFuture$closure1 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - const _0: rt.Poll = read(this.#tally); + const _0: rs.Poll = read(this.#tally); this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -858,49 +858,49 @@ export class blocksFuture$closure2 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { const _3: Mark.Mark = { n: 2 }; Object.assign(this.#mark, _3); - const _0: rt.Poll = this.#mark.n; + const _0: rs.Poll = this.#mark.n; this.#state = 1; return _0; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class blocksFuture$closure3 { #state: number = 0; - #count: rt.Place; - #awaitee!: rt.Future; + #count: rs.Place; + #awaitee!: rs.Future; - constructor(count: rt.Place) { + constructor(count: rs.Place) { this.#count = count; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { - this.#count.v = rt.u32Add(this.#count.v, 1); + this.#count.v = rs.u32Add(this.#count.v, 1); this.#awaitee = new blocksFuture$closure3_closure0(); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - if (this.#awaitee.poll(_2) !== rt.Pending) { - rt.drop(this.#awaitee); - this.#count.v = rt.u32Add(this.#count.v, 1); - const _0: rt.Poll = this.#count.v; + if (this.#awaitee.poll(_2) !== rs.Pending) { + rs.drop(this.#awaitee); + this.#count.v = rs.u32Add(this.#count.v, 1); + const _0: rs.Poll = this.#count.v; this.#state = 1; return _0; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -910,34 +910,34 @@ export class blocksFuture$closure3_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } export class blocksFuture$closure4 { #state: number = 0; - #base: rt.u32; - #total!: rt.u32; - #passes!: rt.i32; - #x!: rt.u32; - #awaitee!: rt.Future; + #base: rs.u32; + #total!: rs.u32; + #passes!: rs.i32; + #x!: rs.u32; + #awaitee!: rs.Future; - constructor(base: rt.u32) { + constructor(base: rs.u32) { this.#base = base; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { let bb0: number = 0; while (true) { switch (bb0) { @@ -949,32 +949,32 @@ export class blocksFuture$closure4 { continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { bb0 = 5; continue; } case 1: if (!(this.#passes < 2)) { - const _0: rt.Poll = this.#total; + const _0: rs.Poll = this.#total; this.#state = 1; return _0; } this.#x = this.#base; - this.#x = rt.u32Add(this.#x, 1); + this.#x = rs.u32Add(this.#x, 1); this.#awaitee = new blocksFuture$closure4_closure0(); bb0 = 5; continue; case 5: - if (this.#awaitee.poll(_2) !== rt.Pending) { - rt.drop(this.#awaitee); - this.#total = rt.u32Add(this.#total, this.#x); - this.#passes = rt.i32Add(this.#passes, 1); + if (this.#awaitee.poll(_2) !== rs.Pending) { + rs.drop(this.#awaitee); + this.#total = rs.u32Add(this.#total, this.#x); + this.#passes = rs.i32Add(this.#passes, 1); bb0 = 1; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } } @@ -986,12 +986,12 @@ export class blocksFuture$closure4_closure0 { [Symbol.dispose](): void { } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -1009,14 +1009,14 @@ export class blocksFuture$closure5 { } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { Guard.note(this.#guard, "moved"); this.#guard[Symbol.dispose](); this.#state = 1; return undefined; } - rt.asyncFnResumed(); + rs.asyncFnResumed(); } } @@ -1026,7 +1026,7 @@ export class blocksFuture$closure6 { #second: Guard.Guard; #rx: Consumer.Consumer; #held!: Guard.Guard; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(first: Guard.Guard, second: Guard.Guard, rx: Consumer.Consumer) { this.#first = first; @@ -1040,7 +1040,7 @@ export class blocksFuture$closure6 { this.#second[Symbol.dispose](); this.#rx[Symbol.dispose](); } else if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); this.#held[Symbol.dispose](); this.#first[Symbol.dispose](); this.#second[Symbol.dispose](); @@ -1048,20 +1048,20 @@ export class blocksFuture$closure6 { } } - poll(_2: rt.Context): rt.Poll { - let _27!: rt.u64; + poll(_2: rs.Context): rs.Poll { + let _27!: rs.u64; if (this.#state === 0) { Guard.note(this.#first, "reads"); Guard.note(this.#second, "reads"); - this.#held = Guard.new(rt.u32Add(this.#second.id, 100), Log.clone$Clone(this.#second.log)); + this.#held = Guard.new(rs.u32Add(this.#second.id, 100), Log.clone$Clone(this.#second.log)); this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _17: rt.Poll = this.#awaitee.poll(_2); - if (_17 !== rt.Pending) { - const result: rt.u64 | undefined = _17; - rt.drop(this.#awaitee); + const _17: rs.Poll = this.#awaitee.poll(_2); + if (_17 !== rs.Pending) { + const result: rs.u64 | undefined = _17; + rs.drop(this.#awaitee); if (result === undefined) { _27 = 0; } else { @@ -1075,53 +1075,53 @@ export class blocksFuture$closure6 { return _27; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } /** `v`, or 0, plus the id of `guard`, which it drops. */ -export function consume(guard: Guard.Guard, v: rt.u64 | undefined): rt.u64 { - return rt.u64Add(Guard.finish(guard, "consumed") as rt.u64, option_unwrapOr$1tvry1i(v, 0)); +export function consume(guard: Guard.Guard, v: rs.u64 | undefined): rs.u64 { + return rs.u64Add(Guard.finish(guard, "consumed") as rs.u64, option_unwrapOr$15hbiwd(v, 0)); } export class slotFuture { #state: number = 0; #_constructor: Consumer.Consumer; - #eval: rt.usize; - #awaitee!: rt.Future; + #eval: rs.usize; + #awaitee!: rs.Future; - constructor(_constructor: Consumer.Consumer, eval_: rt.usize) { + constructor(_constructor: Consumer.Consumer, eval_: rs.usize) { this.#_constructor = _constructor; this.#eval = eval_; } [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { - let _19!: rt.usize; + poll(_2: rs.Context): rs.Poll { + let _19!: rs.usize; if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#_constructor); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - const result: rt.u64 | undefined = _6; - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + const result: rs.u64 | undefined = _6; + rs.drop(this.#awaitee); if (result === undefined) { _19 = 0; } else { - _19 = rt.usizeRem(rt.u64Low(result), this.#eval); + _19 = rs.usizeRem(rs.u64Low(result), this.#eval); } this.#state = 1; return _19; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } @@ -1132,15 +1132,15 @@ export class slotFuture { * a pattern moves out of an array, an empty repeat at once, a closure's captures in its * call, and an iterator's after its loop. */ -export function temporaries(log: Log.Log, id: rt.u32): void { - let matched!: rt.i32; - const guard: (a0: rt.u32) => Guard.Guard = (n2: rt.u32): Guard.Guard => { - return Guard.new(rt.u32Add(id, n2), Log.clone$Clone(log)); +export function temporaries(log: Log.Log, id: rs.u32): void { + let matched!: rs.i32; + const guard: (a0: rs.u32) => Guard.Guard = (n2: rs.u32): Guard.Guard => { + return Guard.new(rs.u32Add(id, n2), Log.clone$Clone(log)); }; const _11: Guard.Guard = guard(1000); const arg = _11.id; - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg, f)]; - const _7: string = rt.fmtFormat(["temporary ", args2[0]]); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg, f)]; + const _7: string = rs.fmtFormat(["temporary ", args2[0]]); _11[Symbol.dispose](); Log.note(log, _7); const _19: Guard.Guard | undefined = guard(1010); @@ -1149,23 +1149,23 @@ export function temporaries(log: Log.Log, id: rt.u32): void { } else { matched = 1; } - rt.drop(_19); + rs.drop(_19); const _24: Guard.Guard | undefined = guard(1020); if (_24 === undefined) { - Log.note(log, rt.fmtFormat(["unmatched"])); - rt.drop(_24); + Log.note(log, rs.fmtFormat(["unmatched"])); + rs.drop(_24); } else { - rt.drop(_24); + rs.drop(_24); } const _39: Guard.Guard = guard(1030); const arg2 = _39.id; - const args4: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(arg2, f), (f: rt.Formatter) => rt.i32Display(matched, f)]; - const _35: string = rt.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); + const args4: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(arg2, f), (f: rs.Formatter) => rs.i32Display(matched, f)]; + const _35: string = rs.fmtFormat(["boxed temporary ", args4[0], " ", args4[1]]); _39[Symbol.dispose](); Log.note(log, _35); const part = first([guard(1040), guard(1050)] as [Guard.Guard, Guard.Guard]); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["skipped ", args6[0]])); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["skipped ", args6[0]])); const _69: Guard.Guard[] = [guard(1060), guard(1070), guard(1080)]; const head: Guard.Guard = _69[0]; const rest: Guard.Guard[] = _69.slice(1, 3); @@ -1174,47 +1174,47 @@ export function temporaries(log: Log.Log, id: rt.u32): void { guard(1090)[Symbol.dispose](); const _98: Guard.Guard[] = []; const part2 = _98.length; - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(part2, f)]; - Log.note(log, rt.fmtFormat(["empty ", args8[0]])); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(part2, f)]; + Log.note(log, rs.fmtFormat(["empty ", args8[0]])); const captured = guard(1100); - const part3 = rt.closure((): rt.u32 => { + const part3 = rs.closure((): rs.u32 => { return Guard.finish(captured, "closure"); }, (): void => { captured[Symbol.dispose](); })(); - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part3, f)]; - Log.note(log, rt.fmtFormat(["closed ", args10[0]])); - let sum: rt.u32 = 0; + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part3, f)]; + Log.note(log, rs.fmtFormat(["closed ", args10[0]])); + let sum: rs.u32 = 0; const iter: Countdown.Countdown = new Countdown.Countdown(2, guard(1110)); while (true) { - const _126: rt.u32 | rt.Done = Countdown.next$iter_Iterator(iter); - if (_126 === rt.DONE) { + const _126: rs.u32 | rs.Done = Countdown.next$iter_Iterator(iter); + if (_126 === rs.DONE) { break; } - sum = rt.u32Add(sum, _126); + sum = rs.u32Add(sum, _126); } iter[Symbol.dispose](); - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(sum, f)]; - Log.note(log, rt.fmtFormat(["counted ", args12[0]])); - rt.dropAll(rest); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(sum, f)]; + Log.note(log, rs.fmtFormat(["counted ", args12[0]])); + rs.dropAll(rest); head[Symbol.dispose](); } /** The id of the first guard, which it drops; the second drops as the call returns. */ -export function first(_1: [Guard.Guard, Guard.Guard]): rt.u32 { - const _0: rt.u32 = Guard.finish(_1[0], "first"); +export function first(_1: [Guard.Guard, Guard.Guard]): rs.u32 { + const _0: rs.u32 = Guard.finish(_1[0], "first"); _1[1][Symbol.dispose](); return _0; } -export function read(t: Tally.Tally): rt.u32 { +export function read(t: Tally.Tally): rs.u32 { return t.n; } /** `i`, noted as picked. */ -export function pick(log: Log.Log, i: rt.usize): rt.usize { - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.usizeDisplay(i, f)]; - Log.note(log, rt.fmtFormat(["pick ", args2[0]])); +export function pick(log: Log.Log, i: rs.usize): rs.usize { + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.usizeDisplay(i, f)]; + Log.note(log, rs.fmtFormat(["pick ", args2[0]])); return i; } @@ -1229,77 +1229,77 @@ export function pick(log: Log.Log, i: rt.usize): rt.usize { * guards that may be absent, which drops them in order, and a `Result` and a * `ControlFlow` that may hold a guard, which rustc's glue drops. */ -export function turns(log: Log.Log, count: rt.u32): void { +export function turns(log: Log.Log, count: rs.u32): void { let stacked!: Guard.Guard[] | undefined; - let failed!: rt.Result; - let flow!: rt.Result; + let failed!: rs.Result; + let flow!: rs.Result; let turn!: Guard.Guard; - const pair: Guard.Guard[] = [Guard.new(rt.u32Add(count, 10), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 20), Log.clone$Clone(log))]; + const pair: Guard.Guard[] = [Guard.new(rs.u32Add(count, 10), Log.clone$Clone(log)), Guard.new(rs.u32Add(count, 20), Log.clone$Clone(log))]; const kept: Guard.Guard = pair[0]; Guard.note(kept, "kept"); - const pinned: Guard.Guard = Guard.new(rt.u32Add(count, 40), Log.clone$Clone(log)); + const pinned: Guard.Guard = Guard.new(rs.u32Add(count, 40), Log.clone$Clone(log)); Guard.note(pinned, "pinned"); - const held: Guard.Guard = Guard.new(rt.u32Add(count, 50), Log.clone$Clone(log)); + const held: Guard.Guard = Guard.new(rs.u32Add(count, 50), Log.clone$Clone(log)); Guard.note(held, "borrowed"); - const _34: Guard.Guard = Guard.new(rt.u32Add(count, 60), Log.clone$Clone(log)); + const _34: Guard.Guard = Guard.new(rs.u32Add(count, 60), Log.clone$Clone(log)); Guard.note(_34, "extended"); - const _42: Guard.Guard = Guard.new(rt.u32Add(count, 90), Log.clone$Clone(log)); - const scoped: rt.u32 = _42.id; + const _42: Guard.Guard = Guard.new(rs.u32Add(count, 90), Log.clone$Clone(log)); + const scoped: rs.u32 = _42.id; _42[Symbol.dispose](); - const args2: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(scoped, f)]; - Log.note(log, rt.fmtFormat(["after ", args2[0]])); - const boxed: Guard.Guard = Guard.new(rt.u32Add(count, 100), Log.clone$Clone(log)); - const once: rt.u32 = boxed.id; - const _70: rt.Fmt = (f: rt.Formatter) => rt.u32Display(once, f); + const args2: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(scoped, f)]; + Log.note(log, rs.fmtFormat(["after ", args2[0]])); + const boxed: Guard.Guard = Guard.new(rs.u32Add(count, 100), Log.clone$Clone(log)); + const once: rs.u32 = boxed.id; + const _70: rs.Fmt = (f: rs.Formatter) => rs.u32Display(once, f); const arg = boxed.id; - const args4: rt.Fmt[] = [_70, (f: rt.Formatter) => rt.u32Display(arg, f)]; - Log.note(log, rt.fmtFormat(["boxed ", args4[0], " ", args4[1]])); - const part = Guard.finish(Guard.new(rt.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); - const args6: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part, f)]; - Log.note(log, rt.fmtFormat(["finished ", args6[0]])); - const part2 = Guard.unbox(Guard.new(rt.u32Add(count, 120), Log.clone$Clone(log)), "unboxing"); - const args8: rt.Fmt[] = [(f: rt.Formatter) => rt.u32Display(part2, f)]; - Log.note(log, rt.fmtFormat(["unboxed ", args8[0]])); - if (rt.u32Rem(count, 2) === 0) { - stacked = [Guard.new(rt.u32Add(count, 130), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 140), Log.clone$Clone(log))]; + const args4: rs.Fmt[] = [_70, (f: rs.Formatter) => rs.u32Display(arg, f)]; + Log.note(log, rs.fmtFormat(["boxed ", args4[0], " ", args4[1]])); + const part = Guard.finish(Guard.new(rs.u32Add(count, 110), Log.clone$Clone(log)), "finishing"); + const args6: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part, f)]; + Log.note(log, rs.fmtFormat(["finished ", args6[0]])); + const part2 = Guard.unbox(Guard.new(rs.u32Add(count, 120), Log.clone$Clone(log)), "unboxing"); + const args8: rs.Fmt[] = [(f: rs.Formatter) => rs.u32Display(part2, f)]; + Log.note(log, rs.fmtFormat(["unboxed ", args8[0]])); + if (rs.u32Rem(count, 2) === 0) { + stacked = [Guard.new(rs.u32Add(count, 130), Log.clone$Clone(log)), Guard.new(rs.u32Add(count, 140), Log.clone$Clone(log))]; } else { stacked = undefined; } const part3 = stacked !== undefined; - const args10: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part3, f)]; - Log.note(log, rt.fmtFormat(["stacked ", args10[0]])); - if (rt.u32Rem(count, 2) === 0) { - failed = rt.Err(Guard.new(rt.u32Add(count, 150), Log.clone$Clone(log))); + const args10: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part3, f)]; + Log.note(log, rs.fmtFormat(["stacked ", args10[0]])); + if (rs.u32Rem(count, 2) === 0) { + failed = rs.Err(Guard.new(rs.u32Add(count, 150), Log.clone$Clone(log))); } else { - failed = rt.Ok(count); + failed = rs.Ok(count); } const part4 = !failed.ok; - const args12: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part4, f)]; - Log.note(log, rt.fmtFormat(["failed ", args12[0]])); - if (rt.u32Rem(count, 3) === 0) { - flow = rt.Err(Guard.new(rt.u32Add(count, 160), Log.clone$Clone(log))); + const args12: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part4, f)]; + Log.note(log, rs.fmtFormat(["failed ", args12[0]])); + if (rs.u32Rem(count, 3) === 0) { + flow = rs.Err(Guard.new(rs.u32Add(count, 160), Log.clone$Clone(log))); } else { - flow = rt.Ok(count); + flow = rs.Ok(count); } const part5 = !flow.ok; - const args14: rt.Fmt[] = [(f: rt.Formatter) => rt.fmtBool(part5, f)]; - Log.note(log, rt.fmtFormat(["flow ", args14[0]])); - const spares: Guard.Guard[] = [Guard.new(rt.u32Add(count, 70), Log.clone$Clone(log)), Guard.new(rt.u32Add(count, 80), Log.clone$Clone(log))]; - const _179: rt.usize = pick(log, rt.usizeRem(count as rt.usize, 2)); + const args14: rs.Fmt[] = [(f: rs.Formatter) => rs.fmtBool(part5, f)]; + Log.note(log, rs.fmtFormat(["flow ", args14[0]])); + const spares: Guard.Guard[] = [Guard.new(rs.u32Add(count, 70), Log.clone$Clone(log)), Guard.new(rs.u32Add(count, 80), Log.clone$Clone(log))]; + const _179: rs.usize = pick(log, rs.usizeRem(count as rs.usize, 2)); if (!(_179 < 2)) { - rt.panic("index out of bounds: the len is " + 2 + " but the index is " + _179); + rs.panic("index out of bounds: the len is " + 2 + " but the index is " + _179); } if (count === 0) { - Log.note(log, rt.fmtFormat(["no turns"])); + Log.note(log, rs.fmtFormat(["no turns"])); } else if (!(count < 4)) { - Log.note(log, rt.fmtFormat(["many turns"])); + Log.note(log, rs.fmtFormat(["many turns"])); } else { - let left: rt.u32 = count; + let left: rs.u32 = count; while (true) { turn = Guard.new(left, Log.clone$Clone(log)); if (!(left === 1)) { Guard.note(turn, "turn"); - left = rt.u32Sub(left, 1); + left = rs.u32Sub(left, 1); turn[Symbol.dispose](); } else { break; @@ -1307,34 +1307,34 @@ export function turns(log: Log.Log, count: rt.u32): void { } turn[Symbol.dispose](); } - rt.dropAll(spares); + rs.dropAll(spares); lib_drop$ops_ControlFlow_model_Guard_u32(flow); lib_drop$Result_u32_model_Guard(failed); - rt.dropAll(stacked); + rs.dropAll(stacked); boxed[Symbol.dispose](); _34[Symbol.dispose](); held[Symbol.dispose](); pinned[Symbol.dispose](); kept[Symbol.dispose](); - rt.dropAll(pair.slice(1, 2)); + rs.dropAll(pair.slice(1, 2)); } /** * Every value until the channel closes, summed, each read `depth` async functions * deep: 1, 4, or 16. */ -export function drain(rx: Consumer.Consumer, depth: rt.u32): rt.Future { +export function drain(rx: Consumer.Consumer, depth: rs.u32): rs.Future { return new drainFuture(rx, depth); } export class drainFuture { #state: number = 0; #rx: Consumer.Consumer; - #depth: rt.u32; - #total!: rt.u64; - #awaitee!: rt.Future; + #depth: rs.u32; + #total!: rs.u64; + #awaitee!: rs.Future; - constructor(rx: Consumer.Consumer, depth: rt.u32) { + constructor(rx: Consumer.Consumer, depth: rs.u32) { this.#rx = rx; this.#depth = depth; } @@ -1345,19 +1345,19 @@ export class drainFuture { return; } if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else if (this.#state === 4) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else if (this.#state === 5) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } else { return; } this.#rx[Symbol.dispose](); } - poll(_2: rt.Context): rt.Poll { - let next!: rt.u64 | undefined; + poll(_2: rs.Context): rs.Poll { + let next!: rs.u64 | undefined; let bb0: number = 0; while (true) { switch (bb0) { @@ -1368,7 +1368,7 @@ export class drainFuture { continue; } if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } else { if (this.#state === 3) { bb0 = 7; @@ -1396,43 +1396,43 @@ export class drainFuture { bb0 = 24; continue; case 24: - const _29: rt.Poll = this.#awaitee.poll(_2); - if (_29 !== rt.Pending) { + const _29: rs.Poll = this.#awaitee.poll(_2); + if (_29 !== rs.Pending) { next = _29; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); bb0 = 30; continue; } this.#state = 5; - return rt.Pending; + return rs.Pending; case 16: - const _18: rt.Poll = this.#awaitee.poll(_2); - if (_18 !== rt.Pending) { + const _18: rs.Poll = this.#awaitee.poll(_2); + if (_18 !== rs.Pending) { next = _18; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); bb0 = 30; continue; } this.#state = 4; - return rt.Pending; + return rs.Pending; case 7: - const _7: rt.Poll = this.#awaitee.poll(_2); - if (_7 !== rt.Pending) { + const _7: rs.Poll = this.#awaitee.poll(_2); + if (_7 !== rs.Pending) { next = _7; - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); bb0 = 30; continue; } this.#state = 3; - return rt.Pending; + return rs.Pending; case 30: if (next === undefined) { - const _40: rt.u64 = this.#total; + const _40: rs.u64 = this.#total; this.#rx[Symbol.dispose](); this.#state = 1; return _40; } - this.#total = rt.u64Add(this.#total, next); + this.#total = rs.u64Add(this.#total, next); bb0 = 1; continue; } @@ -1443,7 +1443,7 @@ export class drainFuture { export class level1Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1451,31 +1451,31 @@ export class level1Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new recvFuture$kio_Consumer(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level10Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1483,31 +1483,31 @@ export class level10Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level9Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level11Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1515,31 +1515,31 @@ export class level11Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level10Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level12Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1547,31 +1547,31 @@ export class level12Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level11Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level13Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1579,31 +1579,31 @@ export class level13Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level12Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level14Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1611,31 +1611,31 @@ export class level14Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level13Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level15Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1643,31 +1643,31 @@ export class level15Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level14Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level2Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1675,31 +1675,31 @@ export class level2Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level1Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level3Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1707,31 +1707,31 @@ export class level3Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level2Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level4Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1739,31 +1739,31 @@ export class level4Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level3Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level5Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1771,31 +1771,31 @@ export class level5Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level4Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level6Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1803,31 +1803,31 @@ export class level6Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level5Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level7Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1835,31 +1835,31 @@ export class level7Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level6Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level8Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1867,31 +1867,31 @@ export class level8Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level7Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } export class level9Future { #state: number = 0; #rx: Consumer.Consumer; - #awaitee!: rt.Future; + #awaitee!: rs.Future; constructor(rx: Consumer.Consumer) { this.#rx = rx; @@ -1899,24 +1899,24 @@ export class level9Future { [Symbol.dispose](): void { if (this.#state === 3) { - rt.drop(this.#awaitee); + rs.drop(this.#awaitee); } } - poll(_2: rt.Context): rt.Poll { + poll(_2: rs.Context): rs.Poll { if (this.#state === 0) { this.#awaitee = new level8Future(this.#rx); } else if (this.#state === 1) { - rt.asyncFnResumed(); + rs.asyncFnResumed(); } - const _6: rt.Poll = this.#awaitee.poll(_2); - if (_6 !== rt.Pending) { - rt.drop(this.#awaitee); + const _6: rs.Poll = this.#awaitee.poll(_2); + if (_6 !== rs.Pending) { + rs.drop(this.#awaitee); this.#state = 1; return _6; } this.#state = 3; - return rt.Pending; + return rs.Pending; } } diff --git a/ts/fixtures/task/expected/std/thread/local.ts b/ts/fixtures/task/expected/std/thread/local.ts index af5e3fd52..cd16465ed 100644 --- a/ts/fixtures/task/expected/std/thread/local.ts +++ b/ts/fixtures/task/expected/std/thread/local.ts @@ -1,19 +1,19 @@ // Generated by rust2-ts. Do not edit. -import * as rt from "../../rt.ts"; +import * as rs from "../../rs.ts"; -export function set$0mfcep2(self: rt.LocalKey, rt.WakerVTable] | undefined>>, value: [rt.Place, rt.WakerVTable] | undefined): void { - rt.localKeyInitializeWith(self, new rt.Cell(value), (value2: rt.Cell<[rt.Place, rt.WakerVTable] | undefined> | undefined, cell: rt.Cell<[rt.Place, rt.WakerVTable] | undefined>): undefined => { +export function set$0ftsz7h(self: rs.LocalKey, rs.WakerVTable] | undefined>>, value: [rs.Place, rs.WakerVTable] | undefined): void { + rs.localKeyInitializeWith(self, new rs.Cell(value), (value2: rs.Cell<[rs.Place, rs.WakerVTable] | undefined> | undefined, cell: rs.Cell<[rs.Place, rs.WakerVTable] | undefined>): undefined => { if (value2 !== undefined) { - rt.cellSet(cell, value2.v); + rs.cellSet(cell, value2.v); } }); } -export function replace$05l9d6x(self: rt.LocalKey, rt.WakerVTable] | undefined>>, value: [rt.Place, rt.WakerVTable] | undefined): [rt.Place, rt.WakerVTable] | undefined { +export function replace$0onyq3t(self: rs.LocalKey, rs.WakerVTable] | undefined>>, value: [rs.Place, rs.WakerVTable] | undefined): [rs.Place, rs.WakerVTable] | undefined { const captured = value; - return ((cell: rt.Cell<[rt.Place, rt.WakerVTable] | undefined>): [rt.Place, rt.WakerVTable] | undefined => { - return rt.cellReplace(cell, captured); + return ((cell: rs.Cell<[rs.Place, rs.WakerVTable] | undefined>): [rs.Place, rs.WakerVTable] | undefined => { + return rs.cellReplace(cell, captured); })(self.get()); } diff --git a/ts/runtime/rt.ts b/ts/runtime/rs.ts similarity index 99% rename from ts/runtime/rt.ts rename to ts/runtime/rs.ts index 554418ce8..7dc1ac917 100644 --- a/ts/runtime/rt.ts +++ b/ts/runtime/rs.ts @@ -5,39 +5,39 @@ // left only where a call dispatches on its receiver: an iterator's `next`, a writer's // `writeStr` and `writeChar`, a future's `poll`, a waker's, and `[Symbol.dispose]`. -import type { Shared } from "./rt/bytes.ts"; -import type { Ordering } from "./rt/collections.ts"; -import type { ParseFloatError } from "./rt/float.ts"; -import { type char, type ParseCharError, type ParseIntError, type TryFromIntError, type u32, type usize, u8Debug, usizeDebug, usizeDisplay } from "./rt/int.ts"; -import type { Iter, Range, RangeInclusive } from "./rt/iter.ts"; -import type { Location } from "./rt/location.ts"; -import { drop as dispose, dropAll, partPlace, type Pending } from "./rt/task.ts"; - -import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./rt/alloc.ts"; -import { AtIndex } from "./rt/collections.ts"; -import { escapeDebug } from "./rt/char.ts"; -import { strFromUtf8Unchecked } from "./rt/str.ts"; -export * from "./rt/alloc.ts"; -export * from "./rt/ascii.ts"; -export * from "./rt/bytes.ts"; -export * from "./rt/char.ts"; -export * from "./rt/collections.ts"; -export * from "./rt/float.ts"; -export * from "./rt/hash.ts"; -export * from "./rt/hook.ts"; -export * from "./rt/int.ts"; -export * from "./rt/iter.ts"; -export * from "./rt/location.ts"; -export * from "./rt/rand.ts"; -export * from "./rt/sort.ts"; -export * from "./rt/str.ts"; -export * from "./rt/task.ts"; -export * from "./rt/time.ts"; +import type { Shared } from "./rs/bytes.ts"; +import type { Ordering } from "./rs/collections.ts"; +import type { ParseFloatError } from "./rs/float.ts"; +import { type char, type ParseCharError, type ParseIntError, type TryFromIntError, type u32, type usize, u8Debug, usizeDebug, usizeDisplay } from "./rs/int.ts"; +import type { Iter, Range, RangeInclusive } from "./rs/iter.ts"; +import type { Location } from "./rs/location.ts"; +import { drop as dispose, dropAll, partPlace, type Pending } from "./rs/task.ts"; + +import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./rs/alloc.ts"; +import { AtIndex } from "./rs/collections.ts"; +import { escapeDebug } from "./rs/char.ts"; +import { strFromUtf8Unchecked } from "./rs/str.ts"; +export * from "./rs/alloc.ts"; +export * from "./rs/ascii.ts"; +export * from "./rs/bytes.ts"; +export * from "./rs/char.ts"; +export * from "./rs/collections.ts"; +export * from "./rs/float.ts"; +export * from "./rs/hash.ts"; +export * from "./rs/hook.ts"; +export * from "./rs/int.ts"; +export * from "./rs/iter.ts"; +export * from "./rs/location.ts"; +export * from "./rs/rand.ts"; +export * from "./rs/sort.ts"; +export * from "./rs/str.ts"; +export * from "./rs/task.ts"; +export * from "./rs/time.ts"; /** A Rust panic. */ export class Panic extends Error { /** - * What `panic` runs before it throws, once a program sets a hook: `rt/hook.ts`'s, which + * What `panic` runs before it throws, once a program sets a hook: `rs/hook.ts`'s, which * gives the text it formatted, if any. */ declare static hooked?: (message: string | Arguments, at: Location | string | undefined, owned?: boolean) => string | undefined; @@ -1280,7 +1280,7 @@ export function cloneFromFn(f: (old: T, src: T) => void): CloneFrom { }; } -/** A crate's own `clone_from` of a value a `&mut` lends as an `rt.Place`, `f`. */ +/** A crate's own `clone_from` of a value a `&mut` lends as an `rs.Place`, `f`. */ export function cloneFromPlaceFn(f: (old: Place, src: T) => void): CloneFrom { return (old, src) => { f(place(() => old, (value) => (old = value)), src); @@ -1733,7 +1733,7 @@ export class ByteSlice { /** * A `bytes::Bytes` that is one of the handles counted of `shared`, its storage. A `Bytes` * that is a plain `ByteSlice` is static: it holds no storage, as `Bytes::new` makes. It is - * here, not in `rt/bytes.ts`, as that module runs before this one defines `ByteSlice`. + * here, not in `rs/bytes.ts`, as that module runs before this one defines `ByteSlice`. */ export class CountedBytes extends ByteSlice { readonly shared: Shared; @@ -2182,7 +2182,7 @@ export function byteVecDedupByKeyMut(v: ByteVec, key: (byte: Place) = // `peak`, the most it held since, where a step shortened it, so a push reads and writes // neither. Reading one doubles `cap` while short of the length or the peak, from the // least `RawVec` allocates, as std's pushes grow it. A `VecDeque`'s is its buffer's -// length, and so is an `rt.ByteVec`'s. +// length, and so is an `rs.ByteVec`'s. /** wasm32's `isize::MAX`, the most bytes std's `Layout` describes. */ const ISIZE_MAX = 0x7fffffff; @@ -2439,8 +2439,8 @@ export function byteVecShrinkTo(v: ByteVec, min: number): void { } // Cows. An owned one is what it owns and a borrowed one what it borrows, told apart by -// class: a `Cow<[u8]>` is an `rt.ByteVec` or an `rt.ByteSlice`, and any other is the -// `rt.Vec` or string it owns or the `rt.Borrowed` wrapping the slice it borrows. +// class: a `Cow<[u8]>` is an `rs.ByteVec` or an `rs.ByteSlice`, and any other is the +// `rs.Vec` or string it owns or the `rs.Borrowed` wrapping the slice it borrows. /** * The slice a `Cow<[T]>` or a `Cow` borrows, which it clones before it changes. A diff --git a/ts/runtime/rt/alloc.ts b/ts/runtime/rs/alloc.ts similarity index 99% rename from ts/runtime/rt/alloc.ts rename to ts/runtime/rs/alloc.ts index ad8a697b2..a628ffcd3 100644 --- a/ts/runtime/rt/alloc.ts +++ b/ts/runtime/rs/alloc.ts @@ -1,11 +1,11 @@ // `std::alloc`, for rust2-ts output: a `Layout`, and memory from `alloc` that a cast of its -// pointer to one to `T` makes a JS array of `T`s, as many as fit. `rt.ts` re-exports all of it. +// pointer to one to `T` makes a JS array of `T`s, as many as fit. `rs.ts` re-exports all of it. // // JS keeps values, not bytes, so the memory is untyped until that cast, and a read or // write of its bytes fails. `realloc` keeps the values in a new array, and `dealloc` lets // the array go; a pointer into it after either reads what Rust leaves undefined. -import { Abort, Err, type Fmt, type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtWriteFmt, Ok, type Place, type Result } from "../rt.ts"; +import { Abort, Err, type Fmt, type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtWriteFmt, Ok, type Place, type Result } from "../rs.ts"; import { AtIndex } from "./collections.ts"; import { type u32, u32Debug, type usize, usizeDebug } from "./int.ts"; diff --git a/ts/runtime/rt/ascii.ts b/ts/runtime/rs/ascii.ts similarity index 98% rename from ts/runtime/rt/ascii.ts rename to ts/runtime/rs/ascii.ts index c6dd84d55..9089f1c2f 100644 --- a/ts/runtime/rt/ascii.ts +++ b/ts/runtime/rs/ascii.ts @@ -1,10 +1,10 @@ // The ASCII methods of `u8`, `char`, `[u8]`, and `str`, for rust2-ts output, and the -// iterators `escape_ascii` makes. `rt.ts` re-exports all of it. +// iterators `escape_ascii` makes. `rs.ts` re-exports all of it. // // A `u8` and a `char` share each function: std's char ones are its byte ones' for an ASCII // char, and past ASCII no test holds and no case map changes it, as for a byte past 0x7f. -import { ByteSlice, ByteVec, byteSliceView, byteVecFrom, type FmtResult, type Formatter, OK } from "../rt.ts"; +import { ByteSlice, ByteVec, byteSliceView, byteVecFrom, type FmtResult, type Formatter, OK } from "../rs.ts"; import type { char, u8 } from "./int.ts"; import { type Done, DONE, Iter, type SizeHint } from "./iter.ts"; diff --git a/ts/runtime/rt/bytes.ts b/ts/runtime/rs/bytes.ts similarity index 99% rename from ts/runtime/rt/bytes.ts rename to ts/runtime/rs/bytes.ts index 5e6168604..491fb59ea 100644 --- a/ts/runtime/rt/bytes.ts +++ b/ts/runtime/rs/bytes.ts @@ -1,10 +1,10 @@ // `bytes`, for rust2-ts output. A `Bytes` is immutable bytes that its clones and slices -// share, as a `&[u8]` shares them, so it is an `rt.ByteSlice`: an `rt.CountedBytes` where +// share, as a `&[u8]` shares them, so it is an `rs.ByteSlice`: an `rs.CountedBytes` where // it holds storage, which counts its handles as `bytes` does, and a plain one where it is // static. A `BytesMut` is a window of a vector of its own, or of storage that the handles // `split_to` makes and the `Bytes` that `freeze` makes share without overlapping. Whether // a handle is the last of its storage decides `bytes`' capacities, so every handle drops. -// `rt.ts` re-exports all of it. +// `rs.ts` re-exports all of it. import { ByteSlice, @@ -26,7 +26,7 @@ import { type Result, Err, Ok, -} from "../rt.ts"; +} from "../rs.ts"; import { type char, type u8, u8LowerHex, type usize } from "./int.ts"; /** `isize::MAX` on wasm32, the most bytes an allocation holds. */ diff --git a/ts/runtime/rt/char.ts b/ts/runtime/rs/char.ts similarity index 98% rename from ts/runtime/rt/char.ts rename to ts/runtime/rs/char.ts index bc476a95c..c3e13828f 100644 --- a/ts/runtime/rt/char.ts +++ b/ts/runtime/rs/char.ts @@ -1,10 +1,10 @@ // `char`'s Unicode classes, case maps, escapes, and encodings, for rust2-ts output, and the -// iterators they make, and `str`'s case maps and escapes. `rt.ts` re-exports all of it. +// iterators they make, and `str`'s case maps and escapes. `rs.ts` re-exports all of it. // -// Each reads std's own Unicode tables, which `rt/unicode.ts` holds, rather than the +// Each reads std's own Unicode tables, which `rs/unicode.ts` holds, rather than the // engine's, whose Unicode version may differ from std's. -import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, fmtWriteFmt, OK, Ok, type Place, panic, type Result, sliceView } from "../rt.ts"; +import { type ByteSlice, type Debug, debugListEntry, debugListFinish, debugStructField, debugStructFinish, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtCharDebug, fmtDebugList, fmtDebugStruct, fmtDebugStructFields, fmtDebugTuple, fmtOption, fmtPad, fmtUnit, fmtWriteFmt, OK, Ok, type Place, panic, type Result, sliceView } from "../rs.ts"; import { type char, type u8, type u16, u16Debug, u16LowerHex, type u32, type usize } from "./int.ts"; import { type Clones, DONE, type Done, Iter, iterFlatMap, iterHeld, type SizeHint } from "./iter.ts"; import { strChars } from "./str.ts"; @@ -12,7 +12,7 @@ import { drop as dispose } from "./task.ts"; import { ALPHABETIC, CASE_IGNORABLE, LOWERCASE, NUMERIC, TITLECASE, TO_LOWERCASE, TO_LOWERCASE_MULTI, TO_UPPERCASE, TO_UPPERCASE_MULTI, UNPRINTABLE, UPPERCASE } from "./unicode.ts"; import type { Location } from "./location.ts"; -/** A class of chars, as runs from one of `rt/unicode.ts`'s tables, decoded once one is looked up. */ +/** A class of chars, as runs from one of `rs/unicode.ts`'s tables, decoded once one is looked up. */ class Runs { readonly #table: readonly number[]; // Where each run starts and ends, in order. @@ -84,7 +84,7 @@ export function charIsControl(c: char): boolean { return c <= 0x1f || (c >= 0x7f && c <= 0x9f); } -/** A case map, from one of `rt/unicode.ts`'s tables of runs and of chars that map to more than one, decoded once one is looked up. */ +/** A case map, from one of `rs/unicode.ts`'s tables of runs and of chars that map to more than one, decoded once one is looked up. */ class CaseMap { readonly #table: readonly number[]; readonly #multi: readonly number[]; diff --git a/ts/runtime/rt/collections.ts b/ts/runtime/rs/collections.ts similarity index 99% rename from ts/runtime/rt/collections.ts rename to ts/runtime/rs/collections.ts index b567f8a1c..462151c41 100644 --- a/ts/runtime/rt/collections.ts +++ b/ts/runtime/rs/collections.ts @@ -1,6 +1,6 @@ // Collections, for rust2-ts output: std's `HashMap`, `HashSet`, `BTreeMap`, `BTreeSet`, // `VecDeque`, `LinkedList`, and `BinaryHeap`, hashbrown's `HashTable`, which std's maps are -// built on, and `Ordering`, which their keys need. `rt.ts` +// built on, and `Ordering`, which their keys need. `rs.ts` // re-exports all of it. Each collection is one type whose functions are free functions // here, so a bundler keeps only those a caller reaches. // @@ -15,7 +15,7 @@ // A function that may drop a key, value, or item std's would, rather than return or keep // it, takes what drops each that does, as `k`, `v`, or `f`, and drops it where std's does. -import { asSlice, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, sliceSort, sliceView, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rt.ts"; +import { asSlice, ByteSlice, ByteVec, byteVecPush, byteVecReserve, capReserve, capReserveExact, capTryReserve, capTryReserveExact, type CloneFrom, type Debug, debugStructField, debugStructFinishNonExhaustive, Err, type Fmt, fmtDebugStruct, fmtDebugStructFields, fmtDebugTupleFields, fmtIter, fmtList, type FmtResult, fmtSet, fmtTuple, type Formatter, type None, OK, Ok, panic, type Place, type RangeBound, rangeCheck, type Result, searchBy, sliceSort, sliceView, Vec, vecAppend, vecCapacity, vecCloneFrom, vecFrom, vecHold, vecKeep, vecMax, vecReserve, vecWithCapacity } from "../rs.ts"; import { allocError, CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; import type { Hashing } from "./hash.ts"; import { type Limbs, lt, type u64, type usize } from "./int.ts"; @@ -92,7 +92,7 @@ export function cmpNothing(_a: undefined, _b: undefined): Ordering { /** * `Ord::cmp` of tuples of type `T`, or `PartialOrd::partial_cmp`, from each field's: the * first that is not `Equal`, as `None` is not. A caller passes `T` and `O`, which `tsc` - * infers from neither a generic field, such as a slice's of `rt.cmp`, nor only total ones. + * infers from neither a generic field, such as a slice's of `rs.cmp`, nor only total ones. */ export function cmpTuple(fields: { readonly [I in keyof T]: (a: T[I], b: T[I]) => O }): (a: T, b: T) => O { return (a, b) => { @@ -5088,7 +5088,7 @@ export function btreeKeysPart(k?: (key: K) => void): Part, K> { /** * `Extend::extend` of `c`, the crate's own collection, by `items`, through `extend`, which - * takes an `rt.Place` of it if `place`, giving it back. + * takes an `rs.Place` of it if `place`, giving it back. */ export function ownExtend(c: C, items: I, extend: (c: C, items: I) => void): C; export function ownExtend(c: C, items: I, extend: (c: Place, items: I) => void, place: true): C; diff --git a/ts/runtime/rt/float.ts b/ts/runtime/rs/float.ts similarity index 99% rename from ts/runtime/rt/float.ts rename to ts/runtime/rs/float.ts index 96e135a09..60e5c3f55 100644 --- a/ts/runtime/rt/float.ts +++ b/ts/runtime/rs/float.ts @@ -4,14 +4,14 @@ // double holds the exact sum, product, or quotient of two singles closely enough that // rounding it again gives the single nearest the exact value. These are their methods // where JS differs from std or has none, each its own function, `f64Round`, so a bundler -// drops every one translated code never calls. `rt.ts` re-exports all of it. +// drops every one translated code never calls. `rs.ts` re-exports all of it. // // JS doesn't specify which NaN an operation makes, so a NaN's payload and sign are the // engine's: `to_bits` reads what it keeps. An `f32` NaN is the double NaN with its sign // and its payload at the top, which a signaling one keeps, where JS's conversion from a // single would quiet it. -import { Err, type FmtPart, type FmtResult, type Formatter, fmtPadFormatted, fmtToString, Ok, panic, type Result } from "../rt.ts"; +import { Err, type FmtPart, type FmtResult, type Formatter, fmtPadFormatted, fmtToString, Ok, panic, type Result } from "../rs.ts"; import type { Ordering } from "./collections.ts"; import { type f32, type f64, type u32, type u64, u64FromHalves } from "./int.ts"; diff --git a/ts/runtime/rt/hash.ts b/ts/runtime/rs/hash.ts similarity index 99% rename from ts/runtime/rt/hash.ts rename to ts/runtime/rs/hash.ts index 938806626..84943d157 100644 --- a/ts/runtime/rt/hash.ts +++ b/ts/runtime/rs/hash.ts @@ -1,11 +1,11 @@ // Hashing, for rust2-ts output: `DefaultHasher`, which is std's SipHash-1-3 byte for byte, // `RandomState`, which keys it, the crate's own `Hasher`, and the `Hash` of std's types, -// which call the `Hasher` methods std's call. `rt.ts` re-exports all of it. +// which call the `Hasher` methods std's call. `rs.ts` re-exports all of it. // // A hash collection hashes a key that is a JS object with a faster hasher of its own, // whose values nothing sees, as std keys a map's hasher at random. -import { asSlice, ByteSlice, type ByteVec, type None, type Vec } from "../rt.ts"; +import { asSlice, ByteSlice, type ByteVec, type None, type Vec } from "../rs.ts"; import { type i8, type i16, diff --git a/ts/runtime/rt/hook.ts b/ts/runtime/rs/hook.ts similarity index 98% rename from ts/runtime/rt/hook.ts rename to ts/runtime/rs/hook.ts index 8483e101c..5473a709b 100644 --- a/ts/runtime/rt/hook.ts +++ b/ts/runtime/rs/hook.ts @@ -1,7 +1,7 @@ // `std::panic`'s hook, for rust2-ts output: only a program that sets one reaches this -// module, so a bundler drops all of it from one that doesn't. `rt.ts` re-exports all of it. +// module, so a bundler drops all of it from one that doesn't. `rs.ts` re-exports all of it. -import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtWriteString, Panic, panic } from "../rt.ts"; +import { Abort, type Arguments, type FmtResult, type Formatter, fmtWriteFmt, fmtWriteString, Panic, panic } from "../rs.ts"; import { fmtLocationDisplay, type Location } from "./location.ts"; import { drop } from "./task.ts"; diff --git a/ts/runtime/rt/int.ts b/ts/runtime/rs/int.ts similarity index 99% rename from ts/runtime/rt/int.ts rename to ts/runtime/rs/int.ts index 5a08cf958..edb263aa5 100644 --- a/ts/runtime/rt/int.ts +++ b/ts/runtime/rs/int.ts @@ -1,12 +1,12 @@ // Integers, for rust2-ts output: each operation of each type is its own function, // `u8Add` or `u64Shr`, so a bundler drops every one translated code never calls. -// `rt.ts` re-exports all of it. +// `rs.ts` re-exports all of it. // // Integers are numbers, but a 64- or 128-bit one past 2^53 is an immutable object of // 32-bit limbs. Arithmetic is checked as a debug build checks it: overflow panics, it // never wraps silently. Every panic's message is the one native Rust panics with. -import { Err, type Formatter, type FmtResult, fmtPadFormatted, fmtPadIntegral, Ok, panic, type Result } from "../rt.ts"; +import { Err, type Formatter, type FmtResult, fmtPadFormatted, fmtPadIntegral, Ok, panic, type Result } from "../rs.ts"; import type { Location } from "./location.ts"; declare const brand: unique symbol; diff --git a/ts/runtime/rt/iter.ts b/ts/runtime/rs/iter.ts similarity index 99% rename from ts/runtime/rt/iter.ts rename to ts/runtime/rs/iter.ts index eb08d30e0..51202c467 100644 --- a/ts/runtime/rt/iter.ts +++ b/ts/runtime/rs/iter.ts @@ -1,5 +1,5 @@ // Iterators, for rust2-ts output: std's `Iterator`, its adaptors, and `Range`, lazy as -// Rust's are. `rt.ts` re-exports all of it. +// Rust's are. `rs.ts` re-exports all of it. // // `next` returns an item or `DONE`, never `undefined`, so an iterator of `Option` keeps // its `None` items apart from its end. Each adaptor calls what it wraps, and the closures @@ -22,7 +22,7 @@ // `owned` functions follow it, dispatching on the kind, so a bundle that never drops an // item carries none of it. -import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, capReserve, type Debug, Err, type Fmt, type FmtResult, type Formatter, fmtBool, fmtDebugStructFields, fmtDebugTupleFields, fmtOption, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, Vec, vecCapacity, vecExtendFromSlice, vecFrom, vecHold, vecMax, vecWithCapacity } from "../rt.ts"; +import { ByteSlice, ByteVec, byteVecExtendFromSlice, byteVecPush, byteVecReserve, byteVecReserveExact, byteVecShrinkTo, byteVecWithCapacity, capReserve, type Debug, Err, type Fmt, type FmtResult, type Formatter, fmtBool, fmtDebugStructFields, fmtDebugTupleFields, fmtOption, type None, Ok, type Place, panic, place, type RangeBound, type Result, slicePart, sliceView, Vec, vecCapacity, vecExtendFromSlice, vecFrom, vecHold, vecMax, vecWithCapacity } from "../rs.ts"; import { AtIndex, BTreeIter, HashIter, type Ordering } from "./collections.ts"; import { type Hasher, hash8 } from "./hash.ts"; import { charStep, intToBig, type Limbs, type Step, usizeDebug, lt as wideLt } from "./int.ts"; @@ -805,7 +805,7 @@ export function iterMap(it: Iter, f: (item: T) => U): Iter { /** * `it` with each item lent by `f` as translated code reads it, as a `&[u8; N]` of a - * `Uint8Array` is lent as an `rt.ByteSlice`. + * `Uint8Array` is lent as an `rs.ByteSlice`. */ export function iterLend(it: Iter, f: (item: T) => U): Iter { return new LendIter(it, f); @@ -1299,7 +1299,7 @@ export function iterRfold(it: Iter, init: A, f: (acc: A, item: T) => A, /** * `Iterator::try_fold`, as `try_fold` steps it, until `f` breaks: by an `Option`'s `None`, - * `none` where that is `rt.None`, if `option`, and else by an `rt.Result`'s `Err`, as a + * `none` where that is `rs.None`, if `option`, and else by an `rs.Result`'s `Err`, as a * `Result` or a `ControlFlow` breaks. It returns what broke, or the accumulator as the type * continues with it. If it `owns` `f`, `f` drops as it returns. */ @@ -1750,7 +1750,7 @@ export function iterCollectResult(it: Iter>, into: (values /** * `collect` of `Option`s: `None` at the first `None`, or every value collected by `into`, * as `iterCollectResult`. An item's `None` is `itemNone`, and the result's `none`, each - * `rt.None` where `undefined` is a value. + * `rs.None` where `undefined` is a value. */ export function iterCollectOption(it: Iter, into: (values: Iter) => C, drop?: Drop): C | undefined; export function iterCollectOption(it: Iter, into: (values: Iter) => C, drop: Drop | undefined, itemNone: None): C | undefined; @@ -1959,7 +1959,7 @@ function flattenFold(it: FlattenIter, back: boolean, acc: A, g: ( } // Iterators. One has `[Symbol.dispose]` if it owns items or wraps an iterator: what holds -// it drops it by `rt.drop`, not knowing its kind. +// it drops it by `rs.drop`, not knowing its kind. class SliceIter extends Iter implements Disposable { readonly s: ArrayLike; @@ -5054,8 +5054,8 @@ function stepsBetween(a: T, b: T, int: Step | undefined): SizeHint { /** * `ops::Range`: `start..end`, which iterates its integers by moving `start`. A 64- or - * 128-bit range takes its type's `Step`, `rt.u64Step`, to step past 2^53, and a range - * of `char`s `rt.charStep`, to step past the surrogates. + * 128-bit range takes its type's `Step`, `rs.u64Step`, to step past 2^53, and a range + * of `char`s `rs.charStep`, to step past the surrogates. */ export class Range extends Iter { start: T; @@ -5145,7 +5145,7 @@ export function rangeContains(r: Range, item: T): boolean { /** * `ops::RangeFrom`: `start..`, which iterates by moving `start` and never ends. It takes - * its type's `Step`, `rt.u8Step` or `rt.charStep`, past whose last value it panics, as + * its type's `Step`, `rs.u8Step` or `rs.charStep`, past whose last value it panics, as * std's does in a debug build. */ export class RangeFrom extends Iter { diff --git a/ts/runtime/rt/location.ts b/ts/runtime/rs/location.ts similarity index 96% rename from ts/runtime/rt/location.ts rename to ts/runtime/rs/location.ts index cb7c38443..8db3fcf7f 100644 --- a/ts/runtime/rt/location.ts +++ b/ts/runtime/rs/location.ts @@ -1,7 +1,7 @@ // `core::panic::Location`, for rust2-ts output: where a `#[track_caller]` function was -// called, which never changes once made, so values share it. `rt.ts` re-exports all of it. +// called, which never changes once made, so values share it. `rs.ts` re-exports all of it. -import { type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtStr, fmtWriteFmt } from "../rt.ts"; +import { type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtStr, fmtWriteFmt } from "../rs.ts"; import { cmp, cmpStr, type Ordering } from "./collections.ts"; import { type Hasher, hash32, hashStr } from "./hash.ts"; import { type u32, u32Debug, u32Display } from "./int.ts"; diff --git a/ts/runtime/rt/rand.ts b/ts/runtime/rs/rand.ts similarity index 96% rename from ts/runtime/rt/rand.ts rename to ts/runtime/rs/rand.ts index b1d33014e..2dc0a2b74 100644 --- a/ts/runtime/rt/rand.ts +++ b/ts/runtime/rs/rand.ts @@ -1,9 +1,9 @@ // `rand`'s thread-local generator, for rust2-ts output: each value comes from the // platform's cryptographic source, `crypto.getRandomValues`, as `rand::rng()` seeds from // the OS's. The values are uniform as `rand`'s are, but not its stream: no seed reproduces -// them on either side. `rt.ts` re-exports all of it. +// them on either side. `rs.ts` re-exports all of it. -import { panic, type RangeInclusive } from "../rt.ts"; +import { panic, type RangeInclusive } from "../rs.ts"; import { intFromBig, intToBig, type Limbs } from "./int.ts"; import type { Location } from "./location.ts"; diff --git a/ts/runtime/rt/sort.ts b/ts/runtime/rs/sort.ts similarity index 99% rename from ts/runtime/rt/sort.ts rename to ts/runtime/rs/sort.ts index f07798079..a4fa2c67a 100644 --- a/ts/runtime/rt/sort.ts +++ b/ts/runtime/rs/sort.ts @@ -1,7 +1,7 @@ // std's slice sorts, for rust2-ts output: the stable driftsort and the unstable ipnsort, // as `core::slice::sort` reads at the pinned toolchain on wasm32, so each calls `less` in // the order and number std's does and leaves the slice as std's would, whatever `less` -// answers. `rt.ts` re-exports all of it. +// answers. `rs.ts` re-exports all of it. // // std picks its small sorts, partitions, and scratch by the element type's size, and by // whether it is `Freeze` and `Copy`, which translation knows and passes. std's @@ -9,7 +9,7 @@ // plain loops here. A panic in `less` leaves the slice as it is, which wasm32, where a // panic aborts, never shows. -import { byValue, panic } from "../rt.ts"; +import { byValue, panic } from "../rs.ts"; import { drop as dispose } from "./task.ts"; type Slice = { [i: number]: T; length: number }; diff --git a/ts/runtime/rt/str.ts b/ts/runtime/rs/str.ts similarity index 99% rename from ts/runtime/rt/str.ts rename to ts/runtime/rs/str.ts index 3947d73c6..af0a3e944 100644 --- a/ts/runtime/rt/str.ts +++ b/ts/runtime/rs/str.ts @@ -1,4 +1,4 @@ -// `str`'s slices, iterators, and searches, for rust2-ts output. `rt.ts` re-exports all of +// `str`'s slices, iterators, and searches, for rust2-ts output. `rs.ts` re-exports all of // it. // // A JS string is UTF-16 where a `str` is UTF-8: these step by code point, and an offset @@ -31,7 +31,7 @@ import { strCowStr, stringLen, utf8Check, -} from "../rt.ts"; +} from "../rs.ts"; import { CAPACITY_OVERFLOW, type TryReserveError } from "./alloc.ts"; import { isAsciiWhitespace } from "./ascii.ts"; import { escapeDebug } from "./char.ts"; diff --git a/ts/runtime/rt/task.ts b/ts/runtime/rs/task.ts similarity index 99% rename from ts/runtime/rt/task.ts rename to ts/runtime/rs/task.ts index 318b054d6..ea4c456d7 100644 --- a/ts/runtime/rt/task.ts +++ b/ts/runtime/rs/task.ts @@ -1,10 +1,10 @@ // Ownership and async, for rust2-ts output: what Rust's `Drop`, `Arc`, `Mutex`, atomics, -// one-time cells, and futures do that plain JS does not. `rt.ts` re-exports all of it. +// one-time cells, and futures do that plain JS does not. `rs.ts` re-exports all of it. // // A value whose drop JS can observe has `[Symbol.dispose]`, which runs its `Drop` impl // and drops its fields. `None` is `undefined`, which drops as nothing. -import { Abort, arrayAssign, type ByteSlice, type CloneFrom, cloneOver, type Debug, type DebugStruct, debugStructField, debugStructFinish, debugStructFinishNonExhaustive, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtBool, fmtDebugStruct, fmtDebugTuple, fmtDebugTupleFields, fmtPad, fmtStr, type None, NULL, objectCopy, OK, Ok, Panic, panic, type Place, place, ptrErase, ptrHome, ptrNowhere, ptrWrite, type Result, stringAsBytes, type Vec } from "../rt.ts"; +import { Abort, arrayAssign, type ByteSlice, type CloneFrom, cloneOver, type Debug, type DebugStruct, debugStructField, debugStructFinish, debugStructFinishNonExhaustive, debugTupleField, debugTupleFinish, Err, type FmtResult, type Formatter, fmtBool, fmtDebugStruct, fmtDebugTuple, fmtDebugTupleFields, fmtPad, fmtStr, type None, NULL, objectCopy, OK, Ok, Panic, panic, type Place, place, ptrErase, ptrHome, ptrNowhere, ptrWrite, type Result, stringAsBytes, type Vec } from "../rs.ts"; import type { Hasher } from "./hash.ts"; import type { Location } from "./location.ts"; @@ -1152,7 +1152,7 @@ export function fence(order: AtomicOrdering, at?: Location): void { /** * `OnceCell`: the `Option` it holds, whose `None`, `N`, is `undefined`, or - * `rt.None` where `T` can already be `undefined`. + * `rs.None` where `T` can already be `undefined`. */ export class OnceCell implements Disposable { v: T | N; @@ -1553,7 +1553,7 @@ const NOOP_VTABLE: WakerVTable = /* @__PURE__ */ wakerVTable( ); /** `Waker::noop()`: one waker for every call, whose data is null, as std's is. */ -// `rt.NULL`, which `rt.ts` makes after this module runs. +// `rs.NULL`, which `rs.ts` makes after this module runs. export const NOOP_WAKER: Waker = /* @__PURE__ */ new VTableWaker(null as never, NOOP_VTABLE); /** `Context`, which carries only its waker. */ @@ -1618,7 +1618,7 @@ export class DynFuture implements Future { } } -/** `future.poll(cx)`: the `poll` of an `rt.DynFuture` over a future it borrows. */ +/** `future.poll(cx)`: the `poll` of an `rs.DynFuture` over a future it borrows. */ export function futurePoll(future: Future, cx: Context): Poll { return future.poll(cx); } diff --git a/ts/runtime/rt/time.ts b/ts/runtime/rs/time.ts similarity index 99% rename from ts/runtime/rt/time.ts rename to ts/runtime/rs/time.ts index 152fbd9e4..88aed60a7 100644 --- a/ts/runtime/rt/time.ts +++ b/ts/runtime/rs/time.ts @@ -1,11 +1,11 @@ // `core::time::Duration`, for rust2-ts output: std's whole seconds and nanoseconds, with // each method its own function, `durationAdd`, so a bundler drops every one translated -// code never calls. `rt.ts` re-exports all of it. +// code never calls. `rs.ts` re-exports all of it. // // A `Duration` never changes once made, so values share it. Its arithmetic is std's: a // sum past `u64::MAX` seconds is `None`, saturates, or panics with std's message. -import { Err, type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtPadding, Ok, panic, type Result } from "../rt.ts"; +import { Err, type FmtResult, type Formatter, fmtDebugStructFields, fmtPad, fmtPadding, Ok, panic, type Result } from "../rs.ts"; import { cmp, type Ordering } from "./collections.ts"; import { type Hasher, hash32, hash64 } from "./hash.ts"; import { f64ToBits } from "./float.ts"; diff --git a/ts/runtime/rt/unicode.ts b/ts/runtime/rs/unicode.ts similarity index 100% rename from ts/runtime/rt/unicode.ts rename to ts/runtime/rs/unicode.ts diff --git a/ts/runtime/tsconfig.json b/ts/runtime/tsconfig.json index a7ad59f8d..dfc30f28a 100644 --- a/ts/runtime/tsconfig.json +++ b/ts/runtime/tsconfig.json @@ -12,5 +12,5 @@ "verbatimModuleSyntax": true, "erasableSyntaxOnly": true }, - "files": ["rt.ts", "rt/bytes.ts", "rt/collections.ts", "rt/int.ts", "rt/iter.ts", "rt/rand.ts", "rt/sort.ts", "rt/str.ts", "rt/task.ts", "rt/time.ts"] + "files": ["rs.ts", "rs/bytes.ts", "rs/collections.ts", "rs/int.ts", "rs/iter.ts", "rs/rand.ts", "rs/sort.ts", "rs/str.ts", "rs/task.ts", "rs/time.ts"] } diff --git a/ts/src/census.rs b/ts/src/census.rs index ae5a03785..b71959f97 100644 --- a/ts/src/census.rs +++ b/ts/src/census.rs @@ -199,9 +199,9 @@ const VERBATIM: &[&str] = &[ "next", "offset_from", "ref mut", - "rt.None", - "rt.OuterPending", - "rt.Pending", + "rs.None", + "rs.OuterPending", + "rs.Pending", "self", "skip", "undefined", diff --git a/ts/src/lower/alloc.rs b/ts/src/lower/alloc.rs index e1076f366..57ed97292 100644 --- a/ts/src/lower/alloc.rs +++ b/ts/src/lower/alloc.rs @@ -1,4 +1,4 @@ -//! `std::alloc`, as `rt/alloc.ts` gives it: a `Layout` is its size and alignment, never +//! `std::alloc`, as `rs/alloc.ts` gives it: a `Layout` is its size and alignment, never //! changed once made, and memory from `alloc` is untyped until a cast of its pointer to one //! to `T`, which [`crate::lower::mir`] allows only where the body shows the pointer came //! from `alloc` or `realloc`, makes it a JS array of `T`s. A pointer to it as bytes is @@ -28,22 +28,22 @@ pub fn call<'tcx>( Err(e) => e, }, ("Layout", "array") => match layout(b) { - Ok((size, align)) => Expr::rt( + Ok((size, align)) => Expr::rs( "layoutArray", vec![arg(), Expr::lit(size.to_string()), Expr::lit(align.to_string())], ), Err(e) => e, }, - ("Layout", "from_size_align") => Expr::rt("layoutFromSizeAlign", vec![arg(), arg()]), + ("Layout", "from_size_align") => Expr::rs("layoutFromSizeAlign", vec![arg(), arg()]), ("Layout", "from_size_align_unchecked") => object(arg(), arg()), ("Layout", "size" | "align") => arg().member(name), - ("alloc", "alloc") => Expr::rt("alloc", vec![arg()]), - ("alloc", "dealloc") => Expr::rt("dealloc", vec![arg()]), + ("alloc", "alloc") => Expr::rs("alloc", vec![arg()]), + ("alloc", "dealloc") => Expr::rs("dealloc", vec![arg()]), ("alloc", "realloc") => { let (p, _, size) = (arg(), arg(), arg()); - Expr::rt("realloc", vec![p, size]) + Expr::rs("realloc", vec![p, size]) } - ("alloc", "handle_alloc_error") => Expr::rt("handleAllocError", vec![arg()]), + ("alloc", "handle_alloc_error") => Expr::rs("handleAllocError", vec![arg()]), _ => return Err(args.collect()), }; Ok(Some(e)) diff --git a/ts/src/lower/bind.rs b/ts/src/lower/bind.rs index 74fc6e02d..5540e5ecc 100644 --- a/ts/src/lower/bind.rs +++ b/ts/src/lower/bind.rs @@ -258,7 +258,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if !ty.has_param() && self.bindings.values.insert(ty) { let value = Type::Sym(sym, args.types().map(|t| self.ty(t, span)).collect()); let flag = |b: bool| Type::Builtin(if b { "true" } else { "false" }); - let ret = Type::Rt("Bound", vec![value.clone(), flag(self.is_copy(ty)), flag(drop)]); + let ret = Type::Rs("Bound", vec![value.clone(), flag(self.is_copy(ty)), flag(drop)]); let value = Param { name: "value".into(), ty: Some(value), @@ -444,7 +444,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// The module `tsc` checks the bindings in, which no Rust module or binding can be: the /// runtime's directory holds only the runtime. pub fn check_module() -> ModPath { - vec!["rt".into(), "bind".into()] + vec!["rs".into(), "bind".into()] } /// The export standing in for the function `def_id`: its name, then the trait it @@ -525,8 +525,8 @@ fn module_of(file: &Path) -> Result { } } } - if module.first().is_some_and(|first| first.eq_ignore_ascii_case("rt")) { - return Err(format!("{} would replace the runtime, rt.ts and rt/", file.display())); + if module.first().is_some_and(|first| first.eq_ignore_ascii_case("rs")) { + return Err(format!("{} would replace the runtime, rs.ts and rs/", file.display())); } Ok(module) } diff --git a/ts/src/lower/body.rs b/ts/src/lower/body.rs index 75460d464..49e5fc2b0 100644 --- a/ts/src/lower/body.rs +++ b/ts/src/lower/body.rs @@ -148,7 +148,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { return Expr::New(Box::new(Expr::Sym(class)), values); } let call = self.direct_call(instance, values, span, out); - // The crate's own `next` returns an item or `rt.DONE`, and its caller an `Option`. + // The crate's own `next` returns an item or `rs.DONE`, and its caller an `Option`. if super::iter::is_next(tcx, did) { let option = self.t.sig(did, instance.args).output(); self.t.ty(option, span); @@ -156,7 +156,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { unreachable!("`next` returns an `Option`") }; let none = self.t.none_arg(option_args.type_at(0)); - return Expr::rt("iterToOption", [call].into_iter().chain(none).collect()); + return Expr::rs("iterToOption", [call].into_iter().chain(none).collect()); } // One that hands back its `Ok`'s parts, made whole here, before anything else can // write its slot. @@ -196,7 +196,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { ) -> Expr { let tcx = self.t.tcx; if let Some(referent) = library::referent(tcx, def_id, gargs, instance) { - // An operand that was a reference to an `rt.Place`, as `&&mut u32` is, passes + // An operand that was a reference to an `rs.Place`, as `&&mut u32` is, passes // what the Place points at. let inputs = |gargs| self.t.sig(def_id, gargs).inputs().to_vec(); let args = std::iter::zip(args, std::iter::zip(inputs(gargs), inputs(referent))) @@ -386,7 +386,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { // Typed, as what reads it may infer nothing of it. if library::empty_iter(tcx, adt.did()) { let ts_ty = self.t.ty(ty, span); - return Ok(Expr::As(Box::new(Expr::rt("iterEmpty", Vec::new())), ts_ty)); + return Ok(Expr::As(Box::new(Expr::rs("iterEmpty", Vec::new())), ts_ty)); } let Some((make, gargs)) = super::iter::maker(self.t, ty) else { return Err(values); @@ -435,7 +435,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { let sym = match self.t.bound_fn(instance, span) { Some(sym) => Some(sym), // One that takes byte slices as their parts, hands back its `Ok`'s parts, or is a - // `next`, which returns an item or `rt.DONE`, is wrapped to take and return what + // `next`, which returns an item or `rs.DONE`, is wrapped to take and return what // a call does. None => (self.t.lowers(self.t.typing_env_pub(), instance) && self.t.parted(instance).is_empty() diff --git a/ts/src/lower/caller.rs b/ts/src/lower/caller.rs index 00a3826f6..6a8e0ebe2 100644 --- a/ts/src/lower/caller.rs +++ b/ts/src/lower/caller.rs @@ -10,7 +10,7 @@ //! reads: each statement's own, the caller's location to each std function that takes it, //! and the call of the macro that defines one, as an integer's methods. A panic in std's //! own code is where the toolchain's source has it, and one in `bytes`' where the -//! program's `bytes` has it, named as the session names that file, which `rt.setHook` is +//! program's `bytes` has it, named as the session names that file, which `rs.setHook` is //! given. use std::sync::OnceLock; @@ -24,7 +24,7 @@ use super::body::Body; use super::library::{self, Std}; use crate::ts::{Expr, Key, Param, Stmt, StmtKind, Type}; -/// The `rt.Location` rustc gives a call at `span`: where the outermost macro call it came +/// The `rs.Location` rustc gives a call at `span`: where the outermost macro call it came /// from is, in the file as the native build names it, by line and column from 1. pub fn location(tcx: TyCtxt<'_>, span: Span) -> Expr { let topmost = span.ctxt().outer_expn().expansion_cause().unwrap_or(span); @@ -498,7 +498,7 @@ const BYTES: &[(&str, &str, &[&str], &str)] = &[ ), ]; -/// The `rt.Sites` of the toolchain's std, which `rt.setHook` takes: where each panic +/// The `rs.Sites` of the toolchain's std, which `rs.setHook` takes: where each panic /// [`SITES`] names is, as the native build names it, and each [`BYTES`] names, in the /// program's `bytes`, if it has one. pub fn sites(t: &mut Translator<'_, '_>, span: Span) -> Expr { @@ -557,7 +557,7 @@ fn bytes_sites(t: &mut Translator<'_, '_>, span: Span) -> Vec<(Key, Expr)> { tables.pop().unwrap_or_default() } -/// The `rt.Location` of the first `needle` after each of `after` in turn in `file`, under +/// The `rs.Location` of the first `needle` after each of `after` in turn in `file`, under /// `krate`'s `src/`, named as the session names it. fn bytes_find( tcx: TyCtxt<'_>, @@ -632,7 +632,7 @@ fn found(tcx: TyCtxt<'_>, file: &str, after: &[&str], needle: &str) -> Expr { } } -/// The `rt.Location` of the first `needle` after each of `after` in turn in `file`, a file +/// The `rs.Location` of the first `needle` after each of `after` in turn in `file`, a file /// under std's `library/` whose `*` stands for a vendored crate's version, in the /// toolchain's source. fn find(tcx: TyCtxt<'_>, file: &str, after: &[&str], needle: &str) -> Option { @@ -679,7 +679,7 @@ fn position(text: &str, after: &[&str], needle: &str) -> Option<(usize, usize)> Some((line, col)) } -/// The `rt.Location` of `file`, `line`, and `col`. +/// The `rs.Location` of `file`, `line`, and `col`. pub fn object(file: String, line: impl ToString, col: impl ToString) -> Expr { Expr::Object(vec![ (Key::Name("file".into()), Expr::Str(file)), @@ -767,7 +767,7 @@ pub fn refuse_std_call<'tcx>(t: &mut Translator<'_, 'tcx>, instance: Instance<'t /// The type of the parameter a `#[track_caller]` function takes its caller's location by. pub fn param_ty() -> Type { - Type::Rt("Location", Vec::new()) + Type::Rs("Location", Vec::new()) } /// Each runtime function that takes where a panic it makes is, as an `at?: Location` @@ -782,7 +782,7 @@ fn located() -> &'static rustc_data_structures::fx::FxHashMap<&'static str, usiz } /// The functions `text` exports that take an `at?: Location` parameter, or one that also -/// takes a key of `rt.Sites`, and its index. +/// takes a key of `rs.Sites`, and its index. fn signatures(text: &'static str) -> impl Iterator { ["export function ", "export const "] .into_iter() @@ -884,8 +884,8 @@ fn unlocated(e: &mut Expr) -> Option<(&mut Vec, usize)> { return None; }; let name = match &**callee { - Expr::Rt(name) => name, - Expr::Instantiate(f, _) if let Expr::Rt(name) = &**f => name, + Expr::Rs(name) => name, + Expr::Instantiate(f, _) if let Expr::Rs(name) = &**f => name, _ => return None, }; let index = *located().get(name.as_str())?; @@ -926,7 +926,7 @@ fn stmt_exprs(stmt: &mut Stmt, f: &mut dyn FnMut(&mut Expr)) { /// Call `f` on `e` and every expression within it, arrow bodies included, innermost first. fn walk(e: &mut Expr, f: &mut dyn FnMut(&mut Expr)) { match e { - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter_mut().for_each(|e| walk(e, f)), Expr::Object(props) => props.iter_mut().for_each(|(_, e)| walk(e, f)), Expr::Member(e, _) diff --git a/ts/src/lower/collections.rs b/ts/src/lower/collections.rs index b2b5b068d..02d2541a7 100644 --- a/ts/src/lower/collections.rs +++ b/ts/src/lower/collections.rs @@ -1,10 +1,10 @@ -//! Collections, as `rt/collections.ts` gives them: `HashMap`, `HashSet`, `BTreeMap`, +//! Collections, as `rs/collections.ts` gives them: `HashMap`, `HashSet`, `BTreeMap`, //! `BTreeSet`, `VecDeque`, `LinkedList`, and `BinaryHeap`, std's or hashbrown's, and //! hashbrown's `HashTable`, with `Ordering` and `DefaultHasher`, which their keys need. //! //! A hash collection holds a key that is a JS primitive as its own JS map key, which JS //! compares as Rust's `Eq` does for numbers, strings, and booleans, and finds any other -//! key through its translated or bound `Hash` and `Eq`, which `rt.hashing` makes it carry. +//! key through its translated or bound `Hash` and `Eq`, which `rs.hashing` makes it carry. //! A B-tree orders every key by its translated or bound `Ord`. Each value a collection //! stores is its own copy, as in Rust. @@ -91,7 +91,7 @@ pub fn call<'tcx>( "min" => "ordMin", _ => "ordClamp", }; - return Ok(Some(Expr::rt(f, values))); + return Ok(Some(Expr::rs(f, values))); } // A std type's own comparisons, as a tuple's are, by its `partial_cmp`. The library // maps the integers' and `bool`'s. @@ -125,7 +125,7 @@ pub fn call<'tcx>( let t = peel(b, t); // Bytes of any form against any other, as the runtime reads each. if bytes(b, t) && bytes(b, peel(b, rhs)) { - let eq = Expr::rt("eqBytes", args); + let eq = Expr::rs("eqBytes", args); return Ok(Some(if name == "eq" { eq } else { eq.not() })); } // Sequences of other forms or items, whose `ne` is `!eq`. @@ -147,7 +147,7 @@ pub fn call<'tcx>( _ => not_ne_fn(b, t, span), }; let eq = match (eq, <[Expr; 2]>::try_from(args)) { - (Expr::Rt(same), Ok([l, r])) if same == "same" => l.binary("===", r), + (Expr::Rs(same), Ok([l, r])) if same == "same" => l.binary("===", r), (eq, Ok(args)) => eq.call(args.into()), (_, Err(args)) => return Err(args), }; @@ -189,7 +189,7 @@ pub fn call<'tcx>( }; let by = lookup_ty(b, std, call, owner, name); // A `[u8; N]` key is a typed array, but a reference to an array or a slice, as a lookup - // takes one, is an `rt.ByteSlice`, so a view of its bytes stands in. A range holds the + // takes one, is an `rs.ByteSlice`, so a view of its bytes stands in. A range holds the // keys themselves. if let Some(by) = by && !matches!(name, "range" | "range_mut") @@ -202,7 +202,7 @@ pub fn call<'tcx>( key = arg(key, 0); } if let (true, Some(at)) = (super::byte_array(key), args.get_mut(1)) { - *at = Expr::rt("byteSliceView", vec![std::mem::replace(at, Expr::undefined())]); + *at = Expr::rs("byteSliceView", vec![std::mem::replace(at, Expr::undefined())]); } } // Elements of any form, an array, a slice, or a `Vec`, hash and compare alike, so each @@ -224,7 +224,7 @@ pub fn call<'tcx>( _ if cow => {} Some(key) if arc && !matches!(name, "range" | "range_mut") => { let value = std::mem::replace(key, Expr::undefined()); - *key = Expr::New(Box::new(Expr::Rt("Arc".into())), vec![value]); + *key = Expr::New(Box::new(Expr::Rs("Arc".into())), vec![value]); } _ => { return Ok(Some(b.err( @@ -234,7 +234,7 @@ pub fn call<'tcx>( } } } - // A slice or an array finds an `rt.Vec` key, which the runtime reads alike, as its type. + // A slice or an array finds an `rs.Vec` key, which the runtime reads alike, as its type. if let Some(by) = by && !matches!(name, "range" | "range_mut") && let Some(at) = args.get_mut(1) @@ -251,10 +251,10 @@ pub fn call<'tcx>( Std::VecDeque => deque(b, coll, call, owner, name, args), Std::LinkedList => list(b, coll, call, owner, name, args), Std::BinaryHeap => heap(b, coll, call, owner, name, args), - Std::PeekMut if name == "pop" => Some(Expr::rt("peekMutPop", args)), + Std::PeekMut if name == "pop" => Some(Expr::rs("peekMutPop", args)), Std::Entry => entry(b, coll, call, name, args), Std::Ordering => ordering(name, args), - Std::Hasher if matches!(name, "new" | "default") => Some(Expr::rt("hasher", vec![])), + Std::Hasher if matches!(name, "new" | "default") => Some(Expr::rs("hasher", vec![])), Std::RandomState => Some(random_state(b, call, coll, name, args)), Std::BuildHasherDefault => Some(build_hasher_default(b, call, coll, name, args, out)), _ => return Err(args), @@ -329,7 +329,7 @@ fn discarded(std: Std, owner: &str, name: &str) -> Option<&'static [usize]> { } /// `values` and then `flag`, which a runtime function defaults to `false` unless the -/// `rt.None` it takes last follows, where `none`. +/// `rs.None` it takes last follows, where `none`. fn flagged(mut values: Vec, flag: bool, none: bool) -> Vec { if flag || none { values.push(Expr::lit(flag.to_string())); @@ -391,7 +391,7 @@ fn same_key<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { } /// Whether a key of type `by` is a slice or an array that finds a `key` that is a `Vec`, -/// whose JS value is an `rt.Vec` of the array. +/// whose JS value is an `rs.Vec` of the array. fn other_shape<'tcx>(b: &Body<'_, '_, 'tcx>, key: Ty<'tcx>, by: Ty<'tcx>) -> bool { b.t.std_of(peel(b, key)) == Some(Std::Vec) && elements_of(b, peel(b, by)).is_some() @@ -420,7 +420,7 @@ fn alike<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, other: Ty<'tcx>) -> bool { } /// Whether `call` lends a value a collection or an atomic holds that JS copies, which its -/// mapping makes an `rt.Place` of: returned as `get_mut` and an entry's do, yielded as +/// mapping makes an `rs.Place` of: returned as `get_mut` and an entry's do, yielded as /// `iter_mut`'s, or handed to a closure as `retain`'s. An atomic is that place itself. pub fn place_call<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> bool { let tcx = b.t.tcx; @@ -500,7 +500,7 @@ fn arg<'tcx>(coll: Ty<'tcx>, n: usize) -> Ty<'tcx> { } /// What a JS value of `ty` is: through references and boxes, which are their pointee, -/// up to a `&mut` that is an `rt.Place`, and a `NonZero`, which is its integer. +/// up to a `&mut` that is an `rs.Place`, and a `NonZero`, which is its integer. fn peel<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { match pointee(b, ty) { Some(inner) => peel(b, inner), @@ -625,37 +625,37 @@ fn hash<'tcx>( values.resize(3, Expr::undefined()); values.push(state); } - empty(b, Expr::rt("hashWithCapacity", values), coll, span) + empty(b, Expr::rs("hashWithCapacity", values), coll, span) } (_, "hasher") if let Some(state) = held_state(b, coll) => { let ty = b.t.ty(state, span); Expr::As(Box::new(values.pop()?.member("s")), ty) } - (_, "len") => Expr::rt("hashLen", values), - (_, "is_empty") => Expr::rt("hashLen", values).binary("===", Expr::lit("0")), - (_, "clear") => Expr::rt("hashClear", values), - (_, "contains_key" | "contains") => Expr::rt("hashContains", values), - (_, "get_mut") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rt("hashGetMut", values), - (_, "get" | "get_mut") if !set => Expr::rt("hashGet", values), - (_, "get") => Expr::rt("hashKey", flagged(values, false, none)), - (_, "take") => Expr::rt("hashKey", flagged(values, true, none)), - (_, "replace") => Expr::rt("hashReplace", values), - (_, "get_key_value") => Expr::rt("hashGetKeyValue", values), - (_, "insert") if set => Expr::rt("hashAdd", values), - (_, "insert") => Expr::rt("hashInsert", values), - (_, "remove") if set => Expr::rt("hashDelete", values), - (_, "remove") => Expr::rt("hashRemove", values), - (_, "remove_entry") => Expr::rt("hashRemoveEntry", values), - (_, "retain") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rt("hashRetainMut", values), - (_, "retain") => Expr::rt("hashRetain", values), - (_, "extract_if") if set => Expr::rt("hashExtractKeysIf", values), - (_, "extract_if") if b.t.needs_place(arg(coll, 1)) => Expr::rt("hashExtractIfMut", values), - (_, "extract_if") => Expr::rt("hashExtractIf", values), - (_, "iter_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rt("hashIterMut", values), - (_, "values_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rt("hashValuesMut", values), - (_, "iter" | "iter_mut") if !set => Expr::rt("hashIter", values), - (_, "iter" | "keys") => Expr::rt("hashKeys", values), - (_, "values" | "values_mut") => Expr::rt("hashValues", values), + (_, "len") => Expr::rs("hashLen", values), + (_, "is_empty") => Expr::rs("hashLen", values).binary("===", Expr::lit("0")), + (_, "clear") => Expr::rs("hashClear", values), + (_, "contains_key" | "contains") => Expr::rs("hashContains", values), + (_, "get_mut") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rs("hashGetMut", values), + (_, "get" | "get_mut") if !set => Expr::rs("hashGet", values), + (_, "get") => Expr::rs("hashKey", flagged(values, false, none)), + (_, "take") => Expr::rs("hashKey", flagged(values, true, none)), + (_, "replace") => Expr::rs("hashReplace", values), + (_, "get_key_value") => Expr::rs("hashGetKeyValue", values), + (_, "insert") if set => Expr::rs("hashAdd", values), + (_, "insert") => Expr::rs("hashInsert", values), + (_, "remove") if set => Expr::rs("hashDelete", values), + (_, "remove") => Expr::rs("hashRemove", values), + (_, "remove_entry") => Expr::rs("hashRemoveEntry", values), + (_, "retain") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rs("hashRetainMut", values), + (_, "retain") => Expr::rs("hashRetain", values), + (_, "extract_if") if set => Expr::rs("hashExtractKeysIf", values), + (_, "extract_if") if b.t.needs_place(arg(coll, 1)) => Expr::rs("hashExtractIfMut", values), + (_, "extract_if") => Expr::rs("hashExtractIf", values), + (_, "iter_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rs("hashIterMut", values), + (_, "values_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rs("hashValuesMut", values), + (_, "iter" | "iter_mut") if !set => Expr::rs("hashIter", values), + (_, "iter" | "keys") => Expr::rs("hashKeys", values), + (_, "values" | "values_mut") => Expr::rs("hashValues", values), // What drops the half it yields, then the other, which the runtime drops as std's // does: before `next` returns, and after `fold` has the item. (_, "into_keys" | "into_values") => { @@ -668,23 +668,23 @@ fn hash<'tcx>( droppers.push(state); } let f = if name == "into_keys" { "hashKeys" } else { "hashValues" }; - Expr::rt(f, super::iter::tail(values, droppers)) + Expr::rs(f, super::iter::tail(values, droppers)) } (_, "drain") => { let droppers = entry_droppers(b, coll, span); - Expr::rt( + Expr::rs( if set { "hashDrainKeys" } else { "hashDrain" }, super::iter::tail(values, droppers), ) } - (_, "entry") => Expr::rt("entry", values), - (_, name) if let Some(f) = set_op("hash", name) => Expr::rt(f, values), + (_, "entry") => Expr::rs("entry", values), + (_, name) if let Some(f) = set_op("hash", name) => Expr::rs(f, values), ("BitOr" | "BitAnd" | "Sub" | "BitXor", _) => { let keys = set_op_keys(b, coll, "hash", owner, values, span)?; let state = new_state(b, coll, span); let target = hash_new(b, coll, state, span)?; let max = hash_max(b, coll, span); - Expr::rt( + Expr::rs( "hashExtendKeys", vec![target, keys, Expr::undefined(), Expr::undefined(), max], ) @@ -695,9 +695,9 @@ fn hash<'tcx>( // hashbrown's returns its own error, an enum of its variants. (_, "try_reserve") if !super::stock::as_std(b.t.tcx, call.def_id) => { values.push(hash_max(b, coll, span)); - Expr::rt("hashTryReserve", values) + Expr::rs("hashTryReserve", values) } - ("Index", "index") => Expr::rt("hashIndex", values), + ("Index", "index") => Expr::rs("hashIndex", values), ("Clone", "clone") => { let k = clone_fn(b, key, span); let v = match value { @@ -706,7 +706,7 @@ fn hash<'tcx>( }; values.extend([k, v]); let s = held_state(b, coll).map(|s| clone_fn(b, s, span)); - Expr::rt("hashClone", super::iter::tail(values, s.into_iter().collect())) + Expr::rs("hashClone", super::iter::tail(values, s.into_iter().collect())) } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; @@ -728,19 +728,19 @@ fn hash<'tcx>( /// of its capacity, as std guarantees it. fn sized<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, name: &str, mut values: Vec, span: Span) -> Expr { match name { - "capacity" => Expr::rt("hashCapacity", values), + "capacity" => Expr::rs("hashCapacity", values), "reserve" => { values.push(hash_max(b, coll, span)); - Expr::rt("hashReserve", values) + Expr::rs("hashReserve", values) } "shrink_to_fit" => { values.push(Expr::lit("0")); - Expr::rt("hashShrinkTo", values) + Expr::rs("hashShrinkTo", values) } - "shrink_to" => Expr::rt("hashShrinkTo", values), + "shrink_to" => Expr::rs("hashShrinkTo", values), _ => { values.push(super::iter::size_of(b, stored(b, coll), span)); - Expr::rt("hashAllocationSize", values) + Expr::rs("hashAllocationSize", values) } } } @@ -765,14 +765,14 @@ fn table<'tcx>( let e = match (owner, name) { (_, "new") | ("Default", "default") => { discard(values, out); - empty(b, Expr::rt("hashNew", vec![]), coll, span) + empty(b, Expr::rs("hashNew", vec![]), coll, span) } (_, "with_capacity") => { values.push(hash_max(b, coll, span)); - empty(b, Expr::rt("hashWithCapacity", values), coll, span) + empty(b, Expr::rs("hashWithCapacity", values), coll, span) } - (_, "len") => Expr::rt("hashLen", values), - (_, "is_empty") => Expr::rt("hashLen", values).binary("===", Expr::lit("0")), + (_, "len") => Expr::rs("hashLen", values), + (_, "is_empty") => Expr::rs("hashLen", values).binary("===", Expr::lit("0")), (_, "capacity" | "allocation_size") => sized(b, coll, name, values, span), // The hasher last. (_, "reserve" | "shrink_to" | "shrink_to_fit") => { @@ -785,29 +785,29 @@ fn table<'tcx>( e => e, } } - (_, "find_mut") if place => Expr::rt("tableFindMut", values), - (_, "find" | "find_mut") => Expr::rt("tableFind", values), - (_, "find_entry") => Expr::rt("tableFindEntry", values), - (_, "entry") => Expr::rt("tableEntry", values), - (_, "insert_unique") => Expr::rt("tableInsertUnique", values), + (_, "find_mut") if place => Expr::rs("tableFindMut", values), + (_, "find" | "find_mut") => Expr::rs("tableFind", values), + (_, "find_entry") => Expr::rs("tableFindEntry", values), + (_, "entry") => Expr::rs("tableEntry", values), + (_, "insert_unique") => Expr::rs("tableInsertUnique", values), (_, "clear") => { values.push(Expr::undefined()); values.extend(b.t.droppers([item], span)?); - Expr::rt("hashClear", values) + Expr::rs("hashClear", values) } (_, "retain") => { values.extend(b.t.droppers([item], span)?); - Expr::rt(if place { "tableRetainMut" } else { "tableRetain" }, values) + Expr::rs(if place { "tableRetainMut" } else { "tableRetain" }, values) } - (_, "iter_mut") if place => Expr::rt("hashValuesMut", values), - (_, "iter" | "iter_mut") => Expr::rt("hashValues", values), + (_, "iter_mut") if place => Expr::rs("hashValuesMut", values), + (_, "iter" | "iter_mut") => Expr::rs("hashValues", values), (_, "drain") => { values.extend(b.t.droppers([item], span)?); - Expr::rt("tableDrain", values) + Expr::rs("tableDrain", values) } ("Clone", "clone") => { values.extend([Expr::undefined(), clone_fn(b, item, span)]); - Expr::rt("hashClone", values) + Expr::rs("hashClone", values) } _ => return None, }; @@ -828,7 +828,7 @@ fn table_entry<'tcx>( let e = match name { "insert" | "or_insert" => { values.extend(b.t.droppers([item], span)?); - Expr::rt( + Expr::rs( if name == "insert" { "tableEntryInsert" } else { @@ -839,11 +839,11 @@ fn table_entry<'tcx>( } "or_insert_with" => { values.extend(uncalled(b, call)?); - Expr::rt("tableOrInsertWith", values) + Expr::rs("tableOrInsertWith", values) } "and_modify" => { values.extend(uncalled(b, call)?); - Expr::rt( + Expr::rs( if b.t.needs_place(item) { "tableAndModifyMut" } else { @@ -855,7 +855,7 @@ fn table_entry<'tcx>( // The entry is its item's place. "get_mut" | "into_mut" if b.t.needs_place(item) => values.pop()?, "get" | "get_mut" | "into_mut" => values.pop()?.member("v"), - "remove" => Expr::rt("tableRemove", values), + "remove" => Expr::rs("tableRemove", values), "into_table" => values.pop()?.member("t"), _ => return None, }; @@ -894,11 +894,11 @@ fn set_op_keys<'tcx>( "Sub" => "difference", _ => "symmetric_difference", }; - let keys = Expr::rt(set_op(prefix, name)?, values); + let keys = Expr::rs(set_op(prefix, name)?, values); let clone = clone_fn(b, arg(coll, 0), span); Some(match clone == Expr::undefined() { true => keys, - false => Expr::rt("iterMap", vec![keys, clone]), + false => Expr::rs("iterMap", vec![keys, clone]), }) } @@ -917,7 +917,7 @@ fn hash_extend<'tcx>( _ => "hashExtend", }; let tail = hash_extend_tail(b, coll, iter, span); - Expr::rt(f, super::iter::tail(vec![target, source], tail)) + Expr::rs(f, super::iter::tail(vec![target, source], tail)) } /// What `hashExtend` and its kin take after the collection and the items, of an iterator of @@ -984,7 +984,7 @@ fn hash_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, state: Option` or `HashSet` of type `coll`. @@ -1028,12 +1028,12 @@ fn state_dropper<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) - } /// `new`, as an empty collection of type `coll`: TS infers a generic key's type, as of -/// `rt.cmp`, from no argument, only from the type it is asserted to be. +/// `rs.cmp`, from no argument, only from the type it is asserted to be. fn empty<'tcx>(b: &mut Body<'_, '_, 'tcx>, new: Expr, coll: Ty<'tcx>, span: Span) -> Expr { Expr::As(Box::new(new), b.t.ty(coll, span)) } -/// The `rt.Hashing` a hash collection of type `coll` finds a `key` that is a JS object +/// The `rs.Hashing` a hash collection of type `coll` finds a `key` that is a JS object /// by, or `Some(None)` if every key is a JS primitive that compares as Rust's `Eq` does. fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span: Span) -> Option> { let peeled = peel(b, key); @@ -1070,7 +1070,7 @@ fn hashing<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, key: Ty<'tcx>, span { values.push(Expr::lit("true")); } - Some(Some(Expr::rt("hashing", values))) + Some(Some(Expr::rs("hashing", values))) } fn fieldless(adt: ty::AdtDef<'_>) -> bool { @@ -1133,7 +1133,7 @@ pub fn test_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, test: &str, span: let ty = peel_ord(b, ty, true); // An integer's, which the runtime tests directly rather than through `partial_cmp`. if matches!(ty.kind(), ty::Char | ty::Int(_) | ty::Uint(_)) { - return Expr::Rt(test.into()); + return Expr::Rs(test.into()); } if !own_test(b, ty, test) { let by = match test { @@ -1142,7 +1142,7 @@ pub fn test_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, test: &str, span: "gt" => "cmpGt", _ => "cmpGe", }; - return Expr::rt(by, vec![cmp_fn(b, ty, true, span)]); + return Expr::rs(by, vec![cmp_fn(b, ty, true, span)]); } match ty.kind() { // The fields before the last chain by `partial_cmp`, which no crate's type overrides. @@ -1150,11 +1150,11 @@ pub fn test_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, test: &str, span: let cmps = init.iter().map(|&t| cmp_fn(b, t, true, span)).collect(); let order = if matches!(test, "lt" | "le") { "-1" } else { "1" }; let last = test_fn(b, last, test, span); - Expr::rt("testTuple", vec![Expr::Array(cmps), last, Expr::lit(order)]) + Expr::rs("testTuple", vec![Expr::Array(cmps), last, Expr::lit(order)]) } - ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rt("cmpArc", vec![test_fn(b, inner, test, span)]), + ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rs("cmpArc", vec![test_fn(b, inner, test, span)]), ty::Adt(..) if let Some(inner) = reverse_of(b, ty) => { - Expr::rt("cmpReverse", vec![test_fn(b, inner, test, span)]) + Expr::rs("cmpReverse", vec![test_fn(b, inner, test, span)]) } ty::Adt(..) if let Some((inner, by)) = cell_of(b, ty) => { let f = test_fn(b, inner, test, span); @@ -1230,7 +1230,7 @@ pub(super) fn own_hasher<'tcx>(t: &Translator<'_, 'tcx>, h: Ty<'tcx>) -> bool { t.translated(hasher_fn(t.tcx, "finish"), t.tcx.mk_args(&[h.into()])) } -/// Each key of `rt.HasherImpl`, and the `Hasher` method it holds. +/// Each key of `rs.HasherImpl`, and the `Hasher` method it holds. const HASHER_METHODS: [(&str, &str); 16] = [ ("write", "write"), ("finish", "finish"), @@ -1251,14 +1251,14 @@ const HASHER_METHODS: [(&str, &str); 16] = [ ]; /// `state`, the `&mut` to `h`, a `Hasher` of the crate's own, as the runtime's `Hash` -/// functions write into it: an `rt.OwnHasher` of it, which hands its methods the `&mut` as -/// it is, an `rt.Place` where JS copies `h`. +/// functions write into it: an `rs.OwnHasher` of it, which hands its methods the `&mut` as +/// it is, an `rs.Place` where JS copies `h`. fn own_state<'tcx>(b: &mut Body<'_, '_, 'tcx>, h: Ty<'tcx>, state: Expr, span: Span) -> Expr { let methods = hasher_impl(b, h, span); - Expr::New(Box::new(Expr::Rt("OwnHasher".into())), vec![state, methods]) + Expr::New(Box::new(Expr::Rs("OwnHasher".into())), vec![state, methods]) } -/// The methods of `h`, a `Hasher` of the crate's own, as an `rt.HasherImpl`: `write`, +/// The methods of `h`, a `Hasher` of the crate's own, as an `rs.HasherImpl`: `write`, /// `finish`, and those of std's provided ones its impl writes, a module-level value beside /// its `finish`, made once. Each takes the `&mut` to `h`, which `finish`, given `&self`, /// reads where JS copies `h`. @@ -1301,7 +1301,7 @@ fn hasher_impl<'tcx>(b: &mut Body<'_, '_, 'tcx>, h: Ty<'tcx>, span: Span) -> Exp }); b.t.program.items.push(crate::ts::Item::Value { sym, - ty: Type::Rt("HasherImpl", vec![state]), + ty: Type::Rs("HasherImpl", vec![state]), value: Expr::Object(methods), doc: Some(format!( "The methods of `{h}`'s impl, which the runtime's hashing calls." @@ -1348,7 +1348,7 @@ fn own_hash_one<'tcx>( } else if let [Some(value_drop), None] = drops { values.push(value_drop); } - Expr::rt("hashOne", values) + Expr::rs("hashOne", values) } /// A method of `BTreeMap` or `BTreeSet`, or of a trait they implement. @@ -1370,7 +1370,7 @@ fn btree<'tcx>( let range = bounds(b, call, values.pop()?); let target = range_input(b, call).1; values.push(match other_shape(b, key, target) { - true => as_type(range.bounds.clone(), Type::Rt("Bounds", vec![b.t.ty(key, span)])), + true => as_type(range.bounds.clone(), Type::Rs("Bounds", vec![b.t.ty(key, span)])), false => range.bounds.clone(), }); ranged = Some(range); @@ -1398,7 +1398,7 @@ fn btree<'tcx>( }; return Some(range.held(|bounds, drop| { values.extend([bounds, f]); - Expr::rt(name, super::iter::tail(values, [tests, vec![drop]].concat())) + Expr::rs(name, super::iter::tail(values, [tests, vec![drop]].concat())) })); } let none = library::sentinel_option(b.t, call).is_some(); @@ -1406,38 +1406,38 @@ fn btree<'tcx>( let first = |values: Vec| flagged(values, false, none); let e = match (owner, name) { (_, "new") | ("Default", "default") => btree_new(b, coll, span), - (_, "len") => Expr::rt("btreeLen", values), - (_, "is_empty") => Expr::rt("btreeLen", values).binary("===", Expr::lit("0")), - (_, "clear") => Expr::rt("btreeClear", values), - (_, "contains_key" | "contains") => Expr::rt("btreeContains", values), - (_, "get_mut") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rt("btreeGetMut", values), - (_, "get" | "get_mut") if !set => Expr::rt("btreeGet", values), - (_, "get") => Expr::rt("btreeKey", first(values)), - (_, "take") => Expr::rt("btreeKey", last(values)), - (_, "replace") => Expr::rt("btreeReplace", values), - (_, "get_key_value") => Expr::rt("btreeGetKeyValue", values), - (_, "insert") if set => Expr::rt("btreeAdd", values), - (_, "insert") => Expr::rt("btreeInsert", values), - (_, "remove") if set => Expr::rt("btreeDelete", values), - (_, "remove") => Expr::rt("btreeRemove", values), - (_, "remove_entry") => Expr::rt("btreeRemoveEntry", values), - (_, "retain") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rt("btreeRetainMut", values), - (_, "retain") => Expr::rt("btreeRetain", values), - (_, "first_key_value") => Expr::rt("btreeFirst", values), - (_, "last_key_value") => Expr::rt("btreeFirst", last(values)), - (_, "pop_first") if set => Expr::rt("btreePopKey", first(values)), - (_, "pop_last") if set => Expr::rt("btreePopKey", last(values)), - (_, "pop_first") => Expr::rt("btreePop", values), - (_, "pop_last") => Expr::rt("btreePop", last(values)), - (_, "first") => Expr::rt("btreeFirstKey", first(values)), - (_, "last") => Expr::rt("btreeFirstKey", last(values)), - (_, "first_entry") => Expr::rt("btreeFirstEntry", values), - (_, "last_entry") => Expr::rt("btreeFirstEntry", last(values)), - (_, "iter_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rt("btreeIterMut", values), - (_, "values_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rt("btreeValuesMut", values), - (_, "iter" | "iter_mut") if !set => Expr::rt("btreeIter", values), - (_, "iter" | "keys") => Expr::rt("btreeKeys", values), - (_, "values" | "values_mut") => Expr::rt("btreeValues", values), + (_, "len") => Expr::rs("btreeLen", values), + (_, "is_empty") => Expr::rs("btreeLen", values).binary("===", Expr::lit("0")), + (_, "clear") => Expr::rs("btreeClear", values), + (_, "contains_key" | "contains") => Expr::rs("btreeContains", values), + (_, "get_mut") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rs("btreeGetMut", values), + (_, "get" | "get_mut") if !set => Expr::rs("btreeGet", values), + (_, "get") => Expr::rs("btreeKey", first(values)), + (_, "take") => Expr::rs("btreeKey", last(values)), + (_, "replace") => Expr::rs("btreeReplace", values), + (_, "get_key_value") => Expr::rs("btreeGetKeyValue", values), + (_, "insert") if set => Expr::rs("btreeAdd", values), + (_, "insert") => Expr::rs("btreeInsert", values), + (_, "remove") if set => Expr::rs("btreeDelete", values), + (_, "remove") => Expr::rs("btreeRemove", values), + (_, "remove_entry") => Expr::rs("btreeRemoveEntry", values), + (_, "retain") if !set && b.t.needs_place(arg(coll, 1)) => Expr::rs("btreeRetainMut", values), + (_, "retain") => Expr::rs("btreeRetain", values), + (_, "first_key_value") => Expr::rs("btreeFirst", values), + (_, "last_key_value") => Expr::rs("btreeFirst", last(values)), + (_, "pop_first") if set => Expr::rs("btreePopKey", first(values)), + (_, "pop_last") if set => Expr::rs("btreePopKey", last(values)), + (_, "pop_first") => Expr::rs("btreePop", values), + (_, "pop_last") => Expr::rs("btreePop", last(values)), + (_, "first") => Expr::rs("btreeFirstKey", first(values)), + (_, "last") => Expr::rs("btreeFirstKey", last(values)), + (_, "first_entry") => Expr::rs("btreeFirstEntry", values), + (_, "last_entry") => Expr::rs("btreeFirstEntry", last(values)), + (_, "iter_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rs("btreeIterMut", values), + (_, "values_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rs("btreeValuesMut", values), + (_, "iter" | "iter_mut") if !set => Expr::rs("btreeIter", values), + (_, "iter" | "keys") => Expr::rs("btreeKeys", values), + (_, "values" | "values_mut") => Expr::rs("btreeValues", values), // Each of which drops the half it does not yield as it reads, and whose `last` reads // the back. (_, "into_keys" | "into_values") => { @@ -1450,14 +1450,14 @@ fn btree<'tcx>( } else { "btreeValues" }; - Expr::rt(f, super::iter::tail(values, droppers)) - } - (_, "range") if set => Expr::rt("btreeRangeKeys", values), - (_, "range_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rt("btreeRangeMut", values), - (_, "range" | "range_mut") => Expr::rt("btreeRange", values), - (_, "entry") => Expr::rt("entry", values), - (_, "split_off") => Expr::rt("btreeSplitOff", values), - (_, name) if let Some(f) = set_op("btree", name) => Expr::rt(f, values), + Expr::rs(f, super::iter::tail(values, droppers)) + } + (_, "range") if set => Expr::rs("btreeRangeKeys", values), + (_, "range_mut") if b.t.needs_place(arg(coll, 1)) => Expr::rs("btreeRangeMut", values), + (_, "range" | "range_mut") => Expr::rs("btreeRange", values), + (_, "entry") => Expr::rs("entry", values), + (_, "split_off") => Expr::rs("btreeSplitOff", values), + (_, name) if let Some(f) = set_op("btree", name) => Expr::rs(f, values), ("BitOr" | "BitAnd" | "Sub" | "BitXor", _) => { let keys = set_op_keys(b, coll, "btree", owner, values, span)?; let target = btree_new(b, coll, span); @@ -1469,9 +1469,9 @@ fn btree<'tcx>( }; let mut rest = vec![same]; rest.extend(entry_droppers(b, coll, span)); - Expr::rt("btreeFromSorted", super::iter::tail(vec![target, keys], rest)) + Expr::rs("btreeFromSorted", super::iter::tail(vec![target, keys], rest)) } - ("Index", "index") => Expr::rt("btreeIndex", values), + ("Index", "index") => Expr::rs("btreeIndex", values), ("Clone", "clone") => { let k = clone_fn(b, key, span); let v = match value { @@ -1479,7 +1479,7 @@ fn btree<'tcx>( None => Expr::undefined(), }; values.extend([k, v]); - Expr::rt("btreeClone", values) + Expr::rs("btreeClone", values) } ("Extend", "extend") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; @@ -1529,7 +1529,7 @@ fn btree_collect<'tcx>( droppers.push(super::iter::size_of(b, elem, span)); droppers.push(Expr::lit(trusted.to_string())); let f = if set { "btreeExtendKeys" } else { "btreeExtend" }; - return Expr::rt(f, super::iter::tail(vec![target, source], droppers)); + return Expr::rs(f, super::iter::tail(vec![target, source], droppers)); } let entries = super::iter::to_vec(b, source, iter, elem, trusted, span).member("items"); let mut rest = Vec::from(super::library::sort_of(b, elem, span)); @@ -1546,7 +1546,7 @@ fn btree_collect<'tcx>( }); rest.extend(entry_droppers(b, coll, span)); let f = if set { "btreeCollectKeys" } else { "btreeCollect" }; - Expr::rt(f, super::iter::tail(vec![target, entries], rest)) + Expr::rs(f, super::iter::tail(vec![target, entries], rest)) } /// Whether ordering or comparing a `ty` may run the crate's own `Ord`, `PartialOrd`, or @@ -1603,12 +1603,12 @@ fn own_ord<'tcx>( /// An empty B-tree of type `coll`, ordered by its keys' `Ord`. fn btree_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { let cmp = cmp_fn(b, arg(coll, 0), false, span); - empty(b, Expr::rt("btreeNew", vec![cmp]), coll, span) + empty(b, Expr::rs("btreeNew", vec![cmp]), coll, span) } /// An empty `VecDeque` of type `coll`. fn deque_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { - let made = Expr::rt("dequeNew", deque_items(b, arg(coll, 0), span)); + let made = Expr::rs("dequeNew", deque_items(b, arg(coll, 0), span)); empty(b, made, coll, span) } @@ -1641,7 +1641,7 @@ fn deque<'tcx>( (_, "new") | ("Default", "default") => deque_new(b, coll, span), (_, "with_capacity") => { values.extend(deque_items(b, item, span)); - empty(b, Expr::rt("dequeWithCapacity", values), coll, span) + empty(b, Expr::rs("dequeWithCapacity", values), coll, span) } ( _, @@ -1659,60 +1659,60 @@ fn deque<'tcx>( "try_reserve_exact" => "dequeTryReserveExact", _ => "dequeShrinkTo", }; - Expr::rt(f, values) + Expr::rs(f, values) } (_, "len") => values.pop()?.member("n"), (_, "is_empty") => values.pop()?.member("n").binary("===", Expr::lit("0")), - (_, "clear") => Expr::rt("dequeClear", values), - (_, "push_back") => Expr::rt("dequePushBack", values), - (_, "push_front") => Expr::rt("dequePushFront", values), - (_, "pop_back") => Expr::rt("dequePopBack", values), - (_, "pop_front") => Expr::rt("dequePopFront", values), - (_, "front_mut") if b.t.needs_place(item) => Expr::rt("dequeEndMut", values), - (_, "back_mut") if b.t.needs_place(item) => Expr::rt("dequeEndMut", back(values)), - (_, "get_mut") if b.t.needs_place(item) => Expr::rt("dequeGetMut", values), - (_, "front" | "front_mut") => Expr::rt("dequeEnd", flagged(values, false, none)), - (_, "back" | "back_mut") => Expr::rt("dequeEnd", back(values)), - (_, "get" | "get_mut") => Expr::rt("dequeGet", values), - (_, "swap_remove_front") => Expr::rt("dequeSwapRemove", flagged(values, false, none)), - (_, "swap_remove_back") => Expr::rt("dequeSwapRemove", back(values)), - (_, "truncate") => Expr::rt("dequeTruncate", values), - (_, "append") => Expr::rt("dequeAppend", values), - (_, "split_off") => Expr::rt("dequeSplitOff", values), + (_, "clear") => Expr::rs("dequeClear", values), + (_, "push_back") => Expr::rs("dequePushBack", values), + (_, "push_front") => Expr::rs("dequePushFront", values), + (_, "pop_back") => Expr::rs("dequePopBack", values), + (_, "pop_front") => Expr::rs("dequePopFront", values), + (_, "front_mut") if b.t.needs_place(item) => Expr::rs("dequeEndMut", values), + (_, "back_mut") if b.t.needs_place(item) => Expr::rs("dequeEndMut", back(values)), + (_, "get_mut") if b.t.needs_place(item) => Expr::rs("dequeGetMut", values), + (_, "front" | "front_mut") => Expr::rs("dequeEnd", flagged(values, false, none)), + (_, "back" | "back_mut") => Expr::rs("dequeEnd", back(values)), + (_, "get" | "get_mut") => Expr::rs("dequeGet", values), + (_, "swap_remove_front") => Expr::rs("dequeSwapRemove", flagged(values, false, none)), + (_, "swap_remove_back") => Expr::rs("dequeSwapRemove", back(values)), + (_, "truncate") => Expr::rs("dequeTruncate", values), + (_, "append") => Expr::rs("dequeAppend", values), + (_, "split_off") => Expr::rs("dequeSplitOff", values), // `resize` clones its value for each slot but the last. (_, "resize") => { values.push(clone_fn(b, item, span)); - Expr::rt("dequeResize", values) - } - (_, "resize_with") => Expr::rt("dequeResizeWith", values), - (_, "swap") => Expr::rt("dequeSwap", values), - (_, "rotate_left") => Expr::rt("dequeRotate", values), - (_, "rotate_right") => Expr::rt("dequeRotate", flagged(values, true, false)), - (_, "make_contiguous") if super::byte(item) => Expr::rt("dequeByteMakeContiguous", values), - (_, "make_contiguous") => Expr::rt("dequeMakeContiguous", values), + Expr::rs("dequeResize", values) + } + (_, "resize_with") => Expr::rs("dequeResizeWith", values), + (_, "swap") => Expr::rs("dequeSwap", values), + (_, "rotate_left") => Expr::rs("dequeRotate", values), + (_, "rotate_right") => Expr::rs("dequeRotate", flagged(values, true, false)), + (_, "make_contiguous") if super::byte(item) => Expr::rs("dequeByteMakeContiguous", values), + (_, "make_contiguous") => Expr::rs("dequeMakeContiguous", values), (_, "binary_search") => { values.push(cmp_fn(b, item, false, span)); - Expr::rt("dequeBinarySearch", values) + Expr::rs("dequeBinarySearch", values) } - (_, "binary_search_by") => Expr::rt("dequeBinarySearchBy", values), + (_, "binary_search_by") => Expr::rs("dequeBinarySearchBy", values), // `VecDeque::binary_search_by_key::`. (_, "binary_search_by_key") => { let key = library::targ(call.args, 2); values.push(cmp_fn(b, key, false, span)); let drop = b.t.dropper(key, span); - Expr::rt("dequeBinarySearchByKey", super::iter::tail(values, vec![drop])) + Expr::rs("dequeBinarySearchByKey", super::iter::tail(values, vec![drop])) } - (_, "partition_point") => Expr::rt("dequePartitionPoint", values), - (_, "retain_mut") if b.t.needs_place(item) => Expr::rt("dequeRetainMut", values), - (_, "retain" | "retain_mut") => Expr::rt("dequeRetain", values), - (_, "remove") => Expr::rt("dequeRemove", values), - (_, "insert") => Expr::rt("dequeInsert", values), + (_, "partition_point") => Expr::rs("dequePartitionPoint", values), + (_, "retain_mut") if b.t.needs_place(item) => Expr::rs("dequeRetainMut", values), + (_, "retain" | "retain_mut") => Expr::rs("dequeRetain", values), + (_, "remove") => Expr::rs("dequeRemove", values), + (_, "insert") => Expr::rs("dequeInsert", values), (_, "contains") => { values.push(eq_fn(b, item, span)); - Expr::rt("dequeContains", values) + Expr::rs("dequeContains", values) } - (_, "iter_mut") if b.t.needs_place(item) => Expr::rt("dequeIterMut", values), - (_, "iter" | "iter_mut") => Expr::rt("dequeIter", values), + (_, "iter_mut") if b.t.needs_place(item) => Expr::rs("dequeIterMut", values), + (_, "iter" | "iter_mut") => Expr::rs("dequeIter", values), (_, "range" | "range_mut") => { let ranged = bounds(b, call, values.pop()?); values.push(ranged.bounds.clone()); @@ -1720,23 +1720,23 @@ fn deque<'tcx>( true => "dequeRangeMut", false => "dequeRange", }; - ranged.after(Expr::rt(f, values)) + ranged.after(Expr::rs(f, values)) } // Each a copy of its part of the buffer, or with `_mut`, a view that writes into it; // bytes are views either way. - (_, "as_slices" | "as_mut_slices") if super::byte(item) => Expr::rt("dequeByteSlices", values), - (_, "as_slices") => Expr::rt("dequeAsSlices", values), - (_, "as_mut_slices") => Expr::rt("dequeAsSlices", flagged(values, true, false)), + (_, "as_slices" | "as_mut_slices") if super::byte(item) => Expr::rs("dequeByteSlices", values), + (_, "as_slices") => Expr::rs("dequeAsSlices", values), + (_, "as_mut_slices") => Expr::rs("dequeAsSlices", flagged(values, true, false)), (_, "drain") => { let ranged = bounds(b, call, values.pop()?); values.push(ranged.bounds.clone()); let droppers = entry_droppers(b, coll, span); - ranged.after(Expr::rt("dequeDrain", super::iter::tail(values, droppers))) + ranged.after(Expr::rs("dequeDrain", super::iter::tail(values, droppers))) } - ("Index" | "IndexMut", "index" | "index_mut") => Expr::rt("dequeIndex", values), + ("Index" | "IndexMut", "index" | "index_mut") => Expr::rs("dequeIndex", values), ("Clone", "clone") => { let clone = clone_fn(b, item, span); - Expr::rt("dequeClone", super::iter::tail(values, vec![clone])) + Expr::rs("dequeClone", super::iter::tail(values, vec![clone])) } // std's clears it, which drops its items, and extends it by clones of the source's, // keeping its capacity; `clone_into` is the target's `clone_from`. @@ -1745,21 +1745,21 @@ fn deque<'tcx>( values.reverse(); } values.push(clone_fn(b, item, span)); - Expr::rt("dequeCloneFrom", values) + Expr::rs("dequeCloneFrom", values) } // `From>` keeps the vector's capacity, and `From<[T; N]>` holds exactly `N`. ("From", "from") if b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { let v = values.pop()?; let v = match super::byte(item) { - true => Expr::rt("byteVecToVec", vec![v]), + true => Expr::rs("byteVecToVec", vec![v]), false => v, }; - let made = Expr::rt("dequeFromVec", [vec![v], deque_items(b, item, span)].concat()); + let made = Expr::rs("dequeFromVec", [vec![v], deque_items(b, item, span)].concat()); empty(b, made, coll, span) } ("From", "from") if library::targ(call.args, 1).is_array() => { let a = values.pop()?; - let made = Expr::rt("dequeFromArray", [vec![a], deque_items(b, item, span)].concat()); + let made = Expr::rs("dequeFromArray", [vec![a], deque_items(b, item, span)].concat()); empty(b, made, coll, span) } ("Extend", "extend") | ("From", "from") => { @@ -1777,7 +1777,7 @@ fn deque<'tcx>( /// An empty `LinkedList` of type `coll`. fn list_new<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Expr { - empty(b, Expr::rt("listNew", vec![]), coll, span) + empty(b, Expr::rs("listNew", vec![]), coll, span) } /// A method of `LinkedList`, or of a trait it implements. Its node is the place of the @@ -1799,36 +1799,36 @@ fn list<'tcx>( (_, "new") | ("Default", "default") => list_new(b, coll, span), (_, "len") => values.pop()?.member("n"), (_, "is_empty") => values.pop()?.member("n").binary("===", Expr::lit("0")), - (_, "clear") => Expr::rt("listClear", values), - (_, "push_back" | "push_back_mut") => Expr::rt("listPushBack", values), - (_, "push_front" | "push_front_mut") => Expr::rt("listPushFront", values), - (_, "pop_back") => Expr::rt("listPopBack", values), - (_, "pop_front") => Expr::rt("listPopFront", values), - (_, "front_mut") if places => Expr::rt("listEndMut", values), - (_, "back_mut") if places => Expr::rt("listEndMut", flagged(values, true, false)), - (_, "front" | "front_mut") => Expr::rt("listEnd", flagged(values, false, none)), - (_, "back" | "back_mut") => Expr::rt("listEnd", flagged(values, true, none)), + (_, "clear") => Expr::rs("listClear", values), + (_, "push_back" | "push_back_mut") => Expr::rs("listPushBack", values), + (_, "push_front" | "push_front_mut") => Expr::rs("listPushFront", values), + (_, "pop_back") => Expr::rs("listPopBack", values), + (_, "pop_front") => Expr::rs("listPopFront", values), + (_, "front_mut") if places => Expr::rs("listEndMut", values), + (_, "back_mut") if places => Expr::rs("listEndMut", flagged(values, true, false)), + (_, "front" | "front_mut") => Expr::rs("listEnd", flagged(values, false, none)), + (_, "back" | "back_mut") => Expr::rs("listEnd", flagged(values, true, none)), (_, "contains") => { values.push(eq_fn(b, item, span)); - Expr::rt("listContains", values) - } - (_, "iter_mut") if places => Expr::rt("listIterMut", values), - (_, "iter" | "iter_mut") => Expr::rt("listIter", values), - (_, "append") => Expr::rt("listAppend", values), - (_, "split_off") => Expr::rt("listSplitOff", values), - (_, "extract_if") if places => Expr::rt("listExtractIfMut", values), - (_, "extract_if") => Expr::rt("listExtractIf", values), + Expr::rs("listContains", values) + } + (_, "iter_mut") if places => Expr::rs("listIterMut", values), + (_, "iter" | "iter_mut") => Expr::rs("listIter", values), + (_, "append") => Expr::rs("listAppend", values), + (_, "split_off") => Expr::rs("listSplitOff", values), + (_, "extract_if") if places => Expr::rs("listExtractIfMut", values), + (_, "extract_if") => Expr::rs("listExtractIf", values), ("Clone", "clone") => { values.push(clone_fn(b, item, span)); - Expr::rt("listClone", values) + Expr::rs("listClone", values) } // Each item by its `clone_from`. ("Clone", "clone_from") => { let fns = library::clone_from_fns(b, item, span); - Expr::rt("listCloneFrom", [values, fns].concat()) + Expr::rs("listCloneFrom", [values, fns].concat()) } // std's specializes `extend` by another list to `append`. - ("Extend", "extend") if library::targ(call.args, 2) == coll => Expr::rt("listAppend", values), + ("Extend", "extend") if library::targ(call.args, 2) == coll => Expr::rs("listAppend", values), ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; let target = match owner { @@ -1868,11 +1868,11 @@ fn heap<'tcx>( let bytes = super::byte(item); let mut values = args; let e = match (owner, name) { - (_, "new") | ("Default", "default") => empty(b, Expr::rt("heapNew", vec![]), coll, span), + (_, "new") | ("Default", "default") => empty(b, Expr::rs("heapNew", vec![]), coll, span), // Its vector's, given the size of its elements, by which std's grows it. (_, "with_capacity") => { values.push(super::iter::size_of(b, item, span)); - empty(b, Expr::rt("heapWithCapacity", values), coll, span) + empty(b, Expr::rs("heapWithCapacity", values), coll, span) } ( _, @@ -1891,7 +1891,7 @@ fn heap<'tcx>( "try_reserve_exact" => "vecTryReserveExact", _ => "vecShrinkTo", }; - Expr::rt(f, values) + Expr::rs(f, values) } (_, "len") => values.pop()?.member("items").member("length"), (_, "is_empty") => values @@ -1899,8 +1899,8 @@ fn heap<'tcx>( .member("items") .member("length") .binary("===", Expr::lit("0")), - // Indexing returns `undefined` for no element, where an `rt.None` must follow. - (_, "peek") if library::sentinel_option(b.t, call).is_some() => Expr::rt("heapPeek", values), + // Indexing returns `undefined` for no element, where an `rs.None` must follow. + (_, "peek") if library::sentinel_option(b.t, call).is_some() => Expr::rs("heapPeek", values), (_, "peek") => values.pop()?.member("items").index(Expr::lit("0")), (_, "push" | "pop" | "peek_mut" | "append" | "retain" | "into_sorted_vec") => { values.extend(heap_tests(b, item, !matches!(name, "push" | "pop"), span)); @@ -1910,15 +1910,15 @@ fn heap<'tcx>( "peek_mut" => "heapPeekMut", "append" => "heapAppend", "retain" => "heapRetain", - _ => return Some(heap_vec(Expr::rt("heapIntoSortedVec", values), bytes)), + _ => return Some(heap_vec(Expr::rs("heapIntoSortedVec", values), bytes)), }; if name == "append" { values.push(super::iter::size_of(b, item, span)); } - Expr::rt(f, values) + Expr::rs(f, values) } (_, "into_vec") => heap_vec(values.pop()?, bytes), - (_, "as_slice") if bytes => Expr::rt( + (_, "as_slice") if bytes => Expr::rs( "byteSliceFrom", vec![ Expr::ident("Uint8Array") @@ -1927,32 +1927,32 @@ fn heap<'tcx>( ], ), (_, "as_slice") => values.pop()?.member("items"), - (_, "clear") => Expr::rt("heapClear", values), + (_, "clear") => Expr::rs("heapClear", values), (_, "drain") => { let droppers = entry_droppers(b, coll, span); - Expr::rt("heapDrain", super::iter::tail(values, droppers)) + Expr::rs("heapDrain", super::iter::tail(values, droppers)) } - (_, "iter") => Expr::rt("heapIter", values), + (_, "iter") => Expr::rs("heapIter", values), ("Clone", "clone") => { values.push(clone_fn(b, item, span)); - Expr::rt("heapClone", values) + Expr::rs("heapClone", values) } // `From>` rebuilds the vector in place, and `From<[T; N]>` collects the array // into one first. ("From", "from") if b.t.std_of(library::targ(call.args, 1)) == Some(Std::Vec) => { let v = values.pop()?; let d = match bytes { - true => Expr::rt("byteVecToVec", vec![v]), + true => Expr::rs("byteVecToVec", vec![v]), false => v, }; - Expr::rt("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) + Expr::rs("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) } ("Extend", "extend") | ("From", "from") => { let (source, iter) = extend_source(b, coll, call, owner, values.pop()?)?; if owner == "From" { let trusted = super::iter::implements(b.t, iter, "TrustedLen"); let d = super::iter::to_vec(b, source, iter, item, trusted, span); - return Some(Expr::rt( + return Some(Expr::rs( "heapFrom", [vec![d], heap_tests(b, item, true, span)].concat(), )); @@ -1964,15 +1964,15 @@ fn heap<'tcx>( Some(e) } -/// The `Vec` a heap, `h`, is, an `rt.ByteVec` of bytes, with its capacity. +/// The `Vec` a heap, `h`, is, an `rs.ByteVec` of bytes, with its capacity. pub fn heap_vec(h: Expr, bytes: bool) -> Expr { match bytes { - true => Expr::rt("byteVecFromVec", vec![h]), + true => Expr::rs("byteVecFromVec", vec![h]), false => h, } } -/// What `extend` or `from` adds to a collection: an `rt.Iter` of what `source` holds, and +/// What `extend` or `from` adds to a collection: an `rs.Iter` of what `source` holds, and /// the type of the iterator std's makes of it. fn extend_source<'tcx>( b: &mut Body<'_, '_, 'tcx>, @@ -2000,13 +2000,13 @@ fn extend_source<'tcx>( _ => elems[0], }; let borrowed = owner == "Extend" && library::targ(call.args, 1) != stored; - // A `[u8; N]` is given as the `rt.ByteSlice` a `&[u8; N]` is, so it is made an array + // A `[u8; N]` is given as the `rs.ByteSlice` a `&[u8; N]` is, so it is made an array // whether or not the crate writes into one. if !borrowed || !elems.iter().any(|&t| b.t.needs_copy(t) || super::byte_array(t)) { return Some((items, iter)); } let items = match super::lend::copy_fn(b, stored, call.span) { - Some(copy) => Expr::rt("iterMap", vec![items, copy]), + Some(copy) => Expr::rs("iterMap", vec![items, copy]), None => items, }; Some((items, iter)) @@ -2028,7 +2028,7 @@ pub fn extend<'tcx>( if coll.is_unit() { let drops = super::iter::iter_drops(b, iter, span); let each = Expr::Lambda(Vec::new(), Box::new(Expr::undefined())); - return Some(Expr::rt( + return Some(Expr::rs( "iterForEach", super::iter::tail(vec![items, each], vec![drops]), )); @@ -2053,15 +2053,15 @@ pub fn extend<'tcx>( Some(match std { Std::Vec if super::byte(arg(coll, 0)) => { let take = super::iter::iter_take(b, iter, trusted, span); - Expr::rt( + Expr::rs( "iterExtendBytes", super::iter::tail(vec![target, items], vec![take, Expr::lit(trusted.to_string())]), ) } - Std::Vec => Expr::rt("iterExtend", super::iter::tail(vec![target, items], vec_reserve(b))), + Std::Vec => Expr::rs("iterExtend", super::iter::tail(vec![target, items], vec_reserve(b))), Std::VecDeque => { let take = super::iter::iter_take(b, iter, trusted, span); - Expr::rt( + Expr::rs( "dequeExtend", super::iter::tail(vec![target, items], vec![take, Expr::lit(trusted.to_string())]), ) @@ -2069,13 +2069,13 @@ pub fn extend<'tcx>( // By `for_each`, reserving nothing. Std::LinkedList => { let take = super::iter::iter_take(b, iter, true, span); - Expr::rt("listExtend", super::iter::tail(vec![target, items], vec![take])) + Expr::rs("listExtend", super::iter::tail(vec![target, items], vec![take])) } // Into its vector, and then sifted. Std::BinaryHeap => { let mut args = vec![target, items]; args.extend(heap_tests(b, arg(coll, 0), true, span)); - Expr::rt("heapExtend", super::iter::tail(args, vec_reserve(b))) + Expr::rs("heapExtend", super::iter::tail(args, vec_reserve(b))) } Std::HashMap | Std::HashSet => hash_extend(b, coll, target, items, iter, span), Std::BTreeMap | Std::BTreeSet => { @@ -2088,7 +2088,7 @@ pub fn extend<'tcx>( } else { "btreeExtend" }; - Expr::rt(f, super::iter::tail(vec![target, items], droppers)) + Expr::rs(f, super::iter::tail(vec![target, items], droppers)) } _ => return None, }) @@ -2148,10 +2148,10 @@ pub fn tuple_extend<'tcx>( let (c, each) = (b.fresh("c"), b.fresh("items")); let mut each_items = Expr::ident(&each); if let Some(copy) = copy_borrowed(b, *coll, *field, span) { - each_items = Expr::rt("iterMap", vec![each_items, copy]); + each_items = Expr::rs("iterMap", vec![each_items, copy]); } let extended = match own_extend(b, *coll, *field, mapped, span) { - Some((f, place)) => Some(Expr::rt( + Some((f, place)) => Some(Expr::rs( "ownExtend", super::iter::tail(vec![Expr::ident(&c), each_items, f], vec![Expr::lit(place.to_string())]), )), @@ -2185,7 +2185,7 @@ pub fn tuple_extend<'tcx>( empty(b, defaults, tuple, span) } }; - Some(Expr::rt(f, [vec![target], rest].concat())) + Some(Expr::rs(f, [vec![target], rest].concat())) } /// `Iterator::partition` of `items`, an iterator of `item`s, by `f`, into two defaults of @@ -2205,21 +2205,21 @@ pub fn partition<'tcx>( let left = empty(b, left, coll, span); let right = default(b, coll, span)?; let right = empty(b, right, coll, span); - Some(Expr::rt( + Some(Expr::rs( "iterPartition", super::iter::tail(vec![items, f, Expr::Array(vec![left, right]), part], flags), )) } -/// The `rt.Part` a tuple's `Extend` adds `item`s to a collection of type `coll` by, or to a +/// The `rs.Part` a tuple's `Extend` adds `item`s to a collection of type `coll` by, or to a /// tuple of them, which is one too: `None` for any other. fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: Span) -> Option { if coll.is_unit() { - return Some(Expr::Rt("UNIT_PART".into())); + return Some(Expr::Rs("UNIT_PART".into())); } if let (ty::Tuple(colls), ty::Tuple(items)) = (coll.kind(), item.kind()) { let parts = colls.iter().zip(items.iter()).map(|(c, i)| part(b, c, i, span)); - return Some(Expr::rt("tuplePart", vec![Expr::Array(parts.collect::>()?)])); + return Some(Expr::rs("tuplePart", vec![Expr::Array(parts.collect::>()?)])); } // The crate's own, whose `extend_one` is `extend` of `Some(item)`. let Some(std) = b.t.std_of(coll) else { @@ -2227,7 +2227,7 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: return None; } let (f, place) = own_extend(b, coll, item, Ty::new_option(b.t.tcx, item), span)?; - return Some(Expr::rt( + return Some(Expr::rs( "ownPart", super::iter::tail(vec![f], vec![Expr::lit(place.to_string())]), )); @@ -2238,17 +2238,17 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: true if library::cow_str(b.t.tcx, item.peel_refs()) => "STRING_COW_PART", true => "STRING_PART", }; - return Some(Expr::Rt(part.into())); + return Some(Expr::Rs(part.into())); } let size = |b: &mut Body<'_, '_, 'tcx>| vec![super::iter::size_of(b, arg(coll, 0), span)]; let part = match std { - Std::Vec if super::byte(arg(coll, 0)) => Expr::rt("byteVecPart", Vec::new()), - Std::Vec => Expr::rt("vecPart", super::iter::tail(Vec::new(), size(b))), - Std::VecDeque => Expr::rt("dequePart", Vec::new()), - Std::LinkedList => Expr::rt("listPart", Vec::new()), + Std::Vec if super::byte(arg(coll, 0)) => Expr::rs("byteVecPart", Vec::new()), + Std::Vec => Expr::rs("vecPart", super::iter::tail(Vec::new(), size(b))), + Std::VecDeque => Expr::rs("dequePart", Vec::new()), + Std::LinkedList => Expr::rs("listPart", Vec::new()), Std::BinaryHeap => { let le = heap_tests(b, arg(coll, 0), false, span); - Expr::rt("heapPart", super::iter::tail(le, size(b))) + Expr::rs("heapPart", super::iter::tail(le, size(b))) } Std::HashMap | Std::HashSet => { let mut args = entry_droppers(b, coll, span); @@ -2258,7 +2258,7 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: } else { "hashPart" }; - Expr::rt(f, super::iter::tail(Vec::new(), args)) + Expr::rs(f, super::iter::tail(Vec::new(), args)) } Std::BTreeMap | Std::BTreeSet => { let droppers = entry_droppers(b, coll, span); @@ -2267,19 +2267,19 @@ fn part<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, item: Ty<'tcx>, span: } else { "btreePart" }; - Expr::rt(f, super::iter::tail(Vec::new(), droppers)) + Expr::rs(f, super::iter::tail(Vec::new(), droppers)) } _ => return None, }; Some(match copy_borrowed(b, coll, item, span) { - Some(copy) => Expr::rt("copiedPart", vec![part, copy]), + Some(copy) => Expr::rs("copiedPart", vec![part, copy]), None => part, }) } /// The crate's own `Extend::extend` of a collection of type `coll` by an iterator of type /// `iter` of `item`s, as a function of the collection and the iterator, and whether it -/// takes the collection as an `rt.Place`: `None` for a collection of std's, or one whose +/// takes the collection as an `rs.Place`: `None` for a collection of std's, or one whose /// `extend` doesn't translate. Stable Rust can't override `extend_reserve` or `extend_one`, /// which keep their defaults: nothing, and `extend` of `Some(item)`. fn own_extend<'tcx>( @@ -2359,11 +2359,11 @@ fn default<'tcx>(b: &mut Body<'_, '_, 'tcx>, coll: Ty<'tcx>, span: Span) -> Opti }; Some(match std { Std::String => Expr::Str(String::new()), - Std::Vec if super::byte(arg(coll, 0)) => Expr::New(Box::new(Expr::Rt("ByteVec".into())), Vec::new()), + Std::Vec if super::byte(arg(coll, 0)) => Expr::New(Box::new(Expr::Rs("ByteVec".into())), Vec::new()), Std::Vec => library::vec_new(false), Std::VecDeque => deque_new(b, coll, span), Std::LinkedList => list_new(b, coll, span), - Std::BinaryHeap => empty(b, Expr::rt("heapNew", Vec::new()), coll, span), + Std::BinaryHeap => empty(b, Expr::rs("heapNew", Vec::new()), coll, span), Std::HashMap | Std::HashSet => { let state = new_state(b, coll, span); hash_new(b, coll, state, span)? @@ -2391,30 +2391,30 @@ fn entry<'tcx>( false => f.to_string(), }; let e = match name { - "or_insert" => Expr::rt(mutable("entryOrInsert"), values), + "or_insert" => Expr::rs(mutable("entryOrInsert"), values), // A vacant entry's. - "insert" if is_vacant(b, coll) => Expr::rt(mutable("entryOrInsert"), values), - "insert" => Expr::rt("entryInsert", values), + "insert" if is_vacant(b, coll) => Expr::rs(mutable("entryOrInsert"), values), + "insert" => Expr::rs("entryInsert", values), "or_insert_with" | "or_insert_with_key" => { values.extend(uncalled(b, call)?); - Expr::rt(mutable("entryOrInsertWith"), values) + Expr::rs(mutable("entryOrInsertWith"), values) } "or_default" => { let tcx = b.t.tcx; let default = trait_fn(tcx, "Default", "default"); values.push(b.fn_value(default, tcx.mk_args(&[value.into()]), span)); - Expr::rt(mutable("entryOrInsertWith"), values) + Expr::rs(mutable("entryOrInsertWith"), values) } "and_modify" => { values.extend(uncalled(b, call)?); - Expr::rt(mutable("entryAndModify"), values) + Expr::rs(mutable("entryAndModify"), values) } - "key" => Expr::rt("entryKey", values), + "key" => Expr::rs("entryKey", values), "into_key" => values.pop()?.member("k"), - "get" => Expr::rt("entryGet", values), - "get_mut" | "into_mut" => Expr::rt(mutable("entryGet"), values), - "remove" => Expr::rt("entryRemove", values), - "remove_entry" => Expr::rt("entryRemoveEntry", values), + "get" => Expr::rs("entryGet", values), + "get_mut" | "into_mut" => Expr::rs(mutable("entryGet"), values), + "remove" => Expr::rs("entryRemove", values), + "remove_entry" => Expr::rs("entryRemoveEntry", values), _ => return None, }; Some(e) @@ -2434,7 +2434,7 @@ pub fn entry_test(std: Std, adt: ty::AdtDef<'_>, index: rustc_abi::VariantIdx, e } else { "entryOccupied" }; - let occupied = Expr::rt(f, vec![entry]); + let occupied = Expr::rs(f, vec![entry]); match adt.variant(index).name.as_str() { "Occupied" => occupied, _ => occupied.not(), @@ -2462,11 +2462,11 @@ fn ordering(name: &str, mut values: Vec) -> Option { "is_gt" => values.pop()?.binary(">", zero()), "is_le" => values.pop()?.binary("<=", zero()), "is_ge" => values.pop()?.binary(">=", zero()), - "reverse" => Expr::rt("orderingReverse", values), - "then" => Expr::rt("orderingThen", values), + "reverse" => Expr::rs("orderingReverse", values), + "then" => Expr::rs("orderingThen", values), "then_with" => { let [o, f] = <[Expr; 2]>::try_from(values).ok()?; - Expr::rt("orderingThen", vec![o, f, Expr::lit("true")]) + Expr::rs("orderingThen", vec![o, f, Expr::lit("true")]) } _ => return None, }; @@ -2486,17 +2486,17 @@ fn random_state<'tcx>( let span = call.span; let mut values = args.into_iter(); match (name, values.next()) { - ("new" | "default", _) => Expr::rt("randomState", vec![]), + ("new" | "default", _) => Expr::rs("randomState", vec![]), ("clone", Some(state)) => state, - ("build_hasher", Some(state)) => Expr::rt("buildHasher", vec![state]), + ("build_hasher", Some(state)) => Expr::rs("buildHasher", vec![state]), // It takes the value, which drops once hashed. ("hash_one", Some(state)) if let Some(value) = values.next() => { let hasher = built_hasher(b, ty).expect("a RandomState builds a DefaultHasher"); let value_ty = library::targ(call.args, 1); - let built = Expr::rt("buildHasher", vec![state]); + let built = Expr::rs("buildHasher", vec![state]); let mut args = vec![built, value, hash_fn(b, value_ty, hasher, span)]; args.extend(b.t.drop_fn(value_ty, span)); - Expr::rt("hashOne", args) + Expr::rs("hashOne", args) } _ => b.err(span, format!("`RandomState::{name}`, which is not supported yet")), } @@ -2531,9 +2531,9 @@ fn build_hasher_default<'tcx>( unreachable!("hash_one takes a state and a value") }; let value_ty = library::targ(call.args, 1); - let mut args = vec![Expr::rt("hasher", vec![]), value, hash_fn(b, value_ty, hasher, span)]; + let mut args = vec![Expr::rs("hasher", vec![]), value, hash_fn(b, value_ty, hasher, span)]; args.extend(b.t.drop_fn(value_ty, span)); - Expr::rt("hashOne", args) + Expr::rs("hashOne", args) } _ => b.err( span, @@ -2555,20 +2555,20 @@ fn hasher_call(b: &mut Body<'_, '_, '_>, name: &str, args: Vec, span: Span } let swapped = |values: Vec| values.into_iter().rev().collect::>(); let f = match name { - "finish" => return Expr::rt("hashFinish", values), + "finish" => return Expr::rs("hashFinish", values), "write" => "hashWrite", "write_str" => "hashStr", "write_length_prefix" => "hashPrefix", _ if let Some(f) = name.strip_prefix("write_").and_then(hash_int) => f, _ => return b.err(span, format!("`Hasher::{name}`, which is not supported yet")), }; - Expr::rt(f, swapped(values)) + Expr::rs(f, swapped(values)) } -/// The runtime's `Hash::hash` of the integer type `rt` names, which calls its `Hasher` +/// The runtime's `Hash::hash` of the integer type `rs` names, which calls its `Hasher` /// method: `hash16` of a `u16`, `hashI16` of an `i16`. -fn hash_int(rt: &str) -> Option<&'static str> { - Some(match rt { +fn hash_int(rs: &str) -> Option<&'static str> { + Some(match rs { "u8" => "hash8", "u16" => "hash16", "u32" => "hash32", @@ -2718,7 +2718,7 @@ fn cow_deref<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, args: &mut [Expr], n: u } /// The elements of `ty` if it is a `Vec`, a slice, or an array of any type but `u8`, whose -/// bytes are typed arrays: an `rt.Vec` or a JS array, which the runtime reads alike. +/// bytes are typed arrays: an `rs.Vec` or a JS array, which the runtime reads alike. fn elements_of<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { let elem = match ty.kind() { ty::Slice(elem) | ty::Array(elem, _) => *elem, @@ -2729,7 +2729,7 @@ fn elements_of<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option> { } /// Whether `ty` is a `Vec`, a slice, an array, or a `Cow` of bytes: a typed array, an -/// `rt.ByteSlice` behind a reference, or an `rt.ByteVec`, or either of the last two. +/// `rs.ByteSlice` behind a reference, or an `rs.ByteVec`, or either of the last two. fn bytes<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { let elem = match ty.kind() { ty::Slice(elem) | ty::Array(elem, _) => *elem, @@ -2740,7 +2740,7 @@ fn bytes<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { super::byte(elem) } -/// What `bounds` makes of the range a call takes: what an `rt.Bounds` reads, and, for a +/// What `bounds` makes of the range a call takes: what an `rs.Bounds` reads, and, for a /// range that drops, the range and what drops it. pub struct Ranged { pub bounds: Expr, @@ -2756,7 +2756,7 @@ impl Ranged { return e; }; let call = Expr::Lambda(vec![Param { name, ty: None }], Box::new(e)); - Expr::rt("dropAfter", vec![range, call, drop]) + Expr::rs("dropAfter", vec![range, call, drop]) } /// `call` of the bounds and what drops the range, for a call whose result holds the @@ -2777,14 +2777,14 @@ impl Ranged { let Some((range, name, drop)) = self.dropped else { return self.bounds; }; - let checked = Expr::rt("boundsChecked", vec![self.bounds, len]); + let checked = Expr::rs("boundsChecked", vec![self.bounds, len]); let call = Expr::Lambda(vec![Param { name, ty: None }], Box::new(checked)); - Expr::rt("dropAfter", vec![range, call, drop]) + Expr::rs("dropAfter", vec![range, call, drop]) } } -/// Makes `range`, the range `call` takes, what an `rt.Bounds` reads: std's range types -/// and a pair of `Bound`s are already, and any other `RangeBounds` becomes `rt.boundsOf` of +/// Makes `range`, the range `call` takes, what an `rs.Bounds` reads: std's range types +/// and a pair of `Bound`s are already, and any other `RangeBounds` becomes `rs.boundsOf` of /// it and its `start_bound` and `end_bound`, which the runtime calls where std's does. pub fn bounds<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, range: Expr) -> Ranged { let tcx = b.t.tcx; @@ -2806,12 +2806,12 @@ pub fn bounds<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, range: Expr) let args = tcx.mk_args(&[ty.into(), target.into()]); let start = b.fn_value(trait_fn(tcx, "RangeBounds", "start_bound"), args, span); let end = b.fn_value(trait_fn(tcx, "RangeBounds", "end_bound"), args, span); - Expr::rt("boundsOf", vec![range, start, end]) + Expr::rs("boundsOf", vec![range, start, end]) }; Ranged { bounds, dropped } } -/// Whether an `rt.Bounds` reads `ty` as it is: std's range types and a pair of `Bound`s. +/// Whether an `rs.Bounds` reads `ty` as it is: std's range types and a pair of `Bound`s. pub fn plain_bounds<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { match (ty.kind(), t.std_of(ty)) { ( @@ -2882,7 +2882,7 @@ fn cell_by(b: &Body<'_, '_, '_>, by: &str, f: Expr, method: &str) -> Expr { if by == "refCellBy" && b.t.hooked { values.extend(super::caller::cell_sites(b.t.tcx, method)); } - Expr::rt(by, values) + Expr::rs(by, values) } /// `Ord::cmp` of `ty` as a function, or `PartialOrd::partial_cmp` if `partial`: the @@ -2892,54 +2892,54 @@ pub fn cmp_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, partial: bool, spa let tcx = b.t.tcx; let ty = peel_ord(b, ty, partial); match ty.kind() { - ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) => Expr::Rt("cmp".into()), + ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) => Expr::Rs("cmp".into()), // `None` for a NaN: only `PartialOrd`, since a float is no `Ord`. - _ if partial && let Some(float) = super::float::Float::of(ty) => Expr::rt_of(float.name(), "partialCmp"), - ty::Str => Expr::Rt("cmpStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rt("cmpStr".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rt("cmp".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rt("durationCmp".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rt("locationCmp".into()), - _ if library::nothing(tcx, ty) => Expr::Rt("cmpNothing".into()), + _ if partial && let Some(float) = super::float::Float::of(ty) => Expr::rs_of(float.name(), "partialCmp"), + ty::Str => Expr::Rs("cmpStr".into()), + ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("cmpStr".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("cmp".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationCmp".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationCmp".into()), + _ if library::nothing(tcx, ty) => Expr::Rs("cmpNothing".into()), ty::Tuple(tys) => { let fns = tys.iter().map(|t| cmp_fn(b, t, partial, span)).collect(); // What the tuple holds and what it orders as, which `tsc` cannot infer from // fields of which some are generic. - let ordering = Type::Rt("Ordering", vec![]); + let ordering = Type::Rs("Ordering", vec![]); let order = match partial { true => Type::Union(vec![ordering, Type::Builtin("undefined")]), false => ordering, }; - let cmp = Expr::Instantiate(Box::new(Expr::Rt("cmpTuple".into())), vec![b.t.ty(ty, span), order]); + let cmp = Expr::Instantiate(Box::new(Expr::Rs("cmpTuple".into())), vec![b.t.ty(ty, span), order]); Expr::Call(Box::new(cmp), vec![Expr::Array(fns)]) } ty::Adt(..) if let Some(inner) = option_of(b, ty) => { let cmp = cmp_fn(b, inner, partial, span); - Expr::rt("cmpOption", [cmp].into_iter().chain(b.t.none_arg(inner)).collect()) + Expr::rs("cmpOption", [cmp].into_iter().chain(b.t.none_arg(inner)).collect()) } - ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rt("cmpArc", vec![cmp_fn(b, inner, partial, span)]), + ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rs("cmpArc", vec![cmp_fn(b, inner, partial, span)]), ty::Adt(..) if let Some((inner, by)) = cell_of(b, ty) => { let cmp = cmp_fn(b, inner, partial, span); cell_by(b, by, cmp, if partial { "partial_cmp" } else { "cmp" }) } - // An `rt.Place` compares by its value, as std's impl on `&mut` does by what it points at. + // An `rs.Place` compares by its value, as std's impl on `&mut` does by what it points at. ty::Ref(..) if let Some(inner) = b.t.place_pointee(ty) => { - Expr::rt("cellBy", vec![cmp_fn(b, inner, partial, span)]) + Expr::rs("cellBy", vec![cmp_fn(b, inner, partial, span)]) } ty::Adt(..) if let Some(inner) = reverse_of(b, ty) => { - Expr::rt("cmpReverse", vec![cmp_fn(b, inner, partial, span)]) + Expr::rs("cmpReverse", vec![cmp_fn(b, inner, partial, span)]) } ty::Adt(..) if let Some(inner) = overflowing_of(b, ty) => cmp_fn(b, inner, partial, span), ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => { - Expr::rt("cowBy", vec![cmp_fn(b, borrowed, partial, span)]) + Expr::rs("cowBy", vec![cmp_fn(b, borrowed, partial, span)]) } - _ if let Some(elem) = elements_of(b, ty) => Expr::rt("cmpSlice", vec![cmp_fn(b, elem, partial, span)]), + _ if let Some(elem) = elements_of(b, ty) => Expr::rs("cmpSlice", vec![cmp_fn(b, elem, partial, span)]), // A deque's is its iterator's, which compares each item by its own impls, as a slice's does. - ty::Adt(..) if let Some(item) = deque_of(b, ty) => Expr::rt("cmpDeque", vec![cmp_fn(b, item, partial, span)]), + ty::Adt(..) if let Some(item) = deque_of(b, ty) => Expr::rs("cmpDeque", vec![cmp_fn(b, item, partial, span)]), // A list's is its iterator's too. - ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rt("cmpList", vec![cmp_fn(b, item, partial, span)]), + ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rs("cmpList", vec![cmp_fn(b, item, partial, span)]), // Whichever form it has, as the key it is or the operand a reference passes. - _ if bytes(b, ty) => Expr::Rt("cmpBytes".into()), + _ if bytes(b, ty) => Expr::Rs("cmpBytes".into()), // A `Result`'s or a `Poll`'s derived impls lower from its MIR, by variant and then by // what it holds. _ if (by_own(b, ty) || derived_std(b, ty)) && partial => { @@ -2972,40 +2972,40 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr { int.func("eq") } - ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => Expr::Rt("same".into()), - _ if library::nothing(tcx, ty) => Expr::Rt("same".into()), + ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => Expr::Rs("same".into()), + _ if library::nothing(tcx, ty) => Expr::Rs("same".into()), ty::Adt(..) if library::string(tcx, ty) || matches!(b.t.std_of(ty), Some(Std::Ordering | Std::ErrorKind)) => { - Expr::Rt("same".into()) + Expr::Rs("same".into()) } - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rt("durationEq".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rt("locationEq".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::TryReserveError) => Expr::Rt("tryReserveErrorEq".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationEq".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationEq".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::TryReserveError) => Expr::Rs("tryReserveErrorEq".into()), ty::Tuple(tys) => { let fns = tys.iter().map(|t| eq_fn(b, t, span)).collect(); - Expr::rt("eqTuple", vec![Expr::Array(fns)]) + Expr::rs("eqTuple", vec![Expr::Array(fns)]) } _ if let Some(pointee) = raw_pointee(tcx, ty) => match b.t.incomparable(pointee) { Some(why) => b.err(span, why), - None if b.t.pointee(pointee) == super::pointer::Pointee::Bytes => Expr::Rt("byteSliceSame".into()), - None => Expr::Rt("same".into()), + None if b.t.pointee(pointee) == super::pointer::Pointee::Bytes => Expr::Rs("byteSliceSame".into()), + None => Expr::Rs("same".into()), }, ty::Adt(..) if let Some(inner) = option_of(b, ty) => match eq_fn(b, inner, span) { // `None` is no value of `inner`, so `===` tells it from each. - Expr::Rt(same) if same == "same" => Expr::Rt(same), - eq => Expr::rt("eqOption", [eq].into_iter().chain(b.t.none_arg(inner)).collect()), + Expr::Rs(same) if same == "same" => Expr::Rs(same), + eq => Expr::rs("eqOption", [eq].into_iter().chain(b.t.none_arg(inner)).collect()), }, ty::Adt(..) if let Some(inner) = reverse_of(b, ty).or_else(|| overflowing_of(b, ty)) => eq_fn(b, inner, span), - ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => Expr::rt("cowBy", vec![eq_fn(b, borrowed, span)]), - ty::Adt(..) if let Some(bound) = range_of(b, ty) => Expr::rt("rangeEq", vec![eq_fn(b, bound, span)]), + ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => Expr::rs("cowBy", vec![eq_fn(b, borrowed, span)]), + ty::Adt(..) if let Some(bound) = range_of(b, ty) => Expr::rs("rangeEq", vec![eq_fn(b, bound, span)]), // A slice compares its elements by `!=`, as a deque does each of its halves. - _ if let Some(elem) = elements_of(b, ty) => Expr::rt("eqSlice", vec![not_ne_fn(b, elem, span)]), - ty::Adt(..) if let Some(item) = deque_of(b, ty) => Expr::rt("eqSeq", vec![not_ne_fn(b, item, span)]), + _ if let Some(elem) = elements_of(b, ty) => Expr::rs("eqSlice", vec![not_ne_fn(b, elem, span)]), + ty::Adt(..) if let Some(item) = deque_of(b, ty) => Expr::rs("eqSeq", vec![not_ne_fn(b, item, span)]), // A list's iterator compares its items by `==`. - ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rt("eqList", vec![eq_fn(b, item, span)]), + ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rs("eqList", vec![eq_fn(b, item, span)]), // A map compares its values by `==`, and a set holds none. - ty::Adt(..) if b.t.std_of(ty) == Some(Std::HashMap) => Expr::rt("hashEq", vec![eq_fn(b, arg(ty, 1), span)]), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::HashSet) => Expr::rt("hashEq", vec![]), - _ if bytes(b, ty) => Expr::Rt("eqBytes".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::HashMap) => Expr::rs("hashEq", vec![eq_fn(b, arg(ty, 1), span)]), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::HashSet) => Expr::rs("hashEq", vec![]), + _ if bytes(b, ty) => Expr::Rs("eqBytes".into()), ty::Adt(..) if let Some(inner) = arc_of(b, ty) => { let eq = eq_fn(b, inner, span); arc_eq(b, inner, eq) @@ -3015,7 +3015,7 @@ pub fn eq_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr let eq = eq_fn(b, inner, span); cell_by(b, by, eq, "eq") } - ty::Ref(..) if let Some(inner) = b.t.place_pointee(ty) => Expr::rt("cellBy", vec![eq_fn(b, inner, span)]), + ty::Ref(..) if let Some(inner) = b.t.place_pointee(ty) => Expr::rs("cellBy", vec![eq_fn(b, inner, span)]), _ if by_own(b, ty) || derived_std(b, ty) || b.t.std_of(ty).is_some_and(Std::record) => { let eq = trait_fn(tcx, "PartialEq", "eq"); b.fn_value(eq, tcx.mk_args(&[ty.into(), ty.into()]), span) @@ -3034,7 +3034,7 @@ fn not_ne_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr // `!(a.0 != b.0 || ...)`: each field's `!ne` in turn. ty::Tuple(tys) => { let fns = tys.iter().map(|t| not_ne_fn(b, t, span)).collect(); - Expr::rt("eqTuple", vec![Expr::Array(fns)]) + Expr::rs("eqTuple", vec![Expr::Array(fns)]) } ty::Adt(..) if let Some(inner) = arc_of(b, ty) => { let eq = not_ne_fn(b, inner, span); @@ -3052,7 +3052,7 @@ fn arc_eq<'tcx>(b: &Body<'_, '_, 'tcx>, inner: Ty<'tcx>, eq: Expr) -> Expr { if super::iter::implements(b.t, inner, "Eq") { values.push(Expr::lit("true")); } - Expr::rt("eqArc", values) + Expr::rs("eqArc", values) } /// `PartialEq::eq` of sequences of types `t` and `u`, as a function, where the runtime's of @@ -3067,7 +3067,7 @@ fn seq_eq<'tcx>(b: &mut Body<'_, '_, 'tcx>, t: Ty<'tcx>, u: Ty<'tcx>, span: Span if !deque && alike(b, t, u) && std_key(b, t) { return None; } - Some(Expr::rt("eqSeq", vec![item_eq(b, ti, ui, span)])) + Some(Expr::rs("eqSeq", vec![item_eq(b, ti, ui, span)])) } /// What a slice, an array, a `Vec`, or a `VecDeque` of type `ty` holds, bytes included. @@ -3156,7 +3156,7 @@ pub fn impl_eq<'tcx>( /// `>::{name}`, a method of a comparison trait, as a function of what JS holds /// of types `held`, references to `t` and `u` or they themselves: a `[u8; N]` held is a -/// typed array, lent as the `rt.ByteSlice` the impl's `&[u8; N]` is. A `ne` is negated. +/// typed array, lent as the `rs.ByteSlice` the impl's `&[u8; N]` is. A `ne` is negated. fn impl_fn<'tcx>( b: &mut Body<'_, '_, 'tcx>, tr: &str, @@ -3177,7 +3177,7 @@ fn impl_fn<'tcx>( let names = [b.fresh("a"), b.fresh("b")]; let values = std::iter::zip(&names, held) .map(|(name, ty)| match super::byte_array(ty) { - true => Expr::rt("byteSliceFrom", vec![Expr::ident(name)]), + true => Expr::rs("byteSliceFrom", vec![Expr::ident(name)]), false => Expr::ident(name), }) .collect(); @@ -3200,42 +3200,42 @@ fn hash_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, hasher: Ty<'tcx>, spa let ty = peel_hash(b, ty, hasher); match ty.kind() { // What std writes of each: a `bool` as a byte, a `char` as its `u32`. - ty::Bool => Expr::Rt("hash8".into()), - ty::Char => Expr::Rt("hash32".into()), - ty::Int(_) | ty::Uint(_) => Expr::Rt( - hash_int(Int::of(ty).expect("an integer").rt()) + ty::Bool => Expr::Rs("hash8".into()), + ty::Char => Expr::Rs("hash32".into()), + ty::Int(_) | ty::Uint(_) => Expr::Rs( + hash_int(Int::of(ty).expect("an integer").rs()) .expect("an integer") .into(), ), - ty::Str => Expr::Rt("hashStr".into()), - ty::Adt(..) if library::string(tcx, ty) => Expr::Rt("hashStr".into()), + ty::Str => Expr::Rs("hashStr".into()), + ty::Adt(..) if library::string(tcx, ty) => Expr::Rs("hashStr".into()), // Its derived `Hash` writes its `i8` discriminant. - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rt("hashI8".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rt("durationHash".into()), - ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rt("locationHash".into()), - _ if library::nothing(tcx, ty) => Expr::Rt("hashNothing".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Ordering) => Expr::Rs("hashI8".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Duration) => Expr::Rs("durationHash".into()), + ty::Adt(..) if b.t.std_of(ty) == Some(Std::Location) => Expr::Rs("locationHash".into()), + _ if library::nothing(tcx, ty) => Expr::Rs("hashNothing".into()), ty::Tuple(tys) => { let fns = tys.iter().map(|t| hash_fn(b, t, hasher, span)).collect(); - Expr::rt("hashTuple", vec![Expr::Array(fns)]) + Expr::rs("hashTuple", vec![Expr::Array(fns)]) } ty::Adt(..) if let Some(inner) = option_of(b, ty) => { let hash = hash_fn(b, inner, hasher, span); - Expr::rt("hashOption", [hash].into_iter().chain(b.t.none_arg(inner)).collect()) + Expr::rs("hashOption", [hash].into_iter().chain(b.t.none_arg(inner)).collect()) } ty::Adt(..) if b.t.std_of(ty) == Some(Std::Poll) => { let inner = arg(ty, 0); let hash = hash_fn(b, inner, hasher, span); - Expr::rt("hashPoll", [hash].into_iter().chain(b.t.pending_arg(inner)).collect()) + Expr::rs("hashPoll", [hash].into_iter().chain(b.t.pending_arg(inner)).collect()) } - ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rt("hashArc", vec![hash_fn(b, inner, hasher, span)]), + ty::Adt(..) if let Some(inner) = arc_of(b, ty) => Expr::rs("hashArc", vec![hash_fn(b, inner, hasher, span)]), ty::Adt(..) if let Some(inner) = reverse_of(b, ty).or_else(|| overflowing_of(b, ty)) => { hash_fn(b, inner, hasher, span) } ty::Adt(..) if let Some(borrowed) = cow_of(b, ty) => { - Expr::rt("hashCow", vec![hash_fn(b, borrowed, hasher, span)]) + Expr::rs("hashCow", vec![hash_fn(b, borrowed, hasher, span)]) } ty::Adt(..) if let Some(bound) = range_of(b, ty) => { - Expr::rt("rangeHash", vec![hash_fn(b, bound, hasher, span)]) + Expr::rs("rangeHash", vec![hash_fn(b, bound, hasher, span)]) } _ if let Some(elem) = elements_of(b, ty) => { if own_hash_slice(b, elem, hasher) { @@ -3246,22 +3246,22 @@ fn hash_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, hasher: Ty<'tcx>, spa // An integer's `hash_slice` writes the bytes of all of them at once. if let Some(int) = Int::of(elem) { let size = if int.pointer { 4 } else { int.bits / 8 }; - return Expr::rt("hashInts", vec![Expr::lit(size.to_string())]); + return Expr::rs("hashInts", vec![Expr::lit(size.to_string())]); } - Expr::rt("hashSlice", vec![hash_fn(b, elem, hasher, span)]) + Expr::rs("hashSlice", vec![hash_fn(b, elem, hasher, span)]) } // Its length, then each item's, never by `hash_slice`. - ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rt("hashList", vec![hash_fn(b, item, hasher, span)]), + ty::Adt(..) if let Some(item) = list_of(b, ty) => Expr::rs("hashList", vec![hash_fn(b, item, hasher, span)]), // Its length, then its bytes, whichever form it is: a `[u8; N]` hashes as a slice. - _ if bytes(b, ty) => Expr::Rt("hashBytes".into()), + _ if bytes(b, ty) => Expr::Rs("hashBytes".into()), _ if by_own(b, ty) => { let hash = trait_fn(tcx, "Hash", "hash"); let args = tcx.mk_args(&[ty.into(), hasher.into()]); let f = b.fn_value(hash, args, span); // A translated one takes the `&mut` to the crate's own hasher, which the runtime's - // functions wrap; a binding's export takes the `rt.Hasher`. + // functions wrap; a binding's export takes the `rs.Hasher`. match own_hasher(b.t, hasher) && !b.t.binds(hash, args) { - true => Expr::rt("hashOwn", vec![f]), + true => Expr::rs("hashOwn", vec![f]), false => f, } } @@ -3300,7 +3300,7 @@ pub fn clone_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> E } if let ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _) = ty.kind() { b.t.clone_closure(*def_id); - return Expr::Rt("closureClone".into()); + return Expr::Rs("closureClone".into()); } let clone = trait_fn(tcx, "Clone", "clone"); b.fn_value(clone, tcx.mk_args(&[ty.into()]), span) @@ -3324,7 +3324,7 @@ fn trait_fn_of(tcx: ty::TyCtxt<'_>, tr: DefId, item: &str) -> DefId { } /// What `into_iter` makes of a collection of type `ty`, by value or by reference: an -/// `rt.Iter` of its entries, keys, or items, which by value drops those it still holds. +/// `rs.Iter` of its entries, keys, or items, which by value drops those it still holds. pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Option { let coll = ty.peel_refs(); // A `&mut` lends each value JS copies as its place. @@ -3354,10 +3354,10 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp droppers.resize(2, Expr::undefined()); droppers.push(state); } - return Some(Expr::rt(name, super::iter::tail(vec![value], droppers))); + return Some(Expr::rs(name, super::iter::tail(vec![value], droppers))); } // What it holds, borrowed. - let iter = Expr::rt(name, vec![value]); + let iter = Expr::rs(name, vec![value]); Some(match super::iter::iter_of(b.t, ty) { Some(into) => super::lend::lend(b, into, into, iter, span), None => iter, @@ -3388,7 +3388,7 @@ pub fn collect<'tcx>( { let make = Expr::Lambda(Vec::new(), Box::new(target)); let tail = hash_extend_tail(b, ty, from, span); - return Some(Expr::rt("hashFromIter", super::iter::tail(vec![iter, make], tail))); + return Some(Expr::rs("hashFromIter", super::iter::tail(vec![iter, make], tail))); } hash_extend(b, ty, target, iter, from, span) } @@ -3397,7 +3397,7 @@ pub fn collect<'tcx>( Std::BinaryHeap => { let item = arg(ty, 0); let d = super::iter::to_vec(b, iter, from, item, trusted, span); - Expr::rt("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) + Expr::rs("heapFrom", [vec![d], heap_tests(b, item, true, span)].concat()) } Std::LinkedList => { let target = list_new(b, ty, span); @@ -3415,10 +3415,10 @@ pub fn collect<'tcx>( Some("collections::vec_deque::into_iter::IntoIter" | "vec::into_iter::IntoIter") ); let made = match whole { - true => Expr::rt("dequeFromIntoIter", [vec![iter], deque_items(b, item, span)].concat()), + true => Expr::rs("dequeFromIntoIter", [vec![iter], deque_items(b, item, span)].concat()), false => { let items = super::iter::to_vec(b, iter, from, item, trusted, span); - Expr::rt("dequeFromVec", [vec![items], deque_items(b, item, span)].concat()) + Expr::rs("dequeFromVec", [vec![items], deque_items(b, item, span)].concat()) } }; empty(b, made, ty, span) diff --git a/ts/src/lower/consts.rs b/ts/src/lower/consts.rs index 2d2aeaed1..d0e0f35e6 100644 --- a/ts/src/lower/consts.rs +++ b/ts/src/lower/consts.rs @@ -29,7 +29,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { }; match ty.kind() { ty::RawPtr(..) => match leaf(valtree) { - Some(scalar) if scalar.is_null() => Expr::Rt("NULL".into()), + Some(scalar) if scalar.is_null() => Expr::Rs("NULL".into()), _ => self.err(span, format!("a constant of type `{ty}` made from an integer")), }, ty::Bool => Expr::lit((leaf(valtree).is_some_and(|l| l.to_bits_unchecked() != 0)).to_string()), @@ -70,14 +70,14 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { .map(|(t, v)| self.value(t, v, span)) .collect(); match elem.kind() { - _ if super::byte(*elem) => Expr::rt( + _ if super::byte(*elem) => Expr::rs( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(items)], ), _ => Expr::Array(items), } } - _ if super::byte_array(*inner) => Expr::rt("byteSliceFrom", vec![self.value(*inner, valtree, span)]), + _ if super::byte_array(*inner) => Expr::rs("byteSliceFrom", vec![self.value(*inner, valtree, span)]), _ => self.value(*inner, valtree, span), }, ty::Array(elem, _) => { @@ -153,7 +153,7 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { { values.pop(); values.extend(super::library::range_step(tcx, args.type_at(0), true)); - Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) + Expr::New(Box::new(Expr::Rs("RangeInclusive".into())), values) } (Std::Ordering, _) => super::collections::ordering_variant(variant), (Std::AtomicOrdering, _) => super::task::atomic_ordering(variant), @@ -166,14 +166,14 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { } (Std::RangeFrom, _) => { values.extend(super::library::range_step(tcx, args.type_at(0), true)); - Expr::New(Box::new(Expr::Rt("RangeFrom".into())), values) + Expr::New(Box::new(Expr::Rs("RangeFrom".into())), values) } (Std::Range, _) => { values.extend(super::library::range_step(tcx, args.type_at(0), false)); - Expr::New(Box::new(Expr::Rt("Range".into())), values) + Expr::New(Box::new(Expr::Rs("Range".into())), values) } (Std::RangeFull | Std::BuildHasherDefault, _) => Expr::undefined(), - (Std::Pending, _) => Expr::Rt("NEVER".into()), + (Std::Pending, _) => Expr::Rs("NEVER".into()), (Std::ParseIntError, _) => { Expr::Object(vec![(Key::Name("kind".into()), values.pop().unwrap())]) } diff --git a/ts/src/lower/copy.rs b/ts/src/lower/copy.rs index bda1a3165..b88d3d26f 100644 --- a/ts/src/lower/copy.rs +++ b/ts/src/lower/copy.rs @@ -40,7 +40,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Tuple(tys) if !tys.is_empty() => (true, tys.to_vec()), ty::Array(elem, _) => (true, vec![*elem]), ty::Adt(adt, args) => match Std::of(self.tcx, adt.did()) { - // Their payload, or no object at all; a write into an `rt.Result`'s payload + // Their payload, or no object at all; a write into an `rs.Result`'s payload // replaces the result. Some( Std::Option @@ -276,7 +276,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } Some(Std::WakerVTable) => { let fns = ["clone", "wake", "wakeByRef", "drop"].map(|f| v().member(f)); - ret(Expr::rt("wakerVTable", fns.into())) + ret(Expr::rs("wakerVTable", fns.into())) } Some(Std::RawWaker) => ret(super::task::raw_waker(v().member("data"), v().member("vtable"))), Some(Std::ControlFlow) => { @@ -353,13 +353,13 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// A copy of `v`, an `rt.Result` of `ok` or `err`. + /// A copy of `v`, an `rs.Result` of `ok` or `err`. fn copy_result(&mut self, ok: Ty<'tcx>, err: Ty<'tcx>, span: Span) -> Expr { let v = || Expr::ident("v"); Expr::Cond( Box::new(v().member("ok")), - Box::new(Expr::rt("Ok", vec![self.snapshot(v().member("value"), ok, span)])), - Box::new(Expr::rt("Err", vec![self.snapshot(v().member("error"), err, span)])), + Box::new(Expr::rs("Ok", vec![self.snapshot(v().member("value"), ok, span)])), + Box::new(Expr::rs("Err", vec![self.snapshot(v().member("error"), err, span)])), ) } @@ -917,7 +917,7 @@ impl<'tcx> BodyWrites<'_, '_, '_, 'tcx> { /// Whether a `ty` may be kept as a JS object that a pointer to it is: a tuple, an /// array, a struct or union of a crate that translates, or a `MaybeUninit` or - /// `ManuallyDrop` of one; or an `UnsafeCell`'s `rt.Cell`, which the pointer `get` + /// `ManuallyDrop` of one; or an `UnsafeCell`'s `rs.Cell`, which the pointer `get` /// gives is or holds. fn inline(&self, ty: Ty<'tcx>) -> bool { match ty.kind() { diff --git a/ts/src/lower/drop.rs b/ts/src/lower/drop.rs index 04610bcb5..499ddb0b0 100644 --- a/ts/src/lower/drop.rs +++ b/ts/src/lower/drop.rs @@ -105,7 +105,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { // What owns its items, an `IntoIter` or a `Drain`, drops those it still holds. true => args.types().any(|t| self.drops(t)), // A `str` search's holds its pattern inside std's searcher, and a `RepeatN` its - // element inside a struct of its own, which no `rt.Iter` stands for. + // element inside a struct of its own, which no `rs.Iter` stands for. false if super::iter::holds_closure(tcx, adt.did()) || library::std_path(tcx, adt.did()) == ["iter", "sources", "repeat_n", "RepeatN"] => @@ -140,7 +140,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { drops } - /// Whether `ty` is one of std's iterators, or a type they are built of, which an `rt.Iter` + /// Whether `ty` is one of std's iterators, or a type they are built of, which an `rs.Iter` /// stands for: it drops what it owns, of its fields or, with a `Drop` impl, its items. pub(super) fn std_iter(&self, ty: Ty<'tcx>) -> bool { let ty::Adt(adt, _) = ty.kind() else { @@ -196,7 +196,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | Std::Wrapping | Std::Saturating, ) => self.disposable(args.type_at(0), glue), - // An `rt.Iter` drops what it was given to. + // An `rs.Iter` drops what it was given to. None | Some(Std::Peekable) if self.std_iter(ty) => self.closures_held(ty), Some(_) => false, None if self.shared_glue(*adt) => { @@ -220,7 +220,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether every JS value of `ty`, a type that drops and is [`Self::disposable`], is an /// object with `[Symbol.dispose]`, which a drop calls directly rather than through - /// `rt.drop`'s one megamorphic site. An `Option` may be `None`, and a type parameter, a + /// `rs.drop`'s one megamorphic site. An `Option` may be `None`, and a type parameter, a /// trait object, a closure, or a future may be any value. fn always_disposes(&self, ty: Ty<'tcx>) -> bool { let ty::Adt(adt, args) = ty.kind() else { @@ -251,7 +251,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | Std::BytesMut, ) => true, Some(_) => false, - // An `rt.Iter` has one only if it was given what drops. + // An `rs.Iter` has one only if it was given what drops. None if self.std_iter(ty) => false, // The class its glue made. None => adt.is_struct(), @@ -259,7 +259,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// Whether each closure that drops in `ty`, one of std's iterators, is one an adaptor's - /// `rt.Iter` drops, as `iter::holds_closure` says. A box of a closure is the closure. + /// `rs.Iter` drops, as `iter::holds_closure` says. A box of a closure is the closure. fn closures_held(&mut self, ty: Ty<'tcx>) -> bool { let ty::Adt(adt, args) = ty.kind() else { return true; @@ -411,12 +411,12 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if !self.disposable(elem, Some(span)) { args.push(self.drop_fn(elem, span)?); } - return Some(Expr::rt(if vec { "dropVec" } else { "dropAll" }, args)); + return Some(Expr::rs(if vec { "dropVec" } else { "dropAll" }, args)); } if self.disposable(ty, Some(span)) { return Some(match self.always_disposes(ty) { true => value.index(Expr::ident("Symbol").member("dispose")).call(Vec::new()), - false => Expr::rt("drop", vec![value]), + false => Expr::rs("drop", vec![value]), }); } if let ty::Adt(adt, args) = ty.kind() @@ -431,7 +431,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { }; let (name, args) = match std { // Not by a `[Symbol.dispose]`: the `&[u8]` it derefs to is the same object, - // which glue may give `rt.drop`. + // which glue may give `rs.drop`. Std::Bytes => ("bytesDrop", vec![value]), Std::Arc => ("arcDrop", vec![value, each(self, 0)?]), Std::Mutex => return self.drop_value(value.member("value"), args.type_at(0), span), @@ -478,7 +478,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } ("cowDrop", args) } - // Its bounds, in the order std's fields are, `rt.RangeInclusive`'s by its own names. + // Its bounds, in the order std's fields are, `rs.RangeInclusive`'s by its own names. Std::Range | Std::RangeInclusive => { let (lo, hi) = match std { Std::Range => ("start", "end"), @@ -507,7 +507,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { while args.len() > 1 && matches!(args.last(), Some(Expr::Lit(l)) if l == "undefined") { args.pop(); } - return Some(Expr::rt(name, args)); + return Some(Expr::rs(name, args)); } return self.drop_glue_call(args.into_iter().next()?, ty, span); } @@ -533,24 +533,24 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { // A census lowers a generic function over its type parameters, where only an // instance can say what the glue is. if rustc && self.census && (ty.has_param() || ty.has_aliases()) { - return Some(Expr::rt("drop", vec![value])); + return Some(Expr::rs("drop", vec![value])); } self.err(span, format!("dropping `{ty}`, which is not supported yet")); None } /// A function dropping a `ty`, or `None` if JS would see nothing drop or translation - /// refused it: `rt.drop` for a value with `[Symbol.dispose]`, or else its glue. + /// refused it: `rs.drop` for a value with `[Symbol.dispose]`, or else its glue. pub fn drop_fn(&mut self, ty: Ty<'tcx>, span: Span) -> Option { let ty = self.tcx.erase_and_anonymize_regions(ty); if !self.drops(ty) { return None; } if self.disposable(ty, Some(span)) { - return Some(Expr::Rt("drop".into())); + return Some(Expr::Rs("drop".into())); } if self.std_of(ty) == Some(Std::Bytes) { - return Some(Expr::Rt("bytesDrop".into())); + return Some(Expr::Rs("bytesDrop".into())); } // A tuple over type parameters, as a generic class's glue holds, has no glue of // rustc's until an instance: each element in order, as that glue drops them. @@ -609,7 +609,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// The elements of an array, slice, or `Vec` that `ty` is, or holds in an `Option` or a box, - /// whose JS value is the array or `rt.Vec`, as the second says, or `undefined`. + /// whose JS value is the array or `rs.Vec`, as the second says, or `undefined`. fn elements(&self, ty: Ty<'tcx>) -> Option<(Ty<'tcx>, bool)> { match ty.kind() { ty::Array(elem, _) | ty::Slice(elem) => Some((*elem, false)), diff --git a/ts/src/lower/dynamic.rs b/ts/src/lower/dynamic.rs index 4661330b8..73ca4b5c2 100644 --- a/ts/src/lower/dynamic.rs +++ b/ts/src/lower/dynamic.rs @@ -5,9 +5,9 @@ //! trait's type, which a TS caller can implement. A coercion to one wraps the value in a //! class of its type's own, shared by every trait object of the type, whose methods call //! that type's impls and whose `[Symbol.dispose]`, which a `Box` drops it by, -//! drops the value. An `Arc` is an `rt.ArcDyn` around the one a box would be. A +//! drops the value. An `Arc` is an `rs.ArcDyn` around the one a box would be. A //! struct whose last field unsizes to one, such as a `RefCell`, is an -//! `rt.tailDyn` view of the struct it was made from, whose last field is that field's +//! `rs.tailDyn` view of the struct it was made from, whose last field is that field's //! object. A raw pointer unsizes as a `&mut` to what it points at does. A //! `dyn Any` has no methods, and a downcast, of it or of a `dyn Error`, checks for the //! class of the type it names. A `dyn Fn`, @@ -65,9 +65,9 @@ pub struct DynFn<'tcx> { /// How a wrapper class holds the value a pointer to it was unsized from. #[derive(Clone, Copy, PartialEq, Eq, Hash)] pub enum Held { - /// Its value, from `&T` or `Box`: the class is an `rt.Place` of it, as a `v`. + /// Its value, from `&T` or `Box`: the class is an `rs.Place` of it, as a `v`. Value, - /// The `rt.Place` a `&mut T` to a value JS copies is. + /// The `rs.Place` a `&mut T` to a value JS copies is. Place, } @@ -254,8 +254,8 @@ impl<'tcx> Translator<'_, 'tcx> { /// Whether `instance` is a call through a trait object's method, whose wrapper takes /// its arguments as the crate's functions do. A `&dyn Debug` or `&dyn Display` is a - /// function writing its value instead, a `dyn Future` an `rt.Future`, and a - /// `dyn Iterator` an `rt.Iter`. + /// function writing its value instead, a `dyn Future` an `rs.Future`, and a + /// `dyn Iterator` an `rs.Iter`. pub fn dispatches(&self, instance: Instance<'tcx>) -> bool { let ty::InstanceKind::Virtual(..) = instance.def else { return false; @@ -404,7 +404,7 @@ impl<'tcx> Translator<'_, 'tcx> { let ty = self.ty(from, span); let field_ty = match held { Held::Value => ty, - Held::Place => Type::Rt("Place", vec![ty]), + Held::Place => Type::Rs("Place", vec![ty]), }; self.program.items.push(Item::Struct { sym, @@ -603,7 +603,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { let view = self.tail_object(value, pointee, object, from.is_box(), span); return view.unwrap_or_else(|| unsupported(self)); } - // A box holds one as a `Uint8Array` and a reference as an `rt.ByteSlice`, which one + // A box holds one as a `Uint8Array` and a reference as an `rs.ByteSlice`, which one // class's methods can't both take. if super::byte_array(pointee) { return self.err( @@ -626,7 +626,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { .into_iter() .chain(self.t.drop_fn(pointee, span)) .collect(); - Expr::rt("fmtOwned", args) + Expr::rs("fmtOwned", args) } }; } @@ -671,7 +671,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { /// `p`, a `from` raw pointer, unsized to `to`, unless it is null or dangling, which stays /// itself: what a box of the object it points at unsizes to, which drops it as the box /// `Box::from_raw` makes of it does, or else what a `&mut` to its place unsizes to. One - /// that is the `rt.Place` of a library value, such as a cell, unsizes to the place of + /// that is the `rs.Place` of a library value, such as a cell, unsizes to the place of /// what a box of the value there unsizes to as each read finds it, since it may be /// uninitialized or replaced until then. pub fn raw_object(&mut self, p: Expr, from: Ty<'tcx>, to: Ty<'tcx>, span: Span) -> Expr { @@ -709,13 +709,13 @@ impl<'tcx> Body<'_, '_, 'tcx> { } }; match read { - true => Expr::rt("rawUnsizePlace", vec![p, make]), - false => Expr::rt("rawUnsize", vec![p, make]), + true => Expr::rs("rawUnsizePlace", vec![p, make]), + false => Expr::rs("rawUnsize", vec![p, make]), } } /// `value`, a `from`, a struct whose last field unsizes, as the struct `to` of the trait - /// object: an `rt.tailDyn` view of it, whose last field is the object a `&mut` to that + /// object: an `rs.tailDyn` view of it, whose last field is the object a `&mut` to that /// field would unsize to, made wherever it is read, so it reads and changes the field in /// place, and whose other fields, a cell's borrows, and a mutex's lock are `value`'s own. /// A box of it drops as one of `value` does. `None` if the struct is none it can view. @@ -730,13 +730,13 @@ impl<'tcx> Body<'_, '_, 'tcx> { let name = self.fresh("value"); let v = Expr::ident(&name); let (key, read, lent, held) = match Std::of(tcx, adt.did()) { - // `rt.RefCell` holds a `RefCell` or an `RwLock`. + // `rs.RefCell` holds a `RefCell` or an `RwLock`. Some(Std::RefCell | Std::Mutex) => { let held = (from_args.type_at(0), to_args.type_at(0)); - let place = Expr::rt("valuePlace", vec![v.clone()]); + let place = Expr::rs("valuePlace", vec![v.clone()]); (Key::Name("value".into()), v.clone().member("value"), place, held) } - // `rt.Cell`, a `Cell`'s or an `UnsafeCell`'s, is the place of what it holds. + // `rs.Cell`, a `Cell`'s or an `UnsafeCell`'s, is the place of what it holds. Some(Std::Cell) => { let held = (from_args.type_at(0), to_args.type_at(0)); (Key::Name("v".into()), v.clone().member("v"), v.clone(), held) @@ -766,7 +766,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { }], Box::new(at.assign(Expr::ident(value))), ); - let place = Expr::rt("place", vec![Expr::Lambda(Vec::new(), Box::new(read.clone())), set]); + let place = Expr::rs("place", vec![Expr::Lambda(Vec::new(), Box::new(read.clone())), set]); (Key::Field(id), read, place, held) } _ => return None, @@ -803,14 +803,14 @@ impl<'tcx> Body<'_, '_, 'tcx> { .into_iter() .chain(owned.then(|| self.t.drop_fn(from, span)).flatten()) .collect(); - Some(Expr::rt("tailDyn", args)) + Some(Expr::rs("tailDyn", args)) } /// `value`, a `from` pointing at a function, as a `dyn Fn*` of `kind`: the function /// itself, through the references and boxes it is behind. A box owning one that an - /// `FnOnce` call consumes but that `Fn` or `FnMut` calls is `rt.once` of it, which drops + /// `FnOnce` call consumes but that `Fn` or `FnMut` calls is `rs.once` of it, which drops /// it after the call, as rustc's shim does, where an `FnOnce` closure's body drops what - /// it owns; a box of a reference to one that drops is `rt.lent` of it, which never does. + /// it owns; a box of a reference to one that drops is `rs.lent` of it, which never does. fn fn_object(&mut self, mut value: Expr, from: Ty<'tcx>, kind: ty::ClosureKind) -> Expr { let tcx = self.t.tcx; let (mut ty, mut owned) = (from, from.is_box()); @@ -832,11 +832,11 @@ impl<'tcx> Body<'_, '_, 'tcx> { return value; } match owned { - false => Expr::rt("lent", vec![value]), + false => Expr::rs("lent", vec![value]), true if kind == ty::ClosureKind::FnOnce && self.t.owned_fn(from).is_some_and(|c| c != ty::ClosureKind::FnOnce) => { - Expr::rt("once", vec![value]) + Expr::rs("once", vec![value]) } true => value, } @@ -917,7 +917,7 @@ pub fn call<'tcx>( ty: None, }; let held = Expr::Lambda(vec![held], Box::new(Expr::ident("object").field(value.v))); - Expr::rt("arcDowncast", vec![o, Expr::Sym(value.sym), held]) + Expr::rs("arcDowncast", vec![o, Expr::Sym(value.sym), held]) } }; Ok(Some(e)) diff --git a/ts/src/lower/float.rs b/ts/src/lower/float.rs index 3ec36d906..e3b812ec7 100644 --- a/ts/src/lower/float.rs +++ b/ts/src/lower/float.rs @@ -32,7 +32,7 @@ impl Float { } } - /// The Rust name, which also prefixes the type's runtime functions: `rt.f32Round`. + /// The Rust name, which also prefixes the type's runtime functions: `rs.f32Round`. pub fn name(self) -> &'static str { match self { Self::F32 => "f32", @@ -42,7 +42,7 @@ impl Float { /// The TypeScript type of a value. pub fn ty(self) -> Type { - Type::Rt(self.name(), Vec::new()) + Type::Rs(self.name(), Vec::new()) } /// `e`, a number JS computed exactly or as a double, rounded to this type. @@ -71,7 +71,7 @@ impl Float { /// The type's runtime function `name`, uncalled. fn func(self, name: &str) -> Expr { - Expr::rt_of(self.name(), name) + Expr::rs_of(self.name(), name) } } @@ -90,7 +90,7 @@ pub fn lit(v: f64) -> Expr { signed: false, pointer: false, }; - Expr::rt("f64FromBits", vec![u64.lit(i128::from(v.to_bits()))]) + Expr::rs("f64FromBits", vec![u64.lit(i128::from(v.to_bits()))]) } _ if v.is_nan() => Expr::lit("NaN"), f64::INFINITY => Expr::lit("Infinity"), @@ -108,7 +108,7 @@ fn lit32(v: f32) -> Expr { signed: false, pointer: false, }; - Expr::rt("f32FromBits", vec![u32.lit(i128::from(v.to_bits()))]) + Expr::rs("f32FromBits", vec![u32.lit(i128::from(v.to_bits()))]) } _ => lit(f64::from(v)), } @@ -179,7 +179,7 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Operand, from: Ty<'tcx>, to /// A call of the float type's own `name`, or `None` if it is not mapped. pub fn method(float: Float, name: &str, args: Vec) -> Option { let math = |f: &str, args: Vec| float.round(Expr::ident("Math").member(f).call(args)); - let rt = |f: &str, args: Vec| float.func(f).call(args); + let rs = |f: &str, args: Vec| float.func(f).call(args); let one = |args: Vec| <[Expr; 1]>::try_from(args).ok().map(|[x]| x); Some(match name { // Exact in JS as in std. @@ -220,11 +220,11 @@ pub fn method(float: Float, name: &str, args: Vec) -> Option { | "is_subnormal" | "is_sign_positive" | "is_sign_negative" | "next_up" | "next_down" | "max" | "min" | "midpoint" | "to_bits" | "from_bits" | "to_be_bytes" | "to_le_bytes" | "from_be_bytes" | "from_le_bytes" | "total_cmp" | "powi" | "powf" | "sin_cos" | "atanh" | "div_euclid" | "rem_euclid" | "clamp" | "mul_add" => { - rt(&super::camel(name), args) + rs(&super::camel(name), args) } // wasm32 is little-endian. - "to_ne_bytes" => rt("toLeBytes", args), - "from_ne_bytes" => rt("fromLeBytes", args), + "to_ne_bytes" => rs("toLeBytes", args), + "from_ne_bytes" => rs("fromLeBytes", args), _ => return None, }) } diff --git a/ts/src/lower/fmt.rs b/ts/src/lower/fmt.rs index a97812c07..f6445db52 100644 --- a/ts/src/lower/fmt.rs +++ b/ts/src/lower/fmt.rs @@ -98,7 +98,7 @@ pub fn argument(name: &str) -> Result, &'static str> { /// A formatter's type, for the parameters of the functions written here. fn formatter() -> Type { - Type::Rt("Formatter", Vec::new()) + Type::Rs("Formatter", Vec::new()) } impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { @@ -181,13 +181,13 @@ impl<'b, 'a, 'tcx> Body<'b, 'a, 'tcx> { /// `f.debug_struct(name).finish_non_exhaustive()`: the name and ` { .. }`, each a `write_str`. fn non_exhaustive(f: Expr, name: &str) -> Expr { - let builder = Expr::rt("fmtDebugStruct", vec![f, Expr::Str(name.into())]); - Expr::rt("debugStructFinishNonExhaustive", vec![builder]) + let builder = Expr::rs("fmtDebugStruct", vec![f, Expr::Str(name.into())]); + Expr::rs("debugStructFinishNonExhaustive", vec![builder]) } /// Whether `e` is a runtime function, which reads no `this`. fn runtime(e: &Expr) -> bool { - matches!(e, Expr::Rt(_)) + matches!(e, Expr::Rs(_)) } /// Whether the path `e` reads the variable `name`. @@ -221,7 +221,7 @@ pub fn std_impl<'tcx>( out: &mut Vec, ) -> Option { let tcx = b.t.tcx; - let rt = |name: &str, args: Vec| Expr::rt_of("fmt", name).call(args); + let rs = |name: &str, args: Vec| Expr::rs_of("fmt", name).call(args); let text = matches!(tr, Trait::Display | Trait::Debug); Some(match ty.kind() { // A reference to an array of bytes is a slice of them, written as a slice is. @@ -253,16 +253,16 @@ pub fn std_impl<'tcx>( Trait::UpperExp => "upperExp", _ => return None, }; - Expr::rt_of(float.name(), method).call(vec![value, f]) + Expr::rs_of(float.name(), method).call(vec![value, f]) } // `!`, and `Infallible`, which is it: never written, as none exists. - ty::Never if text => Expr::rt("unreachable", vec![value]), - ty::Bool if text => rt("bool", vec![value, f]), - ty::Char if tr == Trait::Display => rt("charDisplay", vec![value, f]), - ty::Char if tr == Trait::Debug => rt("charDebug", vec![value, f]), - ty::Str if tr == Trait::Display => Expr::rt("fmtPad", vec![f, value]), - ty::Str if tr == Trait::Debug => rt("str", vec![value, f]), - ty::Tuple(tys) if tys.is_empty() && tr == Trait::Debug => rt("unit", vec![value, f]), + ty::Never if text => Expr::rs("unreachable", vec![value]), + ty::Bool if text => rs("bool", vec![value, f]), + ty::Char if tr == Trait::Display => rs("charDisplay", vec![value, f]), + ty::Char if tr == Trait::Debug => rs("charDebug", vec![value, f]), + ty::Str if tr == Trait::Display => Expr::rs("fmtPad", vec![f, value]), + ty::Str if tr == Trait::Debug => rs("str", vec![value, f]), + ty::Tuple(tys) if tys.is_empty() && tr == Trait::Debug => rs("unit", vec![value, f]), ty::Tuple(tys) if tr == Trait::Debug => { // Each element's function reads the tuple. let value = match pure(&value) { @@ -274,11 +274,11 @@ pub fn std_impl<'tcx>( .enumerate() .map(|(i, t)| b.thunk(tr, t, value.clone().index(Expr::lit(i.to_string())), span)) .collect(); - rt("tuple", vec![Expr::Array(fields), f]) + rs("tuple", vec![Expr::Array(fields), f]) } ty::Array(elem, _) | ty::Slice(elem) if tr == Trait::Debug => { let item = b.fmt_fn(tr, *elem, span); - rt("list", vec![library::elements(value, ty), f, item]) + rs("list", vec![library::elements(value, ty), f, item]) } // A `&dyn Debug` is already a function writing its value. ty::Dynamic(preds, ..) if preds.principal_def_id().and_then(|did| Trait::of(tcx, did)) == Some(tr) => { @@ -290,7 +290,7 @@ pub fn std_impl<'tcx>( ty::Adt(adt, args) if tr == Trait::Debug && adt.is_phantom_data() => { let name = rustc_const_eval::util::type_name(tcx, args.type_at(0)); let pieces = ["PhantomData<", &name, ">"].map(|s| Expr::Str(s.to_string())); - rt("writeFmt", vec![f, Expr::Array(pieces.into())]) + rs("writeFmt", vec![f, Expr::Array(pieces.into())]) } // Each its name alone, unpadded. ty::Adt(adt, _) @@ -302,7 +302,7 @@ pub fn std_impl<'tcx>( Some(Std::Pending | Std::PollFn | Std::BuildHasherDefault) )) => { - rt("writeStr", vec![f, Expr::Str(tcx.item_name(adt.did()).to_string())]) + rs("writeStr", vec![f, Expr::Str(tcx.item_name(adt.did()).to_string())]) } // An ASCII escape writes what it has left, unpadded, and `Debug` only its name. ty::Adt(adt, _) @@ -316,7 +316,7 @@ pub fn std_impl<'tcx>( ) => { match tr { - Trait::Display => Expr::rt("fmtEscapeAscii", vec![value, f]), + Trait::Display => Expr::rs("fmtEscapeAscii", vec![value, f]), Trait::Debug => non_exhaustive(f, tcx.item_name(adt.did()).as_str()), _ => return None, } @@ -337,10 +337,10 @@ pub fn std_impl<'tcx>( ) => { match tr { - Trait::Display => Expr::rt("fmtCharsDisplay", vec![value, f]), + Trait::Display => Expr::rs("fmtCharsDisplay", vec![value, f]), Trait::Debug => { let name = Expr::Str(tcx.item_name(adt.did()).to_string()); - Expr::rt("fmtCharsDebug", vec![value, f, name]) + Expr::rs("fmtCharsDebug", vec![value, f, name]) } _ => return None, } @@ -357,7 +357,7 @@ pub fn std_impl<'tcx>( ["str", "iter", "EscapeUnicode" | "EscapeDebug" | "EscapeDefault"] ) => { - Expr::rt("fmtStrEscapeDisplay", vec![value, f]) + Expr::rs("fmtStrEscapeDisplay", vec![value, f]) } ty::Adt(adt, args) if tr == Trait::Debug @@ -372,8 +372,8 @@ pub fn std_impl<'tcx>( e } ty::Adt(adt, args) => match (Std::of(tcx, adt.did())?, tr) { - (Std::String, Trait::Display) => Expr::rt("fmtPad", vec![f, value]), - (Std::String, Trait::Debug) => rt("str", vec![value, f]), + (Std::String, Trait::Display) => Expr::rs("fmtPad", vec![f, value]), + (Std::String, Trait::Debug) => rs("str", vec![value, f]), // A `NonZero`, a `Wrapping`, and a `Saturating` write their integer, by each trait. (Std::Box | Std::NonZero | Std::Wrapping | Std::Saturating, _) => { b.fmt_call(tr, args.type_at(0), value, f, span) @@ -403,29 +403,29 @@ pub fn std_impl<'tcx>( Std::RangeTo => "rangeTo", _ => "rangeToInclusive", }; - rt(of, vec![value, f, bound]) + rs(of, vec![value, f, bound]) } - (Std::RangeFull, Trait::Debug) => rt("rangeFull", vec![value, f]), + (Std::RangeFull, Trait::Debug) => rs("rangeFull", vec![value, f]), (Std::Bound, Trait::Debug) => { let held = b.fmt_fn(tr, args.type_at(0), span); - rt("bound", vec![value, f, held]) + rs("bound", vec![value, f, held]) } - (Std::Ordering, Trait::Debug) => rt("ordering", vec![value, f]), + (Std::Ordering, Trait::Debug) => rs("ordering", vec![value, f]), // Erased to what it holds. (std @ (Std::Reverse | Std::AssertUnwindSafe), Trait::Debug) => { let held = b.fmt_value(tr, args.type_at(0), value, span, out); let name = format!("{std:?}"); - rt("debugTupleFields", vec![f, Expr::Str(name), Expr::Array(vec![held])]) + rs("debugTupleFields", vec![f, Expr::Str(name), Expr::Array(vec![held])]) } (Std::ControlFlow, Trait::Debug) => { let go = b.fmt_fn(tr, args.type_at(1), span); let stop = b.fmt_fn(tr, args.type_at(0), span); match library::Flow::of(tcx, args) { - library::Flow::Other => rt("controlFlow", vec![value, f, go, stop]), - library::Flow::Result => rt("controlFlow", vec![value, f, go, stop, Expr::lit("true")]), + library::Flow::Other => rs("controlFlow", vec![value, f, go, stop]), + library::Flow::Result => rs("controlFlow", vec![value, f, go, stop, Expr::lit("true")]), library::Flow::Option => { let none = b.t.none_arg(args.type_at(1)); - rt( + rs( "controlFlowOption", [vec![value, f, go, stop], none.into_iter().collect()].concat(), ) @@ -434,51 +434,51 @@ pub fn std_impl<'tcx>( } (Std::Vec, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("list", vec![library::elements(value, ty), f, item]) + rs("list", vec![library::elements(value, ty), f, item]) } (Std::BinaryHeap, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("list", vec![value.member("items"), f, item]) + rs("list", vec![value.member("items"), f, item]) } // Each writes its items as its iterator reads them: a deque from its head. (Std::VecDeque, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("list", vec![Expr::rt("dequeIter", vec![value]), f, item]) + rs("list", vec![Expr::rs("dequeIter", vec![value]), f, item]) } (Std::LinkedList, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("list", vec![Expr::rt("listIter", vec![value]), f, item]) + rs("list", vec![Expr::rs("listIter", vec![value]), f, item]) } // Its items, as a set. (Std::HashTable, Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); - rt("set", vec![Expr::rt("hashValues", vec![value]), f, item]) + rs("set", vec![Expr::rs("hashValues", vec![value]), f, item]) } (std @ (Std::HashSet | Std::BTreeSet), Trait::Debug) => { let item = b.fmt_fn(tr, args.type_at(0), span); let keys = if std == Std::HashSet { "hashKeys" } else { "btreeKeys" }; - rt("set", vec![Expr::rt(keys, vec![value]), f, item]) + rs("set", vec![Expr::rs(keys, vec![value]), f, item]) } (std @ (Std::HashMap | Std::BTreeMap), Trait::Debug) => { let key = b.fmt_fn(tr, args.type_at(0), span); let val = b.fmt_fn(tr, args.type_at(1), span); let entries = if std == Std::HashMap { "hashIter" } else { "btreeIter" }; - rt("map", vec![Expr::rt(entries, vec![value]), f, key, val]) + rs("map", vec![Expr::rs(entries, vec![value]), f, key, val]) } (Std::Option, Trait::Debug) => { let some = b.fmt_fn(tr, args.type_at(0), span); let none = b.t.none_arg(args.type_at(0)); - rt("option", [vec![value, f, some], none.into_iter().collect()].concat()) + rs("option", [vec![value, f, some], none.into_iter().collect()].concat()) } (Std::Result, Trait::Debug) => { let ok = b.fmt_fn(tr, args.type_at(0), span); let err = b.fmt_fn(tr, args.type_at(1), span); - rt("result", vec![value, f, ok, err]) + rs("result", vec![value, f, ok, err]) } (Std::Poll, Trait::Debug) => { let ready = b.fmt_fn(tr, args.type_at(0), span); let pending = b.t.pending_arg(args.type_at(0)); - rt("poll", [vec![value, f, ready], pending.into_iter().collect()].concat()) + rs("poll", [vec![value, f, ready], pending.into_iter().collect()].concat()) } (Std::Waker | Std::Context | Std::WakerVTable | Std::RawWaker, Trait::Debug) => b.err( span, @@ -489,28 +489,28 @@ pub fn std_impl<'tcx>( let held = b.fmt_fn(tr, args.type_at(0), span); value.member("debug").call(vec![f, held]) } - (Std::Arguments, Trait::Display | Trait::Debug) => rt("arguments", vec![value, f]), - (Std::FmtError, Trait::Debug) => rt("errorDebug", vec![value, f]), - (Std::PoisonError, Trait::Debug) => rt("poisonErrorDebug", vec![value, f]), - (Std::PoisonError, Trait::Display) => rt("poisonErrorDisplay", vec![value, f]), - (Std::FmtError, Trait::Display) => rt("errorDisplay", vec![value, f]), - (Std::TryFromIntError, Trait::Debug) => rt("tryFromIntErrorDebug", vec![value, f]), - (Std::TryFromIntError, Trait::Display) => rt("tryFromIntErrorDisplay", vec![value, f]), - (Std::ParseIntError, Trait::Debug) => rt("parseIntErrorDebug", vec![value, f]), - (Std::ParseIntError, Trait::Display) => rt("parseIntErrorDisplay", vec![value, f]), - (Std::ErrorKind, Trait::Debug) => rt("writeStr", vec![f, value]), - (Std::CharTryFromError, Trait::Debug) => rt("charTryFromErrorDebug", vec![value, f]), - (Std::CharTryFromError, Trait::Display) => rt("charTryFromErrorDisplay", vec![value, f]), - (Std::TryFromCharError, Trait::Debug) => rt("tryFromCharErrorDebug", vec![value, f]), - (Std::TryFromCharError, Trait::Display) => rt("tryFromCharErrorDisplay", vec![value, f]), - (Std::DecodeUtf16Error, Trait::Debug) => rt("decodeUtf16ErrorDebug", vec![value, f]), - (Std::DecodeUtf16Error, Trait::Display) => rt("decodeUtf16ErrorDisplay", vec![value, f]), - (Std::ParseBoolError, Trait::Debug) => rt("parseBoolErrorDebug", vec![value, f]), - (Std::ParseBoolError, Trait::Display) => rt("parseBoolErrorDisplay", vec![value, f]), - (Std::BorrowError, Trait::Debug) => Expr::rt("borrowErrorDebug", vec![value, f]), - (Std::BorrowError, Trait::Display) => Expr::rt("borrowErrorDisplay", vec![value, f]), - (Std::BorrowMutError, Trait::Debug) => Expr::rt("borrowMutErrorDebug", vec![value, f]), - (Std::BorrowMutError, Trait::Display) => Expr::rt("borrowMutErrorDisplay", vec![value, f]), + (Std::Arguments, Trait::Display | Trait::Debug) => rs("arguments", vec![value, f]), + (Std::FmtError, Trait::Debug) => rs("errorDebug", vec![value, f]), + (Std::PoisonError, Trait::Debug) => rs("poisonErrorDebug", vec![value, f]), + (Std::PoisonError, Trait::Display) => rs("poisonErrorDisplay", vec![value, f]), + (Std::FmtError, Trait::Display) => rs("errorDisplay", vec![value, f]), + (Std::TryFromIntError, Trait::Debug) => rs("tryFromIntErrorDebug", vec![value, f]), + (Std::TryFromIntError, Trait::Display) => rs("tryFromIntErrorDisplay", vec![value, f]), + (Std::ParseIntError, Trait::Debug) => rs("parseIntErrorDebug", vec![value, f]), + (Std::ParseIntError, Trait::Display) => rs("parseIntErrorDisplay", vec![value, f]), + (Std::ErrorKind, Trait::Debug) => rs("writeStr", vec![f, value]), + (Std::CharTryFromError, Trait::Debug) => rs("charTryFromErrorDebug", vec![value, f]), + (Std::CharTryFromError, Trait::Display) => rs("charTryFromErrorDisplay", vec![value, f]), + (Std::TryFromCharError, Trait::Debug) => rs("tryFromCharErrorDebug", vec![value, f]), + (Std::TryFromCharError, Trait::Display) => rs("tryFromCharErrorDisplay", vec![value, f]), + (Std::DecodeUtf16Error, Trait::Debug) => rs("decodeUtf16ErrorDebug", vec![value, f]), + (Std::DecodeUtf16Error, Trait::Display) => rs("decodeUtf16ErrorDisplay", vec![value, f]), + (Std::ParseBoolError, Trait::Debug) => rs("parseBoolErrorDebug", vec![value, f]), + (Std::ParseBoolError, Trait::Display) => rs("parseBoolErrorDisplay", vec![value, f]), + (Std::BorrowError, Trait::Debug) => Expr::rs("borrowErrorDebug", vec![value, f]), + (Std::BorrowError, Trait::Display) => Expr::rs("borrowErrorDisplay", vec![value, f]), + (Std::BorrowMutError, Trait::Debug) => Expr::rs("borrowMutErrorDebug", vec![value, f]), + (Std::BorrowMutError, Trait::Display) => Expr::rs("borrowMutErrorDisplay", vec![value, f]), // What each holds, held as a guard would while it is written, or what keeps it from // being read. An `RwLock` shares a `RefCell`'s representation, and an `UnsafeCell` a // `Cell`'s. @@ -521,7 +521,7 @@ pub fn std_impl<'tcx>( (Std::Cell, Trait::Debug) => { let held = b.fmt_fn(tr, args.type_at(0), span); let value = b.t.copied(value.member("v"), args.type_at(0), span); - Expr::rt("cellDebug", vec![Expr::Lambda(Vec::new(), Box::new(value)), f, held]) + Expr::rs("cellDebug", vec![Expr::Lambda(Vec::new(), Box::new(value)), f, held]) } (std @ (Std::RefCell | Std::Mutex), Trait::Debug) => { let debug = match std { @@ -530,14 +530,14 @@ pub fn std_impl<'tcx>( _ => "mutexDebug", }; let held = b.fmt_fn(tr, args.type_at(0), span); - Expr::rt(debug, vec![value, f, held]) + Expr::rs(debug, vec![value, f, held]) } // What it holds, or ``. (std @ (Std::OnceCell | Std::OnceLock), Trait::Debug) => { let held = b.fmt_fn(tr, args.type_at(0), span); let none = b.t.none_arg(args.type_at(0)); let name = Expr::Str(format!("{std:?}")); - Expr::rt( + Expr::rs( "onceDebug", [vec![value, f, name, held], none.into_iter().collect()].concat(), ) @@ -547,30 +547,30 @@ pub fn std_impl<'tcx>( let held = b.fmt_fn(tr, args.type_at(0), span); value.member("debug").call(vec![f, Expr::Str(format!("{std:?}")), held]) } - (Std::ParseCharError, Trait::Debug) => rt("parseCharErrorDebug", vec![value, f]), - (Std::ParseCharError, Trait::Display) => rt("parseCharErrorDisplay", vec![value, f]), - (Std::ParseFloatError, Trait::Debug) => rt("parseFloatErrorDebug", vec![value, f]), - (Std::ParseFloatError, Trait::Display) => rt("parseFloatErrorDisplay", vec![value, f]), - (Std::TryFromFloatSecsError, Trait::Debug) => rt("tryFromFloatSecsErrorDebug", vec![value, f]), - (Std::TryFromFloatSecsError, Trait::Display) => rt("tryFromFloatSecsErrorDisplay", vec![value, f]), - (Std::FromUtf8Error, Trait::Debug) => rt("fromUtf8ErrorDebug", vec![value, f]), - (Std::FromUtf8Error, Trait::Display) => rt("fromUtf8ErrorDisplay", vec![value, f]), - (Std::FromUtf16Error, Trait::Debug) => rt("fromUtf16ErrorDebug", vec![value, f]), - (Std::FromUtf16Error, Trait::Display) => rt("fromUtf16ErrorDisplay", vec![value, f]), - (Std::Utf8Error, Trait::Debug) => rt("utf8ErrorDebug", vec![value, f]), - (Std::Utf8Error, Trait::Display) => rt("utf8ErrorDisplay", vec![value, f]), - (Std::Utf8Chunk, Trait::Debug) => rt("utf8ChunkDebug", vec![value, f]), - (Std::Duration, Trait::Debug) => Expr::rt("durationDebug", vec![value, f]), - (Std::Layout, Trait::Debug) => rt("layoutDebug", vec![value, f]), - (Std::Location, Trait::Debug) => rt("locationDebug", vec![value, f]), - (Std::Location, Trait::Display) => rt("locationDisplay", vec![value, f]), - (Std::PanicHookInfo, Trait::Display) => rt("panicHookInfoDisplay", vec![value, f]), - (Std::LayoutError, Trait::Debug) => rt("layoutErrorDebug", vec![value, f]), - (Std::LayoutError, Trait::Display) => rt("layoutErrorDisplay", vec![value, f]), - (Std::TryReserveError, Trait::Debug) => rt("tryReserveErrorDebug", vec![value, f]), - (Std::TryReserveError, Trait::Display) => rt("tryReserveErrorDisplay", vec![value, f]), - (Std::Bytes, Trait::Debug) => Expr::rt("bytesDebug", vec![value, f]), - (Std::BytesMut, Trait::Debug) => Expr::rt("bytesDebug", vec![Expr::rt("bytesMutView", vec![value]), f]), + (Std::ParseCharError, Trait::Debug) => rs("parseCharErrorDebug", vec![value, f]), + (Std::ParseCharError, Trait::Display) => rs("parseCharErrorDisplay", vec![value, f]), + (Std::ParseFloatError, Trait::Debug) => rs("parseFloatErrorDebug", vec![value, f]), + (Std::ParseFloatError, Trait::Display) => rs("parseFloatErrorDisplay", vec![value, f]), + (Std::TryFromFloatSecsError, Trait::Debug) => rs("tryFromFloatSecsErrorDebug", vec![value, f]), + (Std::TryFromFloatSecsError, Trait::Display) => rs("tryFromFloatSecsErrorDisplay", vec![value, f]), + (Std::FromUtf8Error, Trait::Debug) => rs("fromUtf8ErrorDebug", vec![value, f]), + (Std::FromUtf8Error, Trait::Display) => rs("fromUtf8ErrorDisplay", vec![value, f]), + (Std::FromUtf16Error, Trait::Debug) => rs("fromUtf16ErrorDebug", vec![value, f]), + (Std::FromUtf16Error, Trait::Display) => rs("fromUtf16ErrorDisplay", vec![value, f]), + (Std::Utf8Error, Trait::Debug) => rs("utf8ErrorDebug", vec![value, f]), + (Std::Utf8Error, Trait::Display) => rs("utf8ErrorDisplay", vec![value, f]), + (Std::Utf8Chunk, Trait::Debug) => rs("utf8ChunkDebug", vec![value, f]), + (Std::Duration, Trait::Debug) => Expr::rs("durationDebug", vec![value, f]), + (Std::Layout, Trait::Debug) => rs("layoutDebug", vec![value, f]), + (Std::Location, Trait::Debug) => rs("locationDebug", vec![value, f]), + (Std::Location, Trait::Display) => rs("locationDisplay", vec![value, f]), + (Std::PanicHookInfo, Trait::Display) => rs("panicHookInfoDisplay", vec![value, f]), + (Std::LayoutError, Trait::Debug) => rs("layoutErrorDebug", vec![value, f]), + (Std::LayoutError, Trait::Display) => rs("layoutErrorDisplay", vec![value, f]), + (Std::TryReserveError, Trait::Debug) => rs("tryReserveErrorDebug", vec![value, f]), + (Std::TryReserveError, Trait::Display) => rs("tryReserveErrorDisplay", vec![value, f]), + (Std::Bytes, Trait::Debug) => Expr::rs("bytesDebug", vec![value, f]), + (Std::BytesMut, Trait::Debug) => Expr::rs("bytesDebug", vec![Expr::rs("bytesMutView", vec![value]), f]), _ => return None, }, _ => return None, @@ -613,8 +613,8 @@ fn iter_debug<'tcx>( }); Expr::Array(wraps.collect()) }; - let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); - let write = |text: String| Some(Expr::rt("fmtWriteStr", vec![f.clone(), Expr::Str(text)])); + let call = |name: &str, rest: Vec| Expr::rs(name, [vec![value.clone(), f.clone()], rest].concat()); + let write = |text: String| Some(Expr::rs("fmtWriteStr", vec![f.clone(), Expr::Str(text)])); // The item it has left, if any, as std's `Option` inside `wraps`: a reference as it is // held, a `&mut` to a value JS copies its place. let option = |b: &mut Body<'_, '_, 'tcx>, wraps: &[Wrap]| { @@ -626,7 +626,7 @@ fn iter_debug<'tcx>( let slice = |b: &mut Body<'_, '_, 'tcx>| Some(b.fmt_fn(Trait::Debug, Ty::new_slice(tcx, args.types().next()?), span)); let (item, wraps): (Item, &[Wrap]) = match path.as_slice() { - ["str", "iter", "Chars"] => return Some(Expr::rt("fmtChars", vec![value.clone(), f.clone()])), + ["str", "iter", "Chars"] => return Some(Expr::rs("fmtChars", vec![value.clone(), f.clone()])), ["str", "iter", "CharIndices"] => return Some(call("fmtCharIndices", Vec::new())), // Its searcher's state, by the name of std's searcher of its pattern. [ @@ -649,7 +649,7 @@ fn iter_debug<'tcx>( return Some(call("fmtStrSearch", vec![Expr::Str((*name).into())])); } ["string", "Drain"] => return Some(call("fmtStringDrain", Vec::new())), - ["str", "lossy", "Utf8Chunks"] => return Some(Expr::rt("fmtUtf8Chunks", vec![value.clone(), f.clone()])), + ["str", "lossy", "Utf8Chunks"] => return Some(Expr::rs("fmtUtf8Chunks", vec![value.clone(), f.clone()])), // Without its fields, which neither `#` nor a width changes. ["str", "iter", "EncodeUtf16"] | ["iter", "sources", "repeat_with", "RepeatWith"] @@ -755,22 +755,22 @@ fn iter_debug<'tcx>( ] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); let call = vec![value.clone(), f.clone(), debug, Expr::Str((*name).into())]; - return Some(Expr::rt("fmtDequeIter", call)); + return Some(Expr::rs("fmtDequeIter", call)); } ["vec", "extract_if", "ExtractIf"] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); - return Some(Expr::rt("fmtVecExtractIf", vec![value.clone(), f.clone(), debug])); + return Some(Expr::rs("fmtVecExtractIf", vec![value.clone(), f.clone(), debug])); } ["collections", "vec_deque", "drain", "Drain"] => { let len = b.fmt_fn(Trait::Debug, tcx.types.usize, span); - return Some(Expr::rt("fmtDequeDrain", vec![value.clone(), f.clone(), len])); + return Some(Expr::rs("fmtDequeDrain", vec![value.clone(), f.clone(), len])); } // The list it has left, then its length. ["collections", "linked_list", name @ ("Iter" | "IterMut")] => { let debug = b.fmt_fn(Trait::Debug, args.types().next()?, span); let len = b.fmt_fn(Trait::Debug, tcx.types.usize, span); let call = vec![value.clone(), f.clone(), debug, len, Expr::Str((*name).into())]; - return Some(Expr::rt("fmtListIter", call)); + return Some(Expr::rs("fmtListIter", call)); } ["str", "iter", "Bytes"] => (Byte, &[Tuple("Bytes"), Struct("Copied", "it"), Tuple("Iter")]), ["slice", "iter", "Iter"] @@ -807,7 +807,7 @@ fn iter_debug<'tcx>( let debug = match item { Arg(n) => b.fmt_fn(Trait::Debug, arg(n)?, span), Entry => b.fmt_fn(Trait::Debug, Ty::new_tup(tcx, &[arg(0)?, arg(1)?]), span), - SetVal => Expr::rt("fmtSetVal", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), + SetVal => Expr::rs("fmtSetVal", vec![b.fmt_fn(Trait::Debug, arg(0)?, span)]), Byte => b.fmt_fn(Trait::Debug, tcx.types.u8, span), }; let mut rest = vec![debug]; @@ -832,9 +832,9 @@ fn adaptor_debug<'tcx>( let path = library::std_path(tcx, did); let path: Vec<&str> = path.iter().map(String::as_str).collect(); let arg = |n: usize| args.types().nth(n); - let call = |name: &str, rest: Vec| Expr::rt(name, [vec![value.clone(), f.clone()], rest].concat()); + let call = |name: &str, rest: Vec| Expr::rs(name, [vec![value.clone(), f.clone()], rest].concat()); let name = |name: &str| Expr::Str(name.into()); - // What writes an iterator it wraps, as the adaptor holds it and `rt.iterHeld` reads it. + // What writes an iterator it wraps, as the adaptor holds it and `rs.iterHeld` reads it. let wrapped = |b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>| { let (ty, _) = super::iter::peel_iter(b, ty, Expr::undefined()); b.fmt_fn(Trait::Debug, ty, span) @@ -959,7 +959,7 @@ impl Spec { pub fn object(&self, arg: impl Fn(usize) -> Expr) -> Option { let count = |count: Count| match count { Count::Is(n) => Expr::lit(n.to_string()), - Count::Arg(index) => Expr::rt("fmtCountOf", vec![arg(index)]), + Count::Arg(index) => Expr::rs("fmtCountOf", vec![arg(index)]), }; let mut props = Vec::new(); if self.fill != ' ' { diff --git a/ts/src/lower/iter.rs b/ts/src/lower/iter.rs index 835f0b0d6..383e3ed65 100644 --- a/ts/src/lower/iter.rs +++ b/ts/src/lower/iter.rs @@ -1,8 +1,8 @@ -//! Iterators, as `rt/iter.ts` gives them: std's iterators are `rt.Iter` objects whose -//! `next` returns an item or `rt.DONE`, and whose adaptors and consumers are runtime -//! functions taking the iterator first: `rt.iterMap(it, f)`. The crate's own `impl +//! Iterators, as `rs/iter.ts` gives them: std's iterators are `rs.Iter` objects whose +//! `next` returns an item or `rs.DONE`, and whose adaptors and consumers are runtime +//! functions taking the iterator first: `rs.iterMap(it, f)`. The crate's own `impl //! Iterator` keeps that protocol in its `next`, and joins std's adaptors through -//! `rt.iterFrom`, with the methods in `OWN` it has of its own. +//! `rs.iterFrom`, with the methods in `OWN` it has of its own. use rustc_hir::def_id::DefId; use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeVisitableExt}; @@ -48,7 +48,7 @@ impl<'tcx> Translator<'_, 'tcx> { } /// `Iterator::Item` of `ty`, if it is a `dyn Iterator`, `dyn DoubleEndedIterator`, - /// `dyn ExactSizeIterator`, or `dyn FusedIterator`, whose JS value is an `rt.Iter` of its + /// `dyn ExactSizeIterator`, or `dyn FusedIterator`, whose JS value is an `rs.Iter` of its /// items. pub fn dyn_iter(&self, ty: Ty<'tcx>) -> Option> { let ty::Dynamic(preds, ..) = ty.kind() else { @@ -73,7 +73,7 @@ fn own_next<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option } /// The methods of std's iterator traits, by trait, that an iterator of the crate may have -/// of its own: `rt.iterFrom` calls each where std's adaptors and consumers do. +/// of its own: `rs.iterFrom` calls each where std's adaptors and consumers do. const OWN: [(&str, &str); 17] = [ ("Iterator", "next"), ("Iterator", "size_hint"), @@ -402,8 +402,8 @@ fn erases(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Option<(Span, String)> /// The generic arguments the crate's own method `name` taking a closure, of `item`s, is /// translated for, which a body `erases` doesn't refuse can't tell apart from any others: a /// `fold`'s or an `rfold`'s accumulator as an `Option`, a `find_map`'s found value as -/// a `u32`, which `rt.iterFrom` boxes, and the closure as a `Box` of its -/// signature, whose JS value is the function `rt.iterFrom` gives it and which drops what +/// a `u32`, which `rs.iterFrom` boxes, and the closure as a `Box` of its +/// signature, whose JS value is the function `rs.iterFrom` gives it and which drops what /// std's closure owns as it drops. fn closure_args<'tcx>(t: &Translator<'_, 'tcx>, name: &str, item: Ty<'tcx>) -> Option>> { let tcx = t.tcx; @@ -531,7 +531,7 @@ fn folds_own<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { false } -/// The `rt.Own` of the crate's iterator of type `ty`: each method of `OWN` but `next` that +/// The `rs.Own` of the crate's iterator of type `ty`: each method of `OWN` but `next` that /// it has of its own, as a function of its source, and only those in `BORROWED` unless it /// is `owned`. `undefined` if it has none. fn own_methods<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, owned: bool, span: Span) -> Expr { @@ -573,7 +573,7 @@ fn own_methods<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, owned: bool, span sym = through_place(b, ty, sym, args, span); } // Each that returns an `Option` of an item, as the protocol returns it: an item or - // `rt.DONE`. + // `rs.DONE`. let method = match *name { "next_back" | "nth" | "nth_back" | "last" | "find" | "rfind" | "reduce" => { let call = [Expr::ident("it")] @@ -581,7 +581,7 @@ fn own_methods<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, owned: bool, span .chain(args.iter().map(|&arg| Expr::ident(arg))); let option = [sym.call(call.collect())].into_iter().chain(none.clone()).collect(); let params = source_params(b, ty, args, span); - Expr::Lambda(params, Box::new(Expr::rt("iterFromOption", option))) + Expr::Lambda(params, Box::new(Expr::rs("iterFromOption", option))) } _ => sym, }; @@ -598,24 +598,24 @@ fn own_methods<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, owned: bool, span } } -/// Whether `rt.iterFrom` holds the crate's own iterator of type `ty`, through references, as -/// an `rt.Place`, as its `next` reads one whose JS value is copied, such as an enum's. +/// Whether `rs.iterFrom` holds the crate's own iterator of type `ty`, through references, as +/// an `rs.Place`, as its `next` reads one whose JS value is copied, such as an enum's. fn held<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool { b.t.needs_place(ty.peel_refs()) } -/// Whether `ty` is an iterator of the crate's own whose `&mut` is an `rt.Place`, which std's +/// Whether `ty` is an iterator of the crate's own whose `&mut` is an `rs.Place`, which std's /// methods taking `&mut self` read through, as its `next` does. pub fn held_own<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>) -> bool { matches!(ty.kind(), ty::Adt(adt, _) if t.own(adt.did())) && t.iter_item(ty).is_some() && t.needs_place(ty) } -/// The parameters of a function of the source of `rt.iterFrom` holding the crate's own -/// iterator of type `ty`, then `args`, which are typed by their place in `rt.Own`. +/// The parameters of a function of the source of `rs.iterFrom` holding the crate's own +/// iterator of type `ty`, then `args`, which are typed by their place in `rs.Own`. fn source_params<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, args: &[&str], span: Span) -> Vec { let it = b.t.ty(ty.peel_refs(), span); let it = match held(b, ty) { - true => Type::Rt("Place", vec![it]), + true => Type::Rs("Place", vec![it]), false => it, }; let it = Param { @@ -629,7 +629,7 @@ fn source_params<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, args: &[&str], [it].into_iter().chain(args).collect() } -/// `f` of the value in the place `rt.iterFrom` holds the crate's own iterator of type `ty` +/// `f` of the value in the place `rs.iterFrom` holds the crate's own iterator of type `ty` /// by, then `args`. fn through_place<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, f: Expr, args: &[&str], span: Span) -> Expr { let call = [Expr::ident("it").member("v")] @@ -640,7 +640,7 @@ fn through_place<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, f: Expr, args: } /// `iter.next_back()` of the crate's own iterator of type `ty`, as the protocol returns it: -/// an item or `rt.DONE`. +/// an item or `rs.DONE`. fn own_back<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr) -> Option { let instance = own_method(b, ty, "DoubleEndedIterator", "next_back")?; let item = b.t.iter_item(ty.peel_refs())?; @@ -648,10 +648,10 @@ fn own_back<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr) -> Optio let sym = b.t.instance(instance); let none = b.t.none_arg(item); let option = Expr::Sym(sym).call(vec![iter]); - Some(Expr::rt("iterFromOption", [option].into_iter().chain(none).collect())) + Some(Expr::rs("iterFromOption", [option].into_iter().chain(none).collect())) } -/// `iter.next()` by the protocol, for an iterator of type `ty`: an item or `rt.DONE`. +/// `iter.next()` by the protocol, for an iterator of type `ty`: an item or `rs.DONE`. pub fn next<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr) -> Expr { match own_next(b, ty) { Some(instance) => { @@ -665,9 +665,9 @@ pub fn next<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, iter: Expr) -> Expr impl<'tcx> Body<'_, '_, 'tcx> { /// `value`, a `&`, `&mut`, or `Box` of an iterator unsized to `to`, the same pointer to a - /// `dyn Iterator`: an `rt.iterDyn` of the `rt.Iter` it is, which reads it by the methods + /// `dyn Iterator`: an `rs.iterDyn` of the `rs.Iter` it is, which reads it by the methods /// std's vtable has and else by `next`, as std's defaults read a trait object, and drops - /// it if the box owned it. An upcast from another is the same `rt.Iter`. + /// it if the box owned it. An upcast from another is the same `rs.Iter`. pub fn dyn_iter(&mut self, from: Ty<'tcx>, to: Ty<'tcx>, value: Expr, span: Span) -> Expr { let Some(pointee) = from.builtin_deref(true).filter(|_| to.builtin_deref(true).is_some()) else { return self.err(span, format!("a coercion to `{to}`, which is not supported yet")); @@ -675,7 +675,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { if self.t.dyn_iter(pointee).is_some() { return value; } - // Another trait object, whose object has its trait's methods and is no `rt.Iter`. + // Another trait object, whose object has its trait's methods and is no `rs.Iter`. if pointee.is_trait() { return self.err( span, @@ -687,8 +687,8 @@ impl<'tcx> Body<'_, '_, 'tcx> { return Expr::undefined(); } // What a box owns iterates as itself, and what a reference borrows as a `&mut` does, - // which `into_iter` makes of a shared one. A raw pointer can be an `rt.Place`, which - // no `rt.Iter` reads through. + // which `into_iter` makes of a shared one. A raw pointer can be an `rs.Place`, which + // no `rs.Iter` reads through. let ty = match from.kind() { _ if from.is_box() => pointee, ty::Ref(..) => from, @@ -700,7 +700,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { } }; match into_iter(self, ty, value, span) { - Some(it) => Expr::rt("iterDyn", vec![it]), + Some(it) => Expr::rs("iterDyn", vec![it]), None => self.err( span, format!("a coercion of `{from}` to `{to}`, which is not supported yet"), @@ -709,7 +709,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { } } -/// What `IntoIterator::into_iter` makes of `value`, a `ty`: an `rt.Iter`, or `None` for a +/// What `IntoIterator::into_iter` makes of `value`, a `ty`: an `rs.Iter`, or `None` for a /// type without a mapping. One that owns what it yields, by value, is given what drops /// each, and the crate's own iterator what drops it. pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Option { @@ -718,9 +718,9 @@ pub fn into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, sp Some(boxes(b, ty, it)) } -/// `it`, the `rt.Iter` of what `peel_iter` read a `ty` through, read through `ty`'s boxes +/// `it`, the `rs.Iter` of what `peel_iter` read a `ty` through, read through `ty`'s boxes /// as std's `Iterator` for `Box` reads one: by what it forwards, and else by `next`. -/// Boxes before the first reference are one `rt.iterBox`, and a box past it makes that +/// Boxes before the first reference are one `rs.iterBox`, and a box past it makes that /// reference fold by `next` too, whatever the box holds. fn boxes<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>, it: Expr) -> Expr { let held = |ty: Ty<'tcx>| ty.boxed_ty().filter(|held| b.t.iter_item(*held).is_some()); @@ -739,11 +739,11 @@ fn boxes<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>, it: Expr) -> Expr { } }; let it = match borrowed { - true => Expr::rt("iterBorrow", vec![Expr::rt("iterBox", vec![it])]), + true => Expr::rs("iterBorrow", vec![Expr::rs("iterBox", vec![it])]), false => it, }; match outer { - true => Expr::rt("iterBox", vec![it]), + true => Expr::rs("iterBox", vec![it]), false => it, } } @@ -783,12 +783,12 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, false => value, }; let own = own_methods(b, ty, owned, span); - Expr::rt("iterFrom", tail(vec![value, next], vec![drop, own])) + Expr::rs("iterFrom", tail(vec![value, next], vec![drop, own])) } // One borrowed by `&mut`, which std's adaptors may drop once it ends, but which // is its owner's to drop, and which a consumer reads on through the borrow // rather than by its by-value overrides, as `Chain::count` ends both halves. - None if !owned => Expr::rt("iterBorrow", vec![value]), + None if !owned => Expr::rs("iterBorrow", vec![value]), None => value, }); } @@ -810,29 +810,29 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, }; match ty.peel_refs().kind() { ty::Slice(elem) | ty::Array(elem, _) if places(b, *elem) => { - Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) + Some(Expr::rs("iterSliceMut", vec![library::elements(value, ty)])) } ty::Slice(elem) | ty::Array(elem, _) => { let values = each(b, *elem, vec![library::elements(value, ty)]); - Some(items(Expr::rt("iterSlice", values), *elem)) + Some(items(Expr::rs("iterSlice", values), *elem)) } ty::Adt(adt, args) => match Std::of(tcx, adt.did())? { Std::Vec if places(b, args.type_at(0)) => { - Some(Expr::rt("iterSliceMut", vec![library::elements(value, ty)])) + Some(Expr::rs("iterSliceMut", vec![library::elements(value, ty)])) } // A `Vec`'s owned bytes keep its buffer, as a deque collected from them does. - Std::Vec if owned && super::byte(args.type_at(0)) => Some(Expr::rt("byteVecIntoIter", vec![value])), + Std::Vec if owned && super::byte(args.type_at(0)) => Some(Expr::rs("byteVecIntoIter", vec![value])), // An owned `Vec`'s items keep its buffer, as a collect in place or into a deque does. - Std::Vec if owned => Some(Expr::rt("vecIntoIter", each(b, args.type_at(0), vec![value]))), + Std::Vec if owned => Some(Expr::rs("vecIntoIter", each(b, args.type_at(0), vec![value]))), Std::Vec => Some(items( - Expr::rt("iterSlice", vec![library::elements(value, ty)]), + Expr::rs("iterSlice", vec![library::elements(value, ty)]), args.type_at(0), )), // A `&mut` lends the payload JS copies as the `Option`'s own place, while it has one. Std::Option if places(b, args.type_at(0)) => { let mut values = vec![value]; values.extend(b.t.none_arg(args.type_at(0))); - Some(Expr::rt("iterOption", vec![Expr::rt("optionAsMut", values)])) + Some(Expr::rs("iterOption", vec![Expr::rs("optionAsMut", values)])) } // A `&mut` to one of another payload is its place, and yields the payload itself. Std::Option => { @@ -842,7 +842,7 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, values.resize(2, Expr::undefined()); values.push(none); } - Some(items(Expr::rt("iterOption", values), inner)) + Some(items(Expr::rs("iterOption", values), inner)) } Std::Result if places(b, args.type_at(0)) => Some(result_places(value)), // One by value drops its `Err` as it makes the iterator. @@ -853,7 +853,7 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, values.resize(2, Expr::undefined()); values.push(b.t.dropper(err, span)); } - Some(items(Expr::rt("iterResult", values), ok)) + Some(items(Expr::rs("iterResult", values), ok)) } _ => super::collections::into_iter(b, ty, value, span), }, @@ -861,16 +861,16 @@ fn peeled_into_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, } } -/// The iterator of the payload of the `Result` at `place`, an `rt.Place`, as its own place. +/// The iterator of the payload of the `Result` at `place`, an `rs.Place`, as its own place. fn result_places(place: Expr) -> Expr { - Expr::rt("iterOption", vec![Expr::rt("resultAsMut", vec![place])]) + Expr::rs("iterOption", vec![Expr::rs("resultAsMut", vec![place])]) } /// `iter`, over the elements of a slice or `Vec` of `elem`s or the payload of an `Option` /// or a `Result`, yielding references to them: a slice of each array of bytes. pub(super) fn by_ref(iter: Expr, elem: Ty<'_>) -> Expr { match super::byte_array(elem) { - true => Expr::rt("iterLend", vec![iter, Expr::Rt("byteSliceFrom".into())]), + true => Expr::rs("iterLend", vec![iter, Expr::Rs("byteSliceFrom".into())]), false => iter, } } @@ -916,7 +916,7 @@ pub fn unbox_ref<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { } } -/// Whether `ty` is a `&mut` to a `&mut`, which is an `rt.Place` of it, or a box of one, +/// Whether `ty` is a `&mut` to a `&mut`, which is an `rs.Place` of it, or a box of one, /// which is what it holds. pub fn through_mut(ty: Ty<'_>) -> bool { match ty.boxed_ty() { @@ -983,7 +983,7 @@ pub fn peel_iter<'tcx>(b: &Body<'_, '_, 'tcx>, mut ty: Ty<'tcx>, mut value: Expr } } -/// Refuse iterating `ty`, an iterator, if a binding stands in for it: it is no `rt.Iter`, +/// Refuse iterating `ty`, an iterator, if a binding stands in for it: it is no `rs.Iter`, /// which std's adaptors and `for` take every iterator but the crate's own for. fn not_bound<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) { if let ty::Adt(adt, _) = ty.peel_refs().kind() @@ -1014,23 +1014,23 @@ pub fn call<'tcx>( match (owner, name) { ("slice", "iter_mut") if b.t.needs_place(targ(0)?) => { let s = library::elements(args.pop()?, Ty::new_slice(tcx, targ(0)?)); - return Some(Expr::rt("iterSliceMut", vec![s])); + return Some(Expr::rs("iterSliceMut", vec![s])); } ("slice", "iter" | "iter_mut") => { let s = args.pop()?; let s = library::elements(s, Ty::new_slice(tcx, targ(0)?)); - return Some(by_ref(Expr::rt("iterSlice", vec![s]), targ(0)?)); + return Some(by_ref(Expr::rs("iterSlice", vec![s]), targ(0)?)); } ("Option", "iter" | "iter_mut") => { let mut args = args; if let Some(none) = b.t.none_arg(targ(0)?) { args.extend([Expr::undefined(), none]); } - return Some(Expr::rt("iterOption", args)); + return Some(Expr::rs("iterOption", args)); } ("Result", "iter_mut") if b.t.needs_place(targ(0)?) => return Some(result_places(args.pop()?)), - ("Result", "iter" | "iter_mut") => return Some(Expr::rt("iterResult", args)), - // A `&mut` to a `&mut` iterator is itself, an `rt.Place` that each use reads through. + ("Result", "iter" | "iter_mut") => return Some(Expr::rs("iterResult", args)), + // A `&mut` to a `&mut` iterator is itself, an `rs.Place` that each use reads through. ("IntoIterator", "into_iter") if through_mut(targ(0)?) => return args.pop(), // So is a `&mut` iterator, which what takes it by value borrows as it does. ("IntoIterator", "into_iter") @@ -1043,7 +1043,7 @@ pub fn call<'tcx>( let value = args.pop()?; return into_iter(b, targ(0)?, value, span); } - // The `&mut` it was given, an `rt.Place` where that points at a `&mut`. + // The `&mut` it was given, an `rs.Place` where that points at a `&mut`. ("Iterator", "by_ref") => { not_bound(b, targ(0)?, span); return args.pop(); @@ -1053,9 +1053,9 @@ pub fn call<'tcx>( match path.as_slice() { ["iter", "sources", "once", "once"] => { let dropper = b.t.dropper(targ(0)?, span); - return Some(Expr::rt("iterOnce", tail(args, vec![dropper]))); + return Some(Expr::rs("iterOnce", tail(args, vec![dropper]))); } - ["iter", "sources", "empty", "empty"] => return Some(Expr::rt("iterEmpty", Vec::new())), + ["iter", "sources", "empty", "empty"] => return Some(Expr::rs("iterEmpty", Vec::new())), // `a.into_iter().zip(b)`, as std's is. ["iter", "adapters", "zip", "zip"] => { let [a, other] = <[Expr; 2]>::try_from(args).ok()?; @@ -1064,13 +1064,13 @@ pub fn call<'tcx>( } // A closure that owns a value that drops is refused as any std mapping refuses one // it calls but never drops. - // Each takes its closure's `None` last, where that is `rt.None`. + // Each takes its closure's `None` last, where that is `rs.None`. ["iter", "sources", "from_fn", "from_fn"] => { let none = b.t.none_arg(targ(0)?); - return Some(Expr::rt("iterFromFn", [args, none.into_iter().collect()].concat())); + return Some(Expr::rs("iterFromFn", [args, none.into_iter().collect()].concat())); } - ["iter", "sources", "repeat_with", "repeat_with"] => return Some(Expr::rt("iterRepeatWith", args)), - ["iter", "sources", "once_with", "once_with"] => return Some(Expr::rt("iterOnceWith", args)), + ["iter", "sources", "repeat_with", "repeat_with"] => return Some(Expr::rs("iterRepeatWith", args)), + ["iter", "sources", "once_with", "once_with"] => return Some(Expr::rs("iterOnceWith", args)), // What clones the element for each item, and drops it. ["iter", "sources", source @ ("repeat" | "repeat_n"), _] => { let clone = super::collections::clone_fn(b, targ(0)?, span); @@ -1080,12 +1080,12 @@ pub fn call<'tcx>( } else { "iterRepeatN" }; - return Some(Expr::rt(name, tail(args, vec![clone, dropper]))); + return Some(Expr::rs(name, tail(args, vec![clone, dropper]))); } // What drops the item it holds next. ["iter", "sources", "successors", "successors"] => { let droppers = [b.t.dropper(targ(0)?, span)].into_iter().chain(b.t.none_arg(targ(0)?)); - return Some(Expr::rt("iterSuccessors", tail(args, droppers.collect()))); + return Some(Expr::rs("iterSuccessors", tail(args, droppers.collect()))); } _ => {} } @@ -1114,7 +1114,7 @@ pub fn call<'tcx>( let mut items = into_iter(b, source, items, span)?; // `Extend<&T>` copies each element. if let Some(copy) = super::collections::copy_borrowed(b, coll, item, span) { - items = Expr::rt("iterMap", vec![items, copy]); + items = Expr::rs("iterMap", vec![items, copy]); } return super::collections::extend(b, coll, item, target, items, iter, span); } @@ -1148,7 +1148,7 @@ pub fn call<'tcx>( let first = values.next()?; let (iter_ty, recv) = peel_iter(b, self_ty, first.clone()); let rest: Vec = values.collect(); - // What a consumer returns for `None`, after its other arguments, where that is `rt.None`. + // What a consumer returns for `None`, after its other arguments, where that is `rs.None`. let none = b.t.none_arg(item); // `next` by the protocol, as an `Option`. @@ -1162,24 +1162,24 @@ pub fn call<'tcx>( _ => { let recv = into_iter(b, self_ty, first, span)?; let droppers = [b.t.dropper(item, span)].into_iter().chain(none).collect(); - return Some(Expr::rt("iterNthBack", tail([vec![recv], rest].concat(), droppers))); + return Some(Expr::rs("iterNthBack", tail([vec![recv], rest].concat(), droppers))); } }; - return Some(Expr::rt("iterToOption", [item].into_iter().chain(none).collect())); + return Some(Expr::rs("iterToOption", [item].into_iter().chain(none).collect())); } let recv = into_iter(b, self_ty, first, span)?; - // `rt.iter(recv, ...args)`, or `peekable` of a `Peekable`'s own. + // `rs.iter(recv, ...args)`, or `peekable` of a `Peekable`'s own. let method = |name: &str, args: Vec| { let of = match owner { "Peekable" => "peekable", _ => "iter", }; - Some(Expr::rt_of(of, name).call([vec![recv.clone()], args].concat())) + Some(Expr::rs_of(of, name).call([vec![recv.clone()], args].concat())) }; let camel = super::camel(name); match name { "map" | "enumerate" | "rev" | "inspect" | "any" | "all" | "position" => method(&camel, rest), - // Each takes its closure's `None` last, where that is `rt.None`. + // Each takes its closure's `None` last, where that is `rs.None`. "filter_map" | "map_while" | "find_map" => { let none = b.t.none_arg(targ(1)?); method(&camel, [rest, none.into_iter().collect()].concat()) @@ -1220,11 +1220,11 @@ pub fn call<'tcx>( let clones = clones(b, self_ty, span)?; method(name, tail(rest, vec![clones])) } - // `rt.owned`, which drops what `self_ty` holds and its items by `dropper` as + // `rs.owned`, which drops what `self_ty` holds and its items by `dropper` as // std's own does, where either drops, counts a `Cycle` as std's `Take::count` does, // by its `advance_by`, which stops at a clone that yields nothing where `try_fold` // reads on, or reaches a `Repeat`'s or a `RepeatN`'s own, which clone nothing, held - // or yielded to a `Flatten`: else `rt.iter`, so a bundle that never drops + // or yielded to a `Flatten`: else `rs.iter`, so a bundle that never drops // doesn't carry it. "count" | "last" => { let dropper = b.t.dropper(item, span); @@ -1237,7 +1237,7 @@ pub fn call<'tcx>( p == &["iter", "sources", "repeat", "Repeat"] || p == &["iter", "sources", "repeat_n", "RepeatN"] }); match drops_iter(b, self_ty, span) || !undefined(&dropper) || cycles || repeats { - true => Some(Expr::rt_of("owned", name).call(tail(vec![recv.clone()], [vec![dropper], none].concat()))), + true => Some(Expr::rs_of("owned", name).call(tail(vec![recv.clone()], [vec![dropper], none].concat()))), false => method(name, none), } } @@ -1282,7 +1282,7 @@ pub fn call<'tcx>( b.t.hooked .then(|| super::caller::sum_site(b.t.tcx, Some(item.is_ref()))); let args = [drops].into_iter().chain(at).collect(); - Some(Expr::rt("durationSum", tail(vec![recv.clone()], args))) + Some(Expr::rs("durationSum", tail(vec![recv.clone()], args))) } // std's float sum starts from -0.0, so a sum of none, or of -0.0s, is -0.0. "sum" | "product" if let Some(float) = super::float::Float::of(targ(1)?) => { @@ -1293,7 +1293,7 @@ pub fn call<'tcx>( let drops = iter_drops(b, self_ty, span); method( name, - tail(vec![Expr::rt_of(float.name(), op), float.lit(unit)], vec![drops]), + tail(vec![Expr::rs_of(float.name(), op), float.lit(unit)], vec![drops]), ) } // A `Wrapping`'s wraps and a `Saturating`'s saturates, as its `+` and `*` do. @@ -1373,7 +1373,7 @@ pub fn call<'tcx>( // drops the rest with it. if !by_key && btree_end(tcx, self_ty, name) && b.t.drops(self_ty) { let back = Expr::lit((name == "max").to_string()); - return Some(Expr::rt( + return Some(Expr::rs( "ownedEnd", [recv.clone(), back].into_iter().chain(none).collect(), )); @@ -1383,7 +1383,7 @@ pub fn call<'tcx>( "max" => recv.member("nextBack").call(Vec::new()), _ => recv.member("next").call(Vec::new()), }; - return Some(Expr::rt("iterToOption", [end].into_iter().chain(none).collect())); + return Some(Expr::rs("iterToOption", [end].into_iter().chain(none).collect())); } if !by_key && own_ord(b, key, name) { return Some(b.err( @@ -1425,10 +1425,10 @@ pub fn call<'tcx>( let (mut f, f_ty) = (rest.into_iter().next()?, targ(1)?); let (_, lent, _) = library::called_through(b.t, f_ty, None); if lent && drops { - f = Expr::rt("lent", vec![f]); + f = Expr::rs("lent", vec![f]); } let drops = drops || b.t.drops(f_ty); - (Expr::rt("iterMap", vec![recv.clone(), f]), le, key, drops) + (Expr::rs("iterMap", vec![recv.clone(), f]), le, key, drops) } }; let drops = flag(drops); @@ -1436,7 +1436,7 @@ pub fn call<'tcx>( if name == "is_sorted_by" { droppers.push(b.t.dropper(targ(1)?, span)); } - Some(Expr::rt("iterIsSortedBy", tail(vec![items, compare], droppers))) + Some(Expr::rs("iterIsSortedBy", tail(vec![items, compare], droppers))) } "rposition" => method(&camel, rest), "eq" | "cmp" | "partial_cmp" | "eq_by" | "cmp_by" | "partial_cmp_by" => { @@ -1491,7 +1491,7 @@ pub fn call<'tcx>( // Each item through its `Clone`. _ if !copies => Some(clone(b)?), // Out of the slice each item is. - _ if super::byte_array(*inner) => Some(Expr::Rt("byteSliceToArray".into())), + _ if super::byte_array(*inner) => Some(Expr::Rs("byteSliceToArray".into())), _ => b.t.copy_fn(*inner, span), }; // std's `copied` skips through its iterator's `nth`, and `cloned` by its own `next`. @@ -1547,7 +1547,7 @@ fn compare<'tcx>( }; let f = match drops.iter().all(undefined) { true => f, - false => Expr::rt("consuming", [vec![f], drops.to_vec()].concat()), + false => Expr::rs("consuming", [vec![f], drops.to_vec()].concat()), }; (f, false) } @@ -1565,9 +1565,9 @@ fn compare<'tcx>( "eq" => { let trusted = implements(b.t, self_ty, "TrustedLen") && implements(b.t, other_iter, "TrustedLen"); let trusted = if trusted { Expr::lit("true") } else { Expr::undefined() }; - Expr::rt("iterEq", tail(vec![recv, other, f], [vec![trusted], compared].concat())) + Expr::rs("iterEq", tail(vec![recv, other, f], [vec![trusted], compared].concat())) } - _ => Expr::rt("iterCmp", tail(vec![recv, other, f], compared)), + _ => Expr::rs("iterCmp", tail(vec![recv, other, f], compared)), }) } @@ -1736,7 +1736,7 @@ pub(super) fn clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr, Some(value.member("clone").call(tail(Vec::new(), vec![clones]))) } -/// The `rt.Clones` an iterator of type `ty` is cloned by, as std's `Clone` of it clones +/// The `rs.Clones` an iterator of type `ty` is cloned by, as std's `Clone` of it clones /// each part, or `undefined` where each part clones as itself: `i` and `o` for the /// iterators it wraps, `f` for its closure, and `v` for an item or another value it holds. /// The crate's own iterator, which `into_iter` wraps, is that value, by its `Clone`. @@ -1811,7 +1811,7 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< // std's copies what a `Vec`'s has left into a buffer of its own, even of items that // clone as themselves, which a deque collected from it takes. ["vec", "into_iter", "IntoIter"] => match value(b, arg(0)?) { - v if undefined(&v) => parts(vec![("v", Expr::Rt("itself".into()))]), + v if undefined(&v) => parts(vec![("v", Expr::Rs("itself".into()))]), v => parts(vec![("v", v)]), }, // Those that clone their element by what they were made with. @@ -1826,7 +1826,7 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< | ["collections", "linked_list", "IntoIter"] | ["collections", "binary_heap", "IntoIter"] => parts(vec![("v", value(b, arg(0)?))]), // A closure's searcher clones the closure; another holds what it searches for. One - // from the back is `rt.iterRev` of one from the front. + // from the back is `rs.iterRev` of one from the front. [ "str", "iter", @@ -1839,7 +1839,7 @@ fn clones<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option< ] => parts(vec![("i", searcher(b, arg(0)?, span))]), // A slice's parts by a closure clone the closure. ["slice", "iter", "Split" | "SplitInclusive" | "RSplit"] => parts(vec![("f", value(b, arg(1)?))]), - // Its closure is what `rt.iterFrom` reads by. + // Its closure is what `rs.iterFrom` reads by. ["iter", "sources", "from_fn", "FromFn"] => parts(vec![("v", value(b, arg(0)?))]), ["iter", "sources", "successors", "Successors"] => { parts(vec![("v", value(b, arg(0)?)), ("f", value(b, arg(1)?))]) @@ -1888,7 +1888,7 @@ fn searcher<'tcx>(b: &mut Body<'_, '_, 'tcx>, pattern: Ty<'tcx>, span: Span) -> } } -/// An `rt.Clones` of `parts` but those that clone as themselves, or `undefined` if all do. +/// An `rs.Clones` of `parts` but those that clone as themselves, or `undefined` if all do. fn parts(parts: Vec<(&str, Expr)>) -> Expr { let parts: Vec<(Key, Expr)> = (parts.into_iter()) .filter(|(_, e)| !undefined(e)) @@ -1900,7 +1900,7 @@ fn parts(parts: Vec<(&str, Expr)>) -> Expr { } } -/// Whether std's iterator `did` holds a closure that its `rt.Iter` drops, after the iterator +/// Whether std's iterator `did` holds a closure that its `rs.Iter` drops, after the iterator /// it wraps if any, as std's fields order them. pub(super) fn holds_closure(tcx: ty::TyCtxt<'_>, did: DefId) -> bool { let path = library::std_path(tcx, did); @@ -1953,7 +1953,7 @@ pub(super) fn holds_closure(tcx: ty::TyCtxt<'_>, did: DefId) -> bool { ) } -/// `rt.iterZip` of `a`, an iterator, and `other`, of type `other_ty`, into `zip`, the `Zip` +/// `rs.iterZip` of `a`, an iterator, and `other`, of type `other_ty`, into `zip`, the `Zip` /// of their iterators. fn zip<'tcx>( b: &mut Body<'_, '_, 'tcx>, @@ -1974,10 +1974,10 @@ fn zip<'tcx>( b.t.dropper(item, span), b.t.dropper(other_item, span), ]; - Some(Expr::rt("iterZip", tail(vec![a, other], droppers))) + Some(Expr::rs("iterZip", tail(vec![a, other], droppers))) } -/// `rt.Trusted`, how std's `Zip` of `a` and `b` reads them, by the traits it specializes +/// `rs.Trusted`, how std's `Zip` of `a` and `b` reads them, by the traits it specializes /// on: by index if both are `TrustedRandomAccess`, as whether each may have side effects, /// and folded by its size hint if both are `TrustedRandomAccessNoCoerce`, whose `fold` /// reads by index as many pairs as their exact size hints, or `TrustedLen`, whose `fold` @@ -2058,7 +2058,7 @@ fn collect<'tcx>( if ty.is_unit() { let drops = iter_drops(b, from, span); let each = Expr::Lambda(Vec::new(), Box::new(Expr::undefined())); - return Some(Expr::rt( + return Some(Expr::rs( "iterFold", tail(vec![iter, Expr::undefined(), each], vec![drops]), )); @@ -2076,7 +2076,7 @@ fn collect<'tcx>( && let Some(boxed) = super::task::shared_box(tcx, args.type_at(0)) { let boxed = collect(b, boxed, item, iter, from, trusted, span)?; - return Some(Expr::New(Box::new(Expr::Rt("Arc".into())), vec![boxed])); + return Some(Expr::New(Box::new(Expr::Rs("Arc".into())), vec![boxed])); } // A `Cow<[T]>` owns the `Vec` std's collects, and a `Box<[T]>` becomes it. let boxed = library::box_slice(tcx, ty); @@ -2088,7 +2088,7 @@ fn collect<'tcx>( let v = match elem.kind() { _ if super::byte(elem) => { let (take, by_index, src) = collect_take(b, from, elem, span); - Expr::rt( + Expr::rs( "iterToByteVec", tail( vec![iter], @@ -2131,16 +2131,16 @@ fn collect<'tcx>( )?; let param = Param { name: "values".into(), - ty: Some(Type::Rt("Iter", vec![value_ty])), + ty: Some(Type::Rs("Iter", vec![value_ty])), }; let dropper = b.t.dropper(args.type_at(0), span); let collected = vec![iter, Expr::Lambda(vec![param], Box::new(values))]; Some(match std { - Std::Result => Expr::rt("iterCollectResult", tail(collected, vec![dropper])), - // The items' `None`, and the result's, each `rt.None` where `undefined` is a value. + Std::Result => Expr::rs("iterCollectResult", tail(collected, vec![dropper])), + // The items' `None`, and the result's, each `rs.None` where `undefined` is a value. _ => { let nones = [value, args.type_at(0)].map(|t| b.t.none(t)); - Expr::rt( + Expr::rs( "iterCollectOption", tail(collected, [vec![dropper], nones.into()].concat()), ) @@ -2155,7 +2155,7 @@ fn collect<'tcx>( Some(Std::String | Std::Cow) => { let drops = iter_drops(b, from, span); let texts = texts(b.t, iter, item); - Some(Expr::rt("stringFromStrings", tail(vec![texts], vec![drops]))) + Some(Expr::rs("stringFromStrings", tail(vec![texts], vec![drops]))) } _ => string_extend(b, Expr::Str(String::new()), iter, item, from, span), } @@ -2206,13 +2206,13 @@ pub(super) fn string_extend<'tcx>( "stringExtendChars" }; let drops = iter_drops(b, iter, span); - Some(Expr::rt(extend, tail(vec![s, texts(b.t, items, item)], vec![drops]))) + Some(Expr::rs(extend, tail(vec![s, texts(b.t, items, item)], vec![drops]))) } /// `items`, an iterator of `item`s, as one of the strings they are: a `Cow`'s text. fn texts<'tcx>(t: &Translator<'_, 'tcx>, items: Expr, item: Ty<'tcx>) -> Expr { match library::cow_str(t.tcx, item.peel_refs()) { - true => Expr::rt("iterMap", vec![items, Expr::Rt("strCowStr".into())]), + true => Expr::rs("iterMap", vec![items, Expr::Rs("strCowStr".into())]), false => items, } } @@ -2232,7 +2232,7 @@ pub(super) fn text_items<'tcx>(t: &Translator<'_, 'tcx>, item: Ty<'tcx>) -> Opti } } -/// How a `try_` fold's closure returning an `r` breaks: by `None`, and the `rt.None` that is +/// How a `try_` fold's closure returning an `r` breaks: by `None`, and the `rs.None` that is /// where it is, if it is an `Option`, or a `ControlFlow` held as one, and else by `Err`, if /// it is a `Result`, or a `ControlFlow` held as one. fn try_flow<'tcx>(b: &Body<'_, '_, 'tcx>, r: Ty<'tcx>) -> Option<(bool, Option)> { @@ -2250,7 +2250,7 @@ fn try_flow<'tcx>(b: &Body<'_, '_, 'tcx>, r: Ty<'tcx>) -> Option<(bool, Option(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr { flag(drops_iter(b, ty, span)) @@ -2264,7 +2264,7 @@ fn flag(on: bool) -> Expr { } } -/// How a runtime function takes an iterator of type `ty` by value, as `rt.Take` says: by +/// How a runtime function takes an iterator of type `ty` by value, as `rs.Take` says: by /// `next` unless std's `folds` it, and then by its own `fold`, or `undefined` for one that /// drops nothing, which it reads as `folded` steps it. pub(super) fn iter_take<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, folds: bool, span: Span) -> Expr { @@ -2278,7 +2278,7 @@ pub(super) fn iter_take<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, folds: b /// Whether a runtime function takes an iterator of type `ty` by value as std's consumers /// do, by its `fold` or its kind's own `count` and `last`, rather than as `folded` steps /// it: if it drops, refusing one it can't drop, as the crate's own drops through -/// `rt.iterFrom`, or holds one of the crate's own that `folds_own`. +/// `rs.iterFrom`, or holds one of the crate's own that `folds_own`. fn drops_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> bool { if !b.t.drops(ty) { return folds_own(b, ty); @@ -2289,7 +2289,7 @@ fn drops_iter<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> boo true } -/// `rt.iterToVec` of `iter`, an iterator of type `from`, collected into a `Vec` as +/// `rs.iterToVec` of `iter`, an iterator of type `from`, collected into a `Vec` as /// `collect_take` says std's reads it. It reserves as std's does for a `TrustedLen` /// iterator if `trusted`. pub(super) fn to_vec<'tcx>( @@ -2302,7 +2302,7 @@ pub(super) fn to_vec<'tcx>( ) -> Expr { let (take, by_index, src) = collect_take(b, from, elem, span); let size = size_of(b, elem, span); - Expr::rt( + Expr::rs( "iterToVec", tail( vec![iter], @@ -2318,7 +2318,7 @@ fn src_size(src: Option) -> Expr { } /// How std's `collect` of an iterator of type `from` into a `Vec` takes it, as -/// `rt.Take`, and whether by index, reading no item past its length. In place of the `Vec` +/// `rs.Take`, and whether by index, reading no item past its length. In place of the `Vec` /// its items come from, it reads a `TrustedRandomAccessNoCoerce` one by index and any other /// by `try_fold`, then drops it whole, as reading by `next` and then dropping it does but /// for a zip, whose `next` reads a side once past the other, its length reserved as a diff --git a/ts/src/lower/lend.rs b/ts/src/lower/lend.rs index e6979fc94..7e42bbf46 100644 --- a/ts/src/lower/lend.rs +++ b/ts/src/lower/lend.rs @@ -1,10 +1,10 @@ //! The references to `[u8; N]`s that cross between translated code and std. Such an array -//! is a `Uint8Array`, where a `&[u8; N]` is an `rt.ByteSlice` of its bytes, as a `&[u8]` +//! is a `Uint8Array`, where a `&[u8; N]` is an `rs.ByteSlice` of its bytes, as a `&[u8]` //! is, but std's mappings take and hand out a reference to an array as the array itself. //! So each `&[u8; N]` std makes of an array it holds, which it returns or hands a closure, //! is lent as a slice of it, and each std is given as a `&T` of a `T = [u8; N]` is given //! as a view of the slice's bytes. The function's generic signature tells such a -//! reference from one std takes as it is, which is an `rt.ByteSlice` on both sides: a `&T` +//! reference from one std takes as it is, which is an `rs.ByteSlice` on both sides: a `&T` //! where `T = [u8; N]`, not a `T` where `T = &[u8; N]`. use rustc_hir::def_id::DefId; @@ -313,7 +313,7 @@ pub fn holds_bytes_ref(ty: Ty<'_>) -> bool { /// `value`, a `ty` std's mapping hands out, whose type in std's generic code is `generic`, /// as translated code reads it: each `&[u8; N]` std made of an array it holds, which the -/// mapping hands out as the `Uint8Array`, an `rt.ByteSlice` of it. It shares the bytes, +/// mapping hands out as the `Uint8Array`, an `rs.ByteSlice` of it. It shares the bytes, /// which nothing writes through a `&`, and a `&mut` writes where std holds them. pub fn lend<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Expr { cross(b, generic, ty, value, Way::Lent, span) @@ -321,8 +321,8 @@ pub fn lend<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, v /// `value`, a `ty` translated code gives std's mapping as an input whose type in std's /// generic code is `generic`, as the mapping reads it: each `&[u8; N]` where it takes a -/// `&T`, which it reads, copies, and writes through as the array, an `rt.byteSliceView` -/// of the `rt.ByteSlice`. It shares the bytes for as long as the reference lives, so +/// `&T`, which it reads, copies, and writes through as the array, an `rs.byteSliceView` +/// of the `rs.ByteSlice`. It shares the bytes for as long as the reference lives, so /// whatever the mapping keeps of it reads and writes where the reference does. pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, value: Expr, span: Span) -> Expr { cross(b, generic, ty, value, Way::Given, span) @@ -333,7 +333,7 @@ pub fn give<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, v enum Way { /// To translated code, from the `Uint8Array` std holds: [`lend`]. Lent, - /// To std's mapping, from the `rt.ByteSlice` translated code holds: [`give`]. + /// To std's mapping, from the `rs.ByteSlice` translated code holds: [`give`]. Given, } @@ -359,13 +359,13 @@ fn cross<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, valu } if let (Some(g), Some(inner)) = (option_of(b.t, generic), option_of(b.t, ty)) { let f = cross_fn(b, g, inner, way, span); - return Expr::rt("optionMap", vec![value, f]); + return Expr::rs("optionMap", vec![value, f]); } if way == Way::Lent && let Some((Some(g), item)) = item(b.t, ty) { let f = cross_fn(b, g, item, way, span); - return Expr::rt("iterLend", vec![value, f]); + return Expr::rs("iterLend", vec![value, f]); } if let (ty::Tuple(generics), ty::Tuple(parts)) = (generic.kind(), ty.kind()) && value.is_path() @@ -384,7 +384,7 @@ fn cross_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, w if let ty::Ref(_, inner, _) = ty.kind() && super::byte_array(*inner) { - return Expr::Rt( + return Expr::Rs( match way { Way::Lent => "byteSliceFrom", Way::Given => "byteSliceView", @@ -408,7 +408,7 @@ fn cross_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, generic: Ty<'tcx>, ty: Ty<'tcx>, w /// `f`, a closure std calls with `params`, each generic and instantiated, given each as /// [`lend`] makes it. One that what the call returns holds, or that drops, which the -/// mapping may drop through what it is given, is `rt.lending`, `holds`, which clones and +/// mapping may drop through what it is given, is `rs.lending`, `holds`, which clones and /// drops as `f` does. pub fn lend_closure<'tcx>( b: &mut Body<'_, '_, 'tcx>, @@ -436,18 +436,18 @@ pub fn lend_closure<'tcx>( match (holds, called) { (true, Expr::Ident(name)) => { let make = Expr::Lambda(vec![Param { name, ty: None }], Box::new(lent)); - Expr::rt("lending", vec![f, make]) + Expr::rs("lending", vec![f, make]) } _ => lent, } } /// A function copying a `ty` out of what `Extend<&T>` and `Extend<(&K, &V)>` are given, -/// where each `[u8; N]` is the `rt.ByteSlice` a `&[u8; N]` is: `None` if a copy is the +/// where each `[u8; N]` is the `rs.ByteSlice` a `&[u8; N]` is: `None` if a copy is the /// value itself. pub fn copy_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Option { match ty.kind() { - _ if super::byte_array(ty) => Some(Expr::Rt("byteSliceToArray".into())), + _ if super::byte_array(ty) => Some(Expr::Rs("byteSliceToArray".into())), ty::Tuple(parts) if parts.iter().any(super::byte_array) => { let name = b.fresh("held"); let parts = (parts.iter().enumerate()) diff --git a/ts/src/lower/library.rs b/ts/src/lower/library.rs index bc3ad6b37..f875a471b 100644 --- a/ts/src/lower/library.rs +++ b/ts/src/lower/library.rs @@ -22,112 +22,112 @@ use crate::ts::{Expr, Stmt, StmtKind}; pub enum Std { /// `T | undefined`. Option, - /// `rt.Result`. + /// `rs.Result`. Result, - /// `rt.ByteVec` for bytes, an array otherwise. + /// `rs.ByteVec` for bytes, an array otherwise. Vec, /// A JS string. String, - /// What it owns, or an `rt.Borrowed` of what it borrows, or for bytes an `rt.ByteVec` - /// or an `rt.ByteSlice`. + /// What it owns, or an `rs.Borrowed` of what it borrows, or for bytes an `rs.ByteVec` + /// or an `rs.ByteSlice`. Cow, /// Its contents. Box, FromUtf8Error, Utf8Error, TryFromIntError, - /// `rt.ParseIntError`: `{ kind }`, its `IntErrorKind`. + /// `rs.ParseIntError`: `{ kind }`, its `IntErrorKind`. ParseIntError, - /// Why one of std's errors failed, as `rt.IntErrorKind` or `rt.CharErrorKind`: the + /// Why one of std's errors failed, as `rs.IntErrorKind` or `rs.CharErrorKind`: the /// variant's name. ErrorKind, - /// `rt.ParseBoolError`. + /// `rs.ParseBoolError`. ParseBoolError, - /// `rt.ParseCharError`: `{ kind }`, its `CharErrorKind`'s name. + /// `rs.ParseCharError`: `{ kind }`, its `CharErrorKind`'s name. ParseCharError, - /// `rt.FromUtf16Error`: `{ kind }`, its `FromUtf16ErrorKind`'s name. + /// `rs.FromUtf16Error`: `{ kind }`, its `FromUtf16ErrorKind`'s name. FromUtf16Error, - /// `rt.CharTryFromError`: why `char::try_from` a `u32` failed. + /// `rs.CharTryFromError`: why `char::try_from` a `u32` failed. CharTryFromError, - /// `rt.TryFromCharError`: why `u8::try_from` or `u16::try_from` a `char` failed. + /// `rs.TryFromCharError`: why `u8::try_from` or `u16::try_from` a `char` failed. TryFromCharError, - /// `rt.DecodeUtf16Error`: `{ code }`, the unpaired surrogate. + /// `rs.DecodeUtf16Error`: `{ code }`, the unpaired surrogate. DecodeUtf16Error, - /// `rt.Utf8Chunk`: `{ valid, invalid }`, never changed once made. + /// `rs.Utf8Chunk`: `{ valid, invalid }`, never changed once made. Utf8Chunk, ParseFloatError, TryFromFloatSecsError, - /// `rt.Formatter`. + /// `rs.Formatter`. Formatter, - /// `rt.Arguments`: what `format_args!` makes. + /// `rs.Arguments`: what `format_args!` makes. Arguments, - /// `rt.FmtError`. + /// `rs.FmtError`. FmtError, - /// The `Debug` builders: `rt.DebugStruct` and the like. + /// The `Debug` builders: `rs.DebugStruct` and the like. DebugStruct, DebugTuple, DebugList, /// What `assert_eq!` and `assert_ne!` compare by: its operator, as a string. AssertKind, - /// `rt.Arc`, counted: an `Arc` or an `Rc`, which one thread can't tell apart. + /// `rs.Arc`, counted: an `Arc` or an `Rc`, which one thread can't tell apart. Arc, - /// `rt.Weak`, of either. + /// `rs.Weak`, of either. Weak, - /// `rt.Mutex`, which is also its own guard. + /// `rs.Mutex`, which is also its own guard. Mutex, MutexGuard, /// What it holds, a lock's guard or value. PoisonError, - /// `rt.TryLockError`, tagged as `Bound` is. + /// `rs.TryLockError`, tagged as `Bound` is. TryLockError, - /// `rt.RefCell`: a `RefCell` or an `RwLock`, which one thread can't tell apart, and + /// `rs.RefCell`: a `RefCell` or an `RwLock`, which one thread can't tell apart, and /// also its own guard, shared or exclusive. RefCell, Ref, RefMut, - /// `rt.BorrowError` and `rt.BorrowMutError`: why `try_borrow` and `try_borrow_mut` failed. + /// `rs.BorrowError` and `rs.BorrowMutError`: why `try_borrow` and `try_borrow_mut` failed. BorrowError, BorrowMutError, - /// `rt.Cell`, a place holding its value: a `Cell`'s or an `UnsafeCell`'s. + /// `rs.Cell`, a place holding its value: a `Cell`'s or an `UnsafeCell`'s. Cell, - /// `rt.LocalKey`: a thread-local, a module's value. + /// `rs.LocalKey`: a thread-local, a module's value. LocalKey, - /// `rt.Atomic`, a place holding its `bool` or integer. + /// `rs.Atomic`, a place holding its `bool` or integer. Atomic, - /// `rt.AtomicOrdering`: its discriminant. + /// `rs.AtomicOrdering`: its discriminant. AtomicOrdering, - /// `rt.OnceCell` and `rt.OnceLock`: the `Option` each holds. + /// `rs.OnceCell` and `rs.OnceLock`: the `Option` each holds. OnceCell, OnceLock, - /// `rt.Once`, an `rt.OnceLock` of `true`, and `rt.OnceState`, the `Once` it reports on. + /// `rs.Once`, an `rs.OnceLock` of `true`, and `rs.OnceState`, the `Once` it reports on. Once, OnceState, - /// `rt.LazyCell` and `rt.LazyLock`: the function that makes the value, then the value. + /// `rs.LazyCell` and `rs.LazyLock`: the function that makes the value, then the value. LazyCell, LazyLock, - /// `rt.Waker`. + /// `rs.Waker`. Waker, - /// `rt.WakerVTable`: a waker's vtable, of its four functions. + /// `rs.WakerVTable`: a waker's vtable, of its four functions. WakerVTable, - /// `rt.RawWaker`: a waker's data and vtable. + /// `rs.RawWaker`: a waker's data and vtable. RawWaker, - /// `rt.Context`: its waker. + /// `rs.Context`: its waker. Context, - /// `rt.Poll`: `T` itself, or `rt.Pending`. + /// `rs.Poll`: `T` itself, or `rs.Pending`. Poll, /// Its pointer, or the value `pin!` pins in a `PinMacroHelper`. Pin, - /// `rt.PollFn`: `poll_fn`'s future, which owns its function. + /// `rs.PollFn`: `poll_fn`'s future, which owns its function. PollFn, - /// `future::Pending`: `rt.NEVER`, a future never ready. + /// `future::Pending`: `rs.NEVER`, a future never ready. Pending, - /// `rt.Ready`: `future::ready`'s future, which owns its value until a poll takes it. + /// `rs.Ready`: `future::ready`'s future, which owns its value until a poll takes it. Ready, - /// `rt.Range`, an iterator with `start` and `end` fields. + /// `rs.Range`, an iterator with `start` and `end` fields. Range, - /// `rt.RangeInclusive`. + /// `rs.RangeInclusive`. RangeInclusive, - /// `rt.Peekable`, an iterator with `peek`. + /// `rs.Peekable`, an iterator with `peek`. Peekable, /// What `?` branches on, as MIR spells it, and what else makes one: see [`Flow`]. ControlFlow, @@ -138,7 +138,7 @@ pub enum Std { RangeFull, /// `..=end`: `{ end, inclusive: true }`. RangeToInclusive, - /// `rt.RangeBound`, tagged as the crate's own enums are: `{ tag: "Included", _0 }`. + /// `rs.RangeBound`, tagged as the crate's own enums are: `{ tag: "Included", _0 }`. Bound, /// What it holds, which orders the other way. Reverse, @@ -150,7 +150,7 @@ pub enum Std { Saturating, /// What it holds, which it only marks as safe to unwind through. AssertUnwindSafe, - /// A `format_args!` argument: a function writing its value, `rt.Fmt`. + /// A `format_args!` argument: a function writing its value, `rs.Fmt`. Argument, /// A raw pointer to its pointee, as `pointer` has it. NonNull, @@ -160,51 +160,51 @@ pub enum Std { ManuallyDrop, /// No value: `never`. Infallible, - /// `rt.HashMap`, and `rt.HashSet`, a map to `undefined`. + /// `rs.HashMap`, and `rs.HashSet`, a map to `undefined`. HashMap, HashSet, - /// `rt.BTreeMap`, and `rt.BTreeSet`, a map to `undefined`. + /// `rs.BTreeMap`, and `rs.BTreeSet`, a map to `undefined`. BTreeMap, BTreeSet, - /// `rt.VecDeque`, a ring buffer. + /// `rs.VecDeque`, a ring buffer. VecDeque, - /// `rt.LinkedList`, nodes linked both ways. + /// `rs.LinkedList`, nodes linked both ways. LinkedList, - /// `rt.BinaryHeap`, std's max-heap in an array, and `rt.PeekMut`, its greatest element lent. + /// `rs.BinaryHeap`, std's max-heap in an array, and `rs.PeekMut`, its greatest element lent. BinaryHeap, PeekMut, - /// `rt.Entry`: a map's `Entry`, `OccupiedEntry`, or `VacantEntry`. + /// `rs.Entry`: a map's `Entry`, `OccupiedEntry`, or `VacantEntry`. Entry, - /// `rt.HashTable`: hashbrown's `HashTable`, an `rt.HashMap` of its items by the hash its + /// `rs.HashTable`: hashbrown's `HashTable`, an `rs.HashMap` of its items by the hash its /// caller gives. HashTable, - /// `rt.TableEntry`: a `HashTable`'s `Entry`, `OccupiedEntry`, `VacantEntry`, or `AbsentEntry`. + /// `rs.TableEntry`: a `HashTable`'s `Entry`, `OccupiedEntry`, `VacantEntry`, or `AbsentEntry`. TableEntry, - /// `rt.Ordering`: its discriminant, -1, 0, or 1. + /// `rs.Ordering`: its discriminant, -1, 0, or 1. Ordering, - /// `rt.Hasher`: `DefaultHasher`, which hash collections hash their keys with. + /// `rs.Hasher`: `DefaultHasher`, which hash collections hash their keys with. Hasher, - /// `rt.RandomState`: the keys of the `DefaultHasher` it builds, never changed once made. + /// `rs.RandomState`: the keys of the `DefaultHasher` it builds, never changed once made. RandomState, /// `BuildHasherDefault`, which holds nothing and builds its `Hasher` by `Default`. BuildHasherDefault, - /// `rt.Duration`: its seconds and nanoseconds, never changed once made. + /// `rs.Duration`: its seconds and nanoseconds, never changed once made. Duration, - /// `rt.Layout`: its size and alignment, never changed once made. + /// `rs.Layout`: its size and alignment, never changed once made. Layout, - /// `rt.Location`: a panic's file, line, and column, never changed once made. + /// `rs.Location`: a panic's file, line, and column, never changed once made. Location, - /// `rt.PanicHookInfo`: what a panic hook is given, never changed once made. + /// `rs.PanicHookInfo`: what a panic hook is given, never changed once made. PanicHookInfo, - /// `rt.LayoutError`. + /// `rs.LayoutError`. LayoutError, - /// `rt.TryReserveError`: the layout whose allocation failed, if any, never changed once made. + /// `rs.TryReserveError`: the layout whose allocation failed, if any, never changed once made. TryReserveError, - /// `bytes::Bytes`: an `rt.ByteSlice`, as `&[u8]` is. + /// `bytes::Bytes`: an `rs.ByteSlice`, as `&[u8]` is. Bytes, - /// `bytes::BytesMut`: `rt.BytesMut`, a window of storage it shares with what it splits off. + /// `bytes::BytesMut`: `rs.BytesMut`, a window of storage it shares with what it splits off. BytesMut, - /// `rand::rngs::ThreadRng`: `rt.ThreadRng`, which holds no state. + /// `rand::rngs::ThreadRng`: `rs.ThreadRng`, which holds no state. ThreadRng, } @@ -408,11 +408,11 @@ impl Std { /// applied to, which breaks with what can only be its `Err` or `None`. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Flow { - /// Breaking with a `Result`: the `rt.Result` `?` was applied to. + /// Breaking with a `Result`: the `rs.Result` `?` was applied to. Result, /// Breaking with an `Option`: the `Option` `?` was applied to. Option, - /// Any other: an `rt.Result`, `Ok` to continue and `Err` to break. + /// Any other: an `rs.Result`, `Ok` to continue and `Err` to break. Other, } @@ -462,7 +462,7 @@ pub fn pinned(tcx: TyCtxt<'_>, did: DefId) -> bool { tcx.is_diagnostic_item(rustc_span::Symbol::intern("PhantomPinned"), did) } -/// Whether `did` is `iter::Empty`, an `rt.Iter` that holds nothing. +/// Whether `did` is `iter::Empty`, an `rs.Iter` that holds nothing. pub fn empty_iter(tcx: TyCtxt<'_>, did: DefId) -> bool { is_std(tcx, did) && std_path(tcx, did) == ["iter", "sources", "empty", "Empty"] } @@ -498,7 +498,7 @@ pub fn string<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { } } -/// Whether `ty` is a `Cow`: an `rt.StrCow`, the string it owns or the `rt.Borrowed` +/// Whether `ty` is a `Cow`: an `rs.StrCow`, the string it owns or the `rs.Borrowed` /// one it borrows. pub fn cow_str<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { cow_borrowed(tcx, ty).is_some_and(|t| t.is_str()) @@ -512,7 +512,7 @@ pub fn textual<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> bool { /// `value`, of type `ty`, as the JS string it is or, for a `Cow`, derefs to. pub fn text<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, value: Expr) -> Expr { match cow_str(tcx, ty) { - true => Expr::rt("strCowStr", vec![value]), + true => Expr::rs("strCowStr", vec![value]), false => value, } } @@ -606,26 +606,26 @@ pub fn cow_slice<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option> { } } -/// Whether `borrowed`, what a `Cow` borrows, is bytes, which it keeps as an `rt.ByteSlice`. +/// Whether `borrowed`, what a `Cow` borrows, is bytes, which it keeps as an `rs.ByteSlice`. fn cow_bytes(borrowed: Ty<'_>) -> bool { matches!(borrowed.kind(), ty::Slice(elem) if byte(*elem)) } -/// What `cow`, a `Cow` of `borrowed`, derefs to: an `rt.ByteSlice` of bytes, an array, or +/// What `cow`, a `Cow` of `borrowed`, derefs to: an `rs.ByteSlice` of bytes, an array, or /// a string. pub fn cow_deref(cow: Expr, borrowed: Ty<'_>) -> Expr { match borrowed.kind() { - ty::Str => Expr::rt("strCowStr", vec![cow]), - _ if cow_bytes(borrowed) => Expr::rt("byteCowSlice", vec![cow]), - _ => Expr::rt("cowSlice", vec![cow]), + ty::Str => Expr::rs("strCowStr", vec![cow]), + _ if cow_bytes(borrowed) => Expr::rs("byteCowSlice", vec![cow]), + _ => Expr::rs("cowSlice", vec![cow]), } } /// A `Cow` of `borrowed` made by its variant `variant` of `value`: what it owns, or what -/// it borrows, wrapped in an `rt.Borrowed` unless it is bytes. +/// it borrows, wrapped in an `rs.Borrowed` unless it is bytes. pub fn cow_made(borrowed: Ty<'_>, variant: rustc_abi::VariantIdx, value: Expr) -> Expr { match variant.index() == 0 && !cow_bytes(borrowed) { - true => Expr::New(Box::new(Expr::Rt("Borrowed".into())), vec![value]), + true => Expr::New(Box::new(Expr::Rs("Borrowed".into())), vec![value]), false => value, } } @@ -637,7 +637,7 @@ pub fn cow_borrows(cow: Expr, borrowed: Ty<'_>) -> Expr { true => "ByteSlice", false => "Borrowed", }; - cow.binary("instanceof", Expr::Rt(class.into())) + cow.binary("instanceof", Expr::Rs(class.into())) } /// The path of a std item within its crate, as `["slice", "iter", "Iter"]`; empty for @@ -1031,7 +1031,7 @@ fn discards(owner: &str, name: &str) -> Option<&'static [usize]> { | ("RangeInclusive", "new") | ("panic", "panic_any" | "resume_unwind") | ("rt", "begin_panic") - // The hook it keeps, and the one it replaces, which `rt.setHook` drops. + // The hook it keeps, and the one it replaces, which `rs.setHook` drops. | ("panicking", "set_hook") // Each element moves into the closure. | ("array", "map") => &[], @@ -1113,7 +1113,7 @@ pub fn maps_guard(owner: &str, name: &str) -> bool { } /// Whether the mapping of `owner::name` tells an `Option`'s `None` from its `Some` where -/// the `None` is `rt.None`, as the runtime's functions that take `None` to be `undefined` +/// the `None` is `rs.None`, as the runtime's functions that take `None` to be `undefined` /// do not. fn takes_none(owner: &str, name: &str) -> bool { none_last(owner, name) @@ -1145,7 +1145,7 @@ fn takes_none(owner: &str, name: &str) -> bool { } /// Whether the runtime function `owner::name` maps to takes the `None` of the `Option` it -/// makes or reads, where that is `rt.None`, last: after what drops its operands. +/// makes or reads, where that is `rs.None`, last: after what drops its operands. pub(super) fn none_last(owner: &str, name: &str) -> bool { matches!( (owner, name), @@ -1181,7 +1181,7 @@ pub(super) fn none_last(owner: &str, name: &str) -> bool { ) } -/// The type of the first `Some` whose `Option`'s `None` is `rt.None`, of those in the +/// The type of the first `Some` whose `Option`'s `None` is `rs.None`, of those in the /// signature and bounds of the function `call` calls, over its type arguments: what the /// mapping of a std function would make or read with `undefined` for `None`. pub(super) fn sentinel_option<'tcx>(t: &Translator<'_, 'tcx>, call: &Call<'tcx>) -> Option> { @@ -1261,9 +1261,9 @@ pub fn called_through<'tcx>( /// it and nothing else it takes by value drops, or the mapping discards none of it, as then /// nothing it drops is ordered against it; dropped where `discarded` says, by the type's /// index among the call's type arguments; or else leaked. A closure that `Fn` or `FnMut` -/// call, given to one that calls it through `FnOnce`, becomes `rt.once` of it, which drops +/// call, given to one that calls it through `FnOnce`, becomes `rs.once` of it, which drops /// it after the call, as rustc's shim does. A reference to one is the closure in JS, so an -/// iterator, which drops what it holds, keeps `rt.lent` of it instead. +/// iterator, which drops what it holds, keeps `rs.lent` of it instead. fn called_closures<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, @@ -1298,8 +1298,8 @@ fn called_closures<'tcx>( } let mentions = |t: Ty<'tcx>| t.walk().any(|a| a.as_type() == Some(input)); if mentions(output) { - // An `rt.Iter` drops the closure it holds, an `rt.PollFn` one it owns, and an - // `rt.LazyCell` or a `OnceWith` one it never calls, and one it calls through + // An `rs.Iter` drops the closure it holds, an `rs.PollFn` one it owns, and an + // `rs.LazyCell` or a `OnceWith` one it never calls, and one it calls through // `FnOnce` as it does. let holder = match output.kind() { ty::Adt(adt, args) if args.types().any(|a| a == input) => Some(adt.did()), @@ -1311,10 +1311,10 @@ fn called_closures<'tcx>( || holder.is_some_and(|did| std_path(tcx, did) == ["iter", "sources", "once_with", "OnceWith"]); if lent && iter && i < args.len() { let f = std::mem::replace(&mut args[i], Expr::undefined()); - args[i] = Expr::rt("lent", vec![f]); + args[i] = Expr::rs("lent", vec![f]); } else if lazy && !lent && called != ty::ClosureKind::FnOnce && i < args.len() { let f = std::mem::replace(&mut args[i], Expr::undefined()); - args[i] = Expr::rt("once", vec![f]); + args[i] = Expr::rs("once", vec![f]); } else if !lent && !iter && !lazy && holds != Some(Std::PollFn) { closures.leaked = closures.leaked.or(Some(ty)); } @@ -1347,7 +1347,7 @@ fn called_closures<'tcx>( } if bound == ty::ClosureKind::FnOnce && called != ty::ClosureKind::FnOnce && i < args.len() { let f = std::mem::replace(&mut args[i], Expr::undefined()); - args[i] = Expr::rt("once", vec![f]); + args[i] = Expr::rs("once", vec![f]); } } closures @@ -1390,7 +1390,7 @@ fn dropping_operand<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>) -> Opti .map(|(_, ty)| ty) } -/// Where std's `#[track_caller]` panic being mapped is, as `rt.panic` takes it after its +/// Where std's `#[track_caller]` panic being mapped is, as `rs.panic` takes it after its /// message, in a program with a panic hook: nothing in one without. fn hook_at(b: &Body<'_, '_, '_>) -> Vec { match b.t.hooked { @@ -1444,7 +1444,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec { return Some(b.err( call.span, - format!("`{owner}::{name}` of `Option<{inner}>`, whose `None` is `rt.None`, which is not supported yet"), + format!("`{owner}::{name}` of `Option<{inner}>`, whose `None` is `rs.None`, which is not supported yet"), )); } let discarded = discards(&owner, &name); @@ -1478,7 +1478,7 @@ pub fn call<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec } // The last parameter drops first, as a function's do. for f in closures.spent.into_iter().rev() { - e = Expr::rt("dropAfter", vec![f, Expr::Lambda(Vec::new(), Box::new(e))]); + e = Expr::rs("dropAfter", vec![f, Expr::Lambda(Vec::new(), Box::new(e))]); } Some(e) } @@ -1562,7 +1562,7 @@ fn mapping<'tcx>( if to == from || some { return Some(value); } - // One between strings keeps the text, and a `&mut str` is the `rt.Place` of its text. + // One between strings keeps the text, and a `&mut str` is the `rs.Place` of its text. if string(tcx, to) && string(tcx, from.peel_refs()) { return Some(b.t.pointee_value(targ(gargs, 1), value)); } @@ -1584,7 +1584,7 @@ fn mapping<'tcx>( if !from.is_ref() { b.t.string_bytes(); } - return Some(Expr::rt( + return Some(Expr::rs( "stringIntoBytes", vec![b.t.pointee_value(targ(gargs, 1), value)], )); @@ -1612,9 +1612,9 @@ fn mapping<'tcx>( && b.t.std_of(to) == Some(Std::Vec) && b.t.std_of(from) == Some(Std::VecDeque) { - let v = Expr::rt("dequeToVec", vec![value]); + let v = Expr::rs("dequeToVec", vec![value]); return Some(match byte(vargs.type_at(0)) { - true => Expr::rt("byteVecFromVec", vec![v]), + true => Expr::rs("byteVecFromVec", vec![v]), false => v, }); } @@ -1637,7 +1637,7 @@ fn mapping<'tcx>( Some(vec_boxed(cow_cloned(b, "IntoOwned", value, elem, span), elem)) } // A `Box`'s bytes. - _ if string(tcx, from) => Some(Expr::rt("stringAsBytes", vec![value])), + _ if string(tcx, from) => Some(Expr::rs("stringAsBytes", vec![value])), _ => None, }; } @@ -1656,7 +1656,7 @@ fn mapping<'tcx>( || args.type_at(0).is_sized(tcx, b.t.typing_env())) && !super::byte_array(args.type_at(0)) { - return Some(Expr::New(Box::new(Expr::Rt("Arc".into())), vec![value])); + return Some(Expr::New(Box::new(Expr::Rs("Arc".into())), vec![value])); } // An error, boxed as a `dyn Error`, which `?` converts it by. One of a string boxes // std's own private error type. @@ -1691,7 +1691,7 @@ fn mapping<'tcx>( b.convert(value, from, to, span, out) } // A scalar value, but not a surrogate. - ("char", "from_u32") => Expr::rt("charFromU32", args), + ("char", "from_u32") => Expr::rs("charFromU32", args), ("TryFrom", "try_from") | ("TryInto", "try_into") => { let (to, from) = match owner.as_str() { "TryFrom" => (targ(gargs, 0), targ(gargs, 1)), @@ -1704,7 +1704,7 @@ fn mapping<'tcx>( { let mut values = args; let value = b.convert(values.pop()?, from, to, span, out); - return Some(Expr::rt("Ok", vec![value])); + return Some(Expr::rs("Ok", vec![value])); } // A boxed slice or a `Vec` of `N` elements is a boxed array of them, and else // itself again. @@ -1727,20 +1727,20 @@ fn mapping<'tcx>( }; // The bytes keep their buffer, as std keeps the allocation. let array = match byte(*elem) { - true => Expr::rt("byteSliceView", vec![boxed]), + true => Expr::rs("byteSliceView", vec![boxed]), false => boxed, }; return Some(Expr::Cond( Box::new(length.binary("===", Expr::lit(n.to_string()))), - Box::new(Expr::rt("Ok", vec![array])), - Box::new(Expr::rt("Err", vec![from_value])), + Box::new(Expr::rs("Ok", vec![array])), + Box::new(Expr::rs("Err", vec![from_value])), )); } if to.is_char() && from == tcx.types.u32 { - return Some(Expr::rt("charTryFrom", args)); + return Some(Expr::rs("charTryFrom", args)); } if from.is_char() && (to == tcx.types.u8 || to == tcx.types.u16) { - return Some(Expr::rt(format!("{to}TryFromChar"), args)); + return Some(Expr::rs(format!("{to}TryFromChar"), args)); } let (Some(int), Some(_)) = (Int::of(to), Int::of(from)) else { return None; @@ -1830,12 +1830,12 @@ fn mapping<'tcx>( let values = args; match int.big() { true => int.method(name.as_str(), values), - false => Expr::rt(if name == "max" { "max" } else { "min" }, values), + false => Expr::rs(if name == "max" { "max" } else { "min" }, values), } } ("Ord", "clamp") if let Some(int) = Int::of(targ(gargs, 0)) => match int.big() { true => int.method("clamp", args), - false => Expr::rt("clamp", args), + false => Expr::rs("clamp", args), }, ("Clone", "clone") => { let ty = targ(gargs, 0); @@ -1843,10 +1843,10 @@ fn mapping<'tcx>( let value = values.into_iter().next()?; match ty.kind() { ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) && byte(args.type_at(0)) => { - Expr::rt("byteVecFrom", vec![Expr::rt("byteVecView", vec![value])]) + Expr::rs("byteVecFrom", vec![Expr::rs("byteVecView", vec![value])]) } ty::Adt(..) if string(tcx, ty) => value, - ty::Adt(..) if cow_str(tcx, ty) => Expr::rt("strCowClone", vec![value]), + ty::Adt(..) if cow_str(tcx, ty) => Expr::rs("strCowClone", vec![value]), ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Vec) => { return Some(vec_clone(b, value.member("items"), args.type_at(0), span)); } @@ -1857,7 +1857,7 @@ fn mapping<'tcx>( } ty::Tuple(tys) if !clone_copies(b.t, b.t.typing_env_pub(), ty) => { let clones = tys.iter().map(|t| super::collections::clone_fn(b, t, span)).collect(); - Expr::rt("tupleClone", vec![value, Expr::Array(clones)]) + Expr::rs("tupleClone", vec![value, Expr::Array(clones)]) } _ if let Some(elem) = box_slice(tcx, ty) => return slice_boxed(b, value, elem, span), // A box, a `ManuallyDrop`, or a `Reverse` is what it holds, cloned. @@ -1877,7 +1877,7 @@ fn mapping<'tcx>( } } ty::Adt(adt, _) if Std::of(tcx, adt.did()) == Some(Std::FromUtf8Error) => { - Expr::rt("fromUtf8ErrorClone", vec![value]) + Expr::rs("fromUtf8ErrorClone", vec![value]) } // Never changed once made. ty::Adt(adt, _) @@ -1891,13 +1891,13 @@ fn mapping<'tcx>( // Another that holds nothing. ty::Adt(adt, _) if empty_iter(tcx, adt.did()) => b.zero_sized_std(ty, Vec::new(), span).ok()?, // Through the reference, a slice of the bytes. - _ if super::byte_array(ty) => Expr::rt("byteSliceToArray", vec![value]), + _ if super::byte_array(ty) => Expr::rs("byteSliceToArray", vec![value]), _ if b.t.std_iter(ty) => return super::iter::clone(b, ty, value, span), ty::Closure(def_id, _) | ty::CoroutineClosure(def_id, _) if !clone_shares(b.t, b.t.typing_env_pub(), ty) => { b.t.clone_closure(*def_id); - Expr::rt("closureClone", vec![value]) + Expr::rs("closureClone", vec![value]) } _ if clone_shares(b.t, b.t.typing_env_pub(), ty) => value, _ if clone_copies(b.t, b.t.typing_env_pub(), ty) => b.t.copied(value, ty, span), @@ -1912,10 +1912,10 @@ fn mapping<'tcx>( ("Option", "is_none") => args.pop()?.binary("===", b.t.none(targ(gargs, 0))), ("Option", "as_ref" | "as_mut") => args.pop()?, // The payload, if any, as a slice of one, as `slice::from_ref` makes it. - ("Option", "as_slice") if byte(targ(gargs, 0)) => Expr::rt("byteOptionAsSlice", args), + ("Option", "as_slice") if byte(targ(gargs, 0)) => Expr::rs("byteOptionAsSlice", args), ("Option", "as_slice") => { args.extend(b.t.none_arg(targ(gargs, 0))); - Expr::rt("optionAsSlice", args) + Expr::rs("optionAsSlice", args) } // A box is what it holds. ("Option", "as_deref_mut") if targ(gargs, 0).is_box() => args.pop()?, @@ -1971,7 +1971,7 @@ fn mapping<'tcx>( }; let mut values = args; values.push(b.fmt_fn(fmt::Trait::Debug, shown, span)); - Expr::rt_of("result", method).call(values) + Expr::rs_of("result", method).call(values) } ("ControlFlow", "is_continue" | "is_break") => Flow::test(b.t, gargs, args.pop()?, name == "is_continue"), @@ -1981,11 +1981,11 @@ fn mapping<'tcx>( ("RangeInclusive", "new") if range => { let mut values = args; values.extend(self_ty().and_then(|t| range_step(tcx, t, true))); - Expr::New(Box::new(Expr::Rt("RangeInclusive".into())), values) + Expr::New(Box::new(Expr::Rs("RangeInclusive".into())), values) } ("Range" | "RangeInclusive", "start" | "end") | ("RangeInclusive", "into_inner") if range => { let of = range_of(inherent_std(tcx, call.def_id)?)?; - Expr::rt_of(of, &super::camel(&name)).call(args) + Expr::rs_of(of, &super::camel(&name)).call(args) } // Of bounds JS compares as Rust does, by `<` and `<=`, against an item of their type. ("Range" | "RangeInclusive", "is_empty") | (_, "contains") @@ -1993,7 +1993,7 @@ fn mapping<'tcx>( && let Some(bound) = compared(tcx, targ(gargs, 0)) && (name == "is_empty" || compared(tcx, targ(gargs, 1)) == Some(bound)) => { - Expr::rt_of(of, &super::camel(&name)).call(args) + Expr::rs_of(of, &super::camel(&name)).call(args) } ("RangeBounds", "contains") if compared(tcx, targ(gargs, 1)).is_some_and(|bound| compared(tcx, targ(gargs, 2)) == Some(bound)) => @@ -2001,15 +2001,15 @@ fn mapping<'tcx>( let range = targ(gargs, 0).peel_refs(); match b.t.std_of(range) { Some(Std::RangeFull) => Expr::lit("true"), - Some(std) => Expr::rt_of(range_of(std)?, "contains").call(args), - None if super::collections::plain_bounds(b.t, range) => Expr::rt("boundsContains", args), + Some(std) => Expr::rs_of(range_of(std)?, "contains").call(args), + None if super::collections::plain_bounds(b.t, range) => Expr::rs("boundsContains", args), None => return None, } } // A `NonZero` is its integer. ("NonZero", "get") => args.pop()?, - ("NonZero", "new") => Expr::rt("nonZero", args), + ("NonZero", "new") => Expr::rs("nonZero", args), // Its integer's, of each width's own impl, which has no type argument to read the // integer from, but for the bits it always has. ("NonZero", _) => { @@ -2038,7 +2038,7 @@ fn mapping<'tcx>( let bound = b.t.sig(call.def_id, gargs).output(); match super::collections::clone_fn(b, targ(gargs, 0), span) { Expr::Lit(l) if l == "undefined" => b.t.copied(value, bound, span), - clone => Expr::rt("boundMap", vec![value, clone]), + clone => Expr::rs("boundMap", vec![value, clone]), } } ("Bound", "as_ref") => args.pop()?, @@ -2065,14 +2065,14 @@ fn mapping<'tcx>( } else { "rangeInclusiveEndBound" }; - return Some(Expr::As(Box::new(Expr::rt(f, vec![r])), ts)); + return Some(Expr::As(Box::new(Expr::rs(f, vec![r])), ts)); } _ => return None, }; tagged(variant, field.map(|f| r.member(f)), ts) } - // Slices, whose byte functions take an `rt.ByteSlice`. + // Slices, whose byte functions take an `rs.ByteSlice`. ("slice", "len") => super::mir::slice_member(args.pop()?, "length"), ("slice", "is_empty") => super::mir::slice_member(args.pop()?, "length").binary("===", Expr::lit("0")), ("slice", "split_first" | "split_at" | "split_at_checked" | "first" | "get") @@ -2139,7 +2139,7 @@ fn mapping<'tcx>( ), false => rt2(args, "slice", &super::camel(&name)), }, - ("Split", "as_slice") => Expr::rt("splitAsSlice", args), + ("Split", "as_slice") => Expr::rs("splitAsSlice", args), // Halves of bytes are views already, and of other values the runtime's views. ("slice", "split_at_mut" | "split_at_mut_checked") => match byte(targ(gargs, 0)) { true => rt2(args, "byteSlice", &super::camel(&name.replace("_mut", ""))), @@ -2155,7 +2155,7 @@ fn mapping<'tcx>( } }, ("ChunksExact" | "RChunksExact", "remainder") | ("ChunksExactMut" | "RChunksExactMut", "into_remainder") => { - Expr::rt("partsRemainder", args) + Expr::rs("partsRemainder", args) } // The first `N` elements are `get(..N)`, and split off, `split_at_checked(N)`. A part // of bytes is a view already, and one of other values lent mutably the runtime's view. @@ -2195,7 +2195,7 @@ fn mapping<'tcx>( { let value = args.pop()?; match byte(targ(gargs, 0)) { - true => Expr::rt( + true => Expr::rs( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![value])], ), @@ -2225,7 +2225,7 @@ fn mapping<'tcx>( let [s, x] = <[Expr; 2]>::try_from(args).ok()?; let s = elements(s, Ty::new_slice(tcx, elem)); let cmp = super::collections::cmp_fn(b, elem, false, span); - Expr::rt("sliceBinarySearch", vec![s, x, cmp]) + Expr::rs("sliceBinarySearch", vec![s, x, cmp]) } // std's same search by the closure's `Ordering`, by `Ord::cmp` of the key it makes // with `b`, or by whether `pred` holds. @@ -2234,13 +2234,13 @@ fn mapping<'tcx>( let mut values = args; values[0] = elements(values[0].clone(), Ty::new_slice(tcx, elem)); match name.as_str() { - "binary_search_by" => Expr::rt("sliceBinarySearchBy", values), - "partition_point" => Expr::rt("slicePartitionPoint", values), + "binary_search_by" => Expr::rs("sliceBinarySearchBy", values), + "partition_point" => Expr::rs("slicePartitionPoint", values), _ => { let key = targ(gargs, 1); values.push(super::collections::cmp_fn(b, key, false, span)); let drop = b.t.dropper(key, span); - Expr::rt("sliceBinarySearchByKey", super::iter::tail(values, vec![drop])) + Expr::rs("sliceBinarySearchByKey", super::iter::tail(values, vec![drop])) } } } @@ -2259,7 +2259,7 @@ fn mapping<'tcx>( return Some(slice.method("fill", values)); } // Its own droppers, before what clones over a slot. - return Some(Expr::rt("sliceFill", [values, fns].concat())); + return Some(Expr::rs("sliceFill", [values, fns].concat())); } ("slice", "fill_with" | "rotate_left" | "rotate_right") => match byte(targ(gargs, 0)) { true => rt2(args, "byteSlice", &super::camel(&name)), @@ -2275,7 +2275,7 @@ fn mapping<'tcx>( } let mut values = args; values.extend(b.t.copy_fn(elem, span)); - Expr::rt("sliceCopyFromSlice", values) + Expr::rs("sliceCopyFromSlice", values) } // The slice it wrote, which JS holds as what a `MaybeUninit` holds. ("slice", "write_copy_of_slice") => { @@ -2287,7 +2287,7 @@ fn mapping<'tcx>( false => { let mut values = vec![dst.clone(), src]; values.extend(b.t.copy_fn(elem, span)); - Expr::rt("sliceCopyFromSlice", values) + Expr::rs("sliceCopyFromSlice", values) } }; out.push(StmtKind::Expr(copy).at(None)); @@ -2299,10 +2299,10 @@ fn mapping<'tcx>( let fns = clone_from_fns(b, targ(gargs, 0), span); // What clones one, which the runtime takes as `undefined` where it is the value. values.extend(fns.is_empty().then(Expr::undefined)); - return Some(Expr::rt("sliceCloneFromSlice", [values, fns].concat())); + return Some(Expr::rs("sliceCloneFromSlice", [values, fns].concat())); } ("PartialEq", "eq") if byte_slice(targ(gargs, 0)) && byte_slice(targ(gargs, 1)) => { - Expr::rt("byteSliceEq", args) + Expr::rs("byteSliceEq", args) } ("slice", "to_vec") => slice_to_vec(b, args.pop()?, targ(gargs, 0), span), ("slice", "last" | "swap") => match byte(targ(gargs, 0)) { @@ -2314,10 +2314,10 @@ fn mapping<'tcx>( let elem = targ(gargs, 0); let [s, x] = <[Expr; 2]>::try_from(args).ok()?; match byte(elem) { - true => Expr::rt("byteSliceView", vec![s]).method("includes", vec![x]), + true => Expr::rs("byteSliceView", vec![s]).method("includes", vec![x]), false => { let eq = super::collections::eq_fn(b, elem, span); - Expr::rt("sliceContains", vec![s, x, eq]) + Expr::rs("sliceContains", vec![s, x, eq]) } } } @@ -2334,7 +2334,7 @@ fn mapping<'tcx>( // A typed array sorts its numbers by value, and equal bytes are alike. "sort" | "sort_unstable" if byte(elem) => return Some(s.method("sort", Vec::new())), "sort" | "sort_unstable" => super::collections::test_fn(b, elem, "lt", span), - "sort_by" | "sort_unstable_by" => Expr::rt("cmpLt", vec![values.next()?]), + "sort_by" | "sort_unstable_by" => Expr::rs("cmpLt", vec![values.next()?]), _ => { let key = targ(gargs, 1); if b.t.drops(key) { @@ -2344,7 +2344,7 @@ fn mapping<'tcx>( )); } let lt = super::collections::test_fn(b, key, "lt", span); - Expr::rt("keyLt", vec![values.next()?, lt]) + Expr::rs("keyLt", vec![values.next()?, lt]) } }; let mut values = vec![s, less]; @@ -2352,9 +2352,9 @@ fn mapping<'tcx>( match name.contains("unstable") { true => { values.push(Expr::lit(b.t.is_copy(elem).to_string())); - Expr::rt("sliceSortUnstable", values) + Expr::rs("sliceSortUnstable", values) } - false => Expr::rt("sliceSort", values), + false => Expr::rs("sliceSort", values), } } // By `sort_unstable` of each key `f` makes paired with its index, a `usize`, as a @@ -2371,7 +2371,7 @@ fn mapping<'tcx>( let copy = Expr::lit(b.t.is_copy(key).to_string()); let owns = Expr::lit(b.t.drops(targ(gargs, 2)).to_string()); let drop = b.t.dropper(key, span); - Expr::rt( + Expr::rs( "sliceSortByCachedKey", super::iter::tail(vec![s, f, lt, size, freeze, copy], vec![owns, drop]), ) @@ -2384,23 +2384,23 @@ fn mapping<'tcx>( let mut values = args; values[0] = elements(values[0].clone(), Ty::new_slice(tcx, elem)); values.push(super::collections::test_fn(b, elem, "le", span)); - Expr::rt("sliceIsSorted", values) + Expr::rs("sliceIsSorted", values) } ("slice", "is_sorted_by" | "is_sorted_by_key") => { let elem = targ(gargs, 0); let mut values = args.into_iter(); let slice = elements(values.next()?, Ty::new_slice(tcx, elem)); - let items = super::iter::by_ref(Expr::rt("iterSlice", vec![slice]), elem); + let items = super::iter::by_ref(Expr::rs("iterSlice", vec![slice]), elem); let f = values.next()?; let (items, compare, drop) = match name.as_str() { "is_sorted_by" => (items, f, Expr::undefined()), _ => { let key = targ(gargs, 2); let le = super::collections::test_fn(b, key, "le", span); - (Expr::rt("iterMap", vec![items, f]), le, b.t.dropper(key, span)) + (Expr::rs("iterMap", vec![items, f]), le, b.t.dropper(key, span)) } }; - Expr::rt( + Expr::rs( "iterIsSortedBy", super::iter::tail(vec![items, compare], vec![Expr::undefined(), drop]), ) @@ -2413,7 +2413,7 @@ fn mapping<'tcx>( let elem = targ(gargs, 0); let value = args.pop()?; if byte(elem) { - return Some(Expr::rt("byteVecFrom", vec![value])); + return Some(Expr::rs("byteVecFrom", vec![value])); } let items = match (b.t.copy_fn(elem, span), value) { (None, value) => value, @@ -2422,7 +2422,7 @@ fn mapping<'tcx>( } (Some(copy), value) => value.member("map").call(vec![copy]), }; - Expr::rt("vecFrom", vec![items]) + Expr::rs("vecFrom", vec![items]) } ("Box", "new") => args.pop()?, // `vec![x; n]`: `n - 1` clones of `x`, then `x` itself, which the caller gives as its @@ -2431,10 +2431,10 @@ fn mapping<'tcx>( let elem = targ(gargs, 0); let mut values = args; match byte(elem) { - true => Expr::rt("byteVecOf", values), + true => Expr::rs("byteVecOf", values), false => { values.push(super::collections::clone_fn(b, elem, span)); - Expr::rt("vecFromElem", values) + Expr::rs("vecFromElem", values) } } } @@ -2443,7 +2443,7 @@ fn mapping<'tcx>( ("Vec", "new") => vec_new(byte(targ(gargs, 0))), // What reads or sets a capacity is given the size of the elements, by which std's // grows it. - ("Vec", "with_capacity") if byte(targ(gargs, 0)) => Expr::rt("byteVecWithCapacity", args), + ("Vec", "with_capacity") if byte(targ(gargs, 0)) => Expr::rs("byteVecWithCapacity", args), ("Vec", "capacity") if byte(targ(gargs, 0)) => args.pop()?.member("data").member("length"), ("Vec", "reserve" | "reserve_exact" | "try_reserve" | "try_reserve_exact" | "shrink_to") if byte(targ(gargs, 0)) => @@ -2451,7 +2451,7 @@ fn mapping<'tcx>( rt2(args, "byteVec", &super::camel(&name)) } ("Vec", "shrink_to_fit") if byte(targ(gargs, 0)) => { - Expr::rt("byteVecShrinkTo", vec![args.pop()?, Expr::lit("0")]) + Expr::rs("byteVecShrinkTo", vec![args.pop()?, Expr::lit("0")]) } ( "Vec", @@ -2472,26 +2472,26 @@ fn mapping<'tcx>( ("Vec", "push") => { let mut values = args; match byte(targ(gargs, 0)) { - true => Expr::rt("byteVecPush", values), + true => Expr::rs("byteVecPush", values), false => { let v = values.remove(0); v.member("items").method("push", values) } } } - ("Vec", "pop") if byte(targ(gargs, 0)) => Expr::rt("byteVecPop", args), - ("Vec", "pop") => Expr::rt("vecPop", args), + ("Vec", "pop") if byte(targ(gargs, 0)) => Expr::rs("byteVecPop", args), + ("Vec", "pop") => Expr::rs("vecPop", args), // The last element is lent to the test as its place where JS copies it. - ("Vec", "pop_if") if byte(targ(gargs, 0)) => Expr::rt("byteVecPopIf", args), - ("Vec", "pop_if") if b.t.needs_place(targ(gargs, 0)) => Expr::rt("vecPopIfMut", args), - ("Vec", "pop_if") => Expr::rt("vecPopIf", args), + ("Vec", "pop_if") if byte(targ(gargs, 0)) => Expr::rs("byteVecPopIf", args), + ("Vec", "pop_if") if b.t.needs_place(targ(gargs, 0)) => Expr::rs("vecPopIfMut", args), + ("Vec", "pop_if") => Expr::rs("vecPopIf", args), ("Vec", "len") => vec_items(args.pop()?, targ(gargs, 0)).member("length"), ("Vec", "is_empty") => vec_items(args.pop()?, targ(gargs, 0)) .member("length") .binary("===", Expr::lit("0")), - ("Vec", "truncate") if byte(targ(gargs, 0)) => Expr::rt("byteVecTruncate", args), - ("Vec", "clear") if byte(targ(gargs, 0)) => Expr::rt("byteVecClear", args), - ("Vec", "extend_from_slice") if byte(targ(gargs, 0)) => Expr::rt("byteVecExtendFromSlice", args), + ("Vec", "truncate") if byte(targ(gargs, 0)) => Expr::rs("byteVecTruncate", args), + ("Vec", "clear") if byte(targ(gargs, 0)) => Expr::rs("byteVecClear", args), + ("Vec", "extend_from_slice") if byte(targ(gargs, 0)) => Expr::rs("byteVecExtendFromSlice", args), ("Vec", "extend_from_slice") => { let mut values = args; values.push(super::iter::size_of(b, targ(gargs, 0), span)); @@ -2499,7 +2499,7 @@ fn mapping<'tcx>( if !matches!(&clone, Expr::Lit(l) if l == "undefined") { values.push(clone); } - Expr::rt("vecExtendFromSlice", values) + Expr::rs("vecExtendFromSlice", values) } ("Vec", "insert" | "remove" | "swap_remove" | "append" | "resize" | "resize_with" | "split_off") if byte(targ(gargs, 0)) => @@ -2522,11 +2522,11 @@ fn mapping<'tcx>( let ranged = super::collections::bounds(b, call, args.pop()?); args.push(ranged.bounds.clone()); return Some(ranged.after(match byte(elem) { - true => Expr::rt("byteVecExtendFromWithin", args), + true => Expr::rs("byteVecExtendFromWithin", args), false => { args.push(super::iter::size_of(b, elem, span)); args.push(super::collections::clone_fn(b, elem, span)); - Expr::rt("vecExtendFromWithin", args) + Expr::rs("vecExtendFromWithin", args) } })); } @@ -2536,7 +2536,7 @@ fn mapping<'tcx>( ("Vec", "clear") => { let mut values = args; values.push(Expr::lit("0")); - Expr::rt("vecTruncate", values) + Expr::rs("vecTruncate", values) } // What each takes by value is a closure, which it drops once done. An element JS // copies is lent to the closure as its place where it takes a `&mut`. @@ -2586,10 +2586,10 @@ fn mapping<'tcx>( let ranged = super::collections::bounds(b, call, args.pop()?); args.push(ranged.bounds.clone()); return Some(ranged.after(match byte(targ(gargs, 0)) { - true => Expr::rt("byteVecDrain", args), + true => Expr::rs("byteVecDrain", args), false => { let dropper = b.t.dropper(targ(gargs, 0), span); - Expr::rt("vecDrain", super::iter::tail(args, vec![dropper])) + Expr::rs("vecDrain", super::iter::tail(args, vec![dropper])) } })); } @@ -2615,11 +2615,11 @@ fn mapping<'tcx>( let ranged = super::collections::bounds(b, call, args.pop()?); args.push(ranged.bounds.clone()); let drain = match byte(elem) { - true => Expr::rt("byteVecSplice", args), + true => Expr::rs("byteVecSplice", args), false => { args.push(super::iter::size_of(b, elem, span)); let dropper = b.t.dropper(elem, span); - Expr::rt("vecSplice", super::iter::tail(args, vec![dropper])) + Expr::rs("vecSplice", super::iter::tail(args, vec![dropper])) } }; let items = super::iter::into_iter(b, source, items, span)?; @@ -2627,7 +2627,7 @@ fn mapping<'tcx>( let drain = ranged.after(drain); let trusted = Expr::lit(super::iter::implements(b.t, iter, "TrustedLen").to_string()); let drops = super::iter::iter_drops(b, iter, span); - return Some(Expr::rt( + return Some(Expr::rs( "spliceFrom", super::iter::tail(vec![drain, items], vec![trusted, drops]), )); @@ -2643,7 +2643,7 @@ fn mapping<'tcx>( (false, true) => "vecExtractIfMut", (false, false) => "vecExtractIf", }; - return Some(ranged.after(Expr::rt(extract, args))); + return Some(ranged.after(Expr::rs(extract, args))); } // Its elements' elements, with room for as many as its capacity held arrays. // `Vec<[T; N], A>::into_flattened`. @@ -2659,16 +2659,16 @@ fn mapping<'tcx>( let mut values = args; values.push(Expr::lit(n.to_string())); return Some(match byte(elem) { - true => Expr::rt("byteVecIntoFlattened", values), + true => Expr::rs("byteVecIntoFlattened", values), false => { values.push(super::iter::size_of(b, elem, span)); - Expr::rt("vecIntoFlattened", values) + Expr::rs("vecIntoFlattened", values) } }); } // The room past a byte vector's length, a slice of its storage. - ("Vec", "spare_capacity_mut") if byte(targ(gargs, 0)) => Expr::rt("byteVecSpare", args), - ("Vec", "set_len") if byte(targ(gargs, 0)) => Expr::rt("byteVecSetLen", args), + ("Vec", "spare_capacity_mut") if byte(targ(gargs, 0)) => Expr::rs("byteVecSpare", args), + ("Vec", "set_len") if byte(targ(gargs, 0)) => Expr::rs("byteVecSetLen", args), // The room past its length, which no JS array holds. ("Vec", "spare_capacity_mut") => { return Some(b.err( @@ -2702,7 +2702,7 @@ fn mapping<'tcx>( false => b.spill(v, "peek", out), }; if name == "deref_mut" { - out.push(StmtKind::Expr(Expr::rt("peekMutDerefMut", vec![p.clone()])).at(None)); + out.push(StmtKind::Expr(Expr::rs("peekMutDerefMut", vec![p.clone()])).at(None)); } p.member("v") } @@ -2714,34 +2714,34 @@ fn mapping<'tcx>( // Strings. // A `Box`'s bytes are their own, as `as_bytes` gives them. - ("String" | "str", "as_bytes") | ("str", "into_boxed_bytes") => Expr::rt("stringAsBytes", args), - ("String", "from_utf8") => Expr::rt("stringFromUtf8", args), + ("String" | "str", "as_bytes") | ("str", "into_boxed_bytes") => Expr::rs("stringAsBytes", args), + ("String", "from_utf8") => Expr::rs("stringFromUtf8", args), ("String", "into_bytes") => { b.t.string_bytes(); - Expr::rt("stringIntoBytes", args) + Expr::rs("stringIntoBytes", args) } - ("String", "from_utf8_lossy") => Expr::rt("stringFromUtf8Lossy", args), + ("String", "from_utf8_lossy") => Expr::rs("stringFromUtf8Lossy", args), // UTF-8 by their contract, which the lossy decoder reads as the text. - ("converts" | "str", "from_utf8_unchecked") => Expr::rt("strFromUtf8Unchecked", args), - ("String", "from_utf8_unchecked") => Expr::rt( + ("converts" | "str", "from_utf8_unchecked") => Expr::rs("strFromUtf8Unchecked", args), + ("String", "from_utf8_unchecked") => Expr::rs( "strFromUtf8Unchecked", - vec![Expr::rt("byteVecSlice", vec![args.pop()?])], + vec![Expr::rs("byteVecSlice", vec![args.pop()?])], ), - ("FromUtf8Error", "as_bytes") => Expr::rt("byteVecSlice", vec![args.pop()?.member("bytes")]), + ("FromUtf8Error", "as_bytes") => Expr::rs("byteVecSlice", vec![args.pop()?.member("bytes")]), ("FromUtf8Error", "into_bytes") => args.pop()?.member("bytes"), ("FromUtf8Error", "utf8_error") => args.pop()?.member("error"), - ("slice", "utf8_chunks") => Expr::rt("byteSliceUtf8Chunks", args), + ("slice", "utf8_chunks") => Expr::rs("byteSliceUtf8Chunks", args), ("Utf8Chunk", "valid" | "invalid") => args.pop()?.member(&name), ( "String", "from_utf16" | "from_utf16_lossy" | "from_utf16le" | "from_utf16le_lossy" | "from_utf16be" | "from_utf16be_lossy", - ) => Expr::rt_of("string", &super::camel(&name)).call(args), + ) => Expr::rs_of("string", &super::camel(&name)).call(args), // `str::from_utf8` is `core::str::converts::from_utf8`, or `str`'s own. - ("converts" | "str", "from_utf8") => Expr::rt("strFromUtf8", args), + ("converts" | "str", "from_utf8") => Expr::rs("strFromUtf8", args), ("Utf8Error", "valid_up_to") => args.pop()?.member("validUpTo"), ("Utf8Error", "error_len") => args.pop()?.member("errorLen"), - ("String" | "str", "len") => Expr::rt("stringLen", args), + ("String" | "str", "len") => Expr::rs("stringLen", args), // A `Box` is its text, as a `String` is. ("String", "as_str" | "into_boxed_str") | ("str", "into_string") => args.pop()?, ("String", "new") => Expr::Str(String::new()), @@ -2752,9 +2752,9 @@ fn mapping<'tcx>( } ("Add", "add") if cow_str(tcx, targ(gargs, 0)) => { let rhs = str_cow(tcx, targ(gargs, 1), args.pop()?); - Expr::rt("strCowAdd", vec![args.pop()?, rhs]) + Expr::rs("strCowAdd", vec![args.pop()?, rhs]) } - ("String", "with_capacity") => Expr::rt("stringWithCapacity", args), + ("String", "with_capacity") => Expr::rs("stringWithCapacity", args), // Of the place the `&mut` is, which it writes as it drops, and of a range, as `Vec::drain`. ("String", "drain") => { let ranged = super::collections::bounds(b, call, args.pop()?); @@ -2763,66 +2763,66 @@ fn mapping<'tcx>( true => s, false => b.spill(s, "s", out), }; - let len = Expr::rt("stringLen", vec![s.clone().member("v")]); - return Some(Expr::rt("stringDrain", vec![s, ranged.within(len)])); + let len = Expr::rs("stringLen", vec![s.clone().member("v")]); + return Some(Expr::rs("stringDrain", vec![s, ranged.within(len)])); } - ("Drain", "as_str") => Expr::rt("stringDrainAsStr", args), + ("Drain", "as_str") => Expr::rs("stringDrainAsStr", args), ("ParseIntError", "kind") => args.pop()?.member("kind"), // `str::parse` of a float, by std's grammar rather than `Number`'s. ("str", "parse") | ("FromStr", "from_str") if let Some(float) = super::float::Float::of(targ(gargs, 0)) => { - Expr::rt_of(float.name(), "fromStr").call(args) + Expr::rs_of(float.name(), "fromStr").call(args) } // A `char`'s steps through its chars by `&mut`, which no body of std's may. - ("str", "parse") | ("FromStr", "from_str") if targ(gargs, 0).is_char() => Expr::rt("charFromStr", args), + ("str", "parse") | ("FromStr", "from_str") if targ(gargs, 0).is_char() => Expr::rs("charFromStr", args), ("String" | "str", "is_empty") => args.pop()?.member("length").binary("===", Expr::lit("0")), - ("str", "chars") => Expr::rt("strChars", args), - ("str", "bytes") => Expr::rt("strBytes", args), - ("str", "is_char_boundary") => Expr::rt("strIsCharBoundary", args), + ("str", "chars") => Expr::rs("strChars", args), + ("str", "bytes") => Expr::rs("strBytes", args), + ("str", "is_char_boundary") => Expr::rs("strIsCharBoundary", args), // Searches by a pattern. ("str", "split" | "rsplit" | "split_terminator" | "rsplit_terminator" | "split_inclusive") | ("str", "matches" | "rmatches" | "match_indices" | "rmatch_indices" | "split_once" | "rsplit_once") | ("str", "find" | "rfind" | "contains" | "starts_with" | "ends_with" | "strip_prefix" | "strip_suffix") | ("str", "trim_matches" | "trim_start_matches" | "trim_end_matches") => { let [s, p] = <[Expr; 2]>::try_from(args).ok()?; - Expr::rt_of("str", &super::camel(&name)).call(vec![s, pattern(b.t, targ(gargs, 0), p)?]) + Expr::rs_of("str", &super::camel(&name)).call(vec![s, pattern(b.t, targ(gargs, 0), p)?]) } ("str", "splitn" | "rsplitn") => { let [s, n, p] = <[Expr; 3]>::try_from(args).ok()?; - Expr::rt_of("str", &name).call(vec![s, n, pattern(b.t, targ(gargs, 0), p)?]) + Expr::rs_of("str", &name).call(vec![s, n, pattern(b.t, targ(gargs, 0), p)?]) } // `replacen`'s count follows what replaces each match. ("str", "replace" | "replacen") => { let mut args = args.into_iter(); let (s, p) = (args.next()?, args.next()?); let rest = args.collect::>(); - Expr::rt("strReplace", [vec![s, pattern(b.t, targ(gargs, 0), p)?], rest].concat()) + Expr::rs("strReplace", [vec![s, pattern(b.t, targ(gargs, 0), p)?], rest].concat()) } // Searches by whitespace, as std's are by `char::is_whitespace`. - ("char", "is_whitespace") => Expr::rt("charIsWhitespace", args), + ("char", "is_whitespace") => Expr::rs("charIsWhitespace", args), // By std's own Unicode tables, which the engine's may trail. ( "char", "is_alphabetic" | "is_lowercase" | "is_uppercase" | "is_alphanumeric" | "is_control" | "is_numeric" | "to_lowercase" | "to_uppercase" | "escape_unicode" | "escape_debug" | "escape_default" | "len_utf8" | "len_utf16" | "encode_utf16" | "from_digit", - ) => Expr::rt_of("char", &super::camel(&name)).call(args), + ) => Expr::rs_of("char", &super::camel(&name)).call(args), ( "str", "to_lowercase" | "to_uppercase" | "escape_unicode" | "escape_debug" | "escape_default" | "encode_utf16", - ) => Expr::rt_of("str", &super::camel(&name)).call(args), + ) => Expr::rs_of("str", &super::camel(&name)).call(args), // `char::decode_utf16` of what it is given, either as a method or as `char`'s function. ("char", "decode_utf16") => { let mut values = args; let it = super::iter::into_iter(b, targ(gargs, 0), values.pop()?, span)?; - Expr::rt("charDecodeUtf16", vec![it]) + Expr::rs("charDecodeUtf16", vec![it]) } ("DecodeUtf16Error", "unpaired_surrogate") => args.pop()?.member("code"), ("str", "trim" | "trim_start" | "trim_end") => { let f = format!("{}_matches", name); - Expr::rt_of("str", &super::camel(&f)).call(vec![args.pop()?, Expr::Rt("charIsWhitespace".into())]) + Expr::rs_of("str", &super::camel(&f)).call(vec![args.pop()?, Expr::Rs("charIsWhitespace".into())]) } ("str", "char_indices" | "lines" | "split_whitespace" | "split_ascii_whitespace") => { - Expr::rt_of("str", &super::camel(&name)).call(args) + Expr::rs_of("str", &super::camel(&name)).call(args) } // A slice of strings concatenated, or joined by a `&str`. ("slice", "concat" | "join") @@ -2830,18 +2830,18 @@ fn mapping<'tcx>( { let mut values = args; if cow_str(tcx, targ(gargs, 0).peel_refs()) { - values[0] = values[0].clone().member("map").call(vec![Expr::Rt("strCowStr".into())]); + values[0] = values[0].clone().member("map").call(vec![Expr::Rs("strCowStr".into())]); } if name == "concat" { values.push(Expr::Str(String::new())); } - Expr::rt("strsJoin", values) + Expr::rs("strsJoin", values) } ("slice", "concat" | "join") => { return slices_join(b, targ(gargs, 0), targ(gargs, 1), name == "join", args, span); } - ("char", _) if let Some(method) = ascii(&name) => Expr::rt(method, args), - ("ascii", "escape_default") => Expr::rt("escapeAscii", args), + ("char", _) if let Some(method) = ascii(&name) => Expr::rs(method, args), + ("ascii", "escape_default") => Expr::rs("escapeAscii", args), // Those of `[u8]`, a `Vec`'s by `Deref`, and of `str`, a `String`'s, but `str`'s // `make_ascii_*`, which MIR lowers as a byte's and a char's. ( @@ -2856,10 +2856,10 @@ fn mapping<'tcx>( ) | ("slice", "escape_ascii" | "make_ascii_uppercase" | "make_ascii_lowercase") => { let of = if owner == "slice" { "byteSlice" } else { "str" }; - Expr::rt_of(of, &super::camel(&name)).call(args) + Expr::rs_of(of, &super::camel(&name)).call(args) } // A `Cow`'s text, whichever variant holds it. - ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rt("strCowStr", args), + ("Cow", "into_owned") if targ(gargs, 0).is_str() => Expr::rs("strCowStr", args), ("AsRef", "as_ref") if string(tcx, targ(gargs, 0)) && targ(gargs, 1).is_str() => args.pop()?, // A `Cow<[T]>` borrows its slice, and its `Vec` is its own or a clone of what it // borrows, so it drops nothing. @@ -2882,11 +2882,11 @@ fn mapping<'tcx>( ("panicking", "panic_fmt") => { let message = args.pop()?; match literal(&message) { - Some(s) => Expr::rt("panic", [vec![Expr::Str(s)], hook_at(b)].concat()), - None => Expr::rt("panicFmt", vec![message]), + Some(s) => Expr::rs("panic", [vec![Expr::Str(s)], hook_at(b)].concat()), + None => Expr::rs("panicFmt", vec![message]), } } - ("panicking", "panic") => Expr::rt("panic", [args, hook_at(b)].concat()), + ("panicking", "panic") => Expr::rs("panic", [args, hook_at(b)].concat()), // The harness writes a payload of text, and `Box` for any other. A hook reads // the payload itself: a `String`, a `&str`, or the `dyn Any` object of any other. ("panic", "panic_any") | ("rt", "begin_panic") => { @@ -2898,9 +2898,9 @@ fn mapping<'tcx>( ) { (true, true) => { let at = b.panic_at.clone().unwrap_or_else(Expr::undefined); - Expr::rt("panic", vec![args.pop()?, at, Expr::lit(owned.to_string())]) + Expr::rs("panic", vec![args.pop()?, at, Expr::lit(owned.to_string())]) } - (true, false) => Expr::rt("panic", args), + (true, false) => Expr::rs("panic", args), (false, true) => { let class = b.t.object_class( payload, @@ -2908,15 +2908,15 @@ fn mapping<'tcx>( super::dynamic::Held::Value, span, )?; - Expr::rt("panicAny", vec![Expr::New(Box::new(Expr::Sym(class.sym)), args)]) + Expr::rs("panicAny", vec![Expr::New(Box::new(Expr::Sym(class.sym)), args)]) } - (false, false) => Expr::rt("panic", vec![Expr::Str("Box".into())]), + (false, false) => Expr::rs("panic", vec![Expr::Str("Box".into())]), } } // A panic aborts, so `catch_unwind` never catches one. Its call consumes the function, // so nothing drops it. ("panic", "catch_unwind") => return Some(Expr::result(true, args.pop()?.call(Vec::new()))), - ("panic", "resume_unwind") => Expr::rt("resumeUnwind", Vec::new()), + ("panic", "resume_unwind") => Expr::rs("resumeUnwind", Vec::new()), // The location the call passes, as a `#[track_caller]` function's call does. ("Location", _) if inherent_std(tcx, call.def_id) != Some(Std::Location) => return None, ("Location", "caller") => { @@ -2930,9 +2930,9 @@ fn mapping<'tcx>( ("panicking", "set_hook") => { b.t.hook(); let sites = super::caller::sites(b.t, span); - Expr::rt("setHook", vec![args.pop()?, sites]) + Expr::rs("setHook", vec![args.pop()?, sites]) } - ("panicking", "take_hook") => Expr::rt("takeHook", Vec::new()), + ("panicking", "take_hook") => Expr::rs("takeHook", Vec::new()), ("PanicHookInfo", "payload") => { let object = b.t.sig(call.def_id, gargs).output().builtin_deref(true)?; let class = |b: &mut Body<'_, '_, 'tcx>, ty| { @@ -2942,14 +2942,14 @@ fn mapping<'tcx>( let str = class(b, Ty::new_static_str(tcx))?; let string = tcx.lang_items().string()?; let string = class(b, Ty::new_adt(tcx, tcx.adt_def(string), ty::List::empty()))?; - Expr::rt("hookPayload", vec![args.pop()?, str, string]) + Expr::rs("hookPayload", vec![args.pop()?, str, string]) } ("PanicHookInfo", "payload_as_str") => args.pop()?.member("text"), ("PanicHookInfo", "location") => args.pop()?.member("location"), // A panic aborts. ("PanicHookInfo", "can_unwind") => Expr::lit("false"), ("panicking", "panic_explicit") => { - Expr::rt("panic", [vec![Expr::Str("explicit panic".into())], hook_at(b)].concat()) + Expr::rs("panic", [vec![Expr::Str("explicit panic".into())], hook_at(b)].concat()) } ("panicking", "panic_display" | "unreachable_display") => { let value = args.pop()?; @@ -2958,7 +2958,7 @@ fn mapping<'tcx>( if name == "unreachable_display" { message.insert(0, Expr::Str("internal error: entered unreachable code: ".into())); } - Expr::rt("panicFmt", vec![Expr::Array(message)]) + Expr::rs("panicFmt", vec![Expr::Array(message)]) } // `assert_eq!` and `assert_ne!`: the operator, both sides, and any message. ("panicking", "assert_failed") => { @@ -2969,7 +2969,7 @@ fn mapping<'tcx>( if !matches!(&message, Expr::Lit(text) if text == "undefined") { values.push(message); } - Expr::rt("assertFailed", values) + Expr::rs("assertFailed", values) } // Formatting. @@ -3000,7 +3000,7 @@ fn mapping<'tcx>( let value = args.pop()?; let (elem, len) = match ty.kind() { ty::Slice(elem) => (*elem, Some(super::mir::slice_member(value, "length"))), - ty::Str => (tcx.types.u8, Some(Expr::rt("stringLen", vec![value]))), + ty::Str => (tcx.types.u8, Some(Expr::rs("stringLen", vec![value]))), _ if ty.is_sized(tcx, env) => (ty, None), _ => return None, }; @@ -3013,7 +3013,7 @@ fn mapping<'tcx>( (_, Some(len)) => len.binary("*", Expr::lit(size.to_string())), } } - // A reference to an array of bytes is an `rt.ByteSlice` already, and to one of other + // A reference to an array of bytes is an `rs.ByteSlice` already, and to one of other // values its JS array, so each is its own slice, and writes through it land in it. ("array", "as_slice" | "as_mut_slice") => args.pop()?, ("array", "from_fn") => { @@ -3022,14 +3022,14 @@ fn mapping<'tcx>( _ if byte(targ(gargs, 0)) => "bytesFromFn", _ => "arrayFromFn", }; - Expr::rt(f, vec![Expr::lit(n.to_string()), args.pop()?]) + Expr::rs(f, vec![Expr::lit(n.to_string()), args.pop()?]) } ("array", "map") => { let f = match targ(gargs, 2).kind() { _ if byte(targ(gargs, 2)) => "bytesMap", _ => "arrayMap", }; - Expr::rt(f, args) + Expr::rs(f, args) } // Each element lent as `first_mut` lends it: an element JS copies as its place, an // array of bytes as its view, and an object as itself. @@ -3037,16 +3037,16 @@ fn mapping<'tcx>( let elem = targ(gargs, 0); let a = elements(args.pop()?, Ty::new_slice(tcx, elem)); match () { - _ if name == "each_mut" && b.t.needs_place(elem) => Expr::rt("arrayPlaces", vec![a]), - _ if super::byte_array(elem) => Expr::rt("arrayMap", vec![a, Expr::Rt("byteSliceFrom".into())]), - _ => Expr::rt("arrayFrom", vec![a]), + _ if name == "each_mut" && b.t.needs_place(elem) => Expr::rs("arrayPlaces", vec![a]), + _ if super::byte_array(elem) => Expr::rs("arrayMap", vec![a, Expr::Rs("byteSliceFrom".into())]), + _ => Expr::rs("arrayFrom", vec![a]), } } ("fmt", "format") => { let parts = args.pop()?; match literal(&parts) { Some(s) => Expr::Str(s), - None => Expr::rt("fmtFormat", vec![parts]), + None => Expr::rs("fmtFormat", vec![parts]), } } ("Display" | "Debug" | "LowerHex" | "UpperHex" | "Octal" | "Binary" | "LowerExp" | "UpperExp", "fmt") => { @@ -3082,18 +3082,18 @@ fn mapping<'tcx>( ty::Adt(..) if textual(tcx, ty) => text(tcx, ty, value), _ => { let value = b.fmt_value(fmt::Trait::Display, ty, value, span, out); - Expr::rt("fmtToString", vec![value]) + Expr::rs("fmtToString", vec![value]) } } } ("Formatter", "write_fmt") => { let [f, parts] = <[Expr; 2]>::try_from(args).ok()?; match literal(&parts) { - Some(s) => Expr::rt("fmtWriteStr", vec![f, Expr::Str(s)]), - None => Expr::rt("fmtWriteFmt", vec![f, parts]), + Some(s) => Expr::rs("fmtWriteStr", vec![f, Expr::Str(s)]), + None => Expr::rs("fmtWriteFmt", vec![f, parts]), } } - // Each takes its receiver first: `rt.fmtPad(f, s)`, `rt.debugStructField(b, name, value)`. + // Each takes its receiver first: `rs.fmtPad(f, s)`, `rs.debugStructField(b, name, value)`. ("Formatter", "write_str" | "pad" | "alternate" | "width" | "debug_struct" | "debug_tuple" | "debug_list") | ("DebugStruct" | "DebugTuple", "field" | "finish" | "finish_non_exhaustive") | ("DebugList", "entry" | "finish" | "finish_non_exhaustive") => { @@ -3103,11 +3103,11 @@ fn mapping<'tcx>( "DebugTuple" => "debugTuple", _ => "debugList", }; - Expr::rt_of(of, &super::camel(&name)).call(args) + Expr::rs_of(of, &super::camel(&name)).call(args) } // Derived `Debug`: `debug_struct_field2_finish(f, name, "a", &a, "b", &b)`. - ("Formatter", "debug_struct_fields_finish") => Expr::rt("fmtDebugStructFields", args), - ("Formatter", "debug_tuple_fields_finish") => Expr::rt("fmtDebugTupleFields", args), + ("Formatter", "debug_struct_fields_finish") => Expr::rs("fmtDebugStructFields", args), + ("Formatter", "debug_tuple_fields_finish") => Expr::rs("fmtDebugTupleFields", args), ("Formatter", n) if n.starts_with("debug_struct_field") || n.starts_with("debug_tuple_field") => { let mut values = args.into_iter(); let (f, type_name) = (values.next()?, values.next()?); @@ -3116,16 +3116,16 @@ fn mapping<'tcx>( true => ("debugStruct", "fmtDebugStruct"), false => ("debugTuple", "fmtDebugTuple"), }; - let mut builder = Expr::rt(start, vec![f, type_name]); + let mut builder = Expr::rs(start, vec![f, type_name]); let values: Vec = values.collect(); let fields = match structure { true => values.chunks(2).map(<[Expr]>::to_vec).collect::>(), false => values.into_iter().map(|v| vec![v]).collect(), }; for field in fields { - builder = Expr::rt_of(of, "field").call([vec![builder], field].concat()); + builder = Expr::rs_of(of, "field").call([vec![builder], field].concat()); } - Expr::rt_of(of, "finish").call(vec![builder]) + Expr::rs_of(of, "finish").call(vec![builder]) } _ => return super::iter::call(b, call, &owner, &name, args), }; @@ -3135,7 +3135,7 @@ fn mapping<'tcx>( format!("passing `{ty}`, which drops, to `{owner}::{name}`, which is not supported yet"), )); } - // What drops each operand the mapping may discard, then `rt.None` where it is one. + // What drops each operand the mapping may discard, then `rs.None` where it is one. let lost = discarded.unwrap_or_default().iter().map(|&n| targ(gargs, n)); let Some(mut droppers) = b.t.droppers(lost, span) else { return Some(Expr::undefined()); @@ -3221,10 +3221,10 @@ pub(super) fn box_slice_clone_from<'tcx>( span: Span, ) -> Expr { if byte(elem) { - return Expr::rt("byteBoxSliceCloneFrom", vec![slot, source]); + return Expr::rs("byteBoxSliceCloneFrom", vec![slot, source]); } let fns = clone_from_fns(b, elem, span); - Expr::rt("boxSliceCloneFrom", [vec![slot, source], fns].concat()) + Expr::rs("boxSliceCloneFrom", [vec![slot, source], fns].concat()) } /// What `clone_from` of `source` leaves over `old`, a `ty` whose `clone_from` is std's own @@ -3232,12 +3232,12 @@ pub(super) fn box_slice_clone_from<'tcx>( /// place, for all but an `Option`, a `Result`, and a `Cow`. Refused for any other `clone_from`. pub(super) fn clone_from<'tcx>(b: &mut Body<'_, '_, 'tcx>, old: Expr, source: Expr, ty: Ty<'tcx>, span: Span) -> Expr { match std_clone_from(b, ty, span) { - Ok((name, fns)) => Expr::rt(name, [vec![old, source], fns].concat()), + Ok((name, fns)) => Expr::rs(name, [vec![old, source], fns].concat()), Err(refused) => refused, } } -/// An `rt.CloneFrom` of a `ty` whose `clone_from` is not `*self = source.clone()`: the +/// An `rs.CloneFrom` of a `ty` whose `clone_from` is not `*self = source.clone()`: the /// crate's own, or std's over what it holds. fn clone_from_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> Expr { let tcx = b.t.tcx; @@ -3249,10 +3249,10 @@ fn clone_from_fn<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span) -> true => "cloneFromPlaceFn", false => "cloneFromFn", }; - return Expr::rt(name, vec![b.fn_value(clone_from, args, span)]); + return Expr::rs(name, vec![b.fn_value(clone_from, args, span)]); } match std_clone_from(b, ty, span) { - Ok((name, fns)) => Expr::rt(format!("{name}Fn"), fns), + Ok((name, fns)) => Expr::rs(format!("{name}Fn"), fns), Err(refused) => refused, } } @@ -3333,7 +3333,7 @@ fn std_clone_from<'tcx>( /// What the runtime's clones of `elem`s over others by their `clone_from` take after their /// own arguments: what clones one, a copy for a `TrivialClone`; what drops one; and its -/// `rt.CloneFrom` where its `clone_from` is not `*self = source.clone()`. +/// `rs.CloneFrom` where its `clone_from` is not `*self = source.clone()`. pub(super) fn clone_from_fns<'tcx>(b: &mut Body<'_, '_, 'tcx>, elem: Ty<'tcx>, span: Span) -> Vec { if super::iter::implements(b.t, elem, "TrivialClone") { return b.t.copy_fn(elem, span).into_iter().collect(); @@ -3414,7 +3414,7 @@ fn slices_join<'tcx>( }; let bytes = byte(elem); let sep = match (one, bytes) { - (true, true) => Expr::rt( + (true, true) => Expr::rs( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(vec![sep])], ), @@ -3431,13 +3431,13 @@ fn slices_join<'tcx>( _ if box_slice(b.t.tcx, item).is_some() => None, _ => return None, }; - let slice = slice.map_or_else(Expr::undefined, |f| Expr::Rt(f.into())); + let slice = slice.map_or_else(Expr::undefined, |f| Expr::Rs(f.into())); if bytes { - return Some(Expr::rt("byteSlicesJoin", trimmed(vec![items, sep, slice]))); + return Some(Expr::rs("byteSlicesJoin", trimmed(vec![items, sep, slice]))); } let size = super::iter::size_of(b, elem, span); let clone = super::collections::clone_fn(b, elem, span); - Some(Expr::rt("slicesJoin", trimmed(vec![items, size, sep, slice, clone]))) + Some(Expr::rs("slicesJoin", trimmed(vec![items, size, sep, slice, clone]))) } /// `args` without the `undefined`s that end them, which a runtime function's optional @@ -3454,16 +3454,16 @@ fn trimmed(mut args: Vec) -> Vec { /// `Vec` with room for exactly them. pub fn cow_cloned<'tcx>(b: &mut Body<'_, '_, 'tcx>, op: &str, cow: Expr, elem: Ty<'tcx>, span: Span) -> Expr { if byte(elem) { - return Expr::rt(format!("byteCow{op}"), vec![cow]); + return Expr::rs(format!("byteCow{op}"), vec![cow]); } let clone = super::collections::clone_fn(b, elem, span); - Expr::rt(format!("cow{op}"), trimmed(vec![cow, clone])) + Expr::rs(format!("cow{op}"), trimmed(vec![cow, clone])) } /// `to_vec` of `slice`, of `elem`s: a `Vec` of clones of them. pub(super) fn slice_to_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, span: Span) -> Expr { match elem.kind() { - _ if byte(elem) => Expr::rt("byteSliceToByteVec", vec![slice]), + _ if byte(elem) => Expr::rs("byteSliceToByteVec", vec![slice]), _ => vec_clone(b, slice, elem, span), } } @@ -3471,7 +3471,7 @@ pub(super) fn slice_to_vec<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: /// A clone of `value`, a slice or array of `elem` other than bytes, as a `Vec` with room for /// exactly its elements, as std's allocates one. fn vec_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, span: Span) -> Expr { - Expr::rt("vecFrom", vec![slice_clone(b, value, elem, span)]) + Expr::rs("vecFrom", vec![slice_clone(b, value, elem, span)]) } /// A clone of `value`, a slice or array of `elem` other than bytes, as an array: a copy of it if each element's clone is itself, or else each element cloned. @@ -3486,9 +3486,9 @@ fn slice_clone<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Expr, elem: Ty<'tcx>, sp /// make one. fn slice_boxed<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, span: Span) -> Option { match elem.kind() { - _ if byte(elem) => Some(Expr::rt( + _ if byte(elem) => Some(Expr::rs( "byteSliceFrom", - vec![Expr::rt("byteSliceToArray", vec![slice])], + vec![Expr::rs("byteSliceToArray", vec![slice])], )), _ => Some(slice_clone(b, slice, elem, span)), } @@ -3497,7 +3497,7 @@ fn slice_boxed<'tcx>(b: &mut Body<'_, '_, 'tcx>, slice: Expr, elem: Ty<'tcx>, sp /// The `Box<[elem]>` that a `Vec`, `v`, becomes: its elements, as many as it holds. pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { - _ if byte(elem) => Expr::rt("byteVecSlice", vec![v]), + _ if byte(elem) => Expr::rs("byteVecSlice", vec![v]), _ => v.member("items"), } } @@ -3506,15 +3506,15 @@ pub(super) fn vec_boxed(v: Expr, elem: Ty<'_>) -> Expr { /// for exactly its elements. fn boxed_vec(boxed: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { - _ if byte(elem) => Expr::rt("byteSliceToByteVec", vec![boxed]), - _ => Expr::rt("vecFrom", vec![boxed]), + _ if byte(elem) => Expr::rs("byteSliceToByteVec", vec![boxed]), + _ => Expr::rs("vecFrom", vec![boxed]), } } /// The `Box<[elem]>` that `From<[elem; N]>` moves `array` into: its elements. fn array_boxed(array: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { - _ if byte(elem) => Expr::rt("byteSliceFrom", vec![array]), + _ if byte(elem) => Expr::rs("byteSliceFrom", vec![array]), _ => array, } } @@ -3547,7 +3547,7 @@ pub fn overflowing<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<(Overflow, T Int::of(args.type_at(0)).map(|_| (overflow, args.type_at(0))) } -/// A `str` method's pattern as the runtime takes it, an `rt.Pattern`: a `char`'s text, a +/// A `str` method's pattern as the runtime takes it, an `rs.Pattern`: a `char`'s text, a /// string or a predicate as it is, or a predicate for an array or slice of chars. `None` /// for any other pattern. A predicate behind references and boxes, a closure, a function, /// or a `dyn FnMut`, is the predicate, as `called_closures` reads it. @@ -3560,9 +3560,9 @@ fn pattern<'tcx>(t: &Translator<'_, 'tcx>, ty: Ty<'tcx>, p: Expr) -> Option Some(p), // Any of the chars of an array or slice. - ty::Array(c, _) | ty::Slice(c) if c.is_char() => Some(Expr::rt("patternChars", vec![p])), + ty::Array(c, _) | ty::Slice(c) if c.is_char() => Some(Expr::rs("patternChars", vec![p])), ty::Ref(_, inner, _) if matches!(inner.kind(), ty::Array(c, _) | ty::Slice(c) if c.is_char()) => { - Some(Expr::rt("patternChars", vec![p])) + Some(Expr::rs("patternChars", vec![p])) } _ => None, } @@ -3604,9 +3604,9 @@ pub fn char_text(c: Expr) -> Expr { Expr::ident("String").member("fromCodePoint").call(vec![c]) } -/// `rt.(args)`. +/// `rs.(args)`. fn rt2(args: Vec, of: &str, name: &str) -> Expr { - Expr::rt_of(of, name).call(args) + Expr::rs_of(of, name).call(args) } /// What the runtime's functions of a std range type start with. @@ -3630,11 +3630,11 @@ pub fn range_step<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, every: bool) -> Option< { let int = Int::of(args.type_at(0)).filter(|int| !int.signed)?; let step = vec![int.func("step"), int.lit(int.max() as i128)]; - return (every || int.big()).then(|| Expr::rt("nonZeroStep", step)); + return (every || int.big()).then(|| Expr::rs("nonZeroStep", step)); } match Int::of(ty) { Some(int) => (every || int.big()).then(|| int.func("step")), - None => ty.is_char().then(|| Expr::Rt("charStep".into())), + None => ty.is_char().then(|| Expr::Rs("charStep".into())), } } @@ -3832,7 +3832,7 @@ fn int_method<'tcx>( && !int.signed && let Some(method) = ascii(name) => { - return Some(Expr::rt(method, args)); + return Some(Expr::rs(method, args)); } // The operator's, which panics with the message each of these does. "strict_add" => "add", @@ -3872,7 +3872,7 @@ fn int_method<'tcx>( } args.push(Expr::lit(int.bits.to_string())); args.push(Expr::lit(int.signed.to_string())); - let e = Expr::rt(super::camel(&format!("int_{shared}")), args); + let e = Expr::rs(super::camel(&format!("int_{shared}")), args); // What gives another type's integer is any integer to the runtime. return Some(match shared { "abs_diff" | "unsigned_abs" | "checked_signed_diff" => { @@ -3910,7 +3910,7 @@ fn unwrapped<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> { } /// The primitive JS compares a range's bounds of type `ty` as, through shared references -/// and a `NonZero`: not through a `&mut`, which may be an `rt.Place`. +/// and a `NonZero`: not through a `&mut`, which may be an `rs.Place`. fn compared<'tcx>(tcx: TyCtxt<'tcx>, mut ty: Ty<'tcx>) -> Option> { while let ty::Ref(_, inner, ty::Mutability::Not) = ty.kind() { ty = *inner; @@ -3923,16 +3923,16 @@ pub fn primitive(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Bool | ty::Int(_) | ty::Uint(_) | ty::Char) || super::float::is(ty) } -/// A `Vec` of `elem`s as a slice: an `rt.ByteSlice` of a byte vector, or the array of an -/// `rt.Vec`'s items. +/// A `Vec` of `elem`s as a slice: an `rs.ByteSlice` of a byte vector, or the array of an +/// `rs.Vec`'s items. pub fn vec_view(v: Expr, elem: Ty<'_>) -> Expr { match elem.kind() { - _ if byte(elem) => Expr::rt("byteVecSlice", vec![v]), + _ if byte(elem) => Expr::rs("byteVecSlice", vec![v]), _ => v.member("items"), } } -/// What holds a `Vec` of `elem`s' length: an `rt.ByteVec` itself, or an `rt.Vec`'s items. +/// What holds a `Vec` of `elem`s' length: an `rs.ByteVec` itself, or an `rs.Vec`'s items. fn vec_items(v: Expr, elem: Ty<'_>) -> Expr { match byte(elem) { true => v, @@ -3943,7 +3943,7 @@ fn vec_items(v: Expr, elem: Ty<'_>) -> Expr { /// A new empty `Vec`, of bytes if `bytes`. pub fn vec_new(bytes: bool) -> Expr { Expr::New( - Box::new(Expr::Rt(if bytes { "ByteVec" } else { "Vec" }.into())), + Box::new(Expr::Rs(if bytes { "ByteVec" } else { "Vec" }.into())), Vec::new(), ) } @@ -3953,9 +3953,9 @@ pub fn vec_new(bytes: bool) -> Expr { /// index. pub fn elements(v: Expr, ty: Ty<'_>) -> Expr { match ty.peel_refs().kind() { - ty::Slice(elem) if byte(*elem) => Expr::rt("byteSliceView", vec![v]), - _ if super::bytes_ref(ty) => Expr::rt("byteSliceView", vec![v]), - ty::Adt(_, args) if args.types().next().is_some_and(byte) => Expr::rt("byteVecView", vec![v]), + ty::Slice(elem) if byte(*elem) => Expr::rs("byteSliceView", vec![v]), + _ if super::bytes_ref(ty) => Expr::rs("byteSliceView", vec![v]), + ty::Adt(_, args) if args.types().next().is_some_and(byte) => Expr::rs("byteVecView", vec![v]), // A `Vec`'s items. ty::Adt(..) => v.member("items"), _ => v, @@ -3990,12 +3990,12 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, _ if nothing(tcx, ty) => Expr::undefined(), ty::Adt(adt, _) if empty_iter(tcx, adt.did()) => b.zero_sized_std(ty, Vec::new(), span).ok()?, // A list's iterators, over an empty list. - ty::Adt(adt, _) if list_iter(tcx, adt.did()) => Expr::rt("listIter", vec![Expr::rt("listNew", Vec::new())]), + ty::Adt(adt, _) if list_iter(tcx, adt.did()) => Expr::rs("listIter", vec![Expr::rs("listNew", Vec::new())]), ty::Tuple(parts) => Expr::Array(parts.iter().map(|t| part(b, t, out)).collect()), ty::Array(elem, n) => { let n = n.try_to_target_usize(tcx)?; match elem.kind() { - _ if byte(*elem) => return Some(Expr::rt("bytes", vec![Expr::lit(n.to_string())])), + _ if byte(*elem) => return Some(Expr::rs("bytes", vec![Expr::lit(n.to_string())])), // Whatever its element, which needn't have a default. _ if n == 0 => return Some(Expr::Array(Vec::new())), _ => {} @@ -4015,7 +4015,7 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, _ if let Some(float) = super::float::Float::of(ty) => float.lit(0.0), ty::Char => Expr::lit("0"), ty::Ref(_, inner, _) => match inner.kind() { - ty::Slice(elem) if byte(*elem) => Expr::rt( + ty::Slice(elem) if byte(*elem) => Expr::rs( "byteSliceFrom", vec![Expr::New(Box::new(Expr::ident("Uint8Array")), vec![Expr::lit("0")])], ), @@ -4032,7 +4032,7 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, Std::Cow if let Some(elem) = cow_slice(tcx, ty) => vec_new(byte(elem)), Std::Duration => super::time::zero(), Std::Atomic => Expr::New( - Box::new(Expr::Rt("Atomic".into())), + Box::new(Expr::Rs("Atomic".into())), vec![default_value(b, args.type_at(0), span, out)?], ), Std::OnceCell | Std::OnceLock => super::task::once_new(b, ty), @@ -4045,19 +4045,19 @@ pub fn default_value<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: Span, out, )?; match std { - Std::Arc => Expr::New(Box::new(Expr::Rt("Arc".into())), vec![empty]), + Std::Arc => Expr::New(Box::new(Expr::Rs("Arc".into())), vec![empty]), _ => empty, } } Std::Box | Std::Wrapping | Std::Saturating => part(b, args.type_at(0), out), - Std::Arc => Expr::New(Box::new(Expr::Rt("Arc".into())), vec![part(b, args.type_at(0), out)]), - Std::Mutex => Expr::New(Box::new(Expr::Rt("Mutex".into())), vec![part(b, args.type_at(0), out)]), + Std::Arc => Expr::New(Box::new(Expr::Rs("Arc".into())), vec![part(b, args.type_at(0), out)]), + Std::Mutex => Expr::New(Box::new(Expr::Rs("Mutex".into())), vec![part(b, args.type_at(0), out)]), Std::RefCell => Expr::New( - Box::new(Expr::Rt("RefCell".into())), + Box::new(Expr::Rs("RefCell".into())), vec![part(b, args.type_at(0), out)], ), - Std::Cell => Expr::New(Box::new(Expr::Rt("Cell".into())), vec![part(b, args.type_at(0), out)]), - Std::Weak => Expr::New(Box::new(Expr::Rt("Weak".into())), Vec::new()), + Std::Cell => Expr::New(Box::new(Expr::Rs("Cell".into())), vec![part(b, args.type_at(0), out)]), + Std::Weak => Expr::New(Box::new(Expr::Rs("Weak".into())), Vec::new()), _ => return None, }, _ => return None, diff --git a/ts/src/lower/mir/alloc.rs b/ts/src/lower/mir/alloc.rs index f501dd77f..59ceab692 100644 --- a/ts/src/lower/mir/alloc.rs +++ b/ts/src/lower/mir/alloc.rs @@ -56,7 +56,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { )); } let p = self.operand(op, span, out); - Some(Expr::rt(f, vec![p, size, Expr::Str(key.to_string())])) + Some(Expr::rs(f, vec![p, size, Expr::Str(key.to_string())])) } /// Whether memory from `alloc` can be typed as `ty`s: values JS copies, of some bytes. diff --git a/ts/src/lower/mir/call.rs b/ts/src/lower/mir/call.rs index 1d82dca8e..e36b8f611 100644 --- a/ts/src/lower/mir/call.rs +++ b/ts/src/lower/mir/call.rs @@ -57,7 +57,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ); (self.err(span, msg), true) } - // `next` into a local that holds the protocol's item or `rt.DONE`, unconverted. + // `next` into a local that holds the protocol's item or `rs.DONE`, unconverted. ty::FnDef(def_id, gargs) if crate::lower::iter::is_next(tcx, def_id) && dest.as_local().is_some_and(|l| self.next_results.contains(&l)) => @@ -175,7 +175,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// Arguments, uncopied, since a callee that changes a parameter in place copies it /// first, but for a `Copy` aggregate std `keeps`, copied unless moved out of a local's /// own value, which the analysis then made the local's own. Each argument `pointees` - /// marks is what an `rt.Place` it is reads, as std's mappings take a `&mut` parameter. + /// marks is what an `rs.Place` it is reads, as std's mappings take a `&mut` parameter. pub(super) fn operands( &mut self, translated: bool, @@ -328,7 +328,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { .is_some_and(|kind| kind != ty::ClosureKind::FnOnce) && self.b.t.drops(callee_ty) { - return Expr::rt("callOnce", [vec![f], values].concat()); + return Expr::rs("callOnce", [vec![f], values].concat()); } return f.call(values); } @@ -359,7 +359,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// A refusal of std's `def_id` if it would make a `&mut` to a value JS copies, which - /// its mapping has as the value, not an `rt.Place`: one it returns or its iterator + /// its mapping has as the value, not an `rs.Place`: one it returns or its iterator /// yields, other than a map's mapping, or one it hands a closure. A `&mut` it returns /// as a type parameter, as `Option::unwrap` does, is what it was given. fn std_places( @@ -574,7 +574,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let mut made = vec![s, i, t, j]; made.extend(self.copy_depth(ty)); - out.push(StmtKind::Expr(Expr::rt("sliceSwapAcross", made)).at(None)); + out.push(StmtKind::Expr(Expr::rs("sliceSwapAcross", made)).at(None)); return done(Expr::undefined(), false); } // An object written in place gives a copy of what it held, so it goes first: @@ -735,7 +735,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let place = self.borrowed_place(&args[0].node, span, out)?; let rhs = self.operand(&args[1].node, span, out); let rhs = library::str_cow(tcx, targ(1)?, rhs); - let joined = Expr::rt("strCowAdd", vec![place.0.clone(), rhs]); + let joined = Expr::rs("strCowAdd", vec![place.0.clone(), rhs]); self.set_borrowed(&place, joined, span, out); done(Expr::undefined(), false) } @@ -745,8 +745,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let place = self.borrowed_place(&args[0].node, span, out)?; let to = crate::lower::camel(&name.replacen("make", "to", 1)); let to = match owner.as_str() { - "str" => Expr::rt_of("str", &to), - _ => Expr::Rt(to), + "str" => Expr::rs_of("str", &to), + _ => Expr::Rs(to), }; let changed = to.call(vec![place.0.clone()]); self.set_borrowed(&place, changed, span, out); @@ -767,12 +767,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // panics as std's does. ("String", "reserve" | "reserve_exact") => { let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rt("stringReserve", values), true) + done(Expr::rs("stringReserve", values), true) } // The error where `reserve` panics. ("String", "try_reserve" | "try_reserve_exact") => { let values = self.operands(false, &[true, true], args, tcx.types.unit, span, out); - done(Expr::rt("stringTryReserve", values), false) + done(Expr::rs("stringTryReserve", values), false) } ("String", "shrink_to_fit" | "shrink_to") => done(Expr::undefined(), false), // The edited string, from the runtime with what it takes after the string. @@ -808,16 +808,16 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span, }; let range = std::mem::replace(&mut values[1], Expr::undefined()); - let len = Expr::rt("stringLen", vec![values[0].clone()]); + let len = Expr::rs("stringLen", vec![values[0].clone()]); values[1] = crate::lower::collections::bounds(self.b, &call, range).within(len); } let edited = match name.as_str() { "clear" => Expr::Str(String::new()), - "truncate" => Expr::rt("stringTruncate", values), - "insert" | "insert_str" => Expr::rt("stringInsertStr", values), - "retain" => Expr::rt("stringRetain", values), - "replace_range" => Expr::rt("stringReplaceRange", values), - _ => Expr::rt("stringExtendFromWithin", values), + "truncate" => Expr::rs("stringTruncate", values), + "insert" | "insert_str" => Expr::rs("stringInsertStr", values), + "retain" => Expr::rs("stringRetain", values), + "replace_range" => Expr::rs("stringReplaceRange", values), + _ => Expr::rs("stringExtendFromWithin", values), }; self.set_borrowed(&place, edited, span, out); out.extend(spent.map(|drop| StmtKind::Expr(drop).at(None))); @@ -834,7 +834,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "remove" => "stringRemove", _ => "stringSplitOff", }; - let edit = self.path(Expr::rt(f, values), "edit", out); + let edit = self.path(Expr::rs(f, values), "edit", out); self.set_borrowed(&place, edit.clone().index(Expr::lit("0")), span, out); done(edit.index(Expr::lit("1")), false) } @@ -863,7 +863,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let place = self.borrowed_place(&args[0].node, span, out)?; let by = self.operand(&args[1].node, span, out); - let value = Expr::rt(f, vec![place.0.clone(), by]); + let value = Expr::rs(f, vec![place.0.clone(), by]); self.set_borrowed(&place, value, span, out); done(Expr::undefined(), false) } @@ -871,7 +871,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // is its `str`, so the `&mut` borrows the same place. ("Cow", "to_mut") if targ(0).is_some_and(|t| t.is_str()) => { let place = self.borrowed_place(&args[0].node, span, out)?; - self.set_borrowed(&place, Expr::rt("strCowStr", vec![place.0.clone()]), span, out); + self.set_borrowed(&place, Expr::rs("strCowStr", vec![place.0.clone()]), span, out); self.same_place(args, dest, span, out) } ("String", "as_mut_str") => self.same_place(args, dest, span, out), @@ -908,7 +908,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // The `&mut str` is the bytes it wrote, which a write through it changes in place. ("char", "encode_utf8") => { let values = self.operands(false, &[], args, dest.ty(&self.mir.local_decls, tcx).ty, span, out); - done(Expr::rt("charEncodeUtf8", values), true) + done(Expr::rs("charEncodeUtf8", values), true) } ("str", "split_at_mut" | "split_at_mut_checked") => { let values = self.operands(false, &[], args, dest.ty(&self.mir.local_decls, tcx).ty, span, out); @@ -916,7 +916,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "split_at_mut" => "strSplitAtMut", _ => "strSplitAtMutChecked", }; - done(Expr::rt(f, values), true) + done(Expr::rs(f, values), true) } // What the `&mut` borrows gets the result: a primitive's operator's, as `+=` on one // computes, or a `Wrapping`'s or a `Saturating`'s, which is its integer, wrapped or @@ -974,7 +974,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let place = self.make_place(payload, target, span, out); let lent = Expr::Cond(Box::new(none), Box::new(Expr::undefined()), Box::new(place)); match name.as_str() { - "iter_mut" => done(Expr::rt("iterOption", vec![lent]), true), + "iter_mut" => done(Expr::rs("iterOption", vec![lent]), true), _ => done(lent, true), } } @@ -996,9 +996,9 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let none = target.clone().binary("===", self.b.t.none(inner)); let some = if self.b.t.needs_place(inner) { - Expr::rt("sliceOfPlace", vec![self.make_place(payload, target, span, out)]) + Expr::rs("sliceOfPlace", vec![self.make_place(payload, target, span, out)]) } else if self.b.t.write_in(inner).is_some() { - Expr::rt("sliceIn", vec![target]) + Expr::rs("sliceIn", vec![target]) } else { self.err( span, @@ -1036,7 +1036,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // A `&mut` to a value JS copies, such as through a `MutexGuard`, reads and writes // the place it borrows, as an index does, and so does one to any value a guard or // a `RefMut` holds, which is where its mutex or cell keeps it, or that an - // `rt.Place` lends, as one to a pinned box of an `Arc` does. + // `rs.Place` lends, as one to a pinned box of an `Arc` does. ("DerefMut", "deref_mut") if let ty::Ref(_, pointee, _) = dest.ty(&self.mir.local_decls, tcx).ty.kind() && (self.b.t.object_kind(*pointee).is_none() @@ -1052,7 +1052,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // The receiver passes as what it points at, as std's `&mut self` does. let values = self.operands(false, &[true], args, result, span, out); let place = self.b.call_def(def_id, gargs, values, span, out); - // A `&mut`, or a pin of one, lends the `rt.Place` it is, whose value is at `v`. + // A `&mut`, or a pin of one, lends the `rs.Place` it is, whose value is at `v`. let lent = targ(0).map(|t| match t.kind() { ty::Adt(adt, args) if Std::of(tcx, adt.did()) == Some(Std::Pin) => args.type_at(0), _ => t, @@ -1079,7 +1079,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let b = self.operand(&args[0].node, span, out); done( - Expr::rt("bytesSlice", std::iter::once(b).chain([start]).chain(end).collect()), + Expr::rs("bytesSlice", std::iter::once(b).chain([start]).chain(end).collect()), true, ) } @@ -1090,7 +1090,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let end = self.range_fields(&args[1].node, *adt, span, out).pop()?; let b = self.operand(&args[0].node, span, out); - done(Expr::rt("bytesSliceToInclusive", vec![b, end]), true) + done(Expr::rs("bytesSliceToInclusive", vec![b, end]), true) } // A range's bounds taken apart where it is made, or any other's checked as // `slice::range` checks them. A `Copy` aggregate is copied, which JS's @@ -1109,7 +1109,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { span, }; let ranged = crate::lower::collections::bounds(self.b, &call, range); - let checked = Expr::rt("boundsRange", vec![ranged.bounds.clone(), s.clone().member("length")]); + let checked = Expr::rs("boundsRange", vec![ranged.bounds.clone(), s.clone().member("length")]); let checked = ranged.after(checked); let pair = self.path(checked, "bounds", out); (pair.clone().index(Expr::lit("0")), pair.index(Expr::lit("1"))) @@ -1124,7 +1124,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "sliceCopyWithin" } }; - done(Expr::rt(f, values), true) + done(Expr::rs(f, values), true) } // An integer from an array of bytes made in place: its bytes shifted, no array made. (int, "from_be_bytes") if let Some(int) = int_named(int) => { @@ -1154,7 +1154,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // A width or precision, which the template's spec reads. Ok(None) => { let count = self.operand(&args[0].node, span, out); - return done(Expr::rt("fmtCount", vec![count]), true); + return done(Expr::rs("fmtCount", vec![count]), true); } Err(construct) => { self.err(span, format!("{construct} is not supported")); @@ -1217,7 +1217,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let value = arg(index); parts.push(match spec.object(arg) { - Some(spec) => Expr::rt("fmtSpec", vec![spec, value]), + Some(spec) => Expr::rs("fmtSpec", vec![spec, value]), None => value, }); } @@ -1237,7 +1237,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } ("Try", "branch") => { let value = self.operand(&args[0].node, span, out); - // A `Poll`'s `Pending` and `Ready(None)` are no `rt.Result`: they continue. + // A `Poll`'s `Pending` and `Ready(None)` are no `rs.Result`: they continue. if let Some(poll) = targ(0) && let (Some(Std::Poll), ty::Adt(_, poll_args)) = (self.b.t.std_of(poll), poll.kind()) { @@ -1252,13 +1252,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let ok = result_args.type_at(0); let pending = self.b.t.pending(Ty::new_option(self.tcx, ok)); - Expr::rt("pollOptionBranch", vec![value, pending, self.b.t.none(ok)]) + Expr::rs("pollOptionBranch", vec![value, pending, self.b.t.none(ok)]) } - _ => Expr::rt("pollBranch", vec![value, self.b.t.pending(inner_args.type_at(0))]), + _ => Expr::rs("pollBranch", vec![value, self.b.t.pending(inner_args.type_at(0))]), }; return done(value, false); } - // A `next`'s item or `rt.DONE` branches as itself. + // A `next`'s item or `rs.DONE` branches as itself. done(value, false) } ("FromResidual", "from_residual") => { @@ -1295,7 +1295,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let error = match value { // Made in place: its error. Expr::Call(f, mut items) - if matches!(&*f, Expr::Rt(n) if n == "Err") && items.len() == 1 => + if matches!(&*f, Expr::Rs(n) if n == "Err") && items.len() == 1 => { items.pop().expect("checked above") } @@ -1326,7 +1326,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let debug = self.b.fmt_fn(fmt::Trait::Debug, item_ty, span); let mut values = vec![list, items, debug]; values.extend(self.b.t.drop_fn(item_ty, span)); - done(Expr::rt("debugListEntries", values), true) + done(Expr::rs("debugListEntries", values), true) } _ => None, } @@ -1334,7 +1334,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// The place a `&mut` operand borrows, as an assignable path, and through the /// reference, which a store resolves: an alias of a borrowed place, not a copy of a - /// reference, which holds the object it points at, or an `rt.Place`, whose `v` it is, + /// reference, which holds the object it points at, or an `rs.Place`, whose `v` it is, /// or else the object it points at, written in place. A `[u8; N]`'s is a copy of its /// bytes instead, which the store writes in place. What it reads that is held back is /// emitted, as an edit reads it and then writes it, where MIR reads it once. @@ -1350,7 +1350,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // Named before the copy, as the store names it. let slice = self.place_expr(deref, span, out); let slice = self.slice_path(slice, out); - return Some((Expr::rt("byteSliceToArray", vec![slice]), Some(deref))); + return Some((Expr::rs("byteSliceToArray", vec![slice]), Some(deref))); } let borrowed = match &self.slots[place.local] { Slot::Alias(Some(target)) if assignable(target) && self.alias_of_place(place.local) => { @@ -1374,7 +1374,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// `slice::from_mut`, `array::from_mut`, or with `cell`, `Cell::from_mut` of `op`, a - /// `&mut` to a `ty`: of the `rt.Place` it is or of the place it names, or else in place + /// `&mut` to a `ty`: of the `rs.Place` it is or of the place it names, or else in place /// of the bytes or the object it is, which a cell reads a copy of, as a `Cell` only /// moves or copies a value out, and a slice writes its element into. A slice of one /// byte no array holds is refused, as is either of an object JS can't write a whole @@ -1391,8 +1391,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let place = op.place().filter(|p| p.projection.is_empty())?; let deref = tcx.mk_place_deref(place); let of = |made: Expr| match cell { - true => Expr::rt("cellOfPlace", vec![made]), - false => Expr::rt("sliceOfPlace", vec![made]), + true => Expr::rs("cellOfPlace", vec![made]), + false => Expr::rs("sliceOfPlace", vec![made]), }; if !cell && crate::lower::byte(ty) { return Some(self.err( @@ -1402,15 +1402,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } if self.in_bytes(deref) { let slice = self.place_expr(deref, span, out); - let view = Expr::rt("byteSliceView", vec![slice]); - return Some(Expr::rt(if cell { "cellIn" } else { "sliceIn" }, vec![view])); + let view = Expr::rs("byteSliceView", vec![slice]); + return Some(Expr::rs(if cell { "cellIn" } else { "sliceIn" }, vec![view])); } // A cell of an object reads a copy wherever it is, as its place may be one a write // lands in, such as an element of a slice of one. if cell && self.b.t.write_in(ty).is_some() { let mut made = vec![self.operand(op, span, out)]; made.extend(self.copy_depth(ty)); - return Some(Expr::rt("cellIn", made)); + return Some(Expr::rs("cellIn", made)); } if let Slot::Alias(Some(target)) = &self.slots[place.local] && assignable(target) @@ -1426,7 +1426,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } if self.b.t.write_in(ty).is_some() { let object = self.operand(op, span, out); - return Some(Expr::rt("sliceIn", vec![object])); + return Some(Expr::rs("sliceIn", vec![object])); } Some(self.err( span, @@ -1514,14 +1514,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { None => self.borrowed_place(&args[0].node, span, out)?, }; let [arg] = <[Expr; 1]>::try_from(self.operands(true, &[], &args[1..], result, span, out)).ok()?; - let ok = Expr::Rt("OK".into()); + let ok = Expr::Rs("OK".into()); let read = place.0.clone(); let (value, result) = match (name, literal) { ("write_char", _) => (read.binary("+", library::char_text(arg)), ok), ("write_fmt", Some(s)) => (read.binary("+", Expr::Str(s)), ok), // What a placeholder wrote before an error stays written. ("write_fmt", None) => { - let written = self.path(Expr::rt("fmtWriteString", vec![read, arg]), "written", out); + let written = self.path(Expr::rs("fmtWriteString", vec![read, arg]), "written", out); (written.clone().member("s"), written.member("result")) } _ => (read.binary("+", arg), ok), @@ -1542,10 +1542,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let [arg] = <[Expr; 1]>::try_from(rest).ok()?; if std == Some(Std::Formatter) { let e = match (name, literal) { - ("write_char", _) => Expr::rt("fmtWriteChar", vec![receiver, arg]), - ("write_fmt", Some(s)) => Expr::rt("fmtWriteStr", vec![receiver, Expr::Str(s)]), - ("write_fmt", None) => Expr::rt("fmtWriteFmt", vec![receiver, arg]), - _ => Expr::rt("fmtWriteStr", vec![receiver, arg]), + ("write_char", _) => Expr::rs("fmtWriteChar", vec![receiver, arg]), + ("write_fmt", Some(s)) => Expr::rs("fmtWriteStr", vec![receiver, Expr::Str(s)]), + ("write_fmt", None) => Expr::rs("fmtWriteFmt", vec![receiver, arg]), + _ => Expr::rs("fmtWriteStr", vec![receiver, arg]), }; return done(e, true); } @@ -1580,7 +1580,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } let lambda = |name: String, body: Expr| Expr::Lambda(vec![crate::ts::Param { name, ty: None }], Box::new(body)); - let write = Expr::rt("fmtWrite", vec![lambda(s, str_call), lambda(c, char_call), arg]); + let write = Expr::rs("fmtWrite", vec![lambda(s, str_call), lambda(c, char_call), arg]); return done(write, true); } }; @@ -1685,7 +1685,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } match self.b.t.owned_fn(f_ty) { Some(kind) if kind != ty::ClosureKind::FnOnce && self.b.t.drops(f_ty) => { - Expr::rt("callOnce", vec![f]) + Expr::rs("callOnce", vec![f]) } _ => f.call(Vec::new()), } @@ -1723,8 +1723,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// `name = recv.next()` of a range of numbers, stepped in place rather than through - /// `rt.Range`'s generic steps, into the item alone and a flag for whether there was - /// one: a number that is sometimes `rt.DONE` is slower in V8. Past the end, `name` is + /// `rs.Range`'s generic steps, into the item alone and a flag for whether there was + /// one: a number that is sometimes `rs.DONE` is slower in V8. Past the end, `name` is /// left as it was, since only `Some` reads it. A range only `next` reads (`stepped`) /// steps past its end too, so the flag is one comparison, to hold back for the switch /// that reads it; it assigns `name` only if something reads it (`read`). @@ -1781,7 +1781,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if place.1.is_some_and(|p| self.in_object(p)) { let mut made = vec![place.0, value]; made.extend(self.copy_depth(ty)); - let old = Expr::rt("replaceIn", made); + let old = Expr::rs("replaceIn", made); let Some(base) = base else { out.push(StmtKind::Expr(old).at(None)); return Expr::undefined(); @@ -1798,11 +1798,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if let Some((slice, index)) = self.element_in(&place, ty) { let mut made = vec![slice, index, value]; made.extend(self.copy_depth(ty)); - let old = Expr::rt("sliceReplace", made); + let old = Expr::rs("sliceReplace", made); out.push(StmtKind::decl(false, name.clone(), None, Some(old)).at(None)); return Expr::ident(name); } - // TypeScript widens `rt.None` read from a place narrowed to it into a `symbol`. + // TypeScript widens `rs.None` read from a place narrowed to it into a `symbol`. let declared = self.b.t.erases_to(ty).none.then(|| self.b.t.ty(ty, span)); out.push(StmtKind::decl(false, name.clone(), declared, Some(place.0.clone())).at(None)); self.set_borrowed(&place, value, span, out); @@ -1900,13 +1900,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { "index_mut" | "get_mut" => base.clone().member("v"), _ => base.clone(), }; - let len = || Expr::rt("stringLen", vec![text.clone()]); + let len = || Expr::rs("stringLen", vec![text.clone()]); let checked = match (get, self.b.t.std_of(index_ty)) { - (true, _) => Expr::rt("sliceGetBounds", vec![range, len()]), + (true, _) => Expr::rs("sliceGetBounds", vec![range, len()]), (_, Some(Std::RangeInclusive | Std::RangeToInclusive)) => { - Expr::rt("strInclusive", vec![text.clone(), range]) + Expr::rs("strInclusive", vec![text.clone(), range]) } - _ => Expr::rt("boundsRange", vec![range, len()]), + _ => Expr::rs("boundsRange", vec![range, len()]), }; let pair = self.path(checked, "bounds", out); ( @@ -1924,7 +1924,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let mut values = vec![base, start]; values.extend(end); - return Some(Some((Expr::rt(f, values), true))); + return Some(Some((Expr::rs(f, values), true))); } let elem_ty = elem(self.tcx, container)?; let bytes = crate::lower::byte(elem_ty); @@ -1939,7 +1939,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let base = self.path(base, "slice", out); let i = self.operand(&args[1].node, span, out); let i = self.path(i, "index", out); - let checked = Expr::rt("idx", vec![base.clone(), i]); + let checked = Expr::rs("idx", vec![base.clone(), i]); let checked = self.path(checked, "at", out); let place = match container.kind() { ty::Adt(..) if bytes => base.member("data").index(checked), @@ -1951,7 +1951,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; // A reference to an array of bytes is a slice of them. if crate::lower::byte_array(elem_ty) { - return Some(Some((Expr::rt("byteSliceFrom", vec![place]), true))); + return Some(Some((Expr::rs("byteSliceFrom", vec![place]), true))); } // The reference reads and writes the element where it is. if let Some(local) = dest.as_local() @@ -1971,7 +1971,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let get = matches!(name, "get" | "get_mut"); let lent = matches!(name, "index_mut" | "get_mut"); // The range's bounds are taken apart before the slice is read, while they are - // still held back. Any other range, as an `rt.Bounds`, is checked by the + // still held back. Any other range, as an `rs.Bounds`, is checked by the // runtime, as std checks its own fields, into a start and end. let bounds = match self.range_bounds(&args[1].node, index_ty, span, out) { Some(bounds) => Ok(bounds), @@ -1999,7 +1999,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { true => "sliceGetBounds", false => "sliceIndexBounds", }; - let pair = self.path(Expr::rt(checked, vec![range, length]), "bounds", out); + let pair = self.path(Expr::rs(checked, vec![range, length]), "bounds", out); (pair.clone().index(Expr::lit("0")), Some(pair.index(Expr::lit("1")))) } }; @@ -2015,7 +2015,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { (false, false, false) => "sliceRange", (false, false, true) => "sliceGetRange", }; - Some(Some((Expr::rt(range, values), true))) + Some(Some((Expr::rs(range, values), true))) } } } @@ -2067,7 +2067,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// What a `DebugList` iterates, as an iterable JS value: an array or `Vec`'s elements, - /// whose items the runtime drops if it owns them, or else an `rt.Iter`, which it drops + /// whose items the runtime drops if it owns them, or else an `rs.Iter`, which it drops /// once done. fn items(&mut self, value: Expr, ty: Ty<'tcx>, span: Span) -> Option { let tcx = self.tcx; @@ -2127,8 +2127,8 @@ pub fn control_flow_test<'tcx>( let continues = variant.index() == 0; if next { return match continues { - true => scrut.clone().binary("!==", Expr::Rt("DONE".into())), - false => scrut.clone().binary("===", Expr::Rt("DONE".into())), + true => scrut.clone().binary("!==", Expr::Rs("DONE".into())), + false => scrut.clone().binary("===", Expr::Rs("DONE".into())), }; } let ty::Adt(_, args) = ty.kind() else { diff --git a/ts/src/lower/mir/cfg.rs b/ts/src/lower/mir/cfg.rs index 167986baa..a0f65fd94 100644 --- a/ts/src/lower/mir/cfg.rs +++ b/ts/src/lower/mir/cfg.rs @@ -673,7 +673,7 @@ fn unlabel(stmts: &mut [Stmt], innermost: Option<&str>, in_switch: bool) { /// Whether evaluating `e` does nothing but read. pub fn pure(e: &Expr) -> bool { match e { - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => true, + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => true, Expr::Member(base, _) | Expr::Unary(_, base) | Expr::Located(_, base) diff --git a/ts/src/lower/mir/memory.rs b/ts/src/lower/mir/memory.rs index 83d84745b..adf0c8860 100644 --- a/ts/src/lower/mir/memory.rs +++ b/ts/src/lower/mir/memory.rs @@ -1,10 +1,10 @@ //! Values read from the memory rustc evaluated: a `static`'s, and a `const`'s that holds a //! cell or has no value tree. //! -//! An atomic is a new `rt.Atomic` of the value read, a one-time cell the runtime's, empty, +//! An atomic is a new `rs.Atomic` of the value read, a one-time cell the runtime's, empty, //! and a lazy one the runtime's over its function, as const evaluation leaves them. A //! `MaybeUninit` is what it holds or nothing yet, as [`crate::lower::pointer`] has it, and -//! an `UnsafeCell` a new `rt.Cell` of its contents, which a `Cell` is too. +//! an `UnsafeCell` a new `rs.Cell` of its contents, which a `Cell` is too. use rustc_abi::{BackendRepr, Primitive, Size}; use rustc_middle::mir::interpret::{GlobalAlloc, InitChunk, Scalar, alloc_range}; @@ -25,13 +25,13 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { }; let e = match Std::of(tcx, adt.did()) { Some(Std::Cell) => match self.fields(val, ty).as_deref() { - // A `Cell`'s field is its `UnsafeCell`, which is the same `rt.Cell`. + // A `Cell`'s field is its `UnsafeCell`, which is the same `rs.Cell`. Some([(value, inner)]) if !tcx.is_lang_item(adt.did(), rustc_attr_ir::LangItem::UnsafeCell) => { self.const_value(*value, *inner, span) } Some([(value, inner)]) => { let value = self.const_value(*value, *inner, span); - Expr::New(Box::new(Expr::Rt("Cell".into())), vec![value]) + Expr::New(Box::new(Expr::Rs("Cell".into())), vec![value]) } _ => self.unreadable(ty, span), }, @@ -40,7 +40,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { match self.scalar(val, inner) { Some(scalar) => { let value = self.const_value(ConstValue::Scalar(scalar), inner, span); - Expr::New(Box::new(Expr::Rt("Atomic".into())), vec![value]) + Expr::New(Box::new(Expr::Rs("Atomic".into())), vec![value]) } None => self.unreadable(ty, span), } @@ -86,10 +86,10 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { Some(e) } - /// A new `rt.LazyCell` or `rt.LazyLock`, `class`, that `f`, an `f_ty`, initializes. + /// A new `rs.LazyCell` or `rs.LazyLock`, `class`, that `f`, an `f_ty`, initializes. fn lazy(&mut self, class: &str, (f, f_ty): (ConstValue, Ty<'tcx>), span: Span) -> Expr { let f = self.const_value(f, f_ty, span); - Expr::New(Box::new(Expr::Rt(class.into())), vec![f]) + Expr::New(Box::new(Expr::Rs(class.into())), vec![f]) } /// The refusal of a `ty` in a state translation can't read, as a `OnceLock` const diff --git a/ts/src/lower/mir/mod.rs b/ts/src/lower/mir/mod.rs index 798cc48b9..869d0aa86 100644 --- a/ts/src/lower/mir/mod.rs +++ b/ts/src/lower/mir/mod.rs @@ -73,7 +73,7 @@ pub fn function<'a, 'tcx>(t: &mut Translator<'a, 'tcx>, instance: Instance<'tcx> let ret_span = fx.local_span(mir::RETURN_PLACE); let ret = match (next, ret_ty.kind()) { (true, ty::Adt(_, args)) => { - Type::Union(vec![fx.b.t.ty(args.type_at(0), ret_span), Type::Rt("Done", Vec::new())]) + Type::Union(vec![fx.b.t.ty(args.type_at(0), ret_span), Type::Rs("Done", Vec::new())]) } (_, ty::Adt(..)) if let Some(slotted) = &slotted => fx.b.t.slot_ret_ty(slotted, ret_span), _ => fx.b.t.ret_ty(ret_ty, ret_span), @@ -294,7 +294,7 @@ pub enum Env { pub struct Capture { pub value: Expr, /// Whether `value` is the place a `&mut` captured by reference borrows, which the - /// closure reads and writes as JS's do, rather than an `rt.Place` of it or the object + /// closure reads and writes as JS's do, rather than an `rs.Place` of it or the object /// there. pub pointee: bool, } @@ -379,7 +379,7 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { assigned: IndexVec, span: Span, pub labels: u32, - /// Whether this is an `Iterator::next`'s body, which returns an item or `rt.DONE`. + /// Whether this is an `Iterator::next`'s body, which returns an item or `rs.DONE`. next: bool, /// Blocks whose only statement is `unreachable`. unreachable: FxHashSet, @@ -407,7 +407,7 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { ignored_sites: Vec, /// The operands of aggregates assigned once to locals nothing changes. var_parts: FxHashMap>, - /// Locals holding what `Iterator::next` returns by the protocol: an item or `rt.DONE`. + /// Locals holding what `Iterator::next` returns by the protocol: an item or `rs.DONE`. next_results: FxHashSet, /// Next results of a range of numbers stepped in place: each holds only the item, so /// JS keeps it a number, and a flag holds whether there was one. @@ -428,7 +428,7 @@ pub struct Fx<'m, 'b, 'a, 'tcx> { /// Statements that change nothing: a swap through a temporary nothing else names, as /// an async body moves its context at each `await`. noops: FxHashSet<(BasicBlock, usize)>, - /// The lengths a bounds check compares with, of the slices whose `rt.idx` it is. + /// The lengths a bounds check compares with, of the slices whose `rs.idx` it is. idx_of: FxHashMap>, /// The halves a `|` joins into a `u64`, by the local of the shift that is its left side. halves: FxHashMap, &'m Operand<'tcx>)>, @@ -691,7 +691,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } } - // A bounds check of a slice's length is `rt.idx` of the slice; others test their + // A bounds check of a slice's length is `rs.idx` of the slice; others test their // condition, and show their operands. for (cond, len, index) in bounds { if let Operand::Copy(l) | Operand::Move(l) = len @@ -1236,7 +1236,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// Locals an `Iterator::next` assigns that only a switch on their variant and a read - /// of `Some`'s value read: each holds the item or `rt.DONE`, as the protocol returns + /// of `Some`'s value read: each holds the item or `rs.DONE`, as the protocol returns /// it, so an iterator of `Option` keeps each `None` apart from its end. fn find_next_results(&mut self) { use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor}; @@ -1294,7 +1294,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { continue; }; // The return place leaves as the `Option` the signature declares, unless this is a - // `next` itself, which returns the protocol's item or `rt.DONE` below. + // `next` itself, which returns the protocol's item or `rs.DONE` below. if crate::lower::iter::is_next(tcx, def_id) && self.defs[local] == 1 && local != mir::RETURN_PLACE { nexts.push((local, gargs.skip_binder().type_at(0))); } @@ -1323,7 +1323,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if !uses.ok { continue; } - // What `?` branches to holds the same: the item, or `rt.DONE` to return early. + // What `?` branches to holds the same: the item, or `rs.DONE` to return early. if let Some((_, to)) = branch { let mut uses = Uses { local: to, @@ -1342,19 +1342,19 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } self.next_results.insert(local); } - // An `Iterator::next` returns the item or `rt.DONE` too. + // An `Iterator::next` returns the item or `rs.DONE` too. if self.next { self.next_results.insert(mir::RETURN_PLACE); } } - /// Whether `place` is a whole `next` result, which holds the item or `rt.DONE`. + /// Whether `place` is a whole `next` result, which holds the item or `rs.DONE`. fn next_result(&self, place: Place<'tcx>) -> bool { place.as_local().is_some_and(|l| self.next_results.contains(&l)) } /// Each `(hi as u64) << 32 | lo as u64` of halves of at most 32 bits, as moq's - /// `from_halves` writes it, which lowers to `rt.u64FromHalves(hi, lo)`: no shift that + /// `from_halves` writes it, which lowers to `rs.u64FromHalves(hi, lo)`: no shift that /// boxes limbs past 2^53, and no `|` that unboxes them. Its shift and casts go /// unlowered, so it reads the halves where the `|` is, which takes temporaries read /// once, of halves nothing assigns again. @@ -1460,17 +1460,17 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// An `Option` this `Iterator::next` returns, as it returns it: the item, or - /// `rt.DONE` for `None`. + /// `rs.DONE` for `None`. pub(super) fn done_of(&self, option: Expr) -> Expr { let ty::Adt(_, args) = self.mir.return_ty().kind() else { unreachable!("`next` returns an `Option`") }; let none = self.b.t.none(args.type_at(0)); match option { - option if option == none => Expr::Rt("DONE".into()), + option if option == none => Expr::Rs("DONE".into()), option => { let none = self.b.t.none_arg(args.type_at(0)); - Expr::rt("iterFromOption", [option].into_iter().chain(none).collect()) + Expr::rs("iterFromOption", [option].into_iter().chain(none).collect()) } } } @@ -1628,8 +1628,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let mut entry = Vec::new(); // A slice passed as its parts that isn't held so, made from them. for (local, name, parts) in std::mem::take(&mut self.rebuilt) { - let slice = Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.map(Expr::ident).to_vec()); - let ty = Type::Rt("ByteSlice", Vec::new()); + let slice = Expr::New(Box::new(Expr::Rs("ByteSlice".into())), parts.map(Expr::ident).to_vec()); + let ty = Type::Rs("ByteSlice", Vec::new()); entry.push(StmtKind::decl(self.defs[local] > 0, name, Some(ty), Some(slice)).at(None)); } for local in self.mir.args_iter() { @@ -1822,7 +1822,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if self.range_nexts.contains(&local) { return item; } - return Type::Union(vec![item, Type::Rt("Done", Vec::new())]); + return Type::Union(vec![item, Type::Rs("Done", Vec::new())]); } let ty = match (self.checked.contains(&local), ty.kind()) { (true, ty::Tuple(tys)) => tys[0], @@ -2549,7 +2549,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(e) => self.path(e, "view", out), None => match self.reborrowed(*kind, *p, span, out) { Some(e) => e, - // Read whole, the place is held as it is now for its `rt.Place`. + // Read whole, the place is held as it is now for its `rs.Place`. None if self.points_at_place(local) && self.read_whole(local) => { let target = self.place_expr(*p, span, out); self.stable_target(*p, target, span, out) @@ -2654,7 +2654,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ) { (false, _) => value, (true, Rvalue::Aggregate(kind, _)) if matches!(**kind, mir::AggregateKind::Adt(_, v, ..) if v.as_u32() == 0) => { - Expr::Rt("DONE".into()) + Expr::Rs("DONE".into()) } (true, Rvalue::Aggregate(..)) => value, (true, Rvalue::Use(Operand::Move(p) | Operand::Copy(p), _)) @@ -2698,7 +2698,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Expr::ident(name) } - /// Hold `slice`, an `rt.ByteSlice` to read more than once, in a path, as a tuple's part + /// Hold `slice`, an `rs.ByteSlice` to read more than once, in a path, as a tuple's part /// already is. pub(super) fn slice_path(&mut self, slice: Expr, out: &mut Vec) -> Expr { match &slice { @@ -2716,7 +2716,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// of, if it is one at a constant offset. pub(super) fn bytes_at(&mut self, slice: Expr, n: u64, out: &mut Vec) -> Vec { let range = match &slice { - Expr::Call(f, args) if matches!(&**f, Expr::Rt(name) if name == "byteSliceRange") => { + Expr::Call(f, args) if matches!(&**f, Expr::Rs(name) if name == "byteSliceRange") => { match args.as_slice() { [base, Expr::Lit(from), ..] => from.parse::().ok().map(|from| (base.clone(), from)), _ => None, @@ -2819,7 +2819,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // unreachable too: it has no value to return, and `tsc` must see that. TerminatorKind::Unreachable | TerminatorKind::Return => { self.emit( - vec![StmtKind::Expr(Expr::rt("unreachable", vec![Expr::undefined()])).at(None)], + vec![StmtKind::Expr(Expr::rs("unreachable", vec![Expr::undefined()])).at(None)], false, out, ); @@ -3085,7 +3085,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.emit(pre, false, out); return; } - pre.push(StmtKind::Expr(Expr::rt("idx", vec![slice, index])).at(self.b.t.loc(span))); + pre.push(StmtKind::Expr(Expr::rs("idx", vec![slice, index])).at(self.b.t.loc(span))); self.emit(pre, false, out); return; } @@ -3130,22 +3130,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// The panic of an assert that fails: the runtime's own function for a coroutine - /// resumed out of turn, as rustc calls a lang item, else `rt.panic`. + /// resumed out of turn, as rustc calls a lang item, else `rs.panic`. fn assert_panic(&mut self, msg: &mir::AssertMessage<'tcx>, operands: Vec, span: Span) -> Option { use mir::AssertKind; use rustc_hir::{CoroutineDesugaring, CoroutineKind}; let async_fn = |kind: &CoroutineKind| matches!(kind, CoroutineKind::Desugared(CoroutineDesugaring::Async, _)); match msg { - AssertKind::ResumedAfterReturn(kind) if async_fn(kind) => Some(Expr::rt("asyncFnResumed", Vec::new())), - AssertKind::ResumedAfterPanic(kind) if async_fn(kind) => Some(Expr::rt("asyncFnResumedPanic", Vec::new())), + AssertKind::ResumedAfterReturn(kind) if async_fn(kind) => Some(Expr::rs("asyncFnResumed", Vec::new())), + AssertKind::ResumedAfterPanic(kind) if async_fn(kind) => Some(Expr::rs("asyncFnResumedPanic", Vec::new())), // A hook reads a bounds check's message as the `String` std formats. AssertKind::BoundsCheck { .. } if let Some(at) = self.panic_at() => { let message = self.assert_message(msg, operands, span)?; - Some(Expr::rt("panic", vec![message, at, Expr::lit("true")])) + Some(Expr::rs("panic", vec![message, at, Expr::lit("true")])) } _ => { let message = self.assert_message(msg, operands, span)?; - Some(Expr::rt("panic", vec![message])) + Some(Expr::rs("panic", vec![message])) } } } @@ -3358,7 +3358,7 @@ pub(super) fn whole(value: Expr, ty: Type) -> Result { } match inner { Expr::As(_, t) if *t == ty => Ok(value), - Expr::Call(f, _) if matches!(&**f, Expr::Rt(n) if n == "Ok" || n == "Err") => Err(value), + Expr::Call(f, _) if matches!(&**f, Expr::Rs(n) if n == "Ok" || n == "Err") => Err(value), _ => Ok(Expr::As(Box::new(value.typed()), ty)), } } @@ -3480,11 +3480,11 @@ fn field(base: &Expr) -> Read { fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { match e { Expr::Ident(name) => reads.push(Read::Ident(name.clone(), lazy)), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| scan(e, reads, lazy)), Expr::Object(props) => props.iter().for_each(|(_, e)| scan(e, reads, lazy)), // The runtime's and the program's own items never change. - Expr::Member(base, _) if matches!(&**base, Expr::Rt(_) | Expr::Sym(_)) => {} + Expr::Member(base, _) if matches!(&**base, Expr::Rs(_) | Expr::Sym(_)) => {} Expr::Member(base, _) => { scan(base, reads, lazy); reads.push(field(base)); @@ -3495,7 +3495,7 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { reads.push(field(base)); } // A byte slice made of its parts only holds them. - Expr::New(f, args) if matches!(&**f, Expr::Rt(name) if name == "ByteSlice") => { + Expr::New(f, args) if matches!(&**f, Expr::Rs(name) if name == "ByteSlice") => { args.iter().for_each(|e| scan(e, reads, lazy)) } Expr::Call(f, args) | Expr::New(f, args) => { @@ -3506,7 +3506,7 @@ fn scan(e: &Expr, reads: &mut Vec, lazy: bool) { } args.iter().for_each(|e| scan(e, reads, lazy)); reads.push(match &**f { - Expr::Rt(name) if reads_only(name) => Read::Panic, + Expr::Rs(name) if reads_only(name) => Read::Panic, _ => Read::Effect, }); } @@ -3610,7 +3610,7 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { *e = value.clone(); true } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => false, + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => false, Expr::Array(items) => items.iter_mut().any(|e| subst(e, name, value)), Expr::Object(props) => props.iter_mut().any(|(_, e)| subst(e, name, value)), Expr::Member(base, key) => { @@ -3619,14 +3619,14 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { } // The payload of a `Result` made here is what it was made of, which `tsc` reads // where it can't narrow the `Result`, cast to its variant or not, and so is what an - // `rt.Place` made here holds. + // `rs.Place` made here holds. let made = match step::peel(base) { Expr::As(made, _) => step::peel(made), base => base, }; let folded = match (made, &*key) { (Expr::Call(f, args), ts::Key::Name(key)) - if let Expr::Rt(ctor) = step::peel(f) + if let Expr::Rs(ctor) = step::peel(f) && matches!((ctor.as_str(), key.as_str()), ("Ok", "value") | ("Err", "error")) && let [payload] = args.as_slice() => { @@ -3647,7 +3647,7 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { } // A result of what folded in as `undefined` is the shared one. if let Expr::Call(f, args) = &*e - && let (Expr::Rt(ctor), [arg]) = (&**f, args.as_slice()) + && let (Expr::Rs(ctor), [arg]) = (&**f, args.as_slice()) && matches!(ctor.as_str(), "Ok" | "Err") { *e = Expr::result(ctor == "Ok", arg.clone()); @@ -3655,10 +3655,10 @@ fn subst(e: &mut Expr, name: &str, value: &Expr) -> bool { // An `Ok` made in place unwraps to its value, as a lock's does, unless what would // show or replace an error has an effect. if let Expr::Call(f, args) = &*e - && let (Expr::Rt(unwrap), [result, rest @ ..]) = (&**f, args.as_slice()) + && let (Expr::Rs(unwrap), [result, rest @ ..]) = (&**f, args.as_slice()) && matches!(unwrap.as_str(), "resultUnwrap" | "resultExpect" | "resultUnwrapOrElse") && let Expr::Call(ok, value) = result.unlocated() - && matches!(&**ok, Expr::Rt(ok) if ok == "Ok") + && matches!(&**ok, Expr::Rs(ok) if ok == "Ok") && let [value] = value.as_slice() && rest .iter() @@ -3776,7 +3776,7 @@ fn assigned(stmts: &[Stmt]) -> FxHashSet { fn reads_of(e: &Expr, out: &mut Vec) { match e { Expr::Ident(name) => out.push(name.clone()), - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| reads_of(e, out)), Expr::Object(props) => props.iter().for_each(|(_, e)| reads_of(e, out)), Expr::Member(base, _) => reads_of(base, out), @@ -3990,7 +3990,7 @@ fn visit_stmt(stmt: &Stmt, f: &mut dyn FnMut(&Expr)) { fn visit_expr(e: &Expr, f: &mut dyn FnMut(&Expr)) { f(e); match e { - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Array(items) => items.iter().for_each(|e| visit_expr(e, f)), Expr::Object(props) => props.iter().for_each(|(_, e)| visit_expr(e, f)), Expr::Member(e, _) @@ -4034,7 +4034,7 @@ fn parts_of(value: &Expr, slices: &FxHashSet) -> Option { let (start, length) = (props.next()?.1.clone(), props.next()?.1.clone()); Expr::New( - Box::new(Expr::Rt("ByteSlice".into())), + Box::new(Expr::Rs("ByteSlice".into())), vec![value.clone(), start, length], ) } @@ -4043,7 +4043,7 @@ fn parts_of(value: &Expr, slices: &FxHashSet) -> Option { + Expr::New(f, items) if matches!(&**f, Expr::Rs(name) if name == "Range" || name == "RangeFrom") => { Some(items.clone()) } _ => None, diff --git a/ts/src/lower/mir/origin.rs b/ts/src/lower/mir/origin.rs index bd247923e..8e44affe3 100644 --- a/ts/src/lower/mir/origin.rs +++ b/ts/src/lower/mir/origin.rs @@ -413,8 +413,8 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { Expr::Ident(_) => arc, _ => self.b.spill(arc, "arc", out), }; - let p = Expr::rt("arcPlace", vec![arc.clone()]); - Some(Expr::rt("arcRaw", vec![arc, p, Expr::Str(owner)])) + let p = Expr::rs("arcPlace", vec![arc.clone()]); + Some(Expr::rs("arcRaw", vec![arc, p, Expr::Str(owner)])) } /// Whether the raw pointer `op` to a value JS copies is an `Arc`'s or `Rc`'s, as diff --git a/ts/src/lower/mir/place.rs b/ts/src/lower/mir/place.rs index 5a549ca01..fe5e8c6ec 100644 --- a/ts/src/lower/mir/place.rs +++ b/ts/src/lower/mir/place.rs @@ -37,14 +37,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match &self.slots[local] { Slot::Var(name) => Expr::ident(name), // A value of type `!`, as a generic instantiated at `!` reads: native code never - // gets here, and `tsc` sees that through `rt.unreachable`. - Slot::Unit if self.mir.local_decls[local].ty.is_never() => Expr::rt("unreachable", vec![Expr::undefined()]), + // gets here, and `tsc` sees that through `rs.unreachable`. + Slot::Unit if self.mir.local_decls[local].ty.is_never() => Expr::rs("unreachable", vec![Expr::undefined()]), // A function item holds no value, so each read names the function. Slot::Unit if let ty::FnDef(def_id, args) = *self.mir.local_decls[local].ty.kind() => { self.b.fn_value(def_id, args.skip_binder(), span) } Slot::Unit => Expr::undefined(), - // Passed on or kept, a `&mut` to a borrowed place JS copies is its `rt.Place`. + // Passed on or kept, a `&mut` to a borrowed place JS copies is its `rs.Place`. Slot::Alias(Some(target)) if self.points_at_place(local) => { let target = target.clone(); let payload = match self.def_rvalue(local) { @@ -113,7 +113,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { projection.next(); value } - // Passed on or kept whole, it is the place's `rt.Place`, or the + // Passed on or kept whole, it is the place's `rs.Place`, or the // object there. None if pointee && self.b.t.place_pointee(pty.ty).is_some() => self.place_of(value, None), _ => value, @@ -188,7 +188,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ) -> Expr { let tcx = self.tcx; let decls = &self.mir.local_decls; - // Whether `e` is an `rt.ByteSlice` of the place's bytes: a `[u8]`, or a `[u8; N]` + // Whether `e` is an `rs.ByteSlice` of the place's bytes: a `[u8]`, or a `[u8; N]` // behind a reference or raw pointer. let mut in_bytes = false; // The projections a union's field consumed with it, down to a slot. @@ -284,13 +284,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { if let Some([data, start, length]) = made_slice(&base) { let len = super::scalar::sub(length.clone(), Expr::lit((from + to).to_string())); let start = super::scalar::add(start.clone(), Expr::lit(from.to_string())); - e = Expr::New(Box::new(Expr::Rt("ByteSlice".into())), vec![data.clone(), start, len]); + e = Expr::New(Box::new(Expr::Rs("ByteSlice".into())), vec![data.clone(), start, len]); } else { let mut values = vec![base.clone(), Expr::lit(from.to_string())]; if to != 0 { values.push(base.member("length").binary("-", Expr::lit(to.to_string()))); } - e = Expr::rt("byteSliceRange", values); + e = Expr::rs("byteSliceRange", values); } } // Part of a `[u8; N]` behind a reference, as `[a, rest @ ..]` of a `&[u8; N]`. @@ -304,7 +304,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { e = match made_slice(&base) { // In bounds of the array's. Some([data, start, _]) => Expr::New( - Box::new(Expr::Rt("ByteSlice".into())), + Box::new(Expr::Rs("ByteSlice".into())), vec![ data.clone(), super::scalar::add(start.clone(), Expr::lit(from.to_string())), @@ -313,7 +313,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { ), None => { let values = vec![base, Expr::lit(from.to_string()), Expr::lit(end.to_string())]; - Expr::rt("byteSliceRange", values) + Expr::rs("byteSliceRange", values) } }; } @@ -393,7 +393,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// Whether `place` is a `[u8; N]` read through a reference or raw pointer, or a - /// `MaybeUninit` of one through a raw pointer, whose JS value is an `rt.ByteSlice` of + /// `MaybeUninit` of one through a raw pointer, whose JS value is an `rs.ByteSlice` of /// its bytes rather than a `Uint8Array`, as [`Self::place_expr`] reads it. pub(super) fn in_bytes(&self, place: Place<'tcx>) -> bool { let mut in_bytes = false; @@ -409,7 +409,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// Whether `ty`, which projection `at` of a place of `local` derefs, is an - /// `rt.ByteSlice` of the bytes it points at: a reference or a raw pointer to a + /// `rs.ByteSlice` of the bytes it points at: a reference or a raw pointer to a /// `[u8; N]`, but not a box's pointer, which is the box. fn bytes_behind(&self, local: Local, at: usize, ty: Ty<'tcx>) -> bool { use crate::lower::pointer::Pointee; @@ -459,13 +459,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let base = self.place_expr(base.to_place(self.tcx), span, out); let base = self.path(base, "slice", out); let end = self.subslice_end(&base, ty, to, from_end); - Some(Expr::rt("sliceView", vec![base, Expr::lit(from.to_string()), end])) + Some(Expr::rs("sliceView", vec![base, Expr::lit(from.to_string()), end])) } /// `base`, a `ty`, cast to its `variant`, which MIR reads without a switch where the /// others can't be, as a derived `==` reads the other operand after comparing /// discriminants. `tsc` narrows only what a switch tests, and nothing read through a - /// cast, as a generic type's `rt.Ptr` field is read as its instance's type. + /// cast, as a generic type's `rs.Ptr` field is read as its instance's type. fn as_variant(&mut self, base: Expr, ty: Ty<'tcx>, variant: VariantIdx, span: Span) -> Expr { match ty.kind() { ty::Adt(adt, _) @@ -492,8 +492,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { variant: VariantIdx, span: Span, ) -> Expr { - // `rt.Entry` is one class for either variant, which TypeScript narrows nothing by, as is - // `rt.TableEntry`. + // `rs.Entry` is one class for either variant, which TypeScript narrows nothing by, as is + // `rs.TableEntry`. let entry = |adt: &ty::AdtDef<'_>| matches!(Std::of(self.tcx, adt.did()), Some(Std::Entry | Std::TableEntry)); if matches!(ty.kind(), ty::Adt(adt, _) if entry(adt)) { return base; @@ -518,7 +518,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let ty::Adt(adt, args) = ty.kind() else { return None; }; - // `rt.Result`'s variants. + // `rs.Result`'s variants. let result = |ok: bool, payload| { let (flag, name) = match ok { true => ("true", "value"), @@ -544,7 +544,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(match (Flow::of(tcx, args), variant.index()) { (Flow::Option, 0) => self.b.t.ty(continues, span), (Flow::Option, _) => match self.b.t.erases_to(continues).undefined { - true => crate::ts::Type::Rt("None", vec![]), + true => crate::ts::Type::Rs("None", vec![]), false => crate::ts::Type::Builtin("undefined"), }, (Flow::Result | Flow::Other, 0) => result(true, self.b.t.ty(continues, span)), @@ -626,25 +626,25 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(std) if std.record() => { base.member(crate::lower::camel(adt.non_enum_variant().fields[field].name.as_str())) } - // Cast to its variant's class: what an `rt.Borrowed` wraps, or what it owns. + // Cast to its variant's class: what an `rs.Borrowed` wraps, or what it owns. Some(Std::Cow) if let Some(borrowed) = crate::lower::library::cow_borrowed(tcx, ty) => { let bytes = crate::lower::library::cow_slice(tcx, ty).is_some_and(crate::lower::byte); let owned = variant.is_some_and(|v| v.index() == 1); - // What an `rt.Borrowed` holds, and what it owns: an array and an `rt.Vec`, or text. + // What an `rs.Borrowed` holds, and what it owns: an array and an `rs.Vec`, or text. let (held, owns) = match borrowed.kind() { ty::Slice(elem) => { let elem = self.b.t.ty(*elem, span); ( crate::ts::Type::Array(Box::new(elem.clone())), - crate::ts::Type::Rt("Vec", vec![elem]), + crate::ts::Type::Rs("Vec", vec![elem]), ) } _ => (crate::ts::Type::Builtin("string"), crate::ts::Type::Builtin("string")), }; let class = match (bytes, owned) { - (true, false) => crate::ts::Type::Rt("ByteSlice", Vec::new()), - (true, true) => crate::ts::Type::Rt("ByteVec", Vec::new()), - (false, false) => crate::ts::Type::Rt("Borrowed", vec![held]), + (true, false) => crate::ts::Type::Rs("ByteSlice", Vec::new()), + (true, true) => crate::ts::Type::Rs("ByteVec", Vec::new()), + (false, false) => crate::ts::Type::Rs("Borrowed", vec![held]), (false, true) => owns, }; let cast = Expr::As(Box::new(base), class); @@ -689,7 +689,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // An array of bytes read through a reference, copied out of its slice. Operand::Copy(place) | Operand::Move(place) if self.in_bytes(*place) => { let value = self.place_expr(*place, span, out); - Expr::rt("byteSliceToArray", vec![value]) + Expr::rs("byteSliceToArray", vec![value]) } // JS shares objects where Rust copies, so a `Copy` aggregate is copied where // either side could change in place: into a local changed in place, or out of a @@ -774,22 +774,22 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { return out; } // `*r = v` replaces the object `r` points at in place, which other references and - // captures share. An alias of a borrowed place assigns the place, and an `rt.Place` + // captures share. An alias of a borrowed place assigns the place, and an `rs.Place` // its `v`. if let Some(pointee) = self.pointee_object(place) { let target = self.local_expr(place.local, span); let raw = matches!(self.mir.local_decls[place.local].ty.kind(), ty::RawPtr(..)) && !self.box_pointer(place.local); let e = match raw { - true => Expr::rt("ptrWrite", vec![target, value]), + true => Expr::rs("ptrWrite", vec![target, value]), false => match self.b.t.write_in(pointee) { Some(ObjectKind::Bytes) => target.member("set").call(vec![value]), // A boxed slice is a JS array, whose length a write changes, unlike a // tuple's or an array's. Some(ObjectKind::Array) if self.b.t.erased(pointee).is_slice() => { - Expr::rt("arrayAssign", vec![target, value]) + Expr::rs("arrayAssign", vec![target, value]) } - Some(_) if self.b.t.moves_private(pointee) => Expr::rt("ptrWrite", vec![target, value]), + Some(_) if self.b.t.moves_private(pointee) => Expr::rs("ptrWrite", vec![target, value]), Some(_) => Expr::ident("Object").member("assign").call(vec![target, value]), None => self.err(span, format!("an assignment through a reference to `{pointee}`")), }, @@ -833,7 +833,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// What `place` is, where it is `*r` for an `r` that is the object it points at, with - /// no place known to hold it: neither an alias of a borrowed place, nor an `rt.Place`, + /// no place known to hold it: neither an alias of a borrowed place, nor an `rs.Place`, /// nor a closure's environment, nor an alias of a reference to no object, such as a /// `&mut &str`, which only an alias of the place it borrows can be. pub(super) fn pointee_object(&self, place: Place<'tcx>) -> Option> { @@ -954,13 +954,13 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Some(capture.value.clone()) } - /// Whether `local` is an `rt.Place` reference that aliases the place it borrows, so its - /// target is that place rather than the `rt.Place`. + /// Whether `local` is an `rs.Place` reference that aliases the place it borrows, so its + /// target is that place rather than the `rs.Place`. pub(super) fn points_at_place(&self, local: Local) -> bool { self.b.t.place_pointee(self.mir.local_decls[local].ty).is_some() && self.alias_of_place(local) } - /// The `rt.Place` of `target`, the JS path of the borrowed `place`, fixed where it is now. + /// The `rs.Place` of `target`, the JS path of the borrowed `place`, fixed where it is now. pub(super) fn make_place(&mut self, place: Place<'tcx>, target: Expr, span: Span, out: &mut Vec) -> Expr { let target = self.stable_target(place, target, span, out); let payload = self.payload_ty(place, span); @@ -1021,7 +1021,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// `target`, the JS path of the borrowed `place`, with the objects and index it goes - /// through held where they are now, as the borrow fixes them, for an `rt.Place` that + /// through held where they are now, as the borrow fixes them, for an `rs.Place` that /// reads and writes it later. pub(super) fn stable_target(&mut self, place: Place<'tcx>, target: Expr, span: Span, out: &mut Vec) -> Expr { // A store into a `Result`'s value makes the `Result` again, which a path can't. @@ -1113,7 +1113,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { Expr::ident(name) } - /// The `rt.Place` that reads and writes `target`, a path that stays put, read as + /// The `rs.Place` that reads and writes `target`, a path that stays put, read as /// `payload` if it is a variant's. pub(super) fn place_of(&mut self, target: Expr, payload: Option) -> Expr { let value = self.b.fresh("value"); @@ -1137,10 +1137,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } None => Expr::Lambda(vec![param], Box::new(target.assign(Expr::ident(value)))), }; - Expr::rt("place", vec![get, set]) + Expr::rs("place", vec![get, set]) } - /// The `rt.Place` of `place`, a reborrow `&mut *r` of a reference or pointer `r` that is + /// The `rs.Place` of `place`, a reborrow `&mut *r` of a reference or pointer `r` that is /// one, which is `r`'s. A shared reborrow `&*r` is what `r` points at instead, and so is /// a `&mut` to an object that a pointer to is a place, such as a `Cell`. pub(super) fn reborrowed( @@ -1187,7 +1187,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// The test that `scrut`, a `ty`, has the variant whose discriminant is `value`, where - /// `next` says it is a whole `next` result, which holds the item or `rt.DONE`. Only the + /// `next` says it is a whole `next` result, which holds the item or `rs.DONE`. Only the /// place says so: a part of its item, as `*(next as Some).0`, lowers to the same name. pub(super) fn variant_test(&mut self, scrut: &Expr, ty: Ty<'tcx>, value: u128, next: bool, span: Span) -> Expr { let tcx = self.tcx; @@ -1215,8 +1215,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } Some(Std::Option) if next => match index.index() { - 0 => scrut.clone().binary("===", Expr::Rt("DONE".into())), - _ => scrut.clone().binary("!==", Expr::Rt("DONE".into())), + 0 => scrut.clone().binary("===", Expr::Rs("DONE".into())), + _ => scrut.clone().binary("!==", Expr::Rs("DONE".into())), }, Some(Std::Option) => match index.index() { 0 => scrut.clone().binary("===", self.b.t.none(args.type_at(0))), @@ -1377,7 +1377,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { (sym, true) } - /// The module value of the thread-local `key`, made the first time: an `rt.LocalKey` + /// The module value of the thread-local `key`, made the first time: an `rs.LocalKey` /// over what initializes it. fn local_key(&mut self, key: DefId, span: Span) -> Expr { let tcx = self.tcx; @@ -1402,7 +1402,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.b.t.program.items.push(Item::Value { sym, ty, - value: Expr::New(Box::new(Expr::Rt("LocalKey".into())), ctor), + value: Expr::New(Box::new(Expr::Rs("LocalKey".into())), ctor), doc: None, }); Expr::Sym(sym) @@ -1492,7 +1492,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { offset: Size::ZERO, }; let value = match byte_array(static_ty) { - true => Expr::rt("byteSliceFrom", vec![self.const_value(val, static_ty, span)]), + true => Expr::rs("byteSliceFrom", vec![self.const_value(val, static_ty, span)]), false => self.const_value(val, static_ty, span), }; self.b.t.reading.remove(&item); @@ -1509,8 +1509,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { true => { self.b.t.deferred.insert(sym); let make = Expr::Arrow(Vec::new(), ty.clone(), vec![StmtKind::Return(Some(value)).at(None)]); - let lazy = Expr::New(Box::new(Expr::Rt("LazyCell".into())), vec![make]); - (lazy, crate::ts::Type::Rt("LazyCell", vec![ty])) + let lazy = Expr::New(Box::new(Expr::Rs("LazyCell".into())), vec![make]); + (lazy, crate::ts::Type::Rs("LazyCell", vec![ty])) } false => (value, ty), }; @@ -1582,7 +1582,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => self.err(span, format!("a zero-sized constant of type `{ty}`")), }, ConstValue::Scalar(Scalar::Int(int)) => match ty.kind() { - ty::RawPtr(..) if int.is_null() => Expr::Rt("NULL".into()), + ty::RawPtr(..) if int.is_null() => Expr::Rs("NULL".into()), ty::RawPtr(..) => self.err(span, format!("a constant of type `{ty}` made from an integer")), ty::Bool => Expr::lit((int.to_bits_unchecked() != 0).to_string()), ty::Char => Expr::lit(int.to_u32().to_string()), @@ -1794,10 +1794,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let Expr::Call(f, args) = &self.pending[i].value else { return None; }; - let (Expr::Rt(rt), [slice]) = (&**f, args.as_slice()) else { + let (Expr::Rs(rs), [slice]) = (&**f, args.as_slice()) else { return None; }; - if rt != "byteSliceToArray" { + if rs != "byteSliceToArray" { return None; } let slice = slice.clone(); @@ -1810,7 +1810,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { || matches!(e, Expr::Index(base, i) if base.is_path() && i.is_constant()) }; let stable = match &slice { - Expr::Call(f, args) if matches!(&**f, Expr::Rt(name) if name == "byteSliceRange") => { + Expr::Call(f, args) if matches!(&**f, Expr::Rs(name) if name == "byteSliceRange") => { matches!(args.as_slice(), [base, Expr::Lit(_), ..] if path(base)) } e => path(e), @@ -1857,18 +1857,18 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } } -/// Whether `ty` is `[u8]`, which is an `rt.ByteSlice`. +/// Whether `ty` is `[u8]`, which is an `rs.ByteSlice`. pub fn byte_slice(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Slice(elem) if crate::lower::byte(*elem)) } -/// Byte `i` of `slice`, an `rt.ByteSlice` that reading twice reads the same. +/// Byte `i` of `slice`, an `rs.ByteSlice` that reading twice reads the same. pub fn byte_at(slice: Expr, i: Expr) -> Expr { let at = super::scalar::add(slice_member(slice.clone(), "start"), i); slice_member(slice, "data").index(at) } -/// The field `key` of `slice`, an `rt.ByteSlice`: its part, if it is made in place of parts +/// The field `key` of `slice`, an `rs.ByteSlice`: its part, if it is made in place of parts /// that do nothing, as a local held as its parts reads. pub fn slice_member(slice: Expr, key: &str) -> Expr { if let Some([data, start, length]) = made_slice(&slice) { @@ -1900,7 +1900,7 @@ pub fn split_target(target: &Expr) -> Option<(&Expr, [crate::ts::FieldId; 3])> { fn reads_fields(e: &Expr, ids: &[crate::ts::FieldId]) -> bool { let any = |es: &[Expr]| es.iter().any(|e| reads_fields(e, ids)); match e { - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => false, + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => false, Expr::Member(base, key) => { matches!(key, crate::ts::Key::Field(id) if ids.contains(id)) || reads_fields(base, ids) } @@ -1917,10 +1917,10 @@ fn reads_fields(e: &Expr, ids: &[crate::ts::FieldId]) -> bool { } } -/// The parts of `slice`, if it is an `rt.ByteSlice` made in place. +/// The parts of `slice`, if it is an `rs.ByteSlice` made in place. pub fn made_slice(slice: &Expr) -> Option<&[Expr; 3]> { match slice { - Expr::New(f, args) if matches!(&**f, Expr::Rt(name) if name == "ByteSlice") => args.as_slice().try_into().ok(), + Expr::New(f, args) if matches!(&**f, Expr::Rs(name) if name == "ByteSlice") => args.as_slice().try_into().ok(), _ => None, } } @@ -2032,7 +2032,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Why a raw pointer made of `place` here would not keep pointing where Rust's does, if /// it would not: JS keeps each part on its path that is an object, from what the last /// pointer on it points at or from a local, in an object the crate may give another - /// object in its place, which the pointer would not see. With `cells`, an `rt.Cell` on + /// object in its place, which the pointer would not see. With `cells`, an `rs.Cell` on /// the path is such an object, as one is for the pointer `UnsafeCell::get` gives. A /// place read through a reference to a place this body borrows is that place. pub(super) fn out_of_step(&self, place: Place<'tcx>, cells: bool) -> Option { @@ -2174,7 +2174,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } /// Whether a raw pointer to a `ty` is, or is a slice of, the object JS keeps it in, or - /// with `cells`, is or holds an `rt.Cell`. Only an instance decides what a parameter is. + /// with `cells`, is or holds an `rs.Cell`. Only an instance decides what a parameter is. fn pointed_object(&self, ty: Ty<'tcx>, cells: bool) -> bool { let t = &self.b.t; !(t.polymorphic() && ty.has_param()) @@ -2183,7 +2183,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// Why the pointer std's `def_id` makes of what `reference` points at would not keep /// pointing where Rust's does, if it would not, judged as [`Self::out_of_step`] judges a - /// raw pointer: `UnsafeCell::get`'s, holding a `T`, is the `rt.Cell` itself or the + /// raw pointer: `UnsafeCell::get`'s, holding a `T`, is the `rs.Cell` itself or the /// object it holds. pub(super) fn made_out_of_step( &self, @@ -2338,16 +2338,16 @@ fn past_pointers(place: Place<'_>) -> usize { .map_or(0, |i| i + 1) } -/// An `rt.ByteSlice` of `bytes`. +/// An `rs.ByteSlice` of `bytes`. fn bytes_lit(bytes: &[u8]) -> Expr { let items = bytes.iter().map(|b| Expr::lit(b.to_string())).collect(); - Expr::rt( + Expr::rs( "byteSliceFrom", vec![Expr::ident("Uint8Array").member("of").call(items)], ) } -/// `rt.Ok(value)` or `rt.Err(value)` as the object literal they make, which TS types as the +/// `rs.Ok(value)` or `rs.Err(value)` as the object literal they make, which TS types as the /// variant the store's own test narrowed its `Result` to, so a later read of the payload /// type-checks. Any other value is as it is. fn narrowed(value: Expr) -> Expr { @@ -2355,8 +2355,8 @@ fn narrowed(value: Expr) -> Expr { return value; }; let (ok, key) = match &**f { - Expr::Rt(name) if name == "Ok" => ("true", "value"), - Expr::Rt(name) if name == "Err" => ("false", "error"), + Expr::Rs(name) if name == "Ok" => ("true", "value"), + Expr::Rs(name) if name == "Err" => ("false", "error"), _ => return value, }; let [payload] = args.as_slice() else { diff --git a/ts/src/lower/mir/rvalue.rs b/ts/src/lower/mir/rvalue.rs index 0b5c9b622..3f64f6fae 100644 --- a/ts/src/lower/mir/rvalue.rs +++ b/ts/src/lower/mir/rvalue.rs @@ -60,8 +60,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { // a `MaybeUninit` of them through a raw pointer is a view of the pointer's bytes. let pointee = place.ty(&self.mir.local_decls, tcx).ty; match (byte_array(pointee), self.in_bytes(*place)) { - (true, false) => Expr::rt("byteSliceFrom", vec![value]), - (false, true) => Expr::rt("byteSliceView", vec![value]), + (true, false) => Expr::rs("byteSliceFrom", vec![value]), + (false, true) => Expr::rs("byteSliceView", vec![value]), _ => value, } } @@ -95,8 +95,8 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { _ => { let value = self.place_expr(*place, span, out); match crate::lower::pointer::slice_of_bytes(pointee) { - true => Expr::rt("rawByteSliceOf", vec![value]), - false => Expr::rt("rawSliceOf", vec![value]), + true => Expr::rs("rawByteSliceOf", vec![value]), + false => Expr::rs("rawSliceOf", vec![value]), } } }, @@ -105,11 +105,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let value = self.place_expr(*place, span, out); match self.in_bytes(*place) { true => value, - false => Expr::rt("byteSliceFrom", vec![value]), + false => Expr::rs("byteSliceFrom", vec![value]), } } // `&raw mut *p` is `p`. A pointer to `()` is an identity, which only another - // pointer is: not the `rt.Place` of a place or of a `&mut`, each borrow's own. + // pointer is: not the `rs.Place` of a place or of a `&mut`, each borrow's own. Pointee::Place => match place.projection.as_slice() { [rest @ .., mir::ProjectionElem::Deref] if !self.box_pointer(place.local) && { @@ -161,7 +161,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let target = self.stable_target(*place, target, span, out); match target.unlocated() { Expr::Index(array, index) => { - Expr::rt("sliceAsPtr", vec![*array.clone(), *index.clone()]) + Expr::rs("sliceAsPtr", vec![*array.clone(), *index.clone()]) } _ => self.place_of(target, None), } @@ -183,7 +183,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { { let hi = self.half(hi, span, out); let lo = self.half(lo, span, out); - Expr::rt("u64FromHalves", vec![hi, lo]) + Expr::rs("u64FromHalves", vec![hi, lo]) } Rvalue::BinaryOp(op, ops) => { let (l, r) = &**ops; @@ -234,7 +234,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match op { UnOp::Not | UnOp::Neg => num::unary(self.b, *op, value, aty, span), UnOp::PtrMetadata => match aty.builtin_deref(true).map(|t| t.kind()) { - Some(ty::Str) => Expr::rt("stringLen", vec![value]), + Some(ty::Str) => Expr::rs("stringLen", vec![value]), Some(ty::Slice(_)) => super::place::slice_member(value, "length"), _ => self.err(span, format!("the metadata of `{aty}`")), }, @@ -286,7 +286,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }; let first = crate::lower::pointer::cast(self.b, p, array, elem, span); Expr::New( - Box::new(Expr::Rt("RawSlice".into())), + Box::new(Expr::Rs("RawSlice".into())), vec![first, Expr::lit(len.to_string())], ) } @@ -333,7 +333,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let v = self.operand(op, span, out); match elem_ty.kind() { _ if crate::lower::byte(elem_ty) => { - let array = Expr::rt("bytes", vec![Expr::lit(n.to_string())]); + let array = Expr::rs("bytes", vec![Expr::lit(n.to_string())]); match &v { Expr::Lit(text) if text == "0" => array, _ => array.member("fill").call(vec![v]), @@ -394,14 +394,14 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let value = self.operand(op, span, out); self.b.object_of(value, from, to, span) } - // A future, as the `rt.Future` a `dyn Future` is. + // A future, as the `rs.Future` a `dyn Future` is. PointerCoercion::Unsize if unsized_to(from, to).is_some_and(|part| self.b.t.dyn_future(part).is_some()) => { let value = self.operand(op, span, out); self.b.dyn_future(from, to, value, span) } - // An iterator, as the `rt.Iter` a `dyn Iterator` is. + // An iterator, as the `rs.Iter` a `dyn Iterator` is. PointerCoercion::Unsize if unsized_to(from, to).is_some_and(|part| self.b.t.dyn_iter(part).is_some()) => { @@ -420,7 +420,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { match crate::lower::bytes_ref(from) { true => value, false if from.is_raw_ptr() => self.raw_unsize(value, from, span), - false => Expr::rt("byteSliceFrom", vec![value]), + false => Expr::rs("byteSliceFrom", vec![value]), } } _ => self.err(span, format!("a coercion to `{to}`")), @@ -485,15 +485,15 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } /// `arc`, an `Arc` of `pointee` unsized to one of `object`, a trait object or a struct - /// of one: an `rt.ArcDyn` sharing its count, over what a box of its value unsizes to, or + /// of one: an `rs.ArcDyn` sharing its count, over what a box of its value unsizes to, or /// the same `Arc` upcast. fn arc_object(&mut self, arc: Expr, pointee: Ty<'tcx>, object: Ty<'tcx>, span: Span, out: &mut Vec) -> Expr { let tcx = self.tcx; - // An upcast of a function is the same `rt.ArcDyn`: nothing calls an `Arc` through `FnOnce`. + // An upcast of a function is the same `rs.ArcDyn`: nothing calls an `Arc` through `FnOnce`. if pointee.is_trait() && self.b.t.dyn_fn(object).is_some() { return arc; } - // An upcast is of an `rt.ArcDyn` already, whose object has the supertraits' methods. + // An upcast is of an `rs.ArcDyn` already, whose object has the supertraits' methods. let (arc, value) = match pointee.is_trait() { true => (None, arc), false => { @@ -510,12 +510,12 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { self.b.object_of(value, from, to, span) }; match arc { - Some(arc) => Expr::New(Box::new(Expr::Rt("ArcDyn".into())), vec![arc, value]), + Some(arc) => Expr::New(Box::new(Expr::Rs("ArcDyn".into())), vec![arc, value]), None => value, } } - /// `weak`, a `Weak` of `pointee` unsized to one of `object`, as `arc_object`: `rt.weakDyn` + /// `weak`, a `Weak` of `pointee` unsized to one of `object`, as `arc_object`: `rs.weakDyn` /// of it, which makes the `Arc` an upgrade gives as `arc_object` does, or the same `Weak` /// upcast, which `arc_object` checks. fn weak_object( @@ -535,10 +535,10 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { body.push(StmtKind::Return(Some(arc)).at(None)); let param = crate::ts::Param { name, - ty: Some(crate::ts::Type::Rt("Arc", vec![self.b.t.ty(pointee, span)])), + ty: Some(crate::ts::Type::Rs("Arc", vec![self.b.t.ty(pointee, span)])), }; - let ret = crate::ts::Type::Rt("Arc", vec![self.b.t.ty(object, span)]); - Expr::rt("weakDyn", vec![weak, Expr::Arrow(vec![param], ret, body)]) + let ret = crate::ts::Type::Rs("Arc", vec![self.b.t.ty(object, span)]); + Expr::rs("weakDyn", vec![weak, Expr::Arrow(vec![param], ret, body)]) } /// A discriminant as its number, of a whole `next` result if `next`. @@ -639,7 +639,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let op_ty = op.ty(&self.mir.local_decls, self.tcx); let is_ref = op_ty.is_ref(); // Shared references to what holds nothing are `undefined` wherever they point, unlike - // a `&mut`, which may be an `rt.Place`. + // a `&mut`, which may be an `rs.Place`. let mut pointee = op_ty; while let ty::Ref(_, inner, rustc_ast::Mutability::Not) = pointee.kind() { pointee = *inner; @@ -693,7 +693,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { /// The `Result` a variant of one is rebuilt from, if it takes what that same variant of /// another held, as `map_err` returns its `Ok`: that one's object, since a write into - /// an `rt.Result`'s payload replaces the result, so none changes in place. The payload, + /// an `rs.Result`'s payload replaces the result, so none changes in place. The payload, /// held back for this one read, goes unread. fn rebuilt_result( &mut self, @@ -786,7 +786,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { crate::lower::library::cow_made(borrowed, variant, values.pop().unwrap()) } (Std::Result, i) => Expr::result(i == 0, values.pop().unwrap()), - (Std::FmtError, _) => Expr::New(Box::new(Expr::Rt("FmtError".into())), Vec::new()), + (Std::FmtError, _) => Expr::New(Box::new(Expr::Rs("FmtError".into())), Vec::new()), ( std @ (Std::ParseBoolError | Std::BorrowError @@ -794,7 +794,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { | Std::CharTryFromError | Std::TryFromCharError), _, - ) => Expr::New(Box::new(Expr::Rt(format!("{std:?}"))), Vec::new()), + ) => Expr::New(Box::new(Expr::Rs(format!("{std:?}"))), Vec::new()), // `ResumeTy`, an async body's context. (Std::Context, _) => values.pop().unwrap_or_else(Expr::undefined), (Std::RangeTo | Std::RangeToInclusive, _) => { @@ -807,16 +807,16 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { } (Std::RangeFrom, _) => { values.extend(crate::lower::library::range_step(tcx, args.type_at(0), true)); - Expr::New(Box::new(Expr::Rt("RangeFrom".into())), values) + Expr::New(Box::new(Expr::Rs("RangeFrom".into())), values) } (Std::RangeFull | Std::BuildHasherDefault, _) => Expr::undefined(), - (Std::Pending, _) => Expr::Rt("NEVER".into()), - (Std::WakerVTable, _) => Expr::rt("wakerVTable", values), + (Std::Pending, _) => Expr::Rs("NEVER".into()), + (Std::WakerVTable, _) => Expr::rs("wakerVTable", values), (Std::RawWaker, _) => { let [data, vtable] = <[Expr; 2]>::try_from(values).expect("a raw waker's two fields"); crate::lower::task::raw_waker(data, vtable) } - (Std::LayoutError, _) => Expr::Rt("LAYOUT_ERROR".into()), + (Std::LayoutError, _) => Expr::Rs("LAYOUT_ERROR".into()), (Std::ParseIntError, _) => Expr::Object(vec![(Key::Name("kind".into()), values.pop().unwrap())]), (Std::ErrorKind, _) => Expr::As(Box::new(Expr::Str(def.name.to_string())), self.b.t.ty(ty, span)), (Std::Ordering, _) => crate::lower::collections::ordering_variant(variant), @@ -824,7 +824,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { (Std::ControlFlow, _) => super::call::control_flow(self, ty, variant, values), (Std::Range, _) => { values.extend(crate::lower::library::range_step(tcx, args.type_at(0), false)); - Expr::New(Box::new(Expr::Rt("Range".into())), values) + Expr::New(Box::new(Expr::Rs("Range".into())), values) } (Std::AssertKind, _) => match def.name.as_str() { "Eq" => Expr::Str("==".into()), @@ -1028,7 +1028,7 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { let body = inner.lower(); let mut f = Expr::Arrow(inputs, ret, body); if let Some(once) = by_move { - f = Expr::rt("byMove", vec![f, once]); + f = Expr::rs("byMove", vec![f, once]); } let make = made.then(|| self.b.fresh("make")); if let Some(make) = &make { @@ -1044,11 +1044,11 @@ impl<'m, 'b, 'a, 'tcx> Fx<'m, 'b, 'a, 'tcx> { }) .collect(); let again = Expr::Lambda(Vec::new(), Box::new(Expr::ident(make).call(clones))); - f = Expr::rt("cloning", vec![f, again]); + f = Expr::rs("cloning", vec![f, again]); } // One that owns what drops carries the glue that drops it. if let Some(glue) = glue { - f = Expr::rt("closure", vec![f, Expr::Arrow(Vec::new(), Type::Builtin("void"), glue)]); + f = Expr::rs("closure", vec![f, Expr::Arrow(Vec::new(), Type::Builtin("void"), glue)]); } let Some(make) = make else { return f; diff --git a/ts/src/lower/mir/scalar.rs b/ts/src/lower/mir/scalar.rs index b0c8eaadd..1f7a9b427 100644 --- a/ts/src/lower/mir/scalar.rs +++ b/ts/src/lower/mir/scalar.rs @@ -1,4 +1,4 @@ -//! Locals of byte slices held as their parts. A `&[u8]` is an `rt.ByteSlice`, so each +//! Locals of byte slices held as their parts. A `&[u8]` is an `rs.ByteSlice`, so each //! split, and each tuple, `Option`, `Result`, or `ControlFlow` around one, makes objects //! V8 doesn't remove, as does a tuple or `Result` of numbers alone. A local built of them //! that nothing borrows or writes into, and that only splits, `ok_or`, `?`, aggregates, @@ -246,7 +246,7 @@ impl<'tcx> crate::lower::Translator<'_, 'tcx> { } /// Which of `instance`'s parameters it takes as a byte slice's parts, its `data`, - /// `start`, and `length`, rather than an `rt.ByteSlice`: each `&[u8]` or `&[u8; N]` of a + /// `start`, and `length`, rather than an `rs.ByteSlice`: each `&[u8]` or `&[u8; N]` of a /// function only translated code calls directly, that its body holds as its parts and /// never makes the object of. One it would make takes the object its caller has, or /// makes once. Empty if none. @@ -576,8 +576,8 @@ impl<'tcx> Slotted<'tcx> { }; Expr::Cond( Box::new(failed), - Box::new(Expr::rt("Err", vec![Expr::As(Box::new(err), err_ty)])), - Box::new(Expr::rt("Ok", vec![ok])), + Box::new(Expr::rs("Err", vec![Expr::As(Box::new(err), err_ty)])), + Box::new(Expr::rs("Ok", vec![ok])), ) } } @@ -592,7 +592,7 @@ fn build_plain<'tcx>( match shape { Shape::Unit => Expr::undefined(), Shape::Leaf(_) => parts[0].clone(), - Shape::Slice => Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.to_vec()), + Shape::Slice => Expr::New(Box::new(Expr::Rs("ByteSlice".into())), parts.to_vec()), Shape::Tuple(ty, fields) => { let mut at = 0; let mut items = Vec::with_capacity(fields.len()); @@ -627,7 +627,7 @@ fn tuple_items(value: &Expr, n: usize) -> Option<&[Expr]> { } } -/// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rt.ByteSlice`. +/// Whether `ty` is a `&[u8]` or `&[u8; N]`, which is an `rs.ByteSlice`. fn slice_ref(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Ref(_, inner, rustc_ast::Mutability::Not) if super::place::byte_slice(*inner) || crate::lower::byte_array(*inner)) @@ -1599,7 +1599,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { // The parts of a slice bound whole are that slice. Shape::Slice => match members(parts) { Some(slice) => Expr::ident(slice), - None => Expr::New(Box::new(Expr::Rt("ByteSlice".into())), parts.to_vec()), + None => Expr::New(Box::new(Expr::Rs("ByteSlice".into())), parts.to_vec()), }, Shape::Tuple(ty, fields) => { let mut at = 0; @@ -1751,7 +1751,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } let check = StmtKind::If { cond: mid.clone().binary(">", n.clone()), - then: vec![StmtKind::Expr(Expr::rt("panic", panic)).at(loc)], + then: vec![StmtKind::Expr(Expr::rs("panic", panic)).at(loc)], els: Vec::new(), } .at(None); @@ -1817,7 +1817,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { && !p.effect && !p.copy && let Expr::Call(f, items) = &p.value - && matches!(&**f, Expr::Rt(n) if n == "Err") + && matches!(&**f, Expr::Rs(n) if n == "Err") && items.len() == 1 => { let Expr::Call(_, mut items) = self.pending.remove(i).value else { @@ -1826,7 +1826,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { items.pop().expect("checked above") } // Made in place: its error. - Expr::Call(f, mut items) if matches!(&*f, Expr::Rt(n) if n == "Err") && items.len() == 1 => { + Expr::Call(f, mut items) if matches!(&*f, Expr::Rs(n) if n == "Err") && items.len() == 1 => { items.pop().expect("checked above") } value => { @@ -2147,7 +2147,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { .map(|part| (part.clone(), self.steady_expr(part))) .collect(), Shape::Slice => { - let (slice, _) = self.steady_value(value, "slice", Type::Rt("ByteSlice", Vec::new()), out); + let (slice, _) = self.steady_value(value, "slice", Type::Rs("ByteSlice", Vec::new()), out); ["data", "start", "length"] .into_iter() .map(|key| (super::place::slice_member(slice.clone(), key), true)) @@ -2308,7 +2308,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// memory, as a cast, a comparison, or an object literal. pub(super) fn steady_expr(&self, e: &Expr) -> bool { match e { - Expr::Lit(_) | Expr::Str(_) | Expr::Rt(_) => true, + Expr::Lit(_) | Expr::Str(_) | Expr::Rs(_) => true, Expr::Ident(name) => { !self.pending.iter().any(|p| p.name == *name) && (self.steady.contains(name) || self.stable_name(e)) } @@ -2324,7 +2324,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { /// in a variable named after `base` of type `ty` assigned it now. fn steady_value(&mut self, value: Expr, base: &str, ty: Type, out: &mut Vec) -> (Expr, bool) { let made = - matches!(&value, Expr::New(f, args) if matches!(&**f, Expr::Rt(n) if n == "ByteSlice") && args.len() == 3); + matches!(&value, Expr::New(f, args) if matches!(&**f, Expr::Rs(n) if n == "ByteSlice") && args.len() == 3); if made || self.steady_expr(&value) { return (value, true); } diff --git a/ts/src/lower/mir/step.rs b/ts/src/lower/mir/step.rs index 555480b45..aafb9cf72 100644 --- a/ts/src/lower/mir/step.rs +++ b/ts/src/lower/mir/step.rs @@ -1,6 +1,6 @@ //! Iterators stepped in place: a slice's or a `Vec`'s iterator, or a range of numbers, //! that only `next` reads, as a `for` loop's is, is two variables, of the array and an -//! index or of the bounds, rather than an `rt.Iter`, which a bundler can't shake its +//! index or of the bounds, rather than an `rs.Iter`, which a bundler can't shake its //! adaptors from. Variables, not an object of both: V8 took up to 1.25x as long over a //! `BTreeMap` stepping an object's fields. @@ -49,7 +49,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { .filter(|&l| !self.is_arg(l) && l != mir::RETURN_PLACE && self.defs[l] == 1) .filter(|&l| { let ty = mir.local_decls[l].ty; - // An element JS copies is lent as its place, which `rt.iterSliceMut` makes. + // An element JS copies is lent as its place, which `rs.iterSliceMut` makes. let places = || self.b.t.iter_item(ty).is_some_and(|item| self.b.t.has_place(item)); array_iter(tcx, ty).is_some() && !places() || super::small_range(tcx, ty) }) @@ -78,7 +78,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } // A move into a field, such as a coroutine's for a local held across an - // `.await`, needs the `rt.Iter` the field's type says, so it isn't counted. + // `.await`, needs the `rs.Iter` the field's type says, so it isn't counted. Rvalue::Use(Operand::Move(from), _) if let Some(from) = from.as_local() && let Some(to) = place.as_local() => @@ -271,28 +271,28 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } - /// An iterator stepped in place, from the `rt.Iter` its mapping makes: `{ s, i: 0 }` - /// from `rt.iterSlice(s)`, or `rt.iterSlice(s, drop)` of items it owns, which its drop - /// drops again, `{ s: v.items, i: 0 }` from `rt.vecIntoIter(v, drop)`, the view of `v`'s bytes from `rt.byteVecIntoIter(v)`, and - /// `{ start, end }` from `new rt.Range(start, end)`. A moved one is already made. + /// An iterator stepped in place, from the `rs.Iter` its mapping makes: `{ s, i: 0 }` + /// from `rs.iterSlice(s)`, or `rs.iterSlice(s, drop)` of items it owns, which its drop + /// drops again, `{ s: v.items, i: 0 }` from `rs.vecIntoIter(v, drop)`, the view of `v`'s bytes from `rs.byteVecIntoIter(v)`, and + /// `{ start, end }` from `new rs.Range(start, end)`. A moved one is already made. pub(super) fn stepped_make(&mut self, value: Expr, span: rustc_span::Span) -> Expr { - let rt = |f: &Expr, name: &str| matches!(f, Expr::Rt(n) if n == name); + let rs = |f: &Expr, name: &str| matches!(f, Expr::Rs(n) if n == name); let object = |fields: [(&str, Expr); 2]| { Expr::Object(fields.into_iter().map(|(k, v)| (Key::Name(k.into()), v)).collect()) }; match value { - Expr::Call(f, mut args) if rt(&f, "iterSlice") && matches!(args.len(), 1 | 2) => { + Expr::Call(f, mut args) if rs(&f, "iterSlice") && matches!(args.len(), 1 | 2) => { args.truncate(1); object([("s", args.pop().unwrap()), ("i", Expr::lit("0"))]) } - Expr::Call(f, mut args) if rt(&f, "vecIntoIter") && matches!(args.len(), 1 | 2) => { + Expr::Call(f, mut args) if rs(&f, "vecIntoIter") && matches!(args.len(), 1 | 2) => { args.truncate(1); object([("s", args.pop().unwrap().member("items")), ("i", Expr::lit("0"))]) } - Expr::Call(f, args) if rt(&f, "byteVecIntoIter") && args.len() == 1 => { - object([("s", Expr::rt("byteVecView", args)), ("i", Expr::lit("0"))]) + Expr::Call(f, args) if rs(&f, "byteVecIntoIter") && args.len() == 1 => { + object([("s", Expr::rs("byteVecView", args)), ("i", Expr::lit("0"))]) } - Expr::New(f, args) if rt(&f, "Range") && args.len() == 2 => { + Expr::New(f, args) if rs(&f, "Range") && args.len() == 2 => { let [start, end] = <[Expr; 2]>::try_from(args).expect("checked above"); object([("start", start), ("end", end)]) } @@ -303,14 +303,14 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { } } - /// The next item of `it`, stepped in place, or `rt.DONE`. + /// The next item of `it`, stepped in place, or `rs.DONE`. pub(super) fn stepped_next(&self, it: &Expr) -> Expr { let s = stepped_field(it, "s"); let i = stepped_field(it, "i"); Expr::Cond( Box::new(i.clone().binary("<", s.clone().member("length"))), Box::new(s.index(Expr::Postfix(Box::new(i), "++"))), - Box::new(Expr::Rt("DONE".into())), + Box::new(Expr::Rs("DONE".into())), ) } @@ -319,7 +319,7 @@ impl<'tcx> Fx<'_, '_, '_, 'tcx> { pub(super) fn stepped_drop(&mut self, it: &Expr, ty: Ty<'tcx>, span: rustc_span::Span) -> Option { let item = array_iter(self.tcx, ty)?; let dropper = self.b.t.drop_fn(item, span)?; - Some(Expr::rt( + Some(Expr::rs( "dropAll", vec![stepped_field(it, "s"), dropper, stepped_field(it, "i")], )) @@ -364,8 +364,8 @@ pub(super) fn stepped_field(it: &Expr, key: &str) -> Expr { /// Each loop over an array iterator stepped in place that only the loop steps, as /// `for (const item of array)`: a `while (true)` whose first statements take the next -/// item and leave on `rt.DONE`. Nothing else names the index, so nothing sees where it -/// stopped, but for the `rt.dropAll` of a `Vec`'s items it owns right after the loop, +/// item and leave on `rs.DONE`. Nothing else names the index, so nothing sees where it +/// stopped, but for the `rs.dropAll` of a `Vec`'s items it owns right after the loop, /// which drops nothing when the loop can only leave at the end. pub(super) fn for_of(stmts: &mut Vec) { let mut names: FxHashMap = FxHashMap::default(); @@ -485,7 +485,7 @@ fn loops( } } -/// The array and index of `rt.dropAll(array, f, index)`, which drops what a loop over a +/// The array and index of `rs.dropAll(array, f, index)`, which drops what a loop over a /// `Vec` it owns left. fn drop_rest(stmt: &Stmt) -> Option<(String, String)> { let StmtKind::Expr(call) = &stmt.kind else { @@ -495,7 +495,7 @@ fn drop_rest(stmt: &Stmt) -> Option<(String, String)> { return None; }; match (peel(f), args.as_slice()) { - (Expr::Rt(name), [array, _, index]) if name == "dropAll" => match (peel(array), peel(index)) { + (Expr::Rs(name), [array, _, index]) if name == "dropAll" => match (peel(array), peel(index)) { (Expr::Ident(array), Expr::Ident(index)) => Some((array.clone(), index.clone())), _ => None, }, @@ -542,7 +542,7 @@ fn within(own: &Option, inner: &mut Vec, f: impl FnOnce(&mut Vec } /// The item, array, and index of a loop that starts `const item = i < s.length ? -/// s[i++] : rt.DONE; if (item === rt.DONE) break;`, the `break` leaving it. +/// s[i++] : rs.DONE; if (item === rs.DONE) break;`, the `break` leaving it. fn header(body: &[Stmt], label: Option<&str>) -> Option<(String, String, String)> { let [next, test, ..] = body else { return None; @@ -559,7 +559,7 @@ fn header(body: &[Stmt], label: Option<&str>) -> Option<(String, String, String) let Expr::Cond(c, a, b) = peel(init) else { return None; }; - let (Expr::Binary(i, "<", len), Expr::Index(s, at), Expr::Rt(done)) = (peel(c), peel(a), peel(b)) else { + let (Expr::Binary(i, "<", len), Expr::Index(s, at), Expr::Rs(done)) = (peel(c), peel(a), peel(b)) else { return None; }; let (Expr::Ident(index), Expr::Member(s2, Key::Name(length)), Expr::Ident(array), Expr::Postfix(i2, "++")) = @@ -577,7 +577,7 @@ fn header(body: &[Stmt], label: Option<&str>) -> Option<(String, String, String) let leaves = matches!(then.as_slice(), [Stmt { kind: StmtKind::Break(target), .. }] if target.is_none() || target.as_deref() == label); let tests = matches!(peel(cond), Expr::Binary(l, "===", r) - if same(l, item) && matches!(peel(r), Expr::Rt(d) if d == "DONE")); + if same(l, item) && matches!(peel(r), Expr::Rs(d) if d == "DONE")); (leaves && tests && els.is_empty()).then(|| (item.clone(), array.clone(), index.clone())) } diff --git a/ts/src/lower/mod.rs b/ts/src/lower/mod.rs index cf7bf47e1..ace7ff0b7 100644 --- a/ts/src/lower/mod.rs +++ b/ts/src/lower/mod.rs @@ -196,7 +196,7 @@ pub struct Translator<'a, 'tcx> { queue: VecDeque<(Instance<'tcx>, SymId)>, adts: rustc_data_structures::fx::FxHashMap, /// The fields of generic types whose definition types a form only an instance decides, - /// such as an `rt.Ptr` or an `rt.VecOf`, which an instance's read casts to what it + /// such as an `rs.Ptr` or an `rs.VecOf`, which an instance's read casts to what it /// holds, with that type where a function type in it takes one, which an instance's /// value is cast to. instanced_fields: rustc_data_structures::fx::FxHashMap>, @@ -235,7 +235,7 @@ pub struct Translator<'a, 'tcx> { pub values: rustc_data_structures::fx::FxHashMap, /// The statics whose values are being read, which a pointer within one can't name yet. pub reading: rustc_data_structures::fx::FxHashSet, - /// The statics made on first use, as an `rt.LazyCell` of their value. + /// The statics made on first use, as an `rs.LazyCell` of their value. pub deferred: rustc_data_structures::fx::FxHashSet, /// The types the crate writes into in place, which alone are copied. writes: copy::Writes<'tcx>, @@ -253,7 +253,7 @@ pub struct Translator<'a, 'tcx> { /// Those this run compared. comparing: rustc_data_structures::fx::FxHashSet>, /// Whether the runs before reached a `panic::set_hook`, so every panic carries the - /// `rt.Location` its hook reads. + /// `rs.Location` its hook reads. pub hooked: bool, /// Whether this run did. hooking: bool, @@ -287,7 +287,7 @@ pub struct Translator<'a, 'tcx> { slotted: rustc_data_structures::fx::FxHashMap, Option>>, /// The slot of each `Ok` payload type, which every function returning one shares. slots: rustc_data_structures::fx::FxHashMap, SymId>, - /// The `rt.HasherImpl` of each `Hasher` of the crate's own. + /// The `rs.HasherImpl` of each `Hasher` of the crate's own. pub hashers: rustc_data_structures::fx::FxHashMap, SymId>, /// The field of each struct's byte slice field held as its parts that holds its bytes. pub slices: rustc_data_structures::fx::FxHashSet, @@ -366,8 +366,8 @@ pub enum ObjectKind { } /// The JS values a type's own can be that `Option` and `Poll` erase to: `None` is -/// `undefined`, or `rt.None` where `Some` can already be `undefined`, and `Pending` is -/// `rt.Pending`, or `rt.OuterPending` where `Ready` can already be `rt.Pending`. +/// `undefined`, or `rs.None` where `Some` can already be `undefined`, and `Pending` is +/// `rs.Pending`, or `rs.OuterPending` where `Ready` can already be `rs.Pending`. #[derive(Clone, Copy, Default)] pub struct Erased { pub undefined: bool, @@ -380,7 +380,7 @@ pub struct Erased { impl Erased { /// What an `Option` of a type erased so erases to: its `None` is `undefined`, or - /// `rt.None` where `Some` can already be `undefined`. + /// `rs.None` where `Some` can already be `undefined`. fn option(self) -> Self { match self.undefined { true => Self { none: true, ..self }, @@ -391,8 +391,8 @@ impl Erased { } } - /// What a `Poll` of a type erased so erases to: its `Pending` is `rt.Pending`, or - /// `rt.OuterPending` where `Ready` can already be `rt.Pending`. + /// What a `Poll` of a type erased so erases to: its `Pending` is `rs.Pending`, or + /// `rs.OuterPending` where `Ready` can already be `rs.Pending`. fn poll(self) -> Self { match self.pending { true => Self { @@ -572,7 +572,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { match field { StructField::Whole(id) => base.field(id), StructField::Slice(ids) => ts::Expr::New( - Box::new(ts::Expr::Rt("ByteSlice".into())), + Box::new(ts::Expr::Rs("ByteSlice".into())), ids.map(|id| base.clone().field(id)).to_vec(), ), } @@ -1399,7 +1399,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Whether a JS value of `ty` is a copy that no JS value can point at, such as a number /// or a reference, or an object its clones may share, as an `Arc`'s and a `Waker`'s are, - /// pinned or boxed too, which JS erases, so a `&mut` to it is an `rt.Place`: where the + /// pinned or boxed too, which JS erases, so a `&mut` to it is an `rs.Place`: where the /// value is, read and written through `v`. A `LocalKey`'s copies share its storage too. pub fn needs_place(&self, ty: Ty<'tcx>) -> bool { use library::Std; @@ -1413,7 +1413,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// Whether `ty`'s JS value, through the `Pin`s, `Box`es, and `AssertUnwindSafe`s JS - /// erases, is of an `rt` class that keeps its state private, which `rt.ptrWrite` moves in + /// erases, is of an `rs` class that keeps its state private, which `rs.ptrWrite` moves in /// by its `$move`. pub fn moves_private(&self, ty: Ty<'tcx>) -> bool { use library::Std; @@ -1470,7 +1470,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// What `ty` points at, if it is a `&mut` that is an `rt.Place`. + /// What `ty` points at, if it is a `&mut` that is an `rs.Place`. pub fn place_pointee(&self, ty: Ty<'tcx>) -> Option> { match ty.kind() { ty::Ref(_, inner, rustc_ast::Mutability::Mut) if self.needs_place(*inner) => Some(*inner), @@ -1479,7 +1479,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// What `value`, a `ty` that is a reference, points at: an `rt.Place`'s `v`, and + /// What `value`, a `ty` that is a reference, points at: an `rs.Place`'s `v`, and /// otherwise the reference's own JS value. pub fn pointee_value(&self, ty: Ty<'tcx>, value: ts::Expr) -> ts::Expr { match (self.place_pointee(ty), value.place_read()) { @@ -1489,7 +1489,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// Whether `ty` holds a `&mut` that is an `rt.Place`, other than in what a closure or + /// Whether `ty` holds a `&mut` that is an `rs.Place`, other than in what a closure or /// coroutine captured. pub fn has_place(&self, ty: Ty<'tcx>) -> bool { let mut walker = ty.walk(); @@ -1511,26 +1511,26 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Bool => Type::Builtin("boolean"), ty::Int(_) | ty::Uint(_) => num::Int::of(ty).unwrap().ty(), _ if let Some(float) = float::Float::of(ty) => float.ty(), - ty::Char => Type::Rt("char", Vec::new()), + ty::Char => Type::Rs("char", Vec::new()), ty::Str => Type::Builtin("string"), ty::Never => Type::Builtin("never"), ty::Tuple(tys) if tys.is_empty() => Type::Builtin("undefined"), ty::Tuple(tys) => Type::Tuple(tys.iter().map(|t| self.ty(t, span)).collect()), - ty::Ref(_, inner, _) if self.instance_pointee(*inner) => Type::Rt("Ptr", vec![self.ty(*inner, span)]), + ty::Ref(_, inner, _) if self.instance_pointee(*inner) => Type::Rs("Ptr", vec![self.ty(*inner, span)]), ty::Ref(_, inner, rustc_ast::Mutability::Mut) if self.needs_place(*inner) => { - Type::Rt("Place", vec![self.ty(*inner, span)]) + Type::Rs("Place", vec![self.ty(*inner, span)]) } ty::RawPtr(inner, _) => self.pointer_ty(*inner, span), - ty::Ref(..) if bytes_ref(ty) => Type::Rt("ByteSlice", vec![]), + ty::Ref(..) if bytes_ref(ty) => Type::Rs("ByteSlice", vec![]), ty::Ref(_, inner, _) => self.ty(*inner, span), - ty::Array(elem, _) if self.open_elem(*elem) => Type::Rt("ArrayOf", vec![self.ty(*elem, span)]), - ty::Slice(elem) if self.open_elem(*elem) => Type::Rt("SliceOf", vec![self.ty(*elem, span)]), + ty::Array(elem, _) if self.open_elem(*elem) => Type::Rs("ArrayOf", vec![self.ty(*elem, span)]), + ty::Slice(elem) if self.open_elem(*elem) => Type::Rs("SliceOf", vec![self.ty(*elem, span)]), ty::Array(elem, _) => match byte(*elem) { true => Type::Builtin("Uint8Array"), false => Type::Array(Box::new(self.ty(*elem, span))), }, ty::Slice(elem) => match byte(*elem) { - true => Type::Rt("ByteSlice", vec![]), + true => Type::Rs("ByteSlice", vec![]), false => Type::Array(Box::new(self.ty(*elem, span))), }, ty::Param(param) => Type::Param(param.name.to_string()), @@ -1566,7 +1566,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { ty::Pat(base, _) => self.ty(*base, span), ty::Coroutine(_, args) => self.future_ty(args.as_coroutine().return_ty(), span), ty::Dynamic(..) if let Some(output) = self.dyn_future(ty) => self.future_ty(output, span), - ty::Dynamic(..) if let Some(item) = self.dyn_iter(ty) => Type::Rt("Iter", vec![self.ty(item, span)]), + ty::Dynamic(..) if let Some(item) = self.dyn_iter(ty) => Type::Rs("Iter", vec![self.ty(item, span)]), // `&dyn Debug` and `&dyn Display` are values ready to write. ty::Dynamic(preds, ..) if preds @@ -1574,7 +1574,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { .and_then(|did| fmt::Trait::of(tcx, did)) .is_some() => { - Type::Rt("Fmt", vec![]) + Type::Rs("Fmt", vec![]) } ty::Dynamic(..) if let Some(f) = self.dyn_fn(ty) => self.fn_ty(&f.inputs, f.output, span), ty::Dynamic(..) => match self.object(ty, span) { @@ -1633,7 +1633,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let inner = args.type_at(0); let erased = self.erases_to(inner); (erased.undefined && erased.none).then(|| { - format!("`Option<{inner}>` is not supported: its `None` and `Some` would both be `rt.None`") + format!("`Option<{inner}>` is not supported: its `None` and `Some` would both be `rs.None`") }) } library::Std::Poll => { @@ -1641,14 +1641,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let erased = self.erases_to(inner); (erased.pending && erased.outer_pending).then(|| { format!( - "`Poll<{inner}>` is not supported: its `Pending` and `Ready` would both be `rt.OuterPending`" + "`Poll<{inner}>` is not supported: its `Pending` and `Ready` would both be `rs.OuterPending`" ) }) } library::Std::ControlFlow if library::Flow::of(self.tcx, args) == library::Flow::Option => { let erased = self.erases_to(args.type_at(1)); (erased.undefined && erased.none) - .then(|| format!("`{ty}` is not supported: its break and its continue would both be `rt.None`")) + .then(|| format!("`{ty}` is not supported: its break and its continue would both be `rs.None`")) } _ => None, } @@ -1683,24 +1683,24 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } self.option_ty(args.type_at(0), span) } - library::Std::Result => Type::Rt( + library::Std::Result => Type::Rs( "Result", vec![self.ty(args.type_at(0), span), self.ty(args.type_at(1), span)], ), library::Std::Vec if self.open_elem(args.type_at(0)) => { - Type::Rt("VecOf", vec![self.ty(args.type_at(0), span)]) + Type::Rs("VecOf", vec![self.ty(args.type_at(0), span)]) } library::Std::Vec => match byte(args.type_at(0)) { - true => Type::Rt("ByteVec", vec![]), - false => Type::Rt("Vec", vec![self.ty(args.type_at(0), span)]), + true => Type::Rs("ByteVec", vec![]), + false => Type::Rs("Vec", vec![self.ty(args.type_at(0), span)]), }, library::Std::String => Type::Builtin("string"), - library::Std::Cow if library::cow_str(tcx, Ty::new_adt(tcx, adt, args)) => Type::Rt("StrCow", vec![]), + library::Std::Cow if library::cow_str(tcx, Ty::new_adt(tcx, adt, args)) => Type::Rs("StrCow", vec![]), library::Std::Cow if let Some(elem) = library::cow_slice(tcx, Ty::new_adt(tcx, adt, args)) => { match elem.kind() { - _ if self.open_elem(elem) => Type::Rt("CowOf", vec![self.ty(elem, span)]), - _ if byte(elem) => Type::Rt("ByteCow", vec![]), - _ => Type::Rt("Cow", vec![self.ty(elem, span)]), + _ if self.open_elem(elem) => Type::Rs("CowOf", vec![self.ty(elem, span)]), + _ if byte(elem) => Type::Rs("ByteCow", vec![]), + _ => Type::Rs("Cow", vec![self.ty(elem, span)]), } } library::Std::Cow => { @@ -1714,73 +1714,73 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { | library::Std::Wrapping | library::Std::Saturating | library::Std::PoisonError => self.ty(args.type_at(0), span), - library::Std::Bound => Type::Rt("RangeBound", vec![self.ty(args.type_at(0), span)]), - library::Std::TryLockError => Type::Rt("TryLockError", vec![self.ty(args.type_at(0), span)]), - library::Std::FromUtf8Error => Type::Rt("FromUtf8Error", vec![]), - library::Std::Utf8Error => Type::Rt("Utf8Error", vec![]), - library::Std::TryFromIntError => Type::Rt("TryFromIntError", vec![]), - library::Std::ParseIntError => Type::Rt("ParseIntError", vec![]), + library::Std::Bound => Type::Rs("RangeBound", vec![self.ty(args.type_at(0), span)]), + library::Std::TryLockError => Type::Rs("TryLockError", vec![self.ty(args.type_at(0), span)]), + library::Std::FromUtf8Error => Type::Rs("FromUtf8Error", vec![]), + library::Std::Utf8Error => Type::Rs("Utf8Error", vec![]), + library::Std::TryFromIntError => Type::Rs("TryFromIntError", vec![]), + library::Std::ParseIntError => Type::Rs("ParseIntError", vec![]), library::Std::ErrorKind => match self.tcx.item_name(adt.did()).as_str() { - "IntErrorKind" => Type::Rt("IntErrorKind", vec![]), - "CharErrorKind" => Type::Rt("CharErrorKind", vec![]), - "FloatErrorKind" => Type::Rt("FloatErrorKind", vec![]), - _ => Type::Rt("TryFromFloatSecsErrorKind", vec![]), + "IntErrorKind" => Type::Rs("IntErrorKind", vec![]), + "CharErrorKind" => Type::Rs("CharErrorKind", vec![]), + "FloatErrorKind" => Type::Rs("FloatErrorKind", vec![]), + _ => Type::Rs("TryFromFloatSecsErrorKind", vec![]), }, - library::Std::ParseBoolError => Type::Rt("ParseBoolError", vec![]), - library::Std::BorrowError => Type::Rt("BorrowError", vec![]), - library::Std::BorrowMutError => Type::Rt("BorrowMutError", vec![]), - library::Std::ParseCharError => Type::Rt("ParseCharError", vec![]), - library::Std::FromUtf16Error => Type::Rt("FromUtf16Error", vec![]), - library::Std::CharTryFromError => Type::Rt("CharTryFromError", vec![]), - library::Std::TryFromCharError => Type::Rt("TryFromCharError", vec![]), - library::Std::DecodeUtf16Error => Type::Rt("DecodeUtf16Error", vec![]), - library::Std::Utf8Chunk => Type::Rt("Utf8Chunk", vec![]), - library::Std::ParseFloatError => Type::Rt("ParseFloatError", vec![]), - library::Std::TryFromFloatSecsError => Type::Rt("TryFromFloatSecsError", vec![]), - library::Std::Formatter => Type::Rt("Formatter", vec![]), - library::Std::Arguments => Type::Rt("Arguments", vec![]), - library::Std::FmtError => Type::Rt("FmtError", vec![]), - library::Std::DebugStruct => Type::Rt("DebugStruct", vec![]), - library::Std::DebugTuple => Type::Rt("DebugTuple", vec![]), - library::Std::DebugList => Type::Rt("DebugList", vec![]), + library::Std::ParseBoolError => Type::Rs("ParseBoolError", vec![]), + library::Std::BorrowError => Type::Rs("BorrowError", vec![]), + library::Std::BorrowMutError => Type::Rs("BorrowMutError", vec![]), + library::Std::ParseCharError => Type::Rs("ParseCharError", vec![]), + library::Std::FromUtf16Error => Type::Rs("FromUtf16Error", vec![]), + library::Std::CharTryFromError => Type::Rs("CharTryFromError", vec![]), + library::Std::TryFromCharError => Type::Rs("TryFromCharError", vec![]), + library::Std::DecodeUtf16Error => Type::Rs("DecodeUtf16Error", vec![]), + library::Std::Utf8Chunk => Type::Rs("Utf8Chunk", vec![]), + library::Std::ParseFloatError => Type::Rs("ParseFloatError", vec![]), + library::Std::TryFromFloatSecsError => Type::Rs("TryFromFloatSecsError", vec![]), + library::Std::Formatter => Type::Rs("Formatter", vec![]), + library::Std::Arguments => Type::Rs("Arguments", vec![]), + library::Std::FmtError => Type::Rs("FmtError", vec![]), + library::Std::DebugStruct => Type::Rs("DebugStruct", vec![]), + library::Std::DebugTuple => Type::Rs("DebugTuple", vec![]), + library::Std::DebugList => Type::Rs("DebugList", vec![]), library::Std::AssertKind => Type::Builtin("string"), - library::Std::Arc => Type::Rt("Arc", vec![self.ty(args.type_at(0), span)]), - library::Std::Weak => Type::Rt("Weak", vec![self.ty(args.type_at(0), span)]), + library::Std::Arc => Type::Rs("Arc", vec![self.ty(args.type_at(0), span)]), + library::Std::Weak => Type::Rs("Weak", vec![self.ty(args.type_at(0), span)]), // A guard's first argument is its lifetime. library::Std::Mutex | library::Std::MutexGuard => { let inner = args.types().next().expect("a guarded type"); - Type::Rt("Mutex", vec![self.ty(inner, span)]) + Type::Rs("Mutex", vec![self.ty(inner, span)]) } library::Std::RefCell | library::Std::Ref | library::Std::RefMut => { let inner = args.types().next().expect("a borrowed type"); - Type::Rt("RefCell", vec![self.ty(inner, span)]) + Type::Rs("RefCell", vec![self.ty(inner, span)]) } - library::Std::Cell => Type::Rt("Cell", vec![self.ty(args.type_at(0), span)]), - library::Std::LocalKey => Type::Rt("LocalKey", vec![self.ty(args.type_at(0), span)]), - library::Std::Atomic => Type::Rt("Atomic", vec![self.ty(args.type_at(0), span)]), - library::Std::AtomicOrdering => Type::Rt("AtomicOrdering", vec![]), - // With the `Option`'s `None` where it is `rt.None`. + library::Std::Cell => Type::Rs("Cell", vec![self.ty(args.type_at(0), span)]), + library::Std::LocalKey => Type::Rs("LocalKey", vec![self.ty(args.type_at(0), span)]), + library::Std::Atomic => Type::Rs("Atomic", vec![self.ty(args.type_at(0), span)]), + library::Std::AtomicOrdering => Type::Rs("AtomicOrdering", vec![]), + // With the `Option`'s `None` where it is `rs.None`. std @ (library::Std::OnceCell | library::Std::OnceLock) => { let inner = args.type_at(0); if let Some(msg) = self.erasure_conflict(Ty::new_option(tcx, inner)) { self.err(span, msg); } let mut args = vec![self.ty(inner, span)]; - args.extend(self.erases_to(inner).undefined.then(|| Type::Rt("None", vec![]))); + args.extend(self.erases_to(inner).undefined.then(|| Type::Rs("None", vec![]))); let name = match std { library::Std::OnceCell => "OnceCell", _ => "OnceLock", }; - Type::Rt(name, args) + Type::Rs(name, args) } - library::Std::Once => Type::Rt("Once", vec![]), - library::Std::OnceState => Type::Rt("OnceState", vec![]), - library::Std::LazyCell => Type::Rt("LazyCell", vec![self.ty(args.type_at(0), span)]), - library::Std::LazyLock => Type::Rt("LazyLock", vec![self.ty(args.type_at(0), span)]), - library::Std::Waker => Type::Rt("Waker", vec![]), - library::Std::WakerVTable => Type::Rt("WakerVTable", vec![]), - library::Std::RawWaker => Type::Rt("RawWaker", vec![]), - library::Std::Context => Type::Rt("Context", vec![]), + library::Std::Once => Type::Rs("Once", vec![]), + library::Std::OnceState => Type::Rs("OnceState", vec![]), + library::Std::LazyCell => Type::Rs("LazyCell", vec![self.ty(args.type_at(0), span)]), + library::Std::LazyLock => Type::Rs("LazyLock", vec![self.ty(args.type_at(0), span)]), + library::Std::Waker => Type::Rs("Waker", vec![]), + library::Std::WakerVTable => Type::Rs("WakerVTable", vec![]), + library::Std::RawWaker => Type::Rs("RawWaker", vec![]), + library::Std::Context => Type::Rs("Context", vec![]), library::Std::Poll => { if let Some(msg) = self.erasure_conflict(Ty::new_adt(tcx, adt, args)) { self.err(span, msg); @@ -1796,23 +1796,23 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { // that can be pending, as any future's output is. library::Std::Ready => { self.future_ty(args.type_at(0), span); - Type::Rt("Ready", vec![self.ty(args.type_at(0), span)]) + Type::Rs("Ready", vec![self.ty(args.type_at(0), span)]) } - library::Std::Range => Type::Rt("Range", vec![self.ty(args.type_at(0), span)]), - library::Std::RangeInclusive => Type::Rt("RangeInclusive", vec![self.ty(args.type_at(0), span)]), + library::Std::Range => Type::Rs("Range", vec![self.ty(args.type_at(0), span)]), + library::Std::RangeInclusive => Type::Rs("RangeInclusive", vec![self.ty(args.type_at(0), span)]), library::Std::RangeTo => Type::Object(vec![("end".into(), self.ty(args.type_at(0), span))]), library::Std::RangeToInclusive => Type::Object(vec![ ("end".into(), self.ty(args.type_at(0), span)), ("inclusive".into(), Type::Builtin("true")), ]), - library::Std::RangeFrom => Type::Rt("RangeFrom", vec![self.ty(args.type_at(0), span)]), + library::Std::RangeFrom => Type::Rs("RangeFrom", vec![self.ty(args.type_at(0), span)]), library::Std::RangeFull | library::Std::BuildHasherDefault => Type::Builtin("undefined"), - library::Std::Argument => Type::Rt("Fmt", vec![]), + library::Std::Argument => Type::Rs("Fmt", vec![]), library::Std::NonNull => self.pointer_ty(args.type_at(0), span), library::Std::MaybeUninit | library::Std::ManuallyDrop => self.ty(args.type_at(0), span), library::Std::Peekable => { let item = self.iter_item(Ty::new_adt(tcx, adt, args)); - Type::Rt("Peekable", vec![self.item_ty(item, span)]) + Type::Rs("Peekable", vec![self.item_ty(item, span)]) } library::Std::Infallible => Type::Builtin("never"), // The key and value types, or the item type, without the hasher or allocator. @@ -1841,20 +1841,20 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { _ => ("VecDeque", 1), }; let tys: Vec> = args.types().take(n).collect(); - Type::Rt(name, tys.into_iter().map(|t| self.ty(t, span)).collect()) + Type::Rs(name, tys.into_iter().map(|t| self.ty(t, span)).collect()) } - library::Std::Ordering => Type::Rt("Ordering", vec![]), - library::Std::Hasher => Type::Rt("Hasher", vec![]), - library::Std::RandomState => Type::Rt("RandomState", vec![]), - library::Std::Duration => Type::Rt("Duration", vec![]), - library::Std::Layout => Type::Rt("Layout", vec![]), - library::Std::Location => Type::Rt("Location", vec![]), - library::Std::PanicHookInfo => Type::Rt("PanicHookInfo", vec![]), - library::Std::LayoutError => Type::Rt("LayoutError", vec![]), - library::Std::TryReserveError => Type::Rt("TryReserveError", vec![]), - library::Std::Bytes => Type::Rt("ByteSlice", vec![]), - library::Std::BytesMut => Type::Rt("BytesMut", vec![]), - library::Std::ThreadRng => Type::Rt("ThreadRng", vec![]), + library::Std::Ordering => Type::Rs("Ordering", vec![]), + library::Std::Hasher => Type::Rs("Hasher", vec![]), + library::Std::RandomState => Type::Rs("RandomState", vec![]), + library::Std::Duration => Type::Rs("Duration", vec![]), + library::Std::Layout => Type::Rs("Layout", vec![]), + library::Std::Location => Type::Rs("Location", vec![]), + library::Std::PanicHookInfo => Type::Rs("PanicHookInfo", vec![]), + library::Std::LayoutError => Type::Rs("LayoutError", vec![]), + library::Std::TryReserveError => Type::Rs("TryReserveError", vec![]), + library::Std::Bytes => Type::Rs("ByteSlice", vec![]), + library::Std::BytesMut => Type::Rs("BytesMut", vec![]), + library::Std::ThreadRng => Type::Rs("ThreadRng", vec![]), library::Std::ControlFlow => { if let Some(msg) = self.erasure_conflict(Ty::new_adt(tcx, adt, args)) { self.err(span, msg); @@ -1865,10 +1865,10 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let ty::Adt(_, residual) = residual.kind() else { unreachable!("a `Result` residual") }; - Type::Rt("Result", vec![self.ty(value, span), self.ty(residual.type_at(1), span)]) + Type::Rs("Result", vec![self.ty(value, span), self.ty(residual.type_at(1), span)]) } library::Flow::Option => self.option_ty(value, span), - library::Flow::Other => Type::Rt("Result", vec![self.ty(value, span), self.ty(residual, span)]), + library::Flow::Other => Type::Rs("Result", vec![self.ty(value, span), self.ty(residual, span)]), } } }; @@ -1880,11 +1880,11 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { if library::nothing(tcx, Ty::new_adt(tcx, adt, args)) { return Type::Builtin("undefined"); } - // Every other iterator std has is an `rt.Iter` of its items. + // Every other iterator std has is an `rs.Iter` of its items. if !self.crates.translates(adt.did()) && let Some(item) = self.iter_item(Ty::new_adt(tcx, adt, args)) { - return Type::Rt("Iter", vec![self.ty(item, span)]); + return Type::Rs("Iter", vec![self.ty(item, span)]); } if !self.crates.translates(adt.did()) { self.unrepresented( @@ -1911,7 +1911,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { let identity = ty::GenericArgs::identity_for_item(tcx, adt); let ty = copy::field_ty(tcx, TypingEnv::post_analysis(tcx, adt), field.did, identity); let ty = self.ty(ty, span); - let instanced = |t: &Type| matches!(t, Type::Rt("Ptr" | "ArrayOf" | "SliceOf" | "VecOf" | "CowOf", _)); + let instanced = |t: &Type| matches!(t, Type::Rs("Ptr" | "ArrayOf" | "SliceOf" | "VecOf" | "CowOf", _)); if ty.any(&instanced) { self.instanced_fields .insert(field.did, ty.takes(&instanced).then(|| ty.clone())); @@ -1958,8 +1958,8 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// Why an instance of the crate's generic `adt` with `args` can't hold its fields' values, /// if it can't: an `Option` or a `Poll` over a type parameter that its definition types - /// `T | undefined` or `rt.Poll`, whose `None` or `Pending` this instance's `T` makes - /// `rt.None` or `rt.OuterPending`. + /// `T | undefined` or `rs.Poll`, whose `None` or `Pending` this instance's `T` makes + /// `rs.None` or `rs.OuterPending`. fn generic_erasure(&self, adt: AdtDef<'tcx>, args: GenericArgsRef<'tcx>) -> Option { let tcx = self.tcx; if !args.types().any(|t| { @@ -1986,7 +1986,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(library::Std::Option) if erased.param && !erased.undefined => { self.erases_to(instance).undefined.then(|| { format!( - "`{ty}` is not supported: its field `{}` is `Option<{inner}>`, typed `{inner} | undefined`, whose `None` would be `rt.None` as `Option<{instance}>`", + "`{ty}` is not supported: its field `{}` is `Option<{inner}>`, typed `{inner} | undefined`, whose `None` would be `rs.None` as `Option<{instance}>`", field.name ) }) @@ -1994,7 +1994,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { Some(library::Std::Poll) if erased.param && !erased.pending => { self.erases_to(instance).pending.then(|| { format!( - "`{ty}` is not supported: its field `{}` is `Poll<{inner}>`, typed `rt.Poll<{inner}>`, whose `Pending` would be `rt.OuterPending` as `Poll<{instance}>`", + "`{ty}` is not supported: its field `{}` is `Poll<{inner}>`, typed `rs.Poll<{inner}>`, whose `Pending` would be `rs.OuterPending` as `Poll<{instance}>`", field.name ) }) @@ -2016,64 +2016,64 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// The TypeScript type of an `Option`: `T | undefined`, or `T | rt.None` where + /// The TypeScript type of an `Option`: `T | undefined`, or `T | rs.None` where /// `T` can already be `undefined`. fn option_ty(&mut self, inner: Ty<'tcx>, span: Span) -> Type { let none = match self.erases_to(inner).undefined { - true => Type::Rt("None", vec![]), + true => Type::Rs("None", vec![]), false => Type::Builtin("undefined"), }; Type::Union(vec![self.ty(inner, span), none]) } - /// The TypeScript type of a future of `output`, an `rt.Future`, whose `poll` returns - /// `rt.Pending` as its own `Pending`, so an `output` that can already be one is refused. + /// The TypeScript type of a future of `output`, an `rs.Future`, whose `poll` returns + /// `rs.Pending` as its own `Pending`, so an `output` that can already be one is refused. fn future_ty(&mut self, output: Ty<'tcx>, span: Span) -> Type { if self.erases_to(output).pending { self.unrepresented( span, - format!("a future of `{output}`, which can be `rt.Pending`, as the future's own `Pending` is"), + format!("a future of `{output}`, which can be `rs.Pending`, as the future's own `Pending` is"), ); } - Type::Rt("Future", vec![self.ty(output, span)]) + Type::Rs("Future", vec![self.ty(output, span)]) } - /// The TypeScript type of a `Poll`: `rt.Poll`, or `T | rt.OuterPending` where - /// `T` can already be `rt.Pending`. + /// The TypeScript type of a `Poll`: `rs.Poll`, or `T | rs.OuterPending` where + /// `T` can already be `rs.Pending`. fn poll_ty(&mut self, inner: Ty<'tcx>, span: Span) -> Type { let ready = self.ty(inner, span); match self.erases_to(inner).pending { - true => Type::Union(vec![ready, Type::Rt("OuterPending", vec![])]), - false => Type::Rt("Poll", vec![ready]), + true => Type::Union(vec![ready, Type::Rs("OuterPending", vec![])]), + false => Type::Rs("Poll", vec![ready]), } } - /// The JS value of `Pending` in a `Poll`: `rt.Pending`, or `rt.OuterPending` - /// where `inner` can already be `rt.Pending`. + /// The JS value of `Pending` in a `Poll`: `rs.Pending`, or `rs.OuterPending` + /// where `inner` can already be `rs.Pending`. pub fn pending(&self, inner: Ty<'tcx>) -> ts::Expr { self.pending_arg(inner) - .unwrap_or_else(|| ts::Expr::Rt("Pending".into())) + .unwrap_or_else(|| ts::Expr::Rs("Pending".into())) } - /// `rt.OuterPending` where it is a `Poll`'s `Pending`, for a runtime function - /// whose `pending` is `rt.Pending` unless given. + /// `rs.OuterPending` where it is a `Poll`'s `Pending`, for a runtime function + /// whose `pending` is `rs.Pending` unless given. pub fn pending_arg(&self, inner: Ty<'tcx>) -> Option { self.erases_to(inner) .pending - .then(|| ts::Expr::Rt("OuterPending".into())) + .then(|| ts::Expr::Rs("OuterPending".into())) } /// The JS value of `None` in an `Option`, and of `Break` in a `ControlFlow` - /// that `?` on one makes: `undefined`, or `rt.None` where `inner` can already be + /// that `?` on one makes: `undefined`, or `rs.None` where `inner` can already be /// `undefined`. pub fn none(&self, inner: Ty<'tcx>) -> ts::Expr { self.none_arg(inner).unwrap_or_else(ts::Expr::undefined) } - /// `rt.None`, if it is an `Option`'s `None`, which a runtime function taking + /// `rs.None`, if it is an `Option`'s `None`, which a runtime function taking /// one takes after its own arguments. pub fn none_arg(&self, inner: Ty<'tcx>) -> Option { - self.erases_to(inner).undefined.then(|| ts::Expr::Rt("None".into())) + self.erases_to(inner).undefined.then(|| ts::Expr::Rs("None".into())) } /// Which of the values `Option` and `Poll` erase to a `ty`'s JS value can already be, @@ -2088,7 +2088,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { param: true, ..Erased::default() }, - // An `rt.Place`, which is an object. + // An `rs.Place`, which is an object. ty::Ref(..) if self.place_pointee(ty).is_some() => Erased::default(), ty::Ref(_, inner, _) => self.erases_to(*inner), ty::Adt(adt, args) => match library::Std::of(self.tcx, adt.did()) { @@ -2237,7 +2237,7 @@ pub fn byte_array(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Array(elem, _) if byte(*elem)) } -/// The parts of `slice`, an `rt.ByteSlice`, each read once: those it is made of, or those of a +/// The parts of `slice`, an `rs.ByteSlice`, each read once: those it is made of, or those of a /// path or a slice made from a view of known length, or `undefined`'s, as a value not yet /// written. `None` for what must be held in a path first. pub fn slice_parts(slice: ts::Expr) -> Option<[ts::Expr; 3]> { @@ -2252,7 +2252,7 @@ pub fn slice_parts(slice: ts::Expr) -> Option<[ts::Expr; 3]> { match slice { Expr::Lit(text) if text == "undefined" => Some([(); 3].map(|()| Expr::undefined())), e if e.is_path() => Some(["data", "start", "length"].map(|key| e.clone().member(key))), - Expr::Call(f, mut args) if matches!(&*f, Expr::Rt(name) if name == "byteSliceFrom") && args.len() == 1 => { + Expr::Call(f, mut args) if matches!(&*f, Expr::Rs(name) if name == "byteSliceFrom") && args.len() == 1 => { let bytes = args.pop().expect("one argument"); let length = match &bytes { e if e.is_path() => e.clone().member("length"), @@ -2273,7 +2273,7 @@ pub fn slice_parts(slice: ts::Expr) -> Option<[ts::Expr; 3]> { } } -/// Whether `ty` is a reference to a `[u8; N]`, which is an `rt.ByteSlice` of its bytes, as a +/// Whether `ty` is a reference to a `[u8; N]`, which is an `rs.ByteSlice` of its bytes, as a /// `&[u8]` is: a split's chunk is then no view. pub fn bytes_ref(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Ref(..)) && byte_array(ty.peel_refs()) @@ -2377,7 +2377,7 @@ pub fn escape(name: &str) -> String { "while", "with", "yield", - "rt", + "rs", // Globals the output calls. "Array", "Infinity", diff --git a/ts/src/lower/num.rs b/ts/src/lower/num.rs index fb6722145..22a5ce2db 100644 --- a/ts/src/lower/num.rs +++ b/ts/src/lower/num.rs @@ -45,9 +45,9 @@ impl Int { self.bits > 32 } - /// The TypeScript type of a value, named as the runtime's: `rt.u32`. + /// The TypeScript type of a value, named as the runtime's: `rs.u32`. pub fn ty(self) -> Type { - Type::Rt(self.rt(), Vec::new()) + Type::Rs(self.rs(), Vec::new()) } pub fn min(self) -> i128 { @@ -76,8 +76,8 @@ impl Int { } } - /// The runtime's name for the type: `rt.u32`. - pub fn rt(self) -> &'static str { + /// The runtime's name for the type: `rs.u32`. + pub fn rs(self) -> &'static str { match (self.signed, self.bits, self.pointer) { (false, _, true) => "usize", (true, _, true) => "isize", @@ -105,7 +105,7 @@ impl Int { /// A literal of this type spelled `text`, JS number digits of `value`. A wide value /// past 2^53 is its limbs, written out as the runtime makes them, `{ hi: 0xffffffff, - /// lo: 0xffffffff } as rt.u64`: an object literal costs what a hoisted constant does, + /// lo: 0xffffffff } as rs.u64`: an object literal costs what a hoisted constant does, /// where converting a bigint cost more than the arithmetic around it. fn spelled(self, text: String, value: i128) -> Expr { let safe = (1 - (1i128 << 53)..(1 << 53)).contains(&value) && (self.signed || value >= 0); @@ -130,14 +130,14 @@ impl Int { Expr::As(Box::new(Expr::Object(fields)), self.ty()) } - /// A call of the type's runtime function `name`: `rt.u8Add` for `add`. + /// A call of the type's runtime function `name`: `rs.u8Add` for `add`. pub fn method(self, name: &str, args: Vec) -> Expr { self.func(name).call(args) } /// The type's runtime function `name`, uncalled. pub fn func(self, name: &str) -> Expr { - Expr::rt_of(self.rt(), name) + Expr::rs_of(self.rs(), name) } /// `value`, an exact integer of at most 32 bits, wrapped into this narrow type's range. @@ -247,8 +247,8 @@ pub fn binary<'tcx>( // Both sides are already evaluated, so short-circuiting changes nothing. BinOp::BitAnd if r.expr.is_path() => l.expr.binary("&&", r.expr), BinOp::BitOr if r.expr.is_path() => l.expr.binary("||", r.expr), - BinOp::BitAnd => Expr::rt("and", vec![l.expr, r.expr]), - BinOp::BitOr => Expr::rt("or", vec![l.expr, r.expr]), + BinOp::BitAnd => Expr::rs("and", vec![l.expr, r.expr]), + BinOp::BitOr => Expr::rs("or", vec![l.expr, r.expr]), _ => b.err(span, format!("`{op:?}` on `bool`")), }; } @@ -450,7 +450,7 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Operand, from: Ty<'tcx>, to } // Only a `u8` casts to a `char`, whose scalar value it is. if let (ty::Char, ty::Uint(ty::UintTy::U8)) = (to.kind(), from.kind()) { - return Expr::As(Box::new(value.expr), Type::Rt("char", Vec::new())); + return Expr::As(Box::new(value.expr), Type::Rs("char", Vec::new())); } let Some(target) = Int::of(to) else { return b.err(span, format!("a cast to `{to}`")); @@ -494,7 +494,7 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Operand, from: Ty<'tcx>, to } let fits = target.min() <= source.min() && source.max() <= target.max(); // A cast that keeps the value still changes the type `tsc` checks it as. - let retyped = |value: Expr| match source.rt() == target.rt() { + let retyped = |value: Expr| match source.rs() == target.rs() { true => value, false => Expr::As(Box::new(value), target.ty()), }; @@ -510,7 +510,7 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, value: Operand, from: Ty<'tcx>, to } // A narrow integer is already a wide one's number. (false, true) if fits => retyped(value.expr), - (true, true) if source.rt() == target.rt() => value.expr, + (true, true) if source.rs() == target.rs() => value.expr, _ => target.method("cast", vec![value.expr]), } } diff --git a/ts/src/lower/pointer.rs b/ts/src/lower/pointer.rs index 800d820f9..4660774c8 100644 --- a/ts/src/lower/pointer.rs +++ b/ts/src/lower/pointer.rs @@ -2,18 +2,18 @@ //! //! A raw pointer is what a `&mut` to its pointee is where JS keeps the pointee where Rust //! does: the object, a tuple's or array's or the crate's own struct's, or the -//! `rt.ByteSlice` of a `[u8; N]`'s bytes, which may be part of a larger array or a slice. -//! To anything else it is an `rt.Place` of the place holding the value, as a `&mut` to a +//! `rs.ByteSlice` of a `[u8; N]`'s bytes, which may be part of a larger array or a slice. +//! To anything else it is an `rs.Place` of the place holding the value, as a `&mut` to a //! value JS copies is, which a `Vec` or an `Arc` also is here: its JS object is what it -//! owns, not where Rust keeps it. Null is `rt.NULL`, and a dangling pointer `rt.DANGLING`. +//! owns, not where Rust keeps it. Null is `rs.NULL`, and a dangling pointer `rs.DANGLING`. //! -//! An `rt.Place` into an array, slice, or `Vec` is the `rt.AtIndex` of its element, which +//! An `rs.Place` into an array, slice, or `Vec` is the `rs.AtIndex` of its element, which //! pointer arithmetic moves within the array. A pointer to an element JS keeps as an //! object is that object, which knows no array it is in, so arithmetic on one is refused. //! //! A pointer to `()`, as std erases one, is an identity that compares as itself: null, -//! `rt.DANGLING_UNIT`, or a waker's data. One to a place of `()` or from a reference to -//! one is refused, as an `rt.Place` of it would be an identity of its own each borrow. +//! `rs.DANGLING_UNIT`, or a waker's data. One to a place of `()` or from a reference to +//! one is refused, as an `rs.Place` of it would be an identity of its own each borrow. //! //! A whole value written through a pointer to an object is copied into that object, so //! every pointer to it sees the write. That goes one object deep, as `*r = v` does through @@ -27,7 +27,7 @@ //! A `MaybeUninit` is a `T`: `undefined` where JS copies a `T` and it holds none yet, //! or an object whose parts hold none yet where a pointer to it is the object. A //! `ManuallyDrop` is a `T` that nothing drops but its own `drop`. An `UnsafeCell` is -//! an `rt.Cell`, which is the place a pointer to `T` is, or else holds the object it is. +//! an `rs.Cell`, which is the place a pointer to `T` is, or else holds the object it is. use rustc_middle::ty::{self, Ty, TypeVisitableExt}; use rustc_span::Span; @@ -40,14 +40,14 @@ use crate::ts::{Expr, Key, Stmt, StmtKind, Type}; /// What a raw pointer to a type is in JS. #[derive(Clone, Copy, PartialEq, Eq, Debug)] pub enum Pointee { - /// An `rt.Place` of the value, which JS copies. + /// An `rs.Place` of the value, which JS copies. Place, /// The object it points at. Object, - /// An `rt.ByteSlice` of the `[u8; N]` it points at, as a reference to one is, which + /// An `rs.ByteSlice` of the `[u8; N]` it points at, as a reference to one is, which /// compares by where its bytes are. Bytes, - /// An `rt.RawSlice` of a `[T]`: the pointer to its first element and its length, which + /// An `rs.RawSlice` of a `[T]`: the pointer to its first element and its length, which /// a read through it makes the slice of. Slice, } @@ -90,7 +90,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } /// Why pointers to `ty` that are not null don't compare as their JS values, if they - /// don't. Two `rt.Place`s of one place are two objects, and Rust leaves where a value of + /// don't. Two `rs.Place`s of one place are two objects, and Rust leaves where a value of /// no bytes is unspecified, but a pointer to `()` is an identity. Notes the comparison of /// those that do, for [`Self::taken`]. pub fn incomparable(&mut self, ty: Ty<'tcx>) -> Option { @@ -160,14 +160,14 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { /// The TypeScript type of a raw pointer or `NonNull` to `pointee`. pub fn pointer_ty(&mut self, pointee: Ty<'tcx>, span: Span) -> Type { if self.instance_pointee(pointee) { - return Type::Rt("Ptr", vec![self.ty(pointee, span)]); + return Type::Rs("Ptr", vec![self.ty(pointee, span)]); } match self.pointee(pointee) { - Pointee::Place => Type::Rt("Place", vec![self.ty(pointee, span)]), + Pointee::Place => Type::Rs("Place", vec![self.ty(pointee, span)]), Pointee::Object => self.ty(pointee, span), - Pointee::Bytes => Type::Rt("ByteSlice", Vec::new()), + Pointee::Bytes => Type::Rs("ByteSlice", Vec::new()), Pointee::Slice => match pointee.kind() { - ty::Slice(elem) => Type::Rt("RawSlice", vec![self.ty(*elem, span)]), + ty::Slice(elem) => Type::Rs("RawSlice", vec![self.ty(*elem, span)]), _ => unreachable!("a slice's pointee"), }, } @@ -197,7 +197,7 @@ impl<'a, 'tcx> Translator<'a, 'tcx> { } } - /// What `ty` points at, if it is a raw pointer that is an `rt.Place`. + /// What `ty` points at, if it is a raw pointer that is an `rs.Place`. pub fn raw_place(&self, ty: Ty<'tcx>) -> Option> { match ty.kind() { ty::RawPtr(inner, _) if self.pointee(*inner) == Pointee::Place => Some(*inner), @@ -377,7 +377,7 @@ pub fn rebinds(tcx: ty::TyCtxt<'_>, def_id: rustc_hir::def_id::DefId) -> &'stati } /// Whether std's `def_id` is one this module maps that lends a place: it makes the -/// `rt.Place` of the `&mut` it returns. +/// `rs.Place` of the `&mut` it returns. pub fn lends(tcx: ty::TyCtxt<'_>, def_id: rustc_hir::def_id::DefId) -> bool { matches!( super::library::key(tcx, def_id), @@ -420,7 +420,7 @@ pub fn keeps<'tcx>(tcx: ty::TyCtxt<'tcx>, def_id: rustc_hir::def_id::DefId, args keeps || from_reference(tcx, def_id, args) } -/// Whether std's `def_id` of `args` is one a mapping takes the `rt.Place` a `&mut` is for, +/// Whether std's `def_id` of `args` is one a mapping takes the `rs.Place` a `&mut` is for, /// rather than what it points at: a `MaybeUninit`'s or a `ManuallyDrop`'s, which it points /// into, an `Arc`'s that `make_mut` replaces, a `String`'s that a drain edits as it drops, /// a `Result`'s whose payload JS copies, which `iter_mut` lends as a place that writes the @@ -447,7 +447,7 @@ fn takes_place<'tcx>( } /// Which of std's `def_id`'s parameters its mapping of `args` takes as what the `&mut` it -/// declares points at, rather than the `rt.Place` that `&mut` may be: not a type parameter +/// declares points at, rather than the `rs.Place` that `&mut` may be: not a type parameter /// that one instantiates, as `Pin::new`'s pointer. pub fn pointees<'tcx>( t: &Translator<'_, 'tcx>, @@ -480,15 +480,15 @@ pub fn call<'tcx>( let pointee = || targ(gargs, 0); let kind = |b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>| Some(b.t.pointee(ty)); // A mapping holds a `[u8; N]`, and hands out a reference to one, as the `Uint8Array`, - // which a pointer to it is an `rt.ByteSlice` of. + // which a pointer to it is an `rs.ByteSlice` of. let bytes = |b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>| b.t.pointee(ty) == Pointee::Bytes; - let to_pointer = |e: Expr| Expr::rt("byteSliceFrom", vec![e]); - let to_reference = |e: Expr| Expr::rt("byteSliceView", vec![e]); + let to_pointer = |e: Expr| Expr::rs("byteSliceFrom", vec![e]); + let to_reference = |e: Expr| Expr::rs("byteSliceView", vec![e]); // A raw pointer to a slice, from a reference to one, and the slice a read through it // makes, shared if nothing writes through it. let raw_of = |ty: Ty<'tcx>, s: Expr| match slice_of_bytes(ty) { - true => Expr::rt("rawByteSliceOf", vec![s]), - false => Expr::rt("rawSliceOf", vec![s]), + true => Expr::rs("rawByteSliceOf", vec![s]), + false => Expr::rs("rawSliceOf", vec![s]), }; let deref = |ty: Ty<'tcx>, p: Expr, shared: bool| match slice_of_bytes(ty) { true => p.member("derefBytes").call(vec![Expr::lit(shared.to_string())]), @@ -497,8 +497,8 @@ pub fn call<'tcx>( let mut args = args.into_iter(); let mut arg = || args.next().expect("an argument"); let e = match (owner, name) { - ("ptr", "null" | "null_mut") => Expr::Rt("NULL".into()), - // A pointer to `()` is an identity, which the `rt.Place` of a place or a reference + ("ptr", "null" | "null_mut") => Expr::Rs("NULL".into()), + // A pointer to `()` is an identity, which the `rs.Place` of a place or a reference // is not. A box of one holds nothing, so its pointer is dangling. ("MaybeUninit", "as_ptr" | "as_mut_ptr") | ("UnsafeCell", "get") | ("Cell", "as_ptr") if b.t.identity_pointee(pointee()) => @@ -516,11 +516,11 @@ pub fn call<'tcx>( span, "a raw pointer to a place of `()`, which has no address of its own", ), - ("Box", "into_raw" | "leak") if b.t.identity_pointee(pointee()) => Expr::Rt("DANGLING_UNIT".into()), + ("Box", "into_raw" | "leak") if b.t.identity_pointee(pointee()) => Expr::Rs("DANGLING_UNIT".into()), // One to a value of no bytes points at one, which every read of it reads. One to // `()` is an identity, the same for every call, as its address is. ("NonNull", "dangling") | ("ptr", "dangling" | "dangling_mut") if b.t.identity_pointee(pointee()) => { - Expr::Rt("DANGLING_UNIT".into()) + Expr::Rs("DANGLING_UNIT".into()) } ("NonNull", "dangling") | ("ptr", "dangling" | "dangling_mut") if b.t.zero_sized(pointee()) => { match (b.t.empty(pointee()), kind(b, pointee())) { @@ -535,7 +535,7 @@ pub fn call<'tcx>( (true, _) => b.t.uninit(pointee(), span), } } - ("NonNull", "dangling") | ("ptr", "dangling" | "dangling_mut") => Expr::Rt("DANGLING".into()), + ("NonNull", "dangling") | ("ptr", "dangling" | "dangling_mut") => Expr::Rs("DANGLING".into()), ("ptr" | "NonNull", "cast") => { let p = arg(); cast(b, p, pointee(), targ(gargs, 1), span) @@ -545,12 +545,12 @@ pub fn call<'tcx>( } // A raw pointer to a slice is null where its first element's is. ("ptr", "is_null") if kind(b, pointee()) == Some(Pointee::Slice) => { - arg().member("ptr").binary("===", Expr::Rt("NULL".into())) + arg().member("ptr").binary("===", Expr::Rs("NULL".into())) } // Only a pointer to a slice has these, generic over its element. ("ptr" | "NonNull", "len") => arg().member("length"), ("ptr" | "NonNull", "is_empty") => arg().member("length").binary("===", Expr::lit("0")), - ("ptr", "is_null") => arg().binary("===", Expr::Rt("NULL".into())), + ("ptr", "is_null") => arg().binary("===", Expr::Rs("NULL".into())), ("NonNull", "as_ref" | "as_mut") if kind(b, pointee()) == Some(Pointee::Slice) => { deref(pointee(), arg(), name == "as_ref") } @@ -593,7 +593,7 @@ pub fn call<'tcx>( _ => p.clone(), }; Expr::Cond( - Box::new(at.binary("===", Expr::Rt("NULL".into()))), + Box::new(at.binary("===", Expr::Rs("NULL".into()))), Box::new(Expr::undefined()), Box::new(p), ) @@ -601,7 +601,7 @@ pub fn call<'tcx>( ("ptr", "as_ref" | "as_mut") if kind(b, pointee()) == Some(Pointee::Slice) => { let p = b.spill(arg(), "pointer", out); Expr::Cond( - Box::new(p.clone().member("ptr").binary("===", Expr::Rt("NULL".into()))), + Box::new(p.clone().member("ptr").binary("===", Expr::Rs("NULL".into()))), Box::new(Expr::undefined()), Box::new(deref(pointee(), p, name == "as_ref")), ) @@ -616,7 +616,7 @@ pub fn call<'tcx>( false => (p.clone(), Expr::undefined()), }; Expr::Cond( - Box::new(p.binary("===", Expr::Rt("NULL".into()))), + Box::new(p.binary("===", Expr::Rs("NULL".into()))), Box::new(none), Box::new(some), ) @@ -626,7 +626,7 @@ pub fn call<'tcx>( Some(Pointee::Bytes) if owner == "NonNull" => to_reference(arg()), _ => arg(), }, - // An `rt.Arc` is its allocation, which has one place of its value: the pointer to a + // An `rs.Arc` is its allocation, which has one place of its value: the pointer to a // value JS copies and to `()`, whose pointer is an identity. Otherwise the value is // where a reference to it points, a pointer to which is made as `ptr::from_ref` // makes one. @@ -660,18 +660,18 @@ pub fn call<'tcx>( ("Arc" | "Rc", "as_ptr" | "into_raw") => { let arc = b.spill(arg(), "arc", out); let p = match kind(b, pointee()) { - Some(Pointee::Place) => Expr::rt("arcPlace", vec![arc.clone()]), + Some(Pointee::Place) => Expr::rs("arcPlace", vec![arc.clone()]), _ => { b.t.compare(pointee()); arc.clone().member("value") } }; - Expr::rt("arcRaw", vec![arc, p, Expr::Str(owner.into())]) + Expr::rs("arcRaw", vec![arc, p, Expr::Str(owner.into())]) } - ("Arc" | "Rc", "from_raw") => Expr::rt("arcFromRaw", vec![arg(), Expr::Str(owner.into())]), + ("Arc" | "Rc", "from_raw") => Expr::rs("arcFromRaw", vec![arg(), Expr::Str(owner.into())]), ("Arc" | "Rc", "increment_strong_count") => { - let arc = Expr::rt("arcFromRaw", vec![arg(), Expr::Str(owner.into())]); - out.push(StmtKind::Expr(Expr::rt("arcClone", vec![arc])).at(None)); + let arc = Expr::rs("arcFromRaw", vec![arg(), Expr::Str(owner.into())]); + out.push(StmtKind::Expr(Expr::rs("arcClone", vec![arc])).at(None)); Expr::undefined() } // The `Arc` `from_raw` takes back, dropped. @@ -679,10 +679,10 @@ pub fn call<'tcx>( let tcx = b.t.tcx; let imp = tcx.inherent_impl_of_assoc(call.def_id).expect("an inherent function"); let ty = tcx.type_of(imp).instantiate(tcx, gargs).skip_norm_wip(); - let arc = Expr::rt("arcFromRaw", vec![arg(), Expr::Str(owner.into())]); + let arc = Expr::rs("arcFromRaw", vec![arg(), Expr::Str(owner.into())]); match b.t.drop_value(arc.clone(), ty, span) { Some(dropped) => dropped, - None => Expr::rt("arcDrop", vec![arc]), + None => Expr::rs("arcDrop", vec![arc]), } } // A pointer to what a box held, which no box holds any longer. @@ -776,7 +776,7 @@ pub fn call<'tcx>( let p = b.spill(arg(), "uninit", out); let value = arg(); let write = match bytes(b, pointee()) { - true => Expr::rt("ptrWrite", vec![p.clone(), value]), + true => Expr::rs("ptrWrite", vec![p.clone(), value]), false => write(b, p.clone(), value, pointee(), span), }; out.push(StmtKind::Expr(write).at(None)); @@ -801,14 +801,14 @@ pub fn call<'tcx>( }; b.t.snapshot(value, pointee(), span) } - // An `rt.Cell`, a `Cell`'s too, which is the place a pointer to a value JS copies is, + // An `rs.Cell`, a `Cell`'s too, which is the place a pointer to a value JS copies is, // and holds the object a pointer to any other is. - ("UnsafeCell", "new") => Expr::New(Box::new(Expr::Rt("Cell".into())), vec![arg()]), + ("UnsafeCell", "new") => Expr::New(Box::new(Expr::Rs("Cell".into())), vec![arg()]), ("UnsafeCell", "get") | ("Cell", "as_ptr") if kind(b, pointee()) == Some(Pointee::Place) => arg(), ("UnsafeCell", "get") | ("Cell", "as_ptr") if bytes(b, pointee()) => to_pointer(arg().member("v")), ("UnsafeCell" | "Cell", "get_mut") if b.t.needs_place(pointee()) => arg(), ("UnsafeCell", "get" | "get_mut" | "into_inner") | ("Cell", "as_ptr" | "get_mut") => arg().member("v"), - // Pointers into an array: `rt.AtIndex`es, which a `Vec`'s and a slice's give. + // Pointers into an array: `rs.AtIndex`es, which a `Vec`'s and a slice's give. ("slice" | "Vec", "as_ptr" | "as_mut_ptr") => { let elem = targ(gargs, 0); let s = arg(); @@ -816,10 +816,10 @@ pub fn call<'tcx>( return Ok(Some(b.err(span, why))); } match (owner, super::byte(elem)) { - ("slice", true) => Expr::rt("byteSliceAsPtr", vec![s]), - ("Vec", true) => Expr::rt("byteVecAsPtr", vec![s]), - ("Vec", false) => Expr::rt("sliceAsPtr", vec![s.member("items")]), - _ => Expr::rt("sliceAsPtr", vec![s]), + ("slice", true) => Expr::rs("byteSliceAsPtr", vec![s]), + ("Vec", true) => Expr::rs("byteVecAsPtr", vec![s]), + ("Vec", false) => Expr::rs("sliceAsPtr", vec![s.member("items")]), + _ => Expr::rs("sliceAsPtr", vec![s]), } } ("ptr" | "NonNull", "add" | "sub" | "offset" | "wrapping_add" | "wrapping_sub" | "wrapping_offset") => { @@ -837,13 +837,13 @@ pub fn call<'tcx>( }; match name.starts_with("wrapping") { true => match super::iter::layout(b, pointee(), span) { - Ok((size, align)) => Expr::rt( + Ok((size, align)) => Expr::rs( "ptrWrappingAdd", vec![p, n, Expr::lit(size.to_string()), Expr::lit(align.to_string())], ), Err(e) => e, }, - false => Expr::rt("ptrAdd", vec![p, n]), + false => Expr::rs("ptrAdd", vec![p, n]), } } } @@ -856,7 +856,7 @@ pub fn call<'tcx>( format!("`offset_from` of pointers to `{}`, which has no bytes", pointee()), ), Some(why) => b.err(span, why), - None => Expr::rt("ptrOffsetFrom", vec![p, origin]), + None => Expr::rs("ptrOffsetFrom", vec![p, origin]), } } ( @@ -882,7 +882,7 @@ pub fn call<'tcx>( } else { let mut args = vec![src, dst, n]; args.extend(b.t.snapshot_fn(pointee(), span)); - Expr::rt("ptrCopy", args) + Expr::rs("ptrCopy", args) } } ("raw", "from_raw_parts" | "from_raw_parts_mut") @@ -899,12 +899,12 @@ pub fn call<'tcx>( Some(why) => return Ok(Some(b.err(span, why))), // A raw pointer to a slice is where it starts and how long it is, which // nothing checks until a read through it. - None if owner != "raw" => Expr::New(Box::new(Expr::Rt("RawSlice".into())), vec![p, len]), + None if owner != "raw" => Expr::New(Box::new(Expr::Rs("RawSlice".into())), vec![p, len]), None if super::byte(pointee()) => { let shared = name == "from_raw_parts"; - Expr::rt("ptrByteSlice", vec![p, len, Expr::lit(shared.to_string())]) + Expr::rs("ptrByteSlice", vec![p, len, Expr::lit(shared.to_string())]) } - None => Expr::rt("ptrSlice", vec![p, len]), + None => Expr::rs("ptrSlice", vec![p, len]), } } ("mem", "forget") => Expr::undefined(), @@ -916,7 +916,7 @@ pub fn call<'tcx>( /// Why a pointer to `ty` can't be erased to a `*const ()`, an identity that compares as /// itself, if it can't: one JS reaches through a slice's places, or a view of bytes, is a /// new one each borrow, and one to a value of no fixed size loses its size. Of a place, -/// only an `Arc`'s is the value's one, which `rt.arcErase` checks where the body doesn't +/// only an `Arc`'s is the value's one, which `rs.arcErase` checks where the body doesn't /// show it. pub fn unerasable<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>) -> Option { if b.t.polymorphic() && ty.has_param() { @@ -1029,10 +1029,10 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, from: Ty<'tcx>, to: Ty<'t Pointee::Place => "arcErase", _ => "ptrErase", }; - return Expr::rt(erase, vec![p, key(inner), align(inner)]); + return Expr::rs(erase, vec![p, key(inner), align(inner)]); } if b.t.identity_pointee(inner) { - let restored = Expr::rt("ptrUnerase", vec![p, key(into), align(into)]); + let restored = Expr::rs("ptrUnerase", vec![p, key(into), align(into)]); return Expr::As(Box::new(restored), b.t.pointer_ty(into, span)); } let elem = match inner.kind() { @@ -1049,11 +1049,11 @@ pub fn cast<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, from: Ty<'tcx>, to: Ty<'t return b.err(span, why); } // A pointer to a slice holds the pointer to its first element, and one to an array is - // the array, or the `rt.ByteSlice` of its bytes. + // the array, or the `rs.ByteSlice` of its bytes. match b.t.pointee(inner) { Pointee::Slice => p.member("ptr"), - Pointee::Bytes => Expr::rt("byteSliceAsPtr", vec![p]), - _ => Expr::rt("sliceAsPtr", vec![p]), + Pointee::Bytes => Expr::rs("byteSliceAsPtr", vec![p]), + _ => Expr::rs("sliceAsPtr", vec![p]), } } @@ -1077,7 +1077,7 @@ fn read<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, ty: Ty<'tcx>, span: Span) -> let value = match b.t.pointee(ty) { Pointee::Place => p.member("v"), Pointee::Object => p, - Pointee::Bytes => return Expr::rt("byteSliceToArray", vec![p]), + Pointee::Bytes => return Expr::rs("byteSliceToArray", vec![p]), Pointee::Slice => return b.err(span, format!("a read of `{ty}`, which has no size")), }; b.t.snapshot(value, ty, span) @@ -1090,13 +1090,13 @@ fn write<'tcx>(b: &mut Body<'_, '_, 'tcx>, p: Expr, value: Expr, ty: Ty<'tcx>, s } match b.t.pointee(ty) { Pointee::Place => p.member("v").assign(value), - Pointee::Object => Expr::rt("ptrWrite", vec![p, value]), - Pointee::Bytes => Expr::rt("byteSliceSet", vec![p, value]), + Pointee::Object => Expr::rs("ptrWrite", vec![p, value]), + Pointee::Bytes => Expr::rs("byteSliceSet", vec![p, value]), Pointee::Slice => b.err(span, format!("a write of `{ty}`, which has no size")), } } -/// Whether `ty` is `[u8]`, or one of `MaybeUninit`, whose slices are `rt.ByteSlice`s. +/// Whether `ty` is `[u8]`, or one of `MaybeUninit`, whose slices are `rs.ByteSlice`s. pub fn slice_of_bytes(ty: Ty<'_>) -> bool { matches!(ty.kind(), ty::Slice(elem) if super::byte(*elem)) } @@ -1104,12 +1104,12 @@ pub fn slice_of_bytes(ty: Ty<'_>) -> bool { /// Whether pointers `x` and `y` to `ty` point at the same place: the same object or /// bytes, or null both. pub fn compare<'tcx>(b: &mut Body<'_, '_, 'tcx>, x: Expr, y: Expr, ty: Ty<'tcx>, span: Span) -> Expr { - let null = |e: &Expr| matches!(e, Expr::Rt(n) if n == "NULL"); + let null = |e: &Expr| matches!(e, Expr::Rs(n) if n == "NULL"); match b.t.incomparable(ty) { Some(why) if !null(&x) && !null(&y) => b.err(span, why), - _ if b.t.pointee(ty) == Pointee::Bytes && !null(&x) && !null(&y) => Expr::rt("byteSliceSame", vec![x, y]), + _ if b.t.pointee(ty) == Pointee::Bytes && !null(&x) && !null(&y) => Expr::rs("byteSliceSame", vec![x, y]), // Each is a view of the struct it was made from. - _ if !ty.is_trait() && super::dynamic::unsized_object(b.t.tcx, ty) => Expr::rt("tailSame", vec![x, y]), + _ if !ty.is_trait() && super::dynamic::unsized_object(b.t.tcx, ty) => Expr::rs("tailSame", vec![x, y]), _ => x.binary("===", y), } } diff --git a/ts/src/lower/stock.rs b/ts/src/lower/stock.rs index 9084fb8b0..d01f9a652 100644 --- a/ts/src/lower/stock.rs +++ b/ts/src/lower/stock.rs @@ -1,6 +1,6 @@ //! Well-known crates that translation maps itself, as it maps std, so a consumer binds -//! none of them: `bytes`' `Bytes`, which is the `rt.ByteSlice` a `&[u8]` is, and -//! `BytesMut`, which is `rt.BytesMut`, `hashbrown`'s tables, which std's `HashMap` and +//! none of them: `bytes`' `Bytes`, which is the `rs.ByteSlice` a `&[u8]` is, and +//! `BytesMut`, which is `rs.BytesMut`, `hashbrown`'s tables, which std's `HashMap` and //! `HashSet` are, and `rand`'s thread-local generator, which draws from the platform's //! cryptographic source. The rest of `bytes`, such as most of `Buf`'s //! provided methods of the crate's own buffers, translates from its MIR. `tracing`'s @@ -202,10 +202,10 @@ const BUF_MUT: &[&str] = &[ /// A buffer that the mapping of `Buf` or `BufMut` reads or writes. #[derive(Clone, Copy, PartialEq)] enum Buffer { - /// A `Bytes`, whose `&mut` is an `rt.Place`. + /// A `Bytes`, whose `&mut` is an `rs.Place`. Bytes, BytesMut, - /// A `&[u8]`, whose `&mut` is an `rt.Place` too. + /// A `&[u8]`, whose `&mut` is an `rs.Place` too. Slice, /// A `Vec`, which `BufMut` writes. Vec, @@ -280,7 +280,7 @@ pub fn call<'tcx>( let mut arg = || args.next().expect("an argument"); Ok(match (owner.as_str(), name.as_str(), self_std) { // A clone of a `Bytes` counts its storage once more, and a `ThreadRng` holds nothing. - ("Clone", "clone", Some(Std::Bytes)) => Some(Expr::rt("bytesClone", vec![arg()])), + ("Clone", "clone", Some(Std::Bytes)) => Some(Expr::rs("bytesClone", vec![arg()])), // A `Bytes` is the slice it derefs to. ("Clone", "clone", Some(Std::ThreadRng)) | ("Deref", "deref", Some(Std::Bytes)) @@ -293,10 +293,10 @@ pub fn call<'tcx>( | ("AsMut", "as_mut", Some(Std::BytesMut)) | ("Borrow", "borrow", Some(Std::BytesMut)) | ("BorrowMut", "borrow_mut", Some(Std::BytesMut)) => Some(view(arg())), - ("Clone", "clone", Some(Std::BytesMut)) => Some(Expr::rt("bytesMutFrom", vec![view(arg())])), - ("Default", "default", Some(Std::Bytes)) => Some(Expr::rt("bytesNew", vec![])), - ("Default", "default", Some(Std::BytesMut)) => Some(Expr::rt("bytesMutWithCapacity", vec![Expr::lit("0")])), - ("Default", "default", Some(Std::ThreadRng)) => Some(Expr::rt("randRng", vec![])), + ("Clone", "clone", Some(Std::BytesMut)) => Some(Expr::rs("bytesMutFrom", vec![view(arg())])), + ("Default", "default", Some(Std::Bytes)) => Some(Expr::rs("bytesNew", vec![])), + ("Default", "default", Some(Std::BytesMut)) => Some(Expr::rs("bytesMutWithCapacity", vec![Expr::lit("0")])), + ("Default", "default", Some(Std::ThreadRng)) => Some(Expr::rs("randRng", vec![])), ("PartialEq", "eq", _) => { let (l, r) = (targ(call.args, 0).peel_refs(), targ(call.args, 1).peel_refs()); let stock = |t: Ty<'tcx>| matches!(b.t.std_of(t), Some(Std::Bytes | Std::BytesMut)); @@ -305,7 +305,7 @@ pub fn call<'tcx>( } let (a, c) = (arg(), arg()); match (as_slice(b, l, a), as_slice(b, r, c)) { - (Some(a), Some(c)) => Some(Expr::rt("byteSliceEq", vec![a, c])), + (Some(a), Some(c)) => Some(Expr::rs("byteSliceEq", vec![a, c])), _ => None, } } @@ -314,16 +314,16 @@ pub fn call<'tcx>( }) } -/// The bytes of `value`, a `ty`, as an `rt.ByteSlice`, if it is a run of bytes. +/// The bytes of `value`, a `ty`, as an `rs.ByteSlice`, if it is a run of bytes. fn as_slice<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr) -> Option { Some(match ty.kind() { ty::Slice(e) if is_u8(*e) => value, - ty::Array(e, _) if is_u8(*e) => Expr::rt("byteSliceFrom", vec![value]), - _ if string(b.t.tcx, ty) => Expr::rt("stringAsBytes", vec![value]), + ty::Array(e, _) if is_u8(*e) => Expr::rs("byteSliceFrom", vec![value]), + _ if string(b.t.tcx, ty) => Expr::rs("stringAsBytes", vec![value]), _ => match b.t.std_of(ty)? { Std::Bytes => value, Std::BytesMut => view(value), - Std::Vec if targ_is_u8(ty) => Expr::rt("byteVecSlice", vec![value]), + Std::Vec if targ_is_u8(ty) => Expr::rs("byteVecSlice", vec![value]), _ => return None, }, }) @@ -331,7 +331,7 @@ fn as_slice<'tcx>(b: &Body<'_, '_, 'tcx>, ty: Ty<'tcx>, value: Expr) -> Option Expr { - Expr::rt("bytesMutView", vec![value]) + Expr::rs("bytesMutView", vec![value]) } /// `From::from` into or out of a `Bytes` or a `BytesMut`. @@ -348,17 +348,17 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> (Some(Std::Bytes), _) if from.is_ref() && string(tcx, from.peel_refs()) => "stringAsBytes", (Some(Std::Bytes), _) if string(tcx, from) => { b.t.string_bytes(); - let bytes = Expr::rt("stringIntoBytes", args.collect()); - return Ok(Some(Expr::rt("bytesFromVec", vec![bytes]))); + let bytes = Expr::rs("stringIntoBytes", args.collect()); + return Ok(Some(Expr::rs("bytesFromVec", vec![bytes]))); } (Some(Std::Bytes), _) if is_bytes_ref(from) => "bytesStatic", (Some(Std::Bytes), _) => return Ok(None), (Some(Std::BytesMut), _) => { let bytes = match as_slice(b, from.peel_refs(), args.next().expect("an operand")) { - Some(bytes) if from.is_ref() => Expr::rt("bytesMutFrom", vec![bytes]), + Some(bytes) if from.is_ref() => Expr::rs("bytesMutFrom", vec![bytes]), Some(bytes) if b.t.std_of(from) == Some(Std::Bytes) => { b.t.string_capacity(call.span, "BytesMut::from(Bytes)"); - Expr::rt("bytesMutFromBytes", vec![bytes]) + Expr::rs("bytesMutFromBytes", vec![bytes]) } _ => return Ok(None), }; @@ -372,7 +372,7 @@ fn from<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, args: Vec) -> (_, Some(Std::Bytes | Std::BytesMut)) => return Ok(None), _ => return Err(args.collect()), }; - Ok(Some(Expr::rt(f, args.collect()))) + Ok(Some(Expr::rs(f, args.collect()))) } /// A function of `bytes`: `Bytes`'s or `BytesMut`'s own, or a method of `Buf` or `BufMut` @@ -418,7 +418,7 @@ fn bytes<'tcx>( } } -/// A function of `Bytes`: a `&mut self` one takes its `rt.Place`. +/// A function of `Bytes`: a `&mut self` one takes its `rs.Place`. fn bytes_own<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, @@ -433,25 +433,25 @@ fn bytes_own<'tcx>( } let mut args = args.into_iter(); Some(match name { - "new" => Expr::rt("bytesNew", vec![]), + "new" => Expr::rs("bytesNew", vec![]), // A `&'static [u8]` never changes, so the slice is the `Bytes`, which counts no storage. - "from_static" => Expr::rt("bytesStatic", vec![args.next()?]), - "copy_from_slice" => Expr::rt("bytesCopyFromSlice", vec![args.next()?]), + "from_static" => Expr::rs("bytesStatic", vec![args.next()?]), + "copy_from_slice" => Expr::rs("bytesCopyFromSlice", vec![args.next()?]), "len" => args.next()?.member("length"), "is_empty" => args.next()?.member("length").binary("===", Expr::lit("0")), // The other ranges' bounds are read where the range is made, by the body's lowering. "slice" if b.t.std_of(targ(call.args, 0)) == Some(Std::RangeInclusive) => { - Expr::rt("bytesSliceInclusive", vec![args.next()?, args.next()?]) + Expr::rs("bytesSliceInclusive", vec![args.next()?, args.next()?]) } - "slice_ref" => Expr::rt("bytesSliceRef", vec![args.next()?, args.next()?]), - "is_unique" => Expr::rt("bytesIsUnique", vec![args.next()?]), - "try_into_mut" => Expr::rt("bytesTryIntoMut", vec![args.next()?]), - "split_to" => Expr::rt("bytesSplitTo", vec![args.next()?, args.next()?]), - "split_off" => Expr::rt("bytesSplitOff", vec![args.next()?, args.next()?]), - "truncate" => Expr::rt("bytesTruncate", vec![args.next()?, args.next()?]), - "clear" => Expr::rt("bytesTruncate", vec![args.next()?, Expr::lit("0")]), + "slice_ref" => Expr::rs("bytesSliceRef", vec![args.next()?, args.next()?]), + "is_unique" => Expr::rs("bytesIsUnique", vec![args.next()?]), + "try_into_mut" => Expr::rs("bytesTryIntoMut", vec![args.next()?]), + "split_to" => Expr::rs("bytesSplitTo", vec![args.next()?, args.next()?]), + "split_off" => Expr::rs("bytesSplitOff", vec![args.next()?, args.next()?]), + "truncate" => Expr::rs("bytesTruncate", vec![args.next()?, args.next()?]), + "clear" => Expr::rs("bytesTruncate", vec![args.next()?, Expr::lit("0")]), // The owner is read once, as `bytes` reads it, and would drop with the last `Bytes` - // that shares it, which `rt.Shared` keeps no owner to drop. + // that shares it, which `rs.Shared` keeps no owner to drop. "from_owner" => { let owner = targ(call.args, 0); if b.t.drops(owner) { @@ -469,7 +469,7 @@ fn bytes_own<'tcx>( call.span, out, ); - Expr::rt("bytesStatic", vec![bytes]) + Expr::rs("bytesStatic", vec![bytes]) } _ => return None, }) @@ -486,7 +486,7 @@ fn bytes_mut( let mut args = args.into_iter(); let mut arg = || args.next(); let f = match name { - "new" => return Some(Expr::rt("bytesMutWithCapacity", vec![Expr::lit("0")])), + "new" => return Some(Expr::rs("bytesMutWithCapacity", vec![Expr::lit("0")])), "with_capacity" => "bytesMutWithCapacity", "zeroed" => "bytesMutZeroed", "len" => return Some(arg()?.member("length")), @@ -499,10 +499,10 @@ fn bytes_mut( "try_unsplit" => "bytesMutTryUnsplit", "split" => { let this = b.spill(arg()?, "buf", out); - return Some(Expr::rt("bytesMutSplitTo", vec![this.clone(), this.member("length")])); + return Some(Expr::rs("bytesMutSplitTo", vec![this.clone(), this.member("length")])); } "truncate" => "bytesMutTruncate", - "clear" => return Some(Expr::rt("bytesMutTruncate", vec![arg()?, Expr::lit("0")])), + "clear" => return Some(Expr::rs("bytesMutTruncate", vec![arg()?, Expr::lit("0")])), "resize" => "bytesMutResize", "reserve" => "bytesMutReserve", "extend_from_slice" => "bytesMutExtend", @@ -511,7 +511,7 @@ fn bytes_mut( "set_len" => "bytesMutSetLen", _ => return None, }; - Some(Expr::rt(f, args.collect())) + Some(Expr::rs(f, args.collect())) } /// A method of `Buf` on a buffer the mapping reads. @@ -531,21 +531,21 @@ fn buf<'tcx>( Buffer::BytesMut => Some("bytesMut"), Buffer::Vec => None, }; - let rt = |f: &str, args: Vec| Some(Expr::rt(format!("{}{f}", prefix?), args)); + let rs = |f: &str, args: Vec| Some(Expr::rs(format!("{}{f}", prefix?), args)); Some(match name { "remaining" => this.member("length"), "has_remaining" => this.member("length").binary("!==", Expr::lit("0")), "chunk" if buffer == Buffer::BytesMut => view(this), "chunk" => this, - "advance" if buffer == Buffer::Slice => Expr::rt("byteSliceAdvance", vec![this, args.next()?]), - "advance" => rt("Advance", vec![this, args.next()?])?, - "copy_to_slice" => rt("CopyToSlice", vec![this, args.next()?])?, - "copy_to_bytes" if buffer == Buffer::BytesMut => Expr::rt( + "advance" if buffer == Buffer::Slice => Expr::rs("byteSliceAdvance", vec![this, args.next()?]), + "advance" => rs("Advance", vec![this, args.next()?])?, + "copy_to_slice" => rs("CopyToSlice", vec![this, args.next()?])?, + "copy_to_bytes" if buffer == Buffer::BytesMut => Expr::rs( "bytesMutFreeze", - vec![Expr::rt("bytesMutSplitTo", vec![this, args.next()?])], + vec![Expr::rs("bytesMutSplitTo", vec![this, args.next()?])], ), - "copy_to_bytes" if buffer == Buffer::Slice => Expr::rt("byteSliceCopyToBytes", vec![this, args.next()?]), - "copy_to_bytes" => rt("SplitTo", vec![this, args.next()?])?, + "copy_to_bytes" if buffer == Buffer::Slice => Expr::rs("byteSliceCopyToBytes", vec![this, args.next()?]), + "copy_to_bytes" => rs("SplitTo", vec![this, args.next()?])?, _ => { let (ty, le) = scalar(name.strip_prefix("get_")?); let out = b.t.sig(call.def_id, call.args).output(); @@ -554,18 +554,18 @@ fn buf<'tcx>( "uint" | "int" => { let int = Int::of(out)?; let (size, signed) = (Expr::lit("8"), Expr::lit(int.signed.to_string())); - let read = rt("ReadInt", vec![this, size, args.next()?, signed, le])?; + let read = rs("ReadInt", vec![this, size, args.next()?, signed, le])?; int.method("fromBeBytes", vec![read]) } - "f32" => Expr::rt("f32FromBeBytes", vec![rt("Read", vec![this, Expr::lit("4"), le])?]), - "f64" => Expr::rt("f64FromBeBytes", vec![rt("Read", vec![this, Expr::lit("8"), le])?]), + "f32" => Expr::rs("f32FromBeBytes", vec![rs("Read", vec![this, Expr::lit("4"), le])?]), + "f64" => Expr::rs("f64FromBeBytes", vec![rs("Read", vec![this, Expr::lit("8"), le])?]), _ => { let int = Int::of(out)?; let n = Expr::lit((int.bits / 8).to_string()); if int.big() { - int.method("fromBeBytes", vec![rt("Read", vec![this, n, le])?]) + int.method("fromBeBytes", vec![rs("Read", vec![this, n, le])?]) } else { - let word = rt("ReadWord", vec![this, n, le])?; + let word = rs("ReadWord", vec![this, n, le])?; let word = if int.signed { int.wrap(word) } else { word }; Expr::As(Box::new(word), int.ty()) } @@ -624,7 +624,7 @@ fn buf_mut<'tcx>( Buffer::Vec => "byteVec", Buffer::Bytes | Buffer::Slice => return None, }; - let rt = |f: &str, args: Vec| Expr::rt(format!("{prefix}{f}"), args); + let rs = |f: &str, args: Vec| Expr::rs(format!("{prefix}{f}"), args); // A vector's or a `BytesMut`'s length is at most `isize::MAX`. let isize_max = Expr::lit("0x7fffffff"); Some(match name { @@ -633,12 +633,12 @@ fn buf_mut<'tcx>( Int::of(b.t.tcx.types.usize)?.ty(), ), "has_remaining_mut" => this.member("length").binary("<", isize_max), - "advance_mut" => rt("AdvanceMut", vec![this, args.next()?]), - "put_slice" if buffer == Buffer::BytesMut => Expr::rt("bytesMutExtend", vec![this, args.next()?]), - "put_slice" => Expr::rt("byteVecExtendFromSlice", vec![this, args.next()?]), + "advance_mut" => rs("AdvanceMut", vec![this, args.next()?]), + "put_slice" if buffer == Buffer::BytesMut => Expr::rs("bytesMutExtend", vec![this, args.next()?]), + "put_slice" => Expr::rs("byteVecExtendFromSlice", vec![this, args.next()?]), "put" => put(b, call, buffer, through, this, args.next()?, out)?, - "put_bytes" if through => rt("PutFillChunked", vec![this, args.next()?, args.next()?]), - "put_bytes" => rt("PutFill", vec![this, args.next()?, args.next()?]), + "put_bytes" if through => rs("PutFillChunked", vec![this, args.next()?, args.next()?]), + "put_bytes" => rs("PutFill", vec![this, args.next()?, args.next()?]), _ => { let (ty, le) = scalar(name.strip_prefix("put_")?); let input = *b.t.sig(call.def_id, call.args).inputs().get(1)?; @@ -647,15 +647,15 @@ fn buf_mut<'tcx>( match ty { "uint" | "int" => { let be = Int::of(input)?.method("toBeBytes", vec![value]); - rt("PutInt", vec![this, be, args.next()?, le]) + rs("PutInt", vec![this, be, args.next()?, le]) } - "f32" => rt("PutBytes", vec![this, Expr::rt("f32ToBeBytes", vec![value]), le]), - "f64" => rt("PutBytes", vec![this, Expr::rt("f64ToBeBytes", vec![value]), le]), + "f32" => rs("PutBytes", vec![this, Expr::rs("f32ToBeBytes", vec![value]), le]), + "f64" => rs("PutBytes", vec![this, Expr::rs("f64ToBeBytes", vec![value]), le]), _ => { let int = Int::of(input)?; match int.big() { - true => rt("PutBytes", vec![this, int.method("toBeBytes", vec![value]), le]), - false => rt("PutWord", vec![this, value, Expr::lit((int.bits / 8).to_string()), le]), + true => rs("PutBytes", vec![this, int.method("toBeBytes", vec![value]), le]), + false => rs("PutWord", vec![this, value, Expr::lit((int.bits / 8).to_string()), le]), } } } @@ -702,10 +702,10 @@ fn put<'tcx>( if b.t.drops(ty) { values.push(dropper(b, ty, call.span)?); } - return Some(Expr::rt("bytesMutPutBuf", values)); + return Some(Expr::rs("bytesMutPutBuf", values)); } }; - return Some(Expr::rt(f, vec![this, src])); + return Some(Expr::rs(f, vec![this, src])); } // Elsewhere it drops once all of it is written. let src = match b.t.drops(ty) { @@ -724,7 +724,7 @@ fn put<'tcx>( _ if through => "byteVecPutChunked", _ => "byteVecExtendFromSlice", }; - Expr::rt(f, vec![this, bytes]) + Expr::rs(f, vec![this, bytes]) } None => { let mut values = vec![this, held(b, ty, src.clone())]; @@ -736,7 +736,7 @@ fn put<'tcx>( (_, true) => "byteVecPutBufChunked", (_, false) => "byteVecPutBuf", }; - Expr::rt(f, values) + Expr::rs(f, values) } }; match b.t.drop_value(src, ty, call.span) { @@ -764,7 +764,7 @@ fn dropper<'tcx>(b: &mut Body<'_, '_, 'tcx>, ty: Ty<'tcx>, span: rustc_span::Spa } let param = crate::ts::Param { name: "p".into(), - ty: Some(crate::ts::Type::Rt("Place", vec![b.t.ty(ty, span)])), + ty: Some(crate::ts::Type::Rs("Place", vec![b.t.ty(ty, span)])), }; let dropped = b.t.drop_value(Expr::ident("p").member("v"), ty, span)?; Some(Expr::Lambda(vec![param], Box::new(dropped))) @@ -786,7 +786,7 @@ fn provided_copy_to_bytes<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, a buf_method(b, call, ty, "chunk")?, buf_method(b, call, ty, "advance")?, ); - Some(Expr::rt("bufCopyToBytes", vec![this, len, remaining, chunk, advance])) + Some(Expr::rs("bufCopyToBytes", vec![this, len, remaining, chunk, advance])) } /// A provided `get_*` or `try_get_*` of `Buf` of an integer of a fixed size. @@ -810,7 +810,7 @@ impl Get { } } -/// `get` of the buffer `ty` as `bytes` provides it: `rt.bufGet` or `rt.bufTryGet` of its own +/// `get` of the buffer `ty` as `bytes` provides it: `rs.bufGet` or `rs.bufTryGet` of its own /// methods, which read its chunk where it holds the integer, or else copy it out. fn provided_get<'tcx>( b: &mut Body<'_, '_, 'tcx>, @@ -842,11 +842,11 @@ fn provided_get<'tcx>( true => "bufTryGet", false => "bufGet", }; - Some(Expr::rt(f, values)) + Some(Expr::rs(f, values)) } /// `Buf`'s method `name` for `ty`, taking the buffer as a `&mut` to it is: through the -/// `rt.Place` of one JS copies for a `&self` method. +/// `rs.Place` of one JS copies for a `&self` method. fn buf_method_mut<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, ty: Ty<'tcx>, name: &str) -> Option { let f = buf_method(b, call, ty, name)?; if !b.t.needs_place(ty) || matches!(name, "advance" | "copy_to_slice" | "copy_to_bytes") { @@ -854,7 +854,7 @@ fn buf_method_mut<'tcx>(b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, ty: Ty<'t } let param = crate::ts::Param { name: "p".into(), - ty: Some(crate::ts::Type::Rt("Place", vec![b.t.ty(ty, call.span)])), + ty: Some(crate::ts::Type::Rs("Place", vec![b.t.ty(ty, call.span)])), }; Some(Expr::Lambda( vec![param], @@ -898,7 +898,7 @@ fn rand<'tcx>( ) -> Option { let tcx = b.t.tcx; if tcx.def_kind(call.def_id) == DefKind::Fn && matches!(name, "rng" | "thread_rng") { - return Some(Expr::rt("randRng", vec![])); + return Some(Expr::rs("randRng", vec![])); } if !matches!(owner, "Rng" | "RngExt") || b.t.std_of(targ(call.args, 0).peel_refs()) != Some(Std::ThreadRng) { return None; @@ -908,11 +908,11 @@ fn rand<'tcx>( let ty = targ(call.args, 1); let width = |int: Int| (Expr::lit(int.bits.to_string()), Expr::lit(int.signed.to_string())); Some(match name { - "random" if ty.is_bool() => Expr::rt("randBool", vec![]), + "random" if ty.is_bool() => Expr::rs("randBool", vec![]), "random" => { let int = Int::of(ty)?; let (bits, signed) = width(int); - Expr::As(Box::new(Expr::rt("randInt", vec![bits, signed])), int.ty()) + Expr::As(Box::new(Expr::rs("randInt", vec![bits, signed])), int.ty()) } "random_range" => { let int = Int::of(ty)?; @@ -922,12 +922,12 @@ fn rand<'tcx>( Std::Range => { let range = b.spill(range, "range", out); let (start, end) = (range.clone().member("start"), range.member("end")); - Expr::rt("randRange", vec![start, end, bits, signed]) + Expr::rs("randRange", vec![start, end, bits, signed]) } - Std::RangeTo => Expr::rt("randRange", vec![int.lit(0), range.member("end"), bits, signed]), - Std::RangeInclusive => Expr::rt("randRangeInclusive", vec![range, bits, signed]), + Std::RangeTo => Expr::rs("randRange", vec![int.lit(0), range.member("end"), bits, signed]), + Std::RangeInclusive => Expr::rs("randRangeInclusive", vec![range, bits, signed]), // `rand` samples `..=b` only of unsigned integers. - Std::RangeToInclusive => Expr::rt("randRangeToInclusive", vec![range.member("end"), bits]), + Std::RangeToInclusive => Expr::rs("randRangeToInclusive", vec![range.member("end"), bits]), _ => return None, }; Expr::As(Box::new(value), int.ty()) diff --git a/ts/src/lower/task.rs b/ts/src/lower/task.rs index 6cfa025b6..21b53a4fd 100644 --- a/ts/src/lower/task.rs +++ b/ts/src/lower/task.rs @@ -1,4 +1,4 @@ -//! The standard library's ownership and async types, as `rt/task.ts` gives them: `Arc`, +//! The standard library's ownership and async types, as `rs/task.ts` gives them: `Arc`, //! `Rc`, `Weak`, `Mutex`, atomics, `Waker`, `Context`, `Poll`, `Pin`, and std's futures. use rustc_abi::VariantIdx; @@ -13,7 +13,7 @@ use super::num::{self, Int, Operand}; use crate::ts::{Expr, Key, Param, Stmt}; impl<'tcx> Translator<'_, 'tcx> { - /// `Future::Output` of `ty`, if it is a `dyn Future`, whose JS value is an `rt.Future`. + /// `Future::Output` of `ty`, if it is a `dyn Future`, whose JS value is an `rs.Future`. pub fn dyn_future(&self, ty: Ty<'tcx>) -> Option> { let ty::Dynamic(preds, ..) = ty.kind() else { return None; @@ -42,7 +42,7 @@ impl<'tcx> Translator<'_, 'tcx> { impl<'tcx> Body<'_, '_, 'tcx> { /// `value`, a `from` coerced to `to`, which points at a `dyn Future` through - /// references, boxes, and pins, whose JS value is what they point at, or an `rt.Place` + /// references, boxes, and pins, whose JS value is what they point at, or an `rs.Place` /// of it for a `&mut` to a reference. pub fn dyn_future(&mut self, from: Ty<'tcx>, to: Ty<'tcx>, value: Expr, span: Span) -> Expr { let tcx = self.t.tcx; @@ -68,14 +68,14 @@ impl<'tcx> Body<'_, '_, 'tcx> { self.future_object(pointee, value, borrowed, dropped, span) } - /// `value`, a `from` that is a future, as an `rt.Future`: itself if it is one already, - /// and else an `rt.DynFuture` over its `Future` impl, which drops it with itself unless + /// `value`, a `from` that is a future, as an `rs.Future`: itself if it is one already, + /// and else an `rs.DynFuture` over its `Future` impl, which drops it with itself unless /// `borrowed`. A borrowed one that is `dropped` must not drop what it borrows. pub fn future_object(&mut self, from: Ty<'tcx>, value: Expr, borrowed: bool, dropped: bool, span: Span) -> Expr { let tcx = self.t.tcx; let object = match from.kind() { ty::Dynamic(..) | ty::Coroutine(..) => true, - // What a reference or a box points at, which its JS value is, or an `rt.Place` of. + // What a reference or a box points at, which its JS value is, or an `rs.Place` of. ty::Ref(_, inner, _) => { let value = self.t.pointee_value(from, value); return self.future_object(*inner, value, true, dropped, span); @@ -92,13 +92,13 @@ impl<'tcx> Body<'_, '_, 'tcx> { if object { return match borrowed && dropped { true => Expr::New( - Box::new(Expr::Rt("DynFuture".into())), - vec![value, Expr::Rt("futurePoll".into())], + Box::new(Expr::Rs("DynFuture".into())), + vec![value, Expr::Rs("futurePoll".into())], ), false => value, }; } - // What `Future::poll` takes would be an `rt.Place`, which the box doesn't have. + // What `Future::poll` takes would be an `rs.Place`, which the box doesn't have. if self.t.needs_place(from) { return self.err(span, format!("a `dyn Future` of `{from}`, which JS copies")); } @@ -113,7 +113,7 @@ impl<'tcx> Body<'_, '_, 'tcx> { if !borrowed { args.extend(self.t.drop_fn(from, span)); } - Expr::New(Box::new(Expr::Rt("DynFuture".into())), args) + Expr::New(Box::new(Expr::Rs("DynFuture".into())), args) } } @@ -137,16 +137,16 @@ pub fn call<'tcx>( // A clone of a reference is that reference, not a clone of what it points at. let owned_std = self_std.filter(|_| self_ty.is_some_and(|t| !t.is_ref())); let e = match (owner, name) { - ("Arc" | "Rc", "new") => Expr::New(Box::new(Expr::Rt("Arc".into())), args), - ("Arc" | "Rc", "new_cyclic") => Expr::rt("arcNewCyclic", args), + ("Arc" | "Rc", "new") => Expr::New(Box::new(Expr::Rs("Arc".into())), args), + ("Arc" | "Rc", "new_cyclic") => Expr::rs("arcNewCyclic", args), // JS erases the pin. - ("Arc" | "Rc", "pin") => Expr::New(Box::new(Expr::Rt("Arc".into())), args), + ("Arc" | "Rc", "pin") => Expr::New(Box::new(Expr::Rs("Arc".into())), args), // The object of one of a trait object, which every pointer to it shares. A `dyn Any`'s // may hold a copy of a value JS copies, which `Arc::downcast` would not see written. ("Arc" | "Rc", "get_mut") if call.args.type_at(0).is_trait() && !super::dynamic::is_any_object(tcx, call.args.type_at(0)) => { - Expr::rt("arcGetMut", args) + Expr::rs("arcGetMut", args) } // A `&mut` to the value, which is where it is for one JS copies. `make_mut` takes the // `Arc`'s place, which it may point at a new `Arc` of a clone, cloned as a box of a @@ -158,7 +158,7 @@ pub fn call<'tcx>( let value = call.args.type_at(0); let place = if b.t.needs_place(value) { "Place" } else { "" }; match name { - "get_mut" => Expr::rt(format!("arcGetMut{place}"), args), + "get_mut" => Expr::rs(format!("arcGetMut{place}"), args), _ => { let cloned = shared_box(tcx, value).unwrap_or(value); let clone = super::collections::clone_fn(b, cloned, call.span); @@ -170,7 +170,7 @@ pub fn call<'tcx>( // share it: a new object where pointers to it compare. let moved = b.t.held_addressed(value).then(|| b.t.shim(value, call.span)).flatten(); let values = args.into_iter().chain([clone]).chain(droppers).chain(moved).collect(); - Expr::rt(format!("arcMakeMut{place}"), values) + Expr::rs(format!("arcMakeMut{place}"), values) } } } @@ -184,7 +184,7 @@ pub fn call<'tcx>( && matches!(to.type_at(0).kind(), ty::Slice(e) if matches!(e.kind(), ty::Uint(ty::UintTy::U8))) && from.type_at(0).is_str() => { - Expr::rt("arcStrBytes", args) + Expr::rs("arcStrBytes", args) } // An `Arc` of a slice or text, of the box `From` makes of the same value, but for the // `Arc` itself. @@ -196,7 +196,7 @@ pub fn call<'tcx>( && let Some(boxed) = shared_box(tcx, arc.type_at(0)) => { let value = b.convert(first(args), from.expect_ty(), boxed, call.span, out); - Expr::New(Box::new(Expr::Rt("Arc".into())), vec![value]) + Expr::New(Box::new(Expr::Rs("Arc".into())), vec![value]) } // A waker, or its raw parts, over the crate's `Wake` impl. ("From", "from") @@ -206,54 +206,54 @@ pub fn call<'tcx>( { arc_waker(b, from.expect_ty(), first(args), to == Std::RawWaker, call.span) } - ("Waker", "noop") => Expr::Rt("NOOP_WAKER".into()), - ("Waker", "new") => Expr::New(Box::new(Expr::Rt("VTableWaker".into())), args), - ("Waker", "from_raw") => Expr::rt("wakerFromRaw", args), + ("Waker", "noop") => Expr::Rs("NOOP_WAKER".into()), + ("Waker", "new") => Expr::New(Box::new(Expr::Rs("VTableWaker".into())), args), + ("Waker", "from_raw") => Expr::rs("wakerFromRaw", args), ("RawWaker", "new") => { let [data, vtable] = two(args); raw_waker(data, vtable) } - ("RawWakerVTable", "new") => Expr::rt("wakerVTable", args), + ("RawWakerVTable", "new") => Expr::rs("wakerVTable", args), ("AsRef", "as_ref") if self_std == Some(Std::Arc) => first(args).member("value"), - ("Arc" | "Rc", "downgrade") | ("Weak", "new") => Expr::New(Box::new(Expr::Rt("Weak".into())), args), + ("Arc" | "Rc", "downgrade") | ("Weak", "new") => Expr::New(Box::new(Expr::Rs("Weak".into())), args), // The value of the last strong one, which its count says, and else its `None`. ("Arc" | "Rc", "into_inner") => { let none = b.t.none_arg(call.args.type_at(0)); - Expr::rt("arcIntoInner", args.into_iter().chain(none).collect()) + Expr::rs("arcIntoInner", args.into_iter().chain(none).collect()) } ("Arc" | "Rc", "strong_count") => first(args).member("strong"), ("Arc" | "Rc", "weak_count") => first(args).member("weak"), // Two `Arc`s of trait objects, or of structs of them, are views of the `Arc`s they // were made from. ("Arc" | "Rc", "ptr_eq") if self_ty.is_some_and(|t| super::dynamic::unsized_object(tcx, t)) => { - Expr::rt("arcPtrEq", args) + Expr::rs("arcPtrEq", args) } ("Arc" | "Rc", "ptr_eq") => { let [l, r] = two(args); l.binary("===", r) } - ("Weak", "upgrade") => Expr::rt("weakUpgrade", args), + ("Weak", "upgrade") => Expr::rs("weakUpgrade", args), ("Weak", "strong_count") => first(args).member("arc").member("strong"), - ("Weak", "weak_count") => Expr::rt("weakWeakCount", args), + ("Weak", "weak_count") => Expr::rs("weakWeakCount", args), ("Weak", "ptr_eq") if self_ty.is_some_and(|t| super::dynamic::unsized_object(tcx, t)) => { let [l, r] = two(args); - Expr::rt("arcPtrEq", vec![l.member("arc"), r.member("arc")]) + Expr::rs("arcPtrEq", vec![l.member("arc"), r.member("arc")]) } ("Weak", "ptr_eq") => { let [l, r] = two(args); l.member("arc").binary("===", r.member("arc")) } - ("Clone", "clone") if owned_std == Some(Std::Arc) => Expr::rt("arcClone", args), - ("Clone", "clone") if owned_std == Some(Std::Weak) => Expr::rt("weakClone", args), + ("Clone", "clone") if owned_std == Some(Std::Arc) => Expr::rs("arcClone", args), + ("Clone", "clone") if owned_std == Some(Std::Weak) => Expr::rs("weakClone", args), // A `RefCell`'s clone borrows it, and a one-time cell's clones what it holds, if anything. ("Clone", "clone") if matches!(owned_std, Some(Std::RefCell | Std::OnceCell | Std::OnceLock)) => { let inner = held(self_ty); let clone = super::collections::clone_fn(b, inner, call.span); match owned_std { - Some(Std::RefCell) => Expr::rt("refCellClone", vec![first(args), clone]), + Some(Std::RefCell) => Expr::rs("refCellClone", vec![first(args), clone]), _ => { let none = b.t.none_arg(inner); - Expr::rt("onceClone", [first(args), clone].into_iter().chain(none).collect()) + Expr::rs("onceClone", [first(args), clone].into_iter().chain(none).collect()) } } } @@ -263,11 +263,11 @@ pub fn call<'tcx>( let clone = (clone != Expr::undefined()).then_some(clone); first(args).member("clone").call(clone.into_iter().collect()) } - ("Clone", "clone") if owned_std == Some(Std::Pending) => Expr::Rt("NEVER".into()), + ("Clone", "clone") if owned_std == Some(Std::Pending) => Expr::Rs("NEVER".into()), // A waker is the executor's, whose `clone` is its own. ("Clone", "clone") if owned_std == Some(Std::Waker) => first(args).member("clone").call(vec![]), // A reference is the object it points at, which its own `Deref` gives: read out of a - // `&mut` that is an `rt.Place`, whose place `DerefMut` lends on. + // `&mut` that is an `rs.Place`, whose place `DerefMut` lends on. ("Deref", "deref") if let Some(ty) = self_ty.filter(|t| t.is_ref()) => b.t.pointee_value(ty, first(args)), ("DerefMut", "deref_mut") if self_ty.is_some_and(|t| t.is_ref()) => first(args), ("Deref", "deref") | ("DerefMut", "deref_mut") => match self_std { @@ -285,10 +285,10 @@ pub fn call<'tcx>( }, _ => return Err(args), }, - ("Mutex", "new") => Expr::New(Box::new(Expr::Rt("Mutex".into())), args), + ("Mutex", "new") => Expr::New(Box::new(Expr::Rs("Mutex".into())), args), // The mutex is its own guard, and a panic aborts, so nothing poisons it. - ("Mutex", "lock") => Expr::result(true, Expr::rt("mutexLock", args)), - ("Mutex", "try_lock") => Expr::rt("mutexTryLock", args), + ("Mutex", "lock") => Expr::result(true, Expr::rs("mutexLock", args)), + ("Mutex", "try_lock") => Expr::rs("mutexTryLock", args), // What it holds, lent as where it is where JS copies it. ("Mutex" | "RwLock", "get_mut") => Expr::result(true, lend_value(b, call, first(args))), ("RefCell", "get_mut") => lend_value(b, call, first(args)), @@ -298,18 +298,18 @@ pub fn call<'tcx>( ("PoisonError", "into_inner" | "get_ref" | "get_mut") => first(args), // Mapped rather than lowered from core's MIR, so one of a lock unwraps its guard in place. ("Result", "unwrap_or_else") if call.args.types().nth(1).and_then(std_of) == Some(Std::PoisonError) => { - Expr::rt("resultUnwrapOrElse", args) + Expr::rs("resultUnwrapOrElse", args) } // A cell, or a lock, is its own guard. - ("RefCell" | "RwLock", "new") => Expr::New(Box::new(Expr::Rt("RefCell".into())), args), - ("RefCell", "borrow") => Expr::rt("refCellBorrow", args), - ("RefCell", "borrow_mut") => Expr::rt("refCellBorrowMut", args), - ("RefCell", "try_borrow") => Expr::rt("refCellTryBorrow", args), - ("RefCell", "try_borrow_mut") => Expr::rt("refCellTryBorrowMut", args), + ("RefCell" | "RwLock", "new") => Expr::New(Box::new(Expr::Rs("RefCell".into())), args), + ("RefCell", "borrow") => Expr::rs("refCellBorrow", args), + ("RefCell", "borrow_mut") => Expr::rs("refCellBorrowMut", args), + ("RefCell", "try_borrow") => Expr::rs("refCellTryBorrow", args), + ("RefCell", "try_borrow_mut") => Expr::rs("refCellTryBorrowMut", args), // A leaked guard lends what it holds and keeps its borrow until `undo_leak`. ("Ref", "leak") => first(args).member("value"), ("RefMut", "leak") => lend_value(b, call, first(args)), - ("RefCell", "undo_leak") => lend_value(b, call, Expr::rt("refCellUndoLeak", args)), + ("RefCell", "undo_leak") => lend_value(b, call, Expr::rs("refCellUndoLeak", args)), ("Ref" | "RwLockReadGuard" | "MappedRwLockReadGuard", "map" | "filter_map" | "try_map" | "map_split") => { guard_map(b, call, name, "ref", args, out) } @@ -317,12 +317,12 @@ pub fn call<'tcx>( guard_map(b, call, name, "refMut", args, out) } ("MutexGuard" | "MappedMutexGuard", "map" | "filter_map") => guard_map(b, call, name, "mutex", args, out), - ("Ref", "clone") => Expr::rt("refClone", args), - ("RefCell", "replace") => Expr::rt("refCellReplace", args), + ("Ref", "clone") => Expr::rs("refClone", args), + ("RefCell", "replace") => Expr::rs("refCellReplace", args), // With the value's place where JS would copy it. ("RefCell", "replace_with") => { let copied = b.t.needs_place(call.args.type_at(0)); - Expr::rt( + Expr::rs( "refCellReplaceWith", super::iter::tail(args, vec![Expr::lit(copied.to_string())]), ) @@ -331,14 +331,14 @@ pub fn call<'tcx>( let ty = call.args.type_at(0); let f = super::collections::trait_fn(tcx, "Default", "default"); let value = b.call_def(f, tcx.mk_args(&[ty.into()]), Vec::new(), call.span, out); - Expr::rt("refCellReplace", vec![first(args), value]) + Expr::rs("refCellReplace", vec![first(args), value]) } // A panic aborts, so nothing poisons it. - ("RwLock", "read") => Expr::result(true, Expr::rt("rwLockRead", args)), - ("RwLock", "write") => Expr::result(true, Expr::rt("rwLockWrite", args)), - ("RwLock", "try_read") => Expr::rt("rwLockTryRead", args), - ("RwLock", "try_write") => Expr::rt("rwLockTryWrite", args), - ("RwLockWriteGuard", "downgrade") => Expr::rt("rwLockDowngrade", args), + ("RwLock", "read") => Expr::result(true, Expr::rs("rwLockRead", args)), + ("RwLock", "write") => Expr::result(true, Expr::rs("rwLockWrite", args)), + ("RwLock", "try_read") => Expr::rs("rwLockTryRead", args), + ("RwLock", "try_write") => Expr::rs("rwLockTryWrite", args), + ("RwLockWriteGuard", "downgrade") => Expr::rs("rwLockDowngrade", args), ("Cell", _) => return cell(b, call, name, args, out), // A thread-local's value, which is never destroyed. ("LocalKey", "with") => { @@ -354,21 +354,21 @@ pub fn call<'tcx>( let Some(droppers) = b.t.droppers([call.args.type_at(0)], call.span) else { return Ok(Some(Expr::undefined())); }; - Expr::rt("localKeyRefCellSet", args.into_iter().chain(droppers).collect()) + Expr::rs("localKeyRefCellSet", args.into_iter().chain(droppers).collect()) } // With the value's place where JS would copy it. ("LocalKey", "with_borrow_mut") => match b.t.needs_place(call.args.type_at(0)) { - true => Expr::rt("localKeyWithBorrowMutPlace", args), - false => Expr::rt("localKeyWithBorrowMut", args), + true => Expr::rs("localKeyWithBorrowMutPlace", args), + false => Expr::rs("localKeyWithBorrowMut", args), }, - // With the `Option`'s `None` where it is `rt.None`. + // With the `Option`'s `None` where it is `rs.None`. ("LocalKey", "initialize_with") => { let none = b.t.none_arg(call.args.type_at(0)); - Expr::rt("localKeyInitializeWith", args.into_iter().chain(none).collect()) + Expr::rs("localKeyInitializeWith", args.into_iter().chain(none).collect()) } ("Atomic", _) => return atomic(b, call, name, args), ("LazyCell" | "LazyLock", "force") => first(args).member("force").call(vec![]), - ("LazyCell" | "LazyLock", "new") => Expr::New(Box::new(Expr::Rt(owner.into())), args), + ("LazyCell" | "LazyLock", "new") => Expr::New(Box::new(Expr::Rs(owner.into())), args), ("OnceCell" | "OnceLock", _) => return once(b, call, name, args), // A `OnceLock` of `true`, which nothing poisons, as a panic aborts. ("Once", "new") => once_unrun(), @@ -378,14 +378,14 @@ pub fn call<'tcx>( let Some(droppers) = b.t.droppers([call.args.type_at(0)], call.span) else { return Ok(Some(Expr::undefined())); }; - Expr::rt("onceCall", args.into_iter().chain(droppers).collect()) + Expr::rs("onceCall", args.into_iter().chain(droppers).collect()) } - ("OnceState", "is_poisoned") => Expr::rt("onceIsPoisoned", args), + ("OnceState", "is_poisoned") => Expr::rs("onceIsPoisoned", args), ("From", "from") if matches!(self_std, Some(Std::OnceCell | Std::OnceLock)) => { let cell = self_ty.expect("a `From` impl's type"); - Expr::New(Box::new(Expr::Rt(once_class(b, cell).into())), args) + Expr::New(Box::new(Expr::Rs(once_class(b, cell).into())), args) } - ("atomic", "fence" | "compiler_fence") => Expr::rt("fence", args), + ("atomic", "fence" | "compiler_fence") => Expr::rs("fence", args), // A panic aborts, so a thread is panicking only while its hook runs. (_, "panicking") if library::std_path(tcx, call.def_id) @@ -393,13 +393,13 @@ pub fn call<'tcx>( .is_some_and(|m| m == "thread") => { match b.t.hooked { - true => Expr::rt("panicking", Vec::new()), + true => Expr::rs("panicking", Vec::new()), false => Expr::lit("false"), } } ("Waker", "wake_by_ref") => first(args).member("wakeByRef").call(vec![]), ("Waker", "wake") => first(args).member("wake").call(vec![]), - ("Waker", "will_wake") => Expr::rt("willWake", args), + ("Waker", "will_wake") => Expr::rs("willWake", args), // Its identity: what a pointer to `()` stands for, whatever the waker's JS type. ("Waker", "data") => { let ty = b.t.sig(call.def_id, call.args).output(); @@ -410,16 +410,16 @@ pub fn call<'tcx>( ("poll_fn", "poll_fn") => { let dropper = b.t.drop_fn(call.args.type_at(1), call.span); Expr::New( - Box::new(Expr::Rt("PollFn".into())), + Box::new(Expr::Rs("PollFn".into())), args.into_iter().chain(dropper).collect(), ) } - ("pending", "pending") => Expr::Rt("NEVER".into()), + ("pending", "pending") => Expr::Rs("NEVER".into()), // With what drops its value, unless a poll takes it first. ("ready", "ready") => { let dropper = b.t.drop_fn(call.args.type_at(0), call.span); Expr::New( - Box::new(Expr::Rt("Ready".into())), + Box::new(Expr::Rs("Ready".into())), args.into_iter().chain(dropper).collect(), ) } @@ -427,13 +427,13 @@ pub fn call<'tcx>( // A box's JS value is what it holds. ("Box", "pin") => first(args), ("Future", "poll") => match self_ty.map(Ty::kind) { - // A `&mut` polls what it points at, whose pinned `&mut` is an `rt.Place` of it. + // A `&mut` polls what it points at, whose pinned `&mut` is an `rs.Place` of it. Some(ty::Ref(_, inner, _)) => { let [future, cx] = two(args); let args = vec![future.member("v"), cx]; b.call_def(call.def_id, tcx.mk_args(&[(*inner).into()]), args, call.span, out) } - // std's futures and a `dyn Future` are `rt.Future`s, which poll themselves. + // std's futures and a `dyn Future` are `rs.Future`s, which poll themselves. _ if matches!(self_std, Some(Std::PollFn | Std::Pending | Std::Ready)) || self_ty.is_some_and(|ty| b.t.dyn_future(ty).is_some()) => { @@ -476,7 +476,7 @@ pub fn call<'tcx>( Ok(Some(e)) } -/// An `Atomic` method: an `rt.Atomic`'s, with its orderings, which the runtime checks. +/// An `Atomic` method: an `rs.Atomic`'s, with its orderings, which the runtime checks. /// `Ok(None)` refuses it. fn atomic<'tcx>( b: &mut Body<'_, '_, 'tcx>, @@ -493,10 +493,10 @@ fn atomic<'tcx>( let int = Int::of(ty); let fetch = |f: Expr, mut args: Vec| { args.insert(1, f); - Expr::rt("atomicFetch", args) + Expr::rs("atomicFetch", args) }; // A pointer compares as `ptr::eq` does only where it is the object it points at, or - // a slice of the bytes it points at, which `rt.byteSliceSame` compares. + // a slice of the bytes it points at, which `rs.byteSliceSame` compares. let generics = tcx.generics_of(imp).count(); let atomic = tcx .type_of(imp) @@ -526,14 +526,14 @@ fn atomic<'tcx>( // pointers to bytes. let exchange = |f: &str, mut args: Vec| { args.extend(int.filter(|int| int.big()).map(|int| int.func("eq"))); - args.extend(bytes.then(|| Expr::Rt("byteSliceSame".into()))); - Expr::rt(f, args) + args.extend(bytes.then(|| Expr::Rs("byteSliceSame".into()))); + Expr::rs(f, args) }; let e = match name { - "new" => Expr::New(Box::new(Expr::Rt("Atomic".into())), args), - "load" => Expr::rt("atomicLoad", args), - "store" => Expr::rt("atomicStore", args), - "swap" => Expr::rt("atomicSwap", args), + "new" => Expr::New(Box::new(Expr::Rs("Atomic".into())), args), + "load" => Expr::rs("atomicLoad", args), + "store" => Expr::rs("atomicStore", args), + "swap" => Expr::rs("atomicSwap", args), "into_inner" => first(args).member("v"), // The atomic is the place that holds its value. "get_mut" => first(args), @@ -543,7 +543,7 @@ fn atomic<'tcx>( "fetch_max" | "fetch_min" if let Some(int) = int => { let f = match int.big() { true => int.func(&name[6..]), - false => Expr::Rt(name[6..].into()), + false => Expr::Rs(name[6..].into()), }; fetch(f, args) } @@ -582,24 +582,24 @@ fn cell<'tcx>( let tcx = b.t.tcx; let ty = call.args.type_at(0); let e = match name { - "new" => Expr::New(Box::new(Expr::Rt("Cell".into())), args), + "new" => Expr::New(Box::new(Expr::Rs("Cell".into())), args), "get" => b.t.copied(first(args).member("v"), ty, call.span), "into_inner" => first(args).member("v"), - // As its `UnsafeCell`'s `get` and `get_mut`, the same `rt.Cell`. + // As its `UnsafeCell`'s `get` and `get_mut`, the same `rs.Cell`. "as_ptr" | "get_mut" => return Err(args), - "replace" => Expr::rt("cellReplace", args), - "update" => Expr::rt("cellUpdate", args), + "replace" => Expr::rs("cellReplace", args), + "update" => Expr::rs("cellUpdate", args), // With what drops the value it replaces. "set" => { let Some(droppers) = b.t.droppers([ty], call.span) else { return Ok(Some(Expr::undefined())); }; - Expr::rt("cellSet", args.into_iter().chain(droppers).collect()) + Expr::rs("cellSet", args.into_iter().chain(droppers).collect()) } "take" => { let f = super::collections::trait_fn(tcx, "Default", "default"); let value = b.call_def(f, tcx.mk_args(&[ty.into()]), Vec::new(), call.span, out); - Expr::rt("cellReplace", vec![first(args), value]) + Expr::rs("cellReplace", vec![first(args), value]) } _ => return Ok(None), }; @@ -607,7 +607,7 @@ fn cell<'tcx>( } /// A `OnceCell` or `OnceLock` method: its `Option`, `v`, read or written as std -/// does, with that `Option`'s `None` where it is `rt.None`. `Ok(None)` refuses it. +/// does, with that `Option`'s `None` where it is `rs.None`. `Ok(None)` refuses it. fn once<'tcx>( b: &mut Body<'_, '_, 'tcx>, call: &Call<'tcx>, @@ -626,10 +626,10 @@ fn once<'tcx>( let e = match name { "new" => once_new(b, cell), "get" | "into_inner" => first(args).member("v"), - "take" => Expr::rt("onceTake", args.into_iter().chain(none).collect()), - "set" => Expr::rt("onceSet", args.into_iter().chain(none).collect()), + "take" => Expr::rs("onceTake", args.into_iter().chain(none).collect()), + "set" => Expr::rs("onceSet", args.into_iter().chain(none).collect()), // The place of what it holds where JS copies that, which is the cell's own. - "get_mut" if b.t.needs_place(inner) => Expr::rt("optionAsMut", args.into_iter().chain(none).collect()), + "get_mut" if b.t.needs_place(inner) => Expr::rs("optionAsMut", args.into_iter().chain(none).collect()), "get_mut" => first(args).member("v"), // With what drops `f`, as `discards` says, uncalled if the cell is set. "get_or_init" | "get_or_try_init" => { @@ -643,14 +643,14 @@ fn once<'tcx>( "get_or_init" => "onceGetOrInit", _ => "onceGetOrTryInit", }; - Expr::rt(f, args.into_iter().chain(droppers).chain(none).collect()) + Expr::rs(f, args.into_iter().chain(droppers).chain(none).collect()) } _ => return Ok(None), }; Ok(Some(e)) } -/// A `Box`, if `pointee` is a slice or text, whose value an `rt.Arc` of it holds. +/// A `Box`, if `pointee` is a slice or text, whose value an `rs.Arc` of it holds. pub fn shared_box<'tcx>(tcx: ty::TyCtxt<'tcx>, pointee: Ty<'tcx>) -> Option> { matches!(pointee.kind(), ty::Slice(_) | ty::Str).then(|| Ty::new_box(tcx, pointee)) } @@ -686,18 +686,18 @@ fn guard_map<'tcx>( let mut tys = call.args.types(); let held = tys.next().expect("a guarded type"); let lent = match exclusive && b.t.needs_place(held) { - true => Expr::rt("valuePlace", vec![guard.clone()]), + true => Expr::rs("valuePlace", vec![guard.clone()]), false => guard.clone().member("value"), }; let lent = f.call(vec![lent]); - // What the guard holds of a part: a `[u8; N]` as the array its `rt.ByteSlice` views, and + // What the guard holds of a part: a `[u8; N]` as the array its `rs.ByteSlice` views, and // for an exclusive one, where the part is: the place of one JS copies, and an object // itself, which a whole value is written into in place. let converts = |b: &Body<'_, '_, 'tcx>, part: Ty<'tcx>| super::byte_array(part) || exclusive && !b.t.needs_place(part); let at = |b: &mut Body<'_, '_, 'tcx>, part: Ty<'tcx>, value: Expr| { let value = match super::byte_array(part) { - true => Expr::rt("byteSliceView", vec![value]), + true => Expr::rs("byteSliceView", vec![value]), false => value, }; if !converts(b, part) || !exclusive { @@ -708,7 +708,7 @@ fn guard_map<'tcx>( format!("a mapped guard of `{part}`, which JS can't write in place"), ) } else { - Expr::rt("partPlace", vec![value]) + Expr::rs("partPlace", vec![value]) } }; let part = tys.next().expect("a part's type"); @@ -716,9 +716,9 @@ fn guard_map<'tcx>( match name { "map" => { let at = at(b, part, lent); - Expr::rt(f("Map"), vec![guard, at]) + Expr::rs(f("Map"), vec![guard, at]) } - "filter_map" if !converts(b, part) => Expr::rt(f("FilterMap"), vec![guard, lent]), + "filter_map" if !converts(b, part) => Expr::rs(f("FilterMap"), vec![guard, lent]), "filter_map" => { let lent = b.spill(lent, "part", out); let some = at(b, part, lent.clone()); @@ -727,9 +727,9 @@ fn guard_map<'tcx>( Box::new(Expr::undefined()), Box::new(some), ); - Expr::rt(f("FilterMap"), vec![guard, at]) + Expr::rs(f("FilterMap"), vec![guard, at]) } - "try_map" if !converts(b, part) => Expr::rt(f("TryMap"), vec![guard, lent]), + "try_map" if !converts(b, part) => Expr::rs(f("TryMap"), vec![guard, lent]), "try_map" => { let lent = b.spill(lent, "part", out); let some = at(b, part, lent.clone().member("value")); @@ -738,17 +738,17 @@ fn guard_map<'tcx>( Box::new(Expr::result(true, some)), Box::new(Expr::result(false, lent.member("error"))), ); - Expr::rt(f("TryMap"), vec![guard, at]) + Expr::rs(f("TryMap"), vec![guard, at]) } _ => { let other = tys.next().expect("the other part's type"); if !converts(b, part) && !converts(b, other) { - return Expr::rt(f("MapSplit"), vec![guard, lent]); + return Expr::rs(f("MapSplit"), vec![guard, lent]); } let pair = b.spill(lent, "parts", out); let a = at(b, part, pair.clone().index(Expr::lit("0"))); let other = at(b, other, pair.index(Expr::lit("1"))); - Expr::rt(f("MapSplit"), vec![guard, Expr::Array(vec![a, other])]) + Expr::rs(f("MapSplit"), vec![guard, Expr::Array(vec![a, other])]) } } } @@ -757,7 +757,7 @@ fn guard_map<'tcx>( /// `RefMut`, lends: its value, or where that is where JS copies it. fn lend_value<'tcx>(b: &Body<'_, '_, 'tcx>, call: &Call<'tcx>, holder: Expr) -> Expr { match b.t.needs_place(call.args.types().next().expect("a held type")) { - true => Expr::rt("valuePlace", vec![holder]), + true => Expr::rs("valuePlace", vec![holder]), false => holder.member("value"), } } @@ -768,14 +768,14 @@ pub fn once_new<'tcx>(b: &Body<'_, '_, 'tcx>, cell: Ty<'tcx>) -> Expr { unreachable!("a one-time cell is a struct") }; Expr::New( - Box::new(Expr::Rt(once_class(b, cell).into())), + Box::new(Expr::Rs(once_class(b, cell).into())), vec![b.t.none(args.type_at(0))], ) } -/// `Once::new()`: an `rt.OnceLock` holding nothing, as no function has run. +/// `Once::new()`: an `rs.OnceLock` holding nothing, as no function has run. pub fn once_unrun() -> Expr { - Expr::New(Box::new(Expr::Rt("OnceLock".into())), vec![Expr::undefined()]) + Expr::New(Box::new(Expr::Rs("OnceLock".into())), vec![Expr::undefined()]) } /// The runtime class of `cell`, a `OnceCell` or `OnceLock`. @@ -842,10 +842,10 @@ fn arc_waker<'tcx>(b: &mut Body<'_, '_, 'tcx>, arc: Ty<'tcx>, value: Expr, raw: { args.push(b.fn_value(by_ref, w, span)); } - Expr::rt(if raw { "arcRawWaker" } else { "arcWaker" }, args) + Expr::rs(if raw { "arcRawWaker" } else { "arcWaker" }, args) } -/// A `RawWaker` of `data` and `vtable`: an `rt.RawWaker`, under std's names. +/// A `RawWaker` of `data` and `vtable`: an `rs.RawWaker`, under std's names. pub fn raw_waker(data: Expr, vtable: Expr) -> Expr { Expr::Object(vec![ (Key::Name("data".into()), data), diff --git a/ts/src/lower/time.rs b/ts/src/lower/time.rs index 5c76fa3a9..3f9010f5d 100644 --- a/ts/src/lower/time.rs +++ b/ts/src/lower/time.rs @@ -1,4 +1,4 @@ -//! `std::time::Duration`, as `rt/time.ts` gives it: std's seconds and nanoseconds in an +//! `std::time::Duration`, as `rs/time.ts` gives it: std's seconds and nanoseconds in an //! object that never changes, so its arithmetic, overflow, and ordering are std's. use rustc_middle::ty::{self, Ty, ValTree}; @@ -76,7 +76,7 @@ pub fn call<'tcx>( ("Div", "div") if is(0) => "durationDiv", _ => return Err(args), }; - Ok(Some(Expr::rt(f, args))) + Ok(Some(Expr::rs(f, args))) } /// `Duration::ZERO`, which `Default` makes. diff --git a/ts/src/print.rs b/ts/src/print.rs index 0d74e6980..c66a73e33 100644 --- a/ts/src/print.rs +++ b/ts/src/print.rs @@ -31,7 +31,7 @@ pub fn module(program: &Program, module: &ModPath, items: &[&Item], path: &Path) indent: 0, tokens: Vec::new(), current: None, - uses_rt: false, + uses_rs: false, renames: HashMap::new(), aliases: Vec::new(), }; @@ -66,8 +66,8 @@ pub fn module(program: &Program, module: &ModPath, items: &[&Item], path: &Path) }; let mut header = format!("{HEADER}\n\n"); - if p.uses_rt { - writeln!(header, "import * as rt from \"{}\";", up(Path::new("rt.ts"))).unwrap(); + if p.uses_rs { + writeln!(header, "import * as rs from \"{}\";", up(Path::new("rs.ts"))).unwrap(); } let mut targets: Vec<&ModPath> = bindings.imports.keys().chain(bindings.namespaces.keys()).collect(); targets.sort(); @@ -101,7 +101,7 @@ pub fn module(program: &Program, module: &ModPath, items: &[&Item], path: &Path) ) .unwrap(); } - if p.uses_rt || !bindings.imports.is_empty() || !bindings.namespaces.is_empty() { + if p.uses_rs || !bindings.imports.is_empty() || !bindings.namespaces.is_empty() { header.push('\n'); } let offset = header.lines().count() as u32; @@ -170,7 +170,7 @@ impl Texts { indent: 0, tokens: Vec::new(), current: None, - uses_rt: false, + uses_rs: false, renames: HashMap::new(), aliases: Vec::new(), }; @@ -220,7 +220,7 @@ impl Bindings { let mut names = HashMap::new(); // What the module declares, with the runtime's binding. - let mut taken: HashSet = HashSet::from(["rt".to_string()]); + let mut taken: HashSet = HashSet::from(["rs".to_string()]); for (id, sym) in program.syms.iter().enumerate() { if sym.owner.is_none() && &sym.module == module { names.insert(id, sym.name.clone()); @@ -342,7 +342,7 @@ impl Refs { fn ty(&mut self, program: &Program, ty: &Type) { match ty { Type::Builtin(_) | Type::Param(_) | Type::StrLit(_) => {} - Type::Rt(_, args) => args.iter().for_each(|t| self.ty(program, t)), + Type::Rs(_, args) => args.iter().for_each(|t| self.ty(program, t)), Type::Sym(id, args) => { self.use_sym(program, *id, false); args.iter().for_each(|t| self.ty(program, t)); @@ -397,7 +397,7 @@ impl Refs { fn expr(&mut self, program: &Program, e: &Expr) { match e { - Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} Expr::Sym(id) => self.use_sym(program, *id, true), Expr::Array(es) => es.iter().for_each(|e| self.expr(program, e)), Expr::Object(props) => props.iter().for_each(|(_, e)| self.expr(program, e)), @@ -448,7 +448,7 @@ struct Printer<'p> { /// The Rust the node being printed maps to, which the text after a node inside it /// maps back to. current: Option, - uses_rt: bool, + uses_rs: bool, /// Locals of the function being printed renamed away from the module's bindings. renames: HashMap, /// Each function declared under an escaped name, and the name it is exported as. @@ -711,7 +711,7 @@ impl Printer<'_> { // The runtime's too, which printing may call anywhere. let referred: HashSet<&str> = (refs.used.keys()) .map(|id| self.bindings.names[id].split('.').next().unwrap()) - .chain(["rt"]) + .chain(["rs"]) .collect(); let mut taken: HashSet = locals.iter().cloned().collect(); taken.extend(referred.iter().map(|name| name.to_string())); @@ -930,9 +930,9 @@ impl Printer<'_> { let name = self.sym_name(*id); self.write(&name); } - Expr::Rt(name) => { - self.uses_rt = true; - self.write(&format!("rt.{name}")); + Expr::Rs(name) => { + self.uses_rs = true; + self.write(&format!("rs.{name}")); } Expr::Lit(text) => self.write(text), Expr::Str(s) => self.write("e(s)), @@ -1119,9 +1119,9 @@ impl Printer<'_> { fn ty(&mut self, ty: &Type) -> String { match ty { Type::Builtin(name) => name.to_string(), - Type::Rt(name, args) => { - self.uses_rt = true; - format!("rt.{name}{}", self.type_args(args)) + Type::Rs(name, args) => { + self.uses_rs = true; + format!("rs.{name}{}", self.type_args(args)) } Type::Sym(id, args) => format!("{}{}", self.sym_name(*id), self.type_args(args)), Type::Param(name) => name.clone(), @@ -1312,7 +1312,7 @@ fn collect_expr_locals(e: &Expr, out: &mut Vec) { collect_expr_locals(b, out); collect_expr_locals(c, out); } - Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} } } diff --git a/ts/src/program.rs b/ts/src/program.rs index 065e9abfd..202face44 100644 --- a/ts/src/program.rs +++ b/ts/src/program.rs @@ -14,24 +14,24 @@ use crate::ts::{self, FieldId, Function, Item, SymId}; /// The runtime every module imports helpers from, written beside the crate root: each /// file's path from there, and its text. pub const RUNTIME: &[(&str, &str)] = &[ - ("rt.ts", include_str!("../runtime/rt.ts")), - ("rt/alloc.ts", include_str!("../runtime/rt/alloc.ts")), - ("rt/ascii.ts", include_str!("../runtime/rt/ascii.ts")), - ("rt/bytes.ts", include_str!("../runtime/rt/bytes.ts")), - ("rt/char.ts", include_str!("../runtime/rt/char.ts")), - ("rt/collections.ts", include_str!("../runtime/rt/collections.ts")), - ("rt/float.ts", include_str!("../runtime/rt/float.ts")), - ("rt/hash.ts", include_str!("../runtime/rt/hash.ts")), - ("rt/hook.ts", include_str!("../runtime/rt/hook.ts")), - ("rt/int.ts", include_str!("../runtime/rt/int.ts")), - ("rt/iter.ts", include_str!("../runtime/rt/iter.ts")), - ("rt/location.ts", include_str!("../runtime/rt/location.ts")), - ("rt/rand.ts", include_str!("../runtime/rt/rand.ts")), - ("rt/sort.ts", include_str!("../runtime/rt/sort.ts")), - ("rt/str.ts", include_str!("../runtime/rt/str.ts")), - ("rt/task.ts", include_str!("../runtime/rt/task.ts")), - ("rt/time.ts", include_str!("../runtime/rt/time.ts")), - ("rt/unicode.ts", include_str!("../runtime/rt/unicode.ts")), + ("rs.ts", include_str!("../runtime/rs.ts")), + ("rs/alloc.ts", include_str!("../runtime/rs/alloc.ts")), + ("rs/ascii.ts", include_str!("../runtime/rs/ascii.ts")), + ("rs/bytes.ts", include_str!("../runtime/rs/bytes.ts")), + ("rs/char.ts", include_str!("../runtime/rs/char.ts")), + ("rs/collections.ts", include_str!("../runtime/rs/collections.ts")), + ("rs/float.ts", include_str!("../runtime/rs/float.ts")), + ("rs/hash.ts", include_str!("../runtime/rs/hash.ts")), + ("rs/hook.ts", include_str!("../runtime/rs/hook.ts")), + ("rs/int.ts", include_str!("../runtime/rs/int.ts")), + ("rs/iter.ts", include_str!("../runtime/rs/iter.ts")), + ("rs/location.ts", include_str!("../runtime/rs/location.ts")), + ("rs/rand.ts", include_str!("../runtime/rs/rand.ts")), + ("rs/sort.ts", include_str!("../runtime/rs/sort.ts")), + ("rs/str.ts", include_str!("../runtime/rs/str.ts")), + ("rs/task.ts", include_str!("../runtime/rs/task.ts")), + ("rs/time.ts", include_str!("../runtime/rs/time.ts")), + ("rs/unicode.ts", include_str!("../runtime/rs/unicode.ts")), ]; /// The first line of every generated file, which also marks it as safe to replace. @@ -361,7 +361,7 @@ impl Program { ids.sort_by(|&a, &b| self.syms[a].key().cmp(&self.syms[b].key())); // What a class already defines, and else the runtime's import binding. let defined: &[&str] = match &scope { - Scope::Module(_) => &["rt"], + Scope::Module(_) => &["rs"], Scope::Owner(_) => &["constructor", "prototype"], }; let mut named: HashMap> = @@ -510,9 +510,9 @@ impl Program { } if modules .keys() - .any(|module| module.first().is_some_and(|name| name == "rt")) + .any(|module| module.first().is_some_and(|name| name == "rs")) { - return Err("a top-level module named `rt` would replace the runtime, rt.ts and rt/".into()); + return Err("a top-level module named `rs` would replace the runtime, rs.ts and rs/".into()); } for (path, text) in RUNTIME { diff --git a/ts/src/ts.rs b/ts/src/ts.rs index 6a8857644..beb39fa32 100644 --- a/ts/src/ts.rs +++ b/ts/src/ts.rs @@ -28,8 +28,8 @@ pub enum Expr { This, /// A translated item, named at print time. Sym(SymId), - /// A runtime export: `rt.`. - Rt(String), + /// A runtime export: `rs.`. + Rs(String), /// Literal text, printed as is: `1`, `0x40`, `5n`, `true`, `undefined`. Lit(String), Str(String), @@ -47,7 +47,7 @@ pub enum Expr { Assign(Box, Box), Arrow(Vec, Type, Vec), /// An arrow function whose body is one expression, its return type inferred: - /// `(f: rt.Formatter) => rt.fmtPad(f, s)`. + /// `(f: rs.Formatter) => rs.fmtPad(f, s)`. Lambda(Vec, Box), /// `e as T`: a literal whose type TypeScript would widen, or an integer cast to /// another integer type with the same value. @@ -82,11 +82,11 @@ impl Expr { Self::Member(Box::new(self), Key::Name(name.into())) } - /// What `self` reads, if it is an `rt.Place` made here: `rt.place(() => read, set)`. + /// What `self` reads, if it is an `rs.Place` made here: `rs.place(() => read, set)`. pub fn place_read(&self) -> Option<&Expr> { let Self::Call(f, args) = self else { return None }; match (&**f, args.as_slice()) { - (Self::Rt(name), [Self::Lambda(params, read), _]) if name == "place" && params.is_empty() => Some(read), + (Self::Rs(name), [Self::Lambda(params, read), _]) if name == "place" && params.is_empty() => Some(read), _ => None, } } @@ -103,29 +103,29 @@ impl Expr { Self::Call(Box::new(self), args) } - /// A call of the runtime function `rt.`. - pub fn rt(name: impl Into, args: Vec) -> Self { - Self::Rt(name.into()).call(args) + /// A call of the runtime function `rs.`. + pub fn rs(name: impl Into, args: Vec) -> Self { + Self::Rs(name.into()).call(args) } - /// `rt.Ok(value)`, or `rt.Err(value)` if not `ok`: for `undefined`, `rt.OK` or `rt.ERR`, + /// `rs.Ok(value)`, or `rs.Err(value)` if not `ok`: for `undefined`, `rs.OK` or `rs.ERR`, /// one object every evaluation shares, since nothing writes into a result in place and /// `undefined` holds nothing to write into. pub fn result(ok: bool, value: Expr) -> Self { let unit = matches!(&value, Self::Lit(text) if text == "undefined"); match (ok, unit) { - (true, true) => Self::Rt("OK".into()), - (false, true) => Self::Rt("ERR".into()), - (true, false) => Self::rt("Ok", vec![value]), - (false, false) => Self::rt("Err", vec![value]), + (true, true) => Self::Rs("OK".into()), + (false, true) => Self::Rs("ERR".into()), + (true, false) => Self::rs("Ok", vec![value]), + (false, false) => Self::rs("Err", vec![value]), } } - /// The runtime function `name` of what `of` names: `rt.u8Add` for `("u8", "add")`. - pub fn rt_of(of: &str, name: &str) -> Self { + /// The runtime function `name` of what `of` names: `rs.u8Add` for `("u8", "add")`. + pub fn rs_of(of: &str, name: &str) -> Self { let mut chars = name.chars(); let first = chars.next().map(|c| c.to_ascii_uppercase()).into_iter(); - Self::Rt(format!("{of}{}{}", first.collect::(), chars.as_str())) + Self::Rs(format!("{of}{}{}", first.collect::(), chars.as_str())) } pub fn binary(self, op: &'static str, rhs: Expr) -> Self { @@ -154,18 +154,18 @@ impl Expr { /// This without an outer `as`, where the context already gives the type. pub fn typed(self) -> Self { match self { - // Limbs keep theirs, which the brand of their type requires, and an `rt.RangeBound` its + // Limbs keep theirs, which the brand of their type requires, and an `rs.RangeBound` its // own, without which a declaration narrows to the one variant it is made as. Self::As(e, ty) if matches!(*e, Self::Str(_) | Self::Array(_) | Self::Object(_)) && !wide(&ty) - && !matches!(ty, Type::Rt("RangeBound", _)) => + && !matches!(ty, Type::Rs("RangeBound", _)) => { *e } Self::Located(loc, e) => Self::Located(loc, Box::new(e.typed())), - // `rt.Ok(v)` and `rt.Err(e)` infer their type from the context too. - Self::Call(f, args) if matches!(&*f, Self::Rt(name) if name == "Ok" || name == "Err") => { + // `rs.Ok(v)` and `rs.Err(e)` infer their type from the context too. + Self::Call(f, args) if matches!(&*f, Self::Rs(name) if name == "Ok" || name == "Err") => { Self::Call(f, args.into_iter().map(Self::typed).collect()) } e => e, @@ -176,9 +176,9 @@ impl Expr { /// a literal, or `this`. pub fn is_constant(&self) -> bool { match self { - Self::Lit(_) | Self::Str(_) | Self::This | Self::Sym(_) | Self::Rt(_) => true, + Self::Lit(_) | Self::Str(_) | Self::This | Self::Sym(_) | Self::Rs(_) => true, Self::Located(_, e) => e.is_constant(), - // A wide integer literal past 2^53, `{ hi: 0xffffffff, lo: 0xffffffff } as rt.u64`: + // A wide integer literal past 2^53, `{ hi: 0xffffffff, lo: 0xffffffff } as rs.u64`: // immutable limbs, which compare by value. Self::As(e, ty) if wide(ty) => { matches!(&**e, Self::Object(fields) if fields.iter().all(|(_, v)| matches!(v, Self::Lit(_)))) @@ -226,7 +226,7 @@ impl Expr { /// Whether `ty` is a 64- or 128-bit integer type, whose values past 2^53 are limbs. fn wide(ty: &Type) -> bool { - matches!(ty, Type::Rt("u64" | "i64" | "u128" | "i128", _)) + matches!(ty, Type::Rs("u64" | "i64" | "u128" | "i128", _)) } #[derive(Clone, Debug, PartialEq, Eq, Hash)] @@ -385,7 +385,7 @@ impl Expr { b.syms_mut(f); c.syms_mut(f); } - Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} } } } @@ -507,7 +507,7 @@ impl Expr { b.free_names(free); c.free_names(free); } - Expr::This | Expr::Sym(_) | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::This | Expr::Sym(_) | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} } } } @@ -546,7 +546,7 @@ impl Expr { b.eager_syms(f); c.eager_syms(f); } - Expr::Ident(_) | Expr::This | Expr::Rt(_) | Expr::Lit(_) | Expr::Str(_) => {} + Expr::Ident(_) | Expr::This | Expr::Rs(_) | Expr::Lit(_) | Expr::Str(_) => {} } } } @@ -579,8 +579,8 @@ pub enum Type { /// A built-in type: `number`, `bigint`, `boolean`, `string`, `void`, `never`, /// `undefined`, `Uint8Array`. Builtin(&'static str), - /// A runtime type: `rt.`. - Rt(&'static str, Vec), + /// A runtime type: `rs.`. + Rs(&'static str, Vec), Sym(SymId, Vec), Param(String), Union(Vec), @@ -604,7 +604,7 @@ impl Type { match self { Type::Func(params, ret) => params.iter().any(|t| t.any(f)) || ret.takes(f), Type::Param(_) | Type::Builtin(_) | Type::StrLit(_) => false, - Type::Rt(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { + Type::Rs(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { tys.iter().any(|t| t.takes(f)) } Type::Array(t) => t.takes(f), @@ -618,7 +618,7 @@ impl Type { match self { Type::Param(name) => f(name).unwrap_or_else(|| self.clone()), Type::Builtin(_) | Type::StrLit(_) => self.clone(), - Type::Rt(name, tys) => Type::Rt(name, all(tys)), + Type::Rs(name, tys) => Type::Rs(name, all(tys)), Type::Sym(sym, tys) => Type::Sym(*sym, all(tys)), Type::Union(tys) => Type::Union(all(tys)), Type::Tuple(tys) => Type::Tuple(all(tys)), @@ -633,7 +633,7 @@ impl Type { f(self) || match self { Type::Param(_) | Type::Builtin(_) | Type::StrLit(_) => false, - Type::Rt(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { + Type::Rs(_, tys) | Type::Sym(_, tys) | Type::Union(tys) | Type::Tuple(tys) => { tys.iter().any(|t| t.any(f)) } Type::Array(t) => t.any(f), diff --git a/ts/tests/btree.ts b/ts/tests/btree.ts index 87e13449f..8b6819997 100644 --- a/ts/tests/btree.ts +++ b/ts/tests/btree.ts @@ -6,7 +6,7 @@ // // usage: node btree.ts -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; // xorshift32, as `runtime.rs` runs it. let state = 0x2545f491; @@ -19,14 +19,14 @@ function rand(): number { return state; } -const cmp = (a: number, b: number): rt.Ordering => (a < b ? -1 : a > b ? 1 : 0); +const cmp = (a: number, b: number): rs.Ordering => (a < b ? -1 : a > b ? 1 : 0); const out: string[] = []; const show = (v: number | undefined) => (v === undefined ? "-" : String(v)); -const walk = (it: rt.Iter<[number, number]>) => { +const walk = (it: rs.Iter<[number, number]>) => { const seen: number[] = []; for (let i = 0; i < 40; i++) { const item = rand() & 1 ? it.next() : it.nextBack(); - if (item === rt.DONE) break; + if (item === rs.DONE) break; seen.push(item[0]); } return seen.join(","); @@ -38,7 +38,7 @@ const walk = (it: rt.Iter<[number, number]>) => { * count right, and every node but the root at least half as full as the fullest, so its * height is logarithmic. */ -function check(m: rt.BTreeMap): void { +function check(m: rs.BTreeMap): void { type Node = { k: number[]; c?: Node[]; prev?: Node; next?: Node }; const tree = m as unknown as { t: Node; h: number; n: number }; const leaves: Node[] = []; @@ -76,7 +76,7 @@ function check(m: rt.BTreeMap): void { if (tree.n === 0 && tree.h !== 0) fail("an empty tree above its root leaf"); } -let m = rt.btreeNew(cmp); +let m = rs.btreeNew(cmp); const steps = 120_000; for (let step = 0; step < steps; step++) { const keys = 65_536; @@ -85,54 +85,54 @@ for (let step = 0; step < steps; step++) { const op = rand() % 10; const k = rand() % keys; if (op < 5) { - if (phase === 0 || (phase === 1 && k % 2 === 0)) out.push(`insert ${k} ${show(rt.btreeInsert(m, k, step))}`); - else out.push(`remove ${k} ${show(rt.btreeRemove(m, k))}`); + if (phase === 0 || (phase === 1 && k % 2 === 0)) out.push(`insert ${k} ${show(rs.btreeInsert(m, k, step))}`); + else out.push(`remove ${k} ${show(rs.btreeRemove(m, k))}`); } else if (op === 5) { - out.push(`get ${k} ${show(rt.btreeGet(m, k))}`); + out.push(`get ${k} ${show(rs.btreeGet(m, k))}`); } else if (op === 6) { const j = rand() % keys; const [lo, hi] = k < j ? [k, j] : [j, k]; const inclusive = rand() & 1; - const r = inclusive ? new rt.RangeInclusive(lo, hi) : { start: lo, end: hi }; - out.push(`range ${lo} ${hi} ${inclusive} ${walk(rt.btreeRange(m, r))}`); + const r = inclusive ? new rs.RangeInclusive(lo, hi) : { start: lo, end: hi }; + out.push(`range ${lo} ${hi} ${inclusive} ${walk(rs.btreeRange(m, r))}`); } else if (op === 7) { const last = (rand() & 1) === 1; - out.push(`pop ${last} ${rt.btreePop(m, last)?.join(" ") ?? "-"}`); + out.push(`pop ${last} ${rs.btreePop(m, last)?.join(" ") ?? "-"}`); } else if (op === 8) { - out.push(`remove ${k} ${show(rt.btreeRemove(m, k))}`); + out.push(`remove ${k} ${show(rs.btreeRemove(m, k))}`); } else if (step % 97 === 0) { - const it = rt.btreeIter(m); + const it = rs.btreeIter(m); const seen = walk(it); - out.push(`iter ${rt.btreeLen(m)} ${it.len()} ${seen}`); + out.push(`iter ${rs.btreeLen(m)} ${it.len()} ${seen}`); } else if (step % 1009 === 0) { - const copy = rt.btreeClone(m); - rt.btreeRetain(m, (key) => key % 7 !== k % 7); - out.push(`retain ${rt.btreeLen(m)} ${rt.btreeFirst(m)?.join(" ") ?? "-"} ${rt.btreeFirst(m, true)?.join(" ") ?? "-"}`); + const copy = rs.btreeClone(m); + rs.btreeRetain(m, (key) => key % 7 !== k % 7); + out.push(`retain ${rs.btreeLen(m)} ${rs.btreeFirst(m)?.join(" ") ?? "-"} ${rs.btreeFirst(m, true)?.join(" ") ?? "-"}`); m = rand() & 1 ? copy : m; - out.push(`kept ${rt.btreeLen(m)}`); + out.push(`kept ${rs.btreeLen(m)}`); } else if (step % 211 === 0) { const j = rand() % keys; const [lo, hi] = k < j ? [k, j] : [j, k]; const limit = rand() % 400; - const copy = rt.btreeClone(m); - const it = rt.btreeExtractIf(m, { start: lo, end: hi }, (key, value) => (key ^ value) % 3 !== 0); + const copy = rs.btreeClone(m); + const it = rs.btreeExtractIf(m, { start: lo, end: hi }, (key, value) => (key ^ value) % 3 !== 0); const taken: number[] = []; for (let i = 0; i < limit; i++) { const entry = it.next(); - if (entry === rt.DONE) break; + if (entry === rs.DONE) break; taken.push(entry[0]); } - out.push(`extract ${lo} ${hi} ${rt.btreeLen(m)} ${taken.join(",")}`); + out.push(`extract ${lo} ${hi} ${rs.btreeLen(m)} ${taken.join(",")}`); check(m); m = rand() & 1 ? copy : m; } if (step % 499 === 0) check(m); } -out.push(`end ${rt.btreeLen(m)} ${rt.iterToVec(rt.btreeKeys(m)).items.join(",")}`); +out.push(`end ${rs.btreeLen(m)} ${rs.iterToVec(rs.btreeKeys(m)).items.join(",")}`); // Emptied from both ends, down to its root leaf. const drained: number[] = []; -while (rt.btreeLen(m) > 0) { - drained.push((rt.btreePop(m, (rand() & 1) === 1) as [number, number])[0]); +while (rs.btreeLen(m) > 0) { + drained.push((rs.btreePop(m, (rand() & 1) === 1) as [number, number])[0]); if (drained.length % 37 === 0) check(m); } check(m); diff --git a/ts/tests/differential.ts b/ts/tests/differential.ts index d6eb7fefb..f6a49d326 100644 --- a/ts/tests/differential.ts +++ b/ts/tests/differential.ts @@ -3,7 +3,7 @@ // // usage: node differential.ts [cases] // -// A harness, or a hand-written caller wrapping one, exports `run(input: rt.ByteSlice): +// A harness, or a hand-written caller wrapping one, exports `run(input: rs.ByteSlice): // Vec`, what `inputs.ts` reads to pick its inputs, and may export `within(input, // native, translated)`, which accepts outputs that differ only where Rust leaves the // result to the platform, as libm's are. [cases] random inputs run, or that many per case @@ -29,16 +29,16 @@ const count = Number(countArg ?? "20000"); const harness = await import(pathToFileURL(harnessPath).href); // The translation's runtime, beside the harness, which makes the input its slice type. -const rt = await import(pathToFileURL(join(dirname(harnessPath), "rt.ts")).href); +const rs = await import(pathToFileURL(join(dirname(harnessPath), "rs.ts")).href); const wasm = new Wasm(await WebAssembly.compile(await readFile(wasmPath))); function translated(input: Uint8Array): Outcome { try { - const out = harness.run(rt.byteSliceFrom(input)); + const out = harness.run(rs.byteSliceFrom(input)); return out.data.slice(0, out.length); } catch (err) { if (!(err instanceof Error) || (err.name !== "Abort" && err.name !== "Panic")) throw err; - rt.takeHook(); + rs.takeHook(); return err.name === "Abort" ? "abort" : { panic: err.message }; } } diff --git a/ts/tests/fixtures.rs b/ts/tests/fixtures.rs index 15f1ce541..47718cc81 100644 --- a/ts/tests/fixtures.rs +++ b/ts/tests/fixtures.rs @@ -95,7 +95,7 @@ fn sources(dir: &Path) -> Vec<(PathBuf, String)> { let rel = path.strip_prefix(dir).unwrap().to_path_buf(); let text = std::fs::read_to_string(&path).unwrap(); // A hand-written caller copied in beside the output is no part of it. - if rel != Path::new("rt.ts") && !rel.starts_with("rt") && text.starts_with("// Generated by rust2-ts.") + if rel != Path::new("rs.ts") && !rel.starts_with("rs") && text.starts_with("// Generated by rust2-ts.") { files.push((rel, text)); } @@ -236,9 +236,9 @@ fn codec() { /// A caller of two functions of a type, through its module, as moq's TypeScript calls /// the codec. const SHAKE: &str = r#"import * as Decoder from "./coding/decode.Decoder.ts"; -import * as rt from "./rt.ts"; +import * as rs from "./rs.ts"; -export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(rt.byteSliceFrom(buf), { tag: "Quic" })); +export const run = (buf: Uint8Array) => Decoder.u8(Decoder.new(rs.byteSliceFrom(buf), { tag: "Quic" })); "#; /// Bun's and esbuild's tree-shaken bundles of [`SHAKE`] keep the functions it calls and @@ -577,7 +577,7 @@ fn task() { fn task_differential(out: &Path) { let harness = manifest_dir().join("tests").join("task.ts").display().to_string(); let text = format!( - r#"import * as rt from "./rt.ts"; + r#"import * as rs from "./rs.ts"; import * as Log from "./log.Log.ts"; import * as Channel from "./model.Channel.ts"; import * as Guard from "./model.Guard.ts"; @@ -588,9 +588,9 @@ import * as closures from "./closures.ts"; import {{ harness }} from {harness:?}; export {{ cases, input, ops }} from {harness:?}; -const fixture = {{ Pending: rt.Pending, u64: {{ of: rt.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; +const fixture = {{ Pending: rs.Pending, u64: {{ of: rs.u64Of }}, Log, Channel, Guard, sum, drain, blocks, watch, front, drops, futures, closures }}; const script = harness(fixture); -export const run = (input: rt.ByteSlice) => script(rt.byteSliceView(input)); +export const run = (input: rs.ByteSlice) => script(rs.byteSliceView(input)); "# ); std::fs::write(out.join("caller.ts"), text).unwrap(); diff --git a/ts/tests/fma.ts b/ts/tests/fma.ts index 8cd7dfc02..a946de48b 100644 --- a/ts/tests/fma.ts +++ b/ts/tests/fma.ts @@ -6,7 +6,7 @@ import { strict as assert } from "node:assert"; import { exactMulAdd, mulAddsWithin } from "../fixtures/lang/floats/fma.ts"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; function double(bits: bigint): number { const view = new DataView(new ArrayBuffer(8)); @@ -59,7 +59,7 @@ for (let i = 0; i < 20000; i++) { const c = i % 2 === 0 ? double(next()) : -(a * b); const exact = exactMulAdd(a, b, c); if (exact === undefined) continue; - assert.ok(Object.is(exact, rt.f64MulAdd(a, b, c)), `${a}, ${b}, ${c}`); + assert.ok(Object.is(exact, rs.f64MulAdd(a, b, c)), `${a}, ${b}, ${c}`); } // A product of half `c`'s last place that only its error moves off the tie, which wasm32's diff --git a/ts/tests/local.ts b/ts/tests/local.ts index ccd1cfa6e..8a72c3d96 100644 --- a/ts/tests/local.ts +++ b/ts/tests/local.ts @@ -6,28 +6,28 @@ import { strict as assert } from "node:assert"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; // `set`, as std's calls it: what the key had no value for becomes its value, else sets it. -const set = (key: rt.LocalKey>, v: number) => - rt.localKeyInitializeWith(key, new rt.Cell(v), (init, cell) => { - if (init !== undefined) rt.cellSet(cell, init.v); +const set = (key: rs.LocalKey>, v: number) => + rs.localKeyInitializeWith(key, new rs.Cell(v), (init, cell) => { + if (init !== undefined) rs.cellSet(cell, init.v); }); // A lazy key's `set` before its first use doesn't run its expression; a `const` one's // value is always there. const made: string[] = []; -const lazy = new rt.LocalKey(() => { +const lazy = new rs.LocalKey(() => { made.push("lazy"); - return new rt.Cell(1); + return new rs.Cell(1); }, true); set(lazy, 2); assert.equal(lazy.get().v, 2); set(lazy, 3); assert.equal(lazy.get().v, 3); -const eager = new rt.LocalKey(() => { +const eager = new rs.LocalKey(() => { made.push("eager"); - return new rt.Cell(1); + return new rs.Cell(1); }, false); set(eager, 4); assert.equal(eager.get().v, 4); @@ -37,7 +37,7 @@ assert.deepEqual(made, ["eager"]); // replaces, dropping it. const dropped: number[] = []; let count = 0; -const nested: rt.LocalKey = new rt.LocalKey( +const nested: rs.LocalKey = new rs.LocalKey( () => { const n = ++count; if (n === 1) assert.equal(nested.get(), 2); @@ -52,7 +52,7 @@ assert.deepEqual(dropped, [2]); // A use while that drop runs aborts, which here panics. let calls = 0; -const dying: rt.LocalKey = new rt.LocalKey( +const dying: rs.LocalKey = new rs.LocalKey( () => { const n = ++calls; if (n === 1) dying.get(); @@ -62,7 +62,7 @@ const dying: rt.LocalKey = new rt.LocalKey( () => assert.throws( () => dying.get(), - (e: Error) => e instanceof rt.Panic && e.message === "Attempted to initialize thread-local while it is being dropped", + (e: Error) => e instanceof rs.Panic && e.message === "Attempted to initialize thread-local while it is being dropped", ), ); assert.equal(dying.get(), 1); diff --git a/ts/tests/nan.ts b/ts/tests/nan.ts index d945f54f5..ae66fe985 100644 --- a/ts/tests/nan.ts +++ b/ts/tests/nan.ts @@ -6,36 +6,36 @@ import { strict as assert } from "node:assert"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; /** A `u64`'s value. */ -function big(v: rt.u64): bigint { +function big(v: rs.u64): bigint { return typeof v === "number" ? BigInt(v) : (BigInt(v.hi) << 32n) + BigInt(v.lo); } const QUIET = 0x0008000000000000n; for (const bits of [0x7ff8000000000000n, 0xfff8000000000000n, 0x7ff8000000000123n, 0xfffc0000deadbeefn, 0x7ff0000000000001n, 0xfff4000000000abcn]) { - const x = rt.f64FromBits(rt.u64Of(bits)); + const x = rs.f64FromBits(rs.u64Of(bits)); const negative = bits >> 63n === 1n; - assert.equal(big(rt.f64ToBits(x)), bits, `${bits.toString(16)} round trips`); - assert.equal(rt.f64IsSignNegative(x), negative); - assert.equal(rt.f64IsSignPositive(x), !negative); - assert.equal(big(rt.f64ToBits(rt.f64Copysign(x, -1))), bits | (1n << 63n)); - assert.equal(big(rt.f64ToBits(rt.f64Copysign(x, 1))), bits & ~(1n << 63n)); + assert.equal(big(rs.f64ToBits(x)), bits, `${bits.toString(16)} round trips`); + assert.equal(rs.f64IsSignNegative(x), negative); + assert.equal(rs.f64IsSignPositive(x), !negative); + assert.equal(big(rs.f64ToBits(rs.f64Copysign(x, -1))), bits | (1n << 63n)); + assert.equal(big(rs.f64ToBits(rs.f64Copysign(x, 1))), bits & ~(1n << 63n)); // A double array holds a NaN quieted, its payload otherwise kept. const held = [x, 1.5]; - assert.equal(big(rt.f64ToBits(held[0])), bits | QUIET, `${bits.toString(16)} held in an array`); + assert.equal(big(rs.f64ToBits(held[0])), bits | QUIET, `${bits.toString(16)} held in an array`); } // An `f32` NaN is a double NaN with the single's sign and payload at the top, which a // signaling one keeps through `from_bits`, `to_bits`, its bytes, and `copysign`. for (const bits of [0x7fc00000, 0xffc00000, 0x7fc00123, 0xffe0beef, 0x7f800001, 0xffa00abc]) { - const x = rt.f32FromBits(bits); + const x = rs.f32FromBits(bits); const negative = bits >>> 31 === 1; - assert.equal(rt.f32ToBits(x), bits, `${bits.toString(16)} round trips`); - assert.equal(rt.f32IsSignNegative(x), negative); - assert.equal(rt.f32ToBits(rt.f32Copysign(x, -1)), (bits | 0x80000000) >>> 0); - assert.equal(rt.f32ToBits(rt.f32Copysign(x, 1)), bits & 0x7fffffff); - assert.equal(rt.f32ToBits(rt.f32FromBeBytes(rt.f32ToBeBytes(x))), bits); - assert.equal(rt.f32ToBits(rt.f32FromLeBytes(rt.f32ToLeBytes(x))), bits); + assert.equal(rs.f32ToBits(x), bits, `${bits.toString(16)} round trips`); + assert.equal(rs.f32IsSignNegative(x), negative); + assert.equal(rs.f32ToBits(rs.f32Copysign(x, -1)), (bits | 0x80000000) >>> 0); + assert.equal(rs.f32ToBits(rs.f32Copysign(x, 1)), bits & 0x7fffffff); + assert.equal(rs.f32ToBits(rs.f32FromBeBytes(rs.f32ToBeBytes(x))), bits); + assert.equal(rs.f32ToBits(rs.f32FromLeBytes(rs.f32ToLeBytes(x))), bits); } diff --git a/ts/tests/once.ts b/ts/tests/once.ts index 9d4816a43..cad419dc5 100644 --- a/ts/tests/once.ts +++ b/ts/tests/once.ts @@ -7,31 +7,31 @@ import { strict as assert } from "node:assert"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; -const recursive = (f: () => void) => assert.throws(f, (e: Error) => e instanceof rt.Panic && e.message === "one-time initialization may not be performed recursively"); +const recursive = (f: () => void) => assert.throws(f, (e: Error) => e instanceof rs.Panic && e.message === "one-time initialization may not be performed recursively"); -const lock = new rt.OnceLock(undefined); -const made = rt.onceGetOrInit(lock, () => { - recursive(() => rt.onceSet(lock, "set")); - recursive(() => rt.onceGetOrInit(lock, () => "inner")); +const lock = new rs.OnceLock(undefined); +const made = rs.onceGetOrInit(lock, () => { + recursive(() => rs.onceSet(lock, "set")); + recursive(() => rs.onceGetOrInit(lock, () => "inner")); return "outer"; }); assert.equal(made, "outer"); // Once initialized, neither panics, and `set` gives its value back. -assert.deepEqual(rt.onceSet(lock, "again"), rt.Err("again")); +assert.deepEqual(rs.onceSet(lock, "again"), rs.Err("again")); // A lazy cell's function runs once, so a `force` from within it has no value to give. -const lazyLock: rt.LazyLock = new rt.LazyLock(() => { +const lazyLock: rs.LazyLock = new rs.LazyLock(() => { recursive(() => lazyLock.force()); return "made"; }); assert.equal(lazyLock.force(), "made"); -const lazyCell: rt.LazyCell = new rt.LazyCell(() => { +const lazyCell: rs.LazyCell = new rs.LazyCell(() => { assert.throws( () => lazyCell.force(), - (e: Error) => e instanceof rt.Panic && e.message === "LazyCell instance has previously been poisoned", + (e: Error) => e instanceof rs.Panic && e.message === "LazyCell instance has previously been poisoned", ); return "made"; }); diff --git a/ts/tests/pointers.ts b/ts/tests/pointers.ts index 8152e02bb..9b99cae12 100644 --- a/ts/tests/pointers.ts +++ b/ts/tests/pointers.ts @@ -7,137 +7,137 @@ import { strict as assert } from "node:assert"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; -const unsure = (f: () => void) => assert.throws(f, (e: Error) => !(e instanceof rt.Panic) && e.message.startsWith("rust2-ts: ")); +const unsure = (f: () => void) => assert.throws(f, (e: Error) => !(e instanceof rs.Panic) && e.message.startsWith("rust2-ts: ")); -// Two `&raw const x` of one variable, each its own `rt.Place`. +// Two `&raw const x` of one variable, each its own `rs.Place`. let x = 5; -const a = rt.place(() => x, (v) => (x = v)); -const b = rt.place(() => x, (v) => (x = v)); -unsure(() => rt.ptrOffsetFrom(a, b)); -assert.equal(rt.ptrOffsetFrom(rt.ptrAdd(a, 1), a), 1); +const a = rs.place(() => x, (v) => (x = v)); +const b = rs.place(() => x, (v) => (x = v)); +unsure(() => rs.ptrOffsetFrom(a, b)); +assert.equal(rs.ptrOffsetFrom(rs.ptrAdd(a, 1), a), 1); // A `repr(C)` struct's fields, each a value in no array: reached from the other, and as a slice of both. const pair = { low: 1, high: 2 }; -const low = rt.place(() => pair.low, (v) => (pair.low = v)); -const high = rt.place(() => pair.high, (v) => (pair.high = v)); -unsure(() => rt.ptrOffsetFrom(high, low)); -unsure(() => rt.ptrAdd(high, -1).v); -unsure(() => rt.ptrSlice(low, 2)); -unsure(() => rt.ptrCopy(low, high, 2)); +const low = rs.place(() => pair.low, (v) => (pair.low = v)); +const high = rs.place(() => pair.high, (v) => (pair.high = v)); +unsure(() => rs.ptrOffsetFrom(high, low)); +unsure(() => rs.ptrAdd(high, -1).v); +unsure(() => rs.ptrSlice(low, 2)); +unsure(() => rs.ptrCopy(low, high, 2)); // A shared subslice, which is a copy: before it, past it, and against its parent. const lanes = [1, 2, 3, 4]; -const part = rt.sliceRange(lanes, 1, 3); -unsure(() => rt.ptrAdd(rt.sliceAsPtr(part), -1).v); -unsure(() => rt.ptrAdd(rt.sliceAsPtr(part), 2).v); -unsure(() => rt.ptrOffsetFrom(rt.sliceAsPtr(part), rt.sliceAsPtr(lanes))); -unsure(() => rt.ptrSlice(rt.sliceAsPtr(part), 3)); -unsure(() => rt.ptrCopy(rt.sliceAsPtr(part), rt.sliceAsPtr(lanes), 3)); -assert.equal(rt.ptrAdd(rt.sliceAsPtr(part), 1).v, 3); +const part = rs.sliceRange(lanes, 1, 3); +unsure(() => rs.ptrAdd(rs.sliceAsPtr(part), -1).v); +unsure(() => rs.ptrAdd(rs.sliceAsPtr(part), 2).v); +unsure(() => rs.ptrOffsetFrom(rs.sliceAsPtr(part), rs.sliceAsPtr(lanes))); +unsure(() => rs.ptrSlice(rs.sliceAsPtr(part), 3)); +unsure(() => rs.ptrCopy(rs.sliceAsPtr(part), rs.sliceAsPtr(lanes), 3)); +assert.equal(rs.ptrAdd(rs.sliceAsPtr(part), 1).v, 3); // A byte in no array, as a raw or mutable slice, as a shared one past it, and the // pointer of a shared one, a copy, against the byte's. let byte = 3; -const lone = rt.place(() => byte, (v) => (byte = v)); -unsure(() => rt.ptrByteSlice(lone, 1, false)); -unsure(() => rt.ptrByteSlice(lone, 2, true)); -const shared = rt.ptrByteSlice(lone, 1, true); +const lone = rs.place(() => byte, (v) => (byte = v)); +unsure(() => rs.ptrByteSlice(lone, 1, false)); +unsure(() => rs.ptrByteSlice(lone, 2, true)); +const shared = rs.ptrByteSlice(lone, 1, true); assert.deepEqual(shared.data, Uint8Array.of(3)); -unsure(() => rt.ptrOffsetFrom(rt.byteSliceAsPtr(shared), lone)); +unsure(() => rs.ptrOffsetFrom(rs.byteSliceAsPtr(shared), lone)); // A write into a `Vec`'s capacity past its length, which a JS array would grow by. const vec: number[] = [7]; unsure(() => { - rt.ptrAdd(rt.sliceAsPtr(vec), 1).v = 8; + rs.ptrAdd(rs.sliceAsPtr(vec), 1).v = 8; }); assert.equal(vec.length, 1); // Memory from `alloc`, which JS keeps as values once a cast types it: its bytes, typed as // another type of the same size, a pointer past the start of what it holds cast back to // bytes, and one to its values passed as if a block. -const block = rt.alloc({ size: 12, align: 4 }); +const block = rs.alloc({ size: 12, align: 4 }); unsure(() => block.v); -const words = rt.allocAs(block, 4, "u32"); +const words = rs.allocAs(block, 4, "u32"); words.v = 0xffffffff; -assert.equal(rt.allocAs(block, 4, "u32").v, 0xffffffff); -unsure(() => rt.allocAs(block, 4, "i32")); -unsure(() => rt.allocBytes(words, 4, "f32")); -unsure(() => rt.allocBytes(rt.ptrAdd(words, 1), 4, "u32")); +assert.equal(rs.allocAs(block, 4, "u32").v, 0xffffffff); +unsure(() => rs.allocAs(block, 4, "i32")); +unsure(() => rs.allocBytes(words, 4, "f32")); +unsure(() => rs.allocBytes(rs.ptrAdd(words, 1), 4, "u32")); // Grown, it keeps its values, as many as fit; freed or grown, a pointer to its values is // no block. -unsure(() => rt.dealloc(words)); -unsure(() => rt.realloc(words, 16)); -const grown = rt.realloc(rt.allocBytes(words, 4, "u32"), 18); +unsure(() => rs.dealloc(words)); +unsure(() => rs.realloc(words, 16)); +const grown = rs.realloc(rs.allocBytes(words, 4, "u32"), 18); assert.deepEqual(Array.from(grown.array ?? []), [0xffffffff, undefined, undefined, undefined]); // A dangling pointer read through, written through, or copied from, which Rust leaves // undefined, rather than reading `undefined`. -const dangling: rt.Place = rt.DANGLING; -unsure(() => rt.ptrAdd(dangling, 1).v); +const dangling: rs.Place = rs.DANGLING; +unsure(() => rs.ptrAdd(dangling, 1).v); unsure(() => { - rt.ptrAdd(dangling, 1).v = 1; + rs.ptrAdd(dangling, 1).v = 1; }); -unsure(() => rt.ptrCopy(dangling, rt.sliceAsPtr(vec), 1)); -unsure(() => rt.ptrSlice(dangling, 1)); +unsure(() => rs.ptrCopy(dangling, rs.sliceAsPtr(vec), 1)); +unsure(() => rs.ptrSlice(dangling, 1)); assert.equal(vec[0], 7); // A raw slice pointer read through once its `Vec` has shrunk past it, which Rust keeps // the old values for, and one past the array, which Rust allows until a read. const rows = [1, 2, 3, 4]; -const all = new rt.RawSlice(rt.sliceAsPtr(rows), 4); -const tail = new rt.RawSlice(rt.sliceAsPtr(rows, 1), 3); +const all = new rs.RawSlice(rs.sliceAsPtr(rows), 4); +const tail = new rs.RawSlice(rs.sliceAsPtr(rows, 1), 3); assert.equal(all.deref()[3] + tail.deref()[2], 8); rows.length = 3; unsure(() => all.deref()); unsure(() => tail.deref()); -const long = new rt.RawSlice(rt.sliceAsPtr(rows), 10); +const long = new rs.RawSlice(rs.sliceAsPtr(rows), 10); assert.equal(long.length, 10); unsure(() => long.deref()); // A `*const ()` cast back to a pointer to another type than any cast to it was from, which // Rust reads as bytes JS doesn't keep, and one no cast erased, such as a waker's `Arc`. const note = { id: 1 }; -const erased = rt.ptrErase(note, "raw::Note", 2); +const erased = rs.ptrErase(note, "raw::Note", 2); assert.equal(erased, note); -assert.equal(rt.ptrUnerase(erased, "raw::Note", 2), note); -unsure(() => rt.ptrUnerase(erased, "u16", 2)); -unsure(() => rt.ptrUnerase({ v: undefined }, "raw::Note", 2)); +assert.equal(rs.ptrUnerase(erased, "raw::Note", 2), note); +unsure(() => rs.ptrUnerase(erased, "u16", 2)); +unsure(() => rs.ptrUnerase({ v: undefined }, "raw::Note", 2)); // Erased as two types, as a transparent wrapper and what it holds are, it is either. -rt.ptrErase(note, "raw::Wrapper", 2); -assert.equal(rt.ptrUnerase(erased, "raw::Wrapper", 2), note); -assert.equal(rt.ptrUnerase(erased, "raw::Note", 2), note); -assert.throws(() => rt.ptrUnerase(erased, "u16", 2), /`\*const \(\)` cast back to a pointer to `u16`, which points at `raw::Note` or `raw::Wrapper`/); +rs.ptrErase(note, "raw::Wrapper", 2); +assert.equal(rs.ptrUnerase(erased, "raw::Wrapper", 2), note); +assert.equal(rs.ptrUnerase(erased, "raw::Note", 2), note); +assert.throws(() => rs.ptrUnerase(erased, "u16", 2), /`\*const \(\)` cast back to a pointer to `u16`, which points at `raw::Note` or `raw::Wrapper`/); // Null at any type, and dangling at the address of its type's alignment, which a cast // through a type of another alignment keeps. -assert.equal(rt.ptrUnerase(rt.ptrErase(rt.NULL, "raw::Note", 2), "u16", 2), rt.NULL); -assert.equal(rt.ptrUnerase(rt.ptrErase(rt.DANGLING, "raw::Note", 2), "u16", 2), rt.DANGLING); -assert.equal(rt.ptrErase(rt.DANGLING, "raw::Byte", 1), rt.DANGLING_UNIT); -const two = rt.ptrErase(rt.DANGLING, "raw::Note", 2); -assert.notEqual(two, rt.DANGLING_UNIT); -const aligned = rt.ptrUnerase(two, "raw::Byte", 1) as object; -assert.notEqual(aligned, rt.DANGLING); -assert.equal(rt.ptrErase(aligned, "raw::Byte", 1), two); -unsure(() => (aligned as rt.Place).v); +assert.equal(rs.ptrUnerase(rs.ptrErase(rs.NULL, "raw::Note", 2), "u16", 2), rs.NULL); +assert.equal(rs.ptrUnerase(rs.ptrErase(rs.DANGLING, "raw::Note", 2), "u16", 2), rs.DANGLING); +assert.equal(rs.ptrErase(rs.DANGLING, "raw::Byte", 1), rs.DANGLING_UNIT); +const two = rs.ptrErase(rs.DANGLING, "raw::Note", 2); +assert.notEqual(two, rs.DANGLING_UNIT); +const aligned = rs.ptrUnerase(two, "raw::Byte", 1) as object; +assert.notEqual(aligned, rs.DANGLING); +assert.equal(rs.ptrErase(aligned, "raw::Byte", 1), two); +unsure(() => (aligned as rs.Place).v); // `Arc::from_raw` of a pointer no `Arc::into_raw` or `as_ptr` gave, such as a box's, of an // `Rc`'s, or of one whose value dropped, which Rust leaves undefined. -const task = new rt.Arc({ id: 1 }); -const raw = rt.arcRaw(task, task.value, "Arc"); -assert.equal(rt.arcFromRaw(raw, "Arc"), task); -unsure(() => rt.arcFromRaw({ id: 1 }, "Arc")); -unsure(() => rt.arcFromRaw(raw, "Rc")); +const task = new rs.Arc({ id: 1 }); +const raw = rs.arcRaw(task, task.value, "Arc"); +assert.equal(rs.arcFromRaw(raw, "Arc"), task); +unsure(() => rs.arcFromRaw({ id: 1 }, "Arc")); +unsure(() => rs.arcFromRaw(raw, "Rc")); task[Symbol.dispose](); -assert.throws(() => rt.arcFromRaw(raw, "Arc"), /`Arc::from_raw` of a pointer to a value already dropped/); +assert.throws(() => rs.arcFromRaw(raw, "Arc"), /`Arc::from_raw` of a pointer to a value already dropped/); // Moved off its place by arithmetic and back, which is the same address. -const counted = new rt.Arc(7); -const at = rt.arcRaw(counted, rt.arcPlace(counted), "Rc"); -assert.equal(rt.arcFromRaw(rt.ptrAdd(rt.ptrAdd(at, 1), -1), "Rc"), counted); +const counted = new rs.Arc(7); +const at = rs.arcRaw(counted, rs.arcPlace(counted), "Rc"); +assert.equal(rs.arcFromRaw(rs.ptrAdd(rs.ptrAdd(at, 1), -1), "Rc"), counted); // A pointer to a value JS copies cast to `*const ()`, which only an `Arc`'s raw pointer is // the one place of, moved off and back too, or one at no memory. -const flag = new rt.Arc(false); -const flagAt = rt.arcRaw(flag, rt.arcPlace(flag), "Arc"); -assert.equal(rt.arcErase(rt.ptrAdd(rt.ptrAdd(flagAt, 1), -1), "bool", 1), flagAt); -assert.equal(rt.arcErase(rt.NULL, "bool", 1), rt.NULL); -assert.throws(() => rt.arcErase({ v: false }, "bool", 1), /only an `Arc`'s or `Rc`'s raw pointer keeps the place of/); +const flag = new rs.Arc(false); +const flagAt = rs.arcRaw(flag, rs.arcPlace(flag), "Arc"); +assert.equal(rs.arcErase(rs.ptrAdd(rs.ptrAdd(flagAt, 1), -1), "bool", 1), flagAt); +assert.equal(rs.arcErase(rs.NULL, "bool", 1), rs.NULL); +assert.throws(() => rs.arcErase({ v: false }, "bool", 1), /only an `Arc`'s or `Rc`'s raw pointer keeps the place of/); diff --git a/ts/tests/reserve.ts b/ts/tests/reserve.ts index b1289fcc1..2199a041b 100644 --- a/ts/tests/reserve.ts +++ b/ts/tests/reserve.ts @@ -6,7 +6,7 @@ import { strict as assert } from "node:assert"; -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; /** The length past which a `Uint8Array` throws, as V8's does out of memory. */ const LIMIT = 1 << 20; @@ -19,40 +19,40 @@ globalThis.Uint8Array = class extends Native { } } as Uint8ArrayConstructor; -const debug = (e: rt.TryReserveError, spec: rt.Spec = {}) => rt.fmtToString(rt.fmtSpec(spec, (f) => rt.fmtTryReserveErrorDebug(e, f))); -const display = (e: rt.TryReserveError) => rt.fmtToString((f) => rt.fmtTryReserveErrorDisplay(e, f)); -const failed = (r: rt.Result, size: number): rt.TryReserveError => { +const debug = (e: rs.TryReserveError, spec: rs.Spec = {}) => rs.fmtToString(rs.fmtSpec(spec, (f) => rs.fmtTryReserveErrorDebug(e, f))); +const display = (e: rs.TryReserveError) => rs.fmtToString((f) => rs.fmtTryReserveErrorDisplay(e, f)); +const failed = (r: rs.Result, size: number): rs.TryReserveError => { assert.ok(!r.ok); assert.deepEqual(r.error.layout, { size, align: 1 }); return r.error; }; // Grown as `reserve` grows it, to double or to what it needs; exactly to what it needs. -const v = rt.byteVecWithCapacity(LIMIT / 2); -rt.byteVecPush(v, 7); +const v = rs.byteVecWithCapacity(LIMIT / 2); +rs.byteVecPush(v, 7); const data = v.data; -const grown = failed(rt.byteVecTryReserve(v, LIMIT / 2 + 1), LIMIT); -failed(rt.byteVecTryReserveExact(v, LIMIT), LIMIT + 1); +const grown = failed(rs.byteVecTryReserve(v, LIMIT / 2 + 1), LIMIT); +failed(rs.byteVecTryReserveExact(v, LIMIT), LIMIT + 1); assert.equal(v.data, data); -assert.deepEqual([...rt.byteVecView(v)], [7]); -assert.deepEqual(rt.byteVecTryReserve(v, LIMIT / 2 - 1), rt.OK); +assert.deepEqual([...rs.byteVecView(v)], [7]); +assert.deepEqual(rs.byteVecTryReserve(v, LIMIT / 2 - 1), rs.OK); assert.equal(debug(grown), "TryReserveError { kind: AllocError { layout: Layout { size: 1048576, align: 1 (1 << 0) }, non_exhaustive: () } }"); assert.equal(debug(grown, { debugHex: "x" }), "TryReserveError { kind: AllocError { layout: Layout { size: 100000, align: 1 (1 << 0) }, non_exhaustive: () } }"); assert.equal(display(grown), "memory allocation failed because the memory allocator returned an error"); -const overflow = rt.byteVecTryReserve(v, 0x7fffffff); +const overflow = rs.byteVecTryReserve(v, 0x7fffffff); assert.ok(!overflow.ok); -assert.ok(rt.tryReserveErrorEq(grown, new rt.TryReserveError({ size: LIMIT, align: 1 }))); -assert.ok(!rt.tryReserveErrorEq(grown, overflow.error)); -assert.ok(!rt.tryReserveErrorEq(grown, new rt.TryReserveError({ size: LIMIT + 1, align: 1 }))); +assert.ok(rs.tryReserveErrorEq(grown, new rs.TryReserveError({ size: LIMIT, align: 1 }))); +assert.ok(!rs.tryReserveErrorEq(grown, overflow.error)); +assert.ok(!rs.tryReserveErrorEq(grown, new rs.TryReserveError({ size: LIMIT + 1, align: 1 }))); // A deque of bytes, wrapped around its end, keeps its items in place. -const q = rt.dequeWithCapacity(4, 1, true); -for (const b of [1, 2, 3, 4]) rt.dequePushBack(q, b); -rt.dequePopFront(q); -rt.dequePushBack(q, 5); +const q = rs.dequeWithCapacity(4, 1, true); +for (const b of [1, 2, 3, 4]) rs.dequePushBack(q, b); +rs.dequePopFront(q); +rs.dequePushBack(q, 5); const slots = q.b; -failed(rt.dequeTryReserve(q, LIMIT), LIMIT + 4); -failed(rt.dequeTryReserveExact(q, LIMIT - 4), LIMIT); +failed(rs.dequeTryReserve(q, LIMIT), LIMIT + 4); +failed(rs.dequeTryReserveExact(q, LIMIT - 4), LIMIT); assert.equal(q.b, slots); -assert.deepEqual(rt.iterToVec(rt.dequeIter(q)).items, [2, 3, 4, 5]); +assert.deepEqual(rs.iterToVec(rs.dequeIter(q)).items, [2, 3, 4, 5]); diff --git a/ts/tests/retain.ts b/ts/tests/retain.ts index c77f3d00f..12ea6cfb0 100644 --- a/ts/tests/retain.ts +++ b/ts/tests/retain.ts @@ -5,38 +5,38 @@ // // usage: node retain.ts -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; for (let n = 0; n <= 6; n++) { for (let mask = 0; mask < 1 << n; mask++) { const keep = (i: number) => ((mask >> i) & 1) === 1; - const tree = rt.btreeNew(rt.cmp); - for (let i = n - 1; i >= 0; i--) rt.btreeInsert(tree, i, i * 10); - rt.btreeRetain(tree, (k) => keep(k)); + const tree = rs.btreeNew(rs.cmp); + for (let i = n - 1; i >= 0; i--) rs.btreeInsert(tree, i, i * 10); + rs.btreeRetain(tree, (k) => keep(k)); // Half pushed at the front, so the ring wraps. - const deque = rt.dequeNew(); - for (let i = (n >> 1) - 1; i >= 0; i--) rt.dequePushFront(deque, i); - for (let i = n >> 1; i < n; i++) rt.dequePushBack(deque, i); - rt.dequeRetain(deque, keep); + const deque = rs.dequeNew(); + for (let i = (n >> 1) - 1; i >= 0; i--) rs.dequePushFront(deque, i); + for (let i = n >> 1; i < n; i++) rs.dequePushBack(deque, i); + rs.dequeRetain(deque, keep); - const vec = rt.vecFrom([...Array(n).keys()]); + const vec = rs.vecFrom([...Array(n).keys()]); const dropped: number[] = []; - rt.vecRetain(vec, keep, (i) => dropped.push(i)); + rs.vecRetain(vec, keep, (i) => dropped.push(i)); // A run ends at each item the mask clears. - const runs = rt.vecFrom<[number, number]>([]); + const runs = rs.vecFrom<[number, number]>([]); for (let i = 0, run = 0; i < n; i++) runs.items.push([i, keep(i) ? run : ++run]); const deduped: number[] = []; - rt.vecDedupBy( + rs.vecDedupBy( runs, (a, b) => a[1] === b[1], (r) => deduped.push(r[0]), ); - const entries = rt.iterToVec(rt.btreeIter(tree)).items; - const items = rt.iterToVec(rt.dequeIter(deque)).items; + const entries = rs.iterToVec(rs.btreeIter(tree)).items; + const items = rs.iterToVec(rs.dequeIter(deque)).items; const ran = runs.items.map((r) => r[0]); console.log( `${n} ${mask} btree ${entries.join(";")} deque ${items.join(",")} vec ${vec.items.join(",")} dropped ${dropped.join(",")} dedup ${ran.join(",")} dropped ${deduped.join(",")}`, @@ -44,21 +44,21 @@ for (let n = 0; n <= 6; n++) { // Keys that collide by twos, so `retain` unlinks within chains. type Key = { k: number }; - const hashed = rt.hashNew( - rt.hashing( - (key, s) => rt.hash32(key.k >> 1, s), + const hashed = rs.hashNew( + rs.hashing( + (key, s) => rs.hash32(key.k >> 1, s), (a, b) => a.k === b.k, ), ); - for (let i = 0; i < n; i++) rt.hashInsert(hashed, { k: i }, i); - rt.hashRetain(hashed, (key) => keep(key.k)); - const held = rt.iterToVec(rt.hashIter(hashed)).items.map(([key, v]) => { - if (rt.hashGet(hashed, key) !== v) throw new Error(`${key.k} is not found`); + for (let i = 0; i < n; i++) rs.hashInsert(hashed, { k: i }, i); + rs.hashRetain(hashed, (key) => keep(key.k)); + const held = rs.iterToVec(rs.hashIter(hashed)).items.map(([key, v]) => { + if (rs.hashGet(hashed, key) !== v) throw new Error(`${key.k} is not found`); return key.k; }); const want = [...Array(n).keys()].filter(keep); - if (rt.hashLen(hashed) !== held.length || held.sort().join() !== want.join()) { - throw new Error(`hash map of ${n} by ${mask}: ${held} of ${rt.hashLen(hashed)}`); + if (rs.hashLen(hashed) !== held.length || held.sort().join() !== want.join()) { + throw new Error(`hash map of ${n} by ${mask}: ${held} of ${rs.hashLen(hashed)}`); } } } diff --git a/ts/tests/runtime.rs b/ts/tests/runtime.rs index 5d8c7f953..22a58ec4b 100644 --- a/ts/tests/runtime.rs +++ b/ts/tests/runtime.rs @@ -6,7 +6,7 @@ use std::path::PathBuf; use std::process::Command; -/// `rt.spawn` yields to a macrotask once a batch spends its poll budget, and a signal cancels it. +/// `rs.spawn` yields to a macrotask once a batch spends its poll budget, and a signal cancels it. #[test] fn spawn() { let script = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests").join("spawn.ts"); @@ -274,12 +274,12 @@ fn retain() { assert_eq!(got.lines().count(), want.lines().count()); } -/// `rt/unicode.ts` holds std's Unicode tables that `char`'s classes, case maps, and `Debug` +/// `rs/unicode.ts` holds std's Unicode tables that `char`'s classes, case maps, and `Debug` /// read, and `str::to_lowercase`'s final sigma, by this toolchain's std, whose Unicode version /// the JS engine's may trail. `UPDATE_EXPECT=1 just ts test --test runtime unicode` rewrites it. #[test] fn unicode() { - let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("runtime/rt/unicode.ts"); + let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("runtime/rs/unicode.ts"); // The runtime reads `is_cased` from three of the tables, as std defines it. for c in (0..=char::MAX as u32).filter_map(char::from_u32) { let cased = c.is_lowercase() || c.is_uppercase() || c.is_titlecase(); @@ -360,7 +360,7 @@ fn case_map(name: &str, method: &str, map: fn(char) -> Vec) -> String { } /// `map`'s table of the chars it maps to one other, in runs that step by one or two with -/// the same offset, and of those it maps to more than one, in `rt/unicode.ts`'s formats. +/// the same offset, and of those it maps to more than one, in `rs/unicode.ts`'s formats. fn case_runs(map: fn(char) -> Vec) -> (Vec, Vec) { // Each run's first char, length, step, and offset. let mut runs: Vec<(u32, u32, u32, i64)> = Vec::new(); @@ -401,7 +401,7 @@ fn case_runs(map: fn(char) -> Vec) -> (Vec, Vec) { (table, multi) } -/// `values` as `rt/unicode.ts` exports a table: `name`, documented by `doc`, in lines of +/// `values` as `rs/unicode.ts` exports a table: `name`, documented by `doc`, in lines of /// at most 90 columns. fn table(name: &str, doc: &str, values: &[i64]) -> String { let wrap = |text: &str, first: &str, rest: &str| { diff --git a/ts/tests/spawn.ts b/ts/tests/spawn.ts index 862466386..3155a68df 100644 --- a/ts/tests/spawn.ts +++ b/ts/tests/spawn.ts @@ -1,32 +1,32 @@ -// `rt.spawn` on futures that misbehave, and cancelled: one that keeps waking itself yields to a timer +// `rs.spawn` on futures that misbehave, and cancelled: one that keeps waking itself yields to a timer // queued before it once a batch spends its budget of 128 polls, so it cannot starve // timers and I/O, and one that panics as it drops rejects its promise. // // usage: node spawn.ts -import * as rt from "../runtime/rt.ts"; +import * as rs from "../runtime/rs.ts"; let polls = 0; let beforeTimer: number | undefined; -const selfWaking: rt.Future = { - poll(cx: rt.Context): rt.Poll { +const selfWaking: rs.Future = { + poll(cx: rs.Context): rs.Poll { if (++polls === 1000) return polls; cx.wakeByRef(); - return rt.Pending; + return rs.Pending; }, [Symbol.dispose](): void {}, }; setTimeout(() => { beforeTimer = polls; }, 0); -await rt.spawn(selfWaking); +await rs.spawn(selfWaking); if (beforeTimer !== 128) throw new Error(`${beforeTimer} polls ran before the timer, not 128`); -const panicsOnDrop: rt.Future = { +const panicsOnDrop: rs.Future = { poll: () => 1, - [Symbol.dispose]: () => rt.panic("drop failed"), + [Symbol.dispose]: () => rs.panic("drop failed"), }; -const settled = await outcome(rt.spawn(panicsOnDrop)); +const settled = await outcome(rs.spawn(panicsOnDrop)); if (settled !== "panic drop failed") throw new Error(`a panic in drop settled the promise as ${settled}`); // Cancelling through an `AbortSignal`: the future drops as Rust drops one, at once and @@ -34,18 +34,18 @@ if (settled !== "panic drop failed") throw new Error(`a panic in drop settled th // promise rejects with the signal's reason; one ready in that poll resolves instead. const log: string[] = []; /** The waker of the last poll that returned pending. */ -let parked: rt.Waker | undefined; +let parked: rs.Waker | undefined; /** A future that logs each poll and its drop, ready on poll `ready`, and runs `during` in each poll. */ -function logged(name: string, ready = Infinity, during?: () => void): rt.Future { +function logged(name: string, ready = Infinity, during?: () => void): rs.Future { let polls = 0; return { - poll(cx: rt.Context): rt.Poll { + poll(cx: rs.Context): rs.Poll { log.push(`${name} poll`); during?.(); if (++polls >= ready) return name; parked = cx.clone(); - return rt.Pending; + return rs.Pending; }, [Symbol.dispose](): void { log.push(`${name} drop`); @@ -57,7 +57,7 @@ function logged(name: string, ready = Infinity, during?: () => void): rt.Future< function outcome(promise: Promise): Promise { return promise.then( (value) => `resolved ${value}`, - (err: unknown) => (err instanceof rt.Panic ? `panic ${err.message}` : `rejected ${err}`), + (err: unknown) => (err instanceof rs.Panic ? `panic ${err.message}` : `rejected ${err}`), ); } @@ -67,12 +67,12 @@ async function expect(name: string, run: () => Promise, expected: string if (log.join("; ") !== expected.join("; ")) throw new Error(`${name}: ${log.join("; ")}, not ${expected.join("; ")}`); } -await expect("aborted before", async () => outcome(rt.spawn(logged("a"), AbortSignal.abort("early"))), ["a drop", "rejected early"]); +await expect("aborted before", async () => outcome(rs.spawn(logged("a"), AbortSignal.abort("early"))), ["a drop", "rejected early"]); await expect( "aborted before its first poll", async () => { const abort = new AbortController(); - const done = rt.spawn(logged("a"), abort.signal); + const done = rs.spawn(logged("a"), abort.signal); abort.abort("now"); log.push("aborted"); return outcome(done); @@ -83,7 +83,7 @@ await expect( "aborted while pending", async () => { const abort = new AbortController(); - const done = rt.spawn(logged("a"), abort.signal); + const done = rs.spawn(logged("a"), abort.signal); await Promise.resolve(); abort.abort("later"); log.push("aborted"); @@ -98,7 +98,7 @@ await expect( "aborted in its own poll", async () => { const abort = new AbortController(); - return outcome(rt.spawn(logged("a", Infinity, () => abort.abort("inside")), abort.signal)); + return outcome(rs.spawn(logged("a", Infinity, () => abort.abort("inside")), abort.signal)); }, ["a poll", "a drop", "rejected inside"], ); @@ -106,7 +106,7 @@ await expect( "aborted in the poll it is ready in", async () => { const abort = new AbortController(); - return outcome(rt.spawn(logged("a", 1, () => abort.abort("inside")), abort.signal)); + return outcome(rs.spawn(logged("a", 1, () => abort.abort("inside")), abort.signal)); }, ["a poll", "a drop", "resolved a"], ); @@ -114,7 +114,7 @@ await expect( "aborted after it returned", async () => { const abort = new AbortController(); - const done = await outcome(rt.spawn(logged("a", 1), abort.signal)); + const done = await outcome(rs.spawn(logged("a", 1), abort.signal)); abort.abort("late"); return done; }, @@ -125,7 +125,7 @@ await expect( async () => { const abort = new AbortController(); const future = logged("a"); - const done = rt.spawn({ poll: (cx) => future.poll(cx), [Symbol.dispose]: () => rt.panic("drop failed") }, abort.signal); + const done = rs.spawn({ poll: (cx) => future.poll(cx), [Symbol.dispose]: () => rs.panic("drop failed") }, abort.signal); abort.abort("now"); return outcome(done); },